code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 137
101M
|
|---|---|---|---|
#include<iostream>
using namespace std;
struct Card {
char moji;
int value;
};
void print(struct Card A[], int N) {
int i;
for (i = 0; i < N; i++) {
if (i > 0) cout << " ";
cout << A[i].moji << A[i].value;
}
cout << endl;
}
void Bubble_Sort(struct Card A[], int N) {
int i, j;
for (i = 0; i < N; i++) {
for (j = N - 1; j >= i; j--) {
if (A[j].value < A[j-1].value) {
Card tmp = A[j];
A[j] = A[j - 1];
A[j - 1] = tmp;
}
}
}
}
void Selection_Sort(struct Card A[], int N) {
int i, j;
int min;
for (i = 0; i < N; i++) {
min = i;
for (j = i; j < N; j++) {
if (A[j].value < A[min].value) {
min = j;
}
}
Card tmp = A[i];
A[i]= A[min];
A[min] = tmp;
}
}
bool Stable(struct Card C1[], struct Card C2[], int N) {
int i;
for (i = 0; i < N; i++) {
if (C1[i].moji != C2[i].moji) return 0;
}
return 1;
}
int main() {
struct Card C1[100],C2[100];
int N;
int i;
cin >> N;
for (i = 0; i < N; i++) {
cin >> C1[i].moji >> C1[i].value;
}
for (i = 0; i < N; i++) {
C2[i] = C1[i];
}
Bubble_Sort(C1, N);
Selection_Sort(C2, N);
print(C1, N);
cout << "Stable" << endl;
print(C2, N);
if (Stable(C1, C2, N)) {
cout << "Stable" << endl;
}
else {
cout << "Not stable" << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define zero_pad(num) setfill('0') << std::right << setw(num)
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
string s;
cin >> s;
map<char, int> mp;
rep(i, n)mp[s[i]]++;
int m = mp.size();
vector<vector<ll>> dp(m+1, vector<ll>(2, 0));
dp[0][0] = 1;
ll mod = 1000000007;
int cnt = 0;
for(auto p : mp){
ll c = p.second;
dp[cnt+1][0] = (dp[cnt][0] + dp[cnt][1]) % mod;
dp[cnt+1][1] = (dp[cnt][0] + dp[cnt][1]) % mod * c % mod;
cnt++;
}
ll ans = (dp[m][0] + dp[m][1] - 1 + mod) % mod;
cout << ans << endl;
} | 0 | 38,243,210 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const ll N=1e5+5;
ll a,b;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin>>a>>b;
if(a==1)
a+=13;
if(b==1)
b+=13;
if(a>b)
cout<<"Alice";
else if(b>a)
cout<<"Bob";
else
cout<<"Draw";
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i=0;i<(n);++i)
#define fi first
#define se second
#define INF 1000000009
#define lINF 1000000000000000009
typedef long long ll;
int main(){
int m,k;
cin>>m>>k;
if(m==1){
if(k==0)cout<<0<<' '<<0<<' '<<1<<' '<<1<<endl;
else cout<<-1<<endl;
return(0);
}
if(k>=(1<<m)){
cout<<-1<<endl;
return(0);
}
vector<int>ans;
ans.push_back(k);
rep(i,1<<m){
if(i==k)continue;
ans.push_back(i);
}
ans.push_back(k);
for(int i=(1<<m)-1;i>=0;i--){
if(i==k)continue;
ans.push_back(i);
}
rep(i,ans.size()){
cout<<ans[i];
if(i+1==ans.size())cout<<endl;
else cout<<' ';
}
return(0);
} | 0 | 87,930,859 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF 1e9
typedef long long ll;
int main() {
vector<pair<int,int>>dish(5);
REP(i,5){
int x;
cin >> x;
dish[i] = make_pair((x-1)%10, x);
}
sort(ALL(dish));
int ans = dish[0].second;
FOR(i,1,5){
ans += ((dish[i].second-1)/10 + 1)*10;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define pb push_back
#define REP(i, n) for (signed long long i = 0; i < (n); i++)
#define MOD 1000000007
#define bitcnt(a) (ll) __builtin_popcount((a))
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
int main() {
ll n,all=0;
vector<ll>v;
cin>>n;
REP(i,n){
ll p;
cin>>p;
all+=p;
v.pb(p);
}
ll oneCnt=(1+n)*n/2;
if(all%oneCnt){
cout<<"NO"<<endl;
return 0;
}
ll times = all/oneCnt;
REP(i,n){
ll dif=v[(i+1)%n]-v[i];
if(dif>times||(dif-times)%(n)){
cout<<"NO"<<endl;
return 0;
}
}
cout<<"YES"<<endl;
} | 0 | 51,798,677 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define fi first
#define se second
#define m_p make_pair
#define p_b push_back
#define e_b emplace_back
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define REP(i,m,n) for(int i=(int)(m);i<(int)(n);i++)
#define rep(i,n) REP(i,0,n)
#ifdef LOCAL
#define debug(x) cerr<<"LINE"<<__LINE__<<" : "<<#x<<" = "<<(x)<<endl
#define debug_vec(x) cerr<<"LINE"<<__LINE__<<" : "<<#x<<" = ";\
rep(i,sz(x)){cerr<<x[i]<<" ";}cerr<<endl
#define debug_mat(x) cerr<<"LINE"<<__LINE__<<" : "<<#x<<" = "<<endl;\
rep(i,sz(x)){rep(j,sz(x[i])){cerr<<x[i][j]<<" ";}cerr<<endl;}cerr<<endl
#else
#define debug(x) void(0)
#define debug_vec(x) void(0)
#define debug_mat(x) void(0)
#endif
template<class T> bool chmax(T &a,T b){if(a<b){a=b;return true;}return false;}
template<class T> bool chmin(T &a,T b){if(a>b){a=b;return true;}return false;}
class Union_Find_size{
public:
vector<int> Parent;
Union_Find_size(int N){
Parent=vector<int>(N,-1);
}
int root(int x){
if(Parent.at(x)<0) return x;
return Parent.at(x)=root(Parent.at(x));
}
int size(int x){
return -Parent.at(root(x));
}
bool same(int x,int y){
return root(x)==root(y);
}
void unite(int x,int y){
x=root(x);
y=root(y);
if(x==y) return;
if(size(x)<size(y)) swap(x,y);
Parent.at(x)+=Parent.at(y);
Parent.at(y)=x;
}
};
int main(){
ios_base::sync_with_stdio(false);cin.tie(0);
int N,M;
cin >> N >> M;
vector<int> p(N);
rep(i,N){
cin >> p.at(i);
p.at(i)--;
}
Union_Find_size uni(N);
rep(i,M){
int x,y;
cin >> x >> y;
x--;
y--;
uni.unite(x,y);
}
int ans=0;
rep(i,N){
if(uni.same(i,p.at(i))) ans++;
}
cout << ans << 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 | 4,026,646 |
#include <algorithm>
#include <bits/stdc++.h>
#include <iterator>
#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;
cin >> n;
vector<int> p(n);
vector<int> q(n);
rep(i, n)
cin >> p[i];
rep(i, n)
cin >> q[i];
vector<int> a(n);
rep(i, n)
a[i] = i + 1;
int numa = 0;
int numb = 0;
int cnt = 0;
do {
cnt++;
bool flag1 = true;
bool flag2 = true;
for(int i = 0; i < n; ++i) {
if(a[i] != p[i]) {
flag1 = false;
}
if(a[i] != q[i]) {
flag2 = false;
}
}
if(flag1) {
numa = cnt;
}
if(flag2) {
numb = cnt;
}
}while(next_permutation(a.begin(), a.end()));
cout << abs(numa - numb) << endl;
return 0;
} | #include<cstdio>
using namespace std;
int main(void){
int in[100],data,ans[100],cnt,work=0;
int i,j;
for(i=0;i<100;i++){
ans[i]=0;
in[i]=0;
}
for(i=0;i<100;i++){
if(scanf("%d",&data)==EOF) break;
in[data]++;
}
for(i=1;i<100;i++)
if(in[work]<in[i]) work=i;
ans[0]=work;
cnt=0;
for(i=1;i<100;i++){
if(in[work]==in[i] && i!=work){
cnt++;
ans[cnt]=i;
}
}
for(i=0;i<=cnt-1;i++){
for(j=1;j<=cnt;j++){
if(ans[i]>ans[j]){
work=ans[i];
ans[i]=ans[j];
ans[j]=work;
}
}
}
for(i=0;i<=cnt;i++)
printf("%d\n",ans[i]);
return 0;
} | 0 | 94,604,595 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using Graph=vector<vector<int>>;
#define MAX 1000000
#define MOD 1000000007
#define INF 100000000000000
int main(){
int N;
cin>>N;
vector<ll> A(N);
bool plus=false;
bool minus=false;
bool zero=false;
ll sum=0;
for(int i=0;i<N;i++){
cin>>A.at(i);
sum+=abs<ll>(A.at(i));
if(A.at(i)>0){
plus=true;
}else if(A.at(i)<0){
minus=true;
}else{
zero=true;
}
}
sort(A.begin(),A.end());
if((plus&&minus)||zero){
int k=lower_bound(A.begin(),A.end(),0)-A.begin();
cout<<sum<<endl;
for(int i=k;i<N-1;i++){
if(i==0){
continue;
}
cout<<A.at(0)<<" "<<A.at(i)<<endl;
A.at(0)-=A.at(i);
}
for(int i=0;i<k;i++){
cout<<A.at(N-1)<<" "<<A.at(i)<<endl;
A.at(N-1)-=A.at(i);
}
if(k==0){
cout<<A.at(N-1)<<" "<<A.at(0)<<endl;
}
}else if(plus){
cout<<sum-2*A.at(0)<<endl;
for(int i=1;i<N-1;i++){
cout<<A.at(0)<<" "<<A.at(i)<<endl;
A.at(0)-=A.at(i);
}
cout<<A.at(N-1)<<" "<<A.at(0)<<endl;
}else{
cout<<sum+2*A.at(N-1)<<endl;
for(int i=0;i<N-1;i++){
cout<<A.at(N-1)<<" "<<A.at(i)<<endl;
A.at(N-1)-=A.at(i);
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define fr(i,j,k) for(int i=j;i<k;i++)
#define f(n) fr(i,0,n)
#define f1(n) fr(i,1,n+1)
#define pb push_back
#define F first
#define S second
#define all(x) x.begin(), x.end()
const ll mod = 1e11 + 7;
const int maxn = 2e5+5;
#include<atcoder/dsu>
using namespace atcoder;
void solve() {
int n, m;
cin >> n >> m;
dsu d(n);
f(m) {
int op, x, y;
cin >> op >> x >> y;
if (!op) {
d.merge(x, y);
}
else {
cout << d.same(x, y) << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int c = 0;
int t;
if (!c) {
t = 1;
}
else {
cin >> t;
}
while (t--) {
solve();
}
} | 0 | 69,824,995 |
#include <cstdio>
int a, b, c;
int cnt[201];
void solve()
{
cnt[a+100]++;
cnt[b+100]++;
cnt[c+100]++;
for (int i = 0; i < 201; i++) {
if (cnt[i] == 1) {
printf("%d\n", i-100);
}
}
}
int main()
{
scanf("%d%d%d", &a, &b, &c);
solve();
return 0;
} | #include <stdio.h>
void triangle(int number)
{
for(int i = 0; i < number; ++i) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
if ((a > b) && (a > c)) {
if (a * a == b * b + c * c) {
printf("YES\n");
} else {
printf("NO\n");
}
} else if ((b > a) && (b > c)) {
if (b * b == a * a + c * c) {
printf("YES\n");
} else {
printf("NO\n");
}
} else if ((c > a) && (c > b)) {
if (c * c == a * a + b * b) {
printf("YES\n");
} else {
printf("NO\n");
}
} else
{
printf("NO\n");
}
}
}
int main(void)
{
int number;
scanf("%d", &number);
triangle(number);
return 0;
} | 0 | 6,610,873 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
int main()
{
ll a[] = { 1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51 };
ll n; cin >> n;
for(ll i = 0 ; i < 32; i++)
{
if((i + 1) == n)
{
cout << a[i] << '\n';
break;
}
}
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair< int, int > pii;
typedef pair< pii, int > ppi;
#define fill(a,b) memset(a,b,sizeof(a))
#define all(v) (v).begin(),(v).end()
#define sp(k) cout<<setprecision(k)<<fixed;
#define rep(i,a) for(int i=0;i<a;i++)
#define rep1(i,a,b) for(int i=(a);i<=(b);++i)
#define irep(i,b,a) for(int i=(b);i>=(a);--i)
#define minv(v) *min_element(all(v))
#define maxv(v) *max_element(all(v))
#define unq(v) sort(all(v)),(v).erase(unique(all(v)),(v).end())
#define _ ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define endl "\n"
#define sqr(a) ((a)*(a))
#define sz(a) int(a.size())
#define ff first
#define ss second
#define pb push_back
const double pi = acos(-1.0);
const int mod = 1000000007;
const int inf = 0x3f3f3f3f;
const int maxn = 500100;
int ans[maxn];
int main(){
_
string s; cin >> s;
int n = sz(s);
for(int i = 0; i<n; i++){
if(s[i]=='<'){
ans[i+1] = max(ans[i+1], ans[i]+1);
}
}
for(int i = n-1; i>=0; i--){
if(s[i]=='>'){
ans[i] = max(ans[i], ans[i+1]+1);
}
}
ll res = 0;
for(int i = 0; i<=n;i++){
res+=ans[i];
}
cout<<res<<endl;
return 0;
} | 0 | 53,966,397 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long x,y,cnt=0;
cin>>x>>y;
for(long long i=x;i<=y;i*=2)
++cnt;
cout<<cnt;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef long int li;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
typedef pair<ll, ll>P;
typedef tuple<double,ll,ll>T;
#define PI 3.14159265358979
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(){
int N;
cin>>N;
COMinit();
map< ll, int > ret;
for(ll j=2;j<=N;j++){
ll n=j;
for(ll i = 2; i * i <= n; i++) {
while(n % i == 0) {
ret[i]++;
n /= i;
}
}
if(n != 1) ret[n]++;
}
ll a=0,b=0,c=0,d=0,e=0;
ll z=0;
for(auto k:ret){
if(k.second>=2){a++;}
if(k.second>=4){b++;}
if(k.second>=14){c++;}
if(k.second>=24){d++;}
if(k.second>=74){e++;}
}
ll ans=0ll;
ans+=e;
ans+=d*(a-1);
ans+=c*(b-1);
ans+=b*(b-1)*(a-2)/2;
cout<<ans;
} | 0 | 31,300,707 |
#include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int> >;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define brep(n) for(int bit=0;bit<(1<<n);bit++)
#define erep(i,container) for (auto i : container)
#define irep(i, n) for(int i = n-1; i >= (int)0; i--)
#define rrep(i,m,n) for(int i = m; i < (int)(n); i++)
#define reprep(i,j,h,w) rep(i,h)rep(j,w)
#define all(x) (x).begin(),(x).end()
#define aall(x,n) (x).begin(),(x).begin()+(n)
#define VEC(type,name,n) std::vector<type> name(n);rep(i,n)std::cin >> name[i];
#define pb push_back
#define pf push_front
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define itn int
#define mp make_pair
#define sum accumulate
#define keta fixed<<setprecision
#define vvector(name,typ,m,n,a)vector<vector<typ> > name(m,vector<typ> (n,a))
#define vvvector(name,t,l,m,n,a) vector<vector<vector<t> > > name(l, vector<vector<t> >(m, vector<t>(n,a)));
#define vvvvector(name,t,k,l,m,n,a) vector<vector<vector<vector<t> > > > name(k,vector<vector<vector<t> > >(l, vector<vector<t> >(m, vector<t>(n,a)) ));
typedef long long ll;
const int INF = 2000000000;
const ll INF64 = 1000000000000000ll;
const ll MOD = 1000000007LL;
int main(){
int n,m;
std::cin >> n>>m;
std::vector<int> a(n+1,0);
rep(i,m){
int q,w;
std::cin >> q>>w;
q--;w--;
if(w<q)swap(q,w);
a[q]++;a[w]--;
}
bool han=1;
rep(i,n)if(a[i]%2)han=0;
if(han)std::cout << "YES" << std::endl;
else std::cout << "NO"<< std::endl;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF=1e+18;
const int MOD=1e+9+7;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define REP2(i,a,b) for(ll i=a;i<(ll)(b);i++)
#define REPD2(i,a,b) for(ll i=a;i>(ll)(b);i--)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
int main(){
int N,M,R;
cin>>N>>M>>R;
vector<int> r(R);
vector<vector<ll>> d(N,vector<ll>(N,INF));
int tmp;
REP(i,R){
cin >> tmp;
tmp--;
r[i]=tmp;
}
vector<vector<ll>> cost(N,vector<ll>(N,-1));
vector<vector<int>> G(N);
int a,b,c;
REP(i,M){
cin>>a>>b>>c;
a--;
b--;
cost[a][b]=c;
cost[b][a]=c;
G[a].push_back(b);
G[b].push_back(a);
}
REP(i,R){
vector<ll> dist(N, INF);
priority_queue<int> que;
dist[r[i]] = 0;
que.push(r[i]);
while (!que.empty()) {
int v = que.top();
que.pop();
for (int nv : G[v]) {
if (cost[v][nv] == -1) continue;
if(dist[v]+cost[v][nv]<dist[nv]){
dist[nv] = dist[v] + cost[v][nv];
que.push(nv);
}
}
}
REP(j,R){
if(i==j) continue;
d[r[i]][r[j]]=dist[r[j]];
d[r[j]][r[i]]=dist[r[j]];
}
}
ll ans=INF;
ll sum;
sort(r.begin(),r.end());
do{
sum=0;
REP(i,R-1){
sum+=d[r[i]][r[i+1]];
}
ans=min(ans,sum);
}while(next_permutation(r.begin(),r.end()));
cout << ans << endl;
} | 0 | 60,033,313 |
#include<stdio.h>
int main()
{
int a, b, c, s,f, d;
scanf("%d %d %d", &a, &b, &c);
for (s=a;s <= b;s++){
f=c%s;
if(f == 0){
d = d + 1;
}
}
printf("%d\n", d);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ios_base:: sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
ll h,w,d;cin>>h>>w>>d;
ll a[h][w];for(ll i=0;i<h;i++)for(ll j=0;j<w;j++)cin>>a[i][j],a[i][j]--;
vector< pair<ll , pair<ll,ll> > >pos[d];
for(ll i=0;i<h;i++)for(ll j=0;j<w;j++)pos[a[i][j]%d].push_back({a[i][j] , {i,j} });
vector< ll > prfx[d];
for(ll i=0;i<d;i++){
sort(pos[i].begin(),pos[i].end());
prfx[i].push_back(0);
for(ll j=1;j<pos[i].size();j++)
prfx[i].push_back( abs(pos[i][j].second.first-pos[i][j-1].second.first) + abs(pos[i][j].second.second - pos[i][j-1].second.second));
for(ll j=1;j<prfx[i].size();j++)prfx[i][j]+=prfx[i][j-1];
}
ll q;cin>>q;
while(q--){
ll l,r;cin>>l>>r;
l--;r--;
ll idx = l%d;
ll s = l/d , e = r/d;
ll ans = prfx[idx][e] - prfx[idx][s];
cout<<ans<<"\n";
}
} | 0 | 68,166,746 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1e18;
const int BIG = 2e9 + 55;
const int maxN = 200 + 5;
int n;
int a[maxN];
int memo[maxN][maxN];
bool calc[maxN][maxN];
int dp(int i, int curH){
if(i == n){
return (curH != a[i]);
}
if(calc[i][curH]){
return memo[i][curH];
}
int ans = n;
for(int nxtH = 1; nxtH < maxN; nxtH++){
if(curH != nxtH){
ans = min(ans, dp(i + 1, nxtH) + (curH != a[i]));
}
}
calc[i][curH] = true;
return (memo[i][curH] = ans);
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for(int i = 1; i <= n; i++){
cin >> a[i];
}
int mn = n;
for(int curH = 1; curH < maxN; curH++){
mn = min(mn, dp(1, curH));
}
cout << mn << '\n';
return 0;
} | #include <iostream>
#include <cmath>
#include <algorithm>
#include <string>
#include <vector>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <deque>
using namespace std;
#define next '\n'
#define sp " "
#define print(x) cout << (x)
#define println(x) cout << (x) << next
#define stop return(0)
#define rep(i, n) for(int (i) = (0); (i) < (n); (++i))
#define FOR(i, start, end) for(int (i) = (start); (i) < (end); (++i))
#define foreach(e, elem) for(auto& (e) : (elem))
#define FAST ios::sync_with_stdio(false); cin.tie(nullptr)
#define size(s) (s).size()
#define all(vec) (vec).begin(), (vec).end()
#define pb(e) push_back(e);
#define INF 1e+12
#define PI acos(-1)
#define MOD 100000009
using ll = long long;
using ull = unsigned long long;
int main(){
int n;
cin >> n;
double ans = 0;
rep(i, n) {
double xn;
string un;
cin >> xn >> un;
if(un == "JPY"){
ans += xn;
}else{
ans += xn * 380000.0;
}
}
printf("%.12lf", ans);
} | 0 | 60,312,074 |
#include<iostream>
using namespace std;
int main() {
int train[200000] = { 0 }, junban[200000] = { 0 }, a = 0, n, i;
while (cin >> n) {
if (n == 0) {
for (i = 0; train[i] != 0; i++) {}
junban[a] = train[i - 1];
train[i - 1] = 0;
a++;
}
else {
for (i = 0; train[i] != 0; i++) {}
train[i] = n;
}
}
for (i = 0; junban[i] > 0; i++) {
cout << junban[i] << endl;
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll=long long;
using ld=long double;
#define _CRT_SECURE_NO_WARNINGS
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
#define ALL(x) (x).begin(), (x).end()
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;
}
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;
}
char toSmall(char c) {
return (c + 0x20);
}
char toLarge(char c) {
return (c - 0x20);
}
float myPower(int a, int n) {
float x = 1;
while (n > 0) {
if (n & 1) {
x *= a;
}
a *= a;
n >>= 1;
}
return x;
}
bool is_prime(const unsigned n) {
switch (n) {
case 0:
case 1: return false;
case 2:
case 3: return true;
}
if (n % 2 == 0 || n % 3 == 0) return false;
for (unsigned i = 5; i * i <= n; i += 6) {
if (n % i == 0) return false;
if (n % (i + 2) == 0) return false;
}
return true;
}
int main(void){
string s; cin >> s;
vector<int> vec(30);
rep(i, s.size()) {
++vec[s[i] - 'a'];
}
rep(i, 26) {
if (vec[i] == 0) {
cout << (char)(i + 'a') << endl;
return 0;
}
}
cout << "None" << endl;
return 0;
} | 0 | 91,602,756 |
#include<bits/stdc++.h>
#define endl "\n"
#define M_PI 3.14159265358979323846
#define fast_io ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
#define fix_prec cout.setf( std::ios::fixed, std:: ios::floatfield ); cout.precision(9);
#define vi vector<int>
#define vvi vector<vector<int>>
#define vpii vector<pair<int,int>>
#define pb(v,x) v.push_back(x)
#define pii pair<int,int>
#define mp(a,b) make_pair(a,b)
#define F first
#define S second
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define lb(v,x) lower_bound(v.begin(),v.end(),x)
#define ub(v,x) upper_bound(v.begin(),v.end(),x)
using namespace std;
typedef long long int lli;
typedef unsigned long long int ulli;
lli const mod = 1e9+7;
lli const modl = 1e18;
lli gcd(lli x, lli y)
{
if (y == 0)
return x;
return gcd(y, x % y);
}
lli fib(int n)
{
lli a,b,c,i;
a=0,b=1;
if(n == 0)
return a;
for(i=2;i<=n;i++)
{
c=a+b;
a=b;
b=c;
}
return b;
}
bool isprime(lli n)
{
if(n<=1)
return false;
else if(n==2)
return true;
else if(n%2==0)
return false;
else
{
int i;
for(i=3;i*i<=n;i++)
{
if(n%i==0)
return false;
}
return true;
}
}
void readwrite()
{
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
}
vector<lli>prime(100000+7,1);
void buildprime(lli n)
{
lli i,j;
prime[0]=prime[1]=0;
for(i=2;i*i<=n;i++)
{
if(prime[i])
{
for(j=i*i;j<=n;j+=i)
prime[j]=0;
}
}
}
lli dp[1005][1005];
lli comb[1005][1005];
lli ncr(lli n,lli r)
{
if(n==r)
return 1;
if(r==0)
return 1;
if(r==1)
return n;
if(dp[n][r]!=0)
return dp[n][r];
return dp[n][r] = (ncr(n-1,r)%mod+ncr(n-1,r-1)%mod)%mod;
}
void ncrm()
{
comb[0][0]=1;
for(int i=1;i<1001;i++)
{
comb[i][0]=1;
for(int j=1;j<=i;j++)
{
comb[i][j]=(comb[i-1][j]%mod+comb[i-1][j-1]%mod)%mod;
}
}
}
lli binpowm(lli a,lli b)
{
lli res=1;
a%=mod;
while(b)
{
if(b&1)
res=((res%mod)*(a%mod))%mod;
a=((a%mod)*(a%mod))%mod;
b>>=1;
}
return res%mod;
}
lli fact(lli n)
{
lli i,res=1;
for(i=1;i<=n;i++)
res=((res%mod)*(i%mod))%mod;
return res%mod;
}
void solve()
{
lli n,m,i,ans=0;
string s;
cin>>s;
n=s.length();
m=0;
for(i=0;i<n;i++)
{
if(s[i]=='B')
m++;
else
ans+=m;
}
cout<<ans;
}
int main()
{
fast_io;
fix_prec;
int t=1;
while(t--)
{
solve();
cout<<endl;
}
return 0;
} | #include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <map>
#include <cmath>
#include <iomanip>
#include <set>
#include <sstream>
#include <queue>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int d = 0;
for (int i = 0; i < n; i++) {
if (i == 0) {
d += abs(0-a[i]);
} else {
d += abs(a[i-1]-a[i]);
}
}
d += abs(a[n-1]);
for (int i = 0; i < n; i++) {
if (i == 0) {
cout << d - abs(0-a[i]) - abs(a[i]-a[i+1]) + abs(0-a[i+1]) << endl;
} else {
cout << d - abs(a[i-1]-a[i]) - abs(a[i]-a[i+1]) + abs(a[i-1]-a[i+1]) << endl;
}
}
return 0;
} | 0 | 91,820,860 |
#include <bits/stdc++.h>
#define append push_back
using namespace std;
using ll = long long;
const int N = 1e5 + 3;
const int M = 1e6 + 7;
const long long MOD = 1e9 + 7;
const long long INF = 1e18 + 9;
const int SM = 1e3 + 5;
const int logN = 22, BL = 400;
const double EPS = 1e-9, PI = acos(-1);
const int dx[] = {1, 0, 0, -1, -1, 1, -1, 1};
const int dy[] = {0, 1, -1, 0, -1, 1, 1, -1};
void debug() {
cerr << "\n";
}
template<typename Type1, typename... Type2>
void debug(Type1 a, Type2... b) {
cerr << a << " ";
debug(b...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
map<long long, long long> last;
long long s, j = 0; cin >> s;
last[s] = ++j;
auto f = [&](long long n) {
if(n & 1) return 3 * n + 1;
else return n / 2;
};
long long prev = s, cur;
while(true) {
cur = f(prev);
if(last.find(cur) != last.end()){
return cout << ++j, 0;
}
else {
last[cur] = ++j;
}
prev = cur;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
const double pi=3.14159265358979323846;
int ctoi(const char c) {
if ('0' <= c && c <= '9') return (c - '0');
return -1;
}
vector<int> input(int n) {
vector<int> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec.at(i);
}
return vec;
}
void output(vector<int> vec) {
for (int i = 0; i < vec.size(); i++) {
cout << vec[i] << " ";
}
return;
}
vector<vector<int>> input(int n, int m) {
vector<vector<int>> table(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> table. at(i).at(j);
}
}
return table;
}
void output(vector<vector<int>> table) {
for (int i = 0; i < table.size(); i++) {
for (int j = 0; j < table.at(0).size(); j++) {
cout << table.at(i).at(j) << " ";
}
cout << endl;
}
}
long long perm(int n, int r) {
if (n < r) {
cout << "error" << endl;
return 0;
}
long long perm = 1;
for (int i = n; i > n - r; i--) {
perm *= i;
}
return perm;
}
long long comb(int n, int r) {
if (n < r) {
cout << "error" << endl;
return 0;
}
long long comb = perm(n,r);
for (int i = r; i > 0; i--) {
comb /= i;
}
return comb;
}
long long homo(int n, int r) {
return comb(n + r - 1, n - 1);
}
long long fact(int n) {
long long fact = 1;
for (int i = n; i > 0; i--) {
fact *= i;
}
return fact;
}
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 * b / gcd(a, b);
}
bool isprime(int n){
if (n < 2) return false;
else if (n == 2) return true;
else if (n % 2 == 0) return false;
for (int i = 3; i <= sqrt(n); i += 2){
if (n % i == 0){
return false;
}
}
return true;
}
void sayYes(bool f) {
if (f) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
}
void sayYES(bool f) {
if (f) {
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
}
int main() {
int n,m,ans=0;
cin >> n >> m;
vector<int> l(m);
vector<int> r(m);
for(int i=0;i<m;++i){
cin >> l[i] >> r[i];
}
sort(l.begin(),l.end());
reverse(l.begin(),l.end());
sort(r.begin(),r.end());
if(r[0]-l[0]<0){
cout << 0 << endl;
}else{
cout << r[0]-l[0]+1 << endl;
}
} | 0 | 64,539,572 |
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <fstream>
#include <cassert>
#include <cstring>
#include <unordered_set>
#include <unordered_map>
#include <numeric>
#include <ctime>
#include <bitset>
#include <complex>
#include <chrono>
#include <random>
#include <functional>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int k = 2; k * (k - 1) / 2 <= n; k++) {
if (k * (k - 1) / 2 == n) {
cout << "Yes\n";
cout << k << endl;
vector<vector<int>> ans(k);
int c = 0;
for (int i = 0; i < k; i++) {
for (int j = i + 1; j < k; j++) {
ans[i].push_back(c);
ans[j].push_back(c);
c++;
}
}
for (auto t : ans) {
cout << t.size() << ' ';
for (auto x : t) {
cout << x + 1 << ' ';
}
cout << '\n';
}
return 0;
}
}
cout << "No\n";
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
typedef pair<int, int> P;
ll Mod = 1000000007;
int main() {
int N;
cin >> N;
int P[N];
ll where[N];
ll ans = 0;
for (int i = 0; i < N; i++) {
cin >> P[i];
P[i]--;
where[P[i]] = i;
}
set<int> Set;
Set.insert(-1);
Set.insert(N);
Set.insert(where[N-1]);
for (ll i = N-2; i >= 0; i--) {
auto itr3 = Set.lower_bound(where[i]);
auto itr2 = prev(itr3,1);
if (*itr3 != N) {
auto itr4 = next(itr3,1);
ans += ((ll)*itr4 - (ll)*itr3) * (where[i] - (ll)*itr2) * (i+1);
}
if (*itr2 != -1) {
auto itr1 = prev(itr2,1);
ans += ((ll)*itr2 - (ll)*itr1) * ((ll)*itr3 - where[i]) * (i+1);
}
Set.insert(where[i]);
}
cout << ans << endl;
return 0;
} | 0 | 96,093,684 |
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll x, y;
cin >> x >> y;
int count = 0;
while(true) {
x *= 2;
count++;
if (x > y) break ;
}
cout << count << '\n';
return 0;
} | #include "bits/stdc++.h"
#define rep(i,n) for(int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
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() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
rep(i,n) cin >> a[i];
ll ans = 0;
int cnt = 1;
rep(i,n){
int add = (a[i] - 1) / cnt;
ans += add;
a[i] -= add * cnt;
if(add > 0) a[i] = 1;
if(a[i] == cnt) ++cnt;
}
cout << ans << endl;
return 0;
} | 0 | 41,349,750 |
#include <iostream>
#include <string>
#include <cctype>
using namespace std;
int main(){
string str;
int m, h;
while (1) {
cin >> str;
if (str == "-") {
break;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> h;
string head = str.substr(0, h);
string tail = str.substr(h, str.size() - h);
str = tail + head;
}
cout << str << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (long long i = 0; i < N; i++)
using ll = long long;
void solve(long long W, long long H, long long N, std::vector<long long> x, std::vector<long long> y,
std::vector<long long> a) {
ll minX = 0, minY = 0, maxX = W, maxY = H;
rep(i, N) {
switch (a[i]) {
case 1: minX = max(minX, x[i]); break;
case 2: maxX = min(maxX, x[i]); break;
case 3: minY = max(minY, y[i]); break;
case 4: maxY = min(maxY, y[i]); break;
}
}
if (minX > maxX || minY > maxY) {
cout << 0 << endl;
} else {
cout << (maxX - minX) * (maxY - minY) << endl;
}
}
int main() {
long long W;
scanf("%lld", &W);
long long H;
scanf("%lld", &H);
long long N;
scanf("%lld", &N);
std::vector<long long> x(N);
std::vector<long long> y(N);
std::vector<long long> a(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &x[i]);
scanf("%lld", &y[i]);
scanf("%lld", &a[i]);
}
solve(W, H, N, std::move(x), std::move(y), std::move(a));
return 0;
} | 0 | 82,512,711 |
#include <iostream>
#include <vector>
#include<algorithm>
#include<string>
#include<stdio.h>
#include<map>
#include<math.h>
#include<queue>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int MOD = 1000000007;
const int mod = 1000000007;
const int INF = 1000000000;
const long long LINF = 1e18;
const int MAX = 510000;
int main(){
int a, b;
int ans=-1;
cin >> a >> b;
for (int i = 0; i < 10000000; i++) {
if ((i *8)/100 == a && i /10 == b) {
ans = i; break;
}
}
cout << ans << endl;
return 0;
} | #include<cstdio>
#include<iostream>
#include<ctype.h>
#include<string>
using namespace std;
int main(){
int o = 0;
string s;
cin >> s;
for(int i = 0; i <= s.length(); i++){
if(s[i] == 'o'){
o++;
}
}
if(15 - s.length() >= 8 - o){
cout << "YES" << endl;
}
else{
cout << "NO" << endl;
}
return 0;
} | 0 | 7,093,198 |
#include<bits/stdc++.h>
using namespace std;
static const int64_t mod=1000000007;
int main(){
int N,M;
cin>>N>>M;
vector<int>S(N);
for(int i=0;i<N;i++)
cin>>S.at(i);
vector<int>T(M);
for(int i=0;i<M;i++)
cin>>T.at(i);
vector<vector<int>>dp(1+N,vector<int>(1+M,1));
for(int i=1;i<=N;i++){
for(int j=1;j<=M;j++){
if(S.at(i-1)==T.at(j-1))
dp[i][j]=(dp[i-1][j]+dp[i][j-1])%mod;
else
dp[i][j]=(mod+dp[i-1][j]+dp[i][j-1]-dp[i-1][j-1])%mod;
}
}cout<<dp[N][M]<<endl;
return 0;
} | #include <iostream>
#include <bitset>
#include <fstream>
#include <string>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <algorithm>
#include <numeric>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <functional>
#include <cctype>
#include <list>
#include <limits>
const double EPS = (1e-10);
using namespace std;
using Int = long long;
const Int MOD = 1000000007;
Int mod_pow(Int x, Int n) {
Int res = 1;
while(n > 0) {
if(n & 1) res = (res * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return res;
}
int main(){
cin.tie(0);
int N;
cin >> N;
vector<int> ans;
int sum = 0;
for (int i = 1; i <= N; i++){
sum += i;
ans.push_back(i);
if (sum > N){
ans[sum - N - 1] = -1;
break;
}
if (sum == N){
break;
}
}
for (auto i : ans){
if (i != -1) cout << i << endl;
}
return 0;
} | 0 | 100,702,447 |
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <vector>
#include <cmath>
#define INCANT cin.tie(0), cout.tie(0), ios::sync_with_stdio(0);
#define rep(i,n) for (int i=0; i<n;++i)
#define repll(i,n) for (ll i=0; i<n;++i)
typedef long long ll;
using namespace std;
const ll INF = 1e17;
int n;
ll K;
int P[5001];
ll C[5001];
int main() {
INCANT;
cin >> n >> K;
int a;
rep(i, n) {
cin >> a;
P[i] = a-1;
}
rep(i, n) cin >> C[i];
ll MAX=-INF;
rep(i, n) {
vector<ll> score;
ll circle=0ll;
int p = i;
do {
p = P[p];
score.push_back(C[p]);
circle+=C[p];
} while (p!=i);
ll score_size = score.size();
ll t = 0ll;
repll(j, min(K, score_size)) {
t+=score[j];
ll now = t;
if (circle>0ll) {
ll e = (K-j-1ll)/score_size;
now+=circle*e;
}
MAX=max(now, MAX);
}
}
cout << MAX << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <climits>
#include <cstdio>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int INF = 1e9;
const long long LINF = 1e18;
int main() {
int r;
cin >> r;
cout << r * r << endl;
return 0;
} | 0 | 9,518,674 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define rrep2(ri,x,n) for(int ri = (int)(n-1); ri >= (int)(x); ri--)
#define repit(itr,x) for(auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr,x) for(auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
int main(){
int n;
cin >> n;
vector<int> c(n-1), s(n-1), f(n-1);
rep(i, n-1){
cin >> c.at(i) >> s.at(i) >> f.at(i);
}
rep(i, n){
int pos = i, time = 0;
while(pos != n-1){
if(time <= s.at(pos)){
time = s.at(pos) + c.at(pos);
}else{
int m1 = (time+f.at(pos)-1) / f.at(pos);
time = m1*f.at(pos) + c.at(pos);
}
pos++;
}
cout << time << endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define FOR(i,l,r) for(long long i=(l);i<(r);++i)
#define REP(i,n) FOR(i,0,n)
#define REPS(i,n) FOR(i,1,n+1)
#define int long long
#define mp make_pair
#define pb push_back
#define eb emplace_back
const int MOD=1e9+7;
const int INF=1e18;
signed main(){
int N,K;string S;cin>>N>>K>>S;
vector<int>D;
if(S[0]!='1')D.eb(0);
int ren=0;
REP(i,N-1){
if(S[i]!=S[i+1]){
D.eb(ren+1);
ren=0;
}
else ren++;
}
D.eb(ren+1);
if(S[S.size()-1]!='1')D.eb(0);
int ans=0;
vector<int>SUM(D.size()+1,0);
REP(i,D.size())SUM[i+1]=SUM[i]+D[i];
int left=0;int right=K*2+1;
for(;left<SUM.size();left+=2){
if(right>=SUM.size())right=SUM.size()-1;
ans=max(ans,SUM[right]-SUM[left]);
right+=2;
}
cout<<ans<<endl;
} | 0 | 58,395,781 |
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <vector>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
void print() { std::cout << '\n'; }
template <class T>void print(const T &x) {std::cout << x <<'\n';}
template <class T, class... Args>void print(const T &x, const Args &... args) {std::cout << x << " ";print(args...);}
const string YES = "Yes";
const string NO = "No";
void solve(long long A, long long B, long long C){
if (C >= A && C <= B) print(YES);
else print(NO);
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
long long A;
scanf("%lld",&A);
long long B;
scanf("%lld",&B);
long long C;
scanf("%lld",&C);
solve(A, B, C);
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main(void){
int n,k;
ll ans = -(1LL<<60);
cin >> n >> k;
vector<ll> a(n),s1(n+1,0),s2(n+1,0);
for(int i = 0;i < n;i++){
cin >> a[i];
s1[i+1] = s1[i] + a[i];
if(a[i] >= 0) s2[i+1] = s2[i] + a[i];
else s2[i+1] = s2[i];
}
for(int i = 0;i + k <= n;i++){
int left = i,right = i+k;
ll tmp = (s2[left]-s2[0]) + max(0LL,s1[right]-s1[left]) + (s2[n] - s2[right]);
ans = max(ans,tmp);
}
cout << ans << endl;
return 0;
} | 0 | 2,720,919 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define repit(it, li) for(auto it=li.begin(); it!=li.end(); it++)
using namespace std;
using ll = long long;
using P = pair<ll,int>;
vector<P> factor(ll n){
map<ll, int> ma;
for(ll i=2; i*i<=n; i++){
while(n%i==0){
ma[i]++;
n/=i;
}
}
if(n!=1) ma[n]++;
vector<P> ps;
for(auto p : ma) ps.push_back(p);
return ps;
}
int main(){
ll n;
cin>>n;
auto ps=factor(n);
int m=ps.size();
vector<int> ci(m);
ll mn=LLONG_MAX;
while(1){
ll a=1;
rep(i, m) rep(j, ci[i]) a*=ps[i].first;
ll b=n/a;
mn=min(mn, a+b-2);
bool br=false;
rep(i, m){
ci[i]++;
if(ci[i]>ps[i].second) ci[i]=0;
else break;
if(i==m-1) br=true;
}
if(br) break;
}
cout<<mn<<endl;
return 0;
} | #include <bits/stdc++.h>
#include <string>
#include <vector>
#include <algorithm>
#define rep(i,n) for (int i = 0;i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int INF = 1e9;
int D = 50;
ll calc(ll n){
int j = 0;
ll m = 1;
m <<= D;
ll ret = 0;
for(int i = D;i>=2;i--){
if(m<=n*2){
ret = ret*2 + max(n%m - m/2 + 1,ll(0))%2;
j++;
}
m >>= 1;
}
ret = ret*2 + ((n+1)/2)%2;
return ret;
}
int main(){
ll a,b;cin >> a >> b;
ll c = calc(a-1);
ll d = calc(b);
cout <<(c^d)<<endl;
} | 0 | 7,369,574 |
#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<string>
#include<unordered_map>
#include <iomanip>
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,k
#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 sort(a) sort(a.begin(),a.end())
#define push(a,b) (a).push_back(b)
#define llvec vector<vector<ll>>
#define charvec vector<vector<char>>
#define sizeoof(a,b) (a,vector<ll>(b))
#define llpvec vector<pair<ll,ll>>
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 i,ans=1;rep(i,0,n)ans*=x;return ans;}
ll fact(ll x){ll i,ans=1;rep(i,0,x)ans*=(x-i);return ans;}
ll ncr(ll n,ll r){return fact(n)/fact(r)/fact(n-r);}
ll npr(ll n,ll r){return fact(n)/fact(n-r);}
bool prime(ll a){if(a<=1)return false;ll i;for(i=2;i*i<=a;i++){if(a%i==0)return false;}return true;}
ll ans=0;llfor;
int main(){
string a,b;
cin>>a>>b;
string S="D";
if(a==b) S="H";
cout<<S;
return 0;} | #include <bits/stdc++.h>
#define name "bai3"
#define pii pair<int,int>
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define fto(i,a,b) for(int i=a; i<=b; ++i)
#define maxn 100009
#define ll long long
using namespace std;
const int mod=1e9+7;
int n,a[maxn*2],xd[maxn*2];
ll p[maxn];
int main()
{
cin >> n;
int s=0;
p[0]=1;
fto(i,1,n)p[i]=(p[i-1]*i)%mod;
fto(i,1,n*2){
char c;
cin >> c;
if(c=='B')a[i]=1;
else a[i]=0;
if(a[i]==s){
xd[i]=-1;
}
else{
xd[i]=1;
}
s^=1;
}
int s1=0,s2=0;
ll res=1;
fto(i,1,n*2)
if(xd[i]==1)++s1;
else{
if(s1>s2)res=(res*(s1-s2))%mod;
else res=0;
if(res==0)break;
++s2;
}
if(s1!=s2)res=0;
cout << res*p[n]%mod;
return 0;
} | 0 | 89,657,859 |
#include<cstdio>
#include<iostream>
using namespace std;
const int N=100010;
struct tyc{
int to,next;
}e[4*N];
int head[N],n,m,size=0;
int x,y;
int oh,si,oth;
long long ans;
bool p=0;
bool vis[N],color[N];
void add(int x,int y)
{
size++;
e[size].to=y;
e[size].next=head[x];
head[x]=size;
}
void dfs(int x,int fa)
{
vis[x]=1;
color[x]=color[fa]^1;
for (int i=head[x];i;i=e[i].next)
{
int y=e[i].to;
if (y!=fa)
{
if (vis[y])
{
if (color[x]==color[y]) p=1;
continue;
}
else dfs(y,x);
}
}
return;
}
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=m;i++)
scanf("%d%d",&x,&y),add(x,y),add(y,x);
for (int i=1;i<=n;i++)
{
if (!vis[i])
{
if (head[i]==0) {si++,vis[i]=1;continue;}
p=0;
dfs(i,0);
if (p) oh++;
else oth++;
}
}
ans=2ll*si*n-1ll*si*si+2ll*oth*oth+1ll*oh*oh+2ll*oh*oth;
printf("%lld",ans);
} | #include<iostream>
using namespace std;
int main(){
int d, s;
while (cin>>d){
s = 0;
for (int j = 1; j*d < 600; j++){
s = s + d*d*d*j*j;
}
cout << s << endl;
}
return 0;
} | 0 | 50,167,178 |
#include <stdio.h>
int main()
{
char card[20001];
int maze,i,mvc,j,fc,cm,end=0;
while(1){
cm=0;
while(1){
scanf("%c",&card[cm]);
if(card[0]=='\n'){
continue;
}
if(card[0]=='-'){
goto theend;
}
if(card[cm]=='\n'&&cm!=0){
break;
}
cm++;
}
scanf("%d",&maze);
fc=0;
for(i=0;i<maze;i++){
scanf("%d",&mvc);
for(j=0;j<mvc;j++){
card[fc+cm]=card[fc];
fc++;
}
}
for(i=0;i<cm;i++){
printf("%c",card[fc]);
fc++;
}
printf("%c",'\n');
}
theend:
return 0;
} | #include<stdio.h>
#include<string.h>
int main()
{
int i,j,k,count=0;
char s[100],p[100],a;
scanf("%s",s);
scanf("%s",p);
int lens=strlen(s);
int lenp=strlen(p);
for(i=0;i<=lens;i++){
a=s[0];
for(j=0;j<=lens;j++){
s[j]=s[j+1];
}
s[lens-1]=a;
if(s[0]==p[0]){
for(k=0;k<lenp;k++){
if(s[k]==p[k]){
count++;
}
}
}
if(count==lenp)break;
count=0;
}
if(count==lenp)printf("Yes\n");
else printf("No\n");
return 0;
} | 0 | 7,728,092 |
#include<bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(),(x).end()
const long long mod = 1e9+7;
int main() {
int n; cin >> n;
vector<string> s(n);
vector<int> t(n);
for(int i=0; i<n; i++) cin >> s[i] >> t[i];
string x; cin >> x;
int ans = 0;
bool f = false;
for(int i=0; i<n; i++) {
if (f) ans += t[i];
if (s[i] == x) f = true;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i=0; i < (int)(n); i++)
using ull = unsigned long long;
using ll = long long;
using P = pair<int, int>;
int main() {
int N, C, K;
cin >> N >> C >> K;
vector<int> time(N);
rep(i, N) cin >> time[i];
sort(time.begin(), time.end());
int bus_num = 0, wait_start = 0, wait_people = 0;
rep(i, N) {
if (wait_people > 0 && time[i] - wait_start > K) {
bus_num++;
wait_people = 0;
}
if (wait_people == 0) wait_start = time[i];
wait_people++;
if (wait_people == C) {
bus_num++;
wait_people = 0;
}
}
if (wait_people > 0) bus_num++;
cout << bus_num << endl;
return 0;
} | 0 | 82,490,960 |
#include<iostream>
#include<string>
using namespace std;
int main() {
string res = "";
int a, b;
cin >> a >> b;
if (a > b) {
int temp = a;
a = b;
b = temp;
}
for (int i = 0; i < b; i++) {
res += (a + '0');
}
cout << res << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <ctime>
#include <cstring>
#include <functional>
#include <iostream>
#include <iomanip>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <regex>
#include <vector>
#define fix(n) cout<<fixed<<setprecision(n)
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define all(a) (a).begin(), (a).end()
#define sort(a) sort(all(a))
#define uniq(a) sort(a);(a).erase(unique(all(a)), (a).end())
#define reverse(a) reverse(all(a))
#define ctos(c) string(1, (c))
#define out(d) cout << (d)
#define outl(d) std::cout<<(d)<<"\n"
#define YES() cout << "YES" << endl
#define NO() cout << "NO" << endl
#define Yes() cout << "Yes" << endl
#define No() cout << "No" << endl
#define ceil(x, y) ((x + y - 1) / (y))
#define debug(x) cerr << #x << ": " << (x) << '\n'
#define debug2(x, y) cerr << #x << ": " << (x) << ", " << #y << ": " << (y) << '\n'
#define debug3(x, y, z) cerr << #x << ": " << (x) << ", " << #y << ": " << (y) << ", " << #z << ": " << (z) << '\n'
#define dbg(v) for (size_t _ = 0; _ < v.size(); ++_){ cerr << #v << "[" << _ << "] : " << v[_] << '\n'; }
#define pb push_back
#define fst first
#define int long long
#define INF __LONG_LONG_MAX__
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll,ll>;
const ll MOD = 1000000007;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
void solve() {
ll X, Y, Z, K; cin >> X >> Y >> Z >> K;
vector<ll> a(X), b(Y), c(Z);
rep(i, X) cin >> a[i];
rep(i, Y) cin >> b[i];
rep(i, Z) cin >> c[i];
sort(a); sort(b); sort(c);
vector<ll> v;
for (int i = 1; i <= min(X, K); i++) {
for (int j = 1; j <= Y; j++) {
if (i * j > K) break;
for (int k = 1; k <= Z; k++) {
if (i * j * k > K) break;
v.emplace_back(a[X-i] + b[Y-j] + c[Z-k]);
}
}
}
sort(v);
ll vi = v.size() - 1;
rep(i, K) outl(v[vi-i]);
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
srand((unsigned)time(NULL));
fix(12);
solve();
} | 0 | 22,940,415 |
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i=0;i<n;i++)
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N;
cin>>N;
int count=0;
while(N>=3){
count++;
N-=3;
if(N-3>=3)continue;
else{
count++;
break;
}
}
cout<<count<<endl;
} | #include <iostream>
#include <iomanip>
using namespace std;
constexpr int MAXT = 2 * 101 * 200, MAXV = 2 * 101;
constexpr double inf = 1e9;
double dp[MAXT][MAXV];
int main(){
cin.tie(0); ios_base::sync_with_stdio(false);
int N; cin >> N;
int T[100], V[100];
for(int i=0; i < N; ++i) cin >> T[i];
for(int i=0; i < N; ++i) cin >> V[i];
int cur = 0;
int area_max_v[MAXT];
for(int i=0; i < N; ++i) {
for(int j=cur; j < cur + T[i] * 2; ++j) area_max_v[j] = V[i] * 2;
cur += T[i] * 2;
}
for(int i=0; i < MAXT; ++i) for(int j=0; j < MAXV; ++j) dp[i][j] = -inf;
dp[0][0] = 0;
for(int i=0; i < cur; ++i) {
for(int j=0; j < MAXV; ++j) {
if(dp[i][j] != -inf && j <= area_max_v[i]){
if (j > 0) dp[i + 1][j - 1] = max(dp[i + 1][j - 1], dp[i][j] + j + j - 1);
if (j + 1 <= area_max_v[i]) dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] + j + j + 1);
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j] + j + j);
}
}
}
cout << fixed << setprecision(10) << dp[cur][0] / 8.0 << '\n';
return 0;
} | 0 | 26,612,024 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
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);
}
int main(){
int H,W;
cin >> H >> W;
rep(i,H)rep(j,W){
string S;
cin >> S;
if(S=="snuke") cout << (char)('A'+j) << i+1 << endl;
}
return 0;
} | #include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <stack>
#include <queue>
#include <bitset>
#include <cassert>
#include <iomanip>
#include <ctime>
#include <complex>
using namespace std;
#define FOR(i,b,e) for(int i=(b);i<(e);++i)
#define FORQ(i,b,e) for(int i=(b);i<=(e);++i)
#define FORD(i,b,e) for(int i=(b)-1;i>=(e);--i)
#define REP(x, n) for(int x = 0; x < (n); ++x)
#define ST first
#define ND second
#define PB push_back
#define PF push_front
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double
#define pii pair<int,int>
#define pll pair<LL,LL>
#define vi vector<int>
#define vl vector<LL>
#define vii vector<vi>
#define vll vector<vl>
const double pi = 3.14159265358979323846264;
const int mod=1000000007;
const LL lm=1LL*mod*mod;
int main(){
int n,k;
cin>>n>>k;
vl h(n+1,0);
FOR(i,0,n){
cin>>h[i+1];
}
vll dp(n+2,vl(k+2,lm));
dp[0][0]=0;
FOR(i,0,n+1){
FOR(j,0,k+1){
LL nw=dp[i][j];
FOR(p,0,k-j+1){
if(p+1+i>n+1)break;
if(p+1+i==n+1){
dp[p+1+i][j+p]=min(dp[p+1+i][j+p],nw);
}else{
dp[p+1+i][j+p]=min(dp[p+1+i][j+p],nw+max(0LL,h[p+1+i]-h[i]));
}
}
}
}
LL ans=lm;
FOR(i,0,k+1){
ans=min(ans,dp[n+1][i]);
}
cout<<ans;
} | 0 | 32,710,218 |
#pragma region
#define _USE_MATH_DEFINES
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <list>
#include <iomanip>
#include <cstdint>
#include <bitset>
using namespace std;
typedef long long ll;
#define rep(i, e) for (int(i) = 0; (i) < (e); ++(i))
#define rrep(i, s) for (int(i) = (s) - 1; (i) >= 0; --(i))
#define all(x) x.begin(),x.end()
#pragma region UnionFind
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)];
}
};
#pragma endregion
#pragma region GCD
ll gcd(ll a, ll b)
{
if (b == 0)return a;
return gcd(b, a%b);
}
#pragma endregion
#pragma region LCM
ll lcm(ll a, ll b)
{
return a / gcd(a, b) * b;
}
#pragma endregion
#pragma region chmin
template<class T> inline bool chmin(T& a, T b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
#pragma endregion
#pragma region chmax
template<class T> inline bool chmax(T& a, T b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
#pragma endregion
#pragma endregion
int main()
{
ll n; cin >> n;
vector<ll> div;
for (ll i = 2; i*i <= n; ++i)
{
if (n%i != 0)continue;
div.push_back(i);
if (n / i != i)div.push_back(n / i);
}
if (n != 1)div.push_back(n);
ll res = 0;
for (ll m : div)
{
--m;
if (n / m == n % m)res += m;
}
cout << res << endl;
} | #include <bits/stdc++.h>
#if DEBUG
template <typename T>
void debug(T value) {
std::cerr << value;
}
template <typename T, typename... Ts>
void debug(T value, Ts... args) {
std::cerr << value << ", ";
debug(args...);
}
#define dbg(...) \
do { \
cerr << #__VA_ARGS__ << ": "; \
debug(__VA_ARGS__); \
cerr << " (L" << __LINE__ << ")" << endl; \
} while (0)
#else
#define dbg(...)
#endif
void read_from_cin() {}
template <typename T, typename... Ts>
void read_from_cin(T& value, Ts&... args) {
std::cin >> value;
read_from_cin(args...);
}
#define in(type, ...) \
type __VA_ARGS__; \
read_from_cin(__VA_ARGS__);
template <typename T>
void write_to_cout(const T& value) {
std::cout << value << std::endl;
}
template <typename T, typename... Ts>
void write_to_cout(const T& value, const Ts&... args) {
std::cout << value << ' ';
write_to_cout(args...);
}
#define out(...) write_to_cout(__VA_ARGS__);
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
using ll = long long;
using namespace std;
int main() {
in(ll, n, x);
vector<ll> p(n + 1);
vector<ll> b(n + 1);
p[0] = 1;
rep(i, n) {
p[i + 1] = p[i] * 2 + 1;
b[i + 1] = b[i] * 2 + 2;
}
function<ll(ll, ll)> rec = [&p, &b, &rec](ll n, ll x) {
if (n == 0) return 1LL;
if (x <= 1) return 0LL;
--x;
ll pb = p[n - 1] + b[n - 1];
if (x <= pb) {
return rec(n - 1, x);
}
x -= pb;
ll ps = p[n - 1];
if (x <= 1) {
return x + ps;
}
--x;
++ps;
if (x <= pb) {
return ps + rec(n - 1, x);
}
return ps + p[n - 1];
};
out(rec(n, x));
} | 0 | 47,794,675 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
ll n; cin >> n;
ll arr[n];
for(ll i = 0; i < n; ++i){
cin >> arr[i];
}
ll ans = 1000, x;
for(ll i = 1; i < n; ++i){
if(arr[i] > arr[i - 1]){
x = ans / arr[i - 1];
ans -= (x * arr[i - 1]);
ans += (x * arr[i]);
}
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 1000000007;
typedef long long ll;
typedef unsigned long long ull;
#define FOR(i, start, end) for(uint64_t i=start; i<end; i++)
#define REP(i, n) FOR(i, 0, n)
uint64_t gcd(uint64_t m, uint64_t n) {
uint64_t temp;
while (m % n != 0){
temp = n;
n = m % n;
m = temp;
}
return n;
}
uint64_t lcm(uint64_t m, uint64_t n) {
return (m*n)/gcd(m,n);
}
void comb(vector<vector <uint64_t> > &v){
for(uint64_t i = 0;i <v.size(); i++){
v[i][0]=1;
v[i][i]=1;
}
for(uint64_t k = 1;k <v.size();k++){
for(uint64_t j = 1;j<k;j++){
v[k][j]=(v[k-1][j-1]+v[k-1][j]);
}
}
}
bool is_product_overflow(uint64_t a, uint64_t b) {
uint64_t prod = a * b;
return (prod / b != a);
}
void primeFactorization(uint64_t a, list<uint64_t> &factors){
long i,sq;
if(a%2==0){
factors.push_back(2);
primeFactorization(a/2,factors);
return;
}
sq = sqrt(a);
for(i=3;i<=sq;i+=2){
if(a%i==0){
factors.push_back(i);
primeFactorization(a/i,factors);
return;
}
}
if(a!=1){
factors.push_back(a);
}
}
int64_t modinv(int64_t a, int64_t m) {
int64_t b = m, u = 1, v = 0;
while (b) {
int64_t t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
signed main() {
ll n, m;
cin >> n >> m;
vector< pair<ll,ll> > store(n);
ll a,b;
for(int i=0;i<n;i++){
cin >> a >> b;
store[i] = make_pair(a,b);
}
sort(store.begin(), store.end());
ll purchasedCount = 0;
ll totalCost = 0;
ll storeIdx = 0;
while(purchasedCount<m){
if( (m-purchasedCount)>store[storeIdx].second){
totalCost += store[storeIdx].first*store[storeIdx].second;
purchasedCount += store[storeIdx].second;
}
else{
totalCost += store[storeIdx].first*(m-purchasedCount);
purchasedCount += m-purchasedCount;
}
storeIdx++;
}
cout << totalCost << endl;
return 0;
} | 0 | 41,706,197 |
#include <bits/stdc++.h>
#define endl "\n"
#define pb push_back
#define SZ(x) ((int)(x.size()))
#define FOR(i,s,n) for (ll i = (s); (i) < (n); ++i)
#define FORD(i,s,l) for (ll i = (s); (i) >= l; --i)
#define F first
#define S second
#define TC int __tc; cin >> __tc; FOR(case_num,1,__tc+1)
#define TEST(x,i) ((x)&(1ll<<(i)))
#define SET(x,i) ((x)|(1ll<<(i)))
#define FLIP(x,i) ((x)^(1ll<<(i)))
#define CLEAR(x,i) ((x)&~(1ll<<(i)))
const double pi = 4 * atan(1);
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const int MAXN = 200005;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int a[5];
FOR(i,0,5)
{
cin >> a[i];
}
sort(a, a + 5);
int best = 1000000;
do {
int t = 0;
FOR(i,0,5)
{
t += a[i];
if (i < 4)
while (t % 10 != 0) {
t++;
}
}
best = min(best, t);
} while (next_permutation(a, a + 5));
cout << best << "\n";
} | #include<bits/stdc++.h>
#define ll long long
#define vl vector
#define pb push_back
using namespace std;
int main()
{
ll a,b,i,j,n,k;
cin>>n;
while(n)
{
if(n<100) break;
a=n%10;
if(n%100>=10 && n>100) a=5;
else if(a>5) a-=5;
a+=100;
n-=a;
}
if(n==0) cout<<"1";
else cout<<"0";
} | 0 | 7,592,215 |
#include<bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
typedef long long ll;
#define pb push_back
#define fi first
#define se second
#define ALL(x) (x).begin(),(x).end()
#define RALL(x) (x).rbegin(),(x).rend()
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";}
void Yes() {cout << "Yes" << endl;}
void No() {cout << "No" << endl;}
void YES() {cout << "YES" << endl;}
void NO() {cout << "NO" << endl;}
const double PI=acos(-1);
const ll MOD = 1000000007;
using Graph = vector<vector<int>>;
void solve(){
string s; cin >> s;
ll k; cin >> k;
bool flag = true;
char cc = s[0];
REP(i, s.size()){
if(s[i] != cc) flag = false;
}
if(flag) cout << (s.size()*k)/2 << endl;
else{
ll fr=0, bk=0;
char c1 = s[0];
REP(i, s.size()){
if(s[i] != c1){
break;
}
else{
fr++;
}
}
char c2 = s[s.size()-1];
for(int i=s.size()-1; i>=0; i--){
if(s[i] != c2){
break;
}
else{
bk++;
}
}
ll res = 0;
ll cnt = 0;
char c3 = 'A';
REP(i, s.size()){
if(s[i] != c3){
c3 = s[i];
res += k*(cnt/2);
cnt = 1;
}
else{
cnt++;
if(i == s.size()-1) res += k*(cnt/2);
}
}
if(s[0] == s[s.size()-1]) res -= (k-1)*(fr/2 + bk/2 - (fr+bk)/2);
cout << res << endl;
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
solve();
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
#define rep(i, n) for (int64_t i = 0; i < (int64_t)(n); i++)
#define irep(i, n) for (int64_t i = 0; i <= (int64_t)(n); i++)
#define rrep(i, n) for (int64_t i = (n)-1; i >= 0; i--)
#define rirep(i, n) for (int64_t i = n; i >= 0; i--)
#define chmax(a, b) (a) = max(a, b)
#define chmin(a, b) (a) = min(a, b)
class UFTree {
vector<int> m_parent;
vector<int> m_height;
vector<int> m_size;
public:
UFTree(int size) {
for (int i = 0; i < size; i++) {
m_parent.push_back(i);
m_height.push_back(0);
m_size.push_back(1);
}
}
int root(int node) {
if (m_parent[node] == node) {
return node;
}
return m_parent[node] = root(m_parent[node]);
}
void merge(int n0, int n1) {
int r0 = root(n0), r1 = root(n1);
if (r0 == r1) {
return;
}
if (m_height[r0] < m_height[r1]) swap(r0, r1);
if (m_height[r0] == m_height[r1]) m_height[r0]++;
m_parent[r1] = r0;
m_size[r0] += m_size[r1];
}
int size(int node) { return m_size[root(node)]; }
};
int main() {
int N, K;
cin >> N >> K;
K--;
vector<int> p(N), c(N);
UFTree uft(N);
rep(i, p.size()) {
cin >> p[i];
p[i]--;
uft.merge(i, p[i]);
}
for (auto &elm : c) {
cin >> elm;
}
vector<int64_t> s(N, 0);
rep(i, N) { s[uft.root(i)] += c[i]; }
int64_t result = numeric_limits<int64_t>::min();
rep(i, N) {
int curr = p[i];
int T = uft.size(curr);
int64_t score = c[curr];
int R = K % T;
rep(j, T) {
if (j <= R) {
chmax(result, score + max((int64_t)0, s[uft.root(curr)]) * (K / T));
} else if (K >= T) {
chmax(result, score);
}
curr = p[curr];
score += c[curr];
}
}
cout << result << endl;
return 0;
} | 0 | 14,466,481 |
#pragma GCC optimize("Ofast")
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define PI 3.141592
#define all(a) (a).begin(), (a).end()
int main(){
int N, K;
cin >> N >> K;
vector<int> H(N);
for(int i = 0; i < N; i++) cin >> H[i];
int count = 0;
for(int h : H){
if(h >= K) count++;
}
cout << count << endl;
} | const int LG = 21;
const int FN = 400005;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define fi first
#define se second
#define re return
#define pb push_back
#define uniq(x) sort(all(x)); (x).resize(unique(all(x)) - (x).begin())
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " " << #x << " " << x << endl
#define ln cerr << __LINE__ << endl
#else
#define dbg(x) void(0)
#define ln void(0)
#endif
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Ans[2] = {"No", "Yes"};
string ANS[2] = {"NO", "YES"};
ll inq(ll x, ll y)
{
if (!y) re 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) re l * l % MOD * x % MOD;
re l * l % MOD;
}
ll rev(ll x)
{
return inq(x, MOD - 2);
}
bool __precomputed_combinatorics = 0;
vector<ll> __fact, __ufact, __rev;
void __precompute_combinatorics()
{
__precomputed_combinatorics = 1;
__fact.resize(FN);
__ufact.resize(FN);
__rev.resize(FN);
__rev[1] = 1;
for (int i = 2; i < FN; i++) __rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = 1; i < FN; i++) __fact[i] = __fact[i - 1] * i % MOD, __ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
}
ll fact(int x)
{
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[x];
}
ll cnk(int n, int k)
{
if (k < 0 || k > n) return 0;
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
int Root(int x, vector<int> &root)
{
if (x == root[x]) return x;
return root[x] = Root(root[x], root);
}
void Merge(int v, int u, vector<int> &root, vector<int> &sz)
{
v = Root(v, root), u = Root(u, root);
if (v == u) return;
if (sz[v] < sz[u])
{
sz[u] += sz[v];
root[v] = u;
}
else
{
sz[v] += sz[u];
root[u] = v;
}
}
int ok(int x, int n)
{
return 0 <= x && x < n;
}
void bfs(int v, vi &dist, vector<vi> &graph)
{
fill(all(dist), -1);
dist[v] = 0;
vi q = {v};
for (int i = 0; i < q.size(); i++)
{
for (auto u : graph[q[i]])
{
if (dist[u] == -1)
{
dist[u] = dist[q[i]] + 1;
q.push_back(u);
}
}
}
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
if (k == 1) cout << 0;
else cout << n - k;
} | 0 | 5,049,255 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define REP(i, a, b) for(ll i = a; i <= b; i++)
#define out(x) std::cout << x << '\n'
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define sz(x) ((int)(x).size())
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { ll g = gcd(a, b); return a / g * b; }
const int dx[4] = { 1, 0, -1, 0 };
const int dy[4] = { 0, 1, 0, -1 };
const int INF = (int)1e9;
const ll inf = (ll)1e18;
const int mod = 1000000007;
const int MAX_N = 100010;
const double PI = acos(-1);
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
int n;
cin >> n;
vector<int> a(n);
rep(i, n) {
cin >> a[i];
a[i]--;
}
int cnt = 0;
rep(i, n) {
if (a[a[i]] == i) {
cnt++;
}
}
out(cnt / 2);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)n; ++i)
static const int dx[4] = { 0, 1, 0, -1 };
static const int dy[4] = { 1, 0, -1, 0 };
static const char dir[4] = { 'u', 'r', 'd', 'l' };
static const ll INF = 1 << 21;
static const ll MOD = 1e9 + 7;
int main()
{
cout << fixed << setprecision(20);
int N;
cin >> N;
vector<double> t(N);
vector<double> v(N);
rep(i, N)
{
cin >> t[i];
}
rep(i, N)
{
cin >> v[i];
}
int T = 0;
rep(i, N)
{
T += t[i];
}
vector<double> maxV(2 * T + 1, (double)INF);
int nowT = 0;
rep(i, N)
{
rep(ti, t[i])
{
int t1 = nowT + ti * 2;
int t2 = nowT + ti * 2 + 1;
maxV[t1] = min(maxV[t1], v[i]);
maxV[t2] = min(maxV[t2], v[i]);
}
nowT += t[i] * 2;
maxV[nowT] = min(maxV[nowT], v[i]);
}
maxV[0] = maxV[T * 2] = 0.0;
rep(ti, 2 * T + 1)
{
maxV[ti + 1] = min(maxV[ti + 1], maxV[ti] + 0.5);
}
for (int ti = 2 * T; ti >= 0; --ti) {
maxV[ti] = min(maxV[ti], maxV[ti + 1] + 0.5);
}
double ans = 0.0;
rep(i, 2 * T + 1)
{
ans += (maxV[i] + maxV[i + 1]) * 0.5 / 2.0;
}
cout << ans << endl;
return 0;
} | 0 | 4,019,538 |
#include<cstdio>
#include<iostream>
#include<map>
#include<set>
#include<vector>
#include<cstring>
#include<cassert>
#include<sstream>
#include<cmath>
#include<algorithm>
#include<queue>
#include<limits>
#include<ctime>
#include<stack>
#include<bits/stdc++.h>
#include<string>
#include<stdlib.h>
#include<stdio.h>
typedef long long ll;
using namespace std;
int main(){
int n;
cin>>n;
float a[n],ans;
for(int i=0;i<n;i++){
cin>>a[i];
}
sort(a,a+n);
ans=(a[0]+a[1])/2;
for(int i=2;i<n;i++){
ans=(ans+a[i])/2;
}
cout<<ans;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
vector<pair<int, int>> v1(1e5+1);
vector<pair<int, int>> v2(1e5+1);
for(int i=0; i<n; i++){
int in;
cin>> in;
if(i % 2 == 0){
v1[in].first++;
v1[in].second = in;
}else{
v2[in].first++;
v2[in].second = in;
}
}
sort(v1.begin(), v1.end(), greater<pair<int, int>>());
sort(v2.begin(), v2.end(), greater<pair<int, int>>());
int cnt;
if(v1[0].second != v2[0].second){
cnt = v1[0].first + v2[0].first;
}else{
cnt = max(v1[0].first + v2[1].first, v1[1].first + v2[0].first);
}
cout<< n - cnt <<endl;
return 0;
} | 0 | 56,372,013 |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL MOD = 1e9 + 7;
const int N = 200000 + 10;
char s[N]; int n;
int lef[N];
int main() {
scanf("%d%s", &n,s+1);
if(s[1] == 'W') return !printf("0\n");
lef[1]=1;
for(int i=2;i<=2*n;i++){
if(s[i]==s[i-1]) lef[i]=1^lef[i-1];
else lef[i]=lef[i-1];
}
int cnt=0,ans=1;
for(int i=1;i<=2*n;i++){
if(lef[i]){cnt++;}
else {
ans=1LL*ans*cnt%MOD;
if(cnt==0)return !printf("0\n");
cnt--;
}
}
if(cnt)return !printf("0\n");
for(int i=1;i<=n;i++)ans=1LL*ans*i%MOD;
cout<<ans<<endl;
} | #include "bits/stdc++.h"
#define MOD 1000000007
#define rep(i, n) for(ll i=0; i < (n); i++)
#define rrep(i, n) for(ll i=(n)-1; i >=0; i--)
#define ALL(v) v.begin(),v.end()
#define rALL(v) v.rbegin(),v.rend()
#define FOR(i, j, k) for(ll i=j;i<k;i++)
#define debug_print(var) cerr << #var << "=" << var <<endl;
#define DUMP(i, v)for(ll i=0;i<v.size();i++)cerr<<v[i]<<" "
#define fi first
#define se second
using namespace std;
typedef long long int ll;
typedef vector<ll> llvec;
typedef vector<double> dvec;
typedef pair<ll, ll> P;
typedef long double ld;
struct edge{ll x, c;};
ll mod(ll a, ll mod){
ll res = a%mod;
if(res<0)res=res + mod;
return res;
}
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 modinv(ll a, ll mod){
ll b=mod, u=1, v=0;
while(b){
ll t=a/b;
a-=t*b; swap(a, b);
u-=t*v; swap(u, v);
}
u%=mod;
if(u<0)u+=mod;
return u;
}
ll gcd(ll a, ll b){
ll r = a%b;
if(r==0) return b;
else return gcd(b, a%b);
}
bool is_prime(ll n){
ll i = 2;
if(n==1)return false;
if(n==2)return true;
bool res = true;
while(i*i <n){
if(n%i==0){
res = false;
}
i = i+1;
}
if(n%i==0)res=false;
return res;
}
int main(){
ll N, M;
cin >> N >> M;
ll t = (N-M) * 100 + M * 1900;
cout << t * (1<<M);
return 0;
} | 0 | 6,944,485 |
#include<algorithm>
#include<iostream>
#include<string>
#include<vector>
#include<cmath>
#include<stack>
using namespace std;
int main(){
string s;
while(getline(cin,s),s!="."){
stack<int> a;
for(int i=0;i<s.size();i++){
if(s[i]=='('||s[i]=='['){
a.push(s[i]);
}
else if(s[i]==')'){
if(a.size()>0&&a.top()=='('){
a.pop();
}else{
cout<<"no"<<endl;
goto at;
}
}
else if(s[i]==']'){
if(a.size()>0&&a.top()=='['){
a.pop();
}else{
cout<<"no"<<endl;
goto at;
}
}
}
if(a.size()==0){
cout<<"yes"<<endl;
}else{
cout<<"no"<<endl;
}
at: ;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int minCoins(int coinList[], int n, int value) {
int coins[value+1];
if(value == 0)
return 0;
coins[0] = 0;
for (int i=1; i<=value; i++)
coins[i] = INT_MAX;
for (int i=1; i<=value; i++) {
for (int j=0; j<n; j++)
if (coinList[j] <= i) {
int tempCoins = coins[i-coinList[j]];
if (tempCoins != INT_MAX && tempCoins + 1 < coins[i])
coins[i] = tempCoins + 1;
}
}
return coins[value];
}
int main() {
int coins[100100];
int ind = 0 ;
coins[ind++] = 1;
int value ;
cin >> value;
int ans = 6;
while(ans<=value)
{
coins[ind++] = ans;
ans *= 6 ;
}
ans = 9 ;
while(ans<=value)
{
coins[ind++] = ans;
ans *= 9 ;
}
sort(coins,coins+ind) ;
cout << minCoins(coins, ind, value);
return 0;
} | 0 | 6,431,534 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define rev(i,n) for(int i=n-1;i>=0;i--)
#define all(v) v.begin(),v.end()
#define P pair<int,int>
#define len(s) (int)s.size()
template<class T> inline bool chmin(T &a, T b){
if(a>b){a=b;return true;}
return false;
}
template<class T> inline bool chmax(T &a, T b){
if(a<b){a=b;return true;}
return false;
}
template<class T>inline int cmp(vector<T>&v,T &a){
return lower_bound(all(v),a)-v.begin();
}
constexpr int mod = 1e9+7;
constexpr int inf = 3e18;
int f(int x){
int res=0;
rep(i,50){
int j=x>>(i+1);j--;
int cnt=(1ll<<i)*j;
if(x>>i&1)cnt+=x%(1ll<<i)+1;
if(cnt%2)res+=1ll<<i;
}
return res;
}
signed main(){
int A,B;cin>>A>>B;
cout<<(f(B)^f(A-1))<<"\n";
} | #include <algorithm>
#include <iostream>
#include <iomanip>
#include <cassert>
#include <cstring>
#include <string>
#include <vector>
#include <random>
#include <bitset>
#include <queue>
#include <cmath>
#include <unordered_map>
#include <set>
#include <map>
#define INCANT cin.tie(0), cout.tie(0), ios::sync_with_stdio(0), cout << fixed << setprecision(20);
#define rep(i,n) for (int i=0; i<n;++i)
#define ALL(a) (a).begin(),(a).end()
#define PI 3.14159265358979
typedef long long ll;
using namespace std;
const ll MOD = 1e9+7LL;
const int INF = 2e9;
int N;
string s;
vector<int> B;
int main() {
INCANT;
cin >> s;
int N = s.size();
rep(i, N) if (s[i]!='x') B.push_back(i);
int b =B.size();
rep(i, b/2) {
if (s[B[i]] != s[B[b-1-i]]) {
cout << -1 << "\n";
return 0;
}
}
int left = 0;
int right = N-1;
int ans = 0;
rep(i, b/2) {
int tmp = abs((B[i]-left) - (right-B[b-1-i]));
ans+=tmp;
left = B[i];
right = B[b-1-i];
}
if (b%2==1) ans+=abs((B[b/2]-left)- (right-B[b/2]));
cout << ans << "\n";
return 0;
} | 0 | 8,183,065 |
#include<bits/stdc++.h>
using namespace std;
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cout<<fixed; cout<<setprecision(12);
#define randomINT mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#define newl cout<<"\n"
#define DISP(as) for(auto it : as) cout<<it<<" ";newl;
#define all(x) (x).begin(),(x).end()
#define mset(x,val) memset(x,val,sizeof(x))
#define newl cout<<"\n"
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define dline cerr<<"
#define deb1(x) cerr<<#x<<" = "<<x<<'\n';
#define deb2(x,y) cerr<<'['<<#x<<','<<#y<<"] = "<<'['<<x<<','<<y<<']'<<'\n';
#define deb3(x,y,z) cerr<<'['<<#x<<','<<#y<<','<<#z<<"] = "<<'['<<x<<','<<y<<','<<z<<']'<<'\n';
#define N 1000000007
typedef long long ll;
typedef long double ld;
typedef vector<ll> vll;
typedef pair<ll , ll> pll;
typedef pair<ld, ld> pld;
typedef unordered_map<ll, ll> um;
typedef vector<pll> vpll;
const ll MAX5 = 1e+5 + 7;
const ll MAX7 = 1e+7 + 7;
const ll MAXN = MAX7;
const ll INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
const ll MOD = 1e9 + 7;
ll T = 1;
ll n, x, k, m, y, q ;
string s, t, d;
ld w;
void MAIN() {
cin>>n;
set<ll> val;
for(ll i=0;i<n;i++) {
cin>>x;
val.insert(x);
}
if(val.size() == n) {
cout<<"YES";
}
else {
cout<<"NO";
}
}
int main() {
fastio; randomINT;
while (T--) {
MAIN();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF (2e9)
int main() {
ll ans = 0;
ll n, p; cin >> n >> p;
string s; cin >> s;
if(10 % p == 0) {
for(int i = s.length() - 1; i >= 0; i--) {
if((s[i]-'0') % p == 0) ans += i + 1;
}
cout << ans << endl;
return 0;
}
vector<ll> sum(n+1);
ll ten = 1;
for(int i = n - 1; i >= 0; i--) {
ll a = (s[i]-'0') * ten % p;
sum[i] = (sum[i+1] + a) % p;
ten *= 10; ten %= p;
}
vector<ll> cnt(p);
for(int i = n; i >= 0; i--) {
cnt[sum[i]]++;
}
for(auto i = cnt.begin(); i != cnt.end(); i++) {
ans += *i * (*i - 1) / 2;
}
cout << ans << endl;
return 0;
} | 0 | 37,356,700 |
#include <iostream>
using namespace std;
int main(){
int a[110],n;
cin >> n;
for(int i = 0; i < n ; i++){
cin >> a[i];
}
int ans = 0;
for(int i = 0; i < n; i++){
int min = i;
for(int j = i; j < n; j++){
if(a[j] < a[min]) min = j;
}
if(i != min){
int tmp = a[i];
a[i] = a[min];
a[min] = tmp;
ans++;
}
}
for(int i = 0; i < n; i++){
if(i != n-1) cout << a[i] << " ";
else cout << a[i] <<endl;
}
cout <<ans<<endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
#define ll long long
#define hcf __gcd
bool is_prime(ll n){
if(n==2) 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 main(void){
ios::sync_with_stdio(0); cin.tie(0);
#ifndef ONLINE_JUDGE
freopen ("C:\\Users\\Animesh\\Desktop\\i.txt", "r", stdin);
#endif
int n; cin>>n;
int l; cin>>l;
vector<string> s(n); for(auto& it:s) cin>>it;
sort(s.begin(),s.end());
for(auto it:s)
cout<<it;
return 0;
} | 0 | 19,482,016 |
#include <bits/stdc++.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <math.h>
#include <map>
#include <bitset>
#include <cmath>
#include <set>
#define INF 1000000000000
#define MOD 1000000007
using namespace std;
typedef long long ll;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
int main(){
string o,e;
cin >> o >> e;
string ans;
if(o.size() > e.size()){
int i=0;
while(i < e.size()){
ans += o.at(i);
ans += e.at(i);
i++;
}
ans += o.at(i);
}else{
int i = 0;
while(i < o.size()){
ans += o.at(i);
ans += e.at(i);
i++;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)n;i++)
int main() {
int W,H,N,x,y,a; cin>>W>>H>>N;
int ans[W][H]={0};
for(int i=0; i<N; i++){
cin>>x>>y>>a;
if(a==1){
for(int j=0; j<x; j++){
for(int k=0; k<H; k++) ans[j][k]=1;
}
}
else if(a==2){
for(int j=x; j<W; j++){
for(int k=0; k<H; k++) ans[j][k]=1;
}
}
else if(a==3){
for(int j=0; j<W; j++){
for(int k=0; k<y; k++) ans[j][k]=1;
}
}
else{
for(int j=0; j<W; j++){
for(int k=y; k<H; k++) ans[j][k]=1;
}
}
}
int cnt=0;
rep(i,W){
rep(j,H) if(!ans[i][j]==1) cnt++;
}
cout<<cnt;
} | 0 | 62,452,962 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0;i < (n);i++)
using namespace std;
using ll = long long;
using pii = pair<int,int>;
int main(){
int n;
cin >> n;
map<ll,int> mp;
vector<ll> a(n);
rep(i,n)cin >> a[i];
ll x = -1,y = 0;
sort(a.rbegin(),a.rend());
rep(i,n-1){
if(a[i] != a[i+1]) continue;
if(x == -1){
x = a[i];
i++;
}
else{
y = a[i];
break;
}
}
ll ans = x*y;
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
#define arep(i,x,n) for(int i=int(x);i<(int)(n);i++)
#define rep(i,n) for(long long i = 0;i < n;++i)
#define pi 3.141592653589793
#define eps 0.00000001
#define INF 1e9+7
using ll = long long;
using P = pair<int, int>;
using lP = pair<ll, ll>;
using fP = pair<double, double>;
int n;
vector<vector<int>>ans;
void dfs(vector<int> A) {
if (A.size() == n + 1) {
ans.push_back(A);
return;
}
A.push_back(0);
while (A.back() <= 3) {
dfs(A);
A.back()++;
}
}
int main() {
vector<int>t(3);
cin >> n;
rep(i, 3)cin >> t[i];
vector<int>l(n);
rep(i, n)cin >> l[i];
dfs(vector<int>(1, 0));
int res = INF;
rep(i, 1 << (2 * n)) {
vector<int>now = ans[i];
vector<int>abc(3);
int sum = 0;
arep(j, 1, n + 1) {
if (now[j] == 3)continue;
abc[now[j]] += l[j - 1];
sum += 10;
}
if (abc[0] == 0 || abc[1] == 0 || abc[2] == 0)continue;
sum -= 30;
int a = abs(t[0] - abc[0]);
int b = abs(t[1] - abc[1]);
int c = abs(t[2] - abc[2]);
res = min(res, sum+a + b + c);
}
cout << res << endl;
return 0;
} | 0 | 14,717,776 |
#include<bits/stdc++.h>
#include <array>
using namespace std;
#define rep(i, n) for(int i = 0; i < (n); i++)
using LL = long long;
using ULL = unsigned long long;
void solve() {
int n; cin >> n;
int pp[40000]; rep(i, n) { int p; cin >> p; pp[p-1] = i; }
for (int i = 0; i < n; i++) {
if (i != 0) cout << " ";
cout << n * i + pp[i] + 1;
}cout << endl;
for (int i = 0; i < n; i++) {
if (i != 0) cout << " ";
cout << n * (n - i);
}cout << endl;
}
int main() {
solve();
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 _ << " " <<
#define sz(x) ((int) x.size())
#define pb(x) push_back(x)
#define TRACE(x) cerr << #x << " = " << x << endl
typedef long long ll;
typedef pair<int, int> point;
const int MAXN = 1e3 + 5;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const char smjer[4] = {'R', 'U', 'L', 'D'};
int n;
ll X[MAXN], Y[MAXN], pot[MAXN];
void done(){
cout << -1;
exit(0);
}
int main(){
ios_base::sync_with_stdio(false); cin.tie(0);
pot[0] = 1;
FOR(i, 1, 35)
pot[i] = pot[i - 1] * 2;
cin >> n;
REP(i, n)
cin >> X[i] >> Y[i];
int par = (abs(X[0]) + abs(Y[0])) % 2;
FOR(i, 1, n){
if( (abs(X[i]) + abs(Y[i])) % 2 != par )
done();
}
if(par == 0){
REP(i, n)
X[i] ++;
}
par = !par;
cout << 31 + par << "\n";
for(int i = 30; i >= 0; --i)
cout << pot[i] << " ";
if(par)
cout << 1;
cout << "\n";
REP(i, n){
int x = 0, y = 0;
for(int j = 30; j >= 0; --j){
REP(k, 4){
ll nx = x + dx[k] * pot[j];
ll ny = y + dy[k] * pot[j];
if( abs(nx - X[i]) + abs(ny - Y[i]) < pot[j] ){
x = nx;
y = ny;
cout << smjer[k];
break;
}
}
}
if(par) cout << 'L';
cout << "\n";
}
} | 0 | 46,059,384 |
const bool DEBUG = 1;
#include <iostream>
#include <vector>
#include <array>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <complex>
#include <random>
#include <iomanip>
#include <stdio.h>
#include <sys/time.h>
#include <cassert>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> IP;
typedef pair<P, P> PP;
typedef pair<int, PP> IPP;
typedef vector<int> VI;
typedef vector<P> VP;
#define omajinai ios::sync_with_stdio(false);cin.tie(0)
#define FOR(i,a,b) for(int i=(a);i<int(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RFOR(i,a,b) for(int i=(b)-1;i>=int(a);--i)
#define RREP(i,n) RFOR(i,0,n)
#define LFOR(i,a,b) for(ll i=(a);i<(b);++i)
#define LREP(i,n) LFOR(i,0,n)
#define LRFOR(i,a,b) for(ll i=(b)-1;i>=(a);--i)
#define LRREP(i,b,a) LRFOR(i,0,n)
#define ALL(a) (a).begin(),(a).end()
#define UNIQUE(a) (a).erase(unique((a).begin(),(a).end()),(a).end())
#define MP make_pair
#define PB push_back
#define EACH(i,c) REP(i,(int)(c).size())
#define REACH(i,c) RREP(i,(int)(c).size())
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define BR cout << "\n"
#define dump(x) if(DEBUG)cerr<<"[" << __LINE__ << "] "<<#x<<"="<<(x)<<"\n"
#define dump2(x,y) if(DEBUG)cerr<<"["<<__LINE__<< "] "<<#x<<"="<<(x)\
<<" , "<<#y<<"="<<(y)<<"\n"
#define dump3(x,y,z) if(DEBUG)cerr<<"["<<__LINE__<< "] "<<#x<<"="<<(x)\
<<" , "<<#y<<"="<<(y)<<"\n"\
<<" , "<<#z<<"="<<(z)<<"\n"
#define SAY(x) if(DEBUG) cerr << "[" << __LINE__ << "] " << (x) << "\n"
const int INF = 1e9;
const ll LINF = 1e18;
const int MOD = 1e9+7;
ll ans;
int main() {
omajinai;
ll w,h;cin>>w>>h;
VP v;
REP(i,w){
int p;
cin>>p;
v.PB(P(p, 0));
}
REP(i,h){
int p;
cin>>p;
v.PB(P(p, 1));
}
SORT(v);
int c[] = {0,0};
ll ans = 0;
for(auto e:v){
int x = e.first, f = e.second;
ans += (ll)x * ((f ? w+1 : h+1) - c[f]);
c[!f]++;
}
cout << ans;
} | #include<bits/stdc++.h>
#define mo 1000000007
using namespace std;
long long read(){
long long xx=0,flagg=1;
char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-')
ch=getchar();
if(ch=='-'){
flagg=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9'){
xx=xx*10+ch-'0';
ch=getchar();
}
return xx*flagg;
}
void pus(long long xx,long long flagg){
if(xx<0){
putchar('-');
xx=-xx;
}
if(xx>=10)
pus(xx/10,0);
putchar(xx%10+'0');
if(flagg==1)
putchar(' ');
if(flagg==2)
putchar('\n');
return;
}
long long ksm(long long u,long long v){
long long o=1;
while(v){
if(v&1)
o=o*u%mo;
u=u*u%mo;
v>>=1;
}
return o;
}
long long n,l,t,i,x[100005],d[100005],cnt,sum;
int main(){
n=read();l=read();t=read();
for(i=1;i<=n;i++){
x[i]=read();
d[i]=read();
if(d[i]==2)
d[i]=-1;
}
for(i=1;i<=n;i++){
sum=x[i]+d[i]*t;
if(sum>=0)
cnt=(cnt+sum/l)%n;
else
cnt=(cnt+(sum+1)/l-1+n)%n;
x[i]=(sum%l+l)%l;
}
sort(x+1,x+n+1);
for(i=cnt+1;i<=n;i++)
pus(x[i],2);
for(i=1;i<=cnt;i++)
pus(x[i],2);
return 0;
} | 0 | 10,086,555 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define rep(i,n) for (int i=0;i<n;i++)
int main(){
int n;
cin >> n;
vector<int> l(n);
vector<int> r(n);
rep(i,n) cin >> l.at(i) >> r.at(i);
int ans=0;
rep(i,n) ans += 1 + r[i] - l[i];
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
typedef vector<ll> Vec;
typedef vector<int> Vi;
typedef vector<string> Vs;
typedef vector<P> VP;
typedef vector<vector<ll>> VV;
typedef vector<vector<int>> VVi;
#define REP(i, a, b) for(ll i=(a); i<(b); i++)
#define PER(i, a, b) for(ll i=(a); i>=(b); i--)
#define rep(i, n) REP(i, 0, n)
#define per(i, n) PER(i, n, 0)
const ll INF=1e18+18;
const ll MAX=100005;
const ll MOD=1000000007;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define YES(n) cout << ((n) ? "YES" : "NO") << endl;
#define ALL(v) v.begin(), v.end()
#define rALL(v) v.rbegin(), v.rend()
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a,b)
#define Each(a,b) for(auto &a :b)
#define REPM(i, mp) for (auto i = mp.begin(); i != mp.end(); ++i)
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define dbgmap(mp) cerr << #mp << ":"<<endl; for (auto i = mp.begin(); i != mp.end(); ++i) { cerr << i->first <<":"<<i->second << endl;}
#define dbgarr(n,m,arr) rep(i,n){rep(j,m){cerr<<arr[i][j]<<" ";}cerr<<endl;}
#define dbgdp(n,arr) rep(i,n){cerr<<arr[i]<<" ";}cerr<<endl;
#define dbgmint(n,arr) rep(i,n){cerr<<arr[i].x<<" ";}cerr<<endl;
#define Uniq(v) v.erase(unique(v.begin(), v.end()), v.end())
#define fi first
#define se second
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return true; } return false; }
template<typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) { return s<<"("<<p.first<<", "<<p.second<<")"; }
template<typename T>istream& operator>>(istream&i,vector<T>&v)
{rep(j,v.size())i>>v[j];return i;}
template<typename T>
ostream &operator<<(ostream &s, const vector<T> &v) {
int len=v.size();
for(int i=0; i<len; ++i) {
s<<v[i];
if(i<len-1) s<<" ";
}
return s;
}
template<typename T>
ostream &operator<<(ostream &s, const vector<vector<T> > &vv) {
int len=vv.size();
for(int i=0; i<len; ++i) {
s<<vv[i]<<endl;
}
return s;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout<<std::setprecision(10);
ll h,w;
cin>>h>>w;
if(h%3==0||w%3==0){
cout<<0<<endl;
return 0;
}
ll ans=INF;
rep(j,2){
if(j==1)swap(h,w);
REP(x,1,w){
Vec v(3);
v[0] = x*h;
if((w-x)%2==0){
v[1] = v[2] = h*(w-x)/2;
}else{
v[1] = (w-x)*(h/2);
v[2] = (w-x)*(h-h/2);
}
sort(ALL(v));
chmin(ans,v[2]-v[0]);
}
}
cout<<ans<<endl;
return 0;
} | 0 | 41,901,471 |
#include <stdio.h>
int kuadrat(int a, int b)
{
int total = 1;
while(b > 0){
total *= a;
b--;
}
return total;
}
int main()
{
int cases;
scanf("%d", &cases);
long long int arr[cases], total = 1;
int i = 0;
char temp;
do
{
scanf("%lld%c", &arr[i], &temp);
if(arr[i] == 0){
printf("0");
return 0;
}
i++;
} while (temp != '\n');
for(int j = 0; j < cases; j++){
if (total > 1000000000000000000 / arr[j])
{
printf("-1");
return 0;
}
else
{
total *= arr[j];
}
}
printf("%lld", total);
return 0;
} | #include<iostream>
#include<map>
#include<string>
using namespace std;
string lowen(string str)
{
for(int i=0; i<str.size(); i++)
{
if('A'<=str[i] && 'Z'>=str[i])
str[i] += 'a'-'A';
}
return str;
}
int main(void)
{
string str;
int mode = 0;
string modest = "";
string longest = "";
map<string,int> dic;
while(cin >> str)
{
str = lowen(str);
if(dic.count(str))
{
dic[str]++;
if(mode < dic[str])
{
mode = dic[str];
modest = str;
}
}
else
{
dic.insert( map<string,int>::value_type(str,1) );
if(longest.size() < str.size())
longest = str;
}
}
cout << modest << " " << longest << endl;
return 0;
} | 0 | 55,833,442 |
#include <utility>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
const int VALUES = 10000;
int A[VALUES], B[VALUES], C = 0;
while (true)
{
cin >> A[C] >> B[C];
if (A[C] == 0 && B[C] == 0) { goto Exit; }
if (A[C] > B[C]) { swap(A[C], B[C]); }
C++;
}
Exit:;
for (int i = 0; i < C; i++)
{
cout << A[i] << ' ' << B[i] << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const ll INF = 1LL << 60;
const int MAX = 1000000010;
const ll MOD = 1000000007;
int main() {
int N; cin >> N;
map<ll, int> m;
for (int i = 0; i < N; i++) {
ll a; scanf("%lld", &a);
m[a * (-1)]++;
}
ll ans = 0;
bool flag = false;
for (auto p : m) {
ll a = p.first * (-1);
int num = p.second;
if (flag) {
if (num > 1) {
ans *= a;
break;
}
} else {
if (num > 1) {
if (num > 3) {
ans = a * a;
break;
}
ans = a;
flag = true;
}
}
}
cout << ans << endl;
return 0;
} | 0 | 63,210,983 |
#include <iostream>
#include <iomanip>
using namespace std;
int main (int argc, char **argv) {
long a, b;
cin >> a >> b;
long d, r;
double f;
d = a / b;
r = a % b;
f = (double)a / (double)b;
cout << d << " " << r << " " << fixed << setprecision(5)<< f << endl;
} | #include <algorithm>
#include <iostream>
#include <limits>
#include <math.h>
#include <tuple>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include "string.h"
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <set>
using namespace std;
using intll_t = long long;
int main() {
int N;
scanf("%d", &N);
vector<int> AIS;
AIS.reserve(N);
for (int i = 0; i < N; i++) {
int AI;
scanf("%d", &AI);
AIS.push_back(AI);
}
vector<int> c(10001, 0);
for (int number : AIS) {
c[number]++;
}
for (int i = 1; i < c.size(); i++) {
c[i] += c[i-1];
}
vector<int> out(N, 0);
for (int j = N - 1; j >= 0; j--) {
int number = AIS[j];
int& cntAtMostNumber = c[number];
out[cntAtMostNumber - 1] = number;
cntAtMostNumber--;
}
auto outIt = out.begin();
while (true) {
printf("%d", *outIt);
++outIt;
if (outIt == out.end()) {
break;
} else {
printf(" ");
}
}
printf("\n");
return 0;
} | 0 | 96,422,801 |
#include <bits/stdc++.h>
using namespace std;
#define _overload3(_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(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 1LL<<60;
ll gcd(ll a, ll b) {
if(b == 0) return a;
return gcd(b, a % b);
}
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
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;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int ind = -1;
int n;
cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
ll suma = 0;
rep(i, n-1){
suma += a[i];
if(2*suma < a[i+1]){
ind = i;
}
}
cout << n - ind - 1 << 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> ;
const int INF = 1e9;
const int MOD = 1000000007;
int main(){
int n;
cin >> n;
vector<string> s(n);
rep(i,n) cin >> s[i];
int A = 0,B = 0;
int AB = 0;
bool ok = false;
rep(i,n){
rep(j,s[i].size()-1){
if(s[i][j] == 'A' && s[i][j+1] == 'B'){
++AB;
}
}
if(s[i][0] == 'B' && s[i].back() == 'A'){
++A;++B;
}else if(s[i][0] == 'B'){
++B;ok = true;
}else if(s[i].back() == 'A'){
++A;ok = true;
}
}
if(ok) cout << AB + min(A,B) << endl;
else cout << AB + (min(A,B)==0 ? 0 : min(A,B)-1) << endl;
return 0;
} | 0 | 60,273,175 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef double db;
typedef string str;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
#define pb push_back
#define f first
#define s second
#define all(x) x.begin(), x.end()
#define endl '\n'
const ll MOD = 1000000007;
int main() {
int n; scanf("%d", &n);
vector<int> a(n);
for (int &i : a)
scanf("%d", &i);
int m = *max_element(all(a));
vector<int> check(m + 1);
for (int i : a)
check[i]++;
int ans = 0;
for (int i = 1; i <= m; i++) {
if (check[i] >= 1) {
if (check[i] == 1) ans++;
for (int j = 2 * i; j <= m; j += i)
check[j] = 0;
}
}
printf("%d", ans);
return 0;
} | #ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;
typedef long double ld;
#define REP(i,n) for(ll i=0; i<(n); i++)
#define REPR(i, n) for(ll i = n;i >= 0;i--)
#define FOR(i, m, n) for(ll i = m;i < n;i++)
#define ALL(n) begin(n),end(n)
#define IN(a, x, b) (a<=x && x<b)
#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);
template<class T> inline T CHMAX(T & a, const T b) { return a = (a < b) ? b : a; }
template<class T> inline T CHMIN(T & a, const T b) { return a = (a > b) ? b : a; }
const long double EPS = 1e-10;
const long long INF = 1e18;
const long double PI = acos(-1.0L);
const long long MOD = 1000000007;
int main(void){
ll n;
ll k;
ll s;
cin >> n >> k >> s;
if(s == 1000000000){
REP(i,k){
cout << 1000000000 << " " ;
}
for(ll i=0; i<n-k; i++){
cout << 1 << " " ;
}
cout << endl;
}else{
REP(i,k){
cout << s << " " ;
}
for(ll i=0; i<n-k; i++){
cout << 1000000000 << " " ;
}
cout << endl;
}
return 0;
} | 0 | 98,094,801 |
#include <iostream>
#include <algorithm>
#include <cmath>
#define INF 1000000000
using namespace std;
int ary[5010],fn[80],ff[80],fl[80],fr[80];
int main(){
int N;
while(true){
cin>>N;
if(N==0) break;
for(int i=0;i<N;i++){
cin>>ary[i];
}
int NN=sqrt(N),NNN=(N-1)/NN+1,cnt,hog,hog2;
for(int i=0;i<NNN;i++){
hog=hog2=-INF;
for(int j=NN*i;j<min(NN*(i+1),N);j++){
for(int k=j;k<min(NN*(i+1),N);k++){
cnt=0;
for(int l=j;l<=k;l++){
cnt+=ary[l];
}
hog=max(hog,cnt);
if(k==min(N,NN*(i+1))-1) hog2=max(hog2,cnt);
if(j==NN*i&&k==min(N,NN*(i+1))-1) ff[i]=cnt;
}
if(j==NN*i) fl[i]=hog;
}
fn[i]=hog;
fr[i]=hog2;
}
int res=-INF;
for(int i=0;i<NNN;i++){
res=max(res,fn[i]);
for(int j=i+1;j<NNN;j++){
hog=0;
cnt=fr[i]+fl[j];
for(int k=i+1;k<j;k++){
cnt+=ff[k];
}
res=max(res,cnt);
}
}
cout<<res<<endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> p;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<int> a(M);
vector<int> b(M);
vector<int> c(M);
for(int i = 0; i < M; i++) {
cin >> a[i] >> b[i] >> c[i];
a[i]--;
b[i]--;
}
vector<vector<int> > v(N, vector<int>(N, 10000000));
for(int i = 0; i < M; i++) {
v[a[i]][b[i]] = c[i];
v[b[i]][a[i]] = c[i];
}
for(int i = 0; i < N; i++) {
for(int j = 0; j < N; j++) {
for(int k = 0; k < N; k++) {
v[j][k] = min(v[j][k], v[j][i] + v[i][k]);
}
}
}
int ans = 0;
for(int i = 0; i < M; i++) {
if(v[a[i]][b[i]] != c[i]) ans++;
}
cout << ans << endl;
} | 0 | 75,248,407 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
ll a;
unordered_set<ll> st;
rep(i, 4) cin >> a, st.insert(a);
cout << ((st.count(1) && st.count(7) && st.count(9) && st.count(4)) ? "YES"
: "NO")
<< 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);
string n;
cin >> n;
rep(i,n.size()){
if(n[i]=='9') n[i] = '1';
else n[i] = '9';
}
cout << n << endl;
return 0;
} | 0 | 66,980,438 |
#include <stdio.h>
int main () {
int a[3][3];
int count = 0;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
scanf("%d", &a[i][j]);
}
}
int n, m, b[3][3];
scanf("%d", &n);
for ( int i = 0; i < n; i++) {
scanf("%d", &m);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (a[i][j] == m) {
b[i][j] = 1;
}
}
}
}
if (b[0][0]+ b[1][1]+ b[2][2] == 3 || b[0][2]+ b[1][1]+ b[2][0] == 3) {
printf("Yes\n");
return 0;
}
for(int i = 0; i < 3; i++) {
if(b[i][0]+ b[i][1]+ b[i][2] == 3 || b[0][i]+ b[1][i]+ b[2][i] == 3) {
printf("Yes\n");
return 0;
}
}
printf("No\n");
return 0;
} | #include <bits/stdc++.h>
int N = 1e6, SZ = 320, INF = 1 << 29;
long long LINF = (1LL << 60), mod = 1e9 + 7;
const long double eps = 1e-8, PI = acos(-1.0);
#define lowbit(x) (x & (-(x)))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
typedef complex<double> cpx;
char READ_DATA;
int SIGNAL_INPUT;
inline int dcmp(double x, double y = 0.0)
{
return abs(x - y) < eps;
}
template <typename Type>
inline Type ru(Type &v)
{
SIGNAL_INPUT = 1;
while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
if (READ_DATA == '-')
SIGNAL_INPUT = -1;
else if (READ_DATA == EOF)
return EOF;
v = READ_DATA - '0';
while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9')
v = v * 10 + READ_DATA - '0';
v *= SIGNAL_INPUT;
return v;
}
inline ll modru(ll &v)
{
ll p = 0;
SIGNAL_INPUT = 1;
while ((READ_DATA = getchar()) < '0' || READ_DATA > '9')
if (READ_DATA == '-')
SIGNAL_INPUT = -1;
else if (READ_DATA == EOF)
return EOF;
p = v = READ_DATA - '0';
while ((READ_DATA = getchar()) >= '0' && READ_DATA <= '9')
{
v = (v * 10 + READ_DATA - '0') % mod;
p = (p * 10 + READ_DATA - '0') % (mod - 1);
}
v *= SIGNAL_INPUT;
return p;
}
template <typename A, typename B>
inline int ru(A &x, B &y)
{
if (ru(x) == EOF)
return EOF;
ru(y);
return 2;
}
template <typename A, typename B, typename C>
inline int ru(A &x, B &y, C &z)
{
if (ru(x) == EOF)
return EOF;
ru(y);
ru(z);
return 3;
}
template <typename A, typename B, typename C, typename D>
inline int ru(A &x, B &y, C &z, D &w)
{
if (ru(x) == EOF)
return EOF;
ru(y);
ru(z);
ru(w);
return 4;
}
inline ll gcd(ll a, ll b)
{
while (b)
{
a %= b;
swap(a, b);
}
return a;
}
inline ll ss(ll a, ll b)
{
ll ans = 1;
while (b)
{
if (b & 1)
(ans *= a) %= mod;
(a *= a) %= mod;
b >>= 1;
}
return ans;
}
template <typename Type>
void brc(Type *a, int n)
{
int k;
for (int i = 1, j = n / 2; i < n - 1; i++)
{
if (i < j)
swap(a[i], a[j]);
k = n >> 1;
while (j >= k)
{
j ^= k;
k >>= 1;
}
if (j < k)
j ^= k;
}
}
void fft(cpx *a, int n, int inv = 1)
{
cpx u, t;
brc(a, n);
for (int h = 2; h <= n; h <<= 1)
{
cpx wn(cos(inv * 2.0 * PI / h), sin(inv * 2.0 * PI / h));
for (int j = 0; j < n; j += h)
{
cpx w(1, 0);
for (int k = j; k < j + (h >> 1); k++)
{
u = a[k];
t = w * a[k + (h >> 1)];
a[k] = u + t;
a[k + (h >> 1)] = u - t;
w *= wn;
}
}
}
if (inv == -1)
for (int i = 0; i < n; i++)
{
a[i] /= n;
}
}
void ntt(ll *a, int n, int inv = 1)
{
ll u, t;
brc(a, n);
for (int h = 2; h <= n; h <<= 1)
{
ll wn = ss(3, (mod - 1) / h);
if (inv == -1)
wn = ss(wn, mod - 2);
for (int j = 0; j < n; j += h)
{
ll w = 1;
for (int k = j; k < j + (h >> 1); k++)
{
u = a[k];
t = w * a[k + (h >> 1)] % mod;
a[k] = (u + t) % mod;
a[k + (h >> 1)] = (u - t + mod) % mod;
(w *= wn) %= mod;
}
}
}
if (inv == -1)
{
ll tmp = ss(n, mod - 2);
for (int i = 0; i < n; i++)
(a[i] *= tmp) %= mod;
}
}
struct Edge
{
int u, v, nxt;
ll w;
Edge(int _u = 0, int _v = 0, ll _w = 0, int _nxt = -1)
{
u = _u;
v = _v;
w = _w;
nxt = _nxt;
}
int operator<(const Edge &b) const
{
return u < b.u;
}
};
const int maxn = 1e6 + 5;
int n,id[maxn],cnt[maxn];
vector<pii> ans;
ll d[maxn],dis[maxn];
map<ll,vector<int> > f;
int cmp(const int &i,const int &j)
{
return d[i]>d[j];
}
int main()
{
ru(n);
for (int i = 1; i < n+1; i++)
{
ru(d[i]);
f[d[i]].push_back(i);
id[i]=i;
cnt[i]=1;
}
sort(id+1,id+n+1,cmp);
int ok=1;
for (int i = 1; i < n; i++)
{
vector<int> &tmp = f[d[id[i]]+2*cnt[id[i]]-n];
if(!tmp.empty())
{
int v=tmp.back();
ans.push_back(pii(id[i],v));
cnt[v]+=cnt[id[i]];
dis[v]+=dis[id[i]]+cnt[id[i]];
}
else
{
ok=0;
break;
}
}
if(dis[id[n]]!=d[id[n]])
ok=0;
if(ok)
{
for (int i = 0; i < n-1; i++)
{
printf("%d %d\n",ans[i].first,ans[i].second);
}
}
else
{
printf("-1");
}
} | 0 | 87,133,938 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define 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 cnt[100010];
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;
}
int main(){
int n;
cin>>n;
ll ma=0;
ll d[n];
rep(i,n){
cin>>d[i];
ma=max(ma,d[i]);
cnt[d[i]]++;
}
if(cnt[0]!=1 || d[0]!=0){
cout<<0<<endl;
return 0;
}
ll ans=1;
for(int i=1;i<=ma;i++){
ans=(ans*modpow(cnt[i-1],cnt[i],998244353))%998244353;
}
cout<<ans%998244353<<endl;
} | #include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <complex>
#include <ctime>
#include <cstdlib>
using namespace std;
inline int to_int(string s) {int v; istringstream sin(s); sin >> v; return v;}
template<class T> inline string to_str(T x) {ostringstream sout; sout << x; return sout.str();}
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1<<22;
int main()
{
int n, dp[128][128], r[128];
P T[128];
cin >> n;
for(int i = 0; i < n; i++)
{
for(int j = 0; j < n; j++)
{
dp[i][j] = INF;
}
}
for(int i = 0; i < n; i++)
{
cin >> T[i].first >> T[i].second;
dp[0][i] = 0;
}
for(int i = 1; i < n; i++)
{
for(int j = 0; j < n-i; j++)
{
for(int k = 1; k <= i; k++)
{
dp[i][j] = std::min(dp[i][j], dp[k-1][j] + dp[i-k][j+k] + T[j].first*T[j + k].first*T[j + i].second);
}
}
}
cout << dp[n-1][0] << endl;
} | 0 | 47,930,587 |
#include<iostream>
#include <string>
using namespace std;
int main()
{
int iodd = 0;
int iedge = 0;
int patternsum = 0;
cin >> iodd >> iedge;
if (iodd == 0) {
patternsum = (iedge * (iedge - 1) / 2);
}
else if (iedge == 0) {
patternsum = (iodd * (iodd - 1) / 2);
}
else {
patternsum = (iodd * (iodd - 1) / 2) + iedge * (iedge - 1) / 2;
}
cout << patternsum;
return 0;
} | #include <iostream>
#include <algorithm>
#include <vector>
template <typename Iterator>
auto findMaximumSum (Iterator begin , Iterator end) -> long long
{
long long res = * begin;
auto tmp = res;
for (auto ite = begin + 1; ite != end; ++ ite)
{
tmp += * ite;
res = std::max (res , tmp);
}
return res;
}
auto main () -> int
{
int n;
while (std::cin >> n && n)
{
std::vector <int> a (n);
for (auto && elem : a)
{
std::cin >> elem;
}
long long ans = a [0];
for (auto ite = a.begin (); ite != a.end (); ++ ite)
{
auto tmp = findMaximumSum (ite , a.end ());
ans = std::max (ans , tmp);
}
std::cout << ans << std::endl;
}
} | 0 | 1,724,345 |
#include <stdio.h>
int main(void) {
int a,b;
scanf("%5d",&a);
scanf("%5d",&b);
if(a>b){
printf("a > b\n",a,b);
}
if(a<b){
printf("a < b\n",a,b);
}
if(a==b){
printf("a == b\n",a,b);
}
} | #include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <functional>
#include <map>
using namespace std;
using ll = long long int;
int main(){
int N;cin>>N;
vector<int> A(N);
map<int,int> m;
int max = 0;
for(int i=0;i<N;i++){
cin >> A[i];
m[A[i]]++;
if(A[i]>max) max = A[i];
}
vector<bool> dp(max+1,true);
for(int i=0;i<N;i++){
if(dp[A[i]]){
for(int j=2;j*A[i]<=max;j++){
dp[j*A[i]] = false;
}
}
}
int ans = 0;
for(int i=0;i<N;i++){
if(dp[A[i]]&&m[A[i]]==1) ans++;
}
cout << ans << endl;
return 0;
} | 0 | 40,708,095 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using V = vector<int>;
using VV = vector<vector<int>>;
using VVV = vector<vector<vector<int>>>;
using VL = vector<ll>;
using VVL = vector<vector<ll>>;
using VVVL = vector<vector<vector<ll>>>;
template<class T> using P = pair<T, T>;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep1(i,n) for(int i=1;i<=(n);i++)
#define REP(i,k,n) for(int i=(k);i<(n);i++)
#define all(a) (a).begin(),(a).end()
#define output(x,y) cout << fixed << setprecision(y) << x << endl;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
const ll MOD = 1e9 + 7;
ll upper = MOD + MOD;
ll under = -upper;
ll UPPER = MOD * MOD;
ll UNDER = -UPPER;
const long double pi = 3.141592653589793;
int main() {
int n, m;
cin >> n >> m;
vector<P<int>> task(n);
rep(i, n) {
cin >> task[i].first >> task[i].second;
}
sort(all(task));
priority_queue<int> pq;
ll ans = 0;
int cnt = 0;
rep1(i, m) {
while (cnt != n && task[cnt].first == i) {
pq.push(task[cnt].second);
cnt++;
}
if (!pq.empty()) {
ans += pq.top();
pq.pop();
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cstdint>
#include <iostream>
#include <iterator>
#include <vector>
#ifndef UTIL_HPP
#define UTIL_HPP
using i64 = ::std::int_fast64_t;
using u64 = ::std::uint_fast64_t;
using i32 = ::std::int_fast32_t;
using u32 = ::std::uint_fast32_t;
namespace tools {
template <typename T>
void read(::std::istream& is, ::std::vector<T>& vector, const typename ::std::vector<T>::size_type size) {
vector.reserve(size);
::std::copy_n(::std::istream_iterator<T>(is), size, ::std::back_inserter(vector));
}
template <typename T>
void read(::std::vector<T>& vector, const typename ::std::vector<T>::size_type size) {
::tools::read(::std::cin, vector, size);
}
template <typename T, ::std::size_t N>
void read(::std::istream& is, ::std::array<T, N>& array) {
::std::copy_n(std::istream_iterator<T>(is), N, array.begin());
}
template <typename T, ::std::size_t N>
void read(::std::array<T, N>& array) {
::tools::read(::std::cin, array);
}
}
#endif
int main() {
std::string S;
std::cin >> S;
i64 answer = 0;
i64 possible_answer = 0;
for (const char& S_i : S) {
switch (S_i) {
case 'R':
++possible_answer;
break;
case 'S':
answer = std::max(answer, possible_answer);
possible_answer = 0;
break;
}
}
answer = std::max(answer, possible_answer);
std::cout << answer << std::endl;
return 0;
} | 0 | 490,366 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i,s,n) for(int i = (s); i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main(){
string s;
ll k;
cin >> s >> k;
if(s[0]=='1'){
if(k==1)
cout << s[0] << endl;
else{
if(k<=100){
bool flag = true;
rep(i, k){
if(s[i]!='1'){
flag = false;
cout << s[i] << endl;
break;
}
}
if(flag)
cout << s[0] << endl;
} else {
bool flag = true;
rep(i, 100) {
if(s[i]!='1'){
flag = false;
cout << s[i] << endl;
break;
}
}
if(flag)
cout << s[0] << endl;
}
}
}else{
cout<< s[0] << endl;
}
return 0;
} | #include <iostream>
#include <algorithm>
#include <math.h>
#include <vector>
#include <string>
#include <queue>
#include <map>
#include <utility>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define YES cout << "YES" << endl;
#define NO cout << "NO" << endl;
#define yes cout << "Yes" << endl;
#define no cout << "No" << endl;
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);}
int main () {
int n;
cin >> n;
double x;
string u;
double sum=0,sum1 =0;
for(int i =0;i<n; i++) {
cin >> x >> u;
if (u == "JPY") {
sum+= x;
} else {
sum1+= x;
}
}
cout << sum + sum1 * 380000 << endl;
} | 0 | 97,477,752 |
#include <iostream>
#include <queue>
#include <vector>
#include <set>
#include <algorithm>
#include <stdio.h>
inline int in() { int32_t x; scanf("%d", &x); return x ;}
using namespace std;
const int MAX_N = 1e5 + 5;
struct top3
{
int a[4] = {0 , 0 , 0 , 0};
void add(int x)
{
a[3] = x;
sort(a , a + 4 , greater<int>());
}
}tp;
int32_t main()
{
int x;
while (scanf("%d",&x) != EOF)
{
tp.add(x);
}
cout << tp.a[0] << endl << tp.a[1] << endl << tp.a[2] << endl;
} | #include<cstdio>
#include<cmath>
double getd(double x, double y){
double r = atan2(y, x) * 180 / M_PI;
return r;
}
int main(){
double x1,y1,x2,y2,x3,y3,xp,yp,d1,d2,d3;
double h;
while(scanf("%lf %lf %lf %lf %lf %lf %lf %lf", &x1,&y1,&x2,&y2,&x3,&y3,&xp,&yp) + 1){
x1 -= xp;
x2 -= xp;
x3 -= xp;
y1 -= yp;
y2 -= yp;
y3 -= yp;
d1 = getd(x1,y1);
d2 = getd(x2,y2);
d3 = getd(x3,y3);
if(d1 > d2){
h = d1;
d1 = d2;
d2 = h;
}
if(d2 > d3){
h = d2;
d2 = d3;
d3 = h;
if(d1 > d2){
h = d1;
d1 = d2;
d2 = h;
}
}
d2 -= d1;
d3 -= d1;
if(180 > d2){
if(180 < d3 && d3 < d2 + 180){
printf("YES\n");
}else{
printf("NO\n");
}
}else{
printf("NO\n");
}
}
return 0;
} | 0 | 54,285,356 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string X;
string Y;
cin >> X >> Y;
if(X[0] == Y[2] && X[2] == Y[0]){
if(X[1] == Y[1]){
cout << "YES" << endl;
}
else {
cout <<"NO"<<endl;
}
}
else {
cout << "NO" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int A[300005];
void solve(int L, int lim, int a, int b)
{
if(lim == 0)
return;
a = min(a, lim - b + 1);
for(int i=lim-a+1; i<=lim; i++)
A[i] = L++;
solve(L, lim-a, a, b-1);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
int n, a, b;
cin >> n >> a >> b;
if(1LL * a * b < n || a + b > n + 1)
{
cout << -1 << "\n";
return 0;
}
solve(1, n, a, b);
for(int i=1; i<=n; i++)
cout << A[i] << " ";
return 0;
} | 0 | 92,783,947 |
#include <iostream>
using namespace std;
int main() {
string n;
cin >> n;
long long sum = 0;
for (const char &c : n) sum += c - '0';
puts(sum % 9 == 0 ? "Yes" : "No");
} | #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 a, b, c, d, e;
vector<int> dishes(5);
rep(i, 5) cin >> dishes[i];
int m = dishes[0] % 10;
int idx = 0;
for(int i = 1; i < 5; i++) {
if(dishes[i] % 10 < m && dishes[i] % 10 > 0) {
m = dishes[i] % 10;
idx = i;
}
}
int ans = 0;
rep(i, 5) {
if(idx == i)
ans += dishes[i];
else if(dishes[i] % 10 == 0)
ans += dishes[i];
else
ans += dishes[i] - dishes[i] % 10 + 10;
}
cout << ans << endl;
} | 0 | 96,053,329 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,N) for(int i=0,i##_max=(N);i<i##_max;++i)
#define repp(i,l,r) for(int i=(l),i##_max=(r);i<i##_max;++i)
#define per(i,N) for(int i=(N)-1;i>=0;--i)
#define perr(i,l,r) for(int i=r-1,i##_min(l);i>=i##_min;--i)
#define all(arr) (arr).begin(), (arr).end()
#define SP << " " <<
#define SPF << " "
#define SPEEDUP cin.tie(0);ios::sync_with_stdio(false);
#define MAX_I INT_MAX
#define MIN_I INT_MIN
#define MAX_UI UINT_MAX
#define MAX_LL LLONG_MAX
#define MIN_LL LLONG_MIN
#define MAX_ULL ULLONG_MAX
typedef long long ll;
typedef pair<int,int> PII;
typedef pair<char,char> PCC;
typedef pair<ll,ll> PLL;
typedef pair<char,int> PCI;
typedef pair<int,char> PIC;
typedef pair<ll,int> PLI;
typedef pair<int,ll> PIL;
typedef pair<ll,char> PLC;
typedef pair<char,ll> PCL;
inline void YesNo(bool b){ cout << (b?"Yes" : "No") << endl;}
inline void YESNO(bool b){ cout << (b?"YES" : "NO") << endl;}
inline void Yay(bool b){ cout << (b?"Yay!" : ":(") << endl;}
int main(void){
SPEEDUP
cout << setprecision(15);
int N;cin >> N;
vector<ll> v(N);
ll ans = 0;
rep(i,N){
ll A,B;cin >> A >> B;
ans -= B;
v[i] = A+B;
}
sort(all(v),greater<ll>());
rep(i,N){
if(i%2==0) ans += v[i];
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n + 1);
ll s = 0;
for (int i = 0; i <= n; i++) {
cin >> a[i];
s += a[i];
}
ll r = 0;
ll t = 1;
for (int i = 0; i <= n; i++) {
r += t;
t -= a[i];
s -= a[i];
if (t < 0) {
cout << -1 << endl;
exit(0);
}
t = min(t * 2, s);
}
cout << r << endl;
return 0;
} | 0 | 12,555,764 |
#include<bits/stdc++.h>
using namespace std;
int main(){
ios::sync_with_stdio(false);
int n;
cin>>n;
int x=1;
while(x*(x+1)/2<=n) x++;
int s=x*(x+1)/2-n;
for(int i=1;i<=x;i++){
if(i==s) continue;
cout<<i<<endl;
}
} | #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 TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif
#define lsc(x) scanf("%lld",&x)
#define sc(x) scanf("%d",&x)
#define lpr(x) printf("%lld ",(long long)x)
#define pr(x) printf("%d ",x)
#define n_l printf("\n")
#define VI vector<int>
#define VII vector<long long int>
#define m_p make_pair
#define pb push_back
#define fi first
#define se second
#define mset(x,y) memset(x,y,sizeof(x))
#define sz(v) (int)v.size()
#define all(v) v.begin(), v.end()
#define fr(i, a, n) for(int i=a;i<=n;i++)
#define FIO ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
mt19937 rng32(chrono::steady_clock::now().time_since_epoch().count());
const int N=(int)1e6+5;
const int mod = 1000000007;
typedef long long ll;
typedef tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
ll fmod(ll x){if (x<mod) return x;return x%mod;}
ll mul(ll a, ll b, ll c){
ll ret=0;while(b){if (b%2) ret=(ret+a)%c;a=(a*2)%c;b>>=1;}
return ret;
}
int modpow(ll a, ll b){
ll ret=1;while(b){if (b%2) ret=(ret*a)%mod;a=(a*a)%mod;b>>=1;}
return (int)ret;
}
inline int inv(int x){ return modpow(x, mod-2);}
int isprime[N];
void calc_prime(){
isprime[1]=1;for(ll i=2;i<N;i++) if (!isprime[i]) for(ll j=i*i;j<N;j+=i) isprime[j]=1;
}
int main(){
int x;sc(x);
int n;sc(n);
set<int> s;
fr(i, -100, 200) s.insert(i);
fr(i, 1, n){
int p;sc(p);
if (s.find(p)!=s.end()){
s.erase(p);
}
}
int ans = 0;
int diff = mod;
for(auto u: s){
int tmp = abs(u-x);
if (tmp < diff){
diff = tmp;
ans = u;
}
}
pr(ans);n_l;
return 0;
} | 0 | 49,764,104 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<ll, null_type,less<ll>, rb_tree_tag,tree_order_statistics_node_update>
#define ld long double
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define all(a) a.begin(),a.end()
#define sz(a) (ll)(a.size())
const int M = 1002;
ll a[M];
int main()
{
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int n,k;
cin>>n>>k;
for(int i=1;i<=n;i++)
cin>>a[i];
vector<ll> v;
for(int i=1;i<=n;i++)
{
ll s = 0;
for(int j=i;j<=n;j++)
{
s += a[j];
v.pb(s);
}
}
ll mask = 0;
for(int i=50;i>=0;i--)
{
ll c = (mask|(1LL<<i));
int z = 0;
for(auto u:v)
{
if((u&c) == c)
z++;
}
if(z>=k)
mask = c;
}
cout<<mask<<"\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
signed main () {
string s;
cin >> s;
for (int i = 0; i < int(s.size()); ++i) {
if (s[i] == '1')
cout << '9';
else if (s[i] == '9')
cout << '1';
else
cout << s[i];
}
cout << '\n';
} | 0 | 65,144,388 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define _USE_MATH_DEFINES
#include <math.h>
#define NIL = -1;
#define all(x) x.begin(),x.end()
const ll INF = 1e9;
const ll INFL = 1e18;
const ll mod = 1e9 + 7;
int digit(ll x) {
if (x / 10 == 0) return 1;
return digit(x / 10) + 1;
}
ll gcd(long long a,long long b) {
if (a < b) swap(a,b);
if (b == 0) return a;
return gcd(b,a%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;
}
ll lcm(ll a,ll b){
return ((a * b == 0)) ? 0 : (a / gcd(a,b) * b);
}
double DegreeToRadian(double degree){
return degree * M_PI / 180.0;
}
int dx[4] = {0,1,0,-1};
int dy[4] = {1,0,-1,0};
int main(){
long long n,k;
cin >> n >> k;
int mx = 100010;
vector<long long> res(mx, 0);
for (int i = 0;i < n;i++){
long long a, b;
cin >> a >> b;
res[a] += b;
}
long long ans = 0;
for (int i = 1;i < 100010;i++){
ans += res[i];
if (ans >= k){
cout << i << endl;
break;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool check = false;
while(0<s.size()) {
if(s.size()<5) {
check = true;
break;
}
if(s[4]=='m') {
if(s.size()>7) {
if(s.substr(0,7)=="dreamer" && s[7]=='a') {s = s.substr(5); continue;}
else if(s.substr(0,7)=="dreamer" && s[7]!='a') {s = s.substr(7); continue;}
else if(s.substr(0,5)=="dream") {s = s.substr(5); continue;}
else check = true;
}
else if(s=="dream") {s = ""; continue;}
else if(s=="dreamer") {s = ""; continue;}
else check = true;
}
else {
if(s.size()>6) {
if(s.substr(0,6)=="eraser") {s = s.substr(6); continue;}
else if(s.substr(0,5)=="erase") {s = s.substr(5); continue;}
else check = true;
}
else if(s=="erase") {s = ""; continue;}
else if(s=="eraser") {s = ""; continue;}
else check = true;
}
if(check) break;
}
if(check) cout << "NO" << endl;
else cout << "YES" << endl;
return 0;
} | 0 | 17,496,181 |
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <cmath>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <tuple>
#include <stack>
#include <bitset>
#include <utility>
using namespace std;
typedef unsigned long ul;
typedef unsigned long long ull;
typedef long long ll;
typedef vector<ll> vint;
typedef vector<vector<ll>> vvint;
typedef pair<ll,ll> pint;
typedef vector<pint> vpint;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repf(i,f,n) for(ll i=f;i<n;i++)
#define repr(i,n) for(ll i=n-1;i>=0;i--)
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define pf push_front
#define fi first
#define se second
#define INT_MAX 2147483647
#define LLONG_MAX 9223372036854775807
#define vmax(vec) *max_element(vec.begin(), vec.end())
#define vmin(vec) *min_element(vec.begin(), vec.end())
#define vsort(vec) sort(vec.begin(), vec.end())
#define vsortgr(vec) sort(vec.begin(), vec.end(), greater<ll>())
typedef struct{
ll pos;
ll depth;
} data;
int dy[]={0, 0, 1, -1};
int dx[]={1, -1, 0, 0,};
int main() {
ll N,K;
cin>>N>>K;
cout << N-K+1 << endl;
} | #include <bits/stdc++.h>
#define REP(i,n) for(int i=0;i<n;i++)
#define REPP(i,n) for(int i=1;i<=n;i++)
const double PI = acos(-1);
const double EPS = 1e-15;
long long INF=(long long)1E17;
#define i_7 (long long)(1E9+7)
long mod(long a){
long long c=a%i_7;
if(c>=0)return c;
return c+i_7;
}
using namespace std;
bool prime(int n){
if(n==1){
return false;
}else if(n==2){
return true;
}else{
for(int i=2;i<=sqrt(n);i++){
if(n%i==0){
return false;
}
}
return true;
}
}
long long gcd(long long a, long long b){
if(a<b){
swap(a,b);
}
if(a%b==0){
return b;
}else{
return gcd(b,a%b);
}
}
long long lcm(long long x, long long y){
return (x/gcd(x,y))*y;
}
class UnionFind {
public:
vector<int> Parent;
UnionFind(int N) {
Parent = vector<int>(N, -1);
}
int root(int A) {
if (Parent[A] < 0) return A;
return Parent[A] = root(Parent[A]);
}
int size(int A) {
return -Parent[root(A)];
}
bool connect(int A, int B) {
A = root(A);
B = root(B);
if (A == B) {
return false;
}
if (size(A) < size(B)) swap(A, B);
Parent[A] += Parent[B];
Parent[B] = A;
return true;
}
};
int main(){
string s;
cin>>s;
int x,y;
cin>>x>>y;
vector<int> dx,dy;
int cntx=0,cnty=0;
int slen=s.size();
int cnt=0;
bool flag=true;
REP(i,slen){
if(s[i]=='T'){
if(flag){
dx.push_back(cnt);
cntx++;
}else{
dy.push_back(cnt);
cnty++;
}
cnt=0;
flag = !flag;
}else{
cnt++;
if(i==slen-1){
if(flag){
dx.push_back(cnt);
cntx++;
}else{
dy.push_back(cnt);
cnty++;
}
}
}
}
if(cnty==0){
if(x==slen && y==0){
cout<<"Yes"<<endl;
}else{
cout<<"No"<<endl;
}
return 0;
}
vector<vector<bool>> dpx(cntx,vector<bool>(16001,false));
vector<vector<bool>> dpy(cnty,vector<bool>(16001,false));
REP(i,cntx){
if(i==0){
dpx[i][dx[i]+8000]=true;
}else{
REP(j,16001){
if(0<=j-dx[i] && j+dx[i]<16001){
dpx[i][j]=dpx[i-1][j-dx[i]] | dpx[i-1][j+dx[i]];
}else if(0<=j-dx[i]){
dpx[i][j]=dpx[i-1][j-dx[i]];
}else if(j+dx[i]<16001){
dpx[i][j]=dpx[i-1][j+dx[i]];
}else{
continue;
}
}
}
}
REP(i,cnty){
if(i==0){
dpy[i][dy[i]+8000]=true;
dpy[i][-dy[i]+8000]=true;
}else{
REP(j,16001){
if(0<=j-dy[i] && j+dy[i]<16001){
dpy[i][j]=dpy[i-1][j-dy[i]] | dpy[i-1][j+dy[i]];
}else if(0<=j-dy[i]){
dpy[i][j]=dpy[i-1][j-dy[i]];
}else if(j+dy[i]<16001){
dpy[i][j]=dpy[i-1][j+dy[i]];
}else{
continue;
}
}
}
}
if(0<=x+8000 && x+8000<16001 && 0<=y+8000 && y+8000<16001 && dpx[cntx-1][x+8000] && dpy[cnty-1][y+8000]){
cout<<"Yes"<<endl;
}else{
cout<<"No"<<endl;
}
return 0;
} | 0 | 67,538,775 |
#include <iostream>
#include <algorithm>
using namespace std;
#define repeat(i,n) for (int i = 0; i < (n); ++i)
#define repeat_from(i,m,n) for (int i = m; i < (n); ++i)
#define MAX_S 1000
int dp[2][MAX_S+1];
int main() {
string s1, s2;
getline(cin, s1);
getline(cin, s2);
int *cur = dp[0]; repeat (i,s2.size()+1) cur[i] = i;
int *prv = dp[1];
repeat_from (i,1,s1.size()+1) {
swap(cur,prv);
cur[0] = prv[0] + 1;
repeat_from (j,1,s2.size()+1) {
cur[j] = min(cur[j-1]+1,
min(prv[j]+1,
prv[j-1]+(s1[i-1]==s2[j-1]?0:1)));
}
}
cout << cur[s2.size()] << endl;
return 0;
} | #include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std ;
#define int long long
#define ull unsigned long long int
#define ld long double
#define vi vector<int>
#define vii vector<pair<int,int>>
#define vvi vector<vector<int>>
#define pii pair<int,int>
#define prec(x) fixed<<setprecision(15)<<x
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define rev(x) reverse(x.begin(),x.end())
#define mset(a,b) memset(a,b,sizeof(a))
#define mcpy(a,b) memcpy(a,b,sizeof(a))
#define fo0(i,n) for(int i=0,i##end=n;i<i##end;i++)
#define fo1(i,n) for(int i=1,i##end=n;i<=i##end;i++)
#define fo(i,a,b) for(int i=a,i##end=b;i<=i##end;i++)
#define foe(i,x) for(__typeof((x).end())i=(x).begin();i!=(x).end();++i)
#define fre(i,x) for(__typeof((x).rend())i=(x).rbegin();i!=(x).rend();++i)
#define mk(arr,n,type) type *arr=new type[n];
#define dbg(x) cerr << #x << " is " << x << endl;
#define FAST_IO ios_base::sync_with_stdio(false); cin.tie(0);cout.tie(0)
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
int gcd(int a, int b) { return b ? gcd(b, a%b) : a; }
clock_t beg = clock();
const int inf=1e18;const int mod=1e9+7;const int N=2e5+9;
const double pi = 3.1415926535897932384626433;
void FILE_IO(){
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
void JH(){
int d=0,e=0,f=0,g=0,p=0,w=0,flag=0,ans=0,res=0,cnt=0,sum=0;double f1=0.0,f2=0.0,f3=0.0;
int h1,m1,h2,m2,k;cin>>h1>>m1>>h2>>m2>>k;
m1=h1*60+m1;
m2=h2*60+m2;
int diff=m2-m1;
cout<<diff-k<<endl;
}
int32_t main()
{
FILE_IO();FAST_IO;int t=1;
while(t--){JH();}cerr<<"Execution time: "<<(double)(clock()-beg)/1000<<"s ";
} | 0 | 2,483,793 |
#include <bits/stdc++.h>
using namespace std;
const int64_t INF = 1e18;
int main() {
int N, K; cin >> N >> K;
vector<int64_t> A(N);
K--;
for(auto &a : A) cin >> a;
int64_t ans = INF;
for(int bit = 0; bit < (1 << (N - 1)); ++bit) {
if(__builtin_popcount(bit) != K) continue;
int64_t now = A[0], cost = 0;
for(int i = 1; i < N; ++i) {
if(bit & (1 << (i - 1))) {
int64_t dif = A[i] - now;
if(dif > 0) {
now = A[i];
} else {
cost += -dif + 1;
now = A[i] - dif + 1;
}
} else {
now = max(now, A[i]);
}
}
ans = min(ans, cost);
}
cout << ans << '\n';
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int n, m;
cin >> n >> m;
vector<string> a(n), b(m);
for(int i = 0; i < n; i++) {
cin >> a[i];
}
for(int i = 0; i < m; i++) {
cin >> b[i];
}
for(int i = 0; i < n - m + 1; i++) {
for(int j = 0; j < n - m + 1; j++) {
int num = 0;
while(num + i < n && a[num + i].substr(j, m) == b[num]) {
num++;
}
if(num == m) {
cout << "Yes\n";
return 0;
}
}
}
cout << "No\n";
return 0;
} | 0 | 26,248,584 |
#include<stdio.h>
int main(){
char C;
scanf("%c", &C);
if(C != 'z'){
printf("%c", C + 1);
}
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;
typedef long long ll;
vector<ll> fac(1000001);
vector<ll> ifac(1000001);
const ll M = pow(10,9)+7;
ll mpow(ll x, ll n){
ll ans = 1;
while(n != 0){
if(n&1) ans = ans*x % M;
x = x*x % M;
n = n >> 1;
}
return ans;
}
ll comb(ll a, ll b){
if(a == 0 && b == 0)return 1;
if(a < b || a < 0)return 0;
ll tmp = ifac[a-b]* ifac[b] % M;
return tmp * fac[a] % M;
}
int main(){
ll X,Y;
cin >> X >> Y;
ll ans=0;
ll a,b;
fac[0] = 1;
ifac[0] = 1;
a = (2*Y-X)/3;
b = (2*X-Y)/3;
for(ll i = 0; i<a+b; i++){
fac[i+1] = fac[i]*(i+1) % M;
ifac[i+1] = ifac[i]*mpow(i+1, M-2) % M;
}
if((X+Y)%3!=0) ans=0;
else{
if(a>=0 && b>=0) ans = comb(a+b,a)% M;
}
cout << ans << endl;
} | 0 | 96,193,822 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main () {
ll n, m;
int a[3][3];
ll i, j, k;
ll ret = 0;
for ( i = 0;i < 3; i++ ) {
for ( j = 0; j < 3; j++ ) {
cin >> a[i][j];
}
}
cin >> n;
vector<int> b(n);
for ( i = 0; i < n; i++ ) {
cin >> b[i];
}
for ( i = 0;i < 3; i++ ) {
for ( j = 0; j < 3; j++ ) {
for ( k = 0; k < n; k++ ) {
if ( a[i][j] == b[k] ) {
a[i][j] = 0;
}
}
}
}
for ( i = 0;i < 3; i++ ) {
if ( (a[i][0] == 0) && (a[i][1] == 0) && (a[i][2] == 0) ) ret++;
}
for ( i = 0;i < 3; i++ ) {
if ( (a[0][i] == 0) && (a[1][i] == 0) && (a[2][i] == 0) ) ret++;
}
if ( (a[0][0] == 0) && (a[1][1] == 0) && (a[2][2] == 0) ) ret++;
if ( (a[2][0] == 0) && (a[1][1] == 0) && (a[2][0] == 0) ) ret++;
cout << ((ret > 0) ? "Yes" : "No") << endl;
return 0;
} | #include <cstdio>
#include <cstdlib>
#include <string>
using namespace std;
int main(){
char str[1000], cmd[7], p[1000];
int a, b, q;
string OUT;
scanf("%s", str);
string STR = str;
scanf("%d", &q);
for(int i = 0; i < q; i++){
scanf("%s %d %d", cmd, &a, &b);
string CMD = cmd;
if(CMD == "replace"){
scanf("%s", p);
string P = p;
STR.replace(a, b - a + 1, P);
}
else if(CMD == "reverse"){
string R;
for(int j = b; j >= a; j--){
R += STR[j];
}
STR.replace(a, b - a + 1, R);
}
else if(CMD == "print"){
for(int k = a; k <= b; k++){
OUT += STR[k];
}
OUT += "\n";
}
}
char* out;
out = (char*)malloc(OUT.length() + 1);
sprintf(out, "%s", OUT.c_str());
printf("%s", out);
free(out);
return 0;
} | 0 | 2,027,805 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double dd;
#define i_7 (ll)(1E9+7)
#define i_5 i_7-2
ll mod(ll a){
ll c=a%i_7;
if(c>=0)return c;
return c+i_7;
}
typedef pair<ll,ll> l_l;
ll inf=(ll)1E16;
#define rep(i,l,r) for(ll i=l;i<=r;i++)
#define pb push_back
ll max(ll a,ll b){if(a<b)return b;else return a;}
ll min(ll a,ll b){if(a>b)return b;else return a;}
void Max(ll &pos,ll val){pos=max(pos,val);}
void Min(ll &pos,ll val){pos=min(pos,val);}
void Add(ll &pos,ll val){pos=mod(pos+val);}
dd EPS=1E-9;
string alp="abcdefghijklmnopqrstuvwxyz";
#define endl "\n"
#define fastio ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
int main(){
ll n,a,b;cin>>n>>a>>b;
if(((a-b)%2+2)%2==0){
cout<<"Alice"<<endl;
}else{
cout<<"Borys"<<endl;
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<ll>;
using vvi = vector<vi>;
const int INF = 100010001;
const ll LINF = (ll)INF*INF*10;
int main() {
string s;
cin >> s;
int k;
cin >> k;
int num = s.size();
vvi dp(num+1, vi(k+1));
vi dp_(num+1);
rep(i, num) {
dp_[i+1] = dp_[i];
int now = s[i] - '0';
if(s[i] != '0') {
dp_[i+1]++;
if(dp_[i] < k) {
dp[i+1][dp_[i]+1] = now-1;
}
if(dp_[i] <= k) {
dp[i+1][dp_[i]]++;
}
}
rep(j, k) {
dp[i+1][j+1] += dp[i][j] * 9;
}
rep(j, k+1) {
dp[i+1][j] += dp[i][j];
}
}
if(dp_[num] == k) {
dp[num][k]++;
}
cout << dp[num][k] << endl;
} | 0 | 71,200,990 |
#include <bits/stdc++.h>
#include <numeric>
#define REP(i, s, n) for (int i = s; i < n; ++i)
#define rep(i, n) REP(i, 0, n)
#define SORT(c) sort((c).begin(), (c).end())
#define SORT_INV(c) sort((c).begin(), (c).end(), greater<int>())
#define IINF INT_MAX
#define LLINF LLONG_MAX
#define DEBUG false
#define LL long long
#define Dev 1000000007
using namespace std;
int main()
{
int h, w;
cin >> h >> w;
rep(i,h){
rep(j,w){
string temp;
cin >> temp;
if(temp=="snuke"){
cout << (char)('A'+j) << (i + 1) << endl;
return 0;
}
}
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD=1000000007;
#define INF 1LL<<30
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(),(x).end()
int main(){
int n;
cin>>n;
vector<int> c(n-1),s(n-1),f(n-1);
rep(i,n-1) cin>>c[i]>>s[i]>>f[i];
rep(i,n-1){
int ans=s[i]+c[i];
for(int j=i+1;j<n-1;j++){
if(ans<=s[j]) ans=s[j]+c[j];
else{
if((ans-s[j])%f[j]==0){
int x=(ans-s[j])/f[j];
ans=s[j]+f[j]*x+c[j];
}
else{
int x=(ans-s[j]+f[j]-1)/f[j];
ans=s[j]+f[j]*x+c[j];
}
}
}
cout<<ans<<endl;
}
cout<<0<<endl;
} | 0 | 83,190,707 |
#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define ll long long
#define maxn 1000005
#define inf 1e9
#define pb push_back
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define per(i,a,b) for(int i=a;i>=b;i--)
using namespace std;
inline ll read()
{
ll x=0,w=1; char c=getchar();
while(c<'0'||c>'9') {if(c=='-') w=-1; c=getchar();}
while(c<='9'&&c>='0') {x=(x<<1)+(x<<3)+c-'0'; c=getchar();}
return w==1?x:-x;
}
char s[maxn],t[maxn];
int main()
{
scanf("%s",s+1); ll k=read(),a1=0,a2=0,ans=0,n=strlen(s+1);
rep(i,1,n) s[i+n]=s[i],t[i]=s[i];
rep(i,2,n) if(s[i]==s[i-1]) s[i]='#',a1++;
if(s[1]!=s[n]) return cout<<a1*k<<endl,0;
per(i,n-1,1) if(t[i]==t[i+1]) t[i]='#',a2++;
if(t[1]!=t[n]) return cout<<a2*k<<endl,0;
rep(i,n+1,2*n) if(s[i]==s[i-1]) s[i]='#',a2++;
ans=a1*k;
if(s[2*n]=='#') ans+=k/2; else ans+=k-1;
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int INF=1001001001;
vector<pair<int64_t,int64_t>>prime_factorize(int64_t x){
vector<pair<int64_t,int64_t>>p;
for(int64_t i=2;i*i<=x;i++){
int cnt=0;
if(x%i==0){
while(x%i==0){cnt++;x/=i;}
p.push_back(make_pair(i,cnt));
}
}
if(x!=1){p.push_back(make_pair(x,1));}
return p;
}
int main() {
int64_t N,K;
cin>>N>>K;
vector<int>a(N),b(N);
map<int,int64_t>k;
for(int i=0;i<N;i++){
cin>>a[i]>>b[i];
k[a[i]]+=b[i];
}
int64_t sum=0;
for(auto p:k){
int v=p.first;
int64_t q=p.second;
sum+=q;
if(sum>=K){cout<<v<<endl;return 0;}
}
return 0;
} | 0 | 18,261,466 |
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define endl "\n"
#define pb push_back
#define PI 3.1415926535897932384626433832795l
#define F first
#define S second
#define mp make_pair
#define f(i,n) for(int i=0;i<n;i++)
#define fastio ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define all(v) (v).begin(),(v).end()
#define rall(v) (v).rbegin(),(v).rend()
#define sort(v) sort((v).begin(),(v).end())
#define rsort(v) sort((v).rbegin(),(v).rend())
#define gcd(a,b) __gcd((a),(b))
#define minn(v) *min_element(v.begin(), v.end());
#define maxx(v) *max_element(v.begin(), v.end());
#define print(x) cout<<(x)<<endl;
#define sum(v)+x accumulate(v.begin(), v.end(),x);
typedef pair<int,int> pii;
typedef vector<int> vi;
struct type{
int k, i, j;
};
bool isPrime(int n)
{
if (n <= 1)
return false;
if (n <= 3)
return true;
if (n % 2 == 0 || n % 3 == 0)
return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
int findSubarray(int arr[], int n, int k)
{
int window_sum = 0;
int min_window = INT_MAX;
int last = 0;
for (int i = 0; i < n; i++)
{
window_sum += arr[i];
if (i + 1 >= k)
{
if (min_window > window_sum)
{
min_window = window_sum;
last = i;
}
window_sum -= arr[i + 1 - k];
}
}
int sum=0;
for(int i=last-k+1;i<=last;i++)
{
sum+=arr[i];
}
return sum;
}
int nextpermutation(vi v)
{
vi t=v;
sort(t);
int x=0;
while(true)
{
x++;
if(t==v)
{
return x;
}
next_permutation(all(t));
}
}
vector<int>factors(int n)
{
vi ans;
for (int i=1; i<=sqrt(n); i++)
{
if (n%i == 0)
{
if (n/i == i )
ans.pb(i);
else
ans.pb(i);
if (i!=n/i)
ans.pb(n/i);
}
}
return ans;
}
int power(int x, int y, int p)
{
int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0)
{
if (y & 1)
res = (res*x) % p;
y = y/2;
x = (x*x) % p;
}
return res;
}
signed main()
{
fastio;
cout << fixed << setprecision(12);
int a,b;
cin>>a>>b;
print((a*b)/gcd(a,b))
} | #include <bits/stdc++.h>
using namespace std;
#define hs ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
typedef long long ll;
const ll mod = 1000000007;
const ll INF = 1e18;
const ll MAX = 100001;
void solve(){
int k, n;
cin>>k>>n;
vector<int> vec(n);
for(int i = 0; i< n; i++)
cin>>vec[i];
int ans = INT_MAX;
for(int i = 0; i < n; i++){
if(i == 0)
ans = min(ans, vec[n-1]-vec[0]);
else
ans = min(ans, k-(vec[i]-vec[i-1]));
}
cout<<ans;
}
int main(){
hs;
ll t;
t=1;
for (int i=1; i<=t; i++){
solve();
}
return 0;
} | 0 | 84,165,072 |
#include<bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define int ll
#define pb push_back
#define setbits(x) __builtin_popcountll(x)
#define endl "\n"
typedef long long ll;
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int val,n;
cin>>val>>n;
int ans=0;
while(n--)
{int x;
cin>>x;
ans+=x;
}
if(ans>val)
{
cout<<-1<<endl;
}
else
{
cout<<val-ans<<endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pi 3.14159265
#define EPS 1e-8
#define mod 1000000007
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define endl "\n"
const ll INF=(ll)2e18;
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n,k;
cin>>n>>k;
vector<ll> ans(k+1,0);
ll res=0;
for(ll i=k;i>0;i--)
{
ans[i]=binpow(k/i,n,mod);
for(ll j=2;(i*j)<=k;j++)
{
ans[i]-=ans[i*j];
ans[i]+=mod;
ans[i]%=mod;
}
res+=i*(ans[i]);
res%=mod;
}
cout<<res;
} | 0 | 57,053,655 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
#define all(x) x.begin(),x.end()
#define rep(i,j,n) for (long long i = j; i < (long long)(n); i++)
#define _GLIBCXX_DEBUG
#define MOD 1000000007
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; }
long double f(long double a,int b){
if(b==0)return 1;
if(b%2==0){
long double t=f(a,b/2);
return t*t;
}
return f(a,b-1)*a;
}
signed main(){
cout << fixed << setprecision(10);
int n; cin>>n;
int k; cin>>k;
int c=0;
long double ans=0;
long double a=0;
if(n>=k){
a+=(long double)(n-k+1)/n;
}
rep(i,1,n+1){
if(i>=k)break;
int j=i;
int cnt=0;
while(j<k){
j*=2;
cnt++;
}
ans+=f(0.5,cnt)/n;
}
cout<<ans+a<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ff first
#define ss second
typedef long long ll;
typedef pair<int, int> pii;
const int MAXN = 100 * 1000 + 17;
ll n, k, a[MAXN], ans, ps[MAXN], ss[MAXN], s[MAXN];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++)
cin >> a[i];
for (int i = 1; i <= n; i++)
ps[i] = ps[i - 1] + max(a[i], 0LL), s[i] = s[i - 1] + a[i];
for (int i = n; i; i--)
ss[i] = ss[i + 1] + max(a[i], 0LL);
for (int i = k; i <= n; i++)
ans = max(ans, ps[i - k] + ss[i + 1] + max(s[i] - s[i - k], 0LL));
cout << ans << endl;
return 0;
} | 0 | 73,084,224 |
#include <cstdio>
bool query(long long x){
printf("? %lld\n",x);
fflush(stdout);
char s[10];
scanf("%s",s);
return s[0]=='Y';
}
int main(){
long long X=1000000000;
for (;!query(X);X/=10);
if (X==1000000000)
for (X=1;!query(X+1);X*=10);
else{
int l=X,r=X*10-1;
for (;l<=r;){
int mid=(l+r)>>1;
if (query(mid*10ll)) X=mid,r=mid-1;
else l=mid+1;
}
}
printf("! %lld\n",X);
fflush(stdout);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
string s; cin>>s;
int o=0,n=s.length();
for (int i = 0; i < n; i++)if(s[i]=='1')o++;
if(o==0 || n-o==0)return cout<<0,0;
cout<<2*min(o, n - o);
} | 0 | 35,357,184 |
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() {
cerr << endl;
}
template <typename H, typename... T>
void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T>
void print(T x) {
cout << x << "\n";
}
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REVFOR(i, m, n) for (int i = (n - 1); i >= (m); --i)
#define REP(i, n) FOR(i, 0, n)
#define REVREP(i, n) REVFOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll,ll> Pll;
typedef pair<int,int> Pin;
ll INF = 1e16;
int inf = 1e9;
ll MOD = 1e9+7;
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int n, a, b;
cin >> n >> a >> b;
ll ans = 0;
FOR(i, 1, n + 1) {
int c = 0;
int cur = i;
while(cur > 0) {
c += cur % 10;
cur /= 10;
}
if (a <= c && c <= b) {
ans += i;
}
}
print(ans);
} | #include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
#include <cstring>
#include <queue>
#include <deque>
#include <algorithm>
#include <utility>
#include <set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <math.h>
#include <tuple>
#include <iomanip>
#include <bitset>
#include <functional>
#define all(x) (x).begin(),(x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
typedef long double ld;
int dy4[4] = {-1, 0, +1, 0};
int dx4[4] = {0, +1, 0, -1};
int dy8[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dx8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long INF = 1LL << 62;
const ll MOD = 1e9 + 7;
bool greaterSecond(const pair<int, int>& f, const pair<int, int>& s){
return f.second > s.second;
}
ll gcd(ll a, ll b){
if (b == 0)return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b){
return a / gcd(a, b) * b;
}
ll conbinationMemo[100][100];
ll cmemoInit(){
rep(i, 100){
rep(j, 100){
conbinationMemo[i][j] = -1;
}
}
}
ll nCr(ll n, ll r){
if(conbinationMemo[n][r] != -1) return conbinationMemo[n][r];
if(r == 0 || r == n){
return 1;
} else if(r == 1){
return n;
}
return conbinationMemo[n][r] = (nCr(n - 1, r) + nCr(n - 1, r - 1));
}
ll nPr(ll n, ll r){
r = n - r;
ll ret = 1;
for (ll i = n; i >= r + 1; i--) ret *= i;
return ret;
}
int main(void){
ll m, k;
cin >> m >> k;
if((ll)pow(2LL, m) <= k){
cout << -1 << endl;
return 0;
}
vector<ll> ans;
if(m == 1){
if(k == 0){
vector<ll> a = {0, 1, 1, 0};
rep(i, a.size()){
cout << a[i] << " ";
}
} else {
cout << -1;
}
cout << endl;
return 0;
}
for(ll i = 0; i < (ll)pow(2LL, m); i++){
if(i == k) continue;
ans.push_back(i);
}
ans.push_back(k);
for(ll i = (ll)pow(2LL, m) - 1; i >= 0; i--){
if(i == k) continue;
ans.push_back(i);
}
ans.push_back(k);
rep(i, ans.size()){
cout << ans[i] << " ";
}
cout << endl;
} | 0 | 84,047,480 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,x,y) for(int i=(x);i<(y);++i)
#define mp(a,b) make_pair((a),(b))
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif
typedef long long int ll;
typedef pair<int,int> pii;
const int INF=1<<30;
const long long int INFLL=1LL<<58;
const double EPS=1e-9;
const int dx[]={1,0,-1,0},dy[]={0,1,0,-1};
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec){
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
void solve_(){
string a,b;
cin >> a >> b;
static int dp[1000][1000];
fill_n((int*)dp,1000*1000,0);
rep(i,0,a.size()){
rep(j,0,b.size()){
if(i!=0) dp[i][j]=dp[i-1][j];
if(j!=0) dp[i][j]=max(dp[i][j],dp[i][j-1]);
if(a[i]!=b[j]) continue;
if(i==0&&j==0) dp[0][0]=1;
else if(i==0) dp[0][j]=1;
else if(j==0) dp[i][0]=1;
else dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1);
}
}
cout << dp[a.size()-1][b.size()-1] << endl;
}
void solve(){
int n;
cin >> n;
rep(i,0,n) solve_();
}
int main(){
std::ios::sync_with_stdio(false);
std::cin.tie(0);
solve();
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <cfloat>
#include <climits>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <queue>
#include <sstream>
#include <stack>
#include <time.h>
#include <vector>
#include <complex>
#include <map>
#include <set>
#include <iomanip>
#include <math.h>
#include <stdlib.h>
#include <list>
#include <utility>
#include <memory>
#include <cstring>
#include <fstream>
#include <numeric>
#include <assert.h>
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> pii;
int n,m;
vector <pii> neigh[100003];
int dist[100003];
int main() {
cin>>n>>m;
for (int i=0; i<m; i++) {
int x,y,l;
cin>>x>>y>>l;
neigh[x].push_back(pii(y,l));
neigh[y].push_back(pii(x,-l));
}
for (int i=1; i<=n; i++) dist[i]=1e9;
for (int i=1; i<=n; i++)
if (dist[i]==1e9) {
queue <int> q;
q.push(i);
dist[i]=0;
while (!q.empty()) {
int x=q.front();
q.pop();
for (int i=0; i<neigh[x].size(); i++) {
int p=neigh[x][i].first;
int di=neigh[x][i].second;
if (dist[p]!=1e9) {
if (dist[x]+di!=dist[p]) {
puts("No");
return 0;
}
} else {
dist[p]=dist[x]+di;
q.push(p);
}
}
}
}
puts("Yes");
return 0;
} | 0 | 99,494,530 |
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <string>
#include <vector>
#include <math.h>
#include <queue>
#include <deque>
#include <stack>
#include <map>
const int MOD = 1e9+7;
#define PI 3.14159265359
typedef long long ll;
using namespace std;
ll dp1[100][4];
ll dp2[100][4];
int stoi(char c){
return c - '0';
}
int main(){
string s;
int k;
cin >> s >> k;
if (s[0] == '0'){
dp2[0][0] = 1;
}else{
dp1[0][0] = 1;
dp1[0][1] = stoi(s[0]) - 1;
dp2[0][1] = 1;
}
for (int i = 1; i < s.length(); i++){
for (int j = 0; j <= k; j++){
dp1[i][j] += dp1[i-1][j];
if (s[i] == '0'){
dp2[i][j] = dp2[i-1][j];
}else{
dp1[i][j] += dp2[i-1][j];
}
if (j == k) continue;
dp1[i][j+1] += dp1[i-1][j]*9;
if (s[i] != '0'){
dp1[i][j+1] += dp2[i-1][j]*(stoi(s[i])-1);
dp2[i][j+1] = dp2[i-1][j];
}
}
}
cout << dp1[s.length()-1][k] + dp2[s.length()-1][k] << 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>;
const int INF = 1001001001;
const ll LINF = 1001001001001001;
const int MOD = 1000000007;
template <typename T>
void print(const T &v);
const int MAX = 2000000;
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()
{
COMinit();
ll x, y;
cin >> x >> y;
if ((2 * x - y) % 3 == 0 && (2 * y - x) % 3 == 0)
{
ll a = (2 * x - y) / 3;
ll b = (2 * y - x) / 3;
cout << COM(a + b, a) << endl;
}
else
{
cout << 0 << endl;
}
return 0;
}
template <typename T>
void print(T const &v)
{
for (int i = 0; i < v.size(); i++)
{
if (i)
cout << ' ';
cout << v[i];
}
cout << endl;
} | 0 | 46,277,813 |
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define endl "\n"
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define int long long int
#define pll pair<int , int>
#define ALL(v) v.begin(),v.end()
#define ALLR(v) v.rbegin(),v.rend()
#define pii 3.14159265358979323
#define inf LLONG_MAX
#define ones(x) __builtin_popcount(x)
#define fill(a,b) memset(a,b,sizeof(a))
#define mod 1000000007
#define hell 998244353
ll mod_pow(ll a,ll b,ll m)
{
ll res = 1;
while(b)
{
if(b&1)
{
res=(res*a) % m;
}
a=(a*a) % m;
b>>=1;
}
return res;
}
ll mod_inverse(ll a)
{
return mod_pow(a , mod-2 , mod);
}
void solve()
{
int num = 1;
int n;
int b;
cin >> n >> b;
while(n--) {
if(num*2 <= num+b) {
num *= 2;
}
else {
num += b;
}
}
cout << num;
}
signed main() {
fast;
int t = 1;
while(t--) {
solve();
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int n,ans=0,flag=0;
int num[101];
int idx;
cin>>n;
for(int i=0;i<n;i++){
cin>>num[i];
}
for(int i=0;i<n;i++){
idx=i;
for(int j=i+1;j<n;j++){
if(num[idx]>num[j]){
flag=1;
idx=j;
}
}
int temp=num[i];
num[i]=num[idx];
num[idx]=temp;
if(flag)ans++;
flag=0;
}
for(int i=0;i<n;i++){
cout<<num[i];
if(i==n-1)cout<<endl;
else cout<<" ";
}
cout<<ans<<endl;
} | 0 | 27,755,894 |
#include <iostream>
#include <map>
using namespace std;
int main()
{
int N;
cin >> N;
map<int, int> m;
for (int i = 1; i <= N; i++) {
int tmp;
cin >> tmp;
m[tmp] = i;
}
for(auto itr = m.begin(); itr != m.end(); itr++) {
cout << itr->second << " ";
}
cout << endl;
return 0;
} | #pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
constexpr char newl = '\n';
constexpr double eps = 1e-10;
#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define F0R(i,b) FOR(i,0,b)
#define RFO(i,a,b) for (int i = ((b)-1); i >=(a); i--)
#define RF0(i,b) RFO(i,0,b)
#define fi first
#define se second
#define debug(x) cout << #x << ": " << x << '\n';
#define rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()
template<typename T1, typename T2> inline void chmin(T1& a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> inline void chmax(T1& a, T2 b) { if (a < b) a = b; }
template<class T> void Print(vector<T> v) {
F0R(i, v.size()) {
cout << v[i] << ' ';
}
cout << newl;
}
#if 1
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int N;
cin >> N;
int result = 0, n = 0, ph = 0;
F0R(i, N) {
int h;
cin >> h;
if (h <= ph) {
n++;
}
else {
chmax(result, n);
n = 0;
}
ph = h;
}
chmax(result, n);
cout << result;
}
#endif | 0 | 97,284,125 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef vector<int> VI;
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 _overload3(_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(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
int main() {
ll n;
cin >> n;
vector<ll> a(n+2, 0);
ll sum = 0;
rep (i, n+1) {
cin >> a[i];
sum += a[i];
}
vector<ll> b(n+1);
if (a[0] > 0) {
if (a[0] > 1) {
cout << -1 << endl;
exit(0);
} else {
if (sum == 1) {
cout << 1 << endl;
exit(0);
} else {
cout << -1 << endl;
exit(0);
}
}
}
b[0] = 1;
sum -= a[0] + a[1];
rep (i, n-1) {
if (2 * b[i] - a[i+1] < 0) {
cout << -1 << endl;
exit(0);
} else {
ll x = min(2 * b[i] - a[i+1], sum);
b[i+1] = x;
sum -= a[i+2];
}
}
if (2 * b[n-1] - a[n] < 0) {
cout << -1 << endl;
exit(0);
}
b[n] = 0;
cout << accumulate(all(a), 0ll) + accumulate(all(b), 0ll) << endl;
} | #include <bits/stdc++.h>
#define int long long
using namespace std;
void dfs(vector<set<int>>& g, int u, int cur_comp, vector<int>& components) {
if (components[u] != -1) {
return;
}
components[u] = cur_comp;
for(auto v : g[u]) {
dfs(g, v, cur_comp, components);
}
}
int32_t main() {
int n,m;
cin >> n >> m;
vector<set<int>> v(n);
for (int i = 0; i < m; ++i) {
int a,b;
cin >> a >> b;
a--,b--;
v[a].insert(b);
v[b].insert(a);
}
vector<int> components(n, -1);
int cur_comp = 0;
for(int i = 0; i < n; ++i) {
if (components[i] == -1) {
dfs(v,i,cur_comp, components);
cur_comp++;
}
}
vector<int> sizes(cur_comp, 0);
for (int i = 0; i < components.size(); ++i) {
sizes[components[i]]++;
}
cout << *max_element(sizes.begin(), sizes.end());
} | 0 | 11,959,676 |
#include<bits/stdc++.h>
#include<iomanip>
#define fast {ios_base::sync_with_stdio(false);cin.tie(NULL);}
#define mxn 300007
#define ar array
#define mod 1000000007
#define ld long double
#define pb push_back
#define ar array
#define fi first
#define se second
typedef long long int ll;
using namespace std;
int main(void){
fast;
int x;
cin>>x;
if(x<600)
cout<<8;
else if(x<800)
cout<<7;
else if(x<1000)
cout<<6;
else if(x<1200)
cout<<5;
else if(x<1400)
cout<<4;
else if(x<1600)
cout<<3;
else if(x<1800)
cout<<2;
else if(x<2000)
cout<<1;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int,int> P;
int INF = 1e9+7;
int mod = 1e9+7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0 ,-1};
signed main(){
int n;
cin >> n;
vector<int> a(n);
int x = 0;
int count = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
}
for (int i = 0; i < n; i++) {
if (x == 1) {
count = i;
break;
}
x = a[x];
}
if (count!=0) {
cout << count << endl;
}
else {
cout << -1 << endl;
}
} | 0 | 57,097,188 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, m, n) for(int(i) = (int)(m); i < (int)(n); ++i)
#define rep2(i, m, n) for(int(i) = (int)(n)-1; i >= (int)(m); --i)
#define REP(i, n) rep(i, 0, n)
#define REP2(i, n) rep2(i, 0, n)
#define all(hoge) (hoge).begin(), (hoge).end()
#define en '\n'
using ll = long long;
using ull = unsigned long long;
template <class T>
using vec = vector<T>;
template <class T>
using vvec = vector<vec<T>>;
typedef pair<ll, ll> P;
constexpr long long INF = 1LL << 60;
constexpr int INF_INT = 1 << 25;
constexpr long long MOD = (ll)1e9 + 7;
using ld = long double;
static const ld pi = 3.141592653589793L;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
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;
}
struct Edge {
ll to, rev;
long double cap;
Edge(ll _to, long double _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
using Edges = vector<Edge>;
using Graph = vector<Edges>;
void add_edge(Graph &G, ll from, ll to, long double cap, bool revFlag,
long double revCap) {
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if(revFlag)
G[to].push_back(Edge(from, revCap, (ll)G[from].size() - 1));
}
void solve() {
ll n, a, b;
cin >> n >> a >> b;
ll aa = 0, ab = 0, bb = 0;
REP(i, n) {
ll p;
cin >> p;
if(p <= a) {
aa++;
} else if(p <= b) {
ab++;
} else {
bb++;
}
}
cout << min({aa, ab, bb}) << en;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
} | #include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <cmath>
#include <bitset>
#include <iomanip>
#include <stack>
#include <list>
#include <map>
#include <unordered_map>
#include <chrono>
#include <numeric>
using namespace std;
using ll = long long;
const ll INF = (ll)1e18+1;
const ll DIV = 1000000007;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
#ifdef TEST
chrono::system_clock::time_point start, end;
start = chrono::system_clock::now();
#endif
ll N, K;
cin >> N >> K;
vector<ll> A(N);
ll min_num = INF;
for(size_t i=0;i<N; i++)
{
cin >> A[i];
min_num = min(min_num, A[i]);
}
vector<ll> min_index;
for(size_t i=0;i<N; i++)
{
if(min_num == A[i]) min_index.push_back(i);
}
ll _idx = 0;
ll dist=0;
ll count = 0;
if((N - min_index.size()) % (K-1) == 0) count = (N-min_index.size()) / (K-1);
else count = (N-min_index.size()) / (K-1) + 1;
cout << count << endl;
#ifdef TEST
end = chrono::system_clock::now();
cerr << static_cast<double>(chrono::duration_cast<chrono::microseconds>(end - start).count() / 1000.0) << "[ms]" << endl;
#endif
return 0;
} | 0 | 94,697,781 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)n;i++)
using Graph = vector<vector<int> >;
using GraphC = vector<vector<char> >;
const int INF = 1000000000;
typedef pair<int, int> P;
const int MAX_N = 1000000;
const int MAX_L = 100000000;
const int MAX_SQRT_B = 10000;
typedef int64_t ll;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int N, M;
int WA[105000];
bool AC[1050000];
void solve() {
cin >> N >> M;
int WAnum = 0;
int ACnum = 0;
for (int i = 1; i <= N; i++)
{
WA[i] = 0;
AC[i] = false;
}
while (M--)
{
int p;
string S;
cin >> p >> S;
if (AC[p])continue;
if (S=="AC")
{
AC[p] = true;
ACnum++;
WAnum += WA[p];
}
else if (S == "WA") {
WA[p]++;
}
}
cout << ACnum << " " << WAnum << endl;
return;
}
int main()
{
solve();
return 0;
} | #include <iostream>
using namespace std;
#define MOD 1000000007
int main(int argc, const char * argv[]) {
int S;
cin>>S;
int a=0,a_1=0,a_2=0,a_3=1;
for(int i=2;i<S;++i){
a=a_1+a_3;
a%=MOD;
a_3=a_2;
a_2=a_1;
a_1=a;
}
cout<<a<<endl;
return 0;
} | 0 | 43,648,042 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,N) for(int i=0,i##_max=(N);i<i##_max;++i)
#define repp(i,l,r) for(int i=(l),i##_max=(r);i<i##_max;++i)
#define per(i,N) for(int i=(N)-1;i>=0;--i)
#define perr(i,l,r) for(int i=r-1,i##_min(l);i>=i##_min;--i)
#define all(arr) (arr).begin(), (arr).end()
#define SP << " " <<
#define SPF << " "
#define SPEEDUP cin.tie(0);ios::sync_with_stdio(false);
#define MAX_I INT_MAX
#define MIN_I INT_MIN
#define MAX_UI UINT_MAX
#define MAX_LL LLONG_MAX
#define MIN_LL LLONG_MIN
#define MAX_ULL ULLONG_MAX
typedef long long ll;
typedef pair<int,int> PII;
typedef pair<char,char> PCC;
typedef pair<ll,ll> PLL;
typedef pair<char,int> PCI;
typedef pair<int,char> PIC;
typedef pair<ll,int> PLI;
typedef pair<int,ll> PIL;
typedef pair<ll,char> PLC;
typedef pair<char,ll> PCL;
inline void YesNo(bool b){ cout << (b?"Yes" : "No") << endl;}
inline void YESNO(bool b){ cout << (b?"YES" : "NO") << endl;}
inline void Yay(bool b){ cout << (b?"Yay!" : ":(") << endl;}
int main(void){
SPEEDUP
cout << setprecision(15);
int A,B;cin >> A >> B;
int H = 100, W = 100;
cout << H SP W << endl;
vector<vector<char> > maze(H,vector<char>(W,'.'));
rep(i,H/2) rep(j,W) maze[i][j] = '#';
bool ischeck = false;
int count = 0;
rep(i,H/2-1){
rep(j,W){
if(count == A-1){
ischeck = true;
break;
}
maze[i][j] = '.';
++count;
++j;
}
if(ischeck) break;
++i;
}
count = 0;
ischeck = false;
repp(i,H/2+1,H){
rep(j,W){
if(count == B-1){
ischeck = true;
break;
}
maze[i][j] = '#';
++count;
++j;
}
if(ischeck) break;
++i;
}
rep(i,H){
rep(j,W) cout << maze[i][j];
cout << endl;
}
return 0;
} | #include <iostream>
#include <stack>
using namespace std;
bool issame(char a,char b){
if(a=='(')return b==')';
if(a=='[')return b==']';
}
int main(){
while(1){
char in;
in=cin.peek();
if(in=='.')return 0;
stack<char> sta;
bool iscorrect=true;
while(cin.get(in),in!='.'){
if(cin.eof())return 0;
if(in=='('||in=='['){
sta.push(in);
}else if(in==')'||in==']'){
if(sta.empty()||!issame(sta.top(),in)){
iscorrect=false;
break;
}
sta.pop();
}
}
cout<<((iscorrect&&sta.empty())? "yes":"no")<<endl;
cin.ignore(100,'\n');
}
} | 0 | 57,413,755 |
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <map>
#include <numeric>
#include <cmath>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <complex>
#include <string.h>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <iomanip>
#include <sys/time.h>
#include <tuple>
#include <random>
using namespace std;
#define endl '\n'
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define UNIQ(v) (v).erase(unique((v).begin(), (v).end()), (v).end())
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef complex<double> comp;
typedef vector< vector<ld> > matrix;
struct pairhash {
public:
template<typename T, typename U>
size_t operator()(const pair<T, U> &x) const {
size_t seed = hash<T>()(x.first);
return hash<U>()(x.second) + 0x9e3779b9 + (seed<<6) + (seed>>2);
}
};
const int inf = 1e9 + 9;
const ll mod = 1e9 + 7;
const double eps = 1e-8;
const double pi = acos(-1);
ll n, x;
ll solve() {
ll res = x;
ll p = n, q = n-x;
if (p % q == 0) {
res += (2*(p/q)-2) * q;
} else {
res += (2*(p/q)-1) * q;
}
ll r = p % q;
p = q;
q = r;
while (q > 0) {
if (p % q == 0) {
res += (2*(p/q)-1) * q;
} else {
res += (2*(p/q)) * q;
}
r = p % q;
p = q;
q = r;
}
return res;
}
void input() {
cin >> n >> x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
input();
cout << solve() << endl;
} | #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);
struct Edge {
Edge(int a, int b, int c) : a(a), b(b), c(c) {}
int a, b, c;
};
int n, m; std::cin >> n >> m;
vvi to(n, vi(n, inf)), cost;
vector<Edge> edges;
rep(i, n) to[i][i] = 0;
rep(i, m) {
int a, b, c; std::cin >> a >> b >> c;
--a, --b;
to[a][b] = to[b][a] = c;
edges.pb(Edge(a, b, c));
}
cost = to;
rep(k, n) rep(i, n) rep(j, n) chmin(cost[i][j], cost[i][k] + cost[k][j]);
int ans = m;
rep(i, m) {
int a = edges[i].a, b = edges[i].b;
bool used = false;
rep(j, n) {
if (cost[j][a]+to[a][b] == cost[j][b]) used = true;
}
if (used) ans--;
}
std::cout << ans << "\n";
} | 0 | 98,771,087 |
#include<iostream>
#include<stdio.h>
#include<string>
#include<math.h>
#include<iomanip>
#include<algorithm>
#include<string.h>
#include<cctype>
#include<map>
#include<set>
#include<vector>
#include<sstream>
#include<stack>
#include<queue>
using namespace std;
const int MAX_N=10000+5;
int n;
int par[MAX_N];
int rank[MAX_N];
void init()
{
for(int i=0;i<n;i++)
{
par[i]=i;
rank[i]=0;
}
}
int find(int x)
{
if(par[x]==x) return x;
else return par[x]=find(par[x]);
}
void unite(int x,int y)
{
x=find(x);
y=find(y);
if(x==y) return;
if(rank[x]<rank[y]) par[x]=y;
else
{
par[y]=x;
if(rank[x]==rank[y]) rank[x]++;
}
}
bool same(int x,int y)
{
return find(x)==find(y);
}
int main()
{
int q;
cin>>n>>q;
init();
while(q--)
{
int a,b,c;
cin>>a>>b>>c;
if(a==0) unite(b,c);
else
{
if(same(b,c)) cout<<"1"<<endl;
else cout<<"0"<<endl;
}
}
return 0;
} | #include <iostream>
#include <map>
#include <cmath>
#include <queue>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
int N, M;
int A[1 << 18], B[1 << 18], C[1 << 18], D[1 << 18];
int main() {
cin >> N >> M;
for (int i = 1; i <= N; i++) cin >> A[i] >> B[i];
for (int i = 1; i <= M; i++) cin >> C[i] >> D[i];
for (int i = 1; i <= N; i++) {
int minx = (1 << 30), minid = -1;
for (int j = 1; j <= M; j++) {
int dst = abs(A[i] - C[j]) + abs(B[i] - D[j]);
if (minx > dst) { minx = dst; minid = j; }
}
cout << minid << endl;
}
return 0;
} | 0 | 68,623,639 |
#include<iostream>
#include<map>
using namespace std;
int main() {
string S, T;
cin >> S >> T;
int N = S.size();
map<char, char> M;
bool transformable = true;
for (int i = 0; i < N; i++) {
if (M.find(S[i]) != M.end() && M[S[i]] != T[i]) { transformable = false; break; }
M[S[i]] = T[i];
}
M.clear();
for (int i = 0; i < N; i++) {
if (M.find(T[i]) != M.end() && M[T[i]] != S[i]) { transformable = false; break; }
M[T[i]] = S[i];
}
cout << (transformable ? "Yes" : "No") << endl;
} | #include<iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int main(void){
int n;
int taro=0,hanako=0;
char string1[101],string2[101];
cin >> n;
for(int i = 0;i<n;i++){
cin >> string1 >> string2;
if(strcmp(string1,string2)==0){
taro++;
hanako++;
}else if(strcmp(string1,string2)>0){
taro+=3;
}else{
hanako+=3;
}
}
cout << taro << " " << hanako << endl;
} | 0 | 23,900,773 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s,t;
cin >> s >> t;
vector<char> s_sort(s.size()),t_sort(t.size());
for(int i=0; i<s.size(); i++){
s_sort.at(i)=s.at(i);
}
for(int i=0; i<t.size(); i++){
t_sort.at(i)=t.at(i);
}
sort(s_sort.begin(),s_sort.end());
sort(t_sort.begin(),t_sort.end(),greater<>());
if(s_sort<t_sort) cout << "Yes" << endl;
else cout << "No" << endl;
} | #include<bits/stdc++.h>
#define fo(i,l,r) for(int i=l;i<=r;i++)
#define of(i,l,r) for(int i=l;i>=r;i--)
#define fe(i,u) for(int i=head[u];i;i=e[i].next)
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
inline void open(const char *s)
{
#ifndef ONLINE_JUDGE
char str[20];
sprintf(str,"%s.in",s);
freopen(str,"r",stdin);
#endif
}
inline int rd()
{
static int x,f;
x=0;f=1;
char ch=getchar();
for(;ch<'0'||ch>'9';ch=getchar())if(ch=='-')f=-1;
for(;ch>='0'&&ch<='9';ch=getchar())x=x*10+ch-'0';
return f>0?x:-x;
}
const int N=1010;
int n,a[N],b[N],B;
inline void gao(int x,int y,int k)
{
if(k==-1)return;
if(abs(x)>=(1<<k)){
if(x>0){
cout<<'R';
x-=(1<<k);
return gao(x,y,k-1);
}
else{
cout<<'L';
x+=(1<<k);
return gao(x,y,k-1);
}
}
if(abs(y)>=(1<<k)){
if(y>0){
cout<<'U';
y-=(1<<k);
return gao(x,y,k-1);
}
else{
cout<<'D';
y+=(1<<k);
return gao(x,y,k-1);
}
}
if(abs(x)>abs(y)){
if(x>0){
cout<<'R';
x-=1<<k;
return gao(x,y,k-1);
}
else{
cout<<'L';
x+=1<<k;
return gao(x,y,k-1);
}
}
else{
if(y>0){
cout<<'U';
y-=1<<k;
return gao(x,y,k-1);
}
else{
cout<<'D';
y+=1<<k;
return gao(x,y,k-1);
}
}
}
int main()
{
n=rd();fo(i,1,n)a[i]=rd(),b[i]=rd();
fo(i,1,n-1)if((abs(a[i])^abs(b[i])^abs(a[i+1])^abs(b[i+1]))&1)
return puts("-1"),0;
int f=~(abs(a[1])+abs(b[1]))&1;
B=30;
cout<<B+f+1<<'\n';
of(i,B,0)cout<<(1<<i)<<' ';
if(f){cout<<1;fo(i,1,n)++a[i];}
cout<<'\n';
fo(i,1,n){
gao(a[i],b[i],B);
if(f)cout<<'L';
cout<<'\n';
}
return 0;
} | 0 | 25,639,234 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e15;
int main(){
ll N; cin >> N;
vector<ll> V(N); for(int i = 0; i < N; i++) cin >> V[i];
sort(V.begin(), V.end());
ll SUM = V[N-1], idx = N-1;
for(int i = 0; i < N-1; i++) SUM-=V[i];
ll ans = SUM;
for(int i = N-2; i > 0; i--){
SUM += 2*V[i];
if(ans < SUM){
ans = SUM;
idx = i;
}
}
cout << ans << endl;
vector<ll> A;
ll idx2 = idx-1;
ll t = V[idx2];
idx2--;
while(idx < N-1){
cout << t << " " << V[idx] << endl;;
t -= V[idx];
idx++;
}
A.push_back(t);
while(idx2 >= 0){
A.push_back(V[idx2]);
idx2--;
}
t = V[N-1];
for(auto a : A){
cout << t << " " << a << endl;
t -= a;
}
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main()
{
int n, m;
cin >> n >> m;
vector<vector<int>> vec(n + 1, vector<int>(n + 1));
rep(i, m)
{
int a, b;
cin >> a >> b;
vec[a][b] = 1;
vec[b][a] = 1;
}
vector<int> v(n);
rep(i, n) v[i] = i + 1;
int ans = 0;
sort(v.begin(), v.end());
do
{
if (v[0] != 1)
break;
bool ok = true;
rep(i, n - 1)
{
if (vec[v[i]][v[i + 1]] == 0)
ok = false;
}
if (ok)
ans++;
} while (next_permutation(v.begin(), v.end()));
cout << ans << endl;
return 0;
} | 0 | 83,913,561 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
ll chose2(ll n) {
return n * (n - 1) / 2;
}
int main() {
int n;
cin >> n;
vector<int> as(n);
rep(i, n) cin >> as[i];
rep(i, n) as[i]--;
vector<int> cnt(n);
rep(i, n) cnt[as[i]]++;
ll tot = 0;
rep(i, n) { tot += chose2(cnt[i]); }
rep(i, n) {
ll ans = tot;
ans -= chose2(cnt[as[i]]);
ans += chose2(cnt[as[i]] - 1);
cout << ans << endl;
}
return 0;
} | #include<cstdio>
#include<math.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
#include<set>
#include<cstring>
#include<map>
using namespace std;
#define int long long int
#define rep(i,n) for(int i=0;i<n;i++)
#define INF 1001001001
#define LLINF 1001001001001001001
#define mp make_pair
#define pb push_back
#define mod 1000000007
int N,A,B,C;
int l[10];
signed main(){
scanf("%lld %lld %lld %lld",&N,&A,&B,&C);
rep(i,N)scanf("%lld",&l[i]);
int ans=INF;
rep(i,1<<2*N){
int matsu[10];
int a=0,b=0,c=0;
int i_=i;
int sans=-30;
rep(j,N){
matsu[j]=i_%4;
if(matsu[j]==1){a+=l[j];sans+=10;}
if(matsu[j]==2){b+=l[j];sans+=10;}
if(matsu[j]==3){c+=l[j];sans+=10;}
i_/=4;
}
if(a==0||b==0||c==0)continue;
sans+=abs(a-A);
sans+=abs(b-B);
sans+=abs(c-C);
ans=min(ans,sans);
}
printf("%lld\n",ans);
} | 0 | 32,686,857 |
#include <bits/stdc++.h>
#define rep(i, e, n) for (int i = e; i < (n); ++i)
using namespace std;
typedef long long ll;
using P = pair<int,int>;
const ll inf=1000000000007;
int main(){
ll n;
cin >> n;
vector<ll> a(n+1,1);
rep(i,2,n+1){
for(int j=i; j<n+1; j+=i){
a[j]++;
}
}
ll ans=1;
rep(i,2,n+1){
ans= ans + a[i]*i;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, srt, end) for (long long i = (srt); i < (long long)(end); i++)
int main(){
ll x, y, z, k;
cin >> x >> y >> z >> k;
vector<ll> a(x), b(y), c(z);
rep(i, 0, x) cin >> a[i];
rep(i, 0, y) cin >> b[i];
rep(i, 0, z) cin >> c[i];
vector<ll> d(x*y);
rep(i, 0, x){
rep(j, 0, y){
d[i*y + j] = a[i] + b[j];
}
}
sort(d.begin(), d.end(), greater<ll>());
vector<ll> e(min(x*y,k)*z);
rep(i, 0, min(x*y,k)){
rep(j, 0, z){
e[i*z+j] = d[i] + c[j];
}
}
sort(e.begin(), e.end(), greater<ll>());
rep(i, 0, k) cout << e[i] << "\n";
return 0;
} | 0 | 61,859,138 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
typedef pair<int, int> pii;
#define mp(a, b) make_pair(a, b)
#define sqr(s) ((s) * (s))
const int inf = 0x7fffffff / 3.27;
const int maxn = 105;
int i, j, t, n, m, l, r, k, z, y, x;
int a, b;
char f[maxn][maxn];
void calc(int a, int b) {
int i, j;
i = 1;
while (a > 1 && i + 5 <= n) {
for (j = 1; j <= m; j++) {
f[i][j] = f[i + 1][j] = f[i + 2][j] = '.';
f[i + 3][j] = f[i + 4][j] = f[i + 5][j] = '#';
}
a--;
b--;
i += 6;
}
for (; i <= n; i++)
for (j = 1; j <= m; j++) f[i][j] = '.';
a--;
i = 5;
while (a > 0) {
for (j = 1; j <= m; j += 2) {
f[i][j] = '.';
a--;
if (a == 0) break;
}
i += 6;
}
i = 2;
while (b > 0) {
for (j = 1; j <= m; j += 2) {
f[i][j] = '#';
b--;
if (b == 0) break;
}
i += 6;
}
}
int main() {
int I, T = 1;
for (I = 1; I <= T; I++) {
scanf("%d%d", &a, &b);
n = m = 100;
calc(min(a, b), max(a, b));
if (a > b) {
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
f[i][j] = (f[i][j] == '.') ? '#' : '.';
}
}
printf("%d %d\n", n, m);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) printf("%c", f[i][j]);
printf("\n");
}
}
return 0;
} | #include <bits/stdc++.h>
#include <limits>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
#define fi(i,n) for( ll i=0 ; i<n ; i++ )
#define f(i, a, b) for( ll i=a ; i<b ; i++ )
#define vi vector<int>
#define pb push_back
#define MOD 1000000007
ll digits(ll n)
{
return floor(log10(double(n))) + 1;
}
ll SieveOfEratosthenes(ll n)
{
vector<bool>prime(n+1);
int ans = 0;
for(int i =0;i<=n;i++)
prime[i] = true;
prime[1] = false;
for (ll p=2; p*p<=n; p++)
{
if (prime[p] == true)
{
for (ll i=p*p; i<=n; i += p)
prime[i] = false;
}
}
for(int i = 2;i<=n;i++)
{
if(prime[i])
{
ans++;
}
}
return ans;
}
void permute(string a, int l, int r)
{
if (l == r)
{
cout<<a<<endl;
}
else
{
for (int i = l; i <= r; i++)
{
swap(a[l], a[i]);
permute(a, l+1, r);
}
}
}
ll modularExponentiation(ll x,ll n,ll M)
{
ll result = 1;
ll ans = 1;
while(n>0)
{
if(n % 2 ==1)
{
result = (result*x)%MOD;
ans = (ans + result)%MOD;
}
n = n/2;
if(n>0)
{
x = x*x;
}
}
return ans;
}
int d, x, y;
void extendedEuclid(int A, int B) {
if(B == 0) {
d = A;
x = 1;
y = 0;
}
else {
extendedEuclid(B, A%B);
int temp = x;
x = y;
y = temp - (A/B)*y;
}
}
ll fact(ll n)
{
ll ans = 1;
for(ll i = 1;i<=n;i++)
ans = (ans%MOD * i%MOD)%MOD;
return ans%MOD;
}
ll maxpower(ll n,ll k)
{
ll count = 0;
while(n>0)
{
n = n/k;
if(n>0)
count++;
}
return count;
}
bool written(ll n,ll k,string s,ll power)
{
while(power>=0 && n>0)
{
ll x = pow(k,power);
if(n - x>=0)
{
if(s[power] == '1')
return false;
n = n - x;
}
power--;
}
cout<<n<<endl;
if(n!=0)
return false;
return true;
}
void improvise(string s,ll n,ll k,ll power)
{
for(int i = power;i>=0;i--)
{
ll x = pow(k,i);
if(n - x>=0)
{
s[i] = '1';
n = n - pow(k,i);
}
}
}
int main()
{
ll n;
cin>>n;
int arr[n];
int sum = 0;
fi(i,n)
{
cin>>arr[i];
sum += arr[i];
}
int x1 = sum/n;
int x2 = sum/n + 1;
ll ans1 = 0;
ll ans2 = 0;
fi(i,n)
{
ans1 = ans1 + (arr[i] - x1)*(arr[i] - x1);
ans2 = ans2 + (arr[i] - x2)*(arr[i] - x2);
}
cout<<min(ans1,ans2);
} | 0 | 75,758,632 |
#include <iostream>
#include <fstream>
#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <functional>
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
using namespace std;
#define ll long long int
#define rep(i,n) for( int i = 0; i < n; i++ )
#define rrep(i,n) for( int i = n; i >= 0; i-- )
#define REP(i,s,t) for( int i = s; i <= t; i++ )
#define RREP(i,s,t) for( int i = s; i >= t; i-- )
#define dump(x) cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define mod 1000000007
#define INF2 1000000000000000000
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin >> n;
double ans = 0.0;
rep(i, n) {
int a; cin >> a;
ans += 1.0/a;
}
cout << fixed << setprecision(12) << 1.0/ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FAST ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define mp make_pair
#define pb push_back
#define lp(i,s,f) for(ll i = s; i < ll(f); i++)
#define inF freopen("input.in", "r", stdin);
#define outF freopen("output.in", "w", stdout);
#define endl '\n'
#define MOD 1000000007
#define mm(arr) memset(arr, 0, sizeof(arr))
#define F first
#define S second
int main(){
FAST
int k, a, b;
cin >> k >> a >> b;
int c = 1;
while(k*c <= b){
if(k*c >= a && k*c <= b){
cout << "OK";
return 0;
}
c++;
}
cout << "NG";
return 0;
} | 0 | 63,910,472 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define REP(i, l, r) for (int i=(l); i<(r); ++i)
#define RREP(i, r, l) for (int i=(r); i>(l); --i)
#define CASET int _T; cin >> _T; REP(caset, 0, _T)
#define print(x) cout << to_string(x) << '\n'
#define vi vector<int>
#define vb vector<bool>
#define vs vector<string>
#define vvi vector<vi>
#define vvb vector<vb>
#define pii pair<int,int>
#define t3i tuple<int,int,int>
#define mii map<int,int>
#define vpii vector<pii>
#define vt3i vector<t3i>
#define sq(x) (x)*(x)
#define inv(x) powa(x, MOD-2)
long long INF = 1LL<<60;
long long MOD = 1e9+7;
string to_string(char &c) {string x(1, c); return x;}
string to_string(const char s[]) {return (string)s;}
string to_string(string &s) {return s;}
string to_string(vb &v) {string res; for (const bool &x : v) res += to_string(x) + ' '; return res;}
template <class C> string to_string(C &v) {string res; for (auto &x : v) res += to_string(x) + ' '; return res;}
template <typename A, typename B> istream &operator>>(istream &is, pair<A, B> &pr) {is >> pr.first >> pr.second; return is;}
template <typename A> istream &operator>>(istream &is, vector<A> &v) {for (auto &x : v) is >> x; return is;}
ostream &operator<<(ostream &os, char &c) {os << (char)c; return os;}
ostream &operator<<(ostream &os, const char s[]) {os << (string)s; return os;}
ostream &operator<<(ostream &os, string &s) {for (char &c : s) os << (char)c; return os;}
template <typename A, typename B> ostream &operator<<(ostream &os, pair<A, B> pr) {os << '(' << pr.first << ", " << pr.second << ')'; return os;}
ostream &operator<<(ostream &os, vb &v) {
bool first = true;
os << '[';
for (const bool &x : v) {
if (!first) os << ", ";
first = false;
os << x;
}
os << ']';
return os;
}
template <class C> ostream &operator<<(ostream &os, C &v) {
bool first = true;
os << '[';
for (auto &x : v) {
if (!first) os << ", ";
first = false;
os << x;
}
os << ']';
return os;
}
string bin_string(int x) {
const int d = 32;
string res(d, ' ');
REP(i, 0, d) res[d-1-i] = '0'+(x>>i & 1LL);
return res;
}
int powa(int base, int exp) {
int res = 1;
while (exp) {
if (exp&1) res = res*base % MOD;
base = base*base % MOD;
exp >>= 1;
}
return res;
}
main() {
ios::sync_with_stdio(0), cin.tie(0);
int n,m,v,p;
cin >> n >> m >> v >> p;
vi a(n);
cin >> a;
sort(a.begin(), a.end());
vi pref = a;
REP(i, 1, n) pref[i] += pref[i-1];
v -= p-1;
int k = -1;
for (int b=n; b>=1; b/=2) {
while (k+b<n-p) {
int chk = k+b;
int ev = v - (chk+1);
ev = max(0LL, ev);
if (m >= a[n-p]-a[chk]) {
int sm = pref[n-p] - pref[chk];
if (sm + m*ev <= (m+a[chk])*(n-p-chk)) break;
}
k += b;
}
}
++k;
int res = 0;
REP(i, 0, n) if (a[i] >= a[k]) ++res;
print(res);
} | #include<bits/stdc++.h>
using namespace std;
#define ANSWER(x) cout<<x<<endl
#define debug(x) cout<<#x<<": "<<x
typedef pair<int,int> P;
void bfs(int sx,int sy);
int H,W,N,a;
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
int cheese_x[10];
int cheese_y[10];
char ch[1001][1001];
int al[1001][1001];
int S_x,S_y,hp = 1,dis;
int main(){
cin >> H >> W >> N;
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
cin >> ch[i][j];
if(ch[i][j] == 'S'){
S_x = j;
S_y = i;
}
}
}
for(int i=0;i<N;i++){
bfs(S_x,S_y);
}
cout << a << endl;
}
void bfs(int sx,int sy){
queue<P> que;
que.push(P(sx,sy));
al[sy][sx] = a;
while(!que.empty()){
P now = que.front();que.pop();
int x = now.first;
int y = now.second;
if(ch[y][x] - '0' == hp){
hp++;
S_x = x;
S_y = y;
a = al[y][x];
memset(al,0,sizeof(al));
break;
}
for(int i=0;i<4;i++){
int mx = x + dx[i];
int my = y + dy[i];
if(mx < 0 || my < 0 || mx >= W || my >= H)continue;
if(ch[my][mx] != 'X' && al[my][mx] == false){
que.push(P(mx,my));
al[my][mx] = al[y][x] + 1;
}
}
}
} | 0 | 61,705,343 |