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 deb(x) cout<< #x << " " << x << "\n";
#define MAX 9223372036854775807
#define MIN -9223372036854775807
#define PI 3.141592653589
#define setbits(n) __builtin_popcountll(n)
const ll mod=1e9+7;
const int N=1e5+1;
ll dp[N][101][2],d,n;
string s;
ll go(ll pos, ll k, ll mx){
if(pos==n){
if(k==0) return 1;
else return 0;
}
if(dp[pos][k][mx]!=-1)
return dp[pos][k][mx];
ll ans=0,lim=s[pos]-'0';
if(mx==0) lim=9;
for(int i=0;i<lim;i++)
ans=(ans+go(pos+1,(k+i)%d,0))%mod;
if(mx==1) ans=(ans+go(pos+1,(k+lim)%d,1))%mod;
else ans=(ans+go(pos+1,(k+lim)%d,0))%mod;
return dp[pos][k][mx]=ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll T=clock();
cin>>s;
cin>>d;
n=s.size();
memset(dp,-1,sizeof(dp));
cout<<(go(0,0,1)-1+mod)%mod;
cerr<<"\n\nTIME: "<<(double)(clock()-T)/CLOCKS_PER_SEC<<" sec\n";
T = clock();
return 0;
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define int ll
typedef pair<int,int> pii;
#define fi first
#define se second
#define Sort(a) sort(a.begin(),a.end())
#define rep(i,n) for(int i = 0;i < (n) ; i++)
#define REP(i,n) for(int i = 0;i < (n) ; i++)
#define MP(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define INF LLONG_MAX/4
#define INTINF INT_MAX/2
#define all(x) (x).begin(),(x).end()
#define debug(x) cerr<<#x<<": "<<x<<endl
#define debug_vec(v) cerr<<#v<<":";rep(i,v.size())cerr<<" "<<v[i];cerr<<endl
template<class T> inline bool chmax(T &a, T b){if(a < b){a = b;return true;}return false;}
template<class T> inline bool chmin(T &a, T b){if(a > b){a = b;return true;}return false;}
/*----------------------------------------------------------------*/
// const int MOD = 998244353;
const int MOD = 1000000007;
/*----------------------------------------------------------------*/
signed main(){
int n;
cin >> n;
cout << 0 << endl;
string s1;
cin >> s1;
if(s1 == "Vacant")return 0;
string x = s1;
int S = 0;
int G = n-1;
while(1){
int nx = (S+G)-(S+G)/2;
cout << nx << endl;
string s;
cin >> s;
if(s == "Vacant")return 0;
if((s == x && S%2 == nx%2) || (s != x && S%2 != nx%2)){
S = nx;
x = s;
}else{
G = nx-1;
}
}
return 0;
}
/*----------------------------------------------------------------*/
// g++ -std=gnu++17 code1.cpp
// sudo pip3 install --upgrade online-judge-tools
// rm -r -f test;oj dl https://code-festival-2017-qualb.contest.atcoder.jp/tasks/code_festival_2017_qualb_b
// rm -r -f test;oj dl https://abc146.contest.atcoder.jp/tasks/abc146_d | 0 |
#include <bits/stdc++.h>
#define ll long long
#define pi 3.14159265358979
#define rep(i,n) for(ll i=0;i<n;i++)
using namespace std;
int main(){
ll n,a,b,c;
cin >> n;
a=n/3;
b=n/5;
c=n/15;
if(n%2==0){
n=n/2*(n+1);
}else{
n=(n+1)/2*n;
}
a=a*(a+1)/2;
b=b*(b+1)/2;
c=c*(c+1)/2;
cout << n-a*3-b*5+c*15;
} | #include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << ", " << #y << "=" << y << endl
void solve() {
ll n;
cin >> n;
ll sm = 0;
for (int i = 1; i <= n; i++) {
if (i % 3 == 0 || i % 5 == 0)
continue;
sm += i;
}
cout << sm << '\n';
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
ll test = 1;
// cin >> test;
while (test--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#include <string>
//#define local
#ifdef local
#include "dbg-macro/dbg.h"
#endif
#define ll long long
#define pi (acos(-1))
#define rep(i, n) for (unsigned long long i = 0; i < (unsigned long long)(n); ++i)
using namespace std;
std::vector<unsigned ll> genprimevec(const unsigned ll N);
int main()
{
int n, m;
cin >> n >> m;
vector<int> wavec(n, 0);
vector<bool> aced(n, false);
ll ac = 0;
ll wa = 0;
while (m--)
{
int p;
string s;
cin >> p >> s;
if (aced[p]) { continue; }
if (s == "AC")
{
aced[p] = true;
++ac;
wa += wavec[p];
}
else
{
wavec[p]++; // WA
}
}
cout << ac << ' ' << wa << endl;
return 0;
}
ll extgcd(ll a, ll b, ll &x, ll &y)
{
if (b == 0)
{
x = 1, y = 0;
return a;
}
ll d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
std::vector<unsigned ll> genprimevec(const unsigned ll N)
{
std::vector<bool> is_prime(N + 1);
for (unsigned ll i = 0; i <= N; i++) { is_prime[i] = true; }
std::vector<unsigned ll> P;
for (unsigned ll i = 2; i <= N; i++)
{
if (is_prime[i])
{
for (unsigned ll j = 2 * i; j <= N; j += i) { is_prime[j] = false; }
P.emplace_back(i);
}
}
return P;
}
| /***
coded by adarsh
***/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<ll> vec;
typedef vector<vector<ll>> vec2;
typedef pair<ll,ll> pair1;
typedef pair<string,ll> pair2;
typedef pair<ll,string> pair3;
typedef pair<string,string> pair4;
#define fl(i,a,b) for(i=a;i<b;i++)
#define rfl(i,a,b) for(i=b-1;i>=a;i--)
#define f first
#define s second
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n,m,i;cin>>n>>m;
map<ll,ll> b;
set<ll> a;ll c=0;
fl(i,0,m)
{
ll p;string s;
cin>>p>>s;
if(a.count(p)==0&&s=="WA")
{
b[p]++;
}
else if(a.count(p)==0&&s=="AC")
{
c+=b[p];
a.insert(p);
}
}
cout<<a.size()<<" "<<c;
return 0;
}
| 1 |
#include <iostream>
#include <cstdio>
#include <string>
#include <cmath>
#define PI 3.141592653589793
using namespace std;
int main(){
int n;
string str;
cin>>n;
for(int i=0;i<n;i++){
int cnt=0,num=0;
int rui[5]={0};
while(cin>>str){
if(str=="HIT"){
rui[4]=rui[3];
rui[3]=rui[2];
rui[2]=rui[1];
rui[1]=1;
if(rui[4]==1){
rui[4]=0;
cnt++;
}
}else if(str=="HOMERUN"){
for(int j=1;j<=3;j++){
if(rui[j]==1){
rui[j]=0;
cnt++;
}
}
cnt++;
}else{
num++;
if(num==3)break;
}
}
cout<<cnt<<endl;
}
return 0;
} | #include<iostream>
#include<string>
using namespace std;
int main(){
int n;
cin>>n;
string event;
getline(cin,event,'\n');
int i=0,out,b,score;
while(n>0){
out = 0;
b = 0;
score=0;
while(out<3){
getline(cin,event,'\n');
if(event=="HIT"){
b*=2;
b+=1;
if(b>8){
b-=8;
score++;
}
}
if(event=="HOMERUN"){
while(b>0){
score+=b%2;
b/=2;
}
score++;
}
if(event=="OUT"){
out++;
}
}
cout<<score<<endl;
n--;
}
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
using namespace std;
void darts();
void longest_dis();
void sum_of_three_integers();
void otoshidama();
int main()
{
//darts();
//longest_dis();
//sum_of_three_integers();
otoshidama();
}
void darts()
{
while (true)
{
int n, m;
cin >> n >> m;
// stop cond
if (n == 0) break;
vector<int> p(n);
for (int i = 0; i < n; ++i) cin >> p[i];
// 2 darts combination
// p = q, 0, p + q
vector<int> q = p;
q.push_back(0);
for (int i = 0; i < n; ++i)
{
for (int j = 0; j <= i; ++j)
{
q.push_back(p[i] + p[j]);
}
}
sort(q.begin(), q.end());
// q's size = 1 + n + n(n + 1) / 2
//cout << q.size() << "\n";
//for (auto x : q) cout << x << " ";
int ret = 0;
int j = q.size() - 1;
//i:q linear scan
for (int i = 0; i < q.size(); ++i)
{
if (q[i] > m) break;
while (q[i] + q[j] > m) --j;
ret = max(ret, q[i] + q[j]);
}
cout << ret << "\n";
}
}
void longest_dis()
{
int n;
cin >> n;
vector<pair<int, int>> p(n);
for (int i = 0; i < n; ++i) cin >> p[i].first >> p[i].second;
double v_max = 0.0;
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < n; ++j)
{
if ((p[i].first - p[j].first) * (p[i].first - p[j].first)
+ (p[i].second - p[j].second) * (p[i].second - p[j].second)
> v_max * v_max)
{
v_max = sqrt((p[i].first - p[j].first) * (p[i].first - p[j].first)
+ (p[i].second - p[j].second) * (p[i].second - p[j].second));
}
}
}
cout << v_max << "\n";
}
void sum_of_three_integers()
{
int k, s;
cin >> k >> s;
int cnt = 0;
//for (int i = 0; i <= k; ++i)
//{
// for (int j = 0; j <= k; ++j)
// {
// for (int m = 0; m <= k; ++m)
// {
// if (i + j + m == s) ++cnt;
// }
// }
//}
for (int i = 0; i <= k; ++i)
{
for (int j = 0; j <= k; ++j)
{
int m = s - i - j;
if (0 <= m && m <= k) ++cnt;
}
}
cout << cnt << "\n";
}
void otoshidama()
{
int n, Y;
cin >> n >> Y;
for (int x = 0; x <= n; ++x)
{
for (int y = 0; x + y <= n; ++y)
{
int z = n - x - y;
if (x * 10000 + y * 5000 + z * 1000 == Y)
{
cout << x << " "<< y << " " << z << "\n";
return;
}
}
}
cout << "-1 -1 -1\n";
} | #include <algorithm>
#include <cmath>
#include <vector>
#include <functional>
#include <cstdlib>
#include <map>
#include <set>
#include <iostream>
#include <string>
#include <ctype.h>
#include <climits>
#include <queue>
using namespace std;
typedef long long ll;
#define REP(i, n) for(ll i = 0; i < (ll)(n); ++i)
template<class T> inline bool chmax(T& a, T b) { if(a < b){ a=b; return 1; } return 0;}
template<class T> inline bool chmin(T& a, T b) { if(a > b){ a=b; return 1; } return 0;}
int main(){
int n,y;
cin >> n >> y;
for(int i=0; i<=n; i++){
for(int j=0; j<=n; j++){
int k = n - (i+j);
if(k < 0) continue;
if(y == 10000*i + 5000*j + 1000*k){
printf("%d %d %d\n",i,j,k);
return 0;
}
}
}
printf("-1 -1 -1\n");
return 0;
} | 1 |
#include <iostream>
#include <cctype>
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#include <queue>
#include <cstdio>
inline int getInt(){ int s; scanf("%d", &s); return s; }
#include <set>
using namespace std;
char encode(int n){
if(n < 26) return 'a' + n;
return 'A' + n - 26;
}
int decode(char c){
if(islower(c)) return c - 'a';
return c - 'A' + 26;
}
int main(){
while(const int n = getInt()){
vector<int> v(n);
REP(i,n) v[i] = getInt();
char buff[256];
scanf("%s", buff);
for(char *s = buff; *s; s++){
cout << encode((decode(*s) + 52 - v[(s - buff) % v.size()]) % 52);
}
cout << endl;
}
return 0;
} | #include <iostream>
#include <set>
using namespace std;
int main()
{
int n, k, a[11], b[11];
while(1)
{
set<int> s;
cin >> n >> k;
if(n==0 && k==0) break;
else
{
for(int i=0; i<n; i++)
{
cin >> a[i];
if(a[i]>9) b[i]=2;
else b[i]=1;
}
for(int i=0; i<n; i++)
{
int x=0;
x=a[i];
x*=10;
for(int j=0; j<n; j++)
{
int y=x;
if(j==i) continue;
if(b[j]==2) y*=10;
y+=a[j];
if(k==2) s.insert(y);
y*=10;
for(int l=0; l<n; l++)
{
int z=y;
if(l==i || l==j) continue;
if(b[l]==2) z*=10;
z+=a[l];
if(k==3) s.insert(z);
z*=10;
for(int m=0; m<n; m++)
{
int w=z;
if(m==i || m==j || m==l) continue;
if(b[m]==2) w*=10;
w+=a[m];
if(k==4) s.insert(w);
}
}
}
}
cout << s.size() << endl;
}
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define SPEED ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define MP make_pair
#define pb push_back
#define ff first
#define ss second
#define sz(x) x.size()
#define all(c) c.begin(),c.end()
#define int long long
#define fr(i,j,x) for(int i=j;i<x;i++)
#define rep(i,j,x) for(int i=j;i<=x;i++)
#define mem(x,val) memset(x,val,sizeof(x))
//#define endl '\n'
#define vi vector<int>
#define pii pair<int,int>
#define piii pair<int,pii>
const int mod=1e9+7;
const int N=1e5+10;
const int MAXN=2e6+10;
const int INF=1e18;
string to_string(string s) { return '"' + s + '"';}
string to_string(char s) { return string(1, s);}
string to_string(const char* s) { return to_string((string) s);}
string to_string(bool b) { return (b ? "true" : "false");}
template <typename A> string to_string(A);
template <typename A, typename B>string to_string(pair<A, B> p) {return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
template <typename A> string to_string(A v) {bool f = 1; string r = "{"; for (const auto &x : v) {if (!f)r += ", "; f = 0; r += to_string(x);} return r + "}";}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {cerr << " " << to_string(H); debug_out(T...);}
#define pr(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
int a[N];
string getbase(int x,int b){
string ans;
int d;
while(x){
d=x%b;
ans=char('0'+d)+ans;
x/=b;
}
return ans;
}
string L,R;
int d,dp[10010][2][2][101];
int rec(int ind,int tlo,int thi,int rem){
if(ind>=L.length()){
if(rem==0){
return 1;
}
return 0;
}
if(dp[ind][tlo][thi][rem]==-1){
int blo=0;
int bhi=9;
if(tlo){
blo=L[ind]-'0';
}
if(thi){
bhi=R[ind]-'0';
}
int ans=0;
for(int i=blo;i<=bhi;i++){
int ntlo=tlo;
int nthi=thi;
if(i>L[ind]-'0'){
ntlo=0;
}
if(i<R[ind]-'0'){
nthi=0;
}
ans+=rec(ind+1,ntlo,nthi,(rem+i)%d);
ans%=mod;
}
dp[ind][tlo][thi][rem]=ans;
}
return dp[ind][tlo][thi][rem];
}
void solve(){
string l,r;
l="1";
cin>>r>>d;
L=l;
R=r;
reverse(all(L));
reverse(all(R));
while(L.length()<R.length()){
L+='0';
}
while(L.length()>R.length()){
R+='0';
}
reverse(all(L));
reverse(all(R));
mem(dp,-1);
cout<<rec(0,1,1,0)<<endl;
}
int32_t main()
{
// #ifndef ONLINE_JUDGE
// freopen("inputf.in", "r", stdin);
// //freopen("outputf.in", "w", stdout);
// #endif
SPEED;
int T=1;
//cin>>T;
int t1=1;
while(true)
{
//cout<<"Case #"<<t1<<": ";
solve();
t1++;
if(t1>T)
break;
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
const int mod=1000000007;
string k;
int d;
cin >> k >> d;
int n=k.size();
vector<int> now(d,0);
int val=0;
for(int i=0;i<n;i++)
{
vector<int> nxt(d,0);
int x=(k[i]-'0');
for(int a=0;a<x;a++) nxt[(val+a)%d]=(nxt[(val+a)%d]+1)%mod;
val=(val+x)%d;
for(int j=0;j<d;j++)
{
for(int a=0;a<=9;a++) nxt[(j+a)%d]=(nxt[(j+a)%d]+now[j])%mod;
}
now=nxt;
}
cout << (now[0]+(val==0)-1+mod)%mod << "\n";
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main(){
char c[21];
int n = 0;
while(cin >> c[n]){n++;}
for(int i=n-1;i>=0;i--) cout << c[i];
cout << endl;
} | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
constexpr char ln = '\n';
constexpr long long MOD = 1000000007LL;
constexpr long long INF = 1001001001LL;
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define rept(i, j, n) for(int i=(j); i<(n); i++)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main(){
int a, b; cin >> a >> b;
int num = 1, cnt = 0;
while(num < b){
num += a - 1;
cnt++;
}
cout << cnt << ln;
}
| 0 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long ll;
ll a[1005][1005];
int n;
int pri[10005],tot;
bool mk[10005];
ll lcm(ll a,ll b) {
if((!a)||(!b)) return a+b;
return 1ll*a/__gcd(a,b)*b;
}
int main() {
scanf("%d",&n);
if(n==2) {
printf("4 7\n23 10");
return 0;
}
mk[1] = mk[0] = 1;
for(int i=2;i<=10000;i++) {
if(!mk[i]) { pri[++tot]=i; }
if(tot==1000) break;
for(int j=1;j<=tot&&1ll*pri[j]*i<=10000;j++) {
int k = pri[j] * i;
mk[k] = 1;
if(i%pri[j]==0) break;
}
}
for(int i=1;i<=n;i++) {
for(int j=1;j<=n;j++) {
if((i+j)%2==0) a[i][j] = pri[(i + j) / 2] * pri[n+((i-j)/2+(n+1)/2)];
}
}
for(int i=1;i<=n;i++) {
for(int j=1;j<=n;j++) {
if((i+j)%2==1) a[i][j] = lcm( lcm(a[i-1][j],a[i+1][j]),lcm(a[i][j-1],a[i][j+1]) ) + 1;
printf("%lld ",a[i][j]);
}
puts("");
}
} | #include <bits/stdc++.h>
using namespace std;
using vi=vector<int>;
using vvi=vector<vi>;
using vs=vector<string>;
using msi=map<string,int>;
using mii=map<int,int>;
using pii=pair<int,int>;
using vlai=valarray<int>;
using ll=long long;
#define rep(i,n) for(int i=0;i<n;i++)
#define range(i,s,n) for(int i=s;i<n;i++)
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define fs first
#define sc second
struct item{
string name;
int p,s1,s2,x,r,m;
double y;
item(){
int a,b,c,d,e;
cin>>name>>p>>a>>b>>c>>d>>e>>x>>r>>m;
s1=a+b+c;s2=d+e;
y=(double)(x*r*m-p)/(s1+s2*m);
}
};
int main(){
int n;
while(cin>>n,n){
vector<item> v(n);
sort(all(v),[](item a, item b){return a.y>b.y || (a.y==b.y && a.name<b.name);});
for(auto p : v)cout<<p.name<<endl;
cout<<"#"<<endl;
}
} | 0 |
#include <cstdio>
#include <algorithm>
using namespace std;
int w, h;
int map[20][20];
int ans = 11;
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int dfs(int x, int y, int move){
// printf("x:%d y:%d move:%d\n", x, y, move);
if(move == 11) return 0;
for(int i=0; i<4; i++){
// printf(" direction:%d\n", i);
int nx = x, ny = y;
if(0<=x+dx[i] && x+dx[i]<w && 0<=y+dy[i] && y+dy[i]<h && map[x+dx[i]][y+dy[i]] != 1){
// printf(" Start moving\n");
while(1){
// printf(" %d %d\n", nx, ny);
if(nx+dx[i]<0 || w<=nx+dx[i] || ny+dy[i]<0 || h<=ny+dy[i]) break;
// printf(" On board\n");
if(map[nx+dx[i]][ny+dy[i]] == 3){
ans = min(ans, move+1);
// printf("Goal! move=%d\n", move+1);
break;
}
// printf(" Not Goal\n");
if(nx+dx[i]<0 || w<=nx+dx[i] || ny+dy[i]<0 || h<ny+dy[i]){
// printf(" Fall from board\n");
break;
}
if(map[nx+dx[i]][ny+dy[i]] == 1){
// printf(" Stop moving\n");
map[nx+dx[i]][ny+dy[i]] = 0;
dfs(nx, ny, move+1);
map[nx+dx[i]][ny+dy[i]] = 1;
break;
}
// printf(" Continue moving\n");
nx += dx[i];
ny += dy[i];
// printf(" next:%d, %d\n", nx, ny);
}
}
}
return 0;
}
int main(){
while(1){
scanf("%d %d", &w, &h);
if(w == 0 && h == 0) break;
ans = 11;
for(int i=0; i<20; i++){
for(int j=0; j<20; j++){
map[i][j] = 0;
}
}
for(int i=0; i<h; i++){
for(int j=0; j<w; j++){
scanf("%d", &map[j][i]);
}
}
int sx, sy;
for(int i=0; i<h; i++){
for(int j=0; j<w; j++){
if(map[j][i] == 2){
sx = j;
sy = i;
map[j][i] = 0;
}
}
}
dfs(sx, sy, 0);
if(ans == 11) printf("-1\n");
else printf("%d\n", ans);
}
return 0;
} | #include <iostream>
#include <utility>
#include <string>
#include <cstring>
#include <vector>
#include <map>
#include <algorithm>
#include <stack>
using namespace std;
#define rep(i, n) for(int i = 0; i < (int)(n); ++i)
const int INF = 1 << 28;
int w, h;
int field[32][32];
int sx, sy;
int gx, gy;
int ofs[4][2] = {
{0,1},
{1,0},
{-1,0},
{0,-1}
};
bool ok(int p, int n)
{
return 0 <= p && p < n;
}
bool dfs(int x, int y, int d, int n)
{
if( d >= n ) {
return false;
}
bool res = false;
rep(i, 4) {
int dx = ofs[i][0];
int dy = ofs[i][1];
int nx = x;
int ny = y;
int idx = 0;
while(ok(nx, w) && ok(ny, h) && !field[ny][nx]) {
nx += dx;
ny += dy;
if(nx == gx && ny == gy) {
return true;
}
++idx;
}
if( idx > 1 && ok(nx, w) && ok(ny, h) ) {
field[ny][nx] = 0;
res |= dfs(nx - dx, ny - dy, d + 1, n);
field[ny][nx] = 1;
}
}
return res;
}
int idfs(int sx, int sy)
{
int idx = 1;
while( idx <= 10 && !dfs(sx, sy, 0, idx) ) {
++idx;
}
if( idx > 10 ) {
return -1;
} else {
return idx;
}
}
int main()
{
while( cin >> w >> h, (h|w) ) {
rep(i, h) rep(j, w) {
int v;
cin >> v;
field[i][j] = v & 1;
if( v & 2 ) {
if( v & 1 ) {
gx = j;
gy = i;
} else {
sx = j;
sy = i;
}
}
}
cout << idfs(sx, sy) << endl;
}
return 0;
} | 1 |
#include<iostream>
#include<string>
#include<algorithm>
#include<math.h>
#include<queue>
#include<set>
#include<map>
using namespace std;
int main() {
string s;
cin >> s;
vector<pair<char, int>> v;
char last = s[0];
int cnt = 1;
for (int i = 1; i < s.size(); i++) {
if (s[i] == last) {
cnt++;
}
else {
v.push_back(make_pair(last, cnt));
last = s[i];
cnt = 1;
}
}
v.push_back(make_pair(last, cnt));
int ans = 0;
for (int i = 1; i < v.size() - 1; i++) {
if (v[i - 1].first == 'J' && v[i].first == 'O' && v[i + 1].first == 'I') {
if (v[i - 1].second >= v[i].second && v[i].second <= v[i + 1].second) {
ans = max(ans, v[i].second);
}
}
}
cout << ans << endl;
return 0;
}
| #include<bits/stdc++.h>
#define endl enjoy_codeforces
int main(){
std::string s;std::cin>>s;
std::cout<<s.substr(0,s.length()-8)<<'\n';
}
| 0 |
#include<stdio.h>
#include<iostream>
#include<string.h>
using namespace std;
typedef long long ll;
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define FORR(i,a,b) for(int i=(int)(b)-1;i>=(int)(a);i--)
#define CHMIN(a,b) (a) = min((a),(b))
#define CHMAX(a,b) (a) = max((a),(b))
int main()
{
int n,p;
while(1==1)
{
scanf("%d %d\n",&n,&p);
if(n==0&&p==0)return 0;
int ko[55]={};
int zan=p;
int poi=0;
int judge=0;
while(judge==0)
{
for(int i=0;i<n;i++)ko[i]+=zan/n;
zan-=(zan/n)*n;
while(zan>0)
{
ko[poi]++;
if(ko[poi]==p)
{
printf("%d\n",poi);
judge=1;
break;
}
zan--;
poi++;
if(poi>=n)poi-=n;
}
if(judge==1)break;
while(zan==0)
{
if(ko[poi]>0)
{
zan=ko[poi];
ko[poi]=0;
}
poi++;
if(poi>=n)poi-=n;
}
}
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
const int mod = 1e9+7;
int ad(int x,int y) { x+=y; return x>=mod?x-mod:x; }
int sb(int x,int y) { x-=y; return x<0?x+mod:x; }
int mu(int x,int y) { return 1ll*x*y%mod; }
int ksm(int a,int b) {
int ans = 1;
for(;b;b>>=1,a=mu(a,a))
if(b&1) ans = mu(ans,a);
return ans;
}
int fac[4000005],piv[4000005],n,k;
int GC(int a,int b) {
if(a<b) return 0;
return mu(fac[a],mu(piv[b],piv[a-b]));
}
int f[2005][2005];
int main() {
scanf("%d%d",&n,&k);
if(k==1) {
puts("1"); return 0;
}
fac[0] = 1;
for(int i=1;i<=n*k;i++) fac[i] = mu(fac[i-1],i);
piv[n*k] = ksm(fac[n*k],mod-2);
for(int i=n*k-1;i>=0;i--) piv[i] = mu(piv[i+1],i+1);
f[0][0] = 1;
for(int i=1;i<=n;i++) {
f[i][0] = 1;
for(int j=1;j<=i;j++) {
f[i][j] = ad(f[i-1][j],mu(GC((n-i)+(n-j+1)*(k-1)-1,k-2),mu(f[i][j-1],n-j+1)));
}
}
printf("%d",f[n][n]);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,K;
cin >> N >> K;
vector<int>p(N);
for (int i = 0; i < N; i++) {
cin >> p.at(i);
}
vector<int>sum1(N,0);
for (int i = 0; i < N; i++) {
if (i == 0){
sum1.at(i) = p.at(i);
}
else {
sum1.at(i) = sum1.at(i-1) + p.at(i);
}
}
vector<int>sum2(N-K+1);
for (int i = 0; i < N-K+1; i++) {
sum2.at(i) = sum1.at(K-1+i) - sum1.at(i) + p.at(i);
}
sort(sum2.begin(), sum2.end());
double A = (0.5*K + 1.0*sum2.at(N-K)/2);
printf("%.8lf\n", A);
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long LL;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937 mrand(random_device{}());
#define rep(i , l , r) for (int i = (l); i < (r); ++i)
const int N = 2e6 + 5;
const int mod = 998244353;
int n , m;
int fac[N] , ifac[N];
template <typename T> inline void chkmin(T &x , T y) { x = min(x , y); }
template <typename T> inline void chkmax(T &x , T y) { x = max(x , y); }
template <typename T> inline void read(T &x) {
T f = 1; x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + c - '0';
x *= f;
}
inline int quickpow(int a , int n) {
int res = 1;
for (; n; n >>= 1 , a = 1LL * a * a % mod)
if (n & 1) res = 1LL * res * a % mod;
return res;
}
inline void inc(int &x , int y) {
x = x + y < mod ? x + y : x + y - mod;
}
inline void dec(int &x , int y) {
x = x - y >= 0 ? x - y : x - y + mod;
}
inline void init(int n) {
fac[0] = 1;
for (int i = 1; i <= n; ++i)
fac[i] = 1LL * fac[i - 1] * i % mod;
ifac[n] = quickpow(fac[n] , mod - 2);
for (int i = n - 1; i >= 0; --i)
ifac[i] = 1LL * ifac[i + 1] * (i + 1) % mod;
return;
}
inline int binom(int n , int m) {
if (n < m) return 0;
else return 1LL * fac[n] * ifac[m] % mod * ifac[n - m] % mod;
}
inline int F(int n , int m , int k) {
int ret = 0;
for (int i = 0; i <= k; ++i) {
if ((m - i) & 1) continue;
int val = 1LL * binom(n , i) * binom((m - i) / 2 + n - 1 , n - 1) % mod;
inc(ret , val);
}
return ret;
}
int main() {
init(2e6);
read(n) , read(m);
int ans = F(n , 3 * m , m);
dec(ans , 1LL * n * F(n , m , m) % mod);
inc(ans , 1LL * n * F(n - 1 , m , m) % mod);
printf("%d\n" , ans);
return 0;
}
| 0 |
//
// Created by hide on 2020/05/15.
//
//参考：http://ehafib.hatenablog.com/entry/2015/12/23/164517
//インクルード(アルファベット順,bits/stdc++.hは使わない派閥)
#include<algorithm>//sort,二分探索,など
#include<bitset>//固定長bit集合
#include<cmath>//pow,logなど
#include<complex>//複素数
#include<deque>//両端アクセスのキュー
#include<functional>//sortのgreater
#include<iomanip>//setprecision(浮動小数点の出力の誤差)
#include<iostream>//入出力
#include<iterator>//集合演算(積集合,和集合,差集合など)
#include<map>//map(辞書)
#include<numeric>//iota(整数列の生成),gcdとlcm(c++17)
#include<queue>//キュー
#include<set>//集合
#include<stack>//スタック
#include<string>//文字列
#include<unordered_map>//イテレータあるけど順序保持しないmap
#include<unordered_set>//イテレータあるけど順序保持しないset
#include<utility>//pair
#include<vector>//可変長配列
using namespace std;
typedef long long ll;
//マクロ
//forループ関係
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
//Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
//xにはvectorなどのコンテナ
#define ALL(x) (x).begin(),(x).end() //sortなどの引数を省略したい
#define SIZE(x) ((ll)(x).size()) //sizeをsize_tからllに直しておく
#define MAX(x) *max_element(ALL(x)) //最大値を求める
#define MIN(x) *min_element(ALL(x)) //最小値を求める
//定数
#define INF 1000000000000 //10^12:極めて大きい値,∞
#define MOD 1000000007 //10^9+7:合同式の法
#define MAXR 100000 //10^5:配列の最大のrange(素数列挙などで使用)
//略記
//#define PB push_back //vectorヘの挿入
//#define MP make_pair //pairのコンストラクタ
//#define F first //pairの一つ目の要素
//#define S second //pairの二つ目の要素
int main(){
int N;
string S;
cin >> N;
cin >> S;
int r=0;
for(int i=1; i<N; i++) {
if (S[i] == 'E')
r++;
}
int answer = r;
int l = S[0] == 'W' ? 1:0;
for(int i=1; i<N; i++){
if(S[i]=='E')
r--;
answer = min(answer, l+r);
if(S[i]=='W')
l++;
}
cout << answer << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef vector<lint> vlint;
#define inf 1e+9
#define endl "\n"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i < (int)(n); i++)
#define rep_rev(i, n) for (int i = n-1; i >= 0; --i)
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define eb emplace_back
#define Size(c) (int)(c).size()
#define lb(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define ub(c, x) distance((c).begin(), upper_bound(all(c), (x)))
template <class T> using pq = priority_queue<T>;
template <class T> using pqg = priority_queue<T, vector<T>, greater<T>>;
template <class T, class S> inline bool chmax(T &a, S b) {
if(a < b) {a = b;return 1;} return 0;
}
template <class T, class S> inline bool chmin(T &a, S b) {
if(a > b) {a = b;return 1;} return 0;
}
template <class T>
void line(vector<T> &x){for (auto&& xi : x) cin >> xi;}
inline void IN(void){ return;}
template <typename First, typename... Rest>
void IN(First& first, Rest&... rest){ cin >> first; IN(rest...); return;}
#define INT(...) int __VA_ARGS__; IN (__VA_ARGS__)
#define LINT(...) lint __VA_ARGS__; IN (__VA_ARGS__)
#define STR(...) string __VA_ARGS__; IN(__VA_ARGS__)
template <class T> void UNIQUE(vector<T> &x) {
sort(all(x)); x.erase(unique(all(x)), x.end());
}
template <class T> void print_vec(T first, T end){
for (auto i = first; i < end - 1; i++) cout << *i << " ";
cout << *(end-1) << endl;
}
template<class... T>
void debug_print(T... args){
vector<lint> tmp = initializer_list<lint>{args...};
print_vec(all(tmp));
}
template<class T>
void print(T a){ cout << a << endl;}
vector<string> Yes = {"No", "Yes"};
vector<string> YES = {"NO", "YES"};
int ord(char x){ return (int)(x - 'a');}
char chr(lint x){ return (char)(x + (lint)('a'));}
lint mod = 1e9+7;
// lint mod =
lint sum(vlint a){lint ret = 0; for(auto&& v:a) ret += v; return ret;}
lint vmini(vlint a, lint &index){
lint ret = LLONG_MAX;
rep(i, Size(a)){ if (chmin(ret, a[i])) index = i;}
return ret;
}
lint vmaxi(vlint a, lint &index){
lint ret = -LLONG_MAX;
rep(i, Size(a)){ if (chmax(ret, a[i])) index = i;}
return ret;
}
lint vmin(vlint a){
lint ret = LLONG_MAX; for (auto && v : a) chmin(ret, v); return ret;
}
lint vmax(vlint a){
lint ret = -LLONG_MAX; for (auto && v : a) chmax(ret, v); return ret;
}
int main(){
INT(n); STR(s);
vlint leftw(n+1, 0), rightw(n+1, 0);
vlint lefte(n+1, 0), righte(n+1, 0);
rep(i, n){
if (s[i] == 'W'){
leftw[i] ++;
}
else{
lefte[i] ++;
}
leftw[i+1] += leftw[i]; lefte[i+1] += lefte[i];
}
for (int i = n-1; i > 0; --i){
if (s[i] == 'W'){
rightw[i]++;
}
else{
righte[i]++;
}
rightw[i-1] += righte[i];
righte[i-1] += righte[i];
}
lint ans = 2 * n;
rep1(i, n-1){
chmin(ans, leftw[i-1] + righte[i+1]);
}
chmin(ans, righte[1]); chmin(ans, leftw[n-2]);
print(ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve () {
long long n;
cin >> n;
long long mn = 1e15 + 1;
long long pos = 0;
for (int i = 0; i < 5; i++) {
long long x;
cin >> x;
if (mn > x) {
pos = i;
mn = x;
}
}
cout << (n % mn > 0) + (n / mn) + (4ll - pos) + pos;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| #include <bits/stdc++.h>
#define REP(i,n) for (int i = 0; i <(n); ++i)
#define ALL(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main(){
int h1, m1, h2, m2, k;
cin >> h1 >> m1 >> h2 >> m2 >> k;
int hour;
int min;
int t1, t2, t3;
t3 = h2 * 60 + m2;
t2 = t3 - k;
t1 = h1 * 60 + m1;
int ans;
ans = t2 - t1;
cout << ans << endl;
} | 0 |
#include <iostream>
#include <string>
#include <cstdlib>
#include <cstdio>
#include <cstring>
using namespace std;
#define ref goto refrain
int main(){
char str[1000];
cin>>str;
int q;
cin>>q;
string order;
int a,b;
char rep[1000];
for(int i=0;i<q;i++){
cin>>order;
cin>>a;
cin>>b;
if(order=="replace"){
cin>>rep;
for(int j=0;a<=b;j++){
str[a]=rep[j];
a++;
}
}
else if(order=="reverse"){
while(a<=b){
char temp=str[a];
str[a]=str[b];
str[b]=temp;
a++;
b--;
}
}
else if(order=="print"){
for(a=a;a<=b;a++){
printf("%c",str[a]);
}
cout<<endl;
}
}
return 0;
}
| #include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int main(){
int a,b;
string s;
vector<char> lst(10);
cin>>a>>b>>s;
bool ans=true;
// for(int i=0;i<s.size();i++){
// cin>>lst.at(i);
// {
for(int i=0;i<s.size();i++){
if (i!=a && s[i]=='-'){
ans=false;
break;
}
if (i==a && s[i]!='-'){
ans=false;
break;
}
}
if(ans==true){
cout<<"Yes"<<endl;
}else{
cout<<"No"<<endl;
}
return 0;
} | 0 |
// 2020-09-14 20:57:26
// clang-format off
#include<bits/stdc++.h>
#ifdef LOCAL
#include "lib/debug.hpp"
#else
#define debug(...) 1
#endif
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#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>;
using P = pair<int, int>;
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; }
// clang-format on
void answer() {
int n;
cin >> n;
vector<int> a(n), b(n);
rep(i, n) cin >> a[i];
rep(i, n) cin >> b[i];
int d = 0;
rep(ai, n) {
auto itr = lower_bound(ALL(b), a[ai]);
if (itr != b.end() && a[ai] == *itr) {
chmax(d, ai - int(itr - b.begin() - 1));
}
}
bool ok = true;
rep(i, n) ok &= (a[i] != b[(n + i - d) % n]);
if (ok) {
cout << "Yes" << '\n';
rep(i, n) {
if (i) cout << ' ';
cout << b[(n + i - d) % n];
}
cout << '\n';
} else {
cout << "No" << '\n';
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
answer();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll MOD = 1e9+7;
constexpr ll INF = 1ll<<60;
#define FOR(i,a,b) for (ll i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
int main(int argc, char **argv)
{
ll N; cin >> N;
ll MAX = 1;
ll WOM = 2;
vector<string> isu(N);
string S;
ll l = 0;
ll r = N-1;
std::cout << l << std::endl;
cin >> S;
if (S == "Vacant") return 0;
isu[l] = S;
while (true)
{
if (r - l <= 1)
{
std::cout << r << std::endl;
cin >> S;
if (S == "Vacant") return 0;
}
ll mid = (l + r) / 2;
std::cout << mid << std::endl;
cin >> S;
if (S == "Vacant") return 0;
isu[mid] = S;
ll diff = mid - l - 1;;
if (diff % 2 == 0)
{
if (isu[l] == isu[mid])
{
r = mid - 1;
}
else
{
l = mid;
}
}
else
{
if (isu[l] == isu[mid])
{
l = mid;
}
else
{
r = mid - 1;
}
}
}
}
| 0 |
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long int llint;
llint v[1000005],dp[1000005],n;
int x[25][25];
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
cin >> x[i][j];
}
}
for(int i=0;i<(1 << n);i++) {
for(int j=0;j<n;j++) {
for(int k=j+1;k<n;k++) {
v[i]+=((i & (1 << j)) && (i & (1 << k)))*x[j][k];
}
}
}
for(int i=0;i<(1 << n);i++) {
dp[i]=max(dp[i],v[i]);
for(int j=i;j>0;j=(j-1) & i) {
dp[i]=max(dp[i],dp[j]+dp[i ^ j]);
}
}
cout << dp[(1 << n)-1];
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
const ll MAXN = 303;
ll dp[MAXN][MAXN*MAXN];
main(){
int n;
cin >> n;
ll arr[n];
int S = 0;
for(int i=0;i<n;++i){
cin >> arr[i];
S += arr[i];
}
fill(&dp[0][0], &dp[0][0] + MAXN*MAXN*MAXN, 0);
dp[0][0] = 1;
for(auto i=0;i<n;++i){
for(auto j=0;j<MAXN*MAXN;++j){
dp[i+1][j+arr[i]] += dp[i][j];
dp[i+1][j+arr[i]]%=MOD;
dp[i+1][j] += 2LL*dp[i][j];
dp[i+1][j]%=MOD;
}
}
ll K = 0;
for(auto i=(S+1)/2;i<=S;++i){
K += dp[n][i];
}
fill(&dp[0][0], &dp[0][0] + MAXN*MAXN*MAXN, 0);
dp[0][0] = 1;
ll L = 0;
if(S%2==0){
for(auto i=0;i<n;++i){
for(auto j=0;j<MAXN*MAXN;++j){
dp[i+1][j+arr[i]] += dp[i][j];
dp[i+1][j+arr[i]]%=MOD;
dp[i+1][j] += dp[i][j];
dp[i+1][j]%=MOD;
}
}
L = dp[n][S/2];
}
ll ans = 1;
for(int i=0;i<n;++i){
ans *= 3LL;
ans %= MOD;
}
ans += MOD - (3*K)%MOD;
ans %=MOD;
ans += 3*L;
ans %=MOD;
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef vector<string>vst;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
#define fastio ios_base::sync_with_stdio(false);cin.tie(0)
#define all(ct) ct.begin() , ct.end()
#define endl "\n"
#define fr(i,a) for(auto i:a)
#define f(i,a,b) for(int i=a;i<b;++i)
#define fd(i,a,b) for(int i=a;i>=b;--i)
#define pb push_back
#define in(d,v) d.find(v)!=d.end()
#define mp make_pair
#define size(a) int(a.size())
const int mod = 1e9 + 7;
const ll inf = ll(1e18);
const double PI = acos(-1);
ll modexp(ll x,ll n,int md){
if(n==0)return 1;
if(n%2==0)return modexp((x*x)%md,n/2,md);
return (x*modexp((x*x)%md,n/2,md))%md;
}
set<int> g[200001];
int main(){
fastio;
//clock_t tm = clock();
int n;
cin>>n;
vi a(n),b(n),na(n+1,0),nb(n+1,0);
priority_queue<pii>g1;
f(i,0,n){
cin>>a[i];na[a[i]]++;
g[a[i]].insert(i);
}
f(i,0,n){
cin>>b[i];nb[b[i]]++;
}
priority_queue<pii>g2;
f(i,1,n+1){
if(na[i]+nb[i]>n){
cout<<"No"<<endl;
return 0;
}
if(nb[i]>0){
g2.push({nb[i],-i});
}
if(na[i]>0){
g1.push({na[i],i});
}
}
reverse(all(b));
vi ans(n,0);
while(!g2.empty()){
auto pr=g2.top();
g2.pop();
if(pr.first>1){
--pr.first;
g2.push(pr);
}
pr.second*=-1;
auto qr=g1.top();
g1.pop();
if(qr.second!=pr.second) {
if (qr.first > 1) {
--qr.first;
g1.push(qr);
}
ans[*g[qr.second].begin()]=pr.second;
g[qr.second].erase(*g[qr.second].begin());
}
else{
if(g1.empty())break;
auto qr1=g1.top();
g1.pop();g1.push(qr);qr=qr1;
if (qr.first > 1) {
--qr.first;
g1.push(qr);
}
ans[*g[qr.second].begin()]=pr.second;
g[qr.second].erase(*g[qr.second].begin());
}
}
cout<<"Yes"<<endl;
fr(i,ans)cout<<i<<" ";
cout<<endl;
//cout<<((clock()-tm)*1.0)/CLOCKS_PER_SEC<<endl;
} | #include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll=long long;
using ld=long double;
//#define int long long
#define _CRT_SECURE_NO_WARNINGS
#define rep(i, n) for (int i = 0; i < n; i++)
#define _GLIBCXX_DEBUG
#define ALL(x) (x).begin(), (x).end()
const int MOD = 1e9 + 7;
const int INF = 1e18 + 9;
constexpr long double pi = 3.141592653589793238462643383279;
int fact(int i) {
if (i == 0) return 1;
return (fact(i - 1)) * i;
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
int keta(int n) {
if (n == 0) return 1;
int count = 0;
while (n != 0) {
n /= 10;
count++;
}
return count;
}
int ketasum(int n) {
int sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
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;
}
char toSmall(char c) { // 大文字を小文字へ
return (c + 0x20);
}
char toLarge(char c) { // 小文字を大文字へ
return (c - 0x20);
}
float myPower(int a, int n) { // aのn乗の計算
float x = 1;
while (n > 0) { // 全てのbitが捨てられるまで
if (n & 1) { // 一番右のbitが１のとき
x *= a;
}
a *= a;
n >>= 1; // bit全体を右に1つシフトして一番右を捨てる
}
return x;
}
bool is_prime(const unsigned n) {
switch (n) {
case 0: // fall-through
case 1: return false;
case 2: // fall-through
case 3: return true;
} // n > 3 が保証された
if (n % 2 == 0 || n % 3 == 0) return false;
// n は 2 と 3 のいずれの倍数でもないことが保証された
// これより n は (6の倍数)-1 か (6の倍数)+1 である
// 6の倍数前後の数を使って試し割りをする
for (unsigned i = 5; i * i <= n; i += 6) {
if (n % i == 0) return false; // (6の倍数)-1
if (n % (i + 2) == 0) return false; // (6の倍数)+1
}
return true;
}
int main(void){
int saidai = 0;
int N;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++) cin >> s[i];
int M;
cin >> M;
vector<string> t(M);
for (int i = 0; i < M; i++) cin >> t[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;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using LL = long long;
using P = pair<int,int>;
int main(){
int N, K;
cin >> N >> K;
int ans = 0;
for(int i = 1; i <= N - K + 1; ++i) {
ans++;
}
cout << ans << endl;
}
| #include <stdio.h>
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <cstdlib>
#include <list>
#include <numeric>
#include <map>
#define rep(i,n) for(int i=0;i<n;i++)
#define all(x) (x).begin(),(x).end()
using namespace std;
//================================================
int a = 0, b = 0, c, d, n, k=0;
string s, t;
long long kaizyou(int x)
{
if (x == 1)
return 1;
else
return x * kaizyou(x - 1);
}
int main()
{
cin >> n >> k;
cout << n-k+1 << endl;
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
int H, W;
vector<string> fi;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
cin >> H >> W;
fi.resize(H);
for (int i = 0; i < H; ++i) cin >> fi[i];
// 多点をスタートとして扱う
vector<vector<int> > dist(H, vector<int>(W, -1));
using pint = pair<int,int>;
queue<pint> que;
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) {
if (fi[i][j] == '#') {
dist[i][j] = 0;
que.push(pint(i, j));
}
}
}
// BFS
while (!que.empty()) {
auto cur = que.front();
que.pop();
for (int dir = 0; dir < 4; ++dir) {
int nx = cur.first + dx[dir];
int ny = cur.second + dy[dir];
if (nx < 0 || nx >= H || ny < 0 || ny >= W) continue;
if (dist[nx][ny] == -1) {
dist[nx][ny] = dist[cur.first][cur.second] + 1;
que.push(pint(nx, ny));
}
}
}
int res = 0;
for (int i = 0; i < H; ++i) {
for (int j = 0; j < W; ++j) {
res = max(res, dist[i][j]);
}
}
cout << res << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
//#define int long long
//signed main(){
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int h,w;
cin >> h >> w;
vector<bool> a(h*w,false);
queue<int> que;
for(int i = 0; i < h; i++) {
string tmp;
cin >> tmp;
for(int j = 0; j < w; j++) {
int idx=i*w+j;
if(tmp[j]=='#'){
a[idx]=true;
que.push(idx);
}
}
}
int cnt=0;
int ans=0;
while(cnt<h*w) {
int n=que.size();
cnt+=n;
for(int i = 0; i < n; i++) {
int idx=que.front();
int add[4]={1,-1,w,-w};
for(int j = 0; j < 4; j++) {
int t=idx+add[j];
int r=idx/w+add[j]/w;
int c=idx%w+add[j]%w;
if(r<0||r>=h||c<0||c>=w||a[t]==true) continue;
a[t]=true;
que.push(t);
}
que.pop();
}
ans++;
}
cout << ans-1 << "\n";
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const long long r = 1e9 + 7;
long long fac[200001];
long long f(long long a, long long p) {
if (p == 1)
return a;
long long ret = f(a, p / 2);
ret = ret * ret % r;
if (p % 2 == 1)
ret = ret * a % r;
return ret;
}
long long c(int n, int m) {
return fac[n] * f(fac[m] * fac[n - m] % r, r - 2) % r;
}
int main() {
fac[0] = 1;
for (int i = 1; i <= 200000; ++i)
fac[i] = fac[i - 1] * i % r;
int n, m, a, b;
scanf("%d %d %d %d", &n, &m, &a, &b);
a = n - a;
long long ans = 0;
for (int i = 1; i <= a; ++i)
ans = (ans + c(b + i - 2, b - 1) * c(m - b + n - i - 1, n - i) % r) % r;
printf("%lld", ans);
return 0;
} | #include <bits/stdc++.h>
#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define endl "\n"
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
const double PI = 3.14159265358979;
void solve()
{
int h1, m1, h2, m2, k;
cin >> h1 >> m1 >> h2 >> m2 >> k;
cout << (h2 * 60 + m2) - (h1 * 60 + m1) - k;
}
int main()
{
fastio;
solve();
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
void solve(){
ll n;
cin>>n;
ll k,p,x,ans;
ans = (n*(n+1))/2;
k = n/3;
p = n/5;
x = n/15;
ans = ans - 3*(k*(k+1)/2) - 5*(p*(p+1))/2 + 15*(x*(x+1))/2;
cout<<ans<<endl;
}
int main()
{
solve();
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
const long long inf=0x3f3f3f3f;
long long bs[maxn];
long long d,dx1[maxn],dx2[maxn];
long long a[maxn],an,ans;
void dfs(long long x,long long v,long long c)
{
if(x==an)
{
ans+=(v==d)*c;
return ;
}
if(abs(v-d)>a[x]*20)
return ;
for(long long i=0;i<20;i++)
{
long long cnt;
if(x==0)
cnt=dx1[i];
else
cnt=dx2[i];
if(a[x]==0)
cnt=i<10;
if(cnt==0)
continue;
dfs(x+1,v+(i-10)*a[x],c*cnt);
}
}
void solve(long long n)
{
an=0;
for(long long i=0;i<n;i++)
{
if(i>n-i-1)
break;
a[an++]=bs[n-i-1]-bs[i];
}
dfs(0,0,1);
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
for(long long i=0;i<=9;i++)
for(long long j=0;j<=9;j++)
dx2[i-j+10]++;
for(long long i=0;i<=9;i++)
for(long long j=1;j<=9;j++)
dx1[i-j+10]++;
bs[0]=1;
for(long long i=1;i<19;i++)
bs[i]=bs[i-1]*10;
cin>>d;
for(long long i=1;i<=19;i++)
solve(i);
cout<<ans<<endl;
return 0;
}
| 0 |
#include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const double PI = 3.1415926535897932;
/* a と b の最大公約数を返す関数 */
long long GCD(long long a, long long b) {
if (b == 0) return a;
else return GCD(b, a % b);
}
int main()
{
int N, K;
cin >> N >> K;
vector<int> Li(N, 0);
rep(i, N) cin >> Li.at(i);
sort(Li.begin(), Li.end());
reverse(Li.begin(), Li.end());
int ans = 0;
rep(i, K)
{
ans += Li.at(i);
}
cout << ans << endl;
return 0;
} | #include<stdio.h>
#include<iostream>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<algorithm>
#include<string.h>
#include<functional>
#include<limits.h>
#include<stdlib.h>
#include<cmath>
#include<cstring>
#include<set>
#include<climits>
#include<deque>
#include<cstdio>
using namespace std;
#define intmax INT_MAX
#define lmax LONG_MAX
#define uintmax UINT_MAX
#define ulmax ULONG_MAX
#define llmax LLONG_MAX
#define ll long long
#define rep(i,a,N) for((i)=(a);(i)<(N);(i)++)
#define rrp(i,N,a) for((i)=(N)-1;(i)>=(a);(i)--)
#define llfor ll i,j
#define sc(a) cin>>a
#define pr(a) cout<<a<<endl
#define pY puts("YES")
#define pN puts("NO")
#define py puts("Yes")
#define pn puts("No")
#define pnn printf("\n")
#define all(a) a.begin(),a.end()
#define push(a,b) (a).push_back(b)
#define llvec vector<vector<ll>>
#define charvec vector<vector<char>>
#define size(a,b) (a,vector<ll>(b))
#define llpvec vector<pair<ll,ll>>
/*pi*/const double pi=acos(-1);
/*繰り上げ除算*/ll cei(ll x,ll y){ll ans=x/y;if(x%y!=0)ans++;return ans;}
/*最大公約数*/ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
/*最小公倍数*/ll lcm(ll x,ll y){return x/gcd(x,y)*y;}
/*n乗*/ll llpow(ll x,ll n){ll i,ans=1;rep(i,0,n)ans*=x;return ans;}
/*階乗*/ll fact(ll x){ll i,ans=1;rep(i,0,x)ans*=(x-i);return ans;}
/*nCr*/ll ncr(ll n,ll r){return fact(n)/fact(r)/fact(n-r);}
/*nPr*/ll npr(ll n,ll r){return fact(n)/fact(n-r);}
/*primejudge*/bool prime(ll a){if(a<=1)return false;ll i;for(i=2;i*i<=a;i++){if(a%i==0)return false;}return true;}
/*Fibonacci数列*/ll fib(ll x){ll i,fibo[x+10];fibo[0]=1;fibo[1]=1;fibo[2]=1;rep(i,3,x+1)fibo[i]=fibo[i-1]+fibo[i-2];return fibo[x];}
/*桁数*/ll dig(ll n){ll d=0,i=0;while(n/10>0){i++;d++;}return d;}
llfor;ll ans=0;////////////////////////////////////////////////////////////
int main(){
ll a,b;
cin>>a>>b;
ans=1;
ll m=gcd(a,b);
ll tmp=m;
for(i=2;i*i<=m;++i){
if(tmp%i==0){
// cout<<i<<" "<<tmp<<" "<<ans<<endl;
ans++;
}
while(tmp%i==0)tmp/=i;
if(tmp==1)break;
}
if(tmp!=1)ans++;
pr(ans);
return 0;}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
float D, T, S;
cin >> D >> T >> S;
if((D/S) <= T)
cout << "Yes\n";
else
cout << "No\n";
}
| #include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pqueue priority_queue
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
int A, B;
cin>>A>>B;
string S;
cin>>S;
string tmp1=S.substr(0, A), tmp2=S.substr(A+1, B);
bool can = true;
for(int i=0;i<tmp1.size();++i) {
if(tmp1[i]=='-') can = false;
}
if(S[A]!='-') can = false;
for(int i=0;i<tmp2.size();++i) {
if(tmp2[i]=='-') can = false;
}
if(can) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
| 0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <cassert>
using namespace std;
string s,t;
int dp[310][310][310] = {};
int main(){
int i,j,l,n,k;
cin >> s >> k; n = s.size();
for(i=0;i<n;i++){
t.push_back(s[n - 1 - i]);
}
for(i=1;i<=n;i++){
for(j=1;j<=n;j++){
for(l=0;l<=k;l++){
if(s[i - 1]==t[j - 1]){
dp[i][j][l] = dp[i - 1][j - 1][l] + 1;
}else{
int x = max(dp[i - 1][j][l],dp[i][j - 1][l]);
if(l>0) x = max(x,dp[i - 1][j - 1][l - 1] + 1);
dp[i][j][l] = x;
}
}
}
}
int ans = 0;
for(i=0;i<n;i++){
ans = max(ans,2*dp[i][n - i][k]);
ans = max(ans,2*dp[i][n - 1 - i][k] + 1);
}
cout << ans << endl;
} | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;
#define rint register int
#define gc() getchar()
inline int read(rint ans = 0, rint sgn = ' ', rint ch = gc())
{
for(; ch < '0' || ch > '9'; sgn = ch, ch = gc());
for(; ch >='0' && ch <='9';(ans*=10)+=ch-'0', ch = gc());
return sgn-'-'?ans:-ans;
}
char T[305]; int n, K, f[305][305][305]; inline int Cmax(int &x, int v){x < v ? x = v : 0;}
int main()
{
scanf("%s",T+1), n = strlen(T+1), K = read();
for(rint i = 1, k; i <= n; i++) for(k = 0; k <= K; f[i][i][k] = 1, k++);
for(rint d = 2, l, r, k; d <= n; d++)
for(l = 1, r = d; r <= n; l++, r++)
for(k = 0; k <= K; k++)
{
Cmax(f[l][r][k],f[l][r-1][k]);
Cmax(f[l][r][k],f[l+1][r][k]);
T[l]==T[r] ? Cmax(f[l][r][k],f[l+1][r-1][k]+2) : 0;
k ? Cmax(f[l][r][k],f[l+1][r-1][k-1]+2) : 0;
k ? Cmax(f[l][r][k],f[l][r][k-1]) : 0;
} printf("%d\n",f[1][n][K]); return 0;
} | 1 |
#include <bits/stdc++.h>
#define repp(i,l,r)for(long long i=(l);i<(r);i++)
#define rep(i,n) for (long long i = 0; i < (n); ++i)
#define per(i,n) for (long long i = (n); i >= 0; --i)
const int INF = 2147483647;//int max
const long long int MOD = 1000000007;
using namespace std;
using ll = long long;
using P = pair<int,int>;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
//ミョ(-ω- ?)
int main() {
ll n;
cin >> n;
vector<ll> a(n,0);
rep(i,n)cin >> a[i];
map<ll,ll> odds;
for(ll i = 0;i < n;i+=2)odds[a[i]]++;
pair<ll,ll> of = {0,0};
pair<ll,ll> os = {0,0};
for(auto t : odds){
if(t.second > of.second){
os = of;
of = t;
continue;
}else if(t.second > os.second){
os = t;
continue;
}
}
map<ll,ll> even;
for(ll i = 1;i < n;i+=2)even[a[i]]++;
ll e = 0;
pair<ll,ll> ef = {0,0};
pair<ll,ll> es = {0,0};
for(auto t : even){
if(t.second > ef.second){
es = ef;
ef = t;
continue;
}else if(t.second > es.second){
es = t;
continue;
}
}
if(of.first != ef.first){
cout << (n/2 - of.second) + (n/2 - ef.second) << "\n";
}else{
cout << min((n/2 - os.second)+(n/2 - ef.second) , (n/2 - of.second) + (n/2 - es.second)) << "\n";
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for(int (i)=0; (i)<(n); (i)++)
#define FILL0(x) memset(x,0,sizeof(x))
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
int n;
cin >> n;
vector<int> v[2];
rep(i, n)
{
int tmp;
cin >> tmp;
v[i%2].push_back(tmp);
}
if(n==2)
{
if(v[0][0]==v[1][0])
{
cout << 1 << endl;
}
else
{
cout << 0 << endl;
}
}
int tab0[100010];
FILL0(tab0);
rep(i, v[0].size())
{
tab0[v[0][i]]++;
}
vector<P> freq0;
rep(i, 100001)
{
if(tab0[i]!=0)
{
freq0.push_back(P(tab0[i], i));
}
}
int tab1[100010];
FILL0(tab1);
rep(i, v[1].size())
{
tab1[v[1][i]]++;
}
vector<P> freq1;
rep(i, 100001)
{
if(tab1[i]!=0)
{
freq1.push_back(P(tab1[i], i));
}
}
sort(freq0.begin(), freq0.end());
reverse(freq0.begin(), freq0.end());
sort(freq1.begin(), freq1.end());
reverse(freq1.begin(), freq1.end());
if(freq0[0].second==freq1[0].second)
{
if(freq0[0].first-freq0[1].first>freq1[0].first-freq1[1].first)
{
cout << n-(freq0[0].first+freq1[1].first) << endl;
}
else
{
cout << n-(freq1[0].first+freq0[1].first) << endl;
}
}
else
{
cout << n-(freq0[0].first+freq1[0].first) << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9+7;
const ll INF = 1e18;
#define rep(i,m,n) for(ll i = (m); i <= (n); i++)
#define zep(i,m,n) for(ll i = (m); i < (n); i++)
#define rrep(i,m,n) for(ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x,m,n) for(ll i = (m); i <= n; i++){cout << (x[i]) << " ";} cout<<endl;
int main(){
cin.tie(0); ios::sync_with_stdio(false);
ll n, lbuf, rbuf, mi;
cin >> n;
P lr[n];
ll ans = 0;
zep(i, 0, n){
cin >> lbuf >> rbuf;
lr[i] = P(rbuf, lbuf);
if(rbuf-lbuf+1 > ans){
ans = rbuf-lbuf+1;
mi = i;
}
}
ll lm = 0;
ll rm = 1e9;
zep(i, 0, n){
if(i != mi){
lm = max(lr[i].second, lm);
rm = min(lr[i].first, rm);
}
}
ans += max(rm-lm+1, 0LL);
sort(lr, lr+n);
zep(i, 0, n){
ll tmp = lr[i].first;
lr[i].first = lr[i].second;
lr[i].second = tmp;
}
ll al[n], dl[n], ar[n], dr[n];
al[0] = lr[0].first;
ar[0] = lr[0].second;
zep(i, 1, n){
al[i] = max(lr[i].first, al[i-1]);
ar[i] = min(lr[i].second, ar[i-1]);
}
dl[n-1] = lr[n-1].first;
dr[n-1] = lr[n-1].second;
rrep(i, n-2, 0){
dl[i] = max(lr[i].first, dl[i+1]);
dr[i] = min(lr[i].second, dr[i+1]);
}
zep(i, 0, n-1){
ans = max(ar[i]-al[i]+1+dr[i+1]-dl[i+1]+1, ans);
}
print(ans)
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define re register
#define ll long long
#define int ll
#define get getchar()
#define in inline
in int read()
{
int t=0; char ch=get;
while(ch<'0' || ch>'9') ch=get;
while(ch<='9' && ch>='0') t=t*10+ch-'0', ch=get;
return t;
}
const int _=2e5+5;
int n,q,A,B,x[_];
ll lazy[_<<4],min1[_<<4],min2[_<<4];
in void pushdown(int k)
{
if(lazy[k]==0) return ;
int x=lazy[k];
lazy[k]=0;
lazy[k<<1]+=x;
lazy[k<<1|1]+=x;
min1[k<<1]+=x;
min1[k<<1|1]+=x;
min2[k<<1]+=x;
min2[k<<1|1]+=x;
}
in void update(int k,int l,int r,int x,int y)
{
if(l==r)
{
min1[k]=min(min1[k],(ll)(y-l));
min2[k]=min(min2[k],(ll)(y+l));
return;
}
pushdown(k);
int mid=l+r>>1;
if(x<=mid) update(k<<1,l,mid,x,y);
else update(k<<1|1,mid+1,r,x,y);
min1[k]=min(min1[k<<1],min1[k<<1|1]);
min2[k]=min(min2[k<<1],min2[k<<1|1]);
}
/*#define ls(_o) (_o << 1)
#define rs(_o) ((_o << 1) | 1)
ll query1(int rl, int rr, int l, int r, int tree) {
if (rl == l && rr == r)
return (min1[tree]);
int mid = (l + r) >> 1;
pushdown(tree);
if (rl > mid)
return (query1(rl, rr, mid + 1, r, rs(tree)));
if (rr <= mid)
return (query1(rl, rr, l, mid, ls(tree)));
return (min(query1(rl, mid, l, mid, ls(tree)), query1(mid + 1, rr, mid + 1, r, rs(tree))));
}
ll query2(int rl, int rr, int l, int r, int tree) {
if (rl == l && rr == r)
return (min2[tree]);
int mid = (l + r) >> 1;
pushdown(tree);
if (rl > mid)
return (query2(rl, rr, mid + 1, r, rs(tree)));
if (rr <= mid)
return (query2(rl, rr, l, mid, ls(tree)));
return (min(query2(rl, mid, l, mid, ls(tree)), query2(mid + 1, rr, mid + 1, r, rs(tree))));
}*/
in int query1(int k,int l,int r,int x,int y)
{
// cout<<1<<":: "<<k<<' '<<l<<' '<<r<<' '<<x<<' '<<y<<endl;
if(l==x && r==y) return min1[k];
pushdown(k);
int mid=l+r>>1,minn=0x3f3f3f3f;
if(y<=mid) return query1(k<<1,l,mid,x,y);
if(x>mid) return query1(k<<1|1,mid+1,r,x,y);
return min(query1(k<<1,l,mid,x,mid),query1(k<<1|1,mid+1,r,mid+1,y));
}
in int query2(int k,int l,int r,int x,int y)
{
// cout<<2<<":: "<<k<<' '<<l<<' '<<r<<' '<<x<<' '<<y<<endl;
if(l==x && r==y) return min2[k];
pushdown(k);
int mid=l+r>>1,minn=0x3f3f3f3f;
if(y<=mid) return query2(k<<1,l,mid,x,y);
if(x>mid) return query2(k<<1|1,mid+1,r,x,y);
return min(query2(k<<1,l,mid,x,mid),query2(k<<1|1,mid+1,r,mid+1,y));
}
in int getans(int k,int l,int r)
{
if(l==r) return min1[k]+l;
pushdown(k);
int mid=l+r>>1;
return min(getans(k<<1,l,mid), getans(k<<1|1,mid+1,r));
}
signed main()
{
n=read(),q=read(),A=read(),B=read();
x[0]=A;
memset(min1,0x3f,sizeof(min1));
memset(min2,0x3f,sizeof(min2));
update(1,1,n,B,0);
for(re int i=1;i<=q;i++)
{
x[i]=read();
//int qwe=min(query1(1, x[i], 1, n, 1) + x[i], query2(x[i], n, 1, n, 1) - x[i]);
int qwe=min(query1(1,1,n,1,x[i])+x[i],query2(1,1,n,x[i],n)-x[i]);
lazy[1]+=abs(x[i]-x[i-1]);
min1[1]+=abs(x[i]-x[i-1]);
min2[1]+=abs(x[i]-x[i-1]);
update(1,1,n,x[i-1],qwe);
}
cout<<getans(1,1,n);
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
using lli = long long;
#define rep(i,n) for(int i=0;i<n;i++)
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
lli n;
int main(void){
cin >> n;
vector<vector<pair<lli, lli>>> t(n);
rep(i, n){
lli ai;
cin >> ai;
rep(j, ai){
lli x, y;
cin >> x >> y;
t[i].push_back({x-1, y});
}
}
lli ans = 0;
rep(b, (1<<n)){
bool ok = true;
rep(j, n){
if(b>>j&1){
rep(k, t[j].size()){
lli u = t[j][k].second;
lli v = b>>t[j][k].first&1;
if(u != v){
ok = false;
}
}
}
}
if(ok){
ans = max(ans, (lli)__builtin_popcount(b));
}
}
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <bitset>
#include <algorithm>
#include <complex>
#include <array>
#include <functional>
using namespace std;
#define REP(i,n) for(int i=0; i<n; ++i)
#define FOR(i,a,b) for(int i=a; i<=b; ++i)
#define FORR(i,a,b) for (int i=a; i>=b; --i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<double> VD;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef vector<VD> VVD;
typedef pair<int,int> P;
typedef pair<ll,ll> PL;
template<typename T> void chmin(T &a, T b) { if (a > b) a = b; }
template<typename T> void chmax(T &a, T b) { if (a < b) a = b; }
int in() { int x; scanf("%d", &x); return x; }
ll lin() { ll x; scanf("%lld", &x); return x; }
int main() {
int n;
cin >> n;
VVI x(n), y(n);
REP(i,n){
int a = in();
REP(j,a){
x[i].push_back(in() - 1);
y[i].push_back(in());
}
}
int ans = 0;
REP(mask,1<<n){
bool f = true;
int cnt = 0;
REP(i,n) if ((mask >> i) & 1) cnt++;
REP(i,n){
if (((mask >> i) & 1) == 0) continue;
REP(j,x[i].size()){
if (((mask >> x[i][j]) & 1) != y[i][j]) f = false;
}
}
if (f) chmax(ans, cnt);
}
cout << ans << endl;
return 0;
}
| 1 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
#include<string>
long long INF=1000000000000000000;
long long mod=1000000007;
using namespace std;
long long stair(int N){
long long i=1;
for(int k=2;k<=N;k++){
i*=k;
if(i>mod){
i%=mod;
}
}
return i;
}
int main(){
int N;
cin>>N;
string s;
cin>>s;
char white='W';
char black='B';
if(s[0]==white || s[2*N-1]==white){
cout<<"0"<<endl;
return 0;
}
bool LorR[2*N];
LorR[0]=false;//L=false,R=trueとする
for(int i=1;i<2*N;i++){
if(s[i-1]==s[i]){
LorR[i]=!LorR[i-1];
}
else{
LorR[i]=LorR[i-1];
}
}
int countL[2*N+1];//Lの個数の累積和
int countR[2*N+1];//Lの個数の累積和
countL[0]=0;
countR[0]=0;
for(int i=0;i<2*N;i++){
if(LorR[i]){
countR[i+1]=countR[i]+1;
countL[i+1]=countL[i];
}
else{
countR[i+1]=countR[i];
countL[i+1]=countL[i]+1;
}
}
if(countL[2*N]!=countR[2*N]){
cout<<"0"<<endl;
return 0;
}
long long ans=1;
for(int i=1;i<=2*N;i++){
if(LorR[i-1]){
if(countL[i]<countR[i]){
cout<<"0"<<endl;
return 0;
}
ans*=(countL[i]-countR[i-1]);
}
if(ans>mod){
ans%=mod;
}
}
//順列なのでnの階乗をかける
ans=(ans*stair(N))%mod;
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using i64 = std::int_fast64_t;
const int MOD = 1000000007;
template <typename T>
ostream &operator<<(ostream &os, const std::vector<T> &vec) {
for (const auto &e : vec) os << e << (&e == &vec.back() ? "\n" : " ");
return os;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int H, W, K;
cin >> H >> W >> K;
vector<vector<i64>> dp(H + 1, vector<i64>(W + 1, 0));
dp[0][0] = 1;
for (int h = 0; h < H; h++) {
for (int w = 0; w < W; w++) {
for (int bit = 0; bit < (1 << (W - 1)); bit++) {
auto check = [bit, W]() -> bool {
for (int b = 0; b < W - 2; b++) {
if ((bit >> b) & 1 && (bit >> (b + 1)) & 1) return false;
}
return true;
};
if (!check()) continue;
int nw = w;
if ((bit >> w) & 1) {
nw++;
} else if (w > 0 && (bit >> (w - 1)) & 1) {
nw--;
}
dp[h + 1][nw] = (dp[h + 1][nw] + dp[h][w]) % MOD;
}
}
}
cout << dp[H][K - 1] << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (ll i=0;i<(n);i++)
typedef long long ll;
ll modpow(ll a, ll n, ll mod){
ll res=1;
while(n>0){
if(n&1) res = res*a%mod;
a=a*a%mod;
n>>=1;
}
return res;
}
ll modinv(ll a, ll mod){
return modpow(a, mod-2, mod);
}
int main() {
ll N,M,K,ans;
cin>>N>>M>>K;
ll mod = 998244353;
ll kakuk = M*modpow(M-1,N-1,mod)%mod;
ans = kakuk;
ll gyakuM = modinv(M-1,mod);
rep(i,K){
kakuk = (kakuk * (N-i-1))%mod;
kakuk = (kakuk * modinv(i+1,mod))%mod;
kakuk = (kakuk * gyakuM)%mod;
ans += kakuk;
ans = ans%mod;
}
if(M==1&&N-1==K) cout << 1 << endl;
else cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll MOD = 1'000'000'007;
const ld PI = acos(-1);
const ld EPS = 0.0000000001;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define rep(i, n) for(ll i=0; i<(ll)(n); i++)
#define repd(i, n) for(ll i=n-1; 0<=i; i--)
#define FOR(i, a, b) for(ll i=a; i<(ll)(b); i++)
#define FORD(i, a, b) for(ll i=b-1; (ll)(a)<=i; i--)
#define ALL(x) x.begin(), x.end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
class FactorialMod{
void calc_inverse(){
inverse[0] = 0;
inverse[1] = 1;
for(int i=2; i<=max_num; i++){
inverse[i] = md-((md/i)*inverse[md%i]%md);
}
}
void calc_factorial_inverse(){
factorial[0] = factorial_inverse[0] = 1;
for (int i=1; i<=max_num; i++) {
factorial[i] = (factorial[i-1]*i)%md;
factorial_inverse[i] = (factorial_inverse[i-1]*inverse[i])%md;
}
}
public:
ll max_num, md;
vector<ll> inverse;
vector<ll> factorial;
vector<ll> factorial_inverse;
FactorialMod(ll _max_num, ll _md=MOD){
max_num = _max_num;
md = _md;
inverse = vector<ll>(max_num+1);
factorial = vector<ll>(max_num+1);
factorial_inverse = vector<ll>(max_num+1);
calc_inverse();
calc_factorial_inverse();
}
ll combination(int n, int k){
return (((factorial[n]*factorial_inverse[k])%md)*factorial_inverse[n-k])%md;
}
ll multiChoose(int n, int k){
return combination(n+k-1, k);
}
};
ll modpow(ll x, ll n, ll md=MOD){
ll res=1, dig=x;
while(n){
if(n&1) res = res*dig%md;
dig = dig*dig%md;
n /= 2;
}
return res;
}
ll comb(ll N_, ll C_, ll mo) {
const int NUM_=400001;
static ll fact[NUM_+1],factr[NUM_+1],inv[NUM_+1];
if (fact[0]==0) {
inv[1]=fact[0]=factr[0]=1;
for (int i=2;i<=NUM_;++i) inv[i] = inv[mo % i] * (mo - mo / i) % mo;
for (int i=1;i<=NUM_;++i) fact[i]=fact[i-1]*i%mo, factr[i]=factr[i-1]*inv[i]%mo;
}
if(C_<0 || C_>N_) return 0;
return factr[C_]*fact[N_]%mo*factr[N_-C_]%mo;
}
int main(){
ll n, m, k; cin >> n >> m >> k;
//重複組み合わせは配列倍(n+k)にする
ll mod = 998244353, res=0;
FactorialMod calc_mod(n, mod);
rep(i, k+1){
res += m*calc_mod.combination(n-1, i)%mod*modpow(m-1, n-1-i, mod)%mod;
res %= mod;
}
cout << res << endl;
} | 1 |
#include <iostream>
#include <vector>
#include <algorithm>
int main()
{
int n = 1;
std::cin >> n;
while (n)
{
std::vector<int32_t> num_list{};
while (n--)
{
int tmp = 0;
std::cin >> tmp;
num_list.push_back(tmp);
}
std::vector<int32_t> comfarm_list{};
std::vector<int32_t> sum_list{};
for( auto num : num_list )
{
for (auto& sum : sum_list)
{
if (num < 0)
{
comfarm_list.push_back(sum);
}
sum += num;
}
sum_list.push_back(num);
}
for (auto sum : sum_list)
{
comfarm_list.push_back(sum);
}
int32_t max_sum = *( std::max_element(comfarm_list.begin(),comfarm_list.end()) );
std::cout << max_sum << std::endl;
std::cin >> n;
}
return 0;
} | #include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
int main() {
int n,i,j,d,m[11][11];
while(cin >> n) {
if (n==0) break;
memset(m,0,sizeof(m));
for (i=0;i<n;i++) for (j=0;j<n;j++) {
cin >> d;
m[i][j]=d; m[i][n]+=d; m[n][j]+=d; m[n][n]+=d;
}
for (i=0;i<=n;i++) {
for (j=0;j<=n;j++) printf("%5d",m[i][j]);
printf("\n");
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define int long long
#define double long double
using namespace std;
const int MOD = 1000000007;
const int INF = 1e18;
using Graph = vector<vector<int>>;
signed main() {
int N, T;
cin >> N >> T;
vector<pair<int, int>> dish(N);
for( int i = 0; i < N; i++ ){
int A, B;
cin >> A >> B;
dish[i] = make_pair(A, B);
}
sort(dish.begin(), dish.end());
vector<int> dp(10000);
dp[0] = 0;
for( int i = 0; i < N; i++ ){
for( int j = T-1; j >= 0; j-- ){
int A = dish[i].first;
int B = dish[i].second;
dp[j+A] = max(dp[j+A], dp[j]+B);
}
}
int ans = 0;
for( int i = 0; i < 10000; i++ ){
ans = max(ans, dp[i]);
}
cout << ans << endl;
}
| #include<bits/stdc++.h>
using namespace std;
#define N 2005
int n,m,f[N][N],L[N],R[N],ans,stk[N];
bool a[N][N];
char s[N];
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=n;i;--i){
for (int j=1;j<m;++j)
if ((a[i][j]^a[i][j+1])==(a[i+1][j]^a[i+1][j+1])) f[i][j]=f[i+1][j]+1;
else f[i][j]=1;
}
ans=n;
for (int i=1;i<=n;++i){
int tp=0; stk[tp]=0;
for (int j=1;j<m;++j){
for (;tp&&f[i][j]<f[i][stk[tp]];--tp);
L[j]=stk[tp];
stk[++tp]=j;
}
tp=0; stk[tp]=m;
for (int j=m-1;j;--j){
for (;tp&&f[i][j]<=f[i][stk[tp]];--tp);
R[j]=stk[tp];
stk[++tp]=j;
}
for (int j=1;j<m;++j)
ans=max(ans,f[i][j]*(R[j]-L[j]));
}
printf("%d\n",ans);
return 0;
}
| 0 |
#include <iostream>
#include <vector>
#include<algorithm>
#include<iomanip>
#include<queue>
#include<map>
#include<bitset>
#include<math.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define REP(i,m,n) for(int i=m;i<(int)(n);i++)
typedef pair<int,int> pint;
typedef long long ll;
const int inf = 1e9+7;
const ll longinf = 1LL<<60;
const int mod=1e9+7;
int dx[4]={1,0,-1,0}, dy[4]={0,1,0,-1};
ll dp[300001][3][3];
ll all[300001];
int m,s[300003];
string t;
ll rec(int n,int a,int b){
if(dp[n][a][b]!=-1)return dp[n][a][b];
ll ret=0;
if(a!=0&&b!=0)ret+=all[n+2];
if(a!=0&&b!=1){
if(n==m-3)ret+=rec(n+2,s[n+2],0);
else {
if(s[n+2]!=0)ret+=rec(n+2,1,s[n+3]);
if(s[n+2]!=1)ret+=rec(n+2,1,0)*max(s[n+3],1);
}
}
if(a!=1&&b!=0)
ret=(ret+rec(n+2,s[n+2],s[n+3]))%mod;
if(a!=1&&b!=1)
ret=(ret+rec(n+2,0,s[n+3])*max(s[n+2],1))%mod;
return dp[n][a][b]=ret%mod;
}
int main(){
cin>>t;
m=t.size();
rep(i,m){
if(t[i]=='0')s[i]=0;
if(t[i]=='1')s[i]=1;
if(t[i]=='?')s[i]=2;
}
s[m]=0;
rep(i,m+1)rep(j,3)rep(k,3){
dp[i][j][k]=-1;
}
dp[m-1][0][0]=0;
dp[m-1][2][0]=1;
dp[m-1][1][0]=1;
all[m]=1;
rep(i,m){
if(s[m-i-1]==2)all[m-i-1]=2*all[m-i]%mod;
else all[m-i-1]=all[m-i];
}
cout<<rec(0,s[0],s[1])<<endl;
return 0;
} | #include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
using namespace std;
#define int long long
const int N = 3e5 + 5 , mod = 1e9 + 7;
//void add(int &x , int y){
// x += y;
// if(x >= mod)
// x -= mod;
//}
char s[N];
long long n , ans;
long long f[N][3][3];
void add(long long &a, long long b) {
a += b, ((a > mod) ? (a -= mod) : 0);
}
main() {
scanf("%s", s + 1);
n = strlen(s + 1);
f[0][0][0] = 1;
for(int i = 0; i < n; i++) {
for(int j = 0; j < 3; j++) {
for(int k = 0; k < 3; k++) {
if(s[i + 1] != '0') {
if(k)
add(f[i + 1][j][k - 1], f[i][j][k]);
else add(f[i + 1][min(j + 1, (long long)2)][k], f[i][j][k]);
}
if(s[i + 1] != '1') {
if(k == 2)
add(f[i + 1][j][1], f[i][j][k]);
else add(f[i + 1][j][k + 1], f[i][j][k]);
}
}
}
}
for(int i = 0; i < 3; i++)
for(int j = 0; j <= i; j++)
add(ans, f[n][i][j]);
cout << ans;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main(){
int l, r;
cin >> l >> r;
if(r - l >= 2019) cout << 0 << endl;
else{
vector<int> n;
for(int i = l; i <= r; i++){
n.push_back(i % 2019);
}
vector<int> m;
rep(i,n.size()){
for(int j = i+1; j < n.size(); j++) m.push_back((n[i]*n[j])%2019);
}
sort(m.begin(), m.end());
cout << m[0] << endl;
}
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define chmax(x,y) x = max(x,y);
const int INF = 1001001001;
int main() {
ll l, r;
cin >> l >> r;
r = min(l+2019, r);
ll ans = INF;
for (ll i = l; i <= r; i++) {
for (ll j = i+1; j <= r; j++) {
//i = i%2019;
//j = j%2019;
ans = min(ans, (i*j)%2019);
}
}
cout << ans << endl;
return 0;
} | 1 |
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
#include <iostream>
#include <string>
#include <vector>
#include <stdio.h>
#include <algorithm>
#include <cassert>
#include <unordered_set>
#include <unordered_map>
#include <set>
#include <map>
#include <queue>
#include <random>
#include <numeric>
#include <time.h>
#include <stack>
#include <bitset>
#define prev asasddlsa
#define rank aljds
#define rep(i, l, r) for (int i = l; i < r; i++)
#define repb(i, r, l) for (int i = r; i >= l; i++)
using namespace std;
typedef long long ll;
typedef double dbl;
template<typename T>
void print(const vector<T>& s){
for (auto x : s)
cout << x << " ";
cout << endl;
}
template<class T>
void print(const T* s, int n){
for (int i = 0; i < n; i++)
cout << s[i] << ' ';
cout << endl;
}
template<class T>
void print(vector<vector<T>> s){
for (int i = 0; i < s.size(); i++)
print(s[i]);
}
int solve(){
int n;
cin >> n;
vector<int> s(2 * n);
for (int& x : s)
cin >> x;
sort(s.begin(), s.end());
int res = 0;
for (int i = 0; i < 2 * n; i += 2){
res += s[i];
}
cout << res << endl;
return 0;
}
int main(){
srand(time(NULL));
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(10);
cout << fixed;
int t = 1;
// cin >> t;
while (t--)
solve();
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll maxSubarrayXOR(ll a[], int n) {
int index = 0;
for(int i = 60; i >= 0; i--) {
int pos = index;
int f = 0;
for(int j = index; j < n; j++) {
if(a[j] & (1LL << i)) f = 1, pos = j;
}
if(!f) continue;
swap(a[index], a[pos]);
for(int j = 0; j < n; j++) {
if(j != index && (a[j] & (1LL << i))) a[j] ^= a[index];
}
index++;
}
ll res = 0;
for(int i = 0; i < n; i++) res ^= a[i];
return res;
}
int n;
ll a[100010], ans = 0;
int main() {
cin >> n;
for(int i = 0; i < n; i++) {
scanf("%lld", a+i);
ans ^= a[i];
}
for(int i = 0; i < n; i++) a[i] &= ~ans;
cout << ans + 2*maxSubarrayXOR(a, n);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int a[26];
for (int i = 0; i < 26; i++) a[i] = 0;
bool occur = true;
cin >> s;
for (int i = 0; i < s.size(); i++)
{
a[s[i] - 97]++;
}
for (int i = 0; i < 26; i++)
{
if (a[i] == 0)
{
occur = false;
cout << char(i + 97);
break;
}
}
if (occur == true) cout << "None";
} | #include <bits/stdc++.h>
#define PI 3.14159265359
#define NIL -1
using namespace std;
const int64_t MOD = 1e9 + 7;
int main() {
string S;
cin >> S;
vector<bool> v(26);
for (int i = 0; i < S.size(); i++) {
char ch = S.at(i);
int n = (int)ch - 97;
v.at(n) = 1;
}
string ans = "None";
for (int i = 0; i < 26; i++) {
if (v.at(i) == 0) {
ans = (char)i + 97;
break;
}
}
cout << ans << endl;
} | 1 |
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0;i<(int)(n);i++)
using namespace std;
using ll=long long;
int main(){
int n,m;
cin>>n>>m;
string ans{};
rep(i,n) ans.push_back('a');
bool err=false;
rep(i,m){
int s;
char c;
cin>>s>>c;
s--;
if(ans[s]=='a'||ans[s]==c){
ans[s]=c;
}else{
err=true;
}
}
if(ans[0]=='0'&&n>1) err=true;
rep(i,n){
if(ans[i]=='a'){
if(i==0&&n>1) ans[i]='1';
else ans[i]='0';
}
}
if(!err) cout<<ans<<endl;
else cout<<-1<<endl;
} | #include<cmath>
#include<queue>
#include<vector>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define INF 1000005
#define MAXN 500000
int read()
{
int f=1,x=0;char s=getchar();
while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
return x*f;
}
struct node{
int key;
node *ch[2],*fa;
};
node tree[MAXN+5];
node *Root,*NIL,*ncnt;
void Init()
{
NIL=&tree[0];
NIL->fa=NIL->ch[0]=NIL->ch[1]=NIL;
ncnt=&tree[1];
Root=NIL;
return ;
}
inline node *NewNode(int val)
{//插入新的?点
node *p=++ncnt;
p->key=val;
p->fa=p->ch[0]=p->ch[1]=NIL;
return p;
}
void Insert(node *&rt,node *fa,int val)
{//插入(?造二叉排序?)
if(rt==NIL)
{
rt=NewNode(val);
rt->fa=fa;
return ;
}
int d=(val>=rt->key);
Insert(rt->ch[d],rt,val);
return ;
}
void InOrder(node *rt)
{//?出
if(rt==NIL) return ;
InOrder(rt->ch[0]);
printf(" %d",rt->key);
InOrder(rt->ch[1]);
return ;
}
void PreOrder(node *rt)
{//?出
if(rt==NIL) return ;
printf(" %d",rt->key);
PreOrder(rt->ch[0]);
PreOrder(rt->ch[1]);
return ;
}
node *Find(node *rt,int val)
{//找一?在??中
if(rt==NIL) return NIL;
if(rt->key==val) return rt;
int d=(val>=rt->key);
return Find(rt->ch[d],val);
}
node *FindNext(node *rt)
{
if(rt==NIL) return NIL;
node *y=rt->ch[1];
while(y->ch[0]!=NIL)
y=y->ch[0];
return y;
}
void Delete(node *rt,int val)
{
node *x,*y,*z=Find(rt,val);
if(z==NIL) return ;
if(z->ch[0]==NIL||z->ch[1]==NIL)
y=z;
else
y=FindNext(z);
if(y->ch[0]!=NIL)
x=y->ch[0];
else
x=y->ch[1];
if(x!=NIL)
x->fa=y->fa;
if(y->fa==NIL)
Root=x;
else
{
int d=(y==y->fa->ch[1]);
y->fa->ch[d]=x;
}
if(y!=z)
z->key=y->key;
return ;
}
int main()
{
int n=read(),x;
char op[20];
Init();
for(int i=1;i<=n;i++)
{
scanf("%s",op);
if(op[0]=='i')
{
x=read();
Insert(Root,NIL,x);
}
else if(op[0]=='f')
{
x=read();
if(Find(Root,x)==NIL)
printf("no\n");
else
printf("yes\n");
}
else if(op[0]=='d')
{
x=read();
Delete(Root,x);
}
else
{
InOrder(Root);
puts("");
PreOrder(Root);
puts("");
}
}
return 0;
} | 0 |
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
// Acknowledgement: Special thanks to kyomukyomupurin, who developed this
// template.
template <class T, class U>
std::ostream& operator<<(std::ostream& os, const std::pair<T, U>& p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <class T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& vec) {
int n = 0;
for (auto e : vec) os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T>
std::ostream& operator<<(std::ostream& os, const std::set<T>& st) {
int n = 0;
for (auto e : st) os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T, class U>
std::ostream& operator<<(std::ostream& os, const std::map<T, U>& mp) {
int n = 0;
for (auto e : mp) os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T>
std::istream& operator>>(std::istream& is, std::vector<T>& vec) {
for (T& e : vec) is >> e;
return is;
}
#ifdef LOCAL
#define debug(...) \
std::cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
void debug_out() { std::cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head&& head, Tail&&... tail) {
std::cerr << head;
if (sizeof...(Tail) != 0) std::cerr << ", ";
debug_out(std::forward<Tail>(tail)...);
}
using namespace std;
using int64 = long long;
int main() {
int H, W;
cin >> H >> W;
vector<vector<int>> a(H, vector<int>(W));
for (int i = 0; i < H; i++) {
cin >> a[i];
}
int n = 0;
string ans = "";
vector<int> od_row_idx;
for (int i = 0; i < H; i++) {
vector<int> od_idx;
for (int j = 0; j < W; j++) {
if (a[i][j] % 2 == 1) {
od_idx.push_back(j);
}
}
debug(od_idx);
if ((int)od_idx.size() == 0) continue;
for (int j = 0; j < (int)od_idx.size() - 1; j += 2) {
for (int k = od_idx[j]; k < od_idx[j + 1]; k++) {
ans += to_string(i + 1) + ' ' + to_string(k + 1) + ' ' +
to_string(i + 1) + ' ' + to_string(k + 2) + '\n';
n++;
}
}
if ((int)od_idx.size() % 2 == 1) {
for (int k = od_idx.back(); k < W - 1; k++) {
ans += to_string(i + 1) + ' ' + to_string(k + 1) + ' ' +
to_string(i + 1) + ' ' + to_string(k + 2) + '\n';
n++;
}
od_row_idx.push_back(i);
}
}
if ((int)od_row_idx.size() > 1) {
for (int j = 0; j < (int)od_row_idx.size() - 1; j += 2) {
for (int k = od_row_idx[j]; k < od_row_idx[j + 1]; k++) {
ans += to_string(k + 1) + ' ' + to_string(W) + ' ' + to_string(k + 2) +
' ' + to_string(W) + '\n';
n++;
}
}
}
cout << n << endl;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define repd(i, a, b) for (ll i = (a); i < (b); i++)
#define repb(i, n) for (ll i = (n)-1; i >= 0; i--)
#define rep(i, n) repd(i, 0, n)
using namespace std;
using ll = long long;
using ul = unsigned long long;
using ld = long double;
ll mod = 1000000007;
int main() {
ll h, w;
cin >> h >> w;
ll a[h][w];
rep(i, h) {
rep(j, w) { cin >> a[i][j]; }
}
vector<pair<pair<ll, ll>, pair<ll, ll>>> ans;
rep(i, h) {
rep(j, w - 1) {
if (a[i][j] % 2 == 0) {
continue;
}
a[i][j + 1]++;
pair<ll, ll> before, after;
before = make_pair(i, j);
after = make_pair(i, j + 1);
ans.push_back(make_pair(before, after));
}
}
rep(i, h - 1) {
if (a[i][w - 1] % 2 == 0) {
continue;
}
a[i + 1][w - 1]++;
pair<ll, ll> before, after;
before = make_pair(i, w - 1);
after = make_pair(i + 1, w - 1);
ans.push_back(make_pair(before, after));
}
cout << ans.size() << endl;
for (auto p : ans) {
cout << p.first.first + 1 << " " << p.first.second + 1 << " "
<< p.second.first + 1 << " " << p.second.second + 1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,s,n) for (int i = (s); i < (n); i++)
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n+2, 0);
rep(i,1,n+1) cin >> a[i];
int k = 0;
rep(i,0,n+1) {
k += abs(a[i] - a[i+1]);
}
rep(i,1,n+1) {
int ans = k - abs(a[i-1] - a[i]) - abs(a[i] - a[i+1]);
ans += abs(a[i-1] - a[i+1]);
cout << ans << "\n";
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define Rep(n) for (ll _ = 0; _ < (ll)(n); _++)
int main(){
int n; cin >> n;
vector<int> a(n);
rep(i,n) cin >> a[i];
deque<int> d;
rep(j,n){
int i = lower_bound(d.begin(), d.end(), a[j]) - d.begin();
if(i == 0){
d.push_front(a[j]);
}else{
d[i-1] = a[j];
}
}
int ans = d.size();
cout << ans << endl;
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
typedef pair<int, int> P;
const int INF = 1 << 24;
int c[200][200];
int t[200][200];
int cost[200][200];
int tim[200][200];
int main(){
int n, m, K;
int p, q, r;
while(cin >> n >> m && (n || m)){
fill(&cost[0][0], &cost[199][199] + 1, INF);
fill(&tim[0][0], &tim[199][199] + 1, INF);
for(int i = 1; i <= m; i++){
cost[i][i] = tim[i][i] = 0;
c[i][i] = t[i][i] = 0;
}
for(int i = 0; i < n; i++){
int a, b;
int d, e;
cin >> a >> b;
cin >> d >> e;
cost[b][a] = min(cost[b][a], d);
cost[a][b] = min(cost[a][b], d);
tim[b][a] = min(tim[b][a], e);
tim[a][b] = min(tim[a][b], e);
}
for(int k = 1; k <= m; k++){
for(int i = 1; i <= m; i++){
for(int j = 1; j <= m; j++){
if(cost[i][j] > cost[i][k] + cost[k][j]){
cost[i][j] = cost[i][k] + cost[k][j];
}
if(tim[i][j] > tim[i][k] + tim[k][j]){
tim[i][j] = tim[i][k] + tim[k][j];
}
}
}
}
cin >> K;
for(int i = 0; i < K; i++){
cin >> p >> q >> r;
if(!r){
cout << cost[p][q] << endl;
}else{
cout << tim[p][q] << endl;
}
}
}
return 0;
}
| #include <iostream>
#include<algorithm>
#include <vector>
#include <functional>
#include <limits.h>
template<typename T, typename S>
struct LazySegTree{
int size;
std::vector<T> nod;
std::vector<S> monoid;
std::vector<bool> flag;
T t0;
S s0;
std::function<T(T,T)> operation;
std::function<S(S,S)> merge;
std::function<T(T,S,int)> calc;
LazySegTree(int n, T _t0, S _s0, std::function<T(T,T)> _operation, std::function<S(S,S)> _merge, std::function<T(T,S,int)> _calc){
t0 = _t0;
s0 = _s0;
operation = _operation;
merge = _merge;
calc = _calc;
size = 1;
while(n > size) size *= 2;
nod = std::vector<T> (size*2-1, t0);
monoid = std::vector<S> (size*2-1, s0);
flag = std::vector<bool> (size*2-1);
}
void disassembly(int k, int l, int r){
if(r-l>1){
monoid[k*2+1] = merge(monoid[k*2+1], monoid[k]);
monoid[k*2+2] = merge(monoid[k*2+2], monoid[k]);
flag[k*2+1] = true;
flag[k*2+2] = true;
}
nod[k] = calc(nod[k],monoid[k],r-l);
monoid[k] = s0;
flag[k] = false;
}
S update_query(int a,int b,int k,int l,int r,S x){
//[a,b)について
//kは節点の番号,[l,r)はその節点がカバーする範囲
if(r<=a||b<=l){ //[a,b)と[l,r)が重なって無いとき
if(flag[k]) return calc(nod[k], monoid[k], r-l);
return nod[k];
}
if(a<=l && r<=b){ //[a,b)が[l,r)を完全に含んでいるとき
monoid[k] = merge(monoid[k], x);
flag[k] = true;
return calc(nod[k], monoid[k],r-l);
}
else{
if(flag[k]) disassembly(k,l,r);
nod[k] = operation(update_query(a,b,k*2+1,l,(l+r)/2,x), update_query(a,b,k*2+2,(l+r)/2,r,x));
return nod[k];
}
}
void update(int a, int b, S x){
// [a,b)をxに更新
update_query(a,b,0,0,size,x);
}
T sum_query(int a,int b,int k,int l,int r){
if(r<=a||b<=l){
return t0;
}
if(a<=l && r<=b){
if(flag[k]) return calc(nod[k],monoid[k],r-l);
else return nod[k];
}
if(flag[k]) disassembly(k, l, r);
return operation(sum_query(a,b,k*2+1,l,(l+r)/2),sum_query(a,b,k*2+2,(l+r)/2,r));
}
T sum(int a, int b){
return sum_query(a,b,0,0,size);
}
void deb(){ //全ノードの出力
for(int i=0;i<size*2-1;i++){
if(i==size*2-2){
std::cout << nod[i] <<std:: endl;
}
else{
std::cout << nod[i] << ' ';
}
}
for(int i=0;i<size*2-1;i++){
if(i==size*2-2){
std::cout << monoid[i] <<std:: endl;
}
else{
std::cout << monoid[i] << ' ';
}
}
return;
}
};
int main(){
int n,q; std::cin >> n >> q;
std::vector<int> ans(0);
LazySegTree<long long, long long> lst(n,INT_MAX,0,[](long long a, long long b){return std::min(a,b);}, [](long long a, long long b){return b;},[](long long a, long long b, long long c){return b;});
for(int i= 0;i<q;i++){
int w; std::cin >> w;
if(w == 0){
int s,t,x; std::cin >> s >> t >> x;
lst.update(s, t+1, x);
}
else{
int s,t; std::cin >> s;
ans.push_back(lst.sum(s,s+1));
}
//lst.deb();
}
for(int i = 0;i<ans.size();i++) std::printf("%d\n", ans[i]);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
typedef pair<int, int> ii;
int n;
string ans, newans;
int main() {
cin.tie(0), ios::sync_with_stdio(0);
cin >> n;
cout << "0\n";
cout.flush();
cin >> ans;
if(ans == "Vacant"){
cout << "0\n";
cout.flush();
cin >> ans;
exit(0);
}
int pos = 0;
for(int i = 17; i >= 0; i--){
if(pos + (1 << i) < n){
cout << pos + (1 << i) << "\n";
cout.flush();
cin >> newans;
if(newans == "Vacant"){
cout << pos + (1 << i) << "\n";
cout.flush();
cin >> newans;
exit(0);
}
if(ans == newans)
pos += (1 << i);
}
}
cout << pos + 1 << "\n";
cout.flush();
cin >> newans;
exit(0);
}
| #include <iostream>
#include <string>
using namespace std;
int main()
{
int n;
cin >> n;
cout << 0 << endl;
string s;
cin >> s;
int a;
if (s == "Male") {
a = 1;
} else if (s == "Female") {
a = 0;
}
int l = 0, r = n;
while (s != "Vacant") {
int c = (l + r) / 2;
cout << c << endl;
cin >> s;
if (s == "Male") {
if (a) {
if (c & 1 == 1) {
r = c;
} else {
l = c;
}
} else {
if (c & 1 == 1) {
l = c;
} else {
r = c;
}
}
} else if (s == "Female") {
if (a) {
if (c & 1 == 1) {
l = c;
} else {
r = c;
}
} else {
if (c & 1 == 1) {
r = c;
} else {
l = c;
}
}
}
}
return 0;
} | 1 |
#include <iostream>
using namespace std;
int main()
{
int d;
while (cin >> d)
{
cout << 72000000 - 180000 * d + 100 * d * d << endl;
}
return 0;
} | #include<stdio.h>
int main()
{
int a,b,c,d,s,s1;
scanf("%d%d%d%d",&a,&b,&c,&d);
if(a<b)
s=a;
else
s=b;
if(c<d)
s1=c;
else
s1=d;
printf("%d\n",(s+s1));
} | 0 |
#include<bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
#define ll long long
#define rep(i,n) for(int i = 0; i < int(n); i++)
#define vi vector<int>
using namespace std;
const int INF = 1001001001;
const int MOD = 1e9+7;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
template<class T> inline bool chmax(T &a, const T &b){ if(a<b){ a=b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, const T &b){ if(b<a){ a=b; return 1; } return 0; }
int main(){
cin.tie(0), ios::sync_with_stdio(false);
string s; cin >> s;
ll n = s.size();
vector<ll> cnt(26);
rep(i,n) cnt[s[i]-'a']++;
ll ans = n*(n-1)/2+1;
rep(i,26) ans -= cnt[i]*(cnt[i]-1)/2;
cout << ans;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef vector<long long> vl;
typedef pair<long long, long long> pl;
typedef vector<vector<long long>> matrix;
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define all(c) c.begin(), c.end()
#define f(i,a,b) for(ll i=a; i<b; i++)
#define rep(i,n) f(i,0,n)
#define tr(c,i) for(typeof(c).begin() i = c.begin(); i != c.end(); i++)
#define present(c,x) (c.find(x) != c.end()) //for set and map
#define cpresent(c,x) (find(all(c),x) != c.end()) //for vectors
#define w(t) ll t; cin>>t; while(t--)
#define epsilon 1e-9
#define MOD (ll)1e9
void doublade() {
ios::sync_with_stdio(false); cin.tie(0); cout.precision(10);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
int main() {
doublade();
// w(t) {
ll n;
cin >> n;
ll p = n/500;
ll rs = 1000*p;
n -= p*500;
ll q = n/5;
rs += 5*q;
cout<<rs<<"\n";
// }
return 0;
} | 0 |
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
const int Mod=998244353;
int n,K;
#define Maxn 305
char S[Maxn];
int a[Maxn],cnt=0;
int dp[Maxn][Maxn][Maxn];
int main(){
scanf("%s",S+1);scanf("%d",&K);
n=strlen(S+1);
S[n+1]='0';
n++;
int lst=0;
for(int i=1;i<=n;++i)
if(S[i]=='0'){
a[++cnt]=i-lst-1;
lst=i;
}
reverse(a+1,a+cnt+1);
int sum=0;
dp[0][0][0]=1;
for(int i=0;i<cnt;++i){
for(int j=0;j<=sum;++j)
for(int k=0;k<=j;++k){
dp[i+1][j][k]=dp[i][j][k];
if(k){
dp[i+1][j][k]+=dp[i+1][j][k-1];
if(dp[i+1][j][k]>=Mod)dp[i+1][j][k]-=Mod;
}
}
for(int j=0;j<=sum;++j)
for(int k=0;k<=j;++k)
for(int l=1;l<=a[i+1];++l){
dp[i+1][j+l][k]+=dp[i][j][k];
if(dp[i+1][j+l][k]>=Mod)dp[i+1][j+l][k]-=Mod;
}
sum+=a[i+1];
}
int Ans=0;
for(int i=0;i<=min(K,sum);++i){
Ans+=dp[cnt][i][i];
if(Ans>=Mod)Ans-=Mod;
}
printf("%d\n",Ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,l,r) for(int i=(int)(l);i<(int)(r);i++)
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)x.size())
template<class T>bool chmax(T &a,T b){if(a<b){a=b;return 1;}return 0;}
template<class T>bool chmin(T &a,T b){if(a>b){a=b;return 1;}return 0;}
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
const int inf = 1LL<<60;
const int mod = 1e9 + 7;
const double eps = 1e-9;
/*{
}*/
signed main(){
int n;
string s;
cin >> n >> s;
vi a(2*n);
rep(i, 0, 2*n){
a[i] = ((s[i] == 'B') + (i%2 == 0)) % 2;
}
int ans = 1, cnt = 0;
rep(i, 0, 2*n){
if(a[i]){
(ans *= cnt) %= mod;
cnt--;
}else{
cnt++;
}
}
if(cnt) ans = 0;
rep(i, 1, n+1) (ans *= i) %= mod;
cout << ans << endl;
// rep(i, 0, 2*n) cout << a[i] << " ";
// cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define mod 1000000007
#define F first
#define S second
#define all(v) (v).begin(),v.end()
#define np next_permutation
using namespace std;
using vi=vector<int>;
#define rep(i,n) for(int i=0;i<n;i++)
#define reps(i,j,n) for(int i=j;i<=n;i++)
#define vii vector<vi>
#define vb vector<bool>
#define pr pair<int,int>
#define vl vector<ll>
#define eb emplace_back
#define umap unordered_map<ll,int>
const int N=(int)1e5+11;
int n,t;
string s;
void solve(){
cin>>n;
vl a(n);
for(int i=0;i<n;i++)
cin>>a[i];
cin>>s;
vl b;
for(int i=n-1;i>=0;i--){
ll v=a[i];
for(auto x:b){
if(v > (v^x))
v=v^x;
}
if(v){
if(s[i]=='1'){
cout<<1<<"\n";
return;
}
b.pb(v);
}
}
cout<<0<<"\n";
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
cin>>t;
while(t--) solve();
return 0;
}
| #include<bits/stdc++.h>
#define For(i,x,y) for (register int i=(x);i<=(y);i++)
#define FOR(i,x,y) for (register int i=(x);i<(y);i++)
#define Dow(i,x,y) for (register int i=(x);i>=(y);i--)
#define Debug(v) for (auto i:v) printf("%lld ",i);puts("")
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define ep emplace_back
#define siz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define fil(a,b) memset((a),(b),sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pa;
typedef pair<ll,ll> PA;
typedef vector<int> poly;
inline ll read(){
ll x=0,f=1;char c=getchar();
while ((c<'0'||c>'9')&&(c!='-')) c=getchar();
if (c=='-') f=-1,c=getchar();
while (c>='0'&&c<='9') x=x*10+c-'0',c=getchar();
return x*f;
}
const int N = 210;
int n;
ll a[N];
char s[N];
ll b[N];
inline void init(){
For(i,0,63) b[i]=0;
}
inline bool insert(ll x){
Dow(i,63,0) if (x&(1ll<<i)){
if (!b[i]) return b[i]=x,1;
else x^=b[i];
}
return 0;
}
inline void solve(){
n=read();
For(i,1,n) a[i]=read();
scanf("%s",s+1);
init();
Dow(i,n,1) if (s[i]=='0'){
insert(a[i]);
} else if (insert(a[i])) return puts("1"),void(0);
puts("0");
}
int main(){
int T=read();
while (T--) solve();
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const char* sol3[3]={"aab","c.b","cdd"};
const char* sol4[4]={"aacd","bbcd","efgg","efhh"};
const char* sol5[5]={"aabbc","dee.c","d..fg","h..fg","hiijj"};
const char* sol6[6]={"aabbc.","ddeec.",".f.g.h",".f.g.h","i.j.kk","i.j.ll"};
const char* sol7[7]={"aa.bb.c",".dd..ec","f.gg.e.","f...h.i",".j..h.i","kj..ll.","k.mm.nn"};
char ans[1005][1005];
int main() {
int n;
scanf("%d",&n);
if (n<=2) {
puts("-1");
return 0;
}
if (n==3) {
for(int i=0;i<3;i++) puts(sol3[i]);
return 0;
}
for(int i=0;i<n;i++)
for(int j=0;j<n;j++) ans[i][j]='.';
int d=0;
while (n-d>=8) {
for(int i=0;i<4;i++)
for(int j=0;j<4;j++) ans[d+i][d+j]=sol4[i][j];
d+=4;
}
if (n-d==4) {
for(int i=0;i<4;i++)
for(int j=0;j<4;j++) ans[d+i][d+j]=sol4[i][j];
}
else if (n-d==5) {
for(int i=0;i<5;i++)
for(int j=0;j<5;j++) ans[d+i][d+j]=sol5[i][j];
}
else if (n-d==6) {
for(int i=0;i<6;i++)
for(int j=0;j<6;j++) ans[d+i][d+j]=sol6[i][j];
}
else {
for(int i=0;i<7;i++)
for(int j=0;j<7;j++) ans[d+i][d+j]=sol7[i][j];
}
for(int i=0;i<n;i++) puts(ans[i]);
return 0;
} | #include <bits/stdc++.h>
#include <iostream>
#include <ctime>
using namespace std;
#define _LL long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define vecrep(itr, v) for (auto itr = (v).begin(); itr != (v).end(); itr++)
#define MMAX (1000*1000)
pair<int, int> _next[MMAX];
int _in[MMAX];
int _day[MMAX];
int getindex(int i, int j, int n)
{
return min(i, j) * n + max(i, j);
}
bool searchsub(int day, int next, queue<int> &q)
{
if( next < 0 ) return true;
_in[next]--;
_day[next] = max(_day[next], day);
if( _in[next] == 0 ) q.push(next);
return false;
}
int main()
{
int n; cin >> n;
vector<int> first(n);
rep(i, n * n) { _next[i].first = -1; _next[i].second = -1; _in[i] = 0; _day[i] = -1;}
rep(i, n)
{
int pre = -1;
rep(j, n - 1)
{
int a; cin >> a; a--;
int index = getindex(i, a, n);
if(j == 0)
{
first[i] = index;
}
else
{
if( _next[pre].first < 0 )
{
_next[pre].first = index;
}
else
{
_next[pre].second = index;
}
}
_in[index]++;
pre = index;
}
}
int ans = 0;
queue<int> q;
rep(i, n)
{
searchsub(1, first[i], q);
}
while(!q.empty())
{
int index = q.front();
q.pop();
ans = max(ans, _day[index]);
searchsub(_day[index] + 1, _next[index].first, q);
searchsub(_day[index] + 1, _next[index].second, q);
}
bool flag = false;
rep(i, n * n)
if( _in[i] > 0 ) flag = true;
if( flag )
{
cout << -1 << endl;
}
else
{
cout << ans << endl;
}
return 0;
} | 0 |
//In the name of GOD
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll maxn = 2e5 + 100;
const ll maxm = 1e6 + 100;
const ll mod = 1e9 + 7;
const ll inf = 1e18;
#define fast_io ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define file_io freopen("input.txt" , "r+" , stdin) ; freopen("output.txt" , "w+" , stdout);
#define pb push_back
#define Mp make_pair
#define pll pair<ll, ll>
#define F first
#define S second
ll n, m, t, d[maxm];
bool vis[maxm];
pair<pll, ll> e[maxn];
vector<ll> g[maxm], p[maxn], dsu[maxm], sz[maxm];
map<ll, ll> mp[maxn];
queue<ll> q;
ll root(ll c, ll v){
if(dsu[c][v] != v) dsu[c][v] = root(c, dsu[c][v]);
return dsu[c][v];
}
void Union(ll c, ll v, ll u){
v = root(c, v);
u = root(c, u);
if(v == u) return;
if(sz[c][v] < sz[c][u]) swap(v, u);
dsu[c][u] = v;
sz[c][v] += sz[c][u];
return;
}
int main(){
ll v, u, c;
fast_io;
cin >> n >> m;
for(ll i = 0; i < m; i++){
cin >> v >> u >> c;
p[v].pb(c);
p[u].pb(c);
if(mp[v][c] == 0){
dsu[c].pb(dsu[c].size());
sz[c].pb(1);
mp[v][c] = dsu[c].size();
}
if(mp[u][c] == 0){
dsu[c].pb(dsu[c].size());
sz[c].pb(1);
mp[u][c] = dsu[c].size();
}
e[i] = Mp(Mp(v, u), c);
}
for(ll i = 0; i < m; i++){
v = e[i].F.F;
u = e[i].F.S;
c = e[i].S;
Union(c, mp[v][c] - 1, mp[u][c] - 1);
}
t = n + 1;
for(ll i = 1; i < maxm; i++){
for(ll j = 0; j < dsu[i].size(); j++){
if(dsu[i][j] == j) sz[i][j] = t++;
}
}
for(ll i = 1; i <= n; i++){
for(ll j = 0; j < p[i].size(); j++){
g[i].pb(sz[p[i][j]][root(p[i][j], mp[i][p[i][j]] - 1ll)]);
g[sz[p[i][j]][root(p[i][j], mp[i][p[i][j]] - 1ll)]].pb(i);
}
}
q.push(1);
vis[1] = 1;
while(!q.empty()){
v = q.front();
q.pop();
for(ll i = 0; i < g[v].size(); i++){
u = g[v][i];
if(!vis[u]){
vis[u] = 1;
d[u] = d[v] + 1;
q.push(u);
}
}
}
if(!vis[n]) cout << -1;
else cout << d[n] / 2;
return 0;
}
| #include <bits/stdc++.h>
#define mod 1000000007
#define sp ' '
#define intmax 2147483647
#define llmax 9223372036854775807
#define nyan "(=^･ω･^=)"
#define mkp make_pair
#define lP pair<ll, ll>
#define iP pair<int,int>
typedef long long ll;
using namespace std;
int N, M, K, A, B, C, D[100000], vis[100000];
map<int, vector<pair<int,bool>>>v[100000];
queue<int>q;
void dfs(int x, int a, int t) {
vector<pair<int,bool>>&V = v[x][a];
for (int i = 0; i < V.size(); ++i) {
if (!V[i].second) {
V[i].second = true;
if (D[V[i].first] == t + 1 && vis[V[i].first] != a) {
vis[V[i].first] = a;
dfs(V[i].first, a, t);
}
if (D[V[i].first] == -1) {
D[V[i].first] = t + 1;
q.push(V[i].first);
dfs(V[i].first, a, t);
}
}
}
}
int main() {
cin >> N >> M;
while (M--) {
cin >> A >> B >> C;
--A;
--B;
v[A][C].push_back(mkp(B, false));
v[B][C].push_back(mkp(A, false));
}
memset(D, -1, sizeof D);
D[0] = 0;
q.push(0);
while (!q.empty()) {
int x = q.front();
q.pop();
for (auto it = v[x].begin(); it != v[x].end(); ++it) {
dfs(x, it->first, D[x]);
}
}
cout << D[N - 1] << endl;
}
| 1 |
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep(i,n) for(ll i=0;i<(n);i++)
#define pll pair<ll,ll>
#define pq priority_queue
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define ios ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define lb(c,x) distance(c.begin(),lower_bound(all(c),x))
#define ub(c,x) distance(c.begin(),upper_bound(all(c),x))
using namespace std;
template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
const ll mod=1e9+7;
int main()
{
ll n,m;
cin >> n >> m;
if(n%2==0 && n-2==2*m){
bool ok=false;
for(ll l=1,r=n;l<r;l++,r--){
if(r-l<=n/2 && ok==false){
r++;
ok=true;
continue;
}
cout << l << " " << r << endl;
}
}
else{
for(ll i=1;i<=m;i++){
cout << i << " " << n+1-i << endl;
}
}
return 0;
} | // #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; i < n; ++i)
#define REP(i, n) for (int i = 0; i < n; ++i)
#define range(i,a,b) ((a)<=(i) && (i)<(b))
#define debug(x) cout << #x << " = " << (x) << endl;
#define fs first
#define sc second
#define pb push_back
#define eb emplace_back
#define SP << " " <<
typedef long long ll;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
typedef vector<int> vec;
typedef vector<P> pvec;
typedef vector<vector<int>> vvec;
typedef vector<vector<P>> pvvec;
typedef priority_queue<int> PQI;
typedef priority_queue<P> PQP;
typedef priority_queue<int,vector<int>,greater<int>> PQIG;
typedef priority_queue<P,vector<P>,greater<P>> PQPG;
const vector<int> DX = {0, -1, 0, 1, 1, 1, -1, -1};
const vector<int> DY = {1, 0, -1, 0, 1, -1, 1, -1};
constexpr int MOD = (1000000007);
// const int MOD = (998244353);
// const int INF = (1 << 30); // 1073741824
const ll INF = (1LL << 60); // 1152921504606846976
const double PI = (3.141592653589794);
const double EPS = (0.0000000001); // 10^(-10)
template<class T> inline bool chmin(T& a, T b) {if (a > b) {a = b; return 1;} return 0;}
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b; return 1;} return 0;}
template<class T> inline T ceil(T a, T b) {return T((a + b - 1) / b);}
template<class T> inline T round(T a, T b) {return T(a / b);}
template< typename T1, typename T2 > istream &operator>>(istream &is, pair< T1, T2 > &p) { is >> p.first >> p.second; return is; }
template <class T> inline void out(T &a) { bool flag=true; for(auto&x:a){if(flag) {flag=false;} else{ cout << ' '; } cout<<x; } cout << endl; }
//----------------------------------------------------------------
int nmax=200000; // 2*(10^5)
vvec G(nmax);
void solve4ts()
{
int n,m;
cin>>n>>m;
int i1=1;
int i2=m+2;
for(int i=m;i>=1;i--){
cout<<i1<<" "<<i1+i<<endl;
i1++;
swap(i1,i2);
}
}
//-----------------------------------------------------------------
signed main(){ ios::sync_with_stdio(false); cin.tie(0); cout << fixed << setprecision(15);
int repeat = 1;
// cin >> repeat;
while(repeat--) solve4ts();
} | 1 |
#include <iostream>
#include <stdio.h>
#include <string>
#include <math.h>
#include <algorithm>
#include <vector>
#include <map>
#include <cstdio>
using namespace std;
int main(){
int a[12];
while(scanf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d"
,&a[0],&a[1],&a[2],&a[3],&a[4],&a[5],&a[6],&a[7],&a[8],&a[9],&a[10],&a[11]) != EOF){
int ans = 0;
double t = 0, d = 0;
int sum = 0;
for(int i = 0;i < 10;i++){
sum += a[i];
}
t = (double)sum / (a[10]+a[11]);
d = (double)a[10] * t;
sum = 0;
for(int i = 0;i < 10;i++){
sum += a[i];
if(sum >= d){
ans = i + 1;
break;
}
}
cout << ans << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#define MAX_N 100000
using namespace std;
struct Test
{
long long score, upper, lower;
long long sum();
};
Test tests[MAX_N];
long long cum[MAX_N + 1];
long long N, X;
long long aokiScore;
bool cmp( Test u, Test v ) { return u.sum() > v.sum(); }
long long Test::sum() { return upper * ( X - score ) + lower * score; }
bool isok( long long k )
{
long long q = k / X;
long long r = k % X;
if ( q == N ) return true;
long long total = cum[q];
for ( int i = 0; i < N; ++i )
{
long long tmp = total;
if ( i < q )
{
tmp -= tests[i].sum();
tmp += tests[q].sum();
}
tmp += min( r, tests[i].score ) * tests[i].lower;
tmp += max( 0LL, r - tests[i].score ) * tests[i].upper;
if ( tmp >= aokiScore ) return true;
}
return false;
}
int main()
{
N = 0;
aokiScore = 0;
cin >> N >> X;
for ( int i = 0; i < N; ++i )
{
cin >> tests[i].score >> tests[i].lower >> tests[i].upper;
aokiScore += tests[i].score * tests[i].lower;
}
sort( tests, tests + N, cmp );
for ( int i = 0; i < N; ++i ) cum[i + 1] = cum[i] + tests[i].sum();
long long l = 0;
long long r = N * X;
while ( l < r )
{
long long mid = ( l + r ) / 2;
if ( isok( mid ) )
r = mid;
else
l = mid + 1;
}
cout << l << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using WGraph = vector<vector<pair<int, ll>>>;
template<class T>inline bool chmax(T &a, const T &b) { if (b > a) { a = b; return true; } return false; }
template<class T>inline bool chmin(T &a, const T &b) { if (b < a) { a = b; return true; } return false; }
constexpr int dx[4] = {-1, 0, 0, 1}, dy[4] = {0, -1, 1, 0};
constexpr int INF = 1e9;
constexpr int MOD = 1e9 + 7;
constexpr long long LINF = 1e18;
constexpr double EPS = 1e-10;
constexpr double PI = M_PI;
std::map<long long, int> primeFact(long long n) {
std::map<long long, int> res;
for (long long i=2; i*i<=n; i++) {
while (n%i == 0) {
res[i]++;
n /= i;
}
}
if (n != 1) {
res[n] = 1;
}
return res;
}
long long inv(long long n) {
long long res = 1;
while (n > 1) {
res *= (MOD - MOD/n);
res %= MOD;
n = MOD % n;
}
return res;
}
void solve() {
int n;
ll m;
cin >> n >> m;
auto pf = primeFact(m);
vector<ll> comb(31);
ll nume = 1, deno = 1;
for (int i=0; i<31; ++i) {
comb.at(i) = nume * inv(deno) % MOD;
nume *= n+i;
nume %= MOD;
deno *= i+1;
deno %= MOD;
}
ll res = 1;
for (auto iter=pf.begin(); iter!=pf.end(); ++iter) {
res *= comb.at(iter->second);
res %= MOD;
}
cout << res << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N,K;
cin >> N >> K;
int sum = 1;
for(int i = 0; i < N; i++){
if((sum * 2) - (sum + K) > 0){
sum += K;
} else {
sum *= 2;
}
}
cout << sum << endl;
}
| 0 |
//#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
#define PI 3.14159265359
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
const long long INF= 1e+18+1;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll> >vvl;
typedef pair<ll,ll> P;
typedef tuple<ll,ll,ll> T;
const ll MOD=1000000007LL;
string abc="abcdefghijklmnopqrstuvwxyz";
string ABC="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int main(){
ll n,k;cin>>n>>k;
cout<<n-k+1<<endl;
} | #include <stdio.h>
#include <iostream>
#include <string>
#include <algorithm>
#define rep(index,max) for(int index=0;index<max;index++)
using namespace std;
int main(){
string s1,s2;
int l1,l2;
cin>>s1>>s2;
l1=s1.length();
l2=s2.length();
int dp[1010][1010];
rep(i,l1+1) dp[i][0]=i;
rep(j,l2+1) dp[0][j]=j;
rep(i,l1){
rep(j,l2){
if(s1[i]==s2[j]){
dp[i+1][j+1]=dp[i][j];
}
else{
dp[i+1][j+1]=min(min(dp[i+1][j],dp[i][j+1]),dp[i][j])+1;
}
}
}
cout<<dp[l1][l2]<<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(i,0,n)
#define ALL(a) (a).begin(),(a).end()
#define VI vector<int>
#define MOD 1000000007
typedef long long int ll;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const ll INF=(ll)1e19;
//const int INF=(1<<30);
int main(){
int k;
cin >> k;
VI col(8,-1);
REP(i,k){
int r, c;
cin>> r >> c;
col[c] = r;
}
VI a = {0,1,2,3,4,5,6,7};
VI ans;
do {
bool ok=true;
set<int> st;
REP(i,8){
if(col[i] != -1 && col[i] != a[i])ok=false;
}
if(!ok)continue;
ok=true;
REP(i,8){
FOR(j,i+1,8){
if(abs(i - j) == abs(a[i] - a[j]))ok=false;
}
}
if(ok){
ans = a;
break;
}
}while(next_permutation(ALL(a)));
REP(i,8){
REP(j,8){
if(ans[j]==i)cout << "Q";
else cout << ".";
}
cout << endl;
}
}
| // http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_13_A&lang=ja
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) FOR(i, 0, n)
#define REPR(i, n) for (int i = n - 1; i >= 0; i--)
#define FOR(i, s, n) for (int i = (s), i##_len = (n); i < i##_len; ++i)
// 盤面の縦横サイズ
const int SZ = 8;
// クイーンが配置可能かチェック
bool check(int row, int col, map<int, int> mp) {
bool ret = true;
REP(i, SZ) {
// 左上, 右上
if (mp.find(row - i) != mp.end()) {
int t = mp[row - i];
if (t == col - i || t == col + i) {
ret = false;
break;
}
}
// 左下, 右下
if (mp.find(row + i) != mp.end()) {
int t = mp[row + i];
if (t == col - i || t == col + i) {
ret = false;
break;
}
}
// 列
if (mp.find(i) != mp.end()) {
int t = mp[i];
if (t == col || t == col) {
ret = false;
break;
}
}
}
return ret;
}
// 深さ優先探索で配置可能な場所を探す。引数は行、配置済みのmap<行,列>
// 答えを出力したらtrueを返す。
bool dfs(int row, map<int, int> mp) {
// クイーンを8行配置した
if (row == SZ) {
// 正解パターンを出力
REP(row, SZ) {
// Queenが存在する列
int t = mp[row];
REP(col, t) { cout << "."; }
cout << "Q";
FOR(col, t + 1, SZ) { cout << "."; }
cout << "\n";
}
return true;
}
// その行にQueenが存在しなければ追加
if (mp.count(row) == 0) {
REP(col, SZ) {
if (check(row, col, mp)) {
mp[row] = col;
if (dfs(row + 1, mp)) {
return true;
}
}
}
} else {
if (dfs(row + 1, mp)) {
return true;
}
}
return false;
}
int main(void) {
int N;
cin >> N;
map<int, int> mp;
REP(i, N) {
int a, b;
cin >> a >> b;
mp[a] = b;
}
dfs(0, mp);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m; cin >> n >> m;
ll ansAC = 0;
ll ansWA = 0;
vector<bool> usedAC(n, false);
vector<int> cntWA(n, 0);
for (int i = 0; i < m; i++) {
int p; string s; cin >> p >> s;
--p;
if (s == "AC") {
if (usedAC[p]) {}
else {
usedAC[p] = true;
ansAC++;
}
}
else { // s == "WA"
if (usedAC[p]) {}
else {
cntWA[p]++;
}
}
}
for (int i = 0; i < n; i++) {
if (usedAC[i]) ansWA += cntWA[i];
}
cout << ansAC << " " << ansWA << endl;
return 0;
} | #include <iostream>
#include <string>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <ctime>
#include <queue>
#include <stack>
#include <functional>
#include <bitset>
#include <assert.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef pair<ll,ll> P;
typedef vector<P> vpl;
typedef tuple<ll,ll,ll> tapu;
#define rep(i,n) for(ll i=0; i<(n); i++)
#define REP(i,a,b) for(int i=(a); i<(b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1<<30;
const ll linf = 1LL<<62;
const int MAX = 510000;
ll dy[8] = {0,1,0,-1,1,-1,1,-1};
ll dx[8] = {1,0,-1,0,1,-1,-1,1};
const double pi = acos(-1);
const double eps = 1e-7;
template<typename T1,typename T2> inline bool chmin(T1 &a,T2 b){
if(a>b){
a = b; return true;
}
else return false;
}
template<typename T1,typename T2> inline bool chmax(T1 &a,T2 b){
if(a<b){
a = b; return true;
}
else return false;
}
template<typename T> inline void print(T &a){
rep(i,a.size()) cout << a[i] << " ";
cout << "\n";
}
template<typename T1,typename T2> inline void print2(T1 a, T2 b){cout << a << " " << b << "\n";}
template<typename T1,typename T2,typename T3> inline void print3(T1 a, T2 b, T3 c){
cout << a << " " << b << " " << c << "\n";
}
const int mod = 1e9 + 7;
//const int mod = 998244353;
template< typename G >
struct StronglyConnectedComponents {
const G &g;
vector<vector<int>> gg, rg;
vector< int > comp, order, used;
StronglyConnectedComponents(G &g) : g(g), gg(g.size()), rg(g.size()), comp(g.size(), -1), used(g.size()) {
for(int i = 0; i < g.size(); i++) {
for(auto e : g[i]) {
gg[i].emplace_back((int) e);
rg[(int) e].emplace_back(i);
}
}
}
int operator[](int k) {
return comp[k];
}
void dfs(int idx) {
if(used[idx]) return;
used[idx] = true;
for(int to : gg[idx]) dfs(to);
order.push_back(idx);
}
void rdfs(int idx, int cnt) {
if(comp[idx] != -1) return;
comp[idx] = cnt;
for(int to : rg[idx]) rdfs(to, cnt);
}
void build(vector<vector<int>> &t) {
for(int i = 0; i < gg.size(); i++) dfs(i);
reverse(begin(order), end(order));
int ptr = 0;
for(int i : order) if(comp[i] == -1) rdfs(i, ptr), ptr++;
t.resize(ptr);
for(int i = 0; i < g.size(); i++) {
for(auto &to : g[i]) {
int x = comp[i], y = comp[to];
if(x == y) continue;
t[x].push_back(y);
}
}
}
};
int main(){
ll n,m; cin >> n >> m;
vvl G(n);
vector<vector<int>> g;
rep(i,m){
ll s,t; cin >> s >> t;
G[s].push_back(t);
}
StronglyConnectedComponents<vvl> scc(G);
ll q; cin >> q;
scc.build(g);
while(q--){
ll u,v; cin >> u >> v;
cout << (scc[u] == scc[v]) << "\n";
}
}
| 0 |
#include<iostream>
using namespace std;
int main(){
int n,cnt=0,num=0;
int base[4]={0};
cin>>n;
string s;
while(1){
cin>>s;
if(s=="HIT"){
base[3]+=base[2];
base[2]=base[1];
base[1]=base[0];
base[0]=1;
}
if(s=="HOMERUN"){
for(int i=0;i<3;i++){
base[3]+=base[i];
base[i]=0;
}
base[3]++;
}
if(s=="OUT"){
cnt++;
}
if(cnt==3){
cout<<base[3]<<endl;
cnt=0;
num++;
base[0]=base[1]=base[2]=base[3]=0;
}
if(num==n)break;
}
return 0;
} | #include<stdio.h>
#include<string.h>
#include<math.h>
int main(void)
{
long long int g[1001],s[1001],d[1001],f[1001];
int j,i,k,a,h[1001];
while(1){
scanf("%d",&a);
if(a==0) break;
for(i=0;i<a;i++){
h[i]=0;
g[i]=0;
}
for(i=0;i<a;i++){
scanf("%lld %lld %lld",&s[i],&d[i],&f[i]);
if(d[i]*f[i]>=1000000) h[i]=1;
/*if(d[i]==1000000&&f[i]>=1) h[i]=1;
if(f[i]==100000&&d[i]>=10) h[i]=1;*/
if(h[i]==0) g[i]=d[i]*f[i];
else g[i]=0;
}
for(i=0;i<a;i++){
for(j=i+1;j<a;j++){
if(g[i]>=1000000&&h[i]==0){
h[i]=1;
}
if(s[i]==s[j]){
if(h[i]==0){
g[i]+=g[j];
g[j]=0;
}
else g[j]=0;
}
if(g[i]>=1000000&&h[i]==0){
h[i]=1;
}
}
}
k=0;
for(i=0;i<a;i++){
if(h[i]==1){
printf("%lld\n",s[i]);
k=1;
}
}
if(k==0) printf("NA\n");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main()
{
ll sx, sy, tx, ty;
cin >> sx >> sy >> tx >> ty;
string L;
string R;
rep(i, tx - sx)
{
L += 'L';
R += 'R';
}
string U;
string D;
rep(i, ty - sy)
{
U += 'U';
D += 'D';
}
string ans = R + U + L + D + 'D' + R + 'R' + U + 'U' + 'L' + 'U' + L + 'L' + D + 'D' + 'R';
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main(){
cin.tie(0)->sync_with_stdio(false);
int sx, sy, tx, ty;
cin >> sx >> sy >> tx >> ty;
int dy = ty - sy;
int dx = tx - sx;
REP(i, dy) cout << 'U';
REP(i, dx) cout << 'R';
REP(i, dy) cout << 'D';
REP(i, dx) cout << 'L';
cout << 'L';
REP(i, dy + 1) cout << 'U';
REP(i, dx + 1) cout << 'R';
cout << 'D';
cout << 'R';
REP(i, dy + 1) cout << 'D';
REP(i, dx + 1) cout << 'L';
cout << 'U';
cout << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main()
{
ll n,m;
cin >> n >> m;
ll p[m];
string s[m];
rep(i,m) cin >> p[i] >> s[i];
ll acnum[n+1];
for(ll i = 0; i < m; i++){
if(s[i] == "AC"){
acnum[p[i]] = 1;
}
}
ll ac = 0, wa = 0;
ll ok[n+1];
for(ll i = 1; i <= n; i++) ok[i] = 0;
for(ll i = 0; i < m; i++){
if(s[i] == "WA" && ok[p[i]] == 0 && acnum[p[i]] == 1){
wa++;
}
if(s[i] == "AC" && ok[p[i]] == 0){
ok[p[i]] = 1;
ac++;
}
}
cout << ac << " " << wa << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 100000000;
#define rep1(i, n) for (ll i=0; i<(n); i++)
#define rep2(i, k, n) for (ll i=k; i<(n); i++)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n, -1), s(n), c(n);
rep1(i, m) cin >> s[i] >> c[i];
rep1(i, m){
if (a[s[i]-1]!=-1 && a[s[i]-1]!=c[i]){
cout << -1 << endl;
return 0;
}
a[s[i]-1] = c[i];
}
if (a[0]==0 && n>1){
cout << -1 << endl;
return 0;
}
rep1(i, n){
if (i==0 && n>1){
if (a[i]==-1) cout << 1;
else cout << a[i];
}else{
if (a[i]==-1) cout << 0;
else cout << a[i];
}
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
const int N=4e5+5;
int n,m,ty,now,b[N],v[N],vi[N],nex[N],head[N];
void addedges(int x,int y){
nex[++now]=head[x];
head[x]=now,v[now]=y;
}
long long c,one,two;
void dfs(int x,int y){
vi[x]=y;
for(int i=head[x];i;i=nex[i])
if(!vi[v[i]]) dfs(v[i],y^1);
else if(vi[v[i]]==y) ty=1;
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++){
int x,y;
scanf("%d%d",&x,&y);
addedges(x,y),++b[x];
addedges(y,x),++b[y];
}
for(int i=1;i<=n;i++)
if(!vi[i]){
if(!b[i]) ++c;
else{
ty=0,dfs(i,2);
if(ty) ++one;
else ++two;
}
}
printf("%lld\n",c*n*2-c*c+2*two*(two+one)+one*one);
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
const int md=1e9+7;
int n,m,f[33005][20],c[33005][20],d[20][20];
vector<pair<int,int> >g[20];
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
{
int u,v,w;
scanf("%d%d%d",&u,&v,&w);u--;v--;
d[u][v]=d[v][u]=w;
}
for(int msk=0;msk<(1<<n);msk++)for(int i=0;i<n;i++)
{
f[msk][i]=1e9+7;
for(int j=0;j<n;j++)if(msk&(1<<j))c[msk][i]+=d[i][j];
}
f[1][0]=0;
for(int msk=0;msk<(1<<n);msk++)
{
for(int i=0;i<n;i++)if(msk&(1<<i)&&f[msk][i]!=1e9+7)
{
for(int j=0;j<n;j++)
{
if(!(msk&(1<<j))&&d[i][j])
{
f[msk|(1<<j)][j]=min(f[msk|(1<<j)][j],f[msk][i]+c[msk][j]-d[i][j]);
}
}
int nxt=msk^(1<<i),st=((1<<n)-1)^msk,s;
for(int j=st;j>0;j=(j-1)&st)
{
s=0;
for(int l=0;l<n;l++)if(j&(1<<l))s+=c[nxt][l];
f[msk|j][i]=min(f[msk|j][i],f[msk][i]+s);
}
}
}
printf("%d\n",f[(1<<n)-1][n-1]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ldouble = long double;
const ll inf = 1ll << 60;
const ll mod = (ll)1e9 + 7;
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define print(s) cout << s;
#define println(s) cout << s << endl;
#define printd(s) cout << fixed << setprecision(10) << s << endl;
ll res;
int main()
{
ll n;
cin >> n;
ll res = 1;
for (ll i = 1; ; i++)
{
if (i * i > n)
{
break;
}
res = i * i;
}
println(res)
}
| #include <bits/stdc++.h>
using namespace std;
int main()
{int N, i{}; cin >> N;
while ((i + 1) * (i + 1) <= N) ++i;
cout << i * i;} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9+7;
int main(){
int n; cin >> n;
string s; cin >> s;
int open=0, ans=1;
for(int i=0;i<2*n;i++){
if((s[i]=='B' && (open&1)) || (s[i]=='W' && (!(open&1)))){
if(open<=0){
cout << 0 << endl;
return 0;
}
ans=(1ll*ans*open)%mod;
open--;
}
else{
open++;
}
}
for(int i=1;i<=n;i++){
ans=(1ll*ans*i)%mod;
}
if(open==0){
cout << ans << endl;
}
else{
cout << 0 << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
// typedef pair<ll, ll> P;
typedef pair<string, string> P;
#define MOD 1000000007
#define REP(i, N) for (int i = 0; i < N; ++i)
#define REP1(i, N) for (int i = 1; i <= N; ++i)
#define RREP(i, N) for (int i = N - 1; i >= 0; --i)
#define ALL(a) a.begin(), a.end()
int main() {
int n;
cin >> n;
string s;
cin >> s;
string t = s;
reverse(ALL(t));
map<P, ll> mp1, mp2;
REP(bit, 1 << n) {
string r1 = "", b1 = "";
string r2 = "", b2 = "";
REP(i, n) {
(bit >> i & 1 ? r1 : b1) += s[i];
(bit >> i & 1 ? r2 : b2) += t[i];
}
mp1[P(r1, b1)]++;
mp2[P(r2, b2)]++;
}
ll ans = 0;
for (auto a : mp1) {
if (mp2.find(a.first) != mp2.end()) {
ans += a.second * mp2[a.first];
}
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
vector<string> vec = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
int cnt = 0;
for (string x:vec) {
if (S == x) {
cout << 7 - cnt << endl;
} else {
cnt++;
}
}
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <stack>
#include <set>
#include <queue>
#include <iomanip>
#include <math.h>
#include <fstream>
using namespace std;
class pqComp
{
public:
bool operator()(pair<int, int> &a, pair<int, int> &b)
{
return a.second < b.second;
}
};
bool sorting(pair<int, int> a, pair<int, int> b)
{
return a.second < b.second;
}
int main()
{
ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
cin.tie();
cout.tie();
// ifstream cin("in.txt");
// ofstream cout("out.txt");
// int t;
// cin >> t;
// for (int qwe = 0; qwe < t; qwe++)
// {
// cout << "Case #" << qwe + 1 << ": ";
// }
int k;
string s;
cin >> k >> s;
if (s.size() <= k)
{
cout << s << '\n';
}
else
{
cout << s.substr(0, k) << "...\n";
}
return 0;
}
| 0 |
#include <stdio.h>
int main(){
int n;
int n1, n2, n3;
scanf("%d", &n);
n1 = n/100;
n2 = (n%100)/10;
n3 = n%10;
if (n1 == 7 || n2 == 7 || n3 == 7){
printf("Yes\n");
}
else {
printf("No\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);
}
bool is(ll x)
{
while(x)
{
if(x % 10 == 7) return 1;
x /= 10;
}
return 0;
}
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);
while(cin >> input)
{
if(is(input)) cout << "Yes\n";
else cout << "No\n";
}
}
| 1 |
#include<iostream>
#include<string>
using namespace std;
int main()
{
char s[5000];
long long n,i,j,k,total=0,red[5000]={0},green[5000]={0},blue[5000]={0},r=0,g=0,b=0,x,y;
cin>>n;
for(i=1;i<=n;i++)
{
cin>>s[i];
if(s[i]=='R')
{
r++;
red[i]=red[i-1]+1;
blue[i]=blue[i-1];
green[i]=green[i-1];
}
else if(s[i]=='G')
{
g++;
green[i]=green[i-1]+1;
red[i]=red[i-1];
blue[i]=blue[i-1];
}
else if(s[i]=='B')
{
b++;
blue[i]=blue[i-1]+1;
red[i]=red[i-1];
green[i]=green[i-1];
}
}
for(i=1;i<=n;i++)
{
for(j=i+1;j<=n;j++)
{
if((s[i]=='R'&&s[j]=='G')||(s[i]=='G'&&s[j]=='R'))
{
x=b-blue[j];
y=(j-i)+j;
if(s[y]=='B'&&x>0&&y<=n)
{
x--;
}
total+=x;
}
else if((s[i]=='R'&&s[j]=='B')||(s[i]=='B'&&s[j]=='R'))
{
x=g-green[j];
y=(j-i)+j;
if(s[y]=='G'&&x>0&&y<=n)
{
x--;
}
total+=x;
}
else if((s[i]=='B'&&s[j]=='G')||(s[i]=='G'&&s[j]=='B'))
{
x=r-red[j];
y=(j-i)+j;
if(s[y]=='R'&&x>0&&y<=n)
{
x--;
}
total+=x;
}
}
}
cout<<total<<endl;
return 0;
} | #include <iostream>
#include <algorithm>
using namespace std;
int main()
{
long long n, r = 0, b = 0, g = 0;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++)
{
if (s[i] == 'R') r++;
else if (s[i] == 'B') b++;
else g++;
}
long long ans = r * g * b;
for (int i = 0; i < n; i++)
{
for (int j = i + 1; j < n; j++)
{
if (s[i] == s[j]) continue;
int k = 2 * j - i;
if (k >= n) break;
if(s[k]!=s[i]&&s[k]!=s[j]) --ans;
}
}
cout << ans << endl;
} | 1 |
#define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef double db;
typedef vector<ll> VLL;
typedef vector<VLL> VVLL;
typedef pair<ll,ll> PLL;
#define REP(x,l,u) for(ll x = l; x < u; x++)
#define RREP(x,l,u) for(ll x = l; x >= u; x--)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define mst(x,v) memset(x, v, sizeof(x))
#define sz(x) (ll)x.size()
string to_string(string s) {return s;}
string to_string(char c) {string s = string(1, c);return s;}
template <typename A, typename B> string to_string(pair<A,B> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <typename A> string to_string(vector<A> v) { string s = "("; int first = 1; for (A a : v) { if (!first) { s += ", "; } first = 0; s += to_string(a); } s += ")"; return s; }
template <typename A> string to_string(set<A> v) { string s = "("; int first = 1; for (A a : v) { if (!first) { s += ", "; } first = 0; s += to_string(a); } s += ")"; return s; }
void debug_out() {cerr << endl;}
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << " " << to_string(H); debug_out(T...); }
void in() {}
template <typename A> void in(A & x) { cin >> x; }
template <typename A, typename B> void in(pair<A,B> & x) { in(x.first); in(x.second); }
template <typename A> void in(vector<A> & x) { REP(i,0,(ll)x.size()) in(x[i]); }
template <typename Head, typename... Tail> void in(Head & H, Tail & ... T) {in(H); in(T...); }
#ifndef ONLINE_JUDGE
#define debug(...) do { cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__); } while (false)
#else
#define debug(...) do { } while (false)
#endif
const ll inf = (ll)1e18 + 5;
const ll mod = 1e9+7;
const ll nax = 100500;
ll F[nax], INVF[nax];
ll pow(ll a, ll b) {
if (b == 0) return 1;
ll h = pow(a, b/2);
ll ans = b % 2 ? h * h % mod * a : h * h;
ans %= mod;
return ans;
}
ll ncr(ll n, ll r) {
// n! / r! / (n-r)!
ll ans = F[n];
ans *= INVF[r];
ans %= mod;
ans *= INVF[n-r];
ans %= mod;
return ans;
}
void solve() {
ll n, m;
in(n, m);
F[0] = 1;
REP(i,1,nax) F[i] = (F[i-1] * i) % mod;
REP(i,0,nax) INVF[i] = pow(F[i], mod-2);
map<ll,ll> factors;
ll f = 2;
while (m != 1 && f*f <= m) {
while (m % f == 0) {
factors[f]++;
m /= f;
}
f++;
}
if (m != 1) factors[m]++;
ll ans = 1;
for (PLL a : factors) {
ans *= ncr(a.second + n - 1, a.second) % mod;
ans %= mod;
}
cout << ans << endl;
}
signed main() {
ll t = 1;
REP(i,0,t) solve();
return 0;
} | #include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 10;
const int MOD = (int)1e9 + 7;
int n, l;
int go[N][2];
int dp[2][N];
char s[300000 + 5];
void solve()
{
n = 8;
go[0][0] = 2;
go[0][1] = 3;
go[1][0] = 4;
go[1][1] = 5;
go[2][0] = 0;
go[2][1] = 0;
go[3][0] = 0;
go[3][1] = 1;
go[4][0] = 6;
go[4][1] = 1;
go[5][0] = 5;
go[5][1] = 5;
go[6][0] = 4;
go[6][1] = 4;
go[7][0] = 0;
go[7][1] = 1;
scanf("%s", s);
l = strlen(s);
memset(dp, 0, sizeof dp);
dp[0][7] = 1;
for(int i = 0; i < l; ++ i) {
int cur = i & 1;
int nxt = 1 - cur;
memset(dp[nxt], 0, sizeof dp[nxt]);
for(int c = 0; c < 2; ++ c) {
if (c == 0 && s[i] == '1') continue;
if (c == 1 && s[i] == '0') continue;
for(int j = 0; j < n; ++ j) {
(dp[nxt][go[j][c]] += dp[cur][j]) %= MOD;
}
}
}
cout << (dp[l & 1][1] + dp[l & 1][5]) % MOD << endl;
}
int main()
{
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
vector<vector<int>> G;
vector<int> colors;
bool dfs(int v, int color = 0) {
colors[v] = color;
for(auto u : G[v]) {
if (colors[u] != -1) {
if (colors[u] == color) return false;
continue;
}
if(!dfs(u, 1 - color)) return false;
}
return true;
}
int main() {
ll n, m;
cin >> n >> m;
colors.assign(n, -1);
G.resize(n);
for(int i = 0; i < m; ++i) {
int a , b;
cin >> a >> b;
a--; b--;
G[a].push_back(b);
G[b].push_back(a);
}
bool bipartite = true;
if(!dfs(0)) bipartite = false;
if (bipartite) {
ll w = 0, b = 0;
for(int i = 0; i < n; ++i) {
b += colors[i];
}
w = n - b;
cout << w*b-m << endl;
} else {
cout << n*(n-1)/2-m << endl;
}
return 0;
} |
#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define rb(a,b,c) for(int a=b;a<=c;++a)
#define rl(a,b,c) for(int a=b;a>=c;--a)
#define LL long long
#define IT iterator
#define PB push_back
#define II(a,b) make_pair(a,b)
#define FIR first
#define SEC second
#define FREO freopen("check.out","w",stdout)
#define rep(a,b) for(int a=0;a<b;++a)
#define SRAND mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#define random(a) rng()%a
#define ALL(a) a.begin(),a.end()
#define POB pop_back
#define ff fflush(stdout)
#define fastio ios::sync_with_stdio(false)
#define R(a) cin>>a
#define R2(a,b) cin>>a>>b
#define check_min(a,b) a=min(a,b)
#define check_max(a,b) a=max(a,b)
using namespace std;
const int INF=0x3f3f3f3f;
typedef pair<int,int> mp;
/*}
*/
int h,w,a[200000+1],b[200000+1];
multiset<int> s;
set<mp> se;
int main(){
R2(h,w);
rb(i,1,h)
R2(a[i],b[i]);
rb(i,1,w)
s.insert(0),se.insert(II(i,i));
set<mp> :: IT l,r,nex;
rb(i,1,h){
l=se.lower_bound(II(a[i],-INF));
r=se.upper_bound(II(b[i],INF));
if(r!=se.begin()&&l!=se.end()&&l!=r){
r--;
int save=(*r).SEC;
while(1){
// cout<<"E:"<<(*l).FIR<<","<<(*l).SEC<<endl;
if(l==r){
s.erase(s.lower_bound((*l).FIR-(*l).SEC));
se.erase(l);
if(b[i]!=w){
se.insert(II(b[i]+1,save));
// cout<<"I:"<<b[i]+1<<","<<save<<endl;
s.insert(b[i]+1-save);
}
break;
}
l++;
nex=l;
l--;
s.erase(s.lower_bound((*l).FIR-(*l).SEC));
se.erase(l);
l=nex;
}
}
if(s.empty()) cout<<"-1\n";
else cout<<(*s.begin())+i<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int MAX = 2*1e5;
bool IsPrime(long long n){
if(n == 1) return false;
for(long long i = 2; i * i < n; i++){
if(n%i == 0) return false;
}
return true;
}
vector<pair<long long, long long>> PrimeFactorize(long long n){
vector<pair<long long, long long>> res;
long long a = 0;
for(long long i = 2; i * i <= n; i++){
a = 0;
if(n%i == 0){
if(IsPrime(i)){
while(n % i == 0){
n /= i;
a++;
}
res.push_back(make_pair(i, a));
}}}
if(n!= 1) res.push_back(make_pair(n, 1));
return res;
}
long long modpow(long long a, long long n, long long mod){
long long res = 1;
while(n > 0){
//nを２進数に分解してビットの立っているところだけ掛け算していく。
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// a inverse (mod m)
// a^(-1) = a^(p-2) (mod p)
long long modinv(long long a, long long mod){
return modpow(a, mod-2, mod);
}
long long Comb(long long n, long long k){
if(n < k) return 0;
if(n < 0 || k < 0) return 0;
// return fac[n] * (finv[k] * finv[n-k] % MOD) % MOD;
long long ans = 1;
for(long long i = 0; i < k; i++){
ans = ans * (n - i) % MOD;
ans = ans * modinv(k - i, MOD) % MOD;
}
return ans;
}
int main(){
long long n,m;
cin >> n >> m;
vector<pair<long long, long long>> res;
res = PrimeFactorize(m);
// CombInit();
long long ans = 1;
long long size = res.size();
for(long long i = 0; i < size; i++){
long long num = Comb(res[i].second + n - 1, res[i].second);
// ans = (ans * Comb(res[i].second + n - 1, res[i].second)) % MOD;
ans = (ans * num) % MOD;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(a,n) for (ll a = 0; a < (n); ++a)
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
typedef vector<vector<ll> > Graph;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const ll INF = 1e18;
int main(){
ll n,m;
cin >> n >> m;
vector<ll>a(n);
rep(i,n){
cin>>a[i];
a[i] %= m;
}
vector<ll>r(n+1,0);
map<ll,ll>mp;
mp[0]++;
rep(i,n){
r[i+1] = r[i]+a[i];
r[i+1] %= m;
mp[r[i+1]]++;
}
ll ans = 0;
for(auto it = mp.begin();it!=mp.end();it++){
ll now = it->second;
ans += (now-1)*now/2;
}
cout << ans << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
template<class T> void chmax(T&x, T y){if(x < y) x = y;}
int N, K;
vector<int> G[100010];
int ans;
int dfs(int v, int p){
int mx = 0;
for(auto u : G[v]){
chmax(mx, dfs(u, v));
}
if(mx == K - 1 && p > 1) mx = -1, ans++;
return mx + 1;
}
int main(){
cin >> N >> K;
for(int i = 1; i <= N; i++){
int p;
cin >> p;
if(i == 1) ans += (p == 1 ? 0 : 1);
else G[p].push_back(i);
}
dfs(1, 0);
cout << ans << endl;
return 0;
} | #include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pqueue priority_queue
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int N, K;
int parent[100005];
int doub[32][100005];
int depth[100005];
int ok[100005];
vector<vector<int> > edge(100005);
void prepare() {
for(ll i=0;i<N;++i) {
doub[0][i] = parent[i];
}
for(ll i=1;i<32;++i) {
for(ll j=0;j<N;++j) {
doub[i][j] = doub[i-1][doub[i-1][j]];
}
}
}
void getdepth(ll u, ll dist) {
depth[u] = dist;
for(ll i=0;i<edge[u].size();++i) {
getdepth(edge[u][i], dist+1);
}
return;
}
void getok(ll u) {
if(ok[u]) return;
ok[u] = true;
for(ll i=0;i<edge[u].size();++i) {
getok(edge[u][i]);
}
return;
}
ll getcut(ll u) {
ll h=K-1;
ll two;
ll ans=u;
ll tmp;
while(h>0) {
two = 1;
tmp = 0;
while(2*two<h) {
two *= 2;
tmp++;
}
h -= two;
ans = doub[tmp][ans];
}
return ans;
}
int main() {
cin>>N>>K;
ll tmp;
ll ans = 0;
for(ll i=0;i<N;++i) {
cin>>tmp;
tmp--;
if(i==0 && tmp!=0) ans++;
if(i!=0) {
parent[i] = tmp;
edge[tmp].push_back(i);
}
}
prepare();
/**
for(ll i=0;i<10;++i) {
for(ll j=0;j<N;++j) {
cout<<doub[i][j]<<" ";
}
cout<<endl;
}
**/
getdepth(0, 0);
vector<pair<ll, ll> > arr(N);
for(ll i=0;i<N;++i) arr[i] = mp(depth[i], i);
sort(arr.begin(), arr.end(), greater<pair<ll, ll> >());
ll cut;
for(ll i=0;i<N;++i) {
if(ok[arr[i].se]) continue;
if(arr[i].fi<=K) continue;
ans++;
cut = getcut(arr[i].se);
getok(cut);
}
cout<<ans<<endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i,m,n) for(int i=(int)(m); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define RREP(i,m,n) for(int i=(int)(m); i>=(int)(n); i--)
#define rrep(i,n) RREP(i,n-1,0)
#define all(v) v.begin(), v.end()
const int inf = 1e9+7;
const ll longinf = 1LL<<60;
const ll mod = 1e9+7;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin >> n;
vector<int> A(n);
rep(i, n) cin >> A[i];
double ave = (double)accumulate(all(A), 0)/n;
double mn = inf;
int ans = 0;
rep(i, n) {
if(abs(A[i]-ave) < mn) {
ans = i;
mn = abs(A[i]-ave);
}
}
cout << ans << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
int main(){
int N;
cin >> N;
int sum = 0;
double ave = 0;
double mini = 100;
double aa = 0;
int ans = 0;
vector<int> a(N);
for(int i = 0;i < N;i++){
cin >> a.at(i);
sum += a.at(i);
}
ave = (double)sum/(double)N;
/*cout << ave << endl;*/
for(int i = 0;i < N;i++){
aa = abs(ave - a.at(i));
if(mini > aa){
mini = aa;
ans = i;
}
}
cout << ans << endl;
}
| 1 |
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define gc getchar_unlocked
#define fo(i,n) for(int i=0;i<n;i++)
#define Fo(i,k,n) for(int i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define ll long long int
#define s(x) cin>>x
#define p(x) cout<<x<<"\n"
#define goog(x, y) cout<<"Case #"<<x<<": "<<y<<"\n"
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626
#define INF 100000000000
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
typedef pair<int, int> pii;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpi;
typedef vector<pl> vpl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef long double ld;
mt19937_64 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
int rng(int lim) {
uniform_int_distribution<int> uid(0,lim-1);
return uid(rang);
}
int mpow(int base, int exp);
void ipgraph(int n, int m);
void dfs(int u, int par);
int gcd(int a, int b) ;
const int mod = 1'000'000'007;
const int N = 3e5, M = N;
//=======================
vi g[N];
int a[N];
void solve() {
int n;cin>>n;
ll a[n];
fo(i,n) cin>>a[i];
ll cont[n];
cont[0]=a[0];
Fo(i,1,n)
cont[i]=(cont[i-1]+a[i])%mod;
ll res[n];
res[0]=0;
Fo(i,1,n)
{ res[i]=(res[i-1]+a[i]*cont[i-1])%mod;}
p(res[n-1]);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
int t = 1;
//cin >> t;
while(t--) {
solve();
}
return 0;
}
int mpow(int base, int exp) {
base %= mod;
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((ll)result * base) % mod;
base = ((ll)base * base) % mod;
exp >>= 1;
}
return result;
}
void ipgraph(int n, int m){
int i, u, v;
while(m--){
cin>>u>>v;
//u--, v--;
g[u].pb(v);
g[v].pb(u);
}
}
void dfs(int u, int par){
for(int v:g[u]){
if (v == par) continue;
dfs(v, u);
}
}
int gcd(int a, int b)
{
if (a == 0)
return b;
return gcd(b % a, a);
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int64_t N; cin >> N;
vector<int64_t> A(N);
int64_t MOD = 1e9 + 7;
for (int i = 0; i < N; i++) cin >> A.at(i);
int64_t sum = 0;
/* O(N^2)
for (int i = 0; i < N - 1; i++) {
for (int j = i + 1; j < N; j++) {
if (i < j && j <= N) sum += (A.at(i) * A.at(j)) % MOD;
}
}
*/
vector<int64_t> B(N + 1);
for (int i = 0; i < N; i++) B.at(i + 1) = (B.at(i) + A.at(i)) % MOD;
int64_t ans = 0;
for (int i = 0; i < N - 1; i++) {
ans += A.at(i) * (B.at(N) - B.at(i + 1) + MOD);
ans %= MOD;
}
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main () {
int64_t N, K;
cin >> N >> K;
vector<int> p(N);
vector<double> memo(N + 1);
memo.at(0) = 0;
for (int64_t i = 0; i < N; i++) {
cin >> p.at(i);
memo.at(i + 1) = (memo.at(i) + ((p.at(i) + 1) / 2.0));
}
double ans = 0;
for (int64_t i = 0; i <= N - K; i++) {
double M = (memo.at(i + K) - memo.at(i));
ans = max(M, ans);
}
cout << fixed << setprecision(16);
cout << ans << endl;
}
| #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstring>
#define _GLIBCXX_DEBUG
#include <iomanip>
using namespace std;
template<typename T> vector<T> range(T begin, T end, T stride = 1) {
vector<T> vec;
for (T i = begin; i < end; i += stride) {
vec.push_back(i);
}
return vec;
}
template<typename T> T factorial(T in) {
long long ans = 1;
for (int i=2; i < in + 1; ++i) ans *= i;
return ans;
}
int main() {
int n; cin >> n;
vector<int> v = range(0, n);
vector<int> x(n), y(n);
for (int i=0; i < n; ++i) cin >> x[i] >> y[i];
double sum = 0;
do {
for (int i=0; i<n-1; i++) {
sum += sqrt((x[v[i+1]] - x[v[i]]) * (x[v[i+1]] - x[v[i]]) + (y[v[i+1]] - y[v[i]]) * (y[v[i+1]] - y[v[i]]));
}
} while(next_permutation(v.begin(), v.end()));
cout << fixed << setprecision(15) << sum / factorial(n) << endl;
}
| 0 |
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
const int N = 2e5;
const int posp[4] = {3, 2, 1, 0}, negp[4] = {1, 0, 3, 2}, parp[4] = {2, 3, 0, 1};
const bool post[4] = {1, 1, 0, 0}, negt[4] = {0, 1, 1, 0}, part[4] = {1, 1, 0, 0};
int n, x[N + 1], y[N + 1], u[N + 1], id[256], ans = 0x7fffffff;
char c;
vector<int> pos[4][N * 2 + 1], neg[4][N * 2 + 1], par[4][N + 1];
vector<int>::iterator it;
int main(){
id['U'] = 0, id['R'] = 1, id['D'] = 2, id['L'] = 3;
scanf("%d", &n);
for(int i = 1; i <= n; i++){
scanf("%d%d %c", x + i, y + i, &c);
u[i] = id[c];
if(u[i] == 0 || u[i] == 2)
par[u[i]][x[i]].push_back(y[i]);
else par[u[i]][y[i]].push_back(x[i]);
pos[u[i]][N + y[i] - x[i]].push_back(x[i]);
neg[u[i]][x[i] + y[i]].push_back(x[i]);
}
for(int i = 0; i < 4; i++)
for(int j = 0; j <= N; j++)
sort(par[i][j].begin(), par[i][j].end());
for(int i = 0; i < 4; i++)
for(int j = N * 2; ~j; j--){
sort(pos[i][j].begin(), pos[i][j].end());
sort(neg[i][j].begin(), neg[i][j].end());
}
for(int i = 1; i <= n; i++){
if(u[i] == 0 || u[i] == 2){
if(part[u[i]]){
if(par[parp[u[i]]][x[i]].size() && par[parp[u[i]]][x[i]].back() > y[i])
ans = min(ans, *lower_bound(par[parp[u[i]]][x[i]].begin(), par[parp[u[i]]][x[i]].end(), y[i]) - y[i]);
}else if(par[parp[u[i]]][x[i]].size() && par[parp[u[i]]][x[i]].front() < y[i])
ans = min(ans, y[i] - *--lower_bound(par[parp[u[i]]][x[i]].begin(), par[parp[u[i]]][x[i]].end(), y[i]));
}else{
if(part[u[i]]){
if(par[parp[u[i]]][y[i]].size() && par[parp[u[i]]][y[i]].back() > x[i])
ans = min(ans, *lower_bound(par[parp[u[i]]][y[i]].begin(), par[parp[u[i]]][y[i]].end(), x[i]) - x[i]);
}else if(par[parp[u[i]]][y[i]].size() && par[parp[u[i]]][y[i]].front() < x[i])
ans = min(ans, x[i] - *--lower_bound(par[parp[u[i]]][y[i]].begin(), par[parp[u[i]]][y[i]].end(), x[i]));
}
if(post[u[i]]){
if(pos[posp[u[i]]][N + y[i] - x[i]].size() && pos[posp[u[i]]][N + y[i] - x[i]].back() > x[i])
ans = min(ans, (*lower_bound(pos[posp[u[i]]][N + y[i] - x[i]].begin(), pos[posp[u[i]]][N + y[i] - x[i]].end(), x[i]) - x[i]) * 2);
}else if(pos[posp[u[i]]][N + y[i] - x[i]].size() && pos[posp[u[i]]][N + y[i] - x[i]].front() < x[i])
ans = min(ans, (x[i] - *--lower_bound(pos[posp[u[i]]][N + y[i] - x[i]].begin(), pos[posp[u[i]]][N + y[i] - x[i]].end(), x[i])) * 2);
if(negt[u[i]]){
if(neg[negp[u[i]]][x[i] + y[i]].size() && neg[negp[u[i]]][x[i] + y[i]].back() > x[i])
ans = min(ans, (*lower_bound(neg[negp[u[i]]][x[i] + y[i]].begin(), neg[negp[u[i]]][x[i] + y[i]].end(), x[i]) - x[i]) * 2);
}else if(neg[negp[u[i]]][x[i] + y[i]].size() && neg[negp[u[i]]][x[i] + y[i]].front() < x[i])
ans = min(ans, (x[i] - *--lower_bound(neg[negp[u[i]]][x[i] + y[i]].begin(), neg[negp[u[i]]][x[i] + y[i]].end(), x[i])) * 2);
}
if(ans == 0x7fffffff) printf("SAFE");
else printf("%d", ans * 5);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ALL(v) v.begin(), v.end()
#define V vector
#define P pair
typedef long long ll;
const int INT_INF = 1e9;
const ll INF = 1LL << 30;
const ll MOD = 1e9 + 7;
const ll limit = 100010;
using edge = struct { ll to; ll cost; };
V<edge> G[limit];
ll dis[limit];
void dfs(ll v, ll p, ll d){
dis[v] = d;
for(auto g : G[v]){
if(g.to == p) continue;
dfs(g.to, v, d + g.cost);
}
}
int main() {
ll n; cin >> n;
for(int i = 0; i < n - 1; i++){
ll a, b, c; cin >> a >> b >> c;
a--, b--;
G[a].push_back({b, c});;
G[b].push_back({a, c});
}
ll q, k; cin >> q >> k;
k--;
dfs(k, -1, 0);
for(int i = 0; i < q; i++){
ll x, y; cin >> x >> y;
x--, y--;
cout << dis[x] + dis[y] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline char Get(){
static char ch; ch = getchar();
while (ch != '\n' && ch != '0' && ch != '1' && ch != '?') ch = getchar();
if (ch == '\n') return '*';
return ch;
}
const int P = 1e9 + 7;
inline void upd(int &x,int v){ x = (x+v>=P)?(x+v-P):(x+v); }
int f[9],g[9],nxt[9][2];
inline int getnxt(int s,int v){
int cnt1 = s / 3,cnt0 = s % 3;
if (v == 1){ if (!cnt0) cnt1 = min(2,cnt1+1); else --cnt0; }
else{ if (cnt0 == 2) cnt0 = 0; ++cnt0; }
return cnt1 * 3 + cnt0;
}
inline void DP(char c){
int i;
for (i = 0; i < 9; ++i) g[i] = f[i],f[i] = 0;
for (i = 0; i < 9; ++i) if (g[i]){
if (c != '1') upd(f[nxt[i][0]],g[i]);
if (c != '0') upd(f[nxt[i][1]],g[i]);
}
}
int main(){
int i,j;
for (i = 0; i < 9; ++i) for (j = 0; j < 2; ++j) nxt[i][j] = getnxt(i,j);
f[0] = 1;
char c; while ((c=Get())!='*') DP(c);
int ans = 0;
for (i = 0; i < 9; ++i) if (i / 3 >= i % 3) upd(ans,f[i]);
cout << ans << '\n';
return 0;
} | // This amazing code is by Eric Sunli Chen.
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cassert>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
template<typename T> bool get_int(T &x)
{
char t=getchar();
bool neg=false;
x=0;
for(; (t>'9'||t<'0')&&t!='-'&&t!=EOF; t=getchar());
if(t=='-')neg=true,t=getchar();if(t==EOF)return false;
for(; t<='9'&&t>='0'; t=getchar())x=x*10+t-'0';
if(neg)x=-x;return true;
}
template<typename T> void print_int(T x)
{
if(x<0)putchar('-'),x=-x;
short a[20]= {},sz=0;
while(x>0)a[sz++]=x%10,x/=10;
if(sz==0)putchar('0');
for(int i=sz-1; i>=0; i--)putchar('0'+a[i]);
}
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define get1(a) get_int(a)
#define get2(a,b) (get1(a)&&get1(b))
#define get3(a,b,c) (get1(a)&&get2(b,c))
#define printendl(a) print_int(a),puts("")
typedef long long LL;
typedef unsigned long long uLL;
typedef pair<int,int> pii;
const int inf=0x3f3f3f3f;
const LL Linf=1ll<<61;
const double pi=acos(-1.0);
const int mod=1e9+7;
inline void add(int&x,const int&y){x+=y;if(x>=mod)x-=mod;}
char s[300111];
int n,dp[300111][3][2][3];
int main()
{
scanf("%s",s+1);
n=strlen(s+1);s[++n]='1';
dp[1][0][0][0]=1;
for(int i=1;i<=n;i++)for(int v=0;v<3;v++)for(int p=0;p<2;p++)for(int cur=0;cur<3;cur++)
{
if(s[i]!='1')add(dp[i+1][v==0?1:3-v][p][cur],dp[i][v][p][cur]);
if(s[i]!='0')
{
if(v==1)add(dp[i+1][0][p][cur],dp[i][v][p][cur]);
else
{
int nc=cur;
if(cur==0&&v==0&&!p)nc=1;
else if(cur==1&&v==0&&p)nc=2;
add(dp[i+1][0][p^1][nc],dp[i][v][p][cur]);
}
}
}
printf("%d\n",(dp[n+1][0][0][2]+dp[n+1][0][1][2])%mod);
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repe(i, n) for (int i = 0; i <= (n); ++i)
#define all(x) (x).begin(),(x).end()
using namespace std;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
typedef long long ll;
const int INF = 1e9;
const ll mod = 1000000007;
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int lcm(int a,int b){return a*b / gcd(a,b);}
int main() {
string s;
cin >> s;
if (s.size() < 3) {
cout << s << "\n";
} else {
cout << s[2] << s[1] << s[0] << "\n";
}
}
| #include <iostream>
#include <math.h>
using namespace std;
void Solve(int a)
{
const double pi = 3.14;
float ans;
ans = 2 * pi * a;
cout << ans;
}
int main()
{
int x;
cin >> x;
Solve(x);
return 0;
} | 0 |
#include <iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<cmath>
#include<set>
using namespace std;
int main()
{
string S;
cin >> S;
for (int i = 0; i < S.length() - 8; i++) {
cout << S[i];
}
cout << endl;
}
| #include <iostream>
#include <map>
int main(void){
char ans='0';
std::string S;
std::cin >> S;
std::map<char, int> mp;
for (int i=0; i<26; ++i){
mp[(char)('a' + i)] = 0;
}
for (char c: S) ++mp[c];
for (int i=0; i<26; ++i){
if (mp[(char)('a' + i)] == 0){
ans = (char)('a' + i);
break;
}
}
if (ans == '0') {
std::cout << "None" << std::endl;
} else {
std::cout << ans << std::endl;
}
return 0;
}
| 0 |
#include <iostream>
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <list>
#include <deque>
#include <algorithm>
#include <iomanip>
#include <functional>
#include <numeric>
#define REP(i, n) for(int i = 0;i < (n); i++)
#define REP2(i, x, n) for(int i = (x); i < (n); i++)
#define REPR(i, n) for(int i = (n); i >= 0; i--)
#define ALL(a) (a).begin(),(a).end()
#define SORT(c) sort((c).begin(),(c).end())
#define DESCSORT(c) sort(c.begin(), c.end(), greater<int>())
#define LL long long int
#define LD long double
#define PI 3.14159265358979
using namespace std;
//================================================
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string S; cin >> S; reverse(ALL(S)); cout << S << "\n";
return 0;
} | #include <iostream>
using namespace std;
void reverseSequence()
{
char s[20];
cin >> s;
int i;
for (i = 0; i < 20; i++)
{
if (s[i] == '\0')
{
break;
}
}
for (int j = i - 1; j >= 0; j--)
{
cout << s[j];
}
cout << endl;
}
int main()
{
reverseSequence();
return 0;
} | 1 |
#include <iostream>
#include <vector>
int main()
{
long long N;
std::cin >> N;
long long n_r = 0, n_g = 0, n_b = 0;
std::vector<char> S(N);
for (long long i = 0; i < N; i++)
{
char c;
std::cin >> c;
S[i] = c;
if (c == 'R')
{
n_r++;
}
else if (c == 'G')
{
n_g++;
}
else if (c == 'B')
{
n_b++;
}
else
{
return -1;
}
}
long long count = 0;
for (long long j = 1; j < N - 1; j++)
{
for (long long diff = 1; j - diff >= 0 && j + diff < N; diff++)
{
long long i = j - diff;
long long k = j + diff;
if (S[i] != S[j] && S[j] != S[k] && S[k] != S[i])
{
count++;
}
}
}
std::cout << n_r * n_g * n_b - count << std::endl;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define reps(i, f, n) for (ll i = (f); i < (n); i++)
#define repr(i, n) for (ll i = n; i >= 0; i--)
#define repv(v) for (auto it = (v).begin(); it != (v).end(); it++)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define pb push_back
#define INIT cin.tie(0); ios::sync_with_stdio(false);
template <class T>
inline bool chmax(T& a, T b) {
return a = (a < b) ? b : a;
}
template <class T>
inline bool chmin(T& a, T b) {
return a = (a > b) ? b : a;
}
ll const INF = 1LL << 60;
ll const MOD = 1000000007;
int main() {
INIT;
ll N, R;
cin >> N >> R;
cout << max(0LL, 10LL - N) * 100 + R << endl;
return 0;
} | 0 |
///Bismillahir Rahmanir Rahim
#include "bits/stdc++.h"
#define ll long long
#define int ll
#define fi first
#define si second
#define mp make_pair
#define pb push_back
#define pi pair<ll,ll>
#define clr(x) memset(x,0,sizeof(x));
#define f(i,l,r) for(int i=l;i<=r;i++)
#define rf(i,r,l) for(int i=r;i>=l;i--)
#define done(i) cout<<"done = "<<i<<endl;
#define show(x,y) cout<<x<<" : ";for(auto z:y)cout<<z<<" ";cout<<endl;
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
const ll inf=1e18;
const int mod=1e9+7;
const int M=1000005;
inline ll bigmod(ll B,ll P){ll R=1;while(P>0){if(P&1){R=(R*B)%mod;}P>>=1;B=(B*B)%mod;}return R;}
inline int gun(int x,int y)
{
int ret=(x*y)%mod;
if(ret<0){ret+=mod;ret=ret%mod;}
return ret;
}
bitset<M>sv;
vector<int>prime;
int fact[M];
int infact[M];
void sieve()
{
prime.pb(2);
for(int i=4;i<M;i=i+2)sv[i]=1;
for(int i=3;i*i<M;i=i+2)
{
if(sv[i]==0){
for(int j=i*i;j<M;j=j+2*i)
{
sv[j]=1;
}
}
}
for(int i=3;i<M;i=i+2)
{
if(sv[i]==0)prime.pb(i);
}
}
void init()
{
fact[0]=1;
infact[0]=1;
f(i,1,M-1)
{
fact[i]=(fact[i-1]*i)%mod;
}
infact[M-1]=bigmod(fact[M-1],mod-2);
rf(i,M-2,1)
{
infact[i]=(infact[i+1]*(i+1))%mod;
}
}
vector<int>p,c;
void prime_factorization(int x)
{
p.clear();c.clear();
for(int i=0;prime[i]*prime[i]<=x;i++)
{
int cnt=0;
if(x%prime[i]==0)
{
while(x%prime[i]==0)
{
x=x/prime[i];
cnt++;
}
p.pb(prime[i]);
c.pb(cnt);
}
}
if(x>1)
{
p.pb(x);
c.pb(1);
}
}
int star_bar(int bol,int box)
{
int ret=fact[bol+box-1];
ret=gun(ret,infact[box-1]);
ret=gun(ret,infact[bol]);
return ret;
}
main()
{
fast
init();
sieve();
int n,m;
cin>>n>>m;
prime_factorization(m);
int sz=c.size();
int ses=1;
for(int i=0;i<sz;i++)
{
ses=gun(ses,star_bar(c[i],n));
}
cout<<ses<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pii;
#define fi first
#define se second
#define mp make_pair
#define fastIO ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = (int)1e5 + 9;
const int LOG = 40;
const int MOD = (int)1e9 + 7;
int dp[N][LOG];
int main(){
fastIO;
int n, m;
cin >> n >> m;
dp[0][0] = 1;
int s;
for(int i = 1; i <= n; i ++ ){
s = 0;
for(int j = 0 ; j < LOG; j ++ ){
s += dp[i - 1][j];
s %= MOD;
dp[i][j] = s;
}
}
int cnt;
int ans = 1;
for(int i = 2; i * i <= m ; i ++ ){
if(m % i != 0) continue;
cnt = 0;
while(m % i == 0){
cnt ++ ;
m /= i;
}
ans = (ans * 1ll * dp[n][cnt]) % MOD;
}
if(m != 1) ans = (ans * 1ll * dp[n][1]) % MOD;
cout << ans << "\n";
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const int MOD=1e9+7;
int main(void){
int h,w;
cin>>h>>w;
vector<string> M(h);
rep(i,h) cin>>M[i];
queue<pair<int,int>> que;
vector<vector<int>> seen(h,vector<int>(w,-1));
rep(i,h) rep(j,w){
if(M[i][j]=='#'){
que.push(make_pair(i,j));
seen[i][j]=0;
}
}
int dx[]={1,0,-1,0};
int dy[]={0,1,0,-1};
while(!que.empty()){
int x=que.front().first;
int y=que.front().second;
que.pop();
rep(dir,4){
int nx=x+dx[dir];
int ny=y+dy[dir];
if(nx<0 || nx>=h || ny<0 ||ny>=w) continue;
if(seen[nx][ny]!=-1) continue;
seen[nx][ny]=seen[x][y]+1;
que.push(make_pair(nx,ny));
}
}
int ans=0;
rep(i,h){
rep(j,w){
//cout<<seen[i][j]<<" ";
ans=max(ans,seen[i][j]);
}
//cout<<endl;
}
cout<<ans<<endl;
} | #include <bits/stdc++.h>
#include <numeric>
#define rep(i,n) for (int i = 0; i < n; ++i)
#define per(i,n) for (int i = n - 1; i >= 0; --i)
#define rep1(i,n) for (int i = 1; i <= n; ++i)
template<typename T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<typename T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<typename T> inline T intceil(T a, T b) { return (a + (b - 1)) / b; }
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> P;
typedef pair<ll,ll> PL;
const long long MOD = 1e9+7;
#define precout() cout << std::fixed << std::setprecision(20);
const string alphabet = "abcdefghijklmnopqrstuvwxyz";
const int dy[4] = { 0, 1, 0, -1 };
const int dx[4] = { 1, 0, -1, 0 };
static const double pi = 3.141592653589793;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin >> n;
ll prev; cin >> prev;
bool ok = 1;
if(prev > 0) {
ok = 0;
}
ll ans = 0;
rep(i, n - 1) {
ll tmp; cin >> tmp;
if(!ok) continue;
if(tmp == 0) {
prev = tmp;
continue;
}
ll diff = tmp - prev;
if(diff > 1) {
ok = 0;
continue;
}
if(diff == 1) {
++ans;
} else {
ans += tmp;
}
prev = tmp;
}
if(ok) {
cout << ans << endl;
} else {
cout << -1 << endl;
}
}
| 0 |
#include "bits/stdc++.h"
using namespace std;
using ll = long long; using ull = unsigned long long;
#define int ll
using vb = vector<bool>; using vvb = vector<vb>;
using vi = vector<int>; using vvi = vector<vi>;
using vl = vector<ll>; using vvl = vector<vl>;
using pii = pair<int,int>; using pll = pair<ll,ll>;
#define FOR(i,a,b) for(ll i = (a); i < (ll)(b); ++i)
#define REP(i,n) FOR(i,0,n)
#define RFOR(i,a,b) for(ll i = (ll)(b)-1;i >= a;--i)
#define RREP(i,n) RFOR(i,0,n)
#define ALL(obj) (obj).begin(), (obj).end()
#define rALL(obj) (obj).rbegin(), (obj).rend()
#define eb(val) emplace_back(val)
const double PI = acos(-1);
const double EPS = 1e-10;
const ll MOD = 1e9+7;
void cioacc(){//accelerate cin/cout
cin.tie(0);
ios::sync_with_stdio(false);
}
struct dice{
int up,s,e,w,n,dn;
void to(char dir){
if(dir=='N'){
int tmp = n;
n = up;
up = s;
s = dn;
dn = tmp;
}else if(dir=='S'){
int tmp = s;
s = up;
up = n;
n = dn;
dn = tmp;
}else if(dir=='E'){
int tmp = e;
e = up;
up = w;
w = dn;
dn = tmp;
}else if(dir=='W'){
int tmp = w;
w = up;
up = e;
e = dn;
dn = tmp;
}
}
void to(string dirs){
REP(i,dirs.size()) to(dirs[i]);
}
};
signed main(){
int a[6];
REP(i,6) cin >> a[i];
dice di = {a[0],a[1],a[2],a[3],a[4],a[5]};
string s;
cin >> s;
di.to(s);
cout << di.up << endl;
}
| #include <iostream>
const int N = 7;
typedef struct {
int panels[N];
int upper;
int east;
int south;
} Dice;
void rotate_dice(int *x, int *y, int d) {
*x = *y;
*y = d;
}
int main(void) {
Dice dice;
for (int i = 1; i < N; i++) {
std::cin >> dice.panels[i];
}
dice.upper = 1;
dice.east = 3;
dice.south = 2;
std::string input;
std::cin >> input;
for (int i = 0; i < input.size(); i++) {
char m = input[i];
if (m == 'E') {
rotate_dice(&dice.east, &dice.upper, N - dice.east);
} else if (m == 'W') {
rotate_dice(&dice.upper, &dice.east, N - dice.upper);
} else if (m == 'S') {
rotate_dice(&dice.south, &dice.upper, N - dice.south);
} else {
rotate_dice(&dice.upper, &dice.south, N - dice.upper);
}
}
std::cout << dice.panels[dice.upper] << std::endl;
return 0;
} | 1 |
#include<iostream>
#include<string>
int main() {
int K;
std::string S;
std::cin >> K >> S;
if (S.size() <= K) std::cout << S << std::endl;
else {
std::string answer = S.substr(0, K);
answer += "...";
std::cout << answer << std::endl;
}
return 0;
} | #include <bits/stdc++.h>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<string.h>
using namespace std;
#define pb push_back
#define all(v) v. begin(),v. end()
#define rep(i,n,v) for(i=n;i<v;i++)
#define per(i,n,v) for(i=n;i>v;i--)
#define ff first
#define ss second
#define pp pair<ll,ll>
#define eps 1e-6
#define ll long long
#define endl '\n'
void solve()
{
ll n, a,m=0,b=1, k=0, i, j,l=2e9+7;
string s, r, y;
cin>>n>>s;
rep(i,0,s.length())
{
if(i==n) break;
cout<<s[i];
}
if(i!=s. length())
cout<<"...";
}
int main()
{
ios_base::sync_with_stdio(false);
cin. tie(0);cout. tie(0);
ll t=1;
// cin>>t;
while(t--)
{
solve();
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
//Made with <3 by MinumCoklatPanas
typedef long long ll;
const ll INF = 1e9;
const ll INFF = 1e18;
const ll MAXN = 510;
const ll MOD = 1e9 + 7;
const double PI = acos(-1.0);
const double INFD = 1E9;
const double EPS = 1e-9;
ll mul(ll x,ll y)
{
return ((x % MOD) * (y % MOD)) % MOD;
}
ll add(ll x,ll y)
{
return ((x % MOD) + (y % MOD)) % MOD;
}
ll sub(ll x,ll y)
{
ll ret = ((x % MOD) - (y % MOD)) % MOD;
if (ret < 0)
ret += MOD;
return ret;
}
ll modpow(ll x,ll y)
{
if (!y) return 1;
ll z = modpow(x,y / 2);
z = mul(z,z);
if (y & 1) z = mul(z,x);
return z;
}
ll inv(ll x)
{
return modpow(x,MOD - 2);
}
ll bagi(ll x,ll y)
{
return mul(x,inv(y));
}
ll pref[65][300010];
ll tab[300010];
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
for (ll i = 1 ; i <= n ; i++)
{
for (ll j = 0 ; j < 60 ; j++)
pref[j][i] = pref[j][i - 1];
ll ta;
cin >> ta;
for (ll j = 0 ; j < 60 ; j++) if (ta & (1ll << j))
{
pref[j][i]++;
}
tab[i] = ta;
}
ll ans = 0;
for (ll i = 1 ; i <= n ; i++)
{
ll pengali = 1;
ll rem = n - i;
for (ll j = 0 ; j < 60 ; j++)
{
ll satu = pref[j][n] - pref[j][i];
ll nol = rem - satu;
// cout << j << ": " << satu << " " << nol << endl;
if (tab[i] & (1ll << j))
ans = add(ans,mul(nol,pengali));
else
{
// cout << "yo\n";
ans = add(ans,mul(satu,pengali));
}
pengali = mul(pengali,2ll);
}
// cout << ans << endl;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
constexpr const int mod = 1000000007;
int main() {
int n;
cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
ll ans = 0, two_factor = 1;
rep(i, 60) {
ll even = 0;
rep(j, n) if ((a[j] >> i) & 1) even++;
ll add = (even * (n - even)) % mod * two_factor % mod;
ans = (ans + add) % mod;
two_factor = (two_factor * 2) % mod;
}
cout << ans << endl;
return 0;
}
| 1 |
#include<stdio.h>
void devide(int x, int y, int z)
{
if((x == 100) || (y == 100) || (z == 100)) {
printf("A\n");
} else if ((x + y) >= 90*2) {
printf("A\n");
} else if ((x + y + z) >= 80*3) {
printf("A\n");
} else if ((x + y + z) >= 70*3) {
printf("B\n");
} else if ((x + y + z) >= 50*3) {
if ((x >= 80) || (y >= 80)){
printf("B\n");
} else {
printf("C\n");
}
} else {
printf("C\n");
}
}
int main(void)
{
int pm, pe, pj, num;
scanf("%d", &num);
while (num != 0) {
for (int i = 0; i < num; i++) {
scanf("%d %d %d", &pm, &pe, &pj);
devide(pm, pe, pj);
}
scanf("%d", &num);
}
return 0;
} | #define _USE_MATH_DEFINES
#define INF 10000000
#include <iostream>
#include <sstream>
#include <cmath>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P > PP;
static const double eps = 1e-8;
int getAvr(int* p,int n){
int sum = 0;
for(int i=0;i<n;i++){
sum += p[i];
}
return sum/3;
}
int main(){
int n;
while(~scanf("%d",&n)){
if(n==0) break;
for(int i=0;i<n;i++){
int p[3];
//math,english,japanese
scanf("%d %d %d",p,p+1,p+2);
for(int i=0;i<3;i++){
if(p[i]==100){
printf("A\n");
goto next;
}
}
if(p[0] + p[1] >= 180 || getAvr(p,3) >= 80){
printf("A\n");
}
else if(getAvr(p,3) >= 70
|| (getAvr(p,3) >= 50 && (p[0] >= 80 || p[1] >= 80))){
printf("B\n");
}
else{
printf("C\n");
}
next:;
}
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
vector<long long> A(N), sumA(N+1, 0);
long long mod_ = 1000000007;
for (int i=0; i<N; i++){
cin >> A.at(i);
sumA.at(i+1) = sumA.at(i)+A.at(i);
if (sumA.at(i+1) >= mod_) sumA.at(i+1) %= mod_;
}
long long ans = 0;
long long sum_comp = 0;
for (int i=0; i<N-1; i++){
sum_comp = sumA.at(N) > sumA.at(i+1) ? sumA.at(N)-sumA.at(i+1) : sumA.at(N)+mod_-sumA.at(i+1);
ans += A.at(i)*sum_comp;
if (ans >= mod_) ans %= mod_;
}
cout << ans << endl;
}
| #include <iostream>
#include <vector>
#include <string>
using namespace std;
int main() {
int n;
string abc = "abcdefghijklmnopqrstuvwxyz";
string abcc = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string aa = abcc + abc + abcc + abc;
int sz = aa.size();
while (cin >> n) {
if (n == 0) {
break;
}
vector<int> k(n);
for (int i = 0; i < n; i++) {
cin >> k[i];
}
string s;
cin >> s;
int c = 0;
for (int i = 0; i < s.size(); i++) {
for (int j = sz - 1; j >= 0; j--) {
if (aa[j] == s[i]) {
cout << aa[j - k[c]];
c++;
c %= n;
break;
}
}
}
cout << endl;
}
return 0;
} | 0 |
#include <stdio.h>
#include <string.h>
int main(){
int a, b;
scanf("%d %d", &a, &b);
getchar();
char str[a+b+1];
scanf("%s", &str);
int length = strlen(str);
int flag = 0;
for(int i=0; i<length; i++)
{
if(str[i] >= '0' && str[i] <= '9')
{
continue; //kl ada yg bukan angka, di skip
}
else if ('0' > str[i] || str[i] > '9')
{
if (i==a) //kalo dia bukan angka tp ternyata di indeks ke a, di okin
{
flag = 1;
continue;
}
else if(i !=a)
{
flag = 0;
break;
}
}
}
flag ? printf("Yes\n") : printf("No\n");
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define REV(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define ts to_string
#define all(v) (v).begin(), (v).end()
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vs vector <string>
#define vvs vector <vector<string>>
#define pq priority_queue<int>
using ll = long long;
/* ----------------よく使う数字や配列----------------- */
int dx[] = { 1,0,-1,0 };
int dy[] = { 0,1,0,-1 };
const int INF = 2000000000;
constexpr ll mod = 1e9 + 7;
constexpr long double pi = 3.141592653589793238462643383279;
/* ----------------------end----------------------- */
/*---------------------template----------------------*/
/*----------------------end--------------------------*/
/* --------------------ライブラリ--------------------*/
bool isprime(ll a)//素数判定、primeならtrue,違うならfalse
{
if (a < 2) return false;
else if (a == 2) return true;
else if (a % 2 == 0) return false;
double m = sqrt(a);
for (int i = 3; i <= m; i += 2)
{
if (a % i == 0)
{
return false;
}
}
// 素数である
return true;
}
ll ketasum(ll n) { //各桁の和
ll sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
/* ----------------------end----------------------- */
/*---------------------臨時関数----------------------*/
/*----------------------end-------------------------*/
signed main(){
int A,B;string S;cin>>A>>B>>S;
bool b=true;
rep(i,A+B+1){
if(i!=A){
if(S[i]-'0'>=10||S[i]-'0'<0){
b=false;
break;
}
}
else {
if(S[i]!='-'){
b=false;
break;
}
}
}
if(b)puts("Yes");
else puts("No");
}
| 1 |
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string>
#include <iomanip>
#include <math.h>
#include <utility>
#include <vector>
#include <map>
#include <cstdlib>
#define div1 1000000007
const long long INF = 1LL << 60;
using namespace std;
// a>b -> a==b;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
// a<b -> a==b;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
int main(void)
{
string s;
int i;
cin >> s;
for(i=0; i<s.size(); i++){
if(i < s.size() - 8){
cout << s[i];
}
}
cout << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
string s; cin>>s;
reverse(s.begin(),s.end());
int n=s.size();
string t = s.substr(8,n-8);
reverse(t.begin(),t.end());
cout << t << endl;
} | 1 |
#include <iostream>
#include <string>
#include <vector>
#include <math.h>
#include <algorithm>
#include <utility>
typedef long long ll;
const int INF = 1e9+1;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
using namespace std;
int div(int x) {
int cnt = 0;
for (int i = 1; i <= x;i++) {
if (x % i == 0)cnt++;
}
return cnt;
}
bool prime(long long int x) {
for (int i = 2; i <= sqrt(x) ; i++) {
if (x % i == 0)return 0;
}
return 1;
}
long long int divi(long long int n,long long int p) {
int cn = 0;
int q = p;
while (n / q != 0) {
cn += n / q;
q = q * p;
}
return cn;
}
int main() {
long long int n;
int cnt = 0;
long long int ans = 1;
cin >> n;
vector<int> p(n);
vector<int> a(n);
for (int i = 2; i <= n; i++) {
if (prime(i) == 1) {
p.at(cnt) = i;
cnt++;
}
}
//for (int i = 0; i < cnt; i++)cout << p.at(i) << endl;
for (int i = 0; i < cnt; i++) {
a.at(i) = divi(n, p.at(i));
}
for (int i = 0; i < cnt; i++) {
ans =(ans%MOD) * (a.at(i)+1)%MOD;
}
cout << ans%MOD << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int H, W;
int seen[10000][10000];
char S[10000][10000];
vector<pair<ll, ll>> prime_factorize(ll n) { //素因数分解と各素数の個数
vector<pair<ll, ll>> res;
for (ll i = 2; i * i <= n; i++)
{
if (n % i != 0)
{
continue;
}
int num = 0;
while (n % i == 0)
{
++num;
n /= i;
}
res.push_back(make_pair(i, num));
}
if (n != 1)
{
res.push_back(make_pair(n, 1));
}
return res;
}
long long GCD(long long a, long long b) {
if (b == 0) return a;
else return GCD(b, a % b);
}
ll lcm(ll x, ll y) {
return x / GCD(x, y) * y;//先に割り算をして掛けられる数を小さくして掛け算を行う
}
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
void dfs(int st, int fi) {
// cout << st << " " << fi << endl;
if (st < 0 || fi < 0 || st >= H || fi >= W)
{
return ;
}
if (S[st][fi] == '#')
{
return ;
}
if (seen[st][fi] == 1)
{
return ;
}
if (S[st][fi] == '.')
{
seen[st][fi] = 1;
}
dfs(st + 1, fi);
dfs(st, fi + 1);
dfs(st, fi - 1);
dfs(st - 1, fi);
}
int main() {
int N;
cin >> N;
vector<int> p(N + 1);
p[1] = 0;
for(int i = 2; i <= N; i++) {
int n = i;
vector<pair<int, int>> b;
for(int j = 2; j * j <= n; j++) {
if(n % j != 0) continue;
int ex = 0;
while(n % j == 0) {
ex++;
n /= j;
}
b.push_back({j, ex});
}
if(n != 1) b.push_back({n, 1});
for(auto v : b) {
p[v.first] += v.second;
}
}
/*for(int i = 1; i <= N; i++)
cout << p[i] << endl;*/
ll ans = 1;
for(int i = 2; i <= N; i++) {
ans *= (p[i] + 1);
ans %= 1000000007;
}
cout << ans << endl;
return 0;
}
| 1 |
#include<iostream>
using namespace std;
typedef long long LL;
const int N = 1e5;
int a[N];
int info[N];
bool check_feasibility(int n)
{
for(int i = 2; i < n; i++)
a[i] = a[i-2]^a[i-1]^info[i-1];
if((a[n-2]^a[n-1]^a[0])!=info[n-1] || (a[n-1]^a[0]^a[1])!=info[0])
return false;
else
return true;
}
bool solve(int n)
{
for(int i = 0; i <= 1; i++)
for(int j = 0; j <= 1; j++)
{
a[0] = i;
a[1] = j;
if(check_feasibility(n))
return true;
}
return false;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n; cin >> n;
for(int i = 0; i < n; i++)
{
char c; cin >> c;
info[i] = c=='x';
}
if(solve(n))
{
for(int i = 0; i < n; i++)
cout<<(a[i] ? "W" : "S");
cout<<endl;
}
else
cout<<-1<<endl;
cout<<flush;
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <algorithm>
#include <set>
#include <map>
#include <bitset>
#include <cmath>
#include <functional>
#define vv(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))
#define vvi vector<vector<int> >
#define vvl vector<vector<ll> >
#define vll vector<ll>
#define rep(c, a, b) for(ll c=a;c<b;c++)
#define re(c, b) for(ll c=0;c<b;c++)
typedef long long int ll;
typedef long double ld;
using namespace std;
int main(int argc, char const *argv[]) {
ll n;std::cin >> n;
string t, s;std::cin >> s;
//SS
char end='&';
char pre = 'S';
t = "S";
re(i, s.size()){
int k = (s[i]=='o'?1:-1);
if(t[i]=='W') k*=-1;
int b = ((i==0?pre:t[i-1])=='S'?1:-1);
if(k==-1) b*=-1;
if(b==1){
if(i==s.size()-1){
end = 'S';
break;
}
t+='S';
}else {
if(i==s.size()-1){
end = 'W';
break;
}
t+='W';
}
}
if(pre==t[n-1]&&t[0]==end){
std::cout << t << '\n';
return 0;
}
//SW
pre = 'S';
t = "W";
re(i, s.size()){
int k = (s[i]=='o'?1:-1);
if(t[i]=='W') k*=-1;
int b = ((i==0?pre:t[i-1])=='S'?1:-1);
if(k==-1) b*=-1;
if(b==1){
if(i==s.size()-1){
end = 'S';
break;
}
t+='S';
}else {
if(i==s.size()-1){
end = 'W';
break;
}
t+='W';
}
}
if(pre==t[n-1]&&t[0]==end){
std::cout << t << '\n';
return 0;
}
//WW
pre = 'W';
t = "W";
re(i, s.size()){
int k = (s[i]=='o'?1:-1);
if(t[i]=='W') k*=-1;
int b = ((i==0?pre:t[i-1])=='S'?1:-1);
if(k==-1) b*=-1;
if(b==1){
if(i==s.size()-1){
end = 'S';
break;
}
t+='S';
}else {
if(i==s.size()-1){
end = 'W';
break;
}
t+='W';
}
}
if(pre==t[n-1]&&t[0]==end){
std::cout << t << '\n';
return 0;
}
//WS
pre = 'W';
t = "S";
re(i, s.size()){
int k = (s[i]=='o'?1:-1);
if(t[i]=='W') k*=-1;
int b = ((i==0?pre:t[i-1])=='S'?1:-1);
if(k==-1) b*=-1;
if(b==1){
if(i==s.size()-1){
end = 'S';
break;
}
t+='S';
}else {
if(i==s.size()-1){
end = 'W';
break;
}
t+='W';
}
}
if(pre==t[n-1]&&t[0]==end){
std::cout << t << '\n';
return 0;
}
std::cout << -1 << '\n';
return 0;
}
| 1 |
#include<iostream>
using namespace std;
#include <cmath>
int main(){
int n;
cin >> n;
cout << (int)pow((int)sqrt(n),2) << endl;
}
| #include <iostream>
#include <string>
using namespace std;
int main()
{
int N;
cin >> N;
int a = N % 10;
int b = ((N-a) % 100) / 10;
int c = ((N-b*10) % 1000) / 100;
if (a == 7 | b == 7 | c == 7) {
cout << "Yes";
}
else {
cout << "No";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(void)
{
int N;
cin >> N;
vector<vector<int>> part(3, vector<int>(N));
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < N; j++)
{
cin >> part[i][j];
}
sort(part[i].begin(),part[i].end());
}
ll cases = 0;
for (int mid = 0; mid < N; mid++)
{
ll as = lower_bound(part[0].begin(), part[0].end(), part[1][mid]) - part[0].begin();
ll cs = N - (upper_bound(part[2].begin(), part[2].end(), part[1][mid]) - part[2].begin());
cases += (as * cs);
}
cout << cases << endl;
return 0;
}
| #include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
class Dice
{
private:
int surf[6];
public:
void set_surf(int* input);
void roll(char orient);
void disp_top();
};
void Dice::set_surf(int* input)
{
memcpy(surf, input, 6*sizeof(int));
}
void Dice::roll(char orient){
int temp[6];
switch(orient){
case 'S':
temp[0]=surf[4];
temp[1]=surf[0];
temp[2]=surf[2];
temp[3]=surf[3];
temp[4]=surf[5];
temp[5]=surf[1];
break;
case 'N':
temp[0]=surf[1];
temp[1]=surf[5];
temp[2]=surf[2];
temp[3]=surf[3];
temp[4]=surf[0];
temp[5]=surf[4];
break;
case 'W':
temp[0]=surf[2];
temp[1]=surf[1];
temp[2]=surf[5];
temp[3]=surf[0];
temp[4]=surf[4];
temp[5]=surf[3];
break;
case 'E':
temp[0]=surf[3];
temp[1]=surf[1];
temp[2]=surf[0];
temp[3]=surf[5];
temp[4]=surf[4];
temp[5]=surf[2];
break;
}
memcpy(surf, temp, 6*sizeof(int));
}
void Dice::disp_top(){
cout << surf[0] << endl;
}
int main()
{
int input[6];
Dice dice;
string order;
for(int i=0; i<6; i++){
cin >> input[i];
}
dice.set_surf(input);
cin >> order;
for(int i=0; i<order.size(); i++){
dice.roll(order[i]);
}
dice.disp_top();
return(0);
} | 0 |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <queue>
#include <bitset>
#include <stack>
#include <functional>
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#define rep_(i, a_, b_, a, b, ...) for (int i = (a), i##_len = (b); i < i##_len; ++i)
#define rep(i, ...) rep_(i, __VA_ARGS__, __VA_ARGS__, 0, __VA_ARGS__)
#define reprev_(i, a_, b_, a, b, ...) for (int i = (b-1), i##_min = (a); i >= i##_min; --i)
#define reprev(i, ...) reprev_(i, __VA_ARGS__, __VA_ARGS__, 0, __VA_ARGS__)
#define all(x) (x).begin(), (x).end()
template <class T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return 1; } return 0; }
template <class T> bool chmin(T &a, const T &b) { if (b < a) { a = b; return 1; } return 0; }
template <class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair <int,int> P;
typedef long double ld;
int main (void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin >> n;
string a, b, c; cin >> a >> b >> c;
int ans = 0;
rep (i, n) {
set<char> st;
st.insert(a[i]); st.insert(b[i]); st.insert(c[i]);
ans += st.size() - 1;
}
cout << ans << "\n";
return 0;
} | #include <bits/stdc++.h>
#define For(i, a, b) for(int (i)=(int)(a); (i)<(int)(b); ++(i))
#define rFor(i, a, b) for(int (i)=(int)(a)-1; (i)>=(int)(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef unsigned long long ulint;
typedef pair<int, int> pii;
template<class T> bool chmax(T &a, const T &b){if(a<b){a=b; return true;} return false;}
template<class T> bool chmin(T &a, const T &b){if(a>b){a=b; return true;} return false;}
template<class T> T div_floor(T a, T b){
if(b < 0) a *= -1, b *= -1;
return a>=0 ? a/b : (a+1)/b-1;
}
template<class T> T div_ceil(T a, T b){
if(b < 0) a *= -1, b *= -1;
return a>0 ? (a-1)/b+1 : a/b;
}
constexpr lint mod = 1e9+7;
constexpr lint INF = mod * mod;
constexpr int MAX = 200010;
int main(){
int n;
string a, b, c;
cin >> n >> a >> b >> c;
int ans = 0;
rep(i, n){
if(a[i] == b[i] && b[i] == c[i]) continue;
else if(a[i] == b[i] || b[i] == c[i] || c[i] == a[i]) ans += 1;
else ans += 2;
}
printf("%d\n", ans);
} | 1 |
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <vector>
using namespace std;
set<int> guest;
int n, m;
vector<int> people[501];
int main()
{
while((cin >> n >> m) && n && m)
{
int a, b;
int t;
for(int i=0;i<m;i++)
{
cin >> a >> b;
people[a].push_back(b);
people[b].push_back(a);
}
for(int i=0;i<people[1].size();i++)
{
t = people[1][i];
guest.insert(t);
for(int j=0;j<people[t].size();j++) guest.insert(people[t][j]);
}
guest.insert(1);
cout << guest.size()-1 << endl;
guest.clear();
for(int i=0;i<n;i++) people[i].clear();
}
} | #include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <fstream>
#include <complex>
#include <stack>
#include <queue>
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
static const double EPS = 1e-5;
#define FOR(i,k,n) for (int i=(k); i<(int)(n); ++i)
#define REP(i,n) FOR(i,0,n)
int main(void){
int n;
while(cin>>n){
if(n==0) break;
vector<int> friends[501];
int m;
cin>>m;
REP(i,m){
int a,b;
cin>>a>>b;
friends[a].push_back(b);
friends[b].push_back(a);
}
set<int> ans;
REP(i,friends[1].size()){
int s = friends[1][i];
ans.insert(s);
REP(i,friends[s].size()){
ans.insert(friends[s][i]);
}
}
if(ans.size()!=0)cout<<ans.size()-1<<endl;
else cout<<0<<endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
vector<int> A(N), B(N);
for(int i=0; i<N; i++) cin >> A[i];
for(int i=0; i<N; i++) cin >> B[i];
reverse(B.begin(), B.end());
int dup = -1;
vector<int> dup_idx, avail_idx;
for(int i=0; i<N; i++) if(A[i] == B[i]){
dup = A[i];
dup_idx.push_back(i);
}
for(int i=0; i<N; i++) if(A[i] != dup && B[i] != dup) avail_idx.push_back(i);
if(dup_idx.size() > avail_idx.size()){
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
for(int i=0; i<int(dup_idx.size()); i++) swap(B[dup_idx[i]], B[avail_idx[i]]);
for(int i=0; i<N; i++) cout << B[i] << " \n"[i==N-1];
return 0;
}
| #include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define INF 1000000007
using namespace std;
int main(){
int n;
cin >> n;
vector<int> a(n),b(n),asum(n+1,0),bsum(n+1,0);
rep(i,n){
cin >> a[i];
asum[a[i]]++;
}
rep(i,n){
cin >> b[i];
bsum[b[i]]++;
}
rep(i,n+1){
if(asum[i] + bsum[i] > n){
cout << "No\n";
return 0;
}
}
rep(i,n){
asum[i+1] += asum[i];
bsum[i+1] += bsum[i];
}
int d = 0;
rep(i,n+1){
d = max(asum[i]-bsum[i-1],d);
}
cout << "Yes\n";
rep(i,n){
cout << b[(n+i-d)%n] << " ";
}
return 0;
} | 1 |
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
vector< vector<int> > G(100002);
int n_v, n_e;
int prenum[100001], parent[100001], lowest[100001], n_child[100001];
bool is_cut[100001];
void dfs(int u, int f, int t_stamp){
prenum[u] = t_stamp;
parent[u] = f;
lowest[u] = t_stamp;
int v;
for(int i=0; i<G[u].size(); i++){
v = G[u][i];
if(prenum[v]!=0){
//this edge is a backedge
lowest[u] = min(lowest[u], prenum[v]);
}else{
n_child[u] += 1;
dfs(v, u, t_stamp+1);
lowest[u] = min(lowest[u], lowest[v]);
}
}
return;
}
int main(){
scanf("%d %d", &n_v, &n_e);
int u, v;
for(int i=0; i<n_e; i++){
scanf("%d %d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
memset(prenum, 0, sizeof(prenum));
memset(parent, 255, sizeof(parent));
memset(n_child, 0, sizeof(n_child));
for(int i=0; i<n_v; i++){
if(parent[i]==-1){
dfs(i, -1, 1);
}
}
memset(is_cut, 0, sizeof(is_cut));
for(int i=0; i<n_v; i++){
if(parent[i]==-1 && n_child[i]>=2)
is_cut[i] = true;
else if(prenum[parent[i]] <= lowest[i]){
if(parent[parent[i]] == -1 && n_child[parent[i]]>=2){
//the parent is a root
is_cut[parent[i]] = true;
}else if(parent[parent[i]] != -1){
//the parent is not a root
is_cut[parent[i]] = true;
}
}
}
for(int i=0; i<n_v; i++)
if(is_cut[i])
printf("%d\n", 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;
using vi=vector<int>;
using vll=vector<ll>;
#define MOD 1000000007
/*
void dijkstra(vector<vector<pair<ll,int>>> &graph, vll &dist, int s){
priority_queue<pair<ll,int>> que;
dist[s]=0;
que.push({0,s});
while(!que.empty()){
auto x=que.top(); que.pop();
if(dist[x.second]<x.first) continue;
for(auto v:graph[x.second]){
if(dist[v.second]<dist[x.second]+v.first) continue;
dist[v.second]=dist[x.second]+v.first;
que.push({dist[v.second],v.second});
}
}
}
*/
void bfs(vector<vector<pair<ll,int>>> &graph, vll &dist, int s){
queue<pair<ll,int>> que;
dist[s]=0;
que.push({0,s});
while(!que.empty()){
auto x=que.front(); que.pop();
for(auto v:graph[x.second]){
if(dist[v.second]!=-1) continue;
dist[v.second]=dist[x.second]+v.first;
que.push({dist[v.second],v.second});
}
}
}
int main(){
int n;
cin >> n;
vector<vector<pair<ll,int>>> graph(n);
rep(i,n-1){
int a,b;
ll c;
cin >> a >> b >> c;
a--; b--;
graph[a].push_back({c,b});
graph[b].push_back({c,a});
}
vll dist(n,-1);
int q,k;
cin >> q >> k; k--;
//dijkstra(graph,dist,k);
bfs(graph,dist,k);
rep(i,q){
int x,y;
cin >> x >> y;
x--; y--;
cout << dist[x]+dist[y] << endl;
}
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
std::vector<int> v;
std::vector<int> w;
int n;
std::cin >> n;
while (n-- > 0) {
int m;
std::cin >> m;
v.push_back(m);
}
std::cin >> n;
while (n-- > 0) {
int m;
std::cin >> m;
w.push_back(m);
}
int c = 0;
for (auto&& e: w) {
if (std::find(v.begin(), v.end(), e) != v.end()) {
++c;
}
}
std::cout << c << std::endl;
}
| #include <iostream> // cout, endl, cin
#include <string> // string, to_string, stoi
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <math.h> // sqrt
using namespace std;
typedef long long ll;
int main() {
int N, Q;
string S;
cin >> N >> Q;
cin >> S;
vector<vector<int>> data(Q, vector<int>(2));
for (int i = 0; i < Q; i++) {
for (int j = 0; j < 2; j++) {
cin >> data.at(i).at(j);
}
}
vector<int> rsum(N + 1, 0);
int sum = 0;
for (int i = 0; i < N - 1; i++) {
if (S.at(i) == 'A' && S.at(i + 1) == 'C') {
sum++;
}
rsum.at(i + 1) = sum;
}
int ans;
for (int i = 0; i < Q; i++) {
ans = rsum.at(data.at(i).at(1) - 1) - rsum.at(data.at(i).at(0) - 1);
cout << ans << endl;
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 7;
int x[MAXN], st[MAXN][18];
int main()
{
int n; scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
int L, Q; scanf("%d%d", &L, &Q);
// memset(st, 0x3f3f3f3f, sizeof(st));
for (int i = 1; i <= n; i++)
st[i][0] = min(n, (int)(upper_bound(x + 1, x + 1 + n, x[i] + L) - x - 1));
for (int j = 1; j < 18; j++)
for (int i = 1; i <= n; i++)
st[i][j] = st[st[i][j - 1]][j - 1];
while (Q--)
{
int l, r; scanf("%d%d", &l, &r);
if (l > r) swap(l, r);
int res = 0;
for (int j = 17; j >= 0; j--)
if (st[l][j] < r) res += (1 << j), l = st[l][j];
printf("%d\n", res + 1);
}
return 0;
} | #include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <string>
#include <cstring>
#include <set>
#include <vector>
#include <map>
using namespace std;
typedef long long LL;
const LL INF = 0x7ffffffff;
const LL NBDR = -2e7;
const LL BDR = 2e7;
const LL MAXN = 200;
LL G[MAXN][MAXN];
LL n, k, u, v, w;
void init()
{
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
G[i][j] = i == j ? 0 : INF;
}
void floyd()
{
for(int k = 0; k < n; k++)
{
for(int i = 0; i < n; i++)
{
if(G[i][k] == INF)
continue;
for(int j = 0; j < n; j++)
{
if(G[k][j] == INF)
continue;
G[i][j] = min(G[i][j], G[i][k] + G[k][j]);
}
}
}
}
int main()
{
while(scanf("%lld %lld", &n, &k) != EOF)
{
init();
int flag = 0;
while(k--)
{
scanf("%lld %lld %lld", &u, &v, &w);
G[u][v] = w;
}
floyd();
for(int i = 0; i < n; i++)
if(G[i][i] < 0)
{
printf("NEGATIVE CYCLE\n");
flag = 1;
break;
}
if(flag == 1)
continue;
for(int i = 0; i < n; i++)
{
for(int j = 0; j < n; j++)
{
if(G[i][j] == INF && j < n-1)
printf("INF ");
else if(G[i][j] == INF && j < n)
printf("INF");
else if(G[i][j] != INF && j < n-1)
printf("%lld ", G[i][j]);
else if(G[i][j] != INF && j < n)
printf("%lld", G[i][j]);
}
printf("\n");
}
}
return 0;
}
| 0 |
#include "bits/stdc++.h"
using namespace std;
#ifndef LOCAL
#define endl '\n'
#endif
#define fr(i, a, b) for(int i = a; i <= b; i++)
#define rf(i, a, b) for(int i = a; i >= b; i--)
#define pf push_front
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define sz(x) (int)x.size()
#define lb lower_bound
#define ub upper_bound
typedef long long ll;
typedef long double f80;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
int pct(int x) { return __builtin_popcount(x); }
int pct(ll x) { return __builtin_popcountll(x); }
int bt(int x) { return 31 - __builtin_clz(x); } // floor(log2(x))
int bt(ll x) { return 63 - __builtin_clzll(x); } // floor(log2(x))
int cdiv(int a, int b) { return a / b + !(a < 0 || a % b == 0); }
ll cdiv(ll a, ll b) { return a / b + !(a < 0 || a % b == 0); }
int nxt_C(int x) { int c = x & -x, r = x + c; return (((r ^ x) >> 2) / c) | r; }
ll nxt_C(ll x) { ll c = x & -x, r = x + c; return (((r ^ x) >> 2) / c) | r; }
vector<int> get_bits(int mask) {
vector<int> bb;
while(mask) { int b = bt(mask); bb.pb(b); mask ^= (1 << b); }
reverse(all(bb));
return bb;
}
int get_mask(vector<int> v) {
int mask = 0;
for(int x : v) { mask ^= (1 << x); }
return mask;
}
template<typename T>
void uniq(vector<T> &v) { sort(all(v)); v.resize(unique(all(v)) - v.begin()); }
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll rand(ll l, ll r){
uniform_int_distribution<ll> uid(l, r);
return uid(rng);
}
void sc() {}
template <typename Head, typename... Tail>
void sc(Head &H, Tail &... T) { cin >> H; sc(T...); }
#ifdef LOCAL
#define debug(...) cerr << "[L:" << __LINE__ << "][" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// #ifndef LOCAL
// string to_string(__int128 x) {
// string s = "";
// bool neg = 0;
// if(x < 0) { s += "-"; neg = 1; x = -x; }
// if(!x) s += '0';
// while(x) {
// int rem = x % 10;
// s += to_string(rem);
// x /= 10;
// }
// reverse(s.begin() + neg, s.end());
// return s;
// }
// #endif
const int mod = 1e9 + 7; // 998244353;
int pwr(int a,ll b) {
int ans = 1;
while(b) {
if(b & 1) ans = (ans * 1LL * a) % mod;
a = (a * 1LL * a) % mod;
b >>= 1;
}
return ans;
}
/*
Lookout for overflows!!
Check array sizes!!
Clear before test cases!!
Use the correct modulo!!
Check for corner cases!!
Are you forgetting something?!
Read problem statement carefully!!!
*/
const int N = 2e5 + 5;
int a[N];
void solve() {
int n;
sc(n);
fr(i, 0, n - 1) {
sc(a[i]);
a[i] = i - a[i];
debug(a[i]);
}
if(a[0] != 0) {
cout << -1;
return;
}
fr(i, 0, n - 2) {
if(a[i] > a[i + 1]) {
cout << -1;
return;
}
}
ll ans = n - 1 - a[n - 1];
rf(i, n - 1, 1) {
if(a[i] != a[i - 1]) { ans += i - 1 - a[i - 1]; debug(i - 1, ans); }
}
cout << ans;
}
int main() {
ios :: sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
// cin >> t;
for(int tt = 1; tt <= t; tt++) {
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std ;
#define pb(n) push_back(n)
#define fi first
#define se second
#define all(r) (r).begin(),(r).end()
#define gsort(st,en) sort((st),(en),greater<int>())
#define vmax(ary) *max_element(all(ary))
#define vmin(ary) *min_element(all(ary))
#define debug(x) cout<<#x<<": "<<x<<endl
#define fcout(n) cout<<fixed<<setprecision((n))
#define scout(n) cout<<setw(n)
#define vary(type,name,size,init) vector< type> name(size,init)
#define rep(i,n) for(int i = 0; i < (int)(n);++i)
#define REP(i,a,b) for(int i = (a);i < (int)(b);++i)
#define repi(it,array) for(auto it = array.begin(),end = array.end(); it != end;++it)
#define repa(n,array) for(auto &n :(array))
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using dict = map<string,int>;
using pii = pair<int,int> ;
const int mod = 1000000007;
constexpr int imax = ((1<<30)-1)*2+1 ;
constexpr int inf = 100000000;
constexpr double PI = acos(-1.0) ;
double eps = 1e-10 ;
const int dy[] = {-1,0,1,0};
const int dx[] = {0,-1,0,1};
inline bool value(int x,int y,int w,int h){
return (x >= 0 && x < w && y >= 0 && y < h);
}
template<typename T>
void Unique(vector<T> &v){
sort(all(v));
v.erase(unique(all(v)),v.end());
}
template<typename T>
T ston(string& str, T n){
istringstream sin(str) ;
T num ;
sin >> num ;
return num ;
}
void Ans(bool f){
if(f) cout << "YES"<<endl;
else cout << "NO"<<endl;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
while(cin>>n&&n){
int ans = 0;
vary(int,dp,n+3,0);
dp[1]=1,dp[2]=2,dp[3]=4;
REP(i,1,n+1){
if(i > 3){
REP(j,1,4){
dp[i] += dp[i-j];
}
}
ans += dp[i]/3650;
}
cout << 1+ dp[n] / 3650<<endl;
}
return 0;
} | 0 |
#include <iostream>
using namespace std;
struct Dice
{
Dice(int d[6]){
for(int i = 0; i < 6; ++i)
n[i] = d[i];
}
void toN(){ shift( n[0], n[1], n[5], n[4] ); }
void toS(){ shift( n[0], n[4], n[5], n[1] ); }
void toW(){ shift( n[0], n[2], n[5], n[3] ); }
void toE(){ shift( n[0], n[3], n[5], n[2] ); }
void shift( int& a, int& b, int& c, int& d ){
int t = a;
a = b;
b = c;
c = d;
d = t;
}
int n[6];
};
int main()
{
int i, d[6] = {};
for(i = 0; i < 6; ++i)
cin >> d[i];
Dice dice(d);
char c;
cin.get(c);
while( cin.get(c) ){
if( c == '\n' )
break;
switch(c)
{
case 'N': dice.toN(); break;
case 'S': dice.toS(); break;
case 'W': dice.toW(); break;
case 'E': dice.toE(); break;
}
}
cout << dice.n[0] << "\n";
return 0;
} | #include<iostream>
using namespace std;
int main () {
long n, b, min, max;
long total = 0;
min = 1000000;
max = -1000000;
cin >> n;
for(int i=0; i < n; i++) {
cin >> b;
if (b < min) {
min = b;
}
if (b > max) {
max = b;
}
total = total + b;
}
cout << min << " " << max << " " << total << endl;
return 0;
}
| 0 |
#include<iostream>
#include<vector>
using namespace std;
int main(){
int n;
vector<int> array;
cin >> n;
for(int i=0; i<n; i++){
int a;
cin >> a;
array.push_back(a);
}
for(int i=array.size()-1; i>=1; i--){
cout << array[i] << " ";
}cout << array[0] << endl;
return 0;
}
| #include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<vector>
#include<utility>
#include<queue>
#include<deque>
#include<stack>
#include<set>
#include<map>
#include<bitset>
#include<string>
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define reps(i,n) for(int i=1;i<=(int)n;i++)
#define all(v) v.begin(), v.end()
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
#define fs first
#define sc second
#define lb lower_bound
#define ub upper_bound
#define LB(a,x) lb(all(a), x) - a.begin()
#define UB(a,x) ub(all(a), x) - a.begin()
#define MOD 1000000007
#define itn int
#define enld endl
using namespace std;
typedef long long ll;
const double pi = 3.141592653589793;
template<class T> bool chmax(T &a, const T &b){if(a<b){a=b; return 1;} return 0;}
template<class T> bool chmin(T &a, const T &b){if(b<a){a=b; return 1;} return 0;}
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
std::fill( (T*)array, (T*)(array+N), val );
}
int main(){
string S;
int w;
cin >> S >> w;
int cnt = 0;
rep(i,SZ(S)){
if(cnt % w == 0){
cout << S[cnt];
}
cnt++;
}
cout << enld;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int a, b;
cin >> a >> b;
cout << a*b;
}
| #include<iostream>
#include<cstring>
using namespace std;
double eps = 1e-5;
int main() {
long long a;
double b;
string s;
cin >> a;
cin >> b;
cout << (long long)(a * (long long)(b*100 + eps * 100)) / 100;
// system("pause");
} | 1 |
#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <string>
#include <queue>
#include <algorithm>
#include <map>
#include <cmath>
#include <numeric>
#include <list>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <tuple>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<long long, long long> pll;
typedef vector<pll> vpll;
typedef long double ld;
typedef vector<ld> vld;
template <class T> void chmin(T& a, T b) { a = min(a, b);}
template <class T> void chmax(T& a, T b) { a = max(a, b);}
const int INF = 1 << 30;
const long long INFL = 1LL << 60;
const int MOD = 1000000007;
int main() {
// cout << fixed << setprecision(15);
int n;
cin >> n;
vvi a(n, vi(n));
rep(i, n) rep(j, n) cin >> a[i][j];
vll sc(1 << n);
rep(i, 1 << n) {
rep(j, n) for(int k = j; k < n; k++) {
if(!((1 << j) & i && (1 << k) & i)) continue;
sc[i] += a[j][k];
}
}
vll dp(1 << n, -INFL);
dp[0] = 0;
rep(use, 1 << n) {
int unuse = ((1 << n) - 1) & (~use);
for(int i = unuse; i > 0; i = (i - 1) & unuse) {
if(i <= use) continue;
chmax(dp[use | i], dp[use] + sc[i]);
}
}
cout << dp[(1 << n) - 1] << endl;
}
| #include <cstdio>
int N, a[100001], ref[100001], _[3][100001], d[100001], T[100001], cover[100001];
void P(int x)
{
while (x <= N)
{
T[x]++;
x += x & -x;
}
}
int G(int x)
{
int r = 0;
while (x)
{
r += T[x];
x &= x - 1;
}
return r;
}
int main()
{
scanf("%d", &N);
for (int i = 0; i < 3; i++)
for (int j = 1; j <= N; j++)
scanf("%d", _[i] + j);
for (int i = 1; i <= N; i++)
if (_[0][i] == _[1][i] - 1 && _[1][i] == _[2][i] - 1 && _[2][i] % 3 == 0)
{
a[i] = _[2][i] / 3;
ref[a[i]] = i;
d[a[i]] = 0;
}
else if (_[0][i] == _[1][i] + 1 && _[1][i] == _[2][i] + 1 && _[0][i] % 3 == 0)
{
a[i] = _[0][i] / 3;
ref[a[i]] = i;
d[a[i]] = 1;
}
else
{
puts("No");
return 0;
}
for (int i = 1; i <= N; i++)
if (i - a[i] & 1)
{
puts("No");
return 0;
}
for (int i = N - !(N & 1); i >= 1; i -= 2)
{
cover[i] ^= 1;
cover[i + (G(ref[i]) << 1)] ^= 1;
d[a[i]] ^= i - a[i] >> 1 & 1;
P(ref[i]);
}
for (int i = 2; i <= N; i++)
cover[i] ^= cover[i - 1];
for (int i = 2; i <= N; i += 2)
d[a[i]] ^= cover[i];
for (int i = 1; i <= N; i += 2)
a[i] = ref[i] = i;
for (int i = 1; i <= N; i++)
cover[i] = T[i] = 0;
for (int i = N - (N & 1); i >= 2; i -= 2)
{
cover[i] ^= 1;
cover[i + (G(ref[i]) << 1)] ^= 1;
d[a[i]] ^= i - a[i] >> 1 & 1;
P(ref[i]);
}
for (int i = 2; i <= N; i++)
cover[i] ^= cover[i - 1];
for (int i = 1; i <= N; i += 2)
d[a[i]] ^= cover[i];
if (N == 3)
puts(d[1] == 0 && d[2] == 0 && d[3] == 0 ? "Yes" : "No");
else if (N == 4)
puts(d[1] == d[2] && d[2] == d[3] && d[3] == d[4] ? "Yes" : "No");
else
{
int c0 = 0, c1 = 0;
for (int i = 1; i <= N; i += 2)
c0 += d[i];
for (int i = 2; i <= N; i += 2)
c1 += d[i];
puts((c0 & 1) || (c1 & 1) ? "No" : "Yes");
return 0;
}
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.