code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 1
101M
|
|---|---|---|---|
#include<bits/stdc++.h>
#include<string>
#include<cmath>
using namespace std;
#define ll long long int
#define loop(i, n) for (int i = 0; i < n; i++)
#define loops(i, s, n) for (int i = s; i < n; i++)
#define pb push_back
#define mp make_pair
#define all(v) v.begin(),v.end()
#define sz(x) ((int)(x).size())
#define fi first
#define se second
#define MOD 1000000007
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int h1,h2,m1,m2,k;
cin>>h1>>m1>>h2>>m2>>k;
h1*=60;
h1+=m1;
h2*=60;
h2+=m2;
int ans = (h2-h1)-k;
cout<<ans;
} | #include<bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ALL(A) A.begin(),A.end()
#define RALL(A) A.rbegin(),A.rend()
typedef long long LL;
typedef pair<LL,LL> P;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const LL mod=1000000007;
const LL LINF=1LL<<60;
const int INF=1<<30;
int dx[]={1,0,-1,0};
int dy[]={0,1,0,-1};
int main(){
int n,k;cin >> n >> k;
vector<int> a(n),c(n,1);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - k; i++) {
c[i] = 0;
}
LL ans = LINF;
do{
LL t = 0, now = a[0];
for (int i = 1; i < n; i++) {
if(c[i]){
if(now < a[i]){
now = a[i];
}
else{
now++;
t += now - a[i];
}
}
else{
if(now < a[i]) now = a[i];
}
}
ans = min(ans, t);
}while(next_permutation(ALL(c)));
cout << ans << endl;
return 0;
} | 0 | 80,144,787 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
const ll M = 1e9 + 7;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int ans = 0;
rep(v, 1000) {
vector<int> a(3);
a[0] = v / 100;
a[1] = v / 10 - (v / 100) * 10;
a[2] = v % 10;
int now = 0;
rep(i,n) {
if ((int)(s[i] - '0') == a[now]) now++;
if (now == 3){
ans++;
break;
}
}
}
cout << ans << endl;
return 0;
} | #include<math.h>
#include<iomanip>
#include<iostream>
using namespace std;
int main()
{
double x1, x2, y1, y2, d;
cin >> x1 >> y1 >> x2 >> y2;
d = pow((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1), 0.5);
cout << fixed << setprecision(6) << d << endl;
return 0;
} | 0 | 11,964,778 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
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);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll ans = b - a + 1;
ans -= b / c - (a - 1) / c;
ans -= b / d - (a - 1) / d;
ans += b / lcm(c, d) - (a - 1) / lcm(c, d);
cout << ans << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for(ll i=0; i<n; i++)
#define repr(i, s, e) for(ll i=s; i>=e; i--)
#define reps(i, s, e) for(ll i=s; i<=e; i++)
#define inf 1e18
#define all(v) v.begin(),v.end()
#define ceil(a, b) (a+b-1)/b
#define ok cout << "ok" << endl;
#define sp << " " <<
template<typename T> inline bool chmax(T &a, T b){ if(a<b) a=b; return a<b; }
template<typename T> inline bool chmin(T &a, T b){ if(b<a) a=b; return b<a; }
template<typename T> void vdeb(T v){
cout << "#vector set debug" << endl;
for(auto vv : v) cout << vv << " ";
cout << endl;
}
template<typename T1, typename T2> void adeb(T1 arr[], T2 n){
cout << "#adebug" << endl;
for(int i=0; i<=n; i++) cout << arr[i] << " ";
cout << endl;
}
template<typename T1> void mdeb(T1 mp){
cout << "#map pair debug" << endl;
for(auto const& m : mp) cout << m.first sp m.second << endl;
}
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){ fill((T*)array, (T*)(array+N), val); }
void ans(bool b){ cout << (b ? "Yes" : "No") << endl; }
void ans2(bool b){ cout << (b ? "YES" : "NO") << endl; }
int dx[] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, -1, 1};
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
cout << s.substr(0, 4) << " " << s.substr(4, 12) << endl;
return 0;
} | 0 | 19,554,368 |
#include <algorithm>
#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()
#define ll long long
#define INF 1000000000000000000
typedef pair<ll, ll> pll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s, t; cin >> s >> t;
int A, B; cin >> A >> B;
string u; cin >> u;
if (s == u){
cout << A - 1 << " " << B << endl;
}
else {
cout << A << " " << B - 1 << endl;
}
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
int rows,cols;
cin>>rows>>cols;
char input[rows][cols];
int co=1e9+7;
for(int i=0;i<rows;i++)
{
for(int j=0;j<cols;j++)
cin>>input[i][j];
}
int dp[rows][cols];
memset(dp,0,sizeof(dp));
dp[rows-1][cols-1]=1;
for(int i=cols-2;i>=0;i--)
{
if(input[rows-1][i]=='.')
dp[rows-1][i]=dp[rows-1][i+1];
else
dp[rows-1][i]=0;
}
for(int i=rows-2;i>=0;i--)
{
if(input[i][cols-1]=='.')
dp[i][cols-1]=dp[i+1][cols-1];
else
dp[i][cols-1]=0;
}
for(int i=rows-2;i>=0;i--)
{
for(int j=cols-2;j>=0;j--)
{
if(input[i][j]=='.')
dp[i][j]=(dp[i+1][j]+dp[i][j+1])%co;
else
dp[i][j]=0;
}
}
cout<<dp[0][0]<<endl;
} | 0 | 100,268,070 |
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using vl = vector<long long>;
using vs = vector<string>;
using ii = vector<vector<long long>>;
int main() {
ll a;
cin >> a;
vl x(a - 1);
vl y(a);
for (int i = 0; i < a - 1; i++) {
cin >> x[i];
}
for (int i = 0; i < a-1; i++) {
if (i != 0) {
y[i] = min(x[i], x[i - 1]);
}
else {
y[i] = x[i];
}
}
ll count = 0;
for (int i = 0; i < a; i++) {
count += y[i];
}
cout << count+x[a-2] << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int h, w;
cin >> h >> w;
string s[h];
rep(i, h) cin >> s[i];
vector<vector<int>> a(h, vector<int>(w));
rep(i, h) {
int l = 0, r = 0;
rep(j, w) {
if (s[i][j] == '.')
++l;
else
l = 0;
if (s[i][w - 1 - j] == '.')
++r;
else
r = 0;
a[i][j] += l;
a[i][w - j - 1] += r;
}
}
rep(j, w) {
int l = 0, r = 0;
rep(i, h) {
if (s[i][j] == '.')
++l;
else
l = 0;
if (s[h - i - 1][j] == '.')
++r;
else
r = 0;
a[i][j] += l;
a[h - i - 1][j] += r;
}
}
int ans = 0;
rep(i, h) rep(j, w) ans = max(ans, a[i][j]);
cout << ans - 3 << endl;
return 0;
} | 0 | 65,884,503 |
#include <iostream>
using namespace std;
int main()
{
int A , B , C , D;
cin >> A >> B >> C >> D;
if ((A >= B) && (C >= D)) {cout << B + D;}
else if ((A <= B) && (C >= D)) {cout << A + D;}
else if ((A >= B) && (C <= D)) {cout << B + C;}
else if ((A <= B) && (C <= D)) {cout << A + C;}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
using pll = pair<ll,ll>;
#define INF (1LL << 60)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define REP(i,m,n) for(ll (i)=(m),(i_len)=(n);(i)<(i_len);++(i))
#define FORR(i,v) for(auto (i):v)
#define ALL(x) (x).begin(), (x).end()
#define PR(x) cout << (x) << endl
#define PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
#define REV(x) reverse(ALL((x)))
#define ASC(x) sort(ALL((x)))
#define DESC(x) ASC((x)); REV((x))
#define pb push_back
#define eb emplace_back
int main()
{
ll N;
cin >> N;
vec A = {1, 6, 6*6, 6*6*6, 6*6*6*6, 6*6*6*6*6, 6*6*6*6*6*6, 9, 9*9, 9*9*9, 9*9*9*9, 9*9*9*9*9};
vec dp(N+1, INF);
dp[0] = 0;
REP(i,1,N+1) {
REP(j,0,SZ(A)) {
if(i >= A[j]) dp[i] = MIN(dp[i],dp[i-A[j]]+1);
}
}
PR(dp[N]);
return 0;
} | 0 | 10,298,030 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int maxv = -100, a, b, c;
scanf("%d%d%d", &a, &b, &c);
if((a * 10 + b) + c > maxv)maxv = (a * 10 + b) + c;
if((a * 10 + c) + b > maxv)maxv = (a * 10 + c) + b;
if((b * 10 + a) + c > maxv)maxv = (b * 10 + a) + c;
if((b * 10 + c) + a > maxv)maxv = (b * 10 + c) + a;
if((c * 10 + a) + b > maxv)maxv = (c * 10 + a) + b;
if((c * 10 + b) + a > maxv)maxv = (c * 10 + b) + a;
if(a + (b * 10 + c) > maxv)maxv = a + (c * 10 + b);
if(a + (c * 10 + b) > maxv)maxv = a + (c * 10 + b);
if(b + (a * 10 + c) > maxv)maxv = b + (a * 10 + c);
if(b + (c * 10 + a) > maxv)maxv = b + (c * 10 + a);
if(c + (a * 10 + b) > maxv)maxv = c + (a * 10 + b);
if(c + (b * 10 + a) > maxv)maxv = c + (b * 10 + a);
printf("%d", maxv);
return 0;
} | #include <iostream>
#include <cstdio>
#include <string.h>
#include <algorithm>
#define INF 1000000
int cost[1000][1000];
int d[1000];
bool used[1000];
int n,a,b,c,m;
using namespace std;
void dijkstra(int s){
d[s] = 0;
while(1){
int v = -1;
for(int u = 0 ; u <= m ; u++ ){
if(!used[u] && (v == -1 || d[u] < d[v]))v = u;
}
if(v == -1)break;
used[v] = true;
for(int u = 0 ; u <= m ; u++ ){
d[u] = min(d[u],d[v] + cost[v][u]);
}
}
}
int main(){
int ans;
while(cin >> n,n){
memset(cost,INF,sizeof(cost));
m = 0;
for(int i = 0 ; i < n ; i++ ){
cin >> a >> b >> c;
cost[a][b] = cost[b][a] = c;
if(m < a || m < b)m = max(a,b);
}
int ansj;
int mn = 1000000;
for(int j = 0 ; j <= m ; j++ ){
fill(d,d + (m+1),INF);
fill(used,used + (m+1),false);
dijkstra(j);
ans = 0;
for(int i = 0 ; i <= m ; i++){
ans+=d[i];
}
if(mn > ans){
mn = ans;
ansj = j;
}
}
cout << ansj << " " << mn << endl;
}
} | 0 | 18,854,613 |
#include<iostream>
using namespace std;
int main() {
int cnt[10001] = { 0 };
int len;
cin >> len;
int* arr = new int[len+1];
int* narr = new int[len+1];
int max = -1;
for (int i = 1; i < len + 1; i++) {
cin >> arr[i];
if (arr[i] > max)
max = arr[i];
narr[i] = 0;-
cnt[arr[i]]++;
}
for (int i = 1; i <= max; i++)
cnt[i] += cnt[i - 1];
for (int i = len; i >= 1; i--) {
narr[cnt[arr[i]]] = arr[i];
cnt[arr[i]]--;
}
for (int i = 1; i <= len; i++)
if (i!=1)
cout << " " << narr[i];
else
cout << narr[i];
cout << endl;
return 0;
} | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
#define int long long
int32_t main() {
ios_base::sync_with_stdio(0); cin.tie(0);
int ans = 0;
int n; cin >> n;
for(int i = 1; i <= n; ++i) {
string a = to_string(i);
if (a.length() % 2 == 1) ++ans;
}
cout << ans;
} | 0 | 48,402,091 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,n) for(int i=0,_n=(int)(n);i<_n;++i)
#define ALL(v) (v).begin(),(v).end()
#define CLR(t,v) memset(t,(v),sizeof(t))
template<class T1,class T2>ostream& operator<<(ostream& os,const pair<T1,T2>&a){return os<<"("<<a.first<<","<<a.second<< ")";}
template<class T>void pv(T a,T b){for(T i=a;i!=b;++i)cout<<(*i)<<" ";cout<<endl;}
template<class T>void chmin(T&a,const T&b){if(a>b)a=b;}
template<class T>void chmax(T&a,const T&b){if(a<b)a=b;}
int nextInt() { int x; scanf("%d", &x); return x;}
bool possible(ll A, ll B, ll K) {
ll s = max(1LL, K/2 - 100);
ll t = min(K/2 + 100, K);
ll p = 0;
for (ll i = s; i <= t; i++) {
ll x = i;
ll y = K+1-i;
if (x >= A) x++;
if (y >= B) y++;
chmax(p, x * y);
}
return p < A*B;
}
int main2() {
int Q = nextInt();
while(Q-->0) {
ll A = nextInt();
ll B = nextInt();
ll lo = 0;
ll hi = 2 * max(A, B) + 10;
while (hi - lo > 1) {
ll mid = (hi + lo) / 2;
if (possible(A, B, mid)) lo = mid; else hi = mid;
}
cout << lo << endl;
}
return 0;
}
int main() {
for (;!cin.eof();cin>>ws)
main2();
return 0;
} | #include <iostream>
#include <iomanip>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <tuple>
#include <cstring>
#include <functional>
using namespace std;
typedef long long ll;
typedef pair<long long, long long> P;
#define rep(i, n) for(long long i=0; i<n; i++)
#define reps(i, s, e) for(long long i=s; i<e; i++)
#define repr(i, n) for(long long i=n-1; i>=0; i--)
#define reprs(i, s, e) for(long long i=e-1; i>=s; i--)
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m, x;
cin >> n >> m >> x;
ll c[n], a[n][m];
rep(i, n){
cin >> c[i];
rep(j, m){
cin >> a[i][j];
}
}
ll cost_min = 1e18;
ll asum[m];
ll cnt = 1;
while(cnt <= pow(2, n)){
rep(j, m){
asum[j] = 0;
}
ll cnt_temp = cnt;
ll cost = 0;
rep(i, n){
if(cnt_temp % 2 == 1){
cost += c[i];
rep(j, m){
asum[j] += a[i][j];
}
}
cnt_temp /= 2;
}
bool is_cleared = true;
rep(j, m){
if(asum[j] < x){
is_cleared = false;
break;
}
}
if(is_cleared){
if(cost < cost_min){
cost_min = cost;
}
}
cnt++;
}
if(cost_min > 1e9){
cout << -1 << endl;
}
else{
cout << cost_min << endl;
}
return 0;
} | 0 | 10,319,784 |
#include<iostream>
#include<iomanip>
#include<string>
#include<algorithm>
#include<vector>
#include<utility>
#include<tuple>
#include<map>
#include<queue>
#include<stack>
#include<deque>
#include<bitset>
#include<math.h>
using namespace std;
using ll = int64_t;
using Graph = vector<vector<int> >;
const ll M = 1000000007;
int main(){
ll n;
cin >> n;
ll sum=0;
for(int i=1;i<n;i++) sum += i;
cout << sum << endl;
} | #include<bits/stdc++.h>
using namespace std;
int n,ans,maxx;
int a[100005],shu[100005];
int main(){
cin >> n;
for(int i = 1;i <= n;i++){
cin >> a[i];
shu[a[i]]++;
if(a[i] > maxx) maxx = a[i];
}
for(int i = 1;i <= maxx;i++)
if(shu[i] > 1)
ans += shu[i] - 1;
if(ans % 2 == 1) ans++;
cout << n - ans << endl;
return 0;
} | 0 | 30,117,040 |
#include <iostream>
#include <vector>
using namespace std;
int main(){
while(true){
int N,A,B,C,X;
cin >> N >> A >> B >> C >> X;
if(N==0) break;
vector<int> Y(N);
for(int j=0;j<N;j++) cin >> Y[j];
int ind = 0;
int s=0;
for(int i=0;i<10002;i++){
if(Y[ind] == X){
ind++;
}
s = i;
if(ind == Y.size()){
break;
}
X = (A*X+B) % C;
}
if(s == 10001) cout << -1 << endl;
else cout << s << endl;
}
} | #include<bits/stdc++.h>
#define rep(i,n) for (int i=0; i<n; i++)
#define REP(i,x,n) for (int i=x; i<n; i++)
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using ll = long long;
int main(){
int n;
cin >> n;
vi a(n+2);
a.at(0) = 0;
a.at(n+1) = 0;
int sum = 0;
REP(i,1,n+1){
cin >> a.at(i);
}
rep(i,n+1){
sum += abs(a.at(i+1) - a.at(i));
}
REP(i,1,n+1){
if ((a.at(i) > a.at(i-1) && a.at(i) < a.at(i+1)) ||
(a.at(i) < a.at(i-1) && a.at(i) > a.at(i+1))){
cout << sum << endl;
}
else {
cout << sum - abs(a.at(i) - a.at(i-1)) - abs(a.at(i+1) - a.at(i)) + abs(a.at(i+1) - a.at(i-1)) << endl;;
}
}
return 0;
} | 0 | 19,272,504 |
#include <bits/stdc++.h>
using namespace std;
#include<math.h>
typedef long long int ll;
int main()
{
ll n, i, temp, z, mx1=0,mx2=0,i1,i2;
scanf("%lld", &n);
ll ara[n];
for(i=0;i<n;i++){
scanf("%lld", &ara[i]);
if(ara[i]>mx1){
mx1 = ara[i];
i1 = i;
}
}
sort(ara,ara+n);
for(i=0;i<n;i++){
if(i==i1) printf("%lld\n", ara[n-2]);
else printf("%lld\n", ara[n-1]);
}
return 0;
} | #include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <cstdio>
#include <cstring>
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
#define offcin ios::sync_with_stdio(false)
#define DEBUG freopen("#.txt", "r", stdin)
#define sigma_size 26
#define lson l,m,v<<1
#define rson m+1,r,v<<1|1
#define slch v<<1
#define srch v<<1|1
#define ll long long
#define ull unsigned long long
#define lowbit(x) (x&-x)
const int INF = 0x3f3f3f3f;
const ll INFF = 1e18;
const double pi = acos(-1.0);
const double inf = 1e18;
const double eps = 1e-9;
const ll mod = 1e9+7;
const int maxmat = 10;
const ull BASE = 133333331;
inline void RI(int &x) {
char c;
while((c=getchar())<'0' || c>'9');
x=c-'0';
while((c=getchar())>='0' && c<='9') x=(x<<3)+(x<<1)+c-'0';
}
inline ll bits(ll x) {
return !x ? x : bits(x - lowbit(x)) + 1;
}
const int maxn = 1e5 + 5;
std::vector<int> G[maxn];
int c[maxn];
bool used[maxn];
int N, M;
bool bipartitite(int u) {
bool ok = true;
for (int v : G[u]) {
if (c[u] == c[v]) ok = false;
if (!c[v]) {
c[v] = 3 - c[u];
if (!bipartitite(v)) ok = false;
}
}
return ok;
}
int main(int argc, char const *argv[]) {
cin>>N>>M;
memset(c, 0, sizeof(c));
memset(used, false, sizeof(used));
for (int i = 0; i < M; i ++) {
int u, v;
scanf("%d%d", &u, &v);
used[u] = used[v] = true;
G[u].push_back(v);
G[v].push_back(u);
}
int I = 0, B = 0, P = 0;
for (int i = 1; i <= N; i ++) {
if (!used[i]) I ++;
else if (!c[i]) {
c[i] = 1;
if (bipartitite(i)) B ++;
else P ++;
}
}
long long ans = 0;
ans += (ll)I * I + 2ll * I * (N - I);
ans += (ll)P * P + 2ll * P * B + 2ll * B * B;
cout<<ans<<endl;
return 0;
} | 0 | 78,972,864 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int INF = 1e15;
int dp[55555];
int c[22];
int n, m;
int rec(int money) {
if (money == 0) {
return dp[money] = 0;
}
if (dp[money] != INF) {
return dp[money];
}
int ans = INF;
for (int i = 0; i < m; i++) {
if (money - c[i] < 0) continue;
ans = min(ans, rec(money - c[i]) + 1);
}
return dp[money] = ans;
}
signed main() {
cin >> n >> m;
fill(dp, dp + n + 10, INF);
for (int i = 0; i < m; i++) {
cin >> c[i];
}
cout << rec(n) << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
const int mod = 7 + (1e+9);
template<long long mod>
class modint{
private:
long long num;
long long extgcd(long long a, long long b, long long&x, long long&y)const {
long long d = a;
if(b != 0){d = extgcd(b, a%b, y, x); y -= (a/b) * x;}
else{x = 1; y = 0;}
return d;
}
long long modinverse()const{
long long x, y;
extgcd(num, mod, x, y);
return (mod + x%mod)%mod;
}
public:
modint():num(0){}
modint(const long long x):num((x < 0?(x+mod):x)%mod ){}
friend modint operator+(const modint&a, const modint&b)
{ return modint(a.num + b.num); }
friend modint operator-(const modint&a, const modint&b)
{ return modint(a.num - b.num); }
friend modint operator*(const modint&a, const modint&b)
{ return modint(a.num * b.num); }
friend modint operator/(const modint&a, const modint&b)
{ return modint(a*b.modinverse()); }
friend ostream& operator<<(ostream&os, const modint&a){
os << a.num;
return os;
}
};
int main(){
int n,m; cin >> n >> m;
deque<int> s(n),t(m);
for(auto&e:s)cin >> e;
for(auto&e:t)cin >> e;
s.push_front(0);
t.push_front(0);
modint<mod> dp[2010][2010] = {};
for(int i = 1; i <= n; ++i){
for(int j = 1; j <= m; ++j){
modint<mod> x = (s[i]==t[j]?dp[i-1][j-1]+1:0);
dp[i][j] = dp[i][j-1] + dp[i-1][j] - dp[i-1][j-1] + x;
}
}
cout << dp[n][m]+1 << endl;
return 0;
} | 0 | 91,755,534 |
#include <bits/stdc++.h>
using namespace std;
int main(){
vector<int> vec(3);
for(int i=0;i<3;i++){
cin >> vec.at(i);
}
stable_sort(vec.begin(),vec.end());
cout << vec.at(2)-vec.at(0) << endl;
} | #include <algorithm>
#include <climits>
#include <iostream>
#include <string>
#include <utility>
#include<vector>
#include<iomanip>
#include<map>
#include <queue>
#include<cmath>
#include<cstdio>
#include<iomanip>
#include<set>
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=(ll)(n)-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=(a);i<=(b);i++)
#define MOD 1000000007
ll gcd(ll a, ll b) {
ll tmp;
if ( b > a) {
tmp = a;
a = b;
b = tmp;
}
while (a % b !=0) {
tmp = b;
b = a % b;
a = tmp;
}
return b;
}
const int MAX = 2000;
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;
}
void sosuu(ll n, vector<ll> &v){
vector<ll> num(n, 0);
FOR(i, 1, sqrt(n)){
if(num[i]==0){
FOR(j, 0, n/i){
num[i+(j*i)] = 1;
}
}
}
REP(i, n){
if(num[i]==0) v.push_back(i+1);
}
}
ll GetDigit(ll num){
ll digit=0;
while(num!=0){
num /= 10;
digit++;
}
return digit;
}
int main(void){
ll n;
cin>>n;
ll v[n-1][3];
REP(i, n-1){
ll c, s, f;
cin>>c>>s>>f;
v[i][0] = c;
v[i][1] = s;
v[i][2] = f;
}
REP(i, n-1){
ll start = v[i][1];
start += v[i][0];
FOR(j, i+1, n-2){
if(start-v[j][1]==0) start += v[j][0];
else if(start-v[j][1]<0) start = v[j][1] + v[j][0];
else {
if((start-v[j][1])%v[j][2]==0) start += v[j][0];
else start += (v[j][2]-((start-v[j][1])%v[j][2]) + v[j][0]);
}
}
cout<<start<<endl;
}
cout<<"0"<<endl;
return 0;
} | 0 | 9,286,462 |
#include<bits/stdc++.h>
#define ll long long
#define P pair<ll, ll>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
vector<vector<int>>G(n);
vector<int>p(m), y(m);
for(int i=0;i<m;i++){
cin >> p[i] >> y[i];
p[i]--;
G[p[i]].push_back(i);
}
vector<ll>ans(m);
for(ll i=0;i<n;i++){
if(G[i].empty()) continue;
vector<pair<ll, ll>> yy;
for(auto g:G[i]) yy.push_back({y[g], g});
sort(yy.begin(), yy.end());
for(ll j=0;j < (ll)yy.size();j++){
ans[yy[j].second] = (i+1)*1000000 + j+1;
}
}
for(int i=0;i<m;i++) printf("%012lld\n", ans[i]);
} | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define ll long long
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define sz(a) ll((a).size())
#define all(a) (a).begin(), (a).end()
#define REP(i,n) for(int i=0;i<(n);++i)
#define REPD(i,n) for(int i=(n)-1;i>=0;--i)
#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
#define FORD(i,a,b) for(int i=(a);i>=(b);--i)
const ll MOD = 1E9+7;
const ll INF = 1E18;
const double EPS = 1E-9;
const double PI = atan(1.0) * 4.0;
template<class T> T getbit(T s, int i) {return s>>i&1;}
template<class T> void flipbit(T& s, int i) {s^=(1LL<<i);}
constexpr int cntbit(ll x) {return __builtin_popcountll(x);}
constexpr int lg2(ll x) {return __lg(x);}
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
ll fpow(ll a,ll p){ll res=1LL;while(p){if(p&1LL) res=res*a%MOD;a=a*a%MOD;p>>=1LL;} return res;}
int main() {
ios_base::sync_with_stdio(0);cin.tie(0);
double n,k;
cin>>n>>k;
double res=0;
FOR(i,1,n){
double t=1.0/double(n);
if(i<k){
double p=1.0;
int j=i;
while(j<k) j*=2,p/=2.0;
t*=p;
}
res+=t;
}
cout<<fixed<<setprecision(13)<<res<<'\n';
} | 0 | 35,435,711 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const long long INF = 1LL << 60;
int gcd(int a, int b) {
if(a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
int main() {
string S;
cin >> S;
int zero_count = count(S.begin(), S.end(), '0');
int one_count = count(S.begin(), S.end(), '1');
int m = min(zero_count, one_count);
cout << m * 2 << endl;
} | #include <bits/stdc++.h>
using namespace std;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
using ll = long long;
using P = pair<int,int>;
using graph = vector<vector<int>>;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll INF = 1LL<<60;
const ll mod = 1000000007LL;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
ll pow(ll a, ll n, ll m) {
ll ret = 1LL;
for (; n > 0LL; n >>= 1LL, a = a * a % m) {
if (n % 2LL == 1LL) {
ret = ret * a % m;
}
}
return ret;
}
ll cmb(ll x, ll y){
if(y>x||y<0) return 0LL;
ll c = 1;
for(ll i = 0LL; i < y; i++) {
c *= (x-i);
c /= i+1;
}
return c;
}
int main() {
ll N,P;
cin>>N>>P;
vector<ll> v(N);
rep(i,N) {
cin>>v[i];
v[i] %= 2LL;
}
ll a=0,b=0;
rep(i,N){
if(v[i] == 0) a++;
else b++;
}
ll cnt = 0;
for(ll i = 0; i <= b;i += 2){
cnt += cmb(b,i)*(1LL<<a);
}
if(P==1) cout<<(1LL<<N)-cnt<<endl;
else cout<<cnt<<endl;
} | 0 | 4,778,462 |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
using namespace std;
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define INT(a) int((a)+1e-9)
int DX[4]={1,0,-1,0};
int DY[4]={0,1,0,-1};
typedef pair<int,int> Pii;
#define SUPnl 10002
int nl;
int p[SUPnl];
int init(){REP(ni,nl){p[ni]=-1;}}
int getRoot(int a){
while(true){
if(p[a]==-1) return a;
a=p[a];
}
}
bool same(int a, int b){
int ra=getRoot(a); int rb=getRoot(b);
if(ra!=a)p[a]=ra; if(rb!=b)p[b]=rb;
return ra==rb;
}
void unite(int a, int b){
a=getRoot(a);
b=getRoot(b);
if(a==b) return;
p[b]=a;
}
int main(){
int ol;
cin>>nl>>ol;
init();
int ot,a,b;
REP(oi,ol){
cin>>ot>>a>>b;
if(ot==0) unite(a,b);
if(ot==1) cout<<same(a,b)<<endl;
}
} | #include "bits/stdc++.h"
#include <set>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i < (n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define all(i) (i).begin(), (i).end()
#define rall(i) (i).begin(), (i).end(), greater<int>()
#define int long long
#define elif else if
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define fst first
#define sec second
#define mod 1000000007
#define INF 10e10
template <typename T>
void print(T x)
{
std::cout << x << " ";
}
template <typename T>
void println(T x)
{
std::cout << x << "\n";
}
signed main(void) {
int n, m;
cin >> n >> m;
vector<int>from;
map<int,int>to;
rep(i, m) {
int a, b;
cin >> a >> b;
a--;
b--;
if (a == 0)from.pb(b);
if (b == n - 1)to[a]++;
}
rep(i, from.size()) {
if (to[from[i]] == 1) {
print("POSSIBLE");
return 0;
}
}
print("IMPOSSIBLE");
} | 0 | 72,302,025 |
#include <bits/stdc++.h>
using namespace std;
#define PI 3.14159265358979323
#define ll long long int
#define vi vector <int>
#define vl vector <ll>
#define all(v) (v).begin(),(v).end()
#define pb push_back
ll power(ll a, ll b){
ll res=1;
while(b>0){
if(b&1){res=(res*a);b--;}
a=(a*a);
b>>=1;
}
return res;
}
ll gcd(ll a, ll b){return (b==0)?a:gcd(b,a%b);}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n,k;
cin>>n>>k;
vl h(n);
ll sum=0;
for(ll i=0;i<n;i++){
cin>>h[i];
sum+=h[i];
}
sort(all(h));
for(ll i=n-1;i>=0;i--){
if(k==0)
break;
sum-=h[i];
k--;
}
cout<<sum<<"\n";
} | #pragma GCC optimize("avx2, O3")
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <iomanip>
#include <deque>
#include <map>
#include <fstream>
#include <utility>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <numeric>
#include <random>
#include <math.h>
#include <cassert>
#include <bitset>
#include <chrono>
#include <sstream>
#include <array>
using namespace std;
#define DEBUG_VIVOD " SHTO-TO POSHLO NE TAK\n"
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define pb push_back
#define pf push_front
#define _USE_MATH_DEFINES
#define filin(x) freopen(x, "r", stdin)
#define filout(x) freopen(x, "w", stdout)
#define deq deque
#define vec vector
#define umap unordered_map
#define uset unordered_set
#define nan nullptr
#define rtn(x) {return x;}
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef unsigned long long ui;
#define INF 1e9
mt19937 prof_rand(time(0));
#define rand() prof_rand()
signed main() {
ll n, k; cin >> n >> k;
vector<ll> ar(n);
ll sum = 0;
for (auto& it : ar) {
cin >> it;
if (it >= 0) sum += it;
}
ll cur = 0;
ll mx = 0;
ll sm = 0;
for (ll i = 0; i < k - 1; ++i) {
cur += ar[i];
sum -= max(ar[i], 0ll);
}
for (ll i = k - 1; i < n; ++i) {
cur += ar[i];
sum -= max(ar[i], 0ll);
mx = max(mx, max(0ll, cur) + sm + sum);
cur -= ar[i - k + 1];
sm += max(ar[i - k + 1], 0ll);
}
cout << mx;
} | 0 | 19,093,497 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, s, e;
cin >> N;
int ans = 0;
for(int i = 0;i<N ; i++) {
cin >> s >> e;
ans += e-s+1;
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#define _GLIBCXX_DEBUG
#define DIVISOR 1000000007
using namespace std;
typedef pair<int,int> pii;
typedef pair<int64_t, int64_t> pII;
template<typename T>
void cins(vector<T>& arr) { for(T& e: arr) cin >> e; }
#ifdef DEBUG
#define debug(fmt, ...) \
printf("[debug: %s] " fmt, __func__, __VA_ARGS__)
#define ps(arr) \
debug("size %ld: ", arr.size()); \
for(auto e: arr) cout << e << " "; \
cout << endl;
#else
#define debug(fmt, ...)
#define ps(arr)
#endif
#define ROOT_NODE 1
void add(vector<int>& seg, int size, int idx, int val) {
int node = size + idx;
while(node) {
seg[node]++;
node = node/2;
}
return;
}
bool is_overlap(pii r1, pii r2) {
return r1.second > r2.first && r2.second > r1.first;
}
bool is_contain(pii t, pii box) {
return box.first <= t.first && t.second <= box.second;
}
int get_sum(vector<int>& seg, pii r, int node, pii nr) {
if(!is_overlap(r, nr)) return 0;
if(is_contain(nr, r)) return seg[node];
pii left = make_pair(nr.first, (nr.first+nr.second)/2);
pii right = make_pair((nr.first+nr.second)/2, nr.second);
int s1 = get_sum(seg, r, node*2, left);
int s2 = get_sum(seg, r, node*2+1, right);
return s1+s2;
}
#define VAL_MAX 2000
#define VAL2_MAX (1<<11)
int main(void) {
int num,k;
cin >> num >> k;
vector<int> arr(num*2);
for(int i = 0; i < num; i++) {
int val;
cin >> val;
val--;
arr[i] = arr[i+num] = val;
}
vector<int> seg(VAL2_MAX*2);
pii whole = make_pair(0, VAL2_MAX);
vector<int> res(num*2);
for(int i = 0; i < num*2; i++) {
int val = arr[i];
pii range = make_pair(val+1, VAL2_MAX);
res[i] = get_sum(seg, range, ROOT_NODE, whole);
debug("[val %d]%d -> %d\n", val, i, res[i]);
add(seg, VAL2_MAX, val, 1);
}
int64_t sum = 0;
int64_t sum_k = ((int64_t)k * (k-1) / 2)%DIVISOR;
for(int i = 0; i < num; i++) {
int64_t init = res[i];
int64_t d = res[num+i]-init;
debug("seq init: %d, d: %d, k: %d\n", init, d, k);
int64_t res = (init*k)%DIVISOR;
sum = (sum + res)%DIVISOR;
res = (sum_k * d)%DIVISOR;
sum = (sum + res)%DIVISOR;
}
cout << sum << endl;
return 0;
} | 0 | 70,963,683 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <cmath>
#include <iomanip>
#include <ctype.h>
using namespace std;
using ll = long long;
using PAIR = pair<int, int>;
using PAIRLL = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
#define rep(i,N) for(int i=0;i<(int)N;++i)
ll GCD(ll x, ll y) {
if (y == 0) return x;
else return GCD(y, x % y);
}
bool my_compare(pair<string, int> a, pair<string, int> b) {
if (a.first != b.first) {
return a.first < b.first;
}
if (a.second != b.second) {
return a.second > b.second;
}
else {
return true;
}
}
int main()
{
int N;
cin>>N;
vector<ll> A(N);
rep(i,N) cin>>A[i];
ll M=0;
for(int i=0;i<N-1;++i){
for(int j=i+1;j<N;++j){
M=max(abs(A[i]-A[j]),M);
}
}
cout<<M<<endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll n,m;
cin >> n >> m;
ll a[n];
ll b[n+1];
b[0]=0;
map<ll,ll> mp;
for(ll i=0;i<n;i++){
cin >> a[i];
b[i+1]=b[i]+a[i];
b[i+1]%=m;
}
for(ll i=0;i<=n;i++){
mp[b[i]]++;
}
ll res=0;
for(auto p:mp){
res+=p.second*(p.second-1)/2;
}
cout << res << endl;
} | 0 | 46,709,364 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,x,t;
cin>>n>>x>>t;
int a;
if(n%x==0){
a=n/x;
}
else{
a=n/x +1;
}
cout<<a*t<<endl;
} | #include <stdio.h>
int main(){
int a[3][3], c[3][3]={0};
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
scanf("%d", &a[i][j]);
}
}
int N;
scanf("%d", &N);
int b[N];
for(int i=0;i<N;i++){
scanf("%d", &b[i]);
}
for(int k=0;k<N;k++){
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
if(a[i][j] == b[k]){
c[i][j]++;
}
}
}
}
for(int i=0; i<N; i++){
if(c[i][0]+c[i][1]+c[i][2] == 3){
printf("Yes\n");
return 0;
}
if(c[0][i]+c[1][i]+c[2][i] == 3){
printf("Yes\n");
return 0;
}
}
if(c[0][0]+c[1][1]+c[2][2] == 3){
printf("Yes\n");
return 0;
}
if(c[2][0]+c[1][1]+c[0][2] == 3){
printf("Yes\n");
return 0;
}
printf("No\n");
return 0;
} | 0 | 14,517,935 |
#include <stdio.h>
int main(){
char name1[110];
char name2[110];
scanf("%s%s", &name1, &name2);
printf("%s%s", name2, name1);
return 0;
} | #include<bits/stdc++.h>
#define endl '\n';
#define rep(i,n) for(int i=0; i<(n); i++)
using namespace std;
using ll = long long;
using P = pair<int,int>;
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("Ofast")
constexpr ll INF = 1e18;
constexpr int inf = 1e9;
constexpr double INFD = 1e100;
constexpr ll mod = 1000000007;
constexpr ll mod2 = 998244353;
const double PI = 3.1415926535897932384626433832795028841971;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main(){
int N;
cin >> N;
vector<string> S(N);
rep(i,N){
cin >> S[i];
}
int ans = 0;
rep(k,N){
bool can = true;
rep(i,N){
rep(j,N){
if(S[(i+k)%N][j] != S[(j+k)%N][i]) can = false;
}
}
if(can){
ans += N;
}
}
cout << ans << endl;
return 0;
} | 0 | 24,557,031 |
#include<iostream>
using namespace std;
int main(){
int d,a;
while(cin>>d){
a=0;
for(int i=0;i+d<=600;i+=d)
a+=d*i*i;
cout<<a<<endl;
}
} | #include <iostream>
#include <vector>
using namespace std;
int X[100];
int main() {
int N, M;
double P;
while (cin >> N >> M >> P, N) {
P /= 100;
int sum = 0;
for (int i = 0; i < N; i++) {
cin >> X[i];
sum += 100 * X[i];
}
M--;
if (X[M] == 0) {
cout << 0 << endl;
} else {
cout << int(sum * (1.0 - P) / X[M] + 1e-9) << endl;
}
}
} | 0 | 17,955,388 |
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<vector>
#include<functional>
#include<algorithm>
#include<stdlib.h>
#include<string>
#include<string.h>
#define _USE_MATH_DEFINES
#include<math.h>
#include<deque>
#include<set>
#include<map>
#include<queue>
#include<list>
#include<iostream>
#include <bitset>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(auto i=a;i<b;i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x *= x; p /= 2; } else { a *= x; p--; } }return a; }
ll mpower(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x = x * x % mod; p /= 2; } else { a = a * x % mod; p--; } }return a; }
ll c(ll n, ll k) { ll a = 1; rep(i, 1, k) { a *= n - i + 1; a /= i; }return a; }
ll mc(ll n, ll m) { ll k = 1, l = 1; rep(i, n - m + 1, n + 1) k = k * i % mod; rep(i, 1, m + 1) l = l * i % mod; l = mpower(l, mod - 2); return k * l % mod; }
int main(void) {
ll a, b, va = 0, vb = 0;
cin >> a >> b;
if (a == b) {
printf("%lld\n", a);
return 0;
}
a--;
if (a % 2 == 0)va = a ^ (a / 2 % 2);
else va ^= ((a + 1) / 2 % 2);
if (b % 2 == 0)vb = b ^ (b / 2 % 2);
else vb ^= ((b + 1) / 2 % 2);
printf("%lld\n", va^vb);
if (a == 0) {
printf("%lld\n", vb);
return 0;
}
return 0;
} | #include <bits/stdc++.h>
#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++)
#define repr(i, n) for (ll i = n; i >= 0; i--)
#define pb push_back
#define COUT(x) cout << (x) << endl
#define COUTF(x) cout << setprecision(15) << (x) << endl
#define ENDL cout << endl
#define DF(x) x.erase(x.begin())
#define ALL(x) x.begin(), x.end()
#define SORT(x) sort(ALL(x))
#define REVERSE(x) reverse(ALL(x))
#define init() \
cin.tie(0); \
ios::sync_with_stdio(false)
#define debug(x) cerr << "[debug] " << #x << ": " << x << endl;
#define debugV(v) \
cerr << "[debugV] " << #v << ":"; \
rep(i, v.size()) cerr << " " << v[i]; \
cerr << endl;
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using P = pair<ll, ll>;
constexpr ll INF = 0x3f3f3f3f3f3f3f3f;
constexpr ld PI = 3.141592653589793238462643383279;
ll get_digit(ll x) {
return to_string(x).size();
}
ll gcd(ll x, ll y) {
return y ? gcd(y, x % y) : x;
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}
vector<P> factorize(ll n) {
vector<P> result;
for (ll i = 2; i * i <= n; ++i) {
if (n % i == 0) {
result.pb({i, 0});
while (n % i == 0) {
n /= i;
result.back().second++;
}
}
}
if (n != 1) {
result.pb({n, 1});
}
return result;
}
vll divisor(ll n) {
vll ret;
for (ll 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);
return (ret);
}
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;
}
signed main() {
init();
string S;
cin >> S;
if (S[0] != 'A') {
COUT("WA");
return 0;
}
ll c_count = 0;
rep(i, S.size()) {
if (i == 0 || i == 1) continue;
if (i == (ll)S.size() - 1) continue;
if (S[i] == 'C') {
c_count++;
}
}
if (c_count != 1) {
COUT("WA");
return 0;
}
rep(i, S.size()) {
if (i == 0) continue;
if (S[i] == 'C') continue;
if (isupper(S[i])) {
COUT("WA");
return 0;
}
}
COUT("AC");
return 0;
} | 0 | 58,838,896 |
#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(){
ll n; cin >> n;
string s = to_string(n);
ll res = 0;
if(n%2 == 0){
ll dev = 5*2;
while(n >= dev){
res += n/dev;
dev *= 5;
}
cout << res << endl;
}
else cout << 0 << endl;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
solve();
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define REP(i, a, b) for(ll i = a; i <= b; i++)
#define out(x) std::cout << x << '\n'
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define sz(x) ((int)(x).size())
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { ll g = gcd(a, b); return a / g * b; }
const int dx[4] = { 1, 0, -1, 0 };
const int dy[4] = { 0, 1, 0, -1 };
const int INF = (int)1e9;
const ll inf = (ll)1e18;
const int mod = 1000000007;
const int MAX_N = 100010;
const double PI = acos(-1);
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
int n, c, k;
cin >> n >> c >> k;
vector<int> t(n);
rep(i, n) cin >> t[i];
sort(all(t));
int res = 0;
int i = 0;
while (i < n)
{
res++;
int start = i;
while (i < n
&& t[i] - t[start] <= k
&& i - start < c) {
i++;
}
}
out(res);
return 0;
} | 0 | 20,937,558 |
#include<iostream>
using namespace std;
int main(){
int a, b, c, info = 0;
cin >> a >> b >> c;
for (;;){
if (c % a == 0){
info += 1;
}
a += 1;
if (a > b){
break;
}
}
cout << info << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(void){
int N;
vector<int64_t> A, B;
int64_t ans=0;
cin >>N;
for(int i=0;i<N+1;i++){
int64_t tmp;
cin >>tmp;
A.push_back(tmp);
}
for(int i=0;i<N;i++){
int64_t tmp;
cin >>tmp;
B.push_back(tmp);
}
for(int i=0;i<N;i++){
if(B[i] <= A[i]){
ans += B[i];
A[i] -= B[i];
}
else if(B[i] <= A[i]+A[i+1]){
ans += B[i];
A[i+1] -= B[i]-A[i];
A[i] = 0;
}
else {
ans += A[i]+A[i+1];
A[i+1] = 0;
A[i] = 0;
}
}
cout <<ans<<endl;
return 0;
} | 0 | 63,767,225 |
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <numeric>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <string>
#include <functional>
#include <list>
#include <random>
#include <time.h>
#include <iomanip>
#include <assert.h>
#include <numeric>
#define int long long
#define double long double
#define mod 1000000007
#define MAXN (int)1e+5 * 2+1
#define LL_MAX 9223372036854775807
#define LL_HALFMAX 9223372036854775807 / 2
#define MIN -(9223372036854775807 / 2)
#define INF 9223372036854775807 / 2
#define REP(i,a,n) for(int i=(a); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define FOR(it,c) for(__typeof((c).begin()) it=(c).begin(); it!=(c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
#define REPS(i,x) for(int i=1;i<=(int)(x);i++)
#define RREP(i,x) for(int i=((int)(x)-1);i>=0;i--)
#define RREPS(i,x) for(int i=((int)(x));i>0;i--)
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define mp make_pair
using namespace std;
std::mt19937 mt((int)time(0));
int dx[4] = { 0, 1, 0, -1 };
int dy[4] = { 1, 0, -1, 0 };
using Weight = int;
using Flow = int;
struct Edge {
int src, dst;
Weight weight;
Flow cap;
Edge() : src(0), dst(0), weight(0) {}
Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;
void add_edge(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
g[b].emplace_back(b, a, w);
}
void add_arc(Graph &g, int a, int b, Weight w = 1) { g[a].emplace_back(a, b, w); }
struct uf_tree {
std::vector<int> parent;
int __size;
uf_tree(int size_) : parent(size_, -1), __size(size_) {}
void unite(int x, int y) {
if ((x = find(x)) != (y = find(y))) {
if (parent[y] < parent[x]) std::swap(x, y);
parent[x] += parent[y];
parent[y] = x;
__size--;
}
}
bool is_same(int x, int y) { return find(x) == find(y); }
int find(int x) { return parent[x] < 0 ? x : parent[x] = find(parent[x]); }
int size(int x) { return -parent[find(x)]; }
int size() { return __size; }
};
class Node {
};
class dp {
private:
bool InnerValues[20000][8001];
public:
bool Get(int pos, int index) {
if (pos + 10000 > 20000) return 0;
if (pos + 10000 < 0) return 0;
return InnerValues[pos + 10000][index];
}
void Set(int pos, int index, bool value) {
if (pos + 10000 > 20000) return;
if (pos + 10000 < 0) return;
InnerValues[pos + 10000][index] = value;
}
};
dp dpx;
dp dpy;
vector<pair<char, int>> inst;
signed main() {
string s;
cin >> s;
const int len = s.length();
int x, y;
cin >> x >> y;
char now = s[0];
int cnt = 0, consumed = 0;
for (auto c : s) {
if (now != c) {
inst.push_back(make_pair(now, cnt));
now = c;
cnt = 0;
}
cnt++;
consumed++;
if (consumed == len) {
inst.push_back(make_pair(now, cnt));
}
}
bool isX = true;
if (inst[0].first == 'F') {
dpx.Set(inst[0].second, 0, true);
dpy.Set(0, 0, true);
}
else {
if (inst[0].second % 2 == 1) {
isX = !isX;
}
dpx.Set(0, 0, true);
dpy.Set(0, 0, true);
}
rep(i, inst.size()) {
if (i == 0) continue;
if (inst[i].first == 'T') {
if (inst[i].second % 2 == 1) {
isX = !isX;
}
for (int j = -len; j <= len; j++) {
rep(k, 4) {
dpx.Set(j, i, dpx.Get(j, i - 1));
dpy.Set(j, i, dpy.Get(j, i - 1));
}
}
continue;
}
for (int j = -len; j <= len; j++) {
if (isX) {
bool value = dpx.Get(j - inst[i].second, i - 1) || dpx.Get(j + inst[i].second, i - 1);
dpx.Set(j, i, value);
dpy.Set(j, i, dpy.Get(j, i - 1));
}
else {
bool value = dpy.Get(j - inst[i].second, i - 1) || dpy.Get(j + inst[i].second, i - 1);
dpy.Set(j, i, value);
dpx.Set(j, i, dpx.Get(j, i - 1));
}
}
}
int instLen = inst.size();
if (dpx.Get(x, instLen - 1) && dpy.Get(y, instLen - 1)) {
cout << "Yes\n";
}
else {
cout << "No\n";
}
return 0;
} | #include <iostream>
#include <fstream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <cstring>
#include <cassert>
#include <utility>
#include <iomanip>
#include <chrono>
#include <random>
#include <bitset>
using namespace std;
#define sz(x) (int) x.size()
#define unique(x) x.erase(unique(x.begin(), x.end()), x.end())
#define all(a) a.begin(), a.end()
#define sqr(x) ((x) * (x))
#define y1 aksjdaskdjksjfksdjf
#define left kdnvldvoiwejifejg
#define right lkdsjflksdjfdjfk
#define prev asdasfsadjkjsdfjs
#define tm aklsjdasjdasjdkdjjf
#define lcm hddalkwjeidjjhasda
#define random_shuffle asdasdd
const int MAXN = 105000;
int n;
int a[MAXN];
long long l[MAXN], r[MAXN];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
if (i == 0) {
l[i] = abs(a[i]);
} else {
l[i] = l[i - 1] + abs(a[i] - a[i - 1]);
}
}
for (int i = n - 1; i >= 0; i--) {
if (i == n - 1) {
r[i] = abs(a[i]);
} else {
r[i] = r[i + 1] + abs(a[i] - a[i + 1]);
}
}
for (int i = 0; i < n; i++) {
long long cur = 0;
if (i == 0) {
cur = r[i + 1] + abs(a[i + 1]);
} else if (i == n - 1) {
cur = l[i - 1] + abs(a[i - 1]);
} else {
cur = l[i - 1] + r[i + 1] + abs(a[i + 1] - a[i - 1]);
}
printf("%lld\n", cur);
}
return 0;
} | 0 | 95,971,581 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (ll (i) = 0 ; (i) < (ll)(n) ; ++(i))
#define REPN(i, m, n) for (ll (i) = m ; (i) < (ll)(n) ; ++(i))
#define REP_REV(i, n) for (ll (i) = (ll)(n) - 1 ; (i) >= 0 ; --(i))
#define REPN_REV(i, m, n) for (ll (i) = (ll)(n) - 1 ; (i) >= m ; --(i))
#define INF 2e9
#define INF_LL 1LL<<60
#define ll long long
typedef pair<ll, ll> P;
int main(){
string s;
cin >> s;
int n = s.size();
REP(i, n-1) {
if(s[i] == s[i+1]) {
cout << i+1 << " " << i+2;
return 0;
}
}
REP(i, n-2) {
if(s[i] == s[i+2]) {
cout << i + 1 << " " << i + 3;
return 0;
}
}
cout << "-1 -1" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
#define INF 2e18
#define eps 1e-9
#define FastRead ios_base::sync_with_stdio(0);cin.tie(0)
#define fRead freopen("input.txt","r",stdin)
#define fWrite freopen("output.txt","w",stdout)
#define LL long long
#define ull unsigned long long
#define PI acos(-1.0)
#define pb push_back
#define mk make_pair
#define pii pair<int,int>
#define pLL pair<LL,LL>
#define ff first
#define ss second
#define all(a) a.begin(),a.end()
#define SQR(a) ((a)*(a))
#define min3(a,b,c) min(a,min(b,c))
#define max3(a,b,c) max(a,max(b,c))
#define min4(a,b,c,d) min(min(a,b),min(c,d))
#define max4(a,b,c,d) max(max(a,b),max(c,d))
#define max5(a,b,c,d,e) max(max3(a,b,c),max(d,e))
#define min5(a,b,c,d,e) min(min3(a,b,c),min(d,e))
#define vi vector <int>
#define vL vector <LL>
#define LB(a,x) (lower_bound(all(a),x)-a.begin())
#define UB(a,x) (upper_bound(all(a),x)-a.begin())
#define prec(n) fixed << setprecision(n)
#define MEM(a,x) memset(a,x,sizeof(a))
#define SORT(v) sort(v.begin(),v.end())
#define REV(v) reverse(v.begin(),v.end())
#define Unique(a) sort(all(a)),a.erase(unique(all(a)),a.end())
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define ROF(i,a,b) for(int i=a;i>=b;i--)
#define REP(i,b) for(int i=0;i<b;i++)
#define IT(it,x) for(it=x.begin();it!=x.end();it++)
int main()
{
LL l,r;
cin>>l>>r;
LL mn=INF;
for(LL i=l;i<=min(l+2019,r);i++)
{
for(LL j=i+1;j<=min(l+2019,r);j++)
{
LL mod=((i%2019)*(j%2019))%2019;
mn=min(mod,mn);
}
}
cout<<mn;
} | 0 | 34,948,780 |
#include <bits/stdc++.h>
#include <functional>
#include <iomanip>
using namespace std;
#define int long long
#define pb push_back
#define F first
#define S second
#define FOR(i,a,b) for(int (i)=(a);(i)<(b);(i)++)
#define REP(i,n) FOR(i,0,n)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define SORT(c) sort((c).begin(),(c).end())
#define ve vector
#define vi vector<int>
#define vp vector<pair<int,int>>
#define vvi vector<vector<int>>
using ll = long long;
ll INF = LLONG_MAX / 4 - 100;
ll mod = 1e9 + 7;
int dx[] = {-1,0,1,0}, dy[] = {0,1,0,-1};
vector<ll> prime;
class fact {
public:
int fmod = 1e9+7;
vector<int> fac, inv;
fact (int n, int Mod = 1e9+7) {
fmod = Mod;
fac = vector<int>(n,0);
inv = vector<int>(n,0);
fac[0] = 1; for (int i = 1; i < n; i++) fac[i] = fac[i-1] * i % fmod;
for (int i = 0;i < n;i++) inv[i] = fact::POW(fac[i],fmod-2);
}
ll nCr(ll n, ll r) {return (fac[n] * inv[r] % fmod) * inv[n-r] % fmod;}
ll POW(ll a, ll b) {ll c = 1; while (b > 0) {if (b & 1) {c = a * c%fmod;}a = a * a%fmod; b >>= 1;}return c;}
};
template <class T = ll> T in() {T x; cin >> x; return (x);}
void DEBUG(vector<int> a) {for(int i=0;i<a.size();i++)cout<<a[i]<<" ";cout<<endl;}
void EMP(int x) {cout<<"!!!"<<x<<"!!!"<<endl;}
ll GCD(ll a, ll b) {ll c; while (b != 0) {c = a % b; a = b; b = c;}return a;}
ll LCM(ll a, ll b) {return a * b / GCD(a, b);}
ll POW(ll a, ll b) {ll c = 1; while (b > 0) {if (b & 1) {c = a * c%mod;}a = a * a%mod; b >>= 1;}return c;}
void PRI(ll n) {bool a[n + 1LL]; for (int i = 0; i < n + 1LL; i++) {a[i] = 1LL;}for (int i = 2; i < n + 1LL; i++) {if (a[i]) {prime.pb(i); ll b = i; while (b <= n) {a[b] = 0; b += i;}}}}
template <typename T> T chmin(T& a, T b) {if(a>b)a=b;return a;}
template <typename T> T chmax(T& a, T b) {if(a<b)a=b;return b;}
bool isSqrt(ll a) {return pow(sqrt(a),2) == a ? 1 : 0;}
void YesNo(bool a) {if (a) cout << "Yes"; else cout << "No"; cout << endl;}
void yesno(bool a) {if (a) cout << "yes"; else cout << "no"; cout << endl;}
void YESNO(bool a) {if (a) cout << "YES"; else cout << "NO"; cout << endl;}
double dis(int x1, int x2, int y1, int y2) {
return sqrt((double)abs(x1-x2)*(double)abs(x1-x2)+(double)abs(y1-y2)*(double)abs(y1-y2));
}
bool solve() {
int n, k; cin >> n >> k;
int A[n], B[n]; REP (i,n) cin >> A[i] >> B[i];
int tn = 1<<29;
int tr = 1<<29;
int K = k;
bool zero[30]={0};
REP (i,30) {
if (K >= tr) {zero[i] = 1; K -= tr;}
tr >>= 1;
}
bool filz[30]={0}; REP (i,30) {
if (zero[i]) filz[i] = false;
else if (i!=0&&!filz[i-1]) filz[i] = false;
else filz[i] = true;
}
int ans = 0;
REP (i,30) {
if (zero[i]) {
int cand = 0;
filz[i] = true;
REP (j,n) {
int tmp = A[j];
int p = tn;
bool ok = true;
REP (l,30) {
if ((tmp>=p)&&filz[l]) {ok = false;}
if (tmp>=p) tmp -= p;
p >>= 1;
}
if (ok) cand += B[j];
}
chmax(ans,cand);
filz[i] = false;
} else {
filz[i] = true;
}
}
int cand = 0;
REP (j,n) {
int tmp = A[j];
int p = tn;
bool ok = true;
REP (l,30) {
if ((tmp>=p)&&filz[l]) {ok = false;}
if (tmp>=p) tmp -= p;
p >>= 1;
}
if (ok) cand += B[j];
}
chmax(ans,cand);
cout << ans << endl;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> bricks(n);
for (int i = 0; i < n; i++) {
cin >> bricks[i];
}
int next_no = 1;
for (int i = 0; i < n; i++) {
if (bricks[i] == next_no) {
next_no++;
}
}
if (next_no == 1) {
cout << -1;
} else {
cout << n - next_no + 1;
}
} | 0 | 33,702,288 |
#include <bits/stdc++.h>
#define For(i, a, b) for(int (i)=(int)(a); (i)<(int)(b); ++(i))
#define rFor(i, a, b) for(int (i)=(int)(a)-1; (i)>=(int)(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef unsigned long long ulint;
typedef pair<int, int> pii;
typedef pair<int, lint> pil;
typedef pair<lint, int> pli;
typedef pair<lint, lint> pll;
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;}
template<class T> T div_floor(T a, T b){
if(b < 0) a *= -1, b *= -1;
return a>=0 ? a/b : (a+1)/b-1;
}
template<class T> T div_ceil(T a, T b){
if(b < 0) a *= -1, b *= -1;
return a>0 ? (a-1)/b+1 : a/b;
}
constexpr lint mod = 1e9+7;
constexpr lint INF = mod * mod;
constexpr int MAX = 200010;
int main(){
string s;
cin >> s;
int n = s.size();
int X[n+1];
X[0] = 0;
rep(i, n) X[i+1] = X[i] ^ (1 << (s[i]-'a'));
int dp[n+1];
fill(dp, dp+n+1, MAX);
dp[0] = 0;
map<int, int> mp;
mp[0] = 0;
For(i, 1, n+1){
if(mp.find(X[i]) != mp.end()) dp[i] = mp[X[i]] + 1;
rep(j, 26){
int t = X[i] ^ 1<<j;
if(mp.find(t) != mp.end()) chmin(dp[i], mp[t] + 1);
}
if(mp.find(X[i]) == mp.end()) mp[X[i]] = dp[i];
else chmin(mp[X[i]], dp[i]);
}
printf("%d\n", dp[n]);
} | #include<bits/stdc++.h>
using namespace std;
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cout<<fixed; cout<<setprecision(12);
#define randomINT mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#define newl cout<<"\n"
#define DISP(as) for(auto it : as) cout<<it<<" ";newl;
#define all(x) (x).begin(),(x).end()
#define mset(x,val) memset(x,val,sizeof(x))
#define newl cout<<"\n"
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define dline cerr<<"
#define deb1(x) cerr<<#x<<" = "<<x<<'\n';
#define deb2(x,y) cerr<<'['<<#x<<','<<#y<<"] = "<<'['<<x<<','<<y<<']'<<'\n';
#define deb3(x,y,z) cerr<<'['<<#x<<','<<#y<<','<<#z<<"] = "<<'['<<x<<','<<y<<','<<z<<']'<<'\n';
typedef long long ll;
typedef long double ld;
typedef vector<ll> vll;
typedef pair<ll ,ll> pll;
typedef pair<ld,ld> pld;
typedef unordered_map<ll,ll> um;
typedef vector<pll> vpll;
const ll MAX5 = 1e+5+7;
const ll MAX7 = 1e+7+7;
const ll MAXN = MAX7;
const ll INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
const ll MOD = 1e+9+7;
const ll N = 2*1e6;
ll T=1;
ll n,x,y,m;
string s,t;
void MAIN() {
vll a(3);
cin>>a[0]>>a[1]>>a[2];
sort(all(a));
ll val = 3*a[2];
if(val%2 == (a[0]+a[1]+a[2])%2) x=a[2];
else x=a[2]+1;
cout<<(ll)(3*x - (a[0]+a[1]+a[2]))/2;
}
int main() {
fastio;randomINT;
while(T--) {
MAIN();
}
return 0;
} | 0 | 45,390,361 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,m,x,y,a,b;
cin >> n >> m >> x >> y;
int MXx = -101,MNy = 101;
for ( int i = 0; i < n; i++){
cin >> a;
MXx = max(MXx,a);
}
for ( int i = 0; i < m; i++){
cin >> b;
MNy = min(MNy,b);
}
for ( int i = x + 1; i <= y; i++){
if ( MXx < i && i <= MNy ){
cout << "No War" << endl;
return 0;
}
}
cout << "War" << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
const int MAXN = 18;
int sum[MAXN+1][1<<MAXN];
int boro[MAXN+1][1<<MAXN];
int main() {
int n;
cin >> n;
for (int i = 0; i < (1<<n); i++) {
cin >> boro[0][i];
sum[0][i] = -1;
}
for (int p = 1; p <= n; p++) {
for (int msk = 0; msk < (1<<n); msk++) {
boro[p][msk] = boro[p-1][msk];
sum[p][msk] = sum[p-1][msk];
if (msk&(1<<(p-1))) {
boro[p][msk] = max(boro[p][msk], boro[p-1][msk^(1<<(p-1))]);
sum[p][msk] = max(sum[p][msk], boro[p-1][msk]+boro[p-1][msk^(1<<(p-1))]);
}
}
}
int mx = -1;
for (int i = 1; i < (1<<n); i++) {
mx = max(mx, sum[n][i]);
cout << mx << "\n";
}
return 0;
} | 0 | 87,771,458 |
#include <iostream>
#include <vector>
using namespace std;
int main(){
int N;
while(cin >> N){
vector<long long> A(N);
long long all = 0;
for(auto& t : A){
cin >> t;
all ^= t;
}
int start = 0;
for(int i=60;i>=0;i--){
if(all&(1LL<<i)) continue;
int idx = -1;
for(int j=start;j<N;j++){
if(A[j]&(1LL<<i)){
idx = j;
break;
}
}
if(idx == -1) continue;
swap(A[start], A[idx]);
for(int j=0;j<N;j++){
if(j != start && (A[j]&(1LL<<i))) A[j] ^= A[start];
}
++start;
}
long long cur = 0;
for(int i=0;i<start;i++) cur ^= A[i];
cout << (2*(cur&~all) + all) << endl;
}
} | #include <bits/stdc++.h>
#define f(i,j,k) for(int i=j;i<k;i++)
using namespace std;
int main(){
string s;
cin>>s;
bool f=true;
long long ans=0;
if(s[0]!='A'){
f=false;
}
f(i,2,s.size()-1){
if(s[i]=='C'){
ans++;
}
else if(s[i]-'a'<0){
f=false;
}
}
if(s[1]-'a'<0||s[s.size()-1]-'a'<0){
f=false;
}
if(f&&ans==1){
cout<<"AC"<<endl;
}
else{
cout<<"WA"<<endl;
}
return 0;
} | 0 | 36,196,446 |
#include <bits/stdc++.h>
using namespace std;
#define FasterIO ios::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define TIME clock()*1.0/CLOCKS_PER_SEC
#define pi acos(-1.0)
#define mem(a,b) memset(a,b,sizeof(a))
#define all(a) a.begin(),a.end()
#define Sort(x) sort(x.begin(),x.end())
#define Reverse(x) reverse(x.begin(),x.end())
#define SortA(ar,s) sort(ar,ar+s)
#define SortD(ar,s) sort(ar,ar+s,greater<int>())
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) (a*(b/gcd(a,b)))
#define sq(x) (x)*(x)
#define CEIL(a,b) ((a/b)+((a%b)!=0))
#define POSL(x,v) (lower_bound(x.begin(),x.end(),v)-x.begin())
#define POSU(x,v) (upper_bound(x.begin(),x.end(),v)-x.begin())
#define min3(a,b,c) min(a,min(b,c))
#define min4(a,b,c,d) min(a,min(b,min(c,d)))
#define max3(a,b,c) max(a,max(b,c))
#define max4(a,b,c,d) max(a,max(b,max(c,d)))
#define ABS(x) ((x)<0?-(x):(x))
#define pb push_back
#define mod 1000000007
#define nl printf("\n")
#define oh cout<<"Problem ta ki? "<<endl;
inline bool isLow(char ch){return (ch>='a' && ch<='z');}
inline bool isUpp(char ch){return (ch>='A' && ch<='Z');}
inline bool isDig(char ch){return (ch>='0' && ch<='9');}
#define isOn(S, j) (S & (1 << j))
#define setBit(S, j) (S |= (1 << j))
#define clearBit(S, j) (S &= ~(1 << j))
#define toggleBit(S, j) (S ^= (1 << j))
#define lowBit(S) (S & (-S))
#define setAll(S, n) (S = (1 << n) - 1)
#define modulo(S, N) ((S) & (N - 1))
#define isPowerOfTwo(S) (!(S & (S - 1)))
#define nearestPowerOfTwo(S) ((int)pow(2.0, (int)((log((double)S) / log(2.0)) + 0.5)))
#define turnOffLastBit(S) ((S) & (S - 1))
#define turnOnLastZero(S) ((S) | (S + 1))
#define turnOffLastConsecutiveBits(S) ((S) & (S + 1))
#define turnOnLastConsecutiveZeroes(S) ((S) | (S - 1))
#define BinaryToGray(k) (k^(k>>1))
void printSet(int vS) {
printf("S = %2d = ", vS);
stack<int> st;
while (vS)
st.push(vS % 2), vS /= 2;
while (!st.empty())
printf("%d", st.top()), st.pop();
printf("\n");
}
#define Lower_bound(vec,value) lower_bound(vec.begin(),vec.end(),value)
#define Upper_bound(vec,value) upper_bound(vec.begin(),vec.end(),value)
#define READ(f) freopen(f, "r" ,stdin)
#define WRITE(f) freopen(f, "w" ,stdout)
#define ll long long int
#define SIZ 1000005
void solve()
{
int n,d;
cin>>n>>d;
int ar[n+5][d+5];
for(int i=0;i<n;i++)
for(int j=0;j<d;j++)cin>>ar[i][j];
int res=0;
for(int i=0;i<n;i++)
{
for(int j=i+1;j<n;j++)
{
int dis=0;
for(int k=0;k<d;k++)
{
int dif=abs(ar[i][k]-ar[j][k]);
dis+=(dif*dif);
}
int sq=sqrt(dis);
if(sq*sq==dis)res++;
}
}
cout<<res<<endl;
return;
}
int main()
{
int tc=1;
for(int i=1; i<=tc; i++)
{
solve();
}
return 0;
} | #include<iostream>
#include<bits/stdc++.h>
#include<math.h>
#include<vector>
#include<string>
#include<cstring>
#include<ctype.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <functional>
using namespace __gnu_pbds;
using namespace std;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
new_data_set;
typedef long long ll;
typedef long l;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define pb push_back
#define FOR(i,a,b) for(int i=a;i<b;i++)
#define ERR(x) cout<<"#x:"<<x<<endl
#define ERR2(x,y) cout<<"#x:"<<x<<" "<<"#y:"<<y<<endl;
#define ERR3(x,y,z) cout<<"#x:"<<x<<" "<<"#y:"<<y<<" "<<"#z:"<<z<<endl;
#define show(v) for(auto e: v) cout<<e<<" ";
#define showArr(A,n) for(int i=0;i<n;i++) cout<<A[i]<<" ";
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define mp make_pair
#define endl "\n"
#define ff first
#define ss second
#define all(v) v.begin(),v.end()
ll lc = 0;
void dfs(vector<ll>adj[], ll s, vector<bool>&visited){
visited[s] = true;
lc++;
for(auto e: adj[s]){
if(!visited[e]){
dfs(adj,e,visited);
}
}
}
int main()
{
ll n,m;
cin>>n>>m;
vector<ll>adj[n];
FOR(i,0,m){
ll u,v;
cin>>u>>v;
u--;
v--;
adj[u].pb(v);
adj[v].pb(u);
}
ll best = 0;
vector<bool>visited(n,false);
FOR(i,0,n){
lc = 0;
if(!visited[i]){
dfs(adj,i,visited);
}
best = max(lc,best);
}
cout<<best<<endl;
return 0;
} | 0 | 13,969,161 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = n; i <= 999; i++) {
string str = to_string(i);
set<char> st;
for (int i = 0; i < str.size(); i++) {
st.insert(str[i]);
}
if (st.size() == 1) {
cout << i << endl;
break;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int h,w;
cin>>h>>w;
vector<vector<char>> c(h,vector<char>(w));
vector<vector<char>> d(h*2,vector<char>(w));
for(int i=0; i<h; i++){
for(int j=0; j<w; j++){
cin>>c[i][j];
d[i*2][j]=c[i][j];
d[i*2+1][j]=c[i][j];
}
}
for(int i=0; i<h*2; i++){
for(int j=0; j<w; j++){
cout<<d[i][j];
if(j==w-1){
cout<<endl;
}
}
}
} | 0 | 10,379,360 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long int ll;
typedef unsigned long long int sll;
typedef double ld;
#define A 1000000007ll
#define D 1000000000ll
#define B 998244353ll
#define C 1000000000000000000ll
#define FAST ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define oset tree<pair<ll,ll>, null_type,less<pair<ll,ll>>, rb_tree_tag,tree_order_statistics_node_update>
#define pb push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define mxe(v) *max_element(v.begin(),v.end())
#define mne(v) *min_element(v.begin(),v.end())
#define bs binary_search
#define lb lower_bound
#define ub upper_bound
#define ve vector
#define br break
#define PI 3.14159265358979323
#define subt cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC << "ms\n"
ll dp[305][305];
int main()
{
FAST;
ll n,k;
cin>>n>>k;
ll a[n+1];
a[0]=0;
for(int i=1;i<=n;i++)
cin>>a[i];
for(int i=0;i<305;i++)
for(int j=0;j<305;j++)
dp[i][j]=C;
dp[0][0]=0;
dp[1][0]=a[1];
for(int i=2;i<=n;i++)
for(int j=0;j<i;j++)
for(int p=i-1;p>=i-j-1;p--)
if(dp[p][p-i+1+j]!=C)
dp[i][j]=min(dp[i][j],dp[p][p-i+1+j]+max(0ll,a[i]-a[p]));
ll ans=C;
for(int i=n;i>=n-k;i--)
ans=min(ans,dp[i][k+i-n]);
cout<<ans;
subt;
return 0;
} | #include <iostream>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string.h>
#include <cstring>
#include <math.h>
#include <cmath>
#include <iomanip>
#include <set>
#include <vector>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <numeric>
#include <cassert>
using namespace std;
using ll = long long;
#define nl "\n"
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define trav(x) for(auto& i: x)
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int d;
cin >> d;
for(int i = 25; i >= d; i--) {
if(i == 25) {
cout << "Christmas" << ' ';
} else {
cout << "Eve" << ' ';
}
}
} | 0 | 29,062,518 |
#include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)n; ++i)
#define repr(i, n) for (ll i = n - 1; i >= 0; --i)
#define INF 10e8
#define MOD 1000000000 + 7
#define MAX 51000
#define all(x) (x).begin(), (x).end()
#define MX(x) *max_element(all(x))
#define MN(x) *min_element(all(x))
using namespace std;
void solve(void)
{
int n;
cin >> n;
vector<int> tmp;
rep(i, n) tmp.push_back(i + 1);
vector<int> A(n), B(n);
rep(i, n) cin >> A[i];
rep(i, n) cin >> B[i];
int a, b, cta = 1;
do
{
if (tmp == A)
a = cta;
if (tmp == B)
b = cta;
cta++;
} while (next_permutation(all(tmp)));
cout << abs(a - b) << endl;
}
int main(void)
{
solve();
} | #include<cstdio>
#include<iostream>
using namespace std;
int main(){
for(int i=1; i<10; i++){
for(int j=1; j<10; j++){
cout << i << 'x' << j << '=' << i*j << "\n";
}
}
} | 0 | 16,495,904 |
#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 a, b, x;
cin >> a >> b >> x;
if (x >= a && x <= a + b) cout << "YES" << endl;
else cout << "NO" << endl;
return 0;
} | #include <iostream>
#include <cstdio>
#include <vector>
#include <iomanip>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <map>
#include <set>
#include <cmath>
using namespace std;
using VI = vector <int>;
using VVI = vector <VI>;
int main() {
int N;
int K;
cin >> N >> K;
vector <int> intensity(N);
for (int i = 0; i < N; ++i) {
cin >> intensity[i];
}
int nowTurn = 0;
while (nowTurn < K) {
vector <int> newIntensity(N);
vector <int> intAcc(N+1);
for (int i = 0; i < N; ++i) {
int minInt = max(0, i - intensity[i]);
int maxInt = min(N, i + intensity[i] + 1);
++intAcc[minInt];
--intAcc[maxInt];
}
int now = 0;
bool converged = true;
for (int i = 0; i < N; ++i) {
now += intAcc[i];
newIntensity[i] = now;
if (newIntensity[i] != N) {
converged = false;
}
}
++nowTurn;
intensity = newIntensity;
if (converged) {
break;
}
}
for (int i = 0; i < N; ++i) {
if (i) {
cout << " ";
}
cout << intensity[i];
}
cout << endl;
return 0;
} | 0 | 56,275,977 |
#include<bits/stdc++.h>
#define ll long long int
#define pb push_back
#define mk make_pair
#define all(v) v.begin(),v.end()
#define fi first
#define se second
#define vl vector<long long int>
#define vvl vector<vector<ll> >
#define fo(i,a,b) for(int i=a;i<b;i++)
#define rof(i,a,b) for(int i=b;i>=a;i--)
using namespace std;
ll mod=1000000007;
int main()
{
ll n,k;cin>>n>>k;
ll h[n];
fo(i,0,n) cin>>h[i];
ll dp[n+1];
memset(dp,0,sizeof(dp));
dp[0]=0;
for(ll i=1;i<n;i++)
{
dp[i]=1e9+7;
for(ll j=i-1;j>=i-k&&j>=0;j--)
{
dp[i] = min(dp[i],abs(h[i]-h[j])+dp[j]);
}
}
cout << dp[n-1];
} | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <fstream>
#include <numeric>
using namespace std;
typedef long long int ll;
#define EPS (1e-7)
#define INF 1e18
#define max(p,q)((p)>(q)?(p):(q))
#define min(p,q)((p)<(q)?(p):(q))
#define PI (acos(-1))
#define REP(i, n) for(int i = 0; i < (int)(n); i++)
#define rep(i, init, n) for(int i = init; i <(int)(n); i++)
int main() {
ll N;
cin >> N;
vector<ll> A(N);
REP(i, N) cin >> A[i];
vector<ll> B(N);
bool f = (N % 2 == 0) ? true: false;
REP(i, N / 2) B[i] = A[N - 1 - 2 * i];
if (!f) {
B[N / 2] = A[0];
rep(i, 0, N / 2) B[N / 2 + 1 + i] = A[2 * i + 1];
}else{
rep(i, 0, N / 2) B[N / 2 + i] = A[2 * i];
}
REP(i, N) cout << B[i] << " ";
cout << endl;
return 0;
} | 0 | 21,264,784 |
#include<iostream>
using namespace std;
int main(){
int a,b=1;
do{
cin >> a;
if(a!=0){
cout << "Case" << " "<< b <<": "<< a<<"\n";
}
b++;
}while(a!=0);
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int dp[100005][3];
int main(){
int n;
cin>>n;
int v[n][3];
for(int i=0; i<n; i++){
for(int j=0; j<3; j++)
cin>>v[i][j];
}
dp[0][0] = v[0][0];
dp[0][1] = v[0][1];
dp[0][2] = v[0][2];
for(int i=1; i<n; i++){
for(int j=0; j<3; j++){
int x = INT_MIN;
for(int k=0; k<3; k++){
if(j!=k){
dp[i][j] = max((dp[i-1][k])+v[i][j],x);
x = dp[i][j];
}
}
}
}
cout<<max(dp[n-1][0],max(dp[n-1][1],dp[n-1][2]))<<endl;
} | 0 | 71,356,923 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = 1e9;
const ll LINF = ll(1e18);
const int MOD = 1000000007;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1}, Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()
#define debug(v) \
cout << #v << ":"; \
for (auto x : v) \
{ \
cout << x << ' '; \
} \
cout << endl;
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; }
ll n, m;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int a,b,c;
cin>>a>>b>>c;
set<int>s;
s.insert(a);
s.insert(b);
s.insert(c);
cout<<s.size()<<"\n";
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define all(x) (x).begin(),(x).end()
#define SZ(x) ((int)(x).size())
#define bit(n) (1<<(n))
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<bool> vb;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
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;}
ll gcd(ll a, ll b) { return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) { return a/gcd(a,b)*b;}
int const INF = 1001001001;
int main()
{
int n,m,R;
cin >> n >> m >> R;
vi r(R);
rep(i,R) {
cin >> r[i];
r[i]--;
}
sort(all(r));
vvi dist(n,vi(n,INF));
rep(i,n) dist[i][i] = 0;
rep(i,m) {
int a,b,c;
cin >> a >> b >> c;
a--; b--;
dist[a][b] = c;
dist[b][a] = c;
}
rep(k,n) {
rep(i,n) {
rep(j,n) {
chmin(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
int res = INF;
do {
int sum = 0;
rep(i,R-1) {
sum += dist[r[i]][r[i+1]];
}
chmin(res, sum);
} while(next_permutation(all(r)));
cout << res << endl;
return 0;
} | 0 | 53,436,752 |
#include <iostream>
using namespace std;
typedef long long ll;
ll a,b,c;
int main(void){
cin>>a>>b>>c;
for(int i=0;i<c;i++){
if(i%2==0){
if(a%2==1)a--;
b+=a/2;
a-=a/2;
}
else{
if(b%2==1)b--;
a+=b/2;
b-=b/2;
}
}
cout<<a<<" "<<b<<endl;
} | #include<iostream>
#include<iomanip>
#include<algorithm>
#include<vector>
#include<tuple>
#include<map>
#include<queue>
#include<stack>
#include<deque>
#include<bitset>
#include<math.h>
using namespace std;
int main(){
int n,k;
cin >> n >> k;
int c[n][1];
for(int i=0;i<n;i++){
c[i][0]=0;
}
int a[k][n];
for(int i=0;i<k;i++){
int d;
cin >> d;
for(int j=0;j<d;j++){
cin >> a[i][j];
for(int k=0;k<n;k++){
if(k+1==a[i][j]) c[k][0]++;
}
}
}
int counter=0;
for(int i=0;i<n;i++){
if(c[i][0]==0) counter++;
}
cout << counter << endl;
} | 0 | 57,738,776 |
#include <bits/stdc++.h>
using namespace std;
using P = pair<int,int>;
int main(){
int N, K;
cin >> N >> K;
if(K > (N-1)*(N-2)/2){
cout << -1 << endl;
}
else{
vector<P> vec(0);
for(int i=1; i<N; i++){
P p = {1,i+1};
vec.push_back(p);
}
int cnt = (N-1)*(N-2)/2;
bool end = false;
for(int i=1; i<N; i++){
for(int j=i+1; j<N; j++){
if(cnt == K){
end = true;
break;
}
P p = {i+1,j+1};
vec.push_back(p);
cnt--;
}
if(end){
break;
}
}
cout << vec.size() << endl;
for(int i=0; i<vec.size(); i++){
cout << vec[i].first << " " << vec[i].second << endl;
}
}
} | #include <stdio.h>
#include <string.h>
#include <iostream>
#include <vector>
#include <bitset>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
int main() {
string s;
cin >> s;
vector<int> x(4);
rep(i, 4) {
x[i] = s[i] - '0';
}
string ans;
rep(j, 8) {
bitset<3> bits(j);
int sum = x[0];
for (int i = 1; i < 4; i++) {
if (bits[i - 1])sum += x[i];
else sum -= x[i];
}
if (sum == 7) {
ans = to_string(x[0]);
for (int i = 1; i < 4; i++) {
if (bits[i - 1])ans += '+';
else ans += '-';
ans += to_string(x[i]);
}
ans += "=7\n";
break;
}
}
cout << ans;
return 0;
} | 0 | 41,255,389 |
#include<iostream>
#include<vector>
using namespace std;
vector<int> u[10010];
int n,m,t[10010],d[10010];
void dfs(int p){
cout<<p<<"\n";
for(int i=0;i<u[p].size();i++){
d[u[p][i]]++;
if(d[u[p][i]]==t[u[p][i]]){
dfs(u[p][i]);
d[u[p][i]]=1008610086;
}
}
}
int main(){
cin>>n>>m;
for(int i=0;i<m;i++){
int a,b;
cin>>a>>b;
u[a].push_back(b);
t[b]++;
}
for(int i=0;i<n;i++) if(t[i]==0) dfs(i);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define rep(i, n) FOR(i, 0, n)
#define whole(x) (x).begin(),(x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
using P = pair<int, int>;
#define debug(var) cerr << "[" << #var << "] " << var << endl
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
const ll mod = 1000000007;
const int dx[] = {-1,0,1,0};
const int dy[] = {0,-1,0,1};
int main(){
int n, k;
cin >> n >> k;
vector<int> v(n);
rep(i, n) cin >> v[i];
int ans = 0;
for (int l=0; l<=k; l++) {
for (int r=0; r<=k-l; r++) {
if (l+r>n) continue;
int x = k-l-r;
int score = 0;
vector<int> now;
rep(i, l) {
score += v[i];
now.push_back(v[i]);
}
rep(i, r) {
score += v[n-1-i];
now.push_back(v[n-1-i]);
}
sort(whole(now));
auto it = lower_bound(whole(now), 0);
int numit = it - now.begin();
x = min(x, numit);
rep(i, x) {
score -= now[i];
}
chmax(ans, score);
}
}
cout << ans << endl;
return 0;
} | 0 | 100,604,966 |
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
constexpr char ln = '\n';
constexpr long long MOD = 1000000007LL;
constexpr long long INF = 1000000009LL;
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int i=0;i<(n);i++)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
using pos = pair<pair<int, int>, int>;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main(){
int H, W; cin >> H >> W;
vector<vector<char>> grid(H+2, vector<char>(W+2, '#'));
int cnt = 0; queue<pos> que;
for(int i=1; i<=H; i++){
string s; cin >> s;
for(int j=1; j<=W; j++){
grid[i][j] = s[j-1];
if(grid[i][j] == '#'){
pos p{{i, j}, 0};
que.push(p);
cnt++;
}
}
}
int res = 0;
while(cnt < H*W){
pos p = que.front(); que.pop();
int y = p.first.first, x = p.first.second, cost = p.second;
rep(i, 4){
int ny = y + dy[i], nx = x + dx[i];
if(grid[ny][nx] == '#')continue;
pos np = {{ny, nx}, cost+1};
que.push(np);
grid[ny][nx] = '#';
res = cost + 1;
cnt++;
}
}
cout << res << ln;
} | #include <bits/stdc++.h>
using namespace std;
int main(void){
int K;
string S;
cin >> K >> S;
if(K >= S.size()) {
cout << S << endl;
}
else {
for (int i=0;i<K;i++) {
cout << S[i];
}
cout << "..." << endl;
}
} | 0 | 25,617,013 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int num = K;
for (int i = 0; i < N - 1; i++) num *= K - 1;
cout << num << endl;
} | #include <bits/stdc++.h>
#include <boost/range/adaptors.hpp>
#include <boost/range/irange.hpp>
using namespace std;
using namespace boost;
using namespace boost::adaptors;
int main() {
int64_t n, m;
cin >> n >> m;
unordered_map<int64_t, int64_t> nums;
++nums[0];
int64_t ans = 0, s = 0;
for (auto _ : irange(0L, n)) {
int64_t a;
cin >> a;
s += a;
ans += nums[s % m]++;
}
cout << ans << endl;
} | 0 | 66,084,925 |
#include <bits/stdc++.h>
#pragma region Macro
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define SORT(v) sort(v.begin(), v.end())
#define pb(a) push_back(a)
#define eb(a) emplace_back(a)
#define vi vector<int>
#define vvi vector<vector<int>>
#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;
#pragma endregion
void solve(){
#define int ll
int n, x, t;
cin >> n >> x >> t;
cout << t*((n+x-1)/x) <<endl;
}
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int T[100000];
int main() {
int N, C, K;
cin >> N >> C >> K;
for (int i=0; i<N; i++) {
cin >> T[i];
}
sort(T, T+N);
queue<int> q;
for (int i=0; i<N; i++) {
q.push(T[i]);
}
int cnt = 0;
while(! q.empty()) {
cnt++;
int c = 1;
int t = q.front() + K;
q.pop();
while(! q.empty()) {
if (c == C) break;
if (q.front() > t) break;
c++;
q.pop();
}
}
int ans = cnt;
cout << ans << endl;
return 0;
} | 0 | 41,300,622 |
#include<cstdio>
#include<iostream>
using namespace std;
int main()
{
int i,j,n,s=0,t=0;
for(i=1;i<=4;i++)
{
cin>>n;
s+=n;
}
for(i=1;i<=4;i++)
{
cin>>n;
t+=n;
}
if(s>=t)cout<<s<<endl;
else cout<<t<<endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
#define all2(a, b) (a).begin(), (a).begin() + (b)
#define debug(vari) cerr << #vari << " = " << (vari) << endl;
const int MOD = 1e9 + 7;
int main()
{
int n, a, b;
cin >> n >> a >> b;
int ans = 0;
int tmp, cnt;
rep2(i, 1, n + 1)
{
cnt = 0;
tmp = i;
while (tmp)
{
cnt += tmp % 10;
tmp /= 10;
}
if (a <= cnt && cnt <= b)
{
ans += i;
}
}
cout << ans << endl;
return (0);
} | 0 | 1,228,360 |
#include<bits/stdc++.h>
using namespace std;
int main(){
vector<int> s={1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
int k;
cin >> k;
cout << s.at(k-1) <<endl;
return 0;
} | #include <algorithm>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <time.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <numeric>
#include <limits>
#include <type_traits>
#include <locale>
#include <omp.h>
using namespace std;
#define SAY_YES cout << "YES" << endl;
#define SAY_Yes cout << "Yes" << endl;
#define SAY_NO cout << "NO" << endl;
#define SAY_No cout << "No" << endl;
#define IFYES(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "YES" << endl; \
} \
else \
{ \
cout << "NO" << endl; \
}
#define IFYes(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "Yes" << endl; \
} \
else \
{ \
cout << "No" << endl; \
}
#define IFyes(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "yes" << endl; \
} \
else \
{ \
cout << "no" << endl; \
}
#define DEBUG_OUTPUT_ARRAY(XXX, ONE) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << "DEBUG: i = " << i << " -> " << XXX[i] << endl; \
}
#define DEBUG_OUTPUT_ARRAY2(XXX, ONE, TWO) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << "<<< i = " << i << " >>>" << endl; \
for (int j = 0; j < (TWO); j++) \
{ \
cout << "DEBUG: j = " << j << " -> " << XXX[i][j] << endl; \
} \
}
#define DEBUG_OUTPUT_ARRAY2_BOX(XXX, ONE, TWO) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << i << " "; \
for (int j = 0; j < (TWO); j++) \
{ \
cout << XXX[i][j] << " "; \
} \
cout << endl; \
}
typedef pair<long long int, long long int> pll;
typedef pair<long long int, pll> lpll;
const long long int mod = 1000000007;
const long long int INF = 1e18;
const long double PI=3.14159265358979323;
long long int N,X,T,x[200200],t[200200],res=0,four=0,two=0,one=0;
int main(){
cout << fixed << setprecision(18);
cin>>N;
for(long long int i = 0; i < N; i++){
cin>>x[i];
}
for(long long int i = 0; i < N; i++){
res=gcd(res,x[i]);
}
cout<<res<<endl;
} | 0 | 92,669,961 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using si = set<int>;
using ii = pair<int, int>;
using vii = vector<ii>;
#define fastio ios::sync_with_stdio(0); cin.tie(0)
#define rep(i, n) for (int i = 0; i < n; i++)
#define dotc() int tcs; if (cin >> tcs) rep(tc, tcs)
#define sz(x) (int)x.size()
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define fi first
#define se second
int inf(0x3fffffff);
int mod(1000000007);
double pi(acos(-1.0));
int32_t main() {
fastio;
#ifdef LOCAL
freopen("io\\in.txt", "r", stdin);
freopen("io\\out.txt", "w", stdout);
#endif
ll n;
cin >> n;
int cnt = 0;
for (int i = 2; 1ll * i * i <= n; i++) {
int c = 0;
while (n % i == 0) {
c++;
n /= i;
}
for (int j = 1; c - j >= 0; j++) cnt++, c -= j;
}
if (n != 1) cnt++;
cout << cnt;
return 0;
} | #include "bits/stdc++.h"
typedef long long ll;
#define int ll
#define fi first
#define se second
#define SORT(a) sort(a.begin(),a.end())
#define rep(i,n) for(int i = 0;i < (n) ; i++)
#define REP(i,n) for(int i = 0;i < (n) ; i++)
#define MP(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define INF LLONG_MAX/2
#define all(x) (x).begin(),(x).end()
#define debug(x) cerr<<#x<<": "<<x<<endl
#define debug_vec(v) cerr<<#v<<":";rep(i,v.size())cerr<<" "<<v[i];cerr<<endl
using namespace std;
int MOD = 1000000007;
int n;
int a[101];
signed main(){
cin >> n;
int mini = 110;
int maxi = -1;
rep(i,n){
int val;
cin >> val;
a[val]++;
mini = min(mini,val);
maxi = max(maxi,val);
}
if(a[mini] == 1){
if(maxi != mini*2){
cout << "Impossible" << endl;
return 0;
}
for(int i = mini+1;i <= maxi;i++){
if(a[i] < 2){
cout << "Impossible" << endl;
return 0;
}
}
cout << "Possible" << endl;
}else if(a[mini] == 2){
if(maxi != mini*2-1){
cout << "Impossible" << endl;
return 0;
}
for(int i = mini+1;i <= maxi;i++){
if(a[i] < 2){
cout << "Impossible" << endl;
return 0;
}
}
cout << "Possible" << endl;
}else{
cout << "Impossible" << endl;
}
return 0;
} | 0 | 92,419,316 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
int main() {
ll N;
cin >> N;
vector<ll> a(N);
rep(i, N) cin >> a[i];
ll hi = 1e18, lo = -1;
while (lo + 1 < hi) {
ll mi = (lo + hi) / 2, s = 0;
rep(i, N) {
s += (a[i] + mi + 1) / (N + 1);
}
if (s <= mi) hi = mi;
else lo = mi;
}
for (ll i = max(0LL, hi - 100000); i <= hi; i++) {
ll s = 0;
rep(j, N) {
s += (a[j] + i + 1) / (N + 1);
}
if (s <= i) {
cout << i << "\n";
return 0;
}
}
} | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define ull unsigned long long
#define ld long double
#define vi vector<int>
#define vll vector<ll>
#define vc vector<char>
#define vs vector<string>
#define vpii vector<pii>
#define vpll vector<pll>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define repr(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rep1r(i, n) for (int i = ((int)(n)); i >= 1; i--)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define RSORT(x) sort(rall(x));
#define pb push_back
#define mp make_pair
#define INF (1e9)
#define PI (acos(-1))
#define EPS (1e-7)
ull gcd(ull a, ull b) { return b ? gcd(b, a % b) : a; }
ull lcm(ull a, ull b) { return a / gcd(a, b) * b; }
ll dfs(int n, ll x) {
if (n == 0) return 1LL;
ll res = 0;
ll len = (1LL<<(n+2)) - 3, hnum = (1LL<<n) - 1;
if (x >= len-1) res += hnum * 2 + 1;
else if (x >= (len-3)/2+3) {
res += hnum + 1;
res += dfs(n-1, x-1-(len-3)/2-1);
}
else if (x >= (len-3)/2+2) res += hnum + 1;
else if (x >= (len-3)/2+1) res += hnum;
else if (x >= 2) res += dfs(n-1, x-1);
return res;
}
int main(){
int n;
ll x;
cin >> n >> x;
cout << dfs(n, x) << endl;
return 0;
} | 0 | 19,301,585 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1e18;
const ll mod = 1000000007;
#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;
}
int ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
ll factorial(ll n) {
if (n == 1) {
return 1;
}
ll ans = factorial(n-1);
return ans*n;
}
ll gcd(ll a, ll b) {
if (a < b) {
ll tmp = a;
a = b;
b = tmp;
}
ll r = a%b;
while(r != 0) {
a = b;
b = r;
r = a%b;
}
return b;
}
ll lcm(ll a, ll b) {
return (a/gcd(a, b))*b;
}
int main() {
ll n, m;
cin >> n >> m;
cout << n*m - (n+m-1) << endl;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
long long MOD = 1000000000 + 7;
int main(){
cout << setprecision(10);
int K; cin >> K;
queue<string> q;
for(int i = 1; i <= 9; i++){
q.push(to_string(i));
}
int num = 0;
while(true){
string now = q.front();
q.pop();
num++;
if(num == K){
cout << now << endl;
break;
}
int last_num = now[now.size()-1] - '0';
if(last_num > 0){
q.push(now + to_string(last_num-1));
}
q.push(now + to_string(last_num));
if(last_num < 9){
q.push(now + to_string(last_num+1));
}
}
} | 0 | 38,291,625 |
#include<iostream>
#include<cstdlib>
#include<utility>
#include<tuple>
#include<string>
#include<vector>
#include<numeric>
#include<algorithm>
#include<queue>
#include<deque>
#include<bitset>
#include<cmath>
#include<map>
#include<iomanip>
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
#define rep(i, a, b) for(ll i = a; i < b; i++)
int main() {
int h, w;
cin >> h >> w;
vector<vector<char>> a(h, vector<char>(w));
rep(i, 0, h) {
rep(j, 0, w) cin >> a[i][j];
}
vector<int> s(100, 0), v(100, 0);
rep(i, 0, h) {
int j = 0;
while (a[i][j] == '.') {
if (j == w - 1) {
s[i] = 1;
break;
}
j++;
}
}
rep(i, 0, w) {
int j = 0;
if (w != 1) {
while (a[j][i] == '.') {
if (j == h - 1) {
v[i] = 1;
break;
}
j++;
}
}
}
rep(i, 0, h) {
if (s[i] != 1) {
rep(j, 0, w) {
if (v[j] != 1) cout << a[i][j];
}
cout << endl;
}
}
} | #include <bits/stdc++.h>
#define F first
#define S second
#define MP make_pair
#define pb push_back
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define LCM(a, b) (a) / __gcd((a), (b)) * (b)
#define CEIL(a, b) (a)/(b)+(((a)%(b))?1:0)
#define ln '\n'
using namespace std;
using LL = long long;
using ldouble = long double;
using P = pair<int, int>;
using LP = pair<LL, LL>;
static const int INF = INT_MAX;
static const LL LINF = LLONG_MAX;
static const int MIN = INT_MIN;
static const LL LMIN = LLONG_MIN;
static const int MOD = 1e9 + 7;
static const int SIZE = 200005;
const int dx[] = {0, -1, 1, 0};
const int dy[] = {-1, 0, 0, 1};
vector<LL> Div(LL n) {
vector<LL> ret;
for(LL i = 1; i * i <= n; ++i) {
if(n % i == 0) {
ret.pb(i);
if(i * i != n) ret.pb(n / i);
}
}
sort(all(ret));
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int s = 0;
for(int i = 0; i < n; ++i) {
int l, r;
cin >> l >> r;
s += r - l + 1;
}
cout << s << endl;
return 0;
} | 0 | 55,908,520 |
#include<iostream>
#include<iomanip>
#include<cmath>
using namespace std;
const double pi = 3.141592653589793;
struct Cordinate{
double x;
double y;
};
void kock( int n, Cordinate p1, Cordinate p2 ){
if( n==0 ){
return;
}
Cordinate s, t, u;
s.x = (2*p1.x+1*p2.x)/3;
s.y = (2*p1.y+1*p2.y)/3;
t.x = (1*p1.x+2*p2.x)/3;
t.y = (1*p1.y+2*p2.y)/3;
u.x = (t.x-s.x)*cos(pi/3)-(t.y-s.y)*sin(pi/3)+s.x;
u.y = (t.x-s.x)*sin(pi/3)+(t.y-s.y)*cos(pi/3)+s.y;
kock( n-1, p1, s );
cout << fixed << setprecision(8) << s.x << " " << setprecision(8) << s.y << endl;
kock( n-1, s, u );
cout << fixed << setprecision(8) << u.x << " " << setprecision(8) << u.y << endl;
kock( n-1, u, t );
cout << fixed << setprecision(8) << t.x << " " << setprecision(8) << t.y << endl;
kock( n-1, t, p2 );
}
int main(){
int n;
cin >> n;
Cordinate p1, p2;
p1.x = 0, p1.y = 0;
p2.x = 100, p2.y = 0;
cout << fixed << setprecision(8) << p1.x << " " << setprecision(8) << p1.y << endl;
kock( n, p1, p2 );
cout << fixed << setprecision(8) << p2.x << " " << setprecision(8) << p2.y << endl;
return 0;
} | #include<bits/stdc++.h>
#define FAST ios_base::sync_with_stdio(false);cin.tie();cout.tie();
#define FILE_READ_IN freopen("input.txt","r",stdin);
#define FILE_READ_OUT freopen("output.txt","w",stdout);
using namespace std;
typedef long long ll;
int main(){
#ifndef ONLINE_JUDGE
FILE_READ_IN
FILE_READ_OUT
#endif
int n; cin>>n;
int k; cin>>k;
int x; cin>>x;
int y; cin>>y;
if(k>=n)
{
cout<<x*n<<"\n";
}
else{
cout<<(x*k+(n-k)*y)<<"\n";
}
return 0;
} | 0 | 94,672,982 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repo(i,n) for(int i = 1; i < (int)(n); i++)
#define pb push_back
#define mp make_pair
#define np next_permutation
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define all(x) (x).begin(),(x).end()
#define mod 1000000007
#define pi acos(-1.0)
const ll INF = 1LL<<61;
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 x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll jou(ll N, ll P){if(P==0) return 1;
if(P%2==0){ll t = jou(N, P/2);return t*t % mod;
}return (N * jou(N, P-1)) % mod;}
int main() {
int n,m;
cin>>n>>m;
vector<int> p={2,5,5,4,5,6,3,7,6};
vector<bool> q(9,false);
rep(i,m){
int x;
cin>>x;
q[x-1]=true;
}
vector<ll> keta(n+10,-1);
keta[0]=0;
rep(i,n){
if(keta[i]==-1) continue;
rep(j,9){
if(q[j]) chmax(keta[i+p[j]],keta[i]+1);
}
}
vector<int> ans;
int now=n;
while(now>0){
for(int i=8;i>=0;i--){
if(!q[i]) continue;
if(now-p[i]>=0 && keta[now]==keta[now-p[i]]+1) {
now-=p[i];
ans.pb(i+1);
break;
}
}
}
rep(i,ans.size()){
cout << ans[i];
}
cout << endl;
} | #include<bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
int arr[205][205];
int main(){
int n,m,r;
cin>>n>>m>>r;
for(int i=1; i<=n; i++){
for(int j=1; j<=n; j++) arr[i][j] = INF;
}
vector<int>town(r);
for(int i=0; i<r; i++) cin>>town[i];
sort(town.begin(),town.end());
while(m--){
int a,b,c;
cin>>a>>b>>c;
arr[a][b] = min(arr[a][b],c);
arr[b][a] = min(arr[b][a],c);
}
for(int k=1; k<=n; k++){
for(int i=1; i<=n; i++){
for(int j=1; j<=n; j++){
arr[i][j] = min(arr[i][j],arr[i][k]+arr[k][j]);
}
}
}
int mindist = numeric_limits<int>::max();
do{
int dist = 0;
for(int i=1; i<r; i++) dist+=arr[town[i-1]][town[i]];
mindist = min(mindist,dist);
}while(next_permutation(town.begin(),town.end()));
cout<<mindist;
} | 0 | 16,482,880 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int n;
cin >> n;
vector<int> a(n), b(n);
long long suma = 0, sumb = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
suma += a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
sumb += b[i];
}
if (sumb > suma) {
cout << -1 << endl;
return 0;
}
vector<long long> diff;
for (int i = 0; i < n; i++) {
if (a[i] >= b[i]) {
diff.emplace_back(a[i] - b[i]);
}
}
sort(diff.rbegin(), diff.rend());
for (int i = 1; i < diff.size(); i++) {
diff[i] += diff[i - 1];
}
int ans = 0;
long long sum = 0;
for (int i = 0; i < n; i++) {
if (a[i] < b[i]) {
sum += b[i] - a[i];
ans++;
}
}
if (sum != 0) {
for (int i = 0; i < diff.size(); i++) {
if (sum <= diff[i]) {
ans += i + 1;
break;
}
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void){
string S;
cin>>S;
int count=0;
for(int i=1;i<3;i++){
if(S[i]==S[i-1]){
count++;
}
}
if(count==2){
cout<<"No"<<endl;
return 0;
}
else{
cout<<"Yes"<<endl;
}
return 0;
} | 0 | 33,007,397 |
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#include <random>
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()
const int NOT_DEFINED = -111;
class Tree {
int n;
vector<vector<int>> adjlist;
vector<vector<int>> inv_adjlist;
vector<int> depthList;
public:
Tree(int num);
int getParent(int id);
void addNode(int parentId, int childId);
int getDepth(int id);
string getType(int id);
vector<int> getChild(int id);
};
Tree::Tree(int num) {
n = num;
REP(i,num) {
vector<int> v;
adjlist.push_back(v);
inv_adjlist.push_back(v);
depthList.push_back(NOT_DEFINED);
}
}
void Tree::addNode(int parentId, int childId) {
adjlist[parentId].push_back(childId);
inv_adjlist[childId].push_back(parentId);
}
int Tree::getParent(int id) {
vector<int> parent = inv_adjlist[id];
if (parent.size()) return parent[0];
return -1;
}
int Tree::getDepth(int id) {
int depth = 0;
vector<int> parent = inv_adjlist[id];
while(parent.size()) {
if (depthList[parent[0]] != NOT_DEFINED) {
depth += depthList[parent[0]] + 1;
break;
}
parent = inv_adjlist[parent[0]];
depth++;
}
depthList[id] = depth;
return depth;
}
string Tree::getType(int id) {
if (depthList[id] == 0) {
return "root";
}else if (adjlist[id].empty()) {
return "leaf";
}else {
return "internal node";
}
return "";
}
vector<int> Tree::getChild(int id) {
return adjlist[id];
}
int main() {
int n;
cin >> n;
Tree tree = Tree(n);
REP(i,n) {
int id, deg;
cin >> id >> deg;
int k;
REP(j,deg) {
cin >> k;
tree.addNode(id, k);
}
}
REP(i,n) {
vector<int> children = tree.getChild(i);
cout << "node " << i << ": parent = ";
cout << tree.getParent(i) << ", depth = ";
cout << tree.getDepth(i) << ", ";
cout << tree.getType(i) << ", [";
REP(j,children.size()) {
cout << children[j];
if (j < children.size()-1) {
cout << ", ";
}
}
cout << "]" << endl;
}
return 0;
} | #include<iostream>
#include<vector>
#include<algorithm>
#include<iomanip>
#include<stack>
#include<queue>
#include<string>
#include<set>
#include<map>
using namespace std;
#define rep(i,n) for(int i=0;(i)<(n);(i)++)
#define FOR(i,m,n) for(int i=(m);(i)<(n);(i)++)
typedef long long ll;
int main(){
int m,nmin,nmax;
while(cin >> m >> nmin >> nmax,m|nmin|nmax){
vector<int> P(m);
rep(i,m)cin >> P[i];
sort(P.begin(),P.end());
reverse(P.begin(),P.end());
int res=0,gap_max=0;
for(int i=nmin;i<=nmax;i++){
int gap = P[i-1]-P[i];
if(gap>=gap_max){
res=i;
gap_max=gap;
}
}
cout << res << endl;
}
return 0;
} | 0 | 52,705,309 |
#include<iostream>
#include<iomanip>
#include<math.h>
#include<vector>
#include<string>
#include<stack>
#include<queue>
#include<map>
#include<algorithm>
#include<bitset>
#include <climits>
#include<set>
#include<bitset>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vl;
typedef pair<int, int> pi;
typedef vector<pair<int, int>> vpi;
#define itn int
#define endl '\n'
#define pb push_back
#define mp make_pair
#define ss second
#define ff first
#define dup(x,y) ((x) + (y) - 1)/(y)
#define mins(x,y) x = min(x,y)
#define maxs(x,y) x = max(x,y)
#define all(x) (x).begin(),(x).end()
#define Rep(n) for(int i = 0;i < n;i++)
#define rep(i,n) for(int i = 0;i < n;i++)
#define rrep(i,n) for(int i = n - 1;i >= 0;i--)
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() )
#define ioboost cin.tie(0);ios::sync_with_stdio(false)
ll gcd(ll a, ll b) { return b ? gcd(b, a%b) : a; }
ll qp(ll a, ll b) { ll ans = 1; do { if (b & 1)ans = 1ll * ans*a; a = 1ll * a*a; } while (b >>= 1); return ans; }
ll qp(ll a, ll b, int mo) { ll ans = 1; do { if (b & 1)ans = 1ll * ans*a%mo; a = 1ll * a*a%mo; } while (b >>= 1); return ans; }
#define _GLIBCXX_DEBUG
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
int main(void){
ioboost;
ll w,h;cin >> w >> h;
vector<pair<ll,ll>> r;
rep(i,w){
ll p;cin >> p;
r.pb(mp(p,0));
}
rep(i,h){
ll q;cin >> q;
r.pb(mp(q,1));
}
sort(all(r));
ll ans = 0;
ll a = w + 1;
ll b = h + 1;
for(auto i : r){
if(i.second){
ans += i.first * a;
b--;
}else{
ans += i.first * b;
a--;
}
}
cout << ans << endl;
} | #include <iostream>
using namespace std;
const int MOD = 1000000007;
int N;
int dig[60];
long long A[300100];
int main() {
cin >> N;
for (int i = 0; i < N; i++) cin >> A[i];
long long ans = 0, dig = 1;
for (int i = 0; i < 60; i++) {
long long zero = 0, one = 0;
for (int j = 0; j < N; j++) {
long long bit = A[j];
if ((bit >> i) & 1) one++;
else zero++;
}
ans += (zero * one % MOD) * dig % MOD;
ans %= MOD;
dig *= 2;
dig %= MOD;
}
cout << ans << endl;
} | 0 | 94,091,441 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(ll i = 0; i < (ll)(n); i++)
#define rep2(i, a, n) for(ll i = a; i < (ll)(n); i++)
#define memi cout << endl
#define kono(n) cout << fixed << setprecision(n)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define hina cout << ' '
#define in(n) cin >> n
#define in2(n, m) cin >> n >> m
#define in3(n, m, l) cin >> n >> m >> l
#define out(n) cout << n
const ll mei = (ll)1e9 + 7;
int main(){
string s;
in(s);
rep(i, s.size() - 1){
if(s[i] == s[i + 1]){
out(i + 1);
hina;
out(i + 2);
memi;
return 0;
}
}
rep(i, s.size() - 2){
if(s[i] == s[i + 2]){
out(i + 1);
hina;
out(i + 3);
memi;
return 0;
}
}
out(-1);
hina;
out(-1);
memi;
} | #include <bits/stdc++.h>
using namespace std ;
typedef long long ll;
typedef string str;
typedef vector<int> vint;
typedef vector<double> vdou ;
typedef vector<ll> vll;
typedef vector<vint> vvint;
typedef vector<str> vstr;
typedef pair<int, int> pii;
typedef vector<pii> vpii ;
#define REP(i, n) for (ll (i) = 0; (i) < (ll)(n); i++)
#define FOR(i, a, b) for(ll (i) = a; (i) < (ll)b; i++)
#define ALL(v) (v).begin(),(v).end()
#define MOD 1000000007
#define NIL -1
#define FI first
#define SE second
#define MP make_pair
#define PB push_back
#define SZ(x) (ll)x.size()
#define SP(x) setprecision((ll)x)
const int INF = 1e9;
const ll LINF = 1e18;
const double EPS = 1e-9;
const double PI = M_PI;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll gcd(ll a, ll b) {return b ? gcd(b, a % b) : a;}
ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
void yes(){
cout <<"Yes"<<endl ;
}
void no(){
cout <<"No"<<endl ;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
str s ;
cin >> s ;
vstr st ;
int n = SZ(s) ;
vint cnt(26,0);
if(s=="zyxwvutsrqponmlkjihgfedcba"){
cout << -1 <<endl ;
return 0 ;
}
REP(i,n){
cnt[s[i]-'a']++ ;
}
if(n<=25){
cout << s ;
REP(i,26){
if(cnt[i]==0){
cout << (char)(i+'a') <<endl ;
return 0 ;
}
}
}
else{
set<char> S ;
for(int i=n-1;i>=1;i--){
str hoge = s ;
S.insert(s[i]) ;
auto itr = S.begin() ;
hoge = s.substr(0,i-1) + (*itr) ;
if(s<hoge){
set<char> T ;
REP(j,SZ(hoge)){
T.insert(hoge[j]) ;
}
if(SZ(T)==SZ(hoge)){
st.PB(hoge) ;
}
}
hoge = s.substr(0,i-1) ;
REP(j,26){
hoge[SZ(hoge)-1] = (char)(hoge[SZ(hoge)-1]+1) ;
if(hoge[SZ(hoge)-1]-'a'<0 ||hoge[SZ(hoge)-1]-'a'>=26){
continue ; ;
}
if(s<hoge){
set<char> T ;
REP(j,SZ(hoge)){
T.insert(hoge[j]) ;
}
if(SZ(T)==SZ(hoge)){
st.PB(hoge) ;
}
}
}
}
}
sort(ALL(st)) ;
cout << st[0] <<endl ;
return 0 ;
} | 0 | 94,468,566 |
#include<bits/stdc++.h>
using namespace std;
#define INF 1000000007
#define LINF (1LL << 62)
#define PI 3.14159265358979
typedef long long i64;
typedef pair<i64,i64> P;
inline i64 mod(i64 a, i64 m) { return (a % m + m) % m; }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int n, a[101010];
void solve(){
cin >> n;
for(int i = 0; i < n; i++){
cin >> a[i];
}
sort(a,a+n,greater<int>());
i64 cnt = 0;
for(int i = 0; i < n; i++){
if(a[i] == a[i+1]){
if(cnt != 0){
cout << cnt*a[i] << endl;
return;
}
cnt = a[i];
i++;
}
}
cout << 0 << endl;
}
int main(){
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int t = 1;
while(t--){
solve();
}
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(){
ll n,m;
cin >> n >> m;
ll a,b;
vector <int> k(n);
rep(i,m){
cin >> a >> b;
++k[a-1];
++k[b-1];
}
rep(i,n){
if(k[i]%2==1){
cout << "NO" << endl;
break;
}
if(i==(n-1)){
cout << "YES" << endl;
}
}
return 0;
} | 0 | 20,163,390 |
#include <bits/stdc++.h>
using namespace std;
#define pr(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
#define all(v) (v).begin(), (v).end()
#define int long long
#define sz(v) (int)(v).size()
#define mod 1000000007
void solve() {
int n; cin >> n;
set<int> st;
for (int i= 0; i< n; i++) {
int x; cin>> x;
st.insert(x);
}
if (n== st.size()) {
cout << "YES";
} else cout << "NO";
}
int32_t main(){
ios::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
int T= 1;
while ( T-- ) {
solve();
}
return 0;
} | #include<iostream>
#include<cstdio>
using namespace std;
typedef long long ll;
const int maxn=1e5+100;
int a[maxn],b[maxn];
int fac[32];
int main()
{
int N,K;
scanf("%d%d",&N,&K);
ll res=0;
for(int i=0;i<N;i++){
scanf("%d%d",&a[i],&b[i]);
if((a[i]|K)==K) res+=b[i];
}
for(int i=0;i<=30;i++)
fac[i]=1<<i;
for(int i=1;i<=30;i++){
if(K&fac[i]){
ll cnt=0;
int tmp=(K^fac[i])|(fac[i]-1);
for(int j=0;j<N;j++)
if((a[j]|tmp)==tmp) cnt+=b[j];
res=max(res,cnt);
}
}
cout<<res<<endl;
} | 0 | 98,112,843 |
#include <bits/stdc++.h>
#include <numeric>
using namespace std;
#define ALL(v) v.begin(), v.end()
#define V vector
#define P pair
using ll = long long;
using ld = long double;
const int MOD = 1e9+7;
const ll INF = 1LL << 60;
int main() {
string s; cin >> s;
int n = s.size();
V<int> a(n + 1);
for(int i = 0; i < n; i++){
if(s[i] == '<') a[i + 1] = max(a[i + 1], a[i] + 1);
}
for(int i = n - 1; i >= 0; i--){
if(s[i] == '>') a[i] = max(a[i], a[i + 1] + 1);
}
ll ans = 0;
for(int i = 0; i <= n; i++){
ans += a[i];
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
#define FOR(i, n, m) for (ll(i) = (m); (i) < (n); ++(i))
#define REP(i, n) FOR(i, n, 0)
#define OF64 std::setprecision(10)
const ll MOD = 1000000007;
const ll INF = (ll)1e15;
ll P[100005];
ll Q[100005];
int main()
{
int W, H;
cin >> W >> H;
REP(i, W)
{
cin >> P[i];
}
REP(i, H)
{
cin >> Q[i];
}
sort(P, P + W);
P[W] = INF;
sort(Q, Q + H);
Q[H] = INF;
int pi = 0, qi = 0;
ll sum = 0;
ll w = W, h = H;
while (pi < w || qi < h)
{
ll p = P[pi], q = Q[qi];
if (p < q)
{
W--;
pi++;
sum += p * (H + 1);
}
else
{
H--;
qi++;
sum += q * (W + 1);
}
}
cout << sum << endl;
return 0;
} | 0 | 66,613,113 |
#include <bits/stdc++.h>
using namespace std;
#define pi acos(-1)
#define IOS ios_base::sync_with_stdio(0); cin.tie(); cout.tie();
#define ff first
#define ss second
#define pb push_back
#define debug(val) cerr << "The Value Of " << #val << " is : " << val << '\n';
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
const ll mod = 1e9 + 7;
const ll inf = 0x3f3f3f3f;
const ll mininf = -922337203685477;
const ll nax = 1e5+5;
ll n, k, arr[nax];
int main(){
IOS
cin >> n >> k;
for(int i=0;i<n;i++){
cin >> arr[i];
}
n--, k--;
cout << ceil((double)n/k) << '\n';
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
string N;
ll K;
ll dp[105][2][4];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> K;
dp[0][0][0] = 1;
dp[0][0][1] = N[0] - '0' - 1;
dp[0][1][1] = 1;
for (ll i = 1; i < N.size(); i++) {
dp[i][0][0] += dp[i - 1][0][0];
dp[i][0][1] += dp[i - 1][0][0] * 9;
dp[i][0][1] += dp[i - 1][0][1];
dp[i][0][2] += dp[i - 1][0][1] * 9;
dp[i][0][2] += dp[i - 1][0][2];
dp[i][0][3] += dp[i - 1][0][2] * 9;
dp[i][0][3] += dp[i - 1][0][3];
if (N[i] == '0') {
dp[i][1][1] += dp[i - 1][1][1];
dp[i][1][2] += dp[i - 1][1][2];
dp[i][1][3] += dp[i - 1][1][3];
} else {
dp[i][1][2] += dp[i - 1][1][1];
dp[i][0][2] += dp[i - 1][1][1] * (N[i] - '0' - 1);
dp[i][0][1] += dp[i - 1][1][1];
dp[i][1][3] += dp[i - 1][1][2];
dp[i][0][3] += dp[i - 1][1][2] * (N[i] - '0' - 1);
dp[i][0][2] += dp[i - 1][1][2];
dp[i][0][3] += dp[i - 1][1][3];
}
}
ll ans = dp[N.size() - 1][0][K] + dp[N.size() - 1][1][K];
cout << ans << endl;
return 0;
} | 0 | 37,517,955 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
int n,tot=0,head[100001];
struct data {
int next,num;
}edge[200001];
void add(int u,int v) {
edge[++tot].next=head[u];
edge[tot].num=v;
head[u]=tot;
}
int dfs(int x,int fa) {
int ans=0;
for (int i=head[x];i!=-1;i=edge[i].next) {
int kx=edge[i].num;
if (kx==fa) continue;
ans^=dfs(kx,x)+1;
}
return ans;
}
int main() {
memset(head,-1,sizeof(head));
scanf("%d",&n);
for (int i=1;i<n;i++) {
int u,v;
scanf("%d%d",&u,&v);
add(u,v);
add(v,u);
}
int ans=dfs(1,-1);
if (ans) printf("Alice\n");
else printf("Bob\n");
return 0;
} | #include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
int main()
{
while (true) {
int n;
cin >> n;
if (n == 0) {
break;
}
vector<int> s(n);
for (int i = 0; i < n; i++) {
cin >> s[i];
}
sort(s.begin(), s.end());
int minv = numeric_limits<int>::max();
for (int i = 0; i < n - 1; i++) {
if (minv > s[i + 1] - s[i]) {
minv = s[i + 1] - s[i];
}
}
cout << minv << endl;
}
return 0;
} | 0 | 34,665,257 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int INF = (1<<30) - 1;
const ll LINF = (1LL<<60) - 1;
int n, q;
vector<vector<int>> G;
vector<int> cnt;
vector<int> res;
void dfs(int v, int p, int add = 0) {
res[v] = add + cnt[v];
for (auto nv : G[v]) {
if (nv == p) continue;
dfs(nv, v, add + cnt[v]);
}
}
int main(){
cin >> n >> q;
G.resize(n);
for (int i = 0; i < n-1; ++i) {
int a, b;
cin >> a >> b;
--a; --b;
G[a].push_back(b);
G[b].push_back(a);
}
cnt.assign(n, 0);
for (int i = 0; i < q; ++i) {
int p, x;
cin >> p >> x;
--p;
cnt[p] += x;
}
res.resize(n);
dfs(0, -1);
for (int i = 0; i < n; ++i) {
cout << res[i] << endl;
}
} | #include<bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0;i<(n);i++)
#define ALL(v) (v).begin(),(v),end()
#define pb push_back
typedef long long ll;
typedef pair<int,int> P;
template<typename A,typename B> inline void chmin(A &a,B b){if(a>b) a=b;}
template<typename A,typename B> inline void chmax(A &a,B b){if(a<b) a=b;}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n;
while(cin>>n,n)
{
int ans=0;
bool l=false,r=false,f=true;
REP(i,n){
string s; cin>>s;
if(s=="lu") l=true;
else if(s=="ru") r=true;
else if(s=="ld") l=false;
else r=false;
if(l==r && l==f){
ans++;
f=!f;
}
}
cout<<ans<<endl;
}
} | 0 | 76,415,436 |
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, n) for (int i = n - 1; i >= a; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
const vector<int> dx = {1, 0};
const vector<int> dy = {0, 1};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int h, w;
cin >> h >> w;
vector<string> v(h);
rep(i, 0, h) cin >> v[i];
vector<vector<int>> dp(h, vector<int>(w, 1e9));
if (v[0][0] == '#')
dp[0][0] = 1;
else
dp[0][0] = 0;
rep(i, 0, h) {
rep(j, 0, w) {
rep(k, 0, 2) {
int ni = i + dx[k], nj = j + dy[k];
if (ni >= h || nj >= w)
continue;
int add = 0;
if (v[ni][nj] == '#' && v[i][j] == '.')
add = 1;
chmin(dp[ni][nj], dp[i][j] + add);
}
}
}
cout << dp[h - 1][w - 1] << endl;
} | #include <bits/stdc++.h>
#include <stdio.h>
#include <iostream>
#include <cstdio>
#include <bitset>
#include <algorithm>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <string>
#include <string.h>
#include <cmath>
#include <utility>
#include <functional>
#include <map>
#include <set>
#include <cctype>
#include <fstream>
#include <numeric>
#include <iomanip>
#include <cstring>
using namespace std;
using ll = long long;
#define ALL(a) (a).begin(), (a).end()
#define FOR(i, a, b) for (long long int i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (long long int i = (a); i >= (b); i--)
#define MOD 1000000007
#define LLONG_MAXs 9223372036854775800 / 2
#define ALL(a) (a).begin(), (a).end()
#include <iostream>
#include <cmath>
using namespace std;
bool isPrimeNum(ll x)
{
if (x <= 1)
{
return false;
}
int n = (int)sqrt((double)x);
for (int i = 2; i <= n; i++)
{
if (x % i == 0)
{
return false;
}
}
return true;
}
ll myPow(ll x, ll n, ll 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;
}
constexpr ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
constexpr ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
constexpr ll abs(ll a, ll b)
{
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr double dabs(double a, double b)
{
if (a >= b)
return a - b;
if (a < b)
return b - a;
}
constexpr ll min(ll a, ll b)
{
if (a >= b)
return b;
if (a < b)
return a;
}
constexpr ll max(ll a, ll b)
{
if (a >= b)
return a;
if (a < b)
return b;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int dx8[8] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy8[8] = {0, 1, 0, -1, 1, 1, -1, -1};
class UnionFind
{
public:
vector<int> Parent;
UnionFind(int N)
{
Parent = vector<int>(N, -1);
}
int root(int A)
{
if (Parent[A] < 0)
return A;
return Parent[A] = root(Parent[A]);
}
int size(int A)
{
return -Parent[root(A)];
}
bool issame(int x, int y)
{
return root(x) == root(y);
}
bool connect(int A, int B)
{
A = root(A);
B = root(B);
if (A == B)
{
return false;
}
if (size(A) < size(B))
swap(A, B);
Parent[A] += Parent[B];
Parent[B] = A;
return true;
}
};
long long fac[510000], finv[510000], inv[510000];
void COMinit()
{
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < 510000; 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;
}
long long modinv(long long a, long long m)
{
long long b = m, u = 1, v = 0;
while (b)
{
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
string replaceAll(string &replacedStr, string from, string to)
{
unsigned int pos = replacedStr.find(from);
int toLen = to.length();
if (from.empty())
{
return replacedStr;
}
while ((pos = replacedStr.find(from, pos)) != std::string::npos)
{
replacedStr.replace(pos, from.length(), to);
pos += toLen;
}
return replacedStr;
}
void yn(bool flag)
{
if (flag)
{
cout << "Yes" << endl;
}
else
{
cout << "No" << endl;
}
return;
}
void YN(bool flag)
{
if (flag)
{
cout << "YES" << endl;
}
else
{
cout << "NO" << endl;
}
return;
}
std::vector<ll> enum_div(ll n)
{
std::vector<ll> ret;
for (ll i = 1; i * i <= n; ++i)
{
if (n % i == 0)
{
ret.push_back(i);
if (i != 1 && i * i != n)
{
ret.push_back(n / i);
}
}
}
ret.push_back(n);
return ret;
}
void Ssort(int no, char *month[])
{
int i, j;
char *temp;
for (i = 0; i < no; i++)
{
for (j = i + 1; j < no; j++)
{
if (strcmp((month[i]), (month[j])) > 0)
{
temp = *(month + i);
*(month + i) = *(month + j);
*(month + j) = temp;
}
}
}
}
struct Edge
{
ll to;
ll weight;
Edge(int t, int w) : to(t), weight(w) {}
};
using Graph = vector<vector<int>>;
int main()
{
ll N;
cin >> N;
char S[N][N];
char T[N][N];
ll ans = 0;
FOR(i, 0, N - 1)
{
FOR(j, 0, N - 1)
{
cin >> S[i][j];
}
}
FOR(k, 0, N - 1)
{
FOR(i, 0, N - 1)
{
FOR(j, 0, N - 1)
{
if (i + k < N)
{
T[i][j] = S[i + k][j];
}
else
{
T[i][j] = S[i + k - N][j];
}
}
}
ll f = true;
FOR(i, 0, N - 1)
{
FOR(j, 0, N - 1)
{
if (T[i][j] != T[j][i])
{
f = false;
}
}
}
if (f)
ans++;
}
cout << ans * N << endl;
return 0;
} | 0 | 54,263,690 |
#include <bits/stdc++.h>
#define int long long
#define x first
#define y second
#define getbit(x, i) (((x) >> (i)) & 1)
using namespace std;
typedef pair<int, int> pii;
#define hashset unordered_set
#define hashmap unordered_map
#define newline fast_writechar('\n')
#define unify(arr) arr.resize(unique(arr.begin(), arr.end()) - arr.begin())
#define getbit(x, i) (((x) >> (i)) & 1)
template <typename T>
vector<T> readvector(size_t sz) {
vector<T> res(sz);
for (size_t i = 0; i < sz; ++i) {
cin >> res[i];
}
return res;
}
template <typename T>
std::ostream &operator<<(std::ostream &out, const std::vector<T> &v) {
std::copy(v.begin(), v.end(), std::ostream_iterator<T>(out, " "));
return out;
}
int mylog(int n) {
return 63 - __builtin_clzll(n);
}
inline int binPow(int x, int deg, int mod) {
int ans = 1;
for (int i = sizeof(deg) * CHAR_BIT - 1; i >= 0; i--) {
ans *= ans;
ans %= mod;
if (getbit(deg, i)) ans *= x;
ans %= mod;
}
return ans;
}
inline int readInt();
inline int readUInt();
inline void readWord(char *s);
inline int fast_readchar();
inline void writeInt(int x);
inline void fast_writechar(int x);
inline void writeWord(const char *s);
inline void fast_flush();
const int MAXN = 2e6 + 10;
const int MOD = 1e9 + 7;
const int INF = 1e18;
void solve() {
int n, k;
cin >> n >> k;
int ans = 0;
int left = 0, right = 0;
for (int i = 0; i < k; i++) {
left += i;
right += n - i;
}
while (k <= n + 1) {
ans += (right - left + 1) % MOD;
ans %= MOD;
left += k;
right += (n - k);
++k;
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
for (int i = 1; i <= t; ++i) {
solve();
}
return 0;
}
static const int buf_size = 4096;
inline int fast_readchar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int readUInt() {
int c = fast_readchar(), x = 0;
while (c <= 32) c = fast_readchar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = fast_readchar();
return x;
}
inline int readInt() {
int s = 1, c = fast_readchar();
int x = 0;
while (c <= 32) c = fast_readchar();
if (c == '-') s = -1, c = fast_readchar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = fast_readchar();
return x * s;
}
inline void readWord(char *s) {
int c = fast_readchar();
while (c <= 32) c = fast_readchar();
while (c > 32) *s++ = c, c = fast_readchar();
*s = 0;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void fast_writechar(int x) {
if (write_pos == buf_size) fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
inline void fast_flush() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
inline void writeInt(int x) {
if (x < 0) fast_writechar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) fast_writechar(s[n]);
}
inline void writeWord(const char *s) {
while (*s) fast_writechar(*s++);
} | #include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <array>
#include <initializer_list>
#include <random>
#include <regex>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
using namespace std;
char col[4] = {'R', 'G', 'B', 'Y'};
char ans[1005][1005];
int h, w, d;
void fill_triangle(int cx, int cy, int dr, char cr)
{
for (int i = cx - d / 2 + 1; i < cx + d / 2; i++)
{
int R = d / 2 - abs(cx - i);
for (int j = 0; j < R; j++)
{
if (i >= 0 && i < h && cy + dr * j >= 0 && cy + dr * j < w)
ans[i][cy + dr * j] = cr;
}
}
}
int main()
{
scanf("%d%d%d",&h,&w,&d);
if (d & 1)
{
for (int i = 0; i < h; i++)
{
for (int j = 0; j < w; j++)
{
printf("%c", col[(i + j) & 1]);
}
printf("\n");
}
return 0;
}
else if (d % 4 == 2)
{
for (int i = 0; i < h; i++)
{
for (int j = 0; j < w; j++)
{
printf("%c", col[(j + i / 2 * 2) % 4]);
}
printf("\n");
}
return 0;
}
else
{
for (int i = d / 2 - 1; i < h + 2 * d; i += d)
{
for (int j = 0; j < w + 2 * d; j += d)
{
fill_triangle(i, j, 1, col[((i + j + d) / d) & 1]);
fill_triangle(i, j - 1, -1, col[((i + j + d) / d) & 1]);
}
}
for (int i = -1; i < h + 2 * d; i += d)
{
for (int j = d / 2; j < w + 2 * d; j += d)
{
fill_triangle(i, j, 1, col[(((i + j + d) / d) & 1) + 2]);
fill_triangle(i, j - 1, -1, col[(((i + j + d) / d) & 1) + 2]);
}
}
for (int i = 0; i < h; i++) printf("%s\n", ans[i]);
}
} | 0 | 17,423,092 |
#include <bits/stdc++.h>
using namespace std;
#define repd(i,a,b) for (int i=(a);i<(b);i++)
#define rep(i,n) repd(i,0,n)
#define all(x) (x).begin(),(x).end()
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; }
typedef long long ll;
const long long INF = 1LL << 60;
typedef pair<int, int> P;
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
return a * b / gcd(a, b);
}
int main()
{
ll N, M;
cin >> N >> M;
vector<ll> A(N);
rep(i, N) cin >> A[i];
ll L = 1;
rep(i, N) L = lcm(L, A[i]);
M *= 2;
bool flag = true;
rep(i, N) {
if ((L / A[i]) % 2 == 0) flag = false;
}
ll ans = 0;
if (flag) {
ans = M / L;
ans = (ans + 1) / 2;
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define SC scanf
#define PR printf
#define pb push_back
#define mp make_pair
#define SZ(v) ((int)(v).size())
#define rep(i,n) for(int i=0;i<(n);i++)
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
#define db double
#define ldb long double
#define uint unsigned
#define ll long long
typedef pair<int,int> pii;
typedef pair<pii,int> ppi;
typedef pair<int,pii> pip;
typedef pair<pii,pii> ppp;
typedef vector<int> vi;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<pii> vii;
typedef map<int,int> mii;
const int INF=0x3f3f3f3f;
const ll LL_INF=0x3f3f3f3f3f3f3f3f;
const int xx[4]={1,-1,0,0};
const int yy[4]={0,0,1,-1};
int inline nextin(){
int t;
if(scanf("%d",&t)!=1)exit(0);
return t;
}
int inline in(){
int x=0,c;
for(;(uint)((c=getchar())-'0')>=10;){
if(c=='-')return -in();
if(!~c)throw ~0;
}
do{
x=(x<<3)+(x<<1)+(c-'0');
}while((uint)((c=getchar())-'0')<10);
return x;
}
int n;
char c[100005];
int r[100005];
bool hantei(int a,int b,int c,char t){
if(t=='o'&&b==0)if(a==c)return true;else return false;
if(t=='o'&&b==1)if(a!=c)return true;else return false;
if(t=='x'&&b==0)if(a!=c)return true;else return false;
if(t=='x'&&b==1)if(a==c)return true;else return false;
return false;
}
int main(){
cin.sync_with_stdio(false);cin.tie(0);
cin>>n;
rep(i,n)cin>>c[i];
rep(i,4){
r[0]=i/2;r[1]=i%2;
for(int j=2;j<n;j++){
if(c[j-1]=='o')r[j]=r[j-2];
else r[j]=1-r[j-2];
if(r[j-1]==1)r[j]=1-r[j];
}
if(!hantei(r[n-2],r[n-1],r[0],c[n-1]))continue;
if(!hantei(r[n-1],r[0],r[1],c[0]))continue;
rep(j,n)putchar(r[j]?'W':'S');
return 0;
}
puts("-1");
return 0;
} | 0 | 71,238,674 |
#include<iostream>
using namespace std;
int main(void){
int m[100][100];
int n, u, k, v;
cin >> n;
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
m[i][j]=0;
}
}
for(int i=0; i<n; i++){
cin >> u >> k;
u--;
for(int j=0; j<k; j++){
cin >> v;
v--;
m[u][v]=1;
}
}
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
if(j)cout << " ";
cout << m[i][j];
}
cout << endl;
}
return 0;
} | #pragma region include
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <string>
#include <queue>
#include <stack>
#include <cmath>
#include <set>
#include <cstdio>
#include <tuple>
#define ALL(obj) (obj).begin(),(obj).end()
#define RALL(obj) (obj).rbegin(),(obj).rend()
#define REP(i, n) for(int i = 0; i < (int)(n); i++)
#define REPR(i, n) for(int i = (int)(n); i >= 0; i--)
#define FOR(i,n,m) for(int i = (int)(n); i < int(m); i++)
#define MOD (1e9+7)
#define INF (1e9)
#define LLINF (4e18)
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
void input() {}
template<typename... R> void input(int& f, R&... r) { scanf("%d", &f); input(r...); }
template<typename... R> void input(double& f, R&... r) { scanf("%lf", &f); input(r...); }
template<typename... R> void input(ll& f, R&... r) { scanf("%lld", &f); input(r...); }
template<typename... R> void input(char& f, R&... r) { scanf("%c", &f); input(r...); }
template<typename... R> void input(string& f, R&... r) { cin >> f; input(r...); }
template<typename T, typename... R> void input(vector<T>& f, R&... r) { REP(i, f.size())input(f[i]); input(r...); }
#pragma endregion
int main() {
int h, w, n; input(h,w,n);
vector<int> a(n), b(n);
map<PII, ll> mp;
int dx[] = {-1,0,1,-1,0,1,-1,0,1}, dy[] = {-1,-1,-1,0,0,0,1,1,1};
REP(i, n) {
cin >> a[i] >> b[i];
a[i]--; b[i]--;
REP(j, 9) {
int x = a[i] + dx[j], y = b[i] + dy[j];
if (x > 0 && x < h - 1 && y > 0 && y < w - 1) mp[PII(x, y)]++;
}
}
vector<ll> cnt(10, 0);
ll sum = 0;
for (auto p : mp) {
cnt[p.second]++;
sum++;
}
cnt[0] = (ll)(h - 2)*(w - 2) - sum;
REP(i, 10) {
cout << cnt[i] << endl;
}
getchar(); getchar();
} | 0 | 45,200,128 |
#include <bits/stdc++.h>
#define fast_io ios :: sync_with_stdio(false);
using namespace std;
int main() {
cout << fixed << setprecision(3);
fast_io;
int x, n, h;
int cont = 0;
cin >> n;
int max = 0;
while (n--) {
cin >> h;
if(h >= max) {
cont++;
max = h;
}
}
cout << cont;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define eb emplace_back
typedef long long ll;
typedef unsigned long long ull;
void oneCase() {
int a, b, c;
cin>> a >> b >> c;
if (a == b) {
cout << c;
} else if (c == a) {
cout << b;
} else {
cout << a;
}
cout << "\n";
}
int main() {
int t = 1;
while (t--) {
oneCase();
}
return 0;
} | 0 | 15,210,247 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int A,B;
cin>>A>>B;
cout<<6-(A+B)<<endl;{
}
} | #include <bits/stdc++.h>
#include <iostream>
#include<math.h>
using namespace std;
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; }
int64_t cx(int64_t i) {
int64_t res = 1;
while (i > 1) {
res = res * i;
i--;
}
return res;
}
int main()
{
int64_t N;
cin >> N;
map<string, int64_t>d;
for (int64_t i=0; i<N; i++) {
string s;
cin >> s;
sort(s.begin(), s.end());
if (d.count(s) > 0) {
d[s] = d[s] + 1;
} else {
d[s] = 1;
}
}
int64_t sum_count = 0;
for (auto c : d) {
if (c.second > 2) {
int64_t i = c.second;
while (i > 1) {
sum_count += i - 1;
i--;
}
} else if (c.second == 2) {
sum_count += 1;
}
}
cout << sum_count << endl;
return 0;
} | 0 | 54,107,613 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(int)(n); i++)
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int l, r; cin >> l >> r;
const int INF = 2000000005;
int ans = INF, cnt = 0;
for (int i=l; i<=r; i++) {
if (i%2019==0) {
ans = 0;
break;
}
for (int j=i%2019+1; j <= r%2019;j++) {
ans = min((i%2019 * j%2019)%2019, ans);
}
if (cnt == 2019) break;
cnt++;
}
cout << ans << endl;
return 0;
} | #include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
int main()
{
string from,to;
cin>>from>>to;
int f[from.size()+1][to.size()+1];
for(int i=0;i<from.size()+1;i++){
for(int j=0;j<to.size()+1;j++){
f[i][j]=0;
}
}
for(int i=1;i<from.size()+1;i++){
f[i][0]=i;
}
for(int i=1;i<to.size()+1;i++){
f[0][i]=i;
}
for(int i=1;i<from.size()+1;i++){
for(int j=1;j<to.size()+1;j++){
if(from[i-1]==to[j-1]){
f[i][j]=f[i-1][j-1];
}else{
int min1=min(f[i-1][j-1],f[i][j-1]);
f[i][j]=min(min1,f[i-1][j])+1;
}
}
}
cout<<f[from.size()][to.size()]<<endl;
return 0;
} | 0 | 75,932,936 |
# include <iostream>
# include <algorithm>
# include <vector>
# include <string>
# include <set>
# include <map>
# include <cmath>
# include <iomanip>
# include <functional>
# include <utility>
# include <stack>
# include <queue>
# include <list>
# include <unordered_map>
constexpr int MOD = 1000000000 + 7;
constexpr int INF = 2000000000;
using namespace std;
using LL = long long;
char maze[21][21];
bool ok[21][21];
int h, w;
int sx, sy;
void dfs(int hpos, int wpos) {
ok[hpos][wpos] = true;
maze[hpos][wpos] = '#';
int dx[4] = { 0,1,0,-1 }, dy[4] = { -1,0,1,0 };
for (int i = 0; i < 4; i++) {
int nx = wpos + dx[i], ny = hpos + dy[i];
if (0 <= nx&&nx < w && 0 <= ny&&ny < h&&maze[ny][nx] == '.')dfs(ny, nx);
}
}
int main() {
while (cin >> w >> h&&w&&h) {
for (int i = 0; i < 20; i++) {
for (int j = 0; j < 20; j++) {
ok[i][j] = false;
}
}
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
cin >> maze[i][j];
if (maze[i][j] == '@')sx = j, sy = i;
}
}
dfs(sy, sx);
int ans = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (ok[i][j])ans++;
}
}
cout << ans << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int h,w;
cin >> h >> w;
vector<string> s(h);
for(int i=0;i<h;i++)
{
cin >> s.at(i);
}
string ans = "Yes";
for(int i = 0;i<h;i++)
{
for(int j = 0;j<w;j++)
{
int z1=0,z2=0,z3=0,z4=0;
char nw = s.at(i).at(j);
if(nw == '.')
{
continue;
}
if(i - 1 >= 0)
{
if(s.at(i-1).at(j) == '.')
{
z1 = 1;
}
}
else
{
z1 = 1;
}
if(j + 1 < w)
{
if(s.at(i).at(j+1) == '.')
{
z2 = 1;
}
}
else
{
z2 = 1;
}
if(j - 1 >= 0)
{
if(s.at(i).at(j-1) == '.')
{
z3 = 1;
}
}
else
{
z3 = 1;
}
if(i + 1 < h)
{
if(s.at(i+1).at(j) == '.')
{
z4 = 1;
}
}
else
{
z4 = 1;
}
if(z1*z2*z3*z4 == 1)
{
ans = "No";
}
}
}
cout << ans << endl;
return 0;
} | 0 | 79,755,285 |
#include <iostream>
#include <string>
using namespace std;
int main() {
while (1) {
string str;
cin >> str;
if (str == "-") {
break;
}
int m;
cin >> m;
int first = 0;
for (int i = 0; i < m; i++) {
int h;
cin >> h;
first = (first + h) % str.size();
}
for (int i = 0; i < str.size(); i++) {
cout << str[(first + i) % str.size()];
}
cout << endl;
}
return 0;
} | #include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <limits>
#include <random>
#include <complex>
#include <cmath>
#include <cstdio>
#include <cstdlib>
using namespace std;
typedef long long ll;
#define REP(i,n) for (int i = 0; i < n; i++)
template <class T> using reversed_priority_queue = priority_queue<T, vector<T>, greater<T> >;
int N,K;
ll t[100010];
ll d[100010];
int main ()
{
cin >> N >> K;
REP(i,N) cin >> t[i] >> d[i];
vector < pair < ll, ll > > ord;
REP(i,N) ord.push_back(make_pair(d[i], i));
sort(ord.begin(), ord.end());
reverse(ord.begin(), ord.end());
ll sum = 0;
vector < ll > cnd;
reversed_priority_queue < pair < ll, ll > > que1;
priority_queue < pair < ll, ll > > que2;
bool used[100010] = {};
ll x2 = 0;
REP(i,K) {
ll idx = ord[i].second;
ll del = ord[i].first;
ll tt = t[idx];
if (!used[tt]) {
used[tt] = true;
x2++;
} else {
que1.push(make_pair(d[idx], t[idx]));
}
sum += del;
}
for (int i = K; i < N; i++) {
ll idx = ord[i].second;
ll tt = t[idx];
if (!used[tt]) {
used[tt] = true;
que2.push(make_pair(d[idx], t[idx]));
}
}
cnd.push_back(sum + x2 * x2);
while ((!que1.empty()) && (!que2.empty())) {
sum -= que1.top().first;
sum += que2.top().first;
que1.pop();
que2.pop();
x2++;
cnd.push_back(sum + x2 * x2);
}
ll ans = 0;
REP(i,cnd.size()) {
ans = max(ans, cnd[i]);
}
cout << ans << endl;
return 0;
} | 0 | 31,100,371 |
#include <iostream>
using namespace std;
int main()
{
int a,b,c;
cin>>a>>b>>c;
a=a+b;
if(a>=c)
cout<<"Yes";
if(a<c)
cout<<"No";
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <cstdio>
#include <functional>
#include <set>
#include <sstream>
#include <map>
using namespace std;
int main()
{
int n;
while(cin>>n,n){
vector<long long> dp(n);
long long res;
cin>>dp[0];
res=dp[0];
for(int i=1;i<n;i++){
long long a;
cin>>a;
dp[i]=max(dp[i-1]+a,a);
res=max(res,dp[i]);
}
cout<<res<<endl;
}
return 0;
} | 0 | 41,365,072 |
#include <iostream>
#include <algorithm>
#include <string>
#include <math.h>
#include <cstdint>
#include <map>
using namespace std;
typedef long long ll;
ll ans,mx,sum,mn=1e8;
int main(){
ll n,m;
cin>>n>>m;
if(n*2 >= m){
cout<<m/2;
}
else cout<<n+(m-(n*2))/4<<endl;
} | #include<bits/stdc++.h>
#define fast ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define int long long
#define pb push_back
#define pii pair<int,int>
#define vi vector<int>
#define vii vector<pii>
#define mi map<int,int>
#define mii map<pii,int>
#define all(a) (a).begin(),(a).end()
#define F first
#define S second
#define sz(x) (int)x.size()
#define endl '\n'
#define MOD 1000000007
#define loop(i,a,b) for(int (i)=(a);(i)<(b);(i)++)
#define rloop(i,a,b) for(int (i)=(a);(i)>=(b);(i)--)
#define Unique(A) (A).resize(distance((A).begin(),unique(all((A)))))
#define MXe(A) *max_element(all(A))
#define MNe(A) *min_element(all(A))
#define SP(val,precision) fixed << setprecision((precision)) << (val)
#define setBits(x) __builtin_popcountll(x)
#define zroBits(x) __builtin_ctzll(x)
#define trace1(x) cerr<<#x<<": "<<x<<endl
#define trace2(x, y) cerr<<#x<<": "<<x<<" | "<<#y<<": "<<y<<endl
#define trace3(x, y, z) cerr<<#x<<": "<<x<<" | "<<#y<<": "<<y<<" | "<<#z<<": "<<z<<endl
#define trace4(a, b, c, d) cerr<<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<endl
#define trace5(a, b, c, d, e) cerr<<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<" | "<<#e<< ": "<<e<<endl
#define trace6(a, b, c, d, e, f) cerr<<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<" | "<<#e<< ": "<<e<<" | "<<#f<<": "<<f<<endl
#define mem(name,val) memset(name,val,sizeof(name))
#define traceA(A,x) cerr<<#A<<": ";loop(i,0,x)cerr<<A[i]<<' ';cerr<<endl
#define traceV(A) cerr<<#A<<": ";for(auto i:A)cerr<<i<<' ';cerr<<endl
#define traceM(A,n,m) cerr<<#A<<": "<<endl;loop(i,0,n){loop(j,0,m) cerr << A[i][j] << ' ';cerr << endl;}
#define maxheap priority_queue<int>
#define minheap priority_queue<int,vector<int>,greater<int>>
using namespace std;
const int N = 3e5+77;
int X[N] , Y[N] , A[N] , B[N] , n , m , k , a , b , aa ,bb , c;
int32_t main(){
fast;
clock_t clk = clock();
cin >> n >> m >> k;
loop(i,0,k){
cin >> X[i] >> Y[i];
A[X[i]]++; B[Y[i]]++;
}
loop(i,1,n+1) a = max(a,A[i]);
loop(i,1,n+1) if(A[i]==a) aa++;
loop(i,1,m+1) b = max(b,B[i]);
loop(i,1,m+1) if(B[i]==b) bb++;
loop(i,0,k) if(A[X[i]]==a && B[Y[i]]==b) c++;
if(c==aa*bb) cout << a+b-1 << endl;
else cout << a+b << endl;
cerr << endl << "Time (in ms): " << double(clock() - clk) * 1000.0 / CLOCKS_PER_SEC << endl;
return 0;
} | 0 | 70,400,937 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define P pair<ll, ll>
#define Graph vector<vector<ll>>
#define fi first
#define se second
constexpr ll mod = 1000000007;
constexpr ll INF = (1ll << 60);
constexpr double pi = 3.14159265358979323846;
template <typename T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
ll n, k;
cin >> n >> k;
cout << n - k + 1 << "\n";
return 0;
} | #include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#include <vector>
#include <deque>
using namespace std;
#define fors(i,a,b) for(int i=(a);i<=(b);++i)
#define ford(i,a,b) for(int i=(a);i>=(b);--i)
#define min(x,y) ((x) < (y) ? (x) : (y))
#define max(x,y) ((x) < (y) ? (y) : (x))
#define swap(x,y) ((x)^=(y),(y)^=(x),(x)^=(y))
#define abs(x) ((x) < 0 ? -(x) : (x))
const int maxn=1e6+7;
typedef long long ll;
const int inf=1<<25;
int read(){
int s=0,f=1;
char c=getchar();
while(c<'0' || c>'9') {if(c=='-') f=-1; c=getchar();}
while(c>='0' && c<='9') {s=s*10+c-48;c=getchar();}
return s*f;
}
void write(int x){
if(x<0) {putchar('-');x=-x;}
if(x>9) write(x/10);
putchar(x%10+48);
}
const int N = 1e3 + 5;
int a[N], b[N];
int n, m, c, flag;
char s[45];
int main(){
scanf("%d", &n);
c = 0;
fors(i, 1, n){
scanf("%d%d", a + i, b + i);
if ((a[i] + b[i]) & 1) ++c;
else --c;
}
if (abs(c) != n) return 0 * puts("-1");
m = 31 + (c < 0);
printf("%d\n", m);
fors(i, 0, 30) printf("%d ", 1 << i);
if (c < 0) putchar(49);
putchar(10);
fors(i, 1, n){
int x = a[i], y = b[i];
if (c < 0) s[31] = 'R', --x;
flag = 0;
ford(j, 30, 0){
if (abs(x) < abs(y)) swap(x, y), flag ^= 1;
if (x > 0) x -= 1 << j, s[j] = flag ? 'U' : 'R';
else x += 1 << j, s[j] = flag ? 'D' : 'L';
}
puts(s);
}
return 0;
} | 0 | 59,326,129 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,A;
cin >> N >> A;
N = N%500;
if(N - A > 0){
cout << "No" << endl;
}
if(N - A <=0){
cout << "Yes" << endl;
}
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int a,b,x;
cin>>a>>b>>x;
if(a>x){
cout<<"NO"<<endl;
}
else if(a+b>=x){
cout<<"YES"<<endl;
}
else{
cout<<"NO"<<endl;
}
return 0;
} | 0 | 35,850,615 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,tmp;
vector<pair<int,int>> a;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> tmp;
a.push_back(make_pair(tmp,i));
}
sort(a.begin(), a.end());
for (int i = 0; i < n; i++) {
cout << a.at(i).second+1;
if (i != n - 1) {
cout << " ";
}
}
cout << endl;
} | #include <bits/stdc++.h>
using namespace std;
const int inf = 1e5;
int dp[101][101];
signed main () {
int h, w, a, b;
cin >> h >> w >> a >> b;
string t1, t2;
for (int i = 0; i < a; ++i) {
t1 += '1';
t2 += '0';
}
for (int i = 0; i < w - a; ++i) {
t1 += '0';
t2 += '1';
}
for (int i = 0; i < b; ++i)
cout << t1 << '\n';
for (int i = 0; i < h - b; ++i)
cout << t2 << '\n';
} | 0 | 73,518,502 |
#include<iostream>
using namespace std;
bool backet(char a){
if(a=='(')return true;
if(a==')')return true;
if(a=='[')return true;
if(a==']')return true;
if(a=='{')return true;
if(a=='}')return true;
return false;
}
bool check(char a,char b){
if(a=='(' && b==')')return true;
if(a=='[' && b==']')return true;
if(a=='{' && b=='}')return true;
return false;
}
int main(){
string s;
int ans = 0;
while(getline(cin, s)){
if(s==".")break;
for(int j=0;j<(int)s.size();j++)
if(!backet(s[j])){
s.erase(s.begin()+j);
j--;
}
bool f = true;
while(f){
f = false;
for(int j=0;j<(int)s.size()-1;j++)
if(check(s[j],s[j+1])){
s.erase(s.begin()+j);
s.erase(s.begin()+j);
j--;
f = true;
}
}
if(s.size())cout << "no\n";
else cout << "yes\n";
}
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll ;
typedef double db;
const double pi = 3.141592654;
#define pb push_back
#define forab(i,a,b) for(int i=(a);i<=(b);i++)
#define CIN ios_base::sync_with_stdio(0); cin.tie(0)
#define pcase(z,x) printf("Case %ld: %lld\n",z,x)
#define nw "\n"
int main(void)
{
CIN;
ll tc,l,k,sum=0,x=0,y,z=0,m=1,n=0,ans=0,cnt=0;
map<char,int>mp;
char c;
while(cin>>c){
mp[c]++;
if(mp[c]==2)return cout<<"no",0;
}
cout<<"yes";
} | 0 | 35,490,508 |
#include <iostream>
#include <bits/stdc++.h>
#include <string>
#include <ctype.h>
#include <algorithm>
#include <cmath>
#define REP(i, n) for(int i=0;i<(int)(n);i++)
#define ALL(x) (x).begin(),(x).end()
#define square(x) (x) * (x)
#define cube(x) (x) * (x) * (x)
const int INF = 1e9;
using namespace std;
class dice{
private:
int s[6];
int top;
int bottom;
int r_side;
int l_side;
int face;
int rev;
public:
dice(){
top = 0;
bottom = 5;
r_side = 2;
l_side = 3;
face = 1;
rev = 4;
s[0] = 1;
s[1] = 2;
s[2] = 3;
s[3] = 4;
s[4] = 5;
s[5] = 6;
}
dice(int a[5]){
top = 0;
bottom = 5;
r_side = 2;
l_side = 3;
face = 1;
rev = 4;
REP(i, 6) s[i] = a[i];
}
dice(int x, int y, int z, int u, int v, int w){
top = 0;
bottom = 5;
r_side = 2;
l_side = 3;
face = 1;
rev = 4;
s[0] = x;
s[1] = y;
s[2] = z;
s[3] = u;
s[4] = v;
s[5] = w;
}
int get_top() {
return s[top];
}
int get_bottom(){
return s[bottom];
}
int get_r_side(){
return s[r_side];
}
int get_l_side(){
return s[l_side];
}
int get_face(){
return s[face];
}
int get_rev(){
return s[rev];
}
int set_top(int i) {
top = i;
bottom = 5 - top;
r_side = (i+1)%5;
l_side = 5 - r_side;
face = (i+2)%5;
rev = 5 - face;
return s[top];
}
int rotate_r(int i) {
while(i<0)
i+=4;
i %= 4;
REP(j, i){
int temp = face;
face = r_side;
r_side = rev;
rev = l_side;
l_side = temp;
}
return s[top];
}
int roll_r(int i) {
while(i<0)
i+=4;
i %= 4;
REP(j, i){
int temp = top;
top = l_side;
l_side = bottom;
bottom = r_side;
r_side = temp;
}
return s[top];
}
int roll_f(int i){
while(i<0)
i+=4;
i %= 4;
REP(j, i){
int temp = top;
top = face;
face = bottom;
bottom = rev;
rev = temp;
}
return s[top];
}
};
int search(dice d) {
int f, t;
cin >> t >> f;
while(d.get_top() != t || d.get_face() != f){
if(d.get_top() == t)
while(d.get_face() != f)
d.rotate_r(1);
else if(d.get_face() == f)
while(d.get_top() != t)
d.roll_r(1);
else {
REP(i, 4){
d.roll_f(1);
if(d.get_face() == f || d.get_top() == t)
break;
}
}
}
return d.get_r_side();
}
int main() {
ostringstream os;
int in[6];
int q;
REP(i, 6) cin >> in[i];
dice d = dice(in);
cin >> q;
REP(i, q)
os << search(d) << endl;
cout << os.str();
return 0;
} | #include <cmath>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int,int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef double dl;
#define endl '\n'
#define PB push_back
#define F first
#define S second
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define sz(x) (ll)x.size()
#define wt ll t; cin>>t; while(t--)
#define input(a,n) for(int i=0;i<n;i++) cin>>a[i];
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const ll infLL = 9000000000000000000;
#define mem(a,b) memset(a, b, sizeof(a) )
#define sqr(a) ((a) * (a))
#define mod 10000007
#define optimize() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define fraction() cout.unsetf(ios::floatfield); cout.precision(10); cout.setf(ios::fixed,ios::floatfield);
#define file() freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#define dbg(args...) do {cerr << #args << " : "; faltu(args); } while(0)
void faltu () { cerr << endl;}
template < typename T, typename ... hello>void faltu( T arg, const hello &... rest) {cerr << arg << ' ';faltu(rest...);}
ll gcd ( ll a, ll b ) { return __gcd ( a, b ); }
ll lcm ( ll a, ll b ) { return a * ( b / gcd ( a, b ) ); }
const ll mx=1e9;
main()
{
optimize();
int n,i,j=0;
cin>>n;
string s[n+1];
map<string,int>m;
for(i=1;i<=n;i++){
cin>>s[i];
m[s[i]]++;
}
for(auto u:m)
{
if(u.S>1){
cout<<"No"<<endl;
return 0;}
}
for(i=2;i<=n;i++)
{
ll n=sz(s[i-1]);
if(s[i-1][n-1]!=s[i][0])
{
j++;
cout<<"No"<<endl;
break;
}
}
if(j==0)
cout<<"Yes"<<endl;
return 0;
} | 0 | 59,369,741 |
#include <iostream>
#include <string>
using namespace std ;
int main(){
string s = "aaaaaaaaaaaaa" ;
for(int i=0;i<13;i++){
if(i==4) s.at(i) = ' ' ;
else{
char c ; cin >> c ;
s.at(i) = c ;
}
}
cout << s << endl ;
} | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const int INF = 1001001001;
const int MOD = 1000000007;
typedef long long ll;
template<typename T> void print(const T & v);
int main() {
int A, B, M;
cin >> A >> B >> M;
vector<int> a(A), b(B);
rep(i, A) cin >> a[i];
rep(i, B) cin >> b[i];
vector<int> x(M), y(M), c(M);
rep(i, M) cin >> x[i] >> y[i] >> c[i];
int mini_a = INF;
int total = 0;
rep(i, A){
mini_a = min(mini_a, a[i]);
}
int mini_b = INF;
rep(i, B){
mini_b = min(mini_b, b[i]);
}
total = mini_a + mini_b;
int set_mini = INF;
rep(i, M){
int price = a[x[i] - 1] + b[y[i] - 1] - c[i];
set_mini = min(set_mini, price);
}
cout << min(total, set_mini) << endl;
return 0;
}
template <typename T>
void print(T const & v){
for(int i = 0; i < v.size(); i++){
if(i) cout << " ";
cout << v[i];
}
cout << endl;
} | 0 | 14,088,393 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair <ll,ll> P;
#define REP(i, n) for(int i = 0; i < (int)(n); i++)
#define REPR(i, n) for(int i = n-1; i > 0; i--)
#define FOR(i, n, m) for(int i = n; i < (int)(m); i++)
#define PRINT(x) cout << x << endl
#define ALL(v) v.begin(), v.end()
#define INF (ll)1e18
#define PI 3.14159265358979
ll gcd(ll a, ll b) { return b ? gcd(b,a%b) : a;}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll MOD = 1000000007;
int main()
{
ll N;
cin >> N;
vector<ll> T(N);
REP(i, N) cin >> T[i];
vector<ll> A(N);
REP(i, N) cin >> A[i];
if (!(T.front() <= A.front()) || !(T.back() >= A.back())) {
PRINT(0);
return 0;
}
vector<ll> v(N);
v[0] = T.front();
v.back() = A.back();
REP(i, N-1) {
if (T[i] < T[i+1]) {
if(T[i+1] > A[i+1]) {
PRINT(0);
return 0;
}
v[i+1] = T[i+1];
}
if (A[i] > A[i+1]) {
if (A[i] > T[i]) {
PRINT(0);
return 0;
}
v[i] = A[i];
}
}
ll ans = 1;
REP(i, N) {
if (v[i] == 0) {
ans *= min(T[i], A[i]);
ans %= MOD;
}
}
PRINT(ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
while(1){
int n;
cin>>n;
if(n == 0) break;
vector <int> data(n);
for(int i=0; i<n; i++){
cin>>data.at(i);
}
sort(data.begin(), data.end());
reverse(data.begin(),data.end());
vector <int> gap(n);
for(int i=0; i<n-1; i++){
gap.at(i) = data.at(i) - data.at(i+1);
}
sort(gap.begin(),gap.end());
if(gap.at(0) == 0) cout<<gap.at(1)<<endl;
else cout<<gap.at(0)<<endl;
}
return 0;
} | 0 | 65,112,120 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
vector<int> x(n);
for (int i = 0; i < n; i++) {
cin >> x.at(i);
}
int ans = 1e9;
for (int p = 1; p <= 100; p++) {
int po = 0;
for (int i = 0; i < n; i++) {
po += (x.at(i) - p) * (x.at(i) - p);
}
ans = min(ans, po);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1001001001;
const ll mod = 1000000007;
int main(){
ll n; cin >> n;
set<ll> st;
for(ll i = 1; i * i <= n; i++){
if(n % i == 0){
st.insert(i);
st.insert(n / i);
}
}
ll ans = 0;
for(ll k : st){
if(n / k >= k - 1) continue;
if(!st.count(k - 1)){
ans += k - 1;
}
}
cout << ans << endl;
} | 0 | 88,256,939 |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<cstdio>
#include<sstream>
#include<iomanip>
#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()
#define shosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef pair<int,pii> pip;
typedef vector<pip>vip;
const double PI=acos(-1);
const double EPS=1e-8;
const int inf=1e8;
int main(){
int N=9,S=100;
vvi dp(N+1,vi(S+1));
dp[0][0]=1;
loop(x,0,10)for(int i=N-1;i>=0;i--)for(int j=S-x;j>=0;j--){
dp[i+1][j+x]+=dp[i][j];
}
int n,s;
while(cin>>n>>s,n+s){
cout<<dp[n][s]<<endl;
}
} | #include<bits/stdc++.h>
using namespace std;
#define LL long long
#define DD double
#define Pb push_back
#define Bp pop_back
#define Pf push_front
#define Fp pop_front
#define Ub upper_bound
#define Lb lower_bound
#define In insert
#define All(x) x.begin(), x.end()
#define mem(a, b) memset(a, b, sizeof(a))
#define fast ios_base::sync_with_stdio(0);cin.tie(0)
#define X first
#define Y second
#define mx1 10
#define mx2 110
#define mx3 1010
#define mx4 10010
#define mx5 100010
#define mx6 1000010
typedef vector<LL> Vl;
typedef vector<DD> Vd;
typedef vector<bool> Vb;
typedef vector<Vl> VVl;
typedef pair<LL, LL> Pll;
typedef pair<DD, DD> Pdd;
typedef vector<Pll> Vpl;
typedef vector<Pdd> Vpd;
typedef queue<LL> Ql;
typedef stack<LL> Sl;
typedef deque<LL> Dl;
LL _set(LL N, LL pos) {return N = N | (1 << pos);}
LL _reset(LL N, LL pos) {return N = N & ~(1 << pos);}
bool _check(LL N, LL pos) {return (bool)(N & (1 << pos));}
bool _upper(char a) {return a >= 'A' && a <= 'Z';}
bool _lower(char a) {return a >= 'a' && a <= 'z';}
bool _digit(char a) {return a >= '0' && a <= '9';}
LL dx[] = {1, -1, 0, 0, -1, -1, 1, 1};
LL dy[] = {0, 0, 1, -1, -1, 1, -1, 1};
int a[2 * mx5], ans[2 * mx5];
int main()
{
int n;
cin >> n;
for(int i = 1; i <= n; i++)
cin >> a[i];
for(int i = n / 2 + 1, j = 1; i <= n; i++, j += 2)
ans[i] = a[j];
for(int i = n / 2, j = 2; i; i--, j += 2)
ans[i] = a[j];
if(n % 2){
for(int i = n; i; i--)
cout << ans[i] << ' ';
cout << '\n';
return 0;
}
for(int i = 1; i <= n; i++)
cout << ans[i] << ' ';
cout << '\n';
return 0;
} | 0 | 33,224,852 |
#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>
#include <math.h>
using namespace std;
using ll = long long;
using vl = vector<long long>;
using vll = vector<vector<long long>>;
using vs = vector<string>;
using vc = vector<char>;
using vcc = vector<vector<char>>;
using vm = vector<short>;
using vmm = vector<vector<short>>;
using pii = pair<int, int>;
using psi = pair<string, int>;
using ld = long double;
using ull = unsigned long long;
using ld = long double;
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 box(double a)
{
ll b = a;
return b;
}
ll fff(double a)
{
ll b = a + 0.5;
return b;
}
ll sum(ll n) {
return (1 + n) * n / 2;
}
ll mch(ll n) {
if (n == 1) return 1;
else return n * mch(n - 1);
}
bool prime(ll a)
{
if (a < 2) return false;
else if (a == 2) return true;
else if (a % 2 == 0) return false;
double m = sqrt(a);
for (int i = 3; i <= m; i += 2)
{
if (a % i == 0)
{
return false;
}
}
return true;
}
ll modpow(ll a, ll n, ll mod) {
ll hi = 1;
while (n > 0) {
if (n & 1) hi = hi * a % mod;
a = a * a % mod;
n >>= 1;
}
return hi;
}
ll mg(ll a, ll mod) {
return modpow(a, mod - 2, mod);
}
int main() {
ll n; cin >> n;
vl a(n + 1);
vl b(n);
for (int i = 0; i < n + 1; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
ll cnt = 0;
for (int i = 0; i < n ; i++) {
if (b[i] > a[i]) {
cnt += a[i];
b[i] -= a[i];
cnt += a[i + 1];
a[i + 1] = max(0ll, a[i + 1] - b[i]);
cnt -= a[i + 1];
}
else cnt += b[i];
}
cout << cnt << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int64_t calc_gcd(int64_t a, int64_t b)
{
a = a % b;
if (a == 0)
return b;
return calc_gcd(b, a);
}
int64_t calc_lcm(int64_t a, int64_t b)
{
return a / calc_gcd(a, b) * b;
}
int64_t calc_vec_lcm(const vector<int64_t> &a_vec, int64_t upper)
{
int64_t lcm = 1;
for (auto a : a_vec) {
lcm = calc_lcm(lcm, a);
if (lcm > upper)
return upper;
}
return lcm;
}
int64_t count_factor2(int64_t a)
{
int64_t log2 = 0;
while (a > 0) {
if (a & 1)
break;
++log2;
a >>= 1;
}
return log2;
}
bool is_feasible(const vector<int64_t> &a_vec)
{
int64_t cnt, head_cnt = -1;
int size = a_vec.size();
head_cnt = count_factor2(a_vec.at(0));
for (int i = 1; i < size; ++i) {
cnt = count_factor2(a_vec.at(i));
if (cnt != head_cnt)
return false;
}
return true;
}
int main()
{
int N;
int64_t M;
cin >> N >> M;
vector<int64_t> a_vec(N);
int64_t a;
for (int i = 0; i < N; ++i) {
cin >> a;
a_vec.at(i) = a / 2;
}
if (!is_feasible(a_vec)) {
cout << 0 << endl;
return 0;
}
int64_t lcm = calc_vec_lcm(a_vec, M + 1);
cout << M / lcm - M / (2 * lcm) << endl;
} | 0 | 18,288,659 |
#include <algorithm>
#include <array>
#include <assert.h>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
int main() {
int N;
cin >> N;
vector<int> Ais;
for (int i = 0; i < N; i++) {
int Ai;
cin >> Ai;
Ais.push_back(Ai);
}
sort(Ais.begin(), Ais.end());
vector<int> add;
vector<int> subtract;
for (int i = 0; i < Ais.size(); i++) {
int Ai = Ais[i];
if (i == 0) {
subtract.push_back(Ai);
} else if (i == Ais.size() - 1) {
add.push_back(Ai);
} else {
if (Ai >= 0) {
add.push_back(Ai);
} else {
subtract.push_back(Ai);
}
}
}
int add_sum = 0;
for (int n : add) {
add_sum += n;
}
int subtract_sum = 0;
for (int n : subtract) {
subtract_sum += n;
}
cout << add_sum - subtract_sum << endl;
int value = 0;
if (add.size() >= 2) {
value = subtract.back();
subtract.pop_back();
while (add.size() >= 2) {
cout << value << " " << add.back() << endl;
value = value - add.back();
add.pop_back();
}
cout << add.back() << " " << value << endl;
value = add.back() - value;
} else {
value = add[0];
}
while (subtract.size() > 0) {
cout << value << " " << subtract.back() << endl;
value = value - subtract.back();
subtract.pop_back();
}
} | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
#define int ll
#define double long double
#define YES {cout<<"YES"<<'\n';}
#define NO {cout<<"NO"<<'\n';}
#define Yes {cout<<"Yes"<<'\n';}
#define No {cout<<"No"<<'\n';}
#define yes {cout<<"yes"<<'\n';}
#define no {cout<<"no"<<'\n';}
void YN(bool flg){cout<<(flg?"YES":"NO")<<'\n';}
void Yn(bool flg){cout<<(flg?"Yes":"No")<<'\n';}
void yn(bool flg){cout<<(flg?"yes":"no")<<'\n';}
#define SORT(a) sort(a.begin(),a.end())
#define REVERSE(a) reverse(a.begin(),a.end())
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define out(n) {cout << n << '\n';}
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<bool> VB;
typedef vector<VI> VVI;
const int MOD = 1000000007;
const long long INF = 10e10;
const double PI = acos(-1.0);
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>auto MAX(const T& a) { return *max_element(a.begin(),a.end()); }
template<class T>auto MIN(const T& a) { return *min_element(a.begin(),a.end()); }
int ABS(int a) {if(a<0) a = -a; return a;}
template<class T, class U>U SUM(const T& a, const U& v) { return accumulate(a.begin(),a.end(), v); }
template<class T, class U>U COUNT(const T& a, const U& v) { return count(a.begin(),a.end(), v); }
template<class T, class U>int LOWER(const T& a, const U& v) { return lower_bound(a.begin(),a.end(), v) - a.begin(); }
template<class T, class U>int UPPER(const T& a, const U& v) { return upper_bound(a.begin(),a.end(), v) - a.begin(); }
int GCD(int a, int b) { return b ? GCD(b, a%b) : a; }
int LCM(int a, int b) { int g = GCD(a, b); return a / g * b; }
int POW(int a, int n) { int r = 1; while (n > 0) { if (n & 1)r *= a; a *= a; n /= 2; }return r; }
int isPrime(int n){if(n<2){return 0;}for(int i=2; i*i<=n; i++){if(n%i==0){return 0;}}return 1;}
map< int, int >prime_factor(int n){map< int, int > ret;for(int i = 2; i * i <= n; i++) {while(n % i == 0) {ret[i]++;n /= i;}}if(n != 1) ret[n] = 1;return ret;}
int divisor_number(int n){auto p = prime_factor(n); int res = 1; for(auto x:p)res*=(x.second+1); return res;}
vector<int> divisor(int n){vector<int> v; for(int i=1; i*i<=n; i++){if(n%i==0){v.push_back(i);if(i!=n/i){v.push_back(n/i);}}}sort(v.begin(),v.end()); return v;}
signed main(){
cin.tie(0);
ios::sync_with_stdio(0);
cout<<fixed<<setprecision(15);
int n,l,t; cin >> n >> l >> t;
VI x(n) , w(n); REP(i,n) cin >> x[i] >> w[i];
VI tmp(n);
REP(i,n){
if(w[i]==1) tmp[i] = (x[i]+t)%l;
else tmp[i] = ((x[i]-t)%l+l)%l;
}
SORT(tmp);
int count = 0;
REP(i,n){
if(w[i]==1) count -= (t-(l-x[i])+l)/l;
else count += (t-(x[i]+1)+l)/l;
}
count = (count%n+n)%n;
VI res(n); REP(i,n) res[(i+count)%n] = tmp[i];
REP(i,n) out(res[i]);
return 0;
} | 0 | 25,159,844 |
#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 };
void solve() {
int H, W, A, B; cin >> H >> W >> A >> B;
rep(i, H){
rep(j, W){
if(i<B){
if(j<A) cout << 1;
else cout << 0;
}else{
if(j<A) cout << 0;
else cout << 1;
}
}
cout << endl;
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
} | #include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
int main()
{
std::string str;
std::size_t q;
std::cin >> str >> q;
for (std::size_t i = 0; i < q; ++i) {
std::string command;
std::size_t a, b;
std::cin >> command;
if (command == "replace") {
std::string p;
std::cin >> a >> b >> p;
for (std::size_t j = a; j <= b; ++j) {
str[j] = p[j-a];
}
} else if (command == "reverse") {
std::cin >> a >> b;
for (std::size_t j = 0; j <= (b -a)/2; ++j) {
std::swap(str[a + j], str[b - j]);
}
} else if (command == "print") {
std::cin >> a >> b;
std::cout << str.substr(a, b-a+1) << std::endl;
}
}
return 0;
} | 0 | 22,752,994 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
if(n>=400&&n<600) cout<<8;
else if(n>=600&&n<800) cout<<7;
else if(n>=800&&n<1000) cout<<6;
else if(n>=1000&&n<1200) cout<<5;
else if(n>=1200&&n<1400) cout<<4;
else if(n>=1400&&n<1600) cout<<3;
else if(n>=1600&&n<1800) cout<<2;
else if(n>=1800&&n<2000) cout<<1;
return 0;
} | #include <bits/stdc++.h>
#define ll long long int
#define MOD 1000000007
#define P pair<ll,ll>
#define INF 1000000000000000000
#define N 100001
using namespace std;
ll q, k;
ll dist[N];
vector<vector<P>> edge;
void make_dist(int cur){
for (auto p : edge[cur]){
ll u = p.first;
ll d = p.second;
if (dist[u] == -1){
dist[u] = dist[cur] + d;
make_dist(u);
}
}
return;
}
int main(void){
ll n;
cin >> n;
for (int i = 0; i < n; i++){
dist[i] = -1;
}
edge = vector<vector<P>>(n, vector<P>(0));
for (int i = 0; i < n-1; i++){
ll a, b, c;
cin >> a >> b >> c;
a--;b--;
edge[a].emplace_back(P(b, c));
edge[b].emplace_back(P(a, c));
}
cin >> q >> k;
k--;
dist[k] = 0;
make_dist(k);
for (int i = 0; i < q; i++){
ll x, y;
cin >> x >> y;
x--; y--;
cout << dist[x] + dist[y] << endl;
}
return 0;
} | 0 | 62,783,345 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string S;
cin>>S;
for(int i=S.size()-2;i>0;i-=2){
bool bo=false;
for(int j=0;j<i/2;j++)
if(S[j]!=S[j+i/2]){
bo=true;
break;
}
if(bo)
continue;
cout<<i<<endl;
return 0;
}
} | #include<bits/stdc++.h>
using namespace std;
int ar[2000010], br[100010], cr[2000010];
int main()
{
int i, n;
scanf("%d", &n);
memset(br, 0, sizeof(br));
for(i = 1; i <= n; ++i)
{
scanf("%d", &ar[i]);
++br[ar[i]];
}
for(i = 1; i < 100001; ++i)
br[i] = br[i] + br[i - 1];
for(i = n; i > 0; --i)
{
cr[br[ar[i]]] = ar[i];
--br[ar[i]];
}
for(i = 1; i < n; ++i)
printf("%d ", cr[i]);
printf("%d\n", cr[n]);
return 0;
} | 0 | 30,277,798 |
#include <iostream>
#include <utility>
using namespace std;
#define N 1000000
#define INF 1000000
typedef pair<char, int> Card;
void bubSort(Card cards[], int n){
for (int i=0; i<n; i++){
for (int j=n-1; j>=i+1; j--){
if (cards[j].second < cards[j-1].second){
Card tmp;
tmp = cards[j]; cards[j]=cards[j-1]; cards[j-1]=tmp;
}
}
}
}
void selSort(Card cards[], int n){
for (int i=0; i<n; i++){
int mnj = i;
Card tmp;
for (int j=i; j<n; j++){
if (cards[j].second < cards[mnj].second) mnj = j;
}
tmp = cards[i]; cards[i]=cards[mnj]; cards[mnj]=tmp;
}
}
Card readCard(){
char s;
int r;
Card ret;
cin >> s;
ret.first = s;
cin >> r;
ret.second = r;
return ret;
}
void printCard(Card c){
cout << (char)c.first;
cout << (int)c.second;
}
int main(void){
int n,isStbl;
Card cardsBub[40], cardsSel[40], tmpCard;
cin >> n;
for (int i=0; i<n; i++){
cardsBub[i] = cardsSel[i] = readCard();
}
bubSort(cardsBub, n);
selSort(cardsSel, n);
for (int i=0; i<n; i++){
printCard(cardsBub[i]);
cout << (i==n-1?"\n":" ");
}
cout << "Stable" << endl;
isStbl = 1;
for (int i=0; i<n; i++){
printCard(cardsSel[i]);
isStbl &= (cardsSel[i]==cardsBub[i]);
cout << (i==n-1?"\n":" ");
}
cout << (isStbl?"Stable":"Not stable") << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
const int mod = 1e9+7;
char s[200100];
int n,ans=1,num;
int main(){
int i,j,k;
scanf("%d",&n);
scanf("%s",s);
for(i=0;i<2*n;i++)
if(!(((s[i]=='W')^num)&1))
num++;
else{
ans=1ll*ans*num%mod;
num--;
}
if(num!=0 || s[0]=='W' || s[2*n-1]=='W')
return cout<<0<<endl,0;
for(i=1;i<=n;i++)ans=1ll*ans*i%mod;
printf("%d\n",ans);
return 0;
} | 0 | 41,123,697 |
# include <stdio.h>
int main(){
int n,i,ans=0,r=0,l=0;
char s[3];
for(;;){
scanf("%d",&n);
if(n==0){
break;
}
for(i=1;i<=n;i++){
scanf("%s",s);
if(s[0]=='l'&&s[1]=='u'){
l=1;
}
if(s[0]=='l'&&s[1]=='d'){
l=0;
}
if(s[0]=='r'&&s[1]=='u'){
r=1;
}
if(s[0]=='r'&&s[1]=='d'){
r=0;
}
if(ans%2==0&&r==1&&l==1){
ans++;
}
if(ans%2!=0&&r==0&&l==0){
ans++;
}
}
printf("%d\n",ans);
ans=0;
r=0;
l=0;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#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)
int main()
{
string s;cin >> s;
sort(ALL(s));
REP(i,SZ(s)-1){
if(s[i]==s[i+1]){
cout << "no" << "\n";
return 0;
}
}
cout << "yes"
<< "\n";
return 0;
} | 0 | 71,911,806 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
string op;
cin >> A >> op >> B;
char c = op.at(0);
if (c=='+') {
cout << A+B << endl;
}
else {
cout << A-B << endl;
}
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define REP(i, n) for(ll i = 1; i < n + 1; i++)
#define PI 3.14159265359
#define EPS 0.0000000001
#define MOD 1000000007
int main(){
ll N;
cin >> N;
ll H[N + 1];
H[0] = 0;
ll moves = 0;
ll movesMax = 0;
REP(i, N){
cin >> H[i];
if(H[i] > H[i - 1]){
moves = 0;
}else{
moves++;
movesMax = max(movesMax, moves);
}
}
cout << movesMax << endl;
return 0;
} | 0 | 3,566,168 |
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int N, A, B;
cin >> N >> A >> B;
int num[3] = { 0,0,0 };
for (int i = 0; i < N; i++) {
int p;
cin >> p;
num[(p > A) + (p > B)]++;
}
cout << min({ num[0], num[1], num[2] }) << endl;
} | #include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
int a,b,c;
cin >> a >> b >> c;
bool f = false;
for(int i = 0; i < b; i++){
if((i * a%b)%b == c){
f = true;
break;
}
}
if(f) puts("YES");
else puts("NO");
} | 0 | 30,169,683 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<ll,ll> P;
#define pb push_back
#define ft first
#define sd second
#define mp make_pair
#define fr(i,n) for(int i=0;i<n;i++)
#define Fr(i,n) for(int i=0;i++<n;)
#define ifr(i,n) for(int i=n-1;i>=0;i--)
#define iFr(i,n) for(int i=n;i>0;i--)
ll hb(ll x){
ll l=-1,r=32,m;
while(r-l>1){
m=(l+r)/2;
if(x<(1<<m)) r=m;
else l=m;
}
return r;
}
int main(){
ll n,k,a,b,ka,k2,ans=0;
ll s[32]={};
vector<P> v[32];
cin>>n>>k;
fr(i,n){
cin>>a>>b;
ka=hb(a);
v[ka].pb(mp(a,b));
s[ka]+=b;
}
ifr(i,32){
if(i==0){ans=max(ans,s[0]);break;}
if(1-((k>>(i-1))&1)) continue;
ka=0;
fr(j,i) ka+=s[j];
ans=max(ans,ka);
ka=1<<(i-1);
fr(j,v[i].size()){
k2=hb(v[i][j].ft-ka);
v[k2].pb(mp(v[i][j].ft-ka,v[i][j].sd));
s[k2]+=v[i][j].sd;
}
}
cout<<ans<<endl;
} | #include <bits/stdc++.h>
#define rep(i, e, n) for (int i = e; i < (n); ++i)
using namespace std;
typedef long long ll;
using P = pair<int,int>;
const ll inf=1000000000007;
int main(){
int n;
cin >> n;
vector<int> a(n);
vector<int> val(1000001,0);
rep(i,0,n) cin >> a[i];
rep(i,0,n) {
int vali=a[i];
for(int j=2; j*j<=vali;j++){
if(vali%j==0){
val[j]++;
vali/=j;
}
while(vali%j==0){
vali/=j;
}
}
if(vali!=1) val[vali]++;
}
bool pair=true;
rep(i,2,1000001){
if(val[i]==n){
cout << "not coprime" << endl;
return 0;
}
if(val[i]>=2) pair=false;
}
if(pair){
cout << "pairwise coprime" << endl;
return 0;
}
cout << "setwise coprime" << endl;
return 0;
} | 0 | 82,340,303 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
double n, k; cin >> n >> k;
double ans = 0;
for(int i=1; i<=n; i++){
double tmp = 1.0/n;
int now = i;
while(now < k){
now *= 2;
tmp /= 2;
}
ans += tmp;
}
printf("%.12f\n", ans);
return 0;
} | #include <bits/stdc++.h>
#define MAX 1000000
#define MOD 1e9
#define pb push_back
#define pairs pair<int, int>
#define vi vector<int>
#define vb vector<bool>
#define vii vector<pairs>
#define lb lower_bound
#define ub upper_bound
#define ll long long
#define endl '\n'
using namespace std;
#define FastInput ios_base::sync_with_stdio(false), cin.tie(NULL);
#define all(x) x.begin(), x.end()
#define read(x) freopen(x, "r", stdin)
#define write(x) freopen(x, "w", stdout)
#define rep(i, a, n) for (int i = a; i < n; i++)
#define REP(i, a, n) for (int i = a; i <= n; i++)
#define inputArray(a,n) rep(i, 0, n) cin >> a[i];
#define copyArray(a,temp,n) rep(i, 0, n) temp[i]=a[i];
#define printArray(a,n) rep(i, 0, n) cout << a[i] << " "; cout << endl;
#define Cases cout << "Case " << ++Case << ": ";
#define __test int tt; int Case=0; cin >> tt; while(tt--)
#define dbgA2(A, n, m) {cout<<"--> "<<#A<<" = \n";rep(i, 0, n){rep(j, 0, n){cout<<A[i][j]<<" ";}cout<<"\n";}cout<<"\n";}
#define dbgA(A, n) {cout<<" --> "<<#A<<" = (";rep(i, 0, n)cout<<A[i]<<" ";cout<<")\n";}
#define dbg(args...) {string sss(#args);sss+=',';cout<<" --> ";debugger::call(all(sss), args);cout<<"\n";}
ll gcd(ll n, ll m) { return m ? gcd(m, n % m) : n; }
ll lcm(ll n, ll m) { return n / gcd(n, m) * m; }
struct debugger {
typedef string::iterator si;
static void call(si it, si ed) {}
template<typename T, typename ... aT>
static void call(si it, si ed, T a, aT... rest) {
string b;
for(; *it!=','; ++it)
if(*it!=' ')
b+=*it;
cout << b << "=" << a << " ";
call(++it, ed, rest...);
}
};
void solve() {
ll n, m, sum = 0, count = 0;
cin >> n >> m;
int arr[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
}
double res = (sum * (1 / (4.0 * m)));
for (int i = 0; i < n; i++) {
if(arr[i] >= res) {
count++;
}
}
if(count >= m) {
cout << "Yes\n";
return;
}
cout << "No\n";
}
int main() {
solve();
} | 0 | 87,991,894 |
#include<iostream>
#include<string>
#include<cmath>
using namespace std;
int main(void){
string st1, st2;
int q, val[1001][1001];
cin >> q;
for(int i=0; i<q; i++){
cin>>st1;
cin>>st2;
for(int j=0; j<=st1.length(); j++){
for(int k=0; k<=st2.length(); k++){
if(j==0 || k==0) val[j][k] = 0;
else{
if(val[j-1][k] == min(st1.length(), st2.length())){
val[j][k] = st1.length();
}else{
if(st1[j-1] == st2[k-1]){
val[j][k] = val[j-1][k-1]+1;
}else{
val[j][k] = max(val[j-1][k], val[j][k-1]);
}
}
}
}
}
cout << val[st1.length()][st2.length()] << "\n";
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int n;
cin >> n;
vector<int> c(n-1), s(n-1), f(n-1);
rep(i,n-1) cin >> c[i] >> s[i] >> f[i];
rep(i,n-1) {
int t = 0;
rep(j,n-i-1) {
if (t < s[i+j]) {
t = s[i+j];
} else if (t%f[i+j] == 0) {
;
} else {
t += f[i+j] - (t%f[i+j]);
}
t += c[i+j];
}
cout << t << endl;
}
cout << 0 << endl;
} | 0 | 64,131,886 |
#include<iostream>
#include<string>
using namespace std;
int main(){
string S;
cin>>S;
int ans1=0;
int ans2=0;
for(int i=0;i<=(int)(S.length()-1);i++){
if(i%2==0){
if(S[i]=='0')ans1++;
}
else{
if(S[i]=='1')ans1++;
}
}
for(int i=0;i<=(int)(S.length()-1);i++){
if(i%2==0){
if(S[i]=='1')ans2++;
}
else{
if(S[i]=='0')ans2++;
}
}
int ans=ans1<ans2?ans1:ans2;
cout<<ans;
return 0;
} | #include <bits/stdc++.h>
#define F first
#define S second
#define MP make_pair
#define pb push_back
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define LCM(a, b) (a) / __gcd((a), (b)) * (b)
#define CEIL(a, b) (a)/(b)+(((a)%(b))?1:0)
#define ln '\n'
using namespace std;
using LL = long long;
using ldouble = long double;
using P = pair<int, int>;
using LP = pair<LL, LL>;
static const int INF = INT_MAX;
static const LL LINF = LLONG_MAX;
static const int MIN = INT_MIN;
static const LL LMIN = LLONG_MIN;
static const int MOD = 1e9 + 7;
static const int SIZE = 200005;
const int dx[] = {0, -1, 1, 0};
const int dy[] = {-1, 0, 0, 1};
vector<LL> Div(LL n) {
vector<LL> ret;
for(LL i = 1; i * i <= n; ++i) {
if(n % i == 0) {
ret.pb(i);
if(i * i != n) ret.pb(n / i);
}
}
sort(all(ret));
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
deque<int> dq;
bool f = true;
for(int i = 0; i < n; ++i) {
int a;
cin >> a;
if(f) {
dq.push_back(a);
f = false;
} else {
dq.push_front(a);
f = true;
}
}
while(!dq.empty()) {
if(n % 2 == 0) {
cout << dq.front() << " ";
dq.pop_front();
} else {
cout << dq.back() << " ";
dq.pop_back();
}
}
cout << endl;
return 0;
} | 0 | 59,479,213 |
#include<bits/stdc++.h>
using namespace std;
const int N=2003;
int n,m,ans,f1[N][N],f2[N][N],f3[N][N],f4[N][N];
char mp[N][N];
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)scanf("%s",mp[i]+1);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
if(mp[i][j]=='.')f1[i][j]=f1[i-1][j]+1,f2[i][j]=f2[i][j-1]+1;
for(int i=n;i;i--)
for(int j=m;j;j--)
if(mp[i][j]=='.')f3[i][j]=f3[i+1][j]+1,f4[i][j]=f4[i][j+1]+1;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
if(mp[i][j]=='.')ans=max(ans,f1[i][j]+f2[i][j]+f3[i][j]+f4[i][j]-3);
printf("%d\n",ans);
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int n; cin >> n;
map<int,int> a;
for(int i=0;i<n;i++){
int time; cin >> time;
a[time]=i+1;
}
for(auto stu:a){
cout << stu.second << " ";
}
} | 0 | 6,793,115 |
#include <iostream>
#include <string>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <queue>
#include <stack>
#include <functional>
#include <bitset>
#include <assert.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef pair<ll,ll> P;
typedef vector<P> vpl;
typedef tuple<ll,ll,ll> tapu;
#define rep(i,n) for(ll i=0; i<(n); i++)
#define REP(i,a,b) for(int i=(a); i<(b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1<<30;
const ll linf = 1LL<<62;
const int MAX = 510000;
ll dy[8] = {0,1,0,-1,1,-1,1,-1};
ll dx[8] = {1,0,-1,0,1,-1,-1,1};
const double pi = acos(-1);
const double eps = 1e-7;
template<typename T1,typename T2> inline bool chmin(T1 &a,T2 b){
if(a>b){
a = b; return true;
}
else return false;
}
template<typename T1,typename T2> inline bool chmax(T1 &a,T2 b){
if(a<b){
a = b; return true;
}
else return false;
}
template<typename T1,typename T2> inline void print2(T1 a, T2 b){cout << a << " " << b << endl;}
template<typename T1,typename T2,typename T3> inline void print3(T1 a, T2 b, T3 c){
cout << a << " " << b << " " << c << endl;
}
const int mod = 1e9 + 7;
int main(){
ll n,k; cin >> n >> k;
vector<int> a(n); rep(i,n) cin >> a[i];
rep(i,n) if(a[i] >= k) a[i] = 0;
sort(rall(a));
while(!a.empty() && a.back() == 0) a.pop_back(), n--;
vector<vector<int>> dp(n+1,vector<int>(k+1,0));
dp[0][0] = 1;
rep(i,n){
rep(j,k+1){
dp[i+1][j] = dp[i][j];
if(j-a[i] >= 0) dp[i+1][j] += dp[i][j-a[i]];
}
}
vector<vector<int>> ep(n+1,vector<int>(k+1,0));
rep(j,k+1) ep[n][j] = 1;
rep(i,n+1) ep[i][0] = 1;
ll ans = 0;
for(ll i=n-1; i>=0; i--){
bool flag = true;
rep(j,k-a[i]){
if(dp[i][j] && ep[i+1][k-j-1] - ep[i+1][k-a[i]-1-j]){
flag = false;
break;
}
}
REP(j,k-a[i],k) if(dp[i][j]) flag = false;
if(flag) ans++;
rep(j,k){
ep[i][j+1] = ep[i][j] + ep[i+1][j+1] - ep[i+1][j];
if(j+1-a[i]==0) ep[i][j+1]++;
else if(j+1-a[i]>0) ep[i][j+1] += ep[i+1][j+1-a[i]]-ep[i+1][j-a[i]];
}
}
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
int main() {
while (1) {
int n, m, p;
cin >> n >> m >> p;
if (!n) return 0;
--m;
vector<int> x(n);
int sum = 0;
for (int i = 0; i < n; ++i) {
cin >> x[i];
sum += x[i];
}
cout << (x[m] ? sum * (100 - p) / x[m] : 0) << "\n";
}
} | 0 | 3,881,348 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < n; i++)
int main(){
int N, M;
cin >> N >> M;
priority_queue<double> p_que;
ll ans = 0;
rep(i, N){
double a;
cin >> a;
p_que.push(a);
}
rep(i, M){
double val = p_que.top();
p_que.pop();
p_que.push(val/2);
}
while(!p_que.empty()){
double val = p_que.top();
p_que.pop();
ll num = val;
ans += num;
}
cout << ans << endl;
return 0;
} | #include<iostream>
using namespace std;
int x[200000], n, a, b, c, d, p, rell, y[200000];
int main() {
while (true) {
cin >> n >> a >> b >> c >> p; if (!n) { break; }
x[0] = p; rell = 0;
for (int i = 1; i < 200000; i++) { x[i] = (x[i - 1] * a + b) % c; }
for (int i = 0; i < n; i++) { cin >> y[i]; }
for (int i = 0; i < 10001; i++) {
if (y[rell] == x[i]) { rell++; }
if (rell == n) { d = i; goto E; }
}
d = -1;
E:;
cout << d << endl;
}
} | 0 | 2,737,237 |
Subsets and Splits