code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 1
101M
|
|---|---|---|---|
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <stack>
#include <map>
#include <queue>
#include <cmath>
#include <iomanip>
#include <set>
#include <functional>
#include <list>
#define MOD (1000000000 + 7)
using namespace std;
typedef long long ll;
typedef pair<ll, ll> tup;
const int MAX = 3000000;
long long fac[MAX], finv[MAX], inv[MAX];
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a%b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b;}
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;
}
map<ll,ll> prime;
void prime_factorize(ll n){
if(n<=1) return;
ll l=sqrt(n);
for(ll i=2;i<=(ll)(l);i++) {
if(n%i==0){
prime_factorize(i);prime_factorize(ll(n/i));return;
}
}
prime[n]++;return;
}
vector<ll> divisor;
void list_divisor(ll n) {
divisor.clear();
for(int i = 1; i*i <= n; i++) {
if(n % i == 0) {
divisor.push_back(i);
if(i*i != n) divisor.push_back(n/i);
}
}
sort(divisor.begin(), divisor.end());
}
int main() {
ll N, P;
cin >> N >> P;
ll even = 0, odd = 0;
COMinit();
for(ll i = 0; i < N; i++) {
ll tmp;
cin >> tmp;
if(tmp%2 == 0) even++;
else odd++;
}
ll base = pow(2, even);
ll odd_sum = 0, even_sum = 0;
for(ll i = 0; i <= odd; i++) {
if(i%2 == 1) odd_sum += COM(odd, i);
else even_sum += COM(odd, i);
}
if(P == 0) cout << base * even_sum << endl;
else cout << base * odd_sum << endl;
}
|
#include <bits/stdc++.h>
#define rep(i , n) for(int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
int a[3][3];
int d[3][3];
int main() {
int count = 0;
rep(i, 3){
rep(j, 3){
cin >> a[i][j];
}
}
int n;
cin >> n;
rep(k, n) {
int x;
cin >> x;
rep(i, 3){
rep(j, 3){
if(a[i][j] == x){
d[i][j] = 1;
}
}
}
}
bool ans = false;
rep(i, 3) {
int count = 0;
rep(j, 3){
count += d[i][j];
}
if(count == 3){
ans = true;
}
}
rep(i, 3) {
count = 0;
rep(j,3){
count += d[j][i];
}
if(count == 3){
ans = true;
}
count = 0;
rep(j ,3) {
count += d[j][j];
}
if(count == 3){
ans = true;
}
count = 0;
rep(j, 3){
count += d[j][2 - j];
}
if(count == 3){
ans = true;
}
}
if(ans){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
return 0;
}
| 0
| 47,978,686
|
#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(n) begin(n),end(n)
using namespace std;
using P = pair<int, int>;
using ll = long long;
int main()
{
int n;
cin >> n;
vector<int> a(n);
vector<int> b(n);
rep(i,n) cin >> a[i];
rep(i,n) b[i] = a[i];
sort(ALL(b));
int m = b[n-1];
rep(i,n){
if(a[i] == m){
cout << b[n-2] << endl;
}
else{
cout << m << endl;
}
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>
#include <numeric>
#include <string>
#include <cstring>
#include <list>
#include <unordered_set>
#include <tuple>
#include <cmath>
#include <limits>
#include <type_traits>
#include <iomanip>
#include <map>
#include <unordered_map>
#include <queue>
#include <stack>
#include <set>
#include <bitset>
#include <regex>
#include <random>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n)for(ll i=0;i<n;++i)
#define exout(x) printf("%.12f\n", x)
const double pi = acos(-1.0);
const ll MOD = 1000000007;
const ll INF = 1e18;
const ll MAX_N = 1010101;
ll fac[MAX_N], finv[MAX_N], inv[MAX_N];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX_N; 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(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;
}
ll gcd(ll x, ll y) {
return y ? gcd(y, x % y) : x;
}
ll lcm(ll x, ll y) {
if (x == 0 || y == 0)return 0;
return (x / gcd(x, y) * y);
}
ll dx[8] = { 1,-1,0,0,1,1,-1,-1 };
ll dy[8] = { 0,0,1,-1,1,-1,1,-1 };
char c[2010][2010];
ll sum[2010][2010];
ll sum2[2010][2010];
int main() {
ll h, w;
cin >> h >> w;
rep(i, h) {
rep(j, w) {
cin >> c[i][j];
}
}
rep(i, h) {
vector<ll>done(w);
rep(j, w) {
if (c[i][j] == '#')continue;
if (done[j])continue;
ll l = 0;
while (l + j < w) {
if (c[i][l + j] == '#')break;
l++;
}
rep(k, l) {
sum[i][j + k] += l;
done[j + k] = 1;
}
}
}
rep(j, w) {
vector<ll>done(h);
rep(i, h) {
if (c[i][j] == '#')continue;
if (done[i])continue;
ll l = 0;
while (l + i < h) {
if (c[i+l][j] == '#')break;
l++;
}
rep(k, l) {
sum[i + k][j] += l;
done[i + k] = 1;
}
}
}
ll ans = 0;
rep(i, h) {
rep(j, w) {
ans = max(ans, sum[i][j] - 1);
}
}
cout << ans << endl;
return 0;
}
| 0
| 71,456,486
|
#include<bits/stdc++.h>
using namespace std;
#define mp make_pair
#define pb push_back
#define ll long long
#define ff first
#define ss second
#define Endl endl
#define int long long
int gcd(int a,int b){
return b?gcd(b,a%b):a;
}
bool cmps(pair<int,int>p1,pair<int,int>p2) {
return p1.ss<p2.ss;
}
int lcm(int a, int b){
return (a*b)/gcd(a, b);
}
int32_t main() {
int k,x;
cin>>k>>x;
if(k*500>= x)
cout<<"Yes"<<Endl;
else cout<<"No"<<Endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <time.h>
#include <cstdlib>
#include <cmath>
#include <fstream>
#include <iomanip>
using namespace std;
int findindex(int n, int x[]) {
for (int i = 0; i < 6; i++) {
if (x[i] == n) {
return i;
}
}
return -1;
}
int main() {
int d[6], n, u, f, U, F, r;
for (int i = 0; i < 6; i++) {
cin >> d[i];
}
int dice_face[6][5] = {{1, 2, 4, 3, 1}, {0, 3, 5, 2, 0}, {0, 1, 5, 4, 0}, {0, 4, 5, 1, 0}, {0, 2, 5, 3, 0}, {1, 3, 4, 2, 1}};
cin >> n;
for (int i = 0; i < n; i++) {
cin >> u >> f;
U = findindex(u, d);
F = findindex(f, d);
r = dice_face[U][findindex(F, dice_face[U]) + 1];
cout << d[r] << endl;
}
return 0;
}
| 0
| 45,338,337
|
#include<iostream>
#include<vector>
using namespace std;
int main() {
string S;
cin >> S;
vector<int> a(1000);
for (int i = 0; i < S.length(); i++) {
a[S[i] - 'a']++;
}
bool check = true;
for (int i = 0; i < 1000; i++) {
if (a[i] > 1) {
check = false;
}
}
if (check) {
cout << "yes" << endl;
}
else {
cout << "no" << endl;
}
return 0;
}
|
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
constexpr char ln = '\n';
constexpr long long MOD = 1000000007LL;
constexpr long long INF = 1001001001LL;
constexpr long long LINF = 1001001001001001001;
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define rept(i, j, n) for(int i=(j); i<(n); i++)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main(){
int n, k; cin >> n >> k;
vector<int> A(n); rep(i, n) cin >> A[i];
rep(i, min(1000, k)){
vector<int> plus(n), minus(n);
rep(j, n){
int s = max(0, j-A[j]), t = min(n-1, j+A[j]);
plus[s]++; minus[t]++;
}
int cnt = 0;
rep(j, n){
cnt += plus[j];
A[j] = cnt;
cnt -= minus[j];
}
}
rep(i, n)cout << A[i] << " ";
cout << ln;
}
| 0
| 8,015,311
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int main(){
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
int t;
cin>>t;
string s;
cin>>s;
int ans=1;
for(int i=0;i<s.size()-1;++i){
if(s[i]!=s[i+1]) ++ans;
}
cout<<ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define SZ(x) ((int)(x).size())
#define REP(i,n) for(int _n=n, i=0;i<_n;++i)
#define FOR(i,a,b) for(int i=(a),_b=(b);i<=_b;++i)
#define FORD(i,a,b) for(int i=(a),_b=(b);i>=_b;--i)
#define trav(a, x) for (auto& a : x)
using ull = uint64_t;
using ll = int64_t;
using PII = pair<int, int>;
using VI = vector<int>;
#define INF (1ll<<60)
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string) s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <typename A> string to_string(A v) {
bool first = true; string res = "{";
for (const auto &x : v) { if (!first) { res += ", "; } first = false; res += to_string(x); }
res += "}"; return res; }
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H); debug_out(T...); }
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
int main() {
ios::sync_with_stdio(false), cin.tie(0);
ll N, M;
cin >> N >> M;
vector<ll> V(N);
REP(i, N) cin >> V[i];
unordered_map<ll, int> R;
ll sum = 0;
ll ans = 0;
REP(i, N) {
sum = (sum + V[i]) % M;
if (sum == 0) ans++;
ans += R[sum];
R[sum]++;
}
cout << ans << '\n';
}
| 0
| 88,988,677
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
typedef long long ll;
int main() {
int a,b;
cin>>a>>b;
a>b?cout<<"safe":cout<<"unsafe";
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx")
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int (i)=0;i<(n);i++)
#define REP(i,m,n) for(int (i)=(m);(i)<(n);(i)++)
#define MOD 1000000007
#define fcout cout << fixed << setprecision(15)
#define int long long
#define endl "\n"
#define yorn(f) puts((f)?"Yes":"No")
#define YORN(f) puts((f)?"YES":"NO")
typedef long long ll;
typedef pair<int, int> P;
int gcd(int a,int b){return b?gcd(b,a%b):a;};
int lcm(int a,int b){return a/gcd(a,b)*b;};
int mod(int a,int b){return (a+b-1)/b;};
template<typename A, size_t N, typename T>
void Fill(A(&array)[N],const T &val){std::fill((T*)array,(T*)(array+N),val);}
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 cost first
#define to second
#define INF LLONG_MAX
const int MAX_V = 100010;
vector<P> G[MAX_V];
int dist[MAX_V];
int V;
void dijikstra(int s) {
priority_queue< P, vector<P>, greater<P> > que;
fill(dist, dist + V, INF);
dist[s] = 0;
que.push(P(0, s));
while(!que.empty()) {
P p = que.top(); que.pop();
int next = p.to;
if(dist[next] < p.cost) continue;
for(P e : G[next]) {
if(dist[e.to] > dist[next] + e.cost) {
dist[e.to] = dist[next] + e.cost;
que.push(P(dist[e.to], e.to));
}
}
}
}
signed main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cin >> V;
rep(i, V-1) {
int a, b, c;
cin >> a >> b >> c;
a--; b--;
G[a].push_back(P(c, b));
G[b].push_back(P(c, a));
}
int q, k;
cin >> q >> k;
dijikstra(--k);
rep(i, q) {
int x, y;
cin >> x >> y;
x--; y--;
cout << dist[x] + dist[y] << endl;
}
return 0;
}
| 0
| 37,590,881
|
#include <iostream>
#include <string>
#include <vector>
#include <stdio.h>
#include <algorithm>
#include <cassert>
#include <unordered_set>
#include <unordered_map>
#include <set>
#include <map>
#include <queue>
#include <random>
#include <numeric>
#include <time.h>
#include <stack>
#include <bitset>
#define prev asasddlsa
#define rank aljds
#define rep(i, l, r) for (int i = l; i < r; i++)
#define repb(i, r, l) for (int i = r; i >= l; i++)
using namespace std;
typedef long long ll;
typedef double dbl;
template<typename T>
void print(const vector<T>& s){
for (auto x : s)
cout << x << " ";
cout << endl;
}
template<class T>
void print(const T* s, int n){
for (int i = 0; i < n; i++)
cout << s[i] << ' ';
cout << endl;
}
template<class T>
void print(vector<vector<T>> s){
for (int i = 0; i < s.size(); i++)
print(s[i]);
}
ll f(ll x, ll n){
if (n % x == 0)
return x * (2 * (n / x - 1) + 1);
return 2 * x * (n / x) + f(n % x, x);
}
int solve(){
ll n, x;
cin >> n >> x;
cout << n + f(x, n - x) << endl;
return 0;
}
int main(){
srand(time(NULL));
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(10);
cout << fixed;
int t = 1;
while (t--)
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 1010;
typedef long long LL;
int xs[MAXN], ys[MAXN], n;
char step[50];
const int UP = 39;
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n;
for (int i = 1; i <= n; ++i)
std::cin >> xs[i] >> ys[i];
for (int i = 1; i <= n; ++i)
if ((xs[i] + ys[i] & 1) != (xs[1] + ys[1] & 1))
return std::cout << -1 << std::endl, 0;
int typ = (xs[1] + ys[1] & 1) ^ 1;
std::cout << UP + typ << '\n';
if (typ) std::cout << 1 << ' ';
for (int i = 0; i < UP; ++i)
std::cout << (1ll << i) << (" \n" [i == UP - 1]);
for (int i = 1; i <= n; ++i) {
LL x = xs[i], y = ys[i];
if (typ) step[0] = 'L', ++x;
int cur = typ + UP - 1;
for (int j = UP - 1; ~j; --j, --cur) {
const LL L = 1ll << j;
if (std::abs(x) > std::abs(y)) {
if (x > 0) step[cur] = 'R', x -= L;
else step[cur] = 'L', x += L;
} else {
if (y > 0) step[cur] = 'U', y -= L;
else step[cur] = 'D', y += L;
}
}
std::cout << step << '\n';
}
return 0;
}
| 0
| 72,487,709
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
int main() {
int n,k;
cin >> n >> k;
priority_queue<int> q;
vector<vector<int>> v(k);
rep(i,n){
int x,y;
cin >> x >> y;
int z=k-x;
if(z>=0) v[z].push_back(y);
}
ll ans=0;
for(int i=k-1;i>=0;i--){
for(int x:v[i]){
q.push(x);
}
if(!q.empty()){
int y=q.top();q.pop();
ans+=y;
}
}
cout << ans << endl;
}
|
#include <iostream>
using namespace std;
int main(){
int i = 0;
int x[25565] = {0};
int y[25565] = {0};
do{
cin >> x[i] >> y[i];
i = i + 1;
}while(x[i-1] != 0 || y[i-1] != 0);
i = 0;
do{
if(x[i] != 0 || y[i] != 0){
if(x[i] <= y[i]){
cout << x[i] << " " << y[i] << endl;
}else if(x[i] > y[i]){
cout << y[i] << " " << x[i] << endl;
}
}
i = i + 1;
}while(x[i-1] != 0 || y[i-1] != 0);
}
| 0
| 78,074,645
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define FOR(i,a,b) for(int i=(a); i<(b); i++)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
typedef long long ll;
vector<vector<char>> g(100,vector<char>(100));
int main(){
int a,b; cin >> a >> b;
rep(i,100){
rep(j,100){
if(i < 50) g[i][j] = '#';
else g[i][j] = '.';
}
}
int p = (a-1)/50;
for(int i = 0; i < 2*p; i += 2){
for(int j = 0; j < 100; j += 2){
g[i][j] = '.';
}
}
int q = (a-1)%50;
for(int j = 0; j < 2*q; j += 2){
g[2*p][j] = '.';
}
int r = (b-1)/50;
for(int i = 0; i < 2*r; i += 2){
for(int j = 0; j < 100; j += 2){
g[i+51][j] = '#';
}
}
int s = (b-1)%50;
for(int j = 0; j < 2*s; j += 2){
g[2*r+51][j] = '#';
}
cout << "100 100" << endl;
rep(i,100){
rep(j,100){
cout << g[i][j];
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int MAX_N=262144;
vector<int64_t> seg(MAX_N*2-1);
int64_t qu(int a,int b,int k,int l, int r){
if(r<=a||b<=l){
return -1;
}
else if(a<=l&&r<=b){
return seg[k];
}
else{
int64_t X=qu(a,b,k*2+1,l,(l+r)/2);
int64_t Y=qu(a,b,k*2+2,(l+r)/2,r);
return max(X,Y);
}
}
void chmax(int64_t a,int b){
int D=MAX_N-1+b;
seg[D]=a;
while(D>0){
D--;
D/=2;
seg[D]=max(seg[2*D+1],seg[2*D+2]);
}
}
int main() {
int N,l,r;
cin>>N;
vector<int> p(N);
for(int i=0;i<N;i++){
int a;
cin>>a;
chmax(a,i);
p[a-1]=i;
}
int64_t Z=0;
for(int i=N-1;i>0;i--){
int a=p[i-1];
int64_t A=N-a,B=N-a,C=a+1,D=a+1;
if(qu(a,N,0,0,MAX_N)>i){
l=a+1,r=N;
while(r-l>1){
int X=(l+r)/2;
if(qu(a,X,0,0,MAX_N)>i){
r=X;
}
else{
l=X;
}
}
A=r-a-1;
if(qu(A+1+a,N,0,0,MAX_N)>i){
l=A+1+a,r=N;
while(r-l>1){
int X=(l+r)/2;
if(qu(A+1+a,X,0,0,MAX_N)>i){
r=X;
}
else{
l=X;
}
}
B=r-a-1;
}
}
if(qu(0,a,0,0,MAX_N)>i){
l=0,r=a;
while(r-l>1){
int X=(l+r)/2;
if(qu(X,a,0,0,MAX_N)>i){
l=X;
}
else{
r=X;
}
}
C=a-r+1;
if(qu(0,l,0,0,MAX_N)>i){
r=l,l=0;
while(r-l>1){
int X=(l+r)/2;
if(qu(X,a-C,0,0,MAX_N)>i){
l=X;
}
else{
r=X;
}
}
D=a-l;
}
}
int64_t Q=A*(D-C)+(B-A)*C;
Q*=i;
Z+=Q;
}
cout<<Z<<endl;
}
| 0
| 5,352,945
|
#include<iostream>
using namespace std;
int main(){
char chara ;
cin >> chara ;
if( chara == 'a' || chara == 'e' || chara == 'i' || chara == 'o' || chara == 'u' )
cout << "vowel" << endl ;
else
cout << "consonant" << endl ;
return 0;
}
|
#include <bits/stdc++.h>
#define _overload(_1,_2,_3,name,...) name
#define _rep(i,n) _range(i,0,n)
#define _range(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define rep(...) _overload(__VA_ARGS__,_range,_rep,)(__VA_ARGS__)
#define _rrep(i,n) _rrange(i,n,0)
#define _rrange(i,a,b) for(int i=(int)(a)-1;i>=(int)(b);--i)
#define rrep(...) _overload(__VA_ARGS__,_rrange,_rrep,)(__VA_ARGS__)
#define _all(arg) begin(arg),end(arg)
#define uniq(arg) sort(_all(arg)),(arg).erase(unique(_all(arg)),end(arg))
#define bit(n) (1LL<<(n))
#ifdef DEBUG
#define dump(...) fprintf(stderr, __VA_ARGS__)
#else
#define dump(...)
#endif
template<class T>bool chmax(T &a, const T &b) { return (a<b)?(a=b,1):0;}
template<class T>bool chmin(T &a, const T &b) { return (b<a)?(a=b,1):0;}
using namespace std;
using ll=long long;
using vi=vector<int>;
using vll=vector<ll>;
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int inf = INT_MAX;
const ll INF = LLONG_MAX;
const ll MOD = 1000000007LL;
const int dx[4]={1,0,-1,0};
const int dy[4]={0,1,0,-1};
ll extgcd(ll a,ll b,ll& x,ll& y){x=1,y=0;ll g=a;if(b!=0) g=extgcd(b,a%b,y,x),y-=a/b*x;return g;}
ll ADD(const ll &a, const ll &b, const ll mod=MOD) { return (a+b)%mod;}
ll SUB(const ll &a, const ll &b, const ll mod=MOD) { return (a-b+mod)%mod;}
ll MUL(const ll &a, const ll &b, const ll mod=MOD) { return (1LL*a*b)%mod;}
ll DIV(const ll &a, const ll &b, const ll mod=MOD) {ll x,y; extgcd(b,mod,x,y);return MUL(a,(x+mod)%mod,mod);}
using R = long double;
R a, b, T;
bool check(R x){
R S;
if(a * tan(x) <= b){
S = a * b - a * a * tan(x) / 2;
}
else {
S = b * b * tan(PI/2 - x) / 2;
}
return T <= S;
}
int main(void){
cin.tie(0);
ios::sync_with_stdio(false);
cin >> a >> b >> T;
T /= a;
R S = a * b;
R lb = 0.0, ub = PI / 2;
rep(_, 1000){
R mid = (lb + ub) / 2;
if(check(mid)){
lb = mid;
}
else {
ub = mid;
}
}
lb *= 180 / PI;
cout.precision(10);
cout << fixed << lb << endl;
return 0;
}
| 0
| 58,945,330
|
#include <iostream>
#include <map>
#include <algorithm>
#include <string>
#include <vector>
#include <numeric>
#include <cmath>
#include <queue>
#include <iomanip>
#include <functional>
#define CHMAX(a,b) a = std::max(a,b)
#define CHMIN(a,b) a = std::min(a,b)
#define CHABS(a) a = std::abs(a)
#define COUT(a) std::cout << a << std::endl
#define CERR(a) std::cerr << a << std::endl
#define FOR(n) for(lli i = 0; i < n; i++)
using namespace std;
using lli = long long int;
using pll = pair<lli, lli>;
using tlll = tuple<lli, lli, lli>;
using vll = vector<lli>;
lli mod197 = 1000000007LL;
lli INF = 10000000000000;
template< typename T >
T extgcd(T a, T b, T& x, T& y) {
T d = a;
if (b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
}
else {
x = 1;
y = 0;
}
return d;
}
int main(void) {
int n, k;
cin >> n >> k;
COUT((k == 1 ? 0 : n - k));
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,c,k;
cin>>a>>b>>c>>k;
int need=0;
while(a>=b)
{
b*=2;
need++;
}
while(b>=c)
{
c*=2;
need++;
}
if(need<=k)
{
cout<<"Yes\n";
}
else
{
cout<<"No\n";
}
}
| 0
| 79,373,819
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N; cin >> N;
vector<int> X(N); for (auto &x : X) cin >> x;
int L; cin >> L;
vector<vector<int>> dp(N, vector<int>(17));
for (int a = 0; a < N; a++) {
auto it = upper_bound(begin(X), end(X), X[a]+L) - 1;
dp[a][0] = it - begin(X);
}
for (int i = 1; i <= 16; i++) {
for (int a = 0; a < N; a++) {
dp[a][i] = dp[dp[a][i-1]][i-1];
}
}
int Q; cin >> Q;
for (int i = 0; i < Q; i++) {
int a, b; cin >> a >> b; a--, b--;
if (a > b) swap(a, b);
int ans = 0;
for (int j = 16; j >= 0; j--) {
if (dp[a][j] < b) {
ans += 1 << j;
a = dp[a][j];
}
}
ans++;
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#include <array>
using namespace std;
using ULL = unsigned long long;
using UL = unsigned;
using LL = long long;
#define rep(i, n) for(UL i = 0; i < (n); i++)
struct Problem {
void Solve() {
LL a, b, c; cin >> a >> b >> c;
ULL K; cin >> K;
if (K % 2) swap(a, b);
cout << (a - b) << endl;
}
Problem();
};
int main() {
unique_ptr<Problem> p(new Problem());
p->Solve();
return 0;
}
Problem::Problem() {
cout << fixed << setprecision(10);
}
| 0
| 25,602,394
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y;
cin >> x >> y;
if(x % y == 0) {
cout << -1 << "\n";
} else {
cout << x << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define all(x) (x).begin(),(x).end()
using namespace std;
const int INF=1145141919,MOD=1e9+7;
const long long LINF=8931145141919364364,LMOD=998244353;
int main(){
int n; cin>>n;
int t[n+1]={}; rep(i,n){cin>>t[i+1],t[i+1]*=2;}
rep(i,n) t[i+1]+=t[i];
int v[n]; rep(i,n){cin>>v[i],v[i]*=2;}
int vv[n+1]={}; rep(i,n-1) vv[i+1]=min(v[i],v[i+1]);
int sp[40010]; rep(i,40010) sp[i]=INF;
rep(i,n){
for(int j=t[i];j<=t[i+1];j++){
sp[j]=min(sp[j],v[i]);
}
}
rep(i,40010){
rep(j,n+1){
sp[i]=min(sp[i],vv[j]+abs(i-t[j]));
}
}
double ans=0;
rep(i,t[n]){
ans+=min(sp[i],sp[i+1])+1.0*abs(sp[i]-sp[i+1])/2;
}
printf("%.10f\n",ans/4);
return 0;
}
| 0
| 18,973,203
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, M;
cin >> N >> M;
vector<string> A(N), B(M);
for (int i = 0; i < N; ++i) cin >> A.at(i);
for (int i = 0; i < M; ++i) cin >> B.at(i);
bool exist = false;
for (int ly = 0; ly < N; ++ly) {
for (int lx = 0; lx < N; ++lx) {
if (ly + M - 1 >= N || lx + M - 1 >= N) {
continue;
}
bool match = true;
for (int y = 0; y < M; ++y) {
for (int x = 0; x < M; ++x) {
if (A.at(ly + y).at(lx + x) != B.at(y).at(x)) {
match = false;
}
}
}
if (match) {
exist = true;
}
}
}
if (exist) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
const double eps = 1e-10;
const int MOD = 1000000007;
const int INF = 1000000000;
const ll LINF = 1ll<<50;
template<typename T>
void printv(const vector<T>& s) {
for(int i=0;i<(int)(s.size());++i) {
cout << s[i];
if(i == (int)(s.size())-1) cout << endl;
else cout << " ";
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
while(1) {
int n; cin >> n;
if(n == 0) break;
vi a(n);
for(int i=0;i<n;++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
int mi = INF;
for(int i=0;i<n-1;++i) {
mi = min(mi, a[i+1] - a[i]);
}
cout << mi << endl;
}
}
| 0
| 22,067,982
|
#include<iostream>
using namespace std;
int main(){
int i,j,n,min,swap,count=0;
int a[100];
cin >> n;
for (i=0;i<n;i++){
cin >> a[i];
}
for (i=0;i<n;i++){
min = i;
for (j=i;j<n;j++){
if (a[j]<a[min]){
min = j;
}
}
if (min > i){
swap = a[i];a[i] = a[min];a[min] = swap;
count++;
}
}
for (i=0;i<n;i++){
cout << a[i];
if (i<n-1){
cout << " ";
}
}
cout << endl << count << endl;
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 (ll i = m; i < n; ++i)
#define FORR(i, m, n) for (ll 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 n,m;cin >> n >> m;
vector<vector<ll>> x(n,vector<ll>(3));
REP(i,n){
REP(j,3){
cin >> x[i][j];
}
}
ll ans=0;
REP(i,1<<3){
vector<ll> p(n);
REP(j,n){
ll res=0;
REP(k,3){
res+=x[j][k]*(i&(1<<k)?1:-1);
}
p[j]=res;
}
sort(ALL(p));
reverse(ALL(p));
ll sum=0;
REP(j,m){
sum+=p[j];
}
chmax(ans,sum);
}
cout << ans << endl;
}
| 0
| 60,669,755
|
#pragma GCC optimize ("-O3","unroll-loops")
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<math.h>
#include<iomanip>
#include<set>
#include<numeric>
#include<cstring>
#include<cstdio>
#include<functional>
#include<bitset>
#include<limits.h>
#include<cassert>
#include<iterator>
#include<complex>
#include<stack>
#include<unordered_map>
#include<unordered_set>
#include<time.h>
#include <random>
using namespace std;
#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define FORR(i, m, n) for(int i = m;i >= n;i--)
#define SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v,n) reverse(v,v+n);
#define VREVERSE(v) reverse(v.begin(), v.end());
#define ll long long
#define pb(a) push_back(a)
#define print(x) cout<<x<<'\n';
#define pe(x) cout<<x<<" ";
#define lb(v,n) lower_bound(v.begin(), v.end(), n);
#define ub(v,n) upper_bound(v.begin(), v.end(), n);
#define int long long
#define all(x) (x).begin(), (x).end()
#define print_space(v) REP(i,v.size())cout << v[i] << ((i == v.size() - 1) ? "\n" : " ");
template<typename T1, typename T2> inline void chmin(T1 &a, T2 b) { if (a>b) a = b; }
template<typename T1, typename T2> inline void chmax(T1 &a, T2 b) { if (a<b) a = b; }
const int MOD = 1e9 + 7;
const ll INF = 1e17;
const int INT_INF = 1e9;
const double pi = acos(-1);
const double EPS = 1e-10;
typedef pair<int, int>P;
const int MAX = 200020;
bool vis[100010];
vector<int>G[100010];
int grundy(int n, int pre) {
if (n == 1) {
if (G[n].size() == 1) {
return 1;
}
else {
int res = 0;
for (auto nex : G[n]) {
res ^= (grundy(nex, n)+1);
}
return res;
}
}
else {
if (G[n].size() == 2) {
int res = 0;
for (auto nex : G[n]) {
if (nex == pre)continue;
res = grundy(nex, n);
}
res++;
return res;
}
else {
int res = 0;
for (auto nex : G[n]) {
if (nex == pre)continue;
res ^= (grundy(nex, n)+1);
}
return res;
}
}
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N; cin >> N;
REP(i, N-1) {
int x, y; cin >> x >> y;
G[x].pb(y);
G[y].pb(x);
}
ll res = grundy(1, -1);
if (res == 0) {
print("Bob");
}
else print("Alice");
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
set<string> s;
string w;
char c;
cin >> w;
s.insert(w);
c = w.at(w.size() - 1);
for (int i = 1; i < n; i++) {
string x;
cin >> x;
if (s.find(x) == s.end() && x.at(0) == c) {
s.insert(x);
c = x.at(x.size() - 1);
} else {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
}
| 0
| 89,130,404
|
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int N,K;
int a[60];
int total = 0;
cin >> N >> K;
for(int i=0;i<N;++i) cin >> a[i];
sort(a,a+N,greater<int>());
for(int i=0;i<K;++i){
total += a[i];
}
cout << total << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
string query(int n) {
cout << n << '\n' << flush;
string s; cin >> s;
if (s == "Vacant") exit(0);
return s;
}
int main() {
int n; cin >> n;
int l = 0;
int r = n - 1;
string L = query(l);
string R = query(r);
while (true) {
int m = (l + r) / 2;
R = query(m);
if (L == R) {
if (m % 2) r = m;
else l = m;
} else {
if (m % 2) l = m;
else r = m;
}
}
return 0;
}
| 0
| 99,077,104
|
#include <bits/stdc++.h>
#define ll long long
#define MODV 1000000007
#define INF INT_MAX
#define INFLL LLONG_MAX
#define rep(i, n) for(ll i=0, i##_len=(ll)(n); i<i##_len; i++)
#define repf(i, n) for(ll i=1, i##_len=(ll)(n+1); i<i##_len; i++)
#define per(i, n) for(ll i=((ll)(n))-1; i>=0; i--)
#define perf(i, n) for(ll i=((ll)(n)); i>0; i--)
#define all(v) v.begin(), v.end()
#define endl "\n"
#define vi vector<ll>
#define vvi vector<vector<ll>>
#define Yes() cout << "Yes" << endl
#define YES() cout << "YES" << endl
#define No() cout << "No" << endl
#define NO() cout << "NO" << endl
#define Init() std::ios::sync_with_stdio(false); std::cin.tie(0); std::cout<<fixed<<setprecision(15);
template<class T>bool chmax(T &a, const T &b){ if(a<b){ a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b){ if(b<a){ a=b; return 1; } return 0; }
using namespace std;
int main(){
Init();
ll n; cin >> n;
cout << (ll)((1+n)*(n/2.0)) << endl;
}
|
#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
#define rep(i,n) for (int i = 0;i < (n);i++)
#define all(v) v.begin(),v.end()
#define dec(n) cout << fixed << setprecision(n);
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using vl = vector<ll>;
using vvl = vector<vl>;
ll gcd(ll a,ll b){
if(b == 0) return a;
return gcd(b , a % b);
}
ll mod(ll a){
return (a % 1000000007);
}
ll lcm(ll a,ll b){
return (a*b)/gcd(a,b);
}
int main(){
ll l,r; cin >> l >> r; ll ans = 2018;
if(r-l <= 2019){
for(ll i=l; i <= r; i++){
for(ll j=l; j <= r; j++){
if(i != j){
ans = min(ans,(i*j) % 2019);
}
}
}
}
else{
for(ll i=l; i <= l+2019; i++){
for(ll j=l; j <= l+2019; j++){
if(i != j){
ans = min(ans,(i*j) % 2019);
}
}
}
}
cout << ans << endl;
}
| 0
| 93,367,149
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.size();
vector<long long> a(n+1, 0);
for(int i = 0; i < n; i++) {
if(s[i] == '<') {
a[i+1] = max(a[i]+1, a[i+1]);
}
}
for(int i = n-1; i >= 0; i--) {
if(s[i] == '>') {
a[i] = max(a[i], a[i+1]+1);
}
}
long long ans = 0;
for(auto au : a) {
ans += au;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
bool Check(vector<int> vec,int c){
for(int i=0;i<vec.size();i++){if(vec[i] == c) return false;}
return true;
}
int main(){
int N,M,a,b,ans=0; cin >> N >> M;
vector<vector<int>> data(N+1);
vector<int> one_case;
for(int i=0;i<M;i++){
cin >> a >> b;
if(Check(data.at(a),b)) data.at(a).push_back(b);
if(Check(data.at(b),a)) data.at(b).push_back(a);
}
for (int i=1;i<=N;i++) { one_case.emplace_back(i); }
do {
for(int i=0;i<N-1;i++){
if(one_case[0] != 1)break;
if(Check(data.at(one_case[i]),one_case[i+1]) == true) break;
if(i == N-2) ans++;
}
} while (next_permutation(one_case.begin(), one_case.end()));
cout << ans << endl;
}
| 0
| 51,038,814
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define ull unsigned long long
#define ld long double
#define vi vector<int>
#define vll vector<ll>
#define vc vector<char>
#define vs vector<string>
#define vpii vector<pii>
#define vpll vector<pll>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define repr(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rep1r(i, n) for (int i = ((int)(n)); i >= 1; i--)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define RSORT(x) sort(rall(x));
#define pb push_back
#define mp make_pair
#define INF (1e9)
#define PI (acos(-1))
#define EPS (1e-7)
ull gcd(ull a, ull b) { return b ? gcd(b, a % b) : a; }
ull lcm(ull a, ull b) { return a / gcd(a, b) * b; }
int main(){
int h1, m1, h2, m2, k;
cin >> h1 >> m1 >> h2 >> m2 >> k;
int t1 = h1 * 60 + m1, t2 = h2 * 60 + m2;
cout << (t2-k-t1) << endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <map>
#include <algorithm>
using namespace std;
typedef map<string, int> freqmap;
freqmap fm;
int main() {
string word;
while (cin >> word) {
fm[word]++;
}
string most_used;
int most_used_i = 0;
for (freqmap::iterator i = fm.begin(); i!= fm.end(); i++) {
if (most_used_i < (*i).second) {
most_used_i = (*i).second;
most_used = (*i).first;
}
}
cout << most_used << ' ';
string max_length;
int max_length_i = 0;
for (freqmap::iterator j = fm.begin(); j != fm.end(); j++) {
if (max_length_i < (*j).first.length()) {
max_length = (*j).first;
max_length_i = (*j).first.length();
}
}
cout << max_length << endl;
return 0;
}
| 0
| 51,531,891
|
#include <bits/stdc++.h>
using namespace std;
multiset<int>st;
int main(){
long long n;
cin >> n;
long long now = 1;
long long sum = 0;
while(sum < n){
sum+=now++;
}
long long diff = sum-n;
for(long long i = 1; i < now; ++i){
if(i != diff)printf("%lld\n", i);
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
const ll LINF = 1e18;
const int INF = 1e9;
const ll MOD = 1000000007;
template<class T> inline bool chmin(T& a, T b){
if(a > b){
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b){
if(a < b){
a = b;
return true;
}
return false;
}
int main(){
ll n, m;
cin >> n >> m;
ll ans = 0;
if(m >= n*2){
ans += n;
m -= 2*n;
n = 0;
if(m < 0) m = 0;
ans += m/4;
}
else{
ans += m/2;
}
cout << ans << endl;
return 0;
}
| 0
| 64,055,022
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int) (n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int) (n); i++)
#define _GLIBCXX_DEBUG
template <typename T>
bool chmax(T &a, const T& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool chmin(T &a, const T& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int n;
string s, t;
int main(){
cin >> n;
cin >> s >> t;
rep(i, n){
cout << s[i] << t[i];
}
cout << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main(){
int *x;
int _x[10];
x = _x;
int in = 0;
while(cin >> in){
if(!in){
cout << *(x-1) << endl;
x--;
}else{
*x = in;
x++;
}
}
}
| 0
| 60,117,978
|
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i=0;i<(n);++i)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define all(x) (x).begin(), (x).end()
#define PI 3.14159265358979323846264338327950L
using namespace std;
typedef long long ll;
typedef long double ld;
int main() {
int a,b,c;
cin>>a>>b>>c;
cout<<max(c-a+b,0);
}
|
#include<bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
#define REP(i, l, n) for(int i=(l), i##_len=(n); i<i##_len; ++i)
#define ALL(x) (x).begin(),(x).end()
#define pb push_back
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;}
char alpha[26] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int main(){
int n, k; cin >> n >> k;
string s; cin >> s;
int sum = 0;
int r = 1;
int ans = 0;
if(s[0] == '0'){
sum++;
}
REP(l, 0, n){
while(sum < k+1){
if(r == n){
break;
}else{
if(s[r-1] == '1' && s[r] == '0'){
sum++;
}
r++;
}
}
if(r == n){
if(s[n-1] == '0' && s[n-2] == '1'){
ans = max(ans, r-l-1);
}else{
ans = max(ans, r-l);
}
}else{
ans = max(ans, r-l-1);
}
if(l+1 < n && s[l] == '0' && s[l+1] == '1'){
sum--;
}
}
cout << ans << endl;
}
| 0
| 68,690,748
|
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
constexpr int DEBUG = 0;
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v) {
int len = v.size();
s << "[";
for (int i = 0; i < len; i++) {
if (i > 0) s << ", ";
s << v[i];
}
s << "]";
return s;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<pair<int, int64>> xs;
int64 total_sum = 0;
for (int i = 0; i < n; i++) {
int64 x;
cin >> x;
xs.push_back({i, x});
total_sum += x;
}
sort(xs.begin(), xs.end(), [](const auto& p1, const auto& p2) {
if (p1.second != p2.second) return p1.second > p2.second;
return p1.first < p2.first;
});
vector<int64> rs(n);
int index = xs[0].first;
if (index == 0) {
rs[0] = total_sum;
} else {
int64 sum = xs[0].second;
int64 used = 0;
for (int i = 1; i < n; i++) {
const auto& p = xs[i];
if (DEBUG) cout << p.first << " " << p.second << endl;
if (p.first < index) {
rs[index] = sum - (p.second * i) - used;
used += rs[index];
index = p.first;
if (index == 0) {
rs[0] = total_sum - used;
break;
}
}
sum += p.second;
}
}
for (int i = 0; i < n; i++) {
cout << rs[i] << "\n";
}
}
|
#include <bits/stdc++.h>
#include <boost/range/algorithm.hpp>
#include <boost/range/numeric.hpp>
#include <boost/integer/common_factor.hpp>
#include <boost/integer/common_factor_rt.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>
using std::string;
using std::vector;
using std::set;
using std::multiset;
using std::unordered_set;
using std::map;
using std::multimap;
using std::unordered_map;
using std::pair;
using std::cin;
using std::cout;
using boost::multiprecision::cpp_int;
using cpp_dec_float_1000 = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<1000, boost::int128_type>>;
typedef uintmax_t ull;
typedef intmax_t ll;
typedef uint64_t ul;
typedef uint32_t ui;
typedef uint8_t uc;
constexpr char CRLF = '\n';
constexpr char SPACE = ' ';
constexpr char VECTOR_COUT_SEPARATOR = SPACE;
constexpr ll INF = 1000'000'007;
constexpr int MOD = 1000'000'007;
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; }
template<class T> std::ostream& operator<< (std::ostream& os, const std::vector<T>& vc) { for(auto it = vc.begin(); it != vc.end(); ++it) { if (std::next(it) == vc.end()) os << *it; else os << *it << VECTOR_COUT_SEPARATOR; } return os; }
template<class T1, class T2> inline std::ostream & operator<< (std::ostream & os, const std::pair<T1, T2> & p) { return os << p.first << ' ' << p.second; }
template<class T> T modinv(T a, T m) { T b = m, u = 1, v = 0; while (b) { T t = a / b; a -= t * b; boost::swap(a, b); u -= t * v; boost::swap(u, v); } u %= m; if (u < 0) u += m; return u; }
template<class T> inline bool isSosuu(const T& n) { if (n == T(1)) { return false; } for (T i = 2; i*i <= n; ++i) { if (n % i == 0) { return false; } } return true; }
template<class T> vector<vector<T>> split (const vector<T>& S, T delim) { vector<vector<T>> ret{}; vector<T> buff{}; for (auto c : S) { if (c == delim) { if (!buff.empty()) ret.push_back(buff); buff.clear(); } else { buff.push_back(c); } } if (!buff.empty()) ret.push_back(buff); return ret; }
template<class T> inline void printYesNo(const T& t) { cout << (t ? "Yes" : "No") << CRLF; }
template<class T = int64_t> T modpow(T N, T P, T M) { T ret{1}; N %= M; while (P) { if (P & 0x01) { ret *= N; ret %= M; } P >>= 1; N *= N; N %= M; } return ret; }
int gErr = 0;
#define ASSERT(p) if(!(p)){ gErr = 1; }else{ ; }
struct Tmp
{
public:
int N;
Tmp(int N)
: N(N)
{}
};
void solve(void)
{
ll N; cin >> N;
ll res{};
for (ll k = 1; (k-1)*(k-1) <= N; ++k) {
if (N % k == 0) {
ll m = N / k;
if (k - 1 > 0 && (N % (k-1) != 0)) {
if (m < k - 1) {
res += k - 1;
}
}
if (m == k) { continue; }
if (m - 1 > 0 && (N % (m-1) != 0)) {
if (k < m - 1) {
res += m - 1;
}
}
}
}
cout << res << CRLF;
return;
}
int main(void)
{
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
solve();
return 0;
}
| 0
| 49,105,701
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int m, n;
scanf("%d%d", &n,&m);
if(n == 1 || m == 1) cout<<"1\n";
else{
long long c = ((long long)n*(long long)m + 1)*.5;
cout<<c<<'\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int H,W,N;
cin >> H >> W >> N;
int dx[9] = {-1,0,1,-1,0,1,-1,0,1};
int dy[9] = {1,1,1,0,0,0,-1,-1,-1};
vector<int> a(N),b(N);
set< pair<int,int> > s;
set< pair<int,int> > used;
for(int i=0;i<N;i++){
cin >> a[i] >> b[i];
s.insert(make_pair(a[i],b[i]));
}
ll ans[10];
for(int i=0;i<10;i++) ans[i] = 0;
for(int i=0;i<N;i++){
for(int j=0;j<9;j++){
int cx = b[i]+dx[j], cy = a[i]+dy[j];
if(cx<2||W-1<cx||cy<2||H-1<cy) continue;
if(used.count(make_pair(cy,cx)) == 1) continue;
int tmp=0;
for(int k=0;k<9;k++){
int nx = cx + dx[k], ny = cy + dy[k];
if(s.count(make_pair(ny,nx)) == 1)tmp++;
if(k == 8){
used.insert(make_pair(cy,cx));
ans[tmp]++;
}
}
}
}
ll sum = 0;
for(int i=0;i<10;i++) sum += ans[i];
printf("%lld\n",((ll)H-2) * ((ll)W-2) - sum );
for(int i=1;i<10;i++){
printf("%lld\n",ans[i]);
}
return 0;
}
| 0
| 29,474,365
|
#include <bits/stdc++.h>
using namespace std;
long long f(long long k){
return (k*(k-1))/2;
}
int main(){
long long n;
long long now=0;
cin>>n;
vector<long long> p(n,0);
long long a[n];
for(int i=0;i<n;i++){
cin>>a[i];
a[i]--;
p[a[i]]++;
}
for(int i=0;i<n;i++){
now+=f(p[i]);
}
for(int i=0;i<n;i++){
long long k=now;
k=k-f(p[a[i]])+f(p[a[i]]-1);
cout<<k<<endl;
}
}
|
#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
#include <map>
#include <iomanip>
#include <stdlib.h>
#include <queue>
using namespace std;
const int nmax = 1e9 + 7;
const long long INF = 1e18;
const double PI = 2 * asin(1);
typedef long long ll;
int main(){
int num[10] = {0,2,5,5,4,5,6,3,7,6};
vector < pair<int, int> > candidate;
int N, M; cin >> N >> M;
for (int i = 0; i < M; i++){
int A; cin >> A;
candidate.push_back(make_pair(A, num[A]));
}
sort(candidate.begin(), candidate.end(), greater< pair<int, int> >());
int DP[N + 1];
for (int i = 0; i < N + 1; i++){
DP[i] = 0;
}
for (int i = 0; i < candidate.size(); i++){
DP[candidate[i].second] = 1;
}
for (int i = 2; i < N + 1; i++){
if (DP[i] > 0){
for (int j = 0; j < candidate.size(); j++){
int num = candidate[j].second;
DP[i + num] = max(DP[i + num], DP[i] + 1);
}
}
}
int dig = DP[N], sum = N;
while (dig > 0){
for (int i = 0; i < candidate.size(); i++){
int now = candidate[i].second;
if (DP[sum - now] + 1 == DP[sum] && DP[sum] > 1){
cout << candidate[i].first;
sum -= now;
break;
}else if(DP[sum] == 1 && sum == now){
cout << candidate[i].first;
sum -= now;
break;
}
}
dig--;
}
cout << endl;
return 0;
}
| 0
| 47,447,445
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
double A, B;
cin >> A >> B;
for (int i = 1; i < 1e8; i++) {
if (floor(i * 0.08) == A && floor(i * 0.1) == B) {
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
|
#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 H, W;
cin>>H>>W;
vector<string> A(H);
for(int i=0;i<H;++i) cin>>A[i];
queue<tuple<int, int, int> > que;
for(int i=0;i<H;++i) {
for(int j=0;j<W;++j) {
if(A[i][j]=='#') que.push(make_tuple(i, j, 0));
}
}
tuple<int, int, int> state;
int x, y, cost;
int ans = 0;
while(!que.empty()) {
state = que.front();que.pop();
x = get<0>(state);
y = get<1>(state);
cost = get<2>(state);
ans = max(ans, cost);
if(x>0 && A[x-1][y]=='.') {
A[x-1][y] = '#';
que.push(make_tuple(x-1, y, cost+1));
}
if(x<H-1 && A[x+1][y]=='.') {
A[x+1][y] = '#';
que.push(make_tuple(x+1, y, cost+1));
}
if(y>0 && A[x][y-1]=='.') {
A[x][y-1] = '#';
que.push(make_tuple(x, y-1, cost+1));
}
if(y<W-1 && A[x][y+1]=='.') {
A[x][y+1] = '#';
que.push(make_tuple(x, y+1, cost+1));
}
}
cout<<ans<<endl;
}
| 0
| 17,790,718
|
#include "bits/stdc++.h"
using namespace std;
int main() {
long long N;
cin >> N;
vector<long long>H(N);
long long MAX = -1;
for (long long i = 0; i < N; i++) {
cin >> H.at(i);
}
long long ans = 0;
for (long long i = 0; i < 200; i++) {
long long num = 0;
bool check = false;
for (long long j = 0; j < N; j++) {
if (H.at(j) > 0) check = true;
}
if (!check) {
cout << ans << endl;
return 0;
}
if (H.at(0) > 0) {
num++;
}
for (long long j = 1; j < N; j++) {
if (H.at(j - 1) <= 0 && H.at(j) > 0) {
num++;
}
H.at(j - 1)--;
}
H.at(N - 1)--;
ans += num;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, start, n) for (ll i = (ll)(start); i < (ll)(n); ++i)
static const ll INFTY = 1L << 62L;
ll solver(string S, ll K)
{
ll ans = 0, tmp = 0;
bool flag = true;
rep(i, 0, S.size() - 1)
{
if (S[i] != S[i + 1])
{
flag = false;
break;
}
}
if (flag)
ans = S.size() * K / 2;
else
{
ll front = 0, back = S.size() - 1, cnt = 0;
if (S.front() == S.back())
{
rep(i, 1, S.size())
{
if (S.front() != S[i])
{
front = i;
break;
}
}
for (int i = S.size() - 2; i >= 0; --i)
{
++cnt;
if (S.back() != S[i])
{
back = i;
break;
}
}
ans = (front + cnt) / 2 * (K - 1);
rep(i, 0, front)
{
if (S[i] == S[i + 1])
{
++ans;
++i;
}
}
rep(i, back + 1, S.size())
{
if (S[i] == S[i + 1])
{
++ans;
++i;
}
}
}
rep(i, front, back)
{
if (S[i] == S[i + 1])
{
++tmp;
++i;
}
}
ans += tmp * K;
}
return ans;
}
int main()
{
string S;
ll K;
cin >> S >> K;
cout << solver(S, K) << endl;
}
| 0
| 3,207,562
|
#include <bits/stdc++.h>
using namespace std;
#define m_p make_pair
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
mt19937 rnf(2106);
const int N = 200005;
int n;
int a[N];
int q[N];
bool solv()
{
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i)
q[a[i]]++;
int minu;
if (a[n] % 2 == 1)
{
for (int i = a[n]; i >= (a[n] / 2) + 1; --i)
{
if (q[i] < 2)
return false;
q[i] -= 2;
}
minu = (a[n] / 2) + 2;
}
else
{
for (int i = a[n]; i >= (a[n] / 2) + 1; --i)
{
if (q[i] < 2)
return false;
q[i] -= 2;
}
if (q[a[n] / 2] < 1)
return false;
q[a[n] / 2] -= 1;
minu = (a[n] / 2) + 1;
}
for (int i = 1; i < minu; ++i)
{
if (q[i])
return false;
}
return true;
}
int main()
{
#ifdef SOMETHING
freopen("input.txt", "r", stdin);
#endif
if (solv())
printf("Possible\n");
else
{
while ((double)clock() / CLOCKS_PER_SEC <= 0.9){}
printf("Impossible\n");
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll n, xi[1010], yi[1010], c[2], m, ans[40];
ll dx[]={1,-1,0,0};
ll dy[]={0,0,1,-1};
char ch[]={'R','L','U','D'};
void fuck(ll x,ll y,ll w){
if (w>m) return;
ll mn=1e100, d;
for (int i=0;i<4;++i){
ll t=abs(x+dx[i]*ans[w])+abs(y+dy[i]*ans[w]);
if (t<mn) mn=t, d=i;
}
putchar(ch[d]);
fuck(x+dx[d]*ans[w],y+dy[d]*ans[w],w+1);
}
int main(){
cin>>n;
for (int i=1;i<=n;++i){
cin>>xi[i]>>yi[i];
c[(xi[i]+yi[i])&1]++;
}
if (c[0]&&c[1]) return puts("-1"), 0;
for (int i=31;i>=0;--i)
ans[++m]=1ll<<i;
if (c[0]) ans[++m]=1;
cout<<m<<endl;
for (int i=1;i<=m;++i) cout<<ans[i]<<' ';
cout<<endl;
for (int i=1;i<=n;++i){
fuck(-xi[i],-yi[i],1);
puts("");
}
}
| 0
| 63,947,741
|
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
#include "ctime"
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(begin, i, end) for (int i = begin; i < (int)(end); i++)
#define all(v) v.begin(), v.end()
const int MOD = 1000000007;
int main()
{
ll N, K;
cin >> N >> K;
vector<ll> l(N);
rep(0, i, N)
{
cin >> l.at(i);
}
sort(all(l));
reverse(all(l));
ll ans = 0;
rep(0, i, K)
{
ans += l.at(i);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define int long long
const int N=2e5+5;
int n;
int a[N];
bool inc(int k, vector<pair<int, int> > &v)
{
vector<pair<int, int> > temp;
int cur=0;
while(v.size() && v.back().first==k)
{
temp.push_back(v.back());
v.pop_back();
}
if(!v.size())
return 0;
if(v.back().second>=2)
{
v[v.size()-1].second-=1;
int cur=v.back().first;
v.push_back({cur+1, 1});
}
else
v[v.size()-1].first+=1;
while(temp.size())
{
v.push_back({1, temp.back().second});
temp.pop_back();
}
return 1;
}
int check(int k)
{
vector<pair<int, int> > v;
v.push_back({1, a[1]});
int len=a[1];
for(int i=2;i<=n;i++)
{
int sz=v.size();
if(a[i]>a[i-1])
v.push_back({1, a[i]-a[i-1]});
else if(a[i]==a[i-1])
{
if(!inc(k, v))
return 0;
}
else
{
while(v.size())
{
if(len-v.back().second>=a[i])
{
len-=v.back().second;
v.pop_back();
}
else
break;
}
v[v.size()-1].second-=(len-a[i]);
if(!inc(k, v))
return 0;
}
len=a[i];
}
return 1;
}
int binsearch(int lo, int hi)
{
while(lo<hi)
{
int mid=(lo+hi)/2;
if(check(mid))
hi=mid;
else
lo=mid+1;
}
return lo;
}
int32_t main()
{
IOS;
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
int ans=binsearch(1, n);
cout<<ans;
return 0;
}
| 0
| 7,725,869
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<iomanip>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define PI 3.141592653589793238
#define INF 1050000000
using vi = vector<int>;
int main() {
vector<vector<char>> C(2, vector<char>(3));
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cin >> C[i][j];
}
}
if (C[0][0] != C[1][2] || C[0][1] != C[1][1] || C[0][2] != C[1][0]) {
cout << "NO" << endl;
} else{
cout << "YES" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
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];
}
sort(x.begin(),x.end());
sort(y.begin(),y.end());
if(x[N-1] < y[0]) {
if(y[0] > X && x[N-1] < Y) {
cout << "No War" << endl;
return 0;
}
}
cout << "War" << endl;
}
| 0
| 73,669,979
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, n) for (int i = (n); i >= 0; --i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define FORR(i, m, n) for (int i = (m); i >= (n); --i)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
const int inf = 1e9 + 10;
const ll INF = 1e18;
const ld EPS = 1e-10;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(25);
string s;
cin >> s;
int ans = 0, res = 0;
rep(i, 3) {
if (s[i] == 'S') res = 0;
else res++;
chmax(ans, res);
}
cout << ans << '\n';
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define test int t; cin>>t; while(t--)
vector<int>arr[200001];
int vis[200001],di[200001];
void bfs(int root)
{
queue<int> que;
que.push(root);
di[root] = 0;
vis[root] = 1;
while (!que.empty()) {
root = que.front();
que.pop();
for (int i = 0; i < arr[root].size(); i++) {
int b = arr[root][i];
if (!vis[b]) {
que.push(b);
di[b] = di[root] + 1;
vis[b] = 1;
}
}
}
}
int main()
{
int n,m,a,b;
cin>>n>>m;
for(int i=0;i<m;i++)
{
cin>>a>>b;
arr[a].push_back(b);
arr[b].push_back(a);
}
bfs(1);
if(di[n]>2 || di[n]==0)
{
cout<<"IMPOSSIBLE"<<endl;
}
else cout<<"POSSIBLE"<<endl;
}
| 0
| 34,077,391
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,n,counter=0;
cin>>N;
vector<int>vec(N);
for(int i=0;i<N;i++){
cin>>vec.at(i);
}
for(int i=0;i<N;i++){
if(i==0){
if(vec.at(i)==2)
break;
n=vec.at(i);
counter++;
}
else if(i<N-1){
if(vec.at(n-1)==2){
break;
}
else{
n=vec.at(n-1);
counter++;
}
}
else if(i==N-1)
counter = -2;
}
cout<<counter+1<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef vector<PII> VP;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define pb push_back
#define paired make_pair
#define ALL(a) (a).begin(),(a).end()
#define PRINT(V) for (auto v : (V)) cout << v << " "
#define SORT(V) sort((V).begin(),(V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
int QP(int a,int b){int ans=1;do{if(b&1)ans=1ll*ans*a%MOD;a=1ll*a*a%MOD;}while(b>>=1);return ans;}
int QP(int a,int b,int MOD){int ans=1;do{if(b&1)ans=1ll*ans*a%MOD;a=1ll*a*a%MOD;}while(b>>=1);return ans;}
int GCD(int a,int b){return b?GCD(b,a%b):a;}
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
int N,M;
VI Vec;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
int N, K; cin>>N>>K;
cout << N-K+1<<endl;
return 0;
}
| 0
| 36,524,530
|
#include <bits/stdc++.h>
#define ll long long
#define MODV 1000000007
#define INF INT_MAX
#define INFLL LLONG_MAX
#define rep(i, n) for(ll i=0, i##_len=(ll)(n); i<i##_len; i++)
#define repf(i, n) for(ll i=1, i##_len=(ll)(n+1); i<i##_len; i++)
#define per(i, n) for(ll i=((ll)(n))-1; i>=0; i--)
#define perf(i, n) for(ll i=((ll)(n)); i>0; i--)
#define all(v) v.begin(), v.end()
#define endl "\n"
#define vi vector<ll>
#define vvi vector<vector<ll>>
#define Yes() cout << "Yes" << endl
#define YES() cout << "YES" << endl
#define No() cout << "No" << endl
#define NO() cout << "NO" << endl
template<class T>bool chmax(T &a, const T &b){ if(a<b){ a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b){ if(b<a){ a=b; return 1; } return 0; }
using namespace std;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
ll x, y; cin >> x >> y;
cout << x+(y/2) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1e18;
#define rep(i, n) for (int i = 0; i < n; i++)
using Graph = vector<vector<int>>;
using pint = pair<int, int>;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dxx[8] = {1, 1, 1, 0, 0, -1, -1, -1}, dyy[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
int main() {
priority_queue<int> pq;
int x;
string s;
while (1) {
cin >> s;
if (s == "end") break;
if (s == "insert") {
cin >> x;
pq.push (x);
} else {
x = pq.top();
pq.pop();
cout << x << "\n";
}
}
}
| 0
| 1,533,988
|
#include <bits/stdc++.h>
#include <math.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rrep(i, n) for(int i = 0; i <= (n); i++)
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
const ll INF = 1LL<<60;
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 Graph = vector<vector<int>>;
typedef pair<int, int> P;
int main(){
int X, Y, A, B, C; cin >> X >> Y >> A >> B >> C;
vector<ll> p(A), q(B), r(C);
rep (i,A) cin >> p[i];
rep (i,B) cin >> q[i];
rep (i,C) cin >> r[i];
sort(p.rbegin(), p.rend());
sort(q.rbegin(), q.rend());
vector<int> d;
rep(i,X) d.push_back(p[i]);
rep(i,Y) d.push_back(q[i]);
rep(i,C) d.push_back(r[i]);
sort(d.rbegin(), d.rend());
ll ans = 0;
rep(i,X+Y) ans += d[i];
cout << ans << endl;
}
|
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for(int i = 0; (i) < (n); (i)++)
#define FOR(i, m, n) for(int i = (m); (i) < (n); (i)++)
#define All(v) (v).begin(), (v).end()
#define MP make_pair
#define pb push_back
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1 << 30;
const ll LINF = 1LL << 61;
const int MOD = 1e9 + 7;
int main() {
int N;
cin >> N;
using pii = pair<ll, ll>;
vector<pii> AB(N);
rep(i, N) {
ll a, b;
cin >> a >> b;
AB[i] = MP(a, b);
}
sort(All(AB), [](const pii &a, const pii &b) {
return a.first + a.second > b.first + b.second;
});
ll T = 0, A = 0;
rep(i, N) {
if(i % 2 == 0)
T += AB[i].first;
else
A += AB[i].second;
}
cout << T - A << endl;
return 0;
}
| 0
| 97,430,383
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = (long long)(0); i < (long long)(n); ++i)
#define reps(i, n) for (long long i = (long long)(1); i <= (long long)(n); ++i)
#define rrep(i, n) for (long long i = ((long long)(n)-1); i >= 0; i--)
#define rreps(i, n) for (long long i = ((long long)(n)); i > 0; i--)
#define irep(i, m, n) for (long long i = (long long)(m); i < (long long)(n); ++i)
#define ireps(i, m, n) for (long long i = (long long)(m); i <= (long long)(n); ++i)
#define SORT(v, n) sort(v, v + n);
#define REVERSE(v, n) reverse(v, v+n);
#define vsort(v) sort(v.begin(), v.end());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout<<d<<endl;
#define coutd(d) cout<<std::setprecision(10)<<d<<endl;
#define cinline(n) getline(cin,n);
#define replace_all(s, b, a) replace(s.begin(),s.end(), b, a);
#define PI (acos(-1))
#define FILL(v, n, x) fill(v, v + n, x);
#define sz(x) long long(x.size())
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vs = vector<string>;
using vpll = vector<pair<ll, ll>>;
using vtp = vector<tuple<ll,ll,ll>>;
using vb = vector<bool>;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const ll INF = 1e9;
const ll MOD = 1e9+7;
const ll LINF = 1e18;
signed main()
{
cin.tie( 0 ); ios::sync_with_stdio( false );
ll n; cin>>n;
string s; cin>>s;
ll l=0;
rep(i,n){
if(s[i]=='(') l++;
else{
l=max(l-1,0LL);
}
}
rep(i,l) s.push_back(')');
n=s.size();
ll r=0;
rrep(i,n){
if(s[i]==')') r++;
else{
r=max(r-1,0LL);
}
}
if(r){
string tmp=string(r,'(');
s=tmp+s;
}
cout<<s<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T, class U> using Pa = pair<T, U>;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll N,X;
cin >> N >> X;
vec<ll> P(N+1,1),L(N+1,1);
for(int i=1;i<=N;i++){
P[i] = 2*P[i-1]+1;
L[i] = 2*L[i-1]+3;
}
auto dfs = [&](auto&& self,ll x,int level)->ll{
if(!level) return 1;
if(x==1) return 0;
ll res = x>=(L[level-1]+2);
if(1<x && x<=L[level-1]+1) res += self(self,x-1,level-1);
else if(x==L[level-1]+2) res += P[level-1];
else if(x<=L[level]-1) res += P[level-1]+self(self,x-L[level-1]-2,level-1);
else res += 2*P[level-1];
return res;
};
cout << dfs(dfs,X,N) << "\n";
}
| 0
| 69,578,647
|
#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
int abs(int a,int b){
int c=max(a,b)-min(a,b);
return c;
}
priority_queue<int, vector<int>, greater<int> > qu;
signed main(){
cin.tie(NULL);
ios::sync_with_stdio(false);
int a,b,c;
int d=0,e=0;
cin>>a>>b>>c;
for(int i=0;i<c;i++){
if(i%2==0){
if(a%2==1) a--;
a/=2;
b+=a;
}
else{
if(b%2==1) b--;
b/=2;
a+=b;
}
}
cout<<a<<" "<<b<<"\n";
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int N; cin >> N;
vector<ll> x(N); for(int i=0;i<N;i++) cin >> x[i];
ll L; cin >> L;
ll tmp=0;
int y[N];
int j=0;
for(int i=0;i<N;i++){
int ind=upper_bound(x.begin(),x.end(),x[i]+L)-x.begin();
if(ind>=N) ind=N;
y[i]=ind-1;
}
int dp[30][N];
for(int i=0;i<N;i++){
dp[0][i]=y[i];
}
for(int i=0;i<29;i++){
for(int j=0;j<N;j++){
dp[i+1][j]=dp[i][dp[i][j]];
}
}
int Q; cin >> Q;
while(Q--){
int a,b; cin >> a >> b;
a--; b--;
if(b<a) swap(a,b);
ll ans=0;
for(int i=29;i>=0;i--){
if(dp[i][a]<b){
a=dp[i][a];
ans+=(1<<i);
}
}
if(a==b) cout << ans << endl;
else cout << ans+1 << endl;
}
}
| 0
| 45,462,298
|
#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;
}
D getExpectation(D x) {
return perform(x)/x;
}
int main()
{
cin>>N;
set<Int> s;
bool found=false;
Int pos=1;
while(!found){
s.insert(N);
if(N&1) N=3*N+1;
else N/=2;
pos++;
if(s.count(N)) break;
}
cout<<pos<<"\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (a[n - 1] != 2) {
cout << -1 << '\n';
return 0;
}
vector<long long> mn(n + 1, 2), mx(n + 1, 2);
for (int i = n - 1; i >= 0; i--) {
mn[i] = mn[i + 1];
mx[i] = mx[i + 1] + a[i] - 1;
if (i > 0) {
mn[i] += a[i - 1] - 1;
mn[i] /= a[i - 1];
mn[i] *= a[i - 1];
mx[i] /= a[i - 1];
mx[i] *= a[i - 1];
}
if (mn[i] > mx[i]) {
cout << -1 << '\n';
return 0;
}
}
cout << mn[0] << " " << mx[0] << '\n';
return 0;
}
| 0
| 90,444,586
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
#define sz(x) ((int)(x).size())
using ll=long long;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
#define MOD 1000000007
const ll INF=1e18;
template<class T>void show(vector<T>v){for (int i = 0; i < v.size(); i++){cerr<<v[i]<<" ";}cerr<<endl;}
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b){ a = b; return 1; } return 0; }
int main(int argc, char const *argv[]) {
ll x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
vector<ll> p(a),q(b),r(c),al;
rep(i,a){
cin >> p[i];
}
rep(i,b){
cin >> q[i];
}
rep(i,c){
cin >> r[i];
al.pb(r[i]);
}
sort(all(p));
sort(all(q));
reverse(all(p));
reverse(all(q));
rep(i, x) al.pb(p[i]);
rep(i, y) al.pb(q[i]);
sort(all(al));
reverse(all(al));
ll ans = 0;
rep(i, x + y) ans += al[i];
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <numeric>
#include <iomanip>
using namespace std;
using ll = long long;
#define rep(i, j, n) for(int i = (j); i < (n); ++i)
#define rrep(i, j, n) for(int i = (n) - 1; (j) <= i; --i)
constexpr ll MOD = 1000000007;
constexpr ll INF = 1LL << 60;
int main() {
cin.tie(0); ios_base::sync_with_stdio(false);
ll x, y;
cin >> x >> y;
ll unko = INF;
if (x <= y) unko = min(unko, y - x);
if (-x <= y) unko = min(unko, x + y + 1);
if (x <= -y) unko = min(unko, -x - y + 1);
if (-x <= -y) unko = min(unko, x - y + 2);
cout << unko;
return 0;
}
| 0
| 78,787,814
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
int A[100000];
rep(i, N) cin >> A[i];
int k = 0;
vector<int> V, V2;
V.pb(0);
rep(i, N) {
if (A[i] > k) {
V.pb(A[i]);
V2.pb(i);
k = A[i];
}
}
ll B[100001] = {};
int C[100001] = {};
rep(i, N) {
int k2 = lower_bound(V.begin(), V.end(), A[i]) - V.begin();
B[k2] += A[i] - V[k2 - 1];
C[k2]++;
}
int mae = V.back();
ll l = C[(int)V.size()];
ll kotae[100001] = {};
for (int k = (int)V.size() - 2; k >= 0; k--) {
kotae[V2[k]] = B[k + 1] + l * (mae - V[k]);
mae = V[k];
l += C[k + 1];
}
rep(i, N) co(kotae[i]);
Would you please return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define between(a,x,b) ((a)<=(x)&&(x)<=(b))
using namespace std;
int main(){
int n, a, b, c, x, y[100];
while(scanf("%d%d%d%d%d",&n,&a,&b,&c,&x) && (n||a||b||c||x)){
rep(i, n) scanf("%d", y+i);
int i = 0, res = 0;
if(y[i] == x) i++;
while(i < n){
x = (a * x + b) % c;
if(y[i] == x) i++;
res++;
if(res > 10000) break;
}
if(res <= 10000) printf("%d\n", res);
else puts("-1");
}
return 0;
}
| 0
| 42,779,090
|
#include<bits/stdc++.h>
#define rep(i,a,n) for(ll i=a;i<n;i++)
using namespace std;
typedef long long ll;
int main(){
ll n;
cin>>n;
ll a[n],num[n+1];
rep(i,0,n+1)num[i]=0;
rep(i,0,n){
cin>>a[i];
num[a[i]]++;
}
ll sum=0;
rep(i,1,n+1){
if(num[i]>=2){
rep(j,1,num[i])sum+=j;
}
}
rep(i,0,n){
if(a[i])cout<<sum-num[a[i]]+1<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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();}
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef vector<vector<long long>> VVL;
typedef vector<string> VS;
typedef pair<int, int> P;
typedef tuple<int,int,int> tpl;
#define ALL(a) (a).begin(),(a).end()
#define SORT(c) sort((c).begin(),(c).end())
#define REVERSE(c) reverse((c).begin(),(c).end())
#define LB(a,x) lower_bound((a).begin(), (a).end(), x) - (a).begin()
#define UB(a,x) upper_bound((a).begin(), (a).end(), x) - (a).begin()
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RFOR(i,a,b) for(int i=(a)-1;i>=(b);--i)
#define RREP(i,n) RFOR(i,n,0)
#define en "\n"
constexpr double EPS = 1e-9;
constexpr double PI = 3.141592653589793238462643383279;
constexpr int INF = 2147483647;
constexpr long long LINF = 1LL<<60;
constexpr long long MOD = 1000000007;
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
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; }
int main(void){
ll N,K; cin >> N >> K;
VL H(N+1,0); REP(i,N) cin >> H[i+1];
if(N == K){
cout << 0 << en;
return 0;
}
ll dp[N+1][K+1]; REP(i,N+1)REP(j,K+1) dp[i][j] = LINF;
dp[0][0] = 0;
REP(i,N)REP(j,K+1){
REP(k,i+1){
if(i-k < 0 || j-k < 0) break;
chmin(dp[i+1][j], dp[i-k][j-k] + max((ll)0, H[i+1]-H[i-k]));
}
}
ll ans = LINF;
REP(i,K+1) chmin(ans, dp[N-i][K-i]);
cout << ans << en;
return 0;
}
| 0
| 72,212,916
|
#include <iostream>
#include <string>
#include <algorithm>
#include <functional>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <cstdio>
#include <cmath>
#include <tuple>
#include <iomanip>
#include <numeric>
#include <unordered_map>
#include <sstream>
#include<limits.h>
#include<float.h>
#include<list>
#include <array>
#include <complex>
#include<stdio.h>
#include<string.h>
using namespace std;
#define int long long
#define I32_MAX 2147483647
#define I64_MAX 9223372036854775807LL
#define I64_MAX2 1223372036854775807LL
#define INF I64_MAX2
#define MOD 1000000007
#define MEM_SIZE 10000
#define DEBUG_OUT true
#define ALL(x) (x).begin(),(x).end()
template<typename T> void DEBUG(T e){if(DEBUG_OUT == false)return; std::cout << e << std::endl;}
template<typename T> void DEBUG(const std::vector<T>& v){if(DEBUG_OUT == false)return;for(const auto& e : v){std::cout<< e << " "; } std::cout << std::endl;}
template<typename T> void DEBUG(const std::vector<std::vector<T> >& vv){if(DEBUG_OUT == false)return;for(const auto& v : vv){ DEBUG(v); } }
template<class T,class X> void DEBUG(X d, T e){if(DEBUG_OUT == false)return;std::cout <<d<<" ";DEBUG(e);};
template <class T> void corner(bool flg, T hoge) {if (flg) {cout << hoge << endl; exit(0);}}
template< typename T1, typename T2 > inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template< typename T1, typename T2 > inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
template< typename T > using matrix = vector< vector< T > >;
void solve(void)
{
int K;
cin>>K;
vector<int> vec(K);
for (int i = 0; i < K; i++)
{
cin>>vec[i];
}
reverse(ALL(vec));
if(vec[0] != 2)
{
cout<<-1<<endl;
return;
}
int L = 2,R = 3;
for (int i = 0; i < K; i++)
{
int A = vec[i];
L = ceil(double(L)/double(A))*A;
R = floor(double(R-1)/double(A))*A + A ;
if(L >= R)
{
cout<<-1<<endl;
return;
break;
}
}
cout<<L<<" "<<R-1<<endl;
return;
}
int32_t main(int32_t argc, const char *argv[])
{
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout << std::fixed;
std::cout << std::setprecision(9);
solve();
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define srep(i,s,t) for (int i = s; i < t; ++i)
using namespace std;
typedef long long int ll;
typedef pair<int,int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
#define dame { puts("-1"); return 0;}
#define yn {puts("Yes");}else{puts("No");}
#define MAX_N 200005
vector<int> x;
int a[MAX_N],b[MAX_N];
vector<int> G[MAX_N];
int f[MAX_N][2];
int main() {
int n;
cin >> n;
x.push_back(-1);
srep(i,1,n+1){
int x_; cin >> x_;
x.push_back(x_);
}
int l,q;
cin >> l >> q;
rep(i,q){
cin >> a[i] >> b[i];
if(a[i]>b[i])swap(a[i],b[i]);
}
srep(i,1,n+1){
if(f[i][0] == 0){
f[i][0] = i;
G[i].push_back(i);
int now = i;
int day = 1;
while(true){
int ma = x[now] + l;
int ite;
int l = now+1;
int r = n;
while(true){
if(x[n]<=ma){
ite = n;
break;
}
int mid = (l+r)/2;
if(x[mid]<=ma){
l = mid;
}else{
r = mid;
}
if(l+1==r){
ite = l;
break;
}
}
if(ite == n){
if(f[n][0]==0){
f[n][0] = i;
f[n][1] = day;
G[i].push_back(n);
break;
}else{
G[i].push_back(n);
break;
}
}else{
now = ite;
if(f[now][0]==0){
f[now][0] = i;
f[now][1] = day;
G[i].push_back(now);
day++;
}else{
G[i].push_back(now);
break;
}
}
}
}
}
rep(i,q){
int day = 0;
int now[2];
now[0] = f[a[i]][0];
now[1] = f[a[i]][1];
while(true){
int j = now[0];
int k = now[1];
if(G[j][G[j].size()-1] < b[i]){
day += G[j].size() - 1 - k;
now[0] = f[G[j][G[j].size()-1]][0];
now[1] = f[G[j][G[j].size()-1]][1];
}else{
break;
}
}
while(true){
if(G[now[0]].size() - now[1] > 13){
if(G[now[0]][now[1]+10]<b[i]){
day += 10;
now[1] += 10;
continue;
}
}
if(G[now[0]][now[1]+1]<b[i]){
day++;
now[1]++;
}else{
day++;
break;
}
}
cout << day << endl;
}
return 0;
}
| 0
| 32,970,762
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main(void){
string s;
cin >> s;
int ans = 4;
if(s=="RRS" || s=="SRR") ans = 2;
else if(s=="RSS"||s=="SRS"||s=="SSR"||s=="RSR") ans = 1;
else if(s=="SSS") ans = 0;
else ans = 3;
cout << ans << endl;
return 0;
}
|
#ifndef CLion
#pragma GCC optimize ("O3")
#endif
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/numeric>
#define F first
#define S second
#define pb push_back
#define ll long long
#define all(x) x.begin() , x.end()
#define rep(i,s,e) for (int i = s; i < e; ++i)
#define rev(i,s,e) for (int i = s; i > e; --i)
#define mem(a,v) memset(a , v , sizeof a)
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
template<typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag,
tree_order_statistics_node_update>;
void Main(int cse , bool last){
int n; cin >> n;
vector<ll> vec(n);
for ( ll& i : vec ) cin >> i;
vec.pb(-1);
ll cnt = 1000 , buy = -1;
rep(i,1,n+1){
if ( vec[i] >= vec[i - 1] ){
if (buy == -1) buy = vec[i - 1];
}
else if ( ~buy ){
ll div = cnt / buy;
cnt -= div * buy;
cnt += div * vec[i - 1];
buy = vec[i];
}
}
cout << cnt;
}
int main(){
#ifndef CLion
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#endif
#ifdef CLion
freopen( "in.txt" , "r" , stdin );
clock_t st = clock();
#endif
int t = 1;
for ( int cse = 1; cse <= t; ++cse ) Main(cse, cse == t);
#ifdef CLion
clock_t en = clock();
cout << "\n\nTime: " << fixed << (en - st - 0.0) / CLOCKS_PER_SEC;
#endif
return 0;
}
| 0
| 14,962,659
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define space putchar(' ')
#define enter putchar('\n')
#define eps 1e-10
#define MAXN 100005
using namespace std;
typedef long long int64;
typedef unsigned int u32;
typedef double db;
template<class T>
void read(T &res) {
res = 0;T f = 1;char c = getchar();
while(c < '0' || c > '9') {
if(c == '-') f = -1;
c = getchar();
}
while(c >= '0' && c <= '9') {
res = res * 10 +c - '0';
c = getchar();
}
res *= f;
}
template<class T>
void out(T x) {
if(x < 0) {x = -x;putchar('-');}
if(x >= 10) {
out(x / 10);
}
putchar('0' + x % 10);
}
const int MOD = 1000000007;
int T[MAXN],A[MAXN];
int N;
int mul(int a,int b) {
return 1LL * a * b % MOD;
}
void Solve() {
read(N);
for(int i = 1 ; i <= N ; ++i) read(T[i]);
for(int i = 1 ; i <= N ; ++i) read(A[i]);
int ans = 1;
for(int i = 1 ; i <= N ; ++i) {
if(T[i] != T[i - 1] || A[i] != A[i + 1]) {
int a = -1,b = -1;
if(T[i] != T[i - 1]) a = T[i];
if(A[i] != A[i + 1]) b = A[i];
if(a != -1 && b != -1) {
if(a != b) {puts("0");return;}
}
if(b > T[i]) {puts("0");return;}
if(a > A[i]) {puts("0");return;}
}
else {
ans = mul(ans,min(A[i],T[i]));
}
}
out(ans);enter;
}
int main() {
#ifdef ivorysi
freopen("f1.in","r",stdin);
#endif
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N=1e5+10;
int a[N],p[N];
ll sum[N],ans[N];
int main()
{
int n;
scanf("%d",&n);
for (int i=1;i<=n;i++) {
scanf("%d",&a[i]);
p[i]=i;
}
sort(p+1,p+n+1,[&](const int &i,const int &j){ return a[i]>a[j] || a[i]==a[j] && i<j; });
ll now=0;
int pos=1;
int i=p[pos];
ll sum=0;
while (i) {
while (pos<=n && p[pos]>=i) {
sum+=a[p[pos]];
++pos;
}
ll tmp=1LL*(pos-1)*a[p[pos]];
ans[i]+=sum-tmp;
sum=tmp;
i=p[pos];
}
for (int i=1;i<=n;i++) {
printf("%lld\n",ans[i]);
}
return 0;
}
| 0
| 12,818,654
|
#include <iostream>
#include <cstdio>
#include <string>
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <stdlib.h>
#include <string.h>
#include <cmath>
#include <map>
#include <queue>
#include <deque>
#include <stack>
#include <set>
const long long MOD = 1e9 + 7;
using namespace std;
typedef long long ll;
map<ll, int> mp;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, h, w;
cin >> n >> h >> w;
vector<int> a(n), b(n);
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
int counter = 0;
for (int i = 0; i < n; i++) {
if (a[i] >= h && b[i] >= w) counter++;
}
cout << counter << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(long long i=0;i<(long long)(n);i++)
#define REP(i,k,n) for(long long i=k;i<(long long)(n);i++)
#define all(a) a.begin(),a.end()
#define pb push_back
#define eb emplace_back
#define lb(v,k) (lower_bound(all(v),k)-v.begin())
#define ub(v,k) (upper_bound(all(v),k)-v.begin())
#define fi first
#define se second
#define pi M_PI
#define PQ(T) priority_queue<T>
#define SPQ(T) priority_queue<T,vector<T>,greater<T>>
#define dame(a) {out(a);return 0;}
#define decimal cout<<fixed<<setprecision(15);
typedef long long ll;
typedef pair<ll,ll> P;
typedef tuple<ll,ll,ll> PP;
typedef tuple<ll,ll,ll,ll> PPP;
typedef multiset<ll> S;
using vi=vector<ll>;
using vvi=vector<vi>;
using vvvi=vector<vvi>;
using vp=vector<P>;
using vvp=vector<vp>;
using vb=vector<bool>;
using vvb=vector<vb>;
const ll inf=1001001001001001001;
const int INF=1001001001;
const int mod=1000000007;
const double eps=1e-10;
template<class T> bool chmin(T&a,T b){if(a>b){a=b;return true;}return false;}
template<class T> bool chmax(T&a,T b){if(a<b){a=b;return true;}return false;}
template<class T> void out(T a){cout<<a<<'\n';}
template<class T> void outp(T a){cout<<'('<<a.fi<<','<<a.se<<')'<<'\n';}
template<class T> void outvp(T v){rep(i,v.size())cout<<'('<<v[i].fi<<','<<v[i].se<<')';cout<<'\n';}
template<class T> void outvvp(T v){rep(i,v.size())outvp(v[i]);}
template<class T> void outv(T v){rep(i,v.size()){if(i)cout<<' ';cout<<v[i];}cout<<'\n';}
template<class T> void outvv(T v){rep(i,v.size())outv(v[i]);}
template<class T> bool isin(T x,T l,T r){return (l)<=(x)&&(x)<=(r);}
template<class T> void yesno(T b){if(b)out("yes");else out("no");}
template<class T> void YesNo(T b){if(b)out("Yes");else out("No");}
template<class T> void YESNO(T b){if(b)out("YES");else out("NO");}
template<class T> void noyes(T b){if(b)out("no");else out("yes");}
template<class T> void NoYes(T b){if(b)out("No");else out("Yes");}
template<class T> void NOYES(T b){if(b)out("NO");else out("YES");}
void outs(ll a,ll b){if(a>=inf-100)out(b);else out(a);}
ll gcd(ll a,ll b){if(b==0)return a;return gcd(b,a%b);}
ll modpow(ll a,ll b){a%=mod;if(b==0)return 1;if(b&1)return a*modpow(a,b-1)%mod;ll k=modpow(a,b/2);return k*k%mod;}
void merge(P&a,P b){
vi t={a.fi,a.se,b.fi,b.se};
sort(all(t));reverse(all(t));
a=P(t[0],t[1]);
}
int main(){
ll n;cin>>n;
vi v(1<<n);
rep(i,1<<n)cin>>v[i];
vvp dp(1<<n,vp(n+1,P(-inf,-inf)));
rep(i,1<<n){
dp[i][0].fi=v[i];
rep(j,n){
dp[i][j+1]=dp[i][j];
if(i>>j&1){
merge(dp[i][j+1],dp[i&~(1<<j)][j]);
}
}
}
ll m=1<<n;
vi res(m);
rep(i,m)res[i]=dp[i][n].fi+dp[i][n].se;
REP(i,1,m-1)chmax(res[i+1],res[i]);
REP(i,1,m)out(res[i]);
}
| 0
| 82,216,716
|
#include <stdio.h>
int main(void){
int a,b;
scanf("%d %d",&a,&b);
if(a<b){
printf("a < b\n");
}else if(a>b){
printf("a > b\n");
}else{
printf("a == b\n");
}
}
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define pcnt(bit) __builtin_popcountll(bit)
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 long double pi = acos(-1.0);
const int MAX = 1000010;
const int INF = 1LL << 60;
const int MOD = 1000000007;
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n; cin >> n;
map<int,int> mp;
vector<int> v;
int sum = 0;
rep(i,n) {
int a; cin >> a;
mp[a]++;
v.push_back(a);
sum += a;
}
if (mp.size() == 1) {cout << 0 << endl; return 0;}
int m1 = sum/n;
int m2 = m1+1;
int t1 = 0;
int t2 = 0;
rep(i,n) t1 += (v[i]-m1) * (v[i]-m1);
rep(i,n) t2 += (v[i]-m2) * (v[i]-m2);
cout << min(t1,t2) << endl;
return 0;
}
| 0
| 18,861,394
|
#include <stdio.h>
void B_sort(int data[], int n) {
int tmp;
for (int i = 0; i < n-1; i++) {
for (int j = i+1; j < n; j++) {
if (data[i] < data[j]) {
tmp = data[i];
data[i] = data[j];
data[j] = tmp;
}
}
}
}
int ave(int data[], int n) {
int i;
int sum = 0;
int ave;
for (i = 0; i < n; i++) {
sum += data[i];
}
if (n >= 2) {
ave = sum/(n-2);
}
else {
ave = sum;
}
return ave;
}
int main(void) {
int n[100] = {0};
int s[100][100] = { {0} };
int i = 0, j = 0;
while (1) {
scanf("%d", &n[i]);
if (n[i] == 0) {
break;
}
for (j = 0 ; j < n[i]; j++) {
scanf("%d", &s[i][j]);
}
i++;
}
i = 0;
j = 0;
while (n[i] != 0) {
B_sort(s[i], n[i]);
s[i][0] = 0;
s[i][n[i]-1] = 0;
printf("%d\n", ave(s[i], n[i]));
i++;
}
return 0;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <queue>
#include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <limits>
using namespace std;
map<int, int> mp;
int main(int argc, char* argv[]){
long long N, K;
cin >> N >> K;
for(int i=1; i<=N; i++){
int a, b;
cin >> a >> b;
if(mp.count(a)==0){
mp[a] = b;
}
else{
int c = mp[a];
mp[a] = c + b;
}
}
int ans = 0;
long long count = 0;
for(auto itr = mp.begin(); itr != mp.end(); itr++){
ans = itr->first;
count += (long long)itr->second;
if(count >= K){ break; }
}
cout << ans << endl ;
return 0;
}
| 0
| 16,730,518
|
#include <cmath>
#include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
#include<queue>
#include<set>
#include<tuple>
#include<bitset>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
ll inf = 1000000007;
int d[200005];
int main(void) {
int n;
cin >> n;
ll ans = 0;
for (int i = 0; i < n; i++) {
cin >> d[i];
}
int x = *max_element(d, d + n);
sort(d, d + n);
for (int i = 1; i <= x; i++) {
int index = lower_bound(d, d + n, i)-d;
if (index + 1 == n - index + 1) {
ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0; i<n; i++)
typedef long long ll;
typedef long long unsigned int llu;
ll MOD = 1000000007;
ll INF = 1000000009;
ll a[20];
ll p[20];
void solve(){
ll n,k;
cin >> n >> k;
rep(i,n){
cin >> a[i];
if(i!=0) p[i]=max(a[i],p[i-1]);
else p[0]=a[0];
}
ll ans = 10000000000000;
for(ll bit=0; bit<(1<<n); bit++){
ll tmp=bit;
vector<ll> c;
for(ll i=0; i<n; i++){
if(tmp%2==1) {
c.emplace_back(i);
}
tmp = tmp/2;
}
if(c.size()<k) continue;
ll count=0;
count += p[c[0]]-a[c[0]];
rep(i,c.size()-1){
ll x = c[i];
if(p[x]>=p[c[i+1]]){
p[c[i+1]]=p[x]+1;
count += p[x]+1-a[c[i+1]];
}
}
ans = min(ans, count);
rep(i,n){
if(i!=0) p[i]=max(a[i],p[i-1]);
else p[0]=a[0];
}
}
cout << ans << endl;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| 0
| 99,936,571
|
#include <iostream>
#include <string.h>
using namespace std;
int main()
{
string alphabet;
cin >> alphabet;
if(alphabet[0] >= 'A' && alphabet[0] <= 'Z')
{
cout << "A" << endl;
}
if(alphabet[0] >= 'a' && alphabet[0] <= 'z')
{
cout << "a" << endl;
}
}
|
#include <cstdio>
#include <climits>
#include <cmath>
#include <iostream>
#include <iomanip>
#include <string>
#include <cstdio>
#include <climits>
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <utility>
#include <queue>
#include <cstring>
#include <set>
#define rep(i, n) for (int i = 0; i < int(n); i++)
using namespace std;
long long MOD = 1000000007;
long long INF = 1000000000000000;
typedef long long ll;
typedef unsigned long long ull;
int main(void) {
int k;
cin >> k;
vector<ll> a(k);
rep(i, k) cin >> a[i];
if (a[k - 1] != 2) {
cout << -1 << endl;
return 0;
}
pair< ll, ll > sec[100010];
sec[k - 1].first = 2; sec[k - 1].second = 3;
for (int i = k - 2; i >= 0; i--) {
ll l = sec[i + 1].first, r = sec[i + 1].second;
l = ((l - 1LL) / a[i] + 1LL) * a[i];
r = (r / a[i] + 1LL) * a[i] - 1;
if (!(l <= r)) {
cout << -1 << endl;
return 0;
}
sec[i].first = l; sec[i].second = r;
}
cout << sec[0].first << " " << sec[0].second << endl;
return 0;
}
| 0
| 37,415,960
|
#include <bits/stdc++.h>
using namespace std;
void solve(long long a, long long b, long long c, long long d){
long long tmp = a * c;
if(a * d > tmp) tmp = a*d;
if(b * c > tmp) tmp = b*c;
if(b * d > tmp) tmp = b*d;
cout << tmp << endl;
}
int main(){
long long a;
scanf("%lld",&a);
long long b;
scanf("%lld",&b);
long long c;
scanf("%lld",&c);
long long d;
scanf("%lld",&d);
solve(a, b, c, d);
return 0;
}
|
#include<iostream>
using namespace std;
int main() {
for (;;) {
int a, b;
cin >> a >> b;
if (a == 0 && b == 0) {
break;
}
for (int k = 0; k < b; k++) {
cout << "#";
}
for (int m = 0; m < a - 2; m++) {
cout << endl;
cout << "#";
for (int j = 0; j < b - 2; j++) {
cout << ".";
}
cout << "#";
}
cout << endl;
for (int l = 0; l < b; l++) {
cout << "#";
}
cout << endl;
cout << endl;
}
}
| 0
| 5,787,877
|
#include <bits/stdc++.h>
#if LOCAL
#include "dump.hpp"
#else
#define dump(...)
#endif
using namespace std;
using ll=long long;
#define FOR(i,a,b) for(ll i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
template<class T>bool chmax(T &a, const T &b) {if (a<b) { a=b; return 1; } return 0;}
template<class T>bool chmin(T &a, const T &b) {if (b<a) { a=b; return 1; } return 0;}
int main() {
#if LOCAL&01
std::ifstream in("./test/sample-1.in");
std::cin.rdbuf(in.rdbuf());
#else
cin.tie(0);
ios::sync_with_stdio(false);
#endif
ll N,K; cin>>N>>K;
vector<ll> an(N);
for(auto&& a:an){
cin>>a;
}
dump(an);
vector<ll> sums(N+1);
FOR(i,0,N){
sums.at(i+1) = sums.at(i)+an.at(i);
}
dump(sums);
priority_queue<ll> base;
FOR(i,0,N){
FOR(j,i+1,N+1){
auto v = sums.at(j)-sums.at(i);
base.push(v);
}
}
auto mx_bit =[](ll v)->ll{
ll p=0;
while((1LL<<p)<=v){
++p;
}
return p;
};
ll maxv=base.top();
ll p=mx_bit(maxv);
ll tmp=1LL<<p;
dump(p,tmp);
ll ans=0;
for(ll i=p;i>=0;--i){
ll mask = 1LL<<i;
ll cnt=0;
auto pq = base;
priority_queue<ll> nx;
while(pq.size()>0){
auto v = pq.top();
pq.pop();
if(v&mask){
++cnt;
nx.push(v);
}
}
if(cnt>=K){
base=nx;
ans |= mask;
}else{
}
}
cout<<ans<<endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <cmath>
#include <vector>
#include <sstream>
#include <string>
#include <cstdio>
#include <stack>
#include <queue>
#include <list>
#include <numeric>
#include <fstream>
#define NDEBUG
#include <cassert>
using namespace std;
#define TEST
#ifdef TEST
#define dout cout
#else
stringstream dummy;
#define dout dummy.str(""); dummy.clear(stringstream::goodbit); dummy
#endif
#ifdef OUTPUT2TEXTFILE
#define dout outputfile
#define OUTPUTFILENAME "output.txt"
ofstream outputfile(OUTPUTFILENAME);
#define OutputFilePath "/Users/Nag/Documents/Prgm/Test/DerivedData/Test/Build/Products/Debug/output.txt"
#endif
#define disp(A) dout << #A << " = " << (A) << endl
#define disP(A) dout << setw(3) << (A) << " "
#define rep(i,a,n) for(int (i)=(a); (i)<(n); (i)++)
#define dispAll(A,n) dout << #A << " = "; rep(j, 0, (n)) {disP(A[j]);} dout << endl
typedef vector<int> vi;
const int INF = 999;
int M;
vi c;
int dp[20][50001];
int main(){
int yen;
cin >> yen >> M;
int cc;
rep(i,0,M) {
cin >> cc;
c.push_back(cc);
}
rep(i,0,20) {
rep(j,0,50001) {
dp[i][j] = INF;
}
}
rep(j,0,50001) {
dp[0][j] = j;
}
rep(j,0,yen+1) {
dp[0][j] = j;
}
rep(i,1,M) {
rep(j,0,yen+1) {
if( j<c[i] ) {
dp[i][j] = dp[i-1][j];
} else {
dp[i][j] = min( dp[i-1][j], dp[i][j-c[i]]+1 );
}
}
}
dout << dp[M-1][yen] << endl;
#ifdef OUTPUT2TEXTFILE
outputfile.close();
cout << "\"" << OutputFilePath << "\"" << endl;
#endif
return 0;
}
| 0
| 44,576,740
|
#include <iostream>
#include <algorithm>
#include <bitset>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <cstring>
#include <utility>
#include <vector>
#include <complex>
#include <valarray>
#include <fstream>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <numeric>
#define rep(X,Y) for (int (X) = 0;(X) < (Y);++(X))
#define rrep(X,Y) for (int (X) = Y-1;(X) >= 0;--(X))
#define repa(X,A,Y) for (int (X) = A;(X) <= (Y);++(X))
#define all(X) (X).begin(),(X).end()
#define mod(n, m) (((n)%(m)+(m))%m)
#define fi first
#define sc second
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> Pii;
typedef pair<ll,ll> Pll;
const int INFINT = 1 << 30;
const ll INFLL = 1LL << 60;
const double EPS = 1e-10;
const int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
ll N;
int main() {
cin >> N;
ll n = 0, k = 1;
while (true) {
if (n == N) break;
if (n > N) {
cout << "No" << endl;
return 0;
}
n += k;
++k;
}
vector<vector<int> > S(k);
int count = k;
for (int j = 1; j <= k-1; ++j) S[0].push_back(j);
for (int i = 1; i < k; ++i) {
for (int j = 0; j < k-1; ++j) {
if (i > j) {
S[i].push_back(S[j][i-1]);
} else {
S[i].push_back(count++);
}
}
}
cout << "Yes" << endl;
cout << k << endl;
rep(i, k) {
cout << k-1 << ' ';
rep(j, k-1) printf("%d%c", S[i][j], j+1 == k-1 ? '\n' : ' ');
}
return 0;
}
|
#include <fstream>
#include <iostream>
using namespace std;
#define MOD 998244353
#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define F0R(i,b) FOR(i,0,b)
#define RFO(i,a,b) for (int i = (b-1); i >= (a); i--)
#define RF0(i,b) RFO(i,0,b)
#define lli long long int
#define pii pair<int,int>
#define add(a,b) ((int) (((lli) (a) + (b))%MOD))
#define mul(a,b) ((int) (((lli) (a) * (b))%MOD))
#define PB emplace_back
#define F first
#define S second
int N, M;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> M;
if (N&1) {
N -= N&1;
F0R(i,M) cout << i+1 << ' ' << N-i << '\n';
} else {
F0R(i,M) {
if (N-2*i-1 <= N/2) cout << i+1 << ' ' << N-i-1 << '\n';
else cout << i+1 << ' ' << N-i << '\n';
}
}
}
| 0
| 100,283,946
|
#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <string>
#include <numeric>
#include <cmath>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
using P = pair<ll, ll>;
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 ll MOD = 1000000007;
const int INF = 1<<30;
template <class Abel> struct BIT {
vector<Abel> dat[2];
Abel UNITY_SUM = 0;
BIT(int n) { init(n); }
void init(int n) { for (int iter = 0; iter < 2; ++iter) dat[iter].assign(n + 1, UNITY_SUM); }
inline void sub_add(int p, int a, Abel x) {
for (int i = a; i < (int)dat[p].size(); i += i & -i)
dat[p][i] = dat[p][i] + x;
}
inline void add(int a, int b, Abel x) {
sub_add(0, a, x * -(a - 1)); sub_add(1, a, x); sub_add(0, b, x * (b - 1)); sub_add(1, b, x * (-1));
}
inline Abel sub_sum(int p, int a) {
Abel res = UNITY_SUM;
for (int i = a; i > 0; i -= i & -i) res = res + dat[p][i];
return res;
}
inline Abel sum(int a, int b) {
return sub_sum(0, b - 1) + sub_sum(1, b - 1) * (b - 1) - sub_sum(0, a - 1) - sub_sum(1, a - 1) * (a - 1);
}
void print() {
for (int i = 1; i < (int)dat[0].size(); ++i) cout << sum(i, i + 1) << ",";
cout << endl;
}
};
int main(){
ll N, D, A; cin >> N >> D >> A;
vector<P> enemy(N);
rep(i, N) cin >> enemy[i].first >> enemy[i].second;
sort(enemy.begin(), enemy.end());
vector<ll> x(N), h(N);
rep(i, N) {x[i] = enemy[i].first; h[i] = enemy[i].second;}
BIT<ll> bit(N + 10);
rep(i, N){
bit.add(i + 1, i + 2, h[i]);
}
ll ans = 0;
for (int i = 0; i < N; ++i){
ll cur = bit.sum(i + 1, i + 2);
if (cur <= 0) continue;
ll need = (cur + A - 1) / A;
ll right = x[i] + D * 2;
int id = upper_bound(x.begin(), x.end(), right) - x.begin();
bit.add(i + 1, id + 1, -need * A);
ans += need;
}
cout << ans << endl;
}
|
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <queue>
#include <utility>
#include <map>
#include <bitset>
#define ll long long
using namespace std;
using p = pair<ll, ll>;
ll dx[4] = {-1, 0, 1, 0};
ll dy[4] = {0, 1, 0, -1};
int main(void){
ll n;
cin >> n;
vector<ll> g(n+1, 0);
ll MAX = 0;
ll ans = 1;
for(ll i = 0; i < n; i++){
ll a;
cin >> a;
g[a]++;
MAX = max(MAX, a);
if(i==0 && a!=0) ans = 0;
}
ll INF = 998244353;
for(ll i = 1; i <= MAX; i++){
for(ll j = 0; j < g[i]; j++)
ans=(ans*g[i-1])%INF;
}
if(g[0]>1) ans = 0;
cout << ans << endl;
return 0;
}
| 0
| 28,692,216
|
#include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <utility>
#include <cmath>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <numeric>
#include <functional>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define exrep(i, a, b) for(ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll mod = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 100010;
int main() {
ll a, b, k;
cin >> a >> b >> k;
ll Ta = a, Ao = b;
rep(i, k) {
if(i%2 == 0) {
if(Ta%2 == 1) {
Ta--;
}
Ao += Ta/2;
Ta /= 2;
}
else {
if(Ao%2 == 1) {
Ao--;
}
Ta += Ao/2;
Ao /= 2;
}
}
cout << Ta << " " << Ao << endl;
re0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int A,B,M;
cin >> A >> B >> M;
vector<int> a(A),b(B);
int x,y,c;
int i;
int pa=100000,pb=100000;
int price;
for(i=0; i<A; i++){
cin >> a.at(i);
if(pa>a.at(i)) pa=a.at(i);
}
for(i=0; i<B; i++){
cin >> b.at(i);
if(pb>b.at(i)) pb=b.at(i);
}
price=pa+pb;
for(i=0; i<M; i++){
cin >> x >> y >> c;
if(price>a.at(x-1)+b.at(y-1)-c) price=a.at(x-1)+b.at(y-1)-c;
}
cout << price << endl;
}
| 0
| 53,492,467
|
#include <cstring>
#include <iostream>
struct card {
char mark;
unsigned int number;
};
static void print_cards(const card cards[], const unsigned int n) {
const char* sep = "";
for (unsigned int i = 0; i < n; ++i) {
const card* const cardp = &cards[i];
std::cout << sep << cardp->mark << cardp->number;
sep = " ";
}
std::cout << std::endl;
}
static void swap(card* a, card* b) {
card tmp = *a;
*a = *b;
*b = tmp;
}
void bubble_sort(card cards[], const unsigned int n) {
for (unsigned int j = 0; j < n-1; ++j) {
for (unsigned int i = n-1; i > j; --i) {
if (cards[i-1].number > cards[i].number) {
swap(&cards[i-1], &cards[i]);
}
}
}
}
void selection_sort(card cards[], const unsigned int n) {
for (unsigned int i = 0; i < n-1; ++i) {
unsigned int min_j = i;
for (unsigned int j = i+1; j < n; ++j) {
if (cards[min_j].number > cards[j].number) {
min_j = j;
}
}
if (i != min_j) {
swap(&cards[i], &cards[min_j]);
}
}
}
int main(void) {
unsigned int n;
std::cin >> n;
card cards1[n], cards2[n];
for (unsigned int i = 0; i < n; ++i) {
std::cin >> cards1[i].mark;
std::cin >> cards1[i].number;
}
std::memcpy(cards2, cards1, sizeof(cards1));
bubble_sort(cards1, n);
print_cards(cards1, n);
std::cout << "Stable" << std::endl;
selection_sort(cards2, n);
print_cards(cards2, n);
if (std::memcmp(cards1, cards2, sizeof(cards1)) == 0) {
std::cout << "Stable" << std::endl;
} else {
std::cout << "Not stable" << std::endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void err() {
cout << -1 << endl;
exit(0);
}
void dfs (int crr, int dpt, vector<vector<int>>& grh, long long& cnt) {
cnt += dpt;
for (int nxt : grh[crr]) {
dfs(nxt, dpt + 1, grh, cnt);
}
}
int main() {
int n;
cin >> n;
vector<long long> d(n);
map<long long, int> mp;
for (int i = 0; i < n; i++) {
cin >> d[i];
mp[d[i]] = i;
}
sort(d.begin(), d.end());
vector<long long> sz(n, 1);
vector<vector<int>> grh(n);
for (auto it = d.rbegin(); next(it) != d.rend(); it++) {
auto i = mp[*it];
long long ptv = *it - n + 2 * sz[i];
auto jt = lower_bound(d.begin(), d.end(), ptv);
if (jt == d.end() || *jt != ptv) err();
auto p = mp[*jt];
grh[p].push_back(i);
sz[p] += sz[i];
}
long long cnt = 0;
int rt = mp[d[0]];
dfs(rt, 0, grh, cnt);
if (d[0] != cnt) err();
for (int crr = 0; crr < n; crr++) {
for (int nxt : grh[crr]) {
cout << crr + 1 << ' ' << nxt + 1 << endl;
}
}
return 0;
}
| 0
| 15,366,972
|
#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cmath>
#include <algorithm>
#include <climits>
#include <iomanip>
#define endl "\n"
#define debug(x) cout << #x << " : " << x << endl;
#define debug2(x, y) cout << #x << " : " << x << ", " << #y << " : " << y << endl;
#define FASTIO ios_base::sync_with_stdio(false),cin.tie(0);
typedef long long ll;
using namespace std;
const ll maxSize = 2e6;
ll parent[maxSize];
ll size_set[maxSize];
ll cnt[maxSize];
void make_set(ll v)
{
parent[v] = v;
size_set[v] = 1;
}
ll find(ll v)
{
if(v == parent[v])
return v;
return parent[v] = find(parent[v]);
}
void union_set(ll a, ll b)
{
a = find(a);
b = find(b);
if(a != b)
{
if(size_set[a] > size_set[b])
swap(a, b);
parent[a] = b;
size_set[b] += size_set[a];
}
}
int main()
{
FASTIO
ll n, m;
cin >> n >> m;
for(ll i = 1; i <= n; i ++)
make_set(i);
for(ll i = 0; i < m; i ++)
{
ll a, b;
cin >> a >> b;
union_set(a, b);
}
ll maxm = 0;
for(ll i = 1; i <= n; i ++)
{
maxm = max(maxm, size_set[i]);
}
cout << maxm << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define LL long long
int main(){
priority_queue<long long> que;
long long n,m;
cin >> n >> m;
LL a[n];
for(LL i=0;i<n;i++){
cin >> a[i];
que.push(a[i]);
}
for(LL i=0;i<m;i++){
LL b = que.top();
que.pop();
que.push(b/2);
}
LL ans = 0;
for(LL i=0;i<n;i++){
ans += que.top();
que.pop();
}
cout << ans << endl;
}
| 0
| 16,721,582
|
#include <iostream>
using namespace std;
bool isEven(const string &s){
int mid = s.length() / 2;
for(int i = 0 ; i < mid ; ++i){
if(s[i] != s[i + mid]) return false;
}
return true;
}
int main(int argc, char const *argv[])
{
string s;
cin >> s;
s.pop_back(); s.pop_back();
while(!isEven(s)){
s.pop_back();
s.pop_back();
}
cout << s.length() << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
int k;
cin >> k;
vector<ll> a(k);
for(int i = 0; i < k; i++)
{
cin >> a[i];
}
if(a[k-1] != 2)
{
cout << -1 << endl;
return 0;
}
ll l = 2, h = 3;
for(int i = k-2; i >= 0; i--)
{
if(a[i] > h)
{
cout << -1 << endl;
return 0;
}
if(a[i] >= l) l = a[i];
else
{
l = ((l-1)/a[i] + 1) * a[i];
}
ll x = h / a[i] * a[i];
h = x + a[i] - 1;
if(l > h)
{
cout << -1 << endl;
return 0;
}
}
cout << l << " " << h << endl;
}
| 0
| 100,522,817
|
#include <bits/stdc++.h>
#define f first
#define s second
using namespace std;
using namespace chrono;
using ll = long long;
using ii = pair<int, int>;
constexpr int MN = 200002;
int N, A[MN];
time_point<high_resolution_clock> start;
void fast_incorrect() {
int ans = 0;
map<int, int> M;
for (int i = 1; i < N; ++i) {
if (A[i] <= A[i-1]) {
if (!ans) ans = 1;
int x = A[i];
if (M[x] == ans) {
int j = x-1;
while (j > 0 && M[j] == ans) --j;
if (j > 0) x = j;
}
ans = max(++M[x], ans);
while (rbegin(M)->f > x) M.erase(prev(end(M)));
}
}
cout << ans+1;
exit(0);
}
bool solve(int K) {
map<int, int> M;
for (int i = 1; i < N; ++i) {
if (duration_cast<duration<double>>(high_resolution_clock::now()-start) > duration<double>(0.8)) fast_incorrect();
if (A[i] <= A[i-1]) {
int x = A[i];
if (M[x] == K) {
int j = x-1;
while (j > 0 && M[j] == K) --j;
if (j > 0) x = j;
else return 0;
}
++M[x];
while (M.size() && rbegin(M)->f > x) M.erase(prev(end(M)));
}
}
return 1;
}
int main() {
if (fopen("in", "r")) freopen("in", "r", stdin), freopen("out", "w", stdout);
ios_base::sync_with_stdio(0), cin.tie(0);
start = high_resolution_clock::now();
cin >> N;
for (int i = 0; i < N; ++i) cin >> A[i];
bool good = 1;
for (int i = 1; i < N; ++i) {
if (A[i] <= A[i-1]) good = 0;
}
if (good) {
cout << 1;
return 0;
}
int l = 1, h = MN;
for (int i = 0; i < 50; ++i) {
int m = (l+h)/2;
solve(m) ? h = m : l = m+1;
}
cout << l+1;
}
|
# include "bits/stdc++.h"
using namespace std;
using LL = long long;
using ULL = unsigned long long;
const double PI = acos(-1);
template<class T>constexpr T INF() { return ::std::numeric_limits<T>::max(); }
template<class T>constexpr T HINF() { return INF<T>() / 2; }
template <typename T_char>T_char TL(T_char cX) { return tolower(cX); };
template <typename T_char>T_char TU(T_char cX) { return toupper(cX); };
const int vy[] = { -1, -1, -1, 0, 1, 1, 1, 0 }, vx[] = { -1, 0, 1, 1, 1, 0, -1, -1 };
const int dx[4] = { -1,0,1,0 }, dy[4] = { 0,-1,0,1 };
int popcnt(unsigned long long n) { int cnt = 0; for (int i = 0; i < 64; i++)if ((n >> i) & 1)cnt++; return cnt; }
int d_sum(LL n) { int ret = 0; while (n > 0) { ret += n % 10; n /= 10; }return ret; }
int d_cnt(LL n) { int ret = 0; while (n > 0) { ret++; n /= 10; }return ret; }
LL gcd(LL a, LL b) { if (b == 0)return a; return gcd(b, a%b); };
LL lcm(LL a, LL b) { LL g = gcd(a, b); return a / g*b; };
# define ALL(qpqpq) (qpqpq).begin(),(qpqpq).end()
# define UNIQUE(wpwpw) (wpwpw).erase(unique(ALL((wpwpw))),(wpwpw).end())
# define LOWER(epepe) transform(ALL((epepe)),(epepe).begin(),TL<char>)
# define UPPER(rprpr) transform(ALL((rprpr)),(rprpr).begin(),TU<char>)
# define FOR(i,tptpt,ypypy) for(LL i=(tptpt);i<(ypypy);i++)
# define REP(i,upupu) FOR(i,0,upupu)
# define INIT std::ios::sync_with_stdio(false);std::cin.tie(0)
# pragma warning(disable:4996)
LL x, y;
int main() {
cin >> x >> y;
cout << (abs(x - y) >= 2 ? "Alice" : "Brown") << endl;
}
| 0
| 79,731,389
|
#include <iostream>
using namespace std;
int main() {
bool judge = true;
int x, y;
int n = 0;
while (judge) {
cin >> x >> y;
if ((x == 0) && (y == 0)) {
judge = false;
} else {
if (x > y) {
cout << y << " " << x << endl;
} else {
cout << x << " " << y << endl;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
typedef long int ll;
typedef long double ld;
#define pb push_back
#define pii pair < int , int >
#define F first
#define S second
#define endl '\n'
#define int long long
#define sync ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#define kill(x) return cout<<x<<'\n', 0;
using namespace std;
const int N=2e5+100;
vector <int> g[N];
ll vis[N],r[N];
ll p1=0;
void dfs(ll v,ll k){
vis[v]=1;
r[v]=k;
for (auto u : g[v]){
if (!vis[u]){
dfs(u,3-k);
}
else{
if (r[u]==r[v]) p1=1;
}
}
return;
}
int32_t main(){
ll n,m;
cin >> n >> m;
for (int i=1;i<=m;i++){
ll u,v;
cin >> u >> v;
g[u].pb(v);
g[v].pb(u);
}
ll cnt=0;
for (int i=1;i<=n;i++){
if (g[i].size()==0){
cnt++;
}
}
ll ans=cnt*(n-cnt)*2+cnt*cnt;
ll t0=0,t1=0;
for (int i=1;i<=n;i++){
p1=0;
if (g[i].size()==0 || vis[i]) continue;
dfs(i,1);
if (p1) t1++;
else t0++;
}
ans+=2*t0+t1+t0*(t0-1)*2+(t1-1)*t1;
ans+=t0*t1*2;
cout << ans << endl;
}
| 0
| 7,564,453
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <iomanip>
#include <limits>
using namespace std;
typedef pair<long long, long long> P;
vector<P> prime_factorize(long long n)
{
vector<P> res;
for (long long p = 2; p * p <= n; ++p)
{
if (n % p != 0)
continue;
int num = 0;
while (n % p == 0)
{
++num;
n /= p;
}
res.push_back(make_pair(p, num));
}
if (n != 1)
res.push_back(make_pair(n, 1));
return res;
}
long long gcd(long long x, long long y)
{
if (y == 0)
{
return x;
}
else
{
return gcd(y, x % y);
}
}
bool is_prime(long long n){
if (n <= 1) return false;
for (long long p = 2; p * p <= n; ++p) {
if (n % p == 0) return false;
}
return true;
}
const int MOD = 1000000007;
typedef long long int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define rep(i, n) for (int i = 0; i < (n); i++)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
int main()
{
ll N;
cin >> N;
int A[N+1];
rep(i,N+1){
cin >> A[i];
}
int B[N];
rep(i,N){
cin >> B[i];
}
ll ans = 0;
for (int i = 0; i < N; i++)
{
if(B[i]>=A[i]+A[i+1]){
ans += A[i] + A[i + 1];
A[i] = 0;
A[i + 1] = 0;
}else if(B[i]>=A[i]&&B[i]<A[i]+A[i+1]){
ans += B[i];
A[i + 1] = A[i+1]-(B[i] - A[i]);
A[i] = 0;
}else if(B[i]<A[i]){
ans += B[i];
A[i] -= B[i];
}
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define inf INT_MAX
#define INF LLONG_MAX
#define ll long long
#define ull unsigned long long
#define M (int)(1e9+7)
#define P pair<int,int>
#define PLL pair<ll,ll>
#define FOR(i,m,n) for(int i=(int)m;i<(int)n;i++)
#define RFOR(i,m,n) for(int i=(int)m;i>=(int)n;i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,n,0)
#define all(a) a.begin(),a.end()
#define IN(a,n) rep(i,n){ cin>>a[i]; }
const int vx[4] = {0,1,0,-1};
const int vy[4] = {1,0,-1,0};
#define PI 3.14159265
#define F first
#define S second
#define PB push_back
#define EB emplace_back
#define int ll
#define vi vector<int>
#define IP pair<int,P>
#define PP pair<P,P>
int n,l,q;
int x[110000],d[20][110000];
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(20);
cin>>n;
rep(i,n){
cin>>x[i];
}
cin>>l>>q;
int p=0;
rep(i,n){
while(x[i]-x[p]>l) p++;
d[0][i]=p;
}
FOR(i,1,17){
rep(j,n+1){
d[i][j]=d[i-1][d[i-1][j]];
}
}
while(q--){
int a,b;
cin>>a>>b;
a--;b--;
if(a==b){
cout<<0<<endl;
}else{
if(a>b) swap(a,b);
int res=1;
rrep(i,16){
if(d[i][b]>a){
res+=1<<i;
b=d[i][b];
}
}
cout<<res<<endl;
}
}
}
| 0
| 2,461,853
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
int main() {
long double l; cin >> l;
printf("%.9Lf\n", l * l * l / 27.0);
}
|
#include <iostream>
using namespace std;
typedef long long ll;
int main()
{
ll n;
cin >> n;
ll a[52];
for(int i = 0; i < n; i++) cin >> a[i];
ll ans = 0;
while(true){
int l = 0;
for(int i = 1; i < n; i++){
if(a[i] > a[l]) l = i;
}
if(a[l] < n) break;
ll c = a[l] / n;
for(int i = 0; i < n; i++){
if(i == l) a[i] %= n;
else a[i] += c;
}
ans += c;
}
cout << ans << endl;
}
| 0
| 94,319,946
|
#include <cctype>
#include <iostream>
#include <string>
using namespace std;
int main() {
string a, b, c;
cin >> a >> b >> c;
cout << char(toupper(a[0])) << char(toupper(b[0])) << char(toupper(c[0]))
<< endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using ld = long double;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<int>;
using vvi = vector<vi>;
template<class T> using PQ = priority_queue<T>;
template<class T> using PQG = priority_queue<T, vector<T>, greater<T> >;
const int INF = 100010001;
const ll LINF = (ll)INF*INF*10;
template<typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {return a < b && (a = b, true);}
template<typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {return a > b && (a = b, true);}
template<typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) { return is >> p.first >> p.second;}
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) { return os << p.first << ' ' << p.second;}
int main() {
cout << fixed << setprecision(15);
ios::sync_with_stdio(false);
cin.tie(0);
int n;
int k;
cin >> n >> k;
ld ans = 0;
rep(i, n) {
ld cnt = 1;
int x = i+1;
while(x < k) {
x <<= 1;
cnt /= 2;
}
ans += cnt;
}
ans /= ld(n);
cout << ans << endl;
}
| 0
| 18,320,051
|
#include <iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
void roll_dice(char c, int d[])
{
int buf;
switch(c)
{
case 'N':
buf = d[6];
d[6] = d[5];
d[5] = d[1];
d[1] = d[2];
d[2] = buf;
break;
case 'E':
buf = d[6];
d[6] = d[3];
d[3] = d[1];
d[1] = d[4];
d[4] = buf;
break;
case 'S':
buf = d[6];
d[6] = d[2];
d[2] = d[1];
d[1] = d[5];
d[5] = buf;
break;
case 'W':
buf = d[6];
d[6] = d[4];
d[4] = d[1];
d[1] = d[3];
d[3] = buf;
}
}
void init_rand()
{
srand((unsigned int)time(NULL));
}
int return_random_direction()
{
switch(rand()%4)
{
case 0:
return 'N';
case 1:
return 'E';
case 2:
return 'S';
case 3:
return 'W';
}
}
int main()
{
int d[7];
for(int i=1;i<7;i++)
{
cin >> d[i];
}
int q;
cin >> q;
int top, front;
for(int i=0;i<q;i++)
{
cin >> top >> front;
int count = 0;
while(!(d[1]==top && d[2]==front))
{
char dir = return_random_direction();
roll_dice(dir, d);
count++;
}
cout << d[3] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define ALL(a) (a).begin(),(a).end()
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<long long, long long> Pll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<long long> vll;
typedef vector<vector<long long>> vvll;
template <typename T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template <typename T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const long long INF = 1LL << 60;
const int INT_INF = 1LL << 30;
ll func(ll SS1, ll HH, ll WW){
ll SS2, SS3, ans = INF;
if(HH % 2 == 0 || WW % 2 == 0){
SS2 = HH * WW / 2; SS3 = HH * WW / 2;
ll maxs = max(SS1, max(SS2, SS3));
ll mins = min(SS1, min(SS2, SS3));
ans = maxs - mins;
}
else{
ll a = HH/2, b = HH - HH/2;
SS2 = a * WW; SS3 = b * WW;
ll maxs = max(SS1, max(SS2, SS3));
ll mins = min(SS1, min(SS2, SS3));
chmin(ans, maxs - mins);
a = WW/2; b = WW - WW/2;
SS2 = a * HH; SS3 = b * HH;
maxs = max(SS1, max(SS2, SS3));
mins = min(SS1, min(SS2, SS3));
chmin(ans, maxs - mins);
}
return ans;
}
int main(){
ll H, W;
cin >> H >> W;
if(H % 3 == 0 || W % 3 == 0){
cout << 0 << endl;
return 0;
}
ll S1, S2, S3;
ll ans = INF;
S1 = (W/3) * H;
chmin(ans, func(S1, H, W-W/3));
S1 = (W/3+1) * H;
chmin(ans, func(S1, H, W-(W/3+1)));
S1 = (H/3) * W;
chmin(ans, func(S1, H-H/3, W));
S1 = (H/3+1) * W;
chmin(ans, func(S1, H-(H/3+1), W));
cout << ans << endl;
}
| 0
| 80,602,684
|
#pragma GCC optimize("O3")
#define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
using namespace std;
using base = complex<double>;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define M 1000000007
#define M2 998244353
#define ll long long
#define pll pair<long, long>
#define REP(i, a, b) for (ll i = a; i < b; i++)
#define REPI(i, a, b) for (ll i = b - 1; i >= a; i--)
#define ff first
#define ss second
#define pb push_back
#define db pop_back
#define mp make_pair
#define mt make_tuple
#define g(a, b) get<a>(b)
#define INF (ll)1e18 + 100
#define vl vector<ll>
#define vi vector<int>
#define vll vector<pair<ll, ll>>
#define vii vector<pair<int, int>>
#define all(v) v.begin(), v.end()
#define bset(a, p) ((a) | (1ll << (p)))
#define bchk(a, p) ((a) & (1ll << (p)))
#define bxor(a, p) ((a) ^ (1ll << (p)));
#define brem(a, p) (bchk(a, p) ? (bxor(a, p)) : (a))
#define INT_SIZE 32
void solve() {
ll a, b;
char x;
cin >> a >> x >> b;
if (x == '+') {
cout << a + b;
}
else {
cout << a - b;
}
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll ntc;
ntc = 1;
REP(tc, 1, ntc + 1)
{
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
map<int, int> mp;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
mp[a]++;
}
int even = 0;
for (auto &x:mp) {
if (x.second % 2 == 0) even++;
}
int ans = mp.size();
if (even % 2 == 1) ans--;
cout << ans << endl;
return 0;
}
| 0
| 14,850,179
|
#include <bits/stdc++.h>
using namespace std;
#define repd(i,a,b) for (int i=(a);i<(b);i++)
#define rep(i,n) repd(i,0,n)
#define all(x) (x).begin(),(x).end()
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
typedef long long ll;
const long long INF = 1LL << 60;
typedef pair<int, int> P;
int main()
{
int x;
cin >> x;
if (x < 1200) cout << "ABC" << endl;
else cout << "ARC" << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i=0; i<n; i++)
#define rep1(i, n) for(int i=1; i<=n; i++)
#define repr(i, n) for(int i=n-1; i>=0; i--)
#define repr1(i, n) for(int i=n; i>=1; i--)
#define all(v) v.begin(),v.end()
using ll = long long;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const int INF = 1e9;
const ll LLINF = 1e18;
const ll MOD = 1e9+7;
const double EPS = 1e-10;
const double PI = acos(-1);
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main() {
ll n, m, d;
cin >> n >> m >> d;
double ans;
if (d == 0) {
ans = (double)(m-1) / n;
} else {
ans = (double)(m-1) * 2 * (n - d) / (n * n);
}
cout << fixed << setprecision(10) << ans << endl;
}
| 0
| 55,587,749
|
#include <iostream>
using namespace std;
int main(){
int n=1000 ,m ,coin=0;
while( true ){
cin >> m;
if( m == 0 ){
break;
}
n -= m;
if( n >= 500 ){
coin += n / 500;
n %= 500;
}
if( n >= 100 ){
coin += n / 100;
n %= 100;
}
if( n >= 50 ){
coin += n / 50;
n %= 50;
}
if( n >= 10 ){
coin += n / 10;
n %= 10;
}
if( n >= 5 ){
coin += n / 5;
n %= 5;
}
if( n >= 1 ){
coin += n;
}
cout << coin << endl;
n = 1000;
coin = 0;
}
}
|
#include <iostream>
#include <string>
using namespace std;
int main(int argc, char* argv[]) {
string s;
cin >> s;
int from_left[s.size()];
for (int i = 0; i < s.size(); ++i) {
if (i == 0)
from_left[0] = 1;
else if (s[i] == s[i - 1]) {
from_left[i] = from_left[i - 1];
} else {
from_left[i] = from_left[i - 1] + 1;
}
}
int from_right[s.size()];
for (int i = s.size() - 1; i >= 0; --i) {
if (i == s.size() - 1)
from_right[s.size() - 1] = 1;
else if (s[i] == s[i + 1]) {
from_right[i] = from_right[i + 1];
} else {
from_right[i] = from_right[i + 1] + 1;
}
}
long long ret = 10000000;
for (int i = 0; i < s.size(); ++i) {
ret = min(ret, (long long)(from_left[i] + from_right[i]));
}
cout << ret - 2 << endl;
return 0;
}
| 0
| 41,583,223
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = 1; i < (int)(n+1); i++)
int main() {
int N;
cin>>N;
vector<int>A(N);
int ans;
rep(i,N){
cin>>A[i];
if(i==0){
ans=A[0];
}
else{
ans=__gcd(ans,A[i]);
if(ans==1){
break;
}
}
}
cout<<ans<<endl;
}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <map>
#include <set>
#include <string>
#include <cstring>
#include <sstream>
#include <cmath>
#include <functional>
#include <fstream>
#include <cstdlib>
typedef long long ll;
#define REP(i, N) for (int i = 0; i < (N); i++)
#define REPP(i, a, b) for (int i = (a); i < (b); i++)
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
#define VSORT(c) sort((c).begin(),(c).end())
#define SZ(x) ((int)(x).size())
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<string> str(N);
for(int i = 0; i < N;i++){
cin >> str[i];
}
int cntA = 0,cntB = 0,cntAB=0;
int ans = 0;
for(int i = 0; i < N;i++){
if(str[i][0] == 'B' && str[i][str[i].length()-1] == 'A') cntAB++;
else if(str[i][0] == 'B') cntB++;
else if(str[i][str[i].length()-1] == 'A') cntA++;
for(int l = 0; l < str[i].length();l++){
if(str[i][l] == 'A' && l != str[i].length()-1){
if(str[i][l+1] == 'B'){
ans++;
}
}
}
}
ans += cntAB != 0 ? cntAB-1 : 0;
if(cntAB != 0 && cntA > 0){
ans++;
cntA--;
}
if(cntAB != 0 && cntB > 0){
ans++;
cntB--;
}
ans += min(cntA,cntB);
cout << ans << endl;
return 0;
}
| 0
| 30,610,485
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
vector<long> v(N+1);
v.at(0) = 2;
v.at(1) = 1;
for (int i = 2; i < N+1; i++){
v.at(i) = v.at(i-1) + v.at(i-2);
}
cout << v.at(N) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
int remaining = n;
int left = 0, right = n - 1;
while (right - left > 1) {
if (a[left + 1] != a[left]) {
left++;
}
else if (a[right - 1] != a[right]) {
right--;
}
else {
left++;
right--;
remaining -= 2;
}
}
if (a[left] == a[right] && left != right) {
remaining -= 2;
}
cout << remaining << endl;
return 0;
}
| 0
| 26,109,630
|
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<functional>
using namespace std;
int flg[1000000];
int main(void)
{
int n,i,j,cnt;
while(scanf("%d",&n)!=EOF){
for(i=2;i<=n;i++) flg[i]=1;
for(i=2;i*i<=n;i++){
if(flg[i]==1){
for(j=2;i*j<=n;j++){
flg[i*j]=0;
}
}
}
cnt=0;
for(i=2;i<=n;i++){
if(flg[i]==1) cnt++;
}
printf("%d\n",cnt);
}
return 0;
}
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define printl(s) cout << s << endl;
#define rep(i,n) for(int i=0;i<(n);i++)
using ll = long long;
using vvi = vector<vector<int>>;
const ll modSeed = pow(10,9) + 7;
const int INF = 1'000'000'000;
template <typename T>
vector<T> getVector(ll num){
vector<T> values(num);
for(ll i=0;i<num;i++){
cin >> values.at(i);
}
return values;
}
string S;
ll N,ans;
int main(){
ans = 0;
cin >> N;
for(int c=0;c<=N;c++){
for(int d=0;d<=N-c;d++){
int p = 4*c+7*d;
if(p==N){
printl("Yes");
return 0;
}
}
}
printl("No");
}
| 0
| 33,894,627
|
#include <bits/stdc++.h>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
const bool debug=false;
#define DEBUG if(debug==true)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll MOD = 1000000007;
int main(void) {
int n;
cin >>n;
int t[n],v[n];
rep(i,n)cin>>t[i];
rep(i,n)cin>>v[i];
int minutes_=0;
rep(i,n)minutes_+=t[i];
int speed[minutes_+1][2]={};
int sp_now=0,time=0;
rep(i,n){
rep(j,t[i]){
if(sp_now<v[i]){
sp_now++;
}else{
sp_now=v[i];
}
time++;
speed[time][0]=sp_now;
}
}
sp_now=0;
time = minutes_;
for(int i=n-1;i>=0;i--){
rep(j,t[i]){
if(sp_now<v[i]){
sp_now++;
}else{
sp_now=v[i];
}
time--;
speed[time][1]=sp_now;
}
}
long double res=0;
int cnt_cross=0;
sp_now=0;
int sp_next=0;
rep(i,minutes_+1){
if(i==0)continue;
sp_now=sp_next;
sp_next=min(speed[i][0],speed[i][1]);
res+=(sp_now+sp_next);
if(speed[i-1][0]<speed[i-1][1]&&speed[i][0]>speed[i][1])cnt_cross++;
}
res /= 2.0;
res += cnt_cross/4.0;
printf("%Lf\n",res);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
const int INF=1e+9;
const int MOD=1e+9+7;
#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define REPD(i,n) for(int i=n-1;i>=0;i--)
#define REP2(i,a,b) for(int i=a;i<(int)(b);i++)
#define REPD2(i,a,b) for(int i=a;i>(int)(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) ((int)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
bool L[5010][5010];
bool R[5010][5010];
int sumr[5010][5010];
int main(){
int N,K;
cin>>N>>K;
vector<int> a(N);
REP(i,N) cin>>a[i];
sort(ALL(a));
REP(i,5010){
REP(j,5010){
if(j==0){
L[i][j]=true;
R[i][j]=true;
}else{
L[i][j]=false;
R[i][j]=false;
}
}
}
REP(i,N){
REP(j,5010){
if(a[i]>=K) continue;
if(j-a[i]>=0){
L[i+1][j]=L[i][j-a[i]]|L[i][j];
}else{
L[i+1][j]=L[i][j];
}
}
}
sort(ALL(a),greater<int>());
REP(i,N){
REP(j,5010){
if(a[i]>=K) continue;
if(j-a[i]>=0){
R[N-1-i][j]=R[N-i][j-a[i]]|R[N-i][j];
}else{
R[N-1-i][j]=R[N-i][j];
}
}
}
sort(ALL(a));
int ans=0;
REP(i,5010){
REP(j,5010){
sumr[i][j]=0;
}
}
REP(i,5010){
REP(j,5009){
sumr[i][j+1]=sumr[i][j]+R[i][j];
}
}
REP(i,N){
if(a[i]>=K) continue;
bool flag=true;
REP(j,K+1){
if(!L[i][j]) continue;
int l=max(K-a[i]-j,0);
int r=K-j;
if(sumr[i+1][r]-sumr[i+1][l]>0){
flag=false;
break;
}
}
if(flag){
ans++;
}
}
cout<<ans<<endl;
}
| 0
| 8,653,500
|
#include <iostream>
using namespace std;
int main(void)
{
int X;
cin >> X;
int a, b, r, x;
a = 360;
b = X;
r = a % b;
x = a * b;
while (r != 0)
{
a = b;
b = r;
r = a % b;
}
int K;
K = (x / b) / X;
cout << K << "\n";
}
|
#include <iostream>
#include <vector>
#include <string>
#include <stack>
using namespace std;
bool isPair(char top, char input) {
if ((top == '(' && input ==')')
|| (top == '[' && input ==']')) {
return true;
}
return false;
}
void check(string str) {
stack<char> st;
for (int i = 0; i < str.size(); ++i) {
if (!st.empty()) {
char top = st.top();
if (isPair(top, str[i])) {
st.pop();
continue;
}
}
if (str[i] == '(' || str[i] == ')'
|| str[i] == '[' || str[i] == ']') {
st.push(str[i]);
}
}
if( st.empty() ) cout<<"yes"<<endl;
else cout<<"no"<<endl;
}
int main() {
string str;
while(getline(cin, str), str.front() != '.') {
check(str);
}
return 0;
}
| 0
| 1,899,719
|
#include<cstdio>
#define LL long long
#define eps 1e-6
int main(){
LL a,b,c;
double d;
scanf("%lld%lf",&a,&d);
d+=eps;
b=d*100;
c=a*b/100;
printf("%lld\n",c);
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n; string s, t; cin >> n >> s;
int rc = 0, lc = 0;
for (auto i = 0; i < n; i++) {
if(s[i] == '(') rc++;
else {
if(rc == 0) lc++;
else rc--;
}
}
for (auto i = 0; i < lc; i++) t += "(";
t += s;
for (auto i = 0; i < rc; i++) t += ")";
cout << t << endl;
return 0;
}
| 0
| 16,008,170
|
#include <bits/stdc++.h>
inline void rotate(std::string& s) {
const char t = s[s.size() - 1];
for (int i = s.size() - 1; i > 0; --i)
s[i] = s[i - 1];
s[0] = t;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0); std::cout.tie(0);
std::string s;
std::getline(std::cin, s);
std::string t;
std::getline(std::cin, t);
std::string r = "No";
if (s.size() == t.size()) {
if (s == t) {
r = "Yes";
} else {
for (std::size_t i = 1; i < s.size(); ++i) {
rotate(s);
if (s == t) {
r = "Yes";
break;
}
}
}
}
std::cout << r << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i, n) for(int i = 0;i < n;i++)
#define ll long long
using namespace std;
typedef pair<int, int> P;
typedef pair<ll,ll> LP;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int INF = 1000000000;
const ll LINF = 1000000000000000000;
const ll MOD = 998244353;
const double PI = acos(-1.0);
const double EPS = 1e-10;
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; }
vector<pair<char, int>> runLengthEncoding(string &s) {
int n = s.size();
vector<pair<char, int>> res;
char pre = s[0];
int cnt = 1;
for(int i=1;i<n;i++) {
if (pre != s[i]) {
res.push_back({ pre, cnt });
pre = s[i];
cnt = 1;
}
else cnt++;
}
res.push_back({ pre, cnt });
return res;
}
void solve(){
string S;
cin >> S;
auto res = runLengthEncoding(S);
cout << res.size() - 1 << endl;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
solve();
}
| 0
| 28,388,739
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
using pll = pair<long long, long long>;
int main() {
int N;
long long M;
cin >> N >> M;
vector<pll> v(N);
for (int i = 0; i < N; ++i) cin >> v[i].first >> v[i].second;
sort(v.begin(), v.end());
long long res = 0;
for (int i = 0; i < N && M > 0; ++i) {
res += v[i].first * min(M, v[i].second);
M -= min(M, v[i].second);
}
cout << res << endl;
}
|
#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()
#define chmin(a, b) a = min(a, b)
#define chmax(a, b) a = max(a, b)
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<ll, ll>;
using T = ll;
const int MOD = 998244353;
const ll ZER = 0;
int main(){
ll n, a, b;
cin >> n >> a >> b;
ll mn = a * (n - 1) + b, mx = a + b * (n - 1);
cout << max(ZER, mx - mn + 1) << endl;
}
| 0
| 8,598,894
|
#include <bits/stdc++.h>
#include <iomanip>
#include <math.h>
#define rep(i,x) for(ll i = 0;i<x;i++)
#define all(a) (a).begin(),(a).end()
using ll = long long;
using ld = long double;
using namespace std;
using dou = double;
const ll INF = 1LL << 60;
const ll mod = 1000000007;
typedef pair<ll,ll> P;
using graph = vector<vector<ll>>;
template<class T> inline bool chmax(T& a, T b){if(a < b){a = b; return true;}return false;}
template<class T> inline bool chmin(T& a, T b){if(a > b){a = b; return true;}return false;}
ll gcd(ll a,ll b){
if(a < b)swap(a,b);
if(a % b == 0)return b;
else return gcd(b,a%b);
}
bool isp(ll n){
bool res = true;
if(n == 1)return false;
else{
for(ll i = 2;i * i <= n;i++){
if(n % i == 0){
res = false;
break;
}
}
return res;
}
}
int main(){
string S;
cin >> S;
bool a = false;
bool b = false;
if(S[0] == 'A' || S[1] == 'A' || S[2] == 'A')a = true;
if(S[0] == 'B' || S[1] == 'B' || S[2] == 'B')b = true;
if(a && b)cout << "Yes" << endl;
else cout << "No" << endl;
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
using namespace std;
typedef long long unsigned int ll;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
int main() {
long long w, h;
long long eda = 0;
cin >> w >> h;
vector<ll> p;
vector<ll> q;
for(ll i = 0; i < w; i++){
ll in;
cin >> in;
p.push_back(in);
}
for(ll i = 0; i < h; i++){
ll in;
cin >> in;
q.push_back(in);
}
p.push_back(INF);
q.push_back(INF);
ll cost = 0;
sort(p.begin(), p.end(), greater<ll>());
sort(q.begin(), q.end(), greater<ll>());
ll need = (w + 1) * (h + 1) - 1;
while(eda < need){
if((p.back()) > (q.back())){
eda += (w + 1);
cost += (w + 1) * q.back();
h--;
q.pop_back();
} else {
eda += (h + 1);
cost += (h + 1) * p.back();
w--;
p.pop_back();
}
}
cout << cost << endl;
return 0;
}
| 0
| 52,416,383
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(),(x).end()
const int mod=1000000007,MAX=1005,INF=1000;
int main(){
ll N;cin>>N;
vector<ll> S(N);
bool flag=true;
ll sum=0,a=0;
for(int i=0;i<N;i++){
cin>>S[i];
sum+=S[i];
a+=(i+1);
}
if(sum%a!=0) flag=false;
ll play=sum/a;
for(int i=0;i<N-1;i++){
if((play-(S[i+1]-S[i]))%N!=0) flag=false;
if((play-(S[i+1]-S[i]))/N<0||(play-(S[i+1]-S[i]))/N>play) flag=false;
}
if((play-(S[0]-S[N-1]))%N!=0) flag=false;
if((play-(S[0]-S[N-1]))/N<0||(play-(S[0]-S[N-1]))/N>play) flag=false;
if(flag) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
|
#include<algorithm>
#include<bitset>
#include<climits>
#include<cmath>
#include<complex>
#include<deque>
#include<functional>
#include<iomanip>
#include<iostream>
#include<iterator>
#include<map>
#include<numeric>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<unordered_map>
#include<unordered_set>
#include<utility>
#include<vector>
using namespace std;
typedef long long ll;
typedef long double lb;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
int main() {
ll N;
cin >> N;
vector<ll> B(N-1);
rep(i,N-1){
cin >> B[i];
}
vector<ll> A;
A.push_back(B[0]);
rep(i,N-2){
A.push_back(min(B[i],B[i+1]));
}
A.push_back(B[N-2]);
ll ans=0;
rep(i,N){
ans += A[i];
}
cout << ans << endl;
}
| 0
| 17,190,452
|
#include <iostream>
#include <climits>
#include <vector>
#include <numeric>
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
const int INF = INT_MAX / 2;
struct Edge{
int from, to, cost;
Edge( int f, int t, int c ) : from( f ), to( t ), cost( c )
{
return;
}
};
int main()
{
cin.tie( 0 );
ios::sync_with_stdio( false );
while ( true )
{
int n;
cin >> n;
if ( !n )
{
break;
}
int V = 0;
vector< Edge > E;
for ( int i = 0; i < n; i++ )
{
int f, t, c;
cin >> f >> t >> c;
V = max( V, max( f, t ) );
E.push_back( Edge( f, t, c ) );
}
V++;
VVI G( V, VI( V, INF ) );
for ( int i = 0; i < V; i++ )
{
G[i][i] = 0;
}
for ( int i = 0; i < n; i++ )
{
Edge &e = E[i];
G[ e.from ][ e.to ] = e.cost;
G[ e.to ][ e.from ] = e.cost;
}
for ( int k = 0; k < V; k++ )
{
for ( int i = 0; i < V; i++ )
{
for ( int j = 0; j < V; j++ )
{
G[i][j] = min( G[i][j], G[i][k] + G[k][j] );
}
}
}
int num, res = INT_MAX;
for ( int i = 0; i < V; i++ )
{
int sum = accumulate( G[i].begin(), G[i].end(), 0 );
if ( sum < res )
{
num = i;
res = sum;
}
}
cout << num << ' ' << res << endl;
}
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <cmath>
#include <map>
int main(){
int a, b, c; std::cin >> a >> b >> c;
int A = std::min({ a, b, c });
int C = std::max({ a, b, c });
int B = a + b + c - A - C;
if ((A % 2 == 0 && B % 2 == 0 && C % 2 == 0) || (A % 2 == 1 && B % 2 == 1 && C % 2 == 1))
std::cout << ((C - A) / 2) + ((C - B) / 2) << std::endl;
else if (A % 2 == 0 && B % 2 == 1 && C % 2 == 0) {
int count = (C - A) / 2;
while (true) {
if (B > C)
break;
else {
B += 2;
++count;
}
}
std::cout << count + 1 << std::endl;
}
else if (A % 2 == 1 && B % 2 == 0 && C % 2 == 0) {
int count = (C - B) / 2;
while (true) {
if (A > C)
break;
else {
A += 2;
++count;
}
}
std::cout << count + 1 << std::endl;
}
else if (A % 2 == 1 && B % 2 == 0 && C % 2 == 1) {
int count = (C - A) / 2;
while (true) {
if (B > C)
break;
else {
B += 2;
++count;
}
}
std::cout << count + 1 << std::endl;
}
else if (A % 2 == 0 && B % 2 == 1 && C % 2 == 1) {
int count = (C - B) / 2;
while (true) {
if (A > C)
break;
else {
A += 2;
++count;
}
}
std::cout << count + 1 << std::endl;
}
else if (A % 2 == 1 && B % 2 == 1 && C % 2 == 0) {
int count = (((C - 1) - B) / 2) + ((B - A) / 2);
std::cout << count + 1 << std::endl;
}
else if (A % 2 == 0 && B % 2 == 0 && C % 2 == 1) {
int count = (((C - 1) - B) / 2) + ((B - A) / 2);
std::cout << count + 1 << std::endl;
}
}
| 0
| 53,595,925
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <unordered_map>
#include <vector>
#include <string.h>
#include <set>
using namespace std;
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
#define rep(i, n) for(int i = 0; i < n; ++i)
#define all(s) s.begin(), s.end()
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> triple;
typedef double D;
const ll INF = 1e9;
const ll MOD = 1000000007;
struct V {
double x, y;
V(double x = 0, double y = 0) : x(x), y(y) {}
V& operator+=(const V& v) {
x += v.x; y += v.y;
return *this;
}
V& operator+(const V& v) const { return V(*this) += v; }
double dot(const V& v) const { return x*v.x + y*v.y; }
double cross(const V& v) const { return x*v.y - y*v.x; }
double norm() const { return sqrt(norm2()); }
double norm2() const { return x*x + y*y; }
int ort() const {
if (y > 0) {
return (x > 0) ? 1 : 2;
} else {
return (x > 0) ? 4 : 3;
}
}
bool operator<(const V& v) const {
int o = ort();
int vo = v.ort();
if (o != vo) { return o < vo; }
return cross(v) > 0;
}
};
istream& operator>>(istream& i, V& v) {
i >> v.x >> v.y;
return i;
}
ostream& operator<<(ostream& o, const V& v) {
o << "(" << v.x << ", " << v.y << ")";
return o;
}
int main(int argc, char** argv) {
int N;
cin >> N;
vector<V> v(N);
rep(i, N) {
cin >> v[i];
}
sort(all(v));
double ans = 0;
rep(i, N) {
V now(0, 0);
rep(j, N) {
now += v[(i + j) % N];
ans = max(ans, now.norm());
}
}
cout << fixed << setprecision(10) << ans << endl;
}
|
#include <iostream>
int main(void) {
std::string s1;
std::string s2;
std::getline(std::cin, s1);
std::getline(std::cin, s2);
bool compared = true;
for (int i = 0; i < s1.size(); i++) {
compared = true;
for (int j = 0; j < s2.size(); j++) {
int k = (i + j) % s1.size();
if (s1[k] != s2[j]) {
compared = false;
break;
}
}
if (compared) {
break;
}
}
if (compared) {
std::cout << "Yes";
} else {
std::cout << "No";
}
std::cout << std::endl;
return 0;
}
| 0
| 86,488,301
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if(n<=9){
cout << n << endl;
}
else if(n<=99){
cout << 9 << endl;
}
else if(n<=999){
cout << 9 + (n-100+1) << endl;
}
else if(n<=9999){
cout << 9 + (999-100+1) << endl;
}
else if(n<=99999){
cout << 9 + (999-100+1) + (n-10000+1) << endl;
}
else{
cout << 9 + (999-100+1) + (99999-10000+1) << endl;
}
}
|
#include<stdio.h>
int main()
{
int d,sum=0,t;
while(scanf("%d",&d) !=EOF)
{
sum=0;
t=d;
for(t;t<600;t+=d)
{
sum+=t*t*d;
}
printf("%d\n",sum);
}
return 0;
}
| 0
| 98,224,939
|
#include<iostream>
#include<vector>
using namespace std;
int main(){
int n, k;
while(cin >>n >>k){
if(n == 0 && k == 0) break;
vector<int> vec;
int max = 0, now = 0;
for(int i = 0; i < k; i++){
int tmp;
cin >>tmp;
max += tmp;
now += tmp;
vec.push_back(tmp);
}
for(int i = k; i < n; i++){
int tmp;
cin >>tmp;
vec.push_back(tmp);
now += tmp;
now -= vec[i - k];
if(max < now) max = now;
}
cout <<max <<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
#define per(i,n) for(int i = n-1; i >= 0; i--)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<long long, long long> Pll;
typedef vector<int> vi;
typedef vector<ll> vll;
int main() {
ll n;
cin >> n;
vll a(n);
rep(i,n) cin >> a.at(i);
sort(a.begin(),a.end());
reverse(a.begin(),a.end());
ll ans = 1;
int cnt = 0;
rep(i,n-1) {
if(a[i]==a[i+1]) {
ans *= a[i];
cnt++;
i++;
if(cnt==2) {
cout << ans << endl;
return 0;
}
}
}
cout << 0 << endl;
return 0;
}
| 0
| 49,339,321
|
#include <algorithm>
#include <iostream>
#include <stack>
#include <queue>
#include <cmath>
#include <string>
#include <iterator>
#include <map>
#include <set>
#include <iomanip>
#include <vector>
#include <cstdint>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
using Graph = vector<vector<int>>;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
#define rep(i, N) for(int i = 0; i < N; i++)
#define rep2(i, l, r) for (ll i = (ll)l; i < (ll)(r); i++)
#define INF 1000000000000000
#define MAX 200001
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
const ll MOD = 1000000007;
template <typename T > inline string toString(const T &a) {ostringstream oss; oss << a; return oss.str();};
int main(){
ll A, B, K;
cin >> A >> B >> K;
rep(i,K){
if(i % 2 == 0){
if(A % 2 != 0) A--;
B += A/2;
A /= 2;
}
else{
if(B % 2 != 0) B--;
A += B/2;
B /= 2;
}
}
cout << A << ' ' << B << endl;
}
|
#include<bits/stdc++.h>
#define ll long long
#define lowbit(x) (x&-x)
using namespace std;
const int N = 1e5+7, M = 1e3;
int a[N];
vector<int> vec[M];
int main()
{
int n;
scanf("%d", &n);n *= 2;
if(n==1)
{
puts("No");
return 0;
}
for(int i = 1; i*(i+1) <= n; i++)
{
if(i*(i+1)==n)
{
puts("Yes");
int siz = i, m = i+1, p = 0;
for(int i = 1; i <= m; i++)
{
int last = p;
while(vec[i].size()<siz)
{
vec[i].push_back(++p);
}
for(int j = i+1; j <= m; j++)
{
vec[j].push_back(++last);
}
}
printf("%d\n", m);
for(int i = 1; i <= m; i++)
{
printf("%d", siz);
for(int j = 0; j < siz; j++)
{
printf(" %d", vec[i][j]);
}
puts("");
}
return 0;
}
}
puts("No");
return 0;
}
| 0
| 1,662,181
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
int a[n];
int sum =0;
for(int i=0;i<n;i++)
{
cin>>a[i];
sum += a[i];
}
sum /= n;
int sum1 = sum+1;
int ans =0;
int ans2 = 0;
for(int i=0;i<n;i++)
{
ans += ( sum - a[i] )*( sum - a[i] );
ans2 += ( sum1 -a[i])*( sum1 -a[i] );
}
cout<<min( ans , ans2);
}
|
#include <bits/stdc++.h>
#define ll long long
#define pi 3.14159265358979
#define mod 1000000007
#define rep(i,n) for(ll i=0;i<n;i++)
using namespace std;
int main(){
ll a;
cin>>a;
string s;
string t;
vector<string> k(2*a);
cin>>s>>t;
rep(i,a){
k[2*i]=s[i];
k[2*i+1]=t[i];
}
rep(i,2*a){
cout<<k[i];
}
}
| 0
| 32,735,211
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define INF 1000000001
int main() {
int a,b,c;cin >> a>> b >> c;
ll sum=0;
for(int i = 0; i < b; i++) {
sum += a;
if(sum % b == c){
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );
using namespace std;
using ll = long long;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const ll INF = 1e9;
const ll MOD = 1e9 + 7;
int main(){
int n, m;
cin >> n >> m;
vector<vector<int>> G(n+1, vector<int>());
rep(i, m){
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
vector<int> ans(n+1), dist(n+1, INF);
queue<int> que;
que.push(1);
dist[1] = 0;
while(que.size() != 0){
int v = que.front();
que.pop();
for(auto nv: G[v]){
if(dist[nv] > dist[v]+1){
que.push(nv);
dist[nv] = dist[v] + 1;
ans[nv] = v;
}
}
}
cout << "Yes" << endl;
for(int i=2; i<=n; i++) cout << ans[i] << endl;
}
| 0
| 95,760,316
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,n;
int sum = 0;
cin >> N;
n = N;
for (int i = 0; i < N; i++) {
sum += N % 10;
N /= 10;
if (N % 10 == N) {
sum += N;
break;
}
}
if (n % sum == 0) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
}
|
#include <iostream>
#include <cstdio>
#include <map>
using namespace std;
int n, a[200005];
int lt=1, rt, md, ans;
int f(int p) {
int i, t;
map<int,int> mp;
if(p==1) {
for(i=2; i<=n; i++) if(a[i] <= a[i-1]) return 0;
return 1;
}
for(i=2; i<=n; i++) if(a[i] <= a[i-1]) {
t = a[i];
mp.erase(mp.upper_bound(t), mp.end());
for(; t && mp[t]==p-1; t--) mp.erase(t);
if(!t) return 0;
else mp[t]++;
}
return 1;
}
int main() {
cin >> n;
for(int i=1; i<=n; i++) scanf("%d", &a[i]);
rt = n;
while(lt<=rt) {
md = lt+rt >> 1;
if(f(md)) ans = md, rt = md-1;
else lt = md+1;
}
cout << ans;
return 0;
}
| 0
| 45,084,910
|
#include <bits/stdc++.h>
using namespace std;
#define modulo 1000000007
#define mod(mod_x) ((((long long)mod_x+modulo))%modulo)
#define Inf 1000000000
int main(){
string S;
cin>>S;
vector<int> dp(1<<26,Inf);
dp[0] = 0;
int now = 0;
for(int i=0;i<S.size();i++){
now ^= 1<<(S[i]-'a');
for(int j=0;j<26;j++){
dp[now] = min(dp[now],dp[now^(1<<j)]+1);
}
}
if(now!=0)cout<<dp[now]<<endl;
else cout<<1<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
#define f first
#define s second
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rall(x) rbegin(x), rend(x)
#define pb push_back
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) FOR(i, 0, a)
#define ROF(i, a, b) for (int i = (b); i >= (a); i--)
#define R0F(i, a) ROF(i, 0, a-1)
#define trav(x, a) for (auto& x: a)
const int MX = 2e5+5;
const int MOD = 1e9+7;
const ll INF = 1061109567;
const ld EPS = 1e-9;
const ld PI = acos(-1);
typedef pair<int,int> P;
typedef vector<P> vP;
#define X first
#define Y second
int distM(P x, P y) {
return abs(x.X-y.X)+abs(x.Y-y.Y);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int N, M; cin >> N >> M;
vP s(N), c(M);
trav(x, s) cin >> x.X >> x.Y;
trav(x, c) cin >> x.X >> x.Y;
bitset<MX> mk;
F0R(i, N) {
ii res = {-1,INF};
F0R(j, M) {
if (distM(s[i],c[j]) < res.s) {
res.s = distM(s[i],c[j]);
res.f = j;
}
}
cout << res.f+1 << "\n";
}
}
| 0
| 91,086,778
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <array>
#include <string>
#include <cmath>
#include <climits>
#include <cstdint>
using namespace std;
inline namespace atcoder {
template <typename T, size_t Depth>
struct vector_helper { using type = vector<typename vector_helper<T, Depth - 1>::type>; };
template <typename T>
struct vector_helper<T, 0> { using type = T; };
template <typename T, size_t Depth>
using vector_t = typename vector_helper<T, Depth>::type;
template <typename T> using vec = vector_t<T, 1>;
template <typename T> using vvec = vector_t<T, 2>;
template <typename T> using vvvec = vector_t<T, 3>;
constexpr int64_t mpow(int64_t a, int64_t b, int64_t mod = 1000000007) {
if (b <= 0) return 1; if (b == 1) return a % mod; if (b == 2) return (a * a) % mod;
return (max(a * (b & 1), (int64_t)1) * mpow(mpow(a, b / 2, mod), 2, mod)) % mod;
}
constexpr int64_t mdiv(int64_t a, int64_t b, int64_t mod = 1000000007) {
return (a * mpow(b, mod - 2, mod)) % mod;
}
}
int main() {
int x; cin >> x;
int m = 1;
while ((360 * m) % x) ++m;
cout << (360 * m) / x << endl;
}
|
#include <bits/stdc++.h>
#define f(i,j,k) for(int i=j;i<k;i++)
#define f2(i,j,k) for(int i=j;i>k;i--)
using namespace std;
int main(){
long long h,w;
cin>>h>>w;
char a[h][w];
vector<long long> H(h,0),W(w,0);
f(i,0,h){
long long c=0;
f(j,0,w){
cin>>a[i][j];
if(a[i][j]=='.'){
c++;
}
}
if(c==w){
H[i]=1;
}
}
f(j,0,w){
long long c=0;
f(i,0,h){
cin>>a[i][j];
if(a[i][j]=='.'){
c++;
}
}
if(c==h){
W[j]=1;
}
}
f(i,0,h){
if(H[i]==0){
f(j,0,w){
if(W[j]==0){
cout<<a[i][j];
}
}
cout<<endl;
}
}
return 0;
}
| 0
| 96,276,938
|
#include<bits/stdc++.h>
#define int long long
#define ll long long
#define pb push_back
#define endl '\n'
#define pii pair<int,int>
#define vi vector<int>
#define all(a) (a).begin(),(a).end()
#define F first
#define S second
#define sz(x) (int)x.size()
#define hell 1000000007
#define rep(i,a,b) for(int i=a;i<b;i++)
#define dep(i,a,b) for(int i=a;i>=b;i--)
#define lbnd lower_bound
#define ubnd upper_bound
#define bs binary_search
#define mp make_pair
using namespace std;
#define N 100005
ll n;
vi a[N];
bool vis[N];
ll dp[N][2];
void dfs(ll node, ll par){
dp[node][0]=1;
dp[node][1]=1;
for(auto i:a[node]){
if(i==par)continue;
dfs(i,node);
dp[node][0]=(dp[node][0]*(dp[i][0]+dp[i][1])%hell)%hell;
dp[node][1]=(dp[node][1]*dp[i][0])%hell;
}
}
void solve()
{
cin>>n;
rep(i,0,n-1){
ll x,y;
cin>>x>>y;
a[x].pb(y);
a[y].pb(x);
}
dfs(1,0);
cout<<(dp[1][0]+dp[1][1])%hell<<endl;
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS=1;
while(TESTS--)
{
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e9;
const static ll MOD = 1e9+7;
int main(){
string S, S_; cin >> S; S_ = S;
set<char> ST;
for(auto ch : S) ST.insert(ch);
for(int i = 0; i < 26; i++){
char add = i+97;
if(ST.find(add) == ST.end()){
S_+=add;
cout << S_ << endl;
return 0;
}
}
for(int i = S.size()-1; i >=0; i--){
char ch = S[i];
for(int j = (int)S[i]; j <= 122; j++){
if(ST.find((char)j) == ST.end() && S[i] < j){
S_[i] = j;
cout << S_ << endl;
return 0;
}
}
S_.erase(i);
ST.erase(ch);
}
cout << -1 << endl;
}
| 0
| 63,826,789
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int x = 1;
int y = 1;
for (int i = 0; i < N; i++){
y *= 2;
if (x + K <= y){
x += K;
}else{
x *= 2;
}
}
cout << x << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define fr(i,a,b) for (ll i = (a), _b = (b); i <= _b; i++)
#define frr(i,a,b) for (ll i = (a), _b = (b); i >= _b; i--)
#define rep(i,n) for (ll i = 0, _n = (n); i < _n; i++)
#define repr(i,n) for (ll i = n - 1; i >= 0; i--)
#define fill(ar,val) memset(ar, val, sizeof(ar))
#define fill0(ar) fill((ar), 0)
#define debug(x) cout<<#x<<": "<<x<<endl
#define ld double
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
typedef pair<int, int> ii;
typedef pair<ii, int> iii;
typedef vector<ii> vii;
typedef vector<int> vi;
#define INF 1000000000000000000
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll a,b;
cin >> a >> b;
cout << "100 100" << endl;
char ans[101][101];
rep(i,101)
{
rep(j,101)
{
ans[i][j] = 'g';
}
}
b--;
a--;
ll x = 1;
ll y = 1;
while(a!=0)
{
ans[x][y] = '.';
y+=2;
if(y>100)
{
y = 1;
x+=2;
}
a--;
}
fr(i,1,x)
{
fr(j,1,100)
{
if(ans[i][j]=='g')
ans[i][j] = '#';
}
}
x++;
fr(i,1,100)
{
ans[x][i] = '#';
}
x++;
fr(i,1,100)
{
ans[x][i] = '.';
}
x++;
ll x2 = x;
y = 1;
while(b!=0)
{
ans[x][y] = '#';
y+=2;
if(y>100)
{
y = 1;
x+=2;
}
b--;
}
fr(i,x2,100)
{
fr(j,1,100)
{
if(ans[i][j]=='g')
ans[i][j] = '.';
}
}
fr(i,1,100)
{
fr(j,1,100)
{
cout << ans[i][j];
}
cout << endl;
}
}
| 0
| 81,946,562
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define irep(i, n) for (int i = (n); i >= 0; i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1 << 30;
int main() {
int n, x; cin >> n >> x;
vector<int> co(n+1);
rep(i,n) {
int y; cin >> y;
co[i] = abs(x-y);
}
co[n] = co[n-1];
int ans;
if (co[0] == 0) ans = co[1];
else ans = co[0];
rep(i,n) {
if (co[i] == 0) continue;
ans = __gcd(ans,co[i]);
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
#include <cstring>
#include <queue>
#include <deque>
#include <stack>
#include <algorithm>
#include <utility>
#include <set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <math.h>
#include <tuple>
#include <iomanip>
#include <bitset>
#include <functional>
#define all(x) (x).begin(),(x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
typedef long double ld;
int dy4[4] = {-1, 0, +1, 0};
int dx4[4] = {0, +1, 0, -1};
int dy8[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dx8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long INF = 1LL << 62;
const ll MOD = 1e9 + 7;
bool greaterSecond(const pair<int, int>& f, const pair<int, int>& s){
return f.second > s.second;
}
ll gcd(ll a, ll b){
if (b == 0)return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b){
return a / gcd(a, b) * b;
}
ll conbinationMemo[100][100];
void cmemoInit(){
rep(i, 100){
rep(j, 100){
conbinationMemo[i][j] = -1;
}
}
}
ll nCr(ll n, ll r){
if(conbinationMemo[n][r] != -1) return conbinationMemo[n][r];
if(r == 0 || r == n){
return 1;
} else if(r == 1){
return n;
}
return conbinationMemo[n][r] = (nCr(n - 1, r) + nCr(n - 1, r - 1));
}
ll nPr(ll n, ll r){
r = n - r;
ll ret = 1;
for (ll i = n; i >= r + 1; i--) ret *= i;
return ret;
}
ll k;
vector<ll> a;
bool check(ll mid, int type){
ll now = mid;
for(int i = 0; i < k; i++){
now = now - (now % a[i]);
}
if(type == 0){
return now >= 2;
} else {
return now <= 2;
}
}
int main(void){
cin >> k;
a.resize(k);
rep(i, k) cin >> a[i];
ll ok = INF;
ll ng = 0;
pair<ll,ll> ans;
while(abs(ok - ng) > 1){
ll mid = (ok + ng) / 2;
if(check(mid, 0)){
ok = mid;
} else {
ng = mid;
}
}
ans.first = ok;
ok = 0;
ng = INF;
while(abs(ok - ng) > 1){
ll mid = (ok + ng) / 2;
if(check(mid, 1)){
ok = mid;
} else {
ng = mid;
}
}
ans.second = ok;
if(ans.first > ans.second){
cout << -1 << endl;
} else {
cout << ans.first << " " << ans.second << endl;
}
}
| 0
| 89,493,482
|
#include <cstdio>
using namespace std;
int main() {
char c;
unsigned int cnt = 0;
unsigned int max_cnt = 0;
for (int i=0;i<3;i++) {
scanf("%c", &c);
if (c == 'R') {
cnt++;
} else {
cnt = 0;
}
if (cnt > max_cnt)
max_cnt = cnt;
}
printf("%d\n", max_cnt);
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define REP(i,n) for (int64_t i=0; i<(n); ++i)
#define P pair<int,int>
using ll=int64_t;
using namespace std;
#define ketasuu(n) fixed<<setprecision(n)
#define btoe(p) p.begin(),p.end()
#define etob(p) p.rbegin(),p.rend()
int main(){
int n; cin>>n;
vector<int> p(n);
rep(i,n) cin>>p[i];
int sum=0;
rep(i,n-1){
sum+=abs(p[i]-p[i+1]);
}
sum+=abs(p[0]); sum+=abs(p[n-1]);
if(p[0]*(p[1]-p[0])>=0){
cout<<sum<<endl;
}else{
cout<<sum-2*min(abs(p[0]), abs(p[1]-p[0]))<<endl;
}
for(int i=1; i<n-1; ++i){
if((p[i-1]-p[i])*(p[i]-p[i+1])>=0){
cout<<sum<<endl;
}else{
cout<<sum-2*min(abs(p[i-1]-p[i]), abs(p[i]-p[i+1]))<<endl;
}
}
if((p[n-2]-p[n-1])*p[n-1]>=0){
cout<<sum<<endl;
}else{
cout<<sum-2*min(abs(p[n-2]-p[n-1]), abs(p[n-1]))<<endl;
}
return 0;
}
| 0
| 72,770,564
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
string s; cin >> s;
string ans = "";
for (auto &&c : s)
{
if (c == '1')
{
ans.push_back('1');
}
if (c == '0')
{
ans.push_back('0');
}
if (c == 'B' && !ans.empty())
{
ans.pop_back();
}
}
cout << ans << endl;
}
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
#include<set>
#include<string>
#include<stdio.h>
#include<cmath>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#define repn(i, n) for(int i = 1; i <= n; i++)
#define all(x) (x).begin(), (x).end()
#define lint long long
int main(){
int num[10] = {0,2,5,5,4,5,6,3,7,6};
int n, m; cin >> n >> m;
vector<int> a;
rep(i, m) { int x; cin >> x; a.push_back(x); }
sort(all(a), greater<int>());
int dp[10005];
dp[0] = 0;
repn(i, n){
dp[i] = -1;
rep(j, m){
if(i - num[a[j]] >= 0 && dp[i - num[a[j]]] >= 0){
dp[i] = max(dp[i], dp[i - num[a[j]]] + 1);
}
}
}
string ans = "";
int d = dp[n];
rep(i, d){
rep(j, m){
if(n - num[a[j]] >= 0 && dp[n - num[a[j]]] == dp[n] - 1){
ans = ans + to_string(a[j]);
n -= num[a[j]];
break;
}
}
}
cout<<ans<<endl;
}
| 0
| 77,176,739
|
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int64_t i = 0; i < (int64_t)(n); i++)
using vi = vector<int64_t>;
using vvi = vector<vi>;
int64_t INF = 1000000007;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int64_t n;
cin >> n;
vi a(n);
rep(i,n) cin >> a.at(i);
sort(a.begin(), a.end(), greater<>());
vi candidate;
int64_t temp = 1;
rep(i,n-1){
if((a.at(i) != a.at(i+1))){
if(temp>=4){
candidate.push_back(a.at(i));
candidate.push_back(a.at(i));
}else if(temp<4 && temp>=2){
candidate.push_back(a.at(i));
}
temp = 1;
continue;
}
temp++;
if(i == n-2){
if(temp>=4){
candidate.push_back(a.at(i));
candidate.push_back(a.at(i));
}else if(temp<4 && temp>=2){
candidate.push_back(a.at(i));
}
}
}
if(candidate.size()>=2){
cout << candidate.at(0) * candidate.at(1) << endl;
}else{
cout << 0 << endl;
}
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
int n;
map<ll, ll> mp;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
vector<ll> a(n);
ll mx = 0;
rep(i, n)
{
cin >> a[i];
chmax(mx, a[i]);
mp[a[i]]++;
}
ll k = (mx + 1) / 2;
ll d = k;
ll mi=k;
for (auto &it : mp)
{
if (it.first != mx)
{
if (abs(it.first - k) <= d)
{
d=abs(it.first - k);
mi=it.first;
}
}
}
if (mp[k] == 0 || k == mx)
k = mx - k;
cout << mx << " " << mi << endl;
return 0;
}
| 0
| 78,120,806
|
#include<iostream>
#include<algorithm>
#include <array>
int main(void){
int x,y,temp;
while(1){
std::cin >>x>>y;
if (x == 0&&y == 0){
break;
}
if (x > y){
std::swap(x, y);
}
std::cout << x <<" "<< y << std::endl;
}
return 0;
}
|
#include <iostream>
#include <bitset>
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
#include <set>
#include <map>
#include <stack>
#include <cmath>
#include <regex>
#include <iomanip>
#include <climits>
#include <utility>
#include <queue>
using namespace std;
using ll = long long int;
using dd = long double;
const ll MOD = 1e9 + 7;
const dd PI = 3.1415926435;
class UnionFind
{
public:
UnionFind(int N) : par(N)
{
for (ll 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;
}
private:
vector<int> par;
};
ll gcd(ll a, ll b)
{
if (a % b == 0)
{
return b;
}
return gcd(b, a % b);
}
ll fact(ll n)
{
if (n == 0)
{
return 1;
}
if (n == 1)
{
return 1;
}
return n * fact(n - 1) % MOD;
}
ll pow_fast(ll n, ll k)
{
if (k == 0)
{
return 1;
}
if (k == 1)
{
return n;
}
if (k % 2 == 0)
{
ll tmp = pow_fast(n, k / 2LL);
return tmp * tmp % MOD;
}
else
{
ll tmp = pow_fast(n, k / 2LL);
tmp *= tmp;
tmp %= MOD;
return tmp * n % MOD;
}
}
map<ll, ll> sosuu(ll n)
{
map<ll, ll> res;
for (ll i = 2; i * i <= n; i++)
{
while (n % i == 0)
{
res[i] += 1;
n /= i;
}
}
if (n != 1)
{
res[n] += 1;
}
return res;
}
struct Dish
{
ll time;
ll taste;
};
static ll FACTORIAL[10000010] = {};
ll nCk(ll n, ll k)
{
if (FACTORIAL[1] == 0)
{
FACTORIAL[0] = 1;
FACTORIAL[1] = 1;
for (ll i = 2; i <= 10000000; i++)
{
FACTORIAL[i] = FACTORIAL[i - 1] * i;
FACTORIAL[i] %= MOD;
}
}
ll N_fact = FACTORIAL[n];
ll K_fact = pow_fast(FACTORIAL[k], MOD - 2);
ll N_K_fact = pow_fast(FACTORIAL[n - k], MOD - 2);
ll ret = N_fact;
ret %= MOD;
ret *= K_fact;
ret %= MOD;
ret *= N_K_fact;
ret %= MOD;
return ret;
}
void solve(string s, ll K)
{
ll sum = 0;
for (ll i = s.size(); i <= s.size() + K; i++)
{
ll cnt = pow_fast(25, i - s.size()) % MOD;
cnt *= nCk(i - 1, s.size() - 1);
cnt %= MOD;
cnt *= pow_fast(26, s.size() + K - i);
cnt %= MOD;
sum += cnt;
sum %= MOD;
}
cout << sum << endl;
return;
}
vector<string> explode(string s, char delim)
{
vector<string> ret;
string cur;
for (ll i = 0; i < s.size(); i++)
{
if (s[i] == delim)
{
ret.push_back(cur);
cur.clear();
continue;
}
cur += s[i];
}
if (cur.size() != 0) {
ret.push_back(cur);
}
return ret;
}
int main()
{
ll N, M;
cin >> N >> M;
vector<pair<ll, ll>> mul(M + 1);
vector<map<ll, ll>> order(N + 1);
for (ll i = 0; i < M; i++)
{
ll pi, yi;
cin >> pi >> yi;
mul[i] = {pi, yi};
order[pi][yi] += 1;
}
for (ll i = 1; i <= N; i++)
{
ll num = 1;
for (auto &&e : order[i])
{
order[i][e.first] = num;
num += 1;
}
}
for (ll i = 0; i < M; i++)
{
cout << fixed << setw(6) << setfill('0') << mul[i].first;
cout << fixed << setw(6) << setfill('0') << order[mul[i].first][mul[i].second];
cout << endl;
}
}
| 0
| 42,363,284
|
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int MAXN=100005;
int n,m;
vector<int> adj[MAXN];
int col[MAXN];
bool dfs(int u,int color)
{
if(col[u])
return color==col[u];
col[u]=color;
bool ret=true;
for(int i=0;i<(int)adj[u].size();i++)
{
int v=adj[u][i];
if(!dfs(v,color==1?2:1))
ret=false;
}
return ret;
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
{
int u,v;
scanf("%d%d",&u,&v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int a=0,b=0,c=0;
for(int i=1;i<=n;i++)
if(!col[i])
{
if(adj[i].size()==0U)
c++,col[i]=1;
else
{
if(dfs(i,1))
a++;
else
b++;
}
}
long long ans=1LL*c*c+2LL*c*(n-c)+2LL*a*a+2LL*a*b+1LL*b*b;
printf("%lld\n",ans);
return 0;
}
|
#include<stdio.h>
int main()
{
int n, m, mult, sum;
scanf("%d %d", &n, &m);
mult = n * 3;
sum = m + mult;
printf("%d\n", sum/2);
}
| 0
| 97,606,427
|
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
using namespace std;
typedef long long ll;
int main(){
string N;
cin >> N;
if (N.find("7") == string::npos) cout << "No" << endl;
else cout << "Yes" << endl;
}
|
#include <iostream>
using namespace std;
typedef long long ll;
int main(){
int N;
cin>>N;
ll res=1;
for(int i=1;i<=N;i++){
res*=(ll)i;
}
cout<<res<<endl;
return 0;
}
| 0
| 67,849,109
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
bool a=true;
char C='a';
vector<string> W(N);
for(int i=0;i<N;i++){
cin >> W.at(i);
if(i!=0){
if(W.at(i).at(0)!=C){
a=false;
}
}
C=W.at(i).at(W.at(i).size()-1);
}
sort(W.begin(),W.end());
for(int i=0;i<N-1;i++){
if(W.at(i)==W.at(i+1)){
a=false;
}
}
if(a){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
}
|
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#define pi 3.141592653589793238
#define int long long
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
int cc[305];
int dp[305][305][305];
int pre[305][305];
int suf[305][305];
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
#ifndef ONLINE_JUDGE
if(fopen("INPUT.txt","r"))
{
freopen ("INPUT.txt" , "r" , stdin);
freopen ("OUTPUT.txt" , "w" , stdout);
}
#endif
fill_n(&dp[0][0][0],305*305*305,1e17);
dp[0][0][0]=0;
int n,k;
cin>>n>>k;
int h[n+1];
for(int i=1;i<=n;i++)
{
cin>>h[i];
cc[i]=h[i];
}
sort(cc+1,cc+n+1);
cc[n+1]=1e17;
fill_n(&pre[0][0],305*305,1e17);
fill_n(&suf[0][0],305*305,1e17);
pre[0][0]=cc[n];
for(int j=1;j<=n;j++)
{
pre[j][0]=cc[n];
}
suf[0][0]=0;
for(int i=1;i<=n;i++)
{
for(int j=0;j<=n;j++)
{
for(int l=0;l<=k;l++)
{
if(cc[j]==h[i])
{
dp[i][j][l]=min(suf[j][l],pre[j][l]-(cc[n]-cc[j]));
}
else
{
if(l>0)
dp[i][j][l]=min(suf[j][l-1],pre[j][l-1]-(cc[n]-cc[j]));
}
}
}
fill_n(&pre[0][0],305*305,1e17);
fill_n(&suf[0][0],305*305,1e17);
for(int l=0;l<=k;l++)
{
for(int j=0;j<=n;j++)
{
if(j==0)
pre[j][l]=dp[i][j][l]+cc[n];
else
pre[j][l]=min(dp[i][j][l]+cc[n]-cc[j],pre[j-1][l]);
}
}
for(int l=0;l<=k;l++)
{
for(int j=n;j>=0;j--)
{
suf[j][l]=min(dp[i][j][l],suf[j+1][l]);
}
}
}
int mn=1e17;
for(int i=0;i<=n;i++)
for(int j=0;j<=k;j++)
mn=min(mn,dp[n][i][j]);
cout<<mn;
clock_t clk;
clk = clock();
clk = clock() - clk;
cerr << fixed << setprecision(6) << "Time: " << ((double)clk)/CLOCKS_PER_SEC << "\n";
return 0;
}
| 0
| 35,120,965
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(x,n) for(int x=0;x<n;x++)
#define vei vector<int>
#define velli vector<long long int>
#define pb(x) push_back(x)
#define pb2 pop_back()
#define all(x) (x).begin(),(x).end()
#define be(x) (x).begin()
typedef pair<int,int> P;
int main(){
int n, m; cin >> n >> m;
vector<vector<int>> s(m);
for(int i=0; i<m; i++){
int k; cin >> k;
for(int j=0; j<k; j++){
int ss; cin >> ss;
ss--;
s[i].push_back(ss);
}
}
vector<int> p(m);
for(int i=0; i<m; i++){
cin >> p[i];
}
int ans = 0;
for(int bit=0; bit < (1 << n); bit++){
int ok = 1;
for(int li=0; li<m; li++){
int num_swi = 0;
for(int i=0; i<s[li].size(); i++){
if(bit & (1 << s[li][i])) num_swi++;
}
if(num_swi % 2 != p[li]){
ok = 0;
break;
}
}
if(ok==1) ans++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define all(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vc = vector<char>;
using vb = vector<bool>;
using vs = vector<string>;
using vll = vector<long long>;
using vp = vector<pair<int, int>>;
using vvi = vector<vector<int>>;
using vvc = vector<vector<char>>;
using vvll = vector<vector<long long>>;
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 (b<a) {a=b; return 1;} return 0;}
const int INF = 1001001001;
double f(int v, int s, int e, double t) {
if (t < s) return v + (s - t);
else if (s <= t && t <= e) return v;
else return v + (t - e);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vi t(n), v(n);
rep(i, n) cin >> t[i];
rep(i, n) cin >> v[i];
vi smt(n+1, 0);
rep(i, n) smt[i+1] = smt[i] + t[i];
vector<double> ans(2*smt[n]+1, INF);
rep(i, sz(ans)) {
double t = i / 2.0;
chmin(ans[i], t);
rep(j, n) {
chmin(ans[i], f(v[j], smt[j], smt[j+1], t));
}
chmin(ans[i], smt[n] - t);
}
double dist = 0;
rep(i, sz(ans) - 1) {
dist += (ans[i] + ans[i+1]) / 4.0;
}
cout << fixed << setprecision(15) << dist << endl;
}
| 0
| 96,233,375
|
#include <bits/stdc++.h>
#define int long long
using namespace std;
#define rep(i,s,n) for(int i = s;i<n;i++)
#define repe(i,s,n) for(int i = s;i<=n;i++)
#define pb push_back
#define fi first
#define se second
typedef long long ll;
typedef pair<int,int>pint;
typedef vector<int>vint;
typedef vector<pint>vpint;
static const ll maxLL = (ll)1 << 62;
const ll MOD=1000000007,INF=1e18;
int dy[]={-1,0,1,0};
int dx[]={0,1,0,-1};
int x,y;
bool A;
signed main(){
cin>>x>>y;
if(abs(x-y)<=1){
cout<<"Brown"<<endl;
}else cout<<"Alice"<<endl;
return 0;
}
|
#include <iostream>
#include <iomanip>
#include <utility>
#include <cmath>
#include <random>
#include <vector>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <string>
#include <algorithm>
using namespace std;
#define rep(i,n) for(int i = 0; i<n; ++i)
#define REP(i,n) for(int i = 1; i<=n; ++i)
#define all(x) begin(x),end(x)
#define show(obj) {for(auto x:obj)cout<<x<<' ';cout<<endl;}
#define line "----------"
typedef long long ll;
typedef pair<int,int> ip;
typedef pair<ll,ll> lp;
const int inf = 1001001000;
const ll INF = 1LL<<60;
const int MOD = (int)1e9 + 7;
map<ll, ll> prime_factor(ll n){
map<ll,ll> com;
for(ll i = 2LL; i*i<=n; ++i){
while(n%i==0LL){
com[i]++;
n /= i;
}
}
if(n != 1LL)com[n]++;
return com;
}
int main(){
int N;
cin >> N;
map<ll, ll> facts;
REP(i,N){
map<ll, ll> t = prime_factor(i);
for(auto x:t){
facts[x.first] += x.second;
}
}
int ans = 0;
for(auto x:facts){
if(x.second >= 74) ++ans;
}
for(auto x:facts){
for(auto y:facts){
if(!(x.first < y.first))continue;
if(x.second >= 2 && y.second >= 24) ++ans;
if(x.second >= 24 && y.second >= 2) ++ans;
}
}
for(auto x:facts){
for(auto y:facts){
if(!(x.first < y.first))continue;
if(x.second >= 4 && y.second >= 14) ++ans;
if(x.second >= 14 && y.second >= 4) ++ans;
}
}
for(auto x: facts){
for(auto y:facts){
for(auto z: facts){
if(!(x.first < y.first && y.first < z.first))continue;
int a = (x.second >= 2) + (y.second >= 2) + (z.second >= 2);
int b = (x.second >= 4) + (y.second >= 4) + (z.second >= 4);
if(a >= 3 && b >= 3) ans += 3;
else if(a >= 3 && b >= 2) ++ans;
}
}
}
cout << ans << endl;
return 0;
}
| 0
| 45,441,538
|
#include <iostream>
#include <climits>
#include <vector>
class TMinimumMultiplications
{
std::vector<std::vector<int> > FTable;
std::vector<std::pair<int, int> >& FMatrixChain;
int GetMinimum(int Begin, int End);
public:
TMinimumMultiplications(std::vector<std::pair<int, int> >& MatrixChain);
int Get(int Begin, int End);
};
TMinimumMultiplications::TMinimumMultiplications(std::vector<std::pair<int, int> >& MatrixChain)
: FMatrixChain(MatrixChain), FTable(MatrixChain.size(), std::vector<int>(MatrixChain.size(), -1))
{
}
int TMinimumMultiplications::GetMinimum(int Begin, int End)
{
int Minimum = INT_MAX;
for(int i = Begin; i < End; ++i){
int Total = Get(Begin, i) + Get(i + 1, End) + FMatrixChain[Begin].first * FMatrixChain[i + 1].first * FMatrixChain[End].second;
if(Minimum > Total) Minimum = Total;
}
return Minimum;
}
int TMinimumMultiplications::Get(int Begin, int End)
{
if(Begin == End) return 0;
if(FTable[Begin][End] < 0){
FTable[Begin][End] = GetMinimum(Begin, End);
}
return FTable[Begin][End];
}
int main()
{
int Count;
std::cin >> Count;
std::vector<std::pair<int, int> > MatrixChain;
for(int i = 0; i < Count; ++i){
int Row, Col;
std::cin >> Row >> Col;
MatrixChain.push_back(std::make_pair(Row, Col));
}
TMinimumMultiplications Minimum(MatrixChain);
std::cout << Minimum.Get(0, MatrixChain.size() - 1) << std::endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
bool same(int x){
vector<int> v;
while(x){
v.push_back(x%10);
x/=10;
}
int a=v[0];
for(int i=1;i<v.size();i++) if(v[i]!=a) return 0;
return 1;
}
signed main(){
int n;
cin>>n;
while(!same(n)) n++;
cout<<n;
return 0;
}
| 0
| 65,602,131
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define pp pair<int,int>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define ld long double
#define al(a) (a).begin(),(a).end()
#define mk make_pair
#define check cout<<"?"<<endl;
ll MOD=1000000007;
ll mod=998244353;
int inf=1000001000;
ll INF=1e18+5;
int main(){
string s; cin>>s;
for(auto &ch:s){
if(ch=='1') ch='9';
else if(ch=='9') ch='1';
}
cout<<s<<endl;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <math.h>
#include <iomanip>
using namespace std;
#define int long long
signed main(){
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int n,k; cin >> n >> k;
vector<int> a(n),b(n);
for(int i = 0;i < n;i ++) cin >> a.at(i) >> b.at(i);
vector<int> count(100001);
for(int i = 0;i < n;i ++){
count.at(a.at(i)) += b.at(i);
}
int sum = 0;
for(int i = 0;i < 100001;i ++){
sum += count.at(i);
if(sum >= k){
cout << i << endl;
return 0;
}
}
}
| 0
| 99,458,890
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.