code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include<cstring>
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<cmath>
#include<map>
#include<queue>
#include<bitset>
#include<cstdlib>
#include<set>
#include<unordered_map>
#define l(x) (x<<1)
#define r(x) ((x<<1)|1)
#define low(x) (x&(-x))
#define IL inline
#define reg register
#define LL long long
#define N 500010
#define MOD 998244353
#define MO 1000000007
#define INF 0x3f3f3f3f
using namespace std;
int T,n,m,i,j,k,y,z,pos,l,r;
LL Ans,x;
int a[N],b[N];
char c[N];
IL LL Min(LL a,LL b){return (a<b)?a:b;}
IL LL Max(LL a,LL b){return (a>b)?a:b;}
IL int read(){
int p=0,f=1; char c=getchar();
while (c<48||c>57) {if (c=='-') f=-1; c=getchar();}
while (c>=48&&c<=57) p=(p<<1)+(p<<3)+c-48,c=getchar();
return p*f;
}
struct Segtree{
struct Tree{
int l,r;
LL d,lz;
}t[N*4];
IL void Maketree(int x,int low,int high){
int mid=(low+high)>>1;
t[x].l=low; t[x].r=high;
if (low==high){t[x].d=a[low]; return;}
Maketree(l(x),low,mid); Maketree(r(x),mid+1,high);
t[x].d=Min(t[l(x)].d,t[r(x)].d);
}
IL void Push(int x){
LL p=t[x].lz;
t[l(x)].d+=p; t[r(x)].d+=p;
t[l(x)].lz+=p; t[r(x)].lz+=p;
t[x].lz=0;
}
IL void Add(int x,int low,int high,LL val){
reg int mid=(t[x].l+t[x].r)>>1;
if (t[x].l==low && t[x].r==high){
t[x].d+=val; t[x].lz+=val;
return;
}
if (t[x].lz) Push(x);
if (high<=mid) Add(l(x),low,high,val);
else if (low>mid) Add(r(x),low,high,val);
else Add(l(x),low,mid,val),Add(r(x),mid+1,high,val);
t[x].d=Min(t[l(x)].d,t[r(x)].d);
}
IL LL Query(int x,int low,int high){
reg int mid=(t[x].l+t[x].r)>>1;
if (t[x].l==low && t[x].r==high) return t[x].d;
if (t[x].lz) Push(x);
if (high<=mid) return Query(l(x),low,high);
else if (low>mid) return Query(r(x),low,high);
else return Min(Query(l(x),low,mid),Query(r(x),mid+1,high));
}
}T1,T2;
struct Tree{
int l,r;
LL d,lz;
}t[N*4];
int main(){
#ifdef __Marvolo
freopen("zht.in","r",stdin);
freopen("zht.out","w",stdout);
#endif
n=read(); m=read();
T1.Maketree(1,1,m);
for (i=1;i<=m;i++) a[i]=-i;
T2.Maketree(1,1,m);
for (i=1;i<=n;i++){
l=read(); r=read();
if (r<m){
Ans=T2.Query(1,1,r); x=T1.Query(1,r+1,r+1);
if (Ans+r+1<x) T1.Add(1,r+1,r+1,Ans+r+1-x),T2.Add(1,r+1,r+1,Ans+r+1-x);
}
T1.Add(1,l,r,INF); T2.Add(1,l,r,INF);
T1.Add(1,1,m,1); T2.Add(1,1,m,1);
Ans=T1.Query(1,1,m);
if (Ans>=INF) puts("-1");
else printf("%lld\n",Ans);
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int vis[1010][1010];
inline vector<pair<int,int> > getdistant(int n,int D1,bool hasret=true)
{
int cnt[2]={0,0};
vector<pair<int,int> > ret,trans;
for(int i=0;i<n;i++)
{
int v=round(sqrt(D1-i*i));
if(v*v+i*i==D1)trans.push_back(make_pair(i,v)),trans.push_back(make_pair(i,-v)),trans.push_back(make_pair(-i,v)),trans.push_back(make_pair(-i,-v));
}
memset(vis,255,sizeof(vis));
queue<pair<int,int> > q;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(vis[i][j]==-1)
{
// puts("----");
q.push(make_pair(i,j));
vis[i][j]=0;
while(!q.empty())
{
pair<int,int> fr=q.front();q.pop();
// printf("%d %d\n",fr.first,fr.second);
for(auto &x:trans)
{
int nx=fr.first+x.first,ny=fr.second+x.second;
if(nx>=0&&nx<n&&ny>=0&&ny<n&&vis[nx][ny]==-1)
{
vis[nx][ny]=vis[fr.first][fr.second]^1;
q.push(make_pair(nx,ny));
}
}
}
}
}
}
if(!hasret)return ret;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
cnt[vis[i][j]]++;
}
}
if(cnt[0]>cnt[1])
{
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(vis[i][j]==0)ret.push_back(make_pair(i,j));
}
}
}
else
{
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(vis[i][j]==1)ret.push_back(make_pair(i,j));
}
}
}
return ret;
}
int vis2[1010][1010];
inline vector<pair<int,int> > solve(int n,int d1,int d2)
{
vector<pair<int,int> > ret;
if(n==1)
{
ret.push_back(make_pair(0,0));
return ret;
}
if(d1%4&&d2%4)
{
for(int i=0;i<n;i+=2)
{
for(int j=0;j<n;j+=2)
{
ret.push_back(make_pair(i,j));
}
}
return ret;
}
if(d2%4==0)swap(d1,d2);
if(d2%4)
{
auto p=getdistant(n/2,d1/4);
if(d2%4==2)
{
for(auto &x:p)
{
ret.push_back(make_pair(x.first*2,x.second*2));
ret.push_back(make_pair(x.first*2,x.second*2+1));
}
}
else
{
for(auto &x:p)
{
ret.push_back(make_pair(x.first*2,x.second*2));
ret.push_back(make_pair(x.first*2+1,x.second*2+1));
}
}
return ret;
}
else
{
getdistant(n,d2,0);
memcpy(vis2,vis,sizeof(vis));
getdistant(n,d1,0);
int cnt[4]={0,0,0,0};
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
cnt[vis[i][j]*2+vis2[i][j]]++;
}
}
int mx=0;
for(int i=1;i<=3;i++)if(cnt[i]>cnt[mx])mx=i;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(vis[i][j]*2+vis2[i][j]==mx)ret.push_back(make_pair(i,j));
}
}
return ret;
}
}
int n,D1,D2;
int main()
{
scanf("%d%d%d",&n,&D1,&D2);
auto ans=solve(n<<1,D1,D2);
ans.resize(n*n);
for(auto &p:ans)printf("%d %d\n",p.first,p.second);
return 0;
} | 0 |
#include<cstdio>
int H,W,A[2010][2010],h[2010],l[2010],stk[2010];
char S[2010][2010];
void cmax(int&a,int b){b>a?a=b:1;}
int main(){
scanf("%d%d",&H,&W);
for(int i=0;i<H;i++){
scanf("%s",S[i]);
for(int j=0;j<W;j++){
S[i][j]=S[i][j]=='#';
if(i&&j)A[i][j]=S[i][j]^S[i][j-1]^S[i-1][j]^S[i-1][j-1]^1;
}
}
int ans=H>W?H:W;
for(int i=1;i<H;i++){
int*tp=stk;
for(int j=1;j<=W;j++){
h[j]=A[i][j]?h[j]+1:0;
for(;tp>stk&&h[*tp]>=h[j];--tp)
cmax(ans,(j-l[*tp])*(h[*tp]+1));
l[j]=*tp;
*++tp=j;
}
}
printf("%d\n",ans);
} | #include<bits/stdc++.h>
using namespace std;
using ll = long long;
template<class T>
map<T,T> fact(T n){
map<T,T> Map;
for(T i = 2; i * i <= n; i++){
while(n % i == 0){
Map[i]++;
n /= i;
}
}
if(n == 1)return Map;
Map[n]++;
return Map;
}
int main()
{
ll a, b;
cin >> a >> b;
ll gc = gcd(a, b);
cout << fact(gc).size() + 1 << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef ostringstream OSS;
typedef istringstream ISS;
typedef long long LL;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<PII> VPII;
#define fst first
#define snd second
// #define Y first
// #define X second
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) (x).begin(),(x).end()
#define RANGE(x,y,maxX,maxY) (0 <= (x) && 0 <= (y) && (x) < (maxX) && (y) < (maxY))
#define DUMP( x ) cerr << #x << " = " << ( x ) << endl
template < typename T > inline T fromString(const string &s) { T res; ISS iss(s); iss >> res; return res; };
template < typename T > inline string toString(const T &a) { OSS oss; oss << a; return oss.str(); };
const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;
const double DINF = 0x3f3f3f3f;
const int DX[]={1,0,-1,0},DY[]={0,-1,0,1};
int H, W;
PII solve() {
PII res;
PII min_dh(INF, INF);
PII this_dh(H * H + W * W, H);
// x > y
for (int y = 1; y <= 150; y++) {
for (int x = y + 1; x <= 150; x++) {
PII dh(x * x + y * y, y);
if (this_dh < dh && dh < min_dh) {
min_dh = dh;
res = MP(y, x);
}
}
}
return res;
}
int main(void) {
while (cin >> H >> W, H) {
PII ans = solve();
cout << ans.fst << " " << ans.snd << endl;
}
return 0;
} | #include <vector>
#include <algorithm>
#include <iostream>
#include <climits>
using namespace std;
typedef long long int int64;
vector<int64> P,Q;
int64 N,M,T;
int main(void)
{
while(true)
{
N = 0;
M = 0;
P.clear();
Q.clear();
P.shrink_to_fit();
Q.shrink_to_fit();
cin >> N >> M;
if(N == 0 && M == 0)
{
exit(0);
}
for(int i = 0;i < N;i++)
{
cin >> T;
P.push_back(T);
}
P.push_back(0);
for(auto itr = P.begin();itr < P.end();itr++)
{
for(auto itr2 = P.begin();itr2 < P.end();itr2++)
{
Q.push_back(*itr + *itr2);
}
}
Q.push_back(LLONG_MAX / 2);
Q.push_back(LLONG_MIN / 2);
sort(Q.begin(),Q.end());
int64 ms = 0;
for(auto itr = Q.begin();itr < Q.end()+1;itr++)
{
ms = max(ms,*itr + *(lower_bound(Q.begin(),Q.end() - 1,M-*itr+1) - 1));
}
cout << ms << endl;
}
} | 0 |
#include<bits/stdc++.h>
#define rep(i, l, r) for(int i = (l), i##end = (r);i <= i##end;++i)
using std::cin; using std::cout;
const int maxn = 200200;
typedef long long ll;
const int mod = 998244353;
inline ll pow(ll a,int b,int ans = 1) {
for(;b;b >>= 1,a = a * a % mod) if(b & 1)
ans = ans * a % mod;
return ans;
}
inline ll inverse(int x){ return pow(x, mod - 2); }
int n, a[maxn];
inline bool get() {
int s = 0, one = 0;
rep(i, 1, n) s += a[i] % 2, one = one || a[i] == 1;
if(s != 1 || one) return n - s & 1;
int gcd = 0;
for(int i = 1;i <= n;++i) gcd = std::__gcd(gcd, a[i] -= a[i] % 2);
for(int i = 1;i <= n;++i) a[i] /= gcd;
return get() ^ 1;
}
int main() {
std::ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
rep(i, 1, n) cin >> a[i];
cout << (get() ? "First" : "Second") << '\n';
}
| #include <iostream>
#include <algorithm>
#include <utility>
#include <vector>
#include <string>
#include <map>
#include <set>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n) - 1; i >= 0; i--)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (a); i > (b); i--)
#define ALL(a) (a).begin(), (a).end()
const ll INF = 1e18;
ll N;
ll X[200000], Y[200000];
char U[200000];
ll get_min(char first, char second, ll sign) {
map<ll, set<ll>> m;
REP(i, N) {
if (U[i] != first) continue;
ll line = Y[i] + sign * X[i];
if (m.count(line) == 0) {
set<ll> set {Y[i]};
m[line] = set;
} else {
m[line].insert(Y[i]);
}
}
ll ret = INF;
REP(i, N) {
if (U[i] != second) continue;
ll line = Y[i] + sign * X[i];
if (m.count(line) == 0) continue;
auto it = m[line].lower_bound(Y[i]);
if (it != m[line].begin()) {
it--;
ret = min(ret, (Y[i] - *it) * 10);
}
}
return ret;
}
ll get_min_same_line() {
ll ret = INF;
map<ll, set<ll>> m;
REP(i, N) {
if (U[i] != 'U') continue;
if (m.count(X[i]) == 0) {
set<ll> set {Y[i]};
m[X[i]] = set;
} else {
m[X[i]].insert(Y[i]);
}
}
REP(i, N) {
if (U[i] != 'D' || m.count(X[i]) == 0) continue;
auto it = m[X[i]].lower_bound(Y[i]);
if (it != m[X[i]].begin()) {
it--;
ret = min(ret, (Y[i] - *it) * 5);
}
}
m.clear();
REP(i, N) {
if (U[i] != 'R') continue;
if (m.count(Y[i]) == 0) {
set<ll> set {X[i]};
m[Y[i]] = set;
} else {
m[Y[i]].insert(X[i]);
}
}
REP(i, N) {
if (U[i] != 'L' || m.count(Y[i]) == 0) continue;
auto it = m[Y[i]].lower_bound(X[i]);
if (it != m[Y[i]].begin()) {
it--;
ret = min(ret, (X[i] - *it) * 5);
}
}
return ret;
}
int main() {
cin >> N;
REP(i, N) cin >> X[i] >> Y[i] >> U[i];
ll ans = INF;
ans = min(ans, get_min('R', 'D', -1));
ans = min(ans, get_min('U', 'L', -1));
ans = min(ans, get_min('L', 'D', 1));
ans = min(ans, get_min('U', 'R', 1));
ans = min(ans, get_min_same_line());
if (ans == INF) cout << "SAFE" << endl;
else cout << ans << endl;
return 0;
} | 0 |
#include <iostream>
#include <vector>
using namespace std;
int main(){
long long N;
cin >> N;
vector<long long> a(5);
for(int i = 0; i < 5; i++) cin >> a[i];
long long b = 1e17;
for(int i = 0; i < 5; i++) b = min(b, a[i]);
long long t = (N + b - 1) / b;
long long ans = 5 + t - 1;
cout << ans << endl;
} | #include <bits/stdc++.h>
// #undef DEBUG // Uncomment this line to forcefully disable debug print.
#if DEBUG
template <typename T>
void debug(T value) {
std::cerr << value;
}
template <typename T, typename... Ts>
void debug(T value, Ts... args) {
std::cerr << value << ", ";
debug(args...);
}
#define dbg(...) \
do { \
cerr << #__VA_ARGS__ << ": "; \
debug(__VA_ARGS__); \
cerr << " (L" << __LINE__ << ")" << endl; \
} while (0)
#else
#define dbg(...)
#endif
void read_from_cin() {}
template <typename T, typename... Ts>
void read_from_cin(T& value, Ts&... args) {
std::cin >> value;
read_from_cin(args...);
}
#define in(type, ...) \
type __VA_ARGS__; \
read_from_cin(__VA_ARGS__);
template <typename T>
void write_to_cout(const T& value) {
std::cout << value << std::endl;
}
template <typename T, typename... Ts>
void write_to_cout(const T& value, const Ts&... args) {
std::cout << value << ' ';
write_to_cout(args...);
}
#define out(...) write_to_cout(__VA_ARGS__);
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
using ll = long long;
using namespace std;
int main() {
in(ll, n);
vector<ll> transportation(5);
rep(i, 5) cin >> transportation[i];
vector<ll> population(6);
population[0] = n;
ll ans = 0;
ll last_change = 0;
while (population[5] < n) {
++ans;
vector<ll> change(6);
rep(i, 5) {
ll c = min(transportation[i], population[i]);
change[i] -= c;
change[i + 1] += c;
}
rep(i, 6) population[i] += change[i];
if (last_change > 0 && change[5] == last_change) {
out(ans + (n - population[5] + last_change - 1) / last_change);
return 0;
}
last_change = change[5];
}
out(ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i,m,n) for(int i=(int)(m); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define RREP(i,m,n) for(int i=(int)(m); i>=(int)(n); i--)
#define rrep(i,n) RREP(i,n-1,0)
#define REPL(i,m,n) for(ll i=(ll)(m); i<(ll)(n); i++)
#define repl(i,n) REPL(i,0,n)
#define all(v) v.begin(), v.end()
const int inf = 1e9+7;
const ll longinf = 1LL<<60;
const ll mod = 1e9+7;
int main() {
int N, Q;
string S;
cin >> N >> S >> Q;
rep(q, Q) {
int k;
cin >> k;
ll cntD = 0, cntM = 0;
ll cnt = 0;
ll ans = 0;
rep(i, N) {
if(S[i] == 'D') {
cntD++;
} else if(S[i] == 'M') {
cntM++;
cnt += cntD;
} else if(S[i] == 'C') {
ans += cnt;
}
if(i >= k-1) {
if(S[i-k+1] == 'D') {
cntD--;
cnt -= cntM;
} else if(S[i-k+1] == 'M') {
cntM--;
}
}
}
cout << ans << endl;
}
return 0;
}
| #include <iostream>
#include <algorithm>
#include <map>
using namespace std;
#define rep(i,n) for(int i = 0 ; i < n ; i++)
int main(){
int n,K;
while(cin >> n >> K , n + K){
map<string,int> m;
string str[11],in;
rep(i,n){
cin >> str[i];
}
int cnt = 0;
if(K == 2){
rep(i,n){
rep(j,n){
if(i == j) continue;
in = str[i]+str[j];
if(!m[in]){
m[in]++;
cnt++;
}
}
}
}
else if(K == 3){
rep(i,n){
rep(j,n){
if(i == j) continue;
rep(k,n){
if(i == k ||j == k) continue;
in = str[i]+str[j]+str[k];
if(!m[in]){
m[in]++;
cnt++;
}
}
}
}
}
else{
rep(i,n){
rep(j,n){
if(i == j) continue;
rep(k,n){
if(i == k || j == k) continue;
rep(l,n){
if(i == l || j == l || k == l) continue;
in = str[i]+str[j]+str[k]+str[l];
if(!m[in]){
m[in]++;
cnt++;
}
}
}
}
}
}
cout << cnt << endl;
}
return 0;
} | 0 |
// ====================================
// author: M_sea
// website: https://m-sea-blog.com/
// ====================================
#include <bits/stdc++.h>
#define file(x) freopen(#x".in","r",stdin); freopen(#x".out","w",stdout)
#define debug(...) fprintf(stderr,__VA_ARGS__)
using namespace std;
typedef long long ll;
ll read() {
ll X=0,w=1; char c=getchar();
while (c<'0'||c>'9') { if (c=='-') w=-1; c=getchar(); }
while (c>='0'&&c<='9') X=X*10+c-'0',c=getchar();
return X*w;
}
int main() {
ll k=read(); int n=50;
ll c=k/n,r=k%n;
printf("%d\n",n);
for (int i=1;i<=n;++i) {
if (i<=r) printf("%lld ",n-1+c+n-(r-1));
else printf("%lld ",n-1+c-r);
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main(){
long long K;
while(cin >> K){
vector<long long> res(50, 49+(K+49)/50);
long long n = (K+49)/50*50;
while(n > K){
int mIdx = 0;
for(int i=1;i<50;i++) if(res[mIdx] < res[i]) mIdx = i;
for(int i=0;i<50;i++){
if(i == mIdx) res[i] -= 50;
else res[i]++;
}
--n;
}
cout << 50 << endl;
cout << res[0];
for(int i=1;i<50;i++) cout << " " << res[i];
cout << endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
const long long inf = 1e18;
int n, H[N], P[N];
int a[N];
long long f[N][N];
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> H[i] >> P[i], a[i] = i;
sort(a + 1, a + n + 1, [&](int x, int y) {
return H[x] + P[x] < H[y] + P[y];
});
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= n; ++j) f[i][j] = inf;
}
f[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= i; ++j) {
f[i][j] = f[i-1][j];
if (j > 0 && H[a[i]] >= f[i-1][j-1]) {
f[i][j] = min(f[i][j], f[i-1][j-1] + P[a[i]]);
}
}
}
for (int i = n; i >= 0; --i) if (f[n][i] != inf) {
cout << i << endl; return 0;
}
} | #include <bits/stdc++.h>
#define be(v) (v).begin(),(v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod=1000000007, INF=mod*mod*3LL;
#define doublecout(a) cout<<fixed<<setprecision(10)<<a<<endl;
int N = 100001;
vector<vector<int> > fat(N,vector<int> (20,-1));
int par(int now,int n){
for(int i=18;i>=0;i--){
if(now == -1) continue;
if(n>>i&1) now = fat[now][i];
}
return now;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int n, q;
cin >> n;
int x[n];
for(int i=0;i<n;i++) cin >> x[i];
int L;
cin >> L;
for(int i=0;i<n;i++) fat[i][0] = upper_bound(x,x+n,x[i]+L) - x - 1;
for(int i=0;i<18;i++)for(int j=0;j<n;j++) fat[j][i+1] = fat[fat[j][i]][i];
cin >> q;
vector<int> ans;
while(q--){
int a, b;
cin >> a >> b;
a--;b--;
if(a > b)swap(a,b);
int le = 0, ri = n, mid;
while(ri - le > 1){
mid = (ri + le) / 2;
int p = par(a, mid);
if(p >= b) ri = mid;
else le = mid;
}
ans.pb(ri);
}
for(auto& i:ans){
cout << i << endl;
}
return 0;
}
| 0 |
#include <iostream>
#include <string>
//Hoshino search and replace Hoshina
void replace_word(std::string s){
const std::string find_word("Hoshino");
//Hoshino search
std::string::size_type pos = s.find(find_word);
while(pos != std::string::npos){
//Hoshino replace Hoshina
s.replace(pos, find_word.length(), "Hoshina");
pos = s.find(find_word, pos + find_word.length());
}
//output
std::cout << s << std::endl;
return;
}
int main(){
std::string s;
int num;
std::cin >> num; //data set
std::getline(std::cin, s); //read a new line
for(int i=0; i<num; ++i){
//read text
std::getline(std::cin, s);
//replace
replace_word(s);
}
} | #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#define MOD 998244353
using namespace std;
typedef long long ll;
template <typename Tp> inline void getint(Tp &num){
register int ch, neg = 0;
while(!isdigit(ch = getchar())) if(ch == '-') neg = 1;
num = ch & 15;
while(isdigit(ch = getchar())) num = num * 10 + (ch & 15);
if(neg) num = -num;
}
inline int fastpow(int bas, int ex){
register int res = 1;
for(; ex; ex >>= 1, bas = bas * (ll)bas % MOD) if(ex & 1) res = res * (ll)bas % MOD;
return res;
}
inline int kazu(int a, const int &b) {return (a += b) >= MOD ? a - MOD : a;}
inline int hiku(int a, const int &b) {return (a -= b) < 0 ? a + MOD : a;}
int N, sum = 0, f[90005], g[90005];
int main(){
getint(N), f[0] = g[0] = 1;
for(register int i = 1, a; i <= N; i++){
getint(a), sum += a;
for(register int j = sum; j >= 0; j--){
f[j] = f[j] * 2LL % MOD;
if(j >= a) f[j] = kazu(f[j], f[j - a]), g[j] = kazu(g[j], g[j - a]);
}
}
int ans = fastpow(3, N);
for(register int i = sum + 1 >> 1; i <= sum; i++) ans = hiku(ans, f[i] * 3LL % MOD);
if(!(sum & 1)) ans = kazu(ans, g[sum >> 1] * 3LL % MOD);
return printf("%d\n", ans), 0;
} | 0 |
/* /$$ /$$
| $$ | $$
/$$$$$$$ /$$$$$$ /$$$$$$$ /$$$$$$ /$$$$$$$ /$$$$$$ /$$$$$$
/$$__ $$ /$$__ $$ /$$_____/ /$$__ $$ /$$__ $$ /$$__ $$ /$$__ $$
| $$ | $$| $$$$$$$$| $$ | $$ \ $$| $$ | $$| $$$$$$$$| $$ \__/
| $$ | $$| $$_____/| $$ | $$ | $$| $$ | $$| $$_____/| $$
| $$$$$$$| $$$$$$$| $$$$$$$| $$$$$$/| $$$$$$$| $$$$$$$| $$
\_______/ \_______/ \_______/ \______/ \_______/ \_______/|__//$$$$$$ /$$$$$$
|______/|______/
*/
#include <vector>
#include <list>
#include <map>
#include <climits>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <queue>
#include <unordered_map>
#define fastio ios_base::sync_with_stdio(false); cin.tie(NULL);
#define ln cout << endl;
#define vi vector<int>
#define vll vector<long long>
#define sortl(vec) sort(vec.begin(), vec.end());
#define sortr(vec) sort(vec.rbegin(), vec.rend());
#define forn(i, x, n) for(long long i = x; i < n; i++)
#define revn(i, n, x) for(long long i = n; i >= x; i--)
#define in(vec) for(auto &it : vec) cin >> it;
#define loop(vec) for(auto &it : vec)
#define out(vec) for(auto &it : vec) cout << it << " "; ln
#define ll long long
#define mod 1000000007
#define pb emplace_back
#define mp make_pair
#define um unordered_map
#define pii pair<int, int>
#define pll pair<ll, ll>
#define f first
#define s second
#define pi 3.14159265359
#define o(x) cout << x << endl;
#define CLOCK cerr<<"time taken : "<<(float)clock()/CLOCKS_PER_SEC<<" secs"<<endl;
using namespace std;
ll bS(ll l, ll r, ll x, vll arr) {
while (l <= r) {
ll m = l + (r - l) / 2;
if (arr[m] == x)
return m;
if (arr[m] < x)
l = m + 1;
else
r = m - 1;
}
return -1;
}
void primeFactors(ll n) {
while (n % 2 == 0) {
//cout << 2 << " ";
n = n / 2;
}
for (ll i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
//cout << i << " ";
n = n / i;
}
}
if (n > 2)
cout << n << " ";
}
ll power(ll x, ll y, ll p) {
ll res = 1;
x = x % p;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
ll modulo(ll a, ll b) {
ll c = a % b;
return (c < 0) ? c + b : c;
}
int main() {
// in(vec) works for size-defined type vectors
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input1.txt", "r", stdin);
// for writing output to output.txt
freopen("output1.txt", "w", stdout);
#endif
fastio
ll t = 1;
while (t--) {
ll n;
cin >> n;
vll vec(n);
in(vec);
vll count(60, 0);
forn(i, 0, n) {
forn(j, 0, 60) {
if (vec[i] & 1LL << j) {
count[j]++;
}
}
}
ll sum = 0, zero, prod = 1;
forn(i, 0, 60) {
zero = n - count[i];
prod = ((zero % mod) * (count[i] % mod)) % mod;
sum += ((prod % mod) * ((1LL << i) % mod)) % mod;
sum %= mod;
}
o(sum)
}
CLOCK
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod=1e9+7;
ll cnt[66][2];
int main(){
int n;cin>>n;
for(int i=0;i<n;i++){
ll a;cin>>a;
int bit=0;
while(a){
if(a&1){
cnt[bit][1]++;
}else cnt[bit][0]++;
a/=2;
bit++;
}
for(int j=bit;j<=64;j++)cnt[j][0]++;
}
ll ans=0;
for(int i=0;i<=62;i++){
ll p=(1LL<<i);p%=mod;
ll hano=cnt[i][0]*cnt[i][1];
hano%=mod;
ans+=(p*hano);
ans%=mod;
}
cout<<ans;
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,ans;
ans=0;
cin >> n;
vector<string> s(3);
for(int i=0;i<3;i++){
cin >> s[i];
}
for(int i=0;i<n;i++){
if(s[0][i]==s[1][i] && s[0][i]==s[2][i]);
else if(s[0][i]==s[1][i] || s[0][i]==s[2][i] || s[1][i]==s[2][i])ans++;
else ans+=2;
}
cout << ans;
return 0;
} | #include<iostream>
#include<bits/stdc++.h>
#include<vector>
using namespace std;
int main()
{
int n,l;
cin>>n;
vector<int>v;
int a[n];
for(int i=0;i<n;i++){
cin>>a[i];
}
int d=a[0];
int c=0;
for(int i=0;i<n;i++){
if(a[i]<=d){
c++;
v.push_back(a[i]);
d=a[i];
}
}
cout<<c<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define f first
#define s second
#define matrix vector<vector<char>>
#define zero(n,m) matrix(n , vector<char>(m,'0'))
#define one(n,m) matrix(n , vector<ll>(m,1))
#define pii pair<int,int>
#define point complex<ld>
#define angle(a) (atan2((a).imag() , (a).real() ))
#define pi acos(-1)
#define X real()
#define Y imag()
const int N = 2e5+5;
ll n , a[N] , b[N] , seg[4*N] , lazy[4*N];
ll st[N] , en[N] , st2[N] , en2[N];
set<ll> stt;
void probagate(int node , int st , int en)
{
if (lazy[node] != 0)
{
seg[node] += lazy[node];
if (st != en)
{
lazy[2*node] += lazy[node];
lazy[2*node+1] += lazy[node];
}
lazy[node] = 0;
}
}
void update(int node , int st , int en , int l , int r , int val)
{
probagate(node , st , en);
if (st > en || st > r || en < l)
return;
if (st >= l && en <= r)
{
lazy[node] += val;
return probagate(node , st , en);
}
int mid = (st+en)/2;
update(2*node,st,mid,l,r,val);
update(2*node+1,mid+1,en,l,r,val);
seg[node] = max(seg[2*node] , seg[2*node+1]);
}
ll query(int node , int st , int en , int l , int r)
{
if (st > en || st > r || en < l) return 0;
probagate(node , st , en);
if (st >= l && en <= r)
{
return seg[node];
}
int mid = (st+en)/2;
return max(query(2*node , st , mid , l , r) , query(2*node+1 , mid+1 , en , l , r));
}
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
cin >> n;
for(int i=1; i<=n; i++)
{
cin >> a[i];
if (!st[a[i]]) st[a[i]] = i;
en[a[i]] = i;
}
for(int i=1; i<=n; i++)
{
cin >> b[i];
if (!st2[b[i]]) st2[b[i]] = i;
en2[b[i]] = i;
stt.insert(b[i]);
}
for(ll i=1; i<=n; i++)
{
ll l = st[b[i]] , r = en[b[i]];
if (l > i)
{
update(1,0,n-1,0,l-i-1,1);
}
l = max(en[b[i]]+1,i) , r = n;
if (l<=r)
{
ll l2 = l-i , r2 = r-i;
if (l2 <= r2)
{
update(1,0,n-1,l2,r2,1);
}
}
//from one to st[b[i]]-1
l = 1 , r = min(st[b[i]]-1 , i-1);
if (l<=r)
{
ll l2 = n-i+l , r2 = n-i+r;
if (l2 <= r2)
{
update(1,0,n-1,l2,r2,1);
}
}
if (i > en[b[i]])
{
l = en[b[i]]+1 , r = i-1;
if (l<=r)
{
ll l2 = n-i+l , r2 = n-i+r;
if (l2 <= r2)
{
update(1,0,n-1,l2,r2,1);
}
}
}
}
for(int i=0; i<n; i++)
{
if (query(1,0,n-1,i,i) == n)
{
cout << "Yes\n";
for(int j=1; j<=n; j++)
{
int newIdx = j + i;
if (newIdx > n) newIdx -= n;
a[newIdx] = b[j];
}
for(int j=1; j<=n; j++)
cout << a[j] << ' ';
cout << '\n';
return 0;
}
}
cout << "No\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define repd(i,a,b) for (int i=(a);i<(b);i++)
#define rep(i,n) repd(i,0,n)
#define all(x) (x).begin(),(x).end()
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
typedef long long ll;
const long long INF = 1LL << 60;
typedef pair<int, int> P;
int main()
{
int N;
cin >> N;
vector<int> A(N);
rep(i, N) cin >> A[i];
ll ans = 0;
int ct = 0;
bool flag = false;
repd(i, 1, N) {
if (A[i] > ct + 1) {
ans = -1;
ct = 0;
break;
}
else if (A[i] == ct + 1) {
ct = A[i];
}
else {
ans += ct;
ct = A[i];
}
}
ans += ct;
if (A[0] >= 1) ans = -1;
cout << ans << endl;
return 0;
} | 0 |
// luogu-judger-enable-o2
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#include<bits/stdc++.h>
#define R register
using namespace std;
char s[351];int len,k;
int f[351][351][351],ans;
inline void read(R int &x)
{
x=0;R int f=1;
R char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-') f=-1;
c=getchar();
}
while(c>=48&&c<=57)
{
x=(x<<1)+(x<<3)+(c^48);
c=getchar();
}
x=x*f;
}
inline void input_data()
{
char ch=getchar();
while(ch>='a'&&ch<='z')
s[++len]=ch,ch=getchar();
read(k);return;
}
int dfs(R int k,R int l,R int r)
{
if(l>r) return false;
if(l==r) return s[l]==s[r];
if(f[k][l][r]) return f[k][l][r];
f[k][l][r]=max(dfs(k,l+1,r),dfs(k,l,r-1));
if(s[l]==s[r]) f[k][l][r]=max(f[k][l][r],dfs(k,l+1,r-1)+2);
if(k>=1) f[k][l][r]=max(f[k][l][r],dfs(k-1,l+1,r-1)+2);
return f[k][l][r];
}
int main()
{
input_data();
for(R int i=0;i<=k;++i)
ans=max(ans,dfs(i,1,len));
printf("%d\n",ans);
return 0;
} | #include<cstring>
#include<cstdio>
#define max(a,b) (a>b?a:b)
int dp[305][305][305],mk,len;
char a[305];
int main(){
scanf("%s%d",a+1,&mk);
len=strlen(a+1);
for(int i=1;i<=len;i++)
for(int j=i;j>=1;j--){
if(i==j){for(int k=0;k<=mk;k++) dp[j][i][k]=1;continue;}
for(int k=0;k<=mk;k++)
if(k) dp[j][i][k]=max(dp[j+1][i-1][k-1]+2,max(dp[j+1][i-1][k]+(a[i]==a[j])*2,max(dp[j+1][i][k],dp[j][i-1][k])));
else dp[j][i][k]=max(dp[j+1][i-1][k]+(a[i]==a[j])*2,max(dp[j+1][i][k],dp[j][i-1][k]));
}
printf("%d\n",dp[1][len][mk]);
} | 1 |
#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;
} | #include <iostream>
#define reep(i,n,m) for(int i=(n);i<(m);i++)
#define rep(i,n) reep(i,0,n)
using namespace std;
int main(){
int n;
while(cin >> n,n){
int dp[35]={0};
dp[0]=1;
rep(i,n){
dp[i+1] += dp[i];
dp[i+2] += dp[i];
dp[i+3] += dp[i];
}
cout << dp[n]/(365*10)+1 << endl;
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define PI acos(-1)
int main(){
long long x,y,d,ans;
bool minus_x = false,minus_y = false;
cin >> x >> y;
if(x < 0)minus_x = true;
if(y < 0)minus_y = true;
d = abs(abs(x) - abs(y));
if(x == 0 || y == 0){
if(x == 0 && y < 0 || y == 0 && x > 0)ans = d + 1;
else ans = d;
}else{
if(abs(x) > abs(y)){
if(minus_x && minus_y)ans = d;
else if(minus_x || minus_y)ans = d + 1;
else ans = d + 2;
}
else if(abs(x) == abs(y)){
if(minus_x && minus_y)ans = d;
else if(minus_x || minus_y)ans = d + 1;
else ans = d;
}
else{
if(minus_x && minus_y)ans = d + 2;
else if(minus_x || minus_y)ans = d + 1;
else ans = d;
}
}
cout << ans << endl;
}
| #include<bits/stdc++.h>
using namespace std;
int main(){
int x,y; cin >> x >> y;
int ans = 0;
if(x>0){
if(y>0){
if(x>y){
ans++; // x -> -x
ans += abs(x-y); // x -> -y
ans++; // x-> y
}else if(x < y){
ans+= y-x; // x->y
}
}else if(y<0){
if(abs(x) > abs(y)){
ans++; // x->-x
ans+= abs(x) - abs(y); // x->-y
}else if(abs(x) < abs(y)){
ans+= abs(y) - abs(x); // x->y
ans++; // x -> -y
}else{
ans++;
}
}else{
ans++;
ans+= x;
}
}else if(x<0){
if(y>0){
if(abs(x)>abs(y)){
ans += abs(x) -abs(y);
ans++;
}else if(abs(x)<abs(y)){
ans++;
ans += abs(y) - abs(x);
}else{
ans++;
}
}else if(y<0){
if(abs(x)>abs(y)){
ans += abs(x) -abs(y);
}else if(abs(x)<abs(y)){
ans++;
ans += abs(y) - abs(x);
ans++;
}
}else{
ans+=abs(x);
}
}else{
if(y>0) ans+=y;
else if(y<0) ans+= abs(y) + 1;
}
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, k; cin >> a >> b >> k;
for (int i=0; i<k; ++i) {
int na, nb;
if (i%2 == 0) {
na = a/2;
nb = b + a/2;
} else {
nb = b/2;
na = a + b/2;
}
a = na;
b = nb;
}
cout << a << " " << b << endl;
} | #include<iostream>
using namespace std;
int a[1000005];
int main(){
int k,i;
cin>>a[0]>>a[1]>>k;
for(i=0;i<k;i++){
a[!(i&1)]+=(a[i&1]>>=1);
}
cout<<a[0]<<" "<<a[1];
return 0;
} | 1 |
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
int main()
{
int n, m, f[10001] = { 0 }, s[10001] = { 0 }, ss[501] = {0}, f_, s_, cnt = 0;
int up = 0, down = 0;
cin >> n >> m;
ss[1] = 3;
while (n != 0 && m != 0)
{
memset(ss, 0, sizeof(ss));
for (int i = 0; i < m; i++)
{
cin >> f[i] >> s[i];
if (f[i] == 1)
{
ss[s[i]] = 2;
}
}
for (int i = 0; i < m; i++)
{
if (ss[s[i]] == 2 && ss[f[i]] == 0)
ss[f[i]] = 1;
if (ss[f[i]] == 2 && ss[s[i]] == 0)
ss[s[i]] = 1;
}
for (int i = 2; i <= n; i++) {
if (ss[i] != 0)cnt++;
}
cout << cnt << endl;
cnt = 0;
cin >> n >> m;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int INF = 1e+9;
typedef pair<int, int> P;
typedef pair<P, int> pi;
int main() {
vector<pi> data;
for(int y = 1; y <= 150; ++y){
for(int x = y + 1; x <= 150; ++x){
data.push_back(pi(P(x * x + y * y, y), x));
}
}
sort(data.begin(), data.end());
int h, w;
while(cin >> h >> w && (h || w)){
int base = h * h + w * w;
auto it = lower_bound(data.begin(), data.end(), pi(P(base, h), w));
while((*it).first.first == base && (*it).first.second == h){
++it;
}
cout << (*it).first.second << " " << (*it).second << endl;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x,vector<x>,greater<x>>
#define all(x) (x).begin(),(x).end()
#define CST(x) cout<<fixed<<setprecision(x)
#define vtpl(x,y,z) vector<tuple<x,y,z>>
#define rev(x) reverse(x);
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
using pl=pair<ll,ll>;
using vpl=vector<pl>;
using vvpl=vector<vpl>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main(){
string s;cin >> s;
if("zyxwvutsrqponmlkjihgfedcba"==s)cout << -1 <<endl,exit(0);
if(s.size()==26){
set<char> st;
char x;
per(i,25){
st.ins(s[i+1]);
if(s[i]>s[i+1])s.erase(i+1);
else{
x=s[i];
s.erase(i);
break;
}
}
x=*st.upper_bound(x);
cout << s<<x <<endl;
return 0;
}
set<char> st;
rep(i,s.size())st.ins(s[i]);
rep(i,26){
if(!st.count('a'+i)){
//cout << i <<endl;
char x='a'+i;
cout << s <<x<<endl;
return 0;
}
}
} | #include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
using bint = boost::multiprecision::cpp_int;
using ll = long long;
using pint = pair<int, int>;
using pll = pair<ll, ll>;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define repSE(i,s,n) for (int i = (s); i < (n); i++)
#define rrepSE(i,s,e) for (int i = (s); i > (e); i--)
#define ssort(v) sort(v.begin(), v.end())
#define gsort(v) sort(v.rbegin(), v.rend())
template<typename T> istream &operator>>(istream &is, vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec){ os << "["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const deque<T> &vec){ os << "deq["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &pa){ os << "(" << pa.first << "," << pa.second << ")"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename T> bool chmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
template<typename T> bool chmin(T &m, const T q) { if (q < m) {m = q; return true;} else return false; }
#define DEBUG_PRINT(var) std::cout << #var << " = " << var << "\n";
int main()
{
string st;
cin >> st;
int s = 0, t = 0;
rep(i,st.size()) {
if (st[i] == 'S') s++;
if (st[i] == 'T') {
if (s > 0) s--;
else t++;
}
}
cout << s + t << "\n";
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define reg register int
#define il inline
#define fi first
#define se second
#define mk(a,b) make_pair(a,b)
#define numb (ch^'0')
#define pb push_back
#define solid const auto &
#define enter cout<<endl
#define pii pair<int,int>
using namespace std;
typedef long long ll;
template<class T>il void rd(T &x){
char ch;x=0;bool fl=false;while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);
for(x=numb;isdigit(ch=getchar());x=x*10+numb);(fl==true)&&(x=-x);}
template<class T>il void output(T x){if(x/10)output(x/10);putchar(x%10+'0');}
template<class T>il void ot(T x){if(x<0) putchar('-'),x=-x;output(x);putchar(' ');}
template<class T>il void prt(T a[],int st,int nd){for(reg i=st;i<=nd;++i) ot(a[i]);putchar('\n');}
namespace Modulo{
const int mod=998244353;
il int ad(int x,int y){return x+y>=mod?x+y-mod:x+y;}
il int sub(int x,int y){return ad(x,mod-y);}
il int mul(int x,int y){return (ll)x*y%mod;}
il void inc(int &x,int y){x=ad(x,y);}
il void inc2(int &x,int y){x=mul(x,y);}
il int qm(int x,int y=mod-2){int ret=1;while(y){if(y&1) ret=mul(x,ret);x=mul(x,x);y>>=1;}return ret;}
template<class ...Args>il int ad(const int a,const int b,const Args &...args) {return ad(ad(a,b),args...);}
template<class ...Args>il int mul(const int a,const int b,const Args &...args) {return mul(mul(a,b),args...);}
}
//using namespace Modulo;
namespace Miracle{
const int N=2e5+5;
const ll inf=0x3f3f3f3f3f3f3f3f;
int n,q,A,B;
ll f[N],s[N];
ll x[N];
struct SegmentTree{
ll mi[4*N];
#define ls (x<<1)
#define rs (x<<1|1)
#define mid ((l+r)>>1)
void pushup(int x){
mi[x]=min(mi[ls],mi[rs]);
}
void build(int x,int l,int r){
if(l==r){
mi[x]=inf;return;
}
mi[x]=inf;
build(ls,l,mid);build(rs,mid+1,r);
}
void upda(int x,int l,int r,int p,ll c){
if(l==r){
mi[x]=min(mi[x],c);return;
}
if(p<=mid) upda(ls,l,mid,p,c);
else upda(rs,mid+1,r,p,c);
pushup(x);
}
ll query(int x,int l,int r,int L,int R){
if(L<=l&&r<=R){
return mi[x];
}
ll ret=inf;
if(L<=mid) ret=min(ret,query(ls,l,mid,L,R));
if(mid<R) ret=min(ret,query(rs,mid+1,r,L,R));
return ret;
}
}sg[2];
ll dp(){
memset(f,0x3f,sizeof f);
memset(s,0,sizeof s);
sg[0].build(1,1,n);sg[1].build(1,1,n);
s[0]=0;s[1]=abs(x[1]-B);
for(reg i=2;i<=q;++i) s[i]=s[i-1]+abs(x[i]-x[i-1]);
sg[0].upda(1,1,n,A,-A);
sg[1].upda(1,1,n,A,A);
ll mi=0;
for(reg i=1;i<=q;++i){
if(i==q){
return s[i]+mi;
}else{
f[i]=min(sg[0].query(1,1,n,1,x[i+1])+x[i+1]+s[i],sg[1].query(1,1,n,x[i+1],n)-x[i+1]+s[i]);
sg[0].upda(1,1,n,x[i],f[i]-s[i+1]-x[i]);
sg[1].upda(1,1,n,x[i],f[i]-s[i+1]+x[i]);
mi=min(mi,f[i]-s[i+1]);
}
}
return 23333;
}
int main(){
rd(n);rd(q);rd(A);rd(B);
for(reg i=1;i<=q;++i) rd(x[i]);
ll ans=dp();swap(A,B);ans=min(ans,dp());
printf("%lld\n",ans);
return 0;
}
}
signed main(){
Miracle::main();
return 0;
}
/*
Author: *Miracle*
*/ | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> iint;
typedef pair<ll,ll> llll;
#define ALL(x) (x).begin(),(x).end()
const ll zero = 0;
const ll INF = 3000000000000000000; //10^18
const int inINF = 1000000000; //10^9
const ll MOD = 1000000007; //10^9+7
const ll MOD2 = 998244353;
void Yes() {printf("Yes\n");}
void No() {printf("No\n");}
void YES() {printf("YES\n");}
void NO() {printf("NO\n");}
//N点連結グラフの二部グラフ判定
//Gはグラフの隣接リスト表現
//colorは大きさNの配列。二部グラフだったとき、独立集合がここに返ってくる
//vは探索を始める点。cは探索を始める点に塗る色
//vと同じ独立集合に含まれる点はcに塗られ、そうでない点は-cに塗られる
//colorは先に0で埋めておく
bool is_bipartite_graph (vector<vector<int>> &G, vector<int> &color, int v, int c){
color[v] = c;
for (int next_v : G[v]){
if(color[next_v] == c){
return false;
}
if(color[next_v] == 0 && !is_bipartite_graph(G, color, next_v, -c)){
return false;
}
}
return true;
}
int main(){
ll N, M;
cin >> N >> M;
vector<vector<int>> G(N);
int x, y;
for (int i = 0; i < M; i++) {
cin >> x >> y; x--; y--;
G[x].push_back(y);
G[y].push_back(x);
}
vector<int> color(N, 0);
if(is_bipartite_graph(G, color, 0, 1)){
ll a, b;
a = 0; b = 0;
for (int i = 0; i < N; i++) {
if(color[i] == 1){
a++;
}
else{
b++;
}
}
printf("%lld\n", a*b - M);
}
else{
printf("%lld\n", (N-1)*N/2 - M);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 20123, INF = 5012345, MOD = 1000 * 1000 * 1000 + 7;
int inv[INF], fict[INF], invf[INF], dp[MN][MN];
void fact() {
fict[0] = inv[0] = invf[0] = 1;
fict[1] = inv[1] = invf[1] = 1;
for (int i = 2; i < INF; i++) {
inv[i] = 1ll * inv[MOD % i] * (MOD - MOD / i) % MOD;
fict[i] = 1ll * fict[i - 1] * i % MOD;
invf[i] = 1ll * invf[i - 1] * inv[i] % MOD;
}
}
int chose(int a, int b) {
return 1ll * fict[b] * invf[a] % MOD * invf[b - a] % MOD;
}
int main() {
fact();
int n, k;
cin >> n >> k;
if (k == 1)
return cout << 1, 0;
dp[0][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= n; j++) {
if (j > i)
continue;
dp[i][j] = dp[i - 1][j];
if (j)
dp[i][j] = (dp[i][j] + 1ll * dp[i][j - 1] * chose(k - 2, n * k - (j - 1) * (k - 1) - i - 1) % MOD) % MOD;
}
cout << 1ll * dp[n][n] * fict[n] % MOD;
}
| #include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define space putchar(' ')
#define enter putchar('\n')
#define eps 1e-10
#define MAXN 100005
//#define ivorysi
using namespace std;
typedef long long int64;
typedef unsigned int u32;
typedef double db;
template<class T>
void read(T &res) {
res = 0;T f = 1;char c = getchar();
while(c < '0' || c > '9') {
if(c == '-') f = -1;
c = getchar();
}
while(c >= '0' && c <= '9') {
res = res * 10 +c - '0';
c = getchar();
}
res *= f;
}
template<class T>
void out(T x) {
if(x < 0) {x = -x;putchar('-');}
if(x >= 10) {
out(x / 10);
}
putchar('0' + x % 10);
}
const int MOD = 1000000007;
int fac[10000005],invfac[10000005];
int dp[2005][2005],N,K,sum[2005];
int inc(int a,int b) {
return a + b >= MOD ? a + b - MOD : a + b;
}
int mul(int a,int b) {
return 1LL * a * b % MOD;
}
void update(int &x,int y) {
x = inc(x,y);
}
int C(int n,int m) {
if(n < m) return 0;
return mul(fac[n],mul(invfac[m],invfac[n - m]));
}
int Query(int n,int m) {
return C(n + m - 1,m - 1);
}
int fpow(int x,int c) {
int res = 1,t = x;
while(c) {
if(c & 1) res = mul(res,t);
t = mul(t,t);
c >>= 1;
}
return res;
}
void Solve() {
read(N);read(K);
if(K == 1) {puts("1");return;}
fac[0] = 1;
for(int i = 1 ; i <= 10000000 ; ++i) fac[i] = mul(fac[i - 1],i);
invfac[10000000] = fpow(fac[10000000],MOD - 2);
for(int i = 9999999 ; i >= 0 ; --i) invfac[i] = mul(invfac[i + 1],i + 1);
dp[1][0] = 1;
for(int i = 2 ; i <= N ; ++i) {
int t = (i - 1) * K;
for(int j = N ; j >= 0 ; --j) sum[j] = inc(sum[j + 1],dp[i - 1][j]);
for(int j = 0 ; j <= i ; ++j) {
update(dp[i][j],mul(sum[max(0,j - 1)],Query(K - 2,t - j + 1)));
}
}
int ans = 0;
for(int j = 0 ; j <= N ; ++j) update(ans,mul(dp[N][j],fac[N]));
out(ans);enter;
}
int main() {
#ifdef ivorysi
freopen("f1.in","r",stdin);
#endif
Solve();
return 0;
} | 1 |
#include <cstdio>
int main() {
int a, b, c, d, e, tot = 0;
scanf("%d%d%d%d%d", &a, &b, &c, &d, &e);
if (c < a) c += 24;
tot += (c - a) * 60 + (d - b);
printf("%d", tot - e);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int a, b;
cin >> a >> b;
int ans;
if (a == b) {
ans = a + b;
} else {
int mx = max(a, b);
ans = mx + mx - 1;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int N;
ll A, B;
cin >> N >> A >> B;
ll X[N];
for (int i = 0; i < N; i++) {
cin >> X[i];
}
ll e[N- 1];
for (int i = 0; i < N - 1; i++) {
e[i] = X[i + 1] - X[i];
}
ll ans = 0;
for (int i = 0; i < N - 1; i++) {
if (e[i] * A < B) ans += e[i] * A;
else ans += B;
}
cout << ans << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
#define pb push_back
#define f(i,n) for(i=0;i<n;i++)
#define F(i,a,b) for(i=a;a<=b;i++)
#define arr(a,n) for( i=0;i<n;i++)cin>>a[i];
#define fi first
#define se second
#define mp make_pair
#define mod 1000000007
#define YES cout<<"YES"<<endl;
#define Yes cout<<"Yes"<<endl;
#define NO cout<<"NO"<<endl;
#define No cout<<"No"<<endl;
#define yes cout<<"yes"<<endl;
#define no cout<<"no"<<endl;
#define vi vector<ll>
#define ed end()
#define bg begin()
#define sz size()
#define ln length()
#define s() sort(a,a+n);
#define sr() sort(a,a+n,greater<ll>());
#define v() sort(v.begin(),v.end());
#define vr() sort(v.begin(),v.end(),greater<ll>());
#define mod 1000000007
#define fast() ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
ll gcd(ll a, ll b){if(!b)return a;return gcd(b, a % b);}
ll power(ll x,ll y,ll p){ll res=1;x%=p;while(y>0){if(y&1)res=(res*x)%p;y=y>>1;x=(x*x)%p;}return res;}
int main() {
/*#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif*/
/*
Ofcourse it's Hard.
It's supposed to be Hard.
If it's easy everyone would do it.
HARD IS WHAT MAKES IT GREAT
YESTERDAY U SAID TOMORROW
SLOWLY BECOMING THE PERSON I
SHOULD HAVE BEEN A LONG TIME AGO
SAME TASK CAN'T BE FOUND DIFFICULT TWICE
BTBHWSITW
SPRH TU KAB P
CP IS ALL ABOUT THINKING
YOU HAVE MUCH MORE POTENTIAL THAN U THINK
AJIT SHIDDAT 10
UR DAILY ROUTINE
*/
fast();
//ll t;cin>>t;while(t--)
{
ll n,t,s=0;
cin>>n>>t;
ll a[n];
for(int i=0;i<n;i++)
{
cin>>a[i];
}
for(int i=1;i<n;i++)
{
s+=min(t,a[i]-a[i-1]);
}
cout<<s+t<<endl;
}
return 0;
} | 0 |
#include <iostream>
#include <algorithm>
using namespace std;
bool Bsearch(int key, int A[], int len) {
int l = 0, r = len - 1;
while (l <= r) {
int mid = l + (r - l) / 2;
if (A[mid] > key)
r = mid - 1;
else if (A[mid] < key)
l = mid + 1;
else
return true;
}
return false;
}
int main() {
int n, *S;
int q, *T;
int ans = 0;
cin >> n;
S = new int[n];
for (int i = 0; i < n; i++)
cin >> S[i];
cin >> q;
T = new int[q];
for (int i = 0; i < q; i++)
cin >> T[i];
sort(S, S + n);
for (int i = 0; i < q; i++)
for (int j = 0; j < n; j++)
if (Bsearch(T[i], S, n) == true) {
ans++;
break;
}
cout << ans << endl;
delete[] S;
delete[] T;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
using namespace std;
int ar_s[10000];
bool linear_search(int t, int n){
int c = 0;
for (int i = 0; i < n; i++) {
if (ar_s[i] == t) return true;
}
return false;
}
int main(int argc, char const* argv[])
{
int n,q, c = 0;
scanf("%d ", &n);
for (int i = 0; i < n; i++) {
scanf("%d ", &ar_s[i]);
}
scanf("%d ", &q);
for (int i = 0; i < q; i++) {
int t;
scanf("%d ", &t);
linear_search(t, n) ? ++c : 0;
}
printf("%d\n", c);
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
#include <string>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
int n, k, d[4019][4019] = {1}, p[4019] = {1};
cin >> k >> n;
for (int i = 1; i <= 4000; i++) {
d[i][0] = 1;
for (int j = 1; j <= i; j++) {
d[i][j] = d[i - 1][j - 1] + d[i - 1][j];
if (d[i][j] >= 998244353) d[i][j] -= 998244353;
}
p[i] = p[i - 1] + p[i - 1];
if (p[i] >= 998244353) p[i] -= 998244353;
}
for (int i = 2; i <= k + k; i++) {
ll z = 0;
int a, b, c;
if (i % 2) c = 0;
else c = 1;
if (i <= k) b = (i - 1) / 2;
else b = (k + k + 1 - i) / 2;
a = k - b - b - c;
//cout << a << ' ' << b << ' ' << c << ' ';
for (int j = 0; j <= b; j++) {
if (n >= j) z = (z + 1ll * d[n + a - 1][n - j] * d[b][j] % 998244353 * p[j]) % 998244353;
if (c && n > j) z = (z + 1ll * d[n + a - 2][n - j - 1] * d[b][j] % 998244353 * p[j]) % 998244353;
}
cout << z << '\n';
}
}
| #include<bits/stdc++.h>
#define mod 998244353
#define maxn 1000005
using namespace std;
typedef long long LL;
int read()
{
char c=getchar();int f=1,sum=0;
while(c<'0' || c>'9'){if(c=='-')f=-1;c=getchar();}
while(c>='0' && c<='9'){sum=sum*10+c-'0';c=getchar();}
return sum*f;
}
int n,m;
LL fac[maxn],inv[maxn],ans;
LL ksm(LL a,LL b){LL ret=1;while(b){if(b&1) ret=ret*a%mod;a=a*a%mod;b>>=1;}return ret;}
void init(int x)
{
fac[0]=1;
for(int i=1;i<=x;i++) fac[i]=fac[i-1]*i%mod;
inv[x]=ksm(fac[x],mod-2);
for(int i=x;i>=1;i--) inv[i-1]=inv[i]*i%mod;
}
LL calc(LL x,LL y){return fac[x+y]*inv[x]%mod*inv[y]%mod;}
int main()
{
n=read();m=read();
if(n>m) swap(n,m);
init(n+m);
for(int i=1;i<=n;i++) ans+=calc(i,i)*calc(n-i,m-i)%mod;
ans=ans%mod*ksm(calc(n,m)<<1,mod-2)%mod;
printf("%lld\n",(ans+m)%mod);
return 0;
}
| 0 |
#include <iostream>
#include <fstream>
#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <functional>
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
using namespace std;
#define ll long long int
#define rep(i,n) for( int i = 0; i < n; i++ )
#define rrep(i,n) for( int i = n; i >= 0; i-- )
#define REP(i,s,t) for( int i = s; i <= t; i++ )
#define RREP(i,s,t) for( int i = s; i >= t; i-- )
#define dump(x) cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define mod 1000000007
#define INF2 1000000000000000000
#define int long long
signed main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
string S; cin >> S;
S = "00" + S;
int N = S.length();
int ans = 0;
for(int i = N - 1; i >= 0; i--) {
if(S[i] > '9') {
S[i - 1]++;
S[i] -= 10;
}
if(S[i] <= '4' || (S[i] == '5' && S[i - 1] < '5')) {
ans += S[i] - '0';
} else {
ans += 10 - (S[i] - '0');
S[i - 1]++;
}
}
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cmath>
#include <numeric>
#include <iomanip>
#include <stack>
#include <complex>
#include <functional>
#include <tuple>
using namespace std;
#define Rep(i,a,b) for(ll i = a; i < b; ++i)
#define rep(i,b) Rep(i,0,b)
#define allof(a) (a).begin(), (a).end()
#define Yes(q) ((q) ? "Yes" : "No")
#define YES(q) ((q) ? "YES" : "NO")
#define Possible(q) ((q) ? "Possible" : "Impossible")
#define POSSIBLE(q) ((q) ? "POSSIBLE" : "IMPOSSIBLE")
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll infll = 1ll << 60ll;
constexpr ll mod = 998244353;
// 0~3までは右下左上 4~7までは斜め
constexpr int dx[] = { 1, 0, -1, 0, 1, 1, -1, -1 };
constexpr int dy[] = { 0, 1, 0, -1, -1, 1, 1, -1 };
namespace {
template<typename T> bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<typename T> bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
void Cout(long long x, const char* end = "\n") { std::cout << x << end; }
template <typename T> void Cout(const T& x, const char* end = "\n") { std::cout << x << end; }
template <typename T> void Cout(const std::vector<T>& x, const char* sep = " ", const char* end = "\n") { for (std::size_t i = 0, sz = x.size(); i < sz; ++i) { std::cout << x[i] << (i == sz - 1 ? end : sep); } }
// 標準入出力
struct inp {
std::size_t szi, szj;
inp(std::size_t _szi = 1, std::size_t _szj = 1) : szi(_szi), szj(_szj) {}
template <typename T> operator T () const { T a; std::cin >> a; return a; }
template <typename T> operator std::vector<T>() const { std::vector<T> a(szi); for (std::size_t i = 0; i < szi; ++i) std::cin >> a[i]; return a; }
template <typename T> operator std::vector<std::vector<T>>() const {
std::vector<std::vector<T>> a(szi, std::vector<T>(szj));
for (std::size_t i = 0; i < szi; ++i) for (std::size_t j = 0; j < szj; ++j) cin >> a[i][j]; return a;
}
};
inp inp1;
}
int main() {
string s = inp1;
s = '0' + s;
int n = s.size();
vector<vector<int>> dp(n + 1, vector<int>(2, inf));
dp[0][0] = 0;
rep(i, n) {
int num = s[i] - '0';
// ピッタリ払う
chmin(dp[i + 1][0], dp[i][0] + num);
chmin(dp[i + 1][0], dp[i][1] + 10 - num);
// 余分に払う
chmin(dp[i + 1][1], dp[i][0] + num + 1);
chmin(dp[i + 1][1], dp[i][1] + 10 - num - 1);
}
Cout(dp[n][0]);
return 0;
}
| 1 |
#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(){
string S; cin>>S;
cout<<S.substr(0,S.size()-8)<<endl;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main() {
cin.tie(0)->sync_with_stdio(false);
string s; cin >> s;
int n = s.size();
REP(i, n - 8)
cout << s[i];
cout << '\n';
return 0;
} | 1 |
#include <iostream>
using namespace std;
int main(int argc, char** argv){
int n, pm, pe, pj;
while( 1 ){
cin >> n;
if(n==0) break;
for(int i=0; i<n; i++){
cin >> pm;
cin >> pe;
cin >> pj;
if(pm==100 || pe==100 || pj==100){
cout << "A" << endl;
continue;
}
if((pm+pe) / 2 >= 90){
cout << "A" << endl;
continue;
}
int avg = (pm + pe + pj) / 3;
if(avg >= 80){
cout << "A" <<endl;
continue;
}
if(avg >= 70){
cout << "B" << endl;
continue;
}
if(avg>=50 && pm>=80){
cout << "B" << endl;
continue;
}
cout << "C" << endl;
}
}
return 0;
} | #include<iostream>
#include<string>
#include<vector>
#include<utility>
#include<queue>
#include<algorithm>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<map>
#include<complex>
#define INF 2147483647
#define llINF 9223372036854775807
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define ll long long
using namespace std;
int main(){
int n;
while(cin>>n,n){
const double Inf=1e9;
vector<pair<double,string> >vegi;
for(int i=0;i<n;i++){
string str;cin>>str;
double a,b,c,d,e,f,g,h,m;
cin>>a>>b>>c>>d>>e>>f>>g>>h>>m;
double time=b+c+d+m*(e+f);
int value=m*h*g-a;
vegi.pb(mp(Inf-(value/time),str));
}
sort(vegi.begin(),vegi.end());
for(int i=0;i<n;i++)
cout<<vegi[i].S<<endl;
cout<<"#"<<endl;
}
return 0;
}
| 0 |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<iomanip>
using namespace std;
int main(){
int n,m,x,y;
cin>>n>>m>>x>>y;
int minx=200,miny=200,maxx=-200,maxy=-200;
for(int i=0;i<n;i++){
int a;
cin>>a;
maxx=max(maxx,a);
minx=min(minx,a);
}
for(int i=0;i<m;i++){
int a;
cin>>a;
maxy=max(maxy,a);
miny=min(miny,a);
}
if(maxx<miny&&maxx<y&&miny>x)cout<<"No War"<<endl;
else cout<<"War"<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 1000000007
#define pii pair<ll,ll>
#define debug(a) { cout << #a << " = " << a << endl;}
void sep() {
cout << "-------------BLOCK-----------------\n";
}
template<typename T>
void debugv(vector<T> arr) {
for (auto t: arr)
cout << t << " ";
cout << "\n";
}
template<typename T>
void debugarr(T arr, int n) {
for (int i=0;i<n;i++) cout << arr[i] << " ";
cout << "\n";
}
const int maxn = 2e5+1;
ll arr1[maxn], n, m, t, k;
ll arr2[maxn];
unordered_map<ll,ll> u;
ll __min(ll a, ll b) {
return a < b ? a : b;
}
ll __max(ll a, ll b) {
return a > b ? a : b;
}
void par(int n) {
cout << "Yes\n";
for (int i=0;i<n;i++) cout << arr2[i] << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin>>n;
for (int i=0;i<n;i++) cin>>arr1[i];
for (int i=0;i<n;i++) cin>>arr2[i];
reverse(arr2,arr2+n);
ll l=n+1,r=n+1;
for (int i=0;i<n;i++) {
if (arr1[i]==arr2[i]) {
if (l == n+1) l = i, r=i;
else r = i;
}
}
if (l == n+1) {
par(n);
return 0;
}
ll sl=l,sr=r;
ll pl=l,pr=r;
while (sl >=0 && arr1[sl] == arr1[l]) sl--;
while (sr < n && arr1[sr] == arr1[r]) sr++;
while (pl >=0 && arr2[pl] == arr2[l]) pl--;
while (pr < n && arr2[pr] == arr2[r]) pr++;
sl=__min(sl,pl);
sr=__max(sr,pr);
ll i=0;
ll j=n-1;
ll sll=l;
while (i<=sl && l <= r) {
ll t=arr2[i];
arr2[i++]=arr2[l];
arr2[l++]=t;
}
while (j >= sr && r >= l) {
ll t=arr2[j];
arr2[j--]=arr2[r];
arr2[r--]=t;
}
bool pos=true;
for (int i=0;i<n;i++)
if (arr2[i] == arr1[i]) {
pos=false;
break;
}
if (pos) par(n);
else cout << "No\n";
}
| 0 |
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main()
{
int n;
cin >> n;
vector<pair<int, int>> red;
vector<pair<int, int>> blue;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
red.emplace_back(b, a);
}
for (int i = 0; i < n; i++) {
int c, d;
cin >> c >> d;
blue.emplace_back(c, d);
}
sort(red.begin(), red.end(), greater<pair<int, int>>());
sort(blue.begin(), blue.end());
int ans = 0;
for (auto bit = blue.begin(); bit != blue.end(); bit++) {
auto it = red.begin();
while (it != red.end()) {
if (it->first < bit->second && it->second < bit->first) {
ans++;
red.erase(it);
break;
}
it++;
}
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
#define U(v) cerr << #v << ": " << (v) << endl
template <class T>
struct BIT {
vector<T> a;
BIT(int size) : a(size, 0) {}
T sum(int r) const {
T sm = 0;
for (--r; r >= 0; r = (r & r + 1) - 1)
sm += a[r];
return sm;
}
T sum(int l, int r) const {
return sum(r) - sum(l);
}
T at(int i) const {
return sum(i, i + 1);
}
void add(int i, T v) {
for (; i < (int)a.size(); i |= i + 1)
a[i] += v;
}
void set(int i, T v) {
add(i, v - at(i));
}
};
int main() {
int n;
cin >> n;
vector<int> a(n);
vector<pair<int, int>> b(n);
for (int i = 0; i < n; ++i) {
cin >> b[i].first;
b[i].second = i;
}
sort(b.begin(), b.end());
for (int i = 0; i < n; ++i)
a[b[i].second] = i;
BIT<int> bit(n);
long long sm = 0;
for (int i = n - 1; i >= 0; --i) {
sm += bit.sum(a[i]);
bit.add(a[i], 1);
}
cout << sm << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int MOD=1000000007;
int n,k;
LL fac[4000000],inv_fac[4000000],dp[2001];
void check_mod(LL &a) { if (a>=MOD) a%=MOD; }
int ksm(LL a, int b)
{
LL ret=1ll;
while (b) {
if (b&1) ret*=a;
check_mod(ret);
a*=a;
check_mod(a);
b>>=1;
}
return ret;
}
int main()
{
LL lt;
int t;
scanf("%d%d",&n,&k);
if (k==1) {
printf("1\n");
return 0;
}
fac[0]=1;
t=n*k;
for (int i = 1; i < t; ++i) {
fac[i]=1ll*i*fac[i - 1];
check_mod(fac[i]);
}
inv_fac[t-1]=ksm(fac[t-1],MOD-2);
for (int i=t-2;i;--i) {
inv_fac[i]=1ll*(i+1)*inv_fac[i+1];
check_mod(inv_fac[i]);
}
inv_fac[0]=1;
dp[0]=1;
t=-2;
for (int i=1;i<=n;++i) {
t+=k-1;
for (int j=0;j<=i;++j) {
++t;
lt=fac[t]*inv_fac[t-k+2];
check_mod(lt);
lt*=inv_fac[k-2];
check_mod(lt);
dp[j]*=lt;
if (j) dp[j]+=dp[j - 1];
check_mod(dp[j]);
}
t-=i+1;
}
printf("%lld\n",dp[n]*fac[n]%MOD);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 1e9+7;
void add(int64_t& a, int64_t b){
a = (a+b) % MOD;
}
void mul(int64_t& a, int64_t b){
a = a*b % MOD;
}
vector<int64_t> fact, seq_inv, fact_inv;
void create_fact_mod(int num){
fact[0] = fact[1] = 1;
for(int i=2; i<=num; i++) fact[i] = fact[i-1] * i % MOD;
}
void create_seq_inv_mod(int num){
seq_inv[0] = seq_inv[1] = 1;
for(int i=2; i<=num; i++) seq_inv[i] = (MOD - MOD/i) * seq_inv[MOD%i] % MOD;
}
void create_fact_inv_mod(int num){
fact_inv[0] = fact_inv[1] = 1;
for(int i=2; i<=num; i++) fact_inv[i] = fact_inv[i-1] * seq_inv[i] % MOD;
}
void create_mod_tables(int num){
fact.resize(num+1);
seq_inv.resize(num+1);
fact_inv.resize(num+1);
create_fact_mod(num);
create_seq_inv_mod(num);
create_fact_inv_mod(num);
}
int64_t comb_mod(int n, int k){
return fact[n] * fact_inv[n-k] % MOD * fact_inv[k] % MOD;
}
int main(){
int N, K;
cin >> N >> K;
if(K == 1){
cout << 1 << endl;
return 0;
}
create_mod_tables(N*K);
static int64_t dp[2001][2001];
dp[0][0] = fact[N];
for(int i=0; i<=N; i++) for(int j=0; j<=i; j++){
if(i<N) add(dp[i+1][j], dp[i][j]);
if(i>=j+1) add(dp[i][j+1], dp[i][j] * comb_mod(N*K - i - j*(K-1) - 1, K-2));
}
cout << dp[N][N] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
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 << "Left" << endl;
}
else {
cout << "Right" << endl;
}
return 0;
} | #include<iostream>
#include<iomanip>
#include<vector>
#include<map>
#include<stack>
#include<queue>
#include<string>
#include<utility>
#include<numeric>
#include<algorithm>
#include<cmath>
#include<climits>
using namespace std;
using ll = long long;
class Stream{
public:
Stream(){
}
//配列以外の入力を受け取る
void read(){
}
template<typename First, typename... Rest>
void read(First& first, Rest&... rest){
cin >> first;
read(rest...);
}
//配列を区切って出力する
template<typename T>
void write_vec(vector<T>& v, char divider){
for(size_t i = 0; i < v.size(); i++){
cout << v[i] << divider;
}
}
};
int main(){
Stream io;
int A, B, C, D;
io.read(A, B, C, D);
string ans;
if(A + B < C + D){
ans = "Right";
}
else if(A + B == C + D){
ans = "Balanced";
}
else{
ans = "Left";
}
cout << ans;
return 0;
} | 1 |
#include <iostream>
using namespace std;
int main() {
string S,T;
cin>>S>>T;
cout<<T+S;
return 0;
}
| #include<stdio.h>
int main(){
char S[100], T[100];
scanf("%s %s", S, T);
printf("%s%s\n", T, S);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define rep(i, n) FOR(i, 0, n)
#define whole(x) (x).begin(),(x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
using P = pair<int, int>;
#define debug(var) cerr << "[" << #var << "] " << var << endl
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
const ll mod = 1000000007;
const int dx[] = {-1,0,1,0};
const int dy[] = {0,-1,0,1};
vector<int> v[505];
int main(){
int n, m, Q;
cin >> n >> m >> Q;
rep(i, m) {
int l, r;
cin >> l >> r;
l--; r--;
v[l].push_back(r);
}
rep(i, n) {
sort(whole(v[i]));
}
rep(qi, Q) {
int p, q;
cin >> p >> q;
p--; q--;
int ans = 0;
for (int i=p; i<=q; i++) {
auto it = upper_bound(whole(v[i]), q);
ans += (it-v[i].begin());
}
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
ll N, M, Q, L, R;
cin >> N >> M >> Q;
vector<vector<ll>> sum(N+1, vector<ll>(N+1));
rep(i,M) {
cin >> L >> R;
++sum[L][R];
}
rep(i,N) rep(j,N) sum[i+1][j+1] += sum[i+1][j];
for (int i = 1; i <= N; ++i) {
for (int j = N - 1; j > 0; --j) {
sum[j][i] += sum[j+1][i];
}
}
vector<ll> p(Q), q(Q);
rep(i,Q) cin >> p[i] >> q[i];
rep(i,Q) cout << sum[p[i]][q[i]] << endl;
}
| 1 |
#include <iostream>
#include <vector>
#include <queue>
#include <map>
#define INF (int)1e9
void dijkstra(int m, int p, int q, std::vector<std::vector<std::pair<int, int> > > &v);
int main(void) {
int n;
int m;
int a;
int b;
int cost;
int time;
int k;
int p;
int q;
int r;
while (true) {
std::cin >> n >> m;
if (n == 0 && m == 0) {
break;
}
std::vector<std::vector<std::pair<int, int> > > vcost(m);
std::vector<std::vector<std::pair<int, int> > > vtime(m);
for (int i = 0; i < n; i++) {
std::cin >> a >> b >> cost >> time;
--a;
--b;
vcost[a].push_back(std::make_pair(cost, b));
vcost[b].push_back(std::make_pair(cost, a));
vtime[a].push_back(std::make_pair(time, b));
vtime[b].push_back(std::make_pair(time, a));
}
std::cin >> k;
for (int i = 0; i < k; i++) {
std::cin >> p >> q >> r;
--p;
--q;
if (r == 0) {
dijkstra(m, p, q, vcost);
} else {
dijkstra(m, p, q, vtime);
}
}
} return 0;
}
void dijkstra(int m, int p, int q, std::vector<std::vector<std::pair<int, int> > > &v) {
std::vector<int> rvec(m, INF);
rvec[p] = 0;
std::priority_queue<std::pair<int, int>, std::vector<std::pair<int, int> >, std::greater<std::pair<int, int> > > pq;
std::vector<int> search_count(m, 0);
int start_value;
int start_target;
int end_value;
int end_target;
pq.push(std::make_pair(rvec[p], p));
while(! pq.empty()) {
start_target = pq.top().second;
start_value = pq.top().first;
pq.pop();
if (search_count[start_target] != 0) {
continue;
}
++search_count[start_target];
for (int i = 0; i < v[start_target].size(); i++) {
end_value = v[start_target][i].first;
end_target = v[start_target][i].second;
if (rvec[end_target] > end_value + rvec[start_target]) {
rvec[end_target] = end_value + rvec[start_target];
pq.push(std::make_pair(rvec[end_target], end_target));
}
}
}
std::cout << rvec[q] << std::endl;
return;
} | #include <iostream>
using namespace std;
#define INF 10000000
int t[101][101], s[101][101];
int main(void){
int n,m;
while(cin>>n>>m, n){
for(int i=0;i<=m;i++) for(int j=0;j<=m;j++) t[i][j] = s[i][j] = INF;
for(int i=0;i<n;i++){
int a,b,cost,time;
cin>>a>>b>>cost>>time;
t[a][b] = t[b][a] = cost;
s[a][b] = s[b][a] = time;
}
for(int k=1;k<=m;k++){
for(int i=1;i<=m;i++){
for(int j=1;j<=m;j++){
t[i][j] = min(t[i][j],t[i][k]+t[k][j]);
s[i][j] = min(s[i][j],s[i][k]+s[k][j]);
}
}
}
cin>>n;
while(n--){
int a,b,flg;
cin>>a>>b>>flg;
cout<<(flg?s[a][b]:t[a][b])<<endl;
}
}
return 0;
} | 1 |
#include<iostream>
#include<queue>
using namespace std;
#define REP(i, n) for(int i=0; i<n; i++)
typedef struct{
int idx[3];
}int3;
typedef struct{
int status[20][20];
}int20;
typedef vector<pair<int, int > > vecpair;
int20 map;
int dir[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
int w, h;
pair<int3, vecpair> move(int3 cidx, int d[2], vecpair cstatus){
pair<int3, vecpair> output;
int3 nidx;
vecpair nstatus = cstatus;
int ch = cidx.idx[0];
int cw = cidx.idx[1];
int cs;
int20 cmap;
cmap = map;
REP(i, cstatus.size()){
cmap.status[cstatus[i].first][cstatus[i].second] = 0;
}
if(cmap.status[ch+d[0]][cw+d[1]]==1){
nidx.idx[0] = -1;
nidx.idx[1] = -1;
nidx.idx[2] = -1;
output = make_pair(nidx, nstatus);
return output;
}
REP(i, 20){
ch += d[0];
cw += d[1];
if(ch<0 || ch>=h || cw<0 || cw>=w || cidx.idx[2]+1 > 10){
nidx.idx[0] = -1;
nidx.idx[1] = -1;
nidx.idx[2] = -1;
output = make_pair(nidx, nstatus);
return output;
} else {
cs = cmap.status[ch][cw];
}
if(cs == 0){
continue;
} else if(cs == 1){
nstatus.push_back(make_pair(ch, cw));
nidx.idx[0] = ch - d[0];
nidx.idx[1] = cw - d[1];
nidx.idx[2] = cidx.idx[2] + 1;
output = make_pair(nidx, nstatus);
return output;
} else if(cs == 3){
nidx.idx[0] = ch;
nidx.idx[1] = cw;
nidx.idx[2] = cidx.idx[2] + 1;
output = make_pair(nidx, nstatus);
return output;
}
}
}
int main(){
while(1){
cin >> w >> h;
if(w==0){
break;
}
int3 s;
int g[2];
REP(i, h){
REP(j, w){
cin >> map.status[i][j];
if(map.status[i][j] == 2){
s.idx[0] = i;
s.idx[1] = j;
s.idx[2] = 0;
} else if(map.status[i][j] == 3){
g[0] = i;
g[1] = j;
}
}
}
queue<int3> qidx;
queue<vector<pair<int, int> > > qstatus;
vector<pair<int, int> > init;
qidx.push(s);
qstatus.push(init);
int output = -1;
while(!qidx.empty()){
int3 cidx = qidx.front();
qidx.pop();
vecpair cstatus = qstatus.front();
qstatus.pop();
REP(i, 4){
int3 nidx;
vecpair nstatus;
pair<int3, vecpair> next = move(cidx, dir[i], cstatus);
nidx = next.first;
nstatus = next.second;
if(nidx.idx[0] == g[0] && nidx.idx[1] == g[1]) {
output = nidx.idx[2];
queue<int3> empty;
swap(qidx, empty);
break;
} else if(nidx.idx[0] >= 0){
qidx.push(nidx);
qstatus.push(nstatus);
}
}
}
cout << output << endl;
}
} | //#define _GRIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
// ?????¬???????????¬??????
#pragma region MACRO
#define P(x) cout << (x) << endl
#define p(x) cout << (x)
#define PED cout << "\n"
#define rep(i,n) for(int i=0; i<(int)n; ++i)
#define REP(i,x,n) for(int i=x; i<(int)n; ++i)
#define repi(i,n) for(int i=0; i<=(int)n; ++i)
#define REPI(i,x,n) for(int i=x; i<=(int)n; ++i)
#define ILP while(true)
#define FOR(i,c) for(__typeof((c).begin())!=(c).begin(); i!=(c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define mp make_pair
#pragma endregion
// ???
#pragma region TYPE_DEF
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<string, string> pss;
typedef pair<string, int> psi;
typedef pair<int, string> pis;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long double> vld;
typedef vector<long> vl;
typedef vector<long long> vll;
typedef vector<string> vs;
#pragma endregion
// Effective std
#pragma region ESTD
template<typename C, typename T> int count(C& c, T t) { return count(ALL(c), t); }
template<typename C, typename F> int count_if(C& c, F f) { return count_if(ALL(c), f); }
template<typename C, typename T> void erase(C& c, T t) { remove(ALL(c), t), c.end(); }
template<typename C> void remove(vector<C>& c, unsigned int index) { c.erase(c.begin()+index); }
template<typename C, typename T, typename U> void replace(C& c, T t, U u) { replace(ALL(c), t, u); }
template<typename C, typename F, typename U> void replace_if(C& c, F f, U u) { (ALL(c), f, u); }
template<typename C> void reverse(C& c) { reverse(ALL(c)); }
template<typename C> void sort(C& c) { sort(ALL(c)); }
template<typename C, typename Pred> void sort(C& c, Pred p) { sort(ALL(c), p); }
#pragma endregion
// ?????°
#pragma region CONST_VAL
constexpr int PI = (2*acos(0.0));
constexpr int EPS = (1e-9);
constexpr int MOD = (int)(1e9+7);
constexpr int INF = 100000000;
#pragma endregion
bool is_small(int h1, int w1, int h2, int w2) {
int d1 = h1*h1 + w1*w1;
int d2 = h2*h2 + w2*w2;
if(d1 < d2) return true;
else if(d1 > d2) return false;
else if(h1<h2) return true;
else return false;
}
int main()
{
int h, w;
while(cin>>h>>w, h) {
int mh = 151;
int mw = 151;
for(int i=1; i<=150; ++i) {
for(int j=i+1; j<=150; ++j) {
if(i==h&&j==w) continue;
if(is_small(i,j,h,w)) continue;
if(is_small(i,j,mh,mw)) {
mh = i;
mw = j;
}
}
}
cout << mh << " " << mw << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define gc( ) std::getchar( )
#define pc( i ) std::putchar( i )
template < typename T >
inline T read( )
{
register T x = 0;
register char ch = gc( );
register bool f = 0;
while( !std::isdigit( ch ) )
{
f = ( ch == '-' );
ch = gc( );
}
while( std::isdigit( ch ) )
{
x = x * 10 + ( ch - '0' );
ch = gc( );
}
return f ? -x : x;
}
template < typename T >
void print( T x )
{
if( x < 0 )
{
x = -x;
pc( '-' );
}
if( x < 10 )
{
pc( x + 48 );
return;
}
print < T > ( x / 10 );
pc( x % 10 + 48 );
return ;
}
namespace Solution
{
#define IOS std::ios::sync_with_stdio( false ), std::cin.tie( 0 ), std::cout.tie( 0 )
#define Rep( i, j, k ) for( int i = j; i >= k; --i )
#define rdi( ) read < int > ( )
#define rdl( ) read < long long > ( )
#define pti( i ) print < int > ( i ), putchar( ' ' )
#define ptl( i ) print < long long > ( i ), putchar( ' ' )
#define For( i, j, k ) for( int i = j; i <= k; ++i )
using std::cin;
using std::cout;
using std::endl;
using std::vector;
using std::map;
using std::queue;
using std::deque;
using std::set;
using std::pair;
const int Maxn = 100001;
int n, bol, L, Q, bl[ Maxn ], x[ Maxn ], to[ Maxn ], nxt[ Maxn ], out[ Maxn ];
int find( int u )
{
int l = u + 1, r = n, ans = u;
while( l <= r )
{
int mid = l + r >> 1;
if( x[ mid ] - x[ u ] <= L )
ans = mid, l = mid + 1;
else
r = mid - 1;
}
return ans;
}
int solve( int l, int r )
{
int res = 0;
while( bl[ l ] < bl[ r ] )
{
res += nxt[ l ];
l = out[ l ];
}
while( l < r )
{
res++;
l = to[ l ];
}
return res;
}
void fakemain( )
{
IOS;
cin >> n;
bol = sqrt( n );
For( i, 1, n )
cin >> x[ i ],
bl[ i ] = ( i - 1 ) / bol + 1;
cin >> L;
For( i, 1, n )
to[ i ] = find( i );
Rep( i, n - 1, 1 )
{
if( to[ i ] == n )
{
out[ i ] = n;
nxt[ i ] = 1;
}
else
{
if( to[ i ] > bol * bl[ i ] )
{
out[ i ] = to[ i ];
nxt[ i ] = 1;
}
else
{
out[ i ] = out[ to[ i ] ];
nxt[ i ] = nxt[ to[ i ] ] + 1;
}
}
}
cin >> Q;
int l, r;
while( Q-- )
{
cin >> l >> r;
if( l > r )
std::swap( l, r );
cout << solve( l, r ) << '\n';
}
return;
}
} // namespace Solution
int main( int argc, char* argv[] )
{
Solution::fakemain( );
return 0;
} | #include <bits/stdc++.h>
#define FOR(i, a, n) for(ll i = (ll)a; i < (ll)n; i++)
#define rep(i, n) FOR(i, 0, n)
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
constexpr ll mod = 1e9 + 7;
template <class T> inline bool chmax(T &a, const T b) {
if(a >= b) return false;
a = b;
return true;
}
template <class T> inline bool chmin(T &a, const T b) {
if(a <= b) return false;
a = b;
return true;
}
/*-------------------------------------------*/
ll n, l, q;
ll x[100009], nxt[100009][17];
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
cin >> n;
rep(i, n) cin >> x[i];
cin >> l;
ll y = 0;
rep(i, n) {
while(y + 1 < n && x[i] + l >= x[y + 1]) {
y++;
}
nxt[i][0] = y;
}
rep(i, 16) rep(j, n) nxt[j][i + 1] = nxt[nxt[j][i]][i];
cin >> q;
while(q--) {
ll a, b;
cin >> a >> b;
a--;
b--;
if(b < a) swap(a, b);
ll ans = 1;
for(int i = 16; i >= 0; i--) {
if(nxt[a][i] < b) {
a = nxt[a][i];
ans += 1 << i;
}
}
cout << ans << endl;
}
return 0;
} | 1 |
#pragma region
#define _USE_MATH_DEFINES
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <list>
#include <iomanip>
#include <cstdint>
#include <bitset>
using namespace std;
typedef long long ll;
//#define rep(i, s, e) for (int(i) = (s); (i) < (e); ++(i))
#define rep(i, e) for (int(i) = 0; (i) < (e); ++(i))
#define rrep(i, s) for (int(i) = (s) - 1; (i) >= 0; --(i))
#define all(x) x.begin(),x.end()
#pragma region UnionFind
struct UnionFind
{
vector<int> par;
UnionFind(int n) : par(n, -1) {}
void init(int n) { par.assign(n, -1); }
int root(int x)
{
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
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 (par[x] > par[y]) swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x)
{
return -par[root(x)];
}
};
#pragma endregion
#pragma region GCD
ll gcd(ll a, ll b)
{
if (b == 0)return a;
return gcd(b, a%b);
}
#pragma endregion
#pragma region LCM
ll lcm(ll a, ll b)
{
return a / gcd(a, b) * b;
}
#pragma endregion
#pragma region chmin
template<class T> inline bool chmin(T& a, T b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
#pragma endregion
#pragma region chmax
template<class T> inline bool chmax(T& a, T b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
#pragma endregion
#pragma endregion
int main()
{
int h, w; cin >> h >> w;
vector<string> s(h); rep(i, h)cin >> s[i];
ll res = 0;
int d[] = { 0,1,0,-1 };
vector<vector<bool>> passed(h, vector<bool>(w));
rep(i, h)rep(j, w)
{
if (s[i][j] == '.' || passed[i][j])continue;
passed[i][j] = true;
queue<pair<int, int>> q;
q.push(make_pair(i, j));
ll B = 1, W = 0;
while (!q.empty())
{
int x, y;
tie(x, y) = q.front();
q.pop();
rep(k, 4)
{
int nx = x + d[k];
int ny = y + d[k ^ 1];
if (nx < 0 || h <= nx || ny < 0 || w <= ny)continue;
if (passed[nx][ny])continue;
if (s[x][y] != s[nx][ny])
{
q.push(make_pair(nx, ny));
passed[nx][ny] = true;
if (s[nx][ny] == '.')++W;
else ++B;
}
}
}
res += B * W;
}
cout << res << endl;
} | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i=0;i<(n);++i)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define all(x) (x).begin(), (x).end()
#define PI 3.14159265358979323846264338327950L
using namespace std;
typedef long long ll;
typedef long double ld;
int main() {
int n,k;
cin>>n>>k;
vector<int> l(n);
rep(i,n) cin>>l[i];
sort(all(l));
int ans=0;
rep(i,k) ans+=l[n-1-i];
cout<<ans;
} | 0 |
#include<bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
const ll p = 998244353;
ll powmod(ll a, ll b){
if(b==0) return 1;
if(b%2==1) return (a*powmod(a,b-1)) % p;
else{
ll x = powmod(a,b/2);
return (x*x) % p;
}
}
ll combinemod(ll a, ll b){
ll x=1,y=1;
for(int i=1;i<=b;i++){
y = (y*i)%p;
}
for(int i=a-b+1;i<=a;i++){
x = (x*i)%p;
}
return (x * powmod(y,p-2)) % p;
}
int main(){
int n,m,k;
cin >> n >> m >> k;
vector<ll> dp1(k+1), dp2(k+1);
dp1.at(0) = m * powmod(m-1,n-1) % p;
dp2.at(0) = 1;
rep(i,k){
dp1.at(i+1) = m*powmod(m-1,n-1-(i+1)) % p;
dp2.at(i+1) = (dp2.at(i) * (n-i-1) % p * powmod(i+1,p-2)) % p;
}
ll tot = 0;
rep(i,k+1){
tot += dp1.at(i) * dp2.at(i) % p;
tot %= p;
}
cout << tot << endl;
return 0;
} | #include<bits/stdc++.h>
#define ll long long int
#define mod 998244353
#define ld long double
#define pb push_back
#define inf INT_MAX
#define N 1000000
using namespace std;
int n,m,k;
ll ans=0;
ll inv[N+3];
ll fact_inv[N+3];
ll fact[N+3];
//modulo inverse
void inverse(){
inv[1]=1;//MMI
int i;
for(i=2;i<=N;i++){
inv[i]=mod-(mod/i)*inv[mod%i]%mod;
}
}
void factinv(){
int i;
fact_inv[0]=1;
for(i=1;i<=N;i++){
fact_inv[i]=fact_inv[i-1]*inv[i]%mod;
}
}
void facto(){
int i;
fact[0]=1;
for(i=1;i<=N;i++){
fact[i]=(fact[i-1]*i)%mod;
}
}
ll power(int a,int b){
if(b==0)
return 1;
else if(b==1)
return a;
else{
if(b&1)
return ((a%mod)*(power(a,b-1)%mod))%mod;
else
return ((power(a,b/2)%mod)*(power(a,b/2)%mod))%mod;
}
}
void solve(int p){
ll a=((fact_inv[n-p-1]%mod)*(fact_inv[p]%mod))%mod;
ll b=(m*power(m-1,n-p-1)%mod)%mod;
ll c=(a*b)%mod;
ans+=(fact[n-1]*c)%mod;
ans%=mod;
}
int main(void){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i;
cin>>n>>m>>k;
facto();
inverse();
factinv();
//cout<<inv[123]<<endl;
for(i=0;i<=k;i++)
solve(i);
cout<<ans<<endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+5;
char s[N],t[N];
int n,ans,l=1,r,last,q[N];
int main(){
scanf("%d%s%s",&n,s+1,t+1),last=n;
for(int i=n;i;){
while(last&&(i<last||s[last]!=t[i])) --last;
if(!last) {puts("-1");return 0;}
while(l<=r&&q[l]-r+l-1>=i) ++l;
q[++r]=last;
if(i!=last) ans=max(ans,r-l+1);
while(t[i]==s[last]&&i>=last) --i;
}
printf("%d\n",ans);
return 0;
}
| #include <stdio.h>
int main (){
int baris,kolom,warna,x;
scanf ("%d",&baris);
scanf ("%d",&kolom);
scanf ("%d",&warna);
if (baris > kolom){
x = (warna - 1)/baris +1;
}
else {
x = (warna - 1)/kolom +1;
}
printf ("%d",x);
return 0;
} | 0 |
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <cmath>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <stdlib.h>
#include <stdio.h>
#include <bitset>
#include <cstring>
#include <deque>
#include <iomanip>
#include <limits>
#include <fstream>
using namespace std;
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
#define CLR(mat) memset(mat, 0, sizeof(mat))
typedef long long ll;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int n,m;cin>>n>>m;
int A[n], B[m];
FOR(i,0,n)cin>>A[i];
FOR(i,0,m)cin>>B[i];
int cnt[n+1];
int ans = -1, num = 0;
CLR(cnt);
FOR(i,0,m){
FOR(j,0,n){
if(A[j] <= B[i]){
cnt[j+1]++;
if(cnt[j+1] > cnt[ans]) ans = j + 1;
break;
}
}
}
cout << ans << endl;
}
| #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int N, M; cin >> N >> M;
vector<int> cost(N);
for(int i = 0; i < N; ++i)
cin >> cost[i];
vector<int> score(N, 0);
while(M--) {
int x; cin >> x;
for(int i = 0; i < N; ++i) {
if(cost[i] <= x) {
score[i]++;
break;
}
}
}
int argmax = find(score.begin(), score.end(), *max_element(score.begin(), score.end())) - score.begin();
cout << argmax + 1 << endl;
} | 1 |
#include <iostream>
using namespace std;
const int BASE = 6200;
int N, mod;
int dp[6009][12409][3];
long long ret[12409];
void solve(int p1, int p2) {
// 最大値を更新する場合
for (int i = 0; i <= 2; i++) {
int r = 0;
if (i == 0) r = -1;
if (i == 1) r = 1;
dp[p1][p2][0] += 1LL * dp[p1 - 1][p2 - r][i] % mod;
if (dp[p1][p2][0] >= mod) dp[p1][p2][0] -= mod;
}
// 最大値を更新しない場合
for (int i = 1; i <= 2; i++) {
dp[p1][p2][i] += 1LL * (p1 - 1LL) * dp[p1 - 1][p2][i - 1] % mod;
if (dp[p1][p2][i] >= mod) dp[p1][p2][i] -= mod;
}
}
int main() {
cin >> N >> mod;
dp[1][BASE][0] = 1;
for (int i = 2; i <= 3 * N; i++) {
for (int j = 1; j <= BASE * 2 - 1; j++) {
solve(i, j);
}
}
for (int i = 1; i <= BASE * 2 - 1; i++) {
for (int j = 0; j <= 2; j++) {
int r = 0;
if (j == 0) r = -1;
if (j == 1) r = 1;
ret[i + r] += dp[3 * N][i][j];
}
}
long long Answer = 0;
for (int i = 0; i <= BASE; i++) Answer += ret[i];
cout << Answer % mod << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int64_t MOD;
void add(int64_t& a, int64_t b){
a = (a+b) % MOD;
}
void mul(int64_t& a, int64_t b){
a = a*b % MOD;
}
vector<int64_t> fact, seq_inv, fact_inv;
void create_fact_mod(int num){
fact[0] = fact[1] = 1;
for(int i=2; i<=num; i++) fact[i] = fact[i-1] * i % MOD;
}
void create_seq_inv_mod(int num){
seq_inv[0] = seq_inv[1] = 1;
for(int i=2; i<=num; i++) seq_inv[i] = (MOD - MOD/i) * seq_inv[MOD%i] % MOD;
}
void create_fact_inv_mod(int num){
fact_inv[0] = fact_inv[1] = 1;
for(int i=2; i<=num; i++) fact_inv[i] = fact_inv[i-1] * seq_inv[i] % MOD;
}
void create_mod_tables(int num){
fact.resize(num+1);
seq_inv.resize(num+1);
fact_inv.resize(num+1);
create_fact_mod(num);
create_seq_inv_mod(num);
create_fact_inv_mod(num);
}
int64_t comb_mod(int n, int k){
return fact[n] * fact_inv[n-k] % MOD * fact_inv[k] % MOD;
}
int64_t perm_mod(int n, int k){
return fact[n] * fact_inv[n-k] % MOD;
}
int64_t power_mod(int64_t num, int64_t power){
int64_t prod = 1;
num %= MOD;
while(power > 0){
if(power&1) prod = prod * num % MOD;
num = num * num % MOD;
power >>= 1;
}
return prod;
}
int64_t extgcd(int64_t a, int64_t b, int64_t& x, int64_t& y){
int64_t d = a;
if(b != 0){
d = extgcd(b, a%b, y, x);
y -= (a/b) * x;
}else{
x = 1; y = 0;
}
return d;
}
int64_t inv_mod(int64_t a){
int64_t x, y;
extgcd(a, MOD, x, y);
return (MOD + x%MOD) % MOD;
}
int main(){
int N;
cin >> N >> MOD;
create_mod_tables(10000);
static int64_t dp[6010][4001];
dp[3*N][N] = 1;
for(int i=3*N; i>0; i--) for(int j=0; j<=2*N; j++){
add(dp[i-1][min(2*N, j+1)], dp[i][j]);
if(i>=2 && j > 0) add(dp[i-2][j-1], dp[i][j] * (i-1));
if(i>=3) add(dp[i-3][j], dp[i][j] * (i-1) * (i-2));
}
int64_t ans = 0;
for(int j=N; j<=2*N; j++) add(ans, dp[0][j]);
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std::literals::string_literals;
using i64 = long long;
using std::cout;
using std::endl;
using std::cin;
template<typename T>
std::vector<T> make_v(size_t a){return std::vector<T>(a);}
template<typename T,typename... Ts>
auto make_v(size_t a,Ts... ts){
return std::vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));
}
const int MOD = 998244353;
int main() {
int n; scanf("%d", &n); std::vector<int> a(n);
for(int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(begin(a), end(a));
int s = 0;
for(auto v: a) s += v;
auto dp = make_v<i64>(n + 1, s + 1); dp[0][0] = 1;
for(int i = 0; i < n; i++) {
for(int j = 0; j < s; j++) {
if(!dp[i][j]) continue;
(dp[i + 1][j + a[i]] += dp[i][j]) %= MOD;
(dp[i + 1][j] += dp[i][j]) %= MOD;
(dp[i + 1][j] += dp[i][j]) %= MOD;
}
}
i64 ans = 1;
for(int i = 0; i < n; i++) (ans *= 3LL) %= MOD;
i64 sub = 0;
for(int i = (s + 1) / 2; i <= s; i++) (sub += dp[n][i]) %= MOD;
if(!(s & 1)) {
auto dp2 = make_v<i64>(n + 1, s + 1); dp2[0][0] = 1;
for(int i = 0; i < n; i++) {
for(int j = 0; j < s; j++) {
if(!dp2[i][j]) continue;
(dp2[i + 1][j + a[i]] += dp2[i][j]) %= MOD;
(dp2[i + 1][j] += dp2[i][j]) %= MOD;
}
}
(sub -= dp2[n][s / 2] - MOD) %= MOD;
}
printf("%lld\n", (ans - 3 * sub % MOD + MOD) % MOD);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define MOD 998244353
int n, a[330], dp[300*303], d2[300*303], ans = 1, sum;
int expo(int b, int e) {
if(e == 0) return 1;
if(e & 1) return 1ll * b * expo(1LL * b * b % MOD, e >> 1) % MOD;
return expo(1LL * b * b % MOD, e >> 1);
}
int inv_mod(int x) { return expo(x, MOD - 2); }
int main() {
scanf("%d", &n);
dp[0] = d2[0] = 1;
for(int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += a[i];
ans = 3LL * ans % MOD;
for(int v = n * 300; v >= 0; v--) {
dp[v] = (2LL * dp[v] % MOD + (v >= a[i] ? dp[v - a[i]] : 0)) % MOD;
d2[v] = (d2[v] % MOD + (v >= a[i] ? d2[v - a[i]] : 0)) % MOD;
}
}
for(int i = sum; 2*i >= sum; i--)
ans = (ans - 3LL * dp[i] % MOD + MOD) % MOD;
if(sum % 2 == 0) ans = (ans + 3LL * d2[sum/2] % MOD) % MOD;
printf("%d\n", ans);
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define dro first
#define adg second.first
#define mog second.second
#define ll long long
using namespace std;
const int N = 500001;
int n,r,pos,l,x,U,D,S;
long long ans;
int K;
string s;
int fix[100],fix1[100],A[100],B[100];
int dp[305][305][305];
int main(){
cin>>s;
n=s.size();
cin>>K;
for(int j=0;j<n;j++)
for(int l=0;l+j<n;l++)
for(int k=0;k<=K;k++){
int r = l+j;
if(l==r){
dp[l][r][k] = 1;
continue;
//dp[l][r][1] = 1
}
if(l+1==r){
if(k==0){
dp[l][r][k] = 1;
if(s[l] == s[r]) dp[l][r][k] = 2;
} else {
dp[l][r][k] = 2;
}
continue;
}
dp[l][r][k] = max( dp[l+1][r][k], dp[l][r-1][k]);
//cout<<dp[l+1][r][k]<<" "<<l<<" "<<r<<" "<<k<<endl;
//cout<<dp[l][r-1][k]<<" "<<l<<" "<<r<<" "<<k<<endl;
if(s[l]==s[r])
dp[l][r][k] = max( dp[l][r][k], dp[l+1][r-1][k] + 2);
else {
if(k-1>=0)
dp[l][r][k] = max( dp[l][r][k], dp[l+1][r-1][k-1] + 2);
}
//cout<<dp[l][r][k]<<" "<<l<<" "<<r<<" "<<k<<endl;
}
cout<<dp[0][n-1][K]<<endl;
}
| #include<bits/stdc++.h>
using namespace std;
inline void upmax(short &x,const short &y){if(y>x) x=y;}
const int N=105;
short f[N][N][N][N];
short sum1[N][N],sum2[N][N];
int n,m,tx,ty;
void gao()
{
int limu=tx-1,limd=n-tx,liml=ty-1,limr=m-ty;
for(int u=0;u<=limu;u++)
for(int d=0;d<=limd;d++)
for(int l=0;l<=liml;l++)
for(int r=0;r<=limr;r++)
{
int L=max(ty-l,r+1),R=min(ty+r,m-l);
if(L<=R)
{
upmax(f[u+1][d][l][r],f[u][d][l][r]+(tx-u-1>=d+1?sum1[tx-u-1][R]-sum1[tx-u-1][L-1]:0));
upmax(f[u][d+1][l][r],f[u][d][l][r]+(tx+d+1<=n-u?sum1[tx+d+1][R]-sum1[tx+d+1][L-1]:0));
}
L=max(tx-u,d+1),R=min(tx+d,n-u);
if(L<=R)
{
upmax(f[u][d][l+1][r],f[u][d][l][r]+(ty-l-1>=r+1?sum2[R][ty-l-1]-sum2[L-1][ty-l-1]:0));
upmax(f[u][d][l][r+1],f[u][d][l][r]+(ty+r+1<=m-l?sum2[R][ty+r+1]-sum2[L-1][ty+r+1]:0));
}
}
printf("%d\n",f[limu][limd][liml][limr]);
}
int main()
{
static char s[105];
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
{
scanf("%s",s+1);
for(int j=1;j<=m;j++)
{
if(s[j]=='E') tx=i,ty=j;
sum1[i][j]=sum1[i][j-1]+(s[j]=='o');
sum2[i][j]=sum2[i-1][j]+(s[j]=='o');
}
}
gao();
} | 0 |
#include<iostream>
#include<string>
#include<map>
#include<algorithm>
using namespace std;
typedef long long ll;
const int Max = 1e3 + 7;
int lst[Max];
int n;
bool check()
{
for (int i = 1; i <= n; i++)
{
if (lst[i] % 2 != 0) return false;
else lst[i] /= 2;
}
return true;
}
int main()
{
cin >> n;
for (int i = 1; i <= n; i++)scanf("%d", &lst[i]);
int g = 0;
while (check())
{
g++;
}
cout << g;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll gcd( ll x, ll y );
ll lcm( ll x, ll y );
int main()
{
int n, c, a[11];
while ( true ) {
memset( a, 0, sizeof(a) );
scanf("%d", &n );
if ( n == 0 ) break;
for ( int i = 0; i < n; i++ ) {
scanf("%d", &c );
a[c]++;
}
for ( int i = 0; i < 10; ++i ) {
if ( a[i] != 0 ) {
for ( int j = 0; j < a[i]; ++j ) {
printf("*");
}
} else {
printf("-");
}
putchar('\n');
}
}
return 0;
}
ll gcd( ll x, ll y )
{
if ( y == 0 ) return x;
return gcd( y, x % y );
}
ll lcm( ll x, ll y )
{
return x / gcd( x, y ) * y;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
//#define f(i,a,n) for(ll i=a;i<n;i++)
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
ll isPrime(int n)
{
// Corner cases
if (n <= 1)
return 1;
if (n <= 3)
return 2;
// This is checked so that we can skip
// middle five numbers in below loop
if (n % 2 == 0 || n % 3 == 0)
return 1;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return 1;
return 2;
}
ll fact(ll n){ll res = 1;for (ll i = 2; i <= n; i++)res = res * i,res%=1000000007;
return res; }
int gcd(int a, int b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
ll findlcm(ll arr[], int n)
{
ll ans = arr[0];
for (int i = 1; i < n; i++)
ans = (((arr[i] * ans)) /
(gcd(arr[i], ans)));
return ans;
}
int main()
{
fast;
ll t=1;
//cin>>t;
while(t--)
{
double r,g;
cin>>r>>g;
cout<<2*g-r;
}
return 0;
}
| #include<iostream>
#include<vector>
using namespace std;
int main() {
int n, m, s, c;
int ans = 0;
vector<int> a(5, -1);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> s >> c;
if (s == 1 && c == 0 && n != 1) ans = -1;
if (a[s] == -1 || a[s] == c) a[s] = c;
else ans = -1;
}
if (ans == -1) cout << ans << endl;
else {
if (a[1] == -1 && n != 1) a[1] = 1;
for(int i = 1; i <= n; i++) {
if (a[i] == -1) a[i] = 0;
cout << a[i];
}
cout << endl;
}
} | 0 |
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<bitset>
#include<set>
#include<map>
#include<stack>
#include<queue>
#include<deque>
#include<list>
#include<iomanip>
#include<cmath>
#include<cstring>
#include<functional>
#include<cstdio>
#include<cstdlib>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define INF 2e9
#define MOD 1000000007
//#define MOD 998244353
#define LINF (long long)4e18
#define jck 3.141592
const double EPS = 1e-10;
using ll = long long;
using Pi = pair<int,int>;
using Pl = pair<ll,ll>;
int main(){
int N,M; cin >> N >> M;
vector<vector<int>> A(N,vector<int>(M));
rep(i,N)rep(j,M){
cin >> A[i][j];
A[i][j]--;
}
vector<int> id(N);
vector<vector<bool>> used(N,vector<bool>(M,false));
int ans = INF;
while(true){
vector<int> s(M);
bool ok = true;
rep(i,N){
while(used[i][id[i]]){
id[i]++;
if(id[i] >= M) ok = false;
}
if(!ok) break;
s[A[i][id[i]]]++;
}
if(!ok) break;
int now = 0;
int dame = 0;
rep(i,M){
if(now < s[i]){
now = s[i];
dame = i;
}
}
rep(i,N)rep(j,M){
if(A[i][j] == dame) used[i][j] = true;
}
ans = min(ans,now);
}
cout << ans << endl;
}
| #include "bits/stdc++.h"
using namespace std;
#define int long long
#define FOR(i, a, b) for(int i=(a);i<(b);i++)
#define RFOR(i, a, b) for(int i=(b-1);i>=(a);i--)
#define REP(i, n) for(int i=0; i<(n); i++)
#define 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>=1; i--)
#define ALL(a) (a).begin(),(a).end()
#define UNIQUE_SORT(l) sort(ALL(l)); l.erase(unique(ALL(l)), l.end());
#define CONTAIN(a, b) find(ALL(a), (b)) != (a).end()
#define out(...) printf(__VA_ARGS__)
#if DEBUG
#define debug(...) printf(__VA_ARGS__)
#else
#define debug(...) /* ... */
#endif
template<class T>bool chmax(T &a,const T &b){if(a<b){a=b;return true;}return false;}
template<class T>bool chmin(T &a,const T &b){if(b<a){a=b;return true;}return false;}
void _OUT() {}; template<class H, class... T> void _OUT(H &h, T &... t) { cout<<' '<<h; _OUT(t...); };
template<class H, class... T> void _P(H &h, T &... t) { cout<<h; _OUT(t...); };
#define _PN(...) _P(__VA_ARGS__); cout << endl;
#define EXEC(...) void exec() { (__VA_ARGS__ - 1) ? multi() : solve(0); }
void exec();
void solve(int t);
void multi() { int TT; cin>>TT; REP1(t,TT) solve(t); }
signed main()
{
#if DEBUG
std::ifstream in("input.txt");
std::cin.rdbuf(in.rdbuf());
#endif
cin.tie(0);
ios::sync_with_stdio(false);
exec();
return 0;
}
/*================================*/
#if DEBUG
#define SIZE 10
#else
#define SIZE 333
#endif
int N,M;
int A[SIZE][SIZE];
void solve(int _t) {
cin>>N>>M;
REP(n,N) {
REP(m,M) {
cin>>A[n][m];
A[n][m]--;
}
}
int ans = INT_MAX;
vector<int> NG(M,0);
REP(_,M) {
vector<int> C(M,0);
REP(n,N) {
REP(m,M)if(!NG[A[n][m]]) {
C[A[n][m]]++;
break;
}
}
int cnt = 0;
int mai = -1;
REP(m,M) if (chmax(cnt, C[m])) mai=m;
debug("mai:%lld, cnt:%lld\n",mai,cnt);
chmin(ans,cnt);
NG[mai]=1;
}
_PN(ans);
}
EXEC(1)
| 1 |
#include <stdio.h>
int main()
{
int i;
int mark[2] = { 0 };
int a, b, n;
while ((scanf("%d", &n)) != EOF)
{
mark[0] = 0; mark[1] = 0;
if (n == 0) break;
for (i = 0; i < n; i++)
{
if (scanf("%d%d", &a, &b) == EOF) break;
if (a < b) mark[1] += (a + b);
else if (a > b) mark[0] += (a + b);
else {
mark[1] += a; mark[0] += a;
}
}
printf("%d %d\n", mark[0], mark[1]);
}
return 0;
} | #include <bits/stdc++.h>
#define pp push_back
#define pf push_front
#define mp make_pair
#define fs first
#define sc second
#define sf scanf
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> ii;
const int N = (int) 1e6;
const int INF = (int) 1e9 + 7;
bool comp(ii a, ii b) {
int x = max(a.fs, a.sc) - a.sc;
int y = max(b.fs, b.sc) - b.sc;
return x > y;
}
int main(int argc, char *argv[])
{
// ios_base::sync_with_stdio(false);
// cin.tie(NULL);
int n;
sf("%d", &n);
char s[N + 7];
int l = 0, r = 0;
vector<ii> a;
vector<ii> b;
for (int j = 0; j < n; ++j) {
sf("%s", s);
int x = 0;
int y = 0;
for (int i = 0; i < strlen(s); ++i) {
if (s[i] == '(') {
++x;
}
else {
if (x < 1) {
++y;
}
else {
--x;
}
}
}
if (x > 0 && y > 0) {
if (x > y) {
a.pp(mp(y, x));
}
else {
b.pp(mp(y, x));
}
}
else {
l += x;
r += y;
}
}
sort(a.begin(), a.end());
for (int i = 0; i < a.size(); ++i) {
if (l < a[i].fs) {
puts("No");
return 0;
}
l += a[i].sc - a[i].fs;
if (l < 0) {
puts("No");
return 0;
}
}
sort(b.begin(), b.end(), greater<ii>());
for (int i = 0; i < b.size(); ++i) {
if (l < b[i].fs) {
puts("No");
return 0;
}
l += b[i].sc - b[i].fs;
if (l < 0) {
puts("No");
return 0;
}
}
puts(l == r ? "Yes" : "No");
return 0;
}
| 0 |
#include <iostream>
using namespace std;
int main(void)
{
int n;
while(cin>>n){
int date[11][11]={0};
if(!n) break;
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
cin >> date[i][j];
}
}
for(int i=0;i<n;i++){
for(int j=0; j<n; j++){
date[i][n] += date[i][j];
}
}
for(int i=0;i<=n;i++){
for(int j=0; j<n; j++){
date[n][i] += date[j][i];
}
}
for(int i=0; i<=n; i++){
for(int j=0; j<=n; j++){
printf("%5d",date[i][j]);
}
cout << "\n";
}
}
return 0;
} | #include <iostream>
#include <cstdio>
#include <string>
using namespace std;
#define loop(i,a,b) for(int i=(a); i<(int)(b); i++)
#define rep(i,b) loop(i,0,b)
int main(){
int n;
while (cin >> n, n){
int v[10] = {};
rep(i, n){
int s = 0;
rep(j, n){
int t; cin >> t;
printf("%5d", t);
s += t;
v[j] += t;
}
printf("%5d\n", s);
}
int s = 0;
rep(i, n){
printf("%5d", v[i]);
s += v[i];
}
printf("%5d\n", s);
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define REP(i, n) for (int i = 0; i < (n); i++)
const long double EPS = 1e-10;
const long long INF = 1e18;
const long double PI = acos(-1.0L);
ll gcd(ll a, ll b){ if(b==0){ return a; } return gcd(b , a%b); }
int main() {
int n,m,x,y;
cin>>n>>m>>x>>y;
int a[n],b[m];
REP(i,n){
cin>>a[i];
}
REP(i,m){
cin>>b[i];
}
int max_a = INT_MIN;
int min_b = INT_MAX;
REP(i,n){
max_a = max(max_a,a[i]);
}
REP(i,m){
min_b = min(min_b,b[i]);
}
int ans;
int flag = 0;
for(int i=x+1;i<y;i++){
if( i > max_a && i<=min_b){
flag = 1;
ans = i;
break;
}
}
if(flag){
cout<<"No War\n";
}
else{
cout<<"War\n";
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> xs(n + 1), ys(m + 1);
cin >> xs[0] >> ys[0];
for (int i = 1; i <= n; ++i)
cin >> xs[i];
for (int i = 1; i <= m; ++i)
cin >> ys[i];
if (*max_element(xs.begin(), xs.end()) < *min_element(ys.begin(), ys.end()))
cout << "No War" << endl;
else
cout << "War" << endl;
}
| 1 |
#include<iostream>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
int main(){
int n,k;
while(cin>>n>>k){
if(n==0){
break;
}
int d[20]={},cnt[10000]={},c;
for(int i=0;i<n;i++){
cin>>d[i];
}
if(k==2){
c=0;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(i!=j){
if(d[j]>=10){
cnt[c]+=d[i]*100+d[j];
}
else{
cnt[c]+=d[i]*10+d[j];
}
c++;
}
}
}
}
if(k==3){
c=0;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(i!=j){
for(int k=0;k<n;k++){
if(i!=k && j!=k){
if(d[k]>=10){
if(d[j]>=10){
cnt[c]=d[i]*10000+d[j]*100+d[k];
}
else{
cnt[c]=d[i]*1000+d[j]*100+d[k];
}
}
else{
if(d[j]>=10){
cnt[c]=d[i]*1000+d[j]*10+d[k];
}
else{
cnt[c]=d[i]*100+d[j]*10+d[k];
}
}
c++;
}
}
}
}
}
}
if(k==4){
c=0;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(i!=j){
for(int k=0;k<n;k++){
if(i!=k && j!=k){
for(int l=0;l<n;l++){
if(i!=l && j!=l && k!=l){
if(d[l]>=10){
if(d[k]>=10){
if(d[j]>=10){
cnt[c]=d[i]*1000000+d[j]*10000+d[k]*100+d[l];
}
else{
cnt[c]=d[i]*100000+d[j]*10000+d[k]*100+d[l];
}
}
else{
if(d[j]>=10){
cnt[c]=d[i]*100000+d[j]*1000+d[k]*100+d[l];
}
else{
cnt[c]=d[i]*10000+d[j]*1000+d[k]*100+d[l];
}
}
}
else{
if(d[k]>=10){
if(d[j]>=10){
cnt[c]=d[i]*100000+d[j]*1000+d[k]*10+d[l];
}
else{
cnt[c]=d[i]*10000+d[j]*1000+d[k]*10+d[l];
}
}
else{
if(d[j]>=10){
cnt[c]=d[i]*10000+d[j]*100+d[k]*10+d[l];
}
else{
cnt[c]=d[i]*1000+d[j]*100+d[k]*10+d[l];
}
}
}
c++;
}
}
}
}
}
}
}
}
sort(cnt,cnt+c+1,greater<int>());
int ans=0;
for(int i=0;i<c;i++){
if(cnt[i]>cnt[i+1]){
ans++;
}
}
cout<<ans<<endl;
}
return 0;
} | #include<cstdio>
#include<algorithm>
#include<vector>
#include<sstream>
#include<cstdlib>
using namespace std;
int main(){
while(1){
int n,k;
scanf("%d%d",&n,&k);
if(n==0)
break;
vector<int> card(n);
for(int i=0;i<n;i++){
scanf("%d",&card[i]);
}
sort(card.begin(),card.end());
vector<int> data;
do{
stringstream sst;
for(int i=0;i<k;i++){
sst<<card[i];
}
data.push_back(atoi(sst.str().c_str()));
reverse( card.begin()+k,card.end());
}while( next_permutation(card.begin(),card.end()) );
sort(data.begin(),data.end());
printf("%d\n",distance(data.begin(),unique(data.begin(),data.end())) );
}
} | 1 |
//http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_6_B&lang=jp
#include <iostream>
using namespace std;
void swap(int A[],int i,int j){
int buf = A[j];
A[j] = A[i];
A[i] = buf;
}
int partition(int A[], int l, int r){
const int x = A[r]; //????????¨?????????
int i = l-1; //??§???????????????????????¨??????????????????-1
for(int j = l; j < r; j++){
//j?????????????????£???????????¨??????????????????????????¨????????????
if (A[j] <= x){
i += 1;
//??´??????????????????????????¨???
swap(A,i,j);
}
}
swap(A,i+1,r);
return i+1;
}
int main(){
int n;
cin >> n;
int S[n];
for(int i=0; i<n; i++){
cin >> S[i];
}//????????????????????????
int mark = partition(S,0,n-1);
for(int i=0; i<mark; i++){
cout << S[i] << " ";
}
cout << "[" << S[mark] << "] ";
for(int i=mark+1; i<n-1; i++){
cout << S[i] << " ";
}
cout << S[n-1] << endl;
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long lli;
typedef vector<lli> vll;
lli partition(vll& a,lli p,lli r){
lli x = a[r];
lli i = p-1;
for(lli j = p;j < r;j++){
if(a[j] <= x){
i++;
swap(a[j],a[i]);
}
}
swap(a[i+1],a[r]);
return i+1;
}
lli n;
vll a;
int main(){
cin >> n;
a = vll(n);
for(lli i = 0;i < n;i++) cin >> a[i];
lli p = partition(a,0,n-1);
for(lli i = 0;i < n;){
if(i == p) cout << "[";
cout << a[i];
if(i == p) cout << "]";
if(++i < n) cout << " ";
else cout << endl;
}
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main() {
while( true ) {
long long int n;
cin >> n;
if ( n == 0 ) break;
vector< long long int > k;
for ( long long int i = 0; i < n; i++ ) {
long long int in;
cin >> in;
k.push_back( in );
}
string s;
cin >> s;
for ( long long int j = 0; j < s.size(); j++ ) {
long long int b = k[ j % k.size() ];
if ( b >= 26 ) {
b -= 26;
if ( s[j] >= 'a' && s[j] <= 'z' ) {
s[j] += 'A' - 'a';
}else {
s[j] += 'a' - 'A';
}
}
if ( s[j] >= 'a' && s[j] <= 'z' ) {
s[j] -= b;
if ( s[j] < 'a' ) {
s[j] += 26;
s[j] += 'A' - 'a';
}
}else {
s[j] -= b;
if ( s[j] < 'A' ) {
s[j] += 26;
s[j] += 'a' - 'A';
}
}
}
cout << s << endl;
}
return 0;
} | #include<iostream>
#include<queue>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
using namespace std;
int main(){
int n,m,dt;
while(1){
cin>>n>>m;
if(!(n&&m))break;
priority_queue<int> que;
rep(i,n){cin>>dt;que.push(dt);}
int cnt=0,sum=0;
while(!que.empty()){
cnt++;
if(cnt!=m)sum+=que.top();
else cnt=0;
que.pop();
}
cout<<sum<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll MOD = 1000000007;
const ld PI = acos(-1);
const ld EPS = 0.0000000001;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define rep(i, n) for(ll i=0; i<(ll)(n); i++)
#define repd(i, n) for(ll i=n-1; 0<=i; i--)
#define FOR(i, a, b) for(ll i=a; i<(ll)(b); i++)
#define FORD(i, a, b) for(ll i=b-1; (ll)(a)<=i; i--)
#define ALL(x) x.begin(), x.end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
string YES[2] = {"NO", "YES"};
string yes[2] = {"No", "Yes"};
int main(){
ll n; cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
vector<ll> csum(n+1, 0);
rep(i, n) csum[i+1] = (csum[i]+a[i])%MOD;
ll res=0;
rep(i, n){
res += (a[i]*((csum[n]-csum[i+1]+MOD)%MOD))%MOD;
res %= MOD;
}
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin>>n;
vector<long long> a(n);
for(int i=0;i<n;i++){
cin>>a.at(i);
}
long long sum=0;
for(int i=0;i<n;i++){
sum=(sum+a.at(i))%1000000007;
}
long long ans=0;
ans=(sum*sum)%1000000007;
for(int i=0;i<n;i++){
ans=(ans-(a.at(i)*a.at(i))%1000000007)%1000000007;
}
if(ans<0){
ans=1000000007+ans;
}
ans=((ans*1000000008)/2)%1000000007;
cout<<ans;
} | 1 |
#include <bits/stdc++.h>
//#include <atcoder/all>
//using namespace atcoder;
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
typedef pair<int,int> P;
typedef long long ll;
int main() {
int a, b;
cin >> a >> b;
int sum = 1, cnt = 0;
while(sum < b) {
sum += a-1;
cnt++;
}
cout << cnt << endl;
return 0;
}
| #include<iostream>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <vector>
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++)
int main() {
int a, b,i=0;
cin >> a >> b;
while (1) {
if (a * i - i + 1 >= b) {
cout << i << endl;
return 0;
}
i++;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define erep(i,a,n) for(int i = a;i<=n;i++)
typedef long long ll;
#define int long long
#define vint vector<int>
#define vvint vector<vector<int>>
#define vstring vector<string>
#define vdouble vector<double>
#define vll vector<ll>:
#define vbool vector<bool>
#define INF 1101010101010101010
#define MOD 1000000007
#define P pair<int,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; }
const int MAXN = 1010;
const int MAXV = MAXN*(MAXN-1)/2;
vint to[MAXV];
int id[MAXN][MAXN];
bool visited[MAXV];
int dp[MAXV];
bool calculated[MAXV];
int dfs(int a){
if(visited[a]){
if(!calculated[a]){
return -1;
}
return dp[a];
}
visited[a] = true;
dp[a] = 1;
for(int p:to[a]){
int u = dfs(p);
if(u == -1){
return -1;
}
dp[a] = max(dp[a],u+1);
}
calculated[a] = true;
return dp[a];
}
int toID(int a,int b){
if(a < b) swap(a,b);
return id[a][b];
}
signed main(){
int n;
cin >> n;
vvint A(n,vint(n-1));
rep(i,0,n){
rep(j,0,n-1){
cin >> A[i][j];
A[i][j]--;
}
}
int v = 0;
rep(i,0,n){
rep(j,0,n){
if(i > j){
id[i][j] = v;
v++;
}
}
}
rep(i,0,n){
rep(j,0,n-1){
A[i][j] = toID(i,A[i][j]);
}
}
rep(i,0,n){
rep(j,0,n-2){
to[A[i][j+1]].push_back(A[i][j]);
}
}
int ans = 0;
rep(i,0,v){
int res = dfs(i);
if(res == -1){
cout << -1 << endl;
return 0;
}
ans = max(ans,res);
}
cout << ans << endl;
}
| #include<bits/stdc++.h>
using namespace std;
#define int long long
#define ALL(x) (x).begin(),(x).end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
typedef pair<int,int> PI;
typedef pair<int,pair<int,int>> PII;
static const int INF=1010000000000000017LL;
static const double eps=1e-12;
static const double pi=3.14159265358979323846;
static const int dx[4]={1,-1,0,0};
static const int dy[4]={0,0,1,-1};
static const int ddx[8]={1,-1,0,0,1,1,-1,-1};
static const int ddy[8]={0,0,1,-1,1,-1,1,-1};
template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return true;}return false;}
template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return true;}return false;}
int N;
int A[200005],B[200005];
int C[200005],D[200005];
signed main(){
cin>>N;
for(int i=0;i<N;++i)cin>>A[i];
for(int i=0;i<N;++i)cin>>B[i];
for(int i=0;i<N;++i){
C[A[i]]++;
D[B[i]]++;
}
int ma=0;
for(int i=1;i<=N;++i){
if(C[i]+D[i]>N){
cout<<"No\n";
return 0;
}
C[i]+=C[i-1];
D[i]+=D[i-1];
chmax(ma,C[i]-D[i-1]);
}
cout<<"Yes\n";
for(int i=0;i<N;++i){
cout<<B[(i-ma+N)%N];
if(i!=N-1)cout<<" ";
}
cout<<"\n";
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const long long INF=INT_MAX/4;
const long long MOD=998244353;
const double EPS=1e-14;
const bool DEBUG=false;
const string YES = "YES";
const string NO = "NO";
const string Yes = "Yes";
const string No = "No";
template<class T>
void debug(T head){
if(DEBUG){
cout<<head<<endl;
}
}
template <class Head, class... Body>
void debug(Head head, Body... body){
if(DEBUG){
cout<<head<<" ";
debug(body...);
}
}
/////
void answer(ll sx, ll sy, ll tx, ll ty){
for(int i=sy; i<ty; ++i){
cout<<"U";
}
for(int i=sx; i<tx; ++i){
cout<<"R";
}
for(int i=sy; i<ty; ++i){
cout<<"D";
}
for(int i=sx; i<tx; ++i){
cout<<"L";
}
cout<<"L";
for(int i=sy; i<ty+1; ++i){
cout<<"U";
}
for(int i=sx; i<tx+1; ++i){
cout<<"R";
}
cout<<"D";
cout<<"R";
for(int i=sy; i<ty+1; ++i){
cout<<"D";
}
for(int i=sx; i<tx+1; ++i){
cout<<"L";
}
cout<<"U";
cout<<endl;
return;
}
/////
int main(int argc, char* argv[]){
cin.tie(0);
ios::sync_with_stdio(0);
cout.precision(16);
ll sx, sy, tx, ty;
cin>>sx>>sy>>tx>>ty;
answer(sx, sy, tx, ty);
return 0;
}
| #pragma GCC optimize("O3")
#include<bits/stdc++.h>
#define sp " "
#define endl "\n"
#define MAX 10e9
#define MAXN 100001
#define mod 1000000007
#define inf_int 2e9
#define inf_ll 2e18
#define e 1e-9
#define vi vector<int>
#define vl vector<ll>
#define vc vector<char>
#define vs vector<string>
#define vpl vector<pair<ll,ll>>
#define vpc vector<pair<char,char>>
#define adj_list vector<vl>
#define umap unordered_map<ll, ll>
#define pll pair<ll,pair<ll, ll>>
#define clr(x) memset(x,0,sizeof(x))
#define cy cout << "YES" << endl
#define cn cout << "NO" << endl
#define google cout << "Case #" << ++it << ": " << ans << endl;
#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
typedef long long int ll;
ll it = 0, ans = 0;
ll spf[MAXN];
void sieve()
{
spf[1] = 1;
for (auto i=2; i<MAXN; i++)
spf[i] = i;
for (auto i=4; i<MAXN; i+=2)
spf[i] = 2;
for (auto i=3; i*i<MAXN; i++)
{
if (spf[i] == i)
{
for (auto j=i*i; j<MAXN; j+=i)
if (spf[j]==j)
spf[j] = i;
}
}
return;
}
vl getFactorization(ll x)
{
vl ret;
while (x != 1)
{
ret.push_back(spf[x]);
x = x / spf[x];
}
return ret;
}
void check()
{
ll x,y,z;
cin >> x >> y >> z;
cout << z << sp << x << sp << y;
return ;
}
int32_t main()
{
fastio
ll t = 1;
// cin >> t;
while(t--)
check();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int a,b;
cin>>a>>b;
long long int ans=max(a,b);
if(a>=b){
a--;
if(a>0&&a>=b){
cout<<ans+a;
}
else{
cout<<ans+b;
}
}
else{
b--;
if(b>0&&b>=a){
cout<<ans+b;
}
else{
cout<<ans+a;
}
}
return 0;
} | #include <iostream>
using namespace std;
int main()
{
int a, b, ans = 0;
cin >> a >> b;
ans += max(a , b);
if(a == b) ans += max(a, b);
else ans += ans - 1;
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repo(i,n) for(int i = 1; i < (int)(n); i++)
#define pb push_back
#define mp make_pair
#define np next_permutation
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define all(x) (x).begin(),(x).end()
#define mod 1000000007
#define pi acos(-1.0)
const ll INF = 1LL<<61;
template<class T>bool chmax(T &a, const T &b) {
if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) {
if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll jou(ll N, ll P){if(P==0) return 1;
if(P%2==0){ll t = jou(N, P/2);return t*t % mod;
}return (N * jou(N, P-1)) % mod;} //jou(n,mod-2)で逆元
//intの最大値2147483647 ≒ 2×10^9
//long longの最大値9223372036854775807 ≒ 9×10^18
//'大文字'+=32; で小文字に
// cout << fixed << setprecision (20); 小数点以下2０桁まで
//実行時間制約2秒では２×10^8回くらいまで計算できる
//—————————————————BFSグラフ————————————————
using Graph = vector<vector<pair<ll,ll>>>;
int main() {
// 頂点数と辺数
ll n;
cin >> n;
// グラフ入力受取
Graph G(n);
rep(i,n-1) {
ll a,b,c;
cin >> a >> b >> c;
auto x=mp(b-1,c);
G[a-1].pb(x);
auto y=mp(a-1,c);
G[b-1].pb(y);
}
ll q,k;
cin>>q>>k;
k--;
// BFS のためのデータ構造
vector<ll> dist(n, 1000000000000000000); // 全頂点を「未訪問」に初期化
deque<ll> que;
// 初期条件 (頂点 0 を初期ノードとする)
dist[k] = 0;
que.pb(k); // 0 を橙色頂点にする
// BFS 開始 (キューが空になるまで探索を行う)
while (!que.empty()) {
ll v = que.front(); // キューから先頭頂点を取り出す
que.pop_front();
// v から辿れる頂点をすべて調べる
for (auto nv : G[v]) {
// 新たな白色頂点 nv について距離情報を更新してキューに追加する
if(dist[nv.fi]>dist[v] + nv.se){
dist[nv.fi] = dist[v] + nv.se;
que.pb(nv.fi);
}
}
}
rep(i,q){
ll x,y;
cin>>x>>y;
cout << dist[x-1]+dist[y-1] << endl;
}
}
| #include<iostream>
#include<cstdio>
#include<vector>
#include<cmath>
#include<cstring>
#include<fstream>
#include<algorithm>
using namespace std;
typedef long long LL;
const int INF=0x3f3f3f3f;
const int MAXN=1e5+5;
int tot,head[MAXN];
LL dist[MAXN];
bool vis[MAXN];
struct Edge
{
int from,to,nxt;
LL cost;
}e[MAXN*2];
void addedge(int u,int v,int w)
{
e[tot].from=u;
e[tot].to=v;
e[tot].cost=w;
e[tot].nxt=head[u];
head[u]=tot++;
}
void dfs(int u,int fa)
{
for(int i=head[u];i!=-1;i=e[i].nxt)
{
int to=e[i].to;
if(to==fa) continue;
dist[to]=dist[u]+e[i].cost;
dfs(to,u);
}
}
int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
tot=0;
memset(head,-1,sizeof(head));
memset(dist,0,sizeof(dist));
int u,v;
LL w;
for(int i=1;i<=n-1;i++)
{
scanf("%d%d%lld",&u,&v,&w);
addedge(u,v,w);
addedge(v,u,w);
}
int q,k;
scanf("%d%d",&q,&k);
dfs(k,-1);
// for(int i=1;i<=n;i++)
// cout<<dist[i]<<" ";
// cout<<endl;
int x,y;
for(int i=1;i<=q;i++)
{
scanf("%d%d",&x,&y);
printf("%lld\n",dist[x]+dist[y]);
}
}
return 0;
} | 1 |
#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 main() {
ll x; cin >> x;
ll nokori = x % 11;
ll ans = (x-nokori) / 11;
ans *= 2;
if(nokori > 6){
ans += 2;
} else if(nokori > 0) {
ans++;
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main()
{
string N;
cin >> N;
if(N[0] == '7' || N[1] == '7' || N[2] == '7')
{
cout << "Yes" << endl;
}
else
{
cout << "No" << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,m,n) for(int i=(m); i<(int)(n); i++)
#define RREP(i,m,n) for(int i=(int)(n-1); i>=m; i--)
#define rep(i,n) REP(i,0,n)
#define rrep(i,n) RREP(i,0,n)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define fi first
#define se second
#define debug(...) {cerr<<"[L"<<__LINE__<<"] "; _debug(__VA_ARGS__);}
template<typename T>
string join(const vector<T>&v, string del=", "){ stringstream s;
for(auto x : v) s << del << x; return s.str().substr(del.size());
}
template<typename T>
ostream& operator<<(ostream& o, const vector<T>&v){
if(v.size()) o << "[" << join(v) << "]"; return o;
}
template<typename T>
ostream& operator<<(ostream& o, const vector<vector<T> >&vv){
int l = vv.size();
if(l){ o<<endl; rep(i,l) o << (i==0 ? "[ " : ",\n " ) << vv[i] << (i==l-1 ? " ]" : ""); }
return o;
}
template<typename T1, typename T2>
ostream& operator<<(ostream& o, const pair<T1, T2>& p){
return o << "(" << p.first << ", " << p.second << ")";
}
inline void _debug(){cerr<<endl;}
template<class First, class... Rest>
void _debug(const First& first, const Rest&... rest){cerr<<first<<" ";_debug(rest...);}
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
const double PI = (1*acos(0.0));
const double EPS = 1e-9;
const int INF = 0x3f3f3f3f;
const ll INFL = 0x3f3f3f3f3f3f3f3fLL;
const ll mod = 1e9 + 7;
inline void finput(string filename) {
freopen(filename.c_str(), "r", stdin);
}
int main(){
ios_base::sync_with_stdio(0);
// finput("./input");
int n; cin >> n;
vl a(n);
rep(i,n) cin >> a[i];
sort(all(a));
for(int i=0; i<n-1; i+=2){
if(a[i]+a[i+1] < 0){
a[i] = -a[i];
a[i+1] = -a[i+1];
}
}
ll ans = accumulate(all(a), 0ll);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using vint = vector<int>;
using vvint = vector<vint>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vchar = vector<char>;
using vvchar = vector<vchar>;
using vp = vector<P>;
using vpp = vector<pair<P, P>>;
using vvp = vector<vp>;
#define rep(i, n) for (int i = 0; i < n; ++i)
#pragma region Debug
istream &operator>>(istream &is, P &a)
{
return is >> a.first >> a.second;
}
ostream &operator<<(ostream &os, const P &a) { return os << "(" << a.first << "," << a.second << ")"; }
template <typename T>
void view(const std::vector<T> &v)
{
#ifndef ONLINE_JUDGE
for (const auto &e : v)
{
std::cout << e << " ";
}
std::cout << std::endl;
#endif
}
template <typename T>
void view(const std::vector<std::vector<T>> &vv)
{
for (const auto &v : vv)
{
view(v);
}
}
#pragma endregion
int main()
{
int n;
cin >> n;
vll a(n);
rep(i, n) cin >> a[i];
vll neg;
ll ans = 0;
rep(i, n)
{
if (a[i] <= 0)
{
neg.emplace_back(abs(a[i]));
}
ans += abs(a[i]);
}
int k = neg.size();
if (k % 2)
{
ll sml = 10000000000;
rep(i, n) sml = min(sml, abs(a[i]));
ans -= sml * 2;
}
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
typedef pair<int, int> pii;
#define rep(i, start, n) for (int i = (int)(start); i < (int)(n); ++i)
#define all(a) a.begin(), a.end()
const int MOD = 1e9+7;
const int INF = 1e9;
int main(){
int D, G;
cin >> D >> G;
vector<pii> points;
rep(i, 0, D){
int p, c;
cin >> p >> c;
points.push_back(make_pair(p, c));
}
int ans = INF;
rep(i, 0, 1<<D){
ll score = 0;
int cnt = 0;
int last, prob;
rep(j, 0, D){
if ((i>>j)&1){
score += points[j].first * (j+1) * 100 + points[j].second;
cnt += points[j].first;
}
else{
last = j;
prob = points[j].first;
}
}
while (score < G && prob > 1){
score += (last+1) * 100;
cnt++;
prob--;
}
if (score >= G){
ans = min(ans, cnt);
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i,a,n) for(int i=(a); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define FOR(it,c) for(__typeof((c).begin()) it=(c).begin(); it!=(c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
typedef long long ll;
typedef unsigned long long ull;
int N, M;
vector<int> G[1005];
vector<int> ret;
bool is_valid(const vector<int>& path){
map<int,int> visited;
rep(i,path.size()){
visited[path[i]] = 1;
}
vector<int> in(1005, 0);
rep(i,path.size()){
int x = path[i];
rep(j,G[x].size()){
if(visited[G[x][j]] == 1){
in[G[x][j]]++;
}
}
}
rep(i,path.size()){
int x = path[i];
if(in[x] > 1) return false;
}
return true;
}
void solve(int st){
vector<int> path;
vector<int> parent(1005, -1);
parent[st] = st;
queue<int> que;
que.push(st);
while(!que.empty()){
int v = que.front(); que.pop();
rep(i,G[v].size()){
if(G[v][i] == st){
int x = v;
while(x != st){
path.push_back(x);
x = parent[x];
}
path.push_back(st);
if(!is_valid(path)) return;
break;
}else{
if(parent[G[v][i]] != -1){
}else{
parent[G[v][i]] = v;
que.push(G[v][i]);
}
}
if(path.size() > 0) break;
}
}
if(path.size() == 0) return;
if(ret.size() == 0 || path.size() < ret.size()){
ret = path;
}
}
int main(){
cin >> N >> M;
rep(i,M){
int a, b;
cin >> a >> b;
G[a].push_back(b);
}
REP(i,1,N+1){
solve(i);
}
if(ret.size() == 0) cout << -1 << endl;
else {
cout << ret.size() << endl;
rep(i,ret.size()){
cout << ret[i] << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long A,B,M;
cin>>A>>B>>M;
vector<int> a(A);
for(int i=0;i<A;i++)
cin>>a.at(i);
vector<int> b(B);
for(int i=0;i<B;i++)
cin>>b.at(i);
vector<vector<int>> c(M,vector<int>(3));
for(int i=0;i<M;i++){
for(int j=0;j<3;j++)
cin>>c.at(i).at(j);
}
long long min=a.at(0)+b.at(0);
for(int i=0;i<M;i++){
if(a.at(c.at(i).at(0)-1)+b.at(c.at(i).at(1)-1)-c.at(i).at(2)<min)
min=a.at(c.at(i).at(0)-1)+b.at(c.at(i).at(1)-1)-c.at(i).at(2);
}
sort(a.begin(),a.end());
sort(b.begin(),b.end());
if(a.at(0)+b.at(0)<min)
min=a.at(0)+b.at(0);
cout<<min<<endl;
}
| #include <stdio.h>
#include <vector>
#include <algorithm>
using namespace std;
int main(void)
{
vector<int> twoThrow;
int n;
int m;
int point[1000];
int ans;
while (1){
twoThrow.clear();
scanf("%d%d", &n, &m);
if (n == 0){
break;
}
for (int i = 0; i < n; i++){
scanf("%d", &point[i]);
}
twoThrow.push_back(0);
for (int i = 0; i < n; i++){
twoThrow.push_back(point[i]);
for (int j = i; j < n; j++){
twoThrow.push_back(point[i] + point[j]);
}
}
sort(twoThrow.begin(), twoThrow.end());
int t;
ans = 0;
for (int i = 0; i < twoThrow.size(); i++){
vector<int>::iterator it = upper_bound(twoThrow.begin(), twoThrow.end(), m - twoThrow[i]);
if (it == twoThrow.begin()){
continue;
}
it--;
t = *it;
if (ans < t + twoThrow[i]){
ans = t + twoThrow[i];
}
}
printf("%d\n", ans);
}
return (0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define rrep(i,n) for (int i = 1; i <= (n); i++)
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<int,int>;
int x[10],y[10];
int n;
double f(int i, int j) {
double dx = x[i] - x[j];
double dy = y[i] - y[j];
return pow(dx*dx+dy*dy,0.5);
}
int main() {
cin >> n;
rep(i,n) cin >> x[i] >> y[i];
std::vector<int> v(n);
rep(i,n) v.at(i) = i;
double total = 0.0;
do {
rep(i,n-1) total += f(v[i],v[i+1]);
} while(next_permutation(v.begin(), v.end()));
int num = 1;
for (int i = 2; i <= n; i++) num *= i;
cout << std::fixed << std::setprecision(16) << total / num << endl;
}
| #include "bits/stdc++.h"
#define ff first
#define ss second
#define szof(_x) ((int) (_x).size())
#define TASK_NAME ""
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int INF = 1e9 + 7;
const ll INFL = 1e18 + 123;
const double PI = atan2(0, -1);
mt19937 tw(960172);
ll rnd(ll x, ll y) { static uniform_int_distribution<ll> d; return d(tw) % (y - x + 1) + x; }
void solve() {
int n, s;
cin >> n >> s;
set<pair<int, ll>> all;
for (int i = 0; i < n; ++i) {
int x, p;
cin >> x >> p;
all.insert({x, p});
}
ll ans = 0;
int fl = -1;
while (true) {
if (all.begin()->ff > s) {
ans += (--all.end())->ff - s;
break;
}
if ((--all.end())->ff < s) {
ans += s - all.begin()->ff;
break;
}
if ((all.begin())->ss < (--all.end())->ss) {
auto tmp = *all.begin();
all.erase(all.begin());
auto tmp2 = *--all.end();
all.erase(--all.end());
if (fl != 1) {
ans += tmp2.ff - tmp.ff;
fl = 1;
}
tmp2.ss += tmp.ss;
all.insert(tmp2);
} else {
auto tmp = *all.begin();
all.erase(all.begin());
auto tmp2 = *--all.end();
all.erase(--all.end());
if (fl != 2) {
ans += tmp2.ff - tmp.ff;
fl = 2;
}
tmp.ss += tmp2.ss;
all.insert(tmp);
}
//cerr << ans << endl;
}
cout << ans << "\n";
}
int main() {
//freopen(TASK_NAME ".in", "r", stdin);
//freopen(TASK_NAME ".out", "w", stdout);
cerr << fixed << setprecision(15);
cout << fixed << setprecision(15);
ios::sync_with_stdio(false);
int tests = 1;
// cin >> tests;
for (int it = 1; it <= tests; ++it) {
solve();
}
#ifdef LOCAL
cerr << "time: " << clock() << " ms\n";
#endif
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define ALL(c) (c).begin(),(c).end()
#ifdef LOCAL
#define dump(x) cerr << __LINE__ << " " << #x << " = " << (x) << endl
#else
#define dump(x) true
#endif
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n-1); }
template<class T, class U> void chmin(T& t, const U& u) { if (t > u) t = u; }
template<class T, class U> void chmax(T& t, const U& u) { if (t < u) t = u; }
template<class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os<<"("<<p.first<<","<<p.second<<")";
return os;
}
template<class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os<<"{";
rep(i, v.size()) {
if (i) os<<",";
os<<v[i];
}
os<<"}";
return os;
}
ll dp[6010][6010];
int main() {
int N; ll M;
cin >> N >> M;
int n = N * 3;
dp[0][0] = 1;
for (int i = 1; i <= n; ++i) {
if (i >= 3) {
for (int j = 0; j <= n; ++j) {
(dp[i][j+1] += dp[i-3][j] * (i-1) % M * (i-2)) %= M;
}
}
if (i >= 2) {
for (int j = 0; j <= n; ++j) {
(dp[i][j+1] += dp[i-2][j] * (i-1)) %= M;
}
}
for (int j = 0; j <= n; ++j) {
(dp[i][j] += dp[i-1][j]) %= M;
}
}
ll ans = 0;
for (int i = 0; i <= N; ++i) {
ans = (ans + dp[n][i]) % M;
}
cout << ans << endl;
return 0;
} | #include "bits/stdc++.h"
typedef long long ll;
#define int ll
#define fi first
#define se second
#define SORT(a) sort(a.begin(),a.end())
#define rep(i,n) for(int i = 0;i < (n) ; i++)
#define REP(i,n) for(int i = 0;i < (n) ; i++)
#define MP(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define INF LLONG_MAX/2
#define all(x) (x).begin(),(x).end()
#define debug(x) cerr<<#x<<": "<<x<<endl
#define debug_vec(v) cerr<<#v<<":";rep(i,v.size())cerr<<" "<<v[i];cerr<<endl
using namespace std;
#define N 1010
int MOD = 1000000007;
int fac[N+1];
int inv[N+1];
ll bitpow(ll x,ll n){
ll ans = 1;
while(n > 0){
if(n%2 == 1) ans = ans * x % MOD;
x = x * x %MOD;
n = n >> 1;
}
return ans;
}
ll COM(ll n,ll k){
return fac[n]*inv[k]%MOD*inv[n-k]%MOD;
}
int dp[1010][1010] = {0};
signed main(){
int n,a,b,c,d;
cin >> n >> a >> b >> c >> d;
fac[0] = 1;
inv[0] = 1;
for(int i = 1;i <= N;i++){
fac[i] = fac[i-1]*i%MOD;
inv[i] = bitpow(fac[i],MOD-2)%MOD;
}
dp[a-1][0] = 1;
for(int i = a;i <= b;i++){
for(int j = 0;j <= n;j++){
dp[i][j] = dp[i-1][j];
for(int k = c;k <= d;k++){
if(j-i*k < 0 || i*k > n)break;
dp[i][j] += dp[i-1][j-i*k] * fac[n-(j-i*k)] %MOD * inv[n-(j-i*k) - i*k] %MOD * inv[k]%MOD * bitpow(inv[i],k)%MOD;
dp[i][j] %= MOD;
// if(i == 3){
// //cerr << "j : dp[i-1][j-i*k] : fac[n-(j-i*k)] : inv[n-i*k] : inv[k] : bitpow(inv[i],k)" << endl;
// //cerr << j << " " << dp[i-1][j-i*k] << " : " << fac[n-(j-i*k)]<< " : "<< inv[n-i*k] << " : "<< inv[k] << " : "<< bitpow(inv[i],k);
// //cerr << endl;
// }
}
}
}
cout << dp[b][n] << endl;
return 0;
}
// g++ -std=c++14 code1.cpp
// rm -r -f test;oj dl https://yahoo-procon2019-qual.contest.atcoder.jp/tasks/yahoo_procon2019_qual_d
// rm -r -f test;oj dl http://arc067.contest.atcoder.jp/tasks/arc067_c | 0 |
#include <bits/stdc++.h>
// #include <atcoder/all>
#define ll long long int
#define ld long double
#define yorn(f) cout<<((f)?"Yes":"No")<<endl;
#define YORN(f) cout<<((f)?"YES":"NO")<<endl;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repi(i, n) for (ll i = 1; i < (ll)(n); i++)
#define all(x) (x).begin(), (x).end()
#define put(x) cout << x << endl;
#define println(x) cout << x << endl;
using namespace std;
// using namespace atcoder;
void Main()
{
ll n;
cin >> n;
vector<ll> A(n);
rep(i, n) cin >> A[i];
ll pow2 = 1;
ll sum = 0;
ll mod = 7LL + 1e9;
rep(_i, 61) {
ll one = 0, zero = 0;
rep(i, n) {
ll v = A[i] % 2;
if (v == 1) one++;
else zero++;
A[i] /= 2;
}
sum += (one * zero % mod) * pow2 % mod;
sum %= mod;
pow2 *= 2;
pow2 %= mod;
}
put(sum);
}
signed main(){ Main();return 0;} | // /*
// "Won't stop until I'm phenomenal."
// - Phenomenal, Eminem
// */
// #include<bits/stdc++.h>
// using namespace std;
// typedef long long int ll;
// #define ff first
// #define Shazam ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
// #define ss second
// #define all(c) c.begin(),c.end()
// #define endl "\n"
// #define test() int t; cin>>t; while(t--)
// #define fl(i,a,b) for(int i = a ; i <b ;i++)
// #define get(a) fl(i,0,a.size()) cin>>a[i];
// #define pra(a) fl(i,0,a.size()) cout<<a[i]<<" "; cout<<endl;
// #define pr(a,n) fl(i,0,n) cout<<a[i]<<" "; cout<<endl;
// const ll INF = 2e18;
// const int inf = 2e9;
// const int mod1 = 1e9 + 7;
// int main(){
// Shazam;
// int n; cin>>n;
// vector<ll> a(n);
// for(ll &i : a)
// cin>>i;
// vector<vector<int>> table(63, vector<int> (n));
// for(int bit = 0; bit < 63; bit++){
// for(int i = 0 ; i < n; i++){
// table[bit][i] = ((a[i]&(1LL<<bit)) > 0);
// }
// }
// auto add = [&](ll &a, ll b){
// a = (a + b)%mod1;
// };
// ll ans = 0;
// for(int bit = 0; bit < 63; bit++){
// ll x = count(table[bit].begin(), table[bit].end(),0);
// ll y = n - x;
// add(ans, (1LL<<bit)%mod1*y%mod1*x%mod1);
// }
// cout<<ans<<endl;
// return 0;
// }
/*
"Won't stop until I'm phenomenal."
- Phenomenal, Eminem
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define ff first
#define Shazam ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define ss second
#define all(c) c.begin(),c.end()
#define endl "\n"
#define test() int t; cin>>t; while(t--)
#define fl(i,a,b) for(int i = a ; i <b ;i++)
#define get(a) fl(i,0,a.size()) cin>>a[i];
#define pra(a) fl(i,0,a.size()) cout<<a[i]<<" "; cout<<endl;
#define pr(a,n) fl(i,0,n) cout<<a[i]<<" "; cout<<endl;
const ll INF = 2e18;
const int inf = 2e9;
const int mod1 = 1e9 + 7;
int main(){
Shazam;
int n; cin>>n;
vector<ll> a(n);
for(ll &i : a)
cin>>i;
vector<vector<int>> table(61, vector<int> (n));
for(int bit = 0; bit < 61; bit++){
for(int i = 0 ; i < n; i++){
table[bit][i] = ((a[i]&(1LL<<bit)) > 0);
if(i)
table[bit][i]+=table[bit][i-1];
}
}
auto add = [&](ll &a, ll b){
a = (a + b)%mod1;
};
ll ans = 0;
for(int bit = 0; bit < 61; bit++){
for(int i = 0; i < n-1; i++){
if(!(a[i]&(1LL<<bit)))
add(ans, (table[bit][n-1]-table[bit][i-1])*((1LL<<bit)%mod1)%mod1);
else
add(ans, (n- i - (table[bit][n-1]-table[bit][i-1]))*((1LL<<bit)%mod1)%mod1);
}
}
cout<<ans<<endl;
return 0;
} | 1 |
#include<iostream>
int main(){
int x,n=1;
std::cin>>x;
for(int i=0;i<3;++i){
n=n*x;
}
std::cout<<n<<std::endl;
}
| #include <iostream>
using namespace std;
int main(void)
{
int input;
int output;
cin >> input;
output = input * input * input;
cout << output << endl;
return 0;
}
| 1 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(void){
int a,b,c;
while(cin>>a>>b>>c && (a||b||c)){
int i,n;
cin>>n;
int res[a+b+c+1];
int tmp[n][3];
fill(res,res+a+b+c+1,2);
for(i=0;i<n;i++){
int I,J,K,R;
cin>>I>>J>>K>>R;
if(R == 1){
res[I] = res[J] = res[K] = 1;
i--;
n--;
}
else{
tmp[i][0] = I;
tmp[i][1] = J;
tmp[i][2] = K;
}
}
int size = i;
for(i=0;i<size;i++){
if(res[tmp[i][0]] == 1 && res[tmp[i][1]] == 1) res[tmp[i][2]] = 0;
else if(res[tmp[i][0]] == 1 && res[tmp[i][2]] == 1) res[tmp[i][1]] = 0;
else if(res[tmp[i][1]] == 1 && res[tmp[i][2]] == 1) res[tmp[i][0]] = 0;
}
for(i=1;i<=a+b+c;i++){
cout<<res[i]<<endl;
}
}
return 0;
} | #include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
const ll INF = 1LL<<32;;
int n,m;
ll dis[300][300];
int main()
{
cin >> n >> m;
int i,j,k;
for(i = 0;i < n;i++)
for(j = 0;j < n;j++)
{
if(i == j)
dis[i][j] = 0;
else
dis[i][j] = INF;
}
while(m--)
{
int a,b,c;
cin >> a >> b >> c;
dis[a][b] = c;
}
for(k = 0 ; k<n ; k++){
for(i = 0 ; i<n ; i++){
if(dis[i][k] == INF)
continue;
for(j = 0 ; j<n ; j++){
if(dis[k][j] == INF)
continue;
dis[i][j] = min(dis[i][j] , dis[i][k]+dis[k][j]);
}
}
}
bool flag = 0;
for( i = 0 ; i<n ; i++)
{
if(dis[i][i] < 0)
{
flag = 1;
break;
}
}
if(flag == 1)
cout << "NEGATIVE CYCLE" << endl;
else
{
for(i = 0;i < n;i++)
{
for(j = 0;j < n;j++)
{
if(j == n-1)
{
if(dis[i][j] == INF)
cout << "INF";
else
cout << dis[i][j];
}
else
{
if(dis[i][j] == INF)
cout << "INF ";
else
cout << dis[i][j] << ' ';
}
}
cout << endl;
}
}
return 0;
}
| 0 |
#include <iostream>
using namespace std;
int main(){
int n,h,w;
cin>>n>>h>>w;
int count = (n-h+1)*(n-w+1);
cout<<count<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n,w,h;
cin>>n>>h>>w;
int cnt=0;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if(n-i+1>=h&&n-j+1>=w)
cnt++;
}
}
cout<<cnt<<endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define all(x) begin(x), end(x)
#define _ << ' ' <<
using namespace std;
using ll = long long;
int main()
{
int a, b, c;
cin >> a >> b >> c;
if (c > min(a, b) && c < max(a, b))
cout << "Yes";
else
cout << "No";
}
| /*
author : nishi5451
created : 14.08.2020 21:24:46
*/
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
typedef long long ll;
const int INF = 2020202020;
int main(){
int n,m,x,y;
cin >> n >> m >> x >> y;
int l = x, r = y;
rep(i,n){
int a;
cin >> a;
l = max(l,a);
}
rep(i,m){
int a;
cin >> a;
r = min(r,a);
}
if(r-l >= 1) cout << "No War" << endl;
else cout << "War" << endl;
return 0;
} | 0 |
#include <cstdio>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
size_t ldistance(string s, string t) {
/* Levenshtein Distance */
size_t slen=s.length(), tlen=t.length();
vector<vector<size_t>> dp(slen+1, vector<size_t>(tlen+1));
for (size_t i=0; i<=slen; ++i)
dp[i][0] = i;
for (size_t j=0; j<=tlen; ++j)
dp[0][j] = j;
for (size_t i=1; i<=slen; ++i)
for (size_t j=1; j<=tlen; ++j) {
size_t cost=(s[i-1]!=t[j-1]);
dp[i][j] = min(min(dp[i-1][j], dp[i][j-1])+1, dp[i-1][j-1]+cost);
}
return dp[slen][tlen];
}
int main() {
char buf[1024];
scanf("%s", buf);
string s1(buf);
scanf("%s", buf);
string s2(buf);
printf("%zu\n", ldistance(s1, s2));
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int main(){
string s1,s2;
cin >> s1 >> s2;
//d[i][j]:=?????????s1???1?????????~i??????????????§?????¨??????????????¨?????????s2???1?????????~j??????????????§?????¨?????????????????¨????????¢
//(index???0?????¨??????????????????????????¨???)
int d[1001][1001]={0};
//????????????????????????0??????????????????????????\?????????????¶???????????????????
for(int i=0; i<=s1.size(); ++i) d[i][0]=i;
for(int i=0; i<=s2.size(); ++i) d[0][i]=i;
for(int i=1; i<=s1.size(); ++i){
for(int j=1; j<=s2.size(); ++j){
int tmp = d[i-1][j-1];
if(s1[i-1]!=s2[j-1]) tmp++;
d[i][j] = min(tmp, min(d[i-1][j]+1,d[i][j-1]+1));
}
}
printf("%d\n", d[s1.size()][s2.size()]);
} | 1 |
#include <iostream>
#include <stdio.h>
using namespace std;
int main() {
int n,p;//~50
int stone,player[50]={};
int winner;
int i;
scanf("%d%d",&n,&p);
while(1){
for(i=0;i<50;i++){
player[i]=0;
}
stone=p;
for(i=0;;i++){
if(stone==0){
stone=player[i%n];
player[i%n]=0;
}
else{
stone-=1;
player[i%n]+=1;
}
if((stone==0)&&(player[i%n]==p)){
winner=i%n;
break;
}
}
printf("%d\n",winner);
scanf("%d%d",&n,&p);
if((n==0)&&(p==0)){break;}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 200100;
int N;
string s;
int ans[MAXN];
bool wolo()
{
for (int i = 1; i <= N + 1; i++)
{
int av = 0;
if (s[i] == 'x') av = 1;
ans[i+1] = (av + ans[i] + ans[i-1]) % 2;
if (i + 1 >= N && ans[i+1] != ans[i+1-N]) return false;
}
return true;
}
int main()
{
ios_base::sync_with_stdio(0);
cin >> N >> s;
s += s;
for (int i = 0; i < 4; i++)
{
ans[0] = i % 2;
ans[1] = i / 2;
if (wolo())
{
for (int j = 0; j < N; j++)
{
if (ans[j]) cout << 'W';
else cout << 'S';
}
cout << "\n";
return 0;
}
}
cout << "-1\n";
} | 0 |
#include <bits/stdc++.h>
#define REP(i, e) for(int (i) = 0; (i) < (e); ++(i))
#define FOR(i, b, e) for(int (i) = (b); (i) < (e); ++(i))
#define ALL(c) (c).begin(), (c).end()
#define PRINT(x) cout << (x) << "\n"
using namespace std;
using ll = long long; using pint = pair<int, int>; using pll = pair<ll, ll>;
template<typename T> auto compare = [](T x, T y) -> bool{return (x < y);};
const int MOD = 1000000007;
int N, a[100010];
string S;
signed main(){
cin >> N >> S;
REP(st, 4){
if(st & 1){
a[0] = 1;
if(st & 2) a[N - 1] = 1;
else a[N - 1] = 0;
}else{
a[0] = 0;
if(st & 2) a[N - 1] = 1;
else a[N - 1] = 0;
}
REP(i, N){
if(a[i] == 0){
if(S[i] == 'o') a[(i + 1 + N) % N] = a[(i - 1 + N) % N];
else a[(i + 1 + N) % N] = 1 - a[(i - 1 + N) % N];
}else{
if(S[i] == 'o') a[(i + 1 + N) % N] = 1 - a[(i - 1 + N) % N];
else a[(i + 1 + N) % N] = a[(i - 1 + N) % N];
}
}
if(st & 1){
if(a[0] == 0) continue;
if(st & 2){
if(a[N - 1] == 0) continue;
}else{
if(a[N - 1] == 1) continue;
}
}else{
if(a[0] == 1) continue;
if(st & 2){
if(a[N - 1] == 0) continue;
}else{
if(a[N - 1] == 1) continue;
}
}
REP(i, N){
if(a[i] == 0) cout << "S";
else cout << "W";
}
cout << endl;
return 0;
}
PRINT("-1");
return 0;
} | 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 <iostream>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <algorithm>
#include <cmath>
#include <time.h>
#include <unordered_set>
#include <bitset>
#include <deque>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<ll> vi;
#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 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};
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 (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
const int N = 100500;
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
string S;
cin >> n >> S;
for (int a = 0; a < 2; a++)
{
for (int b = 0; b < 2; b++)
{
string s(n, ' ');
if (a == 0) s[0] = 'S'; else s[0] = 'W';
if (b == 0) s[1] = 'S'; else s[1] = 'W';
for (int i = 1; i + 1 < n; i++)
{
if ((s[i] == 'S' && S[i] == 'o') || (s[i] == 'W' && S[i] == 'x')) s[i + 1] = s[i - 1];
else s[i + 1] = 'S' + 'W' - s[i - 1];
}
int t = 1;
if ((s.back() == 'S' && S.back() == 'o') || (s.back() == 'W' && S.back() == 'x')) t &= (s[n - 2] == s[0]);
else t &= (s[n - 2] != s[0]);
if ((s[0] == 'S' && S[0] == 'o') || (s[0] == 'W' && S[0] == 'x')) t &= (s[1] == s.back());
else t &= (s[1] != s.back());
if (t) cout << s, exit(0);
}
}
cout << -1 << "\n";
}
/* 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.
*/
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
using P = pair<int,int>;
/* ちゃんと考えてわかって実装 */
// O(\sqrt{n})
vector<ll> divisor(ll n){
vector<ll> res;
for(ll i=1; i*i <= n; i++){
if(n%i == 0){
res.push_back(i);
if(i != n / i) res.push_back(n / i);
}
}
return res;
}
int main(void){
ll n, m;
cin >> n >> m;
vector<ll> divs = divisor(m);
sort(divs.begin(), divs.end());
ll ans;
for(ll i=0; i<divs.size(); i++){
if(divs[i] * n <= m){
ans = divs[i];
}
}
cout << ans << endl;
return 0;
} | #include<cstdio>
#include<utility>
#include<iostream>
#define RI register int
#define CI const int&
#define mp make_pair
#define fi first
#define se second
using namespace std;
typedef pair <int,int> pi;
const int N=1005,dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
inline char get_ch(void)
{
char ch; while (ch=getchar(),ch!='#'&&ch!='.'); return ch;
}
int n,m,stp[N][N],ans; pi q[N*N];
int main()
{
RI i,j,H=0,T=0; for (scanf("%d%d",&n,&m),i=1;i<=n;++i)
for (j=1;j<=m;++j) if (get_ch()=='#') q[++T]=mp(i,j); else stp[i][j]=1e9;
while (H<T)
{
int nx=q[++H].fi,ny=q[H].se; for (i=0;i<4;++i)
{
int tx=nx+dx[i],ty=ny+dy[i];
if (tx>=1&&tx<=n&&ty>=1&&ty<=m&&stp[tx][ty]>stp[nx][ny]+1)
stp[tx][ty]=stp[nx][ny]+1,q[++T]=mp(tx,ty);
}
}
for (i=1;i<=n;++i) for (j=1;j<=m;++j) ans=max(ans,stp[i][j]);
return printf("%d",ans),0;
} | 0 |
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int lld;
const lld N = 200043;
const lld MOD = 1000000007;
lld add(lld x, lld y)
{
x =((x%MOD)+(y%MOD))%MOD;
while(x >= MOD) x -= MOD;
while(x < 0) x += MOD;
return x;
}
lld mul(lld x, lld y)
{
return ((x%MOD)*(y%MOD))% MOD;
}
lld binpow(lld x, lld y)
{
lld z = 1;
while(y)
{
if(y & 1) z = mul(z, x);
x = mul(x, x);
y >>= 1;
}
return z;
}
lld inv(lld x)
{
return binpow(x, MOD - 2);
}
lld divide(lld x, lld y)
{
return mul(x, inv(y));
}
// Combinations
/*
lld fact[N];
void precalc()
{
fact[0] = 1;
for(lld i = 1; i < N; i++)
fact[i] = mul(fact[i - 1], i);
}
lld C(lld n, lld k)
{
return divide(fact[n], mul(fact[k], fact[n - k]));
}
*/
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
lld t,i,j;
//cin>>t;
t=1;
while(t--)
{
lld n;
cin>>n;
vector<lld>ar(n);
for(i=0;i<n;i++)
cin>>ar[i];
sort(ar.begin(),ar.end());
lld ans=0;
for(i=0;i<n;i++)
{
for(j=i+1;j<n;j++)
{
for(lld k=j+1;k<n;k++)
if(ar[i]+ar[j]>ar[k] && ar[i]!=ar[j] && ar[i]!=ar[k] && ar[k]!=ar[j])
ans++;
}
}
cout<<ans<<endl;
}
}
| #include <iostream>
#include <vector>
using namespace std;
int main(){
long long N,ans=0;
cin>>N;
vector<long long> A(N);
for(int i=0;i<N;i++) cin>>A[i];
for(int i=1;i<N;i++){
if(A[i]<A[i-1]){
ans+=A[i-1]-A[i];
A[i] = A[i-1];
}
}
cout<<ans<<endl;
} | 0 |
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
int main(){
string s;
cin >> s;
int ans = 1000;
for(int i = 0; i+2 < s.length(); i++){
int num = (s[i]-'0')*100+(s[i+1]-'0')*10+(s[i+2]-'0');
if(abs(753-num) < ans) ans = abs(753-num);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
int n;
cin >> n;
ll ans = 0;
for (int i = 1; i <= n; ++i) {
if (i % 3 && i % 5) ans += i;
}
cout << ans << endl;
return 0;
} | 0 |
#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <bitset>
#include <complex>
using namespace std;
const double EPS = 1e-9;
const double PI = 3.14159265359;
typedef complex<double> P;
typedef long long int li;
int main(){
int n;
string hos = "Hoshino";
cin >> n;
cin.ignore();
while(n--){
string s;
getline(cin, s);
int k = s.size()+1-hos.size();
for(int i = 0; i < k; i++){
if(s.substr(i, hos.size()) == hos){
s[i+hos.size()-1] = 'a';
}
}
cout << s << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define pb push_back
#define pll pair <ll, ll>
#define mp make_pair
#define pyshnapyshnakaa ios_base :: sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define x first
#define y second
#pragma GCC optimize("O3")
// #pragma GCC optimize("Ofast")
// #pragma GCC optimize("unroll-loops")
#define plll pair <ll, pair <ll, ll>>
#define pllll pair <pair <ll, ll>, pair <ll, ll> >
#define psl pair <string, ll>
#define all(a) a.begin(), a.end()
#define vvl vector <vector <ll> >
typedef long long ll;
typedef long double ld;
using namespace std;
const ll maxn = 1e3 + 10;
ll n, m, k, t;
ll x, y;
ll ANS[maxn][maxn];
int main() {
pyshnapyshnakaa;
ll q, w, e, a, b, c;
cin >> n >> m >> x >> y;
for (q = 0; q < n; q++) {
for (w = 0; w < x; w++) {
ANS[q][w] = 0;
}
for (w = x; w < m; w++) {
ANS[q][w] = 1;
}
}
for (q = 0; q < y; q++) {
for (w = 0; w < m; w++) {
ANS[q][w] ^= 1;
}
}
for (q = 0; q < n; q++) {
for (w = 0; w < m; w++) {
cout << ANS[q][w];
}
cout << endl;
}
return 0;
}
| 0 |
#include <iostream>
#include <math.h>
#include <queue>
#include <algorithm>
#include <map>
#include <set>
#include <cstdlib>
#include <unordered_map>
#include <numeric>
#include <functional>
#include <limits.h>
#include <utility>
#include <stack>
using namespace std;
#define fs first
#define sc second
typedef long long ll;
typedef pair<ll, ll> P;
const ll mod = 998244353;
ll fact[5010200];
ll invfact[5010200];
inline ll take_mod(ll a){
return (a % mod + mod) % mod;
}
inline ll add(ll a, ll b){
return take_mod(a+b);
}
inline ll sub(ll a, ll b){
return take_mod(a + mod -b);
}
inline ll mul(ll a, ll b){
return take_mod(a * b);
}
inline ll pow(ll x, ll n){
ll res = 1LL;
while(n > 0){
if(n & 1) res = mul(res, x);
x = mul(x, x);
n >>= 1;
}
return res;
}
ll mod_inv(ll x){
return pow(x, mod-2);
}
// nは上限
void make_fact(ll n){
fact[0] = 1;
ll res = 1;
for(int i = 1; i <= n; i++){
fact[i] = res;
res = mul(res, i+1);
}
}
// nは上限
void make_invfact(ll n){
invfact[0] = 1;
invfact[n] = mod_inv(fact[n]);
for(int i = n-1; i >= 1; i--){
invfact[i] = mul(invfact[i + 1], i + 1);
}
}
ll perm(ll n, ll k){
return mul(fact[n], invfact[n-k]);
}
ll comb(ll n, ll k){
if(k == 0){
return 1;
}
return mul(mul(fact[n], invfact[n-k]), invfact[k]);
}
int main(){
ll N, M;
cin >> N >> M;
make_fact(5010000);
make_invfact(5010000);
ll res = 1;
res = mul(res, comb(3 * M + N - 1, N-1));
for(ll i = 2 * M + 1; i <= 3 * M; i++){
ll remain = 3 * M - i;
ll tmp = mul(N, comb(N + remain - 2, N-2));
res = sub(res, tmp);
}
for(ll x = M + 1; x <= N; x++){
if(3 * M - x < 0 || (3 * M - x) % 2 == 1){
continue;
}
if(x > N){
continue;
}
ll ball = (3 * M - x) / 2;
ll tmp = mul(comb(N, x), comb(ball + N - 1, N-1));
res = sub(res, tmp);
}
cout << res << endl;
} | #include<bits/stdc++.h>
#define LL long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
using namespace std;
inline int read(){
int v=0,f=1;
char c=getchar();
while (c<'0' || c>'9'){
if (c=='-') f=-1;
c=getchar();
}
while (c>='0' && c<='9'){
v=v*10+c-'0';
c=getchar();
}
return v*f;
}
const int Maxn=2000005;
const int mod=998244353;
int fact[Maxn],ivf[Maxn];
int qp(int x,int p){
int ret=1;
while (p){
if (p&1) ret=1ll*ret*x%mod;
x=1ll*x*x%mod;
p>>=1;
}
return ret;
}
int inv(int x){
return qp(x,mod-2);
}
int C(int x,int y){
return 1ll*fact[x]*ivf[y]%mod*ivf[x-y]%mod;
}
void _init(){
fact[0]=1;
for (int i=1;i<Maxn;i++){
fact[i]=1ll*fact[i-1]*i%mod;
ivf[i]=inv(fact[i]);
}
ivf[0]=1;
}
int main(){
_init();
int n,m;
scanf("%d %d",&n,&m);
int ans=0;
for (int i=m;i>=0;i-=2){
if (i>n) continue;
int rem=(3*m-i)/2;
ans+=1ll*C(n,i)*C(rem+n-1,n-1)%mod;
if (ans>=mod) ans-=mod;
}
// cout<<ans<<endl;
for (int i=m;i>=0;i-=2){
if (i>n) continue;
int rem=(3*m-i)/2;
rem-=m;
ans-=1ll*C(n,i)*C(rem+n-1,n-1)%mod*i%mod;
if (ans<0) ans+=mod;
}
for (int i=m;i>=0;i-=2){
if (i>n) continue;
int rem=(3*m-i)/2;
rem-=m+1;
if (rem<0) continue;
ans-=1ll*C(n,i)*C(rem+n-1,n-1)%mod*(n-i)%mod;
if (ans<0) ans+=mod;
}
printf("%d\n",ans);
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n)for(long long i=0;i<(long long)(n);++i)
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
const int MOD=1e9+7;
const ll INF=1e18;
const int MAX=510000;
const double pi=acos(-1);
int dx[8] = {1,0,-1,0,1,1,-1,-1};
int dy[8] = {0,1,0,-1,-1,1,1,-1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n,q;
cin >> n >> q;
vector<tuple<int,int,int>> stx(n);
rep(i,n){
cin >> get<1>(stx[i]) >> get<2>(stx[i]) >> get<0>(stx[i]);
}
sort(stx.begin(),stx.end());
set<P> st;
rep(i,q){
int x;
cin >> x;
st.emplace(x,i);
}
vector<int> ans(q,-1);
rep(i,n){
int s = get<1>(stx[i]);
int t = get<2>(stx[i]);
int x = get<0>(stx[i]);
//xの昇順で考えてぶつかったら，その人をerase
auto first = st.lower_bound(P(s-x,0));//引っかかる人
auto end = st.upper_bound(P(t-x-1,q));//引っかからない人
for(auto it = first; it !=end; ++it) ans[it->second] = x;
st.erase(first,end);
}
rep(i,q) cout << ans[i] << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1e18;
const int S = 1 << 18;
ll seg[2*S];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int N, Q; cin >> N >> Q;
vector<pair<pair<ll, ll>, ll>> blocks(N);
for (int i = 0; i < N; i++) {
ll s, t, x; cin >> s >> t >> x;
s -= x, t -= x;
blocks[i] = {{s,t}, x};
}
vector<ll> D(Q);
for (int q = 0; q < Q; q++) {
cin >> D[q];
}
for (int i = 0; i < 2 * S; i++) {
seg[i] = INF;
}
for (int i = 0; i < N; i++) {
ll s = blocks[i].first.first, t = blocks[i].first.second, x = blocks[i].second;
int si = int(lower_bound(D.begin(), D.end(), s) - D.begin());
int ti = int(lower_bound(D.begin(), D.end(), t) - D.begin());
for (int a = S+si, b = S+ti; a < b; a /= 2, b /= 2) {
if (a & 1) {
seg[a] = min(seg[a], x);
a++;
}
if (b & 1) {
--b;
seg[b] = min(seg[b], x);
}
}
}
for (int i = 1; i < S; i++) {
seg[2*i+0] = min(seg[2*i+0], seg[i]);
seg[2*i+1] = min(seg[2*i+1], seg[i]);
}
for (int i = 0; i < Q; i++) {
if (seg[S+i] == INF) cout << -1 << '\n';
else cout << seg[S+i] << '\n';
}
return 0;
}
| 1 |
/*
* Project: AtCoder Beginners Contest 137 B - One Clue
* Author: toms74209200 <https://github.com/toms74209200>
*
* Created on 2020/09/01
* Copyright (c) 2020 toms74209200
*
* This software is released under the MIT License.
* http://opensource.org/licenses/mit-license.php
*/
#include <cstdio>
#include <cstdint>
using namespace std;
int32_t k;
int32_t coord_x;
void solve() {
for (int i=-k+1;i<k;i++) {
printf("%d ", coord_x+i);
}
printf("\n");
}
int main() {
scanf("%d", &k);
scanf("%d", &coord_x);
solve();
}
| #include <iostream> // cout, endl, cin
#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
#include <iomanip> // fixed, setprecision
using namespace std;
int main()
{
int K, X, start = 0, end = 0;
cin >> K >> X;
start = X - K + 1;
end = X + K - 1;
for (int i = start; i <= end; i++)
{
cout << i << " ";
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 1e3 + 7, mod = 1e9 + 7;
int POW(int a, int b, int mod) {
a %= mod; int r = 1;
for(int i = b; i > 0; i >>= 1) {
if(i & 1) r = (r * a) % mod;
a = (a * a) % mod;
}
return r;
}
int f[N], n, dp[10001][1001];
vector <tuple <int, int, int> > v;
vector <int> nxt;
int g(int lft, int idx) {
if(idx >= v.size()) {
return (lft == 0 ? f[n] : 0);
}
if(~dp[idx][lft]) {
return dp[idx][lft];
}
int res = g(lft, idx + 1);
int x, y, z; tie(x, y, z) = v[idx];
if(x * y <= lft) {
res += g(lft - x * y, nxt[idx]) * z % mod;
res %= mod;
}
return dp[idx][lft] = res;
}
int32_t main() {
ios_base :: sync_with_stdio(0); cin.tie(0); cout.tie(0);
f[0] = 1;
for(int i = 1; i < N; i++) {
f[i] = (f[i - 1] * i) % mod;
}
int a, b, c, d; cin >> n >> a >> b >> c >> d;
for(int i = a; i <= b; i++) {
int k = POW(f[i], mod - 2, mod), p = 1;
for(int j = 1; j <= c; j++) {
p = (p * k) % mod;
}
for(int j = c; j <= d; j++) {
if(i * j <= n) {
v.push_back(make_tuple(i, j, (p * POW(f[j], mod - 2, mod)) % mod));
}
p = (p * k) % mod;
}
while(nxt.size() < v.size()) {
nxt.push_back(v.size());
}
}
memset(dp, -1, sizeof dp);
cout << g(n, 0) << endl;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
const int MOD = 1e9+7;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
vector<int> dp(n+1);
dp[0] = 1;
vector<int> clr(3, 0);
rep(i, n) {
int c = 0;
rep(ci, 3) if (clr[ci] == a[i]) ++c;
dp[i+1] = (ll)dp[i] * c % MOD;
rep(ci, 3) {
if (clr[ci] == a[i]) {
clr[ci]++;
break;
}
}
}
cout << dp[n] << endl;
return 0;
} | 0 |
#include <iostream>
using namespace std;
int main(){
int N;
cin >> N;
if(N == 1) cout << "Hello World" << endl;
if(N == 2){
int A, B;
cin >> A >> B;
cout << A + B << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
vector<bool> v(26, true);
for(int i=0; i<s.size(); i++) v[s[i]-'a'] = false;
char ans;
for(int i=0; i<26; i++) {
if(v[i]) {
ans = i+'a';
cout << ans << endl;
break;
}
else if(i==25) cout << "None" << endl;
}
return 0;
} | 0 |
#include <cstdio>
#include <stdlib.h>
int main()
{
int s[600];
int t[6];
int c = 0;
char h[4] = {'N', 'S', 'W', 'E'};
int n;
bool a = false;
scanf("%d", &n);
for (int i = 0; i < 6 * n; i++)
{
scanf("%d", &s[i]);
}
for (int i = 0; i < n; i++)
{
while (1)
{
int k = rand() % 4;
if (h[k] == 'N')
{
t[4] = s[0 + i * 6];
t[0] = s[1 + i * 6];
t[1] = s[5 + i * 6];
t[5] = s[4 + i * 6];
t[2] = s[2 + i * 6];
t[3] = s[3 + i * 6];
}
if (h[k] == 'S')
{
t[0] = s[4 + i * 6];
t[1] = s[0 + i * 6];
t[5] = s[1 + i * 6];
t[4] = s[5 + i * 6];
t[2] = s[2 + i * 6];
t[3] = s[3 + i * 6];
}
if (h[k] == 'W')
{
t[0] = s[2 + i * 6];
t[2] = s[5 + i * 6];
t[5] = s[3 + i * 6];
t[3] = s[0 + i * 6];
t[1] = s[1 + i * 6];
t[4] = s[4 + i * 6];
}
if (h[k] == 'E')
{
t[2] = s[0 + i * 6];
t[5] = s[2 + i * 6];
t[3] = s[5 + i * 6];
t[0] = s[3 + i * 6];
t[1] = s[1 + i * 6];
t[4] = s[4 + i * 6];
}
for (int j = 0; j < 6; j++)
{
s[j + i * 6] = t[j];
}
for (int j = i + 1; j < n; j++)
{
if (s[0 + i * 6] == s[0 + j * 6] && s[1 + i * 6] == s[1 + j * 6] && s[2 + i * 6] == s[2 + j * 6] && s[3 + i * 6] == s[3 + j * 6] && s[4 + i * 6] == s[4 + j * 6] && s[5 + i * 6] == s[5 + j * 6])
{
a = true;
break;
}
}
if (c == 1000)
{
break;
}
c += 1;
}
}
if (a == false)
{
printf("Yes\n");
}
if (a == true)
{
printf("No\n");
}
}
| #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define cinf(n,x) for(int i=0;i<(n);i++)cin>>x[i];
#define ft first
#define sc second
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(),(v).end()
#define mod 1000000007
#define FS fixed<<setprecision(15)
using namespace std;
typedef long long ll;
template<class T> using V=vector<T>;
using Graph = vector<vector<int>>;
using P=pair<ll,ll>;
typedef unsigned long long ull;
typedef long double ldouble;
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=1e18;
ll dp[200005][5];
int main(){
cin.tie(0);ios::sync_with_stdio(false);
ll n;
cin>>n;
V<ll> a(n);
cinf(n,a);
ll k=1+n%2;
rep(i,n+1)rep(j,k+1)dp[i][j]=-INF;
dp[0][0]=0;
rep(i,n){
rep(j,k+1){
chmax(dp[i+1][j+1],dp[i][j]);
ll now=dp[i][j];
if((i+j)%2==0) now+=a[i];
chmax(dp[i+1][j],now);
}
}
cout<<dp[n][k]<<endl;
}
//ペナルティ出しても焦らない ACできると信じろ！！！
/*
V,P(大文字)使用不可
乗算などの際にオーバーフローに注意せよ！
(適切にmodをとれ にぶたんで途中で切り上げろ)
制約をよく読め！
(全探索できるなら全探索しろ)
stringの計算量(扱い)注意
コーナー注意！(特に数値が小さいものについては要検証)
N行出力のときは'\n'
グリッド上では行先が範囲内におさまるかif文で確認(RE注意)
if文ではちゃんと比較演算子==を使え(=でもエラー出ない)
配列(vector)の大きさが0か1以上かで場合分けせよ(RE注意)
(vector<int> a(m)でm==0というものはできない)
modはなるべく最後に取れ！
*/ | 0 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
// freopen("AGC010-D.in", "r", stdin);
int n, cur = 0;
cin >> n;
vector<int> arr(n);
copy(istream_iterator<int>(cin), istream_iterator<int>(), arr.begin());
string str[] = {"First", "Second"}, ans;
while (ans.empty()) {
int cnt = count_if(arr.begin(), arr.end(), [&] (int x) { return x % 2 == 0; });
if (cnt & 1) {
ans = str[cur];
break;
}
cur ^= 1;
if (cnt != n - 1) {
ans = str[cur];
}
int g = 0;
for_each(arr.begin(), arr.end(), [&] (int x) {
if (x == 1) {
ans = str[cur];
}
x -= x & 1;
while (x) {
int r = g % x;
g = x;
x = r;
}
});
if (!g) {
break;
}
for_each(arr.begin(), arr.end(), [&] (int &x) { x /= g; });
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep2(i, x, n) for(int i = x; i <= n; i++)
#define rep3(i, x, n) for(int i = x; i >= n; i--)
#define elif else if
#define sp(x) fixed << setprecision(x)
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define sz(x) (int)x.size()
using ll = long long;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const ll MOD = 1000000007;
//const ll MOD = 998244353;
const int inf = (1<<30)-1;
const ll INF = (1LL<<60)-1;
const double pi = acos(-1.0);
const double EPS = 1e-10;
template<typename T> bool chmax(T &x, const T &y) {return (x < y)? (x = y, true) : false;};
template<typename T> bool chmin(T &x, const T &y) {return (x > y)? (x = y, true) : false;};
int N;
int A[100000];
int res(){
int K = 0;
rep(i, N){
if(A[i]%2 == 0) K++;
}
if(K&1) return 1;
if(K != N-1) return 0;
int g = A[0]&~1;
rep(i, N){
if(A[i] == 1) return 0;
if(A[i]%2 == 1) A[i]--;
g = gcd(g, A[i]);
}
rep(i, N) A[i] /= g;
return res()^1;
}
int main(){
cin >> N;
rep(i, N) cin >> A[i];
cout << (res()? "First" : "Second") << endl;
} | 1 |
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cmath>
#include <numeric>
#include <iomanip>
#include <stack>
#include <complex>
#include <functional>
#include <tuple>
using namespace std;
#define Rep(i,a,b) for(ll i = a; i < b; ++i)
#define rep(i,b) Rep(i,0,b)
#define allof(a) (a).begin(), (a).end()
#define Yes(q) ((q) ? "Yes" : "No")
#define YES(q) ((q) ? "YES" : "NO")
#define Possible(q) ((q) ? "Possible" : "Impossible")
#define POSSIBLE(q) ((q) ? "POSSIBLE" : "IMPOSSIBLE")
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll infll = 1ll << 60ll;
constexpr ll mod = 1e9 + 7;
// 0~3までは右下左上 4~7までは斜め
constexpr int dx[] = { 1, 0, -1, 0, 1, -1 };
constexpr int dy[] = { 0, 1, 0, -1, 1, 1 };
namespace {
template<typename T> bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<typename T> bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
// 標準出力
void Write(long long x, const char* end = "\n") { std::cout << x << end; }
template <typename T> void Write(const T& x, const char* end = "\n") { std::cout << x << end; }
template <typename T, typename U> void Write(const T& x, const U& y, const char* end = "\n") { std::cout << x << " " << y << end; }
template <typename T, typename U, typename V> void Write(const T& x, const U& y, const V& z, const char* end = "\n") { std::cout << x << " " << y << " " << z << end; }
//template <typename... Args> void Write(Args const&... args) { bool a = true; for (auto const& x : { args... }) { if (a) a = false; else std::cout << " "; std::cout << x; } std::cout << "\n"; }
template <typename T> void Write(const std::vector<T>& x, const char* sep = " ", const char* end = "\n") { for (std::size_t i = 0, sz = x.size(); i < sz; ++i) { std::cout << x[i] << (i == sz - 1 ? end : sep); } }
template <typename T> void Write(const std::vector<std::vector<T>>& x, const char* sep = " ", const char* end = "\n") { for (auto v : x) Write(v, sep, end); }
// 標準入力
struct Read {
std::size_t szi, szj;
Read(std::size_t _szi = 1, std::size_t _szj = 1) : szi(_szi), szj(_szj) {}
template <typename T> operator T () const { T a; std::cin >> a; return a; }
template <typename T> operator std::vector<T>() const { std::vector<T> a(szi); for (std::size_t i = 0; i < szi; ++i) std::cin >> a[i]; return a; }
template <typename T> operator std::vector<std::vector<T>>() const {
std::vector<std::vector<T>> a(szi, std::vector<T>(szj));
for (std::size_t i = 0; i < szi; ++i) for (std::size_t j = 0; j < szj; ++j) cin >> a[i][j]; return a;
}
template <typename T, typename U> operator std::vector<std::pair<T, U>>() const {
std::vector<std::pair<T, U>> a(szi);
for (std::size_t i = 0; i < szi; ++i) std::cin >> a[i].first >> a[i].second; return a;
}
};
struct Reads {
template <typename T> Reads(T& a) { std::cin >> a; }
template <typename T, typename U> Reads(T& a, U& b) { std::cin >> a >> b; }
template <typename T, typename U, typename V> Reads(T& a, U& b, V& c) { std::cin >> a >> b >> c; }
template <typename T, typename U, typename V, typename W> Reads(T& a, U& b, V& c, W& d) { std::cin >> a >> b >> c >> d; }
};
Read read;
}
int main() {
int k, t; Reads(k, t);
vector<int> a = Read(t);
int ans = *max_element(allof(a)) * 2 - k - 1;
chmax(ans, 0);
Write(ans);
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
#define mes(a,b) memset((a),(b),sizeof((a)))
#define syio std::ios::sync_with_stdio(false); std::cin.tie(0); std::cout.tie(0);
#define lson l, mid, rt << 1
#define rson mid+1, r, rt << 1 | 1
typedef long long ll;
typedef long double real;
typedef pair<int, int> pii;
const int oo = ~0u >> 2;
const double pi = acos(-1.0);
const double eps = 1e-8;
const int mxn = 200033;
inline int read(){
int x = 0,f = 1;char c = getchar();
while(!isdigit(c))f = c == '-' ? -1 : 1,c = getchar();
while(isdigit(c))x = x * 10 + c - '0',c = getchar();
return x * f;
}
int n, a[mxn];
int main()
{
syio;
cin>>n;
for (int i = 1; i <= n; ++ i) cin>>a[i];
ll res = 0;
for (int i = 2; i <= n; ++ i)
{
if (a[i] < a[i - 1])
{
res += a[i - 1] - a[i];
a[i] += a[i - 1] - a[i];
}
}
cout<<res<<endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
struct CumulativeSum {
vector<long long> csum;
template<typename T>
CumulativeSum(vector<T> input) : csum(input.size() + 1, 0) {
for(int i = 0; i < (int)input.size(); i++) csum[i+1] = csum[i] + input[i];
}
long long query(int l, int r) { /* 0-indexed, inclusive */ return csum[r+1] - csum[l]; }
};
struct CumulativeSum2D {
vector<vector<long long>> csum;
template<typename T>
CumulativeSum2D(vector<vector<T>> input) : csum(input.size() + 1, vector<long long>(input[0].size() + 1, 0)) {
for(int i = 0; i < (int)input.size(); i++) for(int j = 0; j < (int)input[i].size(); j++)
csum[i+1][j+1] += csum[i+1][j] + csum[i][j+1] - csum[i][j] + input[i][j];
}
CumulativeSum2D(vector<string> input, char target) : csum(input.size() + 1, vector<long long>(input[0].size() + 1, 0)) {
for(int i = 0; i < (int)input.size(); i++) for(int j = 0; j < (int)input[i].size(); j++)
csum[i+1][j+1] += csum[i+1][j] + csum[i][j+1] - csum[i][j] + (input[i][j]==target);
}
long long query(int y_top, int x_left, int y_bottom, int x_right) { /* 0-indexed, inclusive */
return csum[y_bottom+1][x_right+1] - csum[y_top][x_right+1] - csum[y_bottom+1][x_left] + csum[y_top][x_left];
}
};
signed main() {
#if 1 // https://atcoder.jp/contests/abc122/tasks/abc122_c
int n,q; cin >> n >> q;
string s; cin >> s;
vector<bool> ac(n);
for(int i=0; i<n-1; ++i) ac[i] = s[i] == 'A' && s[i+1] == 'C';
CumulativeSum cs(ac);
while(q--) {
int l,r; cin >> l >> r; --l, r-=2;
cout << cs.query(l,r) << endl;
}
#elif 1 // https://atcoder.jp/contests/abc005/tasks/abc005_4
int n; cin >> n;
vector<vector<int>> grid(n, vector<int>(n, 0));
for(int i=0; i<n; ++i) for(int j=0; j<n; ++j) cin >> grid[i][j];
CumulativeSum2D cs(grid);
vector<int> ans(n*n+1);
for(int y1=0; y1<n; ++y1) for(int x1=0; x1<n; ++x1) for(int y2=y1; y2<n; ++y2) for(int x2=x1; x2<n; ++x2) {
int w = x2 - x1 + 1, h = y2 - y1 + 1;
ans[w*h] = max(ans[w*h], (int)cs.query(y1,x1,y2,x2));
}
for(int i=1; i<= n*n; ++i) ans[i] = max(ans[i], ans[i-1]);
int q; cin >> q;
while(q--) {
int p; cin >> p;
cout << ans[p] << endl;
}
#else // http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0560
int n,m,k; cin >> m >> n >> k;
vector<string> grid(m);
for(int i=0; i<m; ++i) cin >> grid[i];
CumulativeSum2D J(grid, 'J');
CumulativeSum2D O(grid, 'O');
CumulativeSum2D I(grid, 'I');
for(int i=0; i<k; ++i) {
int x1,y1,x2,y2; cin >> y1 >> x1 >> y2 >> x2;
--x1, --y1, --x2, --y2;
cout << J.query(y1,x1,y2,x2) << " ";
cout << O.query(y1,x1,y2,x2) << " ";
cout << I.query(y1,x1,y2,x2) << endl;
}
#endif
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const long long INF = 1LL << 60;
int main() {
int N, Q;
cin >> N >> Q;
string S;
cin >> S;
vector<int> AC;
AC.push_back(0);
//入力
vector<int> X(Q), Y(Q);
for(int i=0; i<Q; i++) {
int a,b;
cin >> X[i] >> Y[i];
}
//Sの"AC"をカウントして存在した位置をvectorにpush_back
int count = 0;
for(int i=1; i<N; i++) {
if(S[i-1] == 'A' && S[i] == 'C'){
count++;
}
AC.push_back(count);
}
for(int i=0; i<Q; i++) {
cout << AC[Y[i]-1] - AC[X[i]-1] << endl;
}
} | 1 |
#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <map>
using namespace std; typedef long long ll;
typedef pair<string,string> P; const int INF = 1e9+1;
int main() {
int n; cin>>n;
string s; cin>>s;
map<P, ll> mp;
for(int i=0;i<(1<<n);i++) {
string s1, s2;
for(int j=0;j<n;j++) {
if (i & (1<<j)) s1+=s[j];
else s2+=s[j];
}
reverse(s1.begin(), s1.end());
reverse(s2.begin(), s2.end());
mp[make_pair(s1,s2)]++;
}
ll an=0;
for(int i=0;i<(1<<n);i++) {
string s1, s2;
for(int j=0;j<n;j++) {
if (i & (1<<j)) s1+=s[n+j];
else s2+=s[n+j];
}
an += mp[make_pair(s1,s2)];
}
cout<<an<<endl;
} | //* AuThOr GaRyMr *//
#include<bits/stdc++.h>
#define rb(a,b,c) for(int a=b;a<=c;++a)
#define rl(a,b,c) for(int a=b;a>=c;--a)
#define niv vector<int>
#define LL long long
#define IT iterator
#define PB push_back
#define II(a,b) make_pair(a,b)
#define FIR first
#define SEC second
#define FREO freopen("check.out","w",stdout)
#define rep(a,b) for(int a=0;a<b;++a)
#define KEEP while(1)
#define SRAND mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#define random(a) rng()%a
#define ALL(a) a.begin(),a.end()
#define ff fflush(stdout)
using namespace std;
const int INF=0x3f3f3f3f;
typedef pair<int,int> mp;
typedef pair<mp,mp> superpair;
int n;
LL res;
int dp[20][20];
// dp[i][j] 前i个组成长度为j的B的前缀
string r_s="";
int check(string A,string B){
// cout<<A<<" "<<B<<" "<<r_s<<endl;
A='$'+A;
B='^'+B;
rb(i,0,19)
rb(j,0,19) dp[i][j]=0;
dp[0][0]=1;
rb(i,1,n/2){
rb(j,1,min((int)(B.length()-1),i)){
if(r_s[i]==B[j]){
dp[i][j]+=dp[i-1][j-1];
}
if(r_s[i]==A[i-j]){
dp[i][j]+=dp[i-1][j];
}
}
}
return dp[n/2][B.length()-1];
} string s;
void dfs1(string A,string B,int now){
if(now>(n>>1)){
res+=check(A,B);
}
else{
dfs1(A+s[now],B,now+1);
dfs1(A,B+s[now],now+1);
}
}
int main(){
cin>>n;
n=n+n;
cin>>s;
s='$'+s;
rl(i,n,n/2+1) r_s+=s[i];r_s='%'+r_s;
dfs1("","",1);
cout<<res+res<<endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define ll long long
#define MAX 1000005
#define MOD (ll)(1e9+7)
#define INF INT32_MAX
#define INFL INT64_MAX
#define con(x,y) ((x)*(m)+(y))
using namespace std;
int dsu[MAX];
int sz[MAX];
int search(int a) {
if(dsu[a]==a) return a;
return dsu[a]=search(dsu[a]);
}
void join(int a, int b) {
a = search(a);
b = search(b);
if(sz[a]<sz[b]) {
dsu[b]=a;
sz[a]+=sz[b];
}
else {
dsu[a]=b;
sz[b]+=sz[a];
}
}
void solve() {
int n,m;
cin >> n >> m;
string s[n];
for(int i=0; i<m*n; i++) {
sz[i]=1;
dsu[i]=i;
}
for(int i=0; i<n; i++) cin >> s[i];
for(int i=0; i<n; i++) {
for(int j=0; j<m; j++) {
//cout << con(i,j) << endl;
if(j+1<m && s[i][j]=='#' && s[i][j+1]=='#') {
if(search(con(i,j))!=search(con(i,j+1)))
join(con(i,j),con(i,j+1));
}
if(i+1<n && s[i][j]=='#' && s[i+1][j]=='#') {
if(search(con(i,j))!=search(con(i+1,j)))
join(con(i,j),con(i+1,j));
}
}
}
bool f=0;
for(int i=0; i<n; i++) {
for(int j=0; j<m; j++) {
if(s[i][j]=='#') {
if(sz[search(con(i,j))]==1) {
f=1; break;
}
}
}
}
if(f) cout << "No\n";
else cout << "Yes\n";
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t=1;
//cin >> t;
for(int i=1; i<=t; i++) {
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
int h,w; //h side w vertical
cin >> h >> w;
char s[h][w];
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++){
cin >> s[i][j];
}
}
int flag = 0;
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++){
if(s[i][j] == '#'){
if(s[i-1][j] == '#' && i != 0){
continue;
}else if(s[i][j-1] == '#' && j != 0){
continue;
}else if(s[i][j+1] == '#' && j != w-1){
continue;
}else if(s[i+1][j] == '#' && i != h-1){
continue;
}else{
flag = 1;
break;
}//else
}//if
}//for
if(flag == 1){
break;
}
}//for
if(flag == 0){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
}
| 1 |
#include <iostream>
using namespace std;
int main(){
int a, b, c;
cin >> a >> b >> c;
if(a < b){
if(c >= a && c <= b){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
}else{
if(c >= b && c <= a){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
#define all(v) v.begin(), v.end()
const ll mod=1000000007;
ll countBits(ll in){
int res=0;
for(;in>0;in>>=1){
if((in&0x01)!=0){
res++;
}
}
return res;
}
template<typename T>
void show2dVector(vector<vector<T>>& v){
for(int i=0;i<v.size();i++){
int m=v[i].size();
cout<<i<<" : ";
for(int j=0;i<m;i++){
cout<<v[i][j]<<" ";
}
cout<<endl;
}
}
void bfs(const vector<vector<int>>&g, int v, vector<bool>& seen){
seen[v]=true;
cout<<v<<" ";
for(auto next: g[v]){
if(seen[next]){
continue;
}
bfs(g,next,seen);
}
}
bool dfs(vector<vector<int>> &g,int start,int goal,vector<bool>&seen){
bool res=false;
seen[start]=true;
if(start==goal){
return true;
}
for(auto next: g[start]){
if(seen[next]){
continue;
}
res=dfs(g,next,goal,seen);
if(res){
break;
}
}
return res;
}
ll gcd(ll a,ll b) {
return b? gcd(b,a%b): a;
}
ll lcm(ll a,ll b) {
return a*b/gcd(a,b);
}
bool isLowerCase(char c){
return (c>='a'&&c<='z');
}
char toLowerCase(char c){
if(isLowerCase(c)){
return c;
}else{
return c+'a'-'A';
}
}
char toUpperCase(char c){
if(isLowerCase(c)){
return c-('a'-'A');
}else{
return c;
}
}
ll powm(ll a,ll n, ll m){
ll ret=1;
while(n>0){
if(n%2==1){
ret=(ret*a)%m;
}
n>>=1;
a=(a*a)%m;
}
return ret;
}
const string yesno(bool ans){
return (ans?"Yes":"No");
}
int main() {
bool ans=false;
int a,b,c;cin>>a>>b>>c;
if(a<=c&&c<=b){
ans=true;
}else if(b<=c&&c<=a){
ans=true;
}
cout<<yesno(ans)<<endl;
return 0;
}
| 1 |
#include<iostream>
#include<stdio.h>//printf("%.*f\n",*********);
#include<vector>//s.erase(n),vector
#include<algorithm>//next_permutation
#include<set>
#include<string>//char('a'=32+'A')
//to_string,string,substr
#include<sstream>
#include<complex>
#include<time.h>
#include<random>
#include<cmath>//min,max
#include<math.h>
#include<queue>
#include<time.h>
#include<iomanip>
#include<locale>
#include<utility>//swap
#define rt "\n"
#define rep(i,n) for(int i=0;i<n;i++)
#define rop(i,n) for(int i=1;i<=n;i++)//start==1
#define drep(i,n) for(int i=n-1;0<=i;i--)
#define drop(i,n) for(int i=n;0<i;i--)//end==1
#define yes(ans) if(ans)cout<<"yes"<<rt;else cout<<"no"<<rt;
#define Yes(ans) if(ans)cout<<"Yes"<<rt;else cout<<"No"<<rt;
#define YES(ans) if(ans)cout<<"YES"<<rt;else cout<<"NO"<<rt;
#define Yay(ans) if(ans)cout<<"Yay!"<<rt;else cout<<":("<<rt;
#define sec(a,b,ans) if(ans)cout<<a<<rt;else cout<<b<<rt;
#define vcin(a,n) rep(i,n)cin>>a[i];//vcin(配列名),(繰り返し回数)
#define sort(s) sort(s.begin(),s.end())//昇順
#define reve(s) reverse(s.begin(),s.end())//反転
#define please return
#define AC 0
#define rapid_pleaseAC_fast cin.tie(0);ios::sync_with_stdio(false)
#define pi 3.1415926535897932384626//pi
#define nine 1000000000//10^9
using namespace std;
typedef vector<int> vint;
typedef long double ldouble;
typedef vector<string> vstr;
typedef vector<char> vchar;
typedef vector<double> vdou;
typedef vector<double> vdouble;
typedef long long int llint;
typedef pair<int, int> pint;
typedef pair<llint, llint> pllint;
typedef vector<llint> vllint;
typedef vector<pint> vpint;
typedef vector<pair<llint, llint>> vpllint;
typedef vector<vector<int>> vvint;
typedef vector<vector<char>> vvchar;
typedef vector<vector<double>> vvdouble;
typedef vector<vector<llint>> vvllint;
typedef vector<vector<string>> vvstr;
typedef vector<vector<bool>> vvbool;
typedef vector<vector<pint>> vvpint;
typedef vector<bool> vbool;
long long GCD(long long a, long long b) {
if (b == 0) return a;
else return GCD(b, a % b);
}
long long LCM(long long a, long long b) {
return a * b / GCD(a, b);
}
unsigned GetDigit(unsigned num) {
return std::to_string(num).length();
}
int tow(int n) {//2のn乗
if (n == 0)return 1;
int x = tow(n / 2);
x *= x;
if (n % 2 == 1)x *= 2;
return x;//@domino
}
int KETA(int n) { //Sum of Each Digit
int sum = 0;
while (n > 0) {
sum += n % 10; n /= 10;
}
return sum;
}
unsigned ND(unsigned num) {//Number of Digits
return std::to_string(num).length();//outmax=10
}
bool KIBN(string s) {
rep(i, s.size() / 2) {
if (s[i] != s[s.size() - 1 - i])return false;
}
return true;
}
/*
(char)toupper(a[n])=文字列のn文字目を大文字で出力
pow(a,b)=aのb乗
*/
int main(void) {
rapid_pleaseAC_fast;
vint a(2);
vcin(a, 2);
int ans = 0;
rep(i, 2) {
if (a[i] == 3) {
ans += 100000;
}
if (a[i] == 2) {
ans += 200000;
}
if (a[i] == 1) {
ans += 300000;
}
}
if (a[0] == 1 && a[1] == 1) {
ans += 400000;
}
cout << ans << rt;
please AC;
}
//参考：--- | #include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=(a);i<=(b);++i)
#define rrep(i,a,b) for(int i=(a);i>=(b);--i)
#define PB push_back
#define ar2 array<int,2>
typedef long long LL;
const LL P = 1e9+7;
const int INF = 0x3fffffff;
const int N = 25;
mt19937 rng(time(0));
int x,y,ans;
int calc(int x){
if(x==1) return 300000;
if(x==2) return 200000;
if(x==3) return 100000;
return 0;
}
int main(){
#ifndef ONLINE_JUDGE
//freopen("test.in","r",stdin);
#endif
cin>>x>>y;
ans = calc(x) + calc(y);
if(x==1 && y==1) ans += 400000;
cout<<ans<<endl;
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <cmath>
#include <string>
#include <sstream>
#include <iomanip>
#include <complex>
using namespace std;
#define ll long long
#define vvi vector< vector<int> >
#define All(X) X.begin(),X.end()
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define pb push_back
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 n;
while (cin >> n,n){
int x[100];
int y[100];
int gem[25][25] = {0};
REP(i,n){
cin >> x[i] >> y[i];
gem[x[i]][y[i]] = 1;
}
int m;
cin >> m;
char d[100];
int l[100];
int nowx=10;
int nowy=10;
REP(j,m){
cin >> d[j] >> l[j];
if (d[j]=='E'){
REP(k,l[j]){
nowx ++;
gem[nowx][nowy]=0;
}
}else if(d[j]=='W'){
REP(k,l[j]){
nowx --;
gem[nowx][nowy]=0;
}
}else if(d[j]=='S'){
REP(k,l[j]){
nowy --;
gem[nowx][nowy]=0;
}
}else if(d[j]=='N'){
REP(k,l[j]){
nowy ++;
gem[nowx][nowy]=0;
}
}
// cout << nowx << "," << nowy << endl; //
}
int tf=0;
/*
REP(piyo,25){
REP(are,25){
cout << gem[piyo][are] << ",";
}}
*/
REP(hoge,25){
REP(huga,25){
tf += gem[hoge][huga];
}
}
if(tf){
cout<<"No"<<endl;
}else{
cout<<"Yes"<<endl;
}
}
} | #include "bits/stdc++.h"
#define ll long long
#define lld long double
#define MOD 1000000007
#define inf 1000000000000000000ll
#define pii pair<int,int>
#define f first
#define s second
#define pb push_back
#define mp make_pair
#define all(v) v.begin(),v.end()
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
ll power(ll x,ll y, ll md=inf){ll res = 1;x%=md;while(y){if(y&1)res = (res*x)%md;x *= x; if(x>=md) x %= md; y >>= 1;}return res;}
using namespace std;
#define endl '\n'
#define int ll
signed main() {
fast;
int h,w;
cin>>h>>w;
pii v[200002];
for(int i=0;i<h;i++) cin>>v[i].f>>v[i].s;
map<int,int> mp;
for(int i=1;i<=w;i++) mp[i] = 0;
map<int,int> mini = {{0,w}};
for(int i=0;i<h;i++) {
int r = v[i].s;
auto it = mp.lower_bound(v[i].f);
int mn = inf;
while(it!=mp.end() && it->f <= r) {
mn = min(mn, r+1-(it->f)+(it->s));
auto it1 = it++;
auto it2 = mini.find(it1->s);
if(it2->s==1) mini.erase(it2);
else it2->s --;
mp.erase(it1);
}
if(r+1<=w && mn<inf) {
if(it!=mp.end() && it->f == r + 1) {
if(it->s > mn) {
auto it1 = mini.find(it->s);
if(it1->s ==1) mini.erase(it1);
else it1->s --;
mini[mn]++;
it->s = mn;
}
}
else {
mp.insert({r+1,mn});
mini[mn]++;
}
}
if(mini.size()) cout<<mini.begin()->f+i+1<<endl;
else cout<<-1<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<string> v;
set<string> s;
void dfs(string str, int flag, int count) {
if (count == k) {
s.insert(str);
return ;
}
for (int i = 0; i < n; i++) {
if (flag & (1 << i)) continue;
dfs(str + v[i], flag | (1 << i), count + 1);
}
}
int main() {
while (cin >> n >> k, n || k) {
v.resize(0);
for (int i = 0; i < n; i++) {
string str;
cin >> str;
v.push_back(str);
}
s.clear();
dfs("", 0, 0);
cout << s.size() << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
string ab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n, key[100];
string cip;
while(cin >> n && n){
for(int i = 0; i < n; i++){
cin >> key[i];
}
cin >> cip;
for(int i = 0; i < cip.size(); i++){
int ind = lower_bound(ab.begin(), ab.end(), cip[i])-ab.begin();
cout << ab[(ind - key[i%n] + 52) % 52];
}
cout << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAX_N = 501, MAX_M = 2e5+10;
int N, M, Q;
int L[MAX_M], R[MAX_M];
int p[MAX_M], q[MAX_M];
ll ans[MAX_N][MAX_N];
void solve()
{
for(int i=0;i<M;++i){
for(int le=1;le<=L[i];++le)ans[le][R[i]]++;
}
for(int i=1;i<=N;++i)for(int j=1;j<=N;++j){
ans[i][j] += ans[i][j-1];
}
for(int i=0;i<Q;++i){
cout << ans[p[i]][q[i]] << '\n';
}
}
int main()
{
cin >> N >> M >> Q;
for(int i=0;i<M;++i) cin >> L[i] >> R[i];
for(int i=0;i<Q;++i) cin >> p[i] >> q[i];
solve();
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
vector<int> to[100005];
vector<int> dist;
int n;
void dfs(int v, int d=0, int p=-1) {
dist[v] = d;
for (int u : to[v]) {
if (u == p) continue;
dfs(u,d+1,v);
}
}
vector<int> calc(int x) {
dist = vector<int>(n);
dfs(x);
return dist;
}
int main() {
int u, v;
cin >> n >> u >> v;
u--; v--;
rep(i,n-1) {
int a, b;
cin >> a >> b;
a--; b--;
to[a].push_back(b);
to[b].push_back(a);
}
vector<int> distU = calc(u);
vector<int> distV = calc(v);
int ans = 0;
rep(i,n) {
if (distU[i] < distV[i]) {
ans = max(ans, distV[i]-1);
}
}
cout << ans << endl;
return 0;
} | 0 |
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
using namespace std;
#define REP(i,e,s) for(register int i=e; i<=s; i++)
#define DREP(i,e,s) for(register int i=e; i>=s; i--)
#define ll long long
#define DE(...) fprintf(stderr,__VA_ARGS__)
#define DEBUG(a) DE("DEBUG: %d\n",a)
#define int long long
int read() {
int x=0,f=1,ch=getchar();
while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
const int MOD=1e9+7,MAXN=200000+10;
int fac[MAXN],inv[MAXN];
int qpow(int a,int b) {
int ans=1;
while(b) {
if(b&1) ans=(ans*a)%MOD;
a=(a*a)%MOD;
b>>=1;
}
return ans;
}
int c(int m,int n) {
if(n==m||!m||!n) return 1;
return ((fac[m]*inv[n]%MOD)*inv[m-n])%MOD;
}
int calc(int x_1,int y_1,int x_2,int y_2) {
return c(abs(x_2-x_1)+abs(y_2-y_1),abs(x_2-x_1));
}
signed main() {
int h=read(),w=read(),a=read(),b=read();
fac[0]=1;
REP(i,1,h+w) fac[i]=(fac[i-1]*i)%MOD;
REP(i,1,h+w) inv[i]=qpow(fac[i],MOD-2);
int ans=0;
REP(i,1,h-a) {
ans=(ans+calc(1,1,b,i)*(calc(b+1,i,w,h)))%MOD;
}
printf("%lld\n",ans%MOD);
return 0;
} | #include<cstdio>
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(void) {
string S;
cin >> S;
if (S.length() == 3) reverse(S.begin(), S.end());
cout << S << "\n";
return 0;
}
| 0 |
#include "bits/stdc++.h"
using namespace std;
#define ff first
#define ss second
#define pb push_back
typedef long long ll;
#define db(x) cerr<<__LINE__<<": "<<#x<<" = "<<(x)<<'\n'
const int inf = 1e9+7;
const int N = 1e6+9;
int main() {
ios_base::sync_with_stdio(0);
int a,b,n;
string s;
cin>>s;
int sum=0, mx=0;
for(char ch: s) {
if(ch=='R') sum++;
else sum=0;
mx = max(mx, sum);
}
cout<<mx<<endl;
return 0;
} | #include <bits/stdc++.h>
#define endl "\n"
#define ff first
#define ss second
#define PB push_back
#define MP make_pair
#define ll long long
#define llu unsigned long long
#define MAX(a, b) (((a) > (b)) ? (a) : (b))
#define MIN(a, b) (((a) < (b)) ? (a) : (b))
#define ABS(X) ((X)< 0 ? -(X): (X))
#define LCM(X, Y) ( ( (X) / (GCD( (X) , (Y) ))) * (Y) )
#define MEM( A, B) memset((A), (B), sizeof(A))
#define MEM_VEC(V, FILL ) fill( V.begin(), V.end(), FILL)
#define FOR_EACH(IT, V) for (auto IT = V.begin(); IT != V.end(); IT++)
#define DEBUG_ARRAY_PRINT(A,I) cout<<"at pos "<< I <<" value is: "<< A[I]
#define TURBO ios_base::sync_with_stdio(false) ; cin.tie(0); cout.tie(0)
const double EPS =1e-9 ;
const double PI = 3.1415926535897932384626433832795 ;
using namespace std ;
inline ll GCD(ll A, ll B){
if ( B == 0 ) return A;
return GCD( (B) , (A % B) );
}
inline ll POW(ll BASE, ll EXP) {
ll RES = 1;
for(ll I= 0; I < EXP; I++) RES *= BASE ;
return RES;
}
inline ll BIGMOD ( ll a, ll p, ll m ) {
ll res = 1 % m;
ll x = a % m;
while ( p > 0 ) {
if ( (p & 1) > 0 ) res = ( res * x ) % m;
x = ( x * x ) % m; p >>= 1;
}
return res;
}
inline void FILE_HANDLE( ){
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
int main()
{
TURBO;
//FILE_HANDLE() ;
string s;
cin >> s ;
int ans = 0 ;
if(s[1] == 'R' && s[2] == 'R' && s[0] == 'R') ans = 3 ;
else if(s[1] == 'R' && s[2] == 'R' ) ans = 2 ;
else if(s[1] == 'R' && s[0] == 'R' ) ans = 2 ;
else if(s[0] == 'R' || s[1] == 'R' || s[2] == 'R') ans = 1 ;
cout << ans << endl ;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MOD = 998244353;
ll Ep(int x, int y){
if(y == 1) return x;
ll r = Ep(x,y/2);
if(y%2 == 1) return r *r%MOD *x%MOD;
else return r *r%MOD;
}
int main(){
int n, x;
cin >> n;
cin >> x;
if(x != 0){
cout << 0 << endl;
return 0;
}
map<int, int> mp;
for(int i=1; i<n; ++i){
cin >> x;
if(x == 0){
cout << 0 << endl;
return 0;
}
++mp[x];
}
ll ans = 1;
for(auto p: mp){
if(p.first == 1) continue;
ans *= Ep(mp[p.first-1], p.second);
ans %= MOD;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int MAX = 2*1e5;
bool IsPrime(long long n){
if(n == 1) return false;
for(long long i = 2; i * i < n; i++){
if(n%i == 0) return false;
}
return true;
}
vector<pair<long long, long long>> PrimeFactorize(long long n){
vector<pair<long long, long long>> res;
long long a = 0;
for(long long i = 2; i * i <= n; i++){
a = 0;
if(n%i == 0){
if(IsPrime(i)){
while(n % i == 0){
n /= i;
a++;
}
res.push_back(make_pair(i, a));
}}}
if(n!= 1) res.push_back(make_pair(n, 1));
return res;
}
long long modpow(long long a, long long n, long long mod){
long long res = 1;
while(n > 0){
//nを２進数に分解してビットの立っているところだけ掛け算していく。
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// a inverse (mod m)
// a^(-1) = a^(p-2) (mod p)
long long modinv(long long a, long long mod){
return modpow(a, mod-2, mod);
}
long long Comb(long long n, long long k){
if(n < k) return 0;
if(n < 0 || k < 0) return 0;
// return fac[n] * (finv[k] * finv[n-k] % MOD) % MOD;
long long ans = 1;
for(long long i = 0; i < k; i++){
ans = ans * (n - i) % MOD;
ans = ans * modinv(k - i, MOD) % MOD;
}
return ans;
}
int main(){
long long n,m;
cin >> n >> m;
vector<pair<long long, long long>> res;
res = PrimeFactorize(m);
// CombInit();
long long ans = 1;
long long size = res.size();
for(long long i = 0; i < size; i++){
long long num = Comb(res[i].second + n - 1, res[i].second);
// ans = (ans * Comb(res[i].second + n - 1, res[i].second)) % MOD;
ans = (ans * num) % MOD;
}
cout << ans << endl;
return 0;
} | 0 |
#include <iostream>
#include<string>
using namespace std;
int main() {
// your code goes here
string s,t;
cin>>s;
cin>>t;
for(int i = 0; t[i]!='\0'; i++)
{
cout<<t[i];
}
for(int i = 0; s[i]!='\0'; i++)
{
cout<<s[i];
}
return 0;
} | #include <iostream>
int main(int argc, char *argv[])
{
int x = 0;
std::cin >> x;
x = x * x * x;
std::cout << x << std::endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#define int long long
#define mod (int)(1e9+7)
#define inf (int)(3e18)
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define P std::pair<int,int>
#define PiP std::pair<int,std::pair<int,int>>
#define all(v) v.begin(),v.end()
#define mkp std::make_pair
#define prique(T) std::priority_queue<T,vector<T>,greater<T>>
using namespace std;
template<class T> inline void chmax(T& a, T b) { a = std::max(a, b); }
template<class T> inline void chmin(T& a, T b) { a = std::min(a, b); }
bool prime(int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0)return false;
}
return x != 1;
}
int gcd(int x, int y) {
if (y == 0)return x;
return gcd(y, x % y);
}
int lcm(int x, int y) {
return x / gcd(x, y) * y;
}
int kai(int x, int y) {
int res = 1;
for (int i = x - y + 1; i <= x; i++) {
res *= i; res %= mod;
}
return res;
}
int mod_pow(int x, int y, int m) {
int res = 1;
while (y > 0) {
if (y & 1) {
res = res * x % m;
}
x = x * x % m;
y >>= 1;
}
return res;
}
int comb(int x, int y) {
if (y > x)return 0;
return kai(x, y) * mod_pow(kai(y, y), mod - 2, mod) % mod;
}
int get_rand(int MIN, int MAX) {
std::random_device rnd;
std::mt19937 mt32(rnd());
std::uniform_int_distribution<int>engine(MIN, MAX);
return engine(mt32);
}
/*--------Library Zone!--------*/
int n, q;
string s;
int summ[1000005];
signed main() {
cin >> n >> s >> q;
rep(i, n) {
if (s[i] == 'M')summ[i]++;
summ[i + 1] = summ[i];
}
while (q--) {
int k; cin >> k;
int ans = 0;
int d = 0, dm = 0;
rep(i, n) {
if (s[i] == 'D')d++;
else if (s[i] == 'M')dm += d;
else if (s[i] == 'C')ans += dm;
if (i >= k - 1 && s[i - k + 1] == 'D') {
d--;
dm -= summ[i] - (i >= k ? summ[i - k] : 0);
}
}
cout << ans << endl;
}
}
| #include<bits/stdc++.h>
using namespace std;
#define ALL(x) x.begin(),x.end()
#define rep(i,n) for(int i=0;i<n;i++)
#define debug(v) cout<<#v<<":";for(auto x:v){cout<<x<<' ';}cout<<endl;
#define INF 1000000000
#define mod 1000000007
using ll=long long;
const ll LINF = 1001002003004005006ll;
int dx[]={1,0,-1,0};
int dy[]={0,1,0,-1};
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int n;string s;
ll solve(int k){
ll d=0,m=0,dm=0,ret=0;
rep(i,k){
if(s[i]=='D')d++;
if(s[i]=='M'){
dm+=d;
m++;
}
if(s[i]=='C')ret+=dm;
}
for(int i=k;i<n;i++){
if(s[i-k]=='D'){
dm-=m;d--;
}
if(s[i-k]=='M')m--;
if(s[i]=='D') d++;
if(s[i]=='M'){
dm+=d;
m++;
}
if(s[i]=='C')ret+=dm;
}
return ret;
}
signed main(){
cin.tie(0);
ios::sync_with_stdio(0);
cin>>n;
cin>>s;
vector<ll> ans;
int q;cin>>q;
while(q--){
int k;cin>>k;
ans.push_back(solve(k));
}
for(auto x:ans){
cout<<x<<endl;
}
return 0;
}
| 1 |
// C++ 14
#include <bits/stdc++.h>
using namespace std;
template <typename T> ostream& operator<<(ostream& os, const vector<T>& v) { os << "["; for (int i = 0; i < v.size(); ++i) { os << v[i]; if (i != v.size() - 1) os << ", "; } os << "]"; return os; }
template <typename T> void print(T v, string s = "\n") { cout << v << s; }
template <typename T> void in(T &v) { cin >> v; }
#define ll long long
#define loop(__x, __start, __end) for(int __x = __start; __x < __end; __x++)
int main() {
int n, m; in(n),in(m);
vector<bool> ac(n+1, false);
vector<int> wa(n+1, 0);
int p; string s;
loop(i,0,m) {
in(p),in(s);
if (ac[p]) continue;
if (s == "WA") wa[p]++;
else ac[p] = true;
}
loop(p,1,n+1) if (!ac[p]) wa[p] = 0;
int ans1 = 0;
for (auto&&b: ac) ans1+=b;
int ans2 = 0;
for (auto&&w: wa) ans2+=w;
print(ans1, " ");
print(ans2);
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
const ll INF = 1LL << 60;
const double PI = 3.141592653589793238;
const double EPS = 1e-10;
struct UnionFind {
vector<int> par;
vector<int> rank;
vector<int> cmp;
int size;
UnionFind(int n) :size(n) {
par.resize(size);
rank.resize(size);
cmp.resize(size);
for (int i = 0; i < size; i++) {
par[i] = i;
rank[i] = 0;
cmp[i] = 1;
}
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (rank[x] < rank[y]) {
par[x] = y;
cmp[y] += cmp[x];
}
else {
par[y] = x;
cmp[x] += cmp[y];
if (rank[x] == rank[y]) rank[x]++;
}
}
int find(int x) {
if (par[x] == x) return x;
return par[x] = find(par[x]);
}
bool same(int x, int y) {
x = find(x);
y = find(y);
return x == y;
}
};
map<int, int> cnt[200000];
int main() {
int N, K, L;
cin >> N >> K >> L;
UnionFind u1(N), u2(N);
for (int i = 0; i < K; i++) {
int p, q;
cin >> p >> q;
p--; q--;
u1.unite(p, q);
}
for (int i = 0; i < L; i++) {
int r, s;
cin >> r >> s;
r--; s--;
u2.unite(r, s);
}
for (int i = 0; i < N; i++) {
int x = u1.find(i);
int y = u2.find(i);
cnt[x][y]++;
}
for (int i = 0; i < N; i++) {
int x = u1.find(i);
int y = u2.find(i);
cout << cnt[x][y] << " ";
}
cout << endl;
}
| 0 |
#include<iostream>
using namespace std;
int main(void){
int n, q;
cin >> n;
int s[n];
for(int i = 0; i < n; i++){
cin >> s[i];
}
cin >> q;
int t[q];
for(int i = 0; i < q; i++){
cin >> t[i];
}
int count = 0;
for(int i = 0; i < q; i++){
for(int j = 0; j < n; j++){
if(t[i] == s[j]){
count++;
break;
}
else continue;
}
}
cout << count << endl;
}
| #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define vv(T) std::vector<std::vector<T>>
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
using namespace std;
using ll = long long;
int main(void)
{
int n;
cin >> n;
vector<bool> seen(1'000'000'000);
bool ans = true;
for (int i = 0; i < n; ++i)
{
int a;
cin >> a;
if (seen[a])
ans = false;
seen[a] = true;
}
cout << (ans ? "YES" : "NO") << endl;
}
| 0 |
// This amazing code is by Eric Sunli Chen.
#include<bits/stdc++.h>
using namespace std;
template<typename T> bool get_int(T &x)
{
char t=getchar();
bool neg=false;
x=0;
for(; (t>'9'||t<'0')&&t!='-'&&t!=EOF; t=getchar());
if(t=='-')neg=true,t=getchar();if(t==EOF)return false;
for(; t<='9'&&t>='0'; t=getchar())x=x*10+t-'0';
if(neg)x=-x;return true;
}
template<typename T> void print_int(T x)
{
if(x<0)putchar('-'),x=-x;
short a[20]= {},sz=0;
while(x>0)a[sz++]=x%10,x/=10;
if(sz==0)putchar('0');
for(int i=sz-1; i>=0; i--)putchar('0'+a[i]);
}
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define get1(a) get_int(a)
#define get2(a,b) (get1(a)&&get1(b))
#define get3(a,b,c) (get1(a)&&get2(b,c))
#define printendl(a) print_int(a),puts("")
typedef long long LL;
typedef unsigned long long uLL;
typedef pair<int,int> pii;
const int inf=0x3f3f3f3f;
const LL Linf=1ll<<61;
const double pi=acos(-1.0);
const int maxn=100111;
int n,s,x[maxn];
LL p[maxn],ans;
int calc(int l,int r)
{
if(x[r]<s)
{
ans+=s-x[l];
return l;
}
if(x[l]>s)
{
ans+=x[r]-s;
return r;
}
if(p[l]>=p[r])
{
p[l]+=p[r];
ans+=x[r]-x[calc(l,r-1)];
return r;
}
else
{
p[r]+=p[l];
ans+=x[calc(l+1,r)]-x[l];
return l;
}
}
int main()
{
get2(n,s);
for(int i=1;i<=n;i++)get2(x[i],p[i]);
calc(1,n);
printendl(ans);
return 0;
} | #include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<complex>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll MOD = (1e+9)+7;
const ll INF = (ll)1000000007 * 1000000007;
const double EPS = 1e-9;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef long double ld;
typedef complex<ld> Point;
const ld eps = 1e-11;
const ld pi = acos(-1.0);
typedef pair<ll, ll> LP;
typedef pair<ld, ld> LDP;
vector<int> v;
int main() {
int n; ll s; cin >> n >> s;
ll x[100000]; ll p[100000];
rep(i, n) {
cin >> x[i] >> p[i];
}
int j, k; j = 0; k = n - 1;
while (j < k) {
if (p[j] < p[k]) {
p[k] += p[j];
if (s > x[j]) {
v.push_back(j);
}
j++;
}
else if (p[j] >= p[k]) {
p[j] += p[k];
if (s < x[k]) {
v.push_back(k);
}
k--;
}
}
v.push_back(j);
int len = v.size();
ll sum = 0; ll now = s;
per(i, len) {
sum += abs(x[v[i]] - now);
now = x[v[i]];
}
cout << sum << endl;
return 0;
} | 1 |