code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <iostream>
#include <climits>
#include <vector>
#include <cmath>
using namespace std;
vector<int> A;
vector<int> g;
int n, m;
int cnt;
auto prn=[=](){
for(auto a : A)
cout<<a<<"\n";
};
void _insSort(int g){
for(int i=g-1;i<n;i++){
int maxi=i;
for(int j=i+g;j<n;j+=g){
if(A[j] < A[maxi]){
maxi=j;
}
}
if(i!=maxi){
swap(A[i],A[maxi]);
cnt++;
}
}
// cout<<"----"<<g<<"-----\n";
// prn();
}
void insSort(int g){
for(int i=g;i<n;i++){
int v = A[i];
int j = i - g;
while(j>=0 && A[j] > v){
A[j+g] = A[j];
j -= g;
cnt++;
}
A[j+g] = v;
}
}
void ShellSort(){
int i;
cnt=0;
m = n;
if(m>100)
m=100;
g.push_back(1);
for(i=1;pow(4,i)+3*pow(2,i-1)+1<n&&i<=m;i++){
g.push_back(pow(4,i)+3*pow(2,i-1)+1);
}
if(i!=m)
m=i;
for(i=g.size()-1;i>=0;i--)
insSort(g[i]);
}
int main(){
ios::sync_with_stdio(false);
int t;
cin>>n;
for(int i=0;i<n;i++){
cin>>t;
A.push_back(t);
}
ShellSort();
cout<<m<<"\n";
for(int i=g.size()-1;i>0;i--)
cout<<g[i]<<" ";
cout<<g[0]<<"\n";
cout<<cnt<<endl;
prn();
return 0;
} | #include <iostream>
#include <cmath>
using namespace std;
int insertionSort(int a[], int n, int g){
int cnt = 0;
for(int i=g;i<n;++i){
int v = a[i];
int j = i - g;
while(j>=0 && a[j]>v){
a[j+g] = a[j];
j = j - g;
++cnt;
}
a[j+g] = v;
}
return cnt;
}
int* interleavedlist(int n, int *m){
int i = 1, j = 0;
*m = log10(2*n+1) / log10(3);
int *g = new int[*m];
while(i<=n){
g[j] = i;
++j;
i = 3 * i + 1;
}
return g;
}
void shellSort(int a[], int n){
int cnt = 0;
int m;
int *g = interleavedlist(n,&m);
cout<<m<<endl;
for(int i=m-1;i>=0;--i)cout<<g[i]<<(i?" ":"");
cout<<endl;
for(int i=m-1;i>=0;--i){
cnt += insertionSort(a,n,g[i]);
}
cout<<cnt<<endl;
}
int main() {
int n, *data;
cin>>n;
data = new int[n];
for(int i=0;i<n;++i){
cin>>data[i];
}
shellSort(data,n);
for(int i=0;i<n;++i){
cout<<data[i]<<endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#include <cstdlib>
#define rep(i,n) for(int i=0;i<(n);++i)
using namespace std;
using ll = long long;
const int MOD = 1000000007;
long long mod(long long val, long long m) {
long long res = val % m;
if (res < 0) res += m;
return res;
}
bool is_prime(long long N) {
if (N == 1) return false;
for (long long i = 2; i * i <= N; ++i) {
if (N % i == 0) return false;
}
return true;
}
vector<pair<long long, long long> > prime_factorize(long long N) {
vector<pair<long long, long long> > res;
for (long long a = 2; a * a <= N; ++a) {
if (N % a != 0) continue;
long long ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1) res.push_back({N, 1});
return res;
}
int main() {
int K,T,max=0,ans=0,sum=0;
cin >> K >> T;
vector<int> a(T);
rep(i,T) {
cin >> a[i];
sum+=a[i];
if(a[i]>max) max=a[i];
}
sum-=max;
//sort(T.begin(),T.end(),greater<int>());
if(sum>max-2) ans=0;
else ans=max-sum-1;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define all(a) (a).begin(),(a).end()
int main()
{
int k,t;
cin >> k >> t;
vector<int> a(t);
for (int i = 0; i < t; i++)
{
cin >> a[i];
}
sort(all(a));
reverse(all(a));
int ans = max(a[0] - 1 - (k - a[0]) ,0);
cout << ans << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
typedef pair<int,int> ii;
priority_queue<int> q;
vector<ii> v;
int n, sum = 0;
signed main() {
ios_base::sync_with_stdio(false); cin.tie(0);
cin >> n;
for(int i = 0 ; i < n ; ++i) {
int D, L; cin >> D >> L;
v.push_back(ii(D + L,L));
}
sort(v.begin(),v.end());
for(int i = 0 ; i < n ; ++i) {
q.push(v[i].se);
sum += v[i].se;
if(sum > v[i].fi) {
sum -= q.top();
q.pop();
}
}
cout << q.size() << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using Int = long long;
int main() {
int N; cin >> N;
vector<tuple<int, int, int>> A(N);
for (int i = 0; i < N; i++) {
int h, p; cin >> h >> p;
A[i] = make_tuple(h + p, h, p);
}
sort(begin(A), end(A));
const Int INF = 1e18;
vector<Int> dp(N+1, INF), dp2;
dp[0] = 0;
for (int i = 0; i < N; i++) {
dp2 = dp;
int h = get<1>(A[i]), p = get<2>(A[i]);
for (int j = 0; j < N; j++) {
if (dp2[j] == INF || dp2[j] > h) {
break;
}
dp[j+1] = min(dp[j+1], dp2[j] + p);
}
}
int ans = 0;
for (int i = 0; i <= N; i++) {
if (dp[i] != INF) {
ans = i;
}
}
cout << ans << '\n';
return 0;
}
| 1 |
#include <stdio.h>
typedef struct _Gem{
int x;
int y;
bool hit;
} Gem;
static void
pick_gem(Gem* g, int n, int x, int y)
{
for (int i = 0; i < n; i++) {
if (!g[i].hit && g[i].x == x && g[i].y == y) {
g[i].hit = true;
return;
}
}
}
static bool
check_gem(Gem* g, int n)
{
for (int i = 0; i < n; i++) {
if (g[i].hit == false) {
return false;
}
}
return true;
}
int
main(void)
{
char line[80];
int n;
int m;
Gem g[20];
char d[30];
int l[30];
while (true) {
if (fgets(line, sizeof line, stdin) == NULL) {
return 1;
}
if (sscanf(line, "%d", &n) != 1) {
return 1;
}
if (n == 0) {
break;
}
for (int i = 0; i < n; i++) {
if (fgets(line, sizeof line, stdin) == NULL) {
return 1;
}
if (sscanf(line, "%d %d", &(g[i].x), &(g[i].y)) != 2) {
return 1;
}
g[i].hit = false;
}
if (fgets(line, sizeof line, stdin) == NULL) {
return 1;
}
if (sscanf(line, "%d", &m) != 1) {
return 1;
}
for (int i = 0; i < m; i++) {
if (fgets(line, sizeof line, stdin) == NULL) {
return 1;
}
if (sscanf(line, "%c %d", &(d[i]), &(l[i])) != 2) {
return 1;
}
}
int x = 10;
int y = 10;
for (int i = 0; i < m; i++) {
if (d[i] == 'N') {
for (int k = 1; k <= l[i]; k++) {
pick_gem(g, n, x, ++y);
}
} else if (d[i] == 'S') {
for (int k = 1; k <= l[i]; k++) {
pick_gem(g, n, x, --y);
}
} else if (d[i] == 'E') {
for (int k = 1; k <= l[i]; k++) {
pick_gem(g, n, ++x, y);
}
} else {
for (int k = 1; k <= l[i]; k++) {
pick_gem(g, n, --x, y);
}
}
}
printf("%s\n", (check_gem(g, n) ? "Yes" : "No"));
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
bool field[32][32];
const string dic="NESW";
const int dx[]={0,1,0,-1};
const int dy[]={1,0,-1,0};
int main(){
while(true){
int n; cin>>n;
if(n==0) return 0;
for(int i=0;i<32;i++) for(int j=0;j<32;j++) field[i][j]=false;
for(int i=0;i<n;i++){
int x,y; cin>>x>>y;
field[y][x]=true;
}
int m; cin>>m;
int cx=10,cy=10;
for(int i=0;i<m;i++){
char d; int l; cin>>d>>l;
for(int j=0;j<4;j++){
if(dic[j]==d){
for(int k=0;k<l;k++){
cx+=dx[j];
cy+=dy[j];
if(field[cy][cx]){
n--;
field[cy][cx]=false;
}
}
break;
}
}
}
if(n==0) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
} | 1 |
#include<iostream>
#include<map>
#include<vector>
#include<algorithm>
#include<cmath>
#include<climits>
#include<ctime>
#include<cstring>
#define ALL(v) (v).begin(),(v).end()
#define REP(i,p,n) for(int i=p;i<(int)(n);++i)
#define rep(i,n) REP(i,0,n)
#define DUMP(list) cout << "{ "; for(auto nth : list){ cout << nth << " "; } cout << "}" << endl;
using namespace std;
int main() {
int n, p; // テ、ツクツ甘ゥツ卍?50 50
int kouho[50];
//10^6
while(cin >> n >> p && n && p)
{
//cout << n << " " << p << endl;
rep(i,50){kouho[i]=0;}
int box = p;
int index=0;
while(true)
{
if(index >= n){ index=0; }
if(box>0){
box--; kouho[index]++;
}else{
box=kouho[index]; kouho[index]=0;
bool flag=false;
/*
rep(i,n){if(kouho[i]!=0){flag=false;}}
if(flag){cout << index << endl; break;}
*/
rep(i,n){
if(kouho[i]==p){flag=true;}
}
if(flag){
if(index==0){index=n;}
cout << (index-1)%n << endl; break;
}
}
index++;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
int n,m;
scanf("%d%d",&n,&m);
if(n&1)for(int i=1;i<=m;i++){
printf("%d %d\n",i,n-i);
}
else{
int cnt = 0;
for(int i=1;cnt<m&&i<=n/4;cnt++,i++){
printf("%d %d\n",i,n/2-i+1);
}
int cur = 1;
for(int i=n/2+1;cnt<m;i++,cnt++){
printf("%d %d\n",i,n-cur);
cur++;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 100000000;
#define rep1(i, n) for (ll i=0; i<(n); i++)
#define rep2(i, k, n) for (ll i=k; i<(n); i++)
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 mod = 2019;
int main() {
ll l, r;
cin >> l >> r;
map<ll, ll> m;
for (ll i = l; i <= r && i <= l+5000; i++){
m[i%mod]++;
}
ll ans = 2020;
vector<ll> a;
for (auto x: m){
rep1(i, x.second) a.push_back(x.first);
}
ll n = a.size();
for (ll i=0; i<(n); i++){
for (ll j=i+1; j<(n); j++){
ans = min(ans, a[i]*a[j]%2019);
}
}
cout << ans << endl;
//printf("%.12f", ans);
} | #include<bits/stdc++.h>
using namespace std;
/*#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
typedef tree<long long,null_type,less<long long>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
s.find_by_order(x) xth element in set
x.order_of_key(x) number of elements <x*/
#define ll long long
#define vi vector<int>
#define si set<int>
#define mii map<int,int>
#define pb push_back
#define pf push_front
#define pii pair<int,int>
#define extract_word(s) stringstream str(s); while(str>>word)
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define SET(s) cout<<fixed<<setprecision(s)
#define chotu 1000000007
#define set0(a) memset(a,0,sizeof(a))
#define endl "\n"
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define lower_string(s) transform(all(s),s.begin(),::tolower())
#define upper_string(s) transform(all(s),s.begin(),::toupper())
#define size(s) s.size()
template<class T> bool umin(T &a, T b) { return a > b ? (a = b, true) : false; }
template<class T> bool umax(T &a, T b) { return a < b ? (a = b, true) : false; }
template<typename T,typename U>
bool compare(T x,U y){return(abs(x-y)<=1e-9);}
void solve()
{
fastio
int l,r;
cin>>l>>r;
if(l==0)
cout<<0;
else
{
if((r-l)>=2019)
cout<<0;
else
{
int ans=10000000;
for(int i=l;i<=r;i++)
{
for(int j=i+1;j<=r;j++)
ans=min(ans,((i%2019)*(j%2019))%2019);
}
cout<<ans;
}
}
}
int main()
{
//code
fastio
int t;
t=1;
while(t--)
{
solve();
cout<<endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll inf = 1e18;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define per(i, a, b) for (int i = b - 1; i >= a; i--)
#define int ll
using pint = pair<int, int>;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
signed main() {
int a, b, c;
cin >> a >> b >> c;
if (a == b && b != c) {
cout << "Yes\n";
} else if (b == c && a != b) {
cout << "Yes\n";
} else if (a == c && a != b) {
cout << "Yes\n";
} else {
cout << "No\n";
}
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,c,d;
cin>>a>>b>>c>>d;
cout<<min(a,b)+min(c,d)<<endl;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
int main(){
int n;
cin >> n;
int k = 111;
for(int i = 1; i < 10; i++){
if(k >= n){
cout << k << endl;
return 0;
}
k += 111;
}
} | #include <iostream>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <string>
using namespace std;
int main() {
int n;cin>>n;
for(int i = n;i<10000;i++){
string str = std::to_string(i);
if(str[0] == str[1]&&str[1] == str[2]){
cout<<i;
return 0;
break;
}
}
return 0;
} | 1 |
#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> P;
typedef vector<int> vi;
int main(){
int n;
cin >> n;
vi a(n+1);
rep(i,n){
int x;
cin >> x;
a[i+1]=x;
}
int m=0;
vi b(n+1);
for(int i=n;i>0;i--){
for(int j=2*i;j<=n;j+=i){
a[i]^=b[j];
}
if(a[i]){
m++;
b[i]++;
}
}
cout<<m << "\n";
rep(i,n+1){
if(b[i]) cout << i << ' ';
}
return 0;
} | #include<bits/stdc++.h>
#define reg register int
#define il inline
#define fi first
#define se second
#define mk(a,b) make_pair(a,b)
#define numb (ch^'0')
#define pb push_back
#define solid const auto &
#define enter cout<<endl
#define pii pair<int,int>
using namespace std;
typedef long long ll;
template<class T>il void rd(T &x){
char ch;x=0;bool fl=false;while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);
for(x=numb;isdigit(ch=getchar());x=x*10+numb);(fl==true)&&(x=-x);}
template<class T>il void output(T x){if(x/10)output(x/10);putchar(x%10+'0');}
template<class T>il void ot(T x){if(x<0) putchar('-'),x=-x;output(x);putchar(' ');}
template<class T>il void prt(T a[],int st,int nd){for(reg i=st;i<=nd;++i) ot(a[i]);putchar('\n');}
namespace Modulo{
const int mod=998244353;
il int ad(int x,int y){return x+y>=mod?x+y-mod:x+y;}
il int sub(int x,int y){return ad(x,mod-y);}
il int mul(int x,int y){return (ll)x*y%mod;}
il void inc(int &x,int y){x=ad(x,y);}
il void inc2(int &x,int y){x=mul(x,y);}
il int qm(int x,int y=mod-2){int ret=1;while(y){if(y&1) ret=mul(x,ret);x=mul(x,x);y>>=1;}return ret;}
template<class ...Args>il int ad(const int a,const int b,const Args &...args) {return ad(ad(a,b),args...);}
template<class ...Args>il int mul(const int a,const int b,const Args &...args) {return mul(mul(a,b),args...);}
}
using namespace Modulo;
namespace Miracle{
const int N=1e6+5;
int n,m;
int jie[N],inv[N];
int C(int n,int m){
return mul(jie[n],inv[m],inv[n-m]);
}
int main(){
rd(n);rd(m);
jie[0]=1;
int lim=2*max(n,m);
for(reg i=1;i<=lim;++i) jie[i]=mul(jie[i-1],i);
inv[lim]=qm(jie[lim]);
for(reg i=lim-1;i>=0;--i) inv[i]=mul(inv[i+1],i+1);
int d=min(n,m);
int sum=0;
for(reg i=1;i<=d;++i){
inc(sum,mul(C(2*i,i),C(n+m-2*i,n-i)));
}
inc2(sum,qm(2));
inc(sum,mul(max(n,m),C(n+m,n)));
int ans=mul(sum,qm(C(n+m,n)));
cout<<ans;
return 0;
}
}
signed main(){
Miracle::main();
return 0;
}
/*
Author: *Miracle*
*/ | 0 |
#include <bits/stdc++.h>
#define rep(i,l,n) for(int i=l;i<n;i++)
#define rer(i,l,n) for(int i=l;i<=n;i++)
#define all(a) a.begin(),a.end()
#define o(a) cout<<a<<endl
#define pb(a) push_back(a)
#define mk(a,b) make_pair(a,b)
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
string change(string s,int n){
string ret(s);
rep(i,0,ret.size()){
if(ret[i]>='a' && ret[i]<='z'){
if(ret[i]+n>'z') ret[i]+=n-26;
else ret[i]+=n;
}
}
return ret;
}
int main(){
string s;
string str[3]={"this","that","the"};
string stu[2]={" ","."};
while(getline(cin,s)){
bool f=0;
rep(i,0,26){
string t;
t=change(s,i);
rep(j,0,3){
rep(k,0,2){
if(t.find(str[j]+stu[k])!=string::npos){
o(t); f=1; break;
}
}
if(f) break;
}if(f) break;
}
}
} | #include <iostream>
using namespace std;
int e, m;
int main(void){
while(cin >> e && e != 0){
m = 1000000;
for(int y = 0; y <= 1000; y++){
for(int z = 0; z <= 100; z++){
int x = e - y * y - z * z * z;
if(x < 0) continue;
if(x + y + z < m) m = x + y + z;
}
}
cout << m << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define sz(arr) (int)arr.size()
#define all(arr) arr.begin(), arr.end()
using namespace std;
void _cin() {}
template <class Head, class... Tail>
void _cin(Head&& head, Tail&&... tail) {
cin >> head;
_cin(forward<Tail>(tail)...);
}
#define Cin(T, ...) \
T __VA_ARGS__; \
_cin(__VA_ARGS__)
int main() {
Cin(int, n, h, w);
cout << (n - h + 1) * (n - w + 1) << endl;
return 0;
} | #include<iostream>
#include<vector>
using namespace std;
int main(){
string s;
cin >> s;
for(int i=0;i<s.size();i++){
if(s[i]=='h'){
if(s[i+1]=='i'){
i++;
}else{
cout << "No" << endl;
return 0;
}
}else{
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
} | 0 |
#include <iostream>
#include <string>
using namespace std;
int main()
{
string buf;
while (cin >> buf) {
int amount = 0;
while ( !(buf.empty()) ) {
switch ( buf.at(0) ) {
case 'M':
buf.erase( buf.begin() ); amount += 1000; break;
case 'D':
buf.erase( buf.begin() ); amount += 500; break;
case 'C':
if ( buf.size() >= 2 ) {
if ( buf.at(1) == 'M' ) { buf.erase(0,2); amount += 900; break; }
else if ( buf.at(1) == 'D' ) { buf.erase(0,2); amount += 400; break; }
}
buf.erase( buf.begin() ); amount += 100; break;
case 'L':
buf.erase( buf.begin() ); amount += 50; break;
case 'X':
if ( buf.size() >= 2 ) {
if ( buf.at(1) == 'C' ) { buf.erase(0,2); amount += 90; break; }
else if ( buf.at(1) == 'L' ) { buf.erase(0,2); amount += 40; break; }
}
buf.erase( buf.begin() ); amount += 10; break;
case 'V':
buf.erase( buf.begin() ); amount += 5; break;
case 'I':
if ( buf.size() > 1 ) {
if ( buf.at(1) == 'X' ) { buf.erase(0,2); amount += 9; break; }
else if ( buf.at(1) == 'V' ) { buf.erase(0,2); amount += 4; break; }
}
buf.erase( buf.begin() ); amount += 1; break;
}
// cout << buf << endl;
}
cout << amount << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main()
{
long long int s=0,r1,r2;
cin>>r1>>r2;
if(r1==1)
s+=300000;
if(r1==2)
s+=200000;
if(r1==3)
s+=100000;
if(r2==1)
s+=300000;
if(r2==2)
s+=200000;
if(r2==3)
s+=100000;
if(r1==1 &&r2==1)
s+=400000;
cout<<s;
return 0;
}
| 0 |
#include<bits/stdc++.h>
typedef long long ll;
using namespace std;
int main()
{
//ll SUN, MON, TUE, WED, THU, FRI, SAT;
string s;
cin>>s;
if(s=="SUN") cout<<7<<endl;
if(s=="MON") cout<<6<<endl;
if(s=="TUE") cout<<5<<endl;
if(s=="WED") cout<<4<<endl;
if(s=="THU") cout<<3<<endl;
if(s=="FRI") cout<<2<<endl;
if(s=="SAT") cout<<1<<endl;
}
| /*
@uthor: Varun Mishra
"varun21999" -> Codechef, Codeforce, Hackerrank, Hackerearth;
*/
//#include<boost/multiprecision/cpp_int.hpp>
//using boost::multiprecision::cpp_int;
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define int long long int
#define ull unsigned int
#define ld long double
#define pb push_back
#define pa pair<int,int>
#define ppa pair<pair<int,int>,int>
#define pap pair<int,pair<int,int>>
#define v1d vector<int>
#define v2d vector<vector<int> >
#define vpa vector<pair<int,int>>
#define M 1000000007
#define MN LLONG_MIN
#define MX LLONG_MAX
#define ff first
#define ss second
#define endl "\n"
#define v1s vector<string>
#define all(v) v.begin(),v.end()
#define S(v) sort(v.begin(),v.end())
#define RS(v) sort(v.rbegin(),v.rend())
#define R(v) reverse(v.begin(),v.end())
#define mxpq(T) priority_queue <T>
#define mnpq(T) priority_queue<T,vector<T>,greater<T>>
#define T int tc;cin>>tc;while(tc--)
#define p2d(v) for(auto a:v){for(auto b:a)cout<<b<<" ";cout<<endl;}
#define p1d(v) for(auto a:v)cout<<a<<" ";cout<<endl;
#define ppd(v) for(auto a:v)cout<<a.ff<<" "<<a.ss<<endl;
#define forIloop(i,n) for(auto i=0;i<n;i++);
#define forDloop(i,n) for(auto i=n-1;i>=0;i--);
#define qqq 400005
#define isEven(n) (!n & 1);
const int MOD = 1e9 + 7;
// bool isEven(int n){
// return (!(n & 1));
// }
// int popcount(int num){
// num = num - ((num >> 1) & 0x55555555);
// num = (num & 0x33333333) + ((num >> 2) & 0x33333333);
// return ((num + (num >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
// }
// int powerOfTwo(int n){
// return 1 << n;
// }
// int arr[1000001];
// bool temet = false;
void codeforce2(){
string s; cin>>s;
vector<string> temp{"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
int index = find(temp.begin(), temp.end(), s) - temp.begin();
cout << 7 - index << endl;
return;
}
int32_t main(){
cout<<fixed<<setprecision(16);
cin.sync_with_stdio(false);
cin.tie(0);cout.tie(0);
/*#ifndef _DEBUG
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif*/
//auto start = high_resolution_clock::now();
// Lucario();
//codeforceContest();
//hackerEarth();
//codeChef();
codeforce2();
/* auto stop = high_resolution_clock::now();
auto duration = duration_cast<seconds>(stop - start);
cout << "Time: "<<duration.count()<<endl;*/
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int N, x;
vector<int> A;
int ans = 0;
cin >> N >> x;
for (int i = 0; i < N; ++i)
{
int a;
cin >> a;
A.push_back(a);
}
sort(A.begin(), A.end());
for (int i = 0; i < N; ++i)
{
if (A[i] > x){
break;
}
x -= A[i];
++ans;
}
if (x > 0 && ans == N){
ans -= 1;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, start, end) for (long long i = start; i < end; ++i)
#define repreverse(i, start, end) for (long long i = start; i >= end; --i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define len(x) ((long long)(x).size())
#define lcm(a, b) ((a) / __gcd((a), (b)) * (b))
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vllvll = vector<vll>;
using vc = vector<char>;
using pll = pair<ll, ll>;
template<class T> void print1d(T x,ll n=-1){if(n==-1)n=x.size();rep(i,0,n){cout<<x[i]<<' ';}cout<<'\n';}
template<class T> void print2d(T x,ll r=-1,ll c=-1){if(r==-1)r=x.size();if(c==-1)c=x[0].size();rep(i,0,r)print1d(x[i],c);}
template<class T, class U> bool haskey(T mp, U key) { return mp.find(key) != mp.end(); }
template<class T, class U> bool isin(T el, U container) { return find(all(container), el) != container.end(); }
template<class T> bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
template<class T> bool even(T n) { return ! (n & 1); }
template<class T> bool odd(T n) { return n & 1; }
template<class T> ll rup(T a, T b) { return a % b ? a / b + 1 : a / b; }
template<class T> ld deg2rad(T deg) { return M_PI * deg / 180.0; }
template<class T> ld rad2deg(T rad) { return 180.0 * rad / M_PI; }
const long double pi = M_PI;
const long long big = 1LL << 50;
const long long inf = 1LL << 60;
const long long mod = 1e9 + 7;
ll intpow(ll a, ll n, ll _mod=numeric_limits<ll>::max()) { ll p=1; while (n) { if (n&1) p=p*a%_mod; a=a*a%_mod; n>>=1; } return p; }
ll modc(ll a, char op, ll b, ll _mod=mod)
{
a %= _mod; b %= _mod; ll res = 1;
switch (op) {
case '+': res = (a + b) % _mod; break;
case '-': res = (a - b) % _mod; break;
case '*': res = a * b % _mod; break;
case '/': res = modc(a, '*', modc(b, '^', _mod-2, _mod), _mod); break;
case '^': res = intpow(a, b, _mod); break;
case 'P': rep(i, a-b+1, a+1) res = modc(res, '*', i, _mod); break;
case 'C': res = modc(modc(a, 'P', b, _mod), '/', modc(b, 'P', b, _mod)); break;
}
if (res < 0) { res += _mod; } return res;
}
int main()
{
ll N, x;
cin >> N >> x;
vll a(N);
rep(i, 0, N) cin >> a[i];
ll ans = 0;
sort(all(a));
rep(i, 0, N) {
if (i != N-1) {
if (x >= a[i]) {
x -= a[i];
++ans;
}
} else {
if (a.back() == x) ++ans;
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define ff first
#define ss second
#define all(x) (x).begin(), (x).end()
#define len(x) int((x).size())
ll dp_real[2][301][301];
ll dp_suff[2][301][301];
ll dp_diag[2][301][301];
const ll p = 998244353LL;
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
#ifdef ARTHUR_LOCAL
ifstream cin("input.txt");
#endif
string s;
int k;
cin>>s>>k;
k=min(k,300);
int n = len(s);
int zi=0;
int initial_ones = 0;
int ind=n-1;
while(ind>=0 && s[ind]=='1')
{
ind--;
initial_ones++;
}
// initialise the dp
for(int i=0; i<=min(k,initial_ones); i++)
{
dp_real[0][i][i]=1;
//cout << 0 << " " << i << " " << i << " " << 1 << endl;
}
// diag dudes is pretty easy to do
for(int i=0; i<=k; i++)
{
for(int j=0; j<=k; j++)
{
dp_diag[0][i][j]=dp_real[0][i][j];
if(i>0&&j>0)
{
dp_diag[0][i][j] += dp_diag[0][i-1][j-1];
dp_diag[0][i][j] %= p;
}
}
}
// suff dudes ... not so bad either ???
for(int i=0; i<=k; i++)
{
for(int j=k; j>=0; j--)
{
dp_suff[0][i][j]=dp_real[0][i][j];
if(j<k)
{
dp_suff[0][i][j]+=dp_suff[0][i][j+1];
dp_suff[0][i][j]%=p;
}
}
}
for(int ii=n-1; ii>=0; ii--)
{
if(s[ii]=='1') continue;
// if(!skip_first)
// {
// skip_first=1;
// continue;
// }
zi=1-zi;
int a = 0;
int copy_i = ii-1;
while(copy_i>=0 && s[copy_i]=='1')
{
a++;
copy_i--;
}
//cout << a << endl;
for(int i=0; i<=k; i++)
{
for(int j=0; j<=k; j++)
{
// compute new real_dp[zi][i][j] value
dp_real[zi][i][j] = dp_suff[1-zi][i][j];
dp_real[zi][i][j] += dp_diag[1-zi][i][j];
dp_real[zi][i][j] %= p;
if(i-a > 0 && j-a > 0) // maybe add conditions on j < i or whatever
{
dp_real[zi][i][j] += p - dp_diag[1-zi][i-a-1][j-a-1];
dp_real[zi][i][j] %= p;
}
dp_real[zi][i][j] += p-dp_real[1-zi][i][j];
dp_real[zi][i][j] %= p;
//cout << ii << " " << i << " " << j << " " << dp_real[zi][i][j] << endl;
dp_diag[zi][i][j] = dp_real[zi][i][j];
if(i>0&&j>0)
{
dp_diag[zi][i][j] += dp_diag[zi][i-1][j-1];
dp_diag[zi][i][j] %= p;
}
}
dp_suff[zi][i][k]=dp_real[zi][i][k];
for(int j=k-1; j>=0; j--)
{
dp_suff[zi][i][j] = dp_real[zi][i][j];
dp_suff[zi][i][j] += dp_suff[zi][i][j+1];
dp_suff[zi][i][j] %= p;
}
}
}
ll ans=0LL;
for(int i=0; i<=k; i++)
{
ans += dp_real[zi][i][0];
ans %= p;
}
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
const int N = 18, mod = 1e9 + 7;
int dp[44][1 << N], x, y, z;
int yo(int n, int mask) {
mask &= (1 << 18) - 1;
if (mask >> x & 1 && mask >> (x + y) & 1 && mask >> (x + y + z) & 1) return 0;
if (n == 0) return 1;
int &ret = dp[n][mask];
if (ret != -1) return ret;
int ans = 0;
for (int i = 1; i <= 10; i++) {
ans += yo(n - 1, (mask << i) | (1 << i));
if (ans >= mod) ans -= mod;
}
return ret = ans;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n; cin >> n >> x >> y >> z;
memset(dp, -1, sizeof dp);
int ans = 1;
for (int i = 1; i <= n; i++) ans = 1LL * ans * 10 % mod;
ans = (ans - yo(n, 0) + mod) % mod;
cout << ans << '\n';
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define foreach(it,v) for(__typeof(v.begin()) it=v.begin();it!=v.end();it++)
#define chmax(a,b) a=max(a,b)
int n,Q,bl;
int c[500005];
int ans=0,cnt[500005];
struct query{
int l,r,id;
}q[500005];
int qans[500005];
bool cmp(query a,query b){
return (a.r/bl)==(b.r/bl)?a.l<b.l:a.r<b.r;
}
void add(int x){
if(!cnt[c[x]]){
ans++;
}
cnt[c[x]]++;
}
void del(int x){
cnt[c[x]]--;
if(!cnt[c[x]]){
ans--;
}
}
int main(){
cin>>n>>Q;
bl=n/sqrt(Q*2/3);
for(int i=1;i<=n;++i){
cin>>c[i];
}
for(int i=1;i<=Q;++i){
cin>>q[i].l>>q[i].r;
q[i].id=i;
}
sort(q+1,q+1+Q,cmp);
int l=0,r=0;
for(int i=1;i<=Q;++i){
int ql=q[i].l,qr=q[i].r;
// cout<<ql<<' '<<qr<<'\n';
while(l<ql){
del(l);
l++;
}
while(l>ql){
l--;
add(l);
}
while(r>qr){
del(r);
r--;
}
while(r<qr){
r++;
add(r);
}
qans[q[i].id]=ans;
}
for(int i=1;i<=Q;++i){
cout<<qans[i]<<'\n';
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define TEMP_T template<typename T>
TEMP_T void sort(T& v){ sort(v.begin(), v.end()); }
TEMP_T void revs(T& v){ reverse(v.begin(), v.end()); }
TEMP_T void uniq(T& v){ sort(v); v.erase(unique(v.begin(), v.end()), v.end()); }
TEMP_T T cums(T& v){ T r(v.size()); partial_sum(v.begin(), v.end(), r); return r; }
TEMP_T void show(T& v, char delim=' ', char end='\n'){ for(int i=0; i<v.size()-1; i++) cout << v[i] << delim; cout << v[v.size()-1] << end; }
TEMP_T T acum(vector<T>& v, T b=0){ return accumulate(v.begin(), v.end(), b); }
TEMP_T vector<T> inpt(int n){ vector<T> v(n); for (int i=0; i<n; i++) cin >> v[i]; return v; }
static inline int in(){ int x; scanf("%d", &x); return x; }
static const int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
static const int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
struct Field {
Field(int w, int h) : w(w), h(h) {}
bool invalid(int x, int y){ return x < 0 || w <= x || y < 0 || h <= y; }
const int w, h;
};
struct Solver {
Solver(){}
int solve(){
}
};
int main()
{
int n;
while (n = in()){
int robo_x, robo_y;
robo_x = robo_y = 10;
set<pair<int, int> > gems;
for (int i = 0; i < n; i++){
int x, y;
x = in();
y = in();
gems.insert(make_pair(x, y));
}
set<pair<int, int> > robos;
int m = in();
for (int i = 0; i < m; i++){
string s;
int v;
int d;
cin >> s >> v;
if (s == "N") d = 0;
else if (s == "W") d = 3;
else if (s == "E") d = 2;
else d = 1;
for (int j = 0; j < v; j++){
robos.insert(make_pair(robo_x, robo_y));
robo_x += dx[d];
robo_y += dy[d];
robos.insert(make_pair(robo_x, robo_y));
}
}
vector<pair<int, int> > mult;
set_intersection(gems.begin(), gems.end(),
robos.begin(), robos.end(),
back_inserter(mult)
);
if (mult.size() == gems.size()){
puts("Yes");
}
else puts("No");
}
return (0);
} | 0 |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
const int Mod = 998244353;
int fpow(int x, int y) {
int res = 1;
while (y) {
if (y & 1) res = 1ll * res * x % Mod;
x = 1ll * x * x % Mod;
y >>= 1;
}
return res;
}
const int MAX_N = 1e6 + 5;
int N = 1e6, M, fac[MAX_N], ifc[MAX_N];
int C(int n, int m) {
if (n < m || n < 0 || m < 0) return 0;
else return 1ll * fac[n] * ifc[m] % Mod * ifc[n - m] % Mod;
}
int main () {
for (int i = fac[0] = 1; i <= N; i++) fac[i] = 1ll * fac[i - 1] * i % Mod;
ifc[N] = fpow(fac[N], Mod - 2);
for (int i = N - 1; ~i; i--) ifc[i] = 1ll * ifc[i + 1] * (i + 1) % Mod;
cin >> N >> M;
if (N > M) swap(N, M);
int ans = 0;
for (int i = 1; i <= N; i++) ans = (ans + 1ll * C(i << 1, i) * C(N - i + M - i, N - i)) % Mod;
ans = 1ll * ans * fpow(2 * C(N + M, M) % Mod, Mod - 2) % Mod;
printf("%d\n", (ans + M) % Mod);
return 0;
} | #include<bits/stdc++.h>
using namespace std;
const bool DBG = 1;
#define TRACE(x) x
#define WATCH(x) TRACE(cout << #x" = " << x << endl)
#define WATCHR(a,b) TRACE(for(auto it=a; it!=b;) cout<<*(it++)<<" ";cout<<endl)
#define WATCHC(V) TRACE({cout << #V" = "; WATCHR(V.begin(), V.end());})
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
#define lb lower_bound
#define ub upper_bound
#define f first
#define s second
#define resz resize
#define sz(x) int((x).size())
#define all(x) (x).begin(), (x).end()
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define FORd(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define F0Rd(i, a) for (int i = (a)-1; i >= 0; i--)
#define trav(a, x) for (auto& a : x)
#define sort_by(x, y) sort(all(x), [&](const auto& a, const auto& b) { return y; })
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vvpii = vector<vpii>;
using vpll = vector<pll>;
using vvpll = vector<vpll>;
using vpdd = vector<pdd>;
using vvpdd = vector<vpdd>;
template<typename T> void ckmin(T& a, const T& b) { a = min(a, b); }
template<typename T> void ckmax(T& a, const T& b) { a = max(a, b); }
void solve() {
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
cout << fixed << setprecision(15);
int n,m; cin >> n >> m;
if(n % 2) {
F0R(i,m) {
cout << i+1 << " " << 2*m-i << "\n";
}
} else {
int max_odd_m = m, max_even_m = m;
if(m % 2 == 0) max_odd_m--;
else max_even_m--;
for(int i = 0; 2*i+1 <= m; i++) {
cout << i+1 << " " << max_odd_m+1-i << "\n";
}
for(int i = 0; 2*i+2 <= m; i++) {
cout << max_odd_m+2+i << " " << max_odd_m+2+max_even_m-i << "\n";
}
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define title "title"
#define ll long long
#define ull unsigned ll
#define fix(x) fixed<<setprecision(x)
#define pii pair<ll,ll>
#define vint vector<ll>
#define pb push_back
using namespace std;
void Freopen(){
freopen(title".in","r",stdin);
freopen(title".out","w",stdout);
}
ll read(){
ll g=0,f=1;
char ch=getchar();
while(ch<'0'||'9'<ch){if(ch=='-')f=-1;ch=getchar();}
while('0'<=ch&&ch<='9'){g=g*10+ch-'0';ch=getchar();}
return g*f;
}
const ll N=1e5+5;
ll n,st,x[N],p[N];
ll calc(ll l,ll r,ll t){
if(st<x[l])return x[r]-st;if(x[r]<st)return st-x[l];
if(p[l]>=p[r])return p[l]+=p[r],calc(l,r-1,l)+(t==r?x[r]-x[l]:0);
else return p[r]+=p[l],calc(l+1,r,r)+(t==l?x[r]-x[l]:0);
}
signed main(){
n=read(),st=read();
for(ll i=1;i<=n;i++)x[i]=read(),p[i]=read();
return cout<<calc(1,n,p[1]<p[n]?1:n),signed();
} | #include <cmath>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
using ll = long long;
int main() {
int N;
ll S;
cin >> N >> S;
ll X[N], P[N];
for (int i = 0; i < N; ++i) {
cin >> X[i] >> P[i];
}
queue<ll> neg, pos;
// Sより前、後にある座標をそれぞれ両端から入れていく
for (int i = 0; i < N && X[i] < S; ++i) {
neg.push(P[i]);
}
for (int i = N - 1; i >= 0 && X[i] > S; --i) {
pos.push(P[i]);
}
vector<ll> route;
// 最適解における探索順を後ろから
int l = 0, r = N - 1;
while (true) {
// もう一方しか残っていない場合
if (neg.empty()) {
for (; l <= r; --r) {
route.push_back(r);
}
break;
}
if (pos.empty()) {
for (; l <= r; ++l) {
route.push_back(l);
}
break;
}
// 末端の人口を比較、少ない方が選ばれる
if (neg.front() >= pos.front()) {
route.push_back(r);
--r;
neg.front() += pos.front();
pos.pop();
} else {
route.push_back(l);
++l;
pos.front() += neg.front();
neg.pop();
}
}
ll ans = 0, now = S;
while (!route.empty()) {
ll id = route.back();
route.pop_back();
ans += abs(X[id] - now);
now = X[id];
}
cout << ans << endl;
return 0;
}
| 1 |
//#include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <string>
#include <vector>
#include <map>
#include <queue>
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) for(int i=0;i<n;++i)
#define mod (ll)(1e9+7)
#define FIX(a) ((a)%mod+mod)%mod
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define fi first
#define se second
#define pb push_back
int dy[]={0, 0, 1, -1};
int dx[]={1, -1, 0, 0};
ll pow(ll x, ll ntimes) {
ll ret = 1;
while (ntimes > 0) {
if ((ntimes & 1) == 1) {
ret = ret * x;
}
x = x * x;
ntimes >>= 1;
}
return ret;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
ll ans = 1;
vector<bool> prime(n+1,true);
for(ll i=2;i<=n;++i){
if(prime[i]==true){
ll cnt = 0;
for(ll j=2*i;j<=n;j+=i){
prime[j]=false;
}
ll t = 1;
while(pow(i,t)<=n){
ll x = pow(i,t);
cnt += (n/x);
t++;
}
ans *= (cnt+1);
ans %= mod;
}
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define Fast_IO ios::sync_with_stdio(false);
#define int long long
#define mod 1000000007
inline int read()
{
char ch=getchar(); int nega=1; while(!isdigit(ch)) {if(ch=='-') nega=-1; ch=getchar();}
int ans=0; while(isdigit(ch)) {ans=ans*10+ch-48;ch=getchar();}
if(nega==-1) return -ans;
return ans;
}
#define N 200005
int a[N];
char s[N];
int n;
signed main()
{
#ifdef __LOCAL__
freopen("in.txt","r",stdin);
#endif
n=read();
scanf("%s",s+1);
for(int i=1;i<=n*2;i++)
{
a[i]=(s[i]=='B');
}
int cur=0,ans=1;
for(int i=1;i<=n*2;i++)
{
if((cur&1)==a[i])
{
ans=ans*cur%mod;
cur--;
}
else cur++;
}
if(cur!=0) return cout<<"0\n",0;
for(int i=1;i<=n;i++)
{
ans=ans*i%mod;
}
cout<<ans<<endl;
#ifdef __LOCAL__
printf("Time Used : %d\n",clock());
#endif
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
//#define cerr if (false) cerr
#define db(x) cerr << #x << "=" << x << endl
#define db2(x, y) cerr << #x << "=" << x << "," << #y << "=" << y << endl
#define db3(x, y, z) cerr << #x << "=" << x << "," << #y << "=" << y << "," << #z << "=" << z << endl
#define dbv(v) cerr << #v << "="; for (auto _x : v) cerr << _x << ", "; cerr << endl
#define dba(a, n) cerr << #a << "="; for (int _i = 0; _i < (n); ++_i) cerr << a[_i] << ", "; cerr << endl
typedef long long ll;
typedef long double ld;
const int MAX = 100000;
int above[MAX + 2];
ll dp[MAX + 1];
const int MAXN = 205;
ll fac[MAXN], invfac[MAXN];
ll inv[MAXN];
const ll MOD = 1e9 + 7;
int binom[MAXN][MAXN];
ll modex(ll a, ll p, ll m = MOD) {
if (!p) return 1;
if (p & 1) return a * modex(a, p - 1, m) % m;
ll v = modex(a, p >> 1, m);
return v * v % m;
}
int main() {
fac[0] = 1;
for (int i = 1; i < MAXN; ++i)
fac[i] = fac[i - 1] * i % MOD;
invfac[MAXN - 1] = modex(fac[MAXN - 1], MOD - 2);
for (int i = MAXN - 2; i >= 0; --i)
invfac[i] = invfac[i + 1] * (i + 1) % MOD;
for (int i = 1; i < MAXN; ++i)
inv[i] = invfac[i] * fac[i - 1] % MOD;
for (int i = 0; i < MAXN; ++i)
for (int j = 0; j <= i; ++j)
if (!j || j == i) binom[i][j] = 1;
else binom[i][j] = (binom[i - 1][j - 1] + binom[i - 1][j]) % MOD;
int n, X;
scanf("%d%d", &n, &X);
vector<int> s(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &s[i]);
above[s[i] - 1] = 1;
}
sort(s.begin(), s.end());
for (int i = MAX; i >= 0; --i) above[i] += above[i + 1];
for (int i = 0; i <= X; ++i) {
for (int k = 0; k < n; ++k) {
if (s[k] > i) break;
int v = i % s[k];
dp[i] += dp[v] * binom[n - above[i] - 1][n - above[v]] % MOD * fac[above[v] - above[i] - 1] % MOD;
dp[i] %= MOD;
}
if (s[0] > i) dp[i] = i;
}
printf("%lld\n", dp[X] * binom[n][above[X]] % MOD * fac[above[X]] % MOD);
}
| //g++ -std=c++14 test.cpp -o test.out
//全部開催すると仮定した後、1つずつ減らして調べていく
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <cassert>
#include <algorithm>
#include <functional>
#include <iostream>
#include <iomanip>
#include <vector>
#include <queue>
#include <map>
#include <unordered_map>
#include <utility>
#include <limits.h>
#include <bitset>
#include <set>
using namespace std;
#define LL long long int
const LL INF = (1LL<<60);
const int INF_INT = 2147483647-1e6-1;
const LL mod = 1000000007ll;
const int mod_int = 1000000007;
LL N,M;
LL A[300][300];
LL ans = INF;
void solve(){
//i番目の人が何番目のスポーツを選んでいるかをselected_index[i]とおく
vector<int> selected_index(N,0);
vector<int> hold(M,1);//M番目のスポーツを開催するのかどうか
auto max_count = [&](){
//スポーツiを選んでいる人間の数をcounter[i]とおく
vector<int> counter(M,0);
for(int i=0;i<N;i++){
if(selected_index[i]<M) counter[A[i][selected_index[i]]]++;
}
int max_counter = 0;//選んでる人が一番多いスポーツの人数
int max_sports = 0;//選んでる人が一番多いスポーツの番号
for(int i=0;i<M;i++){
if(max_counter<counter[i]){
max_counter = counter[i];
max_sports = i;
}
}
return pair<LL,LL>(max_counter,max_sports);
};
ans = max_count().first;
for(int _=0;_<M-1;_++){
pair<LL,LL> maxs = max_count();
LL max_counter = maxs.first;
LL max_sports = maxs.second;
hold[max_sports] = 0;//選んでる人が一番多いスポーツを中止
for(int i=0;i<N;i++){
while(1){
if(!hold[A[i][selected_index[i]]]) selected_index[i]++;
else break;
}
}
// cout << endl;
// for(int i=0;i<N;i++){
// for(int j=0;j<M;j++){
// if(hold[A[i][j]]==1) cout << A[i][j] << " ";
// else cout << " ";
// }
// cout << endl;
// }
maxs = max_count();
ans = min(ans,maxs.first);
}
}
int main(){
cin >> N >> M;
for(int i=0;i<N;i++){
for(int j=0;j<M;j++){
cin >> A[i][j];
A[i][j]--;
}
}
solve();
cout << ans << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int,int>;
#define rep(i,n) for(ll i = 0;i < (ll)n;i++)
#define ALL(x) (x).begin(),(x).end()
#define MOD 1000000007
int main(){
int T,A,n;
cin >> n >> T >> A;
T--,A--;
vector<vector<int>> v(n);
rep(i,n-1){
int a,b;cin >> a >> b;
a--,b--;
v[a].push_back(b);
v[b].push_back(a);
}
ll res = 0;
bool is = true;
vector<int> next(n,T);
{
vector<int> dt(n,-1);
dt[T] = 0;
queue<int> que;
que.push(T);
while(!que.empty()){
int ov = que.front();que.pop();
for(int nv : v[ov]){
if(dt[nv] != -1)continue;
next[nv] = ov;
dt[nv] = dt[ov] + 1;
que.push(nv);
}
}
if(dt[A] & 1){
int d = dt[A];
while(dt[next[A]] >= d-d/2)A = next[A];
T = A;
while(dt[next[T]] >= d/2 && next[T] != T)T = next[T];
res += d/2;
}else{
int d = dt[A];
while(dt[next[A]] >= d-(d-2)/2)A = next[A];
T = A;
while(dt[next[T]] >= (d-2)/2 && next[T] != T)T = next[T];
res += (d-2)/2;
is = false;
}
}
int L = -1;
{
for(int ov : v[T])for(int nv : v[ov])if(nv == A){
L = ov;
break;
}
}
queue<int> que;
que.push(T);
vector<int> d(n,-1);
d[T] = 0;
while(!que.empty()){
int ov = que.front();que.pop();
for(int nv : v[ov]){
if(nv == A || d[nv] != -1 || nv == L)continue;
d[nv] = d[ov]+1;
que.push(nv);
}
}
int K = T;
rep(i,n)if(d[i] > d[K])K = i;
if(is)res += d[K];
else res += d[K]+1;
cout << res << endl;
/*////////////
cout << "L :" << L << endl;
printf("T :%d A :%d\n",T+1,A+1);
*/////////////
return 0;
}
/*
7
4 7
1 2
1 3
2 4
2 5
3 6
3 7
*/ | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define SZ(x) ((int)(x).size())
#define REP(i,n) for(int _n=n, i=0;i<_n;++i)
#define FOR(i,a,b) for(int i=(a),_b=(b);i<=_b;++i)
#define FORD(i,a,b) for(int i=(a),_b=(b);i>=_b;--i)
using ull = uint64_t;
using ll = int64_t;
using PII = pair<int, int>;
using VI = vector<int>;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string) s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <typename A> string to_string(A v) {
bool first = true; string res = "{";
for (const auto &x : v) { if (!first) { res += ", "; } first = false; res += to_string(x); }
res += "}"; return res; }
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H); debug_out(T...); }
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
const int N = 100005;
vector<VI> tree;
int dist1[N], dist2[N];
void dfs(int v, int d, int from, int *arr) {
arr[v] = d;
for (int u : tree[v]) {
if (u == from) continue;
dfs(u, d + 1, v, arr);
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n, u, v;
cin >> n >> u >> v;
tree.assign(n + 2, VI());
REP(i, n - 1) {
int x, y;
cin >> x >> y;
tree[x].pb(y);
tree[y].pb(x);
}
dfs(u, 0, 0, dist1);
dfs(v, 0, 0, dist2);
int mx = 0;
for (int i = 1; i <= n; i++) {
if (dist1[i] < dist2[i]) {
mx = max(mx, dist2[i]);
}
}
cout << mx - 1 << "\n";
} | 1 |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int n, x;
vector<int> a;
cin >> n;
for(int i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
reverse(a.begin(), a.end());
for(int i = 0; i < n; i++) {
if(i == n-1) cout << a[i] << endl;
else cout << a[i] << " ";
}
} | #include<stdio.h>
int main(void)
{
int a[101],s,i,d;
scanf("%d",&s);
for(i=1;i<=s;i++){
scanf("%d",&a[i]);
}
d=1;
for(i=s;i>=1;i--){
d++;
printf("%d",a[i]);
if(d<=s){
printf(" ");
}
}
printf("\n");
return 0;
} | 1 |
#include <iostream>
#include <vector>
using namespace std;
const int MOD = 998244353;
int main(){
int K, N;
while(cin >> K >> N){
vector<vector<long long>> pair(K+1, vector<long long>(N+1, 0));
vector<vector<long long>> solo(K+1, vector<long long>(N+1, 0));
pair[0][0] = 1;
solo[0][0] = 1;
for(int i=1;i<=K;i++){
long long sum = 0;
for(int j=0;j<=N;j++){
pair[i][j] += pair[i-1][j] + 2 * sum;
pair[i][j] %= MOD;
sum += pair[i-1][j];
sum %= MOD;
}
}
for(int i=1;i<=K;i++){
long long sum = 0;
for(int j=0;j<=N;j++){
sum += solo[i-1][j];
sum %= MOD;
solo[i][j] = sum;
}
}
vector<int> invalid(2*K+1, 0);
for(int i=1;i<=K;i++){
for(int j=i+1;j<=K;j++){
++invalid[i+j];
}
}
for(int k=2;k<=2*K;k++){
long long res = 0;
int pr = invalid[k];
if(k%2 == 0){
for(int i=0;i<=N;i++){
res += pair[pr][i] * (solo[K-2*pr-1][N-i] + (i==N ? 0 : solo[K-2*pr-1][N-i-1]));
res %= MOD;
}
} else {
for(int i=0;i<=N;i++){
res += pair[pr][i] * solo[K-2*pr][N-i];
res %= MOD;
}
}
cout << res << endl;
}
}
} | #include <algorithm>
#include <iostream>
#include <queue>
using namespace std;
typedef pair<int, int> P;
const int inf = 1 << 28;
int w, h;
int a[21][21];
int sx, sy, gx, gy;
const int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
bool check(int x, int w) { return 0 <= x && x < w; }
int dfs(int x, int y, int cnt) {
if (cnt >= 10) {
return inf;
}
int ret = inf;
for (int k = 0; k < 4; ++k) {
int nx = x + dx[k], ny = y + dy[k];
while (check(nx, w) && check(ny, h) && a[ny][nx] != 1 &&
a[ny][nx] != 3) {
nx += dx[k];
ny += dy[k];
}
if (!check(nx, w) || !check(ny, h)) {
continue;
}
if (a[ny][nx] == 3) {
return 1;
}
if (nx - dx[k] == x && ny - dy[k] == y) {
continue;
}
a[ny][nx] = 0;
ret = min(ret, dfs(nx - dx[k], ny - dy[k], cnt + 1) + 1);
a[ny][nx] = 1;
}
return ret;
}
int main() {
while (cin >> w >> h, !(w == 0 && h == 0)) {
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
cin >> a[i][j];
if (a[i][j] == 2) {
sy = i;
sx = j;
}
if (a[i][j] == 3) {
gy = i;
gx = j;
}
}
}
int ans = dfs(sx, sy, 0);
if (ans <= 10) {
cout << ans << endl;
} else {
cout << -1 << endl;
}
}
} | 0 |
#include <bits/stdc++.h>
#define ll long long
#define double long double
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
#define mod (ll)(1e9+7)
#define inf (ll)(3e18+7)
#define P pair<int,int>
#define PiP pair<int,pair<int,int>>
#define all(x) x.begin(),x.end()
using namespace std;
struct Node{
int key;
Node *right, *left, *parent;
};
Node *root, *NIL;
Node * treeMinimum(Node *x){
while(x -> left != NIL)x = x -> left;
return x;
}
Node * treeSuccessor(Node *x){
if(x -> right != NIL)return treeMinimum(x -> right);
Node *y = x -> parent;
while(y != NIL && x == y -> right){
x = y;
y = y->parent;
}
return y;
}
Node * find(Node *u, int k){
while(u != NIL && k != u -> key){
if(k < u -> key) u = u -> left;
else u = u -> right;
}
return u;
}
void treeDelete(Node *z){
Node *y, *x;
if(z -> left == NIL || z -> right == NIL)y = z;
else y = treeSuccessor(z);
if(y -> left != NIL)x = y -> left;
else x = y -> right;
if(x != NIL)x -> parent = y -> parent;
if(y -> parent == NIL)root = x;
else{
if(y == y->parent->left)y -> parent -> left = x;
else y -> parent -> right = x;
}
if(y != z)z -> key = y -> key;
free(y);
}
void insert(int k){
Node *y = NIL, *x = root, *z;
z = (Node*)malloc(sizeof(Node));
z -> key = k;
z -> right = NIL;
z -> left = NIL;
while(x != NIL){
y = x;
if(z->key < x->key){
x = x -> left;
}
else{
x = x -> right;
}
}
z -> parent = y;
if(y == NIL) root = z;
else{
if(z -> key < y -> key){
y -> left = z;
}
else{
y -> right = z;
}
}
return;
}
void inParse(Node *u){
if(u == NIL)return;
inParse(u -> left);
cout << " " << u -> key;
inParse(u -> right);
}
void preParse(Node *u){
if(u == NIL)return;
cout << " " << u -> key;
preParse(u -> left);
preParse(u -> right);
}
int main() {
int n, x;
string q;
cin >> n;
rep(i, n){
cin >> q;
if(q == "insert"){
cin >> x;
insert(x);
}
else if(q == "print"){
inParse(root);
cout << endl;
preParse(root);
cout << endl;
}
else if(q == "delete"){
cin >> x;
treeDelete(find(root, x));
}
else {
cin >> x;
if(find(root, x) != NIL)cout << "yes" << endl;
else cout << "no" << endl;
}
}
}
| //C
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;
int main(){
string d="";
d.resize(52);
for(int i=0;i<26;i++)d[i]='a'+i;
for(int i=0;i<26;i++)d[i+26]='A'+i;
int num;
//cout<<d<<endl;
while(true){
cin>>num;
if(num==0)break;
string ans="",next;
int key[200];
for(int i=0;i<num;i++)cin>>key[i];
cin>>next;
for(int i=0;i<next.size();i++){
int tmp;
for(int j=0;j<52;j++)if(d[j]==next[i])tmp=j;
int index;
if(i==0)index=0;
else index=i%num;
tmp-=key[index];
if(tmp<0)tmp+=52;
cout<<d[tmp];
}
cout<<endl;
}
return 0;
} | 0 |
#include <cstdio>
using namespace std;
int main(void){
int a[1000],b[1000],c[1000],i,j,r[1000],n,ans[303],abc;
for(j=0;j<6;j++){
scanf("%d%d%d%d",&a[0],&b[0],&c[0],&n);
if(a[0]==0) return 0;
abc=a[0]+b[0]+c[0];
for(i=0;i<=abc+1;i++) ans[i]=2;
for(i=0;i<n;i++) scanf("%d%d%d%d",&a[i],&b[i],&c[i],&r[i]);
for(i=0;i<n;i++) if(r[i]){
ans[a[i]]=ans[b[i]]=ans[c[i]]=1;
}
for(i=0;i<n;i++) if(r[i]-1) if(ans[a[i]]+ans[b[i]]+ans[c[i]]==4&&(ans[a[i]]==1||ans[b[i]]==1)){
if(ans[a[i]]-1){
ans[a[i]]=0;
}else if(ans[b[i]]-1){
ans[b[i]]=0;
}else ans[c[i]]=0;
}
for(i=1;i<=abc;i++) printf("%d\n",ans[i]);
}
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, init, n) for(int i = init; i < (n); i++)
using namespace std;
using ll = long long int;
using P = pair<int, int>;
using T = tuple<int, int, int>;
using edge = struct
{
int to, cost;
};
const int MOD = 1e9 + 7;
const int iINF = 1e9;
const long long int llINF = 1e18;
const double PI = acos(-1.0);
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int main()
{
int a, b, c;
while(cin >> a >> b >> c, a, b, c)
{
vector<int> sta(a + b + c + 1, 2);
int N;
cin >> N;
vector<tuple<int, int, int, int>> vec;
rep(num, N)
{
int i, j, k, r;
cin >> i >> j >> k >> r;
vec.push_back(make_tuple(r, i, j, k));
}
sort(vec.begin(), vec.end(), greater<tuple<int, int, int, int>>());
rep(num, N)
{
int i, j, k, r;
tie(r, i, j, k) = vec[num];
if(r == 1)
{
sta[i] = 1;
sta[j] = 1;
sta[k] = 1;
}
else if(r == 0)
{
int cnt = 0;
for(int pro : {i, j, k})
{
if(sta[pro] == 1) cnt++;
}
if(cnt != 2) continue;
for(int pro : {i, j, k})
{
if(sta[pro] == 1) continue;
sta[pro] = 0;
}
}
}
rep(i, a + b + c) cout << sta[i + 1] << endl;
}
return 0;
}
| 1 |
#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>;
vector<ll> f(ll n) {
vector<ll> res;
for (ll a = 2; a*a <= n; a++) {
if (n%a != 0) continue;
while (n%a == 0) {
n /= a;
}
res.push_back(a);
}
if (n != 1) res.push_back(n);
return res;
}
int main() {
ll a, b;
cin >> a >> b;
auto ares = f(a);
auto bres = f(b);
int ans = 0;
for (auto x : ares) {
for (auto y : bres) {
if (x == y) ans++;
}
}
ans++;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define max 1000007
#define ll long long int
using namespace std;
vector <ll> primes;
void sieve()
{
bool isprime[max+1];
for(ll i=0;i<=max;i++) {
isprime[i] = true;
}
isprime[0]=false;
isprime[1]=false;
for(ll i=3;i*i<=(max);i=i+2)
{
if(isprime[i]) {
for (ll j = i*i; j <= max; j=j+i) {
isprime[j] = false;
}
}
}
primes.push_back(2);
for(ll i=3;i<max;i=i+2)
{
if(isprime[i])
primes.push_back(i);
}
}
int main() {
sieve();
ll n,d,b,i,flag,x;
scanf("%lld %lld",&d,&b);
n=__gcd(d%b,b);
set <int> s;
s.insert(1);
for(i=0;primes[i]*primes[i]<=n;i++)
{
while(n%primes[i]==0)
{
s.insert(primes[i]);
n=n/primes[i];
}
}
if(n>1)
s.insert(n);
printf("%lu",s.size());
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
#include <string>
#include <cmath>
#include <iomanip>
#include <map>
#include <set>
#include <numeric>
#include <queue>
using namespace std;
#define loop(i,N) for(ll (i)=0; (i)<(N);++(i))
struct TEMP_OMAZINAI_ { TEMP_OMAZINAI_() { std::ios::sync_with_stdio(false); std::cin.tie(0); } } TEMP__omazinai_instance__;
#define INF ((1LL<<61) + (1<<29))
#define YesNo(x) {std::cout << ((x)?"Yes":"No") << std::endl;}
#define YESNO(x) {std::cout << ((x)?"YES":"NO") << std::endl;}
#define OddEven(x) {std::cout << ((x)%2?"Odd":"Even") << std::endl;}
#define ODDEVEN(x) {std::cout << ((x)%2?"ODD":"EVEN") << std::endl;}
typedef long long int ll;
ll my_gcd(ll a, ll b) { return b ? my_gcd(b, a%b) : a; };
void TEMP_INPUT_IMPL_() {};
template <class T, class... Args> void TEMP_INPUT_IMPL_(T& dest, Args&... args) { cin >> dest; TEMP_INPUT_IMPL_(args...); }
void TEMP_OUTPUT_IMPL_() {};
template <class T, class... Args> void TEMP_OUTPUT_IMPL_(T dest, Args... args) { cout << dest << (sizeof...(Args) ? " " : ""); TEMP_OUTPUT_IMPL_(args...); }
#define in(type, ...) type __VA_ARGS__; TEMP_INPUT_IMPL_(__VA_ARGS__)
#define in_v(type, name, cnt) vector<type> name(cnt); loop(i, cnt) cin >> name[i];
#define sort_v(v) std::sort(v.begin(), v.end())
#define rsort_v(v) std::sort(v.rbegin(), v.rend())
#define unique_v(v) v.erase(std::unique(v.begin(), v.end()), v.end()) //必ずソート後に実行
#define out(...) (TEMP_OUTPUT_IMPL_(__VA_ARGS__), std::cout<<std::endl)
#define set_fix(x) ((std::cerr<<std::fixed<<std::setprecision(x)),(std::cout<<std::fixed<<std::setprecision(x)))
//小さい方に寄る
#define space_op(x, y, a, b, c) ([](auto x_, auto y_, auto a_, auto b_, auto c_){if(x_<y_)return a_;if(x_>y_)return c_;return b_;}(x,y,a,b,c))
#define space_out(x, y, a, b, c) out(space_op(x, y, a, b, c))
// ^^^ Template ^^^ //
struct UnionFind{
vector<ll> parent;
vector<ll> size;
UnionFind() = delete;
UnionFind(ll n) : parent(n), size(n, 1){
loop(i, n)
parent[i] = i;
}
int find(ll x) {
if(parent[x] == x) return x;
return parent[x] = find(parent[x]);
}
void unite(ll x_, ll y_){
ll x = find(x_);
ll y = find(y_);
if(x==y) return ;
if(size[x] < size[y]) swap(x, y);
parent[y] = x;
size[x] += size[y];
}
bool same(ll x, ll y){
return find(x) == find(y);
}
};
int main() {
in(ll, N);
vector<pair<ll, ll>> xv(N), yv(N);
vector<pair<ll, pair<ll, ll>>> ev;
ev.reserve(N*3);
//set<ll> u;
ll ans = 0;
loop(i, N){
in(ll, x, y);
xv[i] = {x, i};
yv[i] = {y, i};
}
sort_v(xv);
sort_v(yv);
loop(i, N-1){
// x
ev.push_back({
xv[i+1].first - xv[i].first,
make_pair(xv[i].second, xv[i+1].second)
});
ev.push_back({
xv[i+1].first - xv[i].first,
make_pair(xv[i+1].second, xv[i].second)
});
// y
ev.push_back({
yv[i+1].first - yv[i].first,
make_pair(yv[i].second, yv[i+1].second)
});
ev.push_back({
yv[i+1].first - yv[i].first,
make_pair(yv[i+1].second, yv[i].second)
});
}
sort_v(ev);
UnionFind uf(N);
for(auto e : ev){
if(!uf.same(e.second.first, e.second.second)){
ans += e.first;
uf.unite(e.second.first, e.second.second);
}
}
out(ans);
}
| #include <bits/stdc++.h>
#define ff first
#define ss second
#define ll long long
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
int n; cin >> n;
int ans = 0;
multiset <ll> m;
for (int i = 0; i < n; i++) {
ll take; cin >> take;
m.insert(take);
}
while (!m.empty()) {
auto x = *m.rbegin();
m.erase(m.find(x));
ll stepval = pow(2, logb(x) + 1);
auto it = m.find(stepval - x);
if (it == m.end())
continue;
m.erase(it);
ans++;
}
cout << ans << endl;
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(void){
vector<int> hands;
int tmp;
while(cin >> tmp){
hands.push_back(tmp);
cin.ignore();
cin >> tmp;
hands.push_back(tmp);
cin.ignore();
cin >> tmp;
hands.push_back(tmp);
cin.ignore();
cin >> tmp;
hands.push_back(tmp);
cin.ignore();
cin >> tmp;
hands.push_back(tmp);
sort(hands.begin(), hands.end());
if(hands[0] == hands[3] || hands[1] == hands[4]){ //four card
cout << "four card" << endl;
}else if((hands[0] == hands[1] && hands[2] == hands[4]) ||
(hands[0] == hands[2] && hands[3] == hands[4])){ //full house
cout << "full house" << endl;
}else if((hands[0]+1 == hands[1] && hands[1]+1 == hands[2] && hands[2]+1 == hands[3] && hands[3]+1 == hands[4]) ||
(hands[0] == 1 && hands[1] == 10 && hands[2] == 11 && hands[3] == 12 && hands[4] == 13)){
cout << "straight" << endl;
}else if(hands[0] == hands[2] || hands[1] == hands[3] || hands[2] == hands[4]){//three cards
cout << "three card" << endl;
}else if((hands[0] == hands[1] && (hands[2] == hands[3] || hands[3] == hands[4])) || (hands[1] == hands[2] && hands[3] == hands[4])){//two pairs
cout << "two pair" << endl;
}else if(hands[0] == hands[1] || hands[1] == hands[2] || hands[2] == hands[3] || hands[3] == hands[4]){
cout << "one pair" << endl;
}else{
cout << "null" << endl;
}
hands.clear();
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int straight(int[]);
int main() {
int ans, h[5];
while(scanf("%d,%d,%d,%d,%d", &h[0], &h[1], &h[2], &h[3], &h[4])!=EOF) {
ans=0;
for(int i=0; i<4; i++) {
for(int j=i+1; j<5; j++) {
if(h[i]==h[j])
ans++;
}
}
switch(ans) {
case 1:
cout << "one pair" << endl;
break;
case 2:
cout << "two pair" << endl;
break;
case 3:
cout << "three card" << endl;
break;
case 4:
cout << "full house" << endl;
break;
case 6:
cout << "four card" << endl;
break;
default:
if(straight(h))
cout << "straight" << endl;
else
cout << "null" << endl;
}
}
return 0;
}
int straight(int h[5]) {
sort(h, h+5);
for(int i=0; i<9; i++) {
if(h[0]==i&&h[1]==i+1&&h[2]==i+2&&h[3]==i+3&&h[4]==i+4||h[0]==1&&h[1]==10&&h[2]==11&&h[3]==12&&h[4]==13)
return 1;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define debug(x) cerr << # x << "; "<< x << endl
int main() {
long long X, Y;
cin >> X;
Y = X;
long long happy = 0;
X = X / 500;
happy += 1000 * X;
Y -= X * 500;
Y = Y / 5;
happy += Y * 5;
cout << happy << endl;
}
| #include <bits/stdc++.h>
#define _overload(_1,_2,_3,name,...) name
#define _rep(i,n) _range(i,0,n)
#define _range(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define rep(...) _overload(__VA_ARGS__,_range,_rep,)(__VA_ARGS__)
#define _rrep(i,n) _rrange(i,n,0)
#define _rrange(i,a,b) for(int i=(int)(a)-1;i>=(int)(b);--i)
#define rrep(...) _overload(__VA_ARGS__,_rrange,_rrep,)(__VA_ARGS__)
#define _all(arg) begin(arg),end(arg)
#define uniq(arg) sort(_all(arg)),(arg).erase(unique(_all(arg)),end(arg))
#define bit(n) (1LL<<(n))
// #define DEBUG
#ifdef DEBUG
#define dump(...) fprintf(stderr, __VA_ARGS__)
#else
#define dump(...)
#endif
template<class T>bool chmax(T &a, const T &b) { return (a<b)?(a=b,1):0;}
template<class T>bool chmin(T &a, const T &b) { return (b<a)?(a=b,1):0;}
using namespace std;
using ll=long long;
using vi=vector<int>;
using vll=vector<ll>;
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int inf = INT_MAX;
const ll INF = LLONG_MAX;
const ll MOD = 1000000007LL;
const int dx[4]={1,0,-1,0};
const int dy[4]={0,1,0,-1};
ll extgcd(ll a,ll b,ll& x,ll& y){x=1,y=0;ll g=a;if(b!=0) g=extgcd(b,a%b,y,x),y-=a/b*x;return g;}
ll ADD(const ll &a, const ll &b, const ll mod=MOD) { return (a+b)%mod;}
ll SUB(const ll &a, const ll &b, const ll mod=MOD) { return (a-b+mod)%mod;}
ll MUL(const ll &a, const ll &b, const ll mod=MOD) { return (1LL*a*b)%mod;}
ll DIV(const ll &a, const ll &b, const ll mod=MOD) {ll x,y; extgcd(b,mod,x,y);return MUL(a,(x+mod)%mod,mod);}
int main(void){
cin.tie(0);
ios::sync_with_stdio(false);
int R; cin >> R;
string res = "AGC";
if(R < 1200){
res = "ABC";
}
else if(R < 2800){
res = "ARC";
}
cout << res << endl;
return 0;
}
| 0 |
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize ("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma warning(disable:4786)
#pragma warning(disable:4996)
#include <ctime>
#include<list>
#include <numeric>
#include<bitset>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<functional>
#include<string>
#include<cstring>
#include<cstdlib>
#include<queue>
#include<utility>
#include<fstream>
#include<sstream>
#include<cmath>
#include<stack>
#include<assert.h>
#include<unordered_map>
#include<unordered_set>
#include <array>
using namespace std;
#define MEM(a, b) memset(a, (b), sizeof(a))
#define CLR(a) memset(a, 0, sizeof(a))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define ABS(X) ( (X) > 0 ? (X) : ( -(X) ) )
#define S(X) ( (X) * (X) )
#define SZ(V) (int )V.size()
#define FORN(i, n) for(int i = 0; i < n; i++)
#define FORAB(i, a, b) for(int i = a; i <= b; i++)
#define ALL(V) V.begin(), V.end()
#define IN(A, B, C) ((B) <= (A) && (A) <= (C))
#define AIN(A, B, C) assert(IN(A, B, C))
typedef long long int LL;
//typedef __int128 LLL;
typedef long long LLL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef pair<double, double> PDD;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PLL> VPL;
typedef vector<PII> VP;
typedef vector<double> VD;
typedef vector<vector<int>> VVI;
typedef vector<string> VS;
typedef long double ld;
#define MAXN 1000006
//#define MAXN 1006
const LL MOD = 1000000007;
//const LL MOD = 998244353;
const LL INF = 2000000000000000001LL; //2e18 + 1
void solve(int ks) {
int h1, m1, h2, m2, k;
scanf("%d %d %d %d %d", &h1, &m1, &h2, &m2, &k);
int t1 = h1 * 60 + m1;
int t2 = h2 * 60 + m2;
if (t2 < t1) t2 += 60 * 24;
int t = t2 - t1 - k;
printf("%d\n", t);
}
void gen() {
}
int main()
{
double start_time = clock();
#ifdef LOCAL
freopen("C:\\Home\\ContestCodes\\sample.in", "r", stdin);
// freopen("C:\\Home\\ContestCodes\\sample.in", "r", stdin);
// freopen("out.out", "w", stdout);
#endif
gen();
if (0) {
int T;
scanf("%d", &T);
//AIN(T, 1, 5000);
for (int ks = 1; ks <= T; ks++) {
solve(ks);
if (ks % 1 == 0) fprintf(stderr, "%d done\n", ks);
}
}
else {
solve(0);
}
double end_time = clock();
fprintf(stderr, "Time = %lf\n", (end_time - start_time) / CLOCKS_PER_SEC);
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int main(){
int h1,m1,h2,m2,k;
cin>>h1>>m1>>h2>>m2>>k;
int x=h1*60+m1;
int y=h2*60+m2;
cout<<y-x-k;
}
| 1 |
#include <iostream>
#include <math.h>
using namespace std;
void Solve(int a)
{
const double pi = 3.14;
float ans;
ans = 2 * pi * a;
cout << ans;
}
int main()
{
int x;
cin >> x;
Solve(x);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long N, x, ans = 0;
cin >> N;
for (int i = N; i > 0; i--) {
x = sqrt(i);
x = x * x;
if (i == x) {
ans = i;
break;
}
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define pp pair<int,int>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define ll long long
ll MOD=1000000007;
int inf=1000000000;
ll INF=10000000000000000;
int main(){
int n;
ll x;
cin >> n >> x;
vector<ll> b(n),l(n),u(n);
vector<pair<ll,ll>> a(n);
ll uu=0;
rep(i,n){
cin >> b.at(i) >> l.at(i) >> u.at(i);
a.at(i).first=u.at(i)*(x-b.at(i))+l.at(i)*b.at(i);
a.at(i).second=i;
uu+=l.at(i)*b.at(i);
}
sort(a.begin(),a.end());
reverse(a.begin(),a.end());
ll sum=0,v;
rep(i,n){
sum+=a.at(i).first;
if (sum>uu) {sum-=a.at(i).first;v=i;break;}
if (sum==uu) {cout << (i+1)*x << endl;return 0;}
}
ll ans=INF;
rep(i,n){
ll y=sum;
int p=a.at(i).second;
if (i<v) y=sum-a.at(i).first+a.at(v).first;
ll t=uu-y+(u.at(p)-l.at(p))*b.at(p);
ll o=t/u.at(p);
if (t%u.at(p)!=0) o++;
ans=min(ans,v*x+o);
t=uu-y;
o=t/l.at(p);
if (t%l.at(p)!=0) o++;
ans=min(ans,v*x+o);
}
cout << ans << endl;
} | #include <vector>
#include <algorithm>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <cstdio>
#include <memory.h>
#include <cmath>
#include <array>
using namespace std;
void re(int& x);
template<class T, class... Ts> void re(T& t, Ts&... ts);
void pr(long long x);
void pr(const char *x);
void ps();
template<class T, class... Ts> void ps(const T& t, const Ts&... ts);
#ifdef FFDBG
#else
#define dbg(x...) dsfdsfsdfasd
#endif
typedef long long ll;
#define rep(i, a, b) for(int i = a; i < (b); ++i)
int n, x;
long long tgt = 0;
struct ex {
int l, r, b;
} exam[110000];
long long score(const ex& a, long long h) {
long long sc = a.l * 1ll * min(h, (ll)a.b);
sc += a.r * 1ll * max(0LL, h-a.b);
return sc;
}
bool check(long long hrs) {
int full = hrs / x;
int rem = hrs % x;
long long sc = 0;
rep(i,0,full) sc += score(exam[i], x);
long long best = sc;
rep(i,full,n) best = max(best, sc + score(exam[i], rem));
if (full < n) {
sc += score(exam[full], x);
rep(i,0,full) best = max(best, sc - score(exam[i], x) + score(exam[i],rem));
}
return best >= tgt;
}
void solve()
{
re(n,x);
rep(i,0,n) re(exam[i].b, exam[i].l, exam[i].r);
rep(i,0,n) tgt += exam[i].l * 1ll * exam[i].b;
sort(exam, exam+n, [](const ex& a, const ex& b) {
return score(a,x) > score(b,x);
});
long long st = 0, ed = n*1ll*x;
while (st < ed) {
long long md = (st+ed)/2;
if (check(md)) ed = md;
else st = md+1;
}
ps(st);
}
int main() {
solve();
}
void re(int& x) { scanf("%d", &x); }
template<class T, class... Ts> void re(T& t, Ts&... ts) {
re(t); re(ts...);
}
void pr(long long x) { printf("%lld", x); }
void pr(const char *x) { printf("%s", x); }
void ps() { pr("\n"); }
template<class T, class... Ts> void ps(const T& t, const Ts&... ts) {
pr(t); if (sizeof...(ts)) pr(" "); ps(ts...);
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
int main ()
{
ll a, z;
cin>>a;
z = a+a*a+a*a*a;
cout<<z<<endl;
return 0;
} | #include<iostream>
#include<algorithm>
using namespace std;
int main() {
string S;
cin >> S;
int s_Len = S.length();
if (s_Len == 3) {
reverse(S.begin(), S.end());
}
cout << S << endl;
}
| 0 |
#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define EPS 1e-6
using namespace std;
typedef long long LL;
const int maxn = 1e5 + 10;
int T;
int main()
{
int a, b, c;
while(cin >> a >> b >> c){
cout << c << " " << a << " " << b << endl;
}
return 0;
}
| #include <bits/stdc++.h>
// #include <chrono>
// #include <math.h>
using namespace std;
using ll = long long;
using ld = long double;
using namespace std::chrono;
#define fo(i,z,n) for(int i = z;i<n;i++)
#define Fo(i,z,n) for(ll i = z;i<n;i++)
#define INT_BITS 32
#define mod 1000000007
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vector<int> >
#define vvl vector<vector<ll> >
#define pb push_back
#define f first
// #define s second
#define int long long
#define float long double
#define all(c) (c).begin(), (c).end()
#define endl '\n'
#define pi 3.14159265358979323846
ll power(ll a,ll p,ll m=mod)
{ll res=1;while(p>0){if(p&1)res=(res*a)%m;a=(a*a)%m;p>>=1;}
return res;}
int pow(int a,int b){
if(b == 0)return 1;
int res = pow(a,b/2);
res = res*res;
if(b&1)res *= a;
return res;
}
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
// int t;
// cin >> t;
// while(t--){
// }
int a,b,c;
cin >> a >> b>> c;
swap(a,b);
swap(a,c);
cout << a << ' ' << b << ' ' << c << endl;
return 0;
}
| 1 |
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<vector>
#include<functional>
#include<algorithm>
#include<stdlib.h>
#include<string>
#include<string.h>
#define _USE_MATH_DEFINES
#include<math.h>
#include<deque>
#include<set>
#include<map>
#include<queue>
#include<list>
#include<iostream>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(auto i=a;i<b;i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
//ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
int main() {
int n, a, b;
ll s = 0, sb = 0;
cin >> n;
vector<int> v(n);
rep(i, 0, n)cin >> a >> b, v[i] = a + b, sb += (ll)b;
sort(all(v));
for (int i = v.size() - 1; i >= 0; i -= 2)s += (ll)v[i];
printf("%lld\n", s - sb);
return 0;
}
| #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main () {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> cur (n);
for (int i = 0; i < n; i++) {
cin >> cur[i];
}
sort(cur.begin(), cur.end());
int ans = 0;
for (int k = 30; k >= 1; k--) {
int target = 1 << k;
vector<int> nxtl;
vector<int> nxtr;
int lptr = 0, rptr = cur.size() - 1;
while (lptr <= rptr) {
if (lptr == rptr) {
nxtl.push_back(cur[lptr]);
break;
} else if (cur[lptr] + cur[rptr] == target) {
ans++;
lptr++;
rptr--;
} else if (cur[lptr] + cur[rptr] < target) {
nxtl.push_back(cur[lptr]);
lptr++;
} else if (cur[lptr] + cur[rptr] > target) {
nxtr.push_back(cur[rptr]);
rptr--;
}
}
reverse(nxtr.begin(), nxtr.end());
for (int u : nxtr) {
nxtl.push_back(u);
}
cur = nxtl;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=a;i<b;i++)
#define FORD(i,a,b) for(int i=a;i>=b;i--)
#define REP(i,n) FOR(i,0,n)
#define pb push_back
#define en "\n"
#define ITER(i,a) for( typeof(a.begin()) i=a.begin();i!=a.end();i++)
#define mod 1000000007
#define mpp make_pair
#define mes(a,b) memset((a),(b),sizeof((a))
typedef map<int,int> MI;
typedef pair<int,int> PI;
typedef vector<int> VI;
typedef long long int LL;
int main() {
// your code goes here
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin>>n;
n=(2*n);
int a[n];
for(int i=0;i<n;i++)
cin>>a[i];
sort(a,a+n);
int ans=0;
for(int i=0;i<n;i+=2)
{
ans=ans+a[i];
}
cout<<ans;
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 len(x) (ll)(x).length()
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
const int INF=1e9;
const ll INFS=1e18;
const int MOD=INF+7;
const int di[] = {-1,0,1,0};
const int dj[] = {0,-1,0,1};
int main() {
int n;
cin>>n;
map<int,int> mp;
rep(i,n){
int a;
cin>>a;
if(mp[a]!=1){
mp[a]=1;
}else{
mp[a]=0;
}
}
int ans=0;
for(auto x:mp){
if(x.second==1){
ans++;
}
}
cout<<ans<<endl;
} | 0 |
#include<stdio.h>
#include<string.h>
int main(void) {
int a[10000],n,b=0,i,x,d=3;
char r[10000];
char s[10000];
scanf("%d", &n);
sprintf(s, "%d", d);
for(i = 1; i <= n; i++) {
sprintf(r,"%d", i);
if (i % 3 == 0) {
a[b] = i;
b++;
}
else if (strstr(r,s) != NULL) {
a[b] = i;
b++;
}
}
for (x = 0; x < b; x++) {
if (x == 0) {
printf(" ");
}
printf("%d",a[x]);
if (x == b - 1) {
printf("\n");
}
else {
printf(" ");
}
}
return 0;
}
| #include<iostream>
using namespace std;
int main(int argc,char* argv[]){
int input,num,tmp;num=1;cin >> input;
while(num<=input){
if(num%3==0){cout<<" "<<num;num++;}
if(num>input) break;tmp=num;
while(tmp!=0){if(tmp%10==3){ cout<<" "<<num;break;}tmp/=10;}
num++;}
cout<<endl;} | 1 |
#include <stdio.h>
#include <math.h>
double dist(int x1, int y1, int x2, int y2)
{
return sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
}
int main()
{
int n; scanf("%d", &n);
int x[8], y[8];
double ans = 0.0;
for (int i=0; i<n; i++) scanf("%d %d", &x[i], &y[i]);
for (int i=0; i<n; i++)
{
for (int j=i+1; j<n; j++)
{
ans += dist(x[i], y[i], x[j], y[j]) * 2 / n;
}
}
printf("%.10lf\n", ans);
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
void printVector(const vector<int>& vec) {
for (int value : vec) {
cout << value << " ";
}
cout << endl;
}
int main()
{
int n;
double x[10], y[10], ans = 0.0, count = 0.0;
cin >> n;
vector<int> num(n);
rep(i, n) cin >> x[i] >> y[i];
rep(i, n) num[i] = i;
do
{
for (int i = 1; i < n; i++)
{
ans += sqrt(pow(x[num[i]] - x[num[i - 1]], 2) + pow(y[num[i]] - y[num[i - 1]], 2));
}
count++;
} while (next_permutation(num.begin(), num.end()));
cout << fixed << setprecision(10) <<ans / count << endl;
return 0;
} | 1 |
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
vector<ll> divisor(ll n) {
vector<ll> res;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (i != n / i) res.push_back(n / i);
}
}
return res;
}
int main() {
ll n;
cin >> n;
auto divs = divisor(n);
sort(divs.begin(), divs.end());
ll left = -1;
ll right = divs.size();
while (right - left > 1) {
ll mid = left + (right - left) / 2;
ll v1 = divs[mid];
ll v2 = n / divs[mid];
if (to_string(v1).size() >= to_string(v2).size())
right = mid;
else
left = mid;
}
ll v1 = divs[right];
ll v2 = n / divs[right];
cout << max(to_string(v1).size(), to_string(v2).size()) << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long
ll F(ll A, ll B){
string bufA = to_string(A), bufB = to_string(B);
return max(bufA.size(), bufB.size());
}
int main(){
ll N;
ll ans = to_string(N).size();
cin >> N;
for(ll i = 1; i <= sqrt(N); ++i){
if(N % i == 0) ans = min(ans, F(i, N/i));
}
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main()
{
int64_t n;
string s = "";
cin >> n;
while(n!=0)
{
n--;
s += 'a' + n % 26;
n /= 26;
}
reverse(s.begin(), s.end());
cout << s << endl;
} | //https://atcoder.jp/contests/abc146/tasks/abc146_a
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
string x;
cin>>x;
if(x=="SUN")
{
cout<<"7"<<"\n";
}
else if(x=="MON")
{
cout<<"6"<<"\n";
}
else if(x=="TUE")
{
cout<<"5"<<"\n";
}
else if(x=="WED")
{
cout<<"4"<<"\n";
}
else if(x=="THU")
{
cout<<"3"<<"\n";
}
else if(x=="FRI")
{
cout<<"2"<<"\n";
}
else if(x=="SAT")
{
cout<<"1"<<"\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define ALL(x) x.begin(), x.end()
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
using ll = long long;
using lld = long double;
using VI = vector<int>;
using VVI = vector<VI>;
using VL = vector<ll>;
using VVL = vector<VL>;
using PII = pair<int, int>;
random_device rnd;
mt19937 mt(rnd());
const int IINF = 1 << 30;
const ll INF = 1ll << 60;
const ll MOD = 1e9 + 7;
int main()
{
int n, m;
cin >> n >> m;
VVI v(n, VI(m));
rep(i, n) rep(j, m)
{
cin >> v[i][j];
v[i][j]--;
}
VI p(n, 0);
int ans = IINF;
map<int, bool> used;
rep(j, m)
{
map<int, int> mp;
rep(i, n)
{
mp[v[i][p[i]]]++;
}
int delid = -1;
int delnum = 0;
rep(i, m)
{
if (mp[i] > delnum)
{
delnum = mp[i];
delid = i;
}
}
chmin(ans, delnum);
used[delid] = true;
if (j == m - 1)
break;
rep(i, n)
{
while (used[v[i][p[i]]])
p[i]++;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define WHOLE(v) (v).begin(), (v).end()
#define REV_WHOLE(v) (v).rbegin(), (v).rend()
using i64 = int64_t;
using namespace std;
template<class F>auto recursive(F f){return[f](auto...a){return f(f,a...);};}
template<class T>using rev_priority_queue=priority_queue<T,vector<T>,greater<T>>;
template<class T>using vector2d=vector<vector<T>>;
struct fixprec{int p;fixprec(int p):p(p){}};
ostream&operator<<(ostream&o,fixprec f){return o<<fixed<<setprecision(f.p);}
int main() {
int N, M, lK;
i64 K;
cin >> N;
vector<i64> x(N), dx(N - 1), y(N);
for(i64 &x_ : x) cin >> x_;
for(int i = 0; i < N - 1; i++) {
dx[i] = x[i + 1] - x[i];
}
cin >> M >> K;
vector<int> perm_base(N - 1), perm_ans(N - 1), perm_tmp(N - 1);
for (int i = 0; i < N - 1; i++) {
perm_base[i] = perm_ans[i] = i;
}
for(int i = 0; i < M; i++) {
int a;
cin >> a;
a--;
swap(perm_base[a - 1], perm_base[a]);
}
// 繰り返し二乗法
for(int b = 0; (1ll << b) <= K; b++) {
if (K & (1ll << b)) {
for (int i = 0; i < N - 1; i++) {
perm_ans[i] = perm_base[perm_ans[i]];
}
}
for (int i = 0; i < N - 1; i++) perm_tmp[i] = i;
for (int i = 0; i < N - 1; i++) {
perm_tmp[i] = perm_base[perm_base[i]];
}
swap(perm_tmp, perm_base);
}
for(int i = 0; i < N; i++) {
y[i] = i ? dx[perm_ans[i - 1]] + y[i - 1] : x[0];
cout << y[i] << endl;
}
return 0;
}
| 0 |
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int A, B, C, D;
int main(int argc, char* argv[]) {
cin >> A >> B >> C >> D;
int L = A + B;
int R = C + D;
if (L > R)
cout << "Left" << endl;
else if (L == R)
cout << "Balanced" << endl;
else
cout << "Right" << endl;
return 0;
} | #include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define rep(i, n) for(int i=0;i<n;++i)
#define rrep(i, n) for(int i=n;i>=0;--i)
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
int H, W, A, B;
cin>>H>>W>>A>>B;
int ans[H][W];
for(int i=0;i<H;++i) {
for(int j=0;j<W;++j) {
ans[i][j] = 0;
}
}
map<int, int> gyo[H], retu[W];
for(int i=0;i<H;++i) {
for(int j=0;j<W;++j) {
if(gyo[i][1]<W-A && retu[j][1]<H-B) {
ans[i][j] = 1;
gyo[i][1]++;
retu[j][1]++;
}
}
}
bool can = true;
for(int i=0;i<H;++i) {
if(gyo[i][1]!=A && gyo[i][1]!=W-A) can = false;
if(retu[i][1]!=B && retu[i][1]!=H-B) can = false;
}
for(int i=0;i<H;++i) {
for(int j=0;j<W;++j) {
cout<<ans[i][j];
}
cout<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ALL(v) v.begin(), v.end()
#define V vector
#define P pair
using ll = long long;
using ld = long double;
const int MOD = 1e9+7;
const ll INF = 1LL << 60;
int main() {
int a, b; cin >> a >> b;
if(a == b || a - 1 == b || a == b - 1) cout << "Yay!" << endl;
else cout << ":(" << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ArraySizeOf(array) (sizeof(array) / sizeof(array[0]))
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define int long long
#define rev(i,n) for(int i=n-1;i>=0;i--)
#define _GLIBCXX_DEBUG
int INF = 1e9+7;
unsigned NthDayOfWeekToDay(unsigned n, unsigned dow, unsigned dow1)
{
unsigned day;
if(dow < dow1) dow += 7;
day = dow - dow1;
day += 7 * n - 6;
return day;
}
unsigned DayToWeekNumber(unsigned day)
{
return (day - 1) / 7 + 1;
}
unsigned AnotherDayOfWeek(unsigned day, unsigned day0, unsigned dow0)
{
return (dow0 + 35 + day - day0) % 7;
}
using namespace std;
signed main(){
int a,b;
cin>>a>>b;
cout<<(a<9&&b<9? "Yay!":":(")<<endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
string s;
cin >> s;
vector<int> alp(26, 0);
for(char d : s){
alp[d - 'a'] = 1;
}
bool f = true;
for(int i = 0; i < 26; i++){
if(alp[i] == 0){
f = false;
cout << char(i + 'a') << endl;
break;
}
}
if(f) puts("None");
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
string s;
cin >> s;
map<char, int> m;
for (int i = 0; i < (int)s.size(); i++) {
m[s.at(i)]++;
}
for (char i = 'a'; i <= 'z'; i++) {
if (m[i] == 0) {
cout << i << endl;
return 0;
}
}
cout << "None" << endl;
return 0;
} | 1 |
#include <bits//stdc++.h>
using namespace std;
#define int long long
signed main() {
int A,N,Max=0;
cin >> N;
long long goukei=0;
for(int i=0;i<N;i++){
cin >> A;
goukei+=max(Max-A,(int)0);
Max=max(A,Max);
}
cout << goukei << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
const int MAX = (int)(1e5 + 5);
const ll INF = (ll)(1e10 + 5);
const int MAX_N = (int)(1e5 + 5);
int n;
ll a[MAX_N];
ll b[MAX_N];
int main(void) {
// Here your code !
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%lld %lld", &(a[i]), &(b[i]));
}
vector<pair<ll, int>> sum_index;
for (int i = 0; i < n; ++i) {
sum_index.emplace_back(a[i] + b[i], i);
}
sort(sum_index.begin(), sum_index.end(), greater<pair<ll, int>>());
ll ans = 0LL;
for (int i = 0; i < n; ++i) {
if (i % 2 == 0) {
ans += a[sum_index[i].second];
} else {
ans -= b[sum_index[i].second];
}
}
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
#include <cstdio>
using namespace std;
const int MAX_P = 10020;
bool prime[MAX_P];
void init()
{
for (int i = 0; i < MAX_P; i++)
prime[i] = true;
prime[0] = prime[1] = false;
for (int i = 2; i * i < MAX_P; i++)
if (prime[i])
for (int j = 2 * i; j < MAX_P; j += i)
prime[j] = false;
}
int main()
{
init();
int n;
while (cin >> n, n) {
while (n >= 2) {
if (prime[n] && prime[n - 2]) {
printf("%d %d\n", n - 2, n);
break;
}
n--;
}
}
return 0;
} | #include<iostream>
#include<string>
#include<cstring>
bool find(const std::string &text, const std::string pattern){
int text_i=0,pattern_i=0;
while(text_i<text.size()&&pattern_i<pattern.size()){
if(text[text_i]==pattern[pattern_i]) {
text_i++;
pattern_i++;
}else{
pattern_i=0;
text_i=text_i-pattern_i+1;
}
}
return (pattern_i==pattern.size()?true:false);
}
void decode( std::string &coded_data,int diff){
for(int i=0;i<coded_data.size();i++){
if(isalpha(coded_data[i])){
coded_data[i]-=diff;
if(!isalpha(coded_data[i])) coded_data[i]+=26;
}
}
}
int main(void){
std::string coded_data;
while(std::getline(std::cin,coded_data)){
for(int i=0;i<26;i++){
decode(coded_data,1);
if(find(coded_data,"the") || find(coded_data,"this")||find(coded_data,"that"))
std::cout<<coded_data<<std::endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin>>N;
vector<int> p(N);
for(int i=0;i<N;i++){
cin>>p[i];
}
int L;
cin>>L;
vector<vector<int>> dp(N,vector<int>(17));
for(int j=0;j<17;j++){
for(int i=0;i<N;i++){
if(j==0){
if(p[i]+L>=p[N-1]){
dp[i][0]=N-1;
}
else{
int b=lower_bound(p.begin(),p.end(),p[i]+L+1)-p.begin();
dp[i][0]=b-1;
}
}
else{
dp[i][j]=dp[dp[i][j-1]][j-1];
}
}
}
int Q;
cin>>Q;
for(int l=0;l<Q;l++){
int a,b;
cin>>a>>b;
a--,b--;
if(a>b){
swap(a,b);
}
int Z=1;
for(int i=16;i>=0;i--){
if(dp[a][i]<b){
Z+=(1<<i);
a=dp[a][i];
}
}
cout<<Z<<endl;
}
} | #include<bits/stdc++.h>
using namespace std;
const long long N=2e5+5;
const long long inf=0x3f3f3f3f;
struct pl
{
long long x;long long y;long long jyz;
}p1[N];
vector <pl> xxx[N],yyy[N],zzz[N*2],fff[N*2];
long long cntx,cnty,cntz,cntf,n,ans=inf;
string s;
bool cjy(pl a,pl b)
{
if (a.x>b.x) return 0;
if (a.x<b.x) return 1;
return a.y<b.y;
}
signed main()
{
;;;;;
cin>>n;
for (long long i=1;i<=n;i++)
{
scanf("%lld%lld",&p1[i].x,&p1[i].y);
cin>>s;
if (s=="U") p1[i].jyz=1;
if (s=="R") p1[i].jyz=2;
if (s=="D") p1[i].jyz=3;
if (s=="L") p1[i].jyz=4;
}
sort(p1+1,p1+n+1,cjy);
for (long long i=1;i<=n;i++)
{
xxx[p1[i].x].push_back(p1[i]);
yyy[p1[i].y].push_back(p1[i]);
fff[p1[i].x+p1[i].y].push_back(p1[i]);
zzz[p1[i].x-p1[i].y+N-5].push_back(p1[i]);
}
for (long long i=0;i<N;i++) if (xxx[i].size()>=2)
{
long long tans=inf,ty=-1;
for (long long j=0;j<xxx[i].size();j++)
{
if (xxx[i][j].jyz==1) ty=xxx[i][j].y;
if (xxx[i][j].jyz==3&&ty!=-1) tans=min(tans,xxx[i][j].y-ty);
}
ans=min(ans,5*tans);
}
for (long long i=0;i<N;i++) if (yyy[i].size()>=2)
{
long long tans=inf,tx=-1;
for (long long j=0;j<yyy[i].size();j++)
{
if (yyy[i][j].jyz==2) tx=yyy[i][j].x;
if (yyy[i][j].jyz==4&&tx!=-1) tans=min(tans,yyy[i][j].x-tx);
}
ans=min(ans,5*tans);
}
for (long long i=0;i<2*N;i++) if (fff[i].size()>=2)
{
long long tans=inf,td=-1,tr=-1;
for (long long j=0;j<fff[i].size();j++)
{
if (fff[i][j].jyz==2) tr=fff[i][j].x;
if (fff[i][j].jyz==3) td=fff[i][j].x;
if (fff[i][j].jyz==1&&tr!=-1) tans=min(tans,fff[i][j].x-tr);
if (fff[i][j].jyz==4&&td!=-1) tans=min(tans,fff[i][j].x-td);
}
ans=min(ans,10*tans);
}
for (long long i=0;i<2*N;i++) if (zzz[i].size()>=2)
{
long long tans=inf,tu=-1,tr=-1;
for (long long j=0;j<zzz[i].size();j++)
{
if (zzz[i][j].jyz==2) tr=zzz[i][j].x;
if (zzz[i][j].jyz==1) tu=zzz[i][j].x;
if (zzz[i][j].jyz==3&&tr!=-1) tans=min(tans,zzz[i][j].x-tr);
if (zzz[i][j].jyz==4&&tu!=-1) tans=min(tans,zzz[i][j].x-tu);
}
ans=min(ans,10*tans);
}
if (ans==inf) cout<<"SAFE"<<endl;
else cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (long long i = (a); i < (b); i++)
#define REP(i, N) for (long long i = 0; i < (N); i++)
#define FORR(i, a, b) for (long long i = (a); i >= (b); i--)
#define REPR(i, N) for (long long i = n; i >= 0; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define ALL(s) (s).begin(), (s).end()
#define pb(a) push_back(a)
#define fi first
#define se second
#define PI acos(-1.0)
#define INF 1000000007
#define EPS 1e-10
#define MAX_M 100100
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<double, double> PD;
typedef pair<string, ll> PS;
typedef vector<ll> V;
typedef pair<P, char> PC;
int dy[] = {0, 0, 1, -1, 0};
int dx[] = {1, -1, 0, 0, 0};
int main()
{
ll N;
string s;
cin >> N;
cin >> s;
string ans;
string init_pattern[4] = {"SS", "SW", "WS", "WW"};
for(string p: init_pattern){
ans = "";
ans += p;
FOR(i,2,N+2){
if(s[(i-1)%N] == 'o'){
if(ans[i-1] == 'S'){
ans += ans[i-2];
}else{
ans += (ans[i-2] == 'S') ? 'W' : 'S';
}
}else {
if(ans[i-1] == 'S'){
ans += (ans[i-2] == 'S') ? 'W' : 'S';
}else{
ans += ans[i-2];
}
}
}
if (ans[0] == ans[N] && ans[1] == ans[N+1]){
break;
}
ans = "-1";
}
cout << ans.substr(0,N) << endl;
}
| #include <bits/stdc++.h>
//#include <atcoder/all>
using namespace std;
//using namespace atcoder;
using usize = ::std::size_t;
using u64 = ::std::int_least64_t;
//using u64 = long long;
static constexpr u64 Inf = ::std::numeric_limits<u64>::max() / 2;
int getrandmax() {
static uint32_t y = time(NULL);
y ^= (y << 13); y ^= (y >> 17);
y ^= (y << 5);
return abs((int)y);
}
int getrand(int l, int r) { // [l, r]
return getrandmax() % (r - l + 1) + l;
}
int main(int argc, char *argv[])
{
cin.tie(0) ;
ios::sync_with_stdio(false) ;
int n;
cin >> n;
vector<int> A(n), B(n);
for (int i = 0; i < n; i++) {
cin >> A[i];
}
for (int i = 0; i < n; i++) {
cin >> B[i];
}
sort(B.begin(), B.end(), greater<int>());
int i = 0;
bool found = false;
while (i < n && clock() < 1.95 * CLOCKS_PER_SEC) {
if (A[i] == B[i]) {
int j = getrand(i, n - 1);
if (B[j] == B[i]) {
j = getrand(0, i);
if(B[j] != A[i] && B[i] != A[j]){
swap(B[i], B[j]);
}
} else {
swap(B[i], B[j]);
}
i--;
}
i++;
found = (i == n);
}
if (found) {
cout << "Yes" << endl;
for (int i = 0; i < n; i++) {
if (i == 0) {
cout << B[i];
} else {
cout << " " << B[i];
}
if(i == n - 1){
cout << endl;
}
}
} else {
cout << "No" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < n; i++)
vector<long long> create_table(vector<long long> pattern) {
vector<long long> table(pattern.size()+1, 0);
long long j = 0;
for (long long i = 1; i < pattern.size(); i++) {
if (pattern[i] == pattern[j])
table[i] = j++;
else {
table[i] = j;
j = 0;
}
}
table[pattern.size()] = j;
return table;
}
vector<long long> kmp_search(vector<long long> target, vector<long long> pattern) {
vector<long long> table = create_table(pattern);
/*
for (int i = 0; i < table.size(); i++)
cout << table[i] << " ";
cout << endl;
*/
vector<long long> result;
long long p = 0;
for (long long i = 0; i < target.size(); i++) {
if (target[i] == pattern[p])
p++;
else if (p != 0 && target[i] != pattern[p]) {
p = table[p];
i--;
}
//cout << i << " " << p << endl;
if (p == pattern.size()) {
result.push_back((i+1)-p);
p = table[p];
}
}
return result;
}
int main() {
int n;
cin >> n;
vector<ll> a(n), b(n);
rep(i, n) cin >> a[i];
rep(i, n) cin >> b[i];
vector<ll> copy_a(a);
copy_a.insert(copy_a.end(), a.begin(), a.end()-1);
vector<ll> new_a(2*n-2), new_b(n-1);
rep(i, 2*n-2) new_a[i] = copy_a[i] ^ copy_a[i+1];
rep(i, n-1) new_b[i] = b[i] ^ b[i+1];
vector<ll> kmp = kmp_search(new_a, new_b);
rep(i, kmp.size())
cout << kmp[i] << " " << (a[kmp[i]] ^ b[0]) << endl;
} | ///
// File: alds1_8_c.cpp
// Author: ymiyamoto
//
// Created on Sun Oct 15 01:12:42 2017
//
#include <cstdint>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct tree_t {
tree_t *left;
tree_t *right;
tree_t *parent;
int64_t value;
tree_t(tree_t *par, int64_t val)
{
left = NULL;
right = NULL;
parent = par;
value = val;
}
};
static tree_t *tree;
static vector<int64_t> pre, in;
void insert(tree_t *top, int64_t val)
{
if (top == NULL) {
tree = new tree_t(NULL, val);
return;
}
if (val < top->value) {
if (top->left == NULL) {
tree_t *node = new tree_t(top, val);
top->left = node;
} else {
insert(top->left, val);
}
} else if (val > top->value) {
if (top->right == NULL) {
tree_t *node = new tree_t(top, val);
top->right = node;
} else {
insert(top->right, val);
}
}
}
void walk(tree_t *top)
{
if (top == NULL) return;
pre.push_back(top->value);
walk(top->left);
in.push_back(top->value);
walk(top->right);
}
void print()
{
pre.clear();
in.clear();
walk(tree);
for (uint32_t i = 0; i < in.size(); i++) {
cout << " " << in[i];
}
cout << endl;
for (uint32_t i = 0; i < pre.size(); i++) {
cout << " " << pre[i];
}
cout << endl;
}
bool find(tree_t *top, int64_t val)
{
if (top == NULL)
return false;
else {
if (val == top->value) {
return true;
} else if (val < top->value) {
return find(top->left, val);
} else {
return find(top->right, val);
}
}
}
int64_t find_min(tree_t *top)
{
if (top->left == NULL)
return top->value;
else
return find_min(top->left);
}
void del(tree_t *top, int64_t val)
{
if (val == top->value) {
if (top->left == NULL && top->right == NULL) {
tree_t *parent = top->parent;
if (parent->left == top) {
parent->left = NULL;
} else {
parent->right = NULL;
}
delete top;
} else if (top->left == NULL) {
tree_t *parent = top->parent;
if (parent->left == top) {
parent->left = top->right;
} else {
parent->right = top->right;
}
top->right->parent = parent;
delete top;
} else if (top->right == NULL) {
tree_t *parent = top->parent;
if (parent->left == top) {
parent->left = top->left;
} else {
parent->right = top->left;
}
top->left->parent = parent;
delete top;
} else {
top->value = find_min(top->right);
del(top->right, top->value);
}
} else if (val < top->value) {
del(top->left, val);
} else {
del(top->right, val);
}
}
int32_t main()
{
uint32_t n;
cin >> n;
for (uint32_t i = 0; i < n; i++) {
string str;
int64_t val;
cin >> str;
if (str[0] == 'i') {
cin >> val;
insert(tree, val);
} else if (str[0] == 'f') {
cin >> val;
if (find(tree, val)) {
cout << "yes" << endl;
} else {
cout << "no" << endl;
}
} else if (str[0] == 'd') {
cin >> val;
del(tree, val);
} else {
print();
}
}
return 0;
} | 0 |
#include<bits/stdc++.h>
#define rep(i,n) for (int i=0; i<n; ++i) // マクロ
using namespace std; // stdの省略
using pii = pair<int, int>; // pairの略記
using ll = long long; // long longの略記
int main(void) {
int r;
cin >> r;
cout << 2*r*M_PI << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int A, B;
cin >> A >> B;
cout << A * B << endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,count=0;
cin>>a>>b;
for(int i=a;i<=b;i++)
{
string s=to_string(i);
int n=s.length();
if(s[0]==s[n-1] && s[1]==s[n-2])
{
count++;
}
}
cout<<count<<"\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
int res = 0;
for (int i = A; i <= B; i++) {
if (i/10000 == i%10) {
if (i/1000%10 == i%100/10) {
res += 1;
}
i += 9;
}
}
cout << res << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll MOD = 1e9+7;
// const ll MOD = 998244353;
const ll INF = 1ll<<60;
#define FOR(i,a,b) for (ll i=(a);i<(ll)(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define DEBUG(x) std::cerr << #x << " : " << (x) << std::endl;
vector<ll> seen, deg, par;
vector<vector<ll>> G;
void dfs(ll v, ll pav)
{
seen[v] = true;
par[v] = pav+1;
for (auto &nv : G[v])
--deg[nv];
for (auto &nv : G[v])
{
if (!deg[nv] && !seen[nv])
dfs(nv, v);
}
}
int main(int argc, char **argv)
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll N, M; cin >> N >> M;
G.resize(N);
par.resize(N);
deg.assign(N, 0);
seen.assign(N, false);
REP(i, N-1+M)
{
ll a, b; cin >> a >> b;
--a, --b;
G[a].push_back(b);
deg[b]++;
}
ll root;
REP(i, N)
if (!deg[i])
root = i;
dfs(root, -1);
REP(i, N)
std::cout << par[i] << std::endl;
return 0;
}
| #include <stdio.h>
#include <math.h>
#define MAXINPUT 100
int main(void){
int h[MAXINPUT],w[MAXINPUT];
int ansh[MAXINPUT]={},answ[MAXINPUT]={};
int i=0,j=0;
int ans=0;
int num=0;
int k;
while(i<MAXINPUT){
scanf("%d %d",&h[i],&w[i]);
if(h[i]==0 && w[i]==0)break;
i++;
num++;
}
for(i=0;i<num;i++,ans=0){
ans=h[i]*h[i]+w[i]*w[i];
for(;(ansh[i]==0||answ[i]==0);){
for(j=1;k==0;j++){
double temp=ans-(j*j);
double tempa=0;
if(temp<=0){
k=1;
break;
}
temp=sqrt(temp);
temp=modf(temp,&tempa);
if(temp==0 && tempa<=150 && j<tempa){
if(tempa*tempa+j*j==h[i]*h[i]+w[i]*w[i] && j<=h[i]){
continue;
}
ansh[i]=j;
answ[i]=(int)tempa;
printf("%d %d\n",ansh[i],answ[i]);
break;
}
}
ans++;
k=0;
}
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
double K=0;
vector<int> X(N),Y(N);
for(int i=0;i<N;i++){
cin >> X.at(i) >> Y.at(i);
}
for(int i=0;i<N-1;i++){
for(int j=i+1;j<N;j++){
int X2=X.at(i)-X.at(j);
int Y2=Y.at(i)-Y.at(j);
K+=sqrt(X2*X2+Y2*Y2);
}
}
cout << fixed << setprecision(10) << 2*K/N << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
int main()
{
int n;
cin >> n;
vector<int> x(n), y(n), per(n);
rep(i, n) cin >> x[i] >> y[i];
rep(i, n) per[i] = i;
double ans = 0;
int cnt = 0;
do
{
cnt++;
rep(i, n - 1)
{
ans += sqrt(pow(x[per[i + 1]] - x[per[i]], 2.0) + pow(y[per[i + 1]] - y[per[i]], 2.0));
}
} while (next_permutation(all(per)));
printf("%6lf\n", ans / cnt);
return 0;
}
| 1 |
# include <bits/stdc++.h>
# include <ext/pb_ds/assoc_container.hpp>
# include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
template<typename T> using ordered_set = tree <T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define _USE_MATH_DEFINES_
#define ll long long
#define ld long double
#define Accepted 0
#define pb push_back
#define mp make_pair
#define sz(x) (int)(x.size())
#define every(x) x.begin(),x.end()
#define F first
#define S second
#define lb lower_bound
#define ub upper_bound
#define For(i,x,y) for (ll i = x; i <= y; i ++)
#define FOr(i,x,y) for (ll i = x; i >= y; i --)
#define SpeedForce ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
// ROAD to... Red
inline void Input_Output () {
//freopen(".in", "r", stdin);
//freopen(".out", "w", stdout);
}
const double eps = 0.000001;
const ld pi = acos(-1);
const int maxn = 1e7 + 9;
const int mod = 1e9 + 7;
const ll MOD = 1e18 + 9;
const ll INF = 1e18 + 123;
const int inf = 2e9 + 11;
const int mxn = 1e6 + 9;
const int N = 6e5 + 123;
const int M = 22;
const int pri = 997;
const int Magic = 2101;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int n, m, k;
int a[N];
string s;
void sol (int x, int y) {
for (int i = 1; i <= n; i ++) {
a[i] = -1;
}
a[1] = x;
a[2] = y;
a[n+1] = x;
for (int i = 2; i < n; i++) {
bool nxt = 0;
if (a[i] == 1) nxt ^= 1;
if (s[i] == 'x') nxt ^= 1;
a[i+1] = (a[i-1] ^ nxt);
}
for (int i = 1; i <= n; i ++) {
int l = i-1;
int r = i+1;
if (r > n) r = 1;
if (l < 1) l = n;
bool nxt = 0;
if (a[i] == 1) nxt ^= 1;
if (s[i] == 'x') nxt ^= 1;
if(!nxt) {
if (a[l] != a[r]) return;
} else {
if (a[l] == a[r]) return;
}
}
for (int i = 1; i <= n; i ++)
cout << (a[i] ? "W" : "S");
exit(0);
}
int main () {
SpeedForce;
cin >> n >> s;
s = '#' + s;
for (int a = 0; a < 2; a++) {
for (int b = 0; b < 2; b++) {
sol(a, b);
}
}
puts("-1");
return Accepted;
}
// B...a
| #include <iostream>
#include <string>
#include <vector>
using namespace std;
int ed(string x,string y){
vector<vector<int>> tb(vector<vector<int>>((int)x.size()+1,vector<int>(y.size()+1,0)));
for(int i=0;i<(int)x.size()+1;i++) tb[i][0]=i;
for(int i=0;i<(int)y.size()+1;i++) tb[0][i]=i;
int tmp;
for(int i=1;i<(int)x.size()+1;i++){
for(int j=1;j<(int)y.size()+1;j++){
if(x[i-1]==y[j-1]) tmp=tb[i-1][j-1];
else tmp=tb[i-1][j-1]+1;
tb[i][j]=min(tmp,min(tb[i-1][j],tb[i][j-1])+1);
}
}
return tb[(int)x.size()][(int)y.size()];
}
int main(){
string x,y;
cin>>x>>y;
cout<<ed(x,y)<<endl;
return 0;
}
| 0 |
#include<cstdio>
const int N=1000005;
int n,he[128],nx[N],a,qu[N*2],hd,tl,d;char s[N],t[N];
inline int mx(int x,int y){return x>y?x:y;}
int main()
{
scanf("%d%s%s",&n,s+1,t+1),hd=n+1,tl=n;
for(int i=1;i<=n;++i)nx[i]=he[s[i]],he[s[i]]=i;
for(int i=n;i;--i)
{
if(hd>tl||i<qu[hd]-d)
{
hd=n+1,tl=n,d=0;
if(s[i]!=t[i])
{
for(;he[t[i]]&&he[t[i]]>=i;he[t[i]]=nx[he[t[i]]]);
if(!he[t[i]])return printf("-1"),0;
qu[--hd]=he[t[i]],qu[++tl]=i;
}
}
else
{
if(s[qu[hd]-d]!=t[i])
{
for(;he[t[i]]&&he[t[i]]>=qu[hd]-d;he[t[i]]=nx[he[t[i]]]);
if(!he[t[i]])return printf("-1"),0;
for(;qu[tl]-d>i;--tl);++d,qu[--hd]=he[t[i]]+d,qu[++tl]=i+d;
}
}
a=mx(a,tl-hd);
}
printf("%d",a);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
template <typename T> void read(T &t) {
t=0; char ch=getchar(); int f=1;
while (ch<'0'||ch>'9') { if (ch=='-') f=-1; ch=getchar(); }
do { (t*=10)+=ch-'0'; ch=getchar(); } while ('0'<=ch&&ch<='9'); t*=f;
}
const int maxn=(1e6)+10;
int n,m,sum,s,a[maxn],b[maxn];
char S[maxn];
int N,id[maxn],d[maxn],tot;
bool cmpa(int x,int y) { return a[x]<a[y]; }
bool cmpb(int x,int y) { return b[x]>b[y]; }
int main() {
//freopen("1.txt","r",stdin);
read(n);
for (int i=1;i<=n;i++) {
scanf("%s",S+1);
m=strlen(S+1);
s=0;
for (int j=1;j<=m;j++) {
if (S[j]=='(') s++; else s--;
a[i]=max(a[i],-s);
}
sum+=s;
s=0;
for (int j=m;j>=1;j--) {
if (S[j]=='(') s++; else s--;
b[i]=max(b[i],s);
}
//printf("%d %d\n",a[i],b[i]);
}
if (sum!=0) { printf("No\n"); return 0; }
sum=0;
for (int i=1;i<=n;i++) if (b[i]>=a[i]) d[++tot]=i;
sort(d+1,d+tot+1,cmpa);
for (int i=1;i<=tot;i++) id[++N]=d[i];
tot=0;
for (int i=1;i<=n;i++) if (b[i]<a[i]) d[++tot]=i;
sort(d+1,d+tot+1,cmpb);
for (int i=1;i<=tot;i++) id[++N]=d[i];
for (int i=1;i<=N;i++) {
if (sum-a[id[i]]<0) { printf("No\n"); return 0; }
sum+=b[id[i]]-a[id[i]];
}
printf("Yes\n");
return 0;
}
/*
0. Enough array size? Enough array size? Enough array size? Interger overflow?
1. Think TWICE, Code ONCE!
Are there any counterexamples to your algo?
2. Be careful about the BOUNDARIES!
N=1? P=1? Something about 0?
3. Do not make STUPID MISTAKES!
Time complexity? Memory usage? Precision error?
*/ | 0 |
#include<bits/stdc++.h>
using namespace std;
char str[100100];
int ty[4][100100];
main()
{
int n;
scanf("%d",&n);
scanf("%s",str);
ty[0][0]=ty[0][1]=ty[1][0]=ty[2][1]=0; // sheep
ty[1][1]=ty[2][0]=ty[3][0]=ty[3][1]=1; // wolf
for(int i=1;i<n;i++)
{
if(str[i]=='o')
{
for(int j=0;j<4;j++)
{
if(ty[j][i]==0)ty[j][i+1]=ty[j][i-1];
else ty[j][i+1]=(ty[j][i-1]+1)%2;
}
}
else
{
for(int j=0;j<4;j++)
{
if(ty[j][i]==1)ty[j][i+1]=ty[j][i-1];
else ty[j][i+1]=(ty[j][i-1]+1)%2;
}
}
}
for(int i=0;i<4;i++)
{
if(str[0]=='o')
{
if(ty[i][0]==0&&ty[i][n-1]==ty[i][1]&&ty[i][0]==ty[i][n])
{
//printf("%d %d\n",ty[i][n-1],ty[i][1]);
for(int j=0;j<n;j++)printf("%s",ty[i][j]==0?"S":"W");
return 0;
}
if(ty[i][0]==1&&ty[i][n-1]!=ty[i][1]&&ty[i][0]==ty[i][n])
{
for(int j=0;j<n;j++)printf("%s",ty[i][j]==0?"S":"W");
return 0;
}
}
else
{
if(ty[i][0]==1&&ty[i][n-1]==ty[i][1]&&ty[i][0]==ty[i][n])
{
for(int j=0;j<n;j++)printf("%s",ty[i][j]==0?"S":"W");
return 0;
}
if(ty[i][0]==0&&ty[i][n-1]!=ty[i][1]&&ty[i][0]==ty[i][n])
{
for(int j=0;j<n;j++)printf("%s",ty[i][j]==0?"S":"W");
return 0;
}
}
}
printf("-1");
}
| //高知能系Vtuberの高井茅乃です。
//Twitter: https://twitter.com/takaichino
//YouTube: https://www.youtube.com/channel/UCTOxnI3eOI_o1HRgzq-LEZw
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INTINF 1999999999
#define REP(i,n) for(int i=0;i<n;i++)
#define REP1(i,n) for(int i=1;i<=n;i++)
#define MODA 1000000007
int main() {
int ans = 0;
int tmp;
int n;
cin >> n;
string s;
cin >> s;
s = "-" + s;
bool sw[n+2] = {}, las, fir, ch = false;
REP(i, 2){
if(ch) break;
REP(j, 2){
if(ch) break;
sw[1] = i;
sw[n] = j;
sw[0] = j;
las = j;
fir = i;
for(int k = 1; k <= n; k++){
if(s[k] == 'o') sw[k+1] = sw[k-1];
else sw[k+1] = !sw[k-1];
if(!sw[k]) sw[k+1] = !sw[k+1];
//cout << k << " " << sw[k-1] << " " << sw[k] << " " << sw[k+1] << endl;
}
if(fir == sw[n+1] && las == sw[n]) ch = true;
}
}
if(ch){
REP1(i, n){
if(sw[i]) cout << "S";
else cout << "W";
}
cout << endl;
}
else cout << -1 << endl;
} | 1 |
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma,tune=native")
//#pragma GCC optimize("unroll-loops")
#ifdef __APPLE__
# include <iostream>
# include <cmath>
# include <algorithm>
# include <stdio.h>
# include <cstdint>
# include <cstring>
# include <string>
# include <cstdlib>
# include <vector>
# include <bitset>
# include <map>
# include <queue>
# include <ctime>
# include <stack>
# include <set>
# include <list>
# include <random>
# include <deque>
# include <functional>
# include <iomanip>
# include <sstream>
# include <fstream>
# include <complex>
# include <numeric>
# include <immintrin.h>
# include <cassert>
# include <array>
# include <tuple>
# include <unordered_map>
# include <unordered_set>
# include <thread>
#else
# include <bits/stdc++.h>
#endif
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define files(name) name!=""?freopen(name".in","r",stdin),freopen(name".out","w",stdout):0
#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define elif else if
#define mp make_pair
#define pb push_back
#define fir first
#define sec second
using namespace std;
#define int long long
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef long double ld;
typedef long long ll;
const int arr=2e5+10;
const int ar=2e3+10;
const ld pi=acos(-1);
const ld eps=1e-10;
const ll md=1e9+7;
const ll inf=1e18+10;
///---program start---///
#define arr (int)(1e6+10)
bool use[arr];
vi reb_one[arr];
vector<pii> reb[arr];
vi rem_comps[arr];
int comps=0;
int dist_bfs[arr];
vi reb_bfs[arr];
void add_bfs_edge(int u,int v)
{
// cout<<"bfs_edge :: "<<u<<" "<<v<<"\n";
reb_bfs[u].pb(v);
reb_bfs[v].pb(u);
}
void dfs(int now)
{
use[now]=1;
rem_comps[now].pb(comps);
for (auto wh:reb_one[now]){
if (!use[wh]){
dfs(wh);
}
}
}
void process(int v)
{
dfs(v);
comps++;
}
signed main()
{
#ifdef __APPLE__
files("barik");
freopen("debug.txt","w",stderr);
#endif
int n,m;
cin>>n>>m;
for (int i=0;i<m;i++){
int u,v,w;
cin>>u>>v>>w;
reb[w].pb(mp(u,v));
}
for (int i=0;i<arr;i++){
for (auto j:reb[i]){
reb_one[j.fir].pb(j.sec);
reb_one[j.sec].pb(j.fir);
}
for (auto j:reb[i]){
if (!use[j.fir]) {
process(j.fir);
}
if (!use[j.sec]) {
process(j.sec);
}
}
for (auto j:reb[i]){
reb_one[j.fir].clear();
reb_one[j.sec].clear();
use[j.fir]=0;
use[j.sec]=0;
}
}
// for (int i=1;i<=n;i++){
// cout<<"rem_comps["<<i<<"] :: ";
// for (auto j:rem_comps[i]){
// cout<<j<<" ";
// }
// cout<<"\n";
// }
for (int i=1;i<=n;i++){
int fake = comps++;
for (auto j:rem_comps[i]){
add_bfs_edge(fake,j);
}
}
queue<int> q;
for (int i=0;i<comps;i++){
dist_bfs[i]=inf;
}
for (auto j:rem_comps[1]){
dist_bfs[j]=0;
q.push(j);
}
while (!q.empty()){
int now=q.front();
q.pop();
for (auto wh:reb_bfs[now]){
if (dist_bfs[wh]>dist_bfs[now]+1){
dist_bfs[wh]=dist_bfs[now]+1;
q.push(wh);
}
}
}
int ans=inf;
for (auto j:rem_comps[n]){
ans=min(ans,dist_bfs[j]);
}
cout<<(ans==inf?-1:ans/2 + 1)<<"\n";
}
| #include<bits/stdc++.h>
#define ll long long
#define fornum(A,B,C) for(A=B;A<C;A++)
#define mp make_pair
#define pii pair<int,int>
#define pll pair<ll,ll>
using namespace std;
/////////////////////////////////////////////////////
#define MOD ((ll)1e9+7)
ll N,S;
vector<pll> xpv[2];
ll i, j, k,ans;
bool ck(ll t,ll aa,ll bb){
return t ? (aa <= bb) : (aa < bb);
}
int main(){
//printf("%lld\n", MOD);
scanf("%lld%lld", &N,&S);
fornum(i,0,N){
ll x, p;
scanf("%lld%lld", &x, &p);
xpv[S < x].push_back(mp(abs(x - S), p));
}
sort(xpv[0].begin(), xpv[0].end(), greater<pll>());
sort(xpv[1].begin(), xpv[1].end(), greater<pll>());
if(xpv[0].size()*xpv[1].size()==0){
printf("%lld",xpv[0].size()?xpv[0][0].first:xpv[1][0].first);
return 0;
}
ll n = 0, t = 0;
ll ii[]={0,0};
n= xpv[0][0].second+xpv[1][0].second;
if(xpv[0][0].second<xpv[1][0].second){
t = 0;
}else{
t = 1;
}
ii[t]++;
ans += xpv[t][0].first + xpv[!t][0].first * 2;
//printf("%lld,%lld\n", xpv[t][0].second, xpv[!t][0].second);
while(true){
while(ii[t]<xpv[t].size()&&ck(t,xpv[t][ii[t]].second,n)){
//printf("%lld,%lld\n", xpv[t][ii[t]].second, n);
n += xpv[t][ii[t]].second;
ii[t]++;
}
//printf("%lld,%lld,%lld\n", t, ii[t],n);
if(ii[t]==xpv[t].size())
break;
n += xpv[t][ii[t]].second;
ans += xpv[t][ii[t]].first*2;
t = !t;
ii[t]++;
}
printf("%lld", ans);
return 0;
} | 0 |
#include<iostream>
#include<stdio.h>
//#include <bits/stdc++.h>
#include<vector>
#include<float.h>
#include<iomanip>
#include<algorithm>
#include<string>
#include<cstring>
#include<math.h>
#include<cmath>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include <cassert>
#include <cmath>
#include<cstdint>
#define INF 1e9
#define rep(i,n)for(int i=0;(i)<(int)(n);i++)
#define REP(i,a,b)for(int i=(int)(a);(i)<=(int)(b);i++)
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define vec(type,n) vector<type>(n)
#define vvec(m,n) vector<vector<int>> (int(m),vector<int>(n))
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<ll, ll>;
struct edge{
int to;
int dist;
};
vector<bool> seen(100000, false);
vector<int> pnt(100000, INF);
vector<vector<edge>> G(100000);
int n, m;
bool f = true;
void dfs(int v, int dist){
seen[v] = true;
if(pnt[v] == INF)pnt[v] = dist;
else {
if(pnt[v] != dist)f = false;
return;
}
for(int i = 0; i < (int)(G[v].size()); i++){
edge e = G[v][i];
if(pnt[e.to] != INF && pnt[e.to] != pnt[v] + e.dist){
f = false;
return;
}
if(seen[e.to])continue;
dfs(e.to, e.dist + pnt[v]);
}
}
int main(){
ll n, m;
cin >> n >> m;
vector<ll> rui(n + 1, 0);
rep(i, n){
ll a;
cin >> a;
rui[i + 1] = rui[i] + a;
}
ll res = 0;
REP(i, 1, n){
rui[i] %= m;
if(rui[i] == 0)res++;
}
map<ll, ll> mp;
REP(i, 1, n)mp[rui[i]]++;
for(auto m : mp){
res += m.second * (m.second - 1) / 2;
}
cout << res << endl;
}
| #include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, n) for (int i = n - 1; i >= a; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> v(n);
rep(i, 0, n) cin >> v[i];
ll ans = 0;
rep(l, 0, k + 1) {
rep(r, 0, k - l + 1) {
if (l + r > n)
continue;
int d = k - l - r;
ll now = 0;
vector<int> s;
rep(i, 0, l) {
now += v[i];
s.push_back(v[i]);
}
rep(i, n - r, n) {
now += v[i];
s.push_back(v[i]);
}
sort(s.begin(), s.end());
rep(i, 0, d) {
if (i >= s.size() || s[i] > 0)
break;
now -= s[i];
}
ans = max(ans, now);
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
ll MOD = 1000000007;
#define vec vector<int>
#define vecll vector<ll>
#define vecd vector<double>
#define vecst vector<string>
#define vecb vector<bool>
#define v2(v,n,m,init) vector<vector<int>> v(n, vector<int>(m, init))
#define vb2(v,n,m,init) vector<vector<bool>> v(n, vector<bool>(m, init))
#define vll2(v,n,m,init) vector<vector<ll>> v(n, vector<ll>(m, init))
#define rep(i,n) for(ll i=(ll)0; i<(ll)n; i++)
#define REP(i,m,n) for(ll i=(ll)m; i<(ll)n; i++)
#define arr(var, n) vec var(n); rep(i,n){cin >> var[i];}
#define arrll(var, n) vecll var(n); rep(i,n){cin >> var[i];}
#define arrst(var, n) vecst var(n); rep(i,n){cin >> var[i];}
#define all(var) (var).begin(), (var).end()
#define sortall(var) sort(all(var))
#define uniqueall(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb(var) push_back(var)
#define prt(var) cout << (var) << "\n"
#define prtd(n, var) cout << fixed << setprecision(n) << (var) << "\n"
#define prtfill(n, var) cout << setw(n) << setfill('0') << (var);
#define prt2(v1, v2) cout << (v1) << " " << (v2) << "\n"
#define prt3(v1, v2, v3) cout << (v1) << " " << (v2) << " " << (v3) << "\n"
#define prtall(v) rep(i,v.size()){cout<<v[i]<<(i!=v.size()-1?" ":"\n");}
template <typename T>
bool chmax(T &a, const T& b){if(a<b){a=b; return true;} return false;}
template <typename T>
bool chmin(T &a, const T& b){if(a>b){a=b; return true;} return false;}
//------------------------------------------------------------------
int main(void){
ll n;
cin >> n;
if(n==0){
prt(0);
return 0;
}
string ans;
ll b=1, bd=2;
while(n!=0){
if(n%bd!=0) ans.push_back('1'), n-=b;
else ans.push_back('0');
b*=-2;
bd*=2;
}
reverse(all(ans));
prt(ans);
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define MOD 1000000007LL
#define rep(i, n) for(ll (i) = 0LL;(i) < (ll)(n);(i)++)
#define rep2(i, s, e) for(ll (i) = (ll)(s);(i) < (ll)(e);(i)++)
#define repi(i, n) for(ll (i) = 0LL;(i) <= (ll)(n);(i)++)
#define repi2(i, s, e) for(ll (i) = (ll)(s);(i) <= (ll)(e);(i)++)
#define per(i, n) for(ll (i) = (ll)(n) - 1LL;(i) >= 0LL;(i)--)
#define per2(i, s, e) for(ll (i) = (ll)(s) - 1LL;(i) >= (ll)(e);(i)--)
#define peri(i, n) for(ll (i) = (ll)(n);(i) >= 0LL;(i)--)
#define peri2(i, s, e) for(ll (i) = (ll)(s);(i) >= (ll)(e);(i)--)
#define iter(i, it) for(auto &(i): (it))
template<typename T, typename U> ostream& operator<<(ostream &s, const pair<T, U> m) {
cout << "(" << m.first << ", " << m.second << ")";
return s;
}
template<typename T, typename U> ostream& operator<<(ostream &s, const map<T, U> m) {
ll c = 0;
cout << "{ ";
iter(i, m) cout << i << (c++ == m.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const vector<T> &v) {
cout << "{ ";
rep(i, v.size()) cout << v[i] << (i == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const list<T> &v) {
ll c = 0;
cout << "{ ";
iter(i, v) cout << i << (c++ == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
int main(void) {
string s;
cin >> s;
if(s.size() == 3) reverse(s.begin(), s.end());
cout << s << endl;
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
const double PI=acos(-1.0);
int N,Q; string S; vi l,r;
void input()
{
cin>>N>>Q;
cin>>S;
for(int i=0;i<Q;++i){
int a,b; cin>>a>>b;
l.emplace_back(a); r.emplace_back(b);
}
}
void solve()
{
vi rui(N+1,0);
for(int i=2;i<N+1;++i){
rui[i]=rui[i-1];
if(S[i-2]=='A' && S[i-1]=='C') ++rui[i];
}
for(int i=0;i<Q;++i){
int ans=rui[r[i]]-rui[l[i]-1];
if(l[i]>1 && S[l[i]-2]=='A' && S[l[i]-1]=='C') --ans;
cout<<ans<<endl;
}
}
int main()
{
cin.tie();
ios::sync_with_stdio(false);
input();
solve();
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
vector<string> vec(3);
rep(i, 3) {
cin >> vec[i];
vec[i] += 'z';
}
vector<int> card_idx(3, 0);
int player = 'a' - 'a';
char now = vec[player][card_idx[player]];
card_idx[player] += 1;
while (now != 'z') {
player = now - 'a';
now = vec[player][card_idx[player]];
card_idx[player] += 1;
}
cout << (char)('A' + player) << endl;
return 0;
} | 0 |
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <assert.h>
#include <vector>
using namespace std;
typedef long long ll;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) for (__typeof((c).begin())it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
struct Item {
string name;
double value;
Item() {;}
Item(string name, double p, double a, double b, double c, double d, double e, double f, double s, double m) : name(name) {
value = (m * s * f - p) / (a + b + c + (d + e) * m);
}
bool operator<(const Item &rhs) const {
if (fabs(value - rhs.value) > EPS) { return value > rhs.value; }
return name < rhs.name;
}
};
int n;
Item item[100];
int main() {
while (scanf("%d", &n), n) {
REP(i, n) {
string name;
double p, a, b, c, d, e, f, s, m;
cin >> name >> p >> a >> b >> c >> d >> e >> f >> s >> m;
item[i] = Item(name, p, a, b, c, d, e, f, s, m);
}
sort(item, item + n);
REP(i, n) {
cout << item[i].name << endl;
}
puts("#");
}
} | #include <iostream>
#include <stdio.h>
#include <string.h>
#include <math.h>
using namespace std;
int s[10001];
void sieve() {
for(int i = 0; i < 10001; i++) s[i] = 1;
s[0] = s[1] = 0;
for(int i = 2; i <= sqrt(10001); i++) {
if(s[i]) {
for(int j = i * i; j < 10001; j += i) {
s[j] = 0;
}
}
}
}
int main() {
sieve();
int n;
while(~scanf("%d", &n)) {
if(n == 0) break;
for(int i = n; i >= 2; i--) {
if(s[i] && s[i - 2]) {
printf("%d %d\n", i - 2, i);
goto end;
}
}
end:;
}
} | 0 |
#include <cstdio>
using namespace std;
typedef long long int LL;
const int Max_N(100050);
namespace io
{
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c, qu[55]; int f, qr;
#define gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
inline void flush (){fwrite (obuf, 1, oS - obuf, stdout);oS = obuf;}
inline void putc (char x){*oS ++ = x;if (oS == oT) flush ();}
template <class I>
inline void gi (I &x) {for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0'; c = gc()) x = x * 10 + (c & 15); x *= f;}
template <class I>
inline void print (I x){
if (!x) putc ('0'); if (x < 0) putc ('-'), x = -x;while(x) qu[++ qr] = x % 10 + '0', x /= 10;while (qr) putc (qu[qr--]);}
struct Flusher_ {~Flusher_(){flush();}}io_flusher_;
}
using io::gi;
using io::putc;
using io::print;
int N, S, X[Max_N], V[Max_N];
LL P[Max_N], Ans;
void solve(int l, int r)
{
if (l == r)
{
V[++V[0]] = X[l], V[++V[0]] = S;
return;
}
if (S < X[l])
{
V[++V[0]] = X[r], solve(l, r - 1);
return;
}
if (S > X[r])
{
V[++V[0]] = X[l], solve(l + 1, r);
return;
}
if (P[l] >= P[r])
V[++V[0]] = X[r], P[l] += P[r], solve(l, r - 1);
else
V[++V[0]] = X[l], P[r] += P[l], solve(l + 1, r);
}
constexpr int Abs(int x)
{
return x >= 0 ? x : -x;
}
int main()
{
gi(N), gi(S);
for (int i = 1;i <= N;++i)
gi(X[i]), gi(P[i]);
solve(1, N);
for (int i = V[0] - 1;i >= 1;--i)
Ans += Abs(V[i + 1] - V[i]);
print(Ans);
return 0;
} | #include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=1e5+2;
int ar[N],num[N];
signed main(){
ios::sync_with_stdio(0);
cin.tie(0);
int n,i,j,k,l,r,s,ans=0,lst=-1;
cin>>n>>s;
for(i=1;i<=n;i++){
cin>>ar[i]>>num[i];
}
l=1;
r=n;
while(true){
if(ar[r]<s){
ans+=s-ar[l];
break;
}
if(ar[l]>s){
ans+=ar[r]-s;
break;
}
if(num[l]>=num[r]){
num[l]+=num[r];
if(lst!=l){
ans+=ar[r]-ar[l];
}
r--;
lst=l;
}
else{
num[r]+=num[l];
if(lst!=r){
ans+=ar[r]-ar[l];
}
l++;
lst=r;
}
}
cout<<ans;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int MOD = 1e9+7;
string s;
ll d, n;
ll dp[10005][101][2]; // k = 0, cannot cross limit, k = 1 can
ll solve(ll i, ll sum, ll k){
if(i == n) return sum == 0;
if(dp[i][sum][k] == -1) {
ll dig = s[i] - '0';
if(k) dig = 9;
ll res = 0;
for(int j = 0; j <= dig; j++){
res += solve(i+1, (sum + j)%d, (k == 1 || (k == 0 && j < dig ) ? 1 : 0) );
res %= MOD;
}
dp[i][sum][k] = res;
}
return dp[i][sum][k];
}
int main(){
cin >> s >> d;
n = s.size();
memset(dp, -1, sizeof(dp));
cout << (solve(0, 0, 0) - 1 + MOD)%MOD;
}
| #include <bits/stdc++.h>
using namespace std;
#pragma region
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << (#x) << "] = [", _print(x)
#else
#define debug(x...)
#endif
#pragma endregion
typedef long long ll;
#define forn(i, n) for (int i = 0; i < int(n); ++i)
#define sz(v) int((v).size())
#define int ll
#define f first
#define s second
#define mp make_pair
#define mt make_tuple
#define pb push_back
int MOD = 998244353;
int fact[222'222];
int power(int a, int n)
{
int res = 1;
int now = a;
while(n)
{
if (n&1)
{
res = (res*now) %MOD;
}
n>>=1;
now = (now*now)%MOD;
}
return res;
}
int inv(int a)
{
return power(a, MOD-2);
}
int C(int n, int r)
{
if (n < r) return 0;
return fact[n] %MOD * inv(fact[n-r])%MOD * inv(fact[r])%MOD;
}
int n, m, k;
int f(int p)
{
return m * power(m-1, n-1-p)%MOD*C(n-1,p)%MOD;
}
void solve()
{
fact[0] = 1;
forn(i, 222'222-1) fact[i+1] = fact[i] * (i+1)%MOD;
cin>>n>>m>>k;
int ans = 0;
forn(i, k+1)
{
ans =(ans + f(i))%MOD;
}
cout << ans <<'\n';
}
signed main()
{
int T = 1;
ios_base::sync_with_stdio(0); cin.tie(0);
//cin >> T;
for(int i=1;i<=T;++i)
{
//cout << "Case #" << i << ": ";
solve();
}
return 0;
} | 0 |
/*
* RD
*/
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#ifndef rd
#define endl '\n'
#endif
#define deb cout<<"Line: "<<__LINE__<<" plz "
#define pb push_back
#define fi first
#define se second
#define int long long
typedef long long ll;
#define pii pair<int,int>
#define sz(x) ((int)x.size())
#define fr(a,b,c) for(int a=b; a<=c; a++)
#define all(con) con.begin(),con.end()
const ll inf=1e18;
const int mod=1000000007;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
//12367769,266916112,123798211
ll powm(ll a, ll b, ll m);
int n,d;
pii segtree1[400005];
pii segtree2[400005];
pii query1(int l, int r)
{
r++;
pii res={inf+1,inf};
for(l+=n+1,r+=n+1; l<r; l>>=1,r>>=1)
{
if(l&1) res=min(res,segtree1[l++]);
if(r&1) res=min(res,segtree1[--r]);
}
return res;
}
pii query2(int l, int r)
{
r++;
pii res={inf+1,inf};
for(l+=n+1,r+=n+1; l<r; l>>=1,r>>=1)
{
if(l&1) res=min(res,segtree2[l++]);
if(r&1) res=min(res,segtree2[--r]);
}
return res;
}
int a[200005];
int solve(int l, int r, int l1, int r1)
{
if(l+1==r)
return 0;
pii lef=query1(l+1,r-1);
pii rig=query2(l+1,r-1);
// deb<<l<<" "<<r<<endl;
// deb<<lef.fi<<" "<<lef.se<<" "<<rig.fi<<" "<<rig.se<<endl;
ll ans=0;
if(lef.fi+a[l1]-l1*d>rig.fi+a[r1]+r1*d)
{
ans+=rig.fi+a[r1]+r1*d;
lef=rig;
}
else
ans+=lef.fi+a[l1]-l1*d;
if(a[lef.se]+lef.se*d<a[r1]+r1*d)
ans+=solve(l,lef.se,l1,lef.se);
else
ans+=solve(l,lef.se,l1,r1);
if(a[lef.se]-lef.se*d<a[l1]-l1*d)
ans+=solve(lef.se,r,lef.se,r1);
else
ans+=solve(lef.se,r,l1,r1);
return ans;
}
void solve()
{
cin>>n>>d;
for(int i=0; i<n; i++)
cin>>a[i];
a[n]=inf;
for(int i=n+1; i<2*n+2; i++)
{
segtree1[i]={a[i-n-1]+(i-n-1)*d,i-n-1};
segtree2[i]={a[i-n-1]-((i-n-1)*d),i-n-1};
}
for(int i=n; i>0; i--) {
segtree1[i]=min(segtree1[i<<1],segtree1[i<<1|1]);
segtree2[i]=min(segtree2[i<<1],segtree2[i<<1|1]);
}
cout<<solve(0,n,0,n)<<endl;
}
signed main()
{
ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
srand(chrono::steady_clock::now().time_since_epoch().count());
auto clk=clock();
int t=1;
// cin>>t;
while(t--)
solve();
#ifdef rd
cout<<endl<<endl<<(double)(clock()-clk)/CLOCKS_PER_SEC<<endl;
#endif
return 0;
}
ll powm(ll a,ll b, ll m) {
ll te=1;
while(b) {
if(b&1) te=(te*a)%m;
a=(a*a)%m;
b>>=1;
}
return te;
}
| #include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<ctime>
#include<map>
#include<bitset>
#include<set>
#define LL long long
#define mp(x,y) make_pair(x,y)
#define pll pair<long long,long long>
#define pii pair<int,int>
#define lc now<<1
#define rc now<<1|1
using namespace std;
inline int read()
{
int f=1,x=0;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
int stack[20];
inline void write(LL x)
{
if(x<0){putchar('-');x=-x;}
if(!x){putchar('0');return;}
int top=0;
while(x)stack[++top]=x%10,x/=10;
while(top)putchar(stack[top--]+'0');
}
inline void pr1(int x){write(x);putchar(' ');}
inline void pr2(LL x){write(x);putchar('\n');}
const LL inf=1e18;
const int MAXN=200005;
int n,D,a[MAXN];
struct node
{
int p;LL c;
node(){}
node(int _p,LL _c){p=_p;c=_c;}
};
node _min(node u1,node u2){return u1.c<u2.c?u1:u2;}
struct segtree1
{
node mn[2][MAXN*4];
void buildtree(int now,int l,int r)
{
if(l==r){mn[0][now]=mn[1][now]=node(l,inf);return ;}
int mid=(l+r)/2;
buildtree(lc,l,mid);buildtree(rc,mid+1,r);
mn[0][now]=mn[1][now]=_min(mn[0][lc],mn[1][rc]);
}
void modify(int now,int l,int r,int p,node c,int opt)
{
if(l==r){mn[opt][now]=c;return ;}
int mid=(l+r)/2;
if(p<=mid)modify(lc,l,mid,p,c,opt);
else modify(rc,mid+1,r,p,c,opt);
mn[opt][now]=_min(mn[opt][lc],mn[opt][rc]);
}
node qry(int now,int l,int r,int ql,int qr,int opt)//0 左边 1 右边
{
if(l==ql&&r==qr)return mn[opt][now];
int mid=(l+r)/2;
if(qr<=mid)return qry(lc,l,mid,ql,qr,opt);
else if(mid+1<=ql)return qry(rc,mid+1,r,ql,qr,opt);
else return _min(qry(lc,l,mid,ql,mid,opt),qry(rc,mid+1,r,mid+1,qr,opt));
}
}seg1,seg2;//1 未加入 2 加入
struct segtree2
{
node mn[MAXN*4];
void buildtree(int now,int l,int r)
{
if(l==r){mn[now]=node(l,inf);return ;}
int mid=(l+r)/2;
buildtree(lc,l,mid);buildtree(rc,mid+1,r);
mn[now]=_min(mn[lc],mn[rc]);
}
void pushup(int now,int l,int r)
{
int mid=(l+r)/2;
mn[now]=_min(mn[lc],mn[rc]);
node u1=seg1.mn[0][lc],u2=seg2.mn[1][rc];
// u1=seg1.qry(1,1,n,l,mid,0),u2=seg2.qry(1,1,n,mid+1,r,1);
mn[now]=_min(mn[now],node(u1.p,u1.c+u2.c));
u1=seg1.mn[1][rc],u2=seg2.mn[0][lc];
// u1=seg1.qry(1,1,n,mid+1,r,1),u2=seg2.qry(1,1,n,l,mid,0);
mn[now]=_min(mn[now],node(u1.p,u1.c+u2.c));
}
void modify(int now,int l,int r,int p)
{
if(l==r){mn[now].c=inf;return ;}
int mid=(l+r)/2;
if(p<=mid)modify(lc,l,mid,p);
else modify(rc,mid+1,r,p);
pushup(now,l,r);
}
}seg3;
int main()
{
n=read();D=read();
if(n==1)return puts("0"),0;
for(int i=1;i<=n;i++)a[i]=read();
seg1.buildtree(1,1,n);
seg2.buildtree(1,1,n);
seg3.buildtree(1,1,n);
for(int i=2;i<=n;i++)
{
seg1.modify(1,1,n,i,node(i,(LL)-D*i+a[i]),0);
seg1.modify(1,1,n,i,node(i,(LL)D*i+a[i]),1);
}
seg2.modify(1,1,n,1,node(1,(LL)-D*1+a[1]),0);
seg2.modify(1,1,n,1,node(1,(LL)D*1+a[1]),1);
seg3.modify(1,1,n,1);
LL ans=0;
for(int i=1;i<n;i++)
{
ans+=seg3.mn[1].c;
int u=seg3.mn[1].p;
seg1.modify(1,1,n,u,node(u,inf),0);seg1.modify(1,1,n,u,node(u,inf),1);
seg2.modify(1,1,n,u,node(u,(LL)-D*u+a[u]),0);seg2.modify(1,1,n,u,node(u,(LL)D*u+a[u]),1);
seg3.modify(1,1,n,u);
}
pr2(ans);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int const nax = 1e6 + 10;
char s[nax];
int n;
int dp[nax][2];
int d;
int main () {
scanf("%s", s + 1);
n = strlen(s + 1);
s[0] = '0';
dp[n + 1][1] = 1;
for (int i = n ; i >= 0 ; -- i) {
d = s[i] - '0';
dp[i][0] = min(dp[i + 1][1] + 10 - d, dp[i + 1][0] + d);
dp[i][1] = min(dp[i + 1][0] + d + 1, dp[i + 1][1] + 9 - d);
}
printf("%d\n", dp[0][0]);
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string ns;
getline(cin, ns);
int a = 0, b = 1;
for (auto c : ns) {
int d = c - '0';
int a_ = min(a + d, b + 10 - d);
b = min(a + d + 1, b + 9 - d);
a = a_;
}
cout << a << '\n';
}
| 1 |
#include "bits/stdc++.h"
using namespace std;
int main() {
int N, T;
cin >> N >> T;
vector<int>t(N);
for (int i = 0;i<N;++i) {
cin >> t[i];
}
int ans = 0;
for (int i = 0;i<N-1;++i) {
ans += min(T, t[i + 1] - t[i]);
}
ans += T;
cout << ans << endl;
return 0;
} | // review
#include <iostream>
using namespace std;
int n, m;
void solve() {
int second = m & 1 ? m + 1 : m + 2;
int cnt = 1;
int cnt2 = 0;
for (int i=0;i<m;i++) {
if (i < m / 2) {
cout << cnt << " " << (second - cnt) << endl;
cnt++;
} else {
cout << cnt2 + second << " " << (2 * m + 1 - cnt2) << endl;
cnt2++;
}
}
}
int main() {
cin >> n >> m;
solve();
}
| 0 |
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <vector>
#include <string>
#include <queue>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <bitset>
using namespace std;
typedef long long ll;
int main() {
ll N; cin >> N;
ll* A = new ll[N];
ll m = 0;
ll sum = 0;
for (int i = 0; i < N; i++) {
cin >> A[i];
sum = sum ^ A[i];
m = m | A[i];
}
ll filter = m - sum;
set<ll, greater<ll>> st;
for (int i = 0; i < N; i++) {
ll a = A[i] & filter;
for (auto itr = st.begin(); itr != st.end(); itr++) {
a = min(a, a ^ *itr);
}
if (a != 0) {
st.insert(a);
}
}
ll s = filter;
for (auto itr = st.begin(); itr != st.end(); itr++) {
s = min(s, (s ^ *itr) & filter);
}
cout << sum + (filter - s) * 2 << endl;
return 0;
}
| /*** author: yuji9511 ***/
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using lpair = pair<ll, ll>;
const ll MOD = 1e9+7;
const ll INF = 1e18;
#define rep(i,m,n) for(ll i=(m);i<(n);i++)
#define rrep(i,m,n) for(ll i=(m);i>=(n);i--)
#define printa(x,n) for(ll i=0;i<n;i++){cout<<(x[i])<<" \n"[i==n-1];};
void print() {}
template <class H,class... T>
void print(H&& h, T&&... t){cout<<h<<" \n"[sizeof...(t)==0];print(forward<T>(t)...);}
ll msb(ll v){
v = v | (v >> 1LL);
v = v | (v >> 2LL);
v = v | (v >> 4LL);
v = v | (v >> 8LL);
v = v | (v >> 16LL);
v = v | (v >> 32LL);
return v ^ (v >> 1LL);
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
ll A[100010];
rep(i,0,N) cin >> A[i];
ll ans = 0;
rep(d,0,60){
ll cnt = 0;
rep(i,0,N){
if((A[i]>>d)&1) cnt++;
}
if(cnt % 2 == 1){
ans += (1LL<<d);
rep(i,0,N){
if((A[i]>>d)&1){
A[i] -= (1LL<<d);
}
}
}
}
vector<ll> V;
rep(i,0,N){
for(auto &v: V) if(msb(v) & A[i]) A[i] ^= v;
if(A[i] > 0){
for(auto &v: V) if(msb(A[i]) & v) v ^= A[i];
V.push_back(A[i]);
sort(V.begin(), V.end(), greater<ll>());
}
}
ll res = 0;
for(auto &v: V) res ^= v;
ans += res * 2;
print(ans);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN=300100,MOD=1e9+7;
const int automata[8][2]={{3,1},{5,2},{2,2},{4,7},{3,3},{6,1},{5,5},{3,1}};
char ch[MAXN];
int dp[MAXN][8],len;
int main()
{
ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
cin>>ch;
len=strlen(ch);
dp[len][1]=dp[len][2]=1;
for(register int i=len-1;~i;i--)
for(register int j=0;j<8;j++)
{
if(ch[i]!='0') dp[i][j]=(dp[i][j]+dp[i+1][automata[j][1]])%MOD;
if(ch[i]!='1') dp[i][j]=(dp[i][j]+dp[i+1][automata[j][0]])%MOD;
}
cout<<dp[0][0]<<endl;
return 0;
} | #include <cstdio>
#include <cstring>
using namespace std;
char s[300001];
long long b[300001];
int c[300001];
long long dp[2][3];
bool can(int x, int c) {
return (s[x] == '?') || (s[x] == '0' + c);
}
int main() {
int n, m = 1000000007, i, j, k, l;
long long ans = 0;
scanf("%s", s);
n = strlen(s);
b[0] = 1;
for (i = 1; i <= n; i++) b[i] = b[i - 1] * 2 % m;
for (i = n - 1; i >= 0; i--) {
c[i] = c[i + 1];
if (s[i] == '?') c[i]++;
}
for (i = 0; i < 2; i++) {
if (can(0, i)) dp[0][i]++;
}
for (i = 1; i < n; i += 2) {
for (j = 0; j < 2; j++) {
for (k = 0; k < 2; k++) {
if (!can(i, j) || !can(i + 1, k)) continue;
for (l = 0; l < 3; l++) {
long long x = dp[0][l];
if (x == 0) continue;
if (l == 0) {
if (j == 1 && k == 1) {
dp[1][1] += x;
if (dp[1][1] >= m) dp[1][1] -= m;
} else {
dp[1][0] += x;
if (dp[1][0] >= m) dp[1][0] -= m;
}
} else if (l == 1) {
if (j == 1) {
ans += x * b[c[i + 2]] % m;
if (ans >= m) ans -= m;
} else if (j == 0 && k == 0) {
dp[1][2] += x;
if (dp[1][2] >= m) dp[1][2] -= m;
} else {
dp[1][1] += x;
if (dp[1][1] >= m) dp[1][1] -= m;
}
} else {
if (k == 0) {
dp[1][2] += x;
if (dp[1][2] >= m) dp[1][2] -= m;
} else {
dp[1][1] += x;
if (dp[1][1] >= m) dp[1][1] -= m;
}
}
}
}
}
for (j = 0; j < 3; j++) {
dp[0][j] = dp[1][j];
dp[1][j] = 0;
}
}
printf("%lld\n", (ans + dp[0][1]) % m);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
int n;
ll t;
cin >> n >> t;
vector<ll> a(n);
ll ans = 0;
ll lim = a[0] + t;
for(int i=0;i<n;i++) cin >> a[i];
for(int i=0;i<n;i++){
if(i == 0) {
ans = t;
continue;
}
if(lim > a[i]){
ll ext = (a[i]+t-lim);
if(ext < 0) continue;
lim = a[i]+t;
ans += ext;
}else{
lim = a[i] + t;
ans += t;
}
}
cout << ans << endl;
} | #include<iostream>
#include<algorithm>
using namespace std;
int main (void)
{
int a,b,ans;
cin>>a>>b;
ans=0;
ans=ans+max(a,b);
ans+=max(max(a-1,b-1),min(a,b));
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll MOD = 1000000007;
bool check(int a,int b,int c)
{
if((a+b)>c && (c+b)>a && (a+c)>b)
return true;
return false;
}
int main()
{
// freopen("input01.txt", "r", stdin);
// freopen("output01.txt", "w", stdout);
int n;
cin>>n;
map<ll int,int> mp;
ll int a;
int l,ct=0;
for(l=0;l<n;l++)
{
cin>>a;
mp[a]++;
}
if(mp.size()<3)
{
cout<<0;
return 0;
}
for(auto i=mp.begin();next(next(i))!=mp.end();i++)
{
for(auto j=next(i);next(j)!=mp.end();j++)
{
for(auto k=next(j);k!=mp.end();k++)
{
if(check(i->first,j->first,k->first))
ct+=(i->second*j->second*k->second);
}
}
}
cout<<ct;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
struct fast_ios { fast_ios(){ cin.tie(0); ios::sync_with_stdio(false); cout << fixed << setprecision(20); }; } fast_ios_;
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define IFOR(i, begin, end) for(int i=(end)-1,i##_begin_=(begin);i>=i##_begin_;i--)
#define REP(i, n) FOR(i,0,n)
#define IREP(i, n) IFOR(i,0,n)
template<typename T> istream &operator>>(istream &is, vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec){ os << "["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &pa){ os << "(" << pa.first << "," << pa.second << ")"; return os; }
#define dbg(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ") " << __FILE__ << endl;
void Yes()
{
puts("Yes");
exit(0);
}
void No()
{
puts("No");
exit(0);
}
// 1-indexed BIT (i : [1, len])
template<typename T>
struct BIT : std::vector<T>
{
BIT(int len = 0) : std::vector<T>(len + 1) {}
void reset() { fill(this->begin(), this->end(), 0); }
void add(int pos, T v) {
while (pos > 0 and pos < (int)this->size()) (*this)[pos] += v, pos += pos & -pos;
}
T sum(int pos) const { // (0, pos]
T res = 0;
while (pos > 0) res += (*this)[pos], pos -= pos & -pos;
return res;
}
friend std::ostream &operator<<(std::ostream &os, const BIT &bit) {
T prv = 0;
os << '[';
for (int i = 1; i < (int)bit.size(); i++) {
T now = bit.sum(i);
os << now - prv << ",";
prv = now;
}
os << ']';
return os;
}
};
vector<int> parity(vector<int> V)
{
int N = 1e5;
BIT<int> bit(N);
vector<int> ret(V.size() * 2 - 1);
lint ten = 0;
REP(i, V.size()) {
int dest = (V[i] - 1);
ret[dest * 2] += abs(dest - i);
// if (i) {
// // int nb_empty = i - bit.sum(i);
// // ret[i * 2 - 1] += nb_empty;
// }
ten += bit.sum(N) - bit.sum(V[i]);
bit.add(V[i], 1);
}
ret[1] += ten % 2;
// dbg(V);
// dbg(ret);
return ret;
}
int main()
{
int N;
cin >> N;
vector<vector<int>> A(3, vector<int>(N));
cin >> A;
vector<vector<int>> val(2);
vector<int> inv;
REP(i, N) {
REP(d, 2) if (abs(A[d][i] - A[d + 1][i]) != 1) No();
int invtmp = 0;
if (A[0][i] > A[2][i]) invtmp = 1;
int tmp = min(A[0][i], A[2][i]) / 3;
if (abs(tmp - i) % 2) No();
val[i % 2].emplace_back(tmp / 2 + 1), inv.emplace_back(invtmp);
}
// dbg(val);
vector<int> v1 = parity(val[0]);
vector<int> v2 = parity(val[1]);
REP(i, v1.size()) inv.at(i) ^= v1.at(i) % 2;
REP(i, v2.size()) inv.at(i + 1) ^= v2.at(i) % 2;
// dbg(inv);
vector<int> cou(4);
REP(i, N) cou[i % 4] ^= inv[i];
// dbg(cou);
int tot = accumulate(cou.begin(), cou.end(), 0);
if (tot % 4 == 0) Yes();
if (tot % 2) No();
if (tot % 4 == 0 or (cou[0] ^ cou[2]) == 0) Yes();
No();
}
| 0 |
#include <cstdio>
#include <iostream>
#include <cmath>
#include <ctype.h>
#include <cstring>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <map>
#include <queue>
using namespace std;
int main()
{
int n;
while(1){
cin >> n;
if(n == 0) break;
int key[200];
char s[200], right_s[200], ch;
for(int i = 0; i < n; i++){
cin >> key[i];
}
ch = getchar();
fgets(s, sizeof(s), stdin);
int wronglist[200]={0}, rightlist[200];
for(int i = 0; i < strlen(s)-1; i++){
wronglist[i] = s[i] - 'A';
if(wronglist[i] > 25) wronglist[i] -= 6;
rightlist[i] = wronglist[i] - key[i%n];
if(rightlist[i] < 0) rightlist[i] = 52 + rightlist[i];
if(rightlist[i] > 25) rightlist[i] += 6;
right_s[i] = rightlist[i] + 'A';
}
right_s[strlen(s)-1] = '\0';
cout << right_s << endl;
}
return 0;
} | //include
//------------------------------------------
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <climits>
#include <queue>
using namespace std;
//typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
//container util
//------------------------------------------
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
//repetition
//------------------------------------------
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
//constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
void sub(char& ch, int d){
REP(i,d)
if(ch == 'a')
ch = 'Z';
else if(ch == 'A')
ch = 'z';
else
--ch;
}
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
int N;
while(cin>>N, N){
VI key(N);
REP(i,N) cin >> key[i];
string str; cin >> str;
REP(i,SZ(str)){
sub(str[i], key[i%N]);
}
cout << str << endl;
}
return 0;
} | 1 |
#include<iostream>
#include<string>
#include<string.h>
#include<algorithm>
#include<stdio.h>
#include<cmath>
#include<vector>
#include<utility>
#include<stack>
#include<queue>
#define FOR(i, a, b) for(int i=(a);i<=(b);i++)
#define RFOR(i, a, b) for(int i=(a);i>=(b);i--)
#define MOD 1000000007
using namespace std;
int main(void) {
int total = 0;
int n;
int t;
while (cin >> n) {
total = 0;
t = 600 - n;
while (t>0) {
total += t*t*n;
t -= n;
}
cout << total << endl;
}
return 0;
} | #include <iostream>
#include <iomanip>
using namespace std;
#define REP(i,k,n) for(int i=k;i<n;i++)
#define rep(i,j) for(int i=0;i<j;i++)
bool has3(int p){
while(p){
if(p % 10 == 3) return true;
p /= 10;
}
return false;
}
void call(int n){
REP(i,1,n + 1){
if(i % 3 == 0 || has3(i))
cout << " " << i;
}
}
int main(void){
int a;
cin >> a;
call(a);
cout << endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n); for(int i = 0;i < (int)(n);i++)
#define all(x) (x).begin(),(x).end()
typedef long long ll;
int main(){
int n;
cin >> n;
string s,t;
cin >> s >> t;
int ans = 2*n;
for(int i = 1;i <= n;i++){
string sx = s.substr(n-i,i);
string tx = t.substr(0,i);
if(sx == tx)ans = 2*n - i;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define REP(i,s,n) for(int i=s;i<n;i++)
#define MOD 1000000007
#define NUM 2520
#define INF (1LL<<50)
#define DEBUG 0
#define mp(a,b) make_pair(a,b)
#define SORT(V) sort(V.begin(),V.end())
#define PI (3.141592653589794)
bool isJudge(lli bit){
REP(i,0,10){
if( (bit&(1LL<<i)) && ( bit& (1LL<< (i+1) ) ) )return false;
}
return true;
}
lli dp[120][10];
void func(long long H, long long W, long long K){
dp[0][0]=1;
REP(i,0,H){
for(lli bit=0;bit<(1LL<<W);bit++){
if(!isJudge(bit))continue;
if((bit&(1LL<<(W-1))))continue;
REP(j,0,W){
if((bit&(1LL<<j))){
dp[i+1][j+1] += dp[i][j];
dp[i+1][j+1] %= MOD;
dp[i+1][j] += dp[i][j+1];
dp[i+1][j] %= MOD;
j++;
}
else{
dp[i+1][j] += dp[i][j];
dp[i+1][j] %= MOD;
}
}
}
}
cout<<dp[H][K-1]%MOD<<endl;
}
int main(){
// cout << fixed << setprecision(5);
long long H;
scanf("%lld",&H);
long long W;
scanf("%lld",&W);
long long K;
scanf("%lld",&K);
func(H, W, K);
return 0;
}
| 0 |
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
const int need[10] = {0, 2,5,5,4,5,6,3,7,6};
const int N = 10005;
string dp[N];
void chmax (string& s, string t) {
if ((int) s.size() < (int) t.size()) s = t;
else if ((int) s.size() < (int) t.size()) return;
for (int i = 0; i < (int) s.size(); i++) {
if (s[i] != t[i]) {
if (t[i] > s[i]) {
s = t;
return;
} else {
return;
}
}
}
}
signed main() {
ios::sync_with_stdio(false); cin.tie(0);
//string test = "74";
//chmax(test, "47");
int n, m;
cin >> n >> m;
vector<int> a(m);
for (int i = 0; i < m; i++) cin >> a[i];
dp[0] = "";
for (int i = 0; i <= n; i++) {
for (int j = 0; j < m; j++) {
if (i + need[a[j]] <= n && (i == 0 || dp[i] != "")) {
chmax(dp[i + need[a[j]]], dp[i] + (char) (a[j] + '0'));
}
}
}
cout << dp[n] << 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;
constexpr ll mod=1000000007;
constexpr int inf=1000000000;
constexpr ll linf=1000000000000000000;
ll modpow(ll x,ll n){
ll res=1;
while(n>0){
if(n&1)res=res*x%mod;
x=x*x%mod;
n>>=1;
}
return res;
}
ll dp[201][100001];
int main(){
int n,x;
cin>>n>>x;
ll s[n];
rep(i,n)cin>>s[i];
sort(s,s+n,greater<ll>());
dp[0][x]=1;
for(int i=0;i<n;++i){
ll p=modpow(n-i,mod-2);
for(int j=0;j<=x;++j){
dp[i+1][j%s[i]]=(dp[i+1][j%s[i]]+dp[i][j]*p)%mod;
dp[i+1][j]=(dp[i+1][j]+dp[i][j]*(mod+1-p))%mod;
}
}
ll ans=0;
for(int i=0;i<=x;++i){
ans=(ans+i*dp[n][i])%mod;
}
rep(i,n){
ans=(ans*(i+1))%mod;
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int,int>;
using pll = pair<long long, long long>;
const long long INF = 1<<29;
const int MOD = 1000000007;
long long ruizyou(long long m,long long n){
if(m == 0)return 0;
if(m == 1)return 1;
long long ans = 1;
long long tmp = m;
for(int i=0;i<=30;i++){
if(n & (1<<i)){
ans *= tmp;
ans %= MOD;
}
tmp *= tmp;
tmp %= MOD;
}
return ans;
}
long long kaizyou(long long x){
if(x == 0)return 1;
return x * kaizyou(x-1) % MOD;
}
long long comb(long long x,long long y){
long long bunsi = kaizyou(x);
long long bunbo = kaizyou(x-y) * kaizyou(y) % MOD;
return bunsi * ruizyou((int)bunbo,MOD-2) % MOD;
}
struct unionfind{
vector<int> par;
vector<int> hukasa;
unionfind(int n){
par = vector<int>(n);
hukasa = vector<int>(n,0);
for(int i=0;i<n;i++){
par.at(i) = i;
}
}
int root(int x){
if(par.at(x) == x)return x;
return root(par.at(x));
}
void unite(int x,int y){
int rx = root(x);
int ry = root(y);
if(rx == ry)return;
if(hukasa.at(rx) >= hukasa.at(ry)){
par.at(ry) = rx;
hukasa.at(rx) = max(hukasa.at(ry) + 1,hukasa.at(rx));
}
else{
par.at(rx) = ry;
}
}
bool same(int x,int y){
return root(x) == root(y);
}
};
int ctoi(char a){
return a - '0';
}
long long gcd(long long a,long long b){
long long c = max(a,b);
long long d = min(a,b);
if(d % c == 0)return c;
return gcd(c,d%c);
}
long long lcm(long long a,long long b){
return a * b / gcd(a,b);
}
int main(){
int n;
cin >> n;
vector<int> a(n);
for(int i=0;i<n;i++)cin >> a.at(i);
vector<int> dp(3,0);
int count2 = 0,count3 = 0;
bool flag = false;
for(int i=0;i<n;i++){
int m = 3;
int count = 0;
for(int j=0;j<3;j++){
if(dp.at(j) == a.at(i)){
m = min(m,j);
count++;
}
}
if(m == 3){
flag = true;
break;
}
dp.at(m)++;
if(count == 2)count2++;
if(count == 3)count3++;
}
if(flag)cout << 0 << endl;
else{
long long ans = 1;
ans *= ruizyou(2,count2);
ans *= ruizyou(3,count3);
cout << ans % MOD << endl;
}
} | #include <iostream>
#include <iomanip>
#include<math.h>
#include<list>
#include <algorithm>
#include<set>
#include<vector>
#include<math.h>
#include<map>
#include<string>
#include <numeric>
#include <queue>
#include <sstream>
#include <bitset>
#include<stack>
using namespace std;
using ll = long long;
using vll = vector<long long>;
using sll = set<long long>;
template<typename T>
T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template<typename T>
T lcm(T a, T b) { return a / gcd(a, b) * b; }
template<typename T>
map<T, T> getPrimeFactor(T n) {
map<T, T> res;
for (T i = 2; i * i <= n; ++i) {
while (n % i == 0) {
res[i] ++;
n /= i;
}
}
if (n != 1) res[n] = 1;
return res;
}
template<typename T>
bool IsPrimeNumber(T num)
{
if (num <= 2) return true;
else if (num % 2 == 0) return false;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2)
{
if (num % i == 0)
{
return false;
}
}
return true;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
// 繰り返し二乗法
ll pow2(ll n, ll p, ll mod) {
if (p == 0 || n == 1) {
return 1;
}
else {
ll ret = pow2(n * n % mod, p / 2, mod);
if (p % 2 == 1) {
ret *= n;
}
return ret % mod;
}
}
#define rep(i,s,e) for(ll i=s;i<e;i++)
#define repeq(i,s,e) for(ll i=s;i<=e;i++)
int main() {
const ll mod = 1e9 + 7;
ll N;
std::cin >> N;
ll ans = 1;
vll c(N+1, 0);
c[0] = 3;
rep(i, 0, N) {
ll A;
std::cin >> A;
ans *= c[A];
ans %= mod;
c[A]--;
c[A + 1]++;
}
std::cout << ans << endl;
return 0;
}
| 1 |
const long long MOD = 1e9 + 7;
const int N = 203010;
#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <algorithm>
#include <cmath>
#include <time.h>
#include <unordered_set>
#include <bitset>
#include <deque>
using namespace std;
#define int long long
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<ll> 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 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 // LOCAL
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
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(N);
__ufact.resize(N);
__rev.resize(N);
__rev[1] = 1;
for (int i = 2; i < N; i++) __rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = 1; i < N; 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 n, m, v, p;
int a[N];
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> v >> p;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int L = -1, R = n - p;
while (L + 1 < R)
{
int M = (L + R) / 2;
int le = M;
int ri = p - 1;
int t = 0;
dbg(M);
dbg(le + ri + 1);
{
int V = v - (le + ri + 1);
int WE = a[M] + m;
vector<int> maxvote;
for (int i = M + 1; i <= n - p; i++)
{
maxvote.push_back(WE - a[i]);
}
if (maxvote.back() < 0)
{
t = 0;
}
else
{
ll si = 0;
for (int i = 0; i < maxvote.size(); i++) si += maxvote[i];
if (si >= V * m) t = 1;
}
}
if (t) R = M;
else L = M;
}
cout << n - R;
}
/* Note:
Check constants at the beginning of the code.
N is set to 4e5 but be careful in problems with large constant factor.
Setting N in every problem is more effective.
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
| #include <cstring>
#include <algorithm>
#include <cstdio>
#define int long long
#define ri register int
#define N 100005
using namespace std;
int n,m,v,p,t=0,ans,a[N]= {0};
template <typename T> inline void read(T &x) {
T c=getchar(),f=0;
for (; c<48||57<c; c=getchar()) if (c=='-') f=1;
for (x=0; 48<=c&&c<=57; c=getchar()) x=(x<<3)+(x<<1)+(c^48);
if (f) x=-x;
}
template <typename T> inline void print(T x) {
if (x<0) x=-x,putchar('-');
if (x>9) print(x/10);
putchar(x%10+48);
}
signed main() {
read(n),read(m),read(v),read(p),ans=p;
for (ri i=1; i<=n; i++) read(a[i]);
sort(a+1,a+1+n),reverse(a+1,a+1+n);
for (ri i=p+1; i<=n; i++) {
if (a[i]+m<a[p]) break;
if (v<=(p-1)+(n-i+1)) ans++;
else if ((v-p-n+i)*m<=t) ans++;
else if (((v-p-n+i)*m-t-1)/(i-p)+1+a[p]<=a[i]+m) ans++;
t+=a[p]-a[i];
}
print(ans),putchar('\n');
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll v[200009];
int main() {
// #ifndef ONLINE_JUDGE
// // for getting input from input.txt
// freopen("input.txt", "r", stdin);
// // for writing output to output.txt
// freopen("output.txt", "w", stdout);
// #endif
ll n,t,ans =0;
cin>>n>>t;
// ans = t;
// vector<ll> v(n,0);
for (ll i = 1; i <=n; ++i)
{
cin>>v[i];
}
for (ll i = 1; i <= n-1; ++i)
{
if(v[i+1] - v[i] <= t){
ans = ans + (v[i+1]-v[i]);
}
else{
ans = ans + t;
}
}
cout<<ans+t<<"\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
int ret = 0;
for (int i = A; i <= B; i++) {
int s1, s2, s4, s5;
s1 = i / 10000;
s5 = i % 10;
if (s1 != s5) {
continue;
}
s2 = (i / 1000) % 10;
s4 = (i / 10) % 10;
if (s2 == s4)
ret++;
}
cout << ret << endl;
}
| 0 |
#include <bits/stdc++.h>
#define MAX 60
#define browse for (int i = 0; i < MAX; ++i) for (int j = 0; j < MAX; ++j) for (int ii = 0; ii < MAX; ++ii) for (int jj = 0; jj < MAX; ++jj)
using namespace std;
int n, cnt[MAX][MAX], a, b;
long long y, ans;
long double x;
int main() {
cin >> n;
while (n--) {
cin >> x;
y = (long long)(x * 1e9 + 0.5);
a = 0;
b = 0;
while (y % 2 == 0) {
y /= 2;
++a;
}
while (y % 5 == 0) {
y /= 5;
++b;
}
++cnt[a][b];
}
browse
if (make_pair(i, j) <= make_pair(ii, jj) && i + ii >= 18 && j + jj >= 18) {
if (i == ii && j == jj)
ans += (long long) cnt[i][j] * (cnt[i][j] - 1) / 2;
else
ans += (long long) cnt[i][j] * cnt[ii][jj];
}
cout << ans;
return 0;
} | // https://atcoder.jp/contests/abc134/tasks/abc134_d
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define REP(i, n) FOR(i, 0, n)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, s, n) for (int i = (s), i##_len = (n); i < i##_len; ++i)
#define ALL(obj) (obj).begin(), (obj).end()
#define ALLR(obj) (obj).rbegin(), (obj).rend()
#define DIV(a, b) ((a - 1) / b + 1)
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
bitset<200001> bs;
FOR(i, 1, N + 1) {
int t;
cin >> t;
if (t) {
bs.set(i);
}
}
bitset<200001> ans;
int cnt = 0;
for (int i = N; i >= 1; i--) {
int sum = 0;
for (int j = i * 2; j <= N; j += i) {
sum += ans[j];
}
if (sum % 2 != bs[i]) {
ans.set(i);
cnt++;
}
}
cout << cnt << "\n";
for (int i = 1; i <= N; i++) {
if (ans[i]) {
cout << i << (--cnt ? " " : "\n");
}
}
return 0;
}
| 0 |
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <functional>
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int,int> PII;
typedef long long ll;
typedef unsigned long long ull;
#define REP( i, m, n ) for ( int i = (int)( m ); i < (int)( n ); i++ )
#define UREP( i, m, n ) for ( unsigned int i = (unsigned int)( m ); i < (unsigned int)( n ); i++ )
#define ITER( c ) __typeof( (c).begin() )
#define IREP( c, it ) for ( ITER(c) it = c.begin(); it != c.end(); ++it )
#define ALL( c ) (c).begin(), (c).end()
#define RALL( c ) (c).rbegin(), (c).rend()
#define PB( n ) push_back( n )
#define MP( a, b ) make_pair( ( a ), ( b ) )
#define EXIST( c, e ) ( (c).find( e ) != (c).end() )
#define fst first
#define snd second
#define DUMP( x ) cerr << #x << " = " << ( x ) << endl
#define DEBUG( x ) cerr << __FILE__ << ":" << __LINE__ << ": " << #x << " = " << ( x ) << endl
int main()
{
string buffer;
while ( getline( cin, buffer ) )
{
UREP( i, 0, buffer.length() )
{
if ( buffer[i] == ',' )
{
buffer[i] = ' ';
}
}
vector<int> l;
l.PB( 0 );
istringstream iss( buffer );
REP( i, 0, 10 )
{
int input;
iss >> input;
l.PB( l.back() + input );
}
int v1, v2, res;
iss >> v1 >> v2;
UREP( i, 0, 11 )
{
if ( l[i] / (double)v1 < ( l.back() - l[i] ) / (double)v2 )
{
res = i;
}
else
{
res++;
break;
}
}
cout << res << endl;
}
return 0;
} | #include<iostream>
#include<vector>
#include<string>
#include<sstream>
using namespace std;
vector<string> split(const string &s, char delimiter)
{
vector<string> ret;
size_t now = 0, find;
while ((find = s.find_first_of(delimiter, now)) != string::npos)
{
ret.push_back(string(s, now, find - now));
now = find + 1;
}
ret.push_back(string(s, now, s.size() - now));
return ret;
}
int main()
{
string in;
while (cin >> in)
{
vector<string> v = split(in, ',');
int disSum = 0;
int dis[10];
int sp[2];
for (int i = 0; i < v.size(); i++)
{
stringstream ss;
ss << v[i];
if (i < 10)
{
ss >> dis[i];
disSum += dis[i];
}
else
{
ss >> sp[i - 10];
}
}
double a = disSum * sp[0] / (sp[0] + sp[1]);
double b = disSum * sp[1] / (sp[0] + sp[1]);
double fromStart = 0.0;
double fromEnd = 0.0;
int i = 0, j = 0;
for (i = 0; i < 10; i++)
{
if (fromStart >= a)
{
break;
}
fromStart += dis[i];
}
for (j = 9; j >= 0; j--)
{
if (fromEnd >= b)
{
break;
}
fromEnd += dis[j];
}
/*cout << i << " " << j << endl;
cout << a << " " << b << " " << fromStart << " " << fromEnd << endl;*/
if (fromStart == a && fromEnd == b)
{
cout << i << endl;
}
else
{
if (fromStart == fromEnd)i++;
cout << i << endl;
}
}
return 0;
} | 1 |
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
int cnt = 0;
while (1) {
rep(i, n) {
if (a[i] % 2 != 0) {
cout << cnt << endl;
return 0;
}
a[i] *= 0.5;
}
cnt++;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N,A,s,r=999;
cin>>N;
for(int i=0;i<N;i++){
cin>>A;
s=0;
while(A%2==0){
s++;
A/=2;
}
if(s<r)r=s;
}
cout<<r<<endl;
} | 1 |
#include <iostream>
#include <algorithm>
#include <vector>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
using namespace std;
struct Node {
int key;
Node *parent, *left, *right;
};
Node* NIL;
int m;
Node* root;
void init() {
NIL = new Node;
NIL->parent = NIL;
NIL->left = NIL;
NIL->right = NIL;
root = NIL;
}
void insert(int k) {
Node* z = new Node {k, NIL, NIL, NIL};
Node* y = NIL;
Node* x = root;
while (x != NIL) {
y = x;
if (z->key < x->key) x = x->left;
else x = x->right;
}
z->parent = y;
if (y == NIL) root = z;
else if (z->key < y->key) y->left = z;
else y->right = z;
}
void preParse(Node* u) {
if (u == NIL) return;
cout << " " << u->key;
preParse(u->left);
preParse(u->right);
}
void inParse(Node* u) {
if (u == NIL) return;
inParse(u->left);
cout << " " << u->key;
inParse(u->right);
}
Node* find(int k) {
Node* c = root;
while (c != NIL) {
if (c->key == k) return c;
else if (k < c->key) c = c->left;
else c = c->right;
}
return NIL;
}
Node* getMinimum(Node* x) {
while (x->left != NIL) x = x->left;
return x;
}
Node* getSucessor(Node* x) {
if (x->right != NIL) return getMinimum(x->right);
Node* y = x->parent;
while (y != NIL && x == y->right) {
x = y;
y = y->parent;
}
return y;
}
void deleteNode(Node* z) {
Node* y;
if (z->left == NIL | z->right == NIL) y = z;
else y = getSucessor(z);
Node* x;
if (y->left != NIL) x = y->left;
else x = y->right;
if (x != NIL) x->parent = y->parent;
if (y->parent == NIL) {
root = x;
} else if (y == y->parent->left) {
y->parent->left = x;
} else {
y->parent->right = x;
}
if (y != z) z->key = y->key;
}
int main() {
cin >> m;
rep(i, m) {
string com;
cin >> com;
int key;
if (com == "insert") {
cin >> key;
insert(key);
} else if (com == "print") {
inParse(root);
cout << endl;
preParse(root);
cout << endl;
} else if (com == "find") {
cin >> key;
if (find(key) != NIL) cout << "yes" << endl;
else cout << "no" << endl;
} else if (com == "delete") {
cin >> key;
deleteNode(find(key));
} else {
cout << "error" << endl;
}
}
return 0;
}
| #include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
class Dice
{
private:
int surf[6];
public:
void set_surf(int* input);
void roll(char orient);
void disp_top();
};
void Dice::set_surf(int* input)
{
memcpy(surf, input, 6*sizeof(int));
}
void Dice::roll(char orient){
int temp[6];
switch(orient){
case 'S':
temp[0]=surf[4];
temp[1]=surf[0];
temp[2]=surf[2];
temp[3]=surf[3];
temp[4]=surf[5];
temp[5]=surf[1];
break;
case 'N':
temp[0]=surf[1];
temp[1]=surf[5];
temp[2]=surf[2];
temp[3]=surf[3];
temp[4]=surf[0];
temp[5]=surf[4];
break;
case 'W':
temp[0]=surf[2];
temp[1]=surf[1];
temp[2]=surf[5];
temp[3]=surf[0];
temp[4]=surf[4];
temp[5]=surf[3];
break;
case 'E':
temp[0]=surf[3];
temp[1]=surf[1];
temp[2]=surf[0];
temp[3]=surf[5];
temp[4]=surf[4];
temp[5]=surf[2];
break;
}
memcpy(surf, temp, 6*sizeof(int));
}
void Dice::disp_top(){
cout << surf[0] << endl;
}
int main()
{
int input[6];
Dice dice;
string order;
for(int i=0; i<6; i++){
cin >> input[i];
}
dice.set_surf(input);
cin >> order;
for(int i=0; i<order.size(); i++){
dice.roll(order[i]);
}
dice.disp_top();
return(0);
} | 0 |
#include <algorithm>
#include <cmath>
#include <vector>
#include <functional>
#include <cstdlib>
#include <map>
#include <set>
#include <iostream>
#include <string>
#include <ctype.h>
#include <climits>
#include <queue>
using namespace std;
typedef long long ll;
#define REP(i, n) for(ll i = 0; i < (ll)(n); ++i)
template<class T> inline bool chmax(T& a, T b) { if(a < b){ a=b; return 1; } return 0;}
template<class T> inline bool chmin(T& a, T b) { if(a > b){ a=b; return 1; } return 0;}
int main(){
int n;
string s;
cin >> n >> s;
vector<int> w(n+1), e(n+1);
w[0] = 0;
e[0] = 0;
REP(i,n){
w[i+1] = w[i];
e[i+1] = e[i];
if(s[i]=='W') w[i+1]++;
if(s[n-1-i]=='E') e[i+1]++;
}
int ans=1000000;
REP(i,n){
chmin(ans, w[i+1]+e[n-i]-1);
}
cout << ans << endl;
return 0;
} | /*{{{*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<string>
#include<iostream>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include<bitset>
#include<vector>
#include<limits.h>
#include<assert.h>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define CASET int ___T; scanf("%d", &___T); for(int cs=1;cs<=___T;cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL,LL> PLL;
typedef vector<PLL> VPLL;
template<class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(LL &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template<class T, class... U> void R(T &head, U &... tail) { _R(head); R(tail...); }
template<class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const LL &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template<class T,class U> void _W(const pair<T,U> &x) {_W(x.F); putchar(' '); _W(x.S);}
template<class T> void _W(const vector<T> &x) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W(const T &head, const U &... tail) { _W(head); putchar(sizeof...(tail) ? ' ' : '\n'); W(tail...); }
#ifdef HOME
#define DEBUG(...) {printf("# ");printf(__VA_ARGS__);puts("");}
#else
#define DEBUG(...)
#endif
int MOD = 1e9+7;
void ADD(LL& x,LL v){x=(x+v)%MOD;if(x<0)x+=MOD;}
/*}}}*/
const int SIZE = 1e6+10;
int N,X;
LL b[SIZE],l[SIZE],u[SIZE];
bool used[SIZE];
int main(){
R(N,X);
LL need=0;
priority_queue<PLL>h0,h1,h2;
REP(i,N){
R(b[i],l[i],u[i]);
need+=b[i]*l[i];
h0.push({l[i]*b[i]+u[i]*(X-b[i]),i});
}
LL an=0;
while(need>=h0.top().F){
an+=X;
used[h0.top().S]=1;
need-=h0.top().F;
h0.pop();
}
if(need<=0){
W(an);
return 0;
}
int add_id=h0.top().S;
LL add_v=l[add_id]*b[add_id]+u[add_id]*(X-b[add_id]);
LL mi=1e18;
REP(i,N){
if(used[i]){
LL need2=need-add_v+l[i]*b[i]+u[i]*(X-b[i]);
if(l[i]*b[i]>=need2){
mi=min(mi,(need2+l[i]-1)/l[i]);
}
else{
mi=min(mi,(need2-l[i]*b[i]+u[i]-1)/u[i]+b[i]);
}
}
else{
if(l[i]*b[i]+u[i]*(X-b[i])<need)continue;
if(l[i]*b[i]>=need){
mi=min(mi,(need+l[i]-1)/l[i]);
}
else{
mi=min(mi,(need-l[i]*b[i]+u[i]-1)/u[i]+b[i]);
}
}
}
an+=mi;
W(an);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define pb push_back
#define pi pair<int, int>
#define l first
#define r second
#define all(x) x.begin(), x.end()
const int maxn = 5e5 + 1;
using namespace std;
int n;
string s;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
string s; cin >> s;
int n = s.size();
bitset<26> bt;
if (n < 26) {
for (int i = 0; i < n; i++)
bt[s[i] - 'a'] = 1;
cout << s;
for (int x = 0; x < 26; x++)
if (!bt[x]) {
cout << (char)(x + 'a');
break;
}
return 0;
}
for (int i = n - 1; i >= 0; i--) {
bool fg = 0;
for (char j = s[i] + 1; j <= 'z'; j++) {
fg = 1;
for (int l = 0; l < i; l++) {
if (s[l] == j) {
fg = 0;
break;
}
}
if (!fg) continue;
s[i] = j;
cout << s.substr(0, i + 1);
return 0;
}
}
cout << -1;
return 0;
}
| #include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cmath>
#include<bitset>
#include<deque>
#include<functional>
#include<iterator>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<utility>
using namespace std;
typedef long long ll;
#define a first
#define b second
#define sz(x) (ll)((x).size())
#define pb push_back
#define mp make_pair
#define bg begin()
#define ed end()
#define all(x) (x).bg,(x).ed
#define rep(i,n) for(ll i=0;i<(n);i++)
#define rep1(i,n) for(ll i=1;i<=(n);i++)
#define rrep(i,n) for(ll i=(n)-1;i>=0;i--)
#define rrep1(i,n) for(ll i=(n);i>=1;i--)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
const ll MOD=1000000007;
const ll INF=1000000000000000;
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 maxx(ll x,ll y,ll z){return max(max(x,y),z);}
ll minn(ll x,ll y,ll z){return min(min(x,y),z);}
ll gcd(ll x,ll y){if(x%y==0) return y;else return gcd(y,x%y);}
ll lcm(ll x,ll y){return x*(y/gcd(x,y));}
ll digsz(ll x){if(x==0) return 1;else{ll ans=0;while(x){x/=10;ans++;}return ans;}}
ll digsum(ll x){ll sum=0;while(x){sum+=x%10;x/=10;}return sum;}
vector<ll> pw2(62,1);vector<ll> pw10(19,1);
int main(){
{rep1(i,61) pw2[i]=2*pw2[i-1];}
{rep1(i,18) pw10[i]=10*pw10[i-1];}
string s; cin>>s;
vector<ll> X(26,0);
rep(i,sz(s)){
X[(ll)(s[i]-'a')]++;
}
string t="";
rrep(i,26){
t+=('a'+i);
}
if(s==t){
cout<<-1<<endl;
return 0;
}
ll tmp=INF;
rep(i,26){
if(X[i]==0){
tmp=i;
break;
}
}
//全文字
if(tmp==INF){
ll c;
vector<ll> Y;
rrep1(i,sz(s)-1){
Y.pb((ll)(s[i]-'a'));
if(s[i]>s[i-1]){
c=i-1;
break;
}
}
sort(all(Y));
rep(i,sz(s)){
if(c==i){
ll d=(ll)(s[i]-'a');
cout<<(char)('a'+*(upper_bound(Y.bg,Y.ed,d)));
return 0;
}
else cout<<s[i];
}
}
else{
cout<<s<<(char)('a'+tmp)<<endl;
}
}
| 1 |
#include <stdio.h>
const int MAX_V = 1000000;
int prime[MAX_V];
int main() {
int i, k, v, n, max = 0;
for(i = 2; i <= MAX_V; i++) {
prime[i] = 1;
}
for(i = 2; i*i <= MAX_V; i++) {
if(prime[i]){
for(k = 2 * i; k <= MAX_V; k += i) {
prime[k] = 0;
}
}
}
while(1){
scanf("%d", &n);
if(n == 0) break;
for(i = n;i > 0;i--){
if(prime[i] == 1 && prime[i - 2] == 1){
max = i;
break;
}
}
printf("%d %d\n", max - 2, max);
}
return 0;
} | #include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <cstring>
#include <string.h>
#include <cmath>
#include <queue>
#include <string>
#include <stack>
#include <utility>
#include <queue>
#include <cmath>
#define mp make_pair
#define pii pair<int,int>
#define ff first
#define ss second
#define ll long long
#define vi vector<int>
using namespace std;
ll _sieve_size;
bitset<10000010> bs;
vi primes;
void sieve(ll upperbound) {
_sieve_size = upperbound + 1;
bs.set();
bs[0] = bs[1] = 0;
for (ll i = 2; i <= _sieve_size; i++) if (bs[i]) {
for (ll j = i * i; j <= _sieve_size; j += i) bs[j] = 0;
primes.push_back((int)i);
} }
bool isPrime(ll N) {
if (N <= _sieve_size) return bs[N];
for (int i = 0; i < (int)primes.size(); i++)
if (N % primes[i] == 0) return false;
return true;
}
int a;
int main()
{
sieve(11000);
while(1)
{
scanf("%d",&a);
if(a==0)break;
if(a%2==0)
a-=3;
else
a-=2;
//printf("%d",b);
while(1)
{
if(isPrime(a)&&isPrime(a+2))
{
printf("%d %d\n",a,a+2);
break;
}
a-=2;
}
}
} | 1 |
#include <iostream>
#include <algorithm>
#include <fstream>
using namespace std;
int N = 0, M = 0;
int points[1001];
int scores[1002001];
bool check(int a, int c){
if(a >= (N + 2) * (N + 1) / 2 - 1){
return true;
}
return (scores[a] <= c && scores[a + 1] > c);
}
int search2(int a, int b, int c){
int pib = a + b - b / 2;
if(check(pib, c)){
return pib;
}else if(scores[pib] < c){
return search2(pib, b / 2, c);
}else{
return search2(a, b / 2, c);
}
}
int main(){
for(;;){
for(int i = 0; i < 1001; i++){
points[i] = 0;
}
for(int i = 0; i < 1002001; i++){
scores[i] = 0;
}
if(cin >> N){
if(N == 0){
break;
}
cin >> M;
for(int i = 1; i <= N; i++){
cin >> points[i];
}
for(int i = 0; i <= N; i++){
for(int j = i; j <= N; j++){
scores[(2 * N - i + 1) * i / 2 + j] = points[i] + points[j];
}
}
int mxsco = 0;
sort(scores, scores + ((N + 2) * (N + 1)) / 2);
for(int i = 0; i < (N + 2) * (N + 1) / 2; i++){
if(scores[i] > M){
break;
}
int nosco = scores[i] + scores[search2(0, (N + 2) * (N + 1) / 2, M - scores[i])];
if(nosco >= mxsco && nosco <= M){
mxsco = nosco;
}
}
cout << mxsco << endl;
}else{
break;
}
}
return 0;
} | #include<cstdio>
#include<cmath>
#include<iostream>
#include<algorithm>
using namespace std;
int lislis[1003000];
int main(){
while(1){
int N,M;
cin>>N>>M;
if(N==0&&M==0)break;
int lis[1002]={0};
for(int i=1;i<=N;i++)cin>>lis[i];
for(int i=0;i<1003000;i++)lislis[i]=0;
for(int i=0;i<=N;i++){
for(int j=0;j<=N;j++)lislis[i*(N+1)+j]=lis[i]+lis[j];
}
sort(lislis,lislis+((N+1)*(N+1)));
lislis[(N+1)*(N+1)]=lislis[(N+1)*(N+1)-1];
int maxans=0;
for(int i=0;i<(N+1)*(N+1);i++){
int l=0,r=(N+1)*(N+1),mid=(l+r)/2;
for(int j=0;j<30;j++){
if(lislis[i]+lislis[mid]<=M)l=mid;
else r=mid;
mid=(l+r)/2;
}
/*
printf("[%d] [%d][%d][%d]\n",i,l,mid,r);
*/
if(lislis[i]+lislis[l]<=M)maxans=max(maxans,lislis[i]+lislis[l]);
}
/*
for(int i=0;i<20;i++)printf("[%d]",lis[i]);
puts("");
for(int i=0;i<30;i++)printf("[%d]",lislis[i]);
puts("");
*/
cout<<maxans<<endl;
}
return 0;
} | 1 |
#include<bits/stdc++.h>
#define L long long
#define vi vector<int>
#define pb push_back
#define pi pair<int,int>
#define pii pair<pi,int>
#define aa first
#define bb second
#define xx aa.aa
#define yy aa.bb
#define zz bb
#define mp make_pair
#define mpp(a,b,c) mp(mp(a,b),c)
using namespace std;
int n,m,p;
L f[600000],g[600000],q,ans;
inline void modify(L f[],int i,int j,int k,int x,L p)
{
f[i]=min(f[i],p);
if(j<k)
if(x<=(j+k>>1))
modify(f,i<<1,j,j+k>>1,x,p);
else
modify(f,i<<1|1,(j+k>>1)+1,k,x,p);
}
inline L minn(L f[],int i,int j,int k,int l,int r)
{
if(l<=j && k<=r)
return f[i];
else
{
L p=1e18;;
if(l<=(j+k>>1))
p=min(p,minn(f,i<<1,j,j+k>>1,l,r));
if(r>(j+k>>1))
p=min(p,minn(f,i<<1|1,(j+k>>1)+1,k,l,r));
return p;
}
}
int main()
{
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
int i,j;
L k;
scanf("%d%d",&n,&m);
for(p=1;p<n;p<<=1);
for(i=1;i<2*p;i++)
f[i]=g[i]=1e18;
scanf("%d%d",&i,&j);
modify(f,1,1,p,i,-i);
modify(g,1,1,p,i,i);
while(m--)
{
scanf("%d",&i);
q+=abs(i-j);
ans+=abs(i-j);
k=min(minn(f,1,1,p,1,i)+i,minn(g,1,1,p,i,n)-i)-abs(i-j);
modify(f,1,1,p,j,k-j);
modify(g,1,1,p,j,k+j);
ans=min(ans,q+k);
j=i;
}
printf("%lld\n",ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 200005;
const long long inf = 1e18;
int n, MAX, A, B;
int x[N];
long long sum[N];
struct SegmentTree {
long long T[N << 2], lz[N << 2];
void init() {
for (int i = 1; i < (N << 2); ++i) {
T[i] = inf;
lz[i] = 0;
}
}
#define mid ((l + r) >> 1)
void push(int v, int l, int r) {
if (lz[v] == 0) return;
if (l < r) lz[v << 1] += lz[v], lz[v << 1 | 1] += lz[v];
T[v] += lz[v];
lz[v] = 0;
if (T[v] > inf) T[v] = inf;
}
void upd_pos(int v, int l, int r, int pos, long long val) {
push(v, l, r);
if (l > r || r < pos || l > pos) return;
if (l == r) { T[v] = val; return; }
upd_pos(v << 1, l, mid, pos, val); upd_pos(v << 1 | 1, mid + 1, r, pos, val);
T[v] = min(T[v << 1], T[v << 1 | 1]);
}
void upd_seg(int v, int l, int r, int L, int R, int val) {
push(v, l, r);
if (l > r || R < l || L > r) return;
if (L <= l && r <= R) { lz[v] = val; push(v, l, r); return; }
upd_seg(v << 1, l, mid, L, R, val); upd_seg(v << 1 | 1, mid + 1, r, L, R, val);
T[v] = min(T[v << 1], T[v << 1 | 1]);
}
long long get(int v, int l, int r, int L, int R) {
push(v, l, r);
if (l > r || R < l || L > r) return inf;
if (L <= l && r <= R) return T[v];
return min(get(v << 1, l, mid, L, R), get(v << 1 | 1, mid + 1, r, L, R));
}
#undef mid
void upd_pos(int pos, long long val) { upd_pos(1, 0, MAX, pos, val); }
void upd_seg(int l, int r, int val) { upd_seg(1, 0, MAX, l, r, val); }
long long get(int l, int r) { return get(1, 0, MAX, l, r); }
} seg1, seg2;
long long ans = inf;
void solve() {
//x[0] = B;
// first move: A
seg1.init(); // seg1 for xi >= xj (i > j)
seg2.init(); // seg2 for xi < xj (i > j)
seg1.upd_pos(B, abs(x[1] - A) - B);
seg2.upd_pos(B, abs(x[1] - A) + B);
for (int i = 2; i <= n; ++i) {
long long cur = min(seg1.get(0, x[i]) + x[i], seg2.get(x[i], MAX) - x[i]);
seg1.upd_seg(0, MAX, abs(x[i] - x[i-1]));
seg2.upd_seg(0, MAX, abs(x[i] - x[i-1]));
seg1.upd_pos(x[i-1], cur - x[i-1]);
seg2.upd_pos(x[i-1], cur + x[i-1]);
}
for (int i = 1; i <= MAX; ++i) {
ans = min(ans, seg1.get(i, i) + i);
}
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
cin >> MAX >> n >> A >> B; // initial positions
for (int i = 1; i <= n; ++i) cin >> x[i];
solve();
swap(A,B);
solve();
printf("%lld\n", ans);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int x;
cin>>x;
int ans,count,s;
ans=x%500;
count=ans%5;
s=(x-ans)/500*1000+(ans-count)/5*5;
cout<<s<<endl;
} | #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;
int ans = 180 * (n-2);
cout << ans << endl;
return 0;
}
| 0 |
#include <algorithm>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <time.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <numeric>
#include <limits>
#include <type_traits>
#include <locale>
#include <omp.h>
using namespace std;
#define SAY_YES cout << "YES" << endl;
#define SAY_Yes cout << "Yes" << endl;
#define SAY_NO cout << "NO" << endl;
#define SAY_No cout << "No" << endl;
#define IFYES(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "YES" << endl; \
} \
else \
{ \
cout << "NO" << endl; \
}
#define IFYes(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "Yes" << endl; \
} \
else \
{ \
cout << "No" << endl; \
}
#define IFyes(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "yes" << endl; \
} \
else \
{ \
cout << "no" << endl; \
}
#define DEBUG_OUTPUT_ARRAY(XXX, ONE) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << "DEBUG: i = " << i << " -> " << XXX[i] << endl; \
}
#define DEBUG_OUTPUT_ARRAY2(XXX, ONE, TWO) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << "<<< i = " << i << " >>>" << endl; \
for (int j = 0; j < (TWO); j++) \
{ \
cout << "DEBUG: j = " << j << " -> " << XXX[i][j] << endl; \
} \
}
#define DEBUG_OUTPUT_ARRAY2_BOX(XXX, ONE, TWO) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << i << " "; \
for (int j = 0; j < (TWO); j++) \
{ \
cout << XXX[i][j] << " "; \
} \
cout << endl; \
}
typedef pair<long long int, long long int> pll;
typedef pair<long long int, pll> lpll;
const long long int mod = 1000000007;
const long long int INF = 1e18;
const long double PI=3.14159265358979323;
//const long long int pl=1000000;
long long int N,a[200200],sum=0;
int main(){
cout << fixed << setprecision(18);
cin>>N;
for(long long int i = 0; i < N; i++){
cin>>a[i];
sum+=a[i];
a[i]*=N;
}
long long int x=INF;
for(long long int i = 0; i < N; i++){
x=min(x,abs(a[i]-sum));
}
for(long long int i = 0; i < N; i++){
if(x==abs(a[i]-sum)){cout<<i<<endl;return 0;}
}
}
| #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, k, ans;
int a[maxn];
bool sec[maxn];
vector<int> E[maxn];
int dfs(int x)
{
int ret = 0;
for(auto v : E[x])
ret = max(ret, dfs(v));
++ret;
if(ret == k && !sec[x]) ++ans, ret = 0;
return ret;
}
int main()
{
scanf("%d%d", &n, &k);
for(int i = 1; i <= n; ++i) scanf("%d", &a[i]);
ans += (a[1] != 1);
for(int i = 2; i <= n; ++i) E[a[i]].push_back(i);
sec[1] = 1;
for(auto v : E[1]) sec[v] = 1;
dfs(1);
printf("%d\n", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define 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(n) begin(n), end(n)
using ll = long long;
using namespace std;
void dfs(vector<vector<int>> &tree, vector<int> &d, int p){
for(auto i : tree.at(p)){
if(d.at(i) != -1) continue;
d.at(i) = d.at(p) + 1;
dfs(tree, d, i);
}
}
int main(){
int n, ta, ao;
cin >> n >> ta >> ao;
ta--; ao--;
vector<vector<int>> tree(n, vector<int>());
rep(i, n-1){
int a, b;
cin >> a >> b;
a--; b--;
tree.at(a).push_back(b);
tree.at(b).push_back(a);
}
vector<int> dta(n, -1), dao(n, -1);
dta.at(ta) = 0; dao.at(ao) = 0;
dfs(tree, dta, ta);
dfs(tree, dao, ao);
// rep(i, n){
// cerr << dta.at(i) << " ";
// }
// cerr << endl;
// rep(i, n){
// cerr << dao.at(i) << " ";
// }
// cerr << endl;
int ans = 0;
rep(i, n){
if(dao.at(i) > dta.at(i)){
ans = max(ans, dao.at(i)-1);
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define mod 1000000007
#define sp ' '
#define intmax 2147483647
#define llmax 9223372036854775807
#define nyan "(=^･ω･^=)"
#define mkp make_pair
#define lP pair<ll, ll>
#define iP pair<int,int>
typedef long long ll;
using namespace std;
int N, M, K, A, B, C, D[100000], vis[100000];
map<int, vector<pair<int,bool>>>v[100000];
queue<int>q;
void dfs(int x, int a, int t) {
vector<pair<int,bool>>&V = v[x][a];
for (int i = 0; i < V.size(); ++i) {
if (!V[i].second) {
V[i].second = true;
if (D[V[i].first] == t + 1 && vis[V[i].first] != a) {
vis[V[i].first] = a;
dfs(V[i].first, a, t);
}
if (D[V[i].first] == -1) {
D[V[i].first] = t + 1;
q.push(V[i].first);
dfs(V[i].first, a, t);
}
}
}
}
int main() {
cin >> N >> M;
while (M--) {
cin >> A >> B >> C;
--A;
--B;
v[A][C].push_back(mkp(B, false));
v[B][C].push_back(mkp(A, false));
}
memset(D, -1, sizeof D);
D[0] = 0;
q.push(0);
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto it = v[x].begin(); it != v[x].end(); ++it) {
dfs(x, it->first, D[x]);
}
}
cout << D[N - 1] << endl;
}
| 0 |
#include<iostream>
using namespace std;
const int BUF = 2000005;
const int MOD = 1000000007;
int add(int a, int b) {
return (a + b) % MOD;
}
int sub(int a, int b) {
return (a - b + MOD) % MOD;
}
int mul(int a, int b) {
return 1LL * a * b % MOD;
}
int nNum;
int a[BUF], b[BUF];
void read() {
cin >> nNum;
for (int i = 0; i < nNum; ++i) cin >> a[i];
for (int i = 0; i < nNum; ++i) cin >> b[i];
}
void work() {
static int s[BUF];
static int t[BUF];
for (int i = 0; i < nNum; ++i) {
s[i] = a[i] ^ a[(i + 1) % nNum];
t[i] = b[i] ^ b[(i + 1) % nNum];
}
const int P = 1<<30;
int sHash = 0;
int tHash = 0;
for (int i = 0; i < nNum; ++i) {
sHash = add(mul(sHash, P), s[i]);
tHash = add(mul(tHash, P), t[i]);
}
int pPowNNum = 1;
for (int i = 0; i < nNum - 1; ++i) {
pPowNNum = mul(pPowNNum, P);
}
for (int shift = 0; shift < nNum; ++shift) {
if (sHash == tHash) {
cout << shift << ' ' << (a[shift] ^ b[0]) << endl;
}
sHash = sub(sHash, mul(s[shift], pPowNNum));
sHash = mul(sHash, P);
sHash = add(sHash, s[shift]);
}
}
int main() {
read();
work();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long N;
cin >> N;
vector<long> A(N);
for (long i = 0; i < N; i++) cin >> A.at(i);
sort(A.rbegin(), A.rend());
long a = 0, b = 0;
for (long i = 0; i + 1 < N; i++) {
if (A.at(i) == A.at(i + 1)) {
if (!a) a = A.at(i++);
else b = A.at(i++);
if (b) break;
}
}
cout << a * b << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin>>a>>b;
if (a == 1 && b == 1) {
cout<<"1 2"<<endl;
cout<<"#."<<endl;
return 0;
}
if (a == 1 || b == 1) {
cout<<"50 100"<<endl;
} else {
cout<<"100 100"<<endl;
}
if (a > 1) {
--b;
for (int i=0; i<50; i++) {
for (int j=0; j<100; j++) {
if (i % 2 == 0 && j % 2 == 0) {
if (a > 1 || (a == 1 && b == 0)) {
cout<<'.';
--a;
} else {
cout<<'#';
}
} else {
cout<<'#';
}
}
cout<<endl;
}
}
if (b > 0) {
for (int i=0; i<50; i++) {
for (int j=0; j<100; j++) {
if (i % 2 == 1 && j % 2 == 0) {
if (b > 0) {
cout<<'#';
--b;
} else {
cout<<'.';
}
} else {
cout<<'.';
}
}
cout<<endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B; cin >> A >> B;
A--; B--;
vector<vector<int>> G(100, vector<int>(100));
for (int i = 0; i < 50; i++) {
for (int j = 0; j < 100; j++) G.at(i).at(j) = 1;
}
int wy = 1, wx = 1;
while (A > 0) {
G.at(wy).at(wx) = 0;
A--;
if (wx == 99) {
wy += 2;
wx = 1;
}
else wx += 2;
}
int by = 51, bx = 1;
while (B > 0) {
G.at(by).at(bx) = 1;
B--;
if (bx == 99) {
by += 2;
bx = 1;
}
else bx += 2;
}
cout << 100 << " " << 100 << endl;
for (int i = 0; i < 100; i++) {
for (int j = 0; j < 100; j++) {
if (G.at(i).at(j) == 0) cout << '.';
else cout << '#';
}
cout << endl;
}
} | 1 |
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
int n;
for(;cin>>n;)
{
int data[n];
int dmax=0;
for(int i=0;i<n;i++)
{
cin>>data[i];
dmax=max(dmax,data[i]);
}
for(int i=1;i<=dmax/2;i++)
{
bool flag=true;
for(int j=0;j<n;j++)
{
if(data[j]%i!=0)
{
flag=false;
break;
}
}
if(flag)
cout<<i<<endl;
}
}
} | #include <iostream>
using namespace std;
bool isMatch(int x) {
if (x % 3 == 0) return true;
do {
if (x % 10 == 3) return true;
} while (x /= 10);
return false;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
if (isMatch(i)) cout << ' ' << i;
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, from, to) for (int i = from; i < (to); ++i)
#define mp(x,y) make_pair(x,y)
#define all(x) (x).begin(),(x).end()
#define pb push_back
using ll = long long;
using vin=vector<int>;
using vll=vector<ll>;
using vst=vector<string>;
using P = pair<int, int>;
const int inf=1e9+7;
const ll INF=1e18;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
template<class T> inline void YES(T condition){ if(condition) cout << "YES" << endl; else cout << "NO" << endl; }
const int dx[4] = { 1, 0, -1, 0 };
const int dy[4] = { 0, 1, 0, -1 };
map<ll,int> prf(ll n){
map<ll,int> ret;
for(ll i=2;i*i<=n;i++){
while(n%i==0){
ret[i]++;
n/=i;
}
}
if(n!=1){
ret[n]=1;
}
return ret;
}
int main(){cout<<fixed<<setprecision(10);
int n,h,w;
cin>>n>>h>>w;
n++;
cout<<(n-w)*(n-h)<<endl;
} | #include "bits/stdc++.h"
#define int long long
#define endl '\n'
using namespace std;
typedef long long ll;
#define db(x) cerr << #x << ": " << x << '\n';
#define read(a) int a; cin >> a;
#define readb(a, b) int a, b; cin >> a >> b;
#define readc(a, b, c) int a, b, c; cin >> a >> b >> c;
#define readarr(a, n) int a[(n) + 1] = {}; FOR(i, 1, (n)) {cin >> a[i];}
#define readmat(a, n, m) int a[n + 1][m + 1] = {}; FOR(i, 1, n) {FOR(j, 1, m) cin >> a[i][j];}
#define print(a) cout << a << endl;
#define printarr(a, n) FOR (i, 1, n) cout << a[i] << " "; cout << endl;
#define printv(v) for (int i: v) cout << i << " "; cout << endl;
#define printmat(a, n, m) FOR (i, 1, n) {FOR (j, 1, m) cout << a[i][j] << " "; cout << endl;} cout << endl;
#define all(v) v.begin(), v.end()
#define sz(v) (int)(v.size())
#define rz(v, n) v.resize((n) + 1);
#define pb push_back
#define fi first
#define se second
#define vi vector <int>
#define pi pair <int, int>
#define vpi vector <pi>
#define vvi vector <vi>
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define FORD(i, a, b) for (int i = (a); i >= (b); i--)
const ll inf = 1e18;
const ll mod = 1e9 + 7;
const ll N = 2e5 + 1;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
readc(n, h, w);
int cnt = 0;
FOR (i, 1, n)
FOR (j, 1, n)
if (i + h - 1 <= n && j + w - 1 <= n) cnt++;
print(cnt);
}
| 1 |
#include <bits/stdc++.h>
#include <vector>
#include <queue>
using namespace std;
int main(){
int N, M;
cin >> N >> M;
vector<bool> IsCorrect(N, false);
vector<int> Penalties(N, 0);
for(int i=0; i<M; i++){
int p;
string s;
cin >> p >> s;
p=p-1;
if(s=="AC"){
IsCorrect[p] = true;
}
if(s=="WA" && IsCorrect[p]==false){
Penalties[p] += 1;
}
}
int c_ans = 0;
int c_pena = 0;
for(int i=0; i<N; i++){
if(IsCorrect[i]== true){
c_ans++;
c_pena += Penalties[i];
}
}
cout << c_ans << " " << c_pena << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
inline int read(){
register int x=0,f=1;register char ch=getchar();
while(ch<'0'||ch>'9')f=ch=='-'?-1:f,ch=getchar();
while(ch>='0'&&ch<='9')x=x*10+ch-'0',ch=getchar();
return x*f;
}
int last[N], root[N];
struct seg{
int l, r;
int val;
}tr[N * 30];
int tot;
void build(int &rt, int l, int r)
{
rt = ++tot;
tr[rt].val = 0;
if(l == r) return ;
int mid =l + r >> 1;
build(tr[rt].l, l, mid), build(tr[rt].r, mid + 1, r);
}
void update(int &p, int q, int x, int c, int l, int r)
{
p = ++ tot;
tr[p] = tr[q];
tr[p].val += c;
if(l == r) return ;
int mid = l + r >> 1;
if(x <= mid) update(tr[p].l, tr[q].l, x,c, l, mid);
else update(tr[p].r, tr[q].r, x, c,mid + 1, r);
}
int query(int p, int q, int L, int R, int l, int r)
{
if(L <= l && R >= r)
return tr[q].val - tr[p].val;
int mid = l + r >> 1;
int res = 0;
if(L <= mid) res += query(tr[p].l, tr[q].l, L, R, l, mid);
if(R > mid) res += query(tr[p].r, tr[q].r, L, R, mid + 1, r);
return res;
}
int main()
{
int n, m;
n = read(); m = read();
build(root[0], 0, n);
for (int i = 1; i <= n; i ++)
{
int x;
x = read();
update(root[i], root[i - 1], last[x], 1, 0, n);
last[x] = i;
}
while(m --)
{
int x, y;
x = read(), y = read();
printf("%d\n", query(root[x - 1], root[y], 0, x - 1, 0, n));
}
} | 0 |
#include<iostream>
#include<string>
#include<cstdio>
#include<cstdlib>
using namespace std;
struct Node{
int key;
Node *parent, *left, *right;
};
Node *root, *NIL;
void insert(int k){
Node *y = NIL;
Node *x = root;
Node *z;
z = (Node *)malloc(sizeof(Node));
z->key = k;
z->left = NIL;
z->right = NIL;
while(x != NIL){
y = x;
if(z->key < x->key){
x = x->left;
} else {
x = x->right;
}
}
z->parent = y;
if( y == NIL){
root = z;
} else {
if(z->key < y->key){
y->left = z;
} else {
y->right = z;
}
}
}
bool find(int k, Node *u){
if(u == NIL) return false;
if(u->key == k) return true;
return (u->key > k)?find(k,u->left):find(k,u->right);
}
Node * treeMinimum(Node *x){
while(x->left != NIL) x = x->left;
return x;
}
Node * _find(Node *u, int k){
while(u != NIL && k != u->key){
if(k < u->key) u = u ->left;
else u = u->right;
}
return u;
}
Node * treeSuccessor(Node * x){
if(x->right != NIL) return treeMinimum(x->right);
Node *y = x->parent;
while(y != NIL && x == y->right){
x = y;
y = y->parent;
}
return y;
}
void treeDelete(Node *z){
Node *y;
Node *x;
if(z->left == NIL || z->right == NIL) y = z;
else y = treeSuccessor(z);
if(y->left != NIL){
x = y->left;
} else {
x = y->right;
}
if(x != NIL){
x->parent = y->parent;
}
if(y->parent == NIL){
root = x;
} else {
if(y == y->parent->left){
y->parent->left = x;
} else {
y->parent->right = x;
}
}
if(y != z){
z->key = y->key;
}
free(y);
}
void inorder(Node *u){
if( u == NIL) return;
inorder(u->left);
printf(" %d", u->key);
inorder(u->right);
}
void preoder(Node *u){
if( u == NIL) return;
printf(" %d", u->key);
preoder(u->left);
preoder(u->right);
}
int main(){
int n;
string s;
cin>>n;
scanf("%d", &n);
for(int i = 0; i < n; i++){
// scanf("%s", s);
cin>>s;
if(s == "print"){
inorder(root);
printf("\n");
preoder(root);
printf("\n");
} else if(s == "insert"){
int x;
scanf("%d", &x);
insert(x);
} else if(s == "find"){
int k;
scanf("%d", &k);
printf(("%s",find(k,root)?"yes":"no"));
printf("\n");
} else if(s == "delete"){
int k;
scanf("%d", &k);
treeDelete(_find(root,k));
}
}
return 0;
}
| #include "stdio.h"
#include"queue"
#include "climits"
using namespace std;
queue<int>Q;
int island;
int query;
int kind;
int start;
int goal;
int connect[101][101] = {};
int price;
int dis[101] = {};
int main() {
scanf("%d %d", &island, &query);
while (island != 0) {
for (int i = 0; i < 101; i++) {
for (int j = 0; j < 101; j++) {
connect[i][j] = INT_MAX;
}
}
for (int i = 0; i < query; i++) {
scanf("%d", &kind);
if (kind == 1) {
scanf("%d %d %d", &start, &goal, &price);
if (connect[start][goal] > price) {
connect[start][goal] = price;
connect[goal][start] = price;
}
}
else {
scanf("%d %d", &start, &goal);
Q.push(start);
for (int i = 1; i < 101; i++) {
dis[i] = INT_MAX;
}
dis[start] = 0;
while (!Q.empty()) {
for (int i = 1; i <= island; i++) {
if (connect[Q.front()][i] != INT_MAX) {
if (dis[i] > dis[Q.front()] + connect[Q.front()][i]) {
dis[i] = dis[Q.front()] + connect[Q.front()][i];
Q.push(i);
}
}
}
Q.pop();
}
if (dis[goal] == INT_MAX)printf("-1\n");
else printf("%d\n", dis[goal]);
}
}
scanf("%d %d", &island, &query);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<ll, int> Pli;
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll MOD3 = 1812447359;
const ll INF = 1ll << 62;
const double PI = 2 * asin(1);
void yes() {printf("yes\n");}
void no() {printf("no\n");}
void Yes() {printf("Yes\n");}
void No() {printf("No\n");}
void YES() {printf("YES\n");}
void NO() {printf("NO\n");}
int main(){
int H, W, N; cin >> H >> W >> N;
if (H < W) swap(H, W);
int ans = N / H;
if (N % H != 0) ans++;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#ifdef KACTL
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define sz(x) (int)(x).size()
#endif
#define all(x) begin(x), end(x)
using ll = int64_t;
using ld = long double;
using pii = pair<int32_t, int32_t>;
using vi = vector<int32_t>;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
int h, w, a, b;
cin >> h >> w >> a >> b;
/* h = w, a = b
* do the jagged thing
*
* XX.
* .XX
* X.X
*
* XX..
* .XX.
* ..XX
* X..X
*
*
* some can be 1s and some can be zeros
* 2 4 1 1
*
* 3 3 1 1
*/
vector<string> res(h, string(w, '0'));
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
res[i][j] ^= (i < b) ^ (j < a);
}
}
for (auto& row : res)
cout << row << '\n';
return 0;
}
| 0 |
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define cinf(n,x) for(int i=0;i<(n);i++)cin>>x[i];
#define ft first
#define sc second
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(),(v).end()
#define mod 1000000007
#define FS fixed<<setprecision(15)
using namespace std;
typedef long long ll;
template<class T> using V=vector<T>;
using Graph = vector<vector<int>>;
using P=pair<ll,ll>;
typedef unsigned long long ull;
typedef long double ldouble;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
const ll INF=1e18;
int main(){
cin.tie(0);ios::sync_with_stdio(false);
int n,m;
cin>>n>>m;
set<int> st;
for(int i=1;i<n;i++){
st.insert(i);
}
int k=1;
int pr=-1;
set<int> check;
while(k<=m){
int v=*rbegin(st);
st.erase(v);
while(pr-v==1||check.count(n-v)||2*v==n){
v=*rbegin(st);
st.erase(v);
}
pr=v;
check.insert(v);
printf("%d %d\n",k,k+v);
k++;
}
} | #pragma GCC optimize("O3")
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using T = tuple<int, int, int>;
template <class T> inline T chmax(T &a, const T b) {return a = (a < b) ? b : a;}
template <class T> inline T chmin(T &a, const T b) {return a = (a > b) ? b : a;}
constexpr int MOD = 1e9 + 7;
constexpr int inf = 1e9;
constexpr long long INF = 1e18;
#define all(a) (a).begin(), (a).end()
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n, m; cin>>n>>m;
int head = 2, tail = n;
vector<P> ans;
if(n % 2 == 1){
for(int i=0; i<m; i++){
ans.emplace_back(head, tail);
head++, tail--;
}
}
else{
set<int> length;
for(int i=0; i<m; i++){
int over = (n - tail) + head, under = tail - head;
if(over == under || length.count(over) || length.count(under)) tail--;
ans.emplace_back(head, tail);
length.emplace(over);
length.emplace(under);
head++, tail--;
}
}
for(auto i : ans) cout << i.first << " " << i.second << endl;
return 0;
} | 1 |
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include<vector>
#include<queue>
#include<map>
#include<tuple>
#define rep(index,num) for(int index=0;index<num;index++)
#define rep1(index,num) for(int index=1;index<=num;index++)
#define scan(argument) cin>>argument
#define prin(argument) cout<<argument<<endl
#define kaigyo cout<<endl
#define eps 1e-15
#define mp(a1,a2) make_pair(a1,a2)
#define YMAX 250001
typedef long long ll;
using namespace std;
typedef pair<ll,ll> pll;
typedef pair<int,int> pint;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef vector<pint> vpint;
typedef vector<pll> vpll;
ll INFl=1e+18+1;
int INF=1e+9+1;
bool arr[10001];
int Nmax=10001;
vint sosu;
void Eratosthenes(){
for(int i = 0; i < Nmax; i++){
arr[i] = true;
}
arr[0]=false; arr[1]=false;
for(int i = 2; i < sqrt(Nmax); i++){
if(arr[i]){
for(int j = 0; i * (j + 2) < Nmax; j++){
arr[i *(j + 2)] = false;
}
}
}
rep1(i,Nmax){
if(arr[i]) sosu.push_back(i);
}
}
ll gcd(ll x,ll y){
if(y==0) return x;
return gcd(y,x%y);
}
ll lcm(ll x,ll y){
return x/gcd(x,y)*y;
}
int main(){
Eratosthenes();
int N;
ll a[502][502];
ll ichimatsu1[501][501],ichimatsu2[501][501];
scan(N);
int NMAX=500;
int sosucount=0;
for(int kyori=0;kyori<=NMAX*2-2;kyori+=2){
for(int j=0;j<=NMAX-1;j++){
int i=kyori-j;
if(i<0||i>NMAX-1) continue;
//printf("kyori:%d i:%d j:%d sosu:%d\n",kyori,i,j,sosu[sosucount]);
ichimatsu1[i][j]=sosu[sosucount];
}
sosucount++;
}
for(int kyori=NMAX-1;kyori<=NMAX*2-2&&kyori>=0;kyori+=(kyori<=NMAX-1 ? 2*(NMAX-1-kyori)+2 : 2*(NMAX-1-kyori))){
for(int j=NMAX-1;j>=0;j--){
int i=j-kyori+NMAX-1;
if(i<0||i>NMAX-1) continue;
ichimatsu2[i][j]=sosu[sosucount];
}
sosucount++;
}
/*rep(i,N){
rep(j,N){
if((i+j)%2==0) printf("%lld ",ichimatsu1[i][j]);
else printf("-- ");
}
kaigyo;
}
kaigyo;
rep(i,N){
rep(j,N){
if((i+j)%2==0) printf("%lld ",ichimatsu2[i][j]);
else printf("-- ");
}
kaigyo;
}*/
rep(i,NMAX){
rep(j,NMAX){
if((i+j)%2==0) a[i+1][j+1]=ichimatsu1[i][j]*ichimatsu2[i][j];
}
}
rep(i,NMAX+2){
a[i][0]=1;
a[i][NMAX+1]=1;
}
rep(j,NMAX+2){
a[0][j]=1;
a[NMAX+1][j]=1;
}
rep(i,NMAX){
rep(j,NMAX){
if((i+j)%2==1) a[i+1][j+1]=lcm(lcm(a[i][j+1],a[i+2][j+1]),lcm(a[i+1][j],a[i+1][j+2]))+1;
}
}
rep1(i,N){
rep1(j,N){
printf("%lld ",a[i][j]);
}
kaigyo;
}
return 0;
}
| #include <iostream>
#include <fstream>
#include <vector>
using namespace std;
#define NMAX 502
#define DIM 7920
int d[DIM], p[DIM];
long long sol[NMAX][NMAX];
void ciur(int n) {
for (int i = 2; i <= n; i++) {
if (d[i] == 0) {
p[++p[0]] = i;
for (int j = i + i; j <= n; j += i) {
d[j] = 1;
}
}
}
}
__int128 gcd(__int128 a, __int128 b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
__int128 lcm(vector <long long>& v) {
__int128 l = 1;
for (const long long x : v) {
if (x == 0)
continue;
__int128 d = gcd(l, (__int128)x);
l = l * x / d;
}
return (long long)l;
}
int main()
{
ios::sync_with_stdio(false);
int n;
cin >> n;
if (n == 2) {
cout << "4 7\n23 10\n";
return 0;
}
ciur(DIM - 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
sol[i][j] = 1;
}
}
int cnt = 1;
for (int j = 1; j <= n; j += 2) {
int col = j;
for (int i = 1; i <= n; i++) {
if (col > n)
break;
sol[i][col] *= p[cnt];
col++;
}
cnt++;
}
for (int i = 3; i <= n; i += 2) {
int lin = i;
for (int j = 1; j <= n; j++) {
if (lin > n)
break;
sol[lin][j] *= p[cnt];
lin++;
}
cnt++;
}
for (int j = 1; j <= n; j += 2) {
int col = j;
for (int i = 1; i <= n; i++) {
if (col <= 0)
break;
sol[i][col] *= p[cnt];
col--;
}
cnt++;
}
for (int i = n; i > 1; i -= 2) {
int lin = i;
for (int j = n; j >= 1; j--) {
if (lin > n)
break;
sol[lin][j] *= p[cnt];
lin++;
}
cnt++;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if ((i + j) % 2 == 0)
continue;
vector <long long> v = {sol[i - 1][j], sol[i + 1][j], sol[i][j - 1], sol[i][j + 1]};
sol[i][j] = lcm(v) + 1;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cout << sol[i][j] << " ";
}
cout << '\n';
}
return 0;
}
| 1 |
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
constexpr char ln = '\n';
constexpr long long MOD = 1000000007LL;
constexpr long long INF = 1001001001LL;
constexpr long long LINF = 1001001001001001001;
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define rept(i, j, n) for(int i=(j); i<(n); i++)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main(){
int n; cin >> n;
vector<ll> A(n);
ll sum = 0;
rep(i, n){
cin >> A[i];
sum += A[i];
}
double avg = sum / (double)n;
double sa = LINF, res = -1;
rep(i, n){
if(sa > abs(avg - A[i])){
sa = abs(avg - A[i]);
res = i;
}
}
cout << res << ln;
}
| #include<bits/stdc++.h>
using namespace std;
int main()
{
long int n,tem;
cin>>n;
vector<long int>p;
for(long int i=0;i<n;i++)
{
cin>>tem;
p.push_back(tem);
}
long int c=1,mini=p[0];
for(long int i=1;i<n;i++)
{
if(mini>=p[i])
{
c++;
mini=p[i];
}
}
cout<<c<<"\n";
return 0;}
| 0 |
#include <bits/stdc++.h> // {{{
#define ARG4(_1, _2, _3, _4, ...) _4
#define rep(...) ARG4(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define REP(i, a) FOR(i, 0, a)
#define FOR(i, a, b) for (int i = (a); i < (int)(b); ++i)
#define rrep(...) ARG4(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
#define RREP(i, a) RFOR(i, 0, a)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (int)(a); --i)
#define ALL(c) (c).begin(), (c).end()
#define TEN(n) ((ll)(1e##n))
#define pb emplace_back
#define mp make_pair
#define fi first
#define se second
#define let const auto
#define USE_T template <typename T>
#define USE_Ti template <typename T = int>
#define USE_TU template <typename T, typename U>
USE_Ti using duo = std::pair<T, T>;
USE_Ti using vec = std::vector<T>;
using ll = long long;
// clang-format off
USE_TU inline bool chmax(T&x,U a){return x<a&&(x=a,1);}
USE_TU inline bool chmin(T&x,U a){return a<x&&(x=a,1);}
USE_Ti inline T in(){T x;std::cin>>x;return x;}
USE_Ti inline vec<T> in(int n){vec<T> v;v.reserve(n);rep(i,n)v.pb(in<T>());return v;}
USE_T inline void in(T*x,int n){rep(i,n)x[i]=in<T>();}
struct IoSetup {
IoSetup(){
using namespace std;
cin.tie(0);
ios::sync_with_stdio(0);
cout<<setprecision(10);
cerr<<setprecision(10);
}
} iosetup;
// clang-format on
// }}}
using namespace std;
const int inf = 1001001001;
const ll infll = 1001001001001001001ll;
const int dd[] = {0, 1, 0, -1, 0};
signed main() {
auto S = in(6);
int tot = std::accumulate(ALL(S), 0);
tot -= *min_element(ALL(S) - 2);
tot -= *min_element(4 + ALL(S));
cout << tot << endl;
return 0;
} | /* template.cpp [[[ */
#include <bits/stdc++.h>
using namespace std;
#define get_macro(a, b, c, d, name, ...) name
#define rep(...) get_macro(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rrep(...) get_macro(__VA_ARGS__, rrep4, rrep3, rrep2, rrep1)(__VA_ARGS__)
#define rep1(n) rep2(i_, n)
#define rep2(i, n) rep3(i, 0, n)
#define rep3(i, a, b) rep4(i, a, b, 1)
#define rep4(i, a, b, s) for (ll i = (a); i < (ll)(b); i += (ll)s)
#define rrep1(n) rrep2(i_, n)
#define rrep2(i, n) rrep3(i, 0, n)
#define rrep3(i, a, b) rrep4(i, a, b, 1)
#define rrep4(i, a, b, s) for (ll i = (ll)(b) - 1; i >= (ll)(a); i -= (ll)s)
#define each(x, c) for (auto &&x : c)
#define fs first
#define sc second
#define all(c) begin(c), end(c)
using ui = unsigned;
using ll = long long;
using ul = unsigned long long;
using ld = long double;
const int INF = 1e9 + 10;
const ll INF_LL = 1e18 + 10;
const int dx[]{-1, 0, 1, 0, -1, 1, 1, -1};
const int dy[]{0, -1, 0, 1, -1, -1, 1, 1};
template<class T, class U> void chmin(T &x, const U &y){ x = min<T>(x, y); }
template<class T, class U> void chmax(T &x, const U &y){ x = max<T>(x, y); }
/* ]]] */
int main(){
int a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
cout << a + b + c + d - min({a, b, c, d}) + max(e, f) << endl;
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.