code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
// define
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)),UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a+mod-b)%mod
#define MUL(a, b) a = (((a)%mod) * ((b)%mod)) % mod
#define rollcall cout << "I'm Sucu." << endl;
#define repi(i,m,n) for(int i = m;i < n;i++)
#define drep(i,n,m) for(int i = n;i >= m;i--)
#define rep(i,n) repi(i,0,n)
#define rrep(i,n) repi(i,1,n+1)
#define chmin(x,y) x = min(x,y)
#define chmax(x,y) x = max(x,y)
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(), v.rend()
#define dmp(x,y) make_pair(x,y)
#define pb(x) push_back(x)
#define pf(x) push_front(x)
#define fi first
#define se second
// typedef
typedef complex<double> Point;
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef pair<P, int> Pi;
typedef vector<int> vi;
typedef deque<int> dq;
const int inf = 1e9+7;
const int INF = 1e18+7;
const int mod = 1e9+7;
// int sum = accumulate(a, a+n, 0LL);
// int mx = max_element(a, a+n);
// int mn = min_element(a, a+n);
// int cnt = count(a, a+n, k);
int N;
signed main()
{
cin >> N;
vi A(N), B(N), C(N);
rep(i, N) cin >> A[i];
rep(i, N) cin >> B[i];
rep(i, N) cin >> C[i];
sort(all(A));
sort(all(C));
int ans = 0;
rep(i,N)
{
auto low = lower_bound(all(A), B[i]);
int ac = low - A.begin();
auto high = upper_bound(all(C), B[i]);
int cc = C.end() - high;
ans += ac * cc;
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
long a[n];
for(int i=0;i<n;i++)cin >> a[i];
long dai = 0;
for(int i=1;i<n;i++){
if(a[i] >= a[i-1]){
continue;
}else{
dai += a[i-1] - a[i];
a[i] = a[i-1];
}
}
cout << dai << endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
vector<vector<pair<int, int> > >edge(n + 3);
vector<vector<int> >rails(n + 3);
for(int i = 1; i <= m; i++){
int u, v, c;
cin >> u >> v >> c;
edge[u].push_back({c, v});
edge[v].push_back({c, u});
rails[u].push_back(c);
rails[v].push_back(c);
}
for(int i = 1; i <= n; i++){
sort(edge[i].begin(), edge[i].end());
}
deque<pair<int, pair<int, int> > >dq;
vector<map<int, int> >mp(n + 3);
mp[1][0] = 0;
dq.push_back({0, {1, 0}});
while(!dq.empty()){
int d = dq.front().first;
int now = dq.front().second.first;
int rail = dq.front().second.second;
dq.pop_front();
if(rail == 0){
for(int i = 0; i < rails[now].size(); i++){
int nrail = rails[now][i];
if(mp[now].find(nrail) != mp[now].end() && mp[now][nrail] <= d + 1){
continue;
}
mp[now][nrail] = d + 1;
dq.push_back({d + 1, {now, nrail}});
}
}
else{
pair<int, int>p = make_pair(rail, 0);
int x = lower_bound(edge[now].begin(), edge[now].end(), p) - edge[now].begin();
while(x != edge[now].size() && edge[now][x].first == rail){
int nxt = edge[now][x].second;
if(mp[nxt].find(rail) != mp[nxt].end() && mp[nxt][rail] <= d){
x++;
continue;
}
mp[nxt][rail] = d;
dq.push_front({d, {nxt, rail}});
x++;
}
if(mp[now].find(0) != mp[now].end() && mp[now][0] <= d){
continue;
}
mp[now][0] = d;
dq.push_front({d, {now, 0}});
}
}
if(mp[n].empty()){
cout << "-1";
return 0;
}
int ans = 1e8;
for(int i = 0; i < rails[n].size(); i++){
int x = rails[n][i];
ans = min(ans, mp[n][x]);
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
#define INF 1023456789
#define sacnf scanf
#define scnf scanf
#define scnaf scanf
#define CRLF <<'\n';
#define ALL(v) v.begin,v.end()
#define SIZE(v) (int)v.size()
#define PRPAIR(x) x.first << x.second
#define DEBUG(x) do { std::cerr <<(x)<<'\n'; } while (0)
#define rep(i,a,b) for(int i=(a);i!=(int)b-((a)>(b));(a)>(b)?--i:++i)
using namespace std;
typedef pair<int,int> ii;
typedef pair<ii,int> pip;
typedef vector<int> vi;
typedef long long ll;
#define BLK 707
int main(){
int n,q;
scanf("%d%d",&n,&q);
int arr[n];
pip que[q];
rep(i,0,n)
scanf("%d",&arr[i]),arr[i]--;
rep(i,0,q){
int a,b;
scanf("%d%d",&a,&b);
a--,b--;
que[i] = pip(ii(a,b),i);
}
sort(que,que+q,[](pip a,pip b){
if (a.first.first/BLK==b.first.first/BLK)
return (a.first.first/BLK & 1) ? (a.first.second < b.first.second) : (a.first.second > b.first.second);
else
return a.first.first/BLK<b.first.first/BLK;
});
int ans[q];
int L=0,R=-1;
int cnt[n];
memset(cnt,0,sizeof cnt);
int num=0;
rep(i,0,q){
int l=que[i].first.first,r=que[i].first.second;
while(L < l){
if (--cnt[arr[L]] == 0)
num--;
L++;
}
while(L > l){
--L;
if (cnt[arr[L]]++ == 0)
num++;
}
while(R<r){
++R;
if (cnt[arr[R]]++ == 0)
num++;
}
while(R>r){
if (--cnt[arr[R]]==0)
num--;
R--;
}
ans[que[i].second] = num;
}
rep(i,0,q)
printf("%d\n",ans[i]);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < (n); i++)
#define REPS(i, n) for(int i = 1; i <= (n); i++)
#define RREP(i, n) for(int i = (n)-1; i >= 0; i--)
#define RREPS(i, n) for(int i = (n); i > 0; i--)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define mp make_pair
#define mt make_tuple
#define pb push_back
using ll = long long;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vs = vector<string>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const ll INFL = 1e18;
const double PI = 3.141592653589793;
const double EPS = 1e-9;
template<class T> bool chmax(T &a, const T &b) { if(a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if(a > b) { a = b; return true; } return false; }
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll N; cin >> N;
vl factor(N+1);
for(ll i = 2; i <= N; i++)
{
ll tmp = i;
for(ll j = 2; j * j <= i; j++)
{
while(tmp % j == 0)
{
factor[j]++;
tmp /= j;
}
}
if(tmp != 1) factor[tmp]++;
}
ll ans = 1;
REP(i, (int)factor.size())
{
ans *= factor[i] + 1;
ans %= MOD;
}
cout << ans << endl;
}
| #include <iostream>
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main(){
string s;
cin>>s;
string ans="Yes";
for(int i=0;i<s.size();i+=2){
if(s.size()%2==1){
ans="No";
break;
}
if(s.at(i)!='h' || s.at(i+1)!='i'){
ans="No";
break;
}
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <iostream>
#include <utility>
#include <set>
#include <cctype>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cmath>
using namespace std;
#define MAXN 5010
int main(void) {
while (1) {
int n;
cin >> n;
if (n == 0) break;
int a[MAXN], sum[MAXN];
for (int i = 0; i < n; i++) {
a[i] = 0;
sum[i] = 0;
}
sum[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum[i] = sum[i-1] + a[i];
}
int ret = a[1];
for (int i = 0; i <= n; i++) {
for (int j = i+1; j <= n; j++) {
ret = max(sum[j]-sum[i], ret);
}
}
cout << ret << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
vector<int> an;
vector<vector<int>> AN;
while (cin >> n) {
if (n == 0)break;
for (int i = 0; i < n; i++) {
cin >> a;
an.push_back(a);
}
AN.push_back(an); an.clear();
}
for (int i = 0; i < AN.size(); i++) {
long long int max = 0, min = INT_MAX, MAX = 0, MIN = 0 , counter = 0, negative = 0;
for (int j = 0; j < AN[i].size(); j++) {
if (AN[i][j] >= 0) {
max += AN[i][j];
if (MAX < max)MAX = max;
counter = 1;
negative = 1;
}
else {
if (negative == 0) {
if(min > abs(AN[i][j]))min=abs(AN[i][j]);
}
else if (counter==1){
if (AN[i][j] + max >= 0)max += AN[i][j];
else {
max = 0;
counter = 0;
}
}
}
}
if (negative == 0)cout << -1*min << endl;
else cout << MAX << endl;
}
return 0;
} | 1 |
#include <iostream>
#include <cstring>
#include <vector>
using namespace std;
typedef pair<int , int> ii;
typedef long long ll;
const ll mod = 1e9 + 7;
const int maxn = 1e5 + 10;
int N;
string S;
ll fac[maxn];
int main(){
cin >> N;
cin >> S;
fac[0] = 1;
for(int i = 1; i < maxn; ++i)fac[i] = fac[i - 1] * i % mod;
ll ret = 1;
ll cnt = 0;
for(int i = 0; i < 2 * N; ++i){
char cc;
if(cnt & 1){
if(S[i] == 'W'){
cc = 'L';
}
else{
cc = 'R';
}
}
else{
if(S[i] == 'W'){
cc = 'R';
}
else{
cc = 'L';
}
}
if(cc == 'R'){
ret = (ret * cnt) % mod;
--cnt;
}
else ++cnt;
if(cnt < 0){
cout << 0 << endl;
return 0;
}
}
if(cnt)cout << 0 << endl;
else cout << (ret * fac[N] % mod + mod) % mod << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin>>n;
int remainder;
bool vqrno=false;
while(n!=0){
remainder=n%10;
if(remainder==7){
vqrno=true;
break;
}
else
n/=10;
}
if(vqrno==true)
puts("Yes");
else
puts("No");
}
| 0 |
#include <iostream>
#include <fstream>
#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <functional>
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
using namespace std;
#define ll long long int
#define rep(i,n) for( int i = 0; i < n; i++ )
#define rrep(i,n) for( int i = n; i >= 0; i-- )
#define REP(i,s,t) for( int i = s; i <= t; i++ )
#define RREP(i,s,t) for( int i = s; i >= t; i-- )
#define dump(x) cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define mod 1000000007
#define INF2 10000000000000000
#define int long long
int dp[200010][3];
int A[200010];
int N;
int calc(int x, int remain_skip) {
//cout << x << " " << remain_skip << endl;
if(dp[x][remain_skip] != -INF2) return dp[x][remain_skip];
if(x >= N) {
if(remain_skip == 2) return -INF2;
return 0;
}
int ret = -INF2;
if(remain_skip > 0) ret = calc(x + 1, remain_skip - 1);
ret = max(ret, calc(x + 2, remain_skip) + A[x]);
return dp[x][remain_skip] = ret;
}
signed main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
rep(i, N) cin >> A[i];
rep(i, 200010) rep(j, 3) dp[i][j] = -INF2;
cout << calc(0, 1 + (N % 2 == 1)) << endl;
return 0;
}
// 1 2 3 4 | #include <stdio.h>
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <queue>
#include <set>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <complex>
using ll = long long int;
using namespace std;
int main(){
ll N, tmp;
vector<ll> A;
cin >> N;
for(ll i = 0; i < N; i++){
cin >> tmp;
A.push_back(tmp);
}
// if N is even
if(N%2 == 0){
cerr << "N is even." << endl;
vector<ll> accum(N);
accum[0] = A[0];
for(ll i = 2; i < N; i+=2){
accum[i] = accum[i-2] + A[i];
}
accum[N-1] = A[N-1];
for(ll i = N-3; i >= 1; i-=2){
accum[i] = accum[i+2] + A[i];
}
ll ans = max(accum[N-2], accum[1]);
for(ll i = 0; i<=N-4; i+=2){
ans = max(ans, accum[i]+accum[i+3]);
}
cerr << "Answer:" << endl;
cout << ans << endl;
return 0;
}
// N is odd
else{
cerr << "N is odd." << endl;
vector<ll> accum(N);
accum[0] = A[0];
for(ll i = 2; i < N; i++){
accum[i] = accum[i-2] + A[i];
}
accum[N-2] = A[N-2];
for(ll i = N-4; i >= 1; i-=2){
accum[i] = accum[i+2] + A[i];
}
vector<ll> diff(N);
for(ll i = 1; i <= N-4; i+=2){
diff[i] = accum[i-1] + accum[i+2] - accum[1];
}
for(ll i = 2; i <= N-3; i+=2){
diff[i] = accum[N-1]-accum[i] + accum[1] - accum[i+1] - accum[1];
}
diff[N-2] = accum[N-3] - accum[1];
diff[0] = accum[2] - accum[1];
vector<ll> eomax(N);
eomax[N-3] = diff[N-3];
for(ll i = N-5; i >= 0; i-=2){
eomax[i] = max(eomax[i+2], diff[i]);
}
ll ans = max(max(accum[N-1]-accum[0], accum[N-3]), accum[1]);
for(ll oe = 1; oe < N-2; oe+=2){
ans = max(ans, accum[1]+diff[oe]+eomax[oe+1]);
}
cerr << "Answer:" << endl;
cout << ans << endl;
return 0;
}
}
| 1 |
#include<bits/stdc++.h>
typedef long long ll;
ll gi(){
ll x=0,f=1;
char ch=getchar();
while(!isdigit(ch))f^=ch=='-',ch=getchar();
while(isdigit(ch))x=x*10+ch-'0',ch=getchar();
return f?x:-x;
}
std::mt19937 rnd(time(NULL));
#define rand rnd
#define pr std::pair<int,int>
#define fi first
#define se second
template<class T>void cxk(T&a,T b){a=a>b?a:b;}
template<class T>void cnk(T&a,T b){a=a<b?a:b;}
#ifdef mod
int pow(int x,int y){
int ret=1;
while(y){
if(y&1)ret=1ll*ret*x%mod;
x=1ll*x*x%mod;y>>=1;
}
return ret;
}
template<class Ta,class Tb>void inc(Ta&a,Tb b){a=a+b>=mod?a+b-mod:a+b;}
template<class Ta,class Tb>void dec(Ta&a,Tb b){a=a>=b?a-b:a+mod-b;}
#endif
int n,D1,D2,N,x[360001],y[360001],c[2][360001];
std::vector<int>vec[4];
void getcol(int D,int*c){
int A=1;
while(D%4==0)D>>=2,A<<=1;
for(int i=1;i<=N;++i)
if(D%4==1)c[i]=((x[i]/A)+(y[i]/A))&1;
else c[i]=(x[i]/A)&1;
}
int main(){
#ifdef LOCAL
freopen("in.in","r",stdin);
//freopen("out.out","w",stdout);
#endif
n=gi(),D1=gi(),D2=gi(),N=n*n*4;
for(int i=1;i<=N;++i)x[i]=(i-1)/(2*n),y[i]=(i-1)%(2*n);
getcol(D1,c[0]),getcol(D2,c[1]);
for(int i=1;i<=N;++i)vec[(c[0][i]<<1)|c[1][i]].push_back(i);
for(int i=0;i<4;++i)
if(vec[i].size()>=n*n){
N=n*n;
for(int j:vec[i]){
printf("%d %d\n",x[j],y[j]);
if(!--N)break;
}
exit(0);
}
return 0;
}
| #include<cstdio>
#define N 600
int a[2][2],i,j,m,n,o,p,x,y;bool b[N][N],c[N][N];
int main()
{
scanf("%d%d%d",&n,&o,&p),m=n<<1;
while(~o&1)o>>=1,x++;
while(~p&1)p>>=1,y++;
if(x&y&1)for(i=0,x=1<<(x>>1),y=1<<(y>>1);i<m;i++)for(j=0;j<m;j++)a[b[i][j]=i&x][c[i][j]=i&y]++;
else if(x&1)for(i=0,x=1<<(x>>1),y=1<<(y>>1);i<m;i++)for(j=0;j<m;j++)a[b[i][j]=i&x][c[i][j]=i+j&y]++;
else if(y&1)for(i=0,x=1<<(x>>1),y=1<<(y>>1);i<m;i++)for(j=0;j<m;j++)a[b[i][j]=i+j&x][c[i][j]=i&y]++;
else for(i=0,x=1<<(x>>1),y=1<<(y>>1);i<m;i++)for(j=0;j<m;j++)a[b[i][j]=i+j&x][c[i][j]=i+j&y]++;
if(a[0][0]>=n*n)x=y=0;
else if(a[0][1]>=n*n)x=0,y=1;
else if(a[1][0]>=n*n)x=1,y=0;
else x=y=1;
for(i=0,n*=n;i<m&&n;i++)for(j=0;j<m&&n;j++)if(b[i][j]==x&&c[i][j]==y)n--,printf("%d %d\n",i,j);
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;using ll=int_fast64_t;using ld=long double;using pll=pair<ll,ll>;using pld=pair<ld,ld>;
const ll INF=1LL<<60;void solve();int main(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(10);solve();}
#define foreach(i,a) for(auto &i:a)
#define SELECTOR(_1,_2,_3,_4,SELECT,...) SELECT
#define rep(...) SELECTOR(__VA_ARGS__,_rep2,_rep1,_rep0)(__VA_ARGS__)
#define _rep0(i,n) for(ll i=0;i<n;++i)
#define _rep1(i,k,n) for(ll i=k;i<n;++i)
#define _rep2(i,k,n,d) for(ll i=k;d!=0&&d>0?i<n:i>n;i+=d)
template<class T> vector<T> make_v(size_t a,T b){return vector<T>(a,b);}
template<class... Ts> auto make_v(size_t a,Ts... ts){return vector<decltype(make_v(ts...))>(a,make_v(ts...));}
template<class T> inline bool chmax(T &a,const T &b){if(a<b){a=b; return 1;} return 0;}
template<class T> inline bool chmin(T &a,const T &b){if(a>b){a=b; return 1;} return 0;}
void solve(){
ll n; cin>>n;
string S; cin>>S;
ll q; cin>>q;
rep(_,q){
ll k; cin>>k;
vector<ll> DMC(3);
ll cnt=0;
ll ans=0;
queue<char> Q;
foreach(s,S){
// push
if(s=='D'){
DMC[0]++;
}else if(s=='M'){
DMC[1]++;
cnt+=DMC[0];
}else if(s=='C'){
DMC[2]++;
ans+=cnt;
}
Q.push(s);
// pop
if(Q.size()<k) continue;
char t=Q.front(); Q.pop();
if(t=='D'){
DMC[0]--;
cnt-=DMC[1];
}else if(t=='M'){
DMC[1]--;
}else if(t=='C'){
DMC[2]--;
}
}
cout<<ans<<"\n";
}
} | #include <cstdio>
#include <iostream>
#include <vector>
#include <set>
using namespace std;
#define M 100000
vector<int> G[M];
int N;
bool visited[M];
int prenum[M], parent[M], lowest[M], timer;
void dfs(int current, int prev){
//?????????current????¨???????????????¨?????????
prenum[current] = lowest[current] = timer;
timer++;
visited[current] = true;
int next;
for(int i=0; i<G[current].size(); ++i){
next = G[current][i];
if( !visited[next] ){
//?????????current???????????????next????¨????????????´????????????
parent[next] = current;
dfs(next, current);
//?????????next?????¢?´¢????????????????????¨?????????
lowest[current] = min(lowest[current], lowest[next]);
}
else if( next != prev){ //??¨??????current --> next ???Back-Edge?????´???
lowest[current] = min(lowest[current], prenum[next]);
}
}
//?????????current ?????¢?´¢????????????????????¨?????????
}
void art_points(){
for(int i=0; i<N; ++i) visited[i] = false;
timer=1;
//lowest????¨????
dfs(0, -1); //0 == root
set<int> ap;
int np=0;
for(int i=1; i<N; ++i){
int p = parent[i];
if(p==0) np++;
else if(prenum[p] <= lowest[i]) ap.insert(p);
}
if(np>1) ap.insert(0);
for(set<int>::iterator it = ap.begin(); it!=ap.end(); ++it) cout << *it << endl;
}
int main(){
int m;
scanf(" %d %d", &N, &m);
for(int i=0; i<m; ++i){
int s, t;
scanf(" %d %d", &s, &t);
G[s].push_back(t);
G[t].push_back(s);
}
art_points();
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
using pll = pair<ll,ll>;
#define INF (1LL << 60)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define REP(i,m,n) for(ll (i)=(m),(i_len)=(n);(i)<(i_len);++(i))
#define FORR(i,v) for(auto (i):v)
#define ALL(x) (x).begin(), (x).end()
#define PR(x) cout << (x) << endl
#define PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
#define REV(x) reverse(ALL((x)))
#define ASC(x) sort(ALL((x)))
#define DESC(x) ASC((x)); REV((x))
#define pb push_back
#define eb emplace_back
int main()
{
ll H, W;
cin >> H >> W;
mat A(H, vec(W, 0));
REP(i,0,H) {
REP(j,0,W) {
cin >> A[i][j];
A[i][j] %= 2;
}
}
mat Z;
REP(i,0,H) {
bool f = false;
REP(j,0,W-1) {
vec z = {i+1, j+1, i+1, j+2};
if(A[i][j] == 1) {
if(!f) {
A[i][j] = 0;
f = true;
}
else {
A[i][j] = 0;
f = false;
}
}
if(f) Z.pb(z);
}
if(f) A[i][W-1] = 1 - A[i][W-1];
}
bool f = false;
REP(i,0,H-1) {
vec z = {i+1, W, i+2, W};
if(A[i][W-1] == 1) {
if(!f) {
A[i][W-1] = 0;
f = true;
}
else {
A[i][W-1] = 0;
f = false;
}
}
if(f) Z.pb(z);
}
if(f) A[H-1][W-1] = 1 - A[H-1][W-1];
PR(SZ(Z));
REP(i,0,SZ(Z)) {
PS(Z[i][0]); PS(Z[i][1]); PS(Z[i][2]); PR(Z[i][3]);
}
return 0;
}
/*
*/ | #include<bits/stdc++.h>
using namespace std;
#define int long long
signed main(){
int H,W;
cin>>H>>W;
vector<vector<int>> A(H,vector<int>(W));
for(vector<int> &v:A)
for(int &i:v)
cin>>i;
int k=0;
vector<vector<int>> B(0);
for(int i=0;i<H;i++){
for(int j=0;j<W-1;j++){
if(A[i][j]%2==1){
k++;
A[i][j+1]+=A[i][j];
B.push_back({i+1,j+1,i+1,j+2});
}
}
if(A[i][W-1]%2==1 && i!=H-1){
k++;
A[i+1][W-1]+=A[i][W-1];
B.push_back({i+1,W,i+2,W});
}
}
cout<<k<<endl;
for(vector<int> v:B)
cout<<v[0]<<' '<<v[1]<<' '<<v[2]<<' '<<v[3]<<endl;
} | 1 |
#include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
using namespace std;
#define int long long
#define REP(i,m,n) for(int i=(m);i<(n);i++)
#define rep(i,n) REP(i,0,n)
#define pb push_back
#define all(a) a.begin(),a.end()
#define rall(c) (c).rbegin(),(c).rend()
#define mp make_pair
#define endl '\n'
typedef long long ll;
typedef pair<ll,ll> pll;
typedef long double ld;
const ll inf=1e9+7;
const ll mod=1e9+7;
signed main(){
ll n;cin>>n;
cout<<0<<endl;
string s;cin>>s;
if(s=="Vacant"){
return 0;
}
cout<<n/2<<endl;
string t;cin>>t;
if(t=="Vacant"){
return 0;
}
ll l,r;
if(n/2%2){
if(s==t){
l=0,r=n/2;
}else{
l=n/2;
r=n-1;
cout<<n-1<<endl;
cin>>s;
if(s=="Vacant"){
return 0;
}
swap(s,t);
}
}else{
if(s!=t){
l=0,r=n/2;
}else{
l=n/2;
r=n-1;
cout<<n-1<<endl;
cin>>s;
if(s=="Vacant"){
return 0;
}
swap(s,t);
}
}
while(1){
ll mid=(r+l)/2;
cout<<mid<<endl;
string d;
cin>>d;
if(d=="Vacant"){
return 0;
}
if((mid-l)%2){
if(d==s){
r=mid;
t=d;
}else{
l=mid;
s=d;
}
}else{
if(d==s){
l=mid;
s=d;
}else{
r=mid;
t=d;
}
}
}
} | #include<bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
const ll mod=1000000007;
const int MAX_N = 1000; // n の最大値
// nCk を取得
double nCk(int n, int k) {
double res=1.0;
for(int i=0; i<n; i++){
res*=0.5;}
for(int i=0; i<k; i++){
res*=(double)(n-i);
res/=(double)(k-i);
}
return res;}
int main() {
ll h,w,n;
cin>>h>>w>>n;
ll ans=0;
if(h>w){
if(n%h==0){
ans = n/h;}
else{
ans = n/h +1;}}
else{
if(n%w==0){
ans = n/w;}
else{
ans = n/w +1;}}
cout << ans << endl;}
| 0 |
#include <bits/stdc++.h>
#ifdef LOCAL_DEBUG
#define DEBUG 1
#define CERR if(DEBUG) cerr
#define MACRO(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,NAME,...) NAME
#define pr(...) CERR<<MACRO(__VA_ARGS__,pr10,pr9,pr8,pr7,pr6,pr5,pr4,pr3,pr2,pr1)(__VA_ARGS__)<<endl
#define pr1(a) (#a)<<"="<<(a)<<" "
#define pr2(a,b) pr1(a)<<pr1(b)
#define pr3(a,b,c) pr1(a)<<pr2(b,c)
#define pr4(a,b,c,d) pr1(a)<<pr3(b,c,d)
#define pr5(a,b,c,d,e) pr1(a)<<pr4(b,c,d,e)
#define pr6(a,b,c,d,e,f) pr1(a)<<pr5(b,c,d,e,f)
#define pr7(a,b,c,d,e,f,g) pr1(a)<<pr6(b,c,d,e,f,g)
#define pr8(a,b,c,d,e,f,g,h) pr1(a)<<pr7(b,c,d,e,f,g,h)
#define pr9(a,b,c,d,e,f,g,h,i) pr1(a)<<pr8(b,c,d,e,f,g,h,i)
#define pr10(a,b,c,d,e,f,g,h,i,j) pr1(a)<<pr9(b,c,d,e,f,g,h,i,j)
#define prArr(a){CERR<<(#a)<<"={";int i=0;for(auto t:(a))CERR<<(i++?", ":"")<<t;CERR<<"}"<<endl;}
#else
#define DEBUG 0
#define pr(...)
#define prArr(a)
#endif
using namespace std;
using Int = long long;
using _int = int;
using ll = long long;
using Double = long double;
const Int INF = (1LL<<60)+1e9; // ~ 1.15 * 1e18
const Int mod = (1e9)+7;
const Double EPS = 1e-8;
const Double PI = 6.0 * asin((Double)0.5);
using P = pair<Int,Int>;
template<class T> T Max(T &a,T b){return a=max(a,b);}
template<class T> T Min(T &a,T b){return a=min(a,b);}
template<class T1, class T2> ostream& operator<<(ostream& o,pair<T1,T2> p){return o<<"("<<p.first<<","<<p.second<<")";}
template<class T1, class T2, class T3> ostream& operator<<(ostream& o,tuple<T1,T2,T3> t){return o<<"("<<get<0>(t)<<","<<get<1>(t)<<","<<get<2>(t)<<")";}
template<class T1, class T2> istream& operator>>(istream& i,pair<T1,T2> &p){return i>>p.first>>p.second;}
template<class T> ostream& operator<<(ostream& o,vector<T> a){Int i=0;for(T t:a)o<<(i++?" ":"")<<t;return o;}
template<class T> istream& operator>>(istream& i,vector<T> &a){for(T &t:a)i>>t;return i;}
//INSERT ABOVE HERE
Int sim(vector<Int> A){
Int N = A.size();
Int k = 0;
while(1){
Int idx = 0;
for(Int i=0;i<N;i++) if(A[idx] < A[i]) idx = i;
if(A[idx] < N) return k;
k++;
for(Int i=0;i<N;i++) A[i]++;
A[idx] -= (N + 1);
pr(k, A);
}
}
vector<Int> sim(vector<Int> A, Int K){
Int N = A.size();
for(Int i=0;i<K;i++){
Int idx = 0;
for(Int i=0;i<N;i++) if(A[idx] < A[i]) idx = i;
for(Int i=0;i<N;i++) A[i]++;
A[idx] -= (N + 1);
}
return A;
}
signed main(){
srand((unsigned)time(NULL));
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
if(0){
Int N;
cin>>N;
vector<Int> A(N);
cin>>A;
sim(A);
}
Int K;
cin>>K;
Int n = 50;
vector<Int> ans(n, 0);
for(Int i=0;i<n;i++){
ans[i] = ((K-1) / n + 1) + n - 1;
}
ans = sim(ans, (n - K % n) % n);
if(K == 0) ans = vector<Int>(n, 0);
cout<<n<<endl;
cout<<ans<<endl;
//assert(sim(ans) == K);
return 0;
}
| /*First observation is that little numbers should be summed up to go to above 3
* any number above 3 is better multiplied
* also given a set of numbers to add, the best pairs to pick are least with most since we will multiply them next
* also if the number of numbers we are going to add is N
* then the numbers we will add are the first N numbers given that the array is sorted
* so we just bruteforce on N
*
*/
#include <bits/stdc++.h>
#include <complex>
using namespace std;
typedef long long int ll;
const double PI = acos(-1);
const int N = 2e6, MOD = 1e6 + 3, LOG = 21;
ll k, mvup, toAdd;
bool chn = false;
vector<ll> v;
int main() {
//freopen("input.txt", "r", stdin);
scanf("%lld", &k);
while (k % 50 != 0) {
k++;
mvup++;
}
ll N = 50;
ll base = N - 1;
ll needed = k / N;
printf("%lld\n", N);
for (int i = 0; i < N; i++) {
v.push_back(base + needed);
}
toAdd = mvup;
for (int i = 0; i < N; i++) {
if (mvup) {
v[i] -= N;
mvup--;
v[i] += (toAdd - 1);
} else {
v[i] += toAdd;
}
}
for (int i = 0; i < N; i++) {
printf("%lld ", v[i]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T random(T lo, T hi) {
std::random_device rd;
std::uniform_int_distribution<T> uid(lo, hi);
return uid(rd);
}
class RollingHash {
private:
const uint64_t mod = (UINT64_C(1) << 61) - 1;
static inline uint64_t base = random(UINT32_C(10007), UINT32_MAX);
std::vector<uint64_t> hashes, pows;
inline uint64_t add(uint64_t a, uint64_t b) const {
a += b;
if (a >= mod) a -= mod;
return a;
}
inline uint64_t sub(uint64_t a, uint64_t b) const {
if (a < b) a += mod;
a -= b;
return a;
}
inline uint64_t mul(uint64_t a, uint64_t b) const {
uint64_t ah = a >> 31, al = a & ((UINT64_C(1) << 31) - 1), bh = b >> 31,
bl = b & ((UINT64_C(1) << 31) - 1), m = ah * bl + al * bh,
v = (ah * bh << 1) + (m >> 30) +
((m & ((UINT64_C(1) << 30) - 1)) << 31) + al * bl;
v = (v & ((UINT64_C(1) << 61) - 1)) + (v >> 61);
return v;
}
public:
template <typename T>
RollingHash(const T &S) : hashes(S.size() + 1, 0), pows(S.size() + 1, 0) {
pows[0] = 1;
for (size_t i = 0; i < S.size(); i++) {
pows[i + 1] = mul(pows[i], base);
hashes[i + 1] = add(mul(hashes[i], base), S[i]);
}
// cout << base << '\n';
}
// S[l, r)
uint64_t slice(int l, int r) const {
return sub(hashes[r], mul(hashes[l], pows[r - l]));
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
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];
}
vector<int> S(N), T(N);
for (int i = 0; i < N; i++) {
S[i] = A[i] ^ A[(i + 1) % N];
T[i] = B[i] ^ B[(i + 1) % N];
}
for (int i = 0; i < N; i++) {
S.emplace_back(S[i]);
}
RollingHash rhs(S), rht(T);
for (int i = 0; i < N; i++) {
if (rhs.slice(i, i + N) == rht.slice(0, N)) {
cout << i << ' ' << (A[i] ^ B[0]) << '\n';
}
}
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define INF 2e9
#define MOD 1000000007
#define ALL(v) v.begin(), v.end()
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using P = pair<int,int>;
int main()
{
int N;
cin >> N;
vector<int> A(N);
REP(i, N) cin >> A[i];
int flag = (A[0]!=0);
REP(i,N-1){
if(A[i]+2<=A[i+1]){
flag=1;
}
}
if(flag==1){
cout << -1 << endl;
}else{
ll ans = 0;
A.push_back(0);
REP(i,N){
if((A[i]>=A[i+1])){
ans+=A[i];
}
}
cout << ans << endl;
}
} | 0 |
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
class Node{
public:
vector< int > e_to;
vector< int > e_cost;
bool def;
int min_cost;
Node(){
def = false;
min_cost = -1;
}
};
bool operator==(const Node& ot1, const Node& ot2){
return ot1.min_cost == ot2.min_cost;
}
bool operator!=(const Node& ot1, const Node& ot2){
return !(ot1 == ot2);
}
bool operator<(const Node& ot1, const Node& ot2){
return ot1.min_cost < ot2.min_cost;
}
bool operator>(const Node& ot1, const Node& ot2){
return ot1.min_cost > ot2.min_cost;
}
bool operator<=(const Node& ot1, const Node& ot2){
return !(ot1 > ot2);
}
bool operator>=(const Node& ot1, const Node& ot2){
return !(ot1 < ot2);
}
int main(){
int v, e, r, s, t, d;
vector< Node > nodes;
priority_queue< Node, vector< Node >, greater< Node > > que;
cin >> v >> e >> r;
nodes.resize(v);
for(int i = 0; i < v; ++i){
nodes[i] = Node();
}
for(int i = 0; i < e; ++i){
cin >> s >> t >> d;
nodes[s].e_to.push_back(t);
nodes[s].e_cost.push_back(d);
}
nodes[r].min_cost = 0;
que.push(nodes[r]);
while(!que.empty()){
Node def_node = que.top();
que.pop();
if(def_node.def)continue;
def_node.def = true;
for(int i = 0; i < def_node.e_to.size(); ++i){
int to = def_node.e_to[i];
int cost = def_node.min_cost + def_node.e_cost[i];
if(nodes[to].min_cost == -1 || cost < nodes[to].min_cost){
nodes[to].min_cost = cost;
que.push(nodes[to]);
}
}
}
for(int i = 0; i < v; ++i){
if(nodes[i].min_cost == -1) cout << "INF" << endl;
else cout << nodes[i].min_cost << endl;
}
return 0;
} | #include<iostream>
#include<algorithm>
using namespace std;
int n,m;
int a[100][100],b[100][100];
main()
{
while(cin>>m>>n,n)
{
for(int i=0;i<n;i++)for(int j=0;j<n;j++)
{
if(i==j)continue;
a[i][j]=1e9;
b[i][j]=1e9;
}
for(int i=0;i<m;i++)
{
int s,t,u,v;cin>>s>>t>>u>>v;
s--,t--;
a[s][t]=min(a[s][t],u);
a[t][s]=min(a[t][s],u);
b[s][t]=min(b[s][t],v);
b[t][s]=min(b[t][s],v);
}
for(int k=0;k<n;k++)for(int i=0;i<n;i++)for(int j=0;j<n;j++)
{
a[i][j]=min(a[i][j],a[i][k]+a[k][j]);
b[i][j]=min(b[i][j],b[i][k]+b[k][j]);
}
int k;cin>>k;
for(;k--;)
{
int p,q,r;cin>>p>>q>>r;
p--,q--;
if(r)cout<<b[p][q]<<endl;
else cout<<a[p][q]<<endl;
}
}
}
| 0 |
#pragma GCC target ("avx2")
#pragma GCC optimize ("unroll-loops")
#pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include <unordered_set>
#include <unordered_map>
#include <random>
using namespace std;
typedef long long ll;
const ll MOD = 1'000'000'007LL; /*998'244'353LL;*/
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for(int (i)=0; (i)<(n); (i)++)
const int dx[4]={ 1,0,-1,0 };
const int dy[4]={ 0,1,0,-1 };
int N, H, W;
signed main(){
cin >> N >> H >> W;
cout << max(0, N-H+1)*max(0, N-W+1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n,h,w;
cin >> n >> h >> w;
int a = 0;
int b = 0;
for(int i = 1; i <= n; i++){
if(i+w-1 <= n) a++;
if(i+h-1 <= n) b++;
}
cout << a*b << endl;
return 0;
} | 1 |
#include<iostream>
using namespace std;
int main() {
int n,a[101];
cin >> n;
for ( int i = 0; i < n; i++ ) {
cin >> a[i];
}
for ( int i = 0; i < n; i++ ) {
cout << a[n - i -1];
if ( i != n - 1 ) cout << " ";
}
cout << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int abs(int x) {
if (x < 0) {
return -x;
} else {
return x;
}
}
int main() {
int N;
cin >> N;
vector<int> a(N);
for (int i = 0; i < N; i++) {
cin >> a.at(i);
}
int sum = 0;
for (int i = 0; i < N; i++) {
sum = sum + a.at(i);
}
int ans = 100000;
int memo;
for (int i = 0; i < N; i++) {
if (ans > abs(a.at(i)*N-sum)) {
ans = abs(a.at(i)*N-sum);
memo = i;
}
}
cout << memo << endl;
}
| 0 |
# include <iostream>
# include <algorithm>
# include <vector>
# include <string>
# include <set>
# include <cmath>
# include <iomanip>
# include <functional>
# include <utility>
using namespace std;
int main() {
int m, d;
while (cin >> m >> d&&m != 0 && d != 0) {
int sum = 0;
for (int i = 1; i < m; i++) {
if (i == 1 || i == 3 || i == 5 || i == 7 || i == 8 || i == 10 || i == 12) {
sum += 31;
}
else if (i == 2) {
sum += 29;
}
else {
sum += 30;
}
}
sum += d;
if (sum % 7 == 1) {
cout << "Thursday" << endl;
}
else if (sum % 7 == 2) {
cout << "Friday" << endl;
}
else if (sum % 7 == 3) {
cout << "Saturday" << endl;
}
else if (sum % 7 == 4) {
cout << "Sunday" << endl;
}
else if (sum % 7 == 5) {
cout << "Monday" << endl;
}
else if (sum % 7 == 6) {
cout << "Tuesday" << endl;
}
else {
cout << "Wednesday" << endl;
}
}
} | #include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
int main(){
int a,b,month[]={0,31,29,31,30,31,30,31,31,30,31,30,31};
string week[]={"Wednesday","Thursday","Friday","Saturday","Sunday","Monday","Tuesday"};
while(cin>>a>>b){
if(a==0 && b==0)break;
for(int i=1;i<a;i++){
b+=month[i];
}
cout<<week[b%7]<<endl;
}
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <string>
#include <cmath>
using namespace std;
using Int = long long int;
using UInt = unsigned long long int;
using VI = vector<long long int>;
int main(void) {
Int r;
cin >> r;
if (r < 1200) {
cout << "ABC" << endl;
} else if (r < 2800) {
cout << "ARC" << endl;
} else {
cout << "AGC" << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(ll i = a; i < b; i++)
#define Rep(i, a, b) for(ll i = a; i <= b; i++)
#define repr(i, a, b) for(ll i = b-1; i >= a; i--)
#define _GLIBCXX_DEBUG
#define Vl vector<ll>
#define Vs vector<string>
#define Vp vector<pair<ll, ll>>
using ll = long long;
#define ALL(v) (v).begin(),(v).end()
#define endl "\n"
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define co(x) cout << x << endl
#define coel cout << endl
#define pb push_back
#define sz(v) ((ll)(v).size())
const double pi = acos(-1.0);
const ll MOD = 1e9 + 7;
// const ll INF = 1LL << 60;
const ll INF = 100000000000;
#define pp pair<ll, pair<ll, ll>>
// #define fi first
// #define se second
/*--------------------------------------------------------------------------------
--------------------------------------------------------------------------------*/
bool IsPrime(int n){
if (n<2) return false;
else if (n==2) return true;
else if (n%2==0) return false;
double q=sqrt(n);
for(int i=3;i<q+1;i+=2){
if(n%i==0){
return false;
}
}
return true;
}
int main(){
// 1~55555 で 5の倍数+1 の素数を列挙
Vl sosu;
for(ll i = 1; i <= 55555; i += 5){
if(IsPrime(i)) sosu.push_back(i);
}
ll n; cin >> n;
rep(i, 0, n) cout << sosu[i] << " \n"[i==n-1];
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod ll(1e9+7)
ll exp(ll a,ll b)
{
if(b==0)
return 1;
if(b%2==0)
return exp(a*a%mod,b/2);
return a*exp(a*a%mod,(b-1)/2)%mod;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
int n,k;
cin>>n>>k;
vector<int>arr(n+1);
for(int i=1; i<=n; i++){
cin>>arr[i];
}
int mx=0;
for(int i=0; i<=k; i++){
for(int j=0; j<=(k-i); j++){
if(i+j>=n){
vector<int>ans;
int sum=0;
for(int x=1; x<=n; x++){
sum+=arr[x];
ans.push_back(arr[x]);
}
sort(ans.begin(),ans.end());
int num=min(n,k-n);
for(int x=0; x<num; x++){
if(ans[x]>=0)
break;
sum-=ans[x];
}
mx=max(sum,mx);
}
else{
vector<int>ans;
int sum=0;
for(int x=1; x<=i; x++){
ans.push_back(arr[x]);
sum+=arr[x];
}
for(int x=n; x>=(n-j+1); x--){
ans.push_back(arr[x]);
sum+=arr[x];
}
int num=min(i+j,k-(i+j));
sort(ans.begin(),ans.end());
for(int x=0; x<num; x++){
if(ans[x]>=0)
break;
sum-=ans[x];
}
mx=max(sum,mx);
}
}
}
cout<<mx;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF 1e9
typedef long long ll;
int main() {
int N,K;
cin >> N >> K;
deque<int> V_origin;
REP(i,N){
int v;
cin >> v;
V_origin.push_back(v);
}
int ans = 0;
int KK = K;
K = min(K,N);
REP(i,K/2+1){
REP(j,K-i+1){
//cout << "front: "<< j << ", back: " << K-i-j << ", return: " << i << endl;
deque<int> V(V_origin);
vector<int> my;
REP(k,j){
int d = V.front();
V.pop_front();
my.push_back(d);
}
FOR(k,j+1,K-i+1){
int d = V.back();
V.pop_back();
my.push_back(d);
}
sort(ALL(my));
REP(x,KK-K+i+1){
int count = 0;
FOR(k,x,my.size()){
count += my[k];
}
ans = max(ans,count);
//cout << count << endl;
}
}
}
ans = max(ans, 0);
cout << ans << endl;
return 0;
} | 1 |
#include <cstdio>
#include <algorithm>
#define INF 2147483647
#define max_n 1000000
using namespace std;
int a[max_n+1];
long long psm[max_n+2],nsm[max_n+2];
long long calc(long long a,long long b,long long c,long long d){
a>b&&(swap(a,b),1),c>d&&(swap(c,d),1);
return max(b,d)-min(a,c);
}
template<typename T>void minify(T&x,const T&y){
y<x&&(x=y);
}
int main(){
int n,i;
scanf("%d",&n),psm[0]=0;
for(int i=0; ++i<=n; psm[i]=psm[i-1]+a[i])
scanf("%d",a+i);
nsm[n+1]=0;
for(int i=n+1; --i; nsm[i]=nsm[i+1]+a[i]);
long long x,y,ans=INF;
for(int j=0,i=0,k=0; ++j<=n; minify(ans,calc(psm[i],psm[j]-psm[i],psm[k]-psm[j],psm[n]-psm[k]))){
for(y=(x=psm[j])>>1; psm[++i]<=y; );
y-psm[i-1]<psm[i]-y&&(--i);
for(y=(x=nsm[j+1])>>1; nsm[++k+1]>y; );
nsm[k]-y<=y-nsm[k+1]&&(--k);
// printf("*(%d,%d,%d)\n",i,j,k);
}
printf("%lld\n",ans);
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define all(c) c.begin(),c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
using namespace std;
template<class S,class T> ostream& operator<<(ostream& o,const pair<S,T> &p){return o<<"("<<p.fs<<","<<p.sc<<")";}
template<class T> ostream& operator<<(ostream& o,const vector<T> &vc){o<<"sz = "<<vc.size()<<endl<<"[";for(const T& v:vc) o<<v<<",";o<<"]";return o;}
vector<int> c2is[26];
vector<int> ls,rs;
int N;
string S,T;
int solve(){
cin>>N;
cin>>S>>T;
if(S==T){
return 0;
}
rep(i,N){
c2is[S[i]-'a'].pb(i);
}
int now=N-1;
int r=N-1;
for(int i=N-2;i>=-1;i--){
if(i==-1 || T[i]!=T[i+1]){
int l=i+1;
int c = T[i+1] -'a';
int id = upper_bound(all(c2is[c]),min(now,l))-c2is[c].begin()-1;
if(id==-1){
return -1;
}
int v = c2is[c][id];
// show(l);
// show(r);
// show(v);
// puts("");
ls.pb(v);
rs.pb(r);
r=i;
now=v-1;
}
}
reverse(all(ls));
reverse(all(rs));
int K=ls.size();
// show(ls);
// show(rs);
rep(i,K) ls[i]-=i;
int ans=0;
rep(i,K){
int r = rs[i];
int id = lower_bound(all(ls),r-i)-ls.begin()-i;
// show(id);
chmax(ans,id);
}
return ans;
}
int main(){
cout<<solve()<<endl;
} | 0 |
//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx,avx2,fma")
#pragma GCC optimize("O3")
#include<iostream>
#include<algorithm>
#include<string>
#include<cmath>
#include<cstdlib>
#include<set>
#include<vector>
#include<sstream>
#include<queue>
#include <iomanip>
#include<unordered_set>
#include <stack>
#include <unordered_map>
#include <map>
#include<numeric>
#include<chrono>
#include <fstream>
constexpr auto INF = 9223372036854775807;
typedef long long int ll;
typedef unsigned long long int ull;
typedef unsigned long int ul;
#define f(i,a,b) for(ll i=(ll)a;i<(ll)b;i+=1)
#define rf(i,a,b) for(ll i=(ll)a;i>=(ll)b;i-=1)
#define endl '\n'
#define N 1000000007 // prime modulo value
#define M 998244353
#define all(x) x.begin(),x.end()
#define mkp(a,b) make_pair(a,b)
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
inline int mex(unordered_set<int> st)
{
int m = 0;
while (st.find(m) != st.end())
{
m += 1;
}
return m;
}
inline int calculateGrundy(int n)
{
if (n == 1)
return 0;
unordered_set<int> mexi;
for (int i = 1; i <= sqrt(n); i += 1)
{
if (n % i == 0)
{
if (n / i != n)
mexi.insert(calculateGrundy(n / i));
mexi.insert(calculateGrundy(i));
}
}
return mex(mexi);
}
inline ll gcd(ll a, ll b)
{
// This is code taken from geeksforgeek
if (b == 0)
return a;
return gcd(b, a % b);
}
/*ll power(ll x, ll y)
{
// This is code taken from geeksforgeek
ll res = 1;
x = x % N;
if (x == 0) return 0;
while (y > 0)
{
if (y & 1)
res = (res * x) % N;
y = y >> 1;
x = (x * x) % N;
}
return res;
}*/
ll power(ll x, ll y)
{
ll res = 1;
x = x;
while (y > 0)
{
if (y & 1)
res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
/*ll modInverse(ll n, ll p)
{
return power(n, p - 2, p);
}*/
ll sum(ll n)
{
return (n * (n + 1)) / 2;
}
ll sum_digit(ll n)
{
ll ans = 0;
while (n)
{
ans += n % 10;
n /= 10;
}
return ans;
}
ll gp(ll r, ll n)
{
return (pow(r,n)-1)/(r-1);
}
int main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
ll n;
cin>>n;
vector<ll> arr(n,0);
ll sum=0;
f(i,0,n)
{
cin>>arr[i];
sum+=arr[i];
}
ll ans=0;
f(i,0,n-1)
{
sum-=arr[i];
ans+=(arr[i])*(sum%N);
ans%=N;
}
cout<<ans;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
const long mod=1e9+7;
long long sum,t;
int n;
long long a;
int main()
{
cin>>n;
while(n>0)
{
cin>>a;
(sum+=a*t)%=mod;
(t+=a)%=mod;
n--;
}
cout<<sum<<endl;
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <utility>
using namespace std;
void fnInput(int &rnMaxSiz, vector<int> &rvnNum)
{
cin >> rnMaxSiz;
rvnNum.resize(rnMaxSiz);
for (int i = 0; i < rnMaxSiz; i++)
cin >> rvnNum[i];
}
void fnPartition(vector<int> &rvnNum, int nStart, int nEnd, int &nCur)
{
for (int i = nStart; i < nEnd; i++)
if (rvnNum[i] <= rvnNum[nEnd])
swap(rvnNum[nCur++], rvnNum[i]);
swap(rvnNum[nCur], rvnNum[nEnd]);
}
void fnResult(const vector<int> &cnrvnNum, int nCur)
{
for (int i = 0; i < cnrvnNum.size(); i++)
{
if (i) cout << " ";
if (i == nCur) cout << "[";
cout << cnrvnNum[i];
if (i == nCur) cout << "]";
}
cout << endl;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int nMaxSiz;
vector<int> vnNum;
fnInput(nMaxSiz, vnNum);
int nStart = 0;
int nEnd = vnNum.size() - 1;
int nCur = nStart;
fnPartition(vnNum, nStart, nEnd, nCur);
fnResult(vnNum, nCur);
return 0;
} | #include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
int n;
vector<int> S;
int partition(int p, int r)
{
int x=S[r];
int i=p-1;
for(int j=p; j<r; j++){
if(S[j]<=x){
i++;
swap(S[i], S[j]);
}
}
swap(S[i+1], S[r]);
return i+1;
}
int main()
{
int n;
scanf("%d", &n);
S=vector<int>(n);
for(auto &it : S){
scanf("%d", &it);
}
int q=partition(0, n-1);
int i=0;
for(; i<q; i++){
if(i!=0){
printf(" ");
}
printf("%d", S[i]);
}
printf(" [%d]", S[i]);
i++;
for(; i<n; i++){
printf(" %d", S[i]);
}
printf("\n");
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long unsigned int ll;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int x;
cin >> x;
cout << x*x*x << endl;
}
| #include <iostream>
#include <math.h>
using namespace std;
int main(){
int x;
cin >> x;
x = pow(x, 3);
cout << x << "\n";
} | 1 |
#include<iostream>
using namespace std;
int main(){
int n, x, y, sumx=0, sumy=0;
while(cin >> n && n > 0){
sumx=0, sumy=0;
for(int i=0; i<n; i++){
x=0,y=0;
cin >> x >> y;
if(x > y){
sumx = sumx + x + y;
}
else if(x < y){
sumy = sumy + x + y;
}
else if(x == y){
sumx = sumx + x;
sumy = sumy + y;
}
}
cout << sumx << " " << sumy << endl;
}
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool SortComp(pair<int, int> num1, pair<int, int> num2)
{
if(num1.second > num2.second)
return true;
else if(num1.second < num2.second)
return false;
else if(num1.first < num2.first)
return true;
else
return false;
}
int main(void)
{
while(1)
{
int num, min;
cin>>num>>min;
if(num == 0 && min == 0)
break;
vector<pair<int, int> > arr(101);
for(int i= 0; i < 101; i++)
arr[i].first= i+1;
for(int i= 0; i < num; i++)
{
int days;
cin>>days;
for(int j= 0; j < days; j++)
{
int input;
cin>>input;
arr[input-1].second++;
}
}
sort(arr.begin(), arr.end(), SortComp);
if(arr[0].second < min)
cout<<0<<endl;
else
cout<<arr[0].first<<endl;
}
} | 0 |
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <random>
#include <chrono>
#include <tuple>
#include <random>
using namespace std;
typedef long long ll;
typedef long double ld;
#define fastInp cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(0);
const ll SIZE = 1e6 * 2 + 10, INF = 1e9 * 1e9 + 10;
char grid[1002][1002];
int main()
{
fastInp;
ll n;
cin >> n;
if (n == 2) {
cout << "-1";
return 0;
}
if (n == 3) {
cout << "aa.\n..b\n..b";
return 0;
}
if (n == 6) {
cout << "aa....\n";
cout << "..b...\n";
cout << "..b...\n";
cout << "...aa.\n";
cout << ".....b\n";
cout << ".....b\n";
return 0;
}
if (n == 7) {
cout << ".aabbcc\n";
cout << "d.eett.\n";
cout << "dc....k\n";
cout << "rc....k\n";
cout << "rf....d\n";
cout << "kf....d\n";
cout << "k.aabb.\n";
return 0;
}
if (n == 11) {
cout << "laabbccddee\n";
cout << "lmmrqqx...z\n";
cout << "hf.rs.x...z\n";
cout << "hfjjsmm...x\n";
cout << "g...tkkdllx\n";
cout << "g...t.fd.hy\n";
cout << "f...eefrrhy\n";
cout << "fbgg...vuut\n";
cout << "ab.q...v.pt\n";
cout << "awwq...sspu\n";
cout << "ddccbbooiiu\n";
return 0;
}
for (int i = 0; i <= n; i++) {
if (4 * i <= n) {
ll left = n - 4 * i;
if (left % 5 == 0) {
ll i2 = left / 5, prevX = 0;
for (int j = 0; j < i; j++) {
grid[prevX][prevX] = 'a'; grid[prevX + 1][prevX] = 'a'; grid[prevX + 2][prevX] = 'b'; grid[prevX + 3][prevX] = 'c';
grid[prevX][prevX + 1] = 'd'; grid[prevX + 1][prevX + 1] = 'd'; grid[prevX + 2][prevX + 1] = 'b'; grid[prevX + 3][prevX + 1] = 'c';
grid[prevX][prevX + 2] = 'a'; grid[prevX + 1][prevX + 2] = 'b'; grid[prevX + 2][prevX + 2] = 'y'; grid[prevX + 3][prevX + 2] = 'y';
grid[prevX][prevX + 3] = 'a'; grid[prevX + 1][prevX + 3] = 'b'; grid[prevX + 2][prevX + 3] = 'x'; grid[prevX + 3][prevX + 3] = 'x';
prevX += 4;
}
for (int j = 0; j < i2; j++) {
grid[prevX][prevX] = 'a'; grid[prevX + 1][prevX] = 'a'; grid[prevX + 2][prevX] = 'b'; grid[prevX + 3][prevX] = 'b'; grid[prevX + 4][prevX] = 'c';
grid[prevX][prevX + 1] = 'd'; grid[prevX + 1][prevX + 1] = '.'; grid[prevX + 2][prevX + 1] = 'f'; grid[prevX + 3][prevX + 1] = 'f'; grid[prevX + 4][prevX + 1] = 'c';
grid[prevX][prevX + 2] = 'd'; grid[prevX + 1][prevX + 2] = 'r'; grid[prevX + 2][prevX + 2] = '.'; grid[prevX + 3][prevX + 2] = '.'; grid[prevX + 4][prevX + 2] = 'z';
grid[prevX][prevX + 3] = 't'; grid[prevX + 1][prevX + 3] = 'r'; grid[prevX + 2][prevX + 3] = '.'; grid[prevX + 3][prevX + 3] = '.'; grid[prevX + 4][prevX + 3] = 'z';
grid[prevX][prevX + 4] = 't'; grid[prevX + 1][prevX + 4] = 'k'; grid[prevX + 2][prevX + 4] = 'k'; grid[prevX + 3][prevX + 4] = 'y'; grid[prevX + 4][prevX + 4] = 'y';
prevX += 5;
}
for (int i= 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] == 0) grid[i][j] = '.';
cout << grid[i][j];
}
cout << "\n";
}
return 0;
}
}
}
return 0;
} | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <iostream>
#include <fstream>
#include <bits/stdc++.h>
using namespace std;
char piece[10][10][10];
bool DONE = false;
typedef pair<int, int> pii;
vector<pair<pii, pii>> placement[10];
int done[10][10];
vector<pair<pii, pii>> doms;
class CDominoQuality {
public:
bool okrow(int n, int row) {
if (row < 0) return true;
int cnt = 0;
for (int j = 0; j < n; j++) {
if (!done[row][j]) continue;
if (j == 0 || (done[row][j] != done[row][j - 1])) cnt++;
}
return cnt == 3;
}
bool okcol(int n, int col) {
if (col < 0) return true;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (!done[i][col]) continue;
if (i == 0 || (done[i][col] != done[i - 1][col])) cnt++;
}
return cnt == 3;
}
void dfs(int n, int p) {
if (DONE) return;
if (p % n == 0) {
int row = p / n - 1;
if (!okrow(n, row - 1)) return;
if (p == n * n) {
for (int i = 0; i < n; i++) {
if (!okcol(n, i)) {
return;
}
}
placement[n] = doms;
DONE = true;
return;
}
}
dfs(n, p + 1);
int r = p / n, c = p % n;
if (c < n - 1 && !done[r][c + 1] && !done[r][c]) {
doms.push_back({{r, c}, {r, c + 1}});
done[r][c + 1] = done[r][c] = p + 1;
dfs(n, p + 1);
done[r][c + 1] = done[r][c] = 0;
doms.pop_back();
}
if (r < n - 1 && !done[r + 1][c] && !done[r][c]) {
doms.push_back({{r, c}, {r + 1, c}});
done[r + 1][c] = done[r][c] = p + 1;
dfs(n, p + 1);
done[r + 1][c] = done[r][c] = 0;
doms.pop_back();
}
}
void solve(std::istream& in, std::ostream& out) {
int n;
in >> n;
if (n == 2) {
out << -1 << endl;
return;
}
if (n == 3) {
out << "aa.\n";
out << "..b\n";
out << "..b\n";
return;
}
memset(piece, '.', sizeof piece);
for (int i = 4; i <= 7; i++) {
DONE = false;
dfs(i, 0);
for (int j = 0; j < placement[i].size(); j++) {
auto p = placement[i][j];
int r1 = p.first.first, c1 = p.first.second, r2 = p.second.first, c2 = p.second.second;
piece[i][r1][c1] = piece[i][r2][c2] = j + 'a';
}
}
int rep = n / 4 - 1, left = n % 4 + 4;
vector<vector<char>> res(n, vector<char>(n, '.'));
for (int k = 0; k < rep; k++) {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
res[k * 4 + i][k * 4 + j] = piece[4][i][j];
}
}
}
for (int i = 0; i < left; i++) {
for (int j = 0; j < left; j++) {
res[rep * 4 + i][rep * 4 + j] = piece[left][i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
out << res[i][j];
out << "\n";
}
}
};
int main() {
CDominoQuality solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 1 |
#define rep(i,n) for (int i=0;i<n;i++)
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mod 1000000007
int main(){
unsigned long long l,r;
cin >> l >> r;
unsigned long long mi=INT_MAX,i=0,j=0;
if(r/2019-l/2019!=0)
cout << 0 << endl;
else{
l%=2019;
r%=2019;
while(l+i!=r){
j=l+i;
while(j!=r){
j++;
mi=min((l+i)%2019*j%2019%2019,mi);
}
i++;
}
cout << mi << endl;
}
}
| #include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
vector<ll> a(300);
a[0] = 300000;
a[1] = 200000;
a[2] = 100000;
int x, y;
cin >> x >> y; x--; y--;
ll ans = a[x] + a[y];
if(x == y && x == 0)ans += 400000;
cout << ans << endl;
} | 0 |
#include <cstdio>
#include <cstring>
#include <algorithm>
const int MOD = 998244353;
const int MAXN = 5e5 + 10;
int n, m;
namespace {
inline int add(int x) { return x >= MOD ? x - MOD : x; }
inline int sub(int x) { return x < 0 ? x + MOD : x; }
inline int mul(int x, int y) { return 1ll * x * y % MOD; }
inline int pwr(int x, int y) {
int ans = 1;
for (; y; y >>= 1, x = mul(x, x)) {
if (y & 1) ans = mul(ans, x);
}
return ans;
}
}
int fact[MAXN << 1], invf[MAXN << 1];
int choose(int x, int y) {
return x < y ? 0 : mul(fact[x], mul(invf[y], invf[x - y]));
}
int main() {
scanf("%d%d", &n, &m);
fact[0] = 1, invf[0] = 1;
if (n < m) std::swap(n, m);
for (int i = 1; i <= 2 * n; i++) {
fact[i] = mul(fact[i - 1], i);
invf[i] = pwr(fact[i], MOD - 2);
}
int ans = 0;
for (int i = 1; i <= m; i++) {
ans = add(ans + mul(choose(2 * i - 1, i), choose(n + m - 2 * i, n - i)));
}
printf("%d\n", add(n + mul(ans, pwr(choose(n + m, n), MOD - 2))));
}
| #include <iostream>
#include <cstdio>
#include <cstring>
#define ll long long
#define ls(_o) (_o << 1)
#define rs(_o) ((_o << 1) | 1)
#define abs(_o) ((_o < 0) ? -(_o) : _o)
using namespace std;
namespace ywy {
inline int get() {
int n = 0;
char c;
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
break;
if (c == '-')
goto s;
}
n = c - '0';
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
n = n * 10 + c - '0';
else
return (n);
}
s:
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
n = n * 10 - c + '0';
else
return (n);
}
}
ll min1[1000001], min2[1000001], adds[1000001];
int x[200001];
inline void down(int tree) {
if (!adds[tree])
return;
ll c = adds[tree];
adds[tree] = 0;
adds[ls(tree)] += c;
adds[rs(tree)] += c;
min1[ls(tree)] += c;
min2[ls(tree)] += c;
min1[rs(tree)] += c;
min2[rs(tree)] += c;
}
inline void up(int tree) {
min1[tree] = min(min1[ls(tree)], min1[rs(tree)]);
min2[tree] = min(min2[ls(tree)], min2[rs(tree)]);
}
void setpt(int l, int r, int tree, int pt, ll num) {
if (l == r) {
min1[tree] = min(min1[tree], num - l);
min2[tree] = min(min2[tree], num + l);
return;
}
int mid = (l + r) >> 1;
down(tree);
if (pt <= mid)
setpt(l, mid, ls(tree), pt, num);
else
setpt(mid + 1, r, rs(tree), pt, num);
up(tree);
}
ll query1(int rl, int rr, int l, int r, int tree) {
if (rl == l && rr == r)
return (min1[tree]);
int mid = (l + r) >> 1;
down(tree);
if (rl > mid)
return (query1(rl, rr, mid + 1, r, rs(tree)));
if (rr <= mid)
return (query1(rl, rr, l, mid, ls(tree)));
return (min(query1(rl, mid, l, mid, ls(tree)), query1(mid + 1, rr, mid + 1, r, rs(tree))));
}
ll query2(int rl, int rr, int l, int r, int tree) {
if (rl == l && rr == r)
return (min2[tree]);
int mid = (l + r) >> 1;
down(tree);
if (rl > mid)
return (query2(rl, rr, mid + 1, r, rs(tree)));
if (rr <= mid)
return (query2(rl, rr, l, mid, ls(tree)));
return (min(query2(rl, mid, l, mid, ls(tree)), query2(mid + 1, rr, mid + 1, r, rs(tree))));
}
ll query(int l, int r, int tree) {
if (l == r)
return (min1[tree] + l);
int mid = (l + r) >> 1;
down(tree);
return (min(query(l, mid, ls(tree)), query(mid + 1, r, rs(tree))));
}
void ywymain() {
int n = get(), q = get(), a = get(), b = get();
x[0] = a;
memset(min1, 0x3f, sizeof(min1));
memset(min2, 0x3f, sizeof(min2));
setpt(1, n, 1, b, 0);
for (register int i = 1; i <= q; i++) {
x[i] = get();
ll cjr = min(query1(1, x[i], 1, n, 1) + x[i], query2(x[i], n, 1, n, 1) - x[i]);
adds[1] += abs(x[i] - x[i - 1]);
min1[1] += abs(x[i] - x[i - 1]);
min2[1] += abs(x[i] - x[i - 1]);
setpt(1, n, 1, x[i - 1], cjr);
}
cout << query(1, n, 1) << endl;
}
}
int main() {
ywy::ywymain();
return (0);
} | 0 |
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define str to_string
#define endl "\n"
#define PI 3.141592653589
using namespace std;
using lint = long long;
template <class T>ostream &operator<<(ostream &o,const vector<T>&v)
{o<<"{";for(int i=0;i<(int)v.size();i++)o<<(i>0?", ":"")<<v[i];o<<"}";return o;}
int main(){
int n,y;cin>>n>>y;
for(int i=0;i<=n;i++){
for(int j=0;j<=n;j++){
int k=(y-10000*i-5000*j)/1000;
if(i+j+k==n && 0<=k && k<=n){
cout<<i<<" "<<j<<" "<<k<<endl;
return 0;
}
}
}
cout<<-1<<" "<<-1<<" "<<-1<<endl;
}
| %:pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 5;
const int M = 4e6 + 5;
const int mod = 1e9 + 7;
int n, k, dp[N][N], fac[M], ifac[M];
inline int mul(int a, int b) {
return (long long) a * b % mod;
}
inline int add(int a, int b) {
return (a += b) >= mod ? a - mod : a;
}
inline int Pow(int a, int b) {
int r = 1;
for(; b; b >>= 1, a = mul(a, a))
if(b & 1) r = mul(r, a);
return r;
}
void pre(int n) {
fac[0] = 1;
for(int i = 1; i <= n; ++i)
fac[i] = mul(fac[i - 1], i);
ifac[n] = Pow(fac[n], mod - 2);
for(int i = n - 1; ~i; --i)
ifac[i] = mul(ifac[i + 1], i + 1);
}
inline int C(int n, int m) {
if(n < 0 || m < 0 || n < m) return 1;
return mul(fac[n], mul(ifac[m], ifac[n - m]));
}
int main() {
cin >> n >> k;
if(k == 1) return 0 * putchar('1');
pre(M - 1);
dp[0][0] = 1;
for(int i = 0; i <= n; ++i)
for(int j = i +(!i); j <= n; ++j) {
if(i) dp[i][j] = dp[i - 1][j];
dp[i][j] = add(dp[i][j], mul(dp[i][j - 1], C(i + j * (k - 1) - 1, k - 2)));
}
printf("%d\n", mul(dp[n][n], fac[n]));
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll,ll>;
using vl = vector<ll>;
using Map = map<ll,ll>;
using T = tuple<ll,ll,ll>;
using vvl = vector<vector<ll>>;
#define all(v) v.begin(), v.end()
#define prt(v) cout<<v<<"\n";
#define fi(v) get<0>(v)
#define se(v) get<1>(v)
#define th(v) get<2>(v)
#define endl "\n"
template <typename T> bool chmax(T &a, const T &b){if (a<b){a=b;return 1;}return 0;}
template <typename T> bool chmin(T &a, const T &b){if (a>b){a=b;return 1;}return 0;}
const ll INF=1LL<<62;
const ll MOD=1000000007;
ll N,Q,K;
vector<ll> a(100007,0);
vector<ll> b(100007,0);
vector<ll> c(100007,0);
vector<ll> x(100007,0);
vector<ll> y(100007,0);
vector<ll> d(100007,INF);
vector<vector<P>> G(100007, vector<P>(0));
void dfs(ll x){
for(auto p: G[x]){
ll s=p.first,t=p.second;
if(d[s]==INF){d[s]=d[x]+t;dfs(s);}
}
}
signed main(void){
cin.tie(0);cout.tie(0);ios::sync_with_stdio(false);
cin >> N;
for(ll i=0;i<N-1;++i){cin>>a[i]>>b[i]>>c[i];a[i]--;b[i]--;}
for(ll i=0;i<N-1;++i){
G[a[i]].emplace_back(P(b[i],c[i]));
G[b[i]].emplace_back(P(a[i],c[i]));
}
cin>>Q>>K;K--;
for(ll i=0;i<Q;++i){cin>>x[i]>>y[i];x[i]--;y[i]--;}
d[K]=0;
dfs(K);
for(ll i=0;i<Q;++i)prt(d[x[i]]+d[y[i]])
return 0;
}
| #pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
//#include<boost/multiprecision/cpp_int.hpp>
//#include<boost/multiprecision/cpp_dec_float.hpp>
//namespace mp=boost::multiprecision;
//#define mulint mp::cpp_int
//#define mulfloat mp::cpp_dec_float_100
using namespace std;
struct __INIT{__INIT(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}} __init;
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
constexpr int MOD=1000000007;
//constexpr int MOD=998244353;
#define INF (1<<30)
#define LINF (lint)(1LL<<56)
#define endl "\n"
#define rep(i,n) for(lint (i)=0;(i)<(n);(i)++)
#define reprev(i,n) for(lint (i)=(n-1);(i)>=0;(i)--)
#define Flag(x) (1<<(x))
#define Flagcount(x) __builtin_popcountll(x)
#define pint pair<int,int>
#define pdouble pair<double,double>
#define plint pair<lint,lint>
#define fi first
#define se second
typedef long long lint;
int dx[8]={1,1,0,-1,-1,-1,0,1};
int dy[8]={0,1,1,1,0,-1,-1,-1};
const int MAX_N=2e5+5;
//struct edge{lint to,num;};
vector<lint> G[200050]; // MAX_V,隣接リスト
lint root;
lint parent[20][200050]; // logMAX_V,MAX_V
lint depth[200050];
void LCAdfs(lint v,lint p,lint d){
parent[0][v]=p;
depth[v]=d;
rep(i,G[v].size()) if(G[v][i]!=p) LCAdfs(G[v][i],v,d+1);
}
void LCAinit(lint V){
LCAdfs(root,-1,0);
for(int k=0;k+1<20;k++){
for(int v=0;v<V;v++){
if(parent[k][v]<0) parent[k+1][v]=-1;
else parent[k+1][v]=parent[k][parent[k][v]];
}
}
}
lint LCA(lint u,lint v){
if(depth[u]>depth[v]) swap(u,v);
for(int k=0;k<20;k++){
if((depth[v]-depth[u])>>k&1) v=parent[k][v];
}
if(u==v) return u;
for(int k=20-1;k>=0;k--){
if(parent[k][u]!=parent[k][v]){
u=parent[k][u];
v=parent[k][v];
}
}
return parent[0][u];
}
vector<int> path(int s,int t){
int lca=LCA(s,t);
vector<int> ps,pt;
int now=s;
while(true){
if(now==lca) break;
ps.push_back(now);
now=parent[0][now];
}
now=t;
while(true){
pt.push_back(now);
if(now==lca) break;
now=parent[0][now];
}
reverse(pt.begin(),pt.end());
ps.insert(ps.end(),pt.begin(),pt.end());
return ps;
}
vector<pint> edge[MAX_N];
bool reach[MAX_N];
lint dis[MAX_N];
void dfs(int now,lint sum){
if(reach[now]) return;
reach[now]=true;
dis[now]=sum;
rep(i,edge[now].size()){
dfs(edge[now][i].fi,sum+edge[now][i].se);
}
}
int main(void){
int N;
cin >> N;
rep(i,N-1){
int u,v,w;
cin >> u >> v >> w;
u--,v--;
G[u].push_back(v);
G[v].push_back(u);
edge[u].push_back(pint(v,w));
edge[v].push_back(pint(u,w));
}
LCAinit(N);
dfs(0,0);
int Q,K;
cin >> Q >> K;
K--;
rep(i,Q){
int x,y;
cin >> x >> y;
x--,y--;
int lca=LCA(x,K);
lint ans=dis[x]+dis[K]-2*dis[lca];
lca=LCA(K,y);
ans+=dis[K]+dis[y]-2*dis[lca];
cout << ans << endl;
}
} | 1 |
//FIRST THINK THEN CODE.
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
//#define MOD 998244353
#define rep(i,a,b) for(ll i=a;i<b;++i)
#define rrep(i,a,b) for(ll i=a;i>b;--i)
#define FOR(i,n) for(ll i=0;i<n;i++)
#define vi vector<int>
#define vl vector<ll>
#define ld long double
#define vvi vector<vector<int>>
#define vvl vector<vector<long long>>
#define pii pair<int,int>
#define pll pair<long,long>
#define vpii vector<pii>
#define vpll vector<pll>
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define lb lower_bound
#define ub upper_bound
#define bs binary_search
#define d1(x) cout<<(x)<<endl
#define d2(x,y) cout<<(x)<<" "<<(y)<<endl
#define d3(x,y,z) cout<<(x)<<" "<<(y)<<" "<<(z)<<endl
#define d4(a,b,c,d) cout<<(a)<<" "<<(b)<<" "<<(c)<<" "<<(d)<<endl
#define PI 3.1415926535897932384626433832795
#define fix(f,n) fixed<<setprecision(n)<<f
#define all(x) x.begin(),x.end()
#define endl "\n"
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define popcount(x) __builtin_popcountll(x)
const int M=1000000007;
const int MM=998244353;
ll newmod(ll a,ll b)
{
return ((a%b)+b)%b;
}
ll powM(ll a,ll b,ll m )
{
if(m<=1)return 0;
a%=m;
ll ans=1LL;
while(b)
{
if(b&1)ans=ans*a%m;
a=a*a%m;
b>>=1;
}
return ans;
}
ll poww(ll a,ll b)
{
ll ans=1;
while(b)
{
if(b&1)ans=ans*a;
a=a*a;
b>>=1;
}
return ans;
}
template<typename T,typename F>
void chmax( T &a,F b){
if(b>a)a=b;
}
template<typename T,typename F>
void chmin( T &a,F b){
if(b<a)a=b;
}
const ll N=1e6+5;
ll sp[N];
void fill(){
for(int i=1;i<N;i++)sp[i]=i;
for(int i=2;i<N;i++){
for(int j=i;j<N;j+=i){
if(sp[j]==j)sp[j]=i;
}
}
}
//vl f(N);
bool prime(ll x){
if(x<=3)return true;
for(ll i=2;i*i<=x;i++)if(x%i==0)return false;
return 1;
}
int main()
{
IOS;
fill();
ll a,b;cin>>a>>b;
ll mn=min(a,b);
ll c=0;
set<ll>s;
for(ll i=1;i*i<=a;i++){
if(a%i==0){
if(prime(i))s.insert(i);
if(prime(a/i))s.insert(a/i);
}
}
for(ll i=1;i*i<=b;i++){
if(b%i==0){
if( prime(i)&&s.count(i))++c;
if(i*i!=b&&prime(b/i)&&s.count(b/i))++c;
}
}
//for(auto d:s)cout<<d<<" ";
cout<<c;
return 0;
}
| #include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define in read()
#define re register
#define fur(i,a,b) for(re int i=a;i<=b;++i)
#define fdr(i,a,b) for(re int i=a;i>=b;--i)
#define cl(a,b) memset(a,b,sizeof(a))
#define jinitaimei signed
#define int long long
inline int read()
{
int x=0;
char ch=getchar();
for(;!isalnum(ch);ch=getchar());
for(;isalnum(ch);ch=getchar()) x=x*10+ch-'0';
return x;
}
const int mod=1e9+7,xx=5e5+1;
inline int power(int b,int k)
{
int res=1;
for(;k;k>>=1,b=b*b%mod) if(k&1) res=res*b%mod;
return res;
}
int jc[xx],ny[xx];
inline int C(int m,int n)
{
if(!m) return 1;
return jc[n]*ny[m]%mod*ny[n-m]%mod;
}
jinitaimei main()
{
jc[0]=1;
ny[0]=1;
int H=in,W=in;
fur(i,1,H+W) jc[i]=jc[i-1]*i%mod,ny[i]=power(jc[i],mod-2);
int A=in,B=in,ans=0;
A=H-A+1;
int up=min(A-1,W-B);
fur(k,1,up)
{
int x=A-k,y=B+k;
int tmp=C(x-1,x+y-2)*C(H-x,W-x+H-y)%mod;
(ans+=tmp)%=mod;
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
typedef long long ll;
int main(){
int n; cin>>n;
set<int> st;
rep(i,n){
int a; cin>>a;
if(st.count(a)==1) st.erase(a);
else st.insert(a);
}
cout<<st.size()<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const long long INF = 1LL << 60;
const ll MOD = 1000000007;
using pint = pair<ll, ll>;
int main() {
ll N;
cin >> N;
map<ll, ll> A;
for (int i = 0; i < N; i++){
ll tmp = 0;
cin >> tmp;
A[tmp]++;
}
ll cnt = 0;
for (auto i : A){
if (i.second % 2 == 0) continue;
else{
cnt++;
}
}
cout << cnt << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define printVec(v) printf("{"); for (const auto& i : v) { std::cout << i << ", "; } printf("}\n");
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; }
//get the biggest element.
template<typename KeyType, typename ValueType>
std::pair<KeyType,ValueType> get_max( const std::map<KeyType,ValueType>& x ) {
using pairtype=std::pair<KeyType,ValueType>;
return *std::max_element(x.begin(), x.end(), [] (const pairtype & p1, const pairtype & p2) {
return p1.second < p2.second;
});
}
using namespace std;
using P = pair<int,int>;
using ll = long long;
const ll INF = 1LL<<60;
int main() {
ll n, a, b, c, d, e;
cin >> n;
vector<ll> vi(5);
rep (i, 5) cin >> vi[i];
ll tmp = n;
rep (i, 5) {
if (tmp > vi[i]) tmp = vi[i];
}
ll ans = 5;
ans += (n - tmp) / tmp;
if ( (n - tmp) % tmp != 0) ++ans;
cout << ans << endl;
return 0;
}
| #define _USE_MATH_DEFINES
#include <iostream>
#include <sstream>
#include <string>
#include <list>
#include <vector>
#include <queue>
#include <algorithm>
#include <climits>
#include <cstring>
#include <cmath>
#include <stack>
#include <iomanip>
#include <tuple>
#include <functional>
#include <cfloat>
#include <map>
#include <set>
#include <array>
#include <stdio.h>
#include <string.h>
using ll = long long;
using ull = unsigned long long;
using namespace std;
#define int long long
#define CONTAINS_VEC(v,n) (find((v).begin(), (v).end(), (n)) != (v).end())
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
#define ARY_SORT(a, size) sort((a), (a)+(size))
#define REMOVE(v,a) (v.erase(remove((v).begin(), (v).end(), (a)), (v).end()))
#define REVERSE(v) (reverse((v).begin(), (v).end()))
#define ARY_REVERSE(v,a) (reverse((v), (v)+(a)))
#define REP(i, n) for (int (i)=0; (i) < (n); (i)++)
#define CONTAINS_MAP(m, a) (m).find((a)) != m.end()
#define CONTAINS_SET(m, a) (m).find((a)) != m.end()
void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
//ceil(n/m)
int int_ceil(int n, int m)
{
if (n % m == 0) return n / m;
return n / m + 1;
}
signed main()
{
int N;
int A[5];
cin >> N;
REP(i, 5) cin >> A[i];
int cur = N;
for (int i = 0; i < 5; i++)
{
cur = min(cur, A[i]);
}
int n = int_ceil(N, cur);
cout << n + 4 << endl;
}
| 1 |
#include<cstdio>
#include<algorithm>
#include<vector>
#include<string>
#include<iostream>
#include<queue>
#include<map>
#include<set>
#include<complex>
#include<stack>
#include<cmath>
using namespace std;
#define reps(i,f,n) for(int i=f;i<int(n);i++)
#define rep(i,n) reps(i,0,n)
int main(){
while(1){
int n;
cin>>n;
if(n==0)break;
int in[5555];
rep(i,n)cin>>in[i];
int ans = -1000000000;
reps(i,1,n+1){
int sum = 0;
rep(j,i)sum += in[j];
ans = max(ans,sum);
reps(j,i,n){
sum-=in[j-i];
sum+=in[j];
ans = max(ans,sum);
}
}
printf("%d\n",ans);
}
} | #include <bits/stdc++.h>
using namespace std;
#define for_(i,a,b) for(int i=a;i<b;++i)
#define for_rev(i,a,b) for(int i=a;i>=b;--i)
#define allof(a) a.begin(),a.end()
#define minit(a,b) memset(a,b,sizeof(a))
#define size_of(a) (int)a.size()
int N, M;
int p[1010];
int main() {
while (cin >> N >> M, N) {
for_(i,0,N) cin >> p[i];
vector<int> vp;
vp.push_back(0);
for_(i,0,N) vp.push_back(p[i]);
vector<int> sum2;
for_(i,0,N + 1) for_(j,0,N + 1) sum2.push_back(vp[i] + vp[j]);
sort(allof(sum2));
int s_size = size_of(sum2);
int ans = 0;
for_(i,0,s_size) {
int sum = sum2[i];
if (sum <= M) {
int sub = M - sum;
int lb = *(upper_bound(allof(sum2), sub) - 1);
//cout << sub << " " << lb << endl;
sum += lb;
ans = max(ans, sum);
}
}
cout << ans << endl;
}
return 0;
} | 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,h,w;
cin>>n>>h>>w;
cout<<max(0,(n-h+1)*(n-w+1))<<endl;
return 0;
} | #include <bits/stdc++.h>
#include <algorithm>
#include<string>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int N, H, W;
bool flag = false;
cin >> N >> H >> W;
int count = 0;
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= N; ++j) {
if (j + W - 1 <= N) {
flag = true;
} else {
flag = false;
}
if (flag && i + H - 1 <= N) {
++count;
}
}
}
cout << count << endl;
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <string>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstring>
#include<map>
#include<cmath>
#include<set>
//#include<bits/stdc++.h>
#define ll long long int
#define ull unsigned long long int
#define I(a) scanf("%d",&a)
#define I2(a,b) scanf("%d%d",&a,&b)
#define I3(a,b,c) scanf("%d%d%d",&a,&b,&c)
#define L(a) scanf("%lld",&a)
#define L2(a,b) scanf("%lld%lld",&a,&b)
#define L3(a,b,c) scanf("%lld%lld%lld",&a,&b,&c)
#define PI(a) printf("%d",a)
#define PL(a) printf("%lld",a)
#define PT(t) printf("Case %d: ",t)
#define PB push_back
#define x first
#define y second
#define xx first.first
#define xy first.second
#define yx second.first
#define yy second.second
#define SC scanf
#define PC printf
#define NL printf("\n")
#define SET(a) memset(a,0,sizeof a)
#define SETR(a) memset(a,-1,sizeof a)
#define SZ(a) ((int)a.size())-1
#define f(i,a,b) for(int i=a;i<=b; i++)
#define fr(i,a,b) for(int i=a;i<=b; i++)
#define frr(i,a,b) for(int i=a;i>=b; i--)
#define frv(i,a) for(int i=0;i<a.size();i++)
#define pi 2.0*acos(0.0)
#define R(a) freopen(a, "r", stdin);
#define W(a) freopen(a, "w", stdout);
#define CB(x) __builtin_popcount(x)
#define STN(a) stringtonumber<ll>(a)
#define lol printf("BUG\n")
#define Endl "\n"
#define mk make_pair
using namespace std;
template <class T> inline T BM(T p, T e, T M)
{
ll ret = 1;
for(; e > 0; e >>= 1)
{
if(e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T> inline T mul(T p, T e, T M)
{
ll ret = 0;
for(; e > 0; e >>= 1)
{
if(e & 1) ret = (ret + p) ;
p = (p + p) ;
if(ret>=M)ret-=M;
if(p>=M)p-=M;
}
return (T)ret;
}
template <class T> inline T gcd(T a, T b)
{
if(b == 0)return a;
return gcd(b, a % b);
}
template <class T> inline T mdINV(T a, T M)
{
return BM(a, M - 2, M);
}
template <class T> inline T PW(T p, T e)
{
ll ret = 1;
for(; e > 0; e >>= 1)
{
if(e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
template <class T>bool ISLEFT(T a, T b, T c)
{
if(((a.xx - b.xx) * (b.yy - c.yy) - (b.xx - c.xx) * (a.yy - b.yy)) < 0.0)return 1; //Uporer dike //A,b,c, x okkher ordera sorted
else return 0;
}
#define mx 200004
#define base 193ll
typedef pair<int,int >P;
//////////////////////////
////////////////////////
#define F(i,a,b) for(int i=a;i<b; i++)
#define LL long long
#define MX 200007
#define md 998244353ll
///////////////////////////
///////////////////////////
char ar[ MX +2], br [MX+2];
int main(){
string s;
cin>>s;
if(s[0] != 'A'){
PC("WA");
}
else {
bool fl =0;
int cnt = 0;
for(int i = 1; i < s.size(); i++){
if(s[i] >= 'A' && s[i] <= 'Z'){
if(s[i] == 'C' && i >= 2 && i < s.size() - 1){
cnt++;
}
else fl = 1;
}
}
if(fl || cnt != 1)PC("WA");
else PC("AC");
}
NL;
return 0;
} | #include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<utility>
#include<tuple>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define BIL ((ll)1e9)
#define MOD ((ll)1e9+7)
#define INF (1LL<<60) //1LL<<63でオーバーフロー
#define inf (1<<29) //1<<29でオーバーフロー
int main(int argc,char* argv[]){
string s;
cin >> s;
bool ans=true,ccheck=false;
for(int i=0;i<s.size();i++){
if(i==0){
if(s[i]!='A'){
ans=false;
break;
}
}else if(i>=2 && i<=s.size()-2 && s[i]=='C'){
if(ccheck){
ans = false;
break;
}else{
ccheck=true;
}
}else{
if(isupper(s[i])){
ans=false;
break;
}
}
}
if(ans && ccheck)cout << "AC" << endl;
else cout << "WA" << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int arr[100003] , N;
int main(){
cin >> N; for(int i = 1 ; i <= N ; ++i) cin >> arr[i];
bool flag = 0;
while(1){
flag ^= 1; int cnt = 0; for(int i = 1 ; i <= N ; ++i) cnt ^= arr[i] - 1;
if(cnt & 1){puts(!flag ? "Second" : "First"); return 0;}
int id = 0;
for(int i = 1 ; i <= N ; ++i)
if(arr[i] & 1) if(arr[i] == 1 || id){puts(flag ? "Second" : "First"); return 0;} else id = i;
--arr[id]; int Gcd = 0; for(int i = 1 ; i <= N ; ++i) Gcd = __gcd(arr[i] , Gcd);
for(int i = 1 ; i <= N ; ++i) arr[i] /= Gcd;
}
return 0;
}
| // This amazing code is by Eric Sunli Chen.
#include<bits/stdc++.h>
using namespace std;
template<typename T> bool get_int(T &x)
{
char t=getchar();
bool neg=false;
x=0;
for(; (t>'9'||t<'0')&&t!='-'&&t!=EOF; t=getchar());
if(t=='-')neg=true,t=getchar();if(t==EOF)return false;
for(; t<='9'&&t>='0'; t=getchar())x=x*10+t-'0';
if(neg)x=-x;return true;
}
template<typename T> void print_int(T x)
{
if(x<0)putchar('-'),x=-x;
short a[20]= {},sz=0;
while(x>0)a[sz++]=x%10,x/=10;
if(sz==0)putchar('0');
for(int i=sz-1; i>=0; i--)putchar('0'+a[i]);
}
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define get1(a) get_int(a)
#define get2(a,b) (get1(a)&&get1(b))
#define get3(a,b,c) (get1(a)&&get2(b,c))
#define printendl(a) print_int(a),puts("")
typedef long long LL;
typedef unsigned long long uLL;
typedef pair<int,int> pii;
const int inf=0x3f3f3f3f;
const LL Linf=1ll<<61;
const double pi=acos(-1.0);
const int maxn=100111;
int n,s,x[maxn];
LL p[maxn],ans;
int calc(int l,int r)
{
if(x[r]<s)
{
ans+=s-x[l];
return l;
}
if(x[l]>s)
{
ans+=x[r]-s;
return r;
}
if(p[l]>=p[r])
{
p[l]+=p[r];
ans+=x[r]-x[calc(l,r-1)];
return r;
}
else
{
p[r]+=p[l];
ans+=x[calc(l+1,r)]-x[l];
return l;
}
}
int main()
{
get2(n,s);
for(int i=1;i<=n;i++)get2(x[i],p[i]);
calc(1,n);
printendl(ans);
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#include<string>
#define fo(i, n) for(ll i = 0; i < n; i++)
#define endl "\n"
#define of(i, n) for(ll i = n - 1; i >= 0; i--)
#define ll long long
#define vec vector<ll>
#define fio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define tr(container, it) \
for(typeof(container.begin()) it = container.begin(); it != container.end(); it++)
#define rep(i,j,n) for (ll i = j; i <= n; ++i)
#define EB emplace_back
#define mem(i,j) memset( i, j,sizeof(i))
#define ff first
#define ss second
#define ii pair<ll,ll>
#define iii pair<ll,pair<ll,ll> >
#define pb push_back
#define mp make_pair
#define all(i) i.begin(),i.end()
#define pr(a) cout<<a<<endl
#define pr
#define prv(a) for(int jkl=0; jkl<a.size();jkl++) cout<<a[jkl]<<" "; cout<<endl;
ll mod = 1e9+7;
string l,r;
ll d;
int dp[10100][2][2][101];
ll getAns(int level, int tlow, int thi, int rem)
{
if(level>=l.length())
{
if(rem==0) return 1;
else return 0;
}
if(dp[level][tlow][thi][rem]==-1)
{
int blow = 0;
int bhigh = 9;
if(tlow) blow =l[level] - '0';
if(thi) bhigh = r[level]-'0';
ll ans =0;
for(int i=blow;i<=bhigh;i++)
{
int ntlow = tlow;
int nthi = thi;
if( i > l[level]-'0') ntlow =0 ;
if(i<r[level]-'0') nthi =0;
ans += getAns(level+1, ntlow,nthi,(rem + i)%d);
ans%=mod;
}
dp[level][tlow][thi][rem] = ans;
}
return dp[level][tlow][thi][rem];
}
int main()
{
string n;
cin>>n;
r = n;
l = "1";
while(l.length()<r.length()) l += '0';
reverse(all(l));
cin>>d;
mem(dp,-1);
//cout<<r<<" "<<l<<endl;
cout<<getAns(0,1,1,0)<<endl;;
}
| #include<bits/stdc++.h>
using namespace std;
typedef int in;
#define int long long
int MAX=1e9;
int MAXEST=1e18;
int MOD=1e9+7;
int d;
string s;
int dp[10005][101][2];
int f(int idx,int cur,bool gr)
{
if(idx==s.size())
{
return (!cur);
}
int &ret=dp[idx][cur][gr];
if(ret!=-1)
return ret;
ret=0;
if(!gr)
{
for(int i=0; i<s[idx]-'0'; i++)
{
ret+=f(idx+1,(cur+i)%d,1);
ret%=MOD;
}
ret+=f(idx+1,(cur+(s[idx]-'0'))%d,0);
ret%=MOD;
}
else{
for(int i=0;i<=9;i++){
ret+=f(idx+1,(cur+i)%d,1);
ret%=MOD;
}
}
return ret;
}
in main()
{
int tc=1;
// cin>>tc;
while(tc--)
{
cin>>s>>d;
memset(dp,-1,sizeof dp);
cout<<(f(0,0,0)+MOD-1)%MOD<<endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
#define rep(i,n) for (int i = 0; i < (n); i++)
typedef pair<int,int> P;
const int INF = 100000000;
typedef long long ll;
int W,H;
int sy, sx, gy, gx;
int dx[4] = {1,-1,0,0};
int dy[4] = {0,0,1,-1};
bool movable(vector<vector<char>> &c, vector<vector<int>> &mat, int h, int w, int hb, int wb) {
if ((h<0) || (h>=H) || (w<0) || (w>=W)) {
return false;
}
else if (mat[h][w]!=INF || (c[h][w]==c[hb][wb])) {
return false;
}
else {
return true;
}
}
ll bfs(vector<vector<char>> &c, vector<vector<int>> &mat, pair<int,int> &q) {
ll k,s;
s=0;
k = 1;
queue<P> que;
que.push(q);
if (mat[q.first][q.second] != INF) return 0;
else (mat[q.first][q.second] = 0);
while(que.size()) {
P p = que.front();
que.pop();
rep(i,4){
if (movable(c,mat,p.first+dy[i],p.second+dx[i],p.first,p.second)) {
que.push(P(p.first+dy[i],p.second+dx[i]));
mat[p.first+dy[i]][p.second+dx[i]]=mat[p.first][p.second]+1;
if (c[p.first+dy[i]][p.second+dx[i]]=='.') s++;
else k++;
}
}
}
return k*s;
}
int main() {
cin >> H >> W;
vector<vector<char>> c(H,vector<char> (W));
vector<pair<int,int>> P;
rep(h,H) {
string s;
cin >> s;
rep(w,W) {
c[h][w] = s[w];
if (s[w]=='#') {
P.push_back(make_pair(h,w));
}
}
}
vector<vector<int>> mat(H,vector<int> (W, INF));
ll ans = 0;
for (auto p: P) {
ll tmp = bfs(c,mat,p);
ans += tmp;
}
cout << ans << endl;
} | #define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
ll dp[11][210000];
const int INF=1e9;
int main() {
ll d,g;
cin>>d>>g;
g/=100;
vector<int> P(d+1),C(d+1);
int x;
rep(i,d){
cin>>P[i+1]>>x;
C[i+1]=x/100;
}
rep(i,11){
rep(j,210000) dp[i][j]=INF;
}
dp[0][0]=0;
for(int i=1;i<=d;i++){
for(int j=0;j<=g+20000;j++){
for(int k=0;k<P[i];k++){
if(j-k*i<0) continue;
dp[i][j]=min(dp[i][j],dp[i-1][j-k*i]+k);
}
if(j-P[i]*i-C[i]<0) continue;
dp[i][j]=min(dp[i][j],dp[i-1][j-P[i]*i-C[i]]+P[i]);
}
}
ll ans=INF;
for(int i=g;i<=g+20000;i++){
ans=min(ans,dp[d][i]);
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
#define show(x) {for(auto i: x){cout << i << " ";} cout << endl;}
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int X, Y, Z;
cin >> X >> Y >> Z;
int a = Z;
Z = Y; Y = X; X = a;
cout << X << ' ' << Y << ' ' << Z << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
// double mathdist(double, double, double, double);
int main()
{
/* 始めからdouble型で読み込むべし */
/* 読み込み時のキャストは危険 */
double x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
// cout << mathdist(x1, x2, y1, y2) << endl;
cout << fixed << setprecision(cout.precision()) << sqrt(pow(abs(x1 - x2), 2) + pow(abs(y1 - y2), 2)) << endl;
return 0;
}
// double mathdist(double x1, double x2, double y1, double y2)
// {
// double dxsq, dysq, res;
// constexpr double EPS = numeric_limits<double>::epsilon();
// if (abs(x1 - x2) <= EPS)
// {
// dxsq = 0.0;
// }
// else
// {
// dxsq = pow(abs(x1 - x2), 2);
// }
// if (abs(y1 - y2) <= EPS)
// {
// dysq = 0.0;
// }
// else
// {
// dysq = pow(abs(y1 - y2), 2);
// }
// return res = sqrt(dxsq + dysq);
// }
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(20) << fixed;
int n;
cin >> n;
vector<int> odd(100001);
vector<int> even(100001);
for (int i = 0; i < n; i++) {
int v;
cin >> v;
if (i % 2 == 0) {
odd[v]++;
} else {
even[v]++;
}
}
int oddMax = 0, evenMax = 0;
int oddMax2 = 0, evenMax2 = 0;
int oddMaxNum = 0, evenMaxNum = 0;
for (int i = 0; i < 100001; i++) {
if (odd[i] >= oddMax) {
oddMax2 = oddMax;
oddMax = odd[i];
oddMaxNum = i;
} else if(odd[i] > oddMax2){
oddMax2 = odd[i];
}
if (even[i] >= evenMax) {
evenMax2 = evenMax;
evenMax = even[i];
evenMaxNum = i;
} else if(even[i] > evenMax2){
evenMax2 = even[i];
}
}
if (oddMaxNum == evenMaxNum) {
if (oddMax - oddMax2 > evenMax - evenMax2) {
evenMax = evenMax2;
} else {
oddMax = oddMax2;
}
}
cout << n - oddMax - evenMax << endl;
}
| #include<bits/stdc++.h>
using namespace std;
int main(void){
int N;
cin>>N;
vector<int> X(N);
for(int i=0;i<N;i++){
cin>>X[i];
}
int sum=0;
for(int i=0;i<N-1;i++){
sum+=abs(X[i+1]-X[i]);
}
for(int i=0;i<N;i++){
if(i==N-1){
cout<<sum+abs(X[0])+abs(X[N-2])-abs(X[i]-X[i-1])<<endl;
}else if(i==0){
cout<<sum+abs(X[1])+abs(X[N-1])-abs(X[1]-X[0])<<endl;
}else{
cout<<sum+abs(X[0])+abs(X[N-1])+abs(X[i+1]-X[i-1])-abs(X[i+1]-X[i])-abs(X[i]-X[i-1])<<endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using P = pair<int,int>;
int main(){
int h, w;
cin >> h >> w;
vector<string> hw(h);
for(int i=0; i<h; ++i) cin >> hw[i];
queue<P> que;
vector<vector<int>> dis(h, vector<int>(w, -1));
for(int i=0; i<h; ++i) for(int j=0; j<w; ++j){
if(hw[i][j] == '#'){
que.push(make_pair(i,j));
dis[i][j] = 0;
}
}
int ans = 0;
while(!que.empty()){
int x, y;
tie(x,y) = que.front();
que.pop();
if(x>0 && dis[x-1][y] == -1){
dis[x-1][y] = dis[x][y] + 1;
ans = max(ans, dis[x-1][y]);
que.push(make_pair(x-1,y));
}
if(x<h-1 && dis[x+1][y] == -1){
dis[x+1][y] = dis[x][y] + 1;
ans = max(ans, dis[x+1][y]);
que.push(make_pair(x+1,y));
}
if(y>0 && dis[x][y-1] == -1){
dis[x][y-1] = dis[x][y] + 1;
ans = max(ans, dis[x][y-1]);
que.push(make_pair(x,y-1));
}
if(y<w-1 && dis[x][y+1] == -1){
dis[x][y+1] = dis[x][y] + 1;
ans = max(ans, dis[x][y+1]);
que.push(make_pair(x,y+1));
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i=0; i<(int)(n); i++)
int main(){
int H, W, ans=1; cin >> H >> W; string A[H];
REP(i, H){ cin >> A[i]; }
int B[H][W]={}; vector< pair<int, int> > C;
REP(i, H){ REP(j, W){
if(A[i][j]=='#'){ B[i][j]=1; C.push_back(make_pair(i, j)); }
} }
REP(i, H*W){
if((int)C.size()==H*W){ cout << ans-1 << "\n"; return 0; }
int a=C[i].first, b=C[i].second, c=B[a][b]+1;
if(a>0&&!B[a-1][b]){ B[a-1][b]=c; C.push_back(make_pair(a-1, b)); }
if(b>0&&!B[a][b-1]){ B[a][b-1]=c; C.push_back(make_pair(a, b-1)); }
if(a<H-1&&!B[a+1][b]){ B[a+1][b]=c; C.push_back(make_pair(a+1, b)); }
if(b<W-1&&!B[a][b+1]){ B[a][b+1]=c; C.push_back(make_pair(a, b+1)); }
ans=c;
}
} | 1 |
#include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define srep(i,s,t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(),a.end()
#define sz(x) (int)(x).size()
#define uni(x) x.erase(unique(rng(x)),x.end())
#define show(x) cout<<#x<<" = "<<x<<endl;
#define PQ(T) priority_queue<T,v(T),greater<T> >
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef pair<int,int> P;
typedef set<int> S;
typedef queue<int> Q;
typedef queue<P> QP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
const int MOD = 1000000007;
int main() {
int N,M;
cin >> N >> M;
vvi A(N,vi(M));
rep(i,N) {
rep(j,M) {
cin >> A[i][j];
A[i][j]--;
}
}
int ans = INF;
vi except(M,0);
while(1) {
vi cnt(M,0);
bool ok = true;
rep(i,N) {
int idx=0;
rep(j,M) {
if(except[A[i][j]]) {
idx++;
} else {
break;
}
}
if(idx==M) {
cout << ans << endl;
return 0;
}
cnt[A[i][idx]]++;
}
int n = 0;
rep(i,M) {
n = max(n,cnt[i]);
}
ans = min(ans,n);
rep(i,M) {
if(cnt[i]==n) {
except[i]++;
}
}
}
return 0;
} | #include <iostream>
#include <vector>
#include <utility>
#include <queue>
using namespace std;
class node {
public:
int parent,children[2],sib,val;
node() {
parent = -1;
children[0] = -1;
children[1] = -1;
sib = -1;
val = -1;
}
int deg() {
int c = 0;
for(int i=0;i<2;i++)if(children[i]!=-1)c++;
return c;
}
string typ() {
if(parent == -1)return "root";
else if(deg() == 0)return "leaf";
else return "internal node";
}
int get1() {
if(children[0] == -1) return children[1];
return children[0];
}
};
int n = 0,c = 0;
node d[600000];
void pre(int i) {
cout << " " << d[i].val;
if(d[i].children[0] != -1) pre(d[i].children[0]);
if(d[i].children[1] != -1) pre(d[i].children[1]);
}
void ino(int i) {
if(d[i].children[0] != -1)ino(d[i].children[0]);
cout << " " << d[i].val;
if(d[i].children[1] != -1)ino(d[i].children[1]);
}
void pos(int i) {
if(d[i].children[0] != -1)pos(d[i].children[0]);
if(d[i].children[1] != -1)pos(d[i].children[1]);
cout << " " << d[i].val;
}
void ins(int v) {
d[c].val = v;
if(c == 0){c++;return;}
int h = 0;
while(1) {
int g;
if(d[h].val < v) {
g = d[h].children[1];
if(g == -1) {
d[c].parent = h;
d[h].children[1] = c;
break;
} else {
h = g;
}
} else {
g = d[h].children[0];
if(g == -1) {
d[c].parent = h;
d[h].children[0] = c;
break;
} else {
h = g;
}
}
}
c++;
}
void find(int v) {
int h = 0;
while(1) {
int g;
if(h == -1) {
cout << "no" << endl;
return;
}
if(d[h].val < v) {
h = d[h].children[1];
} else if (d[h].val > v){
h = d[h].children[0];
} else {
cout << "yes" << endl;
return;
}
}
}
void del(int v) {
int h = 0;
while(1) {
int g;
if(h == -1) {
return;
}
if(d[h].val < v) {
h = d[h].children[1];
} else if (d[h].val > v){
h = d[h].children[0];
} else {
int p = d[h].parent;
if(d[h].deg() == 0) {
if(d[p].val < v){
d[p].children[1] = -1;
}
else {
d[p].children[0] = -1;
}
}
if(d[h].deg() == 1) {
if(d[p].val < v){
d[p].children[1] = d[h].get1();
d[d[h].get1()].parent = p;
}
else {
d[p].children[0] = d[h].get1();
d[d[h].get1()].parent = p;
}
}
if(d[h].deg() == 2) {
int z = d[h].children[1];
while(1){
if(d[z].children[0] != -1) z = d[z].children[0];
else break;
}
int vv = d[z].val;
int pp = d[z].parent;
if(d[z].deg() == 0) {
if(d[pp].val < vv){
d[pp].children[1] = -1;
}
else {
d[pp].children[0] = -1;
}
}
if(d[h].deg() == 1) {
if(d[pp].val < vv){
d[pp].children[1] = d[z].get1();
d[d[z].get1()].parent = pp;
}
else {
d[pp].children[0] = d[z].get1();
d[d[z].get1()].parent = pp;
}
}
d[h].val = d[z].val;
}
return;
}
}
}
int main(void) {
cin >> n;
string s;
int t;
for(int i = 0;i < n;i++) {
cin >> s;
if(s == "insert") {cin >> t;ins(t);}
else if(s == "find"){cin >> t;find(t);}
else if(s == "delete"){cin >> t;del(t);}
else {ino(0);cout << endl;pre(0);cout << endl;}
}
}
| 0 |
#include <bits/stdc++.h>
#define FASTIO
using namespace std;
using ll = long long;
using Vi = vector<int>;
using Vl = vector<ll>;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
constexpr int I_INF = numeric_limits<int>::max();
constexpr ll L_INF = numeric_limits<ll>::max();
//==================================
int main() {
#ifdef FASTIO
cin.tie(0), cout.tie(0);
ios::sync_with_stdio(false);
#endif
#ifdef FILEINPUT
ifstream ifs("./in_out/input.txt");
cin.rdbuf(ifs.rdbuf());
#endif
int N;
cin >> N;
if (N == 1) {
cout << "Hello World\n";
}
else {
int a, b;
cin >> a >> b;
cout << a + b << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void)
{
int R, G, x;
cin >> R >> G;
x = G * 2 - R;
cout << x << endl;
} | 0 |
#include <iostream>
#include <vector>
#include <queue>
#include <functional>
#include <string.h>
using namespace std;
typedef pair<int, int> P;
struct edge
{
int to;
int cost;
};
vector<edge> G[101];
bool isUsed[101];
void solve()
{
int n;
cin >> n;
vector< vector<int> > data((n), vector<int>(n));
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < n; ++j)
{
int c;
cin >> data[i][j];
}
}
for (int i = 0; i < n; ++i)
{
for (int j = i; j < n; ++j)
{
if (data[i][j] != -1)
{
edge e1, e2;
e1.to = j;
e1.cost = data[i][j];
e2.to = i;
e2.cost = data[j][i];
G[i].push_back(e1);
G[j].push_back(e2);
}
}
}
memset(isUsed, 0, sizeof(isUsed));
int ans = 0;
priority_queue < P, vector<P>, greater<P> > pque;
pque.push(P(0, 0));
while (!pque.empty())
{
P p = pque.top();
pque.pop();
int v = p.second;
if (isUsed[v])
{
continue;
}
isUsed[v] = true;
ans += p.first;
for (int i = 0; i < G[v].size(); ++i)
{
edge e = G[v][i];
pque.push(P(e.cost, e.to));
}
}
cout << ans << endl;
}
int main()
{
solve();
return(0);
} | #include<bits/stdc++.h>
using namespace std;
int n,m,a[310][310];
int c[310],u[310],ans;
int main(){
scanf("%d %d",&n,&m);
ans=n;
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
scanf("%d",&a[i][j]);
}
}
for(int x=1;x<=m;x++){
memset(u,0,sizeof(u));
for(int i=1;i<=n;i++){
for(int j=1;j<=m;j++){
if(c[a[i][j]]) continue;
u[a[i][j]]++;
break;
}
}
int maxn=0,p;
for(int i=1;i<=m;i++){
if(u[i]>maxn) maxn=u[i],p=i;
}
c[p]=1;
ans=min(ans,maxn);
}
printf("%d\n",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
struct dice {
P x[3];
dice(int x_[6]) {
x[0] = P(x_[0], x_[5]);
x[1] = P(x_[1], x_[4]);
x[2] = P(x_[2], x_[3]);
}
int X(int n) {
return n < 3 ? x[n].first : x[5 - n].second;
}
void N() {
swap(x[0], x[1]);
swap(x[1].first, x[1].second);
}
void E() {
swap(x[0], x[2]);
swap(x[0].first, x[0].second);
}
void W() {
swap(x[0], x[2]);
swap(x[2].first, x[2].second);
}
void S() {
swap(x[0], x[1]);
swap(x[0].first, x[0].second);
}
};
int main()
{
int x[6];
string s;
for (int i = 0; i < 6; i++) {
cin >> x[i];
}
dice d(x);
cin >> s;
for (auto c : s) {
switch (c)
{
case 'N':
d.N();
break;
case 'E':
d.E();
break;
case 'W':
d.W();
break;
case 'S':
d.S();
break;
}
}
cout << d.X(0) << endl;
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int top, S, E, W, N, bot;
void what(char c)
{
int tmp;
switch (c) {
case 'S':
tmp = top;
top = N;
N = bot;
bot = S;
S = tmp;
break;
case 'E':
tmp = top;
top = W;
W = bot;
bot = E;
E = tmp;
break;
case 'W':
tmp = top;
top = E;
E = bot;
bot = W;
W = tmp;
break;
case 'N':
tmp = top;
top = S;
S = bot;
bot = N;
N = tmp;
break;
}
}
int main()
{
int i;
string op;
cin >> top >> S >> E >> W >> N >> bot;
cin >> op;
for (i=0; i<op.size(); i++) {
what(op[i]); }
cout << top << "\n";
} | 1 |
#include<iostream>
using namespace std;
#include<map>
#include<vector>
#include<cmath>
#include<set>
#include<algorithm>
#define int long long int
#define mod 1000000007
int binary_search(int arr[],int start,int end,int val)
{
if(start>end)
return -1;
else
{
int mid=(start+end)/2;
if(arr[mid]<=val)
return binary_search(arr,mid+1,end,val);
else
{
int x=mid;
int y=binary_search(arr,start,mid-1,val);
if(y==-1)
return x;
else
return y;
}
}
}
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin>>n;
int j,arr1[n],arr2[n],arr3[n];
for(j=0;j<n;j++)
cin>>arr1[j];
for(j=0;j<n;j++)
cin>>arr2[j];
for(j=0;j<n;j++)
cin>>arr3[j];
sort(arr1,arr1+n);
sort(arr2,arr2+n);
sort(arr3,arr3+n);
int value[n]={0};
for(j=0;j<n;j++)
{
int index=binary_search(arr3,0,n-1,arr2[j]);
if(index!=-1)
{
value[j]=(n-index);
}
}
int suffix[n]={0};
suffix[n-1]=value[n-1];
for(j=n-2;j>=0;j--)
{
suffix[j]=value[j]+suffix[j+1];
}
int answer=0;
for(j=0;j<n;j++)
{
int index=binary_search(arr2,0,n-1,arr1[j]);
if(index!=-1)
{
answer+=suffix[index];
}
}
cout<<answer<<endl;
}
| #include <fstream>
#include <iostream>
// BE CAREFUL WITH HASH TABLE & UNORDERED MAP
// #include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
using namespace std;
#define MOD 998244353
#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define F0R(i,b) FOR(i,0,b)
#define RFO(i,a,b) for (int i = (b-1); i >= (a); i--)
#define RF0(i,b) RFO(i,0,b)
#define lli long long int
#define pii pair<int,int>
#define add(a,b) ((int) (((lli) (a) + (b))%MOD))
#define mul(a,b) ((int) (((lli) (a) * (b))%MOD))
#define PB emplace_back
#define F first
#define S second
// ifstream cin ("cinput.in");
// ofstream cout ("coutput.out");
int N, a;
lli dp [200000][2]; // best with i picked. 0: floor((i+1)/2); 1: ceil((i+1)/2)
// transition cands: i-2, i-3
// Helper Functions
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N;
lli ans = -__LONG_LONG_MAX__;
cin >> a;
dp[0][0] = 0; dp[0][1] = a;
if (N <= 3) ans = max(ans, (lli) a);
cin >> a;
dp[1][0] = a; dp[1][1] = a;
if (N <= 3) ans = max(ans, (lli) a);
FOR(i,2,N) {
cin >> a;
dp[i][0] = dp[i-2][0];
dp[i][1] = dp[i-2][1];
// skip 2 cells
if (i-3 >= 0) {
if ((i+1)&1 == 0) dp[i][1] = max(dp[i][1], dp[i-3][1]);
dp[i][0] = max(dp[i][0], dp[i-3][1]);
}
// skip 3 cells
if (i-4 >= 0 && (i-2)/2 + 1 == (i+1)/2) dp[i][0] = max(dp[i][0], dp[i-4][1]);
dp[i][0] += a;
dp[i][1] += a;
if (i&1) {
lli mx = max(dp[i][0], dp[i][1]);
dp[i][0] = mx;
dp[i][1] = mx;
}
// cout << i+1 << '\n';
// cout << dp[i][0] << " " << dp[i][1] << '\n';
if ((i+1)/2 == N/2) ans = max(ans, dp[i][0]);
if ((i+2)/2 == N/2) ans = max(ans, dp[i][1]);
}
cout << ans << '\n';
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n >> x;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a.begin(), a.end());
int ans = 0, sum = 0;
for (int i = 0; i < n; i++) {
if (sum + a[i] > x) break;
sum += a[i];
ans++;
if (i==n-1 && x > sum) ans--;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
bool check(int x, vector<int> &d){
while(x > 0){
int c = x % 10;
for (int i=0; i<d.size(); i++){
if(c == d[i]) return false;
}
x /= 10;
}
return true;
}
int main(void){
// Your code here
int n, k;
cin >> n >> k;
vector<int> d(k);
for (int i=0; i<k; i++){
cin >> d[i];
}
while(1){
if(check(n, d)){
cout << n << endl;
return 0;
}
n++;
}
}
| 0 |
#include <iostream>
using namespace std;
#define repi(i,a,b) for(int i=(a);i<(b);i++)
#define rep(i,n) for(int i=0;i<(n);i++)
int main() {
ios::sync_with_stdio(false);
int w[3]={}, k[3]={};
int a;
rep(i, 10) {
cin >> a;
if(w[0]<a) {
w[2]=w[1];
w[1]=w[0];
w[0]=a;
}else if(w[1]<a) {
w[2]=w[1];
w[1]=a;
}else if(w[2]<a) {
w[2]=a;
}
}
rep(i, 10) {
cin >> a;
if(k[0]<a) {
k[2]=k[1];
k[1]=k[0];
k[0]=a;
}else if(k[1]<a) {
k[2]=k[1];
k[1]=a;
}else if(k[2]<a) {
k[2]=a;
}
}
rep(i, 2) {
w[2]+=w[i];
k[2]+=k[i];
}
cout << w[2] << " " << k[2] << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define pb push_back
#define vll vector<ll>
#define pll pair<ll,ll>
#define vpll vector<pll>
#define ub upper_bound
#define lb lower_bound
#define all(v) ((v).begin()),((v).end())
#define allr(v) ((v).rbegin()),((v).rend())
#define ff first
#define ss second
#define mp make_pair
#define pll pair<ll,ll>
#define fo(i,n) for(ll i=0;i<n;i++)
#define foa(i,s,e) for(ll i=(s);i<e;i++)
#define fod(i,s,e) for(ll i= (s);i>=(e);i--)
#define max3(a,b,c) max(max(a,b),c)
#define min3(a,b,c) min(min(a,b),c)
#define deb(x) cerr<<#x<<' '<<'='<<' '<<x<<'\n'
#define sz(x) (ll)(x.size())
#define ANS cout<<ans<<'\n'
#define YES cout<<"YES\n"
#define NO cout<<"NO\n"
#define Yes cout<<"Yes\n"
#define No cout<<"No\n"
const ld pi = 3.14159265358979323846;
ll MOD = 1e9 + 7;
//ll MOD = 998244353;
const char nl = '\n';
const ll inf = 1e15;
#define fill(a,b) memset(a, b, sizeof(a))
#define setbits(x) __builtin_popcountll(x)
#define print2d(dp,n,m) fo(i, n){fo(j, m)cout<<dp[i][j]<<" ";cout<<"\n";}
ll nxt(){ll x; cin >> x; return x;}
ll mul(ll x,ll y){
return (1ll* (x%MOD)*(y%MOD));
}
ll modpow(ll x,ll y){ll z=1;while(y>0){if(y%2)z=mul(z,x);x =mul(x,x) ;y/=2;}return z;}
ll power(ll x,ll y){ll z=1;while(y>0){if(y%2)z=z*x;x =x*x ;y/=2;}return z;}
ll gcd(ll a,ll b){if(a<b) return gcd(b,a);if(b==0) return a;return gcd(b,a%b);}
ll min(ll a,ll b){if(a<b)return a;return b;}
ll max(ll a,ll b){if(a>b)return a;return b;}
ll sq(ll a){
ll ans = (1ll*a*a);
return ans;
}
void solve(){
ll n;
cin >> n;
ll mn = inf;
ll ans = 0;
fo(i, n){
ll x;
cin >> x;
mn = min(mn ,x);
if(mn >= x)ans++;
}
ANS;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0),cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("inputf.txt" , "r" , stdin) ;
freopen("outputf.txt" , "w" , stdout) ;
freopen("error.txt" , "w" , stderr) ;
#endif
ll TC = 1;
//cin>>TC;
while(TC--){
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC << "ms\n";
}
| 0 |
#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<string>
#include<cstring>
#include<cctype>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<iomanip>
#include<sstream>
#include<vector>
#include<cstdlib>
#include<ctime>
#include<list>
#include<deque>
#include<bitset>
#include<fstream>
#define ld double
#define ull unsigned long long
#define ll long long
#define pii pair<int,int >
#define iiii pair<int,pii >
#define mp make_pair
#define INF 1000000000
#define MOD 1000000007
#define rep(i,x) for(int (i)=0;(i)<(x);(i)++)
inline int getint(){
int x=0,p=1;char c=getchar();
while (c<=32)c=getchar();
if(c==45)p=-p,c=getchar();
while (c>32)x=x*10+c-48,c=getchar();
return x*p;
}
using namespace std;
//ruogu
const int N=310;
int n,k,dp[N][N][N];
char s[N];
//
int go(int l,int r,int x){
if(l>r)return 0;
if(l==r)return 1;
if(dp[l][r][x]!=-1)return dp[l][r][x];
int ans=max(go(l+1,r,x),go(l,r-1,x));
if(s[l]==s[r])ans=max(ans,go(l+1,r-1,x)+2);
if(x>0)ans=max(ans,go(l+1,r-1,x-1)+2);
return dp[l][r][x]=ans;
}
int main(){
memset(dp,-1,sizeof(dp));
scanf("%s",s);
n=strlen(s);
scanf("%d",&k);
printf("%d\n",go(0,n-1,k));
return 0;
} | #include <stdio.h>
#include <math.h>
int n;
int a[1000000];
int cnt;
void insertionSort(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 g[100000];
g[0] = 1;
int m = 0;
while (g[m] <= n) {
g[m + 1] = 3 * g[m] + 1;
m ++;
}
printf("%d\n", m);
for (int i = m - 1; i >= 0; i --) {
if (i < m - 1) printf(" ");
printf("%d", g[i]);
}
puts("");
for (int i = m - 1; i >= 0; i --) {
insertionSort(g[i]);
}
printf("%d\n", cnt);
for (int i = 0; i < n; i ++) {
printf("%d\n", a[i]);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i ++) {
scanf("%d", &a[i]);
}
shellSort();
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define fin(ans) cout << (ans) << endl;
#define blank(ans) cout << (ans) << " ";
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
typedef long long ll;
typedef long long lli;
typedef unsigned long long ull;
typedef long double ld;
typedef string str;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<ld> vd;
typedef vector<str> vs;
typedef vector<ll> vll;
typedef vector<pair<ll, ll>> vpll;
typedef vector<pair<ll, str>> vpls;
typedef vector<tuple<str, ll, ll>> vtsl;
typedef vector<vector<ll>> vvll;
typedef vector<vector<char>> vvc;
typedef vector<vector<str>> vvs;
const ld PI = acos(-1.0);
const ll MAX = 9000000000000000000;
const ll MIN = -9000000000000000000;
const ld DMAX = 4500;
const ld DMIN = -4500;
const ll MOD = 1000000007;
//実行部
void Main()
{
str s; cin >>s;
if(s.size()==3) reverse(all(s));
fin(s)
return;
}
//前処理
int main()
{
//ios::sync_with_stdio(false);
//cin.tie(0);
cout << fixed << setprecision(20); //高精度少数表示
Main();
return 0;
}
| #include <cstdio>
#include <vector>
#include <algorithm>
#include <set>
#include <cstring>
#include <map>
using namespace std;
const int MAXN = 1000005;
char S[MAXN], T[MAXN];
int n, q[MAXN], head = 1, tail;
signed main () {
scanf("%d%s%s", &n, S+1, T+1);
if(strcmp(S+1, T+1) == 0) { puts("0"); return 0; }
int ans = 0;
for(int i = n, j = n; i >= 1; --i) {
if(T[i] == T[i-1]) continue;
j = min(j, i);
for(; j && S[j] != T[i]; --j);
if(!j) { puts("-1"); return 0; }
while(head <= tail && q[head] - (tail-head+1) + 1 > i) ++head;
q[++tail] = j;
if(i != j) ans = max(ans, tail-head+1);
}
printf("%d\n", ans+1);
} | 0 |
#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>;
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); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> l(n * 2);
rep(i, 0, n * 2) cin >> l[i];
sort(l.begin(), l.end());
int ans = 0;
rep(i, 1, n * 2) {
ans += min(l[i], l[i - 1]);
i++;
}
cout << ans << endl;
}
| #include <cstdio>
#include <cstring>
#include <algorithm>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)
using namespace std;
typedef long long ll;
int read() {
char ch;
for(ch=getchar();ch<'0'||ch>'9';ch=getchar());
int x=ch-'0';
for(ch=getchar();ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
return x;
}
const int N=1e5+5;
int n,s,x[N];
ll t[N],p[N];
void solve(int l,int r) {
if (x[r]<s) {
fo(i,l,r) t[i]=s-x[i];
return;
}
if (x[l]>s) {
fo(i,l,r) t[i]=x[i]-s;
return;
}
if (p[l]>=p[r]) {
p[l]+=p[r];
solve(l,r-1);
t[r]=t[l]+x[r]-x[l];
} else {
p[r]+=p[l];
solve(l+1,r);
t[l]=t[r]+x[r]-x[l];
}
}
int main() {
n=read();s=read();
fo(i,1,n) x[i]=read(),p[i]=read();
solve(1,n);
printf("%lld\n",max(t[1],t[n]));
return 0;
} | 0 |
#include <bits/stdc++.h>
struct Point
{
long long x, y, distance{1000000000000};
std::vector<std::pair<int, long long>> edge;
};
using pli = std::pair<long long, int>;
int main()
{
int n;
Point points[100000];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%lld%lld", &points[i].x, &points[i].y);
{
int sort_p[100000];
for (int i = 0; i < n; i++)
sort_p[i] = i;
std::sort(sort_p, sort_p + n, [&](const int &a, const int &b) { return points[a].x < points[b].x; });
for (int i = 0; i < n - 1; i++)
points[sort_p[i]].edge.push_back({sort_p[i + 1], points[sort_p[i + 1]].x - points[sort_p[i]].x});
for (int i = 1; i < n; i++)
points[sort_p[i]].edge.push_back({sort_p[i - 1], points[sort_p[i]].x - points[sort_p[i - 1]].x});
std::sort(sort_p, sort_p + n, [&](const int &a, const int &b) { return points[a].y < points[b].y; });
for (int i = 0; i < n - 1; i++)
points[sort_p[i]].edge.push_back({sort_p[i + 1], points[sort_p[i + 1]].y - points[sort_p[i]].y});
for (int i = 1; i < n; i++)
points[sort_p[i]].edge.push_back({sort_p[i - 1], points[sort_p[i]].y - points[sort_p[i - 1]].y});
}
bool connected[100000]{};
long long sum{};
int rest{n - 1};
std::priority_queue<pli, std::vector<pli>, std::greater<pli>> pq;
connected[0] = true;
for (auto &e : points[0].edge)
{
points[e.first].distance = e.second;
pq.push({e.second, e.first});
}
while (rest)
{
auto next = pq.top();
pq.pop();
if (connected[next.second]) continue;
rest--;
connected[next.second] = true;
sum += next.first;
for (auto &e : points[next.second].edge)
{
if (e.second >= points[e.first].distance) continue;
points[e.first].distance = e.second;
pq.push({e.second, e.first});
}
}
printf("%lld\n", sum);
return 0;
} | #include<bits/stdc++.h>
#define INF 100000000
using namespace std;
int n,m[101][101],p[101];
void dp();
int main(){
cin>>n;
for(int i=0;i<n;i++)cin>>p[i-1]>>p[i];
dp();
cout<<m[1][n]<<endl;
return 0;
}
void dp(){
for(int l=2;l<=n;l++)
for(int i=1;i<=n-l+1;i++){
int j=i+l-1;
m[i][j]=INF;
for(int k=i;k<j;k++){
int a=m[i][k]+m[k+1][j]+p[i-2]*p[k-1]*p[j-1];
if(m[i][j]>a)m[i][j]=a;
}
}
}
| 0 |
#include <iostream>
using namespace std;
int n = 0, a[100000] = { 0 };
int partition(int a[100000], int p, int r) {
int x = a[r - 1];
int i = p - 1;
for (int j = p; j < r; j++) {
if (a[j - 1] <= x) {
i++;
swap(a[i - 1], a[j - 1]);
}
}
swap(a[i], a[r - 1]);
return i + 1;
}
int main()
{
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
int k = 0;
k = partition(a, 1, n);
for (int i = 0; i < k - 1; i++)
cout << a[i] << " ";
if (k < n) {
cout << "[" << a[k - 1] << "] ";
if (k < n - 1) {
for (int i = k; i < n - 1; i++)
cout << a[i] << " ";
}
cout << a[n - 1] << endl;
}
else
cout << "[" << a[n - 1] << "]" << endl;
return 0;
} | #include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>
using namespace std;
void swap(int &a, int &b) {
int t = a;
a = b;
b = t;
}
int partition(vector<int> &A, int p, int r) {
int x = A[r];
int i = p;
for (int j = p; j < r; j++) {
if (A[j] <= x) {
swap(A[i], A[j]);
i++;
}
}
swap(A[i], A[r]);
return i;
}
int main() {
int n = 0;
cin >> n;
vector<int> v;
v.resize(n);
{
vector<int>::iterator i = v.begin();
copy(istream_iterator<int>(cin), istream_iterator<int>(), i++);
}
int p = partition(v, 0, n-1);
for (int i = 0; i < n; i++) {
if (i == p) {
cout << "[" << v[i] << "] ";
}
else if (i == n - 1) {
cout << v[i] << "\n";
}
else {
cout << v[i] << " ";
}
}
return 0;
} | 1 |
#include <bits/stdc++.h>
const double pi = 3.141592653589793238462643383279;
using namespace std;
//typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef pair<int, PII> TIII;
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
//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 SQ(a) ((a)*(a))
#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,s,n) for(int i=s;i<(int)n;++i)
#define REP(i,n) FOR(i,0,n)
#define MOD 1000000007
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const double EPS = 1E-8;
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
// ここから編集
void solve(){
int N;cin >> N;
vector<ll>a(N);
REP(i,N)cin >> a[i];
string s; cin >> s;
vector<ll> b;
for(int i=N-1; i>=0; i--){
ll v = a[i];
for(auto x:b) chmin(v, v^x);
if(v){
if(s[i] == '1'){
cout << 1 << endl;
return;
}
b.push_back(v);
}
}
cout << 0 << endl;
return;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
int t;
cin >> t;
while(t--){
solve();
}
return 0;
}
| #pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
#include<bits/stdc++.h>
using namespace std;
#define GODSPEED ios:: sync_with_stdio(0);cin.tie(0);cout.tie(0);cout<<fixed;cout<<setprecision(15);
#define f first
#define s second
#define newl cout<<"\n";
#define pb push_back
#define mset(a,x) memset(a,x,sizeof(a))
#define debv(a) for(auto it: a)cout<<it<<" ";newl;
#define deb1(a) cout<<a<<"\n";
#define deb2(a,b) cout<<a<<" "<<b<<"\n";
#define deb3(a,b,c) cout<<a<<" "<<b<<" "<<c<<"\n";
#define deb4(a,b,c,d) cout<<a<<" "<<b<<" "<<c<<" "<<d<<"\n";
#define uniq(a) a.resize(unique(a.begin(), a.end()) - a.begin());
#define all(a) a.begin(),a.end()
typedef long long ll;
typedef long double ld;
typedef pair<ll,ll> pll;
typedef vector<ll> vll;
typedef vector<pll> vpll;
const ll N = 2e6+5;
const ll mod = 1e9+7;
const ll INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
ll test = 1, n, a[N], basis[64];
string s;
bool check(ll x){
for(int j = 0; j < 60; j++){
if(((1ll<<j)&x) == 0) continue;
if(!basis[j]) return false;
x ^= basis[j];
}
return true;
}
void insert(ll x){
for(int j = 0; j < 60; j++){
if(((1ll<<j)&x) == 0) continue;
if(basis[j]) x ^= basis[j];
else{
basis[j] = x;
break;
}
}
}
void solve(){
for(int i = 0; i < 60; i++) basis[i] = 0;
cin>>n;
for(int i = 1; i <= n; i++) cin>>a[i];
cin>>s; s = '0'+s;
for(int i = n; i >= 0; i--){
if(s[i] == '0') insert(a[i]);
else if(!check(a[i])){ deb1(1) return; }
}
deb1(0)
}
int main(){
GODSPEED;
cin>>test;
for(int i = 1; i <= test; i++){
solve();
}
#ifndef ONLINE_JUDGE
cout<<"\nTime Elapsed: " << 1.0*clock() / CLOCKS_PER_SEC << " sec\n";
#endif
} | 1 |
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#endif
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <sstream>
#include <numeric>
#include <map>
#include <set>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
static const LL INF = 1LL << 60;
template<typename T, int SIZE, T DEF_VAL, const T& Compare(const T&, const T&)>
class SegmentTree {
vector<T> val;
public:
SegmentTree() : val(SIZE * 2, DEF_VAL) { }
void update(int i, const T& value) {
i += SIZE;
val[i] = value;
while (i > 1) i >>= 1, val[i] = Compare(val[i * 2], val[i * 2 + 1]);
}
T get(LL a, LL b, int l = 0, int r = SIZE, size_t i = 1) {
if (r <= a || b <= l) return DEF_VAL;
if (a <= l && r <= b) return val[i];
return Compare(get(a, b, l, (l + r) / 2, i * 2), get(a, b, (l + r) / 2, r, i * 2 + 1));
}
LL find_leftmost_index(LL a, LL b, const T& value, int l = 0, int r = SIZE, int i = 1) {
if (Compare(val[i], value) != val[i]) return -1;
if (r <= a || b <= l) return -1;
if (i >= SIZE) return i - SIZE;
LL leftmost_index = find_leftmost_index(a, b, value, l, (l + r) / 2, i * 2);
if (leftmost_index >= 0) return leftmost_index;
return find_leftmost_index(a, b, value, (l + r) / 2, r, i * 2 + 1);
}
LL find_rightmost_index(LL a, LL b, const T& value, int l = 0, int r = SIZE, int i = 1) {
if (Compare(val[i], value) != val[i]) return -1;
if (r <= a || b <= l) return -1;
if (i >= SIZE) return i - SIZE;
LL rightmost_index = find_rightmost_index(a, b, value, (l + r) / 2, r, i * 2 + 1);
if (rightmost_index >= 0) return rightmost_index;
return find_rightmost_index(a, b, value, l, (l + r) / 2, i * 2);
}
};
void solve(long long H, long long W, std::vector<long long> &A, std::vector<long long> &B) {
SegmentTree<long long, 1 << 18, INF, min> st;
for (int i = 0; i < W; ++i) {
st.update(i, 0);
}
for (LL y = 0; y < H; ++y) {
LL a = A[y], b = B[y];
while (true) {
LL min_value = st.get(a, b);
if (min_value == INF) break;
LL index = st.find_leftmost_index(a, b, min_value);
LL next_cost = min_value + b - index;
if (b < W && next_cost < st.get(b, b + 1)) {
st.update(b, next_cost);
}
st.update(index, INF);
}
LL cost = y + 1 + st.get(0, W);
cout << (cost < INF ? cost : -1) << endl;
}
}
int main() {
long long H;
scanf("%lld", &H);
long long W;
scanf("%lld", &W);
std::vector<long long> A(H);
std::vector<long long> B(H);
for (int i = 0; i < H; i++) {
scanf("%lld", &A[i]); A[i]--;
scanf("%lld", &B[i]);
}
solve(H, W, A, B);
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
const int N=2e5+5;
int n,m,ans[N],a[N],b[N],t[N<<2],t1[N<<2],t2[N<<2];
void update(int l,int r,int k)
{
t1[k]=t[k]+r-l;t2[k]=t[k];
if(l!=r)
{
int m=l+r>>1;
t[k<<1]=t[k];t[k<<1|1]=t[k]+m+1-l;
}
t[k]=0;
}
int query(int l,int r,int k,int x)
{
if(t[k]) update(l,r,k);
if(l>x) return m+1;
if(r<=x) return t1[k];
int m=l+r>>1;
int a=query(l,m,k<<1,x),b=query(m+1,r,k<<1|1,x);
if(x<=r) a+=x>=m?x-m:0;
else a+=r-m;
t2[k]=min(t2[k<<1],t2[k<<1|1]);
t1[k]=min(t1[k<<1]+r-m,t1[k<<1|1]);
return min(a,b);
}
void update(int l,int r,int k,int x,int y,int d)
{
if(t[k]) update(l,r,k);
if(r<x||l>y) return;
if(l>=x&&r<=y)
{
t[k]=d+l-x;
update(l,r,k);
return;
}
int m=l+r>>1;
update(l,m,k<<1,x,y,d);update(m+1,r,k<<1|1,x,y,d);
t2[k]=min(t2[k<<1],t2[k<<1|1]);
t1[k]=min(t1[k<<1]+r-m,t1[k<<1|1]);
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) scanf("%d%d",&a[i],&b[i]);
for(int i=1;i<=n;i++)
{
int d=min(m+1,query(1,m,1,a[i]-1)+1);
update(1,m,1,a[i],b[i],d);
ans[i]=t2[1];
}
for(int i=1;i<=n;i++)
{
if(ans[i]>=m) ans[i]=-1;
else ans[i]+=i;
printf("%d\n",ans[i]);
}
}
| 1 |
#define _USE_MATH_DEFINES
#include <iostream>
#include <iomanip>
#include <cctype>
#include <cstdlib>
#include <algorithm>
#include <functional>
#include <vector>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cfloat>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <string>
#include <set>
#include <complex>
#include <utility>
#include <numeric>
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,a,n) for(int i=a;i<(n);i++)
#define rrep(i,n) for(int i=(n)-1;i>=0;i--)
#define VI vector<int>
#define VS vector<string>
#define all(a) (a).begin(),(a).end()
#define debug(x) cout<<#x<<": "<<x<<endl
using namespace std;
typedef long long int ll;
typedef string::const_iterator State;
typedef pair<int,int> P;
class ParseError {};
const ll INF=1LL<<50;
char fi[101][101];
int day[12]={31,28,31,30,31,30,31,31,30,31,30,31};
double EPS = 1e-14;
const int MAX_V=100;
const int MAX_N=100;
char o[3]={'+','-','*'};
#define md 1000003
int bow[353][353]={0};
double add(double a,double b){
if(abs(a+b)<EPS*(abs(a)+abs(b)))
return 0;
return a+b;
}
/*struct P{
double x,y;
P(){}
P(double x,double y):x(x),y(y){
}
P operator + (P p){
return P(add(x,p.x),add(y,p.y));
}
P operator - (P p){
return P(add(x,-p.x),add(y,-p.y));
}
P operator *(double d){
return P(x*d,y*d);
}
double dot(P p){
return add(x*p.x,y*p.y);
}
double det(P p){
return add(x*p.y,-y*p.x);
}
};
bool cmp_x(const P& p,const P& q){
if(p.x!=q.x) return p.x<q.x;
return p.y<q.y;
}
vector<P> convex_hull(P* ps, int n){
sort(ps,ps+n,cmp_x);
int k=0;
vector<P> qs(n*2);
rep(i,n){
while(k>1&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)
k--;
qs[k++]=ps[i];
}
for(int i=n-2,t=k;i>=0;i--){
while(k>t&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)
k--;
qs[k++]=ps[i];
}
qs.resize(k-1);
return qs;
}
int n,m;
vector<double> p;
P ps[101];
*/
//char c[520][520];
long long mod=1000000007;
long long pow(ll i,ll j){
ll tmp=1;
while(j){
if(j%2) tmp=tmp*i%mod;
i=i*i%mod;
j/=2;
}
return tmp;
}
int expression(State&);
int term(State&);
int factor(State&);
int number(State&);
int expression(State &begin){
int ret = term(begin);
for(;;){
if(*begin == '+'){
begin++;
ret += term(begin);
}
else if(*begin == '-'){
begin++;
ret -= term(begin);
}
else
break;
}
return ret;
}
int term(State &begin){
int ret = factor(begin);
for(;;){
if(*begin=='*'){
begin++;
ret *= factor(begin);
}
else if(*begin=='/'){
begin++;
ret /= factor(begin);
}
else
break;
}
return ret;
}
int factor(State &begin){
int ret;
if(*begin == '('){
begin++;
ret = expression(begin);
begin++;
}
else
ret = number(begin);
return ret;
}
int number(State &begin){
int ret =0;
while(isdigit(*begin)){
ret*=10;
ret+=*begin - '0';
begin++;
}
return ret;
}
int main(void){
int n;
while(cin>>n,n!=0){
vector<ll> c(n);
for(int i=0;i<n;i++){
cin>>c[i];
}
string s;
cin>>s;
ll k=0;
for(int i=0;i<s.size();i++){
if(s[i]>='A'&&s[i]<='Z'){
if(s[i]-'A'<c[k%n]){
int tmp=c[k%n]-(s[i]-'A'+1);
if('z'-'a'<tmp)
s[i]='Z'-(tmp-('z'-'a'+1));
else
s[i]='z'-tmp;
}
else
s[i]=s[i]-c[k%n];
}
else if(s[i]>='a'&&s[i]<='z'){
if(s[i]-'a'<c[k%n]){
int tmp=c[k%n]-(s[i]-'a'+1);
if('Z'-'A'<tmp)
s[i]='z'-(tmp-('Z'-'A'+1));
else
s[i]='Z'-tmp;
}
else
s[i]=s[i]-c[k%n];
}
k++;
}
cout<<s<<endl;
}
} | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
#include <fstream>
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 ALL(s) (s).begin(),(s).end()
#define fi first
#define se second
#define PI acos(-1.0)
#define INF 10e9+9
#define EPS 1e-10
#define MAX_N 100100
#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 n, k[1000];
string s;
int main(){
while (cin >> n&&n){
REP(i, n)cin >> k[i];
cin >> s;
int key = 0;
REP(i, s.size()){
REP(j, k[key]){
if (s[i] == 'a'){
s[i] = 'Z';
}
else if (s[i] == 'A'){
s[i] = 'z';
}
else{
s[i]--;
}
}
key++;
if (key >= n)key = 0;
}
cout << s << endl;
}
} | 1 |
#include<stdio.h>
int main(){
int W[10],K[10],i,j,c;
for(i=0;i<10;i++){
scanf("%d",&W[i]);
}
for(i=0;i<10;i++){
scanf("%d",&K[i]);
}
for(i=0;i<10;i++){
for(j=i;j<10;j++){
if(W[i]<W[j]){
c=W[i];
W[i]=W[j];
W[j]=c;
}
if(K[i]<K[j]){
c=K[i];
K[i]=K[j];
K[j]=c;
}
}
}
printf("%d %d\n",W[0]+W[1]+W[2],K[0]+K[1]+K[2]);
return 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 fi first
#define se second
using namespace std;
typedef long long ll;
typedef vector<int> vint;
typedef pair<int,int> pii;
int main(){
vint w(10),k(10);
int sw=0,sk=0;
rep(i,0,10) cin>>w[i];
rep(i,0,10) cin>>k[i];
sort(all(w));
sort(all(k));
rep(i,7,10) sw+=w[i];
rep(i,7,10) sk+=k[i];
o(sw<<" "<<sk);
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int mod=1000000007;
signed main(){
int N;
cin>>N;
vector<int> A(64,0);
for(int j=0;j<N;j++){
int B;
cin>>B;
bitset<64> C(B);
for(int i=0;i<64;i++)
if(C.test(i))
A[i]++;
}
int ans=0;
for(int i=0,j=1;i<64;i++,j=j*2%mod)
ans=(ans+j*(A[i]*(N-A[i])%mod))%mod;
cout<<ans<<endl;
} | /* ꧁༒☬महाकाल☬༒꧂ ꧁༒ঔमहाकालঔ༒꧂
ঔৣमहाकालᴳᵒᵈঔৣ
*/
#include<bits/stdc++.h>
using namespace std;
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
//template <typename T, typename cmp=less<T>> using oset =tree<T, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
#define ll long long
#define mod 1000000007
#define MOD 998244353
#define inf 100000000000000000
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define _it iterator
#define all(_x) _x.begin(),_x.end()
#define f first
#define s second
#define pb push_back
#define ar array
#define ld long double
void mahakal(){
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
freopen("error.txt","w",stderr);
#endif
}
ll dx[4]={1,0,-1,0};
ll dy[4]={0,1,0,-1};
char c[4]={'D' , 'R' , 'U' , 'L'};
const ll maxN=3e2+5;
ll n , cnt[4] ;
ld dp[maxN][maxN][maxN];
// dp[three][two][one][zero] where three is the no of 3 and two is the no of 2 ......
// three=two=one=zero=n=300 (300^4)
// zero=n-one-two - three
// dp[three][two][one]
// if i pich three dp[three-1][two+1][one]
// if i pick two dp[three][two-1][one+1]
// if i pick one dp[three][two][one-1];
// dp[three][two][one]=(three/n)*dp[three-1][two+1][one] + (two/n)dp[three][two-1][one+1] +
// one/n * dp[three][two][one-1] + zero/n * dp[three][two][one];
// dp[three][two][one](1-zero/n)=(three/n)*dp[three-1][two+1][one] + (two/n)dp[three][two-1][one+1] +
// one/n * dp[three][two][one-1]
// dp[three][two][one]==((three/n)*dp[three-1][two+1][one] + (two/n)dp[three][two-1][one+1] +
// one/n * dp[three][two][one-1])/(1-zero/n)
void solve(){
cin>>n ;
for(ll i=0 , x ;i<n ;i++){
cin>> x ; cnt[x]++;
}
dp[0][0][0]=0;
for(ll three=0 ;three<=n ; three++){
for(ll two=0 ; two<=n ; two++){
for(ll one=0 ; one<=n ; one++){
ll zero=n-three-two-one;
if(zero==n)continue;
if(three+two+one>n)continue;
ld value=1;
// picking three
if(three>0)value+=(1.0*three/n)*dp[three-1][two+1][one];
if(two>0)value+=(1.0*two/n)*dp[three][two-1][one+1];
if(one>0)value+=(1.0*one/n)*dp[three][two][one-1];
dp[three][two][one]=(value)/(1-1.0*zero/n);
}
}
}
ld ans=dp[cnt[3]][cnt[2]][cnt[1]];
cout<<fixed<<setprecision(10);
cout<<ans<<endl;
}
int main(){
//mahakal();
fast;
ll t =1 ;
//cin>> t ;
while(t--)solve();
//cerr << "\ntime taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl;
return 0;
} | 0 |
#pragma GCC optimize ("Ofast")
#include<bits/stdc++.h>
using namespace std;
template<class S, class T> inline S max_L(S a,T b){
return a>=b?a:b;
}
inline int my_getchar_unlocked(){
static char buf[1048576];
static int s = 1048576;
static int e = 1048576;
if(s == e && e == 1048576){
e = fread_unlocked(buf, 1, 1048576, stdin);
s = 0;
}
if(s == e){
return EOF;
}
return buf[s++];
}
inline void rd(int &x){
int k;
int m=0;
x=0;
for(;;){
k = my_getchar_unlocked();
if(k=='-'){
m=1;
break;
}
if('0'<=k&&k<='9'){
x=k-'0';
break;
}
}
for(;;){
k = my_getchar_unlocked();
if(k<'0'||k>'9'){
break;
}
x=x*10+k-'0';
}
if(m){
x=-x;
}
}
struct MY_WRITER{
char buf[1048576];
int s;
int e;
MY_WRITER(){
s = 0;
e = 1048576;
}
~MY_WRITER(){
if(s){
fwrite_unlocked(buf, 1, s, stdout);
}
}
}
;
MY_WRITER MY_WRITER_VAR;
void my_putchar_unlocked(int a){
if(MY_WRITER_VAR.s == MY_WRITER_VAR.e){
fwrite_unlocked(MY_WRITER_VAR.buf, 1, MY_WRITER_VAR.s, stdout);
MY_WRITER_VAR.s = 0;
}
MY_WRITER_VAR.buf[MY_WRITER_VAR.s++] = a;
}
inline void wt_L(char a){
my_putchar_unlocked(a);
}
inline void wt_L(long long x){
int s=0;
int m=0;
char f[20];
if(x<0){
m=1;
x=-x;
}
while(x){
f[s++]=x%10;
x/=10;
}
if(!s){
f[s++]=0;
}
if(m){
my_putchar_unlocked('-');
}
while(s--){
my_putchar_unlocked(f[s]+'0');
}
}
template<class S, class T> inline S chmax(S &a, T b){
if(a<b){
a=b;
}
return a;
}
int N;
int A[200000];
int main(){
int i;
long long res = 0;
long long mx = -1;
rd(N);
{
int Lj4PdHRW;
for(Lj4PdHRW=(0);Lj4PdHRW<(N);Lj4PdHRW++){
rd(A[Lj4PdHRW]);
}
}
for(i=(0);i<(N);i++){
res +=max_L(mx - A[i], 0);
chmax(mx, A[i]);
}
wt_L(res);
wt_L('\n');
return 0;
}
// cLay varsion 20200911-1
// --- original code ---
// int N, A[2d5];
// {
// ll res = 0, mx = -1;
// rd(N,A(N));
// rep(i,N){
// res += max(mx - A[i], 0);
// mx >?= A[i];
// }
// wt(res);
// }
| #include <bits/stdc++.h>
#define pt(sth) cout << sth << "\n"
#define chmax(a, b) {if(a<b) a=b;}
#define chmin(a, b) {if(a>b) a=b;}
#define moC(a, s, b) (a)=((a)s(b)+MOD)%MOD
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
static const ll INF=1e18;
static const ll MAX=101010;
static const ll MOD=1e9+7;
/*
for(i=0; i<N; i++)
*/
ll N, M;
vector<ll> g[MAX];
ll clr[MAX];
void dfs(ll c, ll u) {
if(clr[u]!=-1) return;
clr[u]=c;
for(ll i=0; i<g[u].size(); i++)
dfs(1-c, g[u][i]);
}
int main(void) {
ll i, j, k;
cin >> N >> M;
for(i=0; i<M; i++) {
ll a, b;
cin >> a >> b;
a--; b--;
g[a].push_back(b);
g[b].push_back(a);
}
memset(clr, -1, sizeof(clr));
dfs(0, 0);
for(i=0; i<N; i++) {
for(j=0; j<g[i].size(); j++) {
if(clr[i]==clr[g[i][j]]) { //not bipartite graph
pt(N*(N-1)/2-M);
return 0;
}
}
}
ll cnt=0;
for(i=0; i<N; i++) if(clr[i]==0) cnt++;
pt(cnt*(N-cnt)-M);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define rep(i,s,e) for(int (i) = (s);(i) <= (e);(i)++)
#define all(x) x.begin(),x.end()
int main() {
int n,k;
while(cin >> n >> k, n && k) {
long long INF = 1e10;
vector<vector<long long>> dist(n, vector<long long>(n, INF));
for(int i = 0;i < n;i++) dist[i][i] = 0;
for(int q = 0;q < k;q++) {
int Q;
cin >> Q;
if(Q == 0) {
int a, b;
cin >> a >> b;
a--;
b--;
if(dist[a][b] < INF) {
cout << dist[a][b] << endl;
}
else {
cout << -1 << endl;
}
}
else {
long long c,d,e;
cin >> c >> d >> e;
c--;
d--;
dist[c][d] = min(dist[c][d], e);
dist[d][c] = min(dist[d][c], e);
for(int i = 0;i < n;i++) for(int j = 0;j < n;j++) {
dist[i][j] = min(dist[i][j], dist[i][c] + dist[c][d] + dist[d][j]);
}
for(int i = 0;i < n;i++) for(int j = 0;j < n;j++) {
dist[i][j] = min(dist[i][j], dist[i][d] + dist[d][c] + dist[c][j]);
}
}
}
}
}
| #include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
#include<queue>
#define PAIR pair<long long,int>
using namespace std;
class island{
public:
vector<PAIR> road;
void add(int goal,int much){
road.push_back(PAIR(much,goal));
}
};
long long func(vector<island>&,int,int);
int main(){
int n,m;
while(cin>>n>>m&&n){
vector<island> map(n+1);
for(int i=0;i<m;++i){
int type;
cin>>type;
if(type==1) {
int a,b,much;
cin>>a>>b>>much;
map[a].add(b,much);
map[b].add(a,much);
}else{
int s,g;
cin>>s>>g;
cout<<func(map,s,g)<<endl;
}
}
}
return 0;
}
long long func(vector<island>& map,int s,int g){
vector<long long> much(map.size()+1,-1);
priority_queue<PAIR,vector<PAIR>,greater<PAIR> > que;
que.push(PAIR(0,s));
much[s]=0;
while(!que.empty()){
PAIR dpair = que.top();
que.pop();
long long time = dpair.first;
int np = dpair.second;
if(much[np]!=time){
continue;
}
for(vector<PAIR>::iterator itr = map[np].road.begin();itr!=map[np].road.end();++itr){
long long ntime = time + itr->first;
int ng = itr->second;
if(much[ng]==-1||much[ng]>ntime){
much[ng]=ntime;
que.push(PAIR(ntime,ng));
}
}
}
return much[g];
}
| 1 |
#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 N; string S, T;
cin >> N >> S >> T;
for (int i = 0; i < N; i++){
string ans = "";
for (int j = 0; j < i; j++) ans += S[j];
for (int j = 0; j < N; j++) ans += T[j];
bool flag = true;
for (int j = 0; j < N; j++){
if (ans[j] != S[j]) flag = false;
}
if (flag){
cout << ans.length() << endl;
return 0;
}
}
cout << N * 2 << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <vector>
# include <cstdint>
#define FOR(i,l,r) for(int i=(l);i<(r);++i)
#define RFOR(i,l,r) for(int i=(l);i>=(int)(r);i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,n-1,0)
#define int long long
using namespace std;
const int MX = 1e6;
const int inf = 1e13;
const int mod = 1e9+7;
#define ll long long
signed main() {
int n;
string s,t;
cin >> n >> s >>t;
int sz = s.length();
int tz = t.length();
if(sz+tz<=n) {
cout << n << endl;
return 0;
}
int ma = 0;
rrep(i,tz) {
int ss = sz-1;
int tmp=0;
while(i>=0 && ss>=0) {
// cout << s[ss]<<t[i]<<ss<<" "<<i<<" " << endl;
if(s[ss]==t[i]) {
if(i==0) {
cout << sz+tz-(sz-ss) << endl;
return 0;
}
ss--;
tmp++;
}else {
if(tmp>0) i++;
break;
}
i--;
}
ma=max(tmp,ma);
//cout << ma << endl;
}
cout << sz+tz-ma << endl;
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main()
{
int a, b;
cin >> a >> b;
if (a + b >= a - b && a + b >= a * b) {
cout << a + b << endl;
}
else if (a - b >= a + b && a - b >= a * b) {
cout << a - b << endl;
}
else if (a * b >= a + b && a * b >= a - b) {
cout << a * b << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define ll long long int
#define MOD 1000000007
#define INF 1e18
#define PI 3.14159265358979
using namespace std;
ll power(ll n, ll k){
ll res = 1;
while(k > 0){
if (k & 1)
res = res * n % MOD;
n = n * n % MOD;
k >>= 1;
}
return res;
}
ll genfact(ll n, ll k){
ll res = 1;
k--;
while (k >= 0){
res = (res * (n - k)) % MOD;
k--;
}
return res;
}
ll inv(ll n){
return power(n, MOD - 2);
}
ll fact(ll n){
return genfact(n, n - 1);
}
ll nck(ll n, ll k){
if (k == 0)
return 1;
if (n <= 0)
return 0;
return ((genfact(n, k) % MOD) * inv(fact(k))) % MOD;
}
int main(void){
ll n, m;
cin >> n >> m;
vector<ll> divisor(0);
for (int i = 2; i*i <= m; i++){
if (m % i == 0){
int t = 0;
while (m % i == 0){
m /= i;
t++;
}
divisor.push_back(t);
}
}
if (m != 1){
divisor.push_back(1);
}
ll ans = 1;
for (int i = 0; i < divisor.size(); i++){
ans = ans * nck(n + divisor[i] - 1, divisor[i]) % MOD;
}
cout << ans << endl;
return 0;
}
| 0 |
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#endif
#include <bits/stdc++.h>
using namespace std;
mt19937 mrand(random_device{} ());
int rnd(int x) {
return mrand() % x;
}
typedef long double ld;
typedef long long ll;
#ifdef DEBUG
#define eprintf(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#else
#define eprintf(...) ;
#endif
#define pb push_back
#define mp make_pair
#define sz(x) ((int) (x).size())
#define TASK "text"
const int inf = (int) 1.01e9;
const ld eps = 1e-9;
const ld pi = acos((ld) -1.0);
const int mod = (int) 1e9 + 7;
void add(int &x, int y) {
if ((x += y) >= mod) {
x -= mod;
}
}
int mult(int x, int y) {
return (long long) x * y % mod;
}
int myPower(int x, int pw) {
int res = 1;
for (; pw; pw >>= 1) {
if (pw & 1) {
res = mult(res, x);
}
x = mult(x, x);
}
return res;
}
void precalc() {
}
const int maxn = 102;
char s[maxn][maxn];
int n, m;
int xe, ye;
int read() {
if (scanf("%d%d", &n, &m) < 2) {
return 0;
}
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
for (int j = 0; j < m; ++j) {
if (s[i][j] == 'E') {
xe = i, ye = j;
}
}
}
return 1;
}
int prec[2][maxn][maxn];
inline int get(int type, int x, int l, int r) {
auto &cur = prec[type][x];
return cur[r] - cur[l];
}
short dp[maxn][maxn][maxn][maxn];
short res;
inline void update(int x1, int x2, int y1, int y2, short nval) {
auto &cur = dp[x1][x2][y1][y2];
if (cur < nval) {
cur = nval;
if (res < nval) {
res = nval;
}
}
}
void solve() {
for (int i = 0; i < n; ++i) {
prec[0][i][0] = 0;
for (int j = 0; j < m; ++j) {
prec[0][i][j + 1] = prec[0][i][j] + (s[i][j] == 'o');
}
}
for (int i = 0; i < m; ++i) {
prec[1][i][0] = 0;
for (int j = 0; j < n; ++j) {
prec[1][i][j + 1] = prec[1][i][j] + (s[j][i] == 'o');
}
}
memset(dp, -1, sizeof(dp));
dp[0][0][0][0] = 0;
int xl = xe + 1, xr = n - xe;
int yl = ye + 1, yr = m - ye;
res = 0;
for (int cxl = 0; cxl < xl; ++cxl) {
for (int cxr = 0; cxr < xr; ++cxr) {
for (int cyl = 0; cyl < yl; ++cyl) {
for (int cyr = 0; cyr < yr; ++cyr) {
auto cur = dp[cxl][cxr][cyl][cyr];
if (cur < 0) {
continue;
}
int x1 = max(xe - cxl, cxr);
int x2 = min(xe + cxr, n - 1 - cxl) + 1;
int y1 = max(ye - cyl, cyr);
int y2 = min(ye + cyr, m - 1 - cyl) + 1;
if (cxr + cxl + 1 < xl) {
update(cxl + 1, cxr, cyl, cyr, cur + get(0, x1 - 1, y1, y2));
}
if (cxr + cxl + 1 < xr) {
update(cxl, cxr + 1, cyl, cyr, cur + get(0, x2, y1, y2));
}
if (cyr + cyl + 1 < yl) {
update(cxl, cxr, cyl + 1, cyr, cur + get(1, y1 - 1, x1, x2));
}
if (cyr + cyl + 1 < yr) {
update(cxl, cxr, cyl, cyr + 1, cur + get(1, y2, x1, x2));
}
}
}
}
}
printf("%d\n", (int) res);
}
int main() {
precalc();
#ifdef LOCAL
freopen(TASK ".out", "w", stdout);
assert(freopen(TASK ".in", "r", stdin));
#endif
while (1) {
if (!read()) {
break;
}
solve();
#ifdef DEBUG
eprintf("Time %.2f\n", (double) clock() / CLOCKS_PER_SEC);
#endif
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
// Reference : Erichto + https://www.youtube.com/watch?v=1HiJ332iZQU
long double dp[301][301][301];
long double solve(int ones, int twos, int threes, int n) {
// cout<<"At "<<ones <<" "<< twos <<" "<< threes<<endl;
if(ones + twos + threes == 0) {
// cout<<"Base:"<<0<<endl;
return 0;
}
if(dp[ones][twos][threes] != -1) {
// cout<<"Cache:"<<dp[ones][twos][threes]<<endl;
return dp[ones][twos][threes];
}
long double coeff1 = (long double)ones / (long double)(ones + twos + threes);
long double coeff2 = (long double)twos / (long double)(ones + twos + threes);
long double coeff3 = (long double)threes / (long double)(ones + twos + threes);
long double ans = (long double) n/ (long double) (ones + twos + threes);
dp[ones][twos][threes] = ans +
coeff1 * (ones == 0 ? 0 : solve(ones - 1, twos, threes, n)) +
coeff2 * (twos == 0 ? 0 : solve(ones + 1, twos - 1, threes, n)) +
coeff3 * (threes == 0 ? 0 : solve(ones, twos + 1, threes - 1, n ));
// cout<<"Returning" << dp[ones][twos][threes]<<endl;
return dp[ones][twos][threes];
}
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int n;
cin >> n;
int a[n];
int cnt[4]={0};
for(int i = 0; i < n; ++i) {
cin >> a[i];
cnt[a[i]]++;
}
for(int i = 0; i <= 300; ++i) {
for(int j = 0; j <= 300; ++j) {
for(int k = 0; k <= 300; ++k) {
dp[i][j][k] = -1;
}
}
}
cout<<fixed<<setprecision(20)<<solve(cnt[1], cnt[2], cnt[3], n);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n,m,p;
std::deque<int> deq;
while (cin>>n>>m) {
if (n==0&&m==0) {
break;
} else {
for (int i=0;i<n;i++) {
cin>>p;
deq.emplace_back(p);
}
sort(deq.begin(),deq.end(),greater<int>());
int sum=0;
while (n>=m) {
for (int j=0;j<m;j++) {
if (j!=m-1) {
sum+=deq.front();
deq.pop_front();
n--;
} else {
deq.pop_front();
n--;
}
}
}
if (n!=0) {
for (int k=0;k<n;k++) {
sum+=deq.front();
deq.pop_front();
}
}
cout<<sum<<endl;
}
}
}
| #include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<cassert>
#include<iostream>
#include<sstream>
#include<string>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<utility>
#include<numeric>
#include<algorithm>
#include<bitset>
#include<complex>
using namespace std;
typedef long long Int;
typedef vector<int> vint;
typedef pair<int,int> pint;
#define mp make_pair
template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }
template<class T> void chmin(T &t, T f) { if (t > f) t = f; }
template<class T> void chmax(T &t, T f) { if (t < f) t = f; }
int in() { int x; scanf("%d", &x); return x; }
int main() {
string str;
for(;getline(cin,str);){
int len=str.size();
int i,c;
for(c=1;c<=26;c++){
for(i=0;i<len;i++){
if('a'<=str[i]&&str[i]<='z'){
str[i]++;
if(str[i]>'z')str[i]='a';
}
}
//cout<<str<<endl;
if(str.find("the")!=string::npos||str.find("this")!=string::npos||str.find("that")!=string::npos){
cout<<str<<endl;
break;
}
}
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll cl[1000000][2];
int main(void){
ll i,len,lv,cnt,p,pp,x;
char s[1000001];
cin>>s;
len=strlen(s);
for(i=0;i<len;i++) cl[i][1]=0;
cnt=1; p=0; pp=0;
if(s[0]=='J') cl[0][0]=0;
else if(s[0]=='O') cl[0][0]=1;
else cl[0][0]=2;
for(i=0;i<len;i++){
if(s[pp]!=s[i]){
p++; pp=i;
if(s[pp]=='J') cl[p][0]=0;
else if(s[pp]=='O') cl[p][0]=1;
else cl[p][0]=2;
}
cl[p][1]++;
}
/* for(i=0;i<=p;i++) cout<<cl[i][1]<<' ';
cout<<endl;*/
lv=0;
for(i=1;i<len-1;i++){
if(cl[i][0]==1){
x=cl[i][1];
if(cl[i-1][0]==0&&cl[i+1][0]==2){
if(cl[i-1][1]>=x&&cl[i+1][1]>=x) lv=max(lv,x);
}
}
}
cout<<lv<<endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,a,n) for(int i=a;i<n;i++)
#define repb(i,a,b) for(int i=a;i>=b;i--)
#define all(a) a.begin(),a.end()
#define o(a) cout<<a<<endl
//#define int long long
#define fi first
#define se second
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
signed main() {
string s, t = "JOI";
cin >> s;
s += 'X';
int ans = 0, f = -1, now = 0, pre = 0;
rep(i, 0, s.size()) {
if (s[i] == t[f]) {
now++;
}
else if (f == 0 && s[i] == t[1]) {
pre = now;
now = 1;
f = 1;
}
else if (f == 1 && s[i] == t[2]) {
if (pre < now) {
f = -1;
}
else {
f++;
pre = now;
now = 1;
}
}
else if (f == 2 && s[i] != t[2]) {
if (pre <= now) ans = max(ans, pre);
f = -1;
}
else {
f = -1;
}
if (f == -1 && s[i] == 'J') {
f = 0;
now = 1;
}
}
cout << ans << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair< ll, ll > Pi;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep2(i,n) for(int i=1;i<=(n);i++)
#define rep3(i,i0,n) for(int i=i0;i<(n);i++)
#define pb push_back
#define mod 1000000007
const ll INF = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll a, ll b) {return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) {return a/gcd(a,b)*b;}
#define all(x) x.begin(), x.end()
#define mp make_pair
bool compare(Pi a, Pi b) {
if(a.first != b.first){
return a.first < b.first;
}else{
return a.second < b.second;
}
}
bool In_map(ll y,ll x,ll h,ll w){
if(y<0 || x<0 || y>=h || x>=w){
return 0;
}else{
return 1;
}
}
const vector<ll> dx{1,0,-1,0};
const vector<ll> dy{0,1,0,-1};
int main() {
vector<ll>a(5);
rep(i,5){
cin>>a[i];
}
ll k;
cin>>k;
if(a[4]-a[0]>k){
cout<<":("<<endl;
}else{
cout << "Yay!" << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const double PI = 3.14159265358979323846;
int main() {
int a, b, c, d, e, k;
cin >> a >> b >> c >> d >> e >> k;
if(e - a <= k) cout << "Yay!" << endl;
else cout << ":(" << endl;
} | 1 |
#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 len(x) ((long long)(x).size())
#define g(a, b) __gcd((a), (b))
#define l(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 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, class U>T rem(T a, U b) { return a - b*floor(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;
int main()
{
ll N;
cin >> N;
ll ans = 1;
rep(i, 1, N+1) {
if (i * i > N) break;
ans = i;
}
cout << ans*ans << endl;
} | #include <iostream>
#include <sstream>
#include <algorithm>
#include <string>
#include <cmath>
using namespace std;
int arr[101] = {0};
int main()
{
long long int a, total=0;
cin >> a;
for(int i=1; i<=a; i++)
{
if(i%3 !=0 && i%5 != 0)
{
total += i;
}
}
cout << total;
}
| 0 |
#include <iostream>
#include <queue>
#include <map>
using namespace std;
typedef pair<int, int> P;
int B[101][101];
bool bfs(int w, int h, int xs, int ys, int xg, int yg);
int main(int argc, char** argv)
{
int w, h;
int xs, ys;
int xg, yg;
int n;
int c, d, x, y;
while( 1 )
{
cin >> w;
cin >> h;
if(w==0 && h==0) break;
cin >> xs;
cin >> ys;
cin >> xg;
cin >> yg;
cin >> n;
for(int i=0; i<n; i++)
{
cin >> c; cin >> d; cin >> x; cin >> y;
if(d==0)
{
for(int dx=0; dx<4; dx++)
{
for(int dy=0; dy<2; dy++)
{
B[x+dx][y+dy] = c;
}
}
}
else
{
for(int dx=0; dx<2; dx++)
{
for(int dy=0; dy<4; dy++)
{
B[x+dx][y+dy] = c;
}
}
}
}
cout << (bfs(w, h, xs, ys, xg, yg) ? "OK" : "NG") << endl;
}
return 0;
}
bool bfs(int w, int h, int xs, int ys, int xg, int yg)
{
int x, y, c, xx, yy;
int offset[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
queue<P> q;
P p;
c = B[xs][ys];
B[xs][ys] = 0;
p.first = xs, p.second = ys;
q.push(p);
while(!q.empty())
{
p = q.front();
q.pop();
x = p.first;
y = p.second;
if(x==xg && y==yg) return true;
B[x][y] = 0;
for(int i=0; i<4; i++)
{
xx = x + offset[i][0];
yy = y + offset[i][1];
if(x>=1 && y>=1 && x<=w && y<=h)
{
if(B[xx][yy] == c)
{
p.first = xx;
p.second = yy;
q.push(p);
}
}
}
}
return false;
} | #include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <chrono>
using namespace std;
#define INF 1e18
long long DP[5001][5001];
struct Constraint {
long long H, P;
Constraint(long long H = 0, long long P = 0):H(H), P(P){}
bool operator<(const Constraint& r)const {
return P+H < r.P+r.H;
}
};
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int N; cin >> N;
vector<Constraint>C(N);
for (int i = 0; i < N; i++) {
int P, H; cin >> H >> P;
C[i] = Constraint(H, P);
}
sort(C.begin(), C.end());
for (int i = 0; i <= N; i++)for (int j = 0; j <= N; j++)DP[i][j] = INF;
DP[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < i + 1; j++) {
if (DP[i][j] == INF)continue;
if (DP[i][j] <= C[i].H) {
DP[i + 1][j + 1] = min(DP[i + 1][j + 1], DP[i][j] + C[i].P);
}
DP[i + 1][j] = min(DP[i + 1][j], DP[i][j]);
}
}
int ans = 0;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (DP[i][j]==0 || DP[i][j] == INF)continue;
ans = max(ans, j);
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
// ここにプログラムを追記
int R,G;
cin >> R >> G;
double x = 2 * G - R;
cout << x << endl;
} | #include<iostream>
int main(){
int R,G;
std::cin >> R >> G;
std::cout << G + G - R;
} | 1 |
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <queue>
#include <utility>
#include <map>
#include <bitset>
#include <numeric>
#define ll long long
using namespace std;
using p = pair<ll, ll>;
ll dx[8]={ 0, 1, 0,-1, 1, 1,-1,-1}; // x軸方向への変位
ll dy[8]={ 1, 0,-1, 0, 1,-1, 1,-1}; // y軸方向への変位
int main(void) {
string s;
cin >> s;
bool ok = true;
for(ll i = 0; i < s.length(); i+=2){
if(s[i]!='h'||s[i+1]!='i'){
ok = false;
break;
}
}
if(ok==true)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int x,y;
cin >> x;
y = x % 500;
x /= 500;
y /= 5;
cout << 1000*x+5*y << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
// #undef DEBUG // Uncomment this line to forcefully disable debug print.
#if DEBUG
template <typename T>
void debug(T value) {
std::cerr << value;
}
template <typename T, typename... Ts>
void debug(T value, Ts... args) {
std::cerr << value << ", ";
debug(args...);
}
#define dbg(...) \
do { \
cerr << #__VA_ARGS__ << ": "; \
debug(__VA_ARGS__); \
cerr << " (L" << __LINE__ << ")" << endl; \
} while (0)
#else
#define dbg(...)
#endif
void read_from_cin() {}
template <typename T, typename... Ts>
void read_from_cin(T& value, Ts&... args) {
std::cin >> value;
read_from_cin(args...);
}
#define in(type, ...) \
type __VA_ARGS__; \
read_from_cin(__VA_ARGS__);
template <typename T>
void write_to_cout(const T& value) {
std::cout << value << std::endl;
}
template <typename T, typename... Ts>
void write_to_cout(const T& value, const Ts&... args) {
std::cout << value << ' ';
write_to_cout(args...);
}
#define out(...) write_to_cout(__VA_ARGS__);
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
using ll = long long;
using namespace std;
template <typename T>
std::map<T, int> Factorize(T x) {
std::map<T, int> m;
for (T i = 2; i * i <= x;) {
if (x % i == 0) {
m[i]++;
x /= i;
} else {
++i;
}
}
if (x > 1) m[x]++;
return m;
}
int main() {
in(int, n, m);
map<int, int> fs = Factorize(m);
int ans = 1;
function<void(map<int, int>::iterator, int)> dfs =
[&](map<int, int>::iterator it, int x) {
if (it == fs.end()) {
if (m / x >= n) ans = max(ans, x);
return;
}
rep(i, it->second + 1) {
dfs(next(it), x);
x *= it->first;
}
};
dfs(fs.begin(), 1);
out(ans);
}
| #include <bits/stdc++.h>
using namespace std;
template<class T> inline bool chmin(T &a, const T &b) { if (b < a) { a = b; return 1; } return 0; }
const int INF = 1e9;
int main() {
string S; cin >> S;
int N = S.size();
vector<vector<int>> dp(N + 1, vector<int>(2, INF));
dp[0][0] = 0;
for(int i = 0; i < N; ++i) {
int d = S[i] - '0';
chmin(dp[i + 1][0], min(dp[i][0], dp[i][1]) + d);
chmin(dp[i + 1][1], min(dp[i][0] + 1, dp[i][1] - 1) + 10 - d);
}
cout << min(dp[N][0], dp[N][1]) << '\n';
return 0;
}
| 0 |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
using namespace std;
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define INT(a) int((a)+1e-9)
int DX[4]={1,0,-1,0};
int DY[4]={0,1,0,-1};
#define EMP 0
#define OBS 1
#define WAL 4
#define STT 2
#define GOA 3
#define SUPmaxY 22
#define SUPmaxX 22
int maxY,maxX;
int field[SUPmaxX][SUPmaxY];
int startX,startY;
int result;
int dfs(int x, int y, int depth){
//DEBUG(x);DEBUG(y);DEBUG(depth);
if(depth>=result) return 0;
if(field[x][y]==GOA) {result=depth; return 0;}
FOR(di,0,4){
int nx=x; int ny=y;
int dx=DX[di]; int dy=DY[di];
if(field[x+dx][y+dy]==OBS) continue;
while(field[nx][ny]==EMP){
nx+=dx;ny+=dy;
}
if(field[nx][ny]==WAL){continue;}
if(field[nx][ny]==GOA){result=depth+1; return 0;}
if(field[nx][ny]==OBS){
field[nx][ny]=EMP;
dfs(nx-dx,ny-dy,depth+1);
field[nx][ny]=OBS;
}
}
}
int main(){
while(true){
cin>>maxY>>maxX; if(!maxY) return 0;
maxX+=2;maxY+=2;
FOR(x,0,maxX) FOR(y,0,maxY) field[x][y]=WAL;
FOR(x,1,maxX-1) FOR(y,1,maxY-1) cin>>field[x][y];
FOR(x,1,maxX-1) FOR(y,1,maxY-1) if(field[x][y]==STT){startX=x;startY=y;field[x][y]=EMP;}
result=11;
dfs(startX,startY,0);
cout<< ((result==11)?-1:result) <<endl;
}
} | #include <iostream>
#include <vector>
using namespace std;
typedef vector <int> VI;
typedef vector <VI> VVI;
const int dx[5] = { 0, 0, 0, 1, -1 };
const int dy[5] = { 0, 1, -1, 0, 0 };
int w, h;
int sx, sy, gx, gy;
VVI M;
int answer;
//==================================================
// Tõ
//==================================================
void dfs( int x, int y, int a, int d )
{
if ( d > 10 ) return;
if ( M[y][x] == 3 )
{
if ( answer == -1 )
answer = d;
else
answer = min( answer, d );
}
if ( a > 0 )
{
int nx = x + dx[a];
int ny = y + dy[a];
if ( nx < 0 || nx >= w || ny < 0 || ny >= h )
return;
if ( M[ny][nx] == 1 )
{
M[ny][nx] = 0;
dfs( x, y, 0, d );
M[ny][nx] = 1;
}
else
dfs( nx, ny, a, d );
}
else
{
for ( int i = 1; i < 5; i++ )
{
int nx = x + dx[i];
int ny = y + dy[i];
if ( nx < 0 || nx >= w || ny < 0 || ny >= h )
continue;
if ( M[ny][nx] == 0 || M[ny][nx] == 3 )
{
dfs( nx, ny, i, d+1 );
}
}
}
}
int main( void )
{
while ( cin >> w >> h && w && h )
{
//==================================================
// Ï
//==================================================
M = VVI( h, VI( w, 0 ) );
answer = -1;
//==================================================
// }bvÌüÍ
//==================================================
for ( int i = 0; i < h; i++ )
{
for ( int j = 0; j < w; j++ )
{
int& s = M[i][j];
cin >> s;
// X^[gES[
if ( s == 2 )
{
sx = j;
sy = i;
s = 0;
}
else if ( s == 3 )
{
gx = j;
gy = i;
}
}
}
//==================================================
//
//==================================================
dfs( sx, sy, 0, 0 );
//==================================================
// oÍ
//==================================================
cout << answer << 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;
ll const INF = 1LL << 60;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
ll N, K;
cin >> N >> K;
vector<ll> A(N);
bool contains_odd = false;
bool contains_even = false;
for (int i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.rbegin(), A.rend());
ll g = gcd(A[0], A[1]);
for (int i = 2; i < N; i++) {
g = gcd(g, A[i]);
}
if (K % g == 0 && K <= A[0]) {
cout << "POSSIBLE" << endl;
} else {
cout << "IMPOSSIBLE" << endl;
}
return 0;
} | #include "bits/stdc++.h"
#define REP(i,num) for(int i=0;i<(num);++i)
#define LOOP(i) while(i--)
#define ALL(c) c.begin(),c.end()
#define PRINTALL(c) for(auto& x:c){cout<<x<<' ';}cout<<endl;
#define PAIRCOMP(c,comp) [](const pair<ll,ll>& lhs,const pair<ll,ll>& rhs){return lhs.c comp rhs.c;}
using namespace std;
using ll = long long;
constexpr ll atcoder_mod = 1e9+7;
template<typename T=int>
T in(){T x; cin >> x; return (x);}
template<typename T=int,typename C=vector<T>>
C vecin(int N){C x(N);REP(i,N){x[i]=in<T>();}return move(x);}
void vout(){cout << endl;}
template<typename Head,typename... Tail>
void vout(Head&& h,Tail&&... t){cout << ' ' << h;vout(forward<Tail>(t)...);}
void out(){cout << endl;}
template<typename Head,typename... Tail>
void out(Head&& h,Tail&&... t){cout << h;vout(forward<Tail>(t)...);}
class Data{
public:
ll first,second,third;
Data()=default;
Data(ll f,ll s,ll t):first(f),second(s),third(t){}
};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(10);
ll N=in(),K=in();
out(N-K+1);
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define FOR(i,l,r) for(long long i=(l);i<(r);++i)
#define REP(i,n) FOR(i,0,n)
#define REPS(i,n) FOR(i,1,n+1)
#define RFOR(i,l,r) for(long long i=(l);i>=(r);--i)
#define RREP(i,n) RFOR(i,n-1,0)
#define RREPS(i,n) RFOR(i,n,1)
#define int long long
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
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 int INF = 1e18;
signed main(){
double n, m, d; cin >> n >> m >> d;
double ans = max(n-d,0.0)*(d !=0 ? 2 : 1) / (n*n) * (m-1);
cout << fixed << setprecision(20.20) << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(k,i,n) for(ll i=k;i<n;++i)
int main(void){
ll n,m,d;
cin>>n>>m>>d;
cout<<fixed<<setprecision(10)<<((d==0)?1.:2.)*(n-d)/n*(m-1)/n;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define ll int64_t
#define _GLIBCXX_DEBUG
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
//約数列挙(√N)
vector< int64_t > divisor(int64_t n) {
vector< int64_t > ret;
for(int64_t i = 1; i * i <= n; i++) {
if(n % i == 0) {
ret.push_back(i);
if(i * i != n) ret.push_back(n / i);
}
}
sort(begin(ret), end(ret));
return (ret);
}
//素因数分解(√N)
map< int64_t, int > prime_factor(int64_t n) {
map< int64_t, int > ret;
for(int64_t i = 2; i * i <= n; i++) {
while(n % i == 0) {
ret[i]++;
n /= i;
}
}
if(n != 1) ret[n] = 1;
return ret;
}
//素数テーブル(NloglogN)
vector< bool > prime_table(int n) {
vector< bool > prime(n + 1, true);
if(n >= 0) prime[0] = false;
if(n >= 1) prime[1] = false;
for(int i = 2; i * i <= n; i++) {
if(!prime[i]) continue;
for(int j = i + i; j <= n; j += i) {
prime[j] = false;
}
}
return prime;
}
//二項係数(K)
template< typename T >
T binomial(int64_t N, int64_t K) {
if(K < 0 || N < K) return 0;
T ret = 1;
for(T i = 1; i <= K; ++i) {
ret *= N--;
ret /= i;
}
return ret;
}
//二項係数テーブル(N^2)
template< typename T >
vector< vector< T > > binomial_table(int N) {
vector< vector< T > > mat(N + 1, vector< T >(N + 1));
for(int i = 0; i <= N; i++) {
for(int j = 0; j <= i; j++) {
if(j == 0 || j == i) mat[i][j] = 1;
else mat[i][j] = mat[i - 1][j - 1] + mat[i - 1][j];
}
}
return mat;
}
//unionfind
struct UnionFind {
vector< int > data;
UnionFind(int sz) {
data.assign(sz, -1);
}
bool unite(int x, int y) {
x = find(x), y = find(y);
if(x == y) return (false);
if(data[x] > data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
return (true);
}
int find(int k) {
if(data[k] < 0) return (k);
return (data[k] = find(data[k]));
}
int size(int k) {
return (-data[find(k)]);
}
};
int main(){
string s;
int w;
cin >> s >> w;
string ans;
rep(i,(s.size()-1)/w+1)
ans+=s.at(w*i);
cout << ans << endl;
} | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
const int INFint = 1e9+1;
const ll INFll = (ll)1e18+1;
ll MOD=1e9+7;
int main(){
string s;
int w;
cin>>s>>w;
for(int i(0);i<int(s.size());i++){
if(i%w==0) cout << s[i];
}
cout << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
template<typename T>inline T read(){
T f=0,x=0;char c=getchar();
while(!isdigit(c)) f=c=='-',c=getchar();
while(isdigit(c)) x=x*10+c-48,c=getchar();
return f?-x:x;
}
#define int long long
namespace run{
const int N=2e5+9;
int a[N],m,v,p,n,ans,sum[N];
int main(){
n=read<int>(),m=read<int>(),v=read<int>(),ans=p=read<int>();
for(int i=1;i<=n;i++) a[i]=read<int>();
sort(a+1,a+n+1);
for(int i=1;i<=n;i++) sum[i]=sum[i-1]+a[i];
// for(int i=1;i<=n;i++) cout<<a[i]<<" ";cout<<endl;
for(int i=1;i<=n-p;i++){
if(m+a[i]<a[n-p+1]) continue;
else{
int tmp=(p-1+i)*m+((n-p+1-i)*(a[i]+m)-(sum[n-p+1]-sum[i]));
// cout<<tmp<<endl;
if(tmp>=m*v) ans++;
}
}
printf("%lld\n",ans);
return 0;
}
}
#undef int
int main(){
#ifdef my
freopen(".in","r",stdin);
freopen(".out","w",stdout);
#endif
return run::main();
} | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
long long N, M, V, P; cin >> N >> M >> V >> P;
vector<long long> A(N);
for(auto& t : A) cin >> t;
sort(A.begin(), A.end());
int L = -1, R = N-1;
while(R-L > 1){
int mid = (L+R)/2;
long long thr = A[mid] + M;
int gr = 0;
long long add = M;
for(int j=N-1;j>=0;j--){
if(j == mid) continue;
if(A[j] > thr){
gr++;
add += M;
} else {
if(gr+1 < P && A[j]+M > thr){
gr++;
add += M;
} else {
add += min(M, thr-A[j]);
}
}
}
if(gr < P && add >= M*V) R = mid;
else L = mid;
}
cout << N-R << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ALL(x) (x).begin(),(x).end()
#define COUT(x) cout<<(x)<<"\n"
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define REP(i, n) for(int i=0;i<n;i++)
#define YES(x) cout<<(x?"YES":"NO")<<"\n"
#define Yes(x) cout<<(x?"Yes":"No")<<"\n"
#define dump(x) cout<<#x<<" = "<<(x)<<"\n"
#define endl "\n"
using G = vector<vector<int>>;
using M = map<int,int>;
using P = pair<int,int>;
using PQ = priority_queue<int>;
using PQG = priority_queue<int,vector<int>,greater<int>>;
using V = vector<int>;
using ll = long long;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
int main() {
IOS;
int n=5;
int d[n],k;
REP(i,5) cin >> d[i];
cin >> k;
REP(i,n) {
REP(j,n) {
if (i == j) continue;
if (abs(d[i]-d[j]) > k) { COUT(":("); return 0; }
}
}
COUT("Yay!");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C, D, E, X;
cin >> A >> B >> C >> D >> E >> X;
int ma, mi;
ma = max(max(max(max(A, B), C), D), E);
mi = min(min(min(min(A, B), C), D), E);
if(ma - mi > X) {
cout << ":(" << endl;
}
else {
cout << "Yay!" << endl;
}
} | 1 |
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
using namespace __gnu_pbds;
using namespace __gnu_cxx;
using namespace std;
typedef tree<int,null_type,less<int>,rb_tree_tag,
tree_order_statistics_node_update> indexed_set;
// order_of_key (val): returns the no. of values less than val
// find_by_order (k): returns the iterator to kth largest element.(0-based)
typedef long long int lli;
#define pb emplace_back
#define mp make_pair
#define ff first
#define ss second
#define pii pair<int,int>
#define vi vector<int>
#define vpii vector<pair<int,int>>
#define vc vector<char>
#define vs vector<string>
#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 fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
/*-------CONSTANTS------- */
const int MAXN = 1000005;
const int SQRTN = 1003;
const int LOGN = 22;
const double PI=acos(-1);
const int INF = 1000000000;
const int MOD = 1000000007;
const int FMOD = 998244353;
const double eps = 1e-9;
/*-----------------------------MATH STUFF----------------------------- */
template<typename T> T gcd(T a, T b){return(b?__gcd(a,b):a);}
template<typename T> T lcm(T a, T b){return(a*(b/gcd(a,b)));}
int mod_neg(int a, int b, int c){int res;if(abs(a-b)<c)res=a-b;else res=(a-b)%c;return(res<0?res+c:res);}
int mulmod(int a, int b, int c){lli res=(lli)a*b;return(res>=c?res%c:res);}
template<typename T>T power_mod(T e, T n, T m){T x=1,p=e;while(n){if(n&1)x=mulmod(x,p,m);p=mulmod(p,p,m);n>>=1;}return x;}
template<typename T>T extended_euclid(T a, T b, T &x, T &y){T xx=0,yy=1;y=0;x=1;while(b){T q=a/b,t=b;b=a%b;a=t;\
t=xx;xx=x-q*xx;x=t;t=yy;yy=y-q*yy;y=t;}return a;}
template<typename T>T mod_inverse(T a, T n){T x,y,z=0;T d=extended_euclid(a,n,x,y);return(d>1?-1:mod_neg(x,z,n));}
//Factorials upto 1e5%MOD,nCr%MOD,nPr%MOD
lli fact[100000+5],fact_modinv[100000+5];
void fact_init(){
fact[0] = 1ll;
fact_modinv[0] = mod_inverse(fact[0],1ll*MOD);
for(int i = 1;i<=100000;i++){
fact[i] = mulmod(fact[i-1],i,1ll*MOD);
fact_modinv[i] = mod_inverse(fact[i],1ll*MOD);
}
}
lli choose(int n,int r){
return mulmod(fact_modinv[n-r],mulmod(fact[n],fact_modinv[r],MOD),MOD);
}
lli P(int n,int r){
return mulmod(fact[n],fact_modinv[n-r],1ll*MOD);
}
/*-----------------------------START----------------------------- */
int n,m;
vector<int> g[10000+5],gr[10000+5];
vector<int> topo;
bool visited1[10000+5],visited2[10000+5];
vector<int> scc[10000+5];
int par[10000+5];
void dfs(int u){
visited1[u] = true;
for(auto x : g[u])
if(!visited1[x])
dfs(x);
topo.push_back(u);
}
void dfs2(int u,int p){
visited2[u] = true;
par[u] = p;
for(auto x : gr[u])
if(!visited2[x])
dfs2(x,p);
}
int main(){
fastio;
cin>>n>>m;
for(int i = 0;i<m;i++){
int u,v;
cin>>u>>v;
g[u].pb(v);
gr[v].pb(u);
}
for(int i = 0;i<n;i++)
if(!visited1[i])
dfs(i);
reverse(topo.begin(),topo.end());
for(auto x : topo)
if(!visited2[x])
dfs2(x,x);
int q;cin>>q;
while(q--){
int u,v;
cin>>u>>v;
cout<<(par[u] == par[v])<<endl;
}
return 0;
}
| #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
// 強連結成分分解
// 計算量: O(V + E)
// operator[]: 頂点kが属する強連結成分の番号を返す
class StronglyConnectedComponents {
int V;
vector<vector<int>> G, rG;
vector <int> comp; // 強連結成分の番号（トポロジカル順）
vector <int> order; // DFSで辿った順
vector <int> used;
void dfs(int cur) {
if (used[cur]) return;
used[cur] = true;
for (int to : G[cur]) dfs(to);
order.push_back(cur);
}
void rdfs(int cur, int cnt) {
if (comp[cur] != -1) return;
comp[cur] = cnt;
for (int to : rG[cur]) rdfs(to, cnt);
}
public:
StronglyConnectedComponents(vector<vector<int>> &edge) {
V = edge.size();
G.resize(V);
rG.resize(V);
comp.assign(V, -1);
used.assign(V, false);
for (int i = 0; i < V; i++) {
for (int e : edge[i]) {
G[i].push_back(e);
rG[e].push_back(i);
}
}
}
int operator[](int k) { return comp[k]; }
void build(vector<vector<int>> &buff) {
for (int i = 0; i < V; i++) dfs(i);
reverse(order.begin(), order.end());
int cnt = 0;
for (int i : order) if (comp[i] == -1) rdfs(i, cnt++);
buff.resize(cnt);
for (int i = 0; i < V; i++) {
for (int to : G[i]) {
int x = comp[i], y = comp[to];
if (x == y) continue;
buff[x].push_back(y);
}
}
}
};
// verified
// https://onlinejudge.u-aizu.ac.jp/courses/library/5/GRL/3/GRL_3_C
void AOJ_GRL_3_C() {
int V, E;
cin >> V >> E;
vector<vector<int>> edge(V), buff;
for (int i = 0; i < E; i++) {
int s, t;
cin >> s >> t;
edge[s].push_back(t);
}
StronglyConnectedComponents scc(edge);
scc.build(buff);
int Q;
cin >> Q;
while (Q--) {
int u, v;
cin >> u >> v;
cout << (scc[u] == scc[v] ? 1 : 0) << "\n";
}
}
int main() {
AOJ_GRL_3_C();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
int n,r;
cin>>n>>r;
if(n>=10){
cout<<r<<endl;
}else{
cout<<r+1000-100*n<<endl;
}
return 0;
}
| #include<stdio.h>
#include<bits/stdc++.h>
#define mod 1000000007
#define maxn 4000095
using namespace std;
int f[2005][2005],fac[maxn],inv[maxn];
int add(int a,int b){a+=b; return a>=mod?a-mod:a;}
int ksm(int a,int b)
{
int s=1;
for(;b;b>>=1,a=1ll*a*a%mod)
if(b&1) s=1ll*s*a%mod;
return s;
}
int n,k;
void Pre()
{
fac[0]=1;
for(int i=1;i<maxn;i++) fac[i]=1ll*fac[i-1]*i%mod;
inv[maxn-1]=ksm(fac[maxn-1],mod-2);
for(int i=maxn-2;i>=0;i--) inv[i]=1ll*inv[i+1]*(i+1)%mod;
}
int C(int n,int m){return 1ll*fac[n]*inv[m]%mod*inv[n-m]%mod;}
int main()
{
Pre();
scanf("%d%d",&n,&k);
if(k==1) return puts("1"),0;
f[0][0]=1;
for(int i=1;i<=n;i++)
{
for(int j=0;j<=i;j++)
{
f[i][j]=f[i-1][j];
if(j) f[i][j]=add(f[i][j],1ll*C(n*k-i-(j-1)*(k-1)-1,k-2)*(n-j+1)%mod*f[i][j-1]%mod);
}
}
printf("%d\n",f[n][n]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long int
#define mp make_pair
#define pb push_back
#define endl "\n"
#define rep(i,a,n) for(int i=a;i<n;i++)
const int mod = 1e9 + 7;
void solve() {
int n;
cin >> n;
int a[n];
rep(i, 0, n) {
cin >> a[i];
}
int s = 0;
rep(i, 1, n) {
if (a[i] < a[i - 1]) {
s += a[i - 1] - a[i];
a[i] = a[i - 1];
}
}
cout << s << endl;
}
int32_t main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output1.txt", "w", stdout);
#endif
int t;
t = 1;
//cin >> t;
while (t--) {
solve();
}
return 0;
}
| #include <iostream>
typedef long long ll;
using namespace std;
int main() {
ll N;
cin >> N;
ll A;
cin >> A;
ll height = A;
ll ans = 0;
for (int i = 0; i < N - 1; ++i) {
cin >> A;
if (height > A) {
ans += height - A;
}
else {
height = A;
}
}
cout << ans << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n, m; scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i)
if (2 * i < m + 2) printf("%d %d\n", i, m + 2 - i);
for (int i = 1; i <= m; ++i)
if (2 * i < m + 1) printf("%d %d\n", m + 1 + i, 2 * m + 2 - i);
return 0;
}
| #include <bits/stdc++.h>
#define int long long
typedef long long ll;
using namespace std;
const ll MAXN = 200000;
const ll INF = 1001001001;
const ll MOD = 1000000007;
ll N, M, tmp=0;
vector<pair<ll,ll>> ans;
signed main(){
cin >> N >> M;
for(int i=1;i<=M;i++) {
tmp = 0;
if(N%2==0&&4*i>=N) tmp++;
cout << (N-i-tmp)%N << " " << (N+i)%N << endl;
}
return 0;
} | 1 |
#include <iostream>
using namespace std;
int main(void){
int n,i,k;
cin >> n;
int day[n];
for(i=0;i<n;i++){
cin >> day[i+1];
}cout << day [n];
for(k=1;k<n;k++){
cout << " ";
cout << day[n-k];
}
cout << endl;
}
| #include <iostream>
#include <string>
#include <sstream>
#include <stack>
using namespace std;
int main()
{
string s;
getline(cin, s);
getline(cin, s);
stringstream ss(s);
stack<string> st;
while (ss.peek() != EOF) {
uint t;
ss >> t;
st.push(to_string(t));
if (ss.peek() == EOF) break;
st.push(" ");
}
while (!st.empty()) {
cout << st.top();
st.pop();
}
cout << endl;
}
| 1 |
#define _USE_MATH_DEFINES
#include <math.h>
#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <algorithm>
#include <numeric>
#include <stdio.h>
#include <vector>
#include <map>
#include <queue>
using namespace std;
typedef long long ll;
#define rep(i, n) for(ll i = 0; i < (ll)(n); i++)
int main() {
ll N,K;
cin >> N >> K;
ll out = 1;
if(N%K==0) out = 0;
cout << out << endl;
return 0;
}
| #include <iostream>
#include <algorithm>
#include <vector>
#include <array>
#include <cmath>
#include <cstdint>
using namespace std;
inline namespace atcoder {
using i32 = int32_t; using u32 = uint32_t;
using i64 = int64_t; using u64 = uint64_t;
using f32 = float; using f64 = double;
template <typename T, size_t Depth>
struct vector_helper { using type = vector<typename vector_helper<T, Depth - 1>::type>; };
template <typename T>
struct vector_helper<T, 0> { using type = T; };
template <typename T, size_t Depth>
using vector_t = typename vector_helper<T, Depth>::type;
template <typename T> using vec = vector_t<T, 1>;
template <typename T> using vvec = vector_t<T, 2>;
template <typename T> using vvvec = vector_t<T, 3>;
}
int main() {
int n, r; cin >> n >> r;
cout << (n < 10 ? r + 100 * (10 - n) : r) << endl;
}
| 0 |
//Date and time of submission:
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const ll N=1e5+5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll a,b;
cin>>a>>b;
cout<<(a%b!=0);
return 0;
}
| #include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char* argv[]){
int N, M;
scanf("%d %d", &N, &M);
int A = M + 2;
int B = M + 1;
int C = 2*M + 2;
for(int i=1, j=0; j < M; i++){
printf("%d %d\n", i, A - i);
if(++j < M){
printf("%d %d\n", B + i, C - i);
j++;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n, q; string s;
cin >> n >> s >> q;
for(int i=0; i<q; i++){
int k;
cin >> k;
long long int d = 0, m = 0, dm = 0, ans = 0;
for(int i=0; i<n; i++){
if(s[i] == 'D') d += 1;
if(s[i] == 'M'){ m += 1; dm += d; }
if(i >= k){
if(s[i-k] == 'D'){ d -= 1; dm -= m; }
if(s[i-k] == 'M') m -= 1;
}
if(s[i] == 'C') ans += dm;
}
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a) for(int i=0; i<(a); i++)
typedef long long ll;
#ifdef _DEBUG
inline void dump() { cerr << endl; }
template<typename Head> void dump(Head&& head) { cerr << head; dump(); }
template<typename Head, typename... Tail> void dump(Head&& head, Tail&&... tail) { cerr << head << ", "; dump(forward<Tail>(tail)...); }
#define debug(...) do {cerr << __LINE__ << ":\t" << #__VA_ARGS__ << " = "; dump(__VA_ARGS__); } while (false)
#else
#define dump(...)
#define debug(...)
#endif
template<typename T>
struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template<typename T>
using Edges = vector<edge<T>>;
template<typename T>
using WeightedGraph = vector<Edges<T>>;
using UnWeightedGraph = vector<vector<int>>;
template<typename T>
using Matrix = vector<vector<T>>;
/////////////////////////////////////////////////////////////////////
const ll inf = 1LL<<60;
int main()
{
ll n,k; cin>>n>>k;
vector<ll> a(k);
rep(i, k) cin>>a[i];
n--;
while (true) {
n++;
string s = to_string(n);
bool flg = true;
for (auto c:s) {
rep(i, k) if (c-'0' == a[i]) flg = false;
}
if (flg) {
cout << n << endl;
return 0;
}
}
return 0;
}
| 0 |
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <numeric>
using namespace std;
int main() {
vector<int> result;
string n;
string input;
getline(cin, n);
getline(cin, input);
istringstream iss(input);
string num;
while (getline(iss, num, ' ')) {
result.push_back(stoi(num));
}
long long min = *min_element(result.begin(), result.end());
long long max = *max_element(result.begin(), result.end());
long long sum = accumulate(result.begin(), result.end(), 0LL);
cout << min << " " << max << " " << sum << endl;
}
| #include <iostream>
using namespace std;
int main(void){
int max=-2147483648;
int min=2147483647;
long sum=0;
int n,in;
cin >> n;
for (int i=0;i<n;i++){
cin >> in;
if(min>in) min=in;
if(max<in) max=in;
sum = sum + in;
}
cout << min <<" "<< max <<" "<< sum << endl;
return 0;
}
| 1 |
/**
* author: souzai32
* created: 13.08.2020 01:38:59
**/
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n;
cin >> n;
vector<int> d(n);
rep(i,n) cin >> d.at(i);
long long ans=1;
if(d.at(0)!=0) ans=0;
sort(d.begin(),d.end());
if(n>2){
if(d.at(1)==0) ans=0;
}
long x=1,y=1;
for(int i=1; i<n; i++){
if(d.at(i-1)==d.at(i)) y++;
else if(d.at(i-1)+1==d.at(i)){
x=y;
y=1;
}
else ans=0;
ans*=x;
ans%=998244353;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define print cout <<
#define printl(s) cout << s << endl;
#define rep(i,n) for (int i = 0; i < (n); ++i)
using ll = long long;
const ll modval = pow(10,9) + 7;
template <typename T>
vector<T> getValues(int num){
vector<T> values(num);
for(int i=0;i<num;i++){
cin >> values.at(i);
}
return values;
}
int main(){
int N;
cin >> N;
auto inputs = getValues<ll>(N);
ll sumOfStep = 0;
ll front = inputs.at(0);
for(int i=1;i<N;i++){
ll target = inputs.at(i);
int step = 0;
if(front>target){
step = front -target;
sumOfStep += step;
}
front = step + inputs.at(i);
}
printl(sumOfStep);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define prec(n) fixed << setprecision(n)
#define maxpq priority_queue<ll>
#define minpq priority_queue<int, vector<int>, greater<int>>
#define PI 3.14159265
#define pb push_back
#define bits(n) __builtin_popcount(n)
void solve()
{
int a,b,c;
cin>>a>>b>>c;
if((a==b&&b!=c)||(a==c&&c!=b)||(b==c&&a!=c))
cout<<"Yes";
else
{
cout<<"No";
}
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input1.txt", "r", stdin);
// for writing output to output.txt
freopen("output1.txt", "w", stdout);
#endif
int t=1;
//cin >> t;
while(t--)
{
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define faster ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
typedef long long ll;
typedef vector<int> vi;;
typedef vector<ll> vll;
#define l() length()
#define sz() size()
#define b() begin()
#define e() end()
#define all(x) x.begin(), x.end()
#define pb(i) push_back(i)
#define PB() pop_back()
typedef pair<int, int> pii;
typedef pair<ll,ll> pll;
#define mp make_pair
#define Fi first
#define Se second
const int maxx=1e6+9;
// Happy Coding!
// 1 way is to find compute all the sorted permutations and find the
// positions of the current permutation.
char _find(string &str){
bool pres[26]={0};
for(char ch:str){
pres[ch-'a']=1;
}
for(int i=0;i<26;i++){
if(pres[i]==0){
return (char)(i+'a');
}
}
return '%';
}
void solve(){
string str;
cin>>str;
char ch=_find(str);
str="";
str.push_back(ch);
cout<<( str=="%" ? "None" : str)<<endl;
}
int main() {
faster;
int t=1;
// cin>>t;
while(t-->0){
solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define rep(i, n) for (int i = 0; i < (n); ++i)
int main() {
int n;
cin >> n;
vector<int> v(n);
rep(i, n) cin >> v[i];
int count = 0;
bool flag = true;
while (flag) {
rep(i, n) {
if (v[i] % 2 == 1) {
flag = false;
break;
}
v[i] /= 2;
}
if (flag) count++;
}
cout << count << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int (i) = 0; (i) < (n); (i)++)
#define repn(i, n) for(int (i) = 1; (i) <= (n); (i)++)
#define repr(i, n) for(int (i) = (n-1); (i) >= 0; (i)--)
#define all(x) (x).begin(), (x).end()
#define lint long long
#define ulint unsigned long long
#define fi first
#define se second
#define setpre(x) cout << fixed << setprecision(x)
#define ii(x) int x; cin >> (x)
#define ii2(x, y) int x, y; cin >> (x) >> (y)
#define ii3(x, y, z) int x, y, z; cin >> (x) >> (y) >> (z)
#define out(x) cout << (x) << endl
#define yn(x) cout << ((x)?("Yes"):("No")) << endl
#define YN(x) cout << ((x)?("YES"):("NO")) << endl
#define bit_c(x) __builtin_popcountll(x)
inline void logger(){ cout << endl; }
template<typename A, typename... B>
void logger(const A& a, const B&... b){
cout << a << " , ";
logger(b...);
}
typedef pair<lint, lint> P;
const lint MOD = 1000000007;
const lint MOD9 = 998244353;
const lint INF = MOD * MOD;
const int MAX = 200005;
/* ...o(^-^)o... */
int main(){
int n; cin >> n;
vector<lint> vec; map<lint, int> mp;
rep(i, n){
lint x; cin >> x;
vec.push_back(x); mp[x]++;
}
sort(all(vec));
lint res = 0;
repr(i, n){
if(mp[vec[i]] == 0) continue;
lint s = 1;
while(s <= vec[i]) s *= 2;
s -= vec[i];
if(s == vec[i] && mp[s] > 1){
mp[s] -= 2; res++;
}
if(s != vec[i] && mp[s] > 0){
mp[vec[i]]--; mp[s]--; res++;
}
}
out(res);
} | 0 |
#include <iostream>
using namespace std;
int main(){
int n, a[150];
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < n - 1; i++)
cout << a[n - i - 1] << " ";
cout << a[0];
cout << endl;
return 0;
}
| //Bismillahir Rahmanir Rahim
#include<bits/stdc++.h>
using namespace std;
#define ios ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL)
#define ll long long
#define endl '\n'
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
bool sortbysec(const pair<ll,ll>&a,const pair<ll,ll>&b)
{
return (a.second<b.second);
}
int main()
{
ios;
int k,x;
cin>>k>>x;
k--;
for(int i=x-k;i<=x+k;i++)
cout<<i<<" ";
cout<<endl;
}
//Alhamdulillah
| 0 |
#include <cstdio>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
int main(){
int N;
int score[101];
vector<int> res;
int A, B, C, D;
int rank[101];
int n, r;
scanf("%d", &N);
for(int i = 1; i <= N; i++){
score[i] = 0;
}
for(int i = 0; i < N * (N - 1) / 2; i++){
scanf("%d%d%d%d", &A, &B, &C, &D);
if(C > D) score[A] += 3;
else if(C < D) score[B] += 3;
else{
score[A]++; score[B]++;
}
}
for(int i = 1; i <= N; i++){
res.push_back(score[i]);
}
sort(res.begin(), res.end(), greater<int>());
res.erase(unique(res.begin(), res.end()), res.end());
n = 0;
for(int i = 0; i < res.size(); i++){
r = n + 1;
for(int j = 1; j <= N; j++){
if(res[i] == score[j]){
rank[j] = r;
n++;
}
}
}
for(int i = 1; i <= N; i++){
printf("%d\n", rank[i]);
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
int N;
vector<pii> P;
bool cmp(pii a, pii b) {
return a.first + a.second < b.first + b.second;
}
ll dp[2][5002];
int main() {
scanf("%d", &N);
P.resize(N);
for(int i = 0; i < N; i++) {
scanf("%d %d", &P[i].first, &P[i].second);
}
sort(P.begin(), P.end(), cmp);
for(int i = 0; i < 5002; i++) dp[1][i] = 1e18;
dp[1][0] = 0;
for(int i = 0; i < N; i++) {
dp[i&1][0] = 0;
for(int j = 1; j <= N; j++) {
dp[i&1][j] = 1e18;
dp[i&1][j] = min(dp[i&1][j], dp[(i&1) ^ 1][j]);
dp[i&1][j] = min(dp[i&1][j], dp[(i&1) ^ 1][j - 1] <= P[i].first? dp[(i&1) ^ 1][j - 1] + P[i].second : (ll)1e18);
}
}
int ans = 0;
for(int i = 0; i <= N; i++) if(dp[(N - 1) & 1][i] != 1e18) ans = i;
printf("%d", ans);
}
| 0 |
// C++ 14
#include <bits/stdc++.h>
using namespace std;
template <typename T> ostream& operator<<(ostream& os, const vector<T>& v) { os << "["; for (int i = 0; i < v.size(); ++i) { os << v[i]; if (i != v.size() - 1) os << ", "; } os << "]"; return os; }
template <typename T> void print(T v, string s = "\n") { cout << v << s; }
template <typename T> void in(T &v) { cin >> v; }
#define ll long long
#define loop(__x, __start, __end) for(int __x = __start; __x < __end; __x++)
int G[500][500];
int ACC[501][501];
int main() {
int n, m, q; in(n),in(m),in(q);
loop(i,0,m) {
int l, r; in(l),in(r);
l--;r--;
G[l][r]++;
}
loop(y,0,n) {
loop(x,0,n) {
ACC[y+1][x+1] = ACC[y+1][x] + ACC[y][x+1] - ACC[y][x] + G[y][x];
}
}
// loop(y,0,n+1) {
// loop(x,0,n+1) {
// print(ACC[y][x], " ");
// }
// print("");
// }
loop(i,0,q) {
int l,r; in(l),in(r);
int cnt = ACC[r][r];
cnt += ACC[l-1][l-1];
cnt -= ACC[l-1][r];
cnt -= ACC[r][l-1];
// print(ACC[r][r]);
// print(ACC[l-1][l-1]);
// print(ACC[l-1][r]);
// print(ACC[r][l-1]);
print(cnt);
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
const int N=502;
int n,m,q;
int f[N][N];
int main()
{
cin>>n>>m>>q;
for(int i=1;i<=m;++i)
{
int u,v;
cin>>u>>v;
for(int j=v;j<=n;++j)
{
f[u][j]++;
}
}
for(int i=1;i<=q;++i)
{
int u,v;
cin>>u>>v;
int res=0;
for(int j=u;j<=v;++j)
{
res+=f[j][v];
}
cout<<res<<endl;
}
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <cstring>
using namespace std;
#define repeat(n, i) for(int i=0; i<(n); i++)
int w, h;
int xs, ys;
int xg, yg;
int n;
int st_color;
int board[300][300];
#define VISITED 6
bool get_input() {
memset(board, 0, sizeof(board));
cin >> w >> h;
if (w == 0 && h == 0) return false;
// board.resize(h);
// repeat(h, i) board[i].resize(w);
cin >> xs >> ys;
cin >> xg >> yg;
cin >> n;
repeat(n, i) {
int c, d, x, y;
cin >> c >> d >> x >> y;
if (d == 1) {
for (int j = y-1; j < y-1+4; j++) {
for (int k = x-1; k < x-1+2; k++) {
board[j][k] = c;
}
}
} else {
for (int j = y-1; j < y-1+2; j++) {
for (int k = x-1; k < x-1+4; k++) {
board[j][k] = c;
}
}
}
}
st_color = board[ys-1][xs-1];
return true;
}
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
bool possible;
void dfs(int x, int y) {
board[y-1][x-1] = VISITED;
if (x == xg && y == yg) {
possible = true;
return;
}
repeat(4, i) {
int nx = x+dx[i], ny = y+dy[i];
if (1 <= nx && nx <= w && 1 <= ny && ny <= h) {
if (board[ny-1][nx-1] == st_color) {
dfs(nx, ny);
}
}
}
}
// debug
//void solve() {
// repeat(h, i) {
// repeat(w, j) {
// cout << board[i][j] << ' ';
// }
// cout << endl;
// }
//}
void solve() {
possible = false; dfs(xs, ys);
if (possible) cout << "OK" << endl;
else cout << "NG" << endl;
}
int main() {
while (get_input()) {
solve();
}
return 0;
} | #include <iostream>
#include <string>
using namespace std;
string ans;
int w,h,gx,gy;
int map[110][110];
int dx_[4] = {0,1,0,-1};
int dy_[4] = {1,0,-1,0};
int dx[2][8] = {
{0,1,2,3,0,1,2,3},
{0,1,0,1,0,1,0,1}
};
int dy[2][8] = {
{0,0,0,0,1,1,1,1},
{0,0,1,1,2,2,3,3},
};
void solve(int x,int y,int color){
if( ans == "OK" || color == 0 /*|| map[y][x] != color*/ ) return;
//if( x<0 || x>w || y<0 || y>h ) return;
for(int i=0 ; i<4 ; ++i ){
int mx = x + dx_[i];
int my = y + dy_[i];
if( mx<0 || mx>w || my<0 || my>h ) continue;
//cout << "x:" << x << " y:" << y << endl;
if( map[my][mx] == color ){
if( mx == gx && my == gy ){
ans = "OK";
}else{
map[my][mx] = 0;
solve( mx , my , color );
}
}
}
}
void debug(){
char c[6] = {' ','#','$','*','+','@'};
cout << "w:" << w << " h:" << h << " map : " << endl;
for(int y=0 ; y<h ; ++y ){
for(int x=0 ; x<w ; ++x ){
cout << c[ map[y][x] ];
}
cout << endl;
}
}
int main(){
int sx,sy,n;
while( cin >> w >> h , w|h ){
ans = "NG";
for(int y=0 ; y<110 ; ++y )
for(int x=0 ; x<110 ; ++x )
map[y][x] = 0;
cin >> sx >> sy >> gx >> gy >> n ;
for(int i=0 ; i<n ; ++i ){
int c,d,x,y;
cin >> c >> d >> x >> y;
for(int j=0 ; j<8 ; j++){
int mx = x + dx[d][j];
int my = y + dy[d][j];
map[my][mx] = c;
}
}
//debug();
//map[sy][sx] = 0;
solve( sx , sy , map[sy][sx] );
//cout << "sx:" << sx << " sy:" << sy << endl;
cout << ans << endl;
}
} | 1 |
#include <cstdio>
#include <utility>
#include <cmath>
#include <algorithm>
using namespace std;
#define gcu getchar_unlocked
int in(int c){int n=0;bool m=false;if(c=='-')m=true,c=gcu();
do{n=10*n+(c-'0'),c=gcu();}while(c>='0');return m?-n:n;}
int in() {return in(gcu());}
bool scan(int &n){int c=gcu();return c==EOF?false:(n=in(c),true);}
bool scan(char &c){c=gcu();gcu();return c!=EOF;}
//bool scan(string &s){int c;s="";
// for(;;){c=gcu();if(c=='\n'||c==' ')return true;else if(c==EOF)return false;s+=c;}}
#define pcu putchar_unlocked
#define vo inline void out
template <typename T>
vo(T n){static char buf[20];char *p=buf;
if(n<0)pcu('-'),n*=-1;if(!n)*p++='0';else while(n)*p++=n%10+'0',n/=10;
while (p!=buf)pcu(*--p);}
vo(const char *s){while(*s)pcu(*s++);}
vo(char c){pcu(c);}
//vo(string &s){for (char c: s) pcu(c);}
template <typename head, typename... tail> vo(head&& h, tail&&... t){out(h);out(move(t)...);}
//template <typename T> vo(vector<T> &v){for(T &x:v)out(&x == &v[0]?"":" "),out(x);out('\n');}
#undef vo
int main() {
for (int e, m; (e = m = in());) {
for (int z = cbrt(e) + 0.00001; z >= 0; z--) {
int te = e - z * z * z;
int y = (int)sqrt(te);
int tm = z + y + te - y * y;
if (y > m)
break;
m = min(m, tm);
}
out(m, '\n');
}
}
| #include <iostream>
using namespace std;
int main(){
while(1){
int E;
cin >> E;
if(E==0) break;
int x=0,y=0,z=0;
int m = 1000000;
for(z=0;z*z*z<=E;z++){
for(y=0;(z*z*z)+(y*y)<=E;y++){
x=E-(z*z*z)-(y*y);
if(x+y+z<m){
m=x+y+z;
//cout << x << y << z << endl;
}
}
}
cout << m << endl;
}
} | 1 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
#define llint long long
using namespace std;
typedef pair<llint, llint> P;
typedef pair<llint, P> E;
struct UnionFind{
int size;
vector<int> parent;
UnionFind(){}
UnionFind(int size){
this->size = size;
parent.resize(size+1);
init();
}
void init(){
for(int i = 0; i <= size; i++) parent[i] = i;
}
int root(int i){
if(parent[i] == i) return i;
return parent[i] = root(parent[i]);
}
bool same(int i, int j){
return root(i) == root(j);
}
void unite(int i, int j){
int root_i = root(i), root_j = root(j);
if(root_i == root_j) return;
parent[root_i] = root_j;
}
};
llint n;
P x[100005], y[100005];
vector<E> vec;
UnionFind uf(100005);
int main(void)
{
cin >> n;
for(int i = 1; i <= n; i++){
cin >> x[i].first >> y[i].first;
x[i].second = y[i].second = i;
}
sort(x+1, x+n+1);
sort(y+1, y+n+1);
for(int i = 1; i < n; i++){
vec.push_back(E(x[i+1].first-x[i].first, P(x[i].second, x[i+1].second)));
vec.push_back(E(y[i+1].first-y[i].first, P(y[i].second, y[i+1].second)));
}
sort(vec.begin(), vec.end());
llint ans = 0;
for(int i = 0; i < vec.size(); i++){
llint w = vec[i].first, u = vec[i].second.first, v = vec[i].second.second;
if(uf.same(u, v)) continue;
ans += w;
uf.unite(u, v);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
#define sz(x) int(x.size())
#define pb push_back
#define eb emplace_back
using ll=long long;
using P = pair<int,int>;
using LP=pair<ll,ll>;
#define chmax(x,y) x = max(x,y)
#define chmin(x,y) x = min(x,y)
const ll MOD=1000000007,MOD2=998244353;
const int INF=1e8;
int minlen(vector<P> A,vector<P> B){
int res=1e8;
for(P p:B){
int a=lower_bound(A.begin(),A.end(),p)-A.begin();
if(a==A.size())continue;
if(A.at(a).first!=p.first)continue;
chmin(res,A.at(a).second-p.second);
}
return res;
}
int main() {
int N;
cin>>N;
vector<int> X(N),Y(N),U(N);
rep(i,N){
char c;
cin>>X.at(i)>>Y.at(i)>>c;
if(c=='U')U.at(i)=0;
if(c=='R')U.at(i)=1;
if(c=='D')U.at(i)=2;
if(c=='L')U.at(i)=3;
}
int ans=INF;
rep(_,4){
vector<P> UDD(0),DRD(0),UP(0),RI(0);
rep(i,N){
if(U.at(i)==2){
UDD.pb({X.at(i),Y.at(i)});
DRD.pb({X.at(i)-Y.at(i),Y.at(i)});
}
if(U.at(i)==0){
UP.pb({X.at(i),Y.at(i)});
}
if(U.at(i)==1){
RI.pb({X.at(i)-Y.at(i),Y.at(i)});
}
}
sort(UDD.begin(),UDD.end());
sort(DRD.begin(),DRD.end());
chmin(ans,minlen(UDD,UP)*5);
chmin(ans,minlen(DRD,RI)*10);
rep(i,N){
int x=X.at(i),y=Y.at(i);
X.at(i)=y;
Y.at(i)=-x;
U.at(i)=(U.at(i)+1)%4;
}
}
if(ans==INF)cout<<"SAFE"<<endl;
else cout<<ans<<endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define M 1000000007
#define ll long long
#define FIO ios_base::sync_with_stdio(false);cin.tie(NULL)
#define ifor(st,lim) for(int i=st;i<lim;i++)
#define jfor(stt,llim) for(int j=stt;j<llim;j++)
#define eifor(st,lim) for(int i=st;i<=lim;i++)
#define ejfor(stt,llim) for(int j=stt;j<=llim;j++)
#define blank cout<<'\n'
void solve()
{
string s; cin>>s;
if(s[0] == s[1] && s[1] == s[2] && s[0] == 'R') cout<<"3";
else if(s[0] == s[1] && s[0] == 'R') cout<<"2";
else if(s[1] == s[2] && s[1] == 'R') cout<<"2";
else if(s[0] == 'R' || s[1] == 'R' || s[2] == 'R') cout<<"1";
else cout<<"0";
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
int t=1;
while(t--){
solve();
}
} | #include <bits/stdc++.h>
#include <vector>
#define rep(i, n) for(int i = 0; i < n; i++)
#define repr(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
//#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int main(){
string W;
cin >> W;
int result=0;
if(W[0]=='R'){
result=1;
if(W[1]=='R'){
result=2;
if(W[2]=='R'){
result=3;
}
}
}
if(W[1]=='R'){
if(result<1) result=1;
if(W[2]=='R'){
if(result<2) result=2;
}
}
if(W[2]=='R'){
if(result<1) result=1;
}
cout << result << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,a,b;
cin>>n;
if(n==1){
cout<<"Hello World"<<'\n';
}
if(n==2){
cin>>a>>b;
cout<<a+b<<'\n';
}
return(0);
}
| #include <bits/stdc++.h>
using namespace std;
// repetition
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
// container util
#define all(x) (x).begin(), (x).end()
// typedef
typedef long long lint;
typedef unsigned long long ull;
typedef complex<long double> Complex;
typedef pair<int, int> P;
typedef tuple<int, int, int> TP;
typedef vector<int> vec;
typedef vector<vec> mat;
// constant
const int MOD = (int)1e9 + 7;
const int INF = (int)1e18;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const int ddx[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[] = {1, 1, 0, -1, -1, -1, 0, 1};
// conversion
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
//
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
//
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
string ans = "", tmp;
rep(i, (int)s.size() - 8) { ans += s[i]; }
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#define trans(x) add(nxt[ d[i][x] ], cur[i])
const int N = 300054, mod = 1000000007;
const int d[8][2] = {{2, 3}, {6, 6}, {4, 5}, {6, 7}, {2, 2}, {2, 3}, {1, 3}, {7, 7}};
int dp_[2][8], *cur = *dp_, *nxt = dp_[1];
char s[N];
inline int & add(int &x, const int y) {return x += y - mod, x += x >> 31 & mod;}
int main() {
int i, ans; char *p = s; *nxt = 1;
for (scanf("%s", s); *p; ++p) {
std::swap(cur, nxt), memset(nxt, 0, sizeof *dp_);
for (i = 0; i < 8; ++i) *p == 48 || trans(1), *p == 49 || trans(0);
}
printf("%d\n", add(ans = nxt[3], nxt[7]));
return 0;
} | #include <bits/stdc++.h>
#define clr(x) memset(x,0,sizeof x)
#define For(i,a,b) for (int i=(a);i<=(b);i++)
#define Fod(i,b,a) for (int i=(b);i>=(a);i--)
#define fi first
#define se second
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define outval(x) cerr<<#x" = "<<x<<endl
#define outtag(x) cerr<<"---------------"#x"---------------"<<endl
#define outarr(a,L,R) cerr<<#a"["<<L<<".."<<R<<"] = ";\
For(_x,L,R)cerr<<a[_x]<<" ";cerr<<endl;
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef vector <int> vi;
typedef long double LD;
LL read(){
LL x=0,f=0;
char ch=getchar();
while (!isdigit(ch))
f|=ch=='-',ch=getchar();
while (isdigit(ch))
x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
return f?-x:x;
}
const int N=300005,mod=1e9+7;
int Pow(int x,int y){
int ans=1;
for (;y;y>>=1,x=(LL)x*x%mod)
if (y&1)
ans=(LL)ans*x%mod;
return ans;
}
void Add(int &x,int y){
if ((x+=y)>=mod)
x-=mod;
}
void Del(int &x,int y){
if ((x-=y)<0)
x+=mod;
}
int Add(int x){
return x>=mod?x-mod:x;
}
int Del(int x){
return x<0?x+mod:x;
}
int n;
char s[N];
int dp[N][2][3][3];
//dp[i][a][b][c]: first i char, there's a 1s, stage b, last c 0s
int main(){
cin>>s+1;
n=strlen(s+1);
s[n+1]='1';
dp[0][0][0][0]=1;
For(i,1,n+1) For(a,0,1) For(b,0,2) For(c,0,2){
int v=dp[i-1][a][b][c],lb,ub;
if (!v)
continue;
if (s[i]=='0')
lb=ub=0;
else if (s[i]=='1')
lb=ub=1;
else
lb=0,ub=1;
For(now,lb,ub){
if (now==0){
int C=c+1;
if (C>2)
C-=2;
Add(dp[i][a][b][C],v);
}
else if (now==1){
if (c==1)
Add(dp[i][a][b][0],v);
else if (a==0&&b<2&&c==0)
Add(dp[i][0][b+1][0],v);
else
Add(dp[i][a^1][b][0],v);
}
}
}
int ans=0;
For(a,0,1) For(b,2,2) For(c,0,2)
Add(ans,dp[n+1][a][b][c]);
cout<<ans<<endl;
return 0;
} | 1 |
/// In The Name Of God
#include <bits/stdc++.h>
#define f first
#define s second
#define pb push_back
#define pp pop_back
#define mp make_pair
#define sz(x) (int)x.size()
#define sqr(x) ((x) * 1ll * (x))
#define all(x) x.begin(), x.end()
#define rep(i, l, r) for (int i = (l); i <= (r); i++)
#define per(i, l, r) for (int i = (l); i >= (r); i--)
#define Kazakhstan ios_base :: sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define nl '\n'
#define ioi exit(0);
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const int N = (int)5e5 + 7;
const int inf = (int)1e9 + 7;
const int mod = (int)1e9 + 7;
const ll linf = (ll)1e18 + 7;
const int dx[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
using namespace std;
int n, m;
unordered_map <int, vector <int > > g[N];
unordered_map <int, int> d[N];
int c[N];
int main() {
#ifdef IOI2018
freopen ("in.txt", "r", stdin);
freopen ("E.out", "w", stdout);
#endif
Kazakhstan
cin >> n >> m;
rep(i, 1, m) {
int a, b, c;
cin >> a >> b >> c;
g[a][c].pb(b);
g[b][c].pb(a);
}
d[1][0] = 0;
set < pair <int, pair <int, int> > > st;
st.insert({0, {1, 0}});
vector <bool> was(n + 1, 0);
while (sz(st)) {
int dist = st.begin() -> f;
int v = st.begin() -> s.f, last = st.begin() -> s.s;
st.erase(st.begin());
if (!was[v]) {
for (auto it : g[v]) {
int C = it.f;
for (auto to : it.s) {
if (!d[to].count(C) || d[to][C] > dist + 1) {
st.erase({d[to][C], {to, C}});
d[to][C] = dist + 1;
st.insert({d[to][C], {to, C}});
}
}
}
was[v] = 1;
}
if (sz(g[v][last])) {
int C = last;
for (auto to : g[v][last]) {
if (!d[to].count(last) || d[to][last] > dist) {
st.erase({d[to][C], {to, C}});
d[to][C] = dist;
st.insert({d[to][C], {to, C}});
}
}
g[v][last].clear();
g[v].erase(last);
}
}
int ans = inf;
for (auto it : d[n]) ans = min(ans, it.s);
cout << (ans == inf ? -1 : ans);
ioi
}
| #include<bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); i++)
#define rrep(i,n) for(int i = (n)-1; i >= 0; i--)
#define rep1(i,n) for(int i = 1; i <= (n); i++)
#define rrep1(i,n) for(int i = (n); i > 0; i--)
#define ll long long
#define pi pair<int, int>
#define pll pair<ll, ll>
#define MOD 1000000007
#define INF 10000000
using namespace std;
int main(){
int n,u,v; cin>>n>>u>>v; u--; v--;
vector<vector<pi>> g( n, vector<pi>() );
rep(i, n-1){
int a,b; cin>>a>>b; a--; b--;
g[a].push_back( {1,b} );
g[b].push_back( {1,a} );
}
if(g[u].size()==1 && g[u][0].second==v) { cout<<0<<endl; return 0; }
set<int>s;
vector<int>d(n);
rep(i, n)d[i]=INF;
d[u]=0;
priority_queue<pi, vector<pi>, greater<pi>> pq;
pq.push( {0, u} );
while( pq.size() ){
auto cn = pq.top(); pq.pop();
if(d[cn.second] < cn.first)continue;
for(auto nn :g[cn.second]){
if(cn.first+1 >= d[nn.second] || nn.second==v)continue;
d[nn.second]=cn.first+1;
pq.push( {d[nn.second], nn.second} );
}
}
rep(i, n)if(d[i]!=INF)s.insert(i);
s.insert(v);
vector<int>d2(d);
rep(i, n)d[i]=INF;
d[v]=0;
pq.push( {0, v} );
while( pq.size() ){
auto cn = pq.top(); pq.pop();
if(d[cn.second] < cn.first)continue;
for(auto nn :g[cn.second]){
if(cn.first+1 >= d[nn.second] || s.count(nn.second)==0 )continue;
d[nn.second]=cn.first+1;
pq.push( {d[nn.second], nn.second} );
}
}
//for(auto t: d2)cout<<t<<' ';cout<<endl;
//for(auto t: d)cout<<t<<' ';cout<<endl;
bool f=true;
rep(i, n)if((d[i]==1 || d2[i]==1) && d[i]!=d2[i])f=false;
if(f) { cout<<1<<endl; return 0; }
int result=0;
rep(i, n)if(d[i]!=INF && d2[i]!=INF){
if(d[i]<=d2[i])continue;
result = max(result, d[i]-1);
}
cout<<result<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int lb = 9, ub = 44;
int v[lb+ub+5][lb+ub+5];
int main () {
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
int n; cin >> n;
int i, j, z, e, pin, p2, p5;
ll m, ans = 0;
string s;
for (i = 1; i <= n; i++) {
cin >> s;
m = e = pin = 0;
for (char ch: s) {
if (pin) e++;
if (ch == '.') pin = 1;
else m = m*10 + ch - '0';
}
p2 = -e;
while (m % 2 == 0) {
p2++;
m /= 2;
}
p5 = -e;
while (m % 5 == 0) {
p5++;
m /= 5;
}
for (int i2 = -lb; i2 <= ub; i2++)
for (int i5 = -lb; i5 <= ub; i5++)
if (i2+p2 >= 0 && i5+p5 >= 0) ans += 1LL*v[lb+i2][lb+i5];
v[lb+p2][lb+p5]++;
}
cout << ans;
return 0;
} | #include<bits/stdc++.h>
#define ll long long int
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
static const ll MAX = 1000000000000000;
static const int NIL = -1;
using namespace std;
const long double EPS = 0.0000000001;
const long double PI = (acos(-1));
const int MOD = 1000000007;
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
int main() {
ll n,a; cin >> n;
map<ll,ll> mp;
set<ll> st;
ll ans = 1;
ll prev,val;
bool f = false;
rep(i,n){
cin >> a;
if(mp.count(a) == 0) mp[a] = 1;
else mp[a] ++;
st.insert(a);
if(a == 0 && i != 0){
cout << 0;
return 0;
}
if(a == 0 && i == 0) f = true;
}
if(!f){
cout << 0;
return 0;
}
for(auto itr = st.begin(); itr != st.end(); ++itr) {
if(*itr == 0) {
prev = mp[*itr];
val = *itr;
}
else{
if(*itr - val != 1){
cout << 0;
return 0;
}
if(prev == 0){
cout << 0;
return 0;
}
rep(i,mp[*itr]){
ans = (prev*ans)%998244353;
}
prev = mp[*itr];
val = *itr;
}
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define ALL(A) A.begin(),A.end()
void ALLIN1_NUMBER(vector<ll>& V)
{
for(auto& x : V)
{
cin >> x;
}
}
template<class T>
void OUT0(T N)
{
cout << N << endl;
}
static const double pi = acos(-1.0);
double Cos(double D)
{
return cos(pi/180 * D);
}
class Dishes
{
public:
ll point_takahashi;
ll point_aoki;
ll sum;
ll number;
};
void ALLIN1_DISHES(ll N, vector<Dishes>& dishes)
{
for(ll i=0;i<N;i++)
{
dishes[i].number = i;
cin >> dishes[i].point_takahashi >> dishes[i].point_aoki;
dishes[i].sum = dishes[i].point_takahashi + dishes[i].point_aoki;
}
}
bool Sort_TA(vector<Dishes>& dishesTA)
{
sort
(ALL(dishesTA),
[](Dishes& a, Dishes& b)
{
return (a.sum == b.sum) ? (a.point_takahashi > b.point_takahashi) : (a.sum > b.sum);
});
}
void Sort_AT(vector<Dishes>& dishes)
{
sort
(ALL(dishes),
[](Dishes& a, Dishes& b)
{
return (a.sum == b.sum) ? (a.point_aoki > b.point_aoki) : (a.sum > b.sum);
});
}
ll Ans(ll N, vector<Dishes> dishes_TA, vector<Dishes> dishes_AT)
{
vector<bool> eaten(N,false);
ll takahashi_point = 0;
ll aoki_point = 0;
ll itr_TA = 0;
ll itr_AT = 0;
for(ll i=0;i<N;i++)
{
if(i%2==0)
{
for(ll& j=itr_TA;j<N;j++)
{
if(!eaten[dishes_TA[j].number])
{
eaten[dishes_TA[j].number] = true;
takahashi_point += dishes_TA[j].point_takahashi;
j++;
break;
}
}
}
else
{
for(ll& j=itr_AT;j<N;j++)
{
if(!eaten[dishes_AT[j].number])
{
eaten[dishes_AT[j].number] = true;
aoki_point += dishes_AT[j].point_aoki;
j++;
break;
}
}
}
}
return takahashi_point - aoki_point;
}
int main()
{
ll N;
cin >> N;
vector<Dishes> dishes(N);
ALLIN1_DISHES(N,dishes);
vector<Dishes> dishes_TA = dishes;
Sort_TA(dishes_TA);
vector<Dishes> dishes_AT = dishes;
Sort_AT(dishes_AT);
OUT0(Ans(N,dishes_TA,dishes_AT));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, e) for (int i = (int)(s); i <= (int)(e); i++)
#define printYesNo(is_ok) puts(is_ok ? "Yes" : "No");
#define SORT(v) sort(v.begin(), v.end());
#define RSORT(v) sort(v.rbegin(), v.rend());
#define REVERSE(v) reverse(v.begin(), v.end());
template <typename T>
void printlnVector(T v)
{
rep(i, v.size())
{
cout << v[i] << endl;
}
}
template <typename T>
void printVector(T v)
{
rep(i, v.size())
{
cout << v[i] << " ";
}
cout << endl;
}
int main()
{
int N;
cin >> N;
priority_queue<long long> point_add;
long long sumA = 0;
rep(i, N)
{
long long A, B;
cin >> A >> B;
point_add.push(A + B);
sumA += A;
}
long long ans = sumA;
bool turn_is_takahashi = true;
while (point_add.size())
{
if (!turn_is_takahashi)
ans -= point_add.top();
turn_is_takahashi = !turn_is_takahashi;
point_add.pop();
}
cout << ans << endl;
return 0;
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.