code1
stringlengths 54
12k
| code2
stringlengths 71
12k
| similar
int64 0
1
| __index_level_0__
int64 0
101M
|
|---|---|---|---|
#include<iostream>
#include<vector>
#include<algorithm>
#include<string>
using namespace std;
bool x_dp[4010][16100] = {};
bool y_dp[4010][16100] = {};
int ori = 8050;
int main(){
string s;
int x, y;
cin >> s >> x >> y;
vector<int> h, v;
int cnt = 0;
bool m = true;
for(int i = 0; i < s.size(); i++){
if(s[i] == 'F') cnt++;
else{
if(m){
if(cnt != 0) h.emplace_back(cnt);
m = false; cnt = 0;
}else{
if(cnt != 0) v.emplace_back(cnt);
m = true; cnt = 0;
}
}
}
if(m){
if(cnt > 0) h.emplace_back(cnt);
}else{
if(cnt > 0) v.emplace_back(cnt);
}
if(s[0] == 'F'){
x_dp[1][ori + h[0]] = true;
}else{
if(h.size() > 0){
x_dp[1][ori + h[0]] = true;
x_dp[1][ori - h[0]] = true;
}else{
x_dp[0][ori] = true;
}
}
y_dp[0][ori] = true;
for(int i = 1; i < h.size(); i++){
for(int j = ori - s.size(); j <= ori + s.size(); j++){
if(x_dp[i][j]){
x_dp[i + 1][j - h[i]] = true;
x_dp[i + 1][j + h[i]] = true;
}
}
}
for(int i = 0; i < v.size(); i++){
for(int j = ori - s.size(); j <= ori + s.size(); j++){
if(y_dp[i][j]){
y_dp[i + 1][j - v[i]] = true;
y_dp[i + 1][j + v[i]] = true;
}
}
}
if(x_dp[h.size()][ori + x] && y_dp[v.size()][ori + y]){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i, n) for(int i = 0;i < n;i++)
#define ll long long
using namespace std;
typedef pair<int, int> P;
typedef pair<ll,ll> LP;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int INF = 1000000000;
const ll LINF = 1000000000000000000;
const ll MOD = 998244353;
const double PI = acos(-1.0);
const double EPS = 1e-10;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
void solve(){
int N;
cin >> N;
vector<ll> A(N), B(N);
ll sum = 0;
ll mi = LINF;
REP(i,N){
cin >> A[i] >> B[i];
sum += A[i];
if(A[i] > B[i]) chmin(mi, B[i]);
}
if(A == B) cout << 0 << endl;
else cout << sum - mi << endl;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
solve();
}
| 0
| 28,012,038
|
#include<bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
#define vi vector<int>
#define all(x) (x).begin(),(x).end()
#define INF (1<<30)-1
using ll = long long;
using namespace std;
template<class T>bool chmax(T &a, const T &b) { if(a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if(b<a) { a=b; return 1; } return 0; }
int main(){
int n; cin >> n;
string s; cin >> s;
int l = 0, r = 0;
rep(i,n){
if(s[i] == '(') r++;
else{
if(r) r--;
else l++;
}
}
rep(i,l) s = "(" + s;
rep(i,r) s += ")";
cout << s;
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
string a, b;
cin >> a >> b;
if (a.size() > b.size()) {
cout << "GREATER" << endl;
return 0;
} else if (a.size() < b.size()) {
cout << "LESS" << endl;
return 0;
} else {
rep(i,a.size()) {
if (a[i] > b[i]) {
cout << "GREATER" << endl;
return 0;
} else if (a[i] < b[i]) {
cout << "LESS" << endl;
return 0;
}
}
}
cout << "EQUAL" << endl;
return 0;
}
| 0
| 13,712,869
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
const double pi = 3.141592653589793238462643383279;
const int INF = 1000000000;
const ll LINF = 100000000000000000;
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZABC";
const string abc = "abcdefghijklmnopqrstuvwxyzabc";
const ll MOD = 1000000007;
const int MAX = 1200000;
struct edge {
ll to;
ll cost;
};
struct UnionFind {
vector<int> UF;
vector<int> SIZE;
UnionFind(int N) : UF(N), SIZE(N, 1) {
for(int i = 0; i < N; i++) {
UF.at(i) = i;
}
}
int root(int x) {
if (UF.at(x) == x) {
return x;
}
return UF.at(x) = root(UF.at(x));
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) {
return;
}
if (SIZE.at(rx) < SIZE.at(ry)) {
UF.at(rx) = ry;
SIZE.at(ry) += SIZE.at(rx);
SIZE.at(rx) = 0;
}
else {
UF.at(ry) = rx;
SIZE.at(rx) += SIZE.at(ry);
SIZE.at(ry) = 0;
}
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
int size(int x) {
return SIZE.at(root(x));
}
};
int ctoi(char c){
if (c == '0') return 0;
if (c == '1') return 1;
if (c == '2') return 2;
if (c == '3') return 3;
if (c == '4') return 4;
if (c == '5') return 5;
if (c == '6') return 6;
if (c == '7') return 7;
if (c == '8') return 8;
if (c == '9') return 9;
return -1;
}
char to_char(int i){
if (i == 0) return '0';
if (i == 1) return '1';
if (i == 2) return '2';
if (i == 3) return '3';
if (i == 4) return '4';
if (i == 5) return '5';
if (i == 6) return '6';
if (i == 7) return '7';
if (i == 8) return '8';
if (i == 9) return '9';
return ' ';
}
ll modpow(ll A, ll N, ll M) {
ll ans = 1;
while (N > 0) {
if (N & 1) ans = ans * A % M;
A = A * A % M;
N >>= 1;
}
return ans;
}
int main() {
cout << fixed << setprecision(16);
ll N, K;
cin >> N >> K;
ll ans = 0;
for (int i = 1; i <= N; i++) {
int j = K - (i % K);
if ((2 * j) % K == 0 && j <= N) {
ans += ((N - j) / K + 1) * ((N - j) / K + 1);
}
}
cout << ans << endl;
}
|
#include <iostream>
#include <cstring>
using namespace std;
int dp[1001][1001];
int main(){
int q,xl,yl;
char X[1001],Y[1001];
cin >> q;
for (int i=0;i<q;i++){
cin >> X >> Y;
xl=strlen(X);
yl=strlen(Y);
for (int i=1;i<=xl;i++)dp[0][i]=0;
for (int i=1;i<=yl;i++)dp[i][0]=0;
for (int i=0;i<yl;i++)
for (int j=0;j<xl;j++){
if (X[j]==Y[i]){
dp[i+1][j+1]=dp[i][j]+1;
}else{
if (dp[i+1][j]>dp[i][j+1])
dp[i+1][j+1]=dp[i+1][j];
else
dp[i+1][j+1]=dp[i][j+1];
}
}
cout << dp[yl][xl]<<endl;
}
return 0;
}
| 0
| 34,792,081
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <iomanip>
using namespace std;
int main()
{
int N, n = 0;
string S;
cin >> N >> S;
while (n < S.length() - 1)
{
if (S[n] == S[n + 1])
{
S.erase(n, 1);
}
else
{
n++;
}
}
cout << S.length() << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,T;
cin>>N>>T;
vector<int>t(N);
for(int i=0;i<N;i++){
cin>>t[i];
}
int a=N*T;
for(int i=1;i<N;i++){
if((T-(t[i]-t[i-1]))>0){
a-=(T-(t[i]-t[i-1]));
}
}
cout<<a<<endl;
return 0;
}
| 0
| 26,337,655
|
# include <iostream>
# include <cstring>
# include <queue>
using namespace std;
# define pii pair<int,int>
int R, C;
char grid[1005][1005];
int dis[1005][1005];
int dx[] = {-1,0,1,0};
int dy[] = {0,-1,0,1};
bool inside(int r, int c){
return 1 <= r && r <= R && 1 <= c && c <= C;
}
int main(){
cin >> R >> C;
queue<pii> q;
memset(dis, -1, sizeof(dis));
for(int i=1; i<=R; i++){
for(int j=1; j<=C; j++){
cin >> grid[i][j];
if(grid[i][j] == '#'){
q.push({i,j});
dis[i][j] = 0;
}
}
}
int ans = 0;
while(!q.empty()){
pii cur = q.front();
q.pop();
int r = cur.first, c = cur.second;
ans = max(ans, dis[r][c]);
for(int d=0; d<4; d++){
int nxr = r+dx[d];
int nxc = c+dy[d];
if(!inside(nxr, nxc)) continue;
if(dis[nxr][nxc] != -1) continue;
if(grid[nxr][nxc] == '#') continue;
dis[nxr][nxc] = dis[r][c] + 1;
q.push({nxr, nxc});
}
}
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#define IOS ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define Pause system("pause")
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int a[250];
int main()
{
IOS;
int n;
cin>>n;
for (int i = 1; i <= 2*n; i++)
{
cin >> a[i];
}
sort(a + 1, a + 2 * n + 1);
int ans = 0;
for (int i = 1; i <= 2 * n; i += 2)
{
ans += a[i];
}
cout << ans << endl;
return 0;
}
| 0
| 29,162,010
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0;i<(int)(n);i++)
using namespace std;
using ll=long long;
int main(){
int n;
cin>>n;
int x[100];
double sum;
rep(i,n){
cin>>x[i];
sum+=x[i];
}
int p=round(sum/n);
int ans=0;
rep(i,n){
int diff=p-x[i];
ans+=pow(diff,2);
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned ll
#define all(x) x.begin(), x.end()
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<ll> vll;
const int N = 1e5 + 10;
const ll M = 998244353;
int main() {
ll n, x, m;
cin >> n >> x >> m;
map<ll, int> pos;
pos[x] = 1;
ll ans[m + 2], mpos = -1, len = 0, lpos = -1;
ans[1] = x;
ll suum = x;
for (int i = 2; i <= min(n, m + 1); ++i) {
ans[i] = (ans[i - 1] * ans[i - 1]) % m;
suum += ans[i];
if (pos.find(ans[i]) == pos.end())
pos[ans[i]] = i;
else {
mpos = pos[ans[i]];
len = i - mpos;
lpos = i;
break;
}
}
if (mpos == -1)
return cout << suum << endl, 0;
ll res = 0;
for (int i = 1; i < mpos; ++i) {
res += ans[i];
}
ll sum = ans[mpos];
for (int i = mpos + 1; i < lpos; ++i) {
sum += ans[i];
}
n -= mpos - 1;
res += (n / len) * sum;
n %= len;
for (int i = mpos; i < mpos + n; ++i) {
res += ans[i];
}
cout << res << endl;
}
| 0
| 14,297,608
|
#include<bits/stdc++.h>
#define ll long long
#define ld long double
#define pb push_back
#define vl vector
#define ff first
#define ss second
using namespace std;
int main()
{
ll a,b,i,j,n,t;
cin>>n;
ll arr[n],brr[n]={0};
for(i=0;i<n;i++) cin>>arr[i];
for(i=0;i<n-1;i++) if(arr[i]>=arr[i+1]) brr[i]=1;
ll count=0,mx=0;
for(i=0;i<n;i++)
{
if(brr[i]==1) count++;
else count=0;
mx=max(count,mx);
}
cout<<mx;
}
|
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<math.h>
#include<complex>
#include<queue>
#include<deque>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<functional>
#include<assert.h>
#include<numeric>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef long double ld;
const int inf=1e9+7;
const ll longinf=1LL<<60;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
#define F first
#define S second
const int mx=1000010;
const ll mod=1e9+7;
#define bit(n,k) ((n>>k)&1)
bool ch(ll k, ll h){
rep(i,30){
if(bit(k,i)==0 && bit(h,i)==1){
return false;
}
}
return true;
}
int main(){
int n;
ll k;
cin >> n >> k;
vector<ll> a(n),b(n);
rep(i,n){
cin >> a[i] >> b[i];
}
ll ans = 0;
vector<ll> op;
op.emplace_back(k);
rep(i,30){
if(bit(k,i)){
ll msk = 0;
REP(j,i+1,30){ msk|=(1<<j); }
ll m2 = 0;
rep(j,i){ m2|=(1<<j); }
op.emplace_back((k&msk)|m2);
}
}
for(auto it:op){
ll tmp = 0;
rep(j,n)if(ch(it,a[j])){
tmp += b[j];
}
ans = max(ans, tmp);
}
cout << ans << endl;
return 0;
}
| 0
| 10,961,722
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> ii;
#define DEBUG freopen("in.txt", "r", stdin);
struct fastio {
fastio() {
ios::sync_with_stdio(false);
cout << setprecision(10) << fixed;
cin.tie(0);
}
};
fastio _fast_io;
string s;
int main() {
cin >> s;
int Cnt = 0;
bool ok = true;
if (s[0] != 'A')
ok = false;
for (int i = 0; i < s.length(); ++i) {
char c = s[i];
if (c != 'A' && c != 'C' && isupper(c)) {
ok = false;
}
if (i >= 2 && i < s.length() - 1) {
if (c == 'C') {
++Cnt;
}
}
}
if (Cnt != 1)
ok = false;
if (ok)
cout << "AC" << endl;
else
cout << "WA" << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <string>
int main(){
std::ios::sync_with_stdio(false);
std::cin.tie(0);
while(true){
std::string str;
std::cin >> str;
if(str=="-") break;
int m;
std::cin >> m;
int cnt = 0;
for(int i=0; i<m; ++i){
int suffle;
std::cin >> suffle;
cnt += suffle;
}
int strSize = str.size();
cnt %= strSize;
str+=str;
std::cout << str.substr(cnt, strSize) << "\n";
}
return 0;
}
| 0
| 8,148,239
|
#include <bits/stdc++.h>
using namespace std;
int h, w;
int n;
bool ng[16][16];
int dp[16][16];
int search(int x, int y)
{
if (x > h - 1 || y > w - 1) return 0;
if (ng[x][y]) return 0;
if (x == h - 1 && y == w - 1) return 1;
if (~dp[x][y]) return dp[x][y];
return dp[x][y] = search(x + 1, y) + search(x, y + 1);
}
int main()
{
while (scanf("%d %d", &h, &w), h){
memset(ng, 0, sizeof(ng));
memset(dp, -1, sizeof(dp));
scanf("%d", &n);
for (int i = 0; i < n; i++){
int x, y;
scanf("%d %d", &x, &y);
ng[--x][--y] = true;
}
printf("%d\n", search(0, 0));
}
}
|
#pragma region header
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <math.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define ts to_string
#define all(v) (v).begin(), (v).end()
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vs vector <string>
#define vvs vector <vector<string>>
#define pq priority_queue<int>
using ll = long long;
int dx[] = { 1,0,-1,0 };
int dy[] = { 0,1,0,-1 };
const int INF = 2000000000;
const int MINF=-2000000000;
constexpr ll mod = 1e9 + 7;
constexpr long double pi = 3.141592653589793238462643383279;
ll fact(int i) {
if (i == 0) return 1;
return (fact(i - 1)) * i % mod;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
return a * b / gcd(a, b);
}
bool isprime(ll a)
{
if (a < 2) return false;
else if (a == 2) return true;
else if (a % 2 == 0) return false;
double m = sqrt(a);
for (int i = 3; i <= m; i += 2)
{
if (a % i == 0)
{
return false;
}
}
return true;
}
ll ketasum(ll n) {
ll sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
ll kind(vi SYURUI) {
int size = SYURUI.size();
sort(all(SYURUI));
int cnt = 1;
rep(i, size-1) {
if (SYURUI[i] != SYURUI[i + 1])cnt++;
}
return cnt;
}
#pragma endregion
signed main() {
int A, B, C, D, K; cin >> A >> B >> C >> D >> K;
cout << (60 * C + D) - (60 * A + B) - K << endl;
}
| 0
| 73,760,552
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
string s;
cin >> s;
int n = s.size();
int zero = 0;
int one = 0;
for(int i=0 ; i<n; i++){
if(s.at(i) == '0') zero++;
else one++;
}
cout << 2*min(zero,one) << endl;
}
|
#include <bits/stdc++.h>
#define rep2(x,fr,to) for(int x=(fr);x<(to);x++)
#define rep(x,to) for(int x=0;x<(to);x++)
#define repr(x,fr,to) for(int x=(fr);x>=(to);x--)
#define all(c) c.begin(),c.end()
#define sz(v) (int)v.size()
using namespace std;
typedef long long ll; typedef vector<int> VI; typedef pair<ll,int> pii;
typedef vector<ll> VL; const int MD = (int)1e9 + 7;
void dbg(){ cerr << "\n"; } template <typename T,typename ...T2> void dbg(const T& fst, const T2&...rst){ cerr << fst << ": "; dbg(rst...); }
template <class T, class T2> void amax(T& a,T2 b){ if(a < b) a = b;}
int main()
{
cin.tie(0); ios_base::sync_with_stdio(false);
int n, k;
cin >>n >>k;
vector<pii> td(n);
for(auto& x: td){ cin >>x.second >>x.first; x.second--; }
sort(td.rbegin(), td.rend());
ll sm = 0, psu =0;
VI cnt(n);
rep(i, k){
sm += td[i].first;
cnt[td[i].second]++;
}
rep(i, n) if(cnt[i]>0) psu++;
sm += psu * psu;
ll ans = sm;
int p=k-1, j=k;
repr(i, p, 0) if(cnt[td[i].second]>=2) {
for( ;j<n; j++) if(cnt[td[j].second]==0){
sm -= td[i].first + psu*psu;
cnt[td[i].second]--;
psu++;
sm += td[j].first + psu*psu;;
cnt[td[j].second]++;
ans = max(ans, sm);
break;
}
}
cout <<ans <<"\n";
return 0;
}
| 0
| 94,992,595
|
#include<iostream>
using namespace std;
int Consecutive_Integers(int n,int k){
return n-k+1;
}
int main(){
int N,K;
cin >> N >> K;
cout << Consecutive_Integers(N,K) << endl;
return 0;
}
|
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <functional>
#include <cstdlib>
#include <sstream>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <complex>
#include <vector>
#include <tuple>
#include <cstdio>
#include <math.h>
#include <cmath>
#include <time.h>
#define all(c) ((c).begin(),(c).end())
#define rall(c) (c).rbegin(),(c).rend()
#define sort(v,n) sort(v,v+n)
#define vsort(v) sort(v.begin(),v.end())
#define vvsort(v) sort(v.begin(),v.end(),greater<int>())
#define ll long long
#define pb(a) push_back(a)
#define fi first
#define se second
#define inf 999999999
using namespace std;
const ll MOD = 1e9 + 7;
const double PI = acos(-1.0);
int w, h;
char a[21][21];
int bfs(int sh,int sw) {
int ans = 1;
queue<pair<int,int> > q;
q.push(pair<int,int>(sh, sw));
while (!q.empty())
{
int nowx, nowy;
nowy = q.front().first;
nowx = q.front().second;
q.pop();
if (a[nowy][nowx + 1] == '.' && nowx<w-1) {
q.push(pair<int,int>(nowy, nowx + 1));
a[nowy][nowx + 1] = '#';
ans++;
}
if (a[nowy][nowx - 1]=='.' && nowx>0) {
q.push(pair<int,int>(nowy, nowx - 1));
a[nowy][nowx - 1] = '#';
ans++;
}
if (a[nowy + 1][nowx] == '.' && nowy<h-1) {
q.push(pair<int,int>(nowy + 1, nowx));
a[nowy + 1][nowx] = '#';
ans++;
}
if (a[nowy - 1][nowx] == '.' && nowy>0) {
q.push(pair<int,int>(nowy - 1, nowx));
a[nowy - 1][nowx] = '#';
ans++;
}
}
return ans;
}
int main() {
while (cin >> w >> h, w) {
int sw, sh;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
cin >> a[i][j];
if (a[i][j] == '@') {
sw = j;
sh = i;
}
}
}
cout << bfs(sh, sw) << endl;
}
}
| 0
| 40,718,676
|
#include <bits/stdc++.h>
#include <random>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4")
#define ll long long
#define f first
#define s second
#define pb push_back
#define mp make_pair
#define o cout<<"BUG"<<endl;
#define IOS ios_base::sync_with_stdio(0);
#define en "\n"
#define FOR(i, j, n) for(int j = i; j < n; ++j)
#define forn(i, j, n) for(int j = i; j <= n; ++j)
#define nfor(i, j, n) for(int j = n; j >= i; --j)
#define sortv(vv) sort(vv.begin(), vv.end())
#define all(v) v.begin(), v.end()
#define ld long double
#define ull unsigned long long
using namespace std;
const ll maxn=2e5+100,inf=1e9,LOG=23,mod=1e9+7;
ll block = 300, timer = 0;
const ld EPS = 1e-7;
#define bt(i) (1 << (i))
#define int ll
#define y1 yy
#define pii pair <int, int>
int n, pu[4*maxn], t[4*maxn], ans;
vector <int> edge[maxn];
void upd(int v, int tl, int tr, int l, int r, int val)
{
if(l <= tl && tr <= r)
{
t[v] += val * (tr - tl + 1);
pu[v] += val;
return;
}
if(l > tr || r < tl) return;
int mid = (tl + tr) / 2;
t[v * 2] += pu[v] * (mid - tl + 1);
pu[v * 2] += pu[v];
t[1 + v * 2] += pu[v] * (tr - mid);
pu[1 + v * 2] += pu[v];
pu[v] = 0;
upd(v * 2, tl, (tl + tr) / 2, l, r, val);
upd(v * 2 + 1, (tl + tr) / 2 + 1, tr, l, r, val);
t[v] = t[v * 2] + t[v * 2 + 1];
}
main()
{
IOS
cin >> n;
forn(1, i, n - 1)
{
int l, r;
cin >> l >> r;
if(l > r) swap(l, r);
edge[r].pb(l);
}
forn(1, i, n)
{
edge[i].pb(0);
sort(all(edge[i]));
reverse(all(edge[i]));
int cur = 1;
int last = i;
for(auto to : edge[i])
{
upd(1, 1, n, to + 1, last, cur);
cur--;
last = to;
}
ans += t[1];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
typedef pair<ll, ll> l4;
typedef pair<double, double> dd;
#define mp make_pair
#define pb push_back
#define debug(x) cerr << #x << " = " << x << " "
const int N = 5e3+2;
bitset<N> bl[N], br[N];
int n, k;
void print(bitset<N> bit)
{
cerr << "bit contains";
for (int i = 0; i <= k; ++i)
if (bit[i] == 1)
cerr << " " << i;
cerr << endl;
}
int main()
{
while (~scanf("%d %d", &n, &k))
{
vector<int> v;
for (int i = 0; i < n; ++i)
{
int x;
scanf("%d", &x);
if (x < k) v.pb(x);
}
bl[0].reset();
bl[0][0] = 1;
for (int i = 0; i < v.size(); ++i)
{
bl[i+1] = bl[i] | (bl[i] << v[i]);
}
br[v.size()+1].reset();
br[v.size()+1][0] = 1;
for (int i = int(v.size())-1; i >= 0; --i)
{
br[i+1] = br[i+2] | (br[i+2] << v[i]);
}
int ans = v.size();
for (int i = 0; i < v.size(); ++i)
{
int need = k - v[i];
int r = k;
for (int l = 0; l < k; ++l)
if (bl[i][l] == 1)
{
while (r >= 0 && (r+l >= k || br[i+2][r] == 0)) --r;
if (r == -1)
{
}
else if (l + r >= need)
{
--ans; break;
}
}
}
printf("%d\n", ans);
}
}
| 0
| 67,987,612
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(),(x).end()
const int mod=1000000007,MAX=1005,INF=1000;
ll gcd(ll a,ll b){
if(b==0) return a;
return gcd(b,a%b);
}
int main(){
ll N,X;cin>>N>>X;
if(gcd(N,X)==1) cout<<(N-1)*3<<endl;
else cout<<(N/gcd(N,X)-1)*3*gcd(N,X)<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
typedef long double ld;
typedef set<int>::iterator sit;
typedef map<int,int>::iterator mit;
typedef vector<int>::iterator vit;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
const int MAXN = 1e6 + 3;
#define _ % MOD
#define __ %= MOD
#define each(it,s) for(auto it = s.begin(); it != s.end(); ++it)
#define sortA(v) sort(v.begin(), v.end())
#define sortD(v) sort(v.begin(), v.end(), greater<auto>())
#define fill(a) memset(a, 0, sizeof (a))
#define swap(a,b) {a=a+b;b=a-b;a=a-b;}
#define rep(i, n) for(ll i = 0; i < (n); ++i)
#define repA(i, a, n) for(ll i = a; i <= (n); ++i)
#define repD(i, a, n) for(ll i = a; i >= (n); --i)
#define watch(x) cout << (#x) << " is " << (x) <<endl
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
ll gcd(ll a,ll b){if(b==0) return a; else return gcd(b,a%b);}
ll power(ll x,ll y){ll res=1; while(y>0){if(y&1) res=res*x;y=y>>1;x=x*x;}return res;}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin>>s;
if(s[2]==s[3] && s[4]==s[5]) cout<<"Yes\n";
else cout<<"No\n";
return 0;
}
| 0
| 77,383,808
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, m, n) for (int i = m; i < n; ++i)
const int MOD = 1000000007;
long long solve(vector<long long> &V, int n) {
long long res = 0;
rep(i, 0, n) {
res += V[i] * (i - n + i + 1);
res %= MOD;
}
return res;
}
int main() {
int N, M;
cin >> N >> M;
vector<long long> X(N);
rep(i, 0, N) cin >> X[i];
vector<long long> Y(M);
rep(i, 0, M) cin >> Y[i];
long long ans = solve(X, N) * (solve(Y, M)) % MOD;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
const int MOD=1e9+7;
const long double Pi=acos(-1);
using P=pair<ll,ll>;
ll gcd(ll a,ll b){
if(a%b==0){return b;}
else{return gcd(b,a%b);}
}
ll lcm(ll a,ll b){
return a*b/gcd(a,b);
}
ll pow(ll x,ll y){
ll tmp=x,res=1;
while(y){
if(y%2){res=res*tmp%MOD;}
y>>=1;
tmp=tmp*tmp%MOD;
}
return res;
}
ll nature(ll a){
if(a>=0){return(a);}
else{return(-1*a);}
}
ll prime(ll a){
if(a==2){return 1;}
else if(a%2==0 || a==1){return 0;}
for(ll i=3;i*i<=a;i+=2){if(a%i==0){return 0;}}
return 1;
}
int main(){
string s,t;
cin>>s>>t;
ll ans=0;
for(ll i=0;i<3;i++){
if(s.at(i)==t.at(i)){ans++;}
}
cout<<ans<<endl;
}
| 0
| 6,079,825
|
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int a[3];
cin>>a[0]>>a[1]>>a[2];
sort(a,a+3);
cout<<a[0]<<" "<<a[1]<<" "<<a[2]<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int N,M;
vector<vector<int>> neighbor;
int res = 0;
void dfs(int now, int reached){
if(reached == (1<<N)-1)res++;
else{
for(int neigh : neighbor.at(now)){
if((1<<(neigh-1)) & reached)continue;
else dfs(neigh, reached + (1<<(neigh-1)));
}
}
}
int main(){
cin >> N >> M;
neighbor = vector<vector<int>>(N+1, vector<int>(0));
for(int i=0; i<M; i++){
int a,b;
cin >> a >> b;
neighbor.at(a).push_back(b);
neighbor.at(b).push_back(a);
}
dfs(1, 1);
cout << res << endl;
}
| 0
| 3,899,663
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double dd;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int,int> pii;
const int mx=1e6+11;
const double PI = acos(-1);
#define MOD 1000000007
#define nl '\n'
#define pb push_back
#define F first
#define S second
#define I insert
#define mp make_pair
#define sz(x) x.size()
#define tt int t; cin>>t; while(t--)
#define lo(i,a,b) for(int i=a;i<b;i++)
#define rlo(i,n) for(int i=n-1;i>=0;i--)
#define be(a) (a).begin(),(a).end()
#define rbe(a) (a).rbegin(),(a).rend()
#define mem(a,b) memset(a,b,sizeof(a))
#define pr(a) {for(auto x:a)cout<<x<<" ";cout<<nl;}
#define su ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define file freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#define frac cout.unsetf(ios::floatfield); cout.precision(10); cout.setf(ios::fixed,ios::floatfield);
#define dbg(args...) do {cerr << #args << " : "; faltu(args); } while(0)
void faltu () { cerr << endl;}
template < typename T, typename ... hello>void faltu( T arg, const hello &... rest) {cerr << arg << ' ';faltu(rest...);}
void f()
{
int a[3];
cin>>a[0]>>a[1]>>a[2];
sort(a,a+3);
cout<<a[2]*10+a[1]+a[0]<<nl;
}
int main()
{
su;
f();
return 0;
}
|
#include <iostream>
using namespace std;
template<typename T>
class Dice {
private:
void Init() {
upId = 0;
frontId = 1;
rightId = 2;
}
public:
Dice() :
number{1, 2, 3, 4, 5, 6}
{
Init();
}
Dice(T (&n)[6]) :
number{n[0], n[1], n[2], n[3], n[4], n[5]}
{
Init();
}
virtual ~Dice() {;}
enum Direction {
north,
south,
east,
west
};
void Roll(Direction direction) {
switch (direction) {
case north: {
int tmp = upId;
upId = frontId;
frontId = 5 - tmp;
break;
}
case south: {
int tmp = frontId;
frontId = upId;
upId = 5 - tmp;
break;
}
case east: {
int tmp = rightId;
rightId = upId;
upId = 5 - tmp;
break;
}
case west: {
int tmp = upId;
upId = rightId;
rightId = 5 - tmp;
break;
}
}
}
T Print() {
return number[upId];
}
T Search(T up, T front) {
int downId = 5 - upId;
int backId = 5 - frontId;
int leftId = 5 - rightId;
if (number[frontId] == up) {
Roll(north);
} else if (number[rightId] == up) {
Roll(west);
} else if (number[downId] == up) {
Roll(north);
Roll(north);
} else if (number[backId] == up) {
Roll(south);
} else if (number[leftId] == up) {
Roll(east);
}
downId = 5 - upId;
backId = 5 - frontId;
leftId = 5 - rightId;
if (number[frontId] == front) {
return number[rightId];
} else if (number[rightId] == front) {
return number[backId];
} else if (number[backId] == front) {
return number[leftId];
} else if (number[leftId] == front) {
return number[frontId];
}
return 0;
}
private:
T number[6];
int upId;
int frontId;
int rightId;
};
int SearchDice(Dice<int>& dice, int up, int front) {
if (dice.Print() != up) {
for (int i = 0; i < 3; ++i) {
dice.Roll(Dice<int>::north);
if (dice.Print() == up) {
break;
}
}
if (dice.Print() != up) {
dice.Roll(Dice<int>::east);
if (dice.Print() != up) {
dice.Roll(Dice<int>::west);
dice.Roll(Dice<int>::west);
}
}
}
dice.Roll(Dice<int>::north);
if (dice.Print() != up) {
for (int i = 0; i < 3; ++i) {
dice.Roll(Dice<int>::east);
if (dice.Print() == up) {
break;
}
}
}
dice.Roll(Dice<int>::east);
return dice.Print();
}
int main() {
int number[6]{};
for (int i = 0; i < 6; ++i) {
cin >> number[i];
}
int n{};
cin >> n;
while (n--) {
int up{}, front{};
cin >> up >> front;
Dice<int> dice(number);
cout << dice.Search(up, front) << endl;;
}
return 0;
}
| 0
| 23,963,976
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x,y;
cin >> x >> y;
bool can = false;
for (int i = 0; i < x+1; i++) {
for (int j = 0; j < x+1; j++) {
if (i * 2 + j * 4 == y && i + j == x) {
can = true;
}
}
}
if (can) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 1e9;
int main(){
int n,m;
cin >> n >> m;
const int max_n = 1e5;
vector<int> a(n);
for(int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
for(int i = 0; i < m; i++){
int left = 0;
int right = n-1;
int price = a[n-1] / 2;
while(right - left > 1){
int x = (right + left) / 2;
if(a[x] > price) right = x;
else left = x;
}
if(a[left] > price) a.insert(a.begin() + left, price);
else a.insert(a.begin() + right, price);
}
long long sum = 0;
for(int i = 0; i < n; i++) sum += a[i];
cout << sum << endl;
return 0;
}
| 0
| 46,516,176
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<numeric>
using namespace std;
using ll = long long;
#define int ll
signed main(){
int N; cin >> N;
vector<int>A(N);
for(auto & e : A) cin >> e;
int sum = A.front() - 1;
int crt = 2;
for(int i = 1; i < A.size(); ++i){
if(crt > A[i])continue;
if(crt == A[i]){++crt; continue;}
int mod = A[i] % crt;
int div = A[i] / crt;
sum += div - (mod == 0);
crt = max(crt,(mod != 0 ? 1 : crt));
}
cout << sum << endl;
}
|
#include <bits/stdc++.h>
int main(){
int X, Y, Z, K;
std::cin >> X >> Y >> Z >> K;
std::vector< long long > A(X);
std::vector< long long > B(Y);
std::vector< long long > C(Z);
for(int i=0; i<X; i++){
std::cin >> A[i];
}
for(int i=0; i<Y; i++){
std::cin >> B[i];
}
for(int i=0; i<Z; i++){
std::cin >> C[i];
}
std::priority_queue< long long > AB_pq;
for(int i=0; i<X; i++){
for(int j=0; j<Y; j++){
AB_pq.push(A[i] + B[j]);
}
}
int K_ab = std::min(K, X * Y);
std::vector< long long > AB(K_ab);
for(int i=0; i<K_ab; i++){
AB[i] = AB_pq.top();
AB_pq.pop();
}
std::priority_queue< long long > ABC_pq;
for(int i=0; i<K_ab; i++){
for(int j=0; j<Z; j++){
ABC_pq.push(AB[i] + C[j]);
}
}
for(int i=0; i<K; i++){
std::cout << ABC_pq.top() << std::endl;
ABC_pq.pop();
}
return 0;
}
| 0
| 82,519,942
|
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;n>i;++i)
#define MOD 1000000007
using namespace std;
using ll=int64_t;
using pii=pair<int,int>;
using vi=vector<int>;
using VI=vector<ll>;
using vis=vector<string>;
using vvi=vector<vi>;
int gcd(int a,int b){
if(a%b==0)
return b;
return gcd(b,a%b);
}
int lcm(int a,int b){
return a*b/gcd(a,b);
}
bool prime(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;
}
int main(){
ll n; cin>>n;
VI d(n);
rep(i,n) cin>>d[i];
sort(d.begin(),d.end());
ll b=d.size()/2;
if(d[b-1]==d[b]){
cout<<"0"<<endl;
return 0;
}
cout<<d[b]-d[b-1]<<endl;
}
|
#include <iostream>
#include <cstring>
#include <stack>
#include <algorithm>
using namespace std;
int N,A[100005],L[100005];
int main()
{
L[0]=0;
cin>>N;
int i,j;
for(i=1;i<=N;i++){
cin>>A[i];
}
int len=1;
L[0]=A[1];
for(i=1;i<=N;i++){
if(L[len-1]<A[i])L[len++]=A[i];
else *lower_bound(L,L+len,A[i])=A[i];
}
cout<<len<<endl;
return 0;
}
| 0
| 26,528,790
|
#include <iostream>
#include <map>
#include <queue>
#include <cmath>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
#pragma warning (disable: 4996)
long long N, A[1 << 18], D[1 << 18];
long long S;
int main() {
cin >> N;
for (int i = 1; i <= N; i++) cin >> A[i];
for (int i = 1; i <= N; i++) S += A[i];
long long base = N * (N + 1LL) / 2LL;
long long kosuu = S / base;
if (S % base != 0) {
cout << "NO" << endl;
return 0;
}
long long t = 0, cnt = 0;
for (int i = 1; i <= N; i++) D[i] = A[i] - 1LL * i * kosuu;
for (int i = 2; i <= N; i++) {
if (D[i] == D[i - 1]) continue;
if (D[i - 1] < D[i]) { cout << "NO" << endl; return 0; }
if ((D[i] - D[i - 1]) % N != 0) { cout << "NO" << endl; return 0; }
long long s = (D[i - 1] - D[i]) / N;
cnt += s;
t += 1LL * (N + 2 - i) * s;
}
if (kosuu < cnt) { cout << "NO" << endl; return 0; }
t += 1LL * (kosuu - cnt);
if (t == A[1]) { cout << "YES" << endl; }
else { cout << "NO" << endl; }
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
#define ll long long
#define ld long double
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
#define sz(x) ((int)(x).size())
#define chmin(x,y) x = min(x,y)
#define chmax(x,y) x = max(x,y)
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
int main()
{
string s;cin >> s;
ll k;cin >> k;
int index = 0;
while(index<(int)s.length())
{
if(s[index]=='1')
{
index++;
continue;
}
break;
}
if(k<=index)
{
cout << '1' << endl;
return 0;
}
cout << s[index] << endl;
}
| 0
| 94,442,899
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) cin >> A.at(i);
int ans = 0, K = 1;
for (int i = 1; i < N; i++) {
if (A.at(i) == A.at(i - 1)) {
K++;
}
else {
ans += K / 2;
K = 1;
}
}
ans += K / 2;
cout << ans << endl;
}
|
#define ONLINE_JUDGE
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll,ll> pl;
typedef vector<pl> vp;
const ll INF=1001001001;
const ll LINF=1001001001001001001;
const ll D4[]={0,1,0,-1,0};
const ll D8[]={0,1,1,0,-1,-1,1,-1,0};
#define _overload3(_1,_2,_3,name,...) name
#define _rep2(i,n) for(ll i=0;i<(n);++i)
#define _rep3(i,a,b) for(ll i=(a);i<(b);++i)
#define rep(...) _overload3(__VA_ARGS__,_rep3,_rep2)(__VA_ARGS__)
#define _repe2(i,n) for(ll i=0;i<=(n);++i)
#define _repe3(i,a,b) for(ll i=(a);i<=(b);++i)
#define repe(...) _overload3(__VA_ARGS__,_repe3,_repe2)(__VA_ARGS__)
#define _rrep2(i,n) for(ll i=(n)-1;i>=0;i--)
#define _rrep3(i,a,b) for(ll i=(b)-1;i>=(a);i--)
#define rrep(...) _overload3(__VA_ARGS__,_rrep3,_rrep2)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
template<class T>
bool chmax(T &a,const T &b){if(a<b){a=b;return 1;}return 0;}
template<class T>
bool chmin(T &a,const T &b){if(b<a){a=b;return 1;}return 0;}
template<class T>
using pq=priority_queue<T,vector<T>,greater<T>>;
void solve();
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
solve();
}
void solve(){
ll n,m;cin>>n>>m;
vl x(n),y(n),z(n);
rep(i,n)cin>>x[i]>>y[i]>>z[i];
ll ans=0;
rep(i,1<<3){
ll sig1=i&1?1:-1;
ll sig2=i>>1&1?1:-1;
ll sig3=i>>2&1?1:-1;
vl cakes;
rep(j,n){
ll tmp=sig1*x[j]+sig2*y[j]+sig3*z[j];
cakes.push_back(tmp);
}
sort(all(cakes),greater<>());
ll sum=0;
rep(j,m)sum+=cakes[j];
chmax(ans,sum);
}
cout<<ans<<endl;
}
| 0
| 5,517,721
|
#include <iostream>
#include <iomanip>
#include <math.h>
#include <string>
#include <algorithm>
#include <vector>
#include <numeric>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <bitset>
using namespace std;
#define ll long long int
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repm(i, a, n) for (int i = a; i >= n; i--)
#define INF 1e9
#define LINF 1e17
#define MOD (int)(1e9 + 7)
#define pi 3.141592653589
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vs vector<string>
#define vii vector<vector<int>>
#define vll vector<ll>
#define vllll vector<vector<ll>>
#define vd vector<double>
#define ALL(a) (a).begin(), (a).end()
#define sort_v(a) sort(a.begin(), a.end())
#define reverse_v(a) reverse(a.begin(), a.end())
#define fi first
#define se second
void print(bool c)
{
(c) ? (cout << "Yes" << endl) : (cout << "No" << endl);
}
void Print(bool c)
{
(c) ? (cout << "YES" << endl) : (cout << "NO" << endl);
}
template <typename T>
T gcd(T a, T b)
{
while (1)
{
if (a < b)
swap(a, b);
if (b == 0)
break;
a %= b;
}
return a;
}
template <typename T>
T lcm(T a, T b)
{
return a * b / gcd(a, b);
}
bool cmp(const pii &a, const pii &b)
{
if (a.second != b.second)
return a.second < b.second;
return a.first < b.first;
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main(void)
{
string s;
cin >> s;
ll k, ans = 0;
cin >> k;
bool flag = true;
char cc = s[0];
rep(i, 0, s.size())
{
if (s[i] != cc)
flag = false;
}
if (flag)
ans = (s.size() * k) / 2;
else
{
ll fr = 0, bk = 0;
char c1 = s[0];
rep(i, 0, s.size())
{
if (s[i] != c1)
{
break;
}
else
{
fr++;
}
}
char c2 = s[s.size() - 1];
for (int i = s.size() - 1; i >= 0; i--)
{
if (s[i] != c2)
{
break;
}
else
{
bk++;
}
}
ll cnt = 0;
char c3 = 'A';
rep(i, 0, s.size())
{
if (s[i] != c3)
{
c3 = s[i];
ans += k * (cnt / 2);
cnt = 1;
}
else
{
cnt++;
if (i == s.size() - 1)
ans += k * (cnt / 2);
}
}
if (s[0] == s[s.size() - 1])
ans -= (k - 1) * (fr / 2 + bk / 2 - (fr + bk) / 2);
}
cout << ans << endl;
}
|
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include<bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define pii pair<int,int>
#define pp pair<pair<ll, ll>,pair<ll, ll>>
#define pll pair<ll,ll>
#define pdd pair<double,double>
#define vii vector<int>
#define vll vector<ll>
#define mat vector<vector<ll>>
#define lb lower_bound
#define ub upper_bound
#define pb push_back
#define fi first
#define sc second
#define rep(i,n) for(ll i=0;i<n;i++)
#define rep2(i,a,b) for(ll i=a;i<b;i++)
#define repr(i,n) for(ll i=n-1;i>=0;i--)
#define all(x) x.begin(),x.end()
#define sz(x) (ll) (x).size()
#define pq priority_queue<ll>
#define pqg priority_queue<ll,vector<ll>,greater<ll>>
#define LB(v,x) (lower_bound(v.begin(),v.end(),x)-v.begin())
#define UB(v,x) (upper_bound(v.begin(),v.end(),x)-v.begin())
#define ERASE(v) sort(v.begin(),v.end());v.erase(unique(v.begin(),v.end()),v.end())
using namespace std;
const ll INF = (1 << 30 ) - 1;
const ll LLINF = (1LL << 60LL);
const ll MOD = 1000000007;
const ll mod = 998244353;
const ll MAX = 1100000;
const double pi = acos(-1);
const double eps = 1e-10;
ll dx[4] ={1,0,-1,0} , dy[4] ={0,1,0,-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 Timer{
chrono::system_clock::time_point start, end;
Timer(){ start = chrono::system_clock::now(); }
~Timer(){
end = chrono::system_clock::now();
auto msec = chrono::duration_cast<chrono::milliseconds>(end - start).count();
cerr<<"time : "<<msec<<" ms"<<endl;
}
};
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
Timer TM;
ll n,a,b;
cin>>n>>a>>b;
vll G[300010];
if(a+b>n+1||a*b<n){
cout<<-1<<endl;
return 0;
}
vll ans;
ll s=n-a;
rep(i,a){
ll num=min(b-1,s)+1;
s-=num-1;
rep(j,num) ans.pb(n-num+1+j);
n-=num;
}
reverse(all(ans));
for(auto i:ans) cout<<i<<" ";
cout<<endl;
return 0;
}
| 0
| 15,224,766
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<n;++i)
#define exrep(i, a, b) for(ll i = a; i < b; i++)
#define out(x) cout << x << endl
#define EPS (1e-7)
#define gearup ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<pair<int,int> > vpii;
typedef vector<vector<int> > vvi;
typedef vector<vector<char> > vvc;
typedef vector<vector<bool> > vvb;
typedef vector<vector<double> > vvd;
typedef vector<vector<string> > vvs;
typedef vector<ll> vl;
typedef vector<vector<ll> > vvl;
typedef vector<vector<vector<ll> > > vvvl;
ll MOD = 1000000007;
const long long L_INF = 1LL << 60;
const int INF = 2147483647;
const double PI = acos(-1);
template<class T> inline bool chmin(T& a, T b) {if (a > b) {a = b;return true;}return false;}
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b;return true;}return false;}
template<class T> void debug(T v){rep(i,v.size()) cout<<v[i]<<" ";cout<<endl;}
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
signed main()
{
gearup;
string s; cin >> s;
int n = s.size();
ll res = 0;
vl cnt(26);
rep(i,n){
rep(j,26){
if(s[i] - 'a' != j)res+=cnt[j];
}
cnt[s[i]-'a']++;
}
out(res + 1);
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<(n); i++)
using namespace std;
using ll = long long;
int main()
{
int W, H, N;
int x, y, a;
cin >> W >> H >> N;
int minx = 0, maxx=W;
int miny = 0, maxy=H;
rep(i, N){
cin >> x >> y >> a;
if(a==1){
minx = max(minx, x);
}else if(a==2){
maxx = min(maxx, x);
}else if(a==3){
miny = max(miny, y);
}else if(a==4){
maxy = min(maxy, y);
}
}
if(maxy < miny || maxx < minx){
cout << 0 << endl;
}else{
cout << (maxy-miny)*(maxx-minx) << endl;
}
return 0;
}
| 0
| 86,572,459
|
#include<bits/stdc++.h>
using namespace std;
int main(){
string s[26][26];
int h,w;
cin>>h>>w;
int number;
char c;
for (int i = 0; i < h; i++){
for (int j = 0; j < w; j++){
cin>>s[i][j];
if(s[i][j]=="snuke"){
c='A'+j;
number=i+1;
}
}
}
cout<<c<<number<<endl;
}
|
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<tuple>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = (ll)1000000007 * 1000000007;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define Per(i,sta,n) for(int i=n-1;i>=sta;i--)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef long double ld;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<ll, ll> LP;
int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};
int n,k;
int a[100010];
ll b[100010];
void solve(){
cin >> n >> k;
rep(i,n){
cin >> a[i] >> b[i];
}
ll ans=0;
rep(i,32){
ll res=0;
vector<int> v;
if(i>0){
if(!(k & (1 << (i-1)))) continue;
v.push_back(i-1);
}
Rep(j,i,32){
if(!(k & (1 << j))){
v.push_back(j);
}
}
rep(s,n){
bool flag=true;
for(int t:v){
if(a[s]&(1 << t)){
flag=false;
}
}
if(flag)res+=b[s];
}
ans=max(ans,res);
}
cout << ans << endl;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(50);
solve();
}
| 0
| 47,522,470
|
#include <iostream>
#include <numeric>
#include <stdio.h>
#include <iomanip>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
using namespace std;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
int main() {
long long N;
cin >> N;
vector<int> vec(N);
long long sm = 0;
for (long long i = 0; i < N; i++) {
cin >> vec.at(i);
}
sort(vec.begin(), vec.end());
long long an = 0;
for (long long i = 0; i < N; i++) {
if (2*sm<vec.at(i)) {
an=i;
}
sm += vec.at(i);
}
cout << N-an << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define vi vector<int>
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define pi 3.141592653589793238
#define rep(i,a,b) for (int i = a; i <= b; i++)
#define zip(i,a,b) for(int i=a;i<b;i++)
#define rzip(i,a,b) for(int i=a;i>=b;i--)
#define ll unsigned int
#define test int t;cin>>t; while(t--)
#define en '\n'
typedef pair<int, int> pii;
typedef pair<char, int> pci;
typedef pair<char, char> pcc;
typedef vector<pii> vii;
typedef long double ld;
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(),v.rend()
#define sz(x) (int)x.size()
#define INF (1e18+5)
#define inf (1e9+5)
#define mod 1000000007
void __print(int x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i : x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
const int gf = 1e6 + 9;
int dp[100009];
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
#ifndef ONLINE_JUDGE
if (fopen("input.txt", "r"))
{
freopen ("input.txt" , "r" , stdin);
freopen ("output.txt" , "w" , stdout);
}
#endif
int n;
cin >> n;
vi v;
int ans = 0;
rep(i, 1, 5)
v.pb(1);
int x = 6;
while (x <= 1e5)
{
v.pb(x);
x *= 6;
}
x = 9;
while (x <= 1e5)
{
v.pb(x);
x *= 9;
}
debug(sz(v));
rep(i, 1, 100000)
{
dp[i] = inf;
}
dp[0] = 0;
rep(i, 1, n)
{
zip(j, 0, sz(v))
{
if (i < v[j])
continue;
else
{
dp[i] = min(dp[i], dp[i - v[j]] + 1);
}
}
}
cout << dp[n] << en;
return 0;
}
| 0
| 46,389,005
|
#include<iostream>
#include<algorithm>
#include<vector>
#include<cmath>
#include<cstdio>
#include<string>
typedef long long int ll;
using namespace std;
string back(string s){
string ret="";
for(int i=s.size()-1;i>=0;i--){
ret+=s[i];
}
return ret;
}
int main(){
string s;
cin>>s;
cout<<back(s)<<endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define IOS ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define ll long long
#define li long int
#define ld long double
#define lld long long double
#define pb push_back
#define mk make_pair
#define F first
#define S second
#define all(v) (v).begin(),(v).end()
#define fill(a) memset(a, 0, sizeof(a))
const int MX = 1e6;
const int MI = -1e6;
const int MOD = 1e9 + 7;
const string ALPHA = "abcdefghijklmnopqrstuvwxyz";
const double PI = 3.1415926535;
#define rep(i, n) for(int i=0; i<n; i++)
const int mod=1e9+7;
inline int add(int x,int y)
{
x+=y;
if (x>=mod)
return x-mod;
return x;
}
inline int sub(int x,int y)
{
x-=y;
if (x<0)
return x+mod;
return x;
}
inline int mul(int x,int y)
{
return (x*1ll*y)%mod;
}
inline int power(int x,int y)
{
int ans=1;
while(y)
{
if (y&1) ans=mul(ans,x);
x=mul(x,x);
y>>=1;
}
return ans;
}
inline int inv(int x)
{
return power(x,mod-2);
}
inline int gcd(int x, int y)
{
return(y!=0)?gcd(y, x%y):x;
}
inline ll nPr(int n, int r)
{
ll i,result=1;
rep(i,r)
{
result*=(ll)(n-i);
}
return result;
}
inline ll nCr(int n,int r)
{
ll i,result=1;
rep(i,min(r,n-r))
{
result*=(ll)(n-i);
result/=(ll)(i+1);
}
return result;
}
bool prime(int n)
{
for (int i=2; i<n/2; i++)
{
if(n%i==0)
return false;
}
return true;
}
int main()
{
IOS;
int a, b, c, k;
cin >> a >> b >> c >> k;
int ans;
if (a>=k)
ans=k;
else if (a+b>=k)
ans=a;
else
ans=2*a+b-k;
cout << ans << endl;
return 0;
}
| 0
| 63,436,032
|
#pragma GCC optimize(3)
#define ADD_STACK int size = 512 << 20;\
char *pp = (char*)malloc(size) + size; \
__asm__("movl %0, %%esp\n" :: "r"(pp))
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<string>
#include<fstream>
#include<queue>
#include<map>
#include<stack>
#include<set>
#include<bitset>
#include<ctime>
#include<vector>
#define ll long long
#define ull unsigned long long
#define mn 200020
#define Max(x,y) (((x)>(y))?(x):(y))
#define Min(x,y) (((x)<(y))?(x):(y))
#define Abs(x) (((x)<(0))?(-(x)):(x))
#define infll (ll)(1e18)
#define infint (1<<30)
#define mod (int)(1e9+7)
#define FOR(a,b,c) for (register int a=b;a<=c;++a)
#define FORD(a,b,c) for (register int a=b;a>=c;--a)
using namespace std;
inline ll read(){
ll x=0,f=1;char c;
for(c=getchar();c<'0'||c>'9';f=((c=='-')?-1:f),c=getchar());
for(;c>='0'&&c<='9';x=x*10+c-'0',c=getchar());
return x*f;
}
template<typename T>
inline void write(T a){
if(a==0){putchar('0');return;}if(a<0)putchar('-'),a=-a;char c1[120];int h=0;
while(a)c1[++h]=a%10+'0',a/=10;FORD(i,h,1)putchar(c1[i]);
}
inline void write_(){return;}
template<typename T,typename... Args>
inline void write_(T a,Args... b){write(a);putchar(' ');write_(b...);}
inline void writeln(){putchar('\n');return;}
template<typename T,typename... Args>
inline void writeln(T a,Args... b){write(a);putchar(' ');writeln(b...);}
inline ll gcd(ll a,ll b){return a==0?b:gcd(b%a,a);}
inline ll lcm(ll a,ll b){return 1ll*a/gcd(a,b)*b;}
inline ll Pow(ll n,ll a){ll b=1;while(a){if(a&1)b=1ll*b*n%mod;n=1ll*n*n%mod;a>>=1;}return b;}
ll n,a[mn],p[120],num,ans;
inline void f(ll x){
FORD(i,62,0)if(!(num&(1ll<<i))&&(x&(1ll<<i))){
if(!p[i]){p[i]=x;return;}
x^=p[i];
}
FORD(i,62,0)if((num&(1ll<<i))&&(x&(1ll<<i))){
if(!p[i]){p[i]=x;return;}
x^=p[i];
}
}
signed main(){
#ifdef LOCAL_LIGEN
double be=clock();
#endif
n=read();
FOR(i,1,n)a[i]=read(),num^=a[i];
FOR(i,1,n)f(a[i]);
FORD(i,62,0)if(!(ans&(1ll<<i)))ans^=p[i];
writeln(ans+(num^ans));
#ifdef LOCAL_LIGEN
double en=clock();
printf("Time: %.0lfms\n",en-be);
fclose(stdin);fclose(stdout);
#endif
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(i,a,n) for(ll i=(ll)a;i<(ll)n;i++)
#define RFOR(i,a,n) for(ll i=(ll)n-1;i >= (ll)a;i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,0,n)
#define ALL(v) v.begin(), v.end()
#define bra(first,second) '(' << first << ',' << second << ')'
constexpr ll MOD = 998244353;
ll INF = 6001001001001001001;
long double EPS = 1e-11;
long double PI = 3.141592653589793238;
template<typename T>
void remove(std::vector<T>& vector, unsigned int index){
vector.erase(vector.begin() + index);
}
using Graph = vector<vector<ll>>;
int main(){
ll N,K;
cin >> N >> K;
vector<pair<ll,ll>> P(N);
rep(i,N) cin >> P[i].first >> P[i].second;
sort(ALL(P));
ll ans = INF;
rep(i,N) FOR(j,i,N) FOR(k,j,N) FOR(l,k,N){
ll x1 = min({P[i].first,P[j].first,P[k].first,P[l].first});
ll x2 = max({P[i].first,P[j].first,P[k].first,P[l].first});
ll y1 = min({P[i].second,P[j].second,P[k].second,P[l].second});
ll y2 = max({P[i].second,P[j].second,P[k].second,P[l].second});
ll cnt = 0;
rep(j,N){
if(x1 <= P[j].first && P[j].first <= x2 && y1 <= P[j].second && P[j].second <= y2) cnt++;
}
if(cnt >= K){
if(x1 == x1 && y1 == y2) ans = min(ans,(ll)1);
else if(x1 == x2) ans = min(ans,abs(y2-y1));
else if(y1 == y2) ans = min(ans,abs(x2-x1));
else ans = min(ans,abs((x2-x1)*(y2-y1)));
}
}
cout << ans << endl;
}
| 0
| 25,925,466
|
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<math.h>
#include<complex>
#include<queue>
#include<deque>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<functional>
#include<assert.h>
#include<numeric>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef long double ld;
const int inf=1e9+7;
const ll longinf=1LL<<60;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
#define F first
#define S second
const int mx=1000010;
const ll mod=1e9+7;
int main(){
string s;
cin >> s;
int n = s.size();
vector<int> pos;
for(int l=0,r=n-1; l<r; ){
if(s[l]==s[r]){
l++;
r--;
continue;
}
if(s[l]=='x'){
pos.emplace_back(r+1);
l++;
continue;
}
if(s[r]=='x'){
pos.emplace_back(l);
r--;
continue;
}
cout << -1 << endl; return 0;
}
cout << pos.size() << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
#define ll long long
int main()
{
ll n, m;
cin >> n >> m;
vector<pair<ll, ll>> v(n);
for (int i = 0; i < n; i++)
{
cin >> v[i].first >> v[i].second;
}
sort(v.begin(), v.end());
ll ans = 0, ind = 0;
while (m)
{
int amt = min(m, v[ind].second);
m -= amt;
v[ind].second -= amt;
ans += amt * v[ind].first;
if (!v[ind].second) ind++;
}
cout << ans << "\n";
}
| 0
| 14,374,785
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<ll, int> Pli;
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll MOD3 = 1812447359;
const ll INF = 1ll << 62;
const double PI = 2 * asin(1);
void yes() {printf("yes\n");}
void no() {printf("no\n");}
void Yes() {printf("Yes\n");}
void No() {printf("No\n");}
void YES() {printf("YES\n");}
void NO() {printf("NO\n");}
string S, T;
vector <int> s[26], t[26];
int main(){
cin >> S >> T;
for (int i = 0; i < S.length(); i++){
s[S[i] - 'a'].push_back(i);
t[T[i] - 'a'].push_back(i);
}
for (int i = 0; i < 26; i++){
bool flag = false;
for (int j = 0; j < 26; j++){
if (s[i] == t[j]) flag = true;
}
if (flag) continue;
No(); return 0;
}
Yes();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define F first
#define S second
#define endl "\n"
#define nl cout<<endl
#define pb push_back
#define f(i,a,b) for(ll i=a;i<b;i++)
#define Knucklehead ios_base::sync_with_stdio(false);cin.tie(NULL);
#define txti freopen("input.txt", "r", stdin);
#define txto freopen("output.txt", "w", stdout);
#define mat vector<vector<ll>>
mat cn(ll n, ll m){return vector< vector<ll> >(n, vector<ll>(m));}
bool compare(char &s1,char &s2){return s1 > s2;}
bool sortmahstyle(const pair<ll,ll> &a, const pair<ll,ll> &b)
{
if(a.second > b.second )
return true;
if( a.second==b.second && a.first > b.second )
return true;
return false;
}
ll const mod = 1e9+7;
ll const inf = 1e6+2;
ll fact[inf];
void factfill()
{
fact[0]=1;
for(ll i=1; i<inf; i++)
fact[i] = ( fact[i-1]*i ) % mod;
}
ll powmod(ll a, ll b)
{
ll res = 1;
while(b){
if(b%2) res = ( res*a )%mod;
a = (a*a)%mod;
b/=2;
}
return res;
}
ll inv(ll x)
{
return powmod(x,mod-2) % mod;
}
ll choose(ll n, ll r)
{
return ( (fact[n]* inv(fact[n-r] ) )%mod *inv(fact[r]))%mod;
}
void solve()
{
ll n; cin >> n;
cout << n*(n+1)/2 ;
}
int main() {
Knucklehead
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ll t;
t=1;
f(testcases,0,t){
solve();
}
return 0;
}
| 0
| 1,967,869
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int num[5];
for ( int i = 0; i < 5; i++ ) cin >> num[i];
sort(num,num+5);
reverse(num,num+5);
cout << num[0] << " " << num[1] << " " << num[2] << " " <<
num[3] << " " << num[4] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using db = double;
using ld = long double;
template <typename T> using V = vector<T>;
template <typename T> using VV = vector<vector<T>>;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(), (v).end()
#define siz(v) (ll)(v).size()
#define rep(i, a, n) for(ll i = a; i < (ll)(n); ++i)
#define repr(i, a, n) for(ll i = n - 1; (ll)a <= i; --i)
#define ENDL '\n'
typedef pair<int, int> Pi;
typedef pair<ll, ll> PL;
constexpr ll mod = 1000000007;
constexpr ll INF = 1000000099;
constexpr ll LINF = (ll)(1e18 + 99);
const ld PI = acos((ld)-1);
const vector<ll> dx = {-1, 1, 0, 0}, dy = {0, 0, -1, 1};
template <typename T, typename U> inline bool chmin(T& t, const U& u) {
if(t > u) {
t = u;
return 1;
}
return 0;
}
template <typename T, typename U> inline bool chmax(T& t, const U& u) {
if(t < u) {
t = u;
return 1;
}
return 0;
}
template <typename T> inline T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template <typename T, typename Y> inline T mpow(T a, Y n) {
T res = 1;
for(; n; n >>= 1) {
if(n & 1) res = res * a;
a = a * a;
}
return res;
}
template <typename T, typename Y>
ostream& operator<<(ostream& os, const pair<T, Y>& p) {
return os << "{" << p.fs << "," << p.sc << "}";
}
template <typename T> ostream& operator<<(ostream& os, const V<T>& v) {
os << "{";
for(auto e : v) os << e << ",";
return os << "}";
}
template <typename... Args> void debug(Args&... args) {
for(auto const& x : {args...}) { cerr << x << ' '; }
cerr << ENDL;
}
template <typename T> struct UnionFind {
vector<T> Parent;
UnionFind(T N) { Parent = vector<T>(N, -1); }
T root(T A) {
if(Parent[A] < 0) return A;
return Parent[A] = root(Parent[A]);
}
T size(T A) { return -Parent[root(A)]; }
bool connect(T A, T B) {
A = root(A);
B = root(B);
if(A == B) return false;
if(size(A) < size(B)) swap(A, B);
Parent[A] += Parent[B];
Parent[B] = A;
return true;
}
bool same(T A, T B) { return root(A) == root(B); }
};
signed main() {
cin.tie(0);
cerr.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll n, q;
cin >> n >> q;
UnionFind<int> uf(n);
rep(i,0,q){
ll t,u,v;cin>>t>>u>>v;
if(t==0)uf.connect(u,v);
else cout<<uf.same(u,v)<<ENDL;
}
}
| 0
| 46,362,751
|
#include <stdio.h>
int main(void)
{
int r,K,x,i;
scanf("%d%d%d",&r,&K,&x);
for(i=0;i<10;i++){
x=x*r-K;
printf("%d\n",x);
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define nl '\n'
#define st first
#define nd second
#define ins insert
#define pb push_back
#define mp make_pair
#define hashmap unordered_map
#define hashset unordered_set
signed main(){
int x, y; cin >> x >> y;
bool flag = false;
for (int i = 0; i <= x; i++){
if (2*i + 4*(x - i) == y){
flag = true;
}
}
if (flag) cout << "Yes";
else cout << "No";
}
| 0
| 53,743,940
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int A, B;
cin >> A >> B;
if(A <= 8 && B <= 8) {
cout << "Yay!" << endl;
} else {
cout << ":(" << endl;
}
}
|
#pragma GCC optimize("Ofast")
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
#define double long double
using datas=pair<ll,ll>;
using ddatas=pair<double,double>;
using tdata=pair<ll,datas>;
using vec=vector<ll>;
using mat=vector<vec>;
using pvec=vector<datas>;
using pmat=vector<pvec>;
#define For(i,a,b) for(i=a;i<(ll)b;++i)
#define bFor(i,b,a) for(i=b,--i;i>=(ll)a;--i)
#define rep(i,N) For(i,0,N)
#define rep1(i,N) For(i,1,N)
#define brep(i,N) bFor(i,N,0)
#define brep1(i,N) bFor(i,N,1)
#define all(v) (v).begin(),(v).end()
#define allr(v) (v).rbegin(),(v).rend()
#define vsort(v) sort(all(v))
#define vrsort(v) sort(allr(v))
#define endl "\n"
#define eb emplace_back
#define print(v) cout<<v<<endl
#define printyes cout<<"Yes"<<endl
#define printno cout<<"No"<<endl
#define printYES cout<<"YES"<<endl
#define printNO cout<<"NO"<<endl
#define output(v) do{bool f=0;for(auto outi:v){cout<<(f?" ":"")<<outi;f=1;}cout<<endl;}while(0)
#define matoutput(v) do{for(auto outimat:v)output(outimat);}while(0)
const ll mod=998244353;
const ll inf=1LL<<60;
const double PI = acos(-1);
const double eps = 1e-9;
template<class T> inline bool chmax(T& a,T b){bool x=a<b;if(x)a=b;return x;}
template<class T> inline bool chmin(T& a,T b){bool x=a>b;if(x)a=b;return x;}
void startupcpp(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(15);
}
double distance(ddatas x,ddatas y){
double a=x.first-y.first,b=x.second-y.second;
return sqrt(a*a+b*b);
}
ll modinv(ll a) {
ll b=mod,u=1,v=0,t;
while(b){
t=a/b;
a-=t*b; swap(a,b);
u-=t*v; swap(u,v);
}
return (u+mod)%mod;
}
ll moddevide(ll a,ll b){return (a*modinv(b))%mod;}
vec modncrlistp,modncrlistm;
ll modncr(ll n,ll r){
if(n<r)return 0;
ll i,size=modncrlistp.size();
if(size<=n){
modncrlistp.resize(n+1);
modncrlistm.resize(n+1);
if(!size){
modncrlistp[0]=modncrlistm[0]=1;
size++;
}
For(i,size,n+1){
modncrlistp[i]=modncrlistp[i-1]*i%mod;
modncrlistm[i]=modinv(modncrlistp[i]);
}
}
return modncrlistp[n]*modncrlistm[r]%mod*modncrlistm[n-r]%mod;
}
ll modpow(ll a,ll n){
ll res=1;
while(n>0){
if(n&1)res=res*a%mod;
a=a*a%mod;
n>>=1;
}
return res;
}
ll gcd(ll a,ll b){if(!b)return abs(a);return (a%b==0)?abs(b):gcd(b,a%b);}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
ll countdigits(ll n){
ll ans=0;
while(n){n/=10;ans++;}
return ans;
}
ll sumdigits(ll n){
ll ans=0;
while(n){ans+=n%10;n/=10;}
return ans;
}
vector<int> topcoder(){
vector<int> v;
string s;
while(1){
cin>>s;
int i=s[0]=='{',x=0;
while(s[i]>='0'&&s[i]<='9'){
x=x*10+s[i]-'0';
++i;
}
v.eb(x);
if(s[i]=='}')break;
}
return v;
}
mat ncrlis(51,vec(51,-1));
ll ncr(ll n,ll r){
if(n==r||r==0)return 1;
if(~ncrlis[n][r])return ncrlis[n][r];
return ncrlis[n][r]=ncr(n-1,r-1)+ncr(n-1,r);
}
int main(){
ll i,N,f,ans=0,cnt[2]={};
cin>>N>>f;
while(N--){
cin>>i;
cnt[i&1]++;
}
rep(i,cnt[1]+1){
if((i&1)==f)ans+=ncr(cnt[1],i);
}
print((ans<<cnt[0]));
}
| 0
| 11,338,322
|
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <math.h>
#include <vector>
#include <string>
#include <sstream>
#include <numeric>
#include <set>
#include <map>
#define rep(i, j) for(int i = 0; i < j; i++)
#define all(i) i.begin(), i.end()
#define ll long long
#define bl bool
#define nn printf("\n");
#define mod 1000000007
using namespace std;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
vector<char> right = { 'p', 'o', 'i', 'u', 'y', 'l', 'k', 'j', 'h', 'm', 'n' };
while (1)
{
string str; cin >> str;
vector<int> move((int)str.size() + 5, 0);
int cnt = 0;
if (str[0] == '#') { return 0; }
rep(i, (int)str.size())
{
if (count(all(right), str[i]) > 0){ move[i] = 1; }
}
for (int i = 1; i < (int)str.size(); i++)
{
if (move[i - 1] != move[i]){ cnt += 1; }
}
printf("%d\n", cnt);
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i < (n); i++)
using namespace std;
using ll = long long;
int N,M;
int DFS(vector<vector<int>> &load, int now, vector<bool> visited){
bool end=true;
for(int i=1; i<=N; i++){
if(visited[i]==false){
end=false;
}
}
if(end) return 1;
int ret=0;
for(int i:load[now]){
if(visited[i]) continue;
visited[i]=true;
ret += DFS(load, i, visited);
visited[i]=false;
}
return ret;
}
int main(){
cin >> N >> M;
vector<vector<int>> load(N+1,vector<int>());
rep(z,M){
int a,b;
cin >> a >> b;
load[a].push_back(b);
load[b].push_back(a);
}
vector<bool> visited(N+1,false);
visited[1] = true;
int ans = DFS(load, 1, visited);
cout << ans << endl;
}
| 0
| 25,013,356
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define ff first
#define Shazam ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define ss second
#define all(c) c.begin(),c.end()
#define endl "\n"
#define test() int t; cin>>t; while(t--)
#define fl(i,a,b) for(int i = a ; i <b ;i++)
#define get(a) fl(i,0,a.size()) cin>>a[i];
#define pra(a) fl(i,0,a.size()) cout<<a[i]<<" "; cout<<endl;
#define pr(a,n) fl(i,0,n) cout<<a[i]<<" "; cout<<endl;
const ll INF = 2e18;
const int inf = 2e9;
const int mod1 = 1e9 + 7;
int main(){
Shazam;
ll n,m; cin>>n>>m;
ll l1 = 1, l2 = 1;
int p = -1;
for(int i = 0; i < n; i++){
ll k; cin>>k;
k>>=1;
l1 = l1*k/__gcd(l1,k);
int cnt = 0;
while(k%2==0){
k/=2;
cnt++;
}
if(!i){
p = cnt;
}
if(p!=cnt){
cout<<0<<endl;
return 0;
}
}
cout<<m/l1 - m/(2*l1)<<endl;
return 0;
}
|
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define revrep(i, n) for(ll i = n-1; i >= 0; i--)
#define pb push_back
#define f first
#define s second
ll INFL = 1LL << 60;
int INF = 1 << 30;
ll MOD = 1e9 + 7;
vector<ll> dy = {0, 0, 1, -1, 1, 1, -1, -1, 0};
vector<ll> dx = {1, -1, 0, 0, 1, -1, 1, -1, 0};
ll max(ll a, ll b){return (a > b) ? a : b;}
ll min(ll a, ll b){return (a < b) ? a : b;}
ll pow_long(ll x, ll k){
ll res = 1;
while(k > 0){
if(k % 2) res *= x;
x *= x;
k /= 2;
}
return res;
}
ll pow_mod(ll x, ll k){
x %= MOD; x += MOD; x %= MOD;
ll res = 1;
while(k > 0){
if(k % 2){
res *= x; res %= MOD;
}
x *= x; x %= MOD;
k /= 2;
}
return res;
}
ll inverse(ll x){return pow_mod(x, MOD - 2);};
ll gcd(ll a, ll b){
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll x, ll y){return x / gcd(x, y) * y % MOD;};
int main(){
ll N, K; cin >> N >> K;
vector<ll> A(N); rep(i, N) cin >> A[i];
vector<ll> sum(N+1), sumplus(N+1);
sum[0] = 0;
rep(i, N) sum[i+1] = sum[i] + A[i];
sumplus[0] = 0;
rep(i, N) sumplus[i+1] = sumplus[i] + max(0, A[i]);
ll ans = 0;
rep(i, N-K+1){
ll res = 0;
res += sumplus[i];
res += sumplus[N] - sumplus[i+K];
ans = max(ans, res);
res += sum[i+K] - sum[i];
ans = max(ans, res);
}
cout << ans << endl;
}
| 0
| 50,058,695
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
int par[100005];
int rnk[100005];
int cnt[100005];
void init(int n) {
for (int i=0; i<n; i++) {
par[i]=i;
rnk[i]=0;
cnt[i]=1;
}
}
int find(int x) {
if (par[x]==x) {
return x;
}
else {
return par[x]=find(par[x]);
}
}
void unite(int x,int y) {
x=find(x);
y=find(y);
if (x==y) return;
if (rnk[x]<rnk[y]) {
par[x]=y;
cnt[y]+=cnt[x];
}
else {
par[y]=x;
cnt[x]+=cnt[y];
if (rnk[x]==rnk[y]) rnk[x]++;
}
}
bool same(int x, int y) {
return find(x)==find(y);
}
int main(){
int n,m;
cin>>n>>m;
int p[100005];
rep(i,n){
int a;
cin>>a;
a--;
p[a]=i;
}
init(n);
rep(i,m){
int x,y;
cin>>x>>y;
x--; y--;
unite(x,y);
}
int ans=0;
rep(i,n){
if(find(i)==find(p[i])) ans++;
}
cout<<ans<<endl;
return 0;
}
|
#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 MOD 1000000007
int main(){
int n,m;
cin >> n >> m;
vector<string> res(m,"");
vector<vector<Pl>> v(n+1);
rep(i,m){
int p,y;cin >> p >> y;
v[p].push_back(make_pair(y,i));
}
rep(i,n+1)sort(ALL(v[i]));
rep(i,n+1){
int ss = 0;
int kk = i;
while(kk)ss++,kk/=10;
string k = "";
rep(l,6-ss)k += '0';
k += to_string(i);
for(int j = 0;j < v[i].size();j++){
res[v[i][j].second] += k;
kk = j+1;
ss = 0;
while(kk)ss++,kk/= 10;
rep(l,6-ss)res[v[i][j].second] += '0';
res[v[i][j].second] += to_string(j+1);
}
}
rep(i,m)cout << res[i] << endl;
return 0;
}
| 0
| 59,753,158
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <cmath>
#include <climits>
#include <iomanip>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
int main(){
string s;
cin >> s;
cout << s.substr(0,5) << " " << s.substr(6,7) << " " << s.substr(14,5) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i,m,n) for(int i=(m); i<(int)(n); i++)
#define RREP(i,m,n) for(int i=(int)((n)-1); i>=m; i--)
#define rep(i,n) REP(i,0,n)
#define rrep(i,n) RREP(i,0,n)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define fi first
#define se second
#define debug(...) {cerr<<"[L"<<__LINE__<<"] "; _debug(__VA_ARGS__);}
template<typename T>
string join(const vector<T>&v, string del=", "){ stringstream s;
for(auto x : v) s << del << x; return s.str().substr(del.size());
}
template<typename T>
ostream& operator<<(ostream& o, const vector<T>&v){
if(v.size()) o << "[" << join(v) << "]"; return o;
}
template<typename T>
ostream& operator<<(ostream& o, const vector<vector<T> >&vv){
int l = vv.size();
if(l){ o<<endl; rep(i,l) o << (i==0 ? "[ " : ",\n " ) << vv[i] << (i==l-1 ? " ]" : ""); }
return o;
}
template<typename T1, typename T2>
ostream& operator<<(ostream& o, const pair<T1, T2>& p){
return o << "(" << p.first << ", " << p.second << ")";
}
inline void _debug(){cerr<<endl;}
template<class First, class... Rest>
void _debug(const First& first, const Rest&... rest){cerr<<first<<" ";_debug(rest...);}
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
const double PI = (1*acos(0.0));
const double EPS = 1e-9;
const int INF = 0x3f3f3f3f;
const ll INFL = 0x3f3f3f3f3f3f3f3fLL;
const ll mod = 1e9 + 7;
inline void finput(string filename) {
freopen(filename.c_str(), "r", stdin);
}
int main(){
ios_base::sync_with_stdio(0);
ll n,m,d;
cin >> n >> m >> d;
if(d == 0){
cout << fixed << setprecision(10) << (n-d)*(m-1) / (double)(n*n) << endl;
}else{
cout << fixed << setprecision(10) << 2*(n-d)*(m-1) / (double)(n*n) << endl;
}
return 0;
}
| 0
| 99,868,849
|
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#define ll long long
using namespace std;
template <class T>
inline void rd(T &x)
{
x=0; char c=getchar(); int f=1;
while(!isdigit(c)){if(c=='-')f=-1; c=getchar();}
while(isdigit(c)) x=x*10-'0'+c,c=getchar(); x*=f;
}
const int N=2e5+10,mod=1e9+7;
char str[N];
int n;
int main() {
rd(n);
scanf("%s",str+1);
int cnt=0,ans=1;
int cur=0;
for(int i=1;i<=2*n;++i) {
int c=str[i]=='B';
if(c!=cur) cnt++;
else ans=ans*(ll)cnt%mod,cnt--;
cur^=1;
}
if(cnt!=0) ans=0;
for(int i=1;i<=n;++i) ans=ans*(ll)i%mod;
printf("%d",ans);
return 0;
}
|
#include<iostream>
using namespace std;
int main()
{
long long min, max;
long long sum = 0;
int n;
cin >> n;
int num[n];
for( int i = 0; i < n; i++ )
{
cin >> num[i];
sum += num[i];
}
min = num[0];
max = num[0];
for( int i = 1; i < n; i++ )
{
if( min > num[i] )
min = num[i];
if( max < num[i] )
max = num[i];
}
cout << min << " " << max << " " << sum << endl;
return 0;
}
| 0
| 57,427,903
|
#include<iostream>
using namespace std;
int main(){
int a,b,c;
for (a=1; a<10; a++){
for (b=1; b<10; b++){
c=a*b;
cout << a <<"x"<< b <<"="<< c <<"\n";
}
}
return 0;
}
|
#pragma GCC optimize ("O3")
#include <iostream>
#include <iomanip>
#include <istream>
#include <ostream>
#include <sstream>
#include <iterator>
#include <vector>
#include <algorithm>
#include <queue>
#include <deque>
#include <list>
#include <stack>
#include <map>
#include <unordered_map>
#include <set>
#include <utility>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <string>
#include <ctime>
#include <cctype>
#include <cstdlib>
#define IINF 10e8
#define INF 10e16
#define MOD 1000000007
#define mod 1000000007
#define rep(i, a, n) for (ll i = a; i < (ll)(n); i++)
#define Endl endl
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define mmax(x,y)(x>y?x:y)
#define mmin(x,y)(x<y?x:y)
#define chmax(x,y) x=mmax(x,y)
#define chmin(x,y) x=mmin(x,y)
#define all(x) (x).begin(),(x).end()
#define siz(x) (ll)(x).size()
#define PI acos(-1.0)
using namespace std;
typedef long long int ll;
typedef long long int LL;
typedef pair<ll,ll>Pll;
typedef pair<int,int>Pin;
long long GCD(long long a, long long b) { return b ? GCD(b, a%b) : a; }
long long LCM(long long a, long long b) {return a/GCD(a,b)*b;}
int dx[8]={-1,0,1,0,1,1,-1,-1};
int dy[8]={0,-1,0,1,1,-1,1,-1};
char dir[4]={'u','l','d','r'};
ll cmp1(pair<ll,string>a,pair<ll,string> b){
if(a.fi!=b.fi)
return a.fi<b.fi;
else
return a.se<b.se;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n,m,k;cin>>n>>m>>k;
map<int,int>mm;
for(int i=0;i<=n;i++){
for(int j=0;j<=m;j++){
int black=0;
black=i*m+j*n-2*i*j;
mm[black]++;
}
}
if(mm[k]==0)cout<<"No"<<endl;
else cout<<"Yes"<<endl;
return 0;
}
| 0
| 46,756,597
|
#include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <functional>
#include <numeric>
#include <cmath>
#include <climits>
#include <limits>
#include <cfloat>
#include <iomanip>
#include <sstream>
#include <cstring>
#include <cctype>
#include <fstream>
#include <ctime>
#define rep(i,n) for(int i=0;i<(n);i++)
#define ALL(A) A.begin(), A.end()
#define EPS 1e-9
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
double cross (double xa, double ya, double xb, double yb )
{
return (xa*yb - xb*ya );
}
int main()
{
int n;
scanf ("%d", &n );
rep (i, n ){
double x1, y1, x2, y2, x3, y3, x4, y4;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4;
double d = cross (x2-x1, y2-y1, x4-x3, y4-y3 );
if (fabs (d ) < EPS ){
cout << "YES" << endl;
}else{
cout << "NO" << endl;
}
}
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <vector>
#define MOD 1000000007
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
template < typename T >
ostream &operator<<(ostream &os, const vector< T > &A) {
for (int i = 0; i < A.size(); i++)
os << A[i] << " ";
os << endl;
return os;
}
template <>
ostream &operator<<(ostream &os, const vector< vector< int > > &A) {
int N = A.size();
int M;
if (N > 0)
M = A[0].size();
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++)
os << A[i][j] << " ";
os << endl;
}
return os;
}
typedef pair< int, int > pii;
typedef long long ll;
struct edge {
int from, to, d, c;
edge(int _from = 0, int _to = 0, int _d = 0, int _c = 0) {
from = _from;
to = _to;
d = _d;
c = _c;
}
bool operator<(const edge &rhs) const {
return (d == rhs.d) ? (c < rhs.c) : (d < rhs.d);
}
};
typedef vector< edge > edges;
typedef vector< edges > graph;
struct flow {
int to, cap, rev, cost;
flow(int to = 0, int cap = 0, int rev = 0, int cost = 0) : to(to), cap(cap), rev(rev), cost(cost) {}
};
typedef vector< vector< flow > > flows;
const int di[4] = {0, -1, 0, 1};
const int dj[4] = {-1, 0, 1, 0};
const int ci[5] = {0, 0, -1, 0, 1};
const int cj[5] = {0, -1, 0, 1, 0};
const ll LINF = LLONG_MAX / 2;
const int INF = INT_MAX / 2;
const double PI = acos(-1);
template < typename T, typename U >
bool chmin(T &x, const U &y) {
if (x > y) {
x = y;
return true;
}
return false;
}
template < typename T, typename U >
bool chmax(T &x, const U &y) {
if (x < y) {
x = y;
return true;
}
return false;
}
struct initializer {
initializer() {
cout << fixed << setprecision(11);
}
};
initializer _____;
int compress(vector< int > &x1, int W) {
vector< int > xs;
int N = x1.size();
for (int i = 0; i < N; i++) {
int tx1 = x1[i];
xs.push_back(tx1);
}
sort(xs.begin(), xs.end());
xs.erase(unique(xs.begin(), xs.end()), xs.end());
for (int i = 0; i < N; i++) {
x1[i] = lower_bound(xs.begin(), xs.end(), x1[i]) - xs.begin() + 1;
}
return (int)xs.size();
}
int N, M, K, T, Q;
signed main() {
int N, A, B;
cin >> N >> A >> B;
if (A * B < N || N + 1 < A + B) {
cout << -1 << endl;
return 0;
}
vector< int > ans(N);
ans.resize(0);
int k = A * B - N;
rep(i, A * B) {
if (k && i % A > 0 && i / A > 0)
if (k >= A - 1) {
k -= A - 1;
i += A - 2;
} else
k--;
else
ans.push_back((i % A) * B + (B - i / A));
}
compress(ans, N);
cout << ans;
return 0;
}
| 0
| 55,581,840
|
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,x[1010],y[1010];
int ansa[40],ansb[40];
void work(int w,int ans[])
{
int f=1;
if(w<0)f=-1,w=-w;
for(int i=30,j;i>=0;--i)
if(!(w>>i&1))
{
j=i-1;
while(~j&&!(w>>j&1))--j;
if(~j)
{
for(int k=j;k<i;++k)ans[k]=-1;ans[i]=1;
}
else
{
for(int k=0;k<i;++k)ans[k]=-1;ans[i]=1;ans[31]=-1;
}
i=j;
}
else ans[i]=1;
if(f==-1)for(int i=0;i<=31;++i)ans[i]=-ans[i];
}
int main()
{
scanf("%d",&n);
int a,b;
for(int i=1;i<=n;++i)
{
scanf("%d %d",&a,&b);
x[i]=a+b,y[i]=a-b;
}
for(int i=2;i<=n;++i)if((x[i]&1)!=(x[1]&1))return printf("-1"),0;
int m=31+(x[1]%2==0);
printf("%d\n",m);
for(int i=0;i<=30;++i)printf("%d ",1<<i);
if(x[1]%2==0)printf("%d ",1);
printf("\n");
for(int i=1;i<=n;++i)
{
work(x[i],ansa);
work(y[i],ansb);
for(int j=0;j<m;++j)
{
if(ansa[j]==1)
{
if(ansb[j]==1)putchar('R');
else putchar('U');
}
else
{
if(ansb[j]==1)putchar('D');
else putchar('L');
}
}
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll int64_t
const double PI = 3.1415926535897932384;
const int INF = 1000000000;
const ll LINF = 1000000000000000;
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZABC";
const string abc = "abcdefghijklmnopqrstuvwxyzabc";
int ctoi(char c){
if (c == '0') {
return 0;
}
if (c == '1') {
return 1;
}
if (c == '2') {
return 2;
}
if (c == '3') {
return 3;
}
if (c == '4') {
return 4;
}
if (c == '5') {
return 5;
}
if (c == '6') {
return 6;
}
if (c == '7') {
return 7;
}
if (c == '8') {
return 8;
}
if (c == '9') {
return 9;
}
return -1;
}
bool PN(int x) {
if (x <= 1) {
return false;
}
if (x == 2) {
return true;
}
for (int i = 2; i < sqrt(x) + 1; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
int main() {
string S;
cin >> S;
if (S.at(0) != 'A') {
cout << "WA" << endl;
}
else {
int SS = S.size();
int C = 0;
int B = 0;
for (int i = 2; i < SS - 1; i++) {
if (S.at(i) == 'C') {
C++;
}
for (int j = 0; j < 26; j++) {
if (S.at(i) == ABC.at(j)) {
B++;
}
}
}
for (int j = 0; j < 26; j++) {
if (S.at(1) == ABC.at(j)) {
B++;
}
if (S.at(SS - 1) == ABC.at(j)) {
B++;
}
}
if (C != 1) {
cout << "WA" << endl;
}
else if (B != C) {
cout << "WA" << endl;
}
else {
cout << "AC" << endl;
}
}
}
| 0
| 65,167,898
|
#include <bits/stdc++.h>
#include <stdio.h>
using namespace std;
#define inputInt(a) int a; cin >> a;
#define inputInt2(a,b) int a; int b; cin >> a >> b;
#define inputInt3(a,b,c) int a; int b; int c; cin >> a >> b >> c;
#define inputLong(a) long a;cin >> a;
#define inputIntArray(a,N) int a[N];for(int i=0;i<N;i++){cin >> a[i];}
#define inputLongArray(a,N) long a[N];for(int i=0;i<N;i++){cin >> a[i];}
#define inputIntArray2(a,b,N) int a[N]; int b[N]; for(int i=0;i<N;i++){cin >> a[i] >> b[i];}
#define output(answer) cout << answer << endl;
#define fN(i,N) for(int i=0; i<N; i++)
#define fSE(i,s,e) for(int i=s; i<=e; i++)
#define ll long long
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define FOR(i,N) for(int i=0; i<N; i++)
#define cinv(v,N) vector<int> v(N); for(int i=0; i<N; i++){ cin >> v[i]; }
#define mt make_tuple
#define vll vector<long long int>
#define vvll vector<vector<long long int>>
#define all(v) (v).begin(),(v).end()
#define show(v) FOR(i,v.size()){ cout << v[i] << " "; } cout << endl;
#define showshow(v) FOR(i,v.size()){ FOR(j,v[i].size()){ cout << v[i][j] << " "; } cout << endl; }
const ll MOD = 1e9+7;
const ll MOD2 = 998244353;
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; }
const int LIMIT = 1e6;
vector<ll> FacMod(LIMIT), InvMod(LIMIT), FacInvMod(LIMIT);
const int dpComTableLIMIT = 3e3+1;
vector<vector<ll>> Com(dpComTableLIMIT,vector<ll>(dpComTableLIMIT,0));
const int ComKTableLIMIT = 1e7;
vector<ll> ComK(ComKTableLIMIT);
void DPComInit(){
for(int i=0; i<dpComTableLIMIT; i++){ Com[i][0] = 1; }
for(int i=1; i<dpComTableLIMIT; i++){
for(int j=1; j<dpComTableLIMIT; j++){
Com[i][j] = (Com[i-1][j-1]+Com[i-1][j])%MOD;
}
}
}
void ComKInit(ll N){
for(int i=0; i<=ComKTableLIMIT; i++){
if(0<i && i<=N/2){
ComK[i] = (ComK[i-1]*(N-i+1)/i)%MOD;
}else if(i==0){
ComK[i] = 1;
}else if(N/2<i && i<=N){
ComK[i] = ComK[N-i];
}else{
ComK[i] = -1;
}
}
}
void ComInit(){
FacMod[0] = FacMod[1] = 1;
InvMod[0] = 0; InvMod[1] = 1;
FacInvMod[0] = FacInvMod[1] = 1;
for(int i=2; i<LIMIT; i++){
FacMod[i] = FacMod[i-1]*i%MOD;
InvMod[i] = -InvMod[MOD%i]*(MOD/i)%MOD + MOD;
FacInvMod[i] = FacInvMod[i-1] * InvMod[i]%MOD;
}
}
ll ComMod(int n, int k){
if(n>=0 && k>=0 && n>=k){
return FacMod[n]*(FacInvMod[k]*FacInvMod[n-k]%MOD)%MOD;
}else{
return 0;
}
}
ll power(ll x, ll y){
if(y < 0){
return 0;
}else if(y == 0){
return 1LL;
}else if(y%2 == 0){
return power(x,y/2)*power(x,y/2);
}else{
return power(x,y-1)*x;
}
}
ll mpower(ll x, ll y, ll m){
if(y < 0){
return 0;
}else if(y == 0){
return 1LL;
}else if(y%2 == 0){
return mpower(x,y/2,m)*mpower(x,y/2,m)%m;
}else{
return mpower(x,y-1,m)*x%m;
}
}
bool compare_by_second(pair<ll,ll> a, pair<ll,ll> b){
return a.second != b.second ? a.second < b.second : a.first < b.first;
}
class UnionFind {
vector<int> parent;
vector<int> rank;
public:
UnionFind(int N);
int root(int x);
void unite(int x, int y);
bool isUnited(int x, int y);
int getRank(int x);
};
UnionFind::UnionFind(int N):parent(N),rank(N,1){
for(int i=0; i<N; i++){parent[i]=i;}
}
int UnionFind::root(int x){
if(parent[x] == x) return x;
return root(parent[x]);
}
void UnionFind::unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) return;
if(rank[x] >= rank[y]){parent[ry] = rx; rank[y]+=1;}
else{parent[rx] = ry; rank[x]+=1;}
}
bool UnionFind::isUnited(int x, int y) {
int rx = root(x);
int ry = root(y);
parent[x]=rx; parent[y]=ry;rank[x]=2;rank[y]=2;
return rx == ry;
}
int UnionFind::getRank(int x){
return rank[x];
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll H, W; cin >> H >> W;
vector<string> vs(H);
FOR(i,H){ cin >> vs[i]; }
vvll row(H,vll(W,0));
vvll col(H,vll(W,0));
FOR(i,H){
FOR(j,W){
if(vs[i][j] != '#'){
if(j==0 || vs[i][j-1] == '#'){
ll tmp = j;
ll cnt = 0;
while(tmp<W && vs[i][tmp] != '#'){
tmp++;
cnt++;
}
row[i][j] = cnt;
}else{
row[i][j] = row[i][j-1];
}
}else{
row[i][j] = 0;
}
}
}
FOR(j,W){
FOR(i,H){
if(vs[i][j] != '#'){
if(i==0 || vs[i-1][j]=='#'){
ll tmp = i;
ll cnt = 0;
while(tmp<H && vs[tmp][j]!='#'){
tmp++;
cnt++;
}
col[i][j] = cnt;
}else{
col[i][j] = col[i-1][j];
}
}else{
col[i][j] = 0;
}
}
}
ll ans = 0;
FOR(i,H){
FOR(j,W){
ans = max(ans,row[i][j]+col[i][j]-1);
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
int main(int argc, char **argv)
{
string str;
int count = 0, h[100] = { 0 };
while(cin >> str) {
if(str == "-") break;
cin >> count;
for(int i = 0; i < count; i++) cin >> h[i];
for(int i = 0; i < count; i++) {
for(int j = 0; j < h[i]; j++) str+= str[j];
for(int j = 0; j < h[i]; j++) str.erase(str.begin());
}
cout << str << endl;
for(int i = 0; i < count; i++) h[i] = 0;
}
return 0;
}
| 0
| 45,923,941
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vl;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<string> vs;
#define INF 1e9
#define LINF __LONG_LONG_MAX__
int main() {
int K, S; cin >> K >> S;
int cnt = 0;
for (int x = 0; x <= K; x++) {
for (int y = 0; y <= K; y++) {
int z = S - x - y;
if (z >= 0 && z <= K) cnt++;
}
}
cout << cnt << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(void){
ll n, k, ans = 0;
cin >> n >> k;
vector<ll> a(n); vector<vector<ll>> b(n, vector<ll>(n, 0));
queue<pair<int, int>> cur, nxt;
for (int i = 0; i < n; i++) cin >> a[i];
for (int l = 0; l < n; l++) for (int r = l; r < n; r++){
b[l][r] = b[l][max(0, r - 1)] + a[r];
cur.push({l, r});
}
auto count = [&](ll bit, bool update) -> ll{
ll cnt = 0, l, r, ok;
while (!cur.empty()){
tie(l, r) = cur.front(); cur.pop();
ok = (bit & b[l][r]);
if (ok) cnt++;
if (!update || ok) nxt.push({l, r});
}
swap(cur, nxt);
return cnt;
};
for (int nd = 40; nd >= 0; nd--){
ll bit = 1LL << nd;
if (count(bit, false) >= k) {
count(bit, true);
ans += bit;
}
}
cout << ans << endl;
return 0;
}
| 0
| 21,763,547
|
#include<bits/stdc++.h>
using namespace std;
#define LL long long
#define DD double
#define Pb push_back
#define Bp pop_back
#define Pf push_front
#define Fp pop_front
#define Ub upper_bound
#define Lb lower_bound
#define In insert
#define All(x) x.begin(), x.end()
#define mem(a, b) memset(a, b, sizeof(a))
#define fast ios_base::sync_with_stdio(0);cin.tie(0)
#define X first
#define Y second
#define mx1 10
#define mx2 110
#define mx3 1010
#define mx4 10010
#define mx5 100010
#define mx6 1000010
typedef vector<LL> Vl;
typedef vector<DD> Vd;
typedef vector<bool> Vb;
typedef vector<Vl> VVl;
typedef pair<LL, LL> Pll;
typedef pair<DD, DD> Pdd;
typedef vector<Pll> Vpl;
typedef vector<Pdd> Vpd;
typedef queue<LL> Ql;
typedef stack<LL> Sl;
typedef deque<LL> Dl;
LL _set(LL N, LL pos) {return N = N | (1 << pos);}
LL _reset(LL N, LL pos) {return N = N & ~(1 << pos);}
bool _check(LL N, LL pos) {return (bool)(N & (1 << pos));}
bool _upper(char a) {return a >= 'A' && a <= 'Z';}
bool _lower(char a) {return a >= 'a' && a <= 'z';}
bool _digit(char a) {return a >= '0' && a <= '9';}
LL dx[] = {1, -1, 0, 0, -1, -1, 1, 1};
LL dy[] = {0, 0, 1, -1, -1, 1, -1, 1};
LL a[2 * mx5];
int main()
{
int n;
cin >> n;
for(int i = 1; i <= n; i++)
cin >> a[i], a[i] -= i;
sort(a + 1, a + n + 1);
LL m1 = a[n / 2], m2 = a[n / 2 + 1], m3 = a[n / 2 - 1];
LL r1 = 0, r2 = 0, r3 = 0;
for(int i = 1; i <= n; i++){
r1 += abs(a[i] - m1);
r2 += abs(a[i] - m2);
r3 += abs(a[i] - m3);
}
cout << min(r1, min(r2, r3)) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rrep(i, n) for (ll i = (n - 1); i >= 0; --i)
#define blank(ans) cout << (ans) << " ";
#define mp(p, q) make_pair(p, q)
#define mt(p, q, r) make_tuple(p, q, r)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef string str;
typedef vector<ll> vll;
typedef vector<ld> vd;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<str> vs;
typedef vector<vector<ll>> vvll;
typedef vector<vector<ld>> vvd;
typedef vector<vector<bool>> vvb;
typedef vector<vector<char>> vvc;
typedef vector<vector<str>> vvs;
typedef vector<pair<ll, ll>> vpll;
typedef vector<tuple<ll, ll, ll>> vtlll;
const ld PI = acos(-1.0);
const ll MAX = 9000000000000000000;
const ll MIN = -9000000000000000000;
const ld DMAX = 4500;
const ld DMIN = -4500;
const ll MOD = 1000000007;
template <typename T>
void fin(T a)
{
cout << a << endl;
exit(0);
}
bool IsPrime(ll num)
{
if (num < 2)
return false;
else if (num == 2)
return true;
else if (num % 2 == 0)
return false;
ld sqrtNum = sqrt(num);
for (ll i = 3; i <= sqrtNum; i += 2)
{
if (num % i == 0)
return false;
}
return true;
}
void Main()
{
str s; ll w; cin >> s >> w;
rep(i, s.size())
{
if(i % w == 0) cout << s[i];
}
cout << endl;
}
int main()
{
ifstream in("text.txt");
cin.rdbuf(in.rdbuf());
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
Main();
return 0;
}
| 0
| 99,965,685
|
#include <vector>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <algorithm>
#include <utility>
#include <functional>
#include <sstream>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <climits>
#include <cassert>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define EACH(t,i,c) for(t::iterator i=(c).begin(); i!=(c).end(); ++i)
const double EPS = 1e-10;
const double PI = acos(-1.0);
int main(){
ll N,M;
while(cin>>N>>M,N|M){
vi D(N),P(N);
ll total=0;
REP(i,N){
cin>>D[i]>>P[i];
total+=P[i]*D[i];
}
vector<pii> p(N);
REP(i,N){
p[i]=make_pair(P[i],i);
}
sort(RALL(p));
ll ans=total;
REP(i,N){
int ii=p[i].second;
if(M-D[ii]>=0){
M-=D[ii];
ans-=P[ii]*D[ii];
}else{
ans-=M*P[ii];
M=0;
}
if(M==0){
break;
}
}
cout<<ans<<endl;
}
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define all(x) (x).begin(),(x).end()
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template < typename T > string tost( const T& n ) { ostringstream stm; stm << n; return stm.str();}
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1;} return 0;}
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1;} return 0;}
int const INF = 1001001001;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int x,y;
cin >> x >> y;
int ans;
if(x == 0) {
if(y >= 0) ans = y;
else ans = abs(y)+1;
}
else if(y == 0) {
if(x < 0) ans = abs(x);
else ans = x+1;
}
else {
if(abs(x) < abs(y)) {
int cnt = 0;
if(x < 0) cnt++;
if(y < 0) cnt++;
ans = abs(y) - abs(x) + cnt;
}
else if(abs(x) > abs(y)) {
int cnt = 0;
if(x > 0) cnt++;
if(y > 0) cnt++;
ans = abs(x) - abs(y) + cnt;
}
else {
if(x == y) ans = 0;
else ans = 1;
}
}
cout << ans << endl;
return 0;
}
| 0
| 72,596,988
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using p = pair<int,int>;
int main() {
int N; cin >> N;
ll L[100];
L[0] = 2;
L[1] = 1;
for(int i = 2; i <= N; i++){
L[i] = L[i-1] + L[i-2];
}
cout << L[N] << endl;
return 0;
}
|
# include <bits/stdc++.h>
# define rep(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
# define reps(i, n) for(int i=1, i##_len=(n); i<=i##_len; ++i)
# define rrep(i, n) for(int i=((int)(n)-1); i>=0; --i)
# define rreps(i, n) for(int i=((int)(n)); i>0; --i)
# define ALL(x) (x).begin(), (x).end()
# define SZ(x) ((int)(x).size())
# define pb push_back
# define mp make_pair
# define optimize_cin() cin.tie(0); ios::sync_with_stdio(false)
using namespace std;
using ll = long long;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int migi[2002][2002];
int hidari[2002][2002];
int ue[2002][2002];
int shita[2002][2002];
int main(){
int h, w; cin >> h >> w;
vector<vector<char>> v(h, vector<char> (w));
rep(i, h)rep(j, w) cin >> v[i][j];
int ans = 0;
rep(i, h){
rep(j, w){
if(v[i][j]=='#') migi[i][j] = 0;
else if(j == 0) migi[i][j] = 1;
else migi[i][j] = migi[i][j-1] + 1;
}
}
rep(i, h){
rrep(j, w){
if(v[i][j]=='#') hidari[i][j] = 0;
else if(j == w-1) hidari[i][j] = 1;
else hidari[i][j] = hidari[i][j+1] + 1;
}
}
rep(j, w){
rep(i, h){
if(v[i][j]=='#') ue[i][j] = 0;
else if(i == 0) ue[i][j] = 1;
else ue[i][j] = ue[i-1][j] + 1;
}
}
rep(j, w){
rrep(i, h){
if(v[i][j]=='#') shita[i][j] = 0;
else if(i == h-1) shita[i][j] = 1;
else shita[i][j] = shita[i+1][j] + 1;
}
}
rep(i, h) {
rep(j, w){
if(v[i][j]=='#') continue;
chmax(ans, ue[i][j] + shita[i][j] + hidari[i][j] + migi[i][j] - 3);
}
}
cout << ans << endl;
}
| 0
| 5,283,405
|
#include<bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define rep2(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define rep_inv(i, n, m) for(int i = (int)(n); i > (int)(m); i--)
using namespace std;
using ll = long long;
using vl = vector<ll>;
using vc = vector<char>;
using vvl = vector<vl>;
using vvc = vector<vc>;
using pll = pair<ll, ll>;
using vpll = vector<pll>;
int main(){
ll A, B, C, D;
cin >> A >> B >> C >> D;
cout << min(A, B) + min(C, D) << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
map<int,int> mp;
int MAX = 0;
int MIN = 1e9;
for(int i=0; i<N; i++){
int x;
cin >> x;
mp[x]++;
MAX = max(MAX,x);
MIN = min(MIN,x);
}
bool flag = true;
int now = MIN-1;
for(auto itr = mp.begin(); itr != mp.end(); itr++){
int x = itr->first;
int y = itr->second;
if(x != now+1){
flag = false;
}
if(x == MIN){
if(MAX %2 == 1){
if(y != 2){
flag = false;
}
}
else{
if(y != 1){
flag = false;
}
}
}
if(x == MAX){
if(y == 1){
flag = false;
}
}
now = x;
}
if(flag){
cout << "Possible" << endl;
}
else{
cout << "Impossible" << endl;
}
}
| 0
| 22,673,468
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int s, w;
scanf("%d%d", &s, &w);
if (w >= s) printf("unsafe\n");
else printf("safe\n");
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i, N) for (int i = 0; i < (int)N; i++)
#define FOR(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define INF (1 << 30)
#define LLINF (1LL << 62)
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
constexpr int MOD = 1000000007;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <class T>
string to_string(T s);
template <class S, class T>
string to_string(pair<S, T> p);
string to_string(string s);
template <class T>
string to_string(T v) {
if (v.empty()) return "{}";
string ret = "{";
auto itr = v.begin(), next = ++v.begin();
for (; next != v.end(); ++itr, ++next) ret += to_string(*itr) + ",";
ret += to_string(*itr) + "}";
return ret;
}
template <class S, class T>
string to_string(pair<S, T> p) {
return "{" + to_string(p.first) + "," + to_string(p.second) + "}";
}
string to_string(string s) { return s; }
void debug() { cerr << endl; }
template <class Head, class... Tail>
void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail>
void print(Head head, Tail... tail) {
cout << to_string(head) << " ";
print(tail...);
}
struct IO {
#ifdef _WIN32
inline char getchar_unlocked() { return getchar(); }
inline void putchar_unlocked(char c) { putchar(c); }
#endif
string separator = " ";
template <class T>
inline void read(T &x) {
char c;
do {
c = getchar_unlocked();
} while (c != '-' && (c < '0' || '9' < c));
bool minus = 0;
if (c == '-') {
minus = 1;
c = getchar_unlocked();
}
x = 0;
while ('0' <= c && c <= '9') {
x *= 10;
x += c - '0';
c = getchar_unlocked();
}
if (minus) x = -x;
}
inline void read(string &x) {
char c;
do {
c = getchar_unlocked();
} while (c == ' ' || c == '\n');
x.clear();
do {
x += c;
c = getchar_unlocked();
} while (c != ' ' && c != '\n' && c != EOF);
}
template <class T>
inline void read(vector<T> &v) {
for (auto &x : v) read(x);
}
template <class Head, class... Tail>
inline void read(Head &head, Tail &... tail) {
read(head);
read(tail...);
}
template <class T>
inline void write(T x) {
char buf[32];
int p = 0;
if (x < 0) {
x = -x;
putchar_unlocked('-');
}
if (x == 0) putchar_unlocked('0');
while (x > 0) {
buf[p++] = (x % 10) + '0';
x /= 10;
}
while (p) {
putchar_unlocked(buf[--p]);
}
}
inline void write(string x) {
for (char c : x) putchar_unlocked(c);
}
inline void write(const char s[]) {
for (int i = 0; s[i] != 0; ++i) putchar_unlocked(s[i]);
}
template <class T>
inline void write(vector<T> v) {
for (auto itr = v.begin(); itr + 1 != v.end(); ++itr) {
write(*itr);
write(separator);
}
write(v.back());
}
template <class Head, class... Tail>
inline void write(Head head, Tail... tail) {
write(head);
write(separator);
write(tail...);
}
void set_separator(string s) { separator = s; }
} io;
int main() {
int N;
io.read(N);
vector<int> A(N);
io.read(A);
int ans = 0;
vector<Pii> P(N);
REP(i, N) P[i] = Pii(A[i], i);
sort(ALL(P));
REP(i, N) if (i % 2 != P[i].second % 2) ans++;
io.write(ans / 2);
io.write("\n");
return 0;
}
| 0
| 18,198,615
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <iomanip>
#include <utility>
#include <tuple>
#include <functional>
#include <bitset>
#include <cassert>
#include <complex>
#include <stdio.h>
#include <time.h>
#include <numeric>
#include <unordered_map>
#include <unordered_set>
# define ll int64_t
# define str string
# define rep(i,n) for(ll i=0;i<n;i++)
# define rrep(i,n) for(ll i=1;i<=n;i++)
# define ALL(x) (x).begin(), (x).end()
# define SZ(x) ((int)(x).size())
# define pb push_back
# define mod 1000000007
# define PI 3.141592653589793
# define vec vector
#define dump(x) cerr<<#x<<"="<<x<<endl
using namespace std;
#define INF 2000000000
#define MAX_V 10
bool compare_by_b(pair<string,ll> a,pair<string,ll> b){
if(a.second != b.second) return a.second<b.second;
else return a.first<b.first;
}
bool my_compare(pair<string,ll> a,pair<string,ll> b){
if(a.first != b.first) return a.first<b.first;
if(a.second != b.second) return a.second>b.second;
else return true;
}
ll modpow(ll a,ll n,ll mod1) {
ll res=1;
while(n>0){
if(n&1) res=res*a%mod1;
a = a*a%mod1;
n >>= 1;
}
return res;
}
ll factorial(ll n){
ll x=1;
rrep(i,n) (x*=i)%=mod;
return x;
}
ll gcd(ll a,ll b){
if (a%b == 0) return(b);
else return(gcd(b,a%b));
}
ll lcm(ll a,ll b){
return a/gcd(a,b)*b;
}
const ll MAX = 5100000;
const ll MOD = 1000000007;
ll fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll COM(ll n, ll k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
using graph = vector<vector<ll>>;
string divide[4]={"dream","dreamer","erase","eraser"};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin>>s;
reverse(ALL(s));
rep(i,4) reverse(ALL(divide[i]));
bool can=true;
for(ll i=0;i<s.size();){
bool can2=false;
rep(j,4){
string d=divide[j];
if(s.substr(i,d.size())==d){
can2=true;
i+=d.size();
}
}
if(!can2){
can=false;
break;
}
}
cout<<(can ? "YES":"NO")<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
typedef pair<int, int> P;
string s;
int main(){
cin >> s;
int n = s.size();
if(n == 26 && s == "zyxwvutsrqponmlkjihgfedcba"){
cout << -1 << endl;
}else if(n == 26){
string t = s;
next_permutation(s.begin(), s.end());
rep(i, n){
if(s.at(i) != t.at(i)){
s = s.substr(0, i + 1);
break;
}
}
cout << s << endl;
}else{
int memo[30];
rep(i, 30) memo[i] = 0;
rep(i, n){
memo[s.at(i) - 'a']++;
}
int c;
rep(i, 30){
if(memo[i] == 0){
c = 'a' + i;
break;
}
}
cout << s << (char)c << endl;
}
}
| 0
| 25,874,993
|
#include<iostream>
#include<cstdio>
#include<cctype>
using namespace std;
int main(){
string a;
while(1){
cin>>a;
if(a=="0")break;
int b=0;
for(int i=0;i<a.size();i++){
b += a[i]-'0';
}
cout<<b<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define N 100010
using namespace std;
int main(){
int n,a[N],i,j,ansa,ansb;
cin>>n;
for(i=0;i<n;i++)
cin>>a[i];
sort(a,a+n);
ansa=a[n-1];
for(i=n-2;i>=0;i--)
{
if(!i)
ansb=a[i];
if(min(a[i],a[n-1]-a[i])>=min(a[i-1],a[n-1]-a[i-1]))
{
ansb=a[i];
break;
}
}
cout<<ansa<<" "<<ansb<<endl;
return 0;
}
| 0
| 96,668,661
|
#include<iostream>
using namespace std;
int main(void){
char str[21]="";
cin >> str;
for(int i=20; i>=0; i--){
if(str[i]!='\0') cout << str[i];
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
typedef long double ld;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> indexed_set;
#define mp make_pair
#define pb push_back
#define pf push_front
#define ss second
#define ff first
#define sz(x) (int)x.size()
#define newl "\n"
#define vi vector<int>
#define pii pair<int, int>
#define vii vector<pii>
#define vl vector<ll>
#define pll pair<ll, ll>
#define vll vector<pll>
#define coutp cout << fixed << setprecision(12)
#define mem(x, val) memset(x, val, sizeof(x))
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define all(v) (v).begin(), (v).end()
const ld pi = 3.14159265359;
ll INF = 1e18 + 10;
ll MOD = 998244353;
ll mod = 1e9 + 7;
inline ll add(ll a, ll b, ll m)
{
if ((a + b) >= m)
return (a + b) % m;
return a + b;
}
inline ll mul(ll a, ll b, ll m)
{
if ((a * b) < m)
return a * b;
return (a * b) % m;
}
ll power(ll x, ll y, ll m)
{
ll res = 1;
x = x % m;
if (x == 0)
return 0;
while (y > 0)
{
if (y & 1)
res = (res * x) % m;
y = y >> 1;
x = (x * x) % m;
}
return res;
}
void solve()
{
ll s;
cin>>s;
vl dp(s+1,0);
dp[0]=1;
for(int i=3;i<=s;i++) {
for(int j=0;j<=i-3;j++) {
dp[i]=(dp[i]+dp[j])%mod;
}
}
cout<<dp[s];
}
int main()
{
fastio;
int t;
t = 1;
while (t-- > 0)
{
solve();
cout << newl;
}
return 0;
}
| 0
| 72,842,037
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < (n); i++)
#define REPS(i, n) for(int i = 1; i <= (n); i++)
#define RREP(i, n) for(int i = (n)-1; i >= 0; i--)
#define RREPS(i, n) for(int i = (n); i > 0; i--)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define mp make_pair
#define mt make_tuple
#define pb push_back
using ll = long long;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vs = vector<string>;
using vb = vector<bool>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const ll INFL = 1e18;
const double PI = 3.141592653589793;
const double EPS = 1e-9;
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; }
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
string A, B; cin >> A >> B;
if(A.length() > B.length())
{
cout << "GREATER" << endl;
return 0;
}
else if(A.length() < B.length())
{
cout << "LESS" << endl;
return 0;
}
else
{
REP(i, (int)A.length())
{
if(A[i] > B[i])
{
cout << "GREATER" << endl;
return 0;
}
if(A[i] < B[i])
{
cout << "LESS" << endl;
return 0;
}
}
}
cout << "EQUAL" << endl;
}
|
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pqueue priority_queue
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
ll N, D, A;
cin>>N>>D>>A;
vector<pair<ll, ll> > arr(N);
ll X, H;
for(int i=0;i<N;++i) {
cin>>X>>H;
arr[i] = mp(X, H);
}
sort(arr.begin(), arr.end());
int l=0;
ll befsum = 0;
ll ans[N];
for(int i=0;i<N;++i) ans[i] = 0;
for(int i=0;i<N;++i) {
X = arr[i].fi;
H = arr[i].se;
while(l<i) {
if(arr[i].fi-arr[l].fi>2*D) {
befsum -= A*ans[l];
l++;
}
else break;
}
H -= befsum;
if(H<=0) ans[i] = 0;
else if(H%A==0) ans[i] = H/A;
else ans[i] = H/A+1;
befsum += A*ans[i];
}
ll ans1 = 0;
for(int i=0;i<N;++i) {
ans1 += ans[i];
}
cout<<ans1<<endl;
}
| 0
| 79,786,537
|
#include <iostream>
#include <stack>
int main()
{
std::stack<int> cars;
int in_car;
while (std::cin >> in_car) {
if (in_car == 0) {
std::cout << cars.top() << std::endl;
cars.pop();
} else {
cars.push(in_car);
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using vl = vector<ll>;
using Map = map<ll,ll>;
using T = tuple<ll,ll,ll>;
using vvl = vector<vector<ll>>;
#define all(v) v.begin(), v.end()
#define print(v) cout<<v<<endl;
#define fi(v) get<0>(v)
#define se(v) get<1>(v)
#define th(v) get<2>(v)
template <typename T> bool chmax(T &a, const T &b){if (a<b){a=b;return 1;}return 0;}
template <typename T> bool chmin(T &a, const T &b){if (a>b){a=b;return 1;}return 0;}
const ll INF=1LL<<60;
const ll MOD=1000000007;
int main(){
ll Q;
cin >> Q;
vector<ll> A(Q,0);
vector<ll> B(Q,0);
for(ll i=0;i<Q;i++){
cin>>A[i]>>B[i];
ll ab=A[i]*B[i];
ll x=sqrt(ab);
if(A[i]==B[i]){print(2*x-2) continue;}
if(x*x==ab){x--;}
if(x*(x+1)<ab)print(2*x-1)
else print(2*x-2)
}
return 0;
}
| 0
| 61,447,029
|
#include<bits/stdc++.h>
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
long long k,a,b;
cin>>k>>a>>b;
if(b-a<=1){
cout<<k+1;
return 0;
}
if(k+1<a+2){
cout<<k+1;
return 0;
}
k++;
k-=(a+2);
cout<<b+(k/2)*(b-a)+k%2;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
vector<int> A(N);
for (int i=0 ; i<N ; i++)
cin >> A.at(i);
vector<int> height(N-1);
for (int i=0 ; i<N-1 ; i++){
if (A.at(i) > A.at(i+1)){
height.at(i) = A.at(i) - A.at(i+1);
A.at(i+1) = A.at(i);
}
else
height.at(i) = 0;
}
long long s = 0;
for (int i=0 ; i<N-1 ; i++)
s += height.at(i);
cout << s << endl;
}
| 0
| 70,587,788
|
#include<bits/stdc++.h>
using namespace std;
int guusuu[100005],kisuu[100005],mx1,mx2,x1,x2;
#define int long long
signed main() {
int n;
cin >> n;
int u;
for(int i = 0; i < n; i++) {
cin >> u;
if(i%2 == 0) {
guusuu[u]++;
if(mx1 < guusuu[u]) {
mx1 = guusuu[u];
x1 = u;
}
}
else{
kisuu[u]++;
if(mx2 < kisuu[u]) {
mx2 = kisuu[u];
x2 = u;
}
}
}
sort(guusuu,guusuu+100005);
sort(kisuu,kisuu+100005);
if(x1 != x2) {
cout << n-mx1-mx2 << endl;;
}
else {
cout << n-max(mx1+kisuu[100003],mx2+guusuu[100003]) << endl;
}
}
|
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <cmath>
#include <bitset>
#include <iomanip>
#include <stack>
#include <list>
#include <map>
#include <unordered_map>
#include <chrono>
#include <numeric>
using namespace std;
using ll = long long;
const ll INF = (ll)1e18+1;
const ll DIV = 1000000007;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
#ifdef TEST
chrono::system_clock::time_point start, end;
start = chrono::system_clock::now();
#endif
long N;
cin >> N;
ll total = 0;
ll l,r;
for(size_t i=0;i<N; i++)
{
cin >> l >> r;
total += (r-l)+1;
}
cout << total << endl;
#ifdef TEST
end = chrono::system_clock::now();
cerr << static_cast<double>(chrono::duration_cast<chrono::microseconds>(end - start).count() / 1000.0) << "[ms]" << endl;
#endif
return 0;
}
| 0
| 44,444,892
|
#include<bits/stdc++.h>
#define fo(i,a,b) for(register int (i)=(a);(i)<=(b);++(i))
#define rd read()
#define maxn 200001
#define gc getchar()
#define mem(a,b) memset(a,b,sizeof(a))
#define mp make_pair
#define ll long long
#define ull unsigned ll
#define pb push_back
#define db double
#define pu puts(" ")
using namespace std;
const int p=998244353;
int read()
{
int x=0,f=1;
char ch=gc;
while(!isdigit(ch))
{
if(ch=='-')f=-1;
ch=gc;
}
while(isdigit(ch))x=x*10+ch-48,ch=gc;
return x*f;
}
void print(int x)
{
if(x<0)putchar('-'),x=-x;
if(x>9)print(x/10);
putchar(x%10+48);
}
int qp(int a,int b)
{
int ans=1;
while(b)
{
if(b&1)ans=(ll)ans*a%p;
a=(ll)a*a%p;
b>>=1;
}
return ans;
}
char s[15];
int ans,ok=1;
int main()
{
cin>>s;
int l=strlen(s);
fo(i,0,l-1)
{
if(s[i]=='x')ans++;
}
if(ans>7)ok=0;
puts(ok?"YES":"NO");
return 0;
}
|
#include <bits/stdc++.h>
#include <random>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef double ld;
#define double ld
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<vvc> vvvc;
typedef pair<int, int> pii;
typedef pair<pii, pii> piii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<pii> vpi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<short> vs;
typedef vector<vs> vvs;
typedef vector<vvs> vvvs;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
typedef vector<ld> vld;
typedef vector<vld> vvld;
typedef vector<vvld> vvvld;
typedef vector<string> vst;
typedef vector<vst> vvst;
typedef pair<ld, ld> pld;
#define inmin(a, b) a = min(a, (b))
#define inmax(a, b) a = max(a, (b))
#define ALL(a) a.begin(),a.end()
#define RALL(a) a.rbegin(),a.rend()
#define sqr(x) ((x) * (x))
#define fori(i, n) for(int i = 0; i < int(n); ++i)
#define SZ(a) ((int)((a).size()))
#define triple(T) tuple<T, T, T>
#define quad(T) tuple<T, T, T, T>
#define watch(x) cerr << (#x) << " = " << (x) << endl;
#ifdef MAX_HOME
#define cerr cout
#else
#define cerr if (false) cerr
#endif
const double PI = 2 * acos(0.0);
#define rand shittttty_shit
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng_64(chrono::steady_clock::now().time_since_epoch().count());
const string DIGITS = "0123456789";
const string ALPH = "abcdefghijklmnopqrstuvwxyz";
template<class T0, class T1>
inline ostream &operator<<(ostream &out, pair<T0, T1> &a) {
return out << "{" << a.first << ", " << a.second << "}";
}
template<class T0, class T1>
inline istream &operator>>(istream &in, pair<T0, T1> &a) {
return in >> a.first >> a.second;
}
template<class T0, class T1, class T2>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2> &a) {
return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a) << "}";
}
template<class T0, class T1, class T2, class T3>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2, T3> &a) {
return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a) << ", " << get<3>(a) << "}";
}
template<class T>
inline ostream &operator<<(ostream &out, vector<T> &a) {
out << "[";
fori (i, a.size())out << a[i] << vector<string>{", ", "] "}[i + 1 == a.size()];
return out;
}
void smain();
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifdef MAX_HOME
freopen("input.txt", "r", stdin);
clock_t start = clock();
#endif
cout << setprecision(12) << fixed;
smain();
#ifdef MAX_HOME
cout << "\n\nTOTAL EXECUTION TIME: " << float(clock() - start) / CLOCKS_PER_SEC << endl;
#endif
return 0;
}
const int N = 1e5 + 10;
vi g[N];
int dl[N];
int used[N];
bool bad = false;
int dfs(int v, int par) {
used[v] = 1;
int ret = 0;
for (int to : g[v]) {
if (to == par) {
par = -1;
continue;
}
if (used[to] == 0) {
int cur = dfs(to, v);
if (!(cur & 1)) {
bad = true;
}
ret += cur;
} else if (used[to] == 1) {
ret++;
dl[to]--;
}
}
used[v] = 2;
return ret - dl[v];
}
void smain() {
int n, m;
cin >> n >> m;
fori (_, m) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int v = 1; v <= n; ++v) {
if (used[v])
continue;
dfs(v, -1);
}
cout << (bad ? "NO" : "YES");
}
| 0
| 37,328,223
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
using namespace std;
#define FOR(i,a,b) for(long long i=(a);i<(b);i++)
#define REP(i,N) for(long long i=0;i<(N);i++)
#define ALL(s) (s).begin(),(s).end()
#define fi first
#define se second
#define PI acos(-1.0)
#define INF 1000000007
#define EPS 1e-10
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<double, double> PD;
typedef pair<string, ll> PS;
typedef vector<ll> V;
typedef pair<P, char> PC;
string s;
int main(){
while (getline(cin, s)){
if (s == ".")break;
bool f = 1, g = 0;
vector<char> vc;
vc.clear();
REP(i, s.size()){
if (s[i] == '('){
vc.push_back(s[i]);
}
if (s[i] == '['){
vc.push_back(s[i]);
}
if (s[i] == ')'){
if (!vc.empty()){
if (vc[vc.size() - 1] == '[')f = 0;
else vc.pop_back();
}
else f = 0;
}
if (s[i] == ']'){
if (!vc.empty()){
if (vc[vc.size() - 1] == '(')f = 0;
else vc.pop_back();
}
else f = 0;
}
}
if ((vc.empty()&&g)||(vc.empty() && f))cout << "yes" << endl;
else cout << "no" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using pint = pair<int, int>;
using ll = long long;
using ull = unsigned long long;
using vll = vector<long long>;
using pll = pair<ll, ll>;
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define VREP(s, ite) for (auto ite = s.begin(); ite != s.end(); ++ite)
#define FI first
#define SE second
#define ALL(v) v.begin(), v.end()
#define endl "\n"
#define ciosup \
cin.tie(0); \
ios::sync_with_stdio(false);
#define eb emplace_back
#define vint vector<int>
constexpr ll INF = 1e15 + 7LL;
constexpr ll MOD = ll(1e9) + 7LL;
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
is >> v[i];
}
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
if (v.size() == 0) return os;
for (int i = 0; i < v.size() - 1; ++i) {
os << v[i] << " ";
}
os << v[v.size() - 1];
return os;
}
struct edge {int to, cap, rev;};
int dfs(int v, int t, int f, vector<bool>& used, vector<vector<edge>>& G) {
if (v == t) return f;
used[v] = true;
REP(i, G[v].size()) {
edge& e = G[v][i];
if (!used[e.to] && e.cap > 0) {
int d = dfs(e.to, t, min(f, e.cap), used, G);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
void solve() {
int x;
cin >> x;
if (360 % x == 0) {
cout << 360 / x << endl;
return;
}
ll ans = x;
while (ans % 360 != 0) {
ans += x;
}
cout << ans / x << endl;
}
int main() {
char tmp;
while (cin >> tmp) {
cin.putback(tmp);
solve();
}
}
| 0
| 83,061,500
|
#include <bits/stdc++.h>
#include <iostream>
#define ll long long
#define map unordered_map
#define set unordered_set
#define pll pair<ll, ll>
#define vll vector<ll>
#define mll map<ll, ll>
using namespace std;
const ll MOD = 1000000007LL;
const ll INF = (1LL << 60LL);
vll r[200005];
ll points[200005];
mll finished;
void calc(ll index, ll plus) {
if (finished[index]) {
return;
}
points[index] += plus;
vll list = r[index];
finished[index] = 1;
for (ll i = 0; i < list.size(); i++) {
ll next_index = list[i];
calc(next_index, points[index]);
}
}
int main() {
ll N, Q;
scanf("%lld %lld", &N, &Q);
for (ll i = 0; i < N - 1; i++) {
ll a, b;
scanf("%lld %lld", &a, &b);
r[a].emplace_back(b);
r[b].emplace_back(a);
}
for (ll i = 0; i < Q; i++) {
ll p, x;
scanf("%lld %lld", &p, &x);
points[p] += x;
}
calc(1, 0);
cout << points[1];
for (ll i = 2; i <= N; i++) {
cout << " " << points[i];
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define repd(i,a,b) for (int i=(a);i<(b);i++)
#define rep(i,n) repd(i,0,n)
#define all(x) (x).begin(),(x).end()
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
typedef long long ll;
const long long INF = 1LL << 60;
typedef pair<int, int> P;
int main()
{
int K;
cin >> K;
vector<ll> A(K);
rep(i, K) cin >> A[i];
ll mi = A[K - 1], ma = A[K - 1] * 2 - 1;
for (int i = K - 2; i >= 0; i--) {
if (mi < A[i]) mi = A[i];
else {
mi = A[i] * ((mi + A[i] - 1) / A[i]);
}
}
for (int i = K - 2; i >= 0; i--) {
ma = A[i] * ((ma / A[i]) + 1) - 1;
}
ll gmi = mi, gma = ma;
rep(i, K) {
gmi -= (gmi % A[i]);
gma -= (gma % A[i]);
}
if (gmi == 2 && gma != 2) {
ma = mi;
}
else if (gmi != 2 && gma == 2) {
mi = ma;
}
else if (gmi != 2 && gma != 2) {
cout << -1 << endl;
return 0;
}
cout << mi << " " << ma << endl;
return 0;
}
| 0
| 28,727,040
|
#include<iostream>
using namespace std;
int main(){
int N;
cin >> N;
int a[N];
for(int i = 0; i < N; i++){
cin >> a[i];
}
int min= a[0];
int max= a[0];
long long sum= a[0];
for(int i = 1; i < N; i++){
sum += a[i];
if(a[i] < min) min = a[i];
if(a[i] > max) max = a[i];
}
cout << min << " " << max << " " << sum << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template<typename T> istream &operator>>(istream &is, vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec){ os << "["; for (auto v : vec) os << v << ", "; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const deque<T> &vec){ os << "deq["; for (auto v : vec) os << v << ", "; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const set<T> &vec){ os << "{"; for (auto v : vec) os << v << ", "; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_set<T> &vec){ os << "{"; for (auto v : vec) os << v << ", "; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ", "; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ", "; os << "}"; return os; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &pa){ os << "(" << pa.first << ", " << pa.second << ")"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << ": " << v.second << ", "; os << "}"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << ": " << v.second << ", "; os << "}"; return os; }
template<typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template<typename T, typename... Args> void ndarray(vector<T> &vec, int len, Args... args) { vec.resize(len); for (auto &v : vec) ndarray(v, args...); }
template<typename T> bool chmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
template<typename T> bool chmin(T &m, const T q) { if (q < m) {m = q; return true;} else return false; }
template<typename T1, typename T2> pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) { return make_pair(l.first + r.first, l.second + r.second); }
template<typename T1, typename T2> pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) { return make_pair(l.first - r.first, l.second - r.second); }
#define f first
#define s second
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int len, tickets;
cin >> len >> tickets;
vector<int> arr(len);
long long ans = 0;
for(int i = 0; i < len; i++) {
cin >> arr[i];
ans += arr[i];
}
if(len == 1) {
cout << (int) (arr[0] / pow(2, tickets));
return 0;
}
while(tickets > 0) {
sort(arr.begin(), arr.end());
int target = arr[len - 1] / 2;
int i = len - 1;
while(i >= 0 && arr[i] > target) {
ans -= arr[i] - arr[i] / 2;
arr[i] = arr[i] / 2;
i--;
tickets--;
if(tickets == 0)
break;
}
}
cout << ans;
}
| 0
| 73,667,189
|
#include <iostream>
#include <cstdio>
#include <queue>
using namespace std;
#define rep(i,a) for(int i=0;i<a;i++)
int mt[100][100];
int w,h;
vector<pair<int,int> > block;
void saiki(int y,int x){
rep(i,block.size())
if(y==block[i].first && x==block[i].second){
mt[y][x]=0;
return;
}
if(x-1>=0 && y-1>=0)mt[y][x]=mt[y][x-1]+mt[y-1][x];
else if(x-1>=0)mt[y][x]=1;
else if(y-1>=0)mt[y][x]=1;
if(y==h-1 && x==w-1)return;
if(x+1<w)saiki(y,x+1);
if(y+1<h)saiki(y+1,x);
}
int main(){
int n,x,y;
while(cin >> w >> h && w && h){
block.clear();
cin >> n;
for(int i=0;i<n;i++){
cin >> x >> y;
x--;y--;
block.push_back( pair<int,int>(y,x) );
}
rep(i,100)rep(j,100)mt[i][j]=0;
mt[0][0]=1;
saiki(0,0);
cout << mt[h-1][w-1] << endl;
}
}
|
#include<bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
typedef long long ll;
#define rep(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define REP(i,num,n) for(int i=num, i##_len=(n); i<i##_len; ++i)
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
#define print(x) (cout << (x) << endl)
#define pb push_back
#define mp make_pair
#define sz(x) int(x.size())
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
#define fs first
#define sc second
#include <boost/rational.hpp>
#include <boost/multiprecision/cpp_int.hpp>
using boost::rational;
using boost::multiprecision::cpp_int;
const int INF = 1e9;
const ll LLINF = 1e16;
const ll MOD = 1e9+7;
template<class T> inline void add(T &a, T b){a = ((a+b) % MOD + MOD) % MOD;};
template<typename T>
vector<T> make_v(size_t a){return vector<T>(a);}
template<typename T,typename... Ts>
auto make_v(size_t a,Ts... ts){
return vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));
}
ll stringcount(string s, char c) {
return count(s.cbegin(), s.cend(), c);
}
template<typename T>
T rp(T a, T b) {
return (a + b - 1) / b;
}
template<typename T>
T digsum(T n) {
T res = 0;
while(n > 0) {
res += n%10;
n /= 10;
}
return res;
}
bool kai (string s) {
string t{s};
reverse(begin(t), end(t));
return s == t;
}
using pint = pair<int, int>;
using pll = pair<ll, ll>;
vector<string> split(const string &s, char delim) {
vector<string> elems;
string item;
for (char ch: s) {
if (ch == delim) {
if (!item.empty())
elems.push_back(item);
item.clear();
}
else {
item += ch;
}
}
if (!item.empty())
elems.push_back(item);
return elems;
}
vector<pair<long long, long long> > prime_factorize(long long n) {
vector<pair<long long, long long> > res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0) continue;
int num = 0;
while (n % p == 0) { ++num; n /= p; }
res.push_back(make_pair(p, num));
}
if (n != 1) res.push_back(make_pair(n, 1));
return res;
}
int main(void)
{
cout.tie(0);
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll n;
cin >> n;
vector<ll> a(n);
vector<ll> b(n);
vector<ll> c;
ll sum = 0;
rep(i, n) cin >> a[i];
rep(i, n) cin >> b[i];
ll num = 0;
rep(i, n){
ll dif = a[i] - b[i];
if(dif < 0) sum -= dif, ++num;
else c.pb(dif);
}
if(num == 0) print(0);
else {
ll ans = num;
sort(rall(c));
ll p = 0;
rep(i, sz(c)){
p += c[i];
++ans;
if (p >= sum) break;
}
if(p >= sum) print(ans);
else print(-1);
}
}
| 0
| 31,925,312
|
#include <bits/stdc++.h>
#define MOD 1000000007
#define INF 1001001001
#define LINF 1001001001001001001
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define bit(n) (1LL<<(n))
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> LLP;
bool check(vector<int> d, int x) {
int sum = 0;
int N = d.size();
if (N == 0) return x == 0;
rep(i,N) sum += d[i];
if ((x + sum) % 2 == 1) return false;
int S = (x + sum) / 2;
vector<vector<bool>> dp(N, vector<bool>(S + 1, false));
dp[0][0] = true;
dp[0][d[0]] = true;
for (int i = 1; i < N; i++) for (int j = 0; j <= S; j++) {
if (dp[i - 1][j]) dp[i][j] = true;
if (j - d[i] >= 0 && dp[i - 1][j - d[i]]) dp[i][j] = true;
}
return dp[N - 1][S];
}
int main() {
string S;
cin >> S;
int N = S.length();
int x, y;
cin >> x >> y;
vector<vector<int>> d(2);
int count = 0;
bool isX = true;
bool isInit = true;
rep(i,N) {
if (S[i] == 'F') count++;
else if (isInit) {
x -= count;
count = 0;
isX = false;
isInit = false;
} else {
if (count > 0) {
if (isX) d[0].push_back(count);
else d[1].push_back(count);
count = 0;
}
isX = !isX;
}
}
if (isInit) {
x -= count;
count = 0;
isX = false;
isInit = false;
}
if (count > 0) {
if (isX) d[0].push_back(count);
else d[1].push_back(count);
}
count = 0;
isX = !isX;
if (check(d[0], abs(x)) && check(d[1], abs(y))) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
|
#include <stdio.h>
#define N (2000)
char s[N], ans[N], s2[N];
int main(){
int len = 0;
s[0] = '1';
for (int i = 1; i < 12; i++){
s[i] = '0';
s[i + 1] = 0;
printf("? %s\n", s);
fflush(stdout);
scanf("%s", ans);
if (ans[0] == 'N'){
len = i;
break;
}
}
if (len == 0){
for (int i = 0; i < 12; i++){
s2[i] = '9';
s2[i + 1] = 0;
printf("? %s\n", s2);
fflush(stdout);
scanf("%s", ans);
if (ans[0] == 'Y'){
len = i + 1;
break;
}
}
if (len == 1){
printf("! 1\n");
fflush(stdout);
return 0;
}
}
for (int i = 0; i < len - 1; i++){
char l = '0', r = '9' + 1;
s[i + 1] = 0;
while (l + 1 < r){
char mid = l + r >> 1;
s[i] = mid;
printf("? %s\n", s);
fflush(stdout);
scanf("%s", ans);
if (ans[0] == 'Y'){
l = mid;
}
else {
r = mid;
}
}
s[i] = l;
}
s[len] = '0';
s[len + 1] = 0;
char l = '0' - 1, r = '9';
while (l + 1 < r){
char ed = l + r >> 1;
s[len - 1] = ed;
printf("? %s\n", s);
fflush(stdout);
scanf("%s", ans);
if (ans[0] == 'Y'){
r = ed;
}
else {
l = ed;
}
}
s[len - 1] = r;
s[len] = 0;
printf("! %s\n", s);
fflush(stdout);
}
| 0
| 11,211,744
|
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <cstring>
using namespace std;
int arr[101];
int main(){ int x, n;
cin >> x >> n;
for (int i=0; i<n; i++){ int x;
cin >> x;
arr[x]++;
}
int min = 2e9, ans;
for (int i=0; i<=102; i++){
if(arr[i] == 0){
if(abs(x-i) < min){
min = abs(x-i);
ans = i;
}
}
}
cout << ans << endl;
return 0;
}
|
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
long long patty_num(const int l,
const long long x,
const vector<long long>& patty,
const vector<long long>& bun,
const vector<long long>& all){
if(l == 0){
if(x <= 0){
return 0;
}else{
return 1;
}
}
if(x <= 1){
return 0;
}
if(x >= all[l]){
return patty[l];
}
long long ret =
patty_num(l - 1, x - 1, patty, bun, all) +
patty_num(l - 1, x - (1 + all[l - 1] + 1), patty, bun, all);
if(x >= 1 + all[l - 1] + 1){
ret += 1;
}
return ret;
}
int main(){
int N;
long long X;
cin >> N >> X;
vector<long long> all(N + 1), patty(N + 1), bun(N + 1);
patty[0] = 1;
all[0] = 1;
for(int n = 1; n <= N; n++){
patty[n] = 2 * patty[n - 1] + 1;
bun[n] = 2 * bun[n - 1] + 2;
all[n] = patty[n] + bun[n];
}
long long ans = patty_num(N, X, patty, bun, all);
cout << ans << endl;
}
| 0
| 83,029,190
|
#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
const int MOD = 1000000007;
int main()
{
string a, b, x;
int m, n;
cin >> a >> b >> m >> n >> x;
if(x == a) cout << m - 1 << " " << n << endl;
else if(x == b) cout << m << " " << n -1 << endl ;
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <math.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <iomanip>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vb = vector<bool>;
using vll = vector<long long>;
using pii = pair<int, int>;
using psi = pair<string, int>;
int main() {
int N;
cin >> N;
vi data(N);
for (int i = 0; i < N; i++) {
cin >> data[i];
}
sort(data.begin(), data.end());
int ans = 20000001;
for (int i = data[0]; i <= data[N - 1]; i++) {
int sum = 0;
for (int x : data) {
int a = (i - x) * (i - x);
sum += a;
}
if (ans > sum) {
ans = sum;
}
else {
break;
}
}
cout << ans << endl;
}
| 0
| 17,944,089
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(n); i++)
#define rep2(i,x,n) for(int i=x; i<(n); i++)
#define ALL(c) (c).begin(), (c).end()
#define pb push_back
#define eb emplace_back
using namespace std;
const long long INF = 1LL<<60;
using ll = long long;
using P = pair<int, int>;
#define vi vector<int>
#define vll vector<ll>
#define vs vector<string>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main()
{
int N, M;
cin >> N >> M;
vi A(N);
int sum = 0;
rep(i, N) {
cin >> A[i];
sum += A[i];
}
sort(ALL(A));reverse(ALL(A));
rep(i, M)
{
if(A[i]*4*M < sum)
{
cout << "No" << endl;return 0;
}
}
cout << "Yes" << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
typedef long long ll;
#define press_F_to_pay_respect ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define forn for(int i=0;i<n;i++)
#define form for(int j=0;j<n;j++)
#define fore(i,a,b) for(int i = a; i < (b); i++)
#define pb push_back
#define pob pop_back()
#define mp make_pair
#define sc second
#define f first
#define ld long double
#define kek cout<<endl;
#define rep(i,a,b) for(int i=a;i<b;i++)
#define all(v) ((v).begin()), ((v).end())
#define pob pop_back()
#define halt {cout<<-1; return 0;}
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const int N = 1010;
const int INF = 1e8;
const ll MOD1=1073741824;
const long double pi=3.1415926535;
using namespace std;
using namespace __gnu_pbds;
typedef tree<ld,null_type,less<ld>,rb_tree_tag,tree_order_statistics_node_update> indexed_set;
string bin_rep(int n)
{
string s="";
for(int i=31;i>=0;i--)
{
if(n&(1<<i)) s+='1';
else s+='0';
}
return s;
}
int main()
{
#if defined(_DEBUG)
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
press_F_to_pay_respect;
int s,w;
cin>>s>>w;
if(w>=s) cout<<"unsafe";
else cout<<"safe";
return 0;
}
| 0
| 42,177,255
|
#include <iostream>
#include <vector>
int main()
{
long long int n;
std::cin>>n;
std::vector<long long int> p(n);
for (int i=0; i<n; i++) std::cin>>p[i];
long long min=p[0],count=1;
for (int i=1; i<n; i++)
{
if (p[i]<min)
{
count++;
min=p[i];
}
}
std::cout<<count;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define INF (1LL<<50)
#define MOD 1000000007
int main(){
ll N;
cin >> N;
ll ans = 0;
for(ll i=1;i*i<=N;i++){
if((N-i)/i > i && (N-i)%i == 0){
ans += (N-i)/i;
}
}
cout << ans << endl;
return 0;
}
| 0
| 62,352,848
|
#include<iostream>
using namespace std;
int main()
{
int A , P , x , pie;
cin>>A;
cin>>P;
x = 3*A;
pie = (x+P)/2;
cout<<pie;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void takahasi(int &x, int &y){
if(x%2 ==1){
x -= 1;
x /= 2;
y += x;
}
else{
x /= 2;
y += x;
}
}
void aoki(int &x, int&y){
if(y%2 ==1){
y -= 1;
y /= 2;
x += y;
}
else{
y /=2;
x += y;
}
}
int main(){
int a,b,k;
cin >> a >> b >> k;
for(int i=1; i<k+1 ; i++){
if(i%2 == 1){
takahasi(a,b);
}
else{
aoki(a,b);
}
}
cout << a << " " << b <<endl;
}
| 0
| 54,869,078
|
#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,m;
cin >> n >> m;
vector<int> a(n);
rep(i,n) cin >> a[i];
int s = 0;
rep(i,n) s += a[i];
int cnt = 0;
rep(i,n) {
if(s <= a[i]*(4*m)) cnt++;
}
if(cnt >= m){
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
}
|
#include <bits/stdc++.h>
typedef long long ll;
#define REP(i, n) for(int i = 0; i < n; i++)
#define REP2(i, a, b) for(int i = a;i <= b;i++)
#define REPR(i, a, b) for(int i = a; i >= b; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define INF 2e9
#define MOD 1000000007
#define PI 3.14159265358979323846
#define vi vector<int>
#define vll vector<ll>
#define vi2 vector<vector<int>>
#define eb emplace_back
#define fi first
#define se second
#define ALL(v) v.begin(), v.end()
#define sz(x) int(x.size())
using namespace std;
using P = pair<ll,ll>;
const int dx[]{0, 1, 0, -1, -1, -1, 1, 1}, dy[]{1, 0, -1, 0, -1, 1, -1, 1};
#define INT(name) int name;cin >> name;
#define VEC(type,name,n) vector<type> name(n);REP(i,n) cin >> name[i];
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main()
{
ll N;
cin >> N;
VEC(ll,A,N);
ll right = 0;
ll sum = 0;
ll xorsum = 0;
ll ans = 0;
REP(left,N){
while(right<N&&sum+A[right]==(xorsum^A[right])){
sum+=A[right];
xorsum=(xorsum^A[right]);
right++;
}
ans+=right-left;
if(right==left){
right++;
}else{
sum-=A[left];
xorsum=(xorsum^A[left]);
}
}
cout << ans << endl;
}
| 0
| 5,324,927
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
int flag = 1;
if (s.size() + 1 == t.size()) {
for (int i = 0; i < s.size(); i++) {
if (s[i] != t[i]) {
flag = 0;
}
}
}
flag == 1 ? cout << "Yes" : cout << "No";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define m0(x) memset(x, 0, sizeof(x))
#define all(x) x.begin(), x.end()
#define rep(i, n) for(int i = 0; i < (n); i++)
#define asort(x) sort(all(x));
#define dsort(x, t) sort(x.begin(), x.end(), greater<t>());
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define MINS(m, s) m.insert(make_pair(s, 1));
#define MFIN(m, s) m.find(s) != m.end()
#define INF (1 << 29)
const int mod = 1000000007;
int main() {
int n;
cin >> n;
int a[200005];
for(int i = 0; i < n; i++) {
cin >> a[i];
}
int cnt = 0;
int now = 1;
for(int i = 0; i < n; i++) {
if(now == a[i]) {
now++;
} else {
cnt++;
}
}
if(now == 1) {
cout << -1 << endl;
} else {
cout << cnt << endl;
}
return 0;
}
| 0
| 99,182,259
|
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vint;
#define rep(i,n) for (ll i = 0; i < (ll)(n); ++i)
#define rrep(i,j,n) for(ll i = (ll)(j); i < (ll)(n); i++)
#define mrep(i,n) for (ll i = (ll)(n-1); i >= 0; i--)
#define be(v) (v).begin(), (v).end()
#define dcout cout << fixed << setprecision(20)
ll INF = 1LL << 60;
ll mod = 1e9 + 7;
int main(){
int n; cin >> n;
int ans=0;
rep(i,n) {
int l,r; cin >> l >> r;
ans+=abs(r-l+1);
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < n; i++)
int main(void){
ll h, w;
cin >> h >> w;
ll a, b, c;
ll mi = 100000000;
for(int i = 1; i < h ; i++){
a = i * w;
b = ceil((h - i) / 2.0) * w;
c = floor((h - i) / 2.0) * w;
ll dif = max(a, max(b, c)) - min(a, min(b, c));
mi = min(dif, mi);
b = ceil(w / 2.0) * (h - i);
c = floor(w / 2.0) * (h - i);
dif = max(a, max(b, c)) - min(a, min(b, c));
mi = min(dif, mi);
}
swap(h, w);
for(int i = 1; i < h ; i++){
a = i * w;
b = ceil((h - i) / 2.0) * w;
c = floor((h - i) / 2.0) * w;
ll dif = max(a, max(b, c)) - min(a, min(b, c));
mi = min(dif, mi);
b = ceil(w / 2.0) * (h - i);
c = floor(w / 2.0) * (h - i);
dif = max(a, max(b, c)) - min(a, min(b, c));
mi = min(dif, mi);
}
cout << mi << endl;
return 0;
}
| 0
| 58,461,505
|
#include <iostream>
#define rep(i, n) for(int i=0; i<n; i++)
using namespace std;
long long MOD = 1000000007;
int main(){
long long N;
string S;
cin >> N >> S;
long long cnt[26] = {0};
rep(i, N){
cnt[ S[i]-'a' ]++;
}
long long ans = 1;
rep(i, 26)
ans = ( ans*(cnt[i]+1) )%MOD;
cout << ans-1 << endl;
return 0;
}
|
#include <iostream>
#include <vector>
std::vector<int> UFT;
int Find(int a);
void Unite(int a,int b);
int main() {
int N,M;
std::cin >> N >> M;
UFT.resize(N+1,0);
for(int i=0;i<M;i++){
int a,b;
std::cin >> a >> b;
int small,large;
if(a>b){
small = b;
large = a;
}else{
small = a;
large = b;
}
Unite(small,large);
}
for(int i=1;i<=N;i++){
Find(i);
}
std::vector<int> cnt(N+1,0);
for(int i=1;i<=N;i++){
if(UFT[i] == 0){
cnt[i]++;
}else {
cnt[UFT[i]]++;
}
}
int max = 0;
for(int i=1;i<=N;i++){
if(cnt[i] > max){
max = cnt[i];
}
}
std::cout << max;
return 0;
}
void Unite(int a,int b){
int rootA,rootB;
rootA = Find(a);
rootB = Find(b);
if(rootA == rootB){
return;
}
UFT[rootB] = rootA;
return;
}
int Find(int a){
if(UFT[a] != 0){
int root = Find(UFT[a]);
UFT[a] = root;
return root;
}
return a;
}
| 0
| 49,697,149
|
#include<iostream>
using namespace std;
int main(void){
int i,a[3],tmp,b,c;
for(i=0;i<3;i++)cin>>a[i];
for(b=0;b<3;b++){
for(c=b+1;c<3;c++){
if(a[b]>a[c]){
tmp=a[b];
a[b]=a[c];
a[c]=tmp;
}
}
}
cout<<a[0]<<" "<<a[1]<<" "<<a[2]<<endl;
return 0;
}
|
#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <array>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define fst first
#define snd second
#define mp make_pair
#define ALL(obj) (obj).begin(),(obj).end()
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define RFOR(i,a,b) for(int i = (b-1);i>=a;i--)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
#define SIZE(x) ((int)(x).size())
#define debug(x) cerr << #x << " -> " << x << " (line:" << __LINE__ << ")" << '\n';
#define debugpair(x, y) cerr << "(" << #x << ", " << #y << ") -> (" << x << ", " << y << ") (line:" << __LINE__ << ")" << '\n';
typedef long long lint;
typedef pair<int, int> pint;
typedef pair<lint, lint> plint;
typedef vector<lint> vec;
typedef vector<vector<lint>> matrix;
typedef priority_queue<lint> p_que;
typedef priority_queue<lint, vector<lint>, greater<lint>> p_que_rev;
const lint INF = INT_MAX;
const lint LINF = LLONG_MAX;
const lint MOD = 1000000000 + 7;
const double EPS = 1e-9;
const double PI = acos(-1);
const int di[]{0, -1, 0, 1, -1, -1, 1, 1};
const int dj[]{1, 0, -1, 0, 1, -1, -1, 1};
lint gcd(lint a, lint b) {
lint r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
lint lcm(lint a, lint b) {
return (a / gcd(a, b)) * b;
}
lint power(lint x, lint n, lint mod = MOD) {
lint ret = 1;
while(n > 0) {
if(n & 1){
(ret *= x) %= mod;
}
(x *= x) %= mod;
n >>= 1;
}
return ret;
}
vector<lint> make_power(int n, lint base){
lint num = 1;
vector<lint> ret;
for (int i=0; i<=n; ++i){
ret.push_back(num);
num *= base;
}
return ret;
}
int main()
{
int n;
cin >> n;
vector<vector<int>> graph(n);
REP(i, n){
graph[i].resize(n);
REP(j, n){
graph[i][j] = 0;
}
}
int u, k, dst;
REP(i, n){
cin >> u >> k;
u--;
REP(j, k){
cin >> dst;
dst--;
graph[u][dst]++;
}
}
bool isFst = true;
REP(i, n){
REP(j, n){
if(isFst){
isFst = false;
cout << graph[i][j];
}
else {
cout << " " << graph[i][j];
}
}
cout << endl;
isFst = true;
}
return 0;
}
| 0
| 74,331,942
|
#include<bits/stdc++.h>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
double pai=3.141592653589;
int n,taro=0,hanako=0;
char t[100],h[100];
string tarostr,hanakostr;
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%s %s",&t,&h);
tarostr=t;
hanakostr=h;
if(tarostr==hanakostr){
taro++;
hanako++;
}else if(tarostr<hanakostr){
hanako+=3;
}else{
taro+=3;
}
}
printf("%d %d\n",taro,hanako);
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i, n) for(int (i)=0;(i)<(n);++(i))
#define REPV(iter, v) for(auto (iter)=(v).begin(); (iter)!=(v).end();++(iter))
#define ALL(v) (v).begin(),(v).end()
#define MOD 1000000007
using namespace std;
typedef long long ll;
struct UnionFind {
vector<ll> par;
vector<ll> vSize;
UnionFind(ll N) : par(N), vSize(N) {
for(ll i = 0; i < N; i++)
{
par[i] = i;
vSize[i] = 1;
}
}
ll root(ll x) {
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(ll x, ll y) {
ll rx = root(x);
ll ry = root(y);
if (rx == ry) return;
par[rx] = ry;
vSize[ry] += vSize[rx];
}
bool same(ll x, ll y) {
ll rx = root(x);
ll ry = root(y);
return rx == ry;
}
ll size(ll x){
ll rx = root(x);
return vSize[rx];
}
};
int main()
{
ll N, M;
cin >> N >> M;
vector<ll> p(N);
REP(i, N)
{
cin >> p[i];
p[i]--;
}
UnionFind uf(N);
REP(i, M)
{
ll x, y;
cin >> x >> y;
x--;
y--;
uf.unite(x, y);
}
ll ans = 0;
REP(i, N)
{
if (uf.same(i, p[i]))
{
ans++;
}
}
cout << ans << endl;
}
| 0
| 10,364,548
|
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define countof(array) (sizeof(array) / sizeof(array[0]))
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = (n)-1; i >= 0; --i)
#define srep(i,n,s) for(int i = s; i < (n); ++i)
#define rsrep(i,n,s) for(int i = (n)-1; i >= s; --i)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define aall(a) (a), (a)+countof(a)
#define raall(a) (a), (a)+countof(a), greater<>()
#define show(x) cout<<#x<<" = "<<x<<endl;
#define vfind(v, a) find(all(v), a) != v.end()
#define yn(f) { if (f) puts("YES"); else puts("NO"); }
#define yns(f) { if (f) puts("Yes"); else puts("No"); }
#define show_ary(...) { cout<<#__VA_ARGS__<<" = "; for (const auto& x : (__VA_ARGS__)) { cout<<x<<" "; } cout<<endl; }
#define show_pair(...) cout<<#__VA_ARGS__<<" = "<<endl; for (const auto& x : (__VA_ARGS__)) { cout<<" "<<x.fi<<" : "<<x.se<<endl; }
#define out_ary(...) { for (const auto& x : (__VA_ARGS__)) { cout<<x<<" "; } cout<<endl; }
#define argmax(v) distance((v).begin(), max_element(all(v)))
#define argmin(v) distance((v).begin(), min_element(all(v)))
#define vmax(v) *max_element(all(v))
#define vmin(v) *min_element(all(v))
typedef long long int ll;
typedef pair<int, int> P;
typedef vector<P> vpair;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef vector<double> vdouble;
typedef vector<string> vstr;
typedef vector<bool> vbool;
typedef vector<vint> vvint;
typedef vector<vll> vvll;
typedef vector<vstr> vvstr;
typedef vector<vbool> vvbool;
const ll LINF = 2000000000000000000ll;
const int INF = 1000000100;
const ll MOD = 1e9+7;
int main() {
int n;
cin >> n;
vint a(n);
rep(i, n) cin >> a[i];
vpair rl;
rl.emplace_back(a[0], 1);
for (int i = 1; i < n; ++i) {
if (a[i] == rl.back().fi) rl.back().se++;
else rl.emplace_back(a[i], 1);
}
int ans = 0;
for(auto x : rl) {
ans += x.se/2;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int t[100010],x[100010],y[100010];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> t[i] >> x[i] >> y[i];
}
bool f = 1;
for (int i = 1; i <= n; i++) {
int tt = t[i] - t[i-1];
int xx = abs(x[i] - x[i-1]);
int yy = abs(y[i] - y[i-1]);
if (tt < xx + yy) {
f = 0;
break;
}
tt -= xx + yy;
if (tt % 2 != 0) {
f = 0;
break;
}
}
cout << (f?"Yes":"No") << endl;
}
| 0
| 74,960,180
|
#include <bits/stdc++.h>
#define ll long long int
#define yorn(f) cout<<((f)?"Yay!":":(")<<endl;
#define YORN(f) cout<<((f)?"YES":"NO")<<endl;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define println(x) cout << x << endl;
using namespace std;
int main()
{
int a, b;
cin >> a >> b;
yorn(a <= 8 && b <= 8)
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (int i = int(a); i < int(b); ++i)
#define _rrep(i, n) rrepi(i, n, 0)
#define rrepi(i, a, b) for (int i = int(a) - 1; i >= int(b); --i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define rrep(...) _overload3(__VA_ARGS__, rrepi, _rrep, )(__VA_ARGS__)
#define each(xi, x) for (auto &&xi : x)
template <class T> using vec = vector<T>;
using ll = long long;
using vi = vec<ll>;
using vvi = vec<vi>;
using vvvi = vec<vvi>;
using pii = pair<ll, ll>;
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define uniq(v) v.erase(unique(all(v)), v.end())
#define perm(c) \
sort(all(c)); \
for (bool c##p = 1; c##p; c##p = next_permutation(all(c)))
template <class T> pair<T, size_t> max(vector<T> &x) {
auto it = max_element(all(x));
return mp(*it, it - x.begin());
}
template <class T> pair<T, size_t> min(vector<T> &x) {
auto it = min_element(all(x));
return mp(*it, it - x.begin());
}
template <class T> inline bool chmax(T &maxval, const T &newval) {
if (maxval < newval) {
maxval = newval;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &minval, const T &newval) {
if (minval > newval) {
minval = newval;
return 1;
}
return 0;
}
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
#define inside(H, W, y, x) 0 <= (x) && (x) < (W) && 0 <= (y) && (y) < (H)
#ifdef LOCAL
#include "dump.hpp"
#define debug(x) cerr << #x << ": " << x << '\n'
#else
#define dump(...)
#define debug(x)
#endif
void solve(long long N, std::vector<long long> A) {
unordered_map<ll,ll> S;
rep(i,N) S[A[i]]++;
ll ret = 0;
for(auto kv : S){
if(kv.second>1)
ret += kv.second * (kv.second-1) / 2;
}
rep(i,N){
ll ans = ret;
if(S[A[i]]>1){
ans -= S[A[i]] * (S[A[i]]-1) / 2;
}
if(S[A[i]]>2){
ans += (S[A[i]]-1) * (S[A[i]]-2) / 2;
}
cout << ans << endl;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.precision(12);
long long N;
std::cin >> N;
std::vector<long long> A(N);
for (int i = 0; i < N; i++) {
std::cin >> A[i];
}
solve(N, std::move(A));
return 0;
}
| 0
| 36,458,571
|
#include <bits/stdc++.h>
using namespace std;
char g[10][10];
int h,w;
int getbit(int x,int pos){
return (x >> pos) & 1;
}
int fun(int row,int col){
int cnt = 0;
for(int i = 0; i < h; i++) {
for(int j = 0; j < w; j++) {
if(g[i][j] == '#'){
if(getbit(row,i) == 0 && getbit(col,j) == 0 ){
cnt++;
}
}
}
}
return cnt;
}
int main() {
int k,ans = 0;
cin >> h >> w >> k;
for(int i = 0; i < h; i++) {
for(int j = 0; j < w; j++) {
cin >> g[i][j];
}
}
for(int i = 0; i < (1 << h); i++){
for(int j = 0; j < (1 << w); j++){
if(fun(i,j) == k)
ans++;
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <cstdint>
#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 (ll i = 0; i < (n); ++i)
#define rrep(i, n) for (ll i = 1; i <= (n); ++i)
#define irep(it, stl) for (auto it = stl.begin(); it != stl.end(); it++)
#define drep(i, n) for (ll i = (n)-1; i >= 0; --i)
#define mes(a) cout << (a) << endl
#define dmes(a, b) cout << (a) << " " << (b) << endl
#define re0 return 0
#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 rSort(a) sort(a.rbegin(), a.rend())
#define Rev(a) reverse(a.begin(), a.end())
#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-19;
signed main() {
ll n;
cin >> n;
vll h(n);
ll tmp = 0;
ll r = 0;
rep(i, n) {
cin >> h[i];
tmp = max(tmp, h[i]);
if (tmp == h[i]) r++;
}
mes(r);
}
| 0
| 70,942,045
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <queue>
#include <bitset>
#include <stack>
#include <functional>
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#define rep_(i, a_, b_, a, b, ...) for (int i = (a), i##_len = (b); i < i##_len; ++i)
#define rep(i, ...) rep_(i, __VA_ARGS__, __VA_ARGS__, 0, __VA_ARGS__)
#define reprev_(i, a_, b_, a, b, ...) for (int i = (b-1), i##_min = (a); i >= i##_min; --i)
#define reprev(i, ...) reprev_(i, __VA_ARGS__, __VA_ARGS__, 0, __VA_ARGS__)
#define all(x) (x).begin(), (x).end()
template <class T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return 1; } return 0; }
template <class T> bool chmin(T &a, const T &b) { if (b < a) { a = b; return 1; } return 0; }
#define fls(x) (64 - __builtin_clzll(x))
#define pcnt(x) __builtin_popcountll(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair <int,int> P;
typedef long double ld;
int main (void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int a, b, c; cin >> a >> b >> c;
rep (i, 2 * b) {
if (a * i % b == c) {
cout << "YES\n"; return 0;
}
}
cout << "NO\n";
return 0;
}
|
#include <bits/stdc++.h>
#define mod 1000000007
#define INF LLONG_MAX
#define ll long long
#define ln cout<<endl
#define Yes cout<<"Yes"<<endl
#define No cout<<"No"<<endl
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
#define rep(i,n) REP(i,0,n)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
using namespace std;
ll dx[4]={1,0,-1,0};
ll dy[4]={0,1,0,-1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll a,b,d,n,maxi=0,f=0,mini=INF,sum=0;
ll w,h,x,y,k;
cin>>n;
vector<string> s(n);
rep(i,n) cin>>s[i];
map<char,ll> m[n];
set<char> c;
rep(i,n)rep(j,s[i].length()){
m[i][s[i][j]]++;
c.insert(s[i][j]);
}
map<char,ll> ans;
for(auto itr=c.begin();itr!=c.end();++itr){
ans[*itr] = INF;
}
for(auto itr=c.begin();itr!=c.end();++itr){
rep(i,n) ans[*itr]=min(ans[*itr],m[i][*itr]);
}
vector<char> answer;
for(auto itr=c.begin();itr!=c.end();++itr){
rep(i,ans[*itr]) answer.push_back(*itr);
}
sort(all(answer));
rep(i,answer.size()) cout<<answer[i];
ln;
return 0;
}
| 0
| 7,078,439
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repi(i, s, n) for (int i = (s); i < (n); i++)
#ifdef LOCAL
#define INPUT_FILE \
ifstream in("atcoder-problems/abc135_c.txt"); \
cin.rdbuf(in.rdbuf());
#define print_vec(v) \
rep(l, v.size()) { cout << v[l] << " "; } \
cout << endl;
#else
#define INPUT_FILE
#define print_vec(v)
#endif
#define CIN_OPTIMIZE \
cin.tie(0); \
ios::sync_with_stdio(false);
typedef pair<int, int> P;
typedef long long ll;
typedef pair<ll, ll> pl;
const int INF = 100100100;
const ll LINF = 1e18 + 100;
const int MOD = 1e9 + 7;
int main() {
INPUT_FILE CIN_OPTIMIZE;
int N;
cin >> N;
vector<ll> a(N + 1);
rep(i, N + 1) { cin >> a[i]; }
vector<ll> b(N);
rep(i, N) { cin >> b[i]; }
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
ll ans = 0;
rep(i, N) {
ll _a = a[i];
ll _b = b[i];
ans += min(_a, _b);
a[i] = max(_a - _b, (ll)0);
b[i] = max(_b - _a, (ll)0);
if (b[i] != 0) {
ll _a = a[i + 1];
ll _b = b[i];
ans += min(_a, _b);
a[i + 1] = max(_a - _b, (ll)0);
b[i] = max(_b - _a, (ll)0);
}
}
cout << ans << endl;
}
|
#include <algorithm>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <fstream>
#include <iostream>
#include <iomanip>
#include <map>
#include <math.h>
#include <memory>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
using Pii = pair<int, int>;
using Pil = pair<int, ll>;
using Pid = pair<int, ld>;
using Pis = pair<int, string>;
#define rep(i,n) for(int i=0; i<n; i++)
#define repm(i,s,n) for(int i=s; i<n; i++)
const int INF = 1 << 28;
const ll INF_L = 1LL << 60;
const int MOD = 1e9+7;
int ctoi(char c){
if(isdigit(c)) return c - '0';
else if(islower(c)) return c - 'a';
else if(isupper(c)) return c - 'A';
else return -1;
}
char itoc(int i){
char c = i + 'a';
if(islower(c)) return c;
else return ' ';
}
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; }
vector<vector<int>> adjMat;
vector<set<Pii>> adjList;
void Dijkstra(){}
void BellmanFord(){}
void WarshallFloyd(){}
ll gcd(ll A, ll B) {if (A%B == 0) {return(B);} else {return(gcd(B, A%B));}}
ll lcm(ll A, ll B) {return A * B / gcd(A, B);}
ll powMod(ll B, ll P) {
if(P == 0) return 1;
if(P%2 == 0){ll t = powMod(B, P/2); return t*t % MOD;}
return B * powMod(B, P-1) % MOD;
}
vector<bool> isprime;
void sieveInit(int size){
int sb = size + 9;
isprime.resize(sb);
isprime[0] = isprime[1] = false;
isprime[2] = true;
for(int i=2; i<sb; i++) {
if(i%2 == 0) isprime[i] = false;
else isprime[i] = true;
}
for(int i=3; i*i<=sb; i+=2){
if(isprime[i]){
int m = 3*i;
while(m < sb){isprime[m] = false; m += 2*i;}
} else {
continue;
}
}
}
const int FAC_INIT_SIZE = 5e6+9;
vector<ll> fac, finv, inv;
void factModInit() {
fac.resize(FAC_INIT_SIZE);
finv.resize(FAC_INIT_SIZE);
inv.resize(FAC_INIT_SIZE);
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i=2; i < FAC_INIT_SIZE; i++){
fac[i] = fac[i-1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i-1] * inv[i] % MOD;
}
}
ll factMod(ll N){return fac[N] % MOD;}
ll factInvMod(ll N){return finv[N] % MOD;}
ll permMod(ll N, ll K){
if (N < 0 || K < 0 || N < K) return 0;
else return factMod(N) * factInvMod(N-K) % MOD;
}
ll combMod(ll N, ll K){
if (N < 0 || K < 0 || N < K) return 0;
else if (N < FAC_INIT_SIZE){ return factMod(N) * (factInvMod(K) * factInvMod(N-K) % MOD) % MOD;}
else {
ll ans = 1; ll Ks = K < N-K ? K : N-K;
for (ll i=N; i > N-Ks; i--) {ans *= i; ans %= MOD;}
return ans * factInvMod(Ks) % MOD;
}
}
int main() {
std::ifstream in("input.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<Pii> WA(N, make_pair(0, 0));
rep(i, M){
int p;
string S;
cin >> p >> S;
p--;
if(S == "AC") WA[p].first = 1;
if(S == "WA" && WA[p].first == 0) WA[p].second++;
}
int resa = 0, resp = 0;
rep(i, N){
if(WA[i].first) {resa++; resp+=WA[i].second;}
}
cout << resa << " " << resp << endl;
}
| 0
| 93,503,542
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
using P = pair<int,int>;
const int mod = 1000000007;
int main(void){
int s;
cin >> s;
int dp[2020];
memset(dp, 0, sizeof(dp));
dp[0] = 0;
dp[1] = 0;
dp[2] = 0;
dp[3] = 1;
for(int i = 4; i <= s; i++){
dp[i] = dp[i - 3] + dp[i - 1];
dp[i] %= mod;
}
cout << dp[s] << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
int k;
int x;
int y;
int m;
cin>>n>>k>>x>>y;
if ((n - k) > 0)
{
m = k*x+(n-k)*y;
cout<<m<<endl;
}
else
{
m =n*x;
cout<<m<<endl;
}
return 0;
}
| 0
| 37,331,686
|
#include <bits/stdc++.h>
using namespace std;
#ifndef ONLINE_JUDGE
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
using bll = boost::multiprecision::cpp_int;
using bdouble = boost::multiprecision::cpp_dec_float_100;
#endif
#ifdef LOCAL_DEV
void debug_impl() { std::cerr << std::endl; }
template<typename Head, typename... Tail> void debug_impl(Head head, Tail... tail) { std::cerr << " " << head << (sizeof...(tail) ? "," : ""); debug_impl(tail...); }
#define debug(...) std::cerr << std::boolalpha << "(" << #__VA_ARGS__ << ") ="; debug_impl(__VA_ARGS__); std::cerr << std::noboolalpha;
#else
#define debug(...)
#endif
#ifdef LOCAL_TEST
#define BOOST_STACKTRACE_USE_ADDR2LINE
#define BOOST_STACKTRACE_ADDR2LINE_LOCATION /usr/local/opt/binutils/bin/addr2line
#define _GNU_SOURCE
#include <boost/stacktrace.hpp>
template<typename T> class dvector : public std::vector<T> {
public:
dvector() : std::vector<T>() {}
explicit dvector(size_t n, const T& value = T()) : std::vector<T>(n, value) {}
dvector(const std::vector<T>& v) : std::vector<T>(v) {}
dvector(const std::initializer_list<T> il) : std::vector<T>(il) {}
dvector(const typename std::vector<T>::iterator first, const typename std::vector<T>::iterator last) : std::vector<T>(first, last) {}
dvector(const std::string::iterator first, const std::string::iterator last) : std::vector<T>(first, last) {}
T& operator[](size_t n) {
try { return this->at(n); } catch (const std::exception& e) {
std::cerr << boost::stacktrace::stacktrace() << std::endl; return this->at(n);
}
}
const T& operator[](size_t n) const {
try { return this->at(n); } catch (const std::exception& e) {
std::cerr << boost::stacktrace::stacktrace() << std::endl; return this->at(n);
}
}
};
class dbool {
private:
bool boolvalue;
public:
dbool() : boolvalue(false) {}
dbool(bool b) : boolvalue(b) {}
dbool(const dbool &b) : boolvalue(b.boolvalue) {}
operator bool&() { return boolvalue; }
operator const bool&() const { return boolvalue; }
};
template<typename T> std::ostream& operator<<(std::ostream& s, const dvector<T>& v) {
for (int i = 0, len = v.size(); i < len; ++i){ s << v[i]; if (i < len - 1) s << "\t"; } return s; }
template<typename T> std::ostream& operator<<(std::ostream& s, const dvector< dvector<T> >& vv) {
for (int i = 0, len = vv.size(); i < len; ++i){ s << vv[i] << std::endl; } return s; }
template<typename T> std::ostream& operator<<(std::ostream& s, const std::set<T>& se) {
s << "{ "; for (auto itr = se.begin(); itr != se.end(); ++itr){ s << (*itr) << "\t"; } s << "}" << std::endl; return s; }
template<typename T> std::ostream& operator<<(std::ostream& s, const std::multiset<T>& se) {
s << "{ "; for (auto itr = se.begin(); itr != se.end(); ++itr){ s << (*itr) << "\t"; } s << "}" << std::endl; return s; }
template<typename T1, typename T2> std::ostream& operator<<(std::ostream& s, const std::map<T1, T2>& m) {
s << "{" << std::endl; for (auto itr = m.begin(); itr != m.end(); ++itr){ s << "\t" << (*itr).first << " : " << (*itr).second << std::endl; } s << "}" << std::endl; return s; }
template<typename T1, typename T2> std::ostream& operator<<(std::ostream& s, const std::pair<T1, T2>& p) {
return s << "(" << p.first << ", " << p.second << ")"; }
#define vector dvector
#define bool dbool
class SIGFPE_exception : std::exception {};
class SIGSEGV_exception : std::exception {};
void catch_SIGFPE(int e) { std::cerr << boost::stacktrace::stacktrace() << std::endl; throw SIGFPE_exception(); }
void catch_SIGSEGV(int e) { std::cerr << boost::stacktrace::stacktrace() << std::endl; throw SIGSEGV_exception(); }
signed convertedmain();
signed main() { signal(SIGFPE, catch_SIGFPE); signal(SIGSEGV, catch_SIGSEGV); return convertedmain(); }
#define main() convertedmain()
#endif
using ll = long long;
constexpr ll INF = (ll)1e18;
constexpr ll MOD = (ll)1e9 + 7;
constexpr double EPS = 1e-9;
constexpr int dx[4] = {1, 0, -1, 0};
constexpr int dy[4] = {0, 1, 0, -1};
#define p(var) std::cout<<var<<std::endl
#define rep(i, n) for(ll i=0, i##_length=(n); i< i##_length; ++i)
#define repeq(i, n) for(ll i=1, i##_length=(n); i<=i##_length; ++i)
#define all(v) (v).begin(), (v).end()
#define uniq(v) (v).erase(unique((v).begin(), (v).end()), (v).end());
template<typename T> inline void pv(vector<T> &v) { for(ll i=0, N=v.size(); i<N; i++) std::cout << v[i] << " \n"[i==N-1]; }
template<typename T> inline T gcd(T a, T b) { return b ? gcd(b,a%b) : a; }
template<typename T> inline T lcm(T a, T b) { return a / gcd(a, b) * b; }
template<typename T1, typename T2> inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }
template<typename T1, typename T2> inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }
class UnionFind {
public:
vector<ll> v;
UnionFind(size_t size) : v(size, -1) {}
ll root(ll x) {
return (v[x] < 0 ? x : v[x] = root(v[x]));
}
bool is_root(ll x) {
return x == root(x);
}
bool is_same(ll x, ll y) {
return root(x) == root(y);
}
bool unite(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (v[x] > v[y]) swap(x, y);
v[x] += v[y];
v[y] = x;
return true;
}
ll size(ll x) {
return -v[root(x)];
}
};
const ll N_MAX = 1e5;
const ll M_MAX = 1e5;
ll N, M;
vector<ll> p;
vector<ll> x;
vector<ll> y;
void solve() {
scanf("%lld%lld", &N, &M);
p.assign(N, 0);
rep(i, N) scanf("%lld", &p[i]);
x.assign(M, 0);
y.assign(M, 0);
rep(i, M) scanf("%lld%lld", &x[i], &y[i]);
UnionFind uf(N);
rep(i,M){
x[i]--;y[i]--;
uf.unite(x[i],y[i]);
}
ll ans = 0;
rep(i,N){
p[i]--;
if(uf.is_same(i,p[i]))ans++;
}
printf("%lld\n", ans);
}
signed main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin>>n;
pair<int, int> r[n], b[n];
for (int i=0; i<n; i++) cin>>r[i].first>>r[i].second;
for (int i=0; i<n; i++) cin>>b[i].first>>b[i].second;
sort(r, r + n);
sort(b, b + n);
bool used[n];
for (int i=0; i<n; i++) used[i] = false;
int cnt = 0;
for (int i=n-1; i>=0; i--) {
bool found = false;
int min_d = 200;
int i_min_d = -1;
for (int j=0; j<n; j++) {
if (used[j]) {
continue;
}
if (r[i].first < b[j].first && r[i].second < b[j].second) {
found = true;
if (b[j].second <= min_d) {
min_d = b[j].second;
i_min_d = j;
}
}
}
if (found) {
used[i_min_d] = true;
++cnt;
}
}
cout<<cnt<<endl;
}
| 0
| 20,561,714
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
void solve() {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v.push_back(a);
}
sort(v.rbegin(), v.rend());
int j = 0;
ll x = 1;
for (int i = 0; i < n; i++) {
if (v[i] == v[i+1]) {
x *= v[i];
j++;
i++;
if (j == 2) {
break;
}
}
}
if (j < 2) {
x = 0;
}
cout << x << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1, i = 1;
while(t--) {
solve();
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
long long MOD = 1000000000 + 7;
long long MAX = 1000000000000000000;
int main(){
cout << setprecision(10);
int N;
ll K;
cin >> N >> K;
vector<ll> A(N);
for(int i = 0; i < N; i++){
cin >> A.at(i);
}
vector<ll> B(N+1);
B[0] = 0;
for(int i = 0; i < N; i++){
B[i+1] = B[i] + A[i];
}
map<ll, int> m;
ll ans = 0;
for(int i = 0; i <= N; i++){
if(i >= K){
ll del = (B[i-K] - (i-K) ) % K;
m[del]--;
}
ll tmp = ( B[i] -i ) % K;
if(m.count(tmp) == 0){
m[tmp]++;
} else {
ans += m[tmp];
m[tmp]++;
}
}
cout << ans << endl;
}
| 0
| 49,258,211
|
#include<cstdio>
#include<cmath>
int main()
{
long long x,y;
scanf("%lld %lld",&x,&y);
printf(fabs(x-y)<2 ? "Brown" : "Alice");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ALL(c) (c).begin(), (c).end()
#define ALLR(c) (c).rbegin(), (c).rend()
#define FOR(i,a,b) for (int i=(a); i < (b); ++i)
#define FORR(i,a,b) for (int i=(a); i > (b); --i)
#define FOR_ALL(i,c) for (__typeof((c).begin()) i=(c).begin(); \
i != (c).end(); ++i)
#define FOR_ALLR(i,c) for (__typeof((c).rbegin()) i=(c).rbegin(); \
i != (c).rend(); ++i)
#define SZ(array) (sizeof(array)/sizeof(array[0]))
#define lc(x) (x<<1)
#define rc(x) (x<<1 | 1)
#define lowbit(x) (x & (-x))
typedef long long LL;
typedef map<int,int> MII;
typedef pair<int,int> PII;
typedef set<int> SI;
typedef vector<bool> VB;
typedef vector<double> VD;
typedef vector<int> VI;
typedef vector<string> VS;
template <class C>
inline bool in_(const typename C::key_type& k, const C& A)
{ return A.find(k) != A.end(); }
inline bool in_(const string& s, const string& S)
{ return S.find(s) != string::npos; }
int n,m,v,p;
vector<LL> A;
bool P(const int i, int v)
{
if (n-i <= p)
return true;
const LL x = A[i]+m;
int j = n - min(p,v);
if (x < A[n-p])
return false;
v -= n-(j+1)+1;
v -= i;
if (v > 0) {
while (A[j] > x)
j--;
const int y = j-i;
LL vol = x*y;
FOR(k,i+1,j+1)
vol -= A[k];
return vol >= 1LL * v*m;
}
return true;
}
int main()
{
#ifdef foo_
freopen("foo", "rt", stdin);
#endif
ios::sync_with_stdio(false);
while (cin >> n >> m >> v >> p) {
A.resize(n);
FOR(i,0,n)
cin >> A[i];
sort(ALL(A));
int lo = 0, hi = n-1;
while (lo < hi) {
const int mid = (lo+hi)/2;
if (P(mid,v))
hi = mid;
else
lo = mid+1;
}
cout << n-lo << endl;
}
return 0;
}
| 0
| 69,154,283
|
#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int main(void){
for(;;){
int n;
int a[10000]={0};
cin>>n;
if(n==0)break;
long long int sum=0;
long long int ans=-1000000;
for(int i=0;i<n;i++){
cin>>a[i];
}
for(int i=0;i<n;i++){
sum=0;
for(int j=i;j<n;j++){
sum+=a[j];
ans=max(ans,sum);
}
}
cout<<ans<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
#define PI 3.141592653589793
#define MOD 1000000007
#define ALL(obj) (obj).begin(),(obj).end()
template<class T>inline bool chmax(T& a,T b){if (a<b){a=b;return 1;}return 0;}
template<class T>inline bool chmin(T& a,T b){if (a>b){a=b;return 1;}return 0;}
const ll INF = 1LL << 56;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
struct edge{
ll from,to,cost;
};
typedef vector<vector<edge> > G;
ll gcd(ll a,ll b){
if (a%b==0)return(b);
else return(gcd(b,a%b));
}
int main(){
ll n;
cin >> n;
ll a[n];
for (ll i=0;i<n;i++){
cin >> a[i];
}
ll ans=0,x=1;
for (ll i=0;i<61;i++){
ll even=0,odd=0;
for (ll j=0;j<n;j++){
if (a[j]&(1LL<<i))odd++;
else even++;
}
ll p=(((odd%MOD)*(even%MOD))%MOD)*x;
ans+=p;
ans%=MOD;
x*=2;
x%=MOD;
}
cout << ans << endl;
return 0;
}
| 0
| 34,574,683
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 100100100;
int main(void){
int n;
cin >> n;
vector<int> x(n);
rep(i,n) cin >> x[i];
int ans = INF;
rep(i,105) {
int cnt = 0;
rep(j,n) {
int a = x[j] - i;
cnt += a*a;
}
ans = min(cnt, ans);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repr(i,n) for(int i = (int)(n); i >= 0; i--)
#define all(v) v.begin(),v.end()
typedef long long ll;
int main(){
ll H,W,D;
cin >> H >> W >> D;
vector<vector<ll> > grid(H, vector<ll>(W));
vector<pair<ll,ll> > grid_state(H * W + 1);
rep(i,H){
rep(j,W){
cin >> grid[i][j];
grid_state[grid[i][j]].first = i + 1;
grid_state[grid[i][j]].second = j + 1;
}
}
ll Q;
cin >> Q;
vector<pair<ll,ll> > test(Q);
rep(i,Q){
cin >> test[i].first >> test[i].second;
}
vector<ll> magic_power(H * W + 1);
for (ll i = 0; i <= D; i++){
magic_power[i] = 0;
}
for (ll i = D + 1; i <= H * W; i++){
magic_power[i] = magic_power[i - D] + abs(grid_state[i].first - grid_state[i - D].first) + abs(grid_state[i].second - grid_state[i - D].second);
}
rep(i,Q){
cout << magic_power[test[i].second] - magic_power[test[i].first] << endl;
}
}
| 0
| 18,089,703
|
#include <iostream>
#include <vector>
using namespace std;
vector<string> myhash(10000000);
void set(string& a){
int x = 0;
for(int i=0; i<a.size(); i++){
x *= 11;
x += a[i];
x %= 10000000;
}
while(true){
if(myhash[x].empty()){
myhash[x] = a;
break;
}
else if(myhash[x].compare(a)==0){
break;
}
else{
x++;
if(x > 10000000)
x -= 10000000;
}
}
}
void find(string& a){
int x = 0;
for(int i=0; i<a.size(); i++){
x *= 11;
x += a[i];
x %= 10000000;
}
while(true){
if(myhash[x].compare(a) == 0){
cout << "yes\n";
break;
}
else if(myhash[x].empty()){
cout << "no\n";
break;
}
else{
x++;
if(x > 10000000)
x -= 10000000;
}
}
}
int main(){
string a, b;
int n;
cin >> n;
while(n--){
cin >> a >> b;
if(a.compare("insert")==0)
set(b);
else
find(b);
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i,n) cin >> a.at(i);
deque<int> b;
if (n%2 == 0) {
rep(i,n) {
if (i%2 == 0) b.push_back(a.at(i));
else b.push_front(a.at(i));
}
}
else {
rep(i,n) {
if (i%2 == 0) b.push_front(a.at(i));
else b.push_back(a.at(i));
}
}
while (!b.empty()) {
cout << b.front();
b.pop_front();
if (!b.empty()) cout << ' ';
}
cout << endl;
return 0;
}
| 0
| 6,593,471
|
#pragma GCC optimize (3)
#include<vector>
#include<stack>
#include<bitset>
#include<cstdlib>
#include<cmath>
#include<set>
#include<list>
#include<deque>
#include<map>
#include<queue>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<iomanip>
#include<algorithm>
#include<unordered_map>
#define ll long long
#define ull unsigned long long
#define INFI 2147483647
#define INFL 9223372036854775807
#define INFU 18446744073709551615
using namespace std;
const double PI=acos(-1.0);
const double eps=1e-6;
inline ll read()
{
ll x=0,f=1;
char ch=getchar();
while(ch<'0' || ch>'9'){
if(ch=='-') f=-1;
ch=getchar();
}
while(ch>='0' && ch<='9'){
x=x*10+ch-'0';
ch=getchar();
}
return x*f;
}
template<typename T> void debug(T x)
{
cout<<"value="<<x<<endl;
return;
}
signed main()
{
ll s=read();
if(s<=1000000000) cout<<0<<' '<<0<<' '<<0<<' '<<s<<' '<<1<<' '<<0<<endl;
else if(s==1e18) cout<<0<<' '<<0<<' '<<0<<' '<<1000000000<<' '<<1000000000<<' '<<0<<endl;
else{
ll s1=s/1000000000;
s1++;
ll s2=s1*1000000000-s;
cout<<0<<' '<<0<<' '<<s1<<' '<<1<<' '<<s2<<' '<<1000000000<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define MAXN 100001
#define inf 1<<30
using namespace std;
struct node {
int x, dist;
node(int _x, int _dist) {
x = _x;
dist = _dist;
}
};
vector<node> G[MAXN];
int cost[MAXN];
bool viz[MAXN], flag = false;
int N, M;
void dfs(int node) {
int next;
if (flag == true) {
return;
}
viz[node] = true;
for (int i = 0; i < G[node].size(); ++i) {
next = G[node][i].x;
if (viz[next] == false) {
cost[next] = cost[node] + G[node][i].dist;
dfs(next);
} else if (cost[next] != cost[node] + G[node][i].dist) {
flag = true;
return;
}
}
}
int main()
{
int l, r, dist;
cin >> N >> M;
for (int i = 1; i <= M; ++i) {
cin >> l >> r >> dist;
G[l].push_back(node(r, dist));
G[r].push_back(node(l, -dist));
}
for (int i = 1; i <= N; ++i) {
if (viz[i] == false) {
cost[i] = 0;
dfs(i);
}
if (flag == true) {
cout << "No";
return 0;
}
}
cout << "Yes";
return 0;
}
| 0
| 72,733,146
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k, nn;
cin >> n >> k;
if(k == 1){
cout << 0;
return 0;
}
nn = n;
n -= k;
cout << n;
return 0;
}
|
#include <iostream>
#include <stack>
#include <algorithm>
#include<string.h>
using namespace std;
typedef pair<int,int>pa;
int ma[42][42];
int main(){
while(true){
int a,b,x,y;
int n;
cin>>a>>b;
if(a==0)break;
cin>>n;
memset(ma,0,sizeof(ma));
while(n--){
cin>>x>>y;x--;
ma[b-y][x]=-1;
}
ma[b-1][0]=1;
stack<pa>stk;
stk.push(pa(0, b-1));
while(stk.size()){
pa p=stk.top();
stk.pop();
x=p.first,y=p.second;
if(x+1<a&&ma[y][x+1]!=-1){
ma[y][x+1]+=1;
stk.push(pa(x+1,y));
}
if(y-1>-1&&ma[y-1][x]!=-1){
ma[y-1][x]+=1;
stk.push(pa(x,y-1));
}
}
cout<<ma[0][a-1]<<endl;
}
return 0;
}
| 0
| 61,934,067
|
#include <iostream>
using namespace std;
void Show_message(char button, int num)
{
switch(button)
{
case '1':
switch(num % 5)
{
case 1:
cout << '.'; break;
case 2:
cout << ','; break;
case 3:
cout << '!'; break;
case 4:
cout << '?'; break;
case 0:
cout << ' '; break;
}
break;
case '2':
switch(num % 3)
{
case 1:
cout << 'a'; break;
case 2:
cout << 'b'; break;
case 0:
cout << 'c'; break;
}
break;
case '3':
switch(num % 3)
{
case 1:
cout << 'd'; break;
case 2:
cout << 'e'; break;
case 0:
cout << 'f'; break;
}
break;
case '4':
switch(num % 3)
{
case 1:
cout << 'g'; break;
case 2:
cout << 'h'; break;
case 0:
cout << 'i'; break;
}
break;
case '5':
switch(num % 3)
{
case 1:
cout << 'j'; break;
case 2:
cout << 'k'; break;
case 0:
cout << 'l'; break;
}
break;
case '6':
switch(num % 3)
{
case 1:
cout << 'm'; break;
case 2:
cout << 'n'; break;
case 0:
cout << 'o'; break;
}
break;
case '7':
switch(num % 4)
{
case 1:
cout << 'p'; break;
case 2:
cout << 'q'; break;
case 3:
cout << 'r'; break;
case 0:
cout << 's'; break;
}
break;
case '8':
switch(num % 3)
{
case 1:
cout << 't'; break;
case 2:
cout << 'u'; break;
case 0:
cout << 'v'; break;
}
break;
case '9':
switch(num % 4)
{
case 1:
cout << 'w'; break;
case 2:
cout << 'x'; break;
case 3:
cout << 'y'; break;
case 0:
cout << 'z'; break;
}
break;
}
}
int main(void)
{
int n;
cin >> n;
char buf_ch;
cin >> noskipws;
cin >> buf_ch;
for (int i = 0; i < n; ++i)
{
while (true)
{
cin >> buf_ch;
if (buf_ch == '\n') break;
if (buf_ch == '0') continue;
int sum = 1;
char button = buf_ch;
while (true)
{
cin >> buf_ch;
if (buf_ch == '0')
{
Show_message(button, sum);
break;
}
else
{
++sum;
}
}
}
cout << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define llu long long unsigned int
#define pii pair<int,int>
#define PII pair<ll,ll>
const ll MAX=1e18+100;
const ll sz=1e5+100;
const ll mod=1e9+7;
ll n,tar;
PII dp[sz];
vector<ll> ad[sz];
void DFS(ll p,ll par)
{
dp[p].first=dp[p].second=1ll;
ll siz=ad[p].size();
for(ll i=0;i<siz;i++){
ll x=ad[p][i];
if(x != par){
DFS(x,p);
dp[p].first=(((dp[x].second+dp[x].first)%mod) * dp[p].first)%mod;
dp[p].second=(dp[x].first * dp[p].second)%mod;
}
}
}
int main()
{
ll m,p,q,i,j,k;
cin>>n;
for(i=1;i<n;i++){
cin>>p>>q;
ad[p].push_back(q);
ad[q].push_back(p);
}
DFS(1,-1);
ll ans=(dp[1].first+dp[1].second)%mod;
cout<<ans<<'\n';
}
| 0
| 99,162,044
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0;i < (int)(n);i++)
using ll = long long;
const ll MOD=998244353;
const long long INF = 1LL << 60;
const double pi=acos(-1.0);
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
ll mod_pow(long long x, long long n) {
long long ret = 1;
while (n > 0) {
if (n & 1) ret = ret * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return ret;
}
int main()
{
ll N; cin>>N;
vector<ll> D(N); rep(i,N) cin>>D[i];
if(D[0]!=0) {cout<<0<<endl; return 0;}
ll max_D=-INF;
rep(i,N) chmax(max_D,D[i]);
vector<ll> vec(max_D+1,0); rep(i,N) vec[D[i]]++;
if(vec[0]!=1) {cout<<0<<endl; return 0;}
ll ans=1; rep(i,max_D) ans=ans*mod_pow(vec[i],vec[i+1])%MOD;
cout<<ans<<endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
using namespace std;
void SelectSort(int x[], int N);
void BubbleSort(int x[], int N);
void InsertSort(int x[], int N, int num);
void ShellSort(int x[], int N);
void Trace(int x[], int N);
int gCount = 0;
int main() {
int N;
cin >> N;
int x[N];
for (int i = 0; i < N; i++) {
cin >> x[i];
}
SelectSort(x, N);
Trace(x, N);
cout << gCount << endl;
return 0;
}
void SelectSort(int x[], int N) {
int min;
for (int i = 0; i < N - 1; i++) {
min = i;
for (int j = i; j < N; j++) {
if (x[min] > x[j]) {
min = j;
}
}
if (i != min) {
gCount++;
swap(x[min], x[i]);
}
}
}
void Trace (int x[], int N) {
int i;
for (i = 0; i < N - 1; i++) {
cout << x[i] << " ";
}
cout << x[i] << endl;
}
| 0
| 76,104,799
|
#include <stdio.h>
int main()
{
long int n,a,e;
scanf("%ld %ld",&n,&a);
if(n<500 && n>a)
{
printf("No\n");
}
else if(n>=500)
{
e=n%500;
if(e==0 || e<=a)
{
printf("Yes\n");
}
else if(e>a)
{
printf("No\n");
}
}
else if(n<=a)
{
printf("Yes\n");
}
return 0;
}
|
#include<iostream>
#include<cstring>
using namespace std;
struct Node
{
int data;
Node* next;
Node* prev;
};
class List
{
private:
Node* mother;
public:
List()
{
mother = new Node;
mother->data = -1;
mother->next = this->mother;
mother->prev = this->mother;
}
~List()
{
Node *tmp;
tmp = mother->next;
while (1)
{
tmp = tmp->next;
delete tmp->prev;
if (tmp == mother)
break;
}
delete mother;
}
void Ins(int x)
{
Node *tmp;
tmp = this->mother->next;
this->mother->next = new Node;
this->mother->next->data = x;
this->mother->next->next = tmp;
this->mother->next->prev = mother;
tmp->prev = mother->next;
return;
}
void Del(int x)
{
Node *tmp;
tmp = this->mother->next;
while (tmp != this->mother)
{
if (tmp->data == x)
{
tmp->prev->next = tmp->next;
tmp->next->prev = tmp->prev;
delete tmp;
break;
}
tmp = tmp->next;
}
return;
}
void DelFirst()
{
Node *tmp;
tmp = this->mother->next;
tmp->next->prev = mother;
this->mother->next = tmp->next;
delete tmp;
}
void DelLast()
{
Node *tmp;
tmp = this->mother->prev;
this->mother->prev = tmp->prev;
tmp->prev->next = mother;
delete tmp;
}
void Show()
{
Node *tmp;
tmp = mother->next;
cout << tmp->data;
tmp = tmp->next;
while (tmp != mother)
{
cout << " " << tmp->data;
tmp = tmp->next;
}
cout << endl;
return;
}
};
int main()
{
int n, x;
char command[20];
List list;
cin >> n;
for (int i = 0; i < n; i++)
{
cin >> command;
if (!strcmp(command, "insert"))
{
cin >> x;
list.Ins(x);
}
else if (!strcmp(command, "delete"))
{
cin >> x;
list.Del(x);
}
else if (!strcmp(command, "deleteFirst"))
list.DelFirst();
else
list.DelLast();
}
list.Show();
return 0;
}
| 0
| 90,731,625
|
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
int main()
{
int coin[] = {500, 100, 50, 10, 5, 1};
for(;;){
int n;
cin >> n;
if(n == 0)
return 0;
n = 1000 - n;
int ret = 0;
for(int i=0; i<6; ++i){
while(n >= coin[i]){
n -= coin[i];
++ ret;
}
}
cout << ret << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> plan(n,vector<int>(3));
for (int i = 0; i < n; i++){
for (int j = 0; j < 3; j++){
cin >> plan.at(i).at(j);
}
}
bool ans=true;
int nx=0;
int ny=0;
int nt=0;
for (vector<int> v: plan){
int t=v.at(0);
int x=v.at(1);
int y=v.at(2);
if(t-nt<abs(x-nx)+abs(y-ny)||(t-nt)%2!=(abs(x-nx)+abs(y-ny))%2){
cout << "No" << endl;
ans=false;
break;
}
nx=x;
ny=y;
nt=t;
}
if(ans){
cout << "Yes" << endl;
}
}
| 0
| 32,501,423
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int v,e;cin>>v>>e;
vector<vector<long long>> dist(v,vector<long long>(v,1e12)) ;
for (int i = 0; i < v; i++) {
dist[i][i] = 0;
}
for (int i = 0; i < e; i++) {
int s,t,d;cin>>s>>t>>d;
dist[s][t] = d;
}
for (int mid = 0; mid < v; mid++)
for (int frm = 0; frm < v; frm++)
for (int des = 0; des < v; des++)
{
dist[frm][des] = min(dist[frm][des],dist[frm][mid] + dist[mid][des]);
}
for (int i = 0; i < v; i++)
{
if(dist[i][i] < 0)
{
cout<<"NEGATIVE CYCLE"<< endl;
return 0;
}
}
for (int i = 0; i < v; i++)
{
if(dist[i][0] <= 1e11)cout << dist[i][0];
else cout << "INF";
for (int j = 1; j < v; j++)
{
if(dist[i][j] <= 1e11)cout << " " << dist[i][j];
else cout << " " << "INF";
}
cout << endl;
}
}
|
#include<iostream>
#include<algorithm>
#define inf 1000000000
using namespace std;
int main(){
while(1){
int n;
int in1[100];
int in2[100];
int in3[100];
cin>>n;
if(n==0)break;
for(int i=0;i<n;i++){
cin>>in1[i]>>in2[i]>>in3[i];
}
int maxi=0;
for(int i=0;i<n;i++){
maxi=max(maxi,in1[i]);
maxi=max(maxi,in2[i]);
}
int m=maxi+1;
int C[100][100];
for(int i=0;i<100;i++){
for(int j=0;j<100;j++){
C[i][j]=inf;
}
}
for(int i=0;i<n;i++){
C[in2[i]][in1[i]]=C[in1[i]][in2[i]]=in3[i];
}
for(int k=0;k<m;k++){
for(int i=0;i<m;i++){
for(int j=0;j<m;j++){
C[i][j]=min(C[i][j],C[i][k]+C[k][j]);
}
}
}
int maxo;
int maxn=inf;
int ans[100];
for(int i=0;i<m;i++){
ans[i]=0;
for(int j=0;j<m;j++){
ans[i]+=C[i][j];
}
ans[i]-=C[i][i];
if(maxn>ans[i]){
maxn=ans[i];
maxo=i;
}
}
printf("%d %d\n",maxo,maxn);
}
}
| 0
| 46,819,501
|
#include <bits/stdc++.h>
#define ALL(obj) begin(obj), end(obj)
#define debug(x) cerr << #x << ": " << x << '\n'
using namespace std;
template <class T>
vector<T> make_vec(size_t a) {
return vector<T>(a);
}
template <class T, class... Ts>
auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
using ll = long long;
using ull = unsigned long long;
const int INF = 1e9;
int main() {
int N, H;
cin >> N >> H;
vector<int> a(N), b(N);
for (int i = 0; i < N; i++) {
cin >> a[i] >> b[i];
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
int ma = a[N - 1];
int cnt = 0;
for (int i = N - 1; i >= 0; i--) {
if (b[i] > ma) {
cnt++;
H -= b[i];
} else {
break;
}
if (H <= 0) {
cout << cnt << endl;
return 0;
}
}
cout << cnt + (H + ma - 1) / ma << endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <queue>
#include <algorithm>
#include <utility>
#include <cmath>
using namespace std;
using ll=long long;
using pint=pair<int,int>;
#define rep(i,a,b) for(ll i=a;i<ll(b);i++)
#define repr(i,a,b) for(ll i=a;i>=ll(b);i--)
#define el '\n'
#define ALL(x) x.begin(),x.end()
#define ALLR(x) x.rbegin(),x.rend()
#define INF 1e9
#define DEBUG(x) cout<<"debug: "<<x<<endl
#define $in(v,n) ;rep(II,0,n)cin>>v[II]
inline void IN(void){return;}
template<typename F,typename... R>inline void IN(F& f, R&... r){cin>>f;IN(r...);}
template<class T>inline bool chmin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
template<class T>inline bool chmax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
int main(){
int k, n;
IN(k, n);
vector<int> a(n+1);
int f; cin >> f; a[0] = 0;
rep(i, 1, n){
int t; cin >> t;
t -= f;
a[i] = t;
}
a[n] = k;
ll tot = 0;
int maxL = 0;
rep(i, 1, n+1){
int t = a[i] - a[i-1];
chmax(maxL, t);
tot += t;
}
cout << tot-maxL << el;
return 0;
}
| 0
| 92,836,431
|
#include <bits/stdc++.h>
#include <ext/rope>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define int long long
#define pb push_back
#define x first
#define y second
#define mk(a,b) make_pair(a,b)
#define rr return 0
#define sqr(a) ((a)*(a))
#define all(a) (a).begin(), (a).end()
#define sz(a) (int)(a).size()
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template<class value, class cmp = less<value> >
using ordered_set = tree<value, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class value, class cmp = less_equal<value> >
using ordered_multiset = tree<value, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class key, class value, class cmp = less<key> >
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int randll(int l = INT_MIN, int r = INT_MAX) {
return uniform_int_distribution<int>(l, r)(rng);
}
const int INF = 1e9, MOD = 1e9 + 7;
const ll LINF = 1e18;
const int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
inline bool inside (int x, int y, int n, int m) {
return 0 <= x && 0 <= y && x < n && y < m;
}
template<class T> bool umin (T &a, T b) {return a > b ? (a = b, true) : false; }
template<class T> bool umax (T &a, T b) {return a < b ? (a = b, true) : false; }
main()
{
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
if (n % 2 == 1) {
cout << "0\n";
rr;
}
ll ans = 0;
for (int st = 10; st <= n; st *= 5) {
ans += n / st;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> P;
typedef tuple<int,int,int> tpl;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define SORT(c) sort((c).begin(),(c).end())
#define REVERSE(c) reverse((c).begin(),(c).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RFOR(i,a,b) for(int i=(a)-1;i>=(b);--i)
#define RREP(i,n) RFOR(i,n,0)
const double EPS = 1e-9;
const double PI = acos(-1.0);
const int INT_INF = 2147483647;
const long long LL_INF = 1LL<<60;
const long long MOD = 1000000007;
#define CLR(a) memset((a), 0 ,sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
int main(void){
int N; cin >> N;
int c = 5*(1e+4);
VI a(N), b(N);
REP(i,N){
a[i] = (i+1)*c-20000;
b[N-1-i] = (i+1)*c-20000;
}
VI p(N); REP(i,N) cin >> p[i];
REP(i,N){
a[p[i]-1] += i;
b[p[i]-1] += i;
}
REP(i,N) cout << a[i] << " ";
cout << endl;
REP(i,N) cout << b[i] << " ";
cout << endl;
return 0;
}
| 0
| 49,978,974
|
#include <iostream>
#include <string>
using namespace std;
int main() {
string s, ans=""; cin>>s;
for (int i=0; i<s.length(); i += 2) ans += s[i];
cout<<ans<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s,t;
cin>>s>>t;
int c=0;
if(s.length()==t.length())
{
for(int i=0;i<s.length();i++)
{
if(s[i]!=t[i])
c++;
}
}
cout<<c;
}
| 0
| 48,756,849
|
#include <iostream>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <cstring>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>
#include <bitset>
#include <ctime>
#include <complex>
using namespace std;
#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define RFOR(i,b,a) for (int i = (b)-1; i >= (a); i--)
#define ITER(it,a) for (__typeof(a.begin()) it = a.begin(); it != a.end(); it++)
#define FILL(a,value) memset(a, value, sizeof(a))
#define SZ(a) (int)a.size()
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
const double PI = acos(-1.0);
const int INF = 1000 * 1000 * 1000 + 7;
const LL LINF = INF * (LL) INF;
const int MOD = 1000 * 1000 * 1000 + 7;
const double EPS = 1e-6;
const int MAX = 33;
int main()
{
int n, m, d;
cin >> n >> m >> d;
string S = "RGBY";
FOR(i, 0, n)
{
FOR(j, 0, m)
{
int ii = (i + j);
int jj = (i - j + d * 1000);
int ib = ii / d;
int jb = jj / d;
int col = (ib % 2) * 2 + (jb % 2);
printf("%c", S[col]);
}
printf("\n");
}
return 0;
}
|
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cassert>
#include<iostream>
#include<iomanip>
#include<map>
#include<unordered_map>
#include<set>
#include<unordered_set>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
using namespace std;
#define DEBUG(x) cout<<#x<<"="<<x<<endl
#define DEBUG2(x,y) cout<<#x<<"="<<x<<","<<#y<<"="<<y<<endl
typedef long long ll;
const int MAXN=3e5+10;
const ll MOD=10;
ll _gcd(ll a,ll b){if(b==0)return a;return _gcd(b,a%b);}
ll gcd(ll a,ll b){a=abs(a),b=abs(b);if(a<b)swap(a,b);return _gcd(a,b);}
ll qpow(ll a,ll n){ll rt=1;while(n){if(n&1)rt=(rt*a)%MOD;a=a*a%MOD;n>>=1;}return rt;}
ll factor[MAXN];
void cal_factor(){factor[0]=1;for(int u=1;u<MAXN;u++){factor[u]=(factor[u-1]*u)%MOD;}}
ll C(ll n,ll k){return factor[n]*qpow(factor[n-k],MOD-2)%MOD*qpow(factor[k],MOD-2)%MOD;}
int H,W,M;
int col[MAXN];
int row[MAXN];
void solve(){
ios::sync_with_stdio(false);
cin.tie(0);
cin>>H>>W>>M;
set<pair<int,int>>tgt;
for(int u=0;u<M;u++){
int h,w;
cin>>h>>w;
tgt.insert({h,w});
row[h]++;
col[w]++;
}
vector<pair<int,int>>r,c;
for(int u=1;u<=H;u++){
if(row[u])r.push_back({row[u],u});
}
for(int u=1;u<=W;u++){
if(col[u])c.push_back({col[u],u});
}
sort(r.begin(),r.end());
reverse(r.begin(),r.end());
sort(c.begin(),c.end());
reverse(c.begin(),c.end());
int ans=0;
int acr=r.front().first;
for(auto p:c){
int t=acr+p.first;
if(tgt.count({r.front().second,p.second}))t--;
ans=max(ans,t);
}
acr=c.front().first;
for(auto p:r){
int t=acr+p.first;
if(tgt.count({p.second,c.front().second}))t--;
ans=max(ans,t);
}
cout<<ans;
}
int main()
{
#ifdef LOCAL
freopen("in.txt","r",stdin);
#endif
solve();
}
| 0
| 1,235,562
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
vector<int> D(N - 1);
for (int i = 0; i < N - 1; i++){
cin >> D.at(i);
}
int sum = 0;
sum += D.at(0);
for (int i = 1; i < N - 1; i++){
sum += min(D.at(i - 1), D.at(i));
}
sum += D.at(N - 2);
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
ll combination(ll n, ll r) {
if (n / 2 <= r) {
r = n - r;
}
ll res = 1;
for (ll i = 0; i < r; ++i) {
res *= (n - i);
}
for (ll i = r; i > 0; --i) {
res /= i;
}
return res;
}
int main() {
ll n, p; cin >> n >> p;
vector<ll> a(n);
for (ll i = 0; i < n; ++i) {
cin >> a[i];
}
ll even = 0;
ll odd = 0;
for (ll i = 0; i < n; ++i) {
if (a[i] % 2 == 0) {
++even;
} else {
++odd;
}
}
ll sum = 0;
for (ll i = 1; i <= odd; i += 2) {
ll com = combination(odd, i);
com *= (ll)pow(2, even);
sum += com;
}
if (p == 1) {
cout << sum << endl;
} else {
cout << (ll)pow(2, n) - sum << endl;
}
}
| 0
| 94,443,577
|
#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
#include<map>
#include<set>
#include<string>
#define fast_io ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
using namespace std;
#define debug(x) cout<<(#x)<<"="<<(x)<<", ";
#define debug1(x) debug(x) cout<<'\n';
#define debug2(x1, x2) debug(x1) debug(x2) cout<<'\n';
#define debug3(x1, x2, x3) debug(x1) debug(x2) debug(x3) cout<<'\n';
#define debug4(x1, x2, x3, x4) debug(x1) debug(x2) debug(x3) debug(x4) cout<<'\n';
#define debug5(x1, x2, x3, x4, x5) debug(x1) debug(x2) debug(x3) debug(x4) debug(x5) cout<<'\n';
typedef long long int lli;
typedef unsigned long long int ulli;
typedef pair<int,int> pi;
typedef pair<lli,lli> plli;
typedef vector<int> vi;
typedef vector<lli> vlli;
typedef vector<pi> vpi;
typedef vector<plli> vplli;
const lli M=1000000007ll;
int main(){
fast_io
string s; cin>>s;
for(int i=0; i<s.size(); ++i){
if(s[i]==',') cout<<" ";
else cout<<s[i];
}
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <set>
#include <map>
#include <queue>
#include <math.h>
using namespace std ;
using ll = long long ;
using vll = vector<ll> ;
using vvll = vector<vll> ;
using vc = vector<char> ;
using vvc = vector<vc> ;
using pll = pair<ll,ll> ;
#define all(v) v.begin(),v.end()
ll mod = 1000000007 ;
ll INF = 1000000000000 ;
ll gcd(long long a,long long b){if(b==0) return a ; return gcd(b,a%b) ;}
ll lcm(long long a,long long b){return a/gcd(a,b)*b ;}
void chmax(ll &a,ll b){ if(a<b) a = b ;}
void chmin(ll &a,ll b){ if(a>b) a = b ;}
int main(){
ll n ; cin >> n ;
vll a(n),b(n),h(n,-1) ;
for(auto &i:a) cin >> i ;
for(auto &i:b) cin >> i ;
for(int i=0;i<n;i++) if(i==0||a[i-1]<a[i]) h[i] = a[i] ;
for(int i=n-1;i>=0;i--){
if(i==n-1||b[i]>b[i+1]){
if(h[i]!=-1&&h[i]!=b[i]){
cout << 0 << endl ;
return 0 ;
}
h[i] = b[i] ;
}
}
ll mx = 0 ;
for(int i=0;i<n;i++){
chmax(mx,h[i]) ;
if(mx!=a[i]){
cout << 0 << endl ;
return 0 ;
}
}
mx = 0 ;
for(int i=n-1;i>=0;i--){
chmax(mx,h[i]) ;
if(mx!=b[i]){
cout << 0 << endl ;
return 0 ;
}
}
ll ans = 1 ;
for(int i=0;i<n;i++){
if(h[i]!=-1) continue ;
ans = ans*min(a[i],b[i])%mod ;
}
cout << ans << endl ;
}
| 0
| 72,575,782
|
# 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] = { 0,1,0,-1 }, dy[4] = { 1,0,-1,0 };
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) sort(ALL((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)
int main(){
int n;
cin >> n;
vector<int> p(n);
REP(i, n)cin >> p[i];
map<int, int> Pinv;
REP(i, n)Pinv[p[i]] = i;
multiset<int> shown;
shown.insert(-1);
shown.insert(-1);
shown.insert(n);
shown.insert(n);
LL ans = 0;
for(LL i = n;i >= 1;--i){
int now = Pinv[i];
LL r = *shown.lower_bound(now);
LL rr = *next(shown.lower_bound(now));
LL l = *prev(shown.lower_bound(now));
LL ll = *prev(shown.lower_bound(now), 2);
ans += ((rr - r) * (now - l) + (l - ll) * (r - now)) * i;
shown.insert(now);
}
cout << ans << endl;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <queue>
#include <stack>
#include <cmath>
#include <iomanip>
#include <map>
#include <cstring>
#define ll long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define repp(i,n) for(int i=n-1;i>=0;i--)
#define fi first
#define se second
using namespace std;
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;}
typedef pair<int,int> P;
const ll MOD = 1000000007;
const int INF = 1001001001;
int main(){
string x,y; cin >> x >> y;
int lx=x.size();
int ly=y.size();
int dp[ly][lx];
bool b1=0,b2=0;
if(x[0]!=y[0]) dp[0][0]=1;
else{
dp[0][0]=0;
b1=b2=1;
}
rep(i,ly-1){
if(y[i+1]!=x[0]||b1) dp[i+1][0]=dp[i][0]+1;
else{
dp[i+1][0]=dp[i][0];
b1=1;
}
}
rep(i,lx-1){
if(y[0]!=x[i+1]||b2) dp[0][i+1]=dp[0][i]+1;
else{
dp[0][i+1]=dp[0][i];
b2=1;
}
}
for(int i=1;i<ly;i++){
for(int j=1;j<lx;j++){
int c=0;
if(y[i]!=x[j])c++;
dp[i][j]=min(dp[i-1][j]+1,min(dp[i][j-1]+1,dp[i-1][j-1]+c));
}
}
cout << dp[ly-1][lx-1] << endl;
return 0;
}
| 0
| 11,020,080
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
using ll = long long;
using p = pair<int,int>;
int main(int argc, const char * argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
string s1,s2,s3;
cin>>s1>>s2>>s3;
if(s1[s1.size()-1]==s2[0]&&s2[s2.size()-1]==s3[0])cout<<"YES"<<endl;
else cout<<"NO"<<endl;
return 0;
}
|
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <functional>
#include <iterator>
#include <numeric>
#include <cstdint>
#include <cmath>
#include <bitset>
#include <string>
#include <list>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define N_TIMES(i, n) for ( uint64_t i = 0; i < n; ++i )
#define N_TIMES_REV(i, n) for ( int64_t i = n - 1; i >= 0; --i )
using namespace std;
namespace State { enum { Unknown = 0, Vacant = 1, Male, Female }; };
int query(uint64_t x)
{
cout << x << endl;
string y;
cin >> y;
if (y == "Vacant") { return State::Vacant; } else
if (y == "Male") { return State::Male; } else
if (y == "Female") { return State::Female; } else
return State::Unknown;
}
uint64_t search(int S, int T, uint64_t L, uint64_t R)
{
auto length_is_odd = [](uint64_t L, uint64_t R) {
return ((R - L + 1) & 1) == 1;
};
uint64_t X = (L + R) >> 1;
if (R - L <= 1) { return L; }
int status = query(X);
if (status == State::Vacant) {
return X;
}
if (length_is_odd(L, X)) {
if (S != status) {
return search(S, status, L, X);
}
} else {
if (S == status) {
return search(S, status, L, X);
}
}
if (length_is_odd(X, R)) {
if (T != status) {
return search(status, T, X, R);
}
} else {
if (T == status) {
return search(status, T, X, R);
}
}
return static_cast<uint64_t>(-1);
}
uint64_t solve(uint64_t N)
{
int status_L = query(0), status_R = query(N - 1);
if (status_L == State::Vacant) { return 0; }
if (status_R == State::Vacant) { return N - 1; }
return search(status_L, status_R, 0, N - 1);
}
int main()
{
uint64_t N;
cin >> N;
cout << solve(N) << endl;
return 0;
}
| 0
| 76,058,437
|
#include<bits/stdc++.h>
int N;
int A;
using namespace std;
int main() {
cin >> N >> A;
if (N%500 <= A) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
|
#include <iostream>
#include <iterator>
#include <vector>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <numeric>
#include <iomanip>
#include <limits>
#include <set>
#include <map>
#include <type_traits>
#include <cstdint>
#include <queue>
#define _USE_MATH_DEFINES
#include <math.h>
#include <sstream>
#include <bitset>
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
using namespace std;
void factoring(ll n, map<ll, ll>& mp) {
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
mp[i]++;
n /= i;
}
}
if (n != 1) mp[n]++;
}
template<class T, class U = std::make_unsigned_t<T>>
U SafeAbs( T x ) {
return x < 0 ? -static_cast<uintmax_t>(x) : x;
}
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll mod_pow(ll x, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll mod_inv(ll x, ll mod) {
return mod_pow(x, mod - 2, mod);
}
ll ncr(ll n, ll r, ll mod){
ll res=1;
ll num=1,den=1;
for(ll i=n;i>=n-r+1;i--){
(den*=i)%=mod;
}
for(ll i=1;i<=r;i++){
(num*=i)%=mod;
}
res=den*mod_inv(num,mod);
return res%mod;
}
bool isOk(ll index, ll key,vector<ll> &a){
if(a[index]>key){
return true;
}
return false;
}
ll bin_search(ll key, vector<ll> &a){
ll l=-1;
ll r=a.size();
while(abs(r-l)>1){
ll mid = (l+r)/2;
if(isOk(mid, key, a)){
r=mid;
}
else{
l=mid;
}
}
return r;
}
const ll MOD=1000000007;
ll min(ll a, ll b){
if(a>=b){
return b;
}
else{
return a;
}
}
void solve(){
ll n;
cin >> n;
vector<ll> a(3*n, 0);
for (ll i = 0; i < n; i++)
{
cin >> a[i];
}
for (ll i = 0; i < n;i++)
{
a[i + n] = a[i] + 1;
a[i + n + n] = a[i] - 1;
}
sort(a.begin(), a.end());
ll max = 1;
ll count = 1;
for (ll i = 0; i < 3 * n - 1; i++)
{
if(a[i]==a[i+1]){
count++;
}
else{
if(count>max){
max = count;
}
count = 1;
}
}
cout << max << endl;
}
int main(){
solve();
return 0;
}
| 0
| 1,191,900
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
#define pb push_back
#define f(i,n) for(i=0;i<n;i++)
#define F(i,a,b) for(i=a;a<=b;i++)
#define arr(a,n) for( i=0;i<n;i++)cin>>a[i];
#define fi first
#define se second
#define mp make_pair
#define mod 1000000007
#define YES cout<<"YES"<<endl;
#define Yes cout<<"Yes"<<endl;
#define NO cout<<"NO"<<endl;
#define No cout<<"No"<<endl;
#define yes cout<<"yes"<<endl;
#define no cout<<"no"<<endl;
#define vi vector<ll>
#define ed end()
#define bg begin()
#define sz size()
#define ln length()
#define s() sort(a,a+n);
#define sr() sort(a,a+n,greater<ll>());
#define v() sort(v.begin(),v.end());
#define vr() sort(v.begin(),v.end(),greater<ll>());
#define mod 1000000007
#define fast() ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
ll gcd(ll a, ll b){if(!b)return a;return gcd(b, a % b);}
ll power(ll x,ll y,ll p){ll res=1;x%=p;while(y>0){if(y&1)res=(res*x)%p;y=y>>1;x=(x*x)%p;}return res;}
int main() {
fast();
{
ll n,m,x,y,f=0;
cin>>n>>m>>x>>y;
ll a[n],b[m];
for(int i=0;i<n;i++)
{
cin>>a[i];
}
for(int i=0;i<m;i++)
{
cin>>b[i];
}
sort(a,a+n);
sort(b,b+m);
ll temp=a[n-1]+1;
if(b[0]>=temp&&b[0]<=y&&b[0]>x)
f=1;
if(f)
{
cout<<"No War"<<endl;
}
else
{
cout<<"War"<<endl;
}
}
return 0;
}
|
#include<iostream>
#include<bits/stdc++.h>
#include<vector>
using namespace std;
int main()
{
int n,l;
cin>>n;
vector<int>v;
int a[n];
for(int i=0;i<n;i++){
cin>>a[i];
}
int d=a[0];
int c=0;
for(int i=0;i<n;i++){
if(a[i]<=d){
c++;
v.push_back(a[i]);
d=a[i];
}
}
cout<<c<<endl;
return 0;
}
| 0
| 31,635,087
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.