code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<set>
#include<queue>
#include<stack>
#include<bitset>
using namespace std;
int p = 998244353;
#define int long long
#define vel vector<long long>
#define vvel vector<vel>
#define rep(i,n) for(long long i=0;i<n;i++)
#define sor(v) sort(v.begin(),v.end())
#define mmax(a,b) a=max(a,b)
#define mmin(a,b) a=min(a,b)
#define mkp make_pair
#define pin pair<int,int>
#define V vector
#define Endl endl
#define veb vector<bool>
#define sq(a) (a)*(a)
#define rev(s) reverse(s.begin(),s.end())
#define end_program(s) cout << s <<endl;return 0
int kai_size = 500001;
vel kai(kai_size, 1);
vel ink(kai_size, 1);
vel dist;
int RE() {
vel v(3, 2);
return v.at(4);
}
int ru(int a, int r) {
if (r == 0) { return 1; }
int ans = ru(a, r / 2);
ans *= ans; ans %= p;
if (r % 2 == 1) { ans *= a; }
return ans % p;
}
int inv(int a) {
return ru(a, p - 2);
}
void make_kai() {
rep(i, kai_size-1) { kai[i + 1] = (kai[i] * (i + 1)) % p; }
rep(i, kai_size) { ink[i] = inv(kai[i]); }
}
int com(int n, int r) {
if (r < 0 || n < r) { return 0; }
int ans = kai[n] * ink[r];
ans %= p; ans *= ink[n - r]; ans %= p;
return ans;
}
vel dis(int mid1, vvel &way) {
int n = way.size();
vel dist(n, -1); dist[mid1] = 0;
queue<int> q;
q.push(mid1);
while (!q.empty()) {
int st = q.front(); q.pop();
rep(i, way[st].size()) {
int to = way[st][i];
if (dist[to] == -1) {
dist[to] = dist[st] + 1;
q.push(to);
}
}
}
return dist;
}
pin most_far(int now, int n, vvel &way) {
vel dist1 = dis(now, way);
pin ans = mkp(-1, 0);
rep(i, n) {
if (dist1[i] > ans.first) { ans = mkp(dist1[i], i); }
}
return ans;
}
int per(int a, int b) {
int ans = a % b;
if (ans < 0) { ans += b; }
return ans;
}
vel uni(vel &v) {
sor(v);
vel ans(1, v[0]);
for (int i = 1; i < v.size(); i++) {
if (v[i] != v[i-1]) { ans.push_back(v[i]); }
}
v = ans;
return v;
}
int s_gcd(int a, int b) {
if (b == 0) { return a; }
return s_gcd(b, a%b);
}
int gcd(int a, int b) {
if (a < b) { swap(a, b); }
return s_gcd(a, b);
}
bool is_prime(int i) {
for (int j = 2; j*j <= i; j++) {
if (i%j == 0) { return false; }
}
return true;
}
int get(int i, int j, vvel &ans) {
int n = ans.size();
if (i < 0 || n <= i || j < 0 || n <= j) { return 1; }
return ans[i][j];
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
int solve(int a, int b) {
if (a < b) { swap(a, b); }
if (b == 1) { return 1; }
return a % b;
}
signed main() {
int n; cin >> n;
vel prime(0);
int mod = 510;
for (int i = 1000; i < 10000; i++) {
if (is_prime(i)) { prime.push_back(i); }
}
vvel ans(n, vel(n,1));
rep(i, n) {
rep(j, n) {
if ((i + j) % 2 == 0) {
int x = (i + j) / 2;
int y = per((i - j) / 2, mod);
ans[i][j] = prime[x] * prime[y];
}
}
}
rep(i, n) {
rep(j, n) {
if ((i + j) % 2 == 1) {
j--;
int x = (i + j) / 2;
int y = per((i - j) / 2, mod);
ans[i][j+1] = prime[x] * prime[y];
j += 2;
x = (i + j) / 2;
y = per((i - j) / 2, mod);
ans[i][j-1] *= prime[x] * prime[y];
j--;
ans[i][j]++;
}
cout << ans[i][j];
if (j == n - 1) { cout << endl; }
else { cout << " "; }
}
}
return 0;
}
| #include<iostream>
#include<cstdio>
using namespace std;
int n,sz;
int a[10101],d[10101];
long long an[1010][1010];
void init(int N)
{
for(int i=2;i<=N;i++)
{
if(!d[i])a[++sz]=i;
for(int j=1;j<=sz&&a[j]*i<=N;j++)
{
d[i*a[j]]=1;
if(i%a[j]==0) break;
}
}
}
long long gcd(long long x,long long y){ return y?gcd(y,x%y):x;}
long long lcm(long long x,long long y)
{
if(!x||!y) return x+y;
return x/gcd(x,y)*y;
}
int main()
{
scanf("%d",&n);
init(10000);
if(n==2)
{
an[1][1]=4;an[1][2]=7;an[2][1]=23;an[2][2]=10;
}
else
{
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if((i+j)&1)
an[i][j]=1LL*a[(i+j)/2]*a[(i-j+n)/2+1+n];
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if(((i+j)&1)^1)
an[i][j]=lcm(lcm(an[i-1][j],an[i+1][j]),lcm(an[i][j-1],an[i][j+1]))+1;
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
printf("%lld ",an[i][j]);
puts("");
}
return 0;
} | 1 |
#include<bits/stdc++.h>
#define del(a,i) memset(a,i,sizeof(a))
#define ll long long
#define inl inline
#define il inl void
#define it inl int
#define ill inl ll
#define re register
#define ri re int
#define rl re ll
#define mid ((l+r)>>1)
#define lowbit(x) (x&(-x))
#define INF 0x3f3f3f3f
using namespace std;
template<class T>il read(T &x){
int f=1;char k=getchar();x=0;
for(;k>'9'||k<'0';k=getchar()) if(k=='-') f=-1;
for(;k>='0'&&k<='9';k=getchar()) x=(x<<3)+(x<<1)+k-'0';
x*=f;
}
template<class T>il _print(T x){
if(x/10) _print(x/10);
putchar(x%10+'0');
}
template<class T>il print(T x){
if(x<0) putchar('-'),x=-x;
_print(x);
}
ll mul(ll a,ll b,ll mod){long double c=1.;return (a*b-(ll)(c*a*b/mod)*mod)%mod;}
it qpow(int x,int m,int mod){
int res=1,bas=x;
while(m){
if(m&1) res=(1ll*res*bas)%mod;
bas=(1ll*bas*bas)%mod,m>>=1;
}
return res;
}
const int MAXN = 2e3+5,mod = 998244353;
int n,k,C[MAXN<<1][MAXN<<1],bit[MAXN<<1];
it add(int x,int y){return x+y>=mod?x+y-mod:x+y;}
it mul(int x,int y){return 1ll*x*y%mod;}
il inc(int &x,int y){x=add(x,y);}
il Init(){
C[0][0]=1,bit[0]=1;
for(ri i=1;i<=4000;++i){
C[i][0]=1;
for(ri j=1;j<=i;++j) C[i][j]=add(C[i-1][j],C[i-1][j-1]);
bit[i]=mul(bit[i-1],2);
}
}
it Solve(int x,int y,int z){
int res=0;
for(ri i=0;i<=z&&i<=x;++i)
if(y+i-1>=0) inc(res,mul(mul(C[x][i],C[y+z-1][i+y-1]),bit[i]));
return res;
}
int main(){
// freopen(".in","r",stdin);
// freopen(".out","w",stdout);
read(k),read(n),Init();
for(ri i=2;i<=2*k;++i){
int cnt=0;
for(ri j=1;j<=k;++j) cnt+=(i-j>=1&&i-j<=k);
if(i&1) print(Solve(cnt>>1,k-cnt,n)),puts("");
else print(add(Solve(cnt>>1,k-cnt,n-1),Solve(cnt>>1,k-cnt,n))),puts("");
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
#define MOD 998244353
using namespace std;
typedef long long ll;
ll ppow(ll a,ll b){
ll res=1;
while(b){
if(b&1)res=(res*a)%MOD;
a=(a*a)%MOD;
b>>=1;
}
return res;
}
ll C[5000][5000];
int main(){
for(int i=0;i<5000;i++){
for(int j=0;j<=i;j++){
if(j==0||j==i)C[i][j]=1;
else C[i][j]=(C[i-1][j-1]+C[i-1][j])%MOD;
}
}
int k,n;scanf("%d%d",&k,&n);
for(int i=2;i<=2*k;i++){
int cnt1=0,cnt2=0;
for(int j=1;j<=k;j++){
if(j<i&&j<i-j&&i-j<=k)cnt1++;
if(j>=i||i-j>k)cnt2++;
}
ll ans=0;
for(int j=0;j<=cnt1;j++){
if(j+cnt2==0)continue;
(ans+=C[n-j+(j+cnt2-1)][j+cnt2-1]*ppow(2,j)%MOD*C[cnt1][j]%MOD)%=MOD;
if(i%2==0)(ans+=C[n-j+(j+cnt2-1)-1][j+cnt2-1]*ppow(2,j)%MOD*C[cnt1][j]%MOD)%=MOD;
}
printf("%lld\n",ans);
}
} | 1 |
#include<stdio.h>
const int MAX_V=10000;
int prime[MAX_V+1];
int main(){
int i,k,n,p,q,v;
for(i=2;i<=MAX_V;i++){
prime[i]=1;
}
for(i=2;i*i<=MAX_V;i++){
if(prime[i]){
for(k=2*i;k<=MAX_V;k+=i){
prime[k]=0;
}
}
}
while(1){
scanf("%d",&n);
if(n==0)break;
for(v=2;v<=n-2;v++){
int isprime=prime[v]*prime[v+2];
if(isprime)p=v,q=v+2;
}
printf("%d %d\n",p,q);
}
return 0;
} | #include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;
int prime[2020],np;
bool vis[10101];
void findprime()
{
memset(vis,0,sizeof(vis));
np=0;
for(int i=2;i<=10000;i++)
{
if(!vis[i])
prime[++np]=i;
for(int j=1;j<=np&&i*prime[j]<=10000;j++)
{
vis[i*prime[j]]=true;
if(i%prime[j]==0)
break;
}
}
}
long long ans[505][505];
long long gcd(long long x,long long y)
{
if(y==0)
return x;
return gcd(y,x%y);
}
long long lcm(long long x,long long y)
{
return x/gcd(x,y)*y;
}
int hx[4]={-1,1,0,0};
int hy[4]={0,0,-1,1};
int main()
{
int n;
findprime();
scanf("%d",&n);
if(n==2)
{
printf("4 7\n23 10");
return 0;
}
for(int i=0;i<=n+1;i++)
for(int j=0;j<=n+1;j++)
ans[i][j]=1;
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if((i+j)%2==0)
ans[i][j]=prime[(i+j)/2]*prime[(n-j+1+i)/2+n];
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
if((i+j)%2==1)
{
for(int k=0;k<4;k++)
ans[i][j]=lcm(ans[i][j],ans[i+hx[k]][j+hy[k]]);
ans[i][j]++;
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
printf("%lld ",ans[i][j]);
printf("\n");
}
return 0;
} | 0 |
#include<bits/stdc++.h>
const int maxn = 1001;
int vis[maxn][maxn];
int n,d1,d2;
void set(int d){
int t = 0;
for(;d % 4 == 0;d /= 4) ++ t;
if(d % 4 == 1){
for(int i = 0;i < n * 2;++i) for(int j = 0;j < n * 2;++j)
vis[i][j] |= (i ^ j) >> t & 1;
} else {
for(int i = 0;i < n * 2;++i) for(int j = 0;j < n * 2;++j)
vis[i][j] |= i >> t & 1;
}
}
int main(){
std::ios_base::sync_with_stdio(false),std::cin.tie(0);
std::cin >> n >> d1 >> d2;
set(d1); set(d2);
for(int i = 0,cnt = 0;i < n * 2;++i) for(int j = 0;j < n * 2;++j)
if(!vis[i][j]) {
std::cout << i << ' ' << j << '\n';
if(++cnt == n * n) return 0;
}
}
| #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) {
if (v.size() == 0) {
os << "(empty)";
return os;
}
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 };
bool
f(vector<int>&ln, int idx, int x, int y) {
if (idx == 10) return true;
int z = ln[idx];
return (x < z && f(ln, idx + 1, z, y)) || (y < z && f(ln, idx + 1, x, z));
}
int main() {
loop {
vector<int>ls(10);
char com;
int v1, v2;
int len = 0;
rep(i, 10) {
cin >> ls[i] >> com;
len += ls[i];
}
if (!cin) break;
cin >> v1 >> com >> v2;
int V = v1 + v2;
rep (i, 10) {
ls[i] *= V;
}
int le1 = len * v1;
for (int i=0; i<10; ++i) {
le1 -= ls[i];
if (le1 <= 0) {
cout << -~i << endl;
break;
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define REPLL(i, n) for (ll i = 0; i < (ll)(n); i++)
using namespace std;
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;
// ABC052 C - Factors of Factorial
// 2020.06.13
ll MOD = 1e9+7;
map<ll, ll> PrimeFac(ll n){
map<ll, ll> mp;
ll cnt = 0;
while(n%2 == 0){
n /= 2;
cnt++;
}
if(cnt != 0) mp[2] = cnt;
for(ll i = 3; i*i <= n; i += 2){
cnt = 0;
while(n%i == 0){
n /= i;
cnt++;
}
if(cnt != 0) mp[i] = cnt;
}
if(n != 1) mp[n] = 1;
return mp;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
ll N; cin >> N;
if(N == 1){
cout << 1 << endl;
return 0;
}
map<ll, ll> res;
for(ll i = 2; i <= N; i++){
map<ll, ll> tmp;
tmp = PrimeFac(i);
for(auto j : tmp){
res[j.first] += j.second;
res[j.first] %= MOD;
}
}
ll ans = 1;
for(auto i : res){
ans = (ans*(i.second+1))%MOD;
}
ans %= MOD;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1e18;
const int inf = 1e9;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define per(i, b, a) for (int i = a - 1; i >= b; i--)
#define int long long
using Graph = vector<vector<int>>;
using pint = pair<int, int>;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dxx[8] = {1, 1, 1, 0, 0, -1, -1, -1}, dyy[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
signed main() {
int n;
cin >> n;
map<int, int> mp;
rep (i, 1, n + 1) {
int k = i;
for (int j = 2; j * j <= k; j++) {
while (k % j == 0) {
k /= j;
mp[j]++;
}
}
mp[k]++;
}
int ans = 1;
const int mod = 1e9 + 7;
for (auto p : mp) {
// cout << p.first << " : " << p.second << "\n";
if (p.first == 1) continue;
ans = ans * (p.second + 1) % mod;
// cout << ans << "\n";
}
cout << ans << "\n";
} | 1 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <random>
#include <cassert>
#include <numeric>
#define ll long long int
#define LL unsigned long long
#define pb push_back
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
using namespace std;
int mx8[] = {0,0,1,-1,-1,1,-1,1};
int my8[] = {-1,1,0,0,-1,-1,1,1};
int mx4[] = {1,-1,0,0};
int my4[] = {0,0,-1,1};
const int MOD = 1000000007;
ll y[10000005];
int main() {
string s; cin >> s;
int n = s.size();
map<char,int> mp;
rep(i,n) mp[s[i]]++;
rep(i,26){
if(!mp[char (i+97)]){
cout << s + char(i+97) << endl;
return 0;
}
}
if(s == "zyxwvutsrqponmlkjihgfedcba") cout << -1 << endl;
else {
for(int i = n-1; i >= 1; i--){
if(s[i-1] < s[i]){
rep(j,i-1){
cout << s[j];
}
for(int j = n-1; j>=1;j--){
if(s[i-1] < s[j]){
cout << s[j];
return 0;
}
}
return 0;
}
}
}
}
| #include<bits/stdc++.h>
//using namespace std;
#define rep(i,j,n) for(ll i=(ll)(j);i<(ll)(n);i++)
#define REP(i,j,n) for(ll i=(ll)(j);i<=(ll)(n);i++)
#define per(i,j,n) for(ll i=(ll)(j);(ll)(n)<=i;i--)
#define ll long long
#define ALL(a) (a).begin(),(a).end()
#define disup(A,key) distance(A.begin(),upper_bound(ALL(A),(ll)(key)))
#define dislow(A,key) distance(A.begin(),lower_bound(ALL(A),(ll)(key)))
#define pb push_back
#define mp std::make_pair
#define endl "\n"
using std::cin;
using std::cout;
using std::vector;
using std::string;
using std::upper_bound;
using std::lower_bound;
using vi=vector<ll>;
using vii=vector<vi>;
using pii=std::pair<ll,ll>;
const ll MOD=1e9+7;
//const ll MOD=998244353;
//const ll MOD=100000;
const ll MAX=1e7;
const ll INF=(1ll<<60);
template<class T>
class prique :public std::priority_queue<T, std::vector<T>, std::greater<T>> {};
struct Binary_indexed_tree{
int N;
vi bit;
Binary_indexed_tree(int n):N(n){
bit.resize(N+1,0);
}
void add(int x,int a){
for(x;x<=N;x+=(x&-x)) bit[x]+=a;
}
ll sum(int x){
ll ret=0;
for(x;x>0;x-=(x&-x)) ret+=bit[x];
return ret;
}
ll lower_bound(ll X){
if(sum(N)<X) return -1;
ll ret=0,memo=1,sum=0;
while(memo*2<=N) memo*=2;
while(memo>0){
if(memo+ret<=N&&sum+bit[memo+ret]<X){
sum+=bit[memo+ret];
ret+=memo;
}
memo/=2;
}
return ret+1;
}
};
struct Union_Find{
ll N;
vi par;
vi siz;
Union_Find(int n):N(n){
par.resize(N);
siz.resize(N,1);
rep(i,0,N) par[i]=i;
}
ll root(ll X){
if(par[X]==X) return X;
return par[X]=root(par[X]);
}
bool same(ll X,ll Y){
return root(X)==root(Y);
}
void unite(ll X,ll Y){
X=root(X);
Y=root(Y);
if(X==Y) return;
par[X]=Y;
siz[Y]+=siz[X];
siz[X]=0;
}
ll size(ll X){
return siz[root(X)];
}
};
ll modpow(ll X,ll Y){
ll sum=X,cnt=1;
vi A;
while(cnt<=Y){
A.pb(sum);
sum*=sum;
sum%=MOD;
cnt*=2;
}
int M=A.size();
ll ret=1;
REP(i,1,M){
if(Y>=(1ll<<M-i)){
Y-=(1ll<<M-i);
ret*=A[M-i];
ret%=MOD;
}
}
return ret;
}
ll 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;
}
}
ll COM(ll n,ll r){
if(n<r||n<0||r<0) return 0;
return fac[n]*finv[r]%MOD*finv[n-r]%MOD;
}
signed main(){
string S; cin>>S;
if(S.size()==26){
if(S=="zyxwvutsrqponmlkjihgfedcba"){
cout<<-1<<endl;
return 0;
}
std::set<char> set;
set.insert(S[25]);
per(i,24,0){
if(*set.rbegin()>S[i]){
for(auto p:set){
if(p>S[i]){
S=S.substr(0,i)+p;
break;
}
}
break;
}
set.insert(S[i]);
}
}
else{
vector<bool> F(26,1);
rep(i,0,S.size()) F[S[i]-'a']=0;
rep(i,0,26){
if(F[i]){
S+=i+'a';
break;
}
}
}
cout<<S<<endl;
}
| 1 |
#include<cstdio>
const int N=1e5+5;
int n,i,a[N],ans;
int read(){
char c=getchar();int k=0;for (;c<48||c>57;c=getchar());
for (;c>47&&c<58;c=getchar()) k=(k<<3)+(k<<1)+c-48;return k;
}
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int main(){
for (n=read(),i=1;i<=n;i++) a[i]=read();
if (n==1){puts("Second");return 0;}
for (;;){
int k0=0,k1=0,x;
for (i=1;i<=n;i++)
if (a[i]&1) k1++,x=i; else k0++;
if (k0&1){ans^=1;break;}
if (k1>1||a[x]==1) break;
a[x]--;int k=a[1];ans^=1;
for (i=2;i<=n&&k>2;i++) k=gcd(k,a[i]);
for (i=1;i<=n;i++) a[i]/=k;
}
puts(ans?"First":"Second");
} | #include <iostream>
#include <algorithm>
#include <numeric>
#include <vector>
using namespace std;
template <class T>
T gcd(T a, T b) {
while (b > 0) {
a %= b;
swap(a, b);
}
return a;
}
bool solve(int N, vector<int>& A) {
if (N == 1) return false;
// 総和の偶奇
int parity = accumulate(A.begin(), A.end(), 0, [](int init, int a) { return (init + (a & 1)) & 1; });
// Nが偶数の場合、和の偶奇がそのまま勝敗になる
if ((N & 1) == 0) return parity != 0;
// Nが奇数の場合も、和が偶数なら絶対勝てる
if (parity == 0) return true;
// 奇数を前に持っていく
sort(A.begin(), A.end(), [](int a, int b) { return (a & 1) > (b & 1); });
// 奇数が複数個ある、あるいは唯一の奇数が1(減らせない)なら負け
if (A[0] == 1 || (A[1] & 1) != 0) return false;
// そうでなければ、唯一の奇数を減らしてワンチャンに賭ける
--A[0];
int g = accumulate(A.begin(), A.end(), 0, gcd<int>);
for (auto& a : A) a /= g;
return !solve(N, A);
}
int main() {
int N;
cin >> N;
vector<int> A(N);
for (auto& a : A) cin >> a;
cout << (solve(N, A) ? "First" : "Second") << endl;
return 0;
}
| 1 |
#include <iostream>
#include <string>
using namespace std;
int main(){
string str;
while(getline(cin,str)){
int flg = 0;
while(true){
for(int i = 0 ; i < str.length() ; i++){
string key1 = str.substr(i,3),key2 = str.substr(i,4);
if(key1 == "the" || key2 == "that" || key2 == "this") flg = 1;
}
if(flg) break;
else{
for(int j = 0 ; j < str.length() ; j++){
if('a' <= str[j] && str[j] <= 'z'){
str[j] -= 'a' - 'A';
str[j] = (char)('A'+(str[j]-'A'+26+1)%26);
str[j] += 'a' - 'A';
}
else continue;
}
}
}
cout << str << endl;
}
return 0;
} | #include<stdio.h>
int main()
{
int h,w,k,omen;
scanf("%d %d %d",&h,&w,&k);
if(h > w) omen = h;
else omen = w;
int count = 1;
for(int i = omen;i<k;i += omen)
{
count++;
}
printf("%d\n",count);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a = 0,b = 0;
cin >> a >> b;
a--;
b--;
cout << (b + (a - 1)) / a << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define REP(i,n) for (int64_t i=0; i<(n); ++i)
#define P pair<int,int>
using ll=int64_t;
using namespace std;
#define ketasuu(n) fixed<<setprecision(n)
#define btoe(p) p.begin(),p.end()
#define etob(p) p.rbegin(),p.rend()
int main(){
int n; cin>>n;
string s; cin>>s;
vector<int> p(n);
if(s[0]=='E') p[0]=-1;
else p[0]=1;
rep(i,n-1){
if(s[i+1]=='E') p[i+1]=-1;
else p[i+1]=1;
p[i+1]+=p[i];
}
auto an=min_element(btoe(p));
int ba=an-p.begin();
int ans=0;
rep(i,n){
if(i<ba){
if(s[i]=='W') ans++;
}
else if(i>ba){
if(s[i]=='E') ans++;
}
}
cout<<ans<<endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
struct Point{
int x,y,idx;
bool operator<(const Point& rhs)const{
return x==rhs.x?y<rhs.y:x<rhs.x;
}
}P[100];
bool bad(const Point& p1,const Point& p2,const Point& p3){
return 1LL*(p3.x-p1.x)*(p2.y-p1.y)-1LL*(p2.x-p1.x)*(p3.y-p1.y)<=0;
}
vector<Point> convex(int n){
sort(P,P+n);
vector<Point> res;
for(int i=0;i<n;i++){
while(res.size()>=2&&bad(res[res.size()-2],res[res.size()-1],P[i]))
res.pop_back();
res.emplace_back(P[i]);
}
for(int i=n-2,t=res.size();i>=0;i--){
while(res.size()>t&&bad(res[res.size()-2],res[res.size()-1],P[i]))
res.pop_back();
res.emplace_back(P[i]);
}
res.pop_back();
return res;
}
double ans[100];
const double pi = acos(-1);
inline double dist(int x,int y){
return sqrt(1LL*x*x+1LL*y*y);
}
double calc(const Point& p1,const Point& p2,const Point& p3){
long long int dot=1LL*(p3.x-p2.x)*(p2.x-p1.x)+1LL*(p3.y-p2.y)*(p2.y-p1.y);
double tmp=dot/(double)dist(p2.x-p1.x,p2.y-p1.y)/(double)dist(p3.x-p2.x,p3.y-p2.y);
double ang = acos(tmp);
return ang/(2*pi);
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin>>n;
for(int i=0;i<n;i++)
cin>>P[i].x>>P[i].y,P[i].idx=i;
auto res = convex(n);
if(res.size()==2){
ans[res[0].idx]=0.5;
ans[res[1].idx]=0.5;
}
else{
for(int j=0;j<res.size();j++){
int i=(j+(res.size()-1))%res.size();
int k=(j+1)%res.size();
ans[res[j].idx] = calc(res[i],res[j],res[k]);
}
}
cout<<fixed<<setprecision(10);
for(int i=0;i<n;i++)
cout<<ans[i]<<'\n';
}
| #include <bits/stdc++.h>
using namespace std::literals::string_literals;
using i64 = long long;
using std::cout;
using std::endl;
using std::cin;
template<typename T>
std::vector<T> make_v(size_t a){return std::vector<T>(a);}
template<typename T,typename... Ts>
auto make_v(size_t a,Ts... ts){
return std::vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));
}
struct UnionFind{
std::vector<int> data;
UnionFind(int n){
data.assign(n, -1);
}
bool unite(int x, int y){
x = find(x); y = find(y);
if(x == y) return false;
if(data[x] > data[y]) std::swap(x, y);
data[x] += data[y];
data[y] = x;
return true;
}
bool same(int x, int y){
return find(x) == find(y);
}
int find(int k){
if(data[k] < 0) return k;
return data[k] = find(data[k]);
}
int size(int k){
return -data[find(k)];
}
};
int main() {
int n; scanf("%d", &n);
std::vector<std::pair<i64, int>> X, Y;
for(int i = 0; i < n; i++) {
int x, y; scanf("%d%d", &x, &y);
X.push_back({x, i});
Y.push_back({y, i});
}
sort(begin(X), end(X)); sort(begin(Y), end(Y));
std::vector<std::pair<i64, std::pair<int, int>>> edges;
for(int i = 0; i < n - 1; i++) {
edges.push_back({X[i + 1].first - X[i].first, {X[i].second, X[i + 1].second}});
edges.push_back({Y[i + 1].first - Y[i].first, {Y[i].second, Y[i + 1].second}});
}
sort(begin(edges), end(edges));
i64 ans = 0;
UnionFind uf(n);
for(auto e: edges) {
int x = e.second.first, y = e.second.second;
if(uf.unite(x, y)) ans += e.first;
}
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define INF 1e9
using namespace std;
#define REPR(i,n) for(int i=(n); i >= 0; --i)
#define FOR(i, m, n) for(int i = (m); i < (n); ++i)
#define REP(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define ALL(a) (a).begin(),(a).end()
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return true; } return false; }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
int gcd(int a,int b){return b?gcd(b,a%b):a;}
typedef long long ll;
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
int main() {
int N;
cin >> N;
vector<double> a(N);
REP(i,N) cin >> a[i];
double av = accumulate(ALL(a),double(0))/N;
int ans = 0;
double shortest = INF;
REP(i,N) {
if (chmin(shortest,abs(av-a[i]))) {
ans = i;
}
}
cout << ans << endl;
return 0;
}
| #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <clocale>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define IOS ios::sync_with_stdio(false); cin.tie(0);
#define FOR(i, s, n) for(int i = (s), i##_len=(n); i < i##_len; ++i)
#define FORS(i, s, n) for(int i = (s), i##_len=(n); i <= i##_len; ++i)
#define VFOR(i, s, n) for(int i = (s); i < (n); ++i)
#define VFORS(i, s, n) for(int i = (s); i <= (n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) FORS(i, 0, n)
#define VREP(i, n) VFOR(i, 0, n)
#define VREPS(i, n) VFORS(i, 0, n)
#define RFOR(i, s, n) for(int i = (s), i##_len=(n); i >= i##_len; --i)
#define RFORS(i, s, n) for(int i = (s), i##_len=(n); i > i##_len; --i)
#define RREP(i, n) RFOR(i, n, 0)
#define RREPS(i, n) RFORS(i, n, 0)
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort(ALL(v))
#define RSORT(v) sort(ALL(v), greater<decltype(v[0])>())
#define SZ(x) ((int)(x).size())
#define REV(x) reverse(ALL(x))
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define MT make_tuple
#define BIT(n) (1LL<<(n))
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end())
using ld = long double;
using ll = long long;
using ui = unsigned int;
using ull = unsigned long long;
using Pi_i = pair<int, int>;
using Pll_ll = pair<ll, ll>;
using VB = vector<bool>;
using VC = vector<char>;
using VD = vector<double>;
using VI = vector<int>;
using VLL = vector<ll>;
using VS = vector<string>;
using VSH = vector<short>;
using VULL = vector<ull>;
const int MOD = 1000000007;
const int INF = 1000000000;
const int NIL = -1;
const double EPS = 1E-10;
template<class T, class S>
bool chmax(T &a, const S &b){
if(a < b){
a = b; return true;
}
return false;
}
template<class T, class S>
bool chmin(T &a, const S &b){
if(b < a){
a = b; return true;
}
return false;
}
int main(){
int N, sum(0); cin >> N;
VI a(N);
REP(i, N){
cin >> a[i];
sum += a[i];
}
int ans = -1, dif(INF);
REP(i, N){
if(dif > abs(N*a[i] - sum)){
dif = abs(N*a[i] - sum);
ans = i;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <iostream>
#include <map>
#include <unordered_map>
#include <algorithm>
#include <vector>
using namespace std;
//const char a[26]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
// input - given string
// You need to update in the given string itself i.e. in input. No need to return or print.
int solver() {
// Write your code here
int n;
cin>>n;
int l;
cin>>l;
//vector<int> my;
int freq[10];
for(int i=0;i<=9;i++)
{
freq[i]=0;
}
for(int i=0;i<l;i++)
{
int x;
cin>>x;
// my[i]=x;
freq[x]=1;
}
//cout<<my[0];
for(int j=n;j<100000;j++)
{
int num=j;
bool k=true;
while(num>0)
{
int m=num%10;
if(freq[m]==1)
{
k=false;
break;
}
num=num/10;
}
if(k)
{
return j;
}
}
return 0;
}
int main() {
int n=1;
//cin>>n;
while(n--)
{
cout<<solver();
}
}
| #include <vector>
#include <stack>
#include <queue>
#include <list>
#include <bitset>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <string>
#include <chrono>
#include <random>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <functional>
#include <sstream>
using namespace std;
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
int n, K;
cin >> n >> K;
vector<int> bad(10, false);
for (int i = 0; i < K; ++i) {
int x;
cin >> x;
bad[x] = true;
}
int mn = 10;
for (int k = 0; k < 10; ++k) {
if (!bad[k]) {
mn = k;
break;
}
}
string s = to_string(n);
n = s.length();
for (int i = 0; i < n; ++i) {
int d = s[i] - '0';
if (bad[d]) {
while (i >= 0) {
bool done = false;
d = s[i] - '0';
for (int j = d + 1; j < 10; ++j) {
if (!bad[j]) {
s[i] = (char) ('0' + j);
for (int k = i + 1; k < n; ++k) {
s[k] = (char)('0' + mn);
}
done = true;
break;
}
}
if (done) {
break;
}
--i;
}
if (i < 0) {
for (int j = 1; j < 10; ++j) {
if (!bad[j]) {
s = string(1, (char)('0' + j));
break;
}
}
s += string(n, (char)('0' + mn));
}
break;
}
}
cout << s << '\n';
return 0;
} | 1 |
#include <bits/stdc++.h>
#define INF 1000000000
#define MAX_N 100
using namespace std;
typedef pair<int, int> P;
struct edge {
int to, cost;
edge(int to_, int cost_) : to(to_), cost(cost_) {}
};
int n;
vector<edge> G[MAX_N];
int Prim() {
int res = 0;
vector<bool> used(n, false);
priority_queue<P, vector<P>, greater<P>> que;
que.push(P(0, 0));
while (!que.empty()) {
P p = que.top(); que.pop();
int v = p.second;
if (used[v]) continue;
used[v] = true;
res += p.first;
for (int i = 0; i < G[v].size(); i++) {
edge e = G[v][i];
que.push(P(e.cost, e.to));
}
}
return res;
}
int main()
{
cin >> n;
for (int i = 0, c; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> c;
if (c != -1)
G[i].push_back(edge(j, c));
}
}
cout << Prim() << endl;
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int P[10010];
void init(int N){
for (int i=0; i<N; i++) P[i] = i;
}
int root (int a){
if (P[a] == a) return a;
else {
P[a] = root(P[a]);
return P[a];
}
}
bool is_same_set(int a, int b){
return root(a) == root(b);
}
void unite(int a, int b){
P[root(a)] = root(b);
}
int main(){
int N;
cin >> N;
pair <int, int> edge[10010];
for (int i=0; i<N; i++){
for (int j=0; j<N; j++){
cin >> edge[i*N+j].first;
edge[i*N+j].second = i*N+j;
}
}
sort(edge, edge+N*N);
init(N);
int ans = 0;
int b = 0;
for (int k=0; k<N*N; k++){
while(edge[k].first < 0) k++;
int i = edge[k].second / N;
int j = edge[k].second % N;
if (is_same_set(i,j)){}
else{
unite(i,j);
ans += edge[k].first;
}
}
cout << ans << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<int(n);++i)
typedef complex<double> Point;
typedef vector<Point> VP;
#define X real()
#define Y imag()
const double EPS = 1e-9;
const double PI = acos(-1.0);
#define LE(n,m) ((n) < (m) + EPS)
#define GE(n,m) ((n) + EPS > (m))
#define EQ(n,m) (abs((n)-(m)) < EPS)
namespace std {
bool operator<(const Point a, const Point b) {
return a.X != b.X ? a.X < b.X : a.Y < b.Y;
}
}
double dot(Point a, Point b) {
return a.X*b.X + a.Y*b.Y;
}
double cross(Point a, Point b) {
return a.X*b.Y - a.Y*b.X;
}
int ccw(Point a, Point b, Point c) {
b -= a; c -= a;
if (cross(b,c) > EPS) return +1; // counter clockwise
if (cross(b,c) < -EPS) return -1; // clockwise
if (dot(b,c) < -EPS) return +2; // c--a--b on line
if (norm(b) < norm(c)) return -2; // a--b--c on line or a==b
return 0; // a--c--b on line or a==c or b==c
}
VP convexHull(VP ps) { // 元の点集合がソートされていいならVP&に
int n = ps.size(), k = 0;
sort(ps.begin(), ps.end());
VP ch(2*n);
for (int i = 0; i < n; ch[k++] = ps[i++]) // lower-hull
while (k >= 2 && ccw(ch[k-2], ch[k-1], ps[i]) <= 0) --k; // 余計な点も含むなら == -1 とする
for (int i = n-2, t = k+1; i >= 0; ch[k++] = ps[i--]) // upper-hull
while (k >= t && ccw(ch[k-2], ch[k-1], ps[i]) <= 0) --k;
ch.resize(k-1);
return ch;
}
int main(void){
VP vp;
int n;
cin>>n;
rep(i,n){
double x,y;
cin>>x>>y;
vp.push_back(Point(x,y));
}
VP ch = convexHull(vp);
int m = ch.size();
vector<double> range;
rep(i,m){
range.push_back(arg(ch[(i+1)%m]-ch[i]) - arg(ch[i]-ch[(m+i-1)%m]));
}
rep(i,n){
bool inConvex = true;
rep(j,m){
if(vp[i] == ch[j]){
inConvex = false;
printf("%.10f\n", acos(cos(range[j]))/(2.0*PI));
break;
}
}
if(inConvex) printf("0.0\n");
}
return 0;
}
| #include<iostream>
#include<math.h>
#include<algorithm>
#include<tuple>
using namespace std;
#define fr(i,n) for(int i=0;i<n;i++)
typedef double db;
typedef tuple<bool,db> bod;
db Pi = 3.14159265358979;
db st(db t){
t+=4*Pi;
while(t>=0) t-=2*Pi;
t+=2*Pi;
return t;
}
bod J(db a,db b){
if(a<=Pi){
return make_tuple(!(a<=b && b<a+Pi),a+Pi-b);
}
else{
return make_tuple(!(a<=b || b<a-Pi),st(a+Pi-b));
}
}
int main(){
int n,q,r;
bool f;
db x[100],y[100],m[100][100],M;
cin >> n;
if(n==2){
cout<<0.5<<endl<<0.5<<endl;
return 0;
}
fr(i,n) cin>>x[i]>>y[i];
fr(i,n){
fr(j,n){
if(i != j){
m[i][j]=st(atan2(x[j]-x[i],y[j]-y[i]));
}
}
fr(j,n){
if(i==j) continue;
f=0;
M=2*Pi;
fr(k,n){
if(k==i || k==j) continue;
// cout<<i<<" "<<j<<" "<<k<<" "<<m[i][j]<<" "<<m[i][k]<<endl;
bod G=J(m[i][j],m[i][k]);
if(M>get<1>(G)){
r=k;
M=get<1>(G);
}
if(get<0>(G)){
f=1;
break;
}
}
if(!f){
q=j;
break;
}
}
if(f) cout<<0.0<<endl;
else cout<<M/(2*Pi)<<endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define ld long double
#define mod 1000000007LL
#define eps 1e-13
// #define PI 3.141592653589793238L
#define INF 1000000011
#define INFLL 1000000000000000011LL
#define vi vector<int>
#define vll vector<long long>
#define pii pair<int, int>
#define pll pair<long long, long long>
#define pil pair<int, long long>
#define pli pair<long long, int>
#define mp make_pair
#define F first
#define S second
#define pb push_back
#define fo(i,a,n) for(i = (a); i < (n); i++)
#define gtl(x) getline(cin, (x))
#define flsh fflush(stdout)
#define sws ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define gcd __gcd
#define all(a) (a).begin(), (a).end()
#define sz(a) (int)((a).size())
#define io_file freopen("D:/Coding Problems/Contest/input_file.in", "r", stdin); freopen("D:/Coding Problems/Contest/output_file.out", "w", stdout)
ll modx(ll Base, ll exponent)
{
ll ans = 1;
if(Base == 1)
return Base;
while(exponent)
{
if(exponent & 1)
ans = (ans * Base)%mod;
Base = (Base * Base)%mod;
exponent = exponent >> 1;
}
return ans;
}
ll inmodx(ll num)
{
return (modx(num, mod-2LL));
}
bool cmp(pair < pii, int > a, pair < pii, int > b)//true for a before b
{
if(a.F.F/300 < b.F.F/300)
return 1;
if(a.F.F/300 > b.F.F/300)
return 0;
if(a.F.S < b.F.S)
return 1;
if(a.F.S > b.F.S)
return 0;
if(a.F <= b.F)
return 1;
return 0;
}
const int N = (6e2) + 9;
const int M = (36e4) + 9;
const int LOGN = ((int)log2(N)) + 3;
const int LOGM = ((int)log2(M)) + 3;
const int BUCK = 2*550;
const int SQRT = BUCK+9;
vector < pii > arr[2], ans[4];
int node[N][N];
pii val[M];
vi v[2][M];
int mark[2][M];
bool vis[2][M];
queue < int > q;
int n;
inline void add_edge(int bit, int a, int b, int x, int y)
{
if(x < 0 || x >= n+n || y < 0 || y >= n+n)
return;
v[bit][node[a][b]].pb(node[x][y]);
return;
}
void bfs(int cur, int bit)
{
if(vis[bit][cur])
return;
while(!q.empty())
q.pop();
int z;
q.push(cur);
vis[bit][cur] = 1;
mark[bit][cur] = 0;
while(!q.empty())
{
z = q.front();
q.pop();
for(auto x : v[bit][z])
if(!vis[bit][x])
{
vis[bit][x] = 1;
mark[bit][x] = 1 - mark[bit][z];
q.push(x);
}
}
return;
}
void solve()
{
int d1, d2, i, j, k, d, cnt = 0;
cin >> n >> d1 >> d2;
fo(i,0,n+n)
fo(j,0,n+n)
{
int d = i*i + j*j;
if(d == d1)
arr[0].pb({i,j});
if(d == d2)
arr[1].pb({i,j});
}
fo(i,0,n+n)
fo(j,0,n+n)
{
node[i][j] = cnt;
val[cnt] = {i,j};
cnt++;
}
fo(i,0,n+n)
fo(j,0,n+n)
fo(k,0,2)
for(auto x : arr[k])
{
add_edge(k,i,j,i+x.F,j+x.S);
add_edge(k,i,j,i+x.F,j-x.S);
add_edge(k,i,j,i-x.F,j+x.S);
add_edge(k,i,j,i-x.F,j-x.S);
}
fo(i,0,cnt)
{
bfs(i,0);
bfs(i,1);
}
fo(i,0,cnt)
ans[mark[0][i]*2 + mark[1][i]].pb(val[i]);
fo(j,0,4)
if(sz(ans[j]) >= n*n)
{
fo(i,0,n*n)
cout << ans[j][i].F << " " << ans[j][i].S << '\n';
return;
}
return;
}
int main()
{
sws;
clock_t clk;
clk = clock();
// io_file;
// srand (time(NULL));
//Code here
int t = 1, cs;
cout << fixed << setprecision(9);
// cin >> t;
fo(cs,1,t+1)
{
// cout << "Case #" << cs << ": ";
solve();
}
// Code ends here
clk = clock() - clk;
cerr << fixed << setprecision(6) << "Time: " << ((double)clk)/CLOCKS_PER_SEC << "\n";
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=55,mod=1e9+7,inf=2000000000;
int n,a[N];
char s[N];
unordered_map<ll,int>vis[20][20];
int main()
{
scanf("%d",&n);
scanf("%s",s+1);
int up=1<<n;
for(int i=0;i<up;i++)
{
ll sum1=0,sum2=0,a=__builtin_popcount(i),b=n-a;
for(int j=1;j<=n;j++)
if(i>>j-1&1)
sum1=(sum1*2333%mod+s[j]-'a')%mod;
else sum2=(sum2*2333%mod+s[j]-'a')%mod;
//cout<<a<<' '<<b<<' '<<sum1*inf+sum2<<endl;
vis[a][b][sum1*inf+sum2]++;
}
reverse(s+1,s+1+n+n);
ll ans=0;
for(int i=0;i<up;i++)
{
ll sum1=0,sum2=0,a=__builtin_popcount(i),b=n-a;
for(int j=1;j<=n;j++)
if(i>>j-1&1)
sum1=(sum1*2333%mod+s[j]-'a')%mod;
else sum2=(sum2*2333%mod+s[j]-'a')%mod;
//cout<<a<<' '<<b<<' '<<sum1*inf+sum2<<endl;
ans+=vis[b][a][sum2*inf+sum1];
}
printf("%lld\n",ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(false); cin.tie(0);
#define FOR(i,s,n) for(int i = s; i < (n); i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(n) (n).begin(), (n).end()
#define RALL(n) (n).rbegin(), (n).rend()
#define ATYN(n) cout << ( (n) ? "Yes":"No") << '\n';
#define CFYN(n) cout << ( (n) ? "YES":"NO") << '\n';
#define OUT(n) cout << (n) << '\n';
using ll = long long;
using ull = unsigned long long;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
int main(void)
{
IOS
int n; cin >> n;
multiset<int> mst;
REP(i,n) {
int a; cin >> a;
mst.insert(a);
}
int ans = 0;
while(!mst.empty()) {
auto back = mst.end();
back--;
int x = *back;
mst.erase(back);
double l2 = log2(x);
if (l2 == floor(l2)) {
auto it = mst.find(x);
if (it != mst.end()) {
ans++;
mst.erase(it);
}
} else {
int x2 = pow(2,ceil(l2));
auto it = mst.find(x2-x);
if (it != mst.end()) {
ans++;
mst.erase(it);
}
}
}
cout << ans << '\n';
return 0;
} | #include <iostream> // cout, endl, cin
#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 <math.h> // sqrt
#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 <iomanip> // setprecision
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vb = vector<bool>;
using vll = vector<long long>;
using pii = pair<int, int>;
using psi = pair<string, int>;
int N;
int f(vector<vector<pair<int, int>>> &data, vi &bit, int n) {
if (n == 0) {
int ans = 0;
bool check = false;
for (int i = 0; i < N; i++) {
if (bit[i] == 0) {
continue;
}
ans++;
for (pair<int, int> p : data[i]) {
if (bit[p.first - 1] != p.second) {
return 0;
}
}
}
return ans;
}
bit[N - n] = 1;
int a = f(data, bit, n - 1);
bit[N - n] = 0;
int b = f(data, bit, n - 1);
return max(a, b);
}
int main() {
cin >> N;
vi a(N);
vector<vector<pair<int, int>>> data(N);
for (int i = 0; i < N; i++) {
cin >> a[i];
vector<pair<int, int>> v(a[i]);
for (int j = 0; j < a[i]; j++) {
int x, y;
cin >> x >> y;
v[j] = {x, y};
}
data[i] = v;
}
vi bit(N, 0);
int ans = f(data, bit, N);
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define pii pair<int,int>
#define piii pair<int,pii>
#define pll pair<ll,ll>
#define plii pair<ll,pii>
#define vi vector<int>
#define ff first
#define ss second
#define mp make_pair
#define pb push_back
#define SORT(x) sort(x.begin(), x.end())
#define GSORT(x) sort(x.begin(), x.end(), greater<int>())
#define lw(vc,num) lower_bound(vc.begin(), vc.end(), num) - vc.begin();
#define hg(vc,num) upper_bound(vc.begin(), vc.end(), num) - vc.begin();
#define bn(v,x) binary_search (v.begin(), v.end(), x)
#define mx 100001
#define eps 0.00000000001
#define mod 1000000007
#define pi acos(-1)
#define inf 100000000
#define loop(i,b,n) for(int i=b;i<n;++i)
#define rev_loop(i,b,n) for(int i=b;i>=n;--i)
#define fio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
bool isprime(int n)
{
if(n == 1) return false;
if(n == 2 || n == 3) return true;
if(n%2 == 0 || n%3 == 0) return false;
for(int i=5; i*i<=n; i+=6){
if((n%i == 0)||(n%(i+2) == 0)) return false;
}
return true;
}
long long binpow(long long a, long long b) {
if (b == 0)
return 1;
long long res = binpow(a, b / 2);
if (b % 2)
return res * res * a;
else
return res * res;
}
int main()
{
fio;
int a,b,c;
cin>>a>>b>>c;
if((a==b && b==c && c==a) || (a!=b && b!=c && c!=a))
cout<<"No\n";
else
cout<<"Yes\n";
return 0;
}
| #pragma GCC optimize ("Ofast")
#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;
struct _ { ios_base::Init i; _() { cin.sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(10); } } ___;
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " ";
__f(comma + 1, args...);
}
#define ll long long
#define pii pair<int,int>
#define oset tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define ff first
#define ss second
#define endll '\n'
#define rep(i,n) for(int i=0;i++<n;)
#define scl(i) scanf("%lld",&i)
#define int long long int
#define all(n) n.begin(),n.end()
#define mem(n,i) memset(n,i,sizeof n)
#define em(a) emplace_back(a)
#define pb(a) push_back(a)
#define srep(it,vv) for(auto &it : vv)
#define prep(it,vv) for(auto it : vv)
//vector<vector<int>>arr(n + 5, vector<int>(m + 5,0));
typedef vector<int> vii;
typedef vector<string> vss;
/*
*/
signed main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
set<int>ss;
int n = 3;
rep(i, n)
{
int a; cin >> a;
ss.insert(a);
}
if (ss.size() == 2) cout << "Yes" << endll;
else cout << "No" << endll;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define LL long long
#define pii pair<int, int>
int main(){
int n; cin>>n;
vector<int> v;
for(int i = 1; i <= 2*n; i++){
int x; cin>>x;
v.push_back(x);
}
sort(v.begin(), v.end());
int res = 0;
for(int i = 0; i < (2*n)-1; i += 2){
res += min(v[i], v[i+1]);
}
cout<<res<<'\n';
}
| //#include<bits/stdc++.h>
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <list>
#include <cmath>
#include <cstring>
#include <algorithm>
using namespace std;
/*#define fast ios_base::sync_with_stdio(0); cin.tie(0)*/
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
const double pi = acos(-1);
typedef long long ll;
int main()
{
//fast;
ll a,b,c,d;
cin>>a>>b>>c>>d;
cout<<min(a,b)+min(c,d);
} | 0 |
#include <bits/stdc++.h>
using namespace::std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef array<int, 3> tri;
typedef long double ld;
template <class T> istream& operator>>(istream& I, vector<T>& v) {for (T &e: v) I >> e; return I;}
template <class T> ostream& operator<<(ostream &O, const vector<T>& v) {for (const T &e: v) O << e << ' '; return O;}
void _main() {
int n; cin >> n;
vector<pair<int,int>> a(n);
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
sort(all(a));
auto calc = [](vector<pair<int,int>> a) {
double cnt = 0;
for (int i = 1; i < a.size(); i++) {
double dist = sqrt(pow(a[i].first - a[i - 1].first,2) + pow(a[i].second - a[i - 1].second, 2));
cnt += dist;
}
return cnt;
};
double ans = 0, k = 0;
sort(all(a));
do {
ans += calc(a);
k++;
} while (next_permutation(all(a)));
ans /= k;
cout << fixed << setprecision(10) << ans;
}
signed main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
// freopen("input.txt", "r", stdin);
int _t = 1;
// cin >> _t;
while (_t--) _main();
return 0;
} | #include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <cmath>
#include <stdio.h>
#include <list>
#include <numeric>
#include <stack>
#include <queue>
#include <tuple>
#include <bitset>
#include <map>
#include <math.h>
//ceil(a/b) (a + (b - 1))/ b
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); i++)
typedef long long ll;
typedef pair<int,int> P;
const int inf=1000000007;
const ll mod=1000000007;
const double PI=3.14159265358979323846;
int dx[] = {1,-1,0,0};
int dy[] = {0,0,1,-1};
int main(){
int N;
cin >> N;
double D[N][N];
vector<P> c(N);
rep(i,N) {
double x,y;
cin >> x >> y;
c[i] = make_pair(x,y);
}
rep(i,N) {
rep(j,N) {
double x0 = c[i].first;
double y0 = c[i].second;
double x1 = c[j].first;
double y1 = c[j].second;
D[i][j] = sqrt((x0-x1)*(x0-x1) + (y0-y1)*(y0-y1));
}
}
vector<int> l(N);
rep(i,N) l[i] = i;
double sum = 0;
double n = 0;
do{
n++;
rep(i,N-1) {
sum += D[l[i]][l[i+1]];
}
}while(next_permutation(l.begin(),l.end()));
double ans = sum/n;
printf("%.12lf\n",ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
vector<int>X(26,0);
string S;cin>>S;
for(long long i=0;i<S.size();i++){
X[(int)S[i]-97]++;
}
for(long long i=0;i<26;i++){
if(X[i]==0){
int ans=i+97;
cout<<(char)ans<<endl;
return 0;
}
}
cout<<"None"<<endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
string s;
cin >> s;
for (char c='a'; c<='z'; c++) {
if (s.find(c) == string::npos) {
cout << c << endl;
return 0;
}
}
cout << "None" << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b,c,d;
cin>>a>>b>>c>>d;
int sum1=min(a,b);
int sum2=min(c,d);
int sum=sum1+sum2;
cout<<sum<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N=2e5+5,MOD=1e9+7;
long long fac[N],infac[N];
long long poww(long long x,long long y)
{
if(y==0) return 1;
if(y&1) return (x*poww(x,y-1))%MOD;
return poww((x*x)%MOD,y/2);
}
long long nck(int n,int k)
{
return (((fac[n]*infac[k])%MOD)*infac[n-k])%MOD;
}
long long get(int a,int b,int c,int d)
{
int tot=(c-a)+(d-b);
return nck(tot,c-a);
}
int main()
{
fac[0]=infac[0]=1;
for(int i=1;i<N;i++)
{
fac[i]=(fac[i-1]*i)%MOD;
infac[i]=poww(fac[i],MOD-2);
}
int n,m,a,b;
cin >> n >> m >> a >> b;
long long ans=0;
for(int i=0;i<n-a;i++)
{
ans+=get(0,0,i,b-1)*get(i,b,n-1,m-1);
ans%=MOD;
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
#define rep(i, f, n) for (ll i = (f); i < (ll)(n); i++)
#define repe(i, f, n) for (ll i = (f); i <= (ll)(n); i++)
using namespace std;
using ll = long long;
using pint = pair<int, int>;
int main() {
int N;
cin >> N;
repe(i, N, 999) {
string s = to_string(i);
bool ok = true;
rep(j, 1, s.size()) if (s[j - 1] != s[j]) ok = false;
if (ok) {
cout << i << endl;
return 0;
}
}
return 0;
}
| #include <iostream>
using namespace std;
int main(void){
int n,i;
cin >> n;
for(i=n;i<n+111;i++){
if(i%111==0) break;
}
cout << i;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N;
cin >> N;
vector<char> name = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
ll block = 0;
vector<int> x;
while (N>0) {
N--;
x.push_back(N%26);
N /= 26;
}
string ans = "";
for (ll i=x.size()-1; i>=0; i--) {
ans += name[x[i]];
}
cout << ans << endl;
} | #include <iostream>
using namespace std;
int main() {
int T, t, b{-(1<<30)}, ans{};
cin >> T >> T;
while (cin >> t) {
ans += t < b + T ? t - b : T;
b = t;
}
cout << ans << endl;
}
| 0 |
#include<iostream>
#include<string>
using namespace std;
int data[7];
void N(){int x=data[5];data[5]=data[1];data[1]=data[2];data[2]=data[6];data[6]=x;}
void S(){int x=data[5];data[5]=data[6];data[6]=data[2];data[2]=data[1];data[1]=x;}
void E(){int x=data[3];data[3]=data[1];data[1]=data[4];data[4]=data[6];data[6]=x;}
void W(){int x=data[4];data[4]=data[1];data[1]=data[3];data[3]=data[6];data[6]=x;}
int main(){
string com;
for(int i=1;i<=6;++i)cin>>data[i];
getline(cin,com);
getline(cin,com);
for(auto ch:com){
if(ch=='N')N();
if(ch=='S')S();
if(ch=='E')E();
if(ch=='W')W();
}
cout<<data[1]<<endl;
return 0;
} | // copied by Nurstan Duisengaliev
// skatal
#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define all(x) x.begin(), x.end()
#define in insert
#define mp make_pair
#define F first
#define S second
#define ppf pop_front
#define pb push_back
#define ppb pop_back
#define pf push_front
#define pii pair <int, int>
#define boost() ios_base::sync_with_stdio(0), cin.tie(0)
#define sz(x) (int)x.size()
using namespace std;
//using namespace __gnu_pbds;
//template<typename T> using ordered_set = tree <T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
const int N = (int)5e5 + 123;
const int mod = (int)1e9 + 7;
const ll INF = (ll)1e18 + 7;
int n, a[N];
void solve () {
cin >> n;
n *= 2;
for (int i = 1; i <= n; i ++) cin >> a[i];
sort (a + 1, a + n + 1);
ll sum = 0;
for (int i = 1; i <= n; i += 2) sum += a[i];
cout << sum;
}
main () {
// freopen (".in", "r", stdin);
// freopen (".out", "w", stdout);
boost ();
int TT = 1;
// cin >> TT;
while (TT --) {
solve ();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef set<int> si;
typedef pair<int,int> pii;
#define rep(i,a,b) for(int i=(a); i<(b); ++i)
#define per(i,a,b) for(int i=(b)-1; i>=(a); --i)
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define F first
#define S second
void cal(string s, string x, string y, map<pair<string, string>, ll>& a) {
if(sz(s) == 0) {
a[mp(x,y)]++;
return;
}
cal(s.substr(1), x + s.substr(0,1), y, a);
cal(s.substr(1), x, y + s.substr(0,1), a);
}
ll solve(string s, string t) {
map<pair<string, string>, ll> a, b;
string x,y;
x = y = "";
cal(s,x,y,a);
cal(t,x,y,b);
ll ret = 0;
for(auto e : a) {
auto key = e.F;
if(b.find(key) != b.end()) {
ret += e.S * b[key];
}
}
return ret;
}
int main(void) {
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
//freopen("in.txt", "r", stdin);
int n;
string s;
cin >> n >> s;
string t = s.substr(n);
reverse(all(t));
cout << solve(s.substr(0,n), t) << '\n';
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll,ll> P;
typedef pair<int,int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
#define endl "\n"
template<typename T> inline bool chmax(T &a, T b){if(a<b){a=b;return true;}return false;}
template<typename T> inline bool chmin(T &a, T b){if(a>b){a=b;return true;}return false;}
template<typename T> ostream& operator<<(ostream& s,const complex<T>& d) {return s<<"("<<d.real()<<", "<<d.imag()<< ")";}
template<typename T1, typename T2> ostream& operator<<(ostream& s,const pair<T1,T2>& d) {return s<<"("<<d.first<<", "<<d.second<<")";}
template<typename T> ostream& operator<<(ostream& s, const vector<T>& d){
int len=d.size();
rep(i,len){
s<<d[i];if(i<len-1) s<<" ";
}
return s;
}
template<typename T> ostream& operator<<(ostream& s,const vector<vector<T>>& d){
int len=d.size();
rep(i,len){
s<<d[i]<<endl;
}
return s;
}
template<typename T> ostream& operator<<(ostream& s,const set<T>& v){
s<<"{ ";
for(auto itr=v.begin();itr!=v.end();++itr) {
if (itr!=v.begin()) {s<< ", ";}
s<<(*itr);
}
s<<" }";
return s;
}
template<typename T1, typename T2> ostream& operator<<(ostream& s,const map<T1,T2>& m){
s<<"{"<<endl;
for(auto itr=m.begin();itr!=m.end();++itr){
s<<" "<<(*itr).first<<" : "<<(*itr).second<<endl;
}
s<<"}"<<endl;
return s;
}
const ll mod=1e9+7;
const ll inf=1e17;
const int INF=1e9;
const double PI=acos(-1);
const double EPS=1e-10;
typedef pair<string,string> Ps;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin>>n;
string s,a,b;
cin>>s;
a=s.substr(0,n),b=s.substr(n,n);
reverse(begin(b),end(b));
map<Ps,ll> cnt1,cnt2;
rep(i,1<<n){
string k,l;
rep(j,n){
if(i & 1<<j){
k.push_back(a[j]);
}else{
l.push_back(a[j]);
}
}
cnt1[Ps(k,l)]++;
}
rep(i,1<<n){
string k,l;
rep(j,n){
if(i & 1<<j){
k.push_back(b[j]);
}else{
l.push_back(b[j]);
}
}
cnt2[Ps(k,l)]++;
}
ll ans=0;
for(auto itr:cnt1){
ll num=cnt2[itr.fi];
ans+=num*itr.se;
}
cout<<ans<<endl;
} | 1 |
//g++ -std=gnu++14 a.cpp
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iostream>
#include <istream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <tuple>
#include <iomanip>
#include <random>
#include <math.h>
#include <stdio.h>
using namespace std;
#define ll long long
#define rep(i, n) for(ll i = 0; i < (n); i++)
ll MOD = 1e9 + 7;
int INF = 1 << 30;
ll INFL = 1LL << 60;
ll MODP = 998244353;
ll kai(ll x,ll y){
if(y == 0)return 1;
if(y == 1)return x;
if(y&1){
return (x*kai(x,y-1))%MOD;
}else{
ll t = kai(x,y/2);
return (t*t)%MOD;
}
}
ll comb(ll a,ll b,vector<ll> &p){
if(a == 0)return 1;
if(b == 0)return 1;
ll ans = p[a+b];
ans = (ans*kai(p[a],MOD-2))%MOD;
ans = (ans*kai(p[b],MOD-2))%MOD;
return ans;
}
ll mind(int x,vector<int> &v){
int ok = v.size()-1,ng = -1;
while(ok - ng > 1){
int next = (ok+ng)/2;
if(v[next] > x){
ok = next;
}else{
ng = next;
}
}
return ok;
}
ll maxd(int x,vector<int> &v){
int ok = 0,ng = v.size();
while(ng - ok > 1){
int next = (ok+ng)/2;
if(v[next] < x){
ok = next;
}else{
ng = next;
}
}
return ok;
}
int main(){
int n,x,t;
cin >> n >> x >> t;
int ans = 0;
ans += (n/x)*t;
if(n%x != 0)ans += t;
cout << ans << endl;
return 0;
}
| #include<iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cmath>
#include <set>
using namespace std;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
/*int t;
cin >> t;
while (t--){
int n;
cin >> n;
vector<int>v(n);
for (int i = 0; i < n; i++){
cin >> v[i];
}
if (n % 2){
reverse(v.begin(), v.end());
swap(v[n / 2], v[n / 2 - 1]);
}
else reverse(v.begin(), v.end());
for (int i : v)cout << i << " ";
cout << '\n';
}*/
double a, b, c;
cin >> a >> b >> c;
int count = ceil(a/b)*c;
cout << count << '\n';
//system("pause");
return 0;
}
| 1 |
#include <cstdio>
using namespace std;
#define MAXN 100
#define INFTY (1 << 21)
#define WHITE 0
#define GRAY 1
#define BLACK 2
int n, M[MAXN][MAXN];
int prim()
{
int d[MAXN], p[MAXN], color[MAXN];
int u, minv;
for(int i = 0; i < n; i++)
{
d[i] = INFTY;
p[i] = -1;
color[i] = WHITE;
//printf("===\n");
}
d[0] = 0;
while(true)
{
u = -1;
minv = INFTY;
for(int i = 0; i < n; i++)
{
if(color[i] != BLACK && d[i] < minv)
{
u = i;
minv = d[i];
//printf("%d \n", u);
}
}
if(u == -1)
{
break;
}
color[u] = BLACK;
for(int v = 0; v < n; v++)
{
if(color[v] != BLACK && M[u][v] != INFTY)
{
if(d[v] > M[u][v])
{
d[v] = M[u][v];
p[v] = u;
color[v] = GRAY;
}
}
}
}
int sum = 0;
for(int i = 0; i < n; i++)
{
if(p[i] != -1)
{
sum += M[i][p[i]];
}
}
return sum;
}
int main()
{
scanf("%d", &n);
for(int i = 0; i < n; i++)
{
for(int j = 0; j < n; j++)
{
int e;
scanf("%d", &e);
M[i][j] = (e == -1) ? INFTY : e;
}
}
printf("%d\n", prim());
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>; using vvi = vector<vi>;
using vb = vector<bool>; using vvb = vector<vb>;
using vl = vector<ll>; using vvl = vector<vl>;
using vd = vector<double>; using vvd = vector<vd>;
#define REP(i,n) for(auto i = 0 * n; i < (n); ++i)
#define ALL(c) (c).begin(), (c).end()
#define FOR(i,s,e) for (ll i = s; i < (ll)e; i++)
#define TEN(x) ((ll)1e##x)
class UnionFind {
typedef size_t U;
vector<int32_t> v;
public:
UnionFind(U n) : v(n, -1) {}
U find(U x) { return v[x] < 0 ? x : (v[x] = find((U)v[x])); }
bool same(U x, U y) { return find(x) == find(y); }
U size(U x) { return (U)-v[find(x)]; }
void unite(U x, U y) {
x = find(x); y = find(y);
if (x != y) {
if (-v[x] < -v[y]) swap(x, y);
v[x] += v[y];
v[y] = x;
}
}
};
struct Edge{ uint32_t to, id; };
typedef vector<vector<Edge>> Graph;
template<class T> struct Kruskal{
typedef uint32_t U;
template<class V> Kruskal(U n, const V & u, const V & v, const vector<T> & w) : g(n) {
vector<U> es(w.size());
iota(es.begin(), es.end(), 0);
sort(es.begin(), es.end(), [&](U i, U j) { return w[i] < w[j]; });
UnionFind uf(n);
for (U i : es) {
if (!uf.same(u[i], v[i])) {
uf.unite(u[i], v[i]); cost += w[i];
g[u[i]].push_back({ (U)v[i], i }); g[v[i]].push_back({ (U)u[i], i });
}
}
}
Graph g; T cost = 0;
};
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(50);
ll n; cin >> n;
vl u, v, w;
REP(i, n) REP(j, n) {
ll x; cin >> x;
if (x != -1) {
u.push_back(i);
v.push_back(j);
w.push_back(x);
}
}
Kruskal<ll> mst(n, u, v, w);
cout << mst.cost << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define endl "\n"
#define se second
#define ls( s) (s&(-s))
#define ll long long
#define inf 0x3f3f3f3f
#define fast ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
const int N = 2e5+5;
#define rep(i, begin, end) for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
const ll mod = 2019;
int n;
ll ans=0;
multiset<ll> ms;
int main()
{ fast
cin>>n;
vector<ll> v(n);
for(auto&x:v)cin>>x;
for(auto x: v)ms.insert(x);
while(!ms.empty())
{
ll val=*ms.rbegin();
ms.erase(ms.find(val));ll y;
for( y=1;y<=val;y*=2);
auto it=ms.find(y-val);
if(it!=ms.end())
{
ans++;
ms.erase(it);
}
}
cout<<ans;
}
| #include<iostream>
#include<map>
#include<vector>
#include<algorithm>
#include<cstdint>
#include<cstdlib>
template<typename T>
void fin(T const& t){ std::cout << t << std::endl; exit(0); }
int msb(int x) { return 31 - __builtin_clz(x); }
int main() {
int N; std::cin >> N;
std::map<int,int> m;
for(int i = 0; i < N; ++i) { int A; std::cin >> A; ++m[A]; }
std::vector<std::pair<int,int>> v(m.begin(), m.end());
int ans = 0;
for(int j = v.size()-1; j >= 0; --j) {
if(v[j].second < 1) continue;
int val = v[j].first;
int x = (1 << msb(val)+1) - val;
if(val == x) { ans += v[j].second/2; continue; }
int i = std::partition_point(v.begin(), v.end(),
[&](auto const& p) { return p.first < x;}) - v.begin();
if(i >= j) continue;
if(v[i].first != x) continue;
int n = std::min(v[j].second, v[i].second);
ans += n;
v[i].second -= n;
}
fin(ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
int L = a+b, R = c+d;
if (L>R) cout << "Left" <<endl;
if (L==R) cout << "Balanced" << endl;
if (L<R) cout << " Right" << endl;
} | #include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main()
{
int cs[5];
while( scanf( "%d,%d,%d,%d,%d", &cs[0], &cs[1], &cs[2], &cs[3], &cs[4] ) != -1 ) {
sort( cs, cs + 5 );
vector<int> uc( 5 );
unique_copy( cs, cs+5, uc.begin() );
int p[5] = {};
for( auto const& c : uc ) {
++p[count( cs, cs + 5, c )];
}
bool const is_straight = [&]{
bool const b = [&](){
for( int i=1; i<5; ++i ) {
if ( cs[i-1] + 1 != cs[i] )
return false;
}
return true;
}();
return b
|| ( cs[0] == 10 && cs[1] == 11 && cs[2] == 12 && cs[3] == 13 && cs[4] == 1 )
|| ( cs[0] == 1 && cs[1] == 10 && cs[2] == 11 && cs[3] == 12 && cs[4] == 13 );
}();
cout <<
( ( p[4] == 1 )
? "four card"
: ( p[3] == 1 && p[2] == 1 )
? "full house"
: ( is_straight )
? "straight"
: ( p[3] == 1 )
? "three card"
: ( p[2] == 2 )
? "two pair"
: ( p[2] == 1 )
? "one pair"
: "null" )
<< endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long int n, a, b;
cin >> n >> a >> b;
long long int x[n], diff[n]={};
long long int ans=0;
for(int i=0; i<n; i++){
cin >> x[i];
if(i==0) continue;
if((x[i]-x[i-1])*a<b) ans += (x[i]-x[i-1])*a;
else ans += b;
}
cout << ans << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int main () {
int N;
cin >> N;
long long A, B;
cin >> A >> B;
long long ans = 0;
long long x;
cin >> x;
for (int i = 0; i < N - 1; i ++) {
long long k = 0;
cin >> k;
ans += min((k - x) * A, B);
x = k;
}
cout << ans << endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll double
#define mod 1e9+7
#define fast_io ios_base::sync_with_stdio(false); cin.tie(NULL)
ll dp[301][301][301];
ll solve(int one, int two, int three, int& n)
{
if(one < 0 || two < 0 || three < 0) return 0;
if(one == 0 && two == 0 && three == 0) return 0;
if(dp[one][two][three] > 0) return dp[one][two][three];
int rem = one + two + three;
ll exp_val = n + one*solve(one-1, two, three, n) + two*solve(one+1, two-1, three, n) + three*solve(one, two+1, three-1, n);
return dp[one][two][three] = exp_val/rem;
}
int main()
{
int i, j, n, m, p, k, x;
cin>>n;
int one = 0, two = 0, three = 0;
for(i = 0; i < n; i++)
{
cin>>x;
if(x == 1) one++;
else if(x == 2) two++;
else three++;
}
memset(dp, -1, sizeof(dp));
cout<<fixed<<setprecision(9)<<solve(one, two, three, n);
return 0;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define int long long
#define endl '\n'
#define pb push_back
#define fi first
#define se second
#define all(c) (c).begin(),(c).end()
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef vector<int> vi;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define TRACE
#ifndef ONLINE_JUDGE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif
const ll inf = 2e18;
const int mod = 1e9 + 7;
const int N = 2e5 + 10;
double dp[305][305][305];
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
int cnt[4] = {0};
for(int i = 0; i < n; i++) {
int x;
cin >> x;
cnt[x]++;
}
for(int k = 0; k <= cnt[3]; k++) {
for(int j = 0; j <= cnt[2] + cnt[3]; j++) {
for(int i = 0; i <= n; i++) {
if(i + j + k == 0) {
dp[i][j][k] = 0;
}
else {
dp[i][j][k] = 1;
if(i >= 1) {
dp[i][j][k] += (1.0 * i / n) * dp[i - 1][j][k];
}
if(j >= 1) {
dp[i][j][k] += (1.0 * j / n) * dp[i + 1][j - 1][k];
}
if(k >= 1) {
dp[i][j][k] += (1.0 * k / n) * dp[i][j + 1][k - 1];
}
dp[i][j][k] /= (1 - (1.0 * (n - i - j - k) / n));
}
}
}
}
cout << fixed << setprecision(12) << dp[cnt[1]][cnt[2]][cnt[3]];
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <queue>
#include <string>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int q;
cin >> q;
vector<int> lk(q);
vector<ll> memo(n, 0);
for (int &k: lk) cin >> k;
for (int k : lk) {
ll ans = 0;
vector<ll> ls(3, 0);
for (int i = 0; i < n; ++i) {
if (i >= k) {
if (s[i-k] == 'D') {
--ls[0];
ls[2] -= ls[1];
}
if (s[i-k] == 'M') --ls[1];
}
if (s[i] == 'D') ++ls[0];
if (s[i] == 'M') {
++ls[1];
ls[2] += ls[0];
}
if (s[i] == 'C') {
ans += ls[2];
}
}
cout << ans << endl;
}
}
| #include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define gt getchar()
#define ll long long
#define File(s) freopen(s".in","r",stdin),freopen(s".out","w",stdout)
typedef std::pair<int,int> P;
#define mk std::make_pair
#define fr first
#define sc second
inline int in()
{
int k=0;char ch=gt;bool p=1;
while(ch<'-')ch=gt;if(ch=='-')ch=gt,p=0;
while(ch>'-')k=k*10+ch-'0',ch=gt;
return p?k:-k;
}
const int N=2e5+5;
const ll inf=1ll<<60;
ll sum[N],ans=inf;int pos[N],n,Q;
inline void cmin(ll &x,ll y){if(x>y)x=y;}
struct Segment_tree
{
#define lc k<<1
#define rc k<<1|1
ll val[N];int mi[N<<2];
inline int cmp(const int &x,const int &y){return val[x]<val[y]?x:y;}
void build(int l,int r,int k)
{
if(l==r)return val[mi[k]=l]=inf,void();
int mid=l+r>>1;
build(l, mid ,lc),build(mid+1,r,rc);
mi[k]=cmp(mi[lc],mi[rc]);
}
void upd(int l,int r,int k,int p,ll v)
{
if(l==r)return cmin(val[l],v);
int mid=l+r>>1;
if(p<=mid)upd(l,mid,lc,p,v);
else upd(mid+1,r,rc,p,v);
mi[k]=cmp(mi[lc],mi[rc]);
}
int query(int L,int R,int l,int r,int k)
{
if(L<=l&&r<=R)return mi[k];
int mid=l+r>>1;
if(L> mid)return query(L,R,mid+1,r,rc);
if(R<=mid)return query(L,R,l, mid ,lc);
return cmp(query(L,R,l,mid,lc),query(L,R,mid+1,r,rc));
}
}A,B,C;
inline int abs(int x){return x<0?-x:x;}
inline void solve(int x)
{
for(int i=2;i<=Q;++i)sum[i]=sum[i-1]+abs(pos[i]-pos[i-1]);
A.build(1,n,1),B.build(1,n,1),C.build(1,n,1);
A.upd(1,n,1,x,0-x),B.upd(1,n,1,x,0+x),C.upd(1,n,1,x,0);
for(int i=2;i<=Q;++i)
{
int le=A.query(1,pos[i],1,n,1),ri=B.query(pos[i],n,1,n,1);
int res=abs(pos[i]-pos[i-1]);
if(A.val[le]+pos[i]>B.val[ri]-pos[i])
{
C.upd(1,n,1,pos[i-1],B.val[ri]-pos[i]-res);
A.upd(1,n,1,pos[i-1],B.val[ri]-pos[i]-res-pos[i-1]);
B.upd(1,n,1,pos[i-1],B.val[ri]-pos[i]-res+pos[i-1]);
}
else
{
C.upd(1,n,1,pos[i-1],A.val[le]+pos[i]-res);
A.upd(1,n,1,pos[i-1],A.val[le]+pos[i]-res-pos[i-1]);
B.upd(1,n,1,pos[i-1],A.val[le]+pos[i]-res+pos[i-1]);
}
}
cmin(ans,C.val[C.mi[1]]+sum[Q]);
}
int main()
{
n=in(),Q=in()+1;int a=in(),b=in();
for(int i=2;i<=Q;++i)pos[i]=in();
pos[1]=a;solve(b);pos[1]=b;solve(a);
return printf("%lld\n",ans),0;
}
| 0 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
#include <fstream>
#include <bitset>
#include <time.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;
#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = (1LL << 31) - 1;
const ll MOD = 1e9 + 7;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,N) for(int i=0;i<(N);i++)
#define ALL(s) (s).begin(),(s).end()
#define EQ(a,b) (abs((a)-(b))<EPS)
#define EQV(a,b) ( EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()) )
#define fi first
#define se second
#define N_SIZE (1LL << 20)
#define NIL -1
#define MAX_N 100100 * 3
int m;
int nmin,nmax;
int p[10000];
int main() {
while (cin >> m >> nmin >> nmax&&m + nmax + nmin) {
REP(i, m) {
cin >> p[i];
}
int ans;
int num = -1;
for (int i = nmin; i <= nmax; i++) {
if (num <= p[i - 1] - p[i]) {
num = p[i - 1] - p[i];
ans = i;
}
}
cout << ans << endl;
}
} | #include <stdio.h>
int check(int a,int b,int c)
{
//printf("[%d][%d][%d]\n",a,b,c);
if(a != 14)return 0;
else if(b == 23)return 1;
else if(b == 1 && c == 10)return 1;
else if(b == 19 && c == 19)return 1;
else return 0;
}
int main()
{
int longth,mem = 0;
while(1)
{
char str[90] = {0};
int mem1[90] = {0},mem2[90] = {0};
if(scanf("%c",&str[0]) == -1)return 0;
if(str[0] >= 'a' && 'z' >= str[0])mem1[0] = str[0] - 'a' + 1;
for(int i = 1; i < 80; i++)
{
scanf("%c",&str[i]);
if(str[i] == '\n')break;
longth = i;
if(str[i] >= 'a' && 'z' >= str[i])mem1[i] = str[i] - 'a' + 1;
}
for(int i = 0; i < longth; i++)
{
if(mem1[i] == 0);
else if(mem1[i + 1] != 0)
{
if(mem1[i] <= mem1[i + 1])mem2[i] = mem1[i + 1] - mem1[i];
else mem2[i] = 26 - mem1[i] + mem1[i + 1];
}
}
/*for(int i = 0; i < longth; i++)
{
printf("[%d]",mem2[i]);
}
printf("\n");*/
for(int i = 0; i < longth; i++)
{
if(mem2[i] != 0)/*printf("[%d]\n",i);*/if(check(mem2[i],mem2[i + 1],mem2[i + 2]))if(mem1[i] <= 20)mem = 20 - mem1[i];else mem = 26 - mem1[i] + 20;
//else printf("no\n");
}
//printf("{{%d}}\n",mem);
for(int i = 0; i < longth + 1; i++)
{
if(str[i] >= 'a' && 'z' >= str[i])printf("%c",(str[i] - 'a' + mem) % 26 + 'a');
else printf("%c",str[i]);
}
printf("\n");
}
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(){
int n;
while(cin>>n,n){
unsigned long long a[5000]={0},c=0,p,o,u;
rep(i,n){
cin>>p>>o>>u;
a[p]+=o*u;
if(a[p]>=1000000){cout<<p<<endl;c++;}
}
if(!c)cout<<"NA"<<endl;
}
} | #include<iostream>
#include<string>
using namespace std;
int main()
{
int n;
int ans[4000];
for(;;)
{
cin >> n;
if(n==0)
break;
int i,j;
for(i=0,j=0;i<n;i++)
{
int num[4000];
int flag=1;
double a[4000],b[4000];
double ans_max[4000];
cin >> num[i] >> a[i] >> b[i] ;
ans_max[i]=a[i]/10000.0*b[i];
for(int l=i-1;l>=0;l--)
{
if(num[l]==num[i])
{
// cout << "in" << endl;
ans_max[i]+=ans_max[l];
break;
}
}
// cout << "ans_max[" << i << "]:" << ans_max[i] << " num:" << num[i] << endl;
if(ans_max[i]>=100.0)
{
for(int k=0;k<j;k++)
{
if(ans[k]==num[i])
flag=0;
}
if(flag==1)
{
ans[j]=num[i];
j++;
}
}
}
if(j!=0)
{
for(int i=0;i<j;i++)
{
cout << ans[i] << endl;
}
}
else
cout << "NA" << endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pint = pair<int, int>;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const int INF=1e9+7;
const ll LINF=9223372036854775807;
const ll MOD=1e9+7;
const ld PI=acos(-1);
const ld EPS = 1e-10; //微調整用（EPSより小さいと0と判定など）
int ii() { int x; if (scanf("%d", &x)==1) return x; else return 0; }
long long il() { long long x; if (scanf("%lld", &x)==1) return x; else return 0; }
string is() { string x; cin >> x; return x; }
char ic() { char x; cin >> x; return x; }
void oi(int x) { printf("%d ", x); }
void ol(long long x) { printf("%lld ", x); }
void od_nosp(double x) { printf("%.15f", x); } // 古い問題用
void od(double x) { printf("%.15f ", x); }
// long doubleで受け取り、fをLfなどに変えて出力すると、変な数値が出る
// それをなんとかするには独自の出力を作らなければならなそう
void os(const string &s) { printf("%s ", s.c_str()); }
void oc(const char &c) { printf("%c ", c); }
#define o_map(v){cerr << #v << endl; for(const auto& xxx: v){cout << xxx.first << " " << xxx.second << "\n";}} //動作未確認
void br() { putchar('\n'); }
// #define gcd __gcd //llは受け取らない C++17~のgcdと違うので注意
// int lcm(int a, int b){return a / gcd(a, b) * b;}
#define begin_end(a) a.begin(),a.end() //sort(begin_end(vec));
#define REP(i,m,n) for(ll i=(ll)(m) ; i < (ll) (n) ; i++ )
#define rep(i,n) REP(i,0,n)
#define m_p(a,b) make_pair(a,b)
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define p_b push_back
#define SZ(x) ((int)(x).size) //size()がunsignedなのでエラー避けに
// coutによるpairの出力（空白区切り）
template<typename T1, typename T2> ostream& operator<<(ostream& s, const pair<T1, T2>& p) {return s << "(" << p.first << " " << p.second << ")";}
// coutによるvectorの出力（空白区切り）
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v) {
int len = v.size();
for (int i = 0; i < len; ++i) {
s << v[i]; if (i < len - 1) s << " "; //"\t"に変えるとTabで見やすく区切る
}
return s;
}
// coutによる多次元vectorの出力（空白区切り）
template<typename T> ostream& operator<<(ostream& s, const vector< vector<T> >& vv) {
int len = vv.size();
for (int i = 0; i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
//最大値、最小値の更新。更新したor等しければtrueを返す
template<typename T>
bool chmax(T& a, T b){return (a = max(a, b)) == b;}
template<typename T>
bool chmin(T& a, T b){return (a = min(a, b)) == b;}
//4近傍（上下左右） rep(i, 2) にすると右・下だけに進む
vector<int> dx_4 = {1, 0, -1, 0};
vector<int> dy_4 = {0, 1, 0, -1};
// -------- template end - //
// - library ------------- //
// --------- library end - //
int main(){
ll N = il();
vector<vector<ll> > abs;
rep(i,N){
ll a = il();
ll b = il();
abs.p_b(vector<ll>{a+b, a, b});
}
sort(abs.begin(), abs.end());
reverse(begin_end(abs));
ll ans;
rep(i, N){
if (i % 2 == 0) ans += abs[i][1];
else ans -= abs[i][2];
}
cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#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 < (int64_t)(n); i++)
#define irep(i, n) for (int64_t i = 0; i <= (int64_t)(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() {
string s;
cin >> s;
vector<bool> contains(26, false);
for (char c : s) {
contains[c - 'a'] = true;
}
if (s.size() < 26) {
rep(i, 26) {
if (!contains[i]) {
cout << s << (char)(i + 'a') << endl;
return 0;
}
}
} else {
set<char> t;
rrep(i, s.size()) {
char c = s[i];
auto p = t.upper_bound(c);
if (p != t.end()) {
cout << s.substr(0, i) << *p << endl;
return 0;
}
t.insert(c);
}
}
cout << -1 << endl;
return 0;
} | 0 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <deque>
#include <queue>
#include <array>
#include <set>
#include <map>
#include <cmath>
#include <algorithm>
#include <numeric>
#include <cassert>
#include <utility>
#include <functional>
#include <bitset>
using namespace std;
using lli = long long int;
template<class T, class U> void init_n(vector<T>& v, size_t n, U x)
{ v = vector<T>(n, x); }
template<class T> void init_n(vector<T>& v, size_t n) { init_n(v, n, T()); }
template<class T> void read_n(vector<T>& v, size_t n, size_t o = 0)
{ v = vector<T>(n+o); for (lli i=o; i<n+o; ++i) cin >> v[i]; }
template<class T> void read_n(T a[], size_t n, size_t o = 0)
{ for (lli i=o; i<n+o; ++i) cin >> a[i]; }
template<class T> T gabs(const T& x) { return max(x, -x); }
#define abs gabs
struct UnionFind {
vector<int> c, s;
UnionFind(size_t n) : c(n), s(n, 1) { iota(begin(c), end(c), 0); }
int root(int i) { return c[i] == i ? i : (c[i] = root(c[i])); }
bool same(int i, int j) { return root(i) == root(j); }
void unite(int i, int j) {
i = root(i); j = root(j);
if (i != j) {
if (s[i] > s[j]) { c[j] = i; s[i] += s[j]; }
else { c[i] = j; s[j] += s[i]; }
}
}
int size(int i) { return s[root(i)]; }
};
lli n, k, l;
int main() {
cin >> n >> k >> l;
UnionFind ufp(n+1), ufr(n+1), ufm(n+1);
for (lli i=0; i<k; ++i) {
lli u, v; cin >> u >> v;
ufp.unite(u, v);
}
for (lli i=0; i<l; ++i) {
lli u, v; cin >> u >> v;
ufr.unite(u, v);
}
map<pair<lli, lli>, lli> m;
for (lli i=1; i<=n; ++i) {
m[make_pair(ufp.root(i), ufr.root(i))]++;
}
for (lli i=1; i<=n; ++i) {
cout << m[make_pair(ufp.root(i), ufr.root(i))] << '\n';
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define FOR(i,s,e) for(int i=(s);(i)<(int)(e);++(i))
#define REP(i,e) FOR(i,0,e)
#define each(it,c) for(__typeof((c).begin()) it=(c).begin();it!=(c).end();++it)
#define all(o) (o).begin(), (o).end()
#define psb(x) push_back(x)
#define ppb(x) pop_back(x)
#define mp make_pair
#define mt make_tuple
#define t0(t) get<0>((t))
#define t1(t) get<1>((t))
#define t2(t) get<2>((t))
typedef long long ll;
int main() {
int h, w;
fscanf(stdin, "%d%d ", &h, &w);
multiset<int> hd; // horizontal distance between from start to current position
map<int, int> hdmap; // (current column, start column) to obtain the answer in log(n)
REP(i,w) {
hdmap[i] = i;
hd.insert(0);
}
REP(i,h) {
int l, r;
fscanf(stdin, "%d%d ", &l, &r);
--l; // semiopen interval [l-1, r) based on 0-index
auto it = hdmap.lower_bound(l);
int re = -1;
while (it != hdmap.end() && it->first <= r) {
re = max(re, it->second);
hd.erase(hd.find(it->first - it->second));
hdmap.erase(it++);
}
// the only optimal start point in [l-1, r) remains
if (re != -1 && r < w) {
hd.insert(r-re);
hdmap[r] = re;
}
int res = -1;
if (hd.size()) res = *hd.begin() + (i+1);
fprintf(stdout, "%d\n", res);
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
int sum(int a, int b) {
return a + b >= MOD ? a + b - MOD : a + b;
}
int sub(int a, int b) {
return a - b < 0 ? a - b + MOD : a - b;
}
int mul(int a, int b) {
return (1LL*a*b)%MOD;
}
int pw(int a, int b) {
if (!b) return 1;
int r = pw(a, b/2);
r = mul(r, r);
if (b%2) r = mul(r, a);
return r;
}
const int MAXX = 4007;
int fact[MAXX], ifact[MAXX];
int nCr(int n, int r) {
if (r < 0 || n < r) return 0;
return mul(fact[n], mul(ifact[r], ifact[n-r]));
}
int split(int elements, int buckets) {
return nCr(elements+buckets-1, buckets-1);
}
int p2[MAXX];
int ans[MAXX];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
fact[0] = 1;
for (int i = 1; i < MAXX; i++) fact[i] = mul(i, fact[i-1]);
ifact[MAXX-1] = pw(fact[MAXX-1], MOD-2);
for (int i = MAXX-2; i >= 0; i--) ifact[i] = mul(i+1, ifact[i+1]);
p2[0] = 1;
for (int i = 1; i < MAXX; i++) p2[i] = mul(p2[i-1], 2);
int k, n;
cin >> k >> n;
for (int i = 3; i <= k+1; i += 2) {
int have = i/2;
for (int bam = 0; bam <= have && bam <= n; bam++) {
int tmp = mul(nCr(have, bam), p2[bam]);
tmp = mul(tmp, split(n-bam, k-have*2+bam));
ans[i] = sum(ans[i], tmp);
// cout << "bam: " << bam << " -> " << tmp << endl;
}
// cout << "ans[" << i << "] = " << ans[i] << endl;
}
for (int i = 2; i <= k+1; i += 2) {
int have = i/2 - 1;
for (int bam = 0; bam <= have && bam <= n; bam++) {
int tmp = mul(nCr(have, bam), p2[bam]);
int z = split(n-bam, k-have*2+bam-1);
if (bam < n) {
z = sum(z, split(n-bam-1, k-have*2+bam-1));
}
ans[i] = sum(ans[i], mul(tmp, z));
}
// cout << "ans[" << i << "] = " << ans[i] << endl;
}
// for (int i = 2; i <= k+k; i++) cout << ans[i] << "\n";
for (int i = 2; i <= k+1; i++) cout << ans[i] << "\n";
for (int i = k; i >= 2; i--) cout << ans[i] << "\n";
return 0;
}
| #include<iostream>
#include<vector>
#include<string>
#include<set>
#define rep(i, start, end) for (int i = (int)start; i < (int)end; ++i)
#define rrep(i, start, end) for (int i = (int)start - 1; i >= (int)end; --i)
#define all(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
template<typename T> inline bool chmax(T& a, T b) {if (a < b) {a = b; return true;} return 0;}
template<typename T> inline bool chmin(T& a, T b) {if (a > b) {a = b; return true;} return 0;}
using P = pair<int, int>;
const int INF = 1 << 30;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int H, W;
cin >> H >> W;
vector<int> A(H), B(H);
rep(i, 0, H) {
cin >> A[i] >> B[i];
--A[i];
}
set<P> path;
multiset<int> dist;
rep(i, 0, W) {
path.emplace(i, i);
dist.insert(0);
}
rep(i, 0, H) {
vector<P> buf;
for (auto itr = path.lower_bound(P(A[i], 0)); itr != path.end() && (*itr).first < B[i]; ++itr) {
buf.push_back(*itr);
}
int max_start = -INF;
P max_path;
for (auto& p : buf) {
path.erase(p);
dist.erase(dist.find(p.first - p.second));
if (chmax(max_start, p.second)) {
max_path = p;
}
}
if (max_start > -INF) {
path.emplace(B[i], max_path.second);
dist.insert(B[i] == W ? INF : B[i] - max_path.second);
}
cout << (*dist.begin() == INF ? -1 : *dist.begin() + i + 1) << endl;
}
return 0;
} | 0 |
#include <set>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
typedef long long ll ;
#define rep(i, a, b) for (int i = a; i <= b; ++ i)
const int N = 1e5 + 5 ;
using namespace std ;
int cnt, n, a[4][N], d[5], b[N], bit[N], c[N], ind[N], outd[N] ; bool vis[N] ;
struct poi {
int l, r ;
} p[N] ;
set <int> S ;
void put(int x) { for ( ; x <= n ; x += x & (- x)) ++ bit[x] ; }
int get(int x) { int res = 0 ; for ( ; x ; x -= x & (- x)) res += bit[x] ; return res ; }
bool cmp(poi a, poi b) {
return a.r < b.r ;
}
int main() {
scanf("%d", &n) ;
rep(i, 1, 3) rep(j, 1, n) scanf("%d", &a[i][j]) ;
rep(j, 1, n) {
rep(i, 1, 3) d[i] = a[i][j] ;
sort(d + 1, d + 4) ;
if (d[1] % 3 != 1 || d[2] != d[1] + 1 || d[3] != d[2] + 1 || d[2] != a[2][j] || vis[d[1] / 3]) {
printf("No\n") ;
return 0 ;
}
vis[d[1] / 3] = true ;
b[d[1] / 3 + 1] = j, c[j] = d[1] / 3 + 1 ;
if ((c[j] - j) % 2) {
printf("No\n") ;
return 0 ;
}
}
/* rep(i, 1, n) bit[i] = 0 ;
for (int i = n; i; -- i) {
if (i & 1) {
put(c[i]) ;
continue ;
}
if (((get(i) + abs(b[i] - i) / 2) & 1) ^ (a[1][b[i]] > a[3][b[i]])) {
printf("No\n") ;
return 0 ;
}
}
rep(i, 1, n) bit[i] = 0 ;
for (int i = n; i; -- i) {
cout << i << endl ;
if (i & 1) {
if (((get(i) + abs(b[i] - i) / 2) & 1) ^ (a[1][b[i]] > a[3][b[i]])) {
printf("No\n") ;
return 0 ;
}
} else put(c[i]) ;
}
*/
rep(i, 1, n) {
if (c[i] < i) ++ outd[i - 1], -- outd[c[i] - 1] ; else
++ ind[i + 1], -- ind[c[i] + 1] ;
}
rep(i, 1, n) ind[i] += ind[i - 2] ;
for (int i = n; i; -- i) outd[i] += outd[i + 2] ;
rep(i, 1, n) if (ind[i] != outd[i]) {
printf("No\n") ;
return 0 ;
}
cnt = 0 ;
rep(i, 1, n) if (i & 1) {
/* if (ind[i] & 1) ++ cnt ;
// if (ind[i] & 1) S.insert(i) ;
if (((abs(c[i] - i) / 2) & 1) ^ (a[3][i] < a[1][i])) ; else continue ;
++ cnt ; */
cnt += a[3][i] < a[1][i] ;
// p[cnt].l = min(c[i], i), p[cnt].r = max(c[i], i) ;
} else {
cnt += get(n - c[i] + 1) & 1 ;
put(n - c[i] + 1) ;
}
if (cnt & 1) {
printf("No\n") ;
return 0 ;
}
rep(i, 1, n) bit[i] = 0 ;
// sort(p + 1, p + cnt + 1, cmp) ;
// rep(i, 1, n) cout << c[i] << " " ; cout << endl ;
/* rep(i, 1, cnt) {
std :: set <int> :: iterator it = S.lower_bound(p[i].l) ;
if (it == S.end() || (*it) > p[i].r) {
S.insert(p[i].r) ;
} else {
S.erase(it) ;
}
}
if (!S.empty()) {
printf("No\n") ;
return 0 ;
}*/
/* if (cnt & 1) {
printf("No\n") ;
return 0 ;
}
cnt = 0 ;
*/
cnt = 0 ;
rep(i, 1, n) if (i & 1) cnt += get(n - c[i] + 1) & 1, put(n - c[i] + 1) ; else {
/* if (ind[i] & 1) ++ cnt ;
// if (ind[i] & 1) S.insert(i) ;
if (((abs(c[i] - i) / 2) & 1) ^ (a[3][i] < a[1][i])) ; else continue ;
++ cnt ;
*/// p[cnt].l = min(c[i], i), p[cnt].r = max(c[i], i) ;
cnt += a[3][i] < a[1][i] ;
}
if (cnt & 1) {
printf("No\n") ;
return 0 ;
}
// sort(p + 1, p + cnt + 1, cmp) ;
// rep(i, 1, cnt) cout << p[i].l << " " << p[i].r << endl ;
// rep(i, 1, n) if (i & 1) ; else printf("%d ", ind[i]) ; cout << endl ;
/* rep(i, 1, cnt) {
std :: set <int> :: iterator it = S.lower_bound(p[i].l) ;
if (it == S.end() || (*it) > p[i].r) {
S.insert(p[i].r) ;
} else {
S.erase(it) ;
}
}
if (!S.empty()) {
printf("No\n") ;
return 0 ;
}
*/
printf("Yes\n") ;
return 0 ;
} | #include<bits/stdc++.h>
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef double lf;
typedef long double llf;
typedef std::pair<int,int> pii;
#define xx first
#define yy second
template<typename T> inline T max(T a,T b){return a>b?a:b;}
template<typename T> inline T min(T a,T b){return a<b?a:b;}
template<typename T> inline T abs(T a){return a>0?a:-a;}
template<typename T> inline bool repr(T &a,T b){return a<b?a=b,1:0;}
template<typename T> inline bool repl(T &a,T b){return a>b?a=b,1:0;}
template<typename T> inline T gcd(T a,T b){T t;if(a<b){while(a){t=a;a=b%a;b=t;}return b;}else{while(b){t=b;b=a%b;a=t;}return a;}}
template<typename T> inline T sqr(T x){return x*x;}
#define mp(a,b) std::make_pair(a,b)
#define pb push_back
#define I inline
#define mset(a,b) memset(a,b,sizeof(a))
#define mcpy(a,b) memcpy(a,b,sizeof(a))
#define fo0(i,n) for(int i=0,i##end=n;i<i##end;i++)
#define fo1(i,n) for(int i=1,i##end=n;i<=i##end;i++)
#define fo(i,a,b) for(int i=a,i##end=b;i<=i##end;i++)
#define fd0(i,n) for(int i=(n)-1;~i;i--)
#define fd1(i,n) for(int i=n;i;i--)
#define fd(i,a,b) for(int i=a,i##end=b;i>=i##end;i--)
#define foe(i,x)for(__typeof((x).end())i=(x).begin();i!=(x).end();++i)
struct Cg{I char operator()(){return getchar();}};
struct Cp{I void operator()(char x){putchar(x);}};
#define OP operator
#define RT return *this;
#define RX x=0;char t=P();while((t<'0'||t>'9')&&t!='-')t=P();bool f=0;\
if(t=='-')t=P(),f=1;x=t-'0';for(t=P();t>='0'&&t<='9';t=P())x=x*10+t-'0'
#define RL if(t=='.'){lf u=0.1;for(t=P();t>='0'&&t<='9';t=P(),u*=0.1)x+=u*(t-'0');}if(f)x=-x
#define RU x=0;char t=P();while(t<'0'||t>'9')t=P();x=t-'0';for(t=P();t>='0'&&t<='9';t=P())x=x*10+t-'0'
#define TR *this,x;return x;
I bool IS(char x){return x==10||x==13||x==' ';}template<typename T>struct Fr{T P;I Fr&OP,(int&x)
{RX;if(f)x=-x;RT}I OP int(){int x;TR}I Fr&OP,(ll &x){RX;if(f)x=-x;RT}I OP ll(){ll x;TR}I Fr&OP,(char&x)
{for(x=P();IS(x);x=P());RT}I OP char(){char x;TR}I Fr&OP,(char*x){char t=P();for(;IS(t);t=P());if(~t){for(;!IS
(t)&&~t;t=P())*x++=t;}*x++=0;RT}I Fr&OP,(lf&x){RX;RL;RT}I OP lf(){lf x;TR}I Fr&OP,(llf&x){RX;RL;RT}I OP llf()
{llf x;TR}I Fr&OP,(uint&x){RU;RT}I OP uint(){uint x;TR}I Fr&OP,(ull&x){RU;RT}I OP ull(){ull x;TR}};Fr<Cg>in;
#define WI(S) if(x){if(x<0)P('-'),x=-x;char s[S],c=0;while(x)s[c++]=x%10+'0',x/=10;while(c--)P(s[c]);}else P('0')
#define WL if(y){lf t=0.5;for(int i=y;i--;)t*=0.1;if(x>=0)x+=t;else x-=t,P('-');*this,(ll)(abs(x));P('.');if(x<0)\
x=-x;while(y--){x*=10;x-=floor(x*0.1)*10;P(((int)x)%10+'0');}}else if(x>=0)*this,(ll)(x+0.5);else *this,(ll)(x-0.5);
#define WU(S) if(x){char s[S],c=0;while(x)s[c++]=x%10+'0',x/=10;while(c--)P(s[c]);}else P('0')
template<typename T>struct Fw{T P;I Fw&OP,(int x){WI(10);RT}I Fw&OP()(int x){WI(10);RT}I Fw&OP,(uint x){WU(10);RT}
I Fw&OP()(uint x){WU(10);RT}I Fw&OP,(ll x){WI(19);RT}I Fw&OP()(ll x){WI(19);RT}I Fw&OP,(ull x){WU(20);RT}I Fw&OP()
(ull x){WU(20);RT}I Fw&OP,(char x){P(x);RT}I Fw&OP()(char x){P(x);RT}I Fw&OP,(const char*x){while(*x)P(*x++);RT}
I Fw&OP()(const char*x){while(*x)P(*x++);RT}I Fw&OP()(lf x,int y){WL;RT}I Fw&OP()(llf x,int y){WL;RT}};Fw<Cp>out;
const int N=100007;
int n,t[N][3],s[N];
int main()
{
in,n;
fo0(l,3)fo1(i,n)in,t[i][l];
fo1(i,n)
{
int p=(t[i][0]-1)/3;
//out,p,'\n';
bool f1=1,f2=1;
fo0(j,3)f1&=t[i][j]==p*3+j+1;
fo0(j,3)f2&=t[i][j]==p*3+3-j;
if((!f1&&!f2)||(~(i^p)&1))return puts("No"),0;
s[i]=f1?p+1:-p-1;
}
//fo1(i,n)out,s[i],' ';out,'\n';
int a[2]={0,0},b[2]={0,0};
fo1(i,n)a[i&1]^=s[i]<0;
fo1(i,n)while(abs(s[i])!=i)std::swap(s[i],s[abs(s[i])]),b[i&1]^=1;
out,a[0]==b[1]&&a[1]==b[0]?"Yes":"No",'\n';
} | 1 |
#include <bits/stdc++.h>
using namespace std;
//#define cerr if (false) cerr
#define db(x) cerr << #x << "=" << x << endl
#define db2(x, y) cerr << #x << "=" << x << "," << #y << "=" << y << endl
#define db3(x, y, z) cerr << #x << "=" << x << "," << #y << "=" << y << "," << #z << "=" << z << endl
#define dbv(v) cerr << #v << "="; for (auto _x : v) cerr << _x << ", "; cerr << endl
#define dba(a, n) cerr << #a << "="; for (int _i = 0; _i < (n); ++_i) cerr << a[_i] << ", "; cerr << endl
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& x) {
return os << "(" << x.first << "," << x.second << ")";
}
typedef long long ll;
typedef long double ld;
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> a(m), b;
vector<int> odds;
for (int i = 0; i < m; ++i) {
scanf("%d", &a[i]);
if (a[i] & 1) odds.push_back(i);
}
if (odds.size() > 2) printf("Impossible\n");
else {
sort(odds.begin(), odds.end());
if (odds.size() == 1) {
swap(a[odds[0]], a[0]);
b = a;
--b[0];
b.push_back(1);
} else if (odds.size() == 2) {
swap(a[odds[0]], a[0]);
swap(a[odds[1]], a[m - 1]);
b = a;
--b[0];
++b[m - 1];
} else {
b = a;
--b[0];
b.push_back(1);
}
for (int x : a) printf("%d ", x);
printf("\n");
if (b[0] == 0) b.erase(b.begin());
printf("%d\n", b.size());
for (int x : b) printf("%d ", x);
printf("\n");
}
}
| #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define sz(a) (long long)((a).size())
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
ll mod = 1e9+7;
ll n,i,j,m;
cin>>n>>m;
vector<ll> x(n), y(m);
for(i=0;i<n;i++) cin>>x[i];
for(i=0;i<m;i++) cin>>y[i];
ll xs = 0, ys = 0;
for(i=0;i<n;i++)
{
xs = (xs + (i*x[i] - (n-i-1)*x[i]))%mod;
}
for(i=0;i<m;i++)
{
ys = (ys + (i*y[i] - (m-i-1)*y[i]))%mod;
}
ll ans = (xs*ys)%mod;
cout<<ans;
}
| 0 |
#include<iostream>
#include<algorithm>
#define MAX 100
#define INFTY (1 << 21)
using namespace std;
int p[MAX + 1], mat[MAX + 1][MAX + 1];
void matrixChainMultiplication(int n) {
for (int i = 1; i <= n; i++) {
mat[i][i] = 0;
}
for (int l = 2; l <= n; l++) {
for (int i = 1; i <= n - l + 1; i++) {
int j = i + l - 1;
mat[i][j] = INFTY;
for (int k = i; k <= j - 1; k++) {
mat[i][j] = min(mat[i][j], (mat[i][k] + mat[k + 1][j] + (p[i - 1] * p[k] * p[j])));
}
}
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i - 1] >> p[i];
}
matrixChainMultiplication(n);
cout << mat[1][n] << endl;
return 0;
} | #include <stdio.h>
const int N=110;
const int INF=1<<30;
int min(int a,int b){
return a>b?b:a;
}
int main(){
int n,dp[N][N],a[N];
scanf("%d%d%d",&n,&a[0],&a[1]);
for(int i=1;i<n;i++)scanf("%d%d",&a[i],&a[i+1]);
for(int k=1;k<n;k++){
for(int i=0;i<n-k;i++){
dp[i][i+k]=INF;
for(int j=i;j<i+k;j++)dp[i][i+k]=min(dp[i][i+k],dp[i][j]+dp[j+1][i+k]+a[i]*a[j+1]*a[i+k+1]);
}
}
printf("%d\n",dp[0][n-1]);
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
int main(){
int N;string A,B,C;cin>>N>>A>>B>>C;
int ans=0;int a=0;
rep(i,N){
if(A.at(i)==B.at(i)){
a++;
}
if(B.at(i)==C.at(i)){
a++;
}
if(C.at(i)==A.at(i)){
a++;
}
if(a==0){
ans++;
ans++;
}else if(a==1){
ans++;
}else if(a==3){
}
a=0;
}
cout<<ans<<endl;
} | #include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define space putchar(' ')
#define enter putchar('\n')
#define MAXN 200005
#define eps 1e-10
//#define ivorysi
using namespace std;
typedef long long int64;
typedef double db;
template<class T>
void read(T &res) {
res = 0;T f = 1;char c = getchar();
while(c < '0' || c > '9') {
if(c == '-') f = -1;
c = getchar();
}
while(c >= '0' && c <= '9') {
res = res * 10 + c - '0';
c = getchar();
}
res *= f;
}
template<class T>
void out(T x) {
if(x < 0) {x = -x;putchar('-');}
if(x >= 10) {
out(x / 10);
}
putchar('0' + x % 10);
}
int N;int64 D;
int64 A[MAXN];
struct seg_tr {
struct node {
int L,R;
int64 cov;
pair<int64,int> val[2];
}tr[MAXN * 4];
void update(int u) {
tr[u].val[1] = mp(1e16,0);
if(tr[u].L != tr[u].R) {
tr[u].val[0] = min(tr[u << 1].val[0],tr[u << 1 | 1].val[0]);
tr[u].val[1] = min(tr[u << 1].val[1],tr[u << 1 | 1].val[1]);
}
tr[u].val[1] = min(tr[u].val[1],mp(tr[u].cov + tr[u].val[0].fi,tr[u].val[0].se));
}
void build(int u,int l,int r,int on) {
tr[u].L = l;tr[u].R = r;tr[u].cov = 1e16;
if(l == r) {
tr[u].val[0] = mp(A[l] + on * l * D,l);
update(u);
return;
}
int mid = (l + r) >> 1;
build(u << 1,l,mid,on);build(u << 1 | 1,mid + 1,r,on);
update(u);
}
void Change(int u,int l,int r,int64 v) {
if(l > r) return;
if(tr[u].L == l && tr[u].R == r) {
tr[u].cov = min(tr[u].cov,v);
update(u);
return;
}
int mid = (tr[u].L + tr[u].R) >> 1;
if(r <= mid) Change(u << 1,l,r,v);
else if(l > mid) Change(u << 1 | 1,l,r,v);
else {Change(u << 1,l,mid,v);Change(u << 1 | 1,mid + 1,r,v);}
update(u);
}
void Change_pos(int u,int p) {
if(tr[u].L == tr[u].R) {
tr[u].val[0] = mp(1e16,tr[u].L);
update(u);return;
}
int mid = (tr[u].L + tr[u].R) >> 1;
if(p <= mid) Change_pos(u << 1,p);
else Change_pos(u << 1 | 1,p);
update(u);
}
}s[2];
void Solve() {
read(N);read(D);
for(int i = 1 ; i <= N ; ++i) read(A[i]);
s[0].build(1,1,N,1);
s[1].build(1,1,N,-1);
s[0].Change_pos(1,1);s[1].Change_pos(1,1);
s[0].Change(1,2,N,A[1] - D);
int cnt = N - 1;
int64 ans = 0;
while(cnt--) {
pair<int64,int> t[2];
t[0] = s[0].tr[1].val[1],t[1] = s[1].tr[1].val[1];
if(t[0] > t[1]) swap(t[0],t[1]);
ans += t[0].fi;
int u = t[0].se;
s[0].Change_pos(1,u);s[1].Change_pos(1,u);
s[1].Change(1,1,u - 1,1LL * u * D + A[u]);
s[0].Change(1,u + 1,N,-1LL * u * D + A[u]);
}
out(ans);enter;
}
int main() {
#ifdef ivorysi
freopen("f1.in","r",stdin);
#endif
Solve();
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define rrep2(ri,x,n) for(int ri = (int)(n-1); ri >= (int)(x); ri--)
#define repit(itr,x) for(auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr,x) for(auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
const int INF = 1001001001;
int main(){
string s;
cin >> s;
reverse(ALL(s));
s.push_back('0');
vector<vector<int>> dp(s.size()+1, vector<int>(2, INF));
dp.at(0).at(0) = 0;
rep(i, s.size())rep(j, 2){
int now = s.at(i) - '0';
now += j;
rep(a, 10){
int ni = i+1, nj = 0;
int b = a - now;
if(b < 0){
nj++;
b += 10;
}
dp.at(ni).at(nj) = min(dp.at(ni).at(nj), dp.at(i).at(j)+a+b);
}
}
cout << dp.at(s.size()).at(0) << endl;
return 0;
} | /*~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=
*$* WRITER:kakitamasziru/OxOmisosiru *$*
~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=~=*/
#ifdef LOCAL_JUDGE
#define _GLIBCXX_DEBUG //FOR THE DEBUG! COMMENT OUT THIS WHEN SUBMITTING!
#endif
/* I REALLY HOPE MY WISH REACH YOU , ATCODER'S ONLINE JUDGE */
#define WOULD
#define YOU
#define PLEASE
#define ACCEPT
#define MY
#define SUBMISSION
/* I REALLY HOPE MY WISH REACH YOU , ATCODER'S ONLINE JUDGE */
#include <iostream> // cout, endl, cin
#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 <iomanip>
#include <limits>//setprecision
//#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <math.h>//pow,,,
#include <cmath>//abs,,,
#include <bitset> // bitset
//It is so troublesome that I include bits/stdc++.h !
using namespace std;
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 long long INF = 100100100100;
const long long MOD = 1000000007;
typedef pair<int,int> P;
//NのM乗を求める(繰り返し二乗法)
long long mod_pow(long long N, long long M) {
if (M == 0) return 1;
long long res = mod_pow((N * N) % MOD, M / 2);
//最下位ビット(*N)が1の時は単独でNをかける
if (M & 1) res = (res * N) % MOD;
return res %= MOD;
}
long long nCr(long long n, long long r) {
long long A = 1, B = 1;
//Aが分子Bが1/r!
for (long long i = n - r + 1; i <= n; i++) {
A = A * i % MOD;
}
for (long long i = 1; i <= r; i++) {
B = B * i % MOD;
}
B = mod_pow(B, MOD - 2);
B %= MOD;
//Bは割るのではなく掛ける
return (A * B) % MOD;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
else return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
return a * b / gcd(a, b);
}
//long long A,B;
bool ok(long long key,long long index){
if(index > key) return true;
else if(index <= key) return false;
}
long long binary_search(long long key,long long size){
//left,right,midはいずれもindex
long long left = -1,right = size;
while(right - left > 1){
long long mid = left + (right-left)/2;
long long hantei = ok(key,mid);
if(hantei) right = mid;
else left = mid;
}
if(left == -1)return 0;
return left;
}
vector<vector<char>> ban(55,vector<char>(55));
vector<vector<int>> ans(55,vector<int>(55));
int main() {
int N;cin >> N;
vector<double> retu(N);
double avg = 0;
for(int i = 0;i<N;i++){
cin >> retu.at(i);
avg += retu.at(i);
}
avg /= N;
int ans = 0;
double sa = 114514.0;
for(int i = 0;i<N;i++){
if(sa > abs(avg-retu.at(i))){
sa = abs(avg-retu.at(i));
ans = i;
}
}
cout << ans << endl;
}
| 0 |
#include<iostream>
#include<string>
#include<vector>
#include<cstdio>
#include<sstream>
#include<algorithm>
#include<cmath>
#include<map>
using namespace std;
int main(){
int n, dp[50];
while(cin>>n,n!=0){
fill(dp,dp+50,0);
dp[0]=0,dp[1]=1,dp[2]=1,dp[3]=2;
for(int i=3;i<=n+1;i++)dp[i]=dp[i-1]+dp[i-2]+dp[i-3];
int ans=dp[n+1];
ans/=3650;
if(dp[n]%3650!=0)ans++;
cout<<ans<<endl;
}
return 0;
} | #include <iostream>
#include <algorithm>
using namespace std;
int main(){
int tmp;
int dp[100];
cin>> tmp;
do{
fill(dp,dp+100,0);
dp[0] = 1;
for (int i = 0; i<tmp;i++)
{
for(int j = 1;j < 4;j++)
dp[i+j] += dp[i];
}
cout << dp[tmp]/3650 + 1<<endl;
cin >> tmp;
}while(tmp);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long Int;
typedef pair<Int,Int> PII;
typedef vector<int> VInt;
#define FOR(i, a, b) for(i = (a); i < (b); ++i)
#define RFOR(i, a, b) for(i = (a) - 1; i >= (b); --i)
#define EACH(it, a) for(auto it = (a).begin(); it != (a).end(); ++it)
#define CLEAR(a, b) memset(a, b, sizeof(a))
#define SIZE(a) int((a).size())
#define ALL(a) (a).begin(),(a).end()
#define MP make_pair
#define MAX (6 << 10)
Int R[MAX][MAX + MAX];
int main()
{
int n, m;
cin >> n >> m;
CLEAR(R, 0);
R[0][MAX] = 1;
int i, j;
FOR(i, 0, 3*n)
FOR(j, 0, MAX + MAX)
if(R[i][j] != 0)
{
R[i + 1][j + 1] = (R[i + 1][j + 1] + R[i][j]) % m;
if(i + 2 <= 3*n) R[i + 2][j - 1] = (R[i + 2][j - 1] + R[i][j]*(i + 1)) % m;
if(i + 3 <= 3*n) R[i + 3][j] = (R[i + 3][j] + R[i][j]*(i + 1)*(i + 2)) % m;
}
Int res = 0;
FOR(i, MAX, MAX + MAX) res += R[3*n][i];
res %= m;
cout << res << endl;
return 0;
} | #include <stdio.h>
#include <iostream>
#include <vector>
#include <queue>
#include <stack>
#include <algorithm>
using ll = long long int;
const int INF = (1<<30);
const ll INFLL = (1ll<<60);
#define l_ength size
ll MOD;
void mul_mod(ll& a, ll b){
a *= b;
a %= MOD;
}
void add_mod(ll& a, ll b){
a = (a<MOD)?a:(a-MOD);
b = (b<MOD)?b:(b-MOD);
a += b;
a = (a<MOD)?a:(a-MOD);
}
ll dp[6060][13000];
int main(void){
int n,i,j;
ll ans = 0ll;
std::cin >> n >> MOD;
n *= 3;
dp[0][6500] = 1ll;
for(i=0; i<n; ++i){
for(j=500; j<=12500; ++j){
add_mod(dp[i+1][j-1],dp[i][j]);
add_mod(dp[i+2][j+1],dp[i][j]*(i+1)%MOD);
add_mod(dp[i+3][j],dp[i][j]*(i+1)*(i+2)%MOD);
}
}
for(j=500; j<=6500; ++j){
add_mod(ans,dp[n][j]);
}
std::cout << ans << std::endl;
return 0;
}
| 1 |
#include<iostream>
#include<math.h>
#include<bits/stdc++.h>
#define ll long long int
#define hell 1000000007LL
using namespace std;
ll power(ll x, ll y){
if(y==0)
return 1;
else
{
ll p=power(x,y/2);
if(y%2==0)
return (p*p)%hell;
else
return (x*((p*p)%hell))%hell;
}}
ll gcd(ll x,ll y)
{
if(y==0)
return x;
else
return gcd(y,x%y);
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(20);
ll a,b;
cin>>a>>b;
cout<<max(max(a+b,2*a-1),2*b-1);} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
if(A==B){
cout << A+B << endl;
}
else if(A>B){
cout << A+A-1 << endl;
}
else if(A<B){
cout << B+B-1 << endl;
}
} | 1 |
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <algorithm>
#include <utility>
#include <functional>
#include <sstream>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <climits>
using namespace std;
inline int toInt(string s) { int v; istringstream sin(s); sin >> v; return v;}
template<class T> inline string toString(T x) { ostringstream sout; sout << x; return sout.str();}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
#define REP(i,n) FOR(i,0,n-1)
const double EPS = 1e-10;
const double PI = acos(-1.0);
int main() {
ll n;
map<int, ll> field;
vi jun;
while(cin >> n, n) {
field.clear();
jun.clear();
int ban;
ll tan, suu;
bool flag = true;
REP(i, n) {
cin >> ban >> tan >> suu;
if(!field[ban]) {
jun.push_back(ban);
}
if(field[ban] < 1000000) {
field[ban] += tan*suu;
}
}
if(jun.size() == 0) {
cout << "NA" << endl;
} else {
REP(i, jun.size()) {
if(field[jun[i]] >= 1000000) {
cout << jun[i] << endl;
flag = false;
}
}
if(flag) {
cout << "NA" << endl;
}
}
}
return 0;
} | #include<cstdio>
#include<queue>
#include<algorithm>
#include<functional>
using namespace std;
int flag[301] = {0};
int main(void){
while(1){
for(int i = 1;i <= 300;i++){
flag[i] = 2;
}
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
if(a == 0 && b == 0 && c == 0) break;
vector < pair<pair<int,int> ,pair<int,int> > > v;
pair<pair<int,int>,pair<int,int> > input;
int n; scanf("%d",&n);
for(int i = 0;i < n;i++){
int x,y,z,w; scanf("%d%d%d%d",&x,&y,&z,&w);
input.first.first = w;
input.first.second = x;
input.second.first = y;
input.second.second = z;
v.push_back(input);
}
sort(v.begin(),v.end(),greater <pair< pair<int,int>,pair<int,int> > >());
for(int i = 0;i < n;i++){
if(v[i].first.first == 1){
flag[v[i].first.second] = 1;
flag[v[i].second.first] = 1;
flag[v[i].second.second] = 1;
}
else{
if(flag[v[i].first.second] == 1 &&
flag[v[i].second.first] == 1 &&
flag[v[i].second.second] == 2){
flag[v[i].second.second] = 0;
}
if(flag[v[i].first.second] == 1 &&
flag[v[i].second.first] == 2 &&
flag[v[i].second.second] == 1){
flag[v[i].second.first] = 0;
}
if(flag[v[i].first.second] == 2 &&
flag[v[i].second.first] == 1 &&
flag[v[i].second.second] == 1){
flag[v[i].first.second] = 0;
}
}
}
for(int i = 1;i <= a+b+c;i++){
printf("%d\n",flag[i]);
}
}
return 0;
} | 0 |
#include <iostream>
using namespace std;
int main () {
int x, y;
cin >> x >> y;
cout << x*y;
} | #include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<pii,int> piii;
typedef pair<ll,ll> pll;
#define reps(i,f,n) for(int i = int(f); i <= int(n); i++)
#define rep(i,n) reps(i,0,int(n)-1)
#define rrep(i,n) for(int i = n-1; i >= 0; i--)
#define all(x) (x).begin(),(x).end()
#define X first
#define Y second
#define sz size()
#define eb emplace_back
int memo[64][64];
int main(void){
while(1){
int n,p;
int pl[64] = {0};
int ans = -1;
int bowl;
cin >> n >> p;
bowl = n;
if(n+p==0)break;
if(memo[n][p] == 0){
bowl = p;
rep(i,1000000){
if(bowl){
bowl--;
pl[(i%n)]++;
if(pl[i%n] == p){ans = i%n;break;}
}else{
bowl = pl[i%n];
pl[i%n] = 0;
}
}
cout << ans << endl;
memo[n][p] = ans;
}else{
cout << memo[n][p] << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define REP(i,s,n) for(int i=s;i<n;i++)
#define MOD 1000000007
#define NUM 2520
#define INF (1LL<<50)
#define DEBUG 0
#define mp(a,b) make_pair(a,b)
#define SORT(V) sort(V.begin(),V.end())
#define PI (3.141592653589794)
#define P pair<lli,lli>
signed main(){
lli n;
cin>>n;
string s[3];
REP(i,0,3)cin>>s[i];
lli cnt = 0;
REP(i,0,n){
set<char> c;
REP(j,0,3){
c.insert(s[j][i]);
}
if(c.size()==3)cnt+=2;
else if(c.size()==2)cnt++;
}
cout<<cnt<<endl;
return 0;
} | #include <bits/stdc++.h>
#include <climits>
using namespace std;
int main(){
int N;
string A,B,C;
cin >> N;
cin >> A >> B >> C;
int ans = 0;
for(int i = 0; i < N;i++){
if(A[i] == B[i] && B[i] != C[i] && C[i] != A[i])ans++;
else if(A[i] != B[i] && B[i] == C[i] && C[i] != A[i])ans++;
else if(A[i] != B[i] && B[i] != C[i] && C[i] == A[i])ans++;
else if(A[i] != B[i] && B[i] != C[i] && C[i] != A[i])ans+=2;
}
cout << ans << endl;
}
| 1 |
#include <iostream>
#include <string>
int main(){
int n;
std::string str;
std::cin >> n;
std::getline(std::cin, str);
for (int i = 0; i < n; ++i){
std::getline(std::cin, str);
while(str.find("Hoshino") != std::string::npos){
str.replace(str.find("Hoshino"), 7, "Hoshina");
}
std::cout << str << std::endl;
}
return 0;
}
| #include <bits/stdc++.h>
#include <cstdlib>
using namespace std;
int64_t n;
// 4*4
char moji4[4][4] = {
{ 'a' , 'b', 'c', 'c' },
{ 'a' , 'b', 'd', 'd' },
{ 'e' , 'e', 'f', 'g' },
{ 'h' , 'h', 'f', 'g' },
};
// 5*5
char moji5[5][5] = {
{ '.', '.', 'a', 'b', 'c' },
{ '.', '.', 'a', 'b', 'c' },
{ 'd', 'd', 'e', 'f', 'f' },
{ 'g', 'g', 'e', '.', 'h' },
{ 'i', 'i', 'j', 'j', 'h' },
};
// 6*6
char moji6[6][6] = {
{ '.', '.', '.', 'a', 'b', 'c' },
{ '.', '.', '.', 'a', 'b', 'c' },
{ 'd', '.', 'e', 'e', '.', 'f' },
{ 'd', 'g', 'g', '.', '.', 'f' },
{ 'h', 'h', 'i', '.', 'j', 'j' },
{ 'k', 'k', 'i', 'l', 'l', '.' },
};
// 7*7
char moji7[7][7] = {
{ 'a', 'a', 'b', 'b', 'c', 'c', '.', },
{ 'd', 'd', 'e', 'e', 'f', '.', '.', },
{ '.', '.', 'g', 'g', 'f', 'h', 'h', },
{ '.', '.', '.', '.', 'i', 'j', 'k', },
{ '.', '.', '.', '.', 'i', 'j', 'k', },
{ 'l', 'm', '.', '.', '.', '.', 'n', },
{ 'l', 'm', '.', '.', '.', '.', 'n', },
};
int main() {
// 入力
cin >> n;
if(n==2){
cout << -1;
return 0;
}else if(n==3){
cout << 'a' << 'a' << '.' << "\n";
cout << '.' << '.' << 'a' << "\n";
cout << '.' << '.' << 'a' << "\n";
return 0;
}
char waku[n][n];
int data = n/4;
int mod = n%4;
for(int i=0; i<n; i++){
int num = i/4;
if(num<data-1||mod==0){
for(int j=0; j<n; j++){
if(j>=num*4&&j<=num*4+3){
waku[i][j]=moji4[i%4][j%4];
}else{
waku[i][j]='.';
}
}
}else{
if(mod+4==5){
for(int j=0; j<n; j++){
if(j>=(data-1)*4&&j<=(data-1)*4+4){
waku[i][j]=moji5[i-(data-1)*4][j-(data-1)*4];
}else{
waku[i][j]='.';
}
}
}else if(mod+4==6){
for(int j=0; j<n; j++){
if(j>=(data-1)*4&&j<=(data-1)*4+5){
waku[i][j]=moji6[i-(data-1)*4][j-(data-1)*4];
}else{
waku[i][j]='.';
}
}
}else if(mod+4==7){
for(int j=0; j<n; j++){
if(j>=(data-1)*4&&j<=(data-1)*4+6){
waku[i][j]=moji7[i-(data-1)*4][j-(data-1)*4];
}else{
waku[i][j]='.';
}
}
}
}
}
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
cout << waku[i][j];
}
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N;
#define MAX_N 100000
int A[MAX_N];
bool F;
int gcd(int a, int b) {
if(b == 0) return a;
return gcd(b, a % b);
}
int main() {
cin >> N;
for(int i = 0; i < N; ++i) cin >> A[i];
F = true;
while(true) {
int c = 0, o = -1;
for(int i = 0; i < N; ++i) {
if(A[i] % 2 == 0) ++c;
else o = i;
}
if(c % 2 == 1) break;
F = !F;
if(c != N - 1 || A[o] == 1) break;
--A[o];
int g = 0; for(int i = 0; i < N; ++i) g = gcd(g, A[i]);
for(int i = 0; i < N; ++i) A[i] /= g;
}
cout << (F ? "First" : "Second") << endl;
return 0;
}
| #include <cstdio>
typedef long long lint;
int const N=1e5+10;
int n,a[N];
int gcd(int x,int y)
{
if(x==-1 || y==-1) return -x*y;
if(x==0) return y;
else return gcd(y%x,x);
}
int g1[N],g2[N];
int main()
{
scanf("%d",&n);
lint sum=0;
for(int i=1;i<=n;i++) scanf("%d",&a[i]),sum+=a[i];
if(n%2==0)
{
if(sum%2==1) printf("First");
else printf("Second");
return 0;
}
if(sum%2==0) {printf("First"); return 0;}
int cur=0;
while(true)
{
bool flag=false;
sum=0;
for(int i=1;i<=n;i++) sum+=a[i];
g1[0]=-1; g2[n+1]=-1;
for(int i=2;i<=n;i++) g1[i]=gcd(g1[i-1],a[i]);
for(int i=n-1;i>=1;i--) g2[i]=gcd(g2[i+1],a[i]);
int g;
for(int i=1;i<=n&&!flag;i++)
{
if(a[i]==1) continue;
g=gcd(gcd(g1[i-1],g2[i+1]),a[i]-1);
if(((sum-1)/g)%2==1) flag=true;
}
if(flag)
for(int i=1;i<=n;i++) a[i]/=g;
else
{
if(cur==0) printf("Second");
else printf("First");
return 0;
}
cur^=1;
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
const int MAXN = 2e3 + 3;
int s[MAXN][MAXN], v[MAXN][MAXN], e[MAXN][MAXN], romokh[2][MAXN][MAXN];
int n, m, q;
int a1, a2, b1, b2;
void input();
void cm_romokh();
void solve();
int main() {
ios:: sync_with_stdio(0), cin.tie(0), cout.tie(0);
input();
return 0;
}
void input() {
cin >> n >> m >> q;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char c;
cin >> c;
s[i][j] = c - '0';
//cout << s[i][j] << endl;
if (i == 0 && j == 0) v[i][j] = (s[i][j] == 1);
else if (i == 0) {
v[i][j] = v[i][j - 1] + (s[i][j] == 1);
e[i][j] = e[i][j - 1] + (s[i][j] == s[i][j - 1] && s[i][j] == 1);
}
else if (j == 0) {
v[i][j] = v[i - 1][j] + (s[i][j] == 1);
e[i][j] = e[i - 1][j] + (s[i][j] == s[i - 1][j] && s[i][j] == 1);
}
else {
v[i][j] = v[i][j - 1] + v[i - 1][j] - v[i - 1][j - 1] + (s[i][j] == 1);
e[i][j] = e[i][j - 1] + e[i - 1][j] - e[i - 1][j - 1] + (s[i][j] == 1 && s[i][j] == s[i - 1][j]) + (s[i][j] == 1 && s[i][j] == s[i][j - 1]);
}
}
cm_romokh();
//cout << romokh[1][1][2];
while (q--) {
cin >> a1 >> b1 >> a2 >> b2;
if (a1 > a2) swap(a1, a2);
if (b1 > b2) swap(b1, b2);
a1--, a2--, b1--, b2--;
solve();
}
}
void cm_romokh() {
for (int i = 1; i < n; i++) {
romokh[0][i][0] = (s[i][0] == s[i - 1][0] && s[i][0] == 1);
for (int j = 1; j < m; j++)
romokh[0][i][j] = romokh[0][i][j - 1] + (s[i][j] == s[i - 1][j] && s[i][j] == 1);
}
for (int i = 1; i < m; i++) {
romokh[1][0][i] = (s[0][i] == s[0][i - 1] && s[0][i] == 1);
for (int j = 1; j < n; j++)
romokh[1][j][i] = romokh[1][j - 1][i] + (s[j][i] == s[j][i - 1] && s[j][i] == 1);
}
}
void solve() {
int te = 0, tv = 1;
if (a1 == 0 && b1 == 0) {
tv = v[a2][b2];
te = e[a2][b2];
}
else if (a1 == 0) {
tv = v[a2][b2] - v[a2][b1 - 1];
te = e[a2][b2] - e[a2][b1 - 1] - romokh[1][a2][b1];
}
else if (b1 == 0) {
tv = v[a2][b2] - v[a1 - 1][b2];
te = e[a2][b2] - e[a1 - 1][b2] - romokh[0][a1][b2];
}
else {
tv = v[a2][b2] + v[a1 - 1][b1 - 1] - v[a1 - 1][b2] - v[a2][b1 - 1];
te = e[a2][b2] + e[a1 - 1][b1 - 1] - e[a1 - 1][b2] - e[a2][b1 - 1];
te -= romokh[0][a1][b2] - romokh[0][a1][b1 - 1];
te -= romokh[1][a2][b1] - romokh[1][a1 - 1][b1];
}
cout << tv - te << endl;
}
| #include <bits/stdc++.h>
#include <iomanip>
using namespace std;
#define reps(i,s,n) for(int i = s; i < n; i++)
#define rep(i,n) reps(i,0,n)
#define Rreps(i,n,e) for(int i = n - 1; i >= e; --i)
#define Rrep(i,n) Rreps(i,n,0)
#define ALL(a) a.begin(), a.end()
#define fi first
#define se second
#define mp make_pair
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
ll N,M,H,W,K,Q,A,B;
string S;
//const ll MOD = 998244353;
const ll MOD = (1e+9) + 7;
const ll INF = 1LL << 60;
typedef pair<ll,ll> P;
int main(){
cin>>N>>M>>Q;
vector<string> grid(N);
rep(i,N) cin>>grid[i];
mat edge(N, vec(M, 0)), num(N + 1, vec(M + 1, 0)), addr(N, vec(M,0)), addc(N, vec(M,0));
rep(i,N){
rep(j,M){
bool blue = grid[i][j] == '1';
if(i > 0) {
edge[i][j] += edge[i-1][j] + (blue && grid[i-1][j] == '1');
addc[i][j] = addc[i-1][j] + (blue && grid[i-1][j] == '1');
}
if(j > 0) {
edge[i][j] += edge[i][j-1] + (blue && grid[i][j-1] == '1');
addr[i][j] = addr[i][j-1] + (blue && grid[i][j-1] == '1');
}
if(i > 0 && j > 0) edge[i][j] -= edge[i-1][j-1];
num[i+1][j+1] = num[i][j+1] + num[i+1][j] - num[i][j] + blue;
}
}
vec x(2), y(2);
rep(i,Q){
rep(j,2) cin>>x[j]>>y[j];
--x[0], --y[0];
ll res = 0;
rep(j,2) rep(k,2) res += (j^k ? -1 : 1) * num[x[j]][y[k]];
--x[1], --y[1];
rep(j,2) rep(k,2) res += (j^k ? 1 : -1) * edge[x[j]][y[k]];
res -= addr[x[0]][y[1]] - addr[x[0]][y[0]];
res -= addc[x[1]][y[0]] - addc[x[0]][y[0]];
cout<<res<<endl;
}
/*rep(i,N){
rep(j,M) cout<<edge[i][j]<<' ';
cout<<endl;
}*/
} | 1 |
#include <iostream>
#include <numeric>
#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++)
int Max(int(a), int(b), int(c)) {
return max(max(a, b), c);
}
int Min(int(a), int(b), int(c)) {
return min(min(a, b), c);
}
int main() {
ll N,K;
cin >> N>>K;
cout << N-K+1 << endl;
} | #include <iostream>
#include <string.h>
using namespace std;
int main()
{
int n, i, j;
ios::sync_with_stdio();
string s;
scanf("%d", &n); cin.get();
for (i=0; i<n; i++) {
getline(cin, s);
for (j=0; j+6 < s.size(); j++) {
if (s.substr(j, 7) == "Hoshino") s[j+6] = 'a';
}
cout << s << endl;
}
return 0;
} | 0 |
#pragma GCC optimize("O2,unroll-loops")
#pragma GCC target("avx,avx2,sse,sse2,ssse3")
#include<bits/stdc++.h>
#define all(x) x.begin(), x.end()
#define pb push_back
using namespace std;
using ll = long long;
using vi = vector<ll>;
using pi = pair<ll, ll>;
const int maxn = 1<<17, mlg = 17, mod = 1e9 + 7;
ll n, l, q, x[maxn], go[maxn][mlg];
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n;
for(int i = 1; i <= n; i++) cin >> x[i];
cin >> l >> q;
for(int i = 1, j = 1; i <= n; i++) {
while(j < n && x[j+1]-x[i] <= l) j++;
go[i][0] = j;
//cout << j << " ";
}
for(int j = 1; j < mlg; j++)
for(int i = 1; i <= n; i++)
go[i][j] = go[go[i][j-1]][j-1];
int a, b;
while(q--) {
cin >> a >> b;
if(a > b) swap(a, b);
int ans = (a!=b);
for(int i = mlg; i--;) if(go[a][i] && go[a][i] < b) {
//cout << a << " " << i << '\n';
a = go[a][i], ans += 1<<i;
}
cout << ans << '\n';
}
}
| //http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=2676345#1
#include <iostream>
#include<cstdlib>
#include<queue>
#include<set>
#include<vector>
#include<string>
#include<algorithm>
#include<stack>
#include<map>
#include<cstdio>
#include<fstream>
#include<cstring>
using namespace std;
#define rep(i,a) for(int i=0;i<a;i++)
#define mp make_pair
#define P pair<int,int>
#define ll __int64
int n,k;
int f,to,from,cost;
const int INF=222222222;
vector<P> G[1000];//first→終点 second→cost
int dist[1000];//頂点iへの最小距離
int keiro(int from,int to){
for(int i=0;i<=n;i++)dist[i]=INF;
//dist[from]=0;
priority_queue<P,vector<P>,greater<P> >bfs;//first→頂点へのコスト second→頂点
bfs.push(mp(0,from));
while(!bfs.empty()){
P now=bfs.top();
bfs.pop();
int index=now.second,ncost=now.first;
if(dist[index]!=INF)continue;
//cout<<index<<" "<<ncost<<endl;
dist[index]=ncost;
for(int i=0;i<G[index].size();i++){
bfs.push(mp(ncost+G[index][i].second,G[index][i].first));
//cout<<G[index][i].first<<" "<<G[index][i].second<<endl;
}
}
//rep(i,n+1)cout<<dist[i]<<" ";
if(dist[to]==INF)return -1;
return dist[to];
}
int main(){
while(cin>>n>>k,n||k){
for(int i=0;i<200;i++)G[i].clear();
for(int i=0;i<k;i++){
cin>>f;
if(!f){
cin>>from>>to;
cout<<keiro(from,to)<<endl;
}
else{
cin>>from>>to>>cost;
G[from].push_back(mp(to,cost));
G[to].push_back(mp(from,cost));
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<vb> vbb;
typedef pair<int, int> pii;
typedef long long ll;
typedef unsigned long long ull;
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define mp make_pair
#define loop(i,a,b) for(int i=(a);i<ull(b);++i)
#define rep(i,n) loop(i,0,n)
const double eps = 1e-10;
const double pi = acos(-1.0);
const double inf = (int)1e8;
int main(){
int d[110];
int n, q;
while(cin >> n >> q, n+q){
fill(d, d+110, 0);
for(int i=0; i< n; i++){
int q;
cin >> q;
rep(j, q){
int r; cin >> r; d[r]++;
}
}
int m = 0, ret = -1;
rep(i, 110){
if(q <= d[i] && m < d[i]){ret = i; m = d[i];}
}
cout << (ret==-1?0:ret) << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
int n, m;
cin >> n >> m;
vector<int> a(m);
vector<char> b(m);
for (int i = 0; i < m; i++)
{
cin >> a[i] >> b[i];
if (n != 1)
{
if (a[i] == 1)
{
if (b[i] == '0')
{
cout << -1 << endl;
return 0;
}
}
}
a[i]--;
}
for (int i = 0; i < m - 1; i++)
{
for (int j = i + 1; j < m; j++)
{
if (a[i] == a[j])
{
if (b[i] != b[j])
{
cout << -1 << endl;
return 0;
}
}
}
}
int nx = pow(10, n);
for (int i = 0; i < nx; i++)
{
string str = to_string(i);
if (str.size() != n) continue;
int flg = 1;
for (int j = 0; j < m; j++)
{
if (str[a[j]] != b[j]) flg = 0;
}
if (flg)
{
cout << i << endl;
return 0;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ii pair<int,int>
#define fi first
#define sc second
#define all(x) (x).begin(),(x).end()
void solve() {
int n;
cin >> n;
string a, b;
cin >> a >> b;
for (int i = 0; i < n; i++) {
int f = 0;
for (int j = 0; i + j < n; j++) {
if (a[j + i] != b[j]) {
f = 1;
break;
}
}
if (!f) {
cout << n + i << '\n';
return;
}
}
cout << n + n << '\n';
}
signed main() {
#ifdef _DEBUG
// freopen("in" , "r", stdin );
// freopen("out", "w", stdout);
#endif
ios::sync_with_stdio(0); cin.tie(0);
int T = 1;
// cin >> T;
while (T--) solve();
}
| #include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<set>
#include<string>
#include<map>
#include<string.h>
#include<complex>
#include<math.h>
#include<queue>
#include <functional>
#include<time.h>
#include <stack>
#include<iomanip>
#include<unordered_map>
using namespace std;
#define rep(i,a,n) for(int i=(a);i<(n);i++)
#define ll long long
#define llint long long int
#define sort(s) sort(s.begin(),s.end())
#define reverse(v) reverse(v.begin(), v.end());
#define Yes(ans) if(ans)cout<<"Yes"<<endl; else cout<<"No"<<endl;
#define YES(ans) if(ans)cout<<"YES"<<endl; else cout<<"NO"<<endl;
#define hei(a) vector<a>
#define whei(a) vector<vector<a>>
#define UF UnionFind
#define rt (a); return (a);
#define Pint pair<int,int>
#define Pll pair<ll,ll>
#define keta(a) fixed << setprecision(a)
constexpr auto INF = 1000000000;
constexpr auto mod = 1000000007;
ll gcd(ll a, ll b) {
if (a < b)swap(a, b);
if (b == 0)return a;
return gcd(b, a % b);
}
int n,q;
hei(ll) seg, lazy;
void aaa(int k) {
if (lazy[k] == 0)return ;
if (k < n - 1) {
lazy[k * 2 + 1] += lazy[k];
lazy[k * 2 + 2] += lazy[k];
}
seg[k] += lazy[k];
lazy[k] = 0;
}
void update(int a, int b, ll x,int k,int l,int r) {
aaa(k);
if (a<=l && b>=r) {
lazy[k] += x;
aaa(k);
}
else if(a<r&&l<b){
update(a, b, x, k * 2 + 1, l, (l + r) / 2);
update(a, b, x, k * 2 + 2, (l + r) / 2, r);
seg[k] = seg[k * 2 + 1]+seg[k * 2 + 2];
}
}
ll query(int a,int b,int k,int l,int r){
aaa(k);
if (l >= b || r <= a)return 0;
if (a <=l && b >= r) {
return seg[k];
}
ll v1 = query(a, b, k*2+1, l, (l + r) / 2);
ll v2 = query(a, b, k*2+2, (l + r) / 2, r);
return v1 + v2;
}
int main() {
int n;
cin >> n;
string s, t;
cin >> s >> t;
int x = 0;
rep(i, 1, n + 1) {
if (s.substr(n - i, i) == t.substr(0, i))x = i;
}
int ans = (2 * n) - x;
cout << ans << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
#define ll long long
#define inf(x) (ll)(1e##x)
using namespace std;
template<typename tn> void read(tn &a){
tn x=0,f=1; char c=' ';
for(;!isdigit(c);c=getchar()) if(c=='-') f=-1;
for(;isdigit(c);c=getchar()) x=x*10+c-'0';
a=x*f;
}
int n,m;
vector<int> v[3];
int main(){
read(n);read(m);
for(int i=1;i<=m;i++){
int x;read(x);
v[x&1].push_back(x);
}
if(v[1].size()>2){puts("Impossible");return 0;}
if(m==1){
int p=v[0].size()?v[0][0]:v[1][0];
cout<<p<<'\n';
cout<<p/2+1<<'\n';
if(p&1){
for(int i=1;i<=p/2;i++) cout<<2<<' ';
cout<<1<<'\n';
}
else{
for(int i=1;i<=p/4;i++) cout<<2<<' ';
cout<<1<<' ';
for(int i=1;i<=(p-2)/4;i++) cout<<2<<' ';
cout<<1<<'\n';
}
return 0;
}
if(v[1].size()) v[2].push_back(v[1][0]);
for(int x:v[0]) v[2].push_back(x);
if(v[1].size()>1) v[2].push_back(v[1][1]);
for(int x:v[2]) cout<<x<<' ';cout<<'\n';
cout<<v[2].size()-(v[2].back()==1)<<'\n';
cout<<v[2][0]+1<<' ';
for(int i=1;i+1<v[2].size();i++) cout<<v[2][i]<<' ';
if(v[2].back()>1) cout<<v[2].back()-1<<'\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 105;
int a[N], n, cnt, m;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) if (a[i] & 1) cnt ++;
if (cnt > 2) {
puts("Impossible");
return 0;
}
for (int i = 1; i <= m; i++)
if ((a[i] & 1) && (!(a[1] & 1))) swap(a[i], a[1]);
else if (a[i] & 1) swap(a[i], a[m]);
for (int i = 1; i <= m; i++) cout << a[i] << " " ; cout << endl;
if (!cnt) {
int ans = m + 2;
if (a[1] == 2) ans--;
cout << ans << endl;
if (a[1] != 2) cout << a[1] - 2 << " " ; cout << "1 ";
for (int i = 2; i <= m; i++) cout << a[i] << " " ; cout << 1 << endl;
}
else if (cnt == 1) {
int ans = m + 1;
if (a[1] == 1) ans--;
cout << ans << endl;
if (a[1] != 1) cout << a[1] - 1 << " " ;
for (int i = 2; i <= m; i++) cout << a[i] << " " ; cout << 1 << endl;
}
else if (cnt == 2) {
int ans = m;
if (a[1] == 1) ans--;
cout << ans << endl;
if (a[1] != 1) cout << a[1] - 1 << " " ;
for (int i = 2; i < m; i++) cout << a[i] << " " ; cout << a[m] + 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,m;
while(cin>>n,n){
set<pair<int,int> > sp;
for(int i=0;i<n;i++){
int x,y;
cin>>x>>y;
sp.insert(make_pair(y,x));
}
cin>>m;
int c=0;
pair<int,int> now(10,10);
for(int i=0;i<m;i++){
char d;
int len;
cin>>d>>len;
cin.ignore();
for(int j=0;j<len;j++){
switch(d){
case 'N':
now.first++;
break;
case 'S':
now.first--;
break;
case 'E':
now.second++;
break;
case 'W':
now.second--;
break;
}
decltype(sp.end()) it;
if((it=sp.find(now)) != sp.end()){
c++;
sp.erase(it);
}
}
}
cout << (c==n ? "Yes" : "No") << endl;
}
} | #include <stdio.h>
#include <string.h>
#define N 0
#define E 1
#define S 2
#define W 3
int dir[4][2] = { {0,1}, {1,0}, {0,-1}, {-1,0} };
int map[21][21];
int main(void)
{
while(true) {
int n, m;
int px=10, py=10, s=0;
memset(map, 0, sizeof(map));
scanf("%d\n", &n);
if(n==0) break;
for(int i=0; i < n; i++)
{
int x,y;
scanf("%d%d\n", &x, &y);
map[x][y] = 1;
}
scanf("%d\n", &m);
map[10][10] = 0;
for(int i=0; i < m; i++)
{
char d;
int *D, l;
scanf("%c %d\n", &d, &l);
switch(d) {
case 'N':
D = dir[N];
break;
case 'E':
D = dir[E];
break;
case 'S':
D = dir[S];
break;
case 'W':
D = dir[W];
break;
}
for(int i=0; i < l; i++)
{
px += *D;
py += *(D+1);
map[px][py] = 0;
}
}
for(int i=0; i <= 20; i++)
for(int j=0; j <= 20; j++)
s += map[i][j];
printf( s ? "No\n" : "Yes\n");
}
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int main(){
int E;
while(cin >> E && E){
int m=1000000;
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;
m = min(m,x+y+z);
}
}
cout << m << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> duo;
#define TT template<typename T>
TT T sq(T x){ return x*x; }
TT int ubnd(vector<T>& v,T x){ return upper_bound(v.begin(), v.end(), x) - v.begin(); }
TT int lbnd(vector<T>& v,T x){ return lower_bound(v.begin(), v.end(), x) - v.begin(); }
TT void sort(T& v){ sort(v.begin(), v.end()); }
TT void revs(T& v){ reverse(v.begin(), v.end()); }
TT void uniq(T& v){ sort(v); v.erase(unique(v.begin(), v.end()), v.end()); }
TT void show(T& v,char d=' ',char e='\n'){for(int i=0;i<v.size();++i)cout<<v[i]<<((i==v.size()-1)?e:d);}
TT void inpt(vector<T>& v,int n){ v.reserve(n);for(int i=0;i<n;++i){T x; cin>>x; v.push_back(x);} }
TT T In(){ T x; cin >> x; return x; }
static inline void fast_io(){ ios::sync_with_stdio(0); cin.tie(0); }
static inline int in(){ int x; scanf("%d", &x); return x; }
static inline string instr(){ string x; cin >> x; return x; }
static const int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
static const int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
int main()
{
while (int e = in()){
int m = 1e8;
for (int z = 0; z <= 100; ++z){
for (int y = 0; y <= 1000; ++y){
int x = e - (sq(z) * z + sq(y));
if (x < 0) continue;
m = min(m, z + y + x);
}
}
printf("%d\n", m);
}
return (0);
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define IO ios::sync_with_stdio(false),cin.tie(0);
#define ll long long
#define inf 0x3f3f3f3f
const int N=105;
//set<string>b;
//set<string>::iterator it;
int main()
{
IO;
double d,t,s,x;
cin>>d>>t>>s;
x=1.0*d/s;
if(x>t) cout<<"No\n";
else cout<<"Yes\n";
return 0;
} | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <iomanip>
#include <limits>
using namespace std;
// 素因数分解
typedef pair<long long, long long> P;
vector<P> prime_factorize(long long n)
{
vector<P> res;
for (long long p = 2; p * p <= n; ++p)
{
if (n % p != 0)
continue;
int num = 0;
while (n % p == 0)
{
++num;
n /= p;
}
res.push_back(make_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
// 因数分解
long long gcd(long long x, long long y)
{
if (y == 0)
{
return x;
}
else
{
return gcd(y, x % y);
}
}
const int MOD = 1000000007;
typedef long long unsigned int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define rep(i, n) for (int i = 0; i < (n); i++)
int main()
{
int a, b, c;
cin >> a >> b >> c;
set<int> set;
set.insert(a);
set.insert(b);
set.insert(c);
if(set.size()==2){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm> // require sort next_permutation count __gcd reverse etc.
#include <cstdlib> // require abs exit atof atoi
#include <cstdio> // require scanf printf
#include <functional>
#include <numeric> // require accumulate
#include <cmath> // require fabs
#include <climits>
#include <limits>
#include <cfloat>
#include <iomanip> // require setw
#include <sstream> // require stringstream
#include <cstring> // require memset
#include <cctype> // require tolower, toupper
#include <fstream> // require freopen
#include <ctime> // require srand
#define rep(i,n) for(int i=0;i<(n);i++)
#define ALL(A) A.begin(), A.end()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main()
{
// cut here before submit
// freopen ("testcase.RL", "r", stdin );
string str = "";
while (getline (cin, str ) ){
if (str.empty() ) break;
int n = str.length();
rep (i, n ){
if (str[i] == ',' ) str[i] = ' ';
} // end rep
vector<int> l (12, 0 ), sum (12, 0 );
int v1, v2;
stringstream ss (str );
for (int i = 1; i <= 10; i++ ){
ss >> l[i];
} // end rep
l[11] = 100000;
ss >> v1 >> v2;
for (int i = 1; i <= 11; i++ ){
sum[i] = sum[i-1] + l[i];
} // end for
/*
cerr << "sum: " << endl;
rep (i, 10+1 ){
cerr << sum[i] << (i != 10 ? ' ' : '\n' );
} // end rep
*/
double t = (double)sum[10]/(double)(v1 + v2 );
// cerr << "t: " << t << endl;
double cl = (double)v1*t;
// cerr << "cl: " << cl << endl;
int res = 0;
for (int i = 1; i <= 10; i++ ){
if ((double)sum[i-1] < cl && cl <= (double)sum[i] ){
res = i;
break;
} // end if
} // end for
printf ("%d\n", res );
} // end loop
return 0;
} | #include <iostream>
using namespace std;
void solve()
{
int l[10];
while(cin >> l[0])
{
for(int i = 1; i <= 9; ++i)
{
scanf(",%d", &l[i]);
}
int v[2];
scanf(",%d,%d", &v[0], &v[1]);
int sum = 0;
for(int i = 0; i < 10; ++i)
{
sum += l[i];
}
double time = (double)sum / (v[0] + v[1]);
double dist = time * (double)v[0];
int pos = 0;
int d = 0;
while(true)
{
d += l[pos];
if(d >= dist)
{
cout << pos + 1 << endl;
break;
}
++pos;
}
}
}
int main()
{
solve();
return(0);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int s = 0;
int M = N;
while(M != 0){
s += M % 10;
M = M / 10;
}
if ( N % s == 0)
cout << "Yes" << endl;
if ( N % s != 0)
cout << "No" <<endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int a = (N % 10);
int b = (N-a)/10%10;
int c = (N-10*b-a)/(10*10)%10;
int d = (N-10*10*c-10*b-a)/(10*10*10)%10;
int e = (N-10*10*10*d-10*10*c-10*b-a)/(10*10*10*10)%10;
int f = (N-10*10*10*10*e-10*10*10*d-10*10*c-10*b-a)/(10*10*10*10*10)%10;
int g = (N-10*10*10*10*10*f-10*10*10*10*e-10*10*10*d-10*10*c-10*b-a)/(10*10*10*10*10*10)%10;
int h = (N-10*10*10*10*10*10*g-10*10*10*10*10*f-10*10*10*10*e-10*10*10*d-10*10*c-10*b-a)/(10*10*10*10*10*10*10)%10;
int i = (N-10*10*10*10*10*10*10*h-10*10*10*10*10*10*g-10*10*10*10*10*f-10*10*10*10*e-10*10*10*d-10*10*c-10*b-a)/(10*10*10*10*10*10*10*10)%10;
if (N % (a+b+c+d+e+f+g+h+i) == 0) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
}
| 1 |
///f. fizzbuzz sequence
#include <stdio.h>
#include <math.h>
int main()
{
long long int n;
scanf("%lld",&n);
long long int d3,d5,d15;
d3=n/3; d5=n/5; d15=n/15;
long long sum = (n*(n+1)-3*d3*(d3+1)-5*d5*(d5+1)+15*d15*(d15+1))/2;
printf("%lld",sum);
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
long long int n,c1=0,c2=0,c3=0,c=1;
cin>>n;
if(n%2==0)
{
for(long long int i=1;i<=n/2;i++)
{
if(i%3==0 || i%5==0 || i%3==0 && i%5==0)
continue;
else
c1+=i;
}
for(long long int j=(n/2)+1;j<=n;j++)
{
if(j%3==0 || j%5==0 || j%3==0 && j%5==0)
continue;
else
c2+=j;
}
cout<<c1+c2;
}
if(n%2!=0)
{
for(long long int i=1;i<=n/2;i++)
{
if(i%3==0 || i%5==0 || i%3==0 && i%5==0)
continue;
else
c1+=i;
}
for(long long int j=(n/2)+1;j<=n;j++)
{
if(j%3==0 || j%5==0 || j%3==0 && j%5==0)
continue;
else
c2+=j;
}
cout<<c1+c2;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1LL << 60;
int main() {
int x;
cin >> x;
int happy = 0;
happy += (x / 500) * 1000;
happy += ((x % 500) / 5) * 5;
cout << happy << endl;
} | //https://atcoder.jp/contests/abc160/tasks/abc160_b
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
ll x;
cin>>x;
ll a;
a=x/500;
ll fin1;
fin1=a*1000;
ll b;
b=x%500;
ll c;
c=b/5;
ll fin2;
fin2=c*5;
ll sum=0;
sum=fin1+fin2;
cout<<sum<<"\n";
return 0;
} | 1 |
#include<bits/stdc++.h>
#define ll long long int
#define M 1000000007
using namespace std;
ll n,t,x,y,m,q,a,b;
vector<ll>v[100001];
ll vis[100001]={0},ans=0;
pair<ll,ll> dfs(ll x,ll lvl){
vis[x]=1;
ll mx=0;
ll d2=1e9;
if(x==a)d2=0;
for(int i=0;i<v[x].size();i++){
if(vis[v[x][i]]==0){
pair<ll,ll> p=dfs(v[x][i],lvl+1);
d2=min(d2,p.second);
mx=max(mx,1+p.first);
}
}
if(d2<lvl) ans=max(ans,mx+lvl);
return {mx,d2+1};
}
int main(){
ios_base::sync_with_stdio(false); cin.tie(NULL);
cin>>n>>a>>b;
for(int i=0;i<n-1;i++){
cin>>x>>y;
v[x].push_back(y);
v[y].push_back(x);
}
if(a==b)cout<<0;
else{
dfs(b,0);
cout<<ans-1;
}
} | #include <bits/stdc++.h>
int main(){
int N, u, v;
std::cin >> N >> u >> v;
u--; v--;
std::vector< std::vector< int > > AB(N);
for(int i=1; i<N; i++){
int tmpa, tmpb;
std::cin >> tmpa >> tmpb;
tmpa--; tmpb--;
AB[tmpa].push_back(tmpb);
AB[tmpb].push_back(tmpa);
}
std::vector< int > min_dist(N, 1e9);
std::vector< int > min_route;
std::deque< int > pos;
std::deque< int > prepos;
std::deque< int > dist;
std::vector< int > route;
pos.push_back(v);
prepos.push_back(-1);
dist.push_back(0);
while(!pos.empty()){
int c_pos = pos[0];
int c_prepos = prepos[0];
int c_dist = dist[0];
pos.pop_front();
prepos.pop_front();
dist.pop_front();
if(min_dist[c_pos] <= c_dist){
continue;
}
route.resize(c_dist);
route.push_back(c_pos);
min_dist[c_pos] = c_dist;
if(c_pos == u){
min_route = route;
break;
}
for(int i=0; i<AB[c_pos].size(); i++){
if(AB[c_pos][i] == c_prepos){
continue;
}
pos.push_front(AB[c_pos][i]);
prepos.push_front(c_pos);
dist.push_front(c_dist+1);
}
}
int center = (min_route.size() % 2 == 0) ? min_route[min_route.size() / 2] : min_route[min_route.size() / 2 + 1];
int pre_center = (min_route.size() % 2 == 0) ? min_route[min_route.size() / 2 - 1] : min_route[min_route.size() / 2];
int center_dist = (min_route.size() % 2 == 0) ? min_route.size() / 2 : min_route.size() / 2 + 1;
pos.clear();
prepos.clear();
dist.clear();
pos.push_back(center);
prepos.push_back(-1);
dist.push_back(0);
min_dist.assign(N, 1e9);
int max_dist = 0;
while(!pos.empty()){
int c_pos = pos[0];
int c_prepos = prepos[0];
int c_dist = dist[0];
pos.pop_front();
prepos.pop_front();
dist.pop_front();
if(c_pos == pre_center){
continue;
}
if(min_dist[c_pos] <= c_dist){
continue;
}
min_dist[c_pos] = c_dist;
if(max_dist < c_dist){
max_dist = c_dist;
}
for(int i=0; i<AB[c_pos].size(); i++){
if(AB[c_pos][i] == c_prepos){
continue;
}
pos.push_back(AB[c_pos][i]);
prepos.push_back(c_pos);
dist.push_back(c_dist+1);
}
}
std::cout << center_dist + max_dist - 1 << std::endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
double x[n];
double y[n];
for(int i=0;i<n;i++)cin >> x[i] >> y[i];
vector<int>v(n);
for(int i=0;i<n;i++)v[i] = i;
double summ = 0.0;
double cnt = 0;
do{
cnt+=1.0;
for(int i=0;i<n-1;i++){
summ += sqrt((x[v[i]]-x[v[i+1]])*(x[v[i]]-x[v[i+1]]) + (y[v[i]]-y[v[i+1]])*(y[v[i]]-y[v[i+1]]));
}
}while(next_permutation(v.begin(),v.end()));
printf("%.10lf", summ/cnt);
} | #include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
int l[m], r[m];
for(int i=0; i<m; i++){
cin >> l[i] >> r[i];
}
int l_prime = *max_element(l, l+m);
int r_prime = *min_element(r, r+m);
if(l_prime > r_prime){
cout << '0' << endl;
return 0;
}
cout << r_prime - l_prime + 1 << endl;
return 0;
} | 0 |
#include<iostream>
#include<cmath>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
#define INF 999999999
struct cost{
string name;
double eff;
bool operator<(const cost& a) const{
if(eff != a.eff) return eff > a.eff;
if(name != a.name) return name < a.name;
}
};
int main(){
double p, a, b, c, d, e, f, s, m;
int n, i, j;
string l;
cost ls[51];
while(1){
cin >> n;
if(!n) break;
for(i=0;i<n;i++){
cin >> l >> p >> a >> b >> c >> d >> e >> f >> s >> m;
ls[i].name = l;
ls[i].eff = (s*f*m-p)/(a+b+c+(d+e)*m);
}
sort(&ls[0], &ls[n]);
for(i=0;i<n;i++){
cout << ls[i].name << endl;
}
cout << "#" << endl;
}
return 0;
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const int INT = 1e9;
const ll LINF = 1e18;
struct UF{
vector<int> d;
UF(int size):d(size,-1){}
bool u(int x,int y){
x = r(x); y = r(y);
if(x != y){
if(d[y] < d[x]) swap(x,y);
d[x] += d[y]; d[y] = x;
}
return x!=y;
}
bool f(int x,int y){
return r(x) == r(y);
}
int r(int x){
return d[x] < 0 ? x:d[x] = r(d[x]);
}
int s(int x){
return -d[r(x)];
}
};
//const ll MAX_PRIME = 200000;
//vector<int> primes;
//vector<int> is_prime(MAX_PRIME + 1,true);
//void init_primes(){
// is_prime[0] = is_prime[1] = false;
// for(int i = 2; i <= MAX_PRIME;i++){
// if(is_prime[i]){
// primes.push_back(i);
// for(int j = i*2;j<=MAX_PRIME;j+=i) is_prime[j] = false;
// }
// }
//}
//void solveF(){
// init_primes();
// ll N,P;
// vector<ll> sum;
// while(cin >> N >> P){
// if(N == -1 && P == -1) break;
// sum.clear();
// auto idx = upper_bound(primes.begin(),primes.end(),N) - primes.begin();
// for(int i = 0; i <= P;i++){
// for(int j = i; j <= P;j++){
// ll S = primes[idx+i] + primes[idx+j];
// sum.push_back(S);
// }
// }
// sort(sum.begin(),sum.end());
// cout << sum[P-1] << endl;
// }
//}
double func(ll P,ll A,ll B,ll C,ll D,ll E,ll F,ll S,ll M){
double ret = 0;
ll sum = M*F*S;
ll kouritu = sum - P;
ll T = A + B + C + D + E + (D + E)*(M-1);
ret = kouritu/(double)T;
return ret;
}
void solveG(){
int N;
while(cin >> N,N){
vector<pair<double,string>> ans(N);
for(int i = 0; i < N;i++){
string L; cin >> L;
ll P,A,B,C,D,E,F,S,M; cin >> P >> A >> B >> C >> D >> E >> F >> S >> M;
ans[i] = {pair<double,string>{-func(P,A,B,C,D,E,F,S,M),L}};
}
sort(ans.begin(),ans.end());
for(int i = 0; i < N;i++){
cout << ans[i].second << endl;
}
cout << "#" << endl;
}
}
int main(void){
cin.tie(0); ios_base::sync_with_stdio(false);
//solveF();
solveG();
return 0;
}
| 1 |
#include<stdio.h>
int main(void){
int a,i;
scanf("%d",&a);
int x[a];
for(i=0;i<a;i++){
scanf("%d",&x[i]);
}
for(i=0;i<a;i++){
printf("%d",x[a-i-1]);
if(i!=a-1){
printf(" ");
}else{
printf("\n");
}
}
}
| #include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) range(i,0,b)
#define debug(x) cout << "debug" << x << endl;
using namespace std;
int main(){
int n, num[105];
while(cin >> n){
rep(i,n){
cin >> num[i];
}
for(int i = n - 1; i >= 0; i--){
if(i != n - 1) cout << ' ';
cout << num[i];
}
cout << endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, start, n) for (int i = (int)(start); i < (int)(n); ++i)
static const int INFTY = (1 << 30);
int N, M;
void func()
{
cin>>N;
int a[N+1];
rep(i, 1, N+1) {
cin>>a[i];
}
int b[N+1]={};
// memset(b, -1, sizeof(int));
for (int i=N;i>0;--i) {
for (int j=2*i;j<=N;j+=i) {
b[i]^=b[j];
}
b[i]^=a[i];
}
int ans=0;
rep(i, 1, N+1) {
if (b[i])++ans;
}
cout<<ans<<endl;
if (ans) {
rep(i, 1, N+1) {
if (b[i])cout<<i<<' ';
}
cout<<endl;
}
}
int main()
{
func();
} | #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define all(x) (x).begin(),(x).end()
#define cyes cout<<"Yes"<<endl
#define cno cout<<"No"<<endl
#define sp <<" "<<
#define cst(x) cout<<fixed<<setprecision(x)
#define pi 3.14159265359
#define mod 1000000007
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; }
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using Graph = vector<vector<int>>;
using que_a = priority_queue<int, vector<int>, greater<int> >;
using que_d = priority_queue<int>;
using pint = pair<int,int>;
queue<pint> que;
int main(){
int h,w; cin >> h >> w;
Graph G(h,vi(w));
rep(i,h){
rep(j,w){
int a; cin >>a;
G.at(i).at(j) = a;
}
if(i%2 == 0){
rep(k,w){
if(G.at(i).at(k)%2 == 1) que.push(make_pair(i,k));
}
}
else{
for(int k = w-1; k>=0; --k){
if(G.at(i).at(k)%2 == 1) que.push(make_pair(i,k));
}
}
}
queue<pint> ans;
while(que.size() > 1){
int m = que.front().first;
int n = que.front().second;
que.pop();
int mn = que.front().first;
int nn = que.front().second;
bool ok = false;
ans.push(make_pair(m+1,n+1));
for(int i = m; i < h; ++i){
if(i%2 == 0){
for(int j = n+1; j < w; ++j){
ans.push(make_pair(i+1,j+1));
if(i == mn && j == nn) ok = true;
else ans.push(make_pair(i+1,j+1));
if(ok) break;
}
n = w;
}
else{
for(int j = n-1; j >= 0; --j){
ans.push(make_pair(i+1,j+1));
if(i == mn && j == nn) ok = true;
else ans.push(make_pair(i+1,j+1));
if(ok) break;
}
n = -1;
}
if(ok){
que.pop();
break;
}
}
}
cout << ans.size()/2 << endl;
while(!ans.empty()){
cout << ans.front().first sp ans.front().second << " ";
ans.pop();
cout << ans.front().first sp ans.front().second << endl;
ans.pop();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < (int)(n); i++)
#define ALL(a) a.begin(), a.end()
#define MOD 1000000007
using namespace std;
using ll = long long;
int main() {
int N; cin >> N;
vector<pair<int, int>> pos, neg;
REP(i, 0, N) {
string s; cin >> s;
int lowest = 0, inc = 0;
for (auto c : s) {
if (c == '(') {
inc++;
} else {
inc--;
lowest = min(lowest, inc);
}
}
if (inc > 0) pos.push_back({lowest, inc});
else neg.push_back({lowest - inc, -inc});
}
sort(ALL(pos), greater<pair<int, int>>());
sort(ALL(neg), greater<pair<int, int>>());
int curp = 0, curn = 0;
for (auto p : pos) {
if (curp + p.first < 0) {
cout << "No" << endl;
return 0;
}
curp += p.second;
}
for (auto n : neg) {
if (curn + n.first < 0) {
cout << "No" << endl;
return 0;
}
curn += n.second;
}
if (curp == curn) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<LL, LL> PII;
// chmax, chmin
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 <typename T>
function<T(T, T)> op_max = [](T a, T b) -> T { return max(a, b); };
template <typename T>
function<T(T, T)> op_min = [](T a, T b) -> T { return min(a, b); };
template <typename T>
function<T(T, T)> op_sum = [](T a, T b) -> T { return a + b; };
using namespace std;
//******************** dumps ************************//
template <typename T>
void dump(const T &data, vector<int> &iter)
{
cout << data << " ";
}
template <typename T>
void dump(const vector<T> &data, vector<int> &iter)
{
for (auto elem : data)
dump(elem, iter);
cout << endl;
}
template <typename T>
void dump(const vector<vector<T>> &data, vector<int> &iter)
{
for (auto elem : iter)
{
cout << "[" << elem << "]";
}
cout << endl;
for (int i = 0; i < data.size(); i++)
{
iter.push_back(i);
dump(data[i], iter);
iter.pop_back();
}
cout << endl;
}
template <typename T>
void dump(const vector<T> &data, int dummy)
{
for (int i = 0; i < data.size(); i++)
{
cout << "[" << i << "] " << data[i] << endl;
}
}
template <typename T>
void dump(const T &data)
{ // T : data, U = base type val.
vector<int> iter;
dump(data, iter);
}
///////////////////////////////////////////////
const string YES = "Yes";
const string NO = "No";
// up, down, l or r
vector<int> parse(string s)
{
int cur = 0;
int minim = 0;
for (auto c : s)
{
if (c == '(')
cur++;
else
cur--;
chmin(minim, cur);
}
if (cur > 0)
{
return vector<int>({cur, minim, true});
}
return vector<int>({-cur, min(minim - cur, 0), false});
}
bool can_construct(vector<PII> input)
{
priority_queue<PII> ord;
for (auto elem : input)
{
ord.push(PII(elem.second, elem.first));
}
LL cur = 0;
while (!ord.empty())
{
auto val = ord.top();
if (cur + val.first < 0)
return false;
ord.pop();
cur += val.second;
}
return true;
}
bool solve(long long N, std::vector<std::string> S)
{
vector<PII> left, right;
LL parity = 0;
for (auto s : S)
{
auto ret = parse(s);
if (ret[2])
left.emplace_back(ret[0], ret[1]);
else
right.emplace_back(ret[0], ret[1]);
if (ret[2])
parity += ret[0];
else
parity -= ret[0];
}
if (parity != 0)
return false;
return can_construct(left) && can_construct(right);
}
int main()
{
cout << setprecision(10);
long long N;
scanf("%lld", &N);
std::vector<std::string> S(N);
for (int i = 0; i < N; i++)
{
std::cin >> S[i];
}
if (solve(N, std::move(S)))
cout << YES << endl;
else
cout << NO << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
// #undef DEBUG // Uncomment this line to forcefully disable debug print.
#if DEBUG
template <typename T>
void debug(T value) {
std::cerr << value;
}
template <typename T, typename... Ts>
void debug(T value, Ts... args) {
std::cerr << value << ", ";
debug(args...);
}
#define dbg(...) \
do { \
cerr << #__VA_ARGS__ << ": "; \
debug(__VA_ARGS__); \
cerr << " (L" << __LINE__ << ")" << endl; \
} while (0)
#else
#define dbg(...)
#endif
void read_from_cin() {}
template <typename T, typename... Ts>
void read_from_cin(T& value, Ts&... args) {
std::cin >> value;
read_from_cin(args...);
}
#define in(type, ...) \
type __VA_ARGS__; \
read_from_cin(__VA_ARGS__);
template <typename T>
void write_to_cout(const T& value) {
std::cout << value << std::endl;
}
template <typename T, typename... Ts>
void write_to_cout(const T& value, const Ts&... args) {
std::cout << value << ' ';
write_to_cout(args...);
}
#define out(...) write_to_cout(__VA_ARGS__);
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
using ll = long long;
using namespace std;
int main() {
in(int, n, t);
vector<pair<int, int>> f(n);
rep(i, n) cin >> f[i].first >> f[i].second;
sort(all(f));
vector<int> dp(t + 3001);
int ans = 0;
rep(i, n) {
for (int j = t - 1; j >= 0; --j) {
dp[j + f[i].first] = max(dp[j + f[i].first], dp[j] + f[i].second);
ans = max(ans, dp[j + f[i].first]);
}
}
out(ans);
}
| #include<bits/stdc++.h>
using namespace std;
const int N = 123456;
int n, m, color[N];
vector<int> adj[N];
bool visit[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1, x, y; i <= m; ++i) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
int a = 0, b = 0, c = 0, number;
bool ok;
for (int i = 1; i <= n; ++i) {
if (!visit[i]) {
function<void (int, int)> dfs = [&] (int x, int z) {
++number;
visit[x] = true;
color[x] = z;
for (auto y : adj[x]) {
if (!visit[y]) {
dfs(y, !z);
} else if (color[y] != (!z)) {
ok = false;
}
}
};
number = 0;
ok = true;
dfs(i, 0);
if (number == 1) {
++a;
} else if (!ok) {
++b;
} else {
++c;
}
}
}
long long answer = 0;
answer += (long long) a * a;
answer += (long long) a * (n - a) << 1;
answer += (long long) b * b;
answer += (long long) b * c << 1;
answer += (long long) c * c << 1;
cout << answer << '\n';
return 0;
} | 0 |
#include <iostream>
#include <string>
using namespace std;
class Dice{
public:
int l1,l2,l3,l4,l5,l6;
void East(){
int t = l1;
l1 = l4;
l4 = l6;
l6 = l3;
l3 = t;
}
void West(){
int t = l1;
l1 = l3;
l3 = l6;
l6 = l4;
l4 = t;
}
void South(){
int t=l1;
l1 = l5;
l5 = l6;
l6 = l2;
l2 = t;
}
void North(){
int t=l1;
l1 = l2;
l2 = l6;
l6 = l5;
l5 = t;
}
};
int main() {
Dice dice;
int l1,l2,l3,l4,l5,l6;
char d;
cin>>l1>>l2>>l3>>l4>>l5>>l6;
dice.l1 = l1;
dice.l2 = l2;
dice.l3 = l3;
dice.l4 = l4;
dice.l5 = l5;
dice.l6 = l6;
while(cin>>d){
if(d=='E')dice.East();
else if(d=='W')dice.West();
else if(d=='S')dice.South();
else dice.North();
}
cout<<dice.l1<<endl;
} | #include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <array>
using namespace std;
#define DEBUG(x) cerr << #x << " = " << x << endl
enum FACE { TOP, FRONT, RIGHT, LEFT, BACK, BOTTOM }; // 1..6
typedef array<int, 6> Dice;
FACE tbl[6][4] = {
{ TOP, BACK, BOTTOM, FRONT },
{ TOP, RIGHT, BOTTOM, LEFT },
{ TOP, FRONT, BOTTOM, BACK },
{ TOP, LEFT, BOTTOM, RIGHT },
{ FRONT, RIGHT, BACK, LEFT },
{ FRONT, LEFT, BACK, RIGHT }
};
enum MOVE { TOP_TO_BACK, TOP_TO_RIGHT, TOP_TO_FRONT, TOP_TO_LEFT, FRONT_TO_RIGHT, FRONT_TO_LEFT };
void rotate(Dice &d, FACE t[4]) {
int tmp = d[t[3]];
d[t[3]] = d[t[2]]; d[t[2]] = d[t[1]]; d[t[1]] = d[t[0]]; d[t[0]] = tmp;
}
vector<Dice> generate_all(Dice dice) {
vector<Dice> res;
for(int i = 0; i < 6; ++i) {
for(int j = 0; j < 4; ++j) {
res.emplace_back(dice);
rotate(dice, tbl[FRONT_TO_RIGHT]);
}
if(i % 2 == 0) rotate(dice, tbl[TOP_TO_BACK]);
else rotate(dice, tbl[TOP_TO_RIGHT]);
}
return res;
}
int main() {
ios::sync_with_stdio(false);
Dice d;
cin >> d[TOP];
cin >> d[FRONT];
cin >> d[RIGHT];
cin >> d[LEFT];
cin >> d[BACK];
cin >> d[BOTTOM];
string s; cin >> s;
for(char c : s) {
if(c == 'S') {
rotate(d, tbl[TOP_TO_FRONT]);
}
if(c == 'E') {
rotate(d, tbl[TOP_TO_RIGHT]);
}
if(c == 'W') {
rotate(d, tbl[TOP_TO_LEFT]);
}
if(c == 'N') {
rotate(d, tbl[TOP_TO_BACK]);
}
}
cout << d[TOP] << endl;
} | 1 |
#include<bits/stdc++.h>
#define MAXN 1000005
#define P int(998244353)
using namespace std;
typedef long long ll;
int N,M;
ll fac[MAXN], ifac[MAXN];
ll qpow(ll x, int n){
ll res = 1;
while(n){
if(n&1) res = res * x % P;
x = x * x % P;
n /= 2;
}
return res;
}
void init(){
fac[0] = ifac[0] = 1;
for(int i=1;i<=N+M;i++){
fac[i] = fac[i-1] * i % P;
ifac[i] = qpow(fac[i], P-2);
}
}
ll comb(int n, int k){
if(k > n) return 0;
return fac[n] * ifac[k] % P * ifac[n-k] % P;
}
int main(){
// freopen("1.in", "r", stdin);
// freopen("1.ans", "w", stdout);
cin>>N>>M;
if(N < M) swap(N,M);
init();
ll ans = 0;
for(int i=1;i<=M;i++){
ans = (ans + comb(N+M-2*i,M-i) * comb(2*i,i) % P) % P;
}
ans = ans * qpow(comb(N+M, M), P-2) % P * qpow(2, P-2) % P;
ans = (ans + N) % P;
cerr<<"ans = "<<ans<<endl;
printf("%lld\n", ans);
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int n, a[610][610];
void solve(int d)
{
int num = 0;
while(d % 4 == 0)
{
d /= 4;
++num;
}
if(d % 4 == 1)
{
for(int i = 0; i < 2 * n; ++i)
for(int j = 0; j < 2 * n; ++j)
if(((i >> num) + (j >> num)) & 1) a[i][j] = 1;
}
else
{
for(int i = 0; i < 2 * n; ++i)
for(int j = 0; j < 2 * n; ++j)
if((i >> num) & 1) a[i][j] = 1;
}
}
int main()
{
int d1, d2, sum = 0, flag = 0;
scanf("%d", &n);
scanf("%d", &d1); solve(d1);
scanf("%d", &d2); solve(d2);
for(int i = 0; i < 2 * n && !flag; ++i)
for(int j = 0; j < 2 * n && !flag; ++j)
if(!a[i][j])
{
printf("%d %d\n", i, j);
if(++sum == (n * n)) flag = 1;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
int n, m, x, y;
cin >> n >> m >> x >> y;
vector<int> xv(n);
vector<int> yv(m);
int xmax = x;
int ymin = y;
rep(i, n) {
cin >> xv[i];
xmax = max(xmax, xv[i]);
}
rep(i, m) {
cin >> yv[i];
ymin = min(ymin, yv[i]);
}
if(xmax < ymin) cout << "No War" << endl;
else cout << "War" << endl;
return 0;
}
| #include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
void Input(int*,int*);
int Calc(int*,int*);
void Output(int*,int*,int*);
int main(int argc,char* argv[]){
int n,count=0;
int arr[100];
Input(&n,arr);
count=Calc(&n,arr);
Output(&n,&count,arr);
return 0;
}
void Input(int* pn,int *arr){
cin>>*pn;
for(int i=0;i<*pn;i++){
cin>>*arr++;
}
}
int Calc(int* pn,int* arr){
int count=0;
for(int i=0;i<*pn;i++){
for(int j=*pn-1;j>i;j--){
if(arr[j]<arr[j-1]){
swap(arr[j],arr[j-1]);
count++;
}
}
}
return count;
}
void Output(int* pn,int* pcount,int* arr){
printf("%d",*arr++);
for(int i=1;i<*pn;i++)
printf(" %d",*arr++);
puts("");
printf("%d\n",*pcount);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
#define int ll
main(){
ll a,b;
int k;
cin >> a >> b >> k;
for(int i=0;i<k;i++){
if(i%2==0){
a -= a%2;
b += a/2;
a -= a/2;
}else{
b -= b%2;
a += b/2;
b -= b/2;
}
}
cout << a << " " << b << endl;
return 0;
}
| #include <bits/stdc++.h>
#define repp(i,l,r)for(long long i=(l);i<(r);i++)
#define rep(i,n) for (long long i = 0; i < (n); ++i)
#define per(i,n) for (long long i = (n); i >= 0; --i)
const int INF = 2147483647;//int max
const long long int MOD = 1000000007;
using namespace std;
using ll = long long;
using P = pair<int,int>;
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; }
vector<pair<long long, long long> > prime_factorize(long long N) {
vector<pair<long long, long long> > res;
for (long long a = 2; a * a <= N; ++a) {
if (N % a != 0) continue;
long long ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1) res.push_back({N, 1});
return res;
}
//ミョ(-ω- ?)
int main() {
ll a,b;
cin >> a >> b;
auto p = prime_factorize(gcd(a,b));
cout << p.size()+1 << endl;
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <string>
using namespace std;
class XorBase {
public:
explicit XorBase(){}
long long reduce(long long t) const {
for(auto& b : base) t = min(t, t^b);
return t;
}
bool add(long long t){
t = reduce(t);
if(!t) return false;
base.push_back(t);
for(int i=base.size()-2;i>=0;i--) if(base[i] < base[i+1]) swap(base[i], base[i+1]);
return true;
}
long long getMax() const {
long long res = 0;
for(auto& b : base) res = max(res, res^b);
return res;
}
bool represent(long long t) const { return reduce(t) == 0; }
private:
vector<long long> base;
};
int solve(const vector<long long>& A, const string& S){
const int N = A.size();
XorBase xb;
for(int i=N-1;i>=0;i--){
if(S[i] == '0'){
xb.add(A[i]);
} else {
if(!xb.represent(A[i])) return 1;
}
}
return 0;
}
int main(){
int T; cin >> T;
while(T--){
int N; cin >> N;
vector<long long> A(N);
for(auto& t : A) cin >> t;
string S; cin >> S;
cout << solve(A, S) << endl;
}
} | #include<bits/stdc++.h>
using namespace std;
int n;
int a[225];
int main(){
cin>>n;
for(int i=1;i<=2*n;i++)cin>>a[i];
sort(a+1,a+2*n+1);
int summ=0;
for(int i=2*n;i>=1;i-=2){
summ+=a[i-1];
}
cout<<summ;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using LL = long long;
using P = pair<int,int>;
int main(){
string S;
cin >> S;
if(S.size()==2) {
cout << S << endl;
}
else cout << S[2] << S[1] << S[0] << endl;
}
| #include<bits/stdc++.h>
using namespace std;
int main(){
int N,t;
cin >> N;
t=N;
int f=0;
for(int i=0;i<9;i++){
f = f+ (t%10);
t=t/10;
}
if(N%f==0)cout<<"Yes"<<endl;
else cout<<"No"<<endl;
} | 0 |
#include <bits/stdc++.h>
#include <vector>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define size_of_array(array) (sizeof(array)/sizeof(array[0]))
using ll =long long;
using namespace std;
using Graph=vector<vector<int>>;
using Field=vector<vector<int>>;
template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
int main(){
int a[5]={};
rep(i,5)cin>>a[i];
int k;
cin>>k;
for(int i=0;i<5;++i){
for(int j=i+1;j<5;++j){
if(a[j]-a[i]>k){
cout<<":("<<endl;
return 0;
}
}
}
cout<<"Yay!"<<endl;
}
| // lcmとか__builtin_popcountとかはg++ -std=c++17 default.cppみたいなかんじで
#include <bits/stdc++.h>
#define mod 1000000007
#define INF LLONG_MAX
#define ll long long
#define ln cout<<endl
#define Yes cout<<"Yes"<<endl
#define NO cout<<"NO"<<endl
#define YES cout<<"YES"<<endl
#define No cout<<"No"<<endl
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
#define rep(i,n) REP(i,0,n)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
using namespace std;
ll dx[4]={1,0,-1,0};
ll dy[4]={0,1,0,-1};
vector< ll > divisor(ll n) {
vector< ll > ret;
for(ll i = 1; i * i <= n; i++) {
if(n % i == 0) {
ret.push_back(i);
if(i * i != n) ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll a,b,c,d,e,n,k,maxi=0,f=0,mini=INF,sum=0,q;
string str,stra,straa;
ll x,y,z;
char ca,cb,cc;
cin>>a>>b>>c>>d>>e>>k;
if(e-a>k)cout<< ":("<<endl;
else cout<<"Yay!"<<endl;
return 0;
}
| 1 |
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <cctype>
#include <cstdio>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <functional>
#define INF (2 << 28)
#define fr first
#define sc second
using namespace std;
typedef long long ll;
typedef pair<int, int> iP;
int main(){
string s;
int kmax = 0;
cin >> s;
for(int i = 0; i < s.size(); i++){
bool j1, j2;
int cnt = 0;
if(s[i] == 'O'){
j1 = false, j2 = false;
cnt = 1;
for(int j = i + 1; s[j] == 'O' && j < s.size(); j++) cnt++;
for(int j = i - 1, c = 1; s[j] == 'J' && j >= 0; j--, c++){
if(c == cnt){
j1 = true;
break;
}
}
for(int j = i + cnt, c = 1; s[j] == 'I' && j < s.size(); j++, c++){
if(c == cnt){
j2 = true;
break;
}
}
}
if(j1 && j2) kmax = max(kmax, cnt);
i += cnt;
}
cout << kmax << endl;
} | #include <iostream>
#include <algorithm>
#include <map>
#include <string>
#include <set>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <bitset>
#include <random>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <complex>
#include <functional>
using namespace std;
#define rep(i,a,b) for(int i = (a); i < int(b); ++i)
#define rrep(i,a,b) for(int i = (b); i --> int(a);)
#define all(v) v.begin(),v.end()
#define trav(x, v) for(auto &x : v)
#define sz(v) int((v).size())
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef long double ld;
void fail(){
puts("No");
exit(0);
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<vi> a(3, vi(n));
trav(v, a) trav(x, v) cin >> x;
vi perm(n);
bool sign[2] = {};
rep(i,0,n){
int ix = (a[0][i]-1)/3;
if(a[1][i] != 3*ix+2) fail();
if(min(a[0][i], a[2][i]) != 3*ix+1
|| max(a[0][i],a[2][i]) != 3*ix+3) fail();
sign[i&1] ^= a[0][i] > a[2][i];
perm[i] = ix;
if((i+ix)&1) fail();
}
int numofcycles[2] = {};
vector<bool> vis(n);
rep(i,0,n) if(!vis[i]){
++numofcycles[i&1];
int j = i;
do {
vis[j] = 1;
j = perm[j];
} while(j != i);
}
int nn[2] = {n/2+(n&1), n/2};
if(sign[0] != (nn[1]+numofcycles[1])%2
|| sign[1] != (nn[0]+numofcycles[0])%2)
fail();
puts("Yes");
} | 0 |
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
using namespace std;
#define rep(i,a,n) for(int (i)=(a); (i)<(n); (i)++)
#define repq(i,a,n) for(int (i)=(a); (i)<=(n); (i)++)
#define repr(i,a,n) for(int (i)=(a); (i)>=(n); (i)--)
#define all(v) begin(v), end(v)
#define pb(a) push_back(a)
#define fr first
#define sc second
#define INF 2000000000
#define int long long int
#define X real()
#define Y imag()
#define EPS (1e-10)
#define EQ(a,b) (abs((a) - (b)) < EPS)
#define EQV(a,b) ( EQ((a).X, (b).X) && EQ((a).Y, (b).Y) )
#define LE(n, m) ((n) < (m) + EPS)
#define LEQ(n, m) ((n) <= (m) + EPS)
#define GE(n, m) ((n) + EPS > (m))
#define GEQ(n, m) ((n) + EPS >= (m))
typedef vector<int> VI;
typedef vector<VI> MAT;
typedef pair<int, int> pii;
typedef long long ll;
typedef complex<double> P;
typedef pair<P, P> L;
typedef pair<P, double> C;
int dx[]={1, -1, 0, 0};
int dy[]={0, 0, 1, -1};
int const MOD = 1000000007;
ll mod_pow(ll x, ll n) {return (!n)?1:(mod_pow((x*x)%MOD,n/2)*((n&1)?x:1))%MOD;}
int madd(int a, int b) {return (a + b) % MOD;}
int msub(int a, int b) {return (a - b + MOD) % MOD;}
int mmul(int a, int b) {return (a * b) % MOD;}
int minv(int a) {return mod_pow(a, MOD-2);}
int mdiv(int a, int b) {return mmul(a, minv(b));}
namespace std {
bool operator<(const P& a, const P& b) {
return a.X != b.X ? a.X < b.X : a.Y < b.Y;
}
}
signed main() {
int n; cin >> n;
rep(i,0,n) {
int outcnt = 0, ans = 0;
int bit = 0;
while(1) {
string s; cin >> s;
if(s == "OUT") outcnt++;
if(outcnt >= 3) break;
if(s == "HIT") {
if(bit >> 2 & 1) ans++;
bit = (bit << 1 | 1) & ((1 << 3) - 1);
}
else if(s == "HOMERUN") {
ans += (__builtin_popcount(bit) + 1);
bit = 0;
}
}
cout << ans << endl;
}
return 0;
} | #include<iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int main() {
char str[20];
int i, len=0;
cin >> str;
while (str[len])
len++;
for (i = len - 1; i >= 0; i--)
cout << str[i];
putchar('\n');
return 0;
} | 0 |
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define str to_string
#define endl "\n"
#define PI 3.141592653589
using namespace std;
using lint = long long;
template <class T>ostream &operator<<(ostream &o,const vector<T>&v)
{o<<"{";for(int i=0;i<(int)v.size();i++)o<<(i>0?", ":"")<<v[i];o<<"}";return o;}
//AC(*'ω'*)AC(*'ω'*)AC(*'ω'*)AC(*'ω'*)AC(*'ω'*)AC(*'ω'*)AC
int main(){
string s,ans;cin>>s;
if(s.size()!=26){
vector<int> vec(26);
for(char c:s){
vec[(c-'a')]++;
}
for(int i=0;i<26;i++){
if(vec[i]==0){
ans=s+(char)('a'+i);
break;
}
}
}
else{
bool answer=false;
vector<int> vec(26);
for(int i=25;i>=0;i--){
int tmp=s[i]-'a';
vec[tmp]++;
for(int j=tmp+1;j<26;j++){
if(vec[j]){
ans=s.substr(0,i)+(char)('a'+j);
answer=true;
break;
}
}
if(answer)break;
}
if(!answer)ans="-1";
}
cout<<ans<<endl;
}
| #include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<(n);i++)
#define rrep(i,n) for(ll i = 1; i <= (n); ++i)
#define drep(i,n) for(ll i = (n)-1; i >= 0; --i)
#define all(v) v.begin(),v.end()
#define len(x) (ll)(x).length()
#define maxs(x,y) x = max(x,y)
#define mins(x,y) x = min(x,y)
#define pb push_back
#define sz(x) (ll)(x).size()
#define v(T) vector<T>
#define vv(T) vector<vector<T>>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
ll gcd(ll a,ll b){if(a%b==0){return b;}else{return(gcd(b,a%b));}}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
const int INF=1e9;
const ll MX = 1e18;
const ll MOD=INF+7;
const int di[] = {-1,0,1,0};
const int dj[] = {0,-1,0,1};
const double PI=acos(-1);
const string tr="abcdefghijklmnopqrstuvwxyz";
#define dame { puts("-1"); return 0;}
#define yn {puts("Yes");}else{puts("No");}
#define YN {puts("YES");}else{puts("NO");}
const ll MAX = 1000001;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {fac[0] = fac[1] = 1;finv[0] = finv[1] = 1;inv[1] = 1;for (ll 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(ll n, ll k){if (n < k) return 0;if (n < 0 || k < 0) return 0;return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;}
ll llpow(ll n,ll i){ll cnt=n; for(ll j=0;j<i-1;j++){n*=cnt;}return n;}
int main(){
string s;
cin>>s;
int n=len(s);
vi T(26);
string t=tr;
rep(i,n){
rep(j,26){
if(s[i]==t[j]){
T[j]++;
}
}
}
if(n<26){
rep(i,26){
if(T[i]==0){
s+=t[i];
break;
}
}
cout<<s<<endl;
return 0;
}
if(n==26){
vector<char> vec;
for (int i = 0; i < s.size(); ++i) {
vec.push_back(s[i]);
}
if (next_permutation(s.begin(), s.end())) {
string res = "";
for (int i = 0; i < s.size(); ++i) {
res += s[i];
if (vec[i] != s[i]) break;
}
cout << res << endl;
}
else {
cout << -1 << endl;
}
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ALL(x) (x).begin(),(x).end()
#define COUT(x) cout<<(x)<<"\n"
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define REP(i, n) for(int i=0;i<n;i++)
#define YES(x) cout<<(x?"YES":"NO")<<"\n"
#define Yes(x) cout<<(x?"Yes":"No")<<"\n"
#define dump(x) cout<<#x<<" = "<<(x)<<"\n"
#define endl "\n"
using G = vector<vector<int>>;
using M = map<int,int>;
using P = pair<int,int>;
using PQ = priority_queue<int>;
using PQG = priority_queue<int,vector<int>,greater<int>>;
using V = vector<int>;
using ll = long long;
using edge = struct { int to; int cost; };
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; }
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
int main() {
IOS;
int n; cin >> n;
vector<int> a(n);
REP(i,n) cin >> a[i];
vector<int> c(n+1);
c[0] = 3;
ll ans = 1;
REP(i,n) {
ans*=c[a[i]];
ans%=MOD;
c[a[i]]--;
c[a[i]+1]++;
}
COUT(ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
int main() {
int n;
long long int ans = 3;
cin >> n;
int a[n], rgb[3] = {0};
for(int i = 0; i < n; ++i) {
cin >> a[i];
}
if(a[0] != 0) {
cout << 0 << '\n';
return 0;
}
rgb[0] = 1;
for(int i = 1; i < n; ++i) {
int sum = 0;
for(int j = 0; j < 3; ++j) {
if(rgb[j] == a[i]) sum++;
}
ans *= sum;
ans %= MOD;
for(int j = 0; j < 3; ++j) {
if(rgb[j] == a[i]) {
rgb[j]++;
break;
}
}
}
cout << ans << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define ull unsigned long long
#define ld long double
#define vi vector<int>
#define vll vector<ll>
#define vc vector<char>
#define vs vector<string>
#define vpii vector<pii>
#define vpll vector<pll>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define repr(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rep1r(i, n) for (int i = ((int)(n)); i >= 1; i--)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define RSORT(x) sort(rall(x));
#define pb push_back
#define mp make_pair
#define INF (1e9)
#define PI (acos(-1))
#define EPS (1e-7)
ull gcd(ull a, ull b) { return b ? gcd(b, a % b) : a; }
ull lcm(ull a, ull b) { return a / gcd(a, b) * b; }
int main(){
int h1, m1, h2, m2, k;
cin >> h1 >> m1 >> h2 >> m2 >> k;
int t1 = h1 * 60 + m1, t2 = h2 * 60 + m2;
cout << (t2-k-t1) << endl;
return 0;
}
| #include<iostream>
#include<cstdio>
int main() {
int n;
std::cin >> n;
printf("%d\n", n * n * n);
return 0;
} | 0 |
#include <iostream>
#include <algorithm>
using namespace std;
const int MAX_N = 205;
int arr [MAX_N];
int main () {
int n;
cin >> n;
n *= 2;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
int ans = 0;
for (int i = 0; i < n; i += 2) {
ans += arr[i];
}
cout << ans << endl;
}
| #include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
int a[2*n];
for(int i=0;i<2*n;i++)
cin>>a[i];
sort(a,a+2*n);
int sum=0;
for(int i=0;i<2*n-1;i+=2)
sum+=min(a[i],a[i+1]);
cout<<sum;
} | 1 |
#include <bits/stdc++.h>
#define PI 3.14159265359
#define NIL (-1)
#define LL long long
using namespace std;
const int64_t MOD = 1e9 + 7;
const int INF = INT_MAX;
int main() {
int N;
cin >> N;
vector<int> A(N), v(N);
for (int i = 0; i < N; i++) cin >> A[i];
vector<int> C;
for (int i = N - 1; i >= 0; i--) {
int n = i + 1;
int c = 0;
for (int j = i; j < N; j += n) {
if (v[j]) c++;
}
c %= 2;
//cout << c << endl;
v[i] = A[i] - c;
if (v[i]) C.push_back(i + 1);
}
sort(C.begin(), C.end());
cout << C.size() << endl;
if (C.size()) {
for (int i = 0; i < C.size(); i++) {
if (i) cout << ' ';
cout << C[i];
}
cout << endl;
}
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <ratio>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <climits>
#include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/trie_policy.hpp>
#define ll long long
#define ld long double
#define mp make_pair
#define pb push_back
#define in insert
#define vll vector<ll>
#define endl "\n"
#define pll pair<ll,ll>
#define f first
#define s second
#define int ll
#define sz(x) (ll)x.size()
#define all(x) (x.begin(),x.end())
using namespace std;
using namespace __gnu_pbds;
typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> os;
const ll INF = 1e18;
const ll N =(2e5+5); // TODO : change value as per problem
const ll MOD = 1e9+9;
const ll p = 1000003;
long long compute_hash(vll v){
ll ans = 0;
ll p_pow = 1;
for(int i =0;i<5;i++){
ans = (ans + v[i] * p_pow) % MOD;
p_pow = (p_pow * p)%MOD;
}
return ans;
}
ll a[N];
ll cnt[N];
void solve(){
ll n;
cin >> n;
for(int i =1;i<=n;i++) cin >> a[i];
for(int i =n;i>=1;i--){
ll co = 0;
for(ll j = 2*i;j<=n;j+=i){
co += cnt[j];
}
if((co&1) == (a[i]&1)){
cnt[i] = 0;
}
else{
cnt[i] = 1;
}
}
vll ans;
bool poss = true;
for(int i = 1;i<=n;i++){
ll co = 0;
for(int j = i;j<=n;j+=i){
co += cnt[j];
}
if(cnt[i] == 1) ans.pb(i);
poss &= ((co&1) == (a[i]&1));
}
if(!poss){
cout << -1 << endl;
return;
}
cout << sz(ans) << endl;
for(auto x:ans) cout << x << " ";cout << endl;
}
signed main(){
ios_base::sync_with_stdio(0);
cin.tie(NULL);
ll tt=1;
// cin >> tt;
while(tt--){
solve();
}
} | 1 |
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define ll long long
#define INF 1000000000000000000
long long GCD(long long a, long long b) {
if (b == 0)
return a;
else
return GCD(b, a % b);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
vector<ll> A(N);
rep(i, N) {
cin >> A[i];
if (A[i] == K) {
cout << "POSSIBLE" << endl;
return 0;
}
}
ll m = *max_element(all(A));
ll gcd = A[0];
rep(i, N) { gcd = GCD(gcd, A[i]); }
if (m < K) {
cout << "IMPOSSIBLE" << endl;
return 0;
}
if (gcd == 1) {
cout << "POSSIBLE" << endl;
return 0;
}
if (K % gcd == 0) {
cout << "POSSIBLE" << endl;
return 0;
}
cout << "IMPOSSIBLE" << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
///////////////////////////////////////////
const long long int INF = 1LL<<60;
const long long int Mod = 1000000007;
using ll = long long int; using ci = const int;
using vi = vector<int>; using Vi = vector<long long int>;
using P = pair<int, int>; using PLL = pair<ll, ll>;
using matrix = vector<vector<ll>>;
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define all(x) (x).begin(),(x).end()
#define rep(i,N) for(ll i = 0; i < (ll)N; i++)
#define repi(i,a,b) for(ll i = ll(a); i < ll(b); ++i)
template<class T>bool chmax(T &former, const T &b) { if (former<b) { former=b; return true; } return false; }
template<class T>bool chmin(T &former, const T &b) { if (b<former) { former=b; return true; } return false; }
template<class T>T sqar(T x){ return x*x; }//sqrt(x)は平方根;
#define Sort(v) std::sort(v.begin(), v.end(), std::greater<decltype(v[0])>()) //降順でVをソート
#define p_queue(v) priority_queue<v, vector<v>, greater<v> >
template<class T> inline void princ(T x){cout<<x<<" ";};
template<class T> inline void print(T x){cout<<x<<"\n";};
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
template<class T> inline void YES(T condition){ if(condition) cout << "YES" << endl; else cout << "NO" << endl; }
///////////////////////////////////////////////////////////////////////////////////
ll n,m;
Vi a;
ll cal(ll n){
switch(n){
case 1:
return 2;
break;
case 2:
case 3:
case 5:
return 5;
break;
case 4:
return 4;
break;
case 6:
return 6;
break;
case 7:
return 3;
break;
case 8:
return 7;
break;
case 9:
return 6;
break;
default:
return 0;
break;
}
}
vector<string> dp;
int main(){
cin.tie(0);ios::sync_with_stdio(false);
std::cout<<std::fixed<<std::setprecision(30);
cin>>n>>m;
a.resize(m);
rep(i,m){
cin>>a[i];
}
dp.resize(n+10,"-1");
dp[0]="";
rep(i,n){
if(dp[i]=="-1")continue;
rep(j,a.size()){
ll tmp = i+cal(a[j]);
string fig = dp[i]+(char)('0'+a[j]);
string now = dp[tmp];
if(now=="-1" || now.size()<fig.size()){
dp[tmp] = fig;
}else if(now.size()>fig.size()){
}else{
chmax(dp[tmp],fig);
}
}
}
print(dp[n]);
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using LL = long long;
using P = pair<int,int>;
int main(){
int N, K;
cin >> N >> K;
int ans = 0;
for(int i = 1; i <= N - K + 1; ++i) {
ans++;
}
cout << ans << endl;
}
| #include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i=0; i<n; i++)
#define rep1(i, n) for(int i=1; i<=n; i++)
#define repr(i, n) for(int i=n-1; i>=0; i--)
#define repr1(i, n) for(int i=n; i>=1; i--)
#define all(v) v.begin(),v.end()
using ll = long long;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const int INF = 1e9;
const ll LLINF = 1e18;
const ll MOD = 1e9+7;
const double EPS = 1e-10;
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; }
int main() {
int n, k;
cin >> n >> k;
cout << n - k + 1 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define all(a)a.begin(),a.end()
#define rep(i,n) for (int i = 0; i < (n); ++i)
using ll=long long;
const int INF = 1<<30;
const ll INFll =1LL<<62;
const int mod = int(1e9)+7;
using V = vector<ll>;
using P = pair<ll,ll>;
int main()
{
string s;cin >>s;
if(s.size()==3)reverse(all(s));
cout << s<< endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
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;}
int main(){
string s; cin>>s;
if (s[0] == 'R' && s[1] == 'R' && s[2] == 'R') cout << 3 << endl;
else if ((s[0] == 'R' && s[1] == 'R') || (s[1] == 'R' && s[2] == 'R')) cout << 2 << endl;
else if (s[0] == s[1] && s[1] == s[2] && s[0] == 'S') cout << 0 << endl;
else cout << 1 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
string s;
int cnt = 0;
cin >> s;
if (s[0] != 'A')
{
cout << "WA" << endl;
return 0;
}
for (int i = 1; i < s.length(); i++)
{
if (i > 1 && i < s.length() - 1)
{
if (s[i] == 'C')
{
if (cnt == 0)
{
cnt = 1;
continue;
}
else
{
cout << "WA" << endl;
return 0;
}
}
}
if (s[i] - '0' >= 17 && s[i] - '0' <= 42)
{
cout << "WA" << endl;
return 0;
}
}
if (cnt == 0)
{
cout << "WA" << endl;
return 0;
}
cout << "AC" << endl;
} | #include<bits/stdc++.h>
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;
typedef pair<int, int> P;
const ll MOD = 1e9+7, INF = 1e9;
int main()
{
string s; cin >> s;
int n = s.size();
if(s == "zyxwvutsrqponmlkjihgfedcba") {
cout << -1 << endl;
return 0;
}
if(n != 26) {
for(char a = 'a'; a <= 'z'; a++) {
if(count(s.begin(), s.end(), a) == 0) {
cout << s << a << endl;
return 0;
}
}
}
string k = s;
next_permutation(k.begin(), k.end());
for(int i = 0; i < n; i++){
if(s[i] != k[i]) {
cout << k.substr(0, i + 1) << endl;
system("pause");
return 0;
}
}
system("pause");
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
/*
*/
int main() {
string S;
cin >> S;
bool flag = false;
for(int i = 0;i<S.size()-1;i++){
if(S[i] == 'A' && S[i+1] == 'C'){
flag = true;
break;
}
}
if(flag) cout << "Yes" << endl;
else cout << "No" << endl;
} | #include <iostream>
using namespace std;
int main()
{
string test;
getline(cin,test);
if (test[0] == 'A' && test[1] == 'C')
{
cout << "Yes" << endl;
}
else if(test[1] == 'A' && test[2] == 'C')
{
cout << "Yes" << endl;
}
else if(test[2] == 'A' && test[3] == 'C')
{
cout << "Yes" << endl;
}
else if(test[3] == 'A' && test[4] == 'C')
{
cout << "Yes" << endl;
}
else
cout << "No" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
int main() {
ll n, m, i, j, k;
cin >> n >> m;
vector<ll> x(n), y(m);
for(i = 0; i < n; i++) {
cin >> x[i];
}
for(i = 0; i < m; i++) {
cin >> y[i];
}
ll retx = 0;
for(k=0;k<n;k++){
retx = (retx + k*x[k] - (n-1-k)*x[k])%MOD;
}
ll rety=0;
for(k = 0; k < m; k++) {
rety = (rety + k * y[k] - (m - 1 - k) * y[k]) % MOD;
}
cout << (rety*retx)%MOD << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define all(v) (v).begin(),(v).end()
using ll=long long;
using ld=long double;
using pii=pair<int, int>;
using vi=vector<int>;
using vii=vector<vector<int>>;
const ll LINF=1LL<<60;
const int INF=1<<29;
const int MOD=1e9+7;
struct edge{int to, cost;};
template<typename T> bool chmin(T &a,const T b){if(a>b){a=b; return true;}return false;}
template<typename T> bool chmax(T &a,const T b){if(a<b){a=b; return true;}return false;}
template <typename T>
vector<pair<T, T>> prime_factor(T n){
vector<pair<T, T>> ret;
for(T i=2; i*i<=n; i++){
T tmp=0;
while(n%i == 0){
tmp++;
n/=i;
}
if(tmp > 0) ret.push_back({i, tmp});
}
if(n != 1) ret.push_back({n, 1});
return ret;
}
const int MAX=1001001;
ll 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; //i!の計算
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD; //iの逆元の計算
finv[i] = finv[i - 1] * inv[i] % MOD; //i!の逆元の計算
}
}
// 二項係数計算
ll 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(){
ll N, M; cin >> N >> M;
vector<pii> p=prime_factor((int)M);
COMinit();
ll ans=1;
for(int i=0; i<(int)p.size(); i++){
ans=(ans*COM(p[i].second+N-1, N-1))%MOD;
}
cout << ans << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long i,j,k,l,m,n,o,p,q;
while(cin>>m>>n>>o>>p)
{
if(m+n>o+p)
cout<<"Left"<<endl;
else if(m+n<o+p)
cout<<"Right"<<endl;
else
cout<<"Balanced"<<endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int a, b, c, d;
cin >> a >> b >> c >> d;
int left = a + b, right = c + d;
if (left > right) cout << "Left" << "\n";
else if (left < right) cout << "Right" << "\n";
else cout << "Balanced" << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int f = 0, j = 1;
while(N >= (j / 10)){
j *= 10;
f += N % j / (j / 10);
}
if (N % f == 0)
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p_ll;
template<class T>
void debug(T itr1, T itr2) { auto now = itr1; while(now<itr2) { cout << *now << " "; now++; } cout << endl; }
#define repr(i,from,to) for (int i=(int)from; i<(int)to; i++)
#define all(vec) vec.begin(), vec.end()
#define rep(i,N) repr(i,0,N)
#define per(i,N) for (int i=(int)N-1; i>=0; i--)
const ll MOD = pow(10,9)+7;
const ll LLINF = pow(2,61)-1;
const int INF = pow(2,30)-1;
vector<ll> fac;
void c_fac(int x=pow(10,6)+10) { fac.resize(x,true); rep(i,x) fac[i] = i ? (fac[i-1]*i)%MOD : 1; }
ll inv(ll a, ll m=MOD) { ll b = m, x = 1, y = 0; while (b!=0) { int d = a/b; a -= b*d; swap(a,b); x -= y*d; swap(x,y); } return (x+m)%m; }
ll nck(ll n, ll k) { return fac[n]*inv(fac[k]*fac[n-k]%MOD)%MOD; }
ll gcd(ll a, ll b) { if (a<b) swap(a,b); return b==0 ? a : gcd(b, a%b); }
ll lcm(ll a, ll b) { return a/gcd(a,b)*b; }
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
vector<bool> isp;
vector<ll> prime;
void sieve(int x=pow(10,6)+10) {
isp.resize(x,true);
isp[0] = false;
isp[1] = false;
for (int i=2; pow(i,2)<=x; i++) {
if (isp[i]) for(int j=2; i*j<=x; j++) isp[i*j] = false;
}
rep(i,x+1) if (isp[i]) prime.push_back(i);
}
// ----------------------------------------------------------------------
// ----------------------------------------------------------------------
int main() {
sieve();
int N; cin >> N;
int tn = N%2==0 ? N+1 : N;
ll result[tn][tn] = {}; rep(i,tn) fill_n(result[i],tn,1);
rep(i,tn) rep(j,tn) if ((i+j)%2==0) result[i][j] = prime[(i+j)/2] * prime[tn+((tn-1-i)+j)/2];
rep(i,tn) rep(j,tn) {
if ((i+j)%2==1) {
if (i!=0) result[i][j] = lcm(result[i][j], result[i-1][j]);
if (i!=tn-1) result[i][j] = lcm(result[i][j], result[i+1][j]);
if (j!=0) result[i][j] = lcm(result[i][j], result[i][j-1]);
if (j!=tn-1) result[i][j] = lcm(result[i][j], result[i][j+1]);
result[i][j]++;
}
}
// ll r = 0; rep(i,N) rep(j,N) r = max(r, result[i][j]);
// cout << r << endl;
rep(i,N) debug(result[i],result[i]+N);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000010;
const int64_t MOD = 1000000007;
int64_t 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;
}
}
int64_t COM(int64_t n, int64_t k)
{
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
vector<pair<int64_t, int64_t>> prime_factorize(int64_t N)
{
vector<pair<int64_t, int64_t>> res;
for (int64_t a = 2; a * a <= N; a++)
{
if (N % a != 0)
continue;
int64_t ex = 0;
while (N % a == 0)
{
ex++;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1)
res.push_back({N, 1});
return res;
}
int64_t nHk(int64_t n, int64_t k)
{
if (k == 1)
{
return n;
}
return COM(n + k - 1, k);
}
int main()
{
int64_t N, M, ans = 1;
cin >> N >> M;
const auto &res = prime_factorize(M);
COMinit();
for (auto p : res)
{
(ans *= nHk(N, p.second)) %= MOD;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
vector<int> primes={2,3,5,7};
int primes_extend(int calc_from, int calc_to);
int factoring(int n, map<int,int> &factors);
const int combination_max=100000+1000;
const int combination_modulo=1000000007;
vector<int64_t> factorials(combination_max);
vector<int64_t> factorials_inv(combination_max);
vector<int64_t> inverse(combination_max);
int combination_mod(int n, int k);
int prepare_combination_mod();
int main()
{
int n,m;
cin >> n >> m;
primes_extend(10,100);
primes_extend(100,10000);
primes_extend(10000,32767);
map<int,int> factors;
factoring(m,factors);
for (pair<int,int> p:factors)
{
// fprintf(stderr,"%d: %d\n",p.first,p.second);
}
prepare_combination_mod();
int64_t patterns=1;
for (pair<int,int> p:factors)
{
int c=combination_mod(p.second+n-1,n-1);
// fprintf(stderr,"%d: %d patterns\n",p.first,c);
patterns*=c;
patterns%=combination_modulo;
}
cout << patterns << endl;
}
int primes_extend(int calc_from, int calc_to)
{
for (int i=calc_from;i<=calc_to;++i)
{
int j;
int loop_max=sqrt(i);
for (j=0;(primes[j]<=loop_max)&&(j<primes.size());++j)
{
if ((i%primes[j])==0)
{
// not prime...
break;
}
}
if ((j>=primes.size())||(primes[j]>loop_max))
{
primes.push_back(i);
}
}
//fprintf(stderr,"count: %d\n",primes.size());
}
int factoring(int n, map<int,int> &factors)
{
int maxfactor=sqrt(n);
for (int i=0;(n>1)&&(primes[i]<=maxfactor);++i)
{
while ((n%primes[i])==0)
{
n/=primes[i];
factors[primes[i]]++;
}
}
if (n!=1)
{
factors[n]++;
}
return 0;
}
int prepare_combination_mod()
{
factorials[0]=1;
factorials[1]=1;
factorials_inv[0]=1;
factorials_inv[1]=1;
inverse[1]=1;
for (int i=2;i<combination_max;++i)
{
factorials[i]=factorials[i-1]*i%combination_modulo;
inverse[i]=combination_modulo - inverse[combination_modulo%i]*(combination_modulo/i)%combination_modulo;
factorials_inv[i]=factorials_inv[i-1]*inverse[i]%combination_modulo;
}
}
int combination_mod(int n, int k)
{
return factorials[n]*(factorials_inv[k]*factorials_inv[n-k]%combination_modulo)%combination_modulo;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll unsigned long long int
#define mod 1000000007
bool isPrime[1000001];
ll power(ll a,ll b)
{
ll result = 1;
while(b>0)
{
if(b%2)
{
result = (a*result)%mod;
}
a = (a*a)%mod;
b = b/2;
}
return result;
}
int gcd(int a,int b)
{
if(b==0)
{
return a;
}
return gcd(b,a%b);
}
void sieve()
{
memset(isPrime,1,sizeof(isPrime));
isPrime[0] = isPrime[1] = 0;
for(int i=2;i*i<=1000000;i++)
{
if(isPrime[i])
{
for(int j=i*i;j<=1000000;j+=i)
{
isPrime[j] = 0;
}
}
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL),cout.tie(NULL);
int t,n;
t = 1;
for(int i=0;i<t;i++)
{
int n,k;
cin>>n>>k;
double arr[n];
for(int i=0;i<n;i++)
{
cin>>arr[i];
arr[i] = (arr[i]+1)/2;
}
double sum = 0;
for(int i=0;i<k;i++)
{
sum+=arr[i];
}
double maxi = sum;
for(int i=k;i<n;i++)
{
sum+=arr[i];
sum-=arr[i-k];
maxi = max(sum,maxi);
}
cout<<fixed<<setprecision(15)<<maxi;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define all(a) a.begin(), a.end()
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<ll,int> pli;
typedef pair<int,int> pii;
#define rep(i,a,b) for(ll i=a ; i<b ; i++)
#define qrep(que, ite) for(auto ite=begin(que) ; ite!=end(que) ; ite++)
const int max_n = 1e5;
const ll mod = 1e9+7;
const ll INF = 1e17;
const int inf = 1e5;
typedef long double ld;
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; }
ll gcd(ll a, ll b) { return a ? gcd(b%a, a) : b; }
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) { }
void init(int n) { par.assign(n, -1); }
int root(int x) {
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
bool issame(int x, int y) {
return root(x) == root(y);
}
bool merge(int x, int y) {
x = root(x); y = root(y);
if (x == y) return false;
if (par[x] > par[y]) swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) {
return -par[root(x)];
}
};
struct SegmentTree{
int N;
vector<int> node;
public :
void intit(vector<int>v){
int sz = v.size();
N=1;
while(N<sz) N*=2;
node.resize(N);
for(int i=0 ; i<sz ; i++) node[i+N-1] = v[i];
for(int i=N-2 ; i>=0 ; i--) node[i] = min(node[i*2+1], node[i*2+2]);
}
void update(int x, int val){
x += N-1;
node[x+N-1] = val;
while(x>0){
x = (x-1)/2;
node[x] = min(node[x*2+1], node[x*2+2]);
}
}
int getmin(int a, int b, int k, int l, int r){
if(b<=l || r<=a) return inf;
else if(a<=l && r<=b) return node[k];
else{
int vl = getmin(a, b, 2*k+1, l, (l+r)/2);
int vr = getmin(a, b, 2*k+2, (l+r)/2, r);
return min(vl, vr);
}
}
};
int main(){
ll N,K; cin>>N>>K;
vector<ll> v(N);
rep(i,0,N){
cin >> v[i];
v[i]++;
}
vector<ll> v2(N+1, 0);
rep(i,0,N) v2[i+1] = v2[i] + v[i];
ll res = 0;
for(ll i=0 ; i+K<=N ; i++){
chmax(res, v2[i+K] - v2[i]);
}
printf("%.7f", (double)res/2);
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define de(x) cout << #x << "=" << x << ", "
#define dd cout << '\n';
#define XinAi ios::sync_with_stdio(0), cin.tie(0);
#define F first
#define S second
using namespace std;
typedef pair<int,int> pii;
const int N = 1e4+10;
string dp[N], val[15];
string num = "123456789";
int c[] = {2,5,5,4,5,6,3,7,6}, cs[200], n, m;
string a[15];
void update (string &x, string y, string z)
{
if (x.size() > y.size() + 1) return;
if (z[0] > y[0]) z += y, swap(y, z);
else y += z;
if (x.size() < y.size()) x = y;
else
{
for (int i=0; i<x.size(); i++)
{
if (x[i] > y[i]) return;
else if (x[i] < y[i])
{
x = y;
break;
}
}
}
}
signed main()
{
XinAi
for (int i=0; i<9; i++) cs[num[i]] = c[i];
cin >> n >> m;
for (int i=0; i<m; i++) cin >> a[i];
for (int i=0; i<n; i++)
for (int j=0; j<m; j++)
{
if (i!=0 && dp[i]=="") continue;
update(dp[i+cs[a[j][0]]], dp[i], a[j]);
}
cout << dp[n] << '\n';
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < int(n); i++)
#define rrep(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define reps(i, n) for (int i = 1; i <= int(n); i++)
#define rreps(i, n) for (int i = int(n); i >= 1; i--)
#define repc(i, n) for (int i = 0; i <= int(n); i++)
#define rrepc(i, n) for (int i = int(n); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define repic(i, a, b) for (int i = int(a); i <= int(b); i++)
#define each(x, y) for (auto &x : y)
#define all(a) (a).begin(), (a).end()
#define bit32(x) (1 << (x))
#define bit64(x) (1ll << (x))
using namespace std;
using i32 = int;
using i64 = long long;
using f80 = long double;
using vi32 = vector<i32>;
using vi64 = vector<i64>;
using vf80 = vector<f80>;
using vstr = vector<string>;
inline void yes() { cout << "Yes" << '\n'; exit(0); }
inline void no() { cout << "No" << '\n'; exit(0); }
inline i64 gcd(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); if (a % b == 0) return b; return gcd(b, a % b); }
inline i64 lcm(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); return a / gcd(a, b) * b; }
template <typename T> class pqasc : public priority_queue<T, vector<T>, greater<T>> {};
template <typename T> class pqdesc : public priority_queue<T, vector<T>, less<T>> {};
template <typename T> inline void amax(T &x, T y) { if (x < y) x = y; }
template <typename T> inline void amin(T &x, T y) { if (x > y) x = y; }
template <typename T> inline T exp(T x, i64 n, T e = 1) { T r = e; while (n > 0) { if (n & 1) r *= x; x *= x; n >>= 1; } return r; }
template <typename T> istream& operator>>(istream &is, vector<T> &v) { each(x, v) is >> x; return is; }
template <typename T> ostream& operator<<(ostream &os, vector<T> &v) { rep(i, v.size()) { if (i) os << ' '; os << v[i]; } return os; }
void solve(); int main() { ios::sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(16); solve(); return 0; }
void solve() {
int n;
cin >> n;
string s;
cin >> s;
int q;
cin >> q;
rep(_, q) {
int k;
cin >> k;
i64 d = 0;
i64 m = 0;
i64 dm = 0;
i64 ans = 0;
for (int r = 1; r <= n; r++) {
if (s[r - 1] == 'D') {
d++;
} else if (s[r - 1] == 'M') {
m++;
dm += d;
}
if (r - k > 0) {
int rem = r - k - 1;
if (s[rem] == 'D') {
d--;
dm -= m;
} else if (s[rem] == 'M') {
m--;
}
}
if (s[r - 1] == 'C') {
ans += dm;
}
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main()
{
ll n;
cin >> n;
vector<ll> a(n);
vector<ll> b(n);
vector<ll> c(n);
rep(i, n) cin >> a[i];
rep(i, n) cin >> b[i];
rep(i, n) cin >> c[i];
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
ll ans = 0;
rep(i, n) {
ll x = lower_bound(a.begin(), a.end(), b[i]) - a.begin();
ll y = c.end() - upper_bound(c.begin(), c.end(), b[i]);
ans += x * y;
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int N,cnt = 0;
cin >> N;
int bubble[N];
for(int i=0;i<N;i++){
cin >> bubble[i];
}
double flag = true;
while(flag){
flag = false;
for(int j=N-1;j>=1;j--){
if(bubble[j] < bubble[j-1]){
swap(bubble[j],bubble[j-1]);
cnt++;
flag = 1;
}
}
}
for(int i=0;i<N;i++){
if(i!= N-1){
cout << bubble[i] << " ";
}
else{
cout << bubble[i] << endl;
}
}
cout << cnt << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pll pair<ll,ll>
#define left 2*node+1
#define right left+1
#define mid (s+e>>1)
const ll N=5e5+5;
vector<ll> T[4*N];
void build(ll A[], ll node, ll s, ll e){
if(s==e){
T[node].push_back(A[s]);
return;
}
build(A, left, s, mid);
build(A, right, mid+1, e);
merge(T[left].begin(), T[left].end(), T[right].begin(), T[right].end(), back_inserter(T[node]));
}
ll query(ll node,ll s, ll e, ll x, ll y){
if(e<s || s>y || e<x)
return 0;
if(x<=s && e<=y){
ll a=upper_bound(T[node].begin(), T[node].end(), y)-T[node].begin();
return T[node].size()-a;
}
ll p1=query(left, s, mid, x, y);
ll p2=query(right, 1+mid,e, x, y);
return p1+p2;
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n, q;
cin>>n>>q;
ll A[n];
ll B[n];
for(ll i=0;i<n;i++)
cin>>A[i];
map<ll,ll> M;
for(ll i=n-1;i>=0;i--){
if(M.count(A[i]))
B[i]=M[A[i]];
else
B[i]=INT_MAX;
M[A[i]]=i;
}
build(B,0,0, n-1);
while(q--){
ll x, y;
cin>>x>>y;
ll ans=query(0,0,n-1,x-1,y-1);
cout<<ans<<"\n";
}
}
| #include<bits/stdc++.h>
using namespace std;
int main()
{
int D, G, p[11], c[11];
cin >> D >> G;
for (int i = 0; i < D; ++i)
cin >> p[i] >> c[i];
int ans = 1e9;
for (int mask = 0; mask < 1 << D; ++mask)
{
int sum = 0, num = 0;
for (int i = 0; i < D; ++i)
{
if (mask & 1 << i)
{
sum += (i + 1) * 100 * p[i] + c[i];
num += p[i];
}
}
if (sum >= G)
{
ans = min(ans, num);
}
else
{
for (int i = D - 1; i >= 0; --i)
{
if (mask & 1 << i)
{
continue;
}
for (int j = 0; j < p[i]; j++)
{
if (sum >= G)
{
break;
}
sum += 100 * (i + 1);
num++;
}
}
ans = min(ans, num);
}
}
cout << ans << endl;
}
| 0 |
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
int n, k;
int a[10];
int v[10000] = {};
int s;
void set_vec(int t, int f, int sum) {
if(t>=k) {
v[s] = sum;
s++;
}else {
for(int i=0;i<n;i++) {
if((1<<i) & f)continue;
set_vec(t+1, f+(1<<i), sum*(a[i]<10?10:100)+a[i]);
}
}
}
int main() {
while(1) {
scanf("%d", &n);
scanf("%d", &k);
if(n==0 && k==0)break;
s = 0;
for(int i=0;i<n;i++) {
scanf("%d", &a[i]);
}
set_vec(0, 0, 0);
sort(v, v+s);
int t = 0;
int sum = 0;
for(int i=0;i<s;i++) {
if(t==v[i])continue;
sum++;
t=v[i];
}
printf("%d\n", sum);
}
return 0;
} | #include <cstdio>
int main(){
int n, table[20][20];
while( scanf("%d", &n) , n ){
for(int i=0 ; i<20 ; i++){
for(int j=0 ; j<20 ; j++){
table[i][j] = 0;
}
}
for(int i=0 ; i<n ; i++){
for(int j=0 ; j<n ; j++){
scanf("%d", &table[i][j]);
}
}
for(int i=0 ; i<n ; i++){
for(int j=0 ; j<n ; j++){
table[i][n] += table[i][j];
table[n][j] += table[i][j];
}
}
for(int i=0 ; i<n ; i++){
table[n][n] += table[n][i];
}
for(int i=0 ; i<=n ; i++){
for(int j=0 ; j<=n ; j++){
printf("%5d", table[i][j]);
}
printf("\n");
}
}
return 0;
} | 0 |
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
int size;
cin >> size;
long long a[size];
int i;
for(i=0; i<size; i++){
cin >> a[i];
}
long long max=0;
for(i=0; i<size; i++){
if(max < a[i] || i==0){
max = a[i];
}
else{
}
}
long long min=0;
for(i=0; i<size; i++){
if(min > a[i] || i==0){
min = a[i];
}
else{
}
}
long long sum=0;
for(i=0; i<size; i++){
sum+= a[i];
}
cout << min << " " << max << " " << sum << endl;
return 0;
}
| #include <stdio.h>
const static int MAX = 100;
void print(int *array, int n){
for(int i=0;i<n;i++){
printf("%d", array[i]);
if(i<n-1) printf(" ");
}
printf("\n");
}
int bubble_sort(int *array, int n){
bool flag = true;
int k, count=0;
while(flag){
flag = false;
for(int i=n-1;i>0;i--){
if(array[i] < array[i-1]){
k = array[i-1];
array[i-1] = array[i];
array[i] = k;
flag = true;
count++;
}
}
}
print(array, n);
return count;
}
int main(){
int n, array[MAX], c;
scanf("%d", &n);
for(int i=0;i<n;i++){
scanf("%d", &array[i]);
}
c = bubble_sort(array, n);
printf("%d\n", c);
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
#include <map>
#include <vector>
#include <string>
#include <cstdio>
#include <cmath>
using namespace std;
int c[5];// card
bool straight()
{
if(c[4]==13 && c[3]==12 && c[2]==11 && c[1]==10 && c[0]==1)
return true;
for(int i=0; i<4; i++) {
if(c[i+1] - c[i] != 1)
return false;
}
return true;
}
int main(void)
{
while(~scanf("%d,%d,%d,%d,%d", c, c+1, c+2, c+3, c+4)) {
sort(c, c+5);
if(c[0] == c[3] || c[1] == c[4]) {
puts("four card");
} else if((c[0] == c[2] && c[3] == c[4]) ||
(c[0] == c[1] && c[2] == c[4])) {
puts("full house");
} else if(straight()) {
puts("straight");
} else if(c[0]==c[2] || c[1]==c[3] || c[2]==c[4]) {
puts("three card");
} else if((c[0]==c[1] && (c[2]==c[3] || c[3]==c[4])) ||
(c[1]==c[2] && c[3]==c[4])) {
puts("two pair");
} else if(c[0]==c[1] || c[1]==c[2] || c[2]==c[3] || c[3]==c[4]) {
puts("one pair");
} else {
puts("null");
}
}
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <cstdio>
#include <string>
#define rep(x,to) for(int x=0;x<to;x++)
#define rep2(x,from,to) for(int x=from;x<to;x++)
using namespace std;
int main(void){
int cd[5]={0},cnt=0;
char k;
while(!cin.eof()){
cin >> cd[0] >> k >>cd[1] >>k >>cd[2] >>k >>cd[3] >>k >>cd[4];
if(cin.eof()) break;
sort(cd,cd+5);
int mxp=0,cn1,cn2=0;
rep(i,5){
cn1=0;
rep2(j,i+1,5) if(cd[i]==cd[j]) cn1++;
cn2 += cn1;
mxp = max(mxp,cn1);
}
// printf("%d,%d\n",mxp,cn2);
string yak = "straight";
rep(i,4) if(cd[i] +1 != cd[i+1]) yak="null";
if(cd[0]==1 && cd[1]==10 && cd[2]==11 && cd[3]==12 && cd[4]==13)
yak = "straight";
if(mxp==1 && cn2==1) yak ="one pair";
if(mxp==1 && cn2==2) yak ="two pair";
if(mxp==2 && cn2==3) yak ="three card";
if(mxp==2 && cn2==4) yak ="full house";
if(mxp==3) yak ="four card";
cout << yak << endl;
cnt++; if(cnt>50) break;
}
return 0;
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.