code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 32
101M
|
|---|---|---|---|
#include<iostream>
#include<algorithm>
using namespace std;
int data[101];
int mod[101];
void ini(void){
for(int i=0;i<101;i++){
data[i]=0;
mod[i]=0;
}
}
main(){
int max=0;
int j;
j=0;
int in;
while(cin >> in){
for(int i=0;i<101;i++){
if(in == i){
data[i]++;
break;
}
}
j++;
}
for(int i=0;i<101;i++){
if(max < data[i])max=data[i];
}
for(int i=0;i<101;i++){
if(data[i]==max)cout << i << endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <iomanip>
#include <utility>
#include <tuple>
#include <functional>
#include <bitset>
#include <cassert>
#include <time.h>
#define int long long
#define endl '\n'
#define INF 1000000000000000000
#define all(a) a.begin(),a.end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define fi first
#define se second
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<ll, P> PP;
template<class T, class S> bool chmax(T &a, const S &b) { if (a < b) { a = b; return 1; } return 0; }
template<class T, class S> bool chmin(T &a, const S &b) { if (a > b) { a = b; return 1; } return 0; }
ll gcd(ll n, ll m) { return (m ? gcd(m, n%m) : n); }
ll lcm(ll n, ll m) { return n / gcd(n, m)*m; }
ll mod = 1000000007;
ll modsize;
ll modinv(ll a) {
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= mod;
if (u < 0) u += mod;
return u;
}
ll modpow(ll a, ll b) {
ll ans = 1;
a %= mod;
while (b) {
if (b & 1) ans = ans * a%mod;
a = a * a%mod;
b >>= 1;
}
return ans;
}
vector<ll> fac(modsize + 5);
vector<ll> inv(modsize + 5);
vector<ll> facinv(modsize + 5);
void modcalc() {
fac[0] = fac[1] = 1; inv[1] = 1;
facinv[0] = facinv[1] = 1;
for (int i = 2; i < modsize; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod%i] * (mod / i) % mod;
facinv[i] = facinv[i - 1] * inv[i] % mod;
}
}
ll modcomb(ll n, ll k) {
if (n < 0 || k < 0 || n < k) return 0;
return fac[n] * facinv[k] % mod * facinv[n - k] % mod;
}
ll modperm(ll n, ll k) {
if (n < 0 || k < 0 || n < k) return 0;
return fac[n] * facinv[n - k] % mod;
}
ll modhom(ll n, ll k) {
if (n < 0 || k < 0) return 0;
if (n == 0 && k == 0) return 1;
return modcomb(n + k - 1, k);
}
template<class T>
class segtree {
int n;
vector<T> data;
T def;
function<T(T, T)> operation;
function<T(T, T)> update;
T _query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) return def;
if (a <= l && r <= b) return data[k];
T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2);
T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r);
return operation(c1, c2);
}
public:
segtree(size_t _n, T _def, function<T(T, T)> _operation, function<T(T, T)> _update)
:def(_def), operation(_operation), update(_update) {
n = 1;
while (n < _n) {
n *= 2;
}
data = vector<T>(2 * n - 1, def);
}
void change(int i, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
T query(int a, int b) {
return _query(a, b, 0, 0, n);
}
T operator[](int i) {
return data[i + n - 1];
}
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
modcalc();
int n, k;
cin >> n >> k;
vector<int> a(n);
rep(i, n) cin >> a[i];
int ans = 0;
vector<int> b(n);
rep(i, n) b[i] = max(0LL, a[i]);
int sum = 0;
rep(i, n) sum += b[i];
int cnt = 0, cnta = 0;
rep(i, k) {
cnt += b[i];
cnta += a[i];
}
rep(i, n - k) {
chmax(ans, sum - cnt + max(0LL, cnta));
cnt -= b[i];
cnt += b[i + k];
cnta -= a[i];
cnta += a[i + k];
}
chmax(ans, sum - cnt + max(0LL, cnta));
cout << ans << endl;
}
| 0
| 7,387,005
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep2(i, x ,n) for(int i = x; i < n; i++)
#define repr(i, n) for(int i = n; i >= 0; i--)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int main(){
int n;
cin >> n;
int ans = 0;
int count = 0;
rep2(i,1,n+1){
if(i%2!=0){
rep2(j,1,n+1){
if(i%j==0)count++;
}
}
if(count==8)ans++;
count = 0;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main () {
set<int> s;
for (int i = 0; i < 3; i++) {
int a;
cin >> a;
s.insert(a);
}
if (s.size() == 1) {
puts("Yes");
}
else {
puts("No");
}
}
| 0
| 13,069,025
|
#include <iostream>
#include <string>
#include <array>
#include <algorithm>
#include <vector>
#include <string>
#include <set>
#include <cctype>
#include <map>
#include <stdio.h>
#include <string.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
\
#define FOR(i,l,r) for(size_t i=(l);i<(r);++i)
#define REP(i,n) FOR(i,0,n)
using namespace std;
int main() {
int n,a,b;
int ans = 0;
cin >> n >> a >> b;
for(int i = 1; i <=n; i ++){
string tmp = to_string(i);
int val = 0;
for(int j = 0; j < tmp.length(); j ++){
val += (int)(tmp[j] - '0');
}
if(val >= a && val <= b) ans += i;
}
cout << ans;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define mod (int)(1e9 + 7)
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
ll n,m;
cin>>n>>m;
ll arr1[n],arr2[m];
for(ll i=0;i<n;i++)
cin>>arr1[i];
for(ll j=0;j<m;j++)
cin>>arr2[j];
ll dp[n + 1][m + 1];
for (ll i = 0; i <= n; i++)
dp[i][0] = 1;
for (ll j = 0; j <= m; j++)
dp[0][j] = 1;
for (ll i = 1; i <= n; ++i) {
for (ll j = 1; j <= m; ++j) {
dp[i][j] = dp[i - 1][j]
+ dp[i][j - 1]
- dp[i - 1][j - 1];
if (arr1[i - 1] == arr2[j - 1])
dp[i][j] += dp[i - 1][j - 1];
dp[i][j] += mod;
dp[i][j] %= mod;
}
}
cout<<dp[n][m];
return 0;
}
| 0
| 30,855,165
|
#include <iostream>
#include <stdio.h>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <map>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int N,M;
char c;
int A[55][55];
int B[55][55];
cin >> N >> M;
rep(i, N) {
rep(j, N) {
cin >> c;
if (c == '#') A[i][j] = 0;
else A[i][j] = 1;
}
}
rep(i, M) {
rep(j, M) {
cin >> c;
if (c == '#') B[i][j] = 0;
else B[i][j] = 1;
}
}
rep(i, N-M+1) {
rep(j, N-M+1) {
int k,l;
bool f = true;
for(k=0; k < M; k++) {
for (l=0; l < M; l++) {
if (A[i+k][j+l] != B[k][l]) {f=false;break;}
}
if (!f) break;
}
if (f) {cout << "Yes" << endl; return 0;}
}
}
cout << "No" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(M), B(M);
for(int i = 0; i < M; i++) {
cin >> A[i] >> B[i];
A[i]--;
B[i]--;
}
vector<vector<int>> s(2000001);
bool hantei[2000001];
int prev[2000001] = {0};
int ans[2000001] = {0};
for(int i = 0; i < M; i++) {
s[A[i]].push_back(B[i]);
s[B[i]].push_back(A[i]);
}
if(s[0].size() == 0) { cout << "No" << endl; return 0; }
queue<int> q;
q.push(0);
hantei[0] = true;
while(!q.empty()) {
int num = q.front(); q.pop();
for(auto i : s[num]) {
if(!hantei[i]) {
hantei[i] = true;
ans[i] = num;
q.push(i);
}
}
}
printf("Yes\n");
for(int i = 1; i < N; i++) {
cout << ans[i] + 1 << endl;
}
return 0;
}
| 0
| 88,141,787
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<pll> vpll;
#define INX(x) (cin >> x)
#define OUTX(x) (cout << x << endl)
#define ADD emplace_back
#define MP make_pair
#define VVEC(type) vector<vector<type>>
int main()
{
ll H, W, M;
cin >> H >> W >> M;
vpll bomb;
vll rcount(H+1, 0);
vll ccount(W+1, 0);
for (ll i = 0; i < M; i++)
{
ll tmp1, tmp2;
cin >> tmp1 >> tmp2;
rcount[tmp1]++;
ccount[tmp2]++;
bomb.ADD(MP(tmp1,tmp2));
}
ll rmax = 0;
vll rmaxindex;
for (ll i = 1; i <= H; i++)
{
if(rmax < rcount[i])
{
rmax = rcount[i];
rmaxindex.resize(0);
rmaxindex.ADD(i);
}
else if(rmax == rcount[i])
{
rmaxindex.ADD(i);
}
}
ll cmax = 0;
vll cmaxindex;
for (ll i = 1; i <= W; i++)
{
if(cmax < ccount[i])
{
cmax = ccount[i];
cmaxindex.resize(0);
cmaxindex.ADD(i);
}
else if(cmax == ccount[i])
{
cmaxindex.ADD(i);
}
}
sort(bomb.begin(), bomb.end());
ll result = rmax + cmax;
bool isFound = false;
for(auto x : rmaxindex)
{
for(auto y : cmaxindex)
{
if(binary_search(bomb.begin(), bomb.end(), MP(x, y)))
{
continue;
}
else
{
isFound = true;
break;
}
}
if(isFound)
{
break;
}
}
cout << (isFound ? result : result - 1) << endl;
return 0;
}
|
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
#define double long double
using datas=pair<ll,ll>;
using ddatas=pair<double,double>;
using tdata=pair<ll,datas>;
using vec=vector<ll>;
using mat=vector<vec>;
using pvec=vector<datas>;
using pmat=vector<pvec>;
#define For(i,a,b) for(i=a;i<(ll)b;i++)
#define bFor(i,b,a) for(i=b-1;i>=(ll)a;i--)
#define rep(i,N) For(i,0,N)
#define rep1(i,N) For(i,1,N)
#define brep(i,N) bFor(i,N,0)
#define all(v) (v).begin(),(v).end()
#define allr(v) (v).rbegin(),(v).rend()
#define vsort(v) sort(all(v))
#define vrsort(v) sort(allr(v))
#define endl "\n"
#define pb push_back
#define eb emplace_back
#define print(v) cout<<v<<endl
#define printyes cout<<"Yes"<<endl
#define printno cout<<"No"<<endl
#define printYES cout<<"YES"<<endl
#define printNO cout<<"NO"<<endl
#define output(v) do{bool f=0;for(auto outi:v){cout<<(f?" ":"")<<outi;f=1;}cout<<endl;}while(0)
const ll mod=1000000007;
const ll inf=1LL<<60;
const double PI = acos(-1);
const double eps = 1e-9;
template<class T> inline bool chmax(T& a,T b){bool x=a<b;if(x)a=b;return x;}
template<class T> inline bool chmin(T& a,T b){bool x=a>b;if(x)a=b;return x;}
void startupcpp(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(15);
}
double distance(ddatas x,ddatas y){
double a=x.first-y.first,b=x.second-y.second;
return sqrt(a*a+b*b);
}
ll modinv(ll a) {
ll b=mod,u=1,v=0,t;
while(b){
t=a/b;
a-=t*b; swap(a,b);
u-=t*v; swap(u,v);
}
return (u+mod)%mod;
}
ll moddevide(ll a,ll b){return (a*modinv(b))%mod;}
vec modncrlistp,modncrlistm;
ll modncr(ll n,ll r){
if(n<r)return 0;
ll i,size=modncrlistp.size();
if(size<=n){
modncrlistp.resize(n+1);
modncrlistm.resize(n+1);
if(!size){
modncrlistp[0]=modncrlistm[0]=1;
size++;
}
For(i,size,n+1){
modncrlistp[i]=modncrlistp[i-1]*i%mod;
modncrlistm[i]=modinv(modncrlistp[i]);
}
}
return modncrlistp[n]*modncrlistm[r]%mod*modncrlistm[n-r]%mod;
}
ll modpow(ll a,ll n){
ll res=1;
while(n>0){
if(n&1)res=res*a%mod;
a=a*a%mod;
n>>=1;
}
return res;
}
ll gcd(ll a,ll b){if(!b)return a;return (a%b==0)?b:gcd(b,a%b);}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
ll countdigits(ll n){
ll ans=0;
while(n){n/=10;ans++;}
return ans;
}
ll sumdigits(ll n){
ll ans=0;
while(n){ans+=n%10;n/=10;}
return ans;
}
int main(){
ll i,j,N,K,ans=0,sum=0;
cin>>N>>K;
vec v(N);
rep(i,N){
cin>>v[i];
sum+=v[i];
chmin(v[i],K);
}
if(sum<K){
print(N);
return 0;
}
vector<vector<int>> l(N+1,vector<int>(K,0)),r(N+1,vector<int>(K,0));
l[0][0]=r[N][0]=1;
rep(i,N)rep(j,K){
l[i+1][j]|=l[i][j];
if(j>=v[i])l[i+1][j]|=l[i][j-v[i]];
}
brep(i,N)rep(j,K){
r[i][j]|=r[i+1][j];
if(j>=v[i])r[i][j]|=r[i+1][j-v[i]];
}
rep(i,N){
if(v[i]==K)continue;
rep1(j,K)l[i][j]+=l[i][j-1];
rep(j,K)if(r[i+1][j]){
if(j>=K-v[i])break;
if(l[i][min(max(K-j-1,0LL),K-1)]-l[i][min(max(K-j-v[i]-1,0LL),K-1)])break;
}
ans+=j==K;
}
print(ans);
return 0;
}
| 0
| 81,087,378
|
#include <stdio.h>
#include <iostream>
#include <queue>
#include <map>
#include <string>
#include <vector>
#define PB push_back
#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define REP(i,n) for (int i=0;i<(n);i++)
#define RREP(i,n) for (int i=(n)-1;i>=0;i--)
using namespace std;
int n,tmp;
void solve(){
while(cin >> n && n!= 0){
vector <int> data ;
REP(i,n){
cin >> tmp;
data.PB(tmp);
}
int sofar = 0 ,end = 0;
REP(i,n){
end = max(end+data[i],0);
sofar = max(end,sofar);
}
if(sofar == 0){
sofar = -10000000;
REP(i,n)sofar = max(sofar,data[i]);
}
cout << sofar <<endl;
}
}
int main(){
solve();
}
|
#include <bits/stdc++.h>
#include <math.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rrep(i, n) for(int i = 0; i <= (n); i++)
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
const ll INF = 1LL<<60;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
using Graph = vector<vector<int>>;
typedef pair<int, int> P;
int main(){
int X, Y, A, B, C; cin >> X >> Y >> A >> B >> C;
vector<ll> p(A), q(B), r(C);
rep (i,A) cin >> p[i];
rep (i,B) cin >> q[i];
rep (i,C) cin >> r[i];
sort(p.rbegin(), p.rend());
sort(q.rbegin(), q.rend());
vector<int> d;
rep(i,X) d.push_back(p[i]);
rep(i,Y) d.push_back(q[i]);
rep(i,C) d.push_back(r[i]);
sort(d.rbegin(), d.rend());
ll ans = 0;
rep(i,X+Y) ans += d[i];
cout << ans << endl;
}
| 0
| 21,058,843
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,k;
cin>>n>>k;
vector<int> vec(n);
vector<int> dp(n,0);
for(int i=0;i<n;i++){
int temp;
cin>>temp;
vec[i]=temp;
}
for(int i=0;i<k;i++){
dp[i]=abs(vec[i]-vec[0]);
}
for(int i=k;i<n;i++){
int minCost=INT_MAX;
for(int j=1;j<=k;j++){
minCost=min(minCost,dp[i-j]+abs(vec[i]-vec[i-j]));
}
dp[i]=minCost;
}
cout<<dp[n-1];
return 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()
{
int n, d;
cin >> n >> d;
vector<vector<int>> x(n, vector<int>(d));
rep(i, n)rep(j, d) cin >> x[i][j];
vector<int> check(200);
for (int i = 1; i <= 200; i++) check[i] = i * i;
int ans = 0;
for (int i = 0; i < n-1; i++) {
for (int j = i + 1; j < n; j++) {
vector<int> y = x[i];
vector<int> z = x[j];
int dis = 0;
rep(i, d) {
int k = abs(y[i] - z[i]);
dis += k * k;
}
bool ok = false;
for (int i = 1; i <= 200; i++) {
if (check[i] == dis) ok = true;
}
if (ok) ans++;
}
}
cout << ans << endl;
return 0;
}
| 0
| 74,797,629
|
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i=0;i<(n);++i)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define all(x) (x).begin(), (x).end()
#define PI 3.14159265358979323846264338327950L
using namespace std;
typedef long long ll;
typedef long double ld;
int main() {
int k,s;
cin>>k>>s;
ll cnt=0;
rep(x,k+1){
rep(y,k+1){
if(s-x-y>=0&&s-x-y<=k) cnt++;
}
}
cout<<cnt;
}
|
#include<stdio.h>
#include<iostream>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<algorithm>
#include<string.h>
#include<functional>
#include<limits.h>
#include<stdlib.h>
#include<cmath>
#include<cstring>
#include<set>
#include<climits>
#include<bitset>
using namespace std;
#define intmax INT_MAX
#define lmax LONG_MAX
#define uintmax UINT_MAX
#define ulmax ULONG_MAX
#define llmax LLONG_MAX
#define ll long long
#define rep(i,a,N) for((i)=(a);(i)<(N);(i)++)
#define rrp(i,N,a) for((i)=(N)-1;(i)>=(a);(i)--)
#define llfor ll i,j
#define sc(a) cin>>a
#define pr(a) cout<<a<<endl
#define pY puts("YES")
#define pN puts("NO")
#define py puts("Yes")
#define pn puts("No")
#define pnn printf("\n")
#define pb(b) push_back(b)
#define all(a) a.begin(),a.end()
#define llvec vector<vector<ll>>
#define charvec vector<vector<char>>
#define llpvec vector<pair<ll,ll>>
#define size_(a,b) (a,vector<ll>(b))
#define S 21
template<class Abel> struct UnionFind{
vector<ll>par;
vector<ll>rank;
vector<Abel>diff_weight;
UnionFind(ll n=1,Abel SUM_UNITY=0) {
init(n,SUM_UNITY);
}
void init(ll n=1,Abel SUM_UNITY=0){
par.resize(n);rank.resize(n);diff_weight.resize(n);
for (ll i=0;i<n;++i)par[i]=i,rank[i]=0,diff_weight[i]=SUM_UNITY;
}
ll root(ll x){
if(par[x]==x)return x;
else {
ll r=root(par[x]);
diff_weight[x]+=diff_weight[par[x]];
return par[x]=r;
}
}
Abel weight(ll x){
root(x);
return diff_weight[x];
}
bool issame(ll x,ll y) {
return root(x)==root(y);
}
bool unite(ll x,ll y,Abel w) {
w+=weight(x);w-=weight(y);
x=root(x);y=root(y);
if(x==y)return false;
if(rank[x]<rank[y])swap(x,y),w=-w;
if(rank[x]==rank[y])++rank[x];
par[y]=x;
diff_weight[y]=w;
return true;
}
ll treecnt(ll n){
map<ll,bool>used;
ll ans=0,i;
rep(i,0,n){
ll p=root(par[i]);
if(used[p])continue;
used[p]=true;
ans++;
}
return ans;
}
Abel diff(ll x, ll y){return weight(y)-weight(x);}
};
const int mod=1e9+7;
const double pi=acos(-1);
ll cei(ll x,ll y){ll ans=x/y;if(x%y!=0)ans++;return ans;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
ll lcm(ll x,ll y){return x/gcd(x,y)*y;}
ll llpow(ll x,ll n){ll ans=1,ii;rep(ii,0,n){ans*=x;}return ans;}
ll modpow(ll x,ll n){ll ans=x,ii,tmp=x,t1=1;ii=1; while(ii<n){if(ii*2<n){ans*=ans;ans%=mod;ii*=2;}else{t1=1;tmp=x;while(t1*2<n-ii){tmp*=tmp;tmp%=mod;t1*=2;}ans*=tmp;ans%=mod;ii+=t1;}}return ans;}
ll fact(ll x){ll ii,ans=1;rep(ii,0,x){ans*=(x-ii);ans%=mod;}return ans;}
ll inv(ll x){return modpow(x,mod-2);}
ll ncr(ll n,ll r){ll a=fact(n),b=inv(fact(n-r)),c=inv(fact(r));if(n-r<0)return 0;else return (((a*b)%mod)*c)%mod;}
ll npr(ll n,ll r){ll a=fact(n),b=inv(fact(n-r));return (a*b)%mod;}
bool prime(ll a){if(a<=1)return false;ll ii;for(ii=2;ii*ii<=a;ii++){if(a%ii==0)return false;}return true;}
ll fib(ll x){ll ii,fibo[x+10];fibo[0]=1;fibo[1]=1;fibo[2]=1;rep(ii,3,x+1)fibo[ii]=fibo[ii-1]+fibo[ii-2];return fibo[x];}
ll dig(ll n){ll d=1,tmp=n;while(tmp/10>0){tmp/=10;d++;}return d;}
void matcpy(ll a[S][S],ll b[S][S]){ll ii,jj;rep(ii,0,S)rep(jj,0,S)b[ii][jj]=a[ii][jj];}
void matrst(ll a[S][S]){ll ii,jj;rep(ii,0,S)rep(jj,0,S)a[ii][jj]=0;}
void matpow(ll a[S][S]){ll ans[S][S];matrst(ans);ll ii,jj,kk;rep(ii,0,S)rep(jj,0,S)rep(kk,0,S){ans[ii][jj]+=a[ii][kk]*a[kk][jj];ans[ii][jj]%=mod;}matcpy(ans,a);}
void matmul(ll a[S][S],ll b[S][S], ll as[S][S]){ll ii,jj,kk;matrst(as);rep(ii,0,S)rep(jj,0,S)rep(kk,0,S){as[ii][jj]+=a[ii][kk]*b[kk][jj];as[ii][jj]%=mod;}}
const int dx[4]={1,0,-1,0};const int dy[4]={0,1,0,-1};
llfor;
int main(){
ll n;
cin>>n;
vector<ll>a(n);
ll xo[80][2];
rep(i,0,61){
rep(j,0,2){
xo[i][j]=0;
}
}
rep(j,0,n){
cin>>a.at(j);
}
rep(j,0,n){
rep(i,0,61){
if(a[j]<(1LL<<i))xo[i][0]++;
else if(a[j]&(1LL<<i))xo[i][1]++;
else xo[i][0]++;
}
}
ll ans=0;
rep(j,0,61){
ans+=((((llpow(2,j)%mod)*xo[j][0])%mod)*xo[j][1])%mod;
ans%=mod;
}
pr(ans);
return 0;}
| 0
| 61,782,077
|
#include<iostream>
using namespace std;
int main(){
int n;
cin >> n;
int a, b, c;
for(int i = 0; i < n; i++){
cin >> a >> b >> c;
if(a*a == b*b+c*c || b*b == a*a+c*c || c*c == a*a+b*b){
cout << "YES\n";
} else{
cout << "NO\n";
}
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <set>
using namespace std;
int main() {
string s;
cin >> s;
set<char> st;
for (const auto c : s)
st.insert(c);
for (char c = 'a'; c <= 'z'; ++c) {
if (!st.count(c)) {
cout << s << c << '\n';
return 0;
}
}
string t = s;
if (next_permutation(s.begin(), s.end())) {
for (int i = 0; i < s.size(); ++i) {
if (s.substr(0, i) > t) {
cout << s.substr(0, i) << '\n';
return 0;
}
}
} else
cout << -1 << '\n';
}
| 0
| 88,048,666
|
#include <iostream>
using namespace std;
int main()
{
int a, b, c;
cin >> a >> b >> c;
if(a>b){
int tmp = a;
a = b;
b = tmp;
}
if(b>c){
int tmp = b;
b = c;
c = tmp;
}
if(a>b){
int tmp = a;
a = b;
b = tmp;
}
cout << a << ' ' << b << ' ' << c << '\n';
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
int main()
{
int n, m;
std::cin >> n >> m;
std::vector<int> a(m);
for (int i = 0; i < m; i++) {
std::cin >> a[i];
}
std::sort(a.begin(), a.end(), std::greater<int>());
std::vector<int> num_match = { 0, 2, 5, 5, 4, 5, 6, 3, 7, 6 };
std::vector<int> dp(n + 1, 0);
for (int i = 0; i <= n; i++) {
for (int j = 0; j < m; j++) {
if (i - num_match[a[j]] >= 0) {
dp[i] = std::max(dp[i], dp[i - num_match[a[j]]] + 1);
}
}
}
std::vector<std::string> ans(n + 1, "");
for (auto num : a) {
if (n >= num_match[num]) {
ans[n - num_match[num]] = std::max(ans[n - num_match[num]], std::to_string(num));
}
}
for (int i = n - 1; i >= 0; i--) {
if (ans[i] == "") {
continue;
}
for (auto num : a) {
if (i - num_match[num] >= 0) {
if (ans[i - num_match[num]].size() <= ans[i].size()) {
ans[i - num_match[num]] = ans[i] + std::to_string(num);
} else if (ans[i - num_match[num]].size() - 1 == ans[i].size()) {
ans[i - num_match[num]] = std::max(ans[i - num_match[num]], ans[i] + std::to_string(num));
}
}
}
}
std::cout << ans[0] << std::endl;
}
| 0
| 44,009,637
|
#include "bits/stdc++.h"
using namespace std;
int main() {
int a[101] = { 0 };
int A;
int M_C = 0;
while (cin >> A) {
a[A]++;
M_C = max(M_C, a[A]);
}
for (int i = 1; i <= 100;i++) {
if (a[i] == M_C) cout << i << endl;
}
}
|
#include <bits/stdc++.h>
#include <atcoder/dsu.hpp>
using namespace std;
using namespace atcoder;
using ll = long long;
using ld = long double;
using intpair = pair<int, int>;
using intmap = map<int, int>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
const int MOD = 1e9 + 7;
inline int mod (ll a, int m = MOD) { return (a % m + m) % m; }
inline bool bit (ll b, ll i) { return b & (1 << i); }
inline ll ceiv (ll a, ll b) { return (a + b - 1) / b; }
#define debug(x) cerr << #x << ": " << x << '\n'
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, n, m) for (int i = (int)(n); i <= (int)(m); i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
int main() {
int n, q;
cin >> n >> q;
dsu uf(n);
while(q--){
int t, u, v;
cin >> t >> u >> v;
if(t == 0){
uf.merge(u, v);
}else{
cout << uf.same(u, v) << endl;
}
}
}
| 0
| 22,883,370
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0;i<n;++i)
#define FOR(i, a, b) for(int i=a;i<b;++i)
#define RFOR(i, a, b) for (int i=a;i>=b;--i)
#define ll long long
#define all(a) a.begin(),a.end()
#define ull unsigned long long
#define pb(x) push_back(x)
#define dbg(x) cout<<#x<<" : "<<(x)<<endl;
using namespace std;
const int INF = 1500000000;
const double PI = 3.14159265359;
const int mod = 1000000000 + 7;
int n, s[1000];
void solve() {
int res = 0, mins = 1000, maxs = 0;
rep(i, n) {
res += s[i];
maxs = max(maxs, s[i]);
mins = min(mins, s[i]);
}
res -= maxs;
res -= mins;
printf("%d\n", res / (n-2));
}
int main() {
while(true) {
scanf("%d", &n);
if (!n) break;
rep(i, n) scanf("%d", &s[i]);
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
struct UnionFind {
vector<int> data;
UnionFind(int N) : data(N, -1) {}
int find(int k) { return data[k] < 0 ? k : data[k] = find(data[k]); }
int unite(int x, int y) {
if ((x = find(x)) == (y = find(y))) return false;
if (data[x] > data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
return true;
}
int size(int k) { return -data[find(k)]; }
int same(int x, int y) { return find(x) == find(y); }
};
using namespace std;
namespace fastio {
static constexpr int SZ = 1 << 17;
char ibuf[SZ], obuf[SZ];
int pil = 0, pir = 0, por = 0;
struct Pre {
char num[40000];
constexpr Pre() : num() {
for (int i = 0; i < 10000; i++) {
int n = i;
for (int j = 3; j >= 0; j--) {
num[i * 4 + j] = n % 10 + '0';
n /= 10;
}
}
}
} constexpr pre;
inline void load() {
memcpy(ibuf, ibuf + pil, pir - pil);
pir = pir - pil + fread(ibuf + pir - pil, 1, SZ - pir + pil, stdin);
pil = 0;
}
inline void flush() {
fwrite(obuf, 1, por, stdout);
por = 0;
}
inline void rd(char& c) { c = ibuf[pil++]; }
template <typename T>
inline void rd(T& x) {
if (pil + 32 > pir) load();
char c;
do
c = ibuf[pil++];
while (c < '-');
bool minus = 0;
if (c == '-') {
minus = 1;
c = ibuf[pil++];
}
x = 0;
while (c >= '0') {
x = x * 10 + (c & 15);
c = ibuf[pil++];
}
if (minus) x = -x;
}
inline void rd() {}
template <typename Head, typename... Tail>
inline void rd(Head& head, Tail&... tail) {
rd(head);
rd(tail...);
}
inline void wt(char c) { obuf[por++] = c; }
template <typename T>
inline void wt(T x) {
if (por > SZ - 32) flush();
if (!x) {
obuf[por++] = '0';
return;
}
if (x < 0) {
obuf[por++] = '-';
x = -x;
}
int i = 12;
char buf[16];
while (x >= 10000) {
memcpy(buf + i, pre.num + (x % 10000) * 4, 4);
x /= 10000;
i -= 4;
}
int d = x < 100 ? (x < 10 ? 1 : 2) : (x < 1000 ? 3 : 4);
memcpy(obuf + por, pre.num + x * 4 + 4 - d, d);
por += d;
memcpy(obuf + por, buf + i + 4, 12 - i);
por += 12 - i;
}
inline void wt() {}
template <typename Head, typename... Tail>
inline void wt(Head head, Tail... tail) {
wt(head);
wt(tail...);
}
template<typename T>
inline void wtn(T x){
wt(x, '\n');
}
struct Dummy {
Dummy() { atexit(flush); }
} dummy;
}
using fastio::rd;
using fastio::wt;
using fastio::wtn;
int main() {
int N, Q;
rd(N, Q);
UnionFind uf(N);
while (Q--) {
int t, u, v;
rd(t, u, v);
if (t)
wtn(uf.same(u, v));
else
uf.unite(u, v);
}
}
| 0
| 93,520,457
|
#include <stdio.h>
int main (){
char alpha;
scanf("%c",&alpha);
printf("%c",alpha+1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, H, W;
cin >> N;
cin >> H;
cin >> W;
int cnt=0;
for(int i=0; i<N; i++){
int a, b;
cin >> a;
cin >> b;
if(a>=H && b>=W) cnt++;
}
cout << cnt << endl;
}
| 0
| 2,575,837
|
#include<bits/stdc++.h>
using namespace std;
using lli = long long;
#define rep(i,n) for(int i=0;i<n;i++)
lli k, s;
int main(void){
cin >> k >> s;
lli ans = 0;
for(lli i = 0; i <= k; i++){
for(lli j = 0; j <= k; j++){
lli u = s-i-j;
if(u >= 0 && u <= k) ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn=112345;
typedef pair<int,int> pii;
int n,m,l,r,x,d[maxn],vis[maxn];
vector<pii> G[maxn];
bool dfs(int u,int dep) {
vis[u]=1;
d[u]=dep;
for (int i=0;i<(int)G[u].size();++i) {
int v=G[u][i].first,w=G[u][i].second;
if (vis[v]&&d[u]+w!=d[v]) return false;
if (!vis[v]&&!dfs(v,dep+w)) return false;
}
return true;
}
int main()
{
scanf("%d%d",&n,&m);
for (int i=0;i<m;++i) {
scanf("%d%d%d",&l,&r,&x);
G[l].push_back(pii(r,x));
G[r].push_back(pii(l,-x));
}
for (int i=1;i<=n;++i) if (!vis[i]&&!dfs(i,0))
return 0*puts("No");
return 0*puts("Yes");
}
| 0
| 39,201,346
|
#include "bits/stdc++.h"
#define rep(i,n) for (ll i=0; i<(n); ++i)
using namespace std;
using ll =long long;
using P =pair<int,int>;
int main(){
ll n,m;
cin >> n >> m;
if(n%2!=0){
rep(i,m){
cout << n/2-i << " " << n/2+i+1 << endl;
}
}
else{
rep(i,m){
if(i*2<=m-1){
cout << n/2-i << " " << n/2+i+1 << endl;
}
else{
cout << n/2-i-1 << " " << n/2+i+1 << endl;
}
}
}
return 0;
}
|
#include <cmath>
#include <complex>
#include <iostream>
#define FOR(i,k,n) for (int (i)=(k); (i)<(n); ++(i))
#define REP(i,n) FOR(i,0,n)
using namespace std;
typedef complex<double> xy_t;
double dot_product(xy_t a, xy_t b){ return (conj(a) * b).real(); }
double cross_product(xy_t a, xy_t b){ return (conj(a) * b).imag(); }
const double eps = 1e-10;
int main(){
int n;
xy_t p[4];
double x,y;
cin >> n;
REP(i,n){
REP(j,4){
cin >> x >> y;
p[j] = xy_t (x,y);
}
bool ans = fabs(cross_product(p[0] - p[1], p[2] - p[3])) < eps;
cout << (ans ? "YES" : "NO") << endl;
}
}
| 0
| 93,227,567
|
#include <bits/stdc++.h>
#define rep3(i, s, n, a) for (int i = (s); i < (int)(n); i += a)
#define rep2(i, s, n) rep3(i, s, n, 1)
#define rep(i, n) rep2(i, 0, n)
using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int, int>;
int main(){
ll n;
cin >> n;
for(ll i=sqrt(n);i>=1;i--){
if(n%i==0){
ll big = n / i;
int dig=0;
while(big){
dig++;
big /= 10;
}
cout << dig << endl;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define Graph vector<vector<int>>
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1000000007;
const int NIL = -1;
struct Node{
int p, l, r;
};
vector<Node> T(100010, {NIL, NIL, NIL});
vector<int> D(100010);
void setDepth(int u, int p){
D[u] = p;
if(T[u].l != NIL) setDepth(T[u].l, p + 1);
if(T[u].r != NIL) setDepth(T[u].r, p);
}
void print(int u){
cout << "node " << u << ": ";
cout << "parent = " << T[u].p << ", ";
cout << "depth = " << D[u] << ", ";
if(T[u].p == NIL) cout << "root, ";
else if(T[u].l == NIL) cout << "leaf, ";
else cout << "internal node, ";
cout << "[";
for(int c = T[u].l, j = 0; c != NIL; c = T[c].r, j++){
if(j) cout << ", ";
cout << c;
}
cout << "]" << endl;
}
int main(){
int N;
cin >> N;
rep(i, N){
int id, k;
cin >> id >> k;
int c1, c2;
rep(j, k){
cin >> c1;
if(j == 0){
T[id].l = c1;
T[c1].p = id;
c2 = c1;
} else {
T[c2].r = c1;
T[c1].p = id;
c2 = c1;
}
}
}
int root;
rep(i, N){
if(T[i].p == NIL){
root = i;
break;
}
}
setDepth(root, 0);
rep(i, N) print(i);
}
| 0
| 19,291,702
|
#pragma GCC optimize ("O3")
#pragma GCC target ("tune=native")
#pragma GCC target ("avx")
#include <bits/stdc++.h>
#define ALL_OF(x) (x).begin(), (x).end()
#define REP(i,n) for (long long i=0, i##_len=(n); i<i##_len; i++)
#define RANGE(i,is,ie) for (long long i=(is), i##_end=(ie); i<=i##_end; i++)
#define DSRNG(i,is,ie) for (long long i=(is), i##_end=(ie); i>=i##_end; i--)
#define UNIQUE(v) { sort((v).begin(), (v).end()); (v).erase(unique((v).begin(), (v).end()), (v).end()); }
template<class T> bool chmax(T &a, const T &b) {if (a < b) {a = b; return true;} return false; }
template<class T> bool chmin(T &a, const T &b) {if (a > b) {a = b; return true;} return false; }
#define INF 0x7FFFFFFF
#define LINF 0x7FFFFFFFFFFFFFFFLL
#define Yes(q) (q ? "Yes" : "No")
#define YES(q) (q ? "YES" : "NO")
#define DUMP(q) cerr << "[DEBUG] " #q ": " << (q) << " at " __FILE__ ":" << __LINE__ << endl
#define DUMPALL(q) { cerr << "[DEBUG] " #q ": ["; REP(dumpall_i, (q).size()) { cerr << q[dumpall_i] << (dumpall_i == (q).size() - 1 ? "" : ", "); } cerr << "] at " __FILE__ ":" << __LINE__ << endl; }
template<class T> T gcd(const T &a, const T &b) { return a < b ? gcd(b, a) : b ? gcd(b, a % b) : a; }
template<class T> T lcm(const T &a, const T &b) { return a / gcd(a, b) * b; }
#define popcount __builtin_popcount
#define popcountll __builtin_popcountll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using namespace std;
int main() {
ll k; cin >> k;
vector<ll> dp(k, INF);
dp[1] = 1;
deque<pair<ll, ll>> q = {{dp[1], 1}};
while (!q.empty()) {
ll c = q.front().first;
ll v = q.front().second;
q.pop_front();
ll n1 = (v + 1) % k;
ll n2 = v * 10 % k;
if (chmin(dp[n1], dp[v] + 1))
q.push_back(pair<ll, ll>(dp[n1], n1));
if (chmin(dp[n2], dp[v]))
q.push_front(pair<ll, ll>(dp[n2], n2));
}
cout << dp[0] << endl;
}
|
#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
string s, t;
cin >> s >> t;
bool flag = true;
int c = 0;
for (int i = 0; i < int(s.size()); ++i) {
flag = true;
c = 0;
for (int j = 0;; ++j) {
if (s[i + j] != t[j]) {
flag = false;
break;
}
++c;
if (i + j == int(s.size()) - 1) {
break;
} else if (j == int(t.size()) - 1) {
flag = false;
break;
}
}
if (flag)
break;
}
cout << max(int(s.size() + t.size()) - c, n) << endl;
}
| 0
| 77,458,268
|
#define rep(i, n) for(int i=0; i<(n); ++i)
#define rrep(i, n) for(int i=(n-1); i>=0; --i)
#define rep2(i, s, n) for(int i=s; i<(n); ++i)
#define ALL(v) (v).begin(), (v).end()
#define memr(dp, val) memset(dp, val, sizeof(dp))
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class T> inline T int_ceil(T a, T b) { T res = a / b; if(a % b != 0) res++; return res; }
#include <bits/stdc++.h>
using namespace std;
template<typename T>
using min_priority_queue = priority_queue<T, vector<T>, greater<T> >;
typedef long long ll;
static const int INTINF = (INT_MAX >> 1);
static const ll LLINF = (LLONG_MAX >> 1);
static const int MAX = 100001;
static const ll MOD = 1000000007;
int main(int argc, const char * argv[]) {
std::cout << std::fixed << std::setprecision(15);
int M, K; cin >> M >> K;
if(M == 0 && K == 0){
cout << 0 << " " << 0 << endl;
return 0;
}
if(M == 1 && K == 1){
cout << -1 << endl;
return 0;
}
int lim = 2 << (M-1);
vector<int> v;
if(K == 0){
rep(i, lim){
if(i) cout << " ";
rep(_, 2){
if(_) cout << " ";
cout << i;
}
}
cout << endl;
return 0;
}
if(K >= lim){
cout << -1 << endl;
return 0;
}
else{
rep(i, lim){
if(i == K) continue;
v.push_back(i);
}
v.push_back(K);
rrep(i, lim){
if(i == K) continue;
v.push_back(i);
}
v.push_back(K);
}
rep(i, v.size()){
if(i) cout << " ";
cout << v[i];
}
cout << endl;
return 0;
}
|
#if 0
#endif
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
int Q;
int L[1000+10][1000+10];
int main() {
cin >> Q;
string X, Y;
for (int i = 0; i < Q; i++) {
for (int j = 0; j < 1000+10; j++) {
L[0][j] = 0; L[j][0] = 0;
}
cin >> X >> Y;
for (int x = 1; x <= X.length(); x++) {
for (int y = 1; y <= Y.length(); y++) {
if (X[x-1] == Y[y-1])
L[x][y] = L[x-1][y-1]+1;
else
L[x][y] = max(L[x-1][y], L[x][y-1]);
}
}
cout << L[X.length()][Y.length()] << endl;
}
}
| 0
| 24,035,332
|
#include <iostream>
using namespace std;
int main(){
int g[1001][1001]={{0}};
int n,a,b,c;
cin >> n;
for (int i = 0; i < n; ++i)
{
cin >> a >> b ;
for (int i = 0; i < b; ++i)
{
cin >> c;
g[a-1][c-1]=1;
}
}
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < n; ++j)
{
if (j==n-1)
{
cout << g[i][j] << endl;
}else{
cout << g[i][j] <<" ";
}
}
}
}
|
#pragma GCC optimize("O3")
#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>
#include <fstream>
#include <functional>
#include <bitset>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using T = tuple<int, int, int>;
template <class T> inline T chmax(T &a, const T b) {return a = (a < b) ? b : a;}
template <class T> inline T chmin(T &a, const T b) {return a = (a > b) ? b : a;}
constexpr int MOD = 1e9 + 7;
constexpr int inf = 1e9;
constexpr long long INF = 1e18;
constexpr double pi = acos(-1);
constexpr double EPS = 1e-10;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n, k; cin>>n>>k;
vector<ll> a(n);
for(int i=0; i<n; i++) cin>>a[i];
vector<ll> asum(n+1, 0);
for(int i=0; i<n; i++) asum[i+1] = asum[i] + a[i];
vector<ll> v;
for(int i=1; i<=n; i++){
for(int j=i; j<=n; j++){
v.emplace_back(asum[j] - asum[i-1]);
}
}
ll ans = 0;
for(int bit=50; bit>=0; bit--){
ans += (1LL << bit);
int cnt = 0;
for(int i=0; i<v.size(); i++){
if((v[i] & ans) == ans) cnt++;
}
if(cnt < k) ans -= (1LL << bit);
}
cout << ans << endl;
return 0;
}
| 0
| 46,683,447
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<cmath>
#include<map>
using namespace std;
#define rep(i,N) for(int i=0;i<N;i++)
typedef long long ll;
ll binary_search(vector<ll> a, ll n, ll key){
ll right = n, left = -1;
ll md = (right + left) / 2;
while(right - left > 1){
if(a[md] <= key){
right = md;
}else{
left = md;
}
md = (right + left) / 2;
}
if(left == -1) return -1;
return right;
}
vector<ll> prime;
void Prime(ll n){
vector<ll> p(n,0);
p[0]=1;
p[1]=1;
for(ll i=2;i<n;i++){
if(p[i]==0){
prime.push_back(i);
p[i]=i;
}
ll k=prime.size();
for(ll j=0;j<k && i*prime[j]<n && prime[j]<=p[i];j++){
p[i*prime[j]]=prime[j];
}
}
}
ll gcd(ll a,ll b){
if(a<b){
swap(a,b);
}
ll r=a%b;
while(r!=0){
a=b;
b=r;
r=a%b;
}
return b;
}
#define MOD ((ll)1e+9 + 7)
int main(){
ll n;
cin>>n;
vector<ll> a(n+1),b(n);
rep(i,n+1){
cin>>a[i];
}
rep(i,n){
cin>>b[i];
}
ll ans=0;
rep(i,n){
if(a[i]>b[i]){
ans+=b[i];
}
else{
ans+=a[i];
b[i]-=a[i];
ans+=min(a[i+1],b[i]);
a[i+1]-=min(a[i+1],b[i]);
}
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void){
int N;
cin >> N;
vector<int> A(N), B(N);
int first = 0, second = 0;
for(int i = 0; i < N; i++) {
cin >> A[i];
if(first <= A[i]) {
second = first;
first = A[i];
}
else if(second <= A[i]) {
second = A[i];
}
}
for(int i = 0; i < N; i++) {
if(A[i] == first) {
cout << second << endl;
}
else {
cout << first << endl;
}
}
return 0;
}
| 0
| 96,780,049
|
#include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
using bint = boost::multiprecision::cpp_int;
using ll = long long;
using pint = pair<int, int>;
using pll = pair<ll, ll>;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define repSE(i,s,n) for (int i = (s); i < (n); i++)
#define rrepSE(i,s,e) for (int i = (s); i > (e); i--)
#define ssort(v) sort(v.begin(), v.end())
#define gsort(v) sort(v.rbegin(), v.rend())
template<typename T> istream &operator>>(istream &is, vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec){ os << "["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const deque<T> &vec){ os << "deq["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &pa){ os << "(" << pa.first << "," << pa.second << ")"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename T> bool chmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
template<typename T> bool chmin(T &m, const T q) { if (q < m) {m = q; return true;} else return false; }
#define DEBUG_PRINT(var) std::cout << #var << " = " << var << "\n";
int gcd(int a,int b){
if(a<b)swap(a,b);
if(a%b==0)return b;
return gcd(a%b,b);
}
int main()
{
int n;
cin >> n;
vector<int> a(n);
ssort(a);
rep(i,n) cin >> a[i];
int ans = gcd(a[0], a[1]);
repSE(i,2,n) {
ans = gcd(ans, a[i]);
}
cout << ans << "\n";
return 0;
}
|
#include<iostream>
#include<string>
using namespace std;
int A[1001][1001];
int main(){
string s1,s2;
cin>>s1;
cin>>s2;
for(int i=0;i<=s1.size();++i){
for(int j=0;j<=s2.size();++j){
if(i==0){
A[0][j]=j;
continue;
}
if(j==0){
A[i][0]=i;
continue;
}
else{
if(s1[i-1]==s2[j-1]){
A[i][j]=A[i-1][j-1];
}
else{
A[i][j]=min(A[i][j-1],A[i-1][j])+1;
A[i][j]=min(A[i][j],A[i-1][j-1]+1);
}
}
}
}
cout<<A[s1.size()][s2.size()]<<endl;
}
| 0
| 13,976,106
|
#include <iostream>
using namespace std;
int main(){
int a=100000,b=0,t;
cin>>t;
for(int k=0;k<t;k++){
b=a*1.05;
b=(b+999)/1000*1000;
a=b;
}
cout<<a<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define fw(p) for(int w=0;w<(p);w++)
#define fx(p) for(int x=0;x<(p);x++)
#define fy(p) for(int y=0;y<(p);y++)
#define fz(p) for(int z=0;z<(p);z++)
#define fyg(p,g) for(int y=(g);y<(p);y++)
#define fzg(p,g) for(int z=(g);z<(p);z++)
#define ce(d) cout<<d<<endl;
#define vecp(p) int aa;cin>>aa;(p).push_back(aa);
#define vecpl(p) long long aa;cin>>aa;(p).push_back(aa);
#define vecps(p) string aa;cin>>aa;(p).push_back(aa);
#define vecp2(p) cin>>aa;(p).push_back(aa);
#define vecpl2(p) long long a b;cin>>ab;(p).push_back(ab);
#define vecps2(p) string ab;cin>>ab;(p).push_back(ab);
#define set0(k,n) for(int nn=0;nn<(n);nn++){ (k).push_back(0); }
#define sorts(c) sort((c).begin(),(c).end());
#define reverses(c) reverse((c).begin(),(c).end());
#define vec(b) vector<int> (b);
#define vecl(b) vector<long long> (b);
#define vecs(b) vector<string> (b);
#define vecsize(b,size) vector<int> (b)((size));
#define pb(b,a) (b).push_back((a));
#define doublece(a,b) cout<<(a)<<' '<<(b)<<endl;
#define pairs(s) vector<pair<int,int>> (s);
#define pairsl(s) vector<pair<ll,ll>> (s);
#define pairss(s) vector<pair<string,string>> (s);
#define pairsp(s) int aa,bb;cin>>aa>>bb;(s).push_back(make_pair(aa,bb));
#define pairspl(s) int aa,bb;cin>>aa>>bb;(s).push_back(make_pair(aa,bb));
#define pairsps(s) int aa,bb;cin>>aa>>bb;(s).push_back(make_pair(aa,bb));
#define pairsREV(s) (s).push_back(make_pair(bb,aa));
#define pairslREV(s) (s).push_back(make_pair(bb,aa));
#define pairssREV(s) (s).push_back(make_pair(bb,aa));
#define MOD 1000000007
int main()
{
string s;
cin>>s;
s.insert(s.begin()+4,' ');
ce(s)
return 0;
}
| 0
| 20,554,152
|
#include <bits/stdc++.h>
using namespace std;
int64_t MOD = 1000000007;
double PI = 3.141592653589793;
int main()
{
int A, B;
cin >> A >> B;
cout << (A + B + 1) / 2;
}
|
#include <iostream>
using namespace std;
#define MAX 250
int main() {
int n;
int x;
int H[MAX];
cin >> n;
for(int i=0; i<n; i++) {
cin >> x;
H[i] = x;
}
for(int i=0; i<n; i++) {
cout << "node " << i+1 << ": ";
cout << "key = " << H[i] << ", ";
if(i>0) {
cout << "parent key = " << H[((i+1)/2-1)] << ", ";
}
if((2*(i+1))<=n) {
cout << "left key = " << H[2*(i+1)-1] << ", ";
}
if((2*(i+1)+1)<=n) {
cout << "right key = " << H[2*(i+1)] << ", ";
}
cout << endl;
}
return 0;
}
| 0
| 21,507,239
|
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
using namespace std;
int main() {
ll X, Y, Z, K;
cin >> X >> Y >> Z >> K;
vector <ll> A(X);
for (int ii = 0; ii < X; ++ii){
cin >> A[ii];
}
vector <ll> B(Y);
for (int ii = 0; ii < Y; ++ii){
cin >> B[ii];
}
vector <ll> C(Z);
for (int ii = 0; ii < Z; ++ii){
cin >> C[ii];
}
sort(A.rbegin(), A.rend());
sort(B.rbegin(), B.rend());
sort(C.rbegin(), C.rend());
vector < pair<ll, ll> > v;
ll cA = 1000000;
ll cB = 1000;
ll cC = 1;
ll pval = A[0] + B[0] + C[0];
ll pidx = cA*0 + cB*0 + cC*0;
v.push_back(make_pair(pval, pidx));
map<ll, ll> m;
map<ll, ll> mm;
mm[pidx] = 1;
for (int cnt = 0; cnt < K; ++cnt){
pair<ll, ll> tmp = v.back();
v.pop_back();
ll val = tmp.first;
ll idx = tmp.second;
if (m[idx] == 0){
cout << val << "\n";
}
m[idx] = 1;
ll aidx = idx / cA;
ll bidx = (idx - cA*aidx) / cB;
ll cidx = idx - cA*aidx - cB*bidx;
if (aidx + 1 < X){
ll taidx = aidx + 1;
bool ok = true;
for (int ii = 0; ii < v.size(); ++ii){
ll vidx = v[ii].second;
ll vaidx = vidx / cA;
ll vbidx = (vidx - cA*vaidx) / cB;
ll vcidx = vidx - cA*vaidx - cB*vbidx;
}
if (ok){
ll val = A[taidx] + B[bidx] + C[cidx];
ll idx = cA*taidx + cB*bidx + cC*cidx;
if (mm[idx] == 0){
v.push_back(make_pair(val, idx));
mm[idx] = 1;
}
}
}
if (bidx + 1 < Y){
ll tbidx = bidx + 1;
bool ok = true;
for (int ii = 0; ii < v.size(); ++ii){
ll vidx = v[ii].second;
ll vaidx = vidx / cA;
ll vbidx = (vidx - cA*vaidx) / cB;
ll vcidx = vidx - cA*vaidx - cB*vbidx;
}
if (ok){
ll val = A[aidx] + B[tbidx] + C[cidx];
ll idx = cA*aidx + cB*tbidx + cC*cidx;
if (mm[idx] == 0){
v.push_back(make_pair(val, idx));
mm[idx] = 1;
}
}
}
if (cidx + 1 < Z){
ll tcidx = cidx + 1;
bool ok = true;
for (int ii = 0; ii < v.size(); ++ii){
ll vidx = v[ii].second;
ll vaidx = vidx / cA;
ll vbidx = (vidx - cA*vaidx) / cB;
ll vcidx = vidx - cA*vaidx - cB*vbidx;
}
if (ok){
ll val = A[aidx] + B[bidx] + C[tcidx];
ll idx = cA*aidx + cB*bidx + cC*tcidx;
if (mm[idx] == 0){
v.push_back(make_pair(val, idx));
mm[idx] = 1;
}
}
}
sort(v.begin(), v.end());
}
return 0;
}
|
#include <iostream>
#include <set>
#include <queue>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <cstring>
#include <climits>
#include <sstream>
#include <iomanip>
#include <map>
#include <stack>
#include <numeric>
#include <functional>
using namespace std;
#define ALL(x) (x).begin(),(x).end()
typedef long long ll;
#define REP(i, n) for (ll i = 0 ; i < (ll)n ; ++i)
#define REPN(i, m, n) for (ll i = m ; i < (ll)n ; ++i)
#define INF (ll)1e9
#define MOD (1000 * 1000 * 1000 + 7)
#define Ceil(x, n) (((((x))+((n)-1))/n))
#define CeilN(x, n) (((((x))+((n)-1))/n)*n)
#define FloorN(x, n) ((x)-(x)%(n))
#define IsOdd(x) (((x)&0x01UL) == 0x01UL)
#define IsEven(x) (!IsOdd((x)))
#define M_PI 3.14159265358979323846
typedef pair<ll, ll> P;
int main()
{
auto myCin = [](ll &a){cin >> a;};
ll N;
cin >> N;
vector<ll> a(N), b(N);
for_each(ALL(a), myCin);
for_each(ALL(b), myCin);
string ans = "No";
ll amari = 0;
ll fusoku = 0;
REP(i, N) {
ll diff = abs(a[i] - b[i]);
if (a[i] < b[i]) {
amari += diff / 2;
} else {
fusoku += diff;
}
}
if (fusoku <= amari) {
ans = "Yes";
}
cout << ans << endl;
return 0;
}
| 0
| 34,969,480
|
#include <bits/stdc++.h>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define ll long long int
#define pb push_back
#define fi first
#define se second
#define ld long double
#define vi vector<vector<ll> >
using namespace std;
const int MOD=1000000007;
const int MOD2=998244353;
const ll MAX=9187201950435737471;
const int N=100005;
const int INF=1e9+7;
const long double PI=acos(-1);
void solve(int T){
int n;
cin>>n;
vector<int>a(n);
for(int i=0;i<n;i++){
cin>>a[i];
}
if(n==1){
cout<<"0\n";
return;
}
sort(a.begin(),a.end());
ll ans=MAX;
for(int i=a[0];i<=a[n-1];i++){
ll md=i;
ll tmp=0;
for(int i=0;i<n;i++){
tmp+=abs(a[i]-md)*abs(a[i]-md);
}
ans=min(tmp,ans);
}
cout<<ans<<"\n";
}
int main() {
fastio
int T=1;
for(int i=1;i<=T;i++){
solve(i);
}
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ArraySizeOf(array) (sizeof(array) / sizeof(array[0]))
#define res(i,n) for(int i=n;;i++)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define rev(i,n) for(int i=n-1;i>=0;i--)
#define REV(i,n) for(int i=n-1;i>0;i--)
#define req(i,n,m) for(int i=n;i<m;i++)
#define REQ(i,n,m,l) for(int i=n;i<m;i+=l)
#define _GLIBCXX_DEBUG
int INF = 1e9 + 7;
unsigned NthDayOfWeekToDay(unsigned n, unsigned dow, unsigned dow1)
{
unsigned day;
if (dow < dow1) dow += 7;
day = dow - dow1;
day += 7 * n - 6;
return day;
}
signed gcd(long long x, long long y) {
if (y == 0)return x;
return gcd(y, x % y);
}
signed lcm(long long x, long long y) {
return x / gcd(x, y) * y;
}
unsigned DayToWeekNumber(unsigned day)
{
return (day - 1) / 7 + 1;
}
unsigned AnotherDayOfWeek(unsigned day, unsigned day0, unsigned dow0)
{
return (dow0 + 35 + day - day0) % 7;
}
using namespace std;
signed main() {
long long Q, H, S, D, N; cin >> Q >> H >> S >> D >> N;
N *= 4;
cout << min(min(min(min(min(min(N * Q, N / 8 * D + N % 8 / 2 * H + N % 2 * Q), N / 8 * D + N % 8 * Q), N / 4 * S + N % 4 * Q), N / 2 * H + N % 2 * Q), N / 4 * S + N % 4 / 2 * H + N % 2 * Q), N / 8 * D + N % 8 / 4 * S + N % 4 / 2 * H + N % 2 * Q) << endl;
}
| 0
| 87,194,658
|
#include <iostream>
using namespace std;
int l[2000][2000], r[2000][2000], up[2000][2000], down[2000][2000];
char a[2000][2000];
int main () {
int h, w, temp = 0, res = 0;
cin >> h >> w;
for (int i = 0; i < h; i++) for (int j = 0; j < w; j++) cin >> a[i][j];
for (int i = 0; i < h; i++) {
temp = 0;
for (int j = 0; j < w; j++) l[i][j] = (a[i][j] == '#') ? temp = 0 : ++temp;
}
for (int i = 0; i < h; i++) {
temp = 0;
for (int j = w-1; j >= 0; j--) r[i][j] = (a[i][j] == '#') ? temp = 0 : ++temp;
}
for (int i = 0; i < w; i++) {
temp = 0;
for (int j = 0; j < h; j++) up[j][i] = (a[j][i] == '#') ? temp = 0 : ++temp;
}
for (int i = 0; i < w; i++) {
temp = 0;
for (int j = h-1; j >= 0; j--) down[j][i] = (a[j][i] == '#') ? temp = 0 : ++temp;
}
for (int i = 0; i < h; i++) {
temp = 0;
for (int j = 0; j < w; j++) if (a[i][j] != '#') res = max(res, l[i][j] + r[i][j] + up[i][j] + down[i][j] - 3);
}
cout << res << endl;
return 0;
}
|
#include <iostream>
#include <stdio.h>
using namespace std;
int main(){
int a[5],i,j,b;
scanf("%d %d %d %d %d",&a[0],&a[1],&a[2],&a[3],&a[4]);
for(i=0;i<5;i++){
for(j=0;j<4;j++){
if(a[j]<=a[j+1]){
b=a[j];
a[j]=a[j+1];
a[j+1]=b;
}
}
}
for(i=0;i<5;i++){
printf("%d",a[i]);
if(i<4){
printf(" ");
}else{
printf("\n");
}
}
return 0;
}
| 0
| 54,929,716
|
#include<stdio.h>
#include<iostream>
#include<list>
#include<map>
#include<vector>
#include<algorithm>
#include<string.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 << x << endl;
using namespace std;
int main(){
int n, m;
while(cin >> n >> m, n){
int ans = 0;
if(n >= 1){
for(int i = 0; i < 10; i++){
if(n == 1)
if(i == m)
ans++;
if(n >= 2){
for(int j = i + 1; j < 10; j++){
if(n == 2)
if(i + j == m)
ans++;
if(n >= 3){
for(int k = j + 1; k < 10; k++){
if(n == 3)
if(i + j + k == m)
ans++;
if(n >= 4){
for(int l = k + 1; l < 10; l++){
if(n == 4)
if(i + j + k + l== m)
ans++;
if(n >= 5){
for(int o = l + 1; o < 10; o++){
if(n == 5)
if(i + j + k + l + o == m)
ans++;
if(n >= 6){
for(int p = o + 1; p < 10; p++){
if(n == 6)
if(i + j + k + l + o + p == m)
ans++;
if(n >= 7){
for(int q = p + 1; q < 10; q++){
if(n == 7)
if(i + j + k + l + o + p + q== m)
ans++;
if(n >= 8){
for(int r = q + 1; r < 10; r++){
if(n == 8)
if(i + j + k + l + o + p + q + r == m)
ans++;
if(n >= 9){
for(int s = r + 1; s < 10; s++){
if(n == 9)
if(i + j + k + l + o + p + q + r + s == m)
ans++;
}}}}}}}}}}}}}}}}}}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<n;++i)
#define exrep(i, a, b) for(ll i = a; i < b; i++)
#define out(x) cout << x << endl
#define EPS (1e-7)
#define gearup ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<pair<int,int> > vpii;
typedef vector<vector<int> > vvi;
typedef vector<vector<char> > vvc;
typedef vector<vector<bool> > vvb;
typedef vector<vector<double> > vvd;
typedef vector<vector<string> > vvs;
typedef vector<ll> vl;
typedef vector<vector<ll> > vvl;
typedef vector<vector<vector<ll> > > vvvl;
ll MOD = 1000000007;
const long long L_INF = 1LL << 60;
const int INF = 2147483647;
const double PI = acos(-1);
template<class T> inline bool chmin(T& a, T b) {if (a > b) {a = b;return true;}return false;}
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b;return true;}return false;}
template<class T> void debug(T v){rep(i,v.size()) cout<<v[i]<<" ";cout<<endl;}
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
signed main()
{
gearup;
int n,m; cin >> n >> m;
vl a(n),b(n+1);
rep(i,n)cin>>a[i];
rep(i,n)b[i+1] = (b[i] + a[i]) % m;
map<ll,ll> mp;
rep(i,n+1)mp[b[i]]++;
ll res = 0;
for(auto m:mp){
res += m.second * (m.second -1 ) / 2;
}
out(res);
}
| 0
| 99,715,815
|
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <numeric>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
typedef long long ll;
typedef long double ld;
int main(){
string n;cin>>n;
if(n[0]==n[1]&&n[1]==n[2]){
cout<<"Yes"<<endl;
}else if(n[1]==n[2] && n[2]==n[3]){
cout<<"Yes"<<endl;
}else{
cout<<"No"<<endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main()
{
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
{
int n, m, v, p;
cin >> n >> m >> v >> p;
vector<int> a(n);
for(int i = 0; i < n; i++)
cin >> a[i];
sort(a.begin(), a.end());
auto poss = [&] (int x) {
int my = a[x] + m, cd = 0;
for(int i = 0; i < n; i++) {
if(x == i)
continue;
if(i > n - min(v, p))
cd += m;
else if(i > n - p)
continue;
else if(a[i] > my)
return false;
else
cd += min(m, my - a[i]);
}
return (cd >= m * (v - 1));
};
int lo = 0, hi = n - 1, lt = -1;
while(lo <= hi) {
int mid = (lo + hi) / 2;
if(poss(mid)) {
lt = mid;
hi = mid - 1;
}
else
lo = mid + 1;
}
cout << n - lt << '\n';
}
cerr << "Time elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " sec \n";
return 0;
}
| 0
| 58,875,593
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
#define loop(i, a, n) for(int i = (a); i < (n); i++)
#ifdef _DEBUG
#define dd(x) cout << #x << " : " << x << endl
#else
#define dd(x)
#endif
using namespace std;
using ll = int64_t;
int main(){
ll n; cin >> n;
ll ans = 0;
for(ll i = 1; i <= n; i++) {
ll tmp = n/i;
ans += i*tmp*(tmp+1)/2;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD=1000000007;
ll modpow(ll x,ll k){
if(k==0)return 1;
ll ret=modpow(x,k/2);
ret*=ret; ret%=MOD;
if(k%2==1){
ret*=x; ret%=MOD;
}
return ret;
}
int main(){
static ll n;
static ll a[100010];
scanf("%lld",&n);
for(int i=0;i<=n;i++)scanf("%lld",&a[i]);
static int cnt[100010]={};
for(int i=0;i<=n;i++)cnt[a[i]]++;
int t=0;
for(int i=1;i<=n;i++)if(cnt[i]==2)t=i;
ll s=0;
for(int i=0;i<=n;i++)if(a[i]==t){s+=i;break;}
for(int i=n;i>=0;i--)if(a[i]==t){s+=n-i;break;}
ll x=1,y=1;
for(int i=1;i<=n+1;i++){
x*=n+1-i+1; x%=MOD;
if(i>=2)y*=s-i+2; y%=MOD;
x*=modpow(i,MOD-2); x%=MOD;
if(i>=2)y*=modpow(i-1,MOD-2); y%=MOD;
printf("%lld\n",(x+MOD-y)%MOD);
}
}
| 0
| 4,305,701
|
#include<queue>
#include<stack>
#include<math.h>
#include<cmath>
#include<bitset>
#include<stdio.h>
#include<string>
#include<map>
#include<algorithm>
#include<vector>
#include<iostream>
#include<utility>
#include<functional>
#include<deque>
#include<list>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
long long int gcd(long long a,long long b){
if(b==0){
return a;
}
else{
return gcd(b,a%b);
}
}
long long int lcm(long long a,long long b){
return a/gcd(a,b)*b;
}
int main(){
ll a,b,c,d;
cin >> a >> b >> c >> d;
ll e=lcm(c,d);
a--;
cout << (b-a)-((b/c+b/d-b/e)-(a/c+a/d-a/e)) << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=500000;
char s[N+9];
int n;
void into(){
scanf("%s",s+1);
n=strlen(s+1);
}
int a[N+9];
LL ans;
void Dfs_a0(int p,int v){
a[p]=max(a[p],v);
if (p>1&&s[p-1]=='>') Dfs_a0(p-1,v+1);
}
void Dfs_a1(int p,int v){
a[p]=max(a[p],v);
if (p<=n&&s[p]=='<') Dfs_a1(p+1,v+1);
}
void Get_ans(){
for (int i=1;i<=n+1;++i) a[i]=-1;
for (int i=1;i<=n+1;++i)
if ((i==1||s[i-1]=='>')&&(i==n+1||s[i]=='<')){
a[i]=0;
Dfs_a0(i-1,1);
Dfs_a1(i+1,1);
}
for (int i=1;i<=n+1;++i) ans+=a[i];
}
void work(){
Get_ans();
}
void outo(){
printf("%lld\n",ans);
}
int main(){
into();
work();
outo();
return 0;
}
| 0
| 69,964,456
|
#include <bits/stdc++.h>
using namespace std;
int main(){
string o,e;
cin >> o >> e;
for(int i=0; i<e.length(); i++){
cout << o.at(i) << e.at(i);
}
if(o.length()!=e.length()) cout << o.at(o.size()-1);
cout << endl;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
#include <fstream>
#include <sstream>
#include <iomanip>
#define ll long long
using namespace std;
long long MOD = 1000000007;
int main(){
ll N;
cin >> N;
ll ans=1;
for(ll i=1; i<N; i++){
ll u, v;
cin >> u >> v;
if(u>v){
ll tmp=u;
u=v;
v=tmp;
}
ans-=u*(N-v+1);
ans+=(N-i+1)*(i+N)/2+(N-i+1)*(1-i);
}
cout << ans << endl;
}
| 0
| 7,728,495
|
#include <bits/stdc++.h>
#include <algorithm>
#include <functional>
#include <map>
#include <queue>
#include <set>
#include <stack>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define REP(i, m, n) for (ll(i) = (ll)(m); i < (ll)(n); ++i)
#define REP2(i, m, n) for (ll(i) = (ll)(n)-1; i >= (ll)(m); --i)
#define rep(i, n) REP(i, 0, n)
#define rep2(i, n) REP2(i, 0, n)
#define all(hoge) (hoge).begin(), (hoge).end()
#define rall(hoge) (hoge).rbegin(), (hoge).rend()
#define en '\n'
using Edge = pair<ll, ll>;
using Graph = vector<vector<Edge>>;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<vector<vector<ll>>> vvvl;
typedef vector<string> vs;
typedef vector<vector<string>> vvs;
typedef pair<ll, ll> P;
constexpr long long INF = 1LL << 60;
constexpr int INF_INT = 1 << 25;
constexpr long long MOD = (ll)1e9 + 7;
using ld = long double;
static const ld pi = 3.141592653589793L;
template <class T> inline void print(T x) { cout << x << '\n'; }
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;
}
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) { return x / gcd(x, y) * y; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a, b, c, d;
cin >> a >> b >> c >> d;
int x = c - a, y = d - b;
printf("%d %d %d %d\n", c - y, d + x, a - y, b + x);
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
const int MAX = 700000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long int maxtime(long long int x, long long int y){
return(x + y - 1) / y;
}
long long int lcm(long long int number1, long long int number2) {
long long int m = number1;
long long int n = number2;
if (number2 > number1) {
m = number2;
n = number1;
}
long long int s = -1;
while (s != 0) {
s = m % n;
m = n;
n = s;
}
return m;
}
long long int gcd(long long int number1, long long int number2) {
long long int m = number1;
long long int n = number2;
return m / lcm(m, n) * n;
}
long long int modinv(long long a, long long m) {
long long int b = m, u = 1, v = 0;
while (b) {
long long int t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
vector<long long int >meguru;
bool isOK(int index, int key) {
if (meguru[index] >= key) return true;
else return false;
}
int binary_search(int key) {
int left = -1;
int right = (int)meguru.size();
while (right - left > 1) {
int mid = left + (right - left) / 2;
if (isOK(mid, key)) right = mid;
else left = mid;
}
return right;
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int sosu[1000] = {};
int uenososu[1000020] = {};
int main() {
int n, x, t;
cin >> n >> x >> t;
cout << (n + x - 1) / x * t;
}
| 0
| 9,990,398
|
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <complex>
#include <utility>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <tuple>
#include <cmath>
#include <bitset>
#include <cctype>
#include <set>
#include <map>
#include <unordered_map>
#include <numeric>
#include <functional>
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(ll i=ll(a);i<ll(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(),(V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long;
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; }
inline void Yes(bool condition){ if(condition) PRINT("Yes"); else PRINT("No"); }
template<class itr> void cins(itr first,itr last){
for (auto i = first;i != last;i++){
cin >> (*i);
}
}
template<class itr> void array_output(itr start,itr goal){
string ans = "",k = " ";
for (auto i = start;i != goal;i++) ans += to_string(*i)+k;
if (!ans.empty()) ans.pop_back();
PRINT(ans);
}
ll gcd(ll a, ll b) {
return a ? gcd(b%a,a) : b;
}
const ll INF = 1e15;
const ll MOD = 1000000007;
const ll MOD2 = 998244353;
typedef pair<ll,ll> P;
typedef pair<double,double> point;
const ll MAX = 2010;
constexpr ll nx[8] = {1,0,-1,0,-1,-1,1,1};
constexpr ll ny[8] = {0,1,0,-1,-1,1,-1,1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
string s;
cin >> n >> s;
bool out = 0;
vector<ll> a(2*n,0),index;
ll cnt = 0;
if (s[0] == 'W' || s[2*n-1] == 'W'){
out = 1;
}
a[0]++;
rep(i,1,2*n-1){
if (s[i] == s[i-1]){
a[i] = 1-a[i-1];
}
else{
a[i] = a[i-1];
}
}
rep(i,2*n){
if (a[i] == 0){
index.push_back(i);
cnt++;
}
}
if (cnt != n) out = 1;
if (out){
PRINT(0);
return 0;
}
rep(i,2*n-1) a[i+1] += a[i];
ll ans = 1;
index.push_back(2*n-1);
rep(i,n){
ans *= a[index[i]]-i;
ans %= MOD;
}
rep(i,1,n+1){
(ans *= i)%=MOD;
}
PRINT(ans);
}
|
#include<iostream>
using namespace std;
int main(){
long long a[100000],b,n;
int p=0,q=0;
cin>>n;
for (int i=0;i<n;i++) cin>>a[i];
b=a[0];
for(int i=0;i<n;i++){
if(a[i]==0) {
b=0;
p=1;
break;
}
}
long long x=1000000000000000000;
if(p==0) for (int i=0;i<n;i++){
x=x/a[i];
if(x<1) {
q=1;
break;
}
}
if(p==0&&q==0) for(int i=1;i<n;i++){
b=b*a[i];
}
if(p==1&&q==0)cout<<0;
else if(p==0&&q==1) cout<<-1;
else cout<<b;
return 0;
}
| 0
| 7,395,240
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
#include<queue>
#include<chrono>
#include<iomanip>
#include<map>
#include<set>
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
void init_io(){
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(10);
}
signed main(){
init_io();
ll n,l,ans_i=-1;
cin >> n >> l;
vector<ll> a(n);
for(int i=0;i<n;i++){
cin >> a[i];
}
for(int i=0;i<n-1;i++){
if(a[i]+a[i+1]>=l){
ans_i=i;
break;
}
}
if(ans_i==-1){
cout <<"Impossible"<<endl;
}else{
cout <<"Possible"<<endl;
for(int i=0;i<ans_i;i++){
cout << i+1<<endl;
}
for(int i=n-2;i>ans_i;i--){
cout << i+1<<endl;
}
cout << ans_i+1<<endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef pair<ll, int> li;
typedef pair<int, ll> il;
typedef vector<ii> vii;
typedef vector<il> vil;
typedef vector<li> vli;
#define F first
#define S second
#define pb(x) push_back(x)
#define mp(a,b) make_pair(a,b)
#define sz size()
#define all(A) A.begin(), A.end()
#define mem(a, b) memset(a, b, sizeof(a))
#define f0(i,b) for(int i=0;i<(b);i++)
#define f1(i,b) for(int i=1;i<=(b);i++)
#define f2(i,a,b) for(int i=(a);i<=(b);i++)
#define fr(i,b,a) for(int i=(b);i>=(a);i--)
#define rep(i,a,b,c) for(int i=(a);i!=(b);i+=(c))
#define mod 1000000007
#define forr(i,n) for(i=0; i<n; i++)
#define whilee(i,t) while(i!=t)
#define sl(a) scanf("%lld",&a)
#define pl(a) printf("%lld",a)
string S, T, U;
ll i, j, k, a, b, c, d, f, g, h, l, m, n, p, q, r, s, t, w, x, y, z, maxx=INT_MIN, minn=INT_MAX, ans=0, sum=0, cnt=0;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin>>t;
int A[3];
forr(i,t)
{
cin>>A[0]>>A[1]>>A[2];
sort(A,A+3);
if((A[2]*A[2])==(A[0]*A[0]+A[1]*A[1]))
{
cout<<"YES"<<endl;
}
else
{
cout<<"NO"<<endl;
}
}
return 0;
}
| 0
| 64,141,720
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
int main(void){
char buf[128] = { 0 };
short grid[64][64] = { {0} };
int H,W;
fgets(buf, sizeof(buf), stdin);
sscanf(buf, "%d %d", &H, &W);
for(int i = 0; i < H; i++){
memset(buf, 0, sizeof(buf));
fgets(buf, sizeof(buf), stdin);
for(int j = 0; j < W; j++)
if(buf[j] == '#') grid[i+1][j+1] = 1;
}
int flag = 0;
for(int i = 1; i < H+1; i++){
for(int j = 1; j < W+1; j++){
if(grid[i][j] == 0) continue;
else{
if(grid[i-1][j] != 1 && grid[i][j-1] != 1
&& grid[i+1][j] != 1 && grid[i][j+1] != 1){
flag = 1;
break;
}
}
}
if(flag) break;
}
if(flag == 0) printf("Yes\n");
else printf("No\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,t0,t1,t2,t3;
cin >> N;
t0=N/1000;
t1=(N-1000*t0)/100;
t2=(N-1000*t0-100*t1)/10;
t3=(N-1000*t0-100*t1-10*t2);
if (t1==t0){
if(t2 == t1){
cout << "Yes" << endl;
}
else{
cout<< "No" << endl;
}
}
else{
if(t1==t2){
if(t2==t3){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
}
else{
cout << "No" << endl;
}
}
}
| 0
| 98,550,666
|
#include <iostream>
#include <vector>
using namespace std;
int main(){
int n,ans=0,now;
cin >> n;
vector<int> a(n);
for(int i = 0; i < n; ++i){
cin >> a.at(i);
}
now = 0;
for(int i = 0; i < n; ++i){
now = a.at(now)-1;
if(now == 1){
cout << (i + 1) << endl;
return 0;
}
}
cout << -1 << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m; i < n; ++i)
#define FORR(i, m, n) for (ll i = m; i >= n; --i)
#define ALL(v) (v).begin(),(v).end()
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 ll INF=1LL<<60;
const int inf=(1<<30)-1;
const int mod=1e9+7;
int dx[8]={1,0,-1,0,-1,-1,1,1};
int dy[8]={0,1,0,-1,-1,1,-1,1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n,m;cin >> n >> m;
vector<vector<ll>> x(n,vector<ll>(3));
REP(i,n){
REP(j,3){
cin >> x[i][j];
}
}
ll ans=0;
REP(i,1<<3){
vector<ll> p(n);
REP(j,n){
ll res=0;
REP(k,3){
res+=x[j][k]*(i&(1<<k)?1:-1);
}
p[j]=res;
}
sort(ALL(p));
reverse(ALL(p));
ll sum=0;
REP(j,m){
sum+=p[j];
}
chmax(ans,sum);
}
cout << ans << endl;
}
| 0
| 20,446,834
|
#include<cctype>
#include<cstdio>
#include<iostream>
using namespace std;
int main(){
char ch;
while(1){
scanf("%c", &ch);
if( isalpha(ch)){
if(islower(ch)){
printf( "%c", toupper(ch));
} else{
printf("%c", tolower(ch));
}
}else{
printf("%c", ch);
}
if(ch =='\n') break;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
vector<int> d(10),e(10);
for(int i = 1;i<10;i++)
{
int now = i*2;
int num = 2;
int cnt = 1;
while(now != i)
{
if(now>9)
{
now = now%10+now/10;
cnt++;
if(now==i)break;
}
now += i;
num++;
cnt++;
if(now==i)break;
if(now>9)
{
now = now%10+now/10;
cnt++;
}
}
d[i]= num;
e[i]= cnt;
d[i]--;
}
d[0] = 1;
e[0]=1;
int n;
cin >> n;
ll ans = 0;
int now = 0;
map<ll,ll> mp;
for(int i = 0;i<n;i++)
{
ll x,y;
cin >> x >> y;
mp[x] += y;
}
for(int i = 0;i<10;i++)
{
if(mp[i]>0)
{
mp[i]--;
ans += mp[i]/d[i]*e[i];
mp[i]%=d[i];
mp[i]++;
for(int j = 0;j<mp[i];j++)
{
now += i;
ans++;
if(now>9)
{
now = now/10+now%10;
ans++;
}
}
}
}
cout << ans -1<< endl;
}
| 0
| 18,795,997
|
#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 bit(b) (1ll << (b))
using namespace std;
using i32 = int;
using i64 = long long;
using u64 = unsigned long long;
using f80 = long double;
using vi32 = vector<i32>;
using vi64 = vector<i64>;
using vu64 = vector<u64>;
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) { return a / gcd(a, b) * b; }
inline u64 xorshift() { static u64 x = 88172645463325252ull; x = x ^ (x << 7); return x = x ^ (x >> 9); }
void solve(); int main() { ios::sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(16); solve(); return 0; }
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 power(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; }
template <typename T, typename S> istream& operator>>(istream &is, pair<T, S> &p) { is >> p.first >> p.second; return is; }
template <typename T, typename S> ostream& operator<<(ostream &os, pair<T, S> &p) { os << p.first << ' ' << p.second; return os; }
int N;
vector<int> a;
bool check(int x) {
map<int, int> ma;
for (int i = 1; i < N; i++) {
if (a[i - 1] < a[i]) {
continue;
}
if (x == 1) return false;
int idx = a[i];
auto it = ma.upper_bound(idx);
while (it != ma.end()) {
ma.erase(it++);
}
while (true) {
ma[idx]++;
if (ma[idx] < x) {
break;
}
if (idx == 1) return false;
ma.erase(idx);
idx--;
}
}
return true;
}
void solve() {
cin >> N;
a.resize(N); cin >> a;
int ok = 200000, ng = 0;
while (ok - ng > 1) {
int md = (ok + ng) / 2;
check(md) ? (ok = md) : (ng = md);
}
cout << ok << '\n';
}
|
#include<iostream>
#include<string>
#include<cstdio>
using namespace std;
int n;
struct Node{
int key;
Node *p, *l, *r;
};
Node *NIL, *root;
void preorder(Node *u){
if(u == NIL) return;
cout << ' ' << u->key;
preorder(u->l);
preorder(u->r);
}
void inorder(Node *u){
if(u == NIL) return;
inorder(u->l);
cout << ' ' << u->key;
inorder(u->r);
}
void insert(int k){
Node *y = NIL;
Node *x = root;
Node *z;
z = new Node[1];
z->key = k;
z->p = NIL;
z->r = NIL;
z->l = NIL;
while(x != NIL){
y = x;
if(z->key < x->key) x = x->l;
else x = x->r;
}
z->p = y;
if(y == NIL){
root = z;
}
else if(z->key < y->key) y->l = z;
else y->r = z;
}
void find(int k){
Node *x = root;
while(x != NIL){
if(k == x->key) break;
else if(k > x->key) x = x->r;
else x = x->l;
}
if(x == NIL) cout << "no" << endl;
else cout << "yes" << endl;
}
Node *getMinimum(Node *x){
while(x->l != NIL){
x = x->l;
}
return x;
}
Node *getsuccessor(Node *x){
if(x->r != NIL) return getMinimum(x->r);
Node *y = x->p;
while(y != NIL && x == y->r){
x = y;
y = y->p;
}
return y;
}
void deletex(int k){
Node *z = root;
while(z->key != k){
if(k > z->key) z = z->r;
else z = z->l;
}
Node *y;
if(z->l == NIL || z->r == NIL) y = z;
else y = getsuccessor(z);
Node *x;
if(y->l != NIL) x = y->l;
else x = y->r;
if(x != NIL) x->p = y->p;
if(y->p == NIL) root = x;
else if(y == y->p->l) y->p->l = x;
else y->p->r = x;
if(y != z) z->key = y->key;
}
void maxheapify(int *A, int x){
int largest, t;
if(2 * x <= n && A[x] < A[2 * x]){
largest = 2 * x;
}
else{
largest = x;
}
if(2 * x + 1 <= n && A[largest] < A[2 * x + 1]){
largest = 2 * x + 1;
}
if(x != largest){
t = A[x];
A[x] = A[largest];
A[largest] = t;
maxheapify(A, largest);
}
}
void buildmaxheap(int *A){
for(int i = n / 2; i >= 1; i--){
maxheapify(A, i);
}
}
void heapinsertmax(int *A, int i, int key){
if(key < A[i]) cout << "error";
A[i] = key;
while(i > 1 && A[i] > A[i / 2]){
int t = A[i];
A[i] = A[i / 2];
A[i / 2] = t;
i = i / 2;
}
}
void insert(int *A, int key){
n++;
A[n] = -1;
heapinsertmax(A, n, key);
}
void heapextractmax(int *A){
if(n < 1) cout << "error";
cout << A[1] << endl;
A[1] = A[n];
n--;
maxheapify(A, 1);
}
int main(){
n = 0;
int *A = new int[2000000000];
string s;
int x;
while(1){
cin >> s;
if(s == "end") break;
else if(s == "insert"){
cin >> x;
insert(A, x);
}
else if(s == "extract"){
heapextractmax(A);
}
}
return 0;
}
| 0
| 69,625,586
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <map>
#include <set>
using namespace std;
void solve(){
int a, b, c, d; cin >> a >> b >> c >> d;
string ans;
if(a + b > c + d) ans = "Left";
else if(a + b < c + d) ans = "Right";
else ans = "Balanced";
cout << ans << endl;
return;
}
int main(){
solve();
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
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; }
const long long INF = 1LL << 60;
const int mod = 1000000007;
ll dp[100100];
int jij(int x,int y){
int ans = 0;
while(y<x){
y*=2;
ans++;
}
return ans;
}
int main() {
int n,k;
cin >> n >> k;
double p=0.0;
for(int i = 1;i<=n;++i){
double d =1.0;
rep(j,jij(k,i)) d/=2;
p+=d;
}
cout << fixed <<setprecision(10) << p/n <<endl;
}
| 0
| 58,204,604
|
#include<cstdio>
#include<iostream>
int a[5];
int swa;
int change(int n){
swa=a[n],a[n]=a[n-1],a[n-1]=swa;
}
int main(){
for(int i=0;i<5;i++)
scanf("%d",&a[i]);
for(int i=4;i>=0;i--){
for(int j=4;j>0;j--){
if(a[j-1]<a[j])
change(j);
}
}
for(int i=0;i<4;i++)
printf("%d ",a[i]);
printf("%d\n",a[4]);
return 0;
}
|
#include <iostream>
#include <algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<iomanip>
#include<ctime>
#include<set>
#include<map>
#include<queue>
#include<stack>
#define sqr(x) ((x)*(x))
#define fz1(i,n) for ((i)=1;(i)<=(n);(i)++)
#define fd1(i,n) for ((i)=(n);(i)>=1;(i)--)
#define fz0g(i,n) for ((i)=0;(i)<=(n);(i)++)
#define fd0g(i,n) for ((i)=(n);(i)>=0;(i)--)
#define fz0k(i,n) for ((i)=0;(i)<(n);(i)++)
#define fd0k(i,n) for ((i)=(long long)((n)-1);(i)>=0;(i)--)
#define fz(i,x,y) for ((i)=(x);(i)<=(y);(i)++)
#define fd(i,y,x) for ((i)=(y);(i)>=(x);(i)--)
#define fzin fz1(i,n)
#define fzim fz1(i,m)
#define fzjn fz1(j,n)
#define fzjm fz1(j,m)
#define ff(c,itr) for (__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++)
#define rdst(st,len){static char ss[len];scanf(" %s",ss);(st)=ss;}
#define inc(x,y) {x+=(y);if(x>=mod)x-=mod;}
#define dec(x,y) {x-=(y);if(x<0)x+=mod;}
#define spln(i,n) (i==n?'\n':' ')
using namespace std;
long long n,m,i,j,a[200005],pre[200005],suf[200005],ans;
int main()
{
scanf("%lld%lld",&n,&m);
fz1(i,n){
scanf("%lld",&a[i]);
pre[i]=pre[i-1]+max(a[i],0ll);
}
fd1(i,n){
suf[i]=suf[i+1]+max(a[i],0ll);
}
fz1(i,n){
a[i]+=a[i-1];
}
fz1(i,n-m+1){
ans=max(ans,a[i+m-1]-a[i-1]+pre[i-1]+suf[i+m]);
ans=max(ans,pre[i-1]+suf[i+m]);
}
cout<<ans<<endl;
return 0;
}
| 0
| 52,441,784
|
#include<iostream>
#include<string>
#include<vector>
using namespace std;
int main()
{
string s,t;
int flg = 0;
cin>>s>>t;
for(int i = 0; i < s.length(); i++)
{
if(s[i] != t[i])
{
flg++;
}
}
cout<<flg;
cout<<endl;
return 0;
}
|
#include <iostream>
#include <cstring>
#include <map>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <set>
#include <vector>
#include <queue>
#include <list>
#include <numeric>
#include <stdio.h>
#include <string>
#include <cstdlib>
#include <math.h>
#include <stack>
#include <climits>
#include <bitset>
#include <utility>
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; }
ll gcd(ll x, ll y) {
ll tmp = 0;
if (x < y){
tmp=x;
x=y;
y=tmp;
}
while (y > 0) {
ll r = x % y;
x = y;
y = r;
}
return x;
}
ll lcm(ll x,ll y){
return x/gcd(x,y)*y;
}
const int MAX = 1e6+1;
const int MOD = 1e9+7;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll kaijo(ll k){
ll sum = 1;
for (ll i = 1; i <= k; ++i)
{
sum *= i;
sum%=1000000000+7;
}
return sum;
}
ll lmax(ll s,ll t){
if(s>t){
return s;
}
else{
return t;
}
}
ll lmin(ll s,ll t){
if(s<t){
return s;
}
else{
return t;
}
}
long long modpow(long long res,long long a, long long n, long long mod) {
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
vector<bool> IsPrime;
void sieve(size_t max){
if(max+1 > IsPrime.size()){
IsPrime.resize(max+1,true);
}
IsPrime[0] = false;
IsPrime[1] = false;
for(size_t i=2; i*i<=max; ++i)
if(IsPrime[i])
for(size_t j=2; i*j<=max; ++j)
IsPrime[i*j] = false;
}
int main(){
string s;
cin>>s;
if(s[0]=='Y'&&s[1]=='A'&&s[2]=='K'&&s[3]=='I') cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
}
| 0
| 35,850,191
|
#include <iostream>
#include <string>
int main() {
int a, b;
auto mark = ">";
std::cin >> a >> b;
if (a > b)
{
mark = ">";
}
else if(a < b)
{
mark = "<";
}
else mark = "==";
std::cout << "a" << " " << mark << " " << "b" << std::endl;
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<stdexcept>
#include<cmath>
#include<fstream>
#include<memory>
#include<algorithm>
#include<cstring>
#include<ctime>
#include<deque>
#include<sstream>
#include<iomanip>
#include<sstream>
#include<vector>
#include<queue>
#include<stack>
#include<string>
#include<climits>
#include<map>
#include<set>
#include<list>
#include<cassert>
#include<deque>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define INF 1<<27
#define all(n) n.begin(),n.end()
#define insert(a,b,c,d) PP(P(a,b),P(c,d))
#define F first
#define iter(c) __typeof__((c).begin())
#define foreach(i,c) for(iter(c) i=(c).begin();i!=(c).end();++i)
#define S second
#define pb push_back
#define pf push_front
#define LIM 100000
using namespace std;
typedef pair<int,int> P;
typedef pair<P,P> PP;
typedef long long ll;
typedef unsigned long long ull;
int di[3] = {3600,60,1};
int getTime(string s){
rep(i,s.length())if(s[i] == ':')s[i] = ' ';
stringstream ss;
ss << s;
int ret = 0;
for(int i=0;i<3;i++){
string pre;
ss >> pre;
int tim = (atoi)(pre.c_str());
ret += tim*di[i];
}
return ret;
}
int main(){
int n;
while(true){
cin >> n;
if(n == 0)break;
string star,endar;
vector<P> vec;
rep(i,n){
cin >> star >> endar;
int st,ed;
st = getTime(star);
ed = getTime(endar);
vec.pb(P(st,ed));
}
sort(all(vec));
int cnt = 0;
int mex = 0;
rep(i,n){
cnt = 1;
for(int j=i-1;j>=0;j--){
if(vec[j].S <= vec[i].F)continue;
cnt++;
}
mex = max(cnt,mex);
}
cout << mex << endl;
}
return 0;
}
| 0
| 91,700,256
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n; cin >> n;
vector<int> a(n + 2);
for (int i = 1; i < n + 1; i++) cin >> a[i];
int s = 0;
for (int i = 0; i < n + 1; i++) {
s += abs(a[i+1] - a[i]);
}
for (int i = 1; i < n + 1; i++) {
int res;
if (a[i-1] <= a[i] && a[i] <= a[i+1]) res = s;
else if (a[i-1] >= a[i] && a[i] >= a[i+1]) res = s;
else res = s - 2 * min(abs(a[i] - a[i-1]), abs(a[i+1] - a[i]));
cout << res << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int N, Q;
vector<vector<int>> graph(0, vector<int>());
void rOp(int v, int p, vector<ll> & score){
if(p != -1) score[v] += score[p];
for (auto elem : graph[v])
{
if(elem == p) continue;
rOp(elem, v, score);
}
}
int main(void)
{
cin >> N >> Q;
graph.resize(N);
vector<ll> ans(N);
for (int i = 0; i < N - 1; i++)
{
int a, b;
cin >> a >> b;
graph[a-1].push_back(b-1);
graph[b-1].push_back(a-1);
}
for (int i = 0; i < Q; i++)
{
int p, x;
cin >> p >> x;
ans[p-1] += (ll) x;
}
rOp(0, -1, ans);
for (int i = 0; i < N; i++)
{
cout << ans[i] << endl;
}
return 0;
}
| 0
| 28,222,357
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,N) for(int i=0;i<int(N);++i)
using ll = long long;
const int INF = 2147483647;
const ll MOD = 1000000007;
string func(int a){
string num;
if(a<100)
num+='0';
else
num+=to_string(a/100);
if(a<10)
num+='0';
else
num+=to_string(a/10%10);
num+=to_string(a%10);
return num;
}
int main(){
int n;
cin >> n;
string s;
cin >> s;
int ans=0;
for(int i=0;i<1000;i++){
int ncnt=0;
string now = func(i);
for( int j=0;j<s.size();j++){
if(now[ncnt]==s[j])
ncnt++;
if(ncnt==3){
ans++;
break;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define all(x) (x).begin(),(x).end()
using ll = long long;
string char_to_string(char val) {
return string(1, val);
}
int char_to_int(char val) {
return val - '0';
}
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ll N, K, S; cin >> N >> K >> S;
ll cnt = 0;
vector<ll> A;
while(true) {
if(cnt == K) break;
A.push_back(S);
cnt++;
}
for(int i = 0; i < N - K; ++i) {
if(S == 1000000000) A.push_back(S - 1);
else A.push_back(S + 1);
}
REP(i, A.size()) {
cout << A[i] << " ";
}
cout << endl;
}
| 0
| 55,499,080
|
#include <bits/stdc++.h>
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; }
const ll INF = 1LL << 60;
const int MAX = 1000000010;
const ll MOD = 1000000007;
const double PI = acos(-1);
int main() {
ll N, K; cin >> N >> K;
ll ans = K;
for (int i = 0; i < N - 1; i++) {
ans *= K - 1;
}
cout << ans << endl;
return 0;
}
|
#include<iostream>
using namespace std;
int main()
{
int a[5],c;
for(int i=0 ; i<5 ; i++){
cin >> a[i];
}
for(int i=0 ; i<4 ; i++){
for(int j=i+1 ; j<5 ; j++){
if(a[j]>a[i]){
c=a[j];
a[j]=a[i];
a[i]=c;
}
}
}
for(int i=0 ; i<5 ; i++){
cout << a[i];
(i!=4) ? cout << ' ' : cout << '\n';
}
return 0;
}
| 0
| 50,893,354
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
using ll = long long;
const int INF = 1001001001;
const ll INF_LL = 1001001001001001001LL;
int main(void){
string s; cin >> s;
bool dup = false;
for(int i = 0;i<s.size();i++)
for(int j = i+1;j<s.size();j++)
if(s[i]==s[j]) dup = true;
if(!dup) cout << "yes" << endl;
else cout << "no" << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
ll f[10000050],n;
int main(){
cin >> n;
for(ll i=1; i<=n; i++){
for(ll j=i; j<=n; j+=i){
f[j]++;
}
}
ll cnt=0;
for(ll i=1; i<=n; i++){
cnt+=i*f[i];
}
cout << cnt << endl;
}
| 0
| 93,690,379
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
#define mod ((int)1e9+7)
#define lim 1000000000000000007
#define lim1 18446744073709551615
#define sq(a) ((a)*(a))
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define mms(v,i) memset(v,i,sizeof(v))
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define REP(i,a,b) for (int i = a; i <= b; i++)
#define REPN(i,a,b) for (int i = a; i >= b; i--)
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
typedef pair<int,int> pi;
typedef pair<ll,ll> PL;
typedef pair<ll,int> PLI;
typedef pair<int,ll> PIL;
typedef pair<int,pair<int,int> > pii;
typedef pair<double,double> pdd;
typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> indexed_set;
typedef tree<pi,null_type,less<pi>,rb_tree_tag,tree_order_statistics_node_update> indexed_set_pair;
ll power(ll a,ll b) {
ll res=1;
while(b){
if(b%2==1) res=(res*a)%mod;
a=(a*a)%mod;
b>>=1;
}
return res;
}
ll gcdll(ll a,ll b) {
if (b==0) return a;
return gcdll(b,a%b);
}
int gcd(int a,int b) {
if (b==0) return a;
return gcd(b,a%b);
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
const int N = (int)1e6+5;
const int M = (int)1e3+5;
const int Q = 102;
const int logN = 19;
const double pie = acos(-1);
int freq[N], sieve[N], a[N];
void solve() {
int n;
cin>>n;
int overall_gcd = 0;
REP(i,1,n) {
cin>>a[i];
freq[a[i]]++;
overall_gcd = __gcd(overall_gcd, a[i]);
}
bool pairwise_coprime = true;
REP(i,2,N-1) {
int cnt_multiples = 0;
for(int j=i;j<N;j+=i) {
cnt_multiples += freq[j];
}
if(cnt_multiples > 1) {
pairwise_coprime = false;
break;
}
}
if(pairwise_coprime) {
cout << "pairwise coprime";
}
else if(overall_gcd == 1) {
cout << "setwise coprime";
}
else {
cout << "not coprime";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T=1;
REP(TC,1,T) {
solve();
cout<<"\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using PLL = pair<ll, ll>;
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repn(i,n) for(int i = 0; i <= (int)(n); i++)
#define srep(i,l,n) for(int i = l; i < (int)(n); i++)
#define srepn(i,l,n) for(int i = l; i <= (int)(n); i++)
#define drep(i,n) for(int i = (int)(n-1); i >= 0; i--)
#define drepn(i,n) for(int i = (int)(n); i >= 0; i--)
#define size(s) (int)s.size()
#define debug(var) do{std::cout << #var << " : ";view(var);}while(0)
template<typename T> void view(T e){std::cout << e << std::endl;}
template<typename T> void view(const std::vector<T>& v){for(const auto& e : v){ std::cout << e << " "; } std::cout << std::endl;}
template<typename T> void view(const std::vector<std::vector<T> >& vv){ for(const auto& v : vv){ view(v); } }
template<typename T> inline istream& operator>>(istream &i, vector<T> &v) {rep(j, size(v)) i >> v[j]; return i;}
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template<class T> T gcd(T a, T b) {if(b==0)return a; else return gcd(b,a%b);}
template<class T> T lcm(T a, T b) {return a/gcd(a,b)*b;}
template<class T = int> using V = vector<T>;
template<class T = int> using VV = vector<V<T>>;
bool isIn(int i, int j, int h, int w) {return i >= 0 && i < h && j >= 0 && j < w;}
void Yes(){cout << "Yes" << endl;}
void No(){cout << "No" << endl;}
void YES(){cout << "YES" << endl;}
void NO(){cout << "NO" << endl;}
void err() {cout << -1 << endl;}
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define pb push_back
#define ep emplace_back
const int MOD = 1000000007;
const int INF = 1e9;
#define PI acos(-1);
int dx[4] = {1,-1,0,0};
int dy[4] = {0,0,1,-1};
int ddx[8] = {1,1,1,-1,-1,-1,0,0};
int ddy[8] = {0,1,-1,0,1,-1,1,-1};
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
string s;
ll k;
cin >> s >> k;
int cnt = -1;
k = min((ll)size(s), k);
rep(i, k) {
if(s[i] != '1') {
cnt = i;
break;
}
}
if(cnt == -1) printf("%c\n", s[k-1]);
else printf("%c\n", s[cnt]);
}
| 0
| 61,620,089
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, A;
cin >> N;
cin >> A;
int k = N*N - A;
cout << k;
return 0;
}
|
#include <cstdio>
#include <string>
#include <vector>
using namespace std;
struct Card {
char suite;
int value;
bool operator==(const Card& rhs) const
{
return suite == rhs.suite && value == rhs.value;
}
};
void bubbleSort(vector<Card>& v)
{
for (size_t i = 0; i < v.size(); ++i) {
for (size_t j = v.size() - 1; j >= i + 1; --j) {
if (v[j].value < v[j - 1].value) {
swap(v[j], v[j - 1]);
}
}
}
}
void selectionSort(vector<Card>& v)
{
for (size_t i = 0; i < v.size(); ++i) {
auto mini = i;
for (size_t j = i; j < v.size(); ++j) {
if (v[j].value < v[mini].value) {
mini = j;
}
}
swap(v[i], v[mini]);
}
}
bool isStableSort(const vector<Card>& raw, const vector<Card>& sorted)
{
for (size_t i = 0; i < sorted.size() - 1; ++i) {
auto&& a = sorted[i];
auto&& b = sorted[i + 1];
if (a.value == b.value) {
int a_pos;
int b_pos;
for (size_t j = 0; j < raw.size(); ++j) {
if (raw[j] == a) {
a_pos = j;
}
else if (raw[j] == b) {
b_pos = j;
}
}
if (!(a_pos < b_pos)) {
return false;
}
}
}
return true;
}
int main()
{
int N;
scanf("%d\n", &N);
vector<Card> vc;
for (auto i = 0; i < N; ++i) {
char c;
int n;
scanf("%c%d ", &c, &n);
vc.push_back(Card{c, n});
}
auto p = [](const vector<Card>& v) {
for (size_t i = 0; i < v.size(); ++i) {
printf("%c%d", v[i].suite, v[i].value);
if (i != v.size() - 1) {
putchar(' ');
}
}
putchar('\n');
};
{
auto t = vc;
bubbleSort(t);
p(t);
if (isStableSort(vc, t)) {
printf("Stable\n");
}
else {
printf("Not stable\n");
}
}
{
auto t = vc;
selectionSort(t);
p(t);
if (isStableSort(vc, t)) {
printf("Stable\n");
}
else {
printf("Not stable\n");
}
}
}
| 0
| 77,816,162
|
#include <bits/stdc++.h>
using namespace std ;
int main()
{
int i,a,b,n,c=0;
cin>>n;
cin>>a>>b;
for(i=a;i<=b;i++){
if(i%n==0)
{
c++;
}
}
if(c>=1)
cout<<"OK"<<endl;
else
cout<<"NG"<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct _dot{
int a;
int b;
}Dot;
int Distance(Dot a,Dot b){
return abs(a.a-b.a) + abs(a.b - b.b);
}
int main(void){
int N,M;
cin >> N >> M;
Dot student[N];
Dot CheckPoint[M];
for(int i=0;i<N;i++){
cin >> student[i].a;
cin >> student[i].b;
}
for(int i=0;i<M;i++){
cin >> CheckPoint[i].a;
cin >> CheckPoint[i].b;
}
for(int i=0;i<N;i++){
int max,index=1;
for(int j=0;j<M;j++){
if(j==0){max = Distance(student[i],CheckPoint[j]);}
else{if(max > Distance(student[i],CheckPoint[j])){ max = Distance(student[i],CheckPoint[j]); index = j+1;}}
}
cout << index << endl;
}
}
| 0
| 81,887,821
|
#include <cstdio>
#include <cmath>
#include <utility>
#include <vector>
using namespace std;
#define nmax 10005
int Countingsort( int A[], int B[], int n){
int i, j;
int C[ nmax ] = {};
for( j = 0 ; j < n ; j++ ){
C[ A[j] ]++;
}
for( j = 1; j < nmax ; j++ ){
C[j] = C[j] + C[j-1];
}
for( j = n-1; j >= 0; j-- ){
B[ C[ A[j] ] ] = A[j];
C[ A[j] ]--;
}
for( i = 1 ; i <= n ; i++ ){
if( i > 1 ) printf(" ");
printf("%d", B[i]);
}
printf("\n");
}
int main(){
int n, i;
scanf("%d", &n);
int A[n], B[n+1] = {};
for( i = 0; i < n ; i++ ){
scanf("%d", &A[i]);
}
Countingsort( A, B, n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(int argc, char **argv)
{
bool flag;
int N;
cin >> N;
vector<ll> a(N+10);
vector<ll> b(N+10);
for (int i = 0; i < N; ++i)
cin >> a[i];
for (int i = 0; i < N; ++i)
cin >> b[i];
ll larger_a{0}, larger_b{0};
for (int i = 0; i < N; ++i)
{
if (a[i] > b[i]) larger_a += a[i] - b[i];
if (b[i] > a[i]) larger_b += (b[i] - a[i]) / 2;
}
if (larger_a <= larger_b) std::cout << "Yes" << std::endl;
else std::cout << "No" << std::endl;
}
| 0
| 59,781,992
|
#include<bits/stdc++.h>
using namespace std;
#define fraction() cout.unsetf(ios::floatfield); cout.precision(10); cout.setf(ios::fixed,ios::floatfield);
#define file() freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#define faster() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
const long long int infLL = 9000000000000000000;
#define mem(a,b) memset(a, b, sizeof(a) )
#define all(a) (a).begin(),(a).end()
#define mx_int_prime 999999937
const int inf = 2000000000;
const double PI = acos(-1);
const double eps = 1e-9;
typedef long double ld;
#define MOD 1000000007
typedef long long ll;
const int mx=2e5+125;
ll pr[mx],ar[mx],br[mx];
#define PB push_back
#define endl '\n'
#define S second
#define F first
int main()
{
ll n;
cin >> n;
bool e=false;
if(n%2==0)
e=true;
if(!e)
{
cout << 0 << endl;
return 0;
}
ll a=0;
n /= 10;
a += n;
while(n>=5)
{
n /= 5;
a += n;
}
cout << a << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define boost ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define all(v) v.begin(),v.end()
#define pb push_back
#define endl '\n'
#define mp make_pair
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef pair<int,int> pi;
typedef pair<long long,long long> pll;
typedef set<int> si;
const ll mod = 1e9 + 7;
const ll modl=998244353;
const double pie=3.1415926535;
ull power(ull x,ull y){
if(y==0) return 1;
else{
if(y%2==0) return power(x*x,y/2);
else return x*power(x*x,(y-1)/2);
}
}
ll mod_power(ll x, ll y, ll m)
{
ll r = 1;
x = x % m;
if (x == 0) return 0;
while (y > 0)
{
if (y & 1)
r = (r*x) % m;
y = y/2;
x = (x*x) % m;
}
return r;
}
ll gcd(ll x,ll y){
if(y==0)return x;
return gcd(y,x%y);
}
int main(){
boost;
int TESTS=1;
while(TESTS--){
int n,m;
cin>>n>>m;
vector<pi>close(n);
vector<int>open(n+1);
for(int i=0;i<n;i++){
int x,y;
cin>>x>>y;
open[i+1]=x;
close[i].first=y;
close[i].second=i+1;
}
sort(all(close));
int x=open[close[0].second];
int y=close[0].first;
int ans=0;
for(int i=1;i<n;i++){
auto p=close[i];
int t=p.first;
int j=p.second;
int temp=open[j];
if(temp>y){
x=0,y=-1;
break;
}
x=max(x,temp);
}
ans=y-x+1;
cout<<ans<<endl;
}
}
| 0
| 80,940,326
|
#include <iostream>
using namespace std;
int main()
{
int n;
cin>>n;
long long int ans=1000;
long long int counter=1000;
long long int a[n];
for(int i=0;i<n;i++)
{
cin>>a[i];
}
for(int i=0;i<n-1;i++)
{
if(a[i]<a[i+1])
{
counter=ans/a[i];
ans-=(counter)*a[i];
ans+=counter*a[i+1];
}
}
cout<<ans;
}
|
#include<bits/stdc++.h>
using namespace std;
int hea[100010],nxt[200010],to[200010],d[100010],tot;
long long v[100010];
void fason(int x,int y)
{
nxt[++tot]=hea[x];
hea[x]=tot;
to[tot]=y;
}
long long dfs(int x,int f,int fa)
{
if(d[x]==1)return v[x];
long long s=0;
for(int i=hea[x];i;i=nxt[i])
{
int y=to[i];
if(y==fa)continue;
long long t=dfs(y,0,x);
if(t==-1||t>v[x])return -1;
s+=t;
}
if(f==1)return s==v[x]*2?1:-1;
if(s>2*v[x]||v[x]-s>0)return -1;
else return 2*v[x]-s;
}
int main()
{
int n,x,y;
scanf("%d",&n);
for(int i=1;i<=n;i++)scanf("%lld",v+i);
for(int i=1;i<n;i++)
{
scanf("%d%d",&x,&y);
fason(x,y);
fason(y,x);
d[x]++;
d[y]++;
}
if(n==2)
{
puts(v[1]==v[2]?"YES":"NO");
return 0;
}
int rt;
for(int i=1;i<=n;i++)
if(d[i]>1)
{
rt=i;
break;
}
if(dfs(rt,1,0)==1)puts("YES");
else puts("NO");
return 0;
}
| 0
| 42,292,156
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
typedef pair<P,int> T;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000
#define sz(x) ((int)(x).size())
#define fi first
#define sec second
#define all(x) (x).begin(),(x).end()
#define sq(x) ((x)*(x))
#define rep(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
#define repn(i,a,n) for(int (i)=(a);(i)<(int)(n);(i)++)
#define EQ(a,b) (abs((a)-(b))<eps)
template<class T> void chmin(T& a,const T& b){if(a>b)a=b;}
template<class T> void chmax(T& a,const T& b){if(a<b)a=b;}
template<class T>
void dump(vector<T> &vec){
for(int i=0;i<vec.size();i++){
cout << vec[i];
if(i+1<vec.size())cout << ' ';
else cout << endl;
}
return;
}
int N;
int p[200100];
vi a,b,c;
int main(){
cin >> N;
for(int i=0;i<N;i++){
cin >> p[i];
}
a.resize(N);
b.resize(N);
c.resize(N);
for(int i=0;i<N;i++){
c[p[i]-1] = i;
}
a[0] = 1;
b[0] = c[0]-1;
for(int i=1;i<N;i++){
int diff = c[i]-c[i-1];
if(diff>=0){
a[i] = a[i-1]+diff+1;
b[i] = b[i-1]-1;
}else{
a[i] = a[i-1]+1;
b[i] = b[i-1]+diff-1;
}
}
int g = b[N-1];
for(int i=0;i<N;i++){
cout << a[i];
if(i+1<N)cout << ' ';
else cout << endl;
}
for(int i=0;i<N;i++){
cout << b[i]-g+1;
if(i+1<N)cout << ' ';
else cout << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int llu;
#define f1(i,n) for(i=1;i<=n;i++)
#define f(i,n) for(i=0;i<n;i++)
#define Max 100009
#define Mx 1e10
#define pb push_back
#define mp make_pair
using namespace std;
int main()
{
ll n,mn=0,mx=0,x,i,t=0,j=0,k=0;
set<ll>s;
cin>>n;
ll a[n],c[n],g[n];
f(i,n)
{
cin>>a[i];
}
sort(a,a+n);
for(i=n-1;i>=0;i--)
{
if(a[i]==a[i-1]&&a[i-1]==a[i-2]&&a[i-2]==a[i-3])
{
t=max(t,a[i]*a[i]);
}
else if(a[i]==a[i-1]&&mx==0)
{
mx=a[i];
}
else if(a[i]==a[i-1]&&mx!=a[i]&&a[i]>mn)
{
mn=a[i];
}
if(mx>0&&mn>0)
k=max(k,mx*mn);
}
cout<<max(k,t)<<endl;
}
| 0
| 63,422,548
|
#include<bits/stdc++.h>
#pragma GCC target ("avx2")
#pragma GCC optimization ("Ofast")
#pragma GCC optimization ("unroll-loops")
#pragma comment(linker, "/stack:200000000")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
#define int long long
typedef pair<int,int>pi;
typedef vector<int>vi;
const int MAXN=100005;
const int MOD=1000000007;
const int INF = 1e9+1;
#define FOR(i,a,b) for(int i=(a);i<=(b);i++)
#define DEC(i,a,b) for(int i=(a);i>=(b);i--)
#define pb push_back
#define mp make_pair
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(),(v).end()
#define db(x) cerr<<#x<<" = "<<x<<"\n"
#define LOW(v,x) (lower_bound(all(v),(x))-(v).begin())
#define UP(v,x) (upper_bound(all(v),(x))-(v).begin())
int N, M, A[MAXN], B[MAXN];
int plcm(int x, int y){
if (x>=INF && y>=INF) return INF;
int lcm = x*y/__gcd(x,y);
return min(lcm,INF);
}
main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
cin>>N>>M;
int prb = -1;
FOR(i,1,N){
cin>>A[i];
int tmp=A[i];
while (tmp%2==0){
tmp/=2;
B[i]++;
}
if (prb == -1) prb = B[i];
else if (prb != B[i]){
cout<<0;
exit(0);
}
}
int totlcm = 1;
FOR(i,1,N){
totlcm = plcm(totlcm, A[i]/2);
}
if (totlcm > M) {
cout<<0;
exit(0);
}
int ans = (M-totlcm)/(2*totlcm);
cout<<ans+1;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n;
cin >> n;
vector<string> s(n);
rep(i,n){
cin >> s.at(i);
sort(s.at(i).begin(),s.at(i).end());
}
vector<int> alp(26);
vector<int> ans(26,100);
int count=0;
rep(i,n){
int k=0;
rep(j,s.at(i).size()){
alp.at(s.at(i).at(j)-'a')++;
}
rep(j,26){
ans.at(j)=min(ans.at(j),alp.at(j));
alp.at(j)=0;
}
}
char a='a';
rep(i,26){
rep(j,ans.at(i)) cout << a;
a++;
}
cout << endl;
return 0;
}
| 0
| 78,958,136
|
#include<iostream>
using namespace std;
int main(){
int money,bell;
while(1){
cin >> money;
if(money==0){
break;
}
money=1000-money;
bell=0;
while(money!=0){
if(money>=500){
bell++;
money-=500;
}
else if(money>=100){
bell++;
money-=100;
}
else if(money>=50){
bell++;
money-=50;
}
else if(money>=10){
bell++;
money-=10;
}
else if(money>=5){
bell++;
money-=5;
}
else if(money>=1){
bell++;
money-=1;
}
}
cout << bell << endl;
}
}
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
const double pi = 3.141592653589793238462643383279;
const int INF = 1000000000;
const ll LINF = 100000000000000000;
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZABC";
const string abc = "abcdefghijklmnopqrstuvwxyzabc";
const ll MOD = 1000000007;
const int MAX = 1200000;
struct edge {
ll to;
ll cost;
};
struct UnionFind {
vector<int> UF;
vector<int> SIZE;
UnionFind(int N) : UF(N), SIZE(N, 1) {
for(int i = 0; i < N; i++) {
UF.at(i) = i;
}
}
int root(int x) {
if (UF.at(x) == x) {
return x;
}
return UF.at(x) = root(UF.at(x));
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) {
return;
}
if (SIZE.at(rx) < SIZE.at(ry)) {
UF.at(rx) = ry;
SIZE.at(ry) += SIZE.at(rx);
SIZE.at(rx) = 0;
}
else {
UF.at(ry) = rx;
SIZE.at(rx) += SIZE.at(ry);
SIZE.at(ry) = 0;
}
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
int size(int x) {
return SIZE.at(root(x));
}
};
int ctoi(char c){
if (c == '0') return 0;
if (c == '1') return 1;
if (c == '2') return 2;
if (c == '3') return 3;
if (c == '4') return 4;
if (c == '5') return 5;
if (c == '6') return 6;
if (c == '7') return 7;
if (c == '8') return 8;
if (c == '9') return 9;
return -1;
}
char to_char(int i){
if (i == 0) return '0';
if (i == 1) return '1';
if (i == 2) return '2';
if (i == 3) return '3';
if (i == 4) return '4';
if (i == 5) return '5';
if (i == 6) return '6';
if (i == 7) return '7';
if (i == 8) return '8';
if (i == 9) return '9';
return ' ';
}
ll BS(vector<int> V, int Q) {
int L = -1;
int R = V.size();
while (R - L > 1) {
int M = (L + R) / 2;
if (V.at(M) < Q) L = M;
else R = M;
}
if (R == int(V.size())) return INF;
return V.at(L);
}
ll BS2(vector<int> V, int Q) {
int L = -1;
int R = V.size();
while (R - L > 1) {
int M = (L + R) / 2;
if (V.at(M) < Q) L = M;
else R = M;
}
if (R == int(V.size())) return INF;
return V.at(R);
}
int main() {
cout << fixed << setprecision(16);
int H, W;
cin >> H >> W;
vector<vector<int>> T(H), Y(W);
for (int i = 0; i < H; i++) {
T.at(i).push_back(-1);
}
for (int i = 0; i < W; i++) {
Y.at(i).push_back(-1);
}
vector<vector<char>> S(H, vector<char>(W));
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
char C;
cin >> C;
S.at(i).at(j) = C;
if (C == '#') {
T.at(i).push_back(j);
Y.at(j).push_back(i);
}
}
}
for (int i = 0; i < H; i++) {
T.at(i).push_back(W);
sort(T.at(i).begin(), T.at(i).end());
}
for (int i = 0; i < W; i++) {
Y.at(i).push_back(H);
sort(Y.at(i).begin(), Y.at(i).end());
}
int ans = 0;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (S.at(i).at(j) == '.') {
int M = 0;
M += (BS2(T.at(i), j) - BS(T.at(i), j));
M += (BS2(Y.at(j), i) - BS(Y.at(j), i));
M -= 3;
ans = max(ans, M);
}
}
}
cout << ans << endl;
}
| 0
| 25,627,351
|
#include<bits/stdc++.h>
#include<vector>
#include<list>
#include<stack>
#include<queue>
#include<algorithm>
using namespace std;
struct UnionFind{
vector<int> data;
UnionFind(int size) : data(size,-1){}
bool unite(int x,int y){
x=root(x),y=root(y);
if(x!=y){
if(data[y]<data[x]){
swap(x,y);
}
data[x]+=data[y],data[y]=x;
}
return x!=y;
}
bool find(int x,int y){
return root(x)==root(y);
}
int root(int x){
return data[x]<0 ? x : data[x]=root(data[x]);
}
int size(int x){
return -data[root(x)];
}
};
int main(){
int n,q;
scanf("%d %d",&n,&q);
UnionFind uf(n);
for(int i=0;i<q;i++){
int c,x,y;
scanf("%d %d %d",&c,&x,&y);
if(c!=0){
if(uf.find(x,y)){
printf("%d\n",1);
}else{
printf("%d\n",0);
}
}else{
uf.unite(x,y);
}
}
return 0;
}
|
#include<iostream>
#include<string>
#include<map>
#include<vector>
using namespace std;
int main(void){
string str;
vector<string> w;
map<string,int> word;
unsigned int max=0,length=0;
while(cin>>str){
w.push_back(str);
if(word.find(str) != word.end()){
word[str]++;
}else{
word.insert(make_pair(str,1));
}
}
map<string,int>::iterator it;
for(it=word.begin();it!=word.end();it++){
if(max<it->second)
max=it->second;
}
for(it=word.begin();it!=word.end();it++){
if(max==it->second)
cout<<it->first<<" ";
}
for(unsigned int i=0;i<w.size();i++){
if(length<w[i].size()){
length=w[i].size();
}
}
for(unsigned int i=0;i<w.size();i++){
if(length==w[i].size()){
cout<<w[i]<<endl;
break;
}
}
return 0;
}
| 0
| 26,661,317
|
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
using ld=long double;
using pll=pair<ll,ll>;
using plll=pair<ll,pll>;
using graph=vector<vector<int>>;
using wgraph=vector<vector<pll>>;
const ll MOD=1000000007;
const int dx[4]={1,0,-1,0};
const int dy[4]={0,1,0,-1};
ll abs1(ll a){
if(a>=0)return a;
else return -a;
}
ll pow1(ll a,ll b,ll p=LLONG_MAX){
ll ret=1;
while(b!=0){
if((b&1)==1){
ret*=a;
}
a*=a;
if(a>=p)a%=p;
b=b>>1;
}
return ret;
}
int digit(ll a,ll b){
int i=0;
while(a!=0){
a/=b;
i++;
}
return i;
}
ll gcd1(ll a,ll b){
if(a==0 && b==0)return 0;
ll n;
while(a%b!=0){
n=a%b;
a=b;
b=n;
}
return b;
}
ll solveLinear(ll n,ll m,ll c){
if(n==0 && m==0)return 0;
ll a[100],b[100];
a[0]=n;b[0]=m;
int i=1;
while(b[i-1]!=0){
a[i]=b[i-1];
b[i]=a[i-1]%b[i-1];
i++;
}
n=i;
if(c%a[n-1]!=0){
return 0;
}
ll x=c/a[n-1],y=0;
for(i=1;i<n;i++){
ll cnt=x;
x=y;
y=cnt-(a[n-i-1]/b[n-i-1])*y;
}
return x;
}
ll modRev(ll a,ll p=MOD){
a%=p;
ll n=solveLinear(a,p,1);
n%=p;
if(n<0)return n+p;
return n;
}
ll fact(ll n,ll p=MOD){
if(n<0)return 0;
int i;
ll ret=1;
for(i=0;i<n;i++){
ret=ret*(i+1);
if(ret>=p)ret%=p;
}
return ret;
}
ll perm(ll n,ll k,ll p=MOD){
if(n<0 || k<0 || n<k)return 0;
int i;
ll ret=1;
for(i=0;i<k;i++){
ret=ret*(n-i);
if(ret>=p)ret%=p;
}
return ret;
}
ll binom(ll n,ll k,ll p=MOD){
if(n<0 || k<0 || n<k)return 0;
int i;
ll ret=1,fact=1;
for(i=0;i<k;i++){
ret=ret*(n-i);
fact*=i+1;
if(ret>=p)ret%=p;
if(fact>=p)fact%=p;
}
return (ret*modRev(fact))%p;
}
void pushHeap(vector<int>& h,int n){
int i=h.size();
h.push_back(n);
while(i!=0 && h[(i-1)/2]<h[i]){
swap(h[i],h[(i-1)/2]);
i=(i-1)/2;
}
h[i]=n;
}
int popHeap(vector<int>& h){
int n=h.size()-1;
if(n==-1)return 0;
int i,ret=h[0];
swap(h[0],h[n]);
h.pop_back();
for(i=0;i<n;){
int j=2*i+1;
if(j>=n)break;
if(j!=n-1 && h[j]<h[j+1])j++;
if(h[i]<h[j]){
swap(h[i],h[j]);
}
i=j;
}
return ret;
}
int bis(vector<int> v,int key){
int left=-1,right=v.size();
while(abs1(right-left)>1){
int mid=left+(right-left)/2;
if(v[mid]<=key)left=mid;
else right=mid;
}
return left;
}
int n;
bool b[100000],c[100000];
string judge(bool x,bool y){
c[0]=x;c[1]=y;
int i;
for(i=2;i<n;i++){
c[i]=b[i-1]^c[i-1]^c[i-2];
}
if(c[0]==b[n-1]^c[n-1]^c[n-2] && c[1]==b[0]^c[0]^c[n-1]){
string t="";
for(i=0;i<n;i++){
if(c[i])t+='S';
else t+='W';
}
return t;
}
return "";
}
int main(){
int i,j,k,cnt=0;
string s;
cin>>n;
cin>>s;
for(i=0;i<n;i++){
if(s[i]=='o')b[i]=true;
else b[i]=false;
}
string tt=judge(true,true),tf=judge(true,false);
string ft=judge(false,true),ff=judge(false,false);
if(tt!=""){
cout<<tt<<endl;
return 0;
}
if(tf!=""){
cout<<tf<<endl;
return 0;
}
if(ft!=""){
cout<<ft<<endl;
return 0;
}
if(ff!=""){
cout<<ff<<endl;
return 0;
}
cout<<-1<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
ll N,M;
cin >> N >> M;
ll ans;
if(N == 2 || M == 2)ans = 0;
else if(N == 1 && M == 1)ans = 1;
else if(N == 1 && M > 2)ans = M - 2;
else if(M == 1 && N > 2)ans = N - 2;
else ans = (M - 2) * (N - 2);
cout << ans << endl;
}
| 0
| 76,946,910
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<unordered_map>
#include<utility>
#include<cmath>
#include<random>
#include<cstring>
#include<queue>
#include<stack>
#include<bitset>
#include<cstdio>
#include<sstream>
#include<iomanip>
#include<assert.h>
#include<typeinfo>
#define loop(i,a,b) for(long long i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define FOR(i,a) for(auto i:a)
#define pb push_back
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
#define show1d(v) {rep(_,v.size())cout<<" "<<v[_];cout<<endl;}
#define show2d(v) {rep(__,v.size())show1d(v[__]);}
using namespace std;
typedef long long ll;
#define int ll
typedef int Def;
typedef pair<Def,Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def,pii> pip;
typedef vector<pip>vip;
#define mt make_tuple
typedef tuple<int,int,int,int> tp;
typedef vector<tp> vt;
template<typename A,typename B>bool cmin(A &a,const B &b){return a>b?(a=b,true):false;}
template<typename A,typename B>bool cmax(A &a,const B &b){return a<b?(a=b,true):false;}
const double PI=acos(-1);
const double EPS=1e-9;
Def inf = sizeof(Def) == sizeof(long long) ? 2e18 : 1e9+10;
#define yes cout<<"Yes\n"
#define no cout<<"No\n"
int dp[10][60][10];
int co[10][60][10];
signed main(){
ios::sync_with_stdio(false);
cin.tie(0);
rep(i,10)rep(j,60)rep(k,10)dp[i][j][k]=co[i][j][k]=0;
rep(i,10)rep(j,10){
int a=i+j;
if(a<10){
dp[i][0][j]=a;
co[i][0][j]=1;
}else{
dp[i][0][j]=a/10+a%10;
co[i][0][j]=2;
}
if(i==0)co[i][0][j]--;
}
rep(j,59)rep(i,10)rep(k,10){
int a=dp[i][j][k];
int c=co[i][j][k]+co[a][j][k];
a=dp[a][j][k];
dp[i][j+1][k]=a;
co[i][j+1][k]=c;
}
int n;
cin>>n;
int out=0,t=0;
while(n--){
int a,b;
cin>>a>>b;
rep(i,60)if(1ll<<i&b){
out+=co[t][i][a];
t=dp[t][i][a];
}
}
cout<<out<<endl;
}
|
#include "bits/stdc++.h"
using namespace std;
#define MOD 1000000007
const double EPS = 1e-9;
#define INF (1LL<<60)
#define fs first
#define sc second
#define pb push_back
#define int long long
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define RFOR(i,a,b) for(int i = (b-1);i>=a;i--)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
#define ITR(itr,mp) for(auto itr = (mp).begin(); itr != (mp).end(); ++itr)
#define RITR(itr,mp) for(auto itr = (mp).rbegin(); itr != (mp).rend(); ++itr)
#define range(i,a,b) ((a)<=(i) && (i)<(b))
#define debug(x) cout << #x << " = " << (x) << endl;
#define SP << " " <<
typedef pair<int,int> P;
typedef vector<vector<P> > Graph;
typedef vector<int> vec;
typedef vector<vector<int>> mat;
const int NMAX = 1e5;
vec used(NMAX,0),edge[NMAX],a(NMAX);
int check(int no){
used[no]++;
int sum = 0,cnt = 0,mx = 0;
for(int to:edge[no]){
if(used[to]) continue;
int tmp = check(to);
cnt++;
sum += tmp;
mx = max(mx,tmp);
}
if(cnt == 0) return a[no];
if(no == 0){
if((cnt == 1 && sum == a[no]) || (cnt > 1 && sum == a[no]*2 && mx*2 <= sum)) return 0;
else{
cout << "NO" << endl;
exit(0);
}
}
else{
int cur = 2*a[no] - sum;
if(sum >= a[no] && min((sum-mx)*2,sum) >= sum-cur) return cur;
else{
cout << "NO" << endl;
exit(0);
}
}
}
signed main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
REP(i,n) cin >> a[i];
REP(_,n-1){
int x,y;
cin >> x >> y;
x--; y--;
edge[x].push_back(y);
edge[y].push_back(x);
}
check(0);
cout << "YES" << endl;
return 0;
}
| 0
| 64,909,614
|
#include <stdio.h>
#include <algorithm>
using namespace std;
int main()
{
int a[10],i;
for(i = 0; i < 10; i++){
scanf("%d",&a[i]);
}
sort(a,a+10);
printf("%d\n%d\n%d\n",a[9],a[8],a[7]);
return 0;
}
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
typedef tree<ii,null_type,less<ii>,rb_tree_tag,tree_order_statistics_node_update> indexed_set;
int main() {
cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(0);
int r; cin>>r;
if (r<1200) cout<<"ABC"<<endl;
else if (r<2800) cout<<"ARC"<<endl;
else cout<<"AGC"<<endl;
return 0;
}
| 0
| 91,643,629
|
#include "bits/stdc++.h"
using ll = long long;
using namespace std;
void solve() {
int n;
cin >> n;
vector <int> v(n);
for(auto &e: v) {
cin >> e;
}
sort(v.begin(), v.end());
int x = v.size() / 2;
cout << v[x] - v[x - 1] << endl;
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int testcase = 1;
for(int i = 0; i < testcase; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a < 0) a = -a;
if (b < 0) b = -b;
if (b == 0) return a;
else return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return a / gcd(a,b) * b;
}
int main(){
int n, m;
cin >> n >> m;
vector<int> a(n);
set<int> a_set;
for(int i=0; i<n; i++){
cin >> a[i];
a[i] /= 2;
a_set.insert(a[i]);
}
int ans = 0;
int x = a[0];
for(int i=1; i<n; i++){
x = gcd(x, a[i]);
}
long long int y = 1;
for(int z : a_set){
y = lcm(y,z);
if(y > m){
cout << 0 << endl;
return 0;
}
}
bool flag = true;
long long int first = y;
for(int i=0; i<n; i++){
if((first / a[i]) % 2 == 0) flag = false;
}
if(flag == false) cout << 0 << endl;
if(flag == true) cout << 1 + (m - (int)y) / (2*y) << endl;
return 0;
}
| 0
| 33,638,732
|
#include <iostream>
using namespace std;
int main() {
int s,h,n,i,a[5000];
while(true) {
cin >> n;
if (n==0) break;
for (i=0;i<n;i++) cin >> a[i];
s=0; h=-100000;
for (i=0;i<n;i++) {
s=(s+a[i]>=a[i]) ? s+a[i] : a[i];
h=(s > h) ? s : h;
}
cout << h << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ordered_set tree<pair<int,int>, null_type,less<pair<int,int> >, rb_tree_tag,tree_order_statistics_node_update>
#define standardVar ll n,m,i,j,k,num,num1,num2,flag=0
#define nn <<"\n"
#define __ <<" "<<
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define ff first
#define ss second
#define all(v) v.begin(),v.end()
#define ittr(x,v) for(auto x=v.begin();x!=v.end();x++)
#define itr(x,n) for(x=0;x<n;x++)
#define itrab(x,a,b) for(x=a;x<b;x++)
#define itpr(v) ittr(x,v)cout<<*x<<" "; cout nn
#define itppr(v) ittr(x,v)cout<<(*x).ff<<" "<<(*x).ss<<" "; cout nn
#define size(x) (ll)x.size()
#define pi 3.14159265359
#define dTor(x) ((x)*pi)/180.0
#define INF 1000000100;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vl;
typedef map<ll,ll> ml;
typedef set<ll> sl;
typedef string str;
typedef pair<ll, ll> pl;
typedef vector< pl > vpl;
typedef map<pl,ll> mpl;
typedef set< pl > spl;
typedef vector<str> vst;
typedef vector<vl> vvl;
const ll M=1000000007;
const ll N=998244353;
ll power(ll x, ll y, ll p){
ll res=1;
x=x%p;
if(x==0)
return 0;
while(y>0){
if(y&1)
res=(res*x)%p;
y=y>>1;
x=(x*x)%p;
}
return res;
}
ll inv(ll x, ll m){
return power(x,m-2,m);
}
struct comp{
template<typename T>
bool operator()(const T &a, const T &b){
if (a.ff==b.ff)
return (a.ss<b.ss);
else
return (a.ff<b.ff);
}
};
bool mod(const pair<ll,ll> &a, const pair<ll,ll> &b){
if(a.ff!=b.ff)
return (a.ff>b.ff);
else
return (a.ss>b.ss);
}
vector<bool> pr(1000000+1,1);
void sieve(ll mn, ll mx){
for(ll i=mn;i*i<=mx;i++)
if(pr[i-mn]==1)
for(ll j=i*i;j<=mx;j+=i)
pr[j-mn]=0;
}
bool isValid(ll i, ll j, ll n, ll m){
if(i>=0&&i<n&&j>=0&&j<m){
return true;
}
return false;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
standardVar;
cin>>n;
vl v;
ll mx=-1;
itr(i,n){
cin>>num;
v.pb(num);
mx=max(num,mx);
}
sort(all(v));
vl a(mx+1,0);
itr(i,n){
for(j=v[i];j<=mx;j+=v[i]){
a[j]++;
}
}
ll c=0;
itr(i,n){
if(a[v[i]]==1){
c++;
}
}
cout<<c nn;
return 0;
}
| 0
| 44,640,744
|
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <functional>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int n, a, b;
cin >> n >> a >> b;
if ((b - a) % 2 == 1) cout << "Borys\n";
else cout << "Alice\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int frog1(int* s, int n){
int dp[100006];
dp[0]=dp[1] = 0;
for(int i=2;i<=n;i++){
int op1 = abs(s[i]-s[i-1]) + dp[i-1];
int op2 = (i==2)?INT_MAX:abs(s[i]-s[i-2]) + dp[i-2];
dp[i] = min(op1, op2);
}
return dp[n];
}
int main() {
int a[100005];
int n; cin>>n;
for(int i=1;i<=n;i++){
cin>>a[i];
}
cout<<frog1(a,n);
return 0;
}
| 0
| 49,413,855
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define re register
#define gc getchar
#define pc putchar
#define cs const
inline
ll getint(){
re ll num;
re char c;
re bool f=0;
while(!isdigit(c=gc()))f^=c=='-';num=c^48;
while(isdigit(c=gc()))num=(num<<1)+(num<<3)+(c^48);
return f?-num:num;
}
inline
void outint(ll a){
static char ch[23];
if(a==0)pc('0');
while(a)ch[++ch[0]]=a-a/10*10,a/=10;
while(ch[0])pc(ch[ch[0]--]^48);
}
cs ll INF=0x3f3f3f3f3f3f3f3f;
cs int N=1005;
cs int dx[4]={1,-1,0,0};
cs int dy[4]={0,0,-1,1};
cs char s[4]={'R','L','D','U'};
int n;
ll x[N],y[N];
vector<ll> len;
bool flag;
signed main(){
n=getint();
for(int re i=1;i<=n;++i){
x[i]=getint(),y[i]=getint();
if(i^1){
if(((x[i]^y[i])&1)!=flag)return puts("-1"),0;
}
else flag=(x[i]^y[i])&1;
}
for(int re i=0;i<=30;++i){
len.push_back(1ll<<i);
}
if(flag==0)len.push_back(1);
sort(len.rbegin(),len.rend());
outint(len.size()),pc('\n');
for(int re i=0;i<len.size();++i)
outint(len[i]),pc(' ');
pc('\n');
for(int re i=1;i<=n;++i){
ll xx=x[i],yy=y[i];
for(int re j=0;j<len.size();++j){
int pos;
ll minn=INF;
for(int re k=0;k<4;++k){
ll tmpx=xx-len[j]*dx[k];
ll tmpy=yy-len[j]*dy[k];
if(abs(tmpx)+abs(tmpy)<minn){
minn=abs(tmpx)+abs(tmpy);
pos=k;
}
}
pc(s[pos]);
xx=xx-len[j]*dx[pos];
yy=yy-len[j]*dy[pos];
}pc('\n');
}
return 0;
}
|
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
#include<complex>
#include<numeric>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
typedef pair<int, int>P;
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
typedef vector<vector<ll>> mat;
typedef vector<ll> vec;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
#define all(v) (v).begin(),(v).end()
const ll mod = 1000000007;
const ll INF = mod * mod;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
ll qp(ll a,ll b,int mo){int ans=1;do{if(b&1)ans=1ll*ans*a%mo;a=1ll*a*a%mo;}while(b>>=1);return ans;}
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll lcm (ll a, ll b){return a/gcd(a,b)*b;}
int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };
template<typename T> istream &operator>>(istream &is, vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec){ os << "["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const deque<T> &vec){ os << "deq["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &pa){ os << "(" << pa.first << "," << pa.second << ")"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template<typename T, typename... Args> void ndarray(vector<T> &vec, int len, Args... args) { vec.resize(len); for (auto &v : vec) ndarray(v, args...); }
template<typename T> bool chmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
template<typename T> bool chmin(T &m, const T q) { if (q < m) {m = q; return true;} else return false; }
template<typename T1, typename T2> pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) { return make_pair(l.first + r.first, l.second + r.second); }
template<typename T1, typename T2> pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) { return make_pair(l.first - r.first, l.second - r.second); }
template<typename T1, typename T2> pair<T1, T2> operator<(const pair<T1, T2> l, const pair<T1, T2> r) { return (l.first < r.first); }
template<typename T1, typename T2> pair<T1, T2> operator>(const pair<T1, T2> l, const pair<T1, T2> r) { return (l.first > r.first); }
struct post{
int index;
int pref;
int year;
string num;
};
auto inc = [](const post& left, const post& right){return left.index < right.index;};
auto prec = [](const post& left, const post& right){return left.pref < right.pref;};
auto yearc = [](const post& left, const post& right){return left.year < right.year;};
void solve() {
ll N,M; cin >> N >> M;
vector<post> P;
rep(i,M){
int p,y; cin >> p >> y;
post tmp;
tmp.index=i;
tmp.pref=p;
tmp.year=y;
tmp.num="";
P.push_back(tmp);
}
sort(all(P), [](const post& left, const post& right){return (left.pref==right.pref) ? (left.year < right.year) : (left.pref < right.pref);});
int nowpre=-1;
int ro = 1;
for(auto& a: P){
if(a.pref!=nowpre){
ro = 1;
nowpre=a.pref;
}
string y = to_string(a.pref);
string r = to_string(ro);
string res = "";
rep(i,6-y.size())res+="0";
res +=y;
rep(i,6-r.size())res+="0";
res+=r;
a.num = res;
ro++;
}
sort(all(P), [](const post& l, const post& r){return l.index < r.index;});
for(auto a: P) cout << a.num << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
std::cout << fixed << setprecision(10);
solve();
return 0;
}
| 0
| 19,212,513
|
#include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(), (x).end()
#define SZ(X) ((int)(X).size())
#define endl "\n";
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int n,m,a,sum=0;
cin>>n>>m;
for (int i = 0; i < m; ++i)
{
cin>>a;
sum+=a;
}
int ans = n-sum;
if(ans<0) cout<<-1; else cout<<ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define forn(i,n) for(int i=0;i<n;++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(),v.rend();
#define isSubstring(s1,s2) s1.find(s2) != std::string::npos
#define pb push_back
#define pf push_front
#define mp make_pair
#define fr first
#define sc second
#define vpi <vector<pair<int,int>>
#define vi vector<int>
#define sz(a) (int)a.size()
#define endl "\n"
#define nl cout<<"\n";
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define MN INT_MIN
#define MX INT_MAX
bool isPrime(ll n){if(n<2)return false;for(ll x = 2;x*x <=n;x++){if(n%x == 0)return false;}return true;}
bool isPerfectSquare(long double x){long double sr=sqrt(x);return((sr-floor(sr))==0);}
int gcd(int a, int b){if(a==0)return b;if(b==0) return a;if(a==b)return a;if(a>b)return gcd(a-b,b);return gcd(a,b-a);}
int32_t main()
{
int n;
cin >> n;
int a[n];
for(int i = 0;i<n;i++)
cin >> a[i];
int mn = MX,cnt = 0;
for(int i = 0;i<n;i++)
{
mn = min(mn,a[i]);
if(a[i] <= mn)
{
cnt++;
}
}
cout <<cnt<<endl;
}
| 0
| 45,966,305
|
#include<bits/stdc++.h>
#define fi first
#define se second
#define show(x) cerr<<#x<<"="<<x<<"\n"
typedef long long ll;
using namespace std;
const int dy[]={1,0,-1};
const int dx[]={1,0,-1};
int n,m,h,w;
int a[90000];
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout<<fixed;
#ifdef LOCAL_DEFINE
FILE *stream1;
stream1=freopen("in","r",stdin);
if(stream1==NULL)return 0;
#endif
int n;
while(cin>>n,n){
for(int i=0;i<90000;i++)a[i]=0;
for(int i=0;i<n;i++){
string s,t;cin>>s>>t;
int start=stoi(s.substr(0,2))*60*60;
start+=stoi(s.substr(3,2))*60;
start+=stoi(s.substr(6,2));
int end=stoi(t.substr(0,2))*60*60;
end+=stoi(t.substr(3,2))*60;
end+=stoi(t.substr(6,2));
a[start]++;
a[end]--;
}
for(int i=1;i<90000;i++)a[i]=a[i-1]+a[i];
int ans=0;
for(int i=0;i<90000;i++)ans=max(ans,a[i]);
cout<<ans<<endl;
}
#ifdef LOCAL_DEFINE
cerr<<"Time elapsed: "<<1.0*clock()/CLOCKS_PER_SEC<<"s.\n";
fclose(stream1);
#endif
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <iomanip>
#include <tuple>
using namespace std;
using i64 = int64_t;
#define rep(i, j, n) for(int i = (j); i < (n); ++i)
#define rrep(i, j, n) for(int i = (n) - 1; (j) <= i; --i)
constexpr i64 MOD = 1000000007;
constexpr i64 INF = 1LL << 60;
int main() {
int n; cin >> n;
int t = 0, x = 0, y = 0, nt, nx, ny;
rep(i, 0, n) {
cin >> nt >> nx >> ny;
int move = abs(x - nx) + abs(y - ny);
int dt = nt - t;
if (move > dt || (move + dt) % 2) {
cout << "No" << endl;
return 0;
}
t = nt;
x = nx;
y = ny;
}
cout << "Yes" << endl;
return 0;
}
| 0
| 75,415,804
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
ll mm=1000000000;ll MM=mm+7;
#define rep(i, n) for(int i=0;i<n;i++)
#define PI 3.141592653589793
int main(){
int n;
cin >> n;
VI a(n);
rep(i,n){
cin >> a.at(i);
}
ll mn=100000000000000;
for(int i=-100;i<=100;i++){
ll cnt=0;
rep(j,n){
cnt+=(a.at(j)-i)*(a.at(j)-i);
}
mn=min(cnt,mn);
}
cout << mn << endl;
}
|
#include <bits/stdc++.h>
#define endl "\n"
using namespace std;
#define ll long long
#define ld long double
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repo(i,n) for(int i = 1; i < (int)(n); i++)
#define pb push_back
#define mp make_pair
#define np next_permutation
#define fi first
#define se second
#define all(x) (x).begin(),(x).end()
#define uniq(v) v.erase(unique(v.begin(),v.end()),v.end())
#define lb(v,x) (lower_bound(v.begin(),v.end(),x)-v.begin())
#define ub(v,x) (upper_bound(v.begin(),v.end(),x)-v.begin())
const ll mod=1000000007;
const ld pi=acos(-1.0);
const ll INF = 1LL<<61;
template<class T>bool chmax(T &a, const T &b) {
if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) {
if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll jou(ll N, ll P){if(P==0) return 1;
if(P%2==0){ll t = jou(N, P/2);return t*t % mod;
}return (N * jou(N, P-1)) % mod;}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n,p;
string s;
cin>>n>>p>>s;
ll ans=0;
if(p==2){
rep(i,n){
if((s[i]-'0')%2==0) ans+=i+1;
}
cout << ans << endl;
return 0;
}
if(p==5){
rep(i,n){
if((s[i]-'0')%5==0) ans+=i+1;
}
cout << ans << endl;
return 0;
}
vector<ll> q(p);
q[0]=1;
ll now=0;
ll ju=1;
for(int i=n-1;i>=0;i--){
now+=((s[i]-'0')*ju);
now%=p;
q[now]++;
ju=(ju*10)%p;
}
rep(i,p){
ans+=q[i]*(q[i]-1)/2;
}
cout << ans << endl;
}
| 0
| 21,903,425
|
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <iomanip>
#include <queue>
#include <deque>
#include <map>
#include <unordered_map>
#define rep(i,n) for(int i=0;i<n;i++)
#define repn(i,n) for(int i=1;i<=n;i++)
#define repr(e,x) for(auto& e:x)
using namespace std;
typedef long long ll;
typedef long double ld;
ll const MOD=1000000007;
ll N;
ll A[100000];
ll B[100000];
ll cnt[100001];
int main(){
cin>>N;
rep(i,N) cin>>A[i]>>B[i];
for(int i=N-1;i>=0;i--){
cnt[i]=cnt[i+1];
cnt[i]+=(B[i]-(A[i]+cnt[i])%B[i])%B[i];
}
ll ans=cnt[0];
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(x,a,b) for(int x = a; x < b; x++)
#define per(x,a,b) for(int x = a; x >= b; x--)
#define all(container) (container).begin(), container.end()
#define rall(container) (container).rbegin(), container.rend()
#define sz(container) (int) (container).size()
#define pb push_back
#define eb emplace_back
#define fi first
#define sc second
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template<class T> bool smin(T &a, T b) { return a > b ? (a = b, true) : false; }
template<class T> bool smax(T &a, T b) { return a < b ? (a = b, true) : false; }
#ifdef LOCAL_DEFINE
#include "DEBUG.hpp"
#else
#define debug(...) 0
#endif
const int maxn = 200010;
vector<int> e[maxn];
int vis[maxn], cc = 0;
void dfs(int at) {
vis[at] = 1;
++cc;
for(auto& x : e[at]) {
if(vis[x]) continue;
dfs(x);
}
}
int main(void)
{
int n, m;
scanf("%d%d", &n, &m);
memset(vis,0,sizeof(vis));
rep(i,0,m) {
int from, to;
scanf("%d%d", &from, &to);
e[from].pb(to);
e[to].pb(from);
}
int ans = 0;
rep(i,1,n+1) {
if(vis[i]) continue;
cc = 0;
dfs(i);
smax(ans, cc);
}
printf("%d\n", ans);
return 0;
}
| 0
| 40,888,087
|
#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <deque>
#include <string>
#include <cstring>
#include <iomanip>
#include <fstream>
#include <map>
#include <unordered_map>
#include <bitset>
#define _crt_secure_no_warnings
#define FREEELO ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define pb push_back
#define mp make_pair
#define INF 0x3F3F3F3F
#define MAX 101
#define MOD 1000000007
#define ALPHABET 128
#define loop(i, n) for (int i = 1; i <= (n); i++)
#define loop0(i, n) for (int i = 0; i < (n); i++)
#define sz(x) (int)x.size()
#define all(v) v.begin(), v.end()
#define F first
#define S second
using namespace std;
typedef long long ll;
typedef double lf;
typedef pair<ll, ll> llll;
typedef pair<int, int> ii;
typedef unordered_map<int, int> umii;
typedef unordered_map<ll, ll> umll;
int main(){
ll a, b, c; cin >> a >> b >> c;
cout << (b * c >= a ? "Yes" : "No") << endl;
}
|
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define all(v) v.begin(),v.end()
#define mp make_pair
#define ff first
#define ss second
#define MAXN 1000005
using namespace std;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
ll k;
cin>>k;
ll e=k/50;
ll f=k%50;
ll rr=50+e-1;
ll zz=rr+(f*50);
ll xx=rr+1;
cout<<50<<endl;
for(ll i=0;i<=49;i++){
xx--;
xx=max(0LL,xx);
if(i<f)
cout<<(xx+50-f)<<" ";
else cout<<xx<<" ";
}
return 0;
}
| 0
| 8,771,016
|
#include<bits/stdc++.h>
using namespace std;
int n,a[100010];
string s;
vector<int> check(int x,int y)
{
vector<int> v;
v.push_back(x);
v.push_back(y);
for(int i=2;i<n;i++)
{
if(!a[i-1])
{
if(v[i-1]==0)
v.push_back(v[i-2]);
else
v.push_back(1-v[i-2]);
}
else
{
if(v[i-1]==0)
v.push_back(1-v[i-2]);
else
v.push_back(v[i-2]);
}
}
if((a[n-1])==(v[n-2]^v[n-1]^v[0])&&(a[0])==(v[n-1]^v[0])^v[1])
return v;
v.clear();
return v;
}
void printans(vector<int> v)
{
for(int i=0;i<v.size();i++)
cout<<(v[i]==0?'S':'W');
exit(0);
}
int main()
{
cin>>n>>s;
for(int i=0;i<n;i++)
{
if(s[i]=='o')
a[i]=0;
else
a[i]=1;
}
vector<int> v;
v=check(0,0);
if(v.size()!=0)
printans(v);
v=check(0,1);
if(v.size()!=0)
printans(v);
v=check(1,0);
if(v.size()!=0)
printans(v);
v=check(1,1);
if(v.size()!=0)
printans(v);
cout<<-1<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
long long h[100009];
long long sz[100009];
long long f[100009];
long long D[100009];
vector<long long> v[100009];
map<long long,long long> M;
void dfs(long long x, long long de){
f[x] = 1;
h[x] = de;
for(long long i = 0; i < v[x].size(); i++){
if(!f[v[x][i]]) dfs(v[x][i], de + 1);
}
}
main(){
long long n;
cin >> n;
for(long long i = 1; i <= n; i++){
cin >> D[i];
M[D[i]] = i;
sz[i] = 1;
}
long long t = D[1];
sort(D + 1, D + n + 1);
for(long long i= n; i >= 2; i--){
long long k = M[D[i]];
long long diff = n - 2 * sz[k];
if(diff <= 0 || !M[D[i] - diff]){
cout << -1 << endl;
return 0;
}
v[k].push_back(M[D[i]-diff]);
v[M[D[i] - diff]].push_back(k);
sz[M[D[i] - diff]] += sz[k];
}
dfs(1,0);
long long S = 0;
for(long long i = 1; i <= n; i++){
S += h[i];
}
if(S == t){
for(long long i = 1; i <= n; i++){
for(long long j = 0; j < v[i].size(); j++){
if(i < v[i][j]){
cout<<i<<" "<<v[i][j]<<endl;
}
}
}
}
else{
cout<< -1 << endl;
return 0;
}
}
| 0
| 54,610,077
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll a, b, k; cin >> a >> b >> k;
ll n = max(a, b);
ll i = 1;
ll order = 0;
vector<ll> p;
for (ll i = 1; i <= n; i++) {
if (a % i == 0 && b % i == 0) {
order++;
p.emplace_back(i);
}
}
sort(p.begin(), p.end(), greater<ll>());
cout << p[k - 1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <unordered_map>
using namespace std;
typedef long long int ll;
typedef long double ld;
#define rep(i, n) for(ll i = 0; i < (ll)(n); i++)
#define repr(i, n) for (ll i = (ll)(n) - 1; i >= 0; i--)
#define all(x) (x).begin(),(x).end()
#define MOD 1000000007
#define INF (1LL << 62)
#define PI (acos(-1))
#define print(x) cout << x << endl
ll gcd(ll a, ll b) { return b ? gcd(b,a%b) : a;}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll countDigit(ll n) { return floor(log10(n) + 1); }
typedef pair <ll,ll> P;
static const ll dy[4] = {0,1,0,-1}, dx[4] = {1,0,-1,0};
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v)
{
for (int i = 0; i < (int)v.size(); ++i) {
os << v[i];
if (i != (int)v.size() - 1)
os << " ";
}
return os;
}
ll nCrModp(ll n, ll r, ll p)
{
ll C[r+1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (ll i = 1; i <= n; i++)
{
for (ll j = min(i, r); j > 0; j--)
C[j] = (C[j] + C[j-1])%p;
}
return C[r];
}
int main()
{
ll N;
cin >> N;
vector<pair<string, ll>> p(N);
rep(i, N) {
string str;
ll tmp;
cin >> str >> tmp;
p[i] = pair<string, ll>(str, tmp);
}
string X;
cin >> X;
ll cnt = 0;
bool flag = false;
rep(i, N) {
if (flag) {
cnt += p[i].second;
}
if (X == p[i].first) {
flag = true;
}
}
print(cnt);
return 0;
}
| 0
| 23,866,498
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF=1e+9;
const int MOD=1e+9+7;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define REP2(i,a,b) for(ll i=a;i<(ll)(b);i++)
#define REPD2(i,a,b) for(ll i=a;i>(ll)(b);i--)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
int main(){
int N,M;
cin>>N>>M;
vector<int> S(1e5+10),T(1e5+10);
REP(i,N) cin >> S[i];
REP(i,M) cin >> T[i];
vector<vector<ll>> dp(2010,vector<ll>(2010,0));
vector<vector<ll>> sum(2010,vector<ll>(2010,0));
dp[0][0]=1;
sum[1][1]=1;
REP(i,N+1){
REP(j,M+1){
if(i==0&&j==0) continue;
if(i-1>=0&&j-1>=0&&S[i-1]==T[j-1]){
dp[i][j] = sum[i][j];
}
sum[i+1][j+1]=(sum[i][j+1]%MOD+sum[i+1][j]%MOD-sum[i][j]%MOD+dp[i][j]%MOD);
while(sum[i+1][j+1]<0){
sum[i+1][j+1]+=MOD;
}
sum[i+1][j+1]%=MOD;
}
}
cout <<sum[N+1][M+1] << endl;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define all(x) (x).begin(),(x).end()
#define SZ(x) ((int)(x).size())
#define bit(n) (1<<(n))
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<bool> vb;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
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 b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) { return a/gcd(a,b)*b;}
int const INF = 1001001001;
vector<pii> List[90005];
int main()
{
int H,W,D;
cin >> H >> W >> D;
vvi a(H,vi(W));
vector<pii> data(H*W);
rep(h,H) rep(w,W) {
cin >> a[h][w];
a[h][w]--;
data[a[h][w]] = pii(h,w);
}
rep(i,H*W) List[i%D].emplace_back(data[i]);
vvi d(D);
vvi sd(D);
rep(i,D) {
if(List[i].empty()) continue;
int n = List[i].size() - 1;
d[i].resize(n);
sd[i].resize(n+1);
rep(j,n) {
int uh = List[i][j].first; int uw = List[i][j].second;
int vh = List[i][j+1].first; int vw = List[i][j+1].second;
d[i][j] = abs(uh-vh) + abs(uw-vw);
sd[i][j+1] = sd[i][j] + d[i][j];
}
}
int Q;
cin >> Q;
rep(q,Q) {
int L,R;
cin >> L >> R;
L--; R--;
cout << sd[R%D][R/D] - sd[L%D][L/D] << endl;
}
return 0;
}
| 0
| 55,210,904
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
int main(){
int h,w; cin >> h >> w;
int x,y;
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++){
string s; cin >> s;
if(s == "snuke"){
x = i+1; y = j;
}
}
}
cout << char(y+'A') << x << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,D,answer=0,a,b=0,count=0;
cin>>N>>D;
vector<vector<int>> X(N,vector<int>(D));
for (int i=0; i < N; ++i) {
for (int j=0; j < D; ++j) {
cin >> X[i][j];
}
}
for(int i=0;i<N;i++){
for(int j=i+1;j<N;j++){
b=0;
for(int k=0;k<D;k++){
a=X[i][k]-X[j][k];
b+=a*a;
}
for(int k=0;k<=b;k++){
if(k*k==b) count++;
}
}
}
cout<<count<<endl;
}
| 0
| 96,148,183
|
#include <cstdio>
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(int argc, char const* argv[]) {
string S;
cin >> S;
vector<string> key = {
"dreamer",
"dream",
"eraser",
"erase",
};
reverse(S.begin(), S.end());
while (S.length() > 0) {
bool stringFlag = false;
for (int i = 0; i < key.size(); i++) {
bool charFlag = true;
for (int j = key[i].length() - 1; j >= 0; j--) {
if (S[key[i].length() - j - 1] != key[i][j]) {
charFlag = false;
break;
}
}
if (charFlag) {
S = S.substr(key[i].length());
stringFlag = true;
break;
}
}
if (!stringFlag) {
printf("NO\n");
return 0;
}
}
printf("YES\n");
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
int main(){
int n;
cin >> n;
string ta, ha;
int left=0, right = 0;
for(int i=0; i<n; i++){
cin >> ta >> ha;
if(ta > ha){
left += 3;
}else if(ta < ha){
right += 3;
}else{
left+=1;
right+=1;
}
}
cout << left << " " << right << endl;
return 0;
}
| 0
| 46,789,505
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int p, q, r;
cin >> p >> q >> r;
int ans = 1000;
if(p + q < ans) ans = p + q;
if(r + q < ans) ans = r + q;
if(p + r < ans) ans = p + r;
if(q + r < ans) ans = q + r;
if(r + p < ans) ans = r + p;
if(q + p < ans) ans = q + p;
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
typedef long long ll;
const int INF = 1e9;
const int MOD = 1e9 + 7;
using namespace std;
#define FOR(i , a , b) for(int i = (a) ; i < (b) ; i++)
#define REP(i , n) for(int i = 0 ; i < n ; i++)
#define REPR(i , n) for(int i = n ; 0 <= i ; i--)
#define ROP(i, n) for(int i = 1 ; i <= n ; i++)
#define SCOUT(x) cout << (x) << " "
#define VECCIN(x) for(auto& ele : (x) ) cin >> ele
#define VECOUT(x) for(auto& ele : (x) ) cout << ele << " "; cout << endl;
#define ALL(obj) (obj).begin() , (obj).end()
#define SORT(obj) sort(ALL(obj))
#define GSORT(obj) sort(ALL(obj) , greater<int>())
#define P pair<int , int>
#define V vector<int>
#define VLL vector<long long>
#define M map<int, int>
#define S set<int>
#define PQ priority_queue<int>
#define PQG priority_queue<int , V , greater<int>>
#define MAX_H 1000
#define MAX_W 1000
int main(void) {
ios::sync_with_stdio(false); cin.tie(0);
ll k, a, b; cin >> k >> a >> b;
if(k < a || b - a < 2){ cout << k + 1 << endl; return 0; }
ll ans = a;
k -= a-1;
ans += k / 2 * (b-a) + k % 2;
cout << ans << endl;
return 0;
}
| 0
| 24,854,682
|
#include<iostream>
#include<algorithm>
#include<string.h>
#include<set>
#define MAX_N 50
#define INF 10000
using namespace std;
int d[MAX_N][MAX_N];
int N;
void floyed(int X) {
for (int k = 0; k<X; k++) {
for (int i = 0; i<X; i++) {
for (int j = 0; j<X; j++) {
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
}
int main() {
while (true) {
set<int> s;
cin >> N;
if (N <= 0)
break;
for (int i = 0; i<MAX_N; i++) {
for (int j = 0; j<MAX_N; j++) {
d[i][j] = INF;
if (i == j)
d[i][j] = 0;
}
}
for (int i = 0; i<N; i++) {
int from, to, costs;
cin >> from >> to >> costs;
d[from][to] = costs;
d[to][from] = costs;
s.insert(to);
s.insert(from);
}
floyed(s.size());
int misum = INF;
int no;
for (int i = 0; i<s.size(); i++) {
int sum = 0;
for (int j = 0; j<s.size(); j++) {
if (i != j&&d[i][j]!=INF)
sum += d[i][j];
}
if (sum < misum) {
misum = sum;
no = i;
}
}
cout << no<<" "<<misum << endl;
}
}
|
#pragma GCC optimize ("Ofast")
#include<bits/stdc++.h>
using namespace std;
void *wmem;
char memarr[96000000];
template<class T> inline void walloc1d(T **arr, int x, void **mem = &wmem){
static int skip[16] = {0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
(*mem) = (void*)( ((char*)(*mem)) + skip[((unsigned long long)(*mem)) & 15] );
(*arr)=(T*)(*mem);
(*mem)=((*arr)+x);
}
template<class T1> void sortA_L(int N, T1 a[], void *mem = wmem){
sort(a, a+N);
}
template<class T1> void rsortA_L(int N, T1 a[], void *mem = wmem){
sortA_L(N, a, mem);
reverse(a, a+N);
}
inline void rd(int &x){
int k;
int m=0;
x=0;
for(;;){
k = getchar_unlocked();
if(k=='-'){
m=1;
break;
}
if('0'<=k&&k<='9'){
x=k-'0';
break;
}
}
for(;;){
k = getchar_unlocked();
if(k<'0'||k>'9'){
break;
}
x=x*10+k-'0';
}
if(m){
x=-x;
}
}
inline void wt_L(char a){
putchar_unlocked(a);
}
inline void wt_L(int x){
int s=0;
int m=0;
char f[10];
if(x<0){
m=1;
x=-x;
}
while(x){
f[s++]=x%10;
x/=10;
}
if(!s){
f[s++]=0;
}
if(m){
putchar_unlocked('-');
}
while(s--){
putchar_unlocked(f[s]+'0');
}
}
template<class T> int runLength(int N, T *arr, T *val = NULL, int *len = NULL){
int i;
int rN;
if(N==0){
return 0;
}
if(val==NULL || len==NULL){
void *mem = wmem;
walloc1d(&val, N, &mem);
walloc1d(&len, N, &mem);
}
rN = 1;
val[0] = arr[0];
len[0] = 1;
for(i=(1);i<(N);i++){
if(val[rN-1] == arr[i]){
len[rN-1]++;
}
else{
val[rN] = arr[i];
len[rN] = 1;
rN++;
}
}
return rN;
}
template<class S, class T> inline S chmin(S &a, T b){
if(a>b){
a=b;
}
return a;
}
int N;
int A[300000];
int arr[300000];
int res[300000];
int sz;
int num[300000];
int len[300000];
int main(){
int i;
wmem = memarr;
int k;
int x;
rd(N);
{
int Lj4PdHRW;
for(Lj4PdHRW=(0);Lj4PdHRW<(N);Lj4PdHRW++){
rd(A[Lj4PdHRW]);A[Lj4PdHRW] += (-1);
}
}
for(i=(0);i<(N);i++){
arr[A[i]]++;
}
rsortA_L(N,arr);
sz = runLength(N, arr, num, len);
for(i=(N)-1;i>=(0);i--){
k = res[i] = num[sz-1];
len[sz-1]--;
if(len[sz-1]==0){
sz--;
}
if(i==0){
break;
}
while(k > 0){
x = k / len[sz-1];
if(sz>=2){
chmin(x, num[sz-2] - num[sz-1]);
}
if(x || (sz>=2 && num[sz-2]==num[sz-1])){
k -= len[sz-1] * x;
num[sz-1] += x;
if(sz>=2 && num[sz-2] == num[sz-1]){
len[sz-2] += len[sz-1];
sz--;
}
}
else{
num[sz] = num[sz-1];
len[sz] = len[sz-1] - k;
num[sz-1]++;
len[sz-1] = k;
k = 0;
sz++;
}
}
}
{
int KL2GvlyY;
for(KL2GvlyY=(0);KL2GvlyY<(N);KL2GvlyY++){
wt_L(res[KL2GvlyY]);
wt_L('\n');
}
}
return 0;
}
| 0
| 3,442,399
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(n); i++)
using namespace std;
using ll = long long;
using v = vector<int>;
using vv = vector<v>;
int gcd(int a, int b){
if(a<b)
swap(a,b);
while(a%b){
a %= b;
swap(a,b);
}
return b;
}
int main(){
int n,k;
cin >> n >> k;
v a(n);
bool ok = false;
int g;
for(int i=0; i<n; i++){
cin >> a[i];
if(a[i]>=k)ok = true;
if(i) g = gcd(g,a[i]);
else g = a[0];
}
if(!ok)cout << "IMPOSSIBLE" << endl;
else{
if(g==1)cout << "POSSIBLE" << endl;
else if(k%g==0)cout << "POSSIBLE" << endl;
else cout << "IMPOSSIBLE" << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int m;
cin >> m;
int ans = 8;
m-=400;
for(;;)
{
if(m<200)
{
break;
}
m-=200;
ans--;
}
cout << ans << endl;
}
| 0
| 52,640,771
|
#include <iostream>
#include <iomanip>
#include <math.h>
using namespace std;
int main(){
int n;
cin >> n;
double point[2][4097];
point[0][0] = 0; point[1][0] = 0; point[0][4096] = 100; point[1][4096] = 0;
double l = 100; double root3 = sqrt(3.0); double gosa = 0.0001;
for(int i = 0; i < n; i++){
l = 100 / pow(3.0,i + 1);
int step = pow(4.0,6-i);
int step4 = step / 4;
double x,y;
for(int j = 0; j < 4096; j += step){
point[0][j + step4] = point[0][j] / 3 * 2 + point[0][j + step] / 3;
point[1][j + step4] = point[1][j] / 3 * 2 + point[1][j + step] / 3;
point[0][j + step4 * 3] = point[0][j] / 3 + point[0][j + step] / 3 * 2;
point[1][j + step4 * 3] = point[1][j] / 3 + point[1][j + step] / 3 * 2;
x = point[0][j + step4] - point[0][j];
y = point[1][j + step4] - point[1][j];
point[0][j + step4 * 2] = point[0][j + step4] + x / 2 - y / 2 * root3;
point[1][j + step4 * 2] = point[1][j + step4] + x / 2 * root3 + y / 2;
}
}
int step = pow(4.0, 6 - n);
for(int i = 0; i < 4097; i += step)
cout << fixed << setprecision(8) << point[0][i] << " " << point[1][i] << endl;
}
|
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
#define FOR(i,a,b) for(int i=int(a);i<int(b);++i)
#define RFOR(i,a,b) for(int i=int(b)-1;i>=int(a);--i)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
int q;
int main() {
int a,b;
string str,q_str,m_str;
cin >> str;
cin >> q;
REP(i,q) {
cin >> q_str;
cin >> a >> b;
if (q_str=="print") {
cout << str.substr(a,b-a+1) << endl;
} else if (q_str=="replace") {
cin >> q_str;
m_str = str.erase(a,b-a+1);
str = m_str.insert(a,q_str);
} else {
reverse(str.begin()+a,str.begin()+b+1);
}
}
return 0;
}
| 0
| 18,047,586
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <climits>
#include <string>
#include <vector>
#include <utility>
#include <functional>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <cassert>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define REP(i, n) for (ll i = 0; i < n; i++)
#define REPR(i, n) for (ll i = n; i >= 0; i--)
#define FOR(i, m, n) for (ll i = m; i < n; i++)
int main() {
int v,a[100][100]{};
cin >> v;
REP(i,v){
int n,m;
cin >> n >> m;
REP(j,m){
int u;
cin >> u;
a[i][u-1]=1;
}
}
REP(i,v){
cout << a[i][0];
FOR(j,1,v){
cout << " " << a[i][j];
}
cout << 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;
int f1(int n, int k) {
int ret = 0;
int tmp = k;
while (n >= tmp) {
tmp += k;
ret++;
}
return ret;
}
int f2(int n, int k, int m) {
int ret = 0;
for(int i =1;i<=n;i++){
if(i%k ==m) ret++;
}
return ret;
}
int main() {
int n, k;
cin >> n >> k;
if (k % 2 == 1) {
int v = f1(n, k);
ll ans = (ll)v * v * v;
cout << ans << endl;
}else{
int v = f2(n, k, 0);
ll ans = (ll)v * v * v;
v = f2(n, k, k/2);
ans += (ll)v * v * v;
cout << ans << endl;
}
return 0;
}
| 0
| 84,012,695
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N; cin >> N;
int n = -1;
for(int i = 0; i < 1000000; i++){
if(N == i * (i - 1) / 2){
n = i;
break;
}
}
if(N == 1){
cout << "Yes" << endl;
cout << 2 << endl;
cout << 1 << " " << 1 << endl;
cout << 1 << " " << 1 << endl;
}else if(n == -1) cout << "No" << endl;
else{
vector<vector<int> > G(n, vector<int> (n, -1));
int num = 1;
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
if(i == j) continue;
if(G[i][j] == -1){
G[i][j] = G[j][i] = num;
num++;
}
}
}
cout << "Yes" << endl;
cout << n << endl;
for(int i = 0; i < n; i++){
cout << n - 1 << " ";
int cnt = 1;
for(int j = 0; j < n; j++){
if(i == j) continue;
if(n - 1 == cnt) cout << G[i][j] << endl;
else cout << G[i][j] << " ";
cnt++;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
ll kyori(ll x,ll y,ll nx,ll ny){
ll a=0;
a+=max(x-nx,nx-x);
a+=max(y-ny,ny-y);
return(a);
}
int main(){
int n,m;
cin >> n >> m;
vector<pair<ll,ll>> s(n);
for(int i=0;i<n;i++) cin >> s.at(i).first >> s.at(i).second;
vector<pair<ll,ll>> p(m);
for(int i=0;i<m;i++) cin >> p.at(i).first >> p.at(i).second;
for(int i=0;i<n;i++){
ll ans=1;
ll k=kyori(s.at(i).first,s.at(i).second,p.at(0).first,p.at(0).second);
for(int j=1;j<m;j++){
if(kyori(s.at(i).first,s.at(i).second,p.at(j).first,p.at(j).second)<k){
ans=j+1;
k=kyori(s.at(i).first,s.at(i).second,p.at(j).first,p.at(j).second);
}
}
cout << ans << endl;
}
}
| 0
| 86,655,435
|
#define _USE_MATH_DEFINES
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <cfloat>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#include <random>
#include <cassert>
using namespace std;
#define rep(i, N) for (int i = 0; i < N; i++)
#define pb push_back
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<ll, int> ll_i;
typedef pair<int, ll> i_ll;
typedef pair<double, int> d_i;
typedef pair<ll, ll> ll_ll;
typedef pair<double, double> d_d;
typedef vector<int> vi;
struct edge { int v; ll w; };
const int MOD = 1000000007;
ll _MOD = 1000000009;
double EPS = 1e-10;
ll INF = INT_MAX;
struct binary_heap {
int N;
vector<int> a;
binary_heap() : N(0) {}
void push(int x) {
a.pb(x); N++;
for (int i = N - 1; i;) {
int p = (i - 1) / 2;
if (a[p] >= a[i]) break;
swap(a[i], a[p]);
i = p;
}
}
int pop() {
int x = a[0];
swap(a[0], a[N - 1]);
a.pop_back(); N--;
for (int i = 0; i * 2 + 1 < N;) {
int l = i * 2 + 1, r = i * 2 + 2;
if (r < N && a[l] < a[r]) swap(l, r);
if (a[l] <= a[i]) break;
swap(a[i], a[l]);
i = l;
}
return x;
}
};
int main() {
binary_heap q;
for (;;) {
char s[10]; scanf("%s", s);
if (s[2] == 's') {
int x; scanf("%d", &x);
q.push(x);
}
if (s[2] == 't') {
int x = q.pop();
printf("%d\n", x);
}
if (s[2] == 'd') break;
}
}
|
#include <bits/stdc++.h>
#include <iomanip>
#include <math.h>
#define rep(i,x) for(ll i = 0;i<x;i++)
#define all(a) (a).begin(),(a).end()
using ll = long long;
using ld = long double;
using namespace std;
using dou = double;
const ll inf = 2147483647;
const ll INF = 1LL << 60;
const ld pi = 3.14159265358;
const ll mod = 1000000007;
typedef pair<ll,ll> P;
using graph = vector<vector<ll>>;
template<class T> inline bool chmax(T& a, T b){if(a < b){a = b; return true;}return false;}
template<class T> inline bool chmin(T& a, T b){if(a > b){a = b; return true;}return false;}
ll gcd(ll a,ll b){
if(a < b)swap(a,b);
if(a % b == 0)return b;
else return gcd(b,a%b);
}
bool isp(ll n){
bool res = true;
if(n == 1)return false;
else{
for(ll i = 2;i * i <= n;i++){
if(n % i == 0){
res = false;
break;
}
}
return res;
}
}
ll fac[510000], finv[510000], inv[510000];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < 510000; 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 nCk(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 modpow(ll n,ll m,ll MOD){
ll res = 1;
while(m){
if(m & 1)res = (res * n) % MOD;
m >>= 1;
n *= n;
n %= MOD;
}
return res;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
string S;
cin >> S;
cout << S.substr(0,4) << " " << S.substr(4,8) << endl;
}
| 0
| 60,788,953
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define srep(i,s,t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(),a.end()
#define sz(x) (int)(x).size()
#define uni(x) x.erase(unique(rng(x)),x.end())
#define show(x) cout<<#x<<" = "<<x<<endl;
#define PQ(T) priority_queue<T,v(T),greater<T> >
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
#define EPS (1e-10)
#define equals(a, b) (fabs((a)-(b)) < EPS)
using namespace std;
typedef long long int ll;
typedef pair<int,int> P;
typedef set<int> S;
typedef queue<int> Q;
typedef queue<P> QP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
const int MOD = 1000000007;
int main() {
int H,W;
cin >> H >> W;
v(string) G(2*H,string(W,'.'));
rep(i,H) {
string s;
cin >> s;
rep(j,W) {
rep(di,2) {
G[2*i+di][j]=s[j];
}
}
}
rep(i,2*H) {
cout << G[i] << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <cmath>
#include <vector>
#include <set>
#include <list>
#include <stack>
#include <map>
#include <cstring>
#include <unordered_map>
#include <queue>
#include <functional>
#define mod 998244353
#define int long long
#define ld long double
#define pb push_back
#define vi vector<int>
#define co(x) cout << x << '\n'
#define dbg(x) cerr << #x << " = " << x << '\n'
#define sz(x) (int)x.size()
#define all(a) a.begin(),a.end()
#define ff first
#define ss second
#define pii pair<int,int>
#define lcm(a,b) (a*b)/__gcd(a,b)
using namespace std;
inline void solve(){
int n, m, ans = 0 ;
cin >> n >> m ;
vector < pair<int, int> > ab ;
vector <int> ocupy ;
for (int i = 1 ; i <= m; i++) ocupy.pb(i);
for (int i = 0 ; i < n ; i++) {
int a,b ; cin>>a>>b;
if (a>m) continue;
ab.emplace_back(b,a) ;
}
sort(all(ab)) ;
for (int i = sz(ab)-1 ; i >= 0 ; i--) {
int k = ab[i].ss ;
auto it = lower_bound(ocupy.begin(), ocupy.end(), k ) ;
if (it != ocupy.end()) {
int in = it - ocupy.begin() ;
ocupy.erase( ocupy.begin() + in ) ;
ans += ab[i].ff ;
}
}
co (ans) ;
}
signed main()
{
int n=1;
while (n--) solve();
return 0;
}
| 0
| 41,287,228
|
#include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int mod=1000000007;
const int INF=1001001001;
int main() {
int a,b;
cin>>a>>b;
if(a+b==15){cout<<'+'<<endl;}
else if(a*b==15){cout<<'*'<<endl;}
else{cout<<'x'<<endl;}
return 0;
}
|
#include <bits/stdc++.h>
#define Fast cin.tie(0), ios::sync_with_stdio(0)
#define All(x) x.begin(), x.end()
#define louisfghbvc int t; cin >> t; while(t--)
#define sz(x) (int)(x).size()
using namespace std;
typedef long long LL;
typedef pair<LL, LL> ii;
typedef vector<LL> vi;
template<typename T> ostream& operator<<(ostream &os, const vector<T> &v) { os << '{'; string sep = ""; for(const auto &x : v) os << sep << x, sep = ", "; return os << '}'; }
template<typename A, typename B> ostream& operator<<(ostream &os, const pair<A, B> &p) { return os << '(' << p.first << ", " << p.second << ')'; }
void dbg_out() { cerr << "\n"; }
template<typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << ' ' << H; dbg_out(T...); }
const int mod = 1e9+7;
const int N = 1e5+5;
LL arr[105];
LL dp[105][N];
void solve(){
int n, k;
cin >> n >> k;
for(int i = 1; i <= n; ++i) cin >> arr[i];
memset(dp, 0, sizeof dp);
dp[0][0] = 1;
for(int i = 1; i <= n; ++i){
int sum[k+1];
sum[0] = dp[i-1][0];
for(int j = 1; j <= k; ++j)
sum[j] = (sum[j-1] + dp[i-1][j]) % mod;
for(int j = 0; j <= k; ++j){
int tmp = sum[j];
int cur = j-arr[i]-1;
if(cur >= 0){
tmp = (tmp - sum[cur]+ mod) % mod;
}
dp[i][j] = tmp;
}
}
cout << dp[n][k] << "\n";
}
int main()
{
Fast;
solve();
return 0;
}
| 0
| 74,567,701
|
#include<iostream>
#include<vector>
using namespace std;
int main() {
string s; cin >> s;
for (int i = 1; i < s.size(); ++i)
{
int sz = s.size() - i;
if (sz % 2 != 0)
continue;
if (s.substr(0, sz / 2) == s.substr(sz / 2, sz / 2)){
cout << sz;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ar array
struct Node{
int Num;
int length = 0;
set<Node*> reach;
};
int N,M,A,B;
Node a[100001];
int r[100001];
void solve(){
cin >> N >> M;
for (int i = 0; i < N; i++)
{
a[i].Num = i;
r[i] = 0;
}
for (int i = 0; i < M; i++)
{
cin >> A >> B;
A--;
B--;
a[A].reach.insert(&a[B]);
a[B].reach.insert(&a[A]);
}
vector<Node*> queue;
vector<Node*> nextqueue;
queue.push_back(&a[0]);
r[0] =1;
int cur = 1;
while (!queue.empty())
{
for (auto q : queue)
{
for (auto rea : q->reach)
{
if(r[rea->Num] == 0){
rea->length = q->Num+1;
r[rea->Num] = 1;
nextqueue.push_back(rea);
}
}
}
cur++;
queue = nextqueue;
nextqueue.clear();
}
bool flag = false;
for (int i = 0; i < N; i++)
{
if(r[i] ==0) flag == true;
}
if(flag){
cout << "No"<< endl;
}
else{
cout << "Yes" << endl;
for (int i = 1; i < N; i++)
{
cout << a[i].length << endl;
}
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
solve();
}
| 0
| 52,288,398
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
if(a!=1&&b!=1){
cout<<"1"<<endl;}
else if(a!=2&&b!=2){
cout<<"2"<<endl;}
else{
cout<<"3"<<endl;}
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int c1=0,c2=0,c3=0,c4=0;
for(int i=0;i<3;i++){
int ai,bi;
cin>>ai>>bi;
if(ai==1)
c1++;
else if(ai==2)
c2++;
else if(ai==3)
c3++;
else
c4++;
if(bi==1)
c1++;
else if(bi==2)
c2++;
else if(bi==3)
c3++;
else
c4++;
}
if(max(max(max(c1,c2),c3),c4)>=3)
cout<<"NO"<<endl;
else
cout<<"YES"<<endl;
return 0;
}
| 0
| 1,297,743
|
#include <cassert>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#include <random>
#include <memory>
#include <utility>
#include <limits>
#include "limits.h"
#define rep(i, a, b) for (long long (i) = (a); i < (b); i++)
#define all(i) i.begin(), i.end()
#define debug(i) std::cerr << "debug " <<"LINE:"<<__LINE__<<" "<< #i <<":"<< i << std::endl
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& os, std::pair<T1, T2> pa) {
return os << pa.first << " " << pa.second;
}
template <typename T>
std::ostream& operator<<(std::ostream& os, std::vector<T> vec) {
for (int i = 0; i < vec.size(); i++)os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
template<typename T1,typename T2>
inline bool chmax(T1& a,T2 b){return a<b && (a=b,true);}
template<typename T1,typename T2>
inline bool chmin(T1& a,T2 b){return a>b && (a=b,true);}
long long pow_mod(long long a, long long b, long long mod=-1) {
if(b==0)return 1;
if ((a == 0)||(mod!=-1&&(a+mod)%mod==0)) {
return 0;
}
long long x = 1;
while (b > 0) {
if (b & 1) {
x = (mod!=-1)?(x * a) % mod:x*a;
}
a = (mod!=-1)?(a * a) % mod:a*a;
b >>= 1;
}
return x;
}
const long long MOD = 1e9 + 7;
using ll = long long;
using P = std::pair<ll, ll>;
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
ll n,k;
std::cin>>n>>k;
std::vector<P> num(n);
rep(i,0,n)std::cin>>num[i].first>>num[i].second;
ll ans=0;
rep(i,0,n){
if((k|num[i].first)==k)ans+=num[i].second;
}
rep(i,0,31){
if((k>>i)&1){
ll bit=k-(1ll<<i);
rep(j,0,i){
if(!((bit>>j)&1)){
bit+=(1ll<<j);
}
}
ll temp=0;
rep(j,0,n){
if((bit|num[j].first)==bit)temp+=num[j].second;
}
chmax(ans,temp);
}
}
std::cout<<ans<<"\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<string> blue(N);
for(int i = 0; i < N; i++) cin >> blue.at(i);
int M;
cin >> M;
vector<string> red(M);
for(int i = 0; i < M; i++) cin >> red.at(i);
int sum = 0;
for(int i = 0; i < N; i++) {
string s = blue.at(i);
if(s == "") continue;
int b = 0;
for(int j = 0; j < N; j++) {
if(blue.at(j) == s) {
blue.at(j) == "";
b++;
}
}
for(int j = 0; j < M; j++) {
if(red.at(j) == s) b--;
}
if(b > sum) sum = b;
}
cout << sum << endl;
}
| 0
| 41,888,651
|
#include <bits/stdc++.h>
#define FASTIO ios::sync_with_stdio(false);cin.tie(0);
#define ADD +
#define SUBTRACT -
#define MULTIPLY *
#define DIVIDE /
#define MOD %
#define INCREMENT(x) ++x
#define DECREMENT(x) --x
#define in(a,b) cin>>a>>b;
#define out(a,b) cout<<a<<endl<<b<<endl;
#define scan(a) scanf("%d",&a);
#define print(a) printf("%d\n",a);
#define scanii(a,b) scanf("%d %d",&a,&b);
#define printii(a,b) printf("%d\n%d\n",a,b);
#define scaniii(a,b,c) scanf("%d %d %d",&a,&b,&c);
#define pub push_back
#define pob pop_back
#define puf push_front
#define pof pop_front
#define ll long long
#define ull unsigned long long
#define sll signed long long
#define pi acos(-1)
#define mod 1000000007
#define TRUE 1
#define FALSE 0
#define ZERO 0
#define MP make_pair
#define F first
#define S second
#define f1(i,a) for(int i=0;i<a;++i)
#define f2(i,a) for(int i=a-1;i>=0;--i)
#define en puts("");
#define elif else if
typedef ll int lli;
typedef sll int slli;
typedef ull int ulli;
const int sz=10000;
using namespace std;
int clue();
int result();
void show();
bool check();
bool cmp(pair<int,int>p,pair<int,int>q) {
return p.second<q.second;
}
int main() {
int t;
t=1;
while(t-->0) {
clue();
}
return 0;
}
int clue() {
int a[50]={1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
int k;
cin>>k;
cout<<a[k-1]<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e2 + 10;
int a[MAXN], b[MAXN];
int n, mx = 0;
template <class T>
inline void _read(T &x)
{
x = 0;
char t = getchar();
while (!isdigit(t) && t != '-') t = getchar();
if (t == '-')
{
_read(x);
x *= -1;
return ;
}
while (isdigit(t))
{
x = x * 10 + t - '0';
t = getchar();
}
}
int main()
{
_read(n);
for (int i = 1; i <= n; ++i) _read(a[i]), mx = max(mx, a[i]), ++b[a[i]];
if(mx & 1)
{
for(int i = mx; i >= (mx + 1) / 2; --i)
if(b[i] < 2)
{
puts("Impossible");
return 0;
}
for(int i = 1; i < (mx + 1) / 2; ++i)
if(b[i])
{
puts("Impossible");
return 0;
}
if(b[(mx + 1) / 2] > 2)
{
puts("Impossible");
return 0;
}
}
else
{
for(int i = mx; i > mx / 2; --i)
if(b[i] < 2)
{
puts("Impossible");
return 0;
}
for(int i = 1; i < mx / 2; ++i)
if(b[i])
{
puts("Impossible");
return 0;
}
if(b[mx / 2] != 1)
{
puts("Impossible");
return 0;
}
}
puts("Possible");
return 0;
}
| 0
| 41,989,790
|
#include <bits/stdc++.h>
using namespace std;
const int INF=999999999;
int main() {
int64_t Q,H,S,D,N;
cin>>Q>>H>>S>>D>>N;
cout<<min(min({4*Q,2*H,S})*N , D*(N/2)+min({4*Q,2*H,S})*(N%2))<<endl;
return 0;}
|
#include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define rep2(i, s, n) for (ll i = s; i < (ll)(n); i++)
#define repr(i, n) for (ll i = n; i >= 0; i--)
#define pb push_back
#define COUT(x) cout << (x) << endl
#define COUTF(x) cout << setprecision(15) << (x) << endl
#define ENDL cout << endl
#define DF(x) x.erase(x.begin())
#define ALL(x) x.begin(), x.end()
#define SORT(x) sort(ALL(x))
#define REVERSE(x) reverse(ALL(x))
#ifdef _DEBUG
#define debug(x) cout << "[debug] " << #x << ": " << x << endl
#else
#define debug(x)
#endif
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using P = pair<ll, ll>;
constexpr ll INF = 0x3f3f3f3f3f3f3f3f;
constexpr double PI = 3.141592653589793238462643383279;
ll getDigit(ll x) {
return x == 0 ? 1 : log10(x) + 1;
}
ll gcd(ll x, ll y) {
return y ? gcd(y, x % y) : x;
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}
vector<P> factorize(ll n) {
vector<P> result;
for (ll i = 2; i * i <= n; ++i) {
if (n % i == 0) {
result.pb({i, 0});
while (n % i == 0) {
n /= i;
result.back().second++;
}
}
}
if (n != 1) {
result.pb({n, 1});
}
return result;
}
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;
}
template <typename T>
void debugV(const vector<T> v) {
#ifdef _DEBUG
rep(i, v.size()) {
cout << i << ":" << v[i] << " ";
}
cout << endl;
#else
(void)v;
#endif
}
vll a(100), p(100);
ll burger(ll n, ll x) {
if (n == 0) {
return x <= 0 ? 0 : 1;
}
if (x == 1) {
return 0;
}
if (1 < x && x < 2 + a[n - 1]) {
return burger(n - 1, x - 1);
}
if (x == 2 + a[n - 1]) {
return p[n - 1] + 1;
}
if (2 + a[n - 1] < x && x < a[n]) {
return p[n - 1] + 1 + burger(n - 1, x - a[n - 1] - 2);
}
if (x == a[n]) {
return p[n];
}
return 0;
}
signed main() {
ll N, X;
cin >> N >> X;
rep(i, 100) {
if (i == 0) {
a[i] = 1;
p[i] = 1;
continue;
}
a[i] = 2 * a[i - 1] + 3;
p[i] = 2 * p[i - 1] + 1;
}
ll b = burger(N, X);
COUT(b);
return 0;
}
| 0
| 83,383,728
|
#include <bits/stdc++.h>
#include <algorithm>
using namespace std;
#define sqr(x) ((x) * (x))
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
typedef long long ll;
const int MOD = 1000000007;
const int INF = 1000000007;
const ll INFLL = 1000000000000000007LL;
void solve() {
int A, B, X;
cin >> A >> B >> X;
string ans = "NO";
if (X >= A && X <= A + B) ans = "YES";
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
int main(){
int n;
cin>>n;
vector<vector<int>> arr(n, vector<int>(3));
for(int i = 0;i<n;i++){
cin>>arr[i][0]>>arr[i][1]>>arr[i][2];
}
vector<vector<int>> dp(n, vector<int>(3));
dp[0][0] = arr[0][0];
dp[0][1] = arr[0][1];
dp[0][2] = arr[0][2];
for(int i=1;i<n;i++){
for(int j=0;j<3;j++){
for(int k =0;k<3;k++){
if(j==k) continue;
dp[i][j] = max(dp[i][j], dp[i-1][k] + arr[i][j]);
}
}
}
int ans = -1;
for(int j=0;j<3;j++){
ans = max(ans, dp[n-1][j]);
}
cout<<ans<<endl;
}
| 0
| 43,221,059
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vl;
typedef vector<string> vs;
typedef vector<char> vc;
typedef queue<ll> ql;
typedef deque<ll> dql;
typedef priority_queue<ll, vl> pql;
typedef set<ll> sl;
typedef pair<ll, ll> pl;
typedef vector<vl> vvl;
typedef vector<pl> vpl;
#define rep(i, n) for(ll i = 0; i < ll(n); i++)
#define rep2(i, n) for(ll i = 1; i <= ll(n); i++)
#define all(v) (v).begin(), (v).end()
bool chmin(ll &a, ll b) {if(b < a) {a = b; return 1;} return 0;}
bool chmax(ll &a, ll b) {if(b > a) {a = b; return 1;} return 0;}
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
const ll MAX = 1e9;
const char newl = '\n';
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
vc vec;
map<char, ll> m;
rep(i, 4) {
vec.push_back(s[i]);
m[s[i]]++;
}
bool T=1;
rep(i, vec.size()) if(m[vec[i]]!=2) T=0;
cout << (T ? "Yes" : "No") << newl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define fast() ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define all(x) begin(x),end(x)
#define rz(x) resize(x)
#define asn(x,y) assign(x,y)
#define mem(a,b) memset(a,b,sizeof(a))
#define sz(x) ((int)size(x))
#define eb emplace_back
#define pb push_back
#define pf push_front
#define pob pop_back
#define pof pop_front
#define ins insert
#define vi vector<int>
#define pii pair<int,int>
#define mii map<int,int>
#define F first
#define S second
#define remax(a,b) a=max(a,b)
#define remin(a,b) a=min(a,b)
#define bitcount(x) __builtin_popcountll(x)
#define iceil(n,x) (((n)-1)/(x)+1)
#define flush fflush(stdout)
using ull=unsigned long long;
using ll=long long;
using ld=long double;
string to_string(char s)
{ string res="'''";res[1]=s;return res; }
string to_string(string s)
{ return '"'+s+'"'; }
string to_string(const char* s)
{ return to_string((string)s); }
string to_string(bool b)
{ return (b?"true":"false"); }
template<typename A, typename B>
string to_string(pair<A, B> p)
{ return "("+to_string(p.F)+", "+to_string(p.S)+")"; }
template<typename A>
string to_string(A v)
{
bool first=1; string res="{";
for(const auto &x:v)
{
if(!first) res+=", ";
first=0;
res+=to_string(x);
}
res+="}";
return res;
}
void debug() { cout<<"\n"; }
template<typename Head, typename... Tail>
void debug(Head H, Tail... T)
{
cout<<" "<<to_string(H);
debug(T...);
}
#define show(...) cout << "[" << #__VA_ARGS__ << "]:", debug(__VA_ARGS__)
const int M=1e9+7;
inline int add(int a,int b,int p=M){ a=a+b; if(a>=p) a-=p; return a; }
inline int sub(int a,int b,int p=M){ a=a-b; if(a<0) a+=p; return a; }
inline int mul(int a,int b,int p=M){ a=(a*1ll*b)%p; return a; }
const ld pi=acos(-1),eps=1e-9;
const ll inf=1e18;
const int N=1;
void solve()
{
int n;
cin>>n;
vi v(n);
for(auto& c:v)
cin>>c;
int have=1000;
int prv=0;
for(int i=1;i<n;++i)
{
if(v[i-1]>v[i])
{
int cnt=have/v[prv];
have%=v[prv];
have+=v[i-1]*cnt;
prv=i;
}
}
int cnt=have/v[prv];
have%=v[prv];
have+=v[n-1]*cnt;
cout<<have;
}
int32_t main()
{
fast();
int t=1;
for(int z=1;z<=t;++z)
{
solve();
}
return 0;
}
| 0
| 42,814,065
|
#include<bits/stdc++.h>
using namespace std;
#define arep(i,x,n) for(int i=int(x);i<(int)(n);i++)
#define rep(i,n) for(long long i = 0;i < n;++i)
#define pi 3.141592653589793
#define eps 0.00000001
#define INF 1e9+7
using ll = long long;
using P=pair<int,int>;
using lP=pair<ll,ll>;
using fP=pair<double,double>;
int main(){
int n,k;
cin>>n>>k;
string s;
cin>>s;
int index=0,cnt=0;
vector<int>zero,one;
if(s[0]=='0')one.push_back(0);
rep(i,n){
cnt=1;
while(i<n-1){
if(s[i]!=s[i+1])break;
cnt++;
i++;
}
if(s[i]=='0')zero.push_back(cnt);
else one.push_back(cnt);
}
if(s[n-1]=='0')one.push_back(0);
if(zero.size()==0){
cout<<s.size()<<endl;
return 0;
}
if(zero.size()<=k){
cout<<s.size()<<endl;
return 0;
}
int ref=one[0];
rep(i,k)ref+=(one[i+1]+zero[i]);
int ans=ref;
for(int i=k;i<(int)zero.size();i++){
ref-=(one[i-k]+zero[i-k]);
ref+=(one[i+1]+zero[i]);
ans=max(ans,ref);
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
using ll = long long;
using ld = long double;
#define rep2(i, s, n) for (ll i = (s); i < (ll)(n); i++)
#define rep3(i, n) for (ll i = 1; i < (ll)(n+1); i++)
#define rep4(i, s, n) for (ll i = (s); i < (ll)(n+1); i++)
#define repr(i,n) for (ll i = (n-1); i>=0;i--)
#define repr3(i,n) for(ll i = (n);i>0;i--)
#define repr4(i,s,n) for(ll i = (n);i>=(s);i--)
#define stlen(s) ll s.size()-1
#define all(v) v.begin(), v.end()
#define cout(n) cout<<std::fixed<<std::setprecision(n)
using Graph = vector<vector<int>>;
using Graphw = vector<vector<pair<ll,ll>>>;
#define INF1 INT_MAX;
#define INF2 LLONG_MAX;
#define PI 3.14159265358979323846;
#define MOD 1000000007;
int main(){
int N; cin >> N;
vector<vector<pair<ll,ll>>> G(N+1);
for (int i = 0; i < N-1; ++i) {
int a, b;
ll c;
cin >> a >> b>>c;
G[a].push_back(make_pair(b,c));
G[b].push_back(make_pair(a,c));
}
vector<ll> dist(N+1, -1);
queue<ll> que;
int Q,K;
cin>>Q>>K;
dist[K] = 0;
que.push(K);
while (!que.empty()) {
int v = que.front();
que.pop();
rep(j,G[v].size()) {
if (dist[G[v][j].first] != -1) continue;
dist[G[v][j].first] = dist[v] + G[v][j].second;
que.push(G[v][j].first);
}
}
ll ans[Q];
rep(i,Q){
int x,y;
cin>>x>>y;
ans[i]=dist[x]+dist[y];
}
rep(i,Q){
cout<<ans[i]<<endl;
}
return 0;
}
| 0
| 31,856,453
|
#include <iostream>
using namespace std;
int main() {
bool judge = true;
int x;
int n = 0;
while (judge) {
cin >> x;
n++;
if (x != 0) {
cout << "Case " << n << ": " << x << endl;
} else {
judge = false;
}
}
return 0;
}
|
#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 <math.h>
#include <iomanip>
using namespace std;
#define int long long
signed main(){
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int n,m; cin >> n >> m;
vector<int> a(m),b(m);
for(int i = 0;i < m;i ++) cin >> a.at(i) >> b.at(i);
vector<int> s(0),g(0);
for(int i = 0;i < m;i ++){
if(a.at(i) == 1) s.push_back(b.at(i));
else if(b.at(i) == 1) s.push_back(a.at(i));
else if(a.at(i) == n) g.push_back(b.at(i));
else if(b.at(i) == n) g.push_back(a.at(i));
}
if(s.size() == 0 || g.size() == 0){
cout << "IMPOSSIBLE" << endl;
return 0;
}
sort(s.begin(),s.end());
sort(g.begin(),g.end());
for(int i = 0;i < s.size();i ++){
if(lower_bound(g.begin(),g.end(),s.at(i)) != upper_bound(g.begin(),g.end(),s.at(i))){
cout << "POSSIBLE" << endl;
return 0;
}
}
cout << "IMPOSSIBLE" << endl;
}
| 0
| 48,935,994
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int s;
cin>>s;
vector<int> dp(s+1,0);
int mod = 1e9 + 7;
dp[0] = 1;
dp[1] = 0;
dp[2] = 0;
for(int i = 3;i<=s;i++)
{
int j = 3;
while(j <= i)
{
dp[i] = (dp[i] + dp[i-j]) % mod;
j++;
}
}
cout<<dp[s]<<"\n";
return 0;
}
|
#include <iostream>
#include <stdio.h>
using namespace std;
int main(int argc, const char * argv[]) {
int n, i, j, id, num, node;
scanf("%d", &n);
int A[n][n];
for(i = 0; i < n; i++){
for(j = 0; j < n; j++){
A[i][j] = 0;
}
}
for (i = 0; i < n; i++){
scanf("%d", &id);
scanf("%d", &num);
for(j = 0; j < num; j++){
scanf("%d", &node);
A[id-1][node-1] = 1;
}
}
for(i = 0; i < n; i++){
for(j = 0; j < n; j++){
if(j) cout << " ";
cout<<A[i][j];
}
cout<<endl;
}
return 0;
}
| 0
| 21,361,985
|
#include<bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define pii pair<int, int>
#define pll pair<long long , long long>
#define pb push_back
#define ll long long
#define ld long double
#define precision(x,d) cout<<fixed<<setprecision(d)<<x
#define fill(a,b) memset((a),(b),sizeof((a)))
#define FAST ios_base::sync_with_stdio(false),cin.tie(0),cout.tie(0);srand(time(NULL));
ll power(ll x,ll y,ll m){ll r=1;for(;y;y>>=1){if(y&1)r=r*x%m;x=x*x%m;}return r;}
const ll mod = 1e9 + 7;
const ld pi = 3.14159265358979;
int run_test(){
int n, m;
cin >> n >> m;
priority_queue<ll> pq;
for(int i=0; i<n; i++){
ll a;
cin >> a;
pq.push(a);
}
while(m > 0){
ll f = pq.top();
pq.pop();
if( f == 0){
cout << 0;
return 0;
}
f /= 2;
pq.push(f);
m--;
}
ll sum = 0;
while(!pq.empty()){
ll t = pq.top();
sum += t;
pq.pop();
}
cout << sum;
return 0;
}
int main(){
FAST;
ll t;
t = 1;
while(t--){
run_test();
}
}
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define srep(i,s,t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()
#define maxs(x,y) (x = max(x,y))
#define mins(x,y) (x = min(x,y))
#define limit(x,l,r) max(l,min(x,r))
#define lims(x,l,r) (x = max(l,min(x,r)))
#define isin(x,l,r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)),x.end())
#define show(x) cout<<#x<<" = "<<x<<endl;
#define PQ(T) priority_queue<T,v(T),greater<T> >
#define bn(x) ((1<<x)-1)
#define dup(x,y) (((x)+(y)-1)/(y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef tuple<int,int,int> T;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
typedef vector<T> vt;
int query(int i){
cout << i <<endl;
string s;
cin >> s;
if(s[0] == 'V')exit(0);
return (s[0] == 'M');
}
int main() {
int n;
cin >> n;
int l=0,r = n-1;
int eve = query(l);
query(r);
while(true){
int mid = (l+r)/2;
int a = query(mid);
if(mid%2){
if(a == eve) r = mid;
else l = mid;
}else{
if(a == eve) l = mid;
else r = mid;
}
}
return 0;
}
| 0
| 95,129,599
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
string s;
cin >> s;
vector<int> count;
vector<char> sign;
sign.push_back(s.at(0));
int ct = 0;
for(char c : s) {
if(c == sign.at(sign.size()-1)) ct++;
else {
count.push_back(ct);
ct = 1;
sign.push_back(c);
}
}
count.push_back(ct);
ll ans = 0;
rep(i, count.size()) {
ans += ((ll) count.at(i)*(count.at(i)+1))/2;
if(i+1 < count.size() && sign.at(i) == '<') {
if(count.at(i) <= count.at(i+1)) ans -= count.at(i);
else ans -= count.at(i+1);
}
}
cout << ans << endl;
return 0;
}
|
#define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
#include<unordered_map>
#include<string>
#include<set>
#include<queue>
#include<deque>
#include<iomanip>
using namespace std;
#define Mohamed_Gad fast()
#define ll long long
#define ull unsigned long long
#define all(v) v.begin(),v.end()
#define endl "\n"
#define sz(x) size(x)
void fast()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void Open()
{
#ifndef ONLINE_JUDGE
freopen("Input.txt", "r", stdin);
#endif
}
int main() {
fast();
multiset<int>s;
int n,a,sum=0;
cin>>n;
for(int i=0;i<2*n;i++){
cin>>a;
s.insert(a);
}
multiset<int>::iterator it=s.begin();
for(it;it!=s.end();it++){
sum+=*it;
it++;
}
cout<<sum<<endl;
}
| 0
| 90,115,698
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define INF 0x6fffffff
#define INFL 0x6fffffffffffffffLL
ll pow2(long long n) {
ll ret = 1;
ll x = 2;
while (n > 0) {
if (n & 1) ret *= x;
x *= x;
n >>= 1;
}
return ret;
}
int main() {
ll a,b,c,h,i,j,k,l,m,n,x,y;
ll ans = 0;
string s;
cin >> n >> k;
long double p = 0.0;
vector<ll> cc;
for(i=n;i>=1;i--) {
c = 0;
a = i;
while(a<k) {
c++;
a *= 2;
}
p += (long double)1/n/pow2(c);
}
cout << fixed << setprecision(10);
cout << p << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
int ans1=0,ans2=0;
for(int i=0; i<s.size(); i++){
if(i%2==(int(s[i])-'0')) ans1++;
else ans2++;
}
cout << min(ans1,ans2) << endl;
return 0;
}
| 0
| 80,163,447
|
#include <iostream>
using namespace std;
long long int f(int a){
return (long long int)a*a;
}
int main(){
int d , od , num;
long long int s=0;
while(cin>>d){
num=600/d;
od=d;
d=0;
for(int i=0 ; i<num ; i++){
s+=od*f(d);
d+=od;
}
cout << s << endl;
s=0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repo(i,n) for(int i = 1; i < (int)(n); i++)
#define pb push_back
#define mp make_pair
#define np next_permutation
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define all(x) (x).begin(),(x).end()
#define mod 1000000007
#define pi acos(-1.0)
const ll INF = 1LL<<61;
template<class T>bool chmax(T &a, const T &b) {
if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) {
if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll jou(ll N, ll P){if(P==0) return 1;
if(P%2==0){ll t = jou(N, P/2);return t*t % mod;
}return (N * jou(N, P-1)) % mod;}
int main(){
string s;
cin>>s;
int n=s.size();
string nox="";
rep(i,n){
if(s[i]!='x') nox+=s[i];
}
auto copy=nox;
reverse(all(copy));
if(nox!=copy) {
cout << -1 << endl;
return 0;
}
int m=nox.size();
vector<int> zen((m+1)/2);
vector<int> go((m+1)/2);
int cnt=0;
int now=0;
rep(i,n){
if(s[i]=='x') cnt++;
else {
zen[now]=cnt;
cnt=0;
now++;
}
if(now>=(m+1)/2) break;
}
cnt=0;
now=0;
for(int i=n-1;i>=0;i--){
if(s[i]=='x') cnt++;
else {
go[now]=cnt;
cnt=0;
now++;
}
if(now>=(m+1)/2) break;
}
int ans=0;
rep(i,(m+1)/2){
ans+=abs(zen[i]-go[i]);
}
cout << ans << endl;
}
| 0
| 60,482,206
|
#include <bits/stdc++.h>
using namespace std;
int main(){
string o,e;
cin >> o >> e;
for(int i =0; i< (int) o.length(); i++){
cout << o[i];
if(i<(int) e.length()) cout << e[i];
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD=1000000007;
#define INF 1LL<<30
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(),(x).end()
int main(){
int n,m;
cin>>n>>m;
char fi1[n][n];
char fi2[m][m];
rep(i,n){
rep(j,n){
cin>>fi1[i][j];
}
}
rep(i,m){
rep(j,m){
cin>>fi2[i][j];
}
}
for(int i=0;i<=n-m;i++){
for(int j=0;j<=n-m;j++){
bool ok=true;
rep(k,m){
rep(l,m){
if(fi1[i+k][j+l]!=fi2[k][l]) ok=false;
}
}
if(ok){
cout<<"Yes"<<endl;
return 0;
}
}
}
cout<<"No"<<endl;
}
| 0
| 42,177,314
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define fin(ans) cout << (ans) << endl;
#define blank(ans) cout << (ans) << " ";
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
typedef long long ll;
typedef long long lli;
typedef unsigned long long ull;
typedef long double ld;
typedef string str;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<ld> vd;
typedef vector<str> vs;
typedef vector<ll> vll;
typedef vector<pair<ll, ll>> vpll;
typedef vector<pair<ll, str>> vpls;
typedef vector<tuple<str, ll, ll>> vtsl;
typedef vector<vector<ll>> vvll;
typedef vector<vector<char>> vvc;
typedef vector<vector<str>> vvs;
const ld PI = acos(-1.0);
const ll MAX = 9000000000000000000;
const ll MIN = -9000000000000000000;
const ld DMAX = 4500;
const ld DMIN = -4500;
const ll MOD = 1000000007;
void Main()
{
ll x, y; cin >> x >> y;
if(x % y == 0)
{
fin(-1)
}
else
{
fin(x)
}
return;
}
int main()
{
cout << fixed << setprecision(20);
Main();
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int n;
while(cin>>n){
int a=0;
for(int i=0;i<10;i++)
for(int j=0;j<10;j++)
for(int p=0;p<10;p++)
for(int q=0;q<10;q++)
if(i+j+p+q==n)
a++;
cout<<a<<endl;
}
}
| 0
| 88,487,760
|
#include "bits/stdc++.h"
using namespace std;
#define DEBUG(x) cerr<<#x<<": "<<x<<endl;
#define DEBUG_VEC(v) cerr<<#v<<":";for(int i=0;i<v.size();i++) cerr<<" "<<v[i]; cerr<<endl
typedef long long ll;
#define vi vector<int>
#define vl vector<ll>
#define vii vector< vector<int> >
#define vll vector< vector<ll> >
#define vs vector<string>
#define pii pair<int,int>
#define pis pair<int,string>
#define psi pair<string,int>
#define pll pair<ll,ll>
template<class S, class T> pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) { return pair<S, T>(s.first + t.first, s.second + t.second); }
template<class S, class T> pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) { return pair<S, T>(s.first - t.first, s.second - t.second); }
template<class S, class T> ostream& operator<<(ostream& os, pair<S, T> p) { os << "(" << p.first << ", " << p.second << ")"; return os; }
#define X first
#define Y second
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define rep1(i,n) for(ll i=1;i<=(ll)(n);i++)
#define rrep(i,n) for(ll i=(ll)(n)-1;i>=0;i--)
#define rrep1(i,n) for(ll i=(ll)(n);i>0;i--)
#define REP(i,a,b) for(ll i=(ll)a;i<(ll)b;i++)
#define in(x, a, b) (a <= x && x < b)
#define all(c) c.begin(),c.end()
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 (a>b) { a = b; return 1; } return 0; }
#define UNIQUE(v) v.erase(std::unique(v.begin(), v.end()), v.end());
const ll inf = 1000000001;
const ll INF = 2e18;
const ll MOD = 1000000007;
const double pi = 3.14159265358979323846;
#define Sp(p) cout<<setprecision(15)<< fixed<<p<<endl;
int dx[4] = { 1,0, -1,0 }, dy[4] = { 0,1,0,-1 };
int dx2[8] = { 1,1,0,-1,-1,-1,0,1 }, dy2[8] = { 0,1,1,1,0,-1,-1,-1 };
#define fio() cin.tie(0); ios::sync_with_stdio(false);
int main() {
while (true) {
int n;
cin >> n;
if (!n) {
return 0;
}
vi a(n);
rep (i, n) {
cin >> a[i];
}
sort(all(a));
int ans = inf;
rep (i, n - 1) {
ans = min(ans, a[i + 1] - a[i]);
}
cout << ans << endl;
}
}
|
#include <iostream>
#include <algorithm>
#include <vector>
int main(){
std::ios::sync_with_stdio(false);
std::cin.tie(0);
while(true){
int m, f, r;
std::cin >> m >> f >> r;
if(m==-1 && f==-1 && r==-1) break;
char rank;
if(m==-1 || f==-1) rank = 'F';
else if(m+f>=80) rank = 'A';
else if(m+f>=65) rank = 'B';
else if(m+f>=50) rank = 'C';
else if(m+f>=30){
if(r>=50) rank = 'C';
else rank = 'D';
}
else rank = 'F';
std::cout << rank << "\n";
}
return 0;
}
| 0
| 15,715,338
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> ii;
#define DEBUG freopen("in.txt", "r", stdin);
struct fastio {
fastio() {
ios::sync_with_stdio(false);
cout << setprecision(10) << fixed;
cin.tie(0);
}
};
fastio _fast_io;
const int N = 1e5 + 5;
int n;
int a, b, c, d;
bool neg[3];
int main() {
cin >> n;
a = n / 1000;
b = (n % 1000) / 100;
c = (n % 100) / 10;
d = n % 10;
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
for (int k = 0; k < 2; ++k) {
int t = a + b * (i ? 1 : -1) + c * (j ? 1 : -1) + d * (k ? 1 : -1);
if (t == 7) {
char op1 = (i ? '+' : '-');
char op2 = (j ? '+' : '-');
char op3 = (k ? '+' : '-');
cout << a << op1 << b << op2 << c << op3 << d << "=7" << endl;
exit(0);
}
}
}
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <string>
#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 pb push_back
#define mp make_pair
#define bg begin()
#define en end()
using namespace std;
typedef long long ll;
static const long long MOD = 1000000007;
static const long long MAX = 1000000000;
ll S, _x1, _y1, _x2 = 1, _y2 = MAX, _x3 = 0, _y3 = 0;
int main(void) {
cin >> S;
ll q = S/MAX, r = S%MAX;
if (r!=0){
_x1 = q+1;
_y1 = MAX-r;
} else {
_x1 = q;
_y1 = r;
}
printf("%lld %lld %lld %lld %lld %lld\n", _x1, _y1, _x2, _y2, _x3, _y3);
return 0;
}
| 0
| 40,615,548
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.