code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <iostream>
#include <cstdio>
using namespace std;
int table[11][11];
int main() {
int N;
while (cin >> N) {
if (N == 0) break;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
cin >> table[i][j];
}
}
int total = 0;
for (int i = 0; i < N; i++) {
int sum = 0;
for (int j = 0; j < N; j++) {
sum += table[i][j];
}
table[i][N] = sum;
total += sum;
}
for (int i = 0; i < N; i++) {
int sum = 0;
for (int j = 0; j < N; j++) {
sum += table[j][i];
}
table[N][i] = sum;
}
table[N][N] = total;
for (int i = 0; i < N+1; i++) {
for (int j = 0; j < N+1; j++) {
printf("%5d", table[i][j]);
}
printf("\n");
}
}
return 0;
}
|
#include <iostream>
#include<math.h>
using namespace std;
int smallest = 1000000;
int x, threez, N;
int main()
{
while (cin >> N && N != 0) {
smallest = 1000000;
for(int z = 0; pow(z, 3) <= N; z++) {
threez = pow(z, 3);
for(int y = 0; pow(y, 2) <= N - threez; y++) {
x = N - threez - pow(y, 2);
if (x + y + z < smallest) {
smallest = x + y + z;
}
}
}
cout << smallest << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using pll = pair<ll, ll>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(i) begin(i), end(i)
const int INF = 0x3fffffff;
const ll MINF = 0x7fffffffffff;
const ld DINF = numeric_limits<ld>::infinity();
const int MOD = 1000000007;
const int MODD = 998244353;
const ld EPS = 1e-9;
const ld PI = 3.1415926535897932;
template<class T> bool chmin(T &a, const T &b){ if(a > b){ a = b; return 1; } else return 0; }
template<class T> bool chmax(T &a, const T &b){ if(a < b){ a = b; return 1; } else return 0; }
template<class T> auto min(const T& a){ return *min_element(all(a)); }
template<class T> auto max(const T& a){ return *max_element(all(a)); }
ll gcd(ll a, ll b){ while(b){ ll c = b; b = a % b; a = c; } return a; }
ll lcm(ll a, ll b){ if(!a || !b) return 0; return a * b / gcd(a, b); }
ll pow_mod(ll n,ll k,ll m){ll r = 1;for(; k > 0;k >>= 1) {if (k & 1) r = (r * n) % m; n = (n * n) % m;}return r;}
//ここから。
int main(){
string S;
cin >> S;
if(S.size() % 2==0){
rep(i,S.size()/2){
if(!(S.at(i*2) == 'h' && S.at(i*2 + 1)=='i')){
cout << "No" << endl;
return 0;
}
}
}else{
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
}
|
#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};
///**************************DONE****************************///
int x[] = {111, 222, 333, 444, 555, 666, 777, 888, 999};
int main()
{
int n;
cin >> n;
for(int i = 0; i < 9; i++){
if(x[i] >= n)
return cout << x[i] << '\n', 0;
}
return 0;
}
| 0 |
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define FOR(i,k,n) for(int(i)=(k);(i)<(n);++(i))
#define rep(i,n) FOR(i,0,n)
#define all(v) begin(v),end(v)
#define debug(x) std::cerr<<#x<<": "<<x<<"\n"
#define debug2(x,y) std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<"\n"
#define debug3(x,y,z) std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<", "<<#z<<": "<<z<<"\n"
using ll=long long;
using vi=std::vector<int>;
using vvi=std::vector<vi>;
using vll=std::vector<ll>;
using vvll=std::vector<vll>;
template<typename T> using vvec=std::vector<std::vector<T>>;
template<typename T>
auto make_v(size_t sz){return std::vector<T>(sz);}
template<typename T,typename... Ts>
auto make_v(size_t sz,Ts...ts){return std::vector<decltype(make_v<T>(ts...))>(sz,make_v<T>(ts...));}
template<typename T>
void fill_v(T&var,const T&x){var=x;}
template<typename V,typename T>
void fill_v(V&v,const T&x){for(auto&& w:v){fill_v(w,x);}}
template<typename T> std::ostream& operator<<(std::ostream&s,const std::vector<T>&v){
int sz=v.size();s<<"\n";rep(i,sz){s<<v[i];if(i<sz-1){s<<"\t";}}s<<"\n";return s;}
template<typename T> std::ostream& operator<<(std::ostream&s,const std::vector<std::vector<T>>&v){
for(auto&& w:v){s<<w;}return s;}
template<typename T> std::ostream& operator<<(std::ostream&s,const std::deque<T>&v){
int sz=v.size();s<<"\n";rep(i,sz){s<<v[i];if(i<sz-1){s<<"\t";}}s<<"\n";return s;}
template<typename T> std::ostream& operator<<(std::ostream&s,const std::deque<std::deque<T>>&v){
for(auto&& w:v){s<<w;}return s;}
template<typename T> std::ostream& operator<<(std::ostream&s, const std::set<T>&v){
s<<"\n";for(auto&& elm:v){s<<elm<<"\t";}s<<"\n";return s;}
inline void scan(int&a){scanf("%d",&a);}
inline void scan(ll&a){scanf("%lld",&a);}
inline void scan(char&a){scanf(" %c",&a);}
inline void scan(double&a){scanf("%lf",&a);}
template<typename T>
inline void scan(std::vector<T>&v){for(auto&& sv:v){scan(sv);}}
template<typename First,typename...Args>
inline void scan(First&f,Args&...args){scan(f);scan(args...);}
inline void scan(std::string&s){char BUF[3000000];scanf(" %s",BUF);s=std::string(BUF);}
inline void print(int a){printf("%d\n",a);}
inline void print(ll a){printf("%lld\n",a);}
inline void print(double a){printf("%.12f\n",a);}
inline void print(std::string s){std::cout<<s<<"\n";}
using namespace std;
int mod = 1000000007;
bool is_wafu(vi& x, int m) {
return ((m >> (x[2] - 1)) & 1)
&& ((m >> (x[2] + x[1] - 1)) & 1)
&& ((m >> (x[2] + x[1] + x[0] - 1)) & 1);
}
int main() {
int n;
scan(n);
vi x(3);
scan(x);
int sumd = x[0] + x[1] + x[2];
ll bitdpmax = (1LL << sumd);
vector<bool> wafu(bitdpmax << 1);
rep (i, bitdpmax << 1) {
wafu[i] = is_wafu(x, i);
}
vll dp(bitdpmax, 0);
dp[0] = 1;
vll dp_;
rep (i, n) {
dp_.assign(bitdpmax, 0);
rep (j, bitdpmax) {
if (dp[j] == 0) { continue; }
if (wafu[j]) { continue; }
FOR (k, 1, 11) {
int nj = (j << k) + (1 << (k-1));
nj &= ((bitdpmax << 1) - 1);
if (wafu[nj]) { continue; }
nj &= (bitdpmax - 1);
dp_[nj] = (dp_[nj] + dp[j]) % mod;
}
}
swap(dp, dp_);
}
ll ans = 1;
rep (i, n) {
ans = ans * 10 % mod;
}
rep (j, bitdpmax) {
ans = (ans + mod - dp[j]) % mod;
}
print(ans);
return 0;
}
|
#include<bits/stdc++.h>
#define int long long
#define rg register
#define file(x) freopen(x".in","r",stdin);freopen(x".out","w",stdout);
using namespace std;
const int mod=1e9+7;
int read(){
int x=0,f=1;char c=getchar();
while(c<'0'||c>'9') f=(c=='-')?-1:1,c=getchar();
while(c>='0'&&c<='9') x=x*10+c-48,c=getchar();
return f*x;
}
int f[41][262143+10];
int ksm(int a,int b){
int ans=1;
while(b){
if(b&1) ans=ans*a%mod;
a=a*a%mod;
b>>=1;
}
return ans;
}
main(){
//file("");
int n=read(),x=read(),y=read(),z=read(),len=(1<<(x+y+z))-1,res=1<<(x+y+z-1),ans=0;
res=res|(1<<(y+z-1)),res=res|(1<<(z-1)),f[0][0]=1;
for(int i=1;i<=n;i++)
for(int j=0;j<=len;j++){
if(f[i-1][j]==0) continue;
for(int k=1;k<=10;k++){
int z=(j<<k)|(1<<(k-1));
z&=len;
if((z&res)==res) continue;
f[i][z]=(f[i-1][j]+f[i][z])%mod;
}
}
for(int i=0;i<=len;i++)
ans=(ans+f[n][i])%mod;
cout<<(ksm(10,n)-ans+mod)%mod;
return 0;
}
| 1 |
#include<stdio.h>
int main (){
int number, A,B,C;
scanf("%d", &number );
A = number / 100;
B = number % 100 / 10;
C = number % 10;
if (A == 7 || B == 7 || C == 7)
{
printf("Yes\n");
}
else
{
printf("No\n");
}
return 0;
}
|
#include<iostream>
using namespace std;
int f(int x){
return x*x;
}
int main(){
int x;
while(cin>>x){
int ans=0;
for(int i=1;i<600/x;i++)ans+=f(i*x)*x;
cout<<ans<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string N;
cin >> N;
if (N.size() == 3) reverse(N.begin(), N.end());
cout << N << endl;
}
|
#include <iostream>
#include <string>
using namespace std;
int main() {
int n;
cin >> n;
string s;
getline(cin, s);
for (int i = 0; i < n; i++) {
getline(cin, s);
for (int i = 6; i < s.length(); i++)
if (s[i-6] == 'H' &&
s[i-5] == 'o' &&
s[i-4] == 's' &&
s[i-3] == 'h' &&
s[i-2] == 'i' &&
s[i-1] == 'n' &&
s[i] == 'o')
s[i] = 'a';
cout << s << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int const M = 1e9 + 7;
vector<int> memo(5500000, -1);
string K; int D;
int count(size_t i, int total, bool upto) {
if (i == K.size()) return total == 0;
// 14 bits for index, 7 bits for total, 1 bit for upto
int key = (i << 9) + (total << 1) + upto;
if (memo[key] >= 0) return memo[key];
int sum = 0, leading = K[i] - '0';
for (int digit = 0; digit <= (upto ? leading : 9); ++digit) {
if (digit == leading)
sum += count(i+1, (total+digit) % D, upto);
else
sum += count(i+1, (total+digit) % D, false);
sum %= M;
}
return memo[key] = sum;
}
int main() {
ios_base::sync_with_stdio(false);
getline(cin, K);
cin >> D;
int answer = count(0, 0, true) - 1;
if (answer < 0) answer += M;
cout << answer << endl;
}
|
#include <bits/stdc++.h>
#define name "vd"
#define ini freopen(name".inp", "r", stdin); freopen(name".out", "w", stdout)
#define fastio ios_base::sync_with_stdio(0); cin.tie(0)
#define oo 1e9 + 7;
#define PII pair<int, int>
#define long long long
using namespace std;
const int NMAX = 1e4 + 5;
const int MOD = 1e9 + 7;
string s;
int d, n, nxt;
long dp[NMAX][2][105];
int main()
{
//ini;
fastio;
cin >> s >> d;
n = s.size();
s = "0" + s;
memset(dp, 0, sizeof dp);
dp[0][0][0] = 1;
for (int i = 1; i <= n; i++){
for (int lss = 0; lss <= 1; lss++){
for (int j = 0; j < d; j++){
for (int dg = 0; dg <= 9; dg++){
if (!dp[i - 1][lss][j]) continue;
if (!lss && dg > (s[i] - '0')) continue;
if (!lss && dg == (s[i] - '0')) nxt = 0;
else nxt = 1;
dp[i][nxt][(j + dg) % d] += dp[i - 1][lss][j] % MOD;
}
}
}
}
cout << ((dp[n][0][0] + dp[n][1][0] - 1) % MOD + MOD) % MOD;
return 0;
}
| 1 |
#include<cstdio>
#include<algorithm>
#define fo(i,a,b) for(i=a;i<=b;i++)
#define fd(i,a,b) for(i=a;i>=b;i--)
using namespace std;
const int maxn=1000000+10;
char a[maxn],b[maxn],sta[maxn];
int dl[maxn*3][2];
int i,j,k,l,t,n,m,tot,head,tail,ans,mi,cnt,num;
bool czy;
int main(){
scanf("%d",&n);
scanf("%s",a+1);
scanf("%s",b+1);
fo(i,1,n+1)
if (i>n||a[i]!=b[i]) break;
if (i>n){
printf("0\n");
return 0;
}
czy=1;
mi=n+1;
i=n;k=n+1;
head=n+1;tail=n;
while (i){
j=i;
while (j>1&&b[j-1]==b[i]) j--;
k=min(k,j);
while (k&&a[k]!=b[i]) k--;
if (!k){
czy=0;
break;
}
while (head<=tail){
if (dl[tail][0]-num>i) tail--;
else break;
}
cnt++;
num++;
head--;
dl[head][0]=k+num;
dl[head][1]=1-cnt;
ans=max(ans,dl[tail][1]+cnt);
i=j-1;
}
if (!czy) printf("-1\n");
else printf("%d\n",ans);
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,f,n) for(int i=(f);i<(n);i++)
#define all(v) (v).begin(),(v).end()
#define each(it,v) for(__typeof((v).begin()) it=(v).begin();it!=(v).end();it++)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
int dx[]={-1,0,1,0};
int dy[]={0,-1,0,1};
int H,W,sy,sx,gy,gx;
int N;
int C[100][100];
bool vis[100][100];
signed main(){
while(cin>>W>>H,W||H){
cin>>sx>>sy>>gx>>gy;
cin>>N;
sy--;sx--;gy--;gx--;
memset(C,0,sizeof(C));
rep(i,N){
int c,d,x,y;
cin>>c>>d>>x>>y;
x--;y--;
for(int dy=0;dy<2;dy++){
for(int dx=0;dx<4;dx++){
int ny,nx;
if(!d)ny=y+dy,nx=x+dx;
else ny=y+dx,nx=x+dy;
C[ny][nx]=c;
}
}
}
if(!C[sy][sx]){
cout<<"NG"<<endl;
continue;
}
memset(vis,0,sizeof(vis));
queue<pint>que;
que.push(pint(sy,sx));
vis[sy][sx]=true;
while(que.size()){
int y,x;
tie(y,x)=que.front();
que.pop();
rep(i,4){
int ny=y+dy[i],nx=x+dx[i];
if(ny<0||ny>=H||nx<0||nx>=W||C[y][x]!=C[ny][nx]||vis[ny][nx])continue;
vis[ny][nx]=true;
que.push(pint(ny,nx));
}
}
if(vis[gy][gx])cout<<"OK"<<endl;
else cout<<"NG"<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define ll long long
#define str string
#define pii pair<int, int>
#define pll pair<ll, ll>
#define fi first
#define se second
#define vc vector<char>
#define vvc vector<vc>
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define vvll vector<vll>
#define vvvll vector<vvll>
#define vs vector<str>
#define vvs vector<vs>
#define vpii vector<pii>
#define vvpii vector<vpii>
#define vpll vector<pll>
#define vvpll vector<vpll>
#define vb vector<bool>
#define vvb vector<vb>
#define rep(i, a, b) for (int i = (a); i < int(b); i++)
#define repi(i, a, b) for (int i = (a); i <= int(b); i++)
using namespace std;
ll INF = LONG_LONG_MAX;
ll mod = 1000000000 + 7;
template <typename T, typename L>
void readVector(vector<T> & _data, L & _size, bool _shift) {
_data.resize(_size + (ll)_shift);
for (ll i = (ll)_shift; i < _size + (ll)_shift; i++)
cin >> _data[i];
}
template <typename T, typename L>
void readMatrix(vector<vector<T>> & _data, L & _rows, L & _cols, bool _shiftRows, bool _shiftCols) {
_data.resize(_rows + (ll)_shiftRows);
for (ll i = 0; i < _rows + (ll)_shiftRows; i++)
_data[i].resize(_cols + (ll)_shiftCols);
for (ll i = (ll)_shiftRows; i < _rows + (ll)_shiftRows; i++)
for (ll j = (ll)_shiftCols; j < _cols + (ll)_shiftCols; j++)
cin >> _data[i][j];
}
//TODO: SOLUTION
ll n;
vll a, pre, f, g;
void computeG() {
ll j = n - 2;
g[n - 1] = n;
while (j >= 1) {
int k = g[j + 1];
while (abs(pre[n] - (2*pre[k - 1]) + pre[j - 1]) > abs(pre[n] - (2*pre[k - 2]) + pre[j - 1]))
k--;
g[j] = k;
j--;
}
}
void computeF() {
ll j = 3;
f[2] = 1;
while (j <= n) {
int k = f[j - 1];
while (abs(pre[j] - (2*pre[k])) > abs(pre[j] - (2*pre[k + 1])))
k++;
f[j] = k;
j++;
}
}
void solve() {
cin >> n;
readVector(a, n, 1);
pre.resize(n + 1, 0);
repi(i, 1, n) {
pre[i] = pre[i - 1] + a[i];
}
f.resize(n + 1);
g.resize(n + 1);
computeF();
computeG();
ll ans = INF;
repi(i, 2, n - 2) {
ans = min(ans, max(max(max(pre[f[i]], pre[i] - pre[f[i]]), pre[n] - pre[g[i + 1] - 1]), pre[g[i + 1] - 1] - pre[i])
-min(min(min(pre[f[i]], pre[i] - pre[f[i]]), pre[n] - pre[g[i + 1] - 1]), pre[g[i + 1] - 1] - pre[i]));
}
cout << ans << endl;
}
int main() {
// TODO: Set value of this variable manually
bool _multipleTestCases = false;
if (_multipleTestCases) {
ll t; cin >> t;
while (t--)
solve();
}
else {
solve();
}
return 0;
}
|
#include <iostream>
#include <stdio.h>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <cstring>
#include <algorithm>
#include <math.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
#define FOR(i,n,m) for(int i=n; i<(int)m; i++)
#define ROF(i,n,m) for(int i=n; i>(int)m; i--)
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define F first
#define S second
#define ri(a) scanf("%d",&a)
#define rii(a,b) ri(a),ri(b)
#define riii(a,b,c) rii(a,b),ri(c)
#define lri(a) scanf("%lld",&a)
#define lrii(a,b) lri(a),lri(b)
#define ms(obj,val) memset(obj,val,sizeof(obj))
#define all(x) x.begin(),x.end()
#define debug true
#define dprintf debug && printf
const int INF = 0x3f3f3f3f;
const ll INFLL = 1e18;
const int MOD = 1e9+7;
const int MAXN = 2e5+5;
ll pref[MAXN];
int n;
ll sum(int l, int r){
if(l > r) return 0;
return pref[r] - (l == 0 ? 0 : pref[l-1]);
}
ll dif(int l, int r, int m){
return abs(sum(l, m-1) - sum(m, r));
}
void mxze(ll &a, ll b){
a = max(a,b);
}
void mnze(ll &a, ll b){
a = min(a,b);
}
ll result(int m1, int m, int m2){
ll mx = sum(0,m1-1);
mxze(mx, sum(m1,m-1));
mxze(mx, sum(m,m2-1));
mxze(mx, sum(m2,n-1));
ll mn = sum(0,m1-1);
mnze(mn, sum(m1,m-1));
mnze(mn, sum(m,m2-1));
mnze(mn, sum(m2,n-1));
return mx - mn;
}
bool check(int l, int r, int m){
return dif(l, r, m) > dif(l,r,m+1);
}
int findBest(int l, int r){
int lo = l + 1, hi = r;
while(lo < hi){
int mid = (lo + hi)>>1;
if(check(l, r, mid)) lo = mid + 1;
else hi = mid;
}
return hi;
}
int main(){
//ios_base::sync_with_stdio(false);
//cin.tie(NULL);
ri(n);
FOR(i,0,n) lri(pref[i]);
FOR(i,1,n) pref[i] += pref[i-1];
ll ans = INFLL;
FOR(m,2,n-1){
mnze(ans, result(findBest(0,m-1), m, findBest(m, n-1)));
}
printf("%lld\n", ans);
return 0;
}
| 1 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
#define inf (1<<29)
#define MAX_V 100010
using namespace std;
typedef pair<int,int> ii;
typedef vector<ii> vii;
typedef vector<int> vi;
const int DFS_WHITE = -1; // unvisited
const int DFS_BLACK = 1; // visited
int V,E;
int dfsNumberCounter,rootChildren,dfsRoot;
vi dfs_num,dfs_low,dfs_parent,articulation_vertex;
vii AdjList[MAX_V];// ii(neighbor,weight)
void articulationPointAndBridge(int u)
{
dfs_low[u] = dfs_num[u] = dfsNumberCounter++;
for(int j=0;j<(int)AdjList[u].size();j++)
{
ii v = AdjList[u][j];
if(dfs_num[v.first] == DFS_WHITE)
{
dfs_parent[v.first] = u;
if(u == dfsRoot)rootChildren++;
articulationPointAndBridge(v.first);
if(dfs_low[v.first] >= dfs_num[u])
articulation_vertex[u] = true;
//if(dfs_low[v.first] > dfs_num[u])
//printf("Edge (%d,%d) is a bridge\n",u,v.first);
dfs_low[u] = min(dfs_low[u],dfs_low[v.first]);
}
else if(v.first != dfs_parent[u])
dfs_low[u] = min(dfs_low[u],dfs_num[v.first]);
}
}
void compute()
{
dfsNumberCounter = 0; dfs_num.assign(V,DFS_WHITE); dfs_low.assign(V,0);
dfs_parent.assign(V,0); articulation_vertex.assign(V,0);
//puts("Bridges:");
for(int i = 0; i < V; i++)
if(dfs_num[i] == DFS_WHITE)
{
dfsRoot = i; rootChildren = 0;
articulationPointAndBridge(i);
articulation_vertex[dfsRoot] = (rootChildren > 1);// special case
}
//puts("Articulation Points");
for(int i = 0; i < V; i++)
if(articulation_vertex[i])
printf("%d\n",i);
//printf("Vertex %d\n",i);
}
int main()
{
scanf("%d%d",&V,&E);
rep(i,V)AdjList[i].clear();
rep(i,E)
{
int s,t;
scanf("%d%d",&s,&t);
AdjList[s].push_back(ii(t,1));
AdjList[t].push_back(ii(s,1));
}
compute();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
void display()
{
int a, b, ar[3];
cin>>a>>b;
ar[0] = a+ b, ar[1] = a - b , ar[2] = a * b;
sort(ar, ar + 3);
cout<<ar[2]<<endl;
}
int main(void)
{
display();
}
| 0 |
#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(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using P = pair<int,int>;
static const double PI = acos(-1);
static const int INF = 1e9+7;
#define REP(i,n) for (int i = 0; i <(n); ++i)
//debug
#ifdef _DEBUG
#define debug(var) do{cout << #var << " :";view(var);}while(0)
#else
#define debug(...)
#endif
template<typename T> void view(T e){cout << e << endl;}
template<typename T> void view(const vector<T>& v){for(const auto& e : v){ cout << e << " "; } cout << endl;}
template<typename T> void view(const vector<vector<T> >& vv){ for(const auto& v : vv){ view(v); } }
int main(){
int a, b, c;
cin >> a >> b >> c;
int k;
cin >> k;
if(c > b) swap(b,c);
if(b > a) swap(a,b);
if(c > b) swap(b,c);
// cout << a << b << c;
REP(i,k){
a *= 2;
}
int ans = a + b + c;
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
#define pii_ pair<int,int>
#define mp_ make_pair
#define pb push_back
#define fi first
#define se second
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define show1(a) cout<<#a<<" = "<<a<<endl
#define show2(a,b) cout<<#a<<" = "<<a<<"; "<<#b<<" = "<<b<<endl
using namespace std;
const ll INF = 1LL<<60;
const int inf = 1<<30;
const int maxn = 2e5+5;
inline void fastio() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);}
int main()
{
fastio();
int a,b,c;
cin>>a>>b>>c;
cout<<min(min(a+b,b+c),a+c)<<endl;
return 0;
}
| 0 |
#include <algorithm>
#include <cassert>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#include <limits.h>
using namespace std;
typedef long long ll;
template<class T>
inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
}
template<class T>
inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
}
vector<int> problems;
vector<int> bonus;
int solve(const int bits, const int D, const ll G) {
ll score = 0;
int ans = 0;
priority_queue<int> que;
for (int i = 0; i < D; i++) {
if (bits & (1 << i)) {
score += (i + 1) * 100 * problems[i];
score += bonus[i];
ans += problems[i];
} else {
for (int j = 0; j < max(0, problems[i] - 1); j++) {
que.push((i + 1) * 100);
}
}
}
while (!que.empty() && score < G) {
auto v = que.top();
que.pop();
score += v;
ans++;
}
if (score < G) {
return -1;
} else {
return ans;
}
}
int main(void) {
int D;
ll G;
cin >> D >> G;
problems.resize(D);
bonus.resize(D);
for (int i = 0; i < D; i++) {
cin >> problems[i] >> bonus[i];
}
int ans = INT_MAX / 2;
for (int bits = 0; bits < (1 << D); bits++) {
int cand = solve(bits, D, G);
if (cand >= 0) {
// printf("bits: %x, required: %d\n", bits, cand);
chmin(ans, cand);
}
}
cout << ans << endl;
return 0;
}
|
#include <cstdio>
#include <string>
#include <algorithm>
using namespace std;
int main() {
char buf[1<<10];
size_t q;
scanf("%s %zu", buf, &q);
string str(buf);
for (size_t i=0; i<q; ++i) {
size_t a, b;
scanf("%s %zu %zu", buf, &a, &b);
string instr(buf);
if (instr == "print") {
printf("%s\n", str.substr(a, b-a+1).c_str());
} else if (instr == "reverse") {
reverse(str.begin()+a, str.begin()+b+1);
} else if (instr == "replace") {
scanf("%s", buf);
string p(buf);
str.replace(a, b-a+1, p);
}
}
return 0;
}
| 0 |
#define LOCAL
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<(n); ++i)
#define rrep(i, n) for(int i=(n-1); i>=0; --i)
#define rep2(i, s, n) for(int i=s; i<(n); ++i)
#define ALL(v) (v).begin(), (v).end()
#define memr(dp, val) memset(dp, val, sizeof(dp))
using namespace std;
typedef long long ll;
static const int INTINF = (INT_MAX >> 1); // 10^9 + 10^7
static const ll LLINF = (LLONG_MAX >> 1);
static const int MAX = 1e5+1;
static const ll MOD = 1e9+7;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class T> inline bool int_ceil(T a, T b) { T res = a / b; if(a % b != 0) res++; return res; }
template<typename T>
using min_priority_queue = priority_queue<T, vector<T>, greater<T> >;
string to_string(string s) { return '"' + s + '"'; }
string to_string(bool b) { return b ? "true" : "false"; }
template <size_t N> string to_string(bitset<N> bs) {
string res;
for (size_t i = 0; i < N; ++i) res += '0' + bs[i];
return res;
}
string to_string(vector<bool> v) {
string res = "{";
for (bool e : v) res += to_string(e) + ", ";
return res += "}";
}
template <class T, class U> string to_string(pair<T, U> p);
template <class C> string to_string(C c) {
string res = "{";
for (auto e : c) res += to_string(e) + ", ";
return res += "}";
}
template <class T, class U> string to_string(pair<T, U> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
void debug() { cerr << '\n'; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << '\t' << to_string(head), debug(tail...);
}
#ifdef LOCAL
#define print(...) cerr << "[" << #__VA_ARGS__ << "]:", debug(__VA_ARGS__)
#else
#define print(...)
#endif
void answer(bool ok){
if(ok) cout << "POSSIBLE" << endl;
else cout << "IMPOSSIBLE" << endl;
}
vector<ll> dividedNum(ll n){
//n == 2 && n == 1の時エラー
vector<ll> res;
ll lim = sqrt(n)+1;
for(ll i=1; i<lim; i++){
if(n%i==0){
res.push_back(i);
if(i != n / i && lim <= n/i){
res.push_back(n/i);
}
}
}
return res;
}
int main(int argc, const char * argv[]) {
std::cout << std::fixed << std::setprecision(15);
ll N, K; cin >> N >> K;
vector<ll> v(N);
rep(i, N) cin >> v[i];
sort(ALL(v));
if(K > v[N-1]){
answer(false);
return 0;
}
if(N == 1){
answer(v[0] == K);
return 0;
}
if(v[0] == 1) {
answer(true);
return 0;
}
bool hasTwoBaisu = true;
auto divs = dividedNum(v[0]);
ll res = 1;
for(ll x : divs){
// print(x);
if(x == 1) continue;
bool ok = true;
rep(i, N){
if(v[i] % x != 0) ok = false;
}
if(ok) {
chmax(res, x);
hasTwoBaisu = false;
}
}
// print(hasTwoBaisu);
// print(res);
if(!hasTwoBaisu){
answer(K % res == 0);
}
else{
answer(true);
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define repit(itr,x) for(auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr,x) for(auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
int main(){
int n, k;
cin >> n >> k;
int g;
bool f = false;
rep(i, n){
int in;
cin >> in;
if(in >= k) f = true;
if(i == 0) g = in;
else g = __gcd(in, g);
}
if(f == true && k % g == 0) cout << "POSSIBLE" << endl;
else cout << "IMPOSSIBLE" << endl;
return 0;
}
| 1 |
#include <iostream>
#include <vector>
using namespace std;
class BIT {
public:
BIT(int n) : a(n) {}
void add(int p, long long num)
{
while (p < a.size()) {
a[p] += num;
p |= p + 1;
}
}
/* i から j までの和 */
long long sum(int i, int j)
{
long long s = 0, t = 0;
i--;
while (i >= 0) {
s += a[i];
i = (i & (i + 1)) - 1;
}
while (j >= 0) {
t += a[j];
j = (j & (j + 1)) - 1;
}
return t - s;
}
private:
vector<long long> a;
};
int main()
{
int n, q;
cin >> n >> q;
BIT b(n);
for (int i = 0; i < n; i++) {
int a;
cin >> a;
b.add(i, a);
}
for (int i = 0; i < q; i++) {
int p, q, r;
cin >> p >> q >> r;
if (p == 1) {
cout << b.sum(q, r - 1) << endl;
} else {
b.add(q, r);
}
}
return 0;
}
|
#include<atcoder/all>
using namespace atcoder;
#include<bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
#define rep(i,n) for(int i=0; i<(n); i++)
int main() {
int N, Q; scanf("%d%d", &N, &Q);
fenwick_tree<LL> G(N);
rep(i, N) { int a; scanf("%d", &a); G.add(i, a); }
rep(q, Q) {
int c; scanf("%d", &c);
if (c == 0) {
int p, x; scanf("%d%d", &p, &x);
G.add(p, x);
}
if (c == 1) {
int l, r; scanf("%d%d", &l, &r);
printf("%lld\n", G.sum(l,r));
}
}
return 0;
}
| 1 |
/*
* Project: AtCoder Beginners Contest 105 A - AtCoder Crackers
* Author: toms74209200 <https://github.com/toms74209200>
*
* Created on 2020/06/16
* Copyright (c) 2020 toms74209200
*
* This software is released under the MIT License.
* http://opensource.org/licenses/mit-license.php
*/
#include <cstdio>
using namespace std;
int n, k;
void solve() {
int rem = n % k;
if (rem == 0)
printf("0\n");
else
printf("1\n");
}
int main() {
scanf("%d", &n);
scanf("%d", &k);
solve();
}
|
#include <iostream>
using namespace std;
int main(){
int n,k;
cin >> n >> k;
int c = 1;
int i;
for(i=0;i<n;i++){
if(c<=k) c*=2;
else c+=k;
}
cout << c << "\n";
return 0;
}
| 0 |
#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 dp[105][10];
int mod = 1000000007;
int main() {
int H, W, K; cin >> H >> W >> K;
dp[0][0] = 1;
for (int i = 0; i < H; i++){
for (int j = 0; j < 1<<(W-1); j++){
bool ok = true;
for (int k = 0; k < (W-2); k++){
if(j>>k&1 == 1 && j>>(k+1)&1 == 1){
ok = false;
}
}
if(!ok)continue;
for (int k = 0; k < W; k++){
int t = k;
if(j>>(k-1)&1 == 1)t = k-1;
if(j>>(k)&1 == 1)t = k+1;
dp[i+1][t] += dp[i][k];
dp[i+1][t] %= mod;
}
}
}
cout << dp[H][K-1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pint = pair<int, int>;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
const int INF=1e9+7;
const ll LINF=9223372036854775807;
const ll MOD=1e9+7;
const ld PI=acos(-1);
const ld EPS = 1e-10; //微調整用（EPSより小さいと0と判定など）
int ii() { int x; if (scanf("%d", &x)==1) return x; else return 0; }
long long il() { long long x; if (scanf("%lld", &x)==1) return x; else return 0; }
string is() { string x; cin >> x; return x; }
char ic() { char x; cin >> x; return x; }
void oi(int x) { printf("%d ", x); }
void ol(long long x) { printf("%lld ", x); }
void od_nosp(double x) { printf("%.15f", x); } // 古い問題用
void od(double x) { printf("%.15f ", x); }
// long doubleで受け取り、fをLfなどに変えて出力すると、変な数値が出る
// それをなんとかするには独自の出力を作らなければならなそう
void os(const string &s) { printf("%s ", s.c_str()); }
void oc(const char &c) { printf("%c ", c); }
#define o_map(v){cerr << #v << endl; for(const auto& xxx: v){cout << xxx.first << " " << xxx.second << "\n";}} //動作未確認
void br() { putchar('\n'); }
// #define gcd __gcd //llは受け取らない C++17~のgcdと違うので注意
// int lcm(int a, int b){return a / gcd(a, b) * b;}
#define begin_end(a) a.begin(),a.end() //sort(begin_end(vec));
#define REP(i,m,n) for(ll i=(ll)(m) ; i < (ll)(n) ; i++ )
#define DREP(i,m,n) for(ll i=(ll)(m) ; i > (ll)(n) ; i-- )
#define rep(i,n) REP(i,0,n)
#define m_p(a,b) make_pair(a,b)
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define p_b push_back
#define SZ(x) ((int)(x).size) //size()がunsignedなのでエラー避けに
// coutによるpairの出力（空白区切り）
template<typename T1, typename T2> ostream& operator<<(ostream& s, const pair<T1, T2>& p) {return s << "(" << p.first << " " << p.second << ")";}
// coutによるvectorの出力（空白区切り）
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v) {
int len = v.size();
for (int i = 0; i < len; ++i) {
s << v[i]; if (i < len - 1) s << " "; //"\t"に変えるとTabで見やすく区切る
}
return s;
}
// coutによる多次元vectorの出力（空白区切り）
template<typename T> ostream& operator<<(ostream& s, const vector< vector<T> >& vv) {
int len = vv.size();
for (int i = 0; i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
//最大値、最小値の更新。更新したor等しければtrueを返す
template<typename T>
bool chmax(T& a, T b){return (a = max(a, b)) == b;}
template<typename T>
bool chmin(T& a, T b){return (a = min(a, b)) == b;}
//4近傍（上下左右） rep(i, 2) にすると右・下だけに進む
vector<int> dx_4 = {1, 0, -1, 0};
vector<int> dy_4 = {0, 1, 0, -1};
// -------- template end - //
// - library ------------- //
// --------- library end - //
int main(){
ll n, m, d;
cin >> n >> m >> d;
ld ans;
if (d==0){
ans = ld(m-1) / n;
}
else if (n - d - d <= 0){
ans = ld(m-1) / n; // d==0 のときと結果は同じ
}
else{
// n-2d >= 1
ans = ld((n-d-d)*2 + (d+d)) / n * (m-1) / n;
}
od_nosp(ans);
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1LL << 60;
ll H, W;
ll A[85][85], B[85][85];
ll AB[85][85];
const ll D = 160 * 80 + 10; // あり得る長さ
const ll D2 = D * 2; // あり得る値の範囲
typedef bitset<D2> bs;
// [r][c] にきたときに、この値はあり得るか。0 or 1
bs dp[85][85];
int main() {
cin >> H >> W;
rep(i, H)rep(j, W) cin >> A[i][j];
rep(i, H)rep(j, W) cin >> B[i][j];
rep(i, H)rep(j, W) AB[i][j] = abs(A[i][j] - B[i][j]);
dp[0][0][D - AB[0][0]] = 1;
dp[0][0][D + AB[0][0]] = 1;
rep(i, H)rep(j, W) {
if (i) {
// たす
dp[i][j] |= dp[i - 1][j] << AB[i][j];
// 引く
dp[i][j] |= dp[i - 1][j] >> AB[i][j];
}
if (j) {
// たす
dp[i][j] |= dp[i][j - 1] << AB[i][j];
// 引く
dp[i][j] |= dp[i][j - 1] >> AB[i][j];
}
}
// 答えを求める D の分を戻す
ll ans = INF;
rep(i, D2) {
if (dp[H - 1][W - 1][i]) ans = min(ans, abs(i - D));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int H, W;
cin >> H >> W;
vector<vector<int>> A(H, vector<int>(W)), B(H, vector<int>(W));
for (int i = 0; i < H; i++)
{
for (int j = 0; j < W; j++)
{
cin >> A.at(i).at(j);
}
}
for (int i = 0; i < H; i++)
{
for (int j = 0; j < W; j++)
{
cin >> B.at(i).at(j);
}
}
vector<vector<int>> d(H, vector<int>(W));
for (int i = 0; i < H; i++)
{
for (int j = 0; j < W; j++)
{
d.at(i).at(j) = abs(A.at(i).at(j) - B.at(i).at(j));
}
}
auto to_id = [&](int i, int j) {
return i * W + j;
};
vector<vector<bool>> dp(H * W, vector<bool>(80 * 160 + 1));
dp.at(to_id(0, 0)).at(d.at(0).at(0)) = true;
for (int i = 1; i < H; i++)
{
for (int k = 0; k < 80 * 160 + 1; k++)
{
if (dp.at(to_id(i - 1, 0)).at(k))
{
dp.at(to_id(i, 0)).at(abs(k + d.at(i).at(0))) = true;
dp.at(to_id(i, 0)).at(abs(k - d.at(i).at(0))) = true;
}
}
}
for (int j = 1; j < W; j++)
{
for (int k = 0; k < 80 * 160 + 1; k++)
{
if (dp.at(to_id(0, j - 1)).at(k))
{
dp.at(to_id(0, j)).at(abs(k + d.at(0).at(j))) = true;
dp.at(to_id(0, j)).at(abs(k - d.at(0).at(j))) = true;
}
}
}
for (int i = 1; i < H; i++)
{
for (int j = 1; j < W; j++)
{
for (int k = 0; k < 80 * 160 + 1; k++)
{
if (dp.at(to_id(i - 1, j)).at(k))
{
dp.at(to_id(i, j)).at(abs(k + d.at(i).at(j))) = true;
dp.at(to_id(i, j)).at(abs(k - d.at(i).at(j))) = true;
}
if (dp.at(to_id(i, j - 1)).at(k))
{
dp.at(to_id(i, j)).at(abs(k + d.at(i).at(j))) = true;
dp.at(to_id(i, j)).at(abs(k - d.at(i).at(j))) = true;
}
}
}
}
for (int k = 0; k < 80 * 160 + 1; k++)
{
if (dp.at(to_id(H - 1, W - 1)).at(k))
{
cout << k << endl;
break;
}
}
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main()
{
int n, a, b, count = 0, pointX = 0, pointY = 0;
cin >> n;
do {
cin >> a >> b;
if (a > b) {
pointX += (a + b);
}
else if (a < b) {
pointY += (a + b);
}
else {
pointX += a;
pointY += b;
}
count++;
if (count == n) {
cout << pointX << " " << pointY << endl;
pointX = pointY = count = 0;
cin >> n;
}
} while (n != 0);
return 0;
}
|
#include <iostream>
int main(){
std::ios::sync_with_stdio(false);
while(true){
int n, a_score = 0, b_score = 0;
std::cin >> n;
if(n == 0)
break;
for(int i = 0; i < n; ++i){
int a, b;
std::cin >> a >> b;
if(a > b)
a_score += a + b;
else if(a < b)
b_score += a + b;
else
a_score += a, b_score += b;
}
std::cout << a_score << " " << b_score << std::endl;
}
return 0;
}
| 1 |
#include <iostream>
#include <stdio.h>
using namespace std;
int main(){
int number;
int sum = 0;
while(1){
cin >> number;
if (number == 0){
break;
}
int array[number][number];
int lastColumn[number];
int lastRow[number];
int total=0;
for(int i=0; i<number; i++){
sum = 0;
for(int j=0; j<number; j++){
cin >> array[i][j];
sum += array[i][j];
}
lastColumn[i] = sum;
}
for(int j=0; j<number; j++){
sum = 0;
for(int i=0; i<number; i++){
sum += array[i][j];
}
lastRow[j] = sum;
total +=sum;
}
for(int i=0; i<number; i++){
for(int j=0; j<number; j++){
printf("%5d", array[i][j]);
}
printf("%5d\n", lastColumn[i]);
}
for(int i=0; i<number; i++){
printf("%5d", lastRow[i]);
}
printf("%5d\n", total);
}
return 0;
}
|
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#define PB push_back
using namespace std;
class cond{
public:
cond(int x, int y, int z, int t){a=x;b=y;c=z;r=t;chked=false;}
int a,b,c,r;
bool chked;
};
int main(void){
int a,b,c;
while(cin >> a >> b >> c){
if((a|b|c) == 0) break;
vector<cond> v;
bool changed = true;
int state[a+b+c+1];
int x,y,z,r;
//at first, every state are unknown
fill(state,state+a+b+c+1,2);
//read data
int n; //# of conditions
cin >> n;
for(int i=0;i<n;i++){
cin >> x >> y >> z >> r;
v.PB(cond(x,y,z,r));
}
while(changed){
changed = false;
//for all conditions
for(int i=0;i<n;i++){
if(v[i].chked) continue; //do not check which is determined
if(v[i].r == 1){ //in case work well
state[v[i].a] = 1;
state[v[i].b] = 1;
state[v[i].c] = 1;
v[i].chked = true;
changed = true;
}else{
if(state[v[i].a] == 1 && state[v[i].b] == 1){
state[v[i].c] = 0;
changed = true;
v[i].chked = true;
}else if(state[v[i].a] == 1 && state[v[i].c] == 1){
state[v[i].b] = 0;
changed = true;
v[i].chked = true;
}else if(state[v[i].b] == 1 && state[v[i].c] == 1){
state[v[i].a] = 0;
changed = true;
v[i].chked = true;
}
}
}
}
for(int i=1;i<=a+b+c;i++){
cout << state[i] << endl;
}
}
}
| 0 |
// ARC100
// D - Equal Cut
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
const int MAX_N = 200000;
const ll INF = 1e18;
int N;
int A[MAX_N];
ll s[MAX_N + 1];
int search(int a, int b) {
int l = a + 1, r = b - 1;
while (r - l > 1) {
int m = (l + r) / 2;
if (s[m] - s[a] <= s[b] - s[m]) {
l = m;
} else {
r = m;
}
}
return l;
}
ll solve() {
s[0] = 0;
for (int i = 1; i <= N; i++) {
s[i] = s[i - 1] + A[i - 1];
}
ll ans = INF;
for (int i = 1; i < N; i++) {
int pq = search(0, i);
int rs = search(i, N);
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
ll pqrs[4] = {
s[pq + j] - s[0],
s[i] - s[pq + j],
s[rs + k] - s[i],
s[N] - s[rs + k],
};
sort(pqrs, pqrs + 4);
ans = min(ans, pqrs[3] - pqrs[0]);
}
}
}
return ans;
}
int main() {
cin >> N;
A[0] = 0;
for (int i = 0; i < N; i++) {
cin >> A[i];
}
cout << solve() << endl;
return 0;
}
|
#include<iostream>
#include<string.h>
#include<string>
#include<stdio.h>
#include<algorithm>
#include<vector>
#include<bitset>
#include<math.h>
#include<stack>
#include<queue>
#include<set>
#include<map>
using namespace std;
typedef long long ll;
typedef long double db;
typedef vector<int> vi;
typedef pair<int,int> pii;
const int N=200000+100;
const db pi=acos(-1.0);
#define lowbit(x) (x)&(-x)
#define sqr(x) (x)*(x)
#define rep(i,a,b) for (register int i=a;i<=b;i++)
#define per(i,a,b) for (register int i=a;i>=b;i--)
#define go(u,i) for (register int i=head[u],v=sq[i].to;i;i=sq[i].nxt,v=sq[i].to)
#define fir first
#define sec second
#define mkp make_pair
#define pb push_back
#define maxd 998244353
#define eps 1e-8
inline int read()
{
int 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;
}
namespace My_Math{
#define N 100000
int fac[N+100],invfac[N+100];
int add(int x,int y) {return x+y>=maxd?x+y-maxd:x+y;}
int dec(int x,int y) {return x<y?x-y+maxd:x-y;}
int mul(int x,int y) {return 1ll*x*y%maxd;}
ll qpow(ll x,int y)
{
ll ans=1;
while (y)
{
if (y&1) ans=mul(ans,x);
x=mul(x,x);y>>=1;
}
return ans;
}
int getinv(int x) {return qpow(x,maxd-2);}
int C(int n,int m)
{
if ((n<m) || (n<0) || (m<0)) return 0;
return mul(mul(fac[n],invfac[m]),invfac[n-m]);
}
void math_init()
{
fac[0]=invfac[0]=1;
rep(i,1,N) fac[i]=mul(fac[i-1],i);
invfac[N]=getinv(fac[N]);
per(i,N-1,1) invfac[i]=mul(invfac[i+1],i+1);
}
#undef N
}
using namespace My_Math;
int n,a[N];
ll sum[N];
ll calc(int l,int r) {return sum[r]-sum[l-1];}
int main()
{
n=read();
rep(i,1,n) a[i]=read();
rep(i,1,n) sum[i]=sum[i-1]+a[i];
int l=1,r=3;
ll ans=1e18;
rep(i,2,n-2)
{
while ((l+2<=i) && (abs(calc(1,l)-calc(l+1,i))>abs(calc(1,l+1)-calc(l+2,i)))) l++;
while ((r+2<=n) && (abs(calc(i+1,r)-calc(r+1,n))>abs(calc(i+1,r+1)-calc(r+2,n)))) r++;
ll mx=0,mn=1e18,x;
x=calc(1,l);mx=max(mx,x);mn=min(mn,x);
x=calc(l+1,i);mx=max(mx,x);mn=min(mn,x);
x=calc(i+1,r);mx=max(mx,x);mn=min(mn,x);
x=calc(r+1,n);mx=max(mx,x);mn=min(mn,x);
ans=min(ans,mx-mn);
}
printf("%lld\n",ans);
return 0;
}
| 1 |
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using ld = long double;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<int>;
using vvi = vector<vi>;
template<class T> using PQ = priority_queue<T>;
template<class T> using PQG = priority_queue<T, vector<T>, greater<T> >;
const int INF = 0xccccccc;
const ll LINF = 922337203685477580LL;
template<typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {return a < b && (a = b, true);}
template<typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {return a > b && (a = b, true);}
template<typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) { return is >> p.first >> p.second;}
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) { return os << p.first << ' ' << p.second;}
const int N = 310;
//head
int n;
int a[N], cnt[4];
ld _[N][N][N];
ld dfs(int i, int j, int k) {
if(_[i][j][k] > -0.5) return _[i][j][k];
ld &res = _[i][j][k] = 0;
int n_ = i+j+k;
if(i) res += dfs(i-1, j, k) * i/n_;
if(j) res += dfs(i+1, j-1, k) * j/n_;
if(k) res += dfs(i, j+1, k-1) * k/n_;
if(n_) res += (ld)n/n_;
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
rep(i, n) cin >> a[i];
rep(i, n) cnt[a[i]]++;
rep(i, n+1) rep(j, n+1) rep(k, n+1) _[i][j][k] = -1;
cout << fixed << setprecision(20) << dfs(cnt[1], cnt[2], cnt[3]) << endl;
}
|
#include "bits/stdc++.h"
#define REP(i,num) for(int i=0;i<(num);++i)
#define LOOP(i) while(i--)
#define ALL(c) c.begin(),c.end()
#define PRINTALL(c) for(auto pitr=c.begin();pitr!=c.end();++pitr){cout<<*pitr;if(next(pitr,1)!=c.end())cout<<' ';}cout<<endl;
#define PAIRCOMP(c,comp) [](const pair<ll,ll>& lhs,const pair<ll,ll>& rhs){return lhs.c comp rhs.c;}
using namespace std;
using ll = long long;
constexpr ll atcoder_mod = 1e9+7;
template<typename T=int>
T in(){T x; cin >> x; return (x);}
template<typename T=int,typename C=vector<T>>
C vecin(int N){C x(N);REP(i,N){x[i]=in<T>();}return move(x);}
void vout(){cout << endl;}
template<typename Head,typename... Tail>
void vout(Head&& h,Tail&&... t){cout << ' ' << h;vout(forward<Tail>(t)...);}
void out(){cout << endl;}
template<typename Head,typename... Tail>
void out(Head&& h,Tail&&... t){cout << h;vout(forward<Tail>(t)...);}
class ConnectNodeInfo{
vector<vector<pair<ll,ll>>> graph;
public:
ConnectNodeInfo(int node_num){
graph.resize(node_num);
}
void AddNonDirectionalConnection(ll u,ll v,ll w){
graph[u].emplace_back(v,w);
graph[v].emplace_back(u,w);
}
void AddDirectionalConnection(ll u,ll v,ll w){
graph[u].emplace_back(v,w);
}
vector<pair<ll,ll>>& operator[](ll index){
return graph[index];
}
size_t size(){return graph.size();}
};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(10);
int N=in(),M=in();
ConnectNodeInfo connect(N);
vector<int> input(N,0);
REP(i,N-1+M){
int u=in()-1,v=in()-1;
connect.AddDirectionalConnection(u,v,1);
input[v]++;
}
stack<int> vertex;
vector<int> sorted;
REP(i,N){
if(input[i]==0){
vertex.push(i);
break;
}
}
while(!vertex.empty()){
auto v=vertex.top();
vertex.pop();
sorted.push_back(v);
for(auto& x:connect[v]){
input[x.first]--;
if(!input[x.first]) vertex.push(x.first);
}
}
vector<int> parent(N,-1);
REP(i,N){
for(auto& x:connect[sorted[i]]){
parent[x.first] = sorted[i];
}
}
for(auto& x:parent){
out(x+1);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int d, g;
cin >> d >> g;
vector<pair<int,int>>pc(d);
for (int i = 0; i < d; i++)cin >> pc.at(i).first >> pc.at(i).second;
int ans = 1e10;
for (int bit = 0; bit < (1 << d); bit++) {
vector<pair<int, int>>pcc = pc;
vector<int> l(0);
for (int i = 0; i < d; i++) if (bit & (1 << i))l.push_back(i);
int res = 0;
int point = 0;
for (int i = 0; i < l.size(); i++) {
point += pcc.at(l.at(i)).second;
res += pcc.at(l.at(i)).first;
point += pcc.at(l.at(i)).first * (l.at(i) + 1) * 100;
pcc.at(l.at(i)).first = 0;
}
int ct = d - 1;
while (true) {
if (ct == -1)break;
if (point >= g)break;
if (pcc.at(ct).first == 0) {
ct--;
}
else {
pcc.at(ct).first--;
res++;
point += (ct + 1) * 100;
}
}
ans = min(ans, res);
}
cout << ans << endl;
}
|
#include <string>
#include <memory>
#include <vector>
#include <iostream>
#include <set>
#include <algorithm>
#include <array>
using namespace std;
vector<vector<int>> graph;
vector<int> colors;
vector<bool> used;
bool Dfs(int v, int col, int* sz) {
used[v] = true;
colors[v] = col;
(*sz)++;
bool ans = false;
for (const auto& to : graph[v]) {
if (!used[to]) {
if (Dfs(to, 1 - col, sz)) {
ans = true;
}
} else {
if (colors[to] == col) {
ans = true;
}
}
}
return ans;
}
int main() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
graph.resize(n);
colors.resize(n);
used.resize(n);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
graph[x].push_back(y);
graph[y].push_back(x);
}
std::array<int64_t, 2> arr{};
int64_t one = 0;
for (int i = 0; i < n; i++) {
if (!used[i]) {
int sz = 0;
if (Dfs(i, 0, &sz)) {
arr[0]++;
} else if (sz == 1) {
one++;
} else {
arr[1]++;
}
}
}
int64_t ans = one * 1ll * n * 2 - one * one;
cout << arr[0] * arr[0] + 2 * arr[0] * arr[1] + 2 * arr[1] * arr[1] + ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std ;
#define pb(n) push_back(n)
#define fi first
#define se second
#define all(r) (r).begin(),(r).end()
#define vmax(ary) *max_element(all(ary))
#define vmin(ary) *min_element(all(ary))
#define debug(x) cout<<#x<<": "<<x<<endl
#define fcout(n) cout<<fixed<<setprecision((n))
#define scout(n) cout<<setw(n)
#define vary(type,name,size,init) vector< type> name(size,init)
#define vvl(v,w,h,init) vector<vector<ll>> v(w,vector<ll>(h,init))
#define mp(a,b) make_pair(a,b)
#define rep(i,n) for(int i = 0; i < (int)(n);++i)
#define REP(i,a,b) for(int i = (a);i < (int)(b);++i)
#define repi(it,array) for(auto it = array.begin(),end = array.end(); it != end;++it)
#define repa(n,array) for(auto &n :(array))
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using dict = map<string,int>;
using pii = pair<int,int> ;
using pll = pair<ll,ll> ;
const int mod = 1000000007;
constexpr int inf = ((1<<30)-1)*2+1 ;
constexpr double PI = acos(-1.0) ;
double eps = 1e-10 ;
const int dy[] = {-1,0,1,0,1,-1,1,-1};
const int dx[] = {0,-1,0,1,1,-1,-1,1};
enum{
t = 0,
f ,
r ,
b ,
l ,
d,
};
array<int,6> dice = {1,3,5,4,2,6};
void Spin(array<int,6> &D,int dir){
if(dir == l){//
swap(D[t],D[r]);
swap(D[r],D[d]);
swap(D[d],D[l]);
}
else if(dir == r){
swap(D[t],D[l]);
swap(D[l],D[d]);
swap(D[d],D[r]);
}
else if(dir == f){
swap(D[t],D[b]);
swap(D[b],D[d]);
swap(D[d],D[f]);
}
else if(dir == b){
swap(D[t],D[f]);
swap(D[f],D[d]);
swap(D[d],D[b]);
}
else if(dir == d){//leftspin
swap(D[f],D[r]);
swap(D[r],D[b]);
swap(D[b],D[l]);
}
else if(dir == t){
swap(D[f],D[l]);
swap(D[l],D[b]);
swap(D[b],D[r]);
}
}
void ViewDice(array<int,6> D){
rep(i,6){
cout << D[i]<< " ";
}
cout << endl;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
array<int,6> di;
cin >> di[t] >> di[f] >> di[r] >> di[l] >> di[b] >> di[d];
string s;
cin >> s;
rep(i,s.size()){
if(s[i] == 'S'){
Spin(di,f);
}
if(s[i] == 'E'){
Spin(di,r);
}
if(s[i] == 'W'){
Spin(di,l);
}
if(s[i] == 'N'){
Spin(di,b);
}
}
cout << di[t]<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ft ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define ll long long
#define pb push_back
#define F first
#define S second
const int N=1e5+5;
ll a[N];
int main()
{
ft
ll t,i,j,n,m,l,r,p,q,s=0;
cin>>n>>l>>r;
for(i=0;i<n;i++)
{
cin>>a[i];
}
for(i=1;i<n;i++)
{
p=(a[i]-a[i-1])*l;
s+=min(p,r);
}
cout<<s<<"\n";
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n, h, w;
cin >> n >> h >> w;
cout << (n-h+1)*(n-w+1) << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main()
{
int a,b,c,d;
cin>>a>>b>>c>>d;
a=a+b;
c=c+d;
if(a>c)
{
cout<<"Left";
}
else if(a==c)
cout<<"Balanced";
else
cout<<"Right";
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m; cin>>n>>m;
int mx=INT_MIN, mn=INT_MAX;
for(int i=0;i<m;i++){
int l,r; cin>>l>>r;
mx = max(mx, l);
mn = min(mn,r);
}
cout<<max(0,mn-mx+1)<<"\n";
}
|
#include<bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); i++)
#define rrep(i,n) for(int i = (n)-1; i >= 0; i--)
#define rep1(i,n) for(int i = 1; i <= (n); i++)
#define rrep1(i,n) for(int i = (n); i > 0; i--)
#define ll long long
#define pi pair<int, int>
#define pll pair<ll, ll>
#define MOD 1000000007
#define INF 1000000000000000LL
using namespace std;
int main(){
ll m;cin>>m;
ll result = 0;
ll digits_counter=-1;
ll sum=0;
rep(i, m){
ll d,c;cin>>d>>c;
digits_counter+=c;
sum+= d*c;
}
if(sum%9==0)cout << sum/9+digits_counter-1 << endl;
else cout << sum/9+digits_counter << endl;
// cout << (sum-1)/9+digits_counter << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#include <iomanip>
#include <math.h>
#include <unistd.h>
#include <stdio.h>
#define rep(i,x) for(ll i = 0;i<x;i++)
#define all(a) (a).begin(),(a).end()
#define vecin(a) rep(i,a.size())cin >> a[i]
#define vecout(a) rep(i,a.size()){cout << a[i];cout << (i == a.size() - 1 ? "\n":" ");}
#define mp make_pair
using ll = long long;
using ld = long double;
using namespace std;
using dou = double;
const ll inf = 2147483647;
const ll INF = 1LL << 60;
const dou pi = 3.14159265358;
const ll mod = 1000000007LL;
typedef pair<ll,ll> P;
using graph = vector<vector<ll>>;
template<class T> inline bool chmax(T& a, T b){if(a < b){a = b; return true;}return false;}
template<class T> inline bool chmin(T& a, T b){if(a > b){a = b; return true;}return false;}
template<class T> inline bool change(T a,T b){if(a > b){swap(a,b);return true;}return false;}
ll gcd(ll a,ll b){
if(a < b)swap(a,b);
if(a % b == 0)return b;
else return gcd(b,a%b);
}
ll lcm(ll a,ll b){
return a / gcd(a,b) * b;
}
//素数判定O(sqrt(N))
bool isp(ll n){
bool res = true;
if(n == 1)return false;
else{
for(ll i = 2;i * i <= n;i++){
if(n % i == 0){
res = false;
break;
}
}
return res;
}
}
const ll cmax = 1000000;
ll fac[cmax], finv[cmax], inv[cmax];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < cmax; 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 nCk(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;
}
//nのm乗をMODで割ったあまりO(logN)
ll modpow(ll n,ll m,ll MOD){
ll res = 1;
while(m){
if(m & 1)res = (res * n) % MOD;
m >>= 1;
n *= n;
n %= MOD;
}
return res;
}
//printf("%.10f\n", N);
/* vector<ll> vec = {1,2,5,6,8,9,10};
cout << binary_search(all(vec),5) << endl; -> true*/
/*
vector<ll> vec = {1,2,5,6,8,9,10};
auto n = upper_bound(all(vec),4);
cout << *n << endl; -> 5*/
// cout << fixed << setprecision(15);
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
string S;
cin >> S;
ll s = S.size();
if(s != 26){
map<char,ll> ma;
rep(i,s){
ma[S[i]]++;
}
for(char c = 'a';c <= 'z';c++){
if(!ma[c]){
S += c;
break;
}
}
cout << S << endl;
}
else{
if(S == "zyxwvutsrqponmlkjihgfedcba"){
cout << "-1\n";
return 0;
}
string T = S;
next_permutation(all(S));
rep(i,s){
if(T[i] == S[i])cout << S[i];
else{
cout << S[i] << "\n";
return 0;
}
}
}
}
|
#include<bits/stdc++.h>
using namespace std;
using lli = long long;
#define rep(i,n) for(int i=0;i<n;i++)
string s;
int main(void){
cin >> s;
lli n = s.size();
if(s.size() == 26){
if(s == "zyxwvutsrqponmlkjihgfedcba") cout << -1 << endl;
else{
string b = s;
next_permutation(s.begin(), s.end());
rep(i, 26){
if(s[i] == b[i]) cout << s[i];
else{
cout << s[i] << endl;
return 0;
}
}
}
return 0;
}
vector<bool> used(26);
rep(i, n) used[s[i]-'a'] = true;
rep(i, 26){
if(used[i] == false){
cout << s+char('a'+i) << endl;
return 0;
}
}
cout << "error" << endl;
return 0;
}
| 1 |
#include<iostream>
using namespace std;
#define N 10 // üHÌ
int main()
{
double l[N], v[2];
double sum[N];
double position;
int i;
while (scanf("%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf",&l[0],&l[1],&l[2],&l[3],&l[4],&l[5],&l[6],&l[7],&l[8],&l[9],&v[0],&v[1]) != EOF) {
sum[0] = l[0];
for (i = 1; i < N; i++)
sum[i] = sum[i-1]+l[i];
position = v[0] * sum[9] / (v[0]+v[1]);
for (i = 0; i < N; i++)
if (sum[i]>=position)
break;
i++;
cout<<i<<endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main()
{
double l[10], sum, v1, v2;
char c;
while (1) {
for (int i = 0; i < 10; i++) {
cin >> l[i] >> c;
}
if (cin.eof()) break;
cin >> v1 >> c >> v2;
sum = 0;
for (int i = 0; i < 10; i++) {
sum += l[i];
}
sum *= v1 / (v1 + v2);
for (int i = 0; i < 10; i++) {
sum -= (double)l[i];
if (sum <= 0) {
cout << i + 1 << endl;
break;
}
}
}
return 0;
}
| 1 |
#include <iostream>
#include <string>
#include <cstring>
#include <sstream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <stack>
#include <queue>
#include <chrono>
#include <numeric>
using namespace std;
class cLSearch
{
int mn, mq;
string mS, mT;
vector<int> vs, vt;
int ans;
void decode();
public:
cLSearch(const int &n, const int &q, const string &s, const string &t)
{
mn = n;
mq = q;
mS = s;
mT = t;
decode();
}
void search();
void output();
};
void cLSearch::search()
{
sort(vs.begin(), vs.end());
sort(vt.begin(), vt.end());
int count = 0;
vector<int>::iterator vis = vs.begin();
vector<int>::iterator vit = vt.begin();
int ts, tt;
while (vis != vs.end() && vit != vt.end())
{
if (*vis == *vit)
{
++count;
ts = *vis;
tt = *vit;
while (vis != vs.end() && ts == *vis)
++vis;
while (vit != vt.end() && tt == *vit)
++vit;
}
else
{
if (vis != vs.end() && vit != vt.end() && *vis > *vit)
++vit;
else
++vis;
}
}
ans = count;
}
void cLSearch::output()
{
cout << ans << endl;
}
void cLSearch::decode()
{
istringstream iss;
iss.str(mS);
int ts;
for (int i = 0; i < mn; ++i)
{
iss >> ts;
vs.push_back(ts);
}
iss.str(mT);
iss.seekg(0, iss.beg);
for (int i = 0; i < mq; ++i)
{
iss >> ts;
vt.push_back(ts);
}
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, q;
string s, t;
cin >> n;
cin.ignore();
getline(cin, s);
cin >> q;
cin.ignore();
getline(cin, t);
cLSearch cls(n, q, s, t);
cls.search();
cls.output();
return 0;
}
|
#include <iostream>
using namespace std;
const int NOT_FOUND=-1;
int linerSearch(int key, int A[],int n){
int i=0;
A[n]=key;
while(A[i]!=key)
i++;
if(i==n)
return NOT_FOUND;
else
return i;
}
int main(){
int n,q;
cin >>n;
int S[n+1];
for(int i=0; i<n; i++)
cin>>S[i];
cin >>q;
int T[q+1];
for(int i=0; i<q; i++)
cin>>T[i];
int C=0;
for(int i=0; i<q; i++){
if(linerSearch(T[i], S,n)!=NOT_FOUND)
C++;
}
cout<<C<<endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define M 1000000007
long long int power(int a,int b)
{
if(b==0)
return 1;
long long int k=power(a,b/2);
if(b%2==0)
return ((k%M)*(k%M))%M;
else
return ((k%M)*(k%M)*(a%M))%M;
}
long long int fact(long long int n)
{
if(n==1 || n==0)
return 1;
else
return ((n%M)*(fact(n-1)%M))%M;
}
int div(int n)
{ int c=0;
for(int i=1;i<=sqrt(n);i++)
{
if(n%i==0)
{
if(n/i==i)
c++;
else
c+=2;
}
}
return c;
}
int func(int n)
{
return (n*(n+1))/2;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
string str;
cin>>str;
set<char> s;
for(int i=0;i<str.length();i++)
{
s.insert(str[i]);
}
if(s.size()==26)
cout<<"None";
else
{ int i=0;
for(auto it=s.begin();it!=s.end();it++,i++)
{
if(*it!=(97+i))
{
cout<<(char)(97+i);
return 0;
}
}
if(s.size()<26)
{
cout<<char(97+s.size());
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep3(i, s, n, a) for (int i = (s); i < (int)(n); i += a)
#define rep2(i, s, n) rep3(i, s, n, 1)
#define rep(i, n) rep2(i, 0, n)
using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int, int>;
int main(){
string n;
cin >> n;
int len = n.size();
vector<ll> tmp(2);
vector<vector<ll>> bill(len, tmp);
bill[0][0] = n[len-1] - '0';
bill[0][1] = 10 - (n[len-1] - '0');
rep2(i, 1, len){
int x = n[len - 1 - i] - '0';
bill[i][0] = min(bill[i - 1][0] + x, bill[i-1][1] + x + 1);
bill[i][1] = min(bill[i-1][0] + 10 - x, bill[i-1][1] + 9 - x);
}
cout << min(bill[len-1][0], bill[len-1][1]+1) << endl;
return 0;
}
| 0 |
#include<iostream>
#include<algorithm>
#include<functional>
#include<cmath>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<deque>
using namespace std;
#define ll long long
const int mod = 1000000007;
const ll INF = 1000000000000000000;
ll cnt[26];
int main()
{
string S; cin >> S;
cnt[S[0] - 'a']++;
ll ans = 1;
for (int i = 1; i < S.size(); i++) {
ans += i - cnt[S[i] - 'a'];
cnt[S[i] - 'a']++;
}
cout << ans << endl;
}
|
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
typedef long long ll;
int main(void) {
int n, i, j, l[30] = {};
ll ans = 1;
string a;
cin >> a;
n = a.size();
for (i = 0; i < n; i++) {
l[a[i] - 'a']++;
}
for (i = 0; i < 26; i++) for (j = i + 1; j < 26; j++) {
ans += (ll)l[i] * l[j];
}
cout << ans << endl;
return 0;
}
| 1 |
#include<stdio.h>
#include<algorithm>
#include<vector>
using namespace std;
int n, A[1010000], B[1010000], cnt;
vector<int>E[26];
char p[1010000], q[1010000];
int main(){
int i, pv, ck = 0, res = 0;
scanf("%d",&n);
scanf("%s",p+1);
scanf("%s",q+1);
for(i=1;i<=n;i++){
E[p[i]-'a'].push_back(i);
if(p[i]!=q[i])ck = 1;
}
if(!ck){
printf("0\n");
return 0;
}
pv = n;
for(i=n;i>=1;i--){
if(q[i]!=q[i-1]){
pv = min(pv, i);
int x = q[i]-'a';
int t = lower_bound(E[x].begin(), E[x].end(), pv + 1) - E[x].begin();
if(!t){
printf("-1\n");
return 0;
}
B[++cnt] = i;
A[cnt] = E[x][t-1];
pv = E[x][t-1] - 1;
}
}
for(i=1;i<=cnt/2;i++)swap(A[i],A[cnt+1-i]),swap(B[i],B[cnt+1-i]);
cnt++;
A[cnt]=B[cnt]=n+1;
for(i=1;i<=cnt;i++) A[i]-=i, B[i]-=i;
for(i=1;i<=cnt;i++){
int t = lower_bound(A+1,A+cnt+1,B[i]) - A;
res = max(res, t - i);
}
printf("%d\n",res+1);
}
|
#include<stdio.h>
int main()
{
int A, B;
scanf("%d %d", &A, &B);
int size = A + B + 1;
char str[100];
scanf("%s", str);
int i, count = 0;
if (str[A] == '-')
{
for (i = 0; i < size; i++)
{
if (str[i] >= '0' && str[i] <= '9')
{
count++;
}
}
if (count == size - 1)
{
printf("Yes\n");
}
else
{
printf("No\n");
}
}
else
{
printf("No\n");
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
using namespace __gnu_pbds;
using namespace std;
#define LETS_GET_SCHWIFTY ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ff first
#define ss second
//#define int long long
#define ll long long
#define pb push_back
#define pii pair<int,int>
#define vi vector<int>
#define mii map<int,int>
#define pqb priority_queue<int>
#define pqs priority_queue<int,vi,greater<int> >
#define setbits(x) __builtin_popcountll(x)
#define zerobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define inf 1e18
#define ps(x,y) fixed<<setprecision(y)<<x
#define vpii vector<pair<int,int> >
#define all(x) x.begin(),x.end()
#define matrixprint(arr,a,b,c,d) for(int i=a;i<=c;i++){for(int j=b;j<=d;j++){cout<<arr[i][j]<<" ";}cout<<"\n";}
#define show(arr,x,y) for(int i=x;i<=y;i++){cout<<arr[i]<<" ";}cout<<"\n"
#define sz(x) (int)x.size()
#define db(x) cout<<x<<"\n";
const int N = 2e5 + 5;
#define TRACE
#ifdef TRACE
#define deb(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ','); cout.write(names, comma - names) << " : " << arg1 << " | "; __f(comma + 1, args...);
}
#else
#define deb(...)
#endif
//////////////////////////////code//////////////////////////////
string s;
int n;
int dp[10001][100][2][2]; // digitnum, digitval , modval , sameask , greatrthanzero
int sol(int i,int k,int l,int m)
{
// deb(i,j,k,l,m);
if(i==sz(s))
{
if(m && k==0)
{
return 1;
}
else
return 0;
}
if(dp[i][k][l][m]!=-1)
return dp[i][k][l][m];
int ans = 0;
if(l)
{
for(int digit=0;digit<10;digit++)
{
int now = s[i] - '0';
if(now > digit)
{
if(digit > 0)
ans = (ans + sol(i+1,(k+digit)%n,0,1))%mod;
else
ans = (ans + sol(i+1,(k+digit)%n,0,m))%mod;
}
else if(now == digit)
{
if(now == 0)
ans = (ans + sol(i+1,(k+digit)%n,1,m))%mod;
else
ans = (ans + sol(i+1,(k+digit)%n,1,1))%mod;
}
// deb(i,j,k,l,m,ans,digit);
}
}
else
{
for(int digit=0;digit<10;digit++)
{
if(digit==0)
ans = (ans + sol(i+1,(k+digit)%n,0,m))%mod;
else
ans = (ans + sol(i+1,(k+digit)%n,0,1))%mod;
// deb(i,j,k,l,m,ans,digit);
}
}
return dp[i][k][l][m]=ans;
}
void solve()
{
// cout << "-------------------" << "\n";
cin>>s>>n;
memset(dp,-1,sizeof(dp));
cout<<sol(0,0,1,0);
// cout << "-------------------" << "\n";
}
int32_t main()
{
LETS_GET_SCHWIFTY;
int t = 1;
//cin >> t;
while (t--)
solve();
}
// check out for following mistakes-
// if using pb operation on vector and then trying to access index..check if sizeof that vec could remain 0 only
// is using prime sieve make sure it fits
// when using factorial template or combinatorics make sure that you edit fillfac fun values and array values
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef pair<int, int> p;
typedef long long ll;
const int inf = 1000000007;
int main() {
ll l, r;
cin >> l >> r;
if (r - l + 1 >= 2019) {
cout << 0 << endl;
return 0;
}
vector<ll> a(r - l + 1);
rep(i, r - l + 1) { a[i] = (l + i) % 2019; }
ll ans = inf;
rep(i, a.size() - 1) {
for (int j = i + 1; j < a.size(); j++) {
ll tmp = a[i] * a[j] % 2019;
if (ans > tmp) ans = tmp;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
using namespace std;
const long long int MOD = 1000000007;
//const int MOD = 998244353;
long long int N, M, K, H, W, L, R;
//int N, M, K, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
vector<long long int>v(N);
for (auto &i : v)cin >> i;
cin >> M >> K;
vector<int>p(N - 1);
for (int i = 0; i < N - 1; i++)p[i] = i;
for (int i = 0; i < M; i++) {
cin >> L;
swap(p[L - 2], p[L - 1]);
}
vector<vector<int>>to(62, vector<int>(N - 1));
for (int i = 0; i < N - 1; i++)to[0][i] = p[i];
for (int i = 1; i < 62; i++) {
for (int j = 0; j < N - 1; j++) {
to[i][j] = to[i - 1][to[i - 1][j]];
}
}
for (int i = 0; i < N - 1; i++) {
long long int box = K;
int cnt = i;
for (int j = 0; j < 62; j++) {
if ((box >> j) & 1) {
cnt = to[j][cnt];
}
}
p[i] = cnt;
}
long long int num = v[0];
cout << num << endl;
for (auto i : p) {
//cout << i << endl;
num += v[i+1]-v[i];
cout << num << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#ifdef ENABLE_DEBUG
#define DEBUG(a) cerr<<#a<<"="<<a<<endl
#define DEBUG_ARRAY(a,n) cerr<<#a<<"["<<n<<"]="<<a[n]<<endl
#else
#define dump(a)
#define dumparr(a,n)
#endif
#define FOR(i, a, b) for(int i = a;i < b;i++)
#define For(i, a) FOR(i, 0, a)
#define REV(i, a, b) for(int i = b-1;i >= a;i--)
#define Rev(i, a) REV(i, 0, a)
#define REP(a) For(i, a)
typedef long long int ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef pair<ll, ll> P;
typedef pair<ll,P> PP;
typedef vector<ll> vll;
const ll INF=(1LL<<50);
vector<ll> d;
vector<ll> powv(vector<ll> &a){
vector<ll> ret(a.size());
REP(a.size()){
ret[i]=a[a[i]];
}
return ret;
}
vector<ll> addv(vector<ll> &a,vector<ll> &b){
vector<ll> ret(a.size());
REP(a.size()){
ret[i]=b[a[i]];
}
return ret;
}
void swapv(vector<ll> &a,ll b,ll c){
swap(a[b],a[c]);
}
void solve(long long N, std::vector<long long> x, long long M, long long K, std::vector<long long> a){
REP(N-1){
d.push_back(x[i+1]-x[i]);
}
vector<ll> h(N-1);
iota(h.begin(),h.end(),0);
REP(M){
swapv(h,a[i],a[i]-1);
}
vector<ll> ans(N-1);
iota(ans.begin(),ans.end(),0);
while(K>0){
if((K&1)>0){
ans=addv(ans,h);
}
K>>=1;
h=powv(h);
}
cout<<x[0]<<endl;
REP(x.size()-1){
x[i+1]=x[i]+d[ans[i]];
cout<<x[i+1]<<endl;
}
}
int main(){
long long N;
scanf("%lld",&N);
std::vector<long long> x(N);
for(int i = 0 ; i < N ; i++){
scanf("%lld",&x[i]);
}
long long M;
scanf("%lld",&M);
long long K;
scanf("%lld",&K);
std::vector<long long> a(M);
for(int i = 0 ; i < M ; i++){
scanf("%lld",&a[i]);
a[i]--;
}
solve(N, std::move(x), M, K, std::move(a));
return 0;
}
| 1 |
#include<iostream>
#include<cstdio>
#include<string>
#include<algorithm>
#include<cmath>
#include<vector>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<cstring>
using namespace std;
typedef long long ll;
int a[100100];
int c[100100];
bool check(int x,int i)
{
if(c[x]<a[i])
{
return 1;
}
else
{
return 0;
}
}
int bs(int l, int r,int i)
{
while (l < r)
{
int mid = l + r >> 1;
if (check(mid,i)) r = mid; // check()判断mid是否满足性质
else l = mid + 1;
}
return l;
}
int main()
{
int n;
cin >> n;
for(int i=1;i<=n;i++)
{
cin >> a[i];
}
int cnt=1;
c[1] = a[1];
for(int i=2;i<=n;i++)
{
int pos = bs(1,cnt,i);
if(c[pos]<a[i])
{
c[pos] = a[i];
}
else
{
cnt++;
c[cnt] = a[i];
}
}
cout << cnt << endl;
return 0;
}
|
// ░░░░░░░░( •̪●)░░░░░░░░░░░░░░░░░░░░░░░░
// ░░░░░░███████ ]▄▄▄▄▄▄▄▄▃░░░▃░░░░ ▃░
// ▂▄▅█████████▅▄▃▂░░░░░░░░░░░░░░░░░
// [███████████████████].░░░░░░░░░░░░░░
// ◥⊙▲⊙▲⊙▲⊙▲⊙▲⊙▲⊙◤...░░░░░░░░░░░░
//PointBlank's code (⌐■_■)
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
ll power(ll x, ll y);
#define repp(I, A, B) for(int I = A; I <= B; I++)
#define rep(I, A, B) for(int I = A; I < B; I++)
#define rrep(I, B, A) for(int I = B; I >= A; I--)
#define pb emplace_back
#define ff first
#define ss second
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define LB lower_bound
#define UB upper_bound
#define MP make_pair
#define mem(A, B) memset(A, B, sizeof(A));
#define mem0(A) memset(A, 0, sizeof(A));
#define quickio ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define debug(this) cerr<<"> "<<#this<<" : "<<this<<"\n"
#define bitcount(n) __builtin_popcountll(n)
#define in_edges(M) repp(I, 1, M){int A, B; cin >> A >> B; v[A].pb(B), v[B].pb(A);}
#define in_edges2(M) repp(I, 1, M){int A, B; cin >> A >> B; v[A].pb(B);}
#define in_edges3(M) repp(I, 1, M){int A, B, C; cin >> A >> B >> C; v[A].pb(B, C), v[B].pb(A, C);}
#define endl "\n"
const ll MOD = 1000000007;
int main() //PointBlank's code ¯\_(ツ)_/¯
{
int n;
cin >> n;
multiset<int> st;
int res = 0;
int inp;
rep(i, 0, n){
cin >> inp;
auto it = st.UB(-inp);
if(it == st.end()){
res++;
st.insert(-inp);
}else{
st.erase(it);
st.insert(-inp);
}
}
cout << res;
}
ll power(ll x, ll y)
{
ll res = 1; x %= MOD;
while(y > 0){if(y & 1) res = (res*x) % MOD; y = y>>1, x = (x*x) % MOD;}
return res;
}
| 1 |
#include <iostream>
#define FAST ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#include <algorithm>
#include <bits/stdc++.h>
#define MOD 1000000007
#define ll long long
#define l long
#define mm(arr) memset(arr, 0, sizeof(arr))
#define scanArray(a,n) for(int i = 0; i < n; i++){cin >> a[i]}
using namespace std;
int main(){
FAST
int n; cin >> n;
int x;
int result=0;
while(n!=0){
x=n%10;
if(x==7){
result=1;
}
n=n/10;
}
if(result==1){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main()
{
string N;
getline(cin,N);
if(N[0]=='7'||N[1]=='7'||N[2]=='7')
{
cout<<"Yes";
}
else
{
cout<<"No";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define all(x) (x).begin(),(x).end()
using ll = long long;
string char_to_string(char val) {
return string(1, val);
}
int char_to_int(char val) {
return val - '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;
}
int vector_finder(std::vector<int> vec, int number) {
auto itr = std::find(vec.begin(), vec.end(), number);
size_t index = std::distance( vec.begin(), itr );
if (index != vec.size()) { // 発見できたとき
return 1;
}
else { // 発見できなかったとき
return 0;
}
}
int gcd(int a, int b) {
if (a % b == 0) {
return(b);
} else {
return(gcd(b, a % b));
}
}
int main() {
ll N, K; cin >> N >> K;
vector<ll> A(N); REP(i, N) cin >> A[i];
ll g = A[0]; ll max_n = *max_element(all(A));
for(int i = 1; i < N; ++i) {
g = gcd(A[i], g);
}
if(K % g == 0 && max_n >= K) cout << "POSSIBLE" << endl;
else cout << "IMPOSSIBLE" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,K;
cin >> N >> K;
if(N % K == 0)
cout << 0;
else
cout << 1;
}
| 0 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <array>
#include <cstdint>
#include <cmath>
using namespace std;
inline namespace atcoder {
using i32 = int32_t; using u32 = uint32_t;
using i64 = int64_t; using u64 = uint64_t;
using f32 = float; using f64 = double;
template <typename T, size_t Depth>
struct vector_helper { using type = vector<typename vector_helper<T, Depth - 1>::type>; };
template <typename T>
struct vector_helper<T, 0> { using type = T; };
template <typename T, size_t Depth>
using vector_t = typename vector_helper<T, Depth>::type;
template <typename T> using vec = vector_t<T, 1>;
template <typename T> using vvec = vector_t<T, 2>;
template <typename T> using vvvec = vector_t<T, 3>;
}
int main() {
int n, m; cin >> n >> m;
int expect[] = { -1, -1, -1 };
while (m--) {
int s, c; cin >> s >> c; --s;
if (expect[s] != -1 && expect[s] != c) {
cout << -1 << endl;
return 0;
}
expect[s] = c;
}
if (n != 1 && expect[0] == 0) {
cout << -1 << endl;
return 0;
}
if (n != 1 && expect[0] == -1) {
expect[0] = 1;
}
for (auto &e : expect) e = max(e, 0);
int ans = 0;
for (int i = n - 1; 0 <= i; --i) {
ans += expect[i] * pow(10, n - 1 - i);
}
cout << ans << endl;
}
|
#include <iostream>
#include <vector>
using namespace std;
int main(){
vector<int> abcde(5);
int k;
for(int i = 0;i < 5;i++) cin >> abcde.at(i);
cin >> k;
for(int i = 0;i < 5;i++){
for(int j = i + 1;j < 5;j++){
if(k < abcde.at(j) - abcde.at(i)){
cout << ":(" << endl;
return 0;
}
}
}
cout << "Yay!" << endl;
return 0;
}
| 0 |
#include "bits/stdc++.h"
using namespace std;
static const int MOD = 998244353;
long long Inv(long long a) {
long long res = 1;
long long n = MOD - 2;
while (n > 0) {
if (n & 1) res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
const int N = 5000001;
long long fact[N];
long long invfact[N];
void init() {
fact[0] = 1;
for (int i = 1; i < N; i ++) fact[i] = fact[i - 1] * i % MOD;
for (int i = 0; i < N; i ++) invfact[i] = Inv(fact[i]);
}
long long C(long long n, long long r) {
if (n < 0 || r < 0 || n < r) return 0;
return fact[n] * invfact[n - r] % MOD * invfact[r] % MOD;
}
int main() {
init();
int n, m;
scanf("%d%d", &n, &m);
if (n < m) swap(n, m);
long long ans = 0;
for (int i = 1; i <= m; i ++) {
long long mul = C(2 * i, i) % MOD;
mul = mul * C(n + m - 2 * i, n - i) % MOD;
ans = (ans + mul) % MOD;
}
ans = ans * Inv(2 * C(n + m, n)) % MOD;
ans = (ans + n) % MOD;
printf("%lld\n", ans);
return 0;
}
|
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LL long long
#define mod 998244353
#define inv2 499122177
#define M 1000020
using namespace std;
namespace IO{
int Top=0; char SS[20];
void write(int x){
if(!x){putchar('0');return;} if(x<0) x=-x,putchar('-');
while(x) SS[++Top]=x%10,x/=10;
while(Top) putchar(SS[Top]+'0'),--Top;
}
int read(){
int nm=0,fh=1; char cw=getchar();
for(;!isdigit(cw);cw=getchar()) if(cw=='-') fh=-fh;
for(;isdigit(cw);cw=getchar()) nm=nm*10+(cw-'0');
return nm*fh;
}
}using namespace IO;
int mul(int x,int y){return (LL)x*(LL)y%mod;}
int add(int x,int y){return (x+y>=mod)?x+y-mod:x+y;}
int mus(int x,int y){return (x-y<0)?x-y+mod:x-y;}
int qpow(int x,int sq){
int res=1;
for(;sq;sq>>=1,x=mul(x,x)) if(sq&1) res=mul(res,x);
return res;
}
int n,m,fac[M],ifac[M],ans;
int C(int tot,int tk){return mul(fac[tot],mul(ifac[tot-tk],ifac[tk]));}
int main(){
n=read(),m=read(),fac[0]=1; if(n>m) swap(n,m);
for(int i=1;i<=n+m;i++) fac[i]=mul(fac[i-1],i); ifac[n+m]=qpow(fac[n+m],mod-2);
for(int i=n+m;i;i--) ifac[i-1]=mul(ifac[i],i);
for(int i=1;i<=n;i++) ans=add(ans,mul(C(i<<1,i),C(n+m-(i<<1),n-i)));
write(add(mul(ans,mul(inv2,qpow(C(n+m,m),mod-2))),m)),putchar('\n'); return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define num 1000000007
//#define num 998244353
#define REP(i,a,n) for(ll i=a;i<n;i++)
#define inarr(i,a,n,A) for(ll i=a;i<n;i++) { cin>>A[i]; }
#define vll vector<long long>
#define pii pair <int,int>
#define pll pair<long long, long long>
#define vpii vector< pair <int,int>>
#define vpll vector< pair<long long, long long>>
//#define max(a,b) ((a>b)?a:b)
//#define min(a,b) ((a>b)?b:a)
#define max3(a,b,c) ((a>b)?(a>c)?a:c:(b>c)?b:c)
#define min3(a,b,c) ((a<b)?(a<c)?a:c:(b<c)?b:c)
#define avg(a,b) ((a)+(b))/2
#define pb push_back
#define pob pop_back
#define sf int flag=0 //Remember semicolon
// #define assmin(a,b) if(b<=a) { a=b; }
// #define assmax(a,b) if(b>=a) { a=b; }
#define f first
#define s second
#define fix(f,n) std::fixed<<std::setprecision(n)<<f
#define all(x) x.begin(), x.end()
#define M_PI 3.14159265358979323846
#define epsilon (double)(0.00000000001)
#define side 1e9
#define watch(x) cout << (#x) << " is " << (x) << endl
typedef long long ll;
ll mod(ll a, ll b)
{
if(a%b<0)
{
return a%b + b;
}
return a%b;
}
ll mod_exp(ll a, ll b, ll c)
{
ll res=1;
a=a%c;
while(b>0)
{
if(b%2==1)
{
res=(res*a)%c;
}
b/=2;
a=(a*a)%c;
}
return res;
}
ll mymod(ll a,ll b)
{
return ((a%b)+b)%b;
}
bool prime[200001];
void SieveOfEratosthenes()
{
memset(prime, true, sizeof(prime));
prime[1]=false;
for (int p=2; p*p<=200000; p++)
{
if (prime[p] == true)
{
for (int i=p*p; i<=200000; i += p)
prime[i] = false;
}
}
return;
}
ll powe[200005];
void power()
{
powe[0]=1;
REP(i,1,200005)
{
powe[i]=mymod(2*powe[i-1],num);
}
}
ll gcdExtended(ll,ll,ll *,ll *);
ll modInverse(ll a, ll m)
{
ll x, y;
ll g = gcdExtended(a, m, &x, &y);
ll res = (x%m + m) % m;
return res;
}
ll gcdExtended(ll a, ll b, ll *x, ll *y)
{
if (a == 0)
{
*x = 0, *y = 1;
return b;
}
ll x1, y1;
ll gcd = gcdExtended(b%a, a, &x1, &y1);
*x = y1 - (b/a) * x1;
*y = x1;
return gcd;
}
struct node
{
vll adj;
ll indegree;
};
ll find(ll n, ll wt, ll nm)
{
ll st = 1;
ll en = nm;
ll mid = (st) + (en - st)/2;
while(st<=en)
{
if(wt+3*(nm+mid)>=n && wt+2*(nm+mid)<=n)
{
return mid;
}
else if(wt+3*(nm+mid)<n)
{
st = mid+1;
}
else
{
en = mid-1;
}
mid = (st) + (en - st)/2;
}
if(wt+3*(nm+mid)>=n && wt+2*(nm+mid)<=n)
{
return mid;
}
return 0;
}
bool my(pair<ll, char> p1, pair<ll, char> p2)
{
return p1.first > p2.first;
}
struct segment
{
ll l,r,v;
};
bool my(segment a, segment b)
{
return a.l<b.l;
}
ll convert(string s)
{
ll n = 0;
REP(i,0,s.size())
{
if(!(n>>(s[i]-97)&1))
{
n+=(1<<(s[i]-97));
}
}
return n;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin>>s;
ll n = s.size();
ll ans = (n*(n+1))/2;
ll count[26]={0};
for(ll i=n-1; i>=0; i--)
{
count[s[i]-97]++;
ans-=count[s[i]-97];
}
cout<<ans+1<<"\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n);i++)
#define sz(x) int(x.size())
typedef long long ll;
typedef long double ld;
typedef pair<int,int> P;
int main() {
string s;
cin >> s;
vector<ll> cnt(26, 0);
ll n = s.size();
ll res = n * (n - 1) / 2;
rep(i,n) cnt[s[i] - 'a']++;
rep(i,26) res -= cnt[i] * (cnt[i] - 1) / 2;
cout << res + 1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#include <limits>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
#define fi(i, n) for( int i=0 ; i<n ; i++ )
#define f(i, a, b) for( int i=a ; i<b ; i++ )
#define vi vector<int>
#define pb push_back
#define MOD 1000000007
int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
ll fact(ll n)
{
ll ans = 1e14;
for(ll i = 1; i<=sqrt(n); i++)
{
if(n%i==0)
{
ll sol = (i - 1) + (n/i - 1);
ans = min(ans,sol);
}
}
return ans;
}
int visited[200000] = {0};
vector<vector<int> > v(200000);
int dfs(int x)
{
int ans = 0;
if(visited[x]==0)
{
visited[x] = 1;
ans++;
int a = v[x].size();
for(int j = 0; j<a; j++)
{
int data = v[x][j];
ans = ans + dfs(data);
}
}
return ans;
}
void primefactors(int n)
{
for (int i = 3; i <= sqrt(n); i = i + 2)
{
// While i divides n, print i and divide n
while (n % i == 0)
{
cout << i << " ";
n = n/i;
}
}
// This condition is to handle the case when n
// is a prime number greater than 2
if (n > 2)
cout << n << " ";
}
double fib(int n)
{
double sol1,sol2;
sol1 = (1 + sqrt(5))/2;
sol2 = (1 - sqrt(5))/2;
sol1 = pow(sol1,n);
sol2 = pow(sol2,n);
double ans = sol1 - sol2;
ans = ans/sqrt(5);
//ans = int(ans);
return ans;
}
ll digits(ll n)
{
return floor(log10(double(n))) + 1;
}
int main()
{
string s,t;
cin>>s>>t;
cout<<t + s;
}
|
#include <iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<cmath>
#include<set>
using namespace std;
int main()
{
string S;
cin >> S;
int w;
cin >> w;
for (int i = 0; i < S.length(); i++) {
if (i % w == 0) {
cout << S[i];
}
}
cout << endl;
}
| 0 |
//
// nomura_a.cpp
// learningCplusplus
//
// Created by Tran Duc Chinh on 2020/04/04.
// Copyright © 2020 Tran Duc Chinh. All rights reserved.
//
#include <iostream>
#include <queue>
#include <map>
#include <algorithm>
#include <math.h>
using namespace std;
typedef long long ll;
ll mod = 998244353;
ll INF = 1000000007;
#define PI 3.14159265
pair<int, int> dijsktra(int x, char des, int n, vector<pair<int, char> > *adj) {
priority_queue<pair<pair<int, char>, int> > q; // (-d, x) current distance to node x is d, using -d to find minimum distance
bool processed[n];
pair<int, char> distance[n];
for (int i=0; i<n; i++) {
distance[i].first = INF;
distance[i].second = '0';
processed[i] = false;
}
// find from x
distance[x] = make_pair(0, '0');
q.push({distance[x], x});
while (!q.empty()) {
int a = q.top().second;
q.pop();
if (processed[a]) continue;;
processed[a] = true;
for (auto u: adj[a]) {
int b = u.first; // node b
char label = u.second;
int w = 1; // distance from a to b is w
if (distance[b].first > distance[a].first + w) {
distance[b] = make_pair(distance[a].first + w, label);
q.push({{-distance[b].first, label}, b});
}
}
}
int l = INF;
int end = 0;
// std::cout << "distance from " << x << std::endl;
for (int i = 0; i < n; i++) {
if (distance[i].first==INF) continue;
if (distance[i].second == des && distance[i].first < l) {
l = distance[i].first;
end = i;
}
// std::cout << " distance to " << i << ": " << distance[i] << std::endl;
}
return make_pair(l, end);
}
int main() {
int h1, m1, h2, m2, k;
cin >> h1 >> m1 >> h2 >> m2 >> k;
std::cout << h2*60+m2 - (h1*60+m1) - k << std::endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <cmath>
#include <sstream>
#include <iomanip>
#include <set>
#include <queue>
#include <stack>
#include <utility>
#include <stdio.h>
#include <unistd.h>
using namespace std;
typedef long long int ll;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define drep(i, n) for(int i = n - 1; i >= 0; i--)
#define itrep(itr, base) for (auto itr = base.begin(); itr != base.end(); itr++)
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define yes cout << "yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
#define no cout << "no" << endl
#define PI 3.14159265359
const int INF = 1001001001;
const ll LINF = 1001002003004005006ll;
const int mod = 1000000007;
void P(int x) {cout << x << endl;}
void P(long x) {cout << x << endl;}
void P(double x) {cout << x << endl;}
void P(ll x) {cout << x << endl;}
void P(string x) {cout << x << endl;}
void P(char x) {cout << x << endl;}
ll gcd(ll a, ll b) { return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) { return a/gcd(a,b)*b;}
int main() {
int h[2], m[2], k;
cin >> h[0] >> m[0] >> h[1] >> m[1] >> k;
int up = h[0] * 60 + m[0];
int down = h[1] * 60 + m[1];
if (down - up - k < 0) {
P(0);
} else {
P(down - up - k);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int mod=1000000007;
const int INF=1001001001;
vector<pair<int64_t,int64_t>>prime_factorize(int64_t x){
vector<pair<int64_t,int64_t>>p;
for(int64_t i=2;i*i<=x;i++){
int cnt=0;
if(x%i==0){
while(x%i==0){cnt++;x/=i;}
p.push_back(make_pair(i,cnt));
}
}
if(x!=1){p.push_back(make_pair(x,1));}
return p;
}
int main() {
int A,B,C,D;
cin>>A>>B>>C>>D;
if(A+B==C+D){cout<<"Balanced"<<endl;}
else if(A+B<C+D){cout<<"Right"<<endl;}
else{cout<<"Left"<<endl;}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a,b,c,d;
cin >> a >> b >> c >> d;
int L=a+b;
int R=c+d;
if(L>R){
cout << "Left" << endl;
}
if(L<R){
cout << "Right" << endl;
}
if(L==R){
cout << "Balanced" << endl;
}
}
| 1 |
/*
author : nishi5451
created: 11.08.2020 00:36:47
*/
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
typedef long long ll;
int main(){
string a,b,c;
cin >> a >> b >> c;
if(*a.rbegin()==*b.begin() && *b.rbegin()==*c.begin()){
cout << "YES" << endl;
}
else cout << "NO" << endl;
return 0;
}
|
#include <stdio.h>
int main () {
char a[12];
char b[12];
char c[12];
int lenA = 0, lenB = 0;
scanf("%s", a);
scanf("%s", b);
scanf("%s", c);
for(int i = 0; a[i] != '\0'; i++) {
lenA++;
}
for(int i = 0; b[i] != '\0'; i++) {
lenB++;
}
if (a[lenA-1] == b [0] && b[lenB-1] == c[0]) {
printf("YES\n");
}
else {
printf("NO\n");
}
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <limits.h>
#include <queue>
using namespace std;
using P=pair<int,int>;
using PP=pair<P,int>;
const int INF=INT_MAX;
/* RMQ：[0,n-1] について、区間ごとの最小値を管理する構造体
update(i,x): i 番目の要素を x に更新。O(log(n))
query(a,b): [a,b) での最小の要素を取得。O(log(n))
*/
template <typename T>
struct RMQ {
const T INF = numeric_limits<T>::max();
int n; // 葉の数
vector<T> dat; // 完全二分木の配列
RMQ(int n_) : n(), dat(n_ * 4, INF) { // 葉の数は 2^x の形
int x = 1;
while (n_ > x) {
x *= 2;
}
n = x;
}
void update(int i, T x) {
i += n - 1;
dat[i] = x;
while (i > 0) {
i = (i - 1) / 2; // parent
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
// the minimum element of [a,b)
T find(int a, int b) { return query_sub(a, b, 0, 0, n); }
T query_sub(int a, int b, int k, int l, int r) {
if (r <= a || b <= l) {
return INF;
} else if (a <= l && r <= b) {
return dat[k];
} else {
T vl = query_sub(a, b, k * 2 + 1, l, (l + r) / 2);
T vr = query_sub(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr);
}
}
};
signed main(){
int n,q;
cin>>n>>q;
priority_queue<pair<int,P>,vector<pair<int,P>>,greater<>> c;
for(int i=0;i<n;i++){
int s,t,x;
cin>>s>>t>>x;
c.push(make_pair(s-x,P(x,i)));
c.push(make_pair(t-x,P(x,i)));
}
vector<int> d(q);
for(int i=0;i<q;i++){
cin>>d[i];
}
RMQ<int> r(n);
for(int i=0;i<q;i++){
queue<pair<int,P>> task;
while(!c.empty()&&c.top().first<=d[i]){
int p=c.top().second.first,idx=c.top().second.second;
//cout<<c.top().first<<" "<<p<<" "<<idx<<endl;
if(r.find(idx,idx+1)==INF){
r.update(idx,p);
}else r.update(idx,INF);
c.pop();
}
if(r.find(0,n)==INF)cout<<-1<<endl;
else cout<<r.find(0,n)<<endl;
}
}
|
#include <iostream>
char jukuClass(int, int, int);
int main()
{
while (true) {
int n;
std::cin >> n;
if (n == 0) {
break;
}
for (int i = 0; i < n; ++i) {
int pm, pe, pj;
std::cin >> pm >> pe >> pj;
std::cout << jukuClass(pm, pe, pj) << std::endl;
}
}
return 0;
}
char jukuClass(int pm, int pe, int pj)
{
if (pm == 100 || pe == 100 || pj == 100) {
return 'A';
} else if ((pm + pe) / 2.0 >= 90) {
return 'A';
} else if ((pm + pe + pj) / 3.0 >= 80) {
return 'A';
} else if ((pm + pe + pj) / 3.0 >= 70) {
return 'B';
} else if (((pm + pe + pj) / 3.0 >= 50) && (pm >= 80 || pe >= 80)) {
return 'B';
} else {
return 'C';
}
}
| 0 |
#include<iostream>
#include<algorithm>
#include<functional>
#define MAX 1000
int main(){
int n,m,p[MAX];
while(1){
int f=0,m1=0;
std::cin>>n>>m;
if(n==0&&m==0)
break;
for(int i=0;i<n;++i){
std::cin>>p[i];
m1+=p[i];
}
std::sort(p,p+n,std::greater<int>());
int c=n%m;
for(int i=0;i<n-c;++i){
if((i+1)%m==0)
f+=p[i];
}
std::cout<<m1-f<<std::endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,a,n) for(int i=a;i<n;i++)
#define repr(i,a,n) for(int i=a;i>=n;i--)
#define INF 999999999
#define INF_M 2147483647
#define pb(a) push_back(a)
using namespace std;
typedef pair<int, int> pii;
typedef long long int ll;
typedef vector<pii> VP;
int dy[]={0, 0, 1, -1};
int dx[]={1, -1, 0, 0};
int main() {
string s;
while(getline(cin,s)) {
string t;
rep(j,0,26) {
t.clear();
rep(i,0,s.length()) {
if('a' <= s[i] && s[i] <= 'z') t += (s[i] + j > 'z') ? (s[i] + j - 26) : (s[i] + j);
else t += s[i];
}
if(t.find("this") != string::npos) break;
else if(t.find("the") != string::npos) break;
else if(t.find("that") != string::npos) break;
}
cout << t << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> wa(N + 5, 0);
for (int i = 0; i < M; i++) {
int p;
string s;
cin >> p >> s;
if (wa[p] >= 0 && s == "WA") wa[p]++;
else if (wa[p] >= 0 && s == "AC") wa[p] = wa[p] * (-1) - 1;
}
int ac = 0, penalty = 0;
for (auto a: wa){
if (a < 0) {
penalty += (a + 1) * (-1);
ac++;
}
}
cout << ac << " " << penalty << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> wa(n), al(n);
int ac = 0, pe = 0;
while (m--) {
int p;
string s;
cin >> p >> s;
p--;
if (s == "WA") {
if (al[p] == 0) wa[p]++;
} else {
if (al[p] == 0) {
pe += wa[p];
ac++;
}
al[p] = 1;
}
}
cout << ac << ' ' << pe;
return 0;
}
| 1 |
//
// main.cpp
// Atcoder1
//
// Created by Hamske on 2020/09/17.
// Copyright © 2020 Author. All rights reserved.
//
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <string>
using namespace std;
//#define pb push_back
//#define mp make_pair
//
//#define F first
//#define S second
typedef long long ll;
#define rept(_i,iv,n,type) for(type _i=(type)(iv);_i<(type)(n);++_i)
//#define repi(_i,iv,n) rept(_i,iv,n,int)
//#define repl(_i,iv,n) rept(_i,iv,n,ll)
#define rept0(_i,n,type) rept(_i,0,n,type)
#define repi0(_i,n) rept(_i,0,n,int)
#define repl0(_i,n) rept(_i,0,n,ll)
//#define repst(_i,iv,n,type) for(type _i=iv;_i<=(type)(n);++_i)
//#define repsi1(_i,n) repst(_i,1,n,int)
#define REPT(_i,iv,_l,n,type) for(type _i=(type)(iv),_l=(type)(n);_i<_l;++_i)
//#define REPI(_i,iv,_l,n) REPT(_i,iv,_l,n,int)
//#define REPL(_i,iv,_l,n) REPT(_i,iv,_l,n,ll)
//
#define REPT0(_i,_l,n,type) REPT(_i,0,_l,n,type)
#define REPI0(_i,_l,n) REPT(_i,0,_l,n,int)
#define REPL0(_i,_l,n) REPT(_i,0,_l,n,ll)
//#define rrept(_i,x,e,type) for(type _i=((type)(x)-1);_i>=e;--_i)
//
//#define rrept0(_i,x,type) rrept(_i,x,0,type)
//
//#define RREPT(_i,x,_e,e,type) for(type _i=((type)(x)-1),_e=(type)(e);_i>=_e;--_i)
//
//#define RREPT0(_i,x,_e,type) RREPT(_i,x,_e,0,type)
//
//#define RREPS(i,x) for(int i=((int)(x));i>0;i--)
//#define all(x) (x).begin(),(x).end()
#define REPV(v,_itr,_end) for(auto _itr=(v).begin(),_end=(v).end();_itr!=_end;++_itr)
#define REPVC(v,_itr,_end) for(auto _itr=(v).cbegin(),_end=(v).cend();_itr!=_end;++_itr)
#define td typedef
//#define tds(stl,type,name) typedef stl<type > name;
#define tdv(type,name) typedef vector<type > name;
//typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<vb > vvb;
typedef vector<int> vi;
typedef vector<vi > vvi;
//typedef vector<ll> vll;
//typedef vector<vll > vvll;
#define MOD7 1'000'000'007
#define MOD9 1'000'000'009
int main(int argc, const char * argv[]) {
int N;
cin>>N;
vi A(N);
REPV(A, itr, end){
cin>>(*itr);
}
ll sum=0;
int bh=0;
repi0(i, N){
if(bh<=A[i]){
bh=A[i];
}else{
sum+=bh-A[i];
}
}
cout<<sum<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,s,n) for (int i=s;i<n;++i)
#define drep(i,s,n) for (int i=n;i>=s;--i)
#define all(x) (x).begin(),(x).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define print(x) cout<<(x)<<endl
using namespace std;
typedef long long 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/gcd(a,b)*b;}
void printv(vector<auto> v) {cout<<'[';rep(i,0,v.size()){cout<<v[i]<<',';}cout<<']'<<endl;}
void printvv(vector<vector<auto>> vv)
{cout<<'['<<endl;
rep(q,0,vv.size()){cout<<'[';rep(p,0,vv.at(q).size())cout<<vv.at(q).at(p)<<',';cout <<']'<<endl;}
cout<<']'<<endl;}
void solve(); int main(){cin.tie(0);ios::sync_with_stdio(0);solve();}
int step_x[] = {-1,0,0,1};
int step_y[] = {0,-1,1,0};
ll INF=1e18;
//------------------------------------------------------------
int N;
int nums[1100];
ll ans=1;
void solve() {
cin>>N;
rep(i,1,N)
{
int num = i+1;
for(int j=2*num;j<=N;j+=num) nums[j]=1;
}
rep(i,1,N)
{
int num = i+1;
if(nums[num]==0)
{
ll tmp=0;
for(int j=num; j<=N; j*=num) tmp+=N/j;
// tmp+=N/num;
ans = ans*(tmp+1)%(int)(1e9+7);
}
}
print(ans);
return;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long N,a,c=1,A[100002]={};A[0]=3;
cin>>N;
for(int i=0;i<N;i++){
scanf("%d",&a);
c*=(A[a]-A[a+1]++);
c%=1000000007;
}
cout<<c<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int MOD=1000000007;
int N;cin>>N;
vector<int> A(N);
for(int i=0;i<N;i++)cin>>A[i];
int a=0,b=0,c=0;
long ans=1;
for(int i=0;i<N;i++){
int m=0;
if(A[i]==a)m++;
if(A[i]==b)m++;
if(A[i]==c)m++;
ans=(ans*m)%MOD;
if(A[i]==a)a++;
else if(A[i]==b)b++;
else if(A[i]==c)c++;
}
cout<<ans<<endl;
}
| 1 |
/**
* created: 03.07.2020 16:00:37
**/
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
// using bint = boost::multiprecision::cpp_int;
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define pcnt(bit) __builtin_popcountll(bit)
template<class T> bool chmax(T &a, const T &b) {if (a < b) {a = b; return 1;} return 0;}
template<class T> bool chmin(T &a, const T &b) {if (b < a) {a = b; return 1;} return 0;}
const long double pi = acos(-1.0);
const int INF = 1LL << 60;
const int MOD = 1000000007;
// const int MOD = 998244353;
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int a, b;
cin >> a >> b;
cout << 2 * b - a << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define pb push_back
const int N = 202;
int a[N];
int main() {
//ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int n, l;
scanf("%d %d", &n, &l);
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += l + i - 1;
}
int res, mn = 1e9, tot = sum;
for (int i = 1; i <= n; i++) {
tot -= l + i - 1;
if (abs(tot - sum) < mn) {
mn = abs(tot - sum);
res = tot;
}
tot += l + i - 1;
}
printf("%d", res);
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <string>
#include <set>
using ll = long long;
using namespace std;
// xorの掃き出し法をするためのクラス
// matに基底たちが入る
// Tはbitsetは無理(minしないといけないから)
template <typename T>
class BitLinearSpace {
vector<T> bases; // この中身をsortしちゃうと壊れる
public:
BitLinearSpace() = default;
BitLinearSpace(vector<T> &matrix) {
for (auto &mi:matrix) {
add_val(mi, false);
}
}
// valが張れるように基底を追加する
// 追加した場合true, しなかった場合false
// O(N) (ソートするとNlogN)
// 追加後にソートするかを選ぶ
bool add_val(T val) {
if ((val = elementary_opperation(val))) {
bases.push_back(val);
return true;
} else {
return false;
}
}
// 今のベクトル空間にvalが含まれるか(=basesの要素のxorでvalが作れるかをチェック)
// O(n)
bool includes(T val) {
return elementary_opperation(val) == 0;
}
// 行列にvalを追加するていで行基本変形をvalに施す
// 実際には追加しない
// O(n)
T elementary_opperation(T val) {
for (auto &b:bases) {
val = min(val, val ^ b);
}
return val;
}
T &operator[](int i) { return bases[(size_t)i]; }
const T &operator[](int i) const { return bases[(size_t)i]; }
auto begin() { return bases.begin(); }
auto end() { return bases.end(); }
auto begin() const { return bases.begin(); }
auto end() const { return bases.end(); }
int size() { return (int)bases.size(); }
};
int main() {
int n;
cin >> n;
BitLinearSpace<ll> bls;
ll sum = 0;
for (int i=0; i<n; i++) {
ll ai; cin >> ai;
sum ^= ai;
bls.add_val(ai);
}
vector<ll> bases(bls.begin(), bls.end());
ll blue = 0, red = sum;
for (int i=59; i>=0; i--) {
if ((blue & (1ll << i)) == (red & (1ll << i))) {
ll used = -1;
for (auto &bi:bases) {
if (bi & (1ll << i)) {
if (used < 0) {
if ((blue & (1ll << i)) == 0)
blue ^= bi;
used = bi;
}
bi ^= used;
}
}
}
red = blue ^ sum;
}
cout << blue + red << '\n';
return 0;
}
|
#include <iostream>
#include <algorithm>
std::vector<size_t> gaps = {1};
template <typename T>
size_t insertion_sort(T a[], size_t n, size_t gap = 1){
size_t count = 0;
for(size_t i = gap; i < n; i++){
T v = a[i];
int j = i - gap;
while(j >= 0 && a[j] > v){
a[j+gap] = a[j];
j -= gap;
count++;
}
a[j+gap] = v;
}
return count;
}
void make_gap_table(size_t n){
size_t h = 4;
while(h < n){
gaps.push_back(h);
h = 3*h + 1;
}
}
template <typename T>
void shell_sort(T a[], size_t n){
make_gap_table(n);
size_t count = 0;
for(auto it = gaps.rbegin(); it != gaps.rend(); it++){
count += insertion_sort(a,n,*it);
}
std::cout << gaps.size() << '\n';
for(auto it = gaps.rbegin(); it != std::prev(gaps.rend()); it++){
std::cout << *it << ' ';
}
std::cout << *(std::prev(gaps.rend())) << '\n';
std::cout << count << '\n';
}
int main(){
size_t n;
size_t buf;
std::vector<size_t> a;
std::cin >> n;
for(size_t i = 0; i < n; i++){
std::cin >> buf;
a.push_back(buf);
}
shell_sort(a.data(),a.size());
for(auto &v : a){
std::cout << v << '\n';
}
}
| 0 |
#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 pair<int, int> P;
typedef pair<long long, long long> LLP;
typedef long long ll;
class Dijkstra {
private:
vector< vector<LLP> > G;
vector<long long> cost;
vector<long long> par;
priority_queue<LLP, vector<LLP>, greater<LLP> > que;
public:
Dijkstra(long long n, vector< vector<long long> > g, long long s);
long long getCost(long long target);
vector< vector<long long> > getPath(long long target);
};
// n: |V|
// g: [point_from, point_to, cost] (directed graph)
// s: start point
Dijkstra::Dijkstra(long long n, vector< vector<long long> > g, long long s) {
for (long long i = 0; i < n; i++) {
G.push_back(vector<LLP>());
cost.push_back(-1);
par.push_back(-1);
}
// create adj-Graph
for (long long i = 0; i < g.size(); i++) {
G[g[i][0]].push_back(make_pair(g[i][1], g[i][2]));
}
// initialize
cost[s] = 0;
par[s] = s;
que.push(make_pair(cost[s], s));
while (!que.empty()) {
LLP p = que.top();
que.pop();
if (cost[p.second] < p.first) continue;
for (int i = 0; i < G[p.second].size(); i++) {
if (cost[G[p.second][i].first] < 0 || cost[G[p.second][i].first] > cost[p.second] + G[p.second][i].second) {
cost[G[p.second][i].first] = cost[p.second] + G[p.second][i].second;
par[G[p.second][i].first] = p.second;
que.push(make_pair(cost[G[p.second][i].first], G[p.second][i].first));
}
}
}
}
// returns the minimum cost from the start point to the target.
// (if there is no path to the target, this returns -1.)
// (if the target is the start point, this returns 0.)
long long Dijkstra::getCost(long long target) {
return cost[target];
}
// returns a list of path: Array of [point_from, point_to, cost].
// (if there is no path to the target or the target is the start point, this returns an empty vector.)
vector< vector<long long> > Dijkstra::getPath(long long target) {
vector< vector<long long> > reversePath = vector< vector<long long> >(0);
if (cost[target] <= 0) return reversePath;
long long now_p = target;
while (par[now_p] != now_p) {
vector<long long> temp(3);
temp[0] = par[now_p];
temp[1] = now_p;
temp[2] = cost[now_p] - cost[par[now_p]];
reversePath.push_back(temp);
now_p = par[now_p];
}
vector< vector<long long> > path = vector< vector<long long> >(0);
for (long long i = reversePath.size() - 1; i >= 0; i--) path.push_back(reversePath[i]);
return path;
}
int main() {
int N, Q, K;
cin >> N;
vector<vector<ll>> g;
rep(i,N-1) {
vector<ll> e(3);
cin >> e[0] >> e[1] >> e[2];
e[0]--;
e[1]--;
g.push_back(e);
swap(e[0], e[1]);
g.push_back(e);
}
cin >> Q >> K;
K--;
Dijkstra tree(N, g, K);
rep(i,Q) {
int x, y;
cin >> x >> y;
x--;
y--;
cout << tree.getCost(x) + tree.getCost(y) << endl;
}
return 0;
}
|
#include "bits/stdc++.h"
#define rep(i,n) for(int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
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 dp[2][6005];
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n, t;
cin >> n >> t;
vector<P> v(n);
rep(i,n) cin >> v[i].first >> v[i].second;
sort(v.begin(), v.end());
rep(i,n){
int a = v[i].first;
int b = v[i].second;
rep(j,6001){
chmax(dp[(i+1)%2][j], dp[i%2][j]);
if(j < t) chmax(dp[(i+1)%2][j+a], dp[i%2][j] + b);
}
}
int ans = 0;
rep(j,6001) chmax(ans, dp[n%2][j]);
cout << ans << endl;
return 0;
}
| 0 |
#include <iostream>
#include <numeric>
#include <cmath>
#include <limits>
#include <stdio.h>
#include <iomanip>
#include <cstdlib>
#include <string> // string, to_string, stoi
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
using namespace std;
using ll = long long;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
ll Max(ll(a), ll(b), ll(c)) {
return max(max(a, b), c);
}
ll Min(ll(a), ll(b), ll(c)) {
return min(min(a, b), c);
}
ll gcd(ll(a), ll(b)) {
ll c = a;
while (a % b != 0) {
c = a % b;
a = b;
b = c;
}
return b;
}
int main() {
ll N,K,G,M;
cin >> N >> K;
ll A;
cin >> A;
G = A;
M = A;
string an = "POSSIBLE";
rep(i, N-1) {
cin >> A;
G = gcd(G, A);
M = max(M, A);
}
if (K % G != 0 || K > M) {
an = "IM" + an;
}
cout <<an << endl;
}
|
#include <bits/stdc++.h>
/// ____ ____ ____ ____ ____
/// ||a |||t |||o |||d |||o ||
/// ||__|||__|||__|||__|||__||
/// |/__\|/__\|/__\|/__\|/__\|
///
using namespace std;
int gcd (int a, int b)
{
if(b == 0)
return a;
return gcd(b, a % b);
}
int n, k;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
int g = 0;
int mi = INT_MAX, mx = INT_MIN;
for(int i = 1; i <= n; i++)
{
int val;
cin >> val;
g = gcd(g, val);
mi = min(mi, val);
mx = max(mx, val);
}
if(k % g == 0 && mi <= k && k <= mx)
cout << "POSSIBLE\n";
else
cout << "IMPOSSIBLE\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair <ll, int> lli;
const ll Inf = 1000000000000000000ll;
const int Maxn = 200005;
const int Maxm = 1048576;
struct node {
ll add;
lli mn;
};
int n, D;
int a[2][Maxn];
node st[2][Maxm];
map <int, ll> M[2];
ll res;
void downOn(int s, int v, ll fl)
{
st[s][v].add += fl;
st[s][v].mn.first += fl;
}
void Down(int s, int v)
{
if (st[s][v].add) {
downOn(s, 2 * v, st[s][v].add);
downOn(s, 2 * v + 1, st[s][v].add);
st[s][v].add = 0;
}
}
void Union(int s, int v)
{
st[s][v].mn = min(st[s][2 * v].mn, st[s][2 * v + 1].mn);
}
void Create(int s, int v, int l, int r)
{
st[s][v].add = 0;
if (l == r) {
st[s][v].mn.first = a[s][l] - ll(l) * D;
st[s][v].mn.second = l;
} else {
int m = l + r >> 1;
Create(s, 2 * v, l, m);
Create(s, 2 * v + 1, m + 1, r);
Union(s, v);
}
}
void Update(int s, int v, int l, int r, int a, int b, ll add)
{
if (l == a && r == b) downOn(s, v, add);
else {
Down(s, v);
int m = l + r >> 1;
if (a <= m) Update(s, 2 * v, l, m, a, min(m, b), add);
if (m + 1 <= b) Update(s, 2 * v + 1, m + 1, r, max(m + 1, a), b, add);
Union(s, v);
}
}
void Insert(int s, int x, ll val)
{
map <int, ll>::iterator it = M[s].upper_bound(x);
if (it->second <= val) return;
ll oldval = it->second;
int cur = x;
it--;
Update(s, 1, 0, n - 1, it->first + 1, cur, val - oldval);
while (val <= it->second) {
cur = it->first;
oldval = it->second;
M[s].erase(it--);
Update(s, 1, 0, n - 1, it->first + 1, cur, val - oldval);
}
M[s][x] = val;
}
void Init()
{
for (int s = 0; s < 2; s++) {
Create(s, 1, 0, n - 1);
M[s][-1] = -Inf; M[s][n] = Inf;
Update(s, 1, 0, n - 1, 0, n - 1, Inf);
}
}
int main()
{
scanf("%d %d", &n, &D);
for (int i = 0; i < n; i++) {
scanf("%d", &a[0][i]);
a[1][n - 1 - i] = a[0][i];
}
Init();
int v = 0;
for (int i = 0; i < n - 1; i++) {
int ov = n - 1 - v;
Update(0, 1, 0, n - 1, v, v, Inf);
Update(1, 1, 0, n - 1, ov, ov, Inf);
ll myval = a[0][v] + ll(v) * D;
Insert(0, v, myval);
ll omyval = a[1][ov] + ll(ov) * D;
Insert(1, ov, omyval);
lli A = st[0][1].mn;
lli B = st[1][1].mn;
if (A <= B) { res += A.first; v = A.second; }
else { res += B.first; v = n - 1 - B.second; }
}
cout << res << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define int long long
using namespace std;int n,d,a[220001],b[220001];main(){cin>>n>>d;for(int i=1;i<=n;i++)cin>>a[i],b[i]=a[i];for(int i=2;i<=n;i++)b[i]=min(b[i],b[i-1]+d);for(int i=n-1;i;i--)b[i]=min(b[i],b[i+1]+d);int pos=min_element(a+1,a+1+n)-a,ans=0;for(int i=pos-1;i;i--)ans+=a[i]+b[i+1]+d;for(int i=pos+1;i<=n;i++)ans+=a[i]+b[i-1]+d;cout<<ans<<'\n';}
| 1 |
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
typedef long long ll;
#define N 1100005
struct node
{
int st,ed,cnt;
char c;
}a[N];
int c[N];
int n,z;
char ch[N],cc[N];
queue<int>q;
int main()
{
//freopen("copy.in","r",stdin);
//freopen("copy.out","w",stdout);
scanf("%d%s%s",&n,ch+1,cc+1);
bool flag=true;
for(int i=1;i<=n;i++)
{
if(ch[i]!=cc[i])
{
flag=false;
break;
}
}
if(ch[1]!=cc[1])
{
puts("-1");return 0;
}
if(flag)
{
puts("0");return 0;
}
for(int i=1;i<=n;i++)
{
int j=i;
while(j<=n&&cc[j]==cc[i])j++;
a[++z].st=i;a[z].ed=j;
if(cc[j]!=cc[i])a[z].ed--;
a[z].c=cc[i];
i=a[z].ed;
}
int la=n,ans=0;
for(int i=z;i;i--)
{
la=min(la,a[i].st);
while(la&&a[i].c!=ch[la])la--;
if(la==0)
{
puts("-1");return 0;
}
while(!q.empty()&&q.front()-q.size()>=a[i].ed)q.pop();
q.push(la);
int te=q.size();
ans=max(ans,te);
}
printf("%d\n",ans);
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define INF 1e9;
using namespace std;
using ll = long long;
int main() {
int x , y;
cin >> x >> y;
int t = abs(abs(x)-abs(y));
if((x > 0 && y < 0) || (x < 0 && y > 0)){
t++;
}
else if((x == 0 || y == 0) && y < x){
t++;
}
else if (y < x){
t+=2;
}
cout << t << endl;
return 0;
}
| 0 |
/**************
* Shell Sort
*************/
#include <iostream>
#include <vector> //??£?¨?
#include <algorithm>
using namespace std;
typedef vector<int> TList;
void insertionSort(TList* A, int g, int* cnt ){
for(unsigned int i=g ; i<(A->size()); i++){
int v = (*A)[i];
int j = i-g;
while(j>=0 && (*A)[j]>v){
(*A)[j+g] = (*A)[j];
j = j-g;
(*cnt)++;
}
(*A)[j+g] =v;
}
return ;
}
//---------------------------------------------------------
void shellSort(TList* A, TList* G, int* cnt){
for(unsigned int i=0; i<(G->size()); i++){
insertionSort(A, (*G)[i], cnt);
}
return;
}
//--<<???????????¢??°>>-------------------------------------------------------
int main(){
//??????????¨????
cin.tie(0);
ios::sync_with_stdio(false);
//??\???
int n;
cin >> n;
vector<int> A;
A.resize(n);
for(unsigned int i=0; i< A.size(); i++){
cin >> A[i];
}
//??????
TList G;
// G.reserve(100);//????????????????´???°???????????£??????????????¨????????????
int sum = 1;
while(sum <= n){
G.push_back(sum);
sum = sum * 3 + 1;
}
reverse(G.begin(), G.end());
int cnt = 0;
shellSort(&A, &G, &cnt);
//??????
cout << G.size() << endl;
for(unsigned int i=0; i<(G.size()); i++){
cout << G[i];
if(i!=(G.size()-1)){
cout <<" " ;
}
}
cout << endl;
cout << cnt << endl;
for(int i=0; i< n; i++){
cout << A[i]<< endl;
}
return 0;
}
//-----------------------------------------------
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,j,n) for(int i=(int)(j);i<(int)(n);i++)
#define REP(i,j,n) for(int i=(int)(j);i<=(int)(n);i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(),(a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<int,int>
#define priq priority_queue<int>
#define disup(A,key) distance(A.begin(),upper_bound(ALL(A),(int)(key)))
#define dislow(A,key) distance(A.begin(),lower_bound(ALL(A),(int)(key)))
#define tii tuple<int,int,int>
#define Priq priority_queue<int,vi,greater<int>>
#define pb push_back
#define mp make_pair
#define INF (1ll<<60)
signed main(){
int N; cin>>N;
vi A(N);
rep(i,0,N) cin>>A[i];
vi dp(N+1);
rep(i,0,N) dp[i+1]=dp[i]+A[i];
int ans=INF;
REP(i,2,N){
int X=disup(dp,dp[i]/2),Y=disup(dp,(dp[i]+dp[N])/2);
rep(j,0,(1ll<<2)){
bitset<2> B(j);
int P=X,Q=Y;
if(B.test(0)) P--;
if(B.test(1)) Q--;
vi C(4);
C[0]=dp[P];
C[1]=dp[i]-dp[P];
C[2]=dp[Q]-dp[i];
C[3]=dp[N]-dp[Q];
sort(ALL(C));
if(C[0]>0) ans=min(ans,C[3]-C[0]);
}
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int l,r;
cin >> l >> r;
const int num = 2019;
int comp = INT_MAX;
long long ans = 0;
for(long long i=l; i<=r; i++){
for(long long j=l; j<i; j++){
ans = ((i%num) * (j%num))%num;
if(ans < comp){
comp = ans;
}
else if(ans == 0){
cout << ans << endl;
return 0;
}
}
}
cout << comp << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long int;
int main() {
ll L, R;
cin >> L >> R;
if (R - L >= 2019) {
cout << 0 << endl;
} else {
ll ans = 2019;
for (ll i = L; i < R; i++) {
for (ll j = i + 1; j <= R; j++) {
ans = min(ans, (i * j) % 2019);
}
}
cout << ans << endl;
}
}
| 1 |
#include <cstdio>
using namespace std;
int main()
{
int n;
bool prime[10001];
for (int i=0; i<=10000; i++) prime[i]=true;
prime[0]=false;
prime[1]=false;
for (int i=2; i<=10000; i++) {
if (!prime[i]) continue;
for (int j=i+i;j<=10000; j+=i) prime[j]=false;
}
while (scanf("%d",&n)&&n!=0) {
int p1=0, p2=0;
for (int i=2; i+2<=n; i++) {
if (!prime[i]) continue;
if (prime[i]&&prime[i+2]) {
p1=i;
p2=i+2;
}
}
printf("%d %d\n",p1,p2);
}
}
|
#include <cstdio>
#include <cmath>
#define buf 10000
using namespace std;
int k=0;
int B[buf];
void Answer(int n);
int PrimeNumber(int n);
int main(void){
int i,n;
char str[buf];
for(i=2;i<buf;i++)
PrimeNumber(i);
for( ;fgets(str,sizeof(str),stdin)!=NULL; ){
sscanf(str,"%d",&n);
if(n==0) break;
Answer(n);
}
return 0;
}
void Answer(int n){
int i,j;
for(i=0;i<k;i++){
if(B[i]>n)
break;
}
for(j=i-1;j>=0;j--){
if(B[j]-B[j-1]==2){
printf("%d %d\n",B[j-1],B[j]);
break;
}
}
}
int PrimeNumber(int n){
int i,c;
if(n==2){
B[k]=n;
k++; return 0;
}
if(n<2 || n%2==0)
return 0;
c=sqrt(n);
for(i=3;i<=c;i+=2){
if(n%i==0)
return 0;
}
B[k]=n;
k++; return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll MOD = 1e9+7;
void add(ll &a, ll b)
{
a = (a + b) % MOD;
}
int main()
{
ll n, m;
cin >> n >> m;
vector<ll> x(n);
vector<ll> y(m);
for(int i = 0; i < n; i++)
{
cin >> x[i];
}
for(int i = 0; i < m; i++)
{
cin >> y[i];
}
ll xsum = 0;
ll ex = 0;
for(int i = 1; i < n; i++)
{
ll cand = x[i] - x[i-1];
add(ex, i * cand);
add(xsum, ex);
}
ll ysum = 0;
ll ey = 0;
for(int i = 1; i < m; i++)
{
ll cand = y[i] - y[i-1];
add(ey, i * cand);
add(ysum, ey);
}
cout << xsum * ysum % MOD << endl;
}
|
const int LG = 21;
const int FN = 400005;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
#include <bits/stdc++.h>
using namespace std;
#define int long long
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define fi first
#define se second
#define re return
#define pb push_back
#define uniq(x) sort(all(x)); (x).resize(unique(all(x)) - (x).begin())
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " " << #x << " " << x << endl
#define ln cerr << __LINE__ << endl
#else
#define dbg(x) void(0)
#define ln void(0)
#endif // LOCAL
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Yes[2] = {"No", "Yes"};
string YES[2] = {"NO", "YES"};
ll inq(ll x, ll y)
{
if (!y) re 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) re l * l % MOD * x % MOD;
re l * l % MOD;
}
ll rev(ll x)
{
return inq(x, MOD - 2);
}
bool __precomputed_combinatorics = 0;
vector<ll> __fact, __ufact, __rev;
void __precompute_combinatorics()
{
__precomputed_combinatorics = 1;
__fact.resize(FN);
__ufact.resize(FN);
__rev.resize(FN);
__rev[1] = 1;
for (int i = 2; i < FN; i++) __rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = 1; i < FN; i++) __fact[i] = __fact[i - 1] * i % MOD, __ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
}
ll fact(int x)
{
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[x];
}
ll cnk(int n, int k)
{
if (k < 0 || k > n) return 0;
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
int Root(int x, vector<int> &root)
{
if (x == root[x]) return x;
return root[x] = Root(root[x], root);
}
void Merge(int v, int u, vector<int> &root, vector<int> &sz)
{
v = Root(v, root), u = Root(u, root);
if (v == u) return;
if (sz[v] < sz[u])
{
sz[u] += sz[v];
root[v] = u;
}
else
{
sz[v] += sz[u];
root[u] = v;
}
}
int ok(int x, int n)
{
return 0 <= x && x < n;
}
void bfs(int v, vi &dist, vector<vi> &graph)
{
fill(all(dist), -1);
dist[v] = 0;
vi q = {v};
for (int i = 0; i < q.size(); i++)
{
for (auto u : graph[q[i]])
{
if (dist[u] == -1)
{
dist[u] = dist[q[i]] + 1;
q.push_back(u);
}
}
}
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int k, n;
cin >> k >> n;
vi a(n);
forn(i, n) cin >> a[i];
int x = *max_element(all(a));
for (int bd = 0; bd <= 30000; bd++)
{
int nx = x - bd;
int ny = k - bd;
if (nx <= (ny + 1) / 2) cout << bd, exit(0);
}
}
/* Note:
Check constants at the beginning of the code.
N is set to 4e5 but be careful in problems with large constant factor.
Setting N in every problem is more effective.
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll =long long;
#define all(v) v.begin(),v.end()
int main() {
ll N,K;
cin>>N>>K;
vector<ll> vec(N);
for(ll i=0;i<N;i++) {
cin>>vec[i];
}
ll ans=0;
for(ll i=1;i<=min(N,K);i++) {
for(ll j=0;j<=i;j++) {
ll sum=0;
priority_queue<ll> S;
ll count=0;
while(count<j) {
sum+=vec[count];
if(vec[count]<0) {
S.push(vec[count]*-1);
}
count++;
}
for(ll h=0;h<i-j;h++) {
sum+=vec[N-1-h];
if(vec[N-1-h]<0) {
S.push(vec[N-1-h]*-1);
}
}
ll s=i;
while(s<K) {
if(S.empty()) {
break;
}
sum+=S.top();
S.pop();
s++;
}
ans=max(ans,sum);
}
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
#include <queue>
#include <string>
#include <algorithm>
//#include <atcoder/all>
using namespace std;
//using namespace atcoder;
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i < n + 1; i++)
#define repr(i, n) for (int i = n - 1; i >= 0; i--)
#define repr1(i, n) for (int i = n; i > 0; i--)
#define FOR(i, j, n) for (int i = j; i < n; i++)
typedef long long ll;
const ll MOD = 1000000007; // 10^9+7
const ll INF = 10000000000;
int main(void){
int n;
cin >> n;
string s;
cin >> s;
ll r=0,g=0,b=0;
rep(i,n){
if(s[i] == 'R') r++;
if(s[i] == 'G') g++;
if(s[i] == 'B') b++;
}
ll cnt = 0;
for(int i = 0; i < n; i++){
for(int j = i+1; j < n; j++){
if(2*j-i >= n) continue;
if(s[i] != s[j] && s[j] != s[2*j-i] && s[2*j-i] != s[i]) cnt++;
}
}
cout << r*g*b - cnt << endl;
return 0;
}
| 0 |
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=1e5+5;
int n,s,x[N];long long p[N],ans;
int main(){
scanf("%d%d",&n,&s);
for(int i=1;i<=n;++i)scanf("%d%lld",&x[i],&p[i]);
for(int l=1,r=n,las=0;;){
if(s<x[l]){ans+=x[r]-s;break;}
if(x[r]<s){ans+=s-x[l];break;}
if(p[l]>=p[r]){
if(las!=1)las=1,ans+=x[r]-x[l];
p[l]+=p[r];--r;
}else{
if(las!=2)las=2,ans+=x[r]-x[l];
p[r]+=p[l];++l;
}
}
printf("%lld\n",ans);
return 0;
}
|
//Author - Rahil Malhotra
#include <bits/stdc++.h>
using namespace std;
template <typename T> void print(T t) { cout<<t<<endl; }
template<typename T, typename... Args> void print(T t, Args... args) { cout<<t<<" "; print(args...); }
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl '\n'
#define int long long
#define double long double
void start() {
#ifndef ONLINE_JUDGE
freopen("in", "r", stdin);
freopen("out", "w", stdout);
#endif
}
int n,t;
vector< pair<int,int> >v;
int cache[3004][3004];
int dp(int pos,int time) {
if(pos == n || time >= t) {
return 0;
}
int &ans = cache[pos][time];
if(ans != -1) {
return ans;
}
ans = dp(pos+1, time);
ans = max(ans, v[pos].second + dp(pos+1, time + v[pos].first));
return ans;
}
int32_t main() {
IOS;
start();
cin >> n >> t;
for(int i = 0; i < n; i++) {
int a,b;
cin >> a >> b;
v.push_back(make_pair(a,b));
}
sort(v.begin(), v.end());
memset(cache, -1, sizeof(cache));
print(dp(0,0));
}
| 0 |
#include <iostream>
#include <string>
using namespace std;
int main(void){
string str;
cin >> str;
int q;
cin >> q;
for(int i = 0; i < q; i++){
string op, p = "";
int a, b;
cin >> op;
if(op == "print"){
cin >> a >> b;
cout << str.substr(a, b - a + 1) << endl;
} else if (op == "reverse"){
cin >> a >> b;
for(int i = b; i >= a; i--) p += str[i];
str.replace(a, b - a + 1, p);
} else {
cin >> a >> b >> p;
str.replace(a, b - a + 1, p);
}
}
return 0;
}
|
#include <iostream>
#include <cstdlib>
using namespace std;
void print(int a, int b, char str[]);
void rev(int a, int b, char str[]);
void rep(int a, int b, char str[], char repstr[]);
int main()
{
char str[1000];
int orderlen;
cin >> str;
cin >> orderlen;
cin.clear();
cin.ignore();
for(int i=0; i<orderlen; i++)
{
char orderstr[1000], buf[1100],
pripar[3][8]={
"print",
"reverse",
"replace"
};
int a, b, j=0;
enum __ORDER{PRI, REV, REP, NONE} ORDER;
cin.getline(buf, sizeof(buf));
while(true){
if(buf[j]==' '){
bool print=true, replace=true, reverse=true;
for(int k=0; k<j; k++){
if(print) if(pripar[0][k] != buf[k]) print = false;
if(reverse) if(pripar[1][k] != buf[k]) reverse = false;
if(replace) if(pripar[2][k] != buf[k]) replace = false;
if(!print && !reverse && !replace) break;
}
if(print){
ORDER = PRI;
} else if(reverse){
ORDER = REV;
} else if(replace){
ORDER = REP;
} else {
ORDER = NONE;
}
j++;
{
int num=0;
char numbuf[4]=" ";
while(true){
numbuf[num] = buf[j];
num++;
j++;
if(buf[j]== ' ' || buf[j]=='\0') break;
}
a = atoi(numbuf);
j++;
num = 0;
while(true){
numbuf[num] = buf[j];
num++;
j++;
if(buf[j]== ' ' || buf[j]=='\0') break;
}
b = atoi(numbuf);
j++;
}
break;
}
j++;
}
if(ORDER == REP){
int num = 0;
while(true){
if(buf[j]=='\0') break;
orderstr[num] = buf[j];
num++;
j++;
}
}
switch(ORDER){
case PRI:
print(a, b, str);
break;
case REV:
rev(a, b, str);
break;
case REP:
rep(a, b, str, orderstr);
break;
default:
break;
}
}
return 0;
}
void print(int a, int b, char str[])
{
for(int i=a; i<=b; i++){
cout << str[i];
}
cout << endl;
}
void rev(int a, int b, char str[])
{
char tmp;
for(int i=a, j=b; i<j; i++){
tmp = str[i];
str[i] =str[j];
str[j] = tmp;
j--;
}
}
void rep(int a, int b, char str[], char repstr[])
{
int i=0;
for(int j=a; j<=b; j++){
str[j] = repstr[i];
i++;
}
}
| 1 |
#include"bits/stdc++.h"
using namespace std;
const int N=5e3+100;
typedef long long LL;
struct node{
LL h,p;
}a[N];
LL dp[N];
bool cmp(node a,node b){
if(a.h+a.p==b.h+b.p)return a.h<b.h;
return a.h+a.p<b.h+b.p;
}
int main()
{
int n;
scanf("%d",&n);
for(int i=0;i<=5050;i++)dp[i]=0x3f3f3f3f3f3f3f3f;
for(int i=1;i<=n;i++)
scanf("%d %d",&a[i].h,&a[i].p);
sort(a+1,a+n+1,cmp);
dp[0]=0;
for(int i=1;i<=n;i++){
for(int j=i-1;j>=0;j--){
if(a[i].h>=dp[j]){
dp[j+1]=min(dp[j+1],dp[j]+a[i].p);
}
}
}
int ans=1;
for(int i=2;i<=n;i++)
if(dp[i]!=0x3f3f3f3f3f3f3f3f)ans=i;
printf("%d\n",ans);
}
|
#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;
typedef tuple<ll,ll,ll> T;
const long long INF = 1LL<<60;
const int MOD = 1000000000+7;
#define rev(s) (string((s).rbegin(), (s).rend()))
template < typename T > inline string toString( const T &a ) { ostringstream oss; oss << a; return oss.str(); };
// cout << fixed << setprecision(10) << ans << endl; 有効桁数指定
// *min_element(c + l, c + r) *max_element(c + l, c + r) 配列の中のmin-max
// int dx[8]={1,1,0,-1,-1,-1,0,1};
// int dy[8]={0,1,1,1,0,-1,-1,-1};
// int dx[4]={1,0,-1,0};
// int dy[4]={0,1,0,-1};
// ~ は、-1の時だけfalse
int main() {
int n,a[16],x[16][16],y[16][16];
cin>> n;
rep(i,n) {
cin>>a[i];
rep(j,a[i]) {
cin>>x[i][j]>>y[i][j];
}
}
int ans = 0;
for (int bit = 0;bit<(1<<n);bit++) {
int count=0;
bool end = false,last=false;
for (int i = 0;i<n;i++) {
if((1<<i) & bit) {
rep(j,a[i]) {
if(y[i][j] != ((bit>>(x[i][j]-1))&1)) {
end = true;
break;
}
}
if(end) {
last=true;
break;
} else {
count++;
}
}
}
if(!last) ans = max(ans,count);
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
#include <ext/rope>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#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>;
/// find_by_order()
/// order_of_key()
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; /// think
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;
vector <int> a(n);
vector <vector<pii> > b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i].resize(a[i]);
for (auto &j : b[i]) {
cin >> j.y >> j.x;
--j.y;
}
}
int ans = 0;
for (int i = 1; i < (1 << n); i++) {
int res = 0;
vector <int> used(n);
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
++res;
used[j] = 1;
}
}
if (ans >= res) continue;
bool ok = true;
for (int j = 0; j < n; j++) {
if (!used[j]) continue;
for (auto &k : b[j]) {
if (k.x) {
if (!used[k.y]) {
ok = false;
}
}
else {
if (used[k.y]) {
ok = false;
}
}
}
}
if (ok) ans = res;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
typedef long long int ll;
using namespace std;
int main () {
int n;
cin >> n;
int a[n];
vector<pair<int, int> > vec[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
for (int j = 0; j < a[i]; j++) {
int x, y;
cin >> x >> y;
vec[i].push_back(make_pair(x - 1, y));
}
}
int max = 0;
for (int i = 0; i < (1 << n); i++) {
int count = 0;
int honest[n];
for (int j = 0; j < n; j++) {
honest[j] = (i >> j) & 1;
count += (i >> j) & 1;
}
bool ok = true;
for (int k = 0; k < n; k++) {
if (honest[k]) {
for (int l = 0; l < a[k]; l++) {
if (honest[vec[k][l].first] != vec[k][l].second) {
ok = false;
}
}
}
}
if (ok) {
if (max < count) max = count;
}
}
cout << max << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define newl "\n"
using namespace std;
using lli = long long int;
using vvint = vector <vector <int>>;
const int mod = 1e9 + 7;
const int N = 2e5 + 1;
lli pow1(lli a,lli b){
lli out = 1;
for(int i = 0;i < b;++i) out = out * a;
return out;
}
void solve(){
lli n;
cin >> n;
n = n - 1;
vector <lli> a;
for(int i = 0;i <= 11;++i) a.push_back(26ll * (pow1(26ll,i) - 1) / 25);
int len = upper_bound(a.begin(),a.end(),n) - a.begin();
n = n - a[len - 1];
string out = "";
for(int i = 1;i <= len;++i){
lli k = pow1(26ll,len - i);
out += 'a' + n / k;
n = n % k;
}
//reverse(out.begin(),out.end());
cout << out << newl;
return;
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(10);
#ifdef EXECUTE_LOCALLY
freopen("in.txt","r",stdin);
#endif
int t = 1;
//cin >> t;
while(t--) solve();
#ifdef EXECUTE_LOCALLY
cout << setprecision(3) << "program time: " << (double)clock() / CLOCKS_PER_SEC << newl;
#endif
return 0;
}
|
#include<iostream>
#include<string>
#include<stdio.h>
#include<cctype>
#include<algorithm>
#include<climits>
#include<cmath>
#include<map>
#include<vector>
#define INF INT_MAX
using namespace std;
long long N;
string name;
int main(){
cin >> N;
while (N != 0){
N--;
name += ('a' + (N % 26));
N /= 26;
}
reverse(name.begin(), name.end());
cout << name << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long N,x;
cin>>N>>x;
long long A[N];
for(long long i=0;i<N;i++){
cin>>A[i];
}
long long ans=0;
if(A[0]>x){
ans+=A[0]-x;
A[0]=x;
}
long long temp=0;
for(long long i=1;i<N;i++){
if(A[i-1]+A[i]>x){
temp=A[i-1]+A[i]-x;
ans+=temp;
A[i]-=temp;
}
}
cout<<setprecision(18)<<ans<<endl;
return 0;
}
|
#include <iostream>
using namespace std;
typedef long long int LLI;
int main()
{
int n;
LLI a, b, x, diff, sum = 0 ;
cin >> n >> x;
cin >> a >> b;
if( a + b > x )
{
diff = a + b - x;
if( diff <= b )
b -= diff;
else
b = 0;
sum += diff;
}
a = b;
for(int i = 2; i < n; i++)
{
cin >> b;
if( a + b > x )
{
diff = a + b - x;
if( diff <= b )
b -= diff;
else
b = 0;
sum += diff;
}
a = b;
}
cout << sum;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rrep(i, n) for (int i = (n); i >= 0; i--)
#define loop(i, r, n) for (int i = (r); i < (n); i++)
#define pb push_back
#define all(in) in.begin(),in.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; }
using ll = long long;
using ull = unsigned long long;
using namespace std;
int main(){
int n; cin >> n;
string s; cin >> s;
int q; cin >> q;
while(q--){
int k; cin >> k;
ll d = 0, m = 0, dm = 0, dmc = 0;
rep(i,n){
if(i >= k){
if(s[i-k] == 'D'){ d--; dm -= m; }
else if(s[i-k] == 'M') m--;
}
if(s[i] == 'D') d++;
else if(s[i] == 'M'){ dm += d; m++; }
else if(s[i] == 'C') dmc += dm;
}
cout << dmc << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define REP(i,s,n) for(int i=s;i<n;i++)
#define NUM 2520
#define INF (1LL<<50)
#define DEBUG 0
#define mp(a,b) make_pair(a,b)
#define SORT(V) sort(V.begin(),V.end())
#define PI (3.141592653589794)
#define TO_STRING(VariableName) # VariableName
#define LOG(x) if(DEBUG)cout<<TO_STRING(x)<<"="<<x<<" "<<endl;
#define LOG2(x,y) if(DEBUG)cout<<TO_STRING(x)<<"="<<x<<" "<<TO_STRING(y)<<"="<<y<<endl;
#define LOG3(x,y,z) if(DEBUG)cout<<TO_STRING(x)<<"="<<x<<" "<<TO_STRING(y)<<"="<<y<<" "<<TO_STRING(z)<<"="<<z<<endl;
#define LOG4(w,x,y,z) if(DEBUG)cout<<TO_STRING(w)<<"="<<w<<" "<<TO_STRING(x)<<"="<<x<<" "<<TO_STRING(y)<<"="<<y<<" "<<TO_STRING(z)<<"="<<z<<endl;
template<class T>bool chmax(T & a, const T & b) { if (a < b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
void func(long long N, std::string S, long long Q, std::vector<long long> k){
lli d=0,m=0,dm=0;
REP(j,0,Q){
lli ans = 0;
d=0,m=0,dm=0;
REP(i,0,N){
if(S[i]=='D')d++;
if(S[i]=='M'){
m++;
dm+= d;
}
if(S[i]=='C')ans += dm;
if(i<k[j]-1)continue;
if(S[i-k[j]+1]=='D'){
dm -= m;
d--;
}
if(S[i-k[j]+1]=='M'){
m--;
}
}
cout<<ans<<endl;
}
}
int main(){
// cout << fixed << setprecision(5);
long long N;
scanf("%lld",&N);
std::string S;
std::cin >> S;
long long Q;
scanf("%lld",&Q);
std::vector<long long> k(Q-1-0+1);
for(int i = 0 ; i < Q-1-0+1 ; i++){
scanf("%lld",&k[i]);
}
func(N, S, Q, std::move(k));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
template<class T> using vc = vector<T>;
template<class T> using vvc = vector<vector<T>>;
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define repr(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repe(i, l, r) for (ll i = (l); i < (r); i++)
#define reper(i, l, r) for (ll i = (r)-1; i >= (l); i--)
#define repa(i,n) for (auto& i: n)
template<class T> inline bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
void init() {cin.tie(0);ios::sync_with_stdio(false);cout << fixed << setprecision(15);}
#ifdef DEBUG
template <class T, class N> void verr(const T& a, const N& n) { rep(i, n) cerr << a[i] << " "; cerr << "\n" << flush; }
ll dbgt = 1; void err() { cerr << "passed " << dbgt++ << "\n" << flush; }
template<class H, class... T> void err(H&& h,T&&... t){ cerr<< h << (sizeof...(t)?" ":"\n") << flush; if(sizeof...(t)>0) err(forward<T>(t)...); }
#endif
const ll INF = 5e18;
const ld EPS = 1e-11;
const ld PI = acos(-1.0L);
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
//--------------------------------------------------------------------------------//
int main() {
init();
string S;
cin >> S;
if(S.find("AC")==string::npos)
cout << "No" << endl;
else
cout << "Yes" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll N; cin >> N;
ll res = to_string(N).size();
ll A,B;
// A <= B としてA,Bを求める． A <= B より Bの桁数の方が大きいことに注意．
for (ll A=1; A<=sqrt(N); A++){
if (N%A != 0) continue;
B = N/A;
// res = min(ll(to_string(B).size()),res);
res = min((ll)log10(B)+1, res);
}
cout << res << endl;
return 0;
}
| 0 |
//#define _USE_MATH_DEFINES
//#include <cmath>
#include <iostream>
//#include <stdio.h>
//#include <stdlib.h>
//#include <iomanip>
#include <vector>
#include <string>
//#include <algorithm>
//#include <functional>
//#include <time.h>
#include <sstream>
using namespace std;
bool isthe(string str){
//?????????????????????????????? the this that?????¢??? ????????°ture
int d1, d2, d3;
d1 = (str[1] - str[0] + 26) % 26;
if (d1 != 14){
return false;
}
else{
d2 = (str[2] - str[0] + 26) % 26;
if (d2 != 11 && d2 != 15 && d2 != 7){
return false;
}
else{
if (d2 == 11 && str.size() == 3){
return true;
}
else{
d3 = (str[3] - str[0] + 26) % 26;
if (d2 == 15 && d3 == 25) return true;
if (d2 == 7 && d3 == 0) return true;
}
}
}
return false;
}
int main(){
string s,sc, buf;
stringstream ss;
vector <string> as;
int dif = 0;
while (getline(cin, s)){
dif = 0;
buf = "";
sc = "";
ss.str("");
ss.clear();
sc += s;
for (int i = 0; i < sc.size(); i++){
if (sc[i] == '.')sc[i] = ' ';
}
ss << sc;
while (ss >> buf){
//the this that???????´¢
if (buf.size() == 4){
if (isthe(buf)){
dif = (buf[0] - 't' + 26)%26;
break;
}
}
if (buf.size() == 3){
if (isthe(buf)){
dif = (buf[0] - 't' + 26) % 26;
//break;
}
}
}
for (int i = 0; i < s.size(); i++){
if (s[i] >= 'a' && s[i] <= 'z') {
s[i] -= dif;
if (s[i] < 'a') s[i] += 26;
if (s[i] > 'z') s[i] -= 26;
}
}
cout << s << endl;
}
return 0;
}
|
#include<iostream>
#include<vector>
#include<string>
using namespace std;
string Caesar(string a) {
for (int b = 0; b < a.length(); b++) {
if (a[b] == 'z')a[b] = 'a';
else if (a[b] >= 'a'&&a[b] < 'z')a[b] = a[b] + 1;
}
return a;
}
int main()
{
string a;
while (getline(cin, a)) {
for (int b = 0; b < 26; b++) {
a=Caesar(a);
for (int c = 0; c < a.length() - 4; c++) {
if (a[c] == 't'&&a[c + 1] == 'h') {
if (a[c + 2] == 'e') { cout << a << endl; goto l; }
else if (a[c + 2] == 'a'&&a[c + 3] == 't') { cout << a << endl; goto l; }
else if (a[c + 2] == 'i'&&a[c + 3] == 's') { cout << a << endl; goto l; }
}
}
if(a[a.length()-1]=='t'&&a[a.length() - 2] == 'h'&&a[a.length() - 3] == 'e') { cout << a << endl; break; }
l:;
}
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
while(1){
int n=0;
cin>>n;
if(n==0)break;
int p[45]={0};
p[0]=1;
p[1]=1;
p[2]=2;
for(int i=3;i<=30;i++){
p[i]=p[i-1]+p[i-2]+p[i-3];
}
int ans=p[n]/3650;
if(p[n]%3650>0)ans++;
cout<<ans<<endl;
}
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int n=1;
int a = 0;
int f = 0;
int quest[10000] = { 1 };
double ans[10000];
int checkc = 0;
int i = 4;
double check[3] = { 1, 2, 4 };
do{
cin >> quest[a];
a++;
} while (quest[a-1] != 0);
while (a > f+1){
switch (quest[f]){
case 1:
ans[f] = 1;
break;
case 2:
ans[f] = 2;
break;
case 3:
ans[f] = 4;
break;
default:
while (quest[f] >= i){
ans[f] = check[0] + check[1] + check[2];
i++;
check[0] = check[1];
check[1] = check[2];
check[2] = ans[f];
}
}
ans[f] = ans[f] / 3650;
checkc = (int)(ans[f]);
if (ans[f] > (double)(checkc)){
checkc++;
}
if (ans[f] != 0){
cout << checkc << endl;
}
else{
cout << endl;
}
f++;
}
return 0;
}
| 1 |
#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;
int ans = (n + 110) / 111 * 111;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string s;
cin >> s;
for (int i = 0; i < s.size() - 8; i++) {
cout << s.at(i);
}
cout << endl;
}
| 0 |
#include<stdio.h>
int main()
{
printf("100 100\n");
int m,n;
scanf("%d%d",&m,&n);
/*
.*.*.*
******
*.*.*.
......
*/
/*for(int i=0;i<50;i++)
{
for(int j=0;j<100;j++)
{
if(m<n&&(m-n)%2==0)
{
m--;
printf(".");
}
else printf("#");
}
printf("\n");
}*/
for(int i=0;i<50;i++)
{
for(int j=0;j<100;j++)
{
if(m!=1&&i%2==0&&j%2==0)
{
m--;
printf(".");
}
else printf("#");
}
printf("\n");
}
/*
for(int i=50;i<100;i++)
{
for(int j=0;j<100;j++)
{
if(m>n&&(m-n)%2==0)
{
n--;
printf("#");
}
else printf(".");
}
printf("\n");
}*/
for(int i=50;i<100;i++)
{
for(int j=0;j<100;j++)
{
if(n!=1&&i%2!=0&&j%2!=0)
{
printf("#");
n--;
}
else printf(".");
}
printf("\n");
}
}
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<utility>
#include<cmath>
#include<climits>
#include<queue>
#include<stack>
#include<numeric>
#include<set>
#include<iomanip>
#include<map>
#include<type_traits>
#include<tuple>
#include<deque>
#include<cassert>
#include<bitset>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define rep(i,N) for(ll (i)=0;(i)<(N);(i)++)
#define chmax(x,y) x=max(x,y)
#define chmin(x,y) x=min(x,y)
const int mod = 1000000007;
const int MAXH = 100;
const int MAXW = 100;
int main() {
int a, b;
cin >> a >> b;
vector<string> s(MAXH);
rep(i, MAXH / 2) {
s[i] = string(MAXW, '#');
}
for (int i = MAXH / 2; i < MAXH; ++i) {
s[i] = string(MAXW, '.');
}
a--; b--;
int cur = 0;
rep(i, a) {
if(cur % 200 == 100) cur += 100;
s[cur / MAXW][cur % MAXW] = '.';
cur += 2;
}
cur = 50 * 100 + 100;
rep(i, b) {
if(cur % 200 == 100) cur += 100;
s[cur / MAXW][cur % MAXW] = '#';
cur += 2;
}
cout << MAXH << " " << MAXW << endl;
rep(i, MAXH) cout << s[i] << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool a[1000005],b[1000005];
const int mod=1e9+7;
int main()
{
int n,m;
cin>>n>>m;
long long sum=1;
for(int i=0;i<n;i++)
{
int x;
cin>>x;
if(a[x])
{
cout<<"0";
return 0;
}
a[x]=1;
}
for(int i=0;i<m;i++)
{
int y;
cin>>y;
if(b[y])
{
cout<<"0";
return 0;
}
b[y]=1;
}
int k1=0,t1=0;
for(int i=n*m;i>0;i--)
{
int k2=k1,t2=t1;
if(b[i])
{
k2=1;
k1++;
}
if(a[i])
{
t2=1;
t1++;
}
if(a[i]||b[i])
sum*=(k2*t2)%mod;
else
sum*=(k2*t2-(n*m-i))%mod;
sum%=mod;
}
cout<<sum%mod;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include<string>
#include <set>
#include <map>
#include <queue>
#include <limits.h>
#include <bitset>
#include <cmath>
using namespace std;
#define rip(i, n, s) for (int i = (s);i < ( int )( n ); i++)
#define all(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int,int> P;
struct modint {
long long num;
long long p;
modint() {
num = 0;
p = 1000000007;
}
modint(int x) {
p = 1000000007;
num = (long long)x%p;
}
modint(long long x) {
p = 1000000007;
num = x % p;
}
modint operator*(const long long &other) {
modint ret;
ret.p = p;
ret.num = (num*(other%p)) % p;
return ret;
}
void operator*=(const long long &other) {
num = (num*other) % p;
}
};
int main(){
int n,m;
cin >> n >> m;
vector<P> da(n+m);
rip(i,n,0){
cin >> da[i].first;
da[i].second=1;
}
rip(i,m,0){
cin >> da[i+n].first;
da[i+n].second=0;
}
set<int> ch;
rip(i,n,0){
if(ch.count(da[i].first)){
cout << 0 << endl;
return 0;
}
else{
ch.insert(da[i].first);
}
}
ch.clear();
rip(i,m,0){
if(ch.count(da[i+n].first)){
cout << 0 << endl;
return 0;
}
else{
ch.insert(da[i+n].first);
}
}
modint ans(1);
int now=n*m,h=0,w=0,cr=0;
sort(all(da));
reverse(all(da));
int co=0;
while(co<n+m){
//printf("%d %d %d %d %d %lld\n",now,co,h,w,cr,ans.num);
if(now<=0){
cout << 0 << endl;
return 0;
}
if(da[co].first==now){
if(co<n*m-1){
if(da[co+1].first==now){
h++;
w++;
cr++;
co++;
}
else{
if(da[co].second){
ans*=w;
h++;
}
else{
ans*=h;
w++;
}
cr++;
}
}
else{
if(da[co].second){
ans*=w;
h++;
}
else{
ans*=h;
w++;
}
}
co++;
}
else{
if((h*w)-cr>0){
ans*=(h*w)-cr;
cr++;
}
else{
cout << 0 << endl;
return 0;
}
}
now--;
}
rip(i,now+1,1){
ans*=i;
}
cout << ans.num << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 1000000007;
typedef int64_t ll;
typedef uint64_t ull;
#define FOR(i, start, end) for(uint64_t i=start; i<end; i++)
#define REP(i, n) FOR(i, 0, n)
// 最大公約数gcd
// 最小公倍数lcm=m*n/gcd
uint64_t gcd(uint64_t m, uint64_t n) {
uint64_t temp;
while (m % n != 0){
temp = n;
n = m % n;
m = temp;
}
return n;
}
uint64_t lcm(uint64_t m, uint64_t n) {
return (m*n)/gcd(m,n);
}
// vector<vector<uint64_t> > v(n+1, vector<uint64_t>(n+1, 0))
// v[n][k]に組み合わせ数が入る。
void comb(vector<vector <uint64_t> > &v){
for(uint64_t i = 0;i <v.size(); i++){
v[i][0]=1;
v[i][i]=1;
}
for(uint64_t k = 1;k <v.size();k++){
for(uint64_t j = 1;j<k;j++){
v[k][j]=(v[k-1][j-1]+v[k-1][j]);
}
}
}
// 掛け算オーバーフロー判定
bool is_product_overflow(uint64_t a, uint64_t b) {
uint64_t prod = a * b;
return (prod / b != a);
}
//素因数分解
void primeFactorization(uint64_t a, list<uint64_t> &factors){ //素因数分解を出力するプログラム
long i,sq;
if(a%2==0){ //偶数の場合
factors.push_back(2);
primeFactorization(a/2,factors); //2で割った値で再帰
return;
}
sq = sqrt(a);
for(i=3;i<=sq;i+=2){ //3以上√a以下の奇数の場合
if(a%i==0){
factors.push_back(i);
primeFactorization(a/i,factors); //割れた値で再帰
return;
}
}
//偶数でも3以上√a以下の奇数の場合でも割り切れない場合
if(a!=1){ //aが1でないなら、a自身は素数
factors.push_back(a);
}
}
// フェルマーの小定理
// mod. m での a の逆元 a^{-1} を計算する
// (a/b)%m = a*movinv(b,m)%m
int64_t modinv(int64_t a, int64_t m) {
int64_t b = m, u = 1, v = 0;
while (b) {
int64_t t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
// 円周率
// M_PI
// #include <iomanip> // setprecisionを使用するのに必要
// cout << std::fixed << std::setprecision(15) << y << endl;
// 昇順
// priority_queue<int, vector<int>, greater<int> > queue;
ll pCount(int x){
if(x==0) return 1;
return pCount(x-1)*2 + 1;
}
ll allCount(int x){
if(x==0) return 1;
return allCount(x-1)*2 + 3;
}
signed main() {
ull n,m;
cin >> n >> m;
ll ans = 1;
for(ll i=1;i*i<=m;i++){
if(m%i!=0)continue;
ll j = m/i;
if(i*n<=m) ans = max(ans,i);
if(j*n<=m) ans = max(ans,j);
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(n); i++)
using namespace std;
using ll=long long;
int main(){
int K;
string S;
cin >> K >> S;
if(S.size()<=K) {
cout << S << endl;
return 0;
}
else{
rep(i,K){
cout << S.at(i);
}
cout << "..."<< endl;
return 0;
}
}
| 0 |
#include<iostream>
using namespace std;
int main() {
int d;
while(cin >> d) {
int ans = 0;
int x = d;
while (x <= 600 - d) {
ans += x * x * d;
x += d;
}
cout << ans << endl;
}
}
|
#include <iostream>
#include <cmath>
using namespace std;
int main(){
int d, ans, n;
while(cin >> d){
ans = pow(d, 3);
n = 600 / d - 1;
ans *= n*(n+1)*(2*n+1) / 6;
cout << ans << endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define int unsigned long long
#define fi first
#define se second
#define pb push_back
#define ins insert
#define er erase
typedef pair<int, int> ii;
typedef pair<ii, int> iii;
typedef pair<ii, ii> iiii;
const int oo = 1e18 + 7, mod = 1e9 + 7, mul = (1 << 30);
int n, pw[200005], a[200005], b[200005], hash1[200005], hash2[200005], c[200005], d[200005];
vector<ii> answers;
int hash11(int l, int r){
return (hash1[r] - (hash1[l - 1] * pw[r - l + 1]) + mod * mod) % mod;
}
int hash22(int l, int r){
return (hash2[r] - (hash2[l - 1] * pw[r - l + 1]) + mod * mod) % mod;
}
signed main(){
ios_base::sync_with_stdio(0);
cin >> n;
for(int i = 1; i <= n; i++) cin >> a[i];
for(int i = 1; i <= n; i++) cin >> b[i];
for(int i = 1; i < n; i++) c[i] = (a[i] ^ a[i + 1]);
c[n] = (a[n] ^ a[1]);
for(int i = 1; i < n; i++) d[i] = (b[i] ^ b[i + 1]);
d[n] = (b[n] ^ b[1]);
//for(int i = 1; i <= n; i++) cout << c[i] << " ";
//cout << "\n";
//for(int i = 1; i <= n; i++) cout << d[i] << " ";
//cout << "\n";
for(int i = 1; i <= n; i++) hash1[i] = (hash1[i - 1] * mul + c[i]) % mod;
for(int i = 1; i <= n; i++) hash2[i] = (hash2[i - 1] * mul + d[i]) % mod;
pw[0] = 1;
for(int i = 1; i <= n; i++) pw[i] = (pw[i - 1] * mul) % mod;
for(int i = 1; i <= n; i++){
//cout << hash11(1, n - i + 1) << " " << hash22(i, n) << "\n";
if(hash11(1, (n - i + 1)) != hash22(i, n) || ((i != 1) && (hash11(n - i + 2, n) != hash22(1, i - 1)))) continue;
answers.pb({(n - i + 1) % n, b[i] ^ a[1]});
}
sort(answers.begin(), answers.end());
for(int i = 0; i < answers.size(); i++) cout << answers[i].fi << " " << answers[i].se << "\n";
}
/*
TEST HERE
INPUT #1
OUTPUT #1
INPUT #2
OUTPUT #2
INPUT #3
OUTPUT #3
*/
|
#include<bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ALL(A) A.begin(),A.end()
#define RALL(A) A.rbegin(),A.rend()
typedef long long LL;
typedef pair<int,int> P;
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 mod=1000000007;
const LL LINF=1LL<<60;
const int INF=1<<30;
int dx[]={1,0,1,-1,1,-1,-1,0};
int dy[]={0,1,1,-1,-1,1,0,-1};
int main(){
int n;cin >> n;
vector<int> a(n),b(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
vector<int> aa(3*n);
for (int i = 0; i < n; i++) {
aa[i] = b[i] ^ b[(i+1)%n];
aa[i + n] = a[i] ^ a[(i+1)%n];
aa[i + 2 * n] = aa[i + n];
}
vector< int > prefix(aa.size());
for(int i = 1, j = 0; i < aa.size(); i++) {
if(i + prefix[i - j] < j + prefix[j]) {
prefix[i] = prefix[i - j];
} else {
int k = max(0, j + prefix[j] - i);
while(i + k < aa.size() && aa[k] == aa[i + k]) ++k;
prefix[i] = k;
j = i;
}
}
for (int i = n; i < 2 * n; i++) {
if(prefix[i] >= n){
int k = i - n;
cout << k << " " << (a[k] ^ b[0]) << endl;
}
}
return 0;
}
| 1 |
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <map>
#include <math.h>
using namespace std;
#include <vector>
#define rep(i,n) for (ll i = 0; i < (n) ; i++)
#define INF 1e9
#define llINF 1e18
#define base10_4 10000 //1e4
#define base10_5 100000 //1e5
#define base10_6 1000000 //1e6
#define base10_7 10000000 //1e7
#define base10_8 100000000 //1e8
#define base10_9 1000000000 //1e9
#define MOD 1000000007
#define pb push_back
#define ll long long
#define ld long double
#define ull unsigned long long
#define vint vector<int>
#define vll vector<ll>
//#include <stack>
//#include <queue>
// #include <iomanip>
// cout << fixed << setprecision(15) << y << endl;
string ans_Yes = "Yes";
string ans_No = "No";
string ans_yes = "yes";
string ans_no = "no";
vll A;
vll B;
ll C;
ll N;
ll L;
ll K;
ll ltmp;
string stmp;
double dtmp;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> N;
cin >> L;
ll sumA=0;
rep(ni,N){
ltmp = L+(ni+1)-1;
A.push_back(ltmp);
sumA+=ltmp;
}
ll ans = sumA;
if(A[0]>0) ans-=A[0];
else if(A[N-1]<0) ans-=A[N-1];
cout << ans << 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() {
int N, L;
cin>>N>>L;
int ans = 0;
if(L*(L+N-1)<=0) {
for(int i=L;i<=L+N-1;++i) {
ans += i;
}
}
else if(L+N-1<0) {
for(int i=L;i<L+N-1;++i) ans += i;
}
else {
for(int i=L+1;i<=L+N-1;++i) ans += i;
}
cout<<ans<<endl;
}
| 1 |
// template version 1.15
using namespace std;
#include <bits/stdc++.h>
// varibable settings
#define int long long
const int INF=1e18;
// define basic macro {{{
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define _rrep(i,n) rrepi(i,0,n)
#define rrepi(i,a,b) for(int i=(int)((b)-1);i>=(int)(a);--i)
#define rrep(...) _overload3(__VA_ARGS__,rrepi,_rrep,)(__VA_ARGS__)
#define each(i,a) for (auto&& i : a)
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define pb(a) push_back(a)
#define mp(a, b) make_pair(a, b)
#define mt(a, b, c) make_tuple(a, b, c)
#define divceil(a,b) ((a)+(b)-1)/(b)
#define is_in(x, a, b) ((a)<=(x) && (x)<(b))
#define uni(x) sort(all(x));x.erase(unique(all(x)),x.end())
#define ub upper_bound
#define lb lower_bound
#define posl(A, x) (lower_bound(all(A), x)-A.begin())
#define posu(A, x) (upper_bound(all(A),x)-A.begin())
template<class T> inline void chmax(T &a, const T &b) { if((a) < (b)) (a) = (b); }
template<class T> inline void chmin(T &a, const T &b) { if((a) > (b)) (a) = (b); }
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long double ld;
typedef pair<int,int> pii;
typedef tuple<int,int,int> iii;
template<typename T> using PQ = priority_queue<T, vector<T>, greater<T>>;
struct Fast { Fast(){ std::cin.tie(0); ios::sync_with_stdio(false); } } fast;
#if defined(PCM) || defined(LOCAL)
#include "lib/dump.hpp"
#else
#define dump(...) 42
#define dump_1d(...) 42
#define dump_2d(...) 42
#define cerrendl 42
#endif
//}}}
//%snippet.set('kmp')%
// Morris-Pratt
template<typename T> struct KMP {
int n;
T pattern;
vector<int> a;
KMP() {}/*{{{*/
KMP(const T& pattern): pattern(pattern) {
n = pattern.size();
a = vector<int>(n+1);
a[0] = -1;
int j = -1;
for (int i = 0; i < n; ++i) {
while (j != -1 && pattern[j] != pattern[i]) j = a[j];
j++;
a[i+1] = j;
}
}/*}}}*/
int operator[](int i) { return a[i];}
vector<int> findAll(const T& s) {/*{{{*/
vector<int> res;
int j = 0;
for (int i = 0; i < sz(s); ++i) {
while (j != -1 && pattern[j] != s[i]) j = a[j];
j++;
if (j == n) {
res.push_back(i-j+1);
j = a[j];
}
}
return res;
}/*}}}*/
};
// KMP<vector<int>> kmp({1,2,3});
// KMP<string> kmp("abc");
//%snippet.end()%
vector<int> f(vector<int>& a) {
int n = a.size();
vector<int> res(n);
rep(i,n) res[i] = a[i]^a[(i+1)%n];
return res;
}
signed main() {
int n;
cin >> n;
vector<int> a(n), b(n);
rep(i,n) cin >> a[i];
rep(i,n) cin >> b[i];
vector<int> xa = f(a);
vector<int> xb = f(b);
dump(xa);
dump(xb);
KMP<vector<int>> kmp(xa);
dump("hello");
vi wxb;
wxb.insert(wxb.end(), xb.begin(), xb.end());
wxb.insert(wxb.end(), xb.begin(), xb.end());
vector<int> res = kmp.findAll(wxb);
vector<int> ks;
for (int p : res) ks.push_back(n-p);
sort(ks.begin(), ks.end());
for (int k : ks) {
if (k >= n) continue;
int x = a[k]^b[0];
cout << k << " " << x << endl;
}
return 0;
}
|
#define _USE_MATH_DEFINES
#include <iostream>
#include <sstream>
#include <cmath>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
typedef long long ll;
using namespace std;
bool is_1pair(int* cards){
sort(cards,cards+5);
map<int,int> freq;
for(int i=0;i<5;i++){
freq[cards[i]]++;
}
int count = 0;
for(map<int,int>::iterator it = freq.begin(); it != freq.end(); it++){
if(it->second == 2){
count++;
}
if(it->second == 3){
return false;
}
}
return count == 1;
}
bool is_2pair(int* cards){
sort(cards,cards+5);
map<int,int> freq;
for(int i=0;i<5;i++){
freq[cards[i]]++;
}
int count = 0;
for(map<int,int>::iterator it = freq.begin(); it != freq.end(); it++){
if(it->second == 2){
count++;
}
}
return count == 2;
}
bool is_3card(int* cards){
sort(cards,cards+5);
map<int,int> freq;
for(int i=0;i<5;i++){
freq[cards[i]]++;
}
int count = 0;
for(map<int,int>::iterator it = freq.begin(); it != freq.end(); it++){
if(it->second == 3){
count++;
}
if(it->second == 2){
return false;
}
}
return count == 1;
}
bool is_straight(int* cards){
sort(cards,cards+5);
map<int,int> freq;
for(int i=0;i<5;i++){
freq[cards[i]]++;
}
int count = 0;
for(map<int,int>::iterator it = freq.begin(); it != freq.end(); it++){
if(it->second > 1){
return false;
}
}
if(freq[1]==1){
int ans[][5] = {{1,2,3,4,5},{1,10,11,12,13}};
bool isok1 = true;
for(int i=0;i<5;i++){
if(cards[i] != ans[0][i]) isok1 = false;
}
bool isok2 = true;
for(int i=0;i<5;i++){
if(cards[i] != ans[1][i]) isok2 = false;
}
return (isok1 || isok2);
}
else{
for(int i=0;i+1<5;i++){
if(cards[i+1] - cards[i] != 1) return false;
}
}
return true;
}
bool is_fullhouse(int* cards){
sort(cards,cards+5);
map<int,int> freq;
for(int i=0;i<5;i++){
freq[cards[i]]++;
}
int count = 0;
bool isok1=false,isok2=false;
for(map<int,int>::iterator it = freq.begin(); it != freq.end(); it++){
if(it->second == 3){
isok1 = true;
}
else if(it->second == 2){
isok2 = true;
}
}
return isok1 && isok2;
}
bool is_4card(int* cards){
sort(cards,cards+5);
map<int,int> freq;
for(int i=0;i<5;i++){
freq[cards[i]]++;
}
int count = 0;
for(map<int,int>::iterator it = freq.begin(); it != freq.end(); it++){
if(it->second == 4){
return true;
}
}
return false;
}
int main()
{
int cards[5];
while(~scanf("%d,%d,%d,%d,%d",cards,cards+1,cards+2,cards+3,cards+4)){
if(is_1pair(cards)) cout << "one pair" << endl;
else if(is_2pair(cards)) cout << "two pair" << endl;
else if(is_3card(cards)) cout << "three card" << endl;
else if(is_straight(cards)) cout << "straight" << endl;
else if(is_fullhouse(cards)) cout << "full house" << endl;
else if(is_4card(cards)) cout << "four card" << endl;
else cout << "null" << endl;
}
}
| 0 |
#include <iomanip>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
void dfs(vector<vector<int>>& G, int u, vector<int>& dist) {
for (auto v : G[u]) {
if (dist[v] != -1) continue;
dist[v] = dist[u] + 1;
dfs(G, v, dist);
}
}
int main(void) {
ios::sync_with_stdio(false);
int N, u, v;
cin >> N >> u >> v;
--u, --v;
vector<vector<int>> G(N);
rep(i, N - 1) {
int a, b;
cin >> a >> b;
--a, --b;
G[a].emplace_back(b);
G[b].emplace_back(a);
}
vector<int> distT(N, -1);
distT[u] = 0;
dfs(G, u, distT);
vector<int> distA(N, -1);
distA[v] = 0;
dfs(G, v, distA);
int answer = 0;
rep(i, N) {
if (distT[i] < distA[i]) {
answer = max(answer, distA[i] - 1);
}
}
cout << answer << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for(int i=0; i<N; i++)
typedef long long ll;
#define dump(x) cerr<<#x<<"="<<x<<endl
using P = pair<int, int>;
int main() {
int n, u, v; cin >> n >> u >> v;
vector<vector<int>> g(n+1);
rep(i, n-1){
int a, b; cin >> a >> b;
g.at(a).push_back(b);
g.at(b).push_back(a);
}
vector<int> distU(n+1, -1);
vector<int> distV(n+1, -1);
queue<int> qu, qv;
qu.push(u);
qv.push(v);
distU.at(u) = 0;
distV.at(v) = 0;
while(!qu.empty()){
int t = qu.front();
qu.pop();
for(auto a:g.at(t)){
if(distU.at(a)!=-1) continue;
distU.at(a) = distU.at(t) + 1;
qu.push(a);
}
}
while(!qv.empty()){
int t = qv.front();
qv.pop();
for(auto a:g.at(t)){
if(distV.at(a)!=-1) continue;
distV.at(a) = distV.at(t) + 1;
qv.push(a);
}
}
int fart = v;
ll dist = 0;
for(int i=1; i<=n; i++){
if(distU.at(i)<distV.at(i)){
if(dist<distV.at(i)){
dist = distV.at(i);
fart = i;
}
}
}
dump(fart);
if(fart==v){
cout << 0 << endl;
}
else{
cout << distV.at(fart) - 1 << endl;
}
return 0;
}
| 1 |
#include <algorithm>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <time.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define SAY_YES cout << "YES" << endl;
#define SAY_Yes cout << "Yes" << endl;
#define SAY_NO cout << "NO" << endl;
#define SAY_No cout << "No" << endl;
#define IFYES(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "YES" << endl; \
} \
else \
{ \
cout << "NO" << endl; \
}
#define IFYes(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "Yes" << endl; \
} \
else \
{ \
cout << "No" << endl; \
}
#define IFyes(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "yes" << endl; \
} \
else \
{ \
cout << "no" << endl; \
}
#define DEBUG_OUTPUT_ARRAY(XXX, ONE) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << "DEBUG: i = " << i << " -> " << XXX[i] << endl; \
}
#define DEBUG_OUTPUT_ARRAY2(XXX, ONE, TWO) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << "<<< i = " << i << " >>>" << endl; \
for (int j = 0; j < (TWO); j++) \
{ \
cout << "DEBUG: j = " << j << " -> " << XXX[i][j] << endl; \
} \
}
#define DEBUG_OUTPUT_ARRAY2_BOX(XXX, ONE, TWO) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << i << " "; \
for (int j = 0; j < (TWO); j++) \
{ \
cout << XXX[i][j] << " "; \
} \
cout << endl; \
}
typedef pair<long long int, long long int> pll;
const long long int mod = 1000000007;
const long long int INF = 99999999999999999;
long long int N,M;
long long int H,W,A[210005]={},Q,sum[210005]={},res=INF;
int main()
{
cout << fixed << setprecision(18);
cin>>N;
for(long long int i = 1; i <= N; i++){
cin>>A[i];
}
for(long long int i = 1; i <= N; i++){
sum[i]=sum[i-1]+A[i];
}
for(long long int i = 2; i <= N-2; i++){
long long int p=1,q=i,pq;
while(q-p>1){
pq=(p+q)/2;
if(sum[pq]*2>=sum[i]){
q=pq;
}else{
p=pq;
}
}
long long int P=sum[p],Q=sum[i]-sum[p];
if(q!=i&&abs(sum[i]-2*sum[p+1])<=Q-P){
P=sum[p+1];
Q=sum[i]-sum[p+1];
}
long long int r=i+1,s=N,rs;
while(s-r>1){
rs=(r+s)/2;
if((sum[rs]-sum[i])*2>=sum[N]-sum[i]){
s=rs;
}else{
r=rs;
}
}
long long int R=sum[r]-sum[i],S=sum[N]-sum[r];
//cout<<R<<" "<<S<<endl;
if(s!=N&&abs(sum[N]-2*sum[r+1]+sum[i])<=S-R){
R=sum[r+1]-sum[i];
S=sum[N]-sum[r+1];
}
//cout<<i<<" "<<P<<" "<<Q<<" "<<R<<" "<<S<<endl;
res=min(res,max({P,Q,R,S})-min({P,Q,R,S}));
}
cout<<res<<endl;
}
|
#include<iostream>
#include<string.h>
#include<string>
#include<stdio.h>
#include<algorithm>
#include<vector>
#include<bitset>
#include<math.h>
#include<stack>
#include<queue>
#include<set>
#include<map>
using namespace std;
typedef long long ll;
typedef long double db;
typedef vector<int> vi;
typedef pair<int,int> pii;
const int N=200000+100;
const db pi=acos(-1.0);
#define lowbit(x) (x)&(-x)
#define sqr(x) (x)*(x)
#define rep(i,a,b) for (register int i=a;i<=b;i++)
#define per(i,a,b) for (register int i=a;i>=b;i--)
#define go(u,i) for (register int i=head[u],v=sq[i].to;i;i=sq[i].nxt,v=sq[i].to)
#define fir first
#define sec second
#define mkp make_pair
#define pb push_back
#define maxd 998244353
#define eps 1e-8
inline int read()
{
int 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;
}
namespace My_Math{
#define N 100000
int fac[N+100],invfac[N+100];
int add(int x,int y) {return x+y>=maxd?x+y-maxd:x+y;}
int dec(int x,int y) {return x<y?x-y+maxd:x-y;}
int mul(int x,int y) {return 1ll*x*y%maxd;}
ll qpow(ll x,int y)
{
ll ans=1;
while (y)
{
if (y&1) ans=mul(ans,x);
x=mul(x,x);y>>=1;
}
return ans;
}
int getinv(int x) {return qpow(x,maxd-2);}
int C(int n,int m)
{
if ((n<m) || (n<0) || (m<0)) return 0;
return mul(mul(fac[n],invfac[m]),invfac[n-m]);
}
void math_init()
{
fac[0]=invfac[0]=1;
rep(i,1,N) fac[i]=mul(fac[i-1],i);
invfac[N]=getinv(fac[N]);
per(i,N-1,1) invfac[i]=mul(invfac[i+1],i+1);
}
#undef N
}
using namespace My_Math;
int n,a[N];
ll sum[N];
ll calc(int l,int r) {return sum[r]-sum[l-1];}
int main()
{
n=read();
rep(i,1,n) a[i]=read();
rep(i,1,n) sum[i]=sum[i-1]+a[i];
int l=1,r=3;
ll ans=1e18;
rep(i,2,n-2)
{
while ((l+2<=i) && (abs(calc(1,l)-calc(l+1,i))>abs(calc(1,l+1)-calc(l+2,i)))) l++;
while ((r+2<=n) && (abs(calc(i+1,r)-calc(r+1,n))>abs(calc(i+1,r+1)-calc(r+2,n)))) r++;
ll mx=0,mn=1e18,x;
x=calc(1,l);mx=max(mx,x);mn=min(mn,x);
x=calc(l+1,i);mx=max(mx,x);mn=min(mn,x);
x=calc(i+1,r);mx=max(mx,x);mn=min(mn,x);
x=calc(r+1,n);mx=max(mx,x);mn=min(mn,x);
ans=min(ans,mx-mn);
}
printf("%lld\n",ans);
return 0;
}
| 1 |
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<vector>
#include<utility>
#include<queue>
#include<deque>
#include<stack>
#include<set>
#include<map>
#include<bitset>
#include<string>
#define rep(i,n,m) for(int i=(n);i<(int)(m);i++)
#define reps(i,n,m) for(int i=(n);i<=(int)(m);i++)
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
#define lb lower_bound
#define ub upper_bound
#define LB(a,x) lb(all(a), x) - a.begin()
#define UB(a,x) ub(all(a), x) - a.begin()
#define printfdouble(x) printf("%.12f\n",(x))
#define chartoint(c) (int)((c) - '0')
#define chartoll(c) (long long)((c) - '0')
#define MOD 1000000007
#define itn int
#define enld endl
#define ednl endl
#define icn cin
#define stirng string
using namespace std;
typedef long long ll;
const double pi = 3.141592653589793;
using Graph = vector<vector<int>>;
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<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
std::fill( (T*)array, (T*)(array+N), val );
}
int main(){
cin.tie(0);ios::sync_with_stdio(false);
int N; cin >> N;
pair<int,int> red[105];
pair<int,int> blue[105];
rep(i,0,N){
int a,b; cin >> a >> b;
red[i] = {a,b};
}
rep(i,0,N){
int c,d; cin >> c >> d;
blue[i] = {c,d};
}
sort(red,red+N);
sort(blue,blue+N);
int ptr = 0;
int ans = 0;
bool used[105];
Fill(used,false);
rep(i,0,N){
int cnt = -1;
int maxy = -1;
rep(j,0,N){
if(blue[i].first > red[j].first && blue[i].second > red[j].second && used[j] == false){
if(maxy < red[j].second){
maxy = red[j].second;
cnt = j;
}
}
}
if(cnt != -1){
used[cnt] = true;
ans++;
}
}
cout << ans << endl;
return 0;
}
|
//
// Created by tac on 2016/10/16.
//
#include <algorithm>
#include <cstdlib>
#include <string>
#include <iostream>
namespace {
void print(const std::string &str,
std::string::size_type a,
std::string::size_type b) {
std::cout << str.substr(a, b - a + 1) << std::endl;
return;
}
const std::string reverse(const std::string &str,
std::string::size_type a,
std::string::size_type b) {
std::string ret = str;
std::reverse(ret.begin() + a, ret.begin() + b + 1);
return ret;
}
const std::string replace(const std::string &str,
std::string::size_type a,
std::string::size_type b,
const std::string &rep) {
std::string ret = str;
ret.replace(ret.begin() + a, ret.begin() + (b + 1), rep);
return ret;
}
}
int main() {
std::string str;
int n;
std::string op, rep;
int a, b;
std::cin >> str;
std::cin >> n;
for (int i = 0; i < n; ++i) {
std::cin >> op;
std::cin >> a >> b;
if (op == "print") {
print(str, a, b);
} else if (op == "reverse") {
str = reverse(str, a, b);
} else if (op == "replace") {
std::cin >> rep;
str = replace(str, a, b, rep);
} else {
throw std::runtime_error("");
}
}
return EXIT_SUCCESS;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ALL(A) A.begin(),A.end()
#define RALL(A) A.rbegin(),A.rend()
typedef long long ll;
typedef pair<ll,ll> P;
const ll mod=1000000007;
const ll LINF=1LL<<60;
const int INF=1<<30;
int main(){
int a,b;cin>>a>>b;
vector<vector<char>> v(100,vector<char>(100,'#'));
for(int i = 50; i < 100; i++) {
for(int j = 0; j < 100; j++) {
v[i][j] = '.';
}
}
int h = 0,w = 0;
a--;b--;
while(a > 0){
v[h][w] = '.';
if (w + 2 < 100){
w += 2;
}
else{
w = 0;
h += 2;
}
a--;
}
h = 51,w = 0;
while(b > 0){
v[h][w] = '#';
if (w + 2 < 100){
w += 2;
}
else{
w = 0;
h += 2;
}
b--;
}
cout << 100 << " " << 100 << endl;
for(int i = 0; i < 100; i++) {
for(int j = 0; j < 100; j++) {
cout << v[i][j];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);++i)
#define rrep(i,n) for(int i=1;i<(n);++i)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define maxs(a, b) a = max(a, b)
#define mins(a, b) a = min(a, b)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll linf = (1ll << 61);
const int inf = 1001001001;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int h, w;
cin >> h >> w;
vector<vector<int>> mp(h, vector<int>(w));
rep(i, h) rep(j, w) cin >> mp[i][j];
vector<tuple<int, int, int, int>> ans;
rep(i, h) {
if (i % 2 == 0) {
for (int j = 0; j < w; ++j) {
if (mp[i][j] % 2 == 1) {
if (j + 1 < w) {
mp[i][j + 1]++;
ans.emplace_back(i + 1, j + 1, i + 1, j + 2);
}
else if (i + 1 < h) {
mp[i + 1][j]++;
ans.emplace_back(i + 1, j + 1, i + 2, j + 1);
}
}
}
}
else {
for (int j = w - 1; j >= 0; --j) {
if (mp[i][j] % 2 == 1) {
if (j - 1 >= 0) {
mp[i][j - 1]++;
ans.emplace_back(i + 1, j + 1, i + 1, j);
}
else if (i + 1 < h) {
mp[i + 1][j]++;
ans.emplace_back(i + 1, j + 1, i + 2, j + 1);
}
}
}
}
}
int sz = ans.size();
cout << sz << endl;
for (auto c : ans) printf("%d %d %d %d\n", get<0>(c), get<1>(c), get<2>(c), get<3>(c));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using PLL = pair<ll, ll>;
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repn(i,n) for(int i = 0; i <= (int)(n); i++)
#define srep(i,l,n) for(int i = l; i < (int)(n); i++)
#define srepn(i,l,n) for(int i = l; i <= (int)(n); i++)
#define drep(i,n) for(int i = (int)(n-1); i >= 0; i--)
#define drepn(i,n) for(int i = (int)(n); i >= 0; i--)
#define size(s) (int)s.size()
#define debug(var) do{std::cout << #var << " : ";view(var);}while(0)
template<typename T> void view(T e){std::cout << e << std::endl;}
template<typename T> void view(const std::vector<T>& v){for(const auto& e : v){ std::cout << e << " "; } std::cout << std::endl;}
template<typename T> void view(const std::vector<std::vector<T> >& vv){ for(const auto& v : vv){ view(v); } }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template<class T = int> using V = vector<T>;
template<class T = int> using VV = vector<V<T>>;
bool isIn(int i, int j, int h, int w) {return i >= 0 && i < h && j >= 0 && j < w;}
void Yes(){cout << "Yes" << endl;}
void No(){cout << "No" << endl;}
void YES(){cout << "YES" << endl;}
void NO(){cout << "NO" << endl;}
void err() {cout << -1 << endl;}
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define pb push_back
#define ep emplace_back
const int MOD = 1000000007;
const int INF = 1e9;
#define PI acos(-1);
int dx[4] = {1,-1,0,0};
int dy[4] = {0,0,1,-1};
int ddx[8] = {1,1,1,-1,-1,-1,0,0};
int ddy[8] = {0,1,-1,0,1,-1,1,-1};
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int d, g;
cin >> d >> g;
V<> p(d), c(d);
rep(i, d) cin >> p[i] >> c[i];
int ans = INF;
rep(bit, 1 << d) {
int score = 0;
int num = 0;
rep(i, d) if(1 & bit >> i) score += c[i] + (i+1) * 100 * p[i], num += p[i];
int rest = g - score;
if(rest > 0) {
drep(i, d) if(!(1 & bit >> i)) {
int now_score = (i+1) * 100;
if(now_score * (p[i] - 1) < rest) rest -= now_score*(p[i]-1), num += (p[i]-1);
else {
num += (rest+now_score-100)/now_score;
score += (rest+now_score-100)/now_score * now_score;
break;
}
}
}
if(score < g) continue;
else chmin(ans, num);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define int long long
#define ull unsigned long long
#define ld long double
#define rep(a) rep1(i,a)
#define rep1(i,a) rep2(i,0,a)
#define rep2(i,b,a) for(int i=(b); i<((int)(a)); i++)
#define rep3(i,b,a) for(int i=(b); i>=((int)(a)); i--)
#define all(a) a.begin(),a.end()
#define pii pair<int,int>
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define sz(a) ((int)a.size())
#define pow2(x) (1ll<<(x))
#define ceiling(a,b) (((a)+(b)-1)/(b))
#define print0(a) cout << (a) << ' '
#define print1(a) cout << (a) << '\n'
#define print2(a,b) cout << (a) << ' ',print1(b)
#define print3(a,b,c) cout << (a) << ' ',print2(b,c)
#define print4(a,b,c,d) cout << (a) << ' ',print3(b,c,d)
#ifdef i_am_noob
#define debug(a) print2(#a,a)
#else
#define debug(a)
#endif
#define ordered_set tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update>
using namespace std;
using namespace __gnu_pbds;
const int Mod=1000000007,Mod2=998244353;
const int MOD=Mod;
inline int add(int a, int b){return (a+b>=MOD?a+b-MOD:a+b);}
inline int sub(int a, int b){return (a+MOD-b>=MOD?a-b:a+MOD-b);}
int Pow(int a, int b){
if(!b) return 1;
int tmp=Pow(a*a%MOD,b>>1);
return (b&1?tmp*a%MOD:tmp);
}
inline int inverse(int n){return Pow(n,MOD-2);}
const int maxn=100005;
//i_am_noob
int n,goal,a[10][2],cnt,x,ans=4e18;
bool flag;
signed main(){
ios_base::sync_with_stdio(0),cin.tie(0);
cin >> n >> goal;
rep(n) rep1(j,2) cin >> a[i][j];
rep(pow2(n)){
cnt=x=0;
rep1(j,n) if(i&pow2(j)){
x+=a[j][0];
cnt+=a[j][0]*(j+1)*100+a[j][1];
}
if(cnt>=goal){
ans=min(ans,x);
continue;
}
flag=false;
rep3(j,n-1,0) if((i&pow2(j))==0){
rep1(k,a[j][0]){
x++;
cnt+=(j+1)*100;
if(cnt>=goal){
ans=min(ans,x);
flag=true;
break;
}
}
if(flag) break;
}
}
print1(ans);
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main(){
int a,b,c;
while(cin>>a>>b>>c){
if(a==0&&b==0&&c==0) break;
int ans[a+b+c+1];
for(int i=1;i<=a+b+c;i++) ans[i] = 2;
int n;
cin >> n;
int ag[n],bg[n],cg[n],r[n];
for(int i=0;i<n;i++){
cin >> ag[i] >> bg[i] >> cg[i] >> r[i];
if(r[i]==1) ans[ag[i]] = ans[bg[i]] = ans[cg[i]] = 1;
}
for(int i=0;i<n;i++){
if(r[i]==0){
if(ans[ag[i]]==2&&ans[bg[i]]==1&&ans[cg[i]]==1) ans[ag[i]] = 0;
if(ans[ag[i]]==1&&ans[bg[i]]==2&&ans[cg[i]]==1) ans[bg[i]] = 0;
if(ans[ag[i]]==1&&ans[bg[i]]==1&&ans[cg[i]]==2) ans[cg[i]] = 0;
}
}
for(int i=1;i<=a+b+c;i++) cout << ans[i] << endl;
}
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<map>
#include<vector>
#include<queue>
using namespace std;
#define MP make_pair
#define PB push_back
int main(int argc,char* argv[]){
multimap<int,vector<int> > tab;
vector<int> vec;
int a,b,c,x,i,j,count,n;
int flag[400];
while(cin>>a>>b>>c){
if(a==0 && b==0 && c==0) break;
for(i=0;i<400;i++) flag[i]=2;
tab.clear();
cin>>n;
for(i=0;i<n;i++){
vec.clear();
for(j=0;j<3;j++){
cin>>x;
vec.PB(x);
}
cin>>x;
if(x==1) tab.insert(MP(0,vec));
else tab.insert(MP(1,vec));
}
multimap<int,vector<int> >::iterator itr;
for(itr=tab.begin();itr!=tab.end();itr++){
if((*itr).first==0){
vector<int>::iterator it;
for(it=(*itr).second.begin();it!=(*itr).second.end();it++){
flag[(*it)]=1;
}
}
else{
vec.clear();
count=0;
vector<int>::iterator it;
for(it=(*itr).second.begin();it!=(*itr).second.end();it++){
if(flag[(*it)]==1) count++;
else{
vec.PB((*it));
}
}
if(count==2){
flag[vec.back()]=0;
}
}
}
for(i=1;i<=a+b+c;i++){
cout<<flag[i]<<endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
template<class T>
inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
}
template<class T>
inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
}
const ll INF = 1e18;
const ll MOD = 998244353;
const ll MX = 1000001;
string N;
void solve() {
cin >> N;
int a[N.size()], inv[N.size()];
ll ans = 0;
for (int i = 0; i < (int)N.size(); i++) {
a[i] = (int)(N[i] - '0');
inv[i] = -1;
// ans += dp[i];
}
// Figure out what segments are better to inverse
for (int i = N.size() - 1; i >= 0; --i) {
if (a[i] > 5) {
inv[i] = i;
if (i + 1 < (int)N.size() && inv[i + 1] != -1) inv[i] = inv[i + 1];
} else if (a[i] == 5) {
if (i + 1 < (int)N.size() && inv[i + 1] != -1) inv[i] = inv[i + 1];
else if (i > 0 && a[i - 1] >= 5) inv[i] = i;
} else if (a[i] == 4) {
if (i > 0 && i < (int)N.size() - 1) {
if (a[i - 1] >= 5 && inv[i + 1] != -1) {
inv[i] = inv[i + 1];
}
}
}
}
int end = -1;
for (int i = 0; i < (int)N.size(); i++) {
if (end == -1) {
if (inv[i] == -1) ans += a[i];
else {
ans += 2;
end = inv[i];
ans += 9 - a[i];
}
} else {
ans += 9 - a[i];
}
if (i == end) end = -1;
}
cout << ans;
}
int main() {
cin.sync_with_stdio(0); cin.tie(0);
ll T = 1; // cin >> T;
while (T--) solve();
return 0;
// You should actually read the stuff at the bottom
}
/* Stuff to Look For
* -----------------
* Int overflow, array bounds
* Initializing all variables, avoid weird behavior
* Edge cases(n = 0, n = 1)
* Just return 0 after result
*/
|
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#define pi 3.141592653589793238
#define int long long
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
int dp[1000005][2];
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
#ifndef ONLINE_JUDGE
if(fopen("INPUT.txt","r"))
{
freopen ("INPUT.txt" , "r" , stdin);
freopen ("OUTPUT.txt" , "w" , stdout);
}
#endif
string a;
cin>>a;
int n=a.length();
reverse(a.begin(),a.end());
a="#"+a;
int ans=0;
fill_n(&dp[0][0],1000005*2,1e17);
dp[0][0]=0;
for(int i=1;i<=n;i++)
{
int z=a[i]-'0';
dp[i][0]=min(dp[i][0],dp[i-1][0]+z);
dp[i][1]=min(dp[i][1],dp[i-1][0]+(10-z));
z++;
dp[i][0]=min(dp[i][0],dp[i-1][1]+z);
dp[i][1]=min(dp[i][1],dp[i-1][1]+(10-z));
}
int mn=min(dp[n][0],dp[n][1]+1);
cout<<mn;
}
| 1 |
#include <bits/stdc++.h>
#define mp make_pair
#define eb emplace_back
#define fi first
#define se second
using namespace std;
using cd = complex <double>;
typedef pair <int, int> pii;
const int N = 3e3 + 5;
const long long INF = 1e18;
const int mod = 1e9 + 7;//786433;//998244353;
const double Pi = acos(-1);
const int p = 510200;
void Fastio()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
int n, m;
int Fact[200005];
map <int, int> M;
int BinPow(int x, int n)
{
if(n == 0)
{
return 1;
}
int temp = BinPow(x, n >> 1);
if(n & 1)
{
return 1ll * temp * temp % mod * x % mod;
}
else
{
return 1ll * temp * temp % mod;
}
}
int C(int k, int n)
{
return 1ll * Fact[n] * BinPow(Fact[k], mod - 2) % mod * BinPow(Fact[n - k], mod - 2) % mod;
}
signed main()
{
// Fastio();
cin >> n >> m;
Fact[0] = 1;
for(int i = 1; i <= 2e5; i++)
{
Fact[i] = 1ll * Fact[i - 1] * i % mod;
}
for(int i = 2; i <= sqrt(m); i++)
{
while(m % i == 0)
{
M[i]++;
m /= i;
}
}
if(m > 1)
{
M[m]++;
}
int ans = 1;
for(auto x : M)
{
ans = 1ll * ans * C(n - 1, x.se + n - 1) % mod;
}
cout << ans;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
const double EPS = 1e-9;
const ll MOD = 1000000007;
const int inf = 1 << 30;
const ll linf = 1LL << 60;
const double PI = 3.14159265358979323846;
#define SIZE 4000001
ll kai[SIZE];
ll mokai[SIZE];
ll mod_pow (ll x, ll y) {
ll ret = 1;
while (y) {
if (y&1) ret = ret*x%MOD;
x = x*x%MOD;
y /= 2;
}
return ret;
}
void init () {
kai[0] = 1;
for (int i = 1; i < SIZE; i++) kai[i] = kai[i-1]*i%MOD;
for (int i = 0; i < SIZE; i++) mokai[i] = mod_pow(kai[i],MOD-2);
}
ll conb (ll x, ll y) {
ll z = x-y;
ll ret = kai[x]*mokai[y]%MOD;
ret = ret*mokai[z]%MOD;
return ret;
}
ll n, k;
ll dp[2001][2001];
inline ll mmul (ll x, ll y) {
return x*y%MOD;
}
int main() {
cin >> n >> k;
init();
if (k == 1) {
cout << 1 << endl;
return 0;
}
dp[0][0] = 1;
for (ll i = 1; i <= n; i++) {
dp[i][0] = mmul(dp[i-1][0], conb(i*(k-1)-1,k-2));
}
for (ll j = 1; j <= n; j++) {
for (ll i = j; i <= n; i++) {
if (i == j) {
dp[i][j] = dp[i][j-1];
} else {
dp[i][j] = (mmul(dp[i-1][j], conb(i*k-(i-j)-1, k-2)) + dp[i][j-1]) % MOD;
}
}
}
cout << (dp[n][n] * kai[n]) % MOD;
}
| 0 |
#include<bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define PI acos(-1)
#define pcnt __builtin_popcountll
#define rng(a) a.begin(), a.end()
#define sz(x) (int)(x).size()
#define v(T) vector<T>
#define vv(T) v(v(T))
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
template<typename T>inline istream& operator>>(istream&i,v(T)&v)
{rep(j,sz(v))i>>v[j];return i;}
template<typename T1,typename T2>inline istream& operator>>(istream&i,pair<T1,T2>&v)
{return i>>v.fi>>v.se;}
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; }
struct UnionFind {
vector<int> par;
vector<int> rank;
UnionFind(int n = 1) {
init(n);
}
void init(int n = 1) {
par.resize(n); rank.resize(n);
for (int i = 0; i < n; ++i) par[i] = i, rank[i] = 0;
}
int root(int x) {
if (par[x] == x) {
return x;
}
else {
int r = root(par[x]);
return par[x] = r;
}
}
bool issame(int x, int y) {
return root(x) == root(y);
}
bool merge(int x, int y) {
x = root(x); y = root(y);
if (x == y) return false;
if (rank[x] < rank[y]) swap(x, y);
if (rank[x] == rank[y]) ++rank[x];
par[y] = x;
return true;
}
};
ll INF = 1001001001;
ll LINF = 1001001001001001001ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll h, w;
cin>>h>>w;
vector<string> grid(h);
cin>>grid;
UnionFind ds(h * w);
rep(i, h) rep(j, w) {
if (i - 1 >= 0 && grid[i][j] != grid[i - 1][j]) ds.merge(i * w + j, (i - 1) * w + j);
if (i + 1 < h && grid[i][j] != grid[i + 1][j]) ds.merge(i * w + j, (i + 1) * w + j);
if (j + 1 < w && grid[i][j] != grid[i][j + 1]) ds.merge(i * w + j, i * w + j + 1);
if (j - 1 >= 0 && grid[i][j] != grid[i][j - 1]) ds.merge(i * w + j, i * w + j - 1);
}
vl bs(h * w);
vl ws(h * w);
rep(i, h) rep(j, w) {
if (grid[i][j] == '#') bs[ds.root(i * w + j)]++;
else ws[ds.root(i * w + j)]++;
}
ll ans = 0;
rep(i, h * w) {
ans += bs[i] * ws[i];
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)((x).size())
#define jonathan ios_base::sync_with_stdio(0)
#define livingston cin.tie(0)
using namespace std;
void yes() {cout << "Yes" << endl;}
void no() {cout << "No" << endl;}
int dx[] = {1, 0, -1, 0, -1, -1, 1, 1};
int dy[] = {0, 1, 0, -1, -1, 1, -1, 1};
const int INF = 1e9 + 9;
const long long LINF = 1e18 + 8;
const double EPS = 1e-9;
const long long MOD = 1e9 + 7; //998244353
const double PI = acos(-1);
vector<int> g[100010];
bool used[100010];
void dfs(int v) {
used[v] = true;
for (auto to : g[v]) {
if (!used[to]) {
dfs(to);
}
}
}
void solve() {
int n, k; cin >> n >> k;
k = min(n, k);
vector<int> a(n + 1);
vector<int> d(n + 1, INF);
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int res = (a[1] != 1);
a[1] = 1;
for (int i = 1; i <= n; i++) {
g[a[i]].push_back(i);
}
queue<int> q;
q.push(1);
d[1] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < sz(g[v]); i++) {
int to = g[v][i];
if (d[to] > d[v] + 1) {
d[to] = d[v] + 1;
q.push(to);
}
}
}
vector<int> s(n);
for (int i = 0; i < n; i++) {
s[i] = i + 1;
}
sort(all(s), [&](int x, int y) {
return d[x] > d[y];
});
for (int i = 0; i < n; i++) {
int v = s[i];
if (used[v]) continue;
for (int j = 0; j < k - 1; j++) {
v = a[v];
}
dfs(v);
if (a[v] != 1) {
res++;
}
}
cout << res << endl;
}
int main() {
jonathan;
livingston;
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
int N,X;
cin >> N >> X;
vector<long long> A(N);
for(int i = 0; i < N;i++)cin >> A[i];
long long ans = 0;
long long b = 0;
for(int i =1; i < N;i++){
b = max(0LL,A[i-1]+A[i]-X);
ans += b;
A[i]= max(0LL,A[i]-b);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll INF=(ll)1e9;
const ll MOD=(ll)1e9+7;
vector<int> dx={1,0,-1,0},dy={0,1,0,-1};
int main(){
ll N,A,B,ans=0;
cin>>N>>A>>B;
ll x[N];
for(ll i=0;i<N;i++) cin>>x[i];
for(ll i=0;i<N-1;i++){
if((x[i+1]-x[i])*A>B) ans+=B;
else ans+=(x[i+1]-x[i])*A;
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
#define INF 1e9
#define endl '\n'
#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 FORE(i, a, b) for (int i = (a), e = (b); i < e; ++i)
#define RFORE(i, a, b) for (int i = (b)-1, e = (a); i >= e; --i)
#define ALL(x) (x).begin(), (x).end()
#define SORT(c) sort((c).begin(), (c).end())
#define SORTR(c) sort((c).begin(), (c).end(), greater<int>())
using namespace std;
long long digits(long long num) {
long long digit = num;
int d_sum = 0;
while (digit > 0) {
++d_sum;
digit /= 10;
}
return d_sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long N;
cin >> N;
long long ans = INF;
for (long long A = 1; A < sqrt(N) + 1; ++A) {
if (N % A == 0) { ans = min(ans, max(digits(A), digits(N / A))); }
}
cout << ans << endl;
}
|
#include<stdio.h>
#define INF (1<<30)-1
int main(){
int n;
scanf("%d",&n);
int s[n];
int i,j,c=INF;
for(i=0;i<n;i++){
scanf("%d",&s[i]);
if(s[i]<c) c = s[i];
}
for(i=1;i<=c;i++){
int ok = 0;
for(j=0;j<n;j++) if(s[j]%i!=0) ok = 1;
if(ok == 0) printf("%d\n",i);
}
}
| 0 |
#include <iostream>
using namespace std;
static int num =0;
void swap(int &a,int &b){
int tmp;
tmp =a;
a = b;
b = tmp;
num++;
}
void bubbleSort(int a[],int n){
int flag = 1;
while(flag){
flag =0;
for(int i=n-1;i>0;i--){
if(a[i]<a[i-1]){
swap(a[i],a[i-1]);
flag =1;
}
}
}
}
int main(){
int n; cin >>n;
int a[n];
for(int i=0;i<n;i++){
cin >> a[i];
}
bubbleSort(a,n);
for(int i=0;i<n-1;i++){
cout << a[i] << " ";
}
cout << a[n-1] << endl;
cout << num << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
int elem[n];
int cnt=0;
for(int i=0;i<n;i++){
cin>>elem[i];
}
for(int i=0;i<n-1;++i){
for(int j=0;j<n-1-i;++j){
if(elem[j]>elem[j+1]){
++cnt;
elem[j]^=elem[j+1];
elem[j+1]^=elem[j];
elem[j]^=elem[j+1];
}
}
}
for(int i=0;i<n;++i){
cout<<elem[i];
if(i!=n-1)cout<<" ";
else cout<<endl;
}
cout<<cnt<<endl;
}
| 1 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <functional>
#include <ctime>
#include <cmath>
#include <limits>
#include <numeric>
#include <type_traits>
#include <iomanip>
#include <float.h>
#include <math.h>
using namespace std;
using ll = long long;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b) return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
class UnionFind {
public:
vector <ll> par;
vector <ll> siz;
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
ll root(ll x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) {
return root(x) == root(y);
}
ll size(ll x) {
return siz[root(x)];
}
};
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
long long modinv(long long a, long long mod) {
return modpow(a, mod - 2, mod);
}
int main() {
ll n;
cin >> n;
string s;
cin >> s;
int q;
cin >> q;
vector<ll> m(n+1);
for (int j = 0; j < n; j++) {
m[j + 1] = m[j];
if (s[j] == 'M')m[j + 1]++;
}
vector<ll> c(n + 1);
for (int j = 0; j < n; j++) {
c[j + 1] = c[j];
if (s[j] == 'C')c[j + 1]++;
}
vector<ll> crui(n + 1);
for (int j = 0; j < n; j++) {
crui[j + 1] = crui[j];
if (s[j] == 'C')crui[j + 1] += m[j];
}
for (int i = 0; i < q; i++) {
ll v;
cin >> v;
ll ans = 0;
for (int j = 0; j < n; j++) {
if (s[j] == 'D')ans += crui[min(n, j + v)]-crui[j]-m[j]*(c[min(n, j + v)]-c[j]);
}
cout << ans << endl;
}
}
|
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<cmath>
using namespace std;
#define REP(i, limit) for(int i=0; i< limit; ++i)
#define FOR(i, j, limit) for(int i=j; i< limit; ++i)
#define DUMP(a) REP(d,a.size()){cout<<a[d];if(d!=a.size()-1)cout<<" ";else cout<<endl;}
#define ECHO(x) cout<<x<<endl;
#define MEMSET(a, n, x) REP(i, n) a[i]=x;
#define ARRIN(a, n) REP(i, n) cin>>a[i];
#define LL long long
int INF = 2147483647;
LL LINF = 9223372036854775807;
LL MOD = 1000000007;
typedef pair<int, int>P;
typedef pair<LL, LL>PL;
typedef vector<int> vi;
typedef vector<LL> vl;
class unionfind{
public:
int Num;
vector<int> par; //親の番号
vector<int> height; //木の高さ(ランク)
unionfind(int N):
par(vector<int>(N, 0)), height(vector<int>(N, 0)), Num(N) {}
//初期化
void init(){
REP(i, Num){
par[i] = i;
height[i] = 0;
}
}
//xの親番号を返す、再帰処理あり
int root(int x){
return par[x] == x ? x : par[x] = root(par[x]);
}
//xとyの親番号が同一か判定する
bool same(int x, int y){
return root(x) == root(y);
}
//xとyのある木を結合する
void unite(int x, int y){
x = root(x);
y = root(y);
if(x == y) return; //親が同一なら結合済み。
if(height[x] < height[y]) par[x] = y;
else {
par[y] = x;
if(height[x] == height[y]) height[x]++;
}
}
};
int main(){
int n, k, l;
cin>>n>>k>>l;
unionfind ro(n);
unionfind ra(n);
map<P, LL> mp;
ro.init();
ra.init();
LL ans, r;
int t1, t2;
REP(i, k){
cin>>t1>>t2;
--t1;
--t2;
ro.unite(t1, t2);
}
REP(i, l){
cin>>t1>>t2;
--t1;
--t2;
ra.unite(t1, t2);
}
REP(i, n){
++mp[make_pair(ro.root(i), ra.root(i))];
}
REP(i, n){
r=mp[make_pair(ro.root(i), ra.root(i))];
ECHO(r);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
const int INF=1001001001;
int main() {
string s;
cin>>s;
int n=s.size();
int stack=0,e=0;
for(int i=0;i<n;i++){
if(s[i]=='S'){stack++;}
else if(stack>0){stack--;e++;}
}
cout<<n-2*e<<endl;
return 0;
}
|
#define _USE_MATH_DEFINES
#include <iostream>
#include <string>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <math.h>
#include <map>
#include <list>
#include <iomanip>
#include <queue>
#include <cmath>
#include <numeric>
#define repl(i, l, r) for (ll i = l; i < r; i++)
#define rep(i, n) repl(i, 0, n)
using namespace std;
using ll = long long;
typedef pair<ll, ll> P;
template<class T>bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
const long long mod = 1e9 + 7;
ll gcd(ll a, ll b);
ll lcm(ll a, ll b);
ll dx[] = { 1, 0 , -1, 0 }, dy[] = { 0, 1, 0, -1 };
ll cb(ll a, ll b);
int main() {
string x;
cin >> x;
stack<char> s;
ll n = x.size();
rep(i, n) {
if (s.size() == 0 || x[i] == 'S') s.push(x[i]);
else if (s.top() == 'S' && x[i] == 'T') s.pop();
else if (s.top() != 'S' && x[i] == 'T') s.push(x[i]);
}
cout << s.size();
return 0;
}
ll cb(ll a, ll b) {
ll ans = 1;
rep(i, b) ans *= (a - i);
rep(i, b) ans /= (b - i);
return ans;
}
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);
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int n;
class Dice{
private:
int right,left,front,back,bottom,now,flag=1;
int role(int num[6],int num2[6],string str){
for(int i=0;i<str.size();i++){
if(num[0]==num2[0]&&num[1]==num2[1]&&num[2]==num2[2]&&num[3]==num2[3]&&num[4]==num2[4]&&num[5]==num2[5]){
cout<<"No"<<endl;
flag=0;
return 0;
}
switch(str[i]){
case 'S':num[1]=now;num[0]=back;num[4]=bottom;num[5]=front;now=num[0];back=num[4];bottom=num[5];front=num[1];break;
case 'W':num[3]=front;num[1]=right;num[2]=back;num[4]=left;front=num[1];left=num[3];back=num[4];right=num[2];break;
case 'E':num[3]=bottom;num[0]=left;num[2]=now;num[5]=right;now=num[0];left=num[3];bottom=num[5];right=num[2];break;
case 'N':num[4]=now;num[0]=front;num[1]=bottom;num[5]=back;now=num[0];back=num[4];bottom=num[5];front=num[1];break;
}
if(num[0]==num2[0]&&num[1]==num2[1]&&num[2]==num2[2]&&num[3]==num2[3]&&num[4]==num2[4]&&num[5]==num2[5]){
cout<<"No"<<endl;
flag=0;
return 0;
}
}
}
public:
void Scan(int num[100][6]){
for(int i=0;i<n-1;i++){
now=num[i][0];right=num[i][2];left=num[i][3];front=num[i][1];back=num[i][4];bottom=num[i][5];
for(int j=i+1;j<n;j++){
role(num[i],num[j],"WWWNWWWWNWWWWNWWWNWWWWNNWWWNWWW");
if(flag==0)
return;
}
}
if(flag==1)
cout<<"Yes"<<endl;
}
};
int main(){
Dice dice;
int a,b;
cin>>n;
int num[100][6];
for(int i=0;i<n;i++)
for(int j=0;j<6;j++)
cin>>num[i][j];
dice.Scan(num);
return 0;
}
|
// lcmとか__builtin_popcountとかはg++ -std=c++17 default.cppみたいなかんじで
#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 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,c,d,e,n,k,maxi=0,f=0,mini=INF,sum=0,q;
string str,stra,straa;
ll x,y,z;
char ca,cb,cc;
cin>>n;
vector<ll> v(n);
set<ll> s;
rep(i,n) cin>>v[i];
rep(i,n) s.insert(v[i]);
if(v.size()==s.size()) YES;
else NO;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int INF=1001001001;
const int mod = 1000000007;
int main() {
int H,W;
cin>>H>>W;
vector<string>s(H);
for(int i=0;i<H;i++){
cin>>s[i];
}
vector<vector<int>>dist(H,vector<int>(W,-1));
queue<pair<int,int>>q;
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
if(s[i][j]=='#'){q.push(make_pair(i,j));dist[i][j]=0;}
}
}
vector<int>dx={0,0,-1,1};
vector<int>dy={1,-1,0,0};
while(!q.empty()){
auto p=q.front();q.pop();
int x=p.second,y=p.first;
for(int k=0;k<4;k++){
int ny=y+dy[k],nx=x+dx[k];
if(ny<0||ny>=H||nx<0||nx>=W){continue;}
if(dist[ny][nx]!=-1){continue;}
dist[ny][nx]=dist[y][x]+1;
q.push(make_pair(ny,nx));
}
}
int MAX=0;
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
chmax(MAX,dist[i][j]);
}
}
cout<<MAX<<endl;
return 0;
}
|
#include <bits/stdc++.h>
#define int long long
#define double long double
using namespace std;
const int MOD = 1000000007;
const int INF = 1e15;
using Graph = vector<vector<int>>;
signed main() {
int N, K;
cin >> N >> K;
vector<int> V(N);
for( int i = 0; i < N; i++ ) cin >> V.at(i);
int ans = 0;
for( int l = 0; l <= min(N, K); l++){
for( int r = 0; l+r <= min(N, K); r++ ){
priority_queue<int, vector<int>, greater<int>> pq;
int total = 0;
for( int i = 1; i <= l; i++ ){ //左の宝石を詰める
pq.push(V.at(i-1));
total += V.at(i-1);
}
for( int i = 1; i <= r; i++ ){ //右の宝石を詰める
pq.push(V.at(N-i));
total += V.at(N-i);
}
for( int i = 0; i < max(0LL, K-(l+r)); i++ ){
if( pq.empty() ) break;
if( pq.top() < 0 ){
total -= pq.top();
pq.pop();
}
}
ans = max(ans, total);
}
}
cout << ans << endl;
}
| 0 |
#include<bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
int main(){
int H,W,i,j,a;scanf("%d%d",&H,&W);
bool odd[H][W];
for(i=0;i<H;i++){
for(j=0;j<W;j++){
scanf("%d",&a);
odd[i][j] = a&1;
}
}
bool coin = false;vector<pair<pair<int,int>,pair<int,int>>> v;
i = 0;j = 0;int ni,nj;
while(true){
if((!(i&1)) && j+1 == W){
ni = i+1;nj = j;
}
else if(i&1 && j == 0){
ni = i+1;nj = j;
}
else if(!(i&1)){
ni = i;nj = j+1;
}
else{
ni = i;nj = j-1;
}
if(ni == H) break;
if(odd[i][j]){
if(coin == false){
coin = true;
v.push_back(make_pair(make_pair(i,j),make_pair(ni,nj)));
}
else{
coin = false;
}
}
else{
if(coin == true){
v.push_back(make_pair(make_pair(i,j),make_pair(ni,nj)));
}
}
i = ni;j = nj;
}
printf("%d\n",v.size());
for(i=0;i<v.size();i++) printf("%d %d %d %d\n",v[i].first.first+1,v[i].first.second+1,v[i].second.first+1,v[i].second.second+1);
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
typedef long long ll;
struct memo {
int x;
int y;
int xx;
int yy;
};
int main() {
int H, W; cin >> H >> W;
vector<vector<int>> a(H, vector<int>(W));
rep(i, H)rep(j, W) cin >> a[i][j];
vector<memo> vec;
rep(i, H)rep(j, W) {
if (a[i][j]%2) {
memo tmp;
tmp.x = j+1;
tmp.y = i+1;
if (j < W-1) {
tmp.xx = j+2;
tmp.yy = i+1;
a[i][j+1]++;
vec.push_back(tmp);
}
else if (i < H-1){
tmp.xx = j+1;
tmp.yy = i+2;
a[i+1][j]++;
vec.push_back(tmp);
}
}
}
cout << vec.size() << endl;
rep(i, vec.size()) {
cout << vec[i].y << " " << vec[i].x << " " << vec[i].yy << " " << vec[i].xx << endl;
}
}
| 1 |
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
#include "ctime"
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
#define rep(begin, i, end) for (int i = begin; i < (int)(end); i++)
#define all(v) v.begin(), v.end()
const int MOD = 1000000007;
int main()
{
ll N, x;
cin >> N >> x;
vector<ll> a(N);
rep(0, i, N)
{
cin >> a.at(i);
}
sort(all(a));
ll ans = 0;
rep(0, i, N)
{
x -= a.at(i);
if (x < 0)
{
break;
}
ans++;
}
if (x > 0)
{
ans--;
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
#define For(i,x,y) for (register int i=(x);i<=(y);i++)
#define FOR(i,x,y) for (register int i=(x);i<(y);i++)
#define Dow(i,x,y) for (register int i=(x);i>=(y);i--)
#define Debug(v) for (auto i:v) printf("%lld ",i);puts("")
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define ep emplace_back
#define siz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define fil(a,b) memset((a),(b),sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pa;
typedef pair<ll,ll> PA;
typedef vector<int> poly;
inline ll read(){
ll x=0,f=1;char c=getchar();
while ((c<'0'||c>'9')&&(c!='-')) c=getchar();
if (c=='-') f=-1,c=getchar();
while (c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
return x*f;
}
int main(){
int x=read(),y=read(),ans=0;
if (x==1) ans+=300000;
if (y==1) ans+=300000;
if (x==2) ans+=200000;
if (y==2) ans+=200000;
if (x==3) ans+=100000;
if (y==3) ans+=100000;
if (x==1&&y==1) ans+=400000;
printf("%d\n",ans);
}
| 0 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
bool check(ll x, ll pos) { return (x & (1LL << pos)); }
vector <ll> v;
ll gelim(ll X)
{
ll ind = 0;
for(ll i = 60; i >= 0; i--)
{
if((X >> i & 1) == 0)
{
ll x = ind;
while(x < v.size() && !check(v[x], i)) x++;
if(x == v.size()) continue;
swap(v[ind], v[x]);
for(ll j = 0; j < v.size(); j++)
{
if(j != ind && check(v[j], i)) v[j] ^= v[ind];
}
ind++;
}
}
ll ans = 0;
for(ll i = 0; i < v.size(); i++) ans ^= v[i];
return ans;
}
int main()
{
ios_base :: sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n,x;
cin >> n;
ll all = 0;
for(ll i = 0; i < n; i++)
{
cin >> x;
all ^= x;
v.push_back(x);
}
sort(v.rbegin(), v.rend());
ll ans = gelim(all);
cout << ans + (ans ^ all);
}
|
#include <iostream>
#include <vector>
#include <set>
using namespace std;
// http://www.prefield.com/algorithm/misc/dice.html
enum FACE { TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT };
class dice {
public:
dice(int top,int front,int right,int left,int back,int bottom) {
id[TOP] = top; id[FRONT] = front; id[RIGHT] = right;
id[LEFT] = left; id[BACK] = back; id[BOTTOM] = bottom;
}
int& operator[] (FACE f) { return id[f]; }
const int& operator[] (FACE f) const { return id[f]; }
bool operator==(const dice &b) const {
const dice &a = *this;
return a[TOP] == b[TOP] && a[BOTTOM] == b[BOTTOM] &&
a[FRONT] == b[FRONT] && a[BACK] == b[BACK] &&
a[LEFT] == b[LEFT] && a[RIGHT] == b[RIGHT];
}
void roll_north() { roll(TOP, FRONT, BOTTOM, BACK); }
void roll_south() { roll(TOP, BACK, BOTTOM, FRONT); }
void roll_east() { roll(TOP, LEFT, BOTTOM, RIGHT); }
void roll_west() { roll(TOP, RIGHT, BOTTOM, LEFT); }
void roll_right() { roll(FRONT, LEFT, BACK, RIGHT); }
void roll_left() { roll(FRONT, RIGHT, BACK, LEFT); }
void all_rolls(set<long long> &s){
for (int k = 0; k < 6; (k&1?roll_east():roll_north()),++k)
for (int i = 0; i < 4; roll_right(), ++i)
s.insert(((long long)id[TOP]<<40) | ((long long)id[FRONT]<<32) | (id[RIGHT]<<24) | (id[LEFT]<<16) | (id[BACK]<<8) | (id[BOTTOM]<<0));
}
private:
void roll(FACE a, FACE b, FACE c, FACE d){
int tmp = id[a];
id[a] = id[b]; id[b] = id[c];
id[c] = id[d]; id[d] = tmp;
}
int id[6];
};
int main(){
int n,d[6];
cin>>n;
int i,j;
set<long long>s;
for(i=0;i<n;i++){
for(j=0;j<6;j++)cin>>d[j];
long long x=((long long)d[0]<<40) | ((long long)d[1]<<32) | (d[2]<<24) | (d[3]<<16) | (d[4]<<8) | (d[5]<<0);
if(s.find(x)!=s.end()){
cout<<"No"<<endl;
return 0;
}else{
dice di(d[0],d[1],d[2],d[3],d[4],d[5]);
di.all_rolls(s);
}
}
cout<<"Yes"<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n = -1;
for(int i = 0;i < s.size();i++){
if(s.at(i)=='A'){
n = i;
break;
}
}
int m = -1;
for(int j = 0;j < s.size();j++){
if(s.at(j)=='C'){
m = j;
if(n+1==m){
break;
}
}
}
if(n >= 0 && m >= 0 && n+1==m){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define contains(v, t) (find(v.begin(), v.end(), t) != v.end())
#define MOD 1000000007
typedef long long ll;
typedef unsigned long long ull;
int main() {
string s;
cin >> s;
int pos = s.find("AC");
if (pos != string::npos) {
cout << "Yes";
} else {
cout << "No";
}
}
| 1 |
#include<bits/stdc++.h>
#define del(a,i) memset(a,i,sizeof(a))
#define ll long long
#define inl inline
#define il inl void
#define it inl int
#define ill inl ll
#define re register
#define ri re int
#define rl re ll
#define mid ((l+r)>>1)
#define lowbit(x) (x&(-x))
#define INF 0x3f3f3f3f
using namespace std;
template<class T>il read(T &x){
int f=1;char k=getchar();x=0;
for(;k>'9'||k<'0';k=getchar()) if(k=='-') f=-1;
for(;k>='0'&&k<='9';k=getchar()) x=(x<<3)+(x<<1)+k-'0';
x*=f;
}
template<class T>il _print(T x){
if(x/10) _print(x/10);
putchar(x%10+'0');
}
template<class T>il print(T x){
if(x<0) putchar('-'),x=-x;
_print(x);
}
ll mul(ll a,ll b,ll mod){long double c=1.;return (a*b-(ll)(c*a*b/mod)*mod)%mod;}
it qpow(int x,int m,int mod){
int res=1,bas=x;
while(m){
if(m&1) res=(1ll*res*bas)%mod;
bas=(1ll*bas*bas)%mod,m>>=1;
}
return res;
}
const int MAXN = 2e3+5,mod = 998244353;
int n,k,C[MAXN<<1][MAXN<<1],bit[MAXN<<1];
it add(int x,int y){return x+y>=mod?x+y-mod:x+y;}
it mul(int x,int y){return 1ll*x*y%mod;}
il inc(int &x,int y){x=add(x,y);}
il Init(){
C[0][0]=1,bit[0]=1;
for(ri i=1;i<=4000;++i){
C[i][0]=1;
for(ri j=1;j<=i;++j) C[i][j]=add(C[i-1][j],C[i-1][j-1]);
bit[i]=mul(bit[i-1],2);
}
}
it Solve(int x,int y,int z){
int res=0;
for(ri i=0;i<=z&&i<=x;++i)
if(y+i-1>=0) inc(res,mul(mul(C[x][i],C[y+z-1][i+y-1]),bit[i]));
return res;
}
int main(){
// freopen(".in","r",stdin);
// freopen(".out","w",stdout);
read(k),read(n),Init();
for(ri i=2;i<=2*k;++i){
int cnt=0;
for(ri j=1;j<=k;++j) cnt+=(i-j>=1&&i-j<=k);
if(i&1) print(Solve(cnt>>1,k-cnt,n)),puts("");
else print(add(Solve(cnt>>1,k-cnt,n-1),Solve(cnt>>1,k-cnt,n))),puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,N) for (int i = 0; i < (N); ++i)
#define all(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int inf{int(1e9)};
int main(void){
ll L, R;
cin >> L >> R;
/*
ll sa = R - L;
L %= 2019;
R %= 2019;
if (L == 0 || L == 2018) cout << 0 << endl;
else if (sa < 2019 - L) cout << (L * (L + 1)) % 2019 << endl;
else cout << 0 << endl;
*/
int ans = 2018;
R = min(R, L + 4038);
for (ll i = L; i <= R; i++){
for (ll j = i + 1; j <= R; j++){
int x = i*j%2019;
ans = min(ans, x);
}
}
cout << ans << endl;
return 0;
}
| 0 |
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma warning(disable : 4996)
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<math.h>
#include<iomanip>
#include<set>
#include<numeric>
#include<cstring>
#include<cstdio>
#include<functional>
#include<bitset>
#include<limits.h>
#include<cassert>
#include<iterator>
#include<complex>
#include<stack>
#include<unordered_map>
#include<unordered_set>
#include<time.h>
#include<random>
#include<array>
using namespace std;
#define REP(i, n) for(int i = 0;i < n;++i)
#define REPR(i, n) for(int i = n-1;i >= 0;--i)
#define FOR(i, m, n) for(int i = m;i < n;++i)
#define FORR(i, m, n) for(int i = m-1;i >= n;--i)
#define SORT(v, n) sort(v, v+n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v,n) reverse(v,v+n);
#define VREVERSE(v) reverse(v.begin(), v.end())
#define ll long long
#define print(x) cout<<(x)<<'\n'
#define pe(x) cout<<(x)<<" "
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define lb(v,n) lower_bound(v.begin(), v.end(), (n))
#define ub(v,n) upper_bound(v.begin(), v.end(), (n))
#define int long long
//#define double long double
#define all(x) (x).begin(), (x).end()
#define print_space(v) REP(i,v.size())cout << v[i] << ((i == v.size() - 1) ? "\n" : " ")
template<typename T1, typename T2> inline void chmin(T1 & a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> inline void chmax(T1& a, T2 b) { if (a < b) a = b; }
typedef pair<int, int>P;
typedef array<int, 3> arr3;
std::random_device rd;
std::mt19937 mt(rd());
constexpr ll MOD = 998244353; constexpr int MAX = 2000020;
const double pi = acos(-1); constexpr double EPS = 1e-8;
constexpr ll INF = 1e18;
void y(bool c) {
if (c)print("Yes");
else print("No");
}
void solve() {
int N, M, V, P; cin >> N >> M >> V >> P;
vector<int>v(N);
REP(i, N)cin >> v[i];
VSORT(v);
int ok = N-1, ng = -1;
while (abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
int val = v[mid] + M;
int rem = M * V - M;
rem -= M * mid;
rem -= M * (P - 1);
FOR(i, mid + 1, N-P+1) {
if (v[i] <= val) {
rem -= (val - v[i]);
}
}
if (rem <= 0&&val>=v[N-P])ok = mid;
else ng = mid;
}
REP(i, N) {
if (v[i] == v[ok]) {
ok = i;
break;
}
}
print(N - ok);
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
//int q; cin >> q;
//while (q--)
solve();
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long int
#define ld long double
#define pb push_back
#define pll pair<ll, ll>
#define vl vector<ll>
#define vvl vector< vector<ll> >
#define vlp vector< pair<ll, ll> >
#define vllp vector<pair<pll, ll> >
#define mll map<ll, ll>
#define rep(i,a) for(ll i=0; i< a; i++)
#define rep1(i,a) for(ll i = 1; i< a; i++)
#define foi(i, a, b) for(ll i = a; i<b ; i++)
#define fod(i, a, b) for(ll i = a; i>=b ; i--)
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fst first
#define sec second
#define ff first.first
#define fs first.second
#define max3(a, b, c) max(max(a, b), c)
#define min3(a, b, c) min(min(a, b), c)
#define MAX 1000001
#define MOD 1000000007
// #define MOD 998244353
#define endl "\n"
#define INF (ll)1e18
#define s(v) (ll)v.size()
#define e(v) v.empty()
#define bscount(x) __builtin_popcountll(x)
// #define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
using namespace std;
// using namespace __gnu_pbds;
ll gcd(ll a, ll b){if(b==0)return a;return gcd(b, a%b);}
ll fexp(ll a, ll b){ll ans = 1;while(b){if(b&1) ans = ans*a%MOD; b/=2;a=a*a%MOD;}return ans;}
ll inverse(ll a, ll p){return fexp(a, p-2);}
void ingraph(vvl& graph, ll m){ll x, y;rep(i, m){cin>>x>>y;x--, y--;graph[x].pb(y);graph[y].pb(x);}}
ll modify(ll n){ll res = n;res%=MOD;res+=MOD;res%=MOD;return res;}
int main(){
// #ifndef ONLINE_JUDGE
// freopen("../input.txt", "r", stdin);
// freopen("../output.txt", "w", stdout);
// #endif
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
ll t;
// cin>>t;
t = 1;
while(t--){
ll n, m, v, p;
cin>>n>>m>>v>>p;
vl vec(n);
rep(i, n) cin>>vec[i];
sort(all(vec));
vl pref(n);
ll cur = 0;
rep(i, n){
cur += vec[i];
pref[i] = cur;
}
ll ans = 0;
rep(i, n){
ll nv = v;
nv -= (i+1);
bool poss = false;
ll j = upper_bound(all(vec), vec[i] + m) - vec.begin();
if(n - j >= p) continue;
else{
nv -= (n - j);
if(v <= 0) {ans++;poss = true;}
else{
ll np = p - (n - j) - 1;
if(j - i - 1 <= np) ans++;
else{
nv -= np;
ll del = (j - np - 1 - i)*(vec[i] + m) - (pref[j-np-1] - pref[i]);
if(del >= nv*m) ans++;
}
}
}
}
cout<<ans;
}
}
| 1 |
#include<cstdio>
#include<vector>
#include<algorithm>
#define MAXN 200006
using namespace std;
int u,v,deep[MAXN],n,m,sum[MAXN],vis[MAXN],ok;
long long a,q,p,ans;
vector<int> road[MAXN];
void DFS(int x,int father)
{
vis[x]=1;
sum[x]=1;
deep[x]=deep[father]+1;
for(int i=0;i<(int)road[x].size();i++)
{
int nex=road[x][i];
if(nex==father) continue;
if(vis[nex])
{
if((deep[nex]+deep[x])%2==0) ok=0;
continue;
}
DFS(nex,x);
sum[x]+=sum[nex];
}
}
int main()
{
//freopen("squared.in","r",stdin);
//freopen("squared.out","w",stdout);
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
{
scanf("%d%d",&u,&v);
road[u].push_back(v);
road[v].push_back(u);
}
for(int i=1;i<=n;i++)
{
if(vis[i]) continue;
ok=1;
DFS(i,0);
if(sum[i]==1) a++;
else
{
if(ok==0) p++;
else q++;
}
}
ans=a*a+2*a*(n-a)+p*p+p*q*2+2*q*q;
printf("%lld",ans);
}
|
#include<bits/stdc++.h>
#define REP(i,n) for(int i=0;i<n;i++)
#define RREP(i,n) for(int i=n;i>=0;i--)
#define FOR(i,m,n) for(int i=m;i<n;i++)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
using namespace std;
typedef long long ll;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
//const ll INF = 1LL << 60;
//const int INF = 1001001001;
int main(void){
int n,m;
cin >> n >> m;
vector<int> ac(n),pena(n);
REP(i,m){
int x;
string y;
cin >> x >> y;
x--;
if(ac[x]) continue;
if(y=="AC"){
ac[x]=1;
}else{
pena[x]++;
}
}
int wa=0;
REP(i,n){
if(ac[i]) wa+=pena[i];
}
printf("%d %d",accumulate(ALL(ac),0),wa);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> Pii;
typedef pair<ll,ll> Pll;
#define rep(i,n) for (ll i=0;i<(n);++i)
#define rep2(i,a,b) for (ll i=(a);i<(b);++i)
#define debug(x) cout << #x << '=' << x << endl
#define all(v) (v).begin(),(v).end()
const ll MOD=1e9+7;
//const ll MOD=998244353;
const ll INF=1e9;
const ll IINF=1e18;
const double EPS=1e-8;
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<int row,int col>
struct BinaryMatrix{
bitset<col> dat[row];
int r,c;
BinaryMatrix(size_t r,size_t c):r(r),c(c){}
bitset<col> &operator[](int i){return dat[i];}
const bitset<col> &operator[](int i) const{return dat[i];}
void Gauss_Jordan(int extended=0){
vector<int> used(r,0);
for (int j=0;j<c;++j){
if (extended&&j==c-1) break;
int p=-1;
for (int i=0;i<r;++i){
if (!used[i]&&dat[i][j]){p=i; break;}
}
if (p==-1) continue;
for (int i=0;i<r;++i){
if (i!=p&&dat[i][j]) dat[i]^=dat[p];
}
used[p]=1;
}
}
};
const int MAX_N=1e5+10,MAX_B=61;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int N; cin >> N;
vector<ll> A(N);
rep(i,N) cin >> A[i];
vector<int> cnt(MAX_B,0),can(MAX_B,0);
ll ans=0;
BinaryMatrix<MAX_B,MAX_N+1> BM(MAX_B,N+1);
for (int i=MAX_B-1;i>=0;--i){
rep(j,N) if (A[j]&(1LL<<i)) ++cnt[i];
if (cnt[i]&1) ans+=1LL<<i;
else if (cnt[i]>0){
can[i]=1;
rep(j,N) if (A[j]&(1LL<<i)) BM[MAX_B-1-i][j]=1;
BM[MAX_B-1-i][N]=1;
}
}
BM.Gauss_Jordan(1);
rep(i,MAX_B){
if (!can[MAX_B-1-i]) continue;
int ok=0;
rep(j,N) if (BM[i][j]==1) ok=1;
if (BM[i][N]==0) ok=1;;
if (ok) ans+=(2LL<<(MAX_B-1-i));
}
cout << ans << endl;
}
|
#include <iostream>
#include <algorithm>
#include <array>
#include <set>
#include <vector>
#include <climits>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int>> graph[n];
array<int, 3> points[n];
int cost[n];
for (int i = 0; cin >> points[i][0] >> points[i][1]; i++) {
points[i][2] = i;
cost[i] = INT_MAX;
}
sort(points, points + n, [](const array<int, 3>& left, const array<int, 3>& right) {
return left[0] < right[0];
});
for (int i = 1; i < n; i++) {
auto dist = min(abs(points[i - 1][0] - points[i][0]), abs(points[i - 1][1] - points[i][1]));
graph[points[i - 1][2]].emplace_back(points[i][2], dist);
graph[points[i][2]].emplace_back(points[i - 1][2], dist);
}
sort(points, points + n, [](const array<int, 3>& left, const array<int, 3>& right) {
return left[1] < right[1];
});
for (int i = 1; i < n; i++) {
auto dist = min(abs(points[i - 1][0] - points[i][0]), abs(points[i - 1][1] - points[i][1]));
graph[points[i - 1][2]].emplace_back(points[i][2], dist);
graph[points[i][2]].emplace_back(points[i - 1][2], dist);
}
long long result = 0;
set<int> mst = {0};
set<pair<int, int>> set;
auto update = [&](const vector<pair<int, int>>& nodes) {
for (auto& p : nodes) {
if (mst.find(p.first) != end(mst)) {
continue;
}
if (cost[p.first] > p.second) {
set.erase({cost[p.first], p.first});
cost[p.first] = p.second;
set.emplace(p.second, p.first);
}
}
};
update(graph[0]);
do {
auto current = set.begin()->second;
auto weight = set.begin()->first;
set.erase(set.begin());
mst.emplace(current);
result += weight;
update(graph[current]);
} while (!set.empty());
cout << result;
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.