code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 45
101M
|
|---|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int h1,m1,h2,m2,k ;
int time = 0;
cin >> h1>>m1>>h2>>m2>>k;
if(m1<=m2){
time=(h2-h1)*60+(m2-m1)-k;
}else{
time=(h2-h1-1)*60+(m2+60-m1)-k;
}
if(time>=0){
cout << time << endl;
}else{
cout << "0" << endl;
}
}
|
#include <iostream>
#include <vector>
#include <string>
#include <math.h>
#include <algorithm>
#include <set>
#include <iomanip>
#include <stdio.h>
#include <sstream>
#include <bits/stdc++.h>
using namespace std;
vector<vector<char>> grid;
vector<vector<long long int>> dp;
long long int h,w;
int main(void){
cin>>h>>w;
grid=vector<vector<char>>(h,vector<char>(w));
for(long long int i=0; i<h; i++){
for(long long int j=0; j<w; j++){
cin>>grid.at(i).at(j);
}
}
dp=vector<vector<long long int>>(h,vector<long long int>(w,10000000));
dp.at(0).at(0)=0;
long long int pre=0;
if(grid.at(0).at(0)=='#'){
dp.at(0).at(0)=1;
}
for(long long int i=0; i<h; i++){
for(long long int j=0; j<w; j++){
if(i==0&&j==0){
continue;
}
if(i==0){
long long int pre=dp.at(i).at(j-1);
if(grid.at(i).at(j-1)=='.'&&grid.at(i).at(j)=='#'){
pre++;
}
dp.at(i).at(j)=pre;
}else if(j==0){
long long int pre=dp.at(i-1).at(j);
if(grid.at(i-1).at(j)=='.'&&grid.at(i).at(j)=='#'){
pre++;
}
dp.at(i).at(j)=pre;
}else{
long long int pre1=dp.at(i).at(j-1);
if(grid.at(i).at(j-1)=='.'&&grid.at(i).at(j)=='#'){
pre1++;
}
long long int pre2=dp.at(i-1).at(j);
if(grid.at(i-1).at(j)=='.'&&grid.at(i).at(j)=='#'){
pre2++;
}
dp.at(i).at(j)=min(pre1,pre2);
}
}
}
cout<<dp.at(h-1).at(w-1)<<endl;
}
| 0
| 19,400,097
|
#include<iostream>
using namespace std;
int main(){
int yama[10], i, p, Flag = 0, t;
for(i = 0; i < 10; i++)
cin >> yama[i];
while(1){
Flag = 0;
for(i = 0; i < 10; i++){
if(i + 1 != 10){
if(yama[i] < yama[i + 1]){
t = yama[i];
yama[i] = yama[i + 1];
yama[i + 1] = t;
Flag++;
}
}
}
if(Flag == 0)
break;
}
cout << yama[0] << "\n";
cout << yama[1] << "\n";
cout << yama[2] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, from, to) for (int i = from; i < (to); ++i)
#define mp(x,y) make_pair(x,y)
#define all(x) (x).begin(),(x).end()
#define pb push_back
using ll = long long;
using vin=vector<int>;
using vll=vector<ll>;
using vst=vector<string>;
using P = pair<int, int>;
const int inf=1e9+7;
const ll INF=1e18;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
template<class T> inline void YES(T condition){ if(condition) cout << "YES" << endl; else cout << "NO" << endl; }
const int dx[4] = { 1, 0, -1, 0 };
const int dy[4] = { 0, 1, 0, -1 };
int main(){cout<<fixed<<setprecision(10);
string a,b;
cin>>a>>b;
bool aok=false;
if(a.size()>b.size())aok=true;
else if(a.size()==b.size()){
if(a==b){
cout<<"EQUAL"<<endl;
return 0;
}
aok=(a>b);
}
if(aok){
cout<<"GREATER"<<endl;
}
else cout<<"LESS"<<endl;
}
| 0
| 68,520,238
|
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N=0;
vector<int> szamok;
int seged=0;
cin>>N;
for(int i=0;i<N;i++){
cin >>seged;
szamok.push_back(seged);
}
bool vane=true;
seged=1;
for(int i=1; i<N;i++){
for(int j=0; j<i; j++){
if(szamok[j]>szamok[i]){
vane=false;
break;
}
}
if(vane){
seged++;
}
vane=true;
}
cout<<seged;
return 0;
}
|
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")
#include<bits/stdc++.h>
#define int long long int
#define double long double
#define minheapair priority_queue<pair<int,int>, vector<pair<int,int>> , greater<pair<int,int>> >
#define maxheapair priority_queue<pair<int,int>>
#define minheap priority_queue<int,vector<int>,greater<int>>
#define vi vector<int>
#define vpi vector<pair<int,int> >
#define mii map<int,int>
#define mpi map<pair<int,int>,int>
#define msi map<string,int>
#define u_set unordered_set<int>
#define pb push_back
#define endl "\n"
#define ll int
#define vll vector<long long int>
#define vi vector<int>
#define vvi vector<vector<int>>
#define vvl vector<vector<ll>>
#define io ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define umap unordered_map
#define mod 1000000007
#define fori(a,n) for(int i=a;i<n;i++)
#define forj(a,n) for(int j=a;j<n;j++)
#define inf 9219999999999999999
#define show(x) cout<<"["<<#x<<":"<<x<<"] "
using namespace std;
ll modexp(ll x,ll y,ll m){
ll ans = 1;
while(y>0){
if(y&1){
ans *= x;
ans %= m;
--y;
}
else{
y /= 2;
x *= x;
x %= m;
}
}
return ans;
}
ll minv(ll a,ll m){
return modexp(a,m-2,m);
}
void Z(string s,vector<int>&z){
int L = 0, R = 0;
int n = s.size();
for (int i = 1; i < n; i++)
{
if (i > R)
{
L = R = i;
while (R < n && s[R-L] == s[R])
{
R++;
}
z[i] = R-L;
R--;
}
else
{
int k = i-L;
if (z[k] < R-i+1)
{
z[i] = z[k];
}
else
{
L = i;
while (R < n && s[R-L] == s[R])
{
R++;
}
z[i] = R-L;
R--;
}
}
}
}
using namespace std;
void solve(){
string s;
cin>>s;
int c=0,ans=0;
fori(0,3){
if(s[i]=='R')c++;
else c=0;
ans = max(ans,c);
}
cout<<ans<<endl;
}
signed main(void) {
io
int tt;
tt = 1;
while (tt--)solve();
return 0;
}
| 0
| 71,191,727
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(int)(n); i++)
using namespace std;
using LL = long long;
int main(){
LL N, K;
cin >> N >> K;
vector<LL> A(N), B(N+1), sum(N+1);
rep(i,N) cin >> A[i];
rep(i,N) sum[i+1]=sum[i]+A[i];
rep(i,N) sum[i+1]%=K;
rep(i,N) B[i+1]=sum[i+1]-(i+1);
map<LL,vector<int>> m;
rep(i,N+1){
B[i]%=K;
if(B[i]<0) B[i]+=K;
}
rep(i,N+1) m[B[i]].emplace_back(i);
LL ans=0;
rep(i,N+1){
LL b=B[i];
int j=lower_bound(m[b].begin(),m[b].end(),i)-m[b].begin();
int k=upper_bound(m[b].begin(),m[b].end(),i-K)-m[b].begin();
ans+=j-k;
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
using namespace std;
void countingSort(int A[], int B[], int n, int k) {
int C[k];
for (int i = 0; i <= k; ++i) {
C[i] = 0;
}
for (int j = 1; j <= n; ++j) {
++C[A[j]];
}
for (int i = 1; i <= k; ++i) {
C[i] += C[i - 1];
}
for (int j = n; j >= 1; --j) {
B[C[A[j]]] = A[j];
--C[A[j]];
}
}
int main() {
int n;
scanf("%d", &n);
int A[n + 1];
int k = 0;
for (int i = 1; i <= n; ++i) {
int e;
scanf("%d", &e);
A[i] = e;
if (e > k) {
k = e;
}
}
int B[n + 1];
countingSort(A, B, n, k);
for (int i = 1; i <= n; ++i) {
if (i > 1) {
printf(" %d", B[i]);
} else {
printf("%d", B[i]);
}
}
printf("\n");
return 0;
}
| 0
| 53,911,624
|
#include <bits/stdc++.h>
#define rep(i,n)for(long long i=0;i<(long long)(n);i++)
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
const ll MOD=1e9+7;
const ll INF=1e18;
const int MAX=510000;
const double pi=acos(-1);
int dx[8] = {1,0,-1,0,1,1,-1,-1};
int dy[8] = {0,1,0,-1,-1,1,1,-1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
int n = s.size();
vector<vector<int>>vec(n+1,vector<int>(26,0));
rep(i,n){
rep(j,26){
int add=0;
if(s[i]-'a'==j)add++;
vec[i+1][j]+=vec[i][j]+add;
}
}
int l=-1,r=-1;
if(n == 2){
if(s[0]==s[1]){
l=1;
r=2;
}
}
else{
for(int i=0;i+3<=n;i++){
rep(j,26){
if(vec[i+3][j]-vec[i][j]>=2){
l=i+1;
r=i+3;
break;
}
}
if(l>0 && r>0)break;
}
}
cout << l << " " << r << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int MOD = 1000000007;
const int INF = 999999999;
int main(){
ll N, T;
cin >> N >> T;
vector<ll> t(N);
rep(i, N){
cin >> t[i];
}
int ans = 0;
rep(i, N){
if(i != N-1){
if(t[i+1] - t[i] > T){
ans += T;
}else{
ans += t[i+1] - t[i];
}
}else{
ans += T;
}
}
cout << ans << endl;
return 0;}
| 0
| 92,128,015
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cctype>
#include <cassert>
#include <climits>
#include <string>
#include <bitset>
#include <cfloat>
#include <unordered_set>
#pragma GCC optimize("Ofast")
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int> > vpii;
typedef vector<vector<int> > vvi;
typedef vector<vector<char> > vvc;
typedef vector<vector<string> > vvs;
typedef vector<vector<ll> > vvll;
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define irep(it, stl) for(auto it = stl.begin(); it != stl.end(); it++)
#define drep(i,n) for(int i = (n) - 1; i >= 0; --i)
#define fin(ans) cout << (ans) << '\n'
#define mp(p,q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define Rort(a) sort(a.rbegin(), a.rend())
#define MATHPI acos(-1)
#define itn int;
int dx[8] = { 1, 0, -1, 0, 1, -1, -1, 1 };
int dy[8] = { 0, 1, 0, -1, 1, 1, -1, -1 };
template <class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template <class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
struct io { io() { ios::sync_with_stdio(false); cin.tie(0); } };
const int INF = INT_MAX;
const ll LLINF = 1LL << 60;
const ll MOD = 1000000007;
const double EPS = 1e-9;
signed main(void)
{
ll h, n, r;
r = 0;
ll sum = 0;
cin >>h >>n;
vll a(n);
rep (i, n) {
cin >>a[i];
sum += a[i];
}
if (sum >= h) {
cout <<"Yes";
return 0;
}
cout <<"No";
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int main()
{
int n, m, flag[100001] = {0}, cor = 0, pen = 0, tmp[100001] = {0};
cin >> n >> m;
rep(i, m)
{
int p;
string s;
cin >> p >> s;
if (flag[p] == 0)
{
if (s.compare("WA") == 0)
tmp[p]++;
else
{
flag[p] = 1;
pen += tmp[p];
cor++;
}
}
}
cout << cor << " " << pen << endl;
return 0;
}
| 0
| 51,182,807
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n; cin >> n;
long long ans = 0;
if(n%2 == 0){
n /= 2;
while(n){
ans += n/5;
n /= 5;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
ll n;
ll x, m;
cin >> n >> x >> m;
map<ll,ll> mp;
vector<ll> a,ind(m+1);
ll cnt=0;
ll ai = x;
mp[ai]++;
a.push_back(ai);
ind[ai]=cnt;
ll st=0, ed=n-1;
bool circlep = false;
for(ll i=2; i < n+1;i++) {
ll now = ll(ai*ai) % m;
if (mp[now]==1){
circlep = true;
ed = cnt;
st = ind[now];
break;
} else if (now == 0) {
ed = cnt;
break;
}
mp[now]++;
a.push_back(now);
cnt++;
ind[now]=cnt;
ai = now;
}
ll sum = 0;
if (circlep) {
ll sumc = 0;
ll suma = 0;
rep(i,st) {
sum += a[i];
}
for(ll i= st;i<=ed;i++){
sumc += a[i];
}
ll nshow=(n-st)/(ed-st+1);
ll amari=(n-st)%(ed-st+1);
for(ll i= st;i< st+amari;i++){
suma += a[i];
}
sum += suma;
sum += sumc*nshow;
} else {
for(ll i= st;i<=ed;i++){
sum += a[i];
}
}
cout << sum << endl;
return 0;
}
| 0
| 75,852,150
|
#include<bits/stdc++.h>
using namespace std;
int main(void) {
int a, b;
cin >> a >> b;
if (a == b) cout << "Draw";
else if (a < b && a != 1 || b == 1) cout << "Bob";
else cout << "Alice";
}
|
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <queue>
#include <cstring>
#include <vector>
#include <map>
#include <algorithm>
#include <cctype>
#include <cmath>
#include <bitset>
#include <set>
#include <stack>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define RREP(i,n) for(int i=n-1;i>=0;i--)
#define FOR(i,k,n) for(int i=(k);i<(int)(n);i++)
#define all(i,n) (i),(i+n)
int dx4[4]={1,0,-1,0};
int dy4[4]={0,-1,0,1};
int dx8[8]={1,0,-1,1,-1,1,0,-1};
int dy8[8]={1,1,1,0,0,-1,-1,-1};
int dx9[9]={0,1,0,-1,1,-1,1,0,-1};
int dy9[9]={0,1,1,1,0,0,-1,-1,-1};
typedef pair<int, int> P;
typedef pair<string, int> SP;
typedef long long ll;
typedef pair<ll, ll> PLL;
const int INF = 1e9;
const ll LLINF = 1e18;
const int MAX_V = 1e6+1;
const ll mod = 1000000007;
int n, m, R;
int r[10];
ll d[205][205];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> R;
REP(i, n) REP(j, n) d[i][j] = INF;
REP(i, R) cin >> r[i], r[i]--;
REP(i, m) {
ll a, b, c;
cin >> a >> b >> c;
a--;b--;
if(d[a][b] > c) d[a][b] = d[b][a] = c;
}
sort(r, r + R);
REP(k, n) REP(i, n) REP(j, n) {
if(d[i][j] > d[i][k] + d[k][j]) d[i][j] = d[i][k] + d[k][j];
}
ll ans = INF;
do {
ll sum = 0;
FOR(i, 1, R) sum += d[r[i - 1]][r[i]];
ans = min(ans, sum);
} while(next_permutation(r, r + R));
cout << ans << endl;
}
| 0
| 44,268,589
|
#include<bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define REP(i,n) for (int i=0;i<(n);i++)
#define RREP(i,n) for (int i=(n)-1;i>=0;i--)
typedef long long LL;
int N,A,B;
int C[300001];
void swa(int x,int y){
while(x<y){
int D=C[x];
C[x]=C[y];
C[y]=D;
x++;
y--;
}
}
int Cnt[300001];
int main(){
REP(i,300001){
Cnt[i]=0;
}
cin>>N>>A>>B;
if(A+B>N+1){
cout<<-1<<endl;
return 0;
}
if(A>N){
cout<<-1<<endl;
return 0;
}
if(B>N){
cout<<-1<<endl;
return 0;
}
if(A==1&&(B!=N)){
cout<<-1<<endl;
return 0;
}
if(B==1&&(A!=N)){
cout<<-1<<endl;
return 0;
}
REP(i,N){
C[i]=i+1;
}
int res=N-A;
int pos=0;
while(res!=0){
swa(pos,pos+min(res+1,B)-1);
res-=(min(res+1,B)-1);
pos+=B;
}
int c=0;
int now=0;
REP(i,N){
if(now<C[i]){
c++;
now=C[i];
}
if(C[i]<=0||C[i]>N){
cout<<-1<<endl;
return 0;
}
Cnt[C[i]-1]++;
}
REP(i,N){
if(Cnt[i]!=1){
cout<<-1<<endl;
return 0;
}
}
if(A!=c){
cout<<-1<<endl;
return 0;
}
REP(i,N){
cout<<C[i];
if(i==N-1){
cout<<endl;
}else{
cout<<" ";
}
}
return(0);
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define size_of_array(array) (sizeof(array)/sizeof(array[0]))
#define MAX 100005
#define NIL -1
using ll =long long;
using namespace std;
using Graph=vector<vector<int>>;
using Field=vector<vector<char>>;
using P =pair<int,int>;
template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
const ll mod=1000000007;
int main(){
ll n;
cin>>n;
vector<ll> a(n);
rep(i,n)cin>>a[i];
ll ans=0;
rep(i,60){
int x=0;
rep(j,n){
if((a[j]>>i)&1)++x;
}
ll sum=x*(n-x)%mod;
rep(j,i){
sum=sum*2%mod;
}
ans+=sum%mod;
}
cout<<ans%mod<<endl;
}
| 0
| 39,649,567
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
long long mo = 1e9 + 7;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> Pii;
typedef pair<ll,ll> Pll;
template<class T, class S> void cmin(T &a, const S &b) { if (a > b)a = b; }
template<class T, class S> void cmax(T &a, const S &b) { if (a < b)a = b; }
template<class A>void PR(A a,ll n){rep(i,n){if(i)cout<<' ';cout<<a[i];}cout << "\n";}
ld PI=3.14159265358979323846;
int main(){
ll N,K;
cin >> N >> K;
vector<ll> V(N);
rep(i,N){
cin >> V[i];
}
ll ans = 0;
rep(T,K+1){
rep(A,K-T+1){
ll B = K-T-A;
priority_queue<ll> que;
ll sum = 0;
rep(i,min(ll(A),N)){
que.push(-V[i]);
}
rep(i,min(B,N)){
if(N-1-i <= A-1)break;
que.push(-V[N-1-i]);
}
rep(i,T){
if(que.empty())break;
if(que.top() < 0)break;
que.pop();
}
while(!que.empty()){
sum -= que.top();
que.pop();
}
cmax(ans, sum);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define int long long
const int N = 2e3 + 5;
int n, m;
char c[N][N];
int a[N][N], l[N][N], u[N][N], r[N][N], d[N][N];
int32_t main()
{
IOS;
cin >> n >> m;
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++)
{
cin >> c[i][j];
if(c[i][j] == '.')
a[i][j] = 1;
}
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= m; j++)
{
if(!a[i][j])
l[i][j] = 0;
else
l[i][j] = 1 + l[i][j - 1];
}
}
for(int i = 1; i <= n; i++)
{
for(int j = m; j >= 1; j--)
{
if(!a[i][j])
r[i][j] = 0;
else
r[i][j] = 1 + r[i][j + 1];
}
}
for(int j = 1; j <= m; j++)
{
for(int i = 1; i <= n; i++)
{
if(!a[i][j])
u[i][j] = 0;
else
u[i][j] = 1 + u[i - 1][j];
}
}
for(int j = 1; j <= m; j++)
{
for(int i = n; i >= 1; i--)
{
if(!a[i][j])
d[i][j] = 0;
else
d[i][j] = 1 + d[i + 1][j];
}
}
int ans = 0;
for(int i = 1; i <= n; i++)
{
for(int j = 1; j <= m; j++)
{
if(a[i][j])
{
ans = max(ans, l[i][j] + r[i][j] + u[i][j] + d[i][j] - 3);
}
}
}
cout << ans;
return 0;
}
| 0
| 27,797,989
|
#include<iostream>
#include<cmath>
#include<cstdio>
using namespace std;
int main()
{
double x1,x2,y1,y2,x,y,z;
cin>>x1>>y1>>x2>>y2;
x=x2-x1;
y=y2-y1;
x *=x;
y *=y;
z=sqrt(x+y);
printf("%lf\n",z);
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define pb push_back
#define fs first
#define sc second
#define mp make_pair
using namespace std;
const ll base = 7;
const ll N = 3e5 + 9;
const ll mod = 1e9 + 7;
typedef pair<ll,ll> LL;
ll n,a[N],b[N],i,k;
map<ll,ll> cnt;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
cin>>n>>k;
for(i=1;i<=n;i++){
cin>>a[i];
b[i] = b[i - 1] + a[i];
}
ll ans = 0;
for (i=0;i<=n;i++){
ll p = (b[i] - i)%k;
ans += cnt[p];
cnt[p]++;
if (i >= k - 1){
ll q = i - k + 1;
ll s = (b[q] - q)%k;
cnt[s]--;
}
}
cout<<ans;
}
| 0
| 67,704,649
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<ll> v1;
typedef vector<v1> v2;
typedef vector<v2> v3;
typedef unordered_map<ll, unordered_map<ll, ll>> graph;
const ll INF = 1ll << 50;
const ll mod = 1000000007;
ll n;
int main(){
cin >> n;
cout << n / 3 << endl;
}
|
#include<iostream>
using namespace std;
int main()
{
int a,b,c,x;
cin>>a>>b>>c;
x = c-(a-b);
if(x>0)
cout<<x<<endl;
else
cout<<"0"<<endl;
return 0;
}
| 0
| 13,263,849
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,ini,n) for(int i=ini;i<n;i++)
#define _rep(i,ini,n) for(int i=ini;i>=n;i--)
#define ToEnd(a) a.begin(),a.end()
uint64_t MOD=1000000007;
int main(){
int N,K; cin>>N>>K;
string S; cin>>S;
vector<int> V(N,0);
int idx=0,vIdx=0;
rep(i,1,N){
if(S.at(i-1)!=S.at(i)){
V.at(vIdx)=pow(-1,S.at(i-1)-'0'+1)*(i-idx);
idx=i;
vIdx++;
}
}
V.at(vIdx)=pow(-1,S.at(N-1)-'0'+1)*(N-idx);
vector<int> sumV{0};
rep(i,1,N+1){
if(V.at(i-1)==0) break;
sumV.push_back(sumV.at(i-1)+abs(V.at(i-1)));
}
int ans=0;
for(int i=0;i<sumV.size();i+=2){
if(V.front()>0){
ans=max(ans,sumV.at(min((int)sumV.size()-1,2*K+1+i))-sumV.at(i));
}else{
ans=max(ans,sumV.at(min((int)sumV.size()-1,2*K+i))-sumV.at(max(0,i-1)));
}
}
cout<<ans<<endl;
}
|
#include <cstdio>
#include <algorithm>
using namespace std;
const int INF=10000000;
int dp[10][10];
int main(){
while(true){
int n;
scanf("%d",&n);
if(n==0) break;
for(int i=0;i<10;i++)
for(int j=0;j<10;j++) dp[i][j]=INF;
int a,b,c;
for(int i=0;i<n;i++){
scanf("%d %d %d",&a,&b,&c);
dp[a][b]=dp[b][a]=c;
}
for(int k=0;k<10;k++){
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j]);
}
}
}
int sum[10]={0};
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
if(i!=j && dp[i][j]!=INF){
sum[i]+=dp[i][j];
}
}
}
int ans=INF,ans_i=0;
for(int i=0;i<10;i++){
if(ans>sum[i] && sum[i]!=0){
ans=sum[i];
ans_i=i;
}
}
printf("%d %d\n",ans_i,ans);
}
return 0;
}
| 0
| 80,670,625
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
long long black , sum , a;
string s;
vector<int>v;
int main(){
cin >> s;
sum = 0;
a = 0;
black = 0;
for(int i = 0 ; i < s.size() ; i++){
if(s[i] == 'B'){
black++;
v.pb(i);
}
}
for(int i = v.size() - 1 ; i >= 0 ; i--){
a++;
sum += s.size() - v[i] - a;
}
cout << sum << endl;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <cmath>
#include <map>
#include <string>
#define reps(i,s,n) for(int (i) = (s); (i) < (n); (i)++)
#define rep(i,n) reps(i,0,n)
using namespace std;
using ll = long long;
vector<int> vs[26],vt[26];
int main(){
string s,t;
cin >> s >> t;
int n = s.length();
rep(i,n){
int pos = s[i] - 'a';
vs[pos].push_back(i);
pos = t[i] - 'a';
vt[pos].push_back(i);
}
vector<bool> check(26,false);
rep(i,n){
int p1 = s[i]-'a';
int p2 = t[i]-'a';
if(!check[p1]){
rep(j,vs[p1].size()){
if(vs[p1][j] != vt[p2][j]){
cout << "No" << endl;
return 0;
}
}
check[p1] = true;
}
}
cout << "Yes" << endl;
return 0;
}
| 0
| 57,907,375
|
#include <iostream>
#include <algorithm>
#include <utility>
#include <vector>
#include <functional>
#include <cmath>
#include <cstring>
#include <numeric>
#include <random>
#include <map>
#include <unordered_map>
#include <queue>
#include <regex>
#include <complex>
#include <list>
#include <cassert>
#include <deque>
#include <iomanip>
#define addf(T) [](T a, T b){return (a + b);}
#define minf(T) [](T a, T b){return min(a, b);}
#define maxf(T) [](T a, T b){return max(a, b);}
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define all(x) (x).begin(), (x).end()
#define INF 2000000000
#define LLINF 2000000000000000000ll
#define sq(x) ((x)*(x))
using namespace std;
using ll = long long;
ll gcd(ll x, ll y) { return y ? gcd(y,x%y) : x;}
int main() {
ll n,m;
cin >> n >> m;
ll tempsum = 0;
vector<ll> mods;
mods.push_back(0);
rep(i,n){
ll ai ;
cin >> ai;
tempsum += ai;
mods.push_back(tempsum % m);
}
map<ll,ll> mp;
rep(i,mods.size()){
mp[mods[i]] = 0;
}
ll ans = 0;
rep(i,mods.size()){
mp[mods[i]] = mp[mods[i]] + 1;
ll c = mp[mods[i]];
ans = ans - (c-1)*(c-2)/2 + c*(c-1) / 2;
}
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int i=0;i<n;i++)
using P = pair<int,int>;
const int INF = 1000100100;
char tolower(char c) {return (c + 0x20);}
char toupr(char c) {return (c - 0x20);}
int main()
{
int n, k; cin >> n >> k;
int h[n];
rep(i,n) cin >> h[i];
int dp[n];
rep(i,n) dp[i] = INF;
dp[0] = 0;
for(int i=1; i<n; i++){
for(int j=1; j<=k; j++){
if(i-j < 0) continue;
else dp[i] = min(dp[i], dp[i-j]+abs(h[i]-h[i-j]));
}
}
cout << dp[n-1] << endl;
return 0;
}
| 0
| 84,428,232
|
#include <stdio.h>
#include <string.h>
int main (){
char A[11],B[11],C[11];
scanf("%s %s %s", &A, &B, &C);
strlen (A),(B);
if(A[strlen(A)-1] == B[0] && B[strlen(B)-1] == C[0]){
printf("YES\n");
}
else{
printf("NO\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,b,a) for(int i=b;i>=a;i--)
#define fori(a) for(auto i : a )
#define all(a) begin(a), end(a)
#define set(a,b) memset(a,b,sizeof(a))
#define sz(a) a.size()
#define pi 3.14159
#define ll long long
#define ull unsigned long long
#define pb push_back
#define PF push_front
#define mp make_pair
#define pq priority_queue
#define mod 1000000007
#define f first
#define s second
#define pii pair< int, int >
#define vi vector<int>
#define vpii vector<pii>
#define debug(v) for(auto i:v) cout<<i<<" ";
#define tc int t; cin >> t; while(t--)
using namespace std;
string repeat(string s, int n) {
string s1 = "";
for (int i=0; i<n;i++)
s1+=s;
return s1;
}
string getString(char x) {
string s(1, x);
return s;
}
void optimizeIO(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int gcd(int a, int b){
if (a == 0) return b;
return gcd(b % a, a);
}
void solve(){
int x,y;
cin>>x>>y;
cout<<(x+y/2)<<endl;
}
int main(){
optimizeIO();
{ solve();
}
}
| 0
| 42,834,432
|
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define repLRE(i, l, r) for (ll i = (l); i <= (r); ++i)
#define rrepLRE(i, l, r) for (ll i = (l); i >= (r); --i)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vector<ll>>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;
ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
const ll INF = 1LL << 50;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
ll n;
cin >> n;
vll as(n);
rep(i, n) cin >> as[i];
Sort(as);
ll sum = 0;
ll t = 0;
rep(i, n-1) {
sum += as[i];
if (as[i + 1] > 2 * sum) t = i + 1;
}
cout << n - t << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define N 200000
int n, k;
int cnt[N+5];
vector<pair<int, int>> v;
int in;
int main(int argc, char *argv[])
{
while(cin >> n >> k && (n||k))
{
memset(cnt, 0, sizeof(cnt));
v.clear();
for(int i = 0; i < n && cin >> in; i++)
cnt[in]++;
for(int i = 0; i <= N; i++)
if(cnt[i])
v.push_back(make_pair(cnt[i], i));
sort(v.begin(), v.end());
int d = v.size() - k, ans = 0;
for(int i = 0; i < d; i++)
{
ans += v[i].first;
}
printf("%d\n", ans);
}
}
| 0
| 14,564,770
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n);i++)
#define sz(x) int(x.size())
typedef long long ll;
typedef long double ld;
typedef pair<int,int> P;
constexpr int INF = 2e9;
int main() {
int h, n;
cin >> h >> n;
vector<int> a(n), b(n);
rep(i,n) cin >> a[i] >> b[i];
vector<int> dp(h + 1, INF);
dp[h] = 0;
for (int i = 0; i < n; i++) {
for (int j = h; j >= 0; j--) {
dp[max(j - a[i], 0)] = min(dp[max(j - a[i], 0)], dp[j] + b[i]);
}
}
cout << dp[0] << endl;
return 0;
}
|
#include <algorithm>
#include <climits>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <iomanip>
#include <cmath>
using namespace std;
using ll = long long int;
template <class T> ostream &operator<<(ostream &os, vector<T> &v) {
for (auto i = v.begin(); i != v.end(); i++) {
os << *i << " ";
}
return os;
}
void solve(ll N){
ll l = 0;
ll r = N-1;
ll c;
string x, y, z;
std::cout << l << std::endl;
cin>>x;
if(x=="Vacant")
return;
std::cout << r << std::endl;
cin>>z;
if(z=="Vacant")
return;
while(true){
c=(l+r)/2;
std::cout << c << std::endl;
cin>>y;
if(y=="Vacant")
return;
if((c-l)%2) {
if(x==y) {
r=c;
z=y;
} else {
l=c;
x=y;
}
} else {
if(x==y) {
l=c;
x=y;
} else {
r=c;
z=y;
}
}
}
}
int main(){
ll N;
std::cin >> N;
solve(N);
return 0;
}
| 0
| 28,861,188
|
#include<iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <set>
#include <queue>
#include <deque>
#include <map>
#include <stack>
#include<bitset>
#include<list>
#include<cassert>
#include<numeric>
using namespace std;
const int N = 400;
bool dp[N][N];
char a[N][N];
int n;
int ans = 0;
int main()
{
cin >> n;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
cin >> a[i][j];
}
}
for (int b = 0; b < n; b++)
{
dp[b][0] = true;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
if (a[(j + b) % n][i] != a[(i + b) % n][j])
{
dp[b][0] = false;
}
}
}
}
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
if (dp[i][j])
{
ans++;
}
}
}
cout << ans * n<< endl;
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <time.h>
#include <math.h>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>
#include <sstream>
#include <string>
#include <bitset>
using namespace std;
#define FOR(I,F,N) for(int I = F; I < (int)(N); I++)
#define rep(i, n) FOR(i, 0, n)
#define FIN(V) cout<<V<<endl
#define pb push_back
#define INF (1 << 30)
typedef pair<int, int> P;
typedef long long ll;
typedef priority_queue<int> pq;
int StrToInt(string);
string IntToStr(int);
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int main(void){
int n, m;
cin >> n >> m;
vector<int> v;
rep(i,m){
int a;
cin >> a;
v.pb(a);
}
int dp[n+1];
fill_n(dp, n+1, INF);
dp[0] = 0;
rep(i, n+1){
rep(j, v.size()){
if(i-v[j] >= 0)
dp[i] = min(dp[i-v[j]]+1, dp[i]);
}
}
FIN(dp[n]);
return 0;
}
| 0
| 19,687,441
|
#include <bits/stdc++.h>
using namespace std;
int main () {
int a, b;
cin >> a >> b;
int big=max(a, b);
int small=min(a, b);
string mojiretsu=to_string(small);
if (big>small) {
for (int i=0; i<big; i++) {
cout << mojiretsu;
}
cout << endl;
}
else {
for (int i=0; i<big; i++) {
cout << mojiretsu;
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y)
{
if (y == 0) return (x);
return (gcd(y, x % y));
}
int main(void)
{
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
int res = 0;
for (int i = 0; i < n; i++) res = gcd(res, a[i]);
bool is_setwise = (res == 1);
vector<bool> is_prime(1e6 + 1, true);
is_prime[0] = false; is_prime[1] = false;
vector<int> prime_list;
for (int i = 2; i * i <= 1e6; i++)
{
if (is_prime[i])
{
prime_list.push_back(i);
for (int j = 2; (long long)j * i <= 1e6; j++) is_prime[j * i] = false;
}
}
map<int, bool> used_prime;
bool is_pairwise = true;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < prime_list.size(); j++)
{
if (a[i] == 1) break ;
if (a[i] % prime_list[j] == 0)
{
if (used_prime[prime_list[j]] == true) is_pairwise = false;
used_prime[prime_list[j]] = true;
while (a[i] % prime_list[j] == 0) a[i] /= prime_list[j];
}
}
if (a[i] != 1)
{
if (used_prime[a[i]] == true) is_pairwise = false;
used_prime[a[i]] = true;
}
}
if (is_pairwise) cout << "pairwise coprime" << endl;
else
{
if (is_setwise == true) cout << "setwise coprime" << endl;
else cout << "not coprime" << endl;
}
return (0);
}
| 0
| 58,466,866
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const long long INF = 1e18;
# define len(x) ((int)(x).size())
# define rep(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
# define reps(i, n) for(int i=1, i##_len=(n); i<=i##_len; ++i)
# define rrep(i, n) for(int i=((int)(n)-1); i>=0; --i)
# define rreps(i, n) for(int i=((int)(n)); i>0; --i)
# define foreps(i, m, n) for(int i = m;i < n;i++)
# define ALL(x) (x).begin(), (x).end()
# define rall(x) (x).rbegin(), (x).rend()
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; }
int main() {
ll N, M; cin >> N >> M;
vector<bool> s(200050, false), t(200050, false);
rep(i, M) {
ll a, b; cin >> a >> b;
if (a == 1) t[b] = true;
if (b == N) s[a] = true;
}
rep(i, 200050) {
if (s[i] && t[i]) {
cout << "POSSIBLE" << endl;
return 0;
}
}
cout << "IMPOSSIBLE" << endl;
}
|
#include <iostream>
using namespace std;
int c;
void search(int last, int s, int n)
{
if(n==0){
if(s==0) c++;
return;
}
if(n==1){
if(last<s&&s<10) c++;
return;
}
--n;
for(int i=last+1; i<10; i++){
search(i, s-i, n);
}
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
while(true){
int n, s;
cin>>n>>s;
if(n==0&&s==0) break;
c=0;
for(int i=0; i<10; i++){
search(i, s-i, n-1);
}
cout<<c<<'\n';
}
return 0;
}
| 0
| 32,044,652
|
#include <bits/stdc++.h>
using namespace std;
#define FAST ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define MAXX 500005
#define INF INT_MAX
#define PI 3.14159265358979323846264338327950
#define PB push_back
#define PF push_front
#define F first
#define S second
#define fixx(n) fixed << setprecision(n)
#define ll long long
#define mod 1000000007
int main()
{
FAST;
int n; int a, b;
cin >> n >> a >> b;
for(int i = a; i <= b; i ++){
if(i % n == 0 ){
cout << "OK";
return 0;
}
}
cout << "NG";
}
|
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<cmath>
#include<ctime>
#include<algorithm>
#include<utility>
#include<stack>
#include<queue>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#define EPS 1e-9
#define PI acos(-1.0)
#define INF 0x3f3f3f3f
#define LL long long
const int MOD = 1E9+7;
const int N = 1000+5;
const int dx[] = {-1,1,0,0,-1,-1,1,1};
const int dy[] = {0,0,-1,1,-1,1,-1,1};
using namespace std;
LL a[10000];
int main()
{
int n;
scanf("%d",&n);
for(int i=1; i<=n; i++)
{
scanf("%lld",&a[i]);
}
LL ans=0;
while(true)
{
LL maxn=a[1];
int id=1;
for(int i=2; i<=n; i++)
{
if(maxn<a[i])
{
maxn=a[i];
id=i;
}
}
if(maxn<=n-1)
break;
for(int i=1; i<=n; i++)
{
if(i==id)
{
a[i]=maxn%n;
}
else
{
a[i]+=maxn/n;
}
}
ans+=maxn/n;
}
printf("%lld\n",ans);
}
| 0
| 22,624,058
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(ll i = 0, i##_len = (n); i < i##_len; ++i)
#define rep2(i, x, n) for(ll i = x, i##_len = (n); i < i##_len; ++i)
#define all(n) begin(n), end(n)
using ll = long long;
using P = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vs = vector<string>;
using vc = vector<char>;
using vb = vector<bool>;
using vd = vector<double>;
vi dir = {-1, 0, 1, 0, -1, -1, 1, 1, -1};
int main() {
ll n, m;
cin >> n >> m;
vl cum(n + 1, 0);
rep(i, m) {
ll a, b;
cin >> a >> b;
cum[a]++;
cum[b]--;
}
bool ans = true;
rep(i, n) {
cum[i + 1] += cum[i];
if(cum[i + 1] % 2) ans = false;
}
cout << (ans ? "YES" : "NO") << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> Pii;
typedef pair<ll,ll> Pll;
#define rep(i,n) for (ll i=0;i<n;++i)
#define rep2(i,a,b) for (ll i=a;i<b;++i)
const ll MOD=1e9+7;
const ll INF=1e9;
const ll IINF=1e18;
const double EPS=1e-8;
const double pi=acos(-1);
template<class T> inline bool chmin(T &a,T b){
if (a>b){
a=b;
return true;
}
return false;
}
template<class T> inline bool chmax(T &a,T b){
if (a<b){
a=b;
return true;
}
return false;
}
int main(){
int N,A,B;
cin >> N >> A >> B;
if (A+B-1>N){
cout << -1 << endl;
return 0;
}
if (A==1){
if (B!=N){
cout << -1 << endl;
return 0;
}
for (int i=N;i>0;--i) cout << i << ' ';
cout << endl;
return 0;
}
if (B==1){
if (A!=N){
cout << -1 << endl;
return 0;
}
for (int i=1;i<=N;++i) cout << i << ' ';
cout << endl;
return 0;
}
if ((N+A-1)/A<=B){
int x=(N-B)/(A-1),y=(N-B)%(A-1)+1,now=N-A+1;
rep(i,x){
rep(j,A){
cout << now+j << ' ';
}
if (i!=x-1) now-=A;
else now-=y;
}
if (now<=0) return 0;
rep(i,y) cout << now+i << ' ';
--now;
while(now>0){
cout << now << ' ';
--now;
}
cout << endl;
return 0;
}
if ((N+B-1)/B<=A){
int x=(N-A)/(B-1),y=(N-A)%(B-1)+1,now=B;
rep(i,x){
rep(j,B){
cout << now-j << ' ';
}
if (i!=x-1) now+=B;
else now+=y;
}
if (now>=N+1) return 0;
rep(i,y) cout << now-i << ' ';
++now;
while(now<=N){
cout << now << ' ';
++now;
}
cout << endl;
}
else cout << -1 << endl;
}
| 0
| 35,761,334
|
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0; i<n; i++)
using namespace std;
using ll = long long;
const ll INF = 10e9;
ll MOD=1000000007;
int main(){
int n,m,x; cin>>n>>m>>x;
int C[n];
int A[n][m];
ll algo[m];
ll money = INF;
bool jud = false;
rep(i,n){
cin>> C[i];
rep(j,m) cin>>A[i][j];
}
rep(bit, 1<<n){
rep(k,m) algo[k]=0;
ll tmp = 0;
rep(i,n){
if (bit & (1<<i)){
rep(j,m) algo[j] += A[i][j];
tmp += C[i];
}
}
bool ok = true;
rep(k,m){
if (algo[k]<x) ok = false;
}
if (ok){
jud = true;
money = min(money, tmp);
}
}
if (jud) cout << money << endl;
else cout << -1 << endl;
}
|
#include <cstdio>
#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <string>
#include <cmath>
#include <functional>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#define rep(i,n) for (int i=0;i<n;i++)
using ll = long long;
using namespace std;
void solve(){
}
int main (){
ios::sync_with_stdio(0);
cin.tie(0);
ll n,m;
cin >> n >> m;
if(n==1&&m==1){
cout << 1;
return 0;
}
if(n==1){
cout << m-2;
return 0;
}
if(m==1){
cout << n-2;
return 0;
}
cout << (n-2)*(m-2);
return 0;
}
| 0
| 44,420,096
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using Graph=vector<vector<int>>;
#define MAX 200003
#define MOD 1000000007
int main(){
int N;
cin>>N;
vector<pair<double,pair<ll,ll>>> xy(N);
for(int i=0;i<N;i++){
ll x,y;
cin>>x>>y;
xy.at(i).second.first=x;
xy.at(i).second.second=y;
complex<double> c(x,y);
xy.at(i).first=arg(c);
}
sort(xy.begin(),xy.end());
ll ans=0;
for(int i=0;i<N;i++){
ll x=0;
ll y=0;
for(int j=0;j<N;j++){
x+=xy.at((i+j)%N).second.first;
y+=xy.at((i+j)%N).second.second;
ans=max<ll>(ans,x*x+y*y);
}
}
printf("%.12Lf\n",sqrtl(ans));
}
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cmath>
#include<bitset>
#include<deque>
#include<functional>
#include<iterator>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<utility>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
#define a first
#define b second
#define sz(x) (ll)((x).size())
#define pb push_back
#define mp make_pair
#define bg begin()
#define ed end()
#define all(x) (x).bg,(x).ed
#define rep(i,n) for(ll i=0;i<(n);i++)
#define rep1(i,n) for(ll i=1;i<=(n);i++)
#define rrep(i,n) for(ll i=(n)-1;i>=0;i--)
#define rrep1(i,n) for(ll i=(n);i>=1;i--)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
const ll MOD=1000000007;
const ll INF=1000000000000000;
template<class T> inline bool chmin(T& a, T b){if(a>b){a=b;return true;}return false;}
template<class T> inline bool chmax(T& a, T b){if(a<b){a=b;return true;}return false;}
ll maxx(ll x,ll y,ll z){return max(max(x,y),z);}
ll minn(ll x,ll y,ll z){return min(min(x,y),z);}
ll gcd(ll x,ll y){if(x%y==0) return y;else return gcd(y,x%y);}
ll lcm(ll x,ll y){return x*(y/gcd(x,y));}
ll digsz(ll x){if(x==0) return 1;else{ll ans=0;while(x){x/=10;ans++;}return ans;}}
ll digsum(ll x){ll sum=0;while(x){sum+=x%10;x/=10;}return sum;}
vector<ll> pw2(62,1);vector<ll> pw10(19,1);
int main(){
{rep1(i,61) pw2[i]=2*pw2[i-1];}
{rep1(i,18) pw10[i]=10*pw10[i-1];}
ll N,K; cin>>N>>K;
double ans=0.0;
rep1(i,N){
ll now=0,tmp=i;
while(tmp<K){
tmp*=2;
now++;
}
ans+=1/(double)(pw2[now]);
}
printf("%.13f\n",ans/N);
}
| 0
| 78,747,662
|
#include <iostream>
using namespace std;
int main() {
int w,h,x,y,r; cin >> w>>h>>x>>y>>r;
if((x-r>=0)&&(x+r<=w)&&(y-r>=0)&&(y+r<=h)){cout << "Yes\n";}else{cout << "No\n";}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i=0;i<n;i++)
using namespace std;
using ll = long long;
int main() {
char a;
cin >> a;
if (a=='A'||a=='B'||a=='C'||a=='D'||a=='E'||a=='F'||a=='G'||a=='H'||a=='I'||a=='J'||a=='K'||a=='L'||a=='M'||a=='N'||a=='O'||a=='P'||a=='Q'||a=='R'||a=='S'||a=='T'||a=='U'||a=='V'||a=='W'||a=='X'||a=='Y'||a=='Z') cout << 'A' << endl;
else cout << 'a' << endl;
}
| 0
| 69,702,802
|
#include<iostream>
#include<cstdlib>
using namespace std;
struct node
{
struct node *parent,*left,*right;
int id,depth;
};
node* nil;
void setdepth(node*,int);
node* getroot(node*);
void printchildren(node*);
int main(){
int n;
cin >> n;
node **N;
nil = (node*)malloc(sizeof(node));
N = (node**)malloc(sizeof(node*)*n);
for(int i=0;i<n;i++) N[i] = (node*)malloc(sizeof(node));
nil->parent = nil->left = nil->right = nil;
nil -> id = -1;
N[0]->parent = nil;
for(int i=0;i<n;i++) N[i]->parent = N[i]->left = N[i]->right = nil;
for(int i=0;i<n;i++){
int id,k;
cin >> id >> k;
N[id]->id = id;
int *c;
c = (int*)malloc(sizeof(int)*k);
for(int j=0;j<k;j++) cin >> c[j];
for(int j=0;j<k;j++){
if(j ==0) N[id]->left = N[c[j]];
N[c[j]]->parent = N[id];
if(j < k-1) N[c[j]]->right = N[c[j+1]];
else if(j == k-1) N[c[j]]->right = nil;
}
if(k == 0) N[id]->left = nil;
free(c);
}
node *root = getroot(N[0]);
setdepth(root,0);
for(int i=0;i<n;i++){
int p,d;
p = N[i]->parent->id;
d = N[i] -> depth;
cout << "node " << N[i]->id << ": parent = " << p << ", depth = " << d << ", ";
if(N[i] == root) cout << "root, ";
else if(N[i]->left == nil) cout << "leaf, ";
else cout << "internal node, ";
printchildren(N[i]);
cout << endl;
}
free(nil);
for(int i=0;i<n;i++) free(N[i]);
free(N);
return 0;
}
void setdepth(node* x,int d){
x->depth = d;
if(x->right != nil) setdepth(x->right,d);
if(x->left != nil) setdepth(x->left,d+1);
}
node* getroot(node* x){
int i=0;
while(x->parent != nil){
x = x->parent;
i++;
if(i >= 100000){
}
}
return x;
}
void printchildren(node* x){
node* l = x->left;
cout << "[";
while(1){
if(l != nil)cout << l->id;
if(l->right == nil) break;
else cout << ", ";
l = l->right;
}
cout << "]";
}
|
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main() {
int N;
cin>>N;
vector<long> A(N);
for(int i=0;i<N;++i){
cin>>A[i];
}
sort(A.begin(), A.end());
long mini = A[0], maxi = A[N-1];
vector<long> minarr, pluarr;
for(int i=1;i<N-1;++i){
if(A[i]>=0){
pluarr.push_back(A[i]);
mini -= A[i];
}
else {
minarr.push_back(A[i]);
maxi -= A[i];
}
}
cout<<maxi - mini<<endl;
maxi = A[N-1];
mini = A[0];
for(int i=0;i<minarr.size();++i){
cout<<maxi<<" "<<minarr[i]<<endl;
maxi -= minarr[i];
}
for(int i=0;i<pluarr.size();++i){
cout<<mini<<" "<<pluarr[i]<<endl;
mini -= pluarr[i];
}
cout<<maxi<<" "<<mini<<endl;
}
| 0
| 1,386,444
|
#include <iostream>
#include <string>
#include <vector>
#include <list>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
#include <fstream>
#include <sstream>
#include <iomanip>
#define ll long long
using namespace std;
long long MOD = 1000000007;
long long gcd(long long N, long long M){
while (true){
if (min(N,M)==0){
return max(N,M);
}else if (N>M){
N%=M;
}else{
M%=N;
}
}
}
long long lcm(long long N, long long M){
return N*M/gcd(N,M);
}
int main(){
ll X;
cin >> X;
ll l=lcm(X,360);
cout << l/X << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define P pair<int,int>
#define fi first
#define se second
#define rep(i,n) for(int i=0;i<n;i++)
#define all(v) v.begin(),v.end()
#define pb push_back
template<class T>void chmax(T &a,T b){if(a<b)a=b;}
template<class T>void chmin(T &a,T b){if(a>b)a=b;}
constexpr int INF=1000000000000000000;
constexpr int mod=1000000007;
int dx[]={0,1,0,-1},dy[]={1,0,-1,0};
int kaijo[2000010];
int gcd(int a,int b){
if(b==0)return a;
return gcd(b,a%b);
}
int lcm(int a,int b){
return a/gcd(a,b)*b;
}
bool prime(int a){
if(a==1)return false;
for(int i=2;i*i<=a;i++){
if(a%i==0)return false;
}
return true;
}
void init_fact(){
kaijo[0]=1;
for(int i=1;i<=2000000;i++){
kaijo[i]=kaijo[i-1]*i;
kaijo[i]%=mod;
}
}
int modpow(int a,int b){
if(b==0)return 1;
if(b%2)return modpow(a,b-1)*a%mod;
int memo=modpow(a,b/2);
return memo*memo%mod;
}
int comb(int a,int b){
if(!kaijo[0])init_fact();
return kaijo[a]*modpow(kaijo[a-b],mod-2)%mod*modpow(kaijo[b],mod-2)%mod;
}
int inv(int x){
x=modpow(x,mod-2);
return x;
}
bool kosa(double ax,double ay,double bx,double by,double cx,double cy,double dx,double dy){
double ta=(cx-dx)*(ay-cy)+(cy-dy)*(cx-ax);
double tb=(cx-dx)*(by-cy)+(cy-dy)*(cx-bx);
double tc=(ax-bx)*(cy-ay)+(ay-by)*(ax-cx);
double td=(ax-bx)*(dy-ay)+(ay-by)*(ax-dx);
return tc*td<0&&ta*tb<0;
}
int n;
vector<int>v[100010];
bool used[100010];
int G[100010];
void dfs(int x){
used[x]=true;
if(x&&v[x].size()==1){
G[x]=0;
return;
}
if((x==0&&v[x].size()==1)||(x&&v[x].size()==2)){
for(int i:v[x]){
if(!used[i]){
dfs(i);
G[x]=G[i]+1;
}
}
return;
}
for(int i:v[x]){
if(!used[i]){
dfs(i);
G[x]^=(G[i]+1);
}
}
}
signed main(){
cin>>n;
rep(i,n-1){
int a,b;
cin>>a>>b;
a--,b--;
v[a].pb(b);
v[b].pb(a);
}
dfs(0);
if(G[0]==0)puts("Bob");
else puts("Alice");
return 0;
}
| 0
| 6,164,456
|
#define _USE_MATH_DEFINES
#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include <string>
#include<math.h>
#include<iomanip>
#include<stdio.h>
#include <stdlib.h>
#include<stdio.h>
#include <queue>
#include<map>
#include <sstream>
#include<set>
#include<stack>
typedef long long int ll;
using namespace std;
int main()
{
int a, b, c, d;
cin >> a >> b >> c >> d;
int x = c + (-d + b), y = d + (c - a);;
cout << x << " " << y << " ";
int g = x + (-y + d), f = y + (x - c);
cout << g << " " << f << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
bool flag = false;
for (int i = 0; i <= x; i++) {
if ((2 * i + 4 * (x - i)) == y) {
flag = true;
}
}
if (flag) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
return 0;
}
| 0
| 92,792,948
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (int i = 0; i < (n); ++i)
double const PI = 3.1415926535897932384626433;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
cout << abs(a[0] - a[a.size() - 1]) << endl;
return 0;
}
|
#include <iostream>
using namespace std;
class Triangle {
public:
double Cross_Product_AB_AP, Cross_Product_BC_BP, Cross_Product_CA_CP;
double Vec_ABx, Vec_BCx, Vec_CAx, Vec_APx, Vec_BPx, Vec_CPx;
double Vec_ABy, Vec_BCy, Vec_CAy, Vec_APy, Vec_BPy, Vec_CPy;
Triangle(double x1, double y1, double x2, double y2, double x3, double y3, double xp, double yp);
bool IsInTriangle();
};
Triangle::Triangle(double x1, double y1, double x2, double y2, double x3, double y3, double xp, double yp){
Vec_ABx = x2 - x1;
Vec_BCx = x3 - x2;
Vec_CAx = x1 - x3;
Vec_APx = xp - x1;
Vec_BPx = xp - x2;
Vec_CPx = xp - x3;
Vec_ABy = y2 - y1;
Vec_BCy = y3 - y2;
Vec_CAy = y1 - y3;
Vec_APy = yp - y1;
Vec_BPy = yp - y2;
Vec_CPy = yp - y3;
Cross_Product_AB_AP = Vec_ABx*Vec_APy - Vec_ABy*Vec_APx;
Cross_Product_BC_BP = Vec_BCx*Vec_BPy - Vec_BCy*Vec_BPx;
Cross_Product_CA_CP = Vec_CAx*Vec_CPy - Vec_CAy*Vec_CPx;
};
bool Triangle::IsInTriangle(){
if ((Cross_Product_AB_AP >= 0 && Cross_Product_BC_BP >= 0 && Cross_Product_CA_CP >= 0) ||
(Cross_Product_AB_AP <= 0 && Cross_Product_BC_BP <= 0 && Cross_Product_CA_CP <= 0)){
return true;
}
else { return false;}
};
int main(){
double x1, y1, x2, y2, x3, y3, xp, yp;
while (cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> xp >> yp){
Triangle Triangle(x1, y1, x2, y2, x3, y3, xp, yp);
if (Triangle.IsInTriangle() == true){
cout << "YES"<<endl;
}
else if (Triangle.IsInTriangle() == false) {
cout << "NO" << endl;
}
}
return 0;
}
| 0
| 42,408,013
|
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <bits/stdc++.h>
#include <iomanip>
#include <numeric>
#include <map>
#include <algorithm>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (ll i = a; i < (ll)b; ++i)
#define rep(i, a, b) for (ll i = a; i < (ll)b; ++i)
#define INF 10e12
#define MAX 51000
#define all(x) (x).begin(), (x).end()
#define MX(x) *max_element(all(x))
#define MN(x) *min_element(all(x))
int main(void)
{
int t, x;
cin >> t >> x;
double ans = (double)t / x;
cout << fixed << setprecision(20);
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
#define all(x) (x).begin(), (x).end()
#define call(x) (x).cbegin(), (x).cend()
#define rall(x) (x).rbegin(), (x).rend()
#define pb push_back
#define sz(x) ((x).size())
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define rep(i, a, b) for(ll i = ll(a); i < ll(b); i++)
const double PI = acos(-1);
const int mod = 1e9+7;
const long long INF = (1LL << 60);
const int dx[] = {0,1,0,-1,1,1,-1,-1};
const int dy[] = {1,0,-1,0,1,-1,-1,1};
ll gcd(ll a,ll b){return b ? gcd(b,a%b) : a;}
ll lcm(ll a,ll b){return a / gcd(a,b) * b;}
ll stringcount(string s, char c){return count(s.cbegin(), s.cend(), c);}
bool isInteger(double x){return floor(x) == x;}
ll ceil(ll a, ll b){return ((a)+(b)-1)/b;}
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; }
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
ll cntw = 0, cntb = 0;
ll n = sz(s);
rep(i, 0, n){
if(s[i] == s[i+1]) continue;
else if(s[i] == 'B') cntb++;
else if(s[i] == 'W') cntw++;
}
if(cntw == 0 || cntb == 0) cout << 0 << endl;
else cout << cntb + cntw - 1 << endl;
return 0;
}
| 0
| 43,550,124
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int K;
cin >> K;
vector<long long> A( K );
for( int i = 0; i < K; i++ ) {
cin >> A[i];
}
auto f = [&]( long long n ) -> long long
{
long long res = n;
for( int i = 0; i < K; i++ ) {
res -= res % A[i];
if( res < 0 ) return -1;
}
return res;
};
const long long INF = INT64_MAX / 2;
long long l = 0;
long long r = INF;
while( r - l > 1 ) {
long long m = (l + r) / 2;
if( f( m ) <= 2 ) l = m;
else r = m;
}
long long ma = l;
l = 0;
r = INF;
while( r - l > 1 ) {
long long m = (l + r) / 2;
if( f( m ) >= 2 ) r = m;
else l = m;
}
long long mi = r;
if( mi > ma ) cout << -1 << endl;
else cout << mi << " " << ma << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define ull unsigned long long
#define ld long double
#define vi vector<int>
#define vll vector<ll>
#define vc vector<char>
#define vs vector<string>
#define vpii vector<pii>
#define vpll vector<pll>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define repr(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rep1r(i, n) for (int i = ((int)(n)); i >= 1; i--)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define RSORT(x) sort(rall(x));
#define pb push_back
#define mp make_pair
#define INF (1e9)
#define PI (acos(-1))
#define EPS (1e-7)
ull gcd(ull a, ull b) { return b ? gcd(b, a % b) : a; }
ull lcm(ull a, ull b) { return a / gcd(a, b) * b; }
int main(){
int h, w, a, b;
cin >> h >> w >> a >> b;
vector<vi> s(h, vi(w));
rep(i, h) rep(j, w) {
if (i<b && j<a) s[i][j] = 1;
else if (i>=b && j>=a) s[i][j] = 1;
}
rep(i, h) {
rep(j, w) printf("%d", s[i][j]);
cout << endl;
}
return 0;
}
| 0
| 37,544,228
|
#include<iostream>
#include<string>
#include<algorithm>
#include<list>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<numeric>
#include<vector>
#include<cstdio>
#include<climits>
#include<cfloat>
#include<cstring>
#define rforeach(t,p) for(t::reverse_iterator it=p.rbegin();it!=p.rend();++it)
#define all(p) p.begin(),p.end()
#define REP(i,n) for(int i=0;i<n;i++)
#define foreach(t,p,tit) for(t::iterator tit=p.begin();tit!=p.end();++tit)
using namespace std;
int main()
{
int n=0,maxn=0,maxlen=0;
string ss,maxs="",maxns;
map<string,int > tango;
map<string,int>::iterator it;
while(cin>>ss)
{
if(maxlen <ss.size())
{
maxlen = ss.size();
maxs = ss;
}
it = tango.find(ss);
if(it==tango.end())
{
tango.insert(map<string,int>::value_type(ss,1));
}
else
{
n = (*it).second+ 1;
tango.erase(it);
tango.insert(map<string,int>::value_type(ss,n));
maxn = max(n,maxn);
}
}
for(map<string,int>::iterator it2=tango.begin();it2!=tango.end(); ++it2)
if( (*it2).second == maxn){cout << (*it2).first; break;}
cout << " " << maxs << endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <algorithm>
#include <functional>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <cstdio>
#include <cmath>
#include <tuple>
#include <iomanip>
#include <numeric>
#include <unordered_map>
#include <sstream>
#include<limits.h>
#include<float.h>
#include<list>
#include <array>
#include <complex>
#include<stdio.h>
#include<string.h>
using namespace std;
#define int long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
#define MOD 1000000007
#define MEM_SIZE 10000
#define DEBUG_OUT true
#define ALL(x) (x).begin(),(x).end()
template<typename T> void DEBUG(T e){if(DEBUG_OUT == false)return; std::cout << e <<" ";}
template<typename T> void DEBUG(const std::vector<T>& v){if(DEBUG_OUT == false)return;for(const auto& e : v){std::cout<< e << " "; } std::cout << std::endl;}
template<typename T> void DEBUG(const std::vector<std::vector<T> >& vv){if(DEBUG_OUT == false)return;for(const auto& v : vv){ DEBUG(v); } }
template<class T,class... Ts> void DEBUG(T d, Ts... e){if(DEBUG_OUT == false)return;DEBUG(d);DEBUG(e...);cout<<"\n";};
template <class T> void corner(bool flg, T hoge) {if (flg) {cout << hoge << endl; exit(0);}}
template< typename T1, typename T2 > inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template< typename T1, typename T2 > inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
template<typename T> vector<T> make_v(size_t a){return vector<T>(a);}
template<typename T,typename... Ts> auto make_v(size_t a,Ts... ts){ return vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...)); }
template<typename T,typename V> typename enable_if<is_class<T>::value==0>::type fill_v(T &t,const V &v){t=v;}
template<typename T,typename V> typename enable_if<is_class<T>::value!=0>::type fill_v(T &t,const V &v){ for(auto &e:t) fill_v(e,v); }
template<typename T,typename U,typename... V> typename enable_if<is_same<T, U>::value!=0>::type fill_v(U &u,const V... v){u=U(v...);}
template<typename T,typename U,typename... V> typename enable_if<is_same<T, U>::value==0>::type fill_v(U &u,const V... v){ for(auto &e:u) fill_v<T>(e,v...);}
void solve(void)
{
string str;
cin>>str;
vector<int> Z(26,0);
for (int i = 0; i < str.size(); i++)
{
Z[str[i] - 'a']++;
}
if(str.size() <26)
{
for (int i = 0; i < 26; i++)
{
if(Z[i] == 0){str += char(i+'a');break;}
}
cout<<str<<endl;
}
else
{
int i = 0;
for (i = 0; i < 26; i++)
{
if(str[i+1] > str[i])break;
}
if(i == 26)
{
cout<<-1<<endl;
return;
}
string str1 = str;
next_permutation(ALL(str1));
for (int i = 0; i < 26; i++)
{
cout<<str1[i];
if(str1[i] != str[i])break;
}
cout<<endl;
}
return;
}
int32_t main(int32_t argc, const char *argv[])
{
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(9);
solve();
return 0;
}
| 0
| 49,556,427
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int X, N, near=0, dif, count=0, ans1, ans2, ans=0;
cin >> X >> N;
if(N == 0){
cout << X << endl;
return 0;
}
vector<int> P(N);
for(int n=0; n<N; n++){
cin >> P.at(n);
}
for(int i=0; i<N; i++){
count = 0;
for(int n=0; n<N && count != 2; n++){
dif = X - P.at(n);
if(abs(dif) == near){
ans1 = dif;
count++;
} else if(abs(dif) == near && count == 1) {
count++;
}
}
if(count == 0){
ans = X - near;
break;
} else if(count == 1 && ans1 != 0){
ans = X + ans1;
break;
}
near++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define MAXN 200005
using namespace std;
typedef long long ll;
ll a[55],ans;
int n;
int main() {
scanf("%d",&n);
for(int i = 1 ; i <= n ; ++i)
scanf("%lld",&a[i]);
while(1) {
int t = 1;
for(int i=2;i<=n;++i)
if(a[i]>a[t]) t=i;
if(a[t]<n) break;
ll k = (a[t]-(n -1)-1)/n + 1;
a[t]-= k*n;
ans += k;
for(int i = 1 ; i <= n ; ++i)
if(i != t) a[i] += k;
}
printf("%lld\n",ans);
return 0;
}
| 0
| 3,848,699
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
long long gcd(long long a, long long b)
{
if (a%b == 0)
{
return(b);
}
else
{
return(gcd(b, a%b));
}
}
long long lcm(long long a, long long b)
{
return a * b / gcd(a, b);
}
int main() {
int n,k;
cin >> n >> k;
vector<long long> a(n);
rep(i,n) cin >> a.at(i);
sort(a.begin(),a.end());
string ans="POSSIBLE";
if(k>a.at(n-1)) ans="IMPOSSIBLE";
else if(n!=1){
long long num=gcd(a.at(0),a.at(1));
for(int i=2; i<n; i++){
num=gcd(num,a.at(i));
}
if(k%num) ans="IMPOSSIBLE";
}
else if(k!=a.at(0)) ans="IMPOSSIBLE";
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
inline int gi(){
char ch=getchar();int x=0,q=0;
while(ch<'0' || ch>'9') ch=='-'?q=1:0,ch=getchar();
while(ch>='0' && ch<='9') x=x*10+ch-'0',ch=getchar();
return q?(-x):x;
}
int z[20];
int gc(){
char ch=getchar();
while(ch!='Y'&&ch!='N') ch=getchar();
return ch=='Y';
}
int main(){
int d=0;
for (ll i=1; i<=1e10; i*=10){
cout<<"? "<<i<<endl;
z[++d]=gc();
}
if (z[d]==1){
for (ll s=10; ; s*=10){
cout<<"? "<<s-1<<endl;
if (gc()){
cout<<"! "<<s/10;
return 0;
}
}
}
for (int i=1; i<=d; ++i)
if (z[i]==0){
--i;
ll l=1,r=1,mid,ans;
for (int j=1; j<=i; ++j)
l*=10;
r=l,l/=10;
while(l<=r){
mid=(l+r)>>1;
cout<<"? "<<mid*10<<endl;
if (gc()) ans=mid,r=mid-1;
else l=mid+1;
}
cout<<"! "<<ans;
return 0;
}
return 0;
}
| 0
| 83,197,360
|
#include <iostream>
#include <vector>
using namespace std;
int main() {
long long N; cin >> N;
vector<long long>C(N - 1), S(N - 1), F(N - 1);
for (long long i = 0; i < N - 1; i++) {
cin >> C.at(i) >> S.at(i) >> F.at(i);
}
vector<long long>ans(N, 0);
for (long long i = 0; i < N; i++) {
if (i == N - 1) continue;
else {
ans.at(i) += S.at(i);
for (long long j = i; j < N - 1; j++) {
if (ans.at(i) < S.at(j)) {
ans.at(i) = S.at(j) + C.at(j);
}
else if ((ans.at(i) - S.at(j)) % F.at(j) == 0) ans.at(i) += C.at(j);
else {
long long sum = (ans.at(i) - S.at(j)) / F.at(j) + 1;
ans.at(i) = S.at(j) + sum * F.at(j) + C.at(j);
}
}
}
}
for (long long i = 0; i < N; i++) {
cout << ans.at(i) << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
using ll=int64_t;
ll mod=1000000007;
ll f(ll x,vector<ll>&dp){
if(x==1){
dp.at(x)=1;
return dp.at(x);
}
else if(x==2){
dp.at(x)=2;
return dp.at(x);
}
if(dp.at(x)!=0){
return dp.at(x);
}
else{
dp.at(x)=(f(x-2,dp)%mod+f(x-1,dp)%mod)%mod;
return dp.at(x);
}
}
int main(){
ll n,m;cin>>n>>m;
vector<ll>dp(n+1,0);
if(m==0){
cout <<f(n,dp)<<endl;
return 0;
}
vector<ll>a(m);
cin>>a.at(0);
for(ll i=1;i<m;i++){
cin>>a.at(i);
if(a.at(i)-a.at(i-1)==1){
cout <<0<<endl;
return 0;
}
}
vector<ll>s(m+1,0);
if(m==1){
s.at(0)=a.at(0)-1;
s.at(1)=n-a.at(0)-1;
}
else{
for(ll i=0;i<m;i++){
if(i==0){
s.at(i)=a.at(i)-1;
}
else {
s.at(i)=a.at(i)-a.at(i-1)-2;
}
}
s.at(m)=n-a.at(m-1)-1;
}
ll ans=1;
for(ll i=0;i<m+1;i++){
if(s.at(i)==0)continue;
ans*=f(s.at(i),dp);
ans%=mod;
}
cout <<ans<<endl;
}
| 0
| 97,964,470
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
int tmp;
for (int i = 1; i <= n; i++) {
cin >> tmp;
a.at(tmp-1) = i;
}
for (int i = 0; i < n; i++) {
cout << a.at(i) << (i == n-1 ? "" : " ");
}
cout << endl;
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<string>
#include<cstdlib>
#include<map>
#include<iomanip>
#include<sstream>
#include<vector>
#include<stack>
#include<math.h>
#include<queue>
#include<complex>
using namespace std;
long long int num[2000000]={};
int main() {
const long long int mod = 1000000007,INF=50000000000000;
typedef pair<long long int,long long int>P;
map<long long int, long long int>mp;
long long int n,t[200001],a[200001],res[200001]={},fin=1;
cin>>n;
for(int i=1;i<=n;i++){
cin>>t[i];
}
for(int i=1;i<=n;i++){
cin>>a[i];
}
res[1]=t[1];
res[n]=a[n];
if(t[1]>a[1]||t[n]<a[n]){
cout<<0<<endl;
return 0;
}
for(int i=2;i<=n;i++){
if(t[i]>t[i-1]){
if(a[i]<t[i]){
cout<<"0"<<endl;
return 0;
}else{
res[i]=t[i];
}
}
}
for(int i=n-1;i>=1;i--){
if(a[i]>a[i+1]){
if(a[i]>t[i]){
cout<<"0"<<endl;
return 0;
}else{
res[i]=a[i];
}
}
}
for(int i=1;i<=n;i++){
if(res[i]==0){
fin*=min(a[i],t[i]);
fin%=mod;
}
}
cout<<fin%mod<<endl;
}
| 0
| 68,587,102
|
#include<iostream>
using namespace std;
int main(){
string n;
cin >> n;
if (n[0] == '7' || n[1] == '7' || n[2] == '7'){
cout << "Yes" << endl;
} else{
cout << "No" << endl;
}
return 0;
}
|
#include<stdio.h>
#include<stdlib.h>
int main()
{
char str[20],x[20],y[20];
int a,b,i=0,j=0;
int d,r;
double f;
fgets(str,sizeof(str),stdin);
for(;;){
if(str[i]==' '){
break;
}
x[i]=str[i];
i++;
}
for(;;){
if(str[i]=='\0'){
break;
}
y[j]=str[i];
i++;
j++;
}
a=atoi(x);
b=atoi(y);
if(a<1 || 1000000000<b){
printf("Error!!\n");
}else{
d=a/b;
r=a%b;
f=(double)a/(double)b;
printf("%d %d %f\n",d,r,f);
}
return 0;
}
| 0
| 10,618,218
|
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main() {
string s; cin >> s;
string ans="";
for(int i=0; i<s.size(); ++i) {
char c = s[i];
if(c=='B' && ans.size()>0) {
ans.pop_back();
} else if(c!='B'){
ans += c;
}
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
typedef long long ll;
#define rep(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define REP(i,num,n) for(int i=num, i##_len=(n); i<i##_len; ++i)
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
#define print(x) (cout << (x) << endl)
#define pb push_back
#define mp make_pair
#define sz(x) int(x.size())
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
#define fs first
#define sc second
template<typename T> vector<T> make_vec(size_t n, T a) { return vector<T>(n, a); }
template<typename... Ts> auto make_vec(size_t n, Ts... ts) { return vector<decltype(make_vec(ts...))>(n, make_vec(ts...)); }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &v) { for (auto &e : v) os << e << ' '; return os; }
#include <boost/rational.hpp>
#include <boost/multiprecision/cpp_int.hpp>
using boost::rational;
using boost::multiprecision::cpp_int;
const double PI = acos(-1);
const int INF = 1e9;
const ll LLINF = 1e16;
const ll MOD = 1e9+7;
template<class T> inline void add(T &a, T b){a = ((a+b) % MOD + MOD) % MOD;};
ll stringcount(string s, char c) {
return count(s.cbegin(), s.cend(), c);
}
template<typename T>
T rp(T a, T b) {
return (a + b - 1) / b;
}
template<typename T>
T digsum(T n) {
T res = 0;
while(n > 0) {
res += n%10;
n /= 10;
}
return res;
}
bool kai (string s) {
string t{s};
reverse(begin(t), end(t));
return s == t;
}
using pint = pair<int, int>;
using pll = pair<ll, ll>;
const int D = 55;
int main(void)
{
cout.tie(0);
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll n, x, m;
cin >> n >> x >> m;
auto next = make_vec(D + 1, m, -1LL);
auto sum = make_vec(D + 1, m, 0LL);
for(ll i = 0; i < m; ++i){
next[0][i] = i * i % m;
sum[0][i] = i;
}
rep(i, D){
rep(j, m){
next[i + 1][j] = next[i][next[i][j]];
sum[i + 1][j] = sum[i][j] + sum[i][next[i][j]];
}
}
ll ans = 0;
int cur = x;
for(int i = D; i >= 0; --i){
if(n & (1LL << i)){
ans += sum[i][cur];
cur = next[i][cur];
}
}
print(ans);
}
| 0
| 61,906,093
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i = (a); i < (b); ++i)
#define REP(i,n) FOR(i,0,n)
using ll = long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using mii = map<int, int>;
using msi = map<string, int>;
using pii = pair<int, int>;
struct Edge {
int to;
int weight;
Edge(int t, int w) : to(t), weight(w) { }
};
using Graph = vector<vector<Edge>>;
int main()
{
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<pair<int, int>> r(n), b(n);
REP(i, n) cin >> r[i].second >> r[i].first;
REP(i, n) cin >> b[i].first >> b[i].second;
sort(r.begin(), r.end(), greater<pair<int,int>>());
sort(b.begin(), b.end());
int ans = 0;
REP(i, n) {
REP(j, r.size()) {
if(r[j].second < b[i].first && r[j].first < b[i].second) {
ans++;
r.erase(r.begin() + j);
break;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<vector<int>> G(N, vector<int>(N, 1e9));
for (int a, b, c; cin >> a >> b >> c;) {
G.at(--a).at(--b) = c;
G.at(b).at(a) = c;
}
for (int i = 0; i < N; i++) {
G.at(i).at(i) = 0;
}
auto G2 = G;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
G.at(j).at(k) = min(G.at(j).at(k), G.at(j).at(i) + G.at(i).at(k));
}
}
}
int ans = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (i == j) continue;
if (G2.at(i).at(j) == 1e9) continue;
if (G2.at(i).at(j) != G.at(i).at(j)) ans++;
}
}
cout << ans / 2 << "\n";
}
| 0
| 23,762,083
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vl = vector<ll>;
using pll = pair<ll, ll>;
#define rep(i, n) for (ll i = 0, xxx_rep_end = (n); i < xxx_rep_end; ++i)
#define all(x) (x).begin(), (x).end()
template <class T1, class T2>
inline bool chmax(T1 &a, const T2 &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2>
inline bool chmin(T1 &a, const T2 &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
constexpr ll INF = 0x3f3f3f3f3f3f3f3fLL;
constexpr ll mod = 1000000007;
int main() {
ll N, P;
cin >> N >> P;
string S;
cin >> S;
if (P == 2 || P == 5) {
ll ans = 0;
for (int i = N - 1; i >= 0; --i) {
if ((S[i] - '0') % P == 0) {
ans += i + 1;
}
}
cout << ans << endl;
return 0;
}
map<ll, ll> mp;
++mp[0];
ll cur = 0;
ll fac = 1;
for (int i = N - 1; i >= 0; --i) {
cur = (cur + (S[i] - '0') * fac) % P;
fac *= 10;
fac %= P;
++mp[cur];
}
ll ans = 0;
for (auto e : mp) {
ans += e.second * (e.second - 1) / 2;
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
#define FOR(i,n,j) for(int i=(j);i<(n);++i)
#define ssort(n) sort((n).begin(),(n).end())
using ll=long long;
using ld=long double;
typedef pair<int,int> P;
#define INF 10101010
int main()
{
int N;
cin >> N;
vector<int> a(N);
rep(i,N)cin >> a[i];
int min=INF;
int cost;
ssort(a);
FOR(i,a[N-1]+1,a[0]){
cost=0;
rep(j,N){
cost+=(a[j]-i)*(a[j]-i);
}
if(cost<min){
min=cost;
}
}
cout << min << endl;
}
| 0
| 22,564,668
|
#include <iostream>
using namespace std;
int main(void){
int n;
cin>>n;
for (int i =0;i<=n/4;i++){
if ((n-i*4)%7==0){
cout<<"Yes";
exit(0);
}
}
cout<<"No";
exit(0);
}
|
#include<cstdio>
int main(){
int h,w;
char s[6], t[6]="snuke";
scanf("%d%d",&h,&w);
for(int i=0;i<h*w;i++){
scanf("%s",s);
int j;
for(j=0;j<5;j++){
if(s[j]!=t[j])break;
}
if(j==5){
printf("%c%d",'A'+(i%w),i/w+1);
return 0;
}
}
return 0;
}
| 0
| 20,756,346
|
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main(void){
string str, ope, p, str_rev;
int q, a, b;
cin >>str >>q;
for(int i=0; i<q; i++){
cin >>ope >>a >>b;
if(ope=="replace"){
cin >>p;
str.replace(a, p.size(), p);
}else if(ope=="reverse"){
str_rev=str.substr(a, b-a+1);
reverse(str_rev.begin(), str_rev.end());
str.replace(a, str_rev.size(), str_rev);
}else{
cout <<str.substr(a, b-a+1) <<endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
#define all(x) x.begin(),x.end()
#define rep(i,j,n) for (long long i = j; i < (long long)(n); i++)
#define _GLIBCXX_DEBUG
#define MOD 1000000007
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
signed main(){
ll hp,n; cin>>hp>>n;
vl a(n),b(n);
rep(i,0,n)cin>>a[i]>>b[i];
vvl dp(n+10,vl(hp+1,MOD));
dp[0][0]=0;
rep(i,0,n){
rep(j,0,hp+1){
chmin(dp[i+1][j],dp[i][j]);
chmin(dp[i+1][min(j+a[i],hp)],dp[i+1][j]+b[i]);
}
}
cout<<dp[n][hp]<<endl;
return 0;
}
| 0
| 65,013,152
|
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
long long a;
cin>>s>>a;
if(s.size()==1){
cout<<s[0]<<"\n";
return 0;
}
int cnt=0;
for(int i=0;i<s.size();i++){
if(s[i]!='1') break;
cnt++;
}
if(a<=cnt)cout<<"1\n";
else cout<<s[cnt]<<"\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double lb;
#define rep(i,j,n) for (ll i = j; i < (n); i++)
#define repr(i,j,n) for(ll i = j; i >= (n); i--)
#define each(i,mp) for(auto& i:mp)
#define all(x) (x).begin(),(x).end()
#define CLR(mat,f) memset(mat, f, sizeof(mat))
#define IN(a, b, x) (a<=x&&x<b)
#define out(ans) cout << ans << endl
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; }
typedef pair<ll,ll>P;
const ll mod=1e9+7;
const ll INF = 1LL<<60;
const ll m=1LL<<32;
int main(){
ll n;cin>>n;
string s;cin>>s;
ll left=0;
ll right=0;
string ans="";
rep(i,0,n){
if(s[i]=='('){
left++;
ans.insert(ans.end(),'(');
}else{
ans.insert(ans.end(),')');
if(left==0)ans.insert(ans.begin(),'(');
left=max((ll)0,left-1);
}
}
rep(i,0,left)ans.insert(ans.end(),')');
out(ans);
return 0;
}
| 0
| 55,598,302
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
static const int Infinity=2000000000;
int main(){
int n;cin>>n;
int P[n+1],DP[n][n];
rep(i,n){
scanf("%d %d",&P[i],&P[i+1]);
}
rep(i,n){
DP[i][i]=0;
}
for(int i=1;i<n;i++){
for(int j=0;j+i<n;j++){
int minc=Infinity;
for(int k=j;k<j+i;k++){
minc=min(minc,DP[j][k]+DP[k+1][j+i]+P[j]*P[k+1]*P[j+i+1]);
}
DP[j][j+i]=minc;
}
}
cout<<DP[0][n-1]<<endl;
}
|
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<ctime>
#include<cstdlib>
#include<sys/time.h>
#include<vector>
#include<cstring>
#include<cmath>
using namespace std;
typedef long long ll;
inline int ri()
{
register int x=0;register bool f=0;register char ch=getchar();
while(ch>'9'||ch<'0'){if(ch=='-')f=1;ch=getchar();}
while(ch<='9'&&ch>='0'){x=x*10+ch-'0';ch=getchar();};
return f?-x:x;
}
void wi(int x)
{
if(x<0) x=-x,putchar('-');
if(x>9) wi(x/10);
putchar('0'+x%10);
}
const int N=300005;
vector<int> v[N];
inline void gg()
{
puts("-1");
exit(0);
}
int main()
{
int n=ri(),a=ri(),b=ri(),j,i,d=n/a,now=n-a+1,tot=d;
for(i=1;i<=d;i++,now-=a)
for(j=1;j<=a;j++)
v[i].push_back(now+j-1);
if(n%a)
{
tot++;
for(j=1;j<=n%a;j++)
v[tot].push_back(j);
}
if(b<tot||a+b>n+1) gg();b-=tot;
for(i=tot;i>1;b-=v[i].size()-1,i--)
{
if(b<v[i].size()-1) break;
reverse(v[i].begin(),v[i].end());
}
if(b)
{
reverse(v[i].begin(),v[i].begin()+b+1);
}
for(i=1;i<=tot;i++)
for(j=0;j<v[i].size();j++)
printf("%d ",v[i][j]);
puts("");
return 0;
}
| 0
| 20,412,717
|
#include<bits/stdc++.h>
using namespace std;
int main(){
long N;cin>>N;
vector<long>A(N),B(N),C(N);
for(long i=0;i<N;i++)cin>>A[i];for(long i=0;i<N;i++)cin>>B[i];
for(long i=0;i<N;i++)C[i]=A[i]-B[i];
long c=0;
for(long i=0;i<N;i++){
if(C[i]<0){
c+=(-C[i]+1)/2;
C[i]=(-C[i])%2;
}
}
for(long i=0;i<N;i++)c-=C[i];
cout<<(c>=0?"Yes":"No");
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vl = vector<ll>;
using pll = pair<ll, ll>;
#define rep(i, n) for (ll i = 0, xxx_rep_end = (n); i < xxx_rep_end; ++i)
#define all(x) (x).begin(), (x).end()
template <class T1, class T2>
inline void chmax(T1 &a, const T2 &b) {
if (a < b) a = b;
}
template <class T1, class T2>
inline void chmin(T1 &a, const T2 &b) {
if (a > b) a = b;
}
constexpr ll INF = 0x3f3f3f3f3f3f3f3fLL;
constexpr ll mod = 1000000007;
int main() {
ll X, Y;
cin >> X >> Y;
if (Y % 2 == 1) {
cout << "No" << endl;
return 0;
}
Y /= 2;
if (Y < X || X * 2 < Y) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
}
| 0
| 24,420,136
|
#include <cstdio>
#include <vector>
using namespace std;
int main()
{
int X, A;
scanf("%d%d", &X, &A);
int ans = X < A ? 0 : 10;
printf("%d\n", ans);
return 0;
}
|
#include <stdio.h>
#include <stdlib.h>
#define MAX_N (100000L)
#define MAX_FACT (MAX_N)
#define NUM_MOD (1000000007L)
long fs[MAX_FACT + 1], finvs[MAX_FACT + 1], invs[MAX_FACT + 1];
void combination_init() {
fs[0] = fs[1] = 1;
finvs[0] = finvs[1] = 1;
invs[1] = 1;
for (long i = 2; i <= MAX_FACT; i++) {
fs[i] = fs[i - 1] * i % NUM_MOD;
invs[i] = NUM_MOD - invs[NUM_MOD % i] * (NUM_MOD / i) % NUM_MOD;
finvs[i] = finvs[i - 1] * invs[i] % NUM_MOD;
}
}
long combination(long n, long k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fs[n] * (finvs[k] * finvs[n - k] % NUM_MOD) % NUM_MOD;
}
long mod(long n, long k) { return n % k >= 0 ? n % k : n % k + k; }
int main(int argc, char *argv[]) {
long N, as[MAX_N + 1];
scanf("%ld", &N);
for (long i = 0; i < N + 1; i++) {
scanf("%ld", &as[i]);
}
long indices[MAX_N + 1], c;
for (long i = 0; i <= N; i++) {
indices[i] = -1;
}
for (long i = 0; i < N + 1; i++) {
const long a = as[i];
if (indices[a] < 0) {
indices[a] = i;
} else {
c = i - indices[a] - 1;
}
}
combination_init();
for (long k = 1; k <= N + 1; k++) {
long ans = 0;
if (k < 2) {
ans = mod(ans + 0, NUM_MOD);
} else {
ans = mod(ans + combination(N - 1, k - 2), NUM_MOD);
}
if (k < N + 1) {
ans = mod(
ans + 2 * combination(N - 1, k - 1) - combination(N - 1 - c, k - 1),
NUM_MOD);
} else {
ans = (ans + 0) % NUM_MOD;
}
if (k < N) {
ans = mod(ans + combination(N - 1, k), NUM_MOD);
} else {
ans = mod(ans + 0, NUM_MOD);
}
printf("%ld\n", ans);
}
return 0;
}
| 0
| 21,151,247
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,s,n) for(int i = s; i < (int)(n); i++)
int main() {
int n,m,k;
cin >> n >> m >> k;
rep(a,0,m+1){
rep(b,0,n+1){
if(a*n+b*(m-2*a) == k){
cout << "Yes" << endl;
return 0;
}
}
}
cout << "No" << endl;
}
|
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define USE_LLONG_AS_INT
#ifdef USE_LLONG_AS_INT
#define int long long
#define inf (1ll<<60)
#else
#define inf (1<<30)
#endif
#define rep(i,n) for(int i=0;i<(n);i++)
#define Rep(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,a,b) for(int i=(a);i<=(b);i++)
#define rev(i,n) for(int i=(n)-1;i>=0;i--)
#define vi vector<int>
#define vvi vector<vi>
#define vs vector<string>
#define pb push_back
#define eb emplace_back
#define pi pair<int,int>
#define vp vector<pair<int,int>>
#define mp make_pair
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
#define MEMSET(a) memset(a,0,sizeof(a))
#define Yes(f) cout<<(f?"Yes":"No")<<endl
#define yes(f) cout<<(f?"yes":"no")<<endl
#define YES(f) cout<<(f?"YES":"NO")<<endl
#define SORT(v) sort(all(v))
#define RSORT(v) sort(all(v), greater<int>())
using namespace std;
const int mod=1e9+7;
const string sp=" ";
void run();
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout<<fixed<<setprecision(12);
}
signed main(){
init();
run();
return 0;
}
void run(){
int h,w,m;
cin>>h>>w>>m;
set<pi> s;
rep(i,m){
int a,b;
cin>>a>>b;
s.insert({a,b});
}
map<int,int> mh,mw;
for(auto t:s)mh[t.fi]++,mw[t.se]++;
int ch=0,cw=0;
for(auto t:s)ch=max(ch,mh[t.fi]),cw=max(cw,mw[t.se]);
vi hh,ww;
for(auto t:mh)if(t.se==ch)hh.eb(t.fi);
for(auto t:mw)if(t.se==cw)ww.eb(t.fi);
int ans=ch+cw-1;
for(auto i:hh)for(auto j:ww){
if(s.find({i,j})==s.end()){
cout<<ans+1<<endl;
return;
}
}
cout<<ans<<endl;
}
| 0
| 26,804,487
|
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define rep(i, n) for(int i=0;i<n;++i)
#define rrep(i, n) for(int i=n;i>=0;--i)
const int inf=1e9+7;
const ll mod=1e9+7;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
double T, X;
cin>>T>>X;
cout<<setprecision(20)<<T/X<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const long long INF = 1LL << 60;
using Graph = vector<vector<int>>;
const int dx[4] = { 1, 0, -1, 0 };
const int dy[4] = { 0, 1, 0, -1 };
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
inline int gcd(int a, int b) { if (a%b == 0) { return b; } else { return gcd(b, a%b); } }
int main() {
int h, w;
cin >> h >> w;
vector<string> s(h);
for (int i = 0; i < h; i++) {
cin >> s[i];
}
for (int iy = 0; iy < h; iy++) {
for (int ix = 0; ix < w; ix++) {
if (s[iy][ix] == '.') {
continue;
}
bool okay = false;
for (int k = 0; k < 4; k++) {
int y = iy + dy[k];
int x = ix + dx[k];
if (0 <= x && 0 <= y && x < w && y < h && s[y][x] == '#')
{
okay = true;
break;
}
}
if (okay == false) {
cout << "No" << endl;
return 0;
}
}
}
cout << "Yes" << endl;
return 0;
}
| 0
| 96,504,855
|
#include <iostream>
int main() {
int m, f, r;
do{
std::cin >> m >> f >> r;
int sum = m + f;
if(m == -1 || f == -1){
if(m == -1 && f == -1 && r == -1){
}
else{
std::cout << 'F' << std::endl;
}
}
else if(sum >= 80){
std::cout << 'A' << std::endl;
}
else if(sum >= 65 && sum < 80){
std::cout << 'B' << std::endl;
}
else if(sum >= 50 && sum < 65){
std::cout << 'C' << std::endl;
}
else if(sum >= 30 && sum < 50){
if(r >= 50){
std::cout << 'C' << std::endl;
}
else {
std::cout << 'D' << std::endl;
}
}
else if(sum < 30){
std::cout << 'F' << std::endl;
}
} while(!(m == -1 && f == -1 && r == -1));
}
|
#include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9+7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) for(int i=0;i<(n);++i)
#define REPR(i,n) for(int i=n;i>=0;i--)
#define FOREACH(x,a) for(auto& (x) : (a) )
typedef long long ll;
using namespace std;
typedef pair<ll, ll> P;
typedef tuple<int,int,int> T;
typedef struct Edge {
ll to, cost;
} Edge;
vector<vector<Edge>> g;
bool ok = true;
ll dist[252525];
bool vi[252525];
void dfs(int x, ll d) {
if (vi[x]) return;
vi[x] = true;
dist[x] = d;
for (auto &&e: g[x]) dfs(e.to,d+e.cost);
return;
}
int main(int argc, char const *argv[]) {
int n,m;
cin >> n >> m;
vector<ll> l(m),r(m),d(m);
g.resize(n);
REP(i,m) {
cin >> l[i] >> r[i] >> d[i];
--l[i],--r[i];
g[l[i]].push_back({r[i],d[i]});
g[r[i]].push_back({l[i],-1ll*d[i]});
}
memset(dist,0,sizeof(dist));
memset(vi,0,sizeof(vi));
for (int i = 0; i < n; ++i) dfs(i, 0);
REP(i,m) {
if (dist[r[i]]-dist[l[i]] != d[i]) ok = false;
}
if (ok) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
| 0
| 44,811,563
|
#include <bits/stdc++.h>
using namespace std;
int main(){
#ifdef LOCAL
freopen("input", "r", stdin);
#endif
int n;
vector<int> a, b, order;
scanf("%d", &n);
for (int i = 0; i < n; i++){
int x;
scanf("%d", &x);
a.push_back(x);
}
for (int i = 0; i < n; i++){
int x;
scanf("%d", &x);
b.push_back(x);
}
for (int i = 0; i < n; i++){
order.push_back(i+1);
}
int ind = 1, orda = -1, ordb = -1;
do {
if (orda == -1){
for (int i = 0; i < n; i++){
if (order[i] != a[i])
break;
else if (i == n-1)
orda = ind;
}
}
if (ordb == -1){
for (int i = 0; i < n; i++){
if (order[i] != b[i])
break;
else if (i == n-1)
ordb = ind;
}
}
ind++;
} while (next_permutation(order.begin(), order.end()));
printf("%d\n", abs(orda - ordb));
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
template<typename T> T nxt() {T res; cin >> res; return res;}
#define tests() for (int _ = nxt<int>(); _ >= 0; _--)
#define nxt1(t,n) t (n); cin >> n
#define nxt2(t,n,m) t (n),(m); cin >> n >> m
#define nxt3(t,n,m,k) t (n),(m),(k); cin >> n >> m >> k
#define rep(i, A) for (int i = 0 ; i < A ; i++)
#define ll long long
typedef pair<int,int> pii;typedef pair<ll, ll> pll;typedef vector<int> vi;typedef vector<vi> vvi;typedef vector<ll> vl;typedef vector<vl> vvl;
#define dbg(vari) cerr<<#vari<<" = "<<(vari)<<endl;
template<typename T,typename TT> ostream& operator<<(ostream &s,pair<T,TT> t) {return s<<"("<<t.first<<","<<t.second<<")";}
template<typename T> ostream& operator<<(ostream &s,vector<T> t){for(T ti : t)s<<ti<<" ";return s; }
#define all(x) (x).begin(), (x).end()
#define last(vec) vec[vec.size()-1]
#define has(c,x) ((c).find(x) != (c).end())
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N = nxt<int>();
vector<array<int, 3>> abc(N);
rep(i, N) {
nxt3(int, a, b, c);
abc[i] = {a, b, c};
}
int dp[3][N + 1];
dp[0][0] = 0;
dp[1][0] = 0;
dp[2][0] = 0;
for (int i = 0; i < N; i++) {
dp[0][i + 1] = abc[i][0] + max(dp[1][i], dp[2][i]);
dp[1][i + 1] = abc[i][1] + max(dp[0][i], dp[2][i]);
dp[2][i + 1] = abc[i][2] + max(dp[0][i], dp[1][i]);
}
cout << max({dp[0][N], dp[1][N], dp[2][N]}) << endl;
return 0;
}
| 0
| 89,859,222
|
#include<iostream>
using namespace std;
int ans,n,s;
void search(int num,int sum,int st)
{
if(num==0)
{
if(sum==s)
ans++;
return;
}
for(int i=st;i<10;i++)
{
search(num-1,sum+i,i+1);
}
return;
}
int main()
{
for(;;)
{
cin >> n >> s;
if(n==0 && s==0)
break;
ans=0;
search(n,0,0);
cout << ans << endl;
}
}
|
#include <stdio.h>
#include <math.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <numeric>
#include <string>
#include <map>
using namespace std;
typedef long long int lli;
#define urept(soeji, start, n) for (int soeji = start; soeji < n; soeji++)
#define drept(soeji, start, n) for (int soeji = start; soeji > n; soeji--)
int main(void)
{
int N, M, X, Y;
cin >> N >> M >> X >> Y;
vector<int> x;
vector<int> y;
int tmp;
for (int i = 0; i < N; i++)
{
cin >> tmp;
x.push_back(tmp);
}
for (int i = 0; i < M; i++)
{
cin >> tmp;
y.push_back(tmp);
}
sort(x.begin(), x.end());
sort(y.begin(), y.end());
bool f = false;
for (int i = x[N-1]+1; i <= y[0]; i++)
{
if (X < i && i <= Y)
{
f = true;
break;
}
}
if(f==true){
cout << "No War" <<endl;
}else{
cout << "War" << endl;
}
return 0;
}
| 0
| 57,023,222
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define all(v) begin(v),end(v)
using ll = long long;
int main() {
int n;cin>>n;
vector<int> l(2*n);
rep(i,2*n)cin>>l[i];
sort(all(l));
int ans=0;
for(int i=0;i<2*n;i+=2){
ans+=min(l[i],l[i+1]);
}
cout<<ans<<endl;
}
|
#include"bits/stdc++.h"
using namespace std;
#define FastIO ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define nl "\n"
#define sp " "
#define int long long
#define PI 3.141592653589793
#define scanstr(s) cin>>ws; getline(cin,s);
void solve()
{
int grid[3][3],x,y,z;
for(int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
{
cin>>grid[i][j];
}
}
int n;
cin>>n;
int a[n];
for(int i=0;i<n;i++) cin>>a[i];
sort(a,a+n);
for(int i=0;i<3;i++)
{
x=grid[i][0], y= grid[i][1], z=grid[i][2];
if(binary_search(a,a+n,x)&&binary_search(a,a+n,y)&&binary_search(a,a+n,z))
{
cout<<"Yes\n";
return ;
}
}
for(int i=0;i<3;i++)
{
x=grid[0][i], y= grid[1][i], z=grid[2][i];
if(binary_search(a,a+n,x)&&binary_search(a,a+n,y)&&binary_search(a,a+n,z))
{
cout<<"Yes\n";
return ;
}
}
x=grid[0][0], y=grid[1][1], z=grid[2][2];
if(binary_search(a,a+n,x)&&binary_search(a,a+n,y)&&binary_search(a,a+n,z))
{
cout<<"Yes\n";
return ;
}
x=grid[0][2], y=grid[1][1], z=grid[2][0];
if(binary_search(a,a+n,x)&&binary_search(a,a+n,y)&&binary_search(a,a+n,z))
{
cout<<"Yes\n";
return ;
}
cout<<"No\n";
return ;
}
int32_t main()
{
FastIO;
solve();
return 0;
}
| 0
| 54,648,075
|
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int n;
cin >> n;
int ans = 0;
int maxv = 0;
for (int i = 0; i < n; i++)
{
int in;
cin >> in;
if(maxv<=in)
{
ans++;
maxv = in;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
int alpha[26] = {};
string s;
cin >> s;
for ( int i = 0; i < 4; i++ ) {
alpha[ s[i] - 'A' ] ++;
}
sort(alpha, alpha + 26, greater<int>());
if ( alpha[0] == 2 && alpha[1] == 2 ) {
cout << "Yes\n";
} else {
cout << "No\n";
}
return (0);
}
| 0
| 6,818,812
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s1, s2 ;
cin >> s1 >> s2 ;
int flag = 0;
for( int i=0 ; i < s1.size(); i++ )
{
if( s1[i] != s2[i] )flag=1;
}
if(flag == 1)cout<<"No\n";
else cout<<"Yes\n";
return 0;
}
|
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
vector<ll>a(5005);
vector<ll>b(5005);
vector<ll>track;
bool vis[5005];
void dfs(int u, long long total_cycle)
{
if(vis[u])
return ;
vis[u]=true;
total_cycle+=b[u];
track.push_back(total_cycle);
dfs(a[u],total_cycle);
}
void solve()
{
int n,k;
cin>>n>>k;
for(int i=0; i<n; i++)
{
cin>>a[i];
a[i]--;
}
for(int i=0; i<n; i++)
cin>>b[i];
ll ans=-2e18;
for(int i=0; i<n; i++)
{
memset(vis,false,sizeof(vis));
dfs(i,0);
ll m = (ll) track.size();
if(track.back()>0 && k>=m)
{
ll cycles= k/m;
ll left= k%m;
ll maxi=-2e18;
for(int x=0; x<(int)track.size(); x++)
maxi=max(maxi,track[x]);
ans=max(ans,(cycles-1)*(track.back())+maxi);
maxi=-2e18;
for(int x=0; x<left; x++)
maxi=max(maxi,track[x]);
ans=max(ans,(cycles*track.back()) + maxi);
}
else
{
for(int j=0; j<(min((int)track.size(),k)); j++)
{
ans=max(ans,track[j]);
}
}
track.clear();
}
cout<<ans;
return;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
| 0
| 86,984,091
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define rep(i, n) for(int i = 0; i < n; i++)
#define REP(i, a, b) for(int i = a; i < b; i++)
#define all(x) x.begin(), x.end()
#define fi first
#define se second
#define pb push_back
#define debug(x) cerr <<__LINE__<< ": " << #x << " = " << x << endl
#define debug_vec(v) cerr<<__LINE__<<": "<<#v<<" = ";rep(i,v.size())cerr<<" "<<v[i];cerr<<endl
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int INF = (1<<30) - 1;
const ll LINF = (1LL<<60) - 1;
void solve() {
string s;
cin >> s;
rep(i, 3) {
if (s[i] == '7') {
cout << "Yes" << endl;
return;
}
}
cout << "No" << endl;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
|
#include <bits/stdc++.h>
#ifdef LOCAL
#include "../cxx-prettyprint/prettyprint.hpp"
#endif
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
#define REP(i, n) for (int (i) = 0 ; (i) < (int)(n) ; ++(i))
#define REPN(i, m, n) for (int (i) = m ; (i) < (int)(n) ; ++(i))
#define REP_REV(i, n) for (int (i) = (int)(n) - 1 ; (i) >= 0 ; --(i))
#define REPN_REV(i, m, n) for (int (i) = (int)(n) - 1 ; (i) >= m ; --(i))
#define ALL(x) x.begin(), x.end()
#define INF ((1 << 29)-1)
#define MOD (1000000007)
#define print2D(h, w, arr) REP(i, h) { REP(j, w) cout << arr[i][j] << " "; cout << endl; }
#define print_line(vec, n) {for(int i=0;i<(n-1);i++) cout << (vec)[i] << " "; cout << (vec)[(n)-1] << endl;}
template<class T> void print(const T& x){cout << x << endl;}
template<class T, class... A> void print(const T& first, const A&... rest) { cout << first << " "; print(rest...); }
struct PreMain {PreMain(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(20);}} premain;
int main() {
#ifdef LOCAL
ifstream in("../arg.txt"); cin.rdbuf(in.rdbuf());
#endif
string A, B, C;
cin >> A >> B >> C;
if (A.back() == B[0] && B.back() == C[0]){
print("YES");
} else{
print("NO");
}
return 0;
}
| 0
| 13,186,654
|
#include <iostream>
using namespace std;
int main(){
int a[3];
int i,t;
for (i = 0; i < 3; i++) {
cin>>a[i];
}
if (a[0]>a[1]){
t=a[0];
a[0]=a[1];
a[1]=t;
}
if (a[1]>a[2]){
t=a[1];
a[1]=a[2];
a[2]=t;
}
if (a[0]>a[1]){
t=a[0];
a[0]=a[1];
a[1]=t;
}
cout<<a[0]<<" "<<a[1]<<" "<<a[2]<<endl;
return 0;
}
|
#include <map>
#include <iostream>
using namespace std;
int main(int argc, char** argv) {
int h, w, n; cin >> h >> w >> n;
map<pair<int, int>, int> m;
while (n--) {
int x, y; cin >> x >> y; x--; y--;
for (int i = max(0, x-2); i <= min(x, h-3); i++)
for (int j = max(0, y-2); j <= min(y, w-3); j++)
m[make_pair(i, j)]++;
}
int ans[10] = {};
for (auto e : m) {
ans[e.second]++;
}
long long ans0 = (long long)(h-2) * (w-2);
for (int i = 1; i < 10; i++) ans0 -= ans[i];
cout << ans0 << endl;
for (int i = 1; i < 10; i++) cout << ans[i] << endl;
}
| 0
| 64,308,548
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n,k; cin >> n >> k;
vector<int> a(n);
int pos_1=0;
rep(i, n) {
cin >> a[i];
if (a[i] == 1) pos_1=i;
}
int ans = 0;
ans = (n+k-3)/(k-1);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,s,n) for (int i = (int)s; i < (int)n; i++)
#define ll long long
#define ld long double
#define pb push_back
#define eb emplace_back
#define All(x) x.begin(), x.end()
#define Range(x, i, j) x.begin() + i, x.begin() + j
#define lbidx(x, y) lower_bound(x.begin(), x.end(), y) - x.begin()
#define ubidx(x, y) upper_bound(x.begin(), x.end(), y) - x.begin()
#define llbidx(x, y, z) lower_bound(x.begin(), x.end(), z) - lower_bound(x.begin(), x.end(), y)
#define deg2rad(deg) ((((double)deg)/((double)360)*2*M_PI))
#define rad2deg(rad) ((((double)rad)/(double)2/M_PI)*(double)360)
#define Find(set, element) set.find(element) != set.end()
#define Decimal(x) printf("%.10f\n", x)
#define PrintVec(x) for (auto elementPrintVec: x) { cout << elementPrintVec << " "; } cout << "\n";
#define debug(x) cerr << #x << ": " << (x) << "\n";
#define endl "\n"
#define Case(x) printf("Case #%d: ", x);
typedef pair<int, int> PI;
typedef pair<ll, ll> PLL;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<vector<vector<int>>> vvvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<vector<vector<int>>> vvvl;
typedef vector<PI> vpi;
typedef vector<vector<PI>> vvpi;
typedef vector<vector<vector<PI>>> vvvpi;
typedef vector<PLL> vpl;
typedef vector<vector<PLL>> vvpl;
typedef vector<vector<vector<PLL>>> vvvpl;
int POWINT(int x, int n) {
int ret = 1;
while (n > 0) {
if (n & 1) ret *= x;
x *= x;
n >>= 1;
}
return ret;
};
ll POWLL(ll x, int n) {
ll ret = 1;
while (n > 0) {
if (n & 1) ret *= x;
x *= x;
n >>= 1;
}
return ret;
};
template<class T>
inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
};
template<class T>
inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
};
void print() {
cout << endl;
};
template <class T>
void print(vector<T> &vec) {
for (auto& a : vec) {
cout << a;
if (&a != &vec.back()) cout << " ";
}
cout << endl;
};
template <class T>
void print(vector<T> &vec, ll k){
ll n = vec.size();
k = min(k, n);
rep(i, 0, k-1) cout << vec[i] << " ";
cout << vec[k-1] << endl;
};
template <class T>
void print(vector<vector<T>> &df) {
for (auto& vec : df) {
print(vec);
}
};
template<class T, class U>
void print(pair<T,U> &p){
cout << p.first << " " << p.second << "\n";
};
const ll LINF = 1e18;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, M; cin >> N >> M;
vl a(N), b(N), c(M), d(M);
rep(i, 0, N) {
cin >> a[i] >> b[i];
}
rep(i, 0, M) {
cin >> c[i] >> d[i];
}
vpl ans(N, make_pair(LINF, 0ll));
rep(i, 0, N) {
ll ai = a[i];
ll bi = b[i];
rep(j, 0, M) {
ll cj = c[j];
ll dj = d[j];
ll dist = abs(ai-cj)+abs(bi-dj);
if (dist < ans[i].first) {
ans[i].first = dist;
ans[i].second = j+1;
}
}
}
for (auto pi: ans) {
cout << pi.second << endl;
}
return 0;
};
| 0
| 75,799,553
|
#include <bits/stdc++.h>
using namespace std;
void nil()
{
int n;
cin>>n;
string s, c="";
cin>>s;
c=c+s[0];
for(int i=1;i<n;i++)
{
if(c.back()!=s[i])
{
c=c+s[i];
}
}
cout<<c.size();
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input1.txt","r",stdin);
freopen("output1.txt","w",stdout);
#endif
nil();
}
|
#include <bits/stdc++.h>
#define pb push_back
#define MP make_pair
#define ALL(r) (r).begin(),(r).end()
typedef long long int ll;
#define FOR(i,m,n) for(ll i=(ll)(m) ; i < (ll) (n) ; ++i )
#define FORN(i,m,n) for(ll i=(ll)(m-1) ; i >= (ll) (n) ; --i )
#define RUN_FAST ios::sync_with_stdio(false);
using namespace std;
void solve()
{
ll a,b,c,d,m,n,p,q,r,x,y,z,aa,bb,cc,dd;
ll i,j,k,l;
ll cnt=0,cnt1=0,cnt2=0,cnt3=0,sum=0,mx=LLONG_MIN,mn=LLONG_MAX;
ll flag=0,flag2=0;
vector <ll> vec1,vec2,vec3;
string s1,s2,s3;
cin >>n >> s1;
if(n%2)
cout << "No\n";
else
{
x=n/2;
FOR(i,0,x)
{
s2.pb(s1[i]);
}
FOR(i,x,n)
{
s3.pb(s1[i]);
}
if(s3==s2)
cout << "Yes\n";
else
cout << "No\n";
}
}
int main()
{
RUN_FAST
ll t=1;
while(t--)
{
solve();
}
return 0;
}
| 0
| 59,585,717
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,n) for(int i=0;i<n;++i)
#define SORT(name) sort(name.begin(), name.end())
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))
#if 1
# define DBG(fmt, ...) printf(fmt, __VA_ARGS__)
#else
# define DBG(fmt, ...)
#endif
#define MOD 1000000007
#define INF 1000000000
#define MAX_N 100010
ll X, Y;
#ifdef CONFIRM
int dp[100][100][2] = {};
int dfs(int x, int y, int cur) {
if(dp[x][y][cur] != -1) { return dp[x][y][cur]; }
if(x <= 2 && y <= 2) { return dp[x][y][cur]; }
int next = (cur == 0) ? 1 : 0;
for(int i = 1; i * 2 <= x; ++i) {
int ret = dfs(x - i * 2, y + i, next);
if(ret == cur) {
dp[x][y][cur] = ret;
return ret;
}
}
for(int i = 1; i * 2 <= y; ++i) {
int ret = dfs(x + i, y - i * 2, next);
if(ret == cur) {
dp[x][y][cur] = ret;
return ret;
}
}
dp[x][y][cur] = next;
return next;
}
#endif
int main()
{
cin >> X >> Y;
#ifdef CONFIRM
MINUS(dp);
dp[0][0][0] = 1;
dp[0][0][1] = 0;
dp[0][1][0] = 1;
dp[0][1][1] = 0;
dp[0][2][0] = 0;
dp[0][2][1] = 1;
dp[1][0][0] = 1;
dp[1][0][1] = 0;
dp[1][1][0] = 1;
dp[1][1][1] = 0;
dp[1][2][0] = 1;
dp[1][2][1] = 0;
dp[2][0][0] = 0;
dp[2][0][1] = 1;
dp[2][1][0] = 1;
dp[2][1][1] = 0;
dp[2][2][0] = 1;
dp[2][2][1] = 0;
for(int i = 0; i < 100; ++i) {
for(int j = 0; j < 100; ++j) {
if(dfs(i, j, 0) == 1 && abs(i-j) >= 2) {
printf("predict is not correct %d %d\n", i, j);
return 0;
}
}
}
#endif
if(abs(X-Y) < 2) { printf("Brown\n"); }
else{ printf("Alice\n"); }
return 0;
}
|
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
constexpr char ln = '\n';
constexpr long long MOD = 1000000007LL;
constexpr long long INF = 1001001001LL;
constexpr long long LINF = 1001001001001001001;
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define rept(i, j, n) for(int i=(j); i<(n); i++)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main(){
int n, k; cin >> n >> k;
vector<int> A(n); rep(i, n) cin >> A[i];
rep(i, min(1000, k)){
vector<int> plus(n), minus(n);
rep(j, n){
int s = max(0, j-A[j]), t = min(n-1, j+A[j]);
plus[s]++; minus[t]++;
}
int cnt = 0;
rep(j, n){
cnt += plus[j];
A[j] = cnt;
cnt -= minus[j];
}
}
rep(i, n)cout << A[i] << " ";
cout << ln;
}
| 0
| 74,715,463
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ff first
#define ss second
#define pb push_back
#define vll vector<ll>
#define mll map<ll,ll>
#define MOD 1000000007
#define pll pair<ll,ll>
constexpr ll INF = 1999999999999999997;
#define fastio ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define MAXN 10000005
int spf[MAXN];
void seive()
{
for(int i=1;i<MAXN;i++)
spf[i]=i;
for(int i=2;i<MAXN;i+=2)
spf[i]=2;
for(int i=3;i*i<MAXN;i++)
{ if(spf[i]==i)
{
for(int j=i*i;j<MAXN;j+=i)
{
if(spf[j]==j)
spf[j]=i;
}
}
}
}
ll prod(ll x)
{ ll res=1;
map<ll,ll>m;
while(x!=1)
{
m[spf[x]]++;
x=x/spf[x];
}
for(auto j:m)
{
res=res*(j.ss+1);
}
return res;
}
int main() {
fastio;
seive();
ll n;
cin>>n;
ll ans=0;
for(ll i=1;i<=n;i++)
{
ans=ans+prod(i)*i;
}
cout<<ans<<endl;
}
|
#include <iostream>
#include <string>
using namespace std;
int wa(string inp);
int main(void)
{
string inp1;
getline(cin, inp1);
while(inp1[0] - '0'){
cout << wa(inp1) << endl;
getline(cin, inp1);
}
return 0;
}
int wa(string inp)
{
int len = inp.size();
int wa = 0;
for(int i = 0; i < len; i++){
wa += (inp[i] - '0');
}
return wa;
}
| 0
| 66,633,142
|
#include <bits/stdc++.h>
#define NREP() for(ll i = 0; i < n; i++)
#define MREP() for(ll j = 0; j < m; j++)
#define REP(i, x, y) for(ll i = x; i < y; i++)
#define ALL(x) (x).begin(), (x).end()
#define MSG(x) cout << x << endl;
#define END(x) cout << x << endl; exit(0);
#define YN(x) x ? cout << "YES" << endl : cout << "NO" << endl;
#define Yn(x) x ? cout << "Yes" << endl : cout << "No" << endl;
#define yn(x) x ? cout << "yes" << endl : cout << "no" << endl;
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<string> vs;
typedef vector<vector<string>> vvs;
const static ll MOD = 1e9 + 7;
ll n, cnt, ans, tmp, sum, minimum, maximum, a, b, c, d, k, m, h, w, q, x, y;
string s, t;
int calc(ll n) {
ll c = 0;
for (k = 1; k <= n; k++) {
if (n % k == 0) c++;
}
return c;
}
int main() {
cin >> n >> x;
MSG(n - x + 1)
}
|
#include<bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define PI acos(-1)
#define pcnt __builtin_popcountll
#define rng(a) a.begin(), a.end()
#define sz(x) (int)(x).size()
#define v(T) vector<T>
#define vv(T) v(v(T))
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
template<typename T>inline istream& operator>>(istream&i,v(T)&v)
{rep(j,sz(v))i>>v[j];return i;}
template<typename T1,typename T2>inline istream& operator>>(istream&i,pair<T1,T2>&v)
{return i>>v.fi>>v.se;}
template<class T> inline bool chmax(T& a, T b) {if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) {if (a > b) { a = b; return true; } return false; }
ll INF = 1001001001;
ll LINF = 1001001001001001001ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
set<int> s;
rep(i, 3) {
int a;
cin>>a;
s.insert(a);
}
cout<<s.size()<<endl;
}
| 0
| 30,502,806
|
#include <iostream>
#include <complex>
#include <sstream>
#include <string>
#include <algorithm>
#include <deque>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <vector>
#include <set>
#include <limits>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <ctime>
using namespace std;
#define REP(i, j) for(int i = 0; i < (int)(j); ++i)
#define FOR(i, j, k) for(int i = (int)(j); i < (int)(k); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define REVERSE(v) reverse((v).begin(), (v).end())
typedef complex<double> P;
const int MAX_V = 105;
const long INF = 1e18;
int V, E;
void disp(int f, long c[MAX_V][MAX_V]){
if(!f) cout <<"NEGATIVE CYCLE" <<endl;
else{
REP(i, V){
REP(j, V){
if(c[i][j] == INF) cout <<"INF";
else cout <<c[i][j];
if(j != V - 1) cout <<" ";
}
cout <<endl;
}
}
}
bool warshall_floyd(long c[MAX_V][MAX_V]){
REP(k, V)
REP(i, V)
REP(j, V)
if(c[i][k] != INF && c[k][j] != INF) c[i][j] = min(c[i][j], c[i][k] + c[k][j]);
REP(i, V) if(c[i][i] < 0) return false;
return true;
}
int main() {
cin >>V >>E;
long c[MAX_V][MAX_V];
REP(i, V) REP(j, V) c[i][j] = INF;
REP(i, V) c[i][i] = 0;
REP(i, E){
int f, t, cost; cin >>f >>t >>cost;
c[f][t] = cost;
}
bool f = warshall_floyd(c);
disp(f, c);
return 0;
}
|
#include <stdio.h>
int main(void)
{
int point = 0;
int i ;
int m,f,r;
char hyouka;
i = 0;
while(1){
scanf("%d %d %d\n", &m, &f, &r);
if(m == -1 && f == -1){
if(f == -1 && r == -1){
break;
}
}
i++;
hyouka = 'Z';
point = m + f;
if(m == -1 || f == -1){
hyouka = 'F';
}else {
if(80 <= point && point <= 100){
hyouka = 'A';
}
else if(65 <= point && point < 80){
hyouka = 'B';
}
else if(50 <= point && point < 65){
hyouka = 'C';
}
else if(30 <= point && point < 50){
if(50 <= r){
hyouka = 'C';
}
else if(r < 50){
hyouka = 'D';
}else {
}
}
else if(0 <= point && point < 30){
hyouka = 'F';
}
else{
}
}
printf("%c\n",hyouka);
}
return 0;
}
| 0
| 24,318,574
|
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <regex>
#define rep(i,n) for(int i = 0; i < n; i++)
#define reps(i,j,n) for(int i = j; i < n; i++)
#define rrep(i,j,n) for(int i = j-1; i >= n; i--)
#define prec(n) fixed << setprecision(n)
#define print_array(v) rep(__k, v.size()) { cout << v[__k]; if(__k != v.size()-1) cout << " "; else cout << endl; }
#define YesorNo(a) printf(a?"Yes\n":"No\n")
#define fi first
#define se second
using namespace std;
int inf = 2147483647;
int64_t inf64 = 9223372036854775807;
int MOD = 1e+7;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
deque<int> res;
rep(i,n) {
int num;
cin >> num;
int a = abs(n-i);
if(a % 2 == 0) res.push_back(num);
if(a % 2 == 1) res.push_front(num);
}
for(int x : res) {
cout << x << " ";
res.pop_front();
}
cout << endl;
return 0;
}
|
#include<iostream>
#include<string>
#include<stack>
using namespace std;
int main(){
bool flg=false,bflg;
int i;
while(!flg){
string s;
stack<char> box;
char ch;
getline(cin,s);
if(s==".")flg=true;
else {
bflg=true;
box.push('s');
for(i=0;i<s.size();i++){
ch=s.at(i);
if(ch=='('||ch=='[')box.push(ch);
else if(ch==')'){
if(box.top()=='(')box.pop();
else{
bflg=false;
break;
}
}
else if(ch==']'){
if(box.top()=='[')box.pop();
else{
bflg=false;
break;
}
}
else if(ch=='.'){
break;
}
}
if(bflg==true && box.top()=='s')cout<<"yes"<<endl;
else cout<<"no"<<endl;
}
}
}
| 0
| 9,689,947
|
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i=0; i<(n); i++)
#define all(n) begin(n),end(n)
using ll = long long;
using P = pair<int,int>;
int main() {
string s;
cin >> s;
set<char> st;
rep(i,s.size()) {
if(st.count(s[i])==1) {cout << "no" << endl; return 0;}
st.insert(s[i]);
}
cout << "yes" << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define rep(i,a,b) for(int i=a;i<b;++i)
#define Rep(i,a) rep(i,0,a)
int date(int y,int m, int d){
int ans=0;
rep(i,y,1000){
rep(j,m,10+1){
if( i % 3 == 0)
rep(k,d,20+1){
ans++;
}
else if( j % 2 != 0)
rep(k,d,20+1){
ans++;
}
else
rep(k,d,19+1){
ans++;
}
d = 1;
}
m = 1;
}
return ans;
}
int main(){
int n;
cin >> n;
rep(i,0,n){
int y,m,d;
cin >> y >> m >> d;
cout << date(y,m,d) << endl;
}
return 0;
}
| 0
| 54,698,570
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) rep2(i, 0, n)
#define rep2(i, m, n) for (ll i = m; i < (n); i++)
using ll = long long;
using pii = pair<int, int>;
using Vi = vector<int>;
int main() {
int a,b,x;
cin >>a>>b>>x;
if(a<=x&&x<=a+b){
cout << "YES" << endl;
}
else{
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100500;
int n,q,a[N],ca[N],p[N],freq[N];
bool vis[N],comp[N];
int par(int u) {
return p[u] == u ? u : p[u] = par(p[u]);
}
void join(int u , int v) {
p[par(u)] = par(v);
}
bool sameset(int u , int v) {
return par(u) == par(v);
}
int main() {
for (int i = 0 ; i < N ; i++) p[i] = i;
scanf("%d%d" , &n , &q);
for (int i = 1 ; i <= n ; i++) {
scanf("%d" , &a[i]);
}
while (q--) {
int u,v; scanf("%d%d" , &u , &v);
join(u , v);
}
vector <int> keep[N],keep1[N];
for (int i = 1 ; i <= n ; i++) {
keep[par(i)].push_back(a[i]);
keep1[par(i)].push_back(i);
}
int sol = 0;
for (int i = 1 ; i <= n ; i++) {
if (!vis[par(i)]) {
vis[par(i)] = true;
for (int j = 0 ; j < keep[par(i)].size() ; j++) {
freq[keep[par(i)][j]]++;
freq[keep1[par(i)][j]]++;
}
for (int j = 0 ; j < keep[par(i)].size() ; j++) {
if (freq[keep[par(i)][j]] == 2 && !comp[keep[par(i)][j]]) {
sol++;
comp[keep[par(i)][j]] = true;
}
if (freq[keep1[par(i)][j]] == 2 && !comp[keep1[par(i)][j]]) {
sol++;
comp[keep1[par(i)][j]] = true;
}
freq[keep[par(i)][j]] = 0, freq[keep1[par(i)][j]] = 0;
}
}
}
printf("%d\n" , sol);
}
| 0
| 93,856,776
|
#include<bits/stdc++.h>
using namespace std;
int n,m;
int main(){
scanf("%d%d",&n,&m);
if (m==1){
puts("0");
return 0;
}
printf("%d\n",n-m);
}
|
#include "bits/stdc++.h"
using namespace std;
#define ll long long
#define rep(i,n) for(int i = 0;i < (n); i++)
int main() {
ll n, p;
ll ans = 0;
cin >> n >> p;
string s;
cin >> s;
if (p == 2 || p == 5) {
rep(i, n) {
if ((s[i] - '0') % p == 0)ans += i + 1;
}
cout << ans << endl;
return 0;
}
else {
vector<ll> sum(n + 1);
vector<ll> c(p);
ll buf = 1;
for (int i = n - 1; i >= 0; i--) {
sum[i] = (sum[i + 1] + (s[i] - '0') * buf % p) % p;
buf *= 10;
buf %= p;
}
for (int i = n; i >= 0; i--) {
ans += c[sum[i]];
c[sum[i]]++;
}
}
cout << ans << endl;
return 0;
}
| 0
| 98,261,067
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
using namespace std;
using ll = long long;
#define rep(i, j, n) for(int i = (j); i < (n); ++i)
#define rrep(i, j, n) for(int i = (n) - 1; (j) <= i; --i)
constexpr ll MOD = 1000000007;
constexpr ll INF = 1LL << 60;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
string s; cin >> s;
reverse(s.begin(), s.end());
string t[4] = { "maerd", "remaerd", "esare", "resare" };
while (s.size()) {
int sz = s.size();
rep(i, 0, 4) {
if (s.size() < t[i].size()) continue;
bool match = true;
rep(j, 0, t[i].size()) if (s[j] != t[i][j]) match = false;
if (match) s.erase(0, t[i].size());
}
if (s.size() == sz) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin>>n;
map<string,int> w_map;
bool flg=true;
string w_old="dummy";
for(int i=0;i<n;i++){
string w;
cin>>w;
if(w_map.count(w))
flg=false;
else
w_map[w]=1;
if(i>0){
if(w.front()!=w_old.back())
flg=false;
}
w_old=w;
}
if(flg)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
}
| 0
| 90,332,785
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
constexpr int Inf = 2000000001;
constexpr ll INF= 9 * 1e18;
constexpr ll MOD = 1000000007;
const double PI = 3.1415926535897;
typedef pair<int,int> P;
int main() {
int M,K;
cin >> M >> K;
if(M == 0) {
if(K == 0) {
cout << 0 << " " << 0 << endl;
}
else {
cout << -1 << endl;
}
}
else if(M == 1) {
if(K == 0) {
cout << "0 1 1 0" << endl;
}
else {
cout << -1 << endl;
}
}
else {
M = pow(2,M) - 1;
if(M < K) {
cout << -1 << endl;
}
else {
for(int i = M;i >= 0;i--) {
if(i != K) {
cout << i << " ";
}
}
cout << K << " ";
for(int i = 0;i <= M;i++) {
if(i != K) {
cout << i << " ";
}
}
cout << K << endl;
}
}
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
vector<int> a(n + 1);
for(int i = 1;i <= n;i++){
cin >> a[i];
}
for(int i = 1;i <= n;i++){
cout << "node " << i << ": key = " << a[i] << ", ";
if(i / 2 >= 1)cout << "parent key = " <<a[i / 2] << ", ";
if(2 * i <= n)cout << "left key = " << a[2 * i] << ", ";
if(2 * i + 1<= n)cout << "right key = " << a[2 * i + 1] << ", ";
cout << endl;
}
}
| 0
| 46,128,797
|
#include <bits/stdc++.h>
using namespace std;
bool b(char ch){
string k="yuiophjklnm";
for(int i=0;i<(int)k.size();i++)
if(k[i]==ch) return 1;
return 0;
}
int main(){
string s;
while(cin>>s && s!="#"){
int ans=0;
bool f=b(s[0]);
for(int i=1;i<(int)s.size();i++){
if(f!=b(s[i])){ans++;f=!f;}
}
cout<<ans<<endl;
}
return 0;
}
|
#include <iostream>
#include <iomanip>
#include <cmath>
#include <string>
#include <vector>
#include <cstdlib>
#include <map>
#include <queue>
#include <deque>
#include <algorithm>
#include <stack>
#include <functional>
#include <sstream>
#define rep(i,j,n) for(i=j;i<(n);i++)
#define rrep(i,j,n) for(i=j;i>(n);i--)
typedef long long int lli;
#define N 1000000007
#define M 998244353
using namespace std;
int main(){
lli n,t=0,a=0,b=0,c=0;
string s;
lli i,j;
cin>>n;
rep(i,0,n){
cin>>s;
rep(j,0,s.size()-2){
if((s[j]=='A')&&(s[j+1]=='B')){
t++;
}
}
if(s[0]=='B'){
if(s[s.size()-1]=='A'){
c++;
}
else{
b++;
}
}
else{
if(s[s.size()-1]=='A'){
a++;
}
}
}
if(c>0){
if(c>1){
t+=c-1;
}
if(a>0){
a--;
t++;
}
if(b>0){
b--;
t++;
}
}
t+=min(a,b);
cout<<t<<endl;
}
| 0
| 39,454,069
|
# include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define pii pair<int,int>
typedef long long ll;
const int mod=1e9+7;
unordered_map<char,int>byk;
ll mul(ll a,ll b){
return ((a%mod)*(b%mod))%mod;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
string s;
cin>>n;
cin>>s;
for(auto isi:s){
byk[isi]++;
}
ll ans=1;
for(int i='a';i<='z';i++){
ans=mul(ans,byk[i]+1);
}
cout<<(ans-1 +mod)%mod<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
int main(){
long long N;
ll money=1000;
ll result;
ll l=0;
long long k=0;
cin>>N;
vector<long long> vec(N);
for(long long i=0;i<N;i++){
cin>>vec.at(i);
}
for(long long i=0;i<N-1;i++){
if(vec.at(i)<vec.at(1+i)){
k+=money/vec.at(i);
l=money/vec.at(i);
money-=l*vec.at(i);
}
if(vec.at(i)>vec.at(1+i)){
money=money+k*vec.at(i);
result=money;
k=0;
}
}
money+=vec.at(N-1)*k;
if(money<result){
cout<<result<<endl;
}
else{
cout<<money<<endl;
}
}
| 0
| 656,965
|
#include<bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("-ffloat-store")
#define int long long
#define rep(i,begin,end) for(__typeof(end)i=(begin)-((begin)>(end));i!=(end)-((begin)>(end));i+=1-2*((begin)>(end)))
#define F first
#define S second
#define sz(x) ((int)x.size())
#define pb push_back
#define pf push_front
#define eb emplace_back
#define all(v) (v).begin(), (v).end()
#define mod 1000000007
#define what_is(x) cerr << #x << " is " << x <<"\n";
#define sortA(v) sort(v.begin(), v.end())
#define sortD(v) sort(v.rbegin(), v.rend())
#define PI 3.14159265358979323846
#define vout(a) for(auto x:a) cout<<x<<" ";
#define INF 10000000000000000
using namespace std;
using ll = long long;
using vi = vector<int>;
using pii = pair<int,int>;
using vii = vector<pii>;
using mi = multiset<int>;
using mii = multiset<pii>;
int lcm(int a,int b) {return (a*(b/__gcd(a,b)));}
void solve()
{
int t,n,m,i,k,r,l,u,v,w,j,s,sum=0,pos,flag=0,count=0;
string S,T,U;
cin>>S;
if(S[2]==S[3]&&S[4]==S[5]) cout<<"Yes";
else cout<<"No";
}
signed main()
{
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int t=1;
while(t--)
{
solve();
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#define NMAX (1000)
using namespace std;
int main(void){
int N = 0;
int a=0;
int b=0;
int c=0;
scanf("%d",&N);
for(int Ncount = 0; Ncount < N; Ncount++){
scanf("%d %d %d",&a,&b,&c);
if( ((a*a) + (b*b)) == (c*c) ){
printf("YES\n");
}else if( (b*b) + (c*c) == (a*a) ){
printf("YES\n");
}else if( (c*c) + (a*a) == (b*b) ){
printf("YES\n");
}else{
printf("NO\n");
}
}
}
| 0
| 70,063,104
|
#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;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define FS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long int
#define ld long double
#define pb push_back
#define bp __builtin_popcount
#define sz size()
#define ff first
#define ss second
#define vll vector<ll>
#define vbool vector<bool>
#define vpll vector<pair<ll,ll>>
#define pll pair<ll,ll>
#define vllv vector<vector<ll>>
#define setpri(x) cout<<setprecision(x)<<fixed;
#define all(v) v.begin(),v.end()
#define allr(v) v.rbegin(),v.rend()
#define yesr {cout<<"YES"<<endl;return;}
#define nor {cout<<"NO"<<endl;return;}
ll MOD=1e9+7;
ll ceil1(ll n,ll x){return (n-1)/x+(n>0);}
ll gcd(ll a,ll b){return __gcd(a,b);}
ll lcm(ll a,ll b){return (max(a,b)/gcd(a,b))*min(a,b);}
ll pow1(ll n,ll m ,ll mod=MOD );
ll pow2(ll n,ll k);
ll modinv(ll n,ll mod=MOD){ return pow1(n,mod-2,mod);}
bool func(pair<ll,ll> &a,pair<ll,ll> &b ){
if(a.ff != b.ff)return a.ff < b.ff;
return a.ss > b.ss;
}
ll const N=(ll)3e2+11;
ll const LG=(ll)log2(N)+1;
vpll v[N];
bool vis[N];
ll dis[N][N];
void disk(ll p,ll n){
ll pp=p;
ll dis1[N];
for(int i=1;i<=n;i++){
vis[i]=0;
dis1[i]=1e9;
}
priority_queue<pll,vpll,greater<pll>> q;
q.push({0,p});
dis1[p]=0;
while(!q.empty()){
ll p=q.top().ss;
q.pop();
if(vis[p])continue;
vis[p]=1;
for(auto x: v[p]){
ll node=x.ff;
ll w=x.ss;
if(dis1[node]>dis1[p]+w){
dis1[node]=dis1[p]+w;
q.push({dis1[node],node});
}
}
}
for(int i=1;i<=n;i++){
dis[pp][i]=dis1[i];
}
}
void solve(){
ll i,j,k,l,n,m,x,y,z,r;
cin>>n>>m;
vector<pair<pll,ll>> edge(m);
for(i=0;i<m;i++){
cin>>x>>y>>z;
edge[i]={{x,y},z};
v[x].pb({y,z});
v[y].pb({x,z});
}
for(i=1;i<=n;i++){
disk(i,n);
}
vbool vis1(m);
for(i=0;i<m;i++){
x=edge[i].ff.ff;
y=edge[i].ff.ss;
z=edge[i].ss;
for(j=1;j<=n;j++){
for(k=j+1;k<=n;k++){
if(dis[j][x]+z+dis[y][k]==dis[j][k] || dis[j][y]+z+dis[x][k]==dis[j][k])
vis1[i]=1;
}
}
}
ll ans=m;
for(i=0;i<m;i++){
if(vis1[i])ans--;
}
cout<<ans<<endl;
}
int main(){
FS;
ll i,j,k,n,m,x,y,z,q;
q=1;
for(ll tc=1;tc<=q;tc++){
solve();
}
return 0;
}
ll pow1(ll n,ll m,ll mod){
if(m==0)return 1;
if(m%2==0)return pow1((n*n)%mod,m/2,mod);
return (pow1((n*n)%mod,m/2,mod)*n)%mod;
}
ll pow2(ll n,ll k){
ll ans=1;
while(k>0){
if(k%2==1)ans=ans*n;
n=n*n;
k/=2;
}
return ans;
}
|
#include <bits/stdc++.h>
#define pb emplace_back
#define ll long long
#define fi first
#define se second
#define mp make_pair
using namespace std;
typedef pair<int, int> pii;
const int N = 1 << 18 | 1;
const int inf = int(1e9);
pii f[N];
int n, k, a[N], g[N];
void maximize(pii& x, pii y) {
vector<pii> v = {mp(a[x.fi], x.fi), mp(a[x.se], x.se), mp(a[y.fi], y.fi), mp(a[y.se], y.se)};
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
x.fi = v.back().se, x.se = v[v.size() - 2].se;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
#define Task "test"
if(fopen(Task".inp", "r")) {
freopen(Task".inp", "r", stdin);
freopen(Task".out", "w", stdout);
}
cin >> k; n = 1 << k;
for(int i = 0; i < n; ++i) {
cin >> a[i]; f[i].fi = i;
}
for(int i = 0; i < k; ++i) {
for(int j = 1; j < n; ++j)
if(j >> i & 1) maximize(f[j], f[j ^ (1 << i)]);
}
for(int i = 1; i < n; ++i) {
g[i] = max(g[i - 1], a[f[i].fi] + a[f[i].se]);
cout << g[i] << '\n';
}
}
| 0
| 45,734,566
|
#include <iostream>
#include <string>
#include <stdio.h>
#include <cmath>
#include <cfloat>
#include <algorithm>
#include <numeric>
#include <vector>
#include <iterator>
#include <set>
using namespace std;
const double PI=acos(-1);
int main(){
long a, b, c, k, d;
cin >> a >> b >> c >> k;
if(k%2 == 0){
d = a - b;
}else{
d = b - a;
}
if(d > 1e18){
cout << "Unfair" << endl;
}else{
cout << d << endl;
}
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <stack>
#include <queue>
#include <numeric>
#include <iomanip>
#include <map>
#include <set>
#include <deque>
#include <utility>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repk(i, k, n) for (int i = k; i < n; i++)
#define MOD 1e9 + 7
#define INF 1e9
#define SENTINEL 2e9
#define PIE 3.14159265358979323
template <class T>
inline bool chmin(T &a, T b){if (a > b){a = b;return true;}return false;}
template <class T>
inline bool chmax(T &a, T b){if (a < b){a = b;return true;}return false;}
template <class T>
inline T GCD(T a, T b){if (b == 0) return a; else return GCD(b, a % b);}
template <class T>
inline T LCM(T a, T b) {return (a * b) / GCD(a, b);}
void ans(bool flag){
if (flag)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
int main(){
int n,k,x,y;
cin>>n>>k>>x>>y;
if(n<=k)
cout << n * x << endl;
else
cout << x * k + (n - k) * y << endl;
}
| 0
| 95,929,393
|
#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);
int H, W; cin >> H >> W;
vs C(H); REP(i, H) cin >> C[i];
REP(i, H)
{
cout << C[i] << endl;
cout << C[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#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;
int main( ) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t, res=0;
vi vodd, veven;
rep(i,0,3){
cin >> t;
(t&1)?vodd.push_back(t):veven.push_back(t);
}
if (sz(vodd)==3){
sort(all(vodd));
res = (2*vodd[2]-vodd[1]-vodd[0])>>1;
}
else if (sz(vodd)==2){
if (veven[0]>= max(vodd[0],vodd[1])){
res = ((2*veven[0]-(vodd[0]+vodd[1]+2))>>1) + 1;
}
else{
res = (abs(vodd[0]-vodd[1])>>1) + ((max(vodd[0],vodd[1])+1-veven[0])>>1) + 1;
}
}
else if (sz(vodd)==1){
if (vodd[0] >= max(veven[0], veven[1])){
res = ((2*vodd[0]- (veven[0]+veven[1]+2))>>1) +1;
}
else{
res = (abs(veven[0]-veven[1])>>1) + ((max(veven[0],veven[1])+1 - vodd[0])>>1) + 1;
}
}
else{
sort(all(veven));
res = (2*veven[2]-veven[1]-veven[0])>>1;
}
cout << res <<endl;
return 0;
}
| 0
| 28,985,687
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
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() {
int n; cin >> n;
vector<ll> a(n), b(n);
rep(i, n) cin >> a.at(i) >> b.at(i);
ll ans = 0;
for (int i = n-1; 0 <= i; --i) {
a.at(i) += ans;
if (a.at(i) % b.at(i) != 0) {
ans += b.at(i) * (a.at(i) / b.at(i) + 1) - a.at(i);
}
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i,a,n) for(ll i=a;i<n;i++)
#define rev(i,n,a) for(ll i=n-1;i>=a;i--)
#define f first
#define s second
#define vll vector<ll>
#define vvll vector<vector<ll>>
#define vpii vector<pair<int,int>>
#define vpll vector<pll>
#define pll pair<ll,ll>
#define secreterror() ios_base::sync_with_stdio(false);cin.tie(NULL);
void solve(){
ll n,k;
cin>>n>>k;
vector<ll>pre(n+5,0);
vector<ll>arr(n+1);
for(int i=1;i<=n;i++){
cin>>arr[i];
}
ll logn=min((ll)41,(k));
for(int k=0;k<logn;k++){
for(int i=1;i<=n;i++){
ll x=ceil(double(i)-0.5-double(arr[i]));
ll y=floor(double(i)+0.5+double(arr[i]));
x=max((ll)0,x);
y=min(n,y);
pre[x]++;
pre[y+1]--;
}
for(int i=1;i<=n+3;i++){
pre[i]=pre[i]+pre[i-1];
}
for(int i=1;i<=n;i++){
arr[i]=pre[i];
}
for(int i=0;i<=n+3;i++){
pre[i]=0;
}
}
for(int i=1;i<=n;i++){
cout<<arr[i]<<" ";
}
cout<<endl;
}
int main()
{
secreterror()
solve();
}
| 0
| 77,858,400
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<ld, ld> pd;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= (a); i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
#define trav(a, x) for (auto& a : x)
#define deb(x) cout << #x << " = "<<x<<endl
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define sz(x) (int)x.size()
#define beg(x) x.begin()
#define en(x) x.end()
#define all(x) beg(x), en(x)
int MOD = 1000000007;
const ll INF = 1e18;
const int MX = 200005;
ll gcd(ll a , ll b) {
return (b == 0) ? a : gcd(b, a % b);
}
ll binpow(ll a, ll b) {
ll res = 1;
while (b > 0) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
ll powmod(ll a, ll b, ll m) {
a %= m;
ll res = 1;
while (b > 0) {
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
ll modinv(ll n, ll p)
{
return powmod(n, MOD - 2, MOD);
}
void max_self(ll &a, ll b) {
a = max(a, b);
}
bool is_ap(vl v, int n) {
ll d = v[1] - v[0];
F0R(i, n) {
if (v[i] != v[0] + i * d)
return false;
}
return true;
}
int main(int argc, char const *argv[])
{
cin.tie(0);
ios_base::sync_with_stdio(false);
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
int k , n;
cin >> k >> n;
int a[n];
int mx = 0;
F0R(i, n) {
cin >> a[i];
}
sort(a, a + n);
F0R(i, n) {
if (i > 0) {
mx = max(a[i] - a[i - 1], mx);
}
mx = max(k - a[n - 1] + a[0], mx);
}
cout << (k - mx) << endl;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(long long i=0; i<n; i++)
#define Rep(i,n) for(long long i=1; i<n; i++)
#define ll long long
#include <math.h>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define PI acos(-1)
using P =pair<int,int>;
ll f(ll x,ll c,ll d){
ll res =x;
res -=x/c;
res -=x/d;
res+= x/lcm(c,d);
return res;
}
int main(){
ll h,w,k;
cin>>h>>w>>k;
vector<string>s(h);
rep(i,h){
cin>>s[i];
}
ll ans=0;
for(ll i=0;i<(1<<h);i++){
for(ll j=0;j<(1<<w);j++){
ll cnt=0;
for(ll is=0;is<h;is++){
for(ll js=0;js<w;js++){
if(i>>is&1)continue;
if(j>>js&1)continue;
if(s[is][js]=='#')cnt++;
}
}
if(cnt==k)ans++;
}
}
cout<<ans<<endl;
}
| 0
| 8,374,137
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main() {
ll n, ans = 0;
cin >> n;
vector<ll> a(n), s(n + 1, 0);
map<ll, ll> mp;
for (int i = 0; i < n; ++i) {
cin >> a[i];
s[i + 1] = a[i] + s[i];
mp[s[i+1]]++;
}
mp[s[0]]++;
for (auto m : mp)
ans += m.second * (m.second - 1) / 2;
cout << ans << endl;
return 0;
}
|
# include <bits/stdc++.h>
# define rep(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
# define reps(i, n) for(int i=1, i##_len=(n); i<=i##_len; ++i)
# define rrep(i, n) for(int i=((int)(n)-1); i>=0; --i)
# define rreps(i, n) for(int i=((int)(n)); i>0; --i)
# define range_for(i, b, e) for(int i=(b), i##_len=(e); i<i##_len; ++i)
# define step(n) rep(_, n)
# define ALL(x) (x).begin(), (x).end()
# define RALL(x) (x).rbegin(), (x).rend()
# define Unique(a) a.erase(unique(ALL(a)), a.end())
# define pb push_back
# define len(x) ((int)(x).size())
# define optimize_cin() cin.tie(0); ios::sync_with_stdio(false)
# define debug(x) std::cerr<<#x<<": "<<(x)<<endl;
# define LINT_MAX (LLONG_MAX)
# define LINT_MIN (LLONG_MIN)
# define cauto const auto
# define int long long
# define float long double
using namespace std;
template <class Type> inline constexpr Type Square(Type x) { return x * x; }
template <class Type> inline constexpr bool InRange(const Type& x, const Type& fst, const Type& lst) { return (fst <= x) && (x < lst); }
template<class Integer>bool chmax(Integer &a, const Integer &b) { if (a<b) { a=b; return 1; } return 0; }
template<class Integer>bool chmin(Integer &a, const Integer &b) { if (b<a) { a=b; return 1; } return 0; }
template<class Integer>bool IsOdd(Integer &n) { return n & 1; }
template<class Integer>bool IsEven(Integer &n) { return !(n & 1); }
long long gcd(long long a, long long b) { while(b){ long long A = a; (a = b), (b = A % b); } return a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int ctoi(const char c) { return ('0' <= c && c <= '9') ? (c - '0') : -1; }
string YesNo(bool b) { return b ? "Yes" : "No"; }
string YESNO(bool b) { return b ? "YES" : "NO"; }
string yesno(bool b) { return b ? "yes" : "no"; }
void _cin(){} template <class Head, class... Tail> void _cin(Head&& head, Tail&&... tail){ cin >> head; _cin(forward<Tail>(tail)...); }
#define Cin(Type, ...) Type __VA_ARGS__; _cin(__VA_ARGS__)
#define Cinv(Type, xs, n) vector<Type> xs(n); rep(i, n) cin >> xs[i]
#define Cinv2(Type, xs, ys, n) vector<Type> xs(n), ys(n); rep(i, n) cin >> xs[i] >> ys[i]
#define Cinv3(Type, xs, ys, zs, n) vector<Type> xs(n), ys(n), zs(n); rep(i, n) cin >> xs[i] >> ys[i] >> zs[i]
#define Cinvv(Type, xs, h, w) vector<vector<Type>> xs(h, vector<int>(w)); rep(i, h) rep(j, w) cin >> xs[i][j]
void Print() { cout << endl; }
template <class Head, class... Tail> void Print(Head&& head, Tail&&... tail) { cout << head; if (sizeof...(tail) != 0) cout << " "; Print(forward<Tail>(tail)...); }
template <class Type> void Print(vector<Type> &vec) { for (auto& a : vec) { cout << a; if (&a != &vec.back()) cout << " "; } cout << endl; }
template <class Type> void Print(vector<vector<Type>> &df) { for (auto& vec : df) { Print(vec); } }
void Debug() { cerr << endl; }
template <class Head, class... Tail> void Debug(Head&& head, Tail&&... tail) { cerr << head; if (sizeof...(tail) != 0) cerr << " "; Debug(forward<Tail>(tail)...); }
template <class Type> void Debug(vector<Type> &vec) { for (auto& a : vec) { cerr << a; if (&a != &vec.back()) cerr << " "; } cerr << endl; }
template <class Type> void Debug(vector<vector<Type>> &df) { for (auto& vec : df) { Debug(vec); } }
signed main()
{
Cin(int, N, Q);
vector<vector<int>> G(N);
rep (i, N-1) {
Cin(int, a, b);
G[a-1].push_back(b-1);
G[b-1].push_back(a-1);
}
vector<int> x(N);
rep (i, Q)
{
Cin(int, _p, _x);
x[ _p - 1 ] += _x;
}
stack<int> stk;
vector<int> visited(N, 0);
stk.push(0);
visited[0] = 1;
vector<int> sums(N);
sums[0] = x[0];
while (!stk.empty())
{
int now = stk.top(); stk.pop();
visited[now] = 1;
for (int nxt : G[now])
{
if (visited[nxt]) continue;
sums[nxt] = sums[now] + x[nxt];
stk.push(nxt);
}
}
Print(sums);
return 0;
}
| 0
| 98,467,145
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<ll> vll;
typedef vector<vector<int>> vvi;
typedef vector<vector<string>> vvs;
typedef vector<vector<char>> vvc;
typedef vector<vector<bool>> vvb;
typedef pair<int,int> P;
typedef pair<ll, ll> Pll;
#define vrep(v,n) for(int i=0;i<n;i++){cin >> v.at(i);}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repn(i, n) for (int i = 0; i <= (int)(n); i++)
#define srep(i, l, n) for (int i = l; i < (int)(n); i++)
#define srepn(i, l, n) for (int i = l; i <= (int)(n); i++)
#define pb push_back
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 mod = 1000000007;
const int inf = 1e9;
#define PI 3.14159265369;
int dx[4] = {1,-1,0,0};
int dy[4] = {0,0,1,-1};
int ddx[8] = {1,1,1,-1,-1,-1,0,0};
int ddy[8] = {0,1,-1,0,1,-1,1,-1};
int main(){
int n;
cin >> n;
ll ret = 0;
ll sum = 0;
while(n--){
int a;
cin >> a;
if(a==0){
ret += sum/2;
sum = 0;
}else{
sum += a;
}
if(n==0){
ret += sum/2;
}
}
cout << ret << endl;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <cmath>
#include <functional>
#define vv(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))
#define vvi vector<vector<int> >
#define vvl vector<vector<ll> >
#define vll vector<ll>
#define rep(c, a, b) for(ll c=a;c<b;c++)
#define re(c, b) for(ll c=0;c<b;c++)
typedef long long int ll;
typedef long double ld;
using namespace std;
struct segtree{
ll M=1;
vector<ll> dat;
segtree(ll N, ll num){
while(M<N) M*=2;
for(int i=0;i<M*2-1;i++) dat.push_back(num);
}
void update(int x, int k, int l=0, int r=-1){
if(r==-1) r = M;
k+=M-1;
dat[k] += x;
while(k>0) k = (k-1)/2, dat[k] += x;
}
ll query(int a, int b=-1, int k=0, int l=0, int r=-1){
if(r==-1) r = M;
if(b==-1) b = M;
if(r<=a || b<=l) return 0;
if(a<=l && r<=b) return dat[k];
ll A = query(a, b, k*2+1, l, (l+r)/2);
ll B = query(a, b, k*2+2, (l+r)/2, r);
return A + B;
}
};
int main(int argc, char const *argv[]) {
ll a, n, k;std::cin >> n >> k;
segtree seg(n, 0);
re(i, n){
std::cin >> a;
seg.update(a, i);
}
vll c;
for(int l=0;l<n;l++) for(int r=l+1;r<=n;r++) c.push_back(seg.query(l, r));
sort(c.begin(), c.end());
reverse(c.begin(), c.end());
ll ans = 0;
vll r(64, 1);rep(i, 1, 64) r[i] = r[i-1]*2;
for(ll i=50;i>=0;i--){
ll C = 0;
vll t;
re(j, c.size()) if(r[i]&c[j]) C++, t.push_back(c[j]);
if(C<k) continue;
c = t, ans += r[i];
}
std::cout << ans << '\n';
return 0;
}
| 0
| 22,593,278
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef pair<int, int> P;
typedef pair<long long, long long> Pll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<long long> vll;
typedef vector<vector<long long>> vvll;
const long long INF = 1LL << 60;
const int INT_INF = 1 << 30;
const double PI = acos(-1.0);
int main() {
int h, w;
cin >> h >> w;
vector<string> grid(h);
rep(i, h) { cin >> grid.at(i); }
vvi left(h, vi(w)), right(h, vi(w)), up(h, vi(w)), down(h, vi(w));
rep(i, h) {
int left_count = 0, right_count = 0;
rep(j, w) {
if (grid.at(i).at(j) == '.') {
left_count++;
} else {
left_count = 0;
}
left.at(i).at(j) = left_count;
if (grid.at(i).at(w - 1 - j) == '.') {
right_count++;
} else {
right_count = 0;
}
right.at(i).at(w - 1 - j) = right_count;
}
}
rep(j, w) {
int up_count = 0, down_count = 0;
rep(i, h) {
if (grid.at(i).at(j) == '.') {
up_count++;
} else {
up_count = 0;
}
up.at(i).at(j) = up_count;
if (grid.at(h - 1 - i).at(j) == '.') {
down_count++;
} else {
down_count = 0;
}
down.at(h - 1 - i).at(j) = down_count;
}
}
int ans = 0;
rep(i, h) {
rep(j, w) { ans = max(ans, up.at(i).at(j) + down.at(i).at(j) + left.at(i).at(j) + right.at(i).at(j) - 3); }
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int i=0;i<(int)(n);++i)
int main(){
int n, m; cin>>n>>m;
vi P(n); rep(i, n){ cin>>P[i]; P[i]--; }
vvi G(n, vi());
rep(i, m){
int x, y; cin>>x>>y; x--, y--;
G[x].push_back(y), G[y].push_back(x);
}
int ans = 0;
vi vis(n, false);
queue<int> q;
rep(i, n){
vi xx, px;
q.push(i);
while(q.size()){
int x = q.front(); q.pop();
if(vis[x]) continue;
vis[x] = true;
xx.push_back(x), px.push_back(P[x]);
for(int y:G[x]){
if(vis[y]) continue;
q.push(y);
}
}
sort(all(xx)), sort(all(px));
for(int x:xx)
if(px[lower_bound(all(px), x) - px.begin()] == x) ans++;
}
cout<< ans <<endl;
}
| 0
| 8,466,022
|
#include<stdio.h>
#include<math.h>
int bruteforce(int N,int M,int a){
int i;
int b;
b=a;
if(M==1){
if(-1<N||N<10){
return 1;
}
else{
return 0;
}
}
else {
M=M-1;
for(i=fmax(N-M*9,0);i<=fmin(N,9);i++){
a=a+bruteforce(N-i,M,b);
}
}
return a;
}
int main(){
int n;
while(scanf("%d",&n)!=EOF){
printf("%d\n",bruteforce(n,4,0));
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cmath>
#include <unordered_map>
#include <deque>
using namespace std;
using ll = long long;
void _cin(){} template <class Head, class... Tail> void _cin(Head&& head, Tail&&... tail){ cin >> head; _cin(forward<Tail>(tail)...); }
void _cout(){ cout << "\n"; } template <class Head, class... Tail> void _cout(Head&& head, Tail&&... tail){ cout << head; _cout(forward<Tail>(tail)...); }
int gcd(int a, int b){ return (b == 0) ? a : gcd(b, a % b); }
template<typename S, typename T> istream& operator>>(istream &is, pair<S, T> &p){ return is >> p.first >> p.second; }
template<typename S, typename T> ostream& operator<<(ostream &os, const pair<S, T> &p){ return os << "[" << p.first << ", " << p.second << "]"; }
#define Sq(x) (x)*(x)
#define For(i, n) for(int i = 0; i < (n); i ++)
#define For1(i, n) for(int i = 1; i <= (n); i ++)
#define Rof(i, n) for(int i = (n)-1; i >= 0; i --)
#define Rep(n) For(_, n)
#define Range(c) c.begin(), c.end()
#define RevRange(c) c.rbegin(), c.rend()
#define Contains(c, x) (find(Range(c), x) != c.end())
#define Search(rb, re, x) distance(rb, find(rb, re, x))
#define Sort(a) sort(Range(a))
#define DeSort(a) sort(RevRange(a))
#define Reverse(c) reverse(Range(c))
#define Unique(a) a.erase(unique(Range(a)), a.end())
#define Cusum(T, xs, sxs) vector<T> sxs(xs.size()+1); For(i, (int)xs.size()) sxs[i+1] = sxs[i] + xs[i]
#define Cin(T, ...) T __VA_ARGS__; _cin(__VA_ARGS__)
#define Cins(T, n, xs) vector<T> xs(n); For(i, n) cin >> xs[i]
#define Cins2(T, n, xs, ys) vector<T> xs(n), ys(n); For(i, n) cin >> xs[i] >> ys[i]
#define Cins3(T, n, xs, ys, zs) vector<T> xs(n), ys(n), zs(n); For(i, n) cin >> xs[i] >> ys[i] >> zs[i]
#define Cinm(T, n, map) unordered_map<T, int> map; Rep(n){ Cin(T, x); map[x] ++; }
#define Cout(...) _cout(__VA_ARGS__)
#define Couts(xs) { for(const auto &e : xs) cout << e << " "; cout << "\n"; }
#define Coutyn(cond) Cout((cond) ? "yes" : "no")
#define CoutYn(cond) Cout((cond) ? "Yes" : "No")
#define CoutYN(cond) Cout((cond) ? "YES" : "NO")
#define vc vector
#define Mini(a, x) a = min(a, x)
#define Maxi(a, x) a = max(a, x)
#define Return(x) { Cout(x); return 0; }
int main(void){
Cin(int, n);
Cins(int, n, a);
ll ans = 0;
int lb = 1;
For(i, n){
int k = (a[i]-1) / lb;
ans += k;
if(k > 0) a[i] = 1;
lb = max(lb-1, a[i]) + 1;
}
Cout(ans);
}
| 0
| 91,812,729
|
#include<iostream>
#include<cmath>
#include<string>
#include<cctype>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
std::string s;
std::string p;
cin>>s;
cin>>p;
s+=s;
int loc=s.find(p,0);
if(loc!=string::npos)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<tuple>
using namespace std;
typedef pair<int, int> pii;
int main(){
while(1){
int n;
cin>> n;
if(!n) break;
string s[n], t[n];
for(int i=0; i<n; i++) cin>> s[i]>> t[i];
int a[n], b[n];
for(int i=0; i<n; i++){
a[i]=60*60*stoi(s[i].substr(0, 2))+60*stoi(s[i].substr(3, 2))+stoi(s[i].substr(6, 2));
b[i]=60*60*stoi(t[i].substr(0, 2))+60*stoi(t[i].substr(3, 2))+stoi(t[i].substr(6, 2));
}
int v[24*60*60]={};
for(int i=0; i<n; i++){
v[a[i]]+=1;
v[b[i]]-=1;
}
for(int i=1; i<24*60*60; i++){
v[i]+=v[i-1];
}
int k=0;
for(int i=0; i<24*60*60; i++){
k=max(k, v[i]);
}
cout<< k<< endl;
}
return 0;
}
| 0
| 49,430,767
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
template<typename H> bool chmin(H& v1, const H v2) { if (v1 > v2) { v1 = v2; return true; } return false; }
template<typename H> bool chmax(H& v1, const H v2) { if (v1 < v2) { v1 = v2; return true; } return false; }
template<typename H> void read(H& head) { cin >> head; }
template<typename H, typename ...T> void read(H& head, T& ...tail) { cin >> head; read(tail...); }
template<typename H> void write(H head) { cout << head << '\n'; }
template<typename H, typename ...T> void write(H head, T ...tail) { cout << head << " "; write(tail...); }
template<typename ...T> void die(T ...tok) { write(tok...); exit(0); }
ll a[100005], b[100005];
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(cin.failbit);
int n; read(n);
rep(i, 0, n) read(a[i], b[i]);
ll ans = 0;
for (int i = n - 1; i >= 0; i--) {
if ((a[i] + ans) % b[i] != 0) {
ans += (b[i] - (a[i] + ans) % b[i]);
}
}
die(ans);
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <list>
#include <utility>
#include <tuple>
#include <cstdio>
#include <set>
#include <queue>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <cmath>
#include <limits>
#include <iomanip>
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i=0;i<(n);++i)
using namespace std;
const long long INF = 1LL << 60;
typedef long long ll;
int main() {
int A,B,C;
cin >> A >> B >> C;
vector<int> surplus;
for(int i=1;i<B;i++){
int num;
num = (A*i)%B;
if(num>0){
surplus.push_back(num);
}
}
bool frg = false;
for(int i=0;i<surplus.size();i++){
if(C%surplus[i]==0){
frg = true;
break;
}
}
if(frg){
cout << "YES" << endl;
}
else{
cout << "NO" << endl;
}
}
| 0
| 6,088,529
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
string s;
cin >> s;
ll zero, one;
zero = one = 0;
if (s.length() < 1)
{
cout << 0 << endl;
return 0;
}
ll ans = 0;
for (ll i = 1; i < s.length(); i++)
{
if (s[i] == s[i - 1])
{
s[i] = s[i] == '0' ? '1' : '0';
ans++;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = a; i < b; i++)
#define Rep(i, a, b) for(int i = a; i <= b; i++)
#define _GLIBCXX_DEBUG
#define Vl vector<ll>
#define Vs vector<string>
#define Vp vector<pair<ll, ll>>
#define ll long long
#define ALL(v) (v).begin(),(v).end()
using namespace std;
const double pi = acos(-1.0);
const ll MOD = 1e9 + 7;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b)
{
if (a%b == 0) {
return(b);
} else {
return(gcd(b, a%b));
}
}
ll lcm(ll a, ll b){
return a / gcd(a, b) * b;
}
bool is_prime(const unsigned n){
switch(n){
case 0:
case 1: return false;
case 2:
case 3: return true;
}
if(n % 2 == 0 || n % 3 == 0) return false;
for(unsigned i = 5; i * i <= n; i += 6) {
if(n % i == 0) return false;
if(n % (i+2) == 0) return false;
}
return true;
}
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; }
void solve() {
ll n; cin >> n;
Vl a(n), b(n);
rep(i, 0, n) cin >> a[i] >> b[i];
ll ans = 0, c = 0;
for(int i = n-1; i >= 0; i--){
if(((a[i]+c)%b[i]) == 0) continue;
ans += b[i]-((a[i]+c)%b[i]);
c += b[i]-((a[i]+c)%b[i]);
}
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| 0
| 46,794,783
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
typedef long long ll;
int main(){
string s; cin>>s;
string ans;
rep(i,s.size()){
if(s[i]=='0') ans+='0';
else if(s[i]=='1') ans+='1';
else if(ans.size()!=0&&s[i]=='B') ans.erase(ans.size()-1);
}
cout<<ans<<endl;
}
|
#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <algorithm>
#include <numeric>
#include <functional>
#include <cmath>
#include <utility>
using namespace std;
using ll = long long int;
int main() {
int N;
cin >> N;
int k = 0;
for (int i = 1; i < 451; i++) {
if (i*(i + 1) / 2 != N) {
continue;
}
else {
cout << "Yes" << endl;
cout << i+1 << endl;
k = i;
break;
}
}
if (!k) { cout << "No"; return 0; }
vector<pair<int,int>> phase(N+1);
vector<int> ness(k + 1);
for (int i = 1; i <= k; i++) {
ness[i] = ness[i - 1] + k + 1 - i;
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= k; j++) {
if (i <= ness[j]) {
phase[i] = make_pair(j,i-ness[j-1]);
break;
}
}
}
for (int i = 0; i <= k; i++) {
cout << k;
for (int j = 1; j <= N; j++) {
int flag = 0;
if (i == phase[j].first - 1)flag++;
if (i == phase[j].first - 1 + phase[j].second)flag++;
if (flag) {
cout << " " << j;
}
}
cout << endl;
}
return 0;
}
| 0
| 8,854,993
|
#include <iostream>
#include <complex>
#include <sstream>
#include <string>
#include <algorithm>
#include <deque>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <vector>
#include <set>
#include <limits>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <ctime>
using namespace std;
#define REP(i, j) for(int i = 0; i < (int)(j); ++i)
#define FOR(i, j, k) for(int i = (int)(j); i < (int)(k); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define REVERSE(v) reverse((v).begin(), (v).end())
typedef complex<double> P;
void display(vector<int> &v){
cout <<v[0];
FOR(i, 1, v.size()) cout <<" " <<v[i];
cout <<endl;
}
int selectionSort(vector<int> &v){
int cnt = 0;
REP(i, v.size()){
int idx = i;
FOR(j, i, v.size()) if(v[j] < v[idx]) idx = j;
swap(v[i], v[idx]);
if(i != idx) ++cnt;
}
display(v);
return cnt;
}
int main() {
int N; cin >>N;
vector<int> v(N);
REP(i, N) cin >>v[i];
cout <<selectionSort(v) <<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int,vector<int>> P;
set<string> RT;
vector<bool> ans;
void prog(int a,string r,vector<bool>T){
T.at(a-1)=true;
if(T==ans){
RT.insert(r);
return;
}
for(int i:P.at(a)){
if(T.at(i-1))continue;
r.push_back(i+'0');
prog(i,r,T);
r.pop_back();
}
}
int main (){
int N,M;
cin >> N >> M;
for(int i=0;i<M;i++){
int j,k;
cin >> j >> k;
P[j].push_back(k);
P[k].push_back(j);
}
ans=vector<bool>(N,true);
prog(1,"1",vector<bool>(N,false));
cout << RT.size() << endl;
}
| 0
| 61,705,527
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> Pint;
typedef pair<ll, ll> P;
ll INFL = 1000000000000000010;
int INF = 2147483600;
ll MOD = 1000000007;
vector<int> dy = {0,0,1,-1};
vector<int> dx = {1,-1,0,0};
int main(void){
cin.tie(0);
ios::sync_with_stdio(false);
int A, B;
cin >> A >> B;
vector<vector<char>> mp(100, vector<char>(100));
for(int i = 0; i < 100; i++){
for(int j = 0; j < 100; j++){
if(i < 50){
mp[i][j] = '.';
}else{
mp[i][j] = '#';
}
}
}
for(int i = 0; i < B - 1; i++){
mp[(i / 50) * 2][(i % 50) * 2] = '#';
}
for(int i = 0; i < A - 1; i++){
mp[(i / 50) * 2 + 51][(i % 50) * 2] = '.';
}
cout << 100 << " " << 100 << endl;
for(int i = 0; i < 100; i++){
for(int j = 0; j < 100; j++){
cout << mp[i][j];
}
cout << endl;
}
}
|
#ifdef LOCAL
#define _GLIBCXX_DEBUG
#define __clock__
#else
#pragma GCC optimize("Ofast")
#endif
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<ll>;
using VV = vector<VI>;
using VS = vector<string>;
using PII = pair<ll, ll>;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
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; }
#define FOR(i,a,b) for(ll i=(a);i<(b);++i)
#define rep(i,b) FOR(i, 0, b)
#define ALL(v) (v).begin(), (v).end()
#define p(s) cout<<(s)<<'\n'
#define p2(s, t) cout << (s) << " " << (t) << '\n'
#define br() p("")
#define pn(s) cout << (#s) << " " << (s) << '\n'
#define SZ(x) ((int)(x).size())
#define SORT(A) sort(ALL(A))
#define RSORT(A) sort(ALL(A), greater<ll>())
#define MP make_pair
#define p_yes() p("Yes")
#define p_no() p("No")
ll SUM(VI& V){
return accumulate(ALL(V), 0LL);
}
ll MIN(VI& V){return *min_element(ALL(V));}
ll MAX(VI& V){return *max_element(ALL(V));}
void print_vector(VI& V){
ll n = V.size();
rep(i, n){
if(i) cout << ' ';
cout << V[i];
}
cout << endl;
}
ll gcd(ll a,ll b){
if(b == 0) return a;
return gcd(b,a%b);
}
ll lcm(ll a,ll b){
ll g = gcd(a,b);
return a / g * b;
}
using ld = long double;
#define EPS (1e-14)
#define equals(a,b) (fabs((a)-(b)) < EPS)
void no(){p_no(); exit(0);}
void yes(){p_yes(); exit(0);}
const ll mod = 1e9 + 7;
const ll inf = 1e18;
const double PI = acos(-1);
void solve(){
ll a;
cin>>a;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll N,M;cin>>N>>M;
VI X(N);
VI Y(N);
VI Z(N);
rep(i,N){
cin>>X[i]>>Y[i]>>Z[i];
}
ll ma = 0;
rep(f,8){
VI sign(3, 1);
if(f>>0&1) sign[0] *= -1;
if(f>>1&1) sign[1] *= -1;
if(f>>2&1) sign[2] *= -1;
VI V;
rep(i,N){
ll taste = X[i]*sign[0] + Y[i]*sign[1] + Z[i]*sign[2];
V.push_back(taste);
}
RSORT(V);
ll sum=0;
rep(i,M) sum+=V[i];
chmax(ma, sum);
}
p(ma);
return 0;
}
| 0
| 86,051,116
|
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> W(N);
for (int i = 0; i < N; i++) cin >> W[i];
int ans = 100000;
for (int T = 0; T < N - 1; T++) {
int S1 = 0, S2 = 0;
for (int i = 0; i < N; i++) {
if (i <= T) S1 += W[i];
else S2 += W[i];
}
ans = min(ans, abs(S1 - S2));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <iomanip>
using namespace std;
#define reps(i,s,n) for(int i = s; i < n; i++)
#define rep(i,n) reps(i,0,n)
#define Rreps(i,n,e) for(int i = n - 1; i >= e; --i)
#define Rrep(i,n) Rreps(i,n,0)
#define ALL(a) a.begin(), a.end()
#define fi first
#define se second
#define mp make_pair
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
ll N,M,H,W,K,Q,A,B;
string S, T;
const ll MOD = (1e+9) + 7;
const ll INF = 1LL << 60;
typedef pair<int, int> P;
mat G(1e+5, vec(0));
vec color(1e+5, 0);
bool ifd2 = true, only_one = false;
void dfs(int v, int c){
color[v] = c;
if(G[v].empty()){
only_one = true;
return;
}
for(int to : G[v]){
if(color[to] == 0){
dfs(to, -c);
}else if(color[to] == c){
ifd2 = false;
}
}
}
int main() {
cin>>N>>M;
rep(i,M){
cin>>A>>B;
--A;
--B;
G[A].push_back(B);
G[B].push_back(A);
}
ll d2{0}, nd2{0}, one{0};
rep(i,N){
if(color[i] == 0){
ifd2 = true;
only_one = false;
dfs(i, 1);
only_one ? ++one : ifd2 ? ++d2 : ++nd2;
}
}
cout<<one * (N * 2 - one) + (d2 + nd2) * (d2 + nd2) + d2 * d2<<endl;
}
| 0
| 28,948,108
|
#include <algorithm>
#include <climits>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <unordered_map>
#include <vector>
const int mod = 1e9 + 7;
const int kmax = 510000;
const int last_days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
long long fact[kmax], fact_inv[kmax], inv[kmax];
void init_comb()
{
fact[0] = fact[1] = 1;
fact_inv[0] = fact_inv[1] = 1;
inv[1] = 1;
for (int i = 2; i < kmax; i++) {
fact[i] = fact[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
fact_inv[i] = fact_inv[i - 1] * inv[i] % mod;
}
}
long long comb(int n, int r)
{
if (n < r) {
return 0;
}
if (n < 0 || r < 0) {
return 0;
}
return fact[n] * (fact_inv[r] * fact_inv[n - r] % mod) % mod;
}
template <typename T, T N>
class UnionFind {
T parent_[N];
T rank_[N];
T size_[N];
public:
UnionFind();
T Root(T idx);
bool IsSame(T x, T y);
void Unite(T x, T y);
T GetSize(T idx);
};
template <typename T, T N>
UnionFind<T, N>::UnionFind()
{
for (T i = 0; i < N; i++) {
parent_[i] = i;
rank_[i] = 0;
size_[i] = 1;
}
}
template <typename T, T N>
T UnionFind<T, N>::Root(T idx)
{
return parent_[idx] == idx ? idx : parent_[idx] = Root(parent_[idx]);
}
template <typename T, T N>
bool UnionFind<T, N>::IsSame(T x, T y)
{
return Root(x) == Root(y);
}
template <typename T, T N>
void UnionFind<T, N>::Unite(T x, T y)
{
x = Root(x);
y = Root(y);
if (x == y) {
return;
}
if (rank_[x] < rank_[y]) {
parent_[x] = y;
size_[y] += size_[x];
} else {
parent_[y] = x;
size_[x] += size_[y];
if (rank_[x] == rank_[y]) {
rank_[x]++;
}
}
}
template <typename T, T N>
T UnionFind<T, N>::GetSize(T idx)
{
return size_[Root(idx)];
}
long long pow_mod(long long n, long long p, long long m)
{
if (p == 0) {
return 1;
}
if (p % 2 == 0) {
long long t = pow_mod(n, p / 2, m);
return t * t % m;
}
return n * pow_mod(n, p - 1, m) % mod;
}
long long nCr_mod(long long n, long long r)
{
long long x = 1;
for (long long i = n - r + 1; i <= n; i++) {
x *= i;
x %= mod;
}
long long a = 1;
for (long long i = 1; i <= r; i++) {
a *= i;
a %= mod;
}
long long y = pow_mod(a, mod - 2, mod) % mod;
return x * y % mod;
}
bool is_prime(long long n)
{
if (n == 1) {
return false;
}
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
bool is_leap(long long y)
{
return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;
}
void next_day(long long& y, long long& m, long long& d)
{
d++;
if (d > last_days[m - 1] + (m == 2 && is_leap(y) ? 1 : 0)) {
d = 1;
m++;
}
if (m > 12) {
y++;
m = 1;
}
}
long long fib(long long n)
{
long long a = 0, b = 1;
for (int i = 0; i < n; i++) {
long long t = a;
a = b;
b = a + t;
}
return a;
}
template <typename T>
std::vector<size_t> calculate_ranks(const std::vector<T>& v)
{
std::vector<T> sorted = v;
std::sort(sorted.begin(), sorted.end());
std::map<T, long long> m;
for (auto i = 0LU; i < v.size(); i++) {
m.insert(std::make_pair(sorted[i], i));
}
std::vector<size_t> rank(v.size());
for (auto i = 0LU; i < v.size(); i++) {
rank[i] = m.find(v[i])->second + 1;
}
return rank;
}
std::map<long long, long long> prime_factors_and_num(long long n)
{
std::map<long long, long long> m;
for (int i = 2; i <= n; i++) {
while (n % i == 0) {
m[i]++;
n /= i;
}
}
return m;
}
inline long long calculate_sum(const std::vector<long long>& v)
{
return std::accumulate(v.begin(), v.end(), 0LL);
}
int main()
{
long long n, h;
std::cin >> n >> h;
std::vector<long long> a(n), b(n);
for (int i = 0; i < n; i++) {
std::cin >> a[i] >> b[i];
}
std::sort(b.begin(), b.end());
long long max_a = *std::max_element(a.begin(), a.end());
long long ans = 0LL;
while (b.size() && b.back() > max_a && h > 0) {
ans++;
h -= b.back();
b.pop_back();
}
std::cout << ans + (h > 0 ? (h + max_a - 1LL) / max_a : 0) << std::endl;
}
|
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;
typedef struct Node{
int key;
Node *prev, *next;
}Node;
Node* nil = (Node*)malloc(sizeof(Node));
void initialize(void){
nil -> key = -1;
nil -> prev = nil;
nil -> next = nil;
}
void insert(int value){
Node* n = (Node*)malloc(sizeof(Node));
nil->next->prev = n;
n->key = value;
n->prev = nil;
n->next = nil->next;
nil->next = n;
}
void delete_(int value){
Node* n = nil->next;
while(1){
if(n == nil){
break;
}
if(n->key == value){
Node* n_prev = n->prev;
Node* n_next = n->next;
n->prev->next = n_next;
n->next->prev = n_prev;
free(n);
break;
}
n = n->next;
}
}
void deleteFirst(){
Node* n = nil->next;
n->next->prev = nil;
nil->next = n->next;
free(n);
}
void deleteLast(){
Node* n = nil->prev;
n->prev->next = nil;
nil->prev = n->prev;
free(n);
}
void print_elements(){
bool is_first = true;
Node* n = nil->next;
while(n != nil){
if(is_first){
is_first = false;
}else{
printf(" ");
}
printf("%d", n->key);
n = n->next;
}
printf("\n");
}
int main(void){
int n;
scanf("%d", &n);
initialize();
for(int i = 0; i < n; i++){
char s[20];
int value;
scanf("%s", s);
string s_ = s;
if(s_ == "insert"){
scanf("%d", &value);
insert(value);
}else if(s_ == "delete"){
scanf("%d", &value);
delete_(value);
}else if(s_ == "deleteFirst"){
deleteFirst();
}else if(s_ == "deleteLast"){
deleteLast();
}
}
print_elements();
}
| 0
| 27,181,539
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <cmath>
#include <climits>
#include <iomanip>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
int main(){
char c;
cin >> c;
char res;
if(c == 'A')res = 'T';
if(c == 'T')res = 'A';
if(c == 'C')res = 'G';
if(c == 'G')res = 'C';
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long lol;
#define REP(i,n) for(lol i=0;i<lol(n);i++)
#define REPD(i,n) for(lol i=n-1;i>=0;i--)
#define FOR(i,a,b) for(lol i=a;i<=lol(b);i++)
#define FORD(i,a,b) for(lol i=a;i>=lol(b);i--)
#define ALL(x) x.begin(),x.end()
#define SIZE(x) lol(x.size())
#define PI 3.1415926535897932385
#define INF 1000000000000
#define MOD 1000000007
#define MAXR 100000
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; }
int gcd(int a,int b){return b?gcd(b,a%b):a;}
bool kaibun(string s, int i, int j)
{
i--; j--;
bool fl = true;
while(i <= j)
{
if(s[i] != s[j])
{
fl = false;
break;
}
i++; j--;
}
if(!fl)
{
return false;
}
else
{
return true;
}
}
int main()
{
string result{"No"};
string s; cin >> s;
lol len = s.length();
if(kaibun(s, 1, len) && kaibun(s, 1, (len-1)/2) && kaibun(s, (len+3)/2, len))
result = "Yes";
cout << result << endl;
return 0;
}
| 0
| 86,361,834
|
#include <bits/stdc++.h>
#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define endl "\n"
#define PI 3.14159265358979
#define MOD 1000000007
using namespace std;
using ll = long long;
void solve()
{
string s, t;
cin >> s >> t;
cout << t << s;
}
int main()
{
fastio;
solve();
return 0;
}
|
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int nIMPOS = -1;
struct StDir
{
int m_nDir;
int m_nDone;
StDir(int nDir) : m_nDir(nDir), m_nDone(0)
{ }
};
void fnInput(vector<vector<StDir>>& rvvoAdjcy, vector<int>& rvnDst)
{
int nxSiz;
cin >> nxSiz;
StDir oDir(0);
rvvoAdjcy.resize(nxSiz + 1, vector<StDir>(nxSiz + 1, oDir));
for (int i = 0; i < nxSiz; ++i)
{
int nx, nySiz;
cin >> nx >> nySiz;
for (int j = 0; j < nySiz; ++j)
{
int ny;
cin >> ny;
rvvoAdjcy[nx][ny].m_nDir = 1;
}
}
rvnDst.resize(nxSiz + 1, nIMPOS);
}
void fnBreadthFirstSearch(vector<vector<StDir>>& rvvoAdjcy,
queue<int>& rqnBFSrch, vector<int>& rvnDst)
{
while (rqnBFSrch.size())
{
int nx = rqnBFSrch.front(); rqnBFSrch.pop();
if (rvnDst[nx] == nIMPOS) continue;
for (int ny = 1; ny < rvvoAdjcy[nx].size(); ++ny)
if (rvvoAdjcy[nx][ny].m_nDir == 1 &&
rvvoAdjcy[nx][ny].m_nDone == 0)
{
rvvoAdjcy[nx][ny].m_nDone = 1;
int nDst = rvnDst[nx] + 1;
if (rvnDst[ny] == nIMPOS)
rvnDst[ny] = nDst;
else
rvnDst[ny] = min(rvnDst[ny], nDst);
rqnBFSrch.push(ny);
}
}
}
void fnResult(const vector<int>& cnrvnDst)
{
for (int i = 1; i < cnrvnDst.size(); ++i)
cout << i << " " << cnrvnDst[i] << endl;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
vector<vector<StDir>> vvoAdjcy;
queue<int> qnBFSrch;
vector<int> vnDst;
fnInput(vvoAdjcy, vnDst);
vnDst[1] = 0;
qnBFSrch.push(1);
fnBreadthFirstSearch(vvoAdjcy, qnBFSrch, vnDst);
fnResult(vnDst);
return 0;
}
| 0
| 61,125,354
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int cnt[5] = {};
rep(i,3) {
int a, b;
cin >> a >> b;
cnt[a]++;
cnt[b]++;
}
string ans = "YES";
rep(i,5) {
if (cnt[i] > 2) ans = "NO";
}
cout << ans << endl;
}
|
#include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
using namespace std;
const int INF = 1 << 30;
const long long MOD = 1000000000 + 7;
const double PI = acos(-1);
int main() {
int N, M; cin >> N >> M;
vector<vector<int>> A(M);
rep(i, N) {
int a, b; cin >> a >> b;
if (a <= M)A[a - 1].push_back(b);
}
priority_queue<int> pq;
int ans = 0;
rep(i, M) {
rep(j, A[i].size()) {
pq.push(A[i][j]);
}
if (!pq.empty()) {
ans += pq.top();
pq.pop();
}
}
cout << ans;
}
| 0
| 22,771,542
|
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<vector>
#include<queue>
#include<bitset>
#include<string>
#include<stack>
#include<set>
#include<unordered_set>
#include<map>
#include<unordered_map>
#include<cstring>
#include<complex>
#include<cmath>
#include<iomanip>
#include<numeric>
#include<algorithm>
#include<list>
#include<functional>
#include<cassert>
#define mp make_pair
#define pb push_back
#define X first
#define Y second
#define y0 y12
#define y1 y22
#define INF 987654321987654321
#define PI 3.141592653589793238462643383279502884
#define fup(i,a,b,c) for(int (i)=(a);(i)<=(b);(i)+=(c))
#define fdn(i,a,b,c) for(int (i)=(a);(i)>=(b);(i)-=(c))
#define MEM0(a) memset((a),0,sizeof(a));
#define MEM_1(a) memset((a),-1,sizeof(a));
#define ALL(a) a.begin(),a.end()
#define SYNC ios_base::sync_with_stdio(false);cin.tie(0)
using namespace std;
typedef long long ll;
typedef long double ld;
typedef double db;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef pair<int, int> Pi;
typedef pair<ll, ll> Pll;
typedef pair<ld, ld> Pd;
typedef vector<int> Vi;
typedef vector<ll> Vll;
typedef vector<double> Vd;
typedef vector<Pi> VPi;
typedef vector<Pll> VPll;
typedef vector<Pd> VPd;
typedef tuple<int, int, int> iii;
typedef tuple<int,int,int,int> iiii;
typedef tuple<ll, ll, ll> LLL;
typedef vector<iii> Viii;
typedef vector<LLL> VLLL;
typedef complex<double> base;
const int MOD = 1000000009;
ll POW(ll a, ll b, ll MMM = MOD) {ll ret=1; for(;b;b>>=1,a=(a*a)%MMM)if(b&1)ret=(ret*a)% MMM; return ret; }
ll gcd(ll a, ll b) { return b ? gcd(b, a%b) : a; }
ll lcm(ll a, ll b) { if (a == 0 || b == 0)return a + b; return a*(b / gcd(a, b)); }
int dx[] = { 0,1,0,-1,1,1,-1,-1 }, dy[] = { 1,0,-1,0,1,-1,1,-1 };
int ddx[]={-1,-2,1,-2,2,-1,2,1},ddy[]={-2,-1,-2,1,-1,2,1,2};
ll a[303],d[303][303];
int n,k;
ll go(int N,int K)
{
if(N==n+1)return 0;
ll &ret=d[N][K];
if(~ret)return ret;
ret=INF;
fup(i,0,K,1)
{
int next=N+i+1;
if(next>n+1)break;
if(a[next]>a[N])ret=min(ret,go(next,K-i)+a[next]-a[N]);
else ret=min(ret,go(next,K-i));
}
return ret;
}
int main(){
MEM_1(d);
scanf("%d%d",&n,&k);
if(n==k)return !printf("0");
fup(i,1,n,1)scanf("%lld",a+i);
printf("%lld",go(0,k));
}
|
#include<iostream>
#include<string>
#include<map>
using namespace std;
map<char,int> mcxi;
int main(){
int n;
mcxi['m']=1000;
mcxi['c']=100;
mcxi['x']=10;
mcxi['i']=1;
string num[11]={"0","1","2","3","4","5","6","7","8","9"};
cin>>n;
while(n--){
int ans=0,a=1;
string s,s1,s2;
cin>>s1>>s2;
s=s1;
for(int i=s.size()-1;i>=0;i--){
if(s[i]=='i' || s[i]=='x' || s[i]=='c' || s[i]=='m'){
a=1;
if(s[i-1]<=57 && s[i-1]>=50)
a+=s[i-1]-'1';
ans+=mcxi[s[i]]*a;
}
}
s=s2;
for(int i=s.size()-1;i>=0;i--){
if(s[i]=='i' || s[i]=='x' || s[i]=='c' || s[i]=='m'){
a=1;
if(s[i-1]<=57 && s[i-1]>=50)
a+=s[i-1]-'1';
ans+=mcxi[s[i]]*a;
}
}
if(ans>=1000){
if(ans/1000>1)
cout<<ans/1000;
cout<<'m';
ans-=ans/1000*1000;
}
if(ans>=100){
if(ans/100>1)
cout<<ans/100;
cout<<'c';
ans-=ans/100*100;
}
if(ans>=10){
if(ans/10>1)
cout<<ans/10;
cout<<'x';
ans-=ans/10*10;
}
if(ans>=1){
if(ans>1)
cout<<ans;
cout<<'i';
}
cout<<endl;
}
return 0;
}
| 0
| 81,464,019
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define int long long int
#define ull unsigned int
#define ld long double
#define pb push_back
#define pa pair<int,int>
#define ppa pair<pair<int,int>,int>
#define pap pair<int,pair<int,int>>
#define v1d vector<int>
#define v2d vector<vector<int> >
#define vpa vector<pair<int,int>>
#define M 1000000007
#define MN LLONG_MIN
#define MX LLONG_MAX
#define ff first
#define ss second
#define endl "\n"
#define v1s vector<string>
#define all(v) v.begin(),v.end()
#define S(v) sort(v.begin(),v.end())
#define RS(v) sort(v.rbegin(),v.rend())
#define R(v) reverse(v.begin(),v.end())
#define mxpq(T) priority_queue <T>
#define mnpq(T) priority_queue<T,vector<T>,greater<T>>
#define T int tc;cin>>tc;while(tc--)
#define p2d(v) for(auto a:v){for(auto b:a)cout<<b<<" ";cout<<endl;}
#define p1d(v) for(auto a:v)cout<<a<<" ";cout<<endl;
#define ppd(v) for(auto a:v)cout<<a.ff<<" "<<a.ss<<endl;
#define forIloop(i,n) for(auto i=0;i<n;i++);
#define forDloop(i,n) for(auto i=n-1;i>=0;i--);
#define qqq 400005
#define isEven(n) (!n & 1);
const int MOD = 1e9 + 7;
void codeforce2(){
int a,b; cin>>a>>b;
int ans = a*b;
int temp = __gcd(a,b);
cout << ans/temp << endl;
}
int32_t main(){
cout<<fixed<<setprecision(16);
cin.sync_with_stdio(false);
cin.tie(0);cout.tie(0);
codeforce2();
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <deque>
#include <queue>
using namespace std;
#define rep(i, a, b) for(int i = a; i < (b); ++i)
typedef long long ll;
typedef pair<int,int> P;
int main() {
string o,e;
cin >> o >> e;
vector<char>s(o.size()+e.size()+1);
int index = 1;
for(int i=0;i<o.size();i++){
s[index]=o[i];
index+=2;
}
index = 2;
for(int i=0;i<e.size();i++){
s[index]=e[i];
index+=2;
}
for(int i=1;i<s.size();i++){
cout << s[i];
}
}
| 0
| 96,643,947
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
int n;cin>>n;
vector<string> w(n);
rep(i,n)cin>>w[i];
bool ans=true;
rep(i,n-1){
if(w[i][w[i].size()-1]!=w[i+1][0])ans=false;
}
rep(i,n){
for(int j=i+1;j<n;j++){
if(w[i]==w[j])ans=false;
}
}
if(ans)cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
long int n, m;
cin >> n >> m;
long int a, b, chk = 0;
vector<long int>cnct_a;
vector<long int>cnct_b;
for(long int i = 0; i < m; i++){
cin >> a >> b;
if(a == 1 && b == n){
chk = 1;
break;
}
else{
if(a == 1)
cnct_a.push_back(b);
if( b == n)
cnct_b.push_back(a);
}
}
sort(cnct_a.begin(), cnct_a.end());
sort(cnct_b.begin(), cnct_b.end());
if(chk == 0){
if(cnct_a.size() == 0 || cnct_b.size() == 0)
chk = 0;
else{
vector<long int>v(cnct_a.size() + cnct_b.size());
vector<long int>::iterator it, st;
it = set_intersection(cnct_a.begin(), cnct_a.end(), cnct_b.begin(), cnct_b.end(), v.begin());
for (st = v.begin(); st != it; ++st){
chk = 1;
break;
}
}
}
if(chk == 0)
cout << "IMPOSSIBLE";
else if(chk == 1)
cout << "POSSIBLE";
return 0;
}
| 0
| 11,255,493
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
using ll = long long;
const int INF = 1001001001;
const ll INF_LL = 1001001001001001001LL;
int main(void){
int n; cin >> n;
int num = -1;
int ans;
for(int i = 1;i<=n;i++){
int tmp = 0;
int k = i;
while(k%2==0){
k /= 2;
tmp++;
if(k==1||k==0) break;
}
num = max(tmp,num);
if(num==tmp) ans = i;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define fast() ios_base::sync_with_stdio(false),cin.tie(0),cout.tie(0);
#define lp(i, n) for(int i = 0; i < n; i++)
#define rlp(i, n) for(int i = n-1; i >= 0; i--)
#define loop(i, a, b) for(int i = a; i <= b; i++)
#define rloop(i, a, b) for(int i = a; i >= b; i--)
#define mem(a, val) memset(a, val, sizeof a);
#define test int t; cin>> t; while(t--)
#define all(v) v.begin(),v.end()
#define ll long long
#define ld long double
#define mp_ make_pair
#define pb push_back
#define sz(s) (int)s.size()
const int MAX = 1e5 + 5;
const int inf = 1e9+1;
const ll OO = 1e18;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int,int> pii;
int n, a[MAX], dp[MAX];
int solve(int i = 0){
if(i == n - 1) return 0;
if(dp[i] < 1e9) return dp[i];
int choice1 = inf, choice2 = inf;
if(i + 1 < n)
choice1 = solve(i + 1) + abs(a[i + 1] - a[i]);
if(i + 2 < n)
choice2 = solve(i + 2) + abs(a[i + 2] - a[i]);
return dp[i] = min(choice1, choice2);
}
int main()
{
cin>> n;
lp(i, n)
cin>> a[i];
mem(dp, 63);
cout<< solve() <<"\n";
return 0;
}
| 0
| 83,198,678
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#define ll long long
#define YES cout << "YES" << endl;
#define NO cout << "NO" << endl;
#define yes cout << "Yes" << endl;
#define no cout << "No" << endl;
#define loop(i,start, stop) for(int i = start; i < (stop); i++)
using namespace std;
int main(){
int A,B,C,K;
cin >> A >> B >> C >> K;
int ans=0;
if(K <= A) ans += 1 * K;
else if(A < K) {
if (K-A <= B) ans += 1 * A + 0;
else if (B < K-A) ans += 1 * A + 0 + (-1 * (K-A-B));
}
cout << ans << endl;
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int a, b;
cin >> a >> b;
char mat[100][100];
string s = "#.";
for(int i = 0; i < 100; i++){
for(int j = 0; j < 100; j++){
mat[i][j] = s[i/50];
}
}
a--, b--;
for(int i = 0; i < 50; i++){
for(int j = 1 + i%2; a > 0 && j < 100; j += 3){
mat[i][j] = '.';
a--;
}
}
for(int i = 51; i < 100; i++){
for(int j = 1 + i%2; b > 0 && j < 100; j += 3){
mat[i][j] = '#';
b--;
}
}
cout << 100 << " " << 100 << endl;
for(int i = 0; i < 100; i++){
for(int j = 0; j < 100; j++){
cout << mat[i][j];
}
cout << endl;
}
return 0;
}
| 0
| 43,965,359
|
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define countof(array) (sizeof(array) / sizeof(array[0]))
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = (n)-1; i >= 0; --i)
#define rep2(i,n) for(int i = 1; i <= (n); ++i)
#define rrep2(i,n) for(int i = (n); i > 0; --i)
#define srep(i,s,n) for(int i = s; i < (n); ++i)
#define rsrep(i,s,n) for(int i = (n)-1; i >= s; --i)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define aall(a) (a), (a)+countof(a)
#define raall(a) (a), (a)+countof(a), greater<>()
#define show(x) cout<<#x<<" = "<<(x)<<endl;
#define vfind(v, a) find(all(v), a) != v.end()
#define yn(f) { if (f) puts("YES"); else puts("NO"); }
#define yns(f) { if (f) puts("Yes"); else puts("No"); }
#define show_ary(...) { cout<<#__VA_ARGS__<<" = "; for (const auto& x : (__VA_ARGS__)) { cout<<x<<" "; } cout<<endl; }
#define show_pair(...) cout<<#__VA_ARGS__<<" = "<<endl; for (const auto& x : (__VA_ARGS__)) { cout<<" "<<x.fi<<" : "<<x.se<<endl; }
#define out_ary(...) { int n = (__VA_ARGS__).size(); rep(i, n) printf("%d%s", (__VA_ARGS__)[i], i != n-1 ? " " : "\n"); }
#define argmax(v) distance((v).begin(), max_element(all(v)))
#define argmin(v) distance((v).begin(), min_element(all(v)))
#define vmax(v) *max_element(all(v))
#define vmin(v) *min_element(all(v))
typedef long long int ll;
typedef pair<int, int> P;
typedef vector<P> vpair;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef vector<double> vdouble;
typedef vector<string> vstr;
typedef vector<bool> vbool;
typedef vector<vint> vvint;
typedef vector<vll> vvll;
typedef vector<vstr> vvstr;
typedef vector<vbool> vvbool;
const ll LINF = 2000000000000000000ll;
const int INF = 1000000100;
const ll MOD = 1e9+7;
int main() {
string s;
cin >> s;
int n = s.length();
string ans = "";
if (n == 26) {
string tmp = s;
next_permutation(all(tmp));
rep(i, 26) {
if (s[i] != tmp[i]) {
ans = tmp.substr(0, i+1);
break;
}
}
if (ans == "a") ans = "-1";
}
else {
vbool c(26, false);
rep(i, n) c[s[i]-'a'] = true;
ans = s;
rep(i, 26) {
if (!c[i]) {
ans += i+'a';
break;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <stdio.h>
#include <math.h>
#include <cstdio>
#include <string>
#include <algorithm>
#pragma GCC optimize("Ofast")
#define REP(i, n) for (ll i = 0; i < ll(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= ll(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= ll(b); i--)
#define FORA(i, I) for (const auto &i : I)
#define ALL(x) x.begin(), x.end()
#define SIZE(x) ll(x.size())
#define INF 1000000000000
#define MOD 1000000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
typedef long long ll;
using namespace std;
int main()
{
int N;
cin >> N;
vector<int> A(N);
REP(i, N) { cin >> A[i]; }
int ans = *max_element(A.begin(), A.end()) - *min_element(A.begin(), A.end());
cout << ans;
return 0;
}
| 0
| 24,436,292
|
#include <iostream>
using namespace std;
int main(int argc, char const *argv[])
{
int a, b;
cin >> a >> b;
if (a < b) cout << 'a' << ' ' << '<' << ' ' << 'b' << endl;
else if (a > b) cout << 'a' << " > " << 'b' << endl;
else cout << 'a' << " == " << 'b' << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll MOD = 1'000'000'007;
const ld PI = acos(-1);
const ld EPS = 0.0000000001;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define rep(i, n) for(ll i=0; i<(ll)(n); i++)
#define repd(i, n) for(ll i=n-1; 0<=i; i--)
#define FOR(i, a, b) for(ll i=a; i<(ll)(b); i++)
#define FORD(i, a, b) for(ll i=a-1; (ll)(b)<=i; i--)
#define ALL(x) x.begin(), x.end()
#define rALL(x) x.rbegin(), x.rend()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main(){
ll n; cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
ll res=0;
rep(i, n){
while(0<a[i]){
FOR(j, i, n){
if(!a[j]) break;
a[j] -= 1;
}
res += 1;
}
}
cout << res << endl;
}
| 0
| 88,833,883
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
typedef long long int ll;
const int E_MAX = 102;
const int K_MAX = 4;
string n;
int k;
ll Choice(int l, int t){
if (t < 0)return 0;
ll ans = 1;
for(int i = 0; i < t; i++)ans *= (l-i);
for(int j = 1; j <= t; j++)ans /= j;
return ans;
}
ll pow(int l, int t){
ll ans = 1;
for(int i = 0; i < t; i++)ans *= l;
return ans;
}
int main(){
cin >> n >> k;
int e = n.length();
ll ans = 0;
for(int i = k; i >= 0; i--){
int res = i;
int now = 0;
while(res > 0 && now < e){
if (n[now] != '0')res--;
now++;
}
while(n[now] == '0' && now < e)now++;
if (now == e && res != 0)continue;
else if (now == e){
if (i == k)ans++;
continue;
}
int num = n[now] - '0';
ans += ((ll)num - 1) * Choice(e-1-now, k-i-1) * pow(9, k-i-1) + Choice(e-1-now, k-i) * pow(9, k-i);
}
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
using namespace std;
int a[100010],n,l;
int main(){
int pos=0;
scanf("%d%d",&n,&l);
for (int i=1; i<=n; i++){
scanf("%d",&a[i]);
if (a[i]+a[i-1]>=l) pos=i;
}
if (!pos) printf("Impossible\n");
else{
printf("Possible\n");
for(int i=n-1;i>=pos;i--)
printf("%d\n",i);
for(int i=1;i<pos;i++)
printf("%d\n",i);
}
return 0;
}
| 0
| 88,879,118
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.