code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 45
101M
|
|---|---|---|---|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
typedef long long ll;
int main(){
int a,b;
cin >> a >> b;
if(a==1) a=14;
if(b==1) b=14;
if(a>b) cout << "Alice" << endl;
else if(a==b) cout << "Draw" << endl;
else cout << "Bob" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#ifdef DEBUG_MODE
#define DEBUG(X) debug_func(X, #X)
#define DEBUG_ENDL endl << flush
#define DEBUG_SEPARATOR_LINE cout<<"=================\n"
#else
#define DEBUG(X) 0
#define DEBUG_ENDL 0
#define DEBUG_SEPARATOR_LINE 0
#endif
#define ALL(V) (V).begin(), (V).end()
#define ALLR(V) (V).rbegin(), (V).rend()
#define DEBUG_ENDL_S(S) ((S).size() ? "\n" : "") << flush;
template <typename T> using V = vector<T>;
template <typename T> using VV = V<V<T>>;
template <typename T, typename U> using P = pair<T, U>;
using ll = int64_t;
using PLL = P<ll, ll>;
template <typename T> const T& var_min(const T &t) { return t; }
template <typename T> const T& var_max(const T &t) { return t; }
template <typename Head, typename... Tail> const Head& var_min(const Head &head, const Tail&... tail) { return min(head, var_min(tail...)); }
template <typename Head, typename... Tail> const Head& var_max(const Head &head, const Tail&... tail) { return max(head, var_max(tail...)); }
template <typename T, typename... Tail> void chmin(T &t, const Tail&... tail) { t = var_min(t, tail...); }
template <typename T, typename... Tail> void chmax(T &t, const Tail&... tail) { t = var_max(t, tail...); }
void debug_func_preffix(const string &s) { if(s.size()) cout << s << " = "; }
template <typename T>
void debug_func(const T &t, const string &s = "") {
debug_func_preffix(s);
cout << t << DEBUG_ENDL_S(s);
}
template <typename T, typename U>
void debug_func(const P<T, U> &p, const string &s = "") {
debug_func_preffix(s);
cout << "(";
debug_func(p.first);
cout << ", ";
debug_func(p.second);
cout << ")" << DEBUG_ENDL_S(s);
}
template <typename T>
void debug_func(const V<T> &v, const string &s = "") {
for(ll i = 0; i < v.size(); i++) {
string t = s + "[" + to_string(i) + "]";
debug_func(v[i], t);
}
}
void init_io() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(30);
}
int main() {
init_io();
ll N;
cin >> N;
V<PLL> A;
for(ll i = 0; i < N; i++) {
ll a;
cin >> a;
A.emplace_back(a, i);
}
A.emplace_back(0, -1);
sort(ALL(A), [](const auto &a, const auto &b) { return a.first != b.first ? a > b : a < b; });
DEBUG(A);
ll idx = 0;
V<ll> cnt(N, 0);
ll preh;
while(idx < N) {
ll nidx = idx + 1;
while(A[nidx].second > A[idx].second) nidx++;
ll sum = idx * (preh - A[nidx].first);
preh = A[nidx].first;
for(ll i = idx; i < nidx; i++) sum += A[i].first - A[nidx].first;
cnt[A[idx].second] = sum;
idx = nidx;
}
for(ll e : cnt) cout << e << endl;
return 0;
}
| 0
| 12,573,415
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int H,W;
cin >> H >> W;
vector<vector<char>> vec(H,vector<char> (W));
for(int i=0;i<H;++i){
for(int j=0;j<W;++j){
cin >> vec.at(i).at(j);
}
}
for(int i=0;i<H;++i){
for(int j=0;j<W;++j){
cout << vec.at(i).at(j);
}
cout << endl;
for(int j=0;j<W;++j){
cout << vec.at(i).at(j);
}
cout << endl;
}
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;
int main() {
long long H, W;
cin >> H >> W;
if (H % 3 == 0 || W % 3 == 0) {
cout << 0 << endl;
return 0;
}
long long mn = H * W;
for (int i = 1; i < H; i++) {
long long S1 = i * W;
long long S2 = (H - i) * (W / 2);
long long S3 = (H - i) * ((W + 1) / 2);
long long Smax = std::max(S1, std::max(S2, S3));
long long Smin = std::min(S1, std::min(S2, S3));
if (mn > Smax - Smin) mn = Smax - Smin;
if (H - i < 2) continue;
S2 = (H - i) / 2 * W;
S3 = (H - i + 1) / 2 * W;
Smax = std::max(S1, std::max(S2, S3));
Smin = std::min(S1, std::min(S2, S3));
if (mn > Smax - Smin) mn = Smax - Smin;
}
for (int i = 1; i < W; i++) {
long long S1 = i * H;
long long S2 = (W - i) * (H / 2);
long long S3 = (W - i) * ((H + 1) / 2);
long long Smax = std::max(S1, std::max(S2, S3));
long long Smin = std::min(S1, std::min(S2, S3));
if (mn > Smax - Smin) mn = Smax - Smin;
if (W - i < 2) continue;
S2 = (W - i) / 2 * H;
S3 = (W - i + 1) / 2 * H;
Smax = std::max(S1, std::max(S2, S3));
Smin = std::min(S1, std::min(S2, S3));
if (mn > Smax - Smin) mn = Smax - Smin;
}
cout << mn << endl;
return 0;
}
| 0
| 89,662,348
|
#include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
typedef long long ll;
#define MOD 1000000007
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n + 1), b(n + 1), p(n + 1);
for (int i = 1; i <= n; i++) {
a[i] = 30000 * i;
int x;
cin >> x;
p[x] = i;
}
for (int i = 1; i < n + 1; i++) {
b[i] = 30000 * (n - i) + p[i];
}
for (int i = 0; i < n; i++) {
cout << a[i + 1] << " ";
}
cout << endl;
for (int i = 0; i < n; i++) {
cout << b[i + 1] << " ";
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
template<class T> using vc = vector<T>;
template<class T> using vvc = vector<vector<T>>;
const ll MOD = 1e9 + 7;
const ll INF = 1e16;
const ld EPS = 1e-11;
const ld PI = acos(-1.0L);
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repr(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repe(i, l, r) for (ll i = (l); i < (r); i++)
#define reper(i, l, r) for (ll i = (r)-1; i >= (l); i--)
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
void init() {cin.tie(0);ios::sync_with_stdio(false);cout << fixed << setprecision(15);}
struct dice{
int u, d, f, b, l, r;
void init(int up,int down,int front, int back, int left, int right){
u = up, d = down, f = front, b = back, l = left, r = right;
}
void goup(){ int tmp = u; u = b, b = d, d = f, f = tmp; }
void godown(){ int tmp = u; u = f, f = d, d = b, b = tmp; }
void goleft(){ int tmp = u; u = r, r = d, d = l, l = tmp; }
void goright(){ int tmp = u; u = l, l = d, d = r, r = tmp; }
void rotateleft() { int tmp = f; f = r, r = b, b = l, l = tmp; }
void rotateright() { int tmp = f; f = l, l = b, b = r, r = tmp; }
void reversefb() { swap(f, b), swap(u, d); }
void reverselr() { swap(l, r), swap(u, d); }
};
int main() {
init();
int u, b, r, l, f, d;
cin >> u >> b >> r >> l >> f >> d;
dice dic;
dic.init(u, d, f, b, l, r);
dice dd[6];
dd[0] = dic;
dic.reversefb(), dd[1] = dic;
dic.goleft(), dd[2] = dic;
dic.reversefb(), dd[3] = dic;
dic.goup(), dd[4] = dic;
dic.reversefb(), dd[5] = dic;
ll N;
cin>>N;
rep(i,N){
cin >> u >> b;
rep(j,6){
if (dd[j].u != u) continue;
rep(k,4){
if(dd[j].b==b){
cout << dd[j].r << endl;
}
dd[j].rotateleft();
}
}
}
}
| 0
| 20,728,803
|
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <stdio.h>
#include <cstring>
#include <iomanip>
#define _USE_MATH_DEFINES
#include <math.h>
#include <numeric>
using namespace std;
int main()
{
char ch[1200];
memset(ch, 0, sizeof(ch));
string st;
getline(cin, st);
strcpy(ch, st.c_str());
char* pch = ch;
while ( *pch )
{
if (*pch >= 'a' && *pch <= 'z')
{
*pch -= 0x20;;
}
else if (*pch >= 'A' && *pch <= 'Z')
{
*pch += 0x20;
}
pch++;
}
cout << ch << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define SIZE 10
#define PI 3.141592653589793
using namespace std;
typedef long long ll;
int main(void){
cin.tie(0);
ios::sync_with_stdio(false);
int i,j;
int tmp;
int counter=0;
double N;
double answer=0;
vector<int> given;
cin >> N;
answer=(N/3)*(N/3)*(N/3);
cout << std::fixed << std::setprecision(15) << answer << endl;
return 0;
}
| 0
| 69,279,691
|
#include <bits/stdc++.h>
using namespace std;
#define all(a)a.begin(),a.end()
using ll=long long;
const int INF = 1<<30;
const ll INFll =1LL<<62;
const int mod= int(1e9)+7;
using P = pair<ll,ll>;
using ld=long double;
int main(){
ll n;cin >>n;
ll ans=0;
for (int i = 0; i < n; ++i) {
ll l,r;cin >>l>>r;
ans+=r-l+1;
}
cout <<ans <<endl;
return 0;
}
|
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pqueue priority_queue
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
int N;
cin>>N;
vector<int> A(N);
for(int i=0;i<N;++i) cin>>A[i];
sort(A.begin(), A.end());
int ans[A[A.size()-1]+1];
for(int i=0;i<=A[A.size()-1];++i) ans[i] = 0;
map<int, int> amap;
for(int i=0;i<N;++i) {
if(ans[A[i]]>0) continue;
amap[A[i]]++;
for(int j=2;A[i]*j<=A[A.size()-1];++j) {
ans[A[i]*j]++;
}
}
int ans1 = 0;
for(int i=0;i<=A[A.size()-1];++i) {
if(amap[i]==1 && ans[i]==0) ans1++;
}
cout<<ans1<<endl;
}
| 0
| 78,744,820
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<queue>
using namespace std;
const int maxn = 10001;
vector<int> G[maxn], ans;
int indegree[maxn], vis[maxn];
int n, e;
void BFS(int s)
{
queue<int> Q;
Q.push(s);
vis[s] = 1;
while(!Q.empty())
{
int top = Q.front();
ans.push_back(top);
vis[top] = 1;
Q.pop();
for(int i = 0; i < G[top].size(); i++)
{
indegree[G[top][i]]--;
if(indegree[G[top][i]] == 0 && vis[G[top][i]] == 0)
{
Q.push(G[top][i]);
}
}
}
}
void topologicalSort()
{
for(int u = 0; u < n; u++)
if(indegree[u] == 0 && vis[u] == 0)
BFS(u);
}
int main()
{
cin >> n >> e;
for(int i = 0; i < n; i++)
{
vis[i] = 0;
indegree[i] = 0;
}
for(int i = 0; i < e; i++)
{
int x, y;
cin >> x >>y;
G[x].push_back(y);
indegree[y]++;
}
topologicalSort();
for(int i = 0; i < ans.size(); i++)
cout << ans[i] <<endl;
return 0;
}
|
#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--)
#define ALL(v) v.begin(), v.end()
using namespace std;
using P = pair<int, int>;
typedef long long ll;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
rep(i, n) cin >> a[i];
ll ans = 10000000000000000;
for (int bit = 0; bit < (1 << n); bit++){
int mx = 0;
int ok = 0;
ll cost = 0;
vector<int> tmp = a;
rep(i, n) {
if(bit & (1 << i)){
if(tmp[i] > mx){
mx = tmp[i];
}else{
cost += (mx + 1) - a[i];
mx++;
tmp[i] = mx;
}
}else{
if(a[i] > mx)mx = a[i];
}
}
mx = 0;
rep(i, n) {
if(tmp[i] > mx){
ok++;
mx = tmp[i];
}
}
if(ok >= k)ans = min(ans, cost);
}
cout << ans << endl;
}
| 0
| 45,450,335
|
#define rep(i, n) for (int i = 0; i < (n); i++)
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int MOD = 1000000007;
int main() {
int k, n;
cin >> k >> n;
vector<int> a(n);
rep(i, n) cin >> a.at(i);
int maxLength = k - a.at(n - 1) + a.at(0);
for (int i = 1; i < n; i++) {
maxLength = max(maxLength, a.at(i) - a.at(i - 1));
}
int ans = k - maxLength;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i<(n); i++)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
using ll = long long;
vector<pair<ll, ll>> prime_factorize(ll n) {
vector<pair<ll, ll>> res;
for (ll p = 2; p * p <= n; p++) {
if (n % p != 0) continue;
int num = 0;
while (n % p == 0) {
num++;
n /= p;
}
res.push_back(make_pair(p, num));
}
if (n != 1) res.push_back(make_pair(n, 1));
return res;
}
int main() {
ll N;
cin >> N;
vector<pair<ll, ll>> primes = prime_factorize(N);
ll ans = 0;
for (auto p: primes) {
int count = p.second;
int n = 1;
while (count >= n) {
ans++;
count -= n;
n++;
}
}
cout << ans << endl;
}
| 0
| 40,620,110
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n;
string s;
cin >> n >> s;
if (s.size() % 2 == 0 && s.substr(0, n / 2) == s.substr(n / 2, n / 2)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
ll const INF = 1LL << 60;
int main() {
ll H, W;
cin >> H >> W;
vector<string> MAP(H);
for (int i = 0; i < H; i++) {
cin >> MAP[i];
}
vector<bool> deletable_row(H, true);
vector<bool> deletable_col(W, true);
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (MAP[i][j] == '#') {
deletable_row[i] = false;
deletable_col[j] = false;
}
}
}
for (int i = 0; i < H; i++) {
if (deletable_row[i]) continue;
for (int j = 0; j < W; j++) {
if (deletable_col[j]) continue;
cout << MAP[i][j];
}
cout << endl;
}
return 0;
}
| 0
| 16,110,812
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
using namespace std;
using P = pair<int, int>;
using ll = long long;
int main()
{
char c;
cin >> c;
if(c == 'A') cout << 'T' << endl;
else if(c == 'T') cout << 'A' << endl;
else if(c == 'G') cout << 'C' << endl;
else cout << 'G' << endl;
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int n,m,p;
while(cin>>n>>m>>p){
if(n==0)break;
double G=0;
int num[n];
for(int i=0;i<n;i++){
cin>>num[i];
G+=num[i];
}
G*=(100.0-p);
if(num[m-1]!=0){
cout << (int)(G/num[m-1]) << endl;
}else{
cout << 0 << endl;
}
}
return 0;
}
| 0
| 8,195,003
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long s;
cin >> s;
long long a, b, k, l;
a = ceil(sqrt(s));
b = ceil(sqrt(s));
long long xy = (a * b) - s;
l = b - 1;
k = xy;
cout << 0 <<" "<< b <<" "<< k <<" "<< 0 << " " << a << " " << l;
}
|
#include <bits/stdc++.h>
#define rep(i, start, end) for (long long i = start; i < end; ++i)
#define repreverse(i, start, end) for (long long i = start; i >= end; --i)
#define all(x) (x).begin(), (x).end()
#define len(x) ((long long)(x).size())
#define g(a, b) __gcd((a), (b))
#define l(a, b) ((a) / __gcd((a), (b)) * (b))
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vllvll = vector<vll>;
using pll = pair<ll, ll>;
template<class T>void print1d(T x,ll n=-1){if(n==-1)n=x.size();rep(i,0,n){cout<<x[i]<<' ';}cout<<'\n';}
template<class T>void print2d(T x,ll r=-1,ll c=-1){if(r==-1)r=x.size();if(c==-1)c=x[0].size();rep(i,0,r)print1d(x[i],c);}
template<class T, class U>bool haskey(T mp, U key) { return mp.find(key) != mp.end(); }
template<class T, class U>bool isin(T el, U container) { return find(all(container), el) != container.end(); }
template<class T>bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
template<class T>ld deg2rad(T deg) { return M_PI * deg / 180.0; }
template<class T>ld rad2deg(T rad) { return 180.0 * rad / M_PI; }
const long double pi = M_PI;
const long long big = 1LL << 50;
const long long inf = 1LL << 60;
const long long mod = 1e9 + 7;
int main()
{
ll n;
cin >> n;
vll a(n);
rep(i, 0, n) cin >> a[i];
deque<ll> b;
if (n % 2 == 0) {
rep(i, 0, n) {
b.push_back(a[i]);
++i;
b.push_front(a[i]);
}
} else {
rep(i, 0, n-1) {
b.push_front(a[i]);
++i;
b.push_back(a[i]);
}
b.push_front(a[n-1]);
}
rep(i, 0, len(b)) {
cout << b[i] << ' ';
}
cout << endl;
}
| 0
| 59,995,543
|
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <queue>
#include <map>
#define ll long long
using namespace std;
int main(void){
ll n, a, b;
cin >> n >> a >> b;
ll check = b-a-1;
if(check%2==0)
cout << "Borys" << endl;
else
cout << "Alice" << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define pi 2*acos(0.0)
#define ll long long
#define FIO ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define Node struct node
#define spc " "
#define E 2.71828182845904523536
#define pb push_back
#define pp pop_back
#define valid(nx,ny) nx>=0 && nx<n && ny>=0 && ny<m
#define ee endl
#define pii pair<int,int>
#define infinity 10000000000000000
#define mod 1000000007
int fx[]={0,0,+1,-1};
int fy[]={+1,-1,0,0};
using namespace std;
const int maX=1e5+1;
vector<ll>Graph[maX],cost[maX];
ll visit[maX];
ll x[10];
ll y[10];
int main()
{
ll i,j,cc=0;
string s,t;
cin>>s>>t;
int a[26]={0};
int b[26]={0};
for(i=0;i<s.size();i++){
a[s[i]-'a']++;
b[t[i]-'a']++;
}
sort(a,a+26);
sort(b,b+26);
for(i=0;i<26;i++){
if(a[i] != b[i]){
cout<<"No"<<endl;
return 0;
}
}
cout<<"Yes"<<endl;
return 0;
}
| 0
| 45,690,987
|
#include<bits/stdc++.h>
using namespace std;
const int N = 2e5 + 8;
int n , a[N] , l = -1 , r , mid , v , q;
pair<int, int> k , z;
set<pair<int , int> > s;
bool is_val(int x)
{
s.clear();
s.insert({0 , 0});
for(int i = 1 ; i < n ; i++)
{
k = *s.rbegin();
if(a[i] > a[i - 1])
{
if(k.second != 0)
s.insert({a[i - 1] + 1 , 0});
}
else
{
while(s.size() && s.rbegin()-> first > a[i])
s.erase(*s.rbegin());
v = s.rbegin()-> second , q = s.rbegin()-> first;
if(v != x)
{
if(s.rbegin()->first == a[i])
s.erase(*s.rbegin());
if(s.empty() || (s.size() && s.rbegin()->second != v + 1))
s.insert({a[i] , v + 1});
}
else
{
if(q == 0)
return 0;
s.erase(*s.rbegin());
z = *s.rbegin();
if(z.first + 1 == q)
s.erase(*s.rbegin());
if(s.empty() || (s.size() && s.rbegin()->second != z.second + 1))
s.insert({q - 1 , z.second + 1});
s.insert({q , 0});
}
}
}
return 1;
}
int main()
{
cin >> n;
for(int i = 0 ; i < n ; i++)
{
cin >> a[i];
a[i]--;
}
r = n;
while(r - l > 1)
{
mid = (l + r) / 2;
if(is_val(mid))
r = mid;
else
l = mid;
}
cout << r + 1;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<bool> vb;
typedef vector <string> vs;
typedef vector<vector<int>> vvi;
typedef vector<vector<ll>> vvl;
typedef pair<int,int> pi;
#define int ll
#define forl(i,a,b) for (int i = a; i < b; i++)
#define rfor(i,b,a) for (int i = b; i >= a; i--)
#define f first
#define s second
#define pb push_back
#define mp make_pair
#define srt(x) sort(x.begin(), x.end())
#define sumup(x) accumulate(x.begin(), x.end(), 0)
#define PI 3.141592653589793238
#define MOD 1000000007
#define loop(n) for(int i = 0; i < n; i++)
#define rloop(n) for(int i = n-1; i >= 0; i--)
void io() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
}
void solve() {
int n, m;
cin>>n>>m;
vl h(n), hm(n);
loop(n) cin>>h[i];
map <ll,set<ll>> roads;
loop(m) {
ll x, y;
cin>>x;
cin>>y;
hm[x-1] = max(hm[x-1],h[y-1]);
hm[y-1] = max(hm[y-1],h[x-1]);
}
int ans=0;
loop(n) {
if(h[i]>hm[i]) ans++;
}
cout<<ans<<"\n";
return;
}
int32_t main() {
io();
int t=1;
while(t--) {
solve();
}
return 0;
}
| 0
| 47,794,661
|
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <iomanip>
#include <vector>
#include <string.h>
#include <math.h>
#include <algorithm>
#include <map>
#include <queue>
#define rep(i,n) for (int i=0;i<(n);i++)
using namespace std;
int gcd(int p, int q) {
if (p % q == 0) return q;
return gcd(q, p % q);
}
long long lcm(long long a, long long b) {
return a * b / gcd(a, b);
}
int main() {
long long a, b;
cin >> a >> b;
cout << lcm(a, b) << endl;
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<cmath>
#include<utility>
#include<cstdio>
#include<set>
#include<string>
#include<map>
#include<queue>
#include<stack>
#include <bitset>
using namespace std;
const int mod=1e9+7;
#define rep(i,n) for(int i=0;i<n;i++)
#define rep2(i,x,n) for (int i= x;i<n;i++)
#define all(v) v.begin(), v.end()
#define nepe(v) next_permutation(all(v))
#define F first
#define S second
#define PB push_back
#define MP make_pair
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vp =vector<pair<int,int>>;
typedef pair<int,int> P;
string s;
int k;
ll INF = 10000000000000000;
int main(){
int N;
cin >> N;
vp r(N),b(N);
rep(i,N) cin >>r[i].F>>r[i].S;
rep(i,N) cin >>b[i].F>>b[i].S;
vi left(N,0);
vi max(N,0);
sort(all(b));
sort(all(r));
int jj=0;
int ans=0;
rep(i,N){
bool judge=false;
rep(j,N){
if(left[j] ==0){
if(r[j].F<b[i].F && r[j].S<b[i].S && r[j].S>=max[i]){
max[i]=r[j].S;
jj = j;
judge = true;
}
}
}
if(judge) {
ans++;
left[jj] = 1;
}
}
cout <<ans<<endl;
}
| 0
| 88,133,760
|
#include <iostream>
#include <cmath>
using namespace std;
bool isPrime(long long n, long long root) {
for (long long i = 2; i <= root; i++) {
if (n % i == 0)
return false;
}
return true;
}
int nDigits(long long n) {
int digits = 0;
while (n > 0) {
digits++;
n /= 10;
}
return digits;
}
int main() {
long long n;
cin >> n;
long long root = sqrt(n);
if (isPrime(n, root)) {
cout << nDigits(n) << endl;
}
else {
for (long long i = root; i < n; i++) {
if (n % i == 0) {
cout << nDigits(i) << endl;
return 0;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char *argv[]) {
int w, h, n;
cin >> w >> h >> n;
int t = h, b = 0, l = 0, r = w;
for (int i = 0; i < n; ++i) {
int x, y, a;
cin >> x >> y >> a;
switch (a) {
case 1:
l = max(l, x);
break;
case 2:
r = min(r, x);
break;
case 3:
b = max(b, y);
break;
default:
t = min(t, y);
break;
}
}
cout << max(0, r - l) * max(0, t - b) << '\n';
return 0;
}
| 0
| 78,806,401
|
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <cmath>
#include <stdio.h>
#include <list>
#include <numeric>
#include <stack>
#include <queue>
#include <tuple>
#include <bitset>
#include <map>
#include <math.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); i++)
typedef long long ll;
typedef pair<int,int> P;
const int inf=1000000007;
const ll mod=1000000007;
const double PI=3.14159265358979323846;
int dx[] = {1,-1,0,0};
int dy[] = {0,0,1,-1};
int main(){
int N,M;
cin >> N >> M;
int k[M];
int s[11][11];
int p[M];
rep(i,M) {
cin >> k[i];
rep(j,k[i]) {
cin >> s[i][j];
s[i][j]--;
}
}
rep(i,M) cin >> p[i];
int ans = 0;
for(int bit=0; bit < (1 << N); bit++) {
vector<bool> isturn(10,false);
rep(i,N) {
if((1<<i) & bit) {
isturn[i] = true;
}
}
int tmp = 0;
rep(i,M) {
int cnt = 0;
rep(j,k[i]) {
if(isturn[s[i][j]]) cnt++;
}
if(cnt%2 == p[i]) tmp++;
}
if(tmp == M) ans++;
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include<vector>
#include<algorithm>
#define ll long long
#define rep(n) for(int i=0;i<n;++i)
using namespace std;
int main(void){
int n, max1=-1,max2=-1;
cin>>n;
vector<int> vec(n+1), vec2(n);
rep(n){
cin>>vec[i];
if(vec[i]>max1){
max2= max1;
max1=vec[i];
}else{
if(vec[i]>max2){
max2=vec[i];
}
}
}
rep(n){
if(vec[i]!=max1){
cout<<max1<<endl;
}
else
cout<<max2<<endl;
}
}
| 0
| 45,942,283
|
#include <bits/stdc++.h>
#define rep(i, n) for (ll(i) = 0; (i) < (n); (i)++)
#define all(x) (x).begin(), (x).end()
#define print(x) cout << (x) << endl;
typedef long long ll;
const ll INF = 99999999999999;
const ll MOD = 1000000007;
using namespace std;
int main()
{
int a, b;
cin >> a >> b;
cout << (a - 1) * (b - 1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ld long double
#define endl "\n"
const int mod = 1e9+7;
inline int add(int a, int b) { int res = a + b; if(res >= mod) res -= mod; return res; }
inline int sub(int a, int b) { int res = a - b; if(res < 0) res += mod; return res;}
inline int mul(int a, int b) { return (a * b)%mod; }
void solve() {
int n; cin >> n;
int pos[n+1]; pos[0] = 0;
for(int i=1; i<=n; i++) {
int x; cin >> x;
pos[x] = i;
}
int ans = 0;
multiset<int> s;
s.insert(0); s.insert(0);
s.insert(n+1); s.insert(n+1);
s.insert(pos[n]);
for(int cur=n-1; cur>0; cur--) {
int l1, l2, r1, r2;
int cp = pos[cur];
auto it = s.lower_bound(cp);
r1 = *it;
auto it2 = it;
it2++;
r2 = *it2;
it2 = (--it);
l1 = *it2;
l2 = *(--it2);
ans += cur * ((cp-l1)*(r2-r1) + (l1-l2)*(r1-cp));
s.insert(cp);
}
cout << ans << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
cout << fixed << setprecision(18);
int T = 1;
while(T--) {
solve();
}
return 0;
}
| 0
| 59,016,337
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<ll> a(n), b(n);
ll sum = 0, keep = 1e9;
for (int i = 0; i < n; i++) {
cin >> a.at(i) >> b.at(i);
sum += a.at(i);
if (a.at(i) > b.at(i)) keep = min(keep, b.at(i));
}
if (a == b) cout << 0 << '\n';
else cout << sum - keep << '\n';
}
|
#include <vector>
#include <stack>
#include <queue>
#include <list>
#include <bitset>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <string>
#include <chrono>
#include <random>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <functional>
#include <sstream>
using namespace std;
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
string S;
cin >> S;
int x, y;
cin >> x >> y;
vector<int> X;
vector<int> Y;
int n = S.length();
int len = 0;
int d = 0;
for (int i = 0; i < n; ++i) {
if (S[i] == 'T') {
if (d == 0) {
X.push_back(len);
} else {
Y.push_back(len);
}
d ^= 1;
len = 0;
continue;
}
++len;
}
if (d == 0) {
X.push_back(len);
} else {
Y.push_back(len);
}
auto check = [&](vector<int>& A, int beg, long long target) {
int n = A.size();
const int M = 8000 * 3 + 10;
int offset = 8000 + 1;
bitset<M> bits;
bits.set(offset);
auto nbits = bits;
for (int i = beg; i < n; ++i) {
nbits.reset();
nbits |= bits << A[i];
nbits |= bits >> A[i];
bits = nbits;
}
if (target + offset >= 0 && target + offset < M) {
return bits.test(target + offset);
} else {
return false;
}
};
bool res = false;
if (check(X, 1, x - X[0]) && check(Y, 0, y)) {
res = true;
}
if (res) {
cout << "Yes\n";
} else {
cout << "No\n";
}
return 0;
}
| 0
| 86,574,363
|
#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
int main(void) {
priority_queue<int> que;
for(int r = 0; r < 10; r++) {
int input; cin >> input;
que.push(input);
}
for(int r = 0; r < 3; r++) {
cout << que.top() << endl; que.pop();
}
return(0);
}
|
#include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <sstream>
#include <vector>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
int main()
{
int n,a,b;
cin>>n>>a>>b;
int ans = 0;
for(int i = 1; i <= n; i++){
int temp = i;
int num = 0;
while(temp > 0){
num += temp % 10;
temp /= 10;
}
if( a <= num && num <= b){
ans += i;
}
}
cout<<ans<<endl;
return 0;
}
| 0
| 99,839,740
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using VI = vector<int>;
using PI = pair<int, int>;
int main() {
int n, a, b;
a = b = 0;
cin >> n;
for (int i = 0; i < n; i++) {
string s, t;
cin >> s >> t;
int ss, ts;
ss = s.size(); ts = t.size();
if (s == t) {
a++; b++;
continue;
}
else {
if (s.substr(0, min(ss, ts)) == t.substr(0, min(ss, ts))) {
if (ss > ts) a += 3;
else b += 3;
continue;
}
for (int j = 0; j < min(ss, ts); j++) {
if (s[j] > t[j]) {
a += 3;
break;;
}
else if (s[j] < t[j]) {
b += 3;
break;;
}
}
}
}
cout << a << " " << b << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const int mod=1000000007;
const double PI = 3.14159265359;
#define mxe(v) *max_element(v.begin(),v.end())
#define mne(v) *min_element(v.begin(),v.end())
#define INF 1000000000000
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define mp make_pair
#define lb lower_bound
#define ub upper_bound
#define FOR(i,n) for(int i=0;i<(n);i++)
#define FORA(i,a,b) for(int i=(a);i<=(b);i++)
#define FORD(i,a,b) for(int i=(a);i>=(b);i--)
#define FAST ios_base::sync_with_stdio(false);cin.tie(NULL);
#define count_1(n) __builtin_popcountll(n)
#define parity(n) __builtin_parityll(n)
void show (int a[], int arraysize) { for (int i = 0; i < arraysize; ++i) {cout << a[i] << " ";} cout<<endl;}
int gcd(int a, int b) { if (b == 0) return a; return gcd(b, a % b);}
void sieve(int n)
{
bool prime[n+1];
memset(prime, true, sizeof(prime));
for (int p=2; p*p<=n; p++)
{
if (prime[p] == true)
{
for (int i=p*p; i<=n; i += p)
prime[i] = false;
}
}
for (int p=2; p<=n; p++)
if (prime[p])
cout << p << " ";
}
int main()
{FAST
int n;
ld m,sum=0;
cin>>n>>m;
int a[n];
FOR(i,n)
{
cin>>a[i];
sum+=a[i];
}
ld x=sum/(4*m);
FOR(i,n)
{
if(a[i]>=x)
{
m--;
}
if(m==0)
{
break;
}
}
if(m==0)
{
cout<<"Yes\n";
}
else
{
cout<<"No\n";
}
return 0;
}
| 0
| 36,874,867
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
using namespace std;
using ll = long long;
#define rep(i, j, n) for(int i = (j); i < (n); ++i)
#define rrep(i, j, n) for(int i = (n) - 1; (j) <= i; --i)
constexpr ll MOD = 1000000007;
constexpr ll INF = 1LL << 60;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
ll n, k; cin >> n >> k;
vector<ll> a(n);
rep(i, 0, n) cin >> a[i];
ll ans = 0;
rep(i, 0, n) {
ll cnt = 0;
rep(j, i + 1, n) if (a[i] > a[j]) ++cnt;
ans += cnt * k;
ans %= MOD;
}
rep(i, 0, n) {
ll cnt = 0;
rep(j, 0, n) if (a[i] > a[j]) ++cnt;
ans += k * (k - 1) / 2 % MOD * cnt % MOD;
ans %= MOD;
}
cout << ans;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define Pi acos(-1)
#define _terminated return 0
#define endl "\n"
#define yes cout << "yes" << endl
#define no cout << "no" << endl
#define booster ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<long> > v2l;
const int mod = 1e+5;
const int mx = 2e+5;
const ll inf = 1e18;
using namespace std;
#define max 101
void solvio(){
int a,b,i;
cin >> a >> b;
if(a>b){
for(i=1; i<=a; i++) cout << b;
} else{
for(i=1; i<=b; i++)
cout << a;
}
cout << endl;
}
int main(){
booster;
solvio();
_terminated;
}
| 0
| 78,138,951
|
#include<bits/stdc++.h>
using namespace std;
#define all(vec) vec.begin(),vec.end()
typedef long long int ll;
typedef pair<ll,ll> P;
const ll MOD=1234567;
const ll INF=1000000010;
const ll LINF=1000000000000000010LL;
const int MAX=10000010;
const double EPS=1e-3;
int dx[4]={0,1,0,1};
int dy[4]={0,0,1,1};
ll fact(int n){
if(n==1){
return 1;
}
ll res=n;
res*=fact(n-1);
return res;
}
int main(){
int n;cin>>n;
cout<<fact(n)<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
vector<long long> ret;
void divisor(long long n) {
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
return;
}
int main(){
ll ans=0;
ll n; cin>>n;
divisor(n);
for(auto x : ret){
if(x>=(n/x-1)){
continue;
}else{
ans+=n/x-1;
}
}
cout<<ans<<endl;
}
| 0
| 75,671,664
|
#include <bits/stdc++.h>
using namespace std;
vector<long> V;
void dfs(long n) {
if (n > 3234566667) return;
V.push_back(n);
int mi = max(0L, n % 10 - 1);
int mx = min(9L, n % 10 + 1);
for (long i = mi; i <= mx; i++) dfs(n * 10 + i);
}
int main() {
int K;
cin >> K;
for (int i = 1; i <= 9; i++) dfs(i);
sort(V.begin(), V.end());
cout << V.at(K - 1) << "\n";
}
|
#include <iostream>
#include <algorithm>
#include <vector>
int main()
{
int n;
while(true){
std::cin >> n;
if ( n == 0 ) break;
std::vector<int> v(n,0);
for ( int i = 0; i < n; ++i ) {
std::cin >> v[i];
}
std::sort(v.begin(), v.end());
int sum = 0;
for ( int i = 1; i < n-1; ++i ) {
sum += v[i];
}
std::cout << sum / (n-2) << std::endl;
}
return 0;
}
| 0
| 18,078,771
|
#include<cstdio>
#define ri register int
#define rc register char
#define ll long long int
#define rl register long long int
#define in inline
#define gc getchar
in int read()
{
ri x=0,p=1;
rc ch=gc();
while(ch<'0' || ch>'9')
{
if(ch=='-')
{
p=-1;
}
ch=gc();
}
while(ch>='0' && ch<='9')
{
x=x*10+ch-'0',ch=gc();
}
return x*p;
}
int a[100]={0,1,1,1,2,1,2,1,5,2,2,1,5,1,2,1,14,1,5,1,5,2,2,1,15,2,2,5,4,1,4,1,51};
int main()
{
ri k=read();
printf("%d\n",a[k]);
}
|
#include <bits/stdc++.h>
#include <math.h>
#include <float.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rrep(i, n) for(int i = 0; i <= (n); i++)
using namespace std;
typedef long long ll;
const ll INF = 1LL<<62;
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>
vector<T> make_vec(size_t a){
return vector<T>(a);
}
template<class T, class... Ts>
auto make_vec(size_t a, Ts... ts){
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
const int MOD = 1000000007;
int main(){
string S, T; cin >> S >> T;
map<char, set<char>> counterS, counterT;
rep(i,S.size()){
counterT[T[i]].insert(S[i]);
counterS[S[i]].insert(T[i]);
}
bool isOK = true;
for (char i = 'a'; i <= 'z'; i++){
if (counterS[i].size() > 1){
isOK = false;
}
if (counterT[i].size() > 1){
isOK = false;
}
}
if(isOK) cout << "Yes" << endl;
else cout << "No" << endl;
}
| 0
| 80,995,195
|
# include <iostream>
# include <algorithm>
# include <vector>
# include <string>
# include <set>
# include <map>
# include <cmath>
# include <iomanip>
# include <functional>
# include <utility>
# include <stack>
# include <queue>
# include <list>
constexpr int MOD = 1000000007;
constexpr int INF = 2000000000;
using namespace std;
int n, s;
int ans = 0;
void dfs(int pos, int sum,int count) {
if (count == n&&sum == s) {
ans++;
return;
}
if (pos == 10 || count == n) {
return;
}
dfs(pos + 1, sum + pos,count+1);
dfs(pos + 1, sum,count);
}
int main() {
while (cin >> n >> s&&(n != 0 || s != 0)) {
ans = 0;
dfs(0, 0, 0);
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair < ll, ll > PLL;
#define rep(i,n) for (int i = 0; i < (n); ++i)
ll MOD = 1e9+7;
int main() {
int n;
cin >> n;
vector<ll> a(n);
vector<ll> cnt(2, 0);
rep(i, n) cin >> a[i];
rep(i, n) {
ll b;
cin >> b;
if ( a[i] == b ) continue;
else if ( a[i] > b ) {
cnt[1] += a[i] - b;
}
else if ( ( b - a[i] ) % 2 == 0 ) {
cnt[0] += ( b - a[i] ) / 2;
}
else {
cnt[0] += ( b - a[i] ) / 2 + 1;
cnt[1] += 1;
}
}
if ( cnt[0] < cnt[1] ) cout << "No" << endl;
else cout << "Yes" << endl;
return 0;
}
| 0
| 5,706,741
|
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i=0;i<(n);++i)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define all(x) (x).begin(), (x).end()
#define PI 3.14159265358979323846264338327950L
using namespace std;
typedef long long ll;
typedef long double ld;
int main(){
int n;
cin>>n;
int i;
for(i=1;i<=7;i++){
if(n<pow(2,i)) break;
}
cout<<pow(2,i-1);
}
|
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#define Emax 9900
#define Vmax 100
#define Dmax (10000000)
#define INF (100000000000L)
using namespace std;
typedef unsigned int uint;
typedef long long int llint_t;
struct Edge {
int from, to, cost;
};
Edge edges[Emax];
static llint_t d[Vmax][Vmax];
static int Vnum, Enum;
void warshall_floyd() {
for (int i = 0; i < Vnum; i++) {
for (int j = 0; j < Vnum; j++) {
d[i][j] = INF;
}
d[i][i] = 0;
}
for (int i = 0; i < Enum; i++) {
auto e = edges[i];
d[e.from][e.to] = e.cost;
}
for (int k = 0; k < Vnum; k++) {
for (int i = 0; i < Vnum; i++) {
for (int j = 0; j < Vnum; j++) {
if (d[i][k] == INF || d[k][j] == INF) continue;
if (d[i][j] > d[i][k] + d[k][j]) {
d[i][j] = d[i][k] + d[k][j];
}
}
}
}
for (int i = 0; i < Vnum; i++) {
if (d[i][i] < 0) {
puts("NEGATIVE CYCLE");
exit(0);
}
}
}
int main(int ac, char **av) {
scanf("%d %d", &Vnum, &Enum);
for (int i = 0; i < Enum; i++) {
int s, t, d;
scanf("%d %d %d", &s, &t, &d);
Edge e;
e.from = s;
e.to = t;
e.cost = d;
edges[i] = e;
}
warshall_floyd();
for (int i = 0; i < Vnum; i++) {
for (int j = 0; j < Vnum; j++) {
if (d[i][j] == INF) {
printf("INF");
} else {
printf("%d", d[i][j]);
}
if (j != Vnum - 1) {
printf(" ");
} else {
printf("\n");
}
}
}
return 0;
}
| 0
| 32,856,046
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<utility>
#include<map>
#include<set>
#include <sstream>
#include<queue>
#include<stack>
#include<functional>
#include<math.h>
#include <iomanip>
#include <numeric>
#include <math.h>
using namespace std;
int main(void){
long H,N;
cin >> H >> N;
long sum = 0;
for(int i =0; i < N; i++){
long tmp = 0;
cin >> tmp;
sum += tmp;
}
if(sum >= H){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int K, S;
cin >> K >> S;
int pattern = 0;
for (int x=0; x<=K; ++x) {
for (int y=0; y<=K; ++y) {
int z = S - (x + y);
if ((z >= 0) && (z <= K)) {
++pattern;
}
}
}
cout << pattern << endl;
}
| 0
| 55,143,494
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <math.h>
#include <cstdlib>
#include <iomanip>
#define rep(i,x) for(ll i=0;i<x;i++)
#define all(a) (a).begin(),(a).end()
using namespace std;
using ld = long double;
using ll = long long;
const ll INF = 10010010010;
typedef pair<ll, ll> P;
using graph = vector<vector<ll>>;
const ll mod = 1000000007;
ll gcd(ll a, ll b) {
if (a < b)swap(a, b);
if (a % b == 0) return b;
else return gcd(b, a % b);
}
bool isp(ll n) {
bool res = true;
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
res = false;
break;
}
}
return res;
}
ll ctoi(char c) {
if (c == '0')return 0;
else if (c == '1')return 1;
else if (c == '2')return 2;
else if (c == '3')return 3;
else if (c == '4')return 4;
else if (c == '5')return 5;
else if (c == '6')return 6;
else if (c == '7')return 7;
else if (c == '8')return 8;
else if (c == '9')return 9;
else return -1;
}int main() {
ll M, N, O, P, L;
cin >> M >> N >> O >> P >> L;
ll cheap = min(min(M * 4, N * 2), O);
if (cheap * 2 <= P) {
cout << L * cheap << endl;
}
else {
cout << L / 2 * P + L % 2 * cheap << endl;
}
}
|
#include <iostream>
#include <stdio.h>
#include <fstream>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <limits.h>
#include <math.h>
#include <functional>
#include <bitset>
#define repeat(i,n) for (long long i = 0; (i) < (n); ++ (i))
#define debug(x) cerr << #x << ": " << x << '\n'
#define debugArray(x,n) for(long long i = 0; (i) < (n); ++ (i)) cerr << #x << "[" << i << "]: " << x[i] << '\n'
#define debugArrayP(x,n) for(long long i = 0; (i) < (n); ++ (i)) cerr << #x << "[" << i << "]: " << x[i].first<< " " << x[i].second << '\n'
using namespace std;
typedef long long ll;
typedef pair<int,int> Pii;
typedef vector<int> vint;
typedef vector<ll> vll;
const ll INF = LLONG_MAX/10;
const ll MOD = 1e9+7;
int main(){
ll ans = 0;
ll pow10 = 1e13;
ll many9 = pow10-1;
ll p10=1;
repeat(i,10){
ll low=i==0?0:-1,high=10;
while(high-low>1){
ll mid = (high+low)/2;
ll a = ans*10+mid;
cout << "? "<< a*pow10+many9 << endl;
char in;
cin >> in;
if(in == 'Y'){
high = mid;
}else{
low = mid;
}
}
if(high==0){
cout << "? "<<ans+1 << endl;
char in;
cin >> in;
if((in == 'Y')^(ans+1==p10)){
break;
}
}
ans = ans*10+high;
pow10 /=10;
many9 /=10;
p10 *= 10;
}
cout << "! " << ans << endl;
return 0;
}
| 0
| 59,579,526
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <map>
using namespace std;
typedef long long ll;
#define rep(i,n) for (int i=0;i < (int)(n);i++)
int dp[100010];
int rec(int x){
if (x == 0) return 0;
if (dp[x] != -1) return dp[x];
int res = x;
for (int pow6 = 1; pow6 <= x; pow6*=6){
res = min(res,rec(x-pow6)+1);
}
for (int pow9 = 1; pow9 <= x; pow9*=9){
res = min(res,rec(x-pow9) + 1);
}
return dp[x] = res;
}
int main(){
int n;
cin >> n;
int ans;
rep(i,n+1) dp[i] = -1;
cout << rec(n) << endl;
return 0;
}
|
#include <cstdio>
typedef long long LL;
int main() {
int Q, H, S, D; LL N;
scanf("%d%d%d%d%lld", &Q, &H, &S, &D, &N);
if (H > 2 * Q) H = 2 * Q;
if (S > 2 * H) S = 2 * H;
if (D > 2 * S) D = 2 * S;
printf("%lld\n", N / 2 * D + N % 2 * S);
return 0;
}
| 0
| 42,120,926
|
#include <bits/stdc++.h>
#define REP(i,n) for (int i = 0; i < (n); ++i)
template<class T> inline bool chmin(T& a, T b) {if (a > b) {a = b;return true;}return false;}
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b;return true;}return false;}
using namespace std;
using ll = long long;
using P = pair<int,int>;
using Pl = pair<long long,long long>;
using veci = vector<int>;
using vecl = vector<long long>;
using vecveci = vector<vector<int>>;
using vecvecl = vector<vector<long long>>;
int main() {
int N; cin >> N;
veci A(N);
REP(i,N) {
cin >> A[i];
A[i]--;
}
int ans = 0;
REP(i,N) {
if(A[A[i]] == i) ans++;
}
cout << ans/2 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
bool kei(vector<int> &moji,vector<bool> &op,int n,int x,bool b){
if(n==3){
if(b){
x+=moji.at(n);
}else{
x-=moji.at(n);
}
if(x==7){
op.at(n)=b;
return true;
}else{
return false;
}
}
if(b){
if(kei(moji,op,n+1,x+moji.at(n),true)){
op.at(n) = b;
return true;
}else if(kei(moji,op,n+1,x+moji.at(n),false)){
op.at(n) = b;
return true;
}
}else{
if(kei(moji,op,n+1,x-moji.at(n),true)){
op.at(n) = b;
return true;
}else if(kei(moji,op,n+1,x-moji.at(n),false)){
op.at(n) = b;
return true;
}
}
return false;
}
int main(){
string str;
cin >> str;
vector<int>moji(str.size());
vector<bool>op(str.size());
for(long unsigned int i=0;i < str.size();i++){
moji.at(i)= str.at(i)-48;
}
kei(moji,op,0,0,true);
for(int i=0;i<3;i++){
cout << moji.at(i);
if(op.at(i+1))
cout << "+";
else
cout << "-";
}
cout << moji.at(3) << "=7";
cout << endl;
}
| 0
| 64,600,728
|
#include <bits/stdc++.h>
#include <bits/stdint-intn.h>
#include <cstdint>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int64_t gcd(int64_t a, int64_t b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int main() {
int n, p;
std::cin >> n >> p;
std::vector<int> x(n);
rep(i, n) std::cin >> x[i];
if (n == 1) {
std::cout << abs(p - x[0]) << std::endl;
return 0;
}
int d = abs(x[0] - p);
for (int i = 0; i < n; ++i) {
d = gcd(d, abs(x[i] - p));
}
std::cout << d << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O0")
typedef long long int ll;
typedef long double ld;
#define rep(i,n) for (ll i = 0; i < (n); ++i)
const ll mod = 1e9+7;
const ll INF = 1e18;
#define All(a) (a).begin(),(a).end()
#define Pi acos(-1)
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << setprecision(15) << fixed;
chrono::system_clock::time_point start,end;
start = chrono::system_clock::now();
ll n;
cin >> n;
vector<ll> a(n+1);
rep(i,n) cin >> a[i];
a[n] = 1000000001;
sort(All(a));
ll ans = 0;
ll cnt = 1;
rep(i,n) {
if (a[i] == a[i+1]) {
++cnt;
}
else {
if (cnt >= a[i]) {
ans += cnt - a[i];
}
else {
ans += cnt;
}
cnt = 1;
}
}
cout << ans << '\n';
end = chrono::system_clock::now();
auto elapsed = chrono::duration_cast< chrono::milliseconds >(end - start).count();
cerr << elapsed << "ms" << '\n';
}
| 0
| 59,647,414
|
#include<bits/stdc++.h>
using namespace std;
#define INF (1<<20)
typedef pair<int,int> P;
vector<P> edge[10];
int dijkstre(int pos){
int min_cost[10];
fill_n(min_cost,10,INF);
priority_queue<P,vector<P>,greater<P> > que;
que.push(P(0,pos));
while(!que.empty()){
P p = que.top(); que.pop();
int cost = p.first;
int now = p.second;
if(min_cost[now] < cost) continue;
min_cost[now] = cost;
for(int i=0;i<edge[now].size();i++){
int nc = edge[now][i].second;
int next = edge[now][i].first;
if(cost+nc < min_cost[next]){
que.push(P(cost+nc,next));
}
}
}
int sum = 0;
for(int i=0;i<10;i++){
if(min_cost[i] != INF){
sum += min_cost[i];
}
}
return sum;
}
int main(){
int n;
while(1){
cin >> n;
if(n == 0) break;
int l=100,r=0;
for(int i=0;i<10;i++){
edge[i].clear();
}
for(int i=0;i<n;i++){
int a,b,c;
cin >> a >> b >> c;
edge[a].push_back(P(b,c));
edge[b].push_back(P(a,c));
l = min(min(l,a),b);
r = max(max(r,a),b);
}
int ans = INF;
int pos = l;
for(int i=l;i<=r;i++){
int tmp = dijkstre(i);
if(ans > tmp){
pos = i;
ans = tmp;
}
}
cout << pos << " " << ans << endl;
}
}
|
#include <vector>
#include <list>
#include <map>
#include <climits>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <queue>
#include <unordered_map>
#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL);
#define ln cout << endl;
#define vi vector<int>
#define vll vector<long long>
#define sortl(vec) sort(vec.begin(), vec.end());
#define sortr(vec) sort(vec.rbegin(), vec.rend());
#define forn(i, x, n) for(long long i = x; i < n; i++)
#define revn(i, n, x) for(long long i = n; i >= x; i--)
#define in(vec) for(auto &it : vec) cin >> it;
#define out(vec) for(auto &it : vec) cout << it << " "; ln
#define ll long long
#define pb emplace_back
#define mp make_pair
#define um unordered_map
#define pii pair<int, int>
#define pll pair<ll, ll>
#define f first
#define sec second
#define pi 3.14159265359
#define o(x) cout << x << endl;
#define CLOCK cerr<<"time taken : "<<(float)clock()/CLOCKS_PER_SEC<<" secs"<<endl;
using namespace std;
const ll NN = 2000005;
const ll mod = 1000000007;
ll bS(ll l, ll r, ll x, vll arr) {
while (l <= r) {
ll m = l + (r - l) / 2;
if (arr[m] == x)
return m;
if (arr[m] < x)
l = m + 1;
else
r = m - 1;
}
return -1;
}
void primeFactors(ll n) {
while (n % 2 == 0) {
n = n / 2;
}
for (ll i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
n = n / i;
}
}
if (n > 2)
cout << n << " ";
}
ll power(ll x, ll y, ll p) {
ll res = 1;
x = x % p;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
ll modulo(ll a, ll b) {
ll c = a % b;
return (c < 0) ? c + b : c;
}
ll mul(ll x, ll y) {
return (x * y) % mod;
}
ll inv(ll x) {
return power(x, mod - 2, mod);
}
ll divide(ll x, ll y)
{
return mul(x, inv(y));
}
ll fact[NN];
void precalc() {
fact[0] = 1;
for (ll i = 1; i < NN; i++)
fact[i] = mul(fact[i - 1], i);
}
ll nCr(ll n, ll k) {
return divide(fact[n], mul(fact[k], fact[n - k]));
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input1.txt", "r", stdin);
freopen("output1.txt", "w", stdout);
#endif
fastio
ll t = 1;
while (t--) {
ll x, y;
cin >> x >> y;
double m = (2 * x - y) / 3.0;
double n = (2 * y - x) / 3.0;
if (m != floor(m) || n != floor(n) || m < 0 || n < 0) {
o(0)
return 0;
}
precalc();
o(nCr(n + m, m));
}
CLOCK
return 0;
}
| 0
| 5,631,204
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
cin>>N;
vector<long long>A(N);
for(int i=0;i<N;i++){
cin>>A.at(i);
}
sort(A.begin(),A.end());
reverse(A.begin(),A.end());
vector<long long>Ans;
long long mark=-1;
long long cnt=0;
for(int i=0;i<N;i++){
if(mark==A.at(i)){
cnt++;
if(cnt==2){
Ans.push_back(A.at(i));
cnt=0;
}
}
else{
cnt=1;
mark=A.at(i);
}
}
if(Ans.size()<2){
cout<<0<<endl;
}
else{
cout<<Ans.at(0)*Ans.at(1)<<endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int getMaxPoint(vector<int> v,int &p){
int point=INT_MIN,act=-1;
for(int i=0;i<3;i++){
if(i==p)
continue;
if(v[i]>point){
point=v[i];
act=i;
}
}
p=act;
return point;
}
int main(){
int n;
cin>>n;
vector<vector<int> > vac(n,vector<int> (3));
for(int i=0;i<n;i++){
cin>>vac[i][0]>>vac[i][1]>>vac[i][2];
}
int activity=-1;
vector<vector<int> > dp(n,vector<int> (3));
dp[0]=vac[0];
for(int i=1;i<n;i++){
dp[i][0]=vac[i][0]+max(dp[i-1][1],dp[i-1][2]);
dp[i][1]=vac[i][1]+max(dp[i-1][0],dp[i-1][2]);
dp[i][2]=vac[i][2]+max(dp[i-1][0],dp[i-1][1]);
}
cout<<max(dp[n-1][0],max(dp[n-1][1],dp[n-1][2]))<<endl;
return 0;
}
| 0
| 99,268,695
|
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<math.h>
using namespace std;
int main()
{
int n,k; cin>>n>>k;
int a[n],sum=0;
for(int i=0;i<n;i++)
{
cin>>a[i];
if(a[i]>=k) sum++;
}
cout<<sum;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,D;
cin >> N >> D;
vector<vector<int>> X(N,vector<int>(D));
for(int i=0;i<N;i++){
for(int j=0;j<D;j++){
cin >> X.at(i).at(j);
}
}
int ans=0;
for(int i=0;i<N;i++){
for(int j=i;j<N;j++){
int d=0;
for(int k=0;k<D;k++){
d += (X.at(i).at(k)-X.at(j).at(k))*(X.at(i).at(k)-X.at(j).at(k));
}
bool h=false;
for(int k=1;k<sqrt(d)+1;k++){
if(k*k==d)h=true;
}
if(h==true)ans++;
}
}
cout << ans << endl;
}
| 0
| 47,599,753
|
#include "bits/stdc++.h"
#include <set>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i < (n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define all(i) (i).begin(), (i).end()
#define rall(i) (i).begin(), (i).end(), greater<int>()
#define int long long
#define elif else if
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define fst first
#define sec second
#define mod 1000000007
#define INF 10e10
template <typename T>
void print(T x)
{
std::cout << x << " ";
}
template <typename T>
void println(T x)
{
std::cout << x << "\n";
}
signed main(void) {
int h, w;
cin >> h >> w;
char s[51][51];
rep(i, h) {
rep(j, w) {
cin >> s[i][j];
}
}
int xx[] = { 0,1,0,-1 };
int yy[] = { 1,0,-1,0 };
rep(i, h) {
rep(j, w) {
if (s[i][j] == '.')continue;
int ok = false;
rep(k, 4) {
int ni = i + xx[k];
int nj = j + yy[k];
if (ni < 0 || h < ni)continue;
if (nj < 0 || w < nj)continue;
if (s[ni][nj] == '#')ok =true;
}
if (!ok) {
print("No");
return 0;
}
}
}
print("Yes");
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
using ll = long long;
int main(void){
int N, M;
cin >> N >> M;
vector<vector<pair<int, int>>> vv(N);
for (int i=0; i<M; i++){
int p, y;
cin >> p >> y;
p--;
vv[p].emplace_back(y, i);
}
vector<pair<int, int>> ans(M);
for (int i=0; i<N; i++){
sort(vv[i].begin(), vv[i].end());
for (int j=0; j<vv[i].size(); j++){
int index = vv[i][j].second;
ans[index] = make_pair(i+1, j+1);
}
}
for (int i=0; i<M; i++){
printf("%06d%06d\n", ans[i].first, ans[i].second);
}
}
| 0
| 10,668,132
|
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<int(n);i++)
#define rep1(i,n) for(int i=1;i<int(n);i++)
#define all(a) (a).begin(),(a).end()
using ll = long long;
using ld = long double;
using Pint = pair<int, int>;
const ll mod = 1e9+7;
int main()
{
int n;
string s, t;
cin>>n;
cin>>s>>t;
rep(i,s.size()) {
cout<<s[i]<<t[i];
}
cout<<endl;
return 0;
}
|
#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 repa(i,a,n) for(int i=(a); i<(int)(n); i++)
#define all(vec) vec.begin(),vec.end()
#define COUT(x) cout<<(x)<<endl
#define YES(x) cout<<(x?"YES":"NO")<<endl
#define Yes(x) cout<<(x?"Yes":"No")<<endl
using vi = vector<int>;
using vs = vector<string>;
using vvi = vector<vi>;
using pii = pair<int, int>;
using psi = pair<string, int>;
const int dx[4] = {1, 0,-1, 0};
const int dy[4] = {0, 1, 0,-1};
const int mod = 1e9+7;
int gcd(int a, int b){if(a%b == 0){return(b);}else{return(gcd(b, a%b));}}
int lcm(int a, int b){return a / gcd(a, b)*b;}
int N, M, K, H, W, L, R, X, Y;
string S, T;
signed main(){
cin >> S;
N = S.size();
if(S[0]!='A') {cout << "WA" << endl; return 0;}
int c = 0, cp;
for(int i = 2; i<=N-2; i++) if(S[i] == 'C') {c++; cp = i;}
if(c != 1) {cout << "WA" << endl; return 0;}
rep1(i,N){
if(i==cp) continue;
if(!islower(S[i])){cout << "WA" << endl; return 0;}
}
cout << "AC" << endl;
return 0;
}
| 0
| 59,543,556
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define rrep2(ri,x,n) for(int ri = (int)(n-1); ri >= (int)(x); ri--)
#define repit(itr,x) for(auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr,x) for(auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
bool fc(vector<string> &s, int n){
rep(i, n){
rep2(j, i+1, n){
if(s.at(i).at(j) != s.at(j).at(i)) return false;
}
}
return true;
}
int main(){
int n;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s.at(i);
vector<string> sn = s;
int ans = 0;
rep(q, n){
if(fc(sn, n) == true) ans++;
rep(i, n){
int ni = (i + q + 1) % n;
rep(j, n){
sn.at(i).at(j) = s.at(ni).at(j);
}
}
}
cout << ans*n << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <string.h>
#include <stack>
#include <queue>
#include <algorithm>
#include <climits>
#include <cmath>
#include <map>
#include <set>
#include <assert.h>
#include <sstream>
#define REP(i,n) for(ll i=0;i<(n);i++)
#define MOD 1000000007
#define int long long
#ifdef int
const long long INF = LLONG_MAX / 10;
#else
const int INF = 1010101010;
#endif
using namespace std;
typedef long long ll;
typedef vector<vector<ll>> mat;
typedef pair<int, int> P;
#ifdef LOCAL
#define dump(...) \
do { \
std::ostringstream os; \
os << __LINE__ << ":\t" << #__VA_ARGS__ << " = "; \
print_to(os, ", ", "\n", __VA_ARGS__); \
std::cerr << os.str(); \
} while (0)
#define dump_(a) \
do { \
std::ostringstream os; \
os << __LINE__ << ":\t" << #a << " = ["; \
print_to_(os, ", ", "]\n", all(a)); \
std::cerr << os.str(); \
} while (0)
#else
#define dump(...)
#define dump_(...)
#endif
template <typename T>
void print_to(std::ostream &os, const char *, const char *tail, const T &fst) {
os << fst << tail;
}
template <typename Fst, typename... Rst>
void print_to(std::ostream &os, const char *del, const char *tail, const Fst &fst, const Rst &... rst) {
os << fst << del;
print_to(os, del, tail, rst...);
}
template <typename Iter>
void print_to_(std::ostream &os, const char *del, const char *tail, Iter bgn, Iter end) {
for (Iter it = bgn; it != end;) {
os << *it;
if (++it != end) {
os << del;
} else {
os << tail;
}
}
}
template <typename Fst, typename... Rst>
void println(const Fst &fst, const Rst &... rst) {
print_to(std::cout, "\n", "\n", fst, rst...);
}
template <typename Fst, typename... Rst>
void print(const Fst &fst, const Rst &... rst) {
print_to(std::cout, " ", "\n", fst, rst...);
}
template <typename Iter>
void println_(Iter bgn, Iter end) {
print_to_(std::cout, "\n", "\n", bgn, end);
}
template <typename Iter>
void print_(Iter bgn, Iter end) {
print_to_(std::cout, " ", "\n", bgn, end);
}
namespace trush {
int _ = (std::cout.precision(10), std::cout.setf(std::ios::fixed), std::cin.tie(0),
std::ios::sync_with_stdio(0), 0);
}
int n, m;
string S, T;
int dp[1010][1010];
signed main()
{
cin >> S >> T;
n = S.length();
m = T.length();
S = '-' + S;
T = '-' + T;
REP(i,m+1) dp[0][i] = i;
REP(i,n+1) dp[i][0] = i;
for (int i=1; i<n+1; i++) {
for (int j=1; j<m+1; j++) {
if (S[i] == T[j]) {
dp[i][j] = min(dp[i-1][j-1], min(dp[i][j-1] + 1, dp[i-1][j] + 1));
} else {
dp[i][j] = min(dp[i-1][j-1] + 1, min(dp[i][j-1] + 1, dp[i-1][j] + 1));
}
}
}
cout << dp[n][m] << endl;
}
| 0
| 23,137,110
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2000006;
int main(){
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int n;
set<int> s;
cin>>n;
for(int i=0;i<n;i++){
int x;
cin>>x;
s.insert(x);
}
if((int)s.size() == n){
cout<<"YES";
}
else{
cout<<"NO";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
long long h,w;
cin >> h >> w;
if(h%3==0 || w%3==0){
cout << 0 << endl;
return 0;
}
long long dx[2]={h/3,h/3+1};
long long dy[2]={w/3,w/3+1};
long long m=10000000000;
for(long long i=1;i<w;i++){
long long s1,s2,s3;
long long p,q;
s1=h*i;
s2=(w-i)*(h/2);
s3=h*w-s1-s2;
p=max(s1,max(s2,s3));
q=min(s1,min(s2,s3));
m=min(m,p-q);
}
for(long long i=1;i<h;i++){
long long s1,s2,s3;
long long p,q;
s1=w*i;
s2=(h-i)*(w/2);
s3=h*w-s1-s2;
p=max(s1,max(s2,s3));
q=min(s1,min(s2,s3));
m=min(m,p-q);
}
m=min(m,min(h,w));
cout << m << endl;
}
| 0
| 21,299,710
|
#include <iostream>
using namespace std;
long long solve(long long x, long long n){
if (x == 0)
return 0;
if (x <= n / 2)
return n + solve(n - 2 * x, n - x);
else{
long long cnt = x / (n - x);
return 2 * cnt * (n - x) + solve(x - cnt * (n - x), n - cnt * (n - x));
}
}
int main(){
long long n, x;
cin >> n >> x;
cout << x + solve(x, n) << endl;
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long
#define itn int
#define endl '\n'
#define co(ans) cout<<ans<<endl
#define COYE cout<<"YES"<<endl
#define COYe cout<<"Yes"<<endl
#define COye cout<<"yes"<<endl
#define CONO cout<<"NO"<<endl
#define CONo cout<<"No"<<endl
#define COno cout<<"no"<<endl
#define FORE(i,a) for(auto &i:a)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define FFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) FFOR(i,1,n)
#define PB push_back
#define MP make_pair
#define ALL(V) (V).begin(),(V).end()
#define SORT(V) sort((V).begin(),(V).end())
#define REVERSE(V) reverse((V).begin(),(V).end())
#define EACH(V,i) for(typeof((V).begin()) i=(V).begin();i!=(V).end();++i)
#define equals(a,b) (fabs((a)-(b))<EPS)
#define INF ((1LL<<62)-(1LL<<31))
#define EPS 1e-10
#define PI 3.141592653589793238
#define MOD 1000000007
#define MAX 5100000
using namespace std;
using Edge=pair<ll,ll>;
using Graph=vector<vector<Edge>>;
inline int toInt(string s){int v;istringstream sin(s);sin>>v;return v;}
template<class T>inline string toString(T x){ostringstream sout;sout<<x;return sout.str();}
template<class T>bool chmax(T &a,const T &b){if(a<b){a=b;return 1;}return 0;}
template<class T>bool chmin(T &a,const T &b){if(b<a){a=b;return 1;}return 0;}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
const int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
int main(){
ll N;
cin>>N;
vector<ll> C(N+1,0),D(N+1,0),S(N+1,0),SS(N+1,0);
REP(i,N){
ll A;
cin>>A;
C[A]++;
D[C[A]]++;
}
RREP(i,N){
S[i]=S[i-1]+D[i];
SS[i]=S[i]/i;
}
ll X=N;
RREP(i,N){
while(X>0 && i>SS[X]) X--;
co(X);
}
return 0;
}
| 0
| 40,624,892
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0;i<(int)(n);i++)
using namespace std;
using ll=long long;
int main(){
int k,n;
cin>>k>>n;
int dis=-1;
int a[200010];
rep(i, n){
cin>>a[i];
if(i!=0){
int tmp=a[i]-a[i-1];
dis=max(dis,tmp);
}
}
int tmp=k+a[0]-a[n-1];
dis=max(dis,tmp);
cout<<k-dis<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for(int i = n-1; i >= 0; i--)
#define all(x) (x).begin(),(x).end()
#define rall(v) (v).rbegin(), (v).rend()
#define FastIO ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define sz(x) ((int)(x).size())
typedef long long ll;
using P = pair<int,int>;
using VI = vector<int>;
using VVI = vector<vector<int>>;
using VL = vector<ll>;
using VVL = vector<vector<ll>>;
using VP = vector<P>;
template<typename T> void view(T e){std::cout << e << std::endl;}
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return true; } return false; }
const int inf = 1 << 29;
const ll INF = 1LL << 61;
int main(){
int N, M, R;
cin >> N >> M >> R;
VI r(R);
rep(i, R) cin >> r[i];
rep(i, R) r[i]--;
VVI dist(N, VI(N, inf));
rep(i,M){
int a, b, c;
cin >> a >> b >> c;
a--; b--;
dist[a][b] = c;
dist[b][a] = c;
}
rep(k ,N) rep(i, N) rep(j, N){
chmin(dist[i][j], dist[i][k] + dist[k][j]);
}
VI rp(R);
rep(i, R) rp[i] = i;
int ans = inf;
do {
VI seq(R);
rep(i,R) seq[rp[i]] = r[i];
int sum = 0;
rep(i,R-1){
int st = seq[i];
int next = seq[i+1];
sum += dist[st][next];
}
ans = min(ans, sum);
} while(next_permutation(all(rp)));
cout << ans << endl;
return 0;
}
| 0
| 16,164,657
|
#include <iostream>
#include <algorithm>
#include <string>
int main(void){
std::string seq;
std::cin >> seq;
std::reverse(seq.begin(), seq.end());
std::cout << seq << std::endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define nl "\n"
#define PB push_back
#define _SAD() ios::sync_with_stdio(0),cin.tie(0), cout.tie(0);
#define SZ(s) s.size()
#define SRT(x,y) sort(x,x+y)
#define REV(a,b) reverse(a,a+b)
#define VSRT(x) sort(x.begin(),x.end())
#define VREV(x) reverse(x.begin(),x.end())
int main()
{
_SAD()
int a,b;
cin>>a>>b;
a--;
b--;
cout<<a*b<<nl;
return 0;
}
| 0
| 60,621,844
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(n); i++)
#define FOR(i,a,n) for(int i=(a); i<(n); i++)
#define all(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
const int INF = 1e9;
const int MOD = 1e9+7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
while (true) {
int n; cin >> n;
if (!n) break;
int ans = 0;
int state = -1;
rep(i, n) {
string x; cin >> x;
if (x[1]=='u') {
if (state == 1) ans++;
state = 1;
} else {
if (state == 0) ans++;
state = 0;
}
}
cout << ans << endl;
}
}
|
#include <iostream>
#include <algorithm>
#include <complex>
#include <utility>
#include <vector>
#include <string>
#include <queue>
#include <tuple>
#include <cmath>
#include <bitset>
#include <cctype>
#include <set>
#include <map>
#include <numeric>
#include <functional>
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(ll i=ll(a);i<ll(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(),(V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long;
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; }
inline void Yes(bool condition){ if(condition) PRINT("Yes"); else PRINT("No"); }
template<class itr> void cins(itr first,itr last){
for (auto i = first;i != last;i++){
cin >> (*i);
}
}
template<class itr> void array_output(itr start,itr goal){
string ans = "",k = " ";
for (auto i = start;i != goal;i++) ans += to_string(*i)+k;
if (!ans.empty()) ans.pop_back();
PRINT(ans);
}
ll gcd(ll a, ll b) {
return a ? gcd(b%a,a) : b;
}
const ll INF = 1e18;
const ll MOD = 1000000007;
typedef pair<ll,ll> P;
const ll MAX = 100010;
constexpr ll nx[8] = {1,0,-1,0,-1,-1,1,1};
constexpr ll ny[8] = {0,1,0,-1,-1,1,-1,1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll odd = 0,even = 0;
ll n,p,a;
cin >> n >> p;
rep(i,n){
cin >> a;
if (a%2) odd++;
else even++;
}
ll ans;
if (p == 0){
ans = pow(2,even)*(odd == 0 ? 1 : pow(2,odd-1));
}
else{
ans = pow(2,even)*(odd == 0 ? 0 : pow(2,odd-1));
}
PRINT(ans);
}
| 0
| 52,225,575
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<long int> H(N);
rep(i, N) cin >> H.at(i);
vector<long int> max_hights(N);
rep(i, N) max_hights.at(i) = 0;
vector<int> A(M);
vector<int> B(M);
rep(i, M) cin >> A.at(i) >> B.at(i);
int nice = 0;
long int max_height = 0;
rep(i, M) {
max_hights.at(A.at(i) - 1) = max(max_hights.at(A.at(i) - 1), H.at(B.at(i) - 1));
max_hights.at(B.at(i) - 1) = max(max_hights.at(B.at(i) - 1), H.at(A.at(i) - 1));
}
rep(i, N) if (max_hights.at(i) < H.at(i)) nice++;
cout << nice << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define fi first
#define se second
const int N = 110;
using namespace std;
int main()
{
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector < int > a(n);
long long inf = 1e18;
vector < long long > d(n + 1, - inf);
vector < long long > f(n + 1, - inf);
d[0] = 0;
for(int i = 0; i < n; i++){
cin >> a[i];
d[i + 1] = max(d[i + 1], d[i] + a[i] / 2);
d[i + 1] = max(d[i + 1], f[i] + a[i] / 2);
if(a[i] > 0)f[i + 1] = max(f[i + 1], d[i] + (a[i] - 1) / 2);
if(a[i] > 0)d[i + 1] = max(d[i + 1], f[i] + (a[i] - 1) / 2 + 1);
if(a[i] > 0)f[i + 1] = max(f[i + 1], f[i] + (a[i] - 1) / 2);
if(a[i] > 1)f[i + 1] = max(f[i + 1], f[i] + (a[i] - 2) / 2 + 1);
d[i] = max(d[i], f[i]);
}
cout << max(f.back(), d.back()) << "\n";
}
| 0
| 67,413,201
|
#include <bits/stdc++.h>
using namespace std;
int main(void){
int n;
cin >> n;
while(n--){
int a[3];
cin >> a[0] >> a[1] >> a[2];
bool tf=false;
for(int b=0; b<3; b++){
for(int c=0; c<3; c++){
if(b==c) continue;
for(int d=0; d<3; d++){
if(b==d || c==d) continue;
if((a[b]*a[b]+a[c]*a[c])==a[d]*a[d]) tf=true;
}
}
}
cout << (tf? "YES":"NO") << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll MOD=1000000007;
int main() {
int n; cin>>n;
vector<int> ans(26,51);
for(int i=0;i<n;i++){
string S; cin>>S;
vector<int> A(26,0);
for(int j=0;j<S.size();j++){
A[S[j]-'a']++;
}
for(int k=0;k<26;k++){
ans[k]=min(ans[k],A[k]);
}
}
for(int i=0;i<26;i++){
for(int j=0;j<ans[i];j++){
char a='a'+i;
cout<<a;
}
}
return 0;
}
| 0
| 84,787,102
|
#include <bits/stdc++.h>
#define rep(i,n)for(long long i=0;i<(n);i++)
using namespace std;
typedef long long ll;
const int MOD=1e9+7;
const int MAX = 1000000;
const int INF = 1e9;
const double pi=acos(-1);
using namespace std;
int main(){
int n;
cin >> n;
ll cnt=0;
vector<ll>a(n),b(n);
rep(i,n) cin >> a[i];
rep(i,n) cin >> b[i];
rep(i,n){
if(a[i]-b[i]>0)cnt-=a[i]-b[i];
if(b[i]-a[i]>0)cnt+=(b[i]-a[i])/2;
}
if(cnt>=0)cout<<"Yes"<<endl;
else cout <<"No"<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define INF 1000000000
using namespace std;
typedef long long ll;
int main() {
int A, B, C, D;
cin >> A >> B >> C >> D;
int Atim,Btim;
Atim = B-A;
Btim = D-C;
int start = max(A, C);
int endtime = min(B, D);
if (endtime - start > 0){
cout << endtime - start << endl;
}
else{
cout << 0 << endl;
}
}
| 0
| 75,335,330
|
#include<bits/stdc++.h>
using namespace std;
#define oo (long long)1e18
#define ll long long
#define setdp memset(dp,-1,sizeof(dp))
const ll mod = 1e9+7;
void _IOS(){ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);cin.sync_with_stdio(0);}
#define PI 3.14159265359
int sx,sy,tx,ty;
struct threeElements{
int _1st,_2nd,_3rd;
};
vector<vector<int>>adj(100);
ll n;
ll a[2000009];
bool check(string s,string t)
{
int n1=s.length(),n2=t.length(),j=0;
for(int i=0;i<n1;i++)
{
if(s[i]==t[j])
j++;
if(j==n2)
return 1;
}
return 0;
}
int main()
{
_IOS();
ll n,k;
cin>>n>>k;
map<ll,ll>mp;
for(int i=0;i<n;i++)
{
int a,b;
cin>>a>>b;
mp[a]+=b;
}
ll sum=0;
for(int i=1;i<=100000;i++)
{
sum+=mp[i];
if(sum>=k)
return cout<<i,0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<int>ans;
ll N, A, B;
void ind(){
for (int i = 0; i < A; ++i) {
ans.push_back(N - A + 1 + i);
}
N -= A; B--;
}
void solve(){
for (int i = B; i <= N; ++i) {
ans.push_back(i);
}
for (int i = B - 1; i > 0; --i) {
ans.push_back(i);
}
}
int main() {
cin >> N >> A >> B;
ans.reserve(N);
if (N + 1 < A + B || N > A * B) {
cout << -1 << "\n";
return 0;
}
int flag = 0;
if (A < B) {
flag = 1;
ll temp = A;
A = B;
B = temp;
}
if (N < A * 2) {
ind();
} else {
while (N > A * 2) {
ind();
}
for (int i = A + 1; i <= N; ++i) {
ans.push_back(i);
}
N = A;
B--;
}
if (B) solve();
if (flag) reverse(ans.begin(), ans.end());
for (int x: ans) cout << x << " ";
cout << "\n";
return 0;
}
| 0
| 85,378,054
|
#include <iostream>
#include <vector>
#include <cassert>
#include <algorithm>
#include <functional>
#include <cmath>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <map>
using ll = long long;
int MOD = 1e9 + 7;
using namespace std;
ll GCD(ll x, ll y)
{
if (y == 0)
{
return x;
}
else
{
return GCD(y, x % y);
}
}
ll LCM(ll x, ll y)
{
return x / GCD(x, y) * y;
}
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()
{
string s;
cin >> s;
for (int i = 0; i < 4;i++){
cout << s[i];
}
cout << " ";
for (int i = 5; i < 13;i++){
cout << s[i-1];
}
cout << endl;
}
|
#include <stdio.h>
#define _USE_MATH_DEFINES
#include <math.h>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int n,k,r,s,p;
scanf("%d %d", &n, &k);
scanf("%d %d %d", &r, &s, &p);
char t[n];
scanf("%s", t);
int nPoint = 0;
for(int i = 0; i < k; i++){
bool bCanWin = true;
for(int j = 0; j * k + i < n; j++){
if(!bCanWin){
bCanWin = true;
continue;
}
if(j * k + k + i < n){
if(bCanWin && t[j * k + i] == t[j * k + k + i]){
bCanWin = false;
}
}
if(t[j * k + i] == 'r'){
nPoint += p;
}
if(t[j * k + i] == 's'){
nPoint += r;
}
if(t[j * k + i] == 'p'){
nPoint += s;
}
}
}
printf("%d", nPoint);
return 0;
}
| 0
| 18,834,831
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
using pll = pair<ll,ll>;
#define INF (1LL << 60)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define REP(i,m,n) for(ll (i)=(m),(i_len)=(n);(i)<(i_len);++(i))
#define FORR(i,v) for(auto (i):v)
#define ALL(x) (x).begin(), (x).end()
#define PR(x) cout << (x) << endl
#define PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
#define REV(x) reverse(ALL((x)))
#define ASC(x) sort(ALL((x)))
#define DESC(x) ASC((x)); REV((x))
#define pb push_back
#define eb emplace_back
int main()
{
string S;
cin >> S;
ll zero = 0, one = 0;
REP(i,0,SZ(S)) {
if(S[i] == '0') ++zero;
else ++one;
}
PR(MIN(zero,one)*2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using vi=vector<int>;
using vvi=vector<vi>;
using vd=vector<double>;
using vvd=vector<vd>;
using vl=vector<ll>;
using vvl=vector<vl>;
using pii=pair<int,int>;
using vs=vector<string>;
#define rep(i,n) range(i,0,n)
#define range(i,a,n) for(int i=a;i<n;i++)
#define all(a) a.begin(),a.end()
#define LINF ((ll)1ll<<60)
#define INF ((int)1<<30)
#define EPS (1e-9)
#define MOD (1000000007)
#define fcout(a) cout<<setprecision(a)<<fixed
#define fs first
#define sc second
#define PI 3.141592653589793
template<class S,class T>ostream& operator<<(ostream&os,pair<S,T>p){os<<"["<<p.first<<", "<<p.second<<"]";return os;};
template<class S>auto&operator<<(ostream&os,vector<S>t){bool a=1; for(auto s:t){os<<(a?"":" ")<<s; a=0;} return os;}
vd fact_log10;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll x,y;
cin>>x>>y;
if(x>y)swap(x,y);
if(y-x<2){
cout<<"Brown"<<endl;
}else{
cout<<"Alice"<<endl;
}
}
| 0
| 18,997,888
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> plan(n,vector<int>(3));
for (int i = 0; i < n; i++){
for (int j = 0; j < 3; j++){
cin >> plan.at(i).at(j);
}
}
bool ans=true;
int nx=0;
int ny=0;
int nt=0;
for (vector<int> v: plan){
int t=v.at(0);
int x=v.at(1);
int y=v.at(2);
if(t-nt<abs(x-nx)+abs(y-ny)||(t-nt)%2!=(abs(x-nx)+abs(y-ny))%2){
cout << "No" << endl;
ans=false;
break;
}
nx=x;
ny=y;
nt=t;
}
if(ans){
cout << "Yes" << endl;
}
}
|
#define _GLIBCXX_DEBUG
#include"bits/stdc++.h"
using namespace std;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=(ll)(n)-1;i>=0;i--)
#define OneToN(i,n) for(ll i=1;i<(ll)(n+1);i++)
#define ZeroToN(i,n) for(ll i=0;i<(ll)(n+1);i++)
#define AToB(i,a,b) for(ll i=a;i<(ll)(b+1);i++)
#define FOR(i,a,b) for(ll i=(a);i<=(b);i++)
#define FORD(i,a,b) for(ll i=(a);i>=(b);i--)
#define BITSEARCH(bit, n) for (int bit = 0; bit < (1<<n); ++bit)
#define isOne(bit, i) bit & (1<<i)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define add push_back
template<typename T>
std::vector<T> slice(std::vector<T> const &v, int m, int n)
{
auto first = v.cbegin() + m;
auto last = v.cbegin() + n + 1;
std::vector<T> vec(first, last);
return vec;
}
#define remove_unique(v) v.erase(unique(ALL(v)), v.end())
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
#define fir first
#define sec second
#define mp make_pair
#define ll long long
#define vec vector
#define cord2d pair<int,int>
#define intP pair<int, int>
template <class T> T get(){ T s; cin >> s; return(s);}
#define gi get<int>()
#define gs get<string>()
#define gll get<ll>()
template <class T> vector<T> getv(int n) { vec<T> v(n); REP(i, n) cin >> v[i]; return v; }
#define gim(n) getv<int>(n)
#define gsm(n) getv<string>(n)
#define gllm(n) getv<ll>(n)
void print(int a){ cout << a << endl; }
void print(long long a){ cout << a << endl; }
void print(string a){ cout << a << endl; }
void print(char a){ cout << a << endl; }
void print(double a){ cout << a << endl; }
void print(double a, int dig){ cout << std::setprecision(dig) << a << endl; }
template <class T>ostream &operator<<(ostream &o,const vector<T>&v)
{o<<"{";for(int i=0;i<(int)v.size();i++)o<<(i>0?", ":"")<<v[i];o<<"}";return o;}
template <class T = int>
void print(vec<T> v){ cout << v << endl; }
template <class T = int>
void print2dVec(vec<vec<T>> v2d){for(vec<T> v: v2d) {print(v);}}
void YesNo1(bool i = true){ return print(i?"Yes":"No"); }
void YESNO2(bool i = true){ return print(i?"YES":"NO"); }
#define var_name(var) #var
template <class T> void debug(T &var, int nest = 0, string before = "") { cout << string(" ", nest) << before; print(var); }
#define y0 y0__
#define y1 y1__
#define j0 j0__
#define j1 j1__
#define lamb(exp) [](auto i){return exp;}
#define isEven [](int i){return i % 2 == 0;}
#define isOdd [](int i){return i % 2 != 0;}
const ll INF = 1e18;
const int MOD = 1000000007;
int factorial(int k){ int sum = 1; for (int i = 1; i <= k; ++i) { sum *= i; } return sum; }
ll gcd(ll a, ll b) { if (b == 0) { return a; } return gcd(b, a % b); }
ll lcm(ll a, ll b) { ll temp = gcd(a, b); return temp ? (a / temp * b) : 0; }
int dx[2] = {1, 0};
int dy[2] = {0, 1};
vec<vec<int>> counter;
int h,w;
void doDP(vector<vector<char>> &G, int x, int y) {
REP(i,2) {
int newX = x + dx[i];
int newY = y + dy[i];
if (!(0 <= newX && newX < w && 0 <= newY && newY < h)) continue;
if (G[y][x] == '.' && G[newY][newX] == '#') {
chmin(counter[newY][newX], counter[y][x] + 1);
} else {
chmin(counter[newY][newX], counter[y][x]);
}
}
}
void Main() {
string s = gs;
string keyence = "keyence";
REP(i1,s.size()-1) {
AToB(i2, i1, s.size()-1) {
if (keyence == s.substr(0, i1) + s.substr(i2, s.size()-i2)) {
print("YES");
return;
}
}
}
print("NO");
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
Main();
}
| 0
| 25,165,331
|
#pragma region Macros
#include <bits/stdc++.h>
using namespace std;
#define CHOOSE(a) CHOOSE2 a
#define CHOOSE2(a0,a1,a2,a3,a4,x,...) x
#define debug_1(x1) cout<<#x1<<": "<<x1<<endl
#define debug_2(x1,x2) cout<<#x1<<": "<<x1<<", "#x2<<": "<<x2<<endl
#define debug_3(x1,x2,x3) cout<<#x1<<": "<<x1<<", "#x2<<": "<<x2<<", "#x3<<": "<<x3<<endl
#define debug_4(x1,x2,x3,x4) cout<<#x1<<": "<<x1<<", "#x2<<": "<<x2<<", "#x3<<": "<<x3<<", "#x4<<": "<<x4<<endl
#define debug_5(x1,x2,x3,x4,x5) cout<<#x1<<": "<<x1<<", "#x2<<": "<<x2<<", "#x3<<": "<<x3<<", "#x4<<": "<<x4<<", "#x5<<": "<<x5<<endl
#ifdef LOCAL
#define debug(...) CHOOSE((__VA_ARGS__,debug_5,debug_4,debug_3,debug_2,debug_1,~))(__VA_ARGS__)
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define debug(...) 42
#define eprintf(...) 42
#endif
#define PI 3.1415926535897932384626433832795
#define INF 2e9
#define SINV(t) greater<t>()
#define REP(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define REPR(i, n) for(int i=(n); i>=0; --i)
#define FOR(i, n, m) for(int i=(m), i##_len=(n); i<i##_len; ++i)
#define FOREACH(i, v) for(const auto& i : v)
#define ALL(x) (x).begin(),(x).end()
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
typedef long long ll;
#define vv(t) vector< t >
#define CHC(mp, x) if(mp.end() != mp.find(x))
#define CHCV(mp, x) if(mp.end() != find(ALL(mp), x))
template<typename T>
inline T lcm(T a, T b) {return a / __gcd(a, b) * b;}
#pragma endregion
template<typename T>
void SV(vector<T> v){
#ifdef LOCAL
REP(i,v.size()){
cout << i << " : " << v[i] << endl;
}
#endif
}
template<typename T>
void SV(map<int, T> v){
#ifdef LOCAL
FOREACH(i, v){
cout << i.first << " : " << i.second << endl;
}
#endif
}
int bitCount(int bits) {
bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
return (bits & 0x0000ffff) + (bits >> 16);
}
int main(void){
int n=0;
cin >> n;
map<int, int> odd, even;
odd[0]=0, even[0]=0;
REP(i, n){
int v;
cin >> v;
if(i%2){
CHC(odd, v){}
else{
odd[v]=0;
}
odd[v]++;
}else{
CHC(even, v){}
else{
even[v]=0;
}
even[v]++;
}
}
int maxodd=0, maxeven=0;
int secondodd=0, secondeven=0;
FOREACH(i, odd){
if(odd[maxodd]<i.second){
secondodd=maxodd;
maxodd=i.first;
}else if(odd[secondodd]<i.second){
secondodd=i.first;
}
}
FOREACH(i, even){
if(even[maxeven]<i.second){
secondeven=maxeven;
maxeven=i.first;
}else if(even[secondeven]<i.second){
secondeven=i.first;
}
}
debug(maxodd, secondeven, maxeven, secondeven);
debug(even[maxeven]-even[secondeven], odd[maxodd]-odd[secondodd]);
if(maxeven==maxodd){
if(even[maxeven]-even[secondeven]>odd[maxodd]-odd[secondodd]){
maxodd=secondodd;
}else{
maxeven=secondeven;
}
}
cout << (n-even[maxeven]-odd[maxodd]) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
int main(void)
{
int N,H,W,cnt = 0,x0,x1,y0,y1,a,xi,yi,ans;
cin >> W >> H >> N;
x0 = 0;
y0 = 0;
x1 = W;
y1 = H;
rep(i, N){
cin >> xi >> yi >> a;
switch (a)
{
case 1:
x0 = max(xi,x0);
break;
case 2:
x1 = min(xi,x1);
break;
case 3:
y0 = max(yi,y0);
break;
default:
y1 = min(yi,y1);
break;
}
}
ans = (x1-x0)*(y1-y0);
if(x1-x0 < 0 || y1-y0 < 0)
ans = 0;
cout << ans << endl;
return 0;
}
| 0
| 53,495,726
|
#include <bits/stdc++.h>
#define rep3(i, s, n, a) for (int i = (s); i < (int)(n); i += a)
#define rep2(i, s, n) rep3(i, s, n, 1)
#define rep(i, n) rep2(i, 0, n)
using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int, int>;
int n;
vector<int> a;
void update(int i, int x);
int query(int x, int y, int k, int l, int r);
int main(){
int h, w, m, colmax=0;
cin >> h >> w >> m;
n = w;
rep(i, 30) {
if ((n - 1) < 1 << i) {
n = 1 << i;
break;
}
}
rep(i, 2 * n - 1) { a.push_back(0); }
vector<int> col(h, 0), row(w, 0);
vector<int> tmph;
vector<vector<int>> collist(h, tmph);
rep(i, m){
int x, y;
cin >> x >> y;
col[x-1]++;
row[y-1]++;
colmax = max(colmax, col[x-1]);
collist[x-1].push_back(y-1);
}
vector<int> cind;
vector<vector<int>> cmax;
rep(i, h){
if(col[i]==colmax){
cind.push_back(i);
cmax.push_back(collist[i]);
}
}
rep(i, w){
update(i, row[i]);
}
int clen=cmax.size(), res=0;
rep(i, clen){
int clislen = cmax[i].size();
rep(j, clislen){
update(cmax[i][j], row[cmax[i][j]]-1);
}
res = max(res, query(0, n, 0, 0, n));
rep(j, clislen) {
update(cmax[i][j], row[cmax[i][j]]);
}
}
cout << colmax + res << endl;
return 0;
}
void update(int i, int x) {
i += n - 1;
a[i] = x;
while (i > 0) {
i = (i - 1) / 2;
a[i] = max(a[i * 2 + 1], a[i * 2 + 2]);
}
}
int query(int x, int y, int k, int l, int r) {
if (r <= x || y <= l) return 0;
if (x <= l && r <= y)
return a[k];
else {
int vl = query(x, y, k * 2 + 1, l, (l + r) / 2);
int vr = query(x, y, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
long long M=0;
long long AA=0;
long long BB=0;
long long SS=0;
cin>>N;
vector<string>vec(N);
for(int X=0;X<N;X++){
cin>>vec.at(X);
string S=vec.at(X);
for(int Y=0;Y<S.size()-1;Y++){
if(S.at(Y)=='A'&&S.at(Y+1)=='B'){
M++;
}
}
if(S.at(S.size()-1)=='A'){
AA++;
}
if(S.at(0)=='B'){
BB++;
}
if(S.at(S.size()-1)=='A'&&S.at(0)=='B'){
SS++;
}
}
if(SS==AA&&SS==BB&&AA!=0&&BB!=0){
M--;
cout<<M+AA<<endl;
}
else{
cout<<M+min(AA,BB)<<endl;
}
}
| 0
| 62,140,730
|
#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;
using Graph = vector<vector<int>>;
#define MOD 1000000007
#define MOD2 998244353
#define INF ((1<<30)-1)
#define LINF (1LL<<60)
#define EPS (1e-10)
typedef long long ll;
typedef pair<ll, ll> P;
int main(){
int n;
cin >> n;
ll a[n];
rep(i, n) cin >> a[i];
ll ans = 0;
rep(i, n - 1){
ans += a[i] / 2;
if (a[i] % 2 == 1 && a[i+1] > 0){
ans++;
a[i+1]--;
}
}
ans += a[n-1] / 2;
cout << ans << endl;
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <set>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
#define mp(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define dbg(x) cout<<#x"="<<x<<endl
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
#define INF 1000000000
char t[9][5] = {
{'.',',','!','?',' '},
{'a','b','c',0,0},
{'d','e','f',0,0},
{'g','h','i',0,0},
{'j','k','l',0,0},
{'m','n','o',0,0},
{'p','q','r','s',0},
{'t','u','v',0,0},
{'w','x','y','z',0}};
int sz[9] = {5,3,3,3,3,3,4,3,4};
int main(){
int n;
scanf("%d\n", &n);
rep(i,n){
char last=0; int cnt=0;
while(true){
char c;
scanf("%c",&c);
if(c==last){
cnt++;
}
else if(c=='0' && last!=0){
printf("%c", t[last-'1'][cnt%sz[last-'1']]);
last=0;
cnt=0;
}
else if(c=='\n'){
break;
}
if(c!='0') last = c;
else last = 0;
}
cout << endl;
}
}
| 0
| 19,159,362
|
#include <stdio.h>
int main(void){
int a, b, c;
int n = 0;
scanf("%d %d %d", &a, &b, &c);
for (int i = a; i <= b; i++) {
if (!(c % i)) n++;
}
printf("%d\n", n);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define loop(i,s,e) for(ll i=s;i<e;i++)
#define test ll x;cin>>x;while(x--)
#define pb push_back
#define vec vector<ll>
#define sortvec(x) sort(x.begin(),x.end())
#define sz(x) x.size()
int main () {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n,k;
cin>>n>>k;
ll a[n];
ll sum=0;
loop(i,0,n)
{
cin>>a[i];
sum+=a[i];
}
ll red=0,pos;
loop(i,0,n-1)
{
if (a[i]+a[i+1]>=k)
{
pos=i+1;
red=1;
break;
}
}
if (red==0)
cout<<"Impossible\n";
else
{
cout<<"Possible\n";
loop(i,1,pos)
cout<<i<<"\n";
for(ll i=n-1;i>pos;i--)
cout<<i<<"\n";
cout<<pos<<"\n";
}
}
| 0
| 23,965,527
|
#include<bits/stdc++.h>
using namespace std;
#define Fast ios_base::sync_with_stdio(0);cin.tie(0),cout.tie(0)
#define FO freopen("in.txt", "r", stdin)
#define FC freopen("out.txt", "w", stdout)
#define aise cout<<"aise"<<endl
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define mp make_pair
#define ll long long
#define all(x) x.begin(), x.end()
#define mset(v, a) memset(v, a, sizeof(v))
#define pll pair< ll, ll >
#define pdd pair< double, double >
#define ff first
#define ss second
#define pi acos(-1.0)
#define mxN 2010
#define inf 1e14
#define mod 1000000007
int main()
{
string a,b;
ll tf=0;
cin >> a >> b;
if(a.size() != b.size())
{
if(a.size() > b.size()) tf=1;
else if(a.size() < b.size()) tf=2;
}
else
{
for(ll i=0; i < a.size(); i++)
{
ll x=a[i] - '0';
ll y=b[i] - '0';
if(x!=y)
{
if(x > y) tf=1;
else tf=2;
break;
}
}
}
if(tf==1) cout << "GREATER";
else if(tf==2) cout << "LESS";
else cout << "EQUAL";
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <numeric>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <time.h>
#include <list>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int i=0;i<(n);++i)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define reps(x,c) for(auto x:c)
#define all(x) begin(x), end(x)
#define pb(a) emplace_back(a)
#define mp(a,b) make_pair((a),(b))
#define pl pair<ll,ll>
#define INF 2147483600
#define MOD 1000000007
#define fi first
#define se second
#define dbg(x) cout << #x"="<< (x) << endl
#define dbgv(x) cout<<#x<<endl;reps(y,x){cout<<y<<" ";}cout<<endl
int table[110][110];
int main(){
ll a,b;cin>>a>>b;
cout<<100<<" "<<100<<endl;
rep(i,100){
rep(j,100){
if(i<50){
table[i][j]=1;
}
}
}
a--;
b--;
rep(i,50){
if(i%2==0){
rep(j,100){
if(a==0){
break;
}
if(j%2==0){
table[i][j]=0;
a--;
}
}
}
}
FOR(i,50,100){
if(i%2==1){
rep(j,100){
if(b==0){
break;
}
if(j%2==0){
table[i][j]=1;
b--;
}
}
}
}
rep(i,100){
rep(j,100){
if(table[i][j]==0){
cout<<".";
}else{
cout<<"#";
}
}
cout<<endl;
}
return 0;
}
| 0
| 83,592,948
|
#include<bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define x first
#define y second
#define ll long long
#define lll __int128
#define ull unsigned long long
#define ulll unsigned __int128
#define pii pair<int,int>
#define pb push_back
#define eb emplace_back
#define gu getchar_unlocked()
#define pu putchar_unlocked()
#define all(x) x.begin(),x.end()
#define endl '\n'
const int mx=100010;
ll arr[mx];
int n;
int main()
{
memset(arr,5,sizeof arr);
cin>>n;
for(int i=1;i<n;i++){
ll a;
cin>>a;
arr[i-1]=min(arr[i-1],a);
arr[i]=min(arr[i],a);
}
ll s=0;
for(int i=0;i<n;i++)s+=arr[i];
cout<<s<<endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
#include <cmath>
#include <tuple>
#include <cstdio>
#include <bitset>
#include <sstream>
#include <iterator>
#include <numeric>
#include <map>
#include <cstring>
#include <set>
#include <functional>
#include <iomanip>
using namespace std;
#define DEBUG_
#ifdef DEBUG_
#define dump(x) cerr << #x << " = " << (x) << endl;
#else
#define dump(x) ;
#endif
#define EPS (1e-10)
#define equals(a,b) (fabs((a)-(b)) < EPS)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define SZ(x) ((int)(x).size())
#define pb push_back
#define eb emplace_back
typedef long long LL;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
template <typename T>
std::string printVector(const std::vector<T> &data)
{
std::stringstream ss;
std::ostream_iterator<T> out_it(ss, ", ");
ss << "[";
std::copy(data.begin(), data.end() - 1, out_it);
ss << data.back() << "]";
return ss.str();
}
const int MOD = 1e9+7;
const LL LINF = 1001002003004005006ll;
const int INF = 1001001001;
int nth_bit(int x, int n){
return (x >> n) & 1;
}
signed main(int argc, char const *argv[])
{
cin.tie(0);
ios::sync_with_stdio(false);
int N,K; cin >> N >> K;
vector<string> c;
VI A(N);
VL B(N);
REP(i,N) cin >> A[i] >> B[i];
string ck;
REP(_,32){
ck += char('0'+K%2);
K /= 2;
}
reverse(ck.begin(),ck.end());
c.eb(ck);
int ck_len = ck.length();
FOR(i,0,ck_len){
if(ck[i] == '1'){
string tmp = ck.substr(0,i);
tmp += '0';
tmp += string(ck_len-1-i,'1');
c.eb(tmp);
}
}
LL ans = 0;
for(auto s : c){
reverse(s.begin(),s.end());
LL tmp = 0;
REP(i,N){
bool ok = 1;
REP(j,32){
if(nth_bit(A[i],j) == 0 || s[j] == '1'){
}else{
ok = 0;
}
}
if(ok) tmp += B[i];
}
ans = max(ans,tmp);
}
cout << ans << endl;
}
| 0
| 15,066,337
|
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<pair<long long int, long long int>> vec(N);
for(int i=0; i<N; i++){
cin >> vec[i].first >> vec[i].second;
}
sort(vec.begin(),vec.end());
long long int cost=0;
long long int bought = 0;
for(int i=0; i<N; i++){
if(bought + vec[i].second < M){
bought += vec[i].second;
cost += vec[i].first * vec[i].second;
}
else{
cost += vec[i].first * (M - bought);
bought += M - bought;
break;
}
}
cout << cost << endl;
}
|
#include <iostream>
#include <iomanip>
using namespace std;
const long INF = 1e9;
const long MOD = 1e9 + 7;
#define repi(i, n, init) for (int i = init; i < int(n); i++)
int main()
{
char a, b;
cin >> a >> b;
if (a == 'H')
{
cout << b << endl;
}
else if (b == 'H')
{
cout << 'D' << endl;
}
else
{
cout << 'H' << endl;
}
return 0;
}
| 0
| 44,263,960
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, l, r) for(ll i = l; i < (r); i++)
#define rep(i, N) FOR(i, 0, N)
typedef long long ll;
typedef pair<int,int> P;
typedef vector<int> vi;
typedef vector<ll> vl;
const ll MOD = round(1e9+7);
int main() {
int N; cin >> N;
int ans = 0;
rep(i,N){
if(i+1 < 105) continue;
int num = i+1;
if(num%2==0) continue;
int tmp = 0;
rep(j,num){
if(num % (j+1) == 0) tmp++;
}
if(tmp == 8) ans++;
}
cout << ans << "\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
map<ll, ll> m;
for (ll i = 0;i < 6;++i) {
ll a;
cin >> a;
m[a]++;
}
for (auto p : m) {
if (p.second > 2) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 0
| 98,932,377
|
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <map>
#include <algorithm>
#include <math.h>
#include <cassert>
#define rep(i,n) for(int i = 0; i < n; ++i )
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
int n;
cin >> n;
vector<int> idx(n);
rep(i,n){
int p;
cin >> p;
idx[p-1] = i;
}
ll ans = 0;
set<int> s;
for(int x = n-1; x>=0; --x){
int i = idx[x];
vector<ll> l(2,-1), r(2,n);
s.insert(i);
auto itrl = s.find(i);
auto itrr = itrl;
rep(ii,2){
if(itrl==s.begin()) break;
--itrl;
l[ii] = *itrl;
}
rep(ii,2){
++itrr;
if(itrr==s.end()) break;
r[ii] = *itrr;
}
ans += (x+1)*((i-l[0])*(r[1]-r[0])+(l[0]-l[1])*(r[0]-i));
}
cout << ans << endl;
}
|
#ifdef LOCAL
#define _GLIBCXX_DEBUG
#define __clock__
#else
#pragma GCC optimize("Ofast")
#endif
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<ll>;
using VV = vector<VI>;
using VS = vector<string>;
using PII = pair<ll, ll>;
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 += "}";
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 << '\n'; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
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; }
#define FOR(i,a,b) for(ll i=(a);i<(b);++i)
#define rep(i,b) FOR(i, 0, b)
#define ALL(v) (v).begin(), (v).end()
#define p(s) cout<<(s)<<'\n'
#define p2(s, t) cout << (s) << " " << (t) << '\n'
#define br() p("")
#define pn(s) cout << (#s) << " " << (s) << '\n'
#define SZ(x) ((int)(x).size())
#define SORT(A) sort(ALL(A))
#define RSORT(A) sort(ALL(A), greater<ll>())
#define MP make_pair
#define p_yes() p("Yes")
#define p_no() p("No")
ll SUM(VI& V){
return accumulate(ALL(V), 0LL);
}
ll MIN(VI& V){return *min_element(ALL(V));}
ll MAX(VI& V){return *max_element(ALL(V));}
void print_vector(VI& V){
ll n = V.size();
rep(i, n){
if(i) cout << ' ';
cout << V[i];
}
cout << endl;
}
ll gcd(ll a,ll b){
if(b == 0) return a;
return gcd(b,a%b);
}
ll lcm(ll a,ll b){
ll g = gcd(a,b);
return a / g * b;
}
using ld = long double;
#define EPS (1e-14)
#define equals(a,b) (fabs((a)-(b)) < EPS)
void no(){p_no(); exit(0);}
void yes(){p_yes(); exit(0);}
const ll mod = 1e9 + 7;
const ll inf = 1e18;
const double PI = acos(-1);
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin>>N;
VI A(N);
rep(i, N) cin >> A[i];
VI B(N);
rep(i, N) cin >> B[i];
ll sum_a = SUM(A);
ll sum_b = SUM(B);
if(sum_a>sum_b){
no();
}
ll diff = sum_b - sum_a;
ll a_add_cnt=0;
ll b_add_cnt=0;
rep(i,N){
if(A[i]==B[i]) continue;
if(A[i]>B[i]){
b_add_cnt += A[i]-B[i];
}
else if(A[i]<B[i]){
ll d = B[i]-A[i];
a_add_cnt += (d+1)/2;
}
}
ll ma = max(a_add_cnt, b_add_cnt);
if(ma<=diff){
yes();
}else{
no();
}
return 0;
}
| 0
| 581,363
|
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <unordered_set>
#include <queue>
#include <deque>
#include <string>
#include <sstream>
#include <iomanip>
#include <map>
#include <unordered_map>
#include <stack>
#include <cstdio>
#include <climits>
#include <tuple>
#include <ctime>
#include <cstring>
#define FOR(i,a,n) for (int i = a; i < n; i++)
#define IFOR(i,n,a) for (int i = n; i >= a; i--)
#define mp make_pair
#define full(a) a.begin(), a.end()
#define sz(x) ((int)(x).size())
#define pii pair<int, int>
#define trav(a,x) for (auto& a : x)
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
using namespace std;
const int mod = 998244353;
const int N = 1e5 + 5;
int main()
{
ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
int n; cin >> n;
double res = 0;
FOR(i, 0, n)
{
double a; cin >> a;
res += (1 / a);
}
res = 1 / res;
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
int main(void) {
int a, b; cin >> a >> b;
int k; cin >> k;
rep(i, k) {
if(i%2 == 0) {
if(a&1) a--;
b += a/2;
a = a/2;
} else {
if(b&1) b--;
a += b/2;
b = b/2;
}
}
cout << a << " " << b << endl;
}
| 0
| 68,335,487
|
#include<bits/stdc++.h>
#define ll long long
#define F(i,a,b) for(ll i=a;i<b;i++)
#define RF(i,a,b) for(ll i=a;i>b;i--)
#define pii pair<ll,ll>
#define ff first
#define ss second
#define pb(x) push_back(x)
#define pob pop_back
#define mp(x,y) make_pair(x,y)
#define mod 1000000007
#define w(t) int t; cin>>t;while(t--)
using namespace std;
const int inf=(int)1e9;
char flip_bits(char c){return (c == '0')? '1': '0';}
bool isPrime(int n)
{
if (n <= 1)
return false;
for (int i = 2; i < n; i++)
if (n % i == 0)
return false;
return true;
}
ll numberOfOneBitsInInteger(ll input) {
ll numOneBits = 0;
ll currNum = input;
while (currNum != 0) {
if ((currNum & 1) == 1) {
numOneBits++;
}
currNum = currNum >> 1;
}
return numOneBits;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
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";
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
const int m=1e9+7;
int main(){
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
fastio
int n,m,x,y;
cin>>n>>m>>x>>y;
int x1[n];
for(int i=0;i<n;++i) cin>>x1[i];
int y1[m];
for(int i=0;i<m;++i) cin >>y1[i];
sort(x1,x1+n);
sort(y1,y1+m);
if(x1[n-1]<y1[0] && x1[n-1]>x && x1[n-1]<y) cout<<"No War";
else cout<<"War";
return 0;
}
| 0
| 80,516,297
|
#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
#include<set>
#include<string>
#include<map>
#include<string.h>
#include<complex>
#include<math.h>
#include<queue>
#include <functional>
#include<time.h>
#include <stack>
#include<iomanip>
using namespace std;
#define rep(i,a,n) for(int i=(a);i<(n);i++)
#define ll long long
#define llint long long int
#define reverse(v) reverse(v.begin(), v.end());
#define Yes(ans) if(ans)cout<<"Yes"<<endl; else cout<<"No"<<endl;
#define YES(ans) if(ans)cout<<"YES"<<endl; else cout<<"NO"<<endl;
#define hei(a) vector<a>
#define whei(a) vector<vector<a>>
#define UF UnionFind
#define Pint pair<int,int>
#define keta(a) fixed << setprecision(a)
constexpr auto INF = 1000000000;
constexpr auto mod = 1000000007;
llint gcd(llint a, llint b) {
if (b > a)swap(a, b);
if (a % b == 0)return b;
return gcd(b, a % b);
}
llint Tow(int m,int n) {
if (n == 0)return 1;
llint x = Tow(m,n / 2);
x *= x;
if (n % 2 == 1)x *= m;
return x;
}
ll max(ll a, ll b) {
if (a < b)return b;
else return a;
}
int main() {
llint n, k;
cin >> n >> k;
llint s = (n / k);
llint ans;
if(k%2==1)ans= s * s * s;
if (k % 2 == 0) {
ans = pow((n/(k/2)) - (n / k), 3);
ans += pow((n / k), 3);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a,b,m;
cin>>a>>b>>m;
vector<int>aprice(a);
vector<int>bprice(b);
vector<vector<int>> data(m, vector<int>(3));
for(int i=0;i<a;i++){
cin>>aprice[i];
}
for(int i=0;i<b;i++){
cin>>bprice[i];
}
for (int j = 0; j < m ; j++) {
for (int k = 0; k < 3; k++) {
cin >> data.at(j).at(k);
}
}
int pp=aprice.at(data.at(0).at(0)-1)+bprice.at(data.at(0).at(1)-1)-data.at(0).at(2);
for(int i=0;i<m;i++){
int x=aprice.at(data.at(i).at(0)-1)+bprice.at(data.at(i).at(1)-1)-data.at(i).at(2);
if(x <=pp){
pp =x;
}
}
sort(aprice.begin(),aprice.end());
sort(bprice.begin(),bprice.end());
int t=aprice[0]+bprice[0];
if(t<=pp){
pp=t;
}
cout<<pp<<endl;
}
| 0
| 81,994,696
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<cmath>
#include<cstdio>
#include<queue>
#include<deque>
#include<map>
#include<stack>
#include<set>
#include<utility>
using namespace std;
typedef pair<int,int> ii;
typedef long long ll;
typedef pair<ll,ii> P;
typedef unsigned long long int ull;
const int MOD=1e9+7;
int dy[]={1,0};
int dx[]={0,1};
const int MAXN=100000;
const int MAXE=100000;
const int MAXV=10000;
const ll INF=2e18;
int h,w;
vector<vector<char> > G(100,vector<char>(100));
vector<vector<ll> > d(100,vector<ll>(100,INF));
ll dijkstra(){
priority_queue<P,vector<P>,greater<P> > que;
que.push(P(0,ii(0,0)));
d[0][0]=1;
while(!que.empty()){
P p=que.top();que.pop();
ll cst=p.first;
int y=p.second.first;
int x=p.second.second;
if(d[y][x]<cst) continue;
for(int i=0;i<2;i++){
int ny=y+dy[i];
int nx=x+dx[i];
if(ny>=0&&ny<h&&nx>=0&&nx<w&&d[ny][nx]>d[y][x]+(G[y][x]==G[ny][nx]?0:1)){
d[ny][nx]=d[y][x]+(G[y][x]==G[ny][nx]?0:1);
que.push(P(d[ny][nx],ii(ny,nx)));
}
}
}
return d[h-1][w-1];
}
int main(){
cin>>h>>w;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
cin>>G[i][j];
}
}
ll ans=dijkstra()/2+((G[0][0]=='#'&&G[h-1][w-1]=='#')?1:0);
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n,K;
ll x[55];
ll y[55];
int main(){
cin >> n >> K;
vector<ll> dx;
vector<ll> dy;
for(ll i=0;i<n;i++){
cin >> x[i] >> y[i];
dx.push_back(x[i]);
dy.push_back(y[i]);
}
sort(dx.begin(),dx.end());
sort(dy.begin(),dy.end());
ll res=abs(dx[n-1]-dx[0])*abs(dy[n-1]-dy[0]);
for(ll i=0;i<n;i++){
for(ll k=i+1;k<n;k++){
for(ll j=0;j<n;j++){
for(ll l=j+1;l<n;l++){
ll lx=dx[i],rx=dx[k],ly=dy[j],ry=dy[l];
ll count=0;
for(ll c=0;c<n;c++){
if(lx<=x[c]&&x[c]<=rx&&ly<=y[c]&&y[c]<=ry) count++;
}
if(K<=count) res=min(res,abs(rx-lx)*abs(ry-ly));
}
}
}
}
cout << res << endl;
return 0;
}
| 0
| 82,051,613
|
#include <iostream>
using namespace std;
int main() {
int n, a[100];
int count = 0;
int mini;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
mini = i;
for (int j = i; j < n; j++) {
if (a[j] < a[mini]) {
mini = j;
}
}
if (a[i] != a[mini]) {
swap(a[i], a[mini]);
count++;
}
}
for (int i = 0; i < n - 1; i++){
cout << a[i] << ' ';
}
cout << a[n - 1] << endl;
cout << count << endl;
return 0;
}
|
#pragma region header
#include <bits/stdc++.h>
#define int long long
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define resort(v) sort((v).rbegin(), (v).rend())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
using ll = long long;
using P = pair<int, int>;
int dx[] = {1,0,-1,0};
int dy[] = {0,1,0,-1};
constexpr ll mod = 1e9+7;
constexpr int inf = INT32_MAX/2;
constexpr ll INF = LLONG_MAX/2;
constexpr long double eps = DBL_EPSILON;
constexpr long double pi = 3.141592653589793238462643383279;
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll fact(int i) {
if (i == 0) return 1;
return (fact(i - 1)) * i % mod;
}
ll gcd(ll a, ll b) {
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
return a * b / gcd(a, b);
}
int keta(ll n) {
if(n == 0) return 1;
int count = 0;
while(n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) {
ll sum = 0;
while(n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
#pragma endregion
signed main() {
int n,m;cin >> n >> m;
int sum=0;
rep(i, m) {
int a;cin >> a;
sum+=a;
}
int ans = n - sum;
if(ans<0) cout << -1 << endl;
else cout << ans << endl;
return 0;
}
| 0
| 55,328,191
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ld long double
#define mp make_pair
#define ff first
#define ss second
#define pb push_back
#define fo(i,n) for(i=0;i<n;i++)
#define fo1(i,n) for(i=1;i<=n;i++)
#define FO(i,k,n) for(i=k;k<=n?i<=n:i>=n;k<=n?i++:i--)
#define all(c) c.begin(),c.end()
#define rall(c) c.rbegin(),c.rend()
#define si set<int>
#define vi vector<int>
#define mii map<int,int>
#define pii pair<int,int>
#define vpii vector<pii>
#define vvi vector<vi>
#define usi unordered_set<int>
#define umii unordered_map<int,int>
#define pqmx priority_queue<int>
#define pqmn priority_queue<int,vi,greater<int> >
#define sp(x) cout<<setprecision(x)<<fixed;
#define setbits(x) __builtin_popcountll(x)
#define zerobits(x) __builtin_ctzll(x)
#define in(a,n) vi a(n);fo(i,n)cin>>a[i];
#define in1(a,n) vi a(n+1);fo1(i,n)cin>>a[i];
#define w(t) int t;cin>>t;while(t--)
#define sz(v) (int)v.size()
#define gcd __gcd
#define lcm(x,y) x*(y/gcd(x,y))
#define endl '\n'
#define PI 3.14159265358979323846
const int inf = 1e18;
const int mod = 1e9+7;
void __p(int x) {cout<<x;}
void __p(int32_t x){cout<<x;}
void __p(float x){cout<<x;}
void __p(double x){cout<<x;}
void __p(ld x) {cout<<x;}
void __p(char x){cout <<'\''<<x<<'\'';}
void __p(const char *x){cout <<'\"' <<x<<'\"';}
void __p(const string &x) {cout<<'\"'<<x<<'\"';}
void __p(bool x) {cout<<(x?"true":"false");}
void _p() {cout << "]\n";}
template<typename T,typename V> void __p(const pair<T,V> &x) {cout<<'{';__p(x.first);cout<<',';__p(x.second);cout<<'}';}
template<typename T> void __p(const T &x) {int f = 0; cout << '{'; for (auto &i: x) cout << (f++ ? "," : ""), __p(i); cout << "}";}
template <typename T,typename... V> void _p(T t, V... v) {__p(t);if(sizeof...(v))cout<<", ";_p(v...);}
int po(int x,int p,int m = inf) {int ans=1;x%=m;while(p>0){if(p&1)ans=(ans*x)%m;p=p>>1;x=(x*x)%m;}return ans;}
int inv(int x,int m=mod){return po(x,m-2,m)%m;}
#ifndef ONLINE_JUDGE
#define dbg(x...) cout<<"["<<#x<<"]=[";_p(x)
#else
#define dbg(x...)
#endif
const int N=1e6+6;
int n,m,k,x,y,z,a,b,c,d,i,j,l,r,f;
void sol()
{
cin>>n>>m;
string a,b;
fo(i,n)a+=char(m+'0');
fo(i,m)b+=char(n+'0');
cout<< ((a<b)?a:b) <<endl;
}
int32_t main()
{
ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
sol();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const long long INF = 1LL << 60;
const ll C = 1e9+7;
int main(){
string S, T;
cin >> S >> T;
int ns = S.size();
int nt = T.size();
vector<string> V;
bool flg;
string ss;
for(int i=0; i<ns-nt+1; i++) {
flg = true;
for(int j=0; j<nt; j++) {
if(S[i+j] != T[j] && S[i+j] != '?') {
flg = false;
}
}
cout << endl;
if (flg) {
ss = S;
ss.replace(i, nt, T);
}
}
if(ss == "") {
cout << "UNRESTORABLE" << endl;
return 0;
}
for(int i=0; i<ss.size(); i++) {
if(ss[i] == '?') {
cout << 'a';
}
else {
cout << ss[i];
}
}
}
| 0
| 64,098,672
|
#include <iostream>
using namespace std;
int main(){
int n;
long long int fib1,fib2,fib3;
cin>>n;
fib1=1;
fib2=1;
if(n==0){
cout<<0<<endl;
}else if(n==1){
cout<<1<<endl;
}else if(n>=2){
for(int i=0;i<n-1;i++){
fib3=fib1+fib2;
fib1=fib2;
fib2=fib3;
}
cout<<fib3<<endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
string s, s1;
int k;
int ans[3];
int main()
{
while (cin >> s >> k)
{
s1 = s + s + s;
for (int i = 1; i < s1.size(); i++)
{
if (s1[i] == s1[i - 1])
{
s1[i] = '.';
ans[(i / s.size())]++;
}
}
k--;
long long res = ans[0];
res += 1ll * (k + 1) / 2 * ans[1];
res += 1ll * k / 2 * ans[2];
cout << res << endl;
}
}
| 0
| 91,431,414
|
#include<cstdio>
#include<cstring>
int main()
{
char str[1001];
while (1) {
scanf("%s", str);
if (str[0] == '0')break;
int sum = 0;
for (int i = 0; i < strlen(str); i++) {
sum += (str[i] - '0');
}
printf("%d\n", sum);
}
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
int main(){
int N;
cin >> N;
vector<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];
vector<int> dp(N, 0);
for(int i = 0; i < N - 1; i++) dp[i] = S[i];
for(int i = 0; i < N; i++){
if(i == N - 1) cout << 0 << endl;
else{
if(dp[i] > S[i]) dp[i] = S[i];
for(int j = i + 1; j < N - 1; j++){
if(dp[j] > S[j]) dp[j] = S[j];
if(dp[j] < dp[j - 1] + C[j - 1]) dp[j] = S[j] + (dp[j - 1] + C[j - 1] + F[j] - 1 - S[j]) / F[j] * F[j];
}
dp[N - 1] = dp[N - 2] + C[N - 2];
cout << dp[N - 1] << endl;
}
}
}
| 0
| 76,367,984
|
#include <bits/stdc++.h>
#define ALL(obj) begin(obj), end(obj)
using namespace std;
template <class T>
vector<T> make_vec(size_t a) {
return vector<T>(a);
}
template <class T, class... Ts>
auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
using ll = long long;
using ull = unsigned long long;
const int INF = 2100100100;
const int MOD = 1e9 + 7;
vector<long long> divisor(long long n) {
vector<long long> ret;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end());
return ret;
}
int N, M, K, Q, W, H, L, R, C, A, B, D;
string S;
vector<vector<int>> X;
int main() {
cin >> N >> K;
vector<ll> a(N), sum(N + 1), plu(N + 1), sub(N + 1);
for (int i = 0; i < N; i++) {
cin >> a.at(i);
sum[i + 1] = sum[i] + a[i];
plu[i + 1] = plu[i] + max(a[i], 0LL);
sub[i + 1] = sub[i] + min(a[i], 0LL);
}
ll ans = sum[N];
for (int i = 0; i <= N - K; i++) {
chmax(ans, plu[N] - (plu[i + K] - plu[i]));
}
for (int i = 0; i <= N - K; i++) {
chmax(ans, plu[N] + (sub[i + K] - sub[i]));
}
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<queue>
#include<deque>
#include<cmath>
#include<map>
#include<unordered_map>
#include<set>
#include<cstring>
#include<iomanip>
using namespace std;
typedef long long ll;
const ll INF = 1e9 + 6;
const ll MOD = 1e9 + 7;
const ll LLINF = 1LL<<60;
#define rng(i,a,b) for(int i=int(a);i<int(b);i++)
#define rep(i,b) rng(i,0,b)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
int main() {
int N; cin >> N;
int a[N]; rep(i, N) cin >> a[i];
int ans = 0;
rep(i, N - 1) {
if(a[i] == a[i + 1]) {
a[i + 1] = 10001;
++ans;
}
}
cout << ans << endl;
}
| 0
| 4,367,978
|
#include "bits/stdc++.h"
#define REP(i,num) for(int i=0;i<(num);++i)
#define LOOP(i) while(i--)
#define ALL(c) c.begin(),c.end()
#define PRINTALL(c) for(auto pitr=c.begin();pitr!=c.end();++pitr){cout<<*pitr;if(next(pitr,1)!=c.end())cout<<' ';}cout<<endl;
#define PAIRCOMP(c,comp) [](const pair<ll,ll>& lhs,const pair<ll,ll>& rhs){return lhs.c comp rhs.c;}
using namespace std;
using ll = long long;
constexpr ll atcoder_mod = 1e9+7;
template<typename T=int>
T in(){T x; cin >> x; return (x);}
template<typename T=int,typename C=vector<T>>
C vecin(int N){C x(N);REP(i,N){x[i]=in<T>();}return move(x);}
void vout(){cout << endl;}
template<typename Head,typename... Tail>
void vout(Head&& h,Tail&&... t){cout << ' ' << h;vout(forward<Tail>(t)...);}
void out(){cout << endl;}
template<typename Head,typename... Tail>
void out(Head&& h,Tail&&... t){cout << h;vout(forward<Tail>(t)...);}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(10);
int H=in(),W=in();
vector<vector<int>> M(H,vector<int>(W,1<<30));
queue<int> Q;
REP(i,H){
string S=in<string>();
REP(j,W){
if(S[j]=='#'){
M[i][j]=0;
Q.push(j+i*W);
}
}
}
while(!Q.empty()){
int V=Q.front();
Q.pop();
int u=V%W,v=V/W;
if(u>0 && M[v][u]+1<M[v][u-1]){
M[v][u-1] = M[v][u]+1;
Q.push(u-1+v*W);
}
if(u<W-1 && M[v][u]+1<M[v][u+1]){
M[v][u+1] = M[v][u]+1;
Q.push(u+1+v*W);
}
if(v>0 && M[v][u]+1<M[v-1][u]){
M[v-1][u] = M[v][u]+1;
Q.push(u+(v-1)*W);
}
if(v<H-1 && M[v][u]+1<M[v+1][u]){
M[v+1][u] = M[v][u]+1;
Q.push(u+(v+1)*W);
}
}
int maxV=0;
REP(i,H){
REP(j,W){
maxV=max(maxV,M[i][j]);
}
}
out(maxV);
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
int main() {
string s;
cin >> s;
int bw = 0, wb = 0;
for (int i = 0; i < s.length(); i++) {
if (i % 2 == 0) {
if (s[i] == '0') bw++;
if (s[i] == '1') wb++;
} else {
if (s[i] == '1') bw++;
if (s[i] == '0') wb++;
}
}
cout << min(bw, wb) << endl;
}
| 0
| 79,981,878
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int n,m,i,j,bl,x,y;
int main(){
scanf("%d%d%d",&n,&m,&bl);
for(i=1;i<=n;i++){
for(j=1;j<=m;j++){
x=(i+j+m)/bl%2;
y=(i-j+m)/bl%2;
printf("%c","YBGR"[x*2+y]);
}
puts("");
}
}
|
#pragma region header
#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;
#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 * b / gcd(a, b);
}
int keta(ll n) {
if (n == 0) return 1;
int count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
bool isprime(ll a)
{
if (a < 2) return false;
else if (a == 2) return true;
else if (a % 2 == 0) return false;
double m = sqrt(a);
for (int i = 3; i <= m; i += 2)
{
if (a % i == 0)
{
return false;
}
}
return true;
}
ll ketasum(ll n) {
ll sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
#pragma endregion
signed main() {
string S;
cin >> S;
int size = S.size();
vector <int>date;
rep(i, S.size()) {
string suuji = (S.substr(i, 3));
int a = stoi(suuji);
int b = abs(753 - a);
date.push_back(b);
}
sort(date.begin(), date.end());
cout << date.at(0) << endl;
}
| 0
| 52,804,434
|
#include <iostream>
using namespace std;
int main() {
const int size = 26;
int count[size]{};
char chara;
while(cin >> chara) {
if ('a' <= chara && chara <= 'z') {
int id = chara - 'a';
++count[id];
} else if ('A' <= chara && chara <= 'Z') {
int id = chara - 'A';
++count[id];
}
}
for (int i = 0; i < size; ++i) {
char word = 'a' + i;
cout << word << " : " << count[i] << endl;
}
return 0;
}
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<vector<int>> Graph;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
#define pi 3.14159265359
#define inf 2147483647
#define INF 9223372036854775807
#define mod 1000000007
#define mod2 998244353
int main() {
int N, K; cin >> N >> K;
vector<pair<int, int>> M(N);
set<int> S;
for(int i = 0; i < N; i++) {
int A; cin >> A;
A--;
S.insert(A);
M[A].second = A;
M[A].first++;
}
sort(M.begin(), M.end());
int ans = 0;
int i = 0;
while(S.size() > K) {
if(M[i].first != 0) {
ans += M[i].first;
S.erase(M[i].second);
}
i++;
}
cout << ans << endl;
return 0;
}
| 0
| 39,460,289
|
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define owo ios_base::sync_with_stdio(0);cin.tie(0);
#define mod (ll)(1e9+7)
#define INF (ll)(1e18)
#define debug(...) fprintf(stderr, __VA_ARGS__),fflush(stderr)
#define time__(d) for(long blockTime = 0; (blockTime == 0 ? (blockTime=clock()) != 0 : false);\
debug("%s time : %.4fs\n", d, (double)(clock() - blockTime) / CLOCKS_PER_SEC))
typedef long long int ll;
typedef long double ld;
typedef pair<ll,ll> PII;
typedef pair<int,int> pii;
typedef vector<vector<int>> vii;
typedef vector<vector<ll>> VII;
int main()
{
ll n;
cin>>n;
vector<ll>a(n);
for(int i=0;i<n;i++)cin>>a[i];
unordered_set<int>cnt;
cnt.insert(0);
ll ans = 0;
for(int i=0;i<n;i++){
if(cnt.count(a[i]-1)){
cnt.insert(a[i]);
ans = max(ans,a[i]);
}
}
if(ans == 0)cout<<-1;
else cout<<n-ans;
}
|
#include <bits/stdc++.h>
using namespace std;
#define SZ(x) (int)(x.size())
#define REP(i, n) for(int i=0;i<(n);++i)
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define RREP(i, n) for(int i=(int)(n);i>=0;--i)
#define RFOR(i, a, b) for(int i=(int)(a);i>=(int)(b);--i)
#define ALL(a) (a).begin(),(a).end()
#define DUMP(x) cerr<<#x<<" = "<<(x)<<endl
#define DEBUG(x) cerr<<#x<<" = "<<(x)<<" (L"<<__LINE__<<")"<< endl;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using P = pair<int, int>;
const double eps = 1e-8;
const ll MOD = 1000000007;
const int INF = INT_MAX / 2;
const ll LINF = LLONG_MAX / 2;
template <typename T1, typename T2>
bool chmax(T1 &a, const T2 &b) {
if(a < b) {a = b; return true;}
return false;
}
template <typename T1, typename T2>
bool chmin(T1 &a, const T2 &b) {
if(a > b) {a = b; return true;}
return false;
}
template<typename T1, typename T2>
ostream& operator<<(ostream &os, const pair<T1, T2> p) {
os << p.first << ":" << p.second;
return os;
}
template<class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
REP(i, SZ(v)) {
if(i) os << " ";
os << v[i];
}
return os;
}
bool ok = true;
int r = -1;
int sch(int now, int prev, const vvi &g, const vi &a, const vi &d) {
if(d[now] == 1 && now != r) {
return a[now];
}
int su = 0;
vi tmp;
for(auto nxt: g[now]) {
if(nxt == prev) continue;
tmp.push_back(sch(nxt, now, g, a, d));
su += tmp.back();
}
if(now == r) {
ok &= su == a[r];
return 0;
}
int res = 2*a[now] - su;
if(res < 0) ok = false;
su += res;
ok &= su % 2 == 0;
REP(i, SZ(tmp)) {
if(tmp[i] > su/2) {
ok = false;
break;
}
}
if(res > su/2) {
ok = false;
}
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
int n; cin >> n;
vi a(n);
REP(i, n) {
cin >> a[i];
}
vvi g(n);
vi d(n);
REP(i, n-1) {
int u, v; cin >> u >> v;
u--; v--;
g[u].push_back(v);
g[v].push_back(u);
d[u]++;
d[v]++;
}
REP(i, n) {
if(d[i] == 1) {
r = i;
break;
}
}
int res = sch(r, -1, g, a, d);
cout << (ok ? "YES" : "NO") << endl;
}
| 0
| 10,021,340
|
#include <iostream>
using std::cin;
using std::cout;
int main() {
int a, b, c;
cin >> a >> b >> c;
if(a < b && b < c) cout << "Yes\n";
else cout <<"No\n";
return 0;
}
|
#include <bits/stdc++.h>
#define f first
#define s second
#define pb push_back
#define pp pop_back
#define mp make_pair
#define sz(x) (int)x.size()
#define sqr(x) ((x) * 1ll * (x))
#define all(x) x.begin(), x.end()
#define rep(i, l, r) for (int i = (l); i <= (r); i++)
#define per(i, l, r) for (int i = (l); i >= (r); i--)
#define Kazakhstan ios_base :: sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define nl '\n'
#define ioi exit(0);
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const int N = (int)5e5 + 7;
const int inf = (int)1e9 + 7;
const int mod = (int)1e9 + 7;
const ll linf = (ll)1e18 + 7;
const int dx[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
using namespace std;
int n, L;
int a[N];
int main() {
#ifdef wws
freopen ("in.txt", "r", stdin);
#endif
Kazakhstan
cin >> n >> L;
rep(i, 1, n) {
cin >> a[i];
}
int p = -1;
rep(i, 1, n - 1) {
if (a[i] + a[i + 1] >= L) {
p = i;
}
}
if (p == -1) cout << "Impossible", ioi;
vector <int> ans;
rep(i, p, n - 1) ans.pb(i);
per(i, p - 1, 1) ans.pb(i);
reverse(all(ans));
cout << "Possible\n";
for (auto it : ans) cout << it << nl;
ioi
}
| 0
| 62,270,185
|
#include <stdio.h>
#include <algorithm>
using namespace std;
void print(char str[],int a,int b){
for(int i = a; i <= b; i++) printf("%c",str[i]);
printf("\n");
}
void replace(char str[],char p[],int a,int b){
int p_length = b-a+1;
for(int i = 0; i < p_length;i++) str[a+i] = p[i];
}
void reverse(char str[],int a,int b){
int left = a,right = b;
while(left < right){
swap(str[left++],str[right--]);
}
}
int main(){
char str[1001],p[1001],order[8];
int q,a,b;
scanf("%s",str);
scanf("%d",&q);
for(int i = 0; i < q; i++){
scanf("%s %d %d",order,&a,&b);
switch(order[2]){
case 'i':
print(str,a,b);
break;
case 'v':
reverse(str,a,b);
break;
case 'p':
scanf("%s",p);
replace(str,p,a,b);
break;
}
}
}
|
#include<iostream>
#include<algorithm>
#include<cmath>
#include<map>
#include<stdio.h>
#include<vector>
#include<queue>
#include<math.h>
#include<deque>
using namespace std;
#define int long long
#define rep(s,i,n) for(int i=s;i<n;i++)
#define c(n) cout<<n<<endl;
#define ic(n) int n;cin>>n;
#define sc(s) string s;cin>>s;
#define mod 1000000007
#define inf 1000000000000000007
#define f first
#define s second
#define mini(c,a,b) *min_element(c+a,c+b)
#define maxi(c,a,b) *max_element(c+a,c+b)
#define pi 3.141592653589793238462643383279
#define e_ 2.718281828459045235360287471352
#define P pair<int,int>
#define upp(a,n,x) upper_bound(a,a+n,x)-a;
#define low(a,n,x) lower_bound(a,a+n,x)-a;
#define UF UnionFind
int keta(int x) {
rep(0, i, 30) {
if (x < 10) {
return i + 1;
}
x = x / 10;
}
}
int gcd(int x, int y) {
if (x == 0 || y == 0)return x + y;
int aa = x, bb = y;
rep(0, i, 1000) {
aa = aa % bb;
if (aa == 0) {
return bb;
}
bb = bb % aa;
if (bb == 0) {
return aa;
}
}
}
int lcm(int x, int y) {
int aa = x, bb = y;
rep(0, i, 1000) {
aa = aa % bb;
if (aa == 0) {
return x / bb * y;
}
bb = bb % aa;
if (bb == 0) {
return x / aa * y;
}
}
}
bool p(int x) {
if (x == 1)return false;
rep(2, i, sqrt(x) + 1) {
if (x % i == 0 && x != i) {
return false;
}
}
return true;
}
int max(int a, int b) {
if (a >= b)return a;
else return b;
}
string maxst(string s, string t) {
int n = s.size();
int m = t.size();
if (n > m)return s;
else if (n < m)return t;
else {
rep(0, i, n) {
if (s[i] > t[i])return s;
if (s[i] < t[i])return t;
}
return s;
}
}
int min(int a, int b) {
if (a >= b)return b;
else return a;
}
int n2[61];
int nis[61];
int nia[61];
int mody[61];
int nn;
int com(int n, int y) {
int ni = 1;
for (int i = 0;i < 41;i++) {
n2[i] = ni;
ni *= 2;
}
int bunsi = 1, bunbo = 1;
rep(0, i, y)bunsi = (bunsi * (n - i)) % mod;
rep(0, i, y)bunbo = (bunbo * (i + 1)) % mod;
mody[0] = bunbo;
rep(1, i, 41) {
bunbo = (bunbo * bunbo) % mod;
mody[i] = bunbo;
}
rep(0, i, 41)nis[i] = 0;
nn = mod - 2;
for (int i = 40;i >= 0;i -= 1) {
if (nn > n2[i]) {
nis[i]++;
nn -= n2[i];
}
}
nis[0]++;
rep(0, i, 41) {
if (nis[i] == 1) {
bunsi = (bunsi * mody[i]) % mod;
}
}
return bunsi;
}
int gyakugen(int n, int y) {
int ni = 1;
for (int i = 0;i < 41;i++) {
n2[i] = ni;
ni *= 2;
}
mody[0] = y;
rep(1, i, 41) {
y = (y * y) % mod;
mody[i] = y;
}
rep(0, i, 41)nis[i] = 0;
nn = mod - 2;
for (int i = 40;i >= 0;i -= 1) {
if (nn > n2[i]) {
nis[i]++;
nn -= n2[i];
}
}
nis[0]++;
rep(0, i, 41) {
if (nis[i] == 1) {
n = (n * mody[i]) % mod;
}
}
return n;
}
int yakuwa(int n) {
int sum = 0;
rep(1, i, sqrt(n + 1)) {
if (n % i == 0)sum += i + n / i;
if (i * i == n)sum -= i;
}
return sum;
}
int poow(int y, int n) {
if (n == 0)return 1;
n -= 1;
int ni = 1;
for (int i = 0;i < 61;i++) {
n2[i] = ni;
ni *= 2;
}
int yy = y;
mody[0] = yy;
rep(1, i, 61) {
yy = (yy * yy) % mod;
mody[i] = yy;
}
rep(0, i, 61)nis[i] = 0;
nn = n;
for (int i = 60;i >= 0;i -= 1) {
if (nn >= n2[i]) {
nis[i]++;
nn -= n2[i];
}
}
rep(0, i, 61) {
if (nis[i] == 1) {
y = (y * mody[i]) % mod;
}
}
return y;
}
int minpow(int x, int y) {
int sum = 1;
rep(0, i, y)sum *= x;
return sum;
}
int ketawa(int x, int sinsuu) {
int sum = 0;
rep(0, i, 100)sum += (x % poow(sinsuu, i + 1)) / (poow(sinsuu, i));
return sum;
}
int sankaku(int a) {
return a * (a + 1) / 2;
}
int sames(int a[1111111], int n) {
int ans = 0;
rep(0, i, n) {
if (a[i] == a[i + 1]) {
int j = i;
while (a[j + 1] == a[i] && j <= n - 2)j++;
ans += sankaku(j - i);
i = j;
}
}
return ans;
}
using Graph = vector<vector<int>>;
int oya[114514];
int depth[114514];
void dfs(const Graph& G, int v, int p, int d) {
depth[v] = d;
oya[v] = p;
for (auto nv : G[v]) {
if (nv == p) continue;
dfs(G, nv, v, d + 1);
}
}
int XOR(int a, int b) {
if (a == 0 || b == 0) {
return a + b;
}
int ni = 1;
rep(0, i, 41) {
n2[i] = ni;
ni *= 2;
}
rep(0, i, 41)nis[i] = 0;
for (int i = 40;i >= 0;i -= 1) {
if (a >= n2[i]) {
nis[i]++;
a -= n2[i];
}
if (b >= n2[i]) {
nis[i]++;
b -= n2[i];
}
}
int sum = 0;
rep(0, i, 41)sum += (nis[i] % 2 * n2[i]);
return sum;
}
int string_int(string s){
int sum=0;
int n=s.size();
int t=1;
rep(0,i,n){
sum+=t*(s[n-i-1]-'0');
t*=10;
}
return sum;
}
struct UnionFind {
vector<int> par;
UnionFind(int N) : par(N) {
for (int i = 0; i < N; i++) par[i] = i;
}
int root(int x) {
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) return;
par[rx] = ry;
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
signed main(){
ic(n)
sc(s)
int ans=0;
for(char a='0';a<='9';a++){
for(char b='0';b<='9';b++){
for(char c='0';c<='9';c++){
int d=n,e=0;
rep(0,i,n){
if(s[i]==a){
d=i;
break;
}
}
for(int i=n-1;i>=0;i-=1){
if(s[i]==c){
e=i;
break;
}
}
rep(d+1,i,e){
if(s[i]==b){
ans++;
break;
}
}
}
}
}
c(ans)
}
| 0
| 78,274,254
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const double PI = 3.14159265358979323846;
int main() {
char a, b;
cin >> a >> b;
if(a == 'D') {
if(b == 'H') cout << 'D' << endl;
else cout << 'H' << endl;
}
else {
if(b == 'H') cout << 'H' << endl;
else cout << 'D' << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define pb push_back
#define ll long long
#define pii pair<int,int>
void test_case()
{
ll k;
cin>>k;
queue<ll> q;
for(ll i=1;i<=9;i++)
q.push(i);
ll v;
while(k--) {
v=q.front();
q.pop();
if(v%10!=0)
q.push(10*v + v%10 - 1);
q.push(10*v + v%10);
if(v%10!=9)
q.push(10*v + v%10 +1);
}
cout<<v;
}
int main()
{
fastio
test_case();
}
| 0
| 55,364,132
|
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
for(int i = 1;;i+2){
s = s.substr(0, s.size() - i * 2);
string a = s.substr(0, s.size() / 2);
string b = s.substr(s.size() / 2, s.size() / 2);
if(a == b){
cout << s.size() << endl;
break;
}
}
}
|
#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);
ll a, b, c, k;
cin >> a >> b >> c >> k;
if(k%2==0)cout<<a-b<<"\n";
else cout<<b-a<<"\n";
}
| 0
| 81,648,422
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
auto f = [](int x) {
cout << x << '\n';
cout << flush;
string s;
cin >> s;
if (s == "Vacant") {
exit(0);
} else if (s == "Male") {
return 0;
} else {
return 1;
}
};
int lo = 0, hi = N - 1, k = f(0);
while (lo <= hi) {
int mi = (lo + hi) / 2, r = f(mi) ^ (mi & 1);
if (k == r) {
lo = mi + 1;
} else {
hi = mi - 1;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#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 _rrep(i,n) rrepi(i,n,0)
#define rrepi(i,a,b) for(int i=int(a)-1;i>=int(b);--i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define rrep(...) _overload3(__VA_ARGS__,rrepi,_rrep,)(__VA_ARGS__)
#define each(xi, x) for (auto&& xi : x)
template <class T> using vec = vector<T>;
using ll = long long;
using vi = vec<int>;
using vvi = vec<vi>;
using vvvi = vec<vvi>;
using pii = pair<int, int>;
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
#define all(x) (x).begin(), (x).end()
#define uniq(v) v.erase( unique(all(v)), v.end() )
#define perm(c) sort(all(c));for(bool c##p=1;c##p;c##p=next_permutation(all(c)))
template<class T> pair<T, size_t> max(vector<T> &x){ auto it = max_element(all(x)); return mp(*it, it-x.begin()); }
template<class T> pair<T, size_t> min(vector<T> &x){ auto it = min_element(all(x)); return mp(*it, it-x.begin()); }
template<class T> inline bool chmax(T &maxval, const T &newval) { if (maxval<newval) { maxval=newval; return 1; } return 0; }
template<class T> inline bool chmin(T &minval, const T &newval) { if (minval>newval) { minval=newval; return 1; } return 0; }
int dx[4]={0,1,0,-1};
int dy[4]={1,0,-1,0};
#define inside(H,W,y,x) 0<=(x) && (x)<(W) && 0<=(y) && (y)<(H)
inline int in() {int x; cin >> x; return x;}
inline ll IN() {ll x; cin >> x; return x;}
#ifdef LOCAL
#include "dump.hpp"
#define debug(x) cerr << #x << ": " << x << '\n'
#else
#define dump(...)
#define debug(x)
#endif
int main(){
cin.tie(0); ios::sync_with_stdio(false);
int n; cin >> n;
vector<ll> h(n);
rep(i,n) cin >> h[i];
int ret = 0; int m = 0;
rep(i,1,n){
if(h[i-1]>=h[i]) ret++;
else ret = 0;
m = max(m,ret);
}
cout << m << endl;
return 0;
}
| 0
| 56,538,650
|
#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>;
string divide[4] = {"dream","dreamer","erase","eraser"};
int main(){
string s;
cin>>s;
reverse(s.begin(),s.end());
rep(i,4) reverse(divide[i].begin(),divide[i].end());
int f1=1;
for(int i=0;i<s.size();){
int f2=0;
rep(j,4){
string d = divide[j];
if(s.substr(i,d.size())==d){
i+=d.size();
f2=1;
}
}
if(1-f2){
f1=0;
break;
}
}
if(f1) cout << "YES" << endl;
else cout << "NO" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define int long long int
#define double long double
#define inf (int)(1e15)
#define all(x) (x).begin(), (x).end()
#define pair pair<int, int>
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pair> vii;
typedef vector<vii> vvii;
typedef vector<bool> vb;
#define pq priority_queue
#define ff first
#define ss second
const int dx4[] = {1, 0, -1, 0}, dy4[] = {0, -1, 0, 1};
const int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1}, dy8[] = {1, -1, 1, 0, -1, 1, -0, -1};
#define testcases(t) \
int(t); \
cin >> (t); \
while ((t)--)
signed main()
{
int n, k, ans = 0;
cin >> n >> k;
for (int i = k; i <= (n + 1); i++)
{
ans += (i * (n - i + 1));
ans++;
ans %= mod;
}
cout << ans << endl;
return 0;
}
| 0
| 2,896,829
|
#include <iostream>
using namespace std;
int main() {
int x, y;
while (cin >> x >> y) {
if (x == y && x == 0)
break;
if (max(x, y) != y)
swap(x, y);
cout << x << " " << y << endl;
}
}
|
#include<bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
int N,K,ans=0;
cin>>N>>K;
vector<int> A(N);
for(int &i:A)cin>>i;
for(int i=0;i<=K && i<=N;i++){
for(int j=0;j+i<=K && i+j<=N;j++){
priority_queue<int,vector<int>,greater<int>> Q;
int sum=0;
for(int k=0;k<i;k++){
Q.push(A[k]);
sum+=A[k];
}
for(int k=0;k<j;k++){
Q.push(A[N-1-k]);
sum+=A[N-1-k];
}
for(int k=0;i+j+k<K && k<i+j;k++){
if(Q.top()>=0)break;
sum-=Q.top();
Q.pop();
}
ans=max(ans,sum);
}
}
cout<<ans<<endl;
}
| 0
| 92,424,673
|
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <algorithm>
#include <numeric>
#include <random>
#include <vector>
#include <array>
#include <bitset>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
int main() {
string s;
cin >> s;
if(s[0] == s[1] && s[1] == s[2]){
cout << "Yes";
}else if(s[1] == s[2] && s[2] == s[3]){
cout << "Yes";
}else{
cout << "No";
}
return 0;
}
|
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
ll MOD = 1000000007;
#define vec vector<int>
#define vecll vector<ll>
#define vecst vector<string>
#define vecb vector<bool>
#define vec2(var, n, m) vector<vector<int>> var(n, vector<int>(m, 0))
#define vecll2(var, n, m) vector<vector<ll>> var(n, vector<ll>(m, 0))
#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 f_sum(var) accumulate(all(var), 0)
#define f_sumll(var) accumulate(all(var), 0LL)
#define chmin(v1, v2) v1 = min(v1, v2)
#define chmax(v1, v2) v1 = max(v1, v2)
#define mp(v1, v2) make_pair(v1, v2)
#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");}
void prtok(bool ok){prt(ok ? "yes" : "no");}
int main(void) {
int n;
cin >> n;
arr(a,n);
deque<int> dq;
rep(i,n){
if(i%2==1) dq.push_back(a[i]);
else dq.push_front(a[i]);
}
if(n%2==0) reverse(all(dq));
prtall(dq);
}
| 0
| 11,530,854
|
#pragma GCC optimize("O3")
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
typedef unsigned long long int ull;
typedef pair<ll,ll> P;
template<class T> using V=vector<T>;
#define fi first
#define se second
#define all(v) (v).begin(),(v).end()
const ll inf=(1e18);
const ll mod=1000000007;
ll gcd(ll a,ll b) {return b ? gcd(b,a%b):a;}
ll lcm(ll c,ll d){return c/gcd(c,d)*d;}
struct __INIT{__INIT(){cin.tie(0);ios::sync_with_stdio(false);cout<<fixed<<setprecision(15);}} __init;
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; }
struct edge{
ll to,cost;
};
V<V<edge>> graph;
V<V<bool>> used;
V<ll> d1;
int n,m;
void dijkstra(ll s){
d1.resize(n);
for(int i=0;i<n;i++)d1[i]=inf;
d1[s]=0;
priority_queue<P,vector<P>,greater<P>> q;
q.push(P(0,s));
while(!q.empty()){
P a=q.top();
q.pop();
if(d1[a.se]<a.fi)continue;
for(int i=0;i<graph[a.se].size();i++){
edge e=graph[a.se][i];
if(d1[e.to]>d1[a.se]+e.cost){
d1[e.to]=d1[a.se]+e.cost;
q.push(P(d1[e.to],e.to));
}
}
}
q.push(P(0,s));
while(!q.empty()){
P a=q.top();
q.pop();
if(d1[a.se]<a.fi)continue;
for(int i=0;i<graph[a.se].size();i++){
edge e=graph[a.se][i];
if(d1[e.to]==d1[a.se]+e.cost){
used[a.se][e.to]=false;
used[e.to][a.se]=false;
q.push(P(d1[e.to],e.to));
}
}
}
return;
}
int main(){
cin>>n>>m;
used.assign(n,V<bool>(n,false));
graph.resize(n);
for(int i=0;i<m;i++){
ll a,b,c;
cin>>a>>b>>c;
a--;b--;
graph[a].push_back(edge{b,c});
graph[b].push_back(edge{a,c});
used[a][b]=true;
used[b][a]=true;
}
int ans=0;
for(int i=0;i<n;i++)dijkstra(i);
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++)if(used[i][j])ans++;
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
string s,t;
map<int,int> mps;
map<int,int> mpt;
cin >> s >> t;
for(int i=0;i<s.size();i++) {
mps[s[i]-'a']++;
}
for(int i=0;i<t.size();i++) {
mpt[t[i]-'a']++;
}
vector<int> sv;
vector<int> tv;
for(auto m:mps) {
sv.push_back(m.second);
}
for(auto m:mpt) {
tv.push_back(m.second);
}
sort(sv.begin(), sv.end());
sort(tv.begin(), tv.end());
if(sv == tv) {
cout << "Yes\n";
} else {
cout << "No\n";
}
return 0;
}
| 0
| 42,145,251
|
#include<bits/stdc++.h>
#define n0_nnE int main(){
using namespace std;
typedef long long ll;
using namespace std;
int main(){
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++)
{
cin >> A[i];
}
long long ans = 0;
int MaxNum = 0;
for (int i = 0; i < N; i++)
{
MaxNum = max(MaxNum, A[i]);
int Bi = MaxNum;
ans += Bi - A[i];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vs = vector<string>;
using vld = vector<ld>;
using vvld = vector<vld>;
typedef pair<ll, ll> P;
#define bit(n) (1LL << (n))
#define all(v) v.begin(), v.end()
#define rep(i, n) for (ll i = 0; i < n; i++)
#define REP(i, n) for (ll i = 1; i < n; i++)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define FORm(i, m) for (auto i = m.begin(); i != m.end(); i++)
template <class T>
inline void chmax(T& a, T b) {
a = std::max(a, b);
}
template <class T>
inline void chmin(T& a, T b) {
a = std::min(a, b);
}
#define mod (ll)(1e9 + 7)
const long long INF = 1LL << 60;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll n, m;
cin >> n >> m;
vs a(n), b(m);
rep(i, n) {
cin >> a[i];
}
rep(i, m) {
cin >> b[i];
}
rep(y, n - m + 1) {
rep(x, n - m + 1) {
bool match = true;
rep(q, m) {
rep(p, m) {
if (b[q][p] != a[y + q][x + p]) {
match = false;
goto end;
}
}
}
end:
if (match) {
cout << "Yes" << endl;
return 0;
}
}
}
cout << "No" << endl;
return 0;
}
| 0
| 43,721,534
|
#include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int NIL = -1;
const int INF = (1<<21);
const long long MOD = 1e9+7;
const int di[] = {-1, 0, 1, 0};
const int dj[] = {0, -1, 0, 1};
int main() {
int r, D, x; cin >> r >> D >> x;
for (int i = 1; i <= 10; ++i) {
int new_x = r * x - D;
cout << new_x << endl;
x = new_x;
}
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits.h>
#include <climits>
#include <map>
#include <unordered_map>
#define _USE_MATH_DEFINES
#include <cmath>
#include <set>
#include <unordered_set>
#include <iterator>
#include <deque>
#include <assert.h>
#include <cstdlib>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
ull min(ull x, ull y){ if (x<y) return x; return y;}
ull max(ull x, ull y){ if (x<y) return y; return x;}
ll min(ll x, ll y){ if (x<y) return x; return y;}
ll max(ll x, ll y){ if (x<y) return y; return x;}
double min(double x, double y){ if (x<y) return x; return y;}
double max(double x, double y){ if (x<y) return y; return x;}
ull gcd(ull x, ull y){
if (!x) return y;
if (!y) return x;
if (x>y) swap(x,y);
return gcd(x, y%x);
}
ull inv(ull a, ull c){
if (a==1){
return 1;
}
return ((c-(c/a))*inv(c%a,c))%c;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int h1, m1, h2, m2, k;
cin>>h1>>m1>>h2>>m2>>k;
int t1 = h1*60 + m1, t2 = h2*60+m2;
int ans = max(0, t2-k-t1);
cout<<ans<<"\n";
return 0;
}
| 0
| 76,223,973
|
#include <bits/stdc++.h>
using namespace std;
int keta(int x){
int sum=0;
while(x>0){
x/=10;
sum++;
}
return sum;
}
int main() {
int n,ans=0;
cin >> n;
for(int i=1;i<=n;i++){
if(i%2==0) continue;
int count=0;
for(int j=1;j<=i;j++){
if(i%j==0) count++;
}
if(count==8) ans++;
}
cout << ans;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x,vector<x>,greater<x>>
#define all(x) (x).begin(),(x).end()
#define CST(x) cout<<fixed<<setprecision(x)
#define vtpl(x,y,z) vector<tuple<x,y,z>>
#define rev(x) reverse(x);
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
using pl=pair<ll,ll>;
using vpl=vector<pl>;
using vvpl=vector<vpl>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main(){
string s;cin >> s;
ll k;cin >> k;
ll cnt=0;
ll n=s.size();
bool same=true;
rep(i,n-1)if(s[i]!=s[i+1])same=false;
if(same){
cout << k*s.size()/2 << endl;
return 0;
}
rep(i,n-1){
if(s[i]==s[i+1]){
cnt++;
i++;
}
}
if(s[0]!=s[n-1])cout << cnt*k <<endl,exit(0);
ll a=1,b=1;
repl(i,1,n){
if(s[i]==s[i-1])a++;
else break;
}
reverse(all(s));
repl(i,1,n){
if(s[i]==s[i-1])b++;
else break;
}
cout << cnt*k-(a/2+b/2-(a+b)/2)*(k-1) <<endl;
}
| 0
| 73,462,452
|
#include <iostream>
using namespace std;
int main() {
long long sol=0;
int a9=1;
while(1) {
int digmin=0;
int digmax=9;
if(sol==0) digmin=1;
string res;
while(digmin<digmax) {
int hf=(digmin+digmax)/2;
if(sol==0) {
cout << "? " << sol*10+hf << "999999999" << endl;
} else {
cout << "? " << sol*10+hf << "99999999" << endl;
}
cin >> res;
if(res[0]=='Y') {
digmax=hf;
} else {
digmin=hf+1;
}
}
if(digmin<9) a9=0;
sol=sol*10+digmin;
if(a9) {
cout << "? " << (sol-1)*10 << endl;
cin >> res;
if(res[0]=='N') break;
} else {
cout << "? " << (sol+1) << endl;
cin >> res;
if(res[0]=='Y') break;
}
}
cout << "! " << sol << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORD(i, m, n) for (int i = m; i >= n; --i)
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REP1(i, n) for (int i = 0; i <= n; ++i)
#define REPR(i, n) for (int i = n; i >= 0; --i)
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
using ll = long long;
using ull = unsigned long long;
using ld = long double;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin>>s;
if(s[0]==s[1]&&s[1]!=s[2]&&s[2]==s[3])cout << "Yes" << endl;
else if(s[0]==s[2]&&s[1]==s[3]&&s[0]!=s[1])cout << "Yes" << endl;
else if(s[0]==s[3]&&s[1]==s[2]&&s[0]!=s[1])cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
| 0
| 185,123
|
#include <iostream>
#include <cstring>
using namespace std;
int main() {
int a[101];
int n, max;
memset(a, 0, sizeof(int)*101);
while (cin >> n) a[n]++;
for (int i=0; i<=100; i++) {
if (a[i] > max) max = a[i];
}
for (int i=0; i<=100; i++) {
if (a[i] == max) cout << i << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<P,ll> PLL;
typedef pair<P,P> PP;
typedef vector<ll> VECLL;
typedef vector<P> VECP;
typedef priority_queue<P,VECP,greater<P> > PQP;
typedef priority_queue<ll, VECLL, greater<ll> > PQll;
#define rep(i,a,n) for(ll i = a;i < n;i++)
#define rrep(i,a,n) for(ll i = n; i >= a;i--)
#define index_check(i,n) if(i > n-1 || i < 0) continue;
#define LINF (ll)1e18
#define INF (int)1e9
#define fs first
#define sc second
const ll MOD = 1e9+7;
int main(){
ll n;
cin >> n;
string s,t;
cin >> s >> t;
string ans = "";
rep(i,0,n){
ans += s[i];
ans += t[i];
}
cout << ans << endl;
return 0;
}
| 0
| 14,404,383
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
bool result = false;
cin >> N;
for ( int i=0; i<= N/4; i++){
for ( int j=0; j<= (N-i*4)/7; j++){
if( N-i*4-j*7 == 0){
result = true;
}
}
}
if(result){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
}
|
#include <bits/stdc++.h>
#define REP(i, e) for(int (i) = 0; (i) < (e); ++(i))
#define FOR(i, b, e) for(int (i) = (b); (i) < (e); ++(i))
#define ALL(c) (c).begin(), (c).end()
#define PRINT(x) cout << (x) << "\n"
using namespace std;
using ll = long long; using pint = pair<int, int>; using pll = pair<ll, ll>;
template<typename T> auto compare = [](T x, T y) -> bool{return (x < y);};
const int MOD = 1000000007;
ll N, M;
ll A[100010];
signed main(){
cin >> N >> M;
REP(i, N) cin >> A[i];
ll sum = 0;
map<ll, ll> mp;
mp[0]++;
REP(i, N){
sum = (sum + A[i]) % M;
mp[sum]++;
}
ll ans = 0;
for(auto p : mp){
ans += p.second * (p.second - 1) / 2;
}
PRINT(ans);
return 0;
}
| 0
| 71,550,262
|
#include<iostream>
using namespace std;
int main() {
int data_lim;
cin >> data_lim;
for(int cnt=0;cnt<data_lim;cnt++) {
int a,b,c;
cin >> a >> b >> c;
bool flg = false;
if(a*a == b*b+c*c)
flg = true;
else if(b*b == a*a+c*c)
flg = true;
else if(c*c == a*a+b*b)
flg = true;
if(flg == true)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <string>
#include <numeric>
#include <cmath>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
using P = pair<ll, ll>;
template<class T> inline bool chmin(T& a,T b) {if (a > b) {a = b; return true;} return false;}
template<class T> inline bool chmax(T& a,T b) {if (a < b) {a = b; return true;} return false;}
const ll MOD = 1000000007;
const int INF = 1<<30;
int main(){
int N, K; cin >> N >> K;
string S; cin >> S;
vector<int> que;
int n_zero = 0, n_one = 0;
if (S[0] != '1') que.push_back(0);
rep(i, N){
if (S[i] == '0'){
if (n_one != 0) que.push_back(n_one);
n_zero++;
n_one = 0;
}
else{
if (n_zero != 0) que.push_back(n_zero);
n_one++;
n_zero = 0;
}
if (i == N - 1){
if (S[i] == '0') que.push_back(n_zero);
else que.push_back(n_one);
}
}
vector<int> s((int)que.size() + 1, 0);
rep(i, (int)que.size()) s[i + 1] = s[i] + que[i];
int ans = 0;
for (int left = 0; left < s.size(); left += 2){
int right = left + K * 2 + 1;
if (right >= s.size()) right = (int)s.size() - 1;
ans = max(ans, s[right] - s[left]);
}
cout << ans << endl;
}
| 0
| 19,685,679
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int N;
cin >> N;
vector<ll> A(N), B(N);
rep(i, N) cin >> A[i] >> B[i];
reverse(A.begin(), A.end());
reverse(B.begin(), B.end());
ll ans = 0;
rep(i, N) ans += (B[i] - (A[i] + ans) % B[i]) % B[i];
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define ll long long
#define MODV 1000000007
#define INFLL LLONG_MAX
#define EPS 1e-9
#define rep(i, n) for(ll i=0, i##_len=(ll)(n); i<i##_len; i++)
#define repf(i, n) for(ll i=1, i##_len=(ll)(n+1); i<i##_len; i++)
#define all(v) v.begin(), v.end()
#define endl "\n"
#define vi vector<ll>
#define vvi vector<vector<ll>>
#define Yes() cout << "Yes" << endl
#define YES() cout << "YES" << endl
#define No() cout << "No" << endl
#define NO() cout << "NO" << endl
#define Init() std::ios::sync_with_stdio(false); std::cin.tie(0); std::cout<<fixed<<setprecision(15);
template<class T>bool chmax(T &a, const T &b){ if(a<b){ a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b){ if(b<a){ a=b; return 1; } return 0; }
using namespace std;
int main(){
Init();
string s; cin >> s;
ll n = s.size();
for(ll i=0; i<=n-2; i++){
if(s[i] == s[i+1]){
cout << i+1 << " " << i+2 << endl;
return 0;
}
if(i <= n-3 && s[i] == s[i+2]){
cout << i+1 << " " << i+3 << endl;
return 0;
}
}
cout << "-1 -1" << endl;
}
| 0
| 12,052,301
|
#include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<ll,ll> llP;
ll mod(ll a, ll b){
ll ret=a%b;
if(ret<0) ret+=b;
return ret;
}
ll modpow(ll a,ll b,ll c){
ll res=1;
while(b>0){
if(b&1) res=mod(res*a,c);
a=mod(a*a,c);
b>>=1;
}
return res;
}
int main() {
int n,k;
cin>>n>>k;
int r,s,p;
cin>>r>>s>>p;
string t;
cin>>t;
ll ans=0;
for(int i=0;i<min(n,k);i++){
int cnt=0;
for(int j=i;j<n;j+=k){
if(j==i){
if(t[j]=='r')ans+=p;
else if(t[j]=='s')ans+=r;
else ans+=s;
cnt++;
}
else{
if(t[j]!=t[j-k]){
if(t[j]=='r')ans+=p;
else if(t[j]=='s')ans+=r;
else ans+=s;
cnt=1;
}
else{
if(cnt%2==0){
if(t[j]=='r')ans+=p;
else if(t[j]=='s')ans+=r;
else ans+=s;
}
cnt++;
}
}
}
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, p;
cin >> n >> p;
ll ans = 1;
int odd = 0;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
odd += a%2;
ans *= 2;
}
if (odd == 0) {
if (p == 0) {
cout << ans << endl;
} else {
cout << 0 << endl;
}
} else {
cout << ans / 2 << endl;
}
}
| 0
| 13,540,643
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define REP(i, n) for(ll i = 1; i < n + 1; i++)
#define PI 3.14159265359
#define EPS 0.0000000001
#define MOD 1000000007
ll digitSum(ll x){
ll sum = 0;
while(x > 0){
sum += x % 10;
x /= 10;
}
return sum;
}
int main(){
ll N, A, B;
cin >> N >> A >> B;
ll ans = 0;
REP(i, N){
ll sum = digitSum(i);
if(sum >= A && sum <= B){
ans += i;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main()
{
string s;
cin >> s;
bool ok = true;
if (s[0] != 'A')
ok = false;
int cnt = 0;
for (int i = 2; i <= s.size() - 2; i++)
{
if (s[i] == 'C')
cnt++;
}
if (cnt >= 2 || cnt == 0)
ok = false;
for (int i = 1; i < s.size(); i++)
{
if (s[i] == 'C')
continue;
if ('A' <= s[i] && s[i] <= 'Z')
ok = false;
}
if (ok)
cout << "AC" << endl;
else
cout << "WA" << endl;
return 0;
}
| 0
| 67,353,415
|
#include<iostream>
using namespace std;
int main() {
int x, y, z;
cin >> x;
cin >> y;
cin >> z;
int alpha;
if (x < y) {
if (y < z) {
cout << x << " " << y << " " << z << endl;
}
else if (z < x) {
cout << z << " " << x << " " << y << endl;
}
else {
cout << x << " " << z << " " << y << endl;
}
}
else if (x < z) {
cout << y << " " << x << " " << z << endl;
}
else if (z < y) {
cout << z << " " << y << " " << x << endl;
}
else {
cout << y << " " << z << " " << x << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, start, end) for (long long i = start; i < end; ++i)
#define repreverse(i, start, end) for (long long i = start; i >= end; --i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define len(x) ((long long)(x).size())
#define lcm(a, b) ((a) / __gcd((a), (b)) * (b))
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vllvll = vector<vll>;
using pll = pair<ll, ll>;
template<class T>void print1d(T x,ll n=-1){if(n==-1)n=x.size();rep(i,0,n){cout<<x[i]<<' ';}cout<<'\n';}
template<class T>void print2d(T x,ll r=-1,ll c=-1){if(r==-1)r=x.size();if(c==-1)c=x[0].size();rep(i,0,r)print1d(x[i],c);}
template<class T, class U>bool haskey(T mp, U key) { return mp.find(key) != mp.end(); }
template<class T, class U>bool isin(T el, U container) { return find(all(container), el) != container.end(); }
template<class T>bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
template<class T>bool even(T n) { return ! (n & 1); }
template<class T>bool odd(T n) { return n & 1; }
template<class T>ld deg2rad(T deg) { return M_PI * deg / 180.0; }
template<class T>ld rad2deg(T rad) { return 180.0 * rad / M_PI; }
ll intpow(ll a,ll n){ll p=1;while(n){if(n&1)p*=a;a*=a;n>>=1;}return p;}
const long double pi = M_PI;
const long long big = 1LL << 50;
const long long inf = 1LL << 60;
const long long mod = 1e9 + 7;
int main()
{
ll x, y, xx, yy;
cin >> x >> y >> xx >> yy;
complex<ll> v1(xx-x, yy-y);
complex<ll> i(0, 1);
complex<ll> v2 = v1 * i;
ll xxxx = v2.real() + x;
ll yyyy = v2.imag() + y;
complex<ll> v3 = v1 + v2;
ll xxx = v3.real() + x;
ll yyy = v3.imag() + y;
cout << xxx << ' ' << yyy << ' ' << xxxx << ' ' << yyyy << endl;
}
| 0
| 9,945,930
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define leading zero str.erase(0, min(str.find_first_not_of('0'), str.size()-1));
using namespace __gnu_pbds;
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
string text="abcdefghijklmnopqrstuvwxyz";
const int maxn=1e6+7;
ll bin_pow(ll a,ll b,ll m)
{
ll res=1;
a%=m;
while(b>0)
{
if(b&1)
res=res*a%m;
b>>=1;
a=a*a%m;
}
return res;
}
bool miller_rabin(ll d,ll n)
{
ll a=2+rand()%(n-4);
ll x=bin_pow(a,d,n);
if(x==1 || x==n-1)
return true;
while(d!=n-1)
{
x=(x*x)%n;
d*=2;
if(x==1)
return false;
if(x==n-1)
return true;
}
return false;
}
bool prime(ll n,ll k)
{
if(n==1 || n==4)
return false;
if(n<=3)
return true;
ll d=n-1;
while(d%2==0)
d/=2;
for(int i=0; i<k; i++)
{
if(!miller_rabin(d,n))
return false;
}
return true;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll a[3];
for(int i=0;i<3;i++)cin>>a[i];
sort(a,a+3);
ll cnt=0;
ll x=a[0];
ll y=a[1];
ll z=a[2];
x=z-x;
y=z-y;
cnt+=x/2;
cnt+=y/2;
x%=2;
y%=2;
if(x && y)cnt+=1;
else if(x!=y)cnt+=2;
cout<<cnt<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M, A, X = 0;
cin >> N;
vector<string> blue(N);
for (int i = 0; i < N; i++){
cin >> blue.at(i);
}
cin >> M;
vector<string> red(M);
for (int i = 0; i < M; i++){
cin >> red.at(i);
}
for (int i = 0; i < N; i++){
A = 1;
for (int j = i + 1; j < N; j++){
if (blue.at(i) == blue.at(j)){
A += 1;
}
}
for (int k = 0; k < M; k++){
if (blue.at(i) == red.at(k)){
if (A == 0)
continue;
A -= 1;
}
}
if (X < A)
X = A;
}
cout << X << endl;
}
| 0
| 19,238,414
|
#include <iostream>
#include <fstream>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define inf 1e18
#define ceill(a, b) (a+b-1)/b
#define ok cout << "ok" << endl;
#define sp << " " <<
ll mod = 1e9+7;
void ans(bool b, ostream& out=cout){ out << (b ? "Yes" : "No") << endl; }
void ans2(bool b, ostream& out=cout){ out << (b ? "YES" : "NO") << endl; }
template<typename T> inline bool chmax(T &a, T b){ if(a<b) a=b; return a<b; }
template<typename T> inline bool chmin(T &a, T b){ if(b<a) a=b; return b<a; }
template<typename A, size_t N, typename T> void Fill(A (&array)[N], const T &val){fill((T*)array, (T*)(array+N), val);}
int dx[] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, -1, 1};
#ifndef INCLUDE_DEBUG_HPP
#define INCLUDE_DEBUG_HPP
class debug
{
public:
template<typename T> void vdeb(T vec);
template<typename T1, typename T2> void adeb(T1 *arr, T2 n);
template<typename T> void mdeb(T mp);
};
#endif
template<typename T> void debug::vdeb(T vec)
{
cout << "#vector set debug" << endl;
for(auto vv : vec) cout << vv << " ";
cout << endl;
}
template<typename T1, typename T2> void debug::adeb(T1 *arr, T2 n)
{
cout << "#adebug" << endl;
for(int i=0; i<=n; i++) cout << arr[i] << " ";
cout << endl;
}
template<typename T> void debug::mdeb(T mp)
{
cout << "#map pair debug" << endl;
for(auto const& m : mp) cout << m.first sp m.second << endl;
}
debug dbg;
class AGarden {
public:
void solve(std::istream& in, std::ostream& out)
{
int a, b;
in >> a >> b;
out << (a-1) * (b-1) << endl;
}
};
int main() {
AGarden solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long MOD = 1e9+7;
template <typename T>
T modPow(T base, T e, T mod) {
if(e==0) return 1;
if(e==1) return base%mod;
if(e%(T)2==1) return (base * modPow(base, e-(T)1, mod)) %mod;
T tmp = modPow(base, e/(T)2, mod);
return (tmp * tmp) % mod;
}
template <typename T>
T primeModDiv(T num, T den, T primeMod){
return ( num*modPow(den, primeMod-(T)2, primeMod) )%primeMod;
}
template <typename T>
T modComb(T n, T k, T mod) {
T num = (T)1;
T den = (T)1;
if (k > n-k) k = n-k;
for (T i = 1; i <= k; i++) {
num *= (n-i+(T)1);
num %= mod;
den *= i;
den %= mod;
}
return primeModDiv(num, den, mod);
}
int main(){
long X, Y;
cin >> X >> Y;
long xMove1 = -1;
long xMove2 = -1;
for (int move2 = 0; move2 <= X/2; move2++) {
int move1 = X - 2*move2;
if (Y==2*move1+move2) {
xMove1 = move1;
xMove2 = move2;
break;
}
}
if (xMove1==-1) {
cout << 0 << endl;
return 0;
}
cout << modComb(xMove1+xMove2, xMove1, MOD) << endl;
}
| 0
| 77,742,758
|
#include<bits/stdc++.h>
#define pb push_back
#define pii pair<int,int>
#define vi vector<int>
#define vii vector<pair<int,int>>
#define mp make_pair
#define FOR(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR1(i, n) for (int i = 1; i <= (int)(n); i++)
#define FORD0(i, n) for (int i = (int)n; i >= 0; i--)
#define FORD1(i, n) for (int i = (int)n; i >= 1; i--)
#define debug(X) { cout << #X << " = " << (X) << endl; }
#define int long long int
using namespace std;
int n;
char mock(int x){
if((to_string(x) <= to_string(n) && x <= n) ||
(to_string(x) > to_string(n) && x > n))return 'Y';
return 'N';
}
bool query(int x){
while(x < 1e10)x *= 10;
cout << "? " << x << endl;
string s;cin >> s;
if(s == "Y")return true;
else return false;
}
bool query1(int x){
cout << "? " << x << endl;
string s;cin >> s;
if(s == "Y")return true;
else return false;
}
void ans(int x){
cout << "! " << x << endl;
}
signed main(){
ios_base::sync_with_stdio(false);cin.tie(NULL);
int prev = 0;
for(int dig = 1; dig <= 10; dig++){
int s = 0, e = 9;
int temp = -1;
while(s <= e){
int mid = (s +e) >> 1;
int x = prev*10 + mid;
if(query1(x)){
temp = mid;
s = mid+1;
}else{
e = mid-1;
}
}
if(temp == 9){
bool last = false;
if(!query(prev*10 + 8)){
if(!query1((prev*100 + 80)))last= true;
}else{
last = true;
}
if(!last)goto leave;
FOR(i, 9+1){
if(prev == 0 && i == 0)continue;
if(query(prev*10 + i)){
prev= prev*10 + i;
break;
}
}
break;
}
leave:
prev = (prev)*10 + temp;
}
ans(prev);
}
|
#include <iostream>
#include <array>
#include <vector>
using namespace std;
int main()
{
vector< int > vec;
int n, tmp;
cin >> n;
array< int, 10001 > arr;
for ( int i = 0 ; i < 10001 ; i++ )
{
arr[i] = 0;
}
for ( int i = 0 ; i < n ; i++ )
{
cin >> tmp;
arr[tmp]++;
}
for ( int i = 0 ; i < 10001 ; i++ )
{
if ( arr[i] != 0 )
{
tmp = i;
for ( int j = 0 ; j < arr[tmp] ; j++ )
{
vec.push_back( tmp );
}
}
}
for ( int i = 0 ; i < n ; i++ )
{
if ( i != n - 1 )
{
cout << vec[i] << " ";
}
else
{
cout << vec[i] << endl;
}
}
return 0;
}
| 0
| 21,531,410
|
#include <bits/stdc++.h>
using namespace std;
int main(){
string N;
int K;
cin>>N>>K;
long long dp[100][1000];
dp[1][1]=9;
dp[2][1]=0;
dp[3][1]=0;
for(int i=2;i<=(int)N.size();i++){
dp[1][i]=9*i;
dp[2][i]=9*dp[1][i-1]+dp[2][i-1];
dp[3][i]=9*dp[2][i-1]+dp[3][i-1];
}
if(K==1){cout<<dp[1][(int)N.size()-1]+(N.at(0)-'0')<<endl;}
if(K==2){
long long ans=dp[1][(int)N.size()-1]*(N.at(0)-'0'-1)+dp[2][(int)N.size()-1];
while((int)N.size()>=2){
N=N.substr(1);
if(N.at(0)!='0'){
ans+=dp[1][(int)N.size()-1];
ans+=N.at(0)-'0';
break;
}
}
cout<<ans<<endl;
}
if(K==3){
long long ans=dp[3][(int)N.size()-1]+dp[2][(int)N.size()-1]*(N.at(0)-'0'-1);
while((int)N.size()>=3){
N=N.substr(1);
if(N.at(0)!='0'){
ans+=dp[2][(int)N.size()-1];
ans+=dp[1][(int)N.size()-1]*(N.at(0)-'0'-1);
while((int)N.size()>=2){
N=N.substr(1);
if(N.at(0)!='0'){
ans+=dp[1][(int)N.size()-1];
ans+=N.at(0)-'0';
if(ans!=0){
cout<<ans<<endl;
return 0;
}
}
cout<<ans<<endl;
return 0;
}
}
}
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll,ll> P;
typedef pair<int,int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
#define endl "\n"
template<typename T> inline bool chmax(T &a, T b){if(a<b){a=b;return true;}return false;}
template<typename T> inline bool chmin(T &a, T b){if(a>b){a=b;return true;}return false;}
template<typename T> ostream& operator<<(ostream& s,const complex<T>& d) {return s<<"("<<d.real()<<", "<<d.imag()<< ")";}
template<typename T1, typename T2> ostream& operator<<(ostream& s,const pair<T1,T2>& d) {return s<<"("<<d.first<<", "<<d.second<<")";}
template<typename T> ostream& operator<<(ostream& s, const vector<T>& d){
int len=d.size();
rep(i,len){
s<<d[i];if(i<len-1) s<<" ";
}
return s;
}
template<typename T> ostream& operator<<(ostream& s,const vector<vector<T>>& d){
int len=d.size();
rep(i,len){
s<<d[i]<<endl;
}
return s;
}
template<typename T> ostream& operator<<(ostream& s,const set<T>& v){
s<<"{ ";
for(auto itr=v.begin();itr!=v.end();++itr) {
if (itr!=v.begin()) {s<< ", ";}
s<<(*itr);
}
s<<" }";
return s;
}
template<typename T1, typename T2> ostream& operator<<(ostream& s,const map<T1,T2>& m){
s<<"{"<<endl;
for(auto itr=m.begin();itr!=m.end();++itr){
s<<" "<<(*itr).first<<" : "<<(*itr).second<<endl;
}
s<<"}"<<endl;
return s;
}
const ll mod=1e9+7;
const ll inf=1e17;
const int INF=1e9;
const double PI=acos(-1);
const double EPS=1e-10;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n,h,w;
cin>>n>>h>>w;
int ans=0;
rep(i,n){
int a,b;
cin>>a>>b;
if(a>=h && b>=w) ans++;
}
cout<<ans<<endl;
}
| 0
| 69,287,433
|
#include <cstdio>
#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <string>
#include <cmath>
#include <functional>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#define rep(i,n) for (int i=0;i<n;i++)
using ll = long long;
using namespace std;
void solve(){
}
int main (){
ios::sync_with_stdio(0);
cin.tie(0);
vector<int> a(5);
int m=0;
int ans=0;
rep(i,5){
cin >> a[i];
}
rep(i,5){
if(a[i]%10==0){
ans+=a[i];
}
else{
int l = 10-a[i]%10;
ans+=a[i]+l;
m = max(m,l);
}
}
cout << ans-m;
return 0;
}
|
#include<iostream>
using namespace std;
int main(void) {
string firstInput;
string secondInput;
int firstScore = 0;
int secondScore = 0;
int num;
cin >> num;
for(int i = 0; i < num; i++) {
cin >> firstInput;
cin >> secondInput;
int cond = firstInput.compare(secondInput);
if(cond == 0) {
firstScore += 1;
secondScore += 1;
}
else if(cond > 0) {
firstScore += 3;
}
else {
secondScore += 3;
}
}
cout << firstScore << " " << secondScore << endl;
return 0;
}
| 0
| 92,029,418
|
#include <iostream>
#include <algorithm>
#include <math.h>
#include <vector>
#include <string>
#include <queue>
#include <map>
#include <utility>
#include <iomanip>
#include <set>
using namespace std;
using ll = long long;
#define rep(i,a,b) for(ll i=(a); i<(b); i++)
#define YES cout << "YES" << endl;
#define NO cout << "NO" << endl;
#define yes cout << "Yes" << endl;
#define no cout << "No" << endl;
#define pai 3.14159265358979323846
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() {
ll n,x;
cin >> n >>x;
vector <ll> a(n);
rep(i, 0,n) {
cin>> a[i];
a[i] -=x;
}
ll ans = abs(a[0]);
for (ll i=0;i< n;i++) {
ans = gcd(ans,abs(a[i]));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define F first
#define S second
#define MP make_pair
#define pb push_back
#define all(a) a.begin(), a.end()
#define lcm( a, b ) (a)/__gcd((a),(b))*(b)
#define endl '\n'
using namespace std;
typedef long long LL;
typedef pair< int, int > P;
typedef pair< LL, LL > LP;
static const int INF = INT_MAX;
static const LL LINF = LLONG_MAX;
static const int MIN = INT_MIN;
static const LL LMIN = LLONG_MIN;
static const int MOD = 1000000007;
static const int SIZE = 200005;
const int dx[] = {0, -1, 1, 0};
const int dy[] = {-1, 0, 0, 1};
LL fac[SIZE], finv[SIZE], inv[SIZE];
void combInit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for( int i = 2; i < SIZE; ++i ) {
fac[i] = (fac[i - 1] * i) % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = (finv[i - 1] * inv[i]) % MOD;
}
}
LL comb(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;
}
vector< int > Div( int n ) {
vector< int > ret;
for( int i = 1; i * i <= n; ++i ) {
if( n % i == 0 ) {
ret.pb( i );
if( i * i != n ) ret.pb( n / i );
}
}
sort( all( ret ) );
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
LL n, K;
cin >> n >> K;
vector< LP > v(n);
for( int i = 0; i < n; ++i ) {
cin >> v[i].F >> v[i].S;
}
LL res = LINF;
for( int i = 0; i < n; ++i ) {
for( int j = 0; j < n; ++j ) {
for( int k = 0; k < n; ++k ) {
for( int l = 0; l < n; ++l ) {
LL xmin, xmax, ymin, ymax;
xmin = min(v[i].F, min(v[j].F, min(v[k].F, v[l].F)));
xmax = max(v[i].F, max(v[j].F, max(v[k].F, v[l].F)));
ymin = min(v[i].S, min(v[j].S, min(v[k].S, v[l].S)));
ymax = max(v[i].S, max(v[j].S, max(v[k].S, v[l].S)));
int cnt = 0;
for( int m = 0; m < n; ++m ) {
if( xmin <= v[m].F && v[m].F <= xmax &&
ymin <= v[m].S && v[m].S <= ymax ) {
++cnt;
}
}
if( K <= cnt ) {
res = min(res, (xmax - xmin) * (ymax - ymin));
}
}
}
}
}
cout << res << endl;
return 0;
}
| 0
| 62,868,891
|
#include<bits/stdc++.h>
using namespace std;
int main(){
long long int N ;
string S , T;
cin >> N >> S >> T ;
for(long long int i = 0; i < N; i++) cout << S[i] << T[i];
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define X 1001100011100001111ll
#define mod 1000000007
#define ll long long
#define all(a) a.begin(),a.end()
#define sortall(a) sort(all(a))
#define fo(i, n) for (int i = 0; i < n; i++)
#define fo1(i, n) for (int i = 1; i <= n; i++)
#define loop(i,a,b) for (int i = a; i < b; i++)
#define nloop(i,a,b) for (int i = a ; i>=b;i--)
#define tc(t) int t; cin >> t; while (t--)
#define arrip(n) int a[n]; fo(i, n) cin >> a[i];
#define arrop(n) fo(i,n) cout<<a[i]<<" ";
#define pb push_back
#define mp make_pair
#define itr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626
#define fio ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define rr return 0
#define prec(n) fixed<<setprecision(n)
#define maxpq priority_queue<int>
#define minpq priority_queue<int, vector<int>, greater<int> >
#define inf (int)(1e18)
#define ini(a, i) memset(a, i, sizeof(a))
#define vi vector<int>
#define fi first
#define se second
#define endl "\n"
#define pi pair<int, int>
#define vpi vector<pi>
#define sz(s) s.size()
#define bits(n) __builtin_popcount(n)
const int MAXN = (int)((1e5) + 100);
int gcd(int a, int b) { if (a == 0) return b; return gcd(b % a, a);}
int max(int a, int b) {if (a > b) return a; else return b;}
int min(int a, int b) {if (a < b) return a; else return b;}
int32_t main()
{
#ifndef ONLINE_JUDGE
freopen("atcoderi.txt", "r", stdin);
freopen("atcodero.txt", "w", stdout);
#endif
fio;
int n, a, b;
cin >> n >> a >> b;
int x = (n / (a + b));
int c = x * a;
n = n % (a + b);
c = c + min(n, a);
cout << c << endl;
}
| 0
| 17,047,199
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <cmath>
#include <climits>
#include <iomanip>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
int main(){
ll n = 0;
cin >> n;
double res = 0;
for(int i = 0;i < n;i++){
double in;
string t;
cin >> in >> t;
if(t[0] == 'J')res += in;
else res += in * 380000;
}
cout << fixed << setprecision(20) << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
ll a[n + 2], sum = 0, cur = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += abs(cur - a[i]);
cur = a[i];
if (i == n) sum += abs(cur - 0);
}
a[0] = a[n + 1] = 0;
for (int i = 1; i <= n; i++) {
cout << sum - (abs(a[i - 1] - a[i]) + abs(a[i] - a[i + 1])) + abs(a[i - 1] - a[i + 1]) << '\n';
}
}
| 0
| 41,858,451
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
int main(void){
int n,a,b; cin>>n>>a>>b;
int k;
int ans=0;
for(int i=1;i<=n;i++){
k=0;
int m=i;
while(m>0){
k+=m%10;
m=m/10;
}
if(a<=k&&k<=b){
ans+=i;
}
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
#define rrep(i,n) for (int i=(n)-1;i>=0;i--)
#define rrep2(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define all(a) (a).begin(),(a).end()
typedef long long ll;
typedef pair<int, int> P;
typedef tuple<int, int, int> TUPLE;
typedef vector<int> V;
typedef vector<V> VV;
typedef vector<VV> VVV;
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n, m;
while (cin >> n >> m, n) {
vector<P> v(n);
rep(i, n) {
cin >> v[i].second >> v[i].first;
}
sort(all(v));
reverse(all(v));
v.emplace_back(0, 1e9);
int ans = 0;
for (auto pa : v) {
int safe = min(m, pa.second);
m -= safe;
ans += pa.first * (pa.second - safe);
}
cout << ans << endl;
}
}
| 0
| 93,224,739
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) begin(v),end(v)
#define fi first
#define se second
template<typename A, typename B> inline bool chmax(A &a, B b) { if (a<b) { a=b; return 1; } return 0; }
template<typename A, typename B> inline bool chmin(A &a, B b) { if (a>b) { a=b; return 1; } return 0; }
using ll = long long;
using pii = pair<int, int>;
constexpr ll INF = 1ll<<30;
constexpr ll longINF = 1ll<<60;
constexpr ll MOD = 1000000007;
constexpr bool debug = 0;
int main() {
int N;
cin >> N;
vector<int> A(N);
REP(i, N) cin >> A[i];
ll ans = 1000;
REP(i, N - 1) if (A[i] < A[i + 1]) ans = ans / A[i] * A[i + 1] + ans % A[i];
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define INF 1e9
using namespace std;
#define REPR(i,n) for(int i=(n); i >= 0; --i)
#define FOR(i, m, n) for(int i = (m); i < (n); ++i)
#define REP(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define ALL(a) (a).begin(),(a).end()
#define endl "\n"
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return true; } return false; }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
typedef long long ll;
void solve() {
int N,K;
cin >> N >> K;
vector<ll> vmx(N+2,0);
vector<ll> vmn(N+2,0);
REP(i,N+1) {
vmx[i+1] = (N-i) + vmx[i];
vmn[i+1] = i + vmn[i];
}
ll sm = 0;
FOR(i,K,N+2) sm+= (vmx[i]-vmn[i]+1);
cout << (sm%ll(1e9+7)) << endl;
}
int main() {
solve();
return 0;
}
| 0
| 4,760,102
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.