code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 44
101M
|
|---|---|---|---|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <functional>
#include <ctime>
#include <cmath>
#include <limits>
#include <numeric>
#include <type_traits>
#include <iomanip>
#include <float.h>
#include <math.h>
using namespace std;
using ll = long long;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b) return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
ll ll_gcd(ll a, ll b) {
if (a < b) return ll_gcd(b, a);
ll r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
struct UnionFind {
vector <ll> par;
vector <ll> siz;
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
ll root(ll x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) {
return root(x) == root(y);
}
ll size(ll x) {
return siz[root(x)];
}
};
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
long long modinv(long long a, long long mod) {
return modpow(a, mod - 2, mod);
}
vector<int> tpsort(vector<vector<int>>& G) {
int V = G.size();
vector<int> sorted_vertices;
queue<int> que;
vector<int> indegree(V);
for (int i = 0; i < V; i++) {
for (int j = 0; j < G[i].size(); j++) {
indegree[G[i][j]]++;
}
}
for (int i = 0; i < V; i++) {
if (indegree[i] == 0) {
que.push(i);
}
}
while (que.empty() == false) {
int v = que.front();
que.pop();
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i];
indegree[u] -= 1;
if (indegree[u] == 0) que.push(u);
}
sorted_vertices.push_back(v);
}
return sorted_vertices;
}
struct Point
{
double x;
double y;
};
struct LineSegment
{
Point start;
Point end;
};
double tenkyori(const LineSegment& line, const Point& point)
{
double x0 = point.x, y0 = point.y;
double x1 = line.start.x, y1 = line.start.y;
double x2 = line.end.x, y2 = line.end.y;
double a = x2 - x1;
double b = y2 - y1;
double a2 = a * a;
double b2 = b * b;
double r2 = a2 + b2;
double tt = -(a * (x1 - x0) + b * (y1 - y0));
if (tt < 0)
return sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0));
else if (tt > r2)
return sqrt((x2 - x0) * (x2 - x0) + (y2 - y0) * (y2 - y0));
double f1 = a * (y1 - y0) - b * (x1 - x0);
return sqrt((f1 * f1) / r2);
}
template <typename X>
struct SegTree {
using FX = function<X(X, X)>;
int n;
FX fx;
const X ex;
vector<X> dat;
SegTree(int n_, FX fx_, X ex_) : n(), fx(fx_), ex(ex_), dat(n_ * 4, ex_) {
int x = 1;
while (n_ > x) {
x *= 2;
}
n = x;
}
void set(int i, X x) { dat[i + n - 1] = x; }
void build() {
for (int k = n - 2; k >= 0; k--) dat[k] = fx(dat[2 * k + 1], dat[2 * k + 2]);
}
void update(int i, X x) {
i += n - 1;
dat[i] = x;
while (i > 0) {
i = (i - 1) / 2;
dat[i] = fx(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
X query(int a, int b) { return query_sub(a, b, 0, 0, n); }
X query_sub(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) {
return ex;
}
else if (a <= l && r <= b) {
return dat[k];
}
else {
X vl = query_sub(a, b, k * 2 + 1, l, (l + r) / 2);
X vr = query_sub(a, b, k * 2 + 2, (l + r) / 2, r);
return fx(vl, vr);
}
}
};
template <typename X, typename M>
struct SegTreeLazy {
using FX = function<X(X, X)>;
using FA = function<X(X, M)>;
using FM = function<M(M, M)>;
int n;
FX fx;
FA fa;
FM fm;
const X ex;
const M em;
vector<X> dat;
vector<M> lazy;
SegTreeLazy(int n_, FX fx_, FA fa_, FM fm_, X ex_, M em_)
: n(), fx(fx_), fa(fa_), fm(fm_), ex(ex_), em(em_), dat(n_ * 4, ex), lazy(n_ * 4, em) {
int x = 1;
while (n_ > x) x *= 2;
n = x;
}
void set(int i, X x) { dat[i + n - 1] = x; }
void build() {
for (int k = n - 2; k >= 0; k--) dat[k] = fx(dat[2 * k + 1], dat[2 * k + 2]);
}
void eval(int k) {
if (lazy[k] == em) return;
if (k < n - 1) {
lazy[k * 2 + 1] = fm(lazy[k * 2 + 1], lazy[k]);
lazy[k * 2 + 2] = fm(lazy[k * 2 + 2], lazy[k]);
}
dat[k] = fa(dat[k], lazy[k]);
lazy[k] = em;
}
void update(int a, int b, M x, int k, int l, int r) {
eval(k);
if (a <= l && r <= b) {
lazy[k] = fm(lazy[k], x);
eval(k);
}
else if (a < r && l < b) {
update(a, b, x, k * 2 + 1, l, (l + r) / 2);
update(a, b, x, k * 2 + 2, (l + r) / 2, r);
dat[k] = fx(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
void update(int a, int b, M x) { update(a, b, x, 0, 0, n); }
X query_sub(int a, int b, int k, int l, int r) {
eval(k);
if (r <= a || b <= l) {
return ex;
}
else if (a <= l && r <= b) {
return dat[k];
}
else {
X vl = query_sub(a, b, k * 2 + 1, l, (l + r) / 2);
X vr = query_sub(a, b, k * 2 + 2, (l + r) / 2, r);
return fx(vl, vr);
}
}
X query(int a, int b) { return query_sub(a, b, 0, 0, n); }
};
int main() {
ll n,k;
cin >> n >> k;
vector<pair<ll,ll>> z(n);
for (int i = 0; i < n; i++) {
cin >> z[i].first >> z[i].second;
}
sort(z.begin(), z.end());
reverse(z.begin(), z.end());
vector<ll> ok;
vector<ll> ng;
ok.push_back(z[0].second);
for (int i = 1; i < n; i++) {
if (z[i].first == z[i - 1].first) {
ng.push_back(z[i].second);
}
else {
ok.push_back(z[i].second);
}
}
sort(ok.begin(), ok.end());
reverse(ok.begin(), ok.end());
sort(ng.begin(), ng.end());
reverse(ng.begin(), ng.end());
ll o = ok.size();
ll g = ng.size();
vector<ll> okk(o+1);
vector<ll> ngg(g+1);
for (int i = 0; i < o; i++) {
okk[i + 1] = okk[i] + ok[i];
}
for (int i = 0; i < g; i++) {
ngg[i + 1] = ngg[i] + ng[i];
}
ll ans = 0;
ll zr = 0;
for (ll i = max(zr,k - g); i < min(o + 1,k+1); i++) {
ans = max(okk[i] + ngg[k - i] + i * i, ans);
}
cout << ans << endl;
}
|
#define _USE_MATH_DEFINES
#include <math.h>
#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <algorithm>
#include <numeric>
#include <stdio.h>
#include <vector>
#include <map>
#include <queue>
using namespace std;
typedef long long ll;
#define rep(i, n) for(ll i = 0; i < (ll)(n); i++)
int main() {
ll N;
string S;
cin >> N >> S;
ll out = 0;
rep(i,1000){
string str = to_string(i);
if(str.size()==1) str = "00" + str;
else if(str.size()==2) str = "0" +str;
ll cnt = 0;
rep(j,N){
if(S[j]==str[cnt]){
cnt++;
if(cnt==3){
out++;
break;
}
}
}
}
cout << out << endl;
return 0;
}
| 0
| 59,905,537
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int,int> P;
int INF = 1e9+7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
signed main() {
int N;
cin >> N;
int ans = 0;
vector<int>a(N);
for(int i = 0; i < N; i++) {
cin >> a[i];
if(i) {
if(a[i] == a[i-1]) {
ans++;
a[i] = 10000+i;
}
}
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long LL;
typedef vector<ll>VI;
typedef vector<bool>VB;
typedef pair<ll,ll>P;
typedef pair<double,double>P_D;
#define VV(T) vector<vector<T>>
#define PI 3.1415926535897932384626433832795
#define rep(i, n) for (ll i = 0; i < (ll)n; i++)
#define reprev(i, n) for (ll i = (ll)n - 1; i >= 0; i--)
#define bitrep(bit,A) for(int bit=A; ;bit=(bit-1)&A)
#define ALL(a) (a).begin(),(a).end()
#define SZ(a) (ll)((a).size())
#define c_max(a, b) (((ll)a)>((ll)b)?(a):(b))
#define c_min(a,b) (((ll)a)<((ll)b)?(a):(b))
#define chmax(x,a) x=c_max(x,a)
#define chmin(x,a) x=c_min(x,a)
#define vmax(v) *max_element(ALL(v))
#define vmin(v) *min_element(ALL(v))
#define SORT(c) stable_sort(ALL(c))
#define $(x) {cout<<#x<<" = " <<(x)<<endl;}
#define fi first
#define se second
#define MAX 100100
#define MAX2 200100
#define MAX_6 1001001
#define MAX_7 10010010
#define SENTINEL 2000000000
#define NIL -1
const int MOD = 1000000007;
#define INF 1<<30
#define INFTY 1LL<<61
#define MAX_INT INT_MAX
#define Endl '\n'
#define greater greater<int>()
inline ll GCD(ll a,ll b){return b?GCD(b,a%b):a;}
inline ll lcm(ll a,ll b){return a*b/GCD(a,b);}
using Edge=pair<int,ll>;
using Graph=vector<vector<ll> >;
using Edge=pair<int,ll>;
int score[MAX2];
void dfs(Graph &tree,ll v,int p,int s){
score[v]+=s;
for(auto node:tree[v]){
if(node==p)continue;
dfs(tree,node,v,score[v]);
}
}
int main(){
memset(score,0,sizeof(score));
int n,q;
cin>>n>>q;
Graph tree(n);
rep(i,n-1){
int a,b;cin>>a>>b;
a--;b--;
tree[a].push_back(b);
tree[b].push_back(a);
}
rep(i,q){
int p,x;cin>>p>>x;
p--;
score[p]+=x;
}
dfs(tree,0,0,0);
rep(i,n){
cout<<score[i]<<" ";
}
cout<<endl;
}
| 0
| 51,035,562
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
long double a, b;
cin >> a >> b;
for (long double n = 1; n < 10000; n++)
{
if (floor(n * 0.08) == a && floor(n * 0.1) == b)
{
cout << n << endl;
return 0;
}
}
cout << -1 << endl;
}
|
#include<bits/stdc++.h>
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
using namespace std;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
const long long INF = 1LL << 60;
int main()
{
int N;
cin >> N;
int A[100010];
rep(i,N) cin >> A[i];
sort(A,A+N);
int M = 0;
int ans[100010][2];
int y;
int x;
x = A[N-1];
y = A[0];
rep(i,1,N-1){
if(A[i]<0){
ans[i-1][0] = x;
ans[i-1][1] = A[i];
x -= A[i];
}else{
ans[i-1][0] = y;
ans[i-1][1] = A[i];
y -= A[i];
}
}
ans[N-2][0] = x;
ans[N-2][1] = y;
M = x-y;
cout << M << endl;
rep(i,N-1){
cout << ans[i][0] << " " << ans[i][1] << endl;
}
}
| 0
| 15,591,315
|
#include<stdio.h>
int main(){
long long int N;
scanf("%lld",&N);
long long int A[N];
long long int i;
long long int prod=1;
long long int x=1e18;
for(i=0;i<N;i++){
scanf("%lld",&A[i]);
}
for(i=0;i<N;i++){
if(A[i]==0){
puts("0");
return 0;
}
}
for(i=0;i<N;i++){
if(A[i]<=x/prod){
prod*=A[i];
}
else{
puts("-1");
return 0;
}
}
printf("%lld\n",prod);
return 0;
}
|
#include <iostream>
#include<sstream>
#include<string>
#include<vector>
#include <cmath>
#include <limits>
#include <queue>
#include<algorithm>
#include<cstring>
#include <cstdlib>
#include <cstdio>
#include <set>
#include <iomanip>
#include <map>
#include <stack>
#include <memory>
#include <numeric>
#include <type_traits>
using namespace std;
#define rep(i,n) for (int (i)=0;(i)<(n);i++)
typedef long long ll;
const int maxN = 1e5;
const ll maxV = 1e14;
const int NIL = -1;
const int white = 0, gray = 1;
ll TRAV[maxN];
int COLOR[maxN];
struct Edge{
int from, to;
ll length;
};
struct Node{
vector<Edge> e;
};
Node T[maxN];
void dfs(int k){
rep(i,T[k].e.size()){
Edge e = T[k].e[i];
if (COLOR[e.to] == gray) continue;
else{
TRAV[e.to] = TRAV[k]+e.length;
COLOR[e.to] = gray;
dfs(e.to);
}
}
}
int main() {
int n;
cin >> n;
rep(i,n){
COLOR[i] = white;
}
int a,b; ll c;
Edge e;
rep(i,n-1){
cin >> a >> b >> c;
--a; --b;
e.from = a; e.to = b; e.length = c;
T[a].e.push_back(e);
e.from = b; e.to = a;
T[b].e.push_back(e);
}
int q,k;
cin >> q >> k;
--k;
TRAV[k] = 0;
COLOR[k] = gray;
dfs(k);
int x[q],y[q];
rep(i,q){
cin >> x[i] >> y[i];
}
rep(i,q){
cout << TRAV[x[i]-1]+TRAV[y[i]-1] << endl;
}
return 0;
}
| 0
| 34,643,195
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
#define F first
#define S second
using namespace std;
template<class T>bool chmax(T &a, const T &b) { if(a < b){ a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if(a > b){ a = b; return 1; } return 0; }
int main()
{
int n,m ; cin >> n >> m;
vector<int> l(m),r(m);
rep(i,m) {
cin >> l[i] >> r[i];
}
using pi = pair<int,int>;
vector<pi> vec;
rep(i,m) {
vec.push_back({l[i], 1});
vec.push_back({r[i] + 1, -1});
}
sort(vec.begin(), vec.end());
int len = vec.size();
int idx = 0;
int cnt = 0;
int res = 0;
rep1(i,n) {
while(idx < len && vec[idx].F == i) {
cnt += vec[idx].S;
idx++;
}
if(cnt == m) res++;
}
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
typedef pair<ll, ll> l4;
typedef pair<double, double> dd;
#define mp make_pair
#define pb push_back
#define debug(x) cerr << #x << " = " << x << " "
const int N = 5e3+2;
bitset<N> bl[N], br[N];
int n, k;
void print(bitset<N> bit)
{
cerr << "bit contains";
for (int i = 0; i <= k; ++i)
if (bit[i] == 1)
cerr << " " << i;
cerr << endl;
}
int main()
{
while (~scanf("%d %d", &n, &k))
{
vector<int> v;
for (int i = 0; i < n; ++i)
{
int x;
scanf("%d", &x);
if (x < k) v.pb(x);
}
bl[0].reset();
bl[0][0] = 1;
for (int i = 0; i < v.size(); ++i)
{
bl[i+1] = bl[i] | (bl[i] << v[i]);
}
br[v.size()+1].reset();
br[v.size()+1][0] = 1;
for (int i = int(v.size())-1; i >= 0; --i)
{
br[i+1] = br[i+2] | (br[i+2] << v[i]);
}
int ans = v.size();
for (int i = 0; i < v.size(); ++i)
{
int need = k - v[i];
int r = k;
for (int l = 0; l < k; ++l)
if (bl[i][l] == 1)
{
while (r >= 0 && (r+l >= k || br[i+2][r] == 0)) --r;
if (r == -1)
{
}
else if (l + r >= need)
{
--ans; break;
}
}
}
printf("%d\n", ans);
}
}
| 0
| 40,620,257
|
#include<bits/stdc++.h>
using namespace std;
int main(){
long long t,i,p=0;
string s;
cin>>s;
t=s.size();
for(i=0;i<t;i++){
if(s[i]=='o')
p++;
}p=p+15-t;
if(p>=8)
cout<<"YES";
else
cout<<"NO";
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
signed main(){
ll w,h,adx,ady,sum=0;
vector<P> pq;
cin >> w >> h;
ll p[w],q[h];
adx=h+1;
ady=w+1;
for(int i=0;i<w;i++){
cin >> p[i];
pq.push_back(P(p[i],0));
}
for(int i=0;i<h;i++){
cin >> q[i];
pq.push_back(P(q[i],1));
}
sort(pq.begin(),pq.end());
for(int i=0;i<pq.size();i++){
if(pq[i].second==0){
sum += pq[i].first*adx;
ady = max(ady-1,(ll)0);
}else{
sum += pq[i].first*ady;
adx = max(adx-1,(ll)0);
}
}
cout << sum<<endl;
}
| 0
| 9,946,427
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
int n;
cin>>n;
ll a,b;
vector<tuple<ll, ll, ll>> ab(n);
for(int i=0; i<n; i++){
cin >> a >> b;
ab[i] = make_tuple(a+b, a, b);
}
sort(ab.rbegin(), ab.rend());
ll ans = 0LL;
for(int i=0; i<n; i++){
if(i%2==0)
ans += get<1>(ab[i]);
else
ans -= get<2>(ab[i]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
typedef long long ll;
typedef pair<ll,ll> prl;
typedef vector<ll> vcl;
typedef map<ll,ll> mapl;
typedef unordered_map<ll,ll> umap;
#define pb push_back
#define all(v) v.begin(), v.end()
#define rep(i,a,b) for(ll i=a;i<=b;i++)
#define repi(i,a,b) for(int i=a;i<=b;i++)
#define repr(i,a,b) for(ll i=a;i>=b;i--)
#define reps(i,v) for(ll i=0;i<v.size();i++)
template<typename T> void chmin(T &a, const T &b) { a = min(a, b); }
template<typename T> void chmax(T &a, const T &b) { a = max(a, b); }
const ll mod = 1e9+7;
int main() {
ll n,a[100005]={0},b[100005],c[100005],pv,ans=0;
bool ok=false;
cin >> n;
rep(i,0,n){
cin >> a[i];
}
rep(i,0,n){
if(i==0){
if(a[i]>1){
cout << -1 << endl;
return 0;
}
b[0]=1;
} else {
if(ok) b[i]=2*1e17;
else b[i]=(b[i-1]-a[i-1])*2;
if(b[i]>=1e17) ok=true;
if(a[i]>b[i]){
cout << -1 << endl;
return 0;
}
}
}
b[n+1]=1;
repr(i,n,0){
if(i==n){
c[i]=a[i];
} else {
c[i]=c[i+1]+a[i];
}
}
c[n+1]=0;
rep(i,0,n){
ans+=min(b[i],c[i]);
}
cout << ans << endl;
return 0;
}
| 0
| 70,275,426
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define pqgreater(x) x, vector<x>, greater<x>
#define abs(x) (x>0?x:-x)
#define decimal(x) cout<<fixed<<setprecision(x)
#define gc getchar
#define pc putchar
const ll mod=998244353;
int solve(); void precomp();
#define multitest 0
#define usecase 0
int main(){ ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t=1;
if(multitest) cin>>t;
precomp();
for(int tc=1; tc<=t; tc++){
if(multitest && usecase)
cout<<"Case #"<<tc<<": ";
solve();
}
}
void precomp(){
return;
}
int a[5005], n, k, sm;
bitset<5005>dp;
int solve(){
cin>>n>>k; sm=0;
for(int i=1; i<=n; i++){
cin>>a[i];
a[i]=min(a[i], k);
sm+=a[i];
}
sort(a+1, a+n+1);
dp[0]=1;
for(int i=n; i>=0; i--){
bool rs=0;
for(int j=k-1; j>=max(k-sm,0); j--){
if(dp[j]){rs=1; break;}
}
if(!rs){
cout<<i<<endl; return 0;
}
for(int j=k; j>=a[i]; j--) if(dp[j-a[i]]) dp[j]=1;;
sm-=a[i];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define rep1(i, n) for(int i = 1; i <= (int)(n); i++)
#define showmap(is, js, x) {rep(i, is){rep(j, js){cout << x[i][j] << " ";}cout << endl;}}
#define show(x) {for(auto i: x){cout << i << " ";} cout<<endl;}
#define showm(m) {for(auto i: m){cout << m.x << " ";} cout<<endl;}
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> llP;
ll gcd(int x, int y){ return y?gcd(y, x%y):x;}
ll lcm(ll x, ll y){ return (x*y)/gcd(x,y);}
int main()
{
ll n;
cin >> n;
vector<int> a;
ll ans = 0;
for (ll i = 1; i*i < n; i++)
{
ll m = 0;
if (n%i == 0){
m = n/i-1;
if (m>i){
ans += m;
}
}
}
cout << ans << endl;
}
| 0
| 91,333,282
|
#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>;
const int MOD=1000000007;
int main() {
int n;
cin >> n;
int ans;
if(n/10==0) ans=n;
else if(n/100==0) ans=9;
else if(n/1000==0) ans=n-90;
else if(n/10000==0) ans=909;
else if(n/100000==0) ans=n-90-9000;
else ans=90909;
cout << ans << endl;
}
|
#include<bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; i++)
using namespace std;
vector<int> dy = {1, 0, -1, 0};
vector<int> dx = {0, 1, 0, -1};
typedef pair<int, int> PII;
int main() {
int h, w;
cin >> h >> w;
vector<string> grah(h);
rep(i, h) cin >> grah.at(i);
queue<PII> q;
vector<vector<int>> dist(h, vector<int>(w, -1));
rep(i,h) rep(j, w){
if(grah.at(i).at(j) == '#'){
q.emplace(i, j);
dist.at(i).at(j) = 0;
}
}
while(!q.empty()){
PII v = q.front();
q.pop();
rep(i, 4){
int ny = v.first + dy.at(i);
int nx = v.second + dx.at(i);
if(ny >= 0 && nx >= 0 && ny < h && nx < w && dist.at(ny).at(nx) == -1 && grah.at(ny).at(nx) != '#'){
dist.at(ny).at(nx) = dist.at(v.first).at(v.second) + 1;
q.emplace(ny, nx);
}
}
}
int res = 0;
rep(i, h) rep(j, w){
res = max(res, dist.at(i).at(j));
}
cout << res << endl;
return 0;
}
| 0
| 63,449,904
|
#include <bits/stdc++.h>
using namespace std;
void hawawa()
{
int n, m;
int mod = 1e9 + 7;
cin >> n >> m;
vector<long long> x(n);
vector<long long> y(m);
for (auto&& i : x) {
cin >> i;
}
for (auto&& i : y) {
cin >> i;
}
long long xsize = 0;
for (int i = 0; i < n; i++) {
xsize += i * x[i];
xsize %= mod;
xsize -= (n - 1 - i) * x[i];
xsize %= mod;
}
long long ysize = 0;
for (int i = 0; i < m; i++) {
ysize += i * y[i];
ysize %= mod;
ysize -= (m - 1 - i) * y[i];
ysize %= mod;
}
long long ans = xsize * ysize;
ans %= mod;
cout << ans << "\n";
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
hawawa();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define hackcyborg shresth_walia
#define ll long long
#define ld double
#define pb push_back
#define mod 998244353
#define IO ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define int long long
#define ordered_set tree<int,null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
ll bp(ll a,ll b,ll m=mod)
{
ll res=1;
if(b<0)
return bp(bp(a,m-2),-b);
while(b>0)
{
if(b&1)
res=(a*res)%m;
a=(a*a)%m;
b/=2;
}
return res;
}
main()
{
IO
ll n,g,m;
cin>>n>>g>>m;
ll po[m+1];
memset(po,-1,sizeof(po));
vector<ll> as;
as.pb(0);
ll a=g;
as.pb(g);
ll l=g;
po[l%m]=1;
ll v=1;
for(int x=2;x<=n;x++)
{
ll e=((l%m)*(l%m))%m;
if(po[e]==-1 || v==0)
{a+=e;
l=e;
po[e]=x;
as.pb(e);
}
else
{
ll k=0;
v=0;
for(int y=po[e];y<x;y++)
{
k+=as[y];
}
ll h=((n-x+1)/(x-po[e]));
a+=(((n-x+1)/(x-po[e]))*k);
x+=(h*(x-po[e]))-1;
}
}
cout<<a;
}
| 0
| 97,499,852
|
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
ll MOD = 1000000007;
#define vec vector<int>
#define vecll vector<ll>
#define vecd vector<double>
#define vecst vector<string>
#define vecb vector<bool>
#define v2(v,n,m,init) vector<vector<int>> v(n, vector<int>(m, init))
#define vb2(v,n,m,init) vector<vector<bool>> v(n, vector<bool>(m, init))
#define vll2(v,n,m,init) vector<vector<ll>> v(n, vector<ll>(m, init))
#define rep(i,n) for(ll i=(ll)0; i<(ll)n; i++)
#define REP(i,m,n) for(ll i=(ll)m; i<(ll)n; i++)
#define arr(var, n) vec var(n); rep(i,n){cin >> var[i];}
#define arrll(var, n) vecll var(n); rep(i,n){cin >> var[i];}
#define arrst(var, n) vecst var(n); rep(i,n){cin >> var[i];}
#define all(var) (var).begin(), (var).end()
#define sortall(var) sort(all(var))
#define uniqueall(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb(var) push_back(var)
#define prt(var) cout << (var) << "\n"
#define prtd(n, var) cout << fixed << setprecision(n) << (var) << "\n"
#define prtfill(n, var) cout << setw(n) << setfill('0') << (var);
#define prt2(v1, v2) cout << (v1) << " " << (v2) << "\n"
#define prt3(v1, v2, v3) cout << (v1) << " " << (v2) << " " << (v3) << "\n"
#define prtall(v) rep(i,v.size()){cout<<v[i]<<(i!=v.size()-1?" ":"\n");}
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 main(void) {
string s;
cin >> s;
ll k;
cin >> k;
ll num=0;
int p;
rep(i,s.size()){
if(s[i]=='1'){
num++;
} else {
p=i;
break;
}
}
if(num>=k){
prt(1);
} else {
prt(s[p]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rem(i, m, n) for (int i = m; i < (n); i++)
#define eps (1e-7)
#define inf (1e9)
#define pi (acos(-1))
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vl;
typedef vector<double> vd;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll a, b, c, k;
cin >> a >> b >> c >> k;
ll ans;
if (k % 2 == 0)
{
ans = a - b;
}
else
{
ans = b - a;
}
if (ans > 1e18)
cout << "Unfair"
<< "\n";
else
cout << ans << "\n";
return 0;
}
| 0
| 87,142,185
|
#include <bits/stdc++.h>
using namespace std;
#define iter(i, a, b) for(int i=(a); i<(b); i++)
#define rep(i, a) iter(i, 0, a)
#define rep1(i, a) iter(i, 1, (a)+1)
#define log(a) cerr<<"\033[32m[DEBUG] "<<#a<<'='<<(a)<<" @ line "<<__LINE__<<"\033[0m"<<endl
#define all(a) a.begin(), a.end()
#define fi first
#define se second
#define pb push_back
#define mp make_pair
using ll=long long;
using pii=pair<int, int>;
const int MOD=1000000007;
signed main() {
ios_base::sync_with_stdio(false); cin.tie(0);
int N, K; cin >> N >> K;
vector<int> v;
rep(i, N) { int t; cin >> t; v.pb(t); }
sort(all(v));
ll ans = 0;
rep(i, N-K) ans += v[i];
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, kakikae = 0;
cin >> n >> k;
map<int, int> a;
for (int i = 0; i < n; i++) {
int ai; cin >> ai;
if (a.count(ai)) a[ai]++;
else a[ai] = 1;
}
int syurui = a.size();
if (syurui <= k) goto OUT;
for (int i = 1; i < n; i++) {
for (auto p: a) {
if (p.second == i) {
syurui--;
kakikae += i;
if (syurui <= k) goto OUT;
}
}
}
OUT:
cout << kakikae;
}
| 0
| 11,646,698
|
#include<bits/stdc++.h>
using namespace std;
#define fast() ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long int
#define test() ll t; cin>>t; while(t--)
#define lp0(i,begin,end) for(ll i=begin;i<end;i++)
#define lp1(i,begin,end) for(ll i=begin;i<=end;i++)
#define rlp(i,begin,end) for(ll i=end;i>=begin;i--)
#define prec(n) fixed<<setprecision(n)
#define initial(a,i) memset(a,i,sizeof(a))
#define pb push_back
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define F first
#define S second
#define all(a) (a).begin(),(a).end()
#define BPC(x) __builtin_popcountll(x)
#define gcd(a,b) __gcd(a,b)
ll gcd(ll a,ll b) {if (a==0) return b;return gcd(b%a,a);}
ll power(ll x,ll n)
{
ll result = 1;
while (n)
{
if (n & 1)
result = result * x;
n = n / 2;
x = x * x;
}
return result;
}
void solution(ll compte)
{
ll r;
cin>>r;
cout<<power(r,2);
}
int main()
{
ll compte = 1;
solution(compte);
compte++;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef set<int> si;
typedef map<string, int> msi;
typedef map<int, int> mii;
#define fr(i, n) for(int i=0; i<(n); ++i)
#define frC(i, n, c) for(int i=0; (i<(n)) && (c); ++i)
#define frA(i, a, n) for(int i=a; i<=(n); ++i)
#define frD(i, a, n) for(int i=a; i>=(n); --i)
#define fill(a) memset(a, 0, sizeof(a))
#define fill1(a) memset(a, -1, sizeof(a))
#define revsort(a, b) sort(a, b, greater<int>())
#define ff first
#define ss second
#define pb push_back
#define dout if(DEBUGGING) cout
#define dbg if(DEBUGGING)
#define endl "\n"
int DEBUGGING = 0;
const int INF = 1000000000;
const int MOD = 1000000007;
const ll LINF = 1e18;
const double PI = 3.1415926535897932;
const double EPS = 1e-7;
ll gcdEx (ll a, ll b, ll *x, ll *y){if(!a){*x=0;*y=1;return b;}
ll x1,y1,gcd=gcdEx (b%a,a,&x1,&y1); *x=y1-(b/a)*x1;*y=x1; return gcd;}
ll modI(ll b, ll m) {ll x,y;gcdEx(b,m,&x,&y);return (x%m+m)%m;}
ll modD(ll a, ll b) {return (modI(b,MOD)*(a%MOD))%MOD;}
ll modS(ll a, ll b) {return ((a%MOD)-(b%MOD)+MOD)%MOD;}
ll modP(ll x, ll y) {ll r=1; x%=MOD; while(y>0){if(y&1){r=(r*x)%MOD;} y=y>>1; x=(x*x)%MOD;} return r;}
ll modA(ll a, ll b) {return ((a%MOD)+(b%MOD))%MOD;}
ll modM(ll a, ll b) {return ((a%MOD)*(b%MOD))%MOD;}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int dp[105][100005];
int in[100005];
int a[105];
void solve(int TEST_CASE){
int n, k;
cin >> n >> k;
fr(i,n) cin >> a[i];
fill(dp);
int cc;
fr(i,a[0]+1) dp[1][i] = 1;
frA(i,2,n){
fill(in);
fr(j,k+1){
in[j]=(in[j]+dp[i-1][j])%MOD;
if(j+a[i-1]<100003) in[j+a[i-1]+1]=(in[j+a[i-1]+1]-dp[i-1][j])%MOD;
}
dbg{
cout << "in "<<i<<": ";
fr(j,k+2) cout << in[j] << ",";
cout << endl;
}
cc=0;
fr(j,k+3) {
cc = (cc+in[j])%MOD;
dp[i][j] = cc;
}
}
dbg{
fr(i,n+1){
fr(j,k+1){
cout << dp[i][j] <<",";
}
cout << endl;
}
}
cout << (dp[n][k]+MOD)%MOD;
}
int main(int argc, char* argv[]){
if(argc==2 && argv[1][1]=='v') DEBUGGING = 1;
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
cin.exceptions(cin.failbit);
int nTestCases=1;
frA(i,1,nTestCases) solve(i);
return 0;
}
| 0
| 51,296,306
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(var, begin, end) for (int var = (begin); var <= (end); var++)
#define RFOR(var, begin, end) for (int var = (begin); var >= (end); var--)
#define REP(var, length) FOR(var, 0, length - 1)
#define RREP(var, length) RFOR(var, length - 1, 0)
#define EACH(value, var) for (auto value : var)
#define SORT(var) sort(var.begin(), var.end())
#define REVERSE(var) reverse(var.begin(), var.end())
#define RSORT(var) SORT(var); REVERSE(var)
#define OPTIMIZE_STDIO ios::sync_with_stdio(false); cin.tie(0); cout.precision(10); cout << fixed
#define endl '\n'
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
void solve(istream& cin, ostream& cout) {
int n, m;
cin >> n >> m;
int ans = (1900 * m + 100 * (n - m)) * pow(2, m);
cout << ans << endl;
}
#ifndef TEST
int main() {
OPTIMIZE_STDIO;
solve(cin, cout);
return 0;
}
#endif
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define eb emplace_back
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
ll gcd(ll a, ll b) { return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) { return a/gcd(a,b)*b;}
int const INF = 1001001001;
ll const MOD = 1000000007;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll N,M;
cin >> N >> M;
if( 2*N >= M ) cout << M/2 << endl;
else cout << N + (M-2*N)/4 << endl;
return 0;
}
| 0
| 16,331,645
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
using namespace std;
#define INF ((1<<30)-1)
#define LINF (1LL<<60)
#define EPS (1e-10)
typedef long long ll;
typedef pair<ll, ll> P;
const int MOD = 1000000007;
const int MOD2 = 998244353;
ll ans[100010];
int main(){
int n;
cin >> n;
vector<P> vp(n+1);
rep(i, n) {
ll a;
cin >> a;
vp.push_back({a, i});
}
sort(vp.rbegin(), vp.rend());
ll idx = LINF;
rep(i, n){
idx = min(idx, vp[i].second);
ans[idx] += (i + 1) * (vp[i].first - vp[i+1].first);
}
rep(i, n) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define all(n) begin(n),end(n)
using ll = long long;
using P = pair<int,int>;
int main() {
string s;
cin >> s;
vector<int> t(26);
rep(i,s.size()) t[s[i]-'a']++;
if(s.size()<26){
cout << s;
rep(i,26){
if(t[i]==0) {
char ans = 'a'+ i;
cout << ans << endl;
return 0;
}
}
}
else if(s=="zyxwvutsrqponmlkjihgfedcba"){
cout << -1 << endl;
return 0;
}
else{
string u = s;
next_permutation(all(u));
rep(i,s.size()){
cout << u[i];
if(s[i]!=u[i]) break;
}
cout << endl;
}
return 0;
}
| 0
| 37,605,047
|
#include<stdio.h>
int main(void)
{
int a,b=0,c=0,i;
for(i=0;i<4;i++){
scanf("%d",&a);
b+=a;
}
for(i=4;i<8;i++){
scanf("%d",&a);
c+=a;
}
if(b<c){
printf("%d\n",c);
}
else{
printf("%d\n",b);
}
return 0;
}
|
#include <stdio.h>
#include <cctype>
#include <limits.h>
#include <math.h>
#include <complex>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cstring>
#include <string>
#include <sstream>
#include <algorithm>
#include <iomanip>
#include <iostream>
#define VARIABLE(x) cerr << #x << "=" << x << endl
#define BINARY(x) static_cast<bitset<16> >(x);
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define REP(i,m,n) for (int i=m;i<(int)(n);i++)
#define if_range(x, y, w, h) if (0<=(int)(x) && (int)(x)<(int)(w) && 0<=(int)(y) && (int)(y)<(int)(h))
const int INF = 1000000000;
const double EPS = 1e-8;
const double PI = 3.14159;
int dx[4]={-1, 0, 1, 0}, dy[4]={0, -1, 0, 1};
using namespace std;
typedef pair<int, int> P;
int main()
{
int n;
int c[] = {500, 100, 50, 10, 5, 1};
while (cin>>n, n) {
n = 1000 - n;
int ans = 0;
rep(i, 6) {
while (n>=c[i]) {
n-=c[i];
ans++;
}
}
cout << ans << endl;
}
}
| 0
| 12,666,844
|
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<math.h>
#include<complex>
#include<queue>
#include<deque>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<functional>
#include<assert.h>
#include<numeric>
using namespace std;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
using ll = long long;
const int inf=1e9+7;
const ll longinf=1LL<<60 ;
const ll mod=1e9+7 ;
int main(){
int n;
cin>>n;
ll a[n];
rep(i,n)cin>>a[i];
ll res = 0;
rep(i,n)res^=a[i];
ll ans = 0;
ll cur = 0;
vector<int> used(n);
for(int j= 61;j>=0;--j){
if(res&(1ll<<j)){
rep(i,n){
if(a[i]&(1ll<<j))a[i]^=1ll<<j;
}
}
rep(i,n){
if(used[i])continue;
if(a[i]&(1ll<<j)){
used[i]=1;
rep(k,n){
if(i==k)continue;
if(a[k]&(1ll<<j))a[k]^=a[i];
}
break;
}
}
}
sort(a,a+n);
reverse(a,a+n);
if(n>65){
n=65;
}
rep(_,40000){
rep(i,n)used[i]=0;
cur = 0;
for(int j= 61;j>=0;--j){
if(cur&(1ll<<j))continue;
rep(i,n){
if(!used[i]&&a[i]&(1ll<<j)){
cur^=a[i];
used[i]=1;
break;
}
}
}
ans = max(ans,cur+(cur^res));
random_shuffle(a, a+n);
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using Pair = pair<int64_t, int64_t>;
constexpr int64_t kInf = INT64_MAX / 2L;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int64_t H, W;
cin >> H >> W;
vector<vector<int64_t>> horizon(H);
vector<vector<int64_t>> vertical(W);
vector<vector<bool>> is_open(H, vector<bool>(W, true));
for (int64_t r = 0; r < H; ++r) {
string s;
cin >> s;
for (int64_t c = 0; c < W; ++c) {
const char ch = s.c_str()[c];
if (ch == '#') {
horizon[r].push_back(c);
vertical[c].push_back(r);
is_open[r][c] = false;
}
}
}
for (int64_t r = 0; r < H; ++r) {
horizon[r].push_back(-1);
horizon[r].push_back(W);
sort(horizon[r].begin(), horizon[r].end());
}
for (int64_t c = 0; c < W; ++c) {
vertical[c].push_back(-1);
vertical[c].push_back(H);
sort(vertical[c].begin(), vertical[c].end());
}
int64_t result = 0;
for (int64_t r = 0; r < H; ++r) {
for (int64_t c = 0; c < W; ++c) {
if (is_open[r][c]) {
auto itr1 = lower_bound(vertical[c].begin(), vertical[c].end(), r);
const int64_t top = *itr1;
--itr1;
const int64_t bottom = *itr1;
auto itr2 = lower_bound(horizon[r].begin(), horizon[r].end(), c);
const int64_t right = *itr2;
--itr2;
const int64_t left = *itr2;
const int64_t temp = (top - bottom - 1) + (right - left - 1) - 1;
result = max(result, temp);
}
}
}
cout << result << endl;
return 0;
}
| 0
| 52,314,650
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
using namespace std;
typedef pair<int,int> P;
typedef pair<int,P> P2;
int next_animal(int a,int b,int c){
if(b==1) c=(c+1)%2;
if(c==0) return a;
else return (a+1)%2;
}
int main(){
int n;
cin>>n;
vector<int> vec;
for(int i=0;i<n;i++){
char a;
cin>>a;
if(a=='o') vec.push_back(0);
else vec.push_back(1);
}
for(int i=0;i<2;i++){
for(int j=0;j<2;j++){
vector<int> ans;
ans.push_back(i);
ans.push_back(j);
for(int k=1;k<n-1;k++){
int ps=ans.size()-1;
ans.push_back(next_animal(ans[ps-1],ans[ps],vec[ps]));
}
if(next_animal(ans[n-2],ans[n-1],vec[n-1])==i&&next_animal(j,i,vec[0])==ans[n-1]){
for(int k=0;k<n;k++) cout<<(ans[k]==0?'S':'W');
cout<<endl;
return 0;
}
}
}
cout<<-1<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
#define sz(x) (int)(x).size()
const int N = 100010;
int a[N], vis[N], n, m;
vector<int> adj[N];
vector<ii> comp;
void dfs (int u) {
vis[u] = 1;
comp.push_back({u, a[u]});
for (int v : adj[u]) if (!vis[v]) dfs(v);
}
int main() {
scanf("%d%d", &n, &m);
int u, v;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
int ans = 0;
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; i++) if (!vis[i]) {
dfs(i);
set<int> v;
for (const auto& p : comp) v.insert(p.second);
for (const auto& p : comp) ans += v.count(p.first);
comp.clear();
}
printf("%d\n", ans);
}
| 0
| 61,456,091
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
const int MAX { 200010 };
const ll MOD { 1000000007 }, oo { 1LL << 62 };
ll solve(int N, const vector<ll>& xs)
{
return 0;
}
int main()
{
ios::sync_with_stdio(false);
string S, T;
cin >> S >> T;
cout << T + S << '\n';
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll X,Y,A,B,C;
void solve(){
cin>>X>>Y>>A>>B>>C;
ll a[A] , b[B] , c[C];
vector<ll> values;
ll sum = 0;
for(ll i = 0 ; i<A ; i++)
cin>>a[i];
for(ll i = 0 ; i<B ; i++)
cin>>b[i];
for(ll i = 0 ; i<C ; i++)
cin>>c[i];
sort(a , a+A); sort(b , b+B); sort(c , c+C);
for(ll i = A-1 ; i>A-1-X; i--)
values.push_back(a[i]);
for(ll i = B-1 ; i>B-1-Y ; i--){
values.push_back(b[i]);
}
for(ll i = 0 ; i<C ; i++)
values.push_back(c[i]);
sort(values.rbegin() , values.rend());
for(ll i = 0 ; i<X+Y ; i++)
sum+=values[i];
cout<<sum<<'\n';
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 0
| 79,357,758
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <cmath>
#include <iomanip>
#include <ctype.h>
using namespace std;
using ll = long long;
using PAIR = pair<int, int>;
using PAIRLL = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
#define rep(i,N) for(int i=0;i<(int)N;++i)
ll GCD(ll x, ll y) {
if (y == 0) return x;
else return GCD(y, x % y);
}
bool my_compare(pair<string, int> a, pair<string, int> b) {
if (a.first != b.first) {
return a.first < b.first;
}
if (a.second != b.second) {
return a.second > b.second;
}
else {
return true;
}
}
int main()
{
int N;
cin >> N;
vector<string> W(N);
rep(i, N) cin >> W[i];
vector<int> L(N);
rep(i, N) L[i] = W[i].size();
for (int i = 0; i < N-1; ++i) {
for (int j = i+1; j < N; ++j) {
if(W[i]==W[j]) { cout << "No" << endl; goto xyz; }
}
}
for (int i = 0; i < N-1; ++i) {
if (W[i][L[i] - 1] != W[i + 1][0]) { cout << "No" << endl; goto xyz; }
}
cout << "Yes" << endl;
xyz:;
}
|
#include <bits/stdc++.h>
#define r(i,n) for(int i = 0; i<n; i++)
typedef long long ll;
using namespace std;
const ll mod=998244353;
int main(){
bool flag=true;
ll n,ans=1;
cin >> n;
map<int,int> mp;
mp[0]=0;
r(i,n){
int a;
cin >> a;
mp[a]++;
if(i==0&&a!=0)flag=false;
if(i!=0&&a==0)flag=false;
}
if(!flag)cout<<0<<endl;
else{
int m=1,p=1;
for(auto it=mp.begin();it!=mp.end();it++){
if(it==mp.begin())continue;
if((*it).first!=m)ans=0;
else {
r(i,(*it).second){
ans*=p;
ans%=mod;
}
m++;
p=(*it).second;
}
}
cout<<ans<<endl;
}
}
| 0
| 38,267,395
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
typedef pair<ll,ll> pll;
const ll mod=1e9+7;
const ll inf=5e18;
int main() {
ll h,w,k;
cin >> h >> w >> k;
for(ll i=0;i<=h;i++) {
for(ll j=0;j<=w;j++) {
if(i*j+(h-i)*(w-j)==k||i*j+(h-i)*(w-j)==h*w-k) {
cout << "Yes" << endl;
return 0;
}
}
}
cout << "No" << endl;
}
|
#include <bits/stdc++.h>
#define repr(i,from,to) for(int (i)=(from);(i)<(to);(i)++)
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
const bool debug=false;
#define DEBUG if(debug==true)
#define vprint(x) for(auto a:(x)) cout << x << endl;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
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(void) {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;cin>>n;
vector<ll> a(n);rep(i,n){cin >> a.at(i);}
priority_queue<ll> pq;
rep(i,n){pq.push(a[i]);}
ll cnt=0;
while(pq.top()+cnt>=n){
ll top = pq.top();
pq.pop();
DEBUG{
printf("top: %lld, cnt: %lld\n", top, cnt);
}
ll sub = (top+cnt-n-1)/(n+1)+1;
top -= (n+1)*sub;
cnt += sub;
pq.push(top);
}
cout << cnt << endl;
return 0;
}
| 0
| 59,759,655
|
#include <iostream>
#include <utility>
#include <map>
#include <vector>
#include <algorithm>
#include <queue>
#include <math.h>
#include <stack>
#include <set>
#include <deque>
#include <cmath>
using namespace std;
typedef long long ll;
ll mod = 1e9+7;
#define rep(i,n) for(int i = 0; i < (n); ++i)
int main() {
int n;
string s;
cin >> n >> s;
int l = 0, r = 0;
rep(i, n) {
if (s[i] == '(') ++l;
else if (l == 0) ++r;
else --l;
}
rep(i, r) s = '(' + s;
rep(i, l) s += ')';
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define P pair<ll, ll>
#define Graph vector<vector<ll>>
#define fi first
#define se second
constexpr ll mod = 1000000007;
constexpr ll INF = (1ll << 60);
constexpr double pi = 3.14159265358979323846;
template <typename T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
ll a, b, k;
cin >> a >> b >> k;
while (k) {
if (a % 2 == 1) {
a--;
}
b += (a / 2);
a /= 2;
k--;
if (k == 0) break;
if (b % 2 == 1) {
b--;
}
a += (b / 2);
b /= 2;
k--;
}
cout << a << " " << b << "\n";
return 0;
}
| 0
| 91,130,390
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,x,t,dot;
cin>>n>>x>>t;
dot=n/x;
if (n%x>0){
dot++;
}
cout<<dot*t;
return 0;
}
|
#include<iostream>
#include<cstdio>
using namespace std;
int main()
{
int s = 100000;
int n;
cin >> n;
while (n--) {
if (int(s*1.05) % 1000 == 0) {
s = int(s*1.05);
}
else {
s = int(s*1.05) + (1000 - int(s*1.05) % 1000);
}
}
printf("%d\n", s);
return 0;
}
| 0
| 24,735,462
|
#line 1 "test/atcoder/practive2-a.cpp"
#include <iostream>
#include <atcoder/dsu>
using namespace std;
using namespace atcoder;
int main() {
int n, q; cin >> n >> q;
dsu d(n);
for (int i = 0; i < q; ++i) {
int t, u, v; cin >> t >> u >> v;
if (t == 0) {
d.merge(u, v);
}
else {
cout << d.same(u, v) << endl;
}
}
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < int(n); i++)
#define rrep(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define reps(i, n) for (int i = 1; i <= int(n); i++)
#define rreps(i, n) for (int i = int(n); i >= 1; i--)
#define repc(i, n) for (int i = 0; i <= int(n); i++)
#define rrepc(i, n) for (int i = int(n); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define repic(i, a, b) for (int i = int(a); i <= int(b); i++)
#define each(x, y) for (auto &x : y)
#define all(a) (a).begin(), (a).end()
#define bit32(x) (1 << (x))
#define bit64(x) (1ll << (x))
using namespace std;
using i32 = int;
using i64 = long long;
using f80 = long double;
using vi32 = vector<i32>;
using vi64 = vector<i64>;
using vf80 = vector<f80>;
using vstr = vector<string>;
inline void yes() { cout << "Yes" << '\n'; exit(0); }
inline void no() { cout << "No" << '\n'; exit(0); }
inline i64 gcd(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); if (a % b == 0) return b; return gcd(b, a % b); }
inline i64 lcm(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); return a / gcd(a, b) * b; }
template <typename T> class pqasc : public priority_queue<T, vector<T>, greater<T>> {};
template <typename T> class pqdesc : public priority_queue<T, vector<T>, less<T>> {};
template <typename T> inline void amax(T &x, T y) { if (x < y) x = y; }
template <typename T> inline void amin(T &x, T y) { if (x > y) x = y; }
template <typename T> inline T exp(T x, i64 n, T e = 1) { T r = e; while (n > 0) { if (n & 1) r *= x; x *= x; n >>= 1; } return r; }
template <typename T> istream& operator>>(istream &is, vector<T> &v) { each(x, v) is >> x; return is; }
template <typename T> ostream& operator<<(ostream &os, vector<T> &v) { rep(i, v.size()) { if (i) os << ' '; os << v[i]; } return os; }
void solve(); int main() { ios::sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(16); solve(); return 0; }
void solve() {
int n;
cin >> n;
vi64 a(n);
cin >> a;
auto check = [&]() {
rep(i, n) if (a[i] >= n) return false;
return true;
};
i64 ans = 0;
while (!check()) {
i64 ma = 0;
int ma_i;
rep(i, n) {
if (a[i] > ma) {
amax(ma, a[i]);
ma_i = i;
}
}
i64 c = (a[ma_i] + n) / n - 1;
rep(i, n) {
if (i != ma_i) a[i] += c;
else a[i] -= c * n;
}
ans += c;
}
cout << ans << endl;
}
| 0
| 1,169,207
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int (i)=(0);(i)<(int)(n);++(i))
using ll = long long;
using P = pair<int, int>;
using namespace std;
int main() {
double n, m, d;
cin >> n >> m >> d;
if (d == 0) {
printf("%.10f\n", (1.0/n) * (m-1));
}
else {
printf("%.10f\n", 2 * (n - d) / (n * n) * (m - 1));
}
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(n); i++)
using namespace std;
using ll = long long;
int a[20];
int main()
{
int n, k;
cin >> n >> k;
rep(i,n) cin >> a[i];
ll ans = ll(1e18)+1;
rep(bit,1<<n) {
ll tot = 0;
int maxv = 0;
int visible = 0;
rep(i,n) {
if (maxv < a[i]) {
visible++;
maxv = a[i];
} else if (bit>>i&1) {
tot += (maxv - a[i]) + 1;
visible++;
maxv++;
}
}
if (visible >= k) ans = min(ans, tot);
}
cout << ans << endl;
return 0;
}
| 0
| 38,984,752
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define P pair<ll,ll>
char grid[1010][1010];
bool seen[1010][1010];
int di[]={0,1,0,-1};
int dj[]={1,0,-1,0};
int main(){
int h,w;
cin>>h>>w;
queue<P> q;
rep(i,h)rep(j,w){
cin>>grid[i][j];
seen[i][j]=0;
if(grid[i][j]=='#'){
seen[i][j]=1;
q.push(make_pair(i,j));
}
}
int ans=0;
while(true){
bool ok=1;
rep(i,h)rep(j,w){
if(!seen[i][j]){
ok=0; break;
}
}
if(ok) break;
queue<P> r;
ans++;
while(!q.empty()){
int pi,pj;
tie(pi,pj)=q.front(); q.pop();
rep(i,4){
int ni=pi+di[i],nj=pj+dj[i];
if(ni<0 || ni>=h || nj<0 || nj>=w) continue;
if(seen[ni][nj]) continue;
seen[ni][nj]=1;
r.push(make_pair(ni,nj));
}
}
q=r;
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
#define rep(i,n) for(int i=0, i##_len=(int)(n); i<i##_len; i++)
#define reps(i,n) for(int i=1 , i##_len=(int)(n);i<=i##_len;i++)
#define rrep(i,n) for(int i=((int)(n)-1);i>=0;i--)
#define rreps(i,n) for(int i=((int)(n));i>0;i--)
#define repi(i,x) for(auto i=(x).begin(),i##_fin=(x).end();i!=i##_fin;i++)
#define all(x) (x).begin(), (x).end()
#define F first
#define S second
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back
string solve(bool a) { return ((a) ? "Yes" : "No"); }
typedef vector<int> Vi;
typedef vector<Vi> VVi;
typedef pair<int , int> Pi;
typedef vector<Pi> VPi;
typedef vector<long long> V;
typedef vector<V> VV;
typedef pair<long long , long long> P;
typedef vector<P> VP;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1;} return 0;}
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1;} return 0;}
template <class T, class U>ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T>ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
rep(i, v.size()) {
if (i) os << ",";
os << v[i];
}
os << "}";
return os;
}
template <class T, class U>istream& operator>>(istream& is, pair<T, U>& p) {
is >> p.first >>p.second ;
return is;
}
template <class T>istream& operator>>(istream& is, vector<T>& v) {
rep(i, v.size()) {
is >> v[i];
}
return is;
}
const long long INFLL = 1LL<<60;
const int INF = 1<<30;
const double PI=acos(-1);
int main(){
ll n,a,b;
ll ans=0LL;
cin >>n>>a>>b;
ans = n / (a + b) * a + min(n % (a + b), a);
cout<<ans<<endl;
}
| 0
| 100,496,151
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); i++)
using ll = long long;
using ull = unsigned long long;
using P = pair<int,int>;
using PP = pair<int,pair<int,int>>;
using T = tuple<string,int,int>;
const string EMP = " ";
const ll INF = 1LL<<60;
const ll MOD = 1000000007;
int main(){
int n; cin >> n;
vector<int> a(n);
for(int i = 0; i < n; i++) cin >> a[i];
int ans = a[0];
for(int i = 0; i < n-1; i++){
if(a[i] < a[i+1]){
ans += a[i+1] - a[i];
}
}
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<math.h>
#include<complex>
#include<queue>
#include<deque>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<functional>
#include<assert.h>
#include<numeric>
using namespace std;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
using ll = long long;
const int inf=1e9+7;
const ll longinf=1LL<<60 ;
const ll mod=1e9+7 ;
#define PI 3.141592653589793
int main(){
ll N, M, V, P; cin >> N >> M >> V >> P; ll a[N];
rep(i, N){
cin >> a[i];
}
sort(a, a+N); ll ok=1e18, ng=-1;
while(abs(ok-ng)>1){
ll mid = (ok+ng)/2; ll tmp=0;
tmp+=(P-1)*M; ll lasti=-1;
rep(i, N){
if(a[i]<=mid && i<=N-P){
tmp+=min(M, mid-a[i]); lasti=i;
}
}
if(lasti<N-P){
ng = mid; continue;
}
if(tmp<(V*M)){
ng = mid; continue;
}
ok = mid; continue;
}
rep(i, N){
if(a[i]>=ok-M){
cout << N-i << endl; return 0;
}
}
}
| 0
| 43,040,215
|
#include <bits/stdc++.h>
using namespace std;
int main(void)
{
int n;
cin >> n;
int c[n-1], s[n-1], f[n-1];
for (int i = 0; i < n-1; i++)
cin >> c[i] >> s[i] >> f[i];
for (int i = 0; i < n-1; i++) {
int t = 0;
for (int j = i; j < n-1; j++) {
if (t < s[j])
t = s[j] + c[j];
else {
int tmp = t - s[j];
int tmp1 = (tmp+f[j]-1)/f[j];
t = s[j] + tmp1*f[j] + c[j];
}
}
cout << t << endl;
}
cout << 0 << endl;
return 0;
}
|
#include <bits/stdc++.h>
typedef long long ll;
#define REP(i, n) for(int i = 0; i < n; i++)
#define REP2(i, a, b) for(int i = a;i <= b;i++)
#define REPR(i, a, b) for(int i = a; i >= b; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define INF 2e9
#define MOD 1000000007
#define PI 3.14159265358979323846
#define vi vector<int>
#define vll vector<ll>
#define vi2 vector<vector<int>>
#define eb emplace_back
#define fi first
#define se second
#define ALL(v) v.begin(), v.end()
#define sz(x) int(x.size())
using namespace std;
using P = pair<ll,ll>;
const int dx[]{0, 1, 0, -1, -1, -1, 1, 1}, dy[]{1, 0, -1, 0, -1, 1, -1, 1};
#define INT(name) int name;cin >> name;
#define VEC(type,name,n) vector<type> name(n);REP(i,n) cin >> name[i];
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main()
{
ll N;
cin >> N;
VEC(ll,A,N);
ll right = 0;
ll sum = 0;
ll xorsum = 0;
ll ans = 0;
REP(left,N){
while(right<N&&sum+A[right]==(xorsum^A[right])){
sum+=A[right];
xorsum=(xorsum^A[right]);
right++;
}
ans+=right-left;
if(right==left){
right++;
}else{
sum-=A[left];
xorsum=(xorsum^A[left]);
}
}
cout << ans << endl;
}
| 0
| 38,254,414
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int x,a;
cin>>x>>a;
if (x<a)
{
printf("0\n");
}
else
printf("10\n");
return 0;
}
|
#include <cstdio>
#include <iostream>
#include <set>
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define fi first
#define se second
using namespace std;
inline char nc()
{
static char buf[100000],*l=buf,*r=buf;
return l==r&&(r=(l=buf)+fread(buf,1,100000,stdin),l==r)?EOF:*l++;
}
template<class T> void read(T &x)
{
x=0; int f=1,ch=nc();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=nc();}
while(ch>='0'&&ch<='9'){x=x*10-'0'+ch;ch=nc();}
x*=f;
}
typedef pair<int,int> pii;
const int maxn=2e5+50;
int n,a[maxn];
set<pii> s;
bool check(int c)
{
s.clear();
for(int i=2;i<=n;++i)
{
if(a[i]<=a[i-1])
{
while(s.size()&&s.rbegin()->fi>a[i]) s.erase(*s.rbegin());
int x=a[i];
while(true)
{
set<pii>::iterator it=s.lower_bound(make_pair(x,0));
int y=0; if(it!=s.end()&&it->fi==x) y=it->se,s.erase(it);
if(++y==c)
{
if(x==1) return 0;
--x; continue;
}
s.insert(make_pair(x,y));
break;
}
}
}
return 1;
}
int main()
{
read(n);
for(int i=1;i<=n;++i) read(a[i]);
int l=1,r=n,an=-1;
while(l<=r)
{
int mid=(l+r)>>1;
if(check(mid)) r=mid-1,an=mid;
else l=mid+1;
}
printf("%d\n",an);
return 0;
}
| 0
| 82,595,120
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = 1e9;
const ll LINF = ll(1e18);
const int MOD = 1000000007;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1}, Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()
#define debug(v) \
cout << #v << ":"; \
for (auto x : v) \
{ \
cout << x << ' '; \
} \
cout << endl;
template <class T>
bool chmax(T &a, const T &b)
{
if (a < b)
{
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b)
{
if (b < a)
{
a = b;
return 1;
}
return 0;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
char s;
string ans="aiueo";
cin>>s;
rep(i,5){
if(s==ans[i]){
cout<<"vowel"<<"\n";
return 0;
}
}
cout<<"consonant"<<"\n";
}
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define rep(i, begin, n) for (int i = begin; i < n; i++)
#define repe(i, begin, n) for (int i = begin; i <= n; i++)
#define repr(i, begin, n) for (int i = begin; i > begin - n; i--)
#define repre(i, begin, end) for (int i = begin; i >= end; 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;
}
const int inf = 1000000007;
const int MOD = 1000000007;
const long long INF = 1000000000000000007;
const long long MAX_V = 1010101;
struct edge {
long long to, cost;
};
using Pll = pair<long long, long long>;
long long V;
vector<edge> Graph[MAX_V];
long long dist[MAX_V];
void dijkstra(long long s) {
priority_queue<Pll, vector<Pll>, greater<Pll>> que;
fill(dist, dist + MAX_V, INF);
dist[s] = 0;
que.push(Pll(0, s));
while (!que.empty()) {
auto elem = que.top();
que.pop();
auto cv = elem.second;
if (elem.first > dist[cv]) {
continue;
}
for (auto e : Graph[cv]) {
if (dist[e.to] > dist[cv] + e.cost) {
dist[e.to] = dist[cv] + e.cost;
que.push(Pll(dist[e.to], e.to));
}
}
}
}
ll N;
ll Q, K;
int main() {
cin >> N;
V = N;
rep(i, 1, N) {
ll a, b, c;
cin >> a >> b >> c;
Graph[a].push_back(edge{b, c});
Graph[b].push_back(edge{a, c});
}
cin >> Q >> K;
dijkstra(K);
vector<ll> ans;
rep(i, 0, Q) {
ll x, y;
cin >> x >> y;
ans.push_back(dist[x] + dist[y]);
}
for (auto e : ans) {
cout << e << "\n";
}
}
| 0
| 76,849,511
|
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define FS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long int
#define ld long double
#define pb push_back
#define bp __builtin_popcount
#define sz size()
#define ff first
#define ss second
#define vll vector<ll>
#define vbool vector<bool>
#define vpll vector<pair<ll,ll>>
#define pll pair<ll,ll>
#define vllv vector<vector<ll>>
#define setpri(x) cout<<setprecision(x)<<fixed;
#define all(v) v.begin(),v.end()
#define allr(v) v.rbegin(),v.rend()
#define yesr {cout<<"YES"<<endl;return;}
#define nor {cout<<"NO"<<endl;return;}
ll MOD=1e9+7;
ll ceil1(ll n,ll x){return (n-1)/x+(n>0);}
ll gcd(ll a,ll b){return __gcd(a,b);}
ll lcm(ll a,ll b){return (max(a,b)/gcd(a,b))*min(a,b);}
ll pow1(ll n,ll m ,ll mod=MOD );
ll pow2(ll n,ll k);
ll modinv(ll n,ll mod=MOD){ return pow1(n,mod-2,mod);}
bool func(pair<ll,ll> &a,pair<ll,ll> &b ){
if(a.ff != b.ff)return a.ff < b.ff;
return a.ss > b.ss;
}
ll const N=(ll)3e2+11;
ll const LG=(ll)log2(N)+1;
void solve(){
ll i,j,k,l,n,m,x,y,z,r;
cin>>n>>k;
ll mx=(n*(n-1))/2 - (n-1);
if(k>mx){
cout<<-1<<endl;
return;
}
cout<<mx-k+n-1<<endl;
for(i=2;i<=n;i++){
cout<<1<<" "<<i<<endl;
}
ll cnt=0;
for(i=2;i<=n;i++){
for(j=i+1;j<=n;j++){
if(cnt==mx-k)break;
cout<<i<<" "<<j<<endl;
cnt++;
}
if(cnt==mx-k)break;
}
}
int main(){
FS;
ll i,j,k,n,m,x,y,z,q;
q=1;
while(q--){
solve();
}
return 0;
}
ll pow1(ll n,ll m,ll mod){
if(m==0)return 1;
if(m%2==0)return pow1((n*n)%mod,m/2,mod);
return (pow1((n*n)%mod,m/2,mod)*n)%mod;
}
ll pow2(ll n,ll k){
ll ans=1;
while(k>0){
if(k%2==1)ans=ans*n;
n=n*n;
k/=2;
}
return ans;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
int tem;
vector<int> v1;
for(int i=0;i<5;i++)
cin >> tem,v1.push_back(tem);
sort(v1.begin(),v1.end(),greater<int>());
for(int i=0;i<5;i++)
cout << (i?" ":"")<< v1[i] ;
cout << endl;
return 0;
}
| 0
| 17,738,434
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
char s[15],t[15];
cin>>s>>t;
int l=strlen(s);
int p=strlen(t),cnt=0;
for(int i=0;i<l;i++)
{
if(s[i]==t[i])
{
cnt++;
}
}
if(cnt==l)
{
if(l==p-1){
cout<<"Yes"<<endl;
}
}
else
cout<<"No"<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
using ld=long double;
#define rep(i,N) for(int i=0;i<(int)(N);++i)
#define rrep(i,N) for(int i=(int)(N)-1;i>=0;--i)
#define debug(x) cout<<#x<<"="<<x<<endl;
constexpr ll MOD=1000000007;
constexpr ll INF=1LL<<60;
template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return true;}return false;}
template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return true;}return false;}
template<typename T> void fail(T v){cout << v << endl;exit(0);}
void solve(){
int N;
while((scanf("%d",&N),N)){
vector<int> imos(101010);
rep(i,N){
int a,b,c;
scanf("%d:%d:%d",&a,&b,&c);
imos[a*3600+b*60+c]++;
scanf("%d:%d:%d",&a,&b,&c);
imos[a*3600+b*60+c]--;
}
rep(i,101001)imos[i+1]+=imos[i];
printf("%d\n",*max_element(imos.begin(),imos.end()));
}
}
int main(){
solve();
return 0;
}
| 0
| 66,304,087
|
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <vector>
#include <string>
#include <sstream>
#include <utility>
#include <deque>
#include <numeric>
#include <map>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef long long ll;
int main () {
int n;
cin >> n;
vector<ll> v(n);
rep(i,n) {
cin >> v[i];
}
ll ans = 0;
int right = 0;
ll s = 0;
for (int left = 0; left < n; ++left) {
while (right < n && (s ^ v[right]) == (s + v[right])) {
s += v[right];
++right;
}
ans += 1LL * right - 1LL * left;
if (right == left)
++right;
else {
s -= v[left];
}
}
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <locale>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#include <map>
using namespace std;
int solve(int nmin, int nmax, vector<int> &score){
vector<int> gp;
for(int i = nmin-1; i < nmax; i++){
gp.push_back(score[i] - score[i+1]);
}
int maxGp = gp[0];
int index = 0;
for(int i =1; i < gp.size(); i++){
if(maxGp <= gp[i] ){
maxGp = gp[i];
index = i;
}
}
return nmin + index;
}
int main(){
int M,nmin,nmax;
vector<int>ans;
while(1){
cin>>M>>nmin>>nmax;
if(!M && !nmin && !nmax)break;
vector<int> P;
for(int i=0;i<M;i++){
int keep;cin>>keep;
P.push_back(keep);
}
ans.push_back(solve(nmin, nmax, P));
}
for(int i: ans)cout<<i<<endl;
}
| 0
| 33,094,621
|
#include <bits/stdc++.h>
using namespace std;
using ll =long long;
#define all(v) v.begin(),v.end()
int main() {
ll N;
cin>>N;
vector<ll> h(N);
for(ll i=0;i<N;i++) {
cin>>h[i];
}
vector<ll> dp(N,0);
dp[N-2]=abs(h[N-1]-h[N-2]);
for(ll i=N-3;i>=0;i--) {
dp[i]=min(dp[i+1]+abs(h[i]-h[i+1]),dp[i+2]+abs(h[i]-h[i+2]));
}
cout<<dp[0]<<endl;
}
|
#define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
using namespace std;
#define DEBUG(x) cout << '>' << #x << ':' << x << endl;
#define FOR0(i,n) for(int i=0, _##i=(n); i<_##i; ++i)
#define FOR(i,l,r) for(int i=(l), _##i=(r); i<_##i; ++i)
#define FORD(i,l,r) for(int i=(r), _##i=(l); --i>=_##i; )
#define repi(i,a) for(__typeof((a).begin()) i=(a).begin(), _##i=(a).end(); i!=_##i; ++i)
#define dwni(i,a) for(__typeof((a).rbegin()) i=(a).rbegin(), _##i=(a).rend(); i!=_##i; ++i)
#define SZ(a) ((int)((a).size()))
#define printCase() "Case #" << caseNum << ": "
#define pb push_back
#define mp make_pair
#define INF ((int)1e9)
#define SYNC std::ios::sync_with_stdio(false); cin.tie(NULL);
#define ff first
#define ss second
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
typedef vector<vi> vvi;
#define N 100010
#define mod (7+(ll)1e9)
ll modexp(ll x, ll y, ll p) {
ll res = 1;
for(;y>0;y>>=1) {
if(y&1)
res = (res*x) % p;
x = (x*x) % p;
}
return res;
}
ll fac[N];
int choose(int n, int r) {
if(n < r) return 0;
if(!r) return 1;
return (fac[n] * modexp((fac[r]*fac[n-r]) % mod, mod-2, mod)) % mod;
}
int n, a[N];
vi pos;
int main() {
SYNC
fac[0] = 1;
FOR(i,1,N) fac[i] = (fac[i-1]*i) % mod;
vi pos;
cin >> n; FOR0(i, n+1) cin >> a[i];
int y = ((n&1)? (n%4==1): n+(n%4 != 0));
FOR0(i, n+1) y ^= a[i];
FOR0(i, n+1) if(a[i] == y) pos.pb(i);
pos[1] = n-pos[1];
FOR(k,1,n+2) {
cout << ((choose(n+1,k) - choose(pos[0] + pos[1],k-1))%mod + mod) % mod<< endl;
}
}
| 0
| 32,291,735
|
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cassert>
using namespace std;
typedef long long LL;
template <typename F, typename S> std::ostream& operator<<(ostream& os, const pair<F,S>& p) {
os << "(" << p.first << "," << p.second << ")"; return os; }
template <typename T> ostream& operator<<(ostream& os, const vector<T>& v) {
os << "["; for(const T& a: v){ os << a << ", "; } os << "]"; return os; }
template <typename K, typename V> ostream& operator<<(ostream& os, const map<K,V>& m) {
os << "{"; for(const auto& p: m){ os << p.first <<":"<< p.second << ", "; } os << "}"; return os; }
int main(){
LL n;
cin >> n;
vector<LL> p(n);
vector<LL> idx(n);
for(LL i = 0; i < n; ++i){
cin >> p[i];
idx[p[i]-1] = i;
}
LL ans = 0;
set<LL> used;
used.insert(idx[n-1]);
used.insert(-2);
used.insert(-1);
used.insert(n);
used.insert(n+1);
for(LL i = n-2; i >= 0; --i){
auto it = used.lower_bound(idx[i]);
LL r1 = min(n, *it);
LL r2 = min(n, *used.lower_bound(r1+1));
LL l1 = max<LL>(-1, *(--it));
LL l2 = max<LL>(-1, *(--it));
LL cnt = (r2-r1)*(idx[i]-l1) + (l2-l1)*(idx[i]-r1);
ans += cnt * (i+1);
used.insert(idx[i]);
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <utility>
#include <set>
#include <stack>
#include <climits>
#include <cmath>
#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 reps(i,s,n) for(int i=s, i##_len=(n); i<i##_len; ++i)
#define all(x) (x).begin(),(x).end()
#define MEMSET(v, h) memset((v), h, sizeof(v))
typedef long long ll;
const char sp = ' ';
using namespace std;
int main(void){
ll N, C, K;
ll t;
cin>>N>>C>>K;
vector<ll> T;
rep(i, N){
cin>>t;
T.push_back(t);
}
sort(all(T));
ll count=1, mem=1;
ll thc=T[0];
rep1(i, N-1){
if(T[i]>thc+K || mem>=C){
mem=0;
thc=T[i];
count++;
}
mem++;
}
cout<<count<<endl;
return 0;
}
| 0
| 53,782,145
|
#include<bits/stdc++.h>
using ll = long long;
using namespace std;
struct UnionFind {
vector<int> par;
UnionFind(int N) : par(N) {
for(int i = 0; i < N; i++) par[i] = i;
}
int root(int x) {
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) return;
par[rx] = ry;
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;cin >> n;
int m;cin >> m;
UnionFind uni(n+1);
for(int i = 0; i < m; i++){
int a;cin >> a;
int b;cin >> b;
uni.unite(a,b);
}
vector<int> count = vector<int>(n+1,0);
int maxCount = 0;
for(int i = 1; i <= n; i++){
int tmp = uni.root(i);
count[tmp]++;
if(count[tmp]>maxCount){
maxCount = count[tmp];
}
}
cout << maxCount << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) cin >> A[i];
int l, r = N;
l = max(0, (int)count(A.begin(), A.end(), 1)-1);
while (r-l > 1) {
int c = (19*l+r+18)/20;
map<int, int> mp;
for (int i = 1; i < N; i++) {
if (A[i-1] >= A[i]) {
if (c == 1) {
mp[0] = 1;
break;
}
int t = A[i];
mp[t]++;
auto it = mp.upper_bound(t);
mp.erase(it, mp.end());
while (t > 0 && mp[t] == c) {
mp[t] = 0;
mp[t-1]++;
t--;
}
}
if (mp[0] > 0) break;
}
if (mp[0] == 0) r = c;
else l = c;
}
cout << r << endl;
return 0;
}
| 0
| 7,486,300
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main(){
int N,P,g=0,n=0,m=0;
cin>>N>>P;
vector<int> A(N);
for(int &i:A){
cin>>i;
if(i%2==1){
cout<<(int)pow(2,N-1)<<endl;
return 0;
}
}
if(P==1)
cout<<0<<endl;
else
cout<<(int)pow(2,N)<<endl;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define FastIO ios_base::sync_with_stdio(0);cin.tie(0),cout.tie(0)
#define pb push_back
#define mp make_pair
#define mem(x,i) memset(x,i,sizeof(x))
#define ff first
#define ss second
#define popcount(x) __builtin_popcount(x)
#define all(x) x.begin(),x.end()
#define Case(t) for(int ks=1;ks<=t;ks++)
#define fileout freopen("output.txt","w",stdout)
#define filein freopen("input.txt","r",stdin)
#define D(x) cerr<< __LINE__ <<": "<< #x << " = "<<(x) <<'\n';
#define endl '\n'
using namespace std;
using namespace __gnu_pbds;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
using pil = pair<int,ll>;
const int INF = 0x3f3f3f3f;
const ll LL_INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
const double eps = 1e-4;
const int mod = 1e9+7;
const int mx = 5e5+5;
template <typename T> using orderedSet =
tree<T, null_type, less_equal<T>,
rb_tree_tag, tree_order_statistics_node_update>;
int main()
{
int n;
cin>>n;
vector<char>v;
for(int i=0;i<n;i++)
{
char c;cin>>c;
if(v.empty() || v.back()!=c) v.pb(c);
}
cout<<v.size()<<endl;
}
| 0
| 24,905,813
|
#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>;
ll x = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
priority_queue<int> pr;
int sum = 0;
rep(i,n) {
int a;
cin >> a;
sum += a;
pr.push(a);
}
rep(i,m) {
if (pr.top() < (double)sum/(4*m)) {
cout << "No" << endl;
return 0;
}
pr.pop();
}
cout << "Yes" << endl;
return 0;
}
|
#include <iostream>
#include <fstream>
#include <vector>
#include <cstring>
#include <queue>
#include <algorithm>
#include <math.h>
#include <map>
#include <set>
#define DEBUG 0
#define REP(i, n) for (long long i = 0; i < (n); i++)
typedef long long ll;
static const ll MOD = 1000000007;
static const ll INF = 1000000000000000000LL;
using namespace std;
int solve(){
ll H,W,M;
cin >> H >> W >> M;
set <pair<ll,ll>> st;
REP(i,M)
{
ll a,b;
cin >> a >> b;
st.insert({a,b});
}
map <ll,ll> mph,mpw;
ll hmaxval = 0;
ll wmaxval = 0;
vector <ll> hmax,wmax;
for(auto tmp: st)
{
hmaxval = max(hmaxval,++mph[tmp.first]);
wmaxval = max(wmaxval,++mpw[tmp.second]);
}
for(auto tmp:mph)
{
if(hmaxval == tmp.second)hmax.push_back(tmp.first);
}
for(auto tmp:mpw)
{
if(wmaxval == tmp.second)wmax.push_back(tmp.first);
}
ll res = hmaxval + wmaxval -1;
for(auto h: hmax)
{
for(auto w: wmax)
{
if(st.find({h,w}) == st.end())
{
++res;
cout << res << endl;
return 0;
}
}
}
cout << res << endl;
return 0;
}
int main()
{
solve();
return 0;
}
| 0
| 37,020,342
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k; cin>>n>>k;
vector<long long> a(n), s(n+1, 0);
for (int i = 0; i < n; i++) cin>>a[i];
for (int i = 0; i < n; i++) s[i+1] = s[i] + a[i];
long long ans = 0;
map<int, int> v;
int l = 0;
for (int r = 0; r < n+1; r++) {
if (r-l >= k) {
--v[(s[l]-l)%k];
++l;
}
ans += v[(s[r]-r)%k];
++v[(s[r]-r)%k];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(void)
{
int n;
cin >> n;
vector<int> v1(n/2, 0), v2(n/2, 0);
for (int i = 0; i < n; i++)
{
if(i%2 == 0){
cin >> v1[i/2];
} else {
cin >> v2[(i-1)/2];
}
}
map<int, int> count1, count2;
for (int i = 0; i < n/2; i++)
{
count1[v1[i]]++;
}
for (int i = 0; i < n/2; i++)
{
count2[v2[i]]++;
}
int freq1_first = 0;
int freq1_2nd = 0;
int freq2_first = 0;
int freq2_2nd = 0;
int freq1_num, freq2_num;
for (auto elem: count1)
{
if(freq1_first < elem.second) {
freq1_2nd = freq1_first;
freq1_first = elem.second;
freq1_num = elem.first;
} else if(freq1_2nd < elem.second){
freq1_2nd = elem.second;
}
}
for (auto elem: count2)
{
if(freq2_first < elem.second) {
freq2_2nd = freq2_first;
freq2_first = elem.second;
freq2_num = elem.first;
} else if(freq2_2nd < elem.second){
freq2_2nd = elem.second;
}
}
int ans;
if(freq1_num != freq2_num){
ans = (n/2 - freq1_first) + (n/2 - freq2_first);
} else {
int ans1 = (n/2 - freq1_first) + (n/2 - freq2_2nd);
int ans2 = (n/2 - freq2_first) + (n/2 - freq1_2nd);
ans = min(ans1, ans2);
}
cout << ans << endl;
return 0;
}
| 0
| 4,965,477
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using vll = vector<ll> ;
#define all(v) v.begin(),v.end()
#define P pair<int, ll>
int main(){
int X,Y,Z,K;cin>>X>>Y>>Z>>K;
vll A(X),B(Y),C(Z);
rep(i,X)cin>>A[i];
rep(i,Y)cin>>B[i];
rep(i,Z)cin>>C[i];
vll bc(1001000,0);
rep(i,Y)rep(j,Z){
bc[i*1000+j] = B[i] + C[j];
}
sort(all(bc),greater<ll>());
sort(all(A),greater<ll>());
auto compare = [&](auto const& a,auto const& b){ return a.second < b.second;};
priority_queue <P, vector<P>, decltype(compare)> pos_sum{compare};
rep(i,X){
int pos = 0;
ll sum = A[i] + bc[0];
pos_sum.push(make_pair(pos,sum));
}
rep(i,K){
P p = pos_sum.top();pos_sum.pop();
if(p.first >= Y * Z) continue;
cout << p.second << endl;
p.first += 1;
p.second -= bc[p.first - 1] - bc[p.first];
pos_sum.emplace(p.first, p.second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define IOS \
ios_base::sync_with_stdio(0); \
cin.tie(NULL); \
cout.tie(NULL);
#define pb push_back
#define mp make_pair
#define Debug(x) cout << #x " = " << (x) << endl
#define SORT(a) sort(a.begin(), a.end())
#define SORTR(a) sort(a.rbegin(), a.rend())
#define mod 1000000007
#define pi 3.141592653589793238
#define ll long long int
#define ull unsigned long long
#define be begin()
#define en end()
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define FORI(i, a, b) for (int i = a; i >= b; i--)
typedef vector<int> VI;
typedef vector<ll> VL;
typedef pair<int, int> PI;
typedef pair<ll, ll> PL;
typedef vector<PI> VPI;
int main()
{
IOS;
int a, b, c, k;
cin >> a >> b >> c >> k;
if (a < b && b < c)
{
cout << "Yes" << endl;
}
else
{
while (k > 0 && a >= b)
{
k--;
b *= 2;
}
while (k > 0 && b >= c)
{
k--;
c *= 2;
}
if (a < b && b < c)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
return 0;
}
| 0
| 70,950,392
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
#define pb push_back
#define f(i,n) for(i=0;i<n;i++)
#define F(i,a,b) for(i=a;a<=b;i++)
#define arr(a,n) for( i=0;i<n;i++)cin>>a[i];
#define fi first
#define se second
#define mp make_pair
#define mod 1000000007
#define YES cout<<"YES"<<endl;
#define Yes cout<<"Yes"<<endl;
#define NO cout<<"NO"<<endl;
#define No cout<<"No"<<endl;
#define yes cout<<"yes"<<endl;
#define no cout<<"no"<<endl;
#define vi vector<ll>
#define ed end()
#define bg begin()
#define sz size()
#define ln length()
#define s() sort(a,a+n);
#define sr() sort(a,a+n,greater<ll>());
#define v() sort(v.begin(),v.end());
#define vr() sort(v.begin(),v.end(),greater<ll>());
#define mod 1000000007
#define fast() ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
ll gcd(ll a, ll b){if(!b)return a;return gcd(b, a % b);}
ll power(ll x,ll y,ll p){ll res=1;x%=p;while(y>0){if(y&1)res=(res*x)%p;y=y>>1;x=(x*x)%p;}return res;}
int main() {
fast();
{
ll x;
cin>>x;
ll q=(1ll*x)/(1ll*100);
ll r=x%100;
if(q*5>=r)
cout<<1<<endl;
else
{
cout<<0<<endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ALL(a) (a).begin(),(a).end()
#define FOR(i, begin, end) for(int i=(begin);i<(end);i++)
#define REP(i, n) FOR(i,0,n)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define Max(a, b) a = max(a, b)
#define Min(a, b) a = min(a, b)
#define YES() printf("YES\n")
#define NO() printf("NO\n")
#define isYES(x) printf("%s\n",(x) ? "YES" : "NO")
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define isYes(x) printf("%s\n",(x) ? "Yes" : "No")
#define F first
#define S second
template<typename T> void Out(T x) { cout << x << endl; }
template<typename T1, typename T2> void Ans(bool f, T1 y, T2 n) { if (f) Out(y); else Out(n); }
using int64 = long long;
signed main() {
string s;
cin >> s;
for(int i = 0; i < (1 << 3); i++){
int cur = s[0] - '0';
string ans;
ans += s[0];
for(int j = 1; j < 4; j++){
if((i >> (j - 1)) & 1){
cur += s[j] - '0';
ans += "+";
ans += s[j];
} else {
cur -= s[j] - '0';
ans += "-";
ans += s[j];
}
}
if(cur == 7) {
cout << ans << "=7" << endl;
return(0);
}
}
}
| 0
| 81,738,600
|
#include <stdlib.h>
#include <cmath>
#include <cstdio>
#include <cstdint>
#include <string>
#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
using namespace std;
using ll = long long;
int main(){
int X;
cin >> X;
if(X<100){
cout << 0 << endl;
return 0;
}
int new_X=X%100;
int N_PC=new_X/5;
new_X=new_X%5;
int temp_X=105*N_PC+100+new_X;
if(new_X==0) temp_X=105*N_PC;
if(X<temp_X) cout << 0 << endl;
else cout << 1 << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define reg register
#define ll long long
inline ll read()
{
ll x=0,w=0;char ch=getchar();
while(!isdigit(ch))w|=ch=='-',ch=getchar();
while(isdigit(ch))x=(x<<3)+(x<<1)+(ch^48),ch=getchar();
return w?-x:x;
}
ll ans;
char s[10];
inline void query(ll x)
{if(x==1){s[0]='Y';return ;}printf("? %lld\n",x);fflush(stdout);scanf("%s",s);}
inline int check(ll x)
{
reg ll y=x*10;
reg int l=0,r=10,mid;
while(l<r-1)
{
mid=(l+r)>>1;
query(y+mid);
if(s[0]=='N')r=mid;
else l=mid;
}
return r-1;
}
int main()
{
reg ll x;reg int i;
x=1;reg int len=15;
for(i=1;i<=10;++i)
{
query(x);
if(s[0]=='N')
{
len=i-1;break;
}x*=10;
}
if(len==15)
{
x=9;
for(i=1;i<=10;++i)
{
query(x);
if(s[0]=='Y')
{
len=i;break;
}x=x*10+9;
}
if(len>1)
{
ans=1;
for(i=1;i<len;++i)ans=ans*10;
printf("! %lld\n",ans);return 0;
}
}
for(i=1;i<len;++i)
x=check(ans),ans=ans*10+x;
if(len==1)
{
for(i=9;i>=1;--i)
{
query(i*10+1);
if(s[0]=='N'){printf("! %d\n",i+1);exit(0);}
}
puts("! 1");return 0;
}
for(i=0;i<=9;++i)
{
x=(ans*10+i)*10+1;
query(x);
if(s[0]=='Y')
{
ans=ans*10+i;
printf("! %lld\n",ans);exit(0);
}
}
return 0;
}
| 0
| 62,474,062
|
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define ll long long
#define ld long double
#define INF 1000000000000000000
typedef pair<ll, ll> pll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, L;
cin >> N >> L;
vector<ll> A(N);
rep(i, N) { cin >> A[i]; }
bool judge = 0;
int l, r;
rep(i, N - 1) {
if (A[i + 1] + A[i] >= L) {
judge = 1;
l = i;
r = i + 1;
break;
}
}
if (!judge) {
cout << "Impossible" << endl;
return 0;
}
cout << "Possible" << endl;
for (int i = 1; i <= l; i++) {
cout << i << endl;
}
for (int i = N - 1; i > r; i--) {
cout << i << endl;
}
cout << r << endl;
return 0;
}
|
#include <numeric>
#include <algorithm>
#include <vector>
#include <iostream>
using namespace std;
int main() {
int n, k; cin >> n >> k;
vector<int> vals[n];
for (int i = 0; i < n; i++) {
int t, d; cin >> t >> d;
vals[t-1].push_back(d);
}
vector<int> rest, top;
for (int i = 0; i < n; i++) {
vector<int> &v = vals[i];
if (!v.empty()) {
sort(v.begin(), v.end());
top.push_back(v.back());
rest.insert(rest.end(), v.begin(), prev(v.end()));
}
}
sort(top.rbegin(), top.rend());
sort(rest.begin(), rest.end());
if (top.size() > k) top.resize(k);
long long sum = accumulate(top.begin(), top.end(), 0LL), count = top.size();
for (int i = 0; i < k - top.size(); i++) {
sum += rest.back();
rest.pop_back();
}
long long ans = sum + count * count;
while (!top.empty() && !rest.empty() && count > 0) {
count--;
sum += rest.back() - top.back();
rest.pop_back(); top.pop_back();
ans = max(ans, sum + count * count);
}
cout << ans << endl;
}
| 0
| 25,045,891
|
#include <bits/stdc++.h>
#define ll long long
#define rep(i,a,b) for(long long i=a; i<b; i+=1)
#define repr(i,a,b) for(long long i=a; i<=b; i+=1)
#define vec vector<ll>
#define mapa map<char,int>
#define repa(p,A) for(auto p:A)
#define pb push_back
#define reverse(a) reverse(a.begin(),a.end())
const double PI=acos(-1);
using namespace std;
int main( ) {
vec A,B;
ll N;
cin>>N;
rep(i,0,N) {
ll a;
cin>>a;
if(i%2==0) {
A.push_back(a);
}
else {
B.push_back(a);
}
}
map<ll,ll> C,D;
rep(i,0,A.size()) {
C[A[i]]++;
}
rep(i,0,B.size()) {
D[B[i]]++;
}
vector<pair<ll,ll>> E,F;
for(auto p:C) {
E.push_back(pair<ll,ll>(p.first,p.second));
}
for(auto p:D) {
F.push_back(pair<ll,ll>(p.first,p.second));
}
auto comp = [](pair<int, int> a, pair<int, int> b) {
return a.second>b.second;
};
ll count=0;
sort(E.begin(),E.end(),comp);
sort(F.begin(),F.end(),comp);
if(E[0].first==F[0].first) {
if(E.size()>=2) {
count+=E[0].second+max(E[1].second,F[1].second);
}
else count+=E[0].second;
}
else count+=E[0].second+F[0].second;
cout<<N-count<<endl;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <iomanip>
#include <cmath>
#include <map>
#include <complex>
#include <random>
using namespace std;
random_device rd;
mt19937 mt(rd());
using Point = complex<double>;
double dot(Point p, Point q) { return (conj(p) * q).real(); }
int n;
double x, y;
vector<Point> ps;
int main() {
cin.tie(0); ios_base::sync_with_stdio(false);
cin >> n;
for(int i = 0; i < n; ++i) {
cin >> x >> y;
ps.emplace_back(x, y);
}
double ans = 0.0;
uniform_real_distribution<> rand(-1.0, 1.0);
for(int unko = 0; unko < 100000; ++unko) {
vector<Point> engines;
Point move(rand(mt), rand(mt));
for(int i = 0; i < n; ++i) {
if(dot(move , ps[i]) >= 0) {
engines.push_back(ps[i]);
}
}
x = 0.0, y = 0.0;
for(auto engine : engines) {
x += engine.real(), y += engine.imag();
}
ans = max(ans, sqrt(x*x + y*y));
}
cout << fixed << setprecision(15) << ans << endl;
return 0;
}
| 0
| 99,749,924
|
#include <iostream>
using namespace std;
int main(){
int a, b, c, d;
cin >> a >> b >> c;
if (a >= b){
d = a; a = b; b = d;
}
if (c <= a){
d = c; c = a; a = d;
}
if (c >= a && c <= b){
d = b; b = c; c = d;
}
cout << a << " " << b << " " << c << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
int main() {
ll N,L;
cin >> N >> L;
vector<ll> A(N);
for(int i=0;i<N;i++){
cin >> A[i];
}
ll l=-1,r=-1;
for(int i=1;i<N;i++){
if(A[i-1]+A[i]>=L){
l = i-1;
r=i;
break;
}
}
if(l==-1){
cout << "Impossible" << endl;
return 0;
}
cout <<"Possible" << endl;
for(int i=0;i<l;i++){
cout << i+1 << endl;
}
for(int j=N-1;j>r;--j){
cout << j << endl;
}
cout << r << endl;
return 0;
}
| 0
| 70,564,692
|
#include <iostream>
#include <string>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <cmath>
#include <stdio.h>
#include <queue>
#include <deque>
#include <cstdio>
#include <set>
#include <map>
#include <bitset>
#include <stack>
#include <cctype>
using namespace std;
vector<int> a, b;
int main() {
string s;
cin >> s;
sort(s.begin(), s.end());
if (s[0] == s[1] && s[2] == s[3] && s[0] != s[2]) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
return 0;
}
|
#include <iostream>
#include <string>
#include <utility>
#include <vector>
#include <algorithm>
using namespace std;
typedef pair<int, int> pi;
int N, M;
vector<vector<pi> > P;
vector<string> A;
void input_init(void) {
cin >> N >> M;
P.resize(N + 1);
for (int i = 0; i < M; ++i) {
int p, y;
cin >> p >> y;
P[p].push_back(make_pair(y, i));
}
A.resize(M);
}
void make_str(int p, int x, int idx) {
string s1 = to_string(p);
int rest = 6 - s1.length();
string s2 = string(rest, '0') + s1;
string s3 = to_string(x);
rest = 6 - s3.length();
string s4 = string(rest, '0') + s3;
A[idx] = s2 + s4;
}
void solve(void) {
for (int i = 1; i < (int)P.size(); ++i) {
if (P[i].size() == 0)
continue;
sort(P[i].begin(), P[i].end());
for (int j = 0; j < (int)P[i].size(); ++j) {
make_str(i, j + 1, P[i][j].second);
}
}
}
int main(void) {
input_init();
solve();
for (int i = 0; i < M; ++i)
cout << A[i] << '\n';
return 0;
}
| 0
| 41,610,277
|
#include "bits/stdc++.h"
using ll = long long;
using namespace std;
void solve() {
int n;
cin >> n;
vector <ll> a(n);
vector <int> b(n);
for(int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
ll ans = 0;
for(int i = n - 1; i >= 0; i--) {
a[i] += ans;
ans += (b[i] - (a[i] % b[i])) % b[i];
}
cout << ans << endl;
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int testcase = 1;
for(int i = 0; i < testcase; i++) {
solve();
}
return 0;
}
|
#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 a,b; cin>>a>>b;
vector<vector<char>> ans(100,vector<char>(100,'#'));
rep(i,50){
rep(j,100){
ans[i+50][j]='.';
}
}
rep(i,a-1){
int x=i%50; x*=2;
int y=i/50; y*=2;
ans[y][x]='.';
}
rep(i,b-1){
int x=i%50; x*=2;
int y=i/50; y*=2; y+=51;
ans[y][x]='#';
}
cout<<"100 100"<<endl;
rep(i,100){
rep(j,100){
cout<<ans[i][j];
}
cout<<endl;
}
}
| 0
| 31,454,560
|
#define _USE_MATH_DEFINES
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <bitset>
#include <stack>
#include <deque>
#include <set>
#include <unordered_set>
#include <list>
#include <map>
#include <unordered_map>
#include <algorithm>
#include <cmath>
#include <climits>
#include <ctime>
#include <random>
#define speed ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define ll long long
#define eps 1e-9
#define inf 0x3f3f3f3f
#define mod 1000000007
using namespace std;
int main() {
speed;
string s;
cin >> s;
if (s == "RRR")
cout << 3;
else if (s == "RRS" || s == "SRR")
cout << 2;
else if (s == "SSS")
cout << 0;
else
cout << 1;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mod107 1000000007
#define rep(i, n) for (int i = 0; i < n; ++i)
using Graph = vector<vector<int>>;
#define grepq priority_queue<double, std::vector<double>, std::greater<double>>
#define all(v) v.begin(), v.end()
#define PI acos(-1)
const ll INF = 10010001010;
const int inf = 1000034000;
typedef vector<ll> vecl;
typedef vector<int> veci;
typedef tuple<string, int, int> TUP;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int W, H, N;
cin >> W >> H >> N;
vector<int> X(N);
vector<int> Y(N);
vector<int> A(N);
ll ans = 0;
vector<vector<char>> B(H, vector<char>(W, '-'));
for (int i = 0; i < N; i++)
{
cin >> X[i] >> Y[i] >> A[i];
if(A[i] == 1){
for (int j = 0; j < H;j++)
{
for (int k = 0; k < X[i];k++)
{
B[j][k] = '*';
}
}
}
else if(A[i] == 2){
for (int j = 0; j < H;j++)
{
for (int k = X[i]; k < W;k++)
{
B[j][k] = '*';
}
}
}
else if(A[i] == 4){
for (int j = Y[i]; j < H;j++)
{
for (int k = 0; k < W;k++)
{
B[j][k] = '*';
}
}
}
else{
for (int j = 0; j < Y[i];j++)
{
for (int k = 0; k < W;k++)
{
B[j][k] = '*';
}
}
}
}
for (int i = 0; i < H;i++)
{
for (int j = 0; j < W;j++)
{
if(B[i][j] == '-'){
ans++;
}
}
}
cout << ans << endl;
}
| 0
| 74,708,468
|
#include<bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define first ff
#define second ss
#define pi acos(-1.0)
typedef long long ll;
using namespace std;
vector<int>node[10001];
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin>>n;
string s;
cin>>s;
if(n%2)
cout<<"No"<<endl;
else
{
string a="",b="";
for(int i=0;i<n;i++)
{
if(i<n/2)
a+=s[i];
else
b+=s[i];
}
if(a==b)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <map>
#include <queue>
static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using namespace std;
template<class T>
constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;
template <class T>
vector<T> make_v(size_t size, const T& init){ return vector<T>(size, init); }
template<class... Ts>
auto make_v(size_t size, Ts... rest) { return vector<decltype(make_v(rest...))>(size, make_v(rest...)); }
int main() {
int n;
cin >> n;
ll i = 0;
while(i*(i+1)/2 < n)i++;
if(n != i*(i+1)/2){
puts("No");
return 0;
}else {
puts("Yes");
cout << i+1 << "\n";
}
auto v = make_v(i+1, i, 0);
int p = 1, q = 1;
for (int j = 0; j < i; ++j) {
for (int k = 0; k < i-j; ++k) {
v[j][k+j] = p;
v[k+j+1][j] = p;
p++;
}
}
for (int j = 0; j < i+1; ++j) {
printf("%d", i);
for (int k = 0; k < i; ++k) {
printf(" ");
printf("%d", v[j][k]);
}
printf("\n");
}
return 0;
}
| 0
| 79,253,632
|
#include <bits/stdc++.h>
using namespace std;
int a[3];
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> a[0] >> a[1] >> a[2];
sort(a, a + 3);
cout << a[2] * 10 + a[1] + a[0];
return 0;
}
|
#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
#include <cmath>
using namespace std;
typedef long long ll;
#define rep(i,n) for (int i = 0; i < (n); ++i)
int main(){
int n; cin >> n;
vector<int> p(n);rep(i,n) cin >> p[i];
vector<int> q(n);rep(i,n) cin >> q[i];
vector<int> r(n);rep(i,n) r[i]=i+1;
int pnum=0,qnum=0;
bool okp=true,okq=true;
do{
if(okp){
rep(i,n){
if(p[i]!=r[i]) break;
if(i==n-1) okp=false;
}
pnum++;
}
if(okq){
rep(i,n){
if(q[i]!=r[i]) break;
if(i==n-1) okq=false;
}
qnum++;
}
if(!okp && !okq) break;
}while(next_permutation(r.begin(),r.end()));
cout << abs(pnum-qnum) << endl;
}
| 0
| 33,432,436
|
#include <bits/stdc++.h>
#define cn count;
#define pb push_back
#define in insert
#define fs first
#define sc second
#define sz size
#define len length
#define forn(i, n) for (ll i = 0; i < (ll) (n); ++i)
#define forni(i, n) for (ll i = 1; i < (ll) (n); ++i)
#define IO ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
using namespace std;
using ll = long long;
const ll inf = 1e9+7;
const double PI = 3.141592653589793;
int main(){
IO;
ll a,b,c,d,lcm,ans;
cin>>a>>b>>c>>d;
lcm= c*d/__gcd(c,d);
ans = b-a;
ans -= (b/c)-(a/c);
ans -= (b/d)-(a/d);
ans += (b/lcm)-(a/lcm);
if(a%d!=0 && a%c!=0)ans++;
cout<<ans<<"\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
#define MAX 1000
typedef pair<int, int> P;
int h, w;
char a[MAX][MAX];
int d[MAX][MAX];
int dy[4] = {-1, 0, 1, 0};
int dx[4] = {0, 1, 0, -1};
queue<P> que;
void bfs() {
while (que.size()) {
P p = que.front();
que.pop();
for (int i = 0; i < 4; i++) {
int ny = p.first + dy[i];
int nx = p.second + dx[i];
if (0 <= ny && ny < h && 0 <= nx && nx < w && a[ny][nx] == '.' && d[ny][nx] == INT_MAX) {
d[ny][nx] = d[p.first][p.second] + 1;
que.emplace(P(ny, nx));
}
}
}
return;
}
int main() {
cin >> h >> w;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
cin >> a[i][j];
if (a[i][j] == '#') {
d[i][j] = 0;
que.emplace(P(i, j));
}
else {
d[i][j] = INT_MAX;
}
}
}
bfs();
int ans = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
chmax(ans, d[i][j]);
}
}
cout << ans << endl;
}
| 0
| 17,270,977
|
#include <fstream>
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <sstream>
#include <map>
#include <set>
#include <vector>
#include <stack>
#include <cmath>
#include <queue>
#include <random>
#include <numeric>
using namespace std;
#define I_MAX 2147483647
#define LL_MAX 9223372036854775807
#define ll long long
#define ld long double
struct XX{
string s;
int p;
int c1;
int c2;
int num;
};
class xxGreater {
public:
bool operator()(const XX& riLeft, const XX& riRight) const {
if((riLeft.s) == (riRight.s)){
return riLeft.p < riRight.p;
}
return (riLeft.s) < (riRight.s);
}
};
#ifdef DEBUG
#else
#endif
int main(int argc, const char * argv[])
{
ios::sync_with_stdio(false);
cin.tie(0);
int N,M;
cin>>N>>M;
vector<ll> a[100000];
for(int i=0;i<N;i++){
ll t1,t2;
cin>>t1>>t2;
t1--;
a[t1].push_back(t2);
}
priority_queue<ll> pque;
ll ans=0;
for(int i=0;i<M;i++){
for(auto s:a[i]){
pque.push(s);
}
if(!pque.empty()){
ans+=pque.top();
pque.pop();
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> rbd(vector<long long> mat) {
int n = mat.size();
int rk = 0;
for (int i = 60; i >= 0; i--) {
bool exist = false;
for (int j = rk; j < n; j++) {
if (mat[j] >> i & 1) {
exist = true;
swap(mat[rk], mat[j]);
break;
}
}
if (exist) {
for (int j = 0; j < n; j++) {
if (j != rk && mat[j] >> i & 1) {
mat[j] ^= mat[rk];
}
}
rk++;
}
}
return mat;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
long long all = 0;
vector<long long> as(n);
for (int i = 0; i < n; i++) cin >> as[i];
vector<int> cnt(60);
for (int i = 0; i < n; i++) {
all ^= as[i];
for (int j = 0; j < 60; j++) {
if (as[i] >> j & 1) cnt[j]++;
}
}
long long ans = 0;
for (int i = 0; i < 60; i++) {
if (cnt[i] & 1) {
ans += 1LL << i;
for (int j = 0; j < n; j++) {
if (as[j] >> i & 1) {
as[j] ^= 1LL << i;
}
}
}
}
long long a = 0;
auto bs = rbd(as);
for (auto &b : bs) {
a ^= b;
}
cout << a + (all ^ a) << endl;
}
| 0
| 78,506,812
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
vector<int> a(n + 1);
for(int i = 1;i <= n;i++){
cin >> a[i];
}
for(int i = 1;i <= n;i++){
cout << "node " << i << ": key = " << a[i] << ", ";
if(i / 2 >= 1)cout << "parent key = " <<a[i / 2] << ", ";
if(2 * i <= n)cout << "left key = " << a[2 * i] << ", ";
if(2 * i + 1<= n)cout << "right key = " << a[2 * i + 1] << ", ";
cout << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define gc getchar_unlocked
#define fo(i,n) for(i=0;i<n;i++)
#define Fo(i,k,n) for(i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define ll long long
#define si(x) scanf("%d",&x)
#define sl(x) scanf("%lld",&x)
#define ss(s) scanf("%s",s)
#define pi(x) printf("%d\n",x)
#define pl(x) printf("%lld\n",x)
#define ps(s) printf("%s\n",s)
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626
typedef pair<int, int> pii;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpii;
typedef vector<pl> vpl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
mt19937_64 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
int rng(int lim) {
uniform_int_distribution<int> uid(0,lim-1);
return uid(rang);
}
const int mod = 1'000'000'007;
const int N = 3e5, M = N;
void solve() {
int i, j, n, m;
cin >> n;
i=1;
while(i<=n){
i*=2;
}
cout << i/2;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
int t = 1;
while(t--) {
solve();
}
return 0;
}
| 0
| 51,423,920
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
long long int y;
cin>>n>>y;
for(int i=0;i<=n;i++){
for(int j=0;j<=n;j++){
int t;
if(n-i-j>=0) t=n-i-j;
else continue;
if(10000*i+5000*j+1000*t==y){
cout<<i<<" "<<j<<" "<<n-i-j;
return 0;
}
}
}
cout<<"-1"<<" "<<"-1"<<" "<<"-1";
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
while(1){
int n;
cin>>n;
if(n == 0) break;
vector <int> data(n);
for(int i=0; i<n; i++){
cin>>data.at(i);
}
sort(data.begin(), data.end());
reverse(data.begin(),data.end());
vector <int> gap(n);
for(int i=0; i<n-1; i++){
gap.at(i) = data.at(i) - data.at(i+1);
}
sort(gap.begin(),gap.end());
if(gap.at(0) == 0) cout<<gap.at(1)<<endl;
else cout<<gap.at(0)<<endl;
}
return 0;
}
| 0
| 56,035,643
|
#include<iostream>
#include <bits/stdc++.h>
#include <string>
#include <cstring>
#include <algorithm>
using namespace std;
int main() {
int n ;
cin >> n ;
int a[n+2] ;
a[0] = 0 ;
a[n+1] = 0 ;
int sum = 0 ;
for(int i=1;i<=n;i++){
cin >> a[i] ;
sum+= abs(a[i]-a[i-1]) ;
}
sum+=abs(a[n]-a[0]) ;
for(int i=1;i<=n;i++){
cout << sum-abs(a[i]-a[i-1])-abs(a[i+1]-a[i])+abs(a[i+1]-a[i-1]) << endl ;
}
return 0;
}
|
#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 INF 1e9
typedef long long ll;
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ll n;
string s, pin, sub_s;
int ans = 0, pos;
bool ok;
cin >> n >> s;
REP(i,1000){
ostringstream sout;
sout << std::setfill('0') << std::setw(3) << i;
pin = sout.str();
sub_s = s;
ok = true;
REP(j,3)
{
pos = sub_s.find_first_of(pin[j]);
if(pos != string::npos){
sub_s = sub_s.substr(pos+1);
}
else{
ok = false;
break;
}
}
if(ok) ans += 1;
}
printf("%d", ans);
return 0;
}
| 0
| 1,593,143
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(void){
int n;
cin >> n;
vector<ll> a(n);
for (int i=0; i<n; i++) cin >> a[i];
list<ll> b;
bool toggle = true;
for (auto x : a) {
toggle ? b.push_back(x) : b.push_front(x);
toggle ^= true;
}
if (toggle == false) reverse(b.begin(), b.end());
for (auto x : b) cout << x << ' ';
cout << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define rep(i,n) for (int i=0; i<n; i++)
#define REP(i,x,n) for (int i=x; i<n; i++)
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using ll = long long;
ll INF = 1'000'000'000'000'000'000;
int main(){
int n;
cin >> n;
ll ans = 1;
vector<ll> a(n);
rep(i,n){
cin >> a.at(i);
if (a.at(i) == 0){
cout << 0 << endl;
return 0;
}
}
rep(i,n){
if (INF/ans < a.at(i) || ans > INF){
cout << -1 << endl;
return 0;
}
ans *= a.at(i);
}
cout << ans << endl;
return 0;
}
| 0
| 48,469,388
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
long long n,m,sum=0;
cin>>n>>m;
vector<int> v(m);
for(long i=0;i<m;i++)
{
cin>>v[i];
}
for(long i=0;i<m;i++)
{
sum+=v[i];
}
if(n-sum>=0)
{
cout<<n-sum<<"\n";
}
else
{
cout<<"-1"<<"\n";
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
int N;
string hoge(int n){
string res;
if(n <= N && to_string(n) <= to_string(N)) res = "Y";
else if(n > N && to_string(n) > to_string(N)) res = "Y";
else res = "N";
cout<<res<<endl;
return res;
}
bool checkt(int m){
string ans;
m *= 10;
cout<<"? "<<m<<endl;
ans = hoge(m);
return ans == "Y";
}
void solvet(){
int con = 0;
for(int i = 1; con < 11;i *= 10){
int n = i;
string ans;
cout<<"? "<<n<<endl;
ans = hoge(n);
if(ans == "Y") {
con++;
} else{
break;
}
}
if(con == 11) {
for(int i = 2, j = 1; ; i *= 10, j *= 10){
string ans;
cout<<"? "<<i<<endl;
cout<<flush;
ans = hoge(i);
if(ans == "Y") {
cout<<"! "<<j<<endl;
return ;
}
}
return ;
}
int l = 1, h = 10, m = 0;
for(int i = 1; i < con; i++){
l *= 10;
h *= 10;
}
while(l + 1< h){
m = (l + h)/2;
if(!checkt(m)){
l = m;
} else {
h = m;
}
}
cout<<"! "<<h<<endl;
cout<<flush;
}
void test(){
while(true){
cin>>N;
solvet();
while(true){
int x;
cin>>x;
cout<<hoge(x)<<endl;
}
}
}
bool check(int m){
string ans;
m *= 10;
cout<<"? "<<m<<endl;
cout<<flush;
cin>>ans;
return ans == "Y";
}
void solve(){
int con = 0;
for(int i = 1;con < 11 ;i *= 10){
int n = i;
string ans;
cout<<"? "<<n<<endl;
cout<<flush;
cin>>ans;
if(ans == "Y") {
con++;
} else if(ans == "N"){
break;
}
}
if(con == 11) {
for(int i = 2, j = 1; ; i *= 10, j *= 10){
string ans;
cout<<"? "<<i<<endl;
cout<<flush;
cin>>ans;
if(ans == "Y") {
cout<<"! "<<j<<endl;
return ;
}
}
return ;
}
int l = 1, h = 10, m = 0;
for(int i = 1; i < con; i++){
l *= 10;
h *= 10;
}
while(l + 1< h){
m = (l + h)/2;
if(!check(m)){
l = m;
} else {
h = m;
}
}
cout<<"! "<<h<<endl;
cout<<flush;
}
signed main(){
solve();
return 0;
}
| 0
| 95,367,518
|
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <set>
using ll = long long;
using graph = std::vector<std::vector<ll>>;
using wGraph = std::vector<std::vector<std::pair<ll,ll>>>;
#define rep(i,n) for (int i=0; i < int(n); i++)
using namespace std;
ll MOD7 = 1000000007;
ll MOD9 = 1000000009;
vector<ll> InputVec(ll N){
vector<ll> A(N);
for (int i = 0; i < N; ++i) {
cin >> A[i];
}
return A;
}
void OutputVec(vector<ll> A){
for (int i = 0; i < A.size(); ++i) {
cout << A[i] << ",";
}
cout << endl;
}
vector<vector<ll>> InputVec2d(ll H,ll W){
vector<vector<ll>> A(H);
for (int yi = 0; yi < H; ++yi) {
A[yi] = vector<ll>(W);
}
for (int yi = 0; yi < H; ++yi) {
for (int xi = 0; xi < W; ++xi) {
cin >> A[yi][xi];
}
}
}
void OutputVec2d(vector<vector<ll>> A){
for (int yi = 0; yi < A.size(); ++yi) {
for (int xi = 0; xi < A[yi].size(); ++xi) {
cout << A[yi][xi] << ",";
}
cout << endl;
}
}
graph InputGraph(ll N,ll M){
graph G(N);
for (int i = 0; i < M; ++i) {
ll a,b;
cin >> a >> b;
a--;b--;
G[a].push_back(b);
G[b].push_back(a);
}
return G;
}
graph InputDGraph(ll N,ll M){
graph G(N);
for (int i = 0; i < M; ++i) {
ll a,b;
cin >> a >> b;
a--;b--;
G[a].push_back(b);
}
return G;
}
void OutputGraph(graph G){
for (int i = 0; i < G.size(); ++i) {
cout << i << ":";
for (int j = 0; j < G[i].size(); ++j) {
cout << G[i][j]<< ",";
}
cout << endl;
}
}
int main() {
ll N,K;
cin >> N >> K;
auto a = InputVec(N);
vector<ll> sum(N + 1);
sum[0] = 0;
for (int i = 1; i < N + 1; ++i) {
sum[i] += sum[i - 1] + a[i - 1];
}
ll res = 0;
for (int i = 40; i >= 0; --i) {
ll count = 0;
for (int j = 0; j < N; ++j) {
}
for (int si = 0; si < N; ++si) {
for (int gi = si + 1; gi < N + 1; ++gi) {
ll b = sum[gi] - sum[si];
if(((res + (1ll << i)) & b) == (res + (1ll << i))){
count++;
}
}
}
if(count >= K){
res += 1ll << i;
}
}
cout << res << endl;
}
|
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <random>
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update> orderedSet;
#define pb push_back
#define F first
#define S second
#define all(a) (a).begin(), (a).end()
#define for1(i0, l0, r0) for (int i0 = l0; i0 < r0; ++i0)
#define for2(i0, l0, r0) for (int i0 = l0; i0 <= r0; ++i0)
#define forn(i0, n0) for (int i0 = 0; i0 < n0; ++i0)
#define forn1(i0, n0) for (int i0 = 1; i0 < n0; ++i0)
#define forr(i0, n0) for (int i0 = n0; i0 >= 0; --i0)
#define forr1(i0, r0, l0) for (int i0 = r0; i0 > l0; --i0)
#define forr2(i0, r0, l0) for (int i0 = r0; i0 >= l0; --i0)
#define Sort(a) sort(all(a))
#define Reverse(a) reverse(all(a))
#define relaxMax(a, b) a = max(a, b)
#define relaxMin(a, b) a = min(a, b)
typedef long double ld;
#define ui unsigned int
#define ull unsigned long long
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef pair<string, string> pss;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<double> vd;
typedef vector<ld> vld;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<pdd> vpdd;
typedef vector<vi> vvi;
typedef vector<vd> vvd;
typedef vector<vll> vvll;
typedef vector<vb> vvb;
#define vpss vector<pss>
#define vvs vector<vs>
#define vvpii vector<vpii>
#define vvpll vector<vpll>
#define vpt vector<pt>
#define vvvi vector<vvi>
#define vsi vector<set<int>>
#define ss second
#define ff first
#define printvi(arr) for (int x0 : arr) cout << x0 << ' '; cout << '\n';
#define printvll(arr) for (ll x0 : arr) cout << x0 << ' '; cout << '\n';
#define printpair(pair0) cout << pair0.F << ' ' << pair0.S << '\n';
#define printvp(arr) for (auto pair0 : arr) printpair(pair0);
#define initArray(arr, N0, X0) memset(arr, X0, N0 * sizeof(int))
void init() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void solve() {
int n;
cin >> n;
int ans = 0;
vi a(n);
forn(i, n){
cin >> a[i];
a[i]--;
}
forn(i, n){
int j = a[i];
if (j > i && a[j] == i) ans++;
}
cout << ans << '\n';
}
bool multitest = false;
int main() {
init();
int t = 1;
if (multitest) cin >> t;
forn(i, t) solve();
}
| 0
| 43,397,731
|
#include<bits/stdc++.h>
using namespace std;
string seven(vector<int> A){
string s="";
for(int bit=0;bit<(1<<3);++bit){
bitset<3> tmp(bit);
int sum=A.at(0);
s=to_string(A.at(0));
for(int i=0;i<3;++i){
if(tmp.test(i)){
sum+=A.at(i+1);
s+="+";
}
else{
sum-=A.at(i+1);
s+="-";
}
s+=to_string(A.at(i+1));
}
if(sum==7){
s+="=7";
break;
}
}
return s;
}
int main(){
int N;
cin >> N;
vector<int> A(4);
for(int i=3;i>=0;i--){
A.at(i)=N%10;
N/=10;
}
cout << seven(A) << endl;
}
|
#include <iostream>
#include <string>
using namespace std;
int func(char w)
{
char n = '0';
for(int i = 2; i <= 10; i++){
if(w == (char)(n+i)){
return i;
}
}
return 1;
}
int main()
{
int n, s, t, v;
string s1, s2;
char w = '0';
cin >> n;
while(n--){
cin >> s1 >> s2;
s = t = 0;
for(int i = 0; i < s1.size(); i++){
v = func(s1[i]);
if(v > 1){
i++;
}
if(s1[i] == 'm'){
s += v*1000;
} else if(s1[i] == 'c'){
s += v*100;
} else if(s1[i] == 'x'){
s += v*10;
} else if(s1[i] == 'i'){
s += v;
}
}
for(int i = 0; i < s2.size(); i++){
v = func(s2[i]);
if(v > 1){
i++;
}
if(s2[i] == 'm'){
t += v*1000;
} else if(s2[i] == 'c'){
t += v*100;
} else if(s2[i] == 'x'){
t += v*10;
} else if(s2[i] == 'i'){
t += v;
}
}
s += t;
s1 = "";
v = s/1000;
if(v > 0){;
if(v > 1){
s1 += (char)(w+v);
}
s1 += 'm';
s -= v*1000;
}
v = s/100;
if(v > 0){
if(v > 1){
s1 += (char)(w+v);
}
s1 += 'c';
s -= v*100;
}
v = s/10;
if(v > 0){
if(v > 1){
s1 += (char)(w+v);
}
s1 += 'x';
s -= v*10;
}
if(s > 0){
if(s > 1){
s1 += (char)(w+s);
}
s1 += 'i';
}
cout << s1 << endl;
}
return 0;
}
| 0
| 91,713,169
|
#include <bits/stdc++.h>
#define rep(X,N) for(ll X = 0LL; X < (N); X++)
#define PI (acos(-1.0))
#define MODN 1000000007
#define MODN2 998244353
#define ALL(V) (V).begin(),(V).end()
#define INT_MAX_HALF (INT_MAX / 2)
#define EPS (1e-10)
using namespace std;
typedef long long ll;
int main(){
string o,e;
cin >> o;
cin >> e;
int osize = o.size();
int esize = e.size();
rep(i, esize){
cout << o[i] << e[i];
}
if(osize > esize) cout << o[osize - 1];
cout << endl;
return 0;
}
|
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define resort(v) sort((v).rbegin(), (v).rend())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
using ll = long long;
using P = pair<int, int>;
int dx[] = {1,0,-1,0};
int dy[] = {0,1,0,-1};
constexpr ll mod = 1e9+7;
constexpr ll inf = INT32_MAX/2;
constexpr ll INF = LLONG_MAX/2;
constexpr long double eps = DBL_EPSILON;
constexpr long double pi = 3.141592653589793238462643383279;
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll fact(int i) {
if (i == 0) return 1;
return (fact(i - 1)) * i % mod;
}
ll gcd(ll a, ll b) {
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b ;
}
int keta(ll n) {
if(n == 0) return 1;
int count = 0;
while(n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) {
ll sum = 0;
while(n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
signed main() {
int x,y,a,b,c;cin >> x >> y >> a >> b >> c;
vector<P> v;
rep(i, a) {
int k;cin >> k;
v.pb({k,0});
}
rep(i, b) {
int k;cin >> k;
v.pb({k,1});
}
rep(i, c) {
int k;cin >> k;
v.pb({k,2});
}
resort(v);
int count = 0;
int sum = 0;
int i = 0;
while(x+y-count>0) {
if(v[i].second==0) {
if(x) {
sum+=v[i].first;
x--;
}
}
else if(v[i].second==1) {
if(y) {
sum+=v[i].first;
y--;
}
}
else {
sum+=v[i].first;
count++;
}
i++;
}
cout << sum << endl;
return 0;
}
| 0
| 13,388,600
|
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <string>
#include <cstring>
#include <ctime>
#include <climits>
#include <limits>
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(); }
template<class T> inline T sqr(T x) { return x * x; }
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long ll;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define EXISTch(s,c) ((((s).find_first_of(c)) != std::string::npos)? 1 : 0)
#define SORT(c) sort((c).begin(),(c).end())
#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = (int)1000000007;
const ll MOD = (ll)1000000007;
const ll INF2 = (ll)100000000000000000;
int main() {
string s;
cin>>s;
for(int i=0;i<s.size()-1;i++){
if(s[i]==s[i+1]){
cout<<i+1<<" "<<i+2<<endl;
return 0;
}
}
for(int i=0;i<s.size()-2;i++){
if(s[i]==s[i+2]){
cout<<i+1<<" "<<i+3<<endl;
return 0;
}
}
cout<<"-1 -1"<<endl;
}
|
#include <iostream>
#include <cmath>
using namespace std;
int main(void) {
int N=999999;
int p[N] , s[N];
p[0]=0 , s[0]=0;
for (int i=1; i<N; i++){
p[i] = 1;
s[i] = 0;
}
for (int i=1; i<N; i++){
if (p[i]==1){
int n=i+1 , m=2*n;
while (m<=N){
p[m-1] = 0;
m += n;
}
}
}
for (int i=1; i<N; i++){
s[i] = s[i-1]+p[i];
}
int n;
while (1){
cin >> n;
if (cin.eof())
break;
cout << s[n-1] << endl;
}
return 0;
}
| 0
| 74,023,152
|
#include "bits/stdc++.h"
using namespace std;
void Main() {
long long N;
cin >> N;
if (N == 1) {
cout << 1 << endl;
return;
}
vector<long long> L(N + 1, 0LL);
L[0] = 2;
L[1] = 1;
for (long long i = 2; i < N + 1; ++i) {
L[i] = L[i - 1] + L[i - 2];
}
cout << L[N] << endl;
}
int main() {
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int INF = 1000000000;
#define REP(i,s,n) for(int i=(int)(s);i<(int)(n);i++)
#define rep(i,n) REP(i, 0, n)
int prime[1000000];
bool is_prime[1000001];
int main(){
int n;
while(cin >> n){
int p = 0;
rep(i, n + 1) is_prime[i] = true;
is_prime[0] = is_prime[1] = false;
REP(i, 2, n + 1){
if(is_prime[i]){
prime[p++] = i;
for(int j = i * 2; j <= n; j += i)
is_prime[j] = false;
}
}
cout << p <<endl;
}
return 0;
}
| 0
| 51,374,312
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for(int i=0; i<N; i++)
typedef long long ll;
#define dump(x) cerr<<#x<<"="<<x<<endl
using P = pair<int, int>;
int main() {
int n, m; cin >> n >> m;
priority_queue<P, vector<P>, greater<P>> q;
priority_queue<int> p;
rep(i, n){
int a, b; cin >> a >> b;
q.push(make_pair(a, b));
}
ll ans = 0;
for(int i=1; i<=m; i++){
while(q.top().first<=i && !q.empty()){
p.push(q.top().second);
q.pop();
if(q.empty()){
break;
}
}
if(!p.empty()) {
ans += p.top();
p.pop();
}
dump(ans);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1000000007;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
int main(){
int N;
cin >> N;
vector<int> C(N), S(N), F(N);
for(int i = 1; i < N; i++){
cin >> C.at(i) >> S.at(i) >> F.at(i);
}
for(int i = 1; i <= N; i++){
int time = 0;
for(int j = i; j < N; j++){
if(time <= S.at(j)) time = S.at(j);
else {
int tmp = ( time - S.at(j) + F.at(j) - 1) / F.at(j);
time = S.at(j) + tmp * F.at(j);
}
time += C.at(j);
}
cout << time << endl;
}
}
| 0
| 52,618,013
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define REP(i,n) for(ll i=0; i<(ll)(n); ++i)
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
using Graph = vector<vector<int>>;
using Edge = map<pair<int,int>,int>;
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
std::fill( (T*)array, (T*)(array+N), val );
}
ll gcd(ll a,ll b){
if (a%b == 0) return(b);
else return(gcd(b, a%b));
}
ll lcm(ll a, ll b){
return a*b/gcd(a, b);
}
int main()
{
cout << fixed << setprecision(15);
ll N;
cin >> N;
vector<ll> L(87);
;
L[1] = 1;
REP(i, N+1){
if(i == 0){
L[0] = 2;
continue;
}
if(i == 1){
L[1] = 1;
continue;
}
L[i] = L[i-1] + L[i-2];
}
cout << L[N] << endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <map>
#include <vector>
#include <stack>
#include <queue>
#include <tuple>
#include <cassert>
#include <functional>
#include <set>
#include <deque>
#include <list>
using namespace std;
typedef long long ll;
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
#define LNF __LONG_LONG_MAX__
const ll MOD = 1000000007;
const int MAX = 200000;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
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;
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
long long gcd(long long x, long long y){
if(y==0) return x;
else return gcd(y,x%y);
}
long long lcm(long long x, long long y){
return x / gcd(x, y) * y;
}
long long com[200005];
void combination(long long n,long long k){
com[0] = 1;
for(int i=1;i<=k;i++){
com[i] = (com[i-1]*(n-i+1)%MOD)*modinv(i,MOD)%MOD;
}
}
int main(){
ll X,A,B; cin >> X >> A >> B;
if(A>=B){
cout << "delicious" << endl;
}else if(B-A<=X){
cout << "safe" << endl;
}else{
cout << "dangerous" << endl;
}
return 0;
}
| 0
| 11,745,259
|
#include<bits/stdc++.h>
#define MOD 1000000007
#define mp make_pair
#define ll long long
#define pb push_back
#define faster ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define debug cout<<"Debugging.."<<endl
using namespace std;
int main()
{
faster;
ll int tc=1;
while(tc--)
{
ll int n,k;
cin>>n>>k;
vector<ll int> v;
ll int x;
for(ll int i=0;i<n;i++)
{
cin>>x;
v.push_back(x);
}
sort(v.begin(),v.end());
int i=0,sum=0;
while(k--)
{
sum+=v[i++];
}
cout<<sum<<endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> P;
typedef pair<ll, ll> Pll;
#define debug(var) do{std::cout << #var << " : ";view(var);}while(0)
template<typename T> void view(T e){std::cout << e << std::endl;}
template<typename T> void view(const std::vector<T>& v){for(const auto& e : v){ std::cout << e << " "; } std::cout << std::endl;}
template<typename T> void view(const std::vector<std::vector<T> >& vv){ for(const auto& v : vv){ view(v); } }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const int MOD = 1000000007;
const int INF = 1e9;
const int mod = 1000000007;
const int inf = 1e9;
#define PI acos(-1);
int dx[4] = {1,-1,0,0};
int dy[4] = {0,0,1,-1};
int ddx[8] = {1,1,1,-1,-1,-1,0,0};
int ddy[8] = {0,1,-1,0,1,-1,1,-1};
int main(){
int n;
cin >> n;
vector<int> a(26, 0);
string s;
cin >> s;
for(int i = 0; i < s.size(); i++) {
a[s[i]-'a']++;
}
for(int i = 0; i < n-1; i++) {
vector<int> b(26, 0);
string t;
cin >> t;
for(int j = 0; j < t.size(); j++) {
b[t[j]-'a']++;
}
for(int j = 0; j < 26; j++) {
chmin(a[j], b[j]);
}
}
for(int i = 0; i < 26; i++) {
for(int j = 0; j < a[i]; j++) {
cout << (char)('a'+i);
}
}
cout << endl;
}
| 0
| 25,765,791
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1LL<<60;
const long long int Mod = 1000000007;
using ll = long long int; using ci = const int;
using vi = vector<int>; using Vi = vector<long long int>;
using P = pair<int, int>; using PLL = pair<ll, ll>;
using matrix = vector<vector<ll>>;
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define all(x) (x).begin(),(x).end()
#define rp(i,N) for(ll i = 0; i < (ll)N; i++)
#define repi(i,a,b) for(ll i = ll(a); i < ll(b); ++i)
template<class T>bool chmax(T &former, const T &b) { if (former<b) { former=b; return true; } return false; }
template<class T>bool chmin(T &former, const T &b) { if (b<former) { former=b; return true; } return false; }
template<class T>T sqar(T x){ return x*x; }
#define Sort(v) std::sort(v.begin(), v.end(), std::greater<decltype(v[0])>())
#define p_queue(v) priority_queue<v, vector<v>, greater<v> >
template<class T> inline void princ(T x){cout<<x<<" ";};
template<class T> inline void print(T x){cout<<x<<"\n";};
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
template<class T> inline void YES(T condition){ if(condition) cout << "YES" << endl; else cout << "NO" << endl; }
int main(){
int n,m,x,y;
cin >> n >> m >> x >> y;
int maxx=x;
int miny=y;
rp(i,n){
int a;
cin >> a;
chmax(maxx,a);
}
rp(i,m){
int b;
cin >> b;
chmin(miny,b);
}
if(maxx<y&&miny>x&&maxx<miny){
print("No War");
}
else print("War");
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
int main() {
int n,m; cin >> n >> m;
vector<int> a(m);
rep(i, m) {
cin >> a[i];
}
sort(a.begin(), a.end(), greater<int>() );
vector<int> match_num{2 , 5 , 5 , 4 , 5 , 6 , 3 , 7 , 6};
vector<int> dp(11000, -INT_MAX);
for(int i=1; i <= n; i++) {
int tmp = -INT_MAX;
rep(j, m) {
if(i-match_num[a[j]-1] < 0) continue;
if(i-match_num[a[j]-1] == 0) {
tmp = 1;
} else if(dp[i-match_num[a[j]-1]] > 0) {
tmp = max(tmp, dp[i-match_num[a[j]-1]]+1);
}
}
dp[i] = tmp;
}
string ans = "";
int remain = dp[n];
int match = n;
dp[0] = 0;
while(match > 0) {
rep(i, m) {
if(remain-1 == dp[match-match_num[a[i]-1]] && match-match_num[a[i]-1] >= 0) {
match -= match_num[a[i]-1];
remain -= 1;
ans += to_string(a[i]);
break;
}
}
}
cout << ans << endl;
return 0;
}
| 0
| 19,349,317
|
#include <iostream>
using namespace std;
using ll = long long;
#define mod 2019
#define INF 2<<30
int main(void){
ll l,r;
cin >> l >> r;
if(r+1-l>=mod)
{
cout<<0;
return 0;
}
int m=mod;
for(int i=l;i<r;i++)for(int j=l+1;j<=r;j++)
{
m=min(((i%mod)*(j%mod))%mod,m);
}
cout<<m<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,m;
cin>>n>>m;
vector<vector<int>> start(n,vector<int>(2));
for(int i=0;i<n;i++){
cin>>start.at(i).at(0)>>start.at(i).at(1);
}
vector<vector<int>> goal(m,vector<int>(2));
for(int i=0;i<m;i++){
cin>>goal.at(i).at(0)>>goal.at(i).at(1);
}
for(int i=0;i<n;i++){
int mindis=1e+9;
int next=-1;
for(int j=0;j<m;j++){
int dis=abs(start.at(i).at(0)-goal.at(j).at(0))+abs(start.at(i).at(1)-goal.at(j).at(1));
if(dis<mindis){
mindis=dis;
next=j+1;
}
}
cout<<next<<endl;
}
}
| 0
| 41,927,405
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
ll GetDigit(ll num){ return log10(num)+1; }
int main()
{
ll r,d;
vector<ll> x(11);
cin >> r >> d >> x[0];
for (int i = 0; i <= 10; i++)
{
x[i+1] = r*x[i] - d;
}
for (int i = 1; i <= 10; i++)
{
cout << x[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
LL read(){
LL x=0,f=1;
char ch=getchar();
while (!isdigit(ch)&&ch!='-')
ch=getchar();
if (ch=='-')
f=-1,ch=getchar();
while (isdigit(ch))
x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
return x*f;
}
const int N=100005;
int n,A[N],in[N];
vector <int> e[N];
vector <LL> v[N];
LL solve(int x,int pre){
vector <LL> &a=v[x];
for (auto y : e[x])
if (y!=pre)
a.push_back(solve(y,x));
if (a.empty())
return A[x];
sort(a.begin(),a.end());
if (!~*a.begin())
return -1;
reverse(a.begin(),a.end());
LL tot=0;
for (auto y : a)
tot+=y;
LL mx=min((LL)A[x],min(tot/2,tot-*a.begin()));
LL Need=tot-A[x];
return Need>mx||Need<0?-1:(A[x]-Need);
}
int main(){
n=read();
for (int i=1;i<=n;i++)
A[i]=read();
for (int i=1;i<=n;i++)
e[i].clear();
for (int i=1;i<n;i++){
int a=read(),b=read();
e[a].push_back(b);
e[b].push_back(a);
in[a]++,in[b]++;
}
if (n==2)
return puts(A[1]==A[2]?"YES":"NO"),0;
int rt=0;
for (int i=1;!rt&&i<=n;i++)
if (in[i]>1)
rt=i;
puts(solve(rt,0)==0?"YES":"NO");
return 0;
}
| 0
| 87,098,988
|
#include <iostream>
using namespace std;
const int maxn=1e6 + 10;
int p[maxn],inp[maxn],f[maxn],top;
void init(){
for(int i=2;i<maxn;i++){
if(!inp[i]){
p[top++]=i;
}
for(int j=0;j<top && i*p[j]<maxn;j++){
inp[i*p[j]]=1;
if(!(i%p[j]))
break;
}
f[i]=f[i-1]+1-inp[i];
}
}
int main(){
init();
int n;
while(cin>>n){
cout<<f[n]<<endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
const int M = 1046527;
const int L = 14;
string H[M];
int getChar(char ch) {
if (ch == 'A') {
return 1;
}
else if (ch == 'C') {
return 2;
}
else if (ch == 'G') {
return 3;
}
else if (ch == 'T') {
return 4;
}
return 0;
}
long long getKey(string str) {
long long sum = 0, p = 1, i;
for (int i = 0; i < str.size(); i++) {
sum += p * (getChar(str[i]));
p *= 5;
}
return sum;
}
int h1(int key) {
return key % M;
}
int h2(int key) {
return 1 + (key % (M - 1));
}
int find(string str) {
long long key, i, h;
key = getKey(str);
for (int i = 0;; i++) {
h = (h1(key) + i * h2(key)) % M;
if (str == H[h]) {
return 1;
}
else if (H[h].size() == 0) {
return 0;
}
}
return 0;
}
int insert(string str) {
long long key, i, h;
key = getKey(str);
for (i = 0;; i++) {
h = (h1(key) + i * h2(key)) % M;
if (str == H[h]) {
return 1;
}
else if (H[h].size() == 0) {
H[h] = str;
return 0;
}
}
return 0;
}
int main() {
int i, n, h;
string str, com;
for (int i = 0; i < M; i++) {
H[i][0] = '\0';
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> com >> str;
if (com[0] == 'i') {
insert(str);
}
else {
if (find(str)) {
cout << "yes" << endl;
}
else {
cout << "no" << endl;
}
}
}
}
| 0
| 59,349,715
|
#include <iostream>
using namespace std;
int main()
{
char s[201];
char p[101];
cin.getline(s,101);
cin.getline(p,101);
int ns=0,np=0;
for(int i=0;s[i];i++)
ns++;
for(int i=0;p[i];i++)
np++;
for(int i=ns;i<2*ns;i++)
s[i]=s[i-ns];
s[2*ns]='\0';
int i,j;
for(i=0;i<2*ns-np;i++)
{
for(j=0;j<np;j++)
if(s[i+j]!=p[j]) break;
if(j==np)
{
cout<<"Yes"<<endl;
break;
}
}
if(i==2*ns-np)
cout<<"No"<<endl;
}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
const int N=100010;
int tt;
int head[N],a[N],to[N*2],nxt[N*2],in[N];
inline int gi() {
int x=0,o=1;
char ch=getchar();
while(ch!='-'&&(ch<'0'||ch>'9')) ch=getchar();
if(ch=='-') ch=getchar(),o=-1;
while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
return x*o;
}
inline void dfs(int x,int fa) {
if(in[x]==1) return;
int Mx=0;
long long sum=0;
for(int i=head[x];i;i=nxt[i]) {
int y=to[i];
if(y!=fa) {
dfs(y,x),sum+=a[y];
Mx=max(Mx,a[y]);
}
}
if(sum<a[x]||sum>a[x]*2||Mx>a[x])
puts("NO"),exit(0);
a[x]-=sum-a[x];
}
int main() {
int n,rt=1;
cin>>n;
if(n==2) return puts(gi()==gi()?"YES":"NO"),0;
for(int i=1;i<=n;i++) a[i]=gi();
for(int i=1;i<n;i++) {
int x=gi(),y=gi();
++in[x],++in[y];
to[++tt]=y,nxt[tt]=head[x],head[x]=tt;
to[++tt]=x,nxt[tt]=head[y],head[y]=tt;
}
for(int i=1;i<=n;i++) if(in[i]>1) rt=i;
dfs(rt,0);
puts(a[rt]?"NO":"YES");
return 0;
}
| 0
| 50,146,784
|
#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <utility>
#include <algorithm>
#include <queue>
#include <deque>
#include <stack>
#include <cmath>
#include <functional>
#include <cassert>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
#define PI 3.14159265358979323846264338327950L
int main()
{
cin.tie(0);
string S, T;
cin >> S >> T;
int currentMin = 100000;
for (int i = 0; i < S.size() - T.size() + 1; i++)
{
int cnt = 0;
for (int j = 0; j < T.size(); j++)
{
if(S[i+j] != T[j])
cnt++;
}
currentMin = min(cnt, currentMin);
}
cout<<currentMin <<endl;
return 0;
}
|
#include <iostream>
using namespace std;
#include <algorithm>
#include <vector>
#include <cmath>
#define MOD1 1000000007
#define MOD2 998244353
#define LIMIT1 200002
#define LIMIT2 500002
typedef long long ll;
typedef long double ld;
typedef const void cv;
#define rep(i,n) for((i)=0;(i)<(n);(i)++)
#define per(i,n) for((i)=(n)-1;(i)>=0;(i)--)
#define max(a,b) ((a)>(b) ? (a) : (b))
#define min(a,b) ((a)<(b) ? (a) : (b))
#define zt(a,b) (max((a),(b))-min((a),(b)))
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll nPr(int n,int r){ll i,result=1;rep(i,r){result*=(ll)(n-i);}return result;}
ll nCr(int n,int r){ll i,result=1;if(n<r) return 0;rep(i,min(r,n-r)){result*=(ll)(n-i);result/=(ll)(i+1);}return result;}
#define nHr(n,r) nCr((int)((n)+(r)+1),(int)(r))
#define sankaku(x) (((x)*((x)+1))/2)
int dx[8]={1,0,-1,0,1,-1,-1,1},dy[8]={0,1,0,-1,1,1,-1,-1};
#define downint greater<int>()
#define downchar greater<char>()
#define downstring greater<string>()
void tmpInit(int *c,ll m) {ll i;rep(i,m) c[i]=i;}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1){
res *= a; if(mod>=1) res %= mod;
}
a *= a; if(mod>=1) a %= mod;
n >>= 1;
}
return res;
}
void initialize(){
}
int main(void){
initialize();
ll n,m,i,j,k,result=0,tmp;
ll a[LIMIT2]={0},b[100]={0};
cin >> n;
rep(i,n) cin >> a[i];
rep(i,n){
tmp=a[i];
j=0;
while(tmp>0){
b[j] += (tmp%2);
tmp /= 2;
j++;
}
}
rep(i,61){
tmp = b[i];
tmp = (tmp*(n-b[i]))%MOD1;
tmp = (tmp*modpow(2,i,MOD1))%MOD1;
result += tmp;
result %= MOD1;
}
cout << result << endl;
return 0;
}
| 0
| 65,790,293
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define repeat(i, n) for (int i = 0; (i) < (n); ++(i))
#define repeat_from(i, m, n) for (int i = (m); (i) < (n); ++(i))
using namespace std;
template <class T>
void setmax(T &a, T const &b) {
if (a < b) a = b;
}
template <class T>
void setmin(T &a, T const &b) {
if (a > b) a = b;
}
template <typename T, typename X>
auto vectors(T a, X x) { return vector<T>(x, a); }
template <typename T, typename X, typename Y, typename... Zs>
auto vectors(T a, X x, Y y, Zs... zs) {
auto cont = vectors(a, y, zs...);
return vector<decltype(cont)>(x, cont);
}
int main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
repeat(i, N) cin >> A[i];
long long B = 0;
map<int, int> ModM;
ModM[0]++;
repeat(i, N) {
B = (A[i] + B) % M;
ModM[B]++;
}
long long res = 0;
for (auto P : ModM) {
long long num = P.second;
res += num * (num - 1) / 2;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, n) for (int i = n - 1; i >= a; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int h, w;
cin >> h >> w;
vector<string> v(h);
rep(i, 0, h) cin >> v[i];
vector<vector<int>> acch(h, vector<int>(w, 0));
vector<vector<int>> accw = acch;
rep(i, 0, h) {
int now = 0;
rep(j, 0, w) {
if (v[i][j] == '#') {
now = 0;
} else {
now++;
accw[i][j] = now;
}
}
now = 0;
repr(j, 0, w) {
if (v[i][j] == '#') {
now = 0;
} else {
now++;
accw[i][j] += now - 1;
}
}
}
rep(i, 0, w) {
int now = 0;
rep(j, 0, h) {
if (v[j][i] == '#') {
now = 0;
} else {
now++;
acch[j][i] = now;
}
}
now = 0;
repr(j, 0, h) {
if (v[j][i] == '#') {
now = 0;
} else {
now++;
acch[j][i] += now - 1;
}
}
}
int ans = 0;
rep(i, 0, h) {
rep(j, 0, w) { chmax(ans, acch[i][j] + accw[i][j]); }
}
cout << ans - 1 << endl;
}
| 0
| 30,881,881
|
#include <iostream>
#include <string>
char c[10][5] = {
{' ', ' ', ' ', ' ', ' '},
{'.', ',', '!', '?', ' '},
{'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 l[10] = {0, 5, 3, 3, 3, 3, 3, 4, 3, 4};
int main() {
int n;
std::string s;
std::cin >> n;
for (int i = 0; i < n; i++) {
std::cin >> s;
int m = s.length();
int x = 0;
int y = 0;
for (int j = 0; j < m; j++) {
int a = int(s[j] - '0');
if (a == 0) {
if (x != 0) {
std::cout << c[x][y];
x = 0;
}
} else {
if (a == x) {
y = (y + 1) % l[x];
} else {
x = a;
y = 0;
}
}
}
std::cout << std::endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define FAST_IO \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long int
#define mp make_pair
#define pb push_back
#define p pair
#define vt vector
#define F first
#define S second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(), (x).end()
#define sz(x) (ll)(x).size()
#define endl "\n"
#define db1(x) cout << #x << " = " << x << '\n';
#define db2(v) \
for (auto &x : v) \
cout << x << " ";
#define umap unordered_map
#define uset unordered_set
#define MOD 1000000007
using namespace std;
int main()
{
FAST_IO;
string s, t;
cin >> s >> t;
int ans = sz(t);
for (int i = 0; i <= sz(s) - sz(t); i++)
{
int dif = 0;
for (int j = 0; j < sz(t); j++)
{
if (t[j] != s[j + i])
{
dif++;
}
}
ans = min(ans, dif);
}
cout << ans;
return 0;
}
| 0
| 26,775,003
|
#include<iostream>
#include<string>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
const ll INF = (ll)1000000007 * 1000000007;
const double PI = 3.14159265358979;
const double E = 2.718281828459045;
const double root2 = sqrt(2);
typedef pair<int, int> P;
typedef unsigned int ui;
int main() {
int n;
cin >> n;
string s; int l;
for (int i = 0; i < n; i++) {
int a, b,memo;
a = 0; b = 0;
cin >> s;
l = s.length();
memo = 1;
for (int j = 0; j < l; j++) {
if (0 <= s[j] - '0'&&s[j] - '0' <= 9) {
memo = s[j] - '0';
}
else if (s[j] == 'm') {
a += memo * 1000; memo = 1;
}
else if (s[j] == 'c') {
a += memo * 100; memo = 1;
}
else if (s[j] == 'x') {
a += memo * 10; memo = 1;
}
else if(s[j]=='i'){
a += memo;
}
}
cin >> s;
l = s.length();
memo = 1;
for (int j = 0; j < l; j++) {
if (0 <= s[j] - '0'&&s[j] - '0' <= 9) {
memo = s[j] - '0';
}
else if (s[j] == 'm') {
b += memo * 1000; memo = 1;
}
else if (s[j] == 'c') {
b += memo * 100; memo = 1;
}
else if (s[j] == 'x') {
b += memo * 10; memo = 1;
}
else if (s[j] == 'i') {
b += memo;
}
}
int x = a + b;
if (x / 1000 >= 2)cout << x / 1000;
if (x / 1000 >= 1)cout << "m";
x %= 1000;
if (x / 100 >= 2)cout << x / 100;
if (x / 100 >= 1)cout << "c";
x %= 100;
if (x / 10 >= 2)cout << x / 10;
if (x / 10 >= 1)cout << "x";
x %= 10;
if (x >= 2)cout << x;
if (x >= 1)cout << "i";
cout << endl;
}
return 0;
}
|
#include <stdio.h>
#define _USE_MATH_DEFINES
#include <math.h>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int q;
scanf("%d", &q);
for(int i = 0; i < q; i++){
long a,b;
scanf("%ld %ld", &a, &b);
if(a>b){
swap(a,b);
}
long n = a * b;
long s = a;
long t = b;
bool bSquare = false;
while(t - s >= 2){
long u = (s + t) / 2;
if(u * u > n){
t = u;
} else {
s = u;
}
}
if(s * s == n){
bSquare = true;
}
long nAns = 0;
if(!bSquare){
if(s * (s + 1) >= n){
nAns = 2 * (s - 1);
} else {
nAns = 2 * s - 1;
}
} else if(a == s){
nAns = 2 * (s - 1);
} else {
nAns = 2 * (s - 1) - 1;
}
printf("%ld\n",nAns);
}
return 0;
}
| 0
| 29,129,944
|
#include <stdio.h>
int main()
{
int hour_1;
int hour_2;
int min_1;
int min_2;
int k;
scanf("%d %d %d %d %d", &hour_1, &min_1, &hour_2, &min_2, &k);
int total_hour = hour_2 - hour_1;
int total_minute = min_2 - min_1;
int duration = (total_hour * 60) + total_minute - k;
printf("%d\n", duration);
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <numeric>
#include <cmath>
#include <stack>
#include <map>
#include <iomanip>
using namespace std;
int64_t min(int64_t a,int64_t b) {
if (a > b)
{
return b ;
}else
{
return a ;
}
}
const int MAX = 510000;
const int MOD = 1000000007;
int64_t fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main(){
int n,d,x ;
cin >> n >> d >> x ;
int a ;
int ans = n + x ;
for (int i = 0; i < n; i++)
{
cin >> a ;
ans += (d-1)/a ;
}
cout << ans << endl ;
}
| 0
| 49,014,456
|
#include <bits/stdc++.h>
using namespace std;
int a[1000005],n,t;
int main() {
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%d",&t), a[t]++;
int cnt = 0;
for(int i=1;i<=100000;i++) if(a[i]>1) cnt+=a[i]-1;
if(cnt&1) n-=cnt+1;
else n-=cnt;
cout<<n<<endl;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#define rep(i, n) for(int i = 0; i < (int)(n); ++i)
#define REP(i, n) for(int i = 1; i < (int)(n); ++i)
using namespace std;
struct LazySegmentTree {
private:
int length;
vector<long long> node, lazy;
public:
LazySegmentTree(int N) {
length = 1;
while (length < N) length *= 2;
node.resize(2 * length - 1, 0);
lazy.resize(2 * length - 1, 0);
}
void eval(int k, int l, int r) {
node[k] += lazy[k];
if (r - l > 1) {
lazy[2 * k + 1] += lazy[k] / 2;
lazy[2 * k + 2] += lazy[k] / 2;
}
lazy[k] = 0;
}
void add(int a, int b, long long x, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = length;
if (b <= l || r <= a) return;
if (a <= l && r <= b) {
lazy[k] += x * (r - l);
eval(k, l, r);
} else {
add(a, b, x, 2 * k + 1, l, (l + r) / 2);
add(a, b, x, 2 * k + 2, (l + r) / 2, r);
node[k] = node[2 * k + 1] + node[2 * k + 2];
}
}
long long getsum(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = length;
if (b <= l || r <= a) return 0;
eval(k, l, r);
if (a <= l && r <= b) return node[k];
long long vl = getsum(a, b, 2 * k + 1, l, (l + r) / 2);
long long vr = getsum(a, b, 2 * k + 2, (l + r) / 2, r);
return vl + vr;
}
};
int main() {
int N;
long long D, A;
cin >> N >> D >> A;
vector<pair<long long, long long>> S(N);
rep(i, N) cin >> S[i].first >> S[i].second;
S.push_back(pair<long long, long long>{1E15, 0});
sort(S.begin(), S.end());
LazySegmentTree LST(N);
rep(i, N) LST.add(i, i + 1, S[i].second);
long long ans = 0;
rep(i, N) {
long long x = LST.getsum(i, i + 1);
if (x <= 0) continue;
auto iter = upper_bound(S.begin(), S.end(), pair<long long, long long>{S[i].first + 2 * D, 1E15});
ans += (x - 1 + A) / A;
LST.add(i, (int)(iter - S.begin()), -(x - 1 + A) / A * A);
}
cout << ans << endl;
}
| 0
| 21,166,939
|
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define speed \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define pb push_back
#define mem1(a) memset(a, -1, sizeof(a))
#define mem0(a) memset(a, 0, sizeof(a))
#define endl "\n"
#define mod 1000000007
#define mod1 998244353
#define ff first
#define ss second
#define MAX 500005
#define N 10004
#define INF 1000000009
#define all(v) v.begin(), v.end()
#define sbit(a) __builtin_popcount(a)
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef pair<ll, ll> pll;
typedef pair<pll, ll> ppl;
typedef map<ll, ll> mpll;
typedef map<vector<ll>, ll> mpvl;
ll power(ll x, ll y, ll p)
{
ll res = 1;
x = x % p;
if (x == 0)
return 0;
while (y > 0)
{
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void solve()
{
ll n, x, m;
cin >> n >> x >> m;
ll ans = x;
ll t = x * x;
ll c = 0;
map<ll, ll> mp;
n--;
ll s[m + 1];
mem0(s);
ll tans = 0;
ll tmp;
for (ll i = 1; i <=m + 1; i++)
{
ll md = t % m;
if (!mp.count(md))
{
tans += md;
t = md * md;
}
else
{
c = i - mp[md];
tmp = mp[md];
break;
}
mp[md] = i;
s[i] = tans;
}
tmp--;
n -= tmp;
ll div = n / c;
ll md = n % c;
ans += (div * (s[c + tmp] - s[tmp]));
ans += s[tmp];
ans += s[tmp + md] - s[tmp];
cout << ans << endl;
}
int main()
{
speed;
ll kk;
kk = 1;
while (kk--)
{
solve();
}
return 0;
}
|
#include <algorithm>
#include <boost/optional.hpp>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define REP(i, n) for(int i = 0, i##_MACRO = (n); i < i##_MACRO; i++)
#define RANGE(i, a, b) for(int i = (a), i##_MACRO = (b); i < i##_MACRO; i++)
#define EACH(e, a) for(auto&& e : a)
#define ALL(a) std::begin(a), std::end(a)
#define RALL(a) std::rbegin(a), std::rend(a)
#define FILL(a, n) memset((a), n, sizeof(a))
#define FILLZ(a) FILL(a, 0)
#define INT(x) (static_cast<int>(x))
#define PRECISION(x) std::fixed << std::setprecision(x)
using namespace std;
using ll = long long;
using VI = std::vector<int>;
using VI2D = std::vector<vector<int>>;
using VLL = std::vector<long long>;
using VLL2D = std::vector<vector<long long>>;
constexpr int INF = 2e9;
constexpr double EPS = 1e-10;
constexpr double PI = acos(-1.0);
constexpr int dx[] = {-1, 0, 1, 0};
constexpr int dy[] = {0, -1, 0, 1};
template <typename T>
constexpr int sign(T x) {
return x < 0 ? -1 : x > 0 ? 1 : 0;
}
template <>
constexpr int sign(double x) {
return x < -EPS ? -1 : x > EPS ? 1 : 0;
}
template <typename T, typename U>
constexpr void chmax(T& m, U x) {
m = max(m, x);
}
template <typename T, typename U>
constexpr void chmin(T& m, U x) {
m = min(m, x);
}
template <typename T>
constexpr T square(T x) {
return x * x;
}
int main() {
int n;
string s;
cin >> n;
cin >> s;
int c = 0;
int a = 0;
REP(i, n) {
if(s[i] == '(') {
c++;
} else {
if(c == 0) {
a++;
} else {
c--;
}
}
}
cout << string(a, '(') << s << string(c, ')') << endl;
return 0;
}
| 0
| 26,714,227
|
#include <bits/stdc++.h>
using namespace std;
#define INF 1000000000
#define MOD 1000000007
#define PI 3.14159265
#define EPS 1e-9
#define Pi acos(-1.0)
typedef pair<int, int> ii;
typedef long long ll;
typedef vector<ll> vll;
typedef pair<ll,ll> pll;
#define forr(i,a,b) for(int i=(a); i<(b); i++)
#define clean(arr,val) memset(arr,val,sizeof(arr))
#define forn(i,n) forr(i,0,n)
#define PB push_back
typedef vector<int> vi;
typedef vector<ii> vii;
typedef vector<pll> vpll;
int a, b, c, d, temp;
int main(){
ios::sync_with_stdio(0);
cin >> a >> b >> c >> d;
temp = min(b,d) - max(a,c);
if(temp < 0){
cout << "0\n";
}else{
cout << temp << "\n";
}
return 0;
}
|
#include<bits/stdc++.h>
#include<unordered_map>
using namespace std;
#define REP(i,m,n) for(int i=(m);i<(n);i++)
#define rep(i,n) REP(i,0,n)
#define pb push_back
#define mp make_pair
#define all(c) (c).begin(),(c).end()
#define rall(c) (c).rbegin(),(c).rend()
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const ll inf=1e9+7;
const ll mod=998244353;
int main(){
ll n;cin>>n;
vector<ll>a(n+1),b(n+1),c(n+1),p(n+1);
c[0]=1;
REP(i,1,n+1){
c[i]=c[i-1]+1;
}
rep(i,n){
ll d;cin>>d;
p[d]=i+1;
}
a[1]=1;
b[1]=p[1]-a[1];
ll mi=b[1];
REP(i,2,n+1){
if(p[i]<p[i-1]){
a[i]=a[i-1]+1;
b[i]=p[i]-a[i];
}else{
b[i]=b[i-1]-1;
a[i]=p[i]-b[i];
}
mi=min(b[i],mi);
}
REP(i,1,n+1)b[i]+=abs(mi)+1;
REP(i,1,n+1)cout<<a[i]<<' ';
cout<<endl;
REP(i,1,n+1)cout<<b[i]<<' ';
}
| 0
| 9,985,820
|
#include<cstdio>
int main(void){char x[1001];int c,i;scanf("%s",x);while(x[0]-'0'){for(i=0,c=0;x[i]!=0;++i){c+=x[i]-'0';}printf("%d\n",c);scanf("%s",x);}return(0);}
|
#include<bits/stdc++.h>
using namespace std;
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cout<<fixed; cout<<setprecision(12);
#define randomINT mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#define newl cout<<"\n"
#define DISP(as) for(auto it : as) cout<<it<<" ";newl;
#define all(x) (x).begin(),(x).end()
#define mset(x,val) memset(x,val,sizeof(x))
#define newl cout<<"\n"
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define dline cerr<<"
#define deb1(x) cerr<<#x<<" = "<<x<<'\n';
#define deb2(x,y) cerr<<'['<<#x<<','<<#y<<"] = "<<'['<<x<<','<<y<<']'<<'\n';
#define deb3(x,y,z) cerr<<'['<<#x<<','<<#y<<','<<#z<<"] = "<<'['<<x<<','<<y<<','<<z<<']'<<'\n';
#define N 1000000007
typedef long long ll;
typedef long double ld;
typedef vector<ll> vll;
typedef pair<ll , ll> pll;
typedef pair<ld, ld> pld;
typedef unordered_map<ll, ll> um;
typedef vector<pll> vpll;
const ll MAX5 = 1e+5 + 7;
const ll MAX7 = 1e+7 + 7;
const ll MAXN = MAX7;
const ll INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
const ll MOD = 1e9 + 7;
ll T = 1;
ll n, x, k, p, m, y;
string s, t;
ld w;
ll a,b;
void MAIN() {
cin >> s;
string t1 = s.substr(0,3);
string t2 = s.substr(1,3);
for(ll i=0;i<=9;i++) {
string I ;
I += ('0' + i) ;I+= ('0' + i); I += ('0' + i);
if(t1 == I || t2 == I) {
cout<<"Yes\n";
return;
}
}
cout<<"No\n";
}
int main() {
fastio; randomINT;
while (T--) {
MAIN();
}
return 0;
}
| 0
| 63,722,631
|
#include<bits/stdc++.h>
using namespace std;
#define l long int
#define ll long long int
vector<int>adj[1000001];
int vis[1000001];
int n=2005;
int dp[2005];
int fact[1000001];
#define mod 1000000007
ll sequence_sum(int a)
{
if(a==0)
return 1ll;
else if(a==1 || a==2)
return 0ll;
else if(a==3 || a==4 || a==5)
return 1ll;
else if(dp[a]!=-1)
return dp[a];
else
{
ll total=0;
for(int i=3;i<=a;i++)
{
if((a-i)>=0)
{
total=(total+sequence_sum(a-i))%mod;
}
}
return dp[a]=total;
}
}
int main()
{
int s;
cin>>s;
for(int i=0;i<=n;i++)
{
dp[i]=-1;
}
dp[0]=0;
cout<<sequence_sum(s)<<"\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, R;
cin >> N >> M >> R;
vector<int> r(R);
for (int i = 0; i < R; i++) {
cin >> r.at(i);
r.at(i)--;
}
vector<vector<int>> G(N, vector<int>(N, 1e9));
for (int a, b, c; cin >> a >> b >> c;) {
G.at(--a).at(--b) = c;
G.at(b).at(a) = c;
}
for (int i = 0; i < N; i++) {
G.at(i).at(i) = 0;
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
for (int k = 0; k < N; k++) {
G.at(j).at(k) = min(G.at(j).at(k), G.at(j).at(i) + G.at(i).at(k));
}
}
}
int ans = 1e9;
sort(r.begin(), r.end());
do {
int tmp = 0;
for (int i = 0; i + 1 < R; i++) {
tmp += G.at(r.at(i)).at(r.at(i + 1));
}
ans = min(ans, tmp);
} while (next_permutation(r.begin(), r.end()));
cout << ans << "\n";
}
| 0
| 93,847,561
|
#include <bits/stdc++.h>
#define for0(i,n) for (int i=0; i<n; i++)
#define iter(c) for(auto it=c.begin(); it!=c.end(); it++)
#define iter2(c) for(auto it2=c.begin(); it2!=c.end(); it2++)
#define pb push_back
#define ms(a,z) memset(a,z,sizeof(a));
#define mp make_pair
#define X first
#define Y second
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
#define all(a) a.begin(),a.end()
#define sz(x) (int)(x).size()
#define pmod(x,m) (((x)%(m)+m)%m)
#ifdef int
#define read(x) scanf("%lld",&x);
#else
#define read(x) scanf("%d",&x);
#endif
#ifdef DEBUG
#define nl cout<<"\n";
#define pr(x) cout<<(x)<<" ";
#define prl(x) cout<<#x " = "<<x<<endl;
#define prp(x) cout<<"("<<(x).first<<" "<<(x).second<<") ";
#define printv(v) {for(int _=0; _<sz(v); _++) cout<<v[_]<<" "; cout<<"\n";}
#define printa(a,s) {for (int _=0; _<s; _++) cout<<a[_]<<" "; cout<<"\n";}
#define print2D(a,m,n) {for (int _=0; _<m; _++) {for (int __=0; __<n; __++) cout<<a[_][__]<<" "; cout<<"\n";} cout<<"\n";}
#define debug cout<<"ok at line "<<__LINE__<<endl;
#else
#define nl
#define pr(x)
#define prl(x)
#define prp(x)
#define printv(v)
#define printa(a,s)
#define print2D(a,m,n)
#define debug
#endif
using namespace std;
typedef long long ll;
const int INF = 999999999;
const long long INFL = 9223372036854775807LL;
const double EPSILON = 0.00000001;
const long long MOD = 1000000007;
int mask[200005];
int best_val[(1<<26)+10];
int dp[200005];
int get_val(int i, int goal_mask)
{
int req_mask = goal_mask ^ mask[i-1];
if (best_val[req_mask] == INF)
return INF;
else
return best_val[req_mask]+1;
}
int32_t main()
{
#ifdef DEBUG
freopen("D.txt","r",stdin);
#endif
string s;
cin >> s;
int n = s.length();
for0(i,(1<<26))
best_val[i] = INF;
int cur_mask = 0;
mask[0] = 0;
for (int i=0; i<n; i++) {
cur_mask ^= 1<<(s[i]-'a');
mask[i+1] = cur_mask;
}
dp[n] = 1;
best_val[mask[n]] = 0;
for (int i=n-1; i>=1; i--) {
best_val[mask[i]] = min(best_val[mask[i]], dp[i+1]);
int ans = get_val(i,0);
for (int b=0; b<26; b++) {
int res = get_val(i,1<<b);
ans = min(ans,res);
}
ans = min(ans,dp[i+1]+1);
dp[i] = ans;
}
printa(dp,n+1)
cout<<dp[1]<<endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const ll INF = 1LL << 60;
const ll MOD = 1000000007;
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;
}
template <class C>
void print(const C &c, std::ostream &os = std::cout) {
std::copy(std::begin(c), std::end(c), std::ostream_iterator<typename C::value_type>(os, " "));
os << std::endl;
}
struct UnionFind {
vector<int> rank, parent, size;
UnionFind(int n) : rank(n + 1, 0), parent(n + 1), size(n + 1, 1) {
iota(parent.begin(), parent.end(), 0);
}
int root(int x) {
if (x != parent[x]) {
parent[x] = root(parent[x]);
}
return parent[x];
}
bool isSame(int x, int y) { return root(x) == root(y); }
bool unite(int x, int y) { return link(root(x), root(y)); }
bool link(int x, int y) {
if (x == y)
return false;
if (rank[x] > rank[y]) {
parent[y] = x;
size[x] += size[y];
} else {
parent[x] = y;
size[y] += size[x];
if (rank[x] == rank[y]) {
rank[y]++;
}
}
return true;
}
int getSize(int x) { return size[root(x)]; }
};
struct BipartileGraph {
vi colors;
vvi edges;
int n;
BipartileGraph(int n) : colors(n, -1), edges(n), n(n) {}
void addEdge(int f, int t) {
edges[f].emplace_back(t);
edges[t].emplace_back(f);
}
void clear() { colors.resize(n, -1); }
bool build(int s, int color = 0) {
colors[s] = color;
for (auto &e : edges[s]) {
if (colors[e] == color)
return false;
if (colors[e] == -1 && !build(e, color ^ 1))
return false;
}
return true;
}
};
int main() {
int n, m;
cin >> n >> m;
BipartileGraph g(n);
UnionFind uf(n);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--, b--;
g.addEdge(a, b);
uf.unite(a, b);
}
vector<bool> used(100001, false);
ll twoes = 0;
ll num = 0;
ll single = n;
for (int i = 0; i < n; ++i) {
int r = uf.root(i);
if (used[r])
continue;
int s = uf.getSize(r);
used[r] = true;
if (s != 1) {
num++;
single -= s;
g.clear();
if (g.build(r)) {
twoes++;
}
}
}
ll ret = num * num;
ret += twoes * twoes;
ret += 2 * n * single - single * single;
cout << ret << "\n";
return 0;
}
| 0
| 76,858,396
|
#include <iostream>
#include <algorithm>
#include <math.h>
#include <cmath>
#include <stdio.h>
#include <string>
#include <string.h>
#include <cstring>
#include <sstream>
#include <iomanip>
#include <stdlib.h>
using namespace std;
int main (void)
{
string a;
cin >> a;
int k = 0;
k = a.size();
for (int i = k; i > 0; i--)
{
cout << a.substr(i - 1,1);
}
cout << endl;
}
|
#include <iostream>
using namespace std;
int numEven[100010], numOdd[100010];
int main(){
int n, v[100010];
cin >> n;
for(int i = 0; i < n; i++){
cin >> v[i];
if(i%2==0){
numEven[v[i]]++;
}else{
numOdd[v[i]]++;
}
}
int numEvenMax = 0, numOddMax = 0;
int numEvenMax2 = 0, numOddMax2 = 0;
int numEvenMaxI = 0, numOddMaxI = 0;
int numEvenMaxI2 = 0, numOddMaxI2 = 0;
for(int i = 1; i < 100001; i++){
if(numEvenMax < numEven[i]){
numEvenMax2 = numEvenMax;
numEvenMaxI2 = numEvenMaxI;
numEvenMax = numEven[i];
numEvenMaxI = i;
}else if(numEvenMax2 < numEven[i]){
numEvenMax2 = numEven[i];
numEvenMaxI2 = i;
}
if(numOddMax < numOdd[i]){
numOddMax2 = numOddMax;
numOddMaxI2 = numOddMaxI;
numOddMax = numOdd[i];
numOddMaxI = i;
}else if(numOddMax2 < numOdd[i]){
numOddMax2 = numOdd[i];
numOddMaxI2 = i;
}
}
int ret;
if(numEvenMaxI != numOddMaxI){
ret = n/2 - numEvenMax + n/2 - numOddMax;
}else{
int ret1 = n/2 - numEvenMax + n/2 - numOddMax2;
int ret2 = n/2 - numEvenMax2 + n/2 - numOddMax;
ret = min(ret1, ret2);
}
cout << ret << '\n';
return 0;
}
| 0
| 31,814,217
|
#include<bits/stdc++.h>
using namespace std;
#define LL long long
struct Q{char x; int a, b, c, d;} a[2001][2001];
int n, m;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++) cin >> a[i][j].x;
for(int i = 1; i <= n; i++) {
int cur = 1;
for(int j = 1; j <= m; j++) {
a[i][j].a = cur;
if(a[i][j].x == '#') cur = j + 1;
}
}
for(int i = 1; i <= n; i++) {
int cur = m;
for(int j = m; j >= 1; j--) {
a[i][j].b = cur;
if(a[i][j].x == '#') cur = j - 1;
}
}
for(int j = 1; j <= m; j++) {
int cur = 1;
for(int i = 1; i <= n; i++) {
a[i][j].c = cur;
if(a[i][j].x == '#') cur = i + 1;
}
}
for(int j = 1; j <= m; j++) {
int cur = n;
for(int i = n; i >= 1; i--) {
a[i][j].d = cur;
if(a[i][j].x == '#') cur = i - 1;
}
}
int ans = 0;
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++) {
if(a[i][j].x == '.') ans = max(ans, a[i][j].b - a[i][j].a + 1 + a[i][j].d - a[i][j].c + 1 - 1);
}
cout << ans;
}
|
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define revrep(i, n) for(ll i = n-1; i >= 0; i--)
#define pb push_back
#define f first
#define s second
const ll INFL = 1LL << 60;
const int INF = 1 << 30;
const ll MOD = 1e9 + 7;
vector<ll> dy = {0, 0, 1, -1, 1, 1, -1, -1, 0};
vector<ll> dx = {1, -1, 0, 0, 1, -1, 1, -1, 0};
ll max(ll a, ll b){return (a > b) ? a : b;}
ll min(ll a, ll b){return (a < b) ? a : b;}
ll pow_long(ll x, ll k){
ll res = 1;
while(k > 0){
if(k % 2) res *= x;
x *= x;
k /= 2;
}
return res;
}
ll pow_mod(ll x, ll k){
x %= MOD; x += MOD; x %= MOD;
ll res = 1;
while(k > 0){
if(k % 2){
res *= x; res %= MOD;
}
x *= x; x %= MOD;
k /= 2;
}
return res;
}
ll inverse(ll x){return pow_mod(x, MOD - 2);};
ll gcd(ll a, ll b){
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll x, ll y){return x / gcd(x, y) * y;};
int main(void){
ll W, H;
cin >> W >> H;
vector<ll> P(W);
vector<ll> Q(H);
rep(i, W) cin >> P[i];
rep(i, H) cin >> Q[i];
sort(P.begin(), P.end());
sort(Q.begin(), Q.end());
ll ans = 0;
ll nowH = H + 1;
ll nowW = W + 1;
ll p = 0, q = 0;
while(true){
if(p == W && q == H) break;
if(p == W){
ans += Q[q++] * nowW;
nowH--;
}else if(q == H){
ans += P[p++] * nowH;
nowW--;
}else{
if(P[p] < Q[q]){
ans += P[p++] * nowH;
nowW--;
}else if(P[p] > Q[q]){
ans += Q[q++] * nowW;
nowH--;
}else{
if(nowH >= nowW){
ans += Q[q++] * nowW;
nowH--;
}else{
ans += P[p++] * nowH;
nowW--;
}
}
}
}
cout << ans << endl;
}
| 0
| 46,278,772
|
#include<iostream>
using namespace std;
long long extGCD(long long a, long long b, long long *px, long long *py){
if(b == 0){
*px = 1;
*py = 0;
return a;
}
long long d = extGCD(b, a%b, py, px);
*py -= a/b * (*px);
return d;
}
int main(){
long long N;
cin >> N;
long long T[N];
long long i;
for(i=0; i<N; i++){
cin >> T[i];
}
long long x, y;
long long val=T[0];
for(i=1; i<N; i++){
val=val*(T[i]/extGCD(val,T[i],&x,&y));
}
cout << val << endl;
system("pause");
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const long long mod = 1e9+7;
int main(){
int n, m; cin >> n >> m;
vector<bool> stairs(n+1, true);
for(int i=0; i<m; i++){
int a; cin >> a;
stairs[a] = false;
}
vector<ll> dp(n+1);
dp[0]=1;
for(int i=0; i<n; i++){
int MIN = min(n, i+2);
for(int j=i+1; j<=MIN; j++){
if(stairs[j]){
dp[j]+=dp[i];
dp[j]%=mod;
}
}
}
cout << dp[n] << endl;
return 0;
}
| 0
| 19,986,708
|
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
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)++)
void solve5a(int a, int b) {
REP(i,a) {
REP(j,b) {
cout << "#";
}
cout << endl;
}
cout << endl;
}
int main() {
int a, b;
while(cin >> a >> b, a+b) {
solve5a(a, b);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 1000000007;
typedef int64_t ll;
typedef uint64_t ull;
#define FOR(i, start, end) for(uint64_t i=start; i<end; i++)
#define REP(i, n) FOR(i, 0, n)
uint64_t gcd(uint64_t m, uint64_t n) {
uint64_t temp;
while (m % n != 0){
temp = n;
n = m % n;
m = temp;
}
return n;
}
uint64_t lcm(uint64_t m, uint64_t n) {
return (m*n)/gcd(m,n);
}
void comb(vector<vector <uint64_t> > &v){
for(uint64_t i = 0;i <v.size(); i++){
v[i][0]=1;
v[i][i]=1;
}
for(uint64_t k = 1;k <v.size();k++){
for(uint64_t j = 1;j<k;j++){
v[k][j]=(v[k-1][j-1]+v[k-1][j]);
}
}
}
bool is_product_overflow(uint64_t a, uint64_t b) {
uint64_t prod = a * b;
return (prod / b != a);
}
void primeFactorization(uint64_t a, list<uint64_t> &factors){
long i,sq;
if(a%2==0){
factors.push_back(2);
primeFactorization(a/2,factors);
return;
}
sq = sqrt(a);
for(i=3;i<=sq;i+=2){
if(a%i==0){
factors.push_back(i);
primeFactorization(a/i,factors);
return;
}
}
if(a!=1){
factors.push_back(a);
}
}
int64_t modinv(int64_t a, int64_t m) {
int64_t b = m, u = 1, v = 0;
while (b) {
int64_t 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 pCount(int x){
if(x==0) return 1;
return pCount(x-1)*2 + 1;
}
ll allCount(int x){
if(x==0) return 1;
return allCount(x-1)*2 + 3;
}
signed main() {
ll n,k;
cin >> n >> k;
ll count = 0;
if(k%2==0){
ll c = k/2;
ll k2Count = (n-c)/k + 1;
if(n<c){
k2Count = 0;
}
count += k2Count;
if(k2Count>1){
count += k2Count*(k2Count-1)*3;
}
if(k2Count>2){
count += k2Count*(k2Count-1)*(k2Count-2);
}
}
ll kCount = n/k;
count += kCount;
if(kCount>1){
count += kCount*(kCount-1)*3;
}
if(kCount>2){
count += kCount*(kCount-1)*(kCount-2);
}
cout << count << endl;
return 0;
}
| 0
| 83,932,734
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
ll ar[500009],br[500009],cr[500009];
int main()
{
ll a,b,c,i,j=0,k;
string s;
cin>>a;
for(i=1; i<=a; i++)
{
cin>>ar[i];
}
for(i=0;i<=a+1;i++)
{
j=j+abs(ar[i]-ar[i-1]);
}
for(i=1; i<=a; i++)
{
k=j+abs(ar[i-1]-ar[i+1])-abs(ar[i-1]-ar[i])-abs(ar[i]-ar[i+1]);
cout<<k<<endl;
}
}
|
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <algorithm>
#include <cstdlib>
#include <cmath>
#include <functional>
#include <map>
using namespace std;
using ll = long long int;
int main(){
int N;cin>>N;
vector<int> d(N);
map<int,int> m;
for(int i=0;i<N;i++){
cin >> d[i];
m[d[i]]++;
}
sort(d.begin(),d.end());
d.erase(unique(d.begin(),d.end()),d.end());
int sum = 0;
int p = d.size()-1;
int ans = 0;
for(int i=d[p];i>0&&sum<=N/2;i--){
if(i==d[p]){
sum += m[d[p]];
p--;
}
if(sum==N/2) ans++;
}
cout << ans << endl;
return 0;
}
| 0
| 37,373,417
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define double long double
#define all(v) (v).begin(),(v).end()
#define vi vector<int>
#define vvi vector<vi>
#define pii pair<int,int>
#define vii vector<pii>
#define MOD 1000000007
#define MOD2 998244353
#define MOD3 1000000009
#define PI acos(-1)
#define eps (1e-8)
#define INF (1e18)
#define FASTER ios_base::sync_with_stdio(0);cin.tie(0)
template<class A,class B>ostream&operator<<(ostream&out,const pair<A,B>&a){return out<<"("<<a.first<<","<<a.second<<")";}
template<class A>ostream&operator<<(ostream&out,const vector<A>&a){for(const A &it:a)out<<it<<" ";return out;}
template<class A,class B>istream&operator>>(istream&in,pair<A,B>&a){return in>>a.first>>a.second;}
template<class A>istream&operator>>(istream&in,vector<A>&a){for(A &i:a)in>>i;return in;}
int poww(const int &a,int b,const int &m=MOD){if(b==0)return 1;int x=poww(a,b/2,m);x=x*x%m;if(b&1)x=x*a%m;return x;}
int ceil(const int &a,const int &b){return (a+b-1)/b;}
signed main(){
FASTER;
int n,k;
cin>>n>>k;
vi v(n);
for(int &i:v){
cin>>i;
i=(i-1+k)%k;
}
for(int i=1;i<n;i++)v[i]=(v[i]+v[i-1])%k;
int ans=0;
map<int,int> mp;
mp[0]=1;
for(int i=0;i<min(k-1,n);i++){
ans+=mp[v[i]];
mp[v[i]]++;
}
if(k<n){
mp[0]--;
ans+=mp[v[k-1]];
mp[v[k-1]]++;
for(int i=k;i<n;i++){
mp[v[i-k]]--;
ans+=mp[v[i]];
mp[v[i]]++;
}
}
cout<<ans;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int N = 0;
cin >> N;
vector<int> A(N,0);
for(int i = 0; i < N; i++)
{
cin >> A.at(i);
}
int ans = 1 << 30;
int temp = 0;
for (int i = 1; i <= 100; i++)
{
temp = 0;
for (int j = 0; j < N; j++)
{
temp += pow(A.at(j) - i,2);
}
ans = min(ans,temp);
}
cout << ans << endl;
return 0;
}
| 0
| 94,299,620
|
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
static const int INF = 1e9;
int dp[1001][1001];
void solve()
{
string s1, s2;
cin >> s1 >> s2;
int m = s1.size();
int n = s2.size();
for (int i = 0; i <= m; ++i)
{
for (int j = 0; j <= n; ++j)
{
dp[i][j] = INF;
}
}
for (int i = 0; i <= m; ++i)
{
dp[i][0] = i;
}
for (int i = 0; i <= n; ++i)
{
dp[0][i] = i;
}
for (int i = 1; i <= m; ++i)
{
for (int j = 1; j <= n; ++j)
{
if (s1[i - 1] == s2[j - 1])
{
dp[i][j] = min(dp[i][j], dp[i - 1][j - 1]);
}
else
{
dp[i][j] = min(dp[i - 1][j - 1], min(dp[i - 1][j], dp[i][j - 1])) + 1;
}
}
}
cout << dp[m][n] << endl;
}
int main()
{
solve();
return(0);
}
|
#ifdef LOCAL_JUDGE
#define _GLIBCXX_DEBUG
#endif
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <iomanip>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <math.h>
#include <cmath>
#include <bitset>
using namespace std;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
const long long INF = 100100100100;
const long long MOD = 1000000007;
typedef pair<int,int> P;
long long mod_pow(long long N, long long M) {
if (M == 0) return 1;
long long res = mod_pow((N * N) % MOD, M / 2);
if (M & 1) res = (res * N) % MOD;
return res %= MOD;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
else return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
return a * b / gcd(a, b);
}
int main() {
int A,B,C;cin >> A >> B >> C;
int hozon = A;
for(int i = 0;i<500;i++){
int V = A%B;
A %= B;
if(V == C){
cout << "YES" << endl;
return 0;
}
A += hozon;
}
cout << "NO" << endl;
}
| 0
| 14,941,476
|
#include<iostream>
#include<algorithm>
#define REP(i,n) for(int (i) = (0);(i) < (n);++i)
using namespace std;
int dp[1010][1010];
int main(){
string a,b;cin>>a>>b;
REP(i,a.size()+1)dp[i][0]=i;
REP(i,b.size()+1)dp[0][i]=i;
for(int i=1;i<=a.size();i++){
for(int j=1;j<=b.size();j++){
int q=1;if(a[i-1]==b[j-1])q = 0;
dp[i][j]=min(min(dp[i-1][j-1]+q,dp[i][j-1]+1),dp[i-1][j]+1);
}
}
cout<<dp[a.size()][b.size()]<<endl;
return 0;
}
|
#include <iostream>
#include <set>
#include <algorithm>
using namespace std;
int main(){
int s, x, d=2;
cin >> s;
set<int> a;
a.insert(s);
while(1) {
if(s%2==0){
x = s/2;
if(a.find(x)!=a.end()) {
cout << d << endl;
return 0;
}
a.insert(x);
} else {
x = 3*s + 1;
if(a.find(x)!=a.end()) {
cout << d << endl;
return 0;
}
a.insert(x);
}
s = x;
d++;
}
cout << d << endl;
return 0;
}
| 0
| 83,767,500
|
#include<stdio.h>
int main(void)
{
int i,j,l;
char a[11],b[11],c[11];
scanf("%s%s%s",&a,&b,&c);
i=j=l=0;
while(a[i] != '\0')
i++;
i=i-1;
while(b[j] != '\0')
j++;
j=j-1;
if(a[i] == b[0]){
if(b[j] == c[0])
printf("YES\n");
else
printf("NO\n");
}
else
printf("NO\n");
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define fast() ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long int
#define test() ll t; cin>>t; while(t--)
#define lp0(i,begin,end) for(ll i=begin;i<end;i++)
#define lp1(i,begin,end) for(ll i=begin;i<=end;i++)
#define rlp(i,begin,end) for(ll i=end;i>=begin;i--)
#define prec(n) fixed<<setprecision(n)
#define initial(a,i) memset(a,i,sizeof(a))
#define pb push_back
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define F first
#define S second
#define all(a) (a).begin(),(a).end()
#define BPC(x) __builtin_popcountll(x)
#define gcd(a,b) __gcd(a,b)
ll gcd(ll a,ll b) {if (a==0) return b;return gcd(b%a,a);}
ll power(ll x,ll n)
{
ll result = 1;
while (n)
{
if (n & 1)
result = result * x;
n = n / 2;
x = x * x;
}
return result;
}
void solution(ll compte)
{
string s, t;
cin >> s >> t;
t.pop_back();
if (s == t)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
int main()
{
ll compte = 1;
solution(compte);
compte++;
return 0;
}
| 0
| 17,667,116
|
#define _LIBCPP_DEBUG 0
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll MOD = 1e9 + 7;
int H,W;
char S[22][22];
int DFS(int x, int y, int max){
return 0;
}
int main(void) {
int a,b,c,d; cin>>a>>b>>c>>d;
if(abs(a-c)<=d){
cout<<"Yes"<<endl;
}else if(abs(a-b)<=d && abs(b-c)<=d){
cout<<"Yes"<<endl;
}else cout<<"No"<<endl;
return 0;
}
|
#ifdef LOCAL_JUDGE
#define _GLIBCXX_DEBUG
#endif
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <iomanip>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <math.h>
#include <cmath>
#include <bitset>
using namespace std;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
const long long INF = 100100100100;
const long long MOD = 1000000007;
typedef pair<long long,long long> P;
long long mod_pow(long long N, long long M) {
if (M == 0) return 1;
long long res = mod_pow((N * N) % MOD, M / 2);
if (M & 1) res = (res * N) % MOD;
return res %= MOD;
}
long long nCr(long long n, long long r) {
long long A = 1, B = 1;
for (long long i = n - r + 1; i <= n; i++) {
A = A * i % MOD;
}
for (long long i = 1; i <= r; i++) {
B = B * i % MOD;
}
B = mod_pow(B, MOD - 2);
B %= MOD;
return (A * B) % MOD;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
else return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
return a * b / gcd(a, b);
}
bool ok(long long key,long long index){
if(index > key) return true;
else if(index <= key) return false;
}
long long binary_search(long long key,long long size){
long long left = -1,right = size;
while(right - left > 1){
long long mid = left + (right-left)/2;
long long hantei = ok(key,mid);
if(hantei) right = mid;
else left = mid;
}
if(left == -1)return 0;
return left;
}
int main() {
int N;cin >> N;
vector<long long>retu(N);
for(int i = 0;i<N;i++)cin >> retu.at(i);
vector<long long> rui(N+1,0);
map<long long,int> M;
M[0]++;
for(int i = 0;i<N;i++){
rui.at(i+1) = rui.at(i) + retu.at(i);
M[rui.at(i+1)]++;
}
long long ans = 0;
for(auto A : M){
long long amount = A.second;
ans += amount*(amount-1)/2;
}
cout << ans << endl;
}
| 0
| 62,802,280
|
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int main() {
char ch[1000];
while(1){
scanf("%s", ch);
if (strcmp(ch, "0") == 0) break;
int sum = 0;
for (int i = 0; i < 1000; i++) {
if (ch[i] == '\0') break;
sum += ch[i] - '0';
}
cout << sum << endl;
}
}
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define srep(i,s,t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()
#define maxs(x,y) (x = max(x,y))
#define mins(x,y) (x = min(x,y))
#define limit(x,l,r) max(l,min(x,r))
#define lims(x,l,r) (x = max(l,min(x,r)))
#define isin(x,l,r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)),x.end())
#define show(x) cout<<#x<<" = "<<x<<endl;
#define print(x)cout<<x<<endl;
#define PQ(T) priority_queue<T,v(T),greater<T> >
#define bn(x) ((1<<x)-1)
#define dup(x,y) (((x)+(y)-1)/(y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef tuple<int,int,int> T;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
typedef vector<T> vt;
int main() {
string s;
cin >> s;
map<char,int> m;
rep(i,sz(s)){
m[s[i]]++;
}
for(auto it : m){
if(it.se !=2){
cout<<"No"<<endl;
return 0;
}
}
cout<<"Yes"<<endl;
return 0;
}
| 0
| 41,421,481
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll inf = 1e18;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define per(i, a, b) for (int i = b - 1; i >= a; i--)
#define int ll
using pint = pair<int, int>;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
signed main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
if (a + b < c + d) {
cout << "Right\n";
} else if (a + b == c + d) {
cout << "Balanced\n";
} else {
cout << "Left\n";
}
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < n; ++i)
#define ALL(c) (c).begin(), (c).end()
#define SUM(x) std::accumulate(ALL(x), 0LL)
#define MIN(v) *std::min_element(v.begin(), v.end())
#define MAX(v) *std::max_element(v.begin(), v.end())
#define EXIST(v, x) (std::find(v.begin(), v.end(), x) != v.end())
#define DUMP(v) for(auto& x : v) cerr << x << " "; cerr << endl;
using namespace std;
using ll = long long;
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; }
constexpr int INF = 1e9+5;
constexpr long long INFLL = 1LL<<60;
constexpr double eps = (1e-9);
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> c(n-1), s(n-1), f(n-1);
rep(i, n-1) cin >> c[i] >> s[i] >> f[i];
for (int i = 0; i < n-1; i++) {
ll ans = 0;
for (int j = i; j < n-1; j++) {
if (ans <= s[j]) {
ans = s[j] + c[j];
} else {
if (ans % f[j] == 0) ans += c[j];
else ans += (f[j] - ans % f[j]) + c[j];
}
}
cout << ans << endl;
}
cout << 0 << endl;
return 0;
}
| 0
| 82,943,305
|
#include <iostream>
#include <string>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string a, b, c;
cin >> a >> b >> c;
if (a[a.length() - 1] == b[0] && b[b.length() - 1] == c[0])
cout << "YES";
else
cout << "NO";
}
|
#include <iostream>
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <math.h>
using namespace std;
int main() {
int N,A,B;
cin>>N>>A>>B;
int X=0;
int Y=0;
int Z=0;
vector<int>P(N);
for(int i=0;i<N;i++){
cin>>P[i];
}
for(int i=0;i<N;i++){
if(P[i]<=A){
X++;
}
else if(P[i]>A&&P[i]<=B){
Y++;
}
else{
Z++;
}
}
cout<<min(X,min(Y,Z))<<endl;
}
| 0
| 84,217,786
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int d[k], a[k][n];
vector<bool> tricked(n, true);
for (int i = 0; i < k; i++) {
cin >> d[i];
for (int j = 0; j < d[i]; j++) {
cin >> a[i][j];
tricked[a[i][j] - 1] = false;
}
}
int count = 0;
for (int i = 0; i < n; i++) {
if (tricked[i]) count++;
}
cout << count;
return 0;
}
|
#include <iostream>
#include <iomanip>
#include <vector>
#include <cmath>
#include <algorithm>
#include <climits>
#include <set>
#include <map>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <list>
#include <ctime>
#include <complex>
#include <bitset>
#include <tuple>
#include <functional>
using namespace std;
#define IOS ios::sync_with_stdio(false);cin.tie(0)
#define all(x) x.begin(), x.end()
#define ff first
#define ss second
#define MOD 1000000007LL
#define rep(i,a,n) for (int i=a ; i<n ; i++)
#define per(i,a,n) for (int i=n-1 ; i>=a ; i--)
#define LLINF 100000000000000005LL
#define INF 1e9+1
#define endl '\n'
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string)s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
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 += "}\n";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
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__ << "]:\n", debug_out(__VA_ARGS__)
using llong = long long;
using VI = vector<int>;
using VLL = vector<long long>;
using PII = pair<int, int>;
int main()
{
IOS;
string s;
int n;
cin >> n;
cin >> s;
int cnt = 1;
rep(i, 0, s.length()-1) {
if (s[i] != s[i + 1]) cnt++;
}
cout << cnt;
return 0;
}
| 0
| 42,170,999
|
#include <algorithm>
#include <iostream>
#include <vector>
#include <map>
#include <queue>
using namespace std;
int main() {
int n; cin >> n;
map<int, int> cnt;
while (n--) {
int a; cin >> a;
cnt[a]++;
}
priority_queue<int> pq;
for (auto &p: cnt) {
for (int i = 0; i < p.second / 2; i++) pq.emplace(p.first);
}
if (pq.size() < 2) return !(cout << 0 << endl);
int x = pq.top(); pq.pop();
int y = pq.top(); pq.pop();
cout << 1LL * x * y << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i=0; i<(n); ++i)
#define repr(i, a, b) for (int i=a; i<(b); ++i)
#define reprev(i, n) for (int i=n-1; i>=0; --i)
#define reprrev(i, a, b) for (int i=b-1; i>=(a); --i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
cout << fixed << setprecision(10);
int n, m, d; cin >> n >> m >> d;
double ans = 0.0;
double e = 0.0;
if (d == 0) {
e = double(1.0) / n;
} else {
e = double(2.0);
ll n2 = ll(n) * n;
e *= (n-d);
e /= n2;
}
cout << e * (m-1) << endl;
return 0;
}
| 0
| 84,720,590
|
#include <iostream>
#include <string>
#include <map>
using namespace std;
int main() {
string line;
map<char, int> m;
const char tmp = 'a';
for(int i=0; i<26; i++) {
m[tmp+i] = 0;
}
while(cin >> line) {
for(unsigned int i = 0; i<line.length(); i++) {
if('a' <= line[i] && line[i] <= 'z') {
m[line[i]] += 1;
}
else if('A' <= line[i] && line[i] <= 'Z') {
m[line[i]+32] += 1;
}
}
}
for(int i=0; i<26; i++) {
cout << (char)(tmp+i) << " : " << m[tmp+i] << endl;
}
return 0;
}
|
# include <stdio.h>
int main(void)
{
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
if(a<=b){
if(b<=c){
printf("%d %d %d\n",a,b,c);
}else if(b>c){
if(a<=c){
printf("%d %d %d\n",a,c,b);
}else if(a>c){
printf("%d %d %d\n",c,a,b);
}
}
}else if(a>b){
if(a<=c){
printf("%d %d %d\n",b,a,c);
}else if(a>c){
if(b<=c){
printf("%d %d %d\n",b,c,a);
}else if(b>c){
printf("%d %d %d\n",c,b,a);
}
}
}
return 0;
}
| 0
| 79,776,817
|
#include<bits/stdc++.h>
#include <string>
using namespace std;
const int mod = 1e9 + 7;
const long long INF = 1e18;
#define PI 3.141592653589793
#define REP(i, n) for(long long i = 0;i < n;i++)
int main()
{
int A,B;
cin>>A>>B;
if(A+B==3)cout<<3;
if(A+B==5)cout<<1;
if(A+B==4)cout<<2;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
long long H, W;
cin >> H >> W;
long long res = 0;
long long w=0, h=0;
if(W%2 == 0){
w = W/2;
if(H%2 == 0){
h = H/2;
res = w*H;
}else{
h = (H+1)/2;
res = w*H;
}
}else{
w = (W+1)/2;
if(H%2 == 0){
h = H/2;
res = w*h + (w-1)*h;
}else{
h = (H+1)/2;
res = w*h + (w-1)*(h-1);
}
}
if(H==1 || W==1){
cout << 1 << endl;
}else{
cout << res << endl;
}
}
| 0
| 30,764,172
|
#include <iostream>
#include <string>
using namespace std;
void insertionSort(int A[],int N){
int i, j, v;
for(i = 1; i < N; ++i){
v = A[i];
j = i - 1;
while (j >= 0 && v < A[j]){
A[j + 1] = A[j];
j--;
}
A[j + 1] = v;
}
}
int main(){
int X, N, p[102], num;
bool flag = 1;
cin >> X >> N;
for(int i = 0; i < N; i ++){
cin >> p[i];
}
insertionSort(p, N);
for(int j = 0; j < N; j ++){
if(X == p[j]){
flag = 0;
num = j;
}
}
if(flag){
cout << X << endl;
return 0;
}
for(int k = 1; k < N; k ++){
if(0 <= num - k && p[num - k] != (p[num] - k)){
cout << p[num] - k << endl;
return 0;
}
if(num + k < N && p[num + k] != (p[num] + k)){
cout << p[num] + k << endl;
return 0;
}
}
if (abs(X - p[0]) <= abs(X - p[N - 1])) cout << p[0] - 1;
else cout << p[N - 1] + 1;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define forin(in, n) for(int i=0; i<n; i++) cin>>in[i]
#define forout(out, n) for(int i=0; i<n; i++) cout<<out[i]<<endl
#define rep(i, n) for(int i=0; i<(n); i++)
int main(){
int n; cin>>n;
vector<int> x(n);
vector<int> y(n);
forin(x, n);
forin(y, n);
vector<int> z;
z=x;
sort(z.begin(), z.end());
int cntx=1;
int cnty=1;
int a, b;
int jx=0, jy=0;
do{
rep(i, n){
if(x[i]==z[i]) jx++;
if(y[i]==z[i]) jy++;
}
if(jx==n) a=cntx;
else cntx++;
if(jy==n) b=cnty;
else cnty++;
jx=0;
jy=0;
}while(next_permutation(z.begin(), z.end()));
cout<<abs(a-b)<<endl;
}
| 0
| 43,267,617
|
#include<iostream>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<vector>
#include<cmath>
#include<cstdio>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define it ::iterator
#define all(in) in.begin(),in.end()
const double PI=acos(-1);
const double ESP=1e-10;
using namespace std;
int main(){
string s;
int out[256]={0};
while(getline(cin,s)){
rep(i,s.size()){s[i]=tolower(s[i]);out[s[i]]++;}
}
for(char i='a';i!='z'+1;i++)cout<<i<<" : "<<out[i]<<endl;
}
|
#include <bits/stdc++.h>
#include <vector>
# include <cstdint>
#define FOR(i,l,r) for(int i=(l);i<(r);++i)
#define RFOR(i,l,r) for(int i=(l);i>=(int)(r);i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,n-1,0)
#define int long long
using namespace std;
const int MX = 1e6;
const int inf = 1e13;
const int mod = 1e9+7;
#define ll long long
signed main() {
int n,c,k;
cin >> n>> c>>k;
vector<int> t(n);
rep(i,n) cin >> t[i];
sort(t.begin(),t.end());
int en = t[0]+k;
int id = 1;
int cnt = 1;
int ans = 1;
while(id<n) {
if(en>=t[id]) {
cnt++;
if(cnt>=c) {
cnt=0;
ans++;
if(id+1<n) en = t[id+1]+k;
}
}else {
cnt=1;
ans++;
en = t[id]+k;
}
id++;
}
cout << ans << endl;
return 0;
}
| 0
| 74,934,906
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.