code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 1
101M
|
|---|---|---|---|
#include <bits/stdc++.h>
#include <vector>
#define rep(i, n) for(int i = 0; i < n; ++i)
#define ll long long
using namespace std;
int main() {
string n;
cin >> n;
rep(i, 3) {
if(n[i] == '1') cout << 9;
else cout << 1;
}
cout << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
vector<char> S(10);
string r ="YAKI";
int i;
int y=0;
for(i=0;i<s.size();i++){
S.at(i)=s.at(i);
}
for(i=0;i<4;i++){
if(S.at(i)!=r.at(i)){
y++;
}
}
if(y==0){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
return 0;
}
| 0
| 37,917,261
|
#include <bits/stdc++.h>
#define REP(i,n) for (int i = 0; i <(n); ++i)
#define REP2(i,x,n) for (int i = x; i <(n); ++i)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using P = pair<int,int>;
static const double PI = acos(-1);
static const int INF = 1e9+7;
#define REP(i,n) for (int i = 0; i <(n); ++i)
#ifdef _DEBUG
#define debug(var) do{cout << #var << " :";view(var);}while(0)
#else
#define debug(...)
#endif
template<typename T> void view(T e){cout << e << endl;}
template<typename T> void view(const vector<T>& v){for(const auto& e : v){ cout << e << " "; } cout << endl;}
template<typename T> void view(const vector<vector<T> >& vv){ for(const auto& v : vv){ view(v); } }
int main(){
int n, d, x;
cin >> n >> d >> x;
vector<int> a(n);
REP(i,n) cin >> a[i];
int cnt = 0;
REP2(i,1,d+1){
REP(j,n){
REP(k,121){
if(i == a[j]*k + 1) {
cnt++;
}
}
}
}
cout << cnt + x << endl;
return 0;
}
|
#include <iostream>
#include <map>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
map<int, int> count;
int getCount(int n) {
int ret = 0;
for (auto& i : count) {
if (i.second >= n) ++ret;
}
return ret;
}
int main(void) {
ios::sync_with_stdio(false);
int N;
cin >> N;
rep(i, N) {
int n = i + 1;
for (int64_t j = 2; j * j <= n; ++j) {
while (n % j == 0) {
count[j]++;
n /= j;
}
}
if (n != 1) count[n]++;
}
int answer = 0;
answer += getCount(75 - 1);
answer += getCount(25 - 1) * (getCount(3 - 1) - 1);
answer += getCount(15 - 1) * (getCount(5 - 1) - 1);
answer += getCount(5 - 1) * (getCount(5 - 1) - 1) / 2 * (getCount(3 - 1) - 2);
cout << answer << endl;
return 0;
}
| 0
| 7,839,912
|
#include <bits/stdc++.h>
#include <vector>
#include <string>
#include <iomanip>
#include <math.h>
#include <algorithm>
#define hmm "\n"
#define test() int t; cin>>t; while(t--)
#define ll long long int
#define ull unsigned long long
#define fastIO ios_base::sync_with_stdio(false); cin.tie(NULL);
#define mod 1000000007ll
using namespace std;
ll fact[2000006];
ll bigmod(ll b, ll p)
{
if(!p)return 1ll;
ll ret= bigmod(b, p/2);
ret= (ret*ret)%mod;
if(p&1ll)return ret= (ret*b)%mod;
return ret;
}
ll ncr(ll n, ll r)
{
ll nume= fact[n];
ll deno= (fact[n-r]*fact[r])%mod;
return (nume*bigmod(deno, mod-2))%mod;
}
int main()
{
fastIO
fact[0]= 1ll;
for(ll i=1; i<=2000000; i++)
fact[i]= (fact[i-1]*i)%mod;
int n, m, cnt= 0;
scanf("%d %d", &n, &m);
if(n<m)swap(n, m);
int tot= (n+m)/3;
while(n>0 && m>0 && 2*n>m)n--, n--, m--, cnt++;
if(2*n==m)printf("%lld\n", ncr(tot, cnt));
else puts("0");
return 0;
}
|
#include <iostream>
#include <string>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <queue>
#include <stack>
#include <functional>
#include <bitset>
#include <assert.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef pair<ll,ll> P;
typedef vector<P> vpl;
typedef tuple<ll,ll,ll> tapu;
#define rep(i,n) for(ll i=0; i<(n); i++)
#define REP(i,a,b) for(int i=(a); i<(b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1<<30;
const ll linf = 1LL<<62;
const int MAX = 510000;
ll dy[8] = {0,1,0,-1,1,-1,1,-1};
ll dx[8] = {1,0,-1,0,1,-1,-1,1};
const double pi = acos(-1);
const double eps = 1e-7;
template<typename T1,typename T2> inline bool chmin(T1 &a,T2 b){
if(a>b){
a = b; return true;
}
else return false;
}
template<typename T1,typename T2> inline bool chmax(T1 &a,T2 b){
if(a<b){
a = b; return true;
}
else return false;
}
template<typename T1,typename T2> inline void print2(T1 a, T2 b){cout << a << " " << b << "\n";}
template<typename T1,typename T2,typename T3> inline void print3(T1 a, T2 b, T3 c){
cout << a << " " << b << " " << c << "\n";
}
const int mod = 1e9 + 7;
int main(){
string s; cin >> s;
ll left = 0, right = s.size()-1;
ll ans = 0;
while(left < right){
if(s[left] != s[right]){
if(s[left]=='x'){
ans++;
left++;
}else if(s[right]=='x'){
ans++;
right--;
}else{
puts("-1");
return 0;
}
}else{
left++;
right--;
}
}
cout << ans << endl;
}
| 0
| 15,287,844
|
#include <iostream>
#include <algorithm>
#include <math.h>
#include <string.h>
#include <cstdio>
#include <vector>
#include <set>
#include <cassert>
#include <cstdlib>
#include <complex>
#include <cctype>
#include <cmath>
#include <ctime>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <sstream>
#include <functional>
#include <iomanip>
#include <bitset>
using namespace std;
#define ll long long
#define pii pair<int,int>
#define qi ios::sync_with_stdio(0)
bool debug=false;
#define pli pair<ll,int>
int n;
pli p[100005];
map<ll,ll> mp;
vector<pii> tree;
vector<int> nei[100005];
int dep[100005];
int sz[100005];
void dfs(int x,int fa){
for(int i=0;i<nei[x].size();i++){
if(nei[x][i]==fa){
continue;
}
dep[nei[x][i]]=dep[x]+1;
dfs(nei[x][i],x);
}
}
void validate(){
for(pii x:tree){
nei[x.first].push_back(x.second);
nei[x.second].push_back(x.first);
}
dfs(p[n-1].second,-1);
ll dick=0;
for(int i=0;i<n;i++){
dick+=dep[i];
}
if(dick!=p[n-1].first){
cout<<"-1";
exit(0);
}
}
int main(int argc,char* argv[]){
cin>>n;
for(int i=0;i<n;i++){
ll x;
cin>>x;
mp[x]=i;
p[i]=make_pair(x,i);
}
fill(sz,sz+n,1);
sort(p,p+n);
reverse(p,p+n);
for(int i=0;i<n-1;i++){
ll ans=p[i].first;
int x=p[i].second;
ll faShould=p[i].first+sz[x]-(n-sz[x]);
if(!mp.count(faShould)){
cout<<"-1";
return 0;
}
ll par=mp[faShould];
sz[par]+=sz[x];
tree.push_back(make_pair(par,x));
}
validate();
for(pii x:tree){
cout<<x.first+1<<" "<<x.second+1<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(false); cin.tie(0);
#define FOR(i,s,n) for(int i = (s); i < (n); i++)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) for(int i = (n); i >= 0; i--)
#define ALL(n) (n).begin(), (n).end()
#define RALL(n) (n).rbegin(), (n).rend()
#define ATYN(n) cout << ( (n) ? "Yes":"No") << '\n';
#define CFYN(n) cout << ( (n) ? "YES":"NO") << '\n';
#define OUT(n) cout << (n) << '\n';
using ll = long long;
using ull = unsigned long long;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
int main(void)
{
IOS
int N; cin >> N;
vector<ll> A(N), B(N);
priority_queue<ll> pq;
int ans = 0;
REP(i,N) cin >> A[i];
REP(i,N) {
cin >> B[i];
if (A[i] < B[i]) ans++;
else pq.push(A[i]-B[i]);
}
ll a = 0;
REP(i,N) {
if (A[i] >= B[i]) continue;
while(A[i] + a < B[i]) {
if (pq.empty()) {
OUT(-1)
return 0;
}
a += pq.top(); pq.pop();
ans++;
}
a = A[i] + a - B[i];
}
cout << ans << '\n';
return 0;
}
| 0
| 25,567,661
|
#include<iostream>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
int main() {
int k, n,i=0,ans=0,kaka=1000000;
cin >> k >> n;
vector<int>a(n),m(n,0);
rep(i, n) {
cin >> a.at(i);
}
rep(i, n-1) {
m.at(i) = a.at(i + 1) - a.at(i);
}
m.at(n - 1) = k - a.at(n-1) + a.at(0);
sort(m.begin(), m.end());
reverse(m.begin(), m.end());
rep(i, n) {
ans += m.at(i);
}
cout << ans - m.at(0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i,m,n) for(int i=(int)(m); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define RREP(i,m,n) for(int i=(int)(m); i>=(int)(n); i--)
#define rrep(i,n) RREP(i,n-1,0)
#define all(v) v.begin(), v.end()
const int inf = 1e9+7;
const ll longinf = 1LL<<60;
const ll mod = 1e9+7;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int H, W;
cin >> H >> W;
vector<string> S(H);
rep(i, H) cin >> S[i];
bool ok = true;
rep(i, H) rep(j, W) {
if(S[i][j] == '#') {
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
bool ok2 = false;
rep(k, 4) {
int nx = i+dx[k], ny = j+dy[k];
if(nx < 0 || nx >= H || ny < 0 || ny >= W) continue;
ok2 |= (S[nx][ny]=='#');
}
ok &= ok2;
}
}
cout << (ok ? "Yes" : "No") << "\n";
return 0;
}
| 0
| 51,668,514
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = s; i < (int)(n); i++)
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int INF = 1e9 + 5;
void solve()
{
string s, t;
cin >> s >> t;
int ans = 0;
rep(i, 3)
if (s[i] == t[i])
ans++;
cout << ans << endl;
}
int main(void)
{
ios::sync_with_stdio(0);
cin.tie(0);
solve();
}
|
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define repLRE(i, l, r) for (ll i = (l); i <= (r); ++i)
#define rrepLRE(i, l, r) for (ll i = (l); i >= (r); --i)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vector<ll>>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;
ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
const ll INF = 1LL << 50;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
ll x, y;
cin >> x >> y;
ll cnt = 0;
if (y == 0) {
if (x <= 0)
cnt = y - x;
else {
cnt++;
x *= -1;
cnt += y - x;
}
} else if (y > 0) {
if (x <= -y) {
cnt += -y - x;
cnt++;
} else if (x < 0) {
cnt++;
x *= -1;
cnt += y - x;
} else if (x <= y) {
cnt += y - x;
} else {
cnt++;
x *= -1;
cnt += -y - x;
cnt++;
}
} else {
if (x <= y) {
cnt += y - x;
} else if (x < 0) {
x *= -1;
cnt++;
cnt += -y - x;
cnt++;
} else if (x <= -y) {
cnt += -y - x;
cnt++;
} else {
cnt++;
x *= -1;
cnt += y - x;
}
}
cout << cnt << endl;
return 0;
}
| 0
| 83,225,932
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int MAX = 510000;
const int MOD = 1000000007;
signed main(){
cout << std::fixed << std::setprecision(15);
int a,b,k;
cin>>a>>b>>k;
for(int i=0;i<k;i++){
if(a%2)a--;
a/=2;b+=a;
swap(a,b);
}
if(k%2)cout<<b<<' '<<a;
else cout<<a<<' '<<b;
cout<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7 , mod = 1e9 + 7 ;
long long n ;
long long x[N] ;
long long a[N] ;
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cin>>n ;
long long a[n+1] ;
long long ans = 0 , mx = 1 ;
long long rem = 0 ;
for(int i = 0 ;i <=n;i++){
long long t ;
cin>>a[i] ;
rem+=a[i] ;
}
x[n] = a[n] ;
for(int i = n ; i ; i--)
x[i-1] = a[i-1] + x[i] ;
for(int i = 0 ; i <=n;i++){
long long t = a[i] ;
if(t > mx){
return cout<<-1,0 ;
}
long long all = min(mx , rem);
mx-=a[i] ;
ans+=all ;
mx*=2 ;
if(mx > 1e15)
mx = 1e15 ;
rem-=a[i] ;
}
cout<< ans ;
return 0;
}
| 0
| 44,912,084
|
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <math.h>
using namespace std;
using ll = long long;
using vl = vector<long long>;
using vll = vector<vector<long long>>;
using vs = vector<string>;
using vc = vector<char>;
using vcc = vector<vector<char>>;
using vm = vector<short>;
using vmm = vector<vector<short>>;
int main() {
ll n;
cin >> n;
ll count = 1;
for (int i = 0; i <= pow(n, 0.5); i++) {
if (i > 0) {
if (n % i == 0) {
count = i;
}
}
}
cout << count + n / count - 2 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
void solve(){
ll n,B,a,b,count=0,sum=0,f=0;cin>>n>>B;
vector<ll> vc;
ll mx=-1;
for(ll i=1;i<=n;i++)
{
cin>>a>>b;
vc.push_back(b);
mx=max(a,mx);
}
sort(vc.begin(),vc.end(),greater<ll>());
for(ll i=0;i<vc.size();i++)
{
if(vc[i]>mx)++count,sum+=vc[i];
else
{
ll left=B-sum;
if(left%mx==0)count+=((left/mx));
else count+=(left/mx)+1;
f=2;
break;
}
if(sum>=B){f=1;break;}
}
if(f==0)
{
ll left=B-sum;
if(left%mx==0)count+=((left/mx));
else count+=(left/mx)+1;
f=2;
cout<<count<<endl;
}
else cout<<count<<endl;
}
int32_t main() {
ll t=1;
while (t--)
solve();
return 0;
}
| 0
| 72,770,017
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int a;
cin >> a;
cout << a*a;
}
|
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <cstring>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
#define endl "\n"
#define all(V) V.begin(),V.end()
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
const int MOD = 1e9 + 7;
const ll INF = 1LL << 60;
const int inf = 1 << 25;
constexpr long double pi = 3.141592653589793238462643383279;
int dx[] = { 1,0,-1,0 };
int dy[] = { 0,1,0,-1 };
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll fact_mod(ll n, ll mod) {
ll f = 1; for (int i = 2; i <= n; i++) f = f * (i % mod) % mod;
return f;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
return a * b / gcd(a, b);
}
ll keta(ll n) {
if (n == 0) return 1;
ll count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) {
ll sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
ll mch(ll n) {
if (n == 1) return 1;
else return n * mch(n - 1);
}
ll powmod(ll x, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1) res = (res * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return res;
}
ll inv_mod(ll a, ll mod) {
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= mod;
if (u < 0) u += mod;
return u;
}
bool is_prime(const unsigned n) {
switch (n) {
case 0:
case 1: return false;
case 2:
case 3: return true;
}
if (n % 2 == 0 || n % 3 == 0) return false;
for (unsigned i = 5; i * i <= n; i += 6) {
if (n % i == 0) return false;
if (n % (i + 2) == 0) return false;
}
return true;
}
struct UnionFind {
vector<int> par;
UnionFind(int N) : par(N) {
for (int i = 0; i < N; i++) par[i] = i;
}
int root(int x) {
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) return;
par[rx] = ry;
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main(void) {
string s;
cin >> s;
reverse(s.begin(), s.end());
bool ok = true;
while (s.size()!=0) {
if (s.find("maerd") == 0) {
s = s.erase(0, 5);
}
else if (s.find("esare") == 0) {
s = s.erase(0, 5);
}
else if (s.find("remaerd") == 0) {
s = s.erase(0, 7);
}
else if (s.find("resare") == 0) {
s = s.erase(0, 6);
}
else {
ok = false;
break;
}
}
(ok ? puts("YES") : puts("NO"));
return 0;
}
| 0
| 11,041,860
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define ll long long
const ll MOD = 1e9+7;
const ll INF = 1e18;
const double pi = acos(-1);
int main(void)
{
vector<ll> a(5);
rep(i,5) cin>>a[i];
ll ans=INF;
vector<ll> p={0,1,2,3,4};
do{
ll tmp=0;
rep(i,5){
tmp+=a[p[i]];
while(tmp%10!=0){
if(i==4) break;
tmp++;
}
}
ans=min(tmp,ans);
}while(next_permutation(p.begin(),p.end()));
cout<<ans<<endl;
return 0;
}
|
#ifndef DEBUG
#pragma GCC optimize("O3,unroll-loops")
#pragma loop_opt(on)
#endif
#include <bits/stdc++.h>
using namespace std;
#ifdef DEBUG
#define FAST ;
#else
#define FAST ios::sync_with_stdio(0);cin.tie(0);
#define endl '\n'
#define cerr
#endif
#define _ <<' '<<
#define Fr(i, s, e) for(auto i = s; i < e; ++i)
#define All(v) v.begin(),v.end()
#define Ft first
#define Sd second
using ll = long long;
using pii = pair<int, int>;
constexpr ll MOD = 1e9+7;
signed main() {
FAST;
array<int,3> v;
for(auto &x: v) cin >> x;
sort(All(v));
int c = 0;
Fr(i, 0, 2) {
int x = (v[2]-v[i])/2;
v[i] += x*2;
c += x;
}
sort(All(v));
if (v[0] == v[2]-1) {
if (v[0]==v[1]) c++;
else c+=2;
}
cout << c << endl;
}
| 0
| 46,869,805
|
#include <bits/stdc++.h>
#define endl "\n"
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i=0;i<int(n);i++)
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> ipair;
template <class T>ostream &operator<<(ostream &o,const vector<T>&v)
{o<<"{";for(int i=0;i<(int)v.size();i++)o<<(i>0?", ":"")<<v[i];o<<"}";return o;}
namespace you {
std::string to_string(char val) {
return std::string(1, val);
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
int n;
cin>>n;
vector<int> coin={0,1};
int num=6;
while(num<=n){
coin.emplace_back(num);
num*=6;
}
num=9;
while(num<=n){
coin.emplace_back(num);
num*=9;
}
int kind=coin.size()-1;
vector<vector<int>> dp(kind+10,vector<int>(n+10,n+10));
for(int i=0;i<=kind;i++) dp[i][0]=0;
for(int i=1;i<=kind;i++){
for(int j=1;j<=n;j++){
if(0<=j-coin[i]) dp[i][j]=min(dp[i][j-coin[i]]+1,dp[i-1][j]);
else dp[i][j]=min(dp[i][j],dp[i-1][j]);
}
}
cout<<dp[kind][n]<<endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
int main()
{
while (true) {
int N, M;
cin >> N >> M;
if (N == 0 && M == 0) {
break;
}
vector<pair<int, int>> pairs(N);
long long int sum = 0;
for (int i = 0; i < N; i++) {
cin >> pairs[i].second >> pairs[i].first;
sum += pairs[i].first*pairs[i].second;
}
sort(pairs.rbegin(), pairs.rend());
int cur = 0;
while (true) {
if (M >= pairs[cur].second) {
sum -= pairs[cur].first*pairs[cur].second;
M -= pairs[cur].second;
cur++;
}
else {
sum -= M*pairs[cur].first;
M = 0;
}
if (cur == N || M == 0) {
break;
}
}
cout << sum << endl;
}
return 0;
}
| 0
| 15,743,133
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
using P = pair<ll, ll>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(x) (x).begin(), (x).end()
const ll INF = ll(1e18)+1;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<ll> ai(n);
rep(i,n) cin >> ai[i];
ll money = 1000;
ll stock = 0;
vector<vector<ll>> bsvec(99,vector<ll>(2,0));
ll mode = 0;
bsvec[0][1] = ai[n-1];
bsvec[0][0] = ai[n-1];
rep(i,n-1){
if(ai[n-2-i] <= bsvec[mode][0]) bsvec[mode][0] = ai[n-2-i];
else{
mode++;
bsvec[mode][0] = ai[n-2-i];
bsvec[mode][1] = ai[n-2-i];
}
}
ll temp,temp2;
rep(i,mode+1){
if(bsvec[mode-i][0] != bsvec[mode-i][1]){
money = money / bsvec[mode-i][0] * (bsvec[mode-i][1] - bsvec[mode-i][0]) + money;
}
}
cout << money;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define int long long
#define pb push_back
#define mod 1000000007
#define setbits(x) __builtin_popcountll(x)
#define zerobits(x) __builtin_ctzll(x)
#define inf 1e18
#define pre(x,y) fixed<<setprecision(y)<<x
#define pq priority_queue<int>
#define mpq priority_queue<int,vector<int>,greater<int>>
#define gcd(x,y) __gcd(x,y)
#define mp make_pair
int dfs(vector<int> v[],vector<vector<int>> &dp,int src,int p,int b)
{
if(dp[src][b]!=-1) return dp[src][b];
int w1=1;
int w2=1;
int ans=0;
for(auto x:v[src])
{
if(x!=p)
{
w1=(w1*dfs(v,dp,x,src,0))%mod;
if(!b)
{
w2=(w2*dfs(v,dp,x,src,1))%mod;
}
}
}
ans=(ans+w1)%mod;
if(!b) ans=(ans+w2)%mod;
return dp[src][b]=ans;
}
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n,i,j,k;
cin>>n;
vector<int> v[n];
int x,y;
for(i=1;i<n;i++)
{
cin>>x>>y;
x--;y--;
v[x].pb(y);
v[y].pb(x);
}
vector<vector<int>> dp(n,vector<int>(2));
for(i=0;i<n;i++)
{
dp[i][0]=-1;
dp[i][1]=-1;
}
cout<<dfs(v,dp,0,0,0)<<endl;
return 0;
}
| 0
| 49,162,564
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0; i<n; i++)
#define eb(t) emplace_back(t)
typedef long long ll;
typedef long long unsigned int llu;
ll INF = 1000000009;
ll MOD = 1000000007;
void solve(){
string a;
cin >> a;
ll mp[30];
rep(i,30){
mp[i]=0;
}
rep(i,a.size()){
mp[a[i]-'a']++;
}
ll n = a.size();
ll ans = n*(n-1)/2+1;
rep(i,30){
ll t = mp[i];
ans -= (t*(t-1)/2);
}
cout << ans << endl;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
|
#include<iostream>
#include<stdio.h>
#include<vector>
#include<float.h>
#include<iomanip>
#include<algorithm>
#include<string>
#include<cstring>
#include<math.h>
#include<cmath>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include <cassert>
#include <cmath>
#include<cstdint>
#define INF 1e9
#define rep(i,n)for(int i=0;(i)<(int)(n);i++)
#define REP(i,a,b)for(int i=(int)(a);(i)<=(int)(b);i++)
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define vec(type,n) vector<type>(n)
#define vvec(m,n) vector<vector<int>> (int(m),vector<int>(n))
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<ll, ll>;
class UnionFind {
public :
vector<int> par;
UnionFind(int N){
par = vector<int>(N, -1);
}
int parent(int x){
return par[x];
}
int root(int x){
if(par[x] < 0)return x;
return par[x] = root(par[x]);
}
int size(int x){
return -par[root(x)];
}
void connect(int x, int y){
int rx = root(x);
int ry = root(y);
if(rx == ry)return;
if(size(rx) < size(ry))swap(rx, ry);
par[rx] += par[ry];
par[ry] = rx;
return;
}
bool same(int x, int y){
return root(x) == root(y);
}
};
int main(){
ll n, m;
cin >> n >> m;
vector<P> p;
rep(i, n){
ll a, b;
cin >> a >> b;
p.emplace_back(a, b);
}
ll res = 0;
ll cnt = 0;
sort(ALL(p));
rep(i, n){
if(cnt + p[i].second >= m){
res += p[i].first * (m - cnt);
break;
}
else {
cnt += p[i].second;
res += p[i].first * p[i].second;
}
}
cout << res << endl;
}
| 0
| 17,177,372
|
#include<iostream>
using namespace std;
int m[101][101];
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n,u,k,v;
cin>>n;
for(int i=0;i<n;++i){
cin>>u>>k;
u--;
for(int j=0;j<k;++j){
cin>>v;
v--;
m[u][v]=1;
}
}
for(int i=0;i<n;++i){
for(int j=0;j<n;++j){
if(j) cout<<" ";
cout<<m[i][j];
}
cout<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to;
int weight;
edge(int t, int w) : to(t), weight(w) { }
};
using Graph = vector<vector<int>>;
using dou =long double;
string Yes="Yes";
string YES="YES";
string NO="NO";
string No="No";
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define brep(n) for(int bit=0;bit<(1<<n);bit++)
#define erep(i,container) for (auto i : container)
#define irep(i, n) for(int i = n-1; i >= (int)0; i--)
#define rrep(i,m,n) for(int i = m; i < (int)(n); i++)
#define reprep(i,j,h,w) rep(i,h)rep(j,w)
#define all(x) (x).begin(),(x).end()
#define aall(x,n) (x).begin(),(x).begin()+(n)
#define VEC(type,name,n) std::vector<type> name(n);rep(i,n)std::cin >> name[i];
#define pb push_back
#define pf push_front
#define lb lower_bound
#define ub upper_bound
#define res resize
#define as assign
#define fi first
#define se second
#define itn int
#define mp make_pair
#define sum(a) accumulate(all(a),0ll)
#define keta fixed<<setprecision
#define vvector(name,typ,m,n,a)vector<vector<typ> > name(m,vector<typ> (n,a))
#define vvvector(name,t,l,m,n,a) vector<vector<vector<t> > > name(l, vector<vector<t> >(m, vector<t>(n,a)));
#define vvvvector(name,t,k,l,m,n,a) vector<vector<vector<vector<t> > > > name(k,vector<vector<vector<t> > >(l, vector<vector<t> >(m, vector<t>(n,a)) ));
typedef long long ll;
const int INF = 2000000000;
const ll INF64 = 922337203685477580ll;
const int mod = 1000000007ll;
const ll MOD = 1000000007LL;
const double pi=3.1415926535897932384626;
int main(){
ll q,h,s,d;
std::cin >> q>>h>>s>>d;
ll n;
std::cin >> n;
ll ans=q*n*4;
ans=min(h*n*2,ans);
ans=min(s*n,ans);
ll du=d*(n/2);
if(n%2==1)du+=min({q*4,h*2,s});
std::cout << min(ans,du) << std::endl;
}
| 0
| 18,840,554
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define all(x) (x).begin(), (x).end()
#define endl '\n'
ll inf = LLONG_MAX;
long double pi = M_PI;
void Yes() {cout << "Yes" << endl;}
void No() {cout << "No" << endl;}
void YES() {cout << "YES" << endl;}
void NO() {cout << "NO" << endl;}
int main() {
string s;
ll k;
cin >> s >> k;
ll n = s.size();
vll a(0);
for (ll i = 0; i < n; i++) {
char c = s[i];
ll cnt = 0;
while (c == s[i] && i < n) {
i++;
cnt++;
}
a.push_back(cnt);
i--;
}
ll ans = 0;
for (ll i = 0; i < a.size(); i++) {
ans += a[i] / 2;
}
if (s[0] != s[n - 1]) cout << ans * k << endl;
else {
if (a.size() == 1) {
cout << a[0] * k / 2 << endl;
return 0;
}
a[0] += a.back();
a.pop_back();
ll m = 0;
for (ll i = 0; i < a.size(); i++) {
m += a[i] / 2;
}
cout << ans + m * (k - 1) << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
#define inf 10000000002
#define pb push_back
#define loop(i,a,b) for(ll i=a;i<b;i++)
#define MAX 100
#define yes cout<<"YES"<<endl
#define no cout<<"NO"<<endl
#define bye return 0
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n;
cin>>n;
ll arr[n];
for(int i=0; i<n; i++){
cin>>arr[i];
}
vector<ll>V[2];
ll mn,mx;
mx=arr[n-1];
for(int i=n-2; i>=0; i--){
if(arr[i]>=mx) mx=arr[i];
else{
mn=arr[i];
ll temp=0;
while(i>0){
if(arr[i-1]<=mn){mn=arr[i-1]; i--;}
else{temp=arr[i-1];break;}
}
V[0].pb(mn);
V[1].pb(mx);
mx=temp;
}
}
ll sz=V[0].size();
reverse(V[0].begin(),V[0].end());
reverse(V[1].begin(),V[1].end());
ll money=1000;
for(int i=0; i<sz; i++){
ll s=(money/V[0][i]);
money= (money%V[0][i]);
money+= (s*V[1][i]);
}
cout<<money<<endl;
bye;
}
| 0
| 74,663,839
|
#include<iostream>
using namespace std;
int main(){
int n,m;
while(1){
cin>>n;
char a[n],b[n],cha;
if(n==0)
break;
for(int i=0;i<n;i++){
cin>>a[i]>>b[i];
}
cin>>m;
for(int i=0;i<m;i++){
cin>>cha;
for(int j=0;j<n;j++){
if(cha==a[j]){
cout<<b[j];
break;
}else if(j+1==n){
cout<<cha;
}
}
}
cout<<endl;
}
}
|
#include<iostream>
using namespace std;
#define ll long long
ll n;
ll a[100005];
ll dp[100005];
const ll Inf = 1e10;
ll MinCostToReachFromNToZero(ll N){
if(dp[N] != -1)return dp[N];
if(N <= 0) return 0;
ll ans = abs(a[N] - a[N-1]) + MinCostToReachFromNToZero(N-1);
if(N-2 >= 0){
ll ans2 = abs(a[N] - a[N-2]) + MinCostToReachFromNToZero(N-2);
ans = min(ans,ans2);
}
return dp[N] = ans;
}
int main(){
cin >> n;
for(ll i = 0; i < n; i++)cin >> a[i];
for(ll i = 0; i < n+1; i++)dp[i] = -1;
cout << MinCostToReachFromNToZero(n-1) << endl;
return 0;
}
| 0
| 9,921,824
|
#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() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int a, b, c, k;
cin >> a >> b >> c >> k;
int cnt = 0;
while(a >= b) {
b *= 2;
cnt++;
}
while(b >= c) {
c *= 2;
cnt++;
}
if(cnt <= k) {
cout << "Yes" << "\n";
} else {
cout << "No" << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define rrep(i,n) for(int i=(n)-1;i>=0;i--)
constexpr int INF = numeric_limits<int>::max()/2;
constexpr long long LINF = numeric_limits<long long>::max()/3;
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(v) (v).begin(),(v).end()
#define sz(x) (int)(x).size()
#define debug(x) cerr<<#x<<":"<<x<<endl
#define debug2(x,y) cerr<<#x<<","<<#y":"<<x<<","<<y<<endl
struct Double{ double d; explicit Double(double x) : d(x){} };
ostream& operator<<(ostream& os,const Double x){ os << fixed << setprecision(20) << x.d; return os; }
template<typename T> ostream& operator<<(ostream& os,const vector<T>& vec){ os << "["; for(const auto& v : vec){ os << v << ","; } os << "]"; return os; }
template<typename T,typename U> ostream& operator<<(ostream& os, const map<T,U>& mp){ os << "{"; for(auto& p : mp){ os << p << ","; } os << "}"; return os; }
template<typename T,typename U> ostream& operator<<(ostream& os,const pair<T,U>& p){ os << "(" << p.first << ","<< p.second <<")"; return os; }
template<typename T> ostream& operator<<(ostream& os,const set<T>& st){ os<<"{"; for(T v:st) os<<v<<","; os <<"}"; return os; }
template<typename T,typename U> inline void chmax(T &x,U y){ if(y>x) x = y; }
template<typename T,typename U> inline void chmin(T &x,U y){ if(y<x) x = y; }
using ll = long long;
using ull = unsigned long long;
using pii = std::pair<int,int>;
using vi = std::vector<int>;
typedef vector<vi> vvi;
ll gcd(ll a,ll b){ if(b==0) return a; else return gcd(b,a%b); }
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
constexpr double eps = 1e-10;
constexpr ll mod = 1e9+7;
const int dx[]={1,0,-1,0} ,dy[] = {0,1,0,-1};
struct UnionFind{
vector<int> par, rank;
UnionFind(int n){
par.resize(n,-1);
rank.resize(n,0);
}
int root(int x){
if(par[x]<0) return x;
else return par[x]=root(par[x]);
}
bool same(int x,int y){
return root(x) == root(y);
}
int size(int x){
return -par[root(x)];
}
void merge(int x,int y){
x = root(x);
y = root(y);
if(x==y) return;
if(rank[x] < rank[y]) swap(x,y);
par[x]+=par[y];
par[y]=x;
rank[x]+=(rank[x]==rank[y]);
}
};
int main(){
int n,m; cin >> n >> m;
UnionFind uf(2*n);
vector<int> p(n);
rep(i,n){
cin >> p[i];
p[i]--;
uf.merge(p[i], i+n);
}
rep(i,m){
int x,y; cin >> x >> y;
x--; y--;
uf.merge(x, y);
}
int ans = 0;
rep(i,n){
if(uf.same(i, i+n)){
ans++;
}
}
cout << ans << endl;
}
| 0
| 43,106,245
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
using ll = long long;
using P = pair<int,int>;
void Yes() {
cout << "Yes" << endl;
}
void No() {
cout << "No" << endl;
}
int main(void) {
int a, b, c, d;
cin >> a >> b >> c >> d;
cout << min(a,b) + min(c,d);
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<utility>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<functional>
#include<math.h>
using namespace std;
#define N (1000000000+7)
#define M (998244353)
#define INF 1e16
typedef long long ll;
typedef pair<int,int> P;
int A(int x){
if(x>=0)return x;
else return -x;
}
int ans[1010][1010];
int main(void){
ll n,k;
cin>>n>>k;
vector<ll>a(n),seq;
for(ll i=0;i<n;i++)cin>>a[i];
for(ll i=0;i<n;i++){
ll sum = 0;
for(ll j=i;j<n;j++){
sum+=a[j];
seq.push_back(sum);
}
}
for(ll i=40;i>=0;i--){
vector<ll>seq1,seq2;
for(ll j=0;j<seq.size();j++){
if(seq[j]&(1LL<<i))seq1.push_back(seq[j]);
else seq2.push_back(seq[j]);
}
if(seq1.size()<k)continue;
else{
if(seq1.size()==k){
seq = seq1;
break;
}
else seq = seq1;
}
}
ll ans = (1LL<<40)-1LL;
for(ll i=0;i<seq.size();i++)ans&=seq[i];
cout<<ans<<endl;
return 0;
}
| 0
| 43,901,596
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int N,M;
cin >> N >> M;
vector<int> A(M);
for(int i=0;i<M;i++) cin >> A.at(i);
vector<int> cnt={0,2,5,5,4,5,6,3,7,6};
sort(A.begin(),A.end());
vector<int> dp(N+1,0);
dp.at(0)=1;
for(int i=0;i<M;i++){
int x=cnt.at(A.at(i));
for(int j=0;j<N+1;j++){
if(j-x<0) continue;
if(dp.at(j-x)==0) continue;
dp.at(j)=max(dp.at(j),dp.at(j-x)+1);
}
}
string ans="";
int now=N;
for(int i=M-1;i>=0;i--){
int x=cnt.at(A.at(i));
for(;now>=0;){
if(now-x<0) break;
if(dp.at(now-x)==0) break;
if(dp.at(now)==dp.at(now-x)+1){
ans+=(A.at(i)+'0');
now-=x;
}
else break;
}
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b;
char c;
cin>>a>>b;
string s1="",s2="";
for(int i=0; i<a; i++)
{
c=b+'0';
s1+=c;
}
for(int i=0; i<b; i++)
{
c=a+'0';
s2+=c;
}
if(s1.size()>s2.size())
{
for(int i=0; i<s1.size(); i++)
{
if((s1[i]-'0')<(s2[i]-'0'))
{
cout<<s1;
return 0;
}
else if((s1[i]-'0')>(s2[i]-'0'))
{
cout<<s2;
return 0;
}
}
}
else
{
for(int i=0; i<s2.size(); i++)
{
if((s1[i]-'0')<(s2[i]-'0'))
{
cout<<s1;
return 0;
}
else if((s1[i]-'0')>(s2[i]-'0'))
{
cout<<s2;
return 0;
}
}
}
cout<<s1;
return 0;
}
| 0
| 70,891,420
|
#include <bits/stdc++.h>
using namespace std;
int main(){
using ll = int64_t;
ll n, k;
cin >> n >> k;
vector<ll> a(n), b(n);
for(int i=0;i<n;i++){
cin >> a[i] >> b[i];
}
ll ans = 0;
for(int j=0;j<n;j++){
if((k | a[j]) == k)ans += b[j];
}
for(int i=1;i<31;i++){
if((k & (1LL << i)) == 0)continue;
ll x = ((k >> i) << i) - 1;
ll t = 0LL;
for(int j=0;j<n;j++){
if((x | a[j]) == x)t += b[j];
}
ans = max(ans, t);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define gcd(m,n) __gcd(m,n)
#define lcm(m,n) m*(n/gcd(m,n))
#define fast std::ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define pi acos(-1.0)
#define endl '\n'
#define MOD 1000000007
#define ull unsigned long long
#define ll long long
#define ld long double
#define pb push_back
#define dbg(x) cout << #x << " " << x << endl;
using namespace std;
ll parent[100005];
ll rankr[100005];
ll find_set(ll v) {
if (v == parent[v])
return v;
return parent[v] = find_set(parent[v]);
}
void make_set(ll v) {
parent[v] = v;
rankr[v] = 0;
}
void union_sets(ll a, ll b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rankr[a] < rankr[b])
swap(a, b);
parent[b] = a;
if (rankr[a] == rankr[b])
rankr[a]++;
}
}
ll power(ll base, ll exp)
{ll res=1;while(exp>0) {if(exp%2==1) res=(res*base);base=(base*base);exp/=2;}return res;}
ll mod(ll a, ll b) {return (a % b + b) % b;}
ll powerm(ll base,ll exp,ll mod)
{ll ans=1;while(exp){if(exp&1) ans=(ans*base)%mod;exp>>=1,base=(base*base)%mod;}return ans;}
int main()
{
fast;
ll n,m; cin>>n>>m;
for(ll i = 1; i <= n; i++)
{
make_set(i);
}
ll arr[n+1]; for(ll i = 1; i <= n; i++) cin>>arr[i];
while(m--)
{
ll a,b; cin>>a>>b;
union_sets(a,b);
}
ll ans = 0;
for(ll i = 1; i <= n; i++)
{
if(arr[i] == i)
ans++;
else
{
ll a = find_set(i); ll b = find_set(arr[i]);
if(a == b)
ans++;
}
}
cout << ans << endl;
return 0;
}
| 0
| 12,530,301
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <list>
#include <utility>
#include <tuple>
#include <cstdio>
#include <set>
#include <queue>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <cmath>
#define _GLIBCXX_DEBUG
using namespace std;
const long long INF = 1LL << 60;
typedef long long ll;
int main() {
ll N;
cin >> N;
ll A,B;
cin >> A >> B;
ll num_Blue_set = N / (A+B);
ll ans;
ans = num_Blue_set * A;
ll num = N % (A + B);
if(num > 0){
if(num <= A){
ans = ans + num;
}
else{
ans = ans + A;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define endl '\n'
#pragma GCC optimize("Ofast","unroll-loops","omit-frame-pointer","inline")
#pragma GCC option("arch=native","tune=native","no-zero-upper")
#pragma GCC target("avx2")
using namespace std;
typedef unsigned long long ull;
typedef long long lld;
typedef long double ld;
typedef pair<int,int> pii;
const int MAXN=1e5+5;
const int MOD=1e9+7;
const int INF=1e9;
const ld PI=acos(-1);
const ld EPS=1e-9;
#define lg2(x) 31-__builtin_clz(x)
#define logx(a,b) (log(a)/log(b))
#define pow2(a) a*a
#define pow3(a) a*a*a
#define lcm(a,b) (a*b)/__gcd(a,b)
pii mkp(int a, int b){
if(a>b)swap(a,b);
return make_pair(a,b);
}
int mod_pow(int a, int b){
if(!b)return 1;
if(b&1)return mod_pow(a,b-1)*a%MOD;
int power=mod_pow(a,b>>1);
return power*power%MOD;
}
int modular_inverse(int a){
return mod_pow(a,MOD-2);
}
vector<int> movy={0,0,1,-1};
vector<int> movx={1,-1,0,0};
void solve(){
int n, l;
cin>>n>>l;
vector<string> a(n);
for(string &it:a)cin>>it;
sort(a.begin(),a.end());
for(string it:a)cout<<it;
cout<<endl;
}
int main()
{
#ifndef ONLINE_JUDGE
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 0
| 22,611,856
|
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#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 mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
int N, K;
cin>>N>>K;
ll V[N];
for(int i=0;i<N;++i) cin>>V[i];
vector<ll> jewel;
ll ans = -big;
ll tmpans;
for(int l=0;l<=N;++l) {
for(int r=0;r+l<=N;++r) {
if(l+r>K) continue;
jewel.clear();
for(int k=0;k<l;++k) jewel.push_back(V[k]);
for(int k=0;k<r;++k) jewel.push_back(V[N-1-k]);
sort(jewel.begin(), jewel.end());
tmpans = 0;
for(int k=0;k<l+r;++k) {
if(K-(l+r)>k && jewel[k]<0) continue;
tmpans += jewel[k];
}
ans = max(ans, tmpans);
}
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll a[233333];
int n;
int main(){
scanf("%d", &n);
for(int i = 1; i <= n; i++) scanf("%lld", &a[i]), a[i] -= i;
sort(a + 1, a + 1 + n);
ll Mid = 0, ans = 0;
if(n % 2 == 0) Mid = (a[n / 2] + a[n / 2 + 1]) / 2;
else Mid = a[n / 2 + 1];
for(int i = 1; i <= n; i++) ans += abs(a[i] - Mid);
printf("%lld\n", ans);
return 0;
}
| 0
| 41,081,806
|
#define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i,n) for(int i=0;i<(lint)(n);i++)
#define REP(i,n) for(int i=1;i<=(lint)(n);i++)
#define all(V) V.begin(),V.end()
#define stackReplaceBegin(size)\
void* p=malloc(size);\
esp_new=(lint)p+size-1;\
void * stack_extend_memory_ = malloc(size);\
void * stack_extend_origin_memory_;\
char * stack_extend_dummy_memory_ = (char*)alloca((1+(int)(((long long)stack_extend_memory_)&127))*16);\
*stack_extend_dummy_memory_ = 0;\
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp":"=b"(stack_extend_origin_memory_):"a"((char*)stack_extend_memory_+(size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX/2;
constexpr lint LINF = LLONG_MAX/2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template<class T>
class prique :public std::priority_queue<T, std::vector<T>, std::greater<T>> {};
template <class T, class U>
inline bool chmax(T& lhs, const U& rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U>
inline bool chmin(T& lhs, const U& rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b; b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) {
return a / gcd(a, b) * b;
}
bool isprime(lint n) {
if (n == 1)return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)return false;
}
return true;
}
template<typename T>
T mypow(T a, unsigned int b) {
T res(1),now(a);
while(b){
if(b&1)res*=now;
b>>=1;
now*=now;
}
return res;
}
template<typename T>
void printArray(std::vector<T>& vec) {
rep(i, (int)vec.size() - 1)std::cout << vec[i] << " ";
if(!vec.empty())std::cout << vec.back() << std::endl;
}
template<typename T>
void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
lint n,a[100010],b[100010];
int main() {
std::cin>>n;
for(int i=0;i<n;i++)std::cin>>a[i]>>b[i];
lint ans=0;
for(int i=n-1;i>=0;i--){
a[i]+=ans;
ans+=(a[i]+b[i]-1)/b[i]*b[i]-a[i];
}
std::cout<<ans<<std::endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,t,x,y;
int tp,xp,yp;
int a,b,c;
bool ans=true;
cin >> n;
tp=0;
xp=0;
yp=0;
for(int i=0;i<n;i++){
cin >> t >> x >> y;
a=abs(t-tp);
b=abs(x-xp);
c=abs(y-yp);
if((a<b+c)||((a-b-c)%2!=0)){
ans=false;
}
else{
tp=t;
xp=x;
yp=y;
}
}
if(ans){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
}
| 0
| 80,912,234
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <map>
#include <queue>
#include <deque>
#include <list>
#include <set>
#include <functional>
#include <cmath>
#include <numeric>
#define REP(i,n) for(lint i{}, i##_len=(n); i<i##_len; ++i)
#define DREP(i, h, j, w) for(lint i{}; i < (lint)(h); ++i)for(lint j{}; j < (lint)(w); ++j)
#define DREP2(i, j, n) for(lint i{}; i < (lint)(n - 1); ++i)for(lint j{i + 1}; j < (lint)(n); ++j)
#define SZ(x) ((lint)(x).size())
using lint = long long; lint N, M, H, W;
using namespace std;
const long long INF{ 1LL << 60 };
const long double PI{ 3.1415926535897932 };
const long long NUM97{ 1000000007 };
template<class T> inline bool chmax(T& x, T y) { if (x < y) { x = y; return 1; } return 0; }
template<class T> inline bool chmin(T& x, T y) { if (x > y) { x = y; return 1; } return 0; }
std::vector<std::string> field;
std::vector<std::vector<bool>> seen(H, std::vector<bool>(W));
const std::vector<int> dx{ 1, 0, -1, 0 };
const std::vector<int> dy{ 0, 1, 0, -1 };
bool first_larger(std::pair<lint, lint>& a, std::pair<lint, lint>& b) {
if (a.first != b.first) return{ a.first > b.first };
else return { a.second > b.second };
}
bool second_smaller(std::pair<lint, lint>& a, std::pair<lint, lint>& b) {
if (a.second != b.second) return{ a.second < b.second };
else return { a.first < b.first };
}
bool second_larger(std::pair<lint, lint>& a, std::pair<lint, lint>& b) {
if (a.second != b.second) return{ a.second > b.second };
else return { a.first > b.first };
}
bool is_prime(lint N) {
if (N == 1) return false;
for (lint i = 2; i * i <= N; ++i) { if (N % i == 0) return false; }
return true;
}
lint toInt(char c) {
return (c - '0');
}
lint StoInt(std::string s) { lint num{};
for (int i = 0; i < s.size(); ++i) { if (i > 0) num *= 10; num += s[i] - '0';}
return num;
}
lint get_digit(lint n) {
return log10(n) + 1;
}
lint factorial(lint n) { lint sum = 1;
for (int i = 1; i <= n; ++i) sum *= i;
return sum;
}
lint count_divisors(lint N) { lint count{};
for (lint i = 1; i * i <= N; ++i) {
if (N % i == 0) { ++count; if (N / i != i) ++count; } }
return count;
}
lint count_prime_divisors(lint N) { lint count{};
for (lint i = 1; i * i <= N; ++i) {
if (N % i == 0) { if (is_prime(i)) ++count;
if (N / i != i) { if (is_prime(N / i)) ++count; } } }
return count;
}
std::vector<lint> divisors(lint N) { std::vector<lint> divisor;
for (lint i = 1; i * i <= N; ++i) {
if (N % i == 0) { divisor.push_back(i);
if (N / i != i) divisor.push_back(N / i); }
} std::sort(divisor.begin(), divisor.end());
divisor.erase(std::unique(divisor.begin(), divisor.end()), divisor.end());
return divisor;
}
std::vector<lint> prime_divisors(lint N) { std::vector<lint> p_divisor;
for (lint i = 1; i * i <= N; ++i) {
if (N % i == 0) { if (is_prime(i)) { p_divisor.push_back(i); }
if (N / i != i) { if (is_prime(N / i)) { p_divisor.push_back(N / i); } } }
} std::sort(p_divisor.begin(), p_divisor.end());
p_divisor.erase(std::unique(p_divisor.begin(), p_divisor.end()), p_divisor.end());
return p_divisor;
}
std::vector<std::pair<lint, lint>> prime_factorize(lint N) {
vector<pair<lint, lint>> factorize;
for (lint a = 2; a * a <= N; ++a) {
if (N % a != 0) continue;
lint ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
factorize.push_back({ a, ex });
}
if (N != 1) factorize.push_back({ N, 1 });
return factorize;
}
void divide(lint N, lint& a, lint& b) {
if (N % 2 == 1) { a = N / 2 + 1; b = N / 2; }
else { a = N / 2; b = N / 2; }
}
int main() {
lint N{}, a{}, b{}, ab{}, count{}; std::cin >> N;
for (int i = 0; i < N; ++i) {
string s; cin >> s;
for (int j = 0; j < s.size() - 1; ++j) {
if (s[j] == 'A' && s[j + 1] == 'B')
++count;
}
if (s[0] == 'B' && s[s.size() - 1] == 'A') {
++ab;
continue;
}
if (s[0] == 'B') {
++b;
}
if (s[s.size() - 1] == 'A') {
++a;
}
}
if (a == 0 && b == 0 && ab == 0) {
cout << count;
return 0;
}
else if (ab == 0) {
cout << count + min(a, b);
return 0;
}
else if (a == 0 && b == 0) {
std::cout << ab - 1 + count;
return 0;
}
else if(b == 0 && a > 0 || a == 0 && b > 0){
std::cout << ab + count;
return 0;
}
else {
--a;
--b;
std::cout << ab + count + 1 + min(a, b);
}
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
int main(){
int H,W,K;
string* c;
cin >> H >> W >> K;
c = new string[H];
for(int i=0;i<H;i++)
cin >> c[i];
int result = 0;
for(int hbit=0;hbit<(1<<H);hbit++){
for(int wbit=0;wbit<(1<<W);wbit++){
int sum=0;
for(int i=0;i<H;i++){
if((1<<i)&hbit)
continue;
for(int j=0;j<W;j++){
if((1<<j)&wbit)
continue;
else if(c[i].at(j) == '#')
sum++;
}
}
if(sum == K)
result++;
}
}
cout << result;
delete[] c;
return 0;
}
| 0
| 43,528,523
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
template <typename T>
void print_vec(const vector<T>& v, bool is_reverse=false, ll num=0){
if(num == 0) num = (ll)v.size();
if(is_reverse) for(ll i=num-1; i>=0; i--){ cout<<v[i]; if(i!=0) cout<<" ";}
else for(ll i=0; i<num; i++){ cout<<v[i]; if(i!=num-1) cout<<" ";}
cout << endl;
}
template <typename T>
void print_pairvec(const vector<T> &v, ll num=0){
if(num == 0) num = (ll)v.size();
cout << endl;
for(ll i=0; i<num; i++){ cout << v[i].first << " " << v[i].second << endl;}
}
template <typename T>
void print_vec2(const vector<vector<T>>& v){
cout << endl; cout << " ";
for(ll i=0; i<v[0].size(); i++) cout << i << " ";
cout << endl;
for(ll i=0; i<v.size(); i++){
cout << "i=" << i << ": ";
for(ll j=0; j<v[i].size(); j++){
if(v[i][j] == 0) cout << "\x1B[0m" << v[i][j] << " ";
else cout << "\x1B[31m" << v[i][j] << " ";
}
cout << "\x1B[0m" << endl;
}
}
int main(){
ll n;
cin >> n;
vector<ll> a(n);
for(ll i=0; i<n; i++) cin >> a[i];
for(ll i=0; i<n; i++) a[i] -= i+1;
sort(a.begin(), a.end());
ll mid = n / 2;
ll b = a[mid];
ll ans = 0;
for(ll i=0; i<n; i++) ans += abs(a[i] - b);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define pragma
using namespace std;
#define ll long long
#define ld long double
#define pb push_back
#define pf push_front
#define aisort sort(a,a+n)
#define adsort sort(a,a+n,greater<ll>())
#define PI 2 * acos(0)
typedef pair<ll, ll> pii;
typedef pair<ll, pii> piii;
typedef vector<ll> vi;
typedef vector<string> vs;
typedef vector<pii> vii;
typedef vector<piii> viii;
typedef set<ll> Set;
const ll maxs = 1e5+3;
const ll maxs1 = 1e3+4;
const ll mod = 1e9 + 7;
inline ll add(ll a, ll b) { return (mod + a + b) % mod; }
inline ll sub(ll a, ll b) { return (a - b + mod) % mod; }
inline ll mul(ll a, ll b) { return (1ll * a * b) % mod; }
ll fastpow(ll x,ll y)
{ll res = 1;x = x % mod;while (y > 0){ if (y & 1)res = (res * x) % mod; y = y >> 1 ; x = (x * x) % mod; } return res;}
ll inv(ll x){ return fastpow(x , mod - 2);}
bool isPrime(ll n) { if (n <= 1) return false; if (n <= 3) return true;if (n%2 == 0 || n%3 == 0) return false; for (int i=5; i*i<=n; i=i+6) if (n%i == 0 || n%(i+2) == 0) return false; return true; }
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin>>s;
ll cnt1=0,cnt2=0;
for(ll i=0;i<s.size();i++)
{
if(s[i]=='A')
cnt1++;
else
cnt2++;
}
if(cnt1>=1&&cnt2>=1)
cout<<"Yes";
else
cout<<"No";
}
| 0
| 22,776,423
|
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <iomanip>
using namespace std;
int main(){
long Q,H,S,D;
long N;
long total=0;
cin>>Q>>H>>S>>D>>N;
total = (N/2)*min({8*Q,4*H,2*S,D})+(N%2)*min({4*Q,2*H,S});
cout<<total<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define pll pair<ll,ll>
#define mod 1000000007
#define wi while
#define vl vector<ll>
#define vi vector<int>
#define map map<char,ll>
#define endl "\n"
const int mxN = 200001;
int main()
{
int n;
cin>>n;
string s;
cin>>s;
int cnt = 1;
for(int i=1;i<s.size();++i)
{
if(s[i]==s[i-1])
continue;
else
cnt++;
}
cout<<cnt<<endl;
return 0;
}
| 0
| 13,844,639
|
#include <bits/stdc++.h>
#define rep(i, n) for(int (i)=0; (i)<(n); (i)++)
using namespace std;
int main() {
int NUM[8], P[8], Q[8];
int N,p,q;
cin >> N;
rep(i, N) cin >> P[i];
rep(i, N) cin >> Q[i];
rep(i, N) NUM[i] = i+1;
int cnt = 0;
do {
cnt++;
bool flag = true;
rep(i, N) {
if(P[i] != NUM[i]) flag = false;
}
if(flag) p = cnt;
} while(next_permutation(NUM, NUM+N));
cnt = 0;
do {
cnt++;
bool flag = true;
rep(i, N) {
if(Q[i] != NUM[i]) {
flag = false;
}
}
if(flag) q = cnt;
} while(next_permutation(NUM, NUM+N));
cout << abs(p - q) << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <string>
#include <math.h>
#include <cstdint>
#include <sstream>
#include <map>
#include <vector>
#include <queue>
#include <iomanip>
using namespace std;
typedef long long ll;
ll ans, mx, sum, mn = 1e8, cnt;
int main(){
ll n;
cin>>n;
ll a[n],b[n];
for(ll i=0; i<n; i++){
cin>>a[i]>>b[i];
}
for(ll i=n-1; i>=0; i--){
a[i] +=ans;
if(a[i]%b[i]!=0){
ll flag=(((a[i]/b[i])+1)*b[i])-a[i];
ans +=flag;
}
}
cout<<ans<<endl;
}
| 0
| 10,987,401
|
#include <stdio.h>
int kuadrat(int a, int b)
{
int total = 1;
while(b > 0){
total *= a;
b--;
}
return total;
}
int main()
{
int cases;
scanf("%d", &cases);
long long int arr[cases], total = 1;
int i = 0;
char temp;
do
{
scanf("%lld%c", &arr[i], &temp);
if(arr[i] == 0){
printf("0");
return 0;
}
i++;
} while (temp != '\n');
for(int j = 0; j < cases; j++){
if (total > 1000000000000000000 / arr[j])
{
printf("-1");
return 0;
}
else
{
total *= arr[j];
}
}
printf("%lld", total);
return 0;
}
|
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <string>
using namespace std;
typedef long long ll;
#define rept(_i,iv,n,type) for(type _i=(type)(iv);_i<(type)(n);++_i)
#define rept0(_i,n,type) rept(_i,0,n,type)
#define repi0(_i,n) rept(_i,0,n,int)
#define repl0(_i,n) rept(_i,0,n,ll)
#define REPT(_i,iv,_l,n,type) for(type _i=(type)(iv),_l=(type)(n);_i<_l;++_i)
#define REPT0(_i,_l,n,type) REPT(_i,0,_l,n,type)
#define REPI0(_i,_l,n) REPT(_i,0,_l,n,int)
#define REPL0(_i,_l,n) REPT(_i,0,_l,n,ll)
#define REPV(v,_itr,_end) for(auto _itr=(v).begin(),_end=(v).end();_itr!=_end;++_itr)
#define REPVC(v,_itr,_end) for(auto _itr=(v).cbegin(),_end=(v).cend();_itr!=_end;++_itr)
#define td typedef
#define tdv(type,name) typedef vector<type > name;
typedef vector<bool> vb;
typedef vector<vb > vvb;
typedef vector<int> vi;
typedef vector<vi > vvi;
typedef vector<ll> vll;
#define mod99 998244353
int main(int argc, const char * argv[]) {
int X;
cin>>X;
int mod=X%100;
repi0(i2, 50){
int s2=i2*2;
repi0(i3, 34){
int s3=s2+i3*3;
repi0(i4, 25){
int s4=s3+i4*4;
repi0(i5, 20){
int s=s4+i5*5;
int i1;
if(mod<s){
i1=(s-mod)%100;
}else{
i1=mod-s;
}
int sum=i1*101+i2*102+i3*103+i4*104+i5*105;
if(sum<=X){
cout<<1<<endl;
return 0;
}
}
}
}
}
cout<<0<<endl;
return 0;
}
| 0
| 64,237,475
|
#include<iostream>
#include<cassert>
#include<stdio.h>
#include<string>
#include<vector>
#include<map>
#include<tuple>
#include<algorithm>
#include<cmath>
#include<limits>
#include<set>
#include<deque>
#include<queue>
using namespace std;
#define int long long int
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
typedef pair<int, int>P;
const int MOD = 1e9 + 7;
const int INF = 1e10;
const long double PI = (acos(-1));
struct UnionFind {
vector<int> par;
UnionFind(int N) : par(N) {
for (int i = 0; i < N; i++) par[i] = i;
}
int root(int x) {
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) return;
par[rx] = ry;
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
signed main() {
int N, M;
cin >> N >> M;
vector<int>p(N);
rep(i, N)cin >> p[i];
rep(i, N)p[i]--;
UnionFind tree(N);
rep(i, M) {
int x, y;
cin >> x >> y;
x--; y--;
tree.unite(x, y);
}
int ans = 0;
rep(i, N) {
if (tree.same(p[i], i))ans++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
#define rng(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, b) rng(i, 0, b)
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
#define pb push_back
#define eb emplace_back
#define a first
#define b second
#define bg begin()
#define ed end()
#define all(x) x.bg, x.ed
#define si(x) int(x.size())
#ifdef LOCAL
#else
#define dmp(x) void(0)
#endif
template <class t, class u>
void chmax(t &a, u b)
{
if (a < b)
a = b;
}
template <class t, class u>
void chmin(t &a, u b)
{
if (b < a)
a = b;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<int, int>;
using vi = vc<int>;
#define mp make_pair
#define mt make_tuple
#define one(x) memset(x, -1, sizeof(x))
#define zero(x) memset(x, 0, sizeof(x))
#ifdef LOCAL
void dmpr(ostream &os)
{
os << endl;
}
template <class T, class... Args>
void dmpr(ostream &os, const T &t, const Args &... args)
{
os << t << ;
dmpr(os, args...);
}
#define dmp2(...) dmpr(cerr, __LINE__, ##__VA_ARGS__)
#else
#define dmp2(...) void(0)
#endif
using uint = unsigned;
using ull = unsigned long long;
template <class t, size_t n>
ostream &operator<<(ostream &os, const array<t, n> &a)
{
return os << vc<t>(all(a));
}
ll read()
{
ll i;
cin >> i;
return i;
}
vi readvi(int n, int off = 0)
{
vi v(n);
rep(i, n) v[i] = read() + off;
return v;
}
pi readpi(int off = 0)
{
int a, b;
cin >> a >> b;
return pi(a + off, b + off);
}
template <class T>
void print(const vector<T> &v, int suc = 1)
{
rep(i, v.size())
print(v[i], i == int(v.size()) - 1 ? suc : 2);
}
string readString()
{
string s;
cin >> s;
return s;
}
template <class T>
T sq(const T &t)
{
return t * t;
}
constexpr ll ten(int n)
{
return n == 0 ? 1 : ten(n - 1) * 10;
}
const ll infLL = LLONG_MAX / 3;
#ifdef int
const int inf = infLL;
#else
const int inf = INT_MAX / 2 - 100;
#endif
int topbit(signed t)
{
return t == 0 ? -1 : 31 - __builtin_clz(t);
}
int topbit(ll t)
{
return t == 0 ? -1 : 63 - __builtin_clzll(t);
}
int botbit(signed a)
{
return a == 0 ? 32 : __builtin_ctz(a);
}
int botbit(ll a)
{
return a == 0 ? 64 : __builtin_ctzll(a);
}
int popcount(signed t)
{
return __builtin_popcount(t);
}
int popcount(ll t)
{
return __builtin_popcountll(t);
}
bool ispow2(int i)
{
return i && (i & -i) == i;
}
ll mask(int i)
{
return (ll(1) << i) - 1;
}
bool inc(int a, int b, int c)
{
return a <= b && b <= c;
}
template <class t>
void mkuni(vc<t> &v)
{
sort(all(v));
v.erase(unique(all(v)), v.ed);
}
ll rand_int(ll l, ll r)
{
#ifdef LOCAL
static mt19937_64 gen;
#else
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
#endif
return uniform_int_distribution<ll>(l, r)(gen);
}
template <class t>
void myshuffle(vc<t> &a)
{
rep(i, si(a)) swap(a[i], a[rand_int(0, i)]);
}
template <class t>
int lwb(const vc<t> &v, const t &a)
{
return lower_bound(all(v), a) - v.bg;
}
int lcm(int a, int b)
{
return a / __gcd(a, b) * b;
}
int fact(int a)
{
vc<int> fa;
for (int i = 1; i * i <= a; i++)
{
if (a % i == 0)
{
fa.emplace_back(i);
if (i != a / i)
fa.emplace_back(a / i);
}
}
return (int)fa.size();
}
signed main()
{
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
int n;
cin >> n;
int ans = 0;
for (int i = 1; i < n; i++)
{
ans += ((n - 1) / i);
}
cout << ans << endl;
}
| 0
| 6,289,529
|
#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);
}
}
int count =0;
for (int i = 0; i < W; i++) {
bool flag = true;
for (int j = 0; j < H; j++) {
if (data.at(j).at(i-count) != '.') {
flag = false;
break;
}
}
if (flag == true) {
for (int k = 0; k < H; k++) {
for (int l = i-count; l < W-1; l++){
data.at(k).at(l) = data.at(k).at(l+1);
}
}
count++;
}
}
for (int i = 0; i < H; i++) {
bool flag = true;
for (int j = 0; j < W; j++) {
if (data.at(i).at(j) != '.') {
flag = false;
break;
}
}
if (flag == false) {
for (int j = 0; j < W - count; j++) {
cout << data.at(i).at(j);
}
cout << endl;
}
}
}
|
#include <bits/stdc++.h>
#include <iostream>
#define ll long long
#define map unordered_map
#define set unordered_set
using namespace std;
const ll MOD = 1000000007;
int main() {
ll n, k;
scanf("%lld %lld", &n, &k);
vector<ll> a(n);
for (ll i = 0; i < n; i++) {
ll v;
scanf("%lld", &v);
a[i] = v;
}
vector<ll> csum(a.size() + 1);
for (ll i = 1; i < a.size() + 1; i++) {
csum[i] = csum[i - 1] + a[i - 1];
}
map<ll, ll> m;
ll ans = 0;
for (ll i = 0; i <= n; i++) {
if (i >= k) {
ll p = i - k;
ll pdf = csum[p] - p;
pdf = ((pdf % k) + k) % k;
m[pdf]--;
}
ll df = csum[i] - i;
df = ((df % k) + k) % k;
ll plus = m[df];
ans += plus;
m[df] += 1;
}
cout << ans << endl;
}
| 0
| 47,605,931
|
#include <bits/stdc++.h>
#define REP(i, n) for(ll i = 0; i < (ll)(n); i++)
#define FOR(i, a, b) for(ll i = a; i < (ll)(b); i++)
#define ALL(x) (x).begin(), (x).end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
using namespace std;
using ll = long long;
using vel = vector<ll>;
using ves = vector<string>;
using veb = vector<bool>;
using qul = queue<ll>;
void Yes(bool a){cout<<(a?"Yes":"No")<<endl;}
void YES(bool a){cout<<(a?"YES":"NO")<<endl;}
int binary_search(ll x, vel a){
auto ite = lower_bound(ALL(a), x);
if(ite != a.end() && *ite == x) {
return ite - a.begin() ;
} else {
return -1;
}
}
ll modpow(ll a, ll n, ll mod) {
if(n == 0)
return 1;
if(n == 1)
return a % mod;
if(n % 2 == 1)
return (a * modpow(a, n - 1, mod)) % mod;
ll t = modpow(a, n / 2, mod);
return (t * t) % mod;
}
int main() {
ll N, K, sum = 0, sum2 = 0, next, count = 0, ans, num, num2, m_l, m_l2;
cin >> N >> K;
vel P(N), C(N), check(N);
REP(i, N) cin >> P[i];
REP(i, N) cin >> C[i];
bool flag = false;
ans = C[0];
REP(i,N){
count = 0;
next = i;
sum = 0;
m_l = C[next];
m_l2 = C[next];
REP(j,N){
sum += C[next];
next = P[next]-1;
ans = max(ans, sum);
m_l2 = max(m_l2, sum);
count++;
if(j+1 >= K || next == i)
break;
}
next = i;
sum2 = 0;
REP(j, K%count) {
sum2 += C[next];
next = P[next]-1;
m_l = max(m_l, sum2);
}
if(sum >= 0){
if(K%count==0) m_l = 0;
num = K/count * sum + m_l;
num2 = (K/count - 1) * sum + m_l2;
num = max(num, num2);
ans = max(ans, num);
} else {
ans = max(ans, m_l);
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <iomanip>
#include <bitset>
#include <set>
#include <map>
#include <stdio.h>
#include <numeric>
#include <cstring>
#define rep(i,n) for (int i = 0; i < (n); i++)
#define rep1(i,n) for (int i = 1; i < (n); i++)
#define FOR(i,a,b) for (int i=(a); i < (b); i++)
#define MOD 1000000007
using namespace std;
using ll = long long;
using PII = pair<int, int>;
using PLL = pair<ll, ll>;
const int INF = numeric_limits<int>::max();
const ll INFL = numeric_limits<ll>::max();
long long mod(long long val, long long m) {
long long res = val % m;
if (res < 0) res += m;
return res;
}
long long gcd(ll a, ll b)
{
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
long long lcm(ll a, ll b)
{
return a / gcd(a, b) * b ;
}
ll factorial(ll n) {
ll res = 1;
for (ll i = 1; i <= n; i++) {
res *= i;
}
return res;
}
int main()
{
string s, t; cin >> s >> t;
reverse(t.begin(), t.end());
if (s == t)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0
| 62,761,849
|
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops,no-stack-protector")
#pragma GCC target("sse,sse2,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define watch(x) cout << (#x) << " is " << (x) << endl
#define debug cout << "hi" << endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
ll gcd(ll a, ll b) {return (!b ? a : gcd(b, a % b));}
bool cmp(int a,int b){return a>b;}
const ll mod = 1e9 + 7;
const int INF32 = 1<<30;
const ll INF64 = 1LL<<60;
const ld pi = 3.141592653589793;
void solve(){
int n,m;
cin >> n >> m;
priority_queue<int>pq;
vector< vector<int> >a(m+1);
for(int i = 0;i<n;i++){
int v,u;cin >> v >> u;
if(v>m) continue;
a[v].push_back(u);
}
int ans = 0;
for(int i = 1;i<=m;i++){
for(int j = 0;j<a[i].size();j++)
pq.push(a[i][j]);
if(pq.size()>0){
ans += pq.top();
pq.pop();
}
}
cout << ans;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);cout.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
typedef long long ll;
using Graph = vector<vector<int>>;
typedef long long ll;
typedef pair<int, int> P;
const int MOD = 1000000007;
const int INF_32 = 1LL << 30;
const int64_t INF_64 = 1LL << 60;
const int MAX_N = 110000;
int dp[MAX_N];
int main()
{
int N;
cin >> N;
for (int i = 0; i < MAX_N; i++)
dp[i] = N;
dp[0] = 0;
for (int n = 0; n <= N; n++) {
for (int pow6 = 1; pow6 + n <= N; pow6 *= 6) {
dp[n + pow6] = min(dp[n + pow6], dp[n] + 1);
}
for (int pow9 = 1; pow9 + n <= N; pow9 *= 9) {
dp[n + pow9] = min(dp[n + pow9], dp[n] + 1);
}
}
cout << dp[N] << endl;
return 0;
}
| 0
| 46,945,768
|
#include <queue>
#include <stack>
#include <map>
#include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <complex>
typedef long long int LL;
typedef unsigned long long int ULL;
using namespace std;
int main() {
int n, k;
scanf("%d%d", &n, &k);
int maxp = (n - 1) * (n - 2) / 2;
if (k > maxp) {
printf("-1\n");
} else {
int diff = maxp - k;
int e = (n - 1) + diff;
printf("%d\n", e);
for (int i = 2; i <= n; i++) {
printf("%d %d\n", 1, i);
}
for (int i = 2; i <= n && diff > 0; i++) {
for (int j = i + 1; j <= n && diff > 0; j++) {
printf("%d %d\n", i, j);
diff--;
}
}
}
}
|
#include <iostream>
#include <string>
#include <stack>
using namespace std;
int main()
{
int n;
string s;
cin >> n >> s;
stack<char> c;
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
c.push('(');
} else {
if (c.empty()) {
cout << '(';
} else {
c.pop();
}
}
}
cout << s;
while (!c.empty()) {
cout << ')';
c.pop();
}
return 0;
}
| 0
| 81,103,568
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, start, n) for (int i = (int)(start); i < (int)(n); ++i)
#define all(a) a.begin(), a.end()
const int MOD = 1e9+7;
int main(){
int N;
cin >> N;
vector<ll> A(60);
long long num;
rep(i, 0, N){
cin >> num;
rep(j, 0, 60){
if ((num>>j)&1){
A[j]++;
}
}
}
ll ans = 0, base = 1;
rep(i, 0, 60){
ll add = (N - A[i]) * A[i] % MOD * base % MOD;
ans = (ans + add) % MOD;
base = (2 * base) % MOD;
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int N, M;
vector<vector<int> > adj;
int cnt, odd;
vector<int> col;
void dfs(int u, int c) {
cnt++;
col[u] = c;
for(int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if(col[v] != -1) {
if(col[v] == col[u]) odd = 1;
continue;
}
dfs(v, c ^ 1);
}
}
int a, b, c;
int main() {
scanf("%d %d", &N, &M);
adj.resize(N);
for(int i = 0; i < M; i++) {
int u, v; scanf("%d %d", &u, &v);
u--; v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
col = vector<int>(N, -1);
a = b = c = 0;
for(int i = 0; i < N; i++) {
if(col[i] == -1) {
cnt = odd = 0;
dfs(i, 0);
if(cnt == 1) a++;
else if(odd) b++;
else c++;
}
}
long long ans = 0;
ans += 2LL * a * (N - a) + 1LL * a * a;
ans += 1LL * b * b;
ans += 2LL * c * c;
ans += 2LL * b * c;
printf("%lld", ans);
}
| 0
| 26,453,267
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
int main(void)
{
char a, b;
cin >> a >> b;
if (a == 'H')
cout << (b == 'H' ? "H" : "D") << endl;
else
cout << (b == 'H' ? "D" : "H") << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
string s;
cin >> s;
vector<int> alp(26, 0);
for(char d : s){
alp[d - 'a'] = 1;
}
bool f = true;
for(int i = 0; i < 26; i++){
if(alp[i] == 0){
f = false;
cout << char(i + 'a') << endl;
break;
}
}
if(f) puts("None");
}
| 0
| 94,769,291
|
#include<bits/stdc++.h>
using namespace std;
int A[10010],B[10010];
int main()
{
int N;
cin>>N;
for(int i=0;i<N;i++)
cin>>A[i];
for(int i=0;i<N;i++)
cin>>B[i];
long long Asum=0,Bsum=0,Csum=0;
for(int i=0;i<N;i++)
{
Asum+=A[i];
Bsum+=B[i];
Csum+=max(0,(B[i]-A[i]+1)/2);
}
Bsum-=Asum;
if(Bsum<0)
puts("No");
else if(Bsum==0)
{
bool ok=true;
for(int i=0;i<N;i++)
if(A[i]!=B[i])
ok=false;
if(ok)
puts("Yes");
else puts("No");
}
else
{
if(Csum>Bsum)
puts("No");
else puts("Yes");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
using pii = pair<int, int>;
struct UnionFind {
vector<int> par;
vector<int> rank;
UnionFind(int N) : par(N), rank(N) {
for (int i = 0; i < N; i++) {
par[i] = i;
rank[i] = 0;
}
}
int root(int x) {
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return;
if (rank[x] < rank[y]) {
par[x] = y;
} else {
par[y] = x;
if (rank[x] == rank[y]) rank[x]++;
}
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main() {
int n, q;
cin >> n >> q;
UnionFind u(n);
for (int i = 0; i < q; i++) {
int p, a, b;
cin >> p >> a >> b;
if (p == 0) {
u.unite(a, b);
} else {
cout << (u.same(a, b) ? 1 : 0) << endl;
}
}
}
| 0
| 48,906,461
|
#include "bits/stdc++.h"
#define PRECISION(x) cout << fixed << setprecision(x)
#define FAST_IO ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define ALLR(X) (X).rbegin(), (X).rend()
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define F first
#define S second
using namespace std;
template<class T> void max_self(T & a, const T & b) { if(a < b) a = b; }
template<class T> void min_self(T & a, const T & b) { if(a > b) a = b; }
typedef long long LL;
const int INF = 1e9 + 7;
const double PI = acos(-1.0);
const double EPS = (1e-9);
int a, b;
int main(){
FAST_IO
cin >> a >> b;
if(a == b) cout << "Draw\n";
else if(a == 1) cout << "Alice\n";
else if(b == 1) cout << "Bob\n";
else if(a > b) cout << "Alice\n";
else cout << "Bob\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORR(i, m, n) for (int i = m; i >= n; --i)
#define ALL(v) (v).begin(),(v).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; }
const ll INF=1LL<<60;
const int inf=(1<<30)-1;
const int mod=1e9+7;
int dx[8]={1,0,-1,0,-1,-1,1,1};
int dy[8]={0,1,0,-1,-1,1,-1,1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int h,w;cin >> h >> w;
char a[h][w];
queue<pair<int,int>> q;
vector<vector<int>> d(h,vector<int>(w,inf));
REP(i,h){
REP(j,w){
cin >> a[i][j];
if(a[i][j]=='#'){
q.push({i,j});
d[i][j]=0;
}
}
}
while(!q.empty()){
int u=q.front().first,v=q.front().second;
q.pop();
REP(i,4){
int x=u+dx[i],y=v+dy[i];
if(x>=0&&x<h&&y>=0&&y<w){
if(chmin(d[x][y],d[u][v]+1)){
q.push({x,y});
}
}
}
}
int ans=0;
REP(i,h) REP(j,w) chmax(ans,d[i][j]);
cout << ans << endl;
}
| 0
| 28,483,897
|
#include <iostream>
#include <vector>
#include<algorithm>
#include<string>
#include<stdio.h>
#include<map>
#include<math.h>
#include<queue>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int MOD = 1000000007;
const int mod = 1000000007;
const int INF = 1000000001;
const long long LINF = 1e18;
const int MAX = 510000;
int main(){
string s, t;
bool f = 0;
cin >> s >> t;
for (int i = 0; i < s.size(); i++) {
s = s[s.size() - 1] + s;
s.erase(s.end()-1);
if (s == t)f = 1;
}
if (f == 1)cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define fast() ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define all(x) begin(x),end(x)
#define rz(x) resize(x)
#define asn(x,y) assign(x,y)
#define mem(a,b) memset(a,b,sizeof(a))
#define sz(x) ((int)(x.size()))
#define eb emplace_back
#define pb push_back
#define pf push_front
#define pob pop_back
#define pof pop_front
#define ins insert
#define vi vector<int>
#define pii pair<int,int>
#define mii map<int,int>
#define F first
#define S second
#define remax(a,b) a=max(a,b)
#define remin(a,b) a=min(a,b)
#define bitcount(x) __builtin_popcountll(x)
#define iceil(n,x) (((n)-1)/(x)+1)
#define dbug(x) cout<<#x<<": "<<(x)<<"\n"
#define flush fflush(stdout)
#define show(x) for(auto zz:x)cout<<zz<<" ";cout<<"\n";
#define show2(x) for(auto zz:x)cout<<zz.F<<" "<<zz.S<<"\n";
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
const ld pi=acos(-1);
const ll inf=1e18,M=1e9+7;
const int N=1e5+5;
int dp[N][2];
string s;
int rec(int ind,int tight)
{
if(ind==-1)
return 1;
int& res=dp[ind][tight];
if(res!=-1)
return res;
res=0;
int nt;
for(int i=0;i<3;++i)
{
if(i)
{
if(s[ind]=='0')
{
if(tight)
break;
else
nt=0;
}
else
nt=tight;
}
else
{
if(s[ind]=='0')
nt=tight;
else
nt=0;
}
res=(res+rec(ind-1,nt))%M;
}
return res;
}
void solve()
{
mem(dp,-1);
cin>>s;
reverse(all(s));
int ans=rec(sz(s)-1,1);
cout<<ans;
}
int32_t main()
{
fast();
int t=1;
for(int z=1;z<=t;++z)
{
solve();
}
return 0;
}
| 0
| 95,286,291
|
#include <bits/stdc++.h>
#include<string.h>
#define ll long long
#include<vector>
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
int main(){
IOS;
int n,m;
cin>>n>>m;
int votes=0;
vector<int> v(n);
for(int i=0;i<n;i++)
{
cin>>v[i];
votes+=v[i];}
sort(v.begin(),v.end(),greater<int>());
if(v[m-1]>=(votes+4*m-1)/(4*m))
cout<<"Yes";
else
cout<<"No";
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
string A,B;
cin >> A >> B;
if(A[0] == B[0]){
cout << "=" << endl;
return 0;
}
if(A[0] > B[0]){
cout << ">" << endl;
}else{
cout << "<" << endl;
}
return 0;
}
| 0
| 83,590,088
|
#include <iostream>
using namespace std;
int main() {
int a,b,c,d,e,f,g,h;
cin >> a >> b >> c >> d >> e >> f >> g >> h;
int S=a+b+c+d;
int T=e+f+g+h;
if (S>T){
cout << S << endl;
}
else cout << T << endl;
return 0;
}
|
#include<iostream>
#include <cstring>
#include<string>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<math.h>
#include<complex>
#include<queue>
#include<deque>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<functional>
#include<assert.h>
#include<numeric>
using namespace std;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
using ll = long long;
const int inf=1e9+7;
const ll longinf=1LL<<60 ;
const ll mod=1e9+7 ;
int main(){
int N; cin >> N;
int t[N+1]; double v[N]; int sum=0; t[0] = 0;
rep(i, N){
cin >> t[i+1]; t[i+1]+=t[i];
}
rep(i, N){
cin >> v[i];
}
double K[N+1];
K[0] = 0; K[N] = 0;
rep(i, N-1){
K[i+1] = min(v[i], v[i+1]);
}
double tmp[2*sum+1]; double ans = 0;
rep(i, 2*t[N]+1){
tmp[i] = inf;
rep(j, N+1){
tmp[i] = min(tmp[i], K[j]+abs(t[j]-i*0.5));
}
rep(j, N){
if(t[j]<=i*0.5 && i*0.5<=t[j+1]) tmp[i] = min(tmp[i], (double)v[j]);
}
if(i>0) ans+=(tmp[i]+tmp[i-1])*0.25;
}
printf("%.12lf\n", ans);
}
| 0
| 52,812,029
|
#include<bits/stdc++.h>
using namespace std;
#define INF 1000000000
#define REP(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
typedef long long LL;
int N;
int main(){
string str;
while(getline(cin,str),str!="."){
vector<string>s(1000);
int num=0;
bool check=true;
REP(i,str.size()){
if(str[i]=='('){
s[num]="(";
num++;
}
if(str[i]=='['){
s[num]="[";
num++;
}
if(str[i]==')'){
if(num==0){
check=false;
break;
}
if(s[num-1]!="("){
check=false;
break;
}
num--;
}
if(str[i]==']'){
if(num==0){
check=false;
break;
}
if(s[num-1]!="["){
check=false;
break;
}
num--;
}
}
if(num!=0)check=false;
if(check==true){
cout<<"yes"<<endl;
}else{
cout<<"no"<<endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
long long int N = 0 ,A, B, C, K;
string S;
cin >> A >> B >> C >> K;
if (K <= A) cout << K << endl;
else if (K <= A + B) cout << A <<endl;
else cout << 2*A + B -K << endl;
}
| 0
| 41,321,901
|
#include <bits/stdc++.h>
using namespace std;
#define INF 100005
#define MOD 1000000007
int main()
{
string a;
cin >> a;
int n=a.size();
for(int i=0;i<n-1;i++)
{
if(a[i]==a[i+1])
{
cout << i+1 << " " << i+2 << endl;
return 0;
}
}
for(int i=0;i<n-2;i++)
{
if(a[i]==a[i+2])
{
cout << i+1 << " " << i+3 << endl;
return 0;
}
}
cout << -1 << " " << -1 << endl;
}
|
#include <bits/stdc++.h>
using ll = long long;
#define FOR(i, k, n) for(ll i = (k); i < (n); i++)
#define FORe(i, k, n) for(ll i = (k); i <= (n); i++)
#define FORr(i, k, n) for(ll i = (k)-1; i > (n); i--)
#define FORre(i, k, n) for(ll i = (k)-1; i >= (n); i--)
#define REP(i, n) FOR(i, 0, n)
#define REPr(i, n) FORre(i, n, 0)
#define ALL(x) (x).begin(), (x).end()
#define ALLr(x) (x).rbegin(), (x).rend()
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
using namespace std;
const int INF = 1001001001;
using P = pair<ll, ll>;
int main(void){
ll H, W, M;
cin >> H >> W >> M;
vector<ll> h(M), w(M);
map<P, ll> mp;
REP(i, M){
cin >> h[i] >> w[i];
h[i]--; w[i]--;
mp[P(h[i], w[i])]++;
}
vector<ll> a(H, 0), b(W, 0);
REP(i, M) a[h[i]]++, b[w[i]]++;
ll c = *max_element(ALL(a));
ll d = *max_element(ALL(b));
vector<ll> p, q;
REP(i, H) if(a[i] == c) p.emplace_back(i);
REP(i, W) if(b[i] == d) q.emplace_back(i);
ll n = p.size(), m = q.size();
ll ans = c+d-1;
REP(i, n) REP(j, m){
if(mp[P(p[i], q[j])] == 0){
ans = c+d;
break;
}
}
cout << ans << endl;
return 0;
}
| 0
| 35,849,690
|
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
const int N = 1e5 + 5;
vector<int> g[N];
int siz[N];
bool f[N], col[N];
i64 mono, ant, col1, col2;
int n, m;
bool dfs(int u, int far = -1) {
bool flag = false;
siz[u] = 1;
f[u] = true;
for (auto v: g[u]) if (v != far) {
if (!f[v]) {
col[v] = !col[u];
flag|= dfs(v, u);
siz[u]+= siz[v]; }
else
flag|= col[u] == col[v]; }
return flag; }
int main() {
#ifdef HOME
freopen("agc11c.in", "r", stdin);
freopen("agc11c.out", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int a, b, i = 0; i < m; ++i) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a); }
for (int i = 1; i <= n; ++i) if (!f[i]) {
if (dfs(i))
++col1;
else
++col2;
if (siz[i] == 1) {
++mono;
--col2; } }
ant+= mono * mono;
ant+= mono * (n - mono) * 2;
ant+= col1 * col1;
ant+= col1 * col2 * 2;
ant+= col2 * col2 * 2;
cout << ant << endl;
return 0; }
|
# include <iostream>
# include <queue>
# include <cctype>
typedef std::pair<int, int> P;
const int INF = 100000;
const int MAX_H = 1000;
const int MAX_W = 1000;
const int MAX_N = 9;
int dx[4] = { 1,-1,0,0 }, dy[4] = { 0,0,1,-1 };
int h, w, n;
int d[MAX_H][MAX_W];
char ch[MAX_H][MAX_W];
P p[MAX_N + 1];
int bfs(P s, P g) {
for (int i = 0; i<h; ++i) {
for (int j = 0; j<w; ++j)
d[i][j] = INF;
}
std::queue<P> que;
que.push(s);
d[s.second][s.first] = 0;
while (!que.empty()) {
P x = que.front(); que.pop();
if (x == g)
break;
for (int i = 0; i < 4; ++i) {
int nx = x.first + dx[i];
int ny = x.second + dy[i];
if (nx >= 0 && ny >= 0 && nx < w && ny < h && d[ny][nx] == INF && ch[ny][nx] != 'X') {
que.push(P(nx, ny));
d[ny][nx] = d[x.second][x.first] + 1;
}
}
}
return d[g.second][g.first];
}
int solve() {
int res = 0;
for (int i = 1; i <= n; ++i) {
res += bfs(p[i - 1], p[i]);
}
return res;
}
int main() {
std::cin >> h >> w >> n;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
std::cin >> ch[i][j];
if (std::isdigit(ch[i][j])) {
p[atoi(&ch[i][j])].first = j;
p[atoi(&ch[i][j])].second = i;
}
else if (ch[i][j] == 'S') {
p[0].first = j;
p[0].second = i;
}
}
}
std::cout << solve() << std::endl;
return 0;
}
| 0
| 61,657,793
|
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define all(a) a.begin(), a.end()
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<ll,int> pli;
typedef pair<int,int> pii;
#define rep(i,a,b) for(ll i=a ; i<b ; i++)
#define qrep(que, ite) for(auto ite=begin(que) ; ite!=end(que) ; ite++)
const int max_n = 1e5;
const ll mod = 1e9+7;
const ll INF = 1e17;
const int inf = 1e5;
typedef long double ld;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
ll gcd(ll a, ll b) { return a ? gcd(b%a, a) : b; }
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) { }
void init(int n) { par.assign(n, -1); }
int root(int x) {
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
bool issame(int x, int y) {
return root(x) == root(y);
}
bool merge(int x, int y) {
x = root(x); y = root(y);
if (x == y) return false;
if (par[x] > par[y]) swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) {
return -par[root(x)];
}
};
struct SegmentTree{
int N;
vector<int> node;
public :
void intit(vector<int>v){
int sz = v.size();
N=1;
while(N<sz) N*=2;
node.resize(N);
for(int i=0 ; i<sz ; i++) node[i+N-1] = v[i];
for(int i=N-2 ; i>=0 ; i--) node[i] = min(node[i*2+1], node[i*2+2]);
}
void update(int x, int val){
x += N-1;
node[x+N-1] = val;
while(x>0){
x = (x-1)/2;
node[x] = min(node[x*2+1], node[x*2+2]);
}
}
int getmin(int a, int b, int k, int l, int r){
if(b<=l || r<=a) return inf;
else if(a<=l && r<=b) return node[k];
else{
int vl = getmin(a, b, 2*k+1, l, (l+r)/2);
int vr = getmin(a, b, 2*k+2, (l+r)/2, r);
return min(vl, vr);
}
}
};const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main(){
string s,t; cin>>s>>t;
int ok = 1;
map<char, int> ma;
int N = s.size();
for(char c='a' ; c<='z' ; c++) ma[c] = c - 'a';
vector<set<int>> set1(26), set2(26);
int cnt = 0;
rep(i,0,N){
int now = ma[s[i]];
set1[now].insert(i);
now = ma[t[i]];
set2[now].insert(i);
}
rep(i,0,26){
char c = ' '; cnt = 0;
for(auto j : set1[i]){
if(cnt==0){
cnt++; c = t[j];
continue;
}
if(c != t[j]) ok = 0;
}
cnt = 0;
for(auto j : set2[i]){
if(cnt==0){
cnt++; c = s[j];
continue;
}
if(c != s[j]) ok = 0;
}
}
string ans = "No";
if(ok){
ans = "Yes";
}
cout<<ans<<endl;
return 0;
}
|
#include <iomanip>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int,int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef double dl;
#define endl '\n'
#define PB push_back
#define F first
#define S second
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define sz(x) (int)x.size()
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const ll infLL = 9000000000000000000;
#define mod 1000000007
#define mem(a,b) memset(a, b, sizeof(a) )
#define sqr(a) ((a) * (a))
#define optimize() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define fraction() cout.unsetf(ios::floatfield); cout.precision(10); cout.setf(ios::fixed,ios::floatfield);
#define file() freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#define dbg(args...) do {cerr << #args << " : "; faltu(args); } while(0)
void faltu () { cerr << endl;}
template < typename T, typename ... hello>void faltu( T arg, const hello &... rest) {cerr << arg << ' ';faltu(rest...);}
ll gcd ( ll a, ll b ) { return __gcd ( a, b ); }
ll lcm ( ll a, ll b ) { return a * ( b / gcd ( a, b ) ); }
main()
{
optimize();
int n,i;
cin>>n;
vector<pair<double,string>>v;
double c=0,x,p=380000.0;
string y;
for(i=1;i<=n;i++)
{
cin>>x>>y;
v.PB({x,y});
}
for(auto u:v)
{
if(u.S=="BTC")
{
c=c+((u.F)*p);
}
else
c=c+u.F;
}
cout<<fixed<<setprecision(4)<<c<<endl;
return 0;
}
| 0
| 49,503,769
|
#include<iostream>
using namespace std;
int main(){
string S;
cin >> S;
cout << (S[0] == S[1] || S[0] == S[2] || S[1]==S[2] ? "No" : "Yes") << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define be(v) (v).begin(),(v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod=1000000007;
#define doublecout(a) cout<<fixed<<setprecision(10)<<a<<endl;
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll n;
string s;
cin>>n>>s;
int a[26]={0};
for(int i=0;i<n;i++){
a[s[i]-'a']++;
}
ll ans=1;
for(int i=0;i<26;i++){
ans*=(a[i]+1);
ans%=mod;
}
cout << ans-1<<endl;
return 0;
}
| 0
| 6,659,128
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); i++)
using ll = long long;
using namespace std;
using P = pair<int,int>;
int main(){
int n, k;
cin >> n >> k;
vector<int> h(n);
for(int i = 0; i < n; i++){
cin >> h[i];
}
int count = 0;
for(int i = 0; i < n; i++){
if(h[i] >= k) count += 1;
}
cout << count << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> par, s;
UnionFind(int n) : par(n), s(n, 1) {
for(int i = 0; i < n; i++) par[i] = i;
}
int root(int n) {
return par[n] == n ? n : root(par[n]);
}
void unite(int n, int m) {
n = root(n);
m = root(m);
if (n == m) return;
if (s[n] < s[m]) swap(n, m);
s[n] += s[m];
par[m] = n;
}
int size(int n) {
return s[root(n)];
}
bool same(int n, int m) {
return root(n) == root(m);
}
};
int main() {
int n, m;
cin >> n >> m;
vector<int> p(n);
for(auto& e : p){
cin >> e;
e--;
}
UnionFind un(n);
for(int i = 0; i < m; i++){
int x, y;
cin >> x >> y, x--, y--;
un.unite(x, y);
}
int cnt = 0;
for (int i = 0; i < n; i++){
if(un.same(i, p[i])) cnt++;
}
cout << cnt << endl;
return 0;
}
| 0
| 4,823,984
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
int a[20],n,s,h;
string v;
main()
{
a[0]=1;
for(int i=1;i<=15;i++)
a[i]=a[i-1]*10;
s=0;
for(int i=10;i>=1;i--)
{
int check = a[i]-1;
cout << "? " << check << "\n";
fflush(stdout);
cin >> v;
if(v == "N")
{
s = i+1;
break;
}
}
if(s==0)
{
for(int i=10;i>=0;i--)
{
int check = a[i];
cout << "? " << check << "\n";
fflush(stdout);
cin >> v;
if(v == "Y"&& i==10)
{
cout << "! " << 1 << "\n";
fflush(stdout);
exit(0);
}
if(v=="Y")
{
s=i+1;
break;
}
}
}
int l,r,gi;
l=a[s];
r=a[s+1]-10;
gi=0;
while(l<r)
{
int mid;
mid=(l+r)/2;
if(mid==gi) break;
else gi=mid;
cout << "? " << mid << "\n";
fflush(stdout);
cin >> v;
if(v == "Y") r=mid;
else l=mid;
h++;
}
if(r/10!=0) cout<<"! "<<r/10<<endl;
else cout<<"! "<<1<<endl;
fflush(stdout);
}
|
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iomanip>
#include <numeric>
#include <queue>
#include <cmath>
using namespace std;
int myposition(const pair<long long int, long long int>& p) {
long long int x = p.first, y = p.second;
if (x > 0 && y >= 0) {
return 1;
}
if (x <= 0 && y > 0) {
return 2;
}
if (x < 0 && y <= 0) {
return 3;
}
if (x >= 0 && y < 0) {
return 4;
}
return 0;
}
bool mycompare(const pair<long long int, long long int>& p1,
const pair<long long int, long long int>& p2) {
return 1.0 * pow(p1.second, 2) / (pow(p1.first, 2) + pow(p1.second, 2)) < 1.0 * pow(p2.second, 2) / (pow(p2.first, 2) + pow(p2.second, 2));
}
int main() {
int n;
cin >> n;
vector<pair<long long int, long long int>> vp1, vp2, vp3, vp4, vp;
long long int x, y;
for (int i = 0; i < n; i++) {
cin >> x >> y;
if (x > 0 && y >= 0) {
vp1.emplace_back(x, y);
}
if (x <= 0 && y > 0) {
vp2.emplace_back(x, y);
}
if (x < 0 && y <= 0) {
vp3.emplace_back(x, y);
}
if (x >= 0 && y < 0) {
vp4.emplace_back(x, y);
}
}
sort(vp1.begin(), vp1.end(), mycompare);
sort(vp2.begin(), vp2.end(), mycompare);
reverse(vp2.begin(), vp2.end());
sort(vp3.begin(), vp3.end(), mycompare);
sort(vp4.begin(), vp4.end(), mycompare);
reverse(vp4.begin(), vp4.end());
vp.reserve(vp1.size() + vp2.size() + vp3.size() + vp4.size());
vp.insert(vp.end(), vp1.begin(), vp1.end());
vp.insert(vp.end(), vp2.begin(), vp2.end());
vp.insert(vp.end(), vp3.begin(), vp3.end());
vp.insert(vp.end(), vp4.begin(), vp4.end());
double res = 0;
n = vp.size();
for (int i = 0; i < n; i++) {
int pos1 = myposition(vp[i]);
int next_pos1 = (pos1 + 1 == 5 ? 1 : pos1 + 1);
int next_pos2 = (pos1 + 2 > 4 ? pos1 + 2 - 4 : pos1 + 2);
int index = (i + 1) % n;
x = vp[i].first, y = vp[i].second;
res = max(res, pow(x * x + y * y, 0.5));
while (index != i) {
int pos2 = myposition(vp[index]);
long long int c = vp[index].first * vp[i].first + vp[index].second * vp[i].second;
if ((pos2 == next_pos1) || (pos2 == pos1 && c >= 0) || (pos2 == next_pos2 && c <= 0)) {
x += vp[index].first;
y += vp[index].second;
res = max(res, pow(x * x + y * y, 0.5));
} else {
break;
}
index = (index + 1) % n;
}
res = max(res, pow(x * x + y * y, 0.5));
}
cout << setprecision(30) << res << endl;
}
| 0
| 30,464,065
|
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define rep(i,n) for(int64_t i=0;i < (int64_t)(n);i++)
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define FILE_IN "billboard.inp"
#define FILE_OUT "billboard.out"
#define ofile freopen(FILE_IN,"r",stdin);freopen(FILE_OUT,"w",stdout)
#define fio ios::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define nfio cin.tie(0);cout.tie(0)
#define max(x,y) (((x)>(y))?(x):(y))
#define min(x,y) (((x)<(y))?(x):(y))
#define ord(a,b,c) ((a>=b)and(b>=c))
#define MOD (ll(1000000007))
#define MAX 300001
#define mag 320
#define p1 first
#define p2 second.first
#define p3 second.second
#define fi first
#define se second
#define pow2(x) (ll(1)<<x)
#define pii pair<int,int>
#define pll pair<ll,ll>
#define piii pair<int,pii>
#define For(i,__,___) for(int i=__;i<=___;i++)
#define Rep(i,__,___) for(int i=__;i>=___;i--)
#define ordered_set tree<long long,null_type,less<long long>,rb_tree_tag,tree_order_statistics_node_update>
#define bi BigInt
#define pi 3.1415926535897
typedef long long ll;
ll n,m,k,cnt[100001],t,t1,i,j,minn=1e9,maxx,cur,lu,lv;
ll arr[100002];
string s;
ll cint,cval;
vector<ll> lis;
int main() {
fio;
cin>>n;
for (i=1;i<=n;i++)
{
cin>>arr[i];
lis.push_back(i);
}
sort(lis.begin(),lis.end(),[](ll a, ll b) {
if (arr[a]-arr[b]) return (arr[a]>arr[b]);
return (a<b);
});
for (i=0;i<n;i++)
{
if (i==0)
{
cint=lis[0];
cval=0;
}
else
{
cval+=(-arr[lis[i]]+arr[lis[i-1]])*i;
if (lis[i]<cint)
{
cnt[cint]=cval;
cint=lis[i];
cval=0;
}
}
}
cval+=(arr[lis[i-1]])*i;
cnt[cint]=cval;
cint=lis[i];
cval=0;
for (i=0;i<n;i++) cout<<cnt[i+1]<<endl;
}
|
#include <bits/stdc++.h>
#include<cmath>
#define N 100005
#define A 1000005
#define MOD 998244353
#define INF 1000000000000000000
#define ll long long
using namespace std;
#define pii pair<ll, ll>
#define piii pair<ll, pii>
#define ft first
#define sd second
#define pb push_back
#define rep(i, n) for(ll i = 0; i < n; i++)
#define repr(i, n) for(ll i = n-1; i >= 0; i--)
#define itr(it, x) for(auto it = x.begin(); it != x.end(); it++)
#define mem(a, b) memset(a, (ll)b, sizeof(a))
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
#define edge(v, x, y) v[x].pb(y); v[y].pb(x);
#define popcount __builtin_popcount
#define ANS(s) {cout << s << "\n"; return;}
#define printpii(a) cout << a.ft << " " << a.sd << endl;
#define printpiii(a) cout << a.ft << " " << a.sd.ft << " " << a.sd.sd << endl;
#define print(a, n) rep(i, n) cout << a[i] << " "; cout << endl;
#define printv(v) for(auto x: v)cout << x << " "; cout << endl;
#define printm(a, n, m) rep(i, n) { rep(j, m) cout << a[i][j] << "\t"; cout << endl;}
ll dx[4] = {0, 0, 1, -1};
ll dy[4] = {1, -1, 0, 0};
void fast(){ios_base::sync_with_stdio(false);cin.tie(0);cout << setprecision(12) << fixed;}
void solve(){
ll n;
cin >> n;
ll a[n+1];
ll l = 1, ans = 1;
rep(i, n)
{
cin >> a[i+1];
}
for(ll i = 2; i <= n; i++){
if(a[i] <= a[i-1]){
l++; ans = max(l, ans);
}
else l = 1;
}
cout << ans-1;
}
main(){
fast();
ll t = 1;
while(t--){
solve();
}
}
| 0
| 76,455,850
|
#include <algorithm>
#include <climits>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
long H, W, ans = LONG_MAX;
cin >> H >> W;
for (long i = 1; i < H; i++) {
long a = LONG_MAX;
pair<long, long> h1(i, H - i);
pair<long, long> h2(h1.first / 2, h1.first - h1.first / 2);
pair<long, long> h3(h1.second / 2, h1.second - h1.second / 2);
pair<long, long> w(W / 2, W - W / 2);
vector<long> s;
s.push_back(h1.first * W);
s.push_back(h1.second * w.first);
s.push_back(h1.second * w.second);
if (none_of(s.begin(), s.end(), [](long& a) { return !a; })) {
a = min(*max_element(s.begin(), s.end()) - *min_element(s.begin(), s.end()), a);
}
s.clear();
s.push_back(h1.first * w.first);
s.push_back(h1.first * w.second);
s.push_back(h1.second * W);
if (none_of(s.begin(), s.end(), [](long& a) { return !a; })) {
a = min(*max_element(s.begin(), s.end()) - *min_element(s.begin(), s.end()), a);
}
s.clear();
s.push_back(h1.first * W);
s.push_back(h3.first * W);
s.push_back(h3.second * W);
if (none_of(s.begin(), s.end(), [](long& a) { return !a; })) {
a = min(*max_element(s.begin(), s.end()) - *min_element(s.begin(), s.end()), a);
}
s.clear();
s.push_back(h2.first * W);
s.push_back(h2.second * W);
s.push_back(h1.second * W);
if (none_of(s.begin(), s.end(), [](long& a) { return !a; })) {
a = min(*max_element(s.begin(), s.end()) - *min_element(s.begin(), s.end()), a);
}
ans = min(a, ans);
}
for (long i = 1; i < W; i++) {
long a = LONG_MAX;
pair<long, long> h(H / 2, H - H / 2);
pair<long, long> w1(i, W - i);
pair<long, long> w2(w1.first / 2, w1.first - w1.first / 2);
pair<long, long> w3(w1.second / 2, w1.second - w1.second / 2);
vector<long> s;
s.push_back(H * w1.first);
s.push_back(h.first * w1.second);
s.push_back(h.second * w1.second);
if (none_of(s.begin(), s.end(), [](long& a) { return !a; })) {
a = min(*max_element(s.begin(), s.end()) - *min_element(s.begin(), s.end()), a);
}
s.clear();
s.push_back(h.first * w1.first);
s.push_back(h.second * w1.first);
s.push_back(H * w1.second);
if (none_of(s.begin(), s.end(), [](long& a) { return !a; })) {
a = min(*max_element(s.begin(), s.end()) - *min_element(s.begin(), s.end()), a);
}
s.clear();
s.push_back(H * w1.first);
s.push_back(H * w3.first);
s.push_back(H * w3.second);
if (none_of(s.begin(), s.end(), [](long& a) { return !a; })) {
a = min(*max_element(s.begin(), s.end()) - *min_element(s.begin(), s.end()), a);
}
s.clear();
s.push_back(H * w2.first);
s.push_back(H * w2.second);
s.push_back(H * w1.second);
if (none_of(s.begin(), s.end(), [](long& a) { return !a; })) {
a = min(*max_element(s.begin(), s.end()) - *min_element(s.begin(), s.end()), a);
}
ans = min(a, ans);
}
cout << ans;
}
|
#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <set>
#include <queue>
#define fi first
#define se second
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
#define int long long
const int N=300010,Mod=1e9+7;
LL n,m,x,tot;
LL nums[N],n2[N];
int vis[N];
signed main(){
IOS;
cin>>n>>x>>m;
int l,r;
for(int i=1;;++i){
if(vis[x]) {
l=vis[x],r=i-1;
break;
}
nums[++tot]=x;
vis[x]=i;
x=x*x%m;
}
for(int i=1,j=l;j<=r;++j,++i){
n2[i]=nums[j];
}
for(int i=1;i<=tot;++i) nums[i]+=nums[i-1];
LL sum=nums[l-1];
int len=r-l+1;
n-=l-1;
for(int i=1;i<=len;++i) n2[i]+=n2[i-1];
sum=sum+n/len*n2[len]+n2[n%len];
cout<<sum<<endl;
return 0;
}
| 0
| 38,483,636
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define drep(i,n) for(int i = (n-1); i >= 0; i--)
#define all(v) (v).begin(),(v).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> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <class T> T lcm(T a, T b) { return a/gcd(a,b)*b; }
typedef pair<int, int> P;
typedef long long ll;
const int INF = 1001001001;
const ll LINF = 1001002003004005006ll;
const ll MOD = 1e9+7;
const int MAXN = 100005;
int n, v, p;
ll m;
vector<ll> a(MAXN);
bool ok(int t) {
if(t<=p) return true;
if(a[p-1]>a[t-1]+m) return false;
if(n-t+p >= v) return true;
ll add = (v-(n-t+p)) * m;
ll mxt = a[t-1] + m;
ll tmp = 0;
for (int i = p-1; i < t-1; i++) {
tmp += mxt - a[i];
if (tmp >= add) return true;
}
return false;
}
int main() {
cin >> n >> m >> v >> p;
rep(i,n) cin >> a[i];
sort(a.begin(), a.end(), greater<ll>());
ll ans;
ll start = 1, end = n+1;
while (start + 1 < end) {
ans = (start + end) / 2;
if (ok(ans)) start = ans;
else end = ans;
}
ans = (start + end) / 2;
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#include<set>
#include<bitset>
#include<map>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#define INF 1000000007
#define inf 100000000000000000
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
int n,t,d[15][15],cost,x,y,k,i,j;
int main()
{
while(scanf("%d",&n)!=EOF&&n!=0)
{
memset(d,INF,sizeof(d));t=0;
P mi;mi.second=INF;
for(i=0;i<n;i++)
{
scanf("%d%d%d",&x,&y,&cost);
d[x][y]=d[y][x]=cost;
t=max(t,max(x,y));
}
for(i=0;i<=t;i++)d[i][i]=0;
for(k=0;k<=t;k++)
{
for(i=0;i<=t;i++)
{
for(j=0;j<=t;j++)d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
}
}
for(i=0;i<=t;i++)
{
P p;p.first=i;p.second=0;
for(j=0;j<=t;j++)
{
if(i==j)continue;
p.second+=d[i][j];
}
if(mi.second>p.second)mi=p;
}
printf("%d %d\n",mi.first,mi.second);
}
return 0;
}
| 0
| 40,936,808
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(ll i = 0; i < (ll)(n); i++)
#define rep2(i, a, n) for(ll i = a; i < (ll)(n); i++)
#define memi cout << endl
#define kono(n) cout << fixed << setprecision(n)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define hina cout << ' '
#define in(n) cin >> n
#define in2(n, m) cin >> n >> m
#define in3(n, m, l) cin >> n >> m >> l
#define out(n) cout << n
const ll mei = (ll)1e9 + 7;
int main(){
ll n, a, b;
in(n);
a = 0;
vector<ll> c(n + 2, 0), d(n + 1), e(n);
rep(i, n){
in(c[i + 1]);
}
rep(i, n + 1)
d[i] = abs(c[i + 1] - c[i]);
rep(i, n){
e[i] = abs(c[i + 2] - c[i]);
}
rep(i, n + 1){
a = a + d[i];
}
rep(i, n){
b = a - d[i] - d[i + 1] + e[i];
out(b);
memi;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
long long int N,ren=1,ans=0;
cin >> N;
vector<long long int> A(N),sum(N+1);
sum[0] = 0;
for(int i=0;i<N;i++){
cin >> A[i];
sum[i+1] = sum[i] + A[i];
}
sort(sum.begin(),sum.end());
for(int i=1;i<=N;i++){
if(sum[i]==sum[i-1]){
ren++;
}else{
ans += ren*(ren-1)/2;
ren = 1;
}
}
ans += ren*(ren-1)/2;
cout << ans << endl;
}
| 0
| 29,552,491
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pint = pair<int, int>;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const int INF=1e9+7;
const ll LINF=9223372036854775807;
const ll MOD=1e9+7;
const ld PI=acos(-1);
const ld EPS = 1e-9;
struct mint {
int n;
mint(int n_ = 0) : n(n_) {}
};
mint operator+(mint a, mint b) { a.n += b.n; if (a.n >= MOD) a.n -= MOD; return a; }
mint operator-(mint a, mint b) { a.n -= b.n; if (a.n < 0) a.n += MOD; return a; }
mint operator*(mint a, mint b) { return (long long)a.n * b.n % MOD; }
mint &operator+=(mint &a, mint b) { return a = a + b; }
mint &operator-=(mint &a, mint b) { return a = a - b; }
mint &operator*=(mint &a, mint b) { return a = a * b; }
int ii() { int x; scanf("%d", &x); return x; }
long long il() { long long x; scanf("%lld", &x); return x; }
string is() { string x; cin >> x; return x; }
char ic() { char x; cin >> x; return x; }
void oi(int x) { printf("%d ", x); }
void ol(long long x) { printf("%lld ", x); }
void od_nosp(double x) { printf("%.15f", x); }
void od(double x) { printf("%.15f ", x); }
void os(const string &s) { printf("%s ", s.c_str()); }
void oc(const char &c) { printf("%c ", c); }
#define o_map(v){cerr << #v << endl; for(const auto& xxx: v){cout << xxx.first << " " << xxx.second << "\n";}}
void br() { putchar('\n'); }
#define gcd __gcd
int lcm(int a, int b){return a / gcd(a, b) * b;}
#define ALL(a) a.begin(),a.end()
#define REP(i,m,n) for(ll i=(ll)(m) ; i < (ll) (n) ; i++ )
#define rep(i,n) REP(i,0,n)
#define MP(a,b) make_pair(a,b)
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define PB push_back
#define SZ(x) ((int)(x).size)
vector<int> dx_4 = {1, 0, -1, 0};
vector<int> dy_4 = {0, 1, 0, -1};
template<typename T1, typename T2> ostream& operator<<(ostream& s, const pair<T1, T2>& p) {return s << "(" << p.first << " " << p.second << ")";}
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v) {
int len = v.size();
for (int i = 0; i < len; ++i) {
s << v[i]; if (i < len - 1) s << " ";
}
return s;
}
template<typename T> ostream& operator<<(ostream& s, const vector< vector<T> >& vv) {
int len = vv.size();
for (int i = 0; i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
template<typename T>
bool chmax(T& a, T b){return (a = max(a, b)) == b;}
template<typename T>
bool chmin(T& a, T b){return (a = min(a, b)) == b;}
int main(){
ll n, m;
cin >> n >> m;
set<ll> from1;
set<ll> ton;
rep(i, m){
ll f = il();
ll t = il();
if (f == 1) from1.insert(t);
if (t == n) ton.insert(f);
}
for ( auto f : from1 ){
if (ton.find(f) != ton.end()){
cout << "POSSIBLE" << endl;
return (0);
}
}
cout << "IMPOSSIBLE" << endl;
}
|
#include <iostream>
#include <vector>
using namespace std;
int main() {
int h, w, k;
cin >> h >> w >> k;
vector<string> s(h);
int ans = 0;
for (int i = 0; i < h; i++) cin >> s[i];
for (int i = 0; i < (1<<h); i++) {
for (int j = 0; j < (1<<w); j++) {
int count = 0;
for (int x = 0; x < h; x++) {
for (int y = 0; y < w; y++) {
if (i>>x & 1) continue;
if (j>>y & 1) continue;
if (s[x][y] == '#') count++;
}
}
if (count == k) ans++;
}
}
cout << ans << endl;
return 0;
}
| 0
| 9,236,117
|
#include <iostream>
using namespace std;
int main()
{
int n;
cin >> n;
int res = n;
for (int i = 0; i <= n; i++)
{
int cnt = 0;
int t = i;
while (t > 0)
cnt += t % 6, t /= 6;
t = n - i;
while (t > 0)
{
cnt += t % 9, t /= 9;
}
if (res > cnt)
{
res = cnt;
}
}
cout << res << endl;
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <stack>
#include <deque>
#include <queue>
#include <set>
#include <cmath>
#include <algorithm>
#include <map>
#include <list>
using namespace std;
#define FOR( i, k, n ) for ( int i = ( k ); i < ( int )( n ); ++i )
#define REP( i, n ) FOR( i, 0, n )
typedef long long ll;
typedef pair< int, int > P;
#define MAX_S 32
bool IsRight( char );
int main()
{
while( 1 ) {
char str[ MAX_S + 1 ];
cin >> str;
if( str[ 0 ] == '#' ) break;
int ans = 0;
bool hand = IsRight( str[ 0 ] );
for( int i = 1; str[ i ] != '\0'; ++i ) {
if( hand != IsRight( str[ i ] ) ) {
hand = IsRight( str[ i ] );
++ans;
}
}
cout << ans << endl;
}
return 0;
}
bool IsRight( char key ) {
const char rights[ 11 ] = { 'y', 'u', 'i', 'o', 'p', 'h', 'j', 'k', 'l', 'n', 'm' };
REP( i, 11 ) if( key == rights[ i ] ) { return true; }
return false;
}
| 0
| 89,521,139
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N);
for (int i = 0; i < N; i++){
cin >> A.at(i);
}
vector<long long> Acnt(N+1,0);
for(auto x: A){
Acnt.at(x)++;
}
long long s=0;
for (int i = 1; i < N+1; i++){
if(Acnt.at(i)!=0){
s=s+Acnt.at(i)*(Acnt.at(i)-1)/2;
}
}
for (auto Ak: A){
long long ans=s-Acnt.at(Ak)+1;
printf("%lld\n",ans);
}
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long
#define itn int
#define endl '\n'
#define co(ans) cout<<ans<<endl
#define COYE cout<<"YES"<<endl
#define COYe cout<<"Yes"<<endl
#define COye cout<<"yes"<<endl
#define CONO cout<<"NO"<<endl
#define CONo cout<<"No"<<endl
#define COno cout<<"no"<<endl
#define FORE(i,a) for(auto &i:a)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define FFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) FFOR(i,1,n)
#define PB push_back
#define MP make_pair
#define ALL(V) (V).begin(),(V).end()
#define SORT(V) sort((V).begin(),(V).end())
#define REVERSE(V) reverse((V).begin(),(V).end())
#define EACH(V,i) for(typeof((V).begin()) i=(V).begin();i!=(V).end();++i)
#define equals(a,b) (fabs((a)-(b))<EPS)
#define INF ((1LL<<62)-(1LL<<31))
#define EPS 1e-10
#define PI 3.141592653589793238
#define MOD 1000000007
#define MAX 5100000
using namespace std;
using Edge=pair<int,int>;
using Graph=vector<vector<int>>;
inline int toInt(string s){int v;istringstream sin(s);sin>>v;return v;}
template<class T>inline string toString(T x){ostringstream sout;sout<<x;return sout.str();}
template<class T>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;}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
const int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
int main(){
ll N,M,ans=0;
cin>>N>>M;
vector<pair<ll,ll>> L;
REP(i,N){
ll a,b;
cin>>a>>b;
L.PB(MP(b,a));
}
SORT(L);
REVERSE(L);
set<ll> S={-INF};
ll ANS[M];
REP(i,M){
S.insert(i);
ANS[i]=0;
}
S.insert(INF);
REP(i,N){
auto itr=S.upper_bound(M-L[i].second);
ll index=*(--itr);
if(index==-INF) continue;
ANS[index]=L[i].first;
S.erase(index);
}
REP(i,M) ans+=ANS[i];
co(ans);
return 0;
}
| 0
| 17,576,753
|
#include <bits/stdc++.h>
#define REP(i, n) for(long long i=0; i<n; i++)
#define REPR(i, n) for(long long i=n-1; i>=0; i--)
#define FOR(i, m, n) for(long long i=m; i<=n; i++)
#define FORR(i, m, n) for(long long i=m; i>=n; i--)
#define SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define VSORTR(v) sort(v.rbegin(), v.rend());
#define ALL(v) (v).begin(),(v).end()
#define FIN ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<ll, ll>;
const ll mod = 1e9+7;
const ll inf = 1e15;
int main(){FIN
ll n,m;cin>>n>>m;
vll a(n);
REP(i,n) cin>>a[i];
vll rui(n+1,0);
ll sum=0;
REP(i,n){
sum += a[i];
rui[i+1] = sum % m;
}
map<ll,ll> mp;
REP(i,n+1) mp[rui[i]]++;
ll ans=0;
for(auto p:mp){
ans += p.second * (p.second-1) /2;
}
cout<<ans<<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++)
int main(){
int w,h,n;
cin>>w>>h>>n;
bool grid[h][w];
rep(hi,h)rep(wi,w){
grid[hi][wi]=0;
}
rep(i,n){
int x, y, a;
cin>>x>>y>>a;
if(a==1){
x--;
for(int wi=x; wi>=0; wi--){
rep(hi,h){
grid[hi][wi]=1;
}
}
}
if(a==2){
for(int wi=x; wi<w; wi++){
rep(hi,h){
grid[hi][wi]=1;
}
}
}
if(a==3){
y--;
for(int hi=y; hi>=0; hi--){
rep(wi,w){
grid[hi][wi]=1;
}
}
}
if(a==4){
for(int hi=y; hi<h; hi++){
rep(wi,w){
grid[hi][wi]=1;
}
}
}
}
int ans=0;
rep(hi,h)rep(wi,w){
if(!grid[hi][wi]) ans++;
}
cout<<ans<<endl;
}
| 0
| 41,691,064
|
#include <iostream>
#include <cstdio>
#include <cstring>
#define N 100005
using namespace std;
struct edge{
int k,next;
}e[N<<1];
int n,home[N],cnt=-1,f[N];
void add(int x,int y){
cnt++;
e[cnt].k=y;
e[cnt].next=home[x];
home[x]=cnt;
}
void dfs(int k,int F){
for(int i=home[k];~i;i=e[i].next) if(e[i].k!=F){
dfs(e[i].k,k);
f[k]^=f[e[i].k]+1;
}
}
int main(){
memset(home,-1,sizeof(home));
scanf("%d",&n);
for(int i=1,x,y;i<n;i++){
scanf("%d%d",&x,&y);
add(x,y);add(y,x);
}
dfs(1,0);
if(f[1]) puts("Alice");
else puts("Bob");
return 0;
}
|
#include <bits/stdc++.h>
#include <cmath>
const double PI = 3.14159265358979323846;
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef pair<ll, ll> P;
const ll INF = 1e15;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
std::istream &operator>>(std::istream &in, set<int> &o) {
ll a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
const int mod = 1000000007;
typedef priority_queue<string, vector<string>, greater<string> > PQ_ASK;
struct Happy {
ll takahashi, aoki, takahashi_value;
};
int main() {
int n;
cin >> n;
vector<Happy> happiness(n);
rep(i, n) cin >> happiness[i].takahashi >> happiness[i].aoki;
rep(i, n) happiness[i].takahashi_value = happiness[i].takahashi + happiness[i].aoki;
sort(happiness.rbegin(), happiness.rend(), [](Happy &h, Happy &i) {
return h.takahashi_value < i.takahashi_value;
});
ll takahashi = 0, aoki = 0;
rep(i, n) {
if (i % 2 == 0) {
takahashi += happiness[i].takahashi;
} else {
aoki += happiness[i].aoki;
}
}
cout << takahashi - aoki << endl;
}
| 0
| 11,851,970
|
#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 all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define INF 2e9
#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; }
typedef long long ll;
typedef pair<int, int> P;
int dx[4] = {1,0,-1,0};
int dy[4] = {0,1,0,-1};
int main() {
int n; cin >> n;
set<int> st;
rep(i,n) {
int a; cin >> a;
st.insert(a);
}
if (sz(st) == n) cout << "YES" << endl;
else cout << "NO" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int64_t n,m;
cin >> n >> m;
int64_t h[n+1];
for(int i = 1; i <= n; i++){
cin >> h[i];
}
int64_t a[m+1],b[m+1];
for(int i = 1; i <= m; i++){
cin >> a[i] >> b[i];
}
int peek[n+1];
for(int i = 1; i <= n; i++){
peek[i] = 1;
}
for(int i = 1; i <= m; i++){
if(h[a[i]] > h[b[i]]){
peek[a[i]] *= 1;
peek[b[i]] = 0;
}else if(h[a[i]] == h[b[i]]){
peek[a[i]] = 0;
peek[b[i]] = 0;
}else{
peek[a[i]] = 0;
peek[b[i]] *= 1;
}
}
int ans = 0;
for(int i = 1; i <= n; i++){
if(peek[i] == 1){
ans++;
}
}
cout << ans << endl;
}
| 0
| 96,399,059
|
#include <bits/stdc++.h>
#define pb push_back
#define Int long long
using namespace std;
const int MAXN=500005;
const long MOD=(long)(1e9+7);
vector<int> adj[MAXN];
vector<pair<int,int>> G[MAXN];
Int N,M,K;
Int B,C,H,W;
Int X,Y,Z;
vector<Int> A;
Int ceilS(Int x,Int y){
return (x+y-1)/y;
}
using D=long double;
Int perform(Int x){
return (x*(x+1))/2LL;
}
int main()
{
cin>>N;
A.resize(N);
for(auto &x:A) cin>>x;
vector<Int> dp(N);
dp[0]=0; dp[1]=abs(A[1]-A[0]);
for(int i=2;i<N;++i){
dp[i]=min(dp[i-1]+abs(A[i]-A[i-1]),dp[i-2]+abs(A[i]-A[i-2]));
}
cout<<dp[N-1]<<"\n";
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M, X, Y;
cin >> N >> M >> X >> Y;
vector<int> x(N);
vector<int> y(M);
for(int i = 0; i < N; i++) {
cin >> x[i];
}
for(int i = 0; i < M; i++) {
cin >> y[i];
}
int mx = *max_element(x.begin(), x.end());
int my = *min_element(y.begin(), y.end());
if(X < Y && X < my && mx < Y && mx < my) {
cout << "No War" << endl;
return 0;
}
cout << "War" << endl;
}
| 0
| 25,050,888
|
#include <iostream>
using namespace std;
int main(){
int n, x;
int y = 0;
while(1){
cin >> n >> x;
if(n == 0 && x == 0)
break;
for(int a=1; a<=n; a++){
for(int b=2; b<=n; b++){
for(int c=3; c<=n; c++){
if(a+b+c == x && a < b && b < c)
y++;
}
}
}
cout << y << endl;
y = 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,r) for(int i = 0; i < (r); i++)
#define pb push_back
#define ALL(a) a.begin(), a.end()
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define int long long
#define uint unsigned long long
#define endl '\n'
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec){ os << "["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const map<T,T> &vec){ os<< "{"; for (auto p : vec) os << "(" << p.first << "," << p.second << "), "; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_map<T,T>&vec){ os<< "{"; for (auto p : vec) os << "(" << p.first << "," << p.second << "), "; os << "}"; return os; }
string n;
int k;
int dp[110][2][5];
int solve(int i, int flag, int n0) {
if (n0 > k) return 0;
if (i == n.size()) {
return (n0 == k);
}
int& res = dp[i][flag][n0];
if (res != -1) return res;
res = 0;
int maxi = flag ? n[i] - '0' : 9;
for (int idx = 0; idx <= maxi; idx++) {
res += solve(i + 1, flag && (idx == maxi), n0 + (idx != 0));
}
return res;
}
signed main() {
fastio;
cin >> n >> k;
memset(dp, -1, sizeof(dp));
cout << solve(0, 1, 0) << endl;
}
| 0
| 92,677,022
|
#include <iostream>
#include <string>
#include <queue>
#include <vector>
#include <algorithm>
#include <math.h>
#include <map>
#include <iomanip>
#include <queue>
#include <numeric>
using namespace std;
long long int combination2(long long int c);
int main() {
long long int N, sum = 0;
cin >> N;
vector<long long int>A(N), B(N + 1), C(N + 1);
for (int i = 0; i < N; i++) {
cin >> A[i];
B[i] = 0;
C[i] = 0;
}
for (int i = 0; i < N; i++) {
B[A[i]] ++;
}
for (int i = 0; i <= N; i++) {
sum += combination2(B[i]);
}
for (int i = 0; i < N; i++) {
if (C[A[i]] == 0) {
C[A[i]] = sum - B[A[i]] + 1;
cout << C[A[i]] << "\n";
}
else {
cout << C[A[i]] << "\n";
}
}
return 0;
}
long long int combination2(long long int c) {
long long int ans;
ans = c * (c - 1) / 2;
return ans;
}
|
#include <bits/stdc++.h>
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
long long h, w;
long long sa, sb, sc;
long long sb2, sc2;
long long smin(long long H, long long W, long long S) {
long long rans = 1e12;
for(int i = 0; i <= H; ++i) {
vector<long long> ss;
vector<long long> ss2;
sa = i*W;
if((H-i) % 2 == 0 || W % 2 == 0) {
sb = sc = (S-sa) / 2;
sb2 = sc2 = (S-sa) / 2;
}else {
sb = (H-i)/2 * W;
sc = S - sa - sb;
sb2 = (H-i) * (W/2);
sc2 = S - sa - sb2;
}
ss.push_back(sa); ss.push_back(sb); ss.push_back(sc);
ss2.push_back(sa); ss2.push_back(sb2); ss2.push_back(sc2);
sort(ss.begin(), ss.end());
sort(ss2.begin(), ss2.end());
chmin(rans, ss.at(2)-ss.at(0));
chmin(rans, ss2.at(2)-ss2.at(0));
}
return rans;
}
int main() {
cin >> h >> w;
long long s = h * w;
long long sa, sb, sc;
long long ans = 1e12;
if(h % 3 == 0 || w % 3 == 0) {
cout << 0 << endl;
}else {
if(h == w) {
cout << smin(h, w, s) << endl;
}else {
cout << min(smin(h, w, s), smin(w, h, s)) << endl;
}
}
}
| 0
| 22,535,156
|
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ArraySizeOf(array) (sizeof(array) / sizeof(array[0]))
#define res(i,n) for(int i=n;;i++)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define rev(i,n) for(int i=n-1;i>=0;i--)
#define REV(i,n) for(int i=n-1;i>0;i--)
#define req(i,n,m) for(int i=n;i<m;i++)
#define REQ(i,n,m,l) for(int i=n;i<m;i+=l)
#define _GLIBCXX_DEBUG
int INF = 1e9 + 7;
int mod = 998244353;
long double PI = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998626034825342117;
unsigned NthDayOfWeekToDay(unsigned n, unsigned dow, unsigned dow1)
{
unsigned day;
if (dow < dow1) dow += 7;
day = dow - dow1;
day += 7 * n - 6;
return day;
}
signed gcd(long long x, long long y) {
if (y == 0)return x;
return gcd(y, x % y);
}
signed lcm(long long x, long long y) {
return x / gcd(x, y) * y;
}
unsigned DayToWeekNumber(unsigned day)
{
return (day - 1) / 7 + 1;
}
unsigned AnotherDayOfWeek(unsigned day, unsigned day0, unsigned dow0)
{
return (dow0 + 35 + day - day0) % 7;
}
#define int long long
using namespace std;
signed ae(long long b, long long c) {
if (c == 1)return b;
return (ae(b, c - 1)*b)%mod;
}
signed main() {
int N; cin >> N;
vector<long long>D(N);
vector<long long>count(N);
long long A = 0;
rep(i, N) {
cin >> D[i];
count[D[i]]++;
A = max(A, D[i]);
}
if (count[0] != 1||D[0]!=0) { puts ("0"); return 0; }
long long ans = 1;
REP(i, A + 1) {
if (count[i] == 0) { puts("0"); return 0; }
ans *= ae(count[i-1],count[i]);
ans %= mod;
}
cout <<ans << endl;
}
|
#include <bits/stdc++.h>
#define ui unsigned int
#define ll long long
#define ul unsigned ll
#define ld long double
#define pi pair <int, int>
#define fi first
#define se second
#define mp make_pair
#define ls (p << 1)
#define rs (ls | 1)
#define md ((t[p].l + t[p].r) >> 1)
#define vi vector <int>
#define pb push_back
#define pq priority_queue
#define dbg(x) cerr << #x" = " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define fl(x) freopen(x".in", "r", stdin), freopen(x".out", "w", stdout)
using namespace std;
namespace io {
const int SI = 1 << 21 | 1;
char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100];
int f, t;
#define gc() (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)
inline void flush() {
fwrite(OB, 1, OS - OB, stdout), OS = OB;
}
inline void pc(char x) {
*OS++ = x;
if (OS == OT) flush();
}
template <class I>
inline void rd(I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + (c & 15), c = gc());
x *= f;
}
template <class I>
inline void rd(I &x, I &y) {
rd(x), rd(y);
}
template <class I>
inline void rd(I &x, I &y, I &z) {
rd(x), rd(y), rd(z);
}
template <class I>
inline void rda(I *a, int n) {
for (int i = 1; i <= n; i++) rd(a[i]);
}
inline void rdc(char &c) {
for (c = gc(); c < 33 || c > 126; c = gc());
}
inline void rds(char *s, int &n) {
for (c = gc(); c < 33 || c > 126; c = gc());
for (n = 0; c >= 33 && c <= 126; s[++n] = c, c = gc());
s[n+1] = '\0';
}
inline void rds(string &s) {
for (c = gc(); c < 33 || c > 126; c = gc());
for (s.clear(); c >= 33 && c <= 126; s.pb(c), c = gc());
}
template <class I>
inline void print(I x, char k = '\n') {
if (!x) pc('0');
if (x < 0) pc('-'), x = -x;
while (x) ch[++t] = x % 10 + '0', x /= 10;
while (t) pc(ch[t--]);
pc(k);
}
template <class I>
inline void print(I x, I y) {
print(x, ' '), print(y);
}
template <class I>
inline void print(I x, I y, I z) {
print(x, ' '), print(y, ' '), print(z);
}
template <class I>
inline void printa(I *a, int n) {
for (int i = 1; i <= n; i++) print(a[i], " \n"[i==n]);
}
inline void printc(char c) {
pc(c);
}
inline void prints(char *s, int n) {
for (int i = 1; i <= n; i++) pc(s[i]);
pc('\n');
}
inline void prints(string s) {
int n = s.length();
while (t < n) pc(s[t++]);
pc('\n'), t = 0;
}
struct Flush {
~Flush() {
flush();
}
} flusher;
}
using io::rd;
using io::rda;
using io::rdc;
using io::rds;
using io::print;
using io::printa;
using io::printc;
using io::prints;
const int N = 2e5 + 7, M = 31;
int n, a[N], p[N], c[N], s[N], t;
inline void add(int x, int k) {
if (x == p[t]) c[t] += k, s[t] += k;
else p[++t] = x, c[t] = k, s[t] = c[t] + s[t-1];
}
inline bool add1(int m) {
if (t == 1 && p[t] == m) return 0;
if (p[t] != m) {
if (c[t] == 1) --t, add(p[t+1] + 1, 1);
else --c[t], --s[t], add(p[t] + 1, 1);
} else {
int k = c[t--];
if (c[t] == 1) --t, add(p[t+1] + 1, 1);
else --c[t], --s[t], add(p[t] + 1, 1);
add(1, k);
}
return 1;
}
inline bool pd(int m) {
t = 0, add(1, a[1]);
for (int i = 2; i <= n; i++)
if (a[i] > a[i-1]) add(1, a[i] - a[i-1]);
else {
while (s[t] > a[i]) --t;
if (s[t] < a[i]) add(p[t+1], a[i] - s[t]);
if (!add1(m)) return 0;
}
return 1;
}
int main() {
rd(n), rda(a, n);
int l = 1, r = n;
while (l < r) {
int d = (l + r) >> 1;
if (pd(d)) r = d;
else l = d + 1;
}
print(l);
return 0;
}
| 0
| 44,657,218
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <climits>
#include <ctime>
#include <numeric>
#include <vector>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <complex>
#include <deque>
#include <functional>
#include <list>
#include <map>
#include <string>
#include <sstream>
#include <set>
#include <stack>
#include <queue>
using namespace std;
template<class T> inline T sqr(T x)
{
return x * x;
}
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int, int> PII;
typedef pair<PII, int> PIII;
typedef pair<LL, LL> PLL;
typedef pair<LL, int> PLI;
typedef pair<LD, LD> PDD;
#define MP make_pair
#define PB push_back
#define sz(x) ((int)(x).size())
#define clr(ar,val) memset(ar, val, sizeof(ar))
#define istr stringstream
#define FOR(i,n) for(int i=0;i<(n);++i)
#define forIt(mp,it) for(__typeof(mp.begin()) it = mp.begin();it!=mp.end();it++)
const double EPS = 1e-6;
const int INF = 0x3fffffff;
const LL LINF = INF * 1ll * INF;
const double PI = acos(-1.0);
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define lowbit(u) (u&(-u))
#define MAXN 105
int g[MAXN][MAXN];
bool vis[MAXN];
int step[MAXN];
int n;
void bfs(int x)
{
vis[x]=true;
queue <int> q;
step[x]=0;
q.push(x);
while(!q.empty())
{
int u=q.front();
q.pop();
for(int v=1; v<=n; v++)
{
if(g[u][v] && !vis[v])
{
vis[v]=true;
step[v]=step[u]+1;
q.push(v);
}
}
}
}
int main()
{
scanf("%d",&n);
for(int i=0; i<n; i++)
{
int u,num;
scanf("%d%d",&u,&num);
while(num--)
{
int v;
scanf("%d",&v);
g[u][v]=1;
}
}
bfs(1);
for(int i=1; i<=n; i++)
{
if(!vis[i])
step[i]=-1;
}
for(int i=1; i<=n; i++)
printf("%d %d\n",i,step[i]);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF=1e+9;
const int MOD=1e+9+7;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define REP2(i,a,b) for(ll i=a;i<(ll)(b);i++)
#define REPD2(i,a,b) for(ll i=a;i>(ll)(b);i--)
template<class T>
vector<T> make_vec(size_t a){
return vector<T>(a);
}
template<class T, class... Ts>
auto make_vec(size_t a, Ts... ts){
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
int main(){
ll N,M;
cin>>N>>M;
if(N==1){
if(M==1){
cout<<1<<endl;
}else{
cout<<(M-2)<<endl;
}
}else if(M==1){
cout<<(N-2)<<endl;
}else{
cout<<(N*M-2*(N+M-2))<<endl;
}
}
| 0
| 68,354,594
|
#include <bits/stdc++.h>
using namespace std;
int main(void)
{
int a=0, b=0;
cin >> a >> b;
cout << (a+b-1)/2+1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
#define ll long long int
#define mod 1000000007
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define prec(n) fixed << setprecision(n)
#define maxpq priority_queue<int>
#define minpq priority_queue<int, vector<int>, greater<int>>
#define PI 3.1415926535897932384626
#define bits(n) __builtin_popcount(n)
bool snuck[101];
void solve()
{
memset(snuck,false,sizeof(snuck));
int n,k;
cin>>n>>k;
for(int i=0;i<k;i++)
{
int d;
cin>>d;
for(int j=0;j<d;j++)
{
int a;
cin>>a;
snuck[a]=true;
}
}
int c=0;
for(int i=1;i<=n;i++)
{
if(!snuck[i])
c++;
}
cout<<c;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input1.txt", "r", stdin);
freopen("output1.txt", "w", stdout);
#endif
int t = 1;
while (t--)
{
solve();
}
return 0;
}
| 0
| 88,882,904
|
#include<bits/stdc++.h>
using namespace std;
#define maxn 1e18
long long a[100005],b[250],len,c[250];
int main(){
int n;
cin>>n;
for(int i=0;i<n;i++)
{
cin>>a[i];
}
for(int i=0;i<n;i++)
{
if(a[i]==0)
{
cout<<"0"<<endl;
return 0;
}
}
long long sum=1;
for(int i=0;i<n;i++)
{
if(a[i]<=1000000000000000000/sum)
{
sum*=a[i];
}
else
{
cout<<"-1"<<endl;
return 0;
}
}
cout<<sum<<endl;
}
|
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
vector<ll> l, p;
ll func(ll n, ll x) {
if (n == 0)
return x;
if (x <= 1)
return 0;
else if (1 < x && x <= l[n-1]+1)
return func(n-1, x-1);
else if (x == l[n-1]+2)
return p[n-1] + 1;
else if (l[n-1]+2 < x && x <= 2*l[n-1]+2)
return p[n-1] + func(n-1, x-l[n-1]-2) + 1;
else
return 2*p[n-1] + 1;
}
int main() {
ll n, x; cin >> n >> x;
l.resize(51, 1);
p.resize(51, 1);
for (int i = 0; i < 50; i++) {
l[i+1] = 2*l[i]+3;
p[i+1] = 2*p[i]+1;
}
cout << func(n, x) << endl;
return 0;
}
| 0
| 81,925,413
|
#include<iostream>
#include<iomanip>
#include<cmath>
using namespace std;
const double pi = 3.141592653589793;
struct Cordinate{
double x;
double y;
};
void kock( int n, Cordinate p1, Cordinate p2 ){
if( n==0 ){
return;
}
Cordinate s, t, u;
s.x = (2*p1.x+1*p2.x)/3;
s.y = (2*p1.y+1*p2.y)/3;
t.x = (1*p1.x+2*p2.x)/3;
t.y = (1*p1.y+2*p2.y)/3;
u.x = (t.x-s.x)*cos(pi/3)-(t.y-s.y)*sin(pi/3)+s.x;
u.y = (t.x-s.x)*sin(pi/3)+(t.y-s.y)*cos(pi/3)+s.y;
kock( n-1, p1, s );
cout << fixed << setprecision(8) << s.x << " " << setprecision(8) << s.y << endl;
kock( n-1, s, u );
cout << fixed << setprecision(8) << u.x << " " << setprecision(8) << u.y << endl;
kock( n-1, u, t );
cout << fixed << setprecision(8) << t.x << " " << setprecision(8) << t.y << endl;
kock( n-1, t, p2 );
}
int main(){
int n;
cin >> n;
Cordinate p1, p2;
p1.x = 0, p1.y = 0;
p2.x = 100, p2.y = 0;
cout << fixed << setprecision(8) << p1.x << " " << setprecision(8) << p1.y << endl;
kock( n, p1, p2 );
cout << fixed << setprecision(8) << p2.x << " " << setprecision(8) << p2.y << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,t;
cin>>n>>t;
int a[n];
for(int i=0;i<n;i++)
cin>>a[i];
int ans=0;
for(int i=1;i<n;i++)
{
if((a[i]-a[i-1])>=t)
ans+=t;
else
ans+=a[i]-a[i-1];
}
ans+=t;
cout<<ans<<endl;
}
| 0
| 35,938,123
|
#include<iostream>
#include<cstdio>
#include<string>
using namespace std;
int main(){
int n;
string str, s1;
string order;
int a, b;
cin >> str;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> order >> a >> b;
if (order == "print") {
for (int i = a; i <= b; i++) {
cout << str[i];
}
cout << "\n";
} else if (order == "reverse") {
for (int i = a, j = b; i < j; i++, j--) swap(str[i], str[j]);
} else if (order == "replace") {
cin >> s1;
str.replace(a, b-a+1, s1);
}
}
return 0;
}
|
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define all(c) (c).begin(),(c).end()
#define pb push_back
#define dbg(...) do{cerr<<__LINE__<<": ";dbgprint(#__VA_ARGS__, __VA_ARGS__);}while(0);
using namespace std;
namespace std{template<class S,class T>struct hash<pair<S,T>>{size_t operator()(const pair<S,T>&p)const{return ((size_t)1e9+7)*hash<S>()(p.first)+hash<T>()(p.second);}};template<class T>struct hash<vector<T>>{size_t operator()(const vector<T> &v)const{size_t h=0;for(auto i : v)h=h*((size_t)1e9+7)+hash<T>()(i)+1;return h;}};}
template<class T>ostream& operator<<(ostream &os, const vector<T> &v){os<<"[ ";rep(i,v.size())os<<v[i]<<(i==v.size()-1?" ]":", ");return os;}template<class T>ostream& operator<<(ostream &os,const set<T> &v){os<<"{ "; for(const auto &i:v)os<<i<<", ";return os<<"}";}
template<class T,class U>ostream& operator<<(ostream &os,const map<T,U> &v){os<<"{";for(const auto &i:v)os<<" "<<i.first<<": "<<i.second<<",";return os<<"}";}template<class T,class U>ostream& operator<<(ostream &os,const pair<T,U> &p){return os<<"("<<p.first<<", "<<p.second<<")";}
void dbgprint(const string &fmt){cerr<<endl;}template<class H,class... T>void dbgprint(const string &fmt,const H &h,const T&... r){cerr<<fmt.substr(0,fmt.find(","))<<"= "<<h<<" ";dbgprint(fmt.substr(fmt.find(",")+1),r...);}
typedef long long ll;typedef vector<int> vi;typedef pair<int,int> pi;const int inf = (int)1e9;const double INF = 1e12, EPS = 1e-9;
int main(){
cin.tie(0); cin.sync_with_stdio(0);
int n; cin >> n;
ll ans = 0;
vector<ll> a(n);
rep(i, n){
cin >> a[i];
ans ^= a[i];
}
rep(i, n) a[i] &= ~ans;
for(int i = 63, p = 0; i >= 0; i--){
int j = -1;
rep(k, n) if((a[k] >> i & 1) && !(a[k] >> i + 1)){
j = k;
break;
}
if(j < 0) continue;
swap(a[p], a[j]);
rep(k, n) if(k != p && (a[k] >> i & 1)) a[k] ^= a[p];
p++;
}
ll sum = 0;
rep(i, n) sum = max(sum, sum ^ a[i]);
ans += 2 * sum;
cout << ans << endl;
return 0;
}
| 0
| 62,513,315
|
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
int main() {
long long N; cin >> N;
long long S = 0;
vector<long long> a(N), b(N);
for (int i = 0; i < N; ++i) cin >> a[i], S += a[i];
if (S % (N * (N+1)/2) != 0) {
cout << "NO" << endl;
return 0;
}
long long num = S / (N * (N+1)/2);
long long count = 0;
for (int i = 0; i < N; ++i) {
b[i] = a[i] - a[(i-1+N)%N];
b[i] -= num;
if (b[i] % N != 0 || b[i] > 0) {
cout << "NO" << endl;
return 0;
}
count += abs(b[i]) / N;
}
cout << "YES" << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vi;
typedef pair<ll,ll> pi;
typedef pair<ll,pi> pii;
typedef vector<pi> vpi;
typedef set<ll> si;
typedef long double ld;
#define mp make_pair
#define pb push_back
#define f first
#define s second
ll INF = 1e9;
ll MOD = 1e9;
#define lb lower_bound
#define ub upper_bound
#define SZ(x) (ll)x.size()
#define ALL(x) x.begin(),x.end()
int N,a,L,b,Q;
vi V;
int dst[100100][18];
int query(int x, int y){
int ans = 0;
for (int i=17;i>=0;--i){
if (dst[x][i] == -1 || dst[x][i] > y)continue;
x = dst[x][i];
ans += (1<<i);
if (x == y)return ans;
}
return ans + 1;
}
int main(){
cin >> N;
for (int i=0;i<N;++i){
cin >>a ;
V.pb(a);
}
V.pb(INF);
cin >> L;
memset(dst, -1, sizeof(dst));
for (int i=0;i<N;++i){
int t = V[i]+L;
int x = ub(ALL(V), t) - V.begin() - 1;
if (i != x)dst[i][0] = x;
}
for (int i=1;i<18;++i){
for (int j=0;j<N;++j){
if (dst[j][i-1] != -1)dst[j][i] = dst[ dst[j][i-1] ][i-1];
}
}
cin >> Q;
while (Q--){
cin >>a >> b;
--a;--b;
if (a > b)swap(a,b);
cout<<query(a,b)<<'\n';
}
}
| 0
| 46,729,438
|
#include <iostream>
#include <cstring>
#include<vector>
#include <algorithm>
#include<cstdlib>
#include<set>
#include<math.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define rep(i,n) for(ll i=0;i<n;i++)
int main()
{
ll n, m, t;
cin >> n;
m = n;
t = 0;
while (0 < m)
{
t++;
m /= 10;
}
ll ans = 0;
for (int i = 1; i < t ; i++)
{
if (i % 2 == 1)
{
ans += 9 * pow(10, i - 1);
}
}
if (t % 2 == 1)
{
ans += n - pow(10, t - 1) + 1;
}
cout << ans << "\n";
return 0;
}
|
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <functional>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <cassert>
#include <exception>
#include <numeric>
using namespace std;
typedef long long ll;
typedef string str;
typedef pair<ll,ll> P;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<char> vc;
typedef vector<str> vs;
typedef vector<P> vp;
#define rep(i,a,n) for(ll i=(a); i<(n); ++i)
#define rrep(i,a,n) for(ll i=(a); i>(n); --i)
#define erep(i,a,n) for(ll i=(a); i<=(n); ++i)
#define rerep(i,a,n) for(ll i=(a); i>=(n); --i)
#define all(c) (c).begin(),(c).end()
#define pb push_back
#define mp make_pair
#define print(X) cout << (X) << endl
#define _ << " " <<
static const int INF = 1e+9+7;
int main(){
while(true){
int n;
cin >> n;
if(n == 0) break;
int A[1010] = {};
rep(i,0,n) cin >> A[i];
int min = INF;
rep(i,0,n){
rep(j,i+1,n){
if(abs(A[i]-A[j]) < min){
min = abs(A[i]-A[j]);
}
}
}
print(min);
}
return 0;
}
| 0
| 72,363,950
|
#include<iostream>
#include <stdio.h>
#include<vector>
using namespace std;
int dfs(int n, int level){
if(n<0) return 0;
if (level == 0 && n<0) return 0;
if(level == 0 && n == 0) return 1;
if(level > 0){
int sum = 0;
for(int i=0; i<=9; i++){
if(i<=n)
sum += dfs(n-i, level-1);
}
return sum;
}
return 0;
}
int main(){
int n;
while(scanf("%d\n", &n)!=EOF){
printf("%d\n", dfs(n, 4));
}
}
|
#include <iostream>
int main() {
long long int n;
std::cin >> n;
long long exclude = -1, last = 1;
for (long long i = 1; i <= n; i++) {
long long t = i * (i + 1) / 2;
if (t > n) {
exclude = t - n;
last = i;
break;
}
}
for (long long i = 1; i <= last; i++) {
if (i != exclude) std::cout << i << std::endl;
}
return 0;
}
| 0
| 55,726,968
|
#include<bits/stdc++.h>
using namespace std;
int main(void){
string s = "Christmas";
int n;
cin>>n;
while(n<25){
s+=" Eve";
n++;
}
cout<<s<<endl;
return 0;}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
using ll = long long;
const ll INF =1001001001;
int main(){
int A,B;
cin >> A >> B ;
int abottom;
if(A%2==0){
abottom = A*25/2;
}else abottom = A*25/2+1;
int atop;
if(A%2==0){
atop = (A+1)*25/2+1;
}else atop = (A+1)*25/2;
int bbottom=B*10;
int btop = (B+1)*10;
for(int i= abottom;i<atop;i++){
for(int j=bbottom;j<btop;j++){
if(i==j){
cout << i << endl;
return 0;
}
}
}
cout << -1 << endl;
return 0;
}
| 0
| 446,529
|
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main() {
int n, a[10000];
int MIN = 1000000;
int MAX = -1000000;
long long SUM = 0;
cin >> n;
for(int i = 0; i < n; i++){
cin >> a[i];
MIN = min(MIN,a[i]);
MAX = max(MAX,a[i]);
SUM = SUM + a[i];
}
cout << MIN << " " << MAX << " " << SUM << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main (void) {
int N, K;
cin >> N >> K;
double ans = 0;
double tmp_ans;
int score;
for ( int first_score=1; first_score<=N; first_score++ ) {
score = first_score;
tmp_ans = (double) 1 / N;
while ( score < K ) {
tmp_ans /= 2;
score *= 2;
}
ans += tmp_ans;
}
printf("%.10lf\n", ans);
return 0;
}
| 0
| 54,255,656
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<ll, int> Pli;
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll MOD3 = 1812447359;
const ll INF = 1ll << 62;
const double PI = 2 * asin(1);
void yes() {printf("yes\n");}
void no() {printf("no\n");}
void Yes() {printf("Yes\n");}
void No() {printf("No\n");}
void YES() {printf("YES\n");}
void NO() {printf("NO\n");}
ll Pow(ll A, ll N){
if (N == 0) return 1;
if (N % 2 == 0) return Pow(A * A % MOD, N / 2);
return Pow(A * A % MOD, N / 2) * A % MOD;
}
int Solve(ll A, ll B){
ll ans = 1;
for (ll i = 1; i <= A + B; i++){
ans *= i; ans %= MOD;
}
ll now = 1;
for (ll i = 1; i <= A; i++){
now *= i; now %= MOD;
}
ans *= Pow(now, MOD - 2); ans %= MOD;
now = 1;
for (ll i = 1; i <= B; i++){
now *= i; now %= MOD;
}
ans *= Pow(now, MOD - 2); ans %= MOD;
cout << ans << endl;
return 0;
}
int main(){
ll X, Y; cin >> X >> Y;
if ((-1 * X + 2 * Y) % 3 != 0 || (2 * X - Y) % 3 != 0){
cout << 0 << endl;
return 0;
}
ll A = (-1 * X + 2 * Y) / 3;
ll B = (2 * X - Y) / 3;
if (A < 0 || B < 0){
cout << 0 << endl;
return 0;
}
Solve(A, B);
return 0;
}
|
#include <bits/stdc++.h>
#define int long long int
using namespace std;
template<typename T,typename U> using P=pair<T,U>;
template<typename T> using V=vector<T>;
template<typename T>bool chmax(T&a,T b){if(a<b){a=b;return true;}return false;}
template<typename T>bool chmin(T&a,T b){if(a>b){a=b;return true;}return false;}
template<typename T>auto&operator<<(ostream&s,const vector<T>&v){s<<"[";bool a=1;for(auto e:v){s<<(a?"":" ")<<e;a=0;}s<<"]";return s;}
template<typename T,typename U>auto&operator<<(ostream&s,const pair<T,U>&p){s<<"("<<p.first<<","<<p.second<<")";return s;}
template<typename T>auto&operator<<(ostream&s,const set<T>&st){s<<"{";bool a=1;for(auto e:st){s<<(a?"":" ")<<e;a=0;}s<<"}";return s;}
template<typename T,typename U>auto&operator<<(ostream&s,const map<T,U>&m){s<<"{";bool a=1;for(auto e:m){s<<(a?"":" ")<<e.first<<":"<<e.second;a=0;}s<<"}";return s;}
#define DUMP(x) cerr<<#x<<" = "<<(x)<<endl;
struct edge { int to, cost; };
const int INF = 1e18;
const int MOD = 1e9+7;
V<int> As;
V<V<int>> G;
int dfs(int p, int v) {
if (G[v].size() == 1) return As[v];
V<int> rec;
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
if (u == p) continue;
int res = dfs(v, u);
if (res == INF) {
return INF;
} else {
rec.push_back(res);
}
}
int B = 2 * As[v] - accumulate(rec.begin(), rec.end(), 0LL);
if (B > As[v]) return INF;
int over = 0;
for (int i = 0; i < rec.size(); i++) {
over += max(rec[i] - (As[v] - B), 0LL);
}
if (over > B) return INF;
return B;
}
signed main()
{
int n; cin >> n;
As.resize(n);
for (int i = 0; i < n; i++) {
cin >> As[i];
}
G.resize(n);
for (int i = 0; i < n-1; i++) {
int a, b; cin >> a >> b; a--; b--;
G[a].push_back(b);
G[b].push_back(a);
}
if (n == 2) {
cout << (As[0] == As[1] ? "YES" : "NO") << endl;
return 0;
}
int root = -1;
for (int i = 0; i < n; i++) {
if (G[i].size() > 1) {
root = i; break;
}
}
int res = dfs(-1, root);
cout << (res == 0 ? "YES" : "NO") << endl;
return 0;
}
| 0
| 19,037,479
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<ld,ld> pdd;
typedef vector<ll> vll;
typedef vector<ld> vld;
typedef vector<pll> vpl;
typedef vector<vll> vvll;
#define ALL(a) a.begin(),a.end()
#define SZ(a) ((int)a.size())
#define FI first
#define SE second
#define REP(i,n) for(int i=0;i<((int)n);i++)
#define REP1(i,n) for(int i=1;i<((int)n);i++)
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define PB push_back
#define EB emplace_back
#define MP(a,b) make_pair(a,b)
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define yes cout<<"Yes"<<endl
#define YES cout<<"YES"<<endl
#define no cout<<"No"<<endl
#define NO cout<<"NO"<<endl
#define Decimal fixed<<setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
const int inf = 1e9;
const ll linf = 1LL << 50;
const double eps = 1e-10;
const int MOD = 1e9 + 7;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
const ll MAX_N=102;
ll n;
vld t(MAX_N),v(MAX_N);
ld f(ld x){
ld res=LLINF;
ld l=0;
REP(i,n+2){
ll r=l+t[i];
if(x<l)
res=min(res,v[i]+(l-x));
if(l<=x && x<r)
res=min(res,v[i]);
if(r<=x)
res=min(res,v[i]+(x-r));
l+=t[i];
}
return res;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin>>n;
t[0]=0;
REP(i,n)cin>>t[i+1];
t[n+1]=0;
v[0]=0;
REP(i,n)cin>>v[i+1];
v[n+1]=0;
ld sum=0;
REP(i,n+2)sum+=t[i];
ld ans=0;
ld pre=f(0);
for(ld x=0.5; x<=sum; x+=0.5){
ld now=f(x);
ld area=(now+pre)*0.5/2;
ans+=area;
pre=now;
}
cout<<Decimal;
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<ll> mat(n);
ll rsum = 0;
for(int i = 0;i < n; ++i){
cin >> mat[i];
rsum ^= mat[i];
}
for(int i = 0;i < n; ++i){
mat[i] &= (~rsum);
}
ll l = 0;
ll ans = 0;
for(int i = 63;i >= 0; --i){
for(int j = l; j < n; ++j){
if((mat[j] >> i) & 1){
swap(mat[l], mat[j]);
}
}
if(((mat[l] >> i)&1) == 0)continue;
for(int j = 0;j < n; ++j){
if(j == l)continue;
if((mat[j] >> i) & 1){
mat[j] ^= mat[l];
}
}
++l;
if(l >= n)break;
}
for(int i = 0;i < n; ++i){
ans^=mat[i];
}
cout << 2 * ans + rsum << '\n';
}
| 0
| 10,009,352
|
#include <bits/stdc++.h>
using namespace std;
#define ALL(x) (x).begin(), (x).end()
#define OUT(x) std::cout << (x) << std::endl
typedef long long ll;
int main() {
int A, B;
cin >> A >> B;
if (A == B) {
cout << "Draw" << endl;
return 0;
}
if (A == 1) {
cout << "Alice" << endl;
return 0;
}
if (B == 1) {
cout << "Bob" << endl;
return 0;
}
if (A < B) {
cout << "Bob" << endl;
} else {
cout << "Alice" << endl;
}
}
|
#include <iostream>
#include <stack>
int main()
{
std::stack<int> s;
while (true) {
int n;
std::cin >> n;
if (std::cin.eof()) break;
if (n == 0) {
std::cout << s.top() << std::endl;
s.pop();
}
else s.push(n);
}
}
| 0
| 86,046,714
|
#include<bits/stdc++.h>
using namespace std;
const int INF= 1e9+5;
typedef long long ll;
int main(){
int x,a,b;
cin>>x>>a>>b;
if(x+a<b)cout<<"dangerous"<<endl;
else if(b<=a)cout<<"delicious"<<endl;
else cout<<"safe"<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,s,n) for(int i=(s);i<=(n);i++)
#define repr(i,n) for(int i=n-1;i>=0;i--)
#define REPR(i,s,n) for(int i=(s);i>=(n);i--)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define Eunique(v) v.erase(unique(all(v)),v.end())
#define Eback(s) s.erase(s.end()-1,s.end())
#define rev(v) reverse(all(v))
#define minvec(v) *min_element(all(v))
#define maxvec(v) *max_element(all(v))
#define sumvec(v) accumulate(all(v),0LL)
#define mapmax(v) v.rbegin()->first
#define mapmin(v) v.begin()->first
#define pb push_back
#define pf push_front
#define m_p make_pair
#define DOUBLE fixed << setprecision(15)
#define OK cerr<<"OK\n"
#define OK1 cerr<<"OK1\n"
#define OK2 cerr<<"OK2\n"
#define SIZE(s) (int)s.size()
#define INF ((1LL<<62)-(1LL<<31))
#define zero(x,n) setw(x) << setfill('0') << n
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<long long> vll;
typedef vector<vll> vvll;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<string> vs;
typedef pair<ll,ll> pll;
typedef pair<int,int> pii;
typedef vector<pair<int,int>> vpii;
typedef vector<pair<ll,ll>> vpll;
const double pi = acos(-1.0);
const int mod=1000000007;
const int mod2=998244353;
template<class A, class B>
ostream& operator<<(ostream& ost, const pair<A, B>&p) {
ost << "{" << p.first << ", " << p.second << "} ";
return ost;
}
template<class T>
ostream& operator<<(ostream& ost, const vector<T>&v) {
ost << "{";
for (int i = 0; i<(int)v.size(); i++) {
if (i)ost << " ";
ost << v[i];
}
ost << "} \n";
return ost;
}
template<class A, class B>
ostream& operator<<(ostream& ost, const map<A, B>&v) {
ost << "{";
for (auto p:v) {
ost << "{" << p.first << ", " << p.second << "} ";
}
ost << "} ";
return ost;
}
template<class T>
inline bool chmax(T& a, T b){if(a<b){a=b;return true;} return false;}
template<class T>
inline bool chmin(T& a, T b){if(a>b){a=b;return true;} return false;}
void YES(bool b) {cout << ((b)?"YES\n":"NO\n");}
void Yes(bool b) {cout << ((b)?"Yes\n":"No\n");}
void yes(bool b) {cout << ((b)?"yes\n":"no\n");}
void Yay(bool b) {cout << ((b)?"Yay!\n":":(\n");}
ll powmod(ll a,ll b){ll c=1; while(b>0){ if(b&1){ c=a*c%mod; } a=a*a%mod; b>>=1; } return c;}
ll gcd(ll x, ll y) {return __gcd(x,y);}
ll lcm(ll x, ll y) {return x/__gcd(x,y)*y;}
int main()
{
ll ans=1,n;
string s;
map<char,ll> m;
cin >> n >> s;
rep(i,n) m[s[i]]++;
for(auto&& e:m){
ans=ans*(e.second+1)%mod;
}
cout << ans-1 << endl;
return 0;
}
| 0
| 54,075,606
|
#include <cstdio>
#include <algorithm>
using namespace std;
#define INF (1<<29)
int main(void) {
int n, m, a;
scanf("%d %d", &n, &m);
int c[m + 1], t[n+1];
for (int i = 0; i < m; i++) {
scanf("%d", &a);
c[i] = a;
}
for (int i = 0; i <= n; i++) t[i] = INF;
t[0] = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j <= n - c[i]; j++) {
t[j + c[i]] = min(t[j + c[i]], t[j] + 1);
}
}
printf("%d\n", t[n]);
return 0;
}
|
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iostream>
#include <iostream>
#include <fstream>
#include <numeric>
#include <cstring>
#include <cassert>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <cmath>
#include <set>
#include <map>
#include <functional>
#include <bitset>
#include <iomanip>
#include <stack>
#include <list>
using namespace std;
#define ll long long
#define all(v) (v).begin() , (v).end()
#define vi vector <ll>
#define vii vector <pair<ll,ll>>
#define ii pair<ll,ll>
#define sz(v) ((int)((v).size()))
#define lp(i,a,b) for(int i=a;i<b;i++)
#define pb push_back
#define pf push_front
#define F first
#define S second
#define endl "\n"
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
const double PI = 3.14159265358979323846;
const ll inf=2e9,MOD=998244353,MAX=1e7+2;
vector<ll>v;
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
IOS;
ll n;
cin>>n;
map<ll,ll>mp;
for(ll i=2;i*i<=n;i++){
while(n%i==0)
n/=i,mp[i]++;
}
if(n>1)
mp[n]++;
for(auto i:mp)
v.pb(i.second);
ll res=0;
lp(i,0,sz(v)){
ll x=1,y=0;
while(x*(x-1)/2<=v[i])
x++,y++;
res+=y-1;
}
cout<<res;
}
| 0
| 86,695,642
|
#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 o,e;
cin >> o >> e;
int size = max((int)o.size(), (int)e.size());
if((int)e.size() != (int)o.size()){
size--;
rep(i,size) cout << o[i] << e[i];
cout << o[o.size()-1] << endl;
}
else{
rep(i,size) cout << o[i] << e[i];
cout << endl;
}
}
|
#include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <string.h>
using namespace std;
int main() {
int x, n,p[200];
cin >> x >> n;
for(int i = 0; i < n; i++)
cin >> p[i];
if(n == 0) {
cout << x << endl;
return 0;
}
bool flags = 0, flagt = 0;
for(int i = 0; ; i++) {
int s = x - i;
int t = x + i;
for(int j = 0; j < n; j++) {
if(s == p[j]) {
flags = 0; break;
} else flags = 1;
}
for(int j = 0; j < n; j++) {
if(t == p[j]) {
flagt = 0; break;
} else flagt = 1;
}
if(flags == 1) {
cout << s << endl; return 0;
}
else if(flagt == 1) {
cout << t << endl; return 0;
}
}
}
| 0
| 8,351,216
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b;return true;}return false;}
int main() {
int N;
cin >> N;
double balance;
for (int i=0; i<N; i++){
double x;
string u;
cin >> x >> u;
if (u=="BTC"){
balance += x*380000.0;
}
else balance += x;
}
cout << balance << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N; cin >> N;
vector<pair<int, int>> P(N);
for(int i = 0; i < N; ++i) {
int a; cin >> a;
P[i] = make_pair(a, i);
}
sort(P.begin(), P.end(), greater<pair<int, int>>());
multiset<int> ms;
ms.insert(-1);
ms.insert(-1);
ms.insert(N);
ms.insert(N);
int64_t ans = 0;
for(auto &e : P) {
int a, i; tie(a, i) = e;
auto c = ms.lower_bound(i);
auto v = next(c);
auto x = prev(c);
auto z = prev(x);
ans += (int64_t)(i - *x) * (*v - *c) * a;
ans += (int64_t)(*x - *z) * (*c - i) * a;
ms.insert(i);
}
cout << ans << '\n';
return 0;
}
| 0
| 89,305,629
|
#include <iostream>
#include <algorithm>
#include <string>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <map>
#include <iomanip>
#include <set>
#include <ctime>
#include <tuple>
#include <bitset>
#include <assert.h>
#include <deque>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define rep(i, n) for (ll i = 0; i < n; i++)
#define debugA() cerr << "AAAAA" << endl
#define debug_() cerr << "-------------" << endl
#define debug(x) cerr << #x << ": " << x << endl
#define debug_vec(v) \
for (int i = 0; i < v.size(); i++) \
{ \
cout << v[i] << " "; \
} \
cout << endl;
using Graph = vector<vector<int>>;
using P = pair<int, int>;
int main()
{
ll h, w;
cin >> h >> w;
if (h == 1 || w == 1)
{
cout << 1 << endl;
return 0;
}
cout << (h * w + 1) / 2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,m,n) for(int (i)=(int)(m);i<(int)(n);++i)
#define rep2(i,m,n) for(int (i)=(int)(n)-1;i>=(int)(m);--i)
#define REP(i,n) rep(i,0,n)
#define REP2(i,n) rep2(i,0,n)
#define FOR(i,c) for(decltype((c).begin())i=(c).begin();i!=(c).end();++i)
#define all(hoge) (hoge).begin(),(hoge).end()
#define en '\n'
using ll = long long;
using ull = unsigned long long;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
typedef pair<ll, ll> P;
constexpr long long INF = 1LL << 60;
constexpr int INF_INT = 1 << 25;
constexpr long long MOD = (ll) 1e9 + 7;
using ld=long double;
static const ld pi = 3.141592653589793L;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
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;
}
struct Edge {
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to; cap = _cap; rev = _rev;
}
};
using Edges = vector<Edge>;
using Graph = vector<Edges>;
void add_edge(Graph& G, ll from, ll to, ll cap, bool revFlag, ll revCap) {
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)G[to].push_back(Edge(from, revCap, (ll)G[from].size() - 1));
}
void solve(){
ll n,m,v,p;
cin>>n>>m>>v>>p;
Array a(n);
REP(i,n) cin>>a[i];
sort(all(a),greater<ll>());
auto check = [&](ll x)->bool{
ll base = a[x]+m;
ll ret = m*(v-1);
ret=ret-(p-1)*m;
rep(i,p-1,n){
if(i==x) continue;
if(a[i]>base) return false;
ret-=min(m, base-a[i]);
}
return ret<=0;
};
ll l=p-1;
ll r=n;
while(l+1<r){
ll m=l+r>>1;
if(check(m)) l=m;
else r=m;
}
cout<<r<<en;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 0
| 96,196,420
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define pb push_back
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <functional>
using namespace __gnu_pbds;
using namespace std;
typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update> set1;
ll find(ll a,ll p[])
{
if(a==p[a])
return a;
else return p[a]=find(p[a],p);
}
void join(ll a,ll b,ll p[],ll sz[])
{
a=find(a,p);
b=find(b,p);
if(a!=b)
{
if(sz[a]<sz[b])
swap(a,b);
sz[a]+=sz[b];
p[b]=a;
}
}
ll power(ll a,ll b,ll mod)
{
ll res=1;
while(b>0)
{
if(b&1)
res=(res*a)%mod;
b=b/2;
a=(a*a)%mod;
}
return res;
}
ll inverse(ll x, ll p)
{
return power(x,p-2,p);
}
ll hash1(ll x,ll y)
{
return x+y+x*y;
}
ll mod=1000000007;
void dfs(ll v,ll vis[],ll dp[][2],vector<ll> adj[])
{
ll k=adj[v].size();
dp[v][1]=1;
dp[v][0]=1;
for(ll i=0;i<k;i++)
{
ll u=adj[v].at(i);
if(vis[u]==0)
{
vis[u]=1;
dfs(u,vis,dp,adj);
dp[v][0]=(dp[v][0]*(dp[u][1]+dp[u][0]))%mod;
dp[v][1]=((dp[v][1])*(dp[u][0]))%mod;
}
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin>>n;
vector<ll> adj[n+1];
for(ll i=0;i<n-1;i++)
{
ll u,v;
cin>>u>>v;
adj[u].pb(v);
adj[v].pb(u);
}
ll dp[n+1][2];
for(ll i=0;i<=n;i++)
dp[i][0]=dp[i][1]=0;
ll vis[n+1]={0};
vis[1]=1;
dfs(1,vis,dp,adj);
ll ans=(dp[1][1]+dp[1][0])%mod;
cout<<ans<<endl;
return 0;
}
|
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <string>
#include <algorithm>
#include <numeric>
#include <map>
#include <unordered_map>
#include <stack>
#include <queue>
#include <set>
#include <unordered_set>
#include <bitset>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define REP(i, n) for(size_t i = 0; i < (n); ++i)
int main()
{
string S;
cin >> S;
int N = S.size();
if ('A' == S[0])
{
int cnt = 0, idx = -1;
for (int i = 2; i < N - 1; ++i)
{
if ('C' == S[i])
{
++cnt;
if (1 == cnt) idx = i;
}
}
if (1 == cnt)
{
for (int i = 1; i < N; ++i)
{
if (0 == i || idx == i) continue;
if ('a' > S[i] || 'z' < S[i])
{
cout << "WA" << endl;
return 0;
}
}
cout << "AC" << endl;
return 0;
}
else
{
cout << "WA" << endl;
return 0;
}
}
cout << "WA" << endl;
return 0;
}
| 0
| 42,948,361
|
#include <bits/stdc++.h>
#define rep(i,n) for(long long i = 0; i < (long long)(n); ++i)
using namespace std;
using ll = long long;
int main() {
string n;
cin >> n;
string ans = "No";
rep(i, 3) if (n[i] == '7') ans = "Yes";
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pi;
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define what_is(x) cerr << #x << " is " << x << endl;
#define MT make_tuple
#define eb emplace_back
#define rep(i, begin, end) for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define REP(i,a,b) for (int i = a; i <= b; i++)
#define FOR(i,n) for (int i=0;i < n ; i++)
#define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
int main(){
ll n,k;
cin >> n>> k;
ll i=1;
ll ans=k;
while(i<n){
ans*=(k-1);
i++;
}
cout << ans;
return 0;
}
| 0
| 60,011,599
|
#include<iostream>
using namespace std;
#define df 0
typedef long int li;
void rem(li x,li& you,li& others,int n);
int main(){
if(df) printf("*debug mode*\n");
int n; cin >> n;
li a[n],s=0;
for(auto& x:a){
cin >> x;
s+=x;
}
li y[n],oth[n];
for(int i=0;i<n;i++){
y[i]=oth[i]=0;
}
bool flag;
do{
li sum=0;
for(int i=0;i<n;i++){
rem(a[i],y[i],oth[i],n);
sum+=oth[i];
}
flag=false;
li amin=sum+y[0];
for(int i=0;i<n;i++){
a[i]=sum+y[i]-oth[i];
if(a[i]>=n)flag=true;
if(a[i]<amin)amin=a[i];
y[i]=oth[i]=0;
if(df)printf("%ld ",a[i]);
}
if(df)printf("\n");
if(amin>=n){
amin-=n-1;
for(auto& x:a){
x-=amin;
if(df)printf("%ld ",x);
}
if(df)printf("\n");
}
sum=0;
}while(flag);
li sum=0;
for(auto& x:a) sum+=x;
printf("%ld",s-sum);
}
void rem(li x,li& you,li& others,int n){
you+=x%n;
x/=n;
others+=x%n;
x/=n;
if(x){
rem(x,you,others,n);
}
}
|
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define REPLL(i, n) for (ll i = 0; i < (ll)(n); i++)
using namespace std;
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;}
typedef long long ll;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
ll N, D, A; cin >> N >> D >> A;
vector<pair<ll, ll> > XI(N, pair<ll, ll>());
vector<ll> X(N, 0);
vector<ll> H(N, 0);
vector<ll> AA(N+1, 0);
REPLL(i, N){
ll x, h; cin >> x >> h;
XI[i] = {x, i};
X[i] = x;
H[i] = h;
}
sort(XI.begin(), XI.end());
sort(X.begin(), X.end());
ll ans = 0;
REP(i, N){
if(i != 0){
AA[i] += AA[i-1];
}
ll hh = H[XI[i].second];
ll a = ((hh-AA[i]*A+(A-1))/A < 0 ? 0 : (hh-AA[i]*A+(A-1))/A);
ans += a;
AA[i] += a;
ll dis = X[i]+2*D;
auto itr = lower_bound(X.begin(), X.end(), dis);
ll idx = *itr;
if(idx == dis){
AA[itr-X.begin()+1] += -a;
}else{
AA[itr-X.begin()] += -a;
}
}
cout << ans << endl;
}
| 0
| 61,122,033
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <queue>
#include <cstdio>
#include <stack>
#include <set>
#include <map>
#include <iomanip>
#include <utility>
#include <tuple>
#include <functional>
#include <bitset>
#include <cassert>
#include <complex>
#include <stdio.h>
#include <time.h>
#include <numeric>
#include <unordered_map>
#include <unordered_set>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
# define ll int64_t
# define str string
# define rep(i,n) for(ll i=0;i<n;i++)
# define rrep(i,n) for(ll i=1;i<=n;i++)
# define ALL(x) (x).begin(), (x).end()
# define SZ(x) ((int)(x).size())
# define pb push_back
# define mod 1000000007
# define PI 3.141592653589793
# define vec vector
#define dump(x) cerr<<#x<<"="<<x<<endl
using namespace std;
#define INF 2000000000
#define MAX_V 10
bool compare_by_b(pair<string,ll> a,pair<string,ll> b){
if(a.second != b.second) return a.second<b.second;
else return a.first<b.first;
}
bool my_compare(pair<ll,ll> a,pair<ll,ll> b){
if(a.first != b.first) return a.first<b.first;
if(a.second != b.second) return a.second>b.second;
else return true;
}
ll modpow(ll a,ll n,ll mod1) {
ll res=1;
while(n>0){
if(n&1) res=res*a%mod1;
a = a*a%mod1;
n >>= 1;
}
return res;
}
ll factorial(ll n){
ll x=1;
rrep(i,n) x*=i;
return x;
}
ll gcd(ll a,ll b) { return b ? gcd(b, a%b) : a; }
ll func(ll a,ll b,ll& ans_x,ll& ans_y){
if(b == 0){
ans_x = 1;
ans_y = 0;
return a;
}else{
ll ret = func(b,(a%b),ans_y,ans_x);
ans_y -= (a/b)*ans_x;
return ret;
}
}
ll lcm(ll a,ll b){
return a/gcd(a,b)*b;
}
const ll MAX = 5100000;
const ll MOD = 1000000007;
ll fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll COM(ll n, ll k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
using graph = vector<vector<ll>>;
pair<pair<ll,ll>,ll> p[100010];
ll dp[50010];
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n,m;
cin>>n;
map<string,ll> mp;
rep(i,n){
string s;
cin>>s;
mp[s]++;
}
cin>>m;
rep(i,m){
string t;
cin>>t;
mp[t]--;
}
ll maxi=0;
for(auto p:mp){
maxi=max(maxi,p.second);
}
cout<<maxi<<endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main(){
int m,f,r;
while(cin>>m>>f>>r,m!=-1||f!=-1||r!=-1){
if(m==-1||f==-1)cout<<"F\n";
else if(m+f>=80)cout<<"A\n";
else if(80>m+f&&m+f>=65)cout<<"B\n";
else if(65>m+f&&m+f>=50)cout<<"C\n";
else if(50>m+f&&m+f>=30){
if(r>=50)cout<<"C\n";
else cout<<"D\n";
}
else cout<<"F\n";
}
return 0;
}
| 0
| 9,715,690
|
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin>>s;
s.erase(s.length()-1,1);
for(int i=s.length()-1;i>1;i--) {
if(s.substr(0,(s.length()/2))==s.substr((s.length()/2),(s.length()/2))) {
cout<<s.length()-1<<endl;
break;
} else {
s.erase(s.length()-1,1);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repi(i, s, n) for (int i = (s); i < (n); i++)
#ifdef LOCAL
#define INPUT_FILE \
ifstream in("atcoder-problems/keyence2020_c.txt"); \
cin.rdbuf(in.rdbuf());
#define print_vec(v) \
rep(l, v.size()) { cout << v[l] << " "; } \
cout << endl;
#else
#define INPUT_FILE
#define print_vec(v)
#endif
#define CIN_OPTIMIZE \
cin.tie(0); \
ios::sync_with_stdio(false);
typedef pair<int, int> P;
typedef long long ll;
typedef pair<ll, ll> pl;
const int INF = 100100100;
const ll LINF = 1e18+100;
const int MOD = 1e9 + 7;
int main() {
INPUT_FILE CIN_OPTIMIZE;
int N, K , S;
cin >> N >> K >> S;
rep(i, K) { cout << S << " "; }
rep(i, N - K) {
if (S == 1e9) {
cout << 1 << " ";
} else {
cout << S + 1 << " ";
}
}
}
| 0
| 45,163,101
|
#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()
{
ll A,B;
cin >> A >> B;
A--;
ll temp = 0, ansA = 0, ansB = 0;
if ((A/2) % 2 == 1) temp = 1;
ansA = temp ^ A;
if (A % 2 == 1) ansA = ansA ^ (A-1);
temp = 0;
if ((B/2) % 2 == 1) temp = 1;
ansB = temp ^ B;
if (B % 2 == 1) ansB = ansB ^ (B-1);
if (A >= 0) cout << (ansA ^ ansB) << endl;
else cout << ansB << endl;
return 0;
}
|
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
using namespace std;
typedef vector<int> vi;
struct Dice {
static const int DN = 6;
vi ds;
Dice(vi &_ds): ds(_ds) {}
Dice(const int _ds[]) { ds.assign(_ds, _ds + DN); }
bool operator==(const Dice &d) const {
for (int i = 0; i < DN; i++)
if (ds[i] != d.ds[i]) return false;
return true;
}
bool operator<(const Dice &d) const {
for (int i = 0; i < DN; i++)
if (ds[i] != d.ds[i]) return (ds[i] < d.ds[i]);
return false;
}
inline int top() const { return ds[0]; }
inline int front() const { return ds[1]; }
inline int right() const { return ds[2]; }
inline int left() const { return ds[3]; }
inline int back() const { return ds[4]; }
inline int bottom() const { return ds[5]; }
Dice rotx(int n = 1) {
Dice r(*this);
while (n--) {
int t = r.ds[1];
r.ds[1] = r.ds[3]; r.ds[3] = r.ds[4]; r.ds[4] = r.ds[2];
r.ds[2] = t;
}
return r;
}
Dice roty(int n = 1) {
Dice r(*this);
while (n--) {
int t = r.ds[2];
r.ds[2] = r.ds[5]; r.ds[5] = r.ds[3]; r.ds[3] = r.ds[0];
r.ds[0] = t;
}
return r;
}
Dice rotz(int n = 1) {
Dice r(*this);
while (n--) {
int t = r.ds[0];
r.ds[0] = r.ds[4]; r.ds[4] = r.ds[5]; r.ds[5] = r.ds[1];
r.ds[1] = t;
}
return r;
}
void print() {
for (int i = 0; i < DN; i++) printf("%d", ds[i]); putchar('\n');
}
static void alldices(const Dice &d0, set<Dice> &s) {
Dice d(d0);
for (int z = 0; z < 4; z++) {
Dice dz = d.rotz(z);
for (int y = 0; y < 4; y++) {
Dice dy = dz.roty(y);
for (int x = 0; x < 4; x++)
s.insert(dy.rotx(x));
}
}
}
};
typedef set<Dice> sd;
int ids[6];
int main() {
for (int i = 0; i < 6; i++) cin >> ids[i];
Dice d0(ids);
sd dset;
Dice::alldices(d0, dset);
int q;
cin >> q;
while (q--) {
int t, f;
cin >> t >> f;
for (sd::iterator sit = dset.begin(); sit != dset.end(); sit++)
if (sit->top() == t && sit->front() == f) {
printf("%d\n", sit->right());
break;
}
}
return 0;
}
| 0
| 60,502,943
|
#include <iostream>
using namespace std;
int main(){
int n,x,count;
while(1){
cin>>n>>x;
if(n==0 && x==0) break;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
for(int k=1;k<=n;k++){
if(i+j+k==x && i!=j && i!=k && j!=k && i<j && j<k) count++;
}
}
}
cout<<count<<endl;
count=0;
}
return 0;
}
|
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
int main(){
int sum;
string inp;
ostringstream oss;
while (true){
cin >> inp;
if (inp == "0"){
break;
}
sum = 0;
for (unsigned int i = 0; i < inp.length(); i++){
sum += inp[i] - '0';
}
oss << sum << endl;
}
cout << oss.str();
}
| 0
| 27,071,685
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <stack>
#include <map>
#include <tuple>
#include <cmath>
#include <cstdio>
#include <cassert>
#include <functional>
#define _LIBCPP_DEBUG 0
using namespace std;
int main(void){
int l,r;
cin >> l >> r;
int mi=2018*2018;
for (int i = l; i<r; i++)
{
int L=i%2019;
for (int j = i+1; j <= r; j++)
{
int R=j%2019;
int ama=(L*R)%2019;
if (ama<mi)
{
mi=ama;
if (mi==0)
{
cout << 0 << endl;
return 0;
}
}
}
}
cout << mi << endl;
}
|
#include <bits/stdc++.h>
#if DEBUG
template <typename T>
void debug(T value) {
std::cerr << value;
}
template <typename T, typename... Ts>
void debug(T value, Ts... args) {
std::cerr << value << ", ";
debug(args...);
}
#define DBG(...) \
do { \
cerr << #__VA_ARGS__ << ": "; \
debug(__VA_ARGS__); \
cerr << " (L" << __LINE__ << ")" << endl; \
} while (0)
#else
#define DBG(...)
#endif
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, n) for (auto i : (n))
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
using ll = long long;
using namespace std;
int main() {
int N, R;
cin >> N >> R;
if (N < 10) R += 100 * (10 - N);
cout << R << endl;
}
| 0
| 89,563,696
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> ii;
typedef map<int, int> MPII;
typedef set<int> SETI;
const int mxN = 2e5;
const ld pi = 4.0 * atanl(1.0);
const int iinf = 1e9 + 10;
const int inf = 1e18 + iinf + 10;
const int mod = 1000000007;
const ld prec = .000001;
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define all(c) c.begin(), c.end()
#define rall(c) c.end(), c.begin()
int n, m, t, a[mxN];
void fast() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); }
int main() {
fast();
cin >> n;
vector<ii> v;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
v.pb(mp(x, i + 1));
}
sort(v.begin(), v.end());
for (auto x : v) {
cout << x.S << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define printVec(v) printf("{"); for (const auto& i : v) { std::cout << i << ", "; } printf("}\n");
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
using namespace std;
using P = pair<int,int>;
using ll = long long;
const ll INF = 1LL<<60;
const double PI = 3.1415926535897932;
const int MOD = 1e9 + 7;
int main() {
int n;
cin >> n;
vector<int> mode_a(1e6);
vector<int> mode_b(1e6);
rep (i, n) {
int x;
cin >> x;
if (i % 2 == 0) {
mode_a[x]++;
} else {
mode_b[x]++;
}
}
int max_a = max_element(mode_a.begin(), mode_a.end()) - mode_a.begin();
int max_b = max_element(mode_b.begin(), mode_b.end()) - mode_b.begin();
ll ans = n;
if (max_a == max_b) {
sort(mode_a.rbegin(), mode_a.rend());
sort(mode_b.rbegin(), mode_b.rend());
ans -= max(mode_a[0] + mode_b[1], mode_b[0] + mode_a[1]);
} else {
ans -= (mode_a[max_a] + mode_b[max_b]);
}
cout << ans << endl;
return 0;
}
| 0
| 60,436,651
|
#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 <functional>
#include <ctime>
#include <cmath>
#include <limits>
#include <numeric>
#include <type_traits>
#include <iomanip>
#include <float.h>
#include <math.h>
using namespace std;
using ll = long long;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b) return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
class UnionFind {
public:
vector <ll> par;
vector <ll> siz;
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
ll root(ll x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) {
return root(x) == root(y);
}
ll size(ll x) {
return siz[root(x)];
}
};
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
long long modinv(long long a, long long mod) {
return modpow(a, mod - 2, mod);
}
int main() {
string a;
cin >> a;
if (a.size() < 4)cout << "No" << endl;
else if (a[0] == 'Y' && a[1] == 'A' && a[2] == 'K' && a[3] == 'I')cout << "Yes" << endl;
else cout << "No" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(i, a, b) for(ll i = (a); i < (b); ++i)
#define REP(i, n) for(ll i = 0; i < (n); ++i)
#define ARRAY_LENGTH(array) sizeof(array)/sizeof(*array)
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
const int INF = 1000100100;
int main() {
string S;
cin >> S;
vector<bool> flags(26, false);
REP(i, S.length()) {
flags[(int)S[i] - (int)'a'] = true;
}
REP(i, 26) {
if(!flags[i]) {
cout << (char)((int)'a' + i) << endl;
return 0;
}
}
cout << "None" << endl;
return 0;
}
| 0
| 14,798,359
|
#include <iostream>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <tuple>
#include <set>
#include <stack>
#include <queue>
#include <functional>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using pii = pair<int, int>;
using vpii = vector<pii>;
using pci = pair<char, int>;
using vpci = vector<pci>;
using vb = vector<bool>;
#define out(S) cout<<(S)<<endl;
#define REP(i,b) for(int i=0;i<(b);i++)
#define rREP(i,b) for(int i=(b)-1;i>=0;i--)
#define FOR(i,a,b) for(size_t i=(a);i<(b);i++)
#define rFOR(i,a,b) for(int i=(a)-1;i>=(b);i--)
#define Foreach(item,collection) for(auto item:collection)
#define mod(i) ((i) % (ll)(1e9 + 7))
ll modpow(ll i, ll j) { ll tmp = 1; while (j) { if (j % 2)tmp = mod(tmp*i); i = mod(i*i); j /= 2; }return tmp; }
#define divmod(a,b) (mod(a * modpow((ll)b,(ll)(1e9 + 5))))
#define Yes out("Yes")
#define No out("No")
#define NO out("NO")
#define YES out("YES")
#define INF 1e10;
#define ShowAll(collection) for(auto i:collection){out(i);}
#define IfOut(condition,text) if((condition)){out(text);return 0;}
#define IfeOut(condition,itext,etext) if(condition){out(itext);return 0;}else{out(etext);return 0;}
#define GetAuto(_N,vect) {cin>>_N;vect.resize(_N);REP(i,_N){cin>>vect[i];}}
#define beginend(vec) (vec).begin(),(vec).end()
#define pb(item) push_back(item)
#define removeAll(vec,deleg) auto itr=remove_if(beginend(vec),deleg);vec.erase(itr,vec.end());
void removeAt(string& s, int index) { s.erase(index, 1); }
template<typename T> void removeAt(vector<T>& v, int index) { v.erase(v.begin() + index); }
ll manhattanDistance(ll x1, ll y1, ll x2, ll y2) { return (abs(x2 - x1) + abs(y2 - y1)); }
vector<ll> sieveOfEratosthenes(int max) { ll prime; double sqrtmax = sqrt(max); vector<ll> primeVec, searchVec; FOR(i, 2, max + 1) searchVec.push_back(i); do { prime = searchVec[0]; primeVec.push_back(prime); auto itr = remove_if(beginend(searchVec), [=](ll x)->bool {return x%prime == 0; }); searchVec.erase(itr, searchVec.end()); } while (prime < sqrtmax); primeVec.reserve(primeVec.size() + searchVec.size()); primeVec.insert(primeVec.end(), beginend(searchVec)); return primeVec; }
bool isPrime(ll x) { if (x == 2) return true; if (x < 2 || x % 2 == 0) return false; ll i = 3; while (i <= sqrt(x)) { if (x%i == 0) return false; i += 2; }return true; }
vi seq(int max, int start = 0) {vi rt(max - start+1);FOR(i, start, max+1) rt[i] = i;return rt;}
template<typename T> size_t find_first_of(vector<T> v, T val) { auto itrfind = find(beginend(v), val); size_t dis = distance(v.begin(), itrfind); if (dis == v.size()) { return -1; }return dis; }
template<class T> struct Identity {typedef T type;};
template<typename T> vector<T> select(const vector<T> &v, typename Identity<function<T(const T &)>>::type ft) {vector<T> rt; for (T item : v) { rt.push_back(ft(item)); }return rt;}
template<typename T> string join(const vector<T> &v, typename Identity<function<string(const T &)>>::type ft) {string rt = "";Foreach(x, v) {rt += ft(x);}return rt;}
int main(){
int N;
cin >> N;
map<string, bool> dic;
REP(i, N) {
string key;
cin >> key;
string value;
cin >> value;
if (key == "insert") {
dic[value] = true;
}
else if(dic.count(value)!=0) {
out("yes");
}
else {
out("no");
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
ll dp[100100][2];
int main()
{
string L;
cin >> L;
int N=L.size();
dp[0][0]=1;
for(int i=0;i<N;i++){
if(L[i]=='1'){
dp[i+1][0]+=dp[i][0]*2;
dp[i+1][0]%=MOD;
dp[i+1][1]+=dp[i][0];
dp[i+1][1]%=MOD;
}
else{
dp[i+1][0]+=dp[i][0];
dp[i+1][0]%=MOD;
}
dp[i+1][1]+=dp[i][1]*3;
dp[i+1][1]%=MOD;
}
cout << (dp[N][0]+dp[N][1])%MOD << endl;
return 0;
}
| 0
| 94,663,719
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define REP(i, n) for(ll i = 1; i < n + 1; i++)
#define MAX 5100000
#define MOD 1000000007
ll fac[MAX], finv[MAX], inv[MAX];
void combModInit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll comb(ll n, ll k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main(){
ll X, Y;
cin >> X >> Y;
combModInit();
if(Y > 2 * X || 2 * Y < X || (X + Y) % 3 != 0){
cout << 0 << endl;
return 0;
}
ll moves = (X + Y) / 3;
ll up = X - moves;
ll ans = comb(moves, up);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define sort stable_sort
using namespace std;
int _;
int n,k,a[100050],ans;
int main()
{
scanf("%d%d",&n,&k);
for(int i=0;i<n;i++)
scanf("%d",a+i);
sort(a,a+n);
for(int i=n-1;i >= n-k;i--)
ans += a[i];
printf("%d\n",ans);
return 0;
}
| 0
| 35,647,513
|
#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;
int K; cin >> K;
int R = min(N, K);
vector<int> V(N);
rep(i, N){
cin >> V[i];
}
int fa = 0;
for (int i = 0; i <= R; i++){
for (int j = 0; j <= R-i; j++){
priority_queue<int, vector<int>, greater<int> > Q;
for (int k = 0; k < i; k++){
Q.push(V[k]);
}
for (int k = 0; k < j; k++){
Q.push(V[N-1-k]);
}
for (int k = 0; k < K-i-j; k++){
if(Q.empty())break;
int x = Q.top();
if(x < 0){
Q.pop();
} else {
break;
}
}
int ans = 0;
while(!Q.empty()){
int y = Q.top(); Q.pop();
ans += y;
}
fa = max(fa, ans);
}
}
cout << fa << endl;
return 0;
}
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
const int INF=1e9;
struct edge{
int to,cost;
edge(int a,int b):to(a),cost(b){}
edge(){}
};
struct data{
int At,cost;
data(int a,int b):At(a),cost(b){}
data(){}
bool operator>(const data &d)const{
return cost>d.cost;
}
};
vector<vector<edge> >E;
int all;
int dijkstra(int s){
vector<int>D(all,INF);
priority_queue<data,vector<data>,greater<data> >Q;
Q.push(data(s,0));
while(!Q.empty()){
int At=Q.top().At,cost=Q.top().cost;
Q.pop();
if(D[At]<=cost)continue;
D[At]=cost;
for(int i=0;i<E[At].size();i++){
edge e=E[At][i];
Q.push(data(e.to,e.cost+cost));
}
}
int sum=0;
for(int i=0;i<all;i++)sum+=D[i];
return sum;
}
int main(){
int n;
while(cin>>n,n){
E.clear();
E.resize(10);
all=0;
for(int i=0;i<n;i++){
int a,b,c;
cin>>a>>b>>c;
all=max(max(a,b),all);
E[a].push_back(edge(b,c));
E[b].push_back(edge(a,c));
}
all++;
int Min=INF,p;
for(int i=0;i<all;i++){
int latte=dijkstra(i);
if(Min>latte){
Min=latte;
p=i;
}
}
cout<<p<<" "<<Min<<endl;
}
}
| 0
| 72,537,180
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, n) for (int i = n-1; i >= 0; i--)
#define all(x) x.begin(), x.end()
using ll = long long;
using pii = pair<int, int>;
const int mod = 1e9+7;
int main() {
int n, m;
cin >> n >> m;
int a[n], b[n], c[m], d[m];
rep(i, n) {
cin >> a[i] >> b[i];
}
rep(i, m) {
cin >> c[i] >> d[i];
}
rep(i, n) {
int min_d = 1e9;
int p;
rep(j, m) {
if (abs(a[i] - c[j]) + abs(b[i] - d[j]) < min_d) {
min_d = abs(a[i] - c[j]) + abs(b[i] - d[j]);
p = j+1;
}
}
cout << p << endl;
}
}
|
#include <iostream>
#include <string>
#include <queue>
using namespace std;
int main() {
long long K;
cin >> K;
queue<long long> Que;
for (long long i = 1; i <= 9; i++) Que.push(i);
long long res = 0;
for (long long i = 0; i < K; i++){
long long a = Que.front();
Que.pop();
if (i == K - 1) res = a;
if (a % 10 == 0) {
Que.push(a * 10);
Que.push(a * 10 + 1);
}
else if (a % 10 == 9) {
Que.push(a * 10 + 8);
Que.push(a * 10 + 9);
}
else {
Que.push(a * 10 + (a % 10) - 1);
Que.push(a * 10 + (a % 10));
Que.push(a * 10 + (a % 10) + 1);
}
}
cout << res << endl;
}
| 0
| 94,748,797
|
#include<bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long bigmod(long long a, long long p){
if(p == 0){
return 1;
}
long long ans = bigmod(a, p/2);
ans = (ans * ans) % mod;
if(p % 2 == 1){
ans = (ans * a) % mod;
}
return ans;
}
int main(){
long long n, k;
cin >> n >> k;
vector<long long>gcd(k + 3);
long long ans = 0;
for(long long i = k; i >= 1; i--){
gcd[i] = bigmod(k / i, n);
for(int j = 2 * i; j <= k; j = j + i){
gcd[i] = (gcd[i] - gcd[j] + mod) % mod;
}
ans = (ans + i * gcd[i]) % mod;
}
cout << ans;
return 0;
}
|
#pragma region header
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define resort(v) sort((v).rbegin(), (v).rend())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
using ll = long long;
using P = pair<int, int>;
int dx[] = {1,0,-1,0};
int dy[] = {0,1,0,-1};
constexpr ll mod = 1e9+7;
constexpr int inf = INT32_MAX/2;
constexpr ll INF = LLONG_MAX/2;
constexpr long double eps = DBL_EPSILON;
constexpr long double pi = 3.141592653589793238462643383279;
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll fact(int i) {
if (i == 0) return 1;
return (fact(i - 1)) * i % mod;
}
ll gcd(ll a, ll b) {
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
return a * b / gcd(a, b);
}
int keta(ll n) {
if(n == 0) return 1;
int count = 0;
while(n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) {
ll sum = 0;
while(n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
#pragma endregion
signed main() {
int n;cin >> n;
vi a(n);
int ma = -1;
rep(i, n) {
cin >> a[i];
}
sort(all(a));
vi rui(n+1);
rui[0] = 0;
rep(i, n) {
rui[i+1]+=rui[i]+a[i];
}
int count = 1;
rep1(i, n-1) {
if(rui[i]*2>=rui[i+1]-rui[i]) count++;
else count = 1;
}
cout << count << endl;
return 0;
}
| 0
| 21,708,871
|
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define int long long
#define _CRT_SECURE_NO_WARNINGS
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
const int MOD = 1e9 + 7;
const int INF = 1e18 + 9;
constexpr long double pi = 3.141592653589793238462643383279;
int fact(int i) {
if (i == 0) return 1;
return (fact(i - 1)) * i;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
int keta(int n) {
if (n == 0) return 1;
int count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
int ketasum(int n) {
int sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
signed main(){
int a,b;
cin>>a>>b;
for(int i=1;i<4;++i){
if(i!=a && i!=b){
cout<<i<<endl;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main(){
int h,w,d;
cin >> h >> w >> d;
vector<P> a(h*w);
rep(i,h){
rep(j,w){
int x;
cin >> x;
P p(i,j);
x--;
a[x] = p;
}
}
int vec_num = (h*w)/d+2;
vector<vector<int>> cum_sum(d,vector<int>(vec_num));
rep(i,d){
cum_sum[i][0]=0;
}
rep(i,d){
int temp = i;
int j = 0;
while(temp+d<(h*w)){
cum_sum[i][j+1]=cum_sum[i][j]+ abs(a[temp+d].first-a[temp].first)+abs(a[temp+d].second-a[temp].second);
temp+=d;
j++;
}
}
int query;
cin >> query;
vector<int> res;
rep(i,query){
int l,r;
cin >> l >> r;
l--; r--;
int ind = 0;
ind = l%d;
l = l/d; r = r/d;
res.push_back(cum_sum[ind][r]-cum_sum[ind][l]);
}
for(auto r:res) cout << r << endl;
}
| 0
| 89,889,865
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
using LL = long long;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<long> VL;
int main() {
int n; cin >> n;
vector<int> A(n+1);
rep(i, n) {
cin >> A.at(i+1);
}
for(int i=1; i<n+1; i++) {
cout << "node " << i << ": " << "key = " << A.at(i) << ", ";
if (i !=1 ) {
cout << "parent key = " << A.at(i/2) << ", ";
}
if (2*i <= n) {
cout << "left key = " << A.at(i*2) << ", ";
}
if (2*i+1 <= n) {
cout << "right key = " << A.at(i*2+1) << ", ";
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void){
int A,B,M,priceA,priceB,priceC;
cin>>A>>B>>M;
int a[A],b[B],x[M],y[M],c[M];
for(int i=0;i<A;i++){
cin>>a[i];
}
for(int i=0;i<B;i++){
cin>>b[i];
}
for(int i=0;i<M;i++){
cin>>x[i]>>y[i]>>c[i];
}
for(int i=0;i<A;i++){
if(i==0){
priceA=a[0];
}
else{
priceA=min(priceA,a[i]);
}
}
for(int i=0;i<B;i++){
if(i==0){
priceB=b[0];
}
else{
priceB=min(priceB,b[i]);
}
}
for(int k=0;k<M;k++){
if(k==0){
priceC=a[x[0]-1]+b[y[0]-1]-c[0];
}
else{
priceC=min(priceC,a[x[k]-1]+b[y[k]-1]-c[k]);
}
}
cout<<min(priceA+priceB,priceC)<<endl;
return 0;
}
| 0
| 42,019,819
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <cstring>
#include <cmath>
#include <queue>
#include <map>
#include <set>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
#define FOR(i,s,n) for(int i=s; i<n; i++)
#define ALL(x) x.begin(), x.end()
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef vector<int> vi;
int main() {
int n;
ll m;
while(cin >> n >> m, n) {
vector<pii> v;
rep(i, n) {
int d, p;
cin >> d >> p;
v.push_back( pii(p, d) );
}
sort( v.begin(), v.end() );
int k = n-1;
while(k>=0 && m>0) {
int diff = min(1LL*v[k].second, m);
v[k].second -= diff;
m -= diff;
k--;
}
ll sum = 0;
rep(i, n) {
sum += v[i].first * v[i].second;
}
cout << sum << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pb push_back
#define dbg(x) cerr << #x << " " << x << "\n"
int main () {
ios::sync_with_stdio (false);
cin.tie (0); cout.tie (0);
ll x, y;
cin >> x >> y;
ll ans;
if (x > y) {
if (x < 0)
ans = 2 + abs (x - y);
else {
ans = min (1 + abs (y + x), 2 + abs (y - x));
}
}
else {
ans = y - x;
if (x <= 0 && y >= 0)
ans = min (ans, 1 + abs (x + y));
}
cout << ans << "\n";
return 0;
}
| 0
| 73,616,437
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
template <class T> inline bool chmin(T &a, T b) {if (a > b){a = b;return true;}return false;}
template <class T> inline bool chmax(T &a, T b) {if (a < b){a = b;return true;}return false;}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int a;cin>>a;
string ans;
if(a<1200){
ans = "ABC";
}else if (a<2800)
{
ans = "ARC";
}else {
ans = "AGC";
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int ctoi(char c) { if(c < '0' || '9' < c) throw invalid_argument("ctoi error"); return c - '0'; }
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define REP(i, k, n) for(int i = (int)(k); i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
template <typename T>
inline T gcd(T x, T y){
if (x <= 0 || y <= 0) throw invalid_argument("gcd error: x <= 0 or y <= 0");
if(x < y) swap(x, y);
T r = x % y;
while(r != 0){
x = y;
y = r;
r = x % y;
}
return y;
}
template <typename T>
inline T lcm(T x, T y){
if (x <= 0 || y <= 0) throw invalid_argument("lcm error: x <= 0 or y <= 0");
return x * y / gcd(x, y);
}
int main(){
vector<int> ans;
while(true){
int n, k;
cin >> n >> k;
if(n == 0 && k == 0) break;
vector<int> input;
rep(i, n){
int a;
cin >> a;
input.push_back(a);
}
vector<int> cumu;
cumu.push_back(0);
rep(i, n){
cumu.push_back(cumu[i] + input[i]);
}
int sumMax = 0;
rep(i, n){
if(n < i + k) break;
if(sumMax < cumu[i + k] - cumu[i]) sumMax = cumu[i + k] - cumu[i];
}
ans.push_back(sumMax);
}
rep(i, ans.size()){
cout << ans[i] << endl;
}
return 0;
}
| 0
| 87,043,975
|
#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
int main() {
double a,b,c,C,S,h,L;
cin >> a >> b >> C;
h = b*sin(C * M_PI / 180);
S = 0.5 * a * h;
L = a+b+sqrt(a*a+b*b-2*a*b*cos(M_PI /180 * C));
cout << setprecision(10) << S << endl;
cout << setprecision(10) << L << endl;
cout << setprecision(10) << h << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i,n) for (int i = 0; i < (n); i++)
#define RREP(i, s, n) for (int i = s; i < (n); i++)
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.rbegin(), a.rend()
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
using namespace std;
using ll = long long;
typedef pair<int, int> pint;
typedef pair<ll, ll> pll;
const ll MOD = 1000000007;
const ll INF = MOD * MOD;
const int inf = (1<<29);
int main() {
int x, y;
cin >> x >> y;
for(int i = 0; i <= 100; i++) {
for (int j = 0; j <= 100; j++) {
int sum = 2*i +4*j;
int num = i+j;
if(sum == y && num == x) {
cout << "Yes" << endl;
return 0;
}
}
}
cout << "No" << endl;
return 0;
}
| 0
| 49,943,000
|
#include<iostream>
#include<vector>
#define rep(i,n) for(int i=0; i<(n); ++i)
int main(){
int n,m; std::cin >> n >> m;
std::vector<bool> ac(n+1,false);
std::vector<int> wa_cnt(n+1,0);
rep(i,m){
int p;
std::string s;
std::cin >> p >> s;
if(ac[p]) continue;
if(s == "WA")
++wa_cnt[p];
else
ac[p] = true;
}
int AC=0, WA=0;
for(int i=1; i<n+1; ++i){
if(ac[i]){
++AC;
WA += wa_cnt[i];
}
}
std::cout << AC << ' ' << WA << std::endl;
return 0;
}
|
#include<cstdio>
using namespace std;
int upd(int x){
if(x == 1){
x = 9;
}
else if(x == 9){
x = 1;
}
return x;
}
int main(){
int n;
while(~scanf("%d", &n)){
int x = n/100, y = n%100/10, z = n%10;
x = upd(x);
y = upd(y);
z = upd(z);
printf("%d\n", x*100 + y*10 + z);
}
}
| 0
| 85,982,801
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.