code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 2
101M
|
|---|---|---|---|
#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include<set>
#include<map>
using namespace std;
int main() {
int a;
cin >> a;
if(a == 25){
cout << "Christmas";
}
else if(a == 24){
cout << "Christmas Eve";
}
else if(a == 23){
cout << "Christmas Eve Eve";
}
else{
cout << "Christmas Eve Eve Eve";
}
cout << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int N,M; cin >> N >> M;
int num[10]={2,5,5,4,5,6,3,7,6};
int a[M];
for(int i=0;i<M;i++) cin >> a[i];
string dp[11000];
for(int i=0;i<=N;i++) dp[i]="-";
dp[0]="";
for(int i=0;i<=N;i++){
for(int j=0;j<M;j++){
if(dp[i]=="-") continue;
int x=dp[i+num[a[j]-1]].size();
int y=(dp[i]+to_string(a[j])).size();
if(dp[i+num[a[j]-1]]=="-"){
dp[i+num[a[j]-1]]=dp[i]+to_string(a[j]);
}else if(x<y){
dp[i+num[a[j]-1]]=dp[i]+to_string(a[j]);
}else if(x==y&&dp[i+num[a[j]-1]]<(dp[i]+to_string(a[j]))){
dp[i+num[a[j]-1]]=dp[i]+to_string(a[j]);
}
}
}
cout << dp[N] << endl;
} | 0 | 12,518,044 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for( int i=a; i<b; i++ )
#define REP(i,n) rep(i,0,n)
#define INF 1000000
using lli = long long int;
using ulli = unsigned long long int;
typedef pair<int, int> P;
struct edge{ int u, v; lli cost; };
struct DirectedGraph
{
int vertex_num;
int edge_num;
vector<edge> edge_list;
vector< vector<int> > adj_list;
vector< vector<lli> > distance_matrix;
};
template <typename T>
vector<int> argsort(const vector<T> &v) {
vector<int> idx(v.size());
iota(idx.begin(), idx.end(), 0);
sort(idx.begin(), idx.end(),
[&v](int i1, int i2) {return v[i1] < v[i2];});
return idx;
}
template<typename T>
void displayVector(vector<T> v)
{
lli n = v.size();
REP(i,n){
cout << v[i] << " " ;
}
cout << endl;
}
int count_comb(int a, int b, int c){
if(a!=b && b!=c){ return 6; }
else if( a==b && b==c){ return 1; }
else{ return 3; }
}
string sub(string str, int start, int end){
return str.substr(start, end-start+1);
}
struct C{ int a; int b; };
int main(){
lli n, k; cin >> n >> k;
vector<C> vec(n);
REP(i, n){ cin >> vec[i].a >> vec[i].b; }
sort(vec.begin(), vec.end(),
[](C c1, C c2) {return c1.a < c2.a;} );
lli now=0;
REP(i,n){
now += vec[i].b;
if( k<=now ){
cout << vec[i].a << endl;
break;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ALL(x) (x).begin(),(x).end()
#define COUT(x) cout<<(x)<<"\n"
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define REP(i,n) for(int i=0;i<n;i++)
#define YES(x) cout<<(x?"YES":"NO")<<"\n"
#define Yes(x) cout<<(x?"Yes":"No")<<"\n"
#define dump(x) cout<<#x<<" = "<<(x)<<"\n"
#define endl "\n"
using G = vector<vector<int>>;
using M = map<int,int>;
using P = pair<int,int>;
using PQ = priority_queue<int>;
using PQG = priority_queue<int,vector<int>,greater<int>>;
using V = vector<int>;
using ll = long long;
using edge = struct { int to; int cost; };
template<class T>bool chmax(T &a,const T &b) {if(a<b){a=b; return 1;} return 0;}
template<class T>bool chmin(T &a,const T &b) {if(b<a){a=b; return 1;} return 0;}
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
int a,b;
const int mx = 100;
const int h=mx,w=mx;
char g[h][w];
int main() {
IOS;
cin >> a >> b;
a--; b--;
REP(i,h) {
char c = i<h/2 ? '#' : '.';
REP(j,w) g[i][j] = c;
}
int swaped = 0;
for (int i = 0; i < h; i+=2) {
if (h/2 < i) {
if (swaped == 0) {
swap(a,b);
swaped = 1;
}
}
for (int j = 0; j < w; j+=2) {
if (a>0) {
g[i][j] = g[i][j] == '.' ? '#' : '.';
a--;
}
}
}
cout << h << " " << w << endl;
REP(i,h) REP(j,w) {
cout << g[i][j];
j == w-1 && cout << endl;
}
return 0;
} | 0 | 3,091,207 |
#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
#define pb push_back
#define mpr make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
#define ll long long
#define ld long double
#define all(arr) arr.begin(), arr.end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define fo(i, l, r) for (int i = l; i <= r; i++)
#define INF 1000000001
#define inf1 1000000000000000001
#define mod 1000000007
#define pie 3.14159265358979323846264338327950L
#define N 100005
#define mid(l, r) l + (r - l) / 2
#define vec vector<int>
#define vecl vector<ll>
#define umap unordered_map<ll,ll>
#define yes cout << "YES" << endl;
#define no cout << "NO" << endl;
#define endl "\n"
using namespace std;
int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
int ddx[8]={1,1,0,-1,-1,-1,0,1},ddy[8]={0,1,1,1,0,-1,-1,-1};
ll gcd(ll a,ll b){ if(!a)return b;return gcd(b%a,a);}
ll lcm(ll a, ll b) { return (a*b)/ gcd(a,b);}
void test_case() {
int n;
cin>>n;
vec arr(n);
rep(i,n) {
cin>>arr[i];
}
int ans = INT_MAX;
for(int i=0; i<=100; i++) {
int j=0;
for(auto it : arr) {
j+= (it-i) * (it - i);
}
ans = min(ans, j);
}
cout<<ans<<endl;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout<<fixed<<setprecision(20);
int t = 1;
while(t--)
{
test_case();
}
} | #include <sstream>
#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <iostream>
#include <utility>
#include <set>
#include <cctype>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
using namespace std;
#define INF 100000000
typedef long long ll;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
int dp[1010][1010];
int main(void) {
int n;
cin >> n;
while (n--) {
string a, b;
cin >> a;
cin >> b;
for (int i = 0; i < 1010; i++) {
for (int j = 0; j < 1010; j++) {
dp[i][j] = 0;
}
}
for (int i = 1; i <= a.size(); i++) {
for (int j = 1; j <= b.size(); j++) {
if (a[i-1] == b[j-1]) {
dp[i][j] = max(dp[i-1][j-1] + 1, max(dp[i-1][j], dp[i][j-1]));
} else {
dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
}
}
}
cout << dp[a.size()][b.size()] << endl;
}
return 0;
} | 0 | 82,662,029 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define irep(i, n) for (int i = (n); i >= 0; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1 << 25;
const int MOD = 1e9+7;
ll c[200100], d[200100];
int main() {
int m;
cin >> m;
rep(i,m) cin >> d[i] >> c[i];
ll s = 0, len = 0;
rep(i,m) {
s += c[i] * d[i];
len += c[i];
}
ll ans = (len-1) + ((s-1)/9);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i,n) for(int i = 0; i < (int)(n); ++i)
using namespace std;
int flag = 1;
int main(){
cin >> flag;
while(flag){
int temp = 0, score = 0;
int M = 0, m = 1000;
REP(i,flag){
cin >> temp;
score += temp;
M = max(temp,M);
m = min(temp,m);
}
cout << (score-M-m)/(flag-2) << endl;
cin >> flag;
}
return 0;
} | 0 | 84,030,331 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
template<class T> bool chmin(T &a, T b) {if(a>b) {a=b;return 1;}return 0;}
using namespace std;
using ll = long long;
const int inf = 1e8;
int dp[105][105];
int main() {
int n;
cin >> n;
vector<int> p(n+1);
cin >> p[0] >> p[1];
rep(i,n-1) {
int a, b;
cin >> a >> b;
p[i+2] = b;
}
rep(i,105)rep(j,105) dp[i][j] = inf;
rep(i,n+1) dp[i][i] = 0;
for (int i = n-1; i >= 1; i--) {
for (int j = i+1; j <= n; j++) {
if (j == i+1) dp[i][j] = p[i-1]*p[i]*p[i+1];
else {
for (int k = i; k <= j-1; k++) {
dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j]+p[i-1]*p[k]*p[j]);
}
}
}
}
cout << dp[1][n] << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N,K;
int64_t Z=0;
cin>>N>>K;
vector<int> p(N);
for(int i=0;i<N;i++){
cin>>p[i];
p[i]--;
}
vector<int> q(N+1);
map<int,int> m;
m[0]=1;
for(int i=0;i<N;i++){
int j=i+1-K;
if(j>=0){
m[q[j]]--;
}
q[i+1]=(q[i]+p[i])%K;
if(m.count(q[i+1])){
m[q[i+1]]++;
}
else{
m[q[i+1]]=1;
}
Z+=m[q[i+1]]-1;
}
cout<<Z<<endl;
} | 0 | 5,818,175 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<math.h>
using namespace std;
int main(){
int f=1,i;
int foot[2];
foot[0]=0;
foot[1]=0;
int ans=0,N;
string x;
while (1){
cin >>N;
ans=0;
f=1;
foot[0]=0;
foot[1]=0;
if(N==0)break;
for(i=0;i<N;i++){
cin >> x;
if(x=="lu"){
foot[0]++;
if(f==1 && foot[1]==1){
ans++;
f=0;
}
}
else if(x=="ru"){
foot[1]++;
if(f==1 && foot[0]==1){
ans++;
f=0;
}
}
else if(x=="ld"){
foot[0]--;
if(f==0 && foot[1]==0){
ans++;
f=1;
}
}
else{
foot[1]--;
if(f==0 && foot[0]==0){
ans++;
f=1;
}
}
}
cout << ans <<endl;
}
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
template <class Abel> struct BIT {
vector<Abel> dat[2];
Abel UNITY_SUM = 0;
BIT(int n) { init(n); }
void init(int n) { for (int iter = 0; iter < 2; ++iter) dat[iter].assign(n + 1, UNITY_SUM); }
inline void sub_add(int p, int a, Abel x) {
for (int i = a; i < (int)dat[p].size(); i += i & -i)
dat[p][i] = dat[p][i] + x;
}
inline void add(int a, int b, Abel x) {
sub_add(0, a, x * -(a - 1)); sub_add(1, a, x); sub_add(0, b, x * (b - 1)); sub_add(1, b, x * (-1));
}
inline Abel sub_sum(int p, int a) {
Abel res = UNITY_SUM;
for (int i = a; i > 0; i -= i & -i) res = res + dat[p][i];
return res;
}
inline Abel sum(int a, int b) {
return sub_sum(0, b - 1) + sub_sum(1, b - 1) * (b - 1) - sub_sum(0, a - 1) - sub_sum(1, a - 1) * (a - 1);
}
void print() {
for (int i = 1; i < (int)dat[0].size(); ++i) cout << sum(i, i + 1) << ",";
cout << endl;
}
};
using pll = pair<long long, long long>;
int N;
long long D, A;
vector<long long> X, H;
long long solve() {
vector<int> ids(N);
for (int i = 0; i < N; ++i) ids[i] = i;
sort(ids.begin(), ids.end(), [&](int i, int j) {
return X[i] < X[j]; });
vector<long long> nX(N), nH(N);
for (int i = 0; i < N; ++i) nX[i] = X[ids[i]], nH[i] = H[ids[i]];
X = nX, H = nH;
BIT<long long> bit(N+10);
for (int i = 0; i < N; ++i) bit.add(i+1, i+2, H[i]);
long long res = 0;
for (int i = 0; i < N; ++i) {
long long cur = bit.sum(i+1, i+2);
if (cur <= 0) continue;
long long need = (cur + A - 1) / A;
long long right = X[i] + D * 2;
int id = upper_bound(X.begin(), X.end(), right) - X.begin();
bit.add(i+1, id+1, -need * A);
res += need;
}
return res;
}
int main() {
cin >> N >> D >> A;
X.resize(N); H.resize(N);
for (int i = 0; i < N; ++i) cin >> X[i] >> H[i];
cout << solve() << endl;
} | 0 | 31,014,155 |
#include<iostream>
#include<stdio.h>
using namespace std;
int main(){
int W, H, x, y, r;
cin >> W >> H >> x >> y >> r;
if (x < 0 || y < 0 || x > W || y > H || x - r < 0 || y - r < 0
|| x+r>W||y+r>H){
cout << "No" << endl;
}
if (x > 0 && y > 0 && x < W && y < H && x - r >= 0 && y - r >= 0
&& x + r<=W && y + r<=H){
cout << "Yes" << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define f(i,n) for(int i=0;i<(n);i++)
#define inf (int)(3e18)
#define int long long
#define mod (int)(1000000007)
#define intt long long
using namespace std;
int modpow(int x, int y, int m = mod) {
int res = 1;
while (y) {
if (y % 2) {
res *= x;
res %= m;
}
x = x * x % mod;
y /= 2;
}
return res;
}
int mypow(int x, int y) {
int res = 1;
while (y) {
if (y % 2) {
res *= x;
}
x = x * x;
y /= 2;
}
return res;
}
bool prime(int x) {
for (int i = 2; i * i <= x; i++) {
if (!(x % i)) {
return false;
}
}
return true;
}
double kyori(pair<int, int> f, pair<int, int> s) {
double ans = 0;
double t = fabs(f.first - s.first);
double y = fabs(f.second - s.second);
ans = sqrt(t * t + y * y);
return ans;
}
int gcd(int x, int y) {
if (!y) {
return x;
}
return gcd(y, x % y);
}
class Union_Find {
vector<int> par;
vector<int> rankmy;
public:
Union_Find(int size) {
par = vector<int>(size);
rankmy = vector<int>(size);
for (int i = 0; i < size; i++) {
par[i] = i;
}
}
int find(int x) {
if (par[x] == x) {
return x;
}
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
return;
}
if (rankmy[x] < rankmy[y]) {
par[x] = y;
}
else {
par[y] = x;
if (rankmy[x] == rankmy[y]) {
rankmy[x]++;
}
}
}
bool same(int x, int y) {
return find(x) == find(y);
}
};
template <class T>
class SegTree {
int n;
vector<T> data;
T def;
function<T(T, T)> operation;
function<T(T, T)> update;
T _query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) return def;
if (a <= l && r <= b)
return data[k];
else {
T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2);
T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r);
return operation(c1, c2);
}
}
public:
SegTree(size_t _n, T _def, function<T(T, T)> _operation,
function<T(T, T)> _update)
: def(_def), operation(_operation), update(_update) {
n = 1;
while (n < _n) {
n *= 2;
}
data = vector<T>(2 * n - 1, def);
}
void change(int i, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
T query(int a, int b) {
return _query(a, b, 0, 0, n);
}
T operator[](int i) {
return data[i + n - 1];
}
};
#define R_MIN ([](long long a, long long b) { return min(a, b); })
#define R_MAX ([](long long a, long long b) { return max(a, b); })
#define R_SUM ([](long long a, long long b) { return a + b; })
#define NORMAL_UPDATE ([](long long a, long long b) { return b; })
#define ADD_UPDATE ([](long long a, long long b) { return a + b; })
#define MINUS_UPDATE ([](long long a, long long b) { return a - b; }
vector<int> v[100004];
bool went[100004];
void dfs(int x) {
went[x] = true;
for (int i = 0; i < (int)v[x].size(); i++) {
if (!went[v[x][i]]) {
dfs(v[x][i]);
}
}
}
int keta(int x) {
int ans = 0;
while (x) {
x /= 10;
ans++;
}
return ans;
}
int ketasum(int x) {
int ans = 0;
while (x) {
ans += x % 10;
x /= 10;
}
return ans;
}
int lcm(int x, int y) {
int ans = x / gcd(x, y) * y;
return ans;
}
int twobeki(int x) {
int ans = 0;
while (1) {
if (!(x & 1)) {
ans++;
x /= 2;
}
else {
break;
}
}
return ans;
}
int kai(int x, int y) {
int res = 1;
for (int i = x - y + 1; i <= x; i++) {
res *= i; res %= mod;
}
return res;
}
int comb(int x, int y) {
if (y > x)return 0;
return kai(x, y) * modpow(kai(y, y), mod - 2) % mod;
}
int fukugen(vector<int> l) {
int ans = 0;
for (int i = 0; i < (int)l.size(); i++) {
ans *= 10;
ans += l[i];
}
return ans;
}
#define rep(i,n) for(int i=0;i<n;i++)
int n,l,a[100004],h;
signed main(){
cin>>n>>l;
for(int i=1;i<=n;i++){
cin>>a[i];
}
h=-100;
for(int i=1;i<n ;i++){
if (a[i]+a[i+1]>=l) {
h=i;
break;
}
}
if (h!=-100) {
cout<<"Possible"<<endl;
for(int i=1; i<h ;i++){
cout<<i<<endl;
}
for (int i=n-1; i>=h+1; i--) {
cout<<i<<endl;
}
cout<<h<<endl;
}else{
cout<<"Impossible"<<endl;
}
} | 0 | 53,084,124 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
using P = pair<int, int>;
using vec = vector<int>;
using mat = vector<vector<int>>;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define endl "\n"
constexpr int MOD = 1000000007;
const int INF = 1 << 30;
int n;
vec c, s, f;
void solve(int start) {
if (start == n-1) {
cout << 0 << endl;
return;
}
int res = 0;
rep(i, n-1) {
if (i < start) continue;
if (res < s[i]) res = s[i];
else {
if (res % f[i] != 0) {
res += f[i] - (res % f[i]);
}
}
res += c[i];
}
cout << res << endl;
}
int main() {
cin >> n;
if (n == 1) {
cout << 0 << endl;
exit(0);
}
c.resize(n-1);
s.resize(n-1);
f.resize(n-1);
rep(i, n-1) cin >> c[i] >> s[i] >> f[i];
rep(i, n) solve(i);
return 0;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VLL = vector<LL>;
using VVLL = vector<VLL>;
using VS = vector<string>;
using PII = pair<int,int>;
using VP = vector<PII>;
#define REP(i,m,n) for(LL i=(m);i<(n);i++)
int main(){
LL h,w;
cin >> h >> w;
VS a(h);
REP(i,0,h){
cin >> a[i];
}
REP(i,0,h){
bool white = true;
REP(j,0,w){
if(a[i][j] != '.'){
white = false;
}
}
if(white){
a.erase(a.begin() + i);
h--;
i--;
}
}
REP(j,0,w){
bool white = true;
REP(i,0,h){
if(a[i][j] != '.'){
white = false;
}
}
if(white){
REP(cnt,0,h){
a.at(cnt).erase(a.at(cnt).begin() + j);
}
w--;
j--;
}
}
REP(i,0,h){
cout << a[i] << endl;
}
return 0;
} | 0 | 17,217,333 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using P =pair<ll,ll>;
const ll INF =ll(1e18)+5;
int main() {
ll N;
cin >> N;
vector<ll> v(N);
map<ll,ll> oddMp;
map<ll,ll> evenMp;
for(int i=0;i<N;i++){
cin >> v[i];
if(i %2 ==0){
oddMp[v[i]]++;
}else{
evenMp[v[i]]++;
}
}
vector<P> oddP,evenP;
for(auto itr = oddMp.begin();itr != oddMp.end();++itr){
oddP.emplace_back(itr->second,itr->first);
}
for(auto itr = evenMp.begin();itr != evenMp.end();++itr){
evenP.emplace_back(itr->second,itr->first);
}
sort(oddP.rbegin(),oddP.rend());
sort(evenP.rbegin(),evenP.rend());
ll ans = INF;
for(int i=0;i<2;i++){
for(int j=0;j<2;j++){
int oddNum=0;
ll oddValue =0;
int evenNum =0;
ll evenValue =0;
if(oddP.size()>i){
oddNum = oddP[i].second;
oddValue = oddP[i].first;
}
if(evenP.size()>j){
evenNum = evenP[j].second;
evenValue = evenP[j].first;
}
if(evenNum == oddNum){
continue;
}
ans = min(ans,N-oddValue-evenValue);
}
}
cout << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
class Dice{
private:
int top, bottom, north, east, west, south;
public:
void setNumber(){
int n1, n2, n3, n4, n5, n6;
cin >> n1 >> n2 >> n3 >> n4 >> n5 >> n6;
top = n1;
south = n2;
east = n3;
west = n4;
north = n5;
bottom = n6;
}
void roll(){
string command;
cin >> command;
for(int i = 0; i < command.length(); i++){
switch(command[i]){
case 'N': rollNorth(); break;
case 'E': rollEast(); break;
case 'W': rollWest(); break;
case 'S': rollSouth(); break;
}
}
}
void rollNorth(){
int tmp = north;
north = top;
top = south;
south = bottom;
bottom = tmp;
}
void rollEast(){
int tmp = east;
east = top;
top = west;
west = bottom;
bottom = tmp;
}
void rollWest(){
int tmp = west;
west = top;
top = east;
east = bottom;
bottom = tmp;
}
void rollSouth(){
int tmp = south;
south = top;
top = north;
north = bottom;
bottom = tmp;
}
void rotateClockwise(){
int tmp = south;
south = east;
east = north;
north = west;
west = tmp;
}
int getTop(){
return top;
}
int getFront(){
return south;
}
int getRight(){
return east;
}
};
int main(){
Dice dice;
dice.setNumber();
int q;
cin >> q;
for(int i = 0; i < q; i++){
int top, front;
cin >> top >> front;
while(true){
if(dice.getTop() == top) break;
dice.rollNorth();
if(dice.getTop() == top) break;
dice.rollEast();
}
while(dice.getFront() != front){
dice.rotateClockwise();
}
cout << dice.getRight() << endl;
}
return 0;
} | 0 | 34,401,028 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define printVec(v) printf("{"); for (const auto& i : v) { std::cout << i << ", "; } printf("}\n");
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
using namespace std;
using P = pair<int,int>;
using ll = long long;
const ll INF = 1LL<<60;
const double PI = 3.1415926535897932;
const int MOD = 1e9 + 7;
int main() {
ll n, k;
cin >> n >> k;
ll ans = 0;
while (k <= n + 1) {
ll head = k * (k - 1) / 2;
ll tail = k * ((2 * n) - (k - 1)) / 2;
ans += (tail - head + 1);
ans %= MOD;
k++;
}
cout << ans << endl;
return 0;
} | #include<vector>
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
using namespace std;
#define N 100010
#define int long long
#define debug cout<<__LINE__<<" "<<__FUNCTION__<<"\n"
inline int read(){
int x=0,y=1;
char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')y=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}
return x*y;
}
void put(int x){
if(x<0) putchar('-'),x=-x;
if(x>=10) put(x/10);
putchar((x%10)+48);
}
int n,a[N],id[N],siz[N],fa[N];
inline int find(int x){
return x==fa[x]?x:fa[x]=find(fa[x]);
}
inline int cmp(const int&A,const int&B){
return a[A]<a[B];
}
vector<int> l[N];
int dfs(int x){
int num=siz[x]-1;
for(int i=0;i<l[x].size();i++) num+=dfs(l[x][i]);
return num;
}
signed main(){
n=read();
for(int i=1;i<=n;i++){
a[i]=read();id[i]=fa[i]=i;siz[i]=1;
}
sort(id+1,id+n+1,cmp);sort(a+1,a+n+1);
int root=0;
for(int i=n,pos,fx;i>=1;i--){
fx=find(i);
pos=lower_bound(a+1,a+n+1,a[i]-n+2*siz[i])-a;
while(pos<=n&&fx==find(pos)) ++pos;
if(a[pos]!=a[i]-n+2*siz[i]){
if(!root){
root=i;
continue;
}
puts("-1");
return 0;
}
siz[pos]+=siz[i];
l[pos].push_back(i);
fa[fx]=find(pos);
}
int res=dfs(root);
if(res!=a[root]){
puts("-1");
return 0;
}
for(int i=1;i<=n;i++){
for(int j=0;j<l[i].size();j++) cout<<id[i]<<" "<<id[l[i][j]]<<"\n";
}
return 0;
} | 0 | 15,563,600 |
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int INF=1e9+7,MAXK=1e5+10;
int K;
bool vis[MAXK];
deque<pair<int,int> > dq;
int main(){
scanf("%d",&K);
dq.push_front(make_pair(1,1));
while(dq.size()){
pair<int,int> cur=dq.front();
dq.pop_front();
vis[cur.first]=1;
if(!cur.first){
printf("%d",cur.second);
return 0;
}
if(!vis[cur.first*10%K])
dq.push_front(make_pair(cur.first*10%K,cur.second));
if(!vis[(cur.first+1)%K])
dq.push_back(make_pair((cur.first+1)%K,cur.second+1));
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair< ll, ll > Pi;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep2(i,n) for(int i=1;i<=(n);i++)
#define rep3(i,i0,n) for(int i=i0;i<(n);i++)
#define pb push_back
#define mod 1000000007
const ll INF = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll a, ll b) {return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) {return a/gcd(a,b)*b;}
#define all(x) x.begin(), x.end()
#define mp make_pair
bool compare(Pi a, Pi b) {
if(a.first != b.first){
return a.first < b.first;
}else{
return a.second < b.second;
}
}
bool In_map(ll y,ll x,ll h,ll w){
if(y<0 || x<0 || y>=h || x>=w){
return 0;
}else{
return 1;
}
}
const vector<ll> dx{1,0,-1,0};
const vector<ll> dy{0,1,0,-1};
int main() {
ll N;
cin >>N;
vector<ll> A(N);
vector<ll> m(N+5);
vector<ll> cm(N+5);
rep(i,N){
ll a;
cin>>a;
a--;
A[i] = a;
m[a]++;
}
ll sum = 0;
rep(i,N){
cm[i] = m[i]*(m[i]-1)/2;
sum+=cm[i];
}
rep(i,N){
cout << sum - m[A[i]]*(m[A[i]]-1)/2 + (m[A[i]]-2)*(m[A[i]]-1)/2 << endl;
}
return 0;
} | 0 | 40,162,218 |
#include <stdio.h>
#include <stdlib.h>
int main(void){
int a;
int b;
int c;
int d;
scanf("%d %d %d %d",&a,&b,&c,&d);
if (abs(a-c)<=d){
printf("Yes\n");
}else if(abs(a-b)<=d && abs(b-c)<=d){
printf("Yes\n");
}else{
printf("No\n");
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef pair<int, int> pi;
const int MAXN = 100005;
int n, m;
vector<pi> gph[MAXN];
bool vis[MAXN], bad;
int col[MAXN];
void dfs(int x, int c){
if(vis[x]){
if(col[x] != c) bad = 1;
return;
}
vis[x] = 1;
col[x] = c;
for(auto &i : gph[x]) dfs(i.second, c + i.first);
}
int main(){
scanf("%d %d",&n,&m);
for(int i=0; i<m; i++){
int s, e, x; scanf("%d %d %d",&s,&e,&x);
gph[s].emplace_back(x, e);
gph[e].emplace_back(-x, s);
}
for(int i=1; i<=n; i++){
if(!vis[i]){
dfs(i, 0);
}
}
puts(!bad ? "Yes" : "No");
} | 0 | 91,757,169 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int main() {
string S, T;
cin >> S >> T;
int ans = T.size();
for (int i = 0; i <= S.size() - T.size(); i++) {
int diff = 0;
rep(j, T.size()) {
if (T[j] != S[i + j]) diff++;
}
ans = min(ans, diff);
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <string>
#include <map>
#include <set>
#include <vector>
#include <utility>
#include <queue>
#include <stack>
#include <math.h>
#include <algorithm>
#define ll long long
#define add push_back
using namespace std;
ll fact(ll n){
ll answ = 1;
for( int i = 1; i <= n; i++){
answ *= i;
}
return answ;
}
ll c(ll n, ll m){
return fact(n) / (fact(m) * fact(n - m));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int t; t = 1;
while(t--){
string s,str; cin >> s >> str;
int answ = 0;
for(int i = 0; i < s.length(); i++){
if(s[i] != str[i]) answ++;
}
cout << answ << endl;
}
return 0;
} | 0 | 74,668,815 |
#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
#include<algorithm>
#define rep(i,n) for (int i = 0;i < (n);i++)
#define all(v) v.begin(),v.end()
#define dec(n) cout << fixed << setprecision(n);
#define large "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
#define small "abcdefghijklmnopqrstuvwxyz"
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using vl = vector<ll>;
using vvl = vector<vl>;
ll gcd(ll a,ll b){
if(b == 0) return a;
return gcd(b , a % b);
}
const ll MOD = 1000000007;
const ll MAX = 2000001;
ll mod(ll a){
return a % MOD;
}
ll lcm(ll a,ll b){
return (a*b)/gcd(a,b);
}
ll fac[MAX], finv[MAX], inv[MAX];
void nCrprep() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll nCr(ll n, ll r){
if (n < r) return 0;
if (n < 0 || r < 0) return 0;
return fac[n] * (finv[r] * finv[n - r] % MOD) % MOD;
}
ll nCrcheep(ll n,ll r){
if(r == 0) return 1;
else if(r == 1) return n;
else return nCrcheep(n-1,r-1)*n/r;
}
vector<pair<ll,ll>> prime_factorize(ll n){
vector<pair<ll,ll>> res;
for(ll i=2; i*i <= n; i++){
if(n % i != 0) continue;
ll ex = 0;
while(n % i == 0){
ex++;
n /= i;
}
res.push_back({i,ex});
}
if(n != 1) res.push_back({n,1});
return res;
}
int main(){
ll n; cin >> n; ll sum = 0;
vector<pair<string,ll>> table(n+1);
for(ll i=1; i <= n; i++){
string s; ll x; cin >> s >> x; sum += x;
table[i] = make_pair(s,x+table[i-1].second);
}
string sleep; cin >> sleep;
for(auto p : table){
if(p.first == sleep){
cout << sum - p.second << endl;
return 0;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rep2(i,s,n) for(int i = (s); i < (n); ++i)
#define ll long long
#define ld long double
#define P pair<ll,ll>
#define all(v) v.begin(),v.end()
const ll mod = 1e9+7;
const ll INF = 1e18;
const double pi = acos(-1.0);
int main(void)
{
ll w,h,n; cin>>w>>h>>n;
ll ans,x1=0,x2=w,y1=0,y2=h;
rep(i,n){
ll x,y,a;
cin>>x>>y>>a;
if(a==1) x1=max(x1,x);
if(a==2) x2=min(x2,x);
if(a==3) y1=max(y1,y);
if(a==4) y2=min(y2,y);
}
if(x1>=x2||y1>=y2) ans=0;
else ans=(x2-x1)*(y2-y1);
cout<<ans<<endl;
return 0;
} | 0 | 4,427,541 |
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0;i < (n);i++)
using ll = long long;
const ll MOD=1000000007;
int main()
{
ll N; cin>>N;
vector<ll> vecA(N);
rep(i,N)
{
cin>>vecA.at(i);
}
sort(vecA.begin(),vecA.end());
reverse(vecA.begin(),vecA.end());
ll L=0;
rep(i,N-1)
{
if(vecA.at(i)==vecA.at(i+1))
{
if(L==0) {L=vecA.at(i); i++; continue;}
cout<<L*vecA.at(i)<<endl; return 0;
}
}
cout<<0<<endl;
return 0;
} | #include<vector>
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include <iostream>
#include <algorithm>
#include <map>
#include <cmath>
#include<queue>
#include <sstream>
#include <set>
const long long INF = 1000000007;
using namespace std;
typedef long long llong;
int main(){
llong N;
cin >> N;
for(int i=0; i<=30; i++){
for(int j=0; j<=30; j++){
if(i*4+j*7==N){
cout << "Yes" <<endl;
exit(0);
}
}
}
cout << "No" << endl;
return 0;
} | 0 | 16,133,656 |
#include <iostream>
#include <map>
using namespace std;
int main(){
int dx[] = {1,0,-1,0,1,1,-1,-1}, dy[] = {0,1,0,-1,1,-1,1,-1};
int H, W, N;
cin >> H >> W >> N;
int a, b;
map<pair<int,int>, int> M;
for(int i = 0; i < N; ++i){
cin >> a >> b;
if(a > 1 && a < H && b > 1 && b < W){
++M[make_pair(a,b)];
}
for(int j = 0; j < 8; ++j){
int s = a + dx[j], t = b + dy[j];
if(s > 1 && s < H && t > 1 && t < W){
++M[make_pair(s,t)];
}
}
}
long long int ans[10], t = (long long int)(H-2)*(W-2);
fill(ans,ans+10,0LL);
for(map<pair<int,int>, int>::iterator itr = M.begin(); itr != M.end(); ++itr){
++ans[itr->second];
--t;
}
ans[0] = t;
for(int i = 0; i < 10; ++i){
cout << ans[i] << endl;
}
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <numeric>
using namespace std;
constexpr int64_t MOD = 998'244'353;
int main(void) {
int N;
cin >> N;
vector<int> D(N);
for(int i=0; i<N; i++) {
cin >> D[i];
}
if(D[0] != 0) {
cout << 0 << endl;
return 0;
}
vector<int64_t> num(N);
for(int i=0; i<N; i++) {
num[D[i]]++;
}
if(num[0] != 1) {
cout << 0 <<endl;
return 0;
}
int64_t ans = 1;
int max = *max_element(D.begin(), D.end());
for(int i=0; i<max; i++) {
for(int j=0; j<num[i+1]; j++) {
ans = (ans*num[i]) % MOD;
}
}
cout << ans << endl;
return 0;
} | 0 | 51,910,371 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int K, N;
cin >> K >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) cin >> A.at(i);
int mx = A.at(0) + (K - A.at(N - 1));
for (int i = 1; i < N; i++) {
mx = max(mx, A.at(i) - A.at(i - 1));
}
cout << K - mx << "\n";
} | #include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
using namespace std;
#define ll long long
const ll mod=1e9+7;
const int maxn=1e2+5;
const int maxk=1e5+5;
int a[maxn];
ll num[maxk],front[maxk];
void update(int k)
{
front[0]=num[0];
for(int i=1;i<=k;i++)
front[i]=(front[i-1]+num[i]-(front[i-1]+num[i]>=mod)*mod);
return;
}
ll query(int l,int r)
{
if(l==-1) return front[r];
else return (front[r]-front[l]+(front[r]-front[l]<0)*mod);
}
int main()
{
int n,k;
scanf("%d%d",&n,&k);
for(int i=1;i<=n;i++)
scanf("%d",&a[i]);
num[0]=1;
update(k);
for(int i=1;i<=n;i++)
{
memset(num,0,sizeof(num));
for(int j=0;j<=k;j++)
num[j]=query(max(0,j-a[i])-1,j);
update(k);
}
printf("%lld\n",num[k]);
return 0;
} | 0 | 21,299,210 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);++i)
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string S;
cin >> S;
if (S.substr(0,4) == "YAKI") cout << "Yes" << endl;
else cout << "No" << endl;
} | #include <fstream>
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <sstream>
#include <map>
#include <set>
#include <vector>
#include <stack>
#include <cmath>
#include <queue>
#include <random>
#include <numeric>
using namespace std;
#define I_MAX 2147483647
#define LL_MAX 9223372036854775807
#define ll long long
#define ld long double
struct XX{
string s;
int p;
int c1;
int c2;
int num;
};
class xxGreater {
public:
bool operator()(const XX& riLeft, const XX& riRight) const {
if((riLeft.s) == (riRight.s)){
return riLeft.p < riRight.p;
}
return (riLeft.s) < (riRight.s);
}
};
#ifdef DEBUG
#else
#endif
int main(int argc, const char * argv[])
{
ios::sync_with_stdio(false);
cin.tie(0);
int N,M;
cin>>N>>M;
vector<ll> a[100000];
for(int i=0;i<N;i++){
ll t1,t2;
cin>>t1>>t2;
t1--;
a[t1].push_back(t2);
}
priority_queue<ll> pque;
ll ans=0;
for(int i=0;i<M;i++){
for(auto s:a[i]){
pque.push(s);
}
if(!pque.empty()){
ans+=pque.top();
pque.pop();
}
}
cout << ans << endl;
return 0;
} | 0 | 5,263,933 |
#include <bits/stdc++.h>
using namespace std;
using Pair = pair<int64_t, int64_t>;
constexpr int64_t kInf = INT64_MAX / 2L;
struct Node {
int64_t value{0};
bool visited{false};
vector<int64_t> nexts;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int64_t N, Q;
cin >> N >> Q;
vector<Node> nodes(N);
for (int64_t i = 0; i < N - 1; ++i) {
int64_t a, b;
cin >> a >> b;
nodes[a - 1].nexts.emplace_back(b - 1);
nodes[b - 1].nexts.emplace_back(a - 1);
}
for (int64_t i = 0; i < Q; ++i) {
int64_t p, x;
cin >> p >> x;
nodes[p - 1].value += x;
}
queue<int64_t> q;
nodes[0].visited = true;
q.push(0);
while (!q.empty()) {
const int64_t n = q.front();
q.pop();
for (const int64_t next : nodes[n].nexts) {
if (!nodes[next].visited) {
nodes[next].value += nodes[n].value;
nodes[next].visited = true;
q.emplace(next);
}
}
}
for (int64_t i = 0; i < N; ++i) {
if (i != 0) {
cout << " ";
}
cout << nodes[i].value;
}
cout << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
using namespace std;
#define INF ((1<<30)-1)
#define LINF (1LL<<60)
#define EPS (1e-10)
typedef long long ll;
typedef pair<ll, ll> P;
const int MOD = 1000000007;
const int MOD2 = 998244353;
vector<int> v;
int main(){
int n;
cin >> n;
rep(i, 2*n){
int l;
cin >> l;
v.push_back(l);
}
sort(v.rbegin(), v.rend());
int ans = 0;
for (int i = 0; i < n; i++){
ans += v[2*i+1];
}
cout << ans << endl;
return 0;
} | 0 | 71,087,212 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double Double;
#define rep(i, n) for (int i = 0; i < (int)(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;
}
long long dp[310][310][310] = {};
void solve(long long N, long long K, std::vector<long long> H) {
for (int i = 0; i < 310; i++) {
for (int j = 0; j < 310; j++) {
for (int k = 0; k < 310; k++) {
dp[i][j][k] = 1e18;
}
}
}
H.insert(H.begin(), 0);
dp[1][0][0] = 0;
for (int i = 1; i < H.size(); i++) {
for (int j = 0; j < i; j++) {
for (int k = 0; k < i; k++) {
dp[i + 1][i][k + 1] = min(dp[i + 1][i][k + 1], dp[i][j][k] + max(0ll, H[i] - H[j]));
dp[i + 1][j][k] = min(dp[i + 1][j][k], dp[i][j][k]);
}
}
}
long long ans = 1e18;
for (int i = N - K; i <= N; i++) {
for (int j = 0; j < H.size(); j++) {
ans = min(ans, dp[H.size()][j][i]);
}
}
cout << ans << endl;
}
int main() {
long long N;
scanf("%lld", &N);
long long K;
scanf("%lld", &K);
std::vector<long long> H(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &H[i]);
}
solve(N, K, std::move(H));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using VI = vector<int>;
using VL = vector<ll>;
using VS = vector<string>;
using VB = vector<bool>;
using VVB = vector<vector<bool>>;
using VVI = vector<VI>;
using VVL = vector<VL>;
using PII = std::pair<int, int>;
using VPII = std::vector<std::pair<int, int>>;
using PLL = std::pair<ll, ll>;
using VPLL = std::vector<std::pair<ll, ll>>;
using TI3 = std::tuple<int, int, int>;
using TI4 = std::tuple<int, int, int, int>;
using TL3 = std::tuple<ll, ll, ll>;
using TL4 = std::tuple<ll, ll, ll, ll>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define rep3(i, s, n, d) for (int i = (s); i < (int)(n); i += (d))
#define allpt(v) (v).begin(), (v).end()
#define allpt_c(v) (v).cbegin(), (v).cend()
#define allpt_r(v) (v).rbegin(), (v).rend()
#define allpt_cr(v) (v).crbegin(), (v).crend()
const int mod1 = 1e9 + 7, mod2 = 998244353, mod3 = 1e9 + 9;
const int mod = mod1;
const ll inf = 1e18;
const string wsp = " ";
const string tb = "\t";
const string rt = "\n";
template <typename T>
void show1dvec(const vector<T> &v)
{
if (v.size() == 0)
return;
int n = v.size() - 1;
rep(i, n) cout << v[i] << wsp;
cout << v[n] << rt;
return;
}
template <typename T>
void show2dvec(const vector<vector<T>> &v)
{
int n = v.size();
rep(i, n) show1dvec(v[i]);
}
template <typename T, typename S>
void show1dpair(const vector<pair<T, S>> &v)
{
int n = v.size();
rep(i, n) cout << v[i].first << wsp << v[i].second << rt;
return;
}
template <typename T, typename S>
void pairzip(const vector<pair<T, S>> &v, vector<T> &t, vector<T> &s)
{
int n = v.size();
rep(i, n)
{
t.push_back(v[i].first);
s.push_back(v[i].second);
}
return;
}
template <typename T>
void maxvec(vector<T> &v)
{
T s = v[0];
int n = v.size();
rep(i, n - 1)
{
if (s > v[i + 1])
{
v[i + 1] = s;
}
s = v[i + 1];
}
}
template <typename T, typename S>
bool myfind(T t, S s)
{
return find(t.cbegin(), t.cend(), s) != t.cend();
}
bool check(int y, int x, int h, int w)
{
return 0 <= y && y < h && 0 <= x && x < w;
}
bool iskadomatsu(int a, int b, int c)
{
return (a != b && b != c && c != a) && ((a > b && b < c) || (a < b && b > c));
}
VS split(string s, char c)
{
VS ret;
string part;
s += c;
rep(i, s.length())
{
if (s[i] == c)
{
ret.emplace_back(part);
part = "";
}
else if (s[i] != c)
{
part += s[i];
}
}
return ret;
}
template <typename T, typename S, typename R>
ll pow_mod(T p, S q, R mod = 1ll)
{
ll ret = 1, r = p;
while (q)
{
if (q % 2)
ret *= r, ret %= mod;
r = (r * r) % mod, q /= 2;
}
return ret % mod;
}
template <typename T, typename S>
ll pow_no_mod(T p, S q)
{
ll ret = 1, r = p;
while (q)
{
if (q % 2)
ret *= r;
r = (r * r), q /= 2;
}
return ret;
}
void make_frac_tables(VL &frac_list, VL &frac_inv_list)
{
rep(i, frac_list.size() - 1)
{
frac_list[i + 1] *= frac_list[i] * (i + 1);
frac_list[i + 1] %= mod;
frac_inv_list[i + 1] *= frac_inv_list[i] * pow_mod(i + 1, mod - 2, mod);
frac_inv_list[i + 1] %= mod;
}
}
ll comb(int a, int b, const VL &frac_list, const VL &frac_inv_list)
{
if (a < b)
return 0;
if (b < 0)
return 0;
ll ret = frac_list[a];
ret *= frac_inv_list[b];
ret %= mod;
ret *= frac_inv_list[a - b];
ret %= mod;
return ret;
}
struct goods
{
ll weight;
ll value;
};
int main()
{
#ifdef DEBUG
cout << "DEBUG MODE" << endl;
ifstream in("input.txt");
cin.rdbuf(in.rdbuf());
#endif
string s, t;
cin >> s >> t;
int ls, lt, a;
ls = s.length(), lt = t.length();
VVI dp(ls + 1, VI(lt + 1, ls + lt));
dp[0][0] = 0;
rep(i, ls) dp[i + 1][0] = i + 1;
rep(i, lt) dp[0][i + 1] = i + 1;
rep(i, ls) rep(j, lt)
{
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i + 1][j] + 1);
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j + 1] + 1);
a = (s[i] == t[j] ? 0 : 1);
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j] + a);
}
cout << dp[ls][lt] << rt;
return 0;
} | 0 | 5,460,259 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define ii pair <int, int>
#define app push_back
#define all(a) a.begin(), a.end()
#define bp __builtin_popcountll
#define ll long long
#define mp make_pair
#define f first
#define s second
#define Time (double)clock()/CLOCKS_PER_SEC
signed main() {
#ifdef HOME
freopen("input.txt", "r", stdin);
#else
#define endl '\n'
ios_base::sync_with_stdio(0); cin.tie(0);
#endif
int n, k;
string s;
cin >> n >> s >> k;
char w = s[k - 1];
for (int i = 0; i < n; ++i) {
if (s[i] != w) {
s[i] = '*';
}
}
cout << s << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int i=0;i<n;i++)
#define Rep(i,n) for(int i=1;i<=n;i++)
const ll MOD = 1000000007;
struct edge{
int to,weight;
edge(int to,int weight):to(to),weight(weight){}
};
using Graph = vector<vector<int>> ;
using GraphEdge = vector<vector<int>> ;
long long modinv(long long a, long long m=MOD) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
int main(){
double a,b;cin >> a >> b;
printf("%0.5f\n",a/b);
return 0;
} | 0 | 42,260,672 |
#include<bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(),v.end()
#define puts(i) cout << i << endl
#define INF INT_MAX
#define INFL LLONG_MAX
typedef long long ll;
using namespace std;
int main(){
int n; cin >> n;
unordered_map<string,int> str;
ll ans = 0;
rep(i,n){
string s; cin >> s;
sort(all(s));
if(str.count(s)){
ans += str[s];
str[s]++;
}else{
str[s]=1;
}
}
cout << ans << endl;
} | #include <iostream>
#include <string.h>
#include <stdio.h>
#include <map>
#include <vector>
#include <math.h>
#include <algorithm>
#include <queue>
#include <set>
#include <tuple>
using namespace std;
#define rep(i,a) for(int i=0; i<a; i++)
#define rrep(i,a) for(int i=a; i>=0; i--)
#define rep1(i,a) for(int i=1; i<=a; i++)
#define cout1(a) cout << a << endl;
#define cout2(a,b) cout << a << " " << b << endl;
#define cout3(a,b,c) cout << a << " " << b << " " << c << endl;
#define cout4(a,b,c,d) cout << a << " " << b << " " << c << " " << d << endl;
#define mem(a,n) memset( a, n, sizeof(a))
#define all(a) a.begin(),a.end()
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LLINF = 1e18;
static const double pi = 3.141592653589793;
int N;
ll A[100009], ret[100009];
vector<int> V;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin>>N;
map<ll,ll> M;
rep(i,N) cin>>A[i], M[A[i]]++;
V.push_back(0);
rep1(i,N-1) if(A[V.back()]<A[i]) V.push_back(i);
rrep(i,V.size()-2){
while(M.rbegin()->first>A[V[i]]){
auto r=*M.rbegin();
M.erase(r.first);
ret[V[i+1]]+=(r.first-A[V[i]])*1LL*r.second;
M[A[V[i]]]+=r.second;
}
}
for(auto& r:M) ret[0]+=r.first*r.second;
rep(i,N) cout1(ret[i]);
} | 0 | 58,638,218 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
typedef pair<int, int> P;
#define INF 1000000000000
#define MOD 1000000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define Z class
template <typename T>
T square(T x) { return x * x; }
template <class T>
T GCD(T a, T b)
{
T r;
while (a)
r = b, b = a, a = r % a;
return b;
}
template <class T>
T LCM(T a, T b) { return a / GCD(a, b) * b; }
#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 repe(i, n) for (ll i = 0; i <= (n); i++)
#define repd(i, n) for (ll i = n; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (b); i--)
#define FORA(i, I) for (const auto &i : I)
#define ALL(x) x.begin(), x.end()
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<vi> vvi;
typedef vector<ll> vl;
#define ERASE(x) x.erase(unique(ALL(x)), x.end());
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0);
#define VAR(type, ...) \
type __VA_ARGS__; \
MACRO_VAR_Scan(__VA_ARGS__);
template <typename T>
void MACRO_VAR_Scan(T &t)
{
std::cin >> t;
}
template <typename First, typename... Rest>
void MACRO_VAR_Scan(First &first, Rest &... rest)
{
std::cin >> first;
MACRO_VAR_Scan(rest...);
}
template <typename T>
void MACRO_OUT(const T t) { std::cout << t; }
#define OUT(...) MACRO_OUT(__VA_ARGS__);
#define SP std::cout << " ";
#define TAB std::cout << "\t";
#define BR std::cout << "\n";
#define ENDL std::cout << std::endl;
#define YES() printf("YES\n")
#define NO() printf("NO\n")
#define isYES(x) printf("%s\n", (x) ? "YES" : "NO")
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define yes() printf("yes\n")
#define no() printf("no\n")
#define ln cout << '\n'
template <Z A>
void pr(A a)
{
cout << a;
ln;
}
template <Z A, Z B>
void pr(A a, B b)
{
cout << a << ' ';
}
bool check = 0;
bool boo = 0;
int N = 3;
vector<int> v(N);
ll minn = INF, maxx = 0;
ll x = 0, y = 0;
int sum;
char ch;
int main()
{
INIT;
int ans = 1000000, num;
string s;
cin >> s;
rep(i, s.length() - 2)
{
int num = (s[i] - '0') * 100 + (s[i + 1] - '0') * 10 + (s[i + 2] - '0');
ans = min(ans, abs(num - 753));
}
pr(ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define all(n) begin(n),end(n)
using ll = long long;
using P = pair<int,int>;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i,n) cin >> a[i];
int sum = 0;
ll ans = 0;
int r = 0;
for(int l = 0; l < n; ++l) {
while(r < n && (sum + a[r]) == (sum ^ a[r])){
sum+=a[r];
r++;
}
ans += r-l;
sum ^= a[l];
}
cout << ans << endl;
return 0;
} | 0 | 66,638,807 |
#include<iostream>
#include<vector>
using namespace std;
int main()
{
int n;
while(1){
vector<int>vec;
int ans=-100000;
cin>>n;
vector<int>dp(n);
if(n==0)break;
for(int i=0;i<n;i++){
int a;cin>>a;
vec.push_back(a);
}
dp[0]=vec[0];
for(int i=1;i<n;i++){
dp[i]=max(dp[i-1]+vec[i],vec[i]);
}
for(int i=0;i<n;i++){
ans=max(ans,dp[i]);
}
cout<<ans<<endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main()
{
string s;
cin>>s;
if(s[0]=='R'&&s[1]=='R'&&s[2]=='R') cout<<3;
else if(s[0]=='R'&&s[2]=='R')cout<<1<<endl;
else if(s[0]=='R'&&s[1]=='R')cout<<2<<endl;
else if(s[1]=='R'&&s[2]=='R')cout<<2<<endl;
else if(s[0]!='R'&&s[1]!='R'&&s[2]=='R') cout<<1;
else if(s[0]=='R'&&s[1]!='R'&&s[2]!='R') cout<<1;
else if(s[0]!='R'&&s[1]=='R'&&s[2]!='R') cout<<1;
else if(s[0]!='R'&&s[2]!='R') cout<<0;
else if(s[0]!='R'&&s[1]!='R') cout<<0;
else if(s[0]!='R'&&s[1]!='R'&&s[2]!='R') cout<<0;
return 0;
} | 0 | 77,493,465 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S, T, U;
cin >> S >> T >> U;
cout << char(S[0] - 32) << char(T[0] - 32) << char(U[0] - 32) << endl;
} | #include <bits/stdc++.h>
#warning !!!check the size of arrayss!!!
#define INF 2000000000000000005
#define MOD 1000000007
#define newMOD 998244353
#define MAX 300006
#define pi 3.1415926535897932384626433832795
#define ll long long
#define int long long
#define P(gg) for(auto rax:gg){cout<<rax<<" ";}cout<<endl;
#define Need_for_speed(activated) ios_base :: sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL)
#define satisfy ll t; cin>> t; while(t--)
#define inp(n) int n;cin >> n
#define mp make_pair
#define pb push_back
#define endl "\n"
#define x first
#define y second
#define fore(i,a,b) for(ll i=a;i<b;i++)
#define forci(i,n) for(ll i=0;i<n;i++)
#define vi vector<ll>
#define Endl endl
#define lb lower_bound
#define ub upper_bound
#define pii pair<ll,ll>
#define MAXN 402
#define input freopen("input.txt", "r", stdin),freopen("output.txt", "w", stdout)
#define time cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
using namespace std;
ll gcd(ll a, ll b){if (b == 0)return a;return gcd(b, a % b);}
int power(int x, unsigned int y, unsigned int m){ if (y == 0) return 1;int p = power(x, y/2, m) % m; p = (p * p) % m; return (y%2 == 0)? p : (x * p) % m;}
ll modInverse(int a, int m){int g = gcd(a, m); { return power(a, m-2, m);}}
ll n,m;
string s[103];
ll dp[103][104];
void solve()
{
cin>>n>>m;
string d;
for(ll i=1;i<=n;i++)cin>>d,s[i]='@'+d;
dp[1][1] = s[1][1]=='#';
for(ll i=2;i<=n;i++)for(ll j=2;j<=m;j++)dp[i][j] = INF;
for(ll i=2;i<=n;i++)
{
if(s[i][1]=='.')dp[i][1]=dp[i-1][1];
else
{
if(s[i-1][1]=='.')dp[i][1]++;
dp[i][1]+=dp[i-1][1];
}
}
for(ll j=2;j<=m;j++)
{
if(s[1][j]=='.')dp[1][j]+=dp[1][j-1];
else
{
if(s[1][j-1]=='.')dp[1][j]++;
dp[1][j]+=dp[1][j-1];
}
}
for(ll i=2;i<=n;i++)
{
for(ll j=2;j<=m;j++)
{
if(s[i][j]=='.')dp[i][j] =min(dp[i][j-1],dp[i-1][j]);
else
{
if(s[i-1][j]=='.')dp[i][j] =min(dp[i][j],dp[i-1][j]+1);
else {dp[i][j]=min(dp[i][j],dp[i-1][j]);}
if(s[i][j-1] == '.' )dp[i][j] = min(dp[i][j],dp[i][j-1]+1);
else dp[i][j] =min(dp[i][j],dp[i][j-1]);
}
}
}
cout<<dp[n][m]<<endl;
}
signed main()
{
Need_for_speed(activated);
solve();
return 0;
} | 0 | 52,420,991 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int c[20], dp[50001];
int main() {
scanf("%d%d",&n,&m);
for (int i=0; i<m; i++) scanf("%d", &c[i]);
sort(c, c+m);
for (int i=1; i<=n; i++) {
dp[i] = dp[i-c[0]]+1;
for (int j=1; j<m; j++) {
if (i < c[j]) break;
dp[i] = min(dp[i], dp[i-c[j]]+1);
}
}
printf("%d\n",dp[n]);
} | #include <bits/stdc++.h>
using namespace std;
void chmax (int &x, int a) {
x = max(x, a);
}
int h, w;
char s[2004][2004];
set < int > ver_bor[2004], hor_bor[2004];
signed main () {
cin >> h >> w;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
cin >> s[i][j];
if (s[i][j] == '#')
hor_bor[i].insert(j);
}
}
for (int i = 0; i < w; ++i) {
for (int j = 0; j < h; ++j) {
if (s[j][i] == '#')
ver_bor[i].insert(j);
}
}
int ans = 0;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
if (s[i][j] == '.') {
auto hor_it = hor_bor[i].lower_bound(j);
auto ver_it = ver_bor[j].lower_bound(i);
int l_hor = -1, r_hor = w, l_ver = -1, r_ver = h;
if (hor_it != hor_bor[i].begin())
l_hor = *prev(hor_it);
if (hor_it != hor_bor[i].end())
r_hor = *hor_it;
if (ver_it != ver_bor[j].begin())
l_ver = *prev(ver_it);
if (ver_it != ver_bor[j].end())
r_ver = *ver_it;
chmax(ans, (r_hor - l_hor - 1) + (r_ver - l_ver - 1) - 1);
}
}
}
cout << ans << '\n';
} | 0 | 53,828,608 |
#include <stdio.h>
#define MAX 100
int main(void)
{
int i, j;
char ring[MAX + 1];
char make[MAX + 1];
scanf("%s %s", ring, make);
char ring2[MAX * 2 + 1];
for (i = 0; (ring2[i] = ring[i]) != '\0'; i++){
;
}
int len_ring = i;
for (i = 0; (ring2[len_ring + i] = ring[i]) != '\0'; i++){
;
}
for (i = 0; make[i] != '\0'; i++){
;
}
int len_make = i;
enum {YES, NO} y_n;
y_n = NO;
for (i = 0; i < len_ring; i++){
if (ring2[i] == make[0]){
for (j = 0; j < len_make; j++){
if (ring2[i + j] == make[j]){
y_n = YES;
continue;
}else{
y_n = NO;
break;
}
}
if (y_n == YES){
break;
}else{
continue;
}
}
}
if (y_n == YES){
printf("Yes\n");
}else{
printf("No\n");
}
return 0;
} | #include <iostream>
#include <string>
#include <typeinfo>
struct Card {
char suit;
int value;
};
void traceALDS12C(Card arr[], int max) {
for (int i = 0; i < max; ++i) {
if (i)
std::cout << " ";
std::cout << arr[i].suit << arr[i].value;
}
std::cout << std::endl;
}
void BubbleSort(Card arr[], int N) {
for (int i = 0; i < N; ++i) {
for (int j = N - 1; j > i; --j) {
if (arr[j - 1].value > arr[j].value) {
std::swap(arr[j - 1], arr[j]);
}
}
}
traceALDS12C(arr, N);
std::cout << "Stable" << std::endl;
}
void SelectionSort(Card arr[], int N) {
for (int i = 0; i < N; ++i) {
int minIdx = i;
for (int j = i; j < N; ++j) {
if (arr[minIdx].value > arr[j].value) {
minIdx = j;
}
}
if (minIdx != i) {
std::swap(arr[minIdx], arr[i]);
}
}
traceALDS12C(arr, N);
}
bool check(Card str1[], Card str2[], int N) {
for (int i = 0; i < N; ++i) {
if (str1[i].suit != str2[i].suit || str1[i].value != str2[i].value) {
return false;
}
}
return true;
}
int main() {
int N;
std::cin >> N;
Card cards[N];
for (int i = 0; i < N; ++i) {
std::cin >> cards[i].suit >> cards[i].value;
}
Card cards2[N];
for (int i = 0; i < N; ++i)
cards2[i] = cards[i];
BubbleSort(cards, N);
SelectionSort(cards2, N);
if (check(cards, cards2, N)) {
std::cout << "Stable" << std::endl;
} else {
std::cout << "Not stable" << std::endl;
}
return 0;
} | 0 | 43,275,423 |
#include<iostream>
int main() {
int X,Y;
std::cin >> X >> Y;
std::cout << X + (int)(Y / 2) << std::endl;;;;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
using Pld = pair<ld, ld>;
using Vec = vector<ll>;
using VecP = vector<P>;
using VecB = vector<bool>;
using VecC = vector<char>;
using VecD = vector<ld>;
using VecS = vector<string>;
template <class T>
using Vec2 = vector<vector<T>>;
#define REP(i, m, n) for(ll i = (m); i < (n); ++i)
#define REPN(i, m, n) for(ll i = (m); i <= (n); ++i)
#define REPR(i, m, n) for(ll i = (m)-1; i >= (n); --i)
#define REPNR(i, m, n) for(ll i = (m); i >= (n); --i)
#define rep(i, n) REP(i, 0, n)
#define repn(i, n) REPN(i, 1, n)
#define repr(i, n) REPR(i, n, 0)
#define repnr(i, n) REPNR(i, n, 1)
#define all(s) (s).begin(), (s).end()
#define pb push_back
#define fs first
#define sc second
template <class T>
bool chmax(T &a, const T b){if(a < b){a = b; return true;} return false;}
template <class T>
bool chmin(T &a, const T b){if(a > b){a = b; return true;} return false;}
ll pow2(const int n){return (1LL << n);}
void co() { cout << endl; }
template <class Head, class... Tail>
void co(Head&& head, Tail&&... tail) {
cout << head << ' ';
co(forward<Tail>(tail)...);
}
void ce() { cerr << endl; }
template <class Head, class... Tail>
void ce(Head&& head, Tail&&... tail) {
cerr << head << ' ';
ce(forward<Tail>(tail)...);
}
void sonic(){ios::sync_with_stdio(false); cin.tie(0);}
void setp(const int n){cout << fixed << setprecision(n);}
constexpr int INF = 1e9+1;
constexpr ll LINF = 1e18L+1;
constexpr ll MOD = 1e9L+7;
constexpr ll MOD_N = 998244353;
constexpr ld EPS = 1e-11;
const double PI = acos(-1);
int main(void){
ll x;
cin >> x;
ll ans = 1, sum = x;
while (sum % 360) {
ans++;
sum += x;
}
co(ans);
return 0;
} | 0 | 38,524,469 |
#include<iostream>
#include<vector>
using namespace std;
void primeCal()
{
const int N = 1000000;
vector<bool> prime(N, true);
prime[0] = prime[1] = false;
for (int i = 2; i*i < N; ++i)
{
if (!prime[i])
{
continue;
}
for (int j = i*i; j < N; j += i)
{
prime[j] = false;
}
}
vector<int> count(N);
for (int i = 1; i < N; ++i)
{
count[i] = count[i-1] + prime[i];
}
int n;
while (cin>>n)
{
cout << count[n] << endl;
}
return;
}
int main()
{
primeCal();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define ALL(x) x.begin(),x.end()
#define get_tp(t,i) get<i>(t)
#define len(x) (ll)(x.size())
#define ub(a,x) (upper_bound(ALL(a),x)-a.begin())
#define lb(a,x) (lower_bound(ALL(a),x)-a.begin())
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<long long,long long> pllll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef priority_queue<ll, vector<ll>, greater<ll> > gpq;
typedef priority_queue<ll> pq;
const int MOD=1000000007;
const long double PI=3.1415926535897932;
int main(){
int W,H,N;cin>>W>>H>>N;
vvi M(W,vi(H,1));
for(int i=0;i<N;i++){
int x,y,a;cin>>x>>y>>a;
if(a==1){
for(int j=0;j<x;j++){
for(int k=0;k<H;k++){
M[j][k]=0;
}
}
}else if(a==2){
for(int j=x;j<W;j++){
for(int k=0;k<H;k++){
M[j][k]=0;
}
}
}else if(a==3){
for(int j=0;j<W;j++){
for(int k=0;k<y;k++){
M[j][k]=0;
}
}
}else if(a==4){
for(int j=0;j<W;j++){
for(int k=y;k<H;k++){
M[j][k]=0;
}
}
}
}
int ans=0;
for(int j=0;j<W;j++){
for(int k=0;k<H;k++){
ans+=M[j][k];
}
}
cout<<ans<<endl;
} | 0 | 62,660,911 |
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
typedef pair<ll,ll> P;
#define fi first
#define se second
#define all(v) (v).begin(),v.end()
const ll inf=(1e18);
const ll mod=1000000007;
const ll mod2=998244353;
ll gcd(ll a,ll b) {return b ? gcd(b,a%b):a;}
ll lcm(ll c,ll d){return c/gcd(c,d)*d;}
map<char,ll> mp;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin>>s;
ll n=s.size();
for(int i=0;i<n;i++){
mp[s[i]]++;
}
ll ma=n*(n-1)/2;
ll same=0;
for(char c='a';c<='z';c++){
same+=mp[c]*(mp[c]-1)/2;
}
cout<<ma-same+1<<endl;
} | #include <bits/stdc++.h>
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, a, b) for (int i = (a); i < (b); i++)
#define INF 1000000000000
typedef long long ll;
int main()
{
ll n, m, min, minNum;
pair<ll, ll> minP;
cin >> n >> m;
vector<pair<ll, ll>> stu(n);
vector<pair<ll, ll>> p(m);
REP(i, n)
{
cin >> stu[i].first >> stu[i].second;
}
REP(i, m)
{
cin >> p[i].first >> p[i].second;
}
REP(i, n)
{
min = abs(stu[i].first - p[0].first) + abs(stu[i].second - p[0].second);
minP.first = p[0].first;
minP.second = p[0].second;
minNum = 1;
REP(j, m)
{
if (min > (abs(stu[i].first - p[j].first) + abs(stu[i].second - p[j].second)))
{
min = abs(stu[i].first - p[j].first) + abs(stu[i].second - p[j].second);
minP.first = p[j].first;
minP.second = p[j].second;
minNum = j + 1;
}
else if (min == (abs(stu[i].first - p[j].first) + abs(stu[i].second - p[j].second)))
{
if (p[j].first < minP.first || p[j].second < minP.second)
{
minP.first = p[j].first;
minP.second = p[j].second;
min = abs(stu[i].first - p[j].first) + abs(stu[i].second - p[j].second);
minNum = j + 1;
}
}
}
cout << minNum << endl;
}
} | 0 | 72,727,865 |
#include<bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(),v.end()
using namespace std;
int main(){
double x,T;
cin >> T >> x;
long double t=T/x;
cout << t << endl;
} | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <fstream>
#include <iostream>
#include <iomanip>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
using Pii = pair<int, int>;
using Pil = pair<int, ll>;
using Pid = pair<int, ld>;
using Pis = pair<int, string>;
const int INF = 1 << 28;
const ll INF_L = 1LL << 60;
const int MOD = 1e9+7;
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; }
vector<vector<int>> adjMat;
vector<set<Pii>> adjList;
void Dijkstra(){}
void BellmanFord(){}
void WarshallFloyd(){}
ll gcd(ll A, ll B) {if (A%B == 0) {return(B);} else {return(gcd(B, A%B));}}
ll lcm(ll A, ll B) {return A * B / gcd(A, B);}
ll powMod(ll B, ll P) {
if(P == 0) return 1;
if(P%2 == 0){ll t = powMod(B, P/2); return t*t % MOD;}
return B * powMod(B, P-1) % MOD;
}
const int FAC_INIT_SIZE = 5e6+9;
vector<ll> fac, finv, inv;
void factModInit() {
fac.resize(FAC_INIT_SIZE);
finv.resize(FAC_INIT_SIZE);
inv.resize(FAC_INIT_SIZE);
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i=2; i < FAC_INIT_SIZE; i++){
fac[i] = fac[i-1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i-1] * inv[i] % MOD;
}
}
ll factMod(ll N){return fac[N] % MOD;}
ll factInvMod(ll N){return finv[N] % MOD;}
ll permMod(ll N, ll K){
if (N < 0 || K < 0 || N < K) return 0;
else return factMod(N) * factInvMod(N-K) % MOD;
}
ll combMod(ll N, ll K){
if (N < 0 || K < 0 || N < K) return 0;
else if (N < FAC_INIT_SIZE){ return factMod(N) * (factInvMod(K) * factInvMod(N-K) % MOD) % MOD;}
else {
ll ans = 1; ll Ks = K < N-K ? K : N-K;
for (ll i=N; i > N-Ks; i--) {ans *= i; ans %= MOD;}
return ans * factInvMod(Ks) % MOD;
}
}
int main() {
std::ifstream in("input.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
int K, N;
cin >> K >> N;
int A[N];
for(int i=0; i<N; i++) cin >> A[i];
int dm = A[0] - A[N-1] + K;
for(int i=1; i<N; i++) {
int d = A[i] - A[i-1];
if(dm < d) dm = d;
}
cout << K-dm << endl;
} | 0 | 6,768,925 |
#include <bits/stdc++.h>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstring>
#include <chrono>
#include <complex>
#define endl "\n"
#define ll long long int
#define vi vector<int>
#define vll vector<ll>
#define vvi vector < vi >
#define pii pair<int,int>
#define pll pair<long long, long long>
#define mod 1000000007
#define inf 1000000000000000001;
#define all(c) c.begin(),c.end()
#define mp(x,y) make_pair(x,y)
#define mem(a,val) memset(a,val,sizeof(a))
#define eb emplace_back
#define f first
#define s second
using namespace std;
vector<int> v;
int main()
{
ll n;
cin>>n;
if(n%2!=0)
{
cout<<0<<endl;
return 0;
}
n = n/2;
ll pot = 5,result = 0;
while(pot <= n)
{
result += n/pot;
pot *=5;
}
cout<<result<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define SORT(c) sort((c).begin(),(c).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define pv(val) cerr << #val << '=' << (val) << endl
const int INF = 1e9;
int main(void){
int N, M, K; cin >> N >> M >> K;
bool ok = false;
REP(i,N+1){
REP(j,M+1){
if((j*N + i*M - 2*i*j) == K) ok = true;
}
}
if(ok) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
} | 0 | 77,883,889 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
#define endl '\n'
#define pb push_back
#define fi first
#define se second
typedef long long ll;
#define double long double
#define pii pair<int,int>
#define pll pair<ll,ll>
#define fr(a,b,c) for(int a=b; a<=c; a++)
#define rep(a,b,c) for(int a=b; a<c; a++)
#define all(con) con.begin(),con.end()
#define w(x) int x; cin>>x; while(x--)
const ll infl=0x3f3f3f3f3f3f3f3fLL;
const int infi=0x3f3f3f3f;
const int mod=1000000007;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<bool> vb;
#define pqb priority_queue<int>
#define pqs priority_queue<int,vi,greater<int> >
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0),cout.tie(0);
cout<<fixed<<setprecision(8);
int n,k;
cin>>n>>k;
vector<int>a(n);
rep(i,0,n)
cin>>a[i];
sort(all(a));
ll ans = 0;
for(int i = 0;i<n;i++)
{
ans += a[i];
--k;
if(k <= 0)
break;
}
cout<<ans<<endl;
return 0;
} | #pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace std;
struct __INIT{__INIT(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}} __init;
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
#define MOD 1000000007
#define INF (1<<30)
#define LINF (lint)(1LL<<56)
#define endl "\n"
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define reprev(i,n) for(int (i)=(n-1);(i)>=0;(i)--)
#define Flag(x) (1<<(x))
#define Flagcount(x) __builtin_popcount(x)
#define pint pair<int,int>
#define pdouble pair<double,double>
#define plint pair<lint,lint>
typedef long long lint;
int dx[8]={1,1,0,-1,-1,-1,0,1};
int dy[8]={0,1,1,1,0,-1,-1,-1};
int main(void){
string N;
cin >> N;
int L=N.length();
lint dp[L+1][2]={};
dp[0][0]=1;
rep(i,L) rep(j,2){
int digit=N[i]-'0';
rep(d,2){
int i2=i+1,j2=j;
if(j==0){
if(digit<d) continue;
if(digit>d) j2=1;
}
dp[i2][j2]=(dp[i2][j2]+dp[i][j]*(d==1?2:1))%MOD;
}
}
cout << (dp[L][0]+dp[L][1])%MOD << endl;
} | 0 | 74,117,035 |
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
char bef[1000001],aft[10000001],word[100000001];
int main(){
int n,m;
while(cin>>n,n){
for(int i=0;i<n;i++){
cin>>bef[i]>>aft[i];
}
cin>>m;
for(int i=0;i<m;i++){
cin>>word[i];
for(int j=0;j<n;j++){
if(bef[j]==word[i]){
word[i]=aft[j];
break;
}
}
}
cout<<word<<endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a,b,c;
cin >> a >> b >> c;
cout << ((c>=a)&&(c<=b)?"Yes":"No") << endl;
} | 0 | 69,283,434 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
#define all(v) (v).begin(),(v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
typedef vector<int> vec;
ll mod_pow(ll a, ll n, ll m) {
ll res = 1;
while (n) {
if (n & 1)res = res * a%m;
a = a * a%m; n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() :n(0) { ; }
modint(ll m) :n(m) {
if (n >= mod)n %= mod;
else if (n < 0)n = (n%mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) { a.n += b.n; if (a.n >= mod)a.n -= mod; return a; }
modint operator-=(modint &a, modint b) { a.n -= b.n; if (a.n < 0)a.n += mod; return a; }
modint operator*=(modint &a, modint b) { a.n = ((ll)a.n*b.n) % mod; return a; }
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)return modint(1);
modint res = (a*a) ^ (n / 2);
if (n % 2)res = res * a;
return res;
}
ll inv(ll a, ll p) {
return (a == 1 ? 1 : (1 - p * inv(p%a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
using mP = pair<modint, modint>;
int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };
string LCS(string s, string t) {
int n = s.size(), m = t.size();
string dp[n+5][m+5];
for (int i=0; i<n; ++i) {
for (int j=0; j<m; ++j) {
if (s[i] == t[j]) {
dp[i+1][j+1] = dp[i][j];
dp[i+1][j+1].push_back(s[i]);
}
else {
dp[i+1][j+1] = max(dp[i][j+1], dp[i+1][j]);
}
}
}
return dp[n][m];
}
void solve() {
int N; cin >> N;
vector<string> sv(N);
rep(i, N){
cin >> sv[i];
sort(all(sv[i]));
}
string res = sv[0];
rep(i, N){
res = LCS(res, sv[i]);
}
cout << res << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
vector<vector<int>> A(3,vector<int>(3));
for(int i=0;i<3;i++){
cin >> A.at(i).at(0) >> A.at(i).at(1) >> A.at(i).at(2);
}
int n; cin >> n;
for(int i=0;i<n;i++){
int b; cin >> b;
for(int x=0;x<3;x++){
for(int y=0;y<3;y++){
if(A.at(x).at(y)==b) A.at(x).at(y)=0;
}
}
}
for(int x=0;x<3;x++){
if(A.at(x).at(0)==0&&A.at(x).at(1)==0&&A.at(x).at(2)==0){
cout << "Yes";
return 0;
}
}
for(int x=0;x<3;x++){
if(A.at(0).at(x)==0&&A.at(1).at(x)==0&&A.at(2).at(x)==0){
cout << "Yes";
return 0;
}
}
if(A.at(0).at(0)==0&&A.at(1).at(1)==0&&A.at(2).at(2)==0){
cout << "Yes";
return 0;
}
if (A.at(0).at(2)==0&&A.at(1).at(1)==0&&A.at(2).at(0)==0){
cout << "Yes";
return 0;
}else{
cout << "No";
}
} | 0 | 10,227,159 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n, k, ans;
cin >> n >> k;
ans=n+2-k+(n+1)*((n+1)*(n+2)/2-(k-1)*k/2)-(n+1)*(n+2)*(2*n+3)/6+(k-1)*k*(2*k-1)/6;
ans%=((int)pow(10, 9)+7);
cout << ans;
return 0;
} | #include<bits/stdc++.h>
#define ford(i,a,b) for(int i=(a);i>=b;i--)
#define rep1(i,a,b) for(int i=(a);(i)<=(b);(i)++)
#define rep(i,a,b) for(int i=(a);(i)<(b);(i)++)
#define ll long long
#define N 105
#define pql priority_queue<ll>
#define all(v) (v).begin(),(v).end()
#define rall(v) (v).rbegin(),(v).rend()
#define rev(a,n) reverse(a,a+n)
using namespace std;
ll gcd(ll a,ll b) {
if(a%b==0) return b;
else return gcd(b,a%b);
}
ll lcm(ll a,ll b) {
return a*b/gcd(a,b);
}
ll a,b,c,d,sum,ans,ans1;
int main() {
cin>>a>>b>>c>>d;
sum=lcm(c,d),a--;
ans=a/c+a/d-a/sum;
ans1=b/c+b/d-b/sum;
cout<<b-a-ans1+ans;
return 0;
} | 0 | 43,684,914 |
#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,K;
cin>>N>>K;
int number = 1;
int number2 ;
rep(i,N){
number2 = number*2;
if(number2-number < K){
number = number2;
}else{
number+=K;
}
}
cout<<number<<endl;
} | #include <bits/stdc++.h>
#define FOR(i, a, n) for(ll i = (ll)a; i < (ll)n; i++)
#define rep(i, n) FOR(i, 0, n)
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
constexpr int Mod = 998244353;
constexpr int mod = 1e9 + 7;
constexpr ll inf = 1LL << 60;
template <typename T> constexpr bool chmax(T &a, const T b) {
if(a >= b) return false;
a = b;
return true;
}
template <typename T> constexpr bool chmin(T &a, const T b) {
if(a <= b) return false;
a = b;
return true;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
ll n;
cin >> n;
ll a[n], k = 0;
rep(i, n) {
cin >> a[i];
k += a[i];
}
if(k % (n * (n + 1) / 2)) {
cout << "NO" << endl;
return 0;
}
k /= n * (n + 1) / 2;
rep(i, n) {
ll x = a[(i + 1) % n] - a[i] - k;
if(x > 0 || (-x) % n) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
} | 0 | 46,635,133 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using pll = pair<ll, ll>;
#define overload4(_1,_2,_3,_4,name,...) name
#define rep1(n) for(ll i=0;i<n;++i)
#define rep2(i,n) for(ll i=0;i<n;++i)
#define rep3(i,a,b) for(ll i=a;i<b;++i)
#define rep4(i,a,b,c) for(ll i=a;i<b;i+=c)
#define rep(...) overload4(__VA_ARGS__,rep4,rep3,rep2,rep1)(__VA_ARGS__)
#define all(i) begin(i), end(i)
const int INF = 0x3fffffff;
const ll MINF = 0x7fffffffffff;
const ld DINF = numeric_limits<ld>::infinity();
const int MOD = 1000000007;
const int MODD = 998244353;
const ld EPS = 1e-9;
const ld PI = 3.1415926535897932;
template<class T> bool chmin(T &a, const T &b){ if(a > b){ a = b; return 1; } else return 0; }
template<class T> bool chmax(T &a, const T &b){ if(a < b){ a = b; return 1; } else return 0; }
template<class T> auto min(const T& a){ return *min_element(all(a)); }
template<class T> auto max(const T& a){ return *max_element(all(a)); }
ll gcd(ll a, ll b){ while(b){ ll c = b; b = a % b; a = c; } return a; }
ll lcm(ll a, ll b){ if(!a || !b) return 0; return a * b / gcd(a, b); }
ll pow_mod(ll n,ll k,ll m){ll r = 1;for(; k > 0;k >>= 1) {if (k & 1) r = (r * n) % m; n = (n * n) % m;}return r;}
int main(){
int h,w;
cin >> h >> w;
vector<string> s(h);
vector<vector<int>> ans(h,vector<int> (w,0));
rep(i,h) cin >> s[i];
rep(i,h){
int cnt = 0;
int start = 0;
rep(j,w){
if(s[i][j] == '.'){
cnt++;
}else{
rep(k,j - start) ans[i][k + start] = cnt;
start = j+1;
cnt = 0;
}
}
if(cnt != 0){
rep(k,w - start) ans[i][k + start] = cnt;
}
}
int res = 0;
rep(i,w){
int cnt = 0;
int start = 0;
rep(j,h){
if(s[j][i] == '.'){
cnt++;
}else{
rep(k,j - start) chmax(res,ans[k + start][i] + cnt - 1);
start = j+1;
cnt = 0;
}
}
if(cnt != 0){
rep(k,h - start) chmax(res,ans[k+start][i] + cnt - 1);
}
}
cout << res << "\n";
} | #include<iostream>
#include<string>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<algorithm>
#include<utility>
#include<map>
using namespace std;
typedef long long ll;
const int mod = 1000000007;
const int INF = 1001001001;
ll pow_mod(ll p, ll n, ll m) {
if (n == 0) return 1;
else if (n == 1) return p % m;
else if (n % 2 == 1) return p * pow_mod(p, n - 1, m) % m;
else {
ll tmp = pow_mod(p, n / 2, m);
return (tmp * tmp) % m;
}
}
ll gcd(ll x, ll y) {
if (y == 0) {
return x;
}
return gcd(y, x % y);
}
ll com_mod(ll n, ll k, ll m) {
if (k == 0) return 1;
else {
ll x = 1;
ll y = 1;
for (ll i = 0; i < k; i++) {
x = (x * (n - i)) % m;
y = (y * (i + 1)) % m;
}
ll res = (x * pow_mod(y, m - 2, m)) % m;
return res;
}
}
int main() {
string s; cin>>s;
for (int i = 0; i < 3; i++) {
if (s[i] == '1') s[i] = '9';
else if (s[i] == '9') s[i] = '1';
}
cout << s << endl;
return 0;
} | 0 | 50,482,471 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(){
int h,w,d;
cin >> h >> w >> d;
int a[h][w];
vector<pair<int,int>> p(h*w);
rep(i,h)rep(j,w){
cin >> a[i][j];
a[i][j]--;
p[a[i][j]] = make_pair(i,j);
}
vector<vector<int>> k(d);
for(int i=0;i<d;i++){
int j = i,cur=0;
k[i].push_back(cur);
while(j+d<h*w){
cur += abs(p[j+d].first-p[j].first)+abs(p[j+d].second-p[j].second);
k[i].push_back(cur);
j += d;
}
}
int q;
cin >> q;
rep(i,q){
int b,c;
cin >> b >> c;
b--;c--;
int t = b%d;
cout << k[t][(c-t)/d]-k[t][(b-t)/d] << endl;
}
} | #include <bits/stdc++.h>
#include <vector>
#include <queue>
using namespace std;
int main(){
int H, W;
cin >> H >> W;
vector<vector<char>> Cij(H, vector<char>(W));
for(int i=0; i<H; i++){
for(int j=0; j<W; j++){
cin >> Cij[i][j];
}
}
for(int i=0; i<2*H; i++){
for(int j=0; j<W-1; j++){
cout << Cij[(int)((i)/2)][j];
}
cout << Cij[(int)((i)/2)][W-1] << endl;
}
return 0;
} | 0 | 42,557,801 |
#include <bits/stdc++.h>
#define rep(i,cc,n) for(int i=cc;i<=n;++i)
using namespace std;
int main() {
int H, W;
cin >> H >> W;
vector<string> board(H);
rep(i,0,H-1) cin >> board[i];
string ans = "Yes";
rep(i,0,H-1) {
rep(j,0,W-1) {
if (board[i][j] == '.') continue;
bool ok = false;
if (0 <= i - 1) {
if (board[i-1][j] == '#') ok = true;
}
if (i + 1 < H) {
if (board[i+1][j] == '#') ok = true;
}
if (0 <= j - 1) {
if (board[i][j-1] == '#') ok = true;
}
if (j + 1 < W) {
if (board[i][j+1] == '#') ok = true;
}
if (!ok) ans = "No";
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define INF 1000000000000000001
#define ll long long
#define pll pair<ll, ll>
using namespace std;
vector<bool> next(bool fir, bool sec, string& s)
{
vector<bool> res = {fir, sec};
ll N = s.size();
for (ll i = 0; i < N; ++i)
{
if (sec)
{
if (s[i] == 'o')
{
res.push_back(fir);
}
else
{
res.push_back(!fir);
}
}
else
{
if (s[i] == 'o')
{
res.push_back(!fir);
}
else
{
res.push_back(fir);
}
}
fir = sec;
sec = *(res.end() - 1);
}
return res;
}
int main()
{
ll N;
cin >> N;
string s;
cin >> s;
vector<bool> temp = next(true, true, s);
for (ll i = 0; i < 2; ++i)
{
for (ll j = 0; j < 2; ++j)
{
temp = next(i, j, s);
if (temp.at(0) == *(temp.end() - 2) && temp.at(1) == *(temp.end() - 1))
{
for (ll i = 1; i < N + 1; ++i)
{
if (temp.at(i))
{
cout << "S";
}
else
{
cout << "W";
}
}
cout << endl;
return 0;
}
}
}
cout << -1 << endl;
} | 0 | 44,522,362 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,K;
cin >> N >> K;
if(N % K == 0)
cout << 0;
else
cout << 1;
} | #include<iostream>
using namespace std;
int main() {
int a[4][3][10] = {0};
int num;
cin >> num;
int b,f,r,v;
while (cin >> b >> f >> r >> v) {
if (a[b-1][f-1][r-1] == 0) {
a[b-1][f-1][r-1] = v;
num--;
} else {
a[b-1][f-1][r-1] += v;
}
if (num == 0) break;
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 10; k++) {
cout << " " << a[i][j][k];
}
cout << endl;
}
if (i != 3) cout << "####################" << endl;
}
} | 0 | 67,957,031 |
#include "bits/stdc++.h"
#define ll long long
#define mp(a, b) make_pair(a, b)
using namespace std;
typedef pair<ll, ll> pairs;
typedef pair<ll, pairs> tpl;
ll dp[101][100001], a[1001], sum, mod = (ll)1e9 + 7;
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
ll n, k;
cin >> n >> k;
for (ll i = 0; i < n; i++)
cin >> a[i];
for (ll i = 0; i <= a[0]; i++)
dp[0][i] = 1;
for (ll i = 1; i < n; i++)
{
ll pre[k + 1];
pre[0] = dp[i - 1][0];
for (ll j = 1; j <= k; j++)
pre[j] = (pre[j - 1] + dp[i - 1][j]) % mod;
for (ll j = 0; j <= k; j++)
{
if (j > a[i])
dp[i][j] = (pre[j] - pre[max(0LL, j - a[i] - 1)] + mod) % mod;
else
dp[i][j] = pre[j];
}
}
cout << dp[n - 1][k];
} | #pragma GCC optimize ("Ofast")
#pragma GCC target ("tune=native")
#pragma GCC target ("avx")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define int ll
#define FOR(i,j,n) for (int i=(int)(j);i<(n);i++)
#define REP(i,n) for (int i=0;i<(int)(n);i++)
#define REPS(i,n) for (int i=1;i<=(int)(n);i++)
#define REPN(i,n) for (int i=(int)(n)-1;i>=0;i--)
#define REPNS(i,n) for (int i=(int)(n);i>0;i--)
#define I(n) scanf("%lld", &(n))
#define LL(n) scanf("%lld", &(n))
#define pb(n) push_back((n))
#define mp(i,j) make_pair((i),(j))
#define eb(i,j) emplace_back((i),(j))
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define uniq(v) v.erase( unique(v.begin(), v.end()), v.end() )
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
typedef vector<int> vi;
typedef pair<int,int> pi;
typedef vector<pi> vpi;
typedef vector<vi> vvi;
typedef vector<vpi> vvpi;
typedef vector<vvi> vvvi;
const int mod = 1000000007;
int digl, digr, l, r;
int n(int d){
int r = 1;
REP(i,d) r *= 10;
return r;
}
string ins;
bool check(){
cin >> ins;
return ins[0] == 'Y';
}
void ask(int i){
cout << "? " << i << endl;
}
void decide(int i){
cout << "! " << i << endl;
}
signed main(){
digr = 10;
ask(n(10));
if (check()){
while(digr - digl > 1){
int mid = (digr+digl)/2;
ask(9 * n(mid-1));
if( !check()) {
digl = mid;
} else {
digr = mid;
}
}
decide(n(digl));
} else {
digr--;
while(digr - digl > 1){
int mid = (digr+digl)/2;
ask(n(mid));
if( check()) {
digl = mid;
} else {
digr = mid;
}
}
l = n(digl);
r = n(digl+1);
while(r-l > 1){
int mid = (l+r)/2;
ask((mid-1)*10);
if(check()){
r = mid;
} else {
l = mid;
}
}
decide(l);
}
} | 0 | 91,179,843 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, srt, end) for (long long i = (srt); i < (long long)(end); i++)
int main(){
ll N, K, R, S, P;
cin >> N >> K >> R >> S >> P;
string T;
cin >> T;
ll ans = 0;
rep(i, 0, N){
if(i + K < N && T[i + K] == T[i]){
T[i + K] = 'd';
}
{
if(T[i] == 's') ans += R;
if(T[i] == 'r') ans += P;
if(T[i] == 'p') ans += S;
}
}
cout << ans << endl;
return 0;
} | #include<iostream>
using namespace std;
int main(){
int h, w, k;
cin >> h >> w >> k;
char c[h][w];
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++){
cin >> c[i][j];
}
}
int ans = 0;
for(int i = 0; i < 1<<h; i++){
for(int j = 0; j < 1<<w; j++){
int count = 0;
for(int I = 0; I < h; I++){
if(i>>I&1) continue;
for(int J = 0; J < w; J++){
if(j>>J&1) continue;
count += c[I][J]=='#';
}
}
ans += (count==k);
}
}
cout << ans << endl;
return 0;
} | 0 | 94,672,206 |
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ArraySizeOf(array) (sizeof(array) / sizeof(array[0]))
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define rev(i,n) for(int i=n-1;i>=0;i--)
#define REV(i,n) for(int i=n-1;i>0;i--)
#define req(i,n,m) for(int i=n;i<m;i++)
#define REQ(i,n,m,l) for(int i=n;i<m;i+=l)
#define _GLIBCXX_DEBUG
int INF = 1e9 + 7;
unsigned NthDayOfWeekToDay(unsigned n, unsigned dow, unsigned dow1)
{
unsigned day;
if (dow < dow1) dow += 7;
day = dow - dow1;
day += 7 * n - 6;
return day;
}
signed gcd(int x, int y) {
if (y == 0)return x;
return gcd(y, x % y);
}
signed lcm(int x, int y) {
return x / gcd(x, y) * y;
}
unsigned DayToWeekNumber(unsigned day)
{
return (day - 1) / 7 + 1;
}
unsigned AnotherDayOfWeek(unsigned day, unsigned day0, unsigned dow0)
{
return (dow0 + 35 + day - day0) % 7;
}
using namespace std;
signed main() {
int N, D, X; cin >> N >> D >> X;
vector<int>A(N);
int ans = X;
rep(i, N) {
cin >> A[i];
REQ(j, 1, D+1, A[i])ans++;
}
cout << ans << endl;
} | #include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#include <array>
#include <algorithm>
#include <utility>
#include <numeric>
#include <deque>
#include <stack>
#include <queue>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cmath>
#include <limits>
#define for0(i, n) for (int i = 0 ; i < (n); ++i)
#define for1n(i, n) for (int i = 1 ; i <= (n); ++i)
#define for1(i, n) for (int i = 1 ; i < (n); ++i)
#define forn(i, n) for (int i = 0 ; i <= (n); ++i)
#define forx(i, n, x) for (int i = (x); i < (n); ++i)
#define forl(i, n, x, a) for (int i = (x), a = 0; a < (n); \
i = (i + 1) % (n), ++a)
using namespace std;
typedef long long ll;
typedef priority_queue<ll> pq;
typedef priority_queue<ll,vector<ll> ,greater<ll>> pql;
typedef stack<ll> stk;
typedef queue<ll> qu;
template<typename T>
struct point{
T x, y;
point(T a = 0, T b = 0) : x(a), y(b){}
point operator+(point p) const { return {p.x + x, p.y + y}; }
point operator-(point p) const { return {p.x - x, p.y - y}; }
T operator*(point p) const { return p.x * x + p.y * y; }
point operator+=(point p) {x += p.x; y += p.y; return *this; }
point operator-=(point p) {x -= p.x; y -= p.y; return *this; }
T length() const { return std::sqrt(x * x + y * y); }
operator T() const { return length(); }
T angle() const { return std::atan2(y, x); }
static bool angleLesser(point<T> const& p, point<T> const& q) {
return p.angle() < q.angle();
}
static bool lengthLesser(point<T> const& p, point<T> const& q) {
return p.length() < q.length();
}
};
int main(void){
int N;
cin >> N;
point<long double> v[100];
for0(i, N){
cin >> v[i].x >> v[i].y;
}
sort(v, v + N, point<long double>::angleLesser);
long double result = 0;
for0(i, N){
point<long double> p = {0, 0};
forl(j, N, i, a){
p += v[j];
result = max(result, p.length());
}
}
printf("%.20Lf", result);
return 0;
} | 0 | 80,073,657 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
const double PI = acos(-1.0);
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int H, W;
while(1) {
cin >> H >> W;
if(H == 0 && W == 0) break;
for(int i = 0; i < H; i++) {
for(int j = 0; j < W; j++) {
if(i == 0 || i == H - 1 || j == 0 || j == W - 1) cout << "#";
else cout << ".";
}
cout << "\n";
}
cout << "\n";
}
return 0;
} | #pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include<bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define pii pair<int,int>
#define pp pair<pair<ll, ll>,pair<ll, ll>>
#define pll pair<ll,ll>
#define pdd pair<double,double>
#define vii vector<int>
#define vll vector<ll>
#define mat vector<vector<ll>>
#define lb lower_bound
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
#define rep(i,n) for(ll i=0;i<n;i++)
#define rep2(i,a,b) for(ll i=a;i<b;i++)
#define repr(i,n) for(ll i=n-1;i>=0;i--)
#define all(x) x.begin(),x.end()
#define pq priority_queue<ll>
#define pqg priority_queue<ll,vector<ll>,greater<ll>>
#define LB(v,x) (lower_bound(v.begin(),v.end(),x)-v.begin())
#define UB(v,x) (upper_bound(v.begin(),v.end(),x)-v.begin())
#define ERASE(v) sort(v.begin(),v.end());v.erase(unique(v.begin(),v.end()),v.end())
using namespace std;
const ll INF = (1 << 30 ) - 1;
const ll LLINF = (1LL << 60LL);
const ll MOD = 1000000007;
const ll mod = 998244353;
const ll MAX = 1100000;
const double pi = acos(-1);
const double eps = 1e-10;
ll dx[4] ={1,0,-1,0} , dy[4] ={0,1,0,-1};
struct Timer{
chrono::system_clock::time_point start, end;
Timer(){ start = chrono::system_clock::now(); }
~Timer(){
end = chrono::system_clock::now();
auto msec = chrono::duration_cast<chrono::milliseconds>(end - start).count();
cerr<<"time : "<<msec<<" ms"<<endl;
}
};
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
Timer TM;
ll n,k,a[100010];
ll sum[100010]={};
cin>>n>>k;
rep(i,n){
cin>>a[i];
sum[i+1]=sum[i]+a[i];
}
ll dp1[100010]={},dp2[100010]={};
rep(i,n){
if(a[i]>0) dp1[i+1]=dp1[i]+a[i];
else dp1[i+1]=dp1[i];
}
repr(i,n){
if(a[i]>0) dp2[i]=dp2[i+1]+a[i];
else dp2[i]=dp2[i+1];
}
ll ans=0;
rep(i,n-k+1){
ll cnt=0;
ll s=sum[i+k]-sum[i];
cnt+=dp1[i]+dp2[i+k];
ans=max(ans,cnt+s);
ans=max(ans,cnt);
}
cout<<ans<<endl;
return 0;
} | 0 | 91,944,755 |
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<map>
#include<cstddef>
#include<queue>
#include<math.h>
#include<iomanip>
using namespace std;
int main()
{
int n, m, pin, ac = 0, wa = 0;
cin >> n >> m;
vector<vector<string>> p(n, vector<string>(0));
vector<string> s(m);
for(int i = 0; i < m; ++i){
cin >> pin >> s.at(i);
pin--;
if(p.at(pin).size() == 0){
if(s.at(i) == "WA") p.at(pin).push_back("WA");
else{
ac++;
wa += p.at(pin).size();
p.at(pin).push_back("AC");
}
}
else{
if(p.at(pin).at(p.at(pin).size() - 1) == "AC") continue;
else if(s.at(i) == "WA") p.at(pin).push_back("WA");
else{
ac++;
wa += p.at(pin).size();
p.at(pin).push_back("AC");
}
}
}
cout << ac << " " << wa << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(i = 0;i < n;++i)
#define all(v) v.begin(), v.end()
template <typename T> bool chmax(T &a, const T& b){if(a < b){a = b;return true;}return false;}
template <typename T> bool chmin(T &a, const T& b){if(a > b){a = b;return true;}return false;}
using ll = long long;
int main()
{
ll i,j;
ll n,d,a;
cin >> n >> d >> a;
vector<pair<ll,ll>> x(n);
for(i = 0;i < n;++i){
cin >> x.at(i).first >> x.at(i).second;
}
sort(all(x));
ll ans = 0;
queue<pair<ll,ll>> que;
ll num = 0;
for(i = 0;i < n;++i){
while(!que.empty() && que.front().first < x.at(i).first){
num -= que.front().second;
que.pop();
}
x.at(i).second -= num;
if(x.at(i).second <= 0) continue;
ll tmp = ((x.at(i).second-1)/a+1)*a;
ans += tmp/a;
que.emplace(x.at(i).first + 2*d, tmp);
num += tmp;
}
cout << ans << endl;
return 0;
} | 0 | 30,565,578 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x,vector<x>,greater<x>>
#define all(x) (x).begin(),(x).end()
#define CST(x) cout<<fixed<<setprecision(x)
#define vtpl(x,y,z) vector<tuple<x,y,z>>
#define rev(x) reverse(x);
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
using pl=pair<ll,ll>;
using vpl=vector<pl>;
using vvpl=vector<vpl>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-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(){
ll n,m;cin >> n >>m;
vector<pair<pl,ll>> v(m);
rep(i,m){
cin >> v[i].fi.fi >> v[i].fi.se;
v[i].se=i;
}
sort(all(v));
vector<string> s(m);
int k=1;
rep(i,m){
string res;
if(i!=0){
if(v[i].fi.fi!=v[i-1].fi.fi)k=1;
else k++;
}
res+=to_string(k);
while(res.size()<6){
res='0'+res;
}
string form;
int city=v[i].fi.fi;
form+=to_string(city);
while(form.size()<6){
form='0'+form;
}
s[v[i].se]=form+res;
}
rep(i,m)cout << s[i] <<endl;
} | #include<algorithm>
#include<bitset>
#include<cmath>
#include<complex>
#include<deque>
#include<functional>
#include<iomanip>
#include<iostream>
#include<iterator>
#include<map>
#include<numeric>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<unordered_map>
#include<unordered_set>
#include<utility>
#include<vector>
using namespace std;
typedef long long ll;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define D()
#define INF 1000000000000
#define MOD 10000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define INITA(a,i,j,v) for(ll k=i;k<=j;k++){a[k]=v;}
ll gcd(ll a, ll b) {
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
int main() {
ll n, k; cin >> n >> k;
vector<ll> a(n, 0);
REP(i, n) {
cin >> a[i];
}
sort(ALL(a));
ll mx = *max_element(ALL(a));
ll g = -1;
REP(i, a.size()) {
if (g == -1) {
g = a[i];
} else {
g = gcd(g, a[i]);
}
}
if (k % g == 0 && k <= mx) {
cout << "POSSIBLE" << endl;
} else {
cout << "IMPOSSIBLE" << endl;
}
return 0;
} | 0 | 88,864,154 |
#include <bits/stdc++.h>
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define ll long long int
#define pb push_back
#define fi first
#define se second
#define ld long double
#define vi vector<vector<ll> >
using namespace std;
const int MOD=1000000007;
const int MOD2=998244353;
const ll MAX=9187201950435737471;
const int N=100005;
const int INF=1e9+7;
const long double PI=acos(-1);
void solve(int T){
int n,d;
cin>>n>>d;
vector<vector<int> >a(n);
for(int i=0;i<n;i++){
for(int j=0;j<d;j++){
int x;
cin>>x;
a[i].pb(x);
}
}
int ans=0;
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
double x=0.0;
for(int k=0;k<d;k++){
x+=(a[i][k]-a[j][k])*(a[i][k]-a[j][k]);
}
x=sqrt(x);
if(floor(x)==ceil(x))ans++;
}
}
cout<<ans<<"\n";
}
int main() {
fastio
int T=1;
for(int i=1;i<=T;i++){
solve(i);
}
return 0;
} | #include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout << (#x) << " is " << (x) << endl
#define debug cout << "hi" << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
ll gcd(ll a, ll b) {return (!b ? a : gcd(b, a % b));}
ll lcm(ll a, ll b) {return ((a*b)/gcd(a,b));}
bool cmp(int a,int b){return a>b;}
const ll mod = 1e9 + 7;
const int INF32 = 1<<30;
const ll INF64 = 1LL<<60;
const ld pi = 3.141592653589793;
const int N = 1e6 + 10;
long long modpow(long long n, long long k, long long mod)
{
if (k == 0) return 1;
long long r = modpow(n * n % mod, k >> 1, mod);
if (k & 1) r = r * n % mod;
return r;
}
void solve(){
ld n,k;cin >> n >> k;
ld ans = 0.0000000;
if(n>=k) {ans = (n-k+1)/n;}
ld p = 1/n;
for(int i = 1;i<=n;i++){
int ii = i;int cnt = 0;
ld pp = 0.500000;
if(ii>=k) break;
while(ii*2<k){
ii *= 2;
pp *= 0.50000;
cnt++;
}
ans += p*pp;
}
cout << fixed <<setprecision(20);
cout << ans;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);cout.tie(NULL);
solve();
return 0;
} | 0 | 86,455,377 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
void compress(vector<int> &a){
vector<int> b = a;
sort(b.begin(), b.end());
for(auto &x : a){
x = lower_bound(b.begin(), b.end(), x) - b.begin();
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout<<setprecision(32);
int n;
cin>>n;
vector<int> a(n);
for(auto &x: a){
cin>>x;
}
compress(a);
int ans = 0;
for(int i = 0; i < n; i++){
if((i^a[i])&1)ans++;
}
cout<<ans/2<<endl;
return 0;
} | #include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef pair<ld, ld> pld;
typedef pair<string, string> pss;
#define all(x) (x).begin(),(x).end()
#define Sort(x) sort(all((x)))
#define X first
#define Y second
#define Mp make_pair
#define sep ' '
#define endl '\n'
#define debug(x) cerr << #x << " = " << x << endl
#define SZ(x) ll(x.size())
#define fast_io ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define file_io freopen("in.txt" , "r+" , stdin) ; freopen("out.txt" , "w+" , stdout);
#define set_random mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
inline ll input() {
ll n;
cin >> n;
return n;
}
ll poww(ll a, ll b, ll md) {
return (!b ? 1 : (b & 1 ? a * poww(a * a % md, b / 2, md) % md : poww(a * a % md, b / 2, md) % md));
}
set_random;
const ll MAXN = 1e6 + 10;
const ll INF = 8e18;
const ll MOD = 1e9 + 7;
ll n , k;
int main() {
fast_io;
cin >> n >> k;
cout << n - k + 1 << endl;
return 0;
} | 0 | 61,420,386 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define cint cpp_int
#define endl "\n"
#define REP(i,a,n) for(int i=a;i<n;++i)
#define REPR(i,a,n) for(int i=a;i>n;--i)
#define RUP(a,b) (((a)+(b)-1)/(b))
#define ALL(v) (v).begin(),(v).end()
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define MOD 1000000007
#define INF LLONG_MAX/2
#define PI acos(-1.0)
typedef long long ll;
typedef pair<int,int> Pii;
typedef tuple<int,int,int> Tiii;
typedef vector<int> Vi;
typedef vector<Vi> VVi;
typedef vector<Pii> VPii;
typedef vector<string> Vs;
typedef priority_queue<int> PQi;
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 vout(Vi &v){for(int i=0;i<(v).size();i++) cout<<v[i]<<" ";cout<<endl;}
void vout(Vs &v){for(int i=0;i<(v).size();i++) cout<<v[i]<<" ";cout<<endl;}
void vvout(VVi &v){for(int i=0;i<(v).size();i++) vout(v[i]);}
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int lcm(int a,int b){return a/gcd(a,b)*b;}
int mypow(int x, int n, int m){if(n==0)return 1;if(n%2==0)return mypow(x*x%m,n/2,m);else return x*mypow(x,n-1,m)%m;}
int digit(int k,int i){string s = to_string(k);return s[s.size()-i]-'0';}
void uniq(Vi &v){sort(v.begin(),v.end()); v.erase(unique(v.begin(),v.end()),v.end());}
int ctoi(char c){if(c>='0'&&c<='9'){return c-'0';}return 0;}
int leng(int n){string s=to_string(n); return s.size();}
int digitsum(int n){int ret=0; while(n>0){ret+=n%10;n/=10;}return ret;}
int lesscount(int x,Vi &a){return lower_bound(a.begin(),a.end(),x)-a.begin();}
int orlesscount(int x,Vi &a){return upper_bound(a.begin(),a.end(),x)-a.begin();}
int morecount(int x,Vi &a){return a.size()-orlesscount(x,a);}
int ormorecount(int x,Vi &a){return a.size()-lesscount(x,a);}
int count(int x,Vi &a) {return upper_bound(ALL(a),x)-lower_bound(ALL(a),x);}
Vi accum(Vi &v){Vi ret((v).size()+1);REP(i,0,(v).size()) ret[i+1]=ret[i]+v[i];return ret;}
bool comp(Pii a,Pii b){
if(a.second != b.second) return a.second<b.second;
else return a.first<b.first;
}
signed main(){cin.tie(0);cout.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);
int n,x,y;
cin>>n>>x>>y;
Vi a(n);
REP(i,0,n) cin>>a[i];
if(n==1){
cout<<abs(y-a[0])<<endl;
}else{
cout<<max(abs(a[n-2]-a[n-1]),abs(a[n-1]-y))<<endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
#define all2(a, b) (a).begin(), (a).begin() + (b)
#define debug(vari) cerr << #vari << " = " << (vari) << endl;
int main()
{
int n;
cin >> n;
vector<int> t(n), x(n), y(n);
rep(i, n) cin >> t[i] >> x[i] >> y[i];
bool ok = true;
int time = 0, dx = 0, dy = 0;
rep(i, n)
{
time = t[i] - time;
dx = abs(x[i] - dx);
dy = abs(y[i] - dy);
if (time % 2 != (dx + dy) % 2 || dx + dy > time)
{
ok = false;
}
}
cout << (ok ? "Yes" : "No") << endl;
return 0;
} | 0 | 39,412,204 |
#include<iostream>
#include<math.h>
#define rep(i,n) for(int i=0;i<(n);i++)
#define lrep(i,n) for(long int i=0;i<(n);i++)
using namespace std;
int main(){
double a;
cin >>a;
string b;
cin >>b;
unsigned long long int c=a,d=b[0]*100+b[2]*10+b[3]-111*'0';
cout<<(c*d/100);
} | #include<bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
typedef long long ll;
#define pb push_back
#define fi first
#define se second
#define ALL(x) (x).begin(),(x).end()
#define RALL(x) (x).rbegin(),(x).rend()
template <class T, class U> ostream &operator<<(ostream &os, const pair<T, U> &p){os<<"("<<p.first<<","<< p.second<<")";return os;}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v){os<<"{";REP(i,(int)v.size()){if(i)os<<",";os<<v[i];}os<<"}";return os;}
template <typename T, size_t S> void printArray(const T (&array)[S]){for(auto val : array)std::cout << val << ", ";std::cout << "\n";}
void Yes() {cout << "Yes" << endl;}
void No() {cout << "No" << endl;}
void YES() {cout << "YES" << endl;}
void NO() {cout << "NO" << endl;}
const double PI=acos(-1);
const ll MOD = 1000000007;
using Graph = vector<vector<int>>;
template<class T>inline bool chmax(T& a, T b){if(a < b){a = b; return 1;}return 0;}
template<class T>inline bool chmin(T& a, T b){if(a > b){a = b; return 1;}return 0;}
const ll INF = 1LL<<60;
void solve(){
string s; cin >> s;
reverse(ALL(s));
bool flag = false;
while(!s.empty()){
if(s[0] == 'r' && s[1] == 'e' && s[2] == 'm' && s[3] == 'a' && s[4] == 'e' && s[5] == 'r' && s[6] == 'd'){
if(s.size() == 7){
flag = true;
break;
}
s = s.substr(7);
}
else if(s[0] == 'r' && s[1] == 'e' && s[2] == 's' && s[3] == 'a' && s[4] == 'r' && s[5] == 'e'){
if(s.size() == 6){
flag = true;
break;
}
s = s.substr(6);
}
else if(s[0] == 'm' && s[1] == 'a' && s[2] == 'e' && s[3] == 'r' && s[4] == 'd'){
if(s.size() == 5){
flag = true;
break;
}
s = s.substr(5);
}
else if(s[0] == 'e' && s[1] == 's' && s[2] == 'a' && s[3] == 'r' && s[4] == 'e'){
if(s.size() == 5){
flag = true;
break;
}
s = s.substr(5);
}
else break;
}
if(flag) YES();
else NO();
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
solve();
} | 0 | 1,738,308 |
#include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
if (n == 1) n = 14;
if (m == 1) m = 14;
if (n > m) cout << "Alice\n";
else if (n < m) cout << "Bob\n";
else cout << "Draw\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll num = 998244353;
ll ex(ll x,ll n){
if(n==0)return 1;
else if(n%2==1)return ex(x,n-1)*x%num;
else return ex(x*x%num,n/2)%num;
};
int main(){
ll n;
cin >> n;
vector<ll> d(n);
unordered_map<ll,ll> mp;
ll ans = 1;
ll mx = 0;
for(ll i = 0; i < n; i++){
cin >> d[i];
if(d[i] > mx) mx = d[i];
}
for(ll i = 0; i < n; i++) mp[d[i]]++;
for(ll i = 1; i < mx; i++){
ans *= ex(mp[i],mp[i+1]);
ans %= num;
}
if(d[0] != 0 || mp[0] > 1) ans = 0;
cout << ans << endl;
} | 0 | 72,897,229 |
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <functional>
#include <queue>
#include <set>
#include <map>
#include <numeric>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cctype>
#define rep(i, a) REP(i, 0, a)
#define REP(i, a, b) for(int i = a; i < b; ++i)
typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> P;
typedef std::pair<P, int> PP;
const double esp = 1e-9;
const int infi = (int)1e+9 + 10;
const ll infll = (ll)1e+17 + 10;
int main(){
int a, b, c, cnt = 0;
std::cin >> a >> b >> c;
REP(i, a, b + 1){
if (c % i == 0)++cnt;
}
std::cout << cnt << std::endl;
return 0;
} | #include <bits/stdc++.h>
#define FOR(i,a,b) for (int i=(a);i<(b);++i)
#define REP(i,n) for (int i=0;i<(n);++i)
using namespace std;
int main() {
int N;
cin >> N;
vector<string> S(N);
REP(i, N) cin >> S[i];
int result = 0;
REP(A, N) {
function<char(int, int)> T = [&](int i, int j) {
return S[(i + A) % N][j];
};
bool is_symmetric = true;
REP(i, N) FOR(j, i + 1, N) {
if (T(i, j) != T(j, i)) {
is_symmetric = false;
break;
}
}
if (is_symmetric) ++result;
}
result *= N;
cout << result << endl;
return 0;
} | 0 | 27,298,238 |
#include<bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define rep2(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define rep_inv(i, n, m) for(int i = (int)(n); i > (int)(m); i--)
using namespace std;
using ll = long long;
using vl = vector<ll>;
using vc = vector<char>;
using vvl = vector<vl>;
using vvc = vector<vc>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
int main(){
ll x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
ll vx = x2 - x1, vy = y2 - y1;
cout << x2 - vy << ' ' << y2 + vx << ' ' << x1 - vy << ' ' << y1 + vx << "\n";
return 0;
} | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int main(void)
{
int n;
string s1,s2;
string kurai = "mcxi";
vector<int> v1(4),v2(4);
vector<int> sum(4);
int temp;
char c;
int i,i1,i2;
cin >> n;
for(i=0; i<n; i++){
cin >> s1 >> s2;
for(i1=0; i1<4; i1++){
v1[i1] = 0;
v2[i1] = 0;
sum[i1] = 0;
}
temp = 1;
for(i1=0; i1<s1.length(); i1++){
if ('2' <= s1[i1] && s1[i1] <= '9'){
temp = s1[i1] - 48;
continue;
}
for(i2=0; i2<4; i2++){
if (s1[i1] == kurai[i2]){
v1[i2] = temp;
temp = 1;
break;
}
}
}
temp = 1;
for(i1=0; i1<s2.length(); i1++){
if ('2' <= s2[i1] && s2[i1] <= '9'){
temp = s2[i1] - 48;
continue;
}
for(i2=0; i2<4; i2++){
if (s2[i1] == kurai[i2]){
v2[i2] = temp;
temp = 1;
break;
}
}
}
for(i1=3; i1>=0; i1--){
sum[i1] = sum[i1] + v1[i1] + v2[i1];
if (sum[i1]>=10){
sum[i1] = sum[i1] % 10;
sum[i1-1]++;
}
}
for(i1=0; i1<4; i1++){
if (sum[i1] == 0) continue;
else if (sum[i1] == 1){
cout << kurai[i1];
}
else {
c = sum[i1] + 48;
cout << c << kurai[i1];
}
}
cout << endl;
}
return 0;
} | 0 | 80,831,871 |
#include <iostream>
#include <string>
#include <cmath>
#include <algorithm>
#include <stack>
#include <vector>
#include <stdio.h>
using namespace std;
int n;
string s;
char s1;
int k;
int main() {
cin >> n >> s >> k;
s1 = s[k - 1];
for (int i = 0; i < n; i++) {
if (s1 != s[i]) s[i] = '*';
}
cout << s << endl;
return 0;
} | #include <iostream>
#include <cstdio>
using namespace std;
const int MAX_N = 10000;
struct UnionFind
{
int par[MAX_N];
int rank[MAX_N];
void init(int n){
for(int i = 0; i < n; i++){
par[i] = i;
rank[i] = 0;
}
}
int find(int x){
if(par[x] == x) return x;
else return par[x] = find(par[x]);
}
void unite(int x, int y){
x = find(x);
y = find(y);
if(x == y) return;
if(rank[x] < rank[y]) par[x] = y;
else{
par[y] = x;
if(rank[x] == rank[y]) rank[x]++;
}
}
bool same(int x, int y){
return find(x) == find(y);
}
};
int main()
{
int n, q;
cin >> n >> q;
UnionFind uf;
uf.init(n);
for(int i = 0; i < q; i++){
int c, x, y;
cin >> c >> x >> y;
if(c == 0) uf.unite(x, y);
if(c == 1){
if(uf.same(x, y))
cout << 1 << endl;
else
cout << 0 << endl;
}
}
} | 0 | 28,185,553 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> p_ll;
typedef vector<pair<ll, ll>> vec_p;
#define REP(i, x) for (ll i = 0; i < (ll)(x); i++)
#define REPS(i, x) for (ll i = 1; i <= (ll)(x); i++)
#define RREP(i, x) for (ll i = ((ll)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (ll i = ((ll)(x)); i > 0; i--)
#define all(x) (x).begin(), (x).end()
const ll MOD = pow(10, 9) + 7;
const ll LLINF = pow(2, 61) - 1;
const int INF = pow(2, 30) - 1;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
ll R,G,B,N;
string S;
cin >> R>>G>>B>>N;
ll tmp;
ll ans = 0;
REP(i, N / R+1)
{
REP(j,N/G+1){
tmp = N - R * i - G * j;
if(tmp>=0&&tmp%B==0){
ans++;
}
}
}
cout << ans << endl;
} | #include<bits/stdc++.h>
#include<ctype.h>
# define pb push_back
#define fst first
#define sec second
#define For(i,a,b) for(int i=a;i<b;i++)
#define ll long long int
#define ull unsigned long long int
#define mod 1000000007
#define fo(i,n) for(ll i=0;i<n;i++)
#define endl "\n"
#define rev(i,n) for(ll i=n-1;i>=0;i--)
#define fo1(i,n) for(ll i=1;i<=n;i++)
#define boolsize 1000001
#define pi pair<ll,ll>
#define vi vector<ll>
#define vii vector<pi>
using namespace std;
template<typename T>
void showvector(vector <T> v)
{
for(T x:v)
cout<<x<<" ";
cout<<endl;
}
template<typename T>
void showvector1(vector <T> v)
{
ll n=v.size();
fo1(i,n-1)
cout<<v[i]<<endl;
}
template<typename T>
void showset(set <T> s)
{
for(T x: s)
cout<<x<<" ";
cout<<endl;
}
template<class T>
void showvectorpair(vector<T> v)
{
for(auto it=v.begin();it!=v.end();it++)
cout<<it->first<<" "<<it->second<<endl;
cout<<endl;
}
template<typename T,typename P>
void showmap(map <T,P> m)
{
for(auto it=m.begin();it!=m.end();it++)
cout<<it->first<<" "<<it->second<<endl;
cout<<endl;
}
template<typename T>
bool comp(T a,T b)
{
return (a>b);
}
template<class T>
bool comppair(T a,T b)
{
if(a.first==b.first)
return(a.second>b.second);
return (a.first>b.first);
}
bool sameparity(ll a,ll b)
{
return (a%2==b%2);
}
bool difparity(ll a,ll b)
{
return !(a%2==b%2);
}
bool isprime(ll x)
{ if(x<=1)
return false;
for(ll i=2;i<=sqrt(x);i++)
{
if(x%i==0)
return false;
}
return true;
}
bool iseven(ll x)
{
return !(x%2);
}
bool isodd(ll x)
{
return (x%2);
}
void vfun()
{
ll n,k;
cin>>n;
vector <ll> v(n);
fo(i,n)
cin>>v[i];
sort(v.begin(),v.end(),comp<ll>);
ll a=-1,b=-1;
fo(i,n)
{
if((i+1<n )&& (v[i]==v[i+1]))
{
if(a!=-1)
{
b=v[i];
break;
}
if(a==-1)
a=v[i];
i++;
}
}
if(a==-1 || b==-1)
cout<<"0\n";
else
cout<<a*b<<endl;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);cout.tie(0);
ll test=1;
while(test--)
{
vfun();
}
} | 0 | 48,108,838 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i=0; i<(int)(n); i++)
int main(){
int i, N, M, a, b, ans=0; cin >> N >> M; vector<int> ar(N-1);
map<pair<int, int>, bool> C;
REP(i, M){ cin >> a >> b; a--; b--; C[make_pair(a, b)]=true; C[make_pair(b, a)]=true; }
REP(i, N-1){ ar[i]=i; }
do {
bool f=true;
REP(i, N-1){
if(i==0){ if(C[make_pair(0, ar[i]+1)]==false){ f=false; break; } }
else{ if(C[make_pair(ar[i-1]+1, ar[i]+1)]==false){ f=false; break; } }
}
if(f){ ans++; }
} while(next_permutation(ar.begin(), ar.end()));
cout << ans << "\n";
} | #include<iostream>
#include<vector>
#include<map>
#include<set>
#include<string>
#include<utility>
#include<algorithm>
#include<cstdio>
#include<iomanip>
#include<queue>
#include<stack>
#define ll int64_t
#define Rep(i, n) for (ll i = 0; i < n; i++)
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
vector<ll> A(N);
Rep (i, N) {
cin >> A[i];
}
ll now = 2, ans = A[0] - 1;
Rep (i, N-1) {
ans += ((A[i+1] + now - 1) / now - 1 );
if (A[i+1] == now) {
now++;
}
}
cout << ans << "\n";
} | 0 | 14,187,560 |
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
#define double long double
using datas=pair<ll,ll>;
using ddatas=pair<double,double>;
using tdata=pair<ll,datas>;
using vec=vector<ll>;
using mat=vector<vec>;
using pvec=vector<datas>;
using pmat=vector<pvec>;
#define For(i,a,b) for(i=a;i<(ll)b;i++)
#define bFor(i,b,a) for(i=b-1;i>=(ll)a;i--)
#define rep(i,N) For(i,0,N)
#define rep1(i,N) For(i,1,N)
#define brep(i,N) bFor(i,N,0)
#define all(v) (v).begin(),(v).end()
#define allr(v) (v).rbegin(),(v).rend()
#define vsort(v) sort(all(v))
#define vrsort(v) sort(allr(v))
#define endl "\n"
#define pb push_back
#define eb emplace_back
#define print(v) cout<<v<<endl
#define printyes cout<<"Yes"<<endl
#define printno cout<<"No"<<endl
#define printYES cout<<"YES"<<endl
#define printNO cout<<"NO"<<endl
#define output(v) do{bool f=0;for(auto outi:v){cout<<(f?" ":"")<<outi;f=1;}cout<<endl;}while(0)
const ll mod=1000000007;
const ll inf=1LL<<60;
const double PI = acos(-1);
const double eps = 1e-9;
template<class T> inline bool chmax(T& a,T b){bool x=a<b;if(x)a=b;return x;}
template<class T> inline bool chmin(T& a,T b){bool x=a>b;if(x)a=b;return x;}
void startupcpp(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(15);
}
double distance(ddatas x,ddatas y){
double a=x.first-y.first,b=x.second-y.second;
return sqrt(a*a+b*b);
}
ll modinv(ll a) {
ll b=mod,u=1,v=0,t;
while(b){
t=a/b;
a-=t*b; swap(a,b);
u-=t*v; swap(u,v);
}
return (u+mod)%mod;
}
ll moddevide(ll a,ll b){return (a*modinv(b))%mod;}
vec modncrlistp,modncrlistm;
ll modncr(ll n,ll r){
if(n<r)return 0;
ll i,size=modncrlistp.size();
if(size<=n){
modncrlistp.resize(n+1);
modncrlistm.resize(n+1);
if(!size){
modncrlistp[0]=modncrlistm[0]=1;
size++;
}
For(i,size,n+1){
modncrlistp[i]=modncrlistp[i-1]*i%mod;
modncrlistm[i]=modinv(modncrlistp[i]);
}
}
return modncrlistp[n]*modncrlistm[r]%mod*modncrlistm[n-r]%mod;
}
ll modpow(ll a,ll n){
ll res=1;
while(n>0){
if(n&1)res=res*a%mod;
a=a*a%mod;
n>>=1;
}
return res;
}
ll gcd(ll a,ll b){if(!b)return a;return (a%b==0)?b:gcd(b,a%b);}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
ll countdigits(ll n){
ll ans=0;
while(n){n/=10;ans++;}
return ans;
}
ll sumdigits(ll n){
ll ans=0;
while(n){ans+=n%10;n/=10;}
return ans;
}
int main(){
startupcpp();
int codeforces;cin>>codeforces;while(codeforces--){
ll A,B,ans=0,ok,ng,mid;
cin>>A>>B;
if(A>B)swap(A,B);
ans=(A-1)<<1;
if(A==B){
print(ans);
continue;
}
ok=A;ng=B;
while(ng-ok>1){
mid=(ok+ng)>>1;
((mid*mid<=A*B-1)?ok:ng)=mid;
}
ans+=2*(ok-A)+(ok*ng<A*B);
print(ans);
}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<ll, ll>;
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define _GLIBCXX_DEBUG
#define ALL(x) (x).begin(), (x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define INF 1000000000000
#define inf 2147483647
#define MOD 1000000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define CST(x) cout << fixed << setprecision(x)
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 gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
int sumDight(int x) {
int sum = 0;
while (x > 0) {
sum += (x % 10);
x /= 10;
}
return sum;
}
int divideReverse(int x) {
int reverse = 0;
int r;
while (x > 0) {
r = x % 10;
reverse = reverse * 10 + r;
x /= 10;
}
return reverse;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
reverse(ALL(s));
string t[4] = {"dream", "dreamer", "erase", "eraser"};
rep(i, 4) reverse(ALL(t[i]));
bool a = true;
for (int i = 0; i < (int)s.size();) {
bool b = false;
rep(j, 4) {
if (s.substr(i, t[j].size()) == t[j]) {
b = true;
i += t[j].size();
}
}
if (!b) {
a = false;
break;
}
}
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
} | 0 | 67,718,925 |
#include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define REP(i,s,n) for(int i=s;i<n;i++)
#define MOD 1000000007
#define NUM 2520
#define INF (1LL<<50)
#define DEBUG 0
#define mp(a,b) make_pair(a,b)
#define L 0
#define R 1
int main(){
lli n;
cin>>n;
n*=2;
string s;
cin>>s;
lli data[200010];
data[0] = L;
lli cnt[2]={0};
cnt[L]=1;
for(lli i=1;i<n;i++){
if(s.at(i-1)!=s.at(i))data[i] = data[i-1];
else data[i] = (data[i-1]+1)%2;
cnt[data[i]]++;
}
if(cnt[L]!=cnt[R] || data[n-1] == L || s.at(0)=='W' || s.at(n-1) == 'W'){
cout<<0<<endl;
return 0;
}
lli lCnt=0;
lli pattern=1;
for(lli i=0;i<n;i++){
if(data[i]==L)lCnt++;
else{
pattern *= lCnt;
pattern %= MOD;
lCnt--;
}
}
lli ans = pattern;
for(lli i=1;i<=n/2;i++){
ans *= i;
ans %= MOD;
}
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using pint = pair<int, int>;
using ll = long long;
using ull = unsigned long long;
using vll = vector<long long>;
using pll = pair<ll, ll>;
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define VREP(s, ite) for (auto ite = s.begin(); ite != s.end(); ++ite)
#define FI first
#define SE second
#define ALL(v) v.begin(), v.end()
#define ciosup \
cin.tie(0); \
ios::sync_with_stdio(false);
#define eb emplace_back
#define vint vector<int>
constexpr ll INF = 1e15 + 7LL;
constexpr ll MOD = ll(1e9) + 7LL;
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
is >> v[i];
}
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size() - 1; ++i) {
os << v[i] << " ";
}
if (v.size() > 0) {
os << v[v.size() - 1] << endl;
}
return os;
}
ll extgcd(ll a, ll b, ll &x, ll &y) {
ll d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
} else {
x = 1;
y = 0;
}
return d;
}
ll mod_inv(ll a, ll m = MOD) {
ll x, y;
extgcd(a, m, x, y);
return (m + x % m) % m;
}
vector<ll> fact, invfact;
void calc_fact(int n, ll m = MOD) {
fact.resize(n + 1);
invfact.resize(n + 1);
fact[0] = invfact[0] = 1;
REP(i, n) {
fact[i + 1] = fact[i] * (i + 1) % m;
invfact[i + 1] = invfact[i] * mod_inv(i + 1) % m;
}
}
ll perm(int n, int k, ll m = MOD) {
if (n < 0 || k < 0 || k > n) return 0;
return fact[n] * invfact[n - k] % m;
}
ll comb(int n, int k, ll m = MOD) {
if (n < 0 || k < 0 || k > n) return 0;
return (fact[n] * invfact[n - k] % m) * invfact[k] % m;
}
int main() {
int h,n;
cin >> h >> n;
vll a(n),b(n);
REP(i, n) { cin >> a[i] >> b[i]; }
vector<vll> dp(n + 1, vll(h+1, LLONG_MAX/2LL));
REP(i, n + 1) { dp[i][0] = 0; }
REP(i,n){
REP(j,h+1){
dp[i+1][j] = min(dp[i+1][j],dp[i][j]);
if (j - a[i] >= 0){
dp[i + 1][j] = min(dp[i + 1][j], dp[i + 1][j - a[i]] + b[i]);
} else {
dp[i + 1][j] = min(dp[i + 1][j], b[i]);
}
}
}
cout << dp[n][h] << endl;
} | 0 | 98,361,397 |
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <sstream>
#include <vector>
using namespace std;
#define int long long int
#define rep(i, n) for (int i = 0; i < n; ++i)
#define all(x) (x).begin(), (x).end()
#define capi(x) int x;cin>>x
signed main() {
capi(n);
set<int> s;
rep(i, n) {
capi(a);
s.insert(a);
}
if (s.size() == n) cout << "YES";
else 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;
using P = pair<int, int>;
int main() {
int n, k;
cin >> n >> k;
int m = (n-1) * (n-2) / 2 - k;
if (m < 0) {
cout << -1 << endl;
return 0;
}
cout << n-1+m << endl;
for (int i = 1; i < n; ++i) {
cout << 1 << " " << i+1 << endl;
}
int s = 0;
for (int i = 1; i < n; ++i) {
if (s >= m) break;
for (int j = i+1; j < n; ++j) {
if (s >= m) break;
cout << i+1 << " " << j+1 << endl;
s++;
}
}
return 0;
} | 0 | 93,580,180 |
#include <bits/stdc++.h>
using namespace std;
#define BROKE 1
int main() {
int64_t n,m;
cin>>n>>m;
vector<int64_t> broken(n+1);
for(int i=0;i<m;i++){
int wk=0;
cin>>wk;
broken.at(wk)=BROKE;
}
vector<int64_t> route(n+1);
route.at(0)=1;
for(int i=1;i<=n;i++){
int route1,route2;
if(broken.at(i-1)==BROKE)
route1 = 0;
else
route1 = route.at(i-1);
if(i<2 || broken.at(i-2)==BROKE)
route2 = 0;
else
route2 = route.at(i-2);
if(broken.at(i)==BROKE)
route.at(i)=0;
else
route.at(i) += (route1+route2)%1000000007;
}
cout<<route.at(n)<<endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int n, k;
while( cin >> n >> k, n+k ) {
int max_sum, sum = 0, data[100000];
for(int i=0; i<k; i++) {
cin >> data[i];
sum += data[i];
}
max_sum =sum;
for(int i=k; i<n; i++) {
cin >> data[i];
sum -= data[i-k];
sum += data[i];
max_sum = max(max_sum, sum);
}
cout << max_sum << endl;
}
} | 0 | 12,758,431 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
int main()
{
int a, b;
cin >> a >> b;
if (a == 1)
{
a *= 100;
}
if (b == 1)
{
b *= 100;
}
cout << (a == b ? "Draw" : a > b ? "Alice" : "Bob") << endl;
return 0;
} | #include<iostream>
#include<map>
#include<set>
#include<string>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<limits>
#include<sstream>
#include<unordered_map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef int itn;
typedef vector<int> vi;
typedef vector<ll> vl;
const int inf = numeric_limits<int>::max() >> 2;
const ll linf = numeric_limits<ll>::max() >> 2;
const ull ulinf = numeric_limits<ull>::max() >> 2;
const double pi = acos(-1);
const int dx[4]={1,0,-1,0};
const int dy[4]={0,1,0,-1};
const int dx8[8]={-1,0,1,-1,1,-1,0,1};
const int dy8[8]={-1,-1,-1,0,0,1,1,1};
#define p_queue(i) priority_queue<i>
#define rp_queue(i) priority_queue<i, vector<i>, greater<i>>
#define umap(i,j) unordered_map<i,j>
#define P(p) cout<<(p)<<endl
#define PS(p) cout<<(p)<< " "
#define IN cin >>
#define rep(i,m,n) for(int i = (m); i < (int)(n); i++)
#define rrep(i,m,n) for(int i = (m-1); i >= (int)(n); i--)
#define inrep(n,a) for(int i = 0; i < (int)(n); i++)cin >> a[i];
#define mod(i) ((i)%(ll)(1e9 + 7))
#define divm(a,b) (mod(a * modpow((ll)b,(ll)(1e9+5))))
#define rsort(a,b,c) sort(a, b, greater<c>())
#define vsort(v) sort(v.begin(), v.end())
#define rvsort(v,c) sort(v.begin(), v.end(), greater<c>())
#define ft first
#define sd second
#define pb push_back
#define it insert
#define sz(x) ((int)(x).size())
#define lb(a,n,k) (lower_bound(a,a+n,k) - a)
#define vlb(a,k) (lower_bound(a.begin(),a.end(),k) - a.begin())
#define ub(a,n,k) (upper_bound(a,a+n,k) - a)
#define vub(a,k) (upper_bound(a.begin(),a.end(),k) - a.begin())
#define YES cout<<"YES"<< endl
#define NO cout<<"NO"<<endl
#define Yes cout<<"Yes"<<endl
#define No cout<<"No"<<endl
#define yes cout<<"yes"<<endl
#define no cout<<"no"<<endl
#define ret return
ll modpow(ll i,ll j){ ll tmp=1; while(j){ if(j%2)tmp=mod(tmp*i);i=mod(i*i);j/=2;}return tmp;}
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; }
vector<string> split(const string &str, char sep){
vector<string> v;
stringstream ss(str);
string buffer;
while( getline(ss, buffer, sep) ) {
v.push_back(buffer);
}
return v;
}
int main(){
ll n;
cin >> n;
ll k = 1;
while(k * (k-1) / 2 < n){
if(k * (k-1) / 2 == n)break;
k++;
}
if(k * (k-1) / 2 == n){
Yes;
P(k);
vector<ll> v[k];
int n = 1;
rep(i,1,k){
rep(j,0,i){
v[i].pb(n++);
}
}
rep(i,1,k)v[0].pb(v[i][0]);
rep(i,2,k)v[1].pb(v[i][sz(v[i])-1]);
rep(i,2,k-1){
rep(j,3+i-2,k)v[i].pb(v[j][i-1]);
}
rep(i,0,k){
PS(sz(v[i]));
rep(j,0,sz(v[i]))PS(v[i][j]);
cout << endl;
}
}else No;
return 0;
} | 0 | 46,972,209 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
int main() {
int N;
cin >> N;
vector<ll> A(N);
rep(i, N) cin >> A[i];
sort(all(A), greater<>());
ll ans = 1;
int cnt = 0;
rep(i, N-1) {
if (cnt < 2 && A[i] == A[i+1]) {
ans *= A[i];
i++;
cnt++;
}
}
if (cnt < 2) ans = 0;
cout << ans << endl;
} | #include<bits/stdc++.h>
#define ll long long int
#define INF 0x3f3f3f3f
#define pb push_back
#define se second
#define fi first
using namespace std;
const int N=1e5+5;
int vis[N],grundy[N];
vector<int> g[N];
void dfs(int u){
vis[u]=1;
for(int v:g[u]){
if(vis[v]) continue;
dfs(v);
grundy[u]^=(grundy[v]+1);
}
}
int main()
{
ios_base::sync_with_stdio(false);cin.tie(NULL);
int n; cin>>n;
for(int i=1;i<n;i++){
int u,v; cin>>u>>v;
g[u].pb(v); g[v].pb(u);
}
dfs(1);
cout<<(grundy[1]?"Alice":"Bob");
return 0;
} | 0 | 69,914,153 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
const ll INF = 1LL << 60;
ll gcd(ll x, ll y){
if(y==0) return x;
else return gcd(y,x%y);
}
ll lcm(ll x, ll y){
return x/gcd(x,y)*y;
}
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 a, b, c, d;
cin >> a >> b >> c >> d;
ll commoncd = lcm(c,d);
ll ans = f(b,c,d) - f(a-1,c,d);
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define FOR(i,a,b) for(int i=(a); i<(b); i++)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
typedef long long ll;
const ll MOD = 1e9+7;
const int MAX = 100005;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main(){
int n; cin >> n;
vector<int> a(n+1);
int key, l, r;
vector<bool> flag(n+1, false);
rep(i,n+1){
cin >> a[i];
if(flag[a[i]]) key = a[i];
flag[a[i]] = true;
}
bool seen = false;
rep(i,n+1){
if(a[i] == key){
if(seen){
r = n-i;
break;
}
else{
seen = true;
l = i;
}
}
}
COMinit();
FOR(i, 1, n+2) cout << (COM(n+1, i) - COM(l+r, i-1) + MOD) % MOD << endl;
} | 0 | 74,504,961 |
#include <iostream>
#include <vector>
#include <string.h>
#include <set>
#include <map>
#include <unordered_map>
#include <assert.h>
#include <algorithm>
#include <queue>
#include <bitset>
#include <stack>
#include <chrono>
#include <random>
#define all(x) x.begin(),x.end()
#define ff first
#define ss second
#define ll long long
#define INF 1000000000000000000
#define MOD 1000000007
#define rnd mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define FIO ios_base::sync_with_stdio(false); cin.tie(NULL);
#define uid uniform_int_distribution <int>
using namespace std;
const ll N = 1LL * 100000 * 100000;
int main() {
ll i = 10;
char ch;
while(true) {
cout << "? " << i << endl;
cin >> ch;
if (ch == 'Y') {
i *= 10;
}
else {
ll lo = i / 10 + 1, hi = i - 1, ans = -1;
while(lo <= hi) {
ll mid = (lo + hi) / 2;
cout << "? " << mid * 10 << endl;
cin >> ch;
if (ch == 'Y') {
ans = mid;
hi = mid - 1;
}
else {
lo = mid + 1;
}
}
cout << "! " << ans << endl;
return 0;
}
if (i == N) {
break;
}
}
while(i > 1) {
cout << "? " << i - 1 << endl;
cin >> ch;
if (ch == 'N') {
cout << "! " << i << endl;
return 0;
}
i /= 10;
}
cout << "! " << 1 << endl;
} | #include<iostream>
#include<iomanip>
#include<algorithm>
#include<bitset>
#include<cctype>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<functional>
#include<limits>
#include<list>
#include<map>
#include<set>
#include<stack>
#include<string>
#include<sstream>
#include<queue>
#include<vector>
using namespace std;
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3fLL
#define MAX 100
int n, M[MAX][MAX] = {};
int d[MAX];
void bfs(int s) {
queue<int> q;
q.push(s);
d[s] = 0;
for (int u; !q.empty();) {
u = q.front(); q.pop();
for (int v = 0; v < n; v++) {
if (M[u][v] == 0)continue;
if (d[v] != INF)continue;
d[v] = d[u] + 1;
q.push(v);
}
}
for (int i = 0; i < n; i++) {
cout << i + 1 << " " << ((d[i] == INF) ? (-1) : d[i]) << endl;
}
}
int main() {
cin >> n;
memset(d, INF, sizeof(d));
for (int i = 0, u, k; i < n; i++) {
cin >> u >> k;
u--;
for (int j = 0, v; j < k; j++) {
cin >> v;
v--;
M[u][v] = 1;
}
}
bfs(0);
return 0;
} | 0 | 26,847,262 |
#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<ll> a(n);
rep(i,n)cin>>a[i];
vector<ll> sum(n+1);
rep(i,n)sum[i+1]=sum[i]+a[i];
map<ll,ll> mp;
rep(i,n+1)mp[sum[i]]++;
ll ans=0;
for(auto x:mp){
ans+=x.second*(x.second-1)/2;
}
cout<<ans<<endl;
} | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#if defined(ENABLE_PRINT)
#define Print(v) \
do {\
cout << #v << ": " << v << endl; \
}while(0)
#define PrintVec(v) \
do {\
for(int __i = 0; __i < v.size(); ++__i) \
{ \
cout << #v << "[" << __i << "]: " << v[__i] << endl; \
}\
}while(0)
#else
#define Print(v) ((void)0)
#define PrintVec(v) ((void)0)
#endif
#define rep(i, n) for(int i = 0; i < (int)(n); ++i)
using ll = int64_t;
const int MaxLayer = 51;
ll len[MaxLayer] = {}, p[MaxLayer] = {};
ll count(int layer, ll index)
{
if(layer == 0)
{
return 1;
}
if(!(index >= 0 && index < len[layer]))
{
printf("layer: %d, index: %ld, len: %ld\n", layer, index, len[layer]);
abort();
}
if(index == 0)
{
return 0;
}
auto center = (len[layer] - 1) / 2;
if(index < center)
{
return count(layer - 1, index - 1);
}
if(index == center)
{
return p[layer - 1] + 1;
}
if(index == len[layer] - 1)
{
return p[layer];
}
return p[layer - 1] + 1 + count(layer - 1, index - len[layer - 1] - 2);
}
int main(int, const char**)
{
ll n, x;
cin >> n >> x;
len[0] = 1;
p[0] = 1;
rep(i, n)
{
len[i + 1] = len[i] * 2 + 3;
p[i + 1] = p[i] * 2 + 1;
}
#if 0
rep(i, n + 1)
{
printf("[%d]: len: %ld, p: %ld\n", i, len[i], p[i]);
}
#endif
auto c = count(n, x - 1);
cout << c << endl;
#if 0
cout << endl;
int ly = 3;
rep(i, len[ly])
{
cout << "i: " << i << ", count: " << count(ly, i) << endl;
}
#endif
return 0;
} | 0 | 48,879,541 |
#include<bits/stdc++.h>
using namespace std;
string up = "QWERTYUIOPLKJHGFDSAZXCVBNM";
string down = "qwertyuioplkjhgfdsazxcvbnm";
signed main(){
char x;
cin>>x;
for(int i=0;i<26;i++){
if(x==up[i]){
cout<<'A';
return 0;
}
if(x==down[i]){
cout<<'a';
return 0;
}
}
} | #include <bits/stdc++.h>
#include<math.h>
#define rep(i,n) for (int i = 0; i < (n) ; ++i)
using namespace std;
using ll = long long ;
using P = pair<int , int> ;
#define PI 3.14159265358979323846264338327950
#define INF 1e18
int main () {
int n ;
cin >> n;
int ans = 0;
for(int i = 1; i <= n; i++){
string s = to_string(i) ;
if(s.size()%2==1){
ans++ ;
}
}
cout << ans << endl ;
} | 0 | 74,175,351 |
#include<iostream>
#include <vector>
using namespace std;
int main() {
long long int n, a, b;
cin >> n >> a >> b;
long long int ans = 0;
ans += (n / (a + b)) * a;
if(n % (a + b) > a) {
ans += a;
}
else {
ans += n % (a + b);
}
cout << ans << "\n";
} | #include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
#include <cmath>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
#include <complex>
#include <unordered_map>
#include <unordered_set>
#include <random>
#include <cassert>
#include <fstream>
#include <utility>
#include <functional>
#define popcount __builtin_popcount
using namespace std;
#include <bits/stdc++.h>
#define rep(i,x) for(long long i=0;i<x;i++)
#define repn(i,x) for(long long i=1;i<=x;i++)
#define rrep(i,x) for(long long i=x-1;i>=0;i--)
#define rrepn(i,x) for(long long i=x;i>1;i--)
#define REP(i,n,x) for(long long i=n;i<x;i++)
#define REPN(i,n,x) for(long long i=n+1;i<x;i++)
#define pr printf
#define re return
#define mod 1000000007
#define INF 1e18+5
const double PI=3.14159265358979323846;
#define fi first
#define se second
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
typedef long long int ll;
typedef pair<long long, long long> P;
vector<pair<long long, long long> > prime_factorize(long long n) {
vector<pair<long long, long long> > res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0) continue;
int num = 0;
while (n % p == 0) { ++num; n /= p; }
res.push_back(make_pair(p, num));
}
if (n != 1) res.push_back(make_pair(n, 1));
return res;
}
vector<long long> calc_divisor(long long n) {
vector<long long> res;
for (long long i = 1LL; i*i <= n; ++i) {
if (n % i == 0) {
res.push_back(i);
long long j = n / i;
if (j != i) res.push_back(j);
}
}
sort(res.begin(), res.end());
return res;
}
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll gcd(const vector<ll> &v) {
ll ret = v[0];
for (ll i = 1; i < v.size(); i++)
ret = gcd(ret, v[i]);
return ret;
}
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll lcm(const vector<ll> &v) {
ll ret = v[0];
for (ll i = 1; i < v.size(); i++)
ret = lcm(ret, v[i]);
return ret;
}
vector<pair<long long,long long>> g[200020];
ll s[200020];
bool used[200020];
ll A,B,C,D,H,K,M,N,Q,T,W,X,Y;
double dA,dB,dC,dH,dK,dM,dN,dQ,dT,dW,dX,dY;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
long long ans,sum,cnt,cnt1,flg,flg1,flg2;
long long max,max1;
long long min,min1;
long long wk,wk1;
max=max1=wk=wk1=sum=ans=cnt=cnt1=flg1=flg2=0;
min=min1=INF;
double dwk,dwk1,dsum,dsum1,dans,dans1;
dwk=dwk1=dsum=dsum1=dans=dans1=0;
cin >> N;
std::vector<ll> v(N);
rep(i, N) {
cin >> v[i];
}
cout << lcm(v) << endl;
return 0;
re 0;
} | 0 | 85,565,355 |
#include<bits/stdc++.h>
using namespace std;
#define p pair<int,int>
int N, M;
char A[10];
int num[10] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
string dp[10010];
int main(){
cin >> N >> M;
for(int i = 0; i < M; i++){
cin >> A[i];
if(dp[num[A[i] - '0']] == ""){
dp[num[A[i] - '0']] = A[i];
}else if(dp[num[A[i] - '0']][0] - '0' < A[i] - '0'){
dp[num[A[i] - '0']] = A[i];
}
}
for(int i = 0; i < N; i++){
for(int j = 0; j < M; j++){
if(dp[i] == "") continue;
string str1 = dp[i] + A[j];
string& str2 = dp[i + num[A[j] - '0']];
if(str2.size() < str1.size()){
str2 = str1;
} else if(str2.size() == str1.size() && str1 > str2){
str2 = str1;
}
}
}
cout << dp[N] << endl;
return 0;
} | #include <bits/stdc++.h>
#define s second
#define f first
#define pb push_back
#define endl '\n'
#define all(x) (x).begin(), (x).end()
#define _ ios_base::sync_with_stdio(0);cin.tie(0);
using namespace std;
typedef double ld;
typedef long long ll;
typedef pair<int,int> pii;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3fLL;
int main(){ _
string S;
cin >> S;
for(auto &i : S){
if(i == ',') i = ' ';
}
cout << S << endl;
return 0;
} | 0 | 89,075,864 |
#include <bits/stdc++.h>
#include <string.h>
#define MAX 10000
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(),(a).end()
#define rep(i,a,n) for(int i=a; i<n; i++)
#define r0 return 0
#define INF (int)1e15
int main(){
string s;
cin>>s;
int a=0,b=0;
for(int i=0;i<s.length();i++){
if(i%2 == 0){
if(s[i] == '0')
a++;
}else {
if(s[i] == '1')
a++;
}
}
for(int i=0;i<s.length();i++){
if(i%2 == 0){
if(s[i] == '1')
b++;
}else if(i%2 == 1){
if(s[i] == '0')
b++;
}
}
cout<<min(a,b)<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll unsigned long long int
#define mod 1000000007
bool isPrime[1000001];
ll power(ll a,ll b)
{
ll result = 1;
while(b>0)
{
if(b%2)
{
result = (a*result)%mod;
}
a = (a*a)%mod;
b = b/2;
}
return result;
}
int gcd(int a,int b)
{
if(b==0)
{
return a;
}
return gcd(b,a%b);
}
void sieve()
{
memset(isPrime,1,sizeof(isPrime));
isPrime[0] = isPrime[1] = 0;
for(int i=2;i*i<=1000000;i++)
{
if(isPrime[i])
{
for(int j=i*i;j<=1000000;j+=i)
{
isPrime[j] = 0;
}
}
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL),cout.tie(NULL);
int t,n;
t = 1;
for(int i=0;i<t;i++)
{
string s1,s2;
cin>>s1>>s2;
if(s1.size()!=s2.size()-1)
{
cout<<"No";
}
else
{
bool x = 0;
for(int i=0;i<s1.size();i++)
{
if(s1[i]!=s2[i])
{
x = 1;
break;
}
}
if(!x)
{
cout<<"Yes";
}
else
{
cout<<"No";
}
}
}
return 0;
} | 0 | 38,882,367 |
#include <bits/stdc++.h>
#define rep0(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef tuple<string, int, int> TU;
typedef tuple<int, int, int> TI;
int main()
{
int a,b,k;
cin >> a >> b >> k;
ll res=0;
ll now=__gcd(a,b);
while(k>0){
if(a%now==0&&b%now==0){
k--;
}
now--;
}
cout << now+1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rrep(i, n) for (ll i = (n - 1); i >= 0; --i)
#define blank(ans) cout << (ans) << " ";
#define mp(p, q) make_pair(p, q)
#define mt(p, q, r) make_tuple(p, q, r)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef string str;
typedef vector<ll> vll;
typedef vector<ld> vd;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<str> vs;
typedef vector<vector<ll>> vvll;
typedef vector<vector<ld>> vvd;
typedef vector<vector<bool>> vvb;
typedef vector<vector<char>> vvc;
typedef vector<vector<str>> vvs;
typedef vector<pair<ll, ll>> vpll;
typedef vector<tuple<ll, ll, ll>> vtlll;
const ld PI = acos(-1.0);
const ll MAX = 9000000000000000000;
const ll MIN = -9000000000000000000;
const ld DMAX = 4500;
const ld DMIN = -4500;
const ll MOD = 1000000007;
template <typename T>
void fin(T a)
{
cout << a << endl;
exit(0);
}
bool IsPrime(ll num)
{
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
ld sqrtNum = sqrt(num);
for (ll i = 3; i <= sqrtNum; i += 2)
{
if (num % i == 0)
return false;
}
return true;
}
void Main()
{
str s; cin >> s;
ll n; cin >> n;
if(s[0] != s[s.size() - 1])
{
ll flag = 1;
ll ans = 0;
for(ll i = 1;i < s.size();i++)
{
if(s[i - 1] == s[i]) flag++;
else
{
ans += (flag / 2) * n;
flag = 1;
}
}
ans += (flag / 2) * n;
fin(ans);
}
else
{
ll flag = 1;
ll ans = 0;
vll K;
ll h = 0;
for(ll i = 1;i < s.size();i++)
{
if(s[i - 1] == s[i]) flag++;
else
{
K.pb(flag);
flag = 1;
h = i;
}
if(i == s.size() - 1&&i != h)
{
K.pb(flag);
}
}
if(s.size() == 1) K.pb(1);
if(K.size() != 1)
{
ans += (K[0] / 2);
ans += (K[K.size() - 1] / 2);
K[0] = K[0] + K[K.size() - 1];
K.pop_back();
ans += (K[0] / 2 * (n - 1));
for(ll i = 1;i < K.size();i++)
{
ans += (K[i] / 2 * n);
}
fin(ans);
}
else
{
ans += K[0] * n / 2;
fin(ans);
}
}
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
Main();
return 0;
} | 0 | 55,746,141 |
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
using namespace std;
int main(void)
{
string str;
getline(cin, str);
vector<string> vStr;
while (str.find(' ') != -1)
{
vStr.push_back(str.substr(0, str.find(' ')));
str.erase(0, str.find(' ') + 1);
}
vStr.push_back(str);
int a, b, c;
a = stoi(vStr.at(0));
b = stoi(vStr.at(1));
c = stoi(vStr.at(2));
if (a < b && b < c)
{
cout << "Yes" << endl;
}
else
{
cout << "No" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize ("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define mod 1000000007
#define pb emplace_back
#define mp make_pair
#define fi first
#define sec second
typedef long long ll;
typedef long double ld;
#define pii pair<ll,ll>
#define vi vector< ll >
#define vvi vector< vi >
#define vpi vector< pii >
#define vvpi vector< vpi >
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define test(t) ll t;cin>>t;while(t--)
#define mem(a,b) memset(a,b,sizeof(a))
#define inn freopen("input.txt", "r", stdin)
#define outt freopen("output.txt", "w", stdout)
#define all(arr) arr.begin(),arr.end()
#define fr(i,n) for(ll i=0;i<(n);++i)
#define rep(i,a,b) for(ll i=a;i<=b;++i)
#define per(i,a,b) for(ll i=a;i>=b;i--)
#define remin(a,b) (a=min((a),(b)))
#define remax(a,b) (a=max((a),(b)))
#ifndef ONLINE_JUDGE
#define debarr(a,n)cerr<<#a<<":";for(int i=0;i<n;i++)cerr<<a[i]<<" ";cerr<<endl;
#define debmat(mat,row,col)cerr<<#mat<<":\n";for(int i=0;i<row;i++){for(int j=0;j<col;j++)cerr<<mat[i][j]<<" ";cerr<<endl;}
#define pr(...)dbs(#__VA_ARGS__,__VA_ARGS__)
template<class S,class T>ostream &operator<<(ostream &os,const pair<S,T> &p){return os<<"("<<p.first<<","<<p.second<<")";}
template<class T>ostream &operator<<(ostream &os,const vector<T> &p){os<<"[";for(auto&it:p)os<<it<<" ";return os<<"]";}
template<class T>ostream &operator<<(ostream &os,const set<T>&p){os<<"[";for(auto&it:p)os<<it<<" ";return os<<"]";}
template<class T>ostream &operator<<(ostream &os,const multiset<T>&p){os<<"[";for(auto&it:p)os<<it<<" ";return os<<"]";}
template<class S,class T>ostream &operator<<(ostream &os,const map<S,T>&p){os<<"[";for(auto&it:p)os<<it<<" ";return os<<"]";}
template<class T>void dbs(string str,T t){cerr<<str<<":"<<t<<"\n";}
template<class T,class...S>void dbs(string str,T t,S... s){int idx=str.find(',');cerr<<str.substr(0,idx)<<":"<<t<<",";dbs(str.substr(idx+1),s...);}
#else
#define pr(...){}
#define debarr(a,n){}
#define debmat(mat,row,col){}
#endif
ll power(ll x,ll y){ll res = 1;while(y){if(y&1) res = (res*x)%mod;y=y/2,x=(x*x)%mod;}return res%mod;}
ll n,k;
ll func(vpi arr,ll bits)
{
if(bits==-1)
{
ll s = 0;
for(auto v:arr)
s+=v.sec;
return s;
}
if(k&(1LL<<bits))
{
ll s = 0;
for(auto v:arr)
{
if(!(v.fi&(1LL<<bits)))
s+=v.sec;
}
return max(func(arr,bits-1),s);
}
else
{
vpi temp;
for(auto v:arr)
{
if(!(v.fi&(1LL<<bits)))
temp.pb(v);
}
return func(temp,bits-1);
}
}
signed main()
{
fast;
cin>>n>>k;
map < ll , ll > lol;
fr(i,n)
{
ll a,b;
cin>>a>>b;
lol[a]+=b;
}
vpi arr(lol.size());
for(auto v:lol)
arr.pb(v);
cout<<func(arr,30);
} | 0 | 58,030,479 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
cin >> x >> y;
if (y % 2 == 1){
cout << "No" << endl;
}
else {
int min = (y / 4) + (y - 4 * (y / 4)) / 2;
int max = y /2;
if (min <= x && x <= max){
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i,n) for (int i = 1; i <= (int)(n); i++)
int main()
{
int n,k;
cin >> n >> k;
ld p[n+1];
rep1(i,n)
{
int score = i;
if(score >= k)
{
while(i <= n)
{
p[i] = (long double)(1.0/(long double)n);
i++;
}
break;
}
p[i] = (long double)(1.0/(long double)n);
while(score < k)
{
score *= 2;
p[i] *= (long double)(1.0/2.0);
}
}
ld ans = 0.0;
rep1(i,n)
{
ans += (long double)p[i];
}
cout << fixed;
cout << setprecision(20);
cout << (long double)ans << endl;
} | 0 | 33,478,410 |
#include <iostream>
#include <map>
#include <string>
using namespace std;
#define loop(i,a,b) for(int i=(a); i<(int)(b); i++)
#define rep(i,b) loop(i,0,b)
int f(string const & s){
int p = 0, res = 0;
while(p < (int)s.size()){
int n = 0;
while(isdigit(s[p])){
n *= 10;
n += s[p]-'0';
p++;
}
n += n==0;
int m[256];
m[(int)'m'] = 1000;
m[(int)'c'] = 100;
m[(int)'x'] = 10;
m[(int)'i'] = 1;
res += m[(int)s[p]] * n;
p++;
}
return res;
}
string g(int n){
string res;
char c[] = "ixcm";
rep(i,4){
int k = n%10;
n /= 10;
if(k == 0) continue;
res += c[i];
if(k!=1) res += k+'0';
}
rep(i,res.size()/2) swap(res[i], res[res.size()-1-i]);
return res;
}
int main(){
int n;
cin >> n;
rep(i,n){
string s, t;
cin >> s >> t;
cout << g(f(s)+f(t)) << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int n;
int main() {
scanf("%d", &n);
vector<int> a(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
auto check = [&](int b) {
map<int, int> s;
for (int i = 0; i < n - 1; ++i) {
if (a[i] >= a[i + 1]) {
while (!s.empty() && s.rbegin()->first >= a[i + 1]) {
s.erase(--s.end());
}
for (int j = a[i + 1] - 1; ~j; --j) {
++s[j];
if (s[j] == b) {
s.erase(j);
} else {
break;
}
if (!j) {
return false;
}
}
}
}
return true;
};
bool flag = true;
for (int i = 0; i < n - 1; ++i) {
if (a[i] >= a[i + 1]) {
flag = false;
break;
}
}
if (flag) {
puts("1");
return 0;
}
int l = 2, r = n + 1;
while (l < r) {
int mid = l + r >> 1;
if (check(mid)) {
r = mid;
} else {
l = mid + 1;
}
}
printf("%d\n", r);
return 0;
} | 0 | 91,378,828 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
const int INF = 1LL<<30;
char fi[1010][1010];
int dx[4]={0,1,0,-1};
int dy[4]={1,0,-1,0};
int dist[1010][1010];
int main() {
int h,w;
cin>>h>>w;
rep(i,h) rep(j,w) dist[i][j]=-1;
queue<pair<int,int>> que;
rep(i,h){
rep(j,w){
cin>>fi[i][j];
if(fi[i][j]=='#'){
que.push({i,j});
dist[i][j]=0;
}
}
}
while (!que.empty()) {
auto v = que.front();
que.pop();
int x=v.first;
int y=v.second;
rep(i,4){
int nx=x+dx[i];
int ny=y+dy[i];
if(dist[nx][ny]!=-1) continue;
if(nx<0 || nx>=h || ny<0 || ny>=w) continue;
dist[nx][ny]=dist[x][y]+1;
que.push({nx,ny});
}
}
int ans=0;
rep(i,h){
rep(j,w){
ans=max(ans,dist[i][j]);
}
}
cout<<ans<<endl;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <thread>
#include <tuple>
#include <type_traits>
#include <vector>
#include <stdio.h>
using ll = long long;
using namespace std;
int main() {
ios::sync_with_stdio(false);
int h, n;
cin >> h >> n;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
vector<int> dp(20005, INT_MAX);
dp[0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 1; j <= h; j++) {
if (j < a[i]) {
dp[j] = min(dp[j], b[i]);
} else {
dp[j] = min(dp[j], dp[j - a[i]] + b[i]);
}
}
}
cout << dp[h] << endl;
return 0;
} | 0 | 19,974,520 |
#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(i=0;i<n;i++)
#define ll long long
#define all(v) v.begin(), v.end()
#define INF 1020304050
int main()
{
int n;
cin >> n;
vector<int> x(n-1);
vector<int> y(n-1);
int i;
rep(i,n-1)
{
cin >> x[i] >> y[i];
x[i]--;
y[i]--;
}
vector<vector<int>> e(n);
rep(i,n-1)
{
e[x[i]].emplace_back(y[i]);
e[y[i]].emplace_back(x[i]);
}
vector<int> root(n,-1);
stack<int> st;
queue<int> q;
queue<int> q2;
vector<int> grundy(n,0);
q.push(0);
while(!q.empty())
{
while(!q.empty())
{
int now = q.front();
q.pop();
rep(i,e[now].size())
{
int to = e[now][i];
if(to != 0 && root[to] == -1)
{
root[to] = now;
q2.push(to);
st.push(to);
}
}
}
while(!q2.empty())
{
q.push(q2.front());
q2.pop();
}
}
while(!st.empty())
{
int now = st.top();
st.pop();
if(e[now].size()==1)
{
grundy[now] = 1;
}
else
{
int kg = 0;
rep(i,e[now].size())
{
int from = e[now][i];
if(from == root[now]) continue;
kg = kg^grundy[from];
}
grundy[now] = kg+1;
}
}
int judge = 0;
rep(i,e[0].size())
{
judge = judge^grundy[e[0][i]];
}
if(judge == 0)
{
cout << "Bob" << endl;
}
else
{
cout << "Alice" << endl;
}
} | #ifdef _MSC_VER
#include <__msvc_all_public_headers.hpp>
#undef min
#undef max
#else
#define NDEBUG
#include <bits/stdc++.h>
#endif
using namespace std;
using large = long long;
int main()
{
int n, m;
cin >> n >> m;
struct Shop { large price, count; };
auto shop = vector<Shop>(n);
for (auto& i : shop)
cin >> i.price >> i.count;
sort(shop.begin(), shop.end(), [](auto&A , auto&B) {
return (A.price < B.price) || (A.price == B.price && A.count > B.count);
});
auto have = 0LL;
auto cost = 0LL;
for (auto& s : shop) {
auto want = m - have;
auto amount = min(want, s.count);
cost += amount * s.price;
have += amount;
if (have >= m) break;
}
cout << cost << endl;
return 0;
} | 0 | 78,448,140 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll N, X, M;
int main(){
ios_base::sync_with_stdio(0); cin.tie(0);
cin >> N >> X >> M;
ll curr = X;
vector < ll > path; path.push_back(curr);
set < ll > vis; vis.insert(curr);
ll hf, result = curr, req = N - 1;
for (int i = 2; i <= N; i ++){
curr = (curr*curr)%M;
if (vis.find(curr) != vis.end()){
hf = curr;
break;
}
result += curr;
req -= 1;
path.push_back(curr); vis.insert(curr);
}
ll ix = find(path.begin(), path.end(), hf) - path.begin();
ll sz = path.size() - ix;
ll score = accumulate(path.begin() + ix, path.end(), 0ll);
if (req){
result += score * (req/sz);
ll rem = (req % sz), iy = ix;
while (rem--){
result += path[iy];
iy += 1;
}
}
cout << result << "\n";
} | #include <iostream>
#include <math.h>
#include <algorithm>
#include <string>
#include <map>
#include <vector>
#include <cmath>
using namespace std;
void a_hotel_easy(void) {
int n, k, x, y;
cin >> n >> k >> x >> y;
int sum = 0;
if (n > k) {
sum = x * k + y*(n-k);
}
else sum = x * n;
cout << sum << endl;
}
int main()
{
a_hotel_easy();
return 0;
} | 0 | 88,724,486 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<ld, ld>;
using vll = vector<ll>;
using vld = vector<ld>;
using vpl = vector<pll>;
using vvll = vector<vll>;
#define ALL(a) a.begin(),a.end()
#define SZ(a) ((int)a.size())
#define FI first
#define SE second
#define REP(i,n) for(ll i=0;i<((ll)n);i++)
#define REP1(i,n) for(ll i=1;i<((ll)n);i++)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
#define PB push_back
#define EB emplace_back
#define MP(a,b) make_pair(a,b)
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define yes cout<<"Yes"<<endl
#define YES cout<<"YES"<<endl
#define no cout<<"No"<<endl
#define NO cout<<"NO"<<endl
#define Decimal fixed<<setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
const int inf = 1e9;
const ll linf = 1LL << 50;
const double eps = 1e-10;
const int MOD = 1e9 + 7;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
ll mpow(ll m, ll p){
ll power = m;
ll res = 1;
while(p>0){
if(p&1)
res = res*power%MOD;
power = (power*power)%MOD;
p /= 2;
}
return res;
}
ll mod_inv(ll m){
return mpow(m, MOD-2);
}
struct COM{
vll fact, fact_inv;
COM(ll n): fact(n+1,1), fact_inv(n+1,1){
for(ll i=1; i<=n; i++)
fact[i] = fact[i-1]*i%MOD;
fact_inv[n] = mod_inv(fact[n]);
for(ll i=n; i>=1; i--)
fact_inv[i-1] = fact_inv[i]*i%MOD;
}
ll calc(ll n, ll k){
if(k<0 || n<k)
return 0;
ll res = fact[n]*fact_inv[n-k]%MOD*fact_inv[k]%MOD;
return res;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
string s;
cin >> n >> s;
n = s.size();
vll v(n);
REP(i, n) {
if (s[i] == 'W')
v[i] = 0;
else
v[i] = 1;
}
ll cnt = 0;
for (ll i = n - 1; i >= 0; i--) {
v[i] = (v[i] + cnt) % 2;
cnt++;
}
ll l = 0, r = 0;
REP(i, n) {
if (v[i] == 1)
r++;
else
l++;
}
if (v[0] == 1 || l != r) {
cout << 0 << endl;
return 0;
}
ll ans = 1;
ll now_l = 0;
REP(i, n) {
if (v[i] == 0)
now_l++;
else {
ans = ans * now_l % MOD;
now_l--;
}
}
COM com(n);
ans = ans * com.fact[l] % MOD;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int k, n;
cin >> k >> n;
vector<int> v;
int result = k;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
if (i > 1) {
int d = (k - x) + v[i-1];
if (d < result) {
result = d;
}
}
}
int d = v[n-1] - v[0];
if (d < result) {
result = d;
}
cout << result << endl;
return 0;
} | 0 | 67,946,875 |
#include<iostream>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<vector>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<time.h>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
const double PI=acos(-1);
const double EPS=1e-10;
const int inf=1e8;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
int main(){
int n,m;
while(cin>>n>>m,n+m){
int a[11]={0};
rep(i,n){
int b,c;cin>>b>>c;
a[c]+=b;
}
int out=0;
for(int i=10;i>=0;i--){
if(a[i])out+=i*(max(0,a[i]-m));
m=max(0,m-a[i]);
}
cout<<out<<endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
string s = to_string(n);
int cnt = 1;
for (int i = 1; i < s.size(); ++i) {
if (s[i] == s[i-1]) {
++cnt;
if (cnt == 3) {
printf("Yes\n");
return 0;
}
} else
{
cnt = 1;
}
}
printf("No\n");
} | 0 | 34,302,603 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define all(aaa) aaa.begin(), aaa.end()
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
if (s.size() > 3 && s.substr(0, 4) == "YAKI")
cout << "Yes\n";
else
cout << "No\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
typedef long long ll;
typedef pair<ll, ll> P;
const ll mod = 1000000007;
const int inf = 1e9;
const long long INF = 1LL << 60;
const double PI = 3.1415926535897932;
ll cnt[1010];
int main()
{
int n,k; cin >> n >> k;
vector<ll> v;
rep(i,n) cin >> cnt[i+1];
rep(i,n) cnt[i+1] += cnt[i];
for(int i = 0; i < n; i++){
for(int j = i+1; j < n+1; j++){
v.push_back(cnt[j]-cnt[i]);
}
}
ll ans = 0;
for(int i = 40; i >= 0; i--){
ll cur = ans + (1LL << i);
int ok = 0;
for(auto tmp : v) if((cur & tmp) == cur) ok++;
if(ok >= k) ans = cur;
}
cout << ans << endl;
} | 0 | 66,336,757 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <cmath>
#include <functional>
#include <bitset>
#define DB cerr<<"D"<<endl
#define pb push_back
using namespace std; using ll=long long; using ld=long double; const int INF=1e9; const ll LINF=1e18; const double dINF = 1e18; const ld ldINF = 1e18; const double EPS = 1e-6;
template<typename T, typename U, typename O> void caut(T a, U b, O c){cout<<"("<<a<<","<<b<<","<<c<<") ";}
template<typename T, typename U> void caut(T a, U b){cout<<"("<<a<<","<<b<<") ";}
template<typename T> void caut(T a){cout<<"("<<a<<") ";}
using P=pair<double,int>;
const ll M = 1e9+7;
int main() {
int n; cin>>n;
int p[n];for(int i=0;i<n;i++) cin>>p[i];
ll ka[n]={}, kb[n+1]={}, aa[n]={}, ab[n]={};
for(int i=0;i<n;i++) {
ka[i]=kb[i]=1;
}
for(int i=0;i<n;i++) {
if (i==0) continue;
ka[p[i]-1]+=i;
kb[p[i]]+=i;
}
ll nw=0;
for(int i=0;i<n;i++) {
nw+=ka[i]; aa[i]=nw;
}
nw=1e9;
for(int i=0;i<n;i++) {
nw-=kb[i]; ab[i]=nw;
}
for(int i=0;i<n;i++) {
cout<<aa[i]<<" ";
} cout<<endl;
for(int j=0;j<n;j++) {
cout<<ab[j]<<" ";
} cout<<endl;
} | #include <iostream>
using namespace std;
int main(){
int N, A, B;
cin >> N >> A >> B;
long long res=0;
for(int i=0;i<=N;i++){
int tmp=i, sum=0;
while(1){
sum+=tmp%10;
if(tmp/10 == 0) break;
else tmp/=10;
}
if(A<=sum && sum<=B) res+=i;
}
cout << res << endl;
} | 0 | 79,787,472 |
#include <bits/stdc++.h>
#define int long long
#define ci(m) for(int i=0;i<m;i++)
#define cj(m) for(int j=0;j<m;j++)
#define ck(m) for(int k=0;k<m;k++)
#define gcd __gcd
#define endl "\n"
#define pb emplace_back
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define mod2 998244353
#define maxe *max_element
#define mine *min_element
#define inf 1e18
#define deci(x, y) fixed<<setprecision(y)<<x
#define w(t) int t; cin>>t; while(t--)
#define nitin ios_base::sync_with_stdio(false); cin.tie(NULL)
#define PI 3.141592653589793238
using namespace std;
int visited[1000][1000];
int r,c;
char grid[1000][1000];
int dx[]={-1,1,0,0};
int dy[]={0,0,-1,1};
bool isvalid(int i, int j) {
return i >= 0 && i < r && j >= 0 && j < c;
}
int32_t main() {
nitin;
cin>>r>>c;
queue<pair<int,int>>q;
for(int i=0;i<r;i++)
{
for(int j=0;j<c;j++)
{
cin>>grid[i][j];
if(grid[i][j]=='#') {
q.push({i, j});
visited[i][j] = 1;
}
}
}
int cnt=0;
while(true)
{
cnt++;
queue<pair<int,int>>nq;
while(!q.empty()){
int x=q.front().first;
int y=q.front().second;
q.pop();
for(int i=0;i<4;i++)
{
int a=x+dx[i];
int b=y+dy[i];
if(isvalid(a,b) && !visited[a][b])
{
nq.push({a,b});
visited[a][b]=1;
}
}
}
q=nq;
if(q.empty())
break;
}
cout<<cnt-1<<endl;
return 0;
} | #include <iostream>
#include <vector>
#include <string>
using namespace std;
int main() {
string a = "qwertasdfgzxcvb";
string b = "yuiophjklnm";
string s;
while (getline(cin, s)) {
if (s == "#") {
break;
}
if (s.size() == 1) {
cout << 0 << endl;
continue;
}
vector<int> c;
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < a.size(); j++) {
if (s[i] == a[j]) {
c.push_back(0);
}
}
for (int j = 0; j < b.size(); j++) {
if (s[i] == b[j]) {
c.push_back(1);
}
}
}
int ans = 0, x = c[0];
for (int i = 1; i < c.size(); i++) {
if (x != c[i]) {
ans++;
x = c[i];
}
}
cout << ans << endl;
}
return 0;
} | 0 | 40,614,190 |
#include<bits/stdc++.h>
#include<string.h>
typedef long long int ll;
#define all(x) (x).begin(), (x).end()
using namespace std;
int nxt() {
int x;
cin >> x;
return x;
}
ll nxtl(){
ll x;
cin>>x;
return x;
}
void SieveOfEratosthenes(int n,vector <int> &primes)
{
bool prime[n+1];
memset(prime, true, sizeof(prime));
for (int p=2; p*p<=n; p++)
{
if (prime[p] == true)
{
for (int i=p*p; i<=n; i += p)
prime[i] = false;
}
}
for (int p=2; p<=n; p++)
if (prime[p])
primes.push_back(p);
}
ll max(ll a,ll b)
{
if(a>b)
return a;
return b;
}
ll power(ll x, ll y,ll mod)
{
ll temp;
if( y == 0)
return 1;
temp = power(x, y/2,mod);
if (y%2 == 0)
return (temp*temp)%mod;
else
return (((x*temp)%mod)*temp)%mod;
}
ll binomialCoeff(ll n, ll k)
{
ll C[k+1];
memset(C, 0, sizeof(C));
C[0] = 1;
for (ll i = 1; i <= n; i++)
{
for (ll j = min(i, k); j > 0; j--)
C[j] = C[j] + C[j-1];
}
return C[k];
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
map <int,int> m;
for(int i=0;i<3;i++)
{
int x=nxt();
m[x]+=1;
}
auto it=m.begin();
if(it->second==1)
cout<<it->first<<endl;
else
{
it++;
cout<<it->first<<endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(),(x).end()
using ll = long long;
#define vl vector<long long>
#define vvl vector<vector<long long>>
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, s, n) for (ll i = (s); i < (ll)(n); i++)
using pll = pair<long long,long long>;
#define cY cout<<"Yes"<<endl
#define cN cout<<"No"<<endl
const long long INF = 1LL << 60;
const long long MOD = 1000000007;
const long double pi = (acos(-1));
#define pb push_back
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;
}
vector<long long> divisor(long long n) {
vector<long long> ret;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
return ret;
}
ll nCr(ll n, ll r) {
ll ans = 1;
for (ll i = n; i > n - r; --i) {
ans = ans*i;
}
for (ll i = 1 ; i < r + 1; ++i) {
ans = ans / i;
}
return ans;
}
map< ll, ll > prime_factor(ll n) {
map< ll, ll > ret;
for(ll i = 2; i * i <= n; i++) {
while(n % i == 0) {
ret[i]++;
n /= i;
}
}
if(n != 1) ret[n] = 1;
return ret;
}
int main(){
ll n;
cin>>n;
map<ll,ll> e;
map<ll,ll> o;
rep(i,n){
ll a;
cin>>a;
if(i%2==0){
e[a]++;
}else{
o[a]++;
}
}
ll keye,keyo;
ll emax=0;
ll e2m=0;
ll omax=0;
ll o2m=0;
for(auto p:e){
ll value=p.second;
if(value>emax){
e2m=emax;
emax=value;
keye=p.first;
}else if(value>e2m){
e2m=value;
}
}
for(auto p:o){
ll value=p.second;
if(value>omax){
o2m=omax;
omax=value;
keyo=p.first;
}else if(value>o2m){
o2m=value;
}
}
if(keye!=keyo){
cout<<n-emax-omax<<endl;
}else{
if(omax+e2m>emax+o2m){
cout<<n-omax-e2m<<endl;
}else{
cout<<n-emax-o2m<<endl;
}
}
} | 0 | 40,702,530 |
#include <iostream>
#include <queue>
using namespace std;
int main(int argc, char* argv[]) {
queue<int> q;
int x, y;
cin >> x >> y;
while(!(x == 0 && y == 0)){
q.push(x);
q.push(y);
cin >> x >> y;
}
while(!q.empty()){
x = q.front();
q.pop();
y = q.front();
q.pop();
for(int j = 0 ; j < x ; j++){
for(int k = 0 ; k < y ; k++){
if(j==0 || j==x-1 || k==0 || k==y-1){
cout << "#";
}else{
cout << ".";
}
}
cout << endl;
}
cout << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int N;
ll a[50];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
cin >> N;
for (int i = 0; i < N; i++) {
cin >> a[i];
}
ll ans = 0;
for (int i = 0; i < 10000; i++) {
ll s = 0;
for (int j = 0; j < N; j++) {
s += a[j] / N;
}
if (s == 0) break;
for (int j = 0; j < N; j++) {
ll k = a[j] / N;
a[j] = a[j] - k * N + (s - k);
}
ans += s;
}
cout << ans << endl;
return 0;
} | 0 | 62,402,227 |
#include<bits/stdc++.h>
using namespace std;
#define pf printf
#define PF(a) printf("%d\n",(a))
#define PF2(a,b) printf("%d %d\n",(a), (b))
#define PF3(a,b,c) printf("%d %d %d\n",(a), (b), (c))
#define PFL(a) printf("%lld\n",(a))
#define PFL2(a,b) printf("%lld %lld\n",(a), (b))
#define PFL3(a,b,c) printf("%lld %lld %lld\n",(a), (b), (c))
#define get(a) cin>>a
#define sf scanf
#define SF(a) scanf("%d",&a)
#define SF2(a,b) scanf("%d %d",&a, &b)
#define SF3(a,b,c) scanf("%d %d %d",&a, &b, &c)
#define SFL(a) scanf("%lld",&a)
#define SFL2(a,b) scanf("%lld %lld",&a, &b)
#define SFL3(a,b,c) scanf("%lld %lld %lld",&a, &b, &c)
#define gl(a) getline(cin,(a))
#define gc() getchar()
#define pb push_back
#define m_p make_pair
#define pc() printf("Case %d: ",tt++)
#define tc() cout<<"Case "<<tt++<<": "
#define SZ(a) (int)(a).size()
#define all(a) a.begin(),a.end()
#define FF first
#define SS second
#define MAX 2134567891
#define MOD 1000000007
#define MM 100005
#define PI 2*acos(0.0)
#define cond(n,m) (xx>=0 && xx<(n) && yy>=0 && yy<(m))
#define mem(a) memset((a),0,sizeof (a))
#define SET(a) memset((a),-1,sizeof (a))
#define output freopen("output.txt","w",stdout);
#define input freopen("input.txt","r",stdin);
#define I_O ios_base::sync_with_stdio(0); cin.tie(0)
#define rep(a) for(int i=0;i<(a);i++)
#define FOR(a,b) for(int i=(a);i<(b);i++)
#define REP(a) for(int j=0;j<(a);j++)
#define rev(a) for(int i=(a);i>=0;i--)
#define fr(i,n) for(i=0;i<n;i++)
#define fr1(i,n,m) for(i=n;i<m;i++)
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
typedef long long ll;
typedef unsigned long long llu;
typedef priority_queue < int > PQ;
typedef pair < int, int > pi;
typedef pair < int, pi > pii;
typedef vector < int > vi;
typedef vector < ll > vl;
typedef vector < string > vs; | #define _USE_MATH_DEFINES
#include <cmath>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <limits>
#include <cstring>
#include <string>
#include <queue>
#include <map>
#include <set>
#include <bitset>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int dx[] = {1, 0, -1, 0, 0};
const int dy[] = {0, 1, 0, -1, 0};
const int Maxn = 100010;
int a[Maxn];
int n, m, r;
double n2;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
m = a[n - 1];
n2 = 1.0 * m / 2;
double dist = 1e9 + 10;
for (int i = 0; i < n; ++i) {
if (abs(a[i] - n2) < dist){
r = a[i];
dist = abs(a[i] - n2);
}
}
cout << m << " " << r << endl;
} | 0 | 72,259,744 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0;i < (n);i++)
using namespace std;
using ll = long long;
using pii = pair<int,int>;
const int INF = 2e9;
int main(){
int r,g,b,n;
cin >> r >> g >> b >> n;
int x,y,z;
int ans = 0;
x = n/r + 1;
y = n/g + 1;
rep(i,x){
rep(j,y){
int res = n - i * r - j * g;
if(res >= 0 && res % b == 0) ans++;
}
}
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
string n;
long long i,l,j,k,s=0;
cin>>n;
l=n.length();
for(i=0;i<l;i++){
s+=(n[i]-48);
}
if(s%9==0)cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
} | 0 | 30,540,005 |
#include <iostream>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int n;
string s;
cin >> n >> s;
int cnt[26];
for (int i = 0; i < 26; ++i) cnt[i] = 0;
for (int i = 0; i < n; ++i) cnt[s[i] - 'a']++;
long long ans = 1;
for (int i = 0; i < 26; ++i) {
ans *= (long long)(cnt[i] + 1);
ans %= mod;
}
cout << (ans ? --ans : --ans + mod) << endl;
} | #include <bits/stdc++.h>
#include <math.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rrep(i, n) for(int i = 0; i <= (n); i++)
using namespace std;
typedef long long ll;
const ll INF = 1LL<<62;
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; }
template<class T>
vector<T> make_vec(size_t a){
return vector<T>(a);
}
template<class T, class... Ts>
auto make_vec(size_t a, Ts... ts){
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
const int MOD = 1000000007;
int ans = 100000000;
int main(){
int N, Y; cin >> N >> Y;
int sheets[3] = {10000,5000,1000};
for(int i = 0; i <= 2000; i++){
for (int j = 0; j <= 2000; j++){
int k = N - i - j;
if (k < 0) break;
if (sheets[0]*i + sheets[1]*j + sheets[2]*k == Y){
cout << i << " " << j << " " << k << endl;
return 0;
}
}
}
cout << -1 << " " << -1 << " " << -1 << endl;
} | 0 | 100,595,780 |
#include<bits/stdc++.h>
#define rep(i,N) for(ll (i)=0;(i)<(N);(i)++)
#define chmax(x,y) x=max(x,y)
#define chmin(x,y) x=min(x,y)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
const int mod = 1000000007;
const int INF = 1001001001;
int main() {
int k, a, b;
cin >> k >> a >> b;
++k;
ll ans = min(a, k);
k -= a;
ll diff = b - a;
if (diff >= 2 && k >= 0) {
ans += (diff) * (k / 2) + k % 2;
} else {
ans += max(0, k);
}
cout << ans << endl;
} | #include<iostream>
#include <vector>
#include <algorithm>
#include <math.h>
#include <string>
using namespace std;
int gcd(int p, int q) {
if (p % q == 0)return q;
return gcd(q, p % q);
}
int main()
{
double l;
cin >> l;
double o;
if ((int)l % 3 == 0) {
o = (l / 3)*(l / 3)*(l / 3);
printf("%0.12f\n", o);
}
else {
o = (l / 3)*(l / 3)*(l / 3);
printf("%0.12f\n", o);
}
return 0;
} | 0 | 68,961,432 |
#include <bits/stdc++.h>
using namespace std;
int ans = 0;
void OnestrokePath(int n,vector<vector<int>> &ABC,vector<bool> &ok) {
bool ok2 = true;
for(int i = 0; i < ok.size(); i++) {
if(ok[i] == false && i != n) {
ok2 = false;
}
}
if(ok2) {
ans++;
return;
}
ok[n] = true;
for(int i = 0; i < ABC[n].size(); i++) {
if(ok[ABC[n][i]] == true) {
continue;
}
OnestrokePath(ABC[n][i],ABC,ok);
}
ok[n] = false;
return;
}
int main() {
int N,M;
cin >> N >> M;
vector<vector<int>>ABC(N);
vector<bool>ok(N,false);
for(int i = 0; i < M; i++) {
int a,b;
cin >> a >> b;
a--;
b--;
ABC[a].push_back(b);
ABC[b].push_back(a);
}
OnestrokePath(0,ABC,ok);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,N) for(int i=0;i<int(N);++i)
#define bit(k) (1LL<<(k))
typedef long long ll;
int main() {
int N;
cin >> N;
vector<ll> X(N), Y(N);
for(int i = 0; i < N;i++)cin >> X[i] >> Y[i];
int wa = abs(X[0])+abs(Y[0]);
for(int i = 0; i < N;i++){
if(wa%2 != (abs(X[i])+abs(Y[i]))%2){
cout << -1 << endl;
return 0;
}
}
vector<ll> d;
for(int s = 32;s >= 0;s--){
d.push_back(bit(s));
}
if((X[0]+Y[0])%2 == 0){
d.push_back(1);
}
cout << d.size() << endl;
rep(i,d.size()){
cout << d[i] << " ";
}
cout << endl;
for(int i = 0; i < N; i++){
string ans = "";
ll u = X[i] + Y[i];
ll v = X[i] - Y[i];
ll nx = 0;
ll ny = 0;
for(int j = 0; j < d.size();j++){
if(nx <= u){
nx += d[j];
if(ny <= v){
ny += d[j];
ans.push_back('R');
}
else{
ny -= d[j];
ans.push_back('U');
}
}
else{
nx -= d[j];
if(ny <= v){
ny += d[j];
ans.push_back('D');
}
else{
ny -= d[j];
ans.push_back('L');
}
}
}
cout << ans << endl;
}
} | 0 | 71,870,950 |
#include <iostream>
int main(){
int n, debt = 100000;
std::cin >> n;
for(int i = 0; i < n; ++i){
debt *= 1.05;
if(debt % 1000 != 0){
debt += 1000;
debt -= debt % 1000;
}
}
std::cout << debt << std::endl;
return 0;
} | #include <iostream>
#include <string>
#include <cstring>
#include <stack>
#include <queue>
#include <cctype>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <cmath>
#include <stdlib.h>
#include <tuple>
#include <iomanip>
#include <iterator>
#include <stdio.h>
#include <fstream>
#include <time.h>
using namespace std;
const double PI = 3.14159265358979323846;
const long long int MOD = 1000000000 + 7;
struct UnionFind {
vector<int> parent;
UnionFind(int N) : parent(N) {
for (int i = 0; i < N; i++) {
parent[i] = -1;
}
}
int root(int i) {
if (parent[i] < 0) {
return i;
}
return (parent[i] = root(parent[i]));
}
bool unite(int from, int to) {
int rx = root(from);
int ry = root(to);
if (rx != ry) {
parent[ry] += parent[rx];
parent[rx] = ry;
return true;
}
else {
return false;
}
}
bool same(int x, int y) {
return root(x) == root(y);
}
int treeSize(int x) {
return -parent[root(x)];
}
};
long long int modpow(long long int base, long long int pow, long long int mod) {
if (pow == 1) {
return base;
}
else if (pow == 0) {
return 1;
}
if (pow % 2 == 0) {
auto temp = modpow(base, pow / 2, mod);
return (temp * temp) % mod;
}
else {
return (base * modpow(base, pow - 1, mod)) % mod;
}
}
long long int moddiv(long long int X, long long int Y, long long int mod) {
auto fermatDiv = modpow(Y, mod - 2, mod);
return (X * fermatDiv) % mod;
}
long long modCombination(long long left, long long right, long long int mod) {
long long answer = 1;
if (left > right) {
for (long long i = 0; i < right; i++) {
answer = (answer * (left - i)) % mod;
answer = moddiv(answer, (i + 1), mod);
}
}
return answer;
}
bool IsPrime(long long N) {
if (N == 1) {
return false;
}
for (long long i = 2; i * i <= N; i++) {
if (N % i == 0) {
return false;
}
}
return true;
}
vector<pair<long long, long long> > prime_factorize(long long N) {
vector<pair<long long, long long> > res;
for (long long a = 2; a * a <= N; ++a) {
if (N % a != 0) continue;
long long ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
res.push_back({ a, ex });
}
if (N != 1) res.push_back({ N, 1 });
return res;
}
long long euclid(long long a, long long b) {
if (a > b) {
long long temp = b;
b = a;
a = temp;
}
if (b % a == 0) {
return a;
}
else {
return euclid(a, b - a);
}
}
long long gcd(long long a, long long b) {
if (b > a) {
long long temp = b;
b = a;
a = temp;
}
long long c = a % b;
if (c == 0) {
return b;
}
else {
return gcd(b, c);
}
}
int main() {
int X, Y, A, B, C;
cin >> X >> Y >> A >> B >> C;
vector<int> p(A), q(B), r(C);
for (int i = 0; i < A; i++) {
int temp;
cin >> temp;
p[i] = temp;
}
for (int i = 0; i < B; i++) {
int temp;
cin >> temp;
q[i] = temp;
}
for (int i = 0; i < C; i++) {
int temp;
cin >> temp;
r[i] = temp;
}
sort(p.begin(), p.end(), greater<int>());
sort(q.begin(), q.end(), greater<int>());
sort(r.begin(), r.end(), greater<int>());
vector<int> eats(X + Y);
for (int i = 0; i < X; i++) {
eats[i] = p[i];
}
for (int i = 0; i < Y; i++) {
eats[X + i] = q[i];
}
sort(eats.begin(), eats.end());
for (int i = 0; i < min(C, X+Y); i++) {
if (eats[i] <= r[i]) {
eats[i] = r[i];
}
else {
break;
}
}
long long total = 0;
for (auto e : eats) {
total += e;
}
cout << total << endl;
return 0;
} | 0 | 62,057,401 |
#include <bits/stdc++.h>
using namespace std;
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<n;++i)
#define exrep(i, a, b) for(ll i = a; i < b; i++)
#define out(x) cout << x << endl
#define EPS (1e-7)
#define gearup ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
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<pair<int,int> > vpii;
typedef vector<vector<int> > vvi;
typedef vector<vector<char> > vvc;
typedef vector<vector<bool> > vvb;
typedef vector<vector<double> > vvd;
typedef vector<vector<string> > vvs;
typedef vector<ll> vl;
typedef vector<vector<ll> > vvl;
typedef vector<vector<vector<ll> > > vvvl;
ll MOD = 1000000007;
const long long L_INF = 1LL << 60;
const int INF = 2147483647;
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;}
template<class T> void debug(T v){rep(i,v.size()) cout<<v[i]<<" ";cout<<endl;}
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
vector<vpii > G;
vb visited;
void bfs(int node,vl &distK){
queue<int> que;
que.push(node);
while(!que.empty()){
int vert = que.front();
visited[vert]=true;
que.pop();
for(auto next:G[vert]){
int nv = next.first;
int cost = next.second;
if(visited[nv])continue;
distK[nv] = distK[vert]+cost;
que.push(nv);
}
}
}
signed main()
{
gearup;
int n;cin>>n;
G.resize(n);
visited.resize(n);
rep(i,n-1){
int a,b,c; cin >> a >> b >> c;
a--;b--;
G[a].push_back({b,c});
G[b].push_back({a,c});
}
int q,k; cin >> q >> k;
k--;
vl distK(n);
bfs(k,distK);
rep(i,q){
int x,y; cin >> x >> y;
x--;y--;
out(distK[x]+distK[y]);
}
} | #include <bits/stdc++.h>
using namespace std;
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vector<vector<t>>;
typedef long long ll;
typedef vc<int> vi;
typedef vvc<int> vvi;
typedef pair<int, int> pi;
#define uset unordered_set
#define umap unordered_map
#define endl "\n"
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define bg begin()
#define ed end()
#define all(a) a.bg, a.ed
template <class t, class u>
ostream &operator<<(ostream &os, const pair<t, u> &p) {
return os << "( " << p.first << ", " << p.second << " )";
}
template <class t>
ostream &operator<<(ostream &os, const vc<t> &v) {
os << "[ ";
for (int i = 0; i < v.size(); i++) {
os << v[i];
if (i != v.size() - 1) {
os << ", ";
}
}
return os << " ]";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int h, w;
cin >> h >> w;
for (int i = 0; i < h; i++) {
string row;
cin >> row;
cout << row << endl;
cout << row << endl;
}
} | 0 | 43,076,544 |
#include <iostream>
#include <array>
#include <algorithm>
using namespace std;
int main(){
int n;
cin >> n;
for (int i = 0; i < n; i++){
array<int, 3> edge;
for (int i = 0; i < 3; i++){
cin >> edge[i];
}
sort(edge.begin(), edge.end());
if (pow(edge[0], 2) + pow(edge[1], 2) == pow(edge[2], 2)){
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
}
return 0;
} | #pragma region Macros
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using WGraph = vector<vector<pair<int, ll>>>;
template<class T>inline bool chmax(T &a, const T &b) { if (b > a) { a = b; return true; } return false; }
template<class T>inline bool chmin(T &a, const T &b) { if (b < a) { a = b; return true; } return false; }
constexpr int dx[4] = {-1, 0, 0, 1}, dy[4] = {0, -1, 1, 0};
constexpr int INF = 1e9;
constexpr long long LINF = 1e18;
constexpr long long MOD = 1e9 + 7;
constexpr double EPS = 1e-10;
constexpr double PI = M_PI;
#pragma endregion
void solve() {
int n, K;
cin >> n >> K;
vector<pair<ll, ll>> a(n);
for (int i=0; i<n; i++) {
cin >> a.at(i).first >> a.at(i).second;
}
ll res = 1e20;
for (int i=0; i<n; i++) {
for (int j=0; j<n; j++) {
for (int k=0; k<n; k++) {
for (int l=0; l<n; l++) {
ll xmin = a.at(i).first, xmax = a.at(j).first, ymin = a.at(k).second, ymax = a.at(l).second;
int cnt = 0;
for (int m=0; m<n; m++) {
if (xmin <= a.at(m).first && a.at(m).first <= xmax && ymin <= a.at(m).second && a.at(m).second <= ymax) {
cnt++;
}
}
if (cnt >= K) {
chmin(res, (xmax - xmin) * (ymax - ymin));
}
}
}
}
}
cout << res << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
solve();
return 0;
} | 0 | 76,752,033 |
#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, m; cin >> n >> m;
vector<vector<bool>> g(n, vector<bool>(n, false));
rep(i, m){
ll a, b; cin >> a >> b;
a--, b--;
g[a][b] = g[b][a] = true;
}
vector<ll> chk(n);
rep(i, n) chk[i] = i;
ll res=0;
do{
bool flag=true;
if(chk[0]) break;
rep(i, n-1){
flag &= g[chk[i]][chk[i+1]];
}
res += flag;
}while(next_permutation(ALL(chk)));
cout << res << endl;
} | #include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<bitset>
#include<set>
#include<map>
#include<stack>
#include<queue>
#include<deque>
#include<list>
#include<iomanip>
#include<cmath>
#include<cstring>
#include<functional>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define INF 2e9
#define MOD 1000000007
#define LINF (long long)4e18
#define jck 3.141592
using ll = long long;
using Pi = pair<int,int>;
using Pl = pair<ll,ll>;
#define MAX 200000
ll fac[MAX];
ll finv[MAX];
ll inv[MAX];
void COMinit(){
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
repr(i,2,MAX){
fac[i] = fac[i-1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD/i) % MOD;
finv[i] = finv[i-1] * inv[i] % MOD;
}
}
int main(){
COMinit();
int N; cin >> N;
string S; cin >> S;
int cntl = 0;
int cntr = 0;
ll ans = 1;
rep(i,2*N){
if((cntl-cntr) % 2 != 0){
if(S[i] == 'W') cntl++;
else{
ans *= (cntl-cntr);
ans %= MOD;
cntr++;
}
}
else{
if(S[i] == 'B') cntl++;
else{
ans *= (cntl-cntr);
ans %= MOD;
cntr++;
}
}
if(cntl < cntr){
cout << 0 << endl;
return 0;
}
}
ans *= fac[N];
ans %= MOD;
if(cntl != cntr) cout << 0 << endl;
else cout << ans << endl;
} | 0 | 97,828,542 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin >> a >> b;
a=(a+11)%13;
b=(b+11)%13;
if(a>b){
cout << "Alice" << endl;
}else if(a<b){
cout << "Bob" << endl;
}else{
cout << "Draw" << endl;
}
} | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
using ll = long long;
using vec = vector<ll>;
using vect = vector<double>;
using Graph = vector<vector<ll>>;
#define loop(i, n) for (ll i = 0; i < n; i++)
#define Loop(i, m, n) for (ll i = m; i < n; i++)
#define pool(i, n) for (ll i = n; i >= 0; i--)
#define Pool(i, m, n) for (ll i = n; i >= m; i--)
#define mod 1000000007ll
#define flagcount __builtin_popcount
#define flag(x) (1ll << x)
#define flagadd(bit, x) bit |= flag(x)
#define flagpop(bit, x) bit &= ~flag(x)
#define flagon(bit, i) bit &flag(i)
#define flagoff(bit, i) !(bit & (1ll << i))
#define all(v) v.begin(), v.end()
#define low2way(v, x) lower_bound(all(v), x)
#define high2way(v, x) upper_bound(all(v), x)
#define idx_lower(v, x) (distance(v.begin(), low2way(v, x)))
#define idx_upper(v, x) (distance(v.begin(), high2way(v, x)))
#define idx_lower2(v, x) (v.size() - idx_lower(v, x))
#define idx_upper2(v, x) (v.size() - idx_upper(v, x))
#define putout(a) cout << a << endl
#define Sum(v) accumulate(all(v), 0ll)
#define gcd(x, y) __gcd(x, y)
ll ctoi(char c)
{
if (c >= '0' && c <= '9')
{
return c - '0';
}
return -1;
}
template <typename T>
string make_string(T N)
{
string ret;
T now = N;
while (now > 0)
{
T x = now % 10;
ret += (char)('0' + x);
now /= 10;
}
reverse(all(ret));
return ret;
}
template <typename T>
T lcm(T x, T y)
{
T z = gcd(x, y);
return x * y / z;
}
template <typename T>
bool primejudge(T n)
{
if (n < 2)
return false;
else if (n == 2)
return true;
else if (n % 2 == 0)
return false;
double sqrtn = sqrt(n);
for (T i = 3; i < sqrtn + 1; i++)
{
if (n % i == 0)
{
return false;
}
i++;
}
return true;
}
template <typename T>
bool chmax(T &a, const T &b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
template <typename T>
bool chmin(T &a, const T &b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
ll dp[2010][2010];
int main()
{
cout << fixed << setprecision(30);
ll N, M;
cin >> N >> M;
vector<ll> S(N), T(M);
loop(i, N) cin >> S[i];
loop(i, M) cin >> T[i];
dp[0][0] = 1;
Loop(i, -1, N)
{
Loop(j, -1, M)
{
if (i >= 0 && j >= 0 && S[i] == T[j])
dp[i + 1][j + 1] += dp[i][j];
if (i >= 0)
dp[i + 1][j + 1] += dp[i][j + 1];
if (j >= 0)
dp[i + 1][j + 1] += dp[i + 1][j];
if (i >= 0 && j >= 0)
dp[i + 1][j + 1] -= dp[i][j];
if (dp[i + 1][j + 1] < 0)
dp[i + 1][j + 1] += mod;
dp[i + 1][j + 1] %= mod;
}
}
putout(dp[N][M]);
return 0;
} | 0 | 1,381,345 |
#include<bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
int main(){
string s;cin >> s;
if(s == "zyxwvutsrqponmlkjihgfedcba"){
cout << "-1\n";return 0;
}
int n = s.size(),i,j;
bool use[26] = {};
for(i=0;i<n;i++) use[s[i]-'a'] = true;
for(i=0;i<26;i++){
if(!use[i]){
cout << s << char(i+'a') << "\n";return 0;
}
}
for(i=n-2;i>=0;i--){
if(s[i] < s[i+1]){
for(j=i+1;j<n;j++) use[s[j]-'a'] = false;
s = s.substr(0,i+1);
while(use[s[s.size()-1]-'a']) s[s.size()-1]++;
cout << s << "\n";
return 0;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define ALL(a) (a).begin(),(a).end()
#define rALL(a) (a).rbegin(),(a).rend()
typedef pair<int, int> Pint;
typedef pair<int64_t, int64_t> Pll;
int main() {
int N, K;
string S;
cin >> N >> S >> K;
for (int i = 0; i < N; i++){
if (S.at(K - 1) == S.at(i)){
cout << S.at(i);
}
else {
cout << "*";
}
}
cout << endl;
} | 0 | 41,829,361 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1LL << 60;
int main() {
int p, q, r;
cin >> p >> q >> r;
cout << min(p + q, min(q + r, r + p)) << endl;
} | #include <iostream>
#include <map>
#include <cmath>
#include <ios>
#include <iomanip>
#include <algorithm>
#include <queue>
#include <stack>
#include <numeric>
using namespace std;
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;
template<class T> using VVV = V<VV<T>>;
template<class T1, class T2> using P = pair<T1, T2>;
using I = int;
using D = double;
using B = bool;
using C = char;
using S = string;
using LL = long long;
using LD = long double;
using ULL = unsigned long long;
using PII = P<I, I>;
using VPII = V<PII>;
using PLL = P<LL, LL>;
using VPLL = V<PLL>;
using VI = V<I>;
using VVI = VV<I>;
using VLL = V<LL>;
using VVLL = VV<LL>;
using VC = V<C>;
using VVC = VV<C>;
using VS = V<S>;
using VVS = VV<S>;
using VB = V<B>;
using VVB = VV<B>;
#define REP(type, i, n) for (type i = 0; i < (type)(n); ++i)
#define REP2(type, i, m, n) for (type i = (m); i < (type)(n); ++i)
#define REPR(type, i, n) for (type i = (n)-1; i >= 0; --i)
#define REPR2(type, i, m, n) for (type i = (n)-1; i >= (m); --i)
#define REPx(x, a) for(auto x : a)
#define ALL(a) a.begin(), a.end()
#define SORT(a) sort(ALL(a))
#define SORTR(a, type) sort(ALL(a), greater<type>())
#define SORTF(a, comp) sort(ALL(a), comp)
#define REVERSE(a) reverse(ALL(a))
#define SIZE(a, type) ((type)(a).size())
#define bit_search(bit, n) REP(LL, bit, 1LL<<(n))
#define bit_check(bit, i) ((bit>>(i)) & 1)
#define setpre(n) fixed << setprecision((n))
#define UNIQUE(a) do {SORT(a); (a).erase(unique(ALL(a)), (a).end());} while(0)
#define MAX(a) *max_element(ALL(a))
#define MIN(a) *min_element(ALL(a))
#define bisect_left(a, x) (lower_bound(ALL(a), (x)) - a.begin())
#define bisect_right(a, x) (upper_bound(ALL(a), (x)) - a.begin())
#define INPUT(a) REPx(&x, a) cin >> x;
#define INPUT2(a) REPx(&x, a) INPUT(x);
#define INPUTP(a) REPx(&x, a) cin >> x.first >> x.second;
#define ENDL cout << endl;
const LL INF = 9e18;
const LL MOD = 1e9+7;
template<class T> using PRIORITY_QUEUE = priority_queue< T, V<T>, greater<T> >;
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 void debug1(V<T> A){REP(int, i, SIZE(A, int)){if (A[i] == INF) cout << "I ";else cout << A[i] << " ";}ENDL}
template<class T> inline void debug2(VV<T> A){REP(int, i, SIZE(A, int)){REP(int, j, SIZE(A[i], int)){if (A[i][j] == INF) cout << "I "; else cout << A[i][j] << " ";}ENDL}}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
LL x, y, ans = INF;
cin >> x >> y;
if (x*y == 0) ans = abs(x+y)+1;
if (x*y > 0)
{
if (y >= x) ans = abs(x-y);
else ans = x - y + 2;
}
else
{
if (y > x) ans = abs(x-y);
chmin(ans, abs(x+y)+1);
}
cout << ans << endl;
return 0;
} | 0 | 81,159,563 |
#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;
string s;
int dp[100005][2];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> s;
dp[0][0] = 1;
REP(i, s.length()) {
if(s[i] == '0') {
dp[i + 1][1] = dp[i][1];
dp[i + 1][0] = dp[i][0];
} else {
dp[i + 1][1] = (dp[i][0] + dp[i][1]) % mod;
}
if(s[i] == '0') {
dp[i + 1][1] = (dp[i + 1][1] + dp[i][1] * 2 % mod) % mod;
} else {
dp[i + 1][0] = (dp[i + 1][0] + dp[i][0] * 2 % mod) % mod;
dp[i + 1][1] = (dp[i + 1][1] + dp[i][1] * 2 % mod) % mod;
}
}
cout << (dp[s.length()][0] + dp[s.length()][1]) % mod << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1e9+7;
const long long INF = 1e15;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);cout.tie(NULL);
int n;
string s;
cin >> n >> s;
map<char,int> mp;
for(int i = 0; i < n; i++) mp[s[i]]++;
ll ans = 1;
for(auto p:mp){
ans *= p.second+1;
ans %= mod;
}
cout << ans-1 << endl;
return 0;
} | 0 | 11,505,250 |
#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++)
#define fi first
#define se second
long long mo = 1000000007;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> Pii;
typedef pair<ll,ll> Pll;
typedef pair<ll,Pll> PlP;
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;
cin >> N;
vector<ll> A(N), b(1000000+1,0), cc(1000001);
rep(i,N){
cin >> A[i];
}
bool flag = false;
REP(i,2,1000001){
ll cur = i;
if(b[i] != 0){
continue;
}
while(cur <= 1000000){
b[cur] = i;
cur += i;
}
}
b[0] = 1;
b[1] = 1;
rep(i,N){
if(A[i] == 1)continue;
ll n = A[i];
vector<pair<ll,int>> res;
while(n > 1){
ll p = b[n];
res.emplace_back(p,0);
while(n % p == 0){
n /= p;
res.back().second++;
}
}
for(auto& e:res){
cc[e.fi]++;
}
}
rep(i,1000001){
if(cc[i] > 1){
flag = 1;
break;
}
}
if(!flag){
cout << "pairwise coprime" << endl;
return 0;
}
ll c=A[0];
rep(i,N){
c = __gcd(c,A[i]);
}
if(c==1){
cout << "setwise coprime" << endl;
}else{
cout << "not coprime" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll A[101010];
ll n, s, k, c;
void die() { cout << "NO" << endl; exit(0); }
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
ll i, t;
cin >> n;
for(i=0; i<n; i++){
cin >> A[i];
s += A[i];
}
k = s / (n * (n + 1) / 2);
if(!k || s % k != 0) die();
for(i=0; i<n; i++){
t = A[i] + k - A[(i + 1) % n];
if(t < 0 || t % n != 0) die();
c += t / n;
}
if(c != k) die();
cout << "YES" << endl;
return 0;
} | 0 | 78,103,662 |
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define MAX 1e18
#define MIN -1e18
#define MOD 1000000007
#define base 139
#define base2 31
#define memz(a) memset(a, 0, sizeof(a))
#define memn(a) memset(a, -1, sizeof(a))
#define in1(a) scanf("%lld", &a)
#define in2(a, b) scanf("%lld%lld", &a, &b)
#define TC(c) printf("Case #%lld: ", ++c)
#define out(x) cout << #x << " -> " << x << endl;
#define FAST ios_base::sync_with_stdio(false); cin.tie(NULL);
#define FILE freopen("input.txt", "r", stdin); freopen("out.txt", "w", stdout);
using namespace std;
const ll B = 20, N = 300010, M = 2000000;
ll n, res;
int solve()
{
cin >> n;
if(n%2) printf("0\n");
else
{
ll k = 5;
n/=2;
while(k<=n)
{
res+=(n/k);
k*=5;
}
printf("%lld\n", res);
}
return 0;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
return solve();
} | #include <stdio.h>
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <cstdlib>
#include <list>
#include <numeric>
#include <map>
#include <cmath>
#include <string>
#define rep(i,n) for(int i=0;i<n;i++)
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
typedef long long ll;
using namespace std;
int a = 0, b = 0, c, d, n, k = 0;
string s, t;
int main()
{
int a, b, c,d;
cin >> a >> b >> c >> d;
cout << min(a, b) + min(c, d) << endl;
return 0;
} | 0 | 3,797,570 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define INF 1000000007
#define mod 1005
#define ll long long int
const double mx = 2e6 + 5 ;
void solve()
{
ll ans = 0;
ll b = 0;
string s;
cin>>s;
REP(i, s.length())
{
if(s[i]=='B')
b++;
else
ans+=b;
}
cout<<ans<<"\n";
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while(t--)
{
solve();
}
return 0;
} | #include <bits/stdc++.h>
#include <iomanip>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
using Graph = vector<vector<int>>;
typedef long long ll;
typedef long double lld;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265359
#define MOD 1000000007
int main() {
int n,m;
cin >> n >> m;
vector<vector<int>> s(10, vector<int>(10,0));
vector<int>denkyu_swiches(m);
for(int i=0; i<m;i++){
int a;
cin >> a;
denkyu_swiches.at(i) = a;
for(int j=0; j<a;j++){
int b;
cin >> b;
--b;
s.at(i).at(b) = 1;
}
}
vector<int>p(m);
rep(i,m) cin >> p.at(i);
int ans = 0;
for(int bit = 0; bit < (1<<n); bit++){
int truecount = 0;
for(int k=0; k<m; k++){
int sum = 0;
for(int i=0; i<n; i++){
if(bit & (1<<i)){
if(s.at(k).at(i) == 1)sum++;
}
}
if(sum%2 == p.at(k))truecount++;
}
if(truecount == m){
ans++;
}
}
cout << ans << endl;
} | 0 | 31,797,864 |