code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 2
101M
|
|---|---|---|---|
#include <iostream>
using namespace std;
int main(){
int n, t = 100000;
cin >> n;
for( int i = 0; i < n; ++i){
t = 1.05 * t;
t = (t/1000)*1000 + ((t % 1000 != 0) ? 1000 : 0);
}
cout << t << "\n";
return 0;
}
|
#include<stdio.h>
#include<string.h>
int main()
{
char a[51], b[51];
scanf("%s %s", a,b);
int i,l=strlen(b);
for(i=0; i<l; i++)
printf("%c%c", a[i], b[i]);
if(strlen(a)==l+1)
printf("%c", a[i]);
return 0;
}
| 0
| 24,644,441
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace std;
using namespace __gnu_pbds;
#define int long long
#define pb push_back
#define mp make_pair
#define endl '\n'
#define PI acos(-1)
typedef tree<int,null_type,less_equal <int>,rb_tree_tag,tree_order_statistics_node_update>ordered_set;
long mod=1e9+7;
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n,k;
cin>>n>>k;
cout<<((n-k+1>0)?n-k+1:0);
return 0;
}
|
#include<iostream>
#include <climits>
#include<vector>
#include<cstring>
#define mod 1000000007
using namespace std;
long long int Paths(char arr[][1001], int r, int c){
long long int dp[r+1][c+1];
for(int i = 0; i <= r; i++){
for(int j = 0; j <= c; j++){
if(i == 0 || j == 0 || arr[i][j] == '#'){
dp[i][j] = 0;
}else if(i == 1 && j == 1){
dp[i][j] = 1;
}else{
dp[i][j] = ((dp[i-1][j] % mod) + (dp[i][j-1]%mod) )% mod;
}
}
}
return dp[r][c];
}
int main(){
int r, c;
cin>>r>>c;
char arr[1001][1001];
for(int i = 1; i <= r; i++){
for(int j = 1; j <= c; j++){
cin>>arr[i][j];
}
}
cout<<Paths(arr, r, c);
}
| 0
| 74,601,902
|
#pragma warning(disable:4996)
#include <stdio.h>
int main()
{
double d, t, s;
scanf("%lf %lf %lf", &d, &t, &s);
if (d / s > t) printf("No");
else printf("Yes");
}
|
#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<deque>
#include<iomanip>
#include<utility>
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 all(a) a.begin(),a.end()
#define push(a,b) (a).push_back(b)
#define llvec vector<vector<ll>>
#define charvec vector<vector<char>>
#define size(a,b) (a,vector<ll>(b))
#define llpvec vector<pair<ll,ll>>
#define S 21
llfor;
const ll mod=1000000007;
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;rep(i,0,n){ans*=x;}return ans;}
ll fact(ll x){ll ans=1;rep(i,0,x)ans*=(x-i);return ans;}
ll ncr(ll n,ll r){return fact(n)*fact(n-r)/fact(r);}
ll npr(ll n,ll r){return fact(n)/fact(n-r);}
bool prime(ll a){if(a<=1)return false;for(i=2;i*i<=a;i++){if(a%i==0)return false;}return true;}
ll fib(ll x){ll fibo[x+10];fibo[0]=1;fibo[1]=1;fibo[2]=1;rep(i,3,x+1)fibo[i]=fibo[i-1]+fibo[i-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 t=i;rep(i,0,S)rep(j,0,S)b[i][j]=a[i][j];i=t;}
void matrst(ll a[S][S]){ll t=i;rep(i,0,S)rep(j,0,S)a[i][j]=0;i=t;}
void matpow(ll a[S][S]){ll ans[S][S];matrst(ans);ll t=i,k;rep(i,0,S)rep(j,0,S)rep(k,0,S)ans[i][j]+=a[i][k]*a[k][j];matcpy(ans,a);i=t;}
void matmul(ll a[S][S],ll b[S][S], ll as[S][S]){ll t=i,k;matrst(as);rep(i,0,S)rep(j,0,S)rep(k,0,S)as[i][j]+=a[i][k]*b[k][j];i=t;}
int main(){
ll n;cin>>n;
string s;cin>>s;
map<char,ll>map;
rep(i,0,n)map[s[i]]++;
char c;
ll ans=1;
rep(i,0,26){
c='a'+i;
map[c]++;
ans*=map[c];
ans%=mod;
}
ans--;
pr(ans);
return 0;}
| 0
| 25,212,705
|
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <iomanip>
#include <queue>
#define rep(i,n) for(int i=0;i<n;i++)
#define repn(i,n) for(int i=1;i<=n;i++)
using namespace std;
typedef long long ll;
double T,X;
int main(){
cin>>T>>X;
cout<<setprecision(10)<<T/X<<endl;
}
|
#include<iostream>
#include<iomanip>
#include<vector>
#include<map>
#include<list>
#include<string>
#include<algorithm>
#define ll long long
using namespace std;
struct edge {
int to;
ll cost;
};
vector<edge> tree[100010];
ll cost_k[100010];
void dfs(int v,int par,ll dist){
cost_k[v] = dist;
for(int i=0;i<(int)tree[v].size();i++){
if(tree[v][i].to == par) continue;
dfs(tree[v][i].to, v, dist + tree[v][i].cost);
}
}
int main(){
int N;
cin >> N;
for(int i=0;i<N-1;i++){
int a,b,c;
cin >> a >> b >> c;
tree[a].push_back({b,c});
tree[b].push_back({a,c});
}
int Q,K;
cin >> Q >> K;
dfs(K,-1,0);
for(int i=0;i<Q;i++){
int x,y;
cin >> x >> y;
cout << cost_k[x] + cost_k[y] << endl;
}
}
| 0
| 72,729,103
|
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define rep(i, n) for(int i=0;i<n;++i)
#define rrep(i, n) for(int i=n;i>=0;--i)
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
int N;
cin>>N;
int A[N];
for(int i=0;i<N;++i) cin>>A[i];
int index = -1;
for(int i=0;i<N-1;++i) {
if(A[i]!=A[i+1]) {
index = i;
break;
}
}
if(index==-1) {
cout<<1000<<endl;
return 0;
}
bool up;
ll money, kabu;
if(A[index]<A[index+1]) {
money = 1000%A[index];
kabu = 1000/A[index];
up = true;
}
else {
money = 1000;
kabu = 0;
up = false;
}
for(int i=index+1;i<N-1;++i) {
if(up) {
if(A[i]>A[i+1]) {
money += kabu*A[i];
kabu = 0;
up = false;
}
}
else {
if(A[i]<A[i+1]) {
kabu = money/A[i];
money = money%A[i];
up = true;
}
}
}
money += kabu*A[N-1];
cout<<money<<endl;
}
|
#include<stdio.h>
int main(){
int m,f,r,ten;
while(1){
scanf("%d %d %d",&m,&f,&r);
if(m==-1 && f==-1 && r==-1){
break;
}
ten = m+f;
if(m == -1 || f == -1){
printf("F\n");
}else if(ten >= 80){
printf("A\n");
}else if(ten>=65 && ten<80){
printf("B\n");
}else if(ten>=50 && ten<65){
printf("C\n");
}else if(ten>=30 && ten<50){
if(r>=50){
printf("C\n");
}else{
printf("D\n");
}
}else if(ten<30){
printf("F\n");
}
}
}
| 0
| 34,031,658
|
#include <bits/stdc++.h>
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
int64_t N, A, B;
cin >> N >> A >> B;
cout << ((N-N%(A+B))/(A+B))*A+min((N%(A+B)),A) << endl;
}
|
#include <bits/stdc++.h>
#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <random>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define repp(i,n,m) for (int i = m; i < (n); ++i)
#define repl(i,n) for (long long i = 0; i < (n); ++i)
#define reppl(i,n,m) for (long long i = m; i < (n); ++i)
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using PL = pair<long long, long long>;
using Pxy = pair<double, double>;
using T = tuple<int, int, bool>;
const int INF = 1001001007;
const int mod = 1000000007;
const int MOD = 998244353;
const ll inf = 1e18;
template <typename AT>
void printvec(vector<AT> &ar){
rep(i,ar.size()-1) cout << ar[i] << " ";
cout << ar[ar.size()-1] << endl;
}
template <typename Q>
void printvvec(vector<vector<Q>> &ar){
rep(i,ar.size()){
rep(j,ar[0].size()-1) cout << ar[i][j] << " ";
cout << ar[i][ar[0].size()-1] << endl;
}
}
template <typename S>
bool range(S a, S b, S x){
return (a <= x && x < b);
}
int cul(int n){
vector<int> ar(5,0);
int re = 0;
rep(i,5){
ar[i] = n % 10;
n /= 10;
re += ar[i];
}
return re;
}
int main() {
int n, a, b; cin >> n >> a >> b;
int ans = 0;
repp(i,n+1,1){
if (a <= cul(i) && cul(i) <= b) ans += i;
}
cout << ans << endl;
}
| 0
| 1,464,990
|
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int main(){
int n=10;
vector<int> v(n);
for(int i=0;i<n;i++)cin >> v[i];
sort(v.begin(),v.end(),greater<int>());
cout << v[0] << endl << v[1] << endl << v[2] << endl;
}
|
#include <iostream>
using namespace std;
int main()
{
int a, b, c;
cin >> a >> b >> c;
int i;
int counter = 0;
for (i = a; i <= b; i++) {
if (c % i == 0) counter++;
}
cout << counter << "\n";
return 0;
}
| 0
| 85,972,165
|
#include<bits/stdc++.h>
#define LL long long
using namespace std;
int main () {
int N;
cin >> N;
vector<LL>A(N);
for (int i = 0; i < N; i ++) cin >> A[i];
sort(A.begin(), A.end());
vector<LL>sum(N + 1);
sum[0] = A[0];
for (int i = 1; i < N; i ++) sum[i] = sum[i - 1] + A[i];
sum[N] = 1e16;
int mi = 0;
int ma = N - 1;
while (mi != ma) {
int mu = (ma + mi) / 2;
LL now = A[mu];
bool ok = true;
while (now != sum[N - 1]) {
int s = mu;
int l = N;
while (s != l) {
int m = (s + l) / 2;
if (A[m] > now * 2) l = m;
else s = m + 1;
}
if (now == sum[l - 1]) {
ok = false;
break;
}
now = sum[l - 1];
}
if (ok) ma = mu;
else mi = mu + 1;
}
cout << N - ma << endl;
}
|
#include<cstdio>
#include<cmath>
#include<vector>
using namespace std;
int main() {
vector<int> nPrimes;
vector<bool> isPrime;
vector<int> inputs;
int maxN, sqrtMax, n;
maxN = 0;
while(scanf("%d", &n) != EOF) {
if(n > maxN) maxN = n;
inputs.push_back(n);
}
sqrtMax = sqrt(maxN-1) + 1;
isPrime.resize(maxN, true);
nPrimes.resize(maxN, 0);
isPrime[0] = false;
for(int i=2; i<=sqrtMax; ++i) {
if(isPrime[i-1] == false) continue;
for(int j=2*i; j<=maxN; j+=i) {
isPrime[j-1] = false;
}
}
for(int i=1; i<maxN; ++i) {
if(isPrime[i]) nPrimes[i] = nPrimes[i-1] + 1;
else nPrimes[i] = nPrimes[i-1];
}
for(auto it=inputs.begin(); it!=inputs.end(); ++it) {
printf("%d\n", nPrimes[(*it)-1]);
}
}
| 0
| 26,268,166
|
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
long s = 100000;
for (int i = 0; i<n; i++) {
s = s * 1.05;
int s1 = s % 1000;
if (s1 != 0) {
s = s - s1 + 1000;
}
}
cout << s << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
#define rep(X,N) for(ll X = 0; X < (N); X++)
#define PI (acos(-1.0))
#define pback push_back
#define mpair make_pair
#define divceil(A, B) ((A + (B - 1)) / B)
#define MODN 1000000007
#define ALL(V) (V).begin(),(V).end()
#define CERR if(false) cerr
using namespace std;
int main(){
int n,z,w;
cin >> n >> z >> w;
vector<int> a(1,w);
rep(i,n){
int tmp;
cin >> tmp;
a.pback(tmp);
}
vector<vector<int>> v(n + 1, vector<int>(n + 1, -1));
for(int i = n - 1; i >= 0; i--){
v[n][i] = abs(a[i] - a[n]);
}
for(int i = n - 1; i >= 1; i--){
v[i][n] = abs(a[i] - a[n]);
}
for(int k = n - 1; k >= 1; k--){
int tmpscore = INT_MAX;
for(int j = n; j > k; j--){
tmpscore = min(tmpscore, v[k][j]);
}
for(int j = k - 1; j >= 0; j--){
v[k][j] = tmpscore;
}
tmpscore = 0;
for(int i = n; i > k; i--){
tmpscore = max(tmpscore, v[i][k]);
}
for(int i = k - 1; i > 0; i--){
v[i][k] = tmpscore;
}
}
int ans = 0;
for(int i = n; i > 0; i--){
ans = max(ans, v[i][0]);
}
cout << ans << endl;
return 0;
}
| 0
| 50,349,001
|
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define sint int32_t
#define int long long int
#define all(v) v.begin() , v.end()
#define pb push_back
#define pii pair<int,int>
#define F first
#define S second
#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
int32_t main()
{ fastio;
int n;
cin>>n;
string s;
cin>>s;
vector<int>v;
for(int i=0; s[i]; i++) {
if(v.empty()) v.pb(s[i]);
else {
if(s[i] != v.back()) v.pb(s[i]);
}
}
cout<<v.size()<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
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.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifndef ONLINE_JUDGE
#define dbg(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define dbg(...) 42
#endif
#define mst(x, a) memset(x, a, sizeof(x))
using ll = long long;
using P = pair<int, int>;
using T = tuple<int, int, int>;
const int INF = 0x3f3f3f3f;
const ll LLINF = 0x3f3f3f3f3f3f3f3f;
const ll MOD = 1e9 + 7;
ll mul(ll a, ll b) { return a * b % MOD; }
ll add(ll a, ll b) { return (a + b) % MOD; }
ll sub(ll a, ll b) { return (a - b + MOD) % MOD; }
ll my_pow(ll a, ll b) {
ll r = 1;
while (b) {
if (b & 1) r = mul(r, a);
a = mul(a, a);
b >>= 1;
}
return r;
}
ll my_inv(ll a) { return my_pow(a, MOD - 2); }
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
ll N, K;
int main() {
cin >> N >> K;
vector<int> a(N);
for (int i = 0; i < N; i++) {
cin >> a[i];
}
ll ans = 0;
for (int i = 0; i < N; i++) {
ll x = 0;
for (int j = N - 1; j > i; j--) {
if (a[j] < a[i]) {
x++;
}
}
ans = add(ans, mul(x, K));
for (int j = i - 1; j >= 0; j--) {
if (a[j] < a[i]) {
x++;
}
}
ans = add(ans, mul(x, mul(K, mul(K - 1, (MOD + 1) / 2))));
}
cout << ans << endl;
}
| 0
| 88,016,946
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair< ll, ll > Pi;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep2(i,n) for(int i=1;i<=(n);i++)
#define rep3(i,i0,n) for(int i=i0;i<(n);i++)
#define pb push_back
#define mod 1000000007
const ll INF = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll a, ll b) {return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) {return a/gcd(a,b)*b;}
#define all(x) x.begin(), x.end()
#define mp make_pair
bool compare(Pi a, Pi b) {
if(a.first != b.first){
return a.first < b.first;
}else{
return a.second < b.second;
}
}
bool In_map(ll y,ll x,ll h,ll w){
if(y<0 || x<0 || y>=h || x>=w){
return 0;
}else{
return 1;
}
}
const vector<ll> dx{1,0,-1,0};
const vector<ll> dy{0,1,0,-1};
int main() {
ll X,Y,A,B,C;
cin >>X>>Y>>A>>B>>C;
vector<ll>p(A);
vector<ll>q(B);
vector<ll>r(C);
rep(i,A) cin>>p[i];
rep(i,B) cin>>q[i];
rep(i,C) cin>>r[i];
sort(all(p));
sort(all(q));
sort(all(r));
reverse(all(p));
reverse(all(q));
reverse(all(r));
ll cnta=0;
ll cntb=0;
ll cntc=0;
while(1){
if(cntc==C) break;
if(X-1-cnta>=0 && Y-1-cntb>=0){
if(p[X-1-cnta]<q[Y-1-cntb]){
if(p[X-1-cnta]<r[cntc]){
p[X-1-cnta] = r[cntc];
cnta++;
cntc++;
}else{
break;
}
}else{
if(q[Y-1-cntb]<r[cntc]){
q[Y-1-cntb] = r[cntc];
cntb++;
cntc++;
}else{
break;
}
}
}else if(X-1-cnta>=0){
if(p[X-1-cnta]<r[cntc]){
p[X-1-cnta] = r[cntc];
cnta++;
cntc++;
}else{
break;
}
}else if(Y-1-cntb>=0){
if(q[Y-1-cntb]<r[cntc]){
q[Y-1-cntb] = r[cntc];
cntb++;
cntc++;
}else{
break;
}
}else{
break;
}
}
ll ans=0;
rep(i,X){
ans+=p[i];
}
rep(i,Y){
ans+=q[i];
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define fi first
#define se second
using namespace std; typedef long long ll;
const int MAXN = 10 + 1e5;
const ll oo = 1 + 1e18, mod = 7 + 1e9;
int n, a[MAXN][5], f[MAXN][5];
int main(){
#define TASK "ABC"
#ifndef ONLINE_JUDGE
freopen(TASK".inp","r",stdin),freopen(TASK".out","w",stdout);
#endif ONLINE_JUDGE
ios_base::sync_with_stdio(0);
cin.tie(0),cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) for (int j = 1; j <= 3; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++){
for (int j = 1; j <= 3; j++){
for (int k = 1; k <= 3; k++){
if (j != k) f[i][j] = max (f[i][j], f[i - 1][k] + a[i][j]);
}
}
}
int ans = 0; for (int i = 1; i <= 3; i++) ans = max (ans, f[n][i]);
cout << ans;
return 0;
}
| 0
| 18,294,649
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define loop(__x, __start, __end) for(int __x = __start; __x < __end; __x++)
int main() {
int n; cin >> n;
vector<int> T(n), X(n), Y(n);
loop(i,0,n) cin >> T[i] >> X[i] >> Y[i];
int prev_t = 0, prev_x = 0, prev_y = 0;
loop(i,0,n) {
int t = T[i] - prev_t;
int x = abs(X[i]-prev_x);
int y = abs(Y[i]-prev_y);
if (x+y > t) {
cout << "No" << endl;
return 0;
}
if ((x+y)%2 != t%2) {
cout << "No" << endl;
return 0;
}
prev_t = T[i];
prev_x = X[i];
prev_y = Y[i];
}
cout << "Yes" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long Int;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n; cin >> n;
vector<int> v(n), l(n/2), r(n/2);
map<int, int> m_l, m_r;
rep(i, n) {
cin >> v[i];
if (i%2 == 0) {
m_l[v[i]]++;
}
else {
m_r[v[i]]++;
}
}
int l1 = 0, l2 = 0, r1=0, r2=0;
int cnt = 0;
for (auto l : m_l) {
if (l.second > cnt) {
cnt = l.second;
l1 = l.first;
}
}
cnt = 0;
for (auto l : m_l) {
if (l.first == l1) continue;
if (l.second > cnt) {
cnt = l.second;
l2 = l.first;
}
}
cnt = 0;
for (auto r : m_r) {
if (r.second > cnt) {
cnt = r.second;
r1 = r.first;
}
}
cnt = 0;
for (auto r : m_r) {
if (r.first == r1) continue;
if (r.second > cnt) {
cnt = r.second;
r2 = r.first;
}
}
if (r1 != l1) {
cout << (n/2-m_r[r1]) + (n/2 - m_l[l1]) << endl;
return 0;
}
cout << min(n/2-m_l[l1] + n/2-m_r[r2], n/2-m_l[l2] + n/2-m_r[r1])<< endl;
}
| 0
| 98,635,415
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
int ans=0,m=0,b;
for(int i=0;i<n;i++){
cin >> b;
if(b>=m)
ans++;
m=max(m,b);
}
cout << ans << 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 main(void){
int n;
cin>>n;
vector<ll> v(n+1);
rep(i, n+1){
cin>>v[i];
}
vector<pair<ll, ll> > minmax(n+1);
minmax[n] = make_pair(v[n], v[n]);
for(int i = n-1;i>=0;i--){
minmax[i] = make_pair((minmax[i+1].first+2-1)/2+v[i], minmax[i+1].second+v[i]);
}
if(!(minmax[0].first<=1 && minmax[0].second>=1)){
cout<<-1<<endl;
return 0;
}
ll now = 1;
ll ans = 1;
for(int i = 1;i<=n;i++){
now = min((now-v[i-1])*2, minmax[i].second);
ans += now;
}
cout<<ans<<endl;
return 0;
}
| 0
| 46,744,938
|
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#define pi 3.141592653589793238
#define int long long
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
long long power(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
int mm[100005];
int cnt[100005];
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
#ifndef ONLINE_JUDGE
if(fopen("INPUT.txt","r"))
{
freopen ("INPUT.txt" , "r" , stdin);
freopen ("OUTPUT.txt" , "w" , stdout);
}
#endif
int n;
cin>>n;
int a[n+1];
map<int,int>mm;
set<int>s;
for(int i=1;i<=n;i++)
{
cin>>a[i];
mm[i]=a[i];
if(a[i])
s.insert(i);
mm[i]=a[i];
}
int ans=0;
for(auto i:s)
{
int z=mm[i]+mm[i-1];
ans+=z/2;
mm[i]=z%2;
}
cout<<ans;
}
|
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <cmath>
#include <utility>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
const ll MOD = 1e9+7;
string s[600];
bool sym[600][600];
vector<P> v[2];
int main()
{
int n;
ll ans=0;
cin>>n;
for(int i=0;i<n;i++)
{
cin>>s[i];
s[i]=s[i]+s[i];
}
for(int i=n;i<2*n;i++)
s[i]=s[i-n];
fill(sym[0],sym[600],false);
if(n==1)
{
cout<<1<<endl;
return 0;
}
for(int i=0;i<2*n-2;i++)
{
for(int j=0;j<2*n-2;j++)
{
if(s[i][j+1]==s[i+1][j])
{
sym[i][j]=true;
v[0].push_back(P(i,j));
}
}
}
for(int a=3;a<n+1;a++)
{
v[a&1].clear();
for(int i=0;i<v[(a+1)&1].size();i++)
{
P p=v[(a+1)&1][i];
if(sym[p.first+1][p.second+1] &&(p.first+a<=2*n && p.second+a<=2*n)&&(s[p.first][p.second+a-1]==s[p.first+a-1][p.second]))
v[a&1].push_back(p);
else
sym[p.first][p.second]=false;
}
}
ans=v[n&1].size();
cout<<ans<<endl;
return 0;
}
| 0
| 90,269,926
|
#include<stdio.h>
int main()
{
int a,b,s;
scanf("%d%d",&a,&b);
s=a*b;
printf("%d\n",(s-(1*a+1*b)+1));
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned 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 (a>b) { a=b; return 1; } return 0; }
#define rep(i, n) REP(i, 0, n)
#define rep_rev(i, n) for (int (i) = (int)(n) - 1 ; (i) >= 0 ; --(i))
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for(int i = x; i < n; i++)
#define all(x) (x).begin(),(x).end()
ll t1,t2,t3;
const ll mod = 1000000007;
const int INF = 1e9;
const ll INFLONG = 1e18;
int main(){
ll n,k;
cin >> n >> k;
vector<ll> vec(k+1,0);
ll ans = 0;
for(ll i = k;i>0;i--){
ll mul = k / i;
ll t1 = n;
ll req = 1;
while(t1 != 0){
if(t1 & 1){
req *= mul;
req %= mod;
}
mul *= mul;
mul %= mod;
t1 = t1 >> 1;
}
t3 = req;
ll ward = i * 2;
while(ward <= k){
t3 -= vec[ward];
if(t3 < 0){
t3 += mod;
}
ward += i;
}
vec[i] = t3;
ans += t3 * i;
ans %= mod;
}
cout << ans << endl;
}
| 0
| 49,154,870
|
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define _CRT_SECURE_NO_WARNINGS
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
const int MOD = 1e9 + 7;
const int INF = 1e18 + 9;
constexpr long double pi = 3.141592653589793238462643383279;
int fact(int i) {
if (i == 0) return 1;
return (fact(i - 1)) * i;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
int keta(int n) {
if (n == 0) return 1;
int count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
int ketasum(int n) {
int sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
int main() {
int n, m; cin >> n >> m;
vector<int> broken(n + 2, false);
for (int i = 1; i <= m; i++) {
int a; cin >> a;
broken[a] = true;
}
vector<long long> dp(n + 2, 0);
dp[0] = 1;
if (!broken[1]) dp[1] = 1;
for (int i = 2; i <= n; i++) {
if (!broken[i]) {
dp[i] += dp[i - 1] + dp[i - 2];
dp[i] %= MOD;
}
}
cout << dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
cin.tie(0);
ios::sync_with_stdio(0);
int s;
cin>>s;
int cnt=1;
int n=s;
while(!(n==4||n==2||n==1))
{
if(n%2)n=3*n+1;
else n/=2;
cnt++;
}
cnt+=3;
cout<<cnt<<"\n";
return 0;
}
| 0
| 86,936,686
|
#include<iostream>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
cout<<(double)a/b;
return 0;
}
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<iomanip>
#include<map>
using namespace std;
int main(){
int n;
cin>>n;
vector<int>d(n),k(n);
map<int,int>values;
for(int i=0;i<n;i++){
cin>>d[i];
k[i]=d[i];
values[d[i]]++;
}
sort(d.begin(),d.end());
for(int i=0;i<n;i++){
if(values[d[n-1]]>1)cout<<d[n-1]<<endl;
else{
if(k[i]==d[n-1])cout<<d[n-2]<<endl;
else cout<<d[n-1]<<endl;
}
}
return 0;
}
| 0
| 85,896,784
|
#include <bits/stdc++.h>
using namespace std;
int main(){
while (1){
int n;
cin >> n;
if (n == 0){
break;
}
vector<string> f(n);
for (int i = 0; i < n; i++){
cin >> f[i];
}
int ans = 0;
for (int i = 0; i < n - 1; i++){
if (f[i][0] != f[i + 1][0] && f[i][1] == f[i + 1][1]){
ans++;
}
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, s, n) for (ll i = (ll)(s); i < (ll)(n); i++)
#define all(x) (x).begin(),(x).end()
const ll MOD = 1e9+7;
ll LLINF = 1LL << 60;
int INF = INT_MAX;
int main(){
ll a,b; cin>>a>>b; b++;
ll waru=2;
ll bit=0LL;
while(b/(waru/2)>0){
ll atemp=a/waru * (waru/2) + max(a%waru - waru/2,0LL);
ll btemp=b/waru * (waru/2) + max(b%waru - waru/2,0LL);
if((btemp-atemp)%2==1) bit=(bit | (1LL<<((int)log2(waru) -1 )));
waru*=2;
}
cout<<bit<<endl;
}
| 0
| 2,844,089
|
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long LL;
LL n,l,id = -1;
LL a[200005];
int main(){
ios::sync_with_stdio(false);
cin >> n >> l;
for(LL i = 1;i <= n;i ++) cin >> a[i];
for(LL i = 1;i < n;i ++) if(a[i] + a[i + 1] >= l) id = i;
if(id == -1) cout << "Impossible" << endl;
else{
cout << "Possible" << endl;
for(LL i = 1;i < id;i ++) cout << i << endl;
for(LL i = n - 1;i > id;i --) cout << i << endl;
cout << id << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll rec(ll n,ll x){
if (n == 0){
return 1;
}
ll sou = pow(2,n+1) -3;
ll pat = pow(2,n) -1;
if (x == 1){
return 0;
}
else if (x <= sou +1){
return rec(n-1,x-1);
}
else if (x == sou +2){
return pat +1;
}
else if (x <= (2*sou) +2){
return pat + 1 + rec(n-1,x-sou-2);
}
else{
return 2*pat +1;
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
ll n,x;
cin >> n >> x;
cout << rec(n,x) << endl;
}
| 0
| 80,351,787
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair< ll, ll > Pi;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep2(i,n) for(int i=1;i<=(n);i++)
#define rep3(i,i0,n) for(int i=i0;i<(n);i++)
#define pb push_back
#define mod 1000000007
const ll INF = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll a, ll b) {return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) {return a/gcd(a,b)*b;}
#define all(x) x.begin(), x.end()
#define mp make_pair
bool compare(Pi a, Pi b) {
if(a.first != b.first){
return a.first < b.first;
}else{
return a.second < b.second;
}
}
int ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
bool In_map(ll y,ll x,ll h,ll w){
if(y<0 || x<0 || y>=h || x>=w){
return 0;
}else{
return 1;
}
}
const vector<ll> dx{1,0,-1,0};
const vector<ll> dy{0,1,0,-1};
int main() {
ll A,B,K;
cin>>A>>B>>K;
ll ansa,ansb;
ansa = max(A-K,ll(0));
if(A<K){
ansb = max(A+B-K,ll(0));
}else{
ansb = B;
}
cout << ansa<<" "<<ansb<<endl;
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 <functional>
#include <ctime>
#include <cmath>
#include <limits>
#include <numeric>
#include <type_traits>
#include <iomanip>
#include <float.h>
#include <math.h>
using namespace std;
using ll = long long;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b) return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
ll ll_gcd(ll a, ll b) {
if (a < b) return ll_gcd(b, a);
ll r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
class UnionFind {
public:
vector <ll> par;
vector <ll> siz;
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
ll root(ll x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) {
return root(x) == root(y);
}
ll size(ll x) {
return siz[root(x)];
}
};
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;
}
long long modinv(long long a, long long mod) {
return modpow(a, mod - 2, mod);
}
int main() {
ll x,y,z,kk;
cin >> x >> y >> z >> kk;
vector<ll> xx(x);
vector<ll> yy(y);
vector<ll> zz(z);
for (int i = 0; i < x; i++) {
cin >> xx[i];
}
for (int i = 0; i < y; i++) {
cin >> yy[i];
}
for (int i = 0; i < z; i++) {
cin >> zz[i];
}
sort(xx.begin(), xx.end());
reverse(xx.begin(), xx.end());
sort(yy.begin(), yy.end());
reverse(yy.begin(), yy.end());
sort(zz.begin(), zz.end());
reverse(zz.begin(), zz.end());
vector<ll> ans(1000000);
ll now = 0;
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
for (int k = 0; k < z; k++) {
if ((i+1) * (j+1) * (k+1) > kk)break;
ans[now] = xx[i] + yy[j] + zz[k];
now++;
}
}
}
sort(ans.begin(), ans.end());
reverse(ans.begin(), ans.end());
for (int i = 0; i < kk; i++) {
cout << ans[i] << endl;
}
}
| 0
| 34,625,844
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n,y;cin>>n>>y;
y /= 1000;
for(int i=0;i<=n;i++) {
for(int j=0;j<=n-i;j++) {
int x = (i*10) + (j*5) + (n-i-j);
if(x == y) {
cout<<i<<" "<<j<<" "<<n-i-j<<"\n";
return 0;
}
}
}
cout <<"-1 -1 -1\n";
return 0;
}
|
#include <iostream>
#include <cstring>
#include<vector>
#include <algorithm>
using namespace std;
int main()
{
int h, n;
cin >> h >> n;
vector<int>a(n);
vector<int>b(n);
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
vector<vector<int>> dp(n + 1, vector<int>(h + 100100));
for (int i = 0; i < h + 100100; i++)
{
if (i % a[0] == 0)
{
dp[0][i] = (i / a[0]) * b[0];
}
else
{
dp[0][i] = (((i - i % a[0]) / a[0]) + 1) * b[0];
}
}
for (int i = 0; i < n; i++)
{
for (int d = 0; d <= h+100000; d++)
{
dp[i + 1][d] = dp[i][d];
if (a[i] <= d)
{
dp[i + 1][d] = min(dp[i][d], dp[i + 1][d - a[i]] + b[i]);
}
}
}
int ans = 100000000;
for (int i = h; i < h + 100000; i++)
{
if (ans > dp[n][i])
{
ans = dp[n][i];
}
}
cout << ans<< "\n";
return 0;
}
| 0
| 79,333,279
|
#include <bits/stdc++.h>
using namespace std;
int M;
int main() {
cin >> M;
long long total_n=0LL;
long long total_q=0LL;
for (int i=0;i<M;i++) {
long long d,c;cin >> d >> c;
total_n+=c;
total_q+=c*d;
}
cout << total_n-1L+(total_q-1L)/9L << endl;
}
|
#include <stdio.h>
int main(void)
{
int i,j;
int m,f,r,sum;
int a[100][3] ={0};
for(i=0;;i++){
scanf("%d %d %d",&m,&f,&r);
if(m == -1 && f == -1 && r == -1)
{
break;
}
else
{
a[i][0] = m;
a[i][1] = f;
a[i][2] = r;
}
}
for(j=0;j<i;j++){
m = a[j][0];
f = a[j][1];
r = a[j][2];
sum = m + f;
if(m == -1 || f == -1){
printf("F\n");
}
else if(sum >= 80){
printf("A\n");
}
else if(sum >= 65){
printf("B\n");
}
else if(sum >= 50){
printf("C\n");
}
else if(sum >= 30){
if(r >= 50){
printf("C\n");
}
else{
printf("D\n");
}
}
else{
printf("F\n");
}
}
return 0;
}
| 0
| 23,142,092
|
#include <bits/stdc++.h>
using namespace std;
#define intt long long
#define FAST ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
const int N = 100005;
int n;
int a[N];
int main() {
FAST;
int n, m;
cin >> n >> m;
if (n > m) swap(n, m);
if (n == 1 && m == 1) {
cout << 1 << '\n';
}
else if (n == 1 && m != 1) {
cout << m - 2 << '\n';
}
else {
cout << 1LL * (n - 2) * (m - 2) << '\n';
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define F first
#define S second
#define all(x) (x).begin(), (x).end()
#define allrev(x) (x).rbegin(), (x).rend()
#define pb push_back
#define pf push_front
#define fori(i, a, n) for(int i = a; i < n; ++i)
#define MAX(x) (*max_element(all(x)))
#define MIN(x) (*min_element(all(x)))
#define sortarr(a, n) sort(a, a + n)
#define sortvec(V) sort(all(V))
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);
}
};
typedef unordered_map<int, int, custom_hash> u_map;
typedef unordered_set<int, int, custom_hash> u_set;
typedef vector<int> V;
typedef pair<int , int> pairi;
typedef set<int> seti;
typedef priority_queue<int> p_queue;
typedef deque<int> deqi;
const int MOD = 1e9+7;
const int INF = 1e9+8;
const double pi = 3.14159265359;
int binpow(int a, int b, int m) {
a %= m;
int res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
void solve()
{
int N, R;
cin >> N >> R;
if(N >= 10) cout << R << endl;
else{
cout << R + 100 * (10 - N) << endl;
}
}
signed main()
{
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
solve();
cerr << "Time elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " sec \n ";
}
| 0
| 42,469,845
|
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=1e5+5;
const int INF=0x3f3f3f3f;
int flag[N];
LL Cnt[N];
int main() {
#ifndef ONLINE_JUDGE
freopen("in.txt","r",stdin);
#endif
ios::sync_with_stdio(false);
cin.tie(0);
LL n,x,mod;
cin>>n>>x>>mod;
for(int i=1; i<=n; ++i) {
int tmp=x%mod;
Cnt[i]=Cnt[i-1]+tmp;
if(flag[tmp]) {
int &pos=flag[tmp],len=i-pos;
cout<<Cnt[pos]
+(n-pos)/len*(Cnt[i]-Cnt[pos])
+Cnt[(n-pos)%len+pos]-Cnt[pos];
return 0;
}
flag[tmp]=i;
x=x*x%mod;
}
cout<<Cnt[n]<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define pb push_back
#define int long long
#define mp make_pair
#define inf 1000000007
#define LINF 6000000000000000007LL
#define ll long long
using namespace std;
signed main(){
int n,k;
cin>>n>>k;
vector< pair<int,int> > a;
for(int i=0;i<n;i++){
int x,y;
cin>>x>>y;
a.pb(mp(x,y));
}
sort( a.begin(), a.end() );
ll ans = LINF;
for(int i=0;i<=n-k;i++){
for(int j=i+k-1;j<n;j++){
int lx = a[j].first - a[i].first;
vector<int> ys;
for(int p=i;p<=j;p++){
ys.pb( a[p].second );
}
sort( ys.begin(),ys.end() );
int ly = LINF;
for(int p=0;p<=ys.size()-k;p++){
ly = min( ly, ys[p+k-1] - ys[p]);
}
ll tmp = lx * ly;
if( ans > tmp ) ans = tmp;
}
}
cout<<ans<<endl;
return 0;
}
| 0
| 83,843,250
|
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <cmath>
#include <set>
#include <map>
#include <queue>
using namespace std;
#define rep(i,n) for(int i = 0;i<n;i++)
const long long MOD = 1000000007LL;
const string alpha = "abcdefghijklmnopqrstuvwxyz";
int main(){
long long x,y;
cin >> x >> y;
if(x%y==0) cout << -1 << endl;
else cout << x << endl;
}
|
#include<iostream>
using namespace std;
int main(){
string s;
cin>>s;
int count1=0,count0=0;
for(int i=0;i<s.size();i++)
{
if(s[i]=='1'){
count1++;
}
else
{
count0++;
}
}
cout<<2*min(count1,count0);
}
| 0
| 50,382,215
|
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx,avx2,sse,sse2,ssse3,tune=native")
#include<bits/stdc++.h>
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define pb push_back
using namespace std;
using ll = long long;
using pi = pair<ll, ll>;
using vi = vector<ll>;
using vpi = vector<pi>;
using ld = long double;
const int maxn = 1<<12, mod = 998244353 , lg = 19;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vi a(n), b;
ll ans = 0, t = 0;
for(auto &i : a) cin >> i, t ^= i;
ans += t;
t = (1ll<<60) - 1 - t;
for(auto &i : a) {
i&=t;
for(auto j : b) i = min(i, i^j);
if(i) b.pb(i);
}
t = 0;
for(auto &i : b) t = max(t, t^i);
ans += t<<1;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s, t;
cin >> s >> t;
vector<int> count(26);
for (auto c : s)
{
count.at(c - 'a')++;
}
string sp = "";
for (char c = 'a'; c <= 'z'; c++)
{
for (int i = 0; i < count.at(c - 'a'); i++)
{
sp += c;
}
}
count = vector<int>(26);
for (auto c : t)
{
count.at(c - 'a')++;
}
string tp = "";
for (char c = 'z'; c >= 'a'; c--)
{
for (int i = 0; i < count.at(c - 'a'); i++)
{
tp += c;
}
}
cout << ((sp < tp) ? "Yes" : "No") << endl;
return 0;
}
| 0
| 29,995,497
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, r, n , m =0;
cin>>n>>m;
int mi= n;
int ma=-1;
for(int i=0; i<m ; i++){
cin>>l>>r;
if(ma < l)ma= l;
if(mi > r)mi=r;
}
cout<<max(mi-ma+1,0);
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
using namespace std;
int main(){
int k;
cin >> k;
vector<int> v(33);
v[1]=1;
v[2]=1;
v[3]=1;
v[4]=2;
v[5]=1;
v[6]=2;
v[7]=1;
v[8]=5;
v[9]=2;
v[10]=2;
v[11]=1;
v[12]=5;
v[13]=1;
v[14]=2;
v[15]=1;
v[16]=14;
v[17]=1;
v[18]=5;
v[19]=1;
v[20]=5;
v[21]=2;
v[22]=2;
v[23]=1;
v[24]=15;
v[25]=2;
v[26]=2;
v[27]=5;
v[28]=4;
v[29]=1;
v[30]=4;
v[31]=1;
v[32]=51;
cout << v[k] << endl;
}
| 0
| 71,242,129
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long int
#define INF 1000000007
#define llINF 1000000000000000007
#define v(i) vector<i>
#define vv(i) vector<vector<i>>
int keta(ll n){int ans=0;while(n>0){n /= 10; ans++;}return ans;}
ll _pow(ll a,ll b){ll ans = 1;rep(i,b){ ans *= a;}return ans;}
int main() {
int a,b; cin>>a>>b;
int ans=0;
for(int i = a; i <= b;i++){
if(i/10000 == i%10 && (i-(i/10000)*10000)/1000 == (i%100)/10 ) ans++;
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B;
cin >> N >> A >> B;
int cnt1 = 0, cnt2 = 0, cnt3 = 0;
for (int i = 0; i < N; ++i) {
int a;
cin >> a;
if (a <= A) {
cnt1++;
} else if (a <= B) {
cnt2++;
} else {
cnt3++;
}
}
cout << min({cnt1, cnt2, cnt3}) << endl;
return 0;
}
| 0
| 76,059,305
|
#include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define pb push_back
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ll long long
using namespace std;
const ll P = 1000000007;
int gcd(int a, int b) { return b != 0 ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int main()
{
cout << fixed << setprecision(10);
int N;
cin >> N;
if(N<1200)
{
cout << "ABC" << endl;
}
else if(N>=1200&&N<2800)
{
cout << "ARC" << endl;
}
else
{
cout << "AGC" << endl;
}
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <stack>
#include <queue>
#include <map>
#include <algorithm>
#include <iomanip>
#include <math.h>
#include <string.h>
using namespace std; using ll = long long; using pll = pair<ll, ll>;
using vl = vector<ll>; using vll = vector<vl>; using vpll = vector<pll>;
int ctoi(char c) {
switch (c) {
case '0': return 0; case '1': return 1; case '2': return 2;
case '3': return 3; case '4': return 4; case '5': return 5;
case '6': return 6; case '7': return 7; case '8': return 8;
case '9': return 9; default: return 0;
}
}
bool pairCompare(const pll firstElof, pll secondElof)
{
return firstElof.first > secondElof.first;
}
ll i, j, k, l; ll N, M, K, H, W, L, X, Y, Z;
ll MOD = 1000000007; ll INF = 9999999999999; ll ans = INF;
vl flag, color, D; vll path;
int main() {
string S;
cin >> S;
for (i = 0; i < 3; i++) {
if (S[i] == '1') S[i] = '9';
else S[i] = '1';
}
cout << S;
}
| 0
| 59,599,957
|
#include <iostream>
#include <string>
using namespace std;
bool used_H[100];
bool used_W[100];
int main(void){
int H,W;
cin >> H >> W;
string a[H];
for(int i=0;i<H;i++){
cin >> a[i];
}
int count = 0;
for(int i=0;i<H;i++){
count = 0;
for(int j=0;j<W;j++){
if(a[i][j] == '.'){
count++;
}
}
if(count == W){
used_H[i] = true;
}
}
for(int i=0;i<W;i++){
count = 0;
for(int j=0;j<H;j++){
if(a[j][i] == '.'){
count ++;
}
}
if(count == H){
used_W[i] = true;
}
}
for(int i=0;i<H;i++){
bool OK = false;
for(int j=0;j<W;j++){
if(!used_H[i] && !used_W[j]){
OK = true;
cout << a[i][j];
}
}
if(OK)cout << endl;
}
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
using ll = long long ;
using P = pair<int,int> ;
using pll = pair<long long,long long>;
constexpr int INF = 1e9;
constexpr long long LINF = 1e17;
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
#include <atcoder/all>
using namespace atcoder;
int main(){
int n,q;
cin >> n >> q;
dsu d(n);
rep(i,q){
int t,u,v;
cin >> t >> u >> v;
if(t==0){
d.merge(u,v);
}else{
cout << (d.same(u,v)?1:0) << endl;
}
}
}
| 0
| 10,233,657
|
#include <bits/stdc++.h>
#define PI acos(-1.0)
#define eps 1e-9
#define ll long long
#define ull unsigned long long
#define nl printf("\n")
#define sf scanf
#define pf printf
#define INF (ll)1e15
#define mod 1000000007
using namespace std;
const int S=223456;
int main()
{
#ifndef ONLINE_JUDGE
#endif
int n,k;
while(sf("%d %d",&n,&k)==2)
{
int ara[n+5];
int fre[S+5];
memset(fre,0,sizeof fre);
for(int i=0;i<n;i++)sf("%d",&ara[i]),fre[ara[i]]++;
sort(fre,fre+S);
reverse(fre,fre+S);
int sum=0;
for(int i=0;i<k;i++)
{
sum+=fre[i];
}
pf("%d\n",n-sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long lint;
typedef long long llint;
bool compPair(const pair<int, int>& arg1, const pair<int, int>& arg2) { return arg1.first > arg2.first; }
template<class T> void chmax(T& a, T b) { if (a < b) { a = b; } }
template<class T> void chmin(T& a, T b) { if (a > b) { a = b; } }
int main(void) {
llint n, k;
cin >> n >> k;
if(k%2==1) {
llint kbai, ans;
kbai = n/k;
ans = kbai*kbai*kbai;
cout << ans << endl;
}
else {
llint kbai, ans, kmod;
kbai = n/k;
ans = kbai*kbai*kbai;
kmod=0;
for(llint in=1;in<=n;in++) {
if(in%k==(k/2)) kmod++;
}
ans += kmod*kmod*kmod;
cout << ans << endl;
}
return 0;
}
| 0
| 93,542,325
|
#include <algorithm>
#include <iostream>
using namespace std;
int n, m, v, p;
bool check(int *a, int i) {
if (a[i] + m < a[n-p]) return false;
else if (v <= i+p) return true;
long long amt = (long long)m * (v - (i + p));
for (int j = i+1; j <= n-p; j++) {
if (a[i] + m < a[j]) return false;
amt -= a[i] + m - a[j];
if (amt <= 0) return true;
}
return false;
}
int main() {
cin >> n >> m >> v >> p;
int a[n]; for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a+n);
int lb = -1, ub = n-p;
while (ub - lb > 1) {
int i = (ub + lb) / 2;
if (check(a, i)) ub = i;
else lb = i;
}
cout << n-ub << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,d,r;
cin>>n>>d;
int a[n][d];
for(int i=0;i<n;i++)
{
for(int j=0;j<d;j++)
{
cin>>a[i][j];
}
}
int ans=0;
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
int sum=0;
for(int k=0;k<d;k++)
{
sum+=pow(a[i][k]-a[j][k],2);
}
r=sqrt(sum);
if(r*r==sum)
{
ans++;
}
}
}
cout<<ans<<endl;
exit(0);
}
| 0
| 4,141,590
|
#include<bits/stdc++.h>
using namespace std;
int main(void){
int A, B, C;
int ans;
cin >> A >> B >> C;
if(A == B)
ans = C;
if(A == C)
ans = B;
if(B == C)
ans = A;
cout << ans << "\n";
return 0;
}
|
#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;
ll k;
cin >> s >> k;
int n = s.size();
int oneLen = 0;
rep (i, n)
if (s[i] == '1')
oneLen++;
else
break;
cout << (k > oneLen ? s[oneLen] : '1') << endl;
return 0;
}
| 0
| 16,858,325
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i < (n); i++)
#define lower(s) transform(s.begin(), s.end(), s.begin(), ::tolower)
using namespace std;
using ll = long long;
int INF = 1001001001;
int main() {
int n;
cin >> n;
vector<int>a(n);
vector<int>p(n);
vector<int>q(n);
rep(i, n) cin >> p[i];
rep(i, n) cin >> q[i];
rep(i, n) a[i]=i+1;
map<vector<int>,int> mp;
int i = 0;
do {
mp[a] = ++i;
}
while(next_permutation(a.begin(), a.end()));
cout << abs(mp[p]-mp[q]) << endl;
return 0;
}
|
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <memory.h>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <algorithm>
#include <functional>
#include <utility>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstdio>
using namespace std;
#define REP(i,n) for(int (i)=0; i<(int)(n); i++)
const int MAXN = 100010;
long long a[MAXN],b[MAXN];
int main(void) {
int N;
long long ans = 0,poor = 0;
cin >> N;
REP(i,N) cin >> a[i];
REP(i,N) cin >> b[i];
priority_queue <int> q;
REP(i,N)
if(a[i] < b[i]) {
poor += abs(a[i]-b[i]);
ans++;
}
else q.push(abs(a[i]-b[i]));
while(!q.empty() && poor > 0) {
poor -= q.top();
q.pop();
ans++;
}
if(poor > 0) cout << -1 << endl;
else cout << ans << endl;
return 0;
}
| 0
| 32,050,310
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<pair<int,int>> vpii;
#define F first
#define S second
#define PU push
#define PUF push_front
#define PUB push_back
#define PO pop
#define POF pop_front
#define POB pop_back
#define REP(i,a,b) for(int i=a; i<=b; i++)
#define MOD 1000000007
void solve(int test_case) {
int n;
cin>>n;
unordered_map<int,int> a,b;
bool flag = true;
REP(i,1,n) {
int val;
cin>>val;
if(flag)a[val]++;
else b[val]++;
flag=!flag;
}
int a1=0,a1v=0,a2=0;
int b1=0,b1v=0,b2=0;
for(auto p:a) {
if(p.S>=a1) {
a2=max(a2,a1);
a1=p.S;
a1v=p.F;
} else {
a2=max(a2,p.S);
}
}
for(auto p:b) {
if(p.S>=b1) {
b2=max(b1,b2);
b1=p.S;
b1v=p.F;
} else {
b2=max(b2,p.S);
}
}
if(a1v==b1v) {
cout<<min(max(0,n-b1-a2),max(0,n-a1-b2));
} else {
cout<<n-a1-b1;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t=1;
REP(i,1,t) {
solve(i);
}
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<utility>
#include<map>
#include<set>
#include <sstream>
#include<queue>
#include<stack>
#include<functional>
#include<math.h>
#include <iomanip>
#include <regex>
#include <initializer_list>
#include <deque>
#define DBL_MIN 0.000000000000001
#include <iostream>
using namespace std;
int main(void){
long K,S;
cin >> K >> S;
int cnt = 0;
for(int i =0; i <= K ;i++){
for(int j = 0; j <= (S- i) && j <= K ; j++){
if( (S-i-j) <= K){
cnt++;
}
}
}
cout << cnt << endl;
return 0;
}
| 0
| 85,012,393
|
#include "bits/stdc++.h"
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<int>X(N);
vector<int>Y(N);
for (int i = 0; i < N; ++i) {
cin >> X[i] >> Y[i];
}
vector<int>copyX = X;
vector<int>copyY = Y;
sort(copyX.begin(),copyX.end());
sort(copyY.begin(),copyY.end());
long long ans = (long long)4 * 1e18;
for (int i = 0;i<N;++i) {
for (int j = i + 1;j<N;++j) {
for (int l = 0;l<N;++l) {
for (int m = l + 1; m < N; ++m) {
int count = 0;
for (int n = 0;n<N;++n) {
if ((X[n]>=copyX[i])&&(X[n]<=copyX[j])&&(Y[n]>=copyY[l])&&(Y[n]<=copyY[m])) {
count++;
}
}
if (count >= K) {
ans = min(ans, (long long)(copyX[j] - copyX[i])*(long long)(copyY[m] - copyY[l]));
}
}
}
}
}
cout << ans <<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
int64_t sum=0;
int64_t line=0;
int64_t amount;
int64_t Ans=0;
int flag=0;
cin>>N;
vector<int64_t> A(N+1);
for(int i=0;i<N+1;i++){
cin>>A.at(i);
sum+=A.at(i);
}
vector<vector<int64_t>> value(N+1,vector<int64_t>(3,0));
if(sum==1){
Ans=N+1;
}else if(A.at(0)==1||N==0&&sum>1){
Ans=-1;
}else{
Ans=1;
value.at(0).at(2)=1;
for(int i=0;i<N;i++){
sum-=A.at(i+1);
line=value.at(i).at(1)+value.at(i).at(2)*2;
Ans+=line;
amount=line-A.at(i+1);
if(amount<0){
flag=1;
Ans=-1;
break;
}
if(amount*2<=sum){
if(amount==0&&sum!=0){
flag=1;
break;
}
value.at(i+1).at(2)=amount;
}else if(amount<=sum){
value.at(i+1).at(2)=sum-amount;
value.at(i+1).at(1)=amount*2-sum;
}else{
flag=1;
Ans=-1;
break;
}
}
if(flag==1){
Ans=-1;
}
}
cout<<Ans<<endl;
}
| 0
| 2,467,121
|
#include <iostream>
#include <cmath>
#include <climits>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;
#pragma warning(disable: 4996)
#define _sort(v,type,order) do { sort(v.begin(),v.end(),order<type>()); } while(0)
#define _sum(v,default_value) accumulate(v.begin(),v.end(),default_value )
#define _round(v) round(v)
#define _square(v) pow(v,2)
#define _cube(v) pow(v,3)
int main()
{
int n, k, x, y;
cin >> n >> k >> x >> y;
int result = n * x - ((n > k) ? (n-k)*(x-y):0);
printf("%d\n", result);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Unionfind {
vector<int> par;
Unionfind(int n = 1) : par(n, -1) {}
int root(int x) {
if (par[x] < 0) return x;
return par[x] = root(par[x]);
}
bool issame(int x, int y) { return root(x) == root(y); }
bool uni(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return 0;
if (par[x] > par[y]) swap(x, y);
par[x] += par[y];
par[y] = x;
return 1;
}
int size(int x) { return -par[root(x)]; }
};
int main() {
int n, q;
cin >> n >> q;
Unionfind uf(n);
while (q--) {
int t, u, v;
cin >> t >> u >> v;
if (t)
cout << uf.issame(u, v) << endl;
else
uf.uni(u, v);
}
return 0;
}
| 0
| 74,853,404
|
#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <string>
#include <cmath>
#include <algorithm>
using namespace std;
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define BIT(X, i) ((X>>i)&1)
#define REP(i, a, b) for(int i = (a); i < (b); ++i)
#define rep(i, n) for(int i = 0; i < (n); ++i)
#define all(a) (a).begin(), (a).end()
#define r_all(a) (a).rbegin(), (a).rend()
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<ll, ll> pii;
typedef vector<pii> vii;
typedef priority_queue<ll> pq;
const int MOD = 1e9+7;
const int INF = (1<<30);
const ll INFL = (1L<<62);
int main() {
int N; cin >> N;
int M = 2, sum = 1;
bool ok = false;
while (sum <= N) {
if (sum == N) {
ok = true;
break;
}
sum += M++;
}
if (!ok) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
vvi ans(M);
int ini = 1;
rep(i, M) {
rep(j, M-1-i) {
ans[i].pb(ini+j);
ans[i+1+j].pb(ini+j);
}
ini += M-1-i;
}
cout << M << endl;
rep(i, M) {
cout << M-1;
rep(j, M-1) {
printf(" %ld", ans[i][j]);
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define repd(i,a,b) for (int i=(a);i<(b);i++)
#define rep(i,n) repd(i,0,n)
#define all(x) (x).begin(),(x).end()
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; }
typedef long long ll;
const long long INF = 1LL << 60;
typedef pair<int, int> P;
int main()
{
int N;
cin >> N;
vector<int> A(N), B(N);
rep(i, N) {
cin >> A[i];
B[i] = A[i];
}
sort(all(B));
reverse(all(B));
rep(i, N) {
if (A[i] == B[0]) cout << B[1] << endl;
else cout << B[0] << endl;
}
return 0;
}
| 0
| 64,578,537
|
#include <bits/stdc++.h>
using namespace std;
int main(){int n,a,b,c,x,y,z,p,q,r; cin>>n>>a>>b>>c; p=a,q=b,r=c,n--; while(n--){cin>>x>>y>>z; a=x+max(q,r),b=y+max(r,p),c=z+max(p,q),p=a,q=b,r=c;}; cout<<max({a,b,c});}
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
int main()
{
static long i,j,k,l;
long n;
long cnt = 0;
long left,right,mid;
long ans = 0;
int a,b;
static int H[10000];
static int W[10000];
for(i = 0;; i++) {
scanf("%d %d",&H[i],&W[i]);
if(H[i] == 0)
break;
}
for(j = 0; j < i; j++) {
for(k = 0; k < H[j]; k++) {
for(l = 0; l < W[j]; l++) {
putchar('#');
}
putchar('\n');
}
putchar('\n');
}
return 0;
}
| 0
| 45,175,081
|
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
int main() {
int x, n;
cin >> x >> n;
if (n == 0) {
cout << x << endl;
} else {
vector<int> p(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
}
int closest, minAbs;
minAbs = 1000;
for (int i = 0; i <= 101; i++) {
if (find(p.begin(), p.end(), i) == p.end()) {
if (abs(x - i) < minAbs) {
closest = i;
minAbs = abs(x - i);
}
}
}
cout << closest << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define fin ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define ii pair<int,int>
#define F first
#define S second
#define pb push_back
#define pf push_front
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define fore(i,a,b) for(int i = a;i < b; i+= 1)
#define forr(i,a) for(int i = a; i >= 0; i--)
#define fori(i,m) for(auto i = m.begin(); i != m.end(); i++)
#define w(t) while(t--)
#define sz(s) int(s.size())
#define cls(a,car) memset(a,car,sizeof (a))
#define what_is(x) cerr << #x << " is " << x << endl;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ii> vii;
const int N = 1 * 1e5 + 5;
const ll mod = 1e9 + 7;
const int INF = INT_MAX;
const ll INFCAD = ll(INT_MAX) * 2 + 1;
const double E = 1e-9;
int main(){
fin;
int n, k;
cin >> n >> k;
int idx;
fore(i, 0, n){
int x;cin >> x;
if(x == 1)
idx = i + 1;
}
if(n == k){
cout << 1 << '\n';
}
else{
n--;k--;
cout << n / k + (n % k != 0) << '\n';
}
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
return 0;
}
| 0
| 14,063,492
|
#include<bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define se second
#define fi first
#define ll long long
#define INF INT_MAX
#define mod 1000000007
#define chutiyaap ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
using namespace std;
ll pw(ll a, ll b) {
if (b == 0) return 1;
ll t = pw(a, b / 2);
if (b % 2 == 0) return (t * t)%mod;
else return ((t * t)%mod * a)%mod;
}
int main()
{
int a,b;cin>>a>>b;
if(a*b==2)cout<<3;
else if(a*b==6)cout<<1;
else cout<<2;
}
|
#include<iostream>
#include<vector>
using namespace std;
class Dice{
vector<int> x;
void advance_vertical(){
advance(0, 1, 5, 4);
}
void advance_horizontal(){
advance(0, 3, 5, 2);
}
void advance_rotation(){
advance(1, 2, 4, 3);
}
void advance(int i, int j, int k, int l){
int tmp = x[i];
x[i] = x[j];
x[j] = x[k];
x[k] = x[l];
x[l] = tmp;
}
public:
Dice(vector<int>& x) : x(x) {}
void roll(const string& command){
for(const auto c : command){
if(c == 'E'){
advance_horizontal();
}
else if(c == 'N'){
advance_vertical();
}
else if(c == 'S'){
for(int i = 0; i < 3; ++i){
advance_vertical();
}
}
else{
for(int i = 0; i < 3; ++i){
advance_horizontal();
}
}
}
}
int getNow(){
return x[0];
}
int getRightSide(int top_side, int front){
for(int i = 0; i < 6; i++){
for(int j = 0; j < 4; j++){
if(x[0] == front && x[4] == top_side){
return x[2];
}
advance_rotation();
}
if(i % 2 == 0){
advance_vertical();
}
else{
advance_horizontal();
}
}
return 0;
}
};
int main(){
vector<int> x(6);
for(int i = 0; i < 6; ++i){
cin >> x[i];
}
Dice dice(x);
int q;
cin >> q;
for(int i = 0; i < q; ++i){
int top_side, front;
cin >> top_side >> front;
cout << dice.getRightSide(top_side, front) << endl;
}
return 0;
}
| 0
| 27,237,031
|
#define _GLIBCXX_DEBUG
#define MIN_MAX 1200001
#include <iostream>
#include <vector>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
int main(void){
int n, m, x;
cin >> n >> m >> x;
vi C(n);
vvi A(n, vi(m));
for(int i=0; i<n; i++){
cin >> C[i];
for(int &a : A[i]) cin >> a;
}
int min = MIN_MAX;
for(int bit=0; bit<1<<n; bit++){
int sumC = 0;
vi sumA(m);
for(int i=0; i<n; i++)if(bit & 1<<i){
sumC += C[i];
for(int j=0; j<m; j++) sumA[j] += A[i][j];
}
bool suc = true;
for(int &a : sumA)if(a<x){suc = false; break;}
if(suc && sumC < min) min = sumC;
}
if(min < MIN_MAX) cout << min << '\n';
else cout << -1 << '\n';
return 0;
}
|
#include<queue>
#include<string>
#include<iostream>
using namespace std;
int main(){
string cmd;
priority_queue<int> Q;
while(cin>>cmd&&cmd!="end"){
if(cmd=="insert"){
int m;
cin>>m;
Q.push(m);
}
else if (cmd=="extract"){
int n=Q.top();
Q.pop();
cout<<n<<endl;
}
}
return 0;
}
| 0
| 35,165,261
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
int main() {
ll N,M;
cin >> N >>M;
vector<ll> X(N);
for(int i=0;i<M;i++){
ll a,b;
cin >> a >>b;
--a;--b;
if(a!=0){
X[a]++;
}
if(b!=0){
X[b]++;
}
}
for(int i=0;i<N;i++){
if(X[i]%2!=0){
cout <<"NO" << endl;
return 0;
}
}
cout<<"YES"<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int,int>;
using Graph = vector<vector<int>>;
int main(void) {
int n, k;
cin >> n >> k;
vector<ll> a(n);
rep(i, n)
cin >> a[i];
ll ans = 1e18;
for(int bit = 0; bit < (1 << n); ++bit) {
vector<ll> tmpa(a);
vector<int> seebull = {0};
for(int i = 1; i < n; ++i) {
if(bit & ( 1 << i)) {
seebull.push_back(i);
}
}
if((int)seebull.size() != k) continue;
ll sum = 0;
for(int i = 0; i < k; ++i) {
int tmpbull = seebull[i];
ll maxheight = 0;
for(int j = 0; j < tmpbull; ++j) {
maxheight = max(maxheight, tmpa[j]);
}
ll add = 0;
if(maxheight >= tmpa[tmpbull]) {
add = maxheight - tmpa[tmpbull] + 1;
tmpa[tmpbull] += add;
}
sum += add;
}
ans = min(sum, ans);
}
cout << ans << endl;
return 0;
}
| 0
| 44,861,489
|
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;
vector<int> v;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
long long a=0,b,c,d=0,e=0,f=0,g=0,i;
string s;
for(int n=0;n<4;n++){
cin >>s[n];
if(s[n]=='1') d++;
if(s[n]=='9') e++;
if(s[n]=='7') f++;
if(s[n]=='4') g++;
}
if(d>0&&e>0&&f>0&&g>0) cout <<"YES\n";
else cout <<"NO\n";
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
#define INCANT cin.tie(0), cout.tie(0), ios::sync_with_stdio(false), cout << fixed << setprecision(20);
#define int long long
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define _overload(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for(int i = (int)(a); i < (int)(b); i++)
#define rep(...) _overload(__VA_ARGS__, repi, _rep)(__VA_ARGS__)
#define _rev(i, n) revi(i, n, 0)
#define revi(i, a, b) for(int i = (int)(a - 1); i >= (int)(b); i--)
#define rev(...) _overload(__VA_ARGS__, revi, _rev)(__VA_ARGS__)
#define each(i, n) for(auto&& i: n)
void in(){}
template<typename F, typename... R>
bool in(F& f, R&... r){
if(cin >> f){in(r...);return true;}
else return false;
}
#define out(x) cout << (x)
#define space() cout << " "
#define indent() cout << '\n'
void print(){}
template<typename F, typename... R>
void print(F f, R... r){out(f), indent(), print(r...);}
#define debughead(x) cerr << "Line " << __LINE__ << ": " << #x << ": "
#define debugout(x) cerr << (x) << " "
#define debugindent() cerr << '\n'
#define debug(x) debughead(x), debugout(x), debugindent()
const int INF = 1e18, MOD = 1e9 + 7;
template<typename T>
bool chmax(T& a, T b){return (a = max(a, b)) == b;}
template<typename T>
bool chmin(T& a, T b){return (a = min(a, b)) == b;}
main(){
INCANT;
int n, k, tmp, tmp2, res = -INF;
string s;
in(n, k);
int a[n + 1] = {}, sum[n + 1] = {}, psum[n + 1] = {};
rep(i, 1, n + 1){
in(a[i]);
sum[i] = sum[i - 1] + a[i];
psum[i] = psum[i - 1] + max(0LL, a[i]);
}
rep(i, k, n + 1){
tmp = sum[i] - sum[i - k];
tmp2 = psum[n] - psum[i] + psum[i - k];
chmax(res, max(0LL, tmp) + tmp2);
}
print(res);
}
| 0
| 93,476,889
|
#include <bits/stdc++.h>
#include <iostream>
#include <math.h>
#include <algorithm>
#include <ctime>
#define ll long long
#define vecvec(h, w, name) vector<vector<ll>> name(h, vector<ll>(w));
#define rep(init, i, n) for (ll i = init; i < (n); i++)
#define rev(s) reverse(s.begin(), s.end())
#define sor(v) sort(v.begin(), v.end())
#define PI 3.14159265358979323846264338327950L
using namespace std;
using vec = vector<ll>;
ll facctorialMethod(ll k);
ll modpow(ll a, ll n, ll mod);
ll gcd(ll a, ll b);
ll lcm(ll a, ll b);
struct UnionFind
{
vector<ll> d;
UnionFind(ll n = 0) : d(n, -1) {}
ll find(ll x)
{
if (d[x] < 0)
return x;
return d[x] = find(d[x]);
}
bool unite(ll x, ll y)
{
x = find(x);
y = find(y);
if (x == y)
return false;
if (d[x] > d[y])
swap(x, y);
d[x] += d[y];
d[y] = x;
return true;
}
bool same(ll x, ll y) { return find(x) == find(y); }
ll size(ll x) { return -d[find(x)]; }
};
int main()
{
int clock_on = 0;
int time_clock = clock();
ll N;
cin>>N;
vector<ll> a(N);
vector<ll> v(100000+2,0);
rep(0,i,N){cin>>a.at(i);}
rep(0,i,N){
if(a.at(i)!=0){
++v.at(a.at(i)-1);}
++v.at(a.at(i));
++v.at(a.at(i)+1);
}
sor(v);
cout<<v.at(v.size()-1)<<endl;
if (clock_on == 1)
printf("Execution Time: %.4lf sec\n", 1.0 * (clock() - time_clock) / CLOCKS_PER_SEC);
return 0;
}
ll facctorialMethod(ll k)
{
ll sum = 1;
for (ll i = 1; i <= k; ++i)
{
sum *= i;
}
return sum;
}
ll modpow(ll a, ll n, ll mod)
{
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 (a % b == 0)
{
return b;
}
else
{
return gcd(b, a % b);
}
}
ll lcm(ll a, ll b)
{
return a * b / gcd(a, b);
}
|
#include <bits/stdc++.h>
#define DAU ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define PLEC exit(0);
using namespace std;
#define int long long
int n, a[100005], res, p, x;
main() {
DAU
cin >> n;
++n;
for (int i = 1; i <= n; ++i)
cin >> a[i];
for (int i = 1; i < n; ++i) {
cin >> x;
if (a[i] >= x)
res += x;
else {
res += a[i];
x -= a[i];
p = min(x, a[i+1]);
res += p;
a[i+1] -= p;
}
}
cout << res;
PLEC
}
| 0
| 81,377,113
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
if (str[0] != 'A') {
cout << "WA" << endl;
return 0;
}
int index;
int flag = 0;
for (int i = 2; i < str.size() - 1; i++) {
if (str[i] == 'C') {
flag = 1;
index = i;
}
}
int up = 0;
for (int i = 1; i < str.size(); i++) {
if (i == index) {
continue;
}
if (isupper(str[i])) {
up = 1;
}
}
if (up == 0 && flag == 1) {
cout << "AC" << endl;
} else {
cout << "WA" << endl;
}
return 0;
}
|
#include <stdio.h>
#include <math.h>
struct dot{
double x;
double y;
};
void koch(struct dot d1, struct dot d2, int n){
if(n == 0){
return;
}
struct dot s;
s.x = d1.x * 2 / 3 + d2.x * 1 / 3;
s.y = d1.y * 2 / 3 + d2.y * 1 / 3;
struct dot t;
t.x = d1.x * 1 / 3 + d2.x * 2 / 3;
t.y = d1.y * 1 / 3 + d2.y * 2 / 3;
struct dot u;
u.x = ((d2.x - d1.x) - sqrt(3) * (d2.y - d1.y)) / 6 + d1.x * 2 / 3 + d2.x * 1 / 3;
u.y = (sqrt(3) * (d2.x - d1.x) + (d2.y - d1.y)) / 6 + d1.y * 2 / 3 + d2.y * 1 / 3;
koch(d1, s, n - 1);
printf("%.8f %.8f\n", s.x, s.y);
koch(s, u, n - 1);
printf("%.8f %.8f\n", u.x, u.y);
koch(u, t, n - 1);
printf("%.8f %.8f\n", t.x, t.y);
koch(t, d2, n - 1);
}
int main(void){
int N;
scanf("%d", &N);
struct dot p1;
p1.x = 0.0;
p1.y = 0.0;
struct dot p2;
p2.x = 100.0;
p2.y = 0.0;
printf("%.8f %.8f\n", p1.x, p1.y);
koch(p1, p2, N);
printf("%.8f %.8f\n", p2.x, p2.y);
return 0;
}
| 0
| 4,016,920
|
#include <bits/stdc++.h>
using namespace std;
#define N 100005
int d[N], n, cnt[N], mx;
const int mod = 998244353;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i ++) {
scanf("%d", &d[i]);
cnt[d[i]] ++;
mx = max(mx, d[i]);
}
if (d[1] != 0) return puts("0"), 0;
for (int i = mx; i >= 0; i --) if (cnt[i] == 0) return puts("0"), 0;
if (cnt[0] > 1) return puts("0"), 0;
int ans = 1;
for (int i = 1; i <= n; i ++) {
int k = d[i];
if (k>0) ans = 1ll * ans * cnt[k-1] % mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define int ll
#define REP(i,n) for (int i = 0; i < (n); ++i)
#define FORE(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define ALL(vec) (vec).begin(), (vec).end()
#define REVALL(vec) (vec).rbegin(), (vec).rend()
#define debug(x) cerr << #x << ": " << x << '\n'
#define hyphen() cerr << "--\n"
#define fst first
#define pb push_back
const int MOD = (int)1e9 + 7;
int bigger(int a, int b) {
return a >= b ? a : b;
}
int smaller(int a, int b) {
return a >= b ? b : a;
}
signed main() {
int N;
cin >> N;
vector<int> As(N);
vector<int> Bs(N);
REP(i, N) {
cin >> As.at(i) >> Bs.at(i);
}
vector<tuple<int, int, int>> sorted_for_a(N);
vector<tuple<int, int, int>> sorted_for_b(N);
REP(i, N) {
int a = As.at(i);
int b = Bs.at(i);
int priority = a + b;
tuple<int, int, int> ta = make_tuple(priority, a, i);
tuple<int, int, int> tb = make_tuple(priority, b, i);
sorted_for_a.pb(ta);
sorted_for_b.pb(tb);
}
sort(REVALL(sorted_for_a));
sort(REVALL(sorted_for_b));
queue<tuple<int, int, int>> a_queue;
for (auto a : sorted_for_a) {
a_queue.push(a);
}
queue<tuple<int, int, int>> b_queue;
for (auto b : sorted_for_b) {
b_queue.push(b);
}
vector<bool> eaten(N, false);
int score_a = 0;
int score_b = 0;
tuple<int,int,int> ta;
tuple<int,int,int> tb;
while(!a_queue.empty() || !b_queue.empty()) {
while(true) {
if (a_queue.empty()) {
break;
}
ta = a_queue.front();
a_queue.pop();
int& ind = get<2>(ta);
if (!eaten.at(ind)) {
break;
}
}
if (a_queue.empty()) {
break;
}
int& a = get<1>(ta);
int& ind_a = get<2>(ta);
debug(a);
debug(ind_a);
score_a += a;
debug(ind_a);
eaten.at(ind_a) = true;
while(true) {
if (b_queue.empty()) {
break;
}
tb = b_queue.front();
b_queue.pop();
int& ind = get<2>(tb);
if (!eaten.at(ind)) {
break;
}
}
if (b_queue.empty()) {
break;
}
int& b = get<1>(tb);
int& ind_b = get<2>(tb);
debug(b);
debug(ind_b);
score_b += b;
debug(ind_b);
eaten.at(ind_b) = true;
}
cout << score_a - score_b << endl;
}
| 0
| 93,003,451
|
#include <bits/stdc++.h>
#define pb push_back
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,n,s) for(int i=(s);i<(n);i++)
#define rrep(i,n) for(int i=(n-1);i>=0;i--)
#define rreps(i,n,s) for(int i=s;i>=n;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 (a>b) { a=b; return 1; } return 0; }
using ll = long long;
using namespace std;
constexpr long long MAX = 5100000;
constexpr long long INF = 1LL << 60;
constexpr int MOD = 1000000007;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n,a,b;
cin>>n>>a>>b;
if(a>b){
cout<<0<<endl;
}
else if(a==b){
cout<<1<<endl;
}
else{
if(n-2>=0){
cout<<b*(n-2)-a*(n-2)+1<<endl;
}
else{
cout<<0<<endl;
}
}
return 0;
}
|
#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(){
int n, m;
cin >> n >> m;
priority_queue<ll> pq;
rep(i, n){
ll x;
cin >> x;
pq.push(x);
}
rep(i, m){
ll top = pq.top();
pq.pop();
top /= 2;
pq.push(top);
}
ll sum = 0;
rep(i, n){
sum += pq.top();
pq.pop();
}
cout << sum << endl;
return 0;
}
| 0
| 40,767,121
|
#include <iostream>
#include <cstdlib>
using namespace std;
int main()
{
int i,j;
for (i=0 ,j=1;i<10000 ; i++)
{cin>>j;
if(j==0) break;
cout <<"Case "<<i+1<<": "<<j<<endl;}
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define repp(i,n,m) for (int i = m; i < (n); ++i)
#define repl(i,n) for (long long i = 0; i < (n); ++i)
#define reppl(i,n,m) for (long long i = m; i < (n); ++i)
using namespace std;
using ll = long long;
const int MOD = 1000000007;
int main(){
int n;
string s;
cin >> n >> s;
vector<int> alp(26);
rep(i,n){
char c = s.at(i);
if (c == 'a') alp[0]++;
else if (c == 'b') alp[1]++;
else if (c == 'c') alp[2]++;
else if (c == 'd') alp[3]++;
else if (c == 'e') alp[4]++;
else if (c == 'f') alp[5]++;
else if (c == 'g') alp[6]++;
else if (c == 'h') alp[7]++;
else if (c == 'i') alp[8]++;
else if (c == 'j') alp[9]++;
else if (c == 'k') alp[10]++;
else if (c == 'l') alp[11]++;
else if (c == 'm') alp[12]++;
else if (c == 'n') alp[13]++;
else if (c == 'o') alp[14]++;
else if (c == 'p') alp[15]++;
else if (c == 'q') alp[16]++;
else if (c == 'r') alp[17]++;
else if (c == 's') alp[18]++;
else if (c == 't') alp[19]++;
else if (c == 'u') alp[20]++;
else if (c == 'v') alp[21]++;
else if (c == 'w') alp[22]++;
else if (c == 'x') alp[23]++;
else if (c == 'y') alp[24]++;
else if (c == 'z') alp[25]++;
}
ll ans = 1;
rep(i,26){
ans *= (alp[i] + 1);
ans %= MOD;
}
ans--;
ans %= MOD;
cout << ans << endl;
}
| 0
| 47,156,955
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll ;
typedef double db;
const double pi = 3.141592654;
#define pb push_back
#define forab(i,a,b) for(int i=(a);i<=(b);i++)
#define CIN ios_base::sync_with_stdio(0); cin.tie(0)
#define pcase(z,x) printf("Case %ld: %lld\n",z,x)
#define nw "\n"
int main(void)
{
CIN;
ll tc,l,k,sum=0,x=0,y,z=0,m=1,n=0,ans=0,cnt=0;
cin>>n;
ll arr[n];ll lala[n];
for(auto &i:arr){
cin>>i;
lala[x++]=i;
}
sort(arr,arr+n);
for(ll i=0;i<n;i++){
if(arr[n-1]==lala[i])cout<<arr[n-2]<<nw;
else cout<<arr[n-1]<<nw;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define INF 1 << 30
#define N 101
int main(void){
int n,m[N][N],tmp[N];
cin >> n;
for(int i = 1 ; i <= n ; i++){
cin >> tmp[i-1] >> tmp[i];
}
for(int i = 1 ; i <= n ; i++){
m[i][i] = 0;
}
for(int j = 2; j<= n ; j++){
for(int i = 1; i <= n- j + 1; i++){
int k = i + j -1;
m[i][k] = INF;
for(int l = i; l <= k - 1 ; l++){
m[i][k] = min(m[i][k],m[i][l] + m[l+1][k]+tmp[i-1] * tmp[l] * tmp[k]);
}
}
}
cout << m[1][n] << endl;
}
| 0
| 97,232,710
|
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
int A[2000001];
int B[2000001];
long C[10001];
long n;
void CountingSort(int k){
memset(C, 0, sizeof(C));
for (long j = 0; j < n; ++j) ++C[A[j]];
for (long i = 1; i <= k; ++i) C[i] += C[i - 1];
for (long j = n - 1; j >= 0; --j){
B[C[A[j]]] = A[j];
--C[A[j]];
}
}
int main(){
scanf("%ld", &n);
int MAX = -1;
for (long i = 0; i < n; ++i) scanf("%d", &A[i]);
for (long i = 0; i < n; ++i){
MAX = max(MAX, A[i]);
}
CountingSort(MAX);
for (long i = 1; i <= n; ++i){
if (i != 1) cout << ' ';
cout << B[i];
}
cout << '\n';
}
|
#include<algorithm>
#include<iostream>
#include<cstdio>
using namespace std;
int n;
int d[50][50];
void floryd()
{
for(int k=0;k<=n;k++)
{
for(int i=0;i<=n;i++)
{
for(int j=0;j<=n;j++)
{
d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
}
}
}
}
int w,ma;
int main()
{
while(scanf("%d",&w)&&w)
{
for(int i=0;i<=46;i++)
{
for(int j=0;j<=46;j++)
{
d[i][j]=0x3f3f3f3f;
}
}
ma=-1;
int a,b,c;
for(int i=0;i<w;i++)
{
scanf("%d%d%d",&a,&b,&c);
ma=max(max(a,b),ma);
d[a][b]=d[b][a]=c;
}
n=ma;
int q,s;
floryd();
int mi=0x3f3f3f3f;
for(int i=0;i<=ma;i++)
{
s=0;
for(int j=0;j<=ma;j++)
{
if(i!=j)
{
s=s+d[i][j];
}
}
if(s<mi)
{
mi=s;
q=i;
}
}
printf("%d %d\n",q,mi);
}
return 0;
}
| 0
| 14,305,040
|
#include<iostream>
#include<algorithm>
#include<string.h>
#include<math.h>
#include<bits/stdc++.h>
#define ll long long
#define IOS ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define mod 1000000009
using namespace std;
bool isprime(ll n)
{
if(n==1)
return true;
if(n==2 || n==3)
return true;
if(n%2==0)return false;
for(ll i=3;i*i<=n;i+=2)
{
if(n%i==0)
return false;
}
return true;
}
int gcd(ll a,ll b)
{
if(a==0)
return b;
return gcd(b%a,a);
}
int lcm(ll a,ll b)
{
return a*(b/gcd(a,b));
}
set<ll> fac;
void allFactors(ll n)
{
for(ll i=1;i<=sqrt(n);i++)
{
if(n%i==0)
{
fac.insert(i);
if(i!=n/i)
{
fac.insert(n/i);
}
}
}
}
bool threefactors(ll n)
{
ll p=sqrt(n);
if(p*p==n)
{
if(isprime(p))
return 1;
else
return 0;
}
else
return 0;
}
unsigned int countSetBits(unsigned int n)
{
unsigned int count = 0;
while (n) {
count += n & 1;
n >>= 1;
}
return count;
}
int main()
{
IOS
int testcases;
{
int n;
cin>>n;
int k;
cin>>k;
int h[n];
for(int i=0;i<n;i++)
{
cin>>h[i];
}
ll dp[n];
for(int i=0;i<n;i++)
{
dp[i]=mod;
}
dp[0]=0;
for(int i=0;i<n;i++)
{
for(int j=i+1;j<=i+k;j++)
{
if(j<n)
{
dp[j]=min(dp[j],dp[i]+abs(h[i]-h[j]));
}
}
}
cout<<dp[n-1];
}
return 0;
}
|
#include<iostream>
#include<vector>
#include<string>
#include<bitset>
#include<algorithm>
#include<map>
#include<queue>
#include<cmath>
#include<set>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int main() {
int h, w,m;
cin >> h >> w >> m;
vector<int> H(h),W(w);
set<pair<int, int>> data;
int temp0, temp1;
int max_h = 0, max_w = 0;
rep(i, m) {
cin >> temp0;
temp0--;
H[temp0]++;
if (H[temp0] > max_h) {
max_h = H[temp0];
}
cin >> temp1;
temp1--;
W[temp1]++;
if (W[temp1] > max_w) {
max_w = W[temp1];
}
data.insert({ temp0,temp1 });
}
vector<int> H_max, W_max;
for (int i = 0; i < h; i++) {
if (H[i] == max_h)
H_max.push_back(i);
}
for (int i = 0; i < w; i++) {
if (W[i] == max_w)
W_max.push_back(i);
}
rep(i,H_max.size()){
rep(j, W_max.size()) {
if (data.count({H_max[i],W_max[j] }))
continue;
else {
cout << max_h + max_w << endl;
return 0;
}
}
}
cout << max_h + max_w - 1 << endl;
return 0;
}
| 0
| 23,574,876
|
#include<bits/stdc++.h>
#define ll long long
#define ljc 998244353
using namespace std;
#define gc getchar
inline ll read(){
register ll x=0,f=1;char ch=gc();
while (!isdigit(ch)){if (ch=='-') f=-1;ch=gc();}
while (isdigit(ch)){x=(x<<3)+(x<<1)+ch-'0';ch=gc();}
return (f==1)?x:-x;
}
vector<int> e[1010101];
int n,sg[1010101],u,v;
void dfs(int u,int faa){
sg[u]=0;
for (auto v:e[u]){
if (v==faa) continue;
dfs(v,u);
sg[u]^=sg[v]+1;
}
}
int main(){
n=read();
for (int i=1;i<n;++i){
int u=read(),v=read();
e[u].push_back(v);
e[v].push_back(u);
}
dfs(1,0);
puts(sg[1]?"Alice":"Bob");
}
|
#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 k, a, b;
cin >> k >> a >> b;
if(b - a <= 1){
cout << k + 1 << endl;
}else{
if(k<=a){
cout << k + 1 << endl;
}else{
k -= (a - 1);
if(k%2){
cout << a + (b - a) * (k / 2) + 1 << endl;
}else{
cout << a + (b - a) * (k / 2) << endl;
}
}
}
return 0;
}
| 0
| 33,338,434
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
#define repr(i, n) for(int i = n; i >= 0; i--)
#define reprl(i, n) for(ll i = n; i >= 0; i--)
#define all(v) v.begin(), v.end()
const ll mod=1000000007;
int countBits(int in){
int res=0;
for(int i=0;i<10;i++){
int msk=1<<i;
if((in&msk)!=0){
res++;
}
}
return res;
}
template<typename T>
void show2dVector(vector<vector<T>>& v){
for(int i=0;i<v.size();i++){
int m=v[i].size();
cout<<i<<" : ";
for(int j=0;i<m;i++){
cout<<v[i][j]<<" ";
}
cout<<endl;
}
}
void bfs(const vector<vector<int>>&g, int v, vector<bool>& seen){
seen[v]=true;
cout<<v<<" ";
for(auto next: g[v]){
if(seen[next]){
continue;
}
bfs(g,next,seen);
}
}
bool dfs(vector<vector<int>> &g,int start,int goal,vector<bool>&seen){
bool res=false;
seen[start]=true;
if(start==goal){
return true;
}
for(auto next: g[start]){
if(seen[next]){
continue;
}
res=dfs(g,next,goal,seen);
if(res){
break;
}
}
return res;
}
ll gcd(ll a,ll b) {
return b? gcd(b,a%b): a;
}
ll lcm(ll a,ll b) {
return a*b/gcd(a,b);
}
bool isLowerCase(char c){
return (c>='a'&&c<='z');
}
const string outputYesNo(bool ans){
return (ans?"Yes":"No");
}
int main() {
int x;cin>>x;
string ans;
if(x<1200)ans="ABC";
else ans="ARC";
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
typedef long long ll;
typedef pair<ll,ll> ii;
typedef vector<int> vi;
typedef long double ld;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
const long long mod = 1000000007;
const long long inf = 1e18;
int main(){
ios_base::sync_with_stdio(0); cin.tie(0);
int n;
cin>>n;
int a;
cin>>a;
n=n%500;
if(n>a)
cout<<"No"<<endl;
else
cout<<"Yes"<<endl;
return 0;
}
| 0
| 39,265,187
|
#include<bits/stdc++.h>
#define ll long long
#define fixed cout.setf(ios::fixed);
#define Precise cout.precision(7);
using namespace std;
int main()
{
ll n,k,i;
string s,t;
cin>>s>>t;
cout<<t+s<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define PI 3.1415926535897
using namespace std;
typedef long long ll;
const int INF = 1000000000;
const ll LINF = 1000000000000000000;
const double EPS = 1e-10;
int main(void)
{
ll N, M;
cin >> N >> M;
ll ans;
if (N == 1 && M == 1)
{
ans = 1;
}
else if (N >= 2 && M >= 2)
{
ans = (N - 2) * (M - 2);
}
else if (N >= 2)
{
ans = N - 2;
}
else if (M >= 2)
{
ans = M - 2;
}
cout << ans << endl;
}
| 0
| 76,745,328
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
if((a*500)>=b){
cout<<"Yes"<<endl;
}
else{
cout<<"No"<<endl;
}
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() {
ll N, M;
cin >> N >> M;
vector<int> k(M), s(M, 0);
rep(i, M) {
cin >> k[i];
rep(j, k[i]) {
int tmp;
cin >> tmp;
--tmp;
s[i] |= (1 << tmp);
}
}
vector<int> p(M);
rep(i, M) cin >> p[i];
int ans = 0;
for (int bit = 0; bit < (1 << N); ++bit) {
int ok = 1;
rep(i, M) {
ok ^= (__builtin_popcount(bit & s[i]) % 2 ^ p[i]);
if (!ok) break;
}
if (ok) ++ans;
}
cout << ans << endl;
}
| 0
| 22,549,786
|
#include <bits/stdc++.h>
#define f first
#define s second
#define pb push_back
#define ENDL '\n'
#define all(a) begin(a),end(a)
#define sz(a) (int)(a.size())
#define deb(a) cout << #a << ": " << a << ENDL
#define fore(i, a, b) for(int i(a), ThkMk(b); i < ThkMk; ++i)
#define _ ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
typedef long long lli;
typedef long double ld;
typedef pair<lli, lli> ii;
const int MAXN = 1e5 + 5;
lli dp[2][MAXN];
lli MOD = 1e9 + 7;
vector<vector<lli>> graph;
lli n;
lli dfs(int u, int pr, int color) {
lli &ans = dp[color][u];
if(ans != -1) return ans;
ans = 1;
for(auto it : graph[u]) {
if(it == pr) continue;
lli cur = dfs(it, u, 0);
if(color == 0) cur = (cur + dfs(it, u, 1)) % MOD;
ans = (ans * cur) % MOD;
}
return ans;
}
int main()
{ _
fore(i, 0, 2) fore(j, 0, MAXN) dp[i][j] = -1;
lli u, v; cin >> n;
graph.resize(n);
fore(i, 1, n) {
cin >> u >> v;
graph[u - 1].pb(v - 1);
graph[v - 1].pb(u - 1);
}
cout << (dfs(0, -1, 0) + dfs(0, -1, 1)) % MOD << ENDL;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> l_l;
typedef pair<int , int> i_i;
typedef vector<ll> vl;
typedef vector<int> vi;
typedef vector<char> vec;
typedef vector<bool> veb;
typedef vector<string> ves;
typedef vector<vector<ll>> vvl;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvec;
typedef vector<vector<bool>> vveb;
typedef vector<vector<string>> vves;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep1(i,n) for(int i=1;i<(int)(n);i++)
#define rep2(i,n) for(int i=2;i<(int)(n);i++)
#define repk(i,k,n) for(int i=k;i<(int)(n);i++)
#define fs first
#define sc second
#define pb push_back
#define pp pop_back
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define maxel(a) *max_element(all(a))
#define minel(a) *min_element(all(a))
#define acc accumulate
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define mod (1000000007)
typedef long long int64;
#define dame { puts("-1"); return 0;}
#define YES { cout << "YES" << endl; return 0; }
#define NO { cout << "NO" << endl; return 0; }
#define Yes { cout << "Yes" << endl; return 0; }
#define No { cout << "No" << endl; return 0; }
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; }
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
char b;
cin >> b;
if(b=='A')cout << 'T' <<endl;
else if(b == 'T')cout << 'A' <<endl;
else if(b == 'C')cout << 'G' <<endl;
else cout << 'C' <<endl;
return 0;
}
| 0
| 35,455,915
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
cin >> n;
if(n < 105){
cout << 0 << endl;
return 0;
}
int r = 0;
for(int i = 105;i <= n;i += 2){
int cnt = 0;
for(int j = 1;j * j < i;j++){
if(i % j == 0){
cnt++;
if(i / j != j){
cnt++;
}
}
}
if(cnt == 8){
r++;
}
}
cout << r << endl;
return 0;
}
|
#include <iostream>
#include <map>
#include <set>
#include <algorithm>
#include <vector>
#include <sstream>
#include <string>
#include <functional>
#include <queue>
#include <deque>
#include <stack>
#include <limits>
#include <unordered_map>
#include <unordered_set>
#include <math.h>
#include <fstream>
#include <iterator>
#include <random>
#include <chrono>
#define forr(i,start,count) for (int i = (start); i < (start)+(count); ++i)
#define set_map_includes(set, elt) (set.find((elt)) != set.end())
#define readint(i) int i; cin >> i
#define readll(i) ll i; cin >> i
#define readdouble(i) double i; cin >> i
#define readstring(s) string s; cin >> s
typedef long long ll;
using namespace std;
ll modd = 1000*1000*1000+7;
ll binary_search(function<bool(ll)> func, ll start, ll end) {
if (end <= start) { return end; }
if (!func(end-1)) { return end; }
while (end-start>1) {
ll mid = (start+end)/2;
if (func(mid)) { end = mid; } else { start = mid; }
}
if (func(start)) { return start; } else { return end; }
};
template<class T>
T fastpower(T a, long long n) {
if (n==0) {return 1;}
if (n % 2 == 0) {
T halfpower = fastpower<T>(a, n/2);
return (halfpower*halfpower) % modd;
} else {
if (n == 1) { return a; } else {
T halfpower = fastpower<T>(a, n/2);
return (((halfpower*halfpower)%modd)*a)%modd;
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cout.precision(17);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<int> rand_gen(0, modd);
int test_cases = 1;
forr(t, 1, test_cases) {
readint(n); readstring(s);
map<char,int> freq;
for(char c : s) {
freq[c]++;
}
ll ret = 1;
for(auto x : freq) {
ret *= (1+x.second);
ret = ret % modd;
}
cout << ret-1 << endl;
}
return 0;
}
| 0
| 89,566,027
|
#include <algorithm>
#include <cmath>
#include <climits>
#include <functional>
#include <iostream>
#include <queue>
#include <string>
#include <numeric>
#include <vector>
using namespace std;
using ll = long long;
template<typename T> void print(T t) {cout << t << endl;}
int main() {
int H, W;
cin >> H >> W;
vector<vector<char>> board(H+2, vector<char>(W+2, '.'));
for (int h = 1; h <= H; h++) {
for (int w = 1; w <= W; w++) {
cin >> board[h][w];
}
}
for (int h = 1; h <= H; h++) {
for (int w = 1; w <= W; w++) {
if (board[h][w] == '#') {
bool ok = false;
if (board[h + 1][w] == '#') ok = true;
if (board[h - 1][w] == '#') ok = true;
if (board[h][w + 1] == '#') ok = true;
if (board[h][w - 1] == '#') ok = true;
if (!ok) {
print("No");
return 0;
}
}
}
}
print("Yes");
}
|
#include <bits/stdc++.h>
#include <string.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define mod 1000000007
#define pi 3.1415926535
typedef long long ll;
int main(){
int H,W;
cin>>H>>W;
vector<vector<char>>C(H,vector<char>(W));
rep(i,H){
rep(j,W){
cin>>C[i][j];
}
}
rep(i,H){
rep(k,2){
rep(j,W){
cout<<C[i][j];
}
cout<<endl;
}
}
return 0;
}
| 0
| 65,033,824
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define all(n) begin(n),end(n)
using ll = long long;
using P = pair<int,int>;
int main() {
int n;
cin >> n;
int ans = n*800 - (n/15)*200;
cout << ans << endl;
return 0;
}
|
#define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
#pragma comment (linker, "/STACK:526000000")
using namespace std;
typedef string::const_iterator State;
#define eps 1e-11L
#define MAX_MOD 1000000007LL
#define GYAKU 500000004LL
#define MOD 998244353LL
#define seg_size 262144*2LL
#define pb push_back
#define mp make_pair
typedef long long ll;
#define REP(a,b) for(long long (a) = 0;(a) < (b);++(a))
#define ALL(x) (x).begin(),(x).end()
unsigned long xor128() {
static unsigned long x = 123456789, y = 362436069, z = 521288629, w = time(NULL);
unsigned long t = (x ^ (x << 11));
x = y; y = z; z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
void init() {
iostream::sync_with_stdio(false);
cout << fixed << setprecision(10);
}
#define int ll
void solve() {
while (true) {
string s = "qazwsxedcrfvtgb";
string a;
cin >> a;
if (a == "#") return;
int now = -1;
int go = -1;
REP(q, a.length()) {
int ok = 0;
REP(j, s.length()) {
if (s[j] == a[q]) ok = 1;
}
if (go != ok) {
go = ok;
now++;
}
}
cout << now << endl;
}
}
#undef int
int main() {
init();
solve();
}
| 0
| 30,315,840
|
#include <iostream>
#include <vector>
#include <algorithm>
#define rep(i, n) for(int i = 0; i < (int)(n); ++i)
#define REP(i, n) for(int i = 1; i < (int)(n); ++i)
using namespace std;
int main() {
string S;
cin >> S;
if (S.size() < 4) {
cout << "No" << endl;
return 0;
}
if (S[0] == 'Y' && S[1] == 'A' && S[2] == 'K' && S[3] == 'I') cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
string S;
string T;
cin >> S >> T;
if(S.size() < T.size()) {
cout << "UNRESTORABLE" << endl;
return 0;
}
vector<string>ans;
bool flag = false;
for(int i = 0; i <= S.size()-T.size(); i++) {
bool ok = true;
int X = i;
for(int j = 0; j < T.size(); j++) {
if(S[X+j] != '?' && T[j] != S[X+j]) {
ok = false;
break;
}
}
if(ok) {
flag = true;
string cnt = "";
for(int k = 0; k < S.size(); k++) {
if(k == X) {
cnt+=T;
k+=T.size()-1;
}
else {
if(S[k] == '?') {
cnt+='a';
}
else {
cnt+=S[k];
}
}
}
ans.push_back(cnt);
}
}
if(flag) {
sort(ans.begin(),ans.end());
cout << ans[0] << endl;
}
else {
cout << "UNRESTORABLE" << endl;
}
}
| 0
| 99,278,080
|
#include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
using Grid= vector<vector<char>>;
using vin= vector<int>;
using ll=long long;
using vll= vector<ll>;
using vbl=vector<bool>;
using vch=vector<char>;
using pinin=pair<int ,int>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rell(i,n) for (ll i=0; i< (ll)(n); i++)
#define sort(x) sort(x.begin(), x.end());
#define rese(x) reverse(x.begin(), x.end());
string yes="Yes",no="No";
int main() {
int h,w,m;
cin>>h>>w>>m;
set<pinin> s;
vin hm(h),wm(w);
rep(i,m){
pinin hw;
cin>>hw.first>>hw.second;
hw.first--; hw.second--;
s.insert(hw);
hm[hw.first]++;
wm[hw.second]++;
}
set<int> hma,wma;
int hmax=0,wmax=0;
rep(i,h){
hmax=max(hmax,hm[i]);
}
rep(i,w){
wmax=max(wmax,wm[i]);
}
rep(i,h){
if(hmax==hm[i]) hma.insert(i);
}
rep(i,w){
if(wmax==wm[i]) wma.insert(i);
}
int ans=hmax+wmax-1;
bool fin=false;
for(int x:hma){
for(int y:wma){
pinin xy;
xy.first=x;
xy.second=y;
if(!s.count(xy)){
ans=hmax+wmax;
break;
fin=true;
}
}
if(fin) break;
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
ll n,a[105],sum,ans;
int main(void){
cin>>n;
for(int i=0;i<n;i++){
cin>>a[i];
sum+=a[i];
}
if(sum%n>=(n+1)/2){
sum=sum/n+1;
}else{
sum=sum/n;
}
for(int i=0;i<n;i++){
ans+=((a[i]-sum)*(a[i]-sum));
}
cout<<ans<<endl;
}
| 0
| 34,464,151
|
#include <iostream>
#include <cstdio>
using namespace std;
int main(){
int a, b;
int sum;
while(1){
int pattern=0;
cin>>a>>b;
if(a==0&&b==0) break;
for(int i=0;i<a;i++){
for(int j=i+1;j<a;j++){
for(int k=j+1;k<a;k++){
if((i+j+k+3)==b){
pattern++;
}
}
}
}
cout<<pattern<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define ll long long
#define li long
#define pb push_back
#define mem(arr,x) memset(arr,x,sizeof(arr))
ll a[101],n;
ll dp[101][100001];
ll totalWays(ll start,ll k)
{
if(k==0) return 1;
if(start<0) return 0;
if(dp[start][k]!=0) return dp[start][k];
ll i,ans=0;
for(i=0;i<=min(a[start],k);i++)
{
if(k-i>=0)
ans=(ans%MOD+totalWays(start-1,k-i)%MOD)%MOD;
}
return dp[start][k]=ans%MOD;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll k,i,j,l;
cin>>n>>k;
for(i=0;i<n;i++)
cin>>a[i];
mem(dp,0);
dp[0][0]=1;
for(i=1;i<=k;i++) dp[0][i]+=dp[0][i-1];
for(i=1;i<=n;i++)
{
for(j=0;j<=k;j++)
{
if(j-a[i-1]>0)
dp[i][j]=(dp[i-1][j]%MOD-dp[i-1][j-a[i-1]-1]%MOD+MOD)%MOD;
else
dp[i][j]=dp[i-1][j]%MOD;
}
for(j=1;j<=k;j++)
{
dp[i][j]+=dp[i][j-1];
dp[i][j]%=MOD;
}
}
cout<<(dp[n][k]-dp[n][k-1]+MOD)%MOD;
return 0;
}
| 0
| 64,892,421
|
#include <iostream>
using namespace std;
struct Card{char suit,value;};
void show_array(struct Card a[],int n){
for(int i=0;i<n;i++){
if(i>0) cout << " ";
cout << a[i].suit << a[i].value;
}
cout << endl;
}
void BubbleSort(struct Card a[],int n){
for(int i=0;i<n;i++){
for(int j=n-1;j>i;j--){
if(a[j].value<a[j-1].value){
struct Card temp=a[j];
a[j]=a[j-1];
a[j-1]=temp;
}
}
}
}
void SelectionSort(struct Card a[],int n){
for(int i=0;i<n;i++){
int index=0;
int minv=a[i].value;
for(int j=i+1;j<n;j++){
if(a[j].value<minv){
minv=a[j].value;
index=j;
}
}
if(i<index){
struct Card temp;
temp=a[i];
a[i]=a[index];
a[index]=temp;
}
}
}
int main(){
int n;
cin >> n;
struct Card cards1[n],cards2[n];
for(int i=0;i<n;i++) {
cin >> cards1[i].suit;
cin >> cards1[i].value;
cards2[i].suit=cards1[i].suit;
cards2[i].value=cards1[i].value;
}
BubbleSort(cards1,n);
show_array(cards1,n);
cout << "Stable" << endl;
SelectionSort(cards2,n);
show_array(cards2,n);
bool flag=true;
for(int i=0;i<n;i++){
if(cards1[i].suit != cards2[i].suit) flag=false;
}
if(flag) cout << "Stable" << endl;
else cout << "Not stable" << endl;
return 0;
}
|
#include <cstdio>
#define MAX_N (10010)
using namespace std;
int par[MAX_N];
int rank[MAX_N];
int root( int x ) {
if ( par[x] == x ) return par[x];
else return par[x] = root( par[x] );
}
void unite( int x, int y ) {
int r_x = root(x);
int r_y = root(y);
par[r_y] = par[r_x];
}
bool isSame( int x, int y ) {
return root(x) == root(y);
}
int main()
{
int n, q;
scanf("%d %d", &n, &q);
for ( int i = 0; i < n; i++ ) {
par[i] = i;
rank[i] = i;
}
for ( int i = 0; i < q; i++ ) {
int c, x, y;
scanf("%d %d %d", &c, &x, &y);
if ( c == 0 ) {
unite( x, y );
}
else {
printf("%d\n", isSame( x, y ) ? 1 : 0);
}
}
return 0;
}
| 0
| 7,040,798
|
#include<bits/stdc++.h>
#define rep(i,j,n) for(int i=(int)(j);i<(int)(n);i++)
#define REP(i,j,n) for(int i=(int)(j);i<=(int)(n);i++)
#define per(i,j,n) for(int i=(int)(j);(int)(n)<=i;i--)
#define ll long long
#define ALL(a) (a).begin(),(a).end()
#define disup(A,key) distance(A.begin(),upper_bound(ALL(A),(ll)(key)))
#define dislow(A,key) distance(A.begin(),lower_bound(ALL(A),(ll)(key)))
#define pb push_back
#define mp make_pair
#define endl "\n"
using std::cin;
using std::cout;
using std::vector;
using std::pair;
using std::string;
using std::upper_bound;
using std::lower_bound;
using vi=vector<ll>;
using vii=vector<vi>;
using pii=pair<ll,ll>;
const ll MOD=1e9+7;
const int MAX=1e5+1;
const ll INF=(1ll<<62)-1;
signed main(){
int N,L,Q; cin>>N;
vi Point(N);
rep(i,0,N) cin>>Point[i];
vii dp(N,vi (60));
Point.pb(INF);
cin>>L>>Q;
rep(i,0,N){
dp[i][0]=disup(Point,Point[i]+L)-1;
}
rep(i,1,60){
rep(j,0,N){
dp[j][i]=dp[dp[j][i-1]][i-1];
}
}
rep(_,0,Q){
int Start,Goal; cin>>Start>>Goal;
if(Start>Goal) std::swap(Start,Goal);
int ans=0;
Start--;
Goal--;
while(1){
int Dist=dislow(dp[Start],Goal);
if(Dist==0){
ans++;
break;
}
Start=dp[Start][Dist-1];
ans+=(1ll<<(Dist-1));
}
cout<<ans<<endl;
}
}
|
#include <iostream>
using namespace std;
int main(){
int n;
cin >> n;
for(int i = 1;i<=n ;i++){
double x[5];
double y[5];
for(int j= 1;j<=4;j++) {
cin >> x[j];
cin >> y[j];
}
if ((y[2]-y[1])*(x[4]-x[3])==(y[4]-y[3])*(x[2]-x[1])) cout << "YES" << endl;
else cout << "NO" << endl;
}
return 0;
}
| 0
| 83,192,190
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define repA(i,n) for(int i=n; i>=0; i--)
#define all(x) x.begin(),x.end()
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define sz(a) (ll)(a.size())
typedef long long ll;
typedef long double ld;
const ll mod = 998244353;
void solve() {
int n,k; cin>>n>>k;
vector<int> a(n);
rep(i,n) cin>>a[i];
while(k--) {
vector<int> b(n+1,0);
rep(i,n) {
int from = max(0,i-a[i]);
int to = min(n-1,i+a[i]);
b[from]++;
b[to+1]--;
}
bool changed = false;
rep(i,n) {
changed |= (a[i]!=b[i]);
a[i] = b[i];
b[i+1] += b[i];
}
if(!changed) break;
}
rep(i,n) cout<<a[i]<<' ';
cout<<'\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
#endif
ll t = 1;
rep(i,t) {
solve();
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <set>
using i64 = long long;
int main() {
int h, w, m;
std::cin >> h >> w >> m;
std::vector<int> rows(h);
std::vector<std::vector<int>> bs(w);
for (int i = 0; i < m; i++) {
int p, q;
std::cin >> p >> q;
--p; --q;
rows[p]++;
bs[q].push_back(p);
}
std::multiset<int> s;
for (const int e : rows) s.insert(e);
int ret = 0;
for (int i = 0; i < w; i++) {
const int base = bs[i].size();
for (const int x : bs[i]) {
const int t = base + rows[x] - 1;
if (t > ret) ret = t;
s.erase(s.find(rows[x]));
}
if (!s.empty()) {
const int t = base + *s.rbegin();
if (t > ret) ret = t;
}
for (const int x : bs[i]) s.insert(rows[x]);
}
std::cout << ret << std::endl;
return 0;
}
| 0
| 3,682,897
|
#include<iostream>
#include<cmath>
using namespace std;
#define EPS 1e-10
double x[4],y[4];
double det(){
double x1,x2,y1,y2;
x1 = x[0] - x[1];
y1 = y[0] - y[1];
x2 = x[2] - x[3];
y2 = y[2] - y[3];
return x1 * y2 - y1 * x2;
}
int main(void){
int n;
cin >> n;
while(n--){
for(int i = 0 ; i < 4 ; i ++)cin>>x[i]>>y[i];
cout<<(fabs(det())<EPS?"YES":"NO")<<endl;
}
return 0;
}
|
#include <stdio.h>
#include <algorithm>
#include <iostream>
using namespace std;
class Heap{
public:
Heap(){
array = new int[2000000];
n = 0;
}
void insert(int data){
array[n] = data;
int tmp = n;
while(tmp != 0 && array[tmp] > array[(tmp-1)/2]){
std::swap(array[tmp], array[(tmp-1)/2]);
tmp = (tmp-1)/2;
}
n++;
}
void max_heapify(int* array, int start, int end)
{
int dad = start;
int son = dad * 2 + 1;
while (son <= end)
{
if (array[son] < array[son+1] && son+1 <= end)
son++;
if (array[dad] > array[son])
return;
else
{
swap(array[son], array[dad]);
dad = son;
son = dad * 2 + 1;
}
}
}
int heap_sort(int* array, int len)
{
int i;
swap(array[0],array[len-1]);
max_heapify(array,0,len-2);
return array[len-1];
}
int extract(){
int ret = heap_sort(array,n);
n--;
return ret;
}
private:
int* array;
int n;
};
int main(){
int insert_data;
char buf[22];
Heap heap;
while(true){
fgets(buf,22,stdin);
if(buf[2] == 'd') break;
if(buf[0] == 'i'){
insert_data = 0;
for(int i = 0; buf[i] != '\0';i++){
if(buf[i] >= '0' && buf[i] <= '9'){
insert_data = 10*insert_data + (buf[i] - '0');
}
}
heap.insert(insert_data);
}else{
printf("%d\n",heap.extract());
}
}
}
| 0
| 48,861,696
|
#include <bits/stdc++.h>
#define pi 3.14159
using namespace std;
int main()
{
long long int a,b,k,c,d;
cin>>a>>b>>k;
if(a>=k)
{
c=a-k;
d=b;
}
else
{
c=0;
if(a+b>=k)
d=a+b-k;
else
d=0;
}
cout<<c<<" "<<d<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define r(i,n) for(auto i=0;i<n;i++)
#define s(c) static_cast<int>((c).size())
int main(){
int n;
cin >> n;
int i, t, A[n+1];
cin >> A[0] >> A[1];
for(i = 2; i <= n; i++){
cin >> t >> A[i];
}
int dp[n][n+1]{}, dplr, l, r;
for(int i = 1; i <= n; i++){
for(int j = 0; j < n-i; j++){
l = j;
r = j+i;
dplr = INT_MAX;
for(int k = l; k < r; k++){
dplr = min(dplr, dp[l][k] + dp[k+1][r] + A[l]*A[k+1]*A[r+1]);
}
dp[l][r] = dplr;
}
}
printf("%d\n", dp[0][n-1]);
}
| 0
| 54,380,112
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int M = N;
int sum = 0;
while (N) sum += N % 10, N /= 10;
cout << ((M % sum) ? "No" : "Yes") << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
#define fi first
#define se second
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define siz(v) (ll)(v).size()
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define repn(i,n) for(ll i=0;i<=(ll)(n);i++)
typedef pair<int,int> P;
typedef pair<ll,ll> PL;
const ll mod = 1000000007;
const ll INF = 1000000099;
signed main(){
db n,ans=0;cin>>n;
vector<pair<db,db> > v(n+2,{0,0});
for(int i=1;i < n+1;i++)
{
cin>>v[i].fi;
v[i].fi+=v[i-1].fi;
}
for(int i=1;i < n+1;i++)
{
cin>>v[i].se;
}
v[n+1].fi=v[n].fi;
db prev=0;
for(db t=0.5;t <= v[n+1].fi;t+=0.5)
{
db nowv=INF;
for(int i=n+1;1 <= i;i--)
{
if(t<=v[i].fi)nowv=v.at(i).se;
}
for(int i=0;i < n+1;i++)
{
if(t>v[i].fi)nowv=min(nowv,t-v[i].fi+v.at(i).se);
else nowv=min(nowv,v[i].fi -t +v.at(i+1).se);
}
ans+=(prev+nowv)/4;
prev=nowv;
}
cout<<setprecision(10)<<ans<<endl;
}
| 0
| 44,627,640
|
#include <bits/stdc++.h>
#define loop(s, e, i) for (int i = s; i < e; ++i)
#define print(s) cout << s << endl;
#define DIV 1000000007
#define ll long long
using namespace std;
int main() {
int N, K;
cin >> N >> K;
vector<ll> A(N);
loop(0, N, i) cin >> A[i];
ll leastcost = -1;
for (int bit=0; bit<(1<<N); bit++) {
int valid = 0;
vector<ll> D(N);
for (int i=0; i<N; i++) {
if (bit&(1<<i)) {
D[i] = 1;
valid++;
}
}
if (valid != K) continue;
ll cost = 0;
ll maxsize = 0;
loop(0, N, i) {
if (D[i] == 0){
maxsize = max(maxsize, A[i]);
continue;
}
if (A[i] <= maxsize) {
cost += maxsize - A[i] + 1;
maxsize = maxsize+1;
} else {
maxsize = A[i];
}
}
if (leastcost == -1 || leastcost > cost) leastcost = cost;
}
print(leastcost);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define all(v) (v).begin(), (v).end()
#define rep(i,n) for(ll i=0;i<n;i++)
#define reps(i,n) for(ll i=0;i<=n;i++)
#define PI 3.14159265358979323846264338327950L
ll MOD = 1000000007;
const long long L_INF = 1LL << 60;
const int INF = 2147483647;
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main(){
ios_base::sync_with_stdio(false);
ll h,n;
cin >> h >> n;
vector<ll> a(n,0);
rep(i,n){
cin >> a[i];
h -= a[i];
if(h<=0){
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| 0
| 21,818,072
|
#include<bits/stdc++.h>
using namespace std;
#define int unsigned long long int
#define pb push_back
#define mp make_pair
#define all(x) x.begin(), x.end()
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
typedef vector<int> vi;
const int mod = 1000000007;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin>>n;
map<int,int> m;
for(int i =0;i<n;i++){
int no;
cin>>no;
m[no]++;
}
int ans = 1;
int cnt =0;
for(auto it = m.rbegin();it!=m.rend();it++){
if(it->second >= 4 && cnt==0){
cout<< it->first *(it->first)<<endl;
return 0;
}
else if(it->second >=2){
ans = ans*(it->first);
cnt++;
if(cnt==2){
cout<<ans<<endl;
return 0;
}
}
}
cout<<0<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll mod=1000000007 ;
ll dp[2010];
ll suu(ll s)
{
if(s==0)
return 1;
if(s<3)
return 0;
if(s<6)
return 1;
if(dp[s]!=-1)
return dp[s];
ll res=0;
for(ll i=3;i<=s;i++)
{
res=(mod+(res+(mod+suu(s-i))%mod))%mod;
}
dp[s]=res;
return res;
}
int main()
{
ll a,b,c,d;
memset(dp,-1,sizeof(dp));
dp[0]=1;
cin>>a;
cout<<(mod+suu(a))%mod<<endl;
return 0;
}
| 0
| 16,979,558
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef complex<double> point;
#define xx real()
#define yy imag()
#define REP(i, a, b) for(int i = (a); i < (int)(b); i++)
#define REPN(i, a, b) for(int i = (a); i <= (int)(b); i++)
#define FA(it, x) for(__typeof((x).begin()) it = (x).begin(); it != (x).end(); it++)
#define SZ(x) (int)(x).size()
#define BE(x) (x).begin(), (x).end()
#define SORT(x) sort(BE(x))
#define _1 first
#define _2 second
#define x1 gray_cat_x1
#define y1 gray_cat_y1
template<class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
#define file "I1"
const double EPS = 1e-9;
const double PI = acos(-1.);
const int INF = 1e9;
const ll MOD = 1e9 + 7;
const int MAXN = 1e5 + 5;
const int MAXF = 1e5 + 5;
ll f[MAXF], f_inv[MAXF];
ll pow_mod(ll a, ll st) {
ll ans = 1ll;
for(; st; st >>= 1ll) {
if (st & 1) {
ans = (ans * a) % MOD;
}
a = (a * a) % MOD;
}
return ans;
}
ll get_inv(ll v) {
return pow_mod(v, MOD - 2);
}
void gen_f() {
f[0] = 1;
REP(i, 1, MAXF) {
f[i] = (f[i - 1] * i) % MOD;
}
f_inv[MAXF - 1] = get_inv(f[MAXF - 1]);
for(int i = MAXF - 2; i >= 0; i--) {
f_inv[i] = (f_inv[i + 1] * (i + 1)) % MOD;
}
}
ll get_c(int i, int j) {
if (j > i || j < 0) {
return 0ll;
}
return (((f[i] * f_inv[j]) % MOD) * f_inv[i - j]) % MOD;
}
int ind[MAXN];
int ind1, ind2;
void solve(){
gen_f();
int n;
scanf("%d", &n);
REPN(i, 1, n + 1) {
int a;
scanf("%d", &a);
if (ind[a]) {
ind1 = ind[a];
ind2 = i;
}
ind[a] = i;
}
REPN(k, 1, n + 1) {
ll v0 = get_c(n - 1, k);
ll v2 = get_c(n - 1, k - 2);
ll v11 = get_c(n - 1, k - 1);
ll v12 = get_c(ind1 - 1 + n + 1 - ind2, k - 1);
ll v1 = (MOD + v11 + v11 - v12) % MOD;
ll ans = (v0 + v1 + v2) % MOD;
printf("%lld\n", ans);
}
}
int main(){
int t = 1;
while(t--){
solve();
}
}
|
#include <stdio.h>
int main() {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
int total = 0;
for(int i = 0; i <= a; i++) {
int syarat = 0, counter = i;
while(counter > 0) {
syarat += counter % 10;
counter /= 10;
}
if(syarat >= b && syarat <= c){
total += i;
}
}
printf("%d\n", total);
return 0;
}
| 0
| 98,945,235
|
#include <bits/stdc++.h>
#include <vector>
using namespace std;
int main(){
string a,b;
cin>>a>>b;
sort(a.begin(),a.end());
sort(b.begin(),b.end(),greater<>());
if(a<b) cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
}
|
#define _USE_MATH_DEFINES
#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <queue>
#include <algorithm>
#include <climits>
#include <cstring>
#include <cmath>
#include <stack>
#include <iomanip>
#include <tuple>
#include <functional>
#include <cfloat>
#include <map>
#include <set>
#include <array>
#include <stdio.h>
#include <string.h>
using ll = long long;
using ull = unsigned long long;
using namespace std;
#define int long long
#define CONTAINS(v,n) (find((v).begin(), (v).end(), (n)) != (v).end())
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
#define ARY_SORT(a, size) sort((a), (a)+(size))
#define REMOVE(v,a) (v.erase(remove((v).begin(), (v).end(), (a)), (v).end()))
#define REVERSE(v) (reverse((v).begin(), (v).end()))
#define ARY_REVERSE(v,a) (reverse((v), (v)+(a)))
#define REP(i, n) for (int (i)=0; (i) < (n); (i)++)
#define CONTAINS_MAP(m, a) (m).find((a)) != m.end()
void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
signed main()
{
int N;
cin >> N;
int cur = 1;
REP(i, N)
{
int a;
cin >> a;
if (a == cur)
{
cur++;
}
}
if (cur == 1)
cout << -1 << endl;
else
cout << (N - (cur - 1)) << endl;
}
| 0
| 89,464,674
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) {
cin >> a[i];
a[i]--;
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] == cnt) {
cnt++;
}
}
if (cnt == 0) cout << "-1" << endl;
else cout << n - cnt << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int (i) = 0; (i) < (n); (i)++)
#define repp(i, n, m) for(int (i) = (n); (i) < (m); (i)++)
#define repn(i, n) for(int (i) = 1; (i) <= (n); (i)++)
#define repr(i, n) for(int (i) = (n-1); (i) >= 0; (i)--)
#define all(x) (x).begin(), (x).end()
#define lint long long
#define ulint unsigned long long
#define ldou long double
#define fi first
#define se second
#define setpre(x) std::cout << fixed << setprecision(x)
#define ii(x) int x; cin >> (x)
#define ii2(x, y) int x, y; cin >> (x) >> (y)
#define ii3(x, y, z) int x, y, z; cin >> (x) >> (y) >> (z)
#define out(x) cout << (x) << endl
#define outs(x) cout << (x) << " "
#define yn(x) cout << ((x)?("Yes"):("No")) << endl
#define YN(x) cout << ((x)?("YES"):("NO")) << endl
#define bit_c(x) __builtin_popcountll(x)
inline void logger(){ std::cout << " [LOGGER] " << endl; }
template<typename A, typename... B>
void logger(const A& a, const B&... b){
cout << a << " , "; logger(b...);
}
typedef pair<lint, lint> P;
const lint MOD = 1000000007;
const lint MOD9 = 998244353;
const lint INF = MOD * MOD;
const int MAX = 200005;
int main(){
int n; cin >> n; out(n/3);
}
| 0
| 98,892,480
|
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <string>
#include <algorithm>
#include <numeric>
#include <map>
#include <unordered_map>
#include <stack>
#include <queue>
#include <set>
#include <unordered_set>
#include <bitset>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define REP(i, n) for(size_t i = 0; i < (n); ++i)
int main()
{
int N;
scanf("%d", &N);
vector<int> P(N);
REP(i, N) scanf("%d", &P[i]);
int minp = P[0];
int ans = 1;
for (int i = 1; i < N; ++i)
{
minp = min(minp, P[i]);
if (minp >= P[i]) ++ans;
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define ii pair <int, int>
#define app push_back
#define all(a) a.begin(), a.end()
#define bp __builtin_popcountll
#define ll long long
#define mp make_pair
#define f first
#define s second
#define Time (double)clock()/CLOCKS_PER_SEC
const int N = 1007;
bool ans[N][N];
int want[N];
bool comp(int i, int j) {
return want[i] > want[j];
}
void print(int n, int m, int a, int b, int x, int y) {
vector <int> per;
for (int i = 0; i < m; ++i)
per.app(i);
for (int i = 0; i < y; ++i)
want[i] = b;
for (int i = y; i < m; ++i)
want[i] = n - b;
for (int i = 0; i < n; ++i) {
sort(all(per), comp);
int add;
if (i < x)
add = a;
else
add = m - a;
for (int j = 0; j < add; ++j) {
ans[i][per[j]] = 1;
--want[per[j]];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << ans[i][j];
}
cout << endl;
}
exit(0);
}
signed main() {
#ifdef HOME
freopen("input.txt", "r", stdin);
#else
#define endl '\n'
ios_base::sync_with_stdio(0); cin.tie(0);
#endif
int n, m, a, b;
cin >> n >> m >> a >> b;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
int k1 = i * a + (n - i) * (m - a);
int k2 = j * b + (m - j) * (n - b);
if (k1 == k2) {
print(n, m, a, b, i, j);
}
}
}
exit(1);
}
| 0
| 53,025,717
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int S;
cin>>S;
set<int>st;
int x=S;
while(st.count(x)==0){
st.insert(x);
if(x%2==0){
x/=2;
}
else{
x=x*3+1;
}
}
cout<<(st.size()+1)<<endl;
}
|
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define FOR(i,a,b) for(int i=a;i<b;i++)
#define each(it,v) for(auto &it : v)
#define mod 1000000007
#define all(v) (v).begin(),(v).end()
#define vi vector<int>
#define vl vector<long>
#define P pair<int,int>
using namespace std;
char score[15];
main()
{
rep(i,15)score[i]='o';
string s; cin>>s;
int n=s.size();
rep(i,n)score[i]=s[i];
int cnt=0;
rep(i,15)cnt+=score[i]=='o';
if(cnt>=8)cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
| 0
| 57,571,782
|
#include <bits/stdc++.h>
# define M_PI 3.14159265358979323846
using namespace std;
int main() {
int N, A, B;
cin >> N >> A >> B;
int k = 0;
int j = 0;
int result = 0;
for (int i = 1; i <= N; i++) {
k = i;
while (true) {
if (k < 10) {
j += k % 10;
break;
}
j += k % 10;
k = k / 10;
}
if (A <= j && j <= B) {
result += i;
}
j = 0;
k = 0;
}
cout << result << endl;
}
|
#include <bits/stdc++.h>
#define mod 1000000007
#define INF 1001001001
#define ll long long
#define ln cout<<endl
#define Yes cout<<"Yes"<<endl
#define No cout<<"No"<<endl
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
#define rep(i,n) REP(i,0,n)
#define rep1(i,n) REP(i,1,n+1)
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll a,b,c,n,f=0,mini=INF;
ll sum=0,maxi=0;
string str,sub;
ll h,w;
ll m,k,d;
ll x;
cin>>k>>a>>b;
if(a+1>=b) cout<<k+1<<endl;
else{
k=k-a+1;
sum=a;
if(k%2) sum++;
sum+=(b-a)*(k/2);
cout<<sum<<endl;
}
return 0;
}
| 0
| 72,677,395
|
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#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;
cin >> N;
vector<int> H(N);
rep(i,N) cin >> H[i];
int ans = 1;
for (int i = 1; i < N; ++i) {
bool ok = true;
for (int j = 0; j < i; ++j) {
if (H[j] > H[i]) ok = false;
}
if (ok) ++ans;
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define MAX 100000
const long long INF=1145141919,MOD=1e9+7;
const int dx[8]={1,0,-1,0,1,-1,-1,1};
const int dy[8]={0,1,0,-1,1,1,-1,-1};
const double EPS = 1e-9;
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
int main(){
int m,nmin,nmax;
cin>>m>>nmin>>nmax;
while(m){
int score[m]={},line=-INF,ans=0;
for(int i=0;i<m;i++){
cin>>score[i];
}
for(int i=nmin-1;i<nmax;i++){
if(line<=score[i]-score[i+1]){
line=score[i]-score[i+1];
ans=i+1;
}
}
cout<<ans<<endl;
cin>>m>>nmin>>nmax;
}
return 0;
}
| 0
| 68,505,106
|
#include <iostream>
#include <utility>
#include <tuple>
#include <vector>
#include <string>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <algorithm>
#include <functional>
#include <climits>
#include <numeric>
#include <queue>
#include <cmath>
#include <iomanip>
#include <array>
#include <string>
#include <stack>
#include <cassert>
#include <memory>
using namespace std;
int main() {
int n, k; std::cin >> n >> k;
vector<int> light(n), sum(n, 0);
for (auto& l : light) cin >> l;
for (auto t = 0; t < k; ++t) {
sum.assign(n, 0);
for (auto i = 0; i < n; ++i) {
sum[std::max(i - light[i], 0)]++;
if (i + light[i] + 1 < n) sum[i + light[i] + 1]--;
}
for (auto i = 0; i < n; ++i) {
if (i > 0) sum[i] += sum[i - 1];
light[i] = sum[i];
}
const auto n_count{ std::count(light.begin(), light.end(), n) };
if (n_count == n) break;
}
for (auto i = 0; i < n; ++i) {
if (i > 0) std::cout << ' ';
std::cout << light[i];
}
}
|
#include <iostream>
#include <vector>
using namespace std;
void failure () {
cout << "Impossible" << endl;
exit(0);
}
const int MAX_N = 105;
int atds [MAX_N];
int main () {
ios::sync_with_stdio(false);
int n;
cin >> n;
int diam = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
atds[x]++;
diam = max(diam, x);
}
if (diam == 1 && n > 2) failure();
int blw, abv;
if (diam % 2 == 0) {
if (atds[diam / 2] != 1) failure();
blw = diam / 2 - 1;
abv = diam / 2 + 1;
} else {
if (atds[(diam + 1) / 2] != 2) failure();
blw = diam / 2;
abv = (diam + 1) / 2;
}
for (int i = 0; i <= blw; i++) {
if (atds[i] > 0) failure();
}
for (int i = abv; i <= diam; i++) {
if (atds[i] < 2) failure();
}
cout << "Possible" << endl;
}
| 0
| 37,977,662
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
int main()
{
string s;
cin >> s;
if (s[0] == s[1] && s[2] == s[3] && s[0] != s[2])
{
cout << "Yes" << '\n';
}
else if (s[0] == s[2] && s[1] == s[3] && s[0] != s[1])
{
cout << "Yes" << '\n';
}
else if (s[0] == s[3] && s[1] == s[2] && s[0] != s[1])
{
cout << "Yes" << '\n';
}
else
{
cout << "No" << '\n';
}
return 0;
}
|
#include<stdio.h>
#include<stack>
#include<iostream>
#include<string>
using namespace std;
int n = 0;
int u = 0;
int k[101];
int v[101][101];
int Short[101] = { 0 };
int p = 0;
int fptr = 0;
int lptr = 0;
int x1[10000];
int y1[10000];
void Enqueue(int y, int x)
{
x1[lptr] = x;
y1[lptr] = y;
lptr = (lptr + 1) % 10000;
}
void bfs(int l) {
int i;
while (fptr!=lptr) {
l=x1[fptr];
p=y1[fptr];
fptr = (fptr + 1) % 10000;
if(Short[l]!=-1){
continue;
}
for(i=0;i<k[l];i++){
if(v[l][i]){
Enqueue(p+1,v[l][i]);
}
}
Short[l]=++p;
}
}
int main()
{
int i;
int j;
cin >> n;
for (i = 0; i < n; i++) {
cin >> u;
cin >> k[u];
for (j = 0; j < k[u]; j++) {
cin >> v[u][j];
}
}
Enqueue(-1,1);
for(i=0;i<n+1;i++){
Short[i]=-1;
}
bfs(0);
for (i = 1; i < n + 1; i++) {
cout << i << " " << Short[i] << endl;
}
}
| 0
| 27,712,627
|
#include <bits/stdc++.h>
using namespace std;
#define FASTIO ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
typedef long long ll;
const double PI = acos(-1.0);
const ll mod = 1e9 + 7;
inline void normal(ll &a) { a %= mod; (a < 0) && (a += mod); }
inline ll modMul(ll a, ll b) { a %= mod, b %= mod; normal(a), normal(b); return (a * b) % mod; }
inline ll modAdd(ll a, ll b) { a %= mod, b %= mod; normal(a), normal(b); return (a + b) % mod; }
inline ll modSub(ll a, ll b) { a %= mod, b %= mod; normal(a), normal(b); a -= b; normal(a); return a; }
inline ll modPow(ll b, ll p) { ll r = 1; while (p) { if (p & 1) r = modMul(r, b); b = modMul(b, b); p >>= 1; } return r; }
inline ll modInverse(ll a) { return modPow(a, mod - 2); }
inline ll modDiv(ll a, ll b) { return modMul(a, modInverse(b)); }
#define si(x) scanf("%d",&x)
#define sii(x,y) scanf("%d %d",&x,&y)
#define siii(x,y,z) scanf("%d %d %d",&x,&y,&z)
#define sl(x) scanf("%lld",&x)
#define sll(x,y) scanf("%lld %lld",&x,&y)
#define slll(x,y,z) scanf("%lld %lld %lld",&x,&y,&z)
#define ss(ch) scanf("%s",ch)
#define pi(x) printf("%d",x)
#define pii(x,y) printf("%d %d",x,y)
#define piii(x,y,z) printf("%d %d %d",x,y,z)
#define pl(x) printf("%lld",x)
#define pll(x,y) printf("%lld %lld",x,y)
#define plll(x,y,z) printf("%lld %lld %lld",x,y,z)
#define ps(ch) printf("%s",ch)
#define F(i,a,b) for(int i= a; i <= b; i++)
#define R(i,b,a) for(int i= b; i >= a; i--)
const int N = 90001;
const int M = 1e5 + 5;
int px[N], py[N];
int ans[N];
int main()
{
/*
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
freopen("error.txt", "w", stderr);
#endif
int n, m, D;
siii(n, m, D);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x;
si(x);
px[x] = i;
py[x] = j;
}
}
for (int i = D + 1; i <= n * m; i++)
ans[i] = ans[i - D] + abs(px[i] - px[i - D]) + abs(py[i] - py[i - D]);
int q;
si(q);
while (q--) {
int l, r;
sii(l, r);
printf("%d\n", ans[r] - ans[l]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define req(i,n) for(int i = 1;i <=n;i++)
#define pai 3.14159265358979323846
const int INF = 1001001001;
typedef long long ll;
int A[3][3], N;
bool punched[3][3];
bool ok[3][3];
using Graph = vector<vector<int>>;
vector<vector<int>> field;
vector<bool> seen;
const int MOD = 1000000007;
typedef pair<int,int> P;
int gcd(int a,int b){
if (a%b == 0){
return b;
}
else{
return gcd(b,a%b);
}
}
int lcm(int a,int b){
return a /gcd(a,b) * b;
}
bool is_prime(long long N) {
if (N == 1) return false;
for (long long i = 2; i * i <= N; ++i) {
if (N % i == 0) return false;
}
return true;
}
vector<pair<long long, long long> > prime_factorize(long long n) {
vector<pair<long long, long long> > res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0) continue;
int num = 0;
while (n % p == 0) { ++num; n /= p; }
res.push_back(make_pair(p, num));
}
if (n != 1) res.push_back(make_pair(n, 1));
return res;
}
int binary(int bina){
int ans = 0;
for (int i = 0; bina>0 ; i++)
{
ans = ans+(bina%2)*pow(10,i);
bina = bina/2;
}
return ans;
}
#define int long long int
int32_t main()
{
string s,t;
cin >> s >> t;
cout << t << s << endl;
}
| 0
| 85,116,294
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
using namespace std;
int main(void) {
string S;
string T;
cin >> S;
cin >> T;
cout << T + S << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
int main()
{
int n, l;
cin >> n >> l;
vector<int> a(n);
for(int i = 0; i < n; i++) cin >> a[i];
int pos = 0;
for(int i = 0; i < n-1; i++)
{
if(a[i] + a[i+1] >= l) pos = i+1;
}
if(pos == 0)
{
cout << "Impossible" << endl;
}
else
{
cout << "Possible" << endl;
for(int i = 1; i < pos; i++) cout << i << endl;
for(int i = n-1; i >= pos; i--) cout << i << endl;
}
}
| 0
| 44,673,099
|
using namespace std;
int p[7];
int main(){
for(int i=0;i<8;i++)cin>>p[i],p[i]+=(i>1&&i%4?p[i-1]:0);
cout<<(p[3]>p[7]?p[3]:p[7])<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
long long N, P;
string S;
long long memo[200005];
map<long long, long long>pcount;
long long kaidan[10000000];
long long modpow(long long ori, long long po){
long long res = 1;
while(po > 0){
if(po&1){
res *= ori;
res %= P;
}
ori *= ori;
ori %= P;
po >>= 1;
}
return res;
}
int main(){
cin >> N >> P >> S;
if(P == 2 || P == 5){
long long num = 0;
for(long long i = 0; i < N; i++) {
if((S[i] - '0') % P == 0) {
num += i + 1;
}
}
cout << num << endl;
return 0;
}
for(long long i = 0; i < N; i++) {
memo[i+1] = memo[i] + (S[N-1-i] - '0') * modpow(10, i);
memo[i+1] %= P;
pcount[memo[i+1]]++;
}
long long ans = 0;
for(auto item: pcount) {
if(item.first == 0) {
ans += (item.second * (item.second - 1))/2 + item.second;
} else {
ans += (item.second * (item.second - 1))/2;
}
}
cout << ans << endl;
}
| 0
| 19,036,478
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, A;
cin >> N >> A;
if (N / 500 == 0) {
cout << "Yes";
}
else {
if ((N % 500) > A) {
cout << "No";
} else {
cout << "Yes";
}
}
}
|
#include <cstdio>
#include <map>
#include <queue>
#include <string>
using namespace std;
const int INF = -1;
const int MAX_H = 1010;
const int MAX_W = 1010;
const int MAX_N = 10;
int H, W, N;
char field[MAX_H][MAX_W];
int d[MAX_H][MAX_W];
int sx, sy, gx, gy;
int power = 1;
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
typedef pair<int, int> P;
void reset_d() {
for (int i = 0; i < H; i++)
for(int j = 0; j < W; j++) d[i][j] = INF;
}
int bfs(int c) {
queue<P> que;
reset_d();
d[sx][sy] = c;
que.push(P(sx, sy));
while(que.size()) {
P p = que.front(); que.pop();
for (int i = 0; i < 4; i++) {
int nx = p.first + dx[i], ny = p.second + dy[i];
if ( 0 <= nx && nx <= H && 0 <= ny && ny <= W && field[nx][ny] != 'X' && d[nx][ny] == INF) {
d[nx][ny] = d[p.first][p.second] + 1;
que.push(P(nx, ny));
if (field[nx][ny] - '0' == power) {
sx = nx;
sy = ny;
power++;
return d[nx][ny];
}
}
}
}
return INF;
}
void solve() {
int c = 0;
for (int i = 0; i < N; i++) {
c = bfs(c);
}
printf("%d\n", c);
}
int main() {
scanf("%d %d %d", &H, &W, &N);
for (int i = 0; i < H; i++) {
scanf("%s", field[i]);
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (field[i][j] == 'S') {
sx = i;
sy = j;
}
if (field[i][j] == 'G') {
gx = i;
gy = j;
}
}
}
solve();
return 0;
}
| 0
| 44,334,951
|
#include<bits/stdc++.h>
using namespace std;
int INF = 100000000;
int book[15][15];
int cost[15];
int main(){
int n,m,x;
cin>>n>>m>>x;
for(int i=0; i<n; i++){
cin>>cost[i];
for(int j=0; j<m; j++) cin>>book[i][j];
}
int mincost = INF;
for(int state = 1; state<(1<<n); state++){
int skill[m]={0};
int price = 0;
for(int j=0; j<n; j++){
if(state&(1<<j)){
for(int k=0; k<m; k++) skill[k]+=book[j][k];
price+=cost[j];
}
}
bool possible = true;
for(int j=0; j<m; j++){
if(skill[j]<x) possible = false;
}
if(possible) mincost = min(mincost,price);
}
if(mincost==INF) cout<<-1;
else cout<<mincost;
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<cmath>
#include<cstdio>
#include<queue>
#include<deque>
using namespace std;
typedef pair<int,int> ii;
typedef long long ll;
typedef pair<ll,ll> pll;
const int INF=1e9;
const ll MOD=1e9+7;
ll gcd(ll x,ll y){
if(y==0) return 0;
return gcd(y,x%y);
}
int dis2(int x1,int y1,int x2,int y2){
return (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
}
int main(){
int n;cin>>n;
int a,b;cin>>a>>b;
int p[n];
for(int i=0;i<n;i++) cin>>p[i];
int c1=0,c2=0,c3=0;
for(int i=0;i<n;i++){
if(p[i]<=a) c1++;
else if(a<p[i]&&p[i]<=b) c2++;
else c3++;
}
cout<<min(min(c1,c2),c3)<<endl;
return 0;
}
| 0
| 42,483,432
|
#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()
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;}
int main(){
ll n,m;
cin>>n>>m;
vector<ll> a(n);
rep(i,n){
cin>>a[i];
a[i]/=2;
}
ll lc=1;
rep(i,n) lc=lcm(lc,a[i]);
rep(i,n){
if((lc/a[i])%2==0){
cout<<0<<endl;
return 0;
}
}
ll ans=m/lc;
ans=(ans+1)/2;
cout<<ans<<endl;
}
|
#include<bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
const ll p = 1e9+7;
int main(){
int n;
cin >> n;
vector<ll> a(n);
rep(i,n) cin >> a.at(i);
vector<ll> d(61);
rep(i,n){
for(int j=0;j<=60;j++){
if(((ll)1<<j) & a.at(i)) d.at(j)++;
}
}
ll tot = 0;
rep(i,d.size()){
ll x = (d.at(i) * (n-d.at(i))) % p;
ll y = ((ll)1<<(ll)i) % p;
tot = (tot + (x * y) % p) % p;
}
cout << tot << endl;
return 0;
}
| 0
| 94,288,177
|
#include<iostream>
#include<queue>
#include<vector>
using namespace std;
int dx[4]={ 0, 1, 0, -1};
int dy[4]={ 1, 0, -1, 0};
using P = pair<int,int>;
int h, w, n;
int sx, sy, gx, gy;
int ans=0;
char c[1000][1000];
queue<P> que;
int main(){
cin >> h >> w;
queue<P> que;
vector<vector<int>> d(w, vector(h, -1));
for(int i=0; i<h; i++){
for(int j=0; j<w; j++){
cin >> c[j][i];
if(c[j][i] == '#'){
que.push(P(j,i));
d[j][i] = 0;
}
}
}
while(!que.empty()){
P p = que.front();
que.pop();
int px = p.first, py = p.second;
for(int i=0; i<4; i++){
int nx = px+dx[i], ny = py+dy[i];
if(ny < 0 || ny >= h || nx < 0 || nx >= w) continue;
else{
if(c[nx][ny] == '.'){
c[nx][ny] = '#';
d[nx][ny] = d[px][py] + 1;
que.push(P(nx, ny));
}
}
}
}
for(int i=0; i<h; i++){
for(int j=0; j<w; j++){
if(ans < d[j][i]) ans = d[j][i];
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define all(a) a.begin(), a.end()
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<ll,int> pli;
typedef pair<int,int> pii;
#define rep(i,a,b) for(ll i=a ; i<b ; i++)
#define qrep(que, ite) for(auto ite=begin(que) ; ite!=end(que) ; ite++)
const int max_n = 1e5;
const ll mod = 1e9+7;
const ll INF = 1e17;
const int inf = 1e5;
typedef long double ld;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
ll gcd(ll a, ll b) { return a ? gcd(b%a, a) : b; }
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) { }
void init(int n) { par.assign(n, -1); }
int root(int x) {
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
bool issame(int x, int y) {
return root(x) == root(y);
}
bool merge(int x, int y) {
x = root(x); y = root(y);
if (x == y) return false;
if (par[x] > par[y]) swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) {
return -par[root(x)];
}
};
struct SegmentTree{
int N;
vector<int> node;
public :
void intit(vector<int>v){
int sz = v.size();
N=1;
while(N<sz) N*=2;
node.resize(N);
for(int i=0 ; i<sz ; i++) node[i+N-1] = v[i];
for(int i=N-2 ; i>=0 ; i--) node[i] = min(node[i*2+1], node[i*2+2]);
}
void update(int x, int val){
x += N-1;
node[x+N-1] = val;
while(x>0){
x = (x-1)/2;
node[x] = min(node[x*2+1], node[x*2+2]);
}
}
int getmin(int a, int b, int k, int l, int r){
if(b<=l || r<=a) return inf;
else if(a<=l && r<=b) return node[k];
else{
int vl = getmin(a, b, 2*k+1, l, (l+r)/2);
int vr = getmin(a, b, 2*k+2, (l+r)/2, r);
return min(vl, vr);
}
}
};
vector<ll> divisor(ll n){
vector<ll> res;
for(ll i=1; i*i<=n ; i++){
while(n%i==0){
++res[i];
n /= i;
}
}
if(n!=1) res[n]=1;
return res;
}
int main(){
ll N,S,K; cin>>N>>K>>S;
rep(i,0,N){
ll st = (S+1)%1000000000 + 1;
if(i<K){
cout<<S<<" ";
}else{
cout<<st<<" ";
}
}
cout<<endl;
return 0;
}
| 0
| 65,721,776
|
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(){
string s;
cin >> s;
rep(i,s.length()){
rep(j,s.length()-i-1){
if(s[i]==s[s.length()-j-1]){
cout << "no" << endl;
return 0;
}
}
}
cout << "yes" << endl;
}
|
#include <bits/stdc++.h>
#define ALL(A) (A).begin(), (A).end()
#define ll long long
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int dx[] = { 0, 1, -1, 0, 1, -1, 1, -1 };
int dy[] = { 1, 0, 0, -1, 1, -1, -1, 1 };
const ll mod = 1e9 + 7;
const ll INF = -1 * ((1LL << 63) + 1);
const int inf = -1 * ((1 << 31) + 1);
ll cnt[1000006];
int main(void){
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int n;
cin >> n;
vector<ll> a(n);
rep(i,n) cin >> a[i];
ll allgcd = a[0];
rep(i,n)allgcd = __gcd(allgcd,a[i]);
if(allgcd > 1){
cout << "not coprime" << endl;
}else{
rep(i,n){
ll now = a[i];
for(ll j=2;j*j<=now;j++){
if(now%j==0){
while(now%j==0)now/=j;
cnt[j]++;
}
}
if(now>1)cnt[now]++;
}
for(int i=2;i<=1e6;i++){
if(cnt[i]>1){
cout << "setwise coprime" << endl;
return 0;
}
}
cout << "pairwise coprime" << endl;
}
}
| 0
| 20,420,379
|
#include <bits/stdc++.h>
using namespace std;
int main (void) {
string S;
long long K;
cin >> S >> K;
bool found = false;
for ( int i=0; i<K; i++ ) {
if ( S.at(i) != '1' ) {
cout << S.at(i) << endl;
found = true;
break;
}
}
if ( !found )
cout << '1' << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
const int N = 110;
char s[N][N];
int n, m;
int dp[N][N];
int main() {
scanf("%d %d", &n, &m);
for(int i = 1; i <= n; ++i)
scanf("%s", s[i] + 1);
dp[1][1] = s[1][1] == '#';
for(int i = 1; i <= n; ++i) {
for(int j = 1; j <= m; ++j) {
if(i == 1 && j == 1) continue;
dp[i][j] = 1e9;
if(s[i][j] == '#') {
if(i > 1) dp[i][j] = min(dp[i][j], dp[i - 1][j] + (s[i - 1][j] != '#'));
if(j > 1) dp[i][j] = min(dp[i][j], dp[i][j - 1] + (s[i][j - 1] != '#'));
} else {
if(i > 1) dp[i][j] = min(dp[i][j], dp[i - 1][j]);
if(j > 1) dp[i][j] = min(dp[i][j], dp[i][j - 1]);
}
}
}
printf("%d\n", dp[n][m]);
return 0;
}
| 0
| 82,990,815
|
#include <iostream>
using namespace std;
int main(){
int array[9][9];
for(int num1=1;num1<=9;num1++){
for(int num2=1;num2<=9;num2++){
cout << num1 << 'x' << num2 << '=' << num1*num2 << endl;
}
}
return 0;
}
|
#include <cstdint>
#include <iostream>
#include <string>
constexpr int32_t kMaxNumberOfVertices = 100;
constexpr int32_t kInvalidVertexIndex = -1;
void CallWarshallFloyd(std::istream &input_stream);
class WarshallFloyd {
public:
WarshallFloyd() noexcept;
~WarshallFloyd() noexcept;
void SetNumberOfVertices(const int32_t number_of_vertices) noexcept;
void AddEdge(const int32_t vertex_from_index, const int32_t vertex_to_index, const int32_t weight);
void CalculateWarshallFloyd() noexcept;
void Print() const noexcept;
private:
int32_t number_of_vertices_;
int32_t distances_[kMaxNumberOfVertices][kMaxNumberOfVertices];
};
void CallWarshallFloyd(std::istream &input_stream) {
input_stream.tie(0);
std::ios::sync_with_stdio(false);
WarshallFloyd *all_pairs_shortest_path = new WarshallFloyd();
try {
int32_t number_of_vertices, number_of_edges;
input_stream >> number_of_vertices >> number_of_edges;
all_pairs_shortest_path->SetNumberOfVertices(number_of_vertices);
for (int32_t i = 0; i < number_of_edges; ++i) {
int32_t vertex_from_index, vertex_to_index, weight;
input_stream >> vertex_from_index >> vertex_to_index >> weight;
all_pairs_shortest_path->AddEdge(vertex_from_index, vertex_to_index, weight);
}
all_pairs_shortest_path->CalculateWarshallFloyd();
all_pairs_shortest_path->Print();
} catch (...) {
std::cerr << "ERROR: CallWarshallFloyd()" << std::endl;
throw;
}
delete all_pairs_shortest_path;
}
WarshallFloyd::WarshallFloyd() noexcept : number_of_vertices_(0) {}
WarshallFloyd::~WarshallFloyd() noexcept {}
void WarshallFloyd::SetNumberOfVertices(const int32_t number_of_vertices) noexcept {
number_of_vertices_ = number_of_vertices;
for (int32_t from = 0; from < number_of_vertices; ++from) {
for (int32_t to = 0; to < number_of_vertices; ++to) {
if (from == to) {
distances_[from][to] = 0;
} else {
distances_[from][to] = INT32_MAX;
}
}
}
}
void WarshallFloyd::AddEdge(const int32_t vertex_from_index, const int32_t vertex_to_index, const int32_t weight) {
distances_[vertex_from_index][vertex_to_index] = weight;
}
void WarshallFloyd::CalculateWarshallFloyd() noexcept {
for (int32_t via = 0; via < number_of_vertices_; ++via) {
for (int32_t from = 0; from < number_of_vertices_; ++from) {
for (int32_t to = 0; to < number_of_vertices_; ++to) {
if (distances_[from][via] != INT32_MAX && distances_[via][to] != INT32_MAX) {
const int32_t distance_candidate = distances_[from][via] + distances_[via][to];
if (distance_candidate < distances_[from][to]) {
distances_[from][to] = distance_candidate;
}
}
}
}
}
}
void WarshallFloyd::Print() const noexcept {
bool negative_cycle = false;
for (int32_t i = 0; i < number_of_vertices_; ++i) {
if (distances_[i][i] < 0) {
negative_cycle = true;
}
}
if (negative_cycle) {
std::cout << "NEGATIVE CYCLE" << std::endl;
} else {
for (int32_t from = 0; from < number_of_vertices_; ++from) {
for (int32_t to = 0; to < number_of_vertices_; ++to) {
if (to != 0) {
std::cout << " ";
}
if (distances_[from][to] == INT32_MAX) {
std::cout << "INF";
} else {
std::cout << distances_[from][to];
}
}
std::cout << std::endl;
}
}
}
int main() {
try {
CallWarshallFloyd(std::cin);
} catch (...) {
std::cerr << "ERROR: main()" << std::endl;
}
return 0;
}
| 0
| 50,462,006
|
#include <iostream>
using namespace std;
void solve(long long X, long long Y){
cout << X + Y / 2 << '\n';
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
long long X;
scanf("%lld",&X);
long long Y;
scanf("%lld",&Y);
solve(X, Y);
return 0;
}
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i,n) for(ll i=0;i<(n);i++)
#define rrep(i,n) for(ll i = 1; i <= (n); ++i)
#define drep(i,n) for(ll i = (n)-1; i >= 0; --i)
#define all(v) v.begin(),v.end()
#define len(x) (ll)(x).length()
#define maxs(x,y) x = max(x,y)
#define mins(x,y) x = min(x,y)
#define pb push_back
#define sz(x) (ll)(x).size()
#define v(T) vector<T>
#define vv(T) vector<vector<T>>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
ll gcd(ll a,ll b){if(a%b==0){return b;}else{return(gcd(b,a%b));}}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
const int INF=1e9;
const ll MX = 1e18;
const ll MOD=INF+7;
const int di[] = {-1,0,1,0};
const int dj[] = {0,-1,0,1};
const double PI=acos(-1);
#define dame { puts("-1"); return 0;}
#define yn {puts("Yes");}else{puts("No");}
#define YN {puts("YES");}else{puts("NO");}
const ll MAX = 1000001;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {fac[0] = fac[1] = 1;finv[0] = finv[1] = 1;inv[1] = 1;for (ll i = 2; i < MAX; i++){fac[i] = fac[i - 1] * i % MOD;inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;finv[i] = finv[i - 1] * inv[i] % MOD;}}
long long COM(ll n, ll k){if (n < k) return 0;if (n < 0 || k < 0) return 0;return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;}
int main() {
int n;
cin>>n;
vi a(n);
rep(i,n) cin>>a[i];
int ans=a[0];
rrep(i,n-1){
ans=gcd(ans,a[i]);
}
cout<<ans<<endl;
}
| 0
| 18,943,399
|
#include <iostream>
#include <vector>
#include <stdlib.h>
#include <algorithm>
#include <numeric>
using namespace std;
int main()
{
while(1)
{
int n,score=10000000;
vector<int> a;
cin >> n;
if(n == 0) exit(0);
for(int i = 0 ; i < n; i++)
{
int tpn;
cin >> tpn;
a.push_back(tpn);
}
for(int i = 0; i < n; i++)
{
for(int k = 0; k < n; k++)
{
int tpscore = abs(a[i] - a[k]);
if((tpscore < score) && (i!=k))
{
score = tpscore;
}
}
}
cout << score << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod ll(1e9+7)
ll exp(ll a,ll b)
{
if(b==0)
return 1;
if(b%2==0)
return exp(a*a%mod,b/2);
return a*exp(a*a%mod,(b-1)/2)%mod;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
string s;
cin>>s;
int n=s.size();
ll ans=1;
for(int i=n-1; i>=0; i--){
if(s[i]=='1'){
ans=(exp(3,n-i-1)+2*ans)%mod;
}
}
cout<<ans;
return 0;
}
| 0
| 56,476,393
|
#include <bits/stdc++.h>
#define FastIO ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
typedef long int li;
typedef long long ll;
typedef long double ld;
int main()
{
int n, k = 1;
cin >> n;
if (n >= 1800 && n <= 1999)
k = 1;
else if (n >= 1600 && n <= 1799)
k = 2;
else if (n >= 1400 && n <= 1599)
k = 3;
else if (n >= 1200 && n <= 1399)
k = 4;
else if (n >= 1000 && n <= 1199)
k = 5;
else if (n >= 800 && n <= 999)
k = 6;
else if (n >= 600 && n <= 799)
k = 7;
else if (n >= 400 && n <= 599)
k = 8;
cout << k << "\n";
}
|
#include<bits/stdc++.h>
using namespace std;
using ll=long long int;
#define rep(i,n) for(int i=0;i<(n);i++)
int main(){
int n,k;
cin>>n>>k;
vector<int>a(n);
rep(i,n)cin>>a[i];
int cnt=0;
int ans=0;
vector<int>counter(n,0);
rep(i,n){
counter[a[i]-1]+=1;
}
int c=0;
rep(i,counter.size()){
if(counter[i]!=0)c+=1;
}
sort(counter.begin(),counter.end());
if(k>=c)cout<<0<<endl;
else{
rep(i,counter.size()){
if(cnt==c-k)break;
else if(counter[i]!=0){
ans+=counter[i];
cnt+=1;
}
}
cout<<ans<<endl;
}
}
| 0
| 18,239,478
|
#include<iostream>
#include<string>
#include<vector>
#include<utility>
#include<queue>
#include<algorithm>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<map>
#include<complex>
#define INF 2147483647
#define llINF 9223372036854775807
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define ll long long
using namespace std;
int main(){
ll n,m;
while(cin>>n>>m,n+m){
ll ans=0;
vector<pair<int,int> >pii(n);
for(int i=0;i<n;i++){
cin>>pii[i].S>>pii[i].F;
ans+=pii[i].S*pii[i].F;
}
int po=n-1;
sort(pii.begin(),pii.end());
while(po>=0){
if(m-pii[po].S>=0){
ans-=pii[po].F*pii[po].S;
m-=pii[po].S;
}else{
ans-=pii[po].F*m;
break;
}
po--;
}
cout<<ans<<endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int mod = 1e9+7;
int uniquePathsWithObstacles(vector<vector<int>>& hi) {
int m=hi.size();
int n=hi[0].size();
if(hi[0][0] || hi[m-1][n-1])
return 0;
int dp[m][n];
for(int i=0;i<n;i++)
{
if(hi[0][i]==1)
{
for(int j=i;j<n;j++)
{
dp[0][j]=0;
}
break;
}
else
dp[0][i]=1;
}
for(int i=0;i<m;i++)
{
if(hi[i][0]==1)
{
for(int j=i;j<m;j++)
{
dp[j][0]=0;
}
break;
}
else
dp[i][0]=1;
}
for(int i=1;i<m;i++)
{
for(int j=1;j<n;j++)
{
if(hi[i][j]==1)
dp[i][j]=0;
else
dp[i][j]=(dp[i-1][j]%mod+dp[i][j-1]%mod)%mod;
}
}
return dp[m-1][n-1]%mod;
}
int main()
{
int n, m;
cin>>n>>m;
vector<vector<char>> hii(n, vector<char>(m));
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
cin>>hii[i][j];
}
vector<vector<int>> hi(n, vector<int>(m));
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
if(hii[i][j]=='.')
hi[i][j]=0;
else
hi[i][j]=1;
}
}
cout<<uniquePathsWithObstacles(hi)%mod<<endl;
return 0;
}
| 0
| 9,697,521
|
#include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = long long;
#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 ddrep(i, n) for (int i = n; i > 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define ssrep(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 pb push_back
#define eb emplace_back
#define fi first
#define se second
#define chmax(x, y) (x = max(x, y))
#define chmin(x, y) (x = min(x, y))
using pi = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
using vs = vector<string>;
using vvs = vector<vs>;
using ld = long double;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
rep(i, (int)v.size()) {
if (i)
os << ",";
os << v[i];
}
os << "}";
return os;
}
template <typename T, size_t S> void printArray(const T (&array)[S]) {
for (auto val : array)
std::cout << val << ", ";
std::cout << "\n";
}
const int mod = 1e9 + 7;
const int inf = 1e9 + 5;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << std::setprecision(10);
int n, m; std::cin >> n >> m;
vi k(m);
vvi s(m);
rep(i, m) {
std::cin >> k[i];
vi vec(k[i]);
rep(j, k[i]) {
std::cin >> vec[j];
}
s[i] = vec;
}
vi p(m);
rep(i, m) std::cin >> p[i];
auto calc = [&](int x) {
int ret = 0;
rep(i, m) {
int c = 0;
for (auto &v : s[i]) {
c += (x >> (v-1)) & 1;
}
if (c % 2 == p[i]) ret++;
}
return ret;
};
int ans = 0;
rep(i, 1 << n) {
ans += calc(i) == m;
}
std::cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef pair<ll, ll> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
double equal(double a, double b) {
return fabs(a - b) < DBL_EPSILON;
}
std::istream &operator>>(std::istream &in, set<int> &o) {
int a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
typedef priority_queue<ll, vector<ll>, greater<ll> > PQ_ASK;
int main() {
int a, b;
cin >> a >> b;
if (a + b == 15) {
cout << '+' << endl;
ret();
}
if (a * b == 15) {
cout << '*' << endl;
ret();
}
cout << 'x' << endl;
}
| 0
| 81,708,983
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(k,i,n) for(ll i=k;i<n;++i)
int main(void){
string s,t;
cin>>s>>t;
sort(s.begin(),s.end());
sort(t.rbegin(),t.rend());
if(s<t)cout<<"Yes";
else cout<<"No";
}
|
#include <iostream>
#include <algorithm>
#include <string>
#include <stdio.h>
#include <math.h>
using namespace std;
int main(){
long long a = -1000000, b = 1000000, c = 0, tmp = 0, tmp2 = 0;
cin >> tmp2;
for (int i = 0; i < tmp2; i++){
cin>>tmp;
c += tmp;
a = max(a, tmp);
b = min(b, tmp);
}
cout << b << " " << a << " " << c << endl;
return 0;
}
| 0
| 89,365,432
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define sz(a) (ll)(a).size()
#define all(a) a.begin(), a.end()
#define ff first
#define ss second
#define endl "\n"
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> pbds;
typedef long long ll;
typedef pair<ll,ll> pii;
ll mod=1000000007;
ll power(ll x, ll y)
{
ll temp;
if( y == 0)
return 1;
temp = power(x, y/2);
if (y%2 == 0)
return (temp*temp)%mod;
else
return (((x*temp)%mod)*temp)%mod;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n;
cin>>n;
ll min_pr = 1;
ll ans = 0;
for(ll i=0;i<n;i++)
{
ll val;
cin>>val;
val--;
ans += val/min_pr;
if(i==0 || val+1 == min_pr)
min_pr++;
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define all(a) a.begin(), a.end()
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<ll,int> pli;
typedef pair<int,int> pii;
#define rep(i,a,b) for(ll i=a ; i<b ; i++)
#define qrep(que, ite) for(auto ite=begin(que) ; ite!=end(que) ; ite++)
const int max_n = 1e5;
const ll mod = 1e9+7;
const ll INF = 1e17;
const int inf = 1e5;
typedef long double ld;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
ll gcd(ll a, ll b) { return a ? gcd(b%a, a) : b; }
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) { }
void init(int n) { par.assign(n, -1); }
int root(int x) {
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
bool issame(int x, int y) {
return root(x) == root(y);
}
bool merge(int x, int y) {
x = root(x); y = root(y);
if (x == y) return false;
if (par[x] > par[y]) swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) {
return -par[root(x)];
}
};
struct SegmentTree{
int N;
vector<int> node;
public :
void intit(vector<int>v){
int sz = v.size();
N=1;
while(N<sz) N*=2;
node.resize(N);
for(int i=0 ; i<sz ; i++) node[i+N-1] = v[i];
for(int i=N-2 ; i>=0 ; i--) node[i] = min(node[i*2+1], node[i*2+2]);
}
void update(int x, int val){
x += N-1;
node[x+N-1] = val;
while(x>0){
x = (x-1)/2;
node[x] = min(node[x*2+1], node[x*2+2]);
}
}
int getmin(int a, int b, int k, int l, int r){
if(b<=l || r<=a) return inf;
else if(a<=l && r<=b) return node[k];
else{
int vl = getmin(a, b, 2*k+1, l, (l+r)/2);
int vr = getmin(a, b, 2*k+2, (l+r)/2, r);
return min(vl, vr);
}
}
};const int MAX = 510000;
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;
}
int main(){
string s,t; cin>>s>>t;
int ok = 1;
map<char, int> ma;
int N = s.size();
for(char c='a' ; c<='z' ; c++) ma[c] = c - 'a';
vector<set<int>> set1(26), set2(26);
int cnt = 0;
rep(i,0,N){
int now = ma[s[i]];
set1[now].insert(i);
now = ma[t[i]];
set2[now].insert(i);
}
rep(i,0,26){
char c = ' '; cnt = 0;
for(auto j : set1[i]){
if(cnt==0){
cnt++; c = t[j];
continue;
}
if(c != t[j]) ok = 0;
}
cnt = 0;
for(auto j : set2[i]){
if(cnt==0){
cnt++; c = s[j];
continue;
}
if(c != s[j]) ok = 0;
}
}
string ans = "No";
if(ok){
ans = "Yes";
}
cout<<ans<<endl;
return 0;
}
| 0
| 32,839,201
|
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <cmath>
#include <string>
#include <iomanip>
#include <deque>
#include <queue>
#include <stack>
#include <set>
#include <complex>
#include <ctime>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef int itn;
const ll LINF = 1e18;
const int INF = 1e9;
#define vvint(vec,n,m,l) vector<vector<int>> vec(n, vector<int>(m,l));
#define vvll(vec,n,m,l) vector<vector<ll>> vec(n,vector<ll>(m,l));
#define vint vector<int>
#define pint pair<int,int>
#define rep(i,a) for(int i=0;i<(a);i++)
#define all(x) (x).begin(),(x).end()
#define debug system("pause")
#define ret return 0
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; }
using Graph = vector<vector<ll>>;
#define ketasitei setprecision(15)
const ll MOD = 1000000007;
const double PI = 3.1415926535897932;
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
cout << ketasitei;
ll n,k;
cin >> n >> k;
vector<ll> a(n);
vector<ll> h(n,0);
rep(i, n)
{
cin >> a[i];
}
rep(i, n - 1)
{
h[i + 1] = max(a[i + 1], h[i]);
}
ll bit = (1LL << n) - 1LL;
ll now = 0;
ll sum = 0;
rep(i, n)
{
if (now < a[i])
{
sum++;
now = a[i];
}
}
if (sum == k)
{
cout << 0 << endl;
ret;
}
sum = 0;
now = 0;
ll ans = LINF;
while (bit)
{
vector<ll> tal(n);
rep(i, n)
tal[i] = a[i];
ll tmp = bit;
now = 0;
sum = 0;
ll point = 0;
while (tmp)
{
if (tmp & 1)
{
if (a[point] <= now)
{
sum += now - a[point] + 1;
now++;
tal[point] = now;
}
}
tmp >>= 1;
now = max(now, a[point]);
point++;
}
now = 0;
ll ok = 0;
rep(i, n)
{
if (tal[i] > now)
{
ok++;
now = tal[i];
}
}
if (ok >= k)
{
ans = min(ans, sum);
}
bit--;
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;
int n, s;
int table[50010];
int main() {
cin >> s>>n;
vector<int>v(n);
for (int i = 0; i < n; i++)
cin >> v[i];
table[0] = 0;
for (int i = 1; i <= s; i++)
table[i] = INT_MAX;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= s; j++) {
if (j >= v[i])
if (table[j - v[i]] != INT_MAX)
table[j] = min(table[j], table[j - v[i]] + 1);
}
}
cout << table[s] << endl;
return 0;
}
| 0
| 30,545,685
|
#include <bits/stdc++.h>
using namespace std;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
using ll = long long;
using pint = pair<int, int>;
using pll = pair<ll, ll>;
using vint = vector<int>;
using vll = vector<ll>;
using vstr = vector<string>;
const ll MOD=1e9+7;
const ll INF=1ll<<60;
int S;
ll dp[2001];
ll solve(){
}
int main(){
cin >> S;
dp[0]=1;
for(int i=1;i<S+1;++i){
if(i<3){
dp[i]=0;
}else{
dp[i]=(dp[i-1]+dp[i-3])%MOD;
}
}
cout << dp[S]<<endl;
return 0;
}
|
#include <iostream>
#include <cmath>
using namespace std;
int comb(int a,int num){
if(num == 1){
return 1;
}
else{
int count = 0;
for(int i = 0; i <= min(a,9); i++){
if(a - i <= 9*(num-1)) count = count + comb(a-i, num-1);
}
return count;
}
}
int main(){
int n,k;
while(cin >> n){
cout << comb(n,4) << endl;
}
}
| 0
| 27,069,729
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
signed main()
{
int x,y,ok=0; cin>> x >> y;
for(int i=0; i<x; ++i){
if(2*i + 4*(x-i) == y){++ok; break;}
}
for(int i=0; i<x; ++i){
if(4*i + 2*(x-i) == y){++ok; break;}
}
if(ok>0){
cout<< "Yes";
}else{
cout<< "No";
}
}
|
#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
using namespace std;
int main(void){
string a[10];
a[0]="";
a[1]=" .,!?";
a[2]="cab";
a[3]="fde";
a[4]="igh";
a[5]="ljk";
a[6]="omn";
a[7]="spqr";
a[8]="vtu";
a[9]="zwxy";
int n;
cin >> n;
cin.ignore();
while(n--){
string str;
getline(cin,str);
int sz=str.size(),i=0,cnt=0;
while(str[i]=='0')i++;
for(;i<sz;i++){
if(str[i]=='0'){
cout << a[str[i-1]-'0'][cnt%a[str[i-1]-'0'].size()];
cnt=0;
while(str[i+1]=='0')i++;
}
else cnt++;
}
cout << endl;
}
return 0;
}
| 0
| 18,841,878
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.