code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;
using ll = long long;
#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const ll INF = 1e9;
const ll MOD = 1e9 + 7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int w, h;
int board[21][21];
int ans = INF;
bool valid(int y, int x) { return 0 <= y && y < h && 0 <= x && x < w; }
void print() {
rep(y, h) {
rep(x, w) printf("%d ", board[y][x]);
printf("\n");
}
}
void dfs(int y, int x, int cnt) {
// printf("debug: %d %d %d\n", y, x, cnt);
// print();
if (cnt == 10) return;
rep(k, 4) {
int ny = y;
int nx = x;
if (!valid(ny + dy[k], nx + dx[k])) continue;
if (board[ny + dy[k]][nx + dx[k]] == 1) continue;
while (1) {
if (!valid(ny + dy[k], nx + dx[k])) break;
ny += dy[k];
nx += dx[k];
if (board[ny][nx] == 3) {
ans = min(cnt + 1, ans);
return;
}
if (board[ny][nx] == 1) {
board[ny][nx] = 0;
dfs(ny - dy[k], nx - dx[k], cnt + 1);
board[ny][nx] = 1;
break;
}
}
}
}
int main() {
while (cin >> w >> h, w) {
ans = INF;
rep(i, h) rep(j, w) cin >> board[i][j];
rep(y, h) rep(x, w) if (board[y][x] == 2) dfs(y, x, 0);
if (ans == INF) ans = -1;
cout << ans << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int f[102][102];
bool dfs(int ys,int xs,int yg,int xg,int c){
if(f[ys][xs]!=c)return 0;
if(ys==yg && xs==xg)return 1;;
f[ys][xs]=0;
bool flag=0;
flag += dfs(ys+1,xs,yg,xg,c);
flag += dfs(ys-1,xs,yg,xg,c);
flag += dfs(ys,xs+1,yg,xg,c);
flag += dfs(ys,xs-1,yg,xg,c);
return flag;
}
void set(int c,bool d,int x,int y){
if(d==0){
for(int i=0; i<4; i++){
f[y][x+i]=c;
f[y+1][x+i]=c;
}
}else if(d==1){
for(int i=0; i<4; i++){
f[y+i][x]=c;
f[y+i][x+1]=c;
}
}
}
;
int main(){
while(1){
int w,h;
cin >> w >> h;
if(w==0 && h==0)break;
int xs,ys;
cin >> xs >> ys;
int xg,yg;
cin >> xg >> yg;
int n;
cin >> n;
for(int i=0; i<n; i++){
bool d;
int c,x,y;
cin >> c >> d >> x >> y;
set(c,d,x,y);
}
if(dfs(ys,xs,yg,xg,f[ys][xs])){
cout << "OK\n";
}else{
cout << "NG\n";
}
}
return 0;
}
| 0 |
#include <iostream>
#include <numeric>
#include <cmath>
#include <limits>
#include <stdio.h>
#include <iomanip>
#include <string> // string, to_string, stoi
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
using namespace std;
using ll = long long;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
ll Max(ll(a), ll(b), ll(c)) {
return max(max(a, b), c);
}
ll Min(ll(a), ll(b), ll(c)) {
return min(min(a, b), c);
}
ll kai(vector<ll> A, ll key) {
ll an = 0;
rep(i, A.size()) {
an += (A.at(i) - 1) / key;
}
return an;
}
// index が条件を満たすかどうか
bool isOK(int index,vector<ll> A, int K) {
if (kai(A,index) <= K) return true;
else return false;
}
// 汎用的な二分探索のテンプレ
int binary_search(ll MA,vector<ll> A,ll K) {
int left = 0; //「index = 0」が条件を満たすこともあるので、初期値は -1
int right = MA; // 「index = a.size()-1」が条件を満たさないこともあるので、初期値は a.size()
/* どんな二分探索でもここの書き方を変えずにできる！ */
while (right - left > 1) {
int mid = left + (right - left) / 2;
if (isOK(mid, A,K)) right = mid;
else left = mid;
}
/* left は条件を満たさない最大の値、right は条件を満たす最小の値になっている */
return right;
}
vector<ll> fact, factinv, inv;
ll mod = 1e9 + 7;
void prenCkModp(ll n) {
fact.resize(n + 5);
factinv.resize(n + 5);
inv.resize(n + 5);
fact.at(0) = fact.at(1) = 1;
factinv.at(0) = factinv.at(1) = 1;
inv.at(1) = 1;
for (ll i = 2; i < n + 5; i++) {
fact.at(i) = (fact.at(i - 1) * i) % mod;
inv.at(i) = mod - (inv.at(mod % i) * (mod / i)) % mod;
factinv.at(i) = (factinv.at(i - 1) * inv.at(i)) % mod;
}
}
ll nCk(ll n, ll k) {
return fact.at(n) * (factinv.at(k) * factinv.at(n - k) % mod) % mod;
}
ll HP[4];
int main() {
ll H, W, A, B,an=0;
cin >> H >> W >> A >> B;
prenCkModp(H + W);
for (ll i = 1; i <= H - A; i++) {
an += (nCk(i + B-2, i-1) * nCk(H - i + W - B-1, W - B-1)) % mod;
}
cout << an % mod << endl;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 3e5;
const LL MOD = 1e9+7;
inline LL dmod(LL x){
return x%MOD;
}
LL fakto[N+5];
void pre(){
fakto[0] = 1LL;
for(int i=1;i<=N;i++){
fakto[i] = dmod(fakto[i-1]*(LL)(i));
}
return;
}
LL fe(LL x, LL y){
if(y==0) return 1LL;
LL ret = fe(x,y/2);
ret = dmod(ret*ret);
if(y&1){
ret = dmod(ret*x);
}
return ret;
}
LL nCr(LL x, LL y){
LL tmp = dmod(fakto[y]*fakto[x-y]);
tmp = fe(tmp,MOD-2);
tmp = dmod(tmp*fakto[x]);
return tmp;
}
LL step(int x, int y, int a, int b){
int dx = a-x;
int dy = b-y;
int tot = dx+dy;
return nCr(tot,dx);
}
int h,w,a,b;
int main(){
pre();
cin >> h >> w >> a >> b;
LL ret = 0LL;
for(int i=1;i<=h-a;i++){
LL tmp = step(1,1,i,b);
tmp = dmod(tmp*step(i,b+1,h,w));
ret = dmod(ret+tmp);
}
cout << ret << endl;
return 0;
} | 1 |
#include <stdio.h>
#include <algorithm>
int m = 0;
int count = 0;
int G[1000000];
void trace(int a[], int size) {
for (int i = 0; i < size; ++i) {
if (i > 0) {
printf(" ");
}
printf("%d", a[i]);
}
printf("\n");
}
void InsertionSort(int A[], int N, int g) {
for (int i = g; i < N; ++i) {
int key = A[i];
int j = i - g;
while (j >= 0 && A[j] > key) {
A[j+g] = A[j];
j = j - g;
count++;
}
A[j + g] = key;
}
}
void ShellSort(int A[], int N) {
int g = 0;
while(true) {
g = 3 * g + 1;
if (g > N) { break; }
G[m] = g;
++m;
}
for (int i = m - 1; i >= 0; --i) {
InsertionSort(A, N, G[i]);
}
}
int main() {
int N;
int A[1000000];
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
}
ShellSort(A, N);
printf("%d\n", m);
for (int i = m - 1; i >= 0; --i) {
printf("%d", G[i]);
if (i > 0) printf(" ");
}
printf("\n");
printf("%d\n", count);
for (int i = 0; i < N; i++) {
printf("%d\n", A[i]);
}
return 0;
} | #include<iostream>
using namespace std;
int InsertionSort(int* a, int n, int g)
{
int tmp, j, count = 0;
for (int i = g; i < n; i++)
{
tmp = a[i];
for (j = i - g; j >= 0 && a[j] > tmp; j -= g)
{
a[j + g] = a[j];
count++;
}
a[j + g] = tmp;
}
return count;
}
int ShellSort(int* a, int n)
{
int m, g[100],count = 0;
for (m = 1; m * m * m <= n; m++)
continue;
m--;
cout << m << endl;
for (int i = 0; i < m; i++)
{
g[i] = (m - i) * (m - i);
if (i)
cout << " ";
cout << g[i];
}
for (int i = 0; i < m; i++)
count += InsertionSort(a, n, g[i]);
return count;
}
int main()
{
int n, a[1000000], count;
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
count = ShellSort(a, n);
cout << endl << count << endl;
for (int i = 0; i < n; i++)
cout << a[i] << endl;
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main(){
while(true){
int e;
cin >> e;
if(e == 0) break;
int m;
m = e;
for(int z = 0 ; z * z * z <= e ; z++){
for(int y = 0 ; y * y + z * z * z <= e ; y++){
int x = e - z * z * z - y * y;
if(m > x + y + z) m = x + y + z;
}
}
cout << m << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
bool is_prime(int n){
if(n == 2 || n == 3) return true;
if(n % 6 != 1 && n % 6 != 5) return false;
for(int i = 2; i * i <= n; i++){
if(n % i == 0) return false;
}
return true;
}
int main(){
vector<int> P;
for(int i = 3; i < 10000; i+=2){
if(is_prime(i)) P.push_back(i);
}
long long A[1010][1010] = {};
for(int i = 0; i <= 500; i++){
for(int j = 0; j <= 500; j++){
A[i*2][j*2] = P[i] * P[501+j];
}
}
for(int i = 0; i <= 499; i++){
for(int j = 0; j <= 499; j++){
A[i*2+1][j*2+1] = A[i*2][j*2] * A[i*2+2][j*2+2] + 1;
}
}
long long ans[510][510] = {};
for(int i = 0; i < 500; i++){
for(int j = 0; j < 500; j++){
ans[i][j] = A[500-i+j][i+j];
}
}
int N; cin >> N;
for(int i = 0; i < N; i++){
for(int j = 0; j < N; j++){
cout << ans[i][j] << " ";
}
cout << endl;
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
using P = pair<int,int>;
#define rep(i,n) for(int i=0; i<(int)n; i++)
bool isBigger(P a, P b){
// return a > b
return (a.first > b.first) && (a.second > b.second);
}
int main(){
int N;
cin >> N;
vector<P> A(N);
vector<P> B(N);
rep(i,N){
cin >> A.at(i).first;
cin >> A.at(i).second;
}
rep(i,N){
cin >> B.at(i).first;
cin >> B.at(i).second;
}
sort(A.begin(), A.end(), [](P left, P right)->bool{if(left.second == right.second)return left.first > right.first;
else return left.second > right.second;});
sort(B.begin(), B.end(), [](P left, P right)->bool{if(left.first == right.first)return left.second < right.second;
else return left.first < right.first;});
// cout << "A:" << endl;
// for(P p : A)cout << p.first << " " << p.second << endl;
// cout << "B:" << endl;
// for(P p : B)cout << p.first << " " << p.second << endl;
int res = 0;
vector<bool> usedA(N,false);
rep(i,N){
P b = B.at(i);
rep(j,N){
if(usedA.at(j))continue;
P a = A.at(j);
if(isBigger(b,a)){
// printf("make pair: a(%d, %d)\tb(%d, %d)\n", a.first, a.second, b.first, b.second);
usedA.at(j) = true;
res++;
break;
}
}
}
cout << res << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
int num;
while(cin>>num){
char str;
int hand[14]={};
hand[num]++;
for(int i=0;i<4;i++){
cin>>str>>num;
hand[num]++;
}
bool four=0,three=0,two[2]={};
for(int i=1,j=0;i<14;i++){
if(hand[i]==4)four=1;
else if(hand[i]==3)three=1;
else if(hand[i]==2){
two[j]=1;
j++;
}
}
if(four)cout<<"four card"<<endl;
else if(three&&two[0])cout<<"full house"<<endl;
else if(three)cout<<"three card"<<endl;
else if(two[1])cout<<"two pair"<<endl;
else if(two[0])cout<<"one pair"<<endl;
else{
bool kawa=0;
for(int i=1;i<=10;i++){
if(hand[i]==1){
for(int j=0;j<5;j++){
if(j+i>13&&hand[1]!=1)break;
else if(j+i<14&&hand[i+j]!=1)break;
if(j==4)kawa=1;
}
}
}
if(kawa)cout<<"straight"<<endl;
else cout<<"null"<<endl;
}
}
} | 0 |
#include <bits/stdc++.h>
#include <boost/range/adaptors.hpp>
#include <boost/range/irange.hpp>
using namespace std;
using namespace boost;
using namespace boost::adaptors;
int main() {
string s;
cin >> s;
transform(s.begin(), s.end(), s.begin(), [](char c) { return c - '0'; });
int64_t n = s.size();
vector<vector<int64_t>> dp(2, vector<int64_t>(n + 1));
dp[0][0] = 0;
dp[1][0] = 1;
for (auto i : irange(0L, n)) {
dp[0][i + 1] = min(dp[0][i] + s[i], dp[1][i] + (10 - s[i]));
dp[1][i + 1] = min({dp[0][i] + s[i] + 1, dp[1][i] + (10 - s[i] - 1)});
}
cout << dp[0][n] << endl;
} | #include <cstdio>
#include <cstdlib>
#include <cassert>
#include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define repi(i,a,b) for(ll i=(a);i<(b);++i)
#define rep(i,a) repi(i,0,a)
#define repdi(i,a,b) for(ll i=(a)-1;i>=(b);--i)
#define repd(i,a) repdi(i,a,0)
#define itr(it,a) for( auto it = (a).begin(); it != (a).end(); ++it )
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define endl '\n'
#define debug(x) std::cerr << #x << " = " << (x) << endl;
using ll = long long;
using P = std::pair<ll, ll>;
constexpr ll INF = 1ll<<60;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class S, class T>
std::ostream& operator<< ( std::ostream& out, const std::pair<S,T>& a )
{ std::cout << '(' << a.first << ", " << a.second << ')'; return out; }
template<class T>
std::ostream &operator<< ( std::ostream& out, const std::vector<T>& a )
{ std::cout << '['; rep( i, a.size() ){ std::cout << a[i]; if( i != a.size()-1 ) std::cout << ", "; } std::cout << ']'; return out; }
template<typename T>
class BinaryIndexedTree2D {
int H;
int W;
std::vector<std::vector<T> > data2d;
public:
BinaryIndexedTree2D(int H, int W) : H(H), W(W) {
data2d.resize(H + 1, std::vector<T>(W + 1, 0));
}
T sum(int h, int w) {
T res = 0;
for (int i = h; i > 0; i -= i & -i) {
for (int j = w; j > 0; j -= j & -j) {
res += data2d[i][j];
}
}
return res;
}
/**
* 左上の座標(h1, w1), 右下の座標(h2, w2) に含まれる値の累積和
*/
T sum(int h1, int w1, int h2, int w2) {
return sum(h2, w2) - sum(h1 - 1, w2) - sum(h2, w1 - 1) + sum(h1 - 1, w1 - 1);
}
void add(int h, int w, ll x) {
for (int i = h; i <= H; i += i & -i) {
for (int j = w; j <= W; j += j & -j) {
data2d[i][j] += x;
}
}
}
};
ll N;
BinaryIndexedTree2D<ll> bit( 100, 100 );
constexpr ll base = 20;
int main() {
std::cin >> N;
ll ans = 0;
rep( i, N ) {
std::string A;
std::cin >> A;
bool fst = true;
ll p = A.size();
ll ten = 1;
ll s = 0, num = 0;
if( A.find('.') != std::string::npos ) repd( i, A.size() ) {
if( A[i] != '0' ) {
if( fst ) {
p = i;
}
fst = false;
}
if( !fst && A[i] != '.' ) {
num += (A[i]-'0')*ten;
ten *= 10;
}
if( A[i] == '.' ) {
s = p-i;
}
} else {
rep( i, A.size() ) {
num *= 10;
num += A[i]-'0';
}
s = 0;
}
//std::cout << P(num, s) << endl;
ll two = 0, five = 0;
while( num % 2 == 0 ) {
num /= 2;
++two;
}
while( num % 5 == 0 ) {
num /= 5;
++five;
}
//std::cout << P(two-s, five-s) << endl;
ans += bit.sum( -(two-s)+base, -(five-s)+base, 98, 98 );
//std::cout << "sum: " << P(-(two-s)+base, -(five-s)+base) << endl;
bit.add( two-s+base, five-s+base, 1 );
//std::cout << "added: " << P(two-s+base, five-s+base) << endl;
}
std::cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h,w;
cin >> h >> w;
vector<vector<char>> s(h+2,vector<char> (w+2,'.'));
for ( int i = 1; i < h+1; i++){
for ( int j = 1; j < w+1; j++){
cin >> s[i][j];
}
}
for ( int i = 1; i < h+1; i++){
for ( int j = 1; j < w+1; j++){
if ( s[i][j] == '#' ){
if ( s[i-1][j] == '#' ||
s[i][j-1] == '#' ||
s[i][j+1] == '#' ||
s[i+1][j] == '#' ){
continue;
}else{
cout << "No" << endl;
return 0;
}
}
}
}
cout << "Yes" << endl;
} |
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0); std::cout.tie(0);
std::string s;
std::getline(std::cin, s);
std::vector<bool> dict(26, false);
for (char c : s)
dict[c - 'a'] = true;
std::string r = "None";
for (std::size_t i = 0; i < dict.size(); ++i) {
if (!dict[i]) {
r = i + 'a';
break;
}
}
std::cout << r << std::endl;
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(void)
{
int n1 , n2;
vector<int> val1 , val2 , ans;
int input;
cin >> n1 >> n2;
for (int i = 0; i < n1; i++)
{
cin >> input;
val1.push_back(input);
ans.push_back(0);
}
for (int i = 0; i < n2; i++)
{
cin >> input;
val2.push_back(input);
}
for (int i = 0; i < n2; i++)
{
for (int j = 0; j < n1; j++)
{
if (val2[i] >= val1[j])
{
ans[j]++;
break;
}
}
}
int Max = -100;
int index = -1;
for (int i = 0; i < ans.size(); i++)
{
if (ans[i] > Max)
{
Max = ans[i];
index = i;
}
}
cout << index + 1 << endl;
return 0;
} | #include <iostream>
#include <vector>
#include <string>
using namespace std;
int main(){
string S; cin >> S;
const int N = S.size();
int K; cin >> K;
int res = 0;
vector<vector<vector<int>>> dp(K+1, vector<vector<int>>(N, vector<int>(N, 0)));
for(int d=N-1;d>=0;d--){
for(int i=0;i+d<N;i++){
int j = i+d;
for(int k=0;k<=K;k++){
if(k < K && S[i] != S[j]){
res = max(res, dp[k][i][j] + 2);
if(i+1 < N && j > 0){
dp[k+1][i+1][j-1] = max(dp[k+1][i+1][j-1], dp[k][i][j] + 2);
}
}
if(S[i] == S[j]){
res = max(res, dp[k][i][j] + (i==j ? 1 : 2));
if(i+1 < N && j > 0){
dp[k][i+1][j-1] = max(dp[k][i+1][j-1], dp[k][i][j] + (i==j ? 1 : 2));
}
}
if(i+1 < N) dp[k][i+1][j] = max(dp[k][i+1][j], dp[k][i][j]);
if(j > 0) dp[k][i][j-1] = max(dp[k][i][j-1], dp[k][i][j]);
}
}
}
cout << res << endl;
} | 0 |
/*program from Wolfycz*/
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define inf 0x7f7f7f7f
using namespace std;
typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
inline char gc(){
static char buf[1000000],*p1=buf,*p2=buf;
return p1==p2&&(p2=(p1=buf)+fread(buf,1,1000000,stdin),p1==p2)?EOF:*p1++;
}
inline int frd(){
int x=0,f=1; char ch=gc();
for (;ch<'0'||ch>'9';ch=gc()) if (ch=='-') f=-1;
for (;ch>='0'&&ch<='9';ch=gc()) x=(x<<3)+(x<<1)+ch-'0';
return x*f;
}
inline int read(){
int x=0,f=1; char ch=getchar();
for (;ch<'0'||ch>'9';ch=getchar()) if (ch=='-') f=-1;
for (;ch>='0'&&ch<='9';ch=getchar()) x=(x<<3)+(x<<1)+ch-'0';
return x*f;
}
inline void print(int x){
if (x<0) putchar('-'),x=-x;
if (x>9) print(x/10);
putchar(x%10+'0');
}
const int N=1e2;
int A[N+10];
int main(){
int n=read(),m=read(),cnt=0;
for (int i=1;i<=m;i++) A[i]=read(),cnt+=A[i]&1;
if (cnt>2){
printf("Impossible\n");
return 0;
}
for (int i=1;i<=m;i++) if (A[i]&1) swap(A[1]&1?A[m]:A[1],A[i]);
if (m==1){
if (A[1]==1){
printf("1\n1\n1\n");
return 0;
}
printf("%d\n2\n1 %d\n",A[1],A[1]-1);
return 0;
}
for (int i=1;i<=m;i++) printf("%d",A[i]),putchar(i==m?'\n':' ');
printf("%d\n%d ",m-(A[m]==1),A[1]+1);
for (int i=2;i<m;i++) printf("%d ",A[i]);
if (A[m]!=1) printf("%d\n",A[m]-1);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int cnt = 0, s1 = -1, s2 = -1;
vector<int> a(m);
for ( int i = 0; i < m; ++ i) {
cin >> a[i];
if( a[i] & 1) {
++ cnt;
if( cnt == 1) {
s1 = i;
} else {
s2 = i;
}
}
}
if( cnt >= 3) {
cout << "Impossible\n";
} else {
if( m == 1) {
cout << a[0] << "\n";
cout << 1 + (n != 1) << "\n" << 1;
if( n != 1) {
cout << " " << n-1 << "\n";
}
} else {
if( ~ s1) {
swap(a[s1], a[0]);
}
if( ~ s2) {
swap(a[s2], a[m-1]);
}
for ( auto v : a) {
cout << v << " ";
}
a[0] ++; a[m-1] --;
if( !a[m-1]) {
a.pop_back();
}
cout << "\n" << a.size() << "\n";
for ( auto v : a) {
cout << v << " ";
}
}
}
return 0;
} | 1 |
#include<stdio.h>
#include<string.h>
#include<math.h>
int main(void)
{
long long int g[1001],s[1001],d[1001],f[1001];
int j,i,k,a,h[1001];
while(1){
scanf("%d",&a);
if(a==0) break;
for(i=0;i<a;i++){
h[i]=0;
g[i]=0;
}
for(i=0;i<a;i++){
scanf("%lld %lld %lld",&s[i],&d[i],&f[i]);
if(d[i]*f[i]>=1000000) h[i]=1;
/*if(d[i]==1000000&&f[i]>=1) h[i]=1;
if(f[i]==100000&&d[i]>=10) h[i]=1;*/
if(h[i]==0) g[i]=d[i]*f[i];
else g[i]=0;
}
for(i=0;i<a;i++){
for(j=i+1;j<a;j++){
if(g[i]>=1000000&&h[i]==0){
h[i]=1;
}
if(s[i]==s[j]){
if(h[i]==0){
g[i]+=g[j];
g[j]=0;
}
else g[j]=0;
}
if(g[i]>=1000000&&h[i]==0){
h[i]=1;
}
}
}
k=0;
for(i=0;i<a;i++){
if(h[i]==1){
printf("%lld\n",s[i]);
k=1;
}
}
if(k==0) printf("NA\n");
}
return 0;
} | #include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
int main(){
int N;
while(cin>>N,N){
vector<int> vi(N*N,0),vi2(N*2+1,0);
for(int i=0;i<N;i++){
int sum=0;
for(int j=0;j<N;j++){
int num;
cin>>num;
vi[i*N+j]=num;
sum+=num;
}
vi2[i]=sum;
}
for(int i=0;i<N;i++){
int sum=0;
for(int j=0;j<N;j++){
sum+=vi[i+j*N];
printf("%5d",vi[i*N+j]);
}
printf("%5d\n",vi2[i]);
vi2[N*2]+=vi2[i];
vi2[N+i]=sum;
}
for(int i=0;i<=N;i++){
printf("%5d",vi2[N+i]);
}
cout<<endl;
}
return 0;
} | 0 |
#define LOCAL
#ifdef LOCAL
#define _GLIBCXX_DEBUG
#endif
#include <bits/stdc++.h>
using namespace std;
#define rep(i,s,n) for (int i = (ll)s; i < (ll)n; i++)
#define rrep(i,n,e) for (int i = (ll)n; i > (ll)e; i--)
#define ll long long
#define ld long double
#define pb push_back
#define eb emplace_back
#define All(x) x.begin(), x.end()
#define Range(x, i, j) x.begin() + i, x.begin() + j
#define lbidx(x, y) lower_bound(x.begin(), x.end(), y) - x.begin()
#define ubidx(x, y) upper_bound(x.begin(), x.end(), y) - x.begin()
#define llbidx(x, y, z) lower_bound(x.begin(), x.end(), z) - lower_bound(x.begin(), x.end(), y) // dist between two elements
// #define M_PI 3.14159265358979323846 // CF
#define deg2rad(deg) ((((double)deg)/((double)360)*2*M_PI))
#define rad2deg(rad) ((((double)rad)/(double)2/M_PI)*(double)360)
#define Find(set, element) set.find(element) != set.end()
#define Decimal(x) cout << fixed << setprecision(10) << x << endl; // 小数点を10桁まで表示
#define endl "\n"
#define Case(x) printf("Case #%d: ", x); // gcj
typedef pair<int, int> PI;
typedef pair<ll, ll> PLL;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<vector<vector<int>>> vvvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<vector<vector<ll>>> vvvl;
typedef vector<PI> vpi;
typedef vector<vector<PI>> vvpi;
typedef vector<PLL> vpl;
typedef vector<vector<PLL>> vvpl;
typedef vector<char> vch;
typedef vector<vector<char>> vvch;
constexpr ll LINF = 1001002003004005006ll;
constexpr int INF = 1001001001;
constexpr int n_max = 2e5+10;
template<class T>
inline bool chmax(T &a, T b) { if(a<b) { a=b; return true; } return false; };
template<class T>
inline bool chmin(T &a, T b) { if(a>b) { a=b; return true; } return false; };
template<class T, class U>
T POW(T x, U n) {T ret=1; while (n>0) {if (n&1) {ret*=x;} x*=x; n>>=1;} return ret;};
// debug
template <typename A, typename B>
string to_string(pair<A, B> p);
string to_string(const string &s) {return '"' + s + '"';};
string to_string(const char c) {return to_string((string) &c);};
string to_string(bool b) {return (b ? "true" : "false");};
template <size_t N>
string to_string(bitset<N> v){
string res = "";
for(size_t i = 0; i < N; i++) res += static_cast<char>('0' + v[i]);
return res;
};
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for(const auto &x : v) {
if(!first) res += ", ";
first = false; res += to_string(x);
}
res += "}";
return res;
};
template <typename A, typename B>
string to_string(pair<A, B> p){return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
void debug_out() {cerr << endl;};
template<typename Head, typename... Tail>
void debug_out(Head H, Tail... T) { cerr << " " << to_string(H); debug_out(T...); };
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 71
#endif
void print() { cout << endl; }
template <class Head, class... Tail>
void print(Head&& head, Tail&&... tail) {
cout << head;
if (sizeof...(tail) != 0) cout << " ";
print(forward<Tail>(tail)...);
};
template <class T>
void print(vector<T> &vec) {
for (auto& a : vec) {
cout << a;
if (&a != &vec.back()) cout << " ";
}
cout << endl;
};
template <class T>
void print(vector<vector<T>> &df) {
for (auto& vec : df) {
print(vec);
}
};
PI solve(string &s) {
int n = s.size();
vvi table(26);
rep(i, 0, 26) {
char ch = 'a'+i;
rep(j, 0, n) {
if (s[j] == ch) table[i].pb(j);
}
}
rep(i, 0, 26) {
rep(j, 0, table[i].size()-1) {
if (table[i][j+1]-table[i][j] < 3) {
return make_pair(table[i][j]+1,table[i][j+1]+1);
}
}
}
return make_pair(-1, -1);
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s; cin >> s;
PI ans = solve(s);
cout << ans.first << " " << ans.second << endl;
return 0;
};
| #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <random>
using namespace std;
using namespace __gnu_pbds;
typedef
tree<pair<int, int>, null_type, less<pair<int, int>>, rb_tree_tag, tree_order_statistics_node_update> orderedSet;
#define pb push_back
#define F first
#define S second
#define all(a) (a).begin(), (a).end()
#define for1(i0, l0, r0) for (int i0 = l0; i0 < r0; ++i0)
#define for2(i0, l0, r0) for (int i0 = l0; i0 <= r0; ++i0)
#define forn(i0, n0) for (int i0 = 0; i0 < n0; ++i0)
#define forn1(i0, n0) for (int i0 = 1; i0 < n0; ++i0)
#define forr(i0, n0) for (int i0 = n0; i0 >= 0; --i0)
#define forr1(i0, r0, l0) for (int i0 = r0; i0 > l0; --i0)
#define forr2(i0, r0, l0) for (int i0 = r0; i0 >= l0; --i0)
#define Sort(a) sort(all(a))
#define Reverse(a) reverse(all(a))
#define relaxMax(a, b) a = max(a, b)
#define relaxMin(a, b) a = min(a, b)
typedef long long ll;
typedef long double ld;
#define ui unsigned int
#define ull unsigned long long
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef pair<string, string> pss;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<double> vd;
typedef vector<ld> vld;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<pdd> vpdd;
typedef vector<vi> vvi;
typedef vector<vd> vvd;
typedef vector<vll> vvll;
typedef vector<vb> vvb;
#define vpss vector<pss>
#define vvs vector<vs>
#define vvpii vector<vpii>
#define vvpll vector<vpll>
#define vpt vector<pt>
#define vvvi vector<vvi>
#define vsi vector<set<int>>
#define ss second
#define ff first
#define printvi(arr) for (int x0 : arr) cout << x0 << ' '; cout << '\n';
#define printvll(arr) for (ll x0 : arr) cout << x0 << ' '; cout << '\n';
#define printpair(pair0) cout << pair0.F << ' ' << pair0.S << '\n';
#define printvp(arr) for (auto pair0 : arr) printpair(pair0);
#define initArray(arr, N0, X0) memset(arr, X0, N0 * sizeof(int))
//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void init() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
//cout.precision(16);
//freopen("amusing.in", "r", stdin);
//freopen("amusing.out", "w", stdout);
}
void solve() {
string s;
cin >> s;
int n = s.length();
forn(i, n - 1){
if (s[i] == s[i + 1]){
cout << i + 1 << ' ' << i + 2 << '\n';
return;
}
}
forn(i, n - 2){
if (s[i] == s[i + 2]){
cout << i + 1 << ' ' << i + 3 << '\n';
return;
}
}
cout << "-1 -1\n";
}
bool multitest = false;
int main() {
init();
int t = 1;
if (multitest) cin >> t;
forn(i, t) solve();
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
#define rep(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
ll n, m;
struct numinfo {
int digit;
int match;
int min_match;
int n;
};
vector<numinfo> nums;
bool dfs( int i, int remain_match, int remain_keta ){
if ( i == SZ(nums) ){
eprintf( "remain=%d %d ", remain_match, remain_keta );
rep(k,SZ(nums)){
eprintf( "%d ", (int)nums[k].n );
}
eprintf( "\n" );
if ( remain_match == 0 && remain_keta <= 0 )
return true;
return false;
}
for ( int k = remain_match/nums[i].match; k >= 0; k-- ){
nums[i].n = k;
int creatable_keta = (remain_match-k*nums[i].match)/nums[i].min_match;
if ( remain_keta-k-creatable_keta > 0 )
continue;
if ( dfs( i+1, remain_match-k*nums[i].match, remain_keta-k ) )
return true;
}
return false;
}
int main(){
cin >> n >> m;
vector<int> a(m);
rep(i,m){
cin >> a[i];
}
sort(a.rbegin(),a.rend());
int digit_to_match[] = { 0, 2, 5, 5, 4, 5, 6, 3, 7, 6 };
set<int> s;
rep(i,m){
int match = digit_to_match[a[i]];
if ( s.count(match) == 0 )
nums.push_back({a[i],match,100,0});
s.insert(match);
}
m = nums.size();
int min_match = 100;
for ( int i = nums.size()-1; i >= 0; i-- ){
nums[i].min_match = min_match;
chmin(min_match, nums[i].match);
eprintf( "digit,=%d match=%d min_match=%d\n", nums[i].digit, nums[i].match, nums[i].min_match );
}
for ( int keta = n / min_match; keta > 0; keta-- ){
eprintf( "\n\nketa=%d\n", keta );
if ( dfs( 0, n, keta ) ){
sort(nums.begin(), nums.end(), [](numinfo &l, numinfo &r){
return l.digit>r.digit;
});
rep(i,m){
rep(j,nums[i].n){
cout << nums[i].digit;
}
}
cout << endl;
return 0;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int cost[] = {0,2,5,5,4,5,6,3,7,6};
bool d[10] = {};
int main() {
int n, m;
cin >> n >> m;
for (int i=0; i<m; i++) {
int a;
cin >> a;
d[a] = 1;
}
vector<string> dp(n+1, "");
for (int j=0; j<=n; j++) {
for (int i=1; i<10; i++) {
if ( !d[i] ) continue;
if ( j+cost[i]>n ) continue;
if ( j && dp[j]=="" ) continue;
string s=dp[j]+(char)(i+'0');
if ( s.length()==dp[j+cost[i]].length() ) {
dp[j+cost[i]]=max(s, dp[j+cost[i]]);
} else if ( s.length()>dp[j+cost[i]].length() ) {
dp[j+cost[i]]=s;
}
}
}
cout << dp[n] << '\n';
return 0;
} | 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout <<(#x)<<" is "<<(x)<<endl
#define debug cout <<"hi"<<endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
const int MOD=1e9+7;
const int INF32=1<<30;
const ll INF64=1LL<<60;
void solve(){
int n; cin >>n;
ll a[n],cnt=0,sum=0,mn=MOD;
for(int i=0; i<n; i++){
ll x; cin >>x; a[i]=x;
if(x<=0) cnt++;
mn=min(mn,abs(x));
sum+=abs(x);
}
if(cnt%2) sum-=2*mn;
cout <<sum;
}
int main(){
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
solve();
return 0;} | #include <iostream>
using namespace std;
typedef long long int LLI;
int main()
{
int n;
LLI a, b, x, diff, sum = 0 ;
cin >> n >> x;
cin >> a >> b;
if( a + b > x )
{
diff = a + b - x;
if( diff <= b )
b -= diff;
else
b = 0;
sum += diff;
}
a = b;
for(int i = 2; i < n; i++)
{
cin >> b;
if( a + b > x )
{
diff = a + b - x;
if( diff <= b )
b -= diff;
else
b = 0;
sum += diff;
}
a = b;
}
cout << sum;
}
| 0 |
#include<iostream>
#include<cstdlib>
#include<queue>
#define MAX 22
#define BLOCK 1
#define START 2
#define GOAL 3
#define REP(i,a,e) for(int i=(a);i<=(e);++i)
#define REPD(i,a,e) for(int i=(a);i>=(e);--i)
using namespace std;
struct Map{
Map(){
REP(i,0,MAX-1)REP(j,0,MAX-1)map[i][j]=0;
}
int h,w;
char map[MAX][MAX];
int depth;
pair<int, int> stone;
};
int BFS(Map &m){
queue<Map> q;
q.push( m );
while( !q.empty() ){
Map t = q.front();
q.pop();
/* up */
REPD(i,t.stone.first,0){
if( t.map[i][ t.stone.second ] == BLOCK ){
if( abs(i-t.stone.first) > 1 ){
Map tt = t;
tt.map[ i ][ t.stone.second ] = 0;
tt.stone = make_pair( i + 1, t.stone.second );
if( ++tt.depth < 10 )
q.push( tt );
}
break;
}else if( t.map[i][ t.stone.second ] == GOAL ){
return t.depth+1;
}
}
/* down */
REP(i,t.stone.first,t.h+1){
if( t.map[i][ t.stone.second ] == BLOCK ){
if( abs(i-t.stone.first) > 1 ){
Map tt = t;
tt.map[ i ][ t.stone.second ] = 0;
tt.stone = make_pair( i - 1, t.stone.second );
if( ++tt.depth < 10 )
q.push( tt );
}
break;
}else if( t.map[i][ t.stone.second ] == GOAL ){
return t.depth+1;
}
}
/* right */
REP(j,t.stone.second,t.w+1){
if( t.map[ t.stone.first ][ j ] == BLOCK ){
if( abs(j-t.stone.second) > 1 ){
Map tt = t;
tt.map[ t.stone.first ][ j ] = 0;
tt.stone = make_pair( t.stone.first, j - 1 );
if( ++tt.depth < 10 )
q.push( tt );
}
break;
}else if( t.map[ t.stone.first ][ j ] == GOAL ){
return t.depth+1;
}
}
/* left */
REPD(j,t.stone.second,0){
if( t.map[ t.stone.first ][ j ] == BLOCK ){
if( abs(j-t.stone.second) > 1 ){
Map tt = t;
tt.map[ t.stone.first ][ j ] = 0;
tt.stone = make_pair( t.stone.first, j + 1 );
if( ++tt.depth < 10 )
q.push( tt );
}
break;
}else if( t.map[ t.stone.first ][ j ] == GOAL ){
return t.depth+1;
}
}
}
return -1;
}
int main(){
while(true){
Map m;
scanf("%d%d", &m.w, &m.h);
if( m.w==0 && m.h==0 )break;
REP(i,1,m.h)REP(j,1,m.w){
scanf("%d", &m.map[i][j]);
if( m.map[i][j] == START ){
m.stone=make_pair(i,j);
}
}
m.depth = 0;
printf("%d\n", BFS( m ));
}
} | #include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
const int INF = 1 << 30;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, -1, 0, 1};
int w, h, field[20][20];
int solve(int x, int y, int t)
{
if (t > 9)
return INF;
int ans = INF;
for (int i = 0; i < 4; ++i) {
int xx = x + dx[i];
int yy = y + dy[i];
if (xx < 0 || xx >= w || yy < 0 || yy >= h || field[yy][xx] == 1)
continue;
bool infield = true;
while (field[yy][xx] == 0) {
xx += dx[i];
yy += dy[i];
if (xx < 0 || xx >= w || yy < 0 || yy >= h) {
infield = false;
break;
}
}
if (!infield)
continue;
if (field[yy][xx] == 3)
return t+1;
if (field[yy][xx] == 1) {
field[yy][xx] = 0;
ans = min(ans, solve(xx-dx[i], yy-dy[i], t+1));
field[yy][xx] = 1;
}
}
return ans;
}
int main()
{
while (scanf("%d %d", &w, &h) != EOF) {
if (w == 0 && h == 0)
break;
int x, y;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
scanf("%d", &field[i][j]);
if (field[i][j] == 2) {
x = j;
y = i;
field[i][j] = 0;
}
}
}
int ans = solve(x, y, 0);
if (ans == INF)
ans = -1;
printf("%d\n", ans);
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
const int MAX = 2000000;
const int MOD = 998244353;
Int fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
Int COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main()
{
COMinit();
int N, M; cin >> N >> M;
Int a = 0, b = 0, c = 0;
for (int o = M % 2; o <= M; o += 2) {
int t = (3 * M - o) / 2;
a += COM(t + N - 1, N - 1) * COM(N, o);
a %= MOD;
}
for (int o = M % 2; o <= M; o += 2) {
int t = (3 * M - o) / 2;
b += N * COM((t - M) + N - 1, N - 1) % MOD * COM(N - 1, o - 1);
b %= MOD;
}
for (int o = M % 2; o <= M; o += 2) {
int t = (3 * M - o) / 2;
c += N * COM((t - M - 1) + N - 1, N - 1) % MOD * COM(N - 1, o);
c %= MOD;
}
cout << (a + MOD - b + MOD - c) % MOD << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 10;
const int mod = 998244353;
typedef long long ll;
#define int long long
int fac[maxn], inv[maxn];
int n, m;
int pw(int a, int n) {
int res = 1;
while(n) {
if(n & 1) res = (ll)res * a % mod;
a = (ll)a * a % mod, n >>= 1;
}
return res;
}
int INV(int a) {
return pw(a, mod - 2);
}
void pre() {
fac[0] = 1;
for(int i = 1; i < maxn; i++) fac[i] = (ll)fac[i - 1] * i % mod;
inv[maxn - 1] = INV(fac[maxn - 1]);
for(int i = maxn - 2; i >= 0; i--) inv[i] = (ll)inv[i + 1] * (i + 1) % mod;
}
int C(int n, int m) {
return (ll)fac[n] * inv[m] % mod * (ll)inv[n - m] % mod;
}
int H(int n, int m) {
return C(n + m - 1, m);
}
void add(int& a, int b) {
a += b;
if(a >= mod) a -= mod;
}
void sub(int& a, int b) {
a -= b;
if(a < 0) a += mod;
}
int32_t main() {
pre();
scanf("%lld%lld", &n, &m);
int ans = 0;
for(int i = 0; i <= min(n, m); i++) if((3 * m - i) % 2 == 0) {
add(ans, C(n, i) * H(n, (3 * m - i) / 2) % mod);
}
int tmp = 0;
for(int i = 0; i <= min(n, m); i++) if((m - i) % 2 == 0) {
add(tmp, C(n, i) * H(n, (m - i) / 2) % mod);
}
for(int i = 0; i <= min(n - 1, m); i++) if((m - i) % 2 == 0) {
sub(tmp, C(n - 1, i) * H(n - 1, (m - i) / 2) % mod);
}
tmp = (ll)tmp * n % mod;
sub(ans, tmp);
printf("%lld\n", ans);
return 0;
}
| 1 |
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <bitset> //UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <iomanip> //do setprecision
#include <ctime>
#include <complex>
#include <chrono>
#include<unordered_map>
using namespace std;
#define FOR(i,b,e) for(int i=(b);i<(e);++i)
#define FORQ(i,b,e) for(int i=(b);i<=(e);++i)
#define FORD(i,b,e) for(int i=(b)-1;i>=(e);--i)
#define REP(x, n) for(int x = 0; x < (n); ++x)
#define ALL(u) (u).begin(),(u).end()
#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef tuple<int, int, int> TIII;
typedef vector<int> VI;
const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int MN = 1e9;
int main()
{
fast_io();
map<PII, int> M;
int N;
scanf("%d", &N);
REP(i, N)
{
double A;
scanf("%lf", &A);
LL llA = llround(A * MN);
// wylicz ile zawieraja 2 i 5
int x = 0, y = 0;
while (llA % 2 == 0)
{
x++;
llA /= 2;
}
while (llA % 5 == 0)
{
y++;
llA /= 5;
}
x = min(x, 18), y = min(y, 18);
M[MP(x, y)]++;
}
LL res = 0;
// zobacz ile jest par, ktore maja sume x >= 0 i sume y >= 0
for (const auto &p : M)
{
if (p.first.first >= 9 && p.first.second >= 9)
res += p.second*(LL)(p.second - 1) / 2;
auto it = M.find(p.first); it++;
while (it != M.end())
{
if (p.first.first + it->first.first >= 18 && p.first.second + it->first.second >= 18)
res += p.second*(LL)it->second;
it++;
}
}
printf("%lld\n", res);
return 0;
}
// FOR GNU C++ use the following pattern:
// Uncomment the code below and change your main into main2
// It does not build in MS C++
// But it does increase the stack size from 256 MB on CF and uses GNU C++
//#include <Processthreadsapi.h>
//#include <iostream>
//#include <Synchapi.h>
//#include <windows.h>
//#include <process.h>
//
//DWORD WINAPI MyThreadFunction(LPVOID lpParam) {
// main2(nullptr);
// return 0;
//}
//int main() {
// auto h = CreateThread(nullptr, 1024 << 20, MyThreadFunction, nullptr, STACK_SIZE_PARAM_IS_A_RESERVATION, nullptr);
// WaitForSingleObject(h, INFINITE);
//} | // A.
#include <stdio.h>
typedef long long LL;
char buffer[3072000];
LL cnt[20][20];
LL sum[20][20];
LL n;
LL ans;
int main(int argc, char* argv[]) {
char c, *bufptr = buffer;
fread(buffer, 1, 3072000, stdin);
while ((c = *bufptr++) >= '0') {
n = (n * 10) + (c - '0');
}
for (LL i = 0; i < n; ++i) {
LL x = 0, two = 0, five = 0, df = 0;
while ((c = *bufptr++) >= ' ') {
if (c == '.') {
df = -1;
} else {
x = (x * 10) + c - '0';
five += df;
}
}
two = __builtin_ctzll(x);
x >>= two;
two += five;
while (x % 5 == 0) {
++five;
x /= 5;
}
if (two > 9) two = 9;
if (five > 9) five = 9;
cnt[10 + two][10 + five] += 1;
sum[10 - two][10 - five] += 1;
}
for (int i = 0; i < 20; ++i) {
for (int j = 1; j < 20; ++j) {
sum[i][j] += sum[i][j - 1];
}
}
for (int i = 1; i < 20; ++i) {
for (int j = 0; j < 20; ++j) {
sum[i][j] += sum[i - 1][j];
}
}
for (int i = -9; i <= 9; ++i) {
for (int j = -9; j <= 9; ++j) {
ans += sum[10 + i][10 + j] * cnt[10 + i][10 + j];
if (i >= 0 && j >= 0) {
ans -= cnt[10 + i][10 + j];
}
}
}
printf("%lld\n", ans >> 1);
return 0;
}
| 1 |
#include <iostream>
#include <cstring>
#include <cmath>
#include <vector>
#include <algorithm>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <set>
#include <map>
#include <iterator>
#include <stack>
#include <string.h>
#include <cstdlib>
#include <queue>
#include <list>
#include <string>
using namespace std;
int main()
{
int a;
int b[3];
string s;
cin >> s;
a = s[0] - '0';
for (int i = 1;i <= 3;i++){
b[i-1] = s[i] - '0';
}
int f[3];
int c[3];
for (int i = 0;i < (1<<3);i++){
for (int j = 0;j < 3;j++){
if ((i>>j)%2){
f[2-j] = 1;
c[2-j] = b[2-j];
}
else {
f[2-j] = 0;
c[2-j] = -b[2-j];
}
}
if (a+c[0]+c[1]+c[2] == 7){
break;
}
}
cout << a;
for (int i = 0;i < 3;i++){
if (f[i]){
cout << "+" << b[i];
}
else {
cout << "-" << b[i];
}
}
cout << "=7" << endl;
}
| #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main(int argc, char const* argv[])
{
std::string s;
std::cin >> s;
std::reverse(s.begin(),s.end());
std::cout << s << std::endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int64_t n,k;
cin >> n >> k;
if(k!=0){
cout << "0\n";
return 0;
}
vector<int64_t>a(n-1);
for(int i=0;i<n-1;i++){
cin >> k;
if(k==0){
cout << "0\n";
return 0;
}
a.at(k-1)++;
}
int64_t ans=1;
for(int i=0;i<n-2;i++){
int64_t m=1;
for(int j=0;j<a.at(i+1);j++){
m*=a.at(i);
m%=998244353;
}
ans*=m;
ans%=998244353;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast,unroll-loops")
//#pragma GCC target("avx,avx2,fma")
typedef long long LL;
typedef pair<int, int> PII;
typedef vector<int> VI;
#define MP make_pair
#define PB push_back
#define X first
#define Y second
#define FOR(i, a, b) for(int i = (a); i < (b); ++i)
#define RFOR(i, b, a) for(int i = (b) - 1; i >= (a); --i)
#define ALL(a) a.begin(), a.end()
#define SZ(a) (int)((a).size())
#define FILL(a, value) memset(a, value, sizeof(a))
#define debug(a) cerr << #a << " = " << a << endl;
template<typename T> void setmax(T& x, T y) {x = max(x, y);}
template<typename T> void setmin(T& x, T y) {x = min(x, y);}
const double PI = acos(-1.0);
const LL INF = 1e9 + 47;
const LL LINF = INF * INF;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> d(n);
FOR(i, 0, n) cin >> d[i];
const int mod = 998244353;
bool ok = d[0] == 0;
FOR(i, 1, n) ok &= d[i] > 0;
if (!ok){
cout << 0 << endl;
return 0;
}
vector<int> cnt(n, 0);
for(auto i: d) cnt[i]++;
while(cnt.back() == 0) cnt.pop_back();
for(auto i: cnt) if (!i){
cout << 0 << endl;
return 0;
}
int ans = 1;
FOR(i, 1, SZ(cnt)) FOR(j, 0, cnt[i]) ans = (ans * (LL) cnt[i - 1]) % mod;
cout << ans << endl;
cerr << "Time elapsed: " << clock() / (double)CLOCKS_PER_SEC << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define ALL(x) (x).begin(), (x).end()
typedef long long ll;
typedef pair<int, int> pii;
const int INF = 1e9;
const int MOD = 1000000007;
const double PI = acos(-1);
int dx[4] = {0,1,0,-1};
int dy[4] = {1,0,-1,0};
void solve() {
int h, w;
cin >> h >> w;
vector<string> v(h);
rep(i,h) cin >> v[i];
vector<vector<int>> d(h, vector<int>(w, INF));
queue<pii> q;
auto update = [&](int y, int x, int nd) {
if (d[y][x] != INF) return;
d[y][x] = nd;
q.push(pii(y, x));
};
update(0, 0, 1);
while (!q.empty()) {
auto p = q.front(); q.pop();
rep(i,4) {
int ny = p.first + dy[i];
int nx = p.second + dx[i];
if (nx < 0 || nx >= w || ny < 0 || ny >= h) continue;
if (v[ny][nx] == '#') continue;
update(ny, nx, d[p.first][p.second] + 1);
}
}
if (d[h-1][w-1] == INF) {
cout << -1 << endl;
} else {
int cs = 0;
rep(i,h) rep(j,w) if (v[i][j] == '#') cs++;
// cout << h * w << " " << cs << " " << d[h-1][w-1] << endl;
cout << h * w - (cs + d[h-1][w-1]) << endl;
}
}
int main() {
solve();
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define debug(s, param) std::cerr << s << param << std::endl;
using namespace std;
using ll = long long;
const ll MOD = 1000000007;
int bfs(const vector<string>& grids, int h, int w) {
vector<vector<int>> deltas{{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
vector<vector<bool>> visit(h, vector<bool>(w, false));
queue<pair<int, int>> q;
auto isAvailable = [h, w](int row, int col) { return (row >= 0 && row < h && col >= 0 && col < w); };
q.emplace(0, 0);
visit[0][0] = true;
int steps = 0;
while (!q.empty()) {
int size = (int)q.size();
rep (i, size) {
int row = q.front().first, col = q.front().second;
if (row == h - 1 && col == w - 1) return steps;
q.pop();
for (const auto& delta : deltas) {
int nextRow = row + delta[0], nextCol = col + delta[1];
if (isAvailable(nextRow, nextCol) && grids[nextRow][nextCol] == '.' && !visit[nextRow][nextCol]) {
visit[nextRow][nextCol] = true;
q.emplace(nextRow, nextCol);
}
}
}
++steps;
}
return -1;
}
int main() {
int h, w;
cin >> h >> w;
int blackNums = 0;
vector<string> grids(h, "");
rep (i, h) {
cin >> grids[i];
rep (j, w) if (grids[i][j] == '#') ++blackNums;
}
int res = bfs(grids, h, w);
if (res == -1) cout << -1 << endl;
else cout << h * w - (blackNums + res + 1) << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
using namespace std;
#define rep(i,x) for(ll i = 0; i < (ll)(x); i++)
#define rrep(i,x) for(ll i = (ll)(x)-1;0 <= i; i--)
#define reps(i,x) for(ll i = 1; i < (ll)(x)+1; i++)
#define rreps(i,x) for(ll i = (ll)(x); 1 <= i; i--)
#define debug(x) cerr << #x << ": " << (x) << "\n";
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef long double ld;
typedef pair<int,int> P;
typedef pair<ll,ll> Pll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<vector<vector<ll>>> vvvl;
const ll INF = numeric_limits<ll>::max()/4;
const int n_max = 1e5+10;
int main(){
ll n; cin >> n;
string s;cin >> s;
ll q; cin >> q;
vector<ll> k(q);
rep(i,q) cin >> k[i];
auto f = [](auto a, auto b){
return a + b;
};
rep(i,q){
ll kt = k[i];
ll cnt = 0;
ll ans = 0;
ll num = 0;
ll d_num = 0, m_num = 0;
rep(i,n){
num++;
if(s[i] == 'D')d_num++;
if(s[i] == 'M'){
m_num++;
cnt += d_num;
}
if(num > kt){
if(s[i-kt] == 'M')m_num--;
if(s[i-kt] == 'D'){
d_num--;
cnt -= m_num;
}
num--;
}
if(s[i] == 'C')ans += cnt;
// debug(i);debug(s[i]);debug(cnt);debug(ans);
}
cout << ans << endl;
}
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll rm[2000005]={0},rc[2000005]={0},rmc[2000005]={0};
ll n;
string s;
ll solve(ll k){
ll res=0;
for(int i=1;i<=n;i++){
if(s[i]=='D'){
res+=rmc[i+k-1]-rmc[i];
res-=rm[i]*(rc[i+k-1]-rc[i]);
}
}
return res;
}
int main(){
cin>>n;
s.push_back('A');
string ks;
cin>>ks;
s+=ks;
for(int i=1;i<=n;i++){
rm[i]=rm[i-1];
rc[i]=rc[i-1];
rmc[i]=rmc[i-1];
if(s[i]=='M') rm[i]++;
if(s[i]=='C') {
rc[i]++;
rmc[i]+=rm[i];
}
}
for(int i=n+1;i<=n*2;i++){
rm[i]=rm[i-1];
rc[i]=rc[i-1];
rmc[i]=rmc[i-1];
}
ll q;
cin>>q;
for(int i=0;i<q;i++){
ll k;
cin>>k;
cout<<solve(k)<<endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
const int inf = 1e9 + 1e8;
int n, k; cin >> n >> k;
vector<int> x(n);
int pos = 0;
bool flag = false;
for (int i = 0; i < n; i++) {
cin >> x[i];
if (x[i - 1] < 0 && x[i] > 0) pos = i;
if (x[i] == 0) {
pos = i;
k--;
flag = true;
}
}
if (x[pos] < 0) pos = n;
if (flag) {
for (int i = pos; i + 1 < n; i++) x[i] = x[i + 1];
n--;
}
int ans = k == 0 ? 0 : inf;
for (int i = 0; i < n; i++) {
if (i < pos) {
int cnt = pos - i;
if (cnt >= k) {
ans = min(ans, -x[i]);
} else {
if (k + i - 1 < n) ans = min(ans, -2 * x[i] + x[k + i - 1]);
}
} else {
int cnt = i - pos + 1;
if (cnt >= k) {
ans = min(ans, x[i]);
} else {
if (i - k + 1 >= 0) ans = min(ans, 2 * x[i] - x[i - k + 1]);
}
}
}
cout << ans << endl;
return 0;
}
| #include <cstdio>
#include <cmath>
#define buf 10000
using namespace std;
int k=0;
int B[buf];
void Answer(int n);
int PrimeNumber(int n);
int main(void){
int i,n;
char str[buf];
for(i=2;i<buf;i++)
PrimeNumber(i);
for( ;fgets(str,sizeof(str),stdin)!=NULL; ){
sscanf(str,"%d",&n);
if(n==0) break;
Answer(n);
}
return 0;
}
void Answer(int n){
int i,j;
for(i=0;i<k;i++){
if(B[i]>n)
break;
}
for(j=i-1;j>=0;j--){
if(B[j]-B[j-1]==2){
printf("%d %d\n",B[j-1],B[j]);
break;
}
}
}
int PrimeNumber(int n){
int i,c;
if(n==2){
B[k]=n;
k++; return 0;
}
if(n<2 || n%2==0)
return 0;
c=sqrt(n);
for(i=3;i<=c;i+=2){
if(n%i==0)
return 0;
}
B[k]=n;
k++; return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
vector<int> a,q;
int b;
for(int i=0;i<4;i++){
cin >> b;
a.push_back(b);
}
for(int i=0;i<2;i++){
cin >> b;
q.push_back(b);
}
sort(a.begin(),a.end(),greater<int>());
sort(q.begin(),q.end(),greater<int>());
int ans=0;
for(int i=0;i<3;i++){
ans+=a[i];
}
ans+=q[0];
cout << ans << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int A, B, C, D, E, F;
cin >> A >> B >> C >> D >> E >> F;
int sum = 0;
if (A <= B && A <= C && A <= D) sum += B + C + D;
else if (B <= A && B <= C && B <= D) sum += A + C + D;
else if (C <= A && C <= B && C <= D) sum += A + B + D;
else sum += A + B + C;
if (E <= F) sum += F;
else sum += E;
cout << sum << endl;
return 0;
}
| 1 |
#include <iostream>
#include <vector>
using namespace std;
const int INF = 2147483647;
struct SegmentTree {
int n;
vector<int> heap;
SegmentTree(int n): n(n) {
heap.assign(4 * n, INF);
}
void update(int nodeId, int l, int r, int ql, int qr, int v) {
if (qr < l || ql > r) {
return;
}
else if (ql <= l && r <= qr) {
heap[nodeId] = v;
}
else {
pushdown(nodeId);
int m = l + (r - l)/2;
update(nodeId * 2, l, m, ql, qr, v);
update(nodeId * 2 + 1, m + 1, r, ql, qr, v);
}
}
int query(int nodeId, int l, int r, int q) {
if (q < l || q > r) {
return -1;
}
else if (heap[nodeId] != -1) {
return heap[nodeId];
}
else {
int m = l + (r - l)/2;
return max(query(nodeId * 2, l, m, q), query(nodeId * 2 + 1, m + 1, r, q));
}
}
void pushdown(int nodeId) {
//cout << "push: " << nodeId << endl;
if (heap[nodeId] != -1) {
heap[nodeId * 2] = heap[nodeId];
heap[nodeId * 2 + 1] = heap[nodeId];
heap[nodeId] = -1;
}
}
};
int main() {
int n, q;
cin >> n >> q;
SegmentTree st(n);
for (int i = 0; i < q; i++) {
int cmd;
cin >> cmd;
if (cmd == 0) {
int ql, qr, v;
cin >> ql >> qr >> v;
st.update(1, 0, n -1, ql, qr, v);
// for (int i = 0; i < 4 * n; i++) {
// cout << i << ":" << st.heap[i] << endl;
// }
}
else {
int pos;
cin >> pos;
cout << st.query(1, 0, n-1, pos) << endl;
}
}
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
#include <string>
#include <queue>
#include <cstdlib>
using namespace std;
typedef long long int ll;
typedef pair<int, int> Pii;
const ll mod = 1000000007;
template <class T>
struct prop_segtree {
int n;
vector<T> data;
vector<bool> propFlag;
prop_segtree(const int s) {
init(s);
}
prop_segtree(const int s, const T u) {
init(s);
for (int i = 0; i < s; i++) {
data[i+n-1] = u;
}
for (int i = n-2; i >= 0; i--) {
data[i] = 0;
}
}
prop_segtree(const vector<T> &v) {
int s = v.size();
init(s);
for (int i = 0; i < s; i++) {
data[i+n-1] = v[i];
}
for (int i = n-2; i >= 0; i--) {
data[i] = 0;
}
}
void init(const int s) {
n = 1;
while (n < s) n <<= 1;
data = vector<T>(2*n-1);
propFlag = vector<bool>(2*n-1);
}
void propagate(int p, int a, int b) {
if (propFlag[p]) {
if (b - a > 1) {
data[p*2+1] = data[p];
data[p*2+2] = data[p];
propFlag[p*2+1] = true;
propFlag[p*2+2] = true;
data[p] = 0;
}
propFlag[p] = false;
}
}
void update(int l, int r, T v, int p = 0, int a = 0, int b = -1) {
if (b < 0) b = n; // init
// propagate value
propagate(p, a, b);
if (r <= a || b <= l) return; // out of range
if (l <= a && b <= r) { // fully covered
data[p] = v;
propFlag[p] = true;
propagate(p, a, b);
}
else {
update(l, r, v, p*2+1, a, (a + b) / 2); // left
update(l, r, v, p*2+2, (a + b) / 2, b); // right
}
return;
}
T query(int x, T p = 0, int a = 0, int b = -1) {
if (b < 0) b = n; // init
// propagate value
propagate(p, a, b);
if (b - a == 1) return data[p];// reached to bottom
if (x < (a + b) / 2) return query(x, p*2+1, a, (a + b) / 2); // left
else return query(x, p*2+2, (a + b) / 2, b); // right
}
};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n, q;
cin >> n >> q;
vector<vector<int> > query(q, vector<int>(4));
for (int i = 0; i < q; i++) {
cin >> query[i][0] >> query[i][1];
if (query[i][0] == 0) cin >> query[i][2] >> query[i][3];
}
prop_segtree<int> pst(n, 0x7fffffff);
vector<ll> ans;
for (int i = 0; i < q; i++) {
if (query[i][0] == 0) { // update
pst.update(query[i][1], query[i][2]+1, query[i][3]);
}
else { // get
ans.push_back(pst.query(query[i][1]));
}
}
for (auto &x: ans) cout << x << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#include <time.h>
#define rep(i,n) for(int i=0; i<(n); i++)
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using vi = vector<ll>;
using vv = vector<vi>;
const ll INF = 1001001001;
const ll NUM = 1<<10;
//(開始, 今)を管理
//例:
//(0,0), (1,1), (2,2), (3,3), (4,4), (5,5)
//壁(1,2) . .(該当領域)
//(0,0), (1,3), (2,3), (3,3), (4,4), (5,5) ->(1,3),(2,3)は消す
//(0,0), (3,3), (4,4), (5,5)
//壁(2,3) .(該当領域)
//(0,0), (3,4), (4,4), (5,5) ->(3,4)は消す
//(0,0), (4,4), (5,5)
//
//・順序集合(map)を使う: map[今]=開始の最大値
//・ans = min(今-開始), multisetで管理
//・該当領域+1の範囲で開始が一番右のものだけ残す
//・それ以外はansからもmapからも消す
//
int main(){
int h,w;
cin >> h >> w;
map<int,int> s;
multiset<int> m;
rep(i,w)s[i] = i;
rep(i,w)m.insert(0);
rep(i,h){
int l,r;
cin>>l>>r;
--l;
auto itr = s.lower_bound(l);
int maxstart= -1;
while(itr!=s.end() && itr->first<=r){
maxstart= max(maxstart, itr->second);
int c = itr->first - itr->second;
m.erase(m.find(c));
s.erase(itr++);
//itr=s.erase(itr);//これでもいい
//s.erase(*itr); itr++;//これはだめ
}
if(r<w && maxstart != -1){
s[r] = maxstart;
m.insert(r-maxstart);
}
int ans = -1;
if(!m.empty())
ans = *m.begin() + (i+1);
cout<<ans<<endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define hackcyborg shresth_walia
#define ll long long
#define ld double
#define pb push_back
#define mod 1000000007
#define IO ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int,null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define int long long
ll binpow(ll a,ll b,ll m=mod)
{
ll res=1;
while(b>0)
{
if(b&1)
res=(a*res)%m;
a=(a*a)%m;
b/=2;
}
return res;
}
const int INF =1e9;
ll n;
vector<pair<ll,ll>> ar[200010];
void dijkstra(int s, vector<int> & d, vector<int> & p) {
d.assign(n+1, INF);
p.assign(n+1, -1);
d[s] = 0;
set<pair<int, int>> q;
q.insert({0, s});
while (!q.empty()) {
int v = q.begin()->second;
q.erase(q.begin());
for (auto edge : ar[v]) {
int to = edge.first;
int len = edge.second;
if (d[v] + len < d[to]) {
q.erase({d[to], to});
d[to] = d[v] + len;
p[to] = v;
q.insert({d[to], to});
}
}
}
}
main()
{
IO
ll m;
cin>>n>>m;
++n;
ll a[n+1],b[n+1];
for(int x=1;x<n;x++)
{cin>>a[x]>>b[x];
++b[x];}
b[n]=m;
a[n]=1;
set<pair<ll,ll>> ae;
for(int x=1;x<=m;x++)
{
ae.insert({x,0ll});
}
for(int x=1;x<=n;x++)
{
auto it=ae.lower_bound(make_pair(a[x],-1ll));
vector<pair<ll,ll>> as;
if(it!=ae.end())
while((it->first)<=(b[x]-1) && (it->first)>=a[x])
{
as.pb(*it);
//cout<<it->second<<" "<<x<<"\n";
ar[it->second].pb(make_pair(x,abs(it->first-b[x])+abs(it->second-x)));
++it;
if(it==ae.end())break;
}
for(auto it : as)
ae.erase(it);
ae.insert(make_pair(b[x],x));
}
vector<ll> d,p;
dijkstra(0,d,p);
ll ans[n+1];
for(int x=1;x<=n;x++)
ans[x]=INF;
for(int x=0;x<=n;x++)
{ ans[x]=min(ans[x],d[x]);
for(auto it : ar[x])
{
ans[it.first]=min(ans[it.first],d[x]+abs(x-it.first));
}
}
ll mi=1e18;
for(int x=n;x>=1;x--)
{
ans[x]=min(ans[x],mi+x);
mi=min(mi,ans[x]-x);
}
for(int x=2;x<=n;x++)
if(ans[x]<1e8)
cout<<ans[x]-1<<"\n";
else
cout<<-1<<"\n";
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define VIEW(x) do {cerr << #x << ": "; for(auto i : x) cerr << i << " "; cerr << endl;} while(0)
struct CumulativeSum2D {
vector<vector<long long>> csum;
template<typename T>
CumulativeSum2D(vector<vector<T>> input) : csum(input.size() + 1, vector<long long>(input[0].size() + 1, 0)) {
for(int i = 0; i < input.size(); i++) for(int j = 0; j < input[i].size(); j++)
csum[i+1][j+1] += csum[i+1][j] + csum[i][j+1] - csum[i][j] + input[i][j];
}
CumulativeSum2D(vector<string> input, char target) : csum(input.size() + 1, vector<long long>(input[0].size() + 1, 0)) {
for(int i = 0; i < input.size(); i++) for(int j = 0; j < input[i].size(); j++)
csum[i+1][j+1] += csum[i+1][j] + csum[i][j+1] - csum[i][j] + (input[i][j]==target);
}
long long query(int x_left, int y_top, int x_right, int y_bottom) { /* 0-indexed, inclusive */
return csum[x_right+1][y_bottom+1] - csum[x_right+1][y_top] - csum[x_left][y_bottom+1] + csum[x_left][y_top];
}
};
signed main() {
int n,m,Q; cin >> n >> m >> Q;
vector<vector<int>> grid(n, vector<int>(n, 0));
rep(i,m) {
int l,r; cin >> l >> r;
grid[l-1][r-1]++;
}
CumulativeSum2D cs(grid);
rep(i,Q) {
int p,q; cin >> p >> q; --p,--q;
cout << cs.query(p,p, q,q) << endl;
}
}
| #define _USE_MATH_DEFINES
#include <cmath>
#include<iostream>
#include<iomanip>
#include<cstdio>
#include<string>
#include<vector>
#include<cctype>
#define rep(i,start,n) for(int i=start;i<n;i++)
#define And &&
#define Or ||
#define Lb cout<<endl
using namespace std;
int main(void) {
string str; cin >> str;
int q; cin >> q;
string meirei, x;
int a, b;
rep(i, 0, q) {
cin >> meirei;
cin >> a >> b;
if (meirei == "replace") {
cin >> x;
rep(j, 0, x.length()) {
str[a + j] = x[j];
}
}
else if (meirei == "reverse") {
rep(j, 0, (b - a + 1) / 2) {
char temp;
temp = str[a + j];
str[a + j] = str[b - j];
str[b - j] = temp;
}
}
else {
rep(j, 0, (b - a + 1)) {
cout << str[a + j];
}
cout << endl;
}
}
} | 0 |
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <functional>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <numeric>
#include <math.h>
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, a, b, i, j;
cin >> n >> m >> b >> a;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if ((i < a) + (j < b) == 1) cout << "1";
else cout << "0";
}
cout << "\n";
}
return 0;
}
| #include<iostream>
#include<string>
#include<numeric>
#include<set>
#include<algorithm>
#include<map>
#include<vector>
using namespace std;
typedef long long li;
#define ceil(a,b) (((a)+(b)-1)/(b))
#define dist(a,b) max((a)-(b),(b)-(a))
#define yn(i) print((i)?"Yes":"No")
#define rep(i,n) for(int i=0;i<(n);i++)
#define df 0
template<class T> void print(const T& t){ cout << t << "\n"; }
template<class T, class... Ts> void print(const T& t, const Ts&... ts) { cout << t; if (sizeof...(ts)) cout << " "; print(ts...); }
// Container コンテナ型, map以外
template< template<class ...> class Ctn,class T>
std::ostream& operator<<(std::ostream& os,const Ctn<T>& v){
auto itr=v.begin();
while(itr!=v.end()){
if(itr!=v.begin())cout << " ";
cout << *(itr++);
}
return os;
}
int main(){
int h,w; cin >>h >>w;
int a,b; cin >>a >>b;
int s=0;
rep(i,h){
if(i==b) s^=1;
rep(j,w){
if(j==a) s^=1;
printf("%d",s);
}
printf("\n");
s^=1;
}
} | 1 |
#include <iostream>
#include <string.h>
#include <vector>
#include <algorithm>
#include <set>
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
set<int> s;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
s.insert(x);
}
int a = n;
while (1) {
int c = a;
bool ok = 1;
while (c > 0) {
int di = c % 10;
if (s.count(di)) {
ok = 0;
break;
}
c /= 10;
}
if (ok) {
cout << a << endl;
break;
}
a++;
}
return 0;
} | #include <iostream>
using namespace std;
int main()
{
int a,b;
cin>>a>>b;
if(1<=(a&&b)<=100)
{
cout<<a*b;
}
return 0;
} | 0 |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <time.h>
#include <math.h>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>
#include <sstream>
#include <string>
#include <bitset>
using namespace std;
#define FOR(I,F,N) for(int I = F; I < (int)(N); I++)
#define rep(i, n) FOR(i, 0, n)
#define FIN(V) cout<<V<<endl
#define pb push_back
#define INF (1 << 28)
template<typename T>
void remove(vector<T>& vector, unsigned int index){
vector.erase(vector.begin() + index);
}
typedef pair<int, int> P;
typedef long long ll;
typedef priority_queue<int> pq;
int StrToInt(string);
string IntToStr(int);
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int n;
int memo[32];
int dfs(int now){
if(now > n)return false;
if(now == n)return true;
if(memo[now] != -1)return memo[now];
int sum = dfs(now+1) + dfs(now+2) + dfs(now+3);
return memo[now] = sum;
}
int main(void){
while(cin >> n, n){
fill_n(memo, 32, -1);
cout << dfs(0)/3650+1 << endl;
}
return 0;
}
int StrToInt(string s){
stringstream ss;
ss << s;
int val;
ss >> val;
return val;
}
string IntToStr(int i){
stringstream ss;
ss << i;
return ss.str();
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define vvi vector<vector<int>>
#define vec vector
#define pq priority_queue
#define all(v) (v).begin(), (v).end()
#define uniqueV(x) sort(x.begin(), x.end()); x.erase(unique(x.begin(), x.end()), x.end());
#define rep(i, n) for (int (i) = (0); (i) < (n); ++(i))
#define repp(i, m, n) for (int (i) = (m); (i) < (n); ++(i))
#define dbg(x) cerr << #x << ": " << x << endl;
#define dbg2(x, y) cerr<<"("<<#x<<", "<<#y<<") = "<<"("<<x<<", "<<y<<")"<<endl;
#define dbg3(x, y, z) cerr<<"("<<#x<<", "<<#y<<", "<<#z<<") = "<<"("<<x<<", "<<y<<", "<<z<<")"<<endl;
#define dbgB(value, size) cerr<<#value<<": "<<bitset<size>(value) << endl;
#define line() cerr << "---------------" << endl;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, -1, 1};
const double PI = 3.14159265358979323846;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a = b; return 1; } return 0; }
template<typename T, typename U>
void print1(T Array, U size) {
for (int i = 0; i < size; i++) {
cout << Array[i] << " ";
}
cout << endl;
}
template<typename T>
void print(T Array, int height, int width) {
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
cout << " " << Array[i][j];
}
cout << endl;
}
}
// ------------------------------------------------------------------------------------------
int n;
int dp[55];
int rec(int stage) {
if (stage == 0) {
return dp[stage] = 1;
}
if (dp[stage] != -1) {
return dp[stage];
}
int ans = 0;
for (int i = 1; i <= 3; i++) {
if (stage - i < 0) continue;
ans += rec(stage - i);
}
return dp[stage] = ans;
}
signed main() {
fill(dp, dp+33, -1);
rec(30);
while (1) {
cin >> n;
if (n == 0) break;
int t = (dp[n] + 3650 - 1) / 3650;
cout << t << endl;
}
return 0;
}
| 1 |
#include <cstdio>
#include <cctype>
#include <cstring>
#include <algorithm>
#include <vector>
#define debug(...) fprintf(stderr, __VA_ARGS__)
#ifndef AT_HOME
#define getchar() IO::myGetchar()
#define putchar(x) IO::myPutchar(x)
#endif
namespace IO {
static const int IN_BUF = 1 << 23, OUT_BUF = 1 << 23;
inline char myGetchar() {
static char buf[IN_BUF], *ps = buf, *pt = buf;
if (ps == pt) {
ps = buf, pt = buf + fread(buf, 1, IN_BUF, stdin);
}
return ps == pt ? EOF : *ps++;
}
template<typename T>
inline bool read(T &x) {
bool op = 0;
char ch = getchar();
x = 0;
for (; !isdigit(ch) && ch != EOF; ch = getchar()) {
op ^= (ch == '-');
}
if (ch == EOF) {
return false;
}
for (; isdigit(ch); ch = getchar()) {
x = x * 10 + (ch ^ '0');
}
if (op) {
x = -x;
}
return true;
}
inline int readStr(char *s) {
int n = 0;
char ch = getchar();
for (; isspace(ch) && ch != EOF; ch = getchar())
;
for (; !isspace(ch) && ch != EOF; ch = getchar()) {
s[n++] = ch;
}
s[n] = '\0';
return n;
}
inline void myPutchar(char x) {
static char pbuf[OUT_BUF], *pp = pbuf;
struct _flusher {
~_flusher() {
fwrite(pbuf, 1, pp - pbuf, stdout);
}
};
static _flusher outputFlusher;
if (pp == pbuf + OUT_BUF) {
fwrite(pbuf, 1, OUT_BUF, stdout);
pp = pbuf;
}
*pp++ = x;
}
template<typename T>
inline void print_(T x) {
if (x == 0) {
putchar('0');
return;
}
std::vector<int> num;
if (x < 0) {
putchar('-');
x = -x;
}
for (; x; x /= 10) {
num.push_back(x % 10);
}
while (!num.empty()) {
putchar(num.back() ^ '0');
num.pop_back();
}
}
template<typename T>
inline void print(T x, char ch = '\n') {
print_(x);
putchar(ch);
}
inline void printStr_(const char *s, int n = -1) {
if (n == -1) {
n = strlen(s);
}
for (int i = 0; i < n; ++i) {
putchar(s[i]);
}
}
inline void printStr(const char *s, int n = -1, char ch = '\n') {
printStr_(s, n);
putchar(ch);
}
}
using namespace IO;
void solve() {
int h1, m1, h2, m2, k;
read(h1), read(m1), read(h2), read(m2), read(k);
int t1 = h1 * 60 + m1, t2 = h2 * 60 + m2;
print(std::max(t2 - t1 - k, 0));
}
int main() {
int T = 1;
// read(T);
while (T--) {
solve();
}
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long LL;
int a,b,c,d,e;
int main(){
scanf("%d%d%d%d%d",&a,&b,&c,&d,&e);
printf("%d\n",max(c*60+d-a*60-b-e,0));
return 0;
} | 1 |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int A,B,M,p{100000},q{100000},mi{200000},x,y,c;
cin >> A >> B >> M;
vector<int> a(A), b(B);
for (auto &e: a) {
cin >> e;
if(e<p) p = e;
}
for (auto &e: b) {
cin >> e;
if(e<q) q = e;
}
mi = p+q;
while(cin >> x >> y >> c) {
mi = min(mi,a[x-1]+b[y-1]-c);
}
cout << mi << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi=vector<int>;
using vvi=vector<vi>;
using vl=vector<ll>;
using vvl=vector<vl>;
using vb=vector<bool>;
using vvb=vector<vb>;
using pii = pair<int,int>;
using pli = pair<ll,int>;
using pll = pair<ll,ll>;
using vpii = vector<pii>;
using vpli = vector<pli>;
using vpll = vector<pll>;
#define rep(i, n) for(int i=0;i<(int)n;i++)
#define rep2(i, s, n) for(int i=(s);i<(int)n;i++)
int INF=1e9+7;
int main() {
int A,B,M;
cin >> A >> B >> M;
vi a(A),b(B),x(M),y(M),c(M);
int mina=INF,minb=INF;
rep(i,A) {
cin >> a[i];
mina=min(mina,a[i]);
}
rep(i,B) {
cin >> b[i];
minb=min(minb,b[i]);
}
rep(i,M) {
cin >> x[i] >> y[i] >> c[i];
x[i]--;y[i]--;
}
int ans=mina+minb;
rep(i,M)
ans=min(ans,a[x[i]]+b[y[i]]-c[i]);
cout << ans << endl;
} | 1 |
#include <bits/stdc++.h>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
int64_t N, ans;
cin >> N;
for (int i=0; i<=sqrt(N); i++) {
if (i*i<=N) {
ans=i*i;
}
}
cout << ans << endl;
}
| #include<bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define REP(i,a,b) for(inti=a;i<=b;i++)
#define MOD 1000000007
typedef long long int ll;
typedef vector<int>vi;
typedef pair<int,int>pi;
int main()
{
int n;cin>>n;
int ans =0;
int i = 0;
while(i*i<=n)
{
i++;
}
cout<<(i-1)*(i-1)<<endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int mod = 1e9 + 7;
ll pwr (ll a, ll b) {
ll res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
ll inv (ll a) {
return pwr (a, mod - 2);
}
ll nCr (ll n, ll r) {
ll ans = 1;
for (int i = 0; i < r; i++) ans = (ans * (n - i)) % mod;
for (int i = 1; i <= r; i++) ans = (ans * inv (i)) % mod;
return ans;
}
int main () {
ios_base::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
int n, m;
ll k;
cin >> n >> m >> k;
ll ans = 0;
for (int i = 1; i <= m; i++) {
ans += (((ll)(m - i) * (m - i + 1)) / 2);
ans %= mod;
}
ll a = (((ll)n * (n - 1)) + n) % mod;
ans = (ans * a) % mod;
ll tmp_ans = 0;
for (int i = 1; i <= n; i++) {
tmp_ans += (((ll)(n - i) * (n - i + 1)) / 2);
tmp_ans %= mod;
}
ll b = (((ll)m * (m - 1)) + m) % mod;
tmp_ans = (tmp_ans * b) % mod;
ans = (ans + tmp_ans) % mod;
ans = (ans * nCr ((ll)n * m - 2, k - 2)) % mod;
cout << ans << '\n';
}
| #include <bits/stdc++.h>
using namespace std;
// 型定義
typedef long long ll;
typedef pair<ll, ll> P;
// forループ
#define REP(i,n) for(ll i=0; i<(ll)(n); ++i)
// 定数宣言
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
// グラフ表現
using Graph = vector<vector<int>>;
// グラフの辺表現
using Edge = map<pair<int,int>,int>;
// n次元配列の初期化。第２引数の型のサイズごとに初期化していく。
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
std::fill( (T*)array, (T*)(array+N), val );
}
const int MAX = 1000000;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
int main()
{
cout << fixed << setprecision(15);
ll N, M, K;
cin >> N >> M >> K;
ll A = 1;
A = (A*N)%MOD;
A = (A*N)%MOD;
A = (A*(M-1))%MOD;
A = (A*M)%MOD;
A = (A*(M+1))%MOD;
ll B = 1;
B = (B*M)%MOD;
B = (B*M)%MOD;
B = (B*(N-1))%MOD;
B = (B*N)%MOD;
B = (B*(N+1))%MOD;
// 前処理
COMinit();
ll C = COM(N*M-2, K-2) % MOD;
cout << ((((A+B)%MOD)* modinv(6, MOD) % MOD) * C) % MOD << endl;
return 0;
} | 1 |
#include <stdio.h>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
string input;
cin >> input;
reverse(input.begin(), input.end());
cout << input << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
//cout << fixed << setprecision(15);
vector<int> forintinput(int n) {
vector<int> x;
for(int i = 0;i < n;i++){
int ia;
cin >> ia;
x.push_back(ia);
}
return x;
}
int main(){
int a,b,c;
cin >> a >> b >> c;
cout << min(a+b,min(b+c,c+a)) << endl;
} | 0 |
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
char field[12][12];
int dx[4]={0,0,-1,1},dy[4]={-1,1,0,0};
void dfs(int x,int y){
field[x][y]='0';
for(int i=0;i<4;i++){
int nx=x+dx[i],ny=y+dy[i];
if(0<=nx&&nx<12&&0<=ny&&ny<12&&field[nx][ny]=='1')dfs(nx,ny);
}
return;
}
int main(void){
char a;
while(cin>>a){
int ans=0;
for(int i=0;i<12;i++){
for(int j=0;j<12;j++){
if(i==0&&j==0)field[0][0]=a;
else cin>>field[i][j];
}
}
for(int i=0;i<12;i++){
for(int j=0;j<12;j++){
if(field[i][j]=='1'){
dfs(i,j);ans++;
}
}
}
cout<<ans<<endl;
}
}
| #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
#define REP(var, a, b) for (int var = (a); var < (b); var++)
#define rep(var, n) for (int var = 0; var < (n); ++var)
#define ALL(c) (c).begin(), (c).end()
#define rALL(c) (c).rbegin(), (c).rend()
ll MOD = 1000000007;
const ll INF = 1LL << 62;
int main() {
//
ll n;
cin >> n;
vl a(n);
rep(i, n) cin >> a[i];
ll s = 0;
rep(i, n) s ^= a[i];
ll ans = s;
rep(i, n) { a[i] &= ~s; }
int r = 0;
for (int i = 60; i >= 0; i--) {
int j = r;
for (; j < n; j++) {
if (a[j] >> i & 1) {
swap(a[r], a[j]);
break;
}
}
if (j == n) continue;
rep(k, n) {
if (k == r) continue;
if (a[k] >> i & 1) a[k] ^= a[r];
}
++r;
}
ll x = 0;
rep(j, r) {
x = x ^ a[j];
}
ans += x * 2;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
if(n<3)
cout<<0;
else if (n%3==0)
cout<<n/3;
else if(n%3!=0){
while(true){
n++;
if(n%3==0){
cout<<n/3-1;
break;
}
}
}
return 0;
} | #include<bits/stdc++.h>
//#define <- プログラムの文字列を置換する
//typedef <- 新しい型に名前を付けるためのキーワード
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const long long MOD = 1e9 + 7;
const long long INF = 1e15;
const int INF_INT = 1e9;
template<class TYPE>
struct edge{
TYPE to,cost;
edge(TYPE t,TYPE c){
to = t;
cost = c;
}
};
int main(){
int N;
cin >> N;
cout << N / 3 << endl;
return 0;
}
| 1 |
//雪花飄飄北風嘯嘯
//天地一片蒼茫
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
#define ll long long
#define ii pair<ll,ll>
#define iii pair<ii,ll>
#define fi first
#define se second
#define endl '\n'
#define debug(x) cout << #x << " is " << x << endl;
#define rep(x,start,end) for(auto x=(start)-((start)>(end));x!=(end)-((start)>(end));((start)<(end)?x++:x--))
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
#define indexed_set tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update>
//change less to less_equal for non distinct pbds, but erase will bug
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
int n;
int arr[200005];
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin>>n;
rep(x,0,n) cin>>arr[x];
int curr=0;
ll ans=0;
if (arr[0]!=0){
cout<<"-1"<<endl;
return 0;
}
rep(x,0,n){
if (curr+1<arr[x]){
cout<<"-1"<<endl;
return 0;
}
else if (curr+1==arr[x]){
ans++;
}
else{
ans+=arr[x];
}
curr=arr[x];
}
cout<<ans<<endl;
}
| #include<bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define PI acos(-1)
#define pcnt __builtin_popcountll
#define rng(a) a.begin(), a.end()
#define sz(x) (int)(x).size()
#define v(T) vector<T>
#define vv(T) v(v(T))
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
template<typename T>inline istream& operator>>(istream&i,v(T)&v)
{rep(j,sz(v))i>>v[j];return i;}
template<typename T1,typename T2>inline istream& operator>>(istream&i,pair<T1,T2>&v)
{return i>>v.fi>>v.se;}
template<class T> inline bool chmax(T& a, T b) {if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) {if (a > b) { a = b; return true; } return false; }
ll INF = 1001001001;
ll LINF = 1001001001001001001ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin>>n;
vl as(n);
cin>>as;
if (n == 1) {
if (as[0]) cout<<-1<<endl;
else cout<<0<<endl;
return 0;
}
ll ans = as.back();
for (int i = n - 2; i >= 0; --i) {
if (as[i] > i) {
cout<<-1<<endl;
return 0;
}
if (as[i] + 1 < as[i + 1]) {
cout<<-1<<endl;
return 0;
}
if (as[i] + 1 == as[i + 1]) continue;
ans += as[i];
}
cout<<ans<<endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define M ((ll)(1e9)+7)
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
typedef long long ll;
ll power(ll x,ll y)
{
if(y==0)
return 1;
ll res=power(x,y/2);
res=(res*res)%M;
if(y&1)
res=(res*x)%M;
return res;
}
void solve()
{
ll h,w,a,b,va;
cin>>h>>w>>a>>b;
a=h-a+1;
ll ta=a-1,tb=b+1;
ll fact[200001];fact[0]=1;
for(ll i=1;i<200001;i++)
fact[i]=(fact[i-1]*i)%M;
vector<ll> v,v1;
for(ll i=tb;i<=w;i++)
{
va=fact[i+ta-2];
va=(va*power(fact[i-1],M-2))%M;
va=(va*power(fact[ta-1],M-2))%M;
v.pb(va);
}
for(ll i=tb;i<=w;i++)
{
va=fact[h+w-a-i];
va=(va*power(fact[h-a],M-2))%M;
va=(va*power(fact[w-i],M-2))%M;
v1.pb(va);
}
//cout<<v[0]<<" "<<v[1]<<" "<<v1[0]<<" "<<v1[1]<<endl;
ll ans=0;
for(int i=0;i<v.size();i++)
{
ans=(ans+(v[i]*v1[i])%M)%M;
}
cout<<ans<<endl;
}
int main()
{
solve();
}
| #include<cstdio>
typedef long long ll;
const ll mod=998244353;
inline ll rev(ll x)
{ll k=mod-2,r=1;for(;k;k>>=1,(x*=x)%=mod)if(k&1)(r*=x)%=mod;return r;}
ll fac[1111111],inv[1111111];
inline ll C(int n,int r)
{return((((fac[n]*inv[r])%mod)*inv[n-r])%mod);}
int main()
{
int n,m;
scanf("%d%d",&n,&m);
if(n<m)n^=m,m^=n,n^=m;
fac[0]=inv[0]=1;
register int i;
for(i=1;i<=n+m;i++)fac[i]=(fac[i-1]*i)%mod;
inv[n+m]=rev(fac[n+m]);
for(i=n+m-1;i;i--)inv[i]=inv[i+1]*(i+1)%mod;
ll ans=0;
for(i=1;i<=m;i++)
(ans+=C(i*2,i)*C(n+m-2*i,n-i))%=mod;
(((ans*=rev(2*C(n+m,n)))%=mod)+=n+mod)%=mod;
printf("%lld\n",ans);
} | 0 |
#include<bits/stdc++.h>
#define _ ios_base::sync_with_stdio(0);cin.tie(0);
#define REP(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
const int MAX_W=20;
const int DIRECTIONS=4;//0:up/1:right/2:down/3:left
const int MAX_DEPTH=10;
const int INF=1<<27;
struct tpl{
int ary[MAX_W][MAX_W];
int depth;
int last;
int x;
int y;
};
int w,h;
int dfs(const tpl& t){
int minDepth=INF;
if(t.depth+1>MAX_DEPTH)return minDepth;
REP(i,DIRECTIONS){
tpl u;
u.depth=t.depth+1;
u.last=i;
REP(j,h)REP(k,w)u.ary[j][k]=t.ary[j][k];
u.x=t.x;
u.y=t.y;
if(i==0&&u.y>0&&u.ary[u.y-1][u.x]!=1){
for(;u.y>=0;u.y--){
if(u.ary[u.y][u.x]==3){
minDepth=min(minDepth,u.depth);
break;
}else if(u.y>0&&u.ary[u.y-1][u.x]==1){
u.ary[u.y-1][u.x]=0;
minDepth=min(minDepth,dfs(u));
break;
}
}
}else if(i==1&&u.x<w-1&&u.ary[u.y][u.x+1]!=1){
for(;u.x<=w-1;u.x++){
if(u.ary[u.y][u.x]==3){
minDepth=min(minDepth,u.depth);
break;
}else if(u.x<w-1&&u.ary[u.y][u.x+1]==1){
u.ary[u.y][u.x+1]=0;
minDepth=min(minDepth,dfs(u));
break;
}
}
}else if(i==2&&u.y<h-1&&u.ary[u.y+1][u.x]!=1){
for(;u.y<=h-1;u.y++){
if(u.ary[u.y][u.x]==3){
minDepth=min(minDepth,u.depth);
break;
}else if(u.y<h-1&&u.ary[u.y+1][u.x]==1){
u.ary[u.y+1][u.x]=0;
minDepth=min(minDepth,dfs(u));
break;
}
}
}else if(i==3&&u.x>0&&u.ary[u.y][u.x-1]!=1){
for(;u.x>=0;u.x--){
if(u.ary[u.y][u.x]==3){
minDepth=min(minDepth,u.depth);
break;
}else if(u.x>0&&u.ary[u.y][u.x-1]==1){
u.ary[u.y][u.x-1]=0;
minDepth=min(minDepth,dfs(u));
break;
}
}
}
}
return minDepth;
}
void solve(const tpl& t){
int result=dfs(t);
cout<<(result==INF?-1:result)<<endl;
}
int main(){ _;
while(cin>>w>>h,(w|h)!=0){
tpl t;
t.depth=0;
t.last=-1;
REP(i,h)REP(j,w){
cin>>t.ary[i][j];
if(t.ary[i][j]==2){
t.ary[i][j]=0;
t.x=j;
t.y=i;
}
}
solve(t);
}
} | #include<iostream>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<vector>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<time.h>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
const double PI=acos(-1);
const double EPS=1e-10;
const int inf=1e8;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
int main(){
int n,m;
while(cin>>n>>m,n+m){
vi in(n+1);
rep(i,n)cin>>in[i+1];
vi cro;
rep(i,n+1)rep(j,n+1)cro.pb(in[i]+in[j]);
sort(all(cro));
int out=0;
rep(i,cro.size()){
int d=m-cro[i];
int h=cro.size();
int l=0;
while(1){
if(h-l==1)break;
int t=(h+l)/2;
if(cro[t]>d)h=t;
else l=t;
}
if(cro[i]+cro[l]<=m)out=max(out,cro[i]+cro[l]);
}
cout<<out<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define pb push_back
#define mp make_pair
#define fr first
#define sc second
const int mod=998244353;
LL jc[2500005];
void add(LL &x,LL y){x=(x+y)%mod;}
LL sqrr(LL x){return x*x%mod;}
LL ksm(LL x,int y){
if (y==0) return 1;if (y==1) return x;
LL ans=sqrr(ksm(x,y>>1));
if (y&1) ans=ans*x%mod;
return ans;
}
LL ny(LL x){return ksm(x,mod-2);}
LL C(int n,int m){return jc[n]*ny(jc[m])%mod*ny(jc[n-m])%mod;}
LL calf(int n,int s){
return C(n+s-1,s);
}
LL cal1(int n,int m,int k){
if (k>n) return 0;
if ((k^m)&1) return 0;
return C(n,k)*calf(n,(m*3-k)/2)%mod;
}
LL cal2(int n,int m,int k){
if (k>n) return 0;
return C(n,k)*k%mod*calf(k,m-k)%mod;
}
void init(){
const int n=2500000;
jc[0]=1;
for (int i=1;i<=n;i++) jc[i]=jc[i-1]*i%mod;
}
int main(){
// freopen("in.txt","r",stdin);
// freopen("out.txt","w",stdout);
init();
int n,m,m3;cin>>n>>m;m3=m*3;
LL ans=calf(n,m3);
for (int i=m+1;i<=m3;i++) add(ans,mod-cal1(n,m,i));
for (int i=1;i<=m;i++) add(ans,mod-cal2(n,m,i));
cout<<ans<<endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int main(){
int n,k;
cin >> n >> k;
vector<int>a(n);
vector<double>kit(n);
for(int i=0;i<n;i++){
cin >> a.at(i);
kit.at(i)=(a.at(i)+1.0)/2;
}
double ans=0,bf=0;
for(int i=0;i<k;i++)
bf+=kit.at(i);
ans=bf;
for(int i=k;i<n;i++){
bf+=kit.at(i)-kit.at(i-k);
ans=max(ans,bf);
}
cout << setprecision(9) << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,X,ans=0;
cin >> N >> X;
vector<int>vec(N);
for(int i=0; i<N; i++){
cin >> vec[i];
}
sort(vec.begin(),vec.end());
for(int i=0; i<N; i++){
if(X<vec[i]){
break;
}
else{
ans++;
X -= vec[i];
}
}
if(ans == N && X>0){
ans--;
}
cout << ans << endl;
}
| //
// main.cpp
// ITP1_6-A
//
// Created by Saicj on 2015/07/14.
// Copyright (c) 2015??´ saicj. All rights reserved.
//
#include <iostream>
#include <stdio.h>
using namespace std;
int main(int argc, const char * argv[])
{
int n;
int index = 0;
cin >> n;
int numList[n];
while (true) {
int temp;
cin >> temp;
numList[index] = temp;
index++;
if (index >= n){
break;
}
}
for (int i = index-1; i >= 0; i--) {
if (i == 0){
printf("%d",numList[0]);
break;
}
printf("%d ",numList[i]);
}
printf("\n");
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define vi vector<int>
int solve(int k, vi& xs){
sort(xs.begin(), xs.end()); //ordena o vector
//xs.back() --> Returns a reference to the last element in the vector
xs.back() *= (1<<k); // shiftar 1 vez pra esquerda eh multiplicar por 2
return accumulate(xs.begin(), xs.end(), 0);
}
int main(){
vi xs(3);
for(int i=0;i<3;i++)
cin>>xs[i];
int k;
cin>>k;
auto ans = solve(k, xs);
cout<<ans<<'\n'<<endl;
return 0;
} | #include <iostream>
#include <map>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <sstream>
#include <cmath>
#include <math.h>
#include <string>
#include <set>
#include <queue>
#include <utility>
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
double a , b , c , k;
cin >> a >> b >> c >> k;
cout << a + b + c - max( a , max( b , c ) ) + max( a , max( b , c ) ) * pow( 2 , k );
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef vector<vector<char>> matrix;
typedef long long ll;
int N;
matrix ans;
matrix make_m(int n) {
matrix m(n, vector<char>(n, '.'));
if (n == 3) {
m[0][0] = m[0][1] = 'a';
m[1][2] = m[2][2] = 'a';
}
else if (n == 4) {
m[0][0] = m[0][1] = m[2][2] = m[2][3] = 'a';
m[0][2] = m[1][2] = m[2][0] = m[3][0] = m[3][2] = m[3][3] = 'b';
m[0][3] = m[1][0] = m[1][1] = m[1][3] = 'c';
m[2][1] = m[3][1] = 'd';
}
else if (n == 5) {
m[0][0] = m[0][1] = m[4][3] = m[4][4] = 'a';
m[0][2] = m[0][3] = m[1][0] = m[2][0] = m[2][4] = m[3][4] = m[4][1] = m[4][2] = 'b';
m[0][4] = m[1][1] = m[1][2] = m[1][4] = m[2][3] = m[3][0] = m[3][3] = m[4][0] = 'c';
}
else if (n == 6) {
m[0][0] = m[0][1] = m[1][2] = m[1][3] = m[2][5] = m[3][5] = m[5][1] = m[5][2] = 'a';
m[0][2] = m[0][3] = m[1][0] = m[2][0] = m[5][3] = m[5][4] = 'b';
m[0][4] = m[0][5] = m[1][1] = m[2][1] = m[3][0] = m[4][0] = m[4][5] = m[5][5] = 'c';
m[3][4] = m[4][4] = 'd';
}
else if (n == 7) {
m[0][0] = m[0][1] = m[1][6] = m[2][6] = m[5][3] = m[5][4] = m[6][1] = m[6][2] = 'a';
m[0][2] = m[0][3] = m[1][0] = m[2][0] = m[3][6] = m[4][6] = m[6][3] = m[6][4] = 'b';
m[0][4] = m[0][5] = m[1][1] = m[1][2] = m[2][5] = m[3][0] = m[3][5] = m[4][0] = m[5][6] = m[6][6] = 'c';
m[4][5] = m[5][5] = 'd';
}
return m;
}
int main() {
cin >> N;
if (N == 2) {
cout << -1 << endl;
return 0;
}
ans = matrix(N, vector<char>(N, '.'));
if (N < 8) ans = make_m(N);
else if (N % 4 == 0) {
matrix m4 = make_m(4);
rep(k, N / 4) {
rep(i, 4) rep(j, 4) {
ans[k*4+i][k*4+j] = m4[i][j];
}
}
}
else {
matrix m4 = make_m(4);
int x = 4 + (N % 4);
matrix mx = make_m(x);
rep(k, (N - x) / 4) {
rep(i, 4) rep(j, 4) {
ans[k*4+i][k*4+j] = m4[i][j];
}
}
int k = N - x;
rep(i, x) rep(j, x) {
ans[k+i][k+j] = mx[i][j];
}
}
rep(i, N) {
rep(j, N) cout << ans[i][j];
cout << endl;
}
}
| /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <iostream>
#include <fstream>
#include <bits/stdc++.h>
using namespace std;
char piece[10][10][10];
bool DONE = false;
typedef pair<int, int> pii;
vector<pair<pii, pii>> placement[10];
int done[10][10];
vector<pair<pii, pii>> doms;
class CDominoQuality {
public:
bool okrow(int n, int row) {
if (row < 0) return true;
int cnt = 0;
for (int j = 0; j < n; j++) {
if (!done[row][j]) continue;
if (j == 0 || (done[row][j] != done[row][j - 1])) cnt++;
}
return cnt == 3;
}
bool okcol(int n, int col) {
if (col < 0) return true;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (!done[i][col]) continue;
if (i == 0 || (done[i][col] != done[i - 1][col])) cnt++;
}
return cnt == 3;
}
void dfs(int n, int p) {
if (DONE) return;
if (p % n == 0) {
int row = p / n - 1;
if (!okrow(n, row - 1)) return;
if (p == n * n) {
for (int i = 0; i < n; i++) {
if (!okcol(n, i)) {
return;
}
}
placement[n] = doms;
DONE = true;
return;
}
}
dfs(n, p + 1);
int r = p / n, c = p % n;
if (c < n - 1 && !done[r][c + 1] && !done[r][c]) {
doms.push_back({{r, c}, {r, c + 1}});
done[r][c + 1] = done[r][c] = p + 1;
dfs(n, p + 1);
done[r][c + 1] = done[r][c] = 0;
doms.pop_back();
}
if (r < n - 1 && !done[r + 1][c] && !done[r][c]) {
doms.push_back({{r, c}, {r + 1, c}});
done[r + 1][c] = done[r][c] = p + 1;
dfs(n, p + 1);
done[r + 1][c] = done[r][c] = 0;
doms.pop_back();
}
}
void solve(std::istream& in, std::ostream& out) {
int n;
in >> n;
if (n == 2) {
out << -1 << endl;
return;
}
if (n == 3) {
out << "aa.\n";
out << "..b\n";
out << "..b\n";
return;
}
memset(piece, '.', sizeof piece);
for (int i = 4; i <= 7; i++) {
DONE = false;
dfs(i, 0);
for (int j = 0; j < placement[i].size(); j++) {
auto p = placement[i][j];
int r1 = p.first.first, c1 = p.first.second, r2 = p.second.first, c2 = p.second.second;
piece[i][r1][c1] = piece[i][r2][c2] = j + 'a';
}
}
int rep = n / 4 - 1, left = n % 4 + 4;
vector<vector<char>> res(n, vector<char>(n, '.'));
for (int k = 0; k < rep; k++) {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
res[k * 4 + i][k * 4 + j] = piece[4][i][j];
}
}
}
for (int i = 0; i < left; i++) {
for (int j = 0; j < left; j++) {
res[rep * 4 + i][rep * 4 + j] = piece[left][i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
out << res[i][j];
out << "\n";
}
}
};
int main() {
CDominoQuality solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 1 |
#pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
using vi = vector<int>;
constexpr char newl = '\n';
constexpr double eps = 1e-10;
#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define F0R(i,b) FOR(i,0,b)
#define RFO(i,a,b) for (int i = ((b)-1); i >=(a); i--)
#define RF0(i,b) RFO(i,0,b)
#define fi first
#define se second
#define show(x) cout << #x << " = " << x << '\n';
#define rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()
#define sz(x) (int)(x).size()
#define YesNo {cout<<"Yes";}else{cout<<"No";}
#define YESNO {cout<<"YES";}else{cout<<"NO";}
#define v(T) vector<T>
template<typename T1, typename T2> inline void chmin(T1& a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> inline void chmax(T1& a, T2 b) { if (a < b) a = b; }
template<class T> bool lcmp(const pair<T, T>& l, const pair<T, T>& r) {
return l.first < r.first;
}
template<class T> istream& operator>>(istream& i, v(T)& v) {
F0R(j, sz(v)) i >> v[j];
return i;
}
template<class A, class B> istream& operator>>(istream& i, pair<A, B>& p) {
return i >> p.first >> p.second;
}
template<class A, class B, class C> istream& operator>>(istream& i, tuple<A, B, C>& t) {
return i >> get<0>(t) >> get<1>(t) >> get<2>(t);
}
template<class T> ostream& operator<<(ostream& o, const vector<T>& v) {
F0R(i, v.size()) {
o << v[i] << ' ';
}
o << newl;
return o;
}
template<class T1, class T2> ostream& operator<<(ostream& o, const map<T1, T2>& m) {
for (auto& p : m) {
o << p.first << ": " << p.second << newl;
}
o << newl;
return o;
}
#if 1
// INSERT ABOVE HERE
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int N, K;
cin >> N >> K;
queue<int> q;
int rs = INT32_MAX;
F0R(i, N) {
int x;
cin >> x;
q.push(x);
if (q.size() == K) {
int l = q.front(), r = q.back();
int score;
if (l < 0) {
if (r > 0) {
score = min(abs(l), abs(r)) + r - l;
}
else {
score = abs(l);
}
}
else {
score = abs(r);
}
chmin(rs, score);
q.pop();
}
}
cout << rs;
}
#endif
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define sz(x) int((x).size())
#define all(x) (x).begin(), (x).end()
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
typedef tree<
ll,
null_type,
less<ll>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
// ordered_set X;
// *X.find_by_order(i) = ith largest element (counting from zero)
// X.order_of_key(k) = number of items in X < k (strict lt)
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int N;
ll x;
cin >> N >> x;
vll A(N);
for (int i=0;i<N;i++) cin >> A[i];
sort(all(A));
int ans = 0;
for (int i=0;i<N;i++) {
if (x >= A[i]) {
x-= A[i];
ans++;
}
}
if (x > 0 && ans == N) ans = N-1;
cout << ans << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
const int mod=1e9+7;
const int N = 2e5+5;
vector<ll>ans,veca,vecb;
vector<int>adj[N];
vector<double>aka;
vector<pair<int,double>>dp[N];
vector<bool>vis;
void init(int n){
ans.clear();veca.clear();aka.clear();vis.clear();ans.resize(n);
vecb.clear(),vecb.resize(n);veca.resize(n);vis.resize(n);
for (int i = 0; i <n; i++) {
vis[i]=0;
}
for (int i = 0; i<=n; i++) {
adj[i].clear();
}
for (int i = 0; i <=n; i++) {
dp[i].clear();
}
for (int i = 0; i < n; i++) {
ans[i]=0;
}
}
int check(int a,int b,int c){
int res=0;
if(a+b>c) res=1;
return res;
}
bool valid(int a,int b,int c){
if((a<b)&&(b<c)) return 0;
return 1;
}
void solve(){
int n,flag=0;
cin>>n;
init(n);
for (int i = 0; i <n; i++) {
cin>>veca[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if(!valid(i,j,k)){
set<int>st;vector<int>vec;
st.insert(veca[i]);st.insert(veca[j]);st.insert(veca[k]);
vec.push_back(veca[i]);vec.push_back(veca[j]);vec.push_back(veca[k]);
if(st.size()==3){
sort(vec.begin(),vec.end());
flag+=check(vec[0],vec[1],vec[2]);
}
}
}
}
}
cout<<flag<<"\n";
}
int main(){
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int T=1;
//cin>>T;
while(T--){
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) \
for (int i = 0; i < (int)(n); i++) \
;
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 0
int main() {
int n;
cin >> n;
vector<long> l(n);
for (long &x : l) {
cin >> x;
}
long ans = 0;
for (int i = 0; i < n - 2; i++) {
for (int j = i + 1; j < n - 1; j++) {
for (int k = j + 1; k < n; k++) {
long sum = 0;
long mx = 0;
sum = l.at(i) + l.at(j) + l.at(k);
mx = max(l.at(i), max(l.at(j), l.at(k)));
if (sum <= 2 * mx) {
continue;
}
if (l.at(i) != l.at(j) && l.at(j) != l.at(k) && l.at(k) != l.at(i)) {
ans++;
}
}
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define pb push_back
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ll long long
using namespace std;
const ll P = 1000000007;
const long long INF = 1LL << 60;
int gcd(int a, int b) { return b != 0 ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int main()
{
cout << fixed << setprecision(10);
int N;
cin >> N;
vector<ll> A(N);
int count = 0;
ll m = P;
rep(i,N)
{
cin >> A[i];
if(A[i]<0)
{
count ++;
A[i] = -1 * A[i];
}
m = min(m,A[i]);
}
ll sum = 0;
rep(i,N)
{
sum += A[i];
}
if(count%2==0)
{
cout << sum << endl;
}
else
{
cout << sum - m * 2 << endl;
}
return 0;
}
| #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
ll const INF = 1LL << 60;
int main() {
ll N;
cin >> N;
vector<ll> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
vector<vector<ll>> memo(N + 1, vector<ll>(2));
memo[0][0] = 0;
memo[0][1] = -INF;
for (int i = 0; i < N; i++) {
memo[i + 1][0] = max(memo[i][0] + A[i], memo[i][1] - A[i]);
memo[i + 1][1] = max(memo[i][0] - A[i], memo[i][1] + A[i]);
}
cout << memo[N][0] << endl;
return 0;
} | 1 |
#include <iostream>
#include <functional>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <set>
#include <queue>
#include <stack>
#include <map>
#include <iomanip>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;++i)
#define repi(i,n) for(ll i=n-1;i>=0;--i)
#define sll(n) scanf("%lld", &n);
#define slf(n) scanf("%lf", &n);
#define pii pair<int, int>
#define pll pair<ll, ll>
typedef long long ll;
typedef double lf;
typedef long long ll;
// const int mod = 1000000007;
const int mod = 998244353;
// vector<string> Qs(max_n);
bool check(vector<pll> ps){
ll h = 0;
for(auto p:ps){
ll b = h + p.first;
if(b < 0) return false;
h = h + p.second;
}
return true;
}
void Main(){
ll N;
string s;
sll(N);
vector<pll> ls, rs;
ll total = 0;
rep(i, N){
cin >> s;
ll h = 0, b = 0;
for(auto c:s){
if(c=='(') h++; else h--;
b = min(b, h);
}
if(h>=0) ls.emplace_back(b, h);
else rs.emplace_back(b-h, -h);
total += h;
}
sort(ls.rbegin(), ls.rend());
sort(rs.rbegin(), rs.rend());
if(check(ls) && check(rs) && total == 0){
printf("Yes\n");
}else{
printf("No\n");
}
}
int main(){
Main();
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1LL << 60;
ll N, K;
vector<ll> v;
int main() {
cin >> N >> K;
v.resize(N);
rep(i, N) cin >> v[i];
ll ans = 0;
for (int l = 0; l <= K; l++) {
for (int r = 0; r <= K - l; r++) {
if (l + r > N) continue;
// 戻せる回数
int d = K - (l + r);
vector<ll> calc;
ll tmp = 0;
// 左からとる
// cout << "pat1 l " << l << " r: " << r << " " << tmp << endl;
// [0, l)
for (int k = 0; k < l; k++) {
calc.push_back(v[k]);
tmp += v[k];
}
// 右からとる
// cout << "pat2 l " << l << " r: " << r << " " << tmp << endl;
// [N - r, N)
for (int k = 0; k < r; k++) {
calc.push_back(v[N - 1 - k]);
tmp += v[N - 1 - k];
}
sort(calc.begin(), calc.end());
// cout << "pat3 l " << l << " r: " << r << " " << tmp << endl;
// 戻す
for (int k = 0; k < min(d, (int)calc.size()); k++) {
if (calc[k] > 0) break;
tmp -= calc[k];
}
// cout << "l " << l << " r: " << r << " " << tmp << endl;
ans = max(tmp, ans);
}
}
cout << ans << endl;
} | 0 |
// include
// ------------------------------------------------
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
// func
// ------------------------------------------------
int CalcSumOfDigit(int n); // 各桁の和を計算する。
int getDigit(int n); // 数字の桁数を取得する。
string upper(string str); // 英字を大文字に変換する。
string lower(string str); // 英字を小文字に変換する。
vector<pair<long long,long long>> prime_factorize(long long p); // 素因数分解
// class
// ------------------------------------------------
class Combi {
public:
Combi();
long long Combination(long long n, long long k);
long long nPk_modp(long long n, long long k, long long p);
private:
map<long long, map<long long, long long>> memo;
long long n_num;
long long k_num;
};
// define
// ------------------------------------------------
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define sz(a) int((a).size())
#define rep(i,n) for(long long(i)=0;(i)<(n);(i)++)
#define repe(i,n) for(long long(i)=0;(i)<=(n);(i)++)
#define vsort(v) sort((v).begin(),(v).end())
#define rvsort(v) sort(rall((v)))
#define vi vector<int>
#define GCD(a,b) __gcd((a),(b))
#define LCM(a,b) (a)/GCD((a),(b))*(b)
#define kiriage(a,b) ((a)+(b)-1)/(b)
const int INF = 1e9;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<long> vll;
// code
// ------------------------------------------------
int main() {
ll n;cin >> n;
vll a(n);
rep(i,n) cin >> a[i];
ll sum = 0;
rep(i,n) sum += a[i];
double ave = (double)sum / n;
ll ans = 0;
double dif = abs(ave - a[0]);
rep(i,n){
if(abs(ave - a[i]) < dif){
dif = abs(ave - a[i]);
ans = i;
}
}
cout << ans << endl;
return 0;
}
// funcの実体
// ------------------------------------------------
int getDigit(int n) {
int i = 1;
while(1) {
n = n / 10;
if(n == 1)
break;
i++;
}
return i;
}
int CalcSumOfDigit(int n) {
int s = 0;
while(n) {
s += n % 10;
n = n / 10;
}
return s;
}
string upper(string str) {
for(auto itr = str.begin();itr != str.end() ; itr++) {
if(97 <= *itr && *itr <= 122) {
*itr = *itr - 32;
}
}
return str;
}
string lower(string str) {
for(auto itr = str.begin();itr != str.end() ; itr++) {
if(65 <= *itr && *itr <= 90) {
*itr = *itr + 32;
}
}
return str;
}
Combi::Combi() {
n_num = -1;
k_num = -1;
};
ll Combi::Combination(ll n, ll k) {
ll ret;
if(memo[n][k] != 0) {
ret = memo[n][k];
} else if(n == k || k == 0) {
memo[n][k] = 1;
ret = 1;
} else {
ret = Combination(n - 1, k - 1) + Combination(n - 1, k);
memo[n][k] = ret;
}
return ret;
}
long long Combi::nPk_modp(long long n, long long k, long long p) {
ll ans = 1;
for(long long i = k; i <= n; i++) {
ans = (ans * i) % p;
}
return ans;
};
vector<pair<long long,long long>> prime_factorize(long long p) {
vector<pair<long long,long long>> ret;
for(long long x = 2; x * x <= p; ++x) {
if(p % x != 0) continue;
long long num = 0;
while(p % x == 0) {
num++;
p /= x;
}
ret.push_back(make_pair(x,num));
}
if(p != 1) ret.push_back(make_pair(p, 1));
return ret;
}
| /*
"Won't stop until I'm phenomenal."
- Phenomenal, Eminem
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define ff first
#define Shazam ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define ss second
#define all(c) c.begin(),c.end()
#define endl "\n"
#define test() int t; cin>>t; while(t--)
#define fl(i,a,b) for(int i = a ; i <b ;i++)
#define get(a) fl(i,0,a.size()) cin>>a[i];
#define pra(a) fl(i,0,a.size()) cout<<a[i]<<" "; cout<<endl;
#define pr(a,n) fl(i,0,n) cout<<a[i]<<" "; cout<<endl;
const ll INF = 2e18;
const int inf = 2e9;
const int mod1 = 1e9 + 7;
int main(){
Shazam;
int n; cin>>n;
vector<int> a(n+1);
for(int i = 1; i <= n; i++) cin>>a[i];
int res = 0;
vector<int> ans(n+1);
for(int i = n; i>0; i--){
int curr = 0;
for(int j = 2*i; j <=n; j+=i){
curr+=ans[j];
}
if ((curr & 1) != (a[i] & 1)){
ans[i] = 1;
res++;
}
}
cout<<res<<endl;
for(int i = 1; i <= n; i++){
if(ans[i])
cout<<i<<" ";
}
cout<<endl;/* */
return 0;
} | 0 |
#include <iostream>
using namespace std;
int a[100005];
int main() {
int n,q = -1,count = 1;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int j = 0; j < n-1; j++) {
if (a[j] <= a[n-1]) {
q++;
int v = a[j];
a[j] = a[q];
a[q] = v;
}
}
int v = a[q+1];
a[q+1] = a[n-1];
a[n-1] = v;
for (int k = 0; k < n; k++) {
cout << (k == q+1?"[":"") << a[k] << (k == q+1?"]":"") << (k == n-1?"":" ");
}
cout << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int n;
int a[5000];
while(cin >> n && n>0){
for(int i=0;i<n;i++)
cin >> a[i];
long long sum=0,tmp=0,ma=-100000;
int m=-100000;
bool flg=true;
for(int i=0;i<n;i++){
if(flg) m=max(m,a[i]);
if(a[i]>=0){
flg=false;
sum+=a[i];
continue;
}
ma=ma>sum?ma:sum;
for(tmp=sum;i<n && a[i]<0;i++){
tmp+=a[i];
}i--;
if(tmp>0)
sum=tmp;
else
sum=0;
}
ma=ma>sum?ma:sum;
cout << (flg?m:ma) << endl;
}
} | 0 |
#include <iostream>
#include <vector>
#include <limits.h>
#include <algorithm>
#include <string>
#include <math.h>
#include <limits.h>
#include <queue>
#include <map>
#include <set>
#include <iomanip>
#include <bitset>
#include <cassert>
#include <random>
#include <functional>
#include <stack>
#include <iomanip>
#include <cassert>
//#include <boost/multiprecision/cpp_int.hpp>
#include <complex>
#include <cstdio>
#include <list>
#include <bitset>
//< in.txt > out.txt
using namespace std;
//std::ios::sync_with_stdio(false);
//std::cin.tie(0);
const long long MOD = 998244353;
const long long INF = 1e18;
typedef long long LL;
typedef long double LD;
typedef pair<LL, LL> PLL;
typedef pair<LD, LL> pdl;
typedef pair<LD, LD> pdd;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef unsigned long long ULL;
//typedef boost::multiprecision::cpp_int bigint;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
LL N;
cin >> N;
string S;
cin >> S;
VLL M(2 * N + 1, 0), C(2 * N + 1,0);
VLL Ds;
for (LL n = 0; n < N; n++) {
if (S[n] == 'D')Ds.push_back(n + 1);
if (S[n] == 'M')M[n + 1]++;
if (S[n] == 'C')C[n + 1]++;
M[n + 1] += M[n];
C[n + 1] += C[n];
}
for (LL n = N + 1; n <= 2 * N; n++) {
M[n] = M[n - 1];
C[n] = C[n - 1];
}
VLL DP(2 * N + 1, 0);
for (LL n = N; n >= 1; n--) {
DP[n] = DP[n + 1];
if (S[n - 1] == 'M')DP[n] += C.back() - C[n];
}
LL Q;
cin >> Q;
for (LL q = 0; q < Q; q++) {
LL K;
cin >> K;
LL ans = 0;
for (LL d : Ds) {
LL temp = DP[d + 1] - DP[d + K] - (M[d + K - 1] - M[d]) * (C.back() - C[d + K-1]);
ans += temp;
}
cout << ans << "\n";
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(void) {
long long N, Q;
string S;
cin >> N >> S >> Q;
vector<int> k(Q);
for (int i = 0; i < Q; i++) {
cin >> k[i];
}
for (int j = 0; j < Q; j++) {
long long d = 0, m = 0, dm = 0, ans = 0;
for (int i = 0; i < N; i++) {
if (i >= k[j]) {
if (S[i - k[j]] == 'D') {
d--;
dm -= m;
}
if (S[i - k[j]] == 'M') m--;
}
if (S[i] == 'D') d++;
if (S[i] == 'M') {
m++;
dm += d;
}
if (S[i] == 'C') {
ans += dm;
}
}
cout << ans << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using pint = pair<int, int>;
using ll = long long;
using ull = unsigned long long;
using vll = vector<long long>;
using pll = pair<ll, ll>;
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define VREP(s, ite) for (auto ite = s.begin(); ite != s.end(); ++ite)
#define FI first
#define SE second
#define ALL(v) v.begin(), v.end()
//#define endl "\n"
#define ciosup \
cin.tie(0); \
ios::sync_with_stdio(false);
#define eb emplace_back
#define vint vector<int>
constexpr ll INF = 1e15 + 7LL;
constexpr ll MOD = 1e9 + 7LL;
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
is >> v[i];
}
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size() - 1; ++i) {
os << v[i] << " ";
}
if (v.size() > 0) {
os << v[v.size() - 1] << endl;
}
return os;
}
int main() {
int n,t;
cin >> n >> t;
vint a(n), b(n);
REP(i, n) { cin >> a[i] >> b[i]; }
vector<vll> dp(n + 1, vll(6000 + 1, 0)), dp2(n + 1, vll(6000 + 1, 0));
//REP(i, n + 1) { REP(j,6000) {dp[i][j] = 0;} }
REP(i,n){
REP(j,6000){
if (dp[i][j] != -1) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
if (j + a[i]<= 6000) dp[i + 1][j + a[i]] = max(dp[i + 1][j + a[i]], dp[i][j] + b[i]);
}
if (j > 0) dp[i + 1][j] = max(dp[i + 1][j], dp[i + 1][j - 1]);
}
}
//REP(i, n + 1) { dp2[i][0] = 0; }
IREP(i, n) {
REP(j, 6000) {
if (dp2[i][j] != -1) {
dp2[i][j] = max(dp2[i][j], dp2[i + 1][j]);
if (j + a[i] <= 6000)
dp2[i][j + a[i]] = max(dp2[i][j + a[i]], dp2[i + 1][j] + b[i]);
}
if (j > 0) dp[i][j] = max(dp[i][j], dp[i][j - 1]);
}
}
ll ans = 0;
REP(i,n){
REP(j, t) { ans = max(ans, b[i] + dp[i][j] + dp2[i+1][t - 1 - j]); }
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define ar array
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T> using oset = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define vt vector
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define sz(x) (int)(x).size()
#define F_OR(i, a, b, s) for (int i=(a); (s)>0?i<(b):i>(b); i+=(s))
#define F_OR1(e) F_OR(i, 0, e, 1)
#define F_OR2(i, e) F_OR(i, 0, e, 1)
#define F_OR3(i, b, e) F_OR(i, b, e, 1)
#define F_OR4(i, b, e, s) F_OR(i, b, e, s)
#define GET5(a, b, c, d, e, ...) e
#define F_ORC(...) GET5(__VA_ARGS__, F_OR4, F_OR3, F_OR2, F_OR1)
#define FOR(...) F_ORC(__VA_ARGS__)(__VA_ARGS__)
#define EACH(x, a) for (auto& x: a)
template<class A> void read(vt<A>& v);
template<class A, size_t S> void read(ar<A, S>& a);
template<class T> void read(T& x) {
cin >> x;
}
void read(double& d) {
string t;
read(t);
d=stod(t);
}
void read(long double& d) {
string t;
read(t);
d=stold(t);
}
template<class H, class... T> void read(H& h, T&... t) {
read(h);
read(t...);
}
template<class A> void read(vt<A>& x) {
EACH(a, x)
read(a);
}
template<class A, size_t S> void read(array<A, S>& x) {
EACH(a, x)
read(a);
}
string to_string(char c) {
return string(1, c);
}
string to_string(bool b) {
return b?"true":"false";
}
string to_string(const char* s) {
return string(s);
}
string to_string(string s) {
return s;
}
string to_string(vt<bool> v) {
string res;
FOR(sz(v))
res+=char('0'+v[i]);
return res;
}
template<size_t S> string to_string(bitset<S> b) {
string res;
FOR(S)
res+=char('0'+b[i]);
return res;
}
template<class T> string to_string(T v) {
bool f=1;
string res;
EACH(x, v) {
if(!f)
res+=' ';
f=0;
res+=to_string(x);
}
return res;
}
template<class A> void write(A x) {
cout << to_string(x);
}
template<class H, class... T> void write(const H& h, const T&... t) {
write(h);
write(t...);
}
void print() {
write("\n");
}
template<class H, class... T> void print(const H& h, const T&... t) {
write(h);
if(sizeof...(t))
write(' ');
print(t...);
}
void DBG() {
cerr << "]" << endl;
}
template<class H, class... T> void DBG(H h, T... t) {
cerr << to_string(h);
if(sizeof...(t))
cerr << ", ";
DBG(t...);
}
#ifdef _DEBUG
#define dbg(...) cerr << "LINE(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)
#else
#define dbg(...) 0
#endif
template<class T> void offset(ll o, T& x) {
x+=o;
}
template<class T> void offset(ll o, vt<T>& x) {
EACH(a, x)
offset(o, a);
}
template<class T, size_t S> void offset(ll o, ar<T, S>& x) {
EACH(a, x)
offset(o, a);
}
mt19937 mt_rng(chrono::steady_clock::now().time_since_epoch().count());
ll randint(ll a, ll b) {
return uniform_int_distribution<ll>(a, b)(mt_rng);
}
const int d4i[4]={-1, 0, 1, 0}, d4j[4]={0, 1, 0, -1};
const int d8i[8]={-1, -1, 0, 1, 1, 1, 0, -1}, d8j[8]={0, 1, 1, 1, 0, -1, -1, -1};
ll mod=1e9+7;
const int N=1e6+5;
const ld PI=2*acos(0.0);
ll modpow(ll a, ll b){
ll res=1; a%=mod;
while(b){
if(b&1){ res=(res*a)%mod;}
a=(a*a)%mod;
b>>=1;
}
return res;
}
#define lcm(a,b) ((a)*(b))/(__gcd(a,b))
bool compare(array<int,2> a,array<int,2> b){
return a[0]<b[0];
}
void solve() {
int n,t; read(n,t);
vt<array<int,2> > td(n+1);
FOR(i,1,n+1) read(td[i][0],td[i][1]);
sort(++td.begin(),td.end(),compare);
int siz=(*--td.end())[0]+t+5;
vt<int> dp(siz,0);
vt<int> pre(siz,0);
FOR(i,1,n+1){
FOR(j,1,siz){
if(j-td[i][0]<0||j-td[i][0]>=t) { dp[j]=pre[j];}
else{ dp[j]=max(pre[j],pre[j-td[i][0]]+td[i][1]);}
}
FOR(j,1,siz){ pre[j]=dp[j]; dp[j]=0; }
//dbg(i,pre);
}
print(*max_element(all(pre)));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 1 |
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define repi(i,a,b) for(ll i=(a);i<(b);++i)
#define rep(i,a) repi(i,0,a)
#define repdi(i,a,b) for(ll i=(a)-1;i>=(b);--i)
#define repd(i,a) repdi(i,a,0)
#define itr(it,a) for( auto it = (a).begin(); it != (a).end(); ++it )
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
using ll = long long;
using P = std::pair<ll, ll>;
constexpr ll INF = 1ll<<60;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class S, class T>
std::ostream& operator<< ( std::ostream& out, const std::pair<S,T>& a )
{ std::cout << '(' << a.first << ", " << a.second << ')'; return out; }
template<class T>
std::ostream &operator<< ( std::ostream& out, const std::vector<T>& a )
{ std::cout << '['; rep( i, a.size() ){ std::cout << a[i]; if( i != a.size()-1 ) std::cout << ", "; } std::cout << ']'; return out; }
ll A[2], B[2];
int main()
{
rep( i, 2 )
std::cin >> A[i];
rep( i, 2 )
std::cin >> B[i];
std::cout << std::min(A[0], A[1])+std::min(B[0], B[1]) << std::endl;
return 0;
} | #include <cstdio>
using ll = long long;
inline ll gcd(ll x, ll y)
{
while (y)
{
auto r = x % y;
x = y;
y = r;
}
return x;
}
inline bool chk(int n)
{
for (int i = 2; i * i <= n; i++)
{
if (!(n % i))
return false;
}
return true;
}
inline ll lcm(ll x, ll y) { return x && y ? x / gcd(x, y) * y : x + y; }
ll pri[1005], arr[505][505];
int main()
{
// freopen("AGC027-D.in", "r", stdin);
int n, cur = 0, len = 0;
scanf("%d", &n);
bool even = n & 1 ^ 1;
n += even;
for (int i = 2; len <= n * 2; i++)
{
if (chk(i))
pri[len++] = i;
}
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
arr[i][j] = 1;
}
for (int i = 0; i < n; i += 2, cur++)
{
int x = i, y = 0;
while (x < n && y < n)
arr[x++][y++] *= pri[cur];
}
for (int i = 2; i < n; i += 2, cur++)
{
int x = 0, y = i;
while (x < n && y < n)
arr[x++][y++] *= pri[cur];
}
cur = len - 1;
for (int i = 0; i < n; i += 2, cur--)
{
int x = i, y = 0;
while (x >= 0 && y < n)
arr[x--][y++] *= pri[cur];
}
for (int i = 2; i < n; i += 2, cur--)
{
int x = n - 1, y = i;
while (x >= 0 && y < n)
arr[x--][y++] *= pri[cur];
}
for (int i = 0; i < n; i++)
{
for (int j = i & 1 ^ 1; j < n; j += 2)
arr[i][j] = lcm(lcm(i ? arr[i - 1][j] : 0, j ? arr[i][j - 1] : 0),
lcm(arr[i + 1][j], arr[i][j + 1])) + 1;
}
n -= even;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
printf("%lld%c", arr[i][j], " \n"[j + 1 == n]);
}
return 0;
}
| 0 |
#include <iostream>
using namespace std;
int D[100][6];
//回転を定義
void spin(int n,char c)
{
if(c=='E'){
swap(D[n][0],D[n][3]);swap(D[n][3],D[n][5]);swap(D[n][5],D[n][2]);
}
else if(c=='W'){
swap(D[n][0],D[n][2]);swap(D[n][2],D[n][5]);swap(D[n][5],D[n][3]);
}
else if(c=='S'){
swap(D[n][0],D[n][1]);swap(D[n][0],D[n][4]);swap(D[n][4],D[n][5]);
}
else if(c=='N'){
swap(D[n][0],D[n][1]);swap(D[n][1],D[n][5]);swap(D[n][5],D[n][4]);
}
}
int main() {
//ダイスを一括で入力
int ans = 0;
int n;
cin >> n;
for (int i = 0; i < n ; i++) {
for (int j = 0; j < 6; j++) {
cin >> D[i][j];
}
}
for (int i = 0; i < n ; i++) {
for (int j = i + 1; j <= n; j++) {
//i個目のダイスとj個目のダイスを比較
//回転して前面を合わせる
char SWS[10]={"SSSSWSSSS"};
for(int k=0; k<10; k++){
if(D[i][1] == D[j][1]) break;
spin(j, SWS[k]);
}
//回転して上面を合わせる
for(int k=0; k<4; k++){
if(D[i][0] == D[j][0]){
if(D[i][1] == D[j][1] && D[i][2] == D[j][2] && D[i][3] == D[j][3] && D[i][4] == D[j][4] && D[i][5] == D[j][5])
ans++;
}
spin(j, 'W');
}
}
}
//出力
if (ans == 0) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
long long N,count=0;
cin>>N;
vector<long long> A(N);
unordered_map<long long,long long> mp;
for(int i=0;i<N;i++){
cin>>A.at(i);
mp[A.at(i)]++;
}
sort(A.begin(),A.end());
reverse(A.begin(),A.end());
for(int i=0;i<N;i++){
if(mp[A.at(i)]>=4){
if(count==0){
cout<<A.at(i)*A.at(i)<<endl;
return 0;
}
if(count>0){
cout<<count*A.at(i)<<endl;
return 0;
}
}
if(mp[A.at(i)]>=2){
if(count==0){
count=A.at(i);
mp[A.at(i)]=0;
}
else{
cout<<count*A.at(i)<<endl;
return 0;
}
}
}
cout<<0<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define rep(i, n) repl(i, 0, n)
#define CST(x) cout << fixed << setprecision(x)
using ll = long long;
const ll MOD = 1000000007;
const int inf = 1e9 + 10;
const ll INF = 4e18 + 10;
const int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
const int dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll l, r;
cin >> l >> r;
if (r - l + 1 >= 2019)
cout << 0 << endl;
else {
ll ans = INF;
repl(i, l, r + 1) repl(j, i + 1, r + 1) ans = min(ans, i * j % 2019);
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
int A, B;
cin >> A >> B;
int ans = 0;
for (int i = A; i <= B; i++)
{
int c = i % 10, d = i / 10000 % 10;
int e = i / 10 % 10, f = i / 1000 % 10;
if (c == d && e == f)ans++;
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
typedef pair<ll,ll> P;
typedef priority_queue<P,vector<P>,greater<P>> P_queue;
#define REP(i,a,b) for(int i=(int)a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define pb push_back
#define mp make_pair
#define ALL(a) a.begin(),a.end()
#define SORT(a) sort(ALL(a))
#define U_ERASE(V) V.erase(unique(ALL(V)), V.end());
#define ADD(a,b) a=(a+b)%mod
const ll MOD=998244353;
const ll mod=1000000007;
const ll INF=1e15;
vec dx={1,0,-1,0};
vec dy={0,1,0,-1};
ll N,M;
ll d[301][301];
bool used[301];
ll Start[301];
ll Solve(ll x){
if(!used[d[x][Start[x]]]) return d[x][Start[x]];
Start[x]++;
return Solve(x);
}
ll SOLVE(){
vec kari(M+1,0);
rep(i,N) kari[Solve(i)]++;
ll MAX=-INF, basho=-1;
rep(i,M) if(kari[i]>MAX){
MAX=kari[i];
basho=i;
}
//rep(i,M) cout<<kari[i]<<' ';
//cout<<endl;
//cout<<MAX<<' '<<basho+1<<endl;
used[basho]=true;
return MAX;
}
ll MAIN(){
if(M==1) return N;
ll ret=INF;
rep(i,M-1) {
//cout<<i<<':';
ll K=SOLVE();
ret=min(ret,K);
}
return ret;
}
int main(){
cin>>N>>M;
rep(i,N) rep(j,M) {cin>>d[i][j]; d[i][j]--;}
cout<<MAIN()<<endl;
} | #include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef vector <int> vi;
typedef vector <string> vs;
#define N1 5
#define N2 13
int main(void){
vi card(N2);
string prize[7]={"null","one pair","two pair","three card","straight","full house","four card"};
while (true){
for (int i=0; i<N2; i++)
card[i]=0;
int a=0, b=0, d=N2, p=0,tmp;
for (int i=0;i<N1;i++){
char c;
if (i!=0) cin>>c;
cin>>tmp;
if (cin.eof()) break;
tmp--;
if (tmp<d) d=tmp;
if (card[tmp]==0) b++;
card[tmp]++;
if (card[tmp]>a) a=card[tmp];
}
if (b==0) break;
switch (b){
case 2:
if (a==4) p=6;
else p=5;
break;
case 3:
if (a==3) p=3;
else p=2;
break;
case 4:
p=1;
break;
case 5:
bool f=true;
for (int i=d; i<d+N1; i++)
if (card[i]!=1){
f=false;
break;
}
if (!f && card[0]==1){
f=true;
for (int i=9; i<N2; i++)
if (card[i]!=1){
f=false;
break;
}
}
if (f) p=4;
else p=0;
}
cout<<prize[p]<<endl;
}
} | 0 |
#include<cstdio>
#include<algorithm>
using namespace std;
#define MAXN 100010
int a[5][MAXN],n,tg[5],to[MAXN];
int Abs(int x)
{
return x>=0?x:-x;
}
int main()
{
scanf("%d",&n);
for(int i=0;i<3;i++)
for(int j=1;j<=n;j++)
scanf("%d",&a[i][j]);
for(int i=1;i<=n;i++)
{
to[i]=a[1][i]/3+1;
if(!((a[0][i]-a[1][i]==-1&&a[1][i]-a[2][i]==-1&&a[0][i]%3==1)||(a[0][i]-a[1][i]==1&&a[1][i]-a[2][i]==1&&!(a[0][i]%3)))||(Abs(i-to[i])&1))
{
printf("No\n");
return 0;
}
tg[i&1]^=(a[0][i]>a[1][i]);
}
for(int i=1;i<=n;i++)
{
while(to[i]!=i)
{
tg[i&1^1]^=1;
swap(to[i],to[to[i]]);
}
}
if(tg[0]||tg[1]) printf("No\n");
else printf("Yes\n");
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) REP(i, 0, n)
#define rrep(i, n) for (int i = (int)(n-1); i >= 0; i--)
#define sz(x) int(x.size())
#define bitsz(x) int(__builtin_popcount(x))
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define INF 2e9
#define LINF 1e18
#define mod 1000000007
template<class T> inline bool chmax(T &a, const T &b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, const T &b) { if (a > b) { a = b; return 1; } return 0; }
template < typename T > inline string toString( const T &a ) { ostringstream oss; oss << a; return oss.str(); };
typedef long long ll;
typedef pair<int, int> P;
int dx[4] = {1,0,-1,0};
int dy[4] = {0,1,0,-1};
int main() {
int n; cin >> n;
vector<ll> a(n);
rep(i,n) cin >> a[i];
ll ans = 0;
rep(i,60) {
ll x = 0;
rep(j,n) if (a[j]>>i & 1) x++;
ll now = x*(n-x)%mod; //今考えてる桁から生じる和
rep(k,i) now = now*2%mod;
ans += now;
ans %= mod;
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
//#pragma GCC optimize(2)
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<string>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
#include<cstring>
#include<bitset>
#include<stack>
#include<time.h>
#define X first
#define Y second
#define PB push_back
#define MP make_pair
#define scd(a) scanf("%d",&a)
#define scdd(a,b) scanf("%d%d",&a,&b)
#define scddd(a,b,c) scanf("%d%d%d",&a,&b,&c)
#define ALL(x) x.begin(),x.end()
#define sz(a) ((int)a.size())
#define getmid ((l+r)>>1)
#define mst(var,val) memset(var,val,sizeof(var))
#define IOS ios::sync_with_stdio(false);cin.tie(0)
#define lowbit(x) x&(-x)
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
#define ls rt<<1
#define rs rt<<1|1
using namespace std;
#ifdef local
#define dbg(args...) cout << #args << " -> ", err(args);
void err(){ cout << endl; }
template<typename T, typename... Args>
void err(T a, Args... args){ cout << a << ' '; err(args...); }
#else
#define dbg(args...)
#endif // local
typedef long long ll;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
typedef pair <ll, int> pli;
typedef pair <double, double> pdd;
const int inf=0x3f3f3f3f;
const long long INF=0x3f3f3f3f3f3f3f3fLL;
const double PI=acos(-1.0);
const long double eps=1e-8;
const int mod=1e9+7;
const int maxn=3e5+100;
const int N=1e6+1000;
const int M=500+10;
const ll mm=(1LL<<32);
template <class T>
inline void read(T &x)
{
x = 0;
char c = getchar();
bool f = 0;
for (; !isdigit(c); c = getchar())
f ^= c == '-';
for (; isdigit(c); c = getchar())
x = x * 10 + (c ^ 48);
x = f ? -x : x;
}
template <class T>
inline void write(T x)
{
if (x < 0)
{
putchar('-');
x = -x;
}
T y = 1;
int len = 1;
for (; y <= x / 10; y *= 10)
++len;
for (; len; --len, x %= y, y /= 10)
putchar(x / y + 48);
}
ll qpow(ll a,ll b,ll mod)
{
ll ans=1;
while(b)
{
if(b&1)
ans=(ans*a)%mod;
b>>=1;
a=(a*a)%mod;
}
return ans;
}
int main()
{
#ifdef local
freopen("in.txt","r",stdin);
#endif // local
IOS;
ll n;cin>>n;
ll len=1,tmp=26;
while(n>tmp)
{
n-=tmp;
tmp*=26;
len++;
}
n-=1;
string ans="";
for(int i=1;i<=len;++i)
{
ans+='a'+n%26;
n/=26;
}
reverse(ALL(ans));
cout<<ans<<endl;
return 0;
}
| #include<iostream>
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s;
cin>>s;
bool ans=true;
if(s.length()%2==1)
{
cout<<"No";
return 0;
}
for(int i=0;i<s.length();i++)
{
if(i%2==0)
{
if(s[i]!='h')
{
ans=false;
break;
}
}
else
{
if(s[i]!='i')
{
ans=false;
break;
}
}
}
if(ans)
cout<<"Yes";
else cout<<"No";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<double, double> P;
int main() {
int n;
cin >> n;
vector<queue<int>> q(n+1);
for (int i=0;i<n; i++){
for (int j=0;j<n-1;j++){
int x;
cin>>x;
q[i].push(x-1);
}
q[i].push(n);
}
q[n].push(n);
int ans=0;
int cnt=n*(n-1);
int f=1;
vector<int>update;
for (int i=0;i<n;i++){
update.push_back(i);
}
while (cnt > 0){
ans++;
vector<int>update2;
for (int i : update){
if (q[q[i].front()].front()==i && q[i].front()>i){
update2.push_back(i);
update2.push_back(q[i].front());
}
}
for (int i:update2){
q[i].pop();
cnt--;
}
if (update2.empty()){
f=0;
break;
}
}
if(f==0) cout<<-1<<endl;
else cout<<ans<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define fi first
#define se second
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
const ll MOD = 998244353;
const int inf = 1e9 + 10;
const ll INF = 4e18;
const int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0}, dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> a(n + 5);
rep(i, n) cin >> a[i];
if (n == 2) {
cout << max(a[0], a[1]) << endl;
return 0;
}
vvl dp(n + 7, vl(3, -INF));
rep(i, 3) dp[i][i] = 0;
rep(i, n) {
rep(j, 3) {
if (dp[i][j] == -INF) continue;
dp[i + 2][j] = max(dp[i + 2][j], dp[i][j] + a[i]);
if (j < 2) dp[i + 3][j + 1] = max(dp[i + 3][j + 1], dp[i][j] + a[i]);
if (j < 1) dp[i + 4][j + 2] = max(dp[i + 4][j + 2], dp[i][j] + a[i]);
}
}
ll ans = -INF;
if (n % 2)
rep(i, 3) ans = max(ans, dp[n - 1 + i][i]);
else
rep(i, 2) ans = max(ans, dp[n + i][i]);
cout << ans << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long int;
int main(void) {
constexpr ll MOD = 1e9 + 7;
cout << fixed << setprecision(16);
ll n, m;
cin >> n >> m;
vector<vector<ll>> G(n);
while(m--) {
ll a, b;
cin >> a >> b;
a--, b--;
G[a].push_back(b);
}
vector<ll> idx(n, -1);
set<ll> cyc;
{
ll x = 0;
auto dfs = [&](auto dfs, ll cur, ll pre) -> ll {
if(idx[cur] > -1) {
cyc.insert(cur);
return cur;
}
idx[cur] = x++;
for(auto &v: G[cur]) {
ll r = dfs(dfs, v, cur);
if(r == cur) return -2;
if(r == -2) return -2;
if(r > -1) {
cyc.insert(cur);
return r;
}
}
return idx[cur] = -1;
};
for(ll i=0; i<n; i++) {
fill(idx.begin(), idx.end(), -1);
if(dfs(dfs, i, -1) == -2) break;
}
if(cyc.size() == 0) {
cout << -1 << endl;
return 0;
}
}
ll t = *cyc.begin();
for(ll i=0; i<n; i++) {
ll m = -1, mm = -1, s = t;
for(auto &v: G[s]) {
if(!cyc.count(v)) continue;
if(idx[v] < idx[s] && mm < idx[v])
mm = idx[v], t = v;
if(mm == -1 && m < idx[v])
m = idx[v], t = v;
}
}
set<ll> res;
for(ll i=0; i<n; i++) {
ll m = -1, mm = -1, s = t;
for(auto &v: G[s]) {
if(!cyc.count(v)) continue;
if(idx[v] < idx[s] && mm < idx[v])
mm = idx[v], t = v;
if(mm == -1 && m < idx[v])
m = idx[v], t = v;
}
res.insert(t);
}
cout << res.size() << endl;
for(auto &e: res) cout << e+1 << endl;
}
| #include<bits/stdc++.h>
using namespace std;
int ac[100005];
char ch[100005];
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n,q;
string s;
cin>>n>>q>>s;
for(int i=0; s[i]; i++) ch[i+1] = s[i];
for(int i=1; i<=n; i++){
if(ch[i]=='A' && ch[i+1]=='C') ac[i]++;
}
for(int i=1; i<=n; i++) ac[i]+=ac[i-1];
while(q--){
int a,b;
cin>>a>>b;
int ret = ac[b]-ac[a-1];
if(ch[b]=='A' && ch[b+1]=='C') ret--;
cout<<ret<<'\n';
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 5e5 + 100, base = 13, m1 = 1e9 + 7, m2 = 1e9 + 9;
int n, a[maxN + 1], b[maxN + 1];
int ha[2][35][maxN + 1], hb[2][35], hc[2][35];
int pw[2][maxN + 1], ans[35][maxN + 1];
inline int read()
{
int num = 0, f = 1;
char ch = getchar();
while( !isdigit( ch ) ) { if(ch == '-') f = -1; ch = getchar(); }
while( isdigit( ch ) ) num = (num << 3) + (num << 1) + (ch ^ 48), ch = getchar();
return num * f;
}
int main()
{
n = read();
for(int i = 1; i <= n; i++) a[i] = a[i + n] = read();
for(int i = 1; i <= n; i++) b[i] = read();
pw[0][0] = pw[1][0] = 1;
for(int i = 1; i <= 2 * n; i++) pw[0][i] = 1ll * pw[0][i - 1] * base % m1, pw[1][i] = 1ll * pw[1][i - 1] * base % m2;
for(int i = 1; i <= 2 * n; i++)
for(int j = 0; j < 30; j++)
{
int x = (a[i] >> j) & 1;
ha[0][j][i] = (1ll * ha[0][j][i - 1] * base % m1 + x) % m1;
ha[1][j][i] = (1ll * ha[1][j][i - 1] * base % m2 + x) % m2;
}
for(int i = 1; i <= n; i++)
for(int j = 0; j < 30; j++)
{
int x = (b[i] >> j) & 1;
hb[0][j] = (1ll * hb[0][j] * base % m1 + x) % m1;
hb[1][j] = (1ll * hb[1][j] * base % m2 + x) % m2;
}
for(int i = 1; i <= n; i++)
for(int j = 0; j < 30; j++)
{
int x = ((~b[i]) >> j) & 1;
hc[0][j] = (1ll * hc[0][j] * base % m1 + x) % m1;
hc[1][j] = (1ll * hc[1][j] * base % m2 + x) % m2;
}
for(int i = 1; i <= n; i++)
for(int j = 0; j < 30; j++)
{
int t1 = ((ha[0][j][i + n - 1] - 1ll * ha[0][j][i - 1] * pw[0][n] % m1) % m1 + m1) % m1;
int t2 = ((ha[1][j][i + n - 1] - 1ll * ha[1][j][i - 1] * pw[1][n] % m2) % m2 + m2) % m2;
if(t1 == hb[0][j] && t2 == hb[1][j]) ans[j][i] = 0;
else if(t1 == hc[0][j] && t2 == hc[1][j]) ans[j][i] = 1;
else ans[j][i] = -1;
}
for(int i = 1; i <= n; i++)
{
bool flag = true;
for(int j = 0; j < 30; j++)
if(ans[j][i] == -1) { flag = false; break; }
if(!flag) continue;
int res = 0;
for(int j = 0; j < 30; j++) res |= (ans[j][i] << j);
printf("%d %d\n", i - 1, res);
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
const int N = 2e5 + 5;
int n, a[N], b[N];
int s[3 * N], p[3 * N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < n; ++i) scanf("%d", &b[i]);
for (int i = 0; i < n; ++i) s[i] = b[i] ^ b[(i + 1) % n];
for (int i = 0; i < n; ++i) s[i + n + 1] = a[i] ^ a[(i + 1) % n];
for (int i = 2 * n + 1; i <= 3 * n; ++i) s[i] = s[i - n];
s[n] = -1;
int now = p[0] = -1;
for (int i = 1; i <= 3 * n; ++i) {
while (now + 1 && s[now + 1] != s[i]) now = p[now];
p[i] = s[now + 1] == s[i] ? ++now : (now = -1);
}
for (int i = 2 * n; i < 3 * n; ++i) {
if (p[i] == n - 1) {
int k = i - 2 * n;
int x = a[k] ^ b[0];
printf("%d %d\n", k, x);
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define all(v) begin(v),end(v)
using ll = long long;
int main() {
string s;cin>>s;
rep(bit,1<<3){
int cnt=s[0]-'0';
string t;
t+=s[0];
rep(i,3){
if(bit&(1<<i)){
cnt+=s[i+1]-'0';
t+='+';
t+=s[i+1];
}
else {
cnt-=s[i+1]-'0';
t+='-';
t+=s[i+1];
}
}
if(cnt==7){
cout<<t<<"=7"<<endl;
return 0;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int INF=1001001001;
vector<pair<int64_t,int64_t>>prime_factorize(int64_t x){
vector<pair<int64_t,int64_t>>p;
for(int64_t i=2;i*i<=x;i++){
int cnt=0;
if(x%i==0){
while(x%i==0){cnt++;x/=i;}
p.push_back(make_pair(i,cnt));
}
}
if(x!=1){p.push_back(make_pair(x,1));}
return p;
}
int main() {
vector<char>s(4);
for(int i=0;i<4;i++){
cin>>s[i];
}
for(int p=0;p<(1<<3);p++){
string t;int sum=s[0]-'0';
t.push_back(s[0]);
for(int i=0;i<3;i++){
if((p>>i)&1){sum+=(s[i+1]-'0');t.push_back('+');}
else{sum-=(s[i+1]-'0');t.push_back('-');}
t.push_back(s[i+1]);
}
t+="=7";
if(sum==7){cout<<t<<endl;return 0;}
}
return 0;
} | 1 |
//what is going on
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
vl w;
int gcd(int a, int b) {
if(a == 0) {return b;}
if(b == 0) {return a;}
return gcd(b,a%b);
}
int main() {
int n;
cin >> n;
for(int i=0;i<n;i++) {
ll t;
cin >> t;
w.push_back(t);
}
int lob = 0;
for(int j=0;j<n;j++) {
if(w[j]&(1)) {
lob++;
}
}
int poss = 0;
if(lob != 1) {
poss = (n-lob)&1;
} else {
if(n&1) {
int ct = 0;
int cob = 0;
while(1) {
int mo = 0;
lob = 0;
for(int i=0;i<n;i++) {
if(w[i]&1) {lob++;
mo = i;
}
}
if(lob != 1) {
cob = n-lob;
break;
}
if(w[mo] == 1) {
cob = 0;
break;
}
ct++;
w[mo]--;
int g = w[0];
for(int i=1;i<n;i++) {
g = gcd(w[i],g);
}
for(int i=0;i<n;i++) {
w[i] /= g;
}
}
poss = (cob+ct)&1;
} else {
poss = (n-lob)&1;
}
}
if(poss) {
cout << "First\n";
} else {
cout << "Second\n";
}
}
| #include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#define ll long long
#define maxn 200010
inline ll read()
{
ll x=0; char c=getchar(),f=1;
for(;c<'0'||'9'<c;c=getchar())if(c=='-')f=-1;
for(;'0'<=c&&c<='9';c=getchar())x=x*10+c-'0';
return x*f;
}
inline void write(ll x)
{
static int buf[20],len; len=0;
if(x<0)x=-x,putchar('-');
for(;x;x/=10)buf[len++]=x%10;
if(!len)putchar('0');
else while(len)putchar(buf[--len]+'0');
}
inline void writeln(ll x){write(x); putchar('\n');}
inline void writesp(ll x){write(x); putchar(' ');}
int p[10010],mn[10010];
ll a[510][510];
int n,tot;
void euler(int n)
{
tot=0;
for(int i=2;i<=n;i++){
if(!mn[i])p[++tot]=i,mn[i]=tot;
for(int j=1;j<=mn[i]&&i*p[j]<=n;j++)
mn[i*p[j]]=j;
}
}
int gcd(ll a,ll b){return b?gcd(b,a%b):a;}
int main()
{
n=read();
if(n==2){
printf("4 7\n23 10\n");
return 0;
}
euler(10000);
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if((i+j)&1){
int x=(i-j+n+1)/2,y=(i+j+1)/2;
a[i][j]=p[x]*p[n+y];
}
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if(!((i+j)&1)){
ll cur=1;
if(i>1)cur=cur/gcd(cur,a[i-1][j])*a[i-1][j];
if(j>1)cur=cur/gcd(cur,a[i][j-1])*a[i][j-1];
if(i<n)cur=cur/gcd(cur,a[i+1][j])*a[i+1][j];
if(j<n)cur=cur/gcd(cur,a[i][j+1])*a[i][j+1];
a[i][j]=cur+1;
}
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++)
writesp(a[i][j]);
putchar('\n');
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define length size()
#define endl "\n"
signed main(void){
float a,b,c;
cin >> a >> b >> c;
cout << (int)(c*(ceil(a/b)))+0 << endl;
}
| #include <stdio.h>
#include <stdlib.h>
#define MAX_INPUT_SIZE 1024
int
main(int argc, char* argv[])
{
char input[MAX_INPUT_SIZE];
int n = atoi(fgets(input, sizeof(input), stdin));
int ret = n * n * n;
printf("%d\n", ret);
return 0;
} | 0 |
#include <iostream>
template<typename X>
X input() {
X value;
std::cin >> value;
return value;
}
int main() {
int x = input<int>();
int x3 = x * x * x;
std::cout << x3 << std::endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) REP(i, 0, n)
#define rrep(i, n) for (int i = (int)(n-1); i >= 0; i--)
#define sz(x) int(x.size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define INF 2e9
#define LINF 1e18
#define mod 1000000007
template<class T> inline bool chmax(T &a, const T &b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, const T &b) { if (a > b) { a = b; return 1; } return 0; }
typedef long long ll;
typedef pair<int, int> P;
int dx[4] = {1,0,-1,0};
int dy[4] = {0,1,0,-1};
int main() {
int n; cin >> n;
set<int> st;
rep(i,n) {
int a; cin >> a;
st.insert(a);
}
if (sz(st) == n) cout << "YES" << endl;
else cout << "NO" << endl;
} | 0 |
#include <cstdio>
#include <algorithm>
using namespace std;
int main(){
int n;
while(scanf("%d",&n) && n != 0){
int arr[n];
for(int i = 0; i < n; i++){
scanf("%d",&arr[i]);
}
int max_e = arr[0], max_s = arr[0];
for(int cur = 1; cur < n; cur++){
max_e = max(arr[cur], max_e + arr[cur]);
max_s = max(max_s, max_e);
}
printf("%d\n",max_s);
}
} | #include<iostream>
#include<cstring>
using namespace std;
int n, a[10], x;
int main() {
while (true) {
cin >> n;
if (n == 0) { break; }
memset(a, 0, sizeof(a));
for (int i = 0; i < n; i++) {
cin >> x;
a[x]++;
}
for (int i = 0; i < 10; i++) {
if (a[i] == 0) { cout << '-' << endl; }
else {
for (int j = 0; j < a[i]; j++) { cout << '*'; }
cout << endl;
}
}
}
} | 0 |
#include<iostream>
#include<string.h>
#include<string>
#include<stdio.h>
#include<algorithm>
#include<vector>
#include<bitset>
#include<math.h>
#include<stack>
#include<queue>
#include<set>
#include<map>
using namespace std;
typedef long long ll;
typedef long double db;
typedef vector<int> vi;
typedef pair<int,int> pii;
const int N=200000+100;
const db pi=acos(-1.0);
#define lowbit(x) (x)&(-x)
#define sqr(x) (x)*(x)
#define rep(i,a,b) for (register int i=a;i<=b;i++)
#define per(i,a,b) for (register int i=a;i>=b;i--)
#define go(u,i) for (register int i=head[u],v=sq[i].to;i;i=sq[i].nxt,v=sq[i].to)
#define fir first
#define sec second
#define mkp make_pair
#define pb push_back
#define maxd 998244353
#define eps 1e-8
inline int read()
{
int x=0,f=1;char ch=getchar();
while ((ch<'0') || (ch>'9')) {if (ch=='-') f=-1;ch=getchar();}
while ((ch>='0') && (ch<='9')) {x=x*10+(ch-'0');ch=getchar();}
return x*f;
}
namespace My_Math{
#define N 100000
int fac[N+100],invfac[N+100];
int add(int x,int y) {return x+y>=maxd?x+y-maxd:x+y;}
int dec(int x,int y) {return x<y?x-y+maxd:x-y;}
int mul(int x,int y) {return 1ll*x*y%maxd;}
ll qpow(ll x,int y)
{
ll ans=1;
while (y)
{
if (y&1) ans=mul(ans,x);
x=mul(x,x);y>>=1;
}
return ans;
}
int getinv(int x) {return qpow(x,maxd-2);}
int C(int n,int m)
{
if ((n<m) || (n<0) || (m<0)) return 0;
return mul(mul(fac[n],invfac[m]),invfac[n-m]);
}
void math_init()
{
fac[0]=invfac[0]=1;
rep(i,1,N) fac[i]=mul(fac[i-1],i);
invfac[N]=getinv(fac[N]);
per(i,N-1,1) invfac[i]=mul(invfac[i+1],i+1);
}
#undef N
}
using namespace My_Math;
int n,a[N];
ll sum[N];
ll calc(int l,int r) {return sum[r]-sum[l-1];}
int main()
{
n=read();
rep(i,1,n) a[i]=read();
rep(i,1,n) sum[i]=sum[i-1]+a[i];
int l=1,r=3;
ll ans=1e18;
rep(i,2,n-2)
{
while ((l+2<=i) && (abs(calc(1,l)-calc(l+1,i))>abs(calc(1,l+1)-calc(l+2,i)))) l++;
while ((r+2<=n) && (abs(calc(i+1,r)-calc(r+1,n))>abs(calc(i+1,r+1)-calc(r+2,n)))) r++;
ll mx=0,mn=1e18,x;
x=calc(1,l);mx=max(mx,x);mn=min(mn,x);
x=calc(l+1,i);mx=max(mx,x);mn=min(mn,x);
x=calc(i+1,r);mx=max(mx,x);mn=min(mn,x);
x=calc(r+1,n);mx=max(mx,x);mn=min(mn,x);
ans=min(ans,mx-mn);
}
printf("%lld\n",ans);
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, a) for (int i = (int)0; i < (int)a; ++i)
#define rrep(i, a) for (int i = (int)a - 1; i >= 0; --i)
#define REP(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define RREP(i, a, b) for (int i = (int)a - 1; i >= b; --i)
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define popcount __builtin_popcount
using ll = long long;
constexpr ll mod = 1e9 + 7;
constexpr ll INF = 1LL << 60;
template <class T>
inline bool chmin(T &a, T b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T &a, T b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
ll gcd(ll n, ll m)
{
ll tmp;
while (m != 0)
{
tmp = n % m;
n = m;
m = tmp;
}
return n;
}
ll lcm(ll n, ll m)
{
return abs(n) / gcd(n, m) * abs(m); //gl=xy
}
using namespace std;
void solve()
{
int n;
cin>>n;
vector<ll>a(n);
rep(i,n)cin>>a[i];
vector<ll>sum(n+1);
rep(i,n){
sum[i+1]=sum[i]+a[i];
}
ll ans=INF;
for(int i=1;i<n-2;++i){
vector<ll>left(4),right(4);
int ok=1,ng=i+1;
while(abs(ok-ng)>1){
int mid=(ok+ng)/2;
if(sum[i+1]-sum[mid]>sum[mid])ok=mid;
else ng=mid;
}
left[0]=sum[ok],right[0]=sum[i+1]-sum[ok];
// ok=1,ng=i+1;
// while(abs(ok-ng)>1){
// int mid=(ok+ng)/2;
// if(sum[i+1]-sum[mid]<sum[mid])ok=mid;
// else ng=mid;
// }
left[1]=sum[ng],right[1]=sum[i+1]-sum[ng];
ok=i+2,ng=n;
while(abs(ok-ng)>1){
int mid=(ok+ng)/2;
if(sum[n]-sum[mid]>sum[mid]-sum[i+1])ok=mid;
else ng=mid;
}
left[2]=sum[ok]-sum[i+1],right[2]=sum[n]-sum[ok];
// ok=i+2,ng=n;
// while(abs(ok-ng)>1){
// int mid=(ok+ng)/2;
// if(sum[n]-sum[mid]<sum[mid]-sum[i+1])ok=mid;
// else ng=mid;
// }
left[3]=sum[ng]-sum[i+1],right[3]=sum[n]-sum[ng];
rep(j,2){
REP(k,2,4){
//cout<<left[j]<<" "<<right[j]<<" "<<left[k]<<" "<<right[k]<<"\n";
chmin(ans,max({left[j],right[j],left[k],right[k]})-min({left[j],right[j],left[k],right[k]}));
}
}
}
cout<<ans<<"\n";
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve();
return 0;
}
| 1 |
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#define fi first
#define se second
#define L(i,u) for (int i=head[u]; i!=0; i=nxt[i])
#define rep(i,a,b) for (register int i=a; i<=b; i++)
#define per(i,a,b) for (register int i=a; i>=b; i--)
typedef long long ll;
using namespace std;
typedef pair<int,int> Pii;
typedef vector<int> Vi;
inline void read(int &x) {
x=0; char c=getchar(); int f=1;
while (!isdigit(c)) {if (c=='-') f=-1; c=getchar();}
while (isdigit(c)) {x=x*10+c-'0'; c=getchar();} x*=f;
}
const int N = 303;
char s[N];
int n,k,f[N][N][N];
inline void umax(int &a, int b) {a=a>b?a:b;}
int main() {
scanf("%s",s+1); read(k); n=strlen(s+1);
rep(i,1,n) f[i][i][0]=1; int ans=0;
rep(l,-1,n-1) rep(i,1,n) {
int j=i+l; if (j>n) break;
rep(K,0,k) {
int v=f[i][j][K]; umax(ans,v);
umax(f[i][j+1][K],v); umax(f[i-1][j][K],v);
umax(f[i-1][j+1][K+(s[i-1]!=s[j+1])],v+2);
}
}
printf("%d",ans);
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define pii pair <int, int>
#define x first
#define y second
using namespace std;
string s;
int dp[301][301][301];
inline int solve(int l, int r, int k) {
if (k < 0)
return INT_MIN;
if (r - l < 1)
return r - l + 1;
if (dp[l][r][k] != -1)
return dp[l][r][k];
return dp[l][r][k] = max(solve(l + 1, r - 1, k - (s[l] != s[r])) + 2, max(solve(l + 1, r, k), solve(l, r - 1, k)));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int k;
cin >> s >> k;
memset(dp, -1, sizeof(dp));
return cout << solve(0, s.length() - 1, k), 0;
}
| 1 |
#include <bits/stdc++.h>
typedef long long ll;
#define pb push_back
using namespace std;
typedef pair<ll,ll> pll;
vector< pll > v;
ll n;
ll h[5005], p[5005];
ll dp[5005][5005];
const ll inf = 1e16;
int main()
{
cin >> n;
v.pb(make_pair(-2LL , -2LL));
for(ll i=1;i<=n;i++) {
cin >> h[i] >> p[i];
v.pb(make_pair(h[i]+p[i], i));
}
sort(v.begin(), v.end());
for(ll i=1;i<=n;i++) dp[0][i] = inf;
dp[0][0] = 0;
for(ll i=1;i<=n;i++) {
ll id = v[i].second;
for(ll j = 0; j <= n; j++) {
dp[i][j] = dp[i-1][j];
if(j && dp[i-1][j-1] <= h[id]) dp[i][j] = min(dp[i][j], p[id] + dp[i-1][j-1]);
}
}
for(ll i=n;i>=0;i--){
if(dp[n][i] != inf) {
cout << i << endl; return 0;
}
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair< ll, ll > Pi;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep2(i,n) for(int i=1;i<=(n);i++)
#define rep3(i,i0,n) for(int i=i0;i<(n);i++)
#define pb push_back
#define mod 1000000007
const ll INF = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll a, ll b) {return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) {return a/gcd(a,b)*b;}
#define all(x) x.begin(), x.end()
#define mp make_pair
bool compare(Pi a, Pi b) {
if(a.first != b.first){
return a.first < b.first;
}else{
return a.second < b.second;
}
}
bool compareg(Pi a, Pi b) {
if(a.second != b.second){
return a.second > b.second;
}else{
return a.first > b.first;
}
}
bool In_map(ll y,ll x,ll h,ll w){
if(y<0 || x<0 || y>=h || x>=w){
return 0;
}else{
return 1;
}
}
const vector<ll> dx{1,0,-1,0};
const vector<ll> dy{0,1,0,-1};
int main() {
ll N;
cin>>N;
vector<Pi>ab(N);
vector<Pi>cd(N);
rep(i,N){
ll a,b;
cin>>a>>b;
ab[i] = mp(a,b);
}
rep(i,N){
ll a,b;
cin>>a>>b;
cd[i] = mp(a,b);
}
sort(all(ab),compareg);
sort(all(cd),compare);
ll ans = 0;
rep(i,N){
rep(j,N){
if(ab[i].first < cd[j].first && ab[i].second <cd[j].second){
ab[i].first = INF;
cd[j].first = -INF;
//cout<<i<<" "<<j<<endl;
ans++;
break;
}
}
}
cout << ans<<endl;
return 0;
}
| 0 |
#include "bits/stdc++.h"
using namespace std;
// Bit Matrix
const int MAX_ROW = 110; // to be set appropriately
const int MAX_COL = 110000; // to be set appropriately
struct BitMatrix {
int H, W;
bitset<MAX_COL> val[MAX_ROW];
BitMatrix(int m = 1, int n = 1) : H(m), W(n) {}
inline bitset<MAX_COL>& operator [] (int i) { return val[i]; }
};
// 掃き出し法
void GaussJordan(BitMatrix &A, bool is_extended = false) {
vector<bool> used(A.H, 0);
for (int col = 0; col < A.W; ++col) {
if (is_extended && col == A.W - 1) break;
int pivot = -1;
for (int row = 0; row < A.H; ++row) {
if (used[row]) continue;
if (A[row][col]) {
pivot = row;
break;
}
}
if (pivot == -1) continue;
for (int row = 0; row < A.H; ++row) {
if (row != pivot && A[row][col]) A[row] ^= A[pivot];
}
used[pivot] = true;
}
}
const int MD = 60;
int main() {
int N; cin >> N;
vector<long long> A(N);
for (int i = 0; i < N; ++i) cin >> A[i];
// 方程式を立てる
long long res = 0;
BitMatrix B(MD + 1, N + 1);
vector<bool> cannot(MD + 1, false);
for (long long d = MD; d >= 0; --d) {
// d 桁目が 1 が何個か
int num = 0;
for (int i = 0; i < N; ++i) {
if (A[i] & (1LL << d)) ++num;
}
if (num == 0) {
cannot[d] = true;
continue;
}
else if (1 == (num % 2)) {
cannot[d] = true;
res += (1LL << d);
continue;
}
for (int i = 0; i < N; ++i) {
if (A[i] & (1LL << d)) B[MD - d][i] = 1;
}
B[MD - d][N] = 1;
}
GaussJordan(B, true);
// 集計
for (int d = MD; d >= 0; --d) {
if (cannot[d]) continue;
// d 行目が (0 0 0 ... 0 | 1) だったらダメ
bool ok = false;
for (int i = 0; i < N; ++i) if (B[MD - d][i]) ok = true;
if (!B[MD - d][N]) ok = true;
// 結果に 2 × 2^d が寄与
if (ok) res += (2LL << d);
}
cout << res << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; i++)
cin >> v.at(i);
long long mod = 1000000007;
long long sum = 0;
for (int i = 0; i < n; i++) {
sum += v.at(i);
sum %= mod;
}
long long ans;
ans = sum * sum % mod;
for (int i = 0; i < n; i++) {
ans -= (long long)v.at(i) * v.at(i) % mod;
}
while (ans < 0) ans += mod;
ans *= (mod + 1) / 2;
cout << ans % mod << endl;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < int(n); i++)
using namespace std;
using ll = long long;
const int INF = (1<<30)-1;
const long long LINF = (1LL<<62)-1;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
vector<vector<string>> s = {
{
"bcaa",
"bcdd",
"eegh",
"ffgh"
}, {
"..abc",
"..abc",
"ddgee",
"ffg.j",
"hhiij"
}, {
"...abc",
"...abc",
"def...",
"def...",
"gghhii",
"jjkkll"
}, {
"i..ll.a",
"i..d..a",
"..gd.nn",
"..g..mj",
"hh...mj",
"effbb..",
"ekk.cc."
}
};
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
if (n < 3) {
cout << -1 << endl;
return 0;
}
if (n == 3) {
cout << "..a\n..a\nbb.\n";
return 0;
}
vector<vector<char>> grid(n, vector<char>(n, '.'));
for (int i = 0; i+4 < n; i+=4) {
rep(j, 4) rep(k, 4)
grid[i+j][i+k] = s[0][j][k];
}
int rem = n%4;
rep(i, rem+4) rep(j, rem+4)
grid[n-rem-4+i][n-rem-4+j] = s[rem][i][j];
rep(i, n) {
rep(j, n)
cout << grid[i][j];
cout << '\n';
}
return 0;
}
/*
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < int(n); i++)
using namespace std;
vector<vector<char>> grid;
int n;
bool check3() {
rep(i, n) {
int num = 0;
char prev = '.';
rep(j, n) {
if (grid[i][j] != prev) {
if (grid[i][j] != '.')
num++;
prev = grid[i][j];
}
}
if (num != 3)
return false;
}
rep(j, n) {
int num = 0;
char prev = '.';
rep(i, n) {
if (grid[i][j] != prev) {
if (grid[i][j] != '.')
num++;
prev = grid[i][j];
}
}
if (num != 3)
return false;
}
return true;
}
void dfs(int now, int c) {
if (now == n*n) {
if (!check3())
return;
rep(i, n) {
rep(j, n)
cout << grid[i][j];
cout << '\n';
}
exit(0);
}
int x = now/n, y = now%n;
dfs(now+1, c);
if (x > 0 && grid[x-1][y] == '.') {
grid[x-1][y] = grid[x][y] = 'a'+c;
dfs(now+1, (c+1)%26);
grid[x-1][y] = grid[x][y] = '.';
}
if (y > 0 && grid[x][y-1] == '.') {
grid[x][y-1] = grid[x][y] = 'a'+c;
dfs(now+1, (c+1)%26);
grid[x][y-1] = grid[x][y] = '.';
}
}
int main() {
cin >> n;
grid.resize(n, vector<char>(n, '.'));
if (n < 7)
dfs(0, 0);
else {
random_device rnd;
mt19937 mt(rnd());
while (true) {
rep(i, n) rep(j, n) grid[i][j] = '.';
int cnt = 0, c = 0;
int lim = 3*n*2/3; //1つのドミノは行と列合わせて3箇所を+1する->クオリティの総和/3=ドミノの数
while (cnt < lim) {
int x = mt()%n, y = mt()%n, d = mt()%2;
if (grid[x][y] != '.')
continue;
if (d && x+1 < n && grid[x+1][y] == '.') {
grid[x][y] = grid[x+1][y] = 'a'+c;
c = (c+1)%26;
cnt++;
} else if (y+1 < n && grid[x][y+1] == '.') {
grid[x][y] = grid[x][y+1] = 'a'+c;
c = (c+1)%26;
cnt++;
}
}
if (check3()) {
rep(i, n) {
rep(j, n)
cout << grid[i][j];
cout << '\n';
}
break;
}
}
}
return 0;
}
*/ | #include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define maxn 100005
const int mod=1e9+7;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
int n,m;
char s[maxn<<1];
inline int read(){
int x=0,f=1; char ch=getchar();
for (;ch<'0'||ch>'9';ch=getchar()) if (ch=='-') f=-1;
for (;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
return x*f;
}
int main(){
n=read(); scanf("%s",s+1);
int cnt=0; int res=1;
for (int i=1;i<=(n<<1);i++){
if (s[i]=='B'){if (cnt&1) res=1ll*res*cnt%mod,--cnt; else ++cnt;}
else if (s[i]=='W'){if (cnt&1) ++cnt; else res=1ll*res*cnt%mod,--cnt;}
if (cnt<0){puts("0"); return 0;}
}
if (cnt){puts("0"); return 0;}
for (int i=1;i<=n;i++) res=1ll*res*i%mod;
printf("%d\n",res);
return 0;
}
| 0 |
#include<cstdio>
#include<iostream>
using namespace std;
#define ll long long
int main() {
int n;
ll a, min, max, sum;
min = 100000000;
max = -min;
sum = 0;
cin >> n;
for (int i = 0; i < n; i ++) {
cin >> a;
if (a < min) min = a;
if (a > max) max = a;
sum += a;
}
cout << min << " " << max << " " << sum << endl;
return 0;
}
| #include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <numeric>
using namespace std;
int main() {
vector<int> result;
string n;
string input;
getline(cin, n);
getline(cin, input);
istringstream iss(input);
string num;
while (getline(iss, num, ' ')) {
result.push_back(stoi(num));
}
long long min = *min_element(result.begin(), result.end());
long long max = *max_element(result.begin(), result.end());
long long sum = accumulate(result.begin(), result.end(), 0LL);
cout << min << " " << max << " " << sum << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
/********************************************************************/
#define M1 1000000007
#define M2 998244353
const double pi = 3.14159265;
#define ll long long
#define pll pair<ll,ll>
#define forr(i, n) for(ll i=0;i<n;i++)
#define pb push_back
#define ppb pop_back
#define mp make_pair
#define MT make_tuple
#define V(a) vector<a>
#define vi vector<ll>
#define CASE(t) ll t; cin>>t; while(t--)
#define endl '\n'
#define space ' '
#define enter cout<<endl
#define yes cout<<"YES"<<endl
#define no cout<<"NO"<<endl
#define all(x) x.begin(), x.end()
#define sortall(x) sort(all(x))
#define collect(v, n) for(ll i = 0; i < n;i++){cin>>v[i];}
#define deci(n) fixed << setprecision(n) //sets no of digits to show after decimal
#define setcount(n) __builtin_popcount(n) //the number of ones in the int
#define setcountll(n) __builtin_popcountll(n) //the number of ones in the ll
#define parity(n) __builtin_parity(n) //the parity (even or odd) of the number of ones
#define clz(n) __builtin_clz(n) //the number of zeros at the beginning of the number
#define clzll(n) __builtin_clzll(n) //the number of zeros at the beginning of the ll
#define ctz(n) __builtin_ctz(n) //the number of zeros at the end of the number
void deb(ll x) { cout << x << endl;}
void deb(int x) { cout << x << endl;}
void deb(unsigned int x) { cout << x << endl;}
void deb(unsigned ll x) { cout << x << endl;}
void deb(float x) { cout << x << endl;}
void deb(double x) { cout << x << endl;}
void deb(long double x) { cout << x << endl;}
void deb(char x) {cout << '\'' << x << '\'' << endl;}
void deb(string s) { cout << '\"' << s << '\"' << endl;}
void deb(vector<ll> v) { for (auto x : v) cout << x << ' '; cout << endl;}
void deb(bool bb) {cout << (bb ? "True" : "False") << endl;}
void deb(map<ll, ll> mpp) {for (auto x : mpp) cout << x.first << ' ' << x.second << endl;}
void deb(pair<ll, ll> pp) { cout << "{" << pp.first << "," << pp.second << "}" << endl;}
ll gcd(ll x, ll y) {
if (x == 0) return y;
return gcd((ll) y % x, (ll) x);
}
template<typename T>
#define o_set(T) tree<T, null_type,less_equal<T>, rb_tree_tag,tree_order_statistics_node_update>
//member functions :
//1. order_of_key(k) : number of elements strictly lesser than k
//2. find_by_order(k) : k-th element in the set
// MULTISET ==> less_equal
// SET ==> less
ll powM(ll x, ll y, ll m) {
ll ans = 1, r = 1;
x %= m;
while (r > 0 && r <= y) {
if (r & y) {
ans *= x;
ans %= m;
}
r <<= 1;
x *= x;
x %= m;
}
return ans;
}
map<long long, long long> factorize(long long n) {
map<long long, long long> ans;
for (long long i = 2; i * i <= n; i++) {
while (n % i == 0) {
ans[i]++;
n /= i;
}
}
if (n > 1) {
ans[n]++;
n = 1;
}
return ans;
}
ll countBits(ll n) {
ll count = 0;
while (n)
{
count++;
n >>= 1;
}
return count;
}
ll isP(ll n) {
if (n == 0 || n == 1)
return 0;
for (ll i = 2; i <= sqrt(n); i++) {
if (n % i == 0)
return 0;
}
return 1;
}
/* **********END OF TEMPLATE*********** */
ll check(ll ar[], ll mid, ll k, ll n) {
ll tmp = 0;
for (ll i = 0; i < n; i++) {
tmp += (ar[i] / mid + (ar[i] % mid != 0) - 1);
}
if (tmp <= k)
return 1;
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n;
ll k;
cin >> n >> k;
double ar[n];
for (ll i = 0; i < n; i++) {
cin >> ar[i];
ar[i] = (double)(ar[i] + 1) / (double)2;
}
double prefs[n + 1];
prefs[0] = 0.0000;
for (ll i = 0; i < n; i++) {
prefs[i + 1] = prefs[i] + ar[i];
}
double mx = -1;
for (ll i = k; i <= n; i++) {
if (prefs[i] - prefs[i - k] > mx)
mx = (prefs[i] - prefs[i - k]);
}
cout << deci(10) << mx << endl;
return 0;
}
| #include<bits/stdc++.h>
#define REP(i,n) for(int i=0;i<n;i++)
#define RREP(i,n) for(int i=n;i>=0;i--)
#define FOR(i,m,n) for(int i=m;i<n;i++)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
using namespace std;
typedef long long ll;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
//const ll INF = 1LL << 60;
//const int INF = 1001001001;
int main(void){
int n,k;
cin >> n >> k;
int p[n];
REP(i,n) cin >> p[i];
int sumf=0,suml=0,maxs=0;
REP(i,n){
sumf+=p[i];
if(i>=k){
suml+=p[i-k];
chmax(maxs,sumf-suml);
}
}
if(n==k) maxs=sumf;
double ans=(double)k/2 + (double)maxs/2;
printf("%.7f\n",ans);
return 0;
} | 1 |
#include <bits/stdc++.h>
#define REP(i, n) for(long long i=0; i<n; i++)
#define REPR(i, n) for(long long i=n-1; i>=0; i--)
#define FOR(i, m, n) for(long long i=m; i<=n; i++)
#define FORR(i, m, n) for(long long i=m; i>=n; i--)
#define SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define VSORTR(v) sort(v.rbegin(), v.rend());
#define ALL(v) (v).begin(),(v).end()
#define FIN ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<ll, ll>;
const ll mod = 1e9+7;
const ll inf = 1e15;
int main(){FIN
ll n,m;cin>>n>>m;
vll a(n);
REP(i,n) cin>>a[i];
vll rui(n+1,0);
ll sum=0;
REP(i,n){
sum += a[i];
rui[i+1] = sum % m;
}
map<ll,ll> mp;
REP(i,n+1) mp[rui[i]]++;
ll ans=0;
for(auto p:mp){
// cout<<p.second<<endl;
ans += p.second * (p.second-1) /2;
}
cout<<ans<<endl;
return 0;
} | #include<iostream> //53~70
using namespace std;
int main(){
int a[1000];
int b[1000];
int t[1000];
int n=0;
int m=0;
int i=0;
int j=0;
int k=0;
cin>>n;
cin>>m;
for(i=0;i<n;i++){
cin>>a[i];
}
for(i=0;i<m;i++){
cin>>b[i];
}
for(i=0;i<1000;i++){
t[i]=0;
}
for(i=0;i<m;i++){
for(j=0;j<n;j++){
if(b[i]>=a[j]){
t[j]++;
break;
}
}
}
for(i=0;i<n;i++){
if(t[k]<t[i]){
k=i;
}
}
k++;
cout<<k<<endl;
} | 0 |
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7; // change if needed
struct Modint {
ll val;
Modint (ll _val = 0)
: val(_val % MOD) {}
Modint operator+ (Modint other) const {
return Modint(val + other.val);
}
void operator+= (Modint other) {
val += other.val;
val %= MOD;
}
Modint operator- () const {
return Modint(MOD - val);
}
Modint operator- (Modint other) const {
return Modint(val + MOD - other.val);
}
void operator-= (Modint other) {
val += MOD - other.val;
val %= MOD;
}
Modint operator* (Modint other) const {
return Modint(val * other.val);
}
void operator*= (Modint other) {
val *= other.val;
val %= MOD;
}
bool operator== (Modint other) const {
return val == other.val;
}
bool operator!= (Modint other) const {
return val != other.val;
}
};
Modint exp (Modint a, int k) {
if (k == 0) {
return Modint(1);
} else if (k % 2 == 0) {
Modint half = exp(a, k / 2);
return half * half;
} else {
return a * exp(a, k - 1);
}
}
Modint inv (Modint a) {
return exp(a, MOD - 2);
}
ostream& operator<< (ostream& out, Modint p) {
out << p.val;
return out;
}
const int MAX_N = 3e5 + 5;
struct State {
int pc, sl, sv;
State (int _pc, int _sl, int _sv) :
pc(_pc), sl(_sl), sv(_sv) {}
};
ostream& operator<< (ostream &out, State s) {
out << "(" << s.pc << " " << s.sl << " " << s.sv << ")";
return out;
}
State nxt (State s, int c) {
if (s.pc == 2) return s;
if (s.sl == 0) {
if (c == 0) return State(s.pc, s.sl + 1, 0);
if (c == 1) return State(s.pc + 1, 0, 0);
}
if (s.sl == 1) {
return State(s.pc, s.sl + 1, 2 * s.sv + c);
}
if (c == 0) {
if (s.sv == 0) {
return State(s.pc, 1, 0);
} else {
return State(s.pc, 1, 0);
}
} else {
if (s.sv == 0) {
return State(s.pc, 1, 0);
} else {
return State(s.pc + 1, 0, 0);
}
}
};
Modint _dp [MAX_N][3][3][4];
Modint& dp (int i, State s) {
return _dp[i][s.pc][s.sl][s.sv];
}
int main () {
string s;
cin >> s;
int n = s.size();
vector<State> alls;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 4; k++) {
alls.push_back(State(i, j, k));
}
}
}
dp(0, State(0, 0, 0)) = Modint(1);
for (int i = 0; i < n; i++) {
for (State st : alls) {
if (s[i] != '1') {
dp(i + 1, nxt(st, 0)) += dp(i, st);
}
if (s[i] != '0') {
dp(i + 1, nxt(st, 1)) += dp(i, st);
}
}
}
Modint ans (0);
ans += dp(n, State(2, 0, 0));
ans += dp(n, State(1, 2, 1));
ans += dp(n, State(1, 0, 0));
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define mp make_pair
#define ff first
#define ss second
#define pb push_back
#define pf push_front
#define popb pop_back
#define popf pop_front
#define all(v) v.begin(),v.end()
const int maxn = 3e5 + 100;
const ll inf = 2e18, mod = 1e9 + 7;
int h, w, a, b;
ll fact[maxn], invfact[maxn], dp[maxn];
ll comb(int n, int r)
{
return (fact[n] * (invfact[r] * invfact[n - r] % mod) % mod);
}
ll powmod(ll a, ll b)
{
if (!b)
return 1;
ll tmp = powmod(a, b / 2);
tmp = tmp * tmp % mod;
if (b & 1)
tmp = tmp * a % mod;
return tmp;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
fact[0] = invfact[0] = 1;
for (int i = 1; i < maxn; i++)
fact[i] = fact[i - 1] * i % mod, invfact[i] = powmod(fact[i], mod - 2);
scanf("%d %d %d %d", &h, &w, &a, &b);
for (int i = 0; i < h - a; i++)
dp[i] = comb(i + b - 1, i);
ll ans = 0;
for (int i = 0; i < h - a; i++)
ans = (ans + dp[i] * comb(w - b - 1 + h - i - 1, w - b - 1) % mod) % mod;
printf("%lld\n", ans);
}
| 0 |
#include<iostream>
#include<vector>
using namespace std;
int main(){
int n,q;
int cnt=0;
cin>>n;
vector<int>s(n);
for(int i=0;i<n;i++){
cin>>s[i];
}
cin>>q;
vector<int>t(q);
for(int i=0;i<q;i++){
cin>>t[i];
}
for(int i=0;i<q;i++){
for(int j=0;j<n;j++){
if(s[j]==t[i]){
cnt++;
break;
}
}
}
cout<<cnt<<endl;
return 0;
}
| #include <iostream>
#include <algorithm>
using namespace std;
bool Bsearch(int key, int A[], int len) {
int l = 0, r = len - 1;
while (l <= r) {
int mid = l + (r - l) / 2;
if (A[mid] > key)
r = mid - 1;
else if (A[mid] < key)
l = mid + 1;
else
return true;
}
return false;
}
int main() {
int n, *S;
int q, *T;
int ans = 0;
cin >> n;
S = new int[n];
for (int i = 0; i < n; i++)
cin >> S[i];
cin >> q;
T = new int[q];
for (int i = 0; i < q; i++)
cin >> T[i];
sort(S, S + n);
for (int i = 0; i < q; i++)
for (int j = 0; j < n; j++)
if (Bsearch(T[i], S, n) == true) {
ans++;
break;
}
cout << ans << endl;
delete[] S;
delete[] T;
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i = 0; i < n; i++)
#define Rep(i,n) for(ll i = 1; i < n; i++)
#define sz(x) int(x.size())
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define YesorNo(a) printf(a ? "Yes\n" : "No\n")
#define endl '\n'
#define fi first
#define se second
using ll = long long;
using P = pair<int,int>;
using Pl = pair<ll,ll>;
template<class T> using V = vector<T>;
const int dx[] = {0,1,0,-1,1,1,-1,-1};
const int dy[] = {1,0,-1,0,1,-1,-1,1};
const int inf = (1<<30)-1;
const ll infll = (1LL<<62)-1;
ll ceil(const ll &a, const ll &b){return ((a)+(b)-1)/b;}
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
int main(){
ll n, a, b;
cin >> n >> a >> b;
V<ll> x(n);
rep(i,n) cin >> x[i];
V<ll> dist(n-1);
rep(i,n) {
dist[i] = x[i+1] - x[i];
dist[i] *= a;
}
sort(all(dist));
int idx = 0;
ll ans = 0;
while(dist[idx] < b && idx < n-1) {
ans += dist[idx];
idx++;
}
ans += 1LL * (n-1 - idx) * b;
cout << ans << endl;
} | #include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#define IO(i, o) freopen(i, "r", stdin), freopen(o, "w", stdout)
using namespace std;
using namespace __gnu_pbds;
typedef tree<long long, null_type, less<long long>, rb_tree_tag, tree_order_statistics_node_update> indexed_set;
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
int n, a, b, x[100000];
int main(){
//IO("input.txt", "output.txt");
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> a >> b >> x[0];
long long cnt = 0;
for(int i = 1; i < n; i++){
cin >> x[i];
cnt += min((long long)b, a * (long long)(x[i] - x[i - 1]));
}
cout << cnt << "\n";
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 2005;
const int mod = 1e9+7;
int fac[N],combi[N][N];
int add(int x,int y) {
int ret = ((x+y)%mod + mod)%mod;
return ret;
}
int mul(int x,int y) {
ll ret = (ll)x*y;
ret%=mod;
return ret;
}
int num[2];
int group[2];
int dp[N][N];
int inv[N];
int invFac[N];
int solveDp(int x,int rem) {
if(rem==0) {
return 1;
}
if(x>num[1]) {
return 0;
}
int &ret = dp[x][rem];
if(ret != -1) {
return ret;
}
ret = solveDp(x+1,rem);
int cur = 1;
for(int j = 0;j<group[0];++j) {
cur = mul(cur, invFac[x]);
}
for(int f = group[0];f<=group[1] && f*x<=rem;++f) {
int tot = f*x;
int m = fac[tot];
int t = cur;
t = mul(t, invFac[f]);
m = mul(t,m);
m = mul(combi[rem][tot],m);
ret = add(ret, mul(m,solveDp(x+1,rem-tot)));
cur = mul(cur,invFac[x]);
}
return ret;
}
int myPow(int x,int c) {
int ret = 1;
while(c>0) {
if(c&1) {
ret = mul(ret,x);
}
x = mul(x,x);
c/=2;
}
return ret;
}
void solve() {
int n;
memset(dp,-1,sizeof(dp));
scanf("%d",&n);
for(int i=0;i<2;++i) {
scanf("%d",&num[i]);
}
for(int i=0;i<2;++i) {
scanf("%d",&group[i]);
}
fac[0] = 1;
inv[0] = 1;
invFac[0] = 1;
for(int i=1;i<N;++i) {
fac[i] = mul(fac[i-1],i);
inv[i] = myPow(i,mod-2);
invFac[i] = myPow(fac[i],mod-2);
}
for(int i=0;i<N;++i) {
combi[i][i] = combi[i][0] = 1;
for(int j = 1;j<i;++j) {
combi[i][j] = add(combi[i-1][j],combi[i-1][j-1]);
}
}
printf("%d\n", solveDp(num[0],n));
}
int main()
{
//freopen("input.txt","r",stdin);
solve();
} | #include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
const int N = 1e3 + 5;
const int mod = 1e9 + 7;
using namespace std;
int n, a, b, c, d, fac[N], inv[N], g[N][N], f[N][N], ans;
template < typename T >
inline T read()
{
T x = 0, w = 1; char c = getchar();
while(c < '0' || c > '9') { if(c == '-') w = -1; c = getchar(); }
while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * w;
}
int fpow(int x, int y)
{
int res = 1;
for( ; y; y >>= 1, x = 1ll * x * x % mod)
if(y & 1) res = 1ll * res * x % mod;
return res;
}
int C(int n, int m)
{
if(n < 0 || m < 0 || n < m) return 0;
return 1ll * fac[n] * inv[m] % mod * inv[n - m] % mod;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("cpp.in", "r", stdin);
#endif
n = read <int> (), a = read <int> (), b = read <int> (), c = read <int> (), d = read <int> ();
for(int i = (fac[0] = 1); i <= n; i++) fac[i] = 1ll * fac[i - 1] * i % mod;
inv[n] = fpow(fac[n], mod - 2);
for(int i = n - 1; i >= 0; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
g[0][0] = 1;
for(int res = 1, i = a; i <= b; i++, res = 1)
for(int j = 1; j <= n && i * j <= n; j++)
g[i * j][j] = 1ll * g[i * (j - 1)][j - 1] * C(i * j, i) % mod * inv[j] % mod * fac[j - 1] % mod;
f[a - 1][0] = 1;
for(int i = a; i <= b; i++)
for(int j = 0; j <= n; j++)
{
f[i][j] = f[i - 1][j];
for(int k = c; k <= d; k++)
{
if(i * k > j) break;
f[i][j] = (1ll * f[i - 1][j - i * k] * C(n - (j - i * k), i * k) % mod * g[i * k][k] + f[i][j]) % mod;
}
}
printf("%d\n", f[b][n]);
return 0;
}
| 1 |
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repo(i,n) for(int i = 1; i < (int)(n); i++)
#define pb push_back
#define np next_permutation
#define fi first
#define se second
#define all(x) (x).begin(),(x).end()
#define mod 1000000007
#define pi acos(-1.0)
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
//cout << fixed << setprecision (20); 小数点以下2０桁まで
//intの最大値2147483647 ≒ 2×10^9
//long longの最大値9223372036854775807 ≒ 9×10^18
//'0'+=16; で大文字に
//'大文字'+=32; で小文字に
//s[i]-'0'でchar文字→int数に;
//string s = to_string(int数);
//int n = stoi(string文字列)
//実行時間制約2秒では２×10^8回くらいまで計算できる
int main() {
ll a,b,k;
cin >> a>>b>>k;
rep(i,k){
if(i%2==0){
if(a%2==1) a--;
b+=a/2;
a/=2;
}
if(i%2==1){
if(b%2==1) b--;
a+=b/2;
b/=2;
}
}
cout << a << " " << b << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long double ans=0,n,m,d;
cin >> n >> m >> d;
if(d==0) {
ans=(m-1)/n;
} else {
ans=(n-d)*2*(m-1)/n/n;
}
cout << fixed << setprecision(10);
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repi(i, s, n) for (int i = (s); i < (n); i++)
#ifdef LOCAL
#define INPUT_FILE \
ifstream in("atcoder-problems/abc045_b.txt"); \
cin.rdbuf(in.rdbuf());
#define print_vec(v) \
rep(l, v.size()) { cout << v[l] << " "; } \
cout << endl;
#else
#define INPUT_FILE
#define print_vec(v)
#endif
#define CIN_OPTIMIZE \
cin.tie(0); \
ios::sync_with_stdio(false);
typedef pair<int, int> P;
typedef long long ll;
typedef pair<ll, ll> pl;
const int INF = 100100100;
const ll LINF = 1e18 + 100;
const int MOD = 1e9 + 7;
int main() {
INPUT_FILE CIN_OPTIMIZE;
string A, B, C;
cin >> A >> B >> C;
int a = 0, b = -1, c = -1;
char next = 'a';
while (true) {
if (next == 'a') {
a++;
if (a == A.size()) {
cout << "A" << endl;
return 0;
}
next = A[a];
} else if (next == 'b') {
b++;
if (b == B.size()) {
cout << "B" << endl;
return 0;
}
next = B[b];
} else {
c++;
if (c == C.size()) {
cout << "C" << endl;
return 0;
}
next = C[c];
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define END '\n'
#define int long long
#define pb push_back
#define pii pair<int, int>
#define ff first
#define ss second
#define trace(x) cerr<<x<<END;
#define loop(i, a, b) for(int i = (a); i < (b); i++)
#define loopb(i, b, a) for(int i = (b); i > (a); --i)
const int mod = 1e9+7;
const int mod1 = 998244353;
const int inf = 1e18;
set<int> s;
int n,x;
void solve()
{
cin>>n;
loop(i,0,n)
{
cin>>x;
s.insert(x);
}
cout<<((int)s.size() == n ? "YES" : "NO");
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
/*int t;
cin>>t;
loop(i,1,t+1)*/
solve();
//cerr<<END<<1.0*clock();
return 0;
}
| 0 |
#include <iostream>
#include <vector>
using namespace std;
vector<char>stack;
// stack.back() will bring you to the last index
void checkForT(string s , char character, int index){
if(!stack.empty() && stack.back()!= 'S'){
stack.push_back(character);
}
else if(!stack.empty()){
stack.pop_back();
}
else if(stack.empty()){
stack.push_back(character);
}
}
void checkForS(string s , char character, int index){
stack.push_back(character);
}
int main(){
string s;
cin >> s;
for(int i = 0; i < s.size(); i++){
if(s[i] == 'S'){
checkForS(s , s[i] , i);
}
else{ // else if stack[i]=='T'
checkForT(s, s[i] , i);
}
}
cout << stack.size() << endl; // Amount of elements left in stack
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const int MOD = 1000000007;
int main()
{
string x;
cin >> x;
int stack = 0, puyo = 0;
rep(i, x.length())
{
if (x[i] == 'S')
stack++;
else if (stack)
{
stack--;
puyo++;
}
}
cout << x.length() - 2 * puyo << endl;
} | 1 |
#include<bits/stdc++.h>
#include<string.h>
#define ll long long
#define pf printf
#define sf scanf
#define ff first
#define ss second
#define clr clear()
#define sz size()
#define pb push_back
#define mk make_pair
#define pi acos(-1)
#define inf 20000000000000000
#define mod 998244353
#define ull unsigned long long int
#define f(i,k,n) for(i=k;i<n;i++)
#define fr(i,n,k) for(i=n;i>=k;i--)
#define ent(a) scanf("%lld",&a)
#define ent2(a,b) scanf("%lld%lld",&a,&b)
#define ent3(a,b,c) scanf("%lld%lld%lld",&a,&b,&c)
#define mem(a) memset(a,0,sizeof(a))
#define vec(v,s) vector<ll>v[s]
#define arr(a,s) ll a[s];
/*#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")*/
//knight and king//
int dr[]= {2,2,-2,-2,1,-1,1,-1};
int dc[]= {1,-1,1,-1,2,2,-2,-2};
int dr1[]= {0,0,1,1,1,-1,-1,-1};
int dc1[]= {1,-1,1,0,-1,0,1,-1};
int dr2[]= {0,0,1,-1};
int dc2[]= {1,-1,0,0};
////////////////////////////
using namespace std;
#define ma 200
ll a[4][4];
ll mark[ma];
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll i,j,x,y,n,m;
while(cin>>n)
{
memset(mark,-1,sizeof(mark));
cin>>m;
vector<pair<ll,ll> >v;
ll max1=n;
for(i=0;i<m;i++)
{
cin>>x>>y;
v.pb({x,y});
mark[x]=y;
max1=max(max1,x);
}
for(i=1;i<=max1;i++)
{
if(mark[i]==-1)
{
if(i==1&&max1>1)mark[i]=1;
else mark[i]=0;
}
}
bool f=0;
for(i=0;i<v.sz;i++)
{
if(mark[v[i].ff]!=v[i].ss)f=1;
}
if(mark[1]==0&&max1>1)f=1;
if(f)cout<<"-1"<<endl;
else
{
for(i=1;i<=max1;i++)cout<<mark[i];
cout<<endl;
}
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
#define endl "\n"
//#define int long long
#define ALL(x) begin(x),end(x)
#define RALL(a) (a).rbegin(), (a).rend()
#define _CRT_SECURE_NO_WARNINGS
#define rep(i, n) for (int i = 0; i < n; i++)
const int MOD = 1e9 + 7;
const ll INF = 1LL << 60;
const int inf = 1 << 25;
constexpr long double pi = 3.141592653589793238462643383279;
int dx[] = { 1,0,-1,0 };
int dy[] = { 0,1,0,-1 };
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll fact(ll i) {
if (i == 0) return 1;
return ((fact(i - 1)) * i) % MOD;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
return a * b / gcd(a, b);
}
ll keta(ll n) {
if (n == 0) return 1;
ll count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) {
ll sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
ll mch(ll n) {
if (n == 1) return 1;
else return n * mch(n - 1);
}
ll modpow(ll a, ll n, ll mod) {
ll hi = 1;
while (n > 0) {
if (n & 1) hi = hi * a % mod;
a = a * a % mod;
n >>= 1;
}
return hi;
}
bool is_prime(const unsigned n) {
switch (n) {
case 0: // fall-through
case 1: return false;
case 2: // fall-through
case 3: return true;
} // n > 3 が保証された
if (n % 2 == 0 || n % 3 == 0) return false;
for (unsigned i = 5; i * i <= n; i += 6) {
if (n % i == 0) return false; // (6の倍数)-1
if (n % (i + 2) == 0) return false; // (6の倍数)+1
}
return true;
}
/*signed*/int main(void) {
int n, m;
cin >> n >> m;
vector<pair<int, int>> p(m);
rep(i, m) {
int s, c;
cin >> s >> c;
s--;
p[i] = make_pair(s, c);
}
rep(i, 1000) {
string s = to_string(i);
if (s.size() == n) {
bool ans = true;
rep(j, m) {
if ((s[p[j].first] - '0') != p[j].second)ans = false;
}
if (ans) {
cout << i << endl;
return 0;
}
}
}
cout << -1 << endl;
return 0;
} | 1 |
#include<stdio.h>
#include<string.h>
char s[524288];
int dp[4],dp2[4];
int main()
{
scanf("%s",s);
int n=strlen(s);
s[n]='1';
n++;
dp[2]=1;
int ans=1;
for(int i=0;i<n;i++)
{
for(int j=0;j<4;j++)
{
dp2[j]=dp[j];
dp[j]=0;
}
for(int j=0;j<4;j++)
{
dp[j&1]+=dp2[j];
if(dp[j&1]>=1000000007)
{
dp[j&1]-=1000000007;
}
}
for(int j=0;j<4;j++)
{
if(i&1)
{
if(j==3)
{
continue;
}
dp[j|2]+=dp2[j];
if(dp[j|2]>=1000000007)
{
dp[j|2]-=1000000007;
}
}
else
{
dp[2+(j!=0)]+=dp2[j];
if(dp[2+(j!=0)]>=1000000007)
{
dp[2+(j!=0)]-=1000000007;
}
}
}
if(s[i]=='1')
{
dp[0]=0;
dp[1]=0;
}
else if(s[i]=='0')
{
dp[2]=0;
dp[3]=0;
}
else
{
ans<<=1;
if(ans>=1000000007)
{
ans-=1000000007;
}
}
}
ans-=dp[2];
if(ans<0)
{
ans+=1000000007;
}
ans-=dp[3];
if(ans<0)
{
ans+=1000000007;
}
printf("%d\n",ans);
return 0;
} | #include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);++i)
using namespace std;
const int N=300005,P=1e9+7;
int n,f[N][3][3];
char s[N];
void addx(int&k1,int k2){
(k1+=k2)>=P&&(k1-=P);
}
int main(){
scanf("%s",s+1);
n=strlen(s+1);
if(n==1){
puts(s[1]=='0'?"0":"1");
return 0;
}
f[0][0][0]=1;
rep(i,1,n){
if(s[i]!='1'){
rep(j,0,2)rep(k,0,2)addx(f[i][j][k?3-k:1],f[i-1][j][k]);
}
if(s[i]!='0'){
rep(j,0,2)rep(k,0,2)addx(f[i][min(2,j+(k==0))][max(k-1,0)],f[i-1][j][k]);
}
}
int ans=0;
rep(i,0,2)rep(j,0,2)if(i>=2||j==0)addx(ans,f[n][i][j]);
printf("%d\n",ans);
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
string s;
int w;
int main(void){
cin>>s>>w;
for(int i=0;i<s.size();i=i+w){
cout<<s[i];
}
cout<<endl;
}
| #include<bits/stdc++.h>
//g++ -std=c++11
using namespace std;
typedef long long ll;
#define rep(i,n) for (long long i = 0; i < (n); ++i)
#define DIV 1000000007 //10^9+7
int main(){
ll K, X;
cin >> K >> X;
K--;
for(ll i = X - K; i <= X + K; i++) {
cout << i;
if(i == X + K) {
cout << endl;
} else {
cout << " ";
}
}
}
| 0 |
#include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
#define rep(i,a,b) for(ll i=a;i<b;i++)
#define rrep(i,b,a) for(int i=b;i>=a;i--)
#define fori(a) for(auto i : a )
#define all(a) begin(a), end(a)
#define set(a,b) memset(a,b,sizeof(a))
#define sz(a) a.size()
double pi=acos(-1);
#define ll long long
#define ull unsigned long long
#define pb push_back
#define PF push_front //deque
// #define mp make_pair
#define pq priority_queue
const ll mod=1000000007;
// #define f first
// #define s second
#define pii pair< ll, ll >
#define vi vector<int>
#define vpii vector<pii>
#define debug(v) for(auto i:v) cout<<i<<" ";
#define tc int t; cin >> t; while(t--)
using namespace boost::multiprecision;
using namespace std;
void optimizeIO(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int N=1000005;
ll fact[N],invfact[N];
ll power(ll x,ll y){
if(y<=0) return 1LL;
ll z=power(x,y/2);
if(y%2) return (((z*z)%mod)*x)%mod;
return (z*z)%mod;
}
void pre(){
fact[0]=invfact[0]=invfact[1]=fact[1]=1;
rep(i,2,N) fact[i]=(i*fact[i-1])%mod;
rep(i,2,N) invfact[i]=(invfact[i-1]*power(i,mod-2))%mod;
}
ll nCr(ll n,ll k){ return (((fact[n]*invfact[n-k])%mod)*invfact[k])%mod; }
const int N1=1e6+1;
vector<int> isprime(N1,1),prime;
void seive(){
rep(i,2,sqrt(N1)+1){
if(isprime[i]){
for(int j=i*i;j<N1;j+=i) isprime[j]=0;
prime.pb(i);
}
}
rep(i,sqrt(N1)+1,N1) if(isprime[i]) prime.pb(i);
}
struct dsu {
vector<int> par, rank;
dsu(int n): par(n+1), rank(n+1) {
for (int i = 0; i <= n; i++) {
par[i] = i;
rank[i]= 1;
}
}
int root(int a) {
if (a == par[a]) return a;
return par[a] = root(par[a]);
}
void merge(int a, int b) {
a = root(a);
b = root(b);
if (a == b) return;
if (rank[a] > rank[b]) swap(a, b);
par[b] = a;
}
set<int> parent(int n){
set<int> s;
for(int i=1;i<=n;i++){
s.insert(root(i));
}
return s;
}
};
void solve(){
string s;
cin>>s;
int a=s[0]-'0',b=s[1]-'0',c=s[2]-'0',d=s[3]-'0';
vector<string> v1={"+--","---","--+","-+-","++-","-++","+-+","+++"};
rep(i,0,8){
int rem=7-a;
if(v1[i][0]=='+') rem-=b;
else rem+=b;
if(v1[i][1]=='+') rem-=c;
else rem+=c;
if(v1[i][2]=='+') rem-=d;
else rem+=d;
if(rem==0){
cout<<a<<v1[i][0]<<b<<v1[i][1]<<c<<v1[i][2]<<d<<"=7"<<endl;
return;
}
}
}
int main(){
optimizeIO();
int r=1;
{solve();}
}
| #include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <fstream>
#include <cassert>
#include <cstring>
#include <unordered_set>
#include <unordered_map>
#include <numeric>
#include <ctime>
#include <bitset>
#include <complex>
#include <random>
using namespace std;
#define int long long
vector<vector<int>> solivoli =
{
{1, 2, -1, -1, 3, 3},
{1, 2, -1, -1, 4, 4},
{5, 5, 7, 8, -1, -1},
{6, 6, 7, 8, -1, -1},
{-1, -1, 9, 9, 11, 12},
{-1, -1, 10, 10, 11, 12}
};
vector<vector<int>> soli = {
{1, 1, 3, 4},
{2, 2, 3, 4},
{5, 6, 7, 7},
{5, 6, 8, 8}
};
vector<vector<int>> voli = {
{1, 1, -1},
{-1, -1, 2},
{-1, -1, 2}
};
vector<vector<int>> volians5 {
{1, 2, 3, -1, -1},
{1, 2, 3, -1, -1},
{4, 5, 5, 6, 6},
{4, -1, 8, 9, 9},
{7, 7, 8, 10, 10}
};
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<vector<int>> ans(n, vector<int> (n, -1));
if (n == 7) {
cout << "aabbcc." << endl;
cout << "dd.ee.f" << endl;
cout << "..a..cf" << endl;
cout << "..a..cb" << endl;
cout << "ll.jj.b" << endl;
cout << "..a..ch" << endl;
cout << "..a..ch" << endl;
return 0;
}
if (n % 3 == 0) {
for (int i = 0; i < n; i += 3) {
for (int di = 0; di < 3; di++) {
for (int dj = 0; dj < 3; dj++) {
ans[i + di][i + dj] = voli[di][dj];
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (ans[i][j] == -1) {
cout << '.';
} else {
cout << (char)(ans[i][j] + 'a');
}
}
cout << endl;
}
return 0;
}
int wn = n;
if (n % 2 == 1 && n >= 5) {
for (int i = n - 5; i < n; i += 5) {
for (int di = 0; di < 5; di++) {
for (int dj = 0; dj < 5; dj++) {
ans[i + di][i + dj] = volians5[di][dj];
}
}
}
n -= 5;
}
if (n % 2 == 0 && n != 2) {
int c1 = 0;
int c2 = 0;
int ln = n;
while (ln % 4) {
ln -= 6;
c2++;
}
c1 = ln / 4;
for (int i = 0; i < 4 * c1; i += 4) {
for (int di = 0; di < 4; di++) {
for (int dj = 0; dj < 4; dj++) {
ans[i + di][i + dj] = soli[di][dj];
}
}
}
for (int i = 4 * c1; i < n; i += 6) {
for (int di = 0; di < 6; di++) {
for (int dj = 0; dj < 6; dj++) {
ans[i + di][i + dj] = solivoli[di][dj];
}
}
}
for (int i = 0; i < wn; i++) {
for (int j = 0; j < wn; j++) {
if (ans[i][j] == -1) {
cout << '.';
} else {
cout << (char)(ans[i][j] + 'a');
}
}
cout << endl;
}
return 0;
}
cout << -1 << endl;
}
| 0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
int main(void){
char buf[128] = { 0 };
short grid[64][64] = { {0} };
int H,W;
fgets(buf, sizeof(buf), stdin);
sscanf(buf, "%d %d", &H, &W);
for(int i = 0; i < H; i++){
memset(buf, 0, sizeof(buf));
fgets(buf, sizeof(buf), stdin);
for(int j = 0; j < W; j++)
if(buf[j] == '#') grid[i+1][j+1] = 1;
}
int flag = 0;
for(int i = 1; i < H+1; i++){
for(int j = 1; j < W+1; j++){
if(grid[i][j] == 0) continue;
else{
if(grid[i-1][j] != 1 && grid[i][j-1] != 1
&& grid[i+1][j] != 1 && grid[i][j+1] != 1){
flag = 1;
break;
}
}
}
if(flag) break;
}
if(flag == 0) printf("Yes\n");
else printf("No\n");
return 0;
}
| #include <iostream>
#include <queue>
#include <vector>
#include <climits>
#include <algorithm>
using namespace std;
/*
* union-find???????£??????\???????????????
*/
#define MAX_V 10001
typedef struct UF{
int parent;
}UF;
UF uf[MAX_V + 1];
/*
* ?????????idx???parent??¨???????????????????¨??????????
*/
void initialize(int num){
int i ;
for (i=1; i <= num; i++) {
uf[i].parent = i;
}
}
/*
* ??????????±?????????°????????????????????????
*/
int find(int a){
if (a == uf[a].parent) {
return a;
}
return uf[a].parent = find(uf[a].parent);
}
int isSame(int a, int b){
if (find(a) == find(b)) {
return 1;
}
else{
return 0;
}
}
void unite(int a, int b){
a = find(a);
b = find(b);
if (a == b) {
return;
}
uf[b].parent = a;
}
/*
* ??\??????Kruskal??????????????°??????(??????????????\????????¨??????????£?)
* ?¢???????????????????X?????????????????¢???????????????X???????????????????????¨??§????°???¨?????¨????±???????
*/
#define MAX_V 10001
#define MAX_E 100001
#define INF INT_MAX
typedef struct edge{
int from;
int to;
int cost;
}edge;
edge es[MAX_E];
// cost?????????????????¢??°
bool cmp(const edge& e1, const edge& e2){
return e1.cost < e2.cost;
}
/*
* e:???????????°
* v:?????????????????°
*/
int Kruskal(int e, int v){
int res = 0;
//?????????????????????????????????
sort(es, es + e, cmp);
//union-find????????????
initialize(v);
for (int i = 0; i< e; i++) {
edge e = es[i];
if (!isSame(e.from, e.to)) {
unite(e.from, e.to);
res += e.cost;
}
}
return res;
}
int main( ){
int i, V, E, u, v, c, ans;
cin >> V >> E;
for (i = 0; i < E; i++) {
cin >> u >> v >> c;
es[i].from = u;
es[i].to = v;
es[i].cost = c;
}
ans = Kruskal(E, V);
cout << ans << endl;
return 0;
} | 0 |
#include <stdio.h>
int main(void)
{
int n,a[4],t[100],p[100],i,j,k;
scanf("%d",&n);
for(i=0;i!=n;++i)
t[i]=0;
for(i=0;i!=n*(n-1)/2;i++){
for(j=0;j!=4;j++)
scanf("%d",&a[j]);
if(a[2]<a[3])
t[a[1]-1]+=3;
else if(a[2]>a[3])
t[a[0]-1]+=3;
else{
t[a[0]-1]+=1;
t[a[1]-1]+=1;
}
}
for(i=0;i!=n;++i)
p[i]=t[i];
for(i=0;i!=n;++i){
for(j=i;j!=n;j++){
if(p[i]<p[j]){
k=p[i];
p[i]=p[j];
p[j]=k;
}
}
}
for(i=0;i!=n;++i){
for(j=0;j!=n;++j){
if(t[i]==p[j]){
printf("%d\n",j+1);
break;
}
}
}
} | #include <iostream>
#include <math.h>
using namespace std;
int e,minimum;
int solve(){
minimum = e;
for(int z=0;z*z*z<=e;z++){
for(int y=0;y <= sqrt(e);y++){
int x = e - z*z*z - y*y;
if(x>=0)
minimum = min(x+y+z,minimum);
}
}
return minimum;
}
int main(){
while(cin >> e && e!=0){
cout << solve() << endl;
}
} | 0 |
#include <iostream>
using namespace std;
int main() {
while (true) {
int n;
cin >> n;
if (n == 0) {
break;
}
for (int i = 0; i < n; i++) {
int pm, pe, pj;
cin >> pm >> pe >> pj;
char output;
if ((pm == 100 || pe == 100 || pj == 100)
|| (180 <= pm + pe)
|| (240 <= pm + pe + pj)) {
output = 'A';
} else if ((210 <= pm + pe + pj)
|| (150 <= pm + pe + pj && (80 <= pm || 80 <= pe))) {
output = 'B';
} else {
output = 'C';
}
cout << output << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define iota(i,n,b,s) for(int i=int(b);i!=int((b)+(s)*(n));i+=(s))
#define range(i,n,m) iota(i,(((n)>(m))?((n)-(m)):((m)-(n))),(n),((n)>(m)?-1:1))
#define rep(i,n) iota(i,(n),0,1)
#define loop for(;;)
#define INF (1e9)
#define EPS (1e-9)
#define cons(a,b) (make_pair(a,b))
#define car(a) (a.first)
#define cdr(a) (a.second)
#define cadr(a) (car(cdr(a)))
#define cddr(a) (cdr(cdr(a)))
#define all(a) a.begin(), a.end()
#define trace(var) cerr<<">>> "<<#var<<" = "<<var<<endl;
typedef long long Integer;
typedef double Real;
typedef vector<int> vi;
typedef vector<string> vs;
typedef map<string,int> Dictionary;
const Real PI = acos(-1);
template<class S, class T>
ostream& operator<<(ostream& os, pair<S,T> p) {
os << '(' << car(p) << ", " << cdr(p) << ')';
return os;
}
template<class T>
ostream& operator<<(ostream& os, vector<T> v) {
os << v[0];
for (int i=1, len=v.size(); i<len; ++i) os << ' ' << v[i];
return os;
}
int dx[] = { -1, 0, 1, 0 };
int dy[] = { 0, -1, 0, 1 };
string rot(string s) {
string r = "";
rep (i, s.size()) {
char c = s[i] < 'a' ? s[i]
: s[i] == 'z' ? 'a' : char(s[i]+1);
r += c;
}
return r;
}
bool ok(string s) {
int a = s.find("the");
int b = s.find("this");
int c = s.find("that");
return a != string::npos || b != string::npos || c != string::npos;
}
int main() {
string s;
while (getline(cin, s)) {
while (!ok(s)) s = rot(s);
cout << (s) << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const long long INF = 1LL<<60;
ll GCD(ll x,ll y){
if(y == 0) return x;
else return GCD(y,x%y);
}
ll LCM(ll a,ll b){
return a / GCD(a,b) * b;
}
const int MOD = 1000000007;
int main() {
int n,m,x,y; cin >> n >> m >> x >> y;
int mx = -101, ym = 101;
vector<int> vec;
for(int i = 0;i < n;i++){
int a; cin >> a;
mx = max(mx,a);
if(x < a && a <= y) vec.push_back(a);
}
for(int i = 0;i < m;i++){
int b; cin >> b;
ym = min(ym,b);
if(x < b && b <= y) vec.push_back(b);
}
string ans = "War";
for(int i = 0;i < vec.size();i++){
if(mx < vec[i] && vec[i] <= ym){
ans = "No War";
break;
}
}
cout << ans;
}
| #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
int main(){
int n; cin >>n;
string s,t;
cin >>s >>t;
for(int i = n; 0<=i; i--){
if(s.substr(n-i)==t.substr(0,i)) {
cout << 2*n-i << endl;
return 0;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long D[201][100001], MOD=1000000007;
int main()
{
int n, x, a;
cin >> n >> x;
vector <int> A;
for (int i = 0; i < n; i++)
{
cin >> a;
A.push_back(a);
}
sort(A.begin(),A.end());
for (int i = 0; i <= x; i++)
{
for (int y = 1; y <= n; y++)
{
D[y][i] = 0;
}
D[0][i] = i;
}
for (int i = 0; i < n; i++)
{
for (int y = 0; y <= x; y++)
{
D[i+1][y] += D[i][y] * i;
D[i+1][y] %= MOD;
D[i+1][y] += D[i][y % A[i]];
D[i+1][y] %= MOD;
}
}
cout << D[n][x];
return 0;
}
| //Solution by Tima
#include <bits/stdc++.h>
#define f first
#define s second
#define ll long long
#define ull unsigned long long
#define mp make_pair
#define pb push_back
#define vi vector <int>
#define ld long double
#define pii pair<int, int>
#define y1 sda
#define all(x) x.begin(), x.end()
using namespace std;
const int N = int(1e5) + 12, mod = int(1e9) + 7;
int n,x,a[N],dp[202][N], obr[N];
ll modpow(ll a, ll b){
ll res = 1;
while(b){
if(b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
int calc(int i,int x){
if(i > n) return x;
if(dp[i][x] != -1) return dp[i][x];
int res = 1ll * calc(i + 1, x) * (n - i) % mod;
res += calc(i + 1, x % a[i]);
if(res >= mod) res -= mod;
return dp[i][x] = 1ll * res * obr[n - i + 1] % mod;
}
void solve(){
scanf("%d%d", &n, &x);
int f = 1;
memset(dp, -1, sizeof(dp));
for(int i = 1; i <= n; i++){
scanf("%d", &a[i]);
f = 1ll * f * i % mod;
obr[i] = modpow(i, mod - 2);
}
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
printf("%d\n", 1ll * calc(1,x) * f % mod);
}
int main () {
int T = 1;
//scanf("%d", &T);
while(T--){
solve();
}
return 0;
} | 1 |
#include <cstdio>
#define F(i, a, b) for (LL i = a; i <= b; i ++)
#define G(i, a, b) for (LL i = a; i >= b; i --)
#define pf printf
typedef long long LL;
const LL N = 1e7 + 10;
const LL M = 20;
using namespace std;
LL D, L, Ans, Sum, total, w[M];
LL ten[M], v[M], tot[M], TOT[M];
void Dfs(LL k, LL s, LL S) {
if (s < 0) return;
if (s + 10 * v[k] < D) return;
if (s - 10 * v[k] > D) return;
if (k > L) {
if (s == D) {
Sum += S;
// printf("Yes\n");
}
return;
}
F(i, -9, 9)
w[k] = i, Dfs(k + 1, s + v[k] * i, S * (k == 1 ? TOT[i + 9] : tot[i + 9]));
}
int main() {
scanf("%lld", &D);
// F(i, 1, N - 10) {
// LL rev = 0;
// for (LL x = i; x; rev = rev * 10 + (x % 10), x /= 10);
// if (rev - i == D)
// printf("%lld\n", i), total ++;
// }
// puts("");
F(i, 0, 9)
F(j, 0, 9)
tot[i - j + 9] ++;
F(i, 0, 9)
F(j, 1, 9)
TOT[i - j + 9] ++;
ten[0] = 1;
F(i, 1, 18)
ten[i] = ten[i - 1] * 10LL;
F(i, 2, 18) {
L = i / 2, Sum = 0;
F(j, 1, L)
v[j] = ten[i - j] - ten[j - 1];
Dfs(1, 0, 1);
Ans += Sum * ((i & 1) ? 10 : 1);
// pf("%d\n", i);
}
pf("%lld\n", Ans);
} | #include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define MN 21001
#define int long long
using namespace std;
int read_p,read_ca;
inline int read(){
read_p=0;read_ca=getchar();
while(read_ca<'0'||read_ca>'9') read_ca=getchar();
while(read_ca>='0'&&read_ca<='9') read_p=read_p*10+read_ca-48,read_ca=getchar();
return read_p;
}
const int MOD=1e9+7;
int n,a[MN],B[MN],x,mmh=0,mm[20][20][2][2];
inline int M(int x){return x<0?x+10:x;}
inline void work(int p,int n,int a,int b){
if (mm[p][n][a][b]!=-1) {mmh+=mm[p][n][a][b];return;}
int u=mmh;
if (p+p-1==n){
if (a==0&&b==0) mmh+=10*(B[p]==0);else
if (a==1&&b==1) mmh+=10*(B[p]==9);
return;
}
if (p+p-1>n){
mmh+=a==b;
return;
}
for (int i=p==1;i<=9;i++)
for (int j=0;j<=9;j++)
if (M(i-j-b)==B[p]&&(a==(j<i)||j==i)&&(M(j-i)==B[n+1-p]||M(j-1-i)==B[n+1-p])){
if (a){
if (j==i&&B[n+1-p]==0) continue;
work(p+1,n,M(j-1-i)==B[n+1-p],i-b-j<0);
}else{
if (j==i&&B[n+1-p]==9) continue;
work(p+1,n,M(j-1-i)==B[n+1-p],i-b-j<0);
}
}
mm[p][n][a][b]=mmh-u;
}
signed main(){
int i,j,k;
x=n=read();
if (n%9) return puts("0"),0;
for (k=1;k<=10&&x;k++) B[k]=x%10,x/=10;k--;
for (int i=k;i<=18;i++) memset(mm,-1,sizeof(mm)),work(1,i,0,0);
printf("%lld\n",mmh);
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for (int i = 1; i < (int)(n); i++)
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define debug(var) do{cout << #var << " : "; view(var);}while(0)
template<class T> bool chmin(T &a, T b) {if(a>b) {a=b;return 1;}return 0;}
template<class T> bool chmax(T &a, T b) {if(a<b) {a=b;return 1;}return 0;}
using namespace std;
template<class T> void view(T e) {cout << e << endl;}
template<class T> void view(const vector<T> &v) {for(const auto &e : v){cout << e << " ";} cout << endl;}
template<class T> void view(const vector<vector<T>> &vv) {for(const auto &v : vv){view(v);}}
using vint = vector<int>;
using vvint = vector<vector<int>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<int,int>;
const int inf = 1e9;
const ll inf_l = 1e18;
const int MAX = 1e5;
int main() {
int n; cin >> n;
int l = 0, r = n;
cout << l << endl;
string sex; cin >> sex;
if (sex == "Vacant") return 0;
else {
while (true) {
int mid = (l+r)/2;
cout << mid << endl;
string sex_ ; cin >> sex_;
if (sex_ == "Vacant") return 0;
if (mid&1) {
if (sex_ == sex) r = mid;
if (sex_ != sex) l = mid;
} else {
if (sex_ == sex) l = mid;
if (sex_ != sex) r = mid;
}
}
}
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define REP(i, a, b) for(ll i = a; i <= b; i++)
#define out(x) std::cout << x << '\n'
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define sz(x) ((int)(x).size())
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { ll g = gcd(a, b); return a / g * b; }
const int dx[4] = { 1, 0, -1, 0 };
const int dy[4] = { 0, 1, 0, -1 };
const int INF = (int)1e9;
const ll inf = (ll)1e18;
const int mod = 1000000007;
const int MAX_N = 100010;
const double PI = acos(-1);
int N;
string a0;
string ask(int i) {
out(i);
fflush(stdout);
string res;
cin >> res;
return res;
}
void f(int l, int r) {
int md = (l + r) / 2;
string res = ask(md);
if (res == "Vacant") return;
if ((md % 2 == 0 && a0 == res)
|| (md % 2 == 1 && a0 != res)) {
f(md + 1, r);
}
else {
f(l, md);
}
}
int main() {
cin >> N;
a0 = ask(0);
if (a0 == "Vacant") return 0;
f(1, N);
return 0;
} | 1 |
#include <iostream>
using namespace std;
int main(void)
{
int a,b,c[101]={0},d,e=0,f=0,g,h,i;
for (a=0;a<4;a++)
{
cin>>b;
c[b]=1;
}
for (a=100;a>0;a--)
{
if (c[a]==1&&e!=3)
{
f=f+a;
e++;
}
}
cin>>d>>e;
if (d>=e)
{
g=d+f;
}
else if (d<=e)
{
g=e+f;
}
cout<<g<<endl;
return 0;
} | // clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
// #define main int main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
#define stlice(from, to) substr(from, (to) - (from) + 1)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
using namespace std;
using pii = pair<int, int>;
using vi = vector<int>;
using vd = vector<double>;
using vc = vector<char>;
using vb = vector<bool>;
using vs = vector<string>;
using vpii = vector<pii>;
using vvi = vector<vi>;
using vvb = vector<vb>;
using vvpii = vector<vpii>;
template<typename A> using fn = function<A>;
constexpr int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
constexpr int MOD = 1000000007;
constexpr double PI = acos(-1);
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
constexpr bool odd(const int &n) { return n & 1; }
constexpr bool even(const int &n) { return !odd(n); }
void solve();
main { solve(); return 0; }
// clang-format on
void solve() {
vi a(4), b(2);
rep(i, 4) cin >> a[i];
rep(i, 2) cin >> b[i];
sort(rall(a)), sort(rall(b));
cout << a[0] + a[1] + a[2] + b[0] << endl;
} | 1 |
#include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
#define rep(i, n) for (int64_t i = 0; i < (n); i++)
#define irep(i, n) for (int64_t i = 0; i <= (n); i++)
#define rrep(i, n) for (int64_t i = (n)-1; i >= 0; i--)
#define rirep(i, n) for (int64_t i = n; i >= 0; i--)
int main() {
int N;
cin >> N;
const int64_t INF = 1'000'000'000L * 200'000 + 1;
vector<vector<int64_t>> dp(N + 2, vector<int64_t>(3, -INF));
dp[0][0] = 0;
rep(i, N) {
int a;
cin >> a;
irep(j, 2) {
dp[i + 2][j] = dp[i][j] + a;
rep(k, j) {
if (i - (j - k) >= 0) {
dp[i + 2][j] = max(dp[i + 2][j], dp[i - (j - k)][k] + a);
}
}
dp[i + 2][j] = max(dp[i + 2][j], -INF);
}
}
/*rep(i, N + 2) {
rep(j, 3) { cerr << " " << dp[i][j]; }
cerr << "\n";
}*/
if (N % 2 == 0) {
cout << max(dp[N + 1][1], dp[N][0]) << endl;
} else {
cout << max(dp[N + 1][2], max(dp[N][1], dp[N - 1][0])) << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define all(x) (x).begin(),(x).end()
using ll = long long;
string char_to_string(char val) {
return string(1, val);
}
int char_to_int(char val) {
return val - '0';
}
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int vector_finder(std::vector<ll> vec, int number) {
auto itr = std::find(vec.begin(), vec.end(), number);
size_t index = std::distance( vec.begin(), itr );
if (index != vec.size()) { // 発見できたとき
return 1;
}
else { // 発見できなかったとき
return 0;
}
}
int main() {
double N; cin >> N;
vector<double> a(N); REP(i, N) cin >> a[i];
double avg = accumulate(all(a), 0) / N;
double ans = 0;
double tmp = pow(10, 8);
REP(i, N) {
if(abs(avg - a[i]) < tmp) {
ans = i;
tmp = abs(avg - a[i]);
}
}
cout << ans << endl;
}
| 0 |
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define FOR(i,k,n) for (int (i)=(k); (i)<(n); ++(i))
#define rep(i,n) FOR(i,0,n)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fst first
#define snd second
#define all(v) begin(v), end(v)
#define debug(x) cerr<< #x <<": "<<x<<endl
#define debug2(x,y) cerr<< #x <<": "<< x <<", "<< #y <<": "<< y <<endl
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vector<int> > vvi;
typedef vector<ll> vll;
typedef vector<vector<ll> > vvll;
template<class T> using vv=vector<vector< T > >;
struct UF {
vector<int> par;
vector<int> sizes;
UF(int n) : par(n), sizes(n, 1) {
rep(i,n) par[i] = i;
}
int root(int x) {
if (x == par[x]) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) {
return;
}
if (sizes[x] < sizes[y]) {
swap(x, y);
}
par[y] = x;
sizes[x] += sizes[y];
sizes[y] = 0;
}
bool same(int x, int y) {
return root(x) == root(y);
}
int size(int x) {
return sizes[root(x)];
}
}; // UF
int V, E;
vvi edge;
ll cost;
void kruskal() {
cost = 0;
UF uf(V);
rep (i, E) {
auto e = edge[i];
if (uf.same(e[1], e[2])) {
continue;
}
uf.unite(e[1], e[2]);
cost += e[0];
if (uf.size(e[1]) == V) {
break;
}
}
return;
}
int main() {
scanf("%d %d", &V, &E);
edge.assign(E, vi(3));
rep (i, E) {
int s, t, w;
scanf("%d %d %d", &s, &t, &w);
edge[i][0] = w;
edge[i][1] = s;
edge[i][2] = t;
}
sort(all(edge));
kruskal();
printf("%lld\n", cost);
return 0;
} | #include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>
#include <queue>
#include <algorithm>
#define shosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef pair<int,P> pip;
typedef vector<pip> vip;
const int inf=1<<30;
const double pi=acos(-1);
class Graph{
private:
vvi Gpro,Gd;
vvp Glist;
int GV,GE;
public:
Graph(int x,int y,bool z){
GV=x;
GE=y;
// Gd=vvi(x,vi(x,inf));
if(z) Gpro=vvi(x,vi(x,inf));
else Glist=vvp(x);
}
void Gpro_add(int x,int y,int z){
Gpro[x][y]=z;
Gpro[y][x]=z;
}
void Glist_add(int x,int y,int z){
Glist[x].push_back(P(y,z));
Glist[y].push_back(P(x,z));
}
void Gd_add(int x,int y,int z){
Gd[x][y]=z;
}
int open(int x,int y){
return Gd[x][y];
}
void DIJplus(int x){
priority_queue<P> que;
Gd[x][x]=0;
que.push(P(0,x));
while(!que.empty()){
P p=que.top();
p.first*=-1;
que.pop();
int v=p.second;
if(Gd[x][v]<p.first) continue;
for(int i=0;i<Glist[v].size();i++){
P e=Glist[v][i];
if(Gd[x][e.first]>Gd[x][v]+e.second){
Gd[x][e.first]=Gd[x][v]+e.second;
que.push(P(-1*Gd[x][e.first],e.first));
}
}
}
}
void BELLMAN(int x){
Gd[x][x]=0;
while(1){
bool update=1;
for(int i=0;i<GV;i++){
for(int j=0;j<Glist[i].size();j++){
P e=P(Glist[i][j].first,Glist[i][j].second);
if(Gd[x][i]!=inf&&Gd[x][e.first]>Gd[x][i]+e.second){
Gd[x][e.first]=Gd[x][i]+e.second;
update=0;
}
}
}
if(update) break;
}
}
bool FNL(int x){
Gd[x][x]=0;
for(int i=0;i<GV;i++){
for(int j=0;j<GV;j++){
for(int k=0;k<Glist[j].size();k++){
P e=P(Glist[j][k].first,Glist[j][k].second);
if(Gd[x][j]!=inf&&Gd[x][e.first]>Gd[x][j]+e.second){
Gd[x][e.first]=Gd[x][j]+e.second;
if(i==GV-1) return 1;
}
}
}
}
Gd=vvi(GV,vi(GV,inf));
return 0;
}
void WARSHALL(){
for(int i=0;i<GV;i++){
for(int j=0;j<GV;j++){
for(int k=0;k<GV;k++) Gd[i][j]=min(Gd[i][j],Gd[i][k]+Gd[k][j]);
}
}
}
int PRIM(){
int Gans=0;
vi mincost(GV,inf);
vector<bool> used(GV,1);
mincost[0]=0;
while(1){
int v=-1;
for(int i=0;i<GV;i++){
if(used[i]&&(v==-1||mincost[i]<mincost[v])) v=i;
}
if(v==-1) break;
used[v]=0;
Gans+=mincost[v];
for(int i=0;i<Glist[v].size();i++){
mincost[Glist[v][i].first]=min(mincost[Glist[v][i].first],Glist[v][i].second);
}
}
return Gans;
}
};
int V,E;
int main(){
cin>>V>>E;
Graph gra(V,E,0);
for(int i=0;i<E;i++){
int s,t,d;
cin>>s>>t>>d;
gra.Glist_add(s,t,d);
}
cout<<gra.PRIM()<<endl;
} | 1 |
#include <stdio.h>
int main(){
char X[3];
scanf("%s",&X);
if(X[0]=='7'){
printf("Yes\n");
}
else if(X[1]=='7'){
printf("Yes\n");
}
else if(X[2]=='7'){
printf("Yes\n");
}
else{
printf("No\n");
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
#define rep(i,cc,n) for(int i=cc;i<n;++i)
#define lrep(i,cc,n) for(long long i=cc;i<n;++i)
#define sqrep(i,cc,n) for(long long i=cc;i*i<=n;++i)
#define rrep(i,cc,n) for(long i=cc;i>n;--i)
#define pii pair<int, int>
#define pll pair<long long, long long>
using ll = long long;
const vector<int> dx = {1, 0, -1, 0};
const vector<int> dy = {0, 1, 0, -1};
const ll inf = 1001001001;
const ll e9 = 1000000000;
const ll mod = 1000000007;
const double PI = 3.1415926535;
int main() {
string s;
cin >> s;
int n = s.size();
vector<int>cnt(26,0);
if(n!=26){
rep(i, 0, n){
cnt[s[i]-'a']++;
}
//cout << "ok" << endl;
rep(i, 0, 26){
if(cnt[i]==0){
char t = i + 'a';
cout << s << t << endl;
return 0;
}
}
}else if (s!="zyxwvutsrqponmlkjihgfedcba"){
string s2 = s;
string p;
next_permutation(s.begin(),s.end());
while(s>s2){
p = s[s.size()-1];
s.erase(s.size()-1);
}
cout << s << p << endl;
}else{
cout << -1 << endl;
}
} | 0 |
#include<iostream>
#include <bits/stdc++.h>
#include<algorithm>
#include <cstring>
#define endl "\n"
#define SRK ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define EPS 1e-6
#define MAX 100000
typedef long long ll;
const ll MOD = 1e9 + 7;
using namespace std;
int N = 1000000;
int NOD[1000000];
void generateNOD()
{
for (int i = 0; i <= N; i++)
{
for (int j = i; j <= N; j += i)
{
NOD[j]++;
}
}
}
int main()
{
int n;
cin >> n;
int yen500 = 1000 * (n / 500);
int left = n % 500;
int yen5 = 5 * (left / 5);
cout << yen500 + yen5 << endl;
}
| #include<bits/stdc++.h>
using namespace std;
#define int long long int
#define endl "\n"
#define F first
#define S second
#define mod 1000000007
#define pb push_back
#define FOR(i,a,n) for(int i=a;i<n;i++)
#define REV(i,a,n) for(int i=a;i>=n;i--)
#define all(a) a.begin(),a.end()
const int NUM = 2e5 + 5;
int32_t main(){
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int num_tests=1;
//cin >> num_tests;
while(num_tests-->0){
int n; cin >> n;
int ans = 0;
while(n >= 500)
{
int x = n/500;
ans += x*1000;
n -= (x)*500;
}
while(n >= 5)
{
int y = n/5;
ans += y*5;
n -= y*5;
}
cout << ans;
}
} | 1 |
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
#define endl "\n"
//#define int long long
#define ALL(x) begin(x),end(x)
#define RALL(a) (a).rbegin(), (a).rend()
#define _CRT_SECURE_NO_WARNINGS
#define rep(i, n) for (int i = 0; i < n; i++)
const int MOD = 1e9 + 7;
const ll INF = 1LL << 60;
const int inf = 1 << 25;
constexpr long double pi = 3.141592653589793238462643383279;
int dx[] = { 1,0,-1,0 };
int dy[] = { 0,1,0,-1 };
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll fact(ll i) {
if (i == 0) return 1;
return ((fact(i - 1)) * i) % MOD;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
return a * b / gcd(a, b);
}
ll keta(ll n) {
if (n == 0) return 1;
ll count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) {
ll sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
ll mch(ll n) {
if (n == 1) return 1;
else return n * mch(n - 1);
}
ll modpow(ll a, ll n, ll mod) {
ll hi = 1;
while (n > 0) {
if (n & 1) hi = hi * a % mod;
a = a * a % mod;
n >>= 1;
}
return hi;
}
bool is_prime(const unsigned n) {
switch (n) {
case 0: // fall-through
case 1: return false;
case 2: // fall-through
case 3: return true;
} // n > 3 が保証された
if (n % 2 == 0 || n % 3 == 0) return false;
for (unsigned i = 5; i * i <= n; i += 6) {
if (n % i == 0) return false; // (6の倍数)-1
if (n % (i + 2) == 0) return false; // (6の倍数)+1
}
return true;
}
/*signed*/int main(void) {
int n, m;
cin >> n >> m;
vector<pair<int, int>> p(m);
rep(i, m) {
int s, c;
cin >> s >> c;
s--;
p[i] = make_pair(s, c);
}
rep(i, 1000) {
string s = to_string(i);
if (s.size() == n) {
bool ans = true;
rep(j, m) {
if ((s[p[j].first] - '0') != p[j].second)ans = false;
}
if (ans) {
cout << i << endl;
return 0;
}
}
}
cout << -1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define ll long long int
#define pb push_back
typedef pair<ll,ll> ipair;
#define F first
#define S second
/*
//functions from gfg
long long int power(long long int x,long long int y,long long int p)
{
long long int res = 1; // Initialize result
x = x % p; // Update x if it is more than or
// equal to p
while (y > 0)
{
// If y is odd, multiply x with result
if (y & 1)
{//d=(long double)x/p;
res = (res*x) % p;
}
// y must be even now
y = y>>1; // y = y/2
x=(x*x)%p;
}
return res%p;
}
long long int gcd(long long int a,long long int b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
long long int binomialCoeff(long long int n, ll k)
{
ll res = 1;
// Since C(n, k) = C(n, n-k)
if (k > n - k)
k = n - k;
// Calculate value of [n*(n-1)*---*(n-k+1)] / [k*(k-1)*---*1]
for (ll i = 0; i < k; ++i)
{
res *= (n - i);
res /= (i + 1);
}
return res;
}
void sieve(int n, vector<ll> &primes)
{
vector<int> prime(n,1);
ll p;
for ( p=2; p*p<=n; p++)
{
// If prime[p] is not changed, then it is a prime
if (prime[p] == 1)
{
for (int i=p*p; i<=n; i += p)
prime[i] = 0;
}
}
for(p=2;p<=n;p++)
{
if(prime[p])
primes.pb(p);
}
}
void dfs(vector<ll> adj[] ,ll src,vector<ll> &vis)
{
vis[src]=1;
for(ll i=0;i<adj[src].size();i++)
{
if(vis[adj[src][i]]==0)
dfs(adj,adj[src][i],vis)
}
}
*/
int main() {
ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
ll n,i,j,p,k,m,t,ans=0;
cin>>n>>t;
ll dp[3005][3005];
memset(dp, 0, sizeof(dp));
vector<ll> a(n),b(n);
vector<pair<ll,ll> > val(n);
for(i=0;i<n;i++)
{
cin>>a[i]>>b[i];
val[i].F=a[i];
val[i].S=b[i];
}
sort(val.begin(),val.end());
for(i=0;i<n;i++)
{
a[i]=val[i].F;
b[i]=val[i].S;
}
for(i=0;i<t;i++)
{
for(j=0;j<n;j++)
{
if(i+a[j]<t)
{
dp[j+1][i+a[j]] = max(dp[j][i]+b[j],dp[j+1][i+a[j]]);
}
dp[j+1][i] = max(dp[j][i],dp[j+1][i]);
}
}
for(i=0;i<n;i++)
{
ans=max(ans,dp[i][t-1]+b[i]);
}
cout<<ans<<endl;
// for(i=0;i<n;i++)
// {
// cout<<a[i]<<" ";
// }
// cout<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long ul;
typedef unsigned long long ull;
typedef long long ll;
typedef vector<ll> vint;
typedef vector< vector<ll> > vvint;
typedef vector< vector< vector<ll> > > vvvint;
typedef vector<string> vstring;
typedef vector< vector<string> > vvstring;
typedef vector<char> vchar;
typedef vector< vector<char> > vvchar;
typedef vector<long double> vdouble;
typedef vector< vector<long double> > vvdouble;
typedef vector< vector< vector<long double> > > vvvdouble;
typedef pair<ll,ll> pint;
typedef vector<pint> vpint;
typedef vector<bool> vbool;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repf(i,f,n) for(ll i=f;i<n;i++)
#define repr(i,n) for(ll i=n-1;i>=0;i--)
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define pf push_front
#define fi first
#define se second
#define ALL(obj) (obj).begin(), (obj).end()
// #define LLONG_MAX 9223372036854775806
#define vmax(vec) *max_element(vec.begin(), vec.end())
#define vmin(vec) *min_element(vec.begin(), vec.end())
#define vsort(vec) sort(vec.begin(), vec.end())
#define vsortgr(vec) sort(vec.begin(), vec.end(), greater<ll>())
#define MOD 1000000007
// #define MOD 998244353
// #define MOD LLONG_MAX
const double PI=3.14159265358979323846;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int dy[]={0, 0, 1, -1};
int dx[]={1, -1, 0, 0,};
void printv(vint &v){
for(auto e:v) cout<<e<<" ";
cout<<endl;
}
// 繰り返し二乗法
ll power(ll a, ll b){
if(a==1)return a;
// if(a==0)re
ll res=1;
while(b>0){
if(b&1) res=res*a%MOD;
a=a*a%MOD;
b>>=1;
}
return res;
}
const int MAX=2100000;
ll fact[MAX], fact_inv[MAX];
void init_fact(ll n){
fact[0]=1;
// 階乗の計算
for(ll i=0; i<n; i++) fact[i+1]=fact[i]*(i+1)%MOD;
fact_inv[n]=power(fact[n], MOD-2);
// 逆元の計算
for(ll i=n-1;i>=0;i--) fact_inv[i]=fact_inv[i+1]*(i+1)%MOD;
}
ll comb(ll n, ll r){
return (fact[n]*fact_inv[r])%MOD*fact_inv[n-r]%MOD;
}
ll perm(ll n, ll r){
return (fact[n]*fact_inv[n-r])%MOD;
}
int main() {
cout<<fixed<<setprecision(10);
ll k; cin>>k;
ll n = 50;
ll x,y;
x = k/n;
y = k%n;
// ll a_base = (x+1)*n - 1 - y;
ll a_base = ( n - 1 ) + x - y;
vint ans(n, a_base);
rep(i,y){
ans[i] += n - (i+1) + 2;
}
cout << n <<endl;
for(auto e:ans) cout<<e<<" ";
cout<<endl;
return 0;
} | #include<bits/stdc++.h>
#define sqr(x) ((x)*(x))
#define ll long long
#define ull unsigned long long
#define ui unsigned int
#define ld long double
#define vi vector<int>
#define HEAP(...) priority_queue<__VA_ARGS__ >
#define heap(...) priority_queue<__VA_ARGS__,vector<__VA_ARGS__ >,greater<__VA_ARGS__ > >
#define pii pair<int,int>
#define pb push_back
#define mp make_pair
#define debuge cerr<<"isok"<<endl
#define debug(x) cerr<<#x<<"="<<x<<endl
#define dprintf(...) fprintf(stderr,__VA_ARGS__)
#define SS second
#define FF first
#define ls (k<<1)
#define rs (k<<1|1)
#define clr(a,x) memset(a,x,sizeof(a))
#define cpy(a,x) memcpy(a,x,sizeof(a))
#define file(x) freopen(x".in","r",stdin),freopen(x".out","w",stdout)
#define SZ(x) ((int)x.size())
using namespace std;
template<class T> inline void gmin(T &x,const T &y){if(x>y) x=y;}
template<class T> inline void gmax(T &x,const T &y){if(x<y) x=y;}
const int BufferSize=1<<16;
char buffer[BufferSize],*Bufferhead,*Buffertail;
bool Terminal;
inline char Getchar(){
if(Bufferhead==Buffertail){
int l=fread(buffer,1,BufferSize,stdin);
if(!l){Terminal=1;return 0;}
Buffertail=(Bufferhead=buffer)+l;
}
return *Bufferhead++;
}
template<class T>inline bool read(T &x){
x=0;char c=Getchar(),rev=0;
while(c<'0'||c>'9'){c=Getchar();rev|=c=='-';if(Terminal)return 0;}
while(c>='0'&&c<='9') x=x*10+c-'0',c=Getchar();
if(c=='.'){
c=Getchar();double t=0.1;
while(c>='0'&&c<='9') x=x+(c-'0')*t,c=Getchar(),t=t/10;
}
x=rev?-x:x;
return 1;
}
template<class T1,class T2> inline bool read(T1 &x,T2 &y){return read(x)&read(y);}
template<class T1,class T2,class T3> inline bool read(T1 &x,T2 &y,T3 &z){return read(x)&read(y)&read(z);}
template<class T1,class T2,class T3,class T4> inline bool read(T1 &x,T2 &y,T3 &z,T4 &w){return read(x)&read(y)&read(z)&read(w);}
inline bool reads(char *x){
char c=Getchar();
while(c<33||c>126){c=Getchar();if(Terminal)return 0;}
while(c>=33&&c<=126) (*x++)=c,c=Getchar();
*x=0;return 1;
}
template<class T>inline void print(T x,const char c='\n'){
if(!x){putchar('0');putchar(c);return;}
if(x<0) putchar('-'),x=-x;
int m=0,a[20];
while(x) a[m++]=x%10,x/=10;
while(m--) putchar(a[m]+'0');
putchar(c);
}
//--------------------------------------------------head--------------------------------------------------
const int inf=0x3f3f3f3f;
const int N=1000005,M=100005,mod=998244353;
template<class T,class S> inline void ch(T &x,const S y){x=(x+y)%mod;}
inline int exp(int x,int y,const int mod=::mod){
int ans=1;
while(y){
if(y&1) ans=(ll)ans*x%mod;
x=(ll)x*x%mod;y>>=1;
}return ans;
}
int n,m,fac[N],ifac[N];
int main(){
#ifdef rqgao2014
freopen("input.txt","r",stdin);
#endif
n=1000000;fac[0]=1;
for(int i=1;i<=n;i++) fac[i]=(ll)fac[i-1]*i%mod;
ifac[n]=exp(fac[n],mod-2);
for(int i=n;i;i--) ifac[i-1]=(ll)ifac[i]*i%mod;
read(n,m);
int ans=0;
for(int i=1;i<=min(n,m);i++)
ch(ans,(ll)ifac[i]*ifac[i]%mod*ifac[n-i]%mod*ifac[m-i]%mod*fac[i*2-1]%mod*fac[n+m-2*i]%mod*i);
ans=(ll)ans*fac[n]%mod*fac[m]%mod*ifac[n+m]%mod;
ch(ans,max(n,m));
print(ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
#include <ext/rope>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define ll long long
#define int long long
#define pb push_back
#define x first
#define ld long double
#define y second
#define mk(a,b) make_pair(a,b)
#define rr return 0
#define sqr(a) ((a)*(a))
#define all(a) a.begin(),a.end()
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
template<class value, class cmp = less<value> >
using ordered_set = tree<value, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class value, class cmp = less_equal<value> >
using ordered_multiset = tree<value, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class key, class value, class cmp = less<key> >
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
/// find_by_order()
/// order_of_key()
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int randll(int l = INT_MIN, int r = INT_MAX) {
return uniform_int_distribution<int>(l, r)(rng);
}
vector <int> t;
inline void upd (int i, int x) {
for (; i < (int)t.size(); i = i | (i + 1)) t[i] += x;
}
inline int sum (int r) {
int ans = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ans += t[r];
return ans;
}
inline int sum (int l, int r) {
return sum(r) - sum(l - 1);
}
main()
{
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, q;
cin >> n >> q;
vector <int> a(n);
for (auto &i : a) cin >> i;
vector <vector <pair<int, int> > > Q(n);
int l, r;
for (int i = 0; i < q; i++) {
cin >> l >> r;
--l, --r;
Q[r].pb({l, i});
}
t.resize(n);
map <int, int> have;
vector <int> ans(q);
for (int i = 0; i < n; i++) {
if (have.count(a[i])) {
upd(have[a[i]], -1);
}
have[a[i]] = i;
upd(i, 1);
for (auto &j : Q[i]) {
ans[j.y] = sum(j.x, i);
}
}
for (auto &i : ans) cout << i << '\n';
}
| #include <iostream>
#include <queue>
#include <vector>
#include <cstdio>
using namespace std;
int main() {
while(1) {
int n;
cin >> n;
int m;
cin >> m;
if(n==0 && m ==0) break;
vector <int> re[502];
queue <int > Q;
int a, b;
for(int i=0;i<m;i++) {
cin >> a >> b;
re[a].push_back(b);
re[b].push_back(a);
}
int t;
int count = -1;
Q.push(1);
int dis[502];
for(int i=0;i<=n;i++) dis[i] = -1;
while(Q.empty() != 1){
t = Q.front();
Q.pop();
for(int i=0;i<re[t].size();i++) {
if(dis[re[t][i]] == -1 && dis[t]+1 < 2) {
dis[re[t][i]] = dis[t] + 1;
count++;
// printf("dis[i%d](%d) | dis[t%d](%d) | re[%d][%d](%d)\n",i,dis[re[t][i]],t,dis[t],t,i,re[t][i]);
Q.push(re[t][i]);
//cout << "Q.front == " << Q.front() << endl;
}
}
}
cout << count << endl;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int gcd(int x,int y){
if(x%y==0) return y;
else return gcd(y,x%y);
}
int main(){
int n,i,k,a,G,MAX;scanf("%d%d",&n,&k);
scanf("%d",&G);MAX = G;
if(n == 1){
printf((k==G) ? "POSSIBLE\n":"IMPOSSIBLE\n");
return 0;
}
for(i=1;i<n;i++){
scanf("%d",&a);
G = gcd(G,a);
MAX = max(MAX,a);
}
printf((k<=MAX && k%G==0) ? "POSSIBLE\n":"IMPOSSIBLE\n");
} | #include<bits/stdc++.h>
#include<cctype>
using namespace std;
#define rep(i,n) for (int i=0;i<(n);i++)
#define all(v) (v).begin(),(v).end()
typedef long long int ll;
#define pi 3.1415926535897932384
#define E9 1000000000
#define eps 1e-4
#define pii pair<int,int>
int main(){
int N, K; cin >> N >> K;
int A[N]; rep(i,N) cin >> A[i];
sort(A,A+N);
int GCD = A[0];
rep(i,N) GCD = __gcd(GCD, A[i]);
if (K%GCD==0 && K<=A[N-1]) cout << "POSSIBLE" << endl;
else cout << "IMPOSSIBLE" << endl;
// cout << fixed << setprecision(10);
return 0;
}
| 1 |
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long LL;
const int mod = 1e9 + 7;
int n , x , y , z;
int dp[50][1 << 18];
int main() {
scanf("%d %d %d %d" , &n , &x , &y , &z);
int st = (1 << (x + y + z - 1)) | (1 << (y + z - 1)) | (1 << (z - 1));
dp[0][0] = 1;
int ans = 1;
for (int i = 1; i <= n; ++i) {
ans = (LL)ans * 10 % mod;
for (int j = 0; j < (1 << (x + y + z)); ++j) {
if(dp[i - 1][j] && (j & st) != st) {
for (int k = 1; k <= 10; ++k) {
int now = (j << k) | (1 << (k - 1));
now &= (1 << (x + y + z)) - 1;
dp[i][now] = (dp[i][now] + dp[i - 1][j]) % mod;
}
}
}
}
for (int i = 0; i < (1 << (x + y + z)); ++ i) {
if((i & st) != st) ans = ((ans - dp[n][i]) % mod + mod) % mod;
}
printf("%d" , ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
#define all(v) (v).begin(),(v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
//typedef vector<vector<ll>> mat;
typedef vector<int> vec;
//繰り返し二乗法
ll mod_pow(ll a, ll n, ll m) {
ll res = 1;
while (n) {
if (n & 1)res = res * a%m;
a = a * a%m; n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() :n(0) { ; }
modint(ll m) :n(m) {
if (n >= mod)n %= mod;
else if (n < 0)n = (n%mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) { a.n += b.n; if (a.n >= mod)a.n -= mod; return a; }
modint operator-=(modint &a, modint b) { a.n -= b.n; if (a.n < 0)a.n += mod; return a; }
modint operator*=(modint &a, modint b) { a.n = ((ll)a.n*b.n) % mod; return a; }
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)return modint(1);
modint res = (a*a) ^ (n / 2);
if (n % 2)res = res * a;
return res;
}
//逆元(Eucledean algorithm)
ll inv(ll a, ll p) {
return (a == 1 ? 1 : (1 - p * inv(p%a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
using mP = pair<modint, modint>;
int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };
// 素因数が何乗かをmapで返却する
map< ll, int > prime_factor(ll n) {
map< ll, int > ret;
for(ll i = 2; i * i <= n; i++) {
while(n % i == 0) {
ret[i]++;
n /= i;
}
}
if(n != 1) ret[n] = 1;
return ret;
}
void solve() {
ll N, M; cin >> N >> M;
auto pf = prime_factor(M);
ll res = 1;
for(auto a: pf){
res = modint(modint(res) * comb(a.second + N - 1, a.second));
}
cout << res << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
//cout << fixed << setprecision(10);
init_f();
//init();
//int t; cin >> t; rep(i, t)solve();
solve();
// stop
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.