code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 2
101M
|
|---|---|---|---|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i,n) for(ll i=0; i<n; i++)
#define loop(i, j, n) for(ll i=j; i<n; i++)
#define all(x) (x).begin(), (x).end()
constexpr int INF = 0x3f3f3f3f;
const long long mod=1e9+7;
const long double PI = acos(-1);
int calc(int n){
int sum =0;
while(n>0){
sum+=n%10;
n/=10;
}
return sum;
}
int main() {
int n, a, b, ans = 0;
cin >> n >> a >> b;
loop(i, 1, n+1){
int k = calc(i);
if(k>=a && k<=b) ans+=i;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define ld long double
#define ll long long int
#define ull unsigned long long int
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define lb lower_bound
#define ub upper_bound
#define deb(x) cout<<"#x "<<x<<"\n";
#define trace(x,y) cout<<"#x "<<x<<" #y "<<y<<"\n";
#define cn cout<<"\n";
bool SBF(const pair <int,int>& a, const pair<int,int>& b){return a.F<b.F;}
bool SBS(const pair <int,int>& a, const pair<int,int>& b){return a.S<b.S;}
const long double PI = 3.1415926535;
const long long mod = 1e9+ 7;
const int mxN = 1000;
const long long INF = 1e9;
int n , a, b;
void solve(){
cin >> n;
if(n <1200)cout<<"ABC\n";
else cout<<"ARC\n";
}
int main(){
solve();
return 0;
}
| 0
| 7,594,728
|
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define ll long long
#define ull unsigned long long
#define si set <ll>
#define vi vector <ll>
#define popcount(x) __builtin_popcountll(x)
#define mii map <ll,ll>
#define vpi vector <pair <ll,ll> >
#define sz(c) (int)c.size()
#define fr first
#define ll long long
#define fastio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define sc second
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(),(a).end()
#define mem0(a) memset(a,0,sizeof(a))
#define rep(i,a,n) for(ll i=a ; i<n ; i++)
#define ld long double
#define rall(a) (a).rbegin(),(a).rend()
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")
ll power(ll b,ll e,ll m)
{
if(b==0) return 0;
if(e==0) return 1;
if(e&1) return b*power(b*b%m,e/2,m)%m;
return power(b*b%m,e/2,m);
}
ll power( ll b, ll e)
{
if(b==0) return 0;
if(e==0) return 1;
if(e&1) return b*power(b*b,e/2);
return power(b*b,e/2);
}
bool isPowerOfTwo(ll x)
{
return (x && !(x & (x - 1)));
}
void solve()
{
ll n,k;
cin>>n>>k;
cout<<k*power(k-1,n-1);
}
int main()
{
ll tt=1;
while(tt--)
{
solve();
cout<<"\n";
}
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
ll k, a, b; cin >> k >> a >> b;
ll cur = 0;
if(a < b) {
ll tim = k - (a - 1);
if(tim >= 2) {
cur += b;
}
cur += ((tim - 2) / 2) * (b - a);
cur += (tim % 2);
}
cout << max(cur, k + 1) << endl;
}
| 0
| 63,094,316
|
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define repLRE(i, l, r) for (ll i = (l); i <= (r); ++i)
#define rrepLRE(i, l, r) for (ll i = (l); i >= (r); --i)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vector<ll>>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;
ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
const ll INF = 1LL << 50;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
ll n, a, b;
cin >> n >> a >> b;
if (a > b) {
cout << 0 << endl;
return 0;
}
if (n == 1) {
if (a == b)
cout << 1;
else
cout << 0;
return 0;
}
if(n == 2) {
cout << 1 << endl;
return 0;
}
ll ma = b * (n - 1) + a;
ll mi = a * (n - 1) + b;
ll ans = ma - mi + 1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
int main() {
ll N;
cin >> N;
ll ans =0;
vector<ll> C(N),S(N),F(N);
for(int i=0;i<N-1;i++){
cin >> C[i] >>S[i] >>F[i];
}
for(int i=0;i<N;i++){
ll ans =0;
for(int j=i;j<N-1;j++){
if(ans<=S[j]){
ans = S[j];
}else{
ll n= (ans-S[j] +F[j]-1)/F[j];
ans = S[j]+F[j]*n;
}
ans += C[j];
}
cout << ans << endl;
}
return 0;
}
| 0
| 85,993,842
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int H,N;
cin>>H>>N;
vector<int>A;
for (int i = 0; i < N; i++)
{
int a;
cin>>a;
A.push_back(a);
}
for (auto a:A)
{
H-=a;
}
if(H>0)
{
cout<<"No"<<endl;
}
else
{
cout<<"Yes"<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define mp make_pair
#define eb emplace_back
#define ff first
#define ss second
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#ifdef ONPC
mt19937 rnd(228);
#else
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#endif
const int MAXN = 100;
const int INF = 1e9;
struct ed {
int a, b, c;
ed() {}
ed(int aa, int bb, int cc){
a = aa;
b = bb;
c = cc;
}
int get(int u){
if (u == a) return b;
return b;
}
};
int n, m;
vector<int> g[MAXN];
int d[MAXN][MAXN];
vector<ed> e;
void read(){
cin >> n >> m;
int a, b, c;
memset(d, 0x3f, sizeof d);
for (int i = 0; i < n; i++) d[i][i] = 0;
for (int i = 0; i < m; i++){
cin >> a >> b >> c;
a--, b--;
g[a].eb(i);
g[b].eb(i);
e.eb(a, b, c);
d[a][b] = c;
d[b][a] = c;
}
}
void floyd(){
for (int k = 0; k < n; k++){
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++){
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
}
void solve(){
read();
floyd();
int ans = 0;
for (auto ei: e){
int f = 1;
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++){
if (i == j) continue;
if (d[i][ei.a] + ei.c + d[ei.b][j] <= d[i][j]) f = 0;
}
}
ans += f;
}
cout << ans << '\n';
}
signed main()
{
#ifdef FILEIO
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 0
| 60,955,723
|
#include<iostream>
using namespace std;
typedef long long int ll;
const int maxn=2e5+10;
const int mod=1e9+7;
ll a[maxn];
int main(){
a[1]=0;
a[2]=0;
a[3]=1;
for(int i=4;i<maxn;i++){
a[i]=(a[i-1]+a[i-3])%mod;
}
int n;
cin>>n;
cout<<a[n]<<endl;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
struct data_t {
int b;
int f;
int r;
int v;
bool operator<(const data_t& right) const {
return b == right.b ? f == right.f ? r < right.r : f < right.f : b < right.b;
}
};
int main(void) {
int n;
int count[4][3][10] = {};
int b,f,r,v;
cin >> n;
vector<data_t> data_array(n);
for(int i = 0; i < n; i++) {
cin >> b >> f >> r >> v;
data_array[i].b = b;
data_array[i].f = f;
data_array[i].r = r;
data_array[i].v = v;
}
sort(data_array.begin(), data_array.end());
int t = 0;
for(int i = 0; i < 4; i++) {
for(int j = 0; j < 3; j++) {
for(int k = 0; k < 10; k++) {
while(i + 1 == data_array[t].b && j + 1 == data_array[t].f && k + 1 == data_array[t].r) {
count[i][j][k] += data_array[t++].v;
}
}
}
}
for(int i = 0; i < 4; i++) {
for(int j = 0; j < 3; j++) {
for(int k = 0; k < 10; k++) {
if(count[i][j][k])
cout << ' ' << count[i][j][k];
else
cout << ' ' << '0';
}
cout << endl;
}
if(i < 3)
cout << "####################" << endl;
}
return 0;
}
| 0
| 82,277,526
|
#include <bits/stdc++.h>
#define ll long long
#define MODV 1000000007
#define INF INT_MAX
#define INFLL LLONG_MAX
#define rep(i, n) for(ll i=0, i##_len=(ll)(n); i<i##_len; i++)
#define repf(i, n) for(ll i=1, i##_len=(ll)(n+1); i<i##_len; i++)
#define per(i, n) for(ll i=((ll)(n))-1; i>=0; i--)
#define perf(i, n) for(ll i=((ll)(n)); i>0; i--)
#define all(v) v.begin(), v.end()
#define endl "\n"
#define vi vector<ll>
#define vvi vector<vector<ll>>
#define Yes() cout << "Yes" << endl
#define YES() cout << "YES" << endl
#define No() cout << "No" << endl
#define NO() cout << "NO" << endl
#define Init() std::ios::sync_with_stdio(false); std::cin.tie(0); std::cout<<fixed<<setprecision(15);
template<class T>bool chmax(T &a, const T &b){ if(a<b){ a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b){ if(b<a){ a=b; return 1; } return 0; }
using namespace std;
int main(){
Init();
ll n, t, sum = 0; cin >> n >> t;
ll pt; cin >> pt;
rep(i, n-1){
ll np; cin >> np;
if(np-pt >= t) sum += t;
else sum += np-pt;
pt = np;
}
sum += t;
cout << sum << endl;
}
|
#include <stdlib.h>
#include <string>
#include <iostream>
using namespace std;
class node{
public:
int data;
node *prev;
node *next;
node(){
prev = 0;
next = 0;
data = 0;
}
node(int data){
prev = 0;
next = 0;
this->data = data;
}
node(int data, node *next){
prev = 0;
this->next = next;
this->data = data;
} friend class double_linked_list;
};
class double_linked_list{
public:
node *first;
node *last;
double_linked_list(){
first = 0;
last = 0;
}
void insert_value(int data);
void delete_value(int data);
void delete_first();
void delete_last();
};
void double_linked_list::insert_value(int data){
if(first == 0){
node *new_first = new node(data);
first = new_first;
last = new_first;
}else{
node *new_first = new node(data, first);
first->prev = new_first;
first = new_first;
}
}
void double_linked_list::delete_value(int data){
node *current_node = first;
if(current_node == 0){
return;
}
if(current_node->data == data){
this->delete_first();
return;
}
current_node = current_node->next;
while(current_node != 0){
if(current_node->data == data){
if(current_node->next != 0){
current_node->prev->next = current_node->next;
current_node->next->prev = current_node->prev;
}else{
current_node->prev->next = 0;
last = current_node->prev;
}
return;
}
current_node = current_node->next;
}
}
void double_linked_list::delete_first(){
node *current_node = first;
if(current_node == 0){
return;
}
if(current_node->next != 0){
current_node->next->prev = 0;
first = current_node->next;
return;
}
first = 0;
last = 0;
return;
}
void double_linked_list::delete_last(){
if(this->last == 0){
return;
}
if(last->prev != 0){
last->prev->next = 0;
last = last->prev;
}else{
last = 0;
first = 0;
}
}
int main(){
int num;
cin >> num;
char command[12];
int value;
double_linked_list *result_list = new double_linked_list();
for(int i = 0; i < num; ++i){
cin >> command;
if(command[0] == 'i'){
cin >> value;
result_list->insert_value(value);
}else{
if(command[6] == '\0'){
cin >> value;
result_list->delete_value(value);
}
else if(command[6] == 'F'){
result_list->delete_first();
}
else if(command[6] == 'L'){
result_list->delete_last();
}
}
}
node *test = result_list->first;
while(test != 0){
cout << test->data;
if(test->next != 0){
cout << " ";
}
test = test->next;
}
cout << endl;
return 0;
}
| 0
| 20,034,417
|
#include<iostream>
using namespace std;
int main(){
int num,oturi,m = 0;
while(1){
cin>>num;
if(num==0){
break;
}else{
oturi=1000-num;
m = oturi/500;
m = m+oturi%500/100;
m = m+oturi%500%100/50;
m = m+oturi%500%100%50/10;
m = m+oturi%500%100%50%10/5;
m = m+oturi%500%100%50%10%5/1;
num = 0;
}
cout<<m<<'\n';
}
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<map>
#define rep(i, start, end) for (int i = (int)start; i < (int)end; ++i)
#define rrep(i, start, end) for (int i = (int)start - 1; i >= end; --i)
#define all(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
template<typename T> inline bool chmax(T& a, T b) {if (a < b) {a = b; return true;} return 0;}
template<typename T> inline bool chmin(T& a, T b) {if (a > b) {a = b; return true;} return 0;}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> A(N);
for (auto& a : A) {
cin >> a;
}
vector<int> B(A);
sort(all(B));
map<int, int> pos_map;
rep(i, 0, B.size()) {
pos_map[B[i]] = i + 1;
}
vector<int> C(N);
rep(i, 0, N) {
C[i] = pos_map[A[i]];
}
int ans = 0;
for (int i = 1; i < N; i += 2) {
ans += C[i] % 2;
}
cout << ans << endl;
return 0;
}
| 0
| 75,504,776
|
# include <bits/stdc++.h>
# define sz(x) (int)((x).size())
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair < int, int > pii;
const int N = (int)2e5 + 5;
const int inf = (int)1e9 + 7;
int n;
int a[N];
set < int > pos;
map < int, int > val;
int ok(int x){
pos.clear(), val.clear();
for(int i = 2; i <= n; ++i){
if(a[i] > a[i - 1]){
continue;
} else{
while(!pos.empty() && *pos.rbegin() > a[i]){
val.erase(*pos.rbegin());
pos.erase(--pos.end());
}
for(int j = a[i]; j >= 1; --j){
val[j]++;
if(val[j] == x){
if(x == 1) return 0;
if(j == 1) return 0;
val[j] = 0;
pos.erase(j);
val.erase(j);
} else{
pos.insert(j);
break;
}
}
}
}
return 1;
}
int main(){
scanf("%d", &n);
for(int i = 1; i <= n; ++i){
scanf("%d", a + i);
}
int ans = n;
for(int j = (1 << 20); j > 0; j >>= 1){
if(ans > j && ok(ans - j)){
ans -= j;
}
}
printf("%d\n", ans);
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define rep(i,a,b) for(int i=(a), i##_len=(b);i<i##_len;i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define all(c) begin(c),end(c)
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<double, double> pdd;
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 (b < a) { a = b; return true; } return false; }
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
struct UnionFind
{
vector<int> parent;
vector<int> rank;
UnionFind(int N) :parent(N, 0), rank(N, 0)
{
rep(i, 0, N)
{
parent[i] = i;
}
}
int find(int x)
{
if (parent[x] == x)
{
return x;
}
else
{
return parent[x] = find(parent[x]);
}
}
void unite(int x, int y)
{
x = find(x);
y = find(y);
if (x == y)
{
return;
}
if (rank[x] < rank[y])
{
parent[x] = y;
}
else
{
parent[y] = x;
if (rank[x] == rank[y])
{
rank[x]++;
}
}
}
bool same(int x, int y)
{
return find(x) == find(y);
}
};
int d[50][50];
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
while (true)
{
int n;
cin >> n;
if (n == 0)
{
break;
}
rep(i, 0, 50)rep(j, 0, 50)if (i != j)d[i][j] = INF;
int a, b, c;
int vn = 0;
rep(i, 0, n)
{
cin >> a >> b >> c;
d[a][b] = c;
d[b][a] = c;
chmax(vn, max(a, b) + 1);
}
rep(k, 0, vn)rep(i, 0, vn)rep(j, 0, vn)
{
if (d[i][k] != INF&&d[k][j] != INF)
{
chmin(d[i][j], d[i][k] + d[k][j]);
}
}
int ansi, ansv = INF;
rep(i, 0, vn)
{
int tans = 0;
rep(j, 0, vn)
{
tans += d[i][j];
}
if (chmin(ansv, tans))
{
ansi = i;
}
}
cout << ansi << " " << ansv << endl;
}
return 0;
}
| 0
| 43,048,255
|
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);
#define all(x) x.begin(),x.end()
#define pb push_back
#define pf push_front
#define ff first
#define ss second
#define vll vector<ll>
#define sll set<ll>
#define pll pair<ll, ll>
#define vpll vector<pll>
#define endl "\n"
const ll maxn = 2e5+2;
int main()
{
fastio;
ll i, j, k, n, m, t;
ll x;
ll flag[maxn];
memset(flag,0,sizeof(flag));
cin>>x>>n;
for ( i = 0; i < n; i++)
{
cin>>j;
flag[j]=1;
}
j=1;
if(flag[x]==0)
{
cout<<x<<endl;
return 0;
}
while (1)
{
if(flag[x-j]==0)
{
cout<<x-j<<endl;
break;
}
if(flag[x+j]==0)
{
cout<<x+j<<endl;
break;
}
j++;
}
return 0;
}
|
using namespace std;
#include<bits/stdc++.h>
#define int long long
#define pb push_back
#define IOS ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define ff first
#define ss second
#define all(x) x.begin(), x.end()
#define repa(i,a,b) for (int i=a; i<=b; i++)
#define repd(i,b,a) for (int i=b; i>=a; i--)
#define endl "\n"
#define debug1(a) cout<<#a<<" = "<<(a)<<endl;
#define debug2(a,b) cout<<#a<<" = "<<(a)<<", "<<#b<<" = "<<(b)<<endl;
#define debug3(a,b,c) cout<<#a<<" = "<<(a)<<", "<<#b<<" = "<<(b)<<", "<<#c<<" = "<<(c)<<endl;
#define debug4(a,b,c,d) cout<<#a<<" = "<<(a)<<", "<<#b<<" = "<<(b)<<", "<<#c<<" = "<<(c)<<", "<<#d<<" = "<<(d)<<endl;
const int N = 1e+6+5;
int big = 1e+18+3;
int mod = 1e+9+7;
signed main()
{
IOS;
int s; cin>>s;
map<int,int>exist;
exist[s]=1;
int prev = s;
for (int i=2; ;i++)
{
int res;
if ( prev%2==0 )
res = prev/2;
else
res = prev*3+1;
if (exist[res])
{
cout<<i<<endl;
return 0;
}
exist[res]=1;
prev = res;
}
}
| 0
| 46,427,050
|
#include <bits/stdc++.h>
#include <numeric>
using namespace std;
#define ll long long
#define mod107 1000000007
#define rep(i, n) for (int i = 0; i < n; ++i)
using Graph = vector<vector<int>>;
#define grepq priority_queue<double, std::vector<double>, std::greater<double>>
#define all(v) v.begin(), v.end()
#define PI acos(-1)
const ll INF = 10010001010;
const int inf = 2000000000;
typedef tuple<string, int, int> TUP;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int main()
{
int N;
cin >> N;
vector<int> A(N);
int ans = 0;
for (int i = 0; i < N; i++)
{
cin >> A[i];
}
for (int i = 0; i < N;i++)
{
if(i+1 == A[A[i]-1]){
ans++;
}
}
if(ans == 0){
cout << ans << endl;
}
else{
cout << ans/2 << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
typedef pair<int,int> P;
const int INF=1e9;
int main(){
int n,now=1,ans=0;
cin>>n;
vector<int> a(n);
rep(i,n) cin>>a[i];
for(int i=0;i<n;i++){
if(a[i]==now){
now++;
}
else ans++;
}
if(ans==n) cout<<"-1";
else cout<<ans;
}
| 0
| 9,020,889
|
#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 <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;
int main(){
int n,h,m,s;
char str;
int temp;
while(1){
int t[86401]={0};
int max=t[0];
cin>>n;
if(n==0)
break;
for(int i=0;i<n;i++){
cin>>h>>str>>m>>str>>s;
temp=h*3600+m*60+s;
t[temp]+=1;
cin>>h>>str>>m>>str>>s;
temp=h*3600+m*60+s;
t[temp]+=-1;
}
for(int i=1;i<=86400;i++){
t[i]+=t[i-1];
if(max<=t[i])
max=t[i];
}
cout<<max<<endl;
}
}
| 0
| 30,408,288
|
#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;
int w;
cin>>S>>w;
rep(i,S.size()){
if(i%w==0){
cout<<S.at(i);
}
}
return 0;}
|
#include<bits/stdc++.h>
using namespace std;
#define cinsc ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(0);
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define FOR(i,k,n) for(int64 i=k;i<(int64)n;i++)
#define FORr(i,k,n) for(int64 i=(int64)k;i>=n;i--)
#define FOREACH(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define FOREACHr(it, l) for (auto it = l.rbegin(); it != l.rend(); it++)
#define IN(A, B, C) assert( B <= A && A <= C)
#define MP make_pair
#define PB push_back
#define INF (int)1e9
#define EPS 1e-9
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define read(type) readInt<type>()
#define SQ(x) ((x)*(x))
const double pi=acos(-1.0);
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef map<int,int> MPII;
typedef set<int> SETI;
typedef multiset<int> MSETI;
typedef long int int32;
typedef unsigned long int uint32;
typedef long long int int64;
typedef unsigned long long int uint64;
const int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int64 powr(int64 x,int64 y,int64 p)
{
int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0){
if (y & 1)
res = (res*x) % p;
y = y>>1;
x = (x*x) % p;
}
return res;
}
void in_o(){
#ifndef LOCAL
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
cinsc;
}
int64 a[51],b[51],c[51],d[51];
int64 dist(int x,int y){
return abs(a[x]-c[y])+abs(b[x]-d[y]);
}
int main(){
int64 n,m;
cin>>n>>m;
FOR(i,0,n){
cin>>a[i]>>b[i];
}
FOR(i,0,m){
cin>>c[i]>>d[i];
}
FOR(i,0,n){
int z=-1;
FOR(j,0,m){
if(z<0 || dist(i,j)<dist(i,z)) z=j;
}
cout<<z+1<<endl;
}
return 0;
}
| 0
| 87,004,838
|
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
priority_queue<int> aque;
for (int i = 0; i < n; i++) {
aque.push(a[i]);
}
for (int i = 0; i < m; i++) {
int p = aque.top();
p /= 2;
aque.pop();
aque.push(p);
}
long s = 0;
for (int i = 0; i < n; i++) {
s += aque.top();
aque.pop();
}
cout << s << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll r[10],c[10];
ll cntr[(1<<10)],cntc[(1<<10)];
string s[10];
bool rr[10],cc[10];
int main() {
ll H,W,K;
cin>>H>>W>>K;
for(ll i=0;i<H;i++) cin>>s[i];
ll sum=0;
for(ll i=0;i<H;i++){
for(ll j=0;j<W;j++){
if(s[i][j]=='#'){
sum++;
}
}
}
for(ll i=0;i<H;i++) {
for (ll j = 0; j < W; j++) {
if (s[i][j] == '#') {
r[i]++;
}
}
}
for(ll i=0;i<W;i++){
for(ll j=0;j<H;j++){
if(s[j][i]=='#'){
c[i]++;
}
}
}
ll limitr=(1<<H);
for(ll i=0;i<limitr;i++){
ll temp=i,now=0,k=0;
while(temp){
if(temp&1){
now+=r[k];
}
k++;
temp>>=1;
}
cntr[i]=now;
}
ll limitc=(1<<W);
for(ll i=0;i<limitc;i++){
ll temp=i,now=0,k=0;
while(temp){
if(temp&1){
now+=c[k];
}
k++;
temp>>=1;
}
cntc[i]=now;
}
ll ans=0;
for(ll i=0;i<limitr;i++){
for(ll j=0;j<limitc;j++){
memset(cc,0,sizeof(cc));
memset(rr,0,sizeof(rr));
ll temp=i,k=0;
while(temp){
if(temp&1) rr[k]=1;
k++;
temp>>=1;
}
temp=j,k=0;
while(temp){
if(temp&1) cc[k]=1;
k++;
temp>>=1;
}
ll cnt=0;
for(ll t=0;t<H;t++){
if(rr[t]){
for(ll k=0;k<W;k++){
if(cc[k]){
if(s[t][k]=='#'){
cnt++;
}
}
}
}
}
if(sum-cntr[i]-cntc[j]+cnt==K) ans++;
}
}
cout<<ans;
return 0;
}
| 0
| 92,582,732
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int i=0;i<(int)(n);++i)
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
const double PI = acos(-1);
const double EPS = 1e-8;
using pi = pair<int,int>;
using P = pair<double,pi>;
int main(){
int n;
scanf(" %d", &n);
vector<P> v;
rep(i,n){
int x,y;
scanf(" %d %d", &x, &y);
double t = atan2(y,x);
if(t<0) t = 2*PI+t;
v.pb({t,{x,y}});
v.pb({t+2*PI,{x,y}});
}
sort(all(v));
int V = v.size();
ll ans = 0;
rep(i,V){
ll x = 0, y = 0;
for(int j=i; j<V; ++j){
if(v[j].fi - v[i].fi > PI+EPS) break;
x += v[j].se.fi;
y += v[j].se.se;
ans = max(ans, x*x+y*y);
}
}
printf("%.15f", sqrt(ans));
return 0;
}
|
#include <cstdio>
int main(void)
{
while (1) {
int h, w;
scanf("%d %d", &h, &w);
if (!h && !w)
break;
for (int y=0; y<h; y++) {
for (int x=0; x<w; x++) {
printf("#");
}
printf("\n");
}
printf("\n");
}
return 0;
}
| 0
| 95,954,567
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
using ll = long long;
using ld = long double;
ll INF = LLONG_MAX;
using vi = vector<int>;
using vll = vector<ll>;
using pii = pair<int, int>;
namespace output {
void pr(int x) { cout << x; }
void pr(long x) { cout << x; }
void pr(ll x) { cout << x; }
void pr(unsigned x) { cout << x; }
void pr(unsigned long x) { cout << x; }
void pr(unsigned long long x) { cout << x; }
void pr(float x) { cout << x; }
void pr(double x) { cout << x; }
void pr(ld x) { cout << x; }
void pr(char x) { cout << x; }
void pr(const char* x) { cout << x; }
void pr(const string& x) { cout << x; }
void pr(bool x) { pr(x ? "true" : "false"); }
template<class T> void pr(const complex<T>& x) { cout << x; }
template<class T1, class T2> void pr(const pair<T1,T2>& x);
template<class T> void pr(const T& x);
template<class T, class... Ts> void pr(const T& t, const Ts&... ts) {
pr(t); pr(ts...);
}
template<class T1, class T2> void pr(const pair<T1,T2>& x) {
pr("{",x.f,", ",x.s,"}");
}
template<class T> void pr(const T& x) {
pr("{");
bool fst = 1; for (const auto& a: x) pr(!fst?", ":"",a), fst = 0;
pr("}");
}
void print() { pr("\n"); }
template<class T, class... Ts> void print(const T& t, const Ts&... ts) {
pr(t); if (sizeof...(ts)) pr(" "); print(ts...);
}
}
using namespace output;
ll MOD = 1e9+7;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int N; cin >> N;
vi T (N);
vi A (N);
F0R(i, N) cin >> T[i];
F0R(i, N) cin >> A[i];
vi arr (N, -1);
arr[0] = T[0];
FOR(i, 1, N) if (T[i] != T[i-1]) arr[i] = T[i];
arr[N-1] = A[N-1];
ROF(i, 0, N-1) if (A[i] != A[i+1]) arr[i] = A[i];
int hi = arr[0];
F0R(i, N) {
hi = max(hi, arr[i]);
if (hi != T[i]) {
print(0);
return 0;
}
}
hi = arr[N-1];
R0F(i, N) {
hi = max(hi, arr[i]);
if (hi != A[i]) {
print(0);
return 0;
}
}
ll res = 1;
vi height (N, 1e9+10);
F0R(i, N) height[i] = min(height[i], T[i]);
R0F(i, N) height[i] = min(height[i], A[i]);
F0R(i, N) if (arr[i] == -1) {
res *= height[i]; res %= MOD;
}
print(res);
}
|
#include <iostream>
#include <string>
#include <vector>
#include <array>
#include <queue>
#include <deque>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <cmath>
#include <functional>
#include <cassert>
#include <iomanip>
#define vll vector<ll>
#define vvvl vector<vvl>
#define vvl vector<vector<ll>>
#define VV(a, b, c, d) vector<vector<d>>(a, vector<d>(b, c))
#define VVV(a, b, c, d) vector<vvl>(a, vvl(b, vll (c, d)));
#define re(c, b) for(ll c=0;c<b;c++)
#define all(obj) (obj).begin(), (obj).end()
typedef long long int ll;
typedef long double ld;
using namespace std;
int main(){
ll n, x, m;scanf("%lld %lld %lld", &n, &x, &m);
vvl d = VV(m, 40, -1, ll);
vvl s = VV(m, 40, -1, ll);
for(ll i=0;i<40;i++){
for(ll j=0;j<m;j++){
if(i==0) {
d[j][0] = (j*j)%m;
s[j][0] = d[j][0];
}else {
d[j][i] = d[d[j][i-1]][i-1];
s[j][i] = s[j][i-1] + s[d[j][i-1]][i-1];
}
}
}
auto f = [&](ll k){
int cnt = 0;
ll ret = x;
ll ans = x;
while(k){
if(k%2) {
ans += s[ret][cnt];
ret = d[ret][cnt];
}
k/=2;
cnt++;
}
return ans;
};
std::cout << f(n-1) << '\n';
}
| 0
| 10,451,280
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e+9+7;
const ll N = 2*1e6+5;
ll dp[N][5];
ll a[N][5];
ll n;
ll solve(ll i,ll p)
{
if(i==n)
{
return 0;
}
if(dp[i][p]!=-1)
{
return dp[i][p];
}
ll ans=-1e9;
for(ll j=0;j<3;j++)
{
if(j==p)
{
continue;
}
ans=max(ans,solve(i+1,j)+a[i][j]);
}
return dp[i][p]=ans;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
cin>>n;
for(ll i=0;i<n;i++)
{
for(ll j=0;j<3;j++)
{
cin>>a[i][j];
}
}
memset(dp,-1,sizeof(dp));
cout<<solve(0,3);
}
|
#include <bits/stdc++.h>
#define forn(x, n) for (int x = 0; x < n; x++)
#define forr(x, n) for (int x = n; x >= 0; x--)
#define fore(x, a, b, c) for (int x = a; x <= b; x += c)
#define forre(x, a, b, c) for (int x = a; x >= b; x -= c)
#define clr cin.ignore(numeric_limits<streamsize>::max(), '\n')
#define all(container) (container).begin(), (container).end()
#define rall(container) (container).rbegin(), (container).rend()
#define FILL(x, val) memset(x, val, sizeof(x))
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define mod (int)1000000007
#define INF (int)0x3f3f3f3f
using namespace std;
template<class T> bool uin(T &a, T b) { return a > b ? (a = b, true) : false; }
template<class T> bool uax(T &a, T b) { return a < b ? (a = b, true) : false; }
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n, x; cin >> n >> x;
ll gg = __gcd(n, x);
ll ans = 3 * (n - gg);
cout << ans << '\n';
return 0;
}
| 0
| 2,289,038
|
#pragma GCC optimize ("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
#include"bits/stdc++.h"
using namespace std;
typedef long long ll;
#define int ll
#define sz(x) (int)(x).size();
#define all(x) x.begin(), x.end()
#define trav(i,a) for(auto &i:a)
inline int in(){int x;scanf("%lld",&x);return x;}
const int mod=1e9+7;
int f[2][64];
int modp(int a,int b)
{
if(b==0)return 1;
int u=modp(a,b/2);
u=(u*u)%mod;
if(b&1)return (a*u)%mod;
return u;
}
int32_t main()
{
int n=in();int x;
for(int i=0;i<n;i++)
{
x=in();
for(int j=0;j<64;j++)
{
f[(x>>j)&1][j]++;
}
}
int ans=0;
for(int i=0;i<64;i++)
{
x=(f[0][i]*f[1][i])%mod;
x*=modp(2,i);
x%=mod;
ans+=x;ans%=mod;
}
cout<<ans;
}
|
#include <bits/stdc++.h>
using namespace std ;
int main()
{
long long n , k ;
vector <long long> v ;
cin >> n >> k ;
long long temp ;
for(int i = 0 ; i < n ; i++)
{
cin >> temp ;
v.push_back(temp) ;
}
sort(v.begin(), v.end(), greater <int>() ) ;
if(k >= n)
{
cout <<0 << endl ;
}
else
{
long long sum = 0 ;
for(auto it = v.begin() + k ; it != v.end() ;it++)
{
sum += *it ;
}
cout <<sum << endl ;
}
}
| 0
| 92,590,810
|
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define ff first
#define ss second
typedef long long ll;
ll power(ll a, ll b){
ll res=1;
a=a%MOD;
while(b>0){
if(b&1){res=(res*a)%MOD;b--;}
a=(a*a)%MOD;
b>>=1;
}
return res;
}
ll fermat_inv(ll y){return power(y,MOD-2);}
ll gcd(ll a, ll b){return (b==0)?a:gcd(b,a%b);}
int main(){
ll t=1;
while(t--){
int n;
cin>>n;
n*=n;
cout<<n;
}
return 0ll;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;
int lcs(string& a, string& b)
{
vector<vector<int>> dp(a.size() + 1, vector<int>(b.size() + 1, 0));
for (size_t i = 1; i < dp.size(); ++i)
{
for (size_t j = 1; j < dp[0].size(); ++j)
{
if (a[i - 1] == b[j - 1])
{
dp[i][j] = dp[i - 1][j - 1] + 1;
}
else
{
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
return dp[a.size()][b.size()];
}
int main()
{
int q;
cin >> q;
for (int i = 0; i < q; ++i)
{
string a, b;
cin >> a >> b;
cout << lcs(a, b) << endl;
}
return 0;
}
| 0
| 7,865,009
|
#include <iostream>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <algorithm>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <utility>
using namespace std;
typedef long long ll;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n) REP(i,0,n)
int d[20][20];
int cost[20][20];
int n;
int numTown;
int t;
void show(){
for(int i=0;i<t;i++){
for(int j=0;j<t;j++){
printf("%10d ",cost[i][j]);
}
cout<<endl;
}
cout<<endl;
}
void solve(){
for(int i=0;i<t;i++)for(int j=0;j<t;j++)cost[i][j]=d[i][j];
for(int k=0;k<t;k++){
for(int i=0;i<t;i++){
for(int j=0;j<t;j++){
if(i==j||i==k||j==k)continue;
cost[i][j]=cost[j][i]=min(cost[i][j],cost[i][k]+cost[k][j]);
}
}
}
int ans=INT_MAX;
int p=0;
for(int i=0;i<t;i++){
int sum=0;
for(int j=0;j<t;j++){
sum+=cost[i][j];
}
if(ans>sum){
ans=sum;
p=i;
}
}
cout<<p<<" "<<ans<<endl;
}
int main(void){
while(cin>>n,n){
t=0;
for(int i=0;i<22;i++){
for(int j=0;j<22;j++){
if(i==j)d[i][j]=0;
else d[i][j]=10000000;
}
}
for(int i=0;i<n;i++){
int a,b,c;
cin>>a>>b>>c;
d[a][b]=d[b][a]=c;
t=max(t,max(a+1,b+1));
}
solve();
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define lint long long
#define P pair<int, int>
#define LLP pair<long long, long long>
#define REP(i, x, n) for(int i = (x), i##_len = (int)(n) ; i < i##_len ; ++i)
#define rep(i, n) for(int i = 0, i##_len = (int)(n) ; i < i##_len ; ++i)
#define repr(i, n) for(int i = (int)(n) - 1 ; i >= 0 ; --i)
#define SORT(x) sort((x).begin(), (x).end())
#define SORT_INV(x) sort((x).rbegin(), (x).rend())
const int IINF = 1e9 + 100;
const long long LLINF = 2e18 + 129;
const long long MOD = 1e9 + 7;
const int dx4[] = {1, 0, -1, 0}, dy4[] = {0, 1, 0, -1};
const int dx8[] = {1, 1, 0, -1, -1, -1, 0, 1}, dy8[] = {0, -1, -1, -1, 0, 1, 1, 1};
const double EPS = 1e-8;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
lint n, a, b, c, x;
while(cin >> n >> a >> b >> c >> x, n){
vector<lint> y(n);
rep(i, n){
cin >> y[i];
}
lint ans = -1;
int j = 0;
rep(i, 10001){
if(x == y[j]){
++j;
}
if(j == n){
ans = i;
break;
}
x = (a * x + b) % c;
}
cout << ans << endl;
}
return 0;
}
| 0
| 9,195,356
|
#include<iostream>
using namespace std;
int main() {
double ave;
int ans,a,b, n,max,min;
while (1) {
ave = 0;
cin >> n;
b = 0;
if (n == 0)break;
for (int i = 0; i < n; i++) {
cin >> a;
if (b == 0) {
max = a;
min = a;
}
else {
if (a > max)max = a;
if (a < min)min = a;
}
ave += a;
b = 1;
}
ans = (ave - max - min) / (n - 2);
cout << ans << endl;
}
return 0;
}
|
#include <cstdio>
using namespace std;
int F[45];
int fib(int x)
{
if (F[x]) return F[x];
if (x <= 1) return F[x] = 1;
return F[x] = fib(x - 1) + fib(x - 2);
}
int main()
{
int x;
scanf("%d", &x);
printf("%d\n", fib(x));
return 0;
}
| 0
| 6,892,439
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<long long> vl;
typedef vector<bool> vb;
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define in insert
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define speed ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define Maxn 4000007
const int INF = 1e9 + 5;
const int N = 2e5 + 314;
void foo(){
int k;
cin>>k;
vi v{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};
cout<<v[k-1];
}
int main(){
speed;
int t=1;
while(t--)foo();
}
|
#include <memory.h>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
#define MOD 1000000007
#define INIT -1
int main() {
int n;
string s;
cin >> n >> s;
int tmp = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '(') {
tmp++;
} else {
if (tmp == 0) {
s = '(' + s;
i++;
} else {
tmp--;
}
}
}
for (int i = 0; i < tmp; i++) {
s = s + ')';
}
cout << s << endl;
}
| 0
| 49,005,800
|
#include <iostream>
#include <cmath>
#include <algorithm>
#include <utility>
#include <vector>
#include <string>
using namespace std;
char letter[] = {'.', ',', '!', '?', ' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
char output(int b, int c)
{
switch (b) {
case 1:
return letter[0 + (c % 5)];
break;
case 2:
return letter[5 + (c % 3)];
break;
case 3:
return letter[8 + (c % 3)];
break;
case 4:
return letter[11 + (c % 3)];
break;
case 5:
return letter[14 + (c % 3)];
break;
case 6:
return letter[17 + (c % 3)];
break;
case 7:
return letter[20 + (c % 4)];
break;
case 8:
return letter[24 + (c % 3)];
break;
case 9:
return letter[27 + (c % 4)];
break;
}
}
int main()
{
int n;
cin >> n;
for (int cnt = 0; cnt < n; cnt++) {
string str;
cin >> str;
int button = -1;
int count = -1;
for (char c : str) {
if (c == '0') {
if (button != -1) {
cout << output(button, count);
}
count = -1;
button = -1;
} else {
button = c - '0';
count++;
}
}
cout << endl;
}
return 0;
}
|
#include<stdio.h>
#include<algorithm>
using namespace std;
#define NIL -2000000001
#define MAX 250
int A[MAX];
void printHeap(int n) {
for ( int i = 0; i < n; i++ ) {
printf("node %d: key = %d, ", i+1, A[i]);
if (i+1 != 1) {
printf("parent key = %d, ", A[(i+1)/2-1]);
}
if (A[2*(i+1)-1] != NIL && 2*(i+1)-1 < MAX) {
printf("left key = %d, ", A[2*(i+1)-1]);
}
if (A[2*(i+1)+1-1] != NIL && 2*(i+1)+1-1 < MAX) {
printf("right key = %d, ", A[2*(i+1)+1-1]);
}
printf("\n");
}
}
int main() {
for ( int i = 0; i < MAX; i++ ) {
A[i] = NIL;
}
int n;
scanf("%d", &n);
for ( int i = 0; i < n; i++ ) {
scanf("%d", &A[i]);
}
printHeap(n);
return 0;
}
| 0
| 89,729,702
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
{
string s,t;
cin>>s>>t;
int sb,tb;
cin>>sb>>tb;
string u;
cin>>u;
if(u==t)
{
tb--;
} else if(u==s){
sb--;
}
cout<<sb<<" "<<tb;
}
return 0;
}
|
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <functional>
using namespace std;
#define REP(i,n) for(int i=0; i<n; ++i)
#define FOR(i,a,b) for(int i=a; i<=b; ++i)
#define FORR(i,a,b) for (int i=a; i>=b; --i)
typedef long long ll;
#define N 100000
int n;
vector<vector<int> > e(N);
vector<int> a(N) , p(N) , d(N);
void dfs(int now, int from, int depth){
p[now] = from;
d[now] = depth;
if (e[now].size()==0){
a[now] = 2;
}
REP(k,e[now].size()){
dfs(e[now][k],now,depth+1);
}
}
int main(void) {
cin >> n;
REP(i,n){
int id , k;
cin >> id >> k;
REP(i,k){
int c;
cin >> c;
e[id].push_back(c);
a[c]=1;
}
}
REP(i,n){
if (a[i]==0){
p[i]=-1;
d[i]=0;
REP(k,e[i].size()){
dfs(e[i][k],i,1);
}
}
}
REP(i,n){
printf("node %d: parent = %d, depth = %d, ",i,p[i],d[i]);
if (a[i]==0)
cout << "root";
if (a[i]==1)
cout << "internal node";
if (a[i]==2)
cout << "leaf";
printf(", [");
REP(k,e[i].size()){
printf("%d",e[i][k]);
if (k<e[i].size()-1){
cout << ", ";
}
}
cout << "]" << endl;
}
return 0;
}
| 0
| 68,987,497
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair< ll, ll > pll;
typedef pair< int, int > pii;
const double pi = 3.14159265358979323846;
#define MOD 1000000007LL
#define PS(p) cout << setprecision(15) << fixed << p << endl;
#define UNIQUE(v) v.erase(std::unique(v.begin(), v.end()), v.end());
#define ALL(c) c.begin(), c.end()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define MT make_tuple
#define TG0 get< 0 >
#define TG1 get< 1 >
#define TG2 get< 2 >
#define F first
#define S second
#define VL vector< ll >
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll A, B;
cin >> A >> B;
ll r = A * B;
r -= A + B - 1;
cout << r << endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define REP(i, a) for (int i = 0; i < (a); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (a)-1; i >= (b); --i)
#define ALL(obj) (obj).begin(), (obj).end()
#define SIZE(obj) (int)(obj).sizeT()
#define YESNO(cond, yes, no) \
{ cout << ((cond) ? (yes) : (no)) << endl; }
#define SORT(list) sort(ALL((list)));
#define RSORT(list) sort((list).rbegin(), (list).rend())
#define ASSERT(cond, mes) assert(cond&& mes)
constexpr int MOD = 1'000'000'007;
constexpr int INF = 1'050'000'000;
template <typename T>
T round_up(const T& a, const T& b) {
return (a + (b - 1)) / b;
}
template <typename T1, typename T2>
istream& operator>>(istream& is, pair<T1, T2>& p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, pair<T1, T2>& p) {
os << p.first << p.second;
return os;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
REP(i, (int)v.size())
is >> v[i];
return is;
}
template <typename T>
T clamp(T& n, T a, T b) {
if (n < a) n = a;
if (n > b) n = b;
return n;
}
template <typename T>
static T GCD(T u, T v) {
T r;
while (v != 0) {
r = u % v;
u = v;
v = r;
}
return u;
}
template <typename T>
static T LCM(T u, T v) {
return u / GCD(u, v) * v;
}
template <typename T>
std::vector<T> enum_div(T n) {
std::vector<T> ret;
for (T i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) { ret.push_back(n / i); }
}
}
return ret;
}
template <typename T>
bool chmin(T& a, const T& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool chmax(T& a, const T& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct ToUpper {
char operator()(char c) {
return toupper(c);
}
};
struct ToLower {
char operator()(char c) {
return tolower(c);
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int a, b;
cin >> a >> b;
if (a + b == 15) {
cout << "+" << endl;
} else if (a * b == 15) {
cout << "*" << endl;
} else {
cout << "x" << endl;
}
return 0;
}
| 0
| 70,563,521
|
#define _USE_MATH_DEFINES
#include<iostream>
#include<string>
#include<cmath>
#include<queue>
#include<map>
#include<set>
#include<list>
#include<iomanip>
#include<vector>
#include<random>
#include<functional>
#include<algorithm>
#include<cstdio>
#include<bitset>
#include<unordered_map>
using namespace std;
typedef long long ll;
typedef long double ld;
#define str string
#define rep(i,j) for(ll i=0;i<(long long)(j);i++)
const ll Mod = 1000000007;
const ll gosenchou = 5000000000000000;
short gh[2][4] = { { 0,0,-1,1 },{ -1,1,0,0 } };
struct P {
ll pos, cost;
};
bool operator<(P a, P b) { return a.cost < b.cost; }
bool operator>(P a, P b) { return a.cost > b.cost; }
struct B {
ll to, cost;
};
struct E {
ll from, to, cost;
};
bool operator<(E a, E b) {
return a.cost < b.cost;
}
struct H {
ll x, y;
};
bool operator<(H a, H b) {
if (a.x != b.x) return a.x < b.x;
return a.y < b.y;
}
bool operator>(H a, H b) {
if (a.x != b.x) return a.x > b.x;
return a.y > b.y;
}
bool operator==(H a, H b) {
return a.x == b.x&&a.y == b.y;
}
bool operator!=(H a, H b) {
return a.x != b.x || a.y != b.y;
}
ll gcm(ll i, ll j) {
if (i > j) swap(i, j);
if (i == 0) return j;
return gcm(j%i, i);
}
ld rad(H a, H b) {
return sqrt(pow(a.x - b.x, 2.0) + pow(a.y - b.y, 2.0));
}
ll ari(ll a, ll b, ll c) {
return (a + b)*c / 2;
}
ll fact(ll x, ll k, ll p) {
ll sum = 1;
for (int i = 0; i < k; i++) {
sum *= (x--);
sum %= p;
}
return sum;
}
ll mod_pow(ll x, ll n, ll p) {
ll res = 1;
while (n > 0) {
if (n & 1) res = res*x%p;
x = x*x%p;
n >>= 1;
}
return res;
}
int ctoi(char a) {
return (int)a - '0';
}
#define int long long
const long long Inf = 4523372036854775807;
const int inf = 15000000000;
signed main() {
int q;
cin >> q;
for (int z = 0; z < q; z++) {
int a, b;
cin >> a >> b;
if (a > b) swap(a, b);
int ans;
if (a == b || a + 1 == b) {
ans = 2 * a - 2;
}
if (a != b) {
int k = floor(sqrt(a*b));
if (k == sqrt(a*b)) {
k--;
}
if (k*(k+1) >= a*b) {
ans = 2 * k - 2;
}
else {
ans = 2 * k - 1;
}
}
cout << ans << endl;
}
getchar(); getchar();
}
|
#include <algorithm>
#include <iostream>
using namespace std;
int main(void)
{
long long a, b, c, d;
long long ans;
cin >> a >> b >> c >> d;
if (b > 0 && d > 0)
{
ans = max(b * d, a * c);
}
else if (b <= 0 && d <= 0)
{
ans = a * c;
}
else if (b > 0 && d <= 0)
{
if (a >= 0)
ans = a * d;
else
ans = a * c;
}
else if (b <= 0 && d > 0)
{
if (c >= 0)
ans = c * b;
else
ans = c * a;
}
cout << ans << endl;
return 0;
}
| 0
| 74,280,498
|
#include <iostream>
#include <cstdio>
using namespace std;
int main() {
int a[4][3][10]={0},n,b,f,r,v;
cin >> n;
for(int i=0; i<n; ++i) {
cin >> b >> f >> r >> v;
a[b-1][f-1][r-1]+=v;
}
for(int i=0;i<4;++i) {
for(int j=0;j<3;++j) {
printf(" %d %d %d %d %d %d %d %d %d %d\n"
,a[i][j][0]
,a[i][j][1]
,a[i][j][2]
,a[i][j][3]
,a[i][j][4]
,a[i][j][5]
,a[i][j][6]
,a[i][j][7]
,a[i][j][8]
,a[i][j][9]);
}
if(i==3) break;
printf("####################\n");
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
static const int MAX = 100;
static const long long INF = (1LL<<32);
int V,E;
long long d[MAX][MAX];
void floyd(){
for(int k=0;k<V;k++){
for(int i=0;i<V;i++){
if(d[i][k] == INF) continue;
for(int j=0;j<V;j++){
if(d[k][j] == INF) continue;
d[i][j] = min(d[i][j],d[i][k] + d[k][j]);
}
}
}
}
int main(){
cin >> V >> E;
for(int i=0;i<V;i++){
for(int j=0;j<V;j++){
if(i == j) d[i][j] = 0;
else d[i][j] = INF;
}
}
for(int i=0;i<E;i++){
int a,b,c;
cin >> a >> b >> c;
d[a][b] = c;
}
floyd();
bool minus = false;
for(int i=0;i<V;i++){
if(d[i][i] < 0) minus = true;
}
if(minus) {
cout << "NEGATIVE CYCLE" << endl;
} else {
for(int i=0;i<V;i++){
for(int j=0;j<V;j++){
if(j) cout << " ";
if(d[i][j] == INF) cout << "INF";
else cout << d[i][j];
}
cout << endl;
}
}
}
| 0
| 80,412,678
|
#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(ll i = 0; i < n; ++i )
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
ll a,b;
cin >> a >> b;
auto f = [](ll x){
ll res = 0;
rep(i,(x+1)%4) res ^= x-i;
return res;
};
cout << (f(a-1)^f(b)) << endl;
}
|
# include "bits/stdc++.h"
using namespace std;
using LL = long long;
using ULL = unsigned long long;
const double PI = acos(-1);
template<class T>constexpr T INF() { return ::std::numeric_limits<T>::max(); }
template<class T>constexpr T HINF() { return INF<T>() / 2; }
template <typename T_char>T_char TL(T_char cX) { return tolower(cX); };
template <typename T_char>T_char TU(T_char cX) { return toupper(cX); };
const int vy[] = { -1, -1, -1, 0, 1, 1, 1, 0 }, vx[] = { -1, 0, 1, 1, 1, 0, -1, -1 };
const int dx[4] = { -1,0,1,0 }, dy[4] = { 0,-1,0,1 };
int popcnt(unsigned long long n) { int cnt = 0; for (int i = 0; i < 64; i++)if ((n >> i) & 1)cnt++; return cnt; }
int d_sum(LL n) { int ret = 0; while (n > 0) { ret += n % 10; n /= 10; }return ret; }
int d_cnt(LL n) { int ret = 0; while (n > 0) { ret++; n /= 10; }return ret; }
LL gcd(LL a, LL b) { if (b == 0)return a; return gcd(b, a%b); };
LL lcm(LL a, LL b) { LL g = gcd(a, b); return a / g*b; };
# define ALL(qpqpq) (qpqpq).begin(),(qpqpq).end()
# define UNIQUE(wpwpw) (wpwpw).erase(unique(ALL((wpwpw))),(wpwpw).end())
# define LOWER(epepe) transform(ALL((epepe)),(epepe).begin(),TL<char>)
# define UPPER(rprpr) transform(ALL((rprpr)),(rprpr).begin(),TU<char>)
# define FOR(i,tptpt,ypypy) for(LL i=(tptpt);i<(ypypy);i++)
# define REP(i,upupu) FOR(i,0,upupu)
# define INIT std::ios::sync_with_stdio(false);std::cin.tie(0)
# pragma warning(disable:4996)
int n;
int g[1010][1010];
int main() {
cin >> n;
int sum = 0;
bool flg = false;
if (n == 1) {
cout << "Yes" << endl;
cout << "2\n1 1\n1 1" << endl;
return 0;
}
int num = -1;
for (int i = 1; sum + i <= n; i++) {
sum += i;
if (sum == n) {
flg = true;
num = i + 1;
}
}
if (flg) {
cout << "Yes" << endl;
cout << num << endl;
int k = 1;
for (int i = 1; i <= num; i++) {
for (int j = 1; j <= num; j++) {
if (i == j)continue;
if (g[i][j] == 0)g[i][j] = g[j][i] = k++;
}
}
for (int i = 1; i <= num; i++) {
cout << num - 1;
for (int j = 1; j <= num; j++) {
if (i == j)continue;
cout << " " << g[i][j];
}
cout << endl;
}
}
else {
cout << "No" << endl;
}
}
| 0
| 74,187,343
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int a, b;
cin>>a>>b;
if (a > b)
{
for (int i = 0; i < a; ++i)
{
cout<<b;
}
cout<<endl;
}
else if (a < b)
{
for (int j = 0; j < b; ++j)
{
cout<<a;
}
cout<<endl;
}
else
{
for (int k = 0;k < b; ++k)
{
cout<<a;
}
cout<<endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
map<int,int>m;
map<int,int>::iterator it;
while(n--){
int a;
cin>>a;
it = m.find(a);
if(it!=m.end()) it->second+=1;
else m.insert(make_pair(a,1));
}
vector<long long>stick;
for(it = m.begin(); it!=m.end(); it++){
if(it->second>=2) stick.push_back(it->first);
if(it->second>=4) stick.push_back(it->first);
sort(stick.begin(),stick.end());
while(stick.size()>=3) stick.erase(stick.begin());
}
if(stick.size()<=1) cout<<0;
else cout<<stick[stick.size()-1]*stick[stick.size()-2];
}
| 0
| 87,689,283
|
#include <bits/stdc++.h>
using namespace std;
int main(){
long long n,k;
cin >> n >> k;
int res=k;
for(int i = 1;i<n;i++){
res*=k-1;
}
cout << res;
}
|
#include <algorithm>
#include <cassert>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#include <limits.h>
using namespace std;
typedef long long ll;
template<class T>
inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
}
template<class T>
inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
}
vector<vector<char>> board;
int main(void) {
int H, W;
cin >> H >> W;
board.resize(H + 2, vector<char>(W + 2, '.'));
for (int h = 1; h <= H; h++) {
for (int w = 1; w <= W; w++) {
char c;
cin >> c;
if (c == '#') {
board[h][w] = c;
}
}
}
bool ok = true;
for (int h = 1; h <= H; h++) {
for (int w = 1; w <= W; w++) {
if (board[h][w] == '#') {
if (board[h - 1][w] == '.' && board[h + 1][w] == '.'
&& board[h][w - 1] == '.' && board[h][w + 1] == '.') {
ok = false;
}
}
}
}
if (ok) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| 0
| 31,028,542
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define each(itr,c) for(__typeof(c.begin()) itr=c.begin(); itr!=c.end(); ++itr)
#define all(x) (x).begin(),(x).end()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
int main()
{
int m,a,b;
while(cin >>m >>a >>b,m)
{
vector<int> p(m);
rep(i,m) cin >>p[i];
int ans=b;
int gap=0;
for(int i=b; i>=a; --i)
{
int tgap=p[i-1]-p[i];
if(tgap>gap)
{
gap=tgap;
ans=i;
}
}
cout << ans << endl;
}
return 0;
}
|
#include<iostream>
using namespace std;
int digit(int n){
int H=0;
while(n!=0){
H+=n%10;
n=n/10;
}
return H;
}
int main(){
int n;
cin >> n;
if(n%digit(n)==0){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
return 0;
}
| 0
| 80,384,700
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, srt, end) for (long long i = (srt); i < (long long)(end); i++)
int main(){
ll N;
cin >> N;
ll a = 0, b = 0, ab = 0, ans = 0;
rep(i, 0, N){
string s;
cin >> s;
if(s[0] == 'B' && s[s.size()-1] == 'A') ab++;
else if(s[0] == 'B') a++;
else if(s[s.size()-1] == 'A') b++;
rep(j, 0, s.size()-1){
if(s[j] == 'A' && s[j+1] == 'B') ans++;
}
}
if(a == 0 && b == 0){
if(ab > 0) ans += ab - 1;
}else if(a == 0 || b == 0){
ans += ab;
}else{
if(ab == 0) ans += min(a, b);
else ans += ab + min(a, b);
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <cstdio>
#include <algorithm>
#include <set>
#include <map>
#include <cassert>
#include <numeric>
#include <string>
#include <cstring>
#include <cmath>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
typedef long long int int64;
const int N = 1005;
char s[N], t[N], str[N];
int main(int, char **)
{
#ifdef LOCAL
freopen("input.txt", "r", stdin);
#endif
int n;
scanf("%d", &n);
scanf("%s%s", s, t);
for (int i = n; i <= 2 * n; i++)
{
for (int j = 0; j < n; j++)
str[j] = s[j];
bool bad = false;
for (int j = 0; j < n; j++)
if (i - 1 - j < n && str[i - 1 - j] != t[n - 1 - j])
bad = true;
if (!bad)
{
printf("%d\n", i);
return 0;
}
}
throw;
return 0;
}
| 0
| 78,303,882
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s,t;
cin>>s>>t;
vector<char> s_c(s.size());
vector<char> t_c(t.size());
for(int i=0;i<s.size();i++){
s_c.at(i)=s.at(i);
}
for(int i=0;i<t.size();i++){
t_c.at(i)=t.at(i);
}
sort(s_c.begin(),s_c.end());
sort(t_c.begin(),t_c.end(),std::greater<char>());
if(s.size()<t.size()){
for(int i=s.size();i<t.size();i++){
s_c.push_back('0');
}
}
if(t.size()<s.size()){
for(int i=t.size();i<s.size();i++){
t_c.push_back('0');
}
}
string s2,t2;
for(int i=0;i<s_c.size();i++){
s2.push_back(s_c.at(i));
t2.push_back(t_c.at(i));
}
#if 0
for(int i=0;i<s_c.size();i++){
cout<<s2.at(i);
}
cout<<endl;
for(int i=0;i<t_c.size();i++){
cout<<t2.at(i);
}
cout<<endl;
#endif
if(s2<t2)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
}
|
#include<iostream>
#include<algorithm>
#include<math.h>
#include<vector>
#include<string>
#include<iomanip>
using namespace std;
int main()
{
int n, m; cin >> n >> m;
vector<vector<long long>>s(n, vector<long long>(2));
vector<vector<long long>>ch(m, vector<long long>(2));
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < 2; ++j)
{
cin >> s[i][j];
}
}
for (int i = 0; i < m; ++i)
{
for (int j = 0; j < 2; ++j)
{
cin >> ch[i][j];
}
}
long long mn, sum = 0,t=0;
for (int i = 0; i < n; ++i)
{
mn = 10e11;
for (int j = 0; j < m; ++j)
{
sum = 0;
for (int k = 0; k < 2; ++k)
{
sum += abs(s[i][k] - ch[j][k]);
}
if (mn > sum)
{
mn = sum;
t = j + 1;
}
}
cout << t << endl;
}
}
| 0
| 65,683,646
|
#include <cmath>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <vector>
#include <map>
#include<cstdio>
#include<functional>
#include <bitset>
#include <iomanip>
#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 repr(i, n) for(int i = n; i >= 0; i--)
#define ll long long
using namespace std;
template <typename T> bool chmin(T &a, const T &b) { if (a > b) { a = b; return true; } return false; }
template <typename T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return true; } return false; }
const ll INF = 1000000000000000000;
const ll MOD = 1e9 + 7;
int main()
{
ll n;
cin >> n;
vector<ll> al(n);
vector<ll> sum(n + 1);
rep(i, n) {
ll a;
cin >> a;
al[i] = a;
sum[i + 1] = sum[i] + a;
}
map<ll, ll> mp;
for (auto item : sum) {
mp[item]++;
}
ll ans = 0;
for(auto item : mp) {
ans += (item.second * (item.second - 1)) / 2;
}
cout << ans << endl;
system("pause");
}
|
#include <bits/stdc++.h>
using namespace std;
#define ALL(v) v.begin(), v.end()
#define V vector
#define P pair
#define ld long double
#define ll long long
#define mod 1000000007
#define IINF INT_MAX
#define INF 1LL << 30
int main() {
int n; cin >> n;
map<string, ll> m;
for(int i = 0; i < n; i++){
string s; cin >> s;
sort(ALL(s));
m[s]++;
}
ll ans = 0;
for(auto p : m){
if(1 < p.second){
ans += (p.second * (p.second - 1) / 2);
}
}
cout << ans << endl;
return 0;
}
| 0
| 19,651,832
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
void solve() {
ll n;
cin >> n;
vector<ll> ret;
ret.resize(50);
for(int i = 0; i < 50; i++) ret[i] = 49;
ll fullInc = n/50;
n %= 50;
for(int i = 0; i < 50; i++) ret[i] += fullInc;
int f = 0;
while(n--) {
ret[f] += 50;
for(int i = 0; i < 50; i++) if(i != f) ret[i]--;
f++;
}
cout << "50\n";
for(int i = 0; i < 50; i++) {
cout << ret[i];
if(i == 49) cout << endl;
else cout << " ";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
using Int = long long;
int W, H;
vector<Int> p, q;
int main() {
cin >> W >> H;
p.resize(W), q.resize(H);
rep(i, W) cin >> p[i];
rep(i, H) cin >> q[i];
sort(all(q));
sort(all(p));
Int ans = 0;
int i = 0, j = 0;
while (i < H || j < W) {
if (i == H) {
ans += p[j];
j++;
} else if (j == W) {
ans += q[i];
i++;
} else {
if (q[i] < p[j]) {
ans += (W - j + 1) * q[i];
i++;
} else {
ans += (H - i + 1) * p[j];
j++;
}
}
}
cout << ans << endl;
return 0;
}
| 0
| 86,084,995
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
int main() {
int64_t n,k;
cin >> n >> k;
vector<int> v(n);
rep(i, n){
int a;
cin >> a;
v[i] = a;
}
int64_t sel = 0;
rep(i, n){
for(int j=i; j<n; j++){
if(v[i] > v[j]){
sel++;
}
}
}
int64_t rgt = 0;
rep(i, n){
rep(j, n){
if(v[i] < v[j]){
rgt++;
}
}
}
int64_t ans = 0;
ans += sel * k;
ans %= 1000000007;
int64_t anstmp;
anstmp = (k*(k-1))/2;
anstmp %= 1000000007;
ans += rgt * anstmp;
ans %= 1000000007;
cout << ans;
}
|
#include<iostream>
using namespace std;
int main (){
int w, h;
while(1){
cin >> h >> w;
if( w == 0 && h == 0) break;
for(int a = 0;a < h;a++){
for(int b = 0;b < w;b++){
cout << "#";
}
cout << endl;
}
cout << endl;
}
return 0;
}
| 0
| 59,526,067
|
#include<bits/stdc++.h>
using namespace std;
int main() {
string N;
cin >> N;
if(N[0] == N[1] && N[1] == N[2] || N[1] == N[2] && N[2] == N[3] || N[0] == N[1] && N[1] == N[2] && N[2] == N[3]) cout << "Yes" << endl;
else cout << "No" << endl;
}
|
#include<bits/stdc++.h>
#define all(v) v.begin(),v.end()
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
long long n,a[3005],ans=0,m;
string s[105],t[105];
cin>>n;
for(int i=0;i<n;i++){
cin>>s[i];
}
cin>>m;
for(int i=0;i<m;i++){
cin>>t[i];
}
for(int i=0;i<n;i++){
int sum=0;
for(int j=0;j<n;j++){
if(s[i]==s[j]){
sum++;
}
}
for(int j=0;j<m;j++){
if(s[i]==t[j]){
sum--;
}
}
if(sum>ans){
ans=sum;
}
}
cout<<ans<<endl;
return(0);
}
| 0
| 35,848,411
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,M,a,b;
cin >> N;
vector<int> G[N];
for (cin >> M; M; M--) {
cin >> a >> b;
G[--a].push_back(--b);
G[b].push_back(a);
}
queue<int> q;
int d[N];
vector<bool> visited(N);
for (q.push(0), d[0] = 0, visited[0] = true; !q.empty(); q.pop()) {
for (int v : G[q.front()]) {
if (!visited[v]) {
visited[v] = true;
q.push(v);
d[v] = d[q.front()]+1;
}
}
}
if (d[N-1] == 2) {
cout << "POSSIBLE";
} else {
cout << "IMPOSSIBLE";
}
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#define rep(i, n) for(int i = 0; i < (int)(n); ++i)
#define REP(i, n) for(int i = 1; i < (int)(n); ++i)
using namespace std;
int main() {
int N;
cin >> N;
vector<long long> A(N);
rep(i, N) cin >> A[i];
set<long long> B;
vector<long long> S;
rep(i, N) {
if (B.count(A[i])) {
S.push_back(A[i]);
B.erase(A[i]);
} else {
B.insert(A[i]);
}
}
if (S.size() < 2) {
cout << 0 << endl;
} else {
sort(S.rbegin(), S.rend());
cout << S[0] * S[1] << endl;
}
return 0;
}
| 0
| 49,344,791
|
#include <bits/stdc++.h>
#define PI 3.14159265359
#define rep(i,a,n) for(int i=a;i<(int)n;++i)
#define SZ(x) ((int)(x).size())
#define descSort(a) sort(a.begin(),a.end(),std::greater<int>())
using namespace std;
typedef long long ll;
const ll INF = 1e9 + 7;
int main() {
string s;
cin>>s;
ll sum=0;
rep(i,0,s.size()){
sum+=s[i]-'0';
}
if(sum%9==0)cout<<"Yes"<<endl;
else cout<<"No"<<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;
typedef pair<int,int> P;
int main(void) {
int N; cin >> N;
vector<ll> A;
for(int i=0; i<N; i++) {
ll x; cin >> x;
A.push_back(x);
}
sort(A.begin(),A.end());
for(int i=0; i<N-1; i++) {
if(A[i]==A[i+1]){
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 0
| 42,422,714
|
#include<algorithm>
#include<bitset>
#include<cmath>
#include<complex>
#include<deque>
#include<functional>
#include<iomanip>
#include<iostream>
#include<iterator>
#include<map>
#include<numeric>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<unordered_map>
#include<unordered_set>
#include<utility>
#include<vector>
using namespace std;
typedef long long ll;
#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 D()
#define INF 1000000000000
#define MOD 10000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define INITA(a,i,j,v) for(ll k=i;k<=j;k++){a[k]=v;}
int main() {
string s, t; cin >> s >> t;
map<char, ll> sm;
map<char, ll> tm;
ll cur_s = 1;
ll cur_t = 1;
vector<int> sv;
vector<int> tv;
REP(i, s.size()) {
char c = s[i];
if (sm[c] == 0) {
sm[c] = cur_s;
cur_s++;
}
sv.push_back(sm[c]);
}
REP(i, t.size()) {
char c = t[i];
if (tm[c] == 0) {
tm[c] = cur_t;
cur_t++;
}
tv.push_back(tm[c]);
}
if (sv == tv) {
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 rep2(i, s, n) for (ll i = s; i < (ll)(n); i++)
#define repr(i, n) for (ll i = n; i >= 0; i--)
#define pb push_back
#define COUT(x) cout << (x) << endl
#define COUTF(x) cout << setprecision(15) << (x) << endl
#define ENDL cout << endl
#define DF(x) x.erase(x.begin())
#define ALL(x) x.begin(), x.end()
#define SORT(x) sort(ALL(x))
#define REVERSE(x) reverse(ALL(x))
#ifdef _DEBUG
#define debug(x) cout << "[debug] " << #x << ": " << x << endl
#else
#define debug(x)
#endif
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using P = pair<ll, ll>;
constexpr ll INF = 0x3f3f3f3f3f3f3f3f;
constexpr double PI = 3.141592653589793238462643383279;
ll getDigit(ll x) {
return x == 0 ? 1 : log10(x) + 1;
}
ll gcd(ll x, ll y) {
return y ? gcd(y, x % y) : x;
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}
vector<P> factorize(ll n) {
vector<P> result;
for (ll i = 2; i * i <= n; ++i) {
if (n % i == 0) {
result.pb({i, 0});
while (n % i == 0) {
n /= i;
result.back().second++;
}
}
}
if (n != 1) {
result.pb({n, 1});
}
return result;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
void debugV(const vector<T> v) {
#ifdef _DEBUG
rep(i, v.size()) {
cout << i << ":" << v[i] << " ";
}
cout << endl;
#else
(void)v;
#endif
}
signed main() {
ll N, K;
cin >> N >> K;
string S;
cin >> S;
vector<P> run_length;
vll sums;
char before;
ll count;
ll all_count = 0;
rep(i, N) {
all_count++;
if (i == 0) {
before = S[i];
count = 1;
continue;
}
if (S[i] == before) {
count++;
} else {
debug(before);
debug(count);
debug(all_count);
run_length.pb({before, count});
sums.pb(all_count - 1);
count = 1;
before = S[i];
}
}
run_length.pb({before, count});
sums.pb(all_count);
debugV(sums);
ll ans = 0;
rep(i, run_length.size()) {
char num = run_length[i].first;
if (num == '1') {
if (i + 2 * K <= (ll)sums.size() - 1) {
if (i == 0) {
ans = max(ans, sums[i + 2 * K] - 0);
continue;
} else {
ans = max(ans, sums[i + 2 * K] - sums[i - 1]);
continue;
}
} else {
if (i == 0) {
ans = max(ans, sums[sums.size() - 1] - 0);
} else {
ans = max(ans, sums[sums.size() - 1] - sums[i - 1]);
}
continue;
}
}
if (num == '0' && i == 0 && i + 2 * K - 1 <= (ll)sums.size() - 1) {
ans = max(ans, sums[i + 2 * K - 1] - 0);
continue;
}
if (num == '0' && i == 0 && i + 2 * K - 1 > (ll)sums.size() - 1) {
ans = max(ans, sums[sums.size() - 1] - 0);
continue;
}
}
if (ans == 0) {
COUT(N);
} else {
COUT(ans);
}
return 0;
}
| 0
| 56,904,588
|
#include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<n;++i)
#define all_map(itr,mp) for(auto itr=mp.begin();itr!=mp.end();itr++)
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
const ll MOD = 1e9 + 7;
const ll LINF = 1LL << 62;
const int INF = 1e9 + 7;
int main(){
ll n, m;
cin >> n >> m;
priority_queue<ll> que;
rep(i, n){
ll a;
cin >> a;
que.push(a);
}
rep(i, m){
ll top = que.top() / 2;
que.pop();
que.push(top);
}
ll ans = 0;
while(!que.empty()){
ans += que.top();
que.pop();
}
cout << ans << endl;
}
|
#include <iostream>
#include <vector>
using namespace std;
int N,count = 0;
bool judge = true;
vector<vector<int>> v(100010);
int visited[100010] = {0},col[100010] = {0};
bool dfs(int n){
visited[n] = 1;
bool j = true;
if(n!=1 && v[n].size()==1) return true;
for(int i=0;i<v[n].size();i++){
int s = v[n][i];
if(visited[s]==0 && dfs(s)){
if(col[n]==0){
col[n] = 1;
count++;
j = false;
}else judge = false;
}
}
return j;
}
int main(){
cin >> N;
int a,b;
for(int i=0;i<N-1;i++){
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
if(N%2==1){
cout << "First" << endl;
return 0;
}
dfs(1);
cout << (!judge? "First":"Second") << endl;
}
| 0
| 74,319,472
|
#include <iostream>
#include <set>
#include <queue>
#include <vector>
#include <algorithm>
#include <math.h>
#include <cmath>
#include <string>
#include <cstring>
#include <climits>
#include <sstream>
#include <iomanip>
#include <map>
#include <stack>
#include <tuple>
#include <numeric>
#include <assert.h>
#include <functional>
#include <unordered_map>
using namespace std;
#define REP(i, n) for (int (i) = 0 ; (i) < (int)(n) ; ++(i))
#define REPN(i, m, n) for (int (i) = m ; (i) < (int)(n) ; ++(i))
#define INF (1000 * 1000 * 1000 * 2)
#define MOD (1000 * 1000 * 1000 + 7)
#define Ceil(x, n) (((((x))+((n)-1))/n))
#define CeilN(x, n) (((((x))+((n)-1))/n)*n)
#define FloorN(x, n) ((x)-(x)%(n))
#define IsOdd(x) (((x)&0x01UL) == 0x01UL)
#define IsEven(x) (!IsOdd((x)))
#define M_PI 3.14159265358979323846
typedef long long ll;
typedef pair<ll, ll> P;
int main()
{
int M, K;
cin >> M >> K;
int valMax = 1 << M;
vector<int> a;
if (K == 0) {
REP(i, valMax) {
a.emplace_back(i);
a.emplace_back(i);
}
} else {
int xorRes = 0;
REP(i, valMax) {
if (i != K) {
xorRes ^= i;
}
}
if (xorRes != K) {
cout << -1 << endl;
return 0;
}
a.emplace_back(K);
REP(i, valMax) {
if (i != K) {
a.emplace_back(i);
}
}
a.emplace_back(K);
for (int i = valMax - 1; 0 <= i; i--) {
if (i != K) {
a.emplace_back(i);
}
}
}
REP(i, a.size()) {
cout << a[i] << " ";
}
cout << endl;
return 0;
}
|
#include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#include<iostream>
#include<cmath>
#include<math.h>
using namespace std;
#define int long long
#define REP(i,m,n) for(int i=(m);i<(n);i++)
#define rep(i,n) REP(i,0,n)
#define pb push_back
#define all(a) a.begin(),a.end()
#define rall(c) (c).rbegin(),(c).rend()
#define mp make_pair
#define endl '\n'
typedef long long ll;
typedef pair<ll,ll> pll;
typedef long double ld;
const ll inf=1e9+7;
const ll mod=1e9+7;
const double PI=M_PI;
signed main(){
ll ans=0;
ll n;cin>>n;
vector<ll>a(n);
rep(i,n){
cin>>a[i];
}
rep(i,n-1){
if(a[i]%2==0){
ans+=a[i]/2;
a[i]=0;
}else{
if(a[i+1]>0){
ans++;
a[i]--;
a[i+1]--;
}
}
}
rep(i,n){
ans+=a[i]/2;
}
cout<<ans<<endl;
}
| 0
| 25,412,119
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#pragma region Macros
#define FOR(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++)
#define rep(i, n) FOR(i, 0, n)
template <class T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return true; } return false; }
template <class T> bool chmin(T &a, const T &b) { if (a > b) { a = b; return true; } return false; }
template <class T> string join(const T &v, const string delim = ",")
{
if (v.empty())
return "";
ostringstream res;
res << v[0];
for (int i = 1; i < v.size(); i++)
{
res << delim << v[i];
}
return res.str();
}
#pragma endregion Macros
int main()
{
int N;
cin >> N;
vector<int> A(N);
rep(i, N) cin >> A[i];
vector<int> c(100001);
rep(i,N) {
c[A[i]]++;
}
rep(i,100001){
if(c[i] >= 3){
if(c[i]%2==0){
c[i] = 2;
}else{
c[i] = 1;
}
}
}
vector<int> d(3);
rep(i,100001){
d[c[i]]++;
}
int ans = 0;
ans += d[1];
ans += d[2];
if (d[2] % 2 == 1) ans--;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll LINF = 1e18;
const int INF = 1e9;
const ll MOD = 1000000007;
int main(){
int n;
cin >> n;
vector<int> cnt(1000010, 0);
cnt[n]++;
int v = INF;
int index = 1;
while(cnt[n] != 2){
if(n%2 == 0) n /= 2;
else n = 3 * n + 1;
if(v > n){
v = min(v, n);
}
cnt[n]++;
index++;
}
cout << index << endl;
return 0;
}
| 0
| 94,322,912
|
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
const int N = 100 * 1000 + 5;
pair <int, int> a[N];
long long pos[N];
int main() {
long long x = 0;
int n, l, t;
cin >> n >> l >> t;
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
if (a[i].second == 1) {
pos[i] = a[i].first + t;
x += pos[i] / l;
pos[i] %= l;
}
else {
pos[i] = a[i].first - t;
if (pos[i] < 0) {
x -= (-pos[i] - 1) / l + 1;
}
pos[i] += 1ll * l * N;
pos[i] %= l;
}
}
sort(pos, pos + n);
x += 1ll * n * t * 1000;
x += 1ll * n * n;
x %= n;
for (int i = 0; i < n; i++) {
cout << pos[(i + x) % n] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
typedef long long ll;
using namespace std;
int main(void){
int n,c,k;cin>>n>>c>>k;
int tmp=0,lim=0,res=0;
vector<int> T(n);
rep(i,n) cin>>T[i];
sort(T.begin(),T.end());
lim=T[0];
rep(i,n){
int t=T[i];
if(t>lim+k){
lim=t;
tmp=1;
res++;
}else if(tmp==c){
lim=t;
tmp=1;
res++;
}else{
tmp++;
}
}
if(tmp>0)res++;
cout<<res<<endl;
}
| 0
| 95,427,503
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ff first
#define ss second
#define int long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define F first
#define S second
#define vi vector<int>
#define mii map<int,int>
#define pqb priority_queue<int>
#define pqs priority_queue<int,vi,greater<int> >
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18 + 1
#define endl '\n'
#define ps(x,y) fixed<<setprecision(y)<<x
#define mk(arr,n,type) type *arr=new type[n];
#define w(x) int x; cin>>x; while(x--)
#define forI(i,a,n) for(int i=a;i<=n;i++)
#define forD(i,a,n) for(int i=n;i>=a;i--)
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
void init(){
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
int dp[100005][2];
vi Tree[100005];
void compute(int n, int p){
dp[n][0] = dp[n][1] = 1;
for(auto child : Tree[n]){
if(child == p) continue;
compute(child, n);
dp[n][0] = dp[n][0] * ((dp[child][0] + dp[child][1])%mod)%mod;
dp[n][1] = dp[n][1] * dp[child][0]%mod;
}
}
void solve(){
int n, x, y; cin>>n;
forI(i, 1, n-1){
cin>>x>>y;
Tree[x].pb(y);
Tree[y].pb(x);
}
compute(1, -1);
cout<<(dp[1][0]+dp[1][1])%mod<<endl;
}
int32_t main(){
init();
solve();
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
typedef pair<int, int> P;
const int INF = 1000000;
int dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
int H, W;
bool a[1000][1000];
int d[1000][1000];
int bfs(int sx, int sy, int gx, int gy) {
for (int y = 0; y < H; y++)
fill_n(d[y], W, INF);
d[sy][sx] = 0;
queue<P> que;
que.push(P(sx, sy));
while (!que.empty()) {
P p = que.front();
que.pop();
int x = p.first, y = p.second;
if (x == gx && y == gy)
return d[y][x];
for (int i = 0; i < 4; i++) {
int _x = x + dx[i], _y = y + dy[i];
if (_x >= 0 && _x < W && _y >= 0 && _y < H && !a[_y][_x] && d[_y][_x] == INF) {
d[_y][_x] = d[y][x] + 1;
que.push(P(_x, _y));
}
}
}
}
int main() {
int N;
scanf("%d%d%d", &H, &W, &N);
int xi[10], yi[10];
for (int y = 0; y < H; y++) {
char s[1001];
scanf("%s", s);
for (int x = 0; x < W; x++) {
a[y][x] = (s[x] == 'X');
if (s[x] == 'S') {
xi[0] = x;
yi[0] = y;
}
if (s[x] >= '1' && s[x] <= '9') {
int i = s[x] - '0';
xi[i] = x;
yi[i] = y;
}
}
}
int ans = 0;
for (int i = 0; i < N; i++)
ans += bfs(xi[i], yi[i], xi[i + 1], yi[i + 1]);
printf("%d\n", ans);
return 0;
}
| 0
| 10,151,900
|
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
int main() {
ll k, a, b;
cin >> k >> a >> b;
ll ans = 1;
if (b - a <= 2) {
cout << 1 + k << endl;
return 0;
}
if (k <= a - 1) {
cout << 1 + k << endl;
return 0;
}
ans = a;
ll num = k - (a - 1);
if (num % 2 == 0) {
ans += num / 2 * (b - a);
} else {
ans += num / 2 * (b - a) + 1;
}
cout << ans << endl;
}
|
#include <iostream>
#include <string>
using namespace std;
string a[10001],b[10001];
int n;
int s2n(string str){
int num=0;
int c = 0;
for(int j=0;j<str.size();j++) {
if(j == 2) {
c += num*60*60;
num = 0;
continue;
}
if(j == 5) {
c += num*60;
num = 0;
continue;
}
num *= 10;
num += str[j]-'0';
}
c += num;
return c;
}
int main() {
while(1) {
cin >> n;
if(n == 0) break;
int time[86401]={};
int c ,d;
for(int i=0;i<n;i++) {
cin >> a[i] >> b[i];
c = s2n(a[i]);
d = s2n(b[i]);
time[c]++;
time[d]--;
}
int ans=-1;
for(int i=1;i<=86400;i++){
time[i] += time[i-1];
if(time[i] > ans) ans = time[i];
}
cout << ans <<endl;
}
return 0;
}
| 0
| 33,895,423
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int>a(n);
for (int i = 0; i < n; i++)cin >> a.at(i);
deque<int>q;
bool r = true;
if (n % 2 == 1)r = false;
for (int i = 0; i < n; i++) {
if (r) {
q.push_back(a.at(i));
r = false;
}
else {
q.push_front(a.at(i));
r = true;
}
}
cout << q.front();
q.pop_front();
while (q.size() > 0) {
cout << " " << q.front();
q.pop_front();
}
cout << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,s,n) for (int i = (int)s; i < (int)n; i++)
#define ll long long
#define pb push_back
#define eb emplace_back
#define All(x) x.begin(), x.end()
#define Range(x, i, j) x.begin() + i, x.begin() + j
#define lbidx(x, y) lower_bound(x.begin(), x.end(), y) - x.begin()
#define ubidx(x, y) upper_bound(x.begin(), x.end(), y) - x.begin()
#define llbidx(x, y, z) lower_bound(x.begin(), x.end(), z) - lower_bound(x.begin(), x.end(), y)
#define deg2rad(deg) ((((double)deg)/((double)360)*2*M_PI))
#define rad2deg(rad) ((((double)rad)/(double)2/M_PI)*(double)360)
#define Find(set, element) set.find(element) != set.end()
#define Decimal(x) printf("%.10f\n", x)
#define PrintVec(x) for (auto elementPrintVec: x) { cout << elementPrintVec << " "; } cout << endl;
typedef pair<int, int> PI;
typedef pair<ll, ll> PLL;
int POWINT(int x, int n) {
int ret = 1;
rep(i, 0, n) ret *= x;
return ret;
};
ll POWLL(int x, int n) {
ll ret = 1;
rep(i, 0, n) ret *= x;
return ret;
};
template<class T>
inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
};
template<class T>
inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
};
bool check(int mid, vector<int> &a, int n, int p, int v, int m) {
if (n - mid <= p) return true;
if (a[mid] + m < a[n-p]) return false;
{
ll score = (ll)a[mid] + (ll)m;
ll mv = (ll)m * (ll)v;
ll possible_mv = 0ll;
possible_mv += (ll)(mid+1) * (ll)m;
possible_mv += (ll)(p-1) * (ll)m;
rep(i, mid+1, n-p+1) {
possible_mv += (score - (ll)a[i]);
}
if (possible_mv >= mv) {
return true;
} else {
return false;
}
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, v, p;
cin >> n >> m >> v >> p;
vector<int> a(n);
rep(i, 0, n) {
cin >> a[i];
}
sort(All(a));
int low = -1;
int high = n-1;
while (abs(high - low) > 1) {
int mid = (high + low) / 2;
if (check(mid, a, n, p, v, m)) {
high = mid;
} else {
low = mid;
}
}
cout << n - high << endl;
return 0;
};
| 0
| 28,645,014
|
#include <stdio.h>
#include <string>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <iostream>
#include <math.h>
#include <bitset>
#include <iomanip>
#include <queue>
#include <cstring>
using namespace std;
int main() {
long long N, K,x=0,mod=1000000007; cin >> N >> K;
vector<long long> A(N);
for (int i = 0; i < N; i++)cin >> A[i];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (A[i] > A[j]&&i<j) {
x += (K * (K + 1)) / 2;
x %= mod;
}
if (A[i]>A[j] && i>j) {
x += (K * (K - 1)) / 2;
x %= mod;
}
}
}
cout << x << endl;
}
|
#include <iostream>
#include <deque>
#include <string>
#include <vector>
#include <queue>
#include <cstdio>
#include <stack>
#include <algorithm>
#include <cstring>
#include <cctype>
#include <cstdio>
#include <cmath>
#include<list>
#include <cstdlib>
using namespace std;
typedef long long ll;
int n;
list<int> p;
int main()
{
scanf("%d",&n);
char s[20];
int x;
for(int i = 0; i < n; ++i){
scanf("%s",s);
if(s[0] == 'i'){
scanf("%d",&x);
p.push_front(x);
}else if(s[6] == 'F'){
p.pop_front();
}else if(s[6] == 'L'){
p.pop_back();
}else if(s[0] == 'd'){
scanf("%d",&x);
for(list<int>::iterator it = p.begin(); it != p.end(); ++it){
if(*it == x){
p.erase(it);
break;
}
}
}
}
for(list<int>::iterator it = p.begin(); it != p.end(); ++it){
printf("%s%d",it == p.begin() ? "" : " ", *it);
}
printf("\n");
return 0;
}
| 0
| 48,434,003
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int x;
cin >> x;
if (x >= 400 && x< 600){
cout << 8 << endl;
}else if (x >= 600 && x <800){
cout << 7 << endl;
}else if ( x >= 800 && x<1000){
cout << 6 << endl;
}else if (x >= 1000 && x <1200){
cout << 5 << endl;
}else if (x >= 1200 && x<1400){
cout << 4 << endl;
}else if (x >=1400 && x <1600){
cout <<3<<endl;
}else if (x>=1600 && x<1800){
cout <<2<<endl;
}else if (x>=1800){
cout <<1<<endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define ld long double
const int INF = 1e15 + 7;
const int MAX = 1e5 + 7;
const int MOD = 1e9 + 7;
typedef pair<ll, ll> ii;
typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef vector<ii> vii;
typedef vector<vii> vvii;
typedef vector<bool> vb;
#define pq priority_queue
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define all(c) (c).begin(), (c).end()
#define ordered_set tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vii a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i].ff, a[i].ss = i;
sort(all(a));
map<int, int> m;
int j = n;
for (int i = n; i > 0; i--)
{
j = min(j, a[i].ss);
m[j] += (a[i].ff - a[i - 1].ff) * (n - i + 1);
}
for (int i = 1; i <= n; i++)
cout << m[i] << endl;
return 0;
}
| 0
| 64,857,695
|
#include <bits/stdc++.h>
#include<cmath>
#define N 100005
#define A 1000005
#define MOD 1000000007
#define inf 1000000000000000000
#define ll long long
using namespace std;
#define pii pair<ll, ll>
#define piii pair<ll, pii>
#define ft first
#define sd second
#define pb push_back
#define rep(i, n) for(ll i = 0; i < n; i++)
#define repr(i, n) for(ll i = n-1; i >= 0; i--)
#define itr(it, x) for(auto it = x.begin(); it != x.end(); it++)
#define mem(a, b) memset(a, (ll)b, sizeof(a))
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
#define edge(v, x, y) v[x].pb(y); v[y].pb(x);
#define popcount __builtin_popcount
#define ANS(s) {cout << s << "\n"; return;}
#define printpii(a) cout << a.ft << " " << a.sd << endl;
#define printpiii(a) cout << a.ft << " " << a.sd.ft << " " << a.sd.sd << endl;
#define print(a, n) rep(i, n) cout << a[i] << " "; cout << endl;
#define printv(v) for(auto x: v)cout << x << " "; cout << endl;
#define printm(a, n, m) rep(i, n) { rep(j, m) cout << a[i][j] << "\t"; cout << endl;}
ll lx[4] = {0, 0, 1, -1};
ll ly[4] = {1, -1, 0, 0};
ll dx[8] = {0, 0, 1, -1, 1, -1, 1, -1};
ll dy[8] = {1, -1, 0, 0, 1, 1, -1, -1};
void fast(){ios_base::sync_with_stdio(false);cin.tie(0);cout << setprecision(12) << fixed;}
ll lcm(ll a, ll b) {return (a*b)/__gcd(a, b); }
void solve()
{
ll l, r; cin >> l >> r;
if(r-l >= 2019) ANS(0);
ll mn = inf;
for(ll i = l; i <= r; i++){
for(ll j = i+1; j <= r; j++){
mn = min(mn, (i*j)%2019);
}
}
cout << mn;
}
int main(){
fast();
ll t = 1;
while(t--){
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define sz(v) ((int)((v).size()))
#define clr(v, d) memset(v, d, sizeof(v))
#define rep(i, v) for(int i=0; i<sz(v); ++i)
#define lp(i, n) for(int i=0; i<(int)(n); ++i)
#define lpi(i, j, n) for(int i=(j); i<(int)(n); ++i)
#define lpd(i, j, n) for(int i=(j); i>=(int)(n); --i)
#define INF 1000000000
typedef long long ll;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
const int N = 1e5+5;
priority_queue<pair<int, int>> all;
priority_queue<pair<int, int>> rep;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>> > sol;
int vis[N];
int main()
{
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, uniq = 0;
cin >> n >> k;
lp(i, n){
pair<int, int> in;
cin >> in.second >> in.first;
all.push(in);
}
lp(i, n){
pair<int, int> in = all.top();
all.pop();
if(vis[in.second] > 0 || uniq == k)
rep.push(in);
else{
sol.push(in);
++vis[in.second];
++uniq;
}
}
lpi(i, uniq, k){
sol.push(rep.top());
++vis[rep.top().second];
rep.pop();
}
while(!rep.empty()){
ll op1 = 0ll + (uniq-1)*(uniq-1) + rep.top().first;
ll op2 = 0ll + (uniq)*(uniq) + sol.top().first;
if(op1 > op2){
sol.pop();
sol.push(rep.top());
rep.pop();
--uniq;
}
else
break;
}
ll ans = 0;
ans = 1ll * uniq * uniq;
while(!sol.empty()){
ans += 0ll + sol.top().first;
sol.pop();
}
cout << ans;
return 0;
}
| 0
| 23,391,496
|
#include<bits/stdc++.h>
#define ll long long
#define mod 1000000007
using namespace std;
int main()
{
ll a,b,k;
cin>>a>>b>>k;
ll h=max(0ll,a-k);
k=max(0ll,k-a);
b=max(0ll,b-k);
cout<<h<<" "<<b<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
typedef vector<vector<int> > vvi;
typedef vector<pair<int, int> > vpii;
typedef pair<int, int> pii;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef vector<ll> vll;
#define INF 0x3f3f3f3f
#define MOD 1000000007LL
#define EPSILON 0.00001
#define f first
#define s second
#define pb push_back
#define mp make_pair
#define FOR(i, a, b) for (ll i=(a); i<=(signed)(b); i++)
#define F0R(i, a) for (ll i=0; i<(signed)(a); i++)
#define RFOR(i, a, b) for (ll i=(a); i >= b; i--)
#define MN 100005
int n;
ll k;
int a[MN];
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
F0R(i, n){
cin >> a[i];
}
ll res = 0;
F0R(i, n){
FOR(j, i+1, n-1){
if(a[i] > a[j]){
res += k*(k+1)/2;
} else if(a[i] < a[j]){
res += k*(k-1)/2;
}
res %= MOD;
}
}
cout << res << "\n";
return 0;
}
| 0
| 66,314,902
|
#include <bits/stdc++.h>
using namespace std;
#define N 200005
int n, a[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i ++) scanf("%d", &a[i]);
int cur = 1;
for (int i = 1; i <= n; i ++) {
if (a[i] == cur) cur ++;
}
if (cur == 1) puts("-1");
else printf("%d\n", n - cur + 1);
return 0;
}
|
#include <iostream>
#include <cstdlib>
using namespace std;
int main(){
char str[1000];
char one_str[2] = {'0', '\0'};
char *sp;
int a, digit;
cin>>str;
a = atoi(str);
while(a){
digit=0;
sp=str;
while(1){
if(*sp=='\0') break;
one_str[0] = *sp;
digit += atoi(one_str);
sp++;
}
cout<<digit<<endl;
cin>>str;
a = atoi(str);
}
return 0;
}
| 0
| 76,667,571
|
#include<iostream>
#include<algorithm>
#include<cmath>
#include<map>
#include<stdio.h>
#include<vector>
#include<queue>
#include<math.h>
#include<deque>
#include<bitset>
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;
}
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) ic(q)
UF tree(n+1);
rep(0,i,q){
ic(t) ic(u) ic(v)
if(t==0)tree.unite(u,v);
else{
c(tree.same(u,v))
}
}
}
|
#include<iostream>
#include<cstdio>
#include<vector>
#include<set>
#include<map>
#include<algorithm>
#include<string.h>
#define fornt(k,n) for(int i=k; i<n; ++i)
#define fornt2(p,n) for(int j=p; j<n; ++j)
#define pb push_back
#define ll long long
#define sc(n) scanf("%d",&n)
#define sc2(x,y) scanf("%d %d",&x,&y)
#define scl(n) scanf("%lld",&n)
#define scl2(x,y) scanf("%lld %lld",&x,&y)
#define pr(n) printf("%d\n",n)
#define prl(n) printf("%lld\n",n)
#define pry printf("YES\n")
#define prn printf("NO\n")
using namespace std;
int main ()
{
int n,m,k,ans(0);
sc2(n,m);
sc(k);
char a[n][m];
fornt(0,n)
{
fornt2(0,m)
{
cin>>a[i][j];
}
}
fornt(0,(1 << n))
{
fornt2(0,(1 << m))
{
int c=0;
for(int c1 = 0; c1<n; c1++)
{
for(int c2 = 0; c2<m; c2++)
{
if((i & (1 << c1)) && (j & (1 << c2)))
{
if(a[c1][c2]=='#')
++c;
}
}
}
if(c==k)
++ans;
}
}
pr(ans);
}
| 0
| 15,440,593
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll solve() {
ll N;
cin >> N;
vector<ll> T(N), A(N);
for ( int i = 0; i < N; i++ ) cin >> T[i];
for ( int i = 0; i < N; i++ ) cin >> A[i];
ll m = 0;
for ( int i = 0; i < N; i++ ) {
m = max(m, T[i]);
m = max(m, A[i]);
}
int it = 0, ia = N-1;
for ( int i = 0; i < N; i++ ) {
if ( T[i] == m ) {
it = i;
break;
}
}
for ( int i = N-1; i >= 0; i-- ) {
if ( A[i] == m ) {
ia = i;
break;
}
}
for ( int i = it; i < N; i++ ) {
if ( T[i] != m ) return 0;
}
for ( int i = ia; i >= 0; i-- ) {
if ( A[i] != m ) return 0;
}
if ( it > ia ) return 0;
const ll MOD = 1e9 + 7;
auto Add = [&](ll& x, ll y) { x = ( x % MOD + y % MOD ) % MOD; };
auto Mul = [&](ll& x, ll y) { x = ( x % MOD * y % MOD ) % MOD; };
ll ans = 1;
for ( int i = 1; i < N-1; i++ ) {
if ( T[i] != T[i-1] || A[i] != A[i+1] ) continue;
Mul(ans, min(T[i], A[i]));
}
return ans;
}
int main() {
auto ans = solve();
cout << ans << "\n";
return 0;
}
|
#include <atcoder/all>
#pragma region template 3.0
#define G3(_1, _2, _3, F, ...) F
#define G4(_1, _2, _3, _4, F, ...) F
#define G5(_1, _2, _3, _4, _5, F, ...) F
#define G6(_1, _2, _3, _4, _5, _6, F, ...) F
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
using vec = vector<T>;
template <typename T>
using vec2 = vec<vec<T>>;
template <typename T>
using vec3 = vec<vec2<T>>;
template <typename T>
using vec4 = vec<vec3<T>>;
using vi = vec<ll>;
using vvi = vec2<ll>;
using ii = pair<ll, ll>;
using iii = tuple<ll, ll, ll>;
using vii = vec<ii>;
using vs = vec<string>;
using vb = vec<bool>;
template <typename T>
using pq = priority_queue<T, vector<T>, greater<T>>;
#define VEC1(T, n1) vec<T>(n1)
#define VEC2(T, n1, n2) vec2<T>(n1, VEC1(T, n2))
#define VEC3(T, n1, n2, n3) vec3<T>(n1, VEC2(T, n2, n3))
#define VEC4(T, n1, n2, n3, n4) vec4<T>(n1, VEC3(T, n2, n3, n4))
#define vec(...) G5(__VA_ARGS__, VEC4, VEC3, VEC2, VEC1)(__VA_ARGS__)
#define VEC1V(T, n1, v) vec<T>(n1, v)
#define VEC2V(T, n1, n2, v) vec2<T>(n1, VEC1V(T, n2, v))
#define VEC3V(T, n1, n2, n3, v) vec3<T>(n1, VEC2V(T, n2, n3, v))
#define VEC4V(T, n1, n2, n3, n4, v) vec4<T>(n1, VEC3V(T, n2, n3, n4, v))
#define vecv(...) G6(__VA_ARGS__, VEC4V, VEC3V, VEC2V, VEC1V)(__VA_ARGS__)
#define REP0(i, n) for (ll i = 0; i < (n); ++i)
#define REP(i, j, n) for (ll i = (j); i < (n); ++i)
#define rep(...) G3(__VA_ARGS__, REP, REP0)(__VA_ARGS__)
#define REP1(i, n) for (ll i = 1; i <= (n); ++i)
#define REPI(i, j, n) for (ll i = (j); i <= (n); ++i)
#define repi(...) G3(__VA_ARGS__, REPI, REP1)(__VA_ARGS__)
#define RREP0(i, n) for (ll i = (n)-1; i >= 0; --i)
#define RREP(i, j, n) for (ll i = (n)-1; i >= (j); --i)
#define rrep(...) G3(__VA_ARGS__, RREP, RREP0)(__VA_ARGS__)
#define RREP1(i, n) for (ll i = (n); i >= 1; --i)
#define RREPI(i, j, n) for (ll i = (n); i >= (j); --i)
#define rrepi(...) G3(__VA_ARGS__, RREPI, RREP1)(__VA_ARGS__)
#define each(i, a) for (auto &i : a)
#define ch(f, x, y) x = f((x), (y))
#define ALL(a) (a).begin(), (a).end()
#define SORT(a) sort(ALL(a))
#define RSORT(a) \
SORT(a); \
reverse(ALL(a))
#define IN1(T, a) \
T a; \
cin >> a;
#define IN2(T, a, b) \
T a, b; \
cin >> a >> b;
#define IN3(T, a, b, c) \
T a, b, c; \
cin >> a >> b >> c;
#define IN4(T, a, b, c, d) \
T a, b, c, d; \
cin >> a >> b >> c >> d;
#define in(...) G5(__VA_ARGS__, IN4, IN3, IN2, IN1)(__VA_ARGS__)
#define ll(...) in(ll, __VA_ARGS__)
#define STR(...) in(string, __VA_ARGS__)
#define VIN1(T, a, n) \
vec<T> a(n); \
each(i, a) cin >> i;
#define VIN2(T, a, b, n) \
vec<T> a(n), b(n); \
rep(i, n) cin >> a[i] >> b[i];
#define VIN3(T, a, b, c, n) \
vec<T> a(n), b(n), c(n); \
rep(i, n) cin >> a[i] >> b[i] >> c[i];
#define VIN4(T, a, b, c, d, n) \
vec<T> a(n), b(n), c(n), d(n); \
rep(i, n) cin >> a[i] >> b[i] >> c[i] >> d[i];
#define vin(...) G6(__VA_ARGS__, VIN4, VIN3, VIN2, VIN1)(__VA_ARGS__)
#define vll(...) vin(ll, __VA_ARGS__)
#define vvll(a, n) \
vvi a = vec(ll, n, n); \
rep(i, n) rep(j, n) cin >> a[i][j];
#define out(x) cout << (x) << endl;
#define fout(x) cout << fixed << setprecision(15) << (x) << endl;
#define DUMP1(a) cout << #a << " = " << (a) << endl;
#define DUMP2(a, b) \
cout << #a << " = " << (a) << ' ' << #b << " = " << (b) << endl;
#define DUMP3(a, b, c) \
cout << #a << " = " << (a) << ' ' << #b << " = " << (b) << ' ' << #c \
<< " = " << (c) << endl;
#define DUMP4(a, b, c, d) \
cout << #a << " = " << (a) << ' ' << #b << " = " << (b) << ' ' << #c \
<< " = " << (c) << ' ' << #d << " = " << (d) << endl;
#define DUMP5(a, b, c, d, e) \
cout << #a << " = " << (a) << ' ' << #b << " = " << (b) << ' ' << #c \
<< " = " << (c) << ' ' << #d << " = " << (d) << ' ' << #e << " = " \
<< (e) << endl;
#define dump(...) \
G5(__VA_ARGS__, DUMP5, DUMP4, DUMP3, DUMP2, DUMP1)(__VA_ARGS__)
template <typename T>
ostream &jout(T s, T e, string sep = " ", ostream &os = cout) {
if (s != e) {
os << *s;
++s;
}
while (s != e) {
os << sep << *s;
++s;
}
return os;
}
ostream &yes(bool cond, string y = "Yes", string n = "No", ostream &os = cout) {
os << (cond ? y : n) << endl;
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3> &t) {
return os << '(' << get<0>(t) << ", " << get<1>(t) << ", " << get<2>(t)
<< ')';
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
return jout(ALL(v), ", ", os << '[') << ']';
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &s) {
return jout(ALL(s), ", ", os << '{') << '}';
}
template <typename K, typename V>
ostream &operator<<(ostream &os, const map<K, V> &m) {
return jout(ALL(m), ", ", os << '{') << '}';
}
const ll INF = 1e18;
const ll MOD = 1e9 + 7;
#pragma endregion template
#pragma region uft 1.0
struct uft {
vi p;
vi s;
uft() {}
uft(ll n) {
p.assign(n + 1, 0);
repi(i, n) { p[i] = i; }
s.assign(n + 1, 1);
}
ll find(ll i) {
if (p[i] == i) {
return i;
}
p[i] = find(p[i]);
return p[i];
}
void unite(ll i, ll j) {
i = find(i);
j = find(j);
if (i == j) {
return;
}
if (s[i] < s[j]) {
p[i] = j;
} else {
p[j] = i;
}
s[j] += s[i];
s[i] = s[j];
}
bool same(ll i, ll j) { return find(i) == find(j); }
ll size(ll i) { return s[find(i)]; }
};
#pragma endregion uft
using namespace atcoder;
int main() {
ll(N, Q);
vll(t, u, v, Q);
uft dsu(N);
rep(i, Q) {
if (t[i] == 0) {
dsu.unite(u[i], v[i]);
} else {
out(dsu.same(u[i], v[i]));
}
}
}
| 0
| 76,217,118
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int,int>;
using Pl = pair<ll,ll>;
#define rep(i,n) for(ll i = 0;i < (ll)n;i++)
#define ALL(x) (x).begin(),(x).end()
#define FILLl(n,first_dimension_size,value) fill((ll*)n,(ll*)(n+first_dimension_size),value)
#define FILL(n,first_dimension_size,value) fill((int*)n,(int*)(n+first_dimension_size),value)
#define INF (1 << 30)
#define MOD 1000000007
int dy[4] = {-1,0,0,1};
int dx[4] = {0,1,-1,0};
int main(){
ll n,m;
cin >> n >> m;
ll sum = 0;
map<ll,ll> mp;
mp[sum]++;
rep(i,n){
ll x;cin >> x;
(sum += x)%= m;
mp[sum]++;
}
ll res =0;
for(auto itr = mp.begin();itr != mp.end();itr++)res += (*itr).second*((*itr).second-1ll)/2;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> v;
int now = 1;
int cnt = 0;
rep(i, n) {
if (s[i] == (now + '0')) {
++cnt;
} else {
v.push_back(cnt);
now = 1 - now;
cnt = 1;
}
}
if (cnt != 0) v.push_back(cnt);
int V = v.size();
if (V % 2 == 0) v.push_back(0);
int add = 2 * k + 1;
int ans = 0;
int l = 0;
int r = 0;
int sum = 0;
for (int i = 0; i < V; i += 2) {
int nl = i;
int nr = min(i + add, V);
while (l < nl) {
sum -= v[l];
++l;
}
while (r < nr) {
sum += v[r];
++r;
}
ans = max(ans, sum);
}
cout << ans << endl;
return 0;
}
| 0
| 99,684,130
|
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<queue>
#include<cmath>
#include<algorithm>
#include<ctime>
using namespace std;
typedef long long ll;
const int MAX=1e5+10;
const int mod=1e9+7;
const int inf=0x3f3f3f3f;
const int d[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
const string mode[4]={"dream","dreamer","erase","eraser"};
bool Match(const string&mo,const char* s,const int&k){
int l=mo.length();
for(int i=0;i<l;i++){
if(mo[i]!=s[i+k]) return false;
}
return true;
}
void DFS(const int&k,const char* s,bool &F){
if(k==strlen(s)){
F=true;
return;
}
for(int i=0;i<4;i++){
if(Match(mode[i],s,k)){
DFS(k+mode[i].length(),s,F);
if(F) return;
}
}
}
int main(){
char s[MAX];
while(~scanf("%s",s)){
bool F=false;
DFS(0,s,F);
if(F) puts("YES");
else puts("NO");
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cctype>
#include <cassert>
#include <climits>
#include <string>
#include <bitset>
#include <cfloat>
#include <unordered_set>
#pragma GCC optimize("Ofast")
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int,int> > vpii;
typedef vector<vector<int> > vvi;
typedef vector<vector<char> > vvc;
typedef vector<vector<string> > vvs;
typedef vector<vector<ll> > vvll;
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define irep(it, stl) for(auto it = stl.begin(); it != stl.end(); it++)
#define drep(i,n) for(int i = (n) - 1; i >= 0; --i)
#define fin(ans) cout << (ans) << '\n'
#define STI(s) atoi(s.c_str())
#define mp(p,q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define Rort(a) sort(a.rbegin(), a.rend())
#define MATHPI acos(-1)
#define itn int;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class T> inline bool chmax(T& a,T b){if(a<b){a=b;return 1;} return 0;}
template <class T> inline bool chmin(T& a,T b){if(a>b){a=b;return 1;} return 0;}
struct io{io(){ios::sync_with_stdio(false);cin.tie(0);}};
const int INF = INT_MAX;
const ll LLINF = 1LL<<60;
const ll MOD = 1000000007;
const double EPS = 1e-9;
int main(void) {
int n,m,k;
cin>>n>>m>>k;
set<int> s;
for(int i=0;i<=n;i++){
s.insert(i*m);
}
for(int i=0;i<=m;i++){
s.insert(i*n);
}
for(int i=0;i<=n;i++){
for(int j=0;j<=m;j++){
int num=i*m+j*n-2*i*j;
s.insert(num);
}
}
if(s.count(k)==0)fin("No");
else fin("Yes");
}
| 0
| 40,901,224
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define REP(i,m,n) for(int i=(int)(m); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define RREP(i,m,n) for(int i=(int)(m); i>=(int)(n); i--)
#define rrep(i,n) RREP(i,(n)-1,0)
#define all(v) v.begin(), v.end()
#define endk '\n'
const int inf = 1e9+7;
const ll longinf = 1LL<<60;
const ll mod = 1e9+7;
const ld eps = 1e-10;
template<typename T1, typename T2> inline void chmin(T1 &a, T2 b){if(a>b) a=b;}
template<typename T1, typename T2> inline void chmax(T1 &a, T2 b){if(a<b) a=b;}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s, t; cin >> s >> t;
sort(all(s));
sort(all(t), greater<char>());
cout << (s < t ? "Yes" : "No") << endk;
return 0;
}
|
#include<iostream>
#include<vector>
using namespace std;
int main(void){
int N;
vector<int> array;
int swap_num;
int tmp;
int min;
cin >> N;
for(int i=0;i<N;++i){
cin >> tmp;
array.push_back(tmp);
}
swap_num = 0;
for(int i=0;i<N;++i){
min = i;
for(int j=i;j<N;++j){
if(array[min]>array[j]){
min = j;
}
}
if(min != i){
tmp = array[i];
array[i] = array[min];
array[min] = tmp;
swap_num++;
}
}
for(int i=0;i<N;++i){
cout << array[i];
if(i<N-1){
cout << " ";
}
}
cout << endl;
cout << swap_num << endl;
return 0;
}
| 0
| 54,970,412
|
#include<iostream>
int main()
{
int arr[2], tmp;
while(true)
{
std::cin >> arr[0] >> arr[1];
if(arr[0] == 0 && arr[1] == 0) break;
if(arr[0] > arr[1]) {
tmp = arr[1];
arr[1] = arr[0];
arr[0] = tmp;
}
std::cout << arr[0] << " " << arr[1] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define INF 1000007
#define MOD 1000000007
#define maxn 101
#define maxh 1001
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) FOR(i, 0, n)
const int dx[4] = {0, 1, -1, 0}, dy[4] = {1, 0, 0, -1};
typedef std::pair<int, int> P;
#define int long long
#define double long double
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *) array, (T *) (array + N), val);
}
vector<bool> prime(maxn + 1, true);
void prime_table(void) {
prime[0] = false;
prime[1] = false;
for (int i = 2; i * i <= maxn; i++) {
if (!prime[i]) {
continue;
}
for (int j = i + i; j <= maxn; j += j + i) {
prime[j] = false;
}
}
}
int gcd(int a, int b) {
return b ? gcd(b, a % b) : a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
bool IsPrime(int num)
{
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2) {
if (num % i == 0) {
return false;
}
}
return true;
}
vector<int> divisor(int n)
{
vector<int> ret;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i - 1);
if (i * i != n) {
ret.push_back((n / i) - 1);
}
}
}
sort(ret.begin(), ret.end());
return (ret);
}
int a, b;
void f(int x) {
while (x) {
a++;
b = x;
x /= 10;
}
}
signed main() {
int N;
cin >> N;
vector<int> a(N);
rep(i, N) {
cin >> a[i];
}
int now = 1;
rep(i, N) {
if (a[i] == now) {
now++;
}
}
now--;
if (now == 0) {
cout << "-1" << endl;
} else {
cout << N - now << endl;
}
}
| 0
| 100,663,061
|
#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 N;
cin >> N;
ll ans = 1;
for (int i = 1; i < 7; i++) {
ll x = pow(2, i);
if (x <= N) ans = x;
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int d[6];
for (int i = 0; i < 6; i++) {
cin >> d[i];
}
int q, tp, ft;
cin >> q;
while (0 < q) {
cin >> tp >> ft;
int i, j;
for (i = 0; i < 6; i++)
if (d[i] == tp)
break;
for (j = 0; j < 6; j++)
if (d[j] == ft)
break;
if (i < 3 && j < 3)
if (i < j)
if (j-i==1)
cout << d[3-i-j] << "\n";
else
cout << d[5-(3-i-j)] << "\n";
else
if (i-j==1)
cout << d[5-(3-i-j)] << "\n";
else
cout << d[3-i-j] << "\n";
else if (2 < i && 2 < j)
if (i < j)
if (j-i==1)
cout << d[12-i-j] << "\n";
else
cout << d[5-(12-i-j)] << "\n";
else
if (i-j==1)
cout << d[5-(12-i-j)] << "\n";
else
cout << d[12-i-j] << "\n";
else if (2 < j) {
int k = 5-j;
if (i < k)
if (k-i==1)
cout << d[5-(3-i-k)] << "\n";
else
cout << d[3-i-k] << "\n";
else
if (i-k==1)
cout << d[3-i-k] << "\n";
else
cout << d[5-(3-i-k)] << "\n";
}
else if (2 < i) {
int k = 5-i;
if (k < j)
if (j-k==1)
cout << d[5-(3-j-k)] << "\n";
else
cout << d[3-j-k] << "\n";
else
if (k-j==1)
cout << d[3-j-k] << "\n";
else
cout << d[5-(3-j-k)] << "\n";
}
q--;
}
}
| 0
| 92,323,961
|
#include <iostream>
#include <string>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
#include <utility>
#include <functional>
#include <deque>
#include <cctype>
#include <stack>
#include <bitset>
#include <set>
using ll = long long;
using namespace std;
typedef unsigned long long ull;
typedef pair<ll, ll>P;
const ll MOD = 1000000007;
const ll INF = 1 << 30;
const ll INF2 = 9000000000000000000LL;
const int dx[4] = { 1,0,-1,0 }, dy[4] = { 0,1,0,-1 };
const int tx[8] = { -1,0,1,-1,1,-1,0,1 }, ty[8] = { -1,-1,-1,0,0,1,1,1 };
#define ALL(x) (x).begin(),(x).end()
ll h, w, n, chx[10] = { 0 }, chy[10] = { 0 }, d[1010][1010] = { 0 };
char c[1010][1010];
int bfs(ll a, ll b, ll e, ll f) {
queue<P> que;
for (int i = 0;i < h;i++) {
for (int j = 0;j < w;j++) {
d[j][i] = INF;
}
}
que.push(make_pair(a, b));
d[a][b] = 0;
while (que.size()) {
P p = que.front();que.pop();
if (p.first == e&&p.second == f) {
break;
}
for (int i = 0;i < 4;i++) {
ll nx = p.first + dx[i], ny = p.second + dy[i];
if (0 <= nx&&nx < w && 0 <= ny&&ny < h&&c[nx][ny] != 'X'&&d[nx][ny] == INF) {
que.push(make_pair(nx, ny));
d[nx][ny] = d[p.first][p.second] + 1;
}
}
}
return d[e][f];
}
int main() {
ll ans = 0;
cin >> h >> w >> n;
for (int i = 0;i < h;i++) {
for (int j = 0;j < w;j++) {
cin >> c[j][i];
if (c[j][i] == 'S')chx[0] = j, chy[0] = i;
else if (c[j][i] != 'S'&&c[j][i] != '.'&&c[j][i] != 'X') {
chx[int(c[j][i] - '0')] = j, chy[(int)(c[j][i] - '0')] = i;
}
}
}
for (int i = 0;i < n;i++) {
ans += bfs(chx[i], chy[i], chx[i + 1], chy[i + 1]);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, s, n) for (ll i = (s); i < (ll)(n); i++)
#define all(v) v.begin(), v.end()
#define sz(v) v.size()
#define INF 100000000000000
template <typename T>
bool chmax(T &a, const T& b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T>
bool chmin(T &a, const T& b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main()
{
ll N, M;
cin >> N >> M;
vector<ll> A(N), B(N);
map<ll, vector<ll>> work;
rep(i, N){
cin >> A.at(i) >> B.at(i);
work[A.at(i)].push_back(B.at(i));
}
priority_queue<ll> app;
ll ans = 0;
rep(i, M){
rep(j, sz(work[i+1])){
app.push(work[i+1].at(j));
}
if(!app.empty()){
ans += app.top();
app.pop();
}
}
cout << ans << endl;
}
| 0
| 58,339,049
|
#include <bits/stdc++.h>
#define rep(i, n) for (rint i = 1; i <= (n); i ++)
#define re0(i, n) for (rint i = 0; i < (int) n; i ++)
#define travel(i, u) for (rint i = head[u]; i; i = e[i].nxt)
#define rint register int
using namespace std;
typedef long long lo;
template<typename tp> inline void read(tp &x) {
x = 0; char c = getchar(); int f = 0;
for (; c < '0' || c > '9'; f |= c == '-', c = getchar());
for (; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + c - '0', c = getchar());
if (f) x = -x;
}
#define int long long
#define GG (puts("Impossible"), exit(0))
const int N = 2333;
int n, mn, mx, a[N];
vector <int> dis[N], rol;
signed main(void) {
read(n);
rep (i, n) read(a[i]), dis[a[i]].push_back(i), mx = max(mx, a[i]);
mn = (mx + 1) / 2;
rep (k, mn - 1) if (dis[k].size()) GG;
for (int k = mx; k >= mn; k--) {
if (!dis[k].size()) GG;
rol.push_back(dis[k].back()); dis[k].pop_back();
}
for (int k = mn + (!(mx & 1)); k <= mx; k++) {
if (!dis[k].size()) GG;
rol.push_back(dis[k].back()); dis[k].pop_back();
}
if (dis[mn].size()) GG;
puts("Possible");
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
int main() {
int N;
cin >> N;
vector<int> T(N + 2, 0), A(N + 2, 0);
for (int i = 1; i <= N; ++i) {
cin >> T[i];
}
for (int i = 1; i <= N; ++i) {
cin >> A[i];
}
vector<int> S(N + 2, 0);
for (int i = 1; i <= N; ++i) {
if (T[i - 1] < T[i]) {
S[i] = T[i];
}
}
for (int i = N; i >= 1; --i) {
if (A[i] > A[i + 1]) {
if (S[i] != 0 && A[i] != S[i]) {
cout << 0 << endl;
return 0;
}
if (A[i] > T[i]) {
cout << 0 << endl;
return 0;
}
S[i] = A[i];
}
}
long long res = 1;
for (int i = 1; i <= N; ++i) {
if (S[i] != 0) {
continue;
}
res = res * min(A[i], T[i]) % MOD;
}
cout << res << endl;
return 0;
}
| 0
| 21,912,451
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
int mod = 1000000007;
int main(void){
int N; cin >> N;
ll sumA = 0, sumB = 0;
ll behB = 0;
ll A[N],B[N];
ll num_op = 0;
rep(i, N) cin >> A[i];
rep(i, N) cin >> B[i];
rep(i, N){
sumA += A[i]; sumB += B[i];
if(A[i] > B[i]) behB += A[i]-B[i];
else num_op += (B[i]-A[i])/2;
}
if(num_op - behB >= 0) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll gcd(ll x, ll y) { return (x % y)? gcd(y, x % y): y; }
int main(){
ll N , X;
cin >> N >> X;
vector<ll> x(N + 1 , 0);
vector<ll> num(N , 0);
x[0] = X;
for(int i = 1; i <= N; i++) cin >> x[i];
for(int i = 0; i < N; i++) num[i] = abs(x[i] - x[i + 1]);
ll ans = 0;
ll a = num[0];
for (int i = 1; i < N; i++) {
a = gcd(a, num[i]);
}
cout << a << endl;
}
| 0
| 53,561,851
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#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 FORV(i,v) for(auto i=v.begin(); i!=v.end();i++)
#define SORT(s) sort((s).begin(),(s).end())
#define SORTD(s) sort((s).rbegin(),(s).rend())
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );
#define SZ(x) ((int)(x).size())
#define MEMSET(v, h) memset((v), h, sizeof(v))
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n,k,s;
cin>>n>>k>>s;
int kari=100000;
while(s%kari==0){
kari--;
}
REP(i,n-1){
if(k>0)cout<<s<<" ";
else cout<<kari<<" ";
k--;
}
if(k>0)cout<<s<<endl;
else cout<<kari<<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(){
ll n,k,A[200001],sum=0;
cin>>n>>k;
rep(i,n){
cin>>A[i];
if(A[i]>0) sum+=A[i];
}
ll m=1e18,a=0,b=0;
rep(i,n-k+1){
if(i==0) rep(j,k) a+=A[j]*(A[j]<0),b+=A[j]*(A[j]>0);
else{
a=a-A[i-1]*(A[i-1]<0)+A[i+k-1]*(A[i+k-1]<0);
b=b-A[i-1]*(A[i-1]>0)+A[i+k-1]*(A[i+k-1]>0);
}
m=min({m,-a,b});
}
cout<<sum-m;
}
| 0
| 81,425,463
|
#include <bits/stdc++.h>
using namespace std;
int main(void){
int n,k;
cin>>n>>k;
cout<<n%k<<endl;
}
|
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<cassert>
#include<iostream>
#include<sstream>
#include<string>
#include<vector>
#include<queue>
#include<set>
#include<map>
#include<utility>
#include<numeric>
#include<algorithm>
#include<bitset>
#include<complex>
#include<stack>
using namespace std;
typedef long long Int;
typedef vector<int> vint;
typedef pair<int,int> pint;
typedef vector<string> vstring;
typedef vector<pint> vpint;
struct Edge{int to,from,cost;};
#ifdef DEBUG
#define debug cout
#else
stringstream __ss__;
#define debug __ss__
#endif
template<class T> void pv(T a, T b) { for (T i = a; i != b; ++i) debug << *i << " "; debug << endl; }
template<class T> void chmin(T &t, T f) { if (t > f) t = f; }
template<class T> void chmax(T &t, T f) { if (t < f) t = f; }
int in() { int x; scanf("%d", &x); return x; }
#define rep(i,n) for(int i=0;i<(n);++i)
#define repd(i,n) for(int i=(n)-1;i>=0;i--)
#define repn(i,m,n) for(int i=(m);i<=(n);++i)
#define repnd(i,m,n) for(int i=(n)-1;i>=(m);i--)
#define rep0(i,n) for(i=0;i<(n);++i)
#define all(n) n.begin(),n.end()
#define sz(n) ((int)(n).size())
#define IL for(;;)
#define MP make_pair
#define PB push_back
#define SS stringstream
#define X second
#define Y first
#define PUTLINE debug<<"LINE:"<<__LINE__<<endl;
const int INF = 2147483647/3;
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int dx[]={1,-1,0,0,1,-1,1,-1,0};
const int dy[]={0,0,1,-1,1,-1,-1,1,0};
int k[300000];
int main() {
IL{
memset(k,0,sizeof(k));
int n=in();
if(n==0)break;
string f,t;
int from,to;
rep(i,n){
cin>>f>>t;
from=(f[0]-'0')*100000+(f[1]-'0')*10000+(f[3]-'0')*1000+(f[4]-'0')*100+(f[6]-'0')*10+f[7]-'0';
to=(t[0]-'0')*100000+(t[1]-'0')*10000+(t[3]-'0')*1000+(t[4]-'0')*100+(t[6]-'0')*10+t[7]-'0';
++k[from];
--k[to];
}
int res=0,p=0;
rep(i,300000){
p+=k[i];
chmax(res,p);
}
cout<<res<<endl;
}
return 0;
}
| 0
| 87,564,783
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
reverse(s.begin(), s.end());
vector<string> a = {"dream", "dreamer", "erase", "eraser"};
for (int i = 0; i < 4; i++) {
reverse(a.at(i).begin(), a.at(i).end());
}
while (!s.empty()) {
if (s.substr(0, 5) == a.at(0) || s.substr(0, 5) == a.at(2)) {
s.erase(0, 5);
}
else if (s.substr(0, 7) == a.at(1)) {
s.erase(0, 7);
}
else if (s.substr(0, 6) == a.at(3)) {
s.erase(0, 6);
}
else {
break;
}
}
if (s.empty()) {
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = int64_t;
using pint = pair<int, int>;
int main()
{
int k, s;
cin >> k >> s;
ll count = 0;
for (int x = 0; x <= k; ++x)
{
for (int y = 0; y <= k; ++y)
{
int z = s - y - x;
if (z >= 0 && z <= k)
++count;
}
}
cout << count << endl;
}
| 0
| 80,892,928
|
#include<iostream>
using namespace std;
int main(void){
int n;
while(cin >> n){
int nums[n];
int prime=0;
for(int i=1;i<=n;i++){
nums[i]=i;
}
for(int i=1;i<=n;i++){
if(nums[i]>1){
prime++;
for(int j=2;nums[i]*j<=n;j++){
nums[nums[i]*j]=1;
}
}
}
cout << prime << endl;
}
return 0;
}
|
#include <stdio.h>
#include <stack>
int main(void)
{
using namespace std;
stack<int> stk;
int n;
while(scanf("%d",&n)==1)
{
if(!n)
{
printf("%d\n",stk.top());
stk.pop();
}
else
{
stk.push(n);
}
}
return 0;
}
| 0
| 84,837,852
|
#include <cstdio>
#include <cstring>
using namespace std;
char s[10];
char t[10];
char u[10];
int a, b;
void solve() {
if (!strncmp(u, s, strlen(u)))
printf("%d %d\n", a-1, b);
else
printf("%d %d\n", a, b-1);
}
int main() {
scanf("%s", s);
scanf("%s", t);
scanf("%d", &a);
scanf("%d", &b);
scanf("%s", u);
solve();
}
|
#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>;
bool v[1005][1005][1005];
int main() {
int x,y,z,k;
cin >> x >> y >> z >> k;
vector<ll> a(x),b(y),c(z);
rep(i,x) cin >> a[i];
rep(i,y) cin >> b[i];
rep(i,z) cin >> c[i];
sort(a.rbegin(),a.rend());
sort(b.rbegin(),b.rend());
sort(c.rbegin(),c.rend());
priority_queue<tuple<ll,int,int,int>> q;
auto push = [&](int n,int m,int l){
if(v[n][m][l]) return;
v[n][m][l] = true;
q.emplace(a[n]+b[m]+c[l],n,m,l);
};
push(0,0,0);
rep(i,k){
ll ans; int ai,bi,ci;
tie(ans,ai,bi,ci) = q.top(); q.pop();
cout << ans << endl;
if(ai<x-1) push(ai+1,bi,ci);
if(bi<y-1) push(ai,bi+1,ci);
if(ci<z-1) push(ai,bi,ci+1);
}
}
| 0
| 5,540,526
|
#include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define rep(i, n) ;for (int i = 0;i < (int)(n);i++)
#define rep2(i, s, n) ;for (int i = s; i < (int)(n);i++)
#define ALL(vec) (vec).begin(),(vec).end()
#define pi 3.1415926535897932384626433832795
#define MAX_INF 9223372036854775807
#define MIN_INF (922337203685477587+1)
#define sosuu 1000000007
int main() {
int N,M,X,Y;
int maxx=-1000,miny=1000;
cin >> N >> M >> X >> Y;
int a,b;
rep(i, N){
cin >> a;
maxx=max(maxx,max(a,X));
}
rep(i, M){
cin >> b;
miny=min(miny,min(Y,b));
}
if(maxx<miny)
cout <<"No War" << endl;
else
cout << "War" << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define sd(x) scanf("%lf", &x)
#define l0(i,n) for(ll i=0; i<n; i++)
#define MAX 100005
#define maxn 200005
#define pb push_back
#define mk make_pair
#define endl "\n"
#define INF 1000000000
#define MOD 1000000007
#define imie(...) "[" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
int main()
{
int n;
cin >> n;
vector<int> hap[n+5];
vector<int> dp[n+5];
for (int i=0 ; i<n ; i++)
{
int a,b,c;
cin >> a >> b >> c;
hap[i].pb(a);
hap[i].pb(b);
hap[i].pb(c);
dp[i].pb(0);
dp[i].pb(0);
dp[i].pb(0);
}
dp[0][0] = hap[0][0];
dp[0][1] = hap[0][1];
dp[0][2] = hap[0][2];
for(int i = 1; i < n; i++){
dp[i][0] = hap[i][0]+max(dp[i-1][1], dp[i-1][2]);
dp[i][1] = hap[i][1]+max(dp[i-1][0], dp[i-1][2]);
dp[i][2] = hap[i][2]+max(dp[i-1][0], dp[i-1][1]);
}
int ans = *max_element(dp[n-1].begin(),dp[n-1].end());
cout << ans << endl;
return 0;
}
| 0
| 60,729,744
|
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <cmath>
#include <algorithm>
#include <iomanip>
#include <queue>
#include <string>
#include <utility>
#include <cassert>
#include <numeric>
#include <random>
using namespace std;
typedef long long ll;
ll pre[128], suf[128];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<ll> pesos;
for (int i = 0; i < n; i++) {
ll w;
cin >> w;
pesos.push_back(w);
}
pre[0] = pesos[0];
for (int i = 1; i < n; i++) {
pre[i] = pre[i-1] + pesos[i];
}
suf[n-1] = pesos[n-1];
for (int i = n-2; i >= 0; i--) {
suf[i] = suf[i+1] + pesos[i];
}
ll res = 1e18;
for (int i = 1; i < n-1; i++) {
ll aux = abs(pre[i] - suf[i+1]);
res = min(res, aux);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define FOR(i, a, n) for(ll i = (ll)a; i < (ll)n; i++)
#define rep(i, n) FOR(i, 0, n)
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
constexpr int Mod = 998244353;
constexpr int mod = 1e9 + 7;
constexpr ll inf = 1LL << 60;
template <typename T> constexpr bool chmax(T &a, const T b) {
if(a >= b) return false;
a = b;
return true;
}
template <typename T> constexpr bool chmin(T &a, const T b) {
if(a <= b) return false;
a = b;
return true;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
ll n;
cin >> n;
ll a[n], k = 0;
rep(i, n) {
cin >> a[i];
k += a[i];
}
if(k % (n * (n + 1) / 2)) {
cout << "NO" << endl;
return 0;
}
k /= n * (n + 1) / 2;
rep(i, n) {
ll x = a[(i + 1) % n] - a[i] - k;
if(x > 0 || (-x) % n) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 0
| 67,567,569
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i < (n); i++)
#define lower(s) transform(s.begin(), s.end(), s.begin(), ::tolower)
using namespace std;
using ll = long long;
int INF = 1001001001;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
int m = 1000005;
vector<int> cnt(m);
for(int x :a) {
if(cnt[x] != 0) {
cnt[x] = 2;
continue;
}
for(int i=x; i<m; i+=x) {
cnt[i]++;
}
}
int ans = 0;
for(int x :a) {
if(cnt[x] == 1) ans++;
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define Ff(i,a,b) for(i=a;i<b;i++)
#define Fb(i,a,b) for(i=a-1;i>=b;i--)
#define mp make_pair
#define pb push_back
#define ppb pop_back
#define mp make_pair
#define ff first
#define ss second
#define mp make_pair
#define PI 2*asin(1)
#define all(x) x.begin(),x.end()
#define trav(x) for(auto& i:x)
#define FIO ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
typedef long long ll;
typedef vector<int> vi;
typedef vector<bool> vb;
typedef vector<long long> vll;
typedef map<int, int> mi;
typedef map<long long, long long> mll;
typedef unordered_map<int, int> umi;
typedef unordered_map<long long, long long> umll;
typedef set<int> si;
typedef set<long long> sll;
typedef unordered_set<int> usi;
typedef unordered_set<long long> usll;
const ll N = 1e9 + 7;
void sub() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output2.txt", "w", stdout);
#endif
}
bool comp(pair<int, int>a, pair<int, int>b) {
return (a.ss > b.ss);
}
void solve() {
int n, m;
cin >> n >> m;
unordered_map<int, int> x, y;
int k, i;
cin >> k;
int g, h;
set<pair<int, int>>s;
Ff(i, 0, k) {
cin >> g >> h;
s.insert(mp(g, h));
x[g]++;
y[h]++;
}
int ma = -1, mb = -1;
trav(x) {
if (i.ss > ma)
ma = i.ss;
}
trav(y) {
if (i.ss > mb)
mb = i.ss;
}
vector<int>a, b;
for (auto it = x.begin(); it != x.end(); it++)
if (it->ss == ma)a.pb(it->ff);
x.clear();
for (auto it = y.begin(); it != y.end(); it++)
if (it->ss == mb)b.pb(it->ff);
y.clear();
auto ia = a.begin();
auto ib = b.begin();
int mx = ma + mb;
while (ia != a.end()) {
ib = b.begin();
while (ib != b.end()) {
if (s.find(mp(*ia, *ib)) == s.end()) {cout << mx << endl; return;}
ib++;
}
ia++;
}
cout << mx - 1 << endl;
}
int32_t main() {
FIO
sub();
int t = 1;
while (t--)
solve();
return 0;
}
| 0
| 31,505,699
|
#include <iostream>
#include <string>
using namespace std;
string co(int n);
int re(string str);
int main(){
int n,i;
cin >> n;
for(i=0;i<n;i++){
string str1,str2;
cin >> str1 >> str2;
cout << co(re(str1)+re(str2)) << endl;
}
return 0;
}
string co(int n){
string b="";
int k=n/1000;
string c;
c[0]=(k+'0');
if(k==1) b+="m";
if(1<k&&k<=9) {b+= c[0];b+="m";}
k=(n%1000)/100;
c[0]=(k+'0');
if(k==1) b+="c";
if(1<k&&k<=9) {b+= c[0];b+="c";}
k=(n%100)/10;
c[0]=(k+'0');
if(k==1) b+="x";
if(1<k&&k<=9){b+= c[0];b+="x";}
k=n%10;
c[0]=(k+'0');
if(k==1) b+="i";
if(1<k&&k<=9){b+= c[0];b+="i";}
return b;
}
int re(string str){
int n=0;
int p=str.find("m");
if(p!=-1){
if(p==0) n+=1000;
else n+=(str[p-1]-'0')*1000;
}
p=str.find("c");
if(p!=-1){
if(p==0||str[p-1]=='m') n+=100;
else n+=(str[p-1]-'0')*100;
}
p=str.find("x");
if(p!=-1){
if(p==0||str[p-1]=='m'||str[p-1]=='c') n+=10;
else n+=(str[p-1]-'0')*10;
}
p=str.find("i");
if(p!=-1){
if(p==0||str[p-1]=='m'||str[p-1]=='c'||str[p-1]=='x') n+=1;
else n+=(str[p-1]-'0')*1;
}
return n;
}
|
#include <bits/stdc++.h>
#define ll long long
#define L long
#define endl "\n"
#define _START_ ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define _END_ return 0;
using namespace std;
int main()
{
_START_
int n;
cin >> n;
while (n != 0)
{
if (n % 10 == 7)
{
cout<< "Yes";
return 0;
}
n /= 10;
}
cout<< "No";
_END_
}
| 0
| 7,263,086
|
#include<stdio.h>
#include<ctype.h>
int main(){
int i,c;
int cnt[128]={0};
while((c=getchar())!=EOF){
if(isupper(c)){
c=tolower(c);
}
cnt[c]++;
i++;
}
for(i=97;i<=122;i++){
printf("%c : %d\n",i,cnt[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b){
if(a%b == 0){
return b;
}else{
return gcd(b, a%b);
}
}
int gcd_arr(vector<int> &a){
int n = a.size();
for(int i=n-2; i>=0; i--){
a[i] = gcd(a[i], a[i+1]);
}
return a.front();
}
int main(void){
long long int i=0,j,c=0,n,m=0,ans=0,z=0;
string s;
cin >> n >> m;
vector<int> x(n);
for(i=0;i<n;i++)
{
cin >> x[i];
x[i]=abs(m-x[i]);
}
c=gcd_arr(x);
cout << c << endl;
return 0;
}
| 0
| 45,900,281
|
#include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long int64;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const int INF = 1<<29;
const long long INFL = 1e18;
const int MOD = 1000000007;
const int MAX = 210000;
const int MAX_NUM = 999999999;
void solve() {
int D; cin >> D;
if (D == 25) cout << "Christmas" << endl;
else if (D == 24) cout << "Christmas Eve" << endl;
else if (D == 23) cout << "Christmas Eve Eve" << endl;
else cout << "Christmas Eve Eve Eve" << endl;
return;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, n) for (int i = (n); i >= 0; --i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define FORR(i, m, n) for (int i = (m); i >= (n); --i)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
const ll mod = 1000000007;
const int inf = 1e9 + 10;
const ll INF = 1e18;
const ld EPS = 1e-10;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(25);
int n;
cin >> n;
vector<string> s(n);
rep(i, n) cin >> s[i];
int ans = 0;
rep(k, n + 1) {
bool f = true;
rep(i, n) {
rep(j, n) {
if (s[(i + k) % n][j] != s[(j + k) % n][i]) {
f = false;
}
}
}
if (f) ans += n - k;
}
FOR(k, 1, n + 1) {
bool f = true;
rep(i, n) {
rep(j, n) {
if (s[i][(j + k) % n] != s[j][(i + k) % n]) {
f = false;
}
}
}
if (f) ans += n - k;
}
cout << ans << '\n';
return 0;
}
| 0
| 53,824,471
|
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
void Trace(int *A, int N, int cnt){
for (int i = 0; i < N - 1; i++){
printf("%d ", A[i]);
}
printf("%d\n", A[N - 1]);
printf("%d\n", cnt);
}
int SelectionSort(int *A, int N){
int cnt = 0;
for (int i = 0; i < N; i++){
int minj = i;
for (int j = i; j < N; j++){
if (A[minj] > A[j]){
minj = j;
}
}
if (minj != i) {
int t = A[i];
A[i] = A[minj];
A[minj] = t;
cnt++;
}
}
return cnt;
}
int main(int argc, char *argv[]){
int N;
scanf("%d", &N);
int *A = (int*)malloc(sizeof(int) * N);
for (int i = 0; i < N; i++){
scanf("%d", &A[i]);
}
int cnt = SelectionSort(A, N);
Trace(A, N, cnt);
free(A);
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#ifdef DEBUG
#define show(...) cerr << #__VA_ARGS__ << " = ", debug(__VA_ARGS__);
#else
#define show(...) 42
#endif
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <typename T, typename S>
ostream& operator<<(ostream& os, pair<T, S> a) {
os << '(' << a.first << ',' << a.second << ')';
return os;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> v) {
for (auto x : v) os << x << ' ';
return os;
}
void debug() {
cerr << '\n';
}
template <typename H, typename... T>
void debug(H a, T... b) {
cerr << a;
if (sizeof...(b)) cerr << ", ";
debug(b...);
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
rep(i,n)cin >> a[i];
vector<int> mp(n+1);
rep(i,n){
mp[a[i]]++;
}
vector<int> cnt(n + 1, 0);
for(auto x : mp){
cnt[x]++;
}
show(cnt);
int all = n;
for(int k = 1; k <= n; k++){
int x = all / k;
show(k, x, all, cnt.size());
while((int) cnt.size() - 1 > all / k){
if(cnt.back() == 0){
cnt.pop_back();
continue;
}
all--;
cnt.back()--;
cnt[cnt.size() - 2]++;
if(cnt.back() == 0)cnt.pop_back();
}
show(all);
show(cnt);
cout << all / k << "\n";
}
}
| 0
| 87,404,638
|
#include<stdio.h>
int main(){
int a,b,d=0,r=0;
double f=0.0;
scanf("%d %d",&a,&b);
d=a/b;
r=a%b;
f=(double)a/b;
printf("%d %d %lf\n",d,r,f);
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int n;
while (true) {
int count = 0;
cin >> n;
if (cin.eof()) {
return 0;
}
for (int a = 0; a < 10; ++a) {
for (int b = 0; b < 10; ++b) {
for (int c = 0; c < 10; ++c) {
for (int d = 0; d < 10; ++d) {
if (a + b + c + d == n) {
++count;
}
}
}
}
}
cout << count << endl;
}
}
| 0
| 6,729,332
|
#include <iostream>
#include <set>
#include <numeric>
#include <map>
using namespace std;
long long a[100000];
long long b[100000];
long long ans[10];
map <long long, set<long long> > point_map;
set <pair <long long, long long> > checked;
int main(void){
long long H;
long long W;
int N;
cin >> H >> W >> N;
for(int i = 0; i < N; i++){
cin >> a[i] >> b[i];
if(point_map.find(a[i]) == point_map.end()){
set <long long> tmp = {b[i]};
point_map[a[i]] = tmp;
} else {
point_map[a[i]].insert(b[i]);
}
}
for(int i = 0; i < N; i++){
for(int j = -2; j <= 0; j++){
for(int k = -2; k <= 0; k++){
int upper_left_h = a[i] + j;
int upper_left_w = b[i] + k;
if(checked.find(make_pair(upper_left_h, upper_left_w)) != checked.end()
|| upper_left_h < 1 || upper_left_w < 1 || upper_left_h > H - 2 || upper_left_w > W - 2){
continue;
}
int filled_no = 0;
for(int l = 0; l < 3; l++){
for(int m = 0; m < 3; m++){
int cur_h = upper_left_h + l;
int cur_w = upper_left_w + m;
if(point_map.find(cur_h) != point_map.end() && point_map[cur_h].find(cur_w) != point_map[cur_h].end()){
filled_no++;
}
}
}
ans[filled_no] ++;
checked.insert(make_pair(upper_left_h, upper_left_w));
}
}
}
ans[0] = (H - 2) * (W - 2) - accumulate(ans + 1, ans + 10, (long long) 0);
for(int i = 0; i < 10; i++){
cout << ans[i] << endl;
}
return 0;
}
|
#include <cstdio>
#define MAX(a, b)((a) < (b) ? (b) : (a))
using namespace std;
int pow32(int base, int exp)
{
int ret = 1;
while (exp) {
if ((exp & 1) == 1) ret *= base;
exp >>= 1;
base *= base;
}
return ret;
}
void YES()
{
printf("YES\n");
}
void NO()
{
printf("NO\n");
}
int main() {
int N;
int a, b, c;
int longest;
scanf("%d", &N);
while (N--) {
scanf("%d %d %d", &a, &b, &c);
longest = MAX(a, MAX(b, c));
if (longest == a) {
if (pow32(a, 2) == (pow32(b, 2) + pow32(c, 2))) YES();
else NO();
} else if (longest == b) {
if (pow32(b, 2) == (pow32(a, 2) + pow32(c, 2))) YES();
else NO();
} else if (longest == c) {
if (pow32(c, 2) == (pow32(a, 2) + pow32(b, 2))) YES();
else NO();
}
}
return 0;
}
| 0
| 53,017,958
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define rep(i,s,n) for(int i = s; i < (int)(n); i++)
int main() {
int n,m;
cin >> n >> m;
vector<ll>d1(n),d2(n),d3(n),d4(n),d5(n),d6(n),d7(n),d8(n);
rep(i,0,n){
ll x,y,z;
cin >> x >> y >> z;
d1[i] = x+y+z;
d2[i] = x+y-z;
d3[i] = x-y+z;
d4[i] = -x+y+z;
d5[i] = x-y-z;
d6[i] = -x+y-z;
d7[i] = -x-y+z;
d8[i] = -x-y-z;
}
sort(d1.begin(),d1.end());
sort(d2.begin(),d2.end());
sort(d3.begin(),d3.end());
sort(d4.begin(),d4.end());
sort(d5.begin(),d5.end());
sort(d6.begin(),d6.end());
sort(d7.begin(),d7.end());
sort(d8.begin(),d8.end());
ll s1 = 0,s2 = 0,s3 = 0,s4 = 0,s5 = 0,s6 = 0,s7 = 0,s8 = 0;
rep(i,0,m){
s1 += d1[n-1-i];
s2 += d2[n-1-i];
s3 += d3[n-1-i];
s4 += d4[n-1-i];
s5 += d5[n-1-i];
s6 += d6[n-1-i];
s7 += d7[n-1-i];
s8 += d8[n-1-i];
}
ll ans = max(s1,s2);
ans = max(ans,s3);ans = max(ans,s4);ans = max(ans,s5);ans = max(ans,s6);
ans = max(ans,s7);ans = max(ans,s8);
cout << ans << endl;
}
|
#include <vector>
#include <map>
#include <set>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <queue>
#include <iomanip>
#include <list>
#include <string>
typedef char SINT8;
typedef short SINT16;
typedef int SINT32;
typedef long long SINT64;
typedef double DOUBLE;
#define MAX(a,b) ((a)>(b)?(a):(b))
#define MIN(a,b) ((a)<(b)?(a):(b))
#define ABS(a) ((a)>(0)?(a):-(a))
#define rep(i,a,b) for(SINT64 (i)=SINT64(a);(i)<SINT64(b);(i)++)
#define rrep(i,a,b) for(SINT64 (i)=SINT64(a);(i)>=SINT64(b);(i)--)
#define put(a) cout << (a) << endl
#define puts(a) cout << (a) << " "
#define putr(a) rep(testIncrement,0,a.size()) {puts(a[testIncrement]);} cout << endl
#define putrr(a) rep(Incr1,0,a.size()) {rep(Incr2,0,a[Incr1].size()) {puts(a[Incr1][Incr2]);} cout<<endl;} cout<<endl;
#define INF 1000000001
#define MOD 1000000007
#define INF64 1000000000000000001
#define PI (acos(-1))
#define F first
#define S second
#define Pii pair<SINT32,SINT32>
#define Pll pair<SINT64,SINT64>
#define Piii pair<SINT32,pair<SINT32,SINT32>>
#define Plll pair<SINT64,pair<SINT64,SINT64>>
#define Vll(a,b,c) vector<vector<SINT64>> (a)((b),vector<SINT64>((c))
#define Vlll(a,b,c,d) vector<vector<vector<SINT64>>> (a)((b),vector<vector<SINT64>>((c),vector<SINT64>((d)))
using namespace std;
int main() {
SINT64 N; cin >> N;
SINT64 a,b; cin >> a >> b;
SINT64 buf = ABS(b-a);
if ((buf % 2) == 0) {
put("Alice");
} else {
put("Borys");
}
return 0;
}
| 0
| 67,639,966
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < int(n); i++)
#define rrep(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define reps(i, n) for (int i = 1; i <= int(n); i++)
#define rreps(i, n) for (int i = int(n); i >= 1; i--)
#define repc(i, n) for (int i = 0; i <= int(n); i++)
#define rrepc(i, n) for (int i = int(n); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define repic(i, a, b) for (int i = int(a); i <= int(b); i++)
#define each(x, y) for (auto &x : y)
#define all(a) (a).begin(), (a).end()
#define bit(b) (1ll << (b))
using namespace std;
using i32 = int;
using i64 = long long;
using u64 = unsigned long long;
using f80 = long double;
using vi32 = vector<i32>;
using vi64 = vector<i64>;
using vu64 = vector<u64>;
using vf80 = vector<f80>;
using vstr = vector<string>;
inline void yes() { cout << "Yes" << '\n'; exit(0); }
inline void no() { cout << "No" << '\n'; exit(0); }
inline i64 gcd(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); if (a % b == 0) return b; return gcd(b, a % b); }
inline i64 lcm(i64 a, i64 b) { return a / gcd(a, b) * b; }
inline u64 xorshift() { static u64 x = 88172645463325252ull; x = x ^ (x << 7); return x = x ^ (x >> 9); }
void solve(); int main() { ios::sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(16); solve(); return 0; }
template <typename T> class pqasc : public priority_queue<T, vector<T>, greater<T>> {};
template <typename T> class pqdesc : public priority_queue<T, vector<T>, less<T>> {};
template <typename T> inline void amax(T &x, T y) { if (x < y) x = y; }
template <typename T> inline void amin(T &x, T y) { if (x > y) x = y; }
template <typename T> inline T power(T x, i64 n, T e = 1) { T r = e; while (n > 0) { if (n & 1) r *= x; x *= x; n >>= 1; } return r; }
template <typename T> istream& operator>>(istream &is, vector<T> &v) { each(x, v) is >> x; return is; }
template <typename T> ostream& operator<<(ostream &os, vector<T> &v) { rep(i, v.size()) { if (i) os << ' '; os << v[i]; } return os; }
template <typename T, typename S> istream& operator>>(istream &is, pair<T, S> &p) { is >> p.first >> p.second; return is; }
template <typename T, typename S> ostream& operator<<(ostream &os, pair<T, S> &p) { os << p.first << ' ' << p.second; return os; }
void solve() {
while (true) {
int n, m; cin >> n >> m;
if (n == 0) return;
pqdesc<pair<int, int>> q;
rep(i, n) {
int d, p; cin >> d >> p;
q.emplace(p, d);
}
i64 ans = 0;
while (!q.empty()) {
int p, d;
tie(p, d) = q.top(), q.pop();
if (m >= d) m -= d;
else {
d -= m;
ans += (i64) d * p;
m = 0;
}
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define xrep(i,a,b) for(int i=int(a);i<int(b);++i)
using ll = long long;
int main() {
int N;
cin >> N;
int ans = 0;
xrep(n1, 1, N+1) {
int cnt = 0;
xrep(n2, 1, N+1) {
if(n1%n2==0 && n1%2==1) {
++cnt;
}
}
if(cnt==8) ++ans;
}
cout << ans << endl;
return 0;
}
| 0
| 24,682,171
|
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define ll long long
#define P pair<ll,ll>
#define all(v) (v).begin(),(v).end()
const ll mod = 1e9+7;
const ll INF = 1e18;
const double pi = acos(-1.0);
int main(void)
{
ll q,h,s,d,n; cin>>q>>h>>s>>d>>n;
ll ans = n/2 * min({8*q,4*h,2*s,d});
ans += n%2 * min({4*q,2*h,s});
cout << ans << endl;
return 0;
}
|
#include<iostream>
using namespace std;
int getCost(int arr[], int N, int target){
int cost = 0;
for(int i=0; i<N; i++){
int diff = arr[i]-target;
cost += diff*diff;
}
return cost;
}
int main(){
int N;
cin >> N;
int arr[N];
int min = 200;
int max = -200;
int minCost;
for(int i=0; i<N; i++){
cin >> arr[i];
if(arr[i] < min){
min = arr[i];
}else if(arr[i] > max){
max = arr[i];
}
}
minCost = getCost(arr, N, min);
for(int i=min+1; i<=max; i++){
int cost = getCost(arr, N, i);
if( cost < minCost ){
minCost = cost;
}
}
cout << minCost << '\n';
}
| 0
| 75,966,590
|
#include<bits/stdc++.h>
using namespace std;
class dice{
public:
int d[6];
void rotate(char a){
if(a=='N'){
int top=d[0];
d[0]=d[1];
d[1]=d[5];
d[5]=d[4];
d[4]=top;
}
else if(a=='S'){
int top=d[0];
d[0]=d[4];
d[4]=d[5];
d[5]=d[1];
d[1]=top;
}
else if(a=='E'){
int top=d[0];
d[0]=d[3];
d[3]=d[5];
d[5]=d[2];
d[2]=top;
}
else if(a=='W'){
int top=d[0];
d[0]=d[2];
d[2]=d[5];
d[5]=d[3];
d[3]=top;
}
else if(a=='R'){
rotate('N');
rotate('E');
rotate('S');
}
else if(a=='L'){
rotate('N');
rotate('W');
rotate('S');
}
return;
}
void rotate2(int t,int f){
int i;
for(i=0;i<6;i++) if(d[i]==t) break;
if(i==1) rotate('N');
else if(i==2) rotate('W');
else if(i==3) rotate('E');
else if(i==4) rotate('S');
else if(i==5) rotate('S'),rotate('S');
for(i=1;i<5;i++) if(d[i]==f) break;
if(i==2) rotate('L');
else if(i==3) rotate('R');
else if(i==4) rotate('R'),rotate('R');
return;
}
};
int main(){
dice d;
int q,t,f;
for(int i=0;i<6;i++){
cin>>d.d[i];
}
cin>>q;
for(int j=0;j<q;j++){
cin>>t>>f;
d.rotate2(t,f);
cout<<d.d[2]<<endl;
}
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <queue>
using namespace std;
int r,c,n;
int ans;
char map[1005][1005];
bool book[1005][1005];
int dir[4][2]={{-1,0},{0,-1},{0,1},{1,0}};
struct point
{
int x,y;
int step;
}p[11],now,last;
bool check(int x,int y)
{
if(x<0||x>=r||y<0||y>=c)
return 0;
return 1;
}
void bfs(int st)
{
p[st].step=0;
queue<point> q;
now=p[st];
q.push(now);
book[now.x][now.y]=1;
while(!q.empty())
{
now=q.front();
q.pop();
for(int i=0;i<4;i++)
{
last.x=now.x+dir[i][0];
last.y=now.y+dir[i][1];
last.step=now.step+1;
if(!check(last.x,last.y)) continue;
if(map[last.x][last.y]=='X'|| book[last.x][last.y]==1) continue;
if(last.x==p[st+1].x && last.y==p[st+1].y)
{
ans+=last.step;
return;
}
book[last.x][last.y]=1;
q.push(last);
}
}
}
int main()
{
while(~scanf("%d%d%d",&r,&c,&n))
{
for(int i=0;i<r;i++)
{
getchar();
for(int j=0;j<c;j++)
{
scanf("%c",&map[i][j]);
if(map[i][j]=='S')
{
p[0].x=i;
p[0].y=j;
}
if(map[i][j]!='S'&&map[i][j]!='X'&&map[i][j]!='.')
{
p[map[i][j]-'0'].x=i;
p[map[i][j]-'0'].y=j;
}
}
}
ans=0;
for(int i=0;i<n;i++)
{
memset(book,0,sizeof(book));
bfs(i);
}
cout<<ans<<endl;
}
return 0;
}
| 0
| 27,113,265
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define fix cout << fixed; cout << setprecision(10)
void solve() {
map<string, int> mp;
string a, b;
cin >> a >> b;
int x, y;
cin >> x >> y;
mp[a] = x;
mp[b] = y;
string s;
cin >> s;
mp[s]--;
cout << mp[a] << " " << mp[b] << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
solve();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
#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);
ll m = 0;
cin >> m;
vector<ll> v(1e6 + 5, 0);
ll n = m;
while(n % 2 == 0) {
n = n/2;
v[2]++;
}
for(int i = 3; i < sqrt(m); i+= 2) {
while(n % i == 0) {
n = n /i;
v[i]++;
}
}
ll ans = 0;
for(int i = 0; i < v.size(); i++) {
if(v[i] != 0) {
int temp = 1;
while(v[i] - temp >= 0) {
v[i] -= temp;
temp++;
ans++;
}
}
}
if(n > 2) ans++;
cout << ans << endl;
return 0;
}
| 0
| 39,143,644
|
#include<bits/stdc++.h>
#define ll long long int
#define pb push_back
#define ff first
#define ss second
#define mp make_pair
#define inf 100000000000000000LL
#define fast_io ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)
#define mod 1000000007
using namespace std;
void addEdge(vector<ll> g[],ll x,ll y)
{
g[x].pb(y);
g[y].pb(x);
}
ll dfs(vector<ll> graph[],ll visited[][2],ll val,ll col)
{
if(visited[val][col]==-1)
{
ll s=0;
ll p=1;
for(ll i=0;i<graph[val].size();i++)
{
s=((col==0)?0:dfs(graph,visited,graph[val][i],col))%mod+dfs(graph,visited,graph[val][i],!col)%mod;
s=s%mod;
p=(p%mod*s%mod)%mod;
}
if(graph[val].size()==0)
return 1;
visited[val][col]=p%mod;
return visited[val][col];
}
else
return visited[val][col];
}
void directed(vector<ll> g[],vector<ll> graph[],ll *v,ll val)
{
if(v[val]==-1)
{
v[val]=1;
for(ll i=0;i<g[val].size();i++)
{
if(v[g[val][i]]==-1)
{
graph[val].pb(g[val][i]);
directed(g,graph,v,g[val][i]);
}
}
}
}
int main()
{
ll n,x,y;
cin>>n;
vector<ll> g[n+1];
vector<ll> graph[n+1];
ll visited[n+1][2];
ll v[n+1];
memset(v,-1,sizeof(v));
memset(visited,-1,sizeof(visited));
for(ll i=1;i<n;i++)
{
cin>>x>>y;
addEdge(g,x,y);
}
directed(g,graph,v,1);
ll s1=(dfs(graph,visited,1,0)%mod+dfs(graph,visited,1,1)%mod)%mod;
cout<<s1<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double db;
#define endl '\n'
#define fi first
#define se second
#define pi pair<ll,ll>
#define pii pair<ll,pi>
#define pb push_back
#define mk make_pair
const ll inf = 1e18;
ll n, m, r;
vector<ll>adj[207];
vector<bool>vis(207, false);
vector<ll>v;
vector<vector<ll>>dis(207, vector<ll>(207, inf));
void flyodwarshasll() {
for (ll k = 0; k < n; k++) {
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < n; j++) {
if (dis[i][j] >= dis[i][k] + dis[k][j])
dis[i][j] = dis[i][k] + dis[k][j];
}
}
}
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> r;
for (int i = 0; i < n; i++)dis[i][i] = 0;
for (ll i = 0; i < r; i++) {
ll x;
cin >> x;
--x;
v.pb(x);
}
for (ll i = 0; i < m; i++) {
ll u, v, c;
cin >> u >> v >> c;
--u, --v;
dis[u][v] = c;
dis[v][u] = c;
}
flyodwarshasll();
sort(v.begin(), v.end());
ll nax = 1e18;
do {
ll ans = 0;
for (ll i = 0; i < ll(v.size() - 1); i++) {
ll to = v[i];
ll from = v[i + 1];
ans += dis[to][from];
}
nax = min(ans, nax);
} while (next_permutation(v.begin(), v.end()));
cout << nax << endl;
}
| 0
| 91,304,863
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(){
int a, ans;
cin >> a;
ans = (1 + a) * a / 2;
cout << ans << endl;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
long long N, M, a[100009][3],maxn = -(10000000000);
int main() {
cin >> N >> M;
for (int i = 1; i <= N; i++) {
for (int j = 0; j < 3; j++) cin >> a[i][j];
}
for (int i = 0; i < 8; i++) {
long long b[10000];
for (int j = 1; j <= N; j++) {
long long S = 0;
for (int k = 0; k < 3; k++) {
if ((i / (1 << k)) % 2 == 0)
S += a[j][k];
else S -= a[j][k];
}
b[j] = S;
}
sort(b+1,b+N+1);
long long ans = 0;
for (int j = N; j >= N-M+1; j--)
ans += b[j];
cout<<endl;
maxn = max(maxn, ans);
}
cout << maxn << endl;
return 0;
}
| 0
| 98,635,383
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
const ll MOD=1000000007;
const double PI=3.14159265358979;
const ll INF= pow(10,18);
typedef pair<ll,ll> P;
typedef vector<ll> vl;
typedef vector<vl> vvl;
#define FOR(i,a,b) for(ll i=a;i<b;i++)
#define rep(i,n) FOR(i,0,n)
string abc="abcdefghijklmnopqrstuvwxyz";
string ABC="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
struct edge{ll to,cost;};
int main() {
vl cnt(26,INF);
ll n;
cin >> n;
rep(i,n){
string s;
cin >> s;
rep(i,26){
ll x=0;
rep(j,s.size()){
if(abc[i]==s[j]){
x++;
}
}
cnt[i]=min(cnt[i],x);
}
}
string t="";
rep(i,26){
rep(j,cnt[i]){
t+=abc[i];
}
}
cout << t << endl;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(n); ++i)
using namespace std;
using ll = long long;
void solve(long long H, long long W, long long A, long long B){
rep(i,H-B) {
rep(j,W-A) {
std::cout << 1;
}
rep(j,A) {
std::cout << 0;
}
std::cout << std::endl;
}
rep(i,B) {
rep(j,W-A) std::cout << 0;
rep(j,A) std::cout << 1;
std::cout << std::endl;
}
}
int main(){
long long H;
scanf("%lld",&H);
long long W;
scanf("%lld",&W);
long long A;
scanf("%lld",&A);
long long B;
scanf("%lld",&B);
solve(H, W, A, B);
return 0;
}
| 0
| 57,187,806
|
#define _USE_MATH_DEFINES
#include<math.h>
#include<deque>
#include<queue>
#include<vector>
#include<algorithm>
#include<iostream>
#include<set>
#include<cmath>
#include<tuple>
#include<string>
#include<chrono>
#include<functional>
#include<iterator>
#include<random>
#include<unordered_set>
#include<array>
#include<map>
#include<iomanip>
#include<assert.h>
#include<bitset>
#include<stack>
#include<memory>
using namespace std;
typedef long long ll;
#define rad_to_deg(rad) (((rad)/2/M_PI)*360)
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
#define rep(i,n) for(int i=0;i<n;i++)
#define show(s) cout<<s<<endl
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
#define LINF (1LL << 50)
#define rep1(i,n) for(int i =1;i<=n;i++)
#define rrep(i,n) for(int i=n-1;i>=0;--i)
typedef pair < ll, ll> P;
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcd(ll a, ll b) {
if (b == 0) return a;
return (a / gcd(a, b)) * b;
}
vector<int> divnum(ll num) {
int dig;
vector<int>p;
while (num) {
dig = num % 10;
p.push_back(dig);
num /= 10;
}
return p;
}
int digiter(ll num) {
int dig;
vector<int>p;
while (num) {
dig = num % 10;
p.push_back(dig);
num /= 10;
}
return p.size();
}
vector<int> convertstring(string s) {
vector<int> d;
ll n = s.size();
rep(i, n) {
d.push_back(s[i] - '0');
}
return d;
}
map< ll, int > prime_factor(ll n) {
map< ll, int > ret;
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1) ret[n] = 1;
return ret;
}
vector<ll> divisor(ll n) {
vector<ll>res;
for (ll i = 1; i * i <= n; i++) {
if (n % i != 0)continue;
res.push_back(i);
if (i * i != n)res.push_back(n / i);
}
return res;
}
ll myPow(ll x, ll n, ll m) {
if (n == 0)
return 1;
if (n % 2 == 0)
return myPow(x * x % m, n / 2, m);
else
return x * myPow(x, n - 1, m) % m;
}
std::vector<int> Eratosthenes(const int N)
{
std::vector<bool> is_prime(N + 1);
for (int i = 0; i <= N; i++)
{
is_prime[i] = true;
}
std::vector<int> P;
for (int i = 2; i <= N; i++)
{
if (is_prime[i])
{
for (int j = 2 * i; j <= N; j += i)
{
is_prime[j] = false;
}
P.emplace_back(i);
}
}
return P;
}
#define int long long
const int N = 4e5 + 5;
const int MOD = 1e9 + 7;
int fact[N], invfact[N];
int pow(int a, int b, int m)
{
int ans = 1;
while (b)
{
if (b & 1)
ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
int modinv(int k)
{
return pow(k, MOD - 2, MOD);
}
void precompute()
{
fact[0] = fact[1] = 1;
for (int i = 2; i < N; i++)
{
fact[i] = fact[i - 1] * i;
fact[i] %= MOD;
}
invfact[N - 1] = modinv(fact[N - 1]);
for (int i = N - 2; i >= 0; i--)
{
invfact[i] = invfact[i + 1] * (i + 1);
invfact[i] %= MOD;
}
}
int nCr(int x, int y)
{
if (y > x)
return 0;
int num = fact[x];
num *= invfact[y];
num %= MOD;
num *= invfact[x - y];
num %= MOD;
return num;
}
string S; int K;
int32_t main() {
cin >> S >> K;
precompute();
int t = S.size(); t--;
ll ans = 0;
auto calc=[&](int length, int num,int k) {
if (K == 0&&num==0)return ll(1);
if (K == 0)return 1LL;
ll res = 0;
rep(head, num) {
if (head == 0) {
res += nCr(length, k) * pow(9, k);
}else res += nCr(length, k-1)*pow(9,k-1);
}
return res;
};
rep(i, S.size()) {
ans += calc(t - i, S[i] - '0', K);
if (K == 0)break;
if (S[i]-'0' != 0)K--;
if (i == S.size() - 1 && K == 0&&S[i]-'0'!=0) {
ans += 1;
}
}
cout << ans << endl;
}
|
#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<string>
#include<vector>
#include<cctype>
using namespace std;
class Saikoro{
private:
int rab[6];
public:
void setrab(int rabs[6]);
void getrab();
int gettop();
void N();
void E();
void S();
void W();
int getR(int ue,int mae);
};
void Saikoro::setrab(int rabs[6]){
for(int i=0;i<6;i++)rab[i]=rabs[i];
}
void Saikoro::getrab(){
for(int i=0;i<6;i++)cout<<rab[i]<<endl;
}
void Saikoro::N(){
int a;
a=rab[0];rab[0]=rab[1];rab[1]=rab[5];rab[5]=rab[4];rab[4]=a;
}
void Saikoro::E(){
int a;
a=rab[0];rab[0]=rab[3];rab[3]=rab[5];rab[5]=rab[2];rab[2]=a;
}
void Saikoro::S(){
int a;
a=rab[0];rab[0]=rab[4];rab[4]=rab[5];rab[5]=rab[1];rab[1]=a;
}
void Saikoro:: W(){
int a;
a=rab[0];rab[0]=rab[2];rab[2]=rab[5];rab[5]=rab[3];rab[3]=a;
}
int Saikoro::gettop(){
return rab[0];
}
int Saikoro::getR(int ue,int mae){
if(ue==rab[0]){
if(mae==rab[1])return rab[2];
if(mae==rab[2])return rab[4];
if(mae==rab[4])return rab[3];
if(mae==rab[3])return rab[1];
}
if(ue==rab[1]){
if(mae==rab[5])return rab[2];
if(mae==rab[2])return rab[0];
if(mae==rab[0])return rab[3];
if(mae==rab[3])return rab[5];
}
if(ue==rab[2]){
if(mae==rab[4])return rab[0];
if(mae==rab[0])return rab[1];
if(mae==rab[1])return rab[5];
if(mae==rab[5])return rab[4];
}
if(ue==rab[3]){
if(mae==rab[0])return rab[4];
if(mae==rab[4])return rab[5];
if(mae==rab[5])return rab[1];
if(mae==rab[1])return rab[0];
}
if(ue==rab[4]){
if(mae==rab[0])return rab[2];
if(mae==rab[2])return rab[5];
if(mae==rab[5])return rab[3];
if(mae==rab[3])return rab[0];
}
if(ue==rab[5]){
if(mae==rab[1])return rab[3];
if(mae==rab[3])return rab[4];
if(mae==rab[4])return rab[2];
if(mae==rab[2])return rab[1];
}
}
int main(){
int a[6];
for(int i=0;i<6;i++)cin>>a[i];
Saikoro saikoro1;
saikoro1.setrab(a);
int n;
cin>>n;
for(int i=0;i<n;i++){
int ue,mae;
cin>>ue>>mae;
cout<<saikoro1.getR(ue,mae)<<endl;
}
return 0;
}
| 0
| 1,598,904
|
#include <stdio.h>
#include <math.h>
int main(){
double x1,x2,y1,y2,r;
scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
r=hypot((x2-x1),(y2-y1));
printf("%f",r);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
typedef pair<int, int> P;
ll Mod = 1000000007;
int main() {
int N,K;
string S;
cin >> N >> K >> S;
vector<int> R(0);
for (int i = 0; i < 100000; i++) {
R.push_back(0);
}
if (S[0] == '0') {
R.push_back(0);
}
int cnt = 1;
for (int i = 1; i < N; i++) {
if (S[i - 1] == S[i]) {
cnt++;
} else {
R.push_back(cnt);
cnt = 1;
}
}
R.push_back(cnt);
for (int i = 0; i < 100000; i++) {
R.push_back(0);
}
int Rs = R.size();
int A[Rs+1];
A[0] = 0;
for (int i = 0; i < Rs; i++) {
A[i+1] = A[i] + R[i];
}
int ans = -1;
for (int i = 0; i < Rs-2*K+1; i+=2) {
ans = max(ans,A[i+2*K+1]-A[i]);
}
cout << ans << endl;
return 0;
}
| 0
| 94,030,796
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int a, b, c;
cin >> a >> b >> c;
if(b >= c) cout << "delicious";
else if(a + b < c) cout << "dangerous";
else cout << "safe";
}
|
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
#define PI acos(-1)
typedef long long ll;
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;
}
using namespace std;
int main(){
ll n,t;
cin>>n>>t;
vector<ll> a(n,0);
rep(i,n){
cin>>a[i];
}
ll ans=0;
ll now=0;
rep(i,n-1){
ll x=min(t,(a[i+1]-now));
ans+=x;
if(x==t) now=a[i+1];
else now+=x;
}
ans+=t;
cout<<ans;
return 0;
}
| 0
| 90,695,595
|
#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()
{
int a[3];
rep(i,3){
cin >> a[i];
}
sort(a, a + 3);
cout << (a[2] - a[1]) + (a[1] - a[0]) << endl;
return 0;
}
|
#pragma region template
#include "bits/stdc++.h"
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const long long MOD = 1e9 + 7, MAX = LLONG_MAX, larg = 1e5, INF = -1e9;
long long A, B, C, D, E, F, G, H, I, J, K, L, N, M, O, P, Q, R, S, T, U, V, W;
typedef long long ll;
typedef pair<ll, ll> Pa;
ll arr[50];
ll maxv = 0, max_index = -1;
bool array_check() {
bool flag = true;
maxv = 0;
rep(i, N) {
flag &= (arr[i] < N);
if (maxv < arr[i]) {
maxv = arr[i];
max_index = i;
}
}
return flag;
}
int main() {
cin >> N;
ll sum = 0;
rep(i, N) {
cin >> arr[i];
sum += arr[i]/N;
}
ll cnt = 0;
while (!array_check()) {
rep(i, N){
ll tmp = arr[i];
arr[i] -= (tmp/N)*N;
arr[i] += (sum - tmp/N);
cnt += tmp/N;
}
sum = 0;
rep(i, N){
sum += arr[i]/N;
}
}
cout << cnt;
}
| 0
| 46,299,685
|
#include <iostream>
using namespace std;
void ABC90(void);
void ABC91(void);
void ABC92(void);
void ABC93(void);
void ABC94(void);
void ABC95(void);
void ABC96(void);
void ABC97(void);
void ABC98(void);
void ABC99(void);
int main(void){
ABC94();
}
void ABC94(){
int a,b,x;
cin>>a>>b>>x;
if(x<a)cout<<"NO"<<endl;
else if(x<=a+b)cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<vector<int>> v(100010);
bool used[100010];
int dfs(int p){
used[p] = true;
int x = 0;
for(auto i:v[p]){
if(!used[i]){
x ^= dfs(i) + 1;
}
}
return x;
}
signed main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
int n;
cin>>n;
for(int i=1;i<n;i++){
int a,b; cin>>a>>b;
a--,b--;
v[a].push_back(b);
v[b].push_back(a);
}
ll ans = dfs(0);
if(ans){
cout << "Alice" << endl;
}
else cout << "Bob" << endl;
}
| 0
| 98,127,938
|
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <string.h>
using namespace std;
#define ISEQ(c) (c).begin(), (c).end()
typedef long long ll;
int main() {
vector<int> a(5);
for (int i = 0; i < 5; i++) {
scanf("%d", &a[i]);
}
sort(a.rbegin(), a.rend());
for (int i = 0; i < 4; i++) {
printf("%d ", a[i]);
}
printf("%d\n", a[4]);
}
|
#include<bits/stdc++.h>
#define rep(i,m) for(long long i=0; i<m; i++)
#define per(i,m) for(long long i=m-1; i>=0; i--)
#define FOR(i,n,m) for(long long i=n; i<m; i++)
#define ROF(i,n,m) for(long long i=m-1; i>=n; i--)
#define SORT(v,n) do{sort(v,v+n);reverse(v,v+n);}while(0)
#define all(x) (x).begin(),(x).end()
#define MP make_pair
#define MT make_tuple
#define EPS (1e-7)
#define INF (1e18)
#define PI (acos(-1))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
using namespace std;
typedef long long ll;
const ll MOD = 1000000007;
typedef pair<int,int> P;
typedef pair<ll,ll> LP;
ll POW(ll x,ll n){
x%=MOD;
if(n==0)return 1;
if(n%2==0)return POW(x*x,n/2)%MOD;
return x%MOD*POW(x,n-1)%MOD;
}
ll POW2(ll x,ll n){
if(n==0)return 1;
if(n%2==0)return POW2(x*x,n/2);
return x*POW2(x,n-1);
}
ll POW3(ll x,ll n,ll m){
x%=m;
if(n==0)return 1;
if(n%2==0)return POW3(x*x,n/2,m)%m;
return x*POW3(x,n-1,m)%m;
}
ll gcd(ll u, ll v) {
ll r;
while (0 != v) {
r = u % v; u = v; v = r;
}
return u;
}
ll lcm(ll u, ll v) {
return u/gcd(u,v)*v;
}
ll KAI(ll m)
{
if(m<0) return 0;
if(m==0) return 1;
return m*KAI(m-1)%MOD;
}
ll KAI2(ll m)
{
if(m<0) return 0;
if(m==0) return 1;
return m*KAI2(m-1);
}
ll extGCD(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
ll d = extGCD(b, a%b, y, x);
y -= a / b * x;
return d;
}
inline ll mod(ll a, ll m) {
return (a % m + m) % m;
}
ll modinv(ll a) {
ll x, y;
extGCD(a, MOD, x, y);
return mod(x, MOD);
}
ll COM(ll m,ll n)
{
if(m<n) return 0;
if(n<0) return 0;
if(n==0) return 1;
if(m==n) return 1;
return KAI(m)%MOD*modinv(KAI(n)%MOD*KAI(m-n)%MOD)%MOD;
}
ll COM2(ll m,ll n)
{
if(m<n) return 0;
if(n<0) return 0;
if(n==0) return 1;
if(m==n) return 1;
return KAI2(m)/KAI2(n)/KAI2(m-n);
}
ll DEC(ll x,ll m,ll n)
{
return x%POW2(m,n+1)/POW2(m,n);
}
ll keta(ll x,ll n)
{
if(x==0)return 0;
return keta(x/n,n)+1;
}
ll DIV(ll x,ll n)
{
if(x==0)return 0;
return x/n+DIV(x/n,n);
}
ll ORD(ll x,ll n)
{
if(x==0)return INF;
if(x%n!=0)return 0;
return 1+ORD(x/n,n);
}
ll SUP(ll x,ll n)
{
if(x==0)return 0;
if(x%n!=0)return x;
return SUP(x/n,n);
}
ll SGS(ll x,ll y, ll m)
{
if(y==0)return 0;
if(y%2==0){
return (1+POW3(x,y/2,m))*SGS(x,y/2,m)%m;
}
return (1+x*SGS(x,y-1,m))%m;
}
ll SSGS(ll x,ll y,ll m)
{
if(y==0)return 0;
if(y==1)return 1;
if(y%2==0){
return (SSGS(x,y/2,m)*(POW3(x,y/2,m)+1)%m+SGS(x,y/2,m)*y/2%m)%m;
}
return (SSGS(x,y-1,m)*x%m+y)%m;
}
void shuffle(ll array[], ll size) {
for(ll i = 0; i < size; i++) {
ll j = rand()%size;
ll t = array[i];
array[i] = array[j];
array[j] = t;
}
}
ll SQRT(ll n){
ll ok,ng,mid;
ng=n+1;
if(303700500<ng)ng=303700500;
ok=0;
while(abs(ok-ng)>1){
mid=(ok+ng)/2;
if(mid*mid<=n){
ok=mid;
}
else{
ng=mid;
}
}
return ok;
}
struct UnionFind
{
vector<int> par;
vector<int> sizes;
UnionFind(int n) : par(n), sizes(n, 1) {
rep(i,n) par[i] = i;
}
int find(int x) {
if (x == par[x]) return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (sizes[x] < sizes[y]) swap(x, y);
par[y] = x;
sizes[x] += sizes[y];
}
bool same(int x, int y) {
return find(x) == find(y);
}
int size(int x) {
return sizes[find(x)];
}
};
map< int64_t, int > prime_factor(int64_t n) {
map< int64_t, int > ret;
for(int64_t i = 2; i * i <= n; i++) {
while(n % i == 0) {
ret[i]++;
n /= i;
}
}
if(n != 1) ret[n] = 1;
return ret;
}
bool is_prime(int64_t x) {
if(x==1)return false;
for(int64_t i = 2; i * i <= x; i++) {
if(x % i == 0) return false;
}
return true;
}
struct edge{ll to, cost;};
struct graph{
ll V;
vector<vector<edge> > G;
vector<ll> d;
graph(ll n){
init(n);
}
void init(ll n){
V = n;
G.resize(V);
d.resize(V);
rep(i,V){
d[i] = INF;
}
}
void add_edge(ll s, ll t, ll cost){
edge e;
e.to = t, e.cost = cost;
G[s].push_back(e);
}
void dijkstra(ll s){
rep(i,V){
d[i] = INF;
}
d[s] = 0;
priority_queue<LP,vector<LP>, greater<LP> > que;
que.push(LP(0,s));
while(!que.empty()){
LP p = que.top(); que.pop();
ll v = p.second;
if(d[v]<p.first) continue;
for(auto e : G[v]){
if(d[e.to]>d[v]+e.cost){
d[e.to] = d[v]+e.cost;
que.push(LP(d[e.to],e.to));
}
}
}
}
};
ll d[300][300];
void warshall_floyd(ll n){
rep(i,n)rep(j,n)rep(k,n)d[j][k]=min(d[j][k],d[j][i]+d[i][k]);
}
struct bit{
ll m;
vector<ll> b;
bit(ll i){
m=i;
b.resize(m+1);
}
ll num(ll i){
return b[i];
}
ll sum(ll i){
ll s=0;
while(i>0){
s+=b[i];
i-=i&-i;
}
return s;
}
void add(ll i, ll x){
while(i<=m){
b[i]+=x;
i+=i&-i;
}
}
};
int main(){
ll n,k,h[310]={},dp[310][1000][3],o=0;
cin >> n >> k;
rep(i,n)cin >> h[i+1];
rep(i,n+1)rep(j,k+1)rep(l,2)dp[i][j][l]=INF;
dp[0][0][1]=0;
rep(i,n){
rep(j,k+1){
rep(l,i+1)dp[i+1][j+i+1-l][0]=min(dp[l][j][1],dp[i+1][j+i+1-l][0]);
rep(l,i+1){
dp[i+1][j+i-l][1]=min(dp[l][j][1]+max(h[i+1]-h[l],o),dp[i+1][j+i-l][1]);
}
}
}
printf("%lld",min(dp[n][k][0],dp[n][k][1]));
}
| 0
| 8,579,307
|
#include <bits/stdc++.h>
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define INF 2e9
#define MOD 1000000007
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
using P = pair<int,int>;
int main()
{
int H,W;
cin >> H >> W;
vector<string> A(H);
REP(i, H) cin >> A[i];
vector<vector<int>> ans(H,vector<int> (W,0));
REP(i,H){
vector<int> X;
int cnt = 0;
REP(j,W){
if(A.at(i).at(j)=='.'){
cnt++;
}else{
X.push_back(cnt);
cnt=0;
}
}
X.push_back(cnt);
int cnt2 = 0;
REP(j,W){
if(A.at(i).at(j)=='#'){
cnt2++;
}else{
ans.at(i).at(j)+=X.at(cnt2);
}
}
}
REP(i,W){
vector<int> X;
int cnt = 0;
REP(j,H){
if(A.at(j).at(i)=='.'){
cnt++;
}else{
X.push_back(cnt);
cnt=0;
}
}
X.push_back(cnt);
int cnt2 = 0;
REP(j,H){
if(A.at(j).at(i)=='#'){
cnt2++;
}else{
ans.at(j).at(i)+=X.at(cnt2);
}
}
}
int MAX=0;
REP(i,H){
REP(j,W){
MAX=max(MAX,ans.at(i).at(j));
}
}
cout << MAX-1 << endl;
}
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
#define mx 100009
ll ar[mx][3];
ll mem[mx][3];
ll n;
ll dp(ll ind,ll f){
if(ind>=n) return 0;
else if(mem[ind][f]!=-1) return mem[ind][f];
ll ans=0;
if(f==0){
ll x=ar[ind+1][1]+dp(ind+1,1);
ll y=ar[ind+1][2]+dp(ind+1,2);
ans=max(x,y);
}
else if(f==1){
ll x=ar[ind+1][0]+dp(ind+1,0);
ll y=ar[ind+1][2]+dp(ind+1,2);
ans=max(x,y);
}
else{
ll x=ar[ind+1][1]+dp(ind+1,1);
ll y=ar[ind+1][0]+dp(ind+1,0);
ans=max(x,y);
}
return mem[ind][f]=ans;
}
int main()
{
memset(mem,-1,sizeof(mem));
cin>>n;
for(ll i=1;i<=n;i++){
cin>>ar[i][0]>>ar[i][1]>>ar[i][2];
}
ll a=ar[1][0]+dp(1,0);
ll b=ar[1][1]+dp(1,1);
ll c=ar[1][2]+dp(1,2);
cout<<max(a,max(b,c))<<endl;
return 0;
}
| 0
| 12,429,598
|
#include<iostream>
int main(){
int W, H, x, y, r;
std::cin >> W >> H >> x >> y >> r;
if (r>x||x+r>W||r>y||y+r>H){
std::cout << "No" << std::endl;
}
else {
std::cout << "Yes" << std::endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int hs(string);
int matoi(char);
int main(){
int nma=1;
for(int i=0;i<12;i++){
nma*=4;
}
vector<int> a(nma+5,0);
int n;
cin >> n;
for(int i=0;i<n;i++){
string fu;
string st;
cin >> fu >> st;
int h=hs(st);
if(fu=="insert"){
a[h]=1;
}
else{
if(a[h])cout << "yes" << endl;
else cout << "no" << endl;
}
}
return 0;
}
int hs(string st){
int re=0;
for(int i=st.size()-1;i>=0;i--){
re*=4;
int a=matoi(st[i]);
re+=a;
}
return re;
}
int matoi(char ch){
if(ch=='A')return 1;
if(ch=='C')return 2;
if(ch=='G')return 3;
return 4;
}
| 0
| 20,735,594
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n,m,v,p,a[200001];
bool ok(int poz)
{
ll nr=a[poz]+m;
ll nrop=m*(v-1);
ll nrmari=0;
for(int i=1;i<=n;i++)
if(a[i]>nr&&i!=poz)
{
nrop-=m;
nrmari++;
}
for(int i=1;i<=n;i++)
if(a[i]<=nr&&i!=poz)
{
ll dif=nr-a[i];
nrop-=min(dif,m);
}
for(int i=n;i>=1&&nrmari<p-1;i--)
{
if(i!=poz)
{
ll dif=nr-a[i];
if(dif<=m&&dif>=0)
{
nrop-=(m-dif);
nrmari++;
}
}
}
if(nrmari<=p-1&&nrop<=0)
return 1;
return 0;
}
int main()
{
cin>>n>>m>>v>>p;
for(int i=1;i<=n;i++)
cin>>a[i];
sort(a+1,a+n+1);
int st=1;
int dr=n;
int pozmin=n+1;
while(st<=dr)
{
int mij=(st+dr)/2;
if(ok(mij))
{
if(mij<pozmin)
pozmin=mij;
dr=mij-1;
}
else
st=mij+1;
}
cout<<n-pozmin+1;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int V; cin >> V;
vector<vector<int> > adjlist(V);
for(int i = 0; i < V; i++){
int gomi; cin >> gomi;
int k; cin >> k;
for(int j = 0; j < k; j++){
int a; cin >> a;
adjlist[i].push_back(a - 1);
}
}
vector<vector<int> > array(V, vector<int> (V, 0));
for(int i = 0; i < V; i++){
for(int j = 0; j < adjlist[i].size(); j++){
array[i][adjlist[i][j]] = 1;
}
}
for(int i = 0; i < V; i++){
for(int j = 0; j < V; j++){
if(j == V - 1) cout << array[i][j] << endl;
else cout << array[i][j] << " ";
}
}
return 0;
}
| 0
| 89,903,542
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(void)
{
int N, M, a, b, ans = 0;
queue<vector<int> > que;
cin >> N >> M;
vector<int> tmp, path;
vector<vector<int>> edge(N, tmp);
rep(i, M) {
cin >> a >> b;
a--; b--;
edge[a].push_back(b);
edge[b].push_back(a);
}
rep(i, edge.size()) {
sort(edge[i].begin(), edge[i].end());
}
tmp.clear();
tmp.push_back(0);
que.push(tmp);
while (!que.empty()) {
tmp = que.front();
que.pop();
if (tmp.size() >= N) {
ans++;
continue;
}
int node = tmp[tmp.size() - 1];
rep(i, edge[node].size()) {
if (find(tmp.begin(), tmp.end(), edge[node][i]) == tmp.end()) {
path = tmp;
path.push_back(edge[node][i]);
que.push(path);
}
}
}
cout << ans << endl;
return 0;
}
|
#pragma region header
#include <bits/stdc++.h>
#define int long long
#define ll long long
#define ld long double
#define vi vector<int>
#define vvi vector<vector<int>>
#define vvvi vector<vector<vector<int>>>
#define all(a) begin(a), end(a)
#define rall(a) rbegin(a), rend(a)
#define SORT(a) stable_sort(all(a))
#define RSORT(a) stable_sort(rall(a))
#define rev(a) reverse(all(a))
#define uniq(a) a.erase(unique(all(a)), end(a))
#define lambda(i) [=](auto i)
#define compare(i, j) [=](auto i, auto j)
#define min_of(a) *min_element(all(a))
#define max_of(a) *max_element(all(a))
#define sum(a) accumulate(all(a), 0)
#define count_of(a, i) count(all(a), i)
#define lower(a, i) (lower_bound(all(a), i) - begin(a))
#define upper(a, i) (upper_bound(all(a), i) - begin(a))
#define binary(a, i) binary_search(all(a), i)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define sz(a) (int)(a).size()
#define rep1(i, n) for (decltype(+n) i = 0; i < (n); i++)
#define rrep1(i, n) for (auto i = n - 1; i != static_cast<decltype(i)>(-1); i--)
#define rep2(i, a, b) for (auto i = (a); i < (b); i++)
#define rrep2(i, a, b) for (auto i = b - 1; i >= a; i--)
#define GET_MACRO(_1, _2, _3, NAME, ...) NAME
#define rep(...) GET_MACRO(__VA_ARGS__, rep2, rep1) (__VA_ARGS__)
#define rrep(...) GET_MACRO(__VA_ARGS__, rrep2, rrep1) (__VA_ARGS__)
#define each(i, a) for (auto &&i : (a))
using namespace std;
const int INF = 1e18;
const int MOD = 1e9 + 7;
int mod_add(int A, int B) { return (A + B) % MOD; }
int mod_sub(int A, int B) { return (A + MOD - B) % MOD; }
int mod_mul(int A, int B) { return ((A % MOD) * (B % MOD)) % MOD; }
int mod_bipow(int X, int Y) {
if (Y == 0) return 1;
else if (Y == 1) return X % MOD;
else if (Y % 2 == 0) {
int Z = mod_bipow(X, (int)(Y / 2));
return mod_mul(Z, Z);
} else {
int Z = mod_bipow(X, (int)(Y / 2));
return mod_mul(mod_mul(Z, Z), X);
}
}
int mod_inv(int X) { return mod_bipow(X, MOD - 2); }
int mod_div(int A, int B) { return mod_mul(A, mod_inv(B)); }
template <class T>
bool amin(T &A, T B) {
if (A > B) {
A = B;
return true;
}
return false;
}
template <class T>
bool amax(T &A, T B) {
if (A < B) {
A = B;
return true;
}
return false;
}
vi divisors(int N) {
vi 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(ret);
return ret;
}
map<int, int> prime_factors(int N) {
map<int, int> ret;
for (int i = 2; i * i <= N; i++) {
while (N % i == 0) {
ret[i]++;
N /= i;
}
}
if (N != 1) ret[N]++;
return ret;
}
int ceil_div(int X, int Y) { return (X - 1) / Y + 1; }
vi cum(vi V) {
vi U(sz(V));
partial_sum(all(V), begin(U));
return U;
}
struct union_find {
vi data;
union_find(int size) : data(size, -1) {}
bool union_set(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
return x != y;
}
bool find_set(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
};
struct vertex {
vector<int> adj = vi(0);
};
#pragma endregion header
void solve(int n, int x){
vi c(n + 1);
c[0] = 1;
rep(i, n)c[i + 1] = c[i] * 2 + 3;
int ans = 0;
int l = n - 1, d = x;
while(true){
if(l == -1) {
ans += min(1ll, max(0ll, d));
break;
}
if(d >= c[l] + 1 && d <= c[l] + 3) {
if(d >= c[l] + 2)ans++;
if(l == 0 && d == c[l] + 3)ans++;
ans += c[l] / 2 + 1;
break;
} else if(d > c[l] + 3) {
ans += c[l] / 2 + 2;
d -= c[l] + 2;
} else {
d--;
}
l--;
}
cout << ans << endl;
}
#pragma region main
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
int n;
cin >> n;
int x;
cin >> x;
solve(n, x);
}
#pragma endregion main
| 0
| 93,228,092
|
#include <iostream>
using namespace std;
int main() {
int a,b,c,d,count;
count = 0;
int num[100];
int max;
int n;
for (int v=0;v<100;v++) {
num[v] = 100;
cin >> num[v];
if (!(0<=num[v]&&num[v]<=50)){
max = v-1;
break;
}
}
for (int w=0;w<=max;w++){
n=num[w];
count = 0;
for (int i=0;i<=9;i++) {
a=i;
if (n-a<0) {
break;
}
for (int j=0;j<=n-a&&j<=9;j++) {
b=j;
if (n-a-b < 0) {
break;
}
for (int k=0;k<=n-a-b&&k<=9;k++) {
c=k;
if (n-a-b-c < 0) {
break;
}
for (int l=0;l<=n-a-b-c&&l<=9;l++) {
d=l;
if (n==a+b+c+d) {
count++;
}
if (n-a-b-c-d < 0) {
break;
}
}
}
}
}
cout << count <<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
string S;
cin >> S;
int flag = 0;
bool ans = false;
if(S.at(0) == 'A'){
S.at(0) = 'a';
for(int i=2; i<(int)S.size()-1; i++){
if(S.at(i) == 'C'){
S.at(i) = 'c';
flag += 1;
}
}
if(flag == 1){
for(int j=0; j<(int)S.size(); j++){
if(islower(S.at(j))){
ans = true;
}else{
ans = false;
break;
}
}
}
}
if(ans == true){
cout << "AC" << endl;
}else{
cout << "WA" << endl;
}
}
| 0
| 76,368,710
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i< (n);i++)
using namespace std;
int main() {
int a;
cin>>a;
if(a<1200)cout<<"ABC"<<endl;
else if(a<2800)cout<<"ARC"<<endl;
else if(a>=2800)cout<<"AGC"<<endl;
}
|
#include<cstdio>
#include<cstdlib>
#include<vector>
using namespace std;
const int N=100100;
vector<int>g[N];
int main()
{
int n,k=0;
int cnt=1;
scanf("%d",&n);
if(n==1)return printf("Yes\n2\n1 1\n1 1"),0;
for(int i=1;i<=n;i++)
{
if(i*(i-1)/2==n)
{
k=i;
break;
}
}
if(k==0)return printf("No\n"),0;
printf("Yes\n%d\n",k);
for(int i=1;i<=k;i++)
{
if(cnt>n)break;
for(int j=i+1;j<=k;j++)
{
if(cnt>n)break;
g[i].push_back(cnt);
g[j].push_back(cnt);
cnt++;
}
}
for(int i=1;i<=k;i++)
{
printf("%d ",g[i].size());
for(int j=0;j<g[i].size();j++)
printf("%d ",g[i][j]);
printf("\n");
}
return 0;
}
| 0
| 62,769,657
|
#include <bits/stdc++.h>
#define rep(i, f, n) for (ll i = (f); i < (ll)(n); i++)
#define repe(i, f, n) for (ll i = (f); i <= (ll)(n); i++)
using namespace std;
using ll = long long;
using pint = pair<int, int>;
bool is_war(const vector<int>& x, const vector<int>& y) {
return *max_element(x.begin(), x.end()) >= *min_element(y.begin(), y.end());
}
int main() {
int N, M;
cin >> N >> M;
vector<int> x(N + 1), y(M + 1);
cin >> x[0] >> y[0];
rep(i, 0, N) cin >> x[i + 1];
rep(i, 0, M) cin >> y[i + 1];
if (is_war(x, y))
cout << "War" << endl;
else
cout << "No War" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int64;
typedef vector<int> vec;
typedef vector<int64> vec64;
#define db(x) cout << "> " << #x << ": " << x << "\n";
#define ss cout << " ";
#define ct(x) cout << x;
#define nn cout << "\n";
#define cts(x) cout << x << " ";
#define ctn(x) cout << x << "\n";
#define qr queries();
void solve();
void YN(bool b){if (b){ctn("YES");}else{ctn ("NO");}};
void yn(bool b){if (b){ctn("Yes");}else{ctn ("No");}};
void queries(){int n;cin >> n;while (n--)solve();}
int64 q, n;
void solve(){
return;
}
int main(){
ios_base::sync_with_stdio(0);cin.tie(0);
int n;
cin >> n;
vec arr (n);
for (int i = 0; i < n; i++){
cin >> arr[i];
}
int64 tovisit = 1;
int64 rs = 0;
bool one = 0;
int last = 0;
for (int i = 0; i < n; i++){
if (arr[i] == 1){
one = 1;
}
if (arr[i] != tovisit){
last++;
}
else{
tovisit++;
rs+=last;
last = 0;
}
}
rs+=last;
if (!one){
ctn(-1);
return 0;
}
ctn(rs);
return 0;
}
| 0
| 13,552,011
|
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <functional>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
string s, ans;
cin >> s;
int n = s.length(), i, j, k;
if (n < 26) {
set<char> ss;
char ch;
for (auto ch : s) ss.insert(ch);
for (ch = 'a'; ch <= 'z'; ch++) {
if (ss.find(ch) == ss.end()) {
ans = s + ch;
break;
}
}
}
else {
ans = s;
if (!next_permutation(ans.begin(), ans.end())) ans = "-1";
else {
set<char> ss;
for (i = n - 1; i >= 0; i--) {
for (auto ch : ss) {
if (ch > s[i]) {
ans = s.substr(0, i) + ch;
goto outer;
}
}
ss.insert(s[i]);
}
outer:;
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef tuple<int,int,int> tii;
#define rep(i,s,n) for(int i=(int)(s);i<(int)(n);i++)
ll mod = 1e9+7;
ll calc(ll a,ll p,ll m){
if(p==0) return 1;
if(p%2==0){
ll d = calc(a,p/2,m);
return d*d%m;
}else{
return a*calc(a,p-1,m)%m;
}
}
ll comb(ll n,ll k){
if(n<k||k<0) return 0;
ll sum = 1;
ll a = 1;
for(int i=0;i<k;i++){
sum *= n-i;
sum %= mod;
a *= i+1;
a %= mod;
}
ll res = sum*calc(a,mod-2,mod)%mod;
return res;
}
int main(){
ll x,y; cin >> x >> y;
ll r = (x+y)%3;
if(r!=0){
cout << 0 << endl;
return 0;
}
ll n = (x+y)/3;
ll k = x - n;
ll ans = comb(n,k)%mod;
cout << ans << endl;
}
| 0
| 6,399,160
|
#include<bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
int n, m; cin >> n >> m;
int ng[100100] = {};
for (int i = 0; i < m; i++)
{
int a; cin >> a;
ng[a] = 1;
}
int res[100100];
if(ng[1]) {
res[1] = 0;
if(ng[2]) res[2] = 0;
else res[2] = 1;
}
else {
res[1] = 1;
if(ng[2]) res[2] = 0;
else res[2] = 2;
}
for (int i = 3; i <= n; i++)
{
if(ng[i]) res[i] = 0;
else res[i] = (res[i-1] + res[i-2]) % MOD;
}
cout << res[n] << endl;
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
#include <queue>
#include <map>
#include <set>
#include <cstring>
#include <cstdlib>
#include <string>
#include <cmath>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
const int INF = 1<<29;
int main() {
int n,a,b,c,x;
while(cin>>n>>a>>b>>c>>x,n) {
int h[n];
REP(i,n) {
cin >> h[i];
}
int cnt =0;
bool f[n];
memset(f,0,sizeof(f));
int i=0;
for (i=0;i<=10000;++i) {
if (h[cnt]==x) {
cnt++;
}
if (cnt==n)
break;
x = (a*x+b)%c;
}
if (cnt==n) {
cout << i << endl;
}else
cout << -1 << endl;
}
}
| 0
| 4,445,994
|
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<string>
using namespace std;
const int MAX_N = int(1e6) + 10;
const long long int MOD=1e15;
const long long int INF=1e18;
typedef long long int ll;
typedef unsigned long long int llu;
inline ll mul(ll a,ll b){
a=(a+MOD)%MOD;
b=(b+MOD)%MOD;
ll c=a*b;
c=(c+MOD)%MOD;
return c;
}
inline ll add(ll a,ll b){
a=(a+MOD)%MOD;
b=(b+MOD)%MOD;
ll ans=(a+b);
ans=(ans+MOD)%MOD;
return ans;
}
ll power(ll a,ll b,ll c){
ll ans=1;
while(b){
if(b&1){
ans=mul(ans,a);
}
a=mul(a,a);
b=b/2;
}
return ans;
}
ll power2(ll a,ll b){
ll ans=1;
while(b){
if(b&1){
ans=ans*a;
}
a=a*a;
b=b/2;
}
return ans;
}
template<class T1, class T2>
istream &operator>>(istream &in, pair<T1, T2> &P){
in >> P.first >> P.second;
return in;
}
template<class T1, class T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &P){
out << "(" << P.first << ", " << P.second << ")";
return out;
}
template<class T>
istream &operator>>(istream &in, vector<T> &arr){
for(auto &x: arr) in >> x;
return in;
}
template<class T>
ostream &operator<<(ostream &out, const vector<T> &arr){
for(auto &x: arr) out << x << ' '; cout << "\n";
return out;
}
template<class T>
istream &operator>>(istream &in, deque<T> &arr){
for(auto &x: arr) in >> x;
return in;
}
template<class T>
ostream &operator<<(ostream &out, const deque<T> &arr){
for(auto &x: arr) out << x << ' '; cout << "\n";
return out;
}
mt19937 rnd(time(0));
inline ll gcd(ll a,ll b){
while(b)a%=b,swap(a,b);
return a;
}
struct SOS{
ll *dp;
int limit;
vector<int>&arr;
SOS(int _limit,vector<int>&v):arr(v){
limit=_limit;
dp=new ll[(1<<limit)+10];
}
void init(){
for(int i=0;i<(1<<limit);i++){
dp[i]=0;
}
for(int i=0;i<arr.size();i++){
dp[arr[i]]++;
}
}
void build1(){
for(int i=0;i<limit;i++){
for(int j=0;j<(1<<limit);j++){
if(j&(1<<i)){
dp[j]=add(dp[j],dp[j^(1<<i)]);
}
}
}
}
void build2(){
for(int i=0;i<limit;i++){
for(int j=(1<<limit)-1;j>=0;j--){
if(j&(1<<i)){
dp[j^(1<<i)]=add(dp[j^(1<<i)],dp[j]);
}
}
}
}
};
int find(int arr[],int x)
{
while(x!=arr[x])
{
x=arr[x];
}
return x;
}
void connect(int x,int arr[],int size[],int comp[],int y)
{
int rootA=find(arr,x);
int rootB=find(arr,y);
if(rootA==rootB)return;
if(size[rootA]<size[rootB])
{
arr[rootA]=rootB;
size[rootB]+=size[rootA];
comp[rootB]=min(comp[rootA],comp[rootB]);
}else{
arr[rootB]=rootA;
size[rootA]+=size[rootB];
comp[rootA]=min(comp[rootA],comp[rootB]);
}
}
const int N=2e5+5;
int tree[1000005];
void update(int x,int v){
while(x<1000005){
tree[x]+=v;
x+=x&(-x);
}
}
int query(int x){
int ans=0;
while(x){
ans+=tree[x];
x-=x&(-x);
}
return ans;
}
void combine(int x,int y,int arr[],int size[])
{
int rootA=find(arr,x);
int rootB=find(arr,y);
if(rootA==rootB)return;
if(size[rootA]<size[rootB])
{
arr[rootA]=rootB;
size[rootB]+=size[rootA];
}else{
arr[rootB]=rootA;
size[rootA]+=size[rootB];
}
}
int A[2005][2005];
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int h,w,a,b;
cin>>h>>w>>a>>b;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(j<a){
if(i<b)A[i][j]=0;
else A[i][j]=1;
}else{
if(i<b)A[i][j]=1;
else A[i][j]=0;
}
}
}
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
cout<<A[i][j];
}
cout<<endl;
}
}
|
#include <iostream>
#include <cstdio>
using namespace std;
int main(){
long long a, b, m;
cin >> a >> b >> m;
long long A[a], B[b];
long long min_a = 1e9, min_b = 1e9;
for(long long i = 0; i < a; i++){
cin >> A[i];
min_a = min(min_a, A[i]);
}
for(long long i = 0; i < b; i++){
cin >> B[i];
min_b = min(min_b, B[i]);
}
long long min_cost = min_a + min_b;
for(long long i = 0; i < m; i++){
long long x, y, c;
cin >> x >> y >> c;
min_cost = min(min_cost, A[x-1]+B[y-1]-c);
}
cout << min_cost << endl;
return 0;
}
| 0
| 57,391,537
|
#include <bits/stdc++.h>
using namespace std;
#define hs ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
typedef long long ll;
const ll mod = 1000000007;
const ll INF = 1e18;
const ll MAX = 100001;
void solve(){
ll a, b, n;
cin>>n>>a>>b;
cout<<n/(a+b)*a + min((n%(a+b)), a);
}
int main(){
hs;
ll t;
t=1;
for (int i=1; i<=t; i++){
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
#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 ASC(x) sort(ALL((x)))
#define DESC(x) sort(ALL((x)),greater<ll>())
#define pb push_back
int main()
{
ll N, M;
cin >> N >> M;
priority_queue<ll> A;
ll a;
REP(i,0,N) {
cin >> a;
A.push(a);
}
REP(i,0,M) {
a = A.top(); A.pop();
A.push(a/2);
}
ll sum = 0;
while(!A.empty()) {
a = A.top(); A.pop();
sum += a;
}
PR(sum);
return 0;
}
| 0
| 89,768,789
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.