code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pb push_back
#define mp make_pair
#define all(z) (z).begin(),(z).end()
#define MOD 1000000007
#define FAST ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
ll isprime(ll n)
{
for(int i=2;i<n;i++)
if(n%i==0)
return 0;
return 1;
}
int main()
{
FAST;
long double d,t,s;
cin>>d>>t>>s;
if(d/s<=t)cout<<"Yes";
else cout<<"No";
}
| #include<bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define PI acos(-1)
#define pcnt __builtin_popcountll
#define rng(a) a.begin(), a.end()
#define sz(x) (int)(x).size()
#define v(T) vector<T>
#define vv(T) v(v(T))
#define fi first
#define se second
using namespace std;
using ll = long long;
using P = pair<int, int>;
using LP = pair<ll, ll>;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
template<typename T>inline istream& operator>>(istream&i,v(T)&v)
{rep(j,sz(v))i>>v[j];return i;}
template<typename T1,typename T2>inline istream& operator>>(istream&i,pair<T1,T2>&v)
{return i>>v.fi>>v.se;}
template<class T> inline bool chmax(T& a, T b) {if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) {if (a > b) { a = b; return true; } return false; }
ll INF = 1001001001;
ll LINF = 1001001001001001001ll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m, d;
cin>>n>>m>>d;
if (1 + d > n) {
cout<<0<<endl;
}
double f = d == 0 ? 1.0 : 2.0;
printf("%.10f\n", f * (n - d) / n / n * (m - 1));
} | 0 |
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<cstdlib>
#include<queue>
#include<set>
#include<cstdio>
using namespace std;
#define ll long long
#define rep(i, n) for(int i = 0; i < n; i++)
#define P pair<int, int>
typedef vector<int> vec;
typedef vector<vec> mat;
// a^n mod を計算する
long int modpow(long int a, long int n, long int mod) {
long int res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = (a * a) % mod;
n >>= 1;
}
return res;
}
long int modcomb(long int a, long int b, long int mod){
long int res = 1;
for(long int i = a; i > a - b; i--){
res *= i % mod;
res %= mod;
}
res %= mod;
for(long int i = 1; i <= b; i++){
long int i_inv = modpow(i, mod - 2, mod);
res *= i_inv % mod;
res %= mod;
}
res %= mod;
// cout << res << endl;
return res;
}
int main(){
ll n, m, k;
cin >> n >> m >> k;
ll mod = 1000000007;
ll combx = modcomb(n * m - 2, k - 2, mod);
ll comby = modcomb(n * m - 2, k - 2, mod);
ll ans = 0;
rep(i, n){
ans += (((((i * (n - i)) % mod) * m) % mod * m) % mod) * combx;
ans %= mod;
}
rep(i, m){
ans += (((((i * (m - i)) % mod) * n) % mod * n) % mod) * comby;
ans %= mod;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rep(i,n) for (int i=0;i<(int)(n);i++)
#define codefor int test;scanf("%d",&test);while(test--)
#define INT(...) int __VA_ARGS__;in(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__;in(__VA_ARGS__)
#define yn(ans) if(ans)printf("Yes\n");else printf("No\n")
#define YN(ans) if(ans)printf("YES\n");else printf("NO\n")
#define vector1d(type,name,...) vector<type>name(__VA_ARGS__)
#define vector2d(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__))
#define umap unordered_map
#define uset unordered_set
using namespace std;
using ll = long long;
const int MOD=1000000007;
//入力系
void scan(int& a){scanf("%d",&a);}
void scan(long long& a){scanf("%lld",&a);}
template<class T> void scan(T& a){cin>>a;}
template<class T> void scan(vector<T>& vec){for(auto&& it:vec)scan(it);}
void in(){}
template <class Head, class... Tail> void in(Head& head, Tail&... tail){scan(head);in(tail...);}
//出力系
void print(const int& a){printf("%d",a);}
void print(const long long& a){printf("%lld",a);}
void print(const double& a){printf("%.15lf",a);}
template<class T> void print(const T& a){cout<<a;}
template<class T> void print(const vector<T>& vec){if(vec.empty())return;print(vec[0]);for(auto it=vec.begin();++it!= vec.end();){putchar(' ');print(*it);}}
void out(){putchar('\n');}
template<class T> void out(const T& t){print(t);putchar('\n');}
template <class Head, class... Tail> void out(const Head& head,const Tail&... tail){print(head);putchar(' ');out(tail...);}
//デバッグ系
template<class T> void dprint(const T& a){cerr<<a;}
template<class T> void dprint(const vector<T>& vec){if(vec.empty())return;cerr<<vec[0];for(auto it=vec.begin();++it!= vec.end();){cerr<<" "<<*it;}}
void debug(){cerr<<endl;}
template<class T> void debug(const T& t){dprint(t);cerr<<endl;}
template <class Head, class... Tail> void debug(const Head& head, const Tail&... tail){dprint(head);cerr<<" ";debug(tail...);}
ll intpow(ll a, ll b){ ll ans = 1; while(b){ if(b & 1) ans *= a; a *= a; b /= 2; } return ans; }
ll modpow(ll a, ll b, ll p){ ll ans = 1; while(b){ if(b & 1) (ans *= a) %= p; (a *= a) %= p; b /= 2; } return ans; }
ll updivide(ll a,ll b){if(a%b==0) return a/b;else return (a/b)+1;}
int main(){
LL(n,m);
ll ans=1,Msqrt=sqrt(m);
for(ll i=1;i<=Msqrt;i++){
if(m%i==0){
if(i*n<=m)ans=max(ans,i);
if((m/i)*n<=m)ans=max(ans,m/i);
}
}
out(ans);
} | 0 |
#include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
int main() {
string s;
cin >> s;
int ans = 1e9;
for (int i = 0; i < s.size() - 2; i++) {
ans = min(ans, abs(753 - atoi((s.substr(i, 3)).c_str())));
}
cout << ans << endl;
return 0;
} |
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0); std::cout.tie(0);
std::string s;
std::getline(std::cin, s);
std::vector<bool> dict(26, false);
for (char c : s)
dict[c - 'a'] = true;
std::string r = "None";
for (std::size_t i = 0; i < dict.size(); ++i) {
if (!dict[i]) {
r = i + 'a';
break;
}
}
std::cout << r << std::endl;
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include<string>
#include <set>
#include <map>
#include <algorithm>
#include <math.h>
using namespace std;
int main()
{
long long N;
cin >> N;
long long result = 0;
for(long long i = 1;i<=N;i++){
if(i % 3 != 0 && i % 5 != 0){
result += i;
}
}
std::cout << result << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int main(){
int64_t N;
cin >> N;
cout << (N / 1 * 1 * (N / 1 + 1) - N / 3 * 3 * (N / 3 + 1) - N / 5 * 5 * (N / 5 + 1) + N / 15 * 15 * (N / 15 + 1)) / 2 << endl;
} | 1 |
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using P=pair<string,int>;
int main() {
map<string,int> day{P("SUN",7),P("MON",6),P("TUE",5),P("WED",4),P("THU",3),P("FRI",2),P("SAT",1)};
string S;cin>>S;
cout<<day[S]<<endl;
} | #include <bits/stdc++.h>
#include <cstdlib>
#define rep(i,n) for(int i=0;i<(n);++i)
using namespace std;
using ll = long long;
int main(){
vector<string> D = {"SUN","MON","TUE","WED","THU","FRI","SAT"};
string S;
cin >> S;
int ans=0;
rep(i,7){
if(D[i]==S) ans = 7-i;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main()
{
double U = 3.14;
int R;
cin >> R >> U;
cout << R * 2 * U <<"\n";
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int R;
cin >> R;
R *= 2;
cout << R * 3.14 << endl;
} | 1 |
// 2020-07-18 10:56:41
#include<bits/stdc++.h>
#ifdef LOCAL
#include "lib/debug.hpp"
#else
#define debug(...) 1
#endif
#define ALL(a) (a).begin(), (a).end()
#define rep(i, n) REP(i, 0, (n))
#define repc(i, n) REPC(i, 0, (n))
#define REP(i, n, m) for (int i = (int)(n); i < (int)(m); i++)
#define REPC(i, n, m) for (int i = (int)(n); i <= (int)(m); i++)
#define REPCM(i, n, m) for (int i = (int)(n); i >= (int)(m); i--)
using namespace std;
using ll = long long;
using ld = long double;
using pr = pair<ll, ll>;
using vll = vector<ll>;
using vpr = vector<pr>;
template<class T> inline bool chmin(T& a, const T& b) { if (a > b) { a = b; return true; } else return false; }
template<class T> inline bool chmax(T& a, const T& b) { if (a < b) { a = b; return true; } else return false; }
const ll INF = 1e18;
void answer() {
int n;
cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
int k = n%2+1;
vector<ll> dp(k+1, -INF);
dp[0] = 0;
rep(i, n) {
vector<ll> p(k+1, -INF);
swap(p, dp);
repc(j, k) {
if(j<k) chmax(dp[j+1], p[j]);
if((i+j)%2) {
chmax(dp[j], p[j]);
} else {
chmax(dp[j], p[j] + a[i]);
}
}
}
cout << dp[k] << '\n';
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
answer();
return 0;
}
| #include<bits/stdc++.h>
#define mo 1000000007
using namespace std;
long long read(){
long long xx=0,flagg=1;
char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-')
ch=getchar();
if(ch=='-'){
flagg=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9'){
xx=xx*10+ch-'0';
ch=getchar();
}
return xx*flagg;
}
void pus(long long xx,long long flagg){
if(xx<0){
putchar('-');
xx=-xx;
}
if(xx>=10)
pus(xx/10,0);
putchar(xx%10+'0');
if(flagg==1)
putchar(' ');
if(flagg==2)
putchar('\n');
return;
}
long long n,m,a,b,i,j,jc[200005],ny[200005],ans;
long long ksm(long long u,long long v){
long long o=1;
while(v){
if(v&1)
o=o*u%mo;
u=u*u%mo;
v>>=1;
}
return o;
}
long long C(long long u,long long v){
return jc[u]*ny[v]%mo*ny[u-v]%mo;
}
long long Q(long long u,long long v){
return C(u+v,v);
}
int main(){
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
n=read();m=read();a=read();b=read();
jc[0]=1;
for(i=1;i<=n+m;i++)
jc[i]=jc[i-1]*i%mo;
ny[n+m]=ksm(jc[n+m],mo-2);
for(i=n+m-1;i>=0;i--)
ny[i]=ny[i+1]*(i+1)%mo;
ans=Q(n-1,m-1);
for(i=1;i<=b;i++)
ans=(ans-Q(n-a-1,i-1)*Q(a-1,m-i)%mo+mo)%mo;
pus(ans,2);
return 0;
} | 0 |
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
#ifndef MAX
#define MAX 400000
#endif
//Range Update Query+Range Sum Query
template<class T>
class RUQ_RSQ {
public:
int n;
T dat[MAX], lazy[MAX], ZERO, DEFAULT;
void init(int n_, T d = INT_MAX, T t = 0) {
DEFAULT = d;
ZERO = T();
n = 1; while (n < n_)n <<= 1;
for (int i = 0; i < 2 * n - 1; i++) {
dat[i] = t; lazy[i] = DEFAULT;
}
}
inline void push(int k, int s) {
if (lazy[k] == DEFAULT)return;
dat[k] = lazy[k] * s;
if (k < n - 1) {
lazy[k * 2 + 1] = lazy[k];
lazy[k * 2 + 2] = lazy[k];
}
lazy[k] = DEFAULT;
}
inline void update_node(int k) {
dat[k] = dat[k * 2 + 1] + dat[k * 2 + 2];
}
inline void update(int a, int b, T x, int k, int l, int r) {
push(k, r - l);
if (r <= a || b <= l)return;
if (a <= l&&r <= b) {
lazy[k] = x; push(k, r - l); return;
}
update(a, b, x, k * 2 + 1, l, (l + r) / 2);
update(a, b, x, k * 2 + 2, (l + r) / 2, r);
update_node(k);
}
inline T query(int a, int b, int k, int l, int r) {
push(k, r - l);
if (r <= a || b <= l)return ZERO;
if (a <= l&&r <= b)return dat[k];
T lb = query(a, b, k * 2 + 1, l, (l + r) / 2);
T rb = query(a, b, k * 2 + 2, (l + r) / 2, r);
update_node(k);
return lb + rb;
}
inline void update(int a, int b, T x) {
update(a, b, x, 0, 0, n);
}
inline void update(int a, T x) {
update(a, a + 1, x);
}
inline T query(int a, int b) {
return query(a, b, 0, 0, n);
}
inline T query(int a) {
return query(a, a + 1);
}
};
RUQ_RSQ<int>seg;
int main() {
int n, q; scanf("%d%d", &n, &q);
seg.init(n, INT_MAX, INT_MAX);
rep(i, q) {
int a; scanf("%d", &a);
if (a == 0) {
int s, t, x; scanf("%d%d%d", &s, &t, &x); t++;
seg.update(s, t, x);
}
else {
int t; scanf("%d", &t);
printf("%d\n", seg.query(t));
}
}
} | #include<stdio.h>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
#define MAX_V 100001
#define INF (1e9 + 1)
int V,E,r,a,b,c;
vector<int> Gto[MAX_V];
vector<int> Gcost[MAX_V];
int d[MAX_V];
void dijkstra(){
int i;
for(i=0;i<MAX_V;i++)d[i]=INF;
d[r]=0;
priority_queue< pair<int,int> > Q;
Q.push( make_pair(0,r) );
while(!Q.empty()){
pair<int,int> p=Q.top();
Q.pop();
int pos=p.second,cost=-p.first;
if( cost > d[pos] )continue;
for(i=0;i<Gto[pos].size();i++){
int to=Gto[pos][i];
int newcost=cost+Gcost[pos][i];
if( newcost < d[to]){
d[to]=newcost;
Q.push( make_pair(-d[to],to) );
}
}
}
for(i=0;i<V;i++){
if(d[i]==INF)printf("INF\n");
else printf("%d\n",d[i]);
}
}
int main(){
int i;
scanf("%d %d %d",&V,&E,&r);
for(i=0;i<E;i++){
scanf("%d %d %d",&a,&b,&c);
Gto[a].push_back(b);
Gcost[a].push_back(c);
}
dijkstra();
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s1,s2;
cin>>s1>>s2;
cout<<s2+s1<<endl;
} | #include <bits/stdc++.h>
#define ll long long int
#define yorn(f) cout<<((f)?"Yes":"No")<<endl;
#define YORN(f) cout<<((f)?"YES":"NO")<<endl;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, n) for (int i = 1; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define put(x) cout << x << endl;
#define println(x) cout << x << endl;
using namespace std;
int main()
{
int n, k;
cin >> n >> k;
int v = 1;
rep(i, n) {
v = min(v * 2, v + k);
}
put(v)
return 0;
} | 0 |
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int n, m;
while(1){
scanf("%d%d", &n, &m);
if(n == 0 && m == 0)return 0;
int res = 0, tmp;
vector<int> points, points2;
for(int i = 0;i < n;i++){
scanf("%d", &tmp);
if(tmp < m)points.push_back(tmp);
}
vector<int>::iterator it1,it2;
for(it1 = points.begin();it1 != points.end();it1++){
points2.push_back(*it1);
for(it2 = points.begin();it2 != points.end();it2++){
if(*it1 + *it2 <= m)points2.push_back(*it1 + *it2);
}
}
sort(points2.begin(),points2.end());
for(it1 = points2.begin();it1 != points2.end();it1++){
it2 = upper_bound(points2.begin(), points2.end(), m - *it1);
res = max(res, *it1);
if(it2 == points2.begin())continue;
it2--;
res = max(res, *it1 + *it2);
}
printf("%d\n",res);
}
} | //JOI 2008??´???3??? ?????????
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<cmath>
using namespace std;
#define MAX -210000000
#define MIN 210000000
int a,b;
int d[1002],c[1001*1001],hk=0,mcunt,low,high;
int x,pr=0/*,flg[200000000]*/,m,ff=0;
int main(){
scanf("%d %d",&a,&b);
while(a!=0 && b!=0){
d[0]=0;
hk=0;
ff=0;
pr=0;
for(int i=1;i<=a;i++) scanf("%d",&d[i]);
for(int i=0;i<=a;i++){
for(int j=0;j<=a;j++){
c[hk]=d[i]+d[j];
hk++;
}
}
sort(c,c+hk);
for(int i=0;i<hk;i++){
x=b-c[i];
low=0;
high=hk-1;
while(low<=high){
m=(low+high)/2;
if(x==c[m]){
ff=1;
break;
}
if(x>c[m]) low=m+1;
else if(x<c[m]) high=m-1;
}
if(ff==1){
pr=c[i]+c[m];
break;
}
if(b>c[i]+c[high] && pr<c[i]+c[high]){
pr=c[i]+c[high];
}
}
printf("%d\n",pr);
scanf("%d %d",&a,&b);
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1e18;
const ll MOD = 1000000007;
const ll MX = 0; //最大値
#define rep(i,n) for(ll i=0; i<(ll)(n); i++)
#define ALL(x) (x).begin(),(x).end()
#define MAX(x) *max_element(ALL(x))
#define PB push_back
#define F first
#define S second
int main(){
double n; cin >> n;
cout << 3.1415 * 2 * n;
return 0;
} | // God put a smile upon your face <3
#include <bits/stdc++.h>
#define slld(longvalue) scanf("%lld", &longvalue)
#define ll long long
#define ull unsigned long long
#define pll pair < long long, long long >
#define fastio ios_base:: sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define pb push_back
#define bug printf("BUG\n")
#define mxlld LLONG_MAX
#define mnlld -LLONG_MAX
#define mxd 2e8
#define mnd -2e8
#define pi 3.14159265359
using namespace std;
bool check(ll n, ll pos)
{
return n & (1LL << pos);
}
ll Set(ll n, ll pos)
{
return n = n | (1LL << pos);
}
int main()
{
ll i, j, k, l, m, n, o, r, q;
ll testcase;
ll input, flag, tag, ans;
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
double rad;
while(cin >> rad)
{
cout << setprecision(10) << fixed << 2.0 * acos(-1.0) * rad << "\n";
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define NIL 2000000001
typedef struct{
int p,l,r,key;
}node;
node tree[500001];
queue<int> q[2];
int root=NIL;
void insert(int key,int i){
node z={NIL,NIL,NIL,key};
int x=(root==NIL?NIL:root),y=NIL;
if(root==NIL)root=i;
while(x!=NIL){
y=x;
if(z.key<tree[x].key){
x=tree[x].l;
}else{
x=tree[x].r;
}
}
z.p=y;
if(y==NIL){
tree[0]=z;
}else if(z.key<tree[y].key){
tree[y].l=i;
}else {
tree[y].r=i;
}
tree[i]=z;
}
void print(int n=0){
if(n==NIL)return;
q[1].push(tree[n].key);
print(tree[n].l);
q[0].push(tree[n].key);
print(tree[n].r);
}
int find(int key){
int f=-1,x=root;
while(x!=NIL){
if(tree[x].key>key){
x=tree[x].l;
}else if(tree[x].key<key){
x=tree[x].r;
}else{
f=x;
break;
}
}
return f;
}
void del(int k){
int x=find(k);
if(x==-1)return;
if(tree[x].l==NIL&&tree[x].r==NIL){
if(tree[tree[x].p].l==x){
tree[tree[x].p].l=NIL;
}else{
tree[tree[x].p].r=NIL;
}
}else if(tree[x].l==NIL||tree[x].r==NIL){
if(tree[x].l==NIL){
if(tree[tree[x].p].l==x){
tree[tree[x].r].p=tree[x].p;
tree[tree[x].p].l=tree[x].r;
}else{
tree[tree[x].r].p=tree[x].p;
tree[tree[x].p].r=tree[x].r;
}
}else{
if(tree[tree[x].p].l==x){
tree[tree[x].l].p=tree[x].p;
tree[tree[x].p].l=tree[x].l;
}else{
tree[tree[x].l].p=tree[x].p;
tree[tree[x].p].r=tree[x].l;
}
}
}else{
int dx=tree[x].r;
while(tree[dx].l!=NIL)dx=tree[dx].l;
tree[x].key=tree[dx].key;
if(tree[dx].l==NIL&&tree[dx].r==NIL){
if(tree[tree[dx].p].l==dx){
tree[tree[dx].p].l=NIL;
}else{
tree[tree[dx].p].r=NIL;
}
}
else{
if(tree[dx].l==NIL){
if(tree[tree[dx].p].l==dx){
tree[tree[dx].r].p=tree[dx].p;
tree[tree[dx].p].l=tree[dx].r;
}else{
tree[tree[dx].r].p=tree[dx].p;
tree[tree[dx].p].r=tree[dx].r;
}
}else{
if(tree[tree[dx].p].l==dx){
tree[tree[dx].l].p=tree[dx].p;
tree[tree[dx].p].l=tree[dx].l;
}else{
tree[tree[dx].l].p=tree[dx].p;
tree[tree[dx].p].r=tree[dx].l;
}
}
}
}
}
int main(){
int n;
cin>>n;
for(int i=0;i<n;i++){
string a;
cin>>a;
if(a[0]=='i'){
int k;
cin>>k;
insert(k,i);
}else if(a[0]=='f'){
int key;
cin>>key;
cout<<(find(key)>=0?"yes":"no")<<endl;
}else if(a[0]=='d'){
int key;
cin>>key;
del(key);
}else{
print();
for(int j=0;j<2;j++){
while(!q[j].empty()){
cout<<" "<<q[j].front();
q[j].pop();
}
cout<<endl;
}
}
}
return 0;
} | #define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
int main(){
int k;
cin>>k;
int r,c;
vector<int> A(8),B(8);
rep(i,8) A[i]=i;
rep(i,8) B[i]=-1;
rep(i,k){
cin>>r>>c;
B[r]=c;
}
char C[8][8];
rep(i,8){
rep(j,8) C[i][j]='.';
}
set<int> p,q;
do{
bool b=true;
rep(i,8){
if(B[i]!=-1 && B[i]!=A[i]) b=false;
}
if(b==false) continue;
rep(i,8) p.insert(i+A[i]);
rep(i,8) q.insert(i-A[i]);
if(p.size()!=8 || q.size()!=8){
p.clear(); q.clear();
continue;
}
rep(i,8) C[i][A[i]]='Q';
break;
}while(next_permutation(ALL(A)));
rep(i,8){
rep(j,8) cout<<C[i][j];
cout<<endl;
}
return 0;
}
| 0 |
/*
ID: anonymo14
TASK: wormhole
LANG: C++
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pair<int,int>> vpii;
#define F first
#define S second
#define PU push
#define PUF push_front
#define PUB push_back
#define PO pop
#define POF pop_front
#define POB pop_back
#define REP(i,a,b) for(int i=a; i<=b; i++)
#define MOD 1000000007
void solve(int test_case) {//223
int n;
cin>>n;
unordered_set<int> s;
while(n--) {
int val;
cin>>val;
if(s.count(val)==1){
s.erase(val);
} else {
s.insert(val);
}
}
cout<<s.size();
}
int main() {
////// FILE BASED IO////
//freopen("wormhole.in", "r", stdin);
//freopen("wormhole.out", "w", stdout);
///////////////
ios::sync_with_stdio(0);
cin.tie(0);
int t=1;
//cin>>t;
REP(i,1,t) {
solve(i);
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
using ll = long long;
int main(void){
string S;
cin>>S;
map<string,int> num;
num["SUN"]=7;
num["MON"]=6;
num["TUE"]=5;
num["WED"]=4;
num["THU"]=3;
num["FRI"]=2;
num["SAT"]=1;
cout<<num[S]<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
int main(){
int n,m,x,y;
cin>>n>>m>>x>>y;
int cnt;
int sum;
string ans="War";
vector<int> a(n);
rep(i,n){
cin>>a[i];
}
vector<int> b(m);
rep(i,m){
cin>>b[i];
}
for(int i=x+1;i<y;i++){
cnt=0;
for(int j=0;j<n;j++){
if(i>a[j]) cnt++;
}
sum=0;
if(cnt==n){
for(int j=0;j<m;j++){
if(i<=b[j]) sum++;
}
}
if(sum==m) ans="No War";
}
cout<<ans<<endl;
} | #include<iostream>
#include<cstdio>
#include <stdio.h>
#include<algorithm>
#include<cstring>
#include <string>
#include<cmath>
#include<cstdlib>
#include<queue>
#include<map>
#include<vector>
#include<bits/stdc++.h>
#include <set>
#define ll long long
#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#define inf 0x3f3f3f
#define pi 3.1415926535898
using namespace std;
int main()
{
int h,w,a,b;
cin>>h>>w>>a>>b;
for(int i=1;i<=b;i++)
{
for(int j=1;j<=w;j++)
{
if(j<=a)
{
cout<<1;
}
else
{
cout<<0;
}
}
cout<<endl;
}
for(int i=b+1;i<=h;i++)
{
for(int j=1;j<=w;j++)
{
if(j>a)
{
cout<<1;
}
else
{
cout<<0;
}
}
cout<<endl;
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
bool bfs(int s,int t,vector<vector<pair<int,int>>> graph,vector<int> &prev)
{
int v,w;
vector<bool> visit(201,false);
queue<int> que;
que.push(s);
visit[s]=true;
for (int i=0;i<prev.size();i++) prev[i]=0;
while(!que.empty())
{
v=que.front();
que.pop();
for (int i=0;i<graph[v].size();i++)
{
if (graph[v][i].first!=0)
{
w=i;
if (!visit[w])
{
visit[w]=true;
prev[w]=v;
que.push(w);
}
}
}
}
return visit[t];
}
int main()
{
int N;cin>>N;
vector<pair<int,int>> red(N),blue(N);
vector<vector<int>> capacity(2*N+2,vector<int> (2*N+2));
vector<vector<int>> flow(2*N+2,vector<int> (2*N+2));
vector<vector<pair<int,int>>> network(2*N+2,vector<pair<int,int>> (2*N+2));
int x,y;
for (int i=0;i<N;i++)
{
cin >> x >> y;
red[i].first=x;
red[i].second=y;
capacity[0][i+1]=1;
}
for (int i=0;i<N;i++)
{
cin >> x >> y;
blue[i].first=x;
blue[i].second=y;
capacity[N+i+1][2*N+1]=1;
}
for (int i=0;i<N;i++)
for (int j=0;j<N;j++)
{
if ((red[i].first<blue[j].first) && (red[i].second < blue[j].second))
{
capacity[i+1][N+j+1]=1;
}
}
for (int i=0;i<2*N+2;i++)
for (int j=0;j<2*N+2;j++)
{
if (capacity[i][j]>flow[i][j])
{
network[i][j].first=1;
network[i][j].second=1;
}
if (flow[i][j]>0)
{
network[j][i].first=1;
network[j][i].second=0;
}
}
int to,from=-1;
vector<int> prev(2*N+2);
while (bfs(0,2*N+1,network,prev))
{
from =-1;
to=2*N+1;
while(from!=0)
{
from=prev[to];
if (network[from][to].second==1)
{
flow[from][to]=1;
network[from][to].first=0;
network[to][from].first=1;
network[from][to].second=1;
network[to][from].second=0;
}
else
{
flow[from][to]=0;
network[from][to].first=0;
network[to][from].first=1;
network[from][to].second=0;
network[to][from].second=1;
}
to=from;
}
}
int ans=0;
for (int i=1;i<2*N+1;i++) ans+=flow[i][2*N+1];
cout << ans << endl;
return 0;
} | #include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cassert>
#define ll long long
using namespace std;
inline int read(){
int re=0,flag=1;char ch=getchar();
while(ch>'9'||ch<'0'){
if(ch=='-') flag=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9') re=(re<<1)+(re<<3)+ch-'0',ch=getchar();
return re*flag;
}
int n,m,dp[110][110][110],sum[110][110],ans;
char s[110];bool a[110][110];
int getsum(int l,int r,int u,int d){
// cout<<" getsum "<<l<<' '<<r<<' '<<u<<' '<<d<<' '<<sum[r][d]-sum[l-1][d]-sum[r][u-1]+sum[l-1][u-1]<<'\n';
return sum[d][r]-sum[d][l-1]-sum[u-1][r]+sum[u-1][l-1];
}
int main(){
// freopen("1.in","r",stdin);
int l,r,u,d,i,j,liml,limr,limu,limd,edx,edy;
n=read();m=read();
for(i=1;i<=n;i++){
scanf("%s",s);
for(j=0;j<m;j++){
if(s[j]=='o') a[i][j+1]=1;
if(s[j]=='E') edx=i,edy=j+1;
}
}
for(i=1;i<=n;i++){
for(j=1;j<=m;j++){
sum[i][j]=sum[i][j-1]+sum[i-1][j]-sum[i-1][j-1]+a[i][j];
// cout<<i<<' '<<j<<' '<<sum[i][j]<<'\n';
}
}
for(i=0;i<=m;i++){
for(j=0;j<=n;j++){
for(l=0;l<=n;l++){
dp[i][j][l]=-1e9;
}
}
}
dp[0][0][0]=0;
// cout<<"start "<<edx<<' '<<edy<<'\n';
for(l=0;l<m;l++){
if(edy-l<=0) break;
for(r=0;r<m;r++){
if(edy+r>m) break;
liml=max(edy-l,1+r);
limr=min(edy+r,m-l);
if(liml>limr) continue;
for(u=0;u<n;u++){
if(edx-u<=0) break;
for(d=0;d<n;d++){
if(edx+d>n) break;
limu=max(edx-u,1+d);
limd=min(edx+d,n-u);
if(limu>limd) continue;
// cout<<l<<' '<<r<<' '<<u<<' '<<d<<' '<<dp[r][u][d]<<'\n';
// if(dp[r][u][d]==-1) continue;
ans=max(ans,dp[r][u][d]);
if(edy+r+1<=m-l){
// cout<<" type 1 "<<l<<' '<<r+1<<' '<<u<<' '<<d<<'\n';
dp[r+1][u][d]=max(dp[r+1][u][d],dp[r][u][d]+getsum(edy+r+1,edy+r+1,limu,limd));
}
if(edx-u-1>=1+d){
// cout<<" type 2 "<<l<<' '<<r<<' '<<u+1<<' '<<d<<'\n';
dp[r][u+1][d]=max(dp[r][u+1][d],dp[r][u][d]+getsum(liml,limr,edx-u-1,edx-u-1));
}
if(edx+d+1<=n-u){
// cout<<" type 3 "<<l<<' '<<r<<' '<<u<<' '<<d+1<<'\n';
dp[r][u][d+1]=max(dp[r][u][d+1],dp[r][u][d]+getsum(liml,limr,edx+d+1,edx+d+1));
}
if(edy-l-1>=1+r){
// cout<<" type 4 "<<l+1<<' '<<r<<' '<<u<<' '<<d<<'\n';
dp[r][u][d]=max(dp[r][u][d],dp[r][u][d]+getsum(edy-l-1,edy-l-1,limu,limd));
}
}
}
}
}
cout<<ans;
} | 0 |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int n; cin >> n;
vector<long long>a(n); for(int i=0;i<n;i++) cin >> a.at(i);
vector<long long>b(n); for(int i=0;i<n;i++) cin >> b.at(i);
vector<long long>c(n); for(int i=0;i<n;i++) cin >> c.at(i);
sort(a.begin(),a.end());
sort(c.begin(),c.end());
long long ans = 0;
for(int i=0;i<n;i++){
auto Iter = lower_bound(a.begin(),a.end(),b.at(i));
long long count_a = Iter - a.begin();
Iter = upper_bound(c.begin(),c.end(),b.at(i));
long long count_c = n - (Iter - c.begin());
ans += count_a * count_c;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
using Graph = vector<vector<ll>>;
int main(){
int n,l; cin>>n>>l;
vector<pair<int, bool> > fla;
for (size_t i = 0; i < n; i++)
{
int tmpfl = l + i;
if (tmpfl< 0)
{
tmpfl *= -1;
fla.push_back(make_pair(tmpfl , true));
continue;
}
fla.push_back(make_pair(tmpfl , false));
}
sort(fla.begin(), fla.end());
fla.erase(fla.begin());
ll ans =0;
for (auto &&i : fla)
{
ans += i.second ? -1 * i.first : i.first ;
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll cou;
void merge(vector<ll> &v,ll l,ll r){
ll mid = (r+l)/2;
ll n1 = mid-l;
ll n2 = r-mid;
vector<ll> a,b;
for(ll i=0;i<n1;i++)a.push_back(v[l+i]);
for(ll i=0;i<n2;i++)b.push_back(v[mid+i]);
a.push_back(1e9);
b.push_back(1e9);
ll aa=0,bb=0;
for(ll i=l;i<r;i++){
if(a[aa]<b[bb]){
v[i]=a[aa++];
}else{
v[i]=b[bb++];
cou+=n1-aa;
}
}
}
void merge_sort(vector<ll> &v,ll l,ll r){
if(r-l>1){
ll mid = (r+l)/2;
merge_sort(v,l,mid);
merge_sort(v,mid,r);
merge(v,l,r);
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
ll n;
cin >> n;
vector<ll> a(n);
for(ll i=0;i<n;i++)cin >> a[i];
merge_sort(a,0,n);
cout << cou << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define PI pair<int,int>
const int maxm=1e6+5;
int a[maxm];
int n;
signed main(){
cin>>n;
for(int i=1;i<=n*2;i++)cin>>a[i];
int ans=0;
sort(a+1,a+1+n*2);
for(int i=1;i<=n*2;i+=2){
ans+=min(a[i],a[i+1]);
}
cout<<ans<<endl;
return 0;
}
/*
*/
| 0 |
#include <iostream>
#include<algorithm>
#include<string>
#include <cmath>
#include <vector>
#include <map>
#include <cstdio>
#include <iomanip>
#pragma region Macros
#define int long long
#define double long double
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,n) for(int i=1;i<=n;i++)
#define LAST(x) x[x.size()-1]
#define ALL(x) (x).begin(),(x).end()
#define swap(a,b) (a += b,b = a - b,a -= b)
#define CEIL(a,b) ((a+b-1)/b)
int FACT(int a) {
if (a == 0)
return 1;
else
return a * FACT(a - 1);
}
int nPr(int n, int r) {
int s = n-r+1;
int sum = 1;
for(int i =s;i<=n;i++)
sum *= i;
return sum;
}
//int nCr1(int n, int r)
//int nCr2(int n, int r)
int GCD(int a, int b) // assuming a,b >= 1
{
if (a < b)
swap(a, b);
if (b == 0)
return a;
if (a % b == 0)
return b;
return GCD(b, a % b);
}
int LCM(int a, int b) // assuming a,b >= 1
{
return a * b / GCD(a, b);
}
double LOG(int a, int b) {
return log(b) / log(a);
}
inline bool BETWEEN(int x, int min, int max) {
if (min <= x && x <= max)
return true;
else
return false;
}
using namespace std;
#pragma endregion
signed main() {
int K, N;
cin >> K >> N;
cout << K - N + 1;
} | #pragma GCC optimize ("Ofast")
#include<bits/stdc++.h>
using namespace std;
inline void rd(int &x){
int k;
int m=0;
x=0;
for(;;){
k = getchar_unlocked();
if(k=='-'){
m=1;
break;
}
if('0'<=k&&k<='9'){
x=k-'0';
break;
}
}
for(;;){
k = getchar_unlocked();
if(k<'0'||k>'9'){
break;
}
x=x*10+k-'0';
}
if(m){
x=-x;
}
}
inline void wt_L(char a){
putchar_unlocked(a);
}
inline void wt_L(int x){
int s=0;
int m=0;
char f[10];
if(x<0){
m=1;
x=-x;
}
while(x){
f[s++]=x%10;
x/=10;
}
if(!s){
f[s++]=0;
}
if(m){
putchar_unlocked('-');
}
while(s--){
putchar_unlocked(f[s]+'0');
}
}
int main(){
int N;
int K;
rd(N);
rd(K);
wt_L(N-K+1);
wt_L('\n');
return 0;
}
// cLay varsion 20191123-1
// --- original code ---
// {
// int N, K;
// rd(N,K);
// wt(N-K+1);
// }
| 1 |
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <cmath>
#include <queue>
#include <stack>
#include <cstdlib>
#include <map>
#include <iomanip>
#include <set>
#include <stdio.h>
#include <ctype.h>
#include <random>
#include <string.h>
using namespace std;
#define pie 3.141592653589793238462643383279
#define mod 1000000007
#define INF 1145141919810364364
#define int long long
#define all(vec) vec.begin(),vec.end()
#define P pair<int,int>
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 n, a[20][20];
int d[(1 << 16)];
vector<int> vec;
signed main() {
cin >> n;
for (int i = 0; i < n; i++)for (int j = 0; j < n; j++)cin >> a[i][j];
for (int i = 1; i < (1 << n); i++) {
vec.clear();
for (int j = 0; j < n; j++)if (i&(1 << j))vec.push_back(j);
int m = (int)vec.size();
int ma = 0;
for (int j = 0; j < (int)vec.size(); j++)for (int k = j + 1; k < (int)vec.size(); k++)ma += a[vec[j]][vec[k]];
for (int j = 0; j < (1 << m); j++) {
int cnt = 0;
for (int k = 0; k < m; k++)if (j&(1 << k))cnt += (1 << vec[k]);
ma = max(ma, d[cnt] + d[i - cnt]);
}
d[i] = ma;
}
cout << d[(1 << n) - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
#ifdef __LOCAL
#define debug(x) cerr << __LINE__ << ": " << #x << " = " << (x) << endl
#define debugArray(x, n) \
cerr << __LINE__ << ": " << #x << " = {"; \
for (long long hoge = 0; (hoge) < (long long)(n); ++(hoge)) \
cerr << ((hoge) ? "," : "") << x[hoge]; \
cerr << "}" << endl
#else
#define debug(x) (void(0))
#define debugArray(x, n) (void(0))
#endif
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
int N;
cin >> N;
long long L[N], R[N];
for (int i = 0; i < N; i++) cin >> L[i] >> R[i];
int idx[N];
iota(idx, idx + N, 0);
// debugArray(idx, N);
auto step = [&]() {
long long leftl[N + 1], leftr[N + 1], rightl[N + 1], rightr[N + 1];
leftl[0] = 0, leftr[0] = INT_MAX;
for (int i = 0; i < N; i++) {
int j = idx[i];
leftl[i + 1] = max(leftl[i], L[j]);
leftr[i + 1] = min(leftr[i], R[j]);
}
rightl[N] = 0, rightr[N] = INT_MAX;
for (int i = N - 1; i >= 0; i--) {
int j = idx[i];
rightl[i] = max(rightl[i + 1], L[j]);
rightr[i] = min(rightr[i + 1], R[j]);
}
// debugArray(leftl, N + 1);
// debugArray(leftr, N + 1);
// debugArray(rightl, N + 1);
// debugArray(rightr, N + 1);
long long ret = 0;
for (int i = 0; i < N - 1; i++) {
ret = max(ret, max(0ll, leftr[i + 1] - leftl[i + 1] + 1)
+ max(0ll, rightr[i + 1] - rightl[i + 1] + 1));
}
for (int i = 0; i < N; i++) {
int j = idx[i];
int ll = max(leftl[i], rightl[i + 1]);
int rr = min(leftr[i], rightr[i + 1]);
ret = max(ret, max(0, rr - ll + 1) + R[j] - L[j] + 1);
}
return ret;
};
long long ans = 0;
sort(idx, idx + N,
[&](int l, int r) { return L[l] == L[r] ? R[l] > R[r] : L[l] < L[r]; });
ans = max(ans, step());
sort(idx, idx + N,
[&](int l, int r) { return R[l] == R[r] ? L[l] > L[r] : R[l] < R[r]; });
ans = max(ans, step());
cout << ans << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 25;
int d;
LL p[N];
int sub1[N], sub2[N]; // sub1 not front, sub2 is front
vector <LL> v;
void dfs(int s, int e, vector <pair <LL, LL> > &w, LL val, LL cnt){
if (s == e){
w.push_back(make_pair(val, cnt));
return ;
}
for (int i = -9; i < 10; i++) // 枚举差值
dfs(s + 1, e, w, val + i * v[s], cnt * (s ? sub1[i + 10] : sub2[i + 10]));
}
LL solve(int len){
v.clear();
for (int i = 0; i < len - 1 - i; i++) v.push_back(p[len - 1 - i] - p[i]);
vector <pair <LL, LL> > v1, v2;
dfs(0, (v.size() + 1) >> 1, v1, 0, 1);
dfs((v.size() + 1) >> 1, v.size(), v2, 0, 1);
LL ans = 0;
map <LL, LL> mp;
for (int i = 0; i < v2.size(); i++) mp[v2[i].first] += v2[i].second;
for (int i = 0; i < v1.size(); i++) ans += mp[d - v1[i].first] * v1[i].second;
if (len & 1) ans *= 10;
return ans;
}
int main(){
p[0] = 1;
for (int i = 1; i < 20; i++) p[i] = p[i - 1] * 10;
for (int i = 0; i < 10; i++)
for (int j = 0; j < 10; j++) sub1[i - j + 10]++;
for (int i = 0; i < 10; i++)
for (int j = 1; j < 10; j++) sub2[i - j + 10]++;
scanf("%d", &d);
LL ans = 0;
for (int i = 2; i <= 18; i++) ans += solve(i);
printf("%lld", ans);
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
long long MOD = 1e9 + 7;
int main(){
int N;
cin >> N;
vector<long long> A(N);
for(int i = 0; i < N; i++) cin >> A[i];
vector<long long> cnt(60, 0);
for(int i = 0; i < N; i++){
int cn = 0;
long long t = A[i];
while(t > 0){
if(t % 2 == 1) cnt[cn]++;
cn++;
t >>= 1;
}
}
long long ans = 0;
for(int i = 0; i < 60; i++){
ans += (1LL << i) % MOD * cnt[i] % MOD * (N - cnt[i]) % MOD;
ans %= MOD;
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
#define sz(x) ((int)x.size())
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const int MOD=1e9+7;
int n,x[3], dp[40][1<<16];
void printbin(int n, int b = 31) {
for(int i=b-1; i>=0; i--) printf("%d", n>>i&1);
}
int Count(int p, int b) {
if(p==n) return 1;
int& res=dp[p][b];
if(res!=-1) return res;
res=0;
int i,t=b,c=0,f=0;
bool chk[11]={0};
while(t>0) t>>=1,c++;
for(i=0;i<c;i++) {
if(i&&(~b>>(i-1)&1)) continue;
if(~b>>(i+x[0]-1)&1) continue;
if(~b>>(i+x[0]+x[1]-1)&1) continue;
t=i+x[0]+x[1]+x[2]-c;
if(t>=1&&t<=10)
chk[t]=1;
}
t=b;
for(int i=1;i<=10;i++) {
if(chk[i]) continue;
while(c+i>16) {
while(t>0&&!(t&1))t>>=1,c--;
t>>=1,c--;
}
res=(res+Count(p+1,t|(1<<(c+i-1))))%MOD;
}
//printf("dp[%d][%d]:%d\n",p,b,res);
//printf("dp[%d][",p); printbin(b,16); printf("]:%d\n",res);
return res;
}
int main() {
memset(dp,-1,sizeof(dp));
scanf("%d%d%d%d",&n,x,x+1,x+2);
int p=1;
for(int i=1;i<=n;i++) p=10ll*p%MOD;
printf("%d", (p-Count(0,0)+MOD)%MOD);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define all(x) x.begin(),x.end()
#define vi vector<int>
#define vll vector<ll>
#define print(x) for(auto it=x.begin();it!=x.end();it++) cout<<*it<<' '; cout<<'\n';
#define debug(a,b,c) cout << a << " " << b << " " << c << endl;
#define in(x,n) for(int e=0;e<n;e++){int y;cin>>y;x.pb(y);}
#define inl(x,n) for(int e=0;e<n;e++){ll y;cin>>y;x.pb(y);}
#define lower(sl) transform(sl.begin(), sl.end(), sl.begin(), ::tolower);
#define endl "\n";
#define pi pair<int,int>
#define vpi vector<pair<int,int>>
#define vvi vector<vector<int>>
int solve(int st, vi a, int& ans,int& n){
if(st > n ) return 0;
int res = 0;
int x1 = solve(st*2, a, ans, n);
int x2 = solve(st*2+1, a, ans, n);
int l1 = (st*2-2)>=a.size()?0:a[st*2-2];
int l2 = (st*2-1)>=a.size()?0:a[st*2-1];
l2 += x2; l1+=x1;
ans += abs(l2-l1);
return max(l1,l2);
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
//code here
int a, b;
cin >> a>> b;
cout << (ll) a*b << endl;
} | 0 |
#include<bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
using namespace std;
#define rep(i,x) for(int i = 0; i < x; i++)
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef long double ld;
typedef pair<int,int> P;
typedef pair<ll,ll> Pll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<vector<vector<int>>> vvvi;
const ll MOD = 1e9+7;
const int n_max = 1e5+10;
int main(){
int a,b; cin >> a >> b;
int h = 100, w = 100;
// int h = 10, w = 10;
// vector<string> s(h);
string s[h];
rep(i,h)rep(j,w){
if(i*2 < h)s[i] += '#';
else s[i] += '.';
}
int cnt = 0;
int x = 0, y = 0;
int dx[8] = {0,0,1,-1,1,-1,1,-1};
int dy[8] = {-1,1,0,0,1,-1,-1,1};
while(cnt < a-1){
bool ok = true;
rep(i,8){
int nx = x + dx[i], ny = y + dy[i];
if(nx >= 0 && h > nx && ny >= 0 && w > ny){
if(s[nx][ny] == '.')ok = false;
}
}
if(ok){
s[x][y] = '.';
++cnt;
}
if(y < w-1)++y;
else{y = 0;++x;}
}
x = h-1;
y = w-1;
cnt = 0;
while(cnt < b-1){
bool ok = true;
rep(i,8){
int nx = x + dx[i], ny = y + dy[i];
if(nx >= 0 && h > nx && ny >= 0 && w > ny){
if(s[nx][ny] == '#')ok = false;
}
}
if(ok){
s[x][y] = '#';
++cnt;
}
if(0 < y)--y;
else{y = w-1;--x;}
}
cout << h << " " << w << endl;
rep(i,h){
rep(j,w)cout << s[i][j];
cout << "\n";
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
vector<int> adj[N];
int vis[N] , n;
bool cycle(int node , int lim) {
if (vis[node])
return vis[node] == 1;
if (!lim)
return 0;
vis[node] = 1;
for (int c : adj[node])
if (cycle(c , lim - 1))
return 1;
vis[node] = 2;
return 0;
}
vector<int> sec;
void find_ans(int node , int lim) {
if (vis[node] == 2)
return;
if (vis[node] == 1) {
for (int c : sec)
cout << c << '\n';
exit(0);
}
if (!lim)
return;
sec.push_back(node);
vis[node] = 1;
for (int c : adj[node])
find_ans(c , lim - 1);
vis[node] = 2;
sec.pop_back();
}
bool good(int lim) {
for (int st = 1 ; st <= n ; st++) {
memset(vis , 0 , sizeof vis);
if (cycle(st , lim))
return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);
int m;
cin >> n >> m;
while (m--) {
int u , v;
cin >> u >> v;
adj[u].push_back(v);
}
int l = 2 , r = n , ans = -1;
while (l <= r) {
int mid = (l + r) / 2;
if (good(mid)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
cout << ans;
if (~ans) {
cout << '\n';
for (int st = 1 ; st <= n ; st++) {
memset(vis , 0 , sizeof vis);
if (cycle(st , ans)) {
memset(vis , 0 , sizeof vis);
find_ans(st , ans);
return 0;
}
}
}
}
| 0 |
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main(){
string str;
cin >> str;
int q;
cin >> q;
for(int i = 0; i < q; i++){
string command;
int a, b;
cin >> command >> a >> b;
if(command == "print"){
cout << str.substr(a, b-a+1) << endl;
}
if(command == "reverse"){
reverse(str.begin()+a, str.begin()+b+1);
}
if(command == "replace"){
string p;
cin >> p;
str.replace(a, b-a+1, p);
}
}
return 0;
} | #include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main() {
int A, B, M;
cin >> A >> B >> M;
vector<int> a(A);
vector<int> b(B);
vector<int> x(M);
vector<int> y(M);
vector<int> c(M);
for (int i = 0; i < A; i++) {
cin >> a[i];
}
for (int i = 0; i < B; i++) {
cin >> b[i];
}
for (int i = 0; i < M; i++) {
cin >> x[i] >> y[i] >> c[i];
}
int value = 1000000;
for (int i = 0; i < M; i++) {
value = min(value, a[x[i] - 1] + b[y[i] - 1] - c[i]);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
value = min(value, a[0] + b[0]);
cout << value << endl;
return 0;
} | 0 |
#include <stdio.h>
int main() {
int n;
long long int val = 0;
scanf("%d",&n);
for (int i = 1 ; i <= n; i++)
{
if (i % 3 == 0 && i % 5 == 0)
{
continue;
}
else if (i % 3 == 0)
{
continue;
}
else if (i % 5 == 0)
{
continue;
}
else
{
val += i;
}
}
printf("%lld",val);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define DBG(x) \
(void)(cout << "L" << __LINE__ \
<< ": " << #x << " = " \
<< (x) << '\n')
#define Lower_bound(v, x) distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) distance(v.begin(), upper_bound(v.begin(), v.end(), x))
typedef long long ll;
using pii = pair<int, int>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const long double PI = (acos(-1));
const long double EPS = 0.0000000001;
const int INF = 0x3f3f3f3f;
const int maxn = 1100000;
void run_case()
{
int a;
cin >> a;
cout << a + a * a + a * a * a << "\n";
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout << setiosflags(ios::fixed) << setprecision(12);
run_case();
cout.flush();
return 0;
} | 0 |
#include<set>
#include<map>
#include<cmath>
#include<queue>
#include<bitset>
#include<string>
#include<cstdio>
#include<cctype>
#include<cstdlib>
#include<cstring>
#include<cassert>
#include<sstream>
#include<numeric>
#include<iostream>
#include<algorithm>
#include<functional>
#define For(i,x,y) for (int i=x;i<y;i++)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define dprintf(...) fprintf(stderr,__VA_ARGS__)
using namespace std;
typedef long long ll;
typedef double db;
typedef vector<int> Vi;
typedef pair<int,int> pii;
int IN(){
int c,f,x;
while (!isdigit(c=getchar())&&c!='-');c=='-'?(f=1,x=0):(f=0,x=c-'0');
while (isdigit(c=getchar())) x=(x<<1)+(x<<3)+c-'0';return !f?x:-x;
}
const int N=1e5+19;
int A[3][N];
int n,rev[2];
Vi V[2];
int C[N];
void Add(int x){
for (;x<N;x+=x&-x) C[x]++;
}
int Qry(int x){
int res=0;
for (;x;x-=x&-x) res+=C[x];
return res;
}
ll calc(int t){
ll res=0;
memset(C,0,sizeof(C));
for (int i=V[t].size()-1;~i;i--){
res+=Qry(V[t][i]+1);
Add(V[t][i]+1);
}
return res;
}
int main(){
n=IN();
For(i,0,3) For(j,0,n) A[i][j]=IN()-1;
For(i,0,3) For(j,0,n){
if (A[i][j]/3!=A[0][j]/3) return puts("No"),0;
if ((A[i][j]/3)%2!=j%2) return puts("No"),0;
}
For(i,0,n){
if (A[1][i]%3!=1) return puts("No"),0;
if (A[0][i]%3!=0) rev[i&1]++;
V[i&1].pb(A[0][i]/3);
}
if (calc(0)%2!=rev[1]%2) return puts("No"),0;
if (calc(1)%2!=rev[0]%2) return puts("No"),0;
puts("Yes");
} | #include<bits/stdc++.h>
#define N 100005
using namespace std;
int n,a[4][N],b[N],c[N],A,B;
void M(int x,int *a){ while(x<=n) a[x]^=1,x+=(x&(-x));}
int Q(int x,int *a){ int s=0; while(x) s^=a[x],x-=(x&(-x)); return s;}
void GG(){ printf("No"); exit(0);}
int main()
{
int i,p;
scanf("%d",&n);
for(i=1;i<=n;i++) scanf("%d",&a[1][i]);
for(i=1;i<=n;i++) scanf("%d",&a[2][i]);
for(i=1;i<=n;i++) scanf("%d",&a[3][i]);
for(i=1;i<=n;i++){
p=(a[1][i]-1)/3;
if((a[2][i]-1)/3!=p) GG();
if((a[3][i]-1)/3!=p) GG();
if((a[1][i]-1)%3==1) GG();
if((a[3][i]-1)%3==1) GG();
if(i&1) b[(a[1][i]+2)/3]=1;
if((a[1][i]-1)%3==2){
if(i&1) A^=1; else B^=1;
}
}
for(i=1;i<=n;i++) if((i&1)&&!b[i]) GG();
memset(b,0,sizeof(b));
for(i=1;i<=n;i++){
p=(a[1][i]+2)/3;
if(i&1) B^=Q(n-p+1,b),M(n-p+1,b);
else A^=Q(n-p+1,c),M(n-p+1,c);
}
if(A+B==0) printf("Yes");
else printf("No");
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define ll long long
#define MODV 1000000007
#define INFLL LLONG_MAX // 9223372036854775807
#define EPS 1e-9
#define rep(i, n) for(ll i=0, i##_len=(ll)(n); i<i##_len; i++)
#define repf(i, n) for(ll i=1, i##_len=(ll)(n+1); i<i##_len; i++)
#define all(v) v.begin(), v.end()
#define endl "\n"
#define vi vector<ll>
#define vvi vector<vector<ll>>
#define Yes() cout << "Yes" << endl
#define YES() cout << "YES" << endl
#define No() cout << "No" << endl
#define NO() cout << "NO" << endl
#define Init() std::ios::sync_with_stdio(false); std::cin.tie(0); std::cout<<fixed<<setprecision(15);
template<class T>bool chmax(T &a, const T &b){ if(a<b){ a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b){ if(b<a){ a=b; return 1; } return 0; }
using namespace std;
int main(){
Init();
ll n, sum = 0; cin >> n;
vi a(n), b(n);
rep(i, n) cin >> a[i] >> b[i];
vector<pair<ll, ll>> ab(n, {0, 0});
rep(i, n){
ab[i].first = a[i]+b[i];
ab[i].second = i;
}
sort(all(ab), greater<pair<ll, ll>>());
rep(i, n){
if(i%2 == 0) sum += a[ab[i].second];
else sum -= b[ab[i].second];
}
cout << sum << endl;
} | #include<iostream>
#include<vector>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
using ll = long long;
using P = pair<int, int>;
#include<algorithm>
#include<math.h>
#include<map>
#include<queue>
#include<set>
int main() {
int n;
cin >> n;
vector<vector<P>>lis(n);
rep(i, n) {
int a;
cin >> a;
rep(j, a) {
int x, y;
cin >> x >> y;
x--;
lis[i].push_back(P(x, y));
}
}
int ans(0);
for (int bit = 0; bit < (1 << n); ++bit) {
int c = 0;
int can = 0;
rep(i, n) {
int cnt(0);
int a = lis[i].size();
if (!(bit >> i & 1))continue;
can++;
rep(j, lis[i].size()) {
int x = lis[i][j].first; int y = lis[i][j].second;
if ((bit >> x & 1) && y != 1)cnt++;
if (!(bit >> x & 1) && y == 1)cnt++;
}
if (cnt >= 1)c = -1;
}
//cout << bit << can << endl;
if (c != -1) {
ans = max(can, ans);
}
}
cout << ans;
return 0;
}
| 0 |
#define _USE_MATH_DEFINES
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <cstring>
#include <vector>
#include <map>
#include <utility>
#include <complex>
#include <stack>
#include <climits>
#include <set>
#include <numeric>
using namespace std;
int t[5];
bool straight()
{
if(t[0] == 1 && t[1] == 10 && t[2] == 11 && t[3] == 12 && t[4] == 13) return true;
for (int i = 0; i < 4; i++){
if(t[i+1]-t[i] != 1) return false;
}
return true;
}
int main()
{
while(~scanf("%d,%d,%d,%d,%d",t,t+1,t+2,t+3,t+4)){
sort(t,t+5);
if(t[0] == t[3] || t[1] == t[4])
puts("four card");
else if( (t[0] == t[1] && t[2] == t[4]) || (t[0] == t[2] && t[3] == t[4]))
puts("full house");
else if(straight())
puts("straight");
else if(t[0] == t[2] || t[1] == t[3] || t[2] == t[4])
puts("three card");
else if( (t[0] == t[1] && (t[2] == t[3] || t[3] == t[4])) || (t[1] == t[2] && t[3] == t[4]) )
puts("two pair");
else if( t[0] == t[1] || t[1] == t[2] || t[2] == t[3] || t[3] == t[4])
puts("one pair");
else
puts("null");
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
int dp[31];
dp[1] = 1;
dp[2] = 2;
dp[3] = 4;
for ( int i = 4; i <= 30; i++ ) dp[i] = dp[i-1] + dp[i-2] + dp[i-3];
while ( cin >> n, n ) {
cout << dp[n]/10/365 + 1 << endl;
}
return 0;
} | 0 |
#include <iostream>
#include <vector>
using namespace std;
const int dx[] = {0, -1, 0, 1};
const int dy[] = {-1, 0, 1, 0};
bool fill(vector<vector<int> > &v, int x, int y, int gx, int gy) {
if(x == gx && y == gy) return true;
int W = v.size();
int H = v[0].size();
int clr = v[x][y];
v[x][y] = 0;
for(int i = 0; i < 4; ++i) {
int xx = x + dx[i];
int yy = y + dy[i];
if(0 <= xx && xx < W && 0 <= yy && yy < H) {
if(v[xx][yy] == clr) {
if(fill(v, xx, yy, gx, gy)) return true;
}
}
}
return false;
}
int main() {
while(true) {
int W, H;
int sx, sy, gx, gy;
int N;
cin >> W >> H;
if(!W && !H) break;
cin >> sx >> sy >> gx >> gy >> N;
--sx; --sy; --gx; --gy;
vector<vector<int> > v(W, vector<int>(H, 0));
for(int i = 0; i < N; ++i) {
int c, d, x, y;
cin >> c >> d >> x >> y;
--x; --y;
int w = d ? 2 : 4;
int h = d ? 4 : 2;
for(int dx = 0; dx < w; ++dx)
for(int dy = 0; dy < h; ++dy)
v[x+dx][y+dy] = c;
}
if(v[sx][sy] != 0 && fill(v, sx, sy, gx, gy)) cout << "OK" << endl;
else cout << "NG" << endl;
}
return 0;
} | #include <cstdio>
#include <functional>
#include <vector>
#include <algorithm>
int testcase_ends() {
int w, h;
scanf("%d %d", &w, &h);
if (w == 0 && h == 0)
return 1;
int xs, ys;
scanf("%d %d", &xs, &ys);
int xg, yg;
scanf("%d %d", &xg, &yg);
std::vector<std::vector<int>> g(h+2, std::vector<int>(w+2));
int n;
scanf("%d", &n);
for (int i=0; i<n; ++i) {
int c, d, x, y;
scanf("%d %d %d %d", &c, &d, &x, &y);
int dh=2, dw=2;
(d? dh:dw) += 2;
for (int j=0; j<dh; ++j)
for (int k=0; k<dw; ++k)
g[y+j][x+k] = c;
}
// for (int i=0; i<h; ++i)
// for (int j=0; j<w; ++j)
// fprintf(stderr, "%d%c", g[i][j], j+1<w? ' ':'\n');
if (g[ys][xs] != g[yg][xg])
return !printf("NG\n");
const int dy[]={-1, 0, 1, 0};
const int dx[]={0, -1, 0, 1};
std::function<bool (int, int)> dfs=[&](int x, int y) {
if (x == xg && y == yg) return true;
int cs=g[y][x];
g[y][x] = -cs; // mark visited
for (int k=0; k<4; ++k) {
int cd=g[y+dy[k]][x+dx[k]];
if (cs == cd && dfs(x+dx[k], y+dy[k]))
return true;
}
return false;
};
printf("%s\n", dfs(xs, ys)? "OK":"NG");
return 0;
}
int main() {
while (!testcase_ends()) {}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef complex<double> P;
typedef pair<int,int> pii;
#define REP(i,n) for(ll i=0;i<n;++i)
#define REPR(i,n) for(ll i=1;i<n;++i)
#define FOR(i,a,b) for(ll i=a;i<b;++i)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define DEBUG_VEC(v) cout<<#v<<":";REP(i,v.size())cout<<" "<<v[i];cout<<endl
#define ALL(a) (a).begin(),(a).end()
#define MOD (ll)(1e9+7)
#define ADD(a,b) a=((a)+(b))%MOD
#define FIX(a) ((a)%MOD+MOD)%MOD
double dot(P a,P b){return real(conj(a)*b);};
double cross(P a,P b){return imag(conj(a)*b);};
int main(){
int n;
while(~scanf("%d",&n)){
if(n==0)break;
ll cur;
cin>>cur;
ll mx = cur;
while(--n){
ll x;
cin>>x;
cur = max(x,cur+x);
mx = max(mx,cur);
}
cout<<mx<<endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main(){
int n;
while(cin >> n, n){
int a[5000], ans = -100001;
for(int i = 0; i < n; i++) cin >> a[i];
for(int i = 0; i < n; i++){
int sum = 0;
for(int j = i; j < n; j++){
sum += a[j];
ans = max(ans, sum);
}
}
cout << ans << endl;
}
return 0;
} | 1 |
#include<queue>
#include<stack>
#include<math.h>
#include<cmath>
#include<bitset>
#include<stdio.h>
#include<string>
#include<map>
#include<algorithm>
#include<vector>
#include<iostream>
#include<utility>
#include<functional>
#include<deque>
#include<list>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int main(){
int k,n,l,i;
int ans=(1<<29);
cin >> n >> l;
vector<int> x(n);
for(i=0;i<n;i++){
x[i]=l+(i+1)-1;
if(abs(x[i])<ans){
ans=abs(x[i]);
k=x[i];
}
}
for(i=0;i<n;i++){
if(k==x[i]){
x[i]=0;
break;
}
}
int sum=0;
for(i=0;i<n;i++){
sum+=x[i];
}
cout << sum << endl;
return 0;
} | #include<iostream>
using namespace std;
int main()
{
int month[12];
month[0]=31;
month[1]=29;
month[2]=31;
month[3]=30;
month[4]=31;
month[5]=30;
month[6]=31;
month[7]=31;
month[8]=30;
month[9]=31;
month[10]=30;
month[11]=31;
int hoge,fuga;
hoge = 1;
int i;
int count=0;
while(hoge!=0)
{
count = 0;
cin >> hoge >> fuga;
//cout << count << endl;
for(i=0;i<hoge-1;i++)
{
count+=month[i];
}
//cout << count << endl;
count+=fuga;
//cout << count << endl;
int flag = 0;
flag = count % 7;
if(flag==0 & hoge!=0)
{
cout << "Wednesday" <<endl;
}
if(flag==1 & hoge!=0)
{
cout << "Thursday" <<endl;
}
if(flag==2 & hoge!=0)
{
cout << "Friday" <<endl;
}
if(flag==3 & hoge!=0)
{
cout << "Saturday" <<endl;
}
if(flag==4 & hoge!=0)
{
cout << "Sunday" <<endl;
}
if(flag==5 & hoge!=0)
{
cout << "Monday" <<endl;
}
if(flag==6 & hoge!=0)
{
cout << "Tuesday" <<endl;
}
}
} | 0 |
#include<iostream>
#include<vector>
using namespace std;
int main() {
int n, p;
while (cin >> n >> p, n) {
int now = 0,wan=p;
vector<int>person(n,0);
while (true) {
if (wan) {
person[now]++; wan--;
if (person[now] == p) {
cout << now << endl;
break;
}
}
else if (person[now]) {
wan = person[now]; person[now] = 0;
}
now++;
if (now >= n)now = 0;
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int N, P;
while(true){
scanf("%d%d", &N, &P);
if(N == 0 && P == 0) break;
int c[50], left = P;
fill(c, c + N, 0);
int turn = 0;
while(true){
if(left == 0){
left += c[turn];
c[turn] = 0;
}else{
--left;
c[turn] += 1;
}
if(c[turn] == P){
break;
}
turn = (turn + 1) % N;
}
printf("%d\n", turn);
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> prime(0);
const int M=1000;
void primeGeneration(){
vector<bool> number(M,true);
for(int i=2;i*i<M;i++){
for(int j=i+i;j<=M;j+=i){
number[j]=false;
}
}
for(int i=2;i<M;i++){
if(number[i])prime.push_back(i);
}
};
void factorization(vector<int> &num,vector<int> &pow,int N){
int n=0,k=-1;
int rn=-1;
for(int i=0;i<M;i++){
num[i]=0;pow[i]==0;
}
while(true){
if(N%prime[n]==0){
if(rn!=n){
k++;
num[k]=prime[n];
}
pow[k]++;
N/=prime[n];
rn=n;
}else{
n++;
}
if(N==1)break;
if(prime[n]*prime[n]>N){
bool ne=true;
for(int i=0;i<=k;i++){
if(num[i]==N){
pow[i]++;
ne=false;
break;
}
}
if(ne){
num[k+1]=N;
pow[k+1]=1;
}
break;
}
}
};
int main() {
primeGeneration();
//for(int i=0;i<M;i++)cout<<prime[i]<<endl;
int N;cin>>N;
vector<int> pow(M,0);
for(int i=2;i<=N;i++){
vector<int> p(M,0);
vector<int> n(M,0);
factorization(n,p,i);
int k=0;
for(int j=0;j<prime.size();j++){
//cout<<prime[j]<<" "<<n[k]<<endl;
if(prime[j]==n[k]){
pow[j]+=p[k];k++;
}
}
}
long cnt=1;
for(int i=0;i<M;i++){
cnt=(cnt*(pow[i]+1))%1000000007;
}
cout<<cnt<<endl;
}
| #include <iostream>
#include <cmath>
using namespace std;
bool isprime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
int log(int base, int num) {
int temp = 0;
int base1 = base;
while (num / base1 > 0) {
temp += num / base1;
base1 *= base;
}
return temp;
}
int main() {
int n;
cin >> n;
long long result = 1;
for (int i = 2; i <= n; i++) {
if (isprime(i)) {
result = (result * (log(i, n) + 1)) % 1000000007;
}
}
cout << result << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, s, n) for(int i = s; i < (int)n; i++)
#define per(i, n) for(int i = n; i >= 0; i--)
#define ROF(i, s, n) for(int i = s; i >= (int)n; i--)
#define FORIT(i, A) for (auto i : A)
#define PRINT(x) cout << (x) << "\n"
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define MP make_pair
#define EACH(i, n) for (__typeof((n).begin()) i = (n).begin(); i != (n).end(); ++i)
#define SZ(a) int((a).size())
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define CLR(a) memset((a), 0 ,sizeof(a))
#define NCLR(a) memset((a), -1 ,sizeof(a))
#define dump(x) cout << #x << " = " << (x) << "\n";
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << "\n";
#define sq(n) (n) * (n)
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef priority_queue<int> maxpq;
typedef priority_queue< int, vector<int>, greater<int> > minpq;
typedef complex<double> P;
static const double EPS = 1e-10;
static const double PI = acos( -1.0 );
static const int mod = 1000000007;
static const int INF = 1 << 29;
static const LL LL_INF = 1152921504606846976;
static const int dx[] = { -1, 0, 1, 0, 1, -1, 1, -1 };
static const int dy[] = { 0, -1, 0, 1, 1, 1, -1, -1 };
int main() {
int n;
VI _array;
string str;
while ( ~scanf( "%d", &n ) && n ) {
_array.resize( n );
for ( int i = 0; i < n; i++ ) {
scanf( "%d", &_array[ i ] );
_array[ i ] %= 52;
}
cin >> str;
for ( int i = 0; i < str.size(); i++ ) {
for ( int j = 0; j < _array[ i % n ]; j++ ) {
if ( str[ i ] - 1 < 'a' && ( str[ i ] < 'A' || str[ i ] > 'Z' ) ) {
str[ i ] = 'Z';
}
else if ( str[ i ] - 1 < 'A' && ( str[ i ] < 'a' || str[ i ] > 'z' ) ) {
str[ i ] = 'z';
}
else {
str[ i ]--;
}
}
}
printf( "%s\n", str.c_str() );
}
return 0;
} | #include <iostream>
#include <map>
using namespace std;
string Alpha = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
int l = 52;
int main(void) {
int n, x, d;
int k[1000];
string s;
map<char, int> mp;
for (int i = 0; i < 52; i++) mp[Alpha[i]] = i;
while (1) {
cin >> n;
if (n == 0) break;
for (int i = 0; i < n; i++) cin >> k[i];
cin >> s;
for (int i = 0; i < s.size(); i++) {
d = k[i % n];
x = (mp[s[i]] + 52 - d) % l;
cout << Alpha[x];
}
cout << endl;
}
return 0;
} | 1 |
#include <iostream>
#include <vector>
using namespace std;
typedef vector<vector<int> > graph;
vector<int> color;
graph G;
bool dfs(int s, int c) {
color[s] = c;
for (int i = 0; i < G[s].size(); i++) {
int v = G[s][i];
if (color[v] == c)
return false;
else if (color[v] == 0 && !dfs(v, -c))
return false;
}
return true;
}
int main() {
long long n, m; cin >> n >> m;
G = graph(n);
color.resize(n);
for (int i = 0; i < n; i++)
color[i] = 0;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
G[a-1].push_back(b-1);
G[b-1].push_back(a-1);
}
if (dfs(0, 1)) {
long long B = 0, W = 0;
for (int i = 0; i < n; i++) {
if (color[i] == 1)
B++;
else if (color[i] == -1)
W++;
}
cout << B * W - m << endl;
}
else {
cout << ((n*(n-1))/2) - m << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<ll> vl;
typedef pair<ll, ll> PP;
#define rep(i, n) for(ll i = 0; i < ll(n); i++)
#define all(v) v.begin(), v.end()
#define inputv(v, n) \
vl v; \
rep(i, n) { \
ll x; \
cin >> x; \
v.push_back(x); \
}
bool chmin(ll& a, ll b) { if (b < a) { a = b; return 1; } return 0; }
bool chmax(ll& a, ll b) { if (b > a) { a = b; return 1; } return 0; }
const ll INF = 999999999999999;
const ll MOD = 1000000007;
const ll MAX_N = 500010;
ll a, b, c, d, e, f, p, t, x, y, z, q, m, n, r, h, k, w, l, ans;
struct Gragh {
ll N;
vector<vl> G;
vl visited;
Gragh(ll n) {
N = n;
G.resize(N);
resetv();
}
void add(ll a, ll b) { G[a].push_back(b); }
void resetv(void) { visited = vl(N, 0); }
//重さ無し
void dfs(ll x) {
visited[x] = 1;
for (ll i : G[x]) {
if (visited[i] == 0) {
dfs(i);
}
}
}
};
int main() {
cin >> n >> m;
Gragh G(2 * n);
rep(i, m) {
cin >> a >> b;
a--;
b--;
G.add(a * 2, b * 2 + 1);
G.add(b * 2, a * 2 + 1);
G.add(a * 2+1, b * 2);
G.add(b * 2+1, a * 2);
}
G.dfs(0);
vl dp(2, 0);
rep(i, n * 2) {
if (G.visited[i] == 1)dp[i % 2]++;
}
x=dp[0];
y=dp[1];
k=x+y-n;
ans=k*(n-k)+k*(k-1)/2+(x-k)*(y-k)-m;
cout << ans << endl;
} | 1 |
#include <iostream>
#include <cassert>
#include <climits>
#include <bitset>
#include <stack>
#include <queue>
#include <iomanip>
#include <limits>
#include <string>
#include <cmath>
#include <set>
#include <map>
#include <math.h>
#include <algorithm>
#include <vector>
#include <string.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
long long int INF = 3e18;
double Pi = 3.1415926535897932384626;
vector<ll> G[500005];
vector<P> tree[500010];
priority_queue <ll> pql;
priority_queue <P> pqp;
//big priority queue
priority_queue <ll,vector<ll>,greater<ll> > pqls;
priority_queue <P,vector<P>,greater<P> > pqps;
//small priority queue
//top pop
int dx[8]={1,0,-1,0,1,1,-1,-1};
int dy[8]={0,1,0,-1,1,-1,-1,1};
char dir[] = "DRUL";
//ll bit[500005];
//↓,→,↑,←
#define p(x) cout<<x<<endl;
#define el cout<<endl;
#define pe(x) cout<<x<<" ";
#define ps(x) cout<<fixed<<setprecision(25)<<x<<endl;
#define pu(x) cout<<x;
#define re(i,n) for(i=0;i<n;i++);
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define deba(x) cout<< #x << " = " << x <<endl
ll mod = 1000000007;
ll rui(ll abc,ll bed){
//abcのbed乗を計算する
if(bed==0){return 1;}
else{
ll ced = rui(abc,bed/2);
ced *= ced;
ced %= mod;
if(bed%2==1){ced*=abc; ced%=mod;}
return ced;
}
}
ll gcd(ll number1,ll number2){
if(number1 > number2){
swap(number1,number2);
}
if(number1 == 0 || number1 == number2){
return number2;
}else{
return gcd(number2 % number1,number1);
}
}
void YES(bool condition){
if(condition){
p("YES");
}else{
p("NO");
}
return;
}
void Yes(bool condition){
if(condition){
p("Yes");
}else{
p("No");
}
return;
}
ll n,m,num,sum,b,c,d,e,f,g,h,i,j,k,w,ok,ng,l,r,ans;
long double a;
ll x[500005],y[500005];
bool flag,dame;
ll sa[40];
void solve(ll reside,ll a,ll b,bool first){
//pe(reside);pe(a);p(b);
if(a == 0){
//p(reside);
if(reside == 0){
ans += b;
//p(b);
}
return;
}
if(reside < -1 * 10 * a || 10 * a < reside)return;
for(int i=-9;i<=9;i++){
if((reside - i * a) % 10 == 0){
if(a == 99){
solve((reside - i * a)/10,a / 100,b * (sa[i + 10] - first) * 10,0);
}else{
solve((reside - i * a)/10,a / 100,b * (sa[i + 10] - first),0);
}
}
}
}
int main(){
cin >> n;
num = 9;
ans = 0;
if(n % 9 != 0){
p(0);return 0;
}
for(i=0;i<20;i++){
sa[i] = 10 - abs(10 - i);
}
for(int i=0;i<18;i++){
solve(n,num,1,1);
//p(num);
num *= 10;
num += 9;
}
p(ans);
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
const int N=4010,M=1000010,P=998244353;
const int inf=0x3f3f3f3f;
const int INF=0xcfcfcfcf;
const double eps=1e-6,pi=asin(1)*2;
inline ll read();
#define cmax(a,b) a=max(a,b)
#define cmin(a,b) a=min(a,b)
inline int ADD(int a,int b) { return a+b>=P?a+b-P:a+b; }
inline int MINUS(int a,int b) { return a-b<0?a-b+P:a-b; }
#define plus(a,b) a=ADD(a,b)
#define minus(a,b) a=MINUS(a,b)
#define mul(a,b) a=(a*(b))%P
#define mem(a,b) memset(a,b,sizeof(a))
#define pii pair<int,int>
#define pil pair<int,ll>
#define pli pair<ll,int>
#define pll pair<ll,ll>
#define mp(x,y) make_pair(x,y)
int K,n;
int C[N][N];
inline void init(int n=4000)
{
for(int i=0;i<=n;i++)
{
C[i][0]=1;
for(int j=1;j<=i;j++) C[i][j]=ADD(C[i-1][j-1],C[i-1][j]);
}
}
const int sign[]={1,P-1};
#ifdef FILE
char buf[1<<25],*p1=buf,*p2=buf;
#define getchar() p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<25,stdin),p1==p2)?EOF:*p1++
#endif
inline ll read()
{
ll s=0;
bool flag=false;
char ch=getchar();
for(;ch<'0'||ch>'9';ch=getchar()) if(ch=='-') flag=true;
for(;'0'<=ch&&ch<='9';ch=getchar()) s=(s<<3)+(s<<1)+(ch^'0');
if(flag) return -s;
return s;
}
int main()
{
#ifdef FILE
freopen(FILE ".in","r",stdin);
freopen(FILE ".out","w",stdout);
#endif
K=read(),n=read();
init();
for(int k=2;k<=2*K;k++)
{
int p=min(k/2,K-(k-1)/2);
int ans=0;
for(int i=0;i<=p;i++) plus(ans,1ll*sign[i&1]*C[p][i]%P*C[n-2*i+K-1][K-1]%P);
printf("%d\n",ans);
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
int kind[16];
int unkind[16];
for(int i=0; i<n; i++){
int kind_p = 0;
int unkind_p = 0;
int t;
cin>>t;
while(t--){
int a,b;
cin>>a>>b;
if(b) kind_p |=(1<<--a);
else unkind_p|=(1<<--a);
}
kind[i] = kind_p;
unkind[i] = unkind_p;
}
int maxpeople = 0;
for(int i=0; i<(1<<n); i++){
int totalkind = 0;
int totalunkind = 0;
for(int j=0; j<n; j++){
if(i&(1<<j)){
totalkind|=kind[j];
totalunkind|=unkind[j];
}
}
bool possible = true;
for(int j=0; j<n; j++){
if(totalkind&(1<<j) && (i&(1<<j))==0) possible = false;
if(totalunkind&(1<<j) && i&(1<<j)) possible = false;
}
if(possible) maxpeople = max(maxpeople,__builtin_popcount(i));
}
//for(int i=0; i<n; i++) cout<<kind[i]<<" ";
cout<<maxpeople;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
int n;
cin >> n;
vector<vector<pair<int, int> > > data(n);
for (int i = 0; i < n; i++) {
int sz;
cin >> sz;
data[i].resize(sz);
for (int j = 0; j < sz; j++) {
cin >> data[i][j].first >> data[i][j].second;
data[i][j].first--;
}
}
int mask = (1 << n) - 1;
while (mask) {
int ppl = mask, i = n - 1;
bool poss = true;
while (ppl) {
if (ppl & 1) {
for (pair<int, int> p : data[i]) {
int id = n - 1 - p.first;
if (p.second && !((1 << id)&mask) || !p.second && (1 << id)&mask)
poss = false;
}
}
ppl /= 2;
i--;
}
if (poss)
break;
mask--;
}
cout << __builtin_popcount(mask);
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int,int>;
#define rep(i, j) for(int i=0; i < (int)(j); i++)
using EdgeList = vector<vector<int>>;
// ?????£?????????????????°?????? E ????????£????????????????§£
// O(N + M) N: ????????°, M: ?????°
vector<vector<int>> strongly_connected_components(const EdgeList &E) {
int N = E.size();
vector<int> ord(N, -1), low(N);
int cnt = 0;
stack<int> stk;
vector<bool> on_stack(N);
vector<vector<int>> scc;
function<void(int, int)> dfs = [&] (int now, int pre) {
stk.push(now);
on_stack[now] = true;
ord[now] = cnt++;
low[now] = ord[now];
for(int nxt : E[now]) {
if(ord[nxt] < 0) {
// not visited
dfs(nxt, now);
low[now] = min(low[now], low[nxt]);
} else if(on_stack[nxt]) {
// visited
low[now] = min(low[now], ord[nxt]);
}
}
if(ord[now] == low[now]) {
scc.push_back({});
while(true) {
int v = stk.top(); stk.pop();
scc.back().push_back(v);
on_stack[v] = false;
if(v == now) break;
}
}
};
// ??£?????°????????????dfs(0)????????§OK?????????
rep(i, N) if(ord[i] < 0) dfs(i, -1);
return scc;
}
#define all(v) v.begin(),v.end()
struct UnionFind{
int n;
vector<int> p;
UnionFind(int nn):n(nn) {
p.resize(n);
rep(i, n) p[i] = i;
}
int root(int x) {
return p[x] == x ? x : (p[x] = root(p[x]));
}
void unite(int x,int y) {
x = root(x); y = root(y);
if(x != y) p[y] = x;
}
bool query(int x,int y){
return root(x) == root(y);
}
};
class Solver {
public:
bool solve() {
int N, M; cin >> N >> M;
EdgeList E(N);
rep(i, M) {
int a, b; cin >> a >> b;
E[a].push_back(b);
}
auto scc = strongly_connected_components(E);
UnionFind uf(N);
for(auto &group : scc) for(int v : group) uf.unite(group.front(), v);
int Q; cin >> Q;
rep(i, Q) {
int u, v; cin >> u >> v;
cout << uf.query(u, v) << endl;
}
return 0;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
Solver s;
s.solve();
return 0;
} | #include <algorithm>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
int n = 0, m = 0;
vector<vector<int>> g;
vector<bool> vi;
vector<int> comp;
stack<int> post;
vector<pair<int, int>> q;
void input() {
cin >> n >> m;
g = vector<vector<int>>(n, vector<int>());
vi = vector<bool>(n, false);
comp = vector<int>(n, -1);
q = vector<pair<int, int>>(0);
while (m--) {
int a = 0, b = 0;
cin >> a >> b;
g[a].push_back(b);
}
int Q = 0;
cin >> Q;
while (Q--) {
int q1 = 0, q2 = 0;
cin >> q1 >> q2;
q.push_back({q1, q2});
}
}
void dfs1(int i) {
vi[i] = true;
for (auto nig : g[i]) {
if (vi[nig] == false) {
dfs1(nig);
}
}
post.push(i);
}
void reverseG() {
vector<vector<int>> rev(n, vector<int>(0));
for (int i = 0; i < g.size(); i++) {
for (int j = 0; j < g[i].size(); j++) {
int node = g[i][j];
rev[node].push_back(i);
}
}
g = rev;
}
void dfs2(int i, int comp_n) {
comp[i] = comp_n;
for (auto nig : g[i]) {
if (comp[nig] == -1) {
dfs2(nig, comp_n);
}
}
}
void compute() {
for (int i = 0; i < n; i++) {
if (vi[i] == false) dfs1(i);
}
reverseG();
int comp_n = 0;
while (!post.empty()) {
int curr = post.top();
post.pop();
if (comp[curr] == -1) dfs2(curr, ++comp_n);
}
for (auto qq : q) {
if (comp[qq.first] == comp[qq.second])
cout << "1" << endl;
else
cout << "0" << endl;
}
}
int main() {
input();
compute();
return 0;
}
| 1 |
#include<cstdio>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
typedef pair<int,int> pii;
const int INF = 1000000000;
int par[10000],rnk[10000];
void init(int n){
for(int i=0;i<n;i++){
par[i] = i;
rnk[i] = 1;
}
}
int find(int x){
if(par[x]==x) return x;
else return par[x] = find(par[x]);
}
bool same(int x,int y){
return find(x)==find(y);
}
void unite(int x,int y){
x = find(x);
y = find(y);
if(rnk[x]>rnk[y]) par[y] = x;
else{
par[x] = y;
if(rnk[x]==rnk[y]) rnk[y]++;
}
return;
}
int main(){
int V,E;
vector<pair<int,pii> > es;
scanf("%d %d",&V,&E);
for(int i=0;i<E;i++){
int s,t,w;
scanf("%d %d %d",&s,&t,&w);
es.push_back(make_pair(w,pii(s,t)));
}
int ans = 0;
int cost[10000];
fill(cost,cost+V,INF);
sort(es.begin(),es.end());
cost[0] = 0;
init(V);
for(int i=0;i<es.size();i++){
if(!same(es[i].second.first,es[i].second.second)){
ans += es[i].first;
unite(es[i].second.first,es[i].second.second);
}
}
printf("%d\n",ans);
return 0;
} | #include<bits/stdc++.h>
using namespace std;
struct Edge{
int to,cost;
bool operator<(const Edge&a)const{
return cost>a.cost;
}
};
struct Graph{
Graph(int n):E(n),T(n),N(n){}
vector<vector<Edge>>E,T;
int N;
void add_edge(int a,int b,int c){
E[a].push_back({b,c});
E[b].push_back({a,c});
}
void prim(int s){
bool visited[N];
priority_queue<pair<Edge,int>>Q;
memset(visited,0,N);
Q.push({{s,0},-1});
while(Q.size()){
Edge e=Q.top().first;
int from=Q.top().second;Q.pop();
if(visited[e.to])continue;
visited[e.to]=1;
if(from+1)T[from].push_back(e),T[e.to].push_back({from,e.cost});
for(auto&a:E[e.to])
if(!visited[a.to])Q.push({a,e.to});
}
}
int get_cost(){
int ret=0;
for(auto&a:T)for(auto&b:a)ret+=b.cost;
return ret/2;
}
vector<Edge>* get_MST(){
return T.data();
}
};
main(){
int V,E,a,b,c;
cin>>V>>E;
Graph G(V);
for(int i=0;i++<E;G.add_edge(a,b,c))cin>>a>>b>>c;
G.prim(0);
cout<<G.get_cost()<<endl;
} | 1 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<cmath>
#include<map>
using namespace std;
#define rep(i,N) for(int i=0;i<N;i++) //0から
typedef long long ll;
ll binary_search(vector<ll> a, ll n, ll key){
ll right = n, left = -1;
ll md = (right + left) / 2;
while(right - left > 1){
if(a[md] <= key){
right = md;
}else{
left = md;
}
md = (right + left) / 2;
}
if(left == -1) return -1; //無い場合
return right;
}
vector<ll> prime;
void Prime(ll n){ //線形篩,素数列挙
vector<ll> p(n,0);
p[0]=1;
p[1]=1;
for(ll i=2;i<n;i++){
if(p[i]==0){
prime.push_back(i);
p[i]=i;
}
ll k=prime.size();
for(ll j=0;j<k && i*prime[j]<n && prime[j]<=p[i];j++){
p[i*prime[j]]=prime[j];
}
}
}
#define MOD ((ll)1e+9 + 7)
//cout<<fixed<<setprecision(10);
int main(){
int p,q,r;
cin>>p>>q>>r;
cout<<p+q+r-max(p,max(q,r))<<endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define ft ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define ll long long
#define pi pair<int,int>
#define pb push_back
#define F first
#define S second
#define B begin()
#define E end()
const int N=2e5+3;
//string s,p;
//vector<int>v;
//map<int,int>mp;
int main()
{
ft
int t,i,j,n,m,l,r,a[3];
for(i=0;i<3;i++)
{
cin>>a[i];
}
sort(a,a+3);
cout<<a[0]+a[1]<<"\n";
return 0;
}
| 1 |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cmath>
#include<bitset>
#include<deque>
#include<functional>
#include<iterator>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<utility>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
#define a first
#define b second
#define sz(x) (ll)((x).size())
#define pb push_back
#define mp make_pair
#define bg begin()
#define ed end()
#define all(x) (x).bg,(x).ed
#define rep(i,n) for(ll i=0;i<(n);i++)
#define rep1(i,n) for(ll i=1;i<=(n);i++)
#define rrep(i,n) for(ll i=(n)-1;i>=0;i--)
#define rrep1(i,n) for(ll i=(n);i>=1;i--)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
const ll MOD=1000000007;
const ll INF=1000000000000000;
template<class T> inline bool chmin(T& a, T b){if(a>b){a=b;return true;}return false;}
template<class T> inline bool chmax(T& a, T b){if(a<b){a=b;return true;}return false;}
ll maxx(ll x,ll y,ll z){return max(max(x,y),z);}
ll minn(ll x,ll y,ll z){return min(min(x,y),z);}
ll gcd(ll x,ll y){if(x%y==0) return y;else return gcd(y,x%y);}
ll lcm(ll x,ll y){return x*(y/gcd(x,y));}
vector<ll> pw2(51,1);vector<ll> pw10(19,1);
ll high_order_bit(ll n){
ll tmp=1,i=-1;
while(tmp<=n){
tmp*=2;
i++;
}
if(n==0) return 0;
else return i;
}
vector<ll> binary_expansion(ll n){
vector<ll> B(high_order_bit(n)+1);
ll tmp=n;
for(ll i=high_order_bit(n);i>=0;i--){
B[i]=tmp/pw2[i];
tmp%=pw2[i];
}
return B;
}
vector<ll> divisor(ll x){
vector<ll> div;
for(int i=1;i*i<=x;i++){
if(i*i!=x && x%i==0){
div.pb(i);
div.pb(x/i);
}
else if(x%i==0) div.pb(i);
}
return div;
}
vector<ll> vectorprime(ll x){
vector<bool> is_prime(x+1);
vector<ll> prime;
rep(i,x+1) is_prime[i]=true;
is_prime[0]=is_prime[1]=false;
for(int i=2;i<=x;i++){
if(is_prime[i]){
prime.pb(i);
}
for(int j=i*2;j<=x;j+=i) is_prime[j]=false;
}
return prime;
}
int main(){
{rep1(i,50) pw2[i]=(-2)*pw2[i-1];}
{rep1(i,18) pw10[i]=10*pw10[i-1];}
ll N,tmp; cin>>N;
if(N==0){
cout<<0;
return 0;
}
tmp=N;
vector<ll> ans;
ll now=0; //0の位見てる
while(tmp!=0){
if(tmp%(pw2[now+1]) !=0 ){
ans.pb(1ll);
tmp -= pw2[now];
}
else{
ans.pb(0ll);
}
now++;
}
rrep(i,sz(ans)) cout<<ans[i];
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double ld;
typedef pair<int,int> pii;
typedef map<int,int> mii;
typedef vector<int>vi;
#define pb push_back
#define sc(n) scanf("%d",&n)
#define lsc(n) scanf("%lld",&n)
#define all(x) x.begin(),x.end()
#define rep(i,n) for(i=0LL;i<n;i++)
#define rep1(i,n) for(i=1;i<=n;i++)
#define rev(i,n) for(i=n-1;i>=0;i--)
#define rev1(i,n) for(i=n;i>0;i--)
#define in insert
#define IT ::iterator
#define F first
#define S second
#define pr(n) printf("%d\n",n)
#define lpr(n) printf("%lld\n",n);
void solve()
{
string v[]={"SUN","MON","TUE","WED","THU","FRI","SAT"};
string s;
cin >> s;
int i;
rep(i,7)
{
if(v[i]==s)
{
cout << 7-i ;
break;
}
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tc=1;
// cin >> tc;
while(tc--)
{
solve();
}
return 0;
}
| 0 |
//include,using,define等
#pragma region header
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <math.h>
#include <cstring>
// ===============================================================
//using系
#pragma region header
using namespace std;
using ll = long long;
using lint = long long;
using vl = vector<long long>;
using vvl = vector<vector<long long>>;
using vvi = vector<vector<int>>;
using vs = vector<string>;
using vc = vector<char>;
using vcc = vector<vector<char>>;
using vm = vector<short>;
using vmm = vector<vector<short>>;
using pii = pair<int, int>;
using psi = pair<string, int>;
using ld = long double;
using ull = unsigned long long;
using ui = unsigned int;
using qul = queue<ll>;
using pql = priority_queue<ll>;
const int dx[] = { 1,0,-1,0 };
const int dy[] = { 0,1,0,-1 };
constexpr ll mod = 1e9 + 7;
constexpr long double pi = 3.141592653589793238462643383279;
#pragma endregion
// ========================================================================
//define
#pragma region header
//#define int long long
#define rep(i, n) for(ll i = 0; i < n; i++)
#define REP(i, n) for(ll i = 1; i <= n; i++)
#define INF (ll)10000000000000000
#define mod (ll)1000000007
#define P pair<lint,lint>
template <class T>
bool chmax(T & a, const T & b) {
if (a < b) {
a = b; // aをbで更新
return true;
}
return false;
}
template <class T>
bool chmin(T& a, const T& b) {
if (a > b) {
a = b; // aをbで更新
return true;
}
return false;
}
#pragma endregion
#pragma endregion
int main(void) {
string s; cin >> s;
if (s.size() == 2)
printf("%s", s.c_str());
else
for (int i = 2; i >= 0; i--)
printf("%c", s[i]);
printf("\n");
return 0;
} | #include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <stack>
#include <string>
using namespace std;
int main(){
string s;
while(cin>>s){
if(s.length()==2){
}else if(s.length()==3){
reverse(s.begin(),s.end());
}
cout<<s<<endl;
}
} | 1 |
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define N 2200
using namespace std;
int a[N][N],f[N][N],l[N],r[N],b[N],id[N];
int n,m,ans;
char s[N];
int check(int x,int y){
return ((a[x][y]==a[x-1][y])&&(a[x][y-1]==a[x-1][y-1]))||((a[x][y]!=a[x-1][y])&&(a[x][y-1]!=a[x-1][y-1]));
}
bool cmp(int x,int y){
return b[x]>b[y];
}
int solve(){
for(int i=1;i<=n;i++)id[i]=i;
sort(id+1,id+1+n,cmp);
memset(l,0,sizeof(l));
memset(r,0,sizeof(r));
for(int i=1;i<=n;i++){
int x=id[i];
l[x]=x;
r[x]=x;
if(l[x-1])l[x]=min(l[x],l[x-1]);
if(r[x+1])r[x]=max(r[x],r[x+1]);
r[l[x]]=r[x];
l[r[x]]=l[x];
ans=max(ans,(r[x]-l[x]+1)*b[x]+((l[x]-1>0)?b[x]:0));
l[0]=0;
r[0]=0;
}
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++){
scanf("%s",s+1);
for(int j=1;j<=m;j++)a[i][j]=s[j]=='.';
}
for(int i=1;i<=m;i++)f[1][i]=i;
for(int i=2;i<=n;i++){
f[i][1]=1;
for(int j=2;j<=m;j++){
if(check(i,j))f[i][j]=f[i][j-1]+1;
else f[i][j]=1;
}
}
for(int i=1;i<=m;i++){
for(int j=1;j<=n;j++)b[j]=f[j][i];
solve();
}
printf("%d\n",ans);
} | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
using namespace std;
#define mod 1000000007
#define FOR(x,to) for(int x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
#define long long long
inline int rei(){int x;cin>>x;return x;}
inline long rel(){long x;cin>>x;return x;}
inline string res(){string x;cin>>x;return x;}
//-------------------------------------------------------
int DP[301*301*301];
void Calc(){
string S = res();
int K = rei();
int N = S.length();
for(int i=0;i<N;i++){
for(int j=N-1;j>i;j--){
for(int k=0;k<=K;k++){
DP[(i+1)*301*301+j*301+k] = max(DP[i*301*301+j*301+k],DP[(i+1)*301*301+(j+1)*301+k]);
if(S[i] == S[j]){
DP[(i+1)*301*301+j*301+k] = max(DP[(i+1)*301*301+j*301+k],DP[i*301*301+(j+1)*301+k]+1);
}
else if(k != 0){
DP[(i+1)*301*301+j*301+k] = max(DP[(i+1)*301*301+j*301+k],DP[i*301*301+(j+1)*301+k-1]+1);
}
}
}
}
int ans = 1;
for(int k=0;k<=K;k++){
for(int i=0;i<N-1;i++){
ans = max(DP[(i+1)*301*301+(i+1)*301+k]*2,ans);
}
for(int i=0;i<N-2;i++){
ans = max(DP[(i+1)*301*301+(i+2)*301+k]*2+1,ans);
}
}
cout << ans << endl;
}
int main(int argc,char** argv){
ios::sync_with_stdio(false), cin.tie(0);
cout.tie(0); Calc(); return 0;
} | 0 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
using namespace std;
typedef pair<int, int> P;
int k, a[100000], dist[100000];
vector<int> v[100000];
vector<P> w;
bool b[100000];
void cal(int x, int y){
dist[x] = y;
b[x] = false;
w.push_back(P(y, x));
for(int i=0;i<v[x].size();i++){
cal(v[x][i], y+1);
}
}
int hin(int x, int y){
if(b[x])return 0;
b[x] = true;
if(x == 0 || (a[x] == 0 && y == k-1))return 0;
if(y == k-1)return 1;
return hin(a[x], y+1);
}
int main() {
int n, ans = 0;
cin >> n >> k >> a[0];
if(--a[0] != 0)ans++;
for(int i=1;i<n;i++){
cin >> a[i];
v[--a[i]].push_back(i);
}
cal(0, 0);
sort(w.begin(), w.end(), greater<P>());
for(int i=0;i<w.size();i++){
int p = w[i].second;
if(!b[p]){
ans += hin(p, 0);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define N 100000
#define pb push_back
int n, k, len, a[N + 5], d[N + 5], vis[N + 5], ans;
vector<int> G[N + 5];
struct Cmp {
bool operator () (const int &a, const int &b) const {
return d[a] < d[b];
}
};
priority_queue<int, vector<int>, Cmp> pq;
void dfs1(int u) {
for (int i = 0, v; i < G[u].size(); ++i) {
v = G[u][i];
d[v] = d[u] + 1;
dfs1(v);
}
}
void dfs2(int u) {
len++;
if (u == 1)
return ;
dfs2(a[u]);
}
void mark(int u) {
vis[u] = 1;
for (int i = 0, v; i < G[u].size(); ++i) {
v = G[u][i];
if (vis[v])
continue;
mark(v);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
dfs2(a[1]);
for (int i = 2; i <= n; ++i)
G[a[i]].pb(i);
dfs1(1);
bool flag = 1;
for (int i = 1; i <= n; ++i)
if (d[i] > k || (k - d[i]) % len) {
flag = 0;
break;
}
if (flag)
ans = 0;
else {
if (a[1] != 1) ans = 1;
else ans = 0;
a[1] = 1;
for (int i = 2; i <= n; ++i)
pq.push(i);
while (!pq.empty()) {
int u = pq.top(), v; pq.pop();
if (d[u] <= k || vis[u])
continue;
ans++;
v = u;
for (int i = 1; i <= k - 1; ++i)
v = a[v];
a[v] = 1;
// printf("u:%d v:%d\n", u, v);
mark(v);
}
}
printf("%d\n", ans);
// for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
// printf("\n");
return 0;
} | 1 |
#include<iostream>
using namespace std;
int main(){
int n;
while(cin>>n){
if(!n) break;
int a[n];
for(int i=0; i<n; i++){
cin >> a[i];
}
int mx=-99999999;
for(int i=0; i<n; i++){
int sum=0;
for(int j=i; j<n; j++){
if(mx < sum+a[j]) mx = sum+a[j];
sum += a[j];
}
}
cout << mx << endl;
}
return 0;
} | #include <cstdio>
#include <cstdlib>
#include <cstdint>
#include <cstring>
#include <cctype>
#include <iostream>
#include <sstream>
#include <vector>
#include <list>
#include <deque>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <functional>
#include <complex>
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long ll;
const double PI = 3.141592653589793238462643383279502884L;
const int LARGE_PRIME = 1000000007;
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define tr(c, i) for(auto i = (c).begin(); i != (c).end(); i++)
#define rtr(c, i) for(auto i = (c).rbegin(); i != (c).rend(); i++)
#define repfn(i,a,cont,next) \
for(auto i = (a); [=](){return(cont);}(); i = [=](){return(next);}())
#define repby(i,a,b,s) repfn(i,a,i<b,i+s)
#define repab(i,a,b) repby(i,a,b,1)
#define rep(i,b) repab(i,0,b)
#define pb push_back
#define sz(c) int((c).size())
int main(int argc, char **argv)
{
for (;;) {
int n;
vi v;
cin >> n;
if (!n)
break;
while (n--) {
int tmp;
cin >> tmp;
v.pb(tmp);
}
vi w(v);
for (int i = 1; i < sz(v); i++) {
v[i] = max(v[i-1] + v[i], v[i]);
}
cout << *max_element(all(v)) << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef ostringstream OSS; typedef istringstream ISS;
typedef long long LL;
typedef pair<int, int> PII; typedef pair<LL, LL> PLL;
typedef vector<int> VI; typedef vector<VI> VVI; typedef vector<VVI> VVVI;
typedef vector<LL> VLL; typedef vector<VLL> VVLL; typedef vector<VVLL> VVVLL;
typedef vector<double> VD; typedef vector<VD> VVD; typedef vector<VVD> VVVD;
typedef vector<string> VS; typedef vector<VS> VVS; typedef vector<VVS> VVVS;
typedef vector<bool> VB; typedef vector<VB> VVB; typedef vector<VVB> VVVB;
typedef vector<PII> VPII; typedef vector<VPII> VVPII; typedef vector<VVPII> VVVPII;
typedef vector<PLL> VPLL; typedef vector<VPLL> VVPLL; typedef vector<VVPLL> VVVPLL;
typedef unsigned int UI;
typedef vector<UI> VUI;
typedef vector<VUI> VVUI;
#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 RALL(x) (x).rbegin(),(x).rend()
#define RANGEBOX(x,y,maxX,maxY) (0 <= (x) && 0 <= (y) && (x) < (maxX) && (y) < (maxY))
#define RANGE(x, l, r) ((l) <= (x) && (x) <= (r))
#define rep(i, N) for (int i = 0; i < (int)(N); i++)
#define rrep(i, N) for (int i = N - 1; i >= 0; i--)
#define REP(i, init, N) for (int i = (init); i < (int)(N); i++)
#define RREP(i, N, last) for (int i = (init - 1); i >= last; i--)
#define MAXUD(orig, target) orig = max(orig, target)
#define MINUD(orig, target) orig = min(orig, target)
#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(); };
template<typename T=int> inline void dump(vector<T> vs, bool ent=false) { rep(i, vs.size()) cout << vs[i] << (i+1==vs.size() ? '\n' : ' '); if (ent) cout << endl; }
template<typename T = int> inline void dump(vector<vector<T>> vs, bool ent = false) { rep(i, vs.size()) dump<T>(vs[i]); if (ent) cout << endl; }
const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;
const double DINF = 0x3f3f3f3f;
const int DX[] = {1, 0, -1, 0};
const int DY[] = {0, -1, 0, 1};
const double EPS = 1e-12;
// const double PI = acos(-1.0);
// lambda: [](T1 x)->T2{return y;}
// simple lambda: [](T x){return x;}
void solve(int n) {
VS names(n);
VI ps(n);
VI ts1(n);
VI ts2(n);
VI fs(n);
VI ss(n);
VI ms(n);
rep(i, n) {
cin >> names[i] >> ps[i];
VI as(5);
rep(j, 5) cin >> as[j];
ts1[i] = accumulate(ALL(as), 0);
ts2[i] = as[3] + as[4];
cin >> fs[i] >> ss[i] >> ms[i];
}
VD scores(n);
rep(i, n) {
scores[i] = 1. * (fs[i] * ms[i] * ss[i] - ps[i]) / (ts1[i] + (ms[i] - 1) * ts2[i]);
}
vector<pair<double, string>> xs(n);
rep(i, n) xs[i] = MP(scores[i], names[i]);
sort(ALL(xs), [](pair<double, string> a, pair<double, string> b){
if (abs(a.fst - b.fst) > EPS) return a.fst > b.fst;
return a.snd < b.snd;
});
for (auto x : xs) cout << x.snd << endl;
cout << "#" << endl;
}
int main(void) {
int n;
while (cin >> n, n) solve(n);
return 0;
} | #include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;
int main(){
int n;
while(cin>>n&&n!=0){
int p,a,b,c,d,e,f,s,m;
string l;
vector<pair<double,string> > vpii;
for(int i = 0; i < n; i++){
cin>>l>>p>>a>>b>>c>>d>>e>>f>>s>>m;
int time = a+b+c+d+e;
for(int j = 1; j < m; j++)
time+=d+e;
int income=-p;
for(int j = 0; j < m; j++)
income+=s*f;
double rate=(double)income/time;
vpii.push_back(make_pair(-rate,l));
}
sort(vpii.begin(),vpii.end());
for(int i = 0; i < vpii.size(); i++){
cout<<vpii[i].second<<endl;
}
cout<<"#"<<endl;
}
return 0;
} | 1 |
#include<cstdio>
#include<cctype>
#include<unordered_map>
#include<vector>
#include<queue>
using namespace std;
const int N=1e5,M=2e5,P=N+2*M,inf=0x3f3f3f3f;
typedef pair<int,int> pii;
int n,m,tot;
vector<pii>e[P+1];
int dis[P+1];
int read()
{
int ret=0;
char c=getchar();
while(!isdigit(c)) {
c=getchar();
}
while(isdigit(c)) {
ret=ret*10+c-'0';
c=getchar();
}
return ret;
}
int get_number(int p,int c)
{
static unordered_map<long long,int>mp;
long long has=(long long)p<<32|c;
if(!mp[has]) {
mp[has]=++tot;
}
return mp[has];
}
void dijkstra()
{
static bool vis[P+1];
static priority_queue<pii,vector<pii>,greater<pii>>que;
fill(dis+1,dis+tot+1,inf);
que.push(pii{dis[1]=0,1});
while(!que.empty()) {
int u=que.top().second;
que.pop();
if(vis[u]) {
continue;
}
vis[u]=true;
for(pii e:e[u]) {
int v=e.first;
if(dis[u]+e.second<dis[v]) {
que.push(pii{dis[v]=dis[u]+e.second,v});
}
}
}
return;
}
int main()
{
n=read(),m=read();
tot=n;
for(int i=1,u,v,c;i<=m;++i) {
u=read(),v=read(),c=read();
int uc=get_number(u,c),vc=get_number(v,c);
e[u].push_back(pii{uc,1}),e[uc].push_back(pii{u,1});
e[v].push_back(pii{vc,1}),e[vc].push_back(pii{v,1});
e[uc].push_back(pii{vc,0}),e[vc].push_back(pii{uc,0});
}
dijkstra();
printf("%d\n",dis[n]==inf?-1:dis[n]/2);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define repi(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define all(x) (x).begin(),(x).end()
#define foreach(u,v) for(auto (u) : (v))
#define pb push_back
#define mp make_pair
#define mt make_tuple
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<ll, ll> pll;
typedef vector<ll> vl;
const int inf = 1e9;
const ll linf = 1LL<<60;
const ll mod = 1e9 + 7;
const double eps = 1e-9;
/*
*/
typedef tuple<int, int, int> triple;
int n, m;
map<pii, vector<triple>> g;
map<pii, ll> dist;
int main()
{
cin >> n >> m;
rep(i, m){
int p, q, c;
cin >> p >> q >> c;
p--; q--;
g[mp(p, c)].pb(mt(q, c, 0));
g[mp(q, c)].pb(mt(p, c, 0));
g[mp(p, c)].pb(mt(q, -1, 0));
g[mp(q, c)].pb(mt(p, -1, 0));
g[mp(p, -1)].pb(mt(q, c, 1));
g[mp(q, -1)].pb(mt(p, c, 1));
dist[mp(p, c)] = linf;
dist[mp(q, c)] = linf;
dist[mp(p, -1)] = linf;
dist[mp(q, -1)] = linf;
}
rep(i, n) dist[mp(i, -1)] = linf;
priority_queue<triple, vector<triple>, greater<triple>> que;
que.push(mt(0, 0, -1));
dist[mp(0, -1)] = 0;
while(!que.empty()){
int d, v, c;
tie(d, v, c) = que.top();
que.pop();
if(dist[mp(v, c)] < d) continue;
for(auto e : g[mp(v, c)]){
int to, cc, dd;
tie(to, cc, dd) = e;
if(dist[mp(to, cc)] > dist[mp(v, c)] + dd){
dist[mp(to, cc)] = dist[mp(v, c)] + dd;
que.push(mt(dist[mp(to, cc)], to, cc));
}
}
}
ll ans = dist[mp(n-1, -1)];
if(ans == linf) cout << -1 << endl;
else cout << ans << endl;
return 0;
}
| 1 |
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
using namespace std;
const ll MOD = 1000000007;
int main() {
ll N;
cin >> N;
vector <ll> A(N);
for (int ii = 0; ii < N; ++ii){
cin >> A[ii];
}
ll ans = 0;
vector <ll> digZero(61);
vector <ll> digOne(61);
for (int ii = 0; ii < N; ++ii){
ll keta = 0;
ll val = 1;
for (int jj = 0; jj < 61; ++jj){
ll tmp = A[ii] & 1;
if (tmp == 0){
ans = (ans + val * digOne[keta]) % MOD;
digZero[keta] = (digZero[keta] + 1) % MOD;
} else {
ans = (ans + val * digZero[keta]) % MOD;
digOne[keta] = (digOne[keta] + 1) % MOD;
}
val = (val * 2) % MOD;
keta++;
A[ii] /= 2;
}
}
cout << ans << "\n";
return 0;
}
| #include<cstdio>
typedef long long LL;
const int N=2003;
const int O=2*N;
int n,m,ans;
int dp[3*N][5*N];
inline LL Pow(LL x,int p) {
if(p==0) return 1;
if(!(p&1)) return Pow(x*x%m,p>>1);
return x*Pow(x*x%m,p>>1)%m;
}
inline void Add(int &x,int y) {
x+=y; if(x>=m) x-=m;
}
int main() {
scanf("%d %d",&n,&m); n*=3;
dp[0][O]=1;
for(int s=0;s<=n;s++) {
for(int D=-s/2;D<=s;D++) {
int d=D+O;
Add(dp[s+1][d+1],dp[s][d]);
Add(dp[s+2][d-1],dp[s][d]*(s+1ll)%m);
Add(dp[s+3][d],dp[s][d]*(s+1ll)%m*(s+2ll)%m);
}
}
for(int i=0;i<=n;i+=3)
Add(ans,dp[n][i+O]);
printf("%d\n",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
#define M_PI 3.14159265358979323846 // pi
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> t3;
#define rep(a,n) for(ll a = 0;a < n;a++)
static const ll INF = 1e15;
static const ll mod = 1e9+7;
template<typename T>
static inline void chmin(T& ref, const T value) {
if (ref > value) ref = value;
}
template<typename T>
static inline void chmax(T& ref, const T value) {
if (ref < value) ref = value;
}
struct MaxFlowCalculator {
int max_flow(int s, int t, const vector<vector<pair<int, int>>>& g) {
struct edge_ { int to, cap, rev; };
vector<bool> used(g.size(), false);
vector<vector<edge_>> G(g.size());
for (int i = 0; i < g.size(); i++) for (int j = 0; j < g[i].size(); j++)
{
int from = i, to = g[i][j].second;
int cap = g[i][j].first;
G[from].push_back({ to, cap, (int)G[to].size() });
G[to].push_back({ from, 0, (int)G[from].size() - 1 });
}
auto dfs = [&](auto&& f, int v, int t, int fl)->int {
if (v == t) return fl;
used[v] = true;
rep(i, G[v].size()) {
edge_& e = G[v][i];
if (!used[e.to] && e.cap > 0) {
int d = f(f, e.to, t, min(fl, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
};
int flow = 0;
while (1) {
used.assign(used.size(), false);
int f = dfs(dfs, s, t, INT_MAX);
if (f == 0) return flow;
flow += f;
}
}
};
int main() {
ll p, r, q;
cin >> p >> r >> q;
ll a1 = p + r;
ll a2 = r + q;
ll a3 = p + q;
cout << min(a1, min(a2, a3)) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define fastIO (cin.tie(0), cout.tie(0), ios::sync_with_stdio(false))
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define precise(i) fixed << setprecision(i)
using namespace std;
int main() {
fastIO;
int p, q, r;
cin >> p >> q >> r;
cout << (min(p + q, min(q + r, r + p)));
} | 1 |
#include <bits/stdc++.h>
#define ll long long
#define pi 3.14159265358979
#define mod 1000000007
#define rep(i,n) for(ll i=0;i<n;i++)
using namespace std;
int main(){
ll n,r,k;
cin>>n>>r;
if(n>=10){
k=0;
}else{
k=1000-100*n;
}
cout<<r+k;
} | #include <bits/stdc++.h>
#include <climits>
#include <sstream>
using namespace std;
int main(){
int K,T;
cin >> K >> T;
int A[T];
int mx = 0;
for(int i = 0;i < T;i++){
cin >> A[i];
mx = max(mx,A[i]);
}
cout << max(0,mx-1-(K-mx))<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
/* typedef */
typedef long long ll;
typedef pair<int, int> pii;
/* constant */
const int INF = 1 << 30;
const ll LINF = 1LL << 50;
const int NIL = -1;
const int MAX = 10000;
const int mod = 1000000007;
const double pi = 3.141592653589;
/* global variables */
/* function */
vector<int> factor(int x) {
vector<int> ret;
int y = x;
for (int i = 1; i * i <= y; i++) {
if (y % i == 0) {
ret.push_back(i);
if (i * i != y) ret.push_back(y / i);
}
}
return ret;
}
/* main */
int main(){
int N;
cin >> N;
vector<int> a(N+1);
for (int i = 1; i <= N; i++) cin >> a[i];
vector<int> cnt(N+1, 0);
vector<int> ball;
for (int i = N; i >= 1; i--) {
if ((cnt[i] % 2) == a[i]) continue;
ball.push_back(i);
vector<int> factors = factor(i);
for (int f : factors) cnt[f]++;
}
reverse(ball.begin(), ball.end());
int M = ball.size();
cout << M << '\n';
for (int i = 0; i < ball.size(); i++) {
if (i) cout << ' ';
cout << ball[i];
}
cout << '\n';
} | #include <bits/stdc++.h>
#include<algorithm>
#define int long long
using namespace std;
typedef pair<int,int> P;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define INF 1000000000000
int MOD=1000000007;
int modpow(int a,int x){
if(a<0)a+=MOD;
int ans=1;
while(x>0){
if(x&1) ans=ans*a%MOD;
a=a*a%MOD;
x>>=1;
}
return ans;
}
int gyaku(int n){
return modpow(n,MOD-2);
}
signed main() {
int n;
int ans=0;
cin>>n;
vector<int>a(n);
rep(i,n)cin>>a[i];
vector<int>ball(n);
for(int i=n-1;i>=0;i--){
int p=i+1;
int count=0;
while(p<=n){
if(ball[p-1])count++;
p+=i+1;
}
ball[i]=abs((count%2)-a[i]);
if(ball[i]) ans++;
}
cout<<ans<<endl;
rep(i,n){
if(ball[i])cout<<i+1<<endl;
}
}
| 1 |
#include<iostream>
#include<cmath>
#include<string>
#include<cctype>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int n;
scanf("%d",&n);
vector<int>ar(n);
for(auto&e:ar){
scanf("%d",&e);
}
for(int i=n-1;i>0;i--){
printf("%d ",ar[i]);
}
printf("%d\n",ar[0]);
return 0;
} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <cstring>
#include <climits>
#include <cmath>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<ll, int> ll_i;
typedef pair<double, int> d_i;
typedef pair<ll, ll> ll_ll;
typedef pair<double, double> d_d;
struct edge { int u, v; ll w; };
int MOD = 1000000007;
int main() {
int mini = INT_MAX, maxi = INT_MIN; ll sum = 0;
int n; cin >> n;
while (n--) {
int a; cin >> a;
mini = min(mini, a);
maxi = max(maxi, a);
sum += a;
}
cout << mini << ' ' << maxi << ' ' << sum << endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
char s[4]={};
cin>>s;
if(s[0]=='S'){
if(s[1]=='U'){
cout<<7<<endl;
}else{
cout<<1<<endl;
}
}else if(s[0]=='M'){
cout<<6<<endl;
}else if(s[0]=='W'){
cout<<4<<endl;
}else if(s[0]=='F'){
cout<<2<<endl;
}else if(s[0]=='T'){
if(s[1]=='U'){
cout<<5<<endl;
}else{
cout<<3<<endl;
}
}
} | #include<bits/stdc++.h>
using namespace std;
int main()
{ string s;
long long d,sum=0,num;
cin>>s;
long long n=s.size();
for(int i=0 ; i<n ; i++){
d = s[i] - '0';
num = num * 10 + d;
sum+=d;
}
if(num%(sum)==0) cout<< "Yes"<< endl;
if(num%(sum)!=0) cout<< "No"<< endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
int N,M,V,P;
cin>>N>>M>>V>>P;
vector<int> A(N);
for(int &i:A)cin>>i;
sort(A.rbegin(),A.rend());
int ok=0,ng=N;
while(ng-ok>1){
int n=(ok+ng)/2,m=0;
for(int i=0;i<N;i++){
if(i<P-1)m+=M;
else if(i>=n)m+=M;
else if(A[n]+M-A[i]>=0)m+=A[n]+M-A[i];
else{
ng=n;
goto home;
}
}
if(m>=M*V || n<P-1)ok=n;
else ng=n;
home:;
}
cout<<ok+1<<endl;
} | #include <bits/stdc++.h>
template <class T>
inline void read(T &res)
{
char ch; bool flag = false; res = 0;
while (ch = getchar(), !isdigit(ch) && ch != '-');
ch == '-' ? flag = true : res = ch ^ 48;
while (ch = getchar(), isdigit(ch))
res = res * 10 + ch - 48;
flag ? res = -res : 0;
}
template <class T>
inline void put(T x)
{
if (x > 9)
put(x / 10);
putchar(x % 10 + 48);
}
template <class T>
inline void CkMax(T &x, T y) {x < y ? x = y : 0;}
template <class T>
inline void CkMin(T &x, T y) {x > y ? x = y : 0;}
template <class T>
inline T Max(T x, T y) {return x > y ? x : y;}
template <class T>
inline T Min(T x, T y) {return x < y ? x : y;}
typedef long long ll;
const int N = 1e5 + 5;
int a[N], n, m, V, P, ans;
ll sum[N];
int main()
{
read(n); read(m); read(V); read(P);
for (int i = 1; i <= n; ++i)
read(a[i]);
std::sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i)
sum[i] = sum[i - 1] + a[i];
for (int i = 1; i <= n; ++i)
{
int l = std::upper_bound(a + 1, a + n + 1, a[i]) - a,
r = std::upper_bound(a + 1, a + n + 1, a[i] + m) - a - 1;
if (l - 2 + n - r >= V - 1)
{
if (n - r + 1 <= P)
++ans;
}
else
{
V -= l - 1 + n - r;
int tl = 0, tr = r - l + 1, res = -1;
while (tl <= tr)
{
int mid = tl + tr >> 1;
if (V <= mid || 1ll * (r - l + 1 - mid) * (a[i] + m) - (sum[r - mid] - sum[l - 1]) >= 1ll * (V - mid) * m)
res = mid, tr = mid - 1;
else
tl = mid + 1;
}
if (~res)
{
if (n - r + 1 + res <= P)
++ans;
}
V += l - 1 + n - r;
}
}
put(ans), putchar('\n');
return 0;
} | 1 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<map>
#include<set>
#include<queue>
#include<cstdio>
#include<climits>
#include<cmath>
#include<cstring>
#include<string>
#include<sstream>
#include<numeric>
#include<cassert>
#define f first
#define s second
#define mp make_pair
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define rep(i,s,n) for(int i=(s); i<(int)(n); i++)
#define FOR(i,c) for(__typeof((c).begin()) i=(c).begin(); i!=(c).end(); i++)
#define ALL(c) (c).begin(), (c).end()
#define IN(x,s,g) ((x) >= (s) && (x) < (g))
#define ISIN(x,y,w,h) (IN((x),0,(w)) && IN((y),0,(h)))
#define print(x) printf("%d\n",x)
using namespace std;
typedef unsigned int uint;
typedef long long ll;
const int _dx[] = {0,1,0,-1};
const int _dy[] = {-1,0,1,0};
int getInt(){
int ret = 0,c;
c = getchar();
while(!isdigit(c)) c = getchar();
while(isdigit(c)){
ret *= 10;
ret += c - '0';
c = getchar();
}
return ret;
}
int main(){
int n;
while(n = getInt()){
REP(i,n){
int pm = getInt();
int pe = getInt();
int pj = getInt();
int sum = pm + pe + pj;
if((pm == 100 || pe == 100 || pj == 100) ||
(pm + pe >= 180) || (sum >= 240)){
puts("A");
}else if((sum >= 210) ||
(sum >= 150 && (pm >= 80 || pe >= 80))){
puts("B");
}else{
puts("C");
}
}
}
return 0;
} | #include<iostream>
#include<vector>
using namespace std;
int main() {
int n, a, b, c;
vector<char>l;
while (true){
cin >> n;
if (n == 0){
break;
}
else{
for (int i = 0; i < n; i++){
cin >> a >> b >> c;
if (a == 100 || b == 100 || c == 100){
l.push_back('A');
}
else if (a + b >= 180){
l.push_back('A');
}
else if (a + b + c >= 240){
l.push_back('A');
}
else if (a + b + c >= 210){
l.push_back('B');
}
else if (a + b + c >= 150 && a >= 80){
l.push_back('B');
}
else if (a + b + c >= 150 && b >= 80){
l.push_back('B');
}
else l.push_back('C');
a = 0;
b = 0;
c = 0;
}
}
}
for (int i = 0; i != l.size(); i++)
{
cout << l[i] << endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int soredake(int point, int kazu, int bonasu, int goal) {
int tokukazu = goal / point;
if (goal % point > 0) {
tokukazu++;
}
if (tokukazu > kazu) {
tokukazu = kazu;
}
return tokukazu;
}
int search(vector<vector<int>> questions, int goal) {
int minimum = 0;
for (int i = 0; i < questions.size(); i++) {
minimum += questions.at(i).at(1);
}
for (int i = 0; i < questions.size(); i++) {
int point = questions.at(i).at(0);
int kazu = questions.at(i).at(1);
int bonasu = questions.at(i).at(2);
int goukei = questions.at(i).at(3);
vector<vector<int>> q = questions;
q.erase(q.begin() + i);
if (goukei < goal) {
int nokori = search(q, goal - goukei) + kazu;
if (nokori < minimum) {
minimum = nokori;
}
} else {
int nokori = soredake(point, kazu, bonasu, goal);
if (nokori < minimum) {
minimum = nokori;
}
}
}
return minimum;
}
int main() {
int d, g;
cin >> d >> g;
vector<vector<int>> questions(d, vector<int>(4));
for (int i = 0; i < d; i++) {
questions.at(i).at(0) = 100 * (i + 1);
cin >> questions.at(i).at(1);
cin >> questions.at(i).at(2);
questions.at(i).at(3) =
questions.at(i).at(0) * questions.at(i).at(1) + questions.at(i).at(2);
}
cout << search(questions, g) << endl;
}
| #include <bits/stdc++.h>
#include <string>
#include <vector>
#include <algorithm>
#define rep(i,w) for (int i = 0;i < (w); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int INF = 1e9;
int main(){
int d,g;cin >> d >> g;
vector<int> p(10),c(10);
rep(i,d) cin >> p[i] >> c[i];
int ind = 0;
int sum = 0;
int ans = INF;
int cnt = 0;
rep(i,1<<d){
sum = 0;
cnt = 0;
rep(j,d){
if(i>>j&1) {
sum += p[j]*(j+1)*100;
sum += c[j];
cnt += p[j];
}else ind = j;
}
if(g-sum > (p[ind]-1)*(ind+1)*100) continue;
cnt += max(g-sum + (ind+1)*100 -1,0)/((ind+1)*100);
ans = min(ans,cnt);
}
cout << ans << endl;
} | 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};
int main(){
int n;
cin >> n;
string ans = "AGC";
if (n<1200) ans = "ABC";
else if (n<2800) ans = "ARC";
cout << ans << endl;
return 0;
}
| /*
Author : Devil088
*/
#include<bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define sep cout<<"\n";
#define Yes cout<<"Yes\n";
#define No cout<<"No\n";
#define YES cout<<"YES\n";
#define NO cout<<"NO\n";
inline string shift(string s){
int n = s.length();
string r = "";
r+=s[n-1];
for(int i=0;i<n-1;i++)r+=s[i];
return r;
}
int main(){
int n;
cin>>n;
if(n<1200){
cout<<"ABC\n";
}else if(n<2800){
cout<<"ARC\n";
}else cout<<"AGC\n";
}
/*
uday
adyu
7 46
45 6
*/
| 1 |
#define rep(i, n) for (int i = 0; i < (n); i++)
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int MOD = 1000000007;
// MAX int 2,147,483,647 -> 10桁
// MAX ll 9,223,372,036,854,775,807 -> 19桁
// MAX O(n) 10^18 -> 18回
// double pi = M_PI or acos(-1)
// printf("%.10f\n", ans);
const int MAX = 1000000001;
int main() {
int n;
cin >> n;
map<ll, int> mp;
string ans = "YES";
rep(i, n) {
ll tmp;
cin >> tmp;
if(mp.count(tmp) == 0) {
mp[tmp] = 1;
} else {
ans = "NO";
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
map<int,int> a;
for(int i=0;i<n;i++){
int p;
cin>>p;
a[p]++;
}
bool ok=true;
for(auto x:a){
if(x.second>=2)ok=false;
}
if(ok){
cout<<"YES"<<endl;
}else{
cout<<"NO"<<endl;
}
return 0;
} | 1 |
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
typedef long long ll;
const int MAX=1e4+10;
const int mod=1e9+7;
void fun(int *cnt,int n){
for(int i=2;i<=n;i++){
while(n%i==0){
cnt[i]++;
n/=i;
}
}
}
ll solve(int n){
int cnt[1001]={0};
ll ans=1;
for(int i=2;i<=n;i++){
fun(cnt,i);
}
for(int i=2;i<=1000;i++){
ans=ans*(cnt[i]+1)%mod;
}
return ans;
}
int main(){
int n;
while(cin>>n){
cout<<solve(n)<<endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
long long n;
long long ans = 1;
cin >> n;
vector<int> fact(10000); //factor container
for(int j = 2; j<=n;j++){
long long num = j;
for (int i = 2; i <= num; i++) {
while (num%i == 0) { // 素数で割り切れなくなるまで割っていく
fact.at(i)++; //割った個数を配列に足す
num /= i;
}
}
}
for(int i = 0; i < 1003; i++){
ans *= (fact.at(i) + 1);
ans %= 1000000007;
}
cout << ans << endl;
} | 1 |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
#include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
#define repi(i,a,b) for(ll i=(a);i<(b);++i)
#define rep(i,a) repi(i,0,a)
#define repdi(i,a,b) for(ll i=(a)-1;i>=(b);--i)
#define repd(i,a) repdi(i,a,0)
#define itr(it,a) for( auto it = (a).begin(); it != (a).end(); ++it )
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define endl '\n'
#define debug(x) std::cerr << #x << " = " << (x) << endl;
using ll = long long;
using P = std::pair<ll, ll>;
constexpr ll INF = 1ll<<60;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<class S, class T>
std::ostream& operator<< ( std::ostream& out, const std::pair<S,T>& a )
{ std::cout << '(' << a.first << ", " << a.second << ')'; return out; }
template<class T>
std::ostream &operator<< ( std::ostream& out, const std::vector<T>& a )
{ std::cout << '['; rep( i, a.size() ){ std::cout << a[i]; if( i != a.size()-1 ) std::cout << ", "; } std::cout << ']'; return out; }
ll A, B;
int main() {
std::cin >> A >> B;
--A; --B;
std::cout << (B+A-1)/A << endl;
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <list>
#include <utility>
#include <tuple>
#include <cstdio>
#include <set>
#include <queue>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <cmath>
#define _GLIBCXX_DEBUG
using namespace std;
const long long INF = 1LL << 60;
int main() {
int A,B;
cin >> A >> B;
int ans;
if( B==1){
ans =0;
}
else{
for(int i=1;i>0;i++){
if((A-1)*(i-1)+A >= B){
ans = i;
break;
}
}
}
cout << ans << endl;
} | 1 |
#include<stdio.h>
#include<iostream>
#include<math.h>
#include<algorithm>
#include<string>
#define pi 3.14159
using namespace std;
int main() {
string str;
int i;
while(getline(cin, str)) {
for(i = 0; i < 26; i++) {
for(int j = 0; j < str.size(); j++) {
if(str[j] != ' ' && str[j] != '.') {
if(str[j] != 'a') {
str[j] -= 1;
} else str[j] = 'z';
}
}
for(int j = 0; j < str.size() - 4; j++) {
if(str[j] == 't' && str[j + 1] == 'h') {
cout << str <<endl;
i = 26;
break;
//if(str[j + 2] == 'e' ) {
//cout << str <<endl;
//i = 26;
//break;
//} else if(str[j + 2] == 'i' && str[j + 3] == 's'){
//cout << str <<endl;
//i = 26;
//break;
//} else if(str[j + 2] == 'a' && str[j + 3] == 't') {
//cout << str <<endl;
//i = 26;
//break;
//}
}
}
}
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
string sa;
while(getline(cin,sa)){
for(int j=0;j<26;j++){
int a=sa.size();
for(int i=0;i<a;i++){
if(sa[i]>='a'&&sa[i]<='z'){
sa[i]+=1;
if(sa[i]>'z'){
sa[i]-=26;
}
}
}
size_t z=sa.find("this");
size_t za=sa.find("that");
size_t zb=sa.find("the");
if(z!=string::npos){break;}
else if(za!=string::npos){break;}
else if(zb!=string::npos){break;}
}
cout<<sa<<endl;
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,t=0;
cin>>n;
int arr[2*n];
priority_queue<int,vector<int>,greater<int>> q;
for(int i=0;i<2*n;i++)
{
int k;
cin>>k;
q.push(k);
}
for(int i=0;i<n;i++)
{
int x=q.top();
q.pop();
int y=q.top();
q.pop();
t=t+min(x,y);
}
cout<<t;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A;
int B;
cin >> A >> B;
if (A > B) {
exit (1);
}
if (A < 9999 || B > 100000) {
exit (1);
}
int sum = 0;
for (int i = A ; i <= B ; i++) {
string k;
k = to_string (i);
int kl = (int)(k.length ());
string k1 = k.substr (0, (kl - 1)/2);
string k2 = k.substr ((kl - 1)/2 + 1, kl - 1);
string k3;
for (int j = (int)(k2.length ()) - 1 ; j > -1 ; j--) {
k3 += k2[j];
}
// cout << k1 << " : " << k2 << " : " << k3 << endl;
if (k1 == k3) {
sum += 1;
}
}
cout << sum << endl;
}
| 0 |
#include <iostream>
#include <vector>
#include <queue>
#include <bitset>
#include <algorithm>
#include <numeric>
using namespace std;
const int kInfinity = 0x3F3F3F3F;
const int kNil = -1;
const int kMaxV = 10010;
template <class T>
struct Edge {
using w_type = T;
Edge(int u, int v, w_type w): u(u), v(v), w(w) { }
int u, v;
w_type w;
bool operator<(const Edge<T> & rhs) const {
if (w != rhs.w) { return w < rhs.w; }
if (u != rhs.u) { return u < rhs.u; }
return v < rhs.v;
}
};
template <class Edge>
decltype(auto) Prim(vector<Edge> & edges,
typename vector<Edge>::size_type node_num,
typename vector<Edge>::size_type root) {
using size_type = typename vector<Edge>::size_type;
using const_it = typename vector<Edge>::const_iterator;
using w_type = typename Edge::w_type;
bitset<kMaxV> bs;
vector<vector<Edge>> adjacency(node_num, vector<Edge>());
for (const auto & e: edges) {
adjacency[e.u].push_back(e);
}
vector<w_type> key(node_num, kInfinity);
vector<int> parent(node_num, kNil);
key[root] = 0;
using Pair = pair<size_type, w_type>;
auto compare = [](const Pair & x, const Pair & y) {
return y.second < x.second || (!(x.second < y.second) && y.first < x.first);
};
priority_queue<Pair, vector<Pair>, decltype(compare)> que(compare);
que.emplace(root, 0);
while (!que.empty()) {
auto top_no = que.top().first;
auto top_key = que.top().second;
que.pop();
bs.set(top_no);
for (const auto & e: adjacency[top_no]) {
if (!bs.test(e.v) && e.w < key[e.v]) {
key[e.v] = e.w;
parent[e.v] = e.u;
que.emplace(e.v, e.w);
}
}
}
auto weight_sum = accumulate(key.begin(), key.end(), 0);
return weight_sum;
}
int main(int argc, char const *argv[]) {
vector<Edge<int>> edges;
unsigned V, E, r;
cin >> V >> E;
for (unsigned i = 0; i < E; ++i) {
unsigned u, v;
unsigned w;
cin >> u >> v >> w;
edges.emplace_back(u, v, w);
edges.emplace_back(v, u, w);
}
cout << Prim(edges, V, 0) << endl;
return 0;
} | //kruskal tree
#include <cstdio>
#include <algorithm>
using namespace std;
#define M 100000
int parent[M],a[M],b[M];
pair<int,int>node[M];
int root(int a){return parent[a]==a?a:parent[a]=root(parent[a]);}
int unite(int a,int b){
int x=root(a),y=root(b);
if(x==y)return 0;
parent[x]=y;
return 1;
}
int main(){
int i,s,n,m;
for(;scanf("%d%d",&n,&m)>1;printf("%d\n",s)){
for(i=0;i<m;i++)scanf("%d%d%d",a+i,b+i,&node[i].first),node[i].second=i;
sort(node,node+m);
for(i=0;i<n;i++)parent[i]=i;
for(s=i=0;i<m;i++)if(unite(a[node[i].second],b[node[i].second]))s+=node[i].first;
}
} | 1 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i=0; i<(int)(n); i++)
#define all(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
const ll MOD = 1000000007;
const ll INF = 10000000000000000;
vector<int> x4 = {0, 1, 0, -1}, x8 = {0, 1, 1, 1, 0, -1, -1, -1};
vector<int> y4 = {1, 0, -1, 0}, y8 = {1, 1, 0, -1, -1, -1, 0, 1};
template<class T> struct edge { int from, to; T cost;};
template<class T> inline bool chmin(T& a, T b){if (a>b){a = b; return true;}return false;}
template<class T> inline bool chmax(T& a, T b){if (a<b){a = b; return true;}return false;}
template<class T> inline T powerM(T a,T b){if (b==0) return 1;
T tmp = powerM(a,b/2); if (b%2==0) return tmp*tmp%MOD; else return tmp*tmp%MOD*a%MOD; }
template<class T> inline T power(T a,T b,T m){ if (b==0) return 1;
T tmp = power(a,b/2,m); if (b%2==0) return tmp*tmp%m; else return tmp*tmp%m*a%m; }
template<class T> inline T gcd(T a, T b){if (b==0) return a; return gcd(b, a%b);}
template<class T> inline T lcm(T a, T b){return a / gcd(a,b) * b;}
// ax+by=gcd(a,b)を解く
template<class T> inline T extgcd(T a,T b,T &x,T &y){if (b==0){x=1; y=0; return a;} T d=extgcd(b,a%b,y,x); y -= a/b*x; return d;}
/*
int N;
Graph G;
int main() {
cin >>N;
rep(i, N-1){
int a,b; cin >>a >>b; a--; b--;
G[a].push_back(b); G[b].push_back(a);
}
}
*/
int main() {
string s; cin >>s;
int n = s.size();
if (n == 2) cout <<s <<endl;
else{
reverse(all(s)); cout <<s <<endl;
}
} | /*
* @Author: wxyww
* @Date: 2020-03-31 09:07:10
* @Last Modified time: 2020-03-31 09:20:33
*/
#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<cmath>
#include<ctime>
#include<bitset>
#include<cstring>
#include<algorithm>
#include<string>
#include<queue>
#include<vector>
using namespace std;
typedef long long ll;
const int N = 300010,mod = 1e9 + 7;
ll read() {
ll x=0,f=1;char c=getchar();
while(c<'0'||c>'9') {
if(c=='-') f=-1;
c=getchar();
}
while(c>='0'&&c<='9') {
x=x*10+c-'0';
c=getchar();
}
return x*f;
}
char s[N];
int e[9][2],f[10][N];
void add(int &x,int y) {
(x = x + y) >= mod ? x -= mod : 0;
}
int main() {
e[1][0] = 2;e[1][1] = 5;
e[2][0] = 3;e[2][1] = 4;
e[3][0] = 2;e[3][1] = 2;
e[4][0] = 2;e[4][1] = 5;
e[5][0] = 7;e[5][1] = 6;
e[6][0] = 6;e[6][1] = 6;
e[7][0] = 8;e[7][1] = 5;
e[8][0] = 7;e[8][1] = 7;
scanf("%s",s + 1);
int n = strlen(s + 1);
f[1][0] = 1;
for(int i = 0;i < n;++i) {
for(int j = 1;j <= 8;++j) {
if(s[i + 1] == '1' || s[i + 1] == '?')
add(f[e[j][1]][i + 1],f[j][i]);
if(s[i + 1] == '0' || s[i + 1] == '?')
add(f[e[j][0]][i + 1],f[j][i]);
}
}
cout<<(f[6][n] + f[5][n]) % mod;
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
using P = pair<int, int>;
int main() {
int n, l;
cin >> n >> l;
int r = n + l - 1;
int eat;
if (r <= 0) eat = r;
else if (l >= 0) eat = l;
else eat = 0;
cout << (r + l) * (r- l + 1) / 2 - eat << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); i++)
using P = pair<int, int>;
using ll = long long;
const int INF = 1001001001;
int main() {
int n, l; cin >> n >> l;
int a[n];
int sum0 = 0;
rep(i, n){
a[i] = i+l;
sum0 += a[i];
}
int s = INF;
bool minus = false;
rep(i, n){
if(s > abs(a[i])){
if(a[i] < 0) minus = true;
else minus = false;
s = abs(a[i]);
}
s = min(s, abs(a[i]));
}
cout << (!minus? sum0-s: sum0+s) << endl;
return 0;
} | 1 |
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <cmath>
#include <queue>
#include <stack>
#include <cstdlib>
#include <map>
#include <iomanip>
#include <set>
#include <stdio.h>
#include <ctype.h>
using namespace std;
#define pie 3.141592653589793238462643383279
#define mod 1000000007
#define INF 1145141919364364
#define int long long
#define all(vec) vec.begin(),vec.end()
#define P pair<int,int>
#define S second
#define F first
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;
}
bool prime(int x) {
for (int i = 2; i <= sqrt(x); i++) {
if (x%i == 0)return false;
}
return true;
}
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 n, m, a[1000], b[1000];
vector<int> vec;
int cnt[1000010], cnt2[1000010];
int ans = 1;
signed main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
cnt[a[i]]++;
}
for (int i = 1; i <= n * m; i++) {
if (2 <= cnt[i]) {
cout << 0 << endl;
return 0;
}
}
for (int i = 1; i <= n * m; i++) {
cnt[i] += cnt[i - 1];
}
for (int j = 0; j < m; j++) {
cin >> b[j];
cnt2[b[j]]++;
}
for (int i = 1; i <= n * m; i++) {
if (2 < cnt2[i]) {
cout << 0 << endl;
return 0;
}
}
for (int i = 1; i <= n * m; i++) {
cnt2[i] += cnt2[i - 1];
}
for (int i = n * m; i >= 1; i--) {
if (cnt[i] - cnt[i - 1] && cnt2[i] - cnt2[i - 1])ans *= 1;
else if (cnt[i] - cnt[i - 1]) {
ans *= cnt2[n*m] - cnt2[i - 1];
ans %= mod;
}
else if (cnt2[i] - cnt2[i - 1]) {
ans *= cnt[n*m] - cnt[i - 1];
ans %= mod;
}
else {
ans *= (cnt[n*m] - cnt[i - 1])*(cnt2[n*m] - cnt2[i - 1]) - (n*m - i);
ans %= mod;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
using namespace std;
#define INF ((1<<30)-1)
#define LINF (1LL<<60)
#define EPS (1e-10)
typedef long long ll;
typedef pair<ll, ll> P;
const int MOD = 1000000007;
const int MOD2 = 998244353;
ll v[55];
int main(){
int n, k;
cin >> n >> k;
rep(i, n) cin >> v[i];
int m = min(n, k);
ll ans = 0;
rep(i, m+1){ // i個取り出す時を考える
rep(l, i+1){
vector<ll> tmp;
rep(j, l) tmp.push_back(v[j]);
int r = i - l;
// cout << l << " " << r << endl;
for(int j = n-1; j >= n - r; j--) tmp.push_back(v[j]);
// rep(j, tmp.size()) cout << tmp[j] << " ";
// cout << endl;
sort(tmp.begin(), tmp.end());
int res = k - (l+r);
ll s = 0;
rep(j, tmp.size()){
if (tmp[j] < 0 && res > 0){
res--;
}
else s += tmp[j];
}
ans = max(s, ans);
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include<iostream>
#include<cstring>
#include<cstdio>
#include<bitset>
#define MN 100
#define ull unsigned long long
#define F(a,b,c,d) ((a>b||c>d)?ans:f[num[a][b]][num2[c][d]])
#define N 65535
using namespace std;
inline int read()
{
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9')x=x*10+ch-'0',ch=getchar();
return x*f;
}
char st[MN+5][MN+5];
int f[5505][5505],num[MN+5][MN+5],num2[MN+5][MN+5],n,m,ans,cnt[1<<16],s[MN+5][MN+5];
inline void R(int&x,int y){y>x?x=y:0;}
/*struct Bitset
{
ull a,b;
Bitset(){a=b=0;}
Bitset(ull c,ull d):a(c),b(d){}
void Mod(int y){y>=64?(b|=1ULL<<y-64):(a|=1ULL<<y);}
Bitset operator & (const Bitset&c){return Bitset(a&c.a,b&c.b);}
int Count(){return cnt[a&N]+cnt[a>>16&N]+cnt[a>>32&N]+cnt[a>>48&N]
+cnt[b&N]+cnt[b>>16&N]+cnt[b>>32&N]+cnt[b>>48&N];}
Bitset operator << (int y){return y>=64?Bitset(0,a<<y-64):Bitset(a<<y,b<<y|(a>>64-y));}
};*/
bitset<105> lru[MN+5][MN+5],lrd[MN+5][MN+5],udl[MN+5][MN+5],udr[MN+5][MN+5],a[MN+5],b[MN+5];
inline int C(int u,int l,int d,int r){return s[d][r]-s[u-1][r]-s[d][l-1]+s[u-1][l-1];}
int main()
{
for(int i=1;i<=N;++i) cnt[i]=cnt[i>>1]+(i&1);
n=read();m=read();
for(int i=1,k=0;i<=n;++i)for(int j=i;j<=n;++j)num[i][j]=++k;
for(int i=1,k=0;i<=m;++i)for(int j=i;j<=m;++j)num2[i][j]=++k;
for(int i=1;i<=n;++i) scanf("%s",st[i]+1);
for(int i=1;i<=n;++i) for(int j=1;j<=m;++j)
{
if(st[i][j]=='o') a[i][j]=1,b[j][i]=1;
s[i][j]=s[i-1][j]+s[i][j-1]-s[i-1][j-1]+(st[i][j]=='E');
}
for(int i=1;i<=m;++i) for(int j=1;j<=n;++j)
for(int k=1;k<=i;++k)
{
if(C(1,k,n-j+1,m-(i-k))) lru[i][j][k]=1;
if(C(j,k,n,m-(i-k))) lrd[i][j][k]=1;
}
for(int i=1;i<=n;++i)for(int j=1;j<=m;++j)
for(int k=1;k<=i;++k)
{
if(C(k,1,n-(i-k),m-j+1)) udl[i][j][k]=1;
if(C(k,j,n-(i-k),m)) udr[i][j][k]=1;
}
for(int i=1;i<=n;++i) for(int j=n;j>=i;--j)
for(int k=1;k<=m;++k) for(int l=m;l>=k;--l)
{
int v=F(i,j,k,l);
R(F(i+1,j,k,l),v+(a[i]&(lru[l-k+1][j-i+1]<<k-1)).count());
R(F(i,j-1,k,l),v+(a[j]&(lrd[l-k+1][j-i+1]<<k-1)).count());
R(F(i,j,k+1,l),v+(b[k]&(udl[j-i+1][l-k+1]<<i-1)).count());
R(F(i,j,k,l-1),v+(b[l]&(udr[j-i+1][l-k+1]<<i-1)).count());
}
printf("%d\n",ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define dump(...) cout<<"# "<<#__VA_ARGS__<<'='<<(__VA_ARGS__)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define peri(i,a,b) for(int i=int(b);i-->int(a);)
#define rep(i,n) repi(i,0,n)
#define per(i,n) peri(i,0,n)
#define all(c) begin(c),end(c)
#define mp make_pair
#define mt make_tuple
using uint=unsigned;
using ll=long long;
using ull=unsigned long long;
using vi=vector<int>;
using vvi=vector<vi>;
using vl=vector<ll>;
using vvl=vector<vl>;
using vd=vector<double>;
using vvd=vector<vd>;
using vs=vector<string>;
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& p){
return os<<'('<<p.first<<','<<p.second<<')';
}
template<typename Tuple>
void print_tuple(ostream&,const Tuple&){}
template<typename Car,typename... Cdr,typename Tuple>
void print_tuple(ostream& os,const Tuple& t){
print_tuple<Cdr...>(os,t);
os<<(sizeof...(Cdr)?",":"")<<get<sizeof...(Cdr)>(t);
}
template<typename... Args>
ostream& operator<<(ostream& os,const tuple<Args...>& t){
print_tuple<Args...>(os<<'(',t);
return os<<')';
}
template<typename Ch,typename Tr,typename C>
basic_ostream<Ch,Tr>& operator<<(basic_ostream<Ch,Tr>& os,const C& c){
os<<'[';
for(auto i=begin(c);i!=end(c);++i)
os<<(i==begin(c)?"":" ")<<*i;
return os<<']';
}
constexpr int INF=1e9;
constexpr int MOD=1e9+7;
constexpr double EPS=1e-9;
int getsum(const vvi& sums,int t,int b,int l,int r)
{
if(l>=r || t>=b) return 0;
return sums[b][r]-sums[t][r]-sums[b][l]+sums[t][l];
}
void chmax(int& a,int b)
{
a=max(a,b);
}
int main()
{
for(int h,w;cin>>h>>w && h|w;){
vs grid(h);
rep(i,h) cin>>grid[i];
int ci=-1,cj=-1;
rep(i,h) rep(j,w) if(grid[i][j]=='E') ci=i,cj=j;
vvi sums(h+1,vi(w+1));
rep(i,h) rep(j,w)
sums[i+1][j+1]=(grid[i][j]=='o')+sums[i+1][j]+sums[i][j+1]-sums[i][j];
int T=h-1-ci,B=ci,L=w-1-cj,R=cj;
int dp[T+1][B+1][L+1][R+1]={};
rep(t,T+1) rep(b,B+1) rep(l,L+1) rep(r,R+1){
if(t!=T && ci+t+1<h-b)
chmax(dp[t+1][b][l][r],dp[t][b][l][r]+getsum(sums,ci+(t+1),ci+(t+1)+1,max(cj-r,l),min(cj+l+1,w-r)));
if(b!=B && t<=ci-(b+1))
chmax(dp[t][b+1][l][r],dp[t][b][l][r]+getsum(sums,ci-(b+1),ci-(b+1)+1,max(cj-r,l),min(cj+l+1,w-r)));
if(l!=L && cj+l+1<w-r)
chmax(dp[t][b][l+1][r],dp[t][b][l][r]+getsum(sums,max(ci-b,t),min(ci+t+1,h-b),cj+(l+1),cj+(l+1)+1));
if(r!=R && l<=cj-(r+1))
chmax(dp[t][b][l][r+1],dp[t][b][l][r]+getsum(sums,max(ci-b,t),min(ci+t+1,h-b),cj-(r+1),cj-(r+1)+1));
}
int res=0;
rep(t,T+1) rep(b,B+1) rep(l,L+1) rep(r,R+1) chmax(res,dp[t][b][l][r]);
cout<<res<<endl;
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
int required = 1,extended = a;
while(extended < b){
required++;
extended += a-1;
}
if(b == 1){
cout<<0;
}else{
cout<<required;
}
return 0;
} | #include <bits/stdc++.h>
typedef long long ll;
int const N = 1e6+5;
int const mod = 1e9+7;
using namespace std;
ll gcd(ll a, ll b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
ll counter=0;
void prime_fuct(ll x){
for (ll i = 2; i * i <= x; i++){
if(x%i==0){
while (x % i == 0){
x /= i;
}
counter++;
}
}
if(x != 1){
counter++;
}
cout<<counter+1;
}
void solve(){
ll a,b;
cin>>a>>b;
prime_fuct(gcd(a,b));
}
int main()
{
int t;
t=1;
while(t--)
{
solve();
}
return 0;
}
| 0 |
#include <iostream>
#include <numeric>
#include <math.h>
#include <algorithm>
#include <float.h>
#include <limits>
#include <vector>
#include <string.h>
#include <iomanip>
#define rep(i,a,n) for(ll int (i) = (a);(i) < (n);(i)++)
#define urep(i,a,n) for(ll int (i) = (a);(i) > (n);(i)--)
#define MOD 1000000007
#define INF 2147483647
#define ll long long
#define asort(a) sort(a.begin(),a.end());//昇順ソート
#define usort(a) sort(a.rbegin(),a.rend());//降順ソート
using namespace::std;
int jo(ll int a, ll int b){//累乗
ll int num=1;
rep(i,0,b) num=num*a;
return num;
}
char tobig(char s){//char大文字化
return (s-0x20);
}
char tolow(char s){//char小文字化
return (s+0x20);
}
int ctoi(char a){//char->int
if('0'<=a&&a<='9') return (a-'0');
return -1;
}
int gcd(ll int a,ll int b) {//最大公約数
if(a<b) return gcd(b,a);
int c;
while ((c=a%b)) {
a=b;
b=c;
}
return b;
}
int lcm(ll int a,ll int b){//最小公倍数
return (a*b)/gcd(a,b);
}
int main(){
int A,B; cin>>A>>B;
cout<<A-B+1;
}
// vector<vector<int>> 変数名(左の個数, vector<int>(右の個数));
//cout<<fixed<<setprecision(n); //小数点n桁まで表示
// vector<pair<int,int>> data(N); //2つのデータを格納、.first/.secondで参照
// pairのソートはfirst優先の昇順
| #pragma GCC optimize ("Ofast")
#include<bits/stdc++.h>
using namespace std;
inline void rd(int &x){
int k;
int m=0;
x=0;
for(;;){
k = getchar_unlocked();
if(k=='-'){
m=1;
break;
}
if('0'<=k&&k<='9'){
x=k-'0';
break;
}
}
for(;;){
k = getchar_unlocked();
if(k<'0'||k>'9'){
break;
}
x=x*10+k-'0';
}
if(m){
x=-x;
}
}
inline void wt_L(char a){
putchar_unlocked(a);
}
inline void wt_L(int x){
int s=0;
int m=0;
char f[10];
if(x<0){
m=1;
x=-x;
}
while(x){
f[s++]=x%10;
x/=10;
}
if(!s){
f[s++]=0;
}
if(m){
putchar_unlocked('-');
}
while(s--){
putchar_unlocked(f[s]+'0');
}
}
int main(){
int N;
int K;
rd(N);
rd(K);
wt_L(N-K+1);
wt_L('\n');
return 0;
}
// cLay varsion 20191123-1
// --- original code ---
// {
// int N, K;
// rd(N,K);
// wt(N-K+1);
// }
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
while(n != 0){
int a[12][12] ={};
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
cin >> a[i][j];
a[i][n] += a[i][j];
a[n][j] += a[i][j];
}
a[n][n] += a[i][n];
}
for(int i=0;i<=n;i++){
for(int j=0;j<=n;j++){
printf("%5d",a[i][j]);
}
printf("\n");
}
cin >> n;
}
return (0);
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
#define inf (int)(1e9+7)
#define abs(x) (x >= 0 ? x : -(x))
#define ceil(a, b) a / b + !!(a % b)
template<typename T1, typename T2> inline bool chmin(T1 &a, T2 b) { if (a > b) { a = b; return 1; } return 0; }
template<typename T1, typename T2> inline bool chmax(T1 &a, T2 b) { if (a < b) { a = b; return 1; } return 0; }
template<typename T> T gcd(T a, T b) { if (b == 0) return a; return gcd(b, a % b); }
int n;
vector<ll> a;
const int MAX_COL = 63;
const int MAX_ROW = 100005;
struct BitMatrix {
int H, W;
bitset<MAX_COL> val[MAX_ROW];
BitMatrix(int m = 1, int n = 1) : H(m), W(n) {}
inline bitset<MAX_COL>& operator [] (int i) { return val[i]; }
};
BitMatrix mat(100005, 61);
int GaussJordan(BitMatrix &A, bool is_extended = false) {
int rank = 0;
for (int col = 0; col < A.W; ++col) {
if (is_extended && col == A.W - 1) break;
int pivot = -1;
for (int row = rank; row < A.H; ++row) {
if (A[row][col]) {
pivot = row;
break;
}
}
if (pivot == -1) continue;
swap(A[pivot], A[rank]);
for (int row = 0; row < A.H; ++row) {
if (row != rank && A[row][col]) A[row] ^= A[rank];
}
++rank;
}
return rank;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout << bitset<61>(1008288677408720767) << endl;
cin >> n;
a.resize(n);
rep(i, n) cin >> a[i];
rep(i, n) rep(j, 61) {
if (a[i] & (1LL << j)) {
mat[i][60 - j] = 1;
} else mat[i][60 - j] = 0;
}
// rep(i, n) { rep(j, 60) cout << mat[i][j] << " "; cout << endl; }
// たてのbit数える
ll ans = 0;
rep(j, 61) {
int cnt = 0;
rep(i, n) {
// if (mat[i][j] & (1LL << (59 - j))) cnt++; // mat[i][j]は1, 0 -> 1LL << とかやばい
if (mat[i][j] == 1) cnt++;
}
// cout << j << " " << cnt << endl;
if (cnt % 2) {
ans += (1LL << (60 - j));
rep(i, n) mat[i][j] = 0;
}
}
// cout << "ans " << ans << endl;
// cout << endl; rep(i, n) { rep(j, 60) cout << mat[i][j] << " "; cout << endl; }
GaussJordan(mat);
// cout << endl; rep(i, n) { rep(j, 60) cout << mat[i][j] << " "; cout << endl; }
// int r = 0;
rep(j, 61) {
int cnt = 0;
rep(i, n) {
if (mat[i][j] == 1) cnt++;
/*
if (mat[i][j] == 1 && r == i) {
// cout << i << " " << j << " " << ans << endl;
ans += (2LL << (59 - j));
r++;
}
*/
}
if (cnt % 2) ans += (2LL << (60 - j));
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
#define xx first
#define yy second
#define mp make_pair
#define pb push_back
#define mset(x, y) memset(x, y, sizeof x)
#define mcpy(x, y) memcpy(x, y, sizeof x)
using namespace std;
typedef long long LL;
typedef pair <int, int> pii;
inline int Read()
{
int x = 0, f = 1, c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-')
f = -1;
for (; isdigit(c); c = getchar())
x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 100005;
int n, a[3][MAXN], c[MAXN];
bool b[MAXN], r[2], s[2];
inline void Ast(bool x)
{
if (!x)
puts("No"), exit(0);
}
inline void Modify(int x)
{
for (; x <= n; x += x & -x)
b[x] ^= 1;
}
inline bool Query(int x)
{
bool r = 0;
for (; x; x -= x & -x)
r ^= b[x];
return r;
}
int main()
{
#ifdef wxh010910
freopen("data.in", "r", stdin);
#endif
n = Read();
for (int i = 0; i < 3; i ++)
for (int j = 1; j <= n; j ++)
a[i][j] = Read();
for (int i = 1; i <= n; i ++)
if (a[0][i] > a[1][i])
{
Ast(a[2][i] % 3 == 1);
Ast(a[1][i] == a[2][i] + 1);
Ast(a[0][i] == a[1][i] + 1);
c[i] = a[2][i] / 3;
Ast((c[i] ^ i) & 1);
c[i] ++;
r[i & 1] ^= 1;
}
else
{
Ast(a[0][i] % 3 == 1);
Ast(a[1][i] == a[0][i] + 1);
Ast(a[2][i] == a[1][i] + 1);
c[i] = a[0][i] / 3;
Ast((c[i] ^ i) & 1);
c[i] ++;
}
for (int i = n - 1 + (n & 1); i > 0; i -= 2)
s[1] ^= Query(c[i]), Modify(c[i]);
mset(b, 0);
for (int i = n - (n & 1); i > 0; i -= 2)
s[0] ^= Query(c[i]), Modify(c[i]);
Ast(s[0] == r[1] && s[1] == r[0]);
return puts("Yes"), 0;
}
| #include<bits/stdc++.h>
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef double lf;
typedef long double llf;
typedef std::pair<int,int> pii;
#define xx first
#define yy second
template<typename T> inline T max(T a,T b){return a>b?a:b;}
template<typename T> inline T min(T a,T b){return a<b?a:b;}
template<typename T> inline T abs(T a){return a>0?a:-a;}
template<typename T> inline bool repr(T &a,T b){return a<b?a=b,1:0;}
template<typename T> inline bool repl(T &a,T b){return a>b?a=b,1:0;}
template<typename T> inline T gcd(T a,T b){T t;if(a<b){while(a){t=a;a=b%a;b=t;}return b;}else{while(b){t=b;b=a%b;a=t;}return a;}}
template<typename T> inline T sqr(T x){return x*x;}
#define mp(a,b) std::make_pair(a,b)
#define pb push_back
#define I inline
#define mset(a,b) memset(a,b,sizeof(a))
#define mcpy(a,b) memcpy(a,b,sizeof(a))
#define fo0(i,n) for(int i=0,i##end=n;i<i##end;i++)
#define fo1(i,n) for(int i=1,i##end=n;i<=i##end;i++)
#define fo(i,a,b) for(int i=a,i##end=b;i<=i##end;i++)
#define fd0(i,n) for(int i=(n)-1;~i;i--)
#define fd1(i,n) for(int i=n;i;i--)
#define fd(i,a,b) for(int i=a,i##end=b;i>=i##end;i--)
#define foe(i,x)for(__typeof((x).end())i=(x).begin();i!=(x).end();++i)
struct Cg{I char operator()(){return getchar();}};
struct Cp{I void operator()(char x){putchar(x);}};
#define OP operator
#define RT return *this;
#define RX x=0;char t=P();while((t<'0'||t>'9')&&t!='-')t=P();bool f=0;\
if(t=='-')t=P(),f=1;x=t-'0';for(t=P();t>='0'&&t<='9';t=P())x=x*10+t-'0'
#define RL if(t=='.'){lf u=0.1;for(t=P();t>='0'&&t<='9';t=P(),u*=0.1)x+=u*(t-'0');}if(f)x=-x
#define RU x=0;char t=P();while(t<'0'||t>'9')t=P();x=t-'0';for(t=P();t>='0'&&t<='9';t=P())x=x*10+t-'0'
#define TR *this,x;return x;
I bool IS(char x){return x==10||x==13||x==' ';}template<typename T>struct Fr{T P;I Fr&OP,(int&x)
{RX;if(f)x=-x;RT}I OP int(){int x;TR}I Fr&OP,(ll &x){RX;if(f)x=-x;RT}I OP ll(){ll x;TR}I Fr&OP,(char&x)
{for(x=P();IS(x);x=P());RT}I OP char(){char x;TR}I Fr&OP,(char*x){char t=P();for(;IS(t);t=P());if(~t){for(;!IS
(t)&&~t;t=P())*x++=t;}*x++=0;RT}I Fr&OP,(lf&x){RX;RL;RT}I OP lf(){lf x;TR}I Fr&OP,(llf&x){RX;RL;RT}I OP llf()
{llf x;TR}I Fr&OP,(uint&x){RU;RT}I OP uint(){uint x;TR}I Fr&OP,(ull&x){RU;RT}I OP ull(){ull x;TR}};Fr<Cg>in;
#define WI(S) if(x){if(x<0)P('-'),x=-x;char s[S],c=0;while(x)s[c++]=x%10+'0',x/=10;while(c--)P(s[c]);}else P('0')
#define WL if(y){lf t=0.5;for(int i=y;i--;)t*=0.1;if(x>=0)x+=t;else x-=t,P('-');*this,(ll)(abs(x));P('.');if(x<0)\
x=-x;while(y--){x*=10;x-=floor(x*0.1)*10;P(((int)x)%10+'0');}}else if(x>=0)*this,(ll)(x+0.5);else *this,(ll)(x-0.5);
#define WU(S) if(x){char s[S],c=0;while(x)s[c++]=x%10+'0',x/=10;while(c--)P(s[c]);}else P('0')
template<typename T>struct Fw{T P;I Fw&OP,(int x){WI(10);RT}I Fw&OP()(int x){WI(10);RT}I Fw&OP,(uint x){WU(10);RT}
I Fw&OP()(uint x){WU(10);RT}I Fw&OP,(ll x){WI(19);RT}I Fw&OP()(ll x){WI(19);RT}I Fw&OP,(ull x){WU(20);RT}I Fw&OP()
(ull x){WU(20);RT}I Fw&OP,(char x){P(x);RT}I Fw&OP()(char x){P(x);RT}I Fw&OP,(const char*x){while(*x)P(*x++);RT}
I Fw&OP()(const char*x){while(*x)P(*x++);RT}I Fw&OP()(lf x,int y){WL;RT}I Fw&OP()(llf x,int y){WL;RT}};Fw<Cp>out;
const int N=100007;
int n,t[N][3],s[N];
int main()
{
in,n;
fo0(l,3)fo1(i,n)in,t[i][l];
fo1(i,n)
{
int p=(t[i][0]-1)/3;
//out,p,'\n';
bool f1=1,f2=1;
fo0(j,3)f1&=t[i][j]==p*3+j+1;
fo0(j,3)f2&=t[i][j]==p*3+3-j;
if((!f1&&!f2)||(~(i^p)&1))return puts("No"),0;
s[i]=f1?p+1:-p-1;
}
//fo1(i,n)out,s[i],' ';out,'\n';
int a[2]={0,0},b[2]={0,0};
fo1(i,n)a[i&1]^=s[i]<0;
fo1(i,n)while(abs(s[i])!=i)std::swap(s[i],s[abs(s[i])]),b[i&1]^=1;
out,a[0]==b[1]&&a[1]==b[0]?"Yes":"No",'\n';
} | 1 |
#include<bits/stdc++.h>
#define rep(i,a) for(int (i)=0; (i)<(a); (i)++)
#define rrep(i,a) for(int (i)=a-1; (i)>=(0); (i)--)
#define rep2(i,a,b) for(int (i)=(a); (i)<(b); (i)++)
#define MOD 1000000007
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
typedef long long ll;
using namespace std;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n,u,v; cin >> n >> u >> v; u--; v--;
vector<vector<ll>> G(n);
rep(i,n-1){
ll a,b; cin >> a >> b;
a--; b--;
G[a].push_back(b); G[b].push_back(a);
}
queue<ll> q;
q.push(u);
vector<ll> d_u(n, 100000000);
d_u[u] = 0;
while(!q.empty()){
ll now = q.front(); q.pop();
for(ll next:G[now]){
if(d_u[next] != 100000000) continue;
d_u[next] = d_u[now] + 1;
q.push(next);
}
}
q.push(v);
vector<ll> d_v(n, 100000000);
d_v[v] = 0;;
while(!q.empty()){
ll now = q.front(); q.pop();
for(ll next:G[now]){
if(d_v[next] != 100000000) continue;
d_v[next] = d_v[now] + 1;
q.push(next);
}
}
ll ans = 0;
rep(i,n){
if(d_u[i] < d_v[i]) ans = max(ans,d_v[i]-1);
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair <ll,ll> P;
#define REP(i, n) for(ll i = 0LL; i < (ll)(n); i++)
#define REPR(i, n) for(ll i = n-1; i >= 0LL; i--)
#define FOR(i, n, m) for(ll i = n; i < (ll)(m); i++)
#define PRINT(x) cout << x << endl
#define ALL(v) v.begin(), v.end()
#define INF (ll)1e18
#define INFD 1e18
#define PI 3.14159265358979
#define MOD 1000000007
// #define MOD 998244353
#define VL vector<ll>
vector<ll> dx = {-1, 1, 0, 0, -1, -1, 1, 1};
vector<ll> dy = { 0, 0, 1, -1, -1, 1, -1, 1};
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; }
template< typename T >
struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template< typename T >
using Edges = vector< edge< T > >;
/*
WeightedGraph<ll> g(V);
g[a].emplace_back(b, c);
*/
template< typename T >
using WeightedGraph = vector< Edges< T > >;
using UnWeightedGraph = vector< vector< int > >;
template< typename T >
using Matrix = vector< vector< T > >;
template< typename T >
void dijkstra(WeightedGraph< T > &g, vector< T > &dist, vector< T > &prev, vector< T > &num, int s) {
T N = g.size();
dist.resize(N, INF);
prev.resize(N, -1); // 初期化
num.resize(N, 0);
using Pi = pair< T, int >;
priority_queue< Pi, vector< Pi >, greater< Pi > > que;
dist[s] = 0;
que.emplace(dist[s], s);
while(!que.empty()) {
T cost;
int idx;
tie(cost, idx) = que.top();
que.pop();
if(dist[idx] < cost) continue;
for(auto &e : g[idx]) {
auto next_cost = cost + e.cost;
if(dist[e.to] < next_cost) continue;
if (dist[e.to] == next_cost) {
num[e.to] += num[idx];
num[e.to] %= MOD;
continue;
}
dist[e.to] = next_cost;
prev[e.to] = idx; // 頂点 v を通って e.to にたどり着いた
num[e.to] = num[idx];
que.emplace(dist[e.to], e.to);
}
}
return;
}
/* get_path(prev, t)
入力：dijkstra で得た prev, ゴール t
出力： t への最短路のパス
*/
template< typename T >
vector<T> get_path(const vector<T> &prev, T t) {
vector<T> path;
for (T cur = t; cur != -1; cur = prev[cur]) {
path.push_back(cur);
}
reverse(path.begin(), path.end()); // 逆順なのでひっくり返す
return path;
}
int main()
{
ll N, u, v;
cin >> N >> u >> v;
u--; v--;
if (N == 2) {
PRINT(0);
return 0;
}
WeightedGraph<ll> G(N);
REP(i, N-1) {
ll a, b;
cin >> a >> b;
a--; b--;
G[a].emplace_back(b,1);
G[b].emplace_back(a,1);
}
vector<ll> dist1, prev1, num1;
dijkstra(G,dist1,prev1,num1,u);
vector<ll> dist2, prev2, num2;
dijkstra(G,dist2,prev2,num2,v);
// REP(i, N) cout << dist1[i] << " ";
// cout << endl;
// REP(i, N) cout << dist2[i] << " ";
// cout << endl;
ll ma = 0;
REP(i, N) {
if (dist1[i] < dist2[i]) {
ma = max(ma, dist2[i]);
}
}
PRINT(ma-1);
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define pii pair<int,int>
#define mp make_pair
#define fi first
#define se second
#define eb emplace_back
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 2e5 + 233;
char s[maxn];
int op[maxn];
int main()
{
int n;cin>>n;
scanf("%s",s+1);
if(s[1]=='W'){
puts("0");
return 0;
}
op[1] = 0;
int cur = 1;
ll ans = 1;
for(int i=2;i<=2*n;i++){
if(s[i]==s[i-1])op[i] = op[i-1]^1;
else op[i] = op[i-1];
if(op[i]==1){
ans = ans*cur%mod;
cur--;
}
else{
cur++;
}
// cout<<"!"<<i<<" "<<cur<<endl;
if(cur<0){
puts("0");
return 0;
}
}
// cout<<"!"<<cur<<endl;
if(cur){
puts("0");
return 0;
}
for(int i=1;i<=n;i++)ans = ans*i%mod;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define FOR(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define FORUL(i,l,u) for(int (i)=(int)(l);(i)<(int)(u);++(i))
#define FORULE(i,l,u) for(int (i)=(int)(l);(i)<=(int)(u);++(i))
#define FOREACH(it, X) for(__typeof((X).begin()) it = (X).begin(); it != (X).end(); it++)
#if defined(_MSC_VER) || __cplusplus > 199711L
#define AUTOVAR(newvar,v) auto newvar = (v)
#else
#define AUTOVAR(newvar,v) __typeof(newvar) r = (v)
#endif
#define PB(x) push_back(x)
#define MP(x,y) make_pair((x),(y))
#define MEMSET(m,v) memset(m,v,sizeof(m))
typedef long long ll;
typedef unsigned long long ull;
#define DEBUG 0
#if DEBUG
#define DOUT cout<<"["<<__LINE__<<"]:"
#else
#define DOUT 0 && cout
#endif
using namespace std;
#define MAX_N (1000*100)
#define MOD (ll(1E9+7))
int N;
string S;
int W,B;
ll kai[MAX_N+5];
ll kaijo(int n)
{
DOUT<<"---- kaijo("<<n<<") ----"<<endl;
if(kai[n]!=0) {
return kai[n];
}
ll i=n;
for(;i>=1; i--) {
if (kai[i]!=0) {
break;
}
}
ll ret = kai[i];
for(;i<n;i++) {
DOUT<<"(i+1)* kai[i]=="<<((i+1)* kai[i])<<endl;
kai[i+1] = ((i+1)* kai[i])%MOD;
}
return (kai[n])%MOD;
}
int main(int argc, char *argv[])
{
kai[0]=1;
kai[1]=1;
ios::sync_with_stdio(false);
cin >> N;
cin >> S;
FOR(n,2*N) {
DOUT << "S["<<n<<"]=="<<S[n]<<endl;
DOUT << "(2*N-n)%2=="<<(2*N-n)%2<<endl;
if((2*N-n)%2==0) {
if(S[n]=='B') { S[n]='W'; }
else if(S[n]=='W') { S[n]='B'; }
}
DOUT << "S["<<n<<"]=="<<S[n]<<endl;
}
W=0;
B=0;
FOR(n,2*N) {
DOUT << "S["<<n<<"]=="<<S[n]<<endl;
if(S[n]=='B') { B++; }
else if(S[n]=='W') { W++; }
}
if(B!=W) {
cout << 0 << endl;
return 0;
}
int count = 0;
ll ans = 1;
count = 0;
FOR(n,2*N) {
DOUT << "S["<<n<<"]=="<<S[n]<<", ans="<<ans<<", count=="<<count<<endl;
if(S[n]=='B') {
DOUT<<"ans*count="<<(ans*count)%MOD<<endl;
ans = ans*count%MOD;
count--;
}
else {
count++;
}
DOUT << "ans=="<<ans<<", count=="<<count<<endl;
}
cout << ans*kaijo(N)%MOD << endl;
DOUT << kaijo(1000*100) << endl;
return 0;
}
| 1 |
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <iomanip>
#include <queue>
#include <deque>
#include <map>
#include <unordered_map>
#define rep(i,n) for(int i=0;i<n;i++)
#define repn(i,n) for(int i=1;i<=n;i++)
#define repr(e,x) for(auto& e:x)
using namespace std;
typedef long long ll;
const ll MOD=1000000007;
ll N;
ll A[100000];
int main(){
cin>>N;
rep(i,N) cin>>A[i];
ll cnt0=3;
vector<ll> cnt(N,0);
ll ans=1;
rep(i,N){
if(A[i]==0){
ans*=cnt0;
cnt0--;
}else{
ans*=cnt[A[i]-1];
cnt[A[i]-1]--;
}
cnt[A[i]]++;
ans%=MOD;
}
ans+=MOD;
ans%=MOD;
cout<<ans<<endl;
} | #include <bits/stdc++.h>
using namespace std;
#define N 300100
const int mod=1e9+7;
int a[8][2],f[N][8];
char s[N];
int main()
{
a[0][0]=1; a[0][1]=2;
a[1][0]=3; a[1][1]=4;
a[2][0]=5; a[2][1]=6;
a[3][0]=a[3][1]=1;
a[4][0]=1; a[4][1]=2;
a[5][0]=7; a[5][1]=2;
a[6][0]=a[6][1]=6;
a[7][0]=a[7][1]=5;
scanf("%s",s);
int n=strlen(s);
f[n][2]=f[n][6]=1;
for (int i=n-1;i>=0;i--)
for (int j=0;j<8;j++)
{
if (s[i]!='1') (f[i][j]+=f[i+1][a[j][0]])%=mod;
if (s[i]!='0') (f[i][j]+=f[i+1][a[j][1]])%=mod;
}
printf("%d\n",f[0][0]);
return 0;
} | 0 |
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#endif
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
#ifdef DEBUG
#define eprintf(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#else
#define eprintf(...) ;
#endif
#define sz(x) ((int) (x).size())
#define TASK "text"
const int inf = (int) 1.01e9;
const long long infll = (long long) 1.01e18;
const ld eps = 1e-9;
const ld pi = acos((ld) -1);
#ifdef DEBUG
mt19937 mrand(300);
#else
mt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());
#endif
int rnd(int x) {
return mrand() % x;
}
void precalc() {
}
const int mod = (int) 1e9 + 7;
int mul(int a, int b) {
return (long long) a * b % mod;
}
void add(int &a, int b) {
a += b;
if (a >= mod) {
a -= mod;
}
}
const int maxn = (int) 3e5 + 5;
char tmp[maxn];
int n;
string s;
bool read() {
if (scanf("%s", tmp) < 1) {
return false;
}
s = tmp;
n = sz(s);
return true;
}
const int k = 9;
const int go[k][2] = {{1, 2}, {3, 4}, {5, 6}, {1, 1}, {1, 2}, {7, 2}, {8, 8}, {5, 5}, {6, 6}};
const int good = ((1 << 2) | (1 << 8));
int dp[k], ndp[k];
void solve() {
memset(dp, 0, sizeof(dp));
dp[0] = 1;
for (int i = 0; i < n; i++) {
memset(ndp, 0, sizeof(ndp));
for (int v = 0; v < k; v++) {
auto cur = dp[v];
if (!cur) {
continue;
}
for (int c = 0; c < 2; c++) {
if (s[i] == (char) ('0' + (c ^ 1))) {
continue;
}
add(ndp[go[v][c]], cur);
}
}
swap(dp, ndp);
}
int res = 0;
for (int v = 0; v < k; v++) {
if (good & (1 << v)) {
add(res, dp[v]);
}
}
printf("%d\n", res);
}
int main() {
precalc();
#ifdef DEBUG
assert(freopen(TASK ".in", "r", stdin));
assert(freopen(TASK ".out", "w", stdout));
#endif
while (read()) {
solve();
#ifdef DEBUG
eprintf("Time %.2f\n", (double) clock() / CLOCKS_PER_SEC);
#endif
}
return 0;
}
| #include<cstdio>
#include<algorithm>
#include<cstring>
#define ll long long
using namespace std;
const ll MOD=1e9+7;
int n;
ll f[300005][9];
char s[300005];
int main()
{
scanf("%s",s+1);
n=(int)strlen(s+1);
f[0][1]=1;
for(int i=1;i<=n;i++)
{
if(s[i]!='1')
{
f[i][2]+=f[i-1][1]+f[i-1][3]+f[i-1][4];
f[i][3]+=f[i-1][2];
f[i][6]+=f[i-1][5]+f[i-1][7];
f[i][7]+=f[i-1][6];
f[i][8]+=f[i-1][8];
}
if(s[i]!='0')
{
f[i][2]+=f[i-1][3];
f[i][4]+=f[i-1][2];
f[i][5]+=f[i-1][1]+f[i-1][4]+f[i-1][6];
f[i][6]+=f[i-1][7];
f[i][8]+=f[i-1][5]+f[i-1][8];
}
f[i][1]%=MOD;
f[i][2]%=MOD;
f[i][3]%=MOD;
f[i][4]%=MOD;
f[i][5]%=MOD;
f[i][6]%=MOD;
f[i][7]%=MOD;
f[i][8]%=MOD;
}
printf("%lld\n",(f[n][5]+f[n][8])%MOD);
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i, n) for(ll i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
const double PI=acos(-1);
template<typename T>
istream& operator>> (istream& is, vector<T> &vec){
for(T& x: vec) is >> x;
return is;
}
int main(){
ll n; cin >> n;
vector<ll> a(n); cin >> a;
vector<ll> b(n, 0);
ll m = 0;
for(ll i = n-1; i >= 0; --i){
if((i+1)*2 > n){
b[i] = a[i];
}else{
ll sum = 0;
for(ll j = i; j < n; j += (i+1)){
sum += b[j];
}
if(sum%2 == 0 && a[i] == 1) b[i] = 1;
if(sum%2 == 1 && a[i] == 0) b[i] = 1;
}
m += b[i];
}
cout << m << endl;
rep(i, n){
if(m == 0) continue;
if(i > 0 && b[i-1]) cout << " ";
if(b[i]) cout << i+1;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<vector<int>> Graph;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
#define pi 3.14159265359
#define inf 2147483647
#define INF 9223372036854775807
#define mod 1000000007
#define mod2 998244353
int main() {
int N; cin >> N;
vector<int> a(N + 1);
for(int i = 1; i <= N; i++) cin >> a[i];
set<int> b;
for(int i = N; i > 0; i--) {
int sum = 0;
for(int j = i + i; j <= N; j += i) {
if(b.count(j)) sum++;
}
if(sum % 2 != a[i]) b.insert(i);
}
int M = b.size();
int cnt = 0;
cout << M << endl;
for(auto p: b) {
cnt++;
if(cnt == b.size()) {
cout << p << endl;
return 0;
}
cout << p << " ";
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int saidai = 0;
int N;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++) {
cin >> s.at(i);
}
int M;
cin >> M;
vector<string> t(M);
for (int i = 0; i < M; i++) {
cin >> t.at(i);
}
for (int i = 0; i < N; i++) {
string a = s.at(i);
int c = 0;
for(int i = 0; i < N; i++) {
if (a == s.at(i)) {
c++;
}
}
for(int i = 0; i < M; i++) {
if (a == t.at(i)) {
c--;
}
}
if (saidai < c) {
saidai = c;
}
}
cout << saidai << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using P = pair<lint, lint>;
#define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++)
#define IFOR(i, begin, end) for(int i=(end)-1,i##_begin_=(begin);i>=i##_begin_;i--)
#define REP(i, n) FOR(i,0,n)
#define IREP(i, n) IFOR(i,0,n)
#define ALL(a) (a).begin(),(a).end()
constexpr int MOD = 1000000007;
constexpr int INF = 2147483647;
void yes(bool expr) {
cout << (expr ? "Yes" : "No") << "\n";
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int N, M;
cin >> N >> M;
vector<int> A(M);
REP(i, M) cin >> A[i];
vector<int> num = {0,2,5,5,4,5,6,3,7,6};
vector<string> dp(N+1, "x");
dp[0] = "";
FOR(i, 1, N+1) {
REP(j, M) {
if(i-num[A[j]] >= 0) {
if(dp[i-num[A[j]]] == "x") continue;
if(dp[i] == "x" || dp[i-num[A[j]]].size() >= dp[i].size()) {
dp[i] = dp[i-num[A[j]]] + (char)(A[j] + '0');
} else if(dp[i-num[A[j]]].size() + 1 == dp[i].size()) {
dp[i] = max(dp[i], dp[i-num[A[j]]] + (char)(A[j] + '0'));
}
}
}
//cout << dp[i] << endl;
}
cout << dp[N] << endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s;
int n,flag=0,result=0;
cin>>s;
for(long int i=s.size()-1;i>=0;i--){
n=s[i]-'0'+flag;
if(n<(10-n) || (n==5 && s[i-1]<'5')){
flag=0;
result+=n;
}
else{
flag=1;
result+=(10-n);
}
}
result+=flag;
cout<<result;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9 + 10;
const ll INFLL = 3e18;
int main(){
ios_base :: sync_with_stdio(false);
cin.tie(0);
int ans = 1;
int n;
cin >> n;
for(int i = 1 ; i*i <= n ; i ++)
ans = i*i;
cout << ans << "\n";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct node {
int key;
node *left, *right, *parent;
};
node *root, *NIL;
node* minimum(node *x) {
while( x ->left != NIL ) x = x->left;
return x;
}
node * successor( node *x ) {
if( x->right != NIL ) return minimum(x->right);
node *y = x->parent;
while( y != NIL && x == y->right ) {
x = y;
y = y->parent;
}
return y;
}
void delete_node( node* z ) {
node *y, *x;
if( z->left == NIL || z->right == NIL ) y = z;
else y = successor(z);
if( y ->left != NIL ) x = y->left;
else x = y->right;
if( x != NIL ) x->parent = y ->parent;
if( y->parent == NIL ) root = x;
else
if(y == y->parent->left) {
y->parent->left = x;
} else {
y->parent->right = x;
}
if( y != z ) z->key = y->key;
}
void insert(int k) {
node *y = NIL;
node *x = root;
node *z;
z = (node *)malloc(sizeof(node));
z->key = k;
z->left = NIL;
z->right = NIL;
while( x != NIL ) {
y = x;
if( z->key < x->key ) x = x->left;
else x = x->right;
}
z->parent = y;
if( y == NIL ) root = z;
else {
if( z->key < y->key ) y->left = z;
else y ->right = z;
}
}
node* find(node *x, int key) {
while( x != NIL && key != x->key) {
if( key < x->key) {
x = x->left;
} else {
x = x->right;
}
}
return x;
}
void preParse(node* u) {
if(u == NIL) return;
printf(" %d", u->key);
preParse(u->left);
preParse(u->right);
}
void inParse(node* u) {
if(u == NIL) return;
inParse(u->left);
printf(" %d", u->key);
inParse(u->right);
}
signed main() {
ll n; scanf("%lld", &n);
string com;
for( ll i = 0; i < n; i++ ) {
cin >> com;
if( com.at(0) == 'i') {
int x;
scanf("%d", &x);
insert(x);
} else if( com.at(0) == 'f' ) {
int x;
scanf("%d", &x);
node* t = find(root, x);
if( t != NIL ) printf("yes\n");
else printf("no\n");
} else if( com.at(0) == 'd' ) {
int x; scanf("%d", &x);
delete_node(find(root, x));
} else {
inParse(root);
putchar('\n');
preParse(root);
putchar('\n');
}
}
return 0;
}
| #include <iostream>
#include <string>
using namespace std;
int main()
{
string tmp;
int n;
cin>>n;
for (int i=0; i<n; i++) {
getline(cin,tmp);
while (tmp=="") getline(cin,tmp);
while (tmp.find("Hoshino")!=string::npos) {
tmp.replace(tmp.find("Hoshino"),7,"Hoshina");
}
cout<<tmp<<endl;
}
} | 0 |
#include<bits/stdc++.h>
#define ll long long int
#define vec vector<ll>
#define mat vector<vector<ll>>
using namespace std;
const ll mod=1000000007;
const ll inf=LONG_LONG_MAX;
ll dx4[4]={1,0,-1,0};
ll dy4[4]={0,-1,0,1};
ll dx8[8]={1,0,-1,1,-1,1,0,-1};
ll dy8[8]={1,1,1,0,0,-1,-1,-1};
int main(){
ll n;
cin >> n;
ll a=0;
while(3*a<=n){
a++;
}
cout << a-1 << endl;
} | #include<iostream>
using namespace std;
int main(){
int a;
cin>>a;
cout<<a/3;
return 0;
}
| 1 |
#include <string>
#include <queue>
#include <stack>
#include <vector>
#include <sstream>
#include <algorithm>
#include <deque>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <list>
#include <cstdio>
#include <iostream>
#include <cmath>
#include <climits>
#include <bitset>
#include <functional>
#include <numeric>
#include <ctime>
#include <cassert>
#include <cstring>
#include <fstream>
#include <iomanip>
using namespace std;
#define FOR(i, a, b) for(int (i)=(a);(i)<(b);(i)++)
#define IFOR(i, a, b) for(int (i)=(a);(i)<=(b);(i)++)
#define RFOR(i, a, b) for(int (i)=(a);(i)>=(b);(i)--)
#define REP(i, n) FOR((i), 0, (n))
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
int main() {
int h, w, n;
cin >> h >> w >> n;
int m = max(h, w);
cout << (n + m - 1) / m << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define sz(x) (int)(x.size())
#define FOR(x,y,z) for(int x = y; x <= z; x++)
#define int long long
const int N = 1e5 + 2, inf = 1e18;
int32_t main(){
ios::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
int n, m;
cin >> n >> m;
if(n > m)
swap(n, m);
int k;
cin >> k;
int ans = 0;
while(k > 0){
k -= m;
ans++;
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
#define FASTIO ios::sync_with_stdio(false);cin.tie(0);
#define ADD +
#define SUBTRACT -
#define MULTIPLY *
#define DIVIDE /
#define MOD %
#define INCREMENT(x) ++x
#define DECREMENT(x) --x
#define in(a,b) cin>>a>>b;
#define out(a,b) cout<<a<<endl<<b<<endl;
#define scan(a) scanf("%d",&a);
#define print(a) printf("%d\n",a);
#define scanii(a,b) scanf("%d %d",&a,&b);
#define printii(a,b) printf("%d\n%d\n",a,b);
#define scaniii(a,b,c) scanf("%d %d %d",&a,&b,&c);
#define pub push_back
#define pob pop_back
#define puf push_front
#define pof pop_front
#define ll long long
#define ull unsigned long long
#define sll signed long long
#define f1(i,a) for(int i=0;i<a;++i)
#define f2(i,a) for(int i=a-1;i>=0;--i)
#define pi acos(-1)
#define mod 1000000007
#define TRUE 1
#define FALSE 0
#define ZERO 0
#define MP make_pair
#define F first
#define S second
#define END puts("");
#define elif else if
typedef ll int lli;
typedef sll int slli;
typedef ull int ulli;
const int sz=10000;
using namespace std;
int clue();
int result();
void show();
bool check();
int main() {
clue();
return 0;
}
int clue() {
//O(n^3) solution
int n;
cin>>n;
lli a[n];
f1(i,n) {
cin>>a[i];
}
lli count=0;
lli p,q,r;
f1(i,n-2) {
for(int j=i+1;j<n-1;++j) {
for(int k=j+1;k<n;++k) {
if(a[i]!=a[j]&&a[j]!=a[k]&&a[i]!=a[k]) {
p=a[i]+a[j];
q=a[j]+a[k];
r=a[k]+a[i];
if(p>a[k]&&q>a[i]&&r>a[j]) {
++count;
}
}
}
}
}
cout<<count<<endl;
return 0;
} | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <time.h>
#include <math.h>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>
#include <sstream>
#include <stack>
#include <string>
#include <bitset>
using namespace std;
#define FOR(I,F,N) for(int I = F; I < (int)(N); I++)
#define rep(i, n) FOR(i, 0, n)
#define FIN(V) cout<<V<<endl
#define pb push_back
#define INF (1 << 28)
template<typename T>
void remove(vector<T>& vector, unsigned int index){
vector.erase(vector.begin() + index);
}
vector<string> split(const string &s, char c);
typedef pair<int, int> P;
typedef long long ll;
typedef priority_queue<int> pq;
int StrToInt(string);
string IntToStr(int);
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int n, q, cnt = 0;
void search(int num, int memo[10001]){
rep(i,n){
if(memo[i]==num){
cnt++;
break;
}
}
}
int main(void){
int memo[10001];
fill_n(memo, 10001, 0);
cin >> n;
rep(i,n)cin >> memo[i];
cin >> q;
rep(i,q){
int a;
cin >> a;
search(a,memo);
}
cout << cnt << endl;
return 0;
}
int StrToInt(string s){
stringstream ss;
ss << s;
int val;
ss >> val;
return val;
}
string IntToStr(int i){
stringstream ss;
ss << i;
return ss.str();
}
vector<string> split(const string &s, char delim) {
vector<string> elems;
string item;
for (int i = 0; i < s.size(); i++) {
char ch = s[i];
if (ch == delim) {
if (!item.empty())
elems.push_back(item);
item.clear();
}
else {
item += ch;
}
}
if (!item.empty())
elems.push_back(item);
return elems;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);++i)
#define rrep(i,n) for(int i=1;i<(n);++i)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define maxs(a, b) a = max(a, b)
#define mins(a, b) a = min(a, b)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll linf = (1ll << 61);
const int inf = 1001001001;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string s;
if (n == 0) s = '0';
while (n != 0) {
if (n % 2 != 0) {
n--;
s = '1' + s;
}
else s = '0' + s;
n /= -2;
}
cout << s << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define ull unsigned long long
#define ld long double
#define vi vector<int>
#define vll vector<ll>
#define vc vector<char>
#define vs vector<string>
#define vpii vector<pii>
#define vpll vector<pll>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define repr(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rep1r(i, n) for (int i = ((int)(n)); i >= 1; i--)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define RSORT(x) sort(rall(x));
#define pb push_back
#define mp make_pair
#define INF (1e9)
#define PI (acos(-1))
#define EPS (1e-7)
ull gcd(ull a, ull b) { return b ? gcd(b, a % b) : a; }
ull lcm(ull a, ull b) { return a / gcd(a, b) * b; }
int main(){
string s;
cin >> s;
vi cnt(26);
int n = sz(s);
rep(i, n) cnt[s[i]-'a']++;
rep(i, 26) {
if (cnt[i] == 0) {
cout << (char)(i+'a') << endl;
return 0;
}
}
cout << "None" << endl;
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
#include <vector>
/*int main(int argc, char **argv)
{
int a, b, c, d, e;
std::cin >> a >> b >> c >> d >> e;
std::cout << std::min(a, std::min(b, c)) + std::min(d, e) - 50 << std::endl;
return 0;
}*/
/*int main()
{
int l, a, b, c, d;
std::cin >> l >> a >> b >> c >> d;
int japa, math;
japa = a / c;
if(a % c != 0){
japa++;
}
math = b / d;
if(b % d != 0){
math++;
}
std::cout << l - std::max(japa, math) << std::endl;
}*/
/*int main()
{
bool sub[31];
int input;
for(int i = 0; i < 31; i++){
sub[i] = false;
}
for(int i = 0; i < 28; i++){
std::cin >> input;
sub[input] = true;
}
for(int i = 1; i < 31; i++){
if(!sub[i]) std::cout << i << std::endl;
}
}*/
int main()
{
std::vector<int> w, k;
int input;
for(int i = 0; i < 10; i++){
std::cin >> input;
w.push_back(input);
}
for(int i = 0; i < 10; i++){
std::cin >> input;
k.push_back(input);
}
std::sort(w.begin(),w.end(),std::greater<int>());
std::sort(k.begin(),k.end(),std::greater<int>());
std::cout << w[0] + w[1] + w[2] << " " << k[0] + k[1] + k[2] << std::endl;
} | #include <cstdio>
#include <functional>
#include <algorithm>
using namespace std;
int p[10];
int main(){
for(int i = 0; i < 2; i++){
int ans = 0;
for(int j = 0; j < 10; j++) scanf("%d", &p[j]);
sort(p,p+10,greater<int>());
for(int j = 0; j < 3; j++) ans += p[j];
if(i == 0) printf("%d", ans);
else printf(" %d\n", ans);
}
} | 1 |
#include <stdio.h>
int main(){
while(1){
int n,m,a[21][21],px=10,py=10;
scanf("%d",&n);
if(n==0) return 0;
for(int i=0;i<21;i++) for(int j=0;j<21;j++) a[i][j]=0;
for(int i=0;i<n;i++){
int x,y;
scanf("%d %d",&x,&y);
a[x][y]=1;
}
scanf("%d",&m);
for(int i=0;i<m;i++){
char d;
int l;
scanf(" %c %d",&d,&l);
for(int j=0;j<l;j++){
if(d=='N') py++;
if(d=='E') px++;
if(d=='S') py--;
if(d=='W') px--;
if(a[px][py]) n--;
a[px][py]=0;
}
}
if(n==0) printf("Yes\n");
else printf("No\n");
}
} | /*+lmake
* STD = c++14
* DEFINE += WAAUTOMATON
*/
#include <bits/stdc++.h>
using namespace std;
using LL=long long;
using ULL=unsigned long long;
#ifdef WAAUTOMATON
#define debug(args...) {dbg,args; cerr<<endl;}
#else
#define debug(args...) // Just strip off all debug tokens
#endif
struct debugger
{
template<typename T> debugger& operator , (const T& v)
{
cerr<<v<<" ";
return *this;
}
} dbg;
#define MAXN 100000
int c[MAXN+10];
bool b[MAXN+10];
void solve(long long N, vector<vector<long long>> a){
int r[2]={0,0},f[2]={0,0};
for(int i=0; i<N; ++i) {
c[i]=a[1][i]/3+1;
if (c[i]%2==i%2) throw 2;
if (a[0][i]==c[i]*3-2 && a[1][i]==c[i]*3-1 && a[2][i]==c[i]*3) {
} else if (a[0][i]==c[i]*3 && a[1][i]==c[i]*3-1 && a[2][i]==c[i]*3-2) {
r[(i+1)&1]^=1;
} else {
throw 1;
}
}
memset(b,true,sizeof(b));
for(int i=1; i<=N; ++i) {
if (b[i]) {
int x=c[i-1];
while(x!=i) {
debug(x);
b[x]=false;
f[i&1]^=1;
x=c[x-1];
}
}
}
debug(f[0],f[1]);
debug(r[0],r[1]);
if (f[0]!=r[1] || f[1]!=r[0]) throw 3;
puts("Yes");
}
int main(){
#ifdef WAAUTOMATON
freopen("in.txt","r",stdin);
#endif
long long N;
scanf("%lld",&N);
vector<vector<long long>> a(3-1+1,vector<long long>(N-1+1));
for(int i = 0 ; i <= 3-1 ; i++){
for(int j = 0 ; j <= N-1 ; j++){
scanf("%lld",&a[i][j]);
}
}
try {
solve(N, a);
} catch(int err) {
puts("No");
debug(err);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef tuple<int, int> duo;
#define TT template<typename T>
#define TTF template<typename T, typename F>
#define ET(T) typename T::value_type
TT inline T sq(T x){return x*x;}
TT inline T In(){T x;cin>>x;return x;}
TT inline void Out(T&x){cout<<x;}
TT inline void sort(T&v){sort(begin(v),end(v));}
TT inline void revs(T&v){reverse(begin(v),end(v));}
TT inline void uniq(T&v){sort(v);v.erase(unique(begin(v),end(v)),end(v));}
TT inline int ubnd(T&v,ET(T)&x){return upper_bound(begin(v),end(v),x)-begin(v);}
TT inline int lbnd(T&v,ET(T)&x){return lower_bound(begin(v),end(v),x)-begin(v);}
TTF inline void inpt(T&v,int n,F f){for(v.reserve(n);n--;v.emplace_back(f()));}
TTF inline void show(T&v,F f,string d=" ",string e="\n"){int i=0;for(auto&x:v)i++&&(cout<<d),f(x);cout<<e;}
#undef TT
#undef TTF
#undef ET
inline void fast_io(){ios::sync_with_stdio(0);cin.tie(0);}
inline int in(){int x;scanf("%d",&x);return x;}
inline ll pow_mod(ll a,ll k,ll m){ll r=1;for(;k>0;a=a*a%m,k>>=1)if(k&1)r=r*a%m;return r;}
inline ll mod_inv(ll a,ll p){return pow_mod(a,p-2,p);}
const int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
const int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
const int Mod = 1000000000;
struct Edge {
int f, t, c;
Edge(int f, int t, int c) : f(f), t(t), c(c) {}
bool operator<(const Edge& e) const { return c != e.c ? c > e.c : (f != e.f ? f < e.f : t < e.t); }
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
int dijkstra(const Graph& g, int s, int t){
int vis[128];
fill(begin(vis), end(vis), 0);
priority_queue<Edge> pq;
for (pq.push(Edge(-2, s, 0)); !pq.empty(); pq.pop()){
Edge e = pq.top();
if (vis[e.t]++) continue;
if (e.t == t) return e.c;
for (const auto& ee : g[e.t]){
pq.push(Edge(e.f, ee.t, e.c + ee.c));
}
}
return -1;
}
int main()
{
int n, k;
while (cin >> n >> k, n || k){
Graph g(n + 1);
for (int i = 0; i < k; i++){
int t = in();
if (t){
int a, b, c;
cin >> a >> b >> c;
g[a].push_back(Edge(a, b, c));
g[b].push_back(Edge(b, a, c));
}
else {
int a, b;
cin >> a >> b;
cout << dijkstra(g, a, b) << endl;
}
}
}
return (0);
}
// priority_queue queue deque front stringstream max_element min_element insert count make_tuple | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.size()
#define inf (int)(1e9+7)
#define abs(x) (x >= 0 ? x : -(x))
template<typename T1, typename T2> inline bool chmin(T1 &a, T2 b) { if (a > b) { a = b; return 1; } return 0; }
template<typename T1, typename T2> inline void chmax(T1 &a, T2 b) { if (a < b) a = b; }
template<typename T> inline T gcd(T a, T b) { if (b == 0) return a; return gcd(b, a % b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
while (cin >> n && n) {
cin >> k;
int dist[105][105];
fill_n(*dist, 105 * 105, inf);
rep(i, 105) dist[i][i] = 0;
while (k--) {
int q;
cin >> q;
if (q == 0) {
int a, b;
cin >> a >> b;
a--; b--;
if (dist[a][b] != inf) cout << dist[a][b] << endl;
else cout << -1 << endl;
} else {
int c, d, e;
cin >> c >> d >> e;
c--; d--;
chmin(dist[c][d], e);
chmin(dist[d][c], e);
rep(k, n) rep(i, n) rep(j, n) {
if (dist[i][k] + dist[k][j] < dist[i][j]) dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
}
}
| 1 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=300+10;
const int MOD=998244353;
int n,a[N],dp[N][N*N],sum;
signed main()
{
cin>>n;
for (int i=1;i<=n;i++) scanf("%lld",&a[i]),sum+=a[i];
dp[0][0]=1;
for (int i=1;i<=n;i++)
for (int j=0;j<=sum;j++) {
dp[i][j]=dp[i-1][j];
if (j>=a[i]) dp[i][j]=(dp[i][j]+dp[i-1][j-a[i]]*2)%MOD;
}
int ans=0;
for (int i=0;i<=sum/2;i++) ans=(ans+dp[n][i])%MOD;
if (sum%2==0) {
memset(dp,0,sizeof(dp)); dp[0][0]=1;
for (int i=1;i<=n;i++)
for (int j=0;j<=sum;j++) {
dp[i][j]=dp[i-1][j];
if (j>=a[i]) dp[i][j]=(dp[i][j]+dp[i-1][j-a[i]])%MOD;
}
ans=((ans-dp[n][sum/2])%MOD+MOD)%MOD;
}
ans=(ans*3)%MOD;
int tmp=1;
for (int i=1;i<=n;i++) tmp=(tmp*3)%MOD;
cout<<((tmp-ans)%MOD+MOD)%MOD<<endl;
return 0;
} | #include <bits/stdc++.h>
#define debug(...) fprintf(stderr, __VA_ARGS__)
#ifndef AT_HOME
#define getchar() IO::myGetchar()
#define putchar(x) IO::myPutchar(x)
#endif
namespace IO {
static const int IN_BUF = 1 << 23, OUT_BUF = 1 << 23;
inline char myGetchar() {
static char buf[IN_BUF], *ps = buf, *pt = buf;
if (ps == pt) {
ps = buf, pt = buf + fread(buf, 1, IN_BUF, stdin);
}
return ps == pt ? EOF : *ps++;
}
template<typename T>
inline bool read(T &x) {
bool op = 0;
char ch = getchar();
x = 0;
for (; !isdigit(ch) && ch != EOF; ch = getchar()) {
op ^= (ch == '-');
}
if (ch == EOF) {
return false;
}
for (; isdigit(ch); ch = getchar()) {
x = x * 10 + (ch ^ '0');
}
if (op) {
x = -x;
}
return true;
}
inline int readStr(char *s) {
int n = 0;
char ch = getchar();
for (; isspace(ch) && ch != EOF; ch = getchar())
;
for (; !isspace(ch) && ch != EOF; ch = getchar()) {
s[n++] = ch;
}
s[n] = '\0';
return n;
}
inline void myPutchar(char x) {
static char pbuf[OUT_BUF], *pp = pbuf;
struct _flusher {
~_flusher() {
fwrite(pbuf, 1, pp - pbuf, stdout);
}
};
static _flusher outputFlusher;
if (pp == pbuf + OUT_BUF) {
fwrite(pbuf, 1, OUT_BUF, stdout);
pp = pbuf;
}
*pp++ = x;
}
template<typename T>
inline void print_(T x) {
if (x == 0) {
putchar('0');
return;
}
static int num[40];
if (x < 0) {
putchar('-');
x = -x;
}
for (*num = 0; x; x /= 10) {
num[++*num] = x % 10;
}
while (*num){
putchar(num[*num] ^ '0');
--*num;
}
}
template<typename T>
inline void print(T x, char ch = '\n') {
print_(x);
putchar(ch);
}
inline void printStr_(const char *s, int n = -1) {
if (n == -1) {
n = strlen(s);
}
for (int i = 0; i < n; ++i) {
putchar(s[i]);
}
}
inline void printStr(const char *s, int n = -1, char ch = '\n') {
printStr_(s, n);
putchar(ch);
}
}
using namespace IO;
const int N = 305, P = 998244353;
int n, a[N], S, f[N * N];
int main() {
read(n);
int ans = 1;
for (int i = 1; i <= n; ++i) {
read(a[i]);
ans = 3ll * ans % P;
S += a[i];
}
f[0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = S; j >= a[i]; --j) {
f[j] = (2ll * f[j] + f[j - a[i]]) % P;
}
for (int j = a[i] - 1; ~j; --j) {
f[j] = 2ll * f[j] % P;
}
}
for (int i = (S + 1) / 2; i <= S; ++i) {
ans = (ans + 3ll * (P - f[i])) % P;
}
if (!(S & 1)) {
for (int i = 0; i <= S; ++i) {
f[i] = 0;
}
f[0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = S; j >= a[i]; --j) {
f[j] = (f[j] + f[j - a[i]]) % P;
}
}
ans = (ans + 3ll * f[S / 2]) % P;
}
print(ans);
}
| 1 |
#include <iostream>
//#include <vector>
#include <string>
//#include <algorithm>
//#include <math.h>
//#include <queue>
//#include <stack>
//#include <iomanip>
// sometimes used
//#include <set>
//#include <map>
//#include <numeric>
//#include <list>
//#include <deque>
//#include <unordered_map>
typedef long long LL;
//typedef long double LD;
using namespace std;
//#define MOD 1000000007
//#define MAX 100100
//#define NIL -1
//#define INFTY 1000000000000000000
int main(){
LL a;
LL b;
string s;
bool is_ok=true;
cin >> a >> b;
cin >> s;
if(a+b+1!=s.size()){
is_ok=false;
}else if(s[a]!='-'){
is_ok=false;
}else{
for(LL i=0; i<a; i++){
LL tmp=s[i]-'0';
if(tmp<0 || tmp>9){
is_ok=false;
}
}
for(LL i=a+1; i<a+b+1; i++){
LL tmp=s[i]-'0';
if(tmp<0 || tmp>9){
is_ok=false;
}
}
}
if(is_ok==true){
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
return 0;
}
| #include <iostream>
#include <string>
using namespace std;
int main(){
int A, B;
string S;
cin >> A >> B >> S;
for (int i = 0; i < S.size(); i++){
if (i==A){
if (S[i]!='-'){
printf("No\n");
return 0;
}
}else if (S[i]-'0' > 9 || S[i]-'0' < 0){
printf("No\n");
return 0;
}
}
printf("Yes\n");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
using ll = long long;
int n, m;
int main(){
scanf("%d%d", &n, &m);
rep(i,m) printf("%d %d\n", i+1, n-i-(~n&1 && n<=i*4+2));
} | #include<iostream>
int main(){
int N,M;
std::cin>>N>>M;
int a,b;
if(M%2==0){
a=M/2;
b=M/2;
}else{
a=M/2;
b=M-a;
}
for(int i=1;i<=a;++i){
std::cout<<i<<" "<<2*a+2-i<<std::endl;
}
for(int i=1;i<=b;++i){
std::cout<<i+2*a+1<<" "<<M*2+2-i<<std::endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
typedef long long ll;
typedef long double ld;
const int N = (int) 1e6 + 7;
int n, sumtop;
struct T {
int top;
int mn;
};
bool cmp1(T a, T b) {
return a.mn > b.mn;
}
bool cmp2(T a, T b) {
return min(a.mn, a.top + b.mn) > min(b.mn, b.top + a.mn);
///return a.top - a.mn > b.top - b.mn;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
vector<T> a, b;
cin >> n;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
int top = 0, mn = 0;
for (auto &ch : s) {
if (ch == '(') {
top++;
} else {
top--;
}
mn = min(mn, top);
}
if (top >= 0) {
a.push_back({top, mn});
} else {
b.push_back({top, mn});
}
sumtop += top;
}
if (sumtop != 0) {
cout << "No\n";
return 0;
}
sort(a.begin(), a.end(), cmp1);
sort(b.begin(), b.end(), cmp2);
int cur = 0;
for (auto &it : a) {
if (cur + it.mn < 0) {
cout << "No\n";
return 0;
}
cur += it.top;
}
for (auto &it : b) {
if (cur + it.mn < 0) {
cout << "No\n";
return 0;
}
cur += it.top;
}
cout << "Yes\n";
return 0;
}
| #include <bits/stdc++.h>
#define repl(i, l, r) for (int i = l; i < r; ++i)
#define rep(i, n) repl(i, 0, n)
#define pb push_back
#define eb emplace_back
#define all(v) (v).begin(),(v).end()
#define rall(v) (v).rbegin(),(v).rend()
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using G = vector<vector<int>>;
const int MOD = 998244353;
const int INF = 1001001001;
const int dy[] = {-1, 0, 1, 0};
const int dx[] = {0, -1, 0, 1};
int main()
{
int n;
cin >> n;
vector<ll> d(n);
rep(i, n) {
cin >> d[i];
if(i == 0 && d[i] != 0) {
cout << 0 << endl;
return 0;
}
else if(i != 0 && d[i] == 0) {
cout << 0 << endl;
return 0;
}
}
map<ll,ll> mp;
rep(i, n) {
++mp[d[i]];
}
ll ans = 1;
repl(i, 1, n) {
ans *= mp[d[i]-1];
ans %= MOD;
}
cout << ans << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
#define ll long long int
#define vll vector<ll>
using namespace std;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll a, b, c;
cin >> a >> b >> c;
cout << c << " " << a << " " << b << endl;
return 0;
} | #include<iostream>
int main(void){
int p, q, r;
std::cin >> p >> q >> r;
int ans;
ans = std::min(p+q, p+r);
ans = std::min(ans, q+r);
std::cout << ans << std::endl;
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <utility>
#include <queue>
#include <algorithm>
#include <map>
#include <set>
#include <cmath>
#include <ctime>
#include <cstdlib>
#include <climits>
using namespace std;
#define MOD1097 1000000007
#define ll long long
#define pint pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define mpair make_pair
#define pm(first, second) pb(mpair(first, second))
#define SPACE " "
#define fpf first.first
#define fps first.second
#define spf second.first
#define sps second.second
#define all(X) (X).begin(), (X).end()
#define reall(X) (X).rbegin(), (X).rend()
#define divcel(a, b) (((a) + ((b) - 1)) / (b))
int main(){
int h1, m1, h2, m2, k;
cin >> h1 >> m1 >> h2 >> m2 >> k;
h2 -= h1;
m2 -= m1;
while(h2 > 0){
m2 += 60;
h2--;
}
cout << m2-k << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <iostream>
using namespace std;
#define ll long long
#define ld long double
#define mp make_pair
#define pb push_back
#define fo(i,n) for(ll i=0;i<n;i++)
#define fo1(i,n) for(ll i=1;i<=n;i++)
#define loop(i,a,b)for(ll i=a;i<=b;i++)
#define loopr(i,a,b)for(ll i=b;i>=a;i--)
#define vll vector<ll>
#define vvl vector<vll>
#define pii pair<ll,ll>
#define F first
#define S second
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll h1,m1,h2,m2,k;
cin>>h1>>m1>>h2>>m2>>k;
ll ans=h2*60+m2-h1*60-m1-k;
if(ans<0)
cout<<0;
else
cout<<ans;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,n) for(int i=0; i<(n); i++)
#define REP2(i,x,n) for(int i=x; i<(n); i++)
#define PRINT(x) cout<<(x)<<endl
#define INF 1000000000000 // 10^12
#define MOD 1000000007 // 10^9+7
#define PB push_back
#define MP make_pair
const int MAX_N = 500;
int N, M, Q;
int L, R;
int p, q;
int cnt[MAX_N][MAX_N];
int dp[MAX_N][MAX_N];
int main() {
cin >> N >> M >> Q;
REP(i, N) {
REP(j, N) {
cnt[i][j] = 0;
dp[i][j] = 0;
}
}
REP(i, M) {
cin >> L >> R; L--; R--;
cnt[L][R]++;
}
REP(i, N) dp[i][i] = cnt[i][i];
REP2(k, 1, N) {
REP(i, N-k) {
int j = i + k;
dp[i][j] = dp[i+1][j] + dp[i][j-1] - dp[i+1][j-1] + cnt[i][j];
}
}
REP(i, Q) {
cin >> p >> q; p--; q--;
PRINT(dp[p][q]);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int MAX_N=262144*2;
vector<int64_t> seg(MAX_N*2-1);
int64_t qu(int a,int b,int k,int l, int r){
if(r<=a||b<=l){
return 0;
}
else if(a<=l&&r<=b){
return seg[k];
}
else{
int64_t X=qu(a,b,k*2+1,l,(l+r)/2);
int64_t Y=qu(a,b,k*2+2,(l+r)/2,r);
return X+Y;
}
}
void pu(int64_t a,int b){
int D=MAX_N-1+b;
while(D>0){
seg[D]+=a;
D--;
D/=2;
}
seg[0]+=a;
}
int main() {
int N,Q;
cin>>N>>Q;
vector<int> p(N);
for(int i=0;i<N;i++){
cin>>p[i];
p[i]--;
}
vector<tuple<int,int,int>> q(Q);
for(int i=0;i<Q;i++){
int a,b;
cin>>a>>b;
q[i]=make_tuple(b,a,i);
}
sort(q.begin(),q.end());
vector<int> la(N,-1);
vector<int> an(Q);
int W=0;
for(int i=0;i<Q;i++){
int a,b,c;
tie(a,b,c)=q[i];
while(W<a){
if(la[p[W]]!=-1){
pu(-1,la[p[W]]);
}
la[p[W]]=W;
pu(1,W);
W++;
}
an[c]=qu(b-1,a,0,0,MAX_N);
}
for(int i=0;i<Q;i++){
cout<<an[i]<<endl;
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
void read(int &x) {
x=0;int f=1;char ch=getchar();
for(;!isdigit(ch);ch=getchar()) if(ch=='-') f=-f;
for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';x*=f;
}
void print(int x) {
if(x<0) putchar('-'),x=-x;
if(!x) return ;print(x/10),putchar(x%10+48);
}
void write(int x) {if(!x) putchar('0');else print(x);putchar('\n');}
#define lf double
#define ll long long
#define pii pair<int,int >
#define vec vector<int >
#define pb push_back
#define mp make_pair
#define fr first
#define sc second
#define data asd09123jdf02i3h
#define FOR(i,l,r) for(int i=l,i##_r=r;i<=i##_r;i++)
const int maxn = 1e6+10;
const int inf = 1e9;
const lf eps = 1e-8;
const int mod = 1e9+7;
int n,m,b[maxn],l[maxn],r[maxn],ans,s[maxn],t[maxn];
int check(int x) {
for(int i=1;i<=n;i++) {
int c=x/m,d=x%m;
int res=l[i]*min(b[i],d)+r[i]*max(0ll,d-b[i]),w=l[i]*b[i]+r[i]*(m-b[i]);// write(t[c+1]);
if(c) {
if(w<s[c]) res+=t[c];
else res+=t[c+1]-w;
}
res-=ans;// printf("%I64d %I64d %I64d\n",x,i,res);
if(res>=0) return 1;
}
return 0;
}
signed main() {
read(n),read(m);
for(int i=1;i<=n;i++) read(b[i]),read(l[i]),read(r[i]),ans+=b[i]*l[i],s[i]=b[i]*l[i]+(m-b[i])*r[i];
sort(s+1,s+n+1,greater<int > ());
for(int i=1;i<=n;i++) t[i]=s[i]+t[i-1];
int l=0,r=n*m,ans=n*m;
while(l<=r) {
int mid=(l+r)>>1;
if(check(mid)) r=mid-1,ans=mid;
else l=mid+1;
}
write(ans);
return 0;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
#pragma comment(linker, "/stack:200000000")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//turn on extra precision
#pragma GCC target("fpmath=387")
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef string str;
typedef pair <int,int> pii;
typedef pair <ll,ll> pll;
typedef vector <int> vi;
typedef vector <ll> vll;
typedef vector <pii> vpii;
typedef vector <pll> vpll;
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define ordered_multiset tree<int, null_type,less_equal<int>, rb_tree_tag,tree_order_statistics_node_update>
#define mp make_pair
#define pb push_back
#define pob pop_back
#define pf push_front
#define pof pop_front
#define fi first
#define se second
#define fs first.second
#define ss second.second
#define ff first.first
#define sf second.first
#define newl '\n'
#define fbo find_by_order
#define ook order_of_key
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(),x.rend()
#define watch(x) cout << (#x) << " is : " << (x) << newl
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
vi dirx = {0,0,1,-1};
vi diry = {1,-1,0,0};
char to_upper (char x){
if( 97 <= int(x) && int(x) <= 122) return char(x-32);
if( 65 <= int(x) && int(x) <= 90) return x;
return -1;
}
char to_lower (char x){
if( 97 <= int(x) && int(x) <= 122) return x;
if( 65 <= int(x) && int(x) <= 90) return char(x+32);
return -1;
}
int numerize (char x){
if(48 <= int(x) && int(x) <= 57) return int(x-'0');
if(97 <= int(x) && int(x) <= 122) return int(x-96);
if(65 <= int(x) && int(x) <= 90) return int(x-64);
return -1;
}
bool isect (int l1, int r1, int l2, int r2){
pii p1 = {l1,r1};
pii p2 = {l2,r2};
if(p1>p2)swap(p1,p2);
return (p2.fi <= p1.se);
}
ll quickpow (ll num1, ll num2, ll MOD){
if(num2==0)return 1%MOD;
else if(num2==1)return num1%MOD;
else{
ll temp = quickpow (num1,num2>>1LL,MOD); ll res = ((temp%MOD) * (temp%MOD))%MOD;
if(num2&1) res = ((res%MOD)*(num1%MOD))%MOD; return res;
}
}
ll invmod (ll num, ll MOD){return quickpow (num,MOD-2,MOD);}
ll gcd (ll num1, ll num2){
if(num1 < num2) swap(num1,num2); ll num3 = num1 % num2 ;
while(num3 > 0){ num1 = num2; num2 = num3; num3 = num1 % num2;}
return num2;
}
ll lcm (ll num1 , ll num2){return (ll) (num1/__gcd(num1,num2))*num2;}
// end of Template
int n,k;
double sum[200010];
double getsum(int l, int r){
return sum[r] - sum[l-1];
}
int main(){
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n,k; cin >> n >> k;
for(int i = 1; i <= n; ++i){
int p; cin >> p;
int res = (p * (p + 1)) / 2;
double RES = (res * 1.0) / (p * 1.0);
sum[i] = sum[i-1] + RES;
}
double ans = 0;
for(int i = k; i <= n; ++i){
int l = i-k+1;
int r = i;
ans = max(ans,getsum(l,r));
}
cout << fixed << setprecision(10) << ans << newl;
return 0;
}
| 0 |
#include <iostream>
using namespace std;
int main() {
string s;
bool pri = 0;
cin >> s;
for (int i = 0; i < s.length(); ++i) {
if(s[i] == 'A'){
if(i+1 != s.length() && s[i+1] == 'C'){
cout << "Yes";
pri = 1;
break;
}
}
}
if(!pri){
cout <<"No";
}
return 0;
}
| #include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main(){
string S;
cin>>S;
if(S.find("AC")!=string::npos ){cout<<"Yes"<<endl;}
else{cout<<"No"<<endl;}
return 0;
} | 1 |
#include <iostream>
#include <vector>
using namespace std;
int main(){
vector<int> outp;
int icn;
int icd;
int g;
vector<int> ice;
for(g = 0;;g++){
vector<int> ice(10,0);
cin >> icn;
if(icn == 0){
break;
}else{
for(int a = 0;a< icn;a++){
cin >> icd;
ice[icd] += 1;
}
outp.insert(outp.end(),ice.begin(),ice.end());
}
}
for(int n = 0;n<g * 10;n++){
if(outp[n] == 0){
cout << "-";
}else{
for(int c = 0;c<outp[n];c++){
cout << "*" ;
}
}
cout << endl;
}
return 0;
} | #include<iostream>
#include<string>
#include<vector>
#include<map>
using namespace std;
int main(void){
int a,n;
while(1){
map<int,string> str;
cin >> n;
if(n==0)break;
for(a=0;a<n;a++){
int b;
cin >> b;
str[b].push_back('*');
}
for(a=0;a<=9;a++){
if(str.size()>0)cout << str[a] << endl;
else cout << "-" << endl;
}
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<ll, int> Pli;
typedef vector < vector<ll> > Mat;
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll MOD3 = 1812447359;
const ll INF = 1ll << 62;
const double PI = 2 * asin(1);
void yes() {printf("yes\n");}
void no() {printf("no\n");}
void Yes() {printf("Yes\n");}
void No() {printf("No\n");}
void YES() {printf("YES\n");}
void NO() {printf("NO\n");}
ll N, K, ans = 1e18;
int Solve(ll num, ll turn){
if (turn == N){
ans = min(ans, num);
return 0;
}
Solve(num * 2, turn + 1);
Solve(num + K, turn + 1);
return 0;
}
int main(){
cin >> N >> K;
Solve(1, 0);
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
}
int lmax = *max_element(L.begin(), L.end());
int rmin = *min_element(R.begin(), R.end());
int d = rmin - lmax + 1;
if (d < 0)
d = 0;
cout << d << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for(int i = (a); i < (b); ++i)
#define REP(i, n) for(int i = 0; i < (n); ++i)
#define REPr(i, n) for(int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for(int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for(int i = (n); i >= (m); --i)
#define MP make_pair
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
#define DB(x) cerr << #x << " = " << x << endl
#define DB2(x, y) \
cerr << "(" << #x << ", " << #y << ") = (" << x << ", " << y << ")\n";
#define DEBUG \
int x12345; \
cin >> x12345;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
///////////////////////////////////////////////
const long long MOD = 1e9 + 7;
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;
}
///////////////////////////////////////////////
/// 🍈( '-' 🍈 |AC|
string S;
ll N,Q;
ll solve(ll k){
ll ret = 0;
ll d = 0;
ll m = 0;
ll dm = 0;
REP(i,k){
if (S[i] == 'D') d++;
if (S[i] == 'M') {
m++;
dm += d;
}
if (S[i] == 'C'){
ret += dm;
}
}
for (size_t i = k; i < N; i++) {
char prev = S[i-k];
char next = S[i];
if (prev == 'D'){
d--;
dm -= m;
}
if (prev == 'M'){
m--;
}
if (next == 'D') d++;
if (next == 'M'){
m++;
dm += d;
}
if (next == 'C'){
ret += dm;
}
}
return ret;
}
int main() {
cin >> N >> S >> Q;
while(Q--){
ll k; cin >> k;
cout << solve(k) << "\n";
}
} | #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define all(v) v.begin(), v.end()
#define sz size()
#define mp make_pair
#define pb push_back
#define rep(p, a, b) for (ll p = a; p < b; p++)
#define F first
#define S second
using namespace std;
typedef vector<ll> vll;
typedef vector<string> vstr;
typedef vector<ld> vld;
typedef pair<ll, ll> pll;
int main()
{
ll t, i, j, k, ans, n, m, sum = 0, x;
//cin>>t;
t = 1;
while (t--)
{
cin >> n >> m;
string s;
vll wa(n + 1), ac(n + 1);
ll c1 = 0, c2 = 0;
rep(p, 0, m)
{
cin >> x >> s;
if (s == "WA")
wa[x]++;
else
{
if (ac[x] == 0)
{
c1++;
c2 += wa[x];
ac[x] = 1;
}
}
}
cout << c1 << " " << c2;
}
return 0;
}
| 0 |
#include <iostream>
#include <string>
#include <cmath>
#include <vector>
#include <map>
#include <algorithm>
#include <stdio.h>
int main(void){
int x,y,z;
std::cin >> x >> y >> z;
std::cout << z << " " << x << " " << y;
return 0;
}
| /*
このコード、と～おれ!
Be accepted!
∧＿∧
（｡･ω･｡)つ━☆・*。
⊂ ノ ・゜+.
しーＪ °。+ *´¨)
.· ´¸.·*´¨) ¸.·*¨)
(¸.·´ (¸.·'* ☆
*/
#include <stdio.h>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <vector>
#include <numeric>
#include <iostream>
#include <random>
#include <map>
#include <unordered_map>
#include <queue>
#pragma GCC optimize("Ofast")
#define rep(i, n) for(int i = 0; i < (n); ++i)
#define rep1(i, n) for(int i = 1; i <= (n); ++i)
#define rep2(i, n) for(int i = 2; i < (n); ++i)
#define repr(i, n) for(int i = n; i >= 0; --i)
#define reprm(i, n) for(int i = n - 1; i >= 0; --i)
#define printynl(a) printf(a ? "yes\n" : "no\n")
#define printyn(a) printf(a ? "Yes\n" : "No\n")
#define printYN(a) printf(a ? "YES\n" : "NO\n")
#define printin(a) printf(a ? "possible\n" : "inposible\n")
#define printdb(a) printf("%.50lf\n", a)//少数出力
#define printdbd(a) printf("%.16lf\n", a)//少数出力(桁少なめ)
#define prints(s) printf("%s\n", s.c_str())//string出力
#define all(x) (x).begin(), (x).end()
#define allsum(a, b, c) ((a + b) * c / 2)//等差数列の和、初項,末項,項数
#define pb push_back
#define priq priority_queue
#define rpriq priq<int, vector<int>, greater<int>>
#define deg_to_rad(deg) (((deg)/360.0)*2.0*PI)
#define rad_to_deg(rad) (((rad)/2.0/PI)*360.0)
#define Please return
#define AC 0
#define ushi int
#define tapu main
#define nichia (
#define kunn void
#define wara )
using ll = long long;
const int INF = 1073741823;
const int MINF = -1073741823;
const ll LINF = ll(4661686018427387903);
const ll MOD = 1000000007;
const double PI = acos(-1);
using namespace std;
void scans(string& str) {
char c;
scanf("%c", &c);
if (c == '\n')scanf("%c", &c);//最初の改行対策
while (c != '\n' && c != -1) {
str += c;
scanf("%c", &c);
}
}
void scanc(char& str) {
char c;
scanf("%c", &c);
if (c == -1)return;
while (c == '\n') {
scanf("%c", &c);
}
str = c;
}
double acot(double x) {
return PI / 2 - atan(x);
}
/*-----------------------------------------ここからコード-----------------------------------------*/
int main(){
string s;
scans(s);
prints(s.substr(0, s.length() - 8));
Please AC;
}
| 0 |
#include<stdio.h>
int main()
{
int a,b,c,n;
scanf("%d %d %d",&n,&a,&b);
if(n==2){
for (int i=1; i < a ;i++) {
if(a%i+b%i==0){
printf("%d\n",i);
}
}
}else if(n==3){
scanf("%d",&c);
for (int i=1; i < a ;i++) {
if(a%i+b%i+c%i==0){
printf("%d\n",i);
}
}
}
return 0;
} | #include "bits/stdc++.h"
#define rep(i,a,n) for(int i = a;i < n;i++)
typedef unsigned long long ull;
typedef long long ll;
using namespace std;
int main(){
int n,memo;
priority_queue<int,vector<int>,greater<int> > que;
cin >> n;
int a[n];
rep(i,0,n){
cin >> a[i];
}
sort(a,a+n);
rep(i,1,sqrt(a[n-1])+1){
rep(j,0,n){
if(a[j] % i)break;
else if(j == n-1)que.push(i);
}
if(a[n-1]/i == i)continue;
rep(j,0,n){
if(a[j] % (a[n-1]/i))break;
else if(j == n-1)que.push(a[n-1]/i);
}
}
while(!que.empty()){
if(que.top() == memo){
que.pop();
continue;
}
memo = que.top(); que.pop();
cout << memo << endl;
}
}
| 1 |
#include <iostream>
#include <map>
using namespace std;
int main()
{
int n;
cin >> n;
map<int, int> mp;
for(int i = 0; i < n; i++){
int a;
cin >> a;
mp[a]++;
}
int t = (1 << 30);
int ans = 0;
for(auto itr = mp.rbegin(); itr != mp.rend(); itr++){
int a = itr->first, c = itr->second;
while(t > a * 2) t /= 2;
if(t == a * 2) ans += c / 2;
else{
ans += min(mp[a], mp[t - a]);
mp[t - a] -= min(mp[a], mp[t - a]);
}
}
cout << ans << endl;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll N = pow(10,9)+7;
vector<ll> ans(61,0);
ll n;
cin >> n;
for(int i=0; i<n; i++){
ll a;
cin >> a;
int count=0;
while(a!=0){
ans.at(count) += a%2;
a /= 2;
count++;
}
}
ll out=0;
ll keta=1;
for(int i=0; i<61; i++){
//cout << "ou" << out << endl;
//cout << "ke" << keta << endl;
ll t = (n-ans.at(i))*ans.at(i)%N;
out = (out+keta*t)%N;
keta = (keta*2)%N;
}
cout << out << endl;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.