code1
stringlengths 54
12k
| code2
stringlengths 66
12k
| similar
int64 0
1
| __index_level_0__
int64 24
101M
|
|---|---|---|---|
#include <iostream>
#include <utility>
#include <tuple>
#include <vector>
#include <string>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <algorithm>
#include <functional>
#include <climits>
#include <numeric>
#include <queue>
#include <cmath>
#include <iomanip>
#include <array>
#include <string>
#include <stack>
#include <cassert>
#include <memory>
int main() {
int n, k; std::cin >> n >> k;
long long int zero{ n / k};
long long int half{ ((k & 1) == 0 && (n >= k / 2)) ? (n - k / 2) / k + 1 : 0 };
std::cout << zero * zero * zero + half * half * half << '\n';
} | #include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 1000000000000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
int main(){
ll N,K;
scanf("%lld %lld",&N,&K);
if(K%2 == 0){
ll num = 0;
ll num2 = 0;
ll half_K = K/2;
for(ll i = 1; i <= N; i++){
if(i%K == 0){
num++;
}else if(i%(half_K) == 0){
num2++;
}
}
printf("%lld\n",num*num*num+num2*num2*num2);
}else{
ll num = 0;
for(ll i = 1; i <= N; i++){
if(i%K == 0)num++;
}
printf("%lld\n",num*num*num);
}
return 0;
} | 1 | 7,919,583 |
#include <bits/stdc++.h>
using namespace std;
constexpr long long MOD = 1000000007;
using ll = long long;
int main() {
ll n;
cin >> n;
ll a[n];
ll b[n];
for(ll i=0;i<n;i++){
cin >> a[i];
b[i]=a[i]-i;
}
sort(b,b+n);
ll best_b = b[n/2];
ll ans=0;
for(ll i=0;i<n;i++){
ans+=abs(b[i]-best_b);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, c) for (int i = 0; i < (int)c; i++)
using ll = long long;
int main() {
int n;
scanf("%d", &n);
vector<ll> a(n), b(n);
rep(i, n) scanf("%lld", &a[i]), b[i] = a[i] - i;
sort(b.begin(), b.end());
ll x = b[n / 2];
ll res = 0;
rep(i, n) res += max(x - b[i], -x + b[i]);
printf("%lld\n", res);
return 0;
} | 1 | 34,678,596 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define PI M_PI
struct Point {
double x;
double y;
void prt(){
printf("%.8f %.8f\n",x,y);
}
};
void koch(int n,Point p1,Point p2){
if(n==0) return ;
Point s,t,u;
s.x = (2*p1.x + p2.x) / 3;
s.y = (2*p1.y + p2.y) / 3;
t.x = (p1.x + 2*p2.x) / 3;
t.y = (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;
koch(n-1, p1, s);
s.prt();
koch(n-1, s, u);
u.prt();
koch(n-1, u, t);
t.prt();
koch(n-1, t , p2);
}
int main(){
int n;
cin >> n;
Point s,g;
s.x=s.y=g.y=0;
g.x=100;
s.prt();
koch(n,s,g);
g.prt();
} | #include<iostream>
#include<vector>
#include<algorithm>
#include<cmath>
#include <iomanip>
using namespace std;
struct Point
{
double x;
double y;
};
struct Edge{
Point start;
Point end;
void make(Point start,Point end)
{
this->start=start;
this->end=end;
}
};
Point rot60(Point a,Point b)
{
Point rot;
rot.x=b.x-a.x; rot.y=b.y-a.y;
double length=sqrt(rot.x*rot.x+rot.y*rot.y);
double slope=(rot.y)/(rot.x);
double deg=atan(slope)+M_PI/3;
if(a.x>=b.x){
deg+=M_PI;
}
rot.x=length*cos(deg)+a.x;
rot.y=length*sin(deg)+a.y;
return rot;
}
vector<Edge> KochCurve(vector<Edge>& edges,int& count)
{
if(count==0){
return edges;
}else{
int n=edges.size();
vector<Edge> results(n*4);
Point s,t,u;
for(int i=0;i<n;i++){
Point s,t,u;
s.x=(edges[i].end.x+2*edges[i].start.x)/3;
s.y=(edges[i].end.y+2*edges[i].start.y)/3;
t.x=(2*edges[i].end.x+edges[i].start.x)/3;
t.y=(2*edges[i].end.y+edges[i].start.y)/3;
u=rot60(s,t);
results[i*4].make(edges[i].start,s);
results[i*4+1].make(s,u);
results[i*4+2].make(u,t);
results[i*4+3].make(t,edges[i].end);
}
count--;
results=KochCurve(results,count);
return results;
}
}
int main()
{
int n;
cin>>n;
int count=n;
vector<Edge> edges(1);
edges[0].start.x=0; edges[0].start.y=0;
edges[0].end.x=100; edges[0].end.y=0;
edges=KochCurve(edges,count);
for(int i=0;i<edges.size();i++){
cout<<fixed;
cout<<setprecision(8)<< edges[i].start.x<<" "<<edges[i].start.y<<endl;
}
cout<<fixed;
cout<<setprecision(8)<<edges[edges.size()-1].end.x<<" "<<edges[edges.size()-1].end.y<<endl;
return 0;
} | 1 | 37,295,891 |
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef complex<double> point;
#define xx real()
#define yy imag()
#define REP(i, a, b) for(int i = (a); i < (int)(b); i++)
#define REPN(i, a, b) for(int i = (a); i <= (int)(b); i++)
#define FA(it, x) for(__typeof((x).begin()) it = (x).begin(); it != (x).end(); it++)
#define SZ(x) (int)(x).size()
#define BE(x) (x).begin(), (x).end()
#define SORT(x) sort(BE(x))
#define _1 first
#define _2 second
#define x1 gray_cat_x1
#define y1 gray_cat_y1
template<class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
#define file "I1"
const double EPS = 1e-9;
const double PI = acos(-1.);
const int INF = 1e9;
const ll MOD = 1e9 + 7;
const int MAXN = 1e5 + 5;
vi g[MAXN];
int gr[MAXN], prv[MAXN];
int mex[MAXN];
void dfs(int s) {
REP(i, 0, SZ(g[s])) {
int to = g[s][i];
if (to != prv[s]) {
prv[to] = s;
dfs(to);
}
}
REP(i, 0, SZ(g[s])) {
int to = g[s][i];
if (to != prv[s]) {
gr[s] ^= (gr[to] + 1);
}
}
}
void solve(){
int n;
scanf("%d", &n);
REP(i, 1, n) {
int a, b;
scanf("%d%d", &a, &b);
g[a].pb(b);
g[b].pb(a);
}
dfs(1);
if (gr[1]) {
printf("Alice\n");
} else {
printf("Bob\n");
}
}
int main(){
int t = 1;
while(t--){
solve();
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int , int> P2;
typedef pair<pair<int , int> , int> P3;
typedef pair<pair<int , int> , pair<int , int> > P4;
#define PB(a) push_back(a)
#define MP(a , b) make_pair((a) , (b))
#define M3P(a , b , c) make_pair(make_pair((a) , (b)) , (c))
#define M4P(a , b , c , d) make_pair(make_pair((a) , (b)) , make_pair((c) , (d)))
#define repp(i,a,b) for(int i = (int)(a) ; i < (int)(b) ; ++i)
#define repm(i,a,b) for(int i = (int)(a) ; i > (int)(b) ; --i)
const int MC = 100010;
int N;
vector<int> V[MC];
int G[MC];
int dfs(int p , int q){
int z = 0;
for(auto u : V[q]){
if(u == p) continue;
z ^= dfs(q,u) + 1;
}
return z;
}
int main(){
scanf("%d" , &N);
repp(i,1,N){
int x,y;
scanf("%d%d" , &x , &y);
V[x].PB(y);
V[y].PB(x);
}
printf("%s\n" , dfs(-1,1) == 0 ? "Bob" : "Alice");
return 0;
} | 1 | 54,778,543 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
template<class T> using vc = vector<T>;
template<class T> using vvc = vector<vector<T>>;
const ll MOD = 1e9 + 7;
const ll INF = 1e14;
const ld EPS = 1e-11;
const ld PI = acos(-1.0L);
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repr(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repe(i, l, r) for (ll i = (l); i < (r); i++)
#define reper(i, l, r) for (ll i = (r)-1; i >= (l); i--)
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1;} return 0;}
template<class T> bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1;} return 0;}
void init() {cin.tie(0);ios::sync_with_stdio(false);cout << fixed << setprecision(15);
}
int main() {
init();
string s;
cin >> s;
if((ll)s.size()>=4&&s.substr(0,4)=="YAKI")
cout << "Yes" << endl;
else
cout << "No" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
string S;
cin >> S;
string T = "YAKI";
if(equal(T.begin(), T.end(), S.begin()))
cout << "Yes" << endl;
else
cout << "No" << endl;
} | 1 | 86,778,340 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int x1,x2,y1,y2;cin>>x1>>y1>>x2>>y2;
int tmp_x,tmp_y;
tmp_x=x2-x1;
tmp_y=y2-y1;
cout <<x2-tmp_y<<' '<<y2+tmp_x<<' ';
cout <<x1-tmp_y<<' '<<y1+tmp_x<<endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll=long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
#define all(x) x.begin(),x.end()
#define rep(i,j,n) for (long long i = j; i < (long long)(n); i++)
#define _GLIBCXX_DEBUG
#define MOD 1000000007
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
signed main(){
int x1,y1,x2,y2; cin>>x1>>y1>>x2>>y2;
int a=y2-y1;
int b=x2-x1;
cout<<(x2-a)<<" "<<(y2+b)<<" "<<(x1-a)<<" "<<(y1+b)<<endl;
return 0;
} | 1 | 56,655,199 |
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <iomanip>
#include <vector>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <map>
#include <queue>
#include <climits>
#define rep(i,n) for (int i=0;i<(n);i++)
using namespace std;
vector<int> g[200005];
vector<long long> ans;
void dfs(int v, int p = -1) {
for (auto next_v : g[v]) {
if (next_v == p) continue;
ans[next_v] += ans[v];
dfs(next_v, v);
}
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 1;i < n;i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
ans.resize(n + 1);
for (int i = 0;i < q;i++) {
int p, x;
cin >> p >> x;
ans[p] += x;
}
dfs(1);
for (int i = 1;i <= n;i++) {
cout << ans[i] << endl;
}
return 0;
} | #include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<cmath>
#include<cstdio>
#include<queue>
#include<deque>
#include<map>
#include<stack>
#include<set>
#include<tuple>
using namespace std;
typedef pair<int,int> ii;
typedef long long ll;
typedef pair<ll,ll> pll;
typedef unsigned long long int ull;
const int INF=1e9;
const ll MOD=1e9+7;
int dy[]={1,0,-1,0};
int dx[]={0,1,0,-1};
const int MAXN=2e5;
int n,q;
vector<vector<int> > G(MAXN);
vector<bool> visited(MAXN,false);
vector<int> cnt(MAXN,0);
void dfs(int u){
visited[u]=true;
for(auto v:G[u]){
if(!visited[v]){
cnt[v]+=cnt[u];
dfs(v);
}
}
return ;
}
int main(){
cin>>n>>q;
for(int i=0;i<n-1;i++){
int a,b;cin>>a>>b;
a--;b--;
G[a].emplace_back(b);
G[b].emplace_back(a);
}
for(int i=0;i<q;i++){
int p,x;cin>>p>>x;
p--;
cnt[p]+=x;
}
dfs(0);
for(int i=0;i<n;i++){
cout<<cnt[i];
if(i!=n-1) cout<<' ';
}
cout<<endl;
return 0;
} | 1 | 29,725,273 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { std::cout << #a << " = " << a << "\n"; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
template<class T, class V> istream& operator>> (istream& ist, pair<T, V>& p) { return ist >> p.first >> p.second; }
template<class T> ostream& operator<< (ostream& ost, pair<T, T>& p) { return ost << p.first << ", " << p.second; }
template<class T> istream& operator>> (istream& ist, vector<T>& vs) { for(auto& e: vs) ist >> e; return ist; }
typedef long long ll;
int const inf = INT_MAX / 2;
int main() {
int N, K; cin >> N >> K;
vector<int> A(N); cin >> A;
rep(_, min(K, 50)) {
vector<int> acc(N + 1);
rep(i, N) {
acc[max(0, i - A[i])]++;
acc[min(N, i + A[i] + 1)]--;
}
REP(i, 1, N + 1) {
acc[i] += acc[i - 1];
}
rep(i, N) {
A[i] = acc[i];
}
}
rep(i, N) {
if (i) cout << " ";
cout << A[i];
}
cout << "\n";
} | #include <bits/stdc++.h>
using namespace std;
int n,k;
int a[200005],b[200005];
int main(){
cin>>n>>k;
for(int i=0;i<n;++i){
cin>>a[i];
}
if(k>50){
for(int i=0;i<n;++i){
cout<<n<<' ';
}
cout<<'\n';
return 0;
}
for(int i=0;i<k;++i){
memset(b,0,sizeof(b));
for(int i=0;i<n;++i){
int l=max(0,i-a[i]);
int r=min(n-1,i+a[i]);
b[l]++;
if(r+1<n){
b[r+1]--;
}
}
for(int i=1;i<n;++i){
b[i]+=b[i-1];
}
for(int i=0;i<n;++i){
a[i]=b[i];
}
}
for(int i=0;i<n;++i){
cout<<a[i]<<' ';
}
cout<<'\n';
return 0;
} | 1 | 47,298,766 |
#include<cstdio>
using namespace std;
int main(){
int n;
scanf("%d", &n);
int t[n];
int v[n+1];
for (int i = 0; i < n; i++) scanf("%d", &t[i]);
for (int i = 0; i < n; i++) scanf("%d", &v[i]);
v[n] = 0;
int time[n];
time[0] = t[0];
for (int i = 1; i < n; i++) time[i] = time[i-1] + t[i];
double speed = 0.5;
double T = 0.5;
double ans = 0.5 * 0.5 * 0.5;
for (double i = 0.5; i < time[n-1]; i += 0.5){
for (int j = 0; j < n; j++){
if (time[j] > i){
bool flag = false;
for (int k = j; k < n; k++){
if (v[k+1] + (time[k] - i) <= speed){
ans += (speed + speed - 0.5) * 0.5 * 0.5;
speed -= 0.5;
flag = true;
break;
}
}
if (flag) break;
if (speed == v[j]){
ans += speed / 2;
break;
}
else {
}
ans += (speed + speed + 0.5) * 0.5 * 0.5;
speed += 0.5;
break;
}
}
}
printf("%f\n", ans);
} | #include <iostream>
#include <iomanip>
#include <cmath>
#include <vector>
#include <queue>
#include <limits>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>
#include <inttypes.h>
using namespace std;
int main()
{
int32_t N;
scanf("%d", &N);
int32_t t[101];
int32_t T = 0;
for (int32_t i = 0; i < N; i++) {
scanf("%d", &t[i]);
T += t[i];
}
int32_t v[101];
for (int32_t i = 0; i < N; i++) {
scanf("%d", &v[i]);
}
double max_v[40001];
int32_t max_v_index = 0;
for (int32_t i = 0; i < N; i++) {
for (int32_t j = 0; j < 2 * t[i]; j++) {
if (i > 0 && j == 0)
max_v[max_v_index++] = min(v[i - 1], v[i]);
else
max_v[max_v_index++] = v[i];
}
}
max_v[0] = 0;
max_v[2 * T] = 0;
for (int32_t i = 1; i < 2 * T + 1; i++)
max_v[i] = min(max_v[i], max_v[i - 1] + 0.5);
for (int32_t i = 2 * T - 1; i >= 0 ; i--)
max_v[i] = min(max_v[i], max_v[i + 1] + 0.5);
double res = 0;
for (int32_t i = 0; i < 2 * T; i++) {
res += min(max_v[i], max_v[i + 1]) * 0.5;
if (max_v[i] != max_v[i + 1])
res += 0.5 * 0.5 / 2;
}
printf("%.17f\n", res);
return 0;
} | 1 | 29,691,985 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define vi vector<int>
#define inf 1000000100
int main()
{
int n;
cin >> n;
map<char ,int> mp;
while(n--)
{
string str;
cin >> str;
vi alpha(26);
for(int i = 0; str[i]; i++)
{
alpha[str[i] - 'a']++;
}
for(int i = 0; i < 26; i++)
{
if(mp.count((char)('a'+i)))
{
mp[(char)('a'+i)] = min(mp[(char)('a'+i)], alpha[i]);
}
else
{
mp[(char)('a'+i)] = alpha[i];
}
}
}
for(int i = 0; i < 26; i++)
{
if(mp.count((char)('a'+i)))
{
for(int j = 0; j < mp[(char)('a'+i)]; j++)
{
cout << (char)('a'+i);
}
}
}
cout << endl;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <queue>
#include <map>
#define ll long long
using namespace std;
int main(){
int n;
cin>>n;
vector<vector<int>>sv(n,vector<int>(26));
for(int i=0;i<n;i++){
string s;
cin>>s;
for(int j=0;j<s.length();j++){
sv[i][s[j]-'a']++;
}
}
for(int i=0;i<n-1;i++){
for(int j=0;j<26;j++){
sv[i+1][j]=min(sv[i][j],sv[i+1][j]);
}
}
string s="";
for(int j=0;j<26;j++){
char tempchar=j+'a';
for(int k=0;k<sv[n-1][j];k++){
s+=tempchar;
}
}
cout<<s<<endl;
return 0;
} | 1 | 33,771,670 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
int main(){
map<string, int> cards;
int n; cin>>n;
string s;
rep(i,n){
cin>>s;
cards[s]++;
}
int m; cin>>m;
rep(i,m){
cin>>s;
cards[s]--;
}
int ans = 0;
for(auto c: cards){
ans = max(c.second, ans);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define sz(x) (int)x.size()
#define rep(i,n) for(int i = 0; i < n; i++)
#define REP(i, k , n) for(int i = k; i <= n; i++)
typedef long long ll;
const char nl = '\n' ;
const ll MOD = 1e9 + 7;
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0);
int n, h; cin >> n ;
map< string , int> m;
int ans =0;
rep(i,n)
{
string s; cin >> s;
m[s]++;
}
cin >> h;
rep(i, h)
{
string s; cin >> s;
m[s]--;
}
for(auto it = m.begin(); it!=m.end(); it++)
{
ans = max(ans, it->second);
}
cout << ans << nl;
return 0;
} | 1 | 54,769,863 |
#include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<VVI> VVVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef priority_queue<int> PQ_DESC;
typedef priority_queue<int, vector<int>, greater<int>> PQ_ASC;
typedef priority_queue<PII> PQ_DESC_PII;
typedef priority_queue<PII, vector<PII>, greater<PII>> PQ_ASC_PII;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<VVLL> VVVLL;
#define SORT_ASC(c) sort((c).begin(), (c).end())
#define SORT_DESC(c) sort((c).begin(), (c).end(), greater<typeof((c).begin())>())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORL(i,a,b) for(LL i=(a);i<(b);++i)
#define REPL(i,n) FORL(i,0,n)
#define ALL(a) (a).begin(),(a).end()
const double EPS = 1e-10;
const double PI = acos(-1.0);
template<typename T>
void vprint(vector<T> v) {
for(auto x : v) {
cerr << x << " ";
}
cerr << endl;
}
template<typename T>
void vvprint(vector<vector<T>> vv) {
REP(i, vv.size()) {
REP(j, vv[i].size()) {
cerr << vv[i][j] << " ";
}
cerr << endl;
}
}
template <typename Iterator>
inline bool next_combination(const Iterator first, Iterator k, const Iterator last)
{
if ((first == last) || (first == k) || (last == k))
return false;
Iterator itr1 = first;
Iterator itr2 = last;
++itr1;
if (last == itr1)
return false;
itr1 = last;
--itr1;
itr1 = k;
--itr2;
while (first != itr1)
{
if (*--itr1 < *itr2)
{
Iterator j = k;
while (!(*itr1 < *j)) ++j;
iter_swap(itr1,j);
++itr1;
++j;
itr2 = k;
rotate(itr1,j,last);
while (last != j)
{
++j;
++itr2;
}
rotate(k,itr2,last);
return true;
}
}
rotate(first,k,last);
return false;
}
inline double get_time_sec(void){
return static_cast<double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count())/1000000000;
}
template<typename T>
T lcm(T a, T b) {
return (a / __gcd(a, b)) * b;
}
template<typename T>
map<T, T> prime_list(T n) {
map<T, T> ret;
for(T i = 2; i*i <= n; i++) {
if(n % i == 0) {
ret[i] = 0;
while(n % i == 0) {
n /= i;
ret[i]++;
}
}
}
if(n != 1) ret[n]++;
return ret;
}
#define MOD 1000000007
LL mypow(LL a, LL n) {
if(n == 0) return 1;
if(n == 1) return a % MOD;
if(n % 2 == 1) return (a * mypow(a, n-1)) % MOD;
LL t = mypow(a, n/2);
return (t * t) % MOD;
}
LL mycomb(LL n, LL k) {
if(n == 0 || n == k) return 1;
LL x = 1, y = 1;
REP(i, k) {
x = x * (n-i) % MOD;
y = y * (i+1) % MOD;
}
return x * mypow(y, MOD - 2) % MOD;
}
#define INF 1e8
int main(void) {
cin.tie(0); ios::sync_with_stdio(false);
int n;
cin >> n;
VI vr(n), vc(n);
REP(i, n) cin >> vr[i] >> vc[i];
VVI dp(n, VI(n, 0));
REP(i, n-1) dp[i][i+1] = vr[i] * vr[i+1] * vc[i+1];
FOR(w, 2, n) {
REP(l, n) {
int r = l + w;
if(r >= n) continue;
int tmp = INF;
FOR(mid, l, r) tmp = min(tmp, dp[l][mid] + dp[mid+1][r] + vr[l] * vc[mid] * vc[r]);
dp[l][r] = tmp;
}
}
cout << dp[0][n-1] << endl;
} | #include <stdio.h>
int main() {
int n, i, j, k, l, p[101], m[101][101];
scanf("%d", &n);
for ( i = 1; i <= n; i++) {
scanf("%d", &p[i - 1]);
scanf("%d", &p[i]);
}
for ( i = 1; i <= n; i++) {
m[i][i] = 0;
}
for ( l = 2; l <= n; l++) {
for ( i = 1; i <= n - l + 1; i++) {
int j = i + l - 1;
m[i][j] = ( 1 << 21);
for ( k = i; k <= j - 1; k++) {
if ( m[i][j] < m[i][k] + m[k + 1][j] + p[i - 1]*p[k]*p[j]) {
m[i][j] = m[i][j];
} else {
m[i][j] = m[i][k] + m[k + 1][j] + p[i - 1]*p[k]*p[j];
}
}
}
}
printf("%d\n", m[1][n]);
return 0;
} | 1 | 2,974,447 |
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
int main(void){
int n;
cin>>n;
map<int,int> m;
for(int i=0;i<n;i++){
int a;
cin>>a;
m[a]++;
}
ll n1=0,n2=0;
for(auto i:m){
if(i.second>=4){
n1=i.first,n2=i.first;
}else if(i.second>=2){
swap(n1,n2);
n1=i.first;
}
}
cout<<n1*n2<<endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for (int i = 1; i < (int)(n); i++)
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define vout(x) rep(i,x.size()) cout << x[i] << " "
template<class T> bool chmin(T &a, T b) {if(a>b) {a=b;return 1;}return 0;}
template<class T> bool chmax(T &a, T b) {if(a<b) {a=b;return 1;}return 0;}
using namespace std;
using vint = vector<int>;
using vvint = vector<vector<int>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<int,int>;
const int inf = 1e9;
const ll inf_l = 1LL<<62;
const int MAX = 1e5;
int main() {
int n; cin >> n;
map<int,int> ct;
rep(i,n) {
int x; cin >> x;
ct[x]++;
}
vint x;
for (auto itr = ct.begin(); itr != ct.end(); itr++) {
if (itr->second >= 2) x.push_back(itr->first);
}
sort(rall(x));
if (x.size() == 0) cout << 0 << endl;
else if (x.size() == 1) {
if (ct[x[0]] >= 4) cout << (ll)x[0]*x[0] << endl;
else cout << 0 << endl;
}
else if (x.size() >= 2) {
if (ct[x[0]] >= 4) cout << (ll)x[0]*x[0] << endl;
else cout << (ll)x[0]*x[1] << endl;
}
} | 1 | 43,898,420 |
#include<stdio.h>
int main(){
int i,j,k,n,x,count;
while(1){
count=0;
scanf("%d %d",&n,&x);
if( n==0 && x==0) break;
for(i=1;i<=n-2;i++){
for(j=i+1;j<=n-1;j++){
for(k=j+1;k<=n;k++){
if( (i+j+k) == x) count++;
}
}
}
printf("%d\n",count);
}
return 0;
} | #include <cstdio>
using namespace std;
int main() {
while (true) {
int n, x;
scanf("%d %d", &n, &x);
if (!n && !x) return 0;
int res=0;
for (int i=1; i<=n; ++i)
for (int j=i+1; j<=n; ++j) {
int k=x-(i+j);
if (j<k && k<=n)
++res;
}
printf("%d\n", res);
}
} | 1 | 19,211,735 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define repA(i,n) for(int i=n; i>=0; i--)
#define all(x) x.begin(),x.end()
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define sz(a) (ll)(a.size())
typedef long long ll;
typedef long double ld;
const ll mod = 998244353;
void solve() {
int n,k; cin>>n>>k;
vector<int> a(n);
rep(i,n) cin>>a[i];
while(k--) {
vector<int> b(n+1,0);
rep(i,n) {
int from = max(0,i-a[i]);
int to = min(n-1,i+a[i]);
b[from]++;
b[to+1]--;
}
bool changed = false;
rep(i,n) {
changed |= (a[i]!=b[i]);
a[i] = b[i];
b[i+1] += b[i];
}
if(!changed) break;
}
rep(i,n) cout<<a[i]<<' ';
cout<<'\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
#endif
ll t = 1;
rep(i,t) {
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
int main() {
int n,k;
cin >> n >> k;
vector<int> v(n);
rep(i,n) cin >> v[i];
k=min(k,200);
rep(i,k){
vector<int> vec(n+1,0);
rep(i,n){
int x=v[i];
int y=max(0,i-x);
int z=min(n,i+x+1);
vec[y]++; vec[z]--;
}
int now=0;
rep(i,n){
now+=vec[i];
v[i]=now;
}
}
rep(i,n) cout << v[i] << endl;
} | 1 | 2,083,866 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int H,W;
cin >> H >> W;
vector<vector<char>> data(H, vector<char>(W));
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> data.at(i).at(j);
}
}
for (int i = 0; i < H; i++) {
int white = 0;
for (int j = 0; j < W; j++){
if(data.at(i).at(j) == '.') {white++;}}
if(white == W)
{
for(int j = 0; j < W; j++) {
data.at(i).at(j) = 'k';}
}
}
for (int j = 0; j < W; j++) {
int white = 0;
for (int i = 0; i < H; i++){
if(data.at(i).at(j) != '#') {white++;}}
if(white == H)
{
for(int i = 0; i < H; i++) {
data.at(i).at(j) = 'k';}
}
}
for (int i = 0; i < H; i++) {
int white = 0;
for (int j = 0; j < W; j++) {
if(data.at(i).at(j) != 'k') {
cout << data.at(i).at(j);} else {white++;}
}
if(white != W){cout << endl;}
}
} | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long LL;
int main() {
int H, W; cin >> H >> W;
vector<string> ss(H);
for (int i = 0; i < H; ++i) cin >> ss[i];
vector<bool> br(H, true), bc(W, true);
for (int r = 0; r < H; ++r) {
for (int c = 0; c < W; ++c) {
if (ss[r][c] == '#') {
br[r] = false, bc[c] = false;
}
}
}
for (int r = 0; r < H; ++r) {
if (br[r]) continue;
for (int c = 0; c < W; ++c) {
if (bc[c]) continue;
cout << ss[r][c];
}
cout << endl;
}
} | 1 | 90,573,182 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
long a[n];
for(int i=0;i<n;i++)cin >> a[i];
long dai = 0;
for(int i=1;i<n;i++){
if(a[i] >= a[i-1]){
continue;
}else{
dai += a[i-1] - a[i];
a[i] = a[i-1];
}
}
cout << dai << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int n;
while (cin >> n) {
long long stool = 0;
int prev = 0;
for (int i = 0; i < n; ++i) {
int aux;
cin >> aux;
if (aux <= prev) {
stool += (prev - aux);
} else {
prev = aux;
}
}
cout << stool << endl;
}
return 0;
} | 1 | 31,743,560 |
#include <bits/stdc++.h>
typedef long long lint;
using namespace std;
struct loop_info {
lint loop_len;
lint prefix_len;
lint unit;
};
lint n, x, m;
lint f(lint z) {
return z * z % m;
}
lint simple_solve(lint start, lint k) {
lint now = start;
lint res = 0;
for (int i = 0; i < k; i++) {
res += now;
now = f(now);
}
return res;
}
loop_info get_loop() {
vector<lint> appear_time(m, -1);
lint now = x;
lint time = 0;
loop_info res;
while (true) {
if (appear_time[now] == -1) {
appear_time[now] = time;
time++;
now = f(now);
} else {
res.loop_len = time - appear_time[now];
res.prefix_len = appear_time[now];
res.unit = simple_solve(now, res.loop_len);
return res;
}
}
}
int main() {
cin >> n >> x >> m;
auto loop = get_loop();
if (n < loop.prefix_len) {
cout << simple_solve(x, n) << endl;
} else {
lint loop_num = (n - loop.prefix_len) / loop.loop_len;
lint rem = n - loop_num * loop.loop_len;
lint ans = simple_solve(x, rem) + loop.unit * loop_num;
cout << ans << endl;
}
} | #include<map>
#include<set>
#include<cmath>
#include<climits>
#include<vector>
#include<queue>
#include<iostream>
#include<iomanip>
#include<algorithm>
#include<unordered_map>
#define mod 1000000007
#define mo 998244353
using namespace std;
#define LL long long int
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
LL N , x , M;
cin >> N >> x >> M;
vector<LL> arr;
set<LL> hash;
LL repeating=-1;
while(hash.find(x)==hash.end())
{
arr.push_back(x) ;
hash.insert(x);
x=(x*x)%M;
}
repeating=x;
if(arr.size() >=N )
{
LL sum=0;
for(LL i=0;i<N;i++)
{
sum = (sum + arr[i]);
}
cout<<sum<<endl;
}
else
{
LL s=0;
for(auto it:arr)
s+=it;
LL sum = 0;
bool ok = true;
LL index= -1;
for(LL i=0;i<arr.size();i++)
{
if(arr[i] == repeating)
{
ok=false;
index=i;
sum=arr[i];
}
else if(!ok)
{
sum+=arr[i];
}
}
LL M=arr.size()-index;
N=N-arr.size();
s= s + sum*(N/M);
for(LL i=index ;i<index+(N%M);i++)
{
s= s+ arr[i];
}
cout<<s<<endl;
}
} | 1 | 21,700,130 |
#include <iostream>
#include <vector>
using namespace std;
const int INF = 1001001001;
int main(){
int n;
cin >> n;
vector<int> rnum(n+1);
for(int i = 0; i < n; i++){
cin >> rnum[i] >> rnum[i+1];
}
vector<vector<int>> memo(n, vector<int>(n, INF));
for(int i = 0; i < n; i++) memo[i][i] = 0;
for(int i = n-1; i >= 0; i--){
for(int j = i; j < n; j++){
for(int k = i; k+1 < n; k++){
if(memo[i][j] > memo[i][k] + memo[k+1][j] + rnum[i]*rnum[k+1]*rnum[j+1]){
memo[i][j] = memo[i][k] + memo[k+1][j] + rnum[i]*rnum[k+1]*rnum[j+1];
}
}
}
}
cout << memo[0][n-1] << endl;
return 0;
} | #include <iostream>
using namespace std;
int m[1000][1000];
int maxchainorder(int p[],int a){
int n=a;
for(int i=1;i<=n;i++){
m[i][i]=0;
}
for(int l=2;l<=n;l++){
for(int i=1;i<=n-l+1;i++){
int j=i+l-1;
m[i][j]=100000000;
for(int k=i;k<=j-1;k++){
int q=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
if(q<m[i][j]){
m[i][j]=q;
}
}
}
}
return m[1][n];
}
int main(){
int n,p[100000];
cin>>n;
for(int i=0;i<n;i++){
cin>>p[i]>>p[i+1];
}
cout<<maxchainorder(p,n)<<endl;
return 0;
} | 1 | 74,354,556 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define FOR(i,n,m) for(int i=(int)(n); i<=(int)(m); i++)
#define RFOR(i,n,m) for(int i=(int)(n); i>=(int)(m); i--)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define RITR(x,c) for(__typeof(c.rbegin()) x=c.rbegin();x!=c.rend();x++)
#define setp(n) fixed << setprecision(n)
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 (a>b) { a=b; return 1; } return 0; }
#define ld long double
#define ll long long
#define vll vector<ll>
#define vi vector<int>
#define pll pair<ll,ll>
#define pi pair<int,int>
#define all(a) (a.begin()),(a.end())
#define rall(a) (a.rbegin()),(a.rend())
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define ins insert
using namespace std;
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int n,k; cin>>n>>k;
ll ans=0;
ans+=(ll)(n/k)*(n/k)*(n/k);
if (k%2==0){
ll c = (n+k/2)/k;
ans+=c*c*c;
}
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<(n); ++i)
#define chmin(x,y) x = min(x,y)
#define chmax(x,y) x = max(x,y)
using namespace std;
using Graph = vector<vector<int>>;
typedef long long ll;
typedef pair<int, int> P;
const int inf = 1 << 21;
const ll INF = 1LL << 60;
const ll mod = 1e9+7;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
int main(){
ll n, k;
cin >> n >> k;
if (k%2){
ll tmp = n/k;
cout << tmp*tmp*tmp << endl;
}else{
ll htmp = 2 * n/k;
ll tmp = n/k;
cout << tmp*tmp*tmp + (htmp-tmp)*(htmp-tmp)*(htmp-tmp) << endl;
}
return 0;
} | 1 | 64,634,784 |
#include <bits/stdc++.h>
using namespace std;
using pp=pair<int, int>;
int main() {
int K, S, C=0;
cin >> K >> S;
for (int x=0; x<=min(K, S); x++) {
for (int y=0; y<=min(K, S); y++) {
if (S-(x+y)>=0 && S-(x+y)<=K) {
C++;
}
}
}
cout << C << endl;
} | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
#define repr(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) for(int i=0;i<n;i++)
#define invrepr(i,a,b) for(int i=b-1;i>=a;i--)
#define invrep(i,n) invrepr(i,0,n)
#define repitr(itr,a) for(auto itr=a.begin();itr!=a.end();++itr)
#define P pair<int,int>
const int MOD=1e9+7;
const int INF=2e9;
const double PI=acos(-1);
int main() {
ios_base::sync_with_stdio(false);
int k,s;
cin >> k >> s;
int ans=0;
rep(x,k+1) {
rep(y,k+1) {
int z=s-x-y;
if (z>=0 && z<=k) ++ans;
}
}
cout << ans << endl;
return 0;
} | 1 | 39,486,704 |
#include <bits/stdc++.h>
#define rt0 return 0
#define rep(i,n) for(int i=0;i<n;i++)
#define repn(i,n) for(int i=1;i<=n;i++)
#define replet(c) for(char c='a';c<='z';c++)
#define LL long long
#define pii pair <int,int>
#define pb push_back
#define fi first
#define se second
#define mpr make_pair
#define sqr(a) ((a)*(a))
using namespace std;
const LL MOD=1e9+7;
int main()
{
int a,b,c;
cin>>a>>b>>c;
if(a==b&&b==c) puts("Yes");
else puts("No");
rt0;
} | #include <iostream>
#include <string>
#include <cmath>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<iomanip>
#define _USE_MATH_DEFINES
#include <math.h>
#include <functional>
using namespace std;
#define rep(i,x) for(ll i=0;i<x;i++)
#define repn(i,x) for(ll i=1;i<=x;i++)
typedef long long ll;
const ll INF = 1e17;
const ll MOD =998244353;
const ll MAX = 1000001;
ll max(ll a, ll b) {
if (a > b) { return a; }
return b;
}
ll min(ll a, ll b) {
if (a > b) { return b; }
return a;
}
ll gcd(ll a, ll b) {
if (b == 0) { return a; }
if (a < b) { return gcd(b, a); }
return gcd(b, a%b);
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) *b;
}
struct edge {
ll ind;
ll fr;
ll to;
ll d;
};
int main() {
ll A, B, C;
cin >> A >> B >> C;
if (A == B && B == C) { cout << "Yes"; }
else { cout << "No"; }
system("PAUSE");
} | 1 | 1,405,259 |
#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, c;
cin >> a >> b >> c;
int ans;
if (a == b) ans = c;
if (a == c) ans = b;
if (c == b) ans = a;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define INF 1001001001
#define LINF 1001001001001001001
#define MOD 1000000007
#define MOD2 998244353
template<class T,class U>bool chmax(T &a, const U &b){if(a<b){a=b;return 1;}return 0;}
template<class T,class U>bool chmin(T &a, const U &b){if(b<a){a=b;return 1;}return 0;}
#define rep(i,n) for(int i=0,_i=(n);i<_i;++i)
#define rep1(i,a,b) for(int a_=(a),b_=(b),i=a_;i<b_;++i)
#define repr(i,n) for(int _i=(n),i=_i;i>0;--i)
#define db(x) cerr<<#x<<" = "<<x<<" ";
#define db2(x,y) cerr<<"("<<#x<<", "<<#y<<") = ("<<x<<", "<<y<<") ";
#define db3(x,y,z) cerr<<"("<<#x<<", "<<#y<<", "<<#z<<") = ("<<x<<", "<<y<<", "<<z<<") ";
#define ln cout<<endl;
#define all(a) (a).begin(),(a).end()
#define dig(n) to_string(n).length()
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define se second
#define fi first
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<pii,pii> ppii;
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b){return (a*b)/gcd(a,b);}
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
int main(){
bool flag=false;
ll ans=0,sum=0;
int a,b,c;
cin>>a>>b>>c;
if(a==b)cout<<c<<endl;
else if(b==c)cout<<a<<endl;
else cout<<b<<endl;
return 0;
} | 1 | 23,452,023 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
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;
bool conditions(string &s) {
if (s[0] != 'A') {
return false;
}
s[0] = 'a';
int n = s.length();
int cnt = 0;
for (int i = 2; i <= n - 2; i++) {
if (s[i] == 'C') {
cnt++;
s[i] = 'c';
}
}
if (cnt != 1) {
return false;
}
for (int i = 0; i < n; i++) {
if (isupper(s[i])) {
return false;
}
}
return true;
}
int main() {
string s; cin >> s;
if (conditions(s)) {
cout << "AC" << endl;
} else {
cout << "WA" << endl;
}
return 0;
} | #include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<utility>
#include<tuple>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define BIL ((ll)1e9)
#define MOD ((ll)1e9+7)
#define INF (1LL<<60)
#define inf (1<<29)
int main(int argc,char* argv[]){
string s;
cin >> s;
bool ans=true,ccheck=false;
for(int i=0;i<s.size();i++){
if(i==0){
if(s[i]!='A'){
ans=false;
break;
}
}else if(i>=2 && i<=s.size()-2 && s[i]=='C'){
if(ccheck){
ans = false;
break;
}else{
ccheck=true;
}
}else{
if(isupper(s[i])){
ans=false;
break;
}
}
}
if(ans && ccheck)cout << "AC" << endl;
else cout << "WA" << endl;
return 0;
} | 1 | 6,122,515 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define eb emplace_back
#define mt make_tuple
#define all(x) (x).begin(), (x).end()
#define MOD 1000000007
typedef long long ll;
typedef pair <int, int> ii;
typedef pair <ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef long double ld;
const ll INF=LLONG_MAX;
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0);
int x; cin >> x;
if(x<1200)cout << "ABC";
else if(x<2800)cout << "ARC";
else cout << "AGC";
} | #include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
#include<cmath>
#include<cstdio>
#include<tuple>
#include<bitset>
using namespace std;
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
#define ALL(x) x.begin(),x.end()
#define ll long long
const int inf=1000000007;
const int MOD=1000000007;
signed main(){
int r;cin>>r;
if(r<1200){
cout<<"ABC";
}
else if(r<2800)cout<<"ARC";
else cout<<"AGC";
cout<<endl;
return 0;
} | 1 | 23,631,725 |
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#define MAXN 100001
#define NIL -1
#define INIFITY 1 << 30
using namespace std;
int n;
int len = 1;
int L[MAXN];
vector<int> A;
void longetIncreasingSubsequence(){
fill(L, L+n+1, 0);
L[0] = A[0];
for (int i = 0; i < n; ++i) {
if (L[len-1] < A[i]){
L[len++] = A[i];
} else {
int *j = lower_bound(L, L+len, A[i]);
*j = A[i];
}
}
}
int main(){
scanf("%d", &n);
int a;
for (int i = 0; i < n; ++i) {
scanf("%d", &a);
A.push_back(a);
}
longetIncreasingSubsequence();
printf("%d\n", len);
} | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <string>
#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <algorithm>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
#define INF 922337203685477580
#define IINF (1<<21)
typedef long long ll;
ll dp[100100];
int N;
int main() {
cin >> N;
REP(i, N + 100) {
dp[i] = INF;
}
REP(_, N) {
ll in;
cin >> in;
*lower_bound(dp, dp + N, in) = in;
}
int cnt = 0;
REP(i, N) {
if (dp[i] < INF) cnt++;
}
cout << cnt << endl;
return 0;
} | 1 | 56,854,847 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int N, M;
cin >> N >> M;
int ans;
ans = ((N - M) * 100 + M * 1900);
for (int i = 0; i < M; i++)
{
ans *= 2;
}
cout << ans << endl;
}
int main() {
solve();
return 0;
} | #include <bits/stdc++.h>
#include <chrono>
using namespace std;
using ll = long long;
using ld = long double;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repl(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define rep2l(i, s, n) for (ll i = (ll)(s); i < (ll)n; i++)
int main() {
int N, M;
cin >> N >> M;
int T = 1900*M + 100*(N-M);
rep(i, M) {
T *= 2;
}
cout << T << endl;
} | 1 | 78,426,246 |
#if debug
#include<iostream>
using namespace std;
int H=0;
int A[2000000+2];
void maxHeapify(int i){
int l=2*i;
int r=2*i+1;
int largest;
if(l<=H&&A[l]>A[i]){
largest=l;
}
else
largest=i;
if(r<=H&&A[r]>A[i])
largest=i;
if(largest!=i){
swap(A[largest],A[i]);
maxHeapify(largest);
}
}
int extract(){
int maxv;
if(H<1) return -1e9;
maxv=A[1];
A[1]=A[H--];
maxHeapify(1);
return maxv;
}
void increaseKey(int i,int key){
if(key<A[i]) return;
A[i]=key;
while(i>1&&A[i/2]<A[i]){
swap(A[i/2],A[i]);
i/=2;
}
}
void insert(int key){
H++;
A[H]=-1e9;
increaseKey(H,key);
}
#include<string>
int main(){
int key;
string s;
while(cin>>s){
if(s=="insert"){
cin>>key;
insert(key);
}
else if(s=="extract"){
cout<<extract()<<endl;
}
else
break;
}
return 0;
}
#endif
#include<iostream>
#include<queue>
using namespace std;
int main(){
char s[20];
priority_queue<int> que;
while(1){
cin>>s;
if(s[0]=='e'&&s[1]=='n') break;
if(s[0]=='i'){
int key;
cin>>key;
que.push(key);
}
else if(s[0]=='e'){
cout<<que.top()<<endl;
que.pop();
}
}
} | #include <iostream>
using namespace std;
struct Heap {
int *heapTable;
int length;
int curr;
Heap () {
this->heapTable = new int[20000001];
this->length = 0;
this->curr = 1;
}
void add (int valor) {
this->heapTable[this->curr] = valor;
this->curr++;
this->length++;
}
void bottomUp() {
if (this->length > 1) {
int k = this->length;
int v = this->heapTable[k];
bool heapConfirm = false;
while (!heapConfirm && k > 1) {
int j = k / 2;
if (v <= this->heapTable[j]) {
heapConfirm = true;
} else {
this->heapTable[k] = this->heapTable[j];
this->heapTable[j] = v;
k = j;
}
}
}
}
void upDown() {
int k = 1;
int v = this->heapTable[k];
bool heapConfirm = false;
while (!heapConfirm) {
int j = 2 * k;
if (j < this->curr) {
if (this->heapTable[j] < this->heapTable[j+1]) {
j = j + 1;
}
} if (v >= this->heapTable[j]) {
heapConfirm = true;
} else {
this->heapTable[k] = this->heapTable[j];
k = j;
}
}
this->heapTable[k] = v;
}
void extract () {
int aux = this->heapTable[1];
this-> heapTable[1] = this->heapTable[length];
this->heapTable[length] = 0;
this->curr--;
this->length--;
cout << aux << endl;
}
};
int main () {
Heap *heap = new Heap();
bool stop = false;
while (!stop) {
string action = "";
int valor = 0;
cin >> action;
if (action == "end") {
stop = true;
}
else if (action == "insert") {
cin >> valor;
heap->add(valor);
heap->bottomUp();
} else {
heap->extract();
heap->upDown();
}
}
} | 1 | 51,363,252 |
#include <iostream>
using namespace std;
int main() {
int X;
int Y;
cin >> X >> Y;
for (int i = 0; i <= X; i++) {
if (2 * i + 4 * (X - i) == Y) {
cout << "Yes" << endl;
exit(0);
}
}
cout << "No" << endl;
} | #include<bits/stdc++.h>
#define ll long long
#define FI freopen("input.txt","r",stdin)
#define FO freopen("output.txt","w",stdout)
#define PrintCase(i) printf("Case %d: ",i)
#define sc(a) scanf("%d",&a)
#define scl(a) scanf("%lld",&a)
#define rep(i,n) for(int i=0;i<n;i++)
#define pb push_back
#define MAX 1000000
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define endl "\n"
using namespace std;
bool isPrime(ll a)
{
for(ll i=2;i*i<=a;i++)
if(a%i==0)
return false;
return true;
}
bool isPowerOfTwo(ll a)
{
if(a==1)
return true;
if(a&1)
return false;
while(a)
{
a/=2;
if(a!=1 && a&1)
return false;
if(a==1)
return true;
}
return true;
}
ll gcd(ll a, ll b)
{
if(a<0 || b<0)
{
a = abs(a);
b = abs(b);
}
if(a<b)
swap(a,b);
if(a%b==0 || b==0)
return b;
else
return gcd(b,a%b);
}
ll lcm(ll a, ll b)
{
return (a*b)/gcd(a,b);
}
ll power(ll base, ll exponent)
{
ll ans = 1;
for(ll i=1;i<=exponent;i++)
ans*=base;
return ans;
}
bool isPowerOfX(ll x, ll value)
{
if(value==1)
return true;
while(value)
{
value/=x;
if(value%x && value!=1)
return false;
}
return true;
}
ll X_or(ll for1, ll for2, ll value)
{
ll arr[7];
arr[3] = for1^for2;
arr[4] = arr[3]^for2;
arr[5] = arr[4]^arr[3];
cout<<arr[3]<<" "<<arr[4]<<" "<<arr[5]<<" ..... \n";
if(value%3==0)
{
return arr[3];
}
else
{
ll ret = ((value%3)==1)?arr[4] : arr[5];
return ret;
}
}
ll X_nor(ll for1, ll for2, ll value)
{
ll arr[7];
arr[3] = ~(for1^for2);
if(arr[3]<0)
arr[3]*=(-1);
arr[4] = ~(arr[3]^for2);
if(arr[4]<0)
arr[4]*=(-1);
arr[5] = ~(arr[3]^arr[4]);
if(arr[5]<0)
arr[5]*=(-1);
cout<<arr[3]<<" "<<arr[4]<<" "<<arr[5]<<" ..... \n";
if(value%3==0)
{
return arr[3];
}
else
{
ll ret = (value%3==1)? arr[4] : arr[5];
return ret;
}
}
int main()
{
ll x,y;
cin>>x>>y;
(y>=(2*x) && y<=(4*x) && !(y&1))?cout<<"Yes\n":cout<<"No\n";
return 0;
} | 1 | 55,273,526 |
#include<iostream>
#include<string>
#include<algorithm>
#include<bits/stdc++.h>
#include<math.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); i++)
#define rep1(i,n) for(int i = 1; i < (n); i++)
int main(){
int n, j;
cin >> n;
int d[n];
rep(i,n) cin >> d[i];
int ans = 0;
rep(i,n){
for(j=i+1; j<n; j++){
ans += d[i]*d[j];
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int n;cin>>n;
vector<int> vc;
int total= 0;
for(int i=0;i<n;i++){
int item;cin >> item;
vc.push_back(item);
}
for(int i=0;i<n;i++){
for(int j=0;j<i;j++){
total+=vc[i]*vc[j];
}
}
cout << total;
} | 1 | 57,820,188 |
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <map>
#include <numeric>
#include <cmath>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <complex>
#include <string.h>
#include <unordered_set>
#include <unordered_map>
#include <bitset>
#include <iomanip>
#include <sys/time.h>
#include <random>
using namespace std;
#define endl '\n'
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define UNIQ(v) (v).erase(unique((v).begin(), (v).end()), (v).end())
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
typedef complex<double> comp;
typedef vector< vector<ld> > matrix;
struct pairhash {
public:
template<typename T, typename U>
size_t operator()(const pair<T, U> &x) const {
size_t seed = hash<T>()(x.first);
return hash<U>()(x.second) + 0x9e3779b9 + (seed<<6) + (seed>>2);
}
};
const int inf = 1e9 + 9;
const ll mod = 1e9 + 7;
const double eps = 1e-8;
const double pi = acos(-1);
int k, n;
int a[200100];
int solve() {
int d = 0;
for (int i = 0; i < n-1; i++) {
d = max(d, a[i+1] - a[i]);
}
d = max(d, a[0]+k-a[n-1]);
return k - d;
}
void input() {
cin >> k >> n;
for (int i = 0; i < n; i++) cin >> a[i];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
input();
cout << solve() << endl;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll k, n;
cin>> k >> n;
vector<ll> a(2*n);
vector<ll> dis(n+1);
for(int i=0; i<n; i++){
cin>>a[i];
a[i+n] = a[i]+k;
}
ll ans = 1e18;
for(int i=0; i<n; i++){
ans = min(ans, abs(a[i+n-1] - a[i]));
}
cout<< ans <<endl;
return 0;
} | 1 | 18,008,599 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define all(x) (x).begin(),(x).end()
#define endl "\n"
using ll = long long;
using P = pair<int,int>;
using mp = map<int,int>;
const int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
int a, b, c, d;
cin >> a >> b >> c >> d;
if(abs(a - c) <= d || (abs(a-b) <= d && abs(b-c) <= d)) {
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int MAX = 200001;
const int MOD = 1000000007;
int 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;
}
}
int COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int modpow(int a, int n, int mod) {
int res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
signed main() {
int a,b,c,d;
cin>>a>>b>>c>>d;
if(abs(a-c)<=d||(abs(a-b)<=d&&abs(b-c)<=d))cout<<"Yes";
else cout<<"No";
} | 1 | 87,958,482 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
cout << (n*(n+1))/2 << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define REP(i,a,b) for(inti=a;i<=b;i++)
#define MOD 1000000009
typedef long long int ll;
typedef vector<int>vi;
typedef pair<int,int>pi;
int main()
{
int n ;
cin>>n;
cout<<n*(n+1)/2<<endl;
return 0;
} | 1 | 38,795,591 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a , b , c;
cin >> a;
cin >> b;
cin >> c;
if ((a + b) >= c){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
ll GetDigit(ll num){ return log10(num)+1; }
int main()
{
int a, b, c;
cin >> a >> b >>c;
if(a+b >= c) cout << "Yes" << endl;
else cout <<"No" << endl;
return 0;
} | 1 | 12,202,272 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
string N;
int K;
cin >> N >> K;
int L = N.length();
if (L < K) {
cout << 0 << endl;
return 0;
}
string A(L, '0');
int ans = 0;
switch (K) {
case 1:
for (int i = 0; i < L; i++) {
A = string(L, '0');
for (char a = '1'; a <= '9'; a++) {
A[i] = a;
if (A <= N) ans++;
}
}
break;
case 2:
for (int j = 1; j < L; j++) {
for (char a = '1'; a <= '9'; a++) {
A[0] = a;
for (char b = '1'; b <= '9'; b++) {
A[j] = b;
if (A <= N) ans++;
A[j] = '0';
}
}
}
ans += (L - 1) * (L - 2) / 2 * 9 * 9;
break;
case 3:
for (int j = 1; j < L; j++) {
for (int k = j + 1; k < L; k++) {
for (char a = '1'; a <= '9'; a++) {
A[0] = a;
for (char b = '1'; b <= '9'; b++) {
A[j] = b;
for (char c = '1'; c <= '9'; c++) {
A[k] = c;
if (A <= N) ans++;
A[k] = '0';
}
A[j] = '0';
}
}
}
}
ans += (L - 1) * (L - 2) * (L - 3) / 6 * 9 * 9 * 9;
}
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
long long MOD = 10000000000 + 7;
int main(){
cout << setprecision(10);
string S; cin >> S;
int K; cin >> K;
int N; N = S.size();
vector<vector<ll>> dp1(N,vector<ll>(K+1,0));
vector<vector<ll>> dp2(N,vector<ll>(K+1,0));
int d0 = S[0] - '0';
for(int k = 0; k <= d0; k++){
if(k < d0){
if(k != 0){
dp1[0][1]++;
} else {
dp1[0][0]++;
}
} else {
dp2[0][1]++;
}
}
for(int i = 0; i < N-1; i++){
int d = S[i+1] - '0';
for(int k = 0; k <= d; k++){
if(k < d){
for(int j = 0; j <= K; j++){
if(k==0){
dp1[i+1][j] += dp2[i][j];
} else {
if(j+1<=K) dp1[i+1][j+1] += dp2[i][j];
}
}
} else {
for(int j = 0; j <= K; j++){
if(k==0){
dp2[i+1][j] += dp2[i][j];
} else {
if(j+1<=K) dp2[i+1][j+1] += dp2[i][j];
}
}
}
}
}
for(int i = 0; i < N-1; i++){
int d = S[i+1] - '0';
for(int j = 0; j <= K; j++){
for(int k = 0; k <= 9; k++){
if(k==0){
dp1[i+1][j] += dp1[i][j];
} else {
if(j+1<=K) dp1[i+1][j+1] += dp1[i][j];
}
}
}
}
cout << dp1[N-1][K] + dp2[N-1][K] << endl;
} | 1 | 54,543,006 |
#include <iostream>
#include <iomanip>
#include <cmath>
#include <vector>
#include <queue>
#include <limits>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
#define MAX_N (100010)
int main()
{
int N, M;
scanf("%d%d", &N, &M);
int sum_prev = 0;
map<int, int> mods;
mods[0] = 1;
for (int i = 0; i < N; i++) {
int A;
scanf("%d", &A);
int sum = (A + sum_prev) % M;
mods[sum]++;
sum_prev = sum;
}
ll res = 0;
for (auto iter = mods.begin(); iter != mods.end(); iter++)
res += (ll)iter->second * (ll)(iter->second - 1) / 2LL;
printf("%lld\n", res);
return 0;
} | #include <bits/stdc++.h>
using ll=long long;
using namespace std;
ll INF=1000000000000000;
ll mod=1000000007;
ll i,j,k,l;
vector<ll> sum;
void pre_process(vector<ll> &a,vector<ll> &s){
ll n=(ll)a.size();
s.assign(n+1,0);
for(i=0;i<n;i++){
s[i+1]=s[i]+a[i];
}
}
ll query(ll i,ll j,vector<ll> &s){
return (s[j]-s[i]);
}
int main(){
ll n,m;cin>>n>>m;
vector<ll> a(n);
for(i=0;i<n;i++){
cin>>a[i];
}
pre_process(a,sum);
for(i=0;i<=n;i++){
sum[i]%=m;
}
sort(sum.begin(),sum.end());
ll same_mod=1;
vector<ll> same;
for(i=0;i<n;i++){
if(sum[i]==sum[i+1]){
same_mod++;
if(i==n-1){same.push_back(same_mod);}
}else{
same.push_back(same_mod);
same_mod=1;
}
}
ll ans=0;
for(i=0;i<same.size();i++){
ans+=same[i]*(same[i]-1)/2;
}
cout<<ans<<endl;
return 0;
} | 1 | 81,866,544 |
#include <bits/stdc++.h>
using namespace std;
#define ln '\n'
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define FOR(i, a, b) for (int i = (a); i <= (int)(b); ++i)
#define FORR(i, a, b) for (int i = (a); i >= (int)(b); --i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
typedef vector<P> VP;
typedef vector<PL> VPL;
typedef vector<string> VS;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
VP a(n);
REP(i, n) {
cin >> a[i].first;
a[i].second = i;
}
sort(ALL(a), greater<P>());
REP(i, n) {
if (i == a[0].second)
cout << a[1].first << ln;
else
cout << a[0].first << ln;
}
return 0;
} | #include <iostream>
#include<vector>
#include<algorithm>
#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 srep(i,s,t) for (int i = s; i < t; i++)
#define rng(a) a.begin(),a.end()
using ll = long long;
using namespace std;
int main() {
int n;
cin>>n;
vector<int>a(n);
vector<int>b(n);
rep(i,n){
cin>>a[i];
b[i] = a[i];
}
sort(rng(b));
rep(i,n){
if(a[i] == b[n-1]){
cout<<b[n-2]<<endl;
}
else cout<<b[n-1]<<endl;
}
return 0;
} | 1 | 16,530,105 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<deque>
#include<cmath>
#include<map>
#include<cstring>
#include<iomanip>
using namespace std;
typedef long long ll;
const int INF = 1e9 + 6;
const ll MOD = 1e9 + 7;
const ll LLINF = 1LL<<60;
#define P pair<int, int>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
const int MAX_N = 110;
const int MAX_K = 5;
ll dp[MAX_N][2][MAX_K];
int main() {
string N; cin >> N;
vector<int>n;
int K; cin >> K;
int Nlen = N.size();
rep(i, Nlen) n.pb(N[i] - '0');
dp[0][0][0] = 1;
rep(i, Nlen) {
rep(smaller, 2) {
rep(count0, K + 1) {
rep(x, 10) {
if(!smaller && x > n[i])continue;
dp[i + 1][smaller || (x < n[i])][count0 + (x != 0)] += dp[i][smaller][count0];
}
}
}
}
cout << dp[Nlen][0][K] + dp[Nlen][1][K] << endl;
} | #include <stdint.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
using default_counter_t = int64_t;
#define let auto const&
#define overload4(a, b, c, d, name, ...) name
#define rep1(n) \
for (default_counter_t i = 0, end_i = default_counter_t(n); i < end_i; ++i)
#define rep2(i, n) \
for (default_counter_t i = 0, end_##i = default_counter_t(n); i < end_##i; \
++i)
#define rep3(i, a, b) \
for (default_counter_t i = default_counter_t(a), \
end_##i = default_counter_t(b); \
i < end_##i; ++i)
#define rep4(i, a, b, c) \
for (default_counter_t i = default_counter_t(a), \
end_##i = default_counter_t(b); \
i < end_##i; i += default_counter_t(c))
#define rep(...) overload4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rrep1(n) \
for (default_counter_t i = default_counter_t(n) - 1; i >= 0; --i)
#define rrep2(i, n) \
for (default_counter_t i = default_counter_t(n) - 1; i >= 0; --i)
#define rrep3(i, a, b) \
for (default_counter_t i = default_counter_t(b) - 1, \
begin_##i = default_counter_t(a); \
i >= begin_##i; --i)
#define rrep4(i, a, b, c) \
for (default_counter_t \
i = (default_counter_t(b) - default_counter_t(a) - 1) / \
default_counter_t(c) * default_counter_t(c) + \
default_counter_t(a), \
begin_##i = default_counter_t(a); \
i >= begin_##i; i -= default_counter_t(c))
#define rrep(...) \
overload4(__VA_ARGS__, rrep4, rrep3, rrep2, rrep1)(__VA_ARGS__)
#define ALL(f, c, ...) \
(([&](decltype((c)) cccc) { \
return (f)(std::begin(cccc), std::end(cccc), ##__VA_ARGS__); \
})(c))
template <class C>
constexpr C& Sort(C& a) {
std::sort(std::begin(a), std::end(a));
return a;
}
template <class C>
constexpr auto& Min(C const& a) {
return *std::min_element(std::begin(a), std::end(a));
}
template <class C>
constexpr auto& Max(C const& a) {
return *std::max_element(std::begin(a), std::end(a));
}
template <class C>
constexpr auto Total(C const& c) {
return std::accumulate(std::begin(c), std::end(c), C(0));
}
template <typename T>
auto CumSum(std::vector<T> const& v) {
std::vector<T> a(v.size() + 1, T(0));
for (std::size_t i = 0; i < a.size() - size_t(1); ++i) a[i + 1] = a[i] + v[i];
return a;
}
template <typename T>
constexpr bool ChMax(T& a, T const& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
constexpr bool ChMin(T& a, T const& b) {
if (b < a) {
a = b;
return true;
}
return false;
}
void In(void) { return; }
template <typename First, typename... Rest>
void In(First& first, Rest&... rest) {
cin >> first;
In(rest...);
return;
}
template <class T, typename I>
void VectorIn(vector<T>& v, const I n) {
v.resize(size_t(n));
rep(i, v.size()) cin >> v[i];
}
void Out(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void Out(First first, Rest... rest) {
cout << first << " ";
Out(rest...);
return;
}
constexpr auto yes(const bool c) { return c ? "yes" : "no"; }
constexpr auto Yes(const bool c) { return c ? "Yes" : "No"; }
constexpr auto YES(const bool c) { return c ? "YES" : "NO"; }
int64_t Binomial(int64_t N, int64_t K) {
if (K < 0 || N < K) return 0;
int64_t ret = 1;
for (int64_t i = 1; i <= K; ++i) {
ret *= N--;
ret /= i;
}
return ret;
}
vector<int64_t> N;
int64_t K;
#ifdef USE_STACK_TRACE_LOGGER
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Weverything"
#include <glog/logging.h>
#pragma clang diagnostic pop
#endif
#endif
int64_t Pow(int64_t x, int64_t n) {
int64_t ret = 1;
while (n > 0) {
if (n & 1) (ret *= x);
(x *= x);
n >>= 1;
}
return ret;
}
int64_t Solve(const int64_t p, const int64_t k) {
if (k == 0) return 1;
if (p == 1 && k == 1) return N[p];
if (p == 1 && k >= 2) return 0;
if (N[p] == 0) {
return Solve(p - 1, k);
}
return Solve(p - 1, k - 1) +
(N[p] - 1) * Binomial(p - 1, k - 1) * Pow(9, k - 1) +
Binomial(p - 1, k) * Pow(9, k);
}
signed main(int argc, char* argv[]) {
(void)argc;
#ifdef USE_STACK_TRACE_LOGGER
google::InitGoogleLogging(argv[0]);
google::InstallFailureSignalHandler();
#else
(void)argv;
#endif
string _N;
In(_N, K);
ALL(reverse, _N);
N.emplace_back(0);
for (auto v : _N) {
N.emplace_back(v - '0');
}
cout << Solve(int64_t(_N.size()), K) << endl;
return EXIT_SUCCESS;
} | 1 | 98,965,703 |
#include<iostream>
#include<cstdio>
#include<string>
#include<vector>
#include<queue>
#include<cmath>
#include<algorithm>
#include<iomanip>
#include<functional>
#include<set>
#include<map>
#include<utility>
#define ul unsigned long long int
#define ll long long int
#define MAX 1000000+1
using namespace std;
#define F first
#define S second
#define pi 2*acos(0.0)
#define PB push_back
#define LSTAGE 1
int main()
{
ll n;
cin >> n;
map<ll, int> v;
for(ll i= 0; i < n; i++)
{
ll r;
cin >> r;
if(v.count(r)==0)
{
v[r] = 0;
v[r]++;
}
else v[r]++;
}
map<ll, int> :: iterator it;
ll area = 0;
ll a= 0, b= 0;
for(it = v.begin(); it!=v.end(); it++)
{
if(it->S >= 4)
{
area = max(area, it->F*it->F);
}
if(it->S>=2)
{
b = a;
a = it->F;
area = max(area, a*b);
}
}
cout << area ;
return 0;
} | #include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include <utility>
#include <cmath>
#include <tuple>
#include <queue>
#include <bitset>
#include <set>
#include <map>
#include <list>
using ll = long long;
using ld = long double;
using namespace std;
const int INF = 1e9+100;
const ll INF64 = 7e18l;
const int mod = 1000000007;
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define ALL(a) (a).begin(), (a).end()
#define FIN ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int main(){
FIN;
ll n; cin >> n;
map<ll,ll> a;
for(int i=0;i<n;i++){
int l; cin >> l;
a[l]++;
}
ll first=0,second=0;
map<ll,ll>::iterator it;
for(it=a.begin();it!=a.end();it++){
if(it->second >= 2){
second = first;
first = it->first;
}
if(it->second >= 4)
second = first;
}
cout << first * second << endl;
return 0;
} | 1 | 97,724,165 |
#include<stdio.h>
int main(void)
{
int x,c;
c=1;
while (scanf("%d",&x),x!=0){
if(x==0) break;
printf("Case %d: %d\n",c,x);
c++;
}
return 0;
} | #include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
int main()
{
int x;
int n=1;
while ( cin >> x && x!=0 )
{
cout << "Case " << n << ": " << x << endl;
n++;
}
} | 1 | 98,450,523 |
#include<iostream>
#include<bits/stdc++.h>
#include<vector>
#define vi vector<int>
#define lli long long int
#define fo(i,n) for(int i=1;i<=n;i++)
#define foo(i,n) for(int i=0;i<n;i++)
#define ff first
#define ss second
#define pb push_back
#define vii vector<lli>
#define ok ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
using namespace std;
#define vp vector<pair<lli,lli>>
#include <map>
lli mod=1000000007;
vii row(300004),col(300004);
map<lli,lli> points;
vii candx,candy;
lli has(lli x,lli y){
return x*1000000000000+y;
}
int main(){
lli r,c,m;
lli maxr,maxc;
bool flag=true;
maxr=maxc=0;
cin>>r>>c>>m;
foo(i,m){
lli x,y;
cin>>x>>y;
row[x]++;
col[y]++;
points[has(x,y)]++;
}
fo(i,r){
maxr=max(maxr,row[i]);
}
fo(i,c){
maxc=max(maxc,col[i]);
}
lli ans=maxr+maxc-1;
fo(i,r){
if(row[i]==maxr) candx.pb(i);
}
fo(i,c){
if(col[i]==maxc) candy.pb(i);
}
foo(i,candx.size()){
foo(j,candy.size()){
if(points.find(has(candx[i],candy[j]))==points.end()){
flag=false;
ans++;
break;
}
}
if(!flag) break;
}
cout<<ans;
} | #include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <set>
using namespace std;
int main(void) {
int h, w, m;
cin >> h >> w >> m;
vector<int> sum_row(h, 0), sum_col(w, 0);
set<pair<int, int>> t;
for (int i = 0; i < m; i++) {
int h, w;
cin >> h >> w;
h--, w--;
sum_row[h] += 1;
sum_col[w] += 1;
t.emplace(h, w);
}
int max_row = *max_element(sum_row.begin(), sum_row.end());
int max_col = *max_element(sum_col.begin(), sum_col.end());
vector<int> row_idx;
vector<int> col_idx;
for (int i = 0; i < sum_row.size(); i++) {
if (sum_row[i] == max_row)
row_idx.push_back(i);
}
for (int i = 0; i < sum_col.size(); i++) {
if (sum_col[i] == max_col)
col_idx.push_back(i);
}
int ans = max_row + max_col;
for (auto row : row_idx) {
for (auto col : col_idx) {
if (t.count(pair<int, int>(row, col))) continue;
cout << ans << endl;
return 0;
}
}
ans--;
cout << ans << endl;
return 0;
} | 1 | 36,107,899 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using p = pair<int,int>;
const long long INF = 1ll << 60;
int main(){
int s;
cin>> s;
set<int> st;
int ans = 1;
while(true){
if(st.find(s) != st.end()){
cout << ans << endl;
return 0;
}
st.insert(s);
if(s%2 == 0) s/=2;
else s = s*3+1;
ans++;
}
} | #include <bits/stdc++.h>
#define rep(i, start, end) for (long long i = start; i < end; ++i)
#define repreverse(i, start, end) for (long long i = start; i >= end; --i)
#define all(x) (x).begin(), (x).end()
#define len(x) ((long long)(x).size())
#define lcm(a, b) ((a) / __gcd((a), (b)) * (b))
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vllvll = vector<vll>;
using pll = pair<ll, ll>;
template<class T>void print1d(T x,ll n=-1){if(n==-1)n=x.size();rep(i,0,n){cout<<x[i]<<' ';}cout<<'\n';}
template<class T>void print2d(T x,ll r=-1,ll c=-1){if(r==-1)r=x.size();if(c==-1)c=x[0].size();rep(i,0,r)print1d(x[i],c);}
template<class T, class U>bool haskey(T mp, U key) { return mp.find(key) != mp.end(); }
template<class T, class U>bool isin(T el, U container) { return find(all(container), el) != container.end(); }
template<class T>bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
template<class T>bool even(T n) { return ! (n & 1); }
template<class T>bool odd(T n) { return n & 1; }
template<class T>ld deg2rad(T deg) { return M_PI * deg / 180.0; }
template<class T>ld rad2deg(T rad) { return 180.0 * rad / M_PI; }
ll intpow(ll a,ll n){ll p=1;while(n){if(n&1)p*=a;a*=a;n>>=1;}return p;}
const long double pi = M_PI;
const long long big = 1LL << 50;
const long long inf = 1LL << 60;
const long long mod = 1e9 + 7;
ll f(ll n)
{
if (even(n)) return n/2;
else return 3*n+1;
}
int main()
{
ll s;
cin >> s;
ll ne = s;
map<ll, ll> mp;
mp[s]++;
ll ans = -inf;
rep(i, 2, 10000000) {
ne = f(ne);
mp[ne]++;
if (mp[ne] == 2) {
ans = i;
break;
}
}
cout << ans << endl;
} | 1 | 56,497,231 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=400005;
int size[N],ne[N],tot,fi[N],zz[N],x,y,n,cnt,d[N];
void jb(int x,int y){
ne[++tot]=fi[x];
fi[x]=tot;
zz[tot]=y;
}
void dfs(int x,int y){
size[x]=1;int cnt=0;
for (int i=fi[x];i;i=ne[i])if (zz[i]!=y){
dfs(zz[i],x);
size[x]+=size[zz[i]];
cnt+=size[zz[i]]&1;
}
if (cnt>=2){
puts("First");
exit(0);
}
}
signed main(){
scanf("%lld",&n);
if (n&1){
puts("First");
return 0;
}
for (int i=1;i<n;i++){
scanf("%lld%lld",&x,&y);
jb(x,y);jb(y,x);
d[x]++;d[y]++;
}
int cnt=0;
for (int i=1;i<=n;i++)
if (d[i]>1){
dfs(i,0);
break;
}
puts("Second");
} | #include <cstdio>
#define rep(i,j,k) for (i=j;i<=k;i++)
using namespace std;
const int N=1e5+5;
int n,u,v,i,j,x,End,l,r,q[N];
int En,fst[N],flg[N],dgr[N],nxt[N*2],to[N*2];
void add(int u,int v) {
En++; nxt[En]=fst[u]; fst[u]=En; to[En]=v;
}
int fs(int x) {
int j;
for (j=fst[x];j;j=nxt[j])
if (!flg[to[j]]) return to[j];
}
int main()
{
scanf("%d",&n);
rep(i,1,n-1)
{
scanf("%d%d",&u,&v);
add(u,v); add(v,u);
dgr[u]++; dgr[v]++;
}
rep(i,1,n)
if (dgr[i]==1)
q[++r]=i;
for (l=1;l<=r;l++)
{
if (flg[q[l]]) continue;
x=fs(q[l]);
flg[x]=1;
End=0;
for (j=fst[x];j;j=nxt[j])
if (!flg[to[j]] && dgr[to[j]]==1) End++,flg[to[j]]=1;
if (End>1) {
printf("First\n");
return 0;
}
for (j=fst[x];j;j=nxt[j])
if (!flg[to[j]])
{
dgr[to[j]]--;
if (!dgr[to[j]]) {
printf("First\n");
return 0;
}
if (dgr[to[j]]==1) q[++r]=to[j];
}
}
printf("Second\n");
return 0;
} | 1 | 9,970,969 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
int main()
{
int n;
ll ans = 1, s = 1000000000000000000;
cin >> n;
vector<ll> a(n);
rep(i, n)
{
cin >> ans;
a[i] = ans;
if (ans == 0)
{
cout << 0;
return 0;
}
}
ans = 1;
rep(i, n)
{
if (a[i] > s / ans)
{
cout << -1;
return 0;
}
ans *= a[i];
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repc(i, a, b) for (int i = a; i <= (int)(b); i++)
#define ll long long
#define vec vector
#define ft first
#define sd second
#define all(vec) vec.begin(), vec.end()
typedef pair<int, int> P;
const int MOD = 1e9 + 7;
const int INF = 1001001001;
const int dx[4] = {1, 0,-1, 0};
const int dy[4] = {0, 1, 0,-1};
int main() {
int n;
cin >> n;
vec<ll> a(n);
rep(i, n){
cin >> a[i];
if(a[i] == 0){
cout << 0 << endl;
return 0;
}
}
ll ans = 1;
rep(i, n){
if(a[i] <= 1000000000000000000 / ans){
ans *= a[i];
}
else{
cout << -1 << endl;
return 0;
}
}
cout << ans << endl;
return 0;
} | 1 | 6,836,963 |
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <cassert>
#define int long long
#define rep(i,n) for(int i=0;i<n;i++)
#define srep(i,n,m) for(int i=n;i<m;i++)
#define elif else if
#define INF 1000000007
#define pi 3.141592653589793
using namespace std;
int saidaikouyakusuu(int a,int b){
if(b==0) return a;
return saidaikouyakusuu(b,a%b);
}
int saisyoukoubaisuu(int a,int b){
return a*b/saidaikouyakusuu(a,b);
}
int n,m,cnt=0,aa[220000],ans=0,x,y,ab[220000];
pair<int,int> pp[220000];
string s,ss[220000];
char c;
queue<int> que;
signed main(){
cin>>n>>m>>x>>y;
rep(i,n){
cin>>aa[i];
x=max(x,aa[i]);
}
rep(i,m){
cin>>ab[i];
y=min(y,ab[i]);
}
if(y<=x){
cout<<"War"<<endl;
}else{
cout<<"No War"<<endl;
}
} | #include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<(n);++i)
#define all(a) (a).begin(),(a).end()
#define dunk(a) cout << (a) << endl
#define rall(a) (a).rbegin(),(a).rend()
const int INF = 2e9;
using namespace std;
using Graph = vector<vector<int>>;
typedef pair<int,int> P;
typedef long long ll;
int main(){
int n, m, x, y; cin >> n >> m >> x >> y;
vector<int> xx(n+1); rep(i,n) cin >> xx[i];
vector<int> yy(m+1); rep(i,m) cin >> yy[i];
xx[n] = x; yy[m] = y;
sort(all(xx));
sort(all(yy));
if(xx[n] < yy[0]) cout << "No War" << endl;
else cout << "War" << endl;
} | 1 | 42,732,501 |
#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
#include<set>
#include<map>
using namespace std;
int main() {
vector<int> v {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 1};
int a, b;
cin >> a >> b;
if(find(v.begin(), v.end(), a) < find(v.begin(), v.end(), b)){
cout << "Bob";
}
else if(find(v.begin(), v.end(), a) > find(v.begin(), v.end(), b)){
cout << "Alice";
}
else
{
cout << "Draw";
}
cout << endl;
} | #include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int main()
{
int a,b;
cin >> a >> b;
if (a == b) cout << "Draw" << endl;
else if (a == 1) cout << "Alice" << endl;
else if (b == 1) cout << "Bob" << endl;
else if (a > b) cout << "Alice" << endl;
else cout << "Bob" << endl;
return 0;
} | 1 | 32,859,380 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s, ans = "No";
cin >> s;
set<int> buf;
for (int i = 0; i < 4; i++) {
buf.insert(s[i]);
}
if (buf.size() == 2) {
ans = "Yes";
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
using namespace std;
vector<int> twoadd(vector<int> v, int N){
v[N-1]+=1;
int ind = N-1;
int j=N-1;
for(j=N-1;j>=1;j--){
if(v[j]>1){
v[j-1]+=1;
v[j]=0;
}
}
return v;
}
long long fibonatti(long long d){
long long count = 0;
long long f1 = 1;
long long f2 = 1;
long long temp;
if(d == 1){
count = f1;
}else if(d == 2){
count = f2;
}else if(d==0){
count = 1;
}else{
for(int i=0;i<d-2;i++){
temp = f1+f2;
f1 = f2;
f2 = temp;
}
count = temp;
}
return count;
}
unsigned long long GCD(long long L,long long R){
if(L>R){
long long temp=R;
R = L;
L = temp;
}
unsigned long long pp=0,ppt=0;
unsigned long long ans=0;
if(R%L==0){
ans = L;
}else{
while(true){
ppt = pp;
pp=R%L;
if(pp == 0){
ans = ppt;
break;
}
R = L;
L = pp;
}
}
return ans;
}
unsigned long long LCM(long long L,long long R){
unsigned long long ans;
unsigned long long gcd = GCD(L,R);
ans = (L/gcd)*R;
return ans;
}
int main() {
char a,b;
cin >> a >> b;
if(a!=b){
for(int i=0;i<2;i++){
char c;
cin >> c;
if(c!=a&&c!=b){
cout << "No" << endl;
exit(0);
}
}
cout << "Yes" << endl;
}else {
char c,d;
cin >> c >> d;
if(c!=d||a==c){
cout << "No" << endl;
}else{
cout << "Yes" << endl;
}
}
} | 1 | 42,249,177 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,t,sum = 0;
bool frag = false;
string s,X;
vector<int> minute;
vector<string> name;
cin >> N;
for(int i = 0;i<N;i++){
cin >> s >> t;
minute.push_back(t);
name.push_back(s);
}
cin >> X;
for(int i = 0; i<N;i++){
if(frag){sum += minute.at(i);}
if(name.at(i) == X){frag = true;}
}
cout << sum << endl;
} | #include <bits/stdc++.h>
#include <regex>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
#define INF 1000000000000
#define MOD 1000000007
#define MAXR 100000
#define PI 3.14159265358979323846264338327950L
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define Z class
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0);
#define VAR(type, ...) \
type __VA_ARGS__; \
MACRO_VAR_Scan(__VA_ARGS__);
template <typename T>
void MACRO_VAR_Scan(T &t)
{
std::cin >> t;
}
template <typename First, typename... Rest>
void MACRO_VAR_Scan(First &first, Rest &... rest)
{
std::cin >> first;
MACRO_VAR_Scan(rest...);
}
#define VEC_ROW(type, n, ...) \
std::vector<type> __VA_ARGS__; \
MACRO_VEC_ROW_Init(n, __VA_ARGS__); \
for (int w_ = 0; w_ < n; ++w_) \
{ \
MACRO_VEC_ROW_Scan(w_, __VA_ARGS__); \
}
template <typename T>
void MACRO_VEC_ROW_Init(int n, T &t)
{
t.resize(n);
}
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Init(int n, First &first, Rest &... rest)
{
first.resize(n);
MACRO_VEC_ROW_Init(n, rest...);
}
template <typename T>
void MACRO_VEC_ROW_Scan(int p, T &t) { std::cin >> t[p]; }
template <typename First, typename... Rest>
void MACRO_VEC_ROW_Scan(int p, First &first, Rest &... rest)
{
std::cin >> first[p];
MACRO_VEC_ROW_Scan(p, rest...);
}
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define MAT(type, c, m, n) \
std::vector<std::vector<type>> c(m, std::vector<type>(n)); \
for (auto &R : c) \
for (auto &w : R) \
std::cin >> w;
template <typename T>
void MACRO_OUT(const T t) { std::cout << t; }
#define OUT(...) MACRO_OUT(__VA_ARGS__);
#define SP std::cout << " ";
#define TAB std::cout << "\t";
#define BR std::cout << "\n";
#define ENDL std::cout << std::endl;
#define YES() printf("YES\n")
#define NO() printf("NO\n")
#define isYES(x) printf("%s\n", (x) ? "YES" : "NO")
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define yes() printf("yes\n")
#define no() printf("no\n")
#define ln cout << '\n'
template <Z A>
void pr(A a)
{
cout << a;
ln;
}
template <Z A, Z B>
void pr(A a, B b)
{
cout << a << ' ' << b << endl;
}
template <typename T>
T square(T x) { return x * x; }
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);
}
#define chmax(x, y) (x = max(x, y))
#define chmin(x, y) (x = min(x, y))
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repe(i, n) for (ll i = 0; i <= (n); i++)
#define repd(i, n) for (ll i = n; i > 0; i--)
#define repde(i, n) for (ll i = n; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i < (b); i++)
#define FORE(i, a, b) for (ll i = a; i <= (b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (b); i--)
#define FORA(i, I) for (const auto &i : I)
#define ALL(x) x.begin(), x.end()
#define ALLR(x) x.end(), x.begin()
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<vi> vvi;
typedef vector<ll> vl;
#define ERASE(x) x.erase(unique(ALL(x)), x.end());
#define sz(x) (int)(x).size()
bool yes = 0;
bool boo = 0;
double mx = -100000;
int mn = 1001001001;
int sum = 0;
ll ans = 0;
int co = 0;
int abc[26];
bool OK = false;
int main()
{
VAR(int, n);
vs v(n);
vi x(n);
rep(i, n)
{
cin >> v[i];
cin >> x[i];
sum += x[i];
}
VAR(string, s);
rep(i, n)
{
ans += x[i];
if (v[i] == s)
{
break;
}
}
pr(sum - ans);
} | 1 | 20,740,159 |
#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() {
string s; cin >> s;
int n = s.size();
for(int left=0;left<n;left++) {
int right = left;
map<char, int> mp;
while(right < n && right-left <=2) {
mp[s[right]] = 1;
if(right-left==1 && mp.size()==1) {
printf("%d %d\n", left+1, right+1);
return 0;
}
if(right-left==2 && mp.size()==2) {
printf("%d %d\n", left+1, right+1);
return 0;
}
right++;
}
}
printf("%d %d\n", -1, -1);
} | #include <iostream>
using namespace std;
pair<int, int> getResult(const string &s){
const size_t sSize = s.size();
pair<int, int> range = {-1, -1};
if(sSize < 2){
return range;
}
if(sSize == 2){
if(s[0] == s[1]){
range.first = 1;
range.second = 2;
}
return range;
}
for(int i = 0; i + 2 < sSize; i++){
if((s[i] == s[i+1]) || (s[i] == s[i+2]) || (s[i+1] == s[i+2])){
range.first = i + 1;
range.second = i + 3;
break;
}
}
return range;
}
int main(){
string s;
cin >> s;
pair<int, int> result = getResult(s);
cout << result.first << " " << result.second << endl;
} | 1 | 100,653,531 |
#include<iostream>
#include<algorithm>
#include<cmath>
#include <string>
#include <vector>
#include <algorithm>
#include <sstream>
#include <queue>
#include <deque>
#include <bitset>
#include <iterator>
#include <list>
#include <stack>
#include <map>
#include <set>
#include <functional>
#include <numeric>
#include <utility>
#include <limits>
#include <time.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
using namespace std;
#define w(t) int t; cin>>t; while(t--)
#define vi vector<int>
#define vs vector<string>
#define mp make_pair
#define ll long long int
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
int a, b;
cin>>a>>b;
if(a == 1) a = a + 13;
if(b == 1) b = b + 13;
if(a > b) cout<<"Alice";
if(b > a) cout<<"Bob";
if(b == a) cout<<"Draw";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(long long i=0; i<(int)n; i++)
#define rep2(i,a,n) for(long long i=(a); i<(int)(n); i++)
#define all(vec) vec.begin(),vec.end()
using vi = vector<int>;
using vs = vector<string>;
using vvi = vector<vi>;
using pii = pair<int, int>;
using psi = pair<string, int>;
const int dx[4] = {1, 0,-1, 0};
const int dy[4] = {0, 1, 0,-1};
const int mod = 1e9+7;
int gcd(int a, int b){if(a%b == 0){return(b);}else{return(gcd(b, a%b));}}
int lcm(int a, int b){return a * b / gcd(a, b);}
int N, M, K, H, W, L, R, X, A, B, C;
signed main(){
cin >> A >> B;
if(A==B) cout << "Draw" <<endl;
else if(A==1 && B == 13) cout << "Alice" << endl;
else if(A==13 && B == 1) cout << "Bob" << endl;
else if(A>B)cout << "Alice" << endl;
else cout << "Bob" << endl;
return 0;
} | 1 | 10,896,519 |
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
int main()
{
string num;
while (1)
{
int i, ans = 0;
cin >> num;
if (num == "0")
break;
for (i = 0; i < num.length(); i++)
ans += num[i] - '0';
printf("%d\n", ans);
}
} | #include<iostream>
using namespace std;
int main(){
char x[1000][1001] = { "a" };
int check;
int a[1000] = {};
for (int i = 0; i < 1000; i++){
cin >> x[i];
if (x[i][0] == '0'){
break;
}
for (int i2 = 0; i2 < 1001; i2++){
if (x[i][i2] != '\0' && x[i][i2] != 'a'){
a[i] += x[i][i2] - '0';
}
}
check = i;
}
for (int i = 0; i <= check; i++){
cout << a[i] << endl;
}
return 0;
} | 1 | 17,544,047 |
#include <bits/stdc++.h>
#define endl '\n'
using namespace std;
typedef long long ll;
const int dx[] = { 1, -1, 0, 0, 1, 1, -1, -1 };
const int dy[] = { 0, 0, 1, -1, 1, -1, 1, -1 };
const char dir[] = {'D', 'U', 'R', 'L'};
void Fast() { cin.sync_with_stdio(0); cin.tie(0); cout.tie(0); }
void File()
{
#ifndef ONLINE_JUDGE
freopen("input.in", "r", stdin);
#endif
}
const int N = 1e5 + 9, M = 2e5 + 9, oo = 0x3f3f3f3f;
int Head[N], Next[M << 1], To[M << 1], signpost[N], ne, n, u, v, m;
void addEdge(int from, int to)
{
Next[++ne] = Head[from];
Head[from] = ne;
To[ne] = to;
}
void BFS(int src)
{
memset(signpost, 0x3f, sizeof signpost);
queue <int> Q;
Q.push(src);
int node;
while(Q.size())
{
node = Q.front(); Q.pop();
for(int i = Head[node]; i; i = Next[i]) if(signpost[To[i]] == oo)
{
signpost[To[i]] = node;
Q.push(To[i]);
}
}
}
void Solve()
{
cin >> n >> m;
while(m--)
{
cin >> u >> v;
addEdge(u, v);
addEdge(v, u);
}
BFS(1);
auto isConnected = [&] () -> bool {
for(int i = 2; i <= n; ++i)
if(signpost[i] == oo) return false;
return true;
};
if(!isConnected()) cout << "No" << endl;
else
{
cout << "Yes" << endl;
for(int i = 2; i <= n; ++i)
cout << signpost[i] << endl;;
}
}
void MultiTest(bool Tests = 0)
{
int tc = 1; (Tests) && (cin >> tc);
for(int i = 1; i <= tc; ++i)
Solve();
}
int main()
{
Fast(); MultiTest();
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VLL = vector<LL>;
using VVLL = vector<VLL>;
using VS = vector<string>;
using PII = pair<int,int>;
using VP = vector<PII>;
using VB = vector<bool>;
using VVB = vector<VB>;
#define REP(i,m,n) for(int i=(m);i<(n);i++)
#define RREP(i,m,n) for(int i=(m);i>=(n);i--)
int main(){
int n,m;
cin >> n >> m;
VI a(m),b(m),sign(n+1,-1);
VVI g(n+1, VI());
REP(i,0,m){
cin >> a[i] >> b[i];
g[a[i]].push_back(b[i]);
g[b[i]].push_back(a[i]);
}
queue<PII> q;
q.push(make_pair(1,0));
while(!q.empty()){
PII cur = q.front();
q.pop();
int x = cur.first;
int y = cur.second;
for(int z : g[x]){
if(sign[z] == -1){
q.push(make_pair(z,x));
sign[z] = x;
}
}
}
cout << "Yes" << endl;
REP(i,2,n+1){
cout << sign[i] << endl;
}
return 0;
} | 1 | 93,926,600 |
#include <stdio.h>
main()
{
int a,b,c,d;
scanf("%d %d %d %d", &a,&b,&c,&d);
int e,f,g,h;
scanf("%d %d %d %d", &e,&f,&g,&h);
int S,T;
S = a + b + c + d;
T = e + f + g + h;
if (S>T) printf("%d\n",S);
else printf("%d\n",T);
} | #include <iostream>
using namespace std;
#define A 0
#define B 1
int main(){
int info[2], math[2], science[2], english[2];
cin >> info[A] >> math[A] >> science[A] >> english[A];
cin >> info[B] >> math[B] >> science[B] >> english[B];
cout << max(info[A]+math[A]+science[A]+english[A], info[B]+math[B]+science[B]+english[B]) << endl;
} | 1 | 90,562,701 |
#include <cstdio>
long long x[100000], s[100000];
long long const p = 1000000007;
long long prodsum(int n) {
int i;
for (i = 0; i < n; i++)scanf("%lld", &x[i]);
for (i = n - 1; i > 0; i--)x[i] -= x[i - 1];
s[0] = 0;
for (i = 1; i <= n / 2; i++)s[i] = s[i - 1] + n - 1 - 2 * (i - 1);
for (i = n - 1; i >= n / 2; i--)s[i] = s[n - i];
long long sum = 0;
for (i = 1; i < n; i++)sum += x[i] * s[i] % p;
return sum%p;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
printf("%lld", prodsum(n)*prodsum(m) % p);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int emod(long long x, long long p = mod) {
return (x % p + p) % p;
}
signed main() {
cin.tie(0); ios::sync_with_stdio(false);
int n, m; cin >> n >> m;
vector<long long> x(n); for (int i = 0; i < n; i++) cin >> x[i];
vector<long long> y(m); for (int i = 0; i < m; i++) cin >> y[i];
long long sumx = 0, sumy = 0;
for (int i = 1; i < n; i++) {
sumx = (sumx + (x[i] - x[i - 1]) * i % mod * (n - i) % mod) % mod;
}
for (int i = 1; i < m; i++) {
sumy = (sumy + (y[i] - y[i - 1]) * i % mod * (m - i) % mod) % mod;
}
cout << emod(sumx * sumy) << '\n';
return 0;
} | 1 | 21,425,524 |
#include <iostream>
int main()
{
char c;
std::cin >> c;
if (c == 'a' || c == 'i' || c == 'u' || c == 'e' || c == 'o')
{
std::cout << "vowel";
}
else
{
std::cout << "consonant";
}
std::cout << std::endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) \
for (int i = 0; i < (int)(n); i++) \
;
#define _GLIBCXX_DEBUG
#define _LIBCPP_DEBUG 0
int main() {
char c;
cin >> c;
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
cout << "vowel" << endl;
} else {
cout << "consonant" << endl;
}
} | 1 | 10,747,761 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e15;
int main(){
ll M; cin >> M;
ll ans = 0, S = 0;
vector<ll> D(M), C(M);
for(int i = 0; i < M; i++){
cin >> D[i] >> C[i];
ans += C[i]; S += D[i]*C[i];
}
cout << ans-1+(S-1)/9 <<endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using WGraph = vector<vector<pair<int, ll>>>;
template<class T>inline bool chmax(T &a, const T &b) { if (b > a) { a = b; return true; } return false; }
template<class T>inline bool chmin(T &a, const T &b) { if (b < a) { a = b; return true; } return false; }
constexpr int dx[4] = {-1, 0, 0, 1}, dy[4] = {0, -1, 1, 0};
constexpr int INF = 1e9;
constexpr int MOD = 1e9 + 7;
constexpr long long LINF = 1e18;
constexpr double EPS = 1e-10;
constexpr double PI = M_PI;
void solve() {
int m;
cin >> m;
ll res = 0, sum = 0;
for (int i=0; i<m; ++i) {
ll d, c;
cin >> d >> c;
res += c;
sum += d * c;
}
cout << res - 1 + (sum - 1) / 9 << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
solve();
return 0;
} | 1 | 17,832,736 |
#include<cstdio>
#include<iostream>
using namespace std;
int num[1000000];
int main()
{
int n, k, ans = 0, sans=0;
while (1)
{
scanf("%d%d", &n, &k);
if (n == 0 && k == 0)
break;
for (int i = 0; i < n; i++)
{
scanf("%d", &num[i]);
}
for (int i = 0; i < n - k; i++)
{
for (int j = i; j < i + k; j++)
{
sans += num[j];
}
if (ans < sans)
ans = sans;
sans = 0;
}
printf("%d\n", ans);
}
return 0;
} | #include <iostream>
using namespace std;
int main()
{
while(1)
{
int n,k; cin >> n >> k ;
if(n==0 && k==0) break;
int* a=new int[n]; int sum=0; int max=0;
for(int i=0;i<n;i++) cin >> a[i] ;
for(int i=0;i<k;i++) sum+=a[i];
max=sum;
for(int i=k;i<n;i++)
{
sum=sum+a[i]-a[i-k];
if(sum>max) max=sum;
}
cout << max << '\n';
}
} | 1 | 95,819,257 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for (int i = 1; i < (int)(n); i++)
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define vout(x) rep(i,x.size()) cout << x[i] << " "
template<class T> bool chmin(T &a, T b) {if(a>b) {a=b;return 1;}return 0;}
template<class T> bool chmax(T &a, T b) {if(a<b) {a=b;return 1;}return 0;}
using namespace std;
using vint = vector<int>;
using vvint = vector<vector<int>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<int,int>;
const int inf = 1e9;
const ll inf_l = 1e18;
const int MAX = 1e5;
int main() {
int n; cin >> n;
vector<P> data(n);
rep(i,n) {
int x, y; cin >> x >> y;
data[n-i-1] = P(x,y);
}
ll ans = 0;
rep(i,n) {
ll x = (ll)data[i].first+ans, y = (ll)data[i].second;
ans += (x+y-1)/y*y-x;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <string>
#include <deque>
using namespace std;
using Graph = vector<vector<int>>;
int main() {
int n; cin >> n;
long long p_total = 0;
long long zero = 0;
vector<long long> a(n + 1);
vector<long long> b(n + 1);
for(int i = 1; i < n + 1; i++) cin >> a[i] >> b[i];;
reverse(a.begin() + 1 , a.end());
reverse(b.begin() + 1 , b.end());
for(int i = 1; i < n + 1; i++){
p_total += max( zero, (b[i] - ((a[i] + p_total) % b[i])) % b[i]);
}
cout << p_total << endl;
} | 1 | 64,302,173 |
#include <cstdio>
const int kMaxN = 2000000;
const int kMaxAi = 10000;
void CountingSort (int A[], int B[], int k, int n) {
int i;
int C[k + 1] = {};
for (i = 0; i < n; ++i) { ++C[A[i]]; }
for (i = 1; i < k + 1; ++i) { C[i] += C[i - 1]; }
for (i = n - 1; i > -1; --i) {
B[C[A[i]] - 1] = A[i];
--C[A[i]];
}
}
int main() {
int n, i;
std::scanf("%d", &n);
int A[n], B[n];
for (i = 0; i < n; ++i) { std::scanf("%d", &A[i]); }
CountingSort(A, B, kMaxAi, n);
for (i = 0; i < n - 1; ++i) { std::printf("%d ", B[i]); }
std::printf("%d\n", B[n - 1]);
return 0;
} | #include<iostream>
#include<string>
#include<math.h>
#include<iomanip>
using namespace std;
int main(){
int n;
cin >> n;
int *a = new int[n];
int *b = new int[n];
int c[10001];
for(int i = 0; i <= 10000; i++){
c[i] = 0;
}
for(int i = 0; i < n; i++){
cin >> a[i];
c[a[i]]++;
}
for(int i = 1; i <= 10000; i++){
c[i] = c[i - 1] + c[i];
}
for(int i = n - 1; i >= 0; i--){
b[c[a[i]] - 1] = a[i];
c[a[i]]--;
}
for(int i = 0; i < n; i++){
if(i == 0) cout << b[i];
else cout << ' ' << b[i];
}
cout << endl;
delete[] a, b;
return 0;
} | 1 | 89,750,259 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
vector<string> X;
for(;;){
string s;
cin >> s;
if(s == "0") break;
X.push_back(s);
}
for(int i = 0; i < X.size(); i++){
int sum = 0;
string x = X.at(i);
for(int j = 0; j < x.size(); j++){
sum += (int)(x.at(j) - '0');
}
cout << sum << endl;
}
} | #include<stdio.h>
int main(){
char a[1001]={0};
int c[1001]={0};
int b=0,d=0,i;
while(1){
scanf("%s",a);
if(a[0]=='0'){
break;
}
while(a[b]!=0){
c[d]+=a[b]-'0';
b++;
}
d++;
b=0;
}
for(i=0;i<d;i++){
printf("%d\n",c[i]);
}
} | 1 | 41,684,585 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
int N, M;
cin >> N >> M;
vector<int> H(N);
for(int i = 0; i < N; i++){
cin >> H.at(i);
}
int A, B;
vector<bool> good(N);
for(int i = 0; i < N; i++){
good.at(i) = true;
}
for(int i = 0; i < M; i++){
cin >> A >> B;
if(H.at(A-1) <= H.at(B-1)){
good.at(A-1) = false;
}
if(H.at(A-1) >= H.at(B-1)){
good.at(B-1) = false;
}
}
int ans = 0;
for(int i = 0; i < N; i++){
if(good.at(i) == true){
ans++;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using Graph = vector<vector<ll>>;
int main(void)
{
ll n,m;
cin >> n >> m;
ll a,b;
vector<ll> h(n),ma(n,0);
for(int i=0;i<n;i++)
{
cin >> h[i];
}
for(int i=0;i<m;i++)
{
cin >> a >> b;
a--;
b--;
ma[a]=max(ma[a],h[b]);
ma[b]=max(ma[b],h[a]);
}
ll count=0;
for(int i=0;i<n;i++)
{
if(h[i]>ma[i])
{
count++;
}
}
cout << count << endl;
return 0;
} | 1 | 71,912,621 |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cctype>
#include <climits>
#include <iostream>
#include <string>
#include <bitset>
#include <vector>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <algorithm>
using namespace std;
#define ALL(g) (g).begin(), (g).end()
#define REP(i, x, n) for(int i = x; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define pb push_back
#define mp make_pair
typedef pair<int, int> pii;
typedef pair<long, long> pll;
typedef long long ll;
const int INF = INT_MAX;
int main(void) {
int v, e, s, t, d;
scanf("%d %d", &v, &e);
int g[v][v];
rep(i, v) rep(j, v) g[i][j] = INF;
rep(i, v) g[i][i] = 0;
rep(i, e) {
scanf("%d %d %d", &s, &t, &d);
g[s][t] = d;
}
rep(k, v) {
rep(i, v) {
if (g[i][k] == INF) continue;
rep(j, v) {
if (g[k][j] == INF) continue;
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
}
}
int flag = 1;
rep(i, v) {
if (g[i][i] < 0) {
flag = 0;
break;
}
}
if (flag) {
rep(i, v) {
rep(j, v) {
if (j) printf(" ");
if (g[i][j] == INF) printf("INF");
else printf("%d", g[i][j]);
}
printf("\n");
}
}
else printf("NEGATIVE CYCLE\n");
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cassert>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,n) FOR(i,0,n)
#define rep(i,n) FOR(i,0,n)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define vint vector<int>
#define vdouble vector<double>
#define vstring vector<string>
using namespace std;
#include<map>
#include<set>
#include<queue>
typedef long long ll;
typedef unsigned long long ull;
const int MAX_N = 1000000;
static const ll INFTY = (1LL << 32);
int V, E;
ll A[100][100];
void warshallFloyd(){
rep(k, V)
rep(i, V)
rep(j, V)
{
if (A[i][k] != INFTY && A[k][j] != INFTY){
A[i][j] = min(A[i][j], A[i][k] + A[k][j]);
}
}
}
int main() {
cin >> V >> E;
rep(i, V) rep(j, V){
A[i][j] = (i == j) ? 0 : INFTY;
}
rep(i, E){
int s, t, d;
cin >> s >> t >> d;
A[s][t] = d;
}
warshallFloyd();
rep(i, V){ if (A[i][i] < 0){ cout << "NEGATIVE CYCLE" << endl; return 0; } }
rep(i, V){
rep(j, V){
if (A[i][j] == INFTY){
cout << "INF";
}
else{
cout << A[i][j];
}
if (j < V - 1){ cout << " "; }
}
cout << endl;
}
} | 1 | 26,057,379 |
#include<stdio.h>
#include<queue>
#include<math.h>
#include<time.h>
#include<string.h>
#include<vector>
#include<algorithm>
#include<iostream>
#include<set>
#include<map>
#include<stack>
#define LL long long
#define mem(a,b) memset(a,b,sizeof(a))
#define lowbit(a) a&(-a)
#define PI acos(-1)
#define shortime(a) std::ios::sync_with_stdio(a);
using namespace std;
const LL mod=1e9+7;
int maxn (int a,int b,int c){return max(max(a,b),max(b,c));}
LL min(LL a,LL b) {return a<b?a:b;}
int gcd (int a,int b){return b==0?a:gcd(b,a%b);}
LL quick(LL x,LL n){ LL ans=1,temp=x; while(n){if(n%2==1){ ans=(ans*temp)%mod;} n/=2;temp=temp*temp%mod;}return ans;}
LL inv[100005]={1,1},f1[100005]={1,1},f2[100005]={1,1};
void init()
{
for(int i=2;i<=100005;i++)
{
f1[i]=(f1[i-1]*i)%mod;
inv[i]=quick(i,mod-2);
f2[i]=(f2[i-1]*inv[i])%mod;
}
}
LL C(LL n,LL m)
{
return f1[n]*f2[n-m]%mod*f2[m]%mod;
}
int n,vis[100005];
int main()
{
init();
scanf("%d",&n);
mem(vis,0);
LL temp;
for(int i=1;i<=n+1;i++)
{
int x;
scanf("%d",&x);
if(vis[x])
{
temp=n-(i-vis[x]);
}
vis[x]=i;
}
LL sum;
for(int i=1;i<=n+1;i++)
{
sum=C((LL) (n+1),(LL) (i))%mod;
if(temp>=i-1)
{
sum=(sum-C((LL)temp,(LL)(i-1))+mod)%mod;
}
printf("%lld\n",sum);
}
return 0;
} | #include<iostream>
#include<string>
#include<cstdio>
#include <cstring>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll mod = 1000000007;
typedef long double ld;
const ll INF = 1e+14;
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++)
typedef complex<ld> Point;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;
#define fr first
#define sc second
#define all(c) c.begin(),c.end()
#define pb push_back
void Yes(){
cout<<"Yes"<<endl;
exit(0);
}
void No(){
cout<<"No"<<endl;
exit(0);
}
long long mod_inverse(long long x) {
long long ret = 1; long long n = mod - 2;
while (n) {
if (n & 1)ret = ret * x % mod;
x = x * x % mod; n >>= 1;
}
return ret;
}
ll fact[100100], inv_fact[100100];
ll comb(ll n, ll r) {
if(n < r || r < 0) return 0;
if(n == r || r == 0) return 1LL;
ll ret = fact[n] * inv_fact[n - r] % mod * inv_fact[r] % mod;
return ret % mod;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n; cin >> n;
set<int> s;
map<int, int> mp;
ll l;
rep(i, n + 1) {
int a; cin >> a;
if(s.find(a) != s.end()) {
l = (ll)i - (ll)mp[a];
break;
} else {
s.insert(a);
mp[a] = i;
}
}
fact[0] = 1LL; inv_fact[0] = 1LL;
rep1(i, n) {
fact[i] = fact[i - 1] * i % mod;
inv_fact[i] = mod_inverse(fact[i]);
}
rep1(k, n + 1) {
ll ans = 0;
(ans += comb(n - 1, k)) %= mod;
(ans += comb(n - l, k - 1)) %= mod;
((ans += 2LL * (comb(n - 1, k - 1) - comb(n - l, k - 1))) += 3 * mod) %= mod;
(ans += comb(n - 1, k - 2)) %= mod;
ans %= mod;
cout << ans << endl;
}
return 0;
} | 1 | 25,864,270 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
int sum = 0;
for (int i = 0; i < N; i++) {
cin >> A.at(i);
sum += A.at(i);
}
sort(A.begin(), A.end());
int count = 0;
for (int i = N-1; i >= 0; i--) {
if (A.at(i) * 4 * M >= sum) {
count++;
} else {
break;
}
}
if (count >= M) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <math.h>
using namespace std;
int main(void)
{
int n, m; cin >> n >> m;
vector<int> a(n);
int sum = 0;
for (int i = 0; i < n; i++)
{
cin >> a[i];
sum += a[i];
}
sort(a.begin(), a.end());
if (4 * a[n - m] * m < sum) cout << "No" << endl;
else cout << "Yes" << endl;
} | 1 | 8,808,464 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) REP(i, 0, n)
#define rrep(i, n) for (int i = (int)(n-1); i >= 0; i--)
#define sz(x) int(x.size())
#define bitsz(x) int(__builtin_popcount(x))
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define pb(x) push_back(x)
#define INF 1e9
#define LINF 1e18
#define mod 1000000007
template<class T> inline bool chmax(T &a, const T &b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, const T &b) { if (a > b) { a = b; return 1; } return 0; }
template < typename T > inline string toString( const T &a ) { ostringstream oss; oss << a; return oss.str(); };
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
const int di[4] = {1,0,-1,0};
const int dj[4] = {0,1,0,-1};
int main() {
ll a;
double b;
cin >> a >> b;
ll ib = b*100+0.5;
a *= ib;
cout << a/100 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long int A;
double B;
cin >> A >> B;
long long int C = B*100+0.1;
A = A * C;
A /= 100;
cout << A << endl;
} | 1 | 44,181,715 |
#include<bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using v1 = vector<int>;
using vl = vector<long long>;
using v2 = vector<vector<int>>;
using v3 = vector<vector<char>>;
int main(){
int n, m;
cin >> n >> m;
v1 a(n+1, 0);
v1 b(n+1, 0);
rep(i, m){
int p;
string s;
cin >> p >> s;
if(s == "AC"){
a[p]++;
}else if(s == "WA" && a[p] == 0){
b[p]++;
}
}
int ac = 0;
int wa = 0;
rep(i, n){
if(a[i+1] != 0){
ac++;
wa += b[i+1];
}
}
cout << ac << " " << wa << endl;
} | #include <bits/stdc++.h>
#include <regex>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
int main(){
int n,m;
cin>>n>>m;
vector<vector<int>>vec(n,vector<int>(2));
int p;
string s;
rep(i,m){
cin>>p>>s;
if(s=="AC"){
vec.at(p-1).at(0)=1;
}else{
if(vec.at(p-1).at(0)==0){
vec.at(p-1).at(1)+=1;
}
}
}
int ac,wa;
ac=0;
wa=0;
rep(i,n){
ac+=vec.at(i).at(0);
if(vec.at(i).at(0)==1){
wa+=vec.at(i).at(1);}
}
cout<<ac<<" "<<wa<<endl;
} | 1 | 17,300,897 |
#include<iostream>
using namespace std;
long N,a,b=10;
int main(){
cin>>N;
if(N&1){
cout<<0<<endl;
return 0;
}
while(b<=N){
a+=N/b;
b*=5;
}
cout<<a<<endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int unsigned long long
#define M 1000000007
int gcd(int a,int b){
if(b==0){
return(a);
}
return(gcd(b,a%b));
}
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);cout.tie(NULL);
int n;
cin >> n;
int d=10;
int ans=0;
if(n%2!=0){
cout << 0 << endl;
exit(0);
}
while(d<=n){
ans+=(n/d);
d*=5;
}
cout << ans << endl;
} | 1 | 53,414,840 |
#include <bits/stdc++.h>
using namespace std;
#define rep0(i,n) for(int i=0;i<(int)(n);i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
#define ll long long
#define coYes cout << "Yes" << endl
#define coYES cout << "YES" << endl
#define coyes cout << "yes" << endl
#define coNo cout << "No" << endl
#define coNO cout << "NO" << endl
#define cono cout << "no" << endl
#define BIT_FLAG_0 (1<<0)
int gcd(int a, int b){
if(a%b == 0){
return b;
}else{
return gcd(b, a%b);
}
}
int main(){
string s;
cin >> s;
rep0(i,2){
if(s[i]!=s[i+1]){
coYes;
return 0;
}
}
coNo;
return 0;
} | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
constexpr char ln = '\n';
constexpr long long MOD = 1000000007LL;
constexpr long long INF = 1001001001LL;
constexpr long long LINF = 1001001001001001001;
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define rept(i, j, n) for(int i=(j); i<(n); i++)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main(){
string s; cin >> s;
set<char> st;
rep(i, 3) st.insert(s[i]);
if(st.size()==1)cout << "No" << ln;
else cout << "Yes" << ln;
} | 1 | 50,029,675 |
#include<bits/stdc++.h>
using namespace std;
#define fo(i,a,n) for(i=a;i<n;i++)
#define ll long long
#define deb(x) cout << #x << "=" << x << endl
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define sortrev(x) sort(all(x),greater<int>())
#define pi 3.1415926535897932384626
typedef pair<int,int> pii;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpii;
typedef vector<pl> vpl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef vector<double> vd;
const int mod = 100000007;
const int inf = 100000005;
const int N = 200005, M = N;
int i,j,n,m;
ll cnt , idx;
vi temp;
void solve() {
ll n;
cin>>n;
ll x;
set<ll>st;
fo(i,0,n) cin>>x , st.insert(x);
if(st.size() == n) cout<<"YES\n";
else cout<<"NO\n";
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
while(t--) {
solve();
}
return 0;
} | #include<iostream>
#include<vector>
#include<algorithm>
#include<set>
using namespace std;
using ll = long long;
int main(){
int n;
cin >> n;
vector<ll> a(n);
for(int i=0;i<n;i++){
cin >> a.at(i);
}
set<ll> a2(a.begin(),a.end());
if(a2.size() == n){
cout << "YES" << endl;
}else{
cout << "NO" << endl;
}
} | 1 | 4,246,396 |
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <stdio.h>
#include <cstring>
#include <iomanip>
#define _USE_MATH_DEFINES
#include <math.h>
#include <numeric>
using namespace std;
int main()
{
while (1)
{
char ch[1000];
char* pch;
pch = ch;
memset(ch, 0, sizeof(ch));
string x;
cin >> x;
if (x == "0")break;
strcpy(ch, x.c_str());
int sum = 0;
int index = 0;
while (*pch)
{
sum += (*pch - 0x30);
pch++;
}
cout << sum << endl;
}
return 0;
} | #include<iostream>
#include<string>
using namespace std;
int main()
{
string number;
while (cin >> number, number != "0") {
int sum = 0;
for (int i = 0; i < number.size(); i++) {
sum += number[i] - '0';
}
cout << sum << endl;
}
return 0;
} | 1 | 45,296,302 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 2e5 + 5;
const int INF = 0x3f3f3f3f;
const ll p = 1e9 + 7;
#define DEBUG(x) cout << (x) << '\n'
#define fi first
#define se second
char s[MAXN];
void run(){
cin >> s + 1;
int x = 0;
for(int i = 1; s[i]; i++)
x += s[i] - '0';
DEBUG(x % 9 == 0 ? "Yes" : "No");
}
int main(){
#ifdef Irene
freopen("in.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
run(); return 0;
} | #include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<cstring>
#include<queue>
#include<tuple>
#include<utility>
#include<map>
#include<math.h>
#include<iomanip>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define FOR(i, a, b) for (int i=a; i<(b); i++)
#define range(a) a.begin(), a.end()
#define endl "\n"
#define Yes() cout << "Yes" << endl
#define No() cout << "No" << endl
using Graph = vector<vector<int>>;
const unsigned long long mod = 1e9 + 7;
const long long INF = 1LL<<60;
const int dx[4]={1,0,-1,0};
const int dy[4]={0,1,0,-1};
void chmin(long long &a, long long b) { if (a > b) a = b; }
void chmax(long long &a, long long b) { if (a < b) a = b; }
int main(void){
ios::sync_with_stdio(0);
cin.tie(0);
string S; cin>>S;
int sum=0;
FOR(i,0,S.size()){
sum+=S.at(i) -'0';
}
if(sum%9==0) Yes();
else No();
return 0;
} | 1 | 27,051,496 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n, m) for (int i = n; i < (int)(m); i++)
#define all(v) v.begin(), v.end()
#define int long long
#define _GLIBCXX_DEBUG
signed main() {
int N; cin >> N;
int fb=0, ea=0, n=0;
string s;
int ans = 0;
rep(i, 0, N) {
cin >> s;
if(s[0] == 'B') {
fb++;
}
if(s[s.size()-1] == 'A') {
ea++;
}
if(s[s.size()-1] == 'A' || s[0] == 'B') {
n++;
}
rep(j, 0, s.size()-1) {
if(s[j] == 'A' && s[j+1] == 'B') ans++;
}
}
int k=0;
ans += min(min(fb, ea), max(k, n-1));
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int nab=0,nea=0,nfb=0,eafb=0;
for(int i=0;i<n;i++) {
string s;
cin >> s;
if(*s.begin()=='B'&&s[s.size()-1]!='A') nfb++;
if(*s.begin()!='B'&&s[s.size()-1]=='A') nea++;
if(*s.begin()=='B'&&s[s.size()-1]=='A') eafb++;
for(int j=0;j<s.size()-1;j++) {
if(s.substr(j,2)=="AB") nab++;
}
}
int temp;
if(nea+nfb==0) {
temp=max(eafb-1,0);
}
else {
temp=eafb+min(nea,nfb);
}
cout << nab + temp << endl;
} | 1 | 16,827,782 |
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = a; i < b; i++)
#define Rep(i, a, b) for(int i = a; i <= b; i++)
#define repr(i, a, b) for(int i = a; i >= b; i--)
#define _GLIBCXX_DEBUG
#define Vl vector<ll>
#define Vs vector<string>
#define Vp vector<pair<ll, ll>>
#define P pair<ll, ll>
using ll = long long;
#define ALL(v) (v).begin(),(v).end()
#define endl "\n"
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define co(x) cout << x << endl
#define coel cout << endl
#define pb push_back
#define sz(v) ((ll)(v).size())
using namespace std;
const double pi = acos(-1.0);
const ll MOD = 1e9 + 7;
const ll INF = 1LL << 60;
#define pp pair<ll, pair<ll, ll>>
#define fi first
#define se second
void print(Vl vec){
rep(i, 0, sz(vec)){
if(i) cout << " ";
cout << vec[i];
}
coel;
}
int main() {
ll n; cin >> n;
string s; cin >> s;
ll cnt = 0;
ll a = 0, b = 0;
rep(i, 0, n){
if(s[i]=='(') cnt++;
else{
if(cnt==0) a++;
else cnt--;
}
}
cnt = 0;
for(int i = n-1; i >= 0; i--){
if(s[i]==')') cnt++;
else{
if(cnt==0) b++;
else cnt--;
}
}
rep(i, 0, a) cout << '(';
cout << s;
rep(i, 0, b) cout << ')';
coel;
return 0;
} | #include <bits/stdc++.h>
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i, n) for(int i = 0; i < (n); i++)
using namespace std;
signed main(void)
{
int n, l, out_l, out_r;
string s;
cin >> n >> s;
l = out_l = out_r = 0;
rep(i, n)
{
if (s[i] == ')')
{
if (out_r > 0)
out_r--;
if (l == 0)
out_l++;
else
l--;
}
else if(s[i] == '(')
{
l++;
out_r++;
}
}
rep(i, out_l)
cout << '(';
cout << s;
rep(i, out_r)
cout << ')';
cout << endl;
} | 1 | 71,475,821 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
int main() {
string S;
cin >> S;
int N = S.size();
string key = "keyence";
bool yes = true;
for(int i = 0; i < 7; i++) {
if(S[i] != key[i]) {
yes = false;
break;
}
}
if(yes) {
cout << "YES";
return 0;
}
yes = true;
for(int i = 0; i < 7; i++) {
if(S[N - 1 - i] != key[6 - i]) {
yes = false;
break;
}
}
if(yes) {
cout << "YES";
return 0;
}
for(int i = 0; i < 7; i++) {
yes = true;
for(int j = 0; j < i; j++) {
if(S[j] != key[j]) {
yes = false;
break;
}
}
for(int j = N - 1; j >= N - 1 - (6 - i); j--) {
if(S[j] != key[6 - (N - 1 - j)]) {
yes = false;
break;
}
}
if(yes) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
} | #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);
string S;
cin >> S;
bool flg = false;
for(int n = 0; n <= S.size()-1; n++){
for(int m = 0; m <= S.size()-n; m++){
string T = S;
if(T.erase(n,m) == "keyence"){
flg = true;
break;
}
}
if(flg) break;
}
cout << (flg ? "YES" : "NO") << endl;
} | 1 | 34,383,175 |
#include <cmath>
#include<iostream>
#include<vector>
#include<algorithm>
#include<map>
#include<iomanip>
#include<queue>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
ll inf = 1000000007;
vector<ll>to[100005];
int main(void) {
ll n, m;
cin >> n >> m;
int a, b;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--; b--;
to[a].push_back(b);
to[b].push_back(a);
}
queue<ll>que;
vector<ll>dist(n, inf);
vector<ll>pre(n, -1);
dist[0] = 0;
que.push(0);
while (!que.empty()) {
int x = que.front();
que.pop();
for (auto v : to[x]) {
if (dist[v] != inf) {
continue;
}
dist[v] = dist[x] + 1;
pre[v] = x + 1;
que.push(v);
}
}
cout << "Yes" << endl;
for (int i = 1; i < n; i++) {
cout << pre[i] << endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int n, m; cin >> n >> m;
vector<vector<int>> graph(n+1);
for(int i = 0; i < m; i++){
int a, b; cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
queue<int> que;
que.push(1);
vector<int> seen(n+1, -1);
seen[1] = 1;
vector<int> parent(n+1);
while(!que.empty()){
int nv = que.front();
que.pop();
for(int v : graph[nv]){
if(seen[v] != -1) continue;
que.push(v);
seen[v] = 1;
parent[v] = nv;
}
}
cout << "Yes" << endl;
for(int i = 2; i <= n; i++) cout << parent[i] << endl;
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
int a=1;
}}
} | 1 | 32,787,488 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);cout.tie(NULL);
int n,m;
cin>>n>>m;
vector<string> s(m);
vector<int>p(m);
for(int i=0;i<m;i++) cin>>p[i]>>s[i];
int val[n+1]={0};
int cor[n+1]={0};
for(int i=0;i<m;i++){
if(s[i]=="AC"){
cor[p[i]]=1;
}
else{
if(cor[p[i]]==0) val[p[i]]--;
}
}
int ans=0,pen=0;
for(int i=1;i<=n;i++){
if(cor[i]) ans++;
if(cor[i]) pen +=abs(val[i]);
}
cout<<ans<<" "<<pen<<"\n";
} | #include <bits/stdc++.h>
#include <limits.h>
#define rep(i, n) for(int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
int main() {
int n, m;
cin >> n >> m;
vector<int> ac(n);
vector<int> wa(n);
int p;
string s;
int ansa = 0;
rep(i, m) {
cin >> p >> s;
if(!ac[p-1]) {
if(s == "AC") {
ansa++;
ac[p-1] = 1;
} else if(s=="WA"){
wa[p-1]++;
}
}
}
int answ = 0;
rep(i,n){
if(ac[i]){
answ += wa[i];
}
}
cout << ansa << " " << answ << endl;
} | 1 | 5,347,606 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll INF = 1LL << 62;
const double PI = acos(-1);
const double eps = 1e-10;
int main() {
ll a, b, k;
cin >> a >> b >> k;
cout << max(a - k, 0LL) << " " << max(b - max(k - a, 0LL), 0LL) << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
const int INF = 1001001001;
int main(){
ll a,b,k;
cin >> a >> b >> k;
ll ans_a = max((ll)0,a-k);
k = max((ll)0,k-a);
ll ans_b = max((ll)0,b-k);
cout << ans_a << " " << ans_b << endl;
} | 1 | 31,007,728 |
#include <stdio.h>
#include <string.h>
int dp[51][5];
void init() {
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (int i = 0; i <= 50; ++i) {
for (int j = 1; j <= 4; ++j) {
for (int t = 0; t < 10 && t <= i; ++t) {
dp[i][j] += dp[i-t][j-1];
}
}
}
}
int main() {
int n;
init();
while (scanf("%d", &n) == 1) {
int result = dp[n][4];
printf("%d\n", result);
}
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <cmath>
using namespace std;
#define REPS(i, a, n) for (int i = (a); i < (n); ++i)
#define REP(i, n) REPS(i, 0, n)
#define RREP(i, n) REPS(i, 1, n + 1)
#define DEPS(i, a, n) for (int i = (a); i >= n; --i)
#define DEP(i, n) DEPS(i, n, 0)
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
using pis = pair<int, string>;
using psi = pair<string, int>;
using D = double;
int main(){
int n, cnt=0;
while(cin >> n){
cnt = 0;
REP(i, 10) REP(j, 10) REP(k, 10) REP(l, 10) if(i + j + k + l == n) cnt++;
cout << cnt << endl;
}
return 0;
} | 1 | 64,626,326 |
#include<stdio.h>
int a[10000]={1,1};
int kaishi(int n){
if(a[n])return a[n];
a[n]=kaishi(n-1)+kaishi(n-2);
return a[n];
}
int main(){
int n;
scanf("%d",&n);
printf("%d\n",kaishi(n));
return 0;
} | #include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <deque>
#include <complex>
#include <stack>
#include <queue>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <ctime>
#include <iterator>
#include <bitset>
#include <numeric>
#include <list>
#include <iomanip>
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
typedef pair<LL,LL> pll;
typedef vector<int> vint;
typedef vector<vector<int> > vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long> > vvll, vvLL;
#define VV(T) vector<vector< T > >
template <class T>
void initvv(vector<vector<T> > &v, int a, int b, const T &t = T()){
v.assign(a, vector<T>(b, t));
}
template <class F, class T>
void convert(const F &f, T &t){
stringstream ss;
ss << f;
ss >> t;
}
#define REP(i,n) for(int i=0;i<int(n);++i)
#define ALL(v) (v).begin(),(v).end()
#define RALL(v) (v).rbegin(),(v).rend()
#define PB push_back
#define MOD 1000000009LL
#define EPS 1e-8
#define NMAX 44
int F[NMAX];
void initialize(){
for( int i = 0; i < NMAX; i++ ){
F[i] = 0;
}
}
int fibonacci(int n){
if( n == 0 || n == 1 ) return 1;
if( F[n] != 0) return F[n];
return F[n] = fibonacci( n - 1 ) + fibonacci( n - 2);
}
int main(){
int n;
scanf("%d", &n);
int ans = fibonacci(n);
printf("%d\n", ans);
return 0;
} | 1 | 10,505,095 |
#include<bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define rep2(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define rep_inv(i, n, m) for(int i = (int)(n); i > (int)(m); i--)
using namespace std;
using ll = long long;
using vl = vector<ll>;
using vc = vector<char>;
using vvl = vector<vl>;
using vvc = vector<vc>;
using pll = pair<ll, ll>;
using vpii = vector<pll>;
int main(){
ll H, W;
cin >> H >> W;
vvl A(H, vl(W, 0));
string row;
queue<vl> que;
rep(i, H){
cin >> row;
rep(j, W){
if(row[j] == '#'){
A[i][j] = 1;
que.push({i, j});
}
}
}
ll cnt = 0;
vl frt, bck;
while(true){
bck = que.back();
while(true){
frt = que.front();
que.pop();
if((frt[0] > 0) && (A[frt[0] - 1][frt[1]] == 0)){
A[frt[0] - 1][frt[1]] = 1;
que.push({frt[0] - 1, frt[1]});
}
if((frt[0] < H - 1) && (A[frt[0] + 1][frt[1]] == 0)){
A[frt[0] + 1][frt[1]] = 1;
que.push({frt[0] + 1, frt[1]});
}
if((frt[1] > 0) && (A[frt[0]][frt[1] - 1] == 0)){
A[frt[0]][frt[1] - 1] = 1;
que.push({frt[0], frt[1] - 1});
}
if((frt[1] < W - 1) && (A[frt[0]][frt[1] + 1] == 0)){
A[frt[0]][frt[1] + 1] = 1;
que.push({frt[0], frt[1] + 1});
}
if((bck[0] == frt[0]) && (bck[1] == frt[1])) break;
}
if(que.empty()) break;
cnt++;
}
cout << cnt << endl;
return 0;
} | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
constexpr char ln = '\n';
constexpr long long MOD = 1000000007LL;
constexpr long long INF = 1001001001LL;
constexpr long long LINF = 1001001001001001001;
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define rept(i, j, n) for(int i=(j); i<(n); i++)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main(){
int h, w; cin >> h >> w;
vector<string> grid(h+2);
rept(i, 1, h+1){
string s; cin >> s;
grid[i] = "*" + s + "*";
}
grid[0] = "";
grid[h+1] = "";
rep(i, w+10){
grid[0] += "*";
grid[h+1] += "*";
}
const int dx[4] = {0,0,-1,1};
const int dy[4] = {1,-1,0,0};
vector<vector<int>> costs(h+2, vector<int>(w+2, INF));
queue<pii> que;
rept(i, 1, h+1){
rept(j, 1, w+1){
if(grid[i][j]=='#'){
que.push({i, j});
costs[i][j] = 0;
}
}
}
while(!que.empty()){
auto p = que.front(); que.pop();
int y = p.first, x = p.second;
rep(k, 4){
int nx = x + dx[k], ny = y + dy[k];
if(grid[ny][nx] == '.'){
grid[ny][nx] = '#';
costs[ny][nx] = costs[y][x] + 1;
que.push({ny, nx});
}
}
}
int res = -INF;
rept(i, 1, h+1){
rept(j, 1, w+1){
chmax(res, costs[i][j]);
}
}
cout << res << ln;
} | 1 | 63,923,734 |
#include "bits/stdc++.h"
#define in std::cin
#define out std::cout
#define rep(i,N) for(LL i=0;i<N;++i)
typedef long long int LL;
const LL inf = 112345678901234567;
LL get_max(std::vector<LL>v)
{
LL res = 0;
rep(i, v.size()) res = std::max(res, v[i]);
return res;
}
LL get_min(std::vector<LL>v)
{
LL res = inf;
rep(i, v.size()) res = std::min(res, v[i]);
return res;
}
int main()
{
LL N;
in >> N;
std::vector<LL>a(N);
rep(i, N) in >> a[i];
LL ans = 0;
while (true)
{
std::sort(a.begin(), a.end());
if (a[N - 1] <= N - 1) break;
if (a[N - 1] - a[0] <= N * N)
{
LL add = std::max<LL>(a[N - 1] - N * N, 0);
ans += add * N;
rep(i, N) a[i] -= add;
do
{
rep(j, N - 1) ++a[j];
a[N - 1] -= N;
++ans;
std::sort(a.begin(), a.end());
} while (a[N - 1] > N - 1);
break;
}
LL left = 0, right = inf;
while (right - left > 1)
{
LL mid = (right + left) / 2;
auto a_ = a;
rep(i, N - 1) a[i] += mid;
a[N - 1] -= N * mid;
if (a[N - 1] < a[0] || get_max(a) <= N - 1) right = mid;
else left = mid;
a = a_;
}
rep(i, N - 1) a[i] += right;
a[N - 1] -= N * right;
ans += right;
}
out << ans << std::endl;
} | #include <bits/stdc++.h>
#define ALL(A) (A).begin(), (A).end()
#define ll long long
#define rep(i, n) for (int i = 0; i < (n); i++)
const ll mod = 1e9 + 7;
const ll INF = -1 * ((1LL << 63) + 1);
const int inf = -1 * ((1 << 31) + 1);
using namespace std;
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
vector<ll> a(N);
rep(i, N) cin >> a[i];
ll ans = 0;
rep(x, 1e4)
{
rep(i, N)
{
if (a[i] >= N)
{
ll del = a[i] / N;
ans += del;
a[i] -= del * N;
rep(j, N) if (i != j) a[j] += del;
}
}
}
cout << ans << endl;
} | 1 | 88,387,406 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
string S, T;
cin>>S>>T;
int ans = 1001;
int l1 = S.length(), l2 = T.length();
for (int i=0; i<=(l1-l2); i++) {
int c = 0;
for (int j=0; j<l2; j++) {
if (S[i+j] != T[j]) c++;
}
ans = min(ans, c);
}
cout << ans << '\n';
return 0;
} | #include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define ll long long
#define mod 1000000007
#define fi first
#define se second
#define inf 4e18
#define lim 1000000000000
#define pll pair<ll,ll>
#define pb push_back
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define el "\n"
#define vll vector<ll>
#define vpll vector<pll>
#define vppll vector<pair<ll,pll> >
#define vvpll vector<vector<pair<ll,ll> > >
#define vvll vector<vector<ll> >
#define vvc vector<vector<char> >
#define vc vector<char>
ll gcd(ll a,ll b){if(b==0)return a;else return gcd(b,a%b);}
ll xpow(ll a,ll b,ll m)
{
if(!b)
return 1%m;
if(b==1)
return a%m;
if(b&1)
{
return(((a%m)*xpow(a,b-1,m))%m);
}
else
{
ll p=xpow(a,b/2,m);
return((p*p)%m);
}
}
const ll zzz=1e3+5;
ll nCr[zzz][zzz];
void cal()
{
nCr[0][0]=1;
for(ll i=1;i<zzz;i++)
{
nCr[i][0]=1;
for(ll j=1;j<zzz;j++)
{
nCr[i][j]=(nCr[i-1][j]+nCr[i-1][j-1])%mod;
}
}
}
const ll N=1e5+5;
bool check_prime(ll n)
{
for(ll i=2;i*i<=n;i++)
{
if(n%i==0)
return 0;
}
return 1;
}
ll solve(string a,string b){
ll ans=0;
for(ll i=0;i<a.length();i++){
ans+=(a[i]!=b[i]);
}
return ans;
}
void doit()
{
string s,t;cin>>s>>t;
ll n=s.length(),m=t.length();
ll ans=inf;
for(ll i=m-1;i<n;i++){
string a=s.substr(i-m+1,m);
ans=min(ans,solve(a,t));
}
cout<<ans;
cout<<el;
}
int32_t main()
{
ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
cal();
ll t;
t=1;
while(t--)
{
doit();
}
return 0;
} | 1 | 1,620,302 |
#include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
constexpr ll MOD = 1000000007;
int main(void) {
int N, v[100010];
cin >> N;
for (int i=0;i<N;i++) cin >> v[i];
vector<int> O(100010,0),E(100010,0);
for (int i=0;i<N;i+=2) O[v[i]]++;
for (int i=1;i<N;i+=2) E[v[i]]++;
multimap<int,int,greater<int>> Om, Em;
Om.emplace(0,0), Em.emplace(0,0);
for (int i=0;i<100010;i++) {
if (O[i]) Om.emplace(O[i],i);
if (E[i]) Em.emplace(E[i],i);
}
auto oitr = Om.begin(), eitr = Em.begin();
bool flag = false;
while (oitr->second == eitr->second) {
oitr++; eitr++;
flag = true;
if (oitr == Om.end()) break;
}
if (oitr == Om.end()) {
oitr = Om.begin(), eitr = Em.begin();
eitr++;
} else if (flag) {
if (oitr->first < eitr->first) {
oitr = Om.begin(), eitr = Em.begin();
eitr++;
} else {
oitr = Om.begin(), eitr = Em.begin();
oitr++;
}
}
cout << N - oitr->first - eitr->first << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<pair<int,int>> vpii;
#define F first
#define S second
#define PU push
#define PUF push_front
#define PUB push_back
#define PO pop
#define POF pop_front
#define POB pop_back
#define REP(i,a,b) for(int i=a; i<=b; i++)
#define MOD 1000000007
void solve(int test_case) {
int n;
cin>>n;
unordered_map<int,int> a,b;
bool flag = true;
REP(i,1,n) {
int val;
cin>>val;
if(flag)a[val]++;
else b[val]++;
flag=!flag;
}
int a1=0,a1v=0,a2=0;
int b1=0,b1v=0,b2=0;
for(auto p:a) {
if(p.S>=a1) {
a2=max(a2,a1);
a1=p.S;
a1v=p.F;
} else {
a2=max(a2,p.S);
}
}
for(auto p:b) {
if(p.S>=b1) {
b2=max(b1,b2);
b1=p.S;
b1v=p.F;
} else {
b2=max(b2,p.S);
}
}
if(a1v==b1v) {
cout<<min(max(0,n-b1-a2),max(0,n-a1-b2));
} else {
cout<<n-a1-b1;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t=1;
REP(i,1,t) {
solve(i);
}
return 0;
} | 1 | 46,122,502 |
#include<bits/stdc++.h>
#define M ll(1e9 + 7)
#define maxn 2003
using namespace std;
typedef long long ll;
int n, m;
int a[maxn];
int b[maxn];
ll dp[maxn][maxn];
int main(){
ios_base::sync_with_stdio(0); cin.tie(); cout.tie();
cin >> n >> m;
for (int i = 1; i <= n; ++i)
cin >> a[i];
for (int i = 1; i <= m; ++i)
cin >> b[i];
dp[0][0] = 1;
for (int i = 1; i <= n; ++i)
dp[i][0] = 1;
for (int j = 1; j <= m; ++j)
dp[0][j] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
dp[i][j] = (dp[i - 1][j] + dp[i][j - 1] - (a[i] == b[j] ? 0 : dp[i - 1][j - 1]) + M) % M;
cout << dp[n][m];
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define sz(a) int(a.size())
#define ll long long int
#define mod (long long)(1e9+7)
#define endl '\n'
#define ENGZ ios::sync_with_stdio(0);ios_base::sync_with_stdio(0);cin.tie(0) , cout.tie(0) ;
#define pi (acos(-1))
#define F first
#define S second
ll fp(ll n , ll p )
{
if(p==0)
return 1;
if(p==1)
return n ;
ll res = fp(n,p/2);
res=((res)*(res)) ;
if(p%2)
res=(res*n) ;
return res ;
}
ll n , m , arr[2005] , brr[2005] , com[2005];
int main()
{
ENGZ;
cin>>n >>m ;
for(int i=0 ; i<n ; i++)cin>>arr[i] ;
for(int i=0 ; i<m ;i++)cin>>brr[i] ;
for(int i=0 ; i<m ; i++)
{
ll tmp = 0 ;
for(int j=0 ; j<n ; j++)
{
if(j>0)
{
if(arr[j] == brr[i])
{
ll tt = tmp+ com[j] ;
com[j] += (tmp+1)%mod;
tmp = tt ;
}
else
{
tmp+=com[j] ;
}
continue;
}
tmp += com[j] ;
if(arr[j] == brr[i])
com[j]++ ;
}
}
ll ans = 0;
for(int i=0 ; i<n ; i++)
{
ans+=com[i] ;
ans %= mod ;
}
cout<<ans+1 <<endl ;
return 0;
} | 1 | 17,945,235 |
#include <iostream>
#include <iomanip>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <string>
#include <algorithm>
#include <string>
#include <climits>
#include <utility>
#define REP(i, n) for (int (i) = 0; (i) < (int)(n); (i)++)
#define REG(i, a, b) for (int (i) = ((int)(a)); (i) < ((int)(b)); i++)
#define ALL(V) (V).begin(), (V).end()
#define PRINT(STR) cout << (STR) << endl
#define ROUNDED(N) fixed << setprecision(N)
#define SPACE " "
typedef long long ll;
using namespace std;
int nextInt() { int n; cin >> n; return n; }
double nextDouble() { double d; cin >> d; return d; }
string nextString() { string str; cin >> str; return str; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n,m;
while(cin>>n>>m,n){
vector<pair<int,int>> load(n);
REP(i,n)cin >> load[i].second >> load[i].first;
sort(load.begin(),load.end());
reverse(load.begin(),load.end());
for(int i = 0;m>0&&i<n;i++){
if(m-load[i].second>=0){
m -= load[i].second;
load[i].second = 0;
}else{
load[i].second -= m;
m = 0;
}
}
int ans=0;
REP(i,n)ans += load[i].first * load[i].second;
cout << ans << endl;
}
return 0;
} | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <map>
#include <set>
#include <vector>
#include <stack>
#include <queue>
#include <bitset>
#include <algorithm>
#include <numeric>
#include <functional>
using namespace std;
#define Rep(b, e, i) for(int i = b; i <= e; i++)
#define Repr(e, b, i) for(int i = e; i >= b; i--)
#define rep(n, i) Rep(0, n-1, i)
#define repr(n, i) Repr(n-1, 0, i)
#define all(v) (v).begin(), (v).end()
#define pb(x) push_back(x)
#define uniq(x) (x).erase(unique(all(x)),(x).end())
typedef long long ll;
typedef pair<ll, ll> llP;
typedef pair<int, int> P;
typedef std::priority_queue<int> IntPrioQueue;
typedef std::priority_queue<int, std::vector<int>, std::greater<int> > IntReversePrioQueue;
const int MAX = 200000;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const int INF = 1<<29;
const int MOD = 1000000007;
int N, d, p;
ll M, ans = 0LL;
void solve(void){
while (1) {
scanf("%d %lld\n", &N, &M);
if (N==0&&M==0) return;
ans = 0LL;
vector <P> v(N);
rep(N, i) {
scanf("%d %d\n", &d, &p);
v.pb(P(p, d));
ans += p*d;
}
sort(all(v));
reverse(all(v));
for (P pd : v) {
if (pd.second > M) {
ans -= pd.first*M;
break;
}
ans -= pd.first*pd.second;
M -= pd.second;
}
printf("%lld\n", ans);
}
}
int main(void){
solve();
return 0;
} | 1 | 21,699,592 |
#include <iostream>
using namespace std;
int main (void) {
int a, b, c, d, ttl;
cin >> a >> b >> c >> d;
if (a < b) {
ttl += a;
} else {
ttl += b;
}
if (c < d) {
ttl += c;
} else {
ttl += d;
}
int ans = ttl;
cout << ans << endl;
} | #include <iostream>
int main() {
int a, b, c, d; std::cin >> a >> b >> c >> d;
std::cout << (std::min(a, b) + std::min(c, d))<< std::endl;
return 0;
} | 1 | 24,589,809 |
#include <cstdio>
#include <vector>
using namespace std;
int main(){
int n, k;
while( scanf("%d %d", &n, &k), n && k ){
vector<int> data(n);
for( int i=0; i<n; i++ ){
scanf("%d", &data[i]);
}
int ans = 0;
int sum = 0;
for( int i=0; i<k; i++ ) sum += data[i];
for( int i=k; i<n; i++ ){
sum += data[i] - data[i-k];
ans = max(ans, sum);
}
printf("%d\n", ans);
}
} | #include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
typedef double db;
ll n,k;
ll val[100000];
ll sum[100000];
int main()
{while(1){
memset(val,0,sizeof(val));
memset(sum,0,sizeof(sum));
cin>>n>>k;
if(!n) return 0;
for(ll i=0;i<n;i++) cin>>val[i];
for(ll i=0;i<k;i++) sum[0]+=val[i];
ll ans=sum[0];
for(ll i=1;i<=n-k;i++){
sum[i]=sum[i-1]-val[i-1]+val[i+k-1];
ans=max(ans,sum[i]);
}
cout<<ans<<endl;
}} | 1 | 69,566,960 |
#include <iostream>
using namespace std;
int main()
{
int n;
n=10000;
for(int i=0;i<n;i++){
int x,y;
cin>>x>>y;
if(x>y){
cout<<y<<" "<<x<<endl;}
else if(x==0&&y==0)
{return 0;}
else{
cout<<x<<" "<<y<<endl;
}
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b;
while(cin >> a >> b && (a > 0 || b > 0))
if (a < b) cout << a << " " << b << "\n";
else cout << b << " " << a << "\n";
} | 1 | 42,378,335 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep1(i, n) for(int i = 1; i < n+1; i++)
#define all(A) A.begin(),A.end()
typedef long long ll;
const ll MOD = (ll)pow(10,9)+7;
int main(){
int s;
cin >> s;
vector<vector<ll>> pas(2001,vector<ll>(2001));
pas[0][0] = 1;
rep(i,2000){
rep(j,2000){
pas[i+1][j] += pas[i][j];
pas[i+1][j] %= MOD;
pas[i+1][j+1] += pas[i][j];
pas[i+1][j] %= MOD;
}
}
ll ans = 0;
for(int i=1;3*i<=2000;i++){
if(s < i*3) break;
int h = s - 3*i;
ans += pas[h+i-1][i-1];
ans %= MOD;
}
cout << ans << endl;
} | #include <iostream>
#include<unordered_map>
#include<bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int p)
{
long long int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0)
{
if (y & 1)
res = (res*x) % p;
y = y>>1;
x = (x*x) % p;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t=1;
while(t--)
{
long long int sum;
cin>>sum;
long long int p=1e9+7;
long long int arr[2005]={0};
for(int i=3;i<=sum;i++)
{
arr[i]=1;
}
for(int i=4;i<=sum;i++)
{
for(int j=3;j<=i;j++)
{
arr[i]+=arr[i-j]%p;
arr[i]%=p;
}
}
cout<<arr[sum]<<endl;
}
return 0;
} | 1 | 35,930,313 |
#include <bits/stdc++.h>
#define PI 3.14159265359
#define rep(i,a,n) for(int i=a;i<(int)n;++i)
#define SZ(x) ((int)(x).size())
#define descSort(a) sort(a.begin(),a.end(),std::greater<int>())
using namespace std;
typedef long long ll;
const ll INF = 1e9 + 7;
ll gcd(ll x,ll y){
if(x%y==0)return y;
return gcd(y,x%y);
}
int main(void){
int n;
cin>>n;
vector<int> h(n);
rep(i,0,n){
cin>>h[i];
}
int ans=h[0];
rep(i,0,n-1){
int tmp=h[i];
if(tmp<h[i+1]){
ans+=h[i+1]-tmp;
}
}
cout<<ans<<endl;
return 0;
} | #include <iostream>
#include <algorithm>
#include <stdio.h>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <cstring>
#include <unordered_map>
#include <queue>
#define mod 998244353
#define int long long
#define ld long double
#define pb push_back
#define vi vector<int>
#define dbg(x) cerr << #x << " = " << x << '\n'
#define sz(x) (int)x.size()
#define all(a) (a.begin(),a.end())
#define ff first
#define ss second
#define pii pair<int,int>
#define lcm(a,b) (a*b)/__gcd(a,b)
using namespace std;
inline void solve(){
int n,ans=0; cin>>n;
int a[n],mn=1000;
for (int i=0;i<n;i++){
cin >> a[i];
if (i==0) ans=a[i];
else ans += max(0LL,a[i]-a[i-1]);
}
cout << ans << endl;
}
signed main()
{
int n=1;
while (n--) solve();
return 0;
} | 1 | 69,688,419 |
#include <bits/stdc++.h>
#define ll long long int
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define vi vector<int>
#define vll vector<long long int>
#define all(v) v.begin(),v.end()
const ll MOD = 1e9 + 7;
const ll INF = 10000000000000000;
const ll MAX_N = 1e5 + 7;
using namespace std;
int main(){
int a,b,m;
cin >> a >> b >> m;
vll v1(a),v2(b);
for(int i=0;i<a;i++)cin >> v1[i];
for(int j=0;j<b;j++)cin >> v2[j];
ll k = *min_element(all(v1))+*min_element(all(v2));
ll sum = INT_MAX;
for(int i=0;i<m;i++){
ll a,b,c;
cin >> a >> b >> c;
a--,b--;
sum=min(sum,v1[a]+v2[b]-c);
}
cout << min(k,sum);
} | #include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#define rep(i,j,k) for(int i=(int)j;i<(int)k;i++)
#define ll long long
#define Sort(v) sort(all(v))
#define LINF (1LL<<40)
#define END return 0
#define pb push_back
#define se second
#define fi first
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define MP make_pair
#define int long long
#define umap unordered_map
#define re0 return 0
using namespace std;
int day[12]={31,28,31,30,31,30,31,31,30,31,30,31};
int dx[]={0,1,0,-1};
int dy[]={1,0,-1,0};
const long long MOD=1000000007LL;
bool isupper(char c){if('A'<=c&&c<='Z')return 1;return 0;}
bool islower(char c){if('a'<=c&&c<='z')return 1;return 0;}
bool isnumber(char c){return ('0'<=c&&c<='9');}
bool isalpha(char c){return (isupper(c)||islower(c));}
bool is_kaibun(string s){string rs = s;reverse(all(rs));if(s == rs)return true;else return false;}
template<typename T>
void printv(vector<T> v, bool is_endl=true){
for(int i=0;i<v.size();i++){
if(i)cout<<" ";
cout<<v[i];
}
if(is_endl)cout<<endl;
}
int INF=1e18;
template<typename T>
void printendl(vector<T> v){
for(auto date:v)cout<<date<<endl;
}
template<typename T>
void printvv(vector<vector<T>> v){
for(int i=0;i<v.size();i++){
for(int j=0;j<v[i].size();j++){
if(j)cout<<" ";
cout<<v[i][j];
}
cout<<endl;
}
}
struct Point{
int x,y,num;
double e_dis(Point other){
return sqrt((x-other.x)*(x-other.x)+(y-other.y)*(y-other.y));
}
};
int gcd(int a,int b){
if(b==0)return a;
else return gcd(b,a%b);
}
bool isPrime(int x){
if(x==1)return 0;
if(x==2)return 1;
if(x%2==0)return 0;
for(int i=3;i*i<=x;i++)if(x%i==0)return 0;
return 1;
}
vector<string> split(string s, char c){
if(s[s.size()-1]!=c)s+=c;
vector<string> v;
int pos=0;
rep(i,0,s.size()){
if(s[i]==c){
v.push_back(s.substr(pos,i-pos));
pos=i+1;
}
if(i==s.size()-1 && s.substr(pos,i-pos)!="")v.push_back(s.substr(pos,i-pos));
}
return v;
}
int f(int x){
return (3*x*x+x)/2;
}
signed main(){
int a,b,c;
cin>>a>>b>>c;
vector<int> va(a),vb(b);
rep(i,0,a)cin>>va[i];
rep(i,0,b)cin>>vb[i];
int ans=1e9;
rep(i,0,c){
int x,y,t;
cin>>x>>y>>t;
x--; y--;
ans=min(ans, max(0LL,va[x]+vb[y]-t));
}
int mia=*min_element(all(va));
int mib=*min_element(all(vb));
ans=min(ans, mia+mib);
cout<<ans<<endl;
} | 1 | 65,648,368 |
#include <stdio.h>
#include <iostream>
using namespace std;
int main(void)
{
int n;
int house[4][3][10] = {0};
cin >> n;
for (int i = 0; i < n; i++) {
int b, f, r, v;
cin >> b >> f >> r >> v;
house[b-1][f-1][r-1] += v;
}
for (int b = 0; b < 4; b++) {
for (int f = 0; f < 3; f++) {
for (int r = 0; r < 10; r++) {
cout << " " << house[b][f][r];
}
cout << "\n";
}
if (b < 3) {
cout << "####################\n";
}
}
return 0;
} | #include <iostream>
using namespace std;
int main()
{
int ndata, b, f, r, v;
int rm[4][3][10];
for(int i = 0; i < 4 ; i++) {
for(int j = 0; j < 3 ; j++)
for (int k = 0; k < 10; k++)
rm[i][j][k] = 0;
}
cin >> ndata;
for (int i = 0; i < ndata; i++) {
cin >> b >> f >> r >> v;
rm[b-1][f-1][r-1] += v;
}
for(int i = 0; i < 4 ; i++) {
for(int j = 0; j < 3 ; j++) {
for (int k = 0; k < 10; k++)
cout << ' ' << rm[i][j][k];
cout << endl;
}
if(i!=3)
cout << "####################" << endl;
}
return 0;
} | 1 | 60,533,334 |
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
int main()
{
int n, k, num, ans, sam;
while(cin >> n >> k)
{
if(!n && !k) break;
queue<int> que;
ans = 0;
sam = 0;
for(int i = 0; i < n; i++)
{
cin >> num;
que.push(num);
sam += num;
if(que.size() == k )
{
if(ans < sam)
{
ans = sam;
}
sam -= que.front();
que.pop();
}
}
cout << ans << endl;
}
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int n,k;
cin>>n>>k;
while(n!=0||k!=0){
vector<int> a(n);
for(int i=0;i<n;i++) cin>>a[i];
vector<int> S(n+1);
S[0] = 0;
for(int i=0;i<=n;i++){
S[i] = S[i-1] + a[i-1];
}
int max = 0;
int tmp = 0;
for(int i= 0;i<=n-k;i++){
tmp= S[i+k] - S[i];
if(max<tmp){
max = tmp;
}
}
cout<<max<<endl;
cin>>n>>k;
}
return 0;
} | 1 | 53,582,111 |
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <fstream>
#include <cstdlib>
#include <ctime>
#include <string>
#include <cstring>
#include <fstream>
#include <random>
#include <tuple>
#include <climits>
#include <unordered_map>
using namespace std;
long long f(long long a) {
if (a <= 0) return 0;
long long ans = 0;
for (int i=40; i>0; i--) {
if (a & (1LL<<i) && !(a & 1)) ans |= (1LL<<i);
}
ans |= (a&1)^(a>>1&1);
return ans;
}
int main() {
long long a, b;
cin>>a>>b;
cout<<(f(a-1)^f(b))<<endl;
} | #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 <math.h>
#include <cmath>
using namespace std;
#define ll long long
#define int long long
#define endl "\n"
#define all(v) v.begin(),v.end()
#define fir first
#define sec second
#define m_p make_pair
#define rep(i,n) for(int i=0; i<(int) (n); i++)
#define vecin(v) for(int i=0; i<(int)v.size(); i++)cin>>v[i];
const double pai = 3.1415926535897;
const int mod = 1000000007;
const int INF = 2000000015;
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
struct bigint{
};
int keta(int x00) {
int z00 = x00;
int w00 = 0;
while (z00 != 0) {
z00 /= 10;
w00++;
}
return w00;
}
int krag(double xx) {
return INF - (int)(INF - xx);
}
int b_s(vector<int>& vecxx, int xx) {
if (xx < vecxx[0]) {
return 0;
}
if (vecxx.back() <= xx) {
return vecxx.size();
}
int aa1 = 0, aa2 = vecxx.size() - 1, aa3;
while (aa1 + 1 < aa2) {
aa3 = (aa1 + aa2) / 2;
if (vecxx[aa3] > xx) {
aa2 = aa3;
}
else {
aa1 = aa3;
}
}
return aa2;
}
template<typename T>
void vecout(vector<T>& vec) { for (T t : vec) cout << t << " "; cout << endl; }
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int modinv(int a, int m) {
int b = m, u = 1, v = 0;
while (b) {
int t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
int modpow(int a, int n) {
int res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int gcd(int xx, int yy) {
int p = xx;
int q = yy;
if (q > p)swap(p, q);
while (p % q != 0) {
p %= q;
swap(p, q);
}
return q;
}
int lcm(int xx, int yy) {
return xx * yy / gcd(xx, yy);
}
bool prime(int xx) {
if (xx == 1) {
return 0;
}
for (int i = 2; i * i <= xx; i++) {
if (xx % i == 0) {
return 0;
}
}
return 1;
}
signed main() {
int a, b, a2, b2, t = 0;
cin >> a >> b;
a--;
if (a & 1) {
a2 = ((a+1) / 2) % 2;
}
else {
a2 = (((a+1) / 2) % 2) ^ a;
}
if (b & 1) {
b2 = ((b+1) / 2) % 2;
}
else {
b2 = (((b+1) / 2) % 2) ^ b;
}
b2 ^= a2;
cout << b2 << endl;
} | 1 | 86,860,129 |
#include <algorithm>
#include <iostream>
using namespace std;
int a[ 210 ];
int main()
{
int n;
cin >> n;
for ( int i = 0; i < 2 * n; i++ )
{
cin >> a[ i ];
}
sort( a, a + 2 * n );
long long int ans = 0;
for ( int i = 0; i < 2 * n; i += 2 )
{
ans += min( a[ i ], a[ i + 1 ] );
}
cout << ans << endl;
} | #include<iostream>
#include<bits/stdtr1c++.h>
#include<vector>
#define ll long long
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define zn(a,b,c) for(ll a=b;a<c;a++)
#define nz(a,b,c) for(ll a=b;a>c;a--)
using namespace std;
double nthRoot(int A, int N)
{
double xPre = rand() % 10;
double eps = 1e-3;
double delX = INT_MAX;
double xK;
while (delX > eps)
{
xK = ((N - 1.0) * xPre +
(double)A/pow(xPre, N-1)) / (double)N;
delX = abs(xK - xPre);
xPre = xK;
}
return xK;
}
void print(ll arr[],ll n){
zn(i,0,n){
cout<<arr[i]<<" ";
}
cout<<endl;
}
bool square(int n){
for(int i=1;i*i<=n;i++){
if((n%i==0) && (n/i==i)){
return true;
}
}
return false;
}
int main(){
ll n;
cin>>n;
ll n1=2*n;
ll arr[n1];
zn(i,0,n1) cin>>arr[i];
sort(arr,arr+n1);
ll ans=0;
for(int i=0;i<n1;i=i+2){
ans+=arr[i];
}
cout<<ans<<endl;
} | 1 | 80,452,600 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
using namespace __gnu_pbds;
using namespace std;
#define ull unsigned long long int
#define ll long long int
#define ld long double
#define MAX 1000000007
#define pll pair<ll,ll>
#define pii pair<int,int>
#define piii pair<int,pii>
#define IO ios_base::sync_with_stdio(false); cin.tie(NULL);
#define FO ifstream fin("a.in");ofstream fout("a.out");
#define TEST int testcase;cin>>testcase;while(testcase--)
#define FTEST int testcase;fin>>testcase;while(testcase--)
#define all(x) (x).begin(),(x).end()
#define mset0(x) memset((x), 0, sizeof((x)));
#define mset1(x) memset((x), -1, sizeof((x)));
#define endl "\n"
#define plll pair<ll,pll>
#define no {cout<<"NO"<<endl;return;}
#define yes {cout<<"YES"<<endl;}
const int maxn=2e5;
typedef tree<ll,null_type,less<ll>,rb_tree_tag, tree_order_statistics_node_update> indexed_set;
void solve(){
int n;
cin>>n;
int a[n+1],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;
int c=0;
for(int i=0;i<n;i++){
if(b[i]>a[i]){
cnt+=a[i];
c=a[i+1];
a[i+1]=max(0,a[i+1]-(b[i]-a[i]));
cnt+=c-a[i+1];
}
else if(b[i]<=a[i]){
cnt+=b[i];
}
}
cout<<cnt;
return;
}
int main(){
IO
solve();
return(0);
} | #include<bits/stdc++.h>
#define rep(i,N) for(int i=0;i<N;i++)
using namespace std;
typedef long long ll;
int main(){
int N;
cin>>N;
vector<int> A(N+1);
vector<int> B(N);
for(int i=0;i<=N;i++)cin>>A[i];
for(int i=0;i<N;i++)cin>>B[i];
ll a=0;
for(int i=0;i<N;i++){
int x=min(A[i],B[i]);
a+=x;
B[i]-=x;
x=min(A[i+1],B[i]);
A[i+1]-=x;
a+=x;
}
cout<<a<<endl;
return 0;
} | 1 | 23,377,851 |
#include <iostream>
using namespace std;
int main() {
int H1, M1, H2, M2, K, ans;
cin >> H1 >> M1 >> H2 >> M2 >> K;
ans = H2 * 60 + M2 - (H1 * 60 + M1);
if (ans - K < 0) cout << 0 << endl;
else cout << ans - K << endl;
return 0;
} | #include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define rep(i, n) for(int i=0;i<n;++i)
#define rrep(i, n) for(int i=n;i>=0;--i)
const int inf=1e9+7;
const ll mod=1e9+7;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
int H1, M1, H2, M2, K;
cin>>H1>>M1>>H2>>M2>>K;
int a = H1*60+M1;
int b = H2*60+M2;
cout<<max(0, b-a-K)<<endl;
} | 1 | 27,663,649 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <iomanip>
using namespace std;
using ll = long long;
#define rep(i, j, n) for(int i = (j); i < (n); ++i)
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n; cin >> n;
vector<ll> a(n);
rep(i, 0, n) cin >> a[i];
sort(a.begin(), a.end());
vector<ll> s(n + 1), t(n + 1);
rep(i, 0, n) s[i + 1] = s[i] + a[i];
rep(i, 0, n - 1) {
if (s[i + 1] * 2 < a[i + 1]) t[i + 1] = 0;
else t[i + 1] = t[i] + 1;
}
cout << t[n - 1] + 1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, from, to) for (int i = from; i < (to); ++i)
#define mp(x,y) make_pair(x,y)
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
using ll = long long;
using vin=vector<int>;
using vll=vector<ll>;
using P = pair<int, int>;
const int inf=1e9+7;
const ll INF=1e18;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
int main() {
int n;
cin>>n;
vll a(n);
rep(i,0,n) cin>>a[i];
sort(all(a));
ll sum=a[0];
int ans=0;
rep(i,0,n-1){
if(sum*2>=a[i+1]){
sum+=a[i+1];
}
else{
ans=i+1;
sum+=a[i+1];
}
}
cout<<n-ans<<endl;
} | 1 | 72,083 |
#ifdef LOCAL_JUDGE
#define _GLIBCXX_DEBUG
#endif
#define WOULD
#define YOU
#define PLEASE
#define ACCEPT
#define MY
#define SUBMISSION
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <iomanip>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <math.h>
#include <cmath>
#include <bitset>
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; }
const long long INF = 100100100100;
const long long MOD = 1000000007;
typedef pair<int,int> P;
long long mod_pow(long long N, long long M) {
if (M == 0) return 1;
long long res = mod_pow((N * N) % MOD, M / 2);
if (M & 1) res = (res * N) % MOD;
return res %= MOD;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
else return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
return a * b / gcd(a, b);
}
int main() {
long long N,K;cin >> N >> K;
vector<long long> retu(N);
for(int i = 0;i<N;i++) cin >> retu.at(i);
vector<long long> rui(N+1);
rui.at(0) = 0;
for(int i = 1;i<=N;i++){
retu.at(i-1)--;
rui.at(i) = (rui.at(i-1) + retu.at(i-1)) % K;
}
long long ans = 0;
map<long long,long long> M;
queue<int> Q;
for(int i = 0;i<=N;i++){
ans += M[rui.at(i)];
Q.push(rui.at(i));
M[rui.at(i)]++;
if(Q.size() > K-1){
int dele = Q.front();
Q.pop();
M[dele]--;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
#define vt vector
#define sz(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define fi first
#define se second
signed main() {
ios::sync_with_stdio(0), cin.tie(0);
int n, k;
cin >> n >> k;
vt<int> a(n);
for (int &i : a) cin >> i;
ll ans = 0;
vt<int> b(n + 1);
map<int, int> m;
for (int i = 0; i < n; i++) {
m[b[i]]++;
if (i >= k - 1) m[b[i - k + 1]]--;
b[i + 1] = ((b[i] - a[i] + 1) % k + k) % k;
if (m.count(b[i + 1])) ans += m[b[i + 1]];
}
cout << ans;
} | 1 | 100,359,924 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
#include <cmath>
#include <tuple>
#include <cstdio>
#include <bitset>
#include <sstream>
#include <iterator>
#include <numeric>
#include <map>
#include <cstring>
#include <set>
#include <functional>
#include <iomanip>
using namespace std;
#define DEBUG_
#ifdef DEBUG_
#define dump(x) cerr << #x << " = " << (x) << endl;
#else
#define dump(x) ;
#endif
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define SZ(x) ((int)(x).size())
#define pb push_back
#define eb emplace_back
typedef long long LL;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
template <typename T>
std::string printVector(const std::vector<T> &data)
{
std::stringstream ss;
std::ostream_iterator<T> out_it(ss, ", ");
ss << "[";
std::copy(data.begin(), data.end() - 1, out_it);
ss << data.back() << "]";
return ss.str();
}
const int MOD = 1e9+7;
const LL LINF = 1001002003004005006ll;
const int INF = 1001001001;
LL reflect(LL A, LL B){
if(A > B) swap(A,B);
if(B % A == 0){
return A * (2 * (B / A) - 1);
}
else{
return A * (2 * (B / A)) + reflect(A,B%A);
}
}
signed main(int argc, char const *argv[])
{
cin.tie(0);
ios::sync_with_stdio(false);
LL N,X; cin >> N >> X;
cout << N + reflect(X,N-X) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define sz(x) ((int) ((x).size()))
typedef long long ll;
typedef long double ld;
ll n, x;
ll f(ll a, ll b) {
return b % a == 0 ? (2 * b / a - 1) * a : 2 * a * (b / a) + f(b % a, a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
cin >> n >> x;
cout << n + f(x, n - x) << "\n";
} | 1 | 16,210,028 |