code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n - 1; i >= 0; i--)
using namespace std;
#define INF ((1<<30)-1)
#define LINF (1LL<<60)
#define EPS (1e-10)
typedef long long ll;
typedef pair<ll, ll> P;
const int MOD = 1000000007;
const int MOD2 = 998244353;
ll v[55];
int main(){
int n, k;
cin >> n >> k;
rep(i, n) cin >> v[i];
int m = min(n, k);
ll ans = 0;
rep(i, m+1){ // i個取り出す時を考える
rep(l, i+1){
vector<ll> tmp;
rep(j, l) tmp.push_back(v[j]);
int r = i - l;
// cout << l << " " << r << endl;
for(int j = n-1; j >= n - r; j--) tmp.push_back(v[j]);
// rep(j, tmp.size()) cout << tmp[j] << " ";
// cout << endl;
sort(tmp.begin(), tmp.end());
int res = k - (l+r);
ll s = 0;
rep(j, tmp.size()){
if (tmp[j] < 0 && res > 0){
res--;
}
else s += tmp[j];
}
ans = max(s, ans);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
ll ans = 1;
const ll mo = 1000000007;
int main()
{
ll n , m ;
cin >> n >> m ;
vector<ll> a(n);
rep(i, n){
cin >> a[i];
}
vector<ll> b(m);
rep(i, m){
cin >> b[i];
}
sort(a.rbegin(),a.rend());
sort(b.rbegin(),b.rend());
rep(i,n-1)if(a[i]==a[i+1])ans=0;
rep(i,m-1)if(b[i]==b[i+1])ans=0;
a.push_back(-1);
b.push_back(-1);
if(a[0]!=n*m||b[0]!=n*m)ans=0;
ll in=0,im=0;
for (ll i = n*m; i > 0; i--)
{
while(i<a[in]&&in!=n)in++;
while(i<b[im]&&im!=m)im++;
if(a[in]==i&&b[im]==i)continue;
else if(a[in]==i)ans=(ans*im)%mo;
else if(b[im]==i)ans=(ans*in)%mo;
else{
if(in*im-n*m+i<=0)ans=0;
else ans=(ans*(in*im-n*m+i))%mo;
}
}
cout << ans << endl;
return 0;
} | 0 |
#include<iostream>
#include<vector>
#include<string>
using namespace std;
int main(){
string str;
while(cin >> str){
vector<char> v;
int ci, cj, co;
int lv = 0;
for(int i=0; i<str.size(); ++i) v.push_back(str[i]);
ci = 0;
cj = 0;
co = 0;
for(int i=0; i<v.size(); ++i){
if(v[i] == 'J'){
++cj;
}else if(cj>0){
for(;i<v.size(); ++i){
if(v[i] == 'O'){
++co;
}else if(co>0){
for(;i<v.size(); ++i){
if(v[i] == 'I'){
++ci;
}
if(v[i] != 'I' || i == v.size()-1){
if(co <= cj && co <= ci && co > lv)lv = co;
co = 0;
ci = 0;
cj = 0;
//cout << "cj:co:ci:i = " <<cj<<":"<<co<<":"<<ci<<":"<<i<< endl;
//--i;
break;
}
}
}
if(v[i]!='O'){
co = 0;
cj = 0;
ci = 0;
i -=1;
break;
}
}
}
}
//cout << "-----------------------------"<< endl;
cout << lv << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int CountOfJOI[3];
const string target = "JOI";
int main() {
int len, curPos, k;
string input;
k = 0;
cin >> input;
len = input.size();
curPos = 0;
while (curPos < len) {
if (input[curPos] != 'J') {
++curPos;
continue;
}
memset(CountOfJOI, 0, sizeof(CountOfJOI));
for (int i = 0; i < 3; ++i) {
while (curPos < len && input[curPos] == target[i]) {
++curPos;
++CountOfJOI[i];
}
}
if (CountOfJOI[1] <= CountOfJOI[0] && CountOfJOI[1] <= CountOfJOI[2]) {
k = max(k, CountOfJOI[1]);
}
}
cout << k << endl;
return 0;
}
| 1 |
#include <iostream>
#include <string>
using namespace std;
int main(){
int n;
cin >> n;
while(n--){
int runner = 0, out = 0, score = 0;
while(out < 3){
string e;
cin >> e;
if(e == "HIT"){
runner = (runner << 1) + 1;
if(runner & 0xf8){ ++score; }
}else if(e == "HOMERUN"){
++score;
if(runner & 0x01){ ++score; }
if(runner & 0x02){ ++score; }
if(runner & 0x04){ ++score; }
runner = 0;
}else if(e == "OUT"){
++out;
}
runner &= 0x07;
}
cout << score << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
const i64 MOD = 998244353;
const i64 INF = 998244353;
template <typename T>
bool chmin(T& x, T y){
if(x > y){
x = y;
return true;
}
return false;
}
template <typename T>
bool chmax(T& x, T y){
if(x < y){
x = y;
return true;
}
return false;
}
template <i64 mod = MOD>
struct ModInt{
i64 p;
ModInt() : p(0){}
ModInt(i64 x){p = x >= 0 ? x % mod : x + (-x + mod - 1) / mod * mod;}
ModInt& operator+=(const ModInt& y){p = p + *y - ((p + *y) >= mod ? mod : 0); return *this;}
ModInt& operator-=(const ModInt& y){p = p - *y + (p - *y < 0 ? mod : 0); return *this;}
ModInt& operator*=(const ModInt& y){p = (p * *y) % mod; return *this;}
ModInt& operator%=(const ModInt& y){if(y)p %= *y; return *this;}
ModInt operator+(const ModInt& y) const{ModInt x = *this; return x += y;}
ModInt operator-(const ModInt& y) const{ModInt x = *this; return x -= y;}
ModInt operator*(const ModInt& y) const{ModInt x = *this; return x *= y;}
ModInt operator%(const ModInt& y) const{ModInt x = *this; return x %= y;}
friend ostream& operator<<(ostream& stream, const ModInt<mod>& x){
stream << *x;
return stream;
}
friend ostream& operator>>(ostream& stream, const ModInt<mod>& x){
stream >> *x;
return stream;
}
ModInt& operator++(){p = (p + 1) % mod; return *this;}
ModInt& operator--(){p = (p - 1 + mod) % mod; return *this;}
bool operator==(const ModInt& y) const{return p == *y;}
bool operator!=(const ModInt& y) const{return p != *y;}
const i64& operator*() const{return p;}
i64& operator*(){return p;}
};
using mint = ModInt<>;
auto mpow = [](auto x, i64 y){
auto z = x;
decltype(x) val = y & 1 ? x : decltype(x)(1);
while(z *= z, y >>= 1)
if(y & 1)
val *= z;
return val;
};
signed main(){
int n;
cin >> n;
vector<int> a(n);
map<int,int> v;
for(int i = 0; i < n; ++i){
cin >> a[i];
++v[a[i]];
}
if(a[0] != 0 || v[0] != 1){
cout << 0 << endl;
return 0;
}
int ma = *max_element(a.begin(), a.end());
mint ans = 1;
for(int i = 1; i <= ma; ++i){
if(v[i] == 0){
cout << 0 << endl;
return 0;
}
ans *= mpow(mint(v[i - 1]), v[i]);
}
cout << ans << endl;
}
| 0 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
using namespace std;
#define FOR(i,a,b) for(long long i=(a);i<(b);i++)
#define REP(i,N) for(long long i=0;i<(N);i++)
#define ALL(s) (s).begin(),(s).end()
#define fi first
#define se second
#define PI acos(-1.0)
#define INF 1000000007
#define EPS 1e-10
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<double, double> PD;
typedef pair<string, ll> PS;
typedef vector<ll> V;
typedef pair<P, char> PC;
ll n;
ll index, a, b;
ll sum[5000];
V vi;
int main(){
while (cin >> n&&n){
vi.clear();
fill(sum, sum + 5000, 0);
REP(i, n){
cin >> index >> a >> b;
if (find(ALL(vi), index) == vi.end()){
vi.push_back(index);
}
if (sum[index] >= 1000000)continue;
sum[index] += a*b;
}
bool f = 1;
REP(i, vi.size()){
if (sum[vi[i]] >= 1000000){
cout << vi[i] << endl;
f = 0;
}
}
if (f)cout << "NA" << endl;
}
} | #include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <cstdio>
#include <functional>
#include <set>
#include <sstream>
#include <cctype>
#include <stack>
#include <queue>
#include <cstring>
#include <map>
using namespace std;
int main(){
int n;
while(cin>>n,n){
map<long double,set<string> > ans;
for(int i=0;i<n;i++){
string name;
long double p,a,b,c,d,e,f,s,m;
cin>>name>>p>>a>>b>>c>>d>>e>>f>>s>>m;
ans[((f*s*m)-p)/(a+b+c+m*(d+e))].insert(name);
}
for(auto it=ans.rbegin();it!=ans.rend();it++){
set<string> ss =it->second;
for(auto it2=ss.begin();it2!=ss.end();it2++) cout<<(*it2)<<endl;
}
cout<<"#"<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
#define rep2(i,a,n) for(int i=(a); i<(n); i++)
#define all(vec) vec.begin(),vec.end()
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
int main() {
int N,T; cin>>N>>T;
vi time(N);
rep(i,N) cin>>time[i];
ll ans = 0;
int ct=0;
rep(i,N){
if(time[i]>=ct){
ans += T;
}
else {
ans = ans + time[i] - ct + T;
}
ct = time[i]+T;
}
cout << ans << endl;
} | #include<stdio.h>
#include<vector>
#include<algorithm>
using namespace std;
#define get(A,B,C,D) (rui[B][D]-rui[A-1][D]-rui[B][C-1]+rui[A-1][C-1])
short dp[102][102][102][102];
int map[100][100];
short rui[101][101];
int main()
{
int mx,my;
scanf("%d%d",&mx,&my);
int sx,sy;
for(int i=0;i<mx;i++)
{
for(int j=0;j<my;j++)
{
char z;
scanf(" %c",&z);
if(z=='o')map[i][j]=1;
if(z=='E')sx=i,sy=j;
}
}
for(int i=0;i<mx;i++)for(int j=0;j<my;j++)rui[i+1][j+1]=rui[i+1][j]+rui[i][j+1]-rui[i][j]+map[i][j];
short maxi=0;
for(int i=1;i<=mx;i++)
{
for(int j=mx;j>=i-1;j--)
{
for(int k=1;k<=my;k++)
{
for(int l=my;l>=k-1;l--)
{
short t=dp[i][j][k][l];
maxi=max(maxi,t);
if(i>j||k>l)continue;
int si=1+sx-(mx-j);
int sj=1+sx+(i-1);
int sk=1+sy-(my-l);
int sl=1+sy+(k-1);
dp[i+1][j][k][l]=max(dp[i+1][j][k][l],t);
dp[i][j-1][k][l]=max(dp[i][j-1][k][l],t);
dp[i][j][k+1][l]=max(dp[i][j][k+1][l],t);
dp[i][j][k][l-1]=max(dp[i][j][k][l-1],t);
if(si<=i)dp[i+1][j][k][l]=max(dp[i+1][j][k][l],short(t+get(i,i,max(sk,k),min(sl,l))));
if(sj>=j)dp[i][j-1][k][l]=max(dp[i][j-1][k][l],short(t+get(j,j,max(sk,k),min(sl,l))));
if(sk<=k)dp[i][j][k+1][l]=max(dp[i][j][k+1][l],short(t+get(max(si,i),min(sj,j),k,k)));
if(sl>=l)dp[i][j][k][l-1]=max(dp[i][j][k][l-1],short(t+get(max(si,i),min(sj,j),l,l)));
}
}
}
}
printf("%d\n",maxi);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int>c(N, -1);
int s, t;
int ans = 0;
bool b = true;
for (int i = 0; i < M; i++) {
cin >> s;
if (c[s - 1] == -1){
cin >> c[s - 1];
}else{
cin >> t;
if (c[s - 1] != t) {
b = false;
ans = -1;
break;
}
}
}
if (c[0] == -1) {
if (N > 1) {
c[0] = 1;
}else {
c[0] = 0;
}
}else if (c[0] == 0 && N > 1){
b = false;
ans = -1;
}
for (int i = 1; i < N; i++) {
if (c[i] == -1) {
c[i] = 0;
}
}
if (b) {
int d = 1;
for (int i = N - 1; i >= 0; i--) {
ans += c[i]*d;
d *= 10;
}
}
//cout << c[0] << ',' << c[1] << ',' << c[2] << endl;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<bool>> a(n, vector<bool>(m));
for (int i = 0; i < n; i++) {
string foo;
cin >> foo;
for (int j = 0; j < m; j++) {
a[i][j] = foo[j] == '#';
}
}
queue<pair<int, int>> que;
vector<vector<int>> dist(n, vector<int>(m, -1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j]) {
que.push({i, j});
dist[i][j] = 0;
}
}
}
while (!que.empty()) {
auto u = que.front();
que.pop();
int x = u.first, y = u.second;
for (int i = 0; i < 4; i++) {
int tx = x + dx[i], ty = y + dy[i];
if (0 <= tx && tx < n && 0 <= ty && ty < m && dist[tx][ty] == -1) {
dist[tx][ty] = dist[x][y] + 1;
que.push({tx, ty});
}
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ans = max(ans, dist[i][j]);
}
}
cout << ans << '\n';
return 0; // :)
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
#define FOR(i,n,j) for(int i=(j);i<(n);++i)
#define ssort(n) sort((n).begin(),(n).end())
#define rsort(n) sort((n).begin(),(n).end(),greater<int>())
using ll=long long;
using ld=long double;
typedef pair<int,int> P;
typedef pair<P,int> COST;
#define repl(i,n) for(ll i=0;i<(n);++i)
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define YES cout << "YES" << endl
#define NO cout << "NO" << endl
using Graf=vector<vector<int>>;
#define MAX 10000000
int main()
{
int n;
cin >> n;
vector<ll> a(n);
rep(i,n){
cin >> a[i];
}
ll sum=0;
ll tmp=0;
int count=0;
rep(i,n){
if(a[i]<0)count++;
a[i]=abs(a[i]);
sum+=a[i];
}
ssort(a);
if(count%2==0){
cout << sum << endl;
}else{
cout << sum-2*a[0] << endl;
}
} | #include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<queue>
#include<deque>
#include<cmath>
#include<map>
#include<unordered_map>
#include<set>
#include<cstring>
#include<iomanip> //cout << fixed << setprecision(15) << x << endl;
using namespace std;
typedef long long ll;
const ll INF = 1e9 + 6;
const ll MOD = 1e9 + 7;
const ll LLINF = 1LL<<60;
#define Pint pair<int, int>
#define rng(i,a,b) for(int i=int(a);i<int(b);i++)
#define rep(i,b) rng(i,0,b)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
/* -- template -- */
const int mod = 998244353;
long long modpow(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
int N; cin >> N;
map<int, ll> m;
int D[N]; rep(i, N) cin >> D[i], m[D[i]]++;
bool ok = true;
if(D[0] != 0) ok = false;
if(m[0] != 1) ok = false;
ll ans = 1;
ll prev = m[0], prev_num = -1;
for(auto itr = m.begin(); itr != m.end(); ++itr) {
if(prev_num != itr -> first - 1) ok = false;
ans = (ans * modpow(prev, itr -> second)) % mod;
prev = itr -> second;
prev_num = itr -> first;
}
cout << ((ok) ? ans : 0) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define run ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);cerr.tie(0);
#define MOD 1000000007
#define ms(a,x) memset(a,x,sizeof(a))
int main()
{
run;
ll n,i,ans=0;
cin>>n;
ll a[n], b[n+1]={0};
for(i=0;i<n;i++)
{
cin>>a[i];
b[i+1]+=b[i]+a[i];
}
for(i=0;i<n;i++)
{
ll sum=(b[n]-b[i+1])%MOD;
ans+=a[i]*sum;
ans%=MOD;
}
cout<<ans<<endl;
}
| #include <iostream>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
bool is_prime(int n) {
for (int p = 2; p * p <= n; p++) {
if (n % p == 0) {
return false;
}
}
return true;
}
vector<pair<int, int>> factorize(int n) {
vector<pair<int, int>> result;
for (int p = 2; p * p <= n; p++) {
if (is_prime(p)) {
int cnt = 0;
while (n % p == 0) {
n /= p;
cnt++;
}
if (cnt > 0) {
result.push_back(make_pair(p, cnt));
}
}
}
if (n != 1) {
result.push_back(make_pair(n, 1));
}
return move(result);
}
int main() {
int n;
cin >> n;
vector<int> e(n + 1, 0);
for (int i = 1; i <= n; i++) {
auto factor = factorize(i);
for (const auto f : factor) {
int p, j;
tie(p, j) = f;
e[p] += j;
}
}
const int64_t MOD = 1e9 + 7;
int64_t result = 1;
for (int i = 1; i <= n; i++) {
result *= e[i] + 1;
result %= MOD;
}
cout << result << endl;
return 0;
} | 0 |
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
bool block[6][110][110];
bool visit[110][110];
int main(){
int w, h;
int xs, ys, xg, yg;
int n, c, d, x, y;
while(scanf("%d%d%d%d%d%d%d", &w, &h, &xs, &ys, &xg, &yg, &n) == 7){
memset(block, 0, sizeof block);
memset(visit, 0, sizeof visit);
for(int i = 0; i < n; ++i){
scanf("%d%d%d%d", &c, &d, &x, &y);
int dx, dy;
if(d){ dx = 2; dy = 4; }
else{ dy = 2; dx = 4; }
for(int j = 0; j < dy; ++j)
for(int k = 0; k < dx; ++k){
block[c][y + j][x + k] = true;
}
}
for(c = 5; c > 1 && !block[c][ys][xs]; --c);
if(c){
queue<int> q;
q.push(ys << 16 | xs);
visit[ys][xs] = true;
while(!q.empty()){
y = q.front() >> 16;
x = q.front() & 0xffff;
q.pop();
for(int dy = -1; dy <= 1; ++dy)
for(int dx = -1; dx <= 1; ++dx){
if(block[c][y+dy][x+dx] && !visit[y+dy][x+dx]){
visit[y+dy][x+dx] = true;
q.push(y+dy << 16 | x+dx);
}
}
}
}
puts(visit[yg][xg] ? "OK" : "NG");
}
} | #include <iostream>
#include <string>
using namespace std;
string ans;
int w,h,gx,gy;
int map[110][110];
int dx_[4] = {0,1,0,-1};
int dy_[4] = {1,0,-1,0};
int dx[2][8] = {
{0,1,2,3,0,1,2,3},
{0,1,0,1,0,1,0,1}
};
int dy[2][8] = {
{0,0,0,0,1,1,1,1},
{0,0,1,1,2,2,3,3},
};
void solve(int x,int y,int color){
if( ans == "OK" || color == 0 ) return;
for(int i=0 ; i<4 ; ++i ){
int mx = x + dx_[i];
int my = y + dy_[i];
if( mx<0 || mx>w || my<0 || my>h ) continue;
if( map[my][mx] == color ){
if( mx == gx && my == gy ){
ans = "OK";
}else{
map[my][mx] = 0;
solve( mx , my , color );
}
}
}
}
int main(){
int sx,sy,n;
while( cin >> w >> h , w|h ){
ans = "NG";
for(int y=0 ; y<110 ; ++y )
for(int x=0 ; x<110 ; ++x )
map[y][x] = 0;
cin >> sx >> sy >> gx >> gy >> n ;
for(int i=0 ; i<n ; ++i ){
int c,d,x,y;
cin >> c >> d >> x >> y;
for(int j=0 ; j<8 ; j++){
int mx = x + dx[d][j];
int my = y + dy[d][j];
map[my][mx] = c;
}
}
solve( sx , sy , map[sy][sx] );
cout << ans << endl;
}
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int h,w;
cin >> h >> w;
vector<vector<int>> a(h,vector<int>(w,0));
for(int i=0;i<h;++i){
for(int j=0;j<w;++j){
cin >> a[i][j];
}
}
vector<tuple<int,int,int,int>> ans;
for(int i=0;i<h;++i){
for(int j=0;j<w-1;++j){
if(a[i][j]%2==1){
a[i][j]--;
a[i][j+1]++;
ans.push_back(make_tuple(i,j,i,j+1));
}
}
}
for(int i=0;i<h-1;++i){
if(a[i][w-1]%2==1){
a[i][w-1]--;
a[i+1][w-1]++;
ans.push_back(make_tuple(i,w-1,i+1,w-1));
}
}
int n=ans.size();
cout << n << endl;
for(auto p : ans){
cout << get<0>(p)+1 << " " << get<1>(p)+1 << " " << get<2>(p)+1 << " " << get<3>(p)+1 << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define rep(i,n) for(ll (i)=0; (i)<(ll)(n); (i)++)
#define frep(i,m,n) for(ll (i)=(m); (i)<=(ll)(n); (i)++)
#define rrep(i,n) for(ll (i)=(n)-1; (i)>-1; (i)--)
#define frrep(i,m,n) for(ll (i)=(n); (i)>(ll)(m); (i)--)
#define ALL(x) (x).begin(), (x).end()
const ll INF = 100100100100100100;
const ll MOD = 1000000007;
// get abs
ll my_abs(ll a);
// a^n
ll a_n(ll a, ll n);
// get gcd
ll my_gcd(ll a, ll b);
// a^(-1) % MOD
ll inv(ll a);
// (a+b+c)%MOD
ll madd(ll a, ll b, ll c);
// (a-b)%MOD
ll msub(ll a, ll b);
// (a*b*c)%MOD
ll mtime(ll a, ll b, ll c);
int main() {
ll h, w;
cin >> h >> w;
vector<vector<bool>> odd(h, vector<bool>(w, false)); // 奇数ならtrue;
vector<pair<P,P>> ans;
rep(i, h) {
rep(j, w) {
ll a; cin >> a;
if((a%2) == 1) odd[i][j] = true;
}
}
rep(i, h) {
bool ok = false; // 奇数から取ったコインを移動中
rep(j, w) {
if(odd[i][j]) {
if(ok) {
ok = false;
}
else {
ok = true;
if(j != w-1) ans.push_back(make_pair(P(i+1,j+1), P(i+1,j+2)));
}
}
else {
if(ok && (j != w-1)) {
ans.push_back(make_pair(P(i+1,j+1), P(i+1,j+2)));
}
}
}
if(ok && i != h-1) {
ans.push_back(make_pair(P(i+1,w), P(i+2,w)));
odd[i+1][w-1] = !(odd[i+1][w-1]);
}
}
cout << ans.size() << endl;
rep(i, ans.size()) {
cout << ans[i].first.first << ' ';
cout << ans[i].first.second << ' ';
cout << ans[i].second.first << ' ';
cout << ans[i].second.second << endl;
}
return 0;
}
ll my_abs(ll a) {
if(a >= 0) return a;
else return -1 *a;
}
ll a_n(ll a, ll n) {
if(n == 0) return 1;
ll ret = a, count = 1;
while(count * 2 < n) {
ret *= ret;
count *= 2;
}
if(count == n) return ret;
else return (ret * a_n(a, n-count));
}
ll my_gcd(ll a, ll b) {
if(b == 0) return a;
return my_gcd(b, a%b);
}
ll inv(ll a) {
return a_n(a, MOD-2);
}
ll madd(ll a, ll b, ll c) {
ll ret = (a+b) % MOD;
return (ret+c) % MOD;
}
ll msub(ll a, ll b) {
if(a < b) return (a-b+MOD) % MOD;
else return (a-b) % MOD;
}
ll mtime(ll a, ll b, ll c) {
ll ret = (a*b) % MOD;
return (ret*c) % MOD;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int mod = 1000000007;
//const int mod = 998244353;
//#define int long long
//signed main(){
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
ll a[n];
for(ll i = 0; i < n; i++) {
cin >> a[i];
}
ll cnt[3][n+1];
cnt[0][0]=0;
cnt[1][0]=0;
cnt[2][0]=0;
for(ll i = 0; i < n; i++) {
ll c=0;
while(cnt[c][i]!=a[i]){
c++;
if(c==3){
cout << "0" << "\n";
return 0;
}
}
for(ll j = 0; j < 3; j++) cnt[j][i+1]=cnt[j][i];
cnt[c][i+1]++;
}
for(ll i = 0; i < 3; i++) {
for(ll j = 0; j < n; j++) {
cerr << std::right << std::setw(2) << cnt[i][j];
}
cerr << "\n";
}
ll ans=1;
for(ll i = 0; i < n; i++) {
ll tmp=0;
for(ll j = 0; j < 3; j++) if(a[i]==cnt[j][i]) tmp++;
cerr << std::right << std::setw(2) << tmp;
ans=(ans*tmp)%mod;
}
cout << ans << "\n";
return 0;
} | #include<iostream>
#include<algorithm>
#include<vector>
#include<stdio.h>
#include<cstring>
#include<math.h>
#include<map>
#include<bitset>
#include<iomanip>
#include<queue>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
using P = pair<int, int>;
const long long MOD = 1000000007;
long long N;
long long a[100000] = {0};
int main() {
cin >> N;
long long ans = 1;
rep(i, N) {
long long A;
cin >> A;
long long temp;
if(A == 0) {
temp = 3 - a[A];
} else {
temp = a[A-1] - a[A];
}
ans = ans * temp % MOD;
a[A]++;
}
if(ans <= 0) cout << 0 << endl;
else cout << ans << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
int gcd(int x, int y) { return (x % y)? gcd(y, x % y): y; } //最大公約数
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; } //最小公倍数
using Graph = vector<vector<ll>>;
ll inf=300000000000000000;
const double PI = 3.14159265358979323846;
int main(){
ll n;
cin >> n;
string s="";
ll m=1;
if(n==0){
cout << 0 << endl;
return 0;
}
while(n!=0){
if(abs(n)%(abs(m)*2)!=0){
s='1'+s;
n-=m;
}
else s='0'+s;
m*=-2;
}
cout << s << endl;
}
| #pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#include <bits/stdc++.h>
using namespace std;
#define getchar getchar_unlocked
template <class T>
inline void _read(T &x)
{
x = 0;
char t = getchar();
while (!isdigit(t)) t = getchar();
while (isdigit(t))
{
x = x * 10 + t - '0';
t = getchar();
}
}
constexpr int MAXN = 1e6 + 10, mo = 998244353;
int n, m, ans, sum, fac[MAXN], inv[MAXN];
inline int C(int n, int m)
{
return 1ll * fac[n] * inv[m] % mo * inv[n - m] % mo;
}
int main()
{
_read(n), _read(m);
if (n < m)
swap(n, m);
ans = n;
fac[0] = fac[1] = inv[0] = inv[1] = 1;
for (int i = 2; i <= n + m; ++i)
fac[i] = 1ll * fac[i - 1] * i % mo, inv[i] = 1ll * (mo - mo / i) * inv[mo % i] % mo;
for (int i = 2; i <= n + m; ++i)
inv[i] = 1ll * inv[i] * inv[i - 1] % mo;
for (int i = 1; i <= m; ++i)
sum = (1ll * C(i << 1, i) * C(n + m - (i << 1), n - i) + sum) % mo;
printf("%d", (1ll * sum * inv[2] % mo * inv[n + m] % mo * fac[n] % mo * fac[m] + ans) % mo);
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
int main(){
int n;
cin>>n;
vector<int> l(n*2);
rep(i,n*2) cin>>l.at(i);
sort(l.begin(),l.end());
int ans=0;
rep(i,n){
ans+=l.at(2*i);
}
cout<<ans;
} |
// C - 2D Plane 2N Points
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// const int INF = 2147483647;
// const ll INF = 9223372036854775807;
// const ll MOD = 1e9 + 7;
pair<int, int> red[100];
pair<int, int> blue[100];
bool used_red[100];
int main() {
int N;
cin >> N;
for (int i=0; i<N; i++) {
int a, b;
cin >> a >> b;
red[i] = make_pair(a, b);
}
for (int i=0; i<N; i++) {
int c, d;
cin >> c >> d;
blue[i] = make_pair(c, d);
}
sort(blue, blue+N);
int ans = 0;
for (int i=0; i<N; i++) {
int bx = blue[i].first;
int by = blue[i].second;
int max_ry = -1;
int max_red_idx = -1;
for (int j=0; j<N; j++) {
int rx = red[j].first;
int ry = red[j].second;
if (rx < bx && ry < by && ry > max_ry && used_red[j] == false) {
max_red_idx = j;
max_ry = ry;
}
}
if (max_red_idx != -1) {
ans++;
used_red[max_red_idx] = true;
}
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
typedef long long ll;
const int maxn = 1e5 + 1e2;
int bipart[maxn];
int color[maxn];
std::vector<int> adj[maxn];
int main(){
std::ios::sync_with_stdio(false);
int v, e;
std::cin >> v >> e;
for(int i = 0; i < e; i++){
int f, s;
std::cin >> f >> s;
f--, s--;
adj[f].push_back(s);
adj[s].push_back(f);
}
memset(bipart, -1, sizeof(bipart));
memset(color, -1, sizeof(color));
ll single = 0;
ll nonbipartite = 0;
ll bipartite = 0;
for(int i = 0; i < v; i++){
if(bipart[i] == -1){
std::queue<int> q;
bipart[i] = 1;
int size = 0;
q.push(i);
color[i] = 0;
while(!q.empty()){
int fr = q.front();
size++;
q.pop();
for(int next : adj[fr]){
if(color[next] == -1){
bipart[next] = 0;
color[next] = !color[fr];
q.push(next);
} else if(color[next] == color[fr]){
bipart[i] = 0;
}
}
}
if(size == 1){
single++;
} else if(bipart[i]){
bipartite++;
} else {
nonbipartite++;
}
}
}
ll sum = 0;
sum += (ll) 2 * v * single;
sum -= single * single;
sum += 2 * bipartite * bipartite;
sum += 2 * bipartite * nonbipartite;
sum += nonbipartite * nonbipartite;
std::cout << sum << '\n';
}
| #pragma GCC optimize ("O3")
#pragma GCC target ("avx")
//#include<bits/stdc++.h>
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
const int cm = 1 << 17;
char cn[cm], * ci = cn + cm, ct;
inline char getcha() {
if (ci - cn == cm) { fread_unlocked(cn, 1, cm, stdin); ci = cn; }
return *ci++;
}
inline int getint() {
int A = 0;
if (ci - cn + 16 > cm) while ((ct = getcha()) >= '0') A = A * 10 + ct - '0';
else while ((ct = *ci++) >= '0') A = A * 10 + ct - '0';
return A;
}
//わけわかめ
int P[100001];
bool dame[100001];
int Find(int A) {
if (P[A] < 0) return A << 1;
return P[A] = Find(P[A] >> 1) ^ (P[A] & 1);
}
int main() {
//cin.tie(0);
//ios::sync_with_stdio(false);
int N = getint(), M = getint();
rep1(i, N) P[i] = -1;
rep(i, M) {
int a = Find(getint());
int b = Find(getint());
//なんてセンスのない
int a1 = a >> 1;
int b1 = b >> 1;
if (a1 == b1) {
if (!((a ^ b) & 1)) dame[a1] = true;
continue;
}
if (P[a1] > P[b1]) {
P[b1] += P[a1];
dame[b1] |= dame[a1];
P[a1] = b ^ !(a & 1);
}
else {
P[a1] += P[b1];
dame[a1] |= dame[b1];
P[b1] = a ^ !(b & 1);
}
}
ll x = 0, y = 0, z = 0;
rep1(i, N) {
if (P[i] < 0) {
if (P[i] == -1) z++;
else if (dame[i]) y++;
else x++;
}
}
printf("%lld\n", x * x + (x + y) * (x + y) + 2 * N * z - z * z);
Would you please return 0;
} | 1 |
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<complex>
#define rep(i, a, n) for(int i=a;i<n;i++)
#define REP(i, n) rep(i, 0, n)
#define repb(i, a, b) for(int i = a; i >= b; i--)
#define all(a) a.begin(), a.end()
#define int long long
#define R long double
#define P complex<R>
using namespace std;
const int mod = 1000000007;
const int INF = 1e12;
template<class T>bool chmax(T &a, const T &b) { return (a < b) ? (a = b, 1) : 0;}
template<class T>bool chmin(T &a, const T &b) { return (b < a) ? (a = b, 1) : 0;}
const R PI = acos(-1.0L);
const R inf = 1e13;
int x[110], y[110];
R ans[110];
inline R dist(int i, P q) {
P p = P(x[i], y[i]);
return norm(p - q);
}
signed main(){
int n;
cin>>n;
for (int i=0;i<n;i++)
{
cin>>x[i]>>y[i];
}
int limit = 200000;
rep(i, 0, limit){
R cur = 2.0 * PI / limit * i;
P point = polar(inf, cur);
R d = 1e130;
int idx = -1;
rep(j, 0, n) if(chmin(d, dist(j, point))) idx = j;
ans[idx] += 1.0;
}
cout.precision(20);
rep(i, 0, n) cout << fixed << 1.0 * ans[i] / limit << endl;
return 0;
}
| #include<iostream>
#include<algorithm>
using namespace std;
int main()
{
int n, i, j, l,k;
int A[101];
int q[101][101];
cin >> n;
for (i = 1; i < n+1; i++) {
cin >> A[i - 1] >> A[i];
}
for (i = 0; i < n + 1; i++) q[i][i] = 0;
for (l = 2; l < n + 1; l++) {
for (i = 1; i < n - l + 2; i++) {
j = i + l - 1;
q[i][j] = (1<<21);
for (k = i; k < j; k++) {
q[i][j] = min(q[i][j], q[i][k] + q[k + 1][j] + A[i - 1] * A[k] * A[j]);
}
}
}
cout << q[1][n] << endl;
} | 0 |
//Author: Fuadul Hasan([email protected])
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 2e5 + 5;
int main(){
int a,b;
cin>>a>>b;
cout<<max(a+(a-1),max(b+(b-1),a+b))<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define INF 1000000000
int main() {
int a,b,ans;
cin >> a >> b;
ans = (a==b ? 2*a : 2*max(a,b)-1);
cout << ans << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
using P = pair<int,int>;
/* ちゃんと考えてわかって実装 */
ll amari(ll a){
if(abs(a) % 2 == 0) return 0;
else return 1;
}
ll sho(ll a){
if(a<0 && amari(a)==1) return (a / (-2)) + 1;
else return a / (-2);
}
stack<char> base_min2(ll a){
stack<char> res;
if(a == 0){
res.push('0');
return res;
}
while(true){
if(a == 1){
res.push('1');
break;
}
else{
if(amari(a) == 1){
res.push('1');
a = sho(a);
}
else if(amari(a) == 0){
res.push('0');
a = sho(a);
}
}
}
return res;
}
int main(void){
ll n;
cin >> n;
stack<char> ans = base_min2(n);
while(!ans.empty()){
cout << ans.top();
ans.pop();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin>>S;
for(int i=0;i<8;i++){
string ans;
ans+=S.at(0);
int sum=S.at(0)-'0';
for(int j=0;j<3;j++){
if(i>>j&1){
sum+=S.at(j+1)-'0';
ans+="+";
ans+=S.at(j+1);
}
else{
sum-=S.at(j+1)-'0';
ans+="-";
ans+=S.at(j+1);
}
}
if(sum==7){
cout<<ans<<"=7"<< endl;
return 0;
}
}
} | 0 |
#include <cstdio>
#include <algorithm>
using namespace std;
int N, M, p[1001], s[1001 * 1001];
int main(){
while(scanf("%d%d", &N, &M) != EOF && (N|M)){
for(int x = 0; x < N; x++){
scanf("%d", p+x);
}
p[N++] = 0;
for(int x = 0; x < N; x++){
for(int y = 0; y < N; y++){
s[N*x + y] = p[x] + p[y];
}
}
sort(s, s+N*N);
int ans = 0;
for(int x = 0; x < N*N; x++){
int* lb = lower_bound(s, s + N * N, M - s[x]);
if(lb != s) --lb;
if(s[x] + *lb > M) continue;
ans = max(ans, s[x] + *lb);
}
printf("%d\n", ans);
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define chmax(x,y) x = max(x,y);
#define chmin(x,y) x = min(x,y);
const int di[] = {-1, 0, 1, 0};
const int dj[] = {0, -1, 0, 1};
const int INF = 1001001001;
int main() {
int h, w;
cin >> h >> w;
vector<vector<int>> a(h, vector<int>(w));
rep(i,h)rep(j,w) cin >> a[i][j];
vector<P> now, next;
rep(i,h)rep(j,w) {
if (a[i][j]%2 == 0) continue;
if (i == h-1 && j == w-1) continue;
if (i == h-1) {
now.emplace_back(i+1,j+1);
next.emplace_back(i+1,j+2);
a[i][j]--;
a[i][j+1]++;
continue;
}
if (j == w-1) {
now.emplace_back(i+1,j+1);
next.emplace_back(i+2,j+1);
a[i][j]--;
a[i+1][j]++;
continue;
}
now.emplace_back(i+1,j+1);
next.emplace_back(i+2,j+1);
a[i][j]--;
a[i+1][j]++;
}
int n = now.size();
cout << n << endl;
rep(i,n) {
cout << now[i].first << " " << now[i].second << " " << next[i].first << " " << next[i].second << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(k,i,n) for(ll i=k;i<n;++i)
ll dx[4]={1,-1,0,0},dy[4]={0,0,1,-1};
int main(void){
ll h,w;
cin>>h>>w;
string s[h];
rep(0,i,h)cin>>s[i];
ll ans=0;
vector<vector<bool>>d(h,vector<bool>(w,false));
rep(0,i,h){
rep(0,j,w){
if(d[i][j]==false){
ll cw=0,cb=0;
queue<pair<ll,ll>>q;
d[i][j]=true;
q.push({i,j});
while(!q.empty()){
ll x=q.front().first,y=q.front().second;q.pop();
if(s[x][y]=='#')++cb;
else ++cw;
rep(0,k,4){
ll nx=x+dx[k],ny=y+dy[k];
if(!(nx>=0&&nx<h&&ny>=0&&ny<w))continue;
if(s[x][y]!=s[nx][ny]&&(!d[nx][ny])){
d[nx][ny]=true;
q.push({nx,ny});
}
}
}
//cout<<cb<<" "<<cw<<endl;
ans+=cw*cb;
}
}
}
cout<<ans;
} | #include<bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int,int>;
ll dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
ll counterb=0,counterw=0;
void dfs(ll x,ll y,ll H, ll W,vector<vector<bool>> &field,vector<vector<bool>> &check){
check[x][y]=1;
if(field[x][y]==1){counterb++;}
if(field[x][y]==0){counterw++;}
bool meter=(x+y+field[x][y])%2;
for(int i=0;i<4;i++){if(x+dx[i]>=0&&x+dx[i]<H&&y+dy[i]>=0&&y+dy[i]<W){
if(check[x+dx[i]][y+dy[i]]==0&&(x+y+dx[i]+dy[i]+field[x+dx[i]][y+dy[i]])%2==meter){
dfs(x+dx[i],y+dy[i],H,W,field,check);
};}
;}
}
int main(){
ll H;
cin >> H;
ll W;
cin >> W;
vector<vector<bool>> field(H, vector<bool>(W, 0));
vector<vector<bool>> check(H, vector<bool>(W, 0));
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
char k;
cin>>k;
if(k=='#'){field[i][j]=1;}
;}
;}
ll ans=0;
for(ll i=0;i<H;i++){
for(ll j=0;j<W;j++){
if(check[i][j]==0){
dfs(i,j,H,W,field,check);ans+=counterb*counterw;
counterb=0;counterw=0;
}
;}
;}
cout<<ans<<endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define REP(i,n) for (ll i = 0; i < (n); ++i)
#define RREP(i, n) for (ll i = (n) - 1; i >= 0; --i)
#define ALL(v) (v).begin(), (v).end()
template<class T>
using reverse_priority_queue = priority_queue<T, vector<T>, greater<T>>;
int main(){
ll n, m;
cin >> n >> m;
vector<vector<ll>> a(n, vector<ll>(m));
REP(i, n){
REP(j, m){
cin >> a.at(i).at(j);
a.at(i).at(j)--;
}
reverse(ALL(a.at(i)));
}
ll ans = n;
vector<bool> use(m, true);
REP(_, m){
vector<ll> count(m, 0);
REP(i, n){
while(!use.at(a.at(i).back())){
a.at(i).pop_back();
}
count.at(a.at(i).back())++;
}
const ll max_idx = max_element(ALL(count)) - count.begin();
ans = min(ans, count.at(max_idx));
use.at(max_idx) = false;
}
cout << ans << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define F first
#define S second
#define int long long
const int maxn = 310;
const ll inf = 1e18+10;
//const int mod = 998244353;
//const int mod = 1e9+7;
int n, m;
int a[maxn][maxn], ptr[maxn], cnt[maxn];
bool mark[maxn];
bool ok(int q)
{
// cout<< q <<" ";
set<pair<int,int>> se;
for(int i = 1; i <= m; i++) cnt[i] = 0;
for(int i = 1; i <= n; i++)
{
ptr[i] = 1;
cnt[a[i][ptr[i]]]++;
}
for(int i = 1; i <= m; i++)
{
se.insert({cnt[i],i});
mark[i] = 0;
}
while(se.size())
{
// cout<< se.size() <<" ";
auto it = se.end(); it--;
int X = (*it).S;
//cout<< X <<" "<< cnt[X] <<" \n";
if(cnt[X] <= q) return 1;
se.erase(it);
if(se.empty()) return 0;
mark[X] = 1;
for(int i = 1; i <= n; i++)
{
if(mark[a[i][ptr[i]]] == 0) continue;
while(mark[a[i][ptr[i]]])
ptr[i]++;
// if(X == 2)
// cout<< i <<" "<< ptr[i] <<"\n";
int Y = a[i][ptr[i]];
se.erase({cnt[Y],Y});
cnt[Y]++;
// if(X == 2)
// cout<< Y <<" "<< cnt[Y] <<"\n";
se.insert({cnt[Y],Y});
}
}
return 0;
}
signed main()
{
//ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin>> n >> m;
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++)
cin>> a[i][j];
int hi = n+1, lo = 0;
while(hi-lo > 1)
{
int tm = (hi+lo) >> 1;
if(ok(tm)) hi = tm;
else lo = tm;
}
//cout<< ok(2) <<" ";
cout<< hi;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
#define repp(i,a,b) for(int i = (int)(a) ; i < (int)(b) ; ++i)
#define repm(i,a,b) for(int i = (int)(a) ; i > (int)(b) ; --i)
int main(){
LL D; cin >> D;
if(D%9 != 0) return cout << 0 << endl, 0;
D /= 9;
LL ans = 0;
repp(i,1,19){
LL z = 1;
repp(k,0,i) z *= 10;
LL x = D;
LL a = 1;
LL b = 1;
while(z > 0){
a *= 10-x%10-b;
if(z == 1) break;
x -= x%10*(z-1)/9;
if(x < 0) x = -x;
x /= 10;
z /= 100;
b = 0;
}
if(x == 0) ans += a;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define space putchar(' ')
#define enter putchar('\n')
#define eps 1e-10
#define MAXN 200005
//#define ivorysi
using namespace std;
typedef long long int64;
typedef unsigned int u32;
typedef double db;
template<class T>
void read(T &res) {
res = 0;T f = 1;char c = getchar();
while(c < '0' || c > '9') {
if(c == '-') f = -1;
c = getchar();
}
while(c >= '0' && c <= '9') {
res = res * 10 +c - '0';
c = getchar();
}
res *= f;
}
template<class T>
void out(T x) {
if(x < 0) {x = -x;putchar('-');}
if(x >= 10) {
out(x / 10);
}
putchar('0' + x % 10);
}
int64 D;
int Len(int64 D) {
int res = 0;
while(D) {
res++;
D /= 10;
}
return res;
}
int64 pw[20];
int64 v[20],d[20];
int up;
int64 dfs(int64 rem,int dep) {
if(dep == up) return !rem;
int64 t = rem / v[dep];
int64 res = 0;
if(abs(t - 1) <= 9 && abs(rem - (t - 1) * v[dep]) < v[dep]) {
int c = 0;
if(t - 1 >= 0 && !dep) c = 1;
res += (d[t - 1 + 9] - c) * dfs(rem - (t - 1) * v[dep],dep + 1);
}
if(abs(t) <= 9 && abs(rem - t * v[dep]) < v[dep]) {
int c = 0;
if(t >= 0 && !dep) c = 1;
res += (d[t + 9] - c) * dfs(rem - t * v[dep],dep + 1);
}
if(abs(t + 1) <= 9 && abs(rem - (t + 1) * v[dep]) < v[dep]) {
int c = 0;
if(t + 1 >= 0 && !dep) c = 1;
res += (d[t + 1 + 9] - c) * dfs(rem - (t + 1) * v[dep],dep + 1);
}
return res;
}
void Solve() {
read(D);
int Ld = Len(D);
int64 ans = 0;
pw[0] = 1;
for(int i = 1 ; i <= 18 ; ++i) pw[i] = pw[i - 1] * 10;
for(int i = 0 ; i <= 9 ; ++i) {
for(int j = 0 ; j <= 9 ; ++j) {
d[i - j + 9]++;
}
}
for(int i = Ld ; i <= 2 * Ld ; ++i) {
for(int j = 0 ; j <= i / 2 ; ++j) v[j] = pw[i - j - 1] - pw[j];
up = i / 2;
int64 tmp = dfs(D,0);
if(i & 1) tmp *= d[0 + 9];
ans += tmp;
}
out(ans);enter;
}
int main() {
#ifdef ivorysi
freopen("f1.in","r",stdin);
#endif
Solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int x, y;
cin >> x >> y;
long long int ans = 0;
if(x == y) ans = 0;
else if(x == 0){
ans = abs(y);
if(y < 0) ans += 1;
}
else if(y == 0){
ans = abs(x);
if(x > 0) ans += 1;
}
// different sign
else if(x == -y) ans = 1;
else if(x > 0 && y < 0) ans = 1 + abs(x-(-y));
else if(x < 0 && y > 0) ans = min(y-x, 1+abs(y-(-x)));
// same sign
else if(x > y) ans = 2 + (x-y);
else if(x < y) ans = y-x;
cout << ans << endl;
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <algorithm>
#include <set>
#include <map>
#define vv(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))
typedef unsigned long long ull;
#define vvi std::vector<std::vector<int> >
#define vvs std::vector<std::vector<string> >
#define MODs 1000000007;
typedef long long int ll;
using namespace std;
int main(int argc, char const *argv[]) {
int N;
ll ans = 0;
string s, S, t, T="";
std::cin >> N;
std::cin >> s;
S = s.substr(0, N);
t = s.substr(N);
for(int i=0;i<N;i++) T+=t[N-1-i];
std::vector<int> num(26, 0);
for(int i=0;i<N;i++) num[S[i]-'a']++, num[T[i]-'a']--;
bool flag = true;
for(int i=0;i<26;i++) if(num[i]!=0) flag = false;
vvs str = vv(0, 2, "", string);
for(int i=0;i<(1<<N);i++){
int n = i+(1<<20), count=0;
string ah = "", bh = "";
while(count<N){
if(n%2==1) ah += T[count];
if(n%2==0) bh += T[count];
count++;
n/=2;
}
str.push_back(std::vector<string> {ah, bh});
}
sort(str.begin(), str.end());
for(int i=0;i<(1<<N);i++){
int n = i + (1<<20), count=0;
string ah="", bh="";
while(count<N){
if(n%2==1) ah += S[count];
if(n%2==0) bh += S[count];
count++;
n/=2;
}
int k = upper_bound(str.begin(), str.end(), std::vector<string> {ah,bh}) - lower_bound(str.begin(), str.end(), std::vector<string> {ah, bh});
ans += k;
}
std::cout << (!flag?0:ans) << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
template<class T>
inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
}
template<class T>
inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
}
const ll INF = 1e18;
const ll MOD = 998244353;
const ll MX = 1000001;
ll N;
struct Comp {
bool operator()(const l_l &a, const l_l &b) {
return a.first > b.first;
}
};
void solve() {
cin >> N;
vector<string> a(N);
vector<l_l> adds, subs;
int tlc = 0, trc = 0;
for (int i = 0; i < N; i++) {
int lc = 0, rc = 0;
cin >> a[i];
for (auto& c : a[i]) {
if (c == '(') {
lc++;
} else {
if (lc) lc--;
else rc++;
}
}
if (lc && !rc) tlc += lc;
else if (!lc && rc) trc += rc;
else if (lc && rc) {
if (lc >= rc) adds.push_back({rc, lc});
else subs.push_back({rc, lc});
}
}
sort(adds.begin(), adds.end());
sort(subs.begin(), subs.end(), Comp());
bool pos = true;
for (auto& i : adds) {
if (i.first > tlc) {
pos = false;
break;
} else {
tlc -= i.first;
tlc += i.second;
}
}
for (auto& i : subs) {
if (i.first > tlc) {
pos = false;
break;
} else {
tlc -= i.first;
tlc += i.second;
}
}
if (pos && tlc == trc) cout << "Yes";
else cout << "No";
}
int main() {
cin.sync_with_stdio(0); cin.tie(0);
ll T = 1; // cin >> T;
while (T--) solve();
return 0;
// You should actually read the stuff at the bottom
}
/* Stuff to Look For
* -----------------
* Int overflow, array bounds
* Initializing all variables, avoid weird behavior
* Edge cases(n = 0, n = 1)
* Just return 0 after result
*/
| // #pragma GCC target("avx") // CPU 処理並列化
// #pragma GCC optimize("O3") // CPU 処理並列化
// #pragma GCC optimize("unroll-loops") // 条件処理の呼び出しを減らす
// #define BEGIN_STACK_EXTEND(size) void * stack_extend_memory_ = malloc(size);void * stack_extend_origin_memory_;char * stack_extend_dummy_memory_ = (char*)alloca((1+(int)(((long long)stack_extend_memory_)&127))*16);*stack_extend_dummy_memory_ = 0;asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp":"=b"(stack_extend_origin_memory_):"a"((char*)stack_extend_memory_+(size)-1024));
// #define END_STACK_EXTEND asm volatile("mov %%rax, %%rsp"::"a"(stack_extend_origin_memory_));free(stack_extend_memory_);
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<deque>
#include<stack>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#include<stdlib.h>
#include<cassert>
#include<time.h>
#include<bitset>
#include<numeric>
#include<unordered_set>
#include<unordered_map>
#include<complex>
using namespace std;
const long long mod=998244353;
const long long inf=mod*mod;
const long long d2=(mod+1)/2;
const double EPS=1e-11;
const double INF=1e+10;
const double PI=acos(-1.0);
const int C_SIZE = 3100000;
const int UF_SIZE = 3100000;
namespace{
long long fact[C_SIZE];
long long finv[C_SIZE];
long long inv[C_SIZE];
inline long long Comb(int a,int b){
if(a<b||b<0)return 0;
return fact[a]*finv[b]%mod*finv[a-b]%mod;
}
void init_C(int n){
fact[0]=finv[0]=inv[1]=1;
for(int i=2;i<n;i++){
inv[i]=(mod-(mod/i)*inv[mod%i]%mod)%mod;
}
for(int i=1;i<n;i++){
fact[i]=fact[i-1]*i%mod;
finv[i]=finv[i-1]*inv[i]%mod;
}
}
long long pw(long long a,long long b){
if(a<0LL)return 0;
if(b<0LL)return 0;
long long ret=1;
while(b){
if(b%2)ret=ret*a%mod;
a=a*a%mod;
b/=2;
}
return ret;
}
long long pw_mod(long long a,long long b,long long M){
if(a<0LL)return 0;
if(b<0LL)return 0;
long long ret=1;
while(b){
if(b%2)ret=ret*a%M;
a=a*a%M;
b/=2;
}
return ret;
}
int pw_mod_int(int a,int b,int M){
if(a<0)return 0;
if(b<0)return 0;
int ret=1;
while(b){
if(b%2)ret=(long long)ret*a%M;
a=(long long)a*a%M;
b/=2;
}
return ret;
}
int ABS(int a){return max(a,-a);}
long long ABS(long long a){return max(a,-a);}
double ABS(double a){return max(a,-a);}
int sig(double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }
int UF[UF_SIZE];
void init_UF(int n){
for(int i=0;i<n;i++)UF[i]=-1;
}
int FIND(int a){
if(UF[a]<0)return a;
return UF[a]=FIND(UF[a]);
}
void UNION(int a,int b){
a=FIND(a);b=FIND(b);if(a==b)return;
if(UF[a]>UF[b])swap(a,b);
UF[a]+=UF[b];UF[b]=a;
}
}
// ここから編集しろ
char in[1100000];
pair<int,int>p[1100000];
vector<pair<int,int> > L;
vector<pair<int,int> > R;
int main(){
int a;scanf("%d",&a);
int sum=0;
for(int i=0;i<a;i++){
scanf("%s",in);
int t=0;
int m=0;
for(int j=0;in[j];j++){
if(in[j]=='(')t++;
else t--;
m=min(m,t);
}
p[i]=make_pair(t,m);
sum+=t;
}
if(sum){
printf("No\n");return 0;
}
for(int i=0;i<a;i++){
if(p[i].first>=0){
L.push_back(make_pair(-p[i].second,i));
}else{
R.push_back(make_pair(p[i].second-p[i].first,i));
}
}
std::sort(L.begin(),L.end());
std::sort(R.begin(),R.end());
int cur=0;
for(int i=0;i<L.size();i++){
int I=L[i].second;
if(cur+p[I].second<0){
printf("No\n");return 0;
}
cur+=p[I].first;
}
for(int i=0;i<R.size();i++){
int I=R[i].second;
if(cur+p[I].second<0){
printf("No\n");return 0;
}
cur+=p[I].first;
}
printf("Yes\n");
} | 1 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(void) {
int m,nmin,nmax;
while (cin >> m >> nmin >> nmax, m) {
vector<int> p(m);
for (int i = 0; i < m; ++i) {
cin >> p[i];
}
int res = 0;
int gap = 0;
for (int i = nmin; i <= nmax; ++i) {
if (p[i-1] - p[i] >= gap) {
res = i;
gap = p[i-1] - p[i];
}
}
cout << res << endl;
}
return 0;
} | #include <iostream>
#include <string>
using namespace std;
const int MOD = 1000000007;
int solve(const string& s){
const int N = s.size()/2;
long long res = 1;
int numS = 0, sumS = 0, inc = 0;
for(auto& c : s){
if(c == 'B'){
if(inc%2 == 0){
++inc;
++numS;
++sumS;
} else {
if(numS == 0) return 0;
--inc;
res = (res * numS) % MOD;
--numS;
}
} else {
if(inc%2 == 0){
if(numS == 0) return 0;
--inc;
res = (res * numS) % MOD;
--numS;
} else {
++inc;
++numS;
++sumS;
}
}
}
if(sumS != N) return 0;
for(int i=1;i<=N;i++) res = (res*i)%MOD;
return res;
}
int main(){
int N;
while(cin >> N){
string s; cin >> s;
cout << solve(s) << endl;
}
} | 0 |
#include <iostream>
#include <algorithm>
int main()
{
int n;
int64_t a, b;
std::cin >> n >> a >> b;
int x;
std::cin >> x;
int64_t sum = 0;
for (int i = 1; i < n; ++i)
{
int y;
std::cin >> y;
sum += std::min((y - x) * a, b);
x = y;
}
std::cout << sum << std::endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define all(x) (x).begin(),(x).end()
using ll = long long;
string char_to_string(char val) {
return string(1, val);
}
int char_to_int(char val) {
return val - '0';
}
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int vector_finder(std::vector<ll> vec, int number) {
auto itr = std::find(vec.begin(), vec.end(), number);
size_t index = std::distance( vec.begin(), itr );
if (index != vec.size()) { // 発見できたとき
return 1;
}
else { // 発見できなかったとき
return 0;
}
}
struct edge {
ll to, cost;
};
int main() {
int N, M, X, Y; cin >> N >> M >> X >> Y;
vector<int> x(N); REP(i, N) cin >> x[i];
vector<int> y(M); REP(i, M) cin >> y[i];
sort(all(x)); sort(all(y));
string ans = "War";
for(int i = X + 1; i <= Y; ++i) {
if(x[N - 1] < i && i <= y[0]) ans = "No War";
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ll long long
#define pb push_back
#define mk make_pair
#define mod 1000000007
#define lb lower_bound
#define ub upper_bound
#define endl "\n"
#define all(x) x.begin(),x.end()
#define ff first
#define ss second
#define prec(y,x) fixed<<setprecision(y)<<x
#define inf 1e18
#define pi 3.1415926535
typedef tree<int, null_type, less<int>, rb_tree_tag, //if using ll change int to ll
tree_order_statistics_node_update> pbset;
#define fob(x) find_by_order(x)
#define ook(x) order_of_key(x)
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int n;
cin >> n;
string s; ll l, r; l = 0; r = 0; vector<pair<int, pair<int, int>>> v1, v2;
vector<int> ans, ans1;
for (int i = 1; i <= n; i++)
{
cin >> s; int a = 0; int b = 0; //cout << s << endl;
for (int j = 0; j < s.size(); j++)
{
if (s[j] == '(')
a++;
else
{
if (a == 0)
b++;
else
a--;
}
}
if (a == 0 && b == 0)
{
ans.pb(i);
}
else if (a == 0)
{
r += b;
ans1.pb(i);
}
else if (b == 0)
{
l += a; ans.pb(i);
}
else
{
if (a >= b)
{
v1.pb(mk(b, mk(a, i)));
}
else
{
v2.pb(mk(a, mk(b, i)));
}
}
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
int flag = 0;
for (int i = 0; i < v1.size(); i++)
{
int b = v1[i].ff;
int a = v1[i].ss.ff;
ans.pb(v1[i].ss.ss);
l -= b;
if (l < 0)
{
flag = 1; break;
}
l += a;
}
if (flag == 1)
{
cout << "No" << endl; return 0;
}
for (int i = v2.size() - 1; i >= 0; i--)
{
int a = v2[i].ff;
int b = v2[i].ss.ff;
ans.pb(v2[i].ss.ss);
l -= b;
if (l < 0)
{
flag = 1; break;
}
l += a;
}
if (flag == 1 || l != r)
{
cout << "No" << endl;
}
else
{
cout << "Yes" << endl;
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
const int S=(1<<20)+5;
char buf[S],*H,*T;
inline char Get()
{
if(H==T) T=(H=buf)+fread(buf,1,S,stdin);
if(H==T) return -1;return *H++;
}
inline int read()
{
int x=0;char c=Get();
while(!isdigit(c)) c=Get();
while(isdigit(c)) x=x*10+c-'0',c=Get();
return x;
}
typedef long long LL;
const int N=200010;
int n,q,a,b,X[N];
int delta[N];
LL sumd[N],f[N];
struct SegmentTree
{
LL mnv[N<<2];int leaf;
void build()
{
for(leaf=1;leaf<=(n+2);leaf<<=1);
for(int i=1;i<=leaf+n;i++) mnv[i]=INT64_MAX/3;
}
void modify(int k,LL x)
{
mnv[leaf+k]=min(mnv[leaf+k],x);
for(int i=(leaf+k)>>1;i;i>>=1)
mnv[i]=min(mnv[i<<1],mnv[i<<1|1]);
}
LL qmin(int l,int r)
{
LL res=INT64_MAX/3;
for(l=leaf+l-1,r=leaf+r+1;l^r^1;l>>=1,r>>=1)
{
if(~l&1) res=min(res,mnv[l^1]);
if(r&1) res=min(res,mnv[r^1]);
}
return res;
}
}t1,t2;
LL solve(int a,int b)
{
X[0]=a;
for(int i=1;i<=q;i++)
{
delta[i]=abs(X[i]-X[i-1]);
sumd[i]=sumd[i-1]+delta[i];
}
f[1]=abs(b-X[1]);
t1.build();t2.build();
t1.modify(X[0],f[1]-sumd[1]-X[0]);
t2.modify(X[0],f[1]-sumd[1]+X[0]);
for(int i=2;i<=q;i++)
{
f[i]=t1.qmin(1,X[i])+X[i]+sumd[i-1];
f[i]=min(f[i],t2.qmin(X[i],n)-X[i]+sumd[i-1]);
t1.modify(X[i-1],f[i]-sumd[i]-X[i-1]);
t2.modify(X[i-1],f[i]-sumd[i]+X[i-1]);
}
LL ans=INT64_MAX/3;
for(int i=0;i<=q;i++) ans=min(ans,f[i]+sumd[q]-sumd[i]);
return ans;
}
int main()
{
n=read();q=read();a=read();b=read();
for(int i=1;i<=q;i++) X[i]=read();
LL ans=min(solve(a,b),solve(b,a));
printf("%lld\n",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF=1e9;
const int MOD=1e9+7;
//const int MOD=998244353;
const long long LINF=1e18;
#define int long long
//template
/*
問題の言い換え
//0の行き先が0じゃなかったら0にしてans++;
0を根とする根付き木を考える
各部分根付き木の深さが(根の深さを0として）K以下になるように分解するとき最小でいくつに分解しないといけないか
これは葉から決めていけばよさそう
*/
//main
signed main(){
int N,K,ans=0;cin>>N>>K;
std::vector<int> v(N),in(N,0),depth(N,1);;
for(int i=0;i<N;i++)cin>>v[i],v[i]--;
if(v[0])ans++;v[0]=0;
for(int i=0;i<N;i++)in[v[i]]++;
queue<int> que;
for(int i=0;i<N;i++)if(!in[i])que.push(i);
while(que.size()){
int p=que.front();que.pop();if(p==0)continue;
if(depth[p]==K&&v[p])depth[p]=0,ans++;
depth[v[p]]=max(depth[v[p]],depth[p]+1);
if(!--in[v[p]])que.push(v[p]);
}
cout<<ans<<endl;
}
| #include <iostream>
#include <algorithm>
using namespace std;
int A[110], ans[110];
int main() {
int N, M;
cin >> N >> M;
int cnt=0;
for(int i=0; i<M; ++i){
cin >> A[i];
cnt += A[i]%2;
}
if(cnt>2){
cout << "Impossible" << endl;
return 0;
}
if(cnt>0){
bool flag=false;
for(int i=0; i<M; ++i){
if(A[i]%2==1){
if(flag){
swap(A[i], A[M-1]);
}else{
swap(A[i], A[0]);
flag=true;
}
}
}
}
cout << A[0];
for(int i=1; i<M; ++i) cout << ' ' << A[i];
cout << endl;
int bs=0;
if(A[0]>1){
ans[bs]=A[0]-1;
++bs;
}
A[0]=2;
for(int i=0; i<M-1; ++i){
ans[bs]=A[i];
++bs;
}
if(A[M-1]>1){
ans[bs]=A[M-1]-1;
++bs;
}
cout << bs << endl;
cout << ans[0];
for(int i=1; i<bs; ++i) cout << ' ' << ans[i];
cout << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(n); i++)
using namespace std;
using P = pair<int,int>;
using ll = long long;
int main(){
ll n,m,x,y;
cin>>n>>m>>x>>y;
ll a_max=-101;
ll b_min=101;
ll tmp;
rep(i,n){
cin>>tmp;
a_max=std::max(a_max, tmp);
}
rep(i,m){
cin>>tmp;
b_min=std::min(b_min, tmp);
}
if(a_max<b_min && x<b_min && a_max<y){
cout<<"No War"<<endl;
}else{
cout<<"War"<<endl;
}
}
| #define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
int main(){
ll n,a,b,c,d,e;
cin>>n>>a>>b>>c>>d>>e;
ll mi=min({a,b,c,d,e});
ll x=(n+mi-1)/mi-1;
cout<<x+5<<endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int di[4] = {0, -1, 0, 1};
int dj[4] = {1, 0, -1, 0};
void game(int n, int& ans, int ni, int nj, int gi, int gj, vector<vector<int> >& table){
if(ni == gi && nj == gj){
if(ans == -1) ans = n;
else ans = min(ans, n);
return;
}else if(n == 10){
return;
}else{
for(int h = 0; h < 4; h++){
int nexti = ni;
int nextj = nj;
if(table[ni + di[h]][nj + dj[h]] == 1) continue;
while(1){
nexti += di[h];
nextj += dj[h];
if(table[nexti][nextj] == 1){
table[nexti][nextj] = 0;
game(n + 1, ans, nexti - di[h], nextj - dj[h], gi, gj, table);
table[nexti][nextj] = 1;
break;
}else if(table[nexti][nextj] == 3){
game(n + 1, ans, nexti, nextj, gi, gj, table);
break;
}else if(table[nexti][nextj] == -1){
break;
}
}
}
}
return;
}
int main(){
while(1){
int w, h; cin >> w >> h;
if(!w) break;
int si, sj, gi, gj;
vector<vector<int> > table(h + 2, vector<int> (w + 2, -1));
for(int i = 1; i <= h; i++){
for(int j = 1; j <= w; j++){
cin >> table[i][j];
if(table[i][j] == 2){
si = i;
sj = j;
table[i][j] = 0;
}
if(table[i][j] == 3){
gi = i;
gj = j;
}
}
}
int ans = -1;
game(0, ans, si, sj, gi, gj, table);
cout << ans << endl;
}
return 0;
}
| #include <cstdio>
#include <vector>
using namespace std;
class Edge{
public:
int from,to,cost;
Edge(int f,int t,int c){
from = f;
to = t;
cost = c;
}
void swap(){
int a = from;
from = to;
to = a;
}
};
vector<Edge> edge;
int n,m;
const int INF = 999999999;
int solve(int s){
int* d = new int[n + 1];
for(int i=0;i<=n;i++){
d[i] = INF;
}
d[s] = 0;
while(1){
bool f = true;
vector<Edge>::iterator it;
for(it = edge.begin();it<edge.end();it++){
if(d[it->from] != INF){
if(d[it->to] > d[it->from] + it->cost){
d[it->to] = d[it->from] + it->cost;
f = false;
}
}
}
if(f){
break;
}
}
int ans = 0;
for(int i=2;i<=n;i++){
if(d[i] <= 2){
ans += 1;
}
}
delete[] d;
return ans;
}
int main(){
int a,b;
while(scanf("%d %d",&n,&m) && (n || m)){
edge.clear();
for(int i=0;i<m;i++){
scanf("%d %d",&a,&b);
edge.push_back( Edge(a,b,1) );
edge.push_back( Edge(b,a,1) );
}
printf("%d\n",solve(1));
}
} | 0 |
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "complex"
using namespace std;
const long long int MOD = 1000000007;
const long double EPS = 1e-8;
long long int N, M, K, H, W, L, R;
list<int> Prime(int num) {
list<int>P;
for (int i = 5; i <= num; i += 6) {
bool flag = true;
for (auto j : P) {
if (j*j > i) {
break;
}
if (i%j == 0) {
flag = false;
break;
}
}
if (flag)P.push_back(i);
flag = true;
for (auto j : P) {
if (j*j > i + 2) {
break;
}
if ((i + 2) % j == 0) {
flag = false;
break;
}
}
if (flag)P.push_back(i + 2);
}
P.push_front(3);
P.push_front(2);
return P;
}
inline long long int gcd(long long int a, long long int b) {
if (a < b)a ^= b ^= a ^= b;
while (b) {
a %= b;
a ^= b ^= a ^= b;
}
return a;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
auto P = Prime(10000);
list<int>p;
P.pop_front();
while (p.size() < N + 2) {
p.push_back(P.front());
P.pop_front();
}
vector<int>tate((N+2)/2);
vector<int>yoko((N+2)/2);
for (int i = 0; i < (N + 2) / 2; i++) {
if (i % 2) {
tate[i] = p.front();
p.pop_front();
}
else {
tate[i] = p.back();
p.pop_back();
}
}
for (int i = 0; i < N/2+1; i++) {
if (i % 2) {
yoko[i] = p.front();
p.pop_front();
}
else {
yoko[i] = p.back();
p.pop_back();
}
}
vector<vector<long long int>>v(N, vector<long long int>(N));
map<long long int, int>m;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if ((i^j) & 1) {
v[i][j] = tate[i / 2] * yoko[j / 2] * 2;
if (m[v[i][j]])v[i][j] *= 2;
m[v[i][j]]++;
}
}
}
int dir[] = { 0,1,0,-1,0 };
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (!v[i][j]) {
v[i][j] = 1;
for (int k = 0; k < 4; k++) {
int ny = i + dir[k];
int nx = j + dir[k + 1];
if (ny < 0 || nx < 0 || ny >= N || nx >= N)continue;
v[i][j] = v[i][j] / gcd(v[i][j], v[ny][nx])*v[ny][nx];
}
v[i][j]++;
if (m[v[i][j]])v[i][j] = v[i][j] * 2 - 1;
m[v[i][j]]++;
}
}
}
long long int mx = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (j)cout << " ";
cout << v[i][j];
mx = max(mx, v[i][j]);
}
cout << endl;
}
return 0;
} | #ifdef _MSC_VER
#define _CRT_SECURE_NO_WARNINGS
#endif
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
#define pii pair<int , int>
#define mp make_pair
#define fi first
#define se second
const int MAXN = 2e5 + 10;
int pc;
int pr[MAXN] , f[MAXN];
LL A[MAXN] , B[MAXN];
template <typename T> inline void chkmax(T &x , T y) { x = max(x , y); }
template <typename T> inline void chkmin(T &x , T y) { x = min(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 void G(int n) {
for (int i = 2; i <= n; ++i) {
if (!f[i]) f[i] = pr[++pc] = i;
for (int j = 1; j <= pc && i * pr[j] <= n; ++j) {
f[i * pr[j]] = pr[j];
if (i % pr[j] == 0) break;
}
}
}
int main() {
int n;
scanf("%d" , &n); G(10000);
for (int i = 1; i <= n; ++i) A[i] = pr[i & 1 ? i / 2 + 1 : n + n - i / 2 + 1];
for (int i = 1; i <= n; ++i) B[i] = pr[(i & 1 ? n - i / 2 : n + i / 2) + (n & 1)];
A[0] = A[n + 1] = B[0] = B[n + 1] = 1;
for (int i = 1; i <= n; ++i , printf("\n"))
for (int j = 1; j <= n; ++j)
if ((i + j) & 1) printf("%lld " , (LL) A[(i + j) / 2] * A[(i + j) / 2 + 1] * B[(n + i - j + (n & 1)) / 2] * B[(n + i - j + (n & 1)) / 2 + 1] + 1);
else printf("%lld " , A[(i + j) / 2] * B[(n + i - j + (n & 1)) / 2]);
return 0;
} | 1 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<numeric>
using namespace std;
typedef long long ll;
ll MOD = 1e9+7;
#define rep(i,n) for(int i = 0; i < (n); ++i)
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
int sum = accumulate(a.begin(), a.end(), (int)0);
int frame_num = 0;
int frame_min_dif = 1e8;
rep(i, n) {
int tmp_num = a[i] * n;
int dif = abs(tmp_num - sum);
if ( dif < frame_min_dif ) {
frame_num = i;
frame_min_dif = dif;
}
}
cout << frame_num << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main()
{
double n, m;
int d;
cin >> n >> m >> d;
double ans = 1.0;
if (d == 0) {
ans *= m - 1;
ans /= n;
}else{
ans = 2.0 * (n - d);
ans *= m - 1;
ans /= n * n;
}
printf("%.10f\n", ans);
return 0;
} | 0 |
#include<stdio.h>
#include<algorithm>
using namespace std;
char str[110];
int b[110];
int main(){
int a;
while(scanf("%d",&a),a){
for(int i=0;i<a;i++)scanf("%d",b+i);
scanf("%s",str);
for(int i=0;str[i];i++){
int p=0;
if('a'<=str[i]&&str[i]<='z')p=str[i]-'a';
else p=str[i]-'A'+26;
p-=b[i%a];
if(p<0)p+=52;
if(p<26)str[i]='a'+p;
else str[i]='A'+p-26;
}
printf("%s\n",str);
}
} | #include <iostream>
#include <string>
using namespace std;
char byte_minus(char ch, int num)
{
if ( 97 <= ch && ch <= 122 )
{
if ( ch - 97 >= num )
{
return ch - num;
}
else
{
return byte_minus('Z', num - (ch - 96) );
}
}
else
{
if ( ch - 65 >= num )
{
return ch - num;
}
else
{
return byte_minus('z', num - (ch - 64) );
}
}
}
int main()
{
while (true)
{
int n;
cin >> n;
if ( n == 0 ) break;
int* keys = new int[n];
for (int i = 0; i < n; i++)
{
cin >> keys[i];
}
string cipher;
//getline(cin, cipher);
cin >> cipher;
for (int i = 0, size = cipher.length(); i < size; i++)
{
int key_index = i % n;
char result = byte_minus(cipher[i], keys[key_index]);
cout << result;
}
cout << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, n) for (int i = (n); i >= 0; --i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define FORR(i, m, n) for (int i = (m); i >= (n); --i)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
const ll mod = 1000000007;
//const ll mod = 998244353;
const int inf = 1e9 + 10;
const ll INF = 1e18;
const ld EPS = 1e-10;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
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 (a>b) { a=b; return 1; } return 0; }
int main() {
string s;
cin >> s;
int n = s.length();
cout << s.substr(0, n - 8) << endl;
return 0;
}
| #include<iostream>
#include<algorithm>
#include <string>
using namespace std;
int main() {
int a, b, c, d, n = 0, ans = 0, ans2 = 0;
string s;
cin >>s;
s.pop_back();
s.pop_back();
s.pop_back();
s.pop_back();
s.pop_back();
s.pop_back();
s.pop_back();
s.pop_back();
cout << s << endl;
} | 1 |
#include <stdio.h>
int main()
{
int a[101],n,cou;
scanf("%d",&n);
for(cou=1;cou<=n;cou++){
scanf("%d",&a[cou]);
}
for(cou=n;cou>=1;cou--){
printf("%d",a[cou]);
if(cou==1){
break;
}
printf(" ");
}
printf("\n");
return 0;
} | #include <set>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <cstdio>
#include <vector>
#include <string>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <utility>
#include <numeric>
#include <complex>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <cassert>
#include <iostream>
#include <iterator>
#include <algorithm>
using namespace std;
using ll = long long;
using vll = vector<long long>;
using vvll = vector<vll>;
const double EPS = 1e-9;
const long long MOD=1e9+7;
ll dx4[4]={1,0,-1,0};
ll dy4[4]={0,-1,0,1};
ll dx8[8]={1,0,-1,1,-1,1,0,-1};
ll dy8[8]={1,1,1,0,0,-1,-1,-1};
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for(int i = x; i < n; i++)
#define SZ(x) ((int)(x).size())
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
using vd = vector<double>;
using vvd = vector<vd>;
using vvvd = vector<vvd>;
ll n;
double dfs(vvvd &dp, ll n1, ll n2, ll n3){
if(n1==0 && n2==0 && n3==0) return 0.0;
if(dp[n1][n2][n3] >= 0.0){
return dp[n1][n2][n3];
}
double expect = (double)n / (n1+n2+n3);
if(n1 > 0){
expect += dfs(dp, n1-1, n2, n3) * (double)n1/(n1+n2+n3);
}
if(n2 > 0){
expect += dfs(dp, n1+1, n2-1, n3) * (double)n2/(n1+n2+n3);
}
if(n3 > 0){
expect += dfs(dp, n1, n2+1, n3-1) * (double)n3/(n1+n2+n3);
}
return dp[n1][n2][n3] = expect;
}
int main(){
cin>>n;
vll a(n); rep(i,n) cin>>a[i];
double p=1.0/n;
ll n1,n2,n3; n1=n2=n3=0;
rep(i,n){
if(a[i]==1) n1++;
else if(a[i]==2) n2++;
else if(a[i]==3) n3++;
}
vvvd dp(n+1,vvd(n+1,vd(n+1,-1)));
double ans = dfs(dp,n1,n2,n3);
cout<< fixed << setprecision(10)<< ans<<endl;
} | 0 |
// AOJ ITP 1_5_D
#include<cstdio>
void call( int n )
{
int i = 1;
do
{
int x = i;
if( x % 3 == 0 )
printf( " %d", i );
else
{
do
{
if( x % 10 == 3 )
{
printf( " %d", i );
break;
}
x /= 10;
} while( x );
}
}while( ++i <= n );
puts("");
return;
}
int main()
{
int n;
scanf( "%d", &n );
call( n );
return 0;
} | #include<iostream>
using namespace std;
int main(){
int n,k,l,m,o;
cin>>n;
for(int i=3;i<=n;i++){
k=i%10;
l=i/1000;
m=i/100%10;
o=i/10%10;
if(i%3==0){
cout<<" "<<i;
}else if(k==3 || l==3 || m==3 || o==3){
cout<<" "<<i;
}
}
cout<<endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int INF=1001001001;
const int mod=1e9+7;
int main(){
int N,K;
cin>>N>>K;
vector<char>D(K);
for(int i=0;i<K;i++){
cin>>D[i];
}
for(int i=N;;i++){
string t=to_string(i);
bool use=true;
for(int k=0;k<t.size();k++){
bool ok=true;
for(int j=0;j<K;j++){
if(t[k]==D[j]){
ok=false;
}
}
if(!ok){use=false;}
}
if(use){cout<<t<<endl;return 0;}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int mod=1000000007;
const int INF=1001001001;
vector<pair<int64_t,int64_t>>prime_factorize(int64_t x){
vector<pair<int64_t,int64_t>>p;
for(int64_t i=2;i*i<=x;i++){
int cnt=0;
if(x%i==0){
while(x%i==0){cnt++;x/=i;}
p.push_back(make_pair(i,cnt));
}
}
if(x!=1){p.push_back(make_pair(x,1));}
return p;
}
int main() {
string s;
cin>>s;
int n=s.size();
stack<char>k;
for(int i=0;i<n;i++){
if(k.empty()){k.push(s[i]);}
else if(s[i]=='T'&&k.top()=='S'){k.pop();}
else{k.push(s[i]);}
}
cout<<k.size()<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
ll x = 1e9 + 7;
int main() {
int n;
cin >> n;
if ((n-7) % 10 == 0) {
cout << "Yes" << endl;
return 0;
}
n /= 10;
if ((n-7) % 10 == 0) {
cout << "Yes" << endl;
return 0;
}
n /= 10;
if ((n-7) % 10 == 0) {
cout << "Yes" << endl;
return 0;
}
cout << "No" << 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;
int main() {
string s;
cin >> s;
bool ok = false;
if (s[0] == '7')
ok = true;
if (s[1] == '7')
ok = true;
if (s[2] == '7')
ok = true;
if (ok) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | 1 |
#include <iostream>
using namespace std;
int n;
int A[100000];
int main()
{
cin>>n;
for(int i=0;i<n;i++)cin>>A[i];
int x=A[n-1];
int j=A[0]<x?1:0;
for(int i=1;i<n-1;i++)
{
if (A[i]<=x)
{
int aj=A[j];
A[j]=A[i];
A[i]=aj;
j++;
}
}
A[n-1]=A[j];
A[j]=x;
for (int i=0;i<j;i++)
{
if (i) cout <<' ';
cout<<A[i];
}
if(j)cout<<' ';
cout<<'['<<A[j]<<']';
for(int i=j+1;i<n;i++)//bug here i=j+1
{
cout <<' '<<A[i];
}
cout<<endl;//bug here
} | #include<iostream>
#include<cstdio>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<cstring>
#include<string>
#include<cmath>
#include<list>
#include<algorithm>
using namespace std;
#define inf 0x3f3f3f3f
typedef long long ll;
const int maxn = 100000 + 8;
int n,a[maxn];
int Partition(int a[],int p,int r)
{
int last_element = a[r];
int i = p-1;
for(int j = p; j < r; ++j)
{
if(a[j] <= last_element)
{
i++;
swap(a[i],a[j]);
}
}
swap(a[i+1],a[r]);
return i+1;
}
int main()
{
scanf("%d",&n);
fill(a,a+n,0);
for(int i = 0; i < n; ++i)
{
scanf("%d",&a[i]);
}
int pos = Partition(a,0,n-1);
for(int i = 0;i < n; ++i){
if(i == pos) printf("");
printf("%s%s%d%s", i==0?"":" ",i == pos?"[":"",a[i],i == pos?"]":"");
}
printf("\n");
return 0;
}
///*
//const int maxn = 1e5 + 8;
//
//int n,k,w[maxn];
//
//int check(ll P)
//{
// for(int i = 0; i < n; ++i){
//
// }
//}
//ll BinarySearch()
//{
// ll left = 0;
// ll right = maxn * maxn;
// while(left <= right)
// {
// ll mid = (left + right) / 2;
// int r = check(mid);
// if(r >= n) ;
// else ;
// }
// return right;
//}
//int main()
//{
// scanf("%d%d",&n,&k);
// fill(w,w+n,0);
// for(int i = 0; i < n; ++i) scanf("%d",&w[i]);
// ll ans = BinarySearch();
//}
//
/*
#include <iostream>
#include <deque>
#include <string>
#include <vector>
#include <queue>
#include <cstdio>
#include <stack>
#include <algorithm>
#include <cstring>
#include <cctype>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <iomanip>
using namespace std;
int tile = 0;
int Board[8][8];
void ChessBoard(int tr,int tc,int dr,int dc,int size){
if(size == 1)return ;
int t = tile++;
int s = size / 2;
if(dr < tr + s && dc < tc + s){
ChessBoard(tr,tc,dr,dc,s);
}
else{
Board[tr + s - 1][tc + s - 1] = t;
ChessBoard(tr,tc,tr + s - 1, tc + s - 1,s);
}
if(dr < tr + s && dc >= tc + s){
ChessBoard(tr,tc + s,dr,dc,s);
}
else{
Board[tr + s - 1][tc + s] = t;
ChessBoard(tr,tc+s,tr + s - 1, tc + s,s);
}
if(dr >= tr + s && dc < tc + s){
ChessBoard(tr+s,tc,dr,dc,s);
}
else{
Board[tr + s][tc + s - 1] = t;
ChessBoard(tr+s,tc,tr + s, tc + s - 1,s);
}
if(dr >= tr + s && dc >= tc + s){
ChessBoard(tr+s,tc+s,dr,dc,s);
}
else{
Board[tr + s][tc + s] = t;
ChessBoard(tr+s,tc+s,tr + s, tc + s,s);
}
}
void Print(){
for (int i = 0; i < 8; ++i) {
for (int j = 0; j < 8; ++j) {
cout << setw(3) << Board[i][j];
}
cout << endl;
}
cout << endl;
}
int main(){
memset(Board,0,sizeof Board);
ChessBoard(0,0,0,1,8);
Print();
}
*/ | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mn=2e6+10;
const ll mod=998244353;
ll inv(ll x){
ll ans=1;
for(ll i=mod-2;i;i>>=1,x=x*x%mod)if(i&1)ans=ans*x%mod;
return ans;
}
ll fact[mn];
ll ch(ll n,ll k){
if(k<0||k>n)return 0;
return fact[n]*inv(fact[k])%mod*inv(fact[n-k])%mod;
}
ll hail(ll k,ll n,ll m){
m++;
return ch(k+n-1,n-1)-n*ch(k+n-1-m,n-1)%mod;
}
int main()
{
ll n,m,i;
fact[0]=1;
for(i=1;i<mn;i++)fact[i]=fact[i-1]*i%mod;
scanf("%lld%lld",&n,&m);
ll ans=0;
for(i=m%2;i<=min(n,m);i+=2){
ans+=ch(n,i)*hail((3*m-i)/2,n,m-1)+(hail((3*m-i)/2,n,m)-hail((3*m-i)/2,n,m-1))*ch(n-1,i);
ans%=mod;
}
if(ans<0)ans+=mod;
printf("%lld",ans);
}
| #include <iostream>
#include <vector>
#include <limits.h>
#include <algorithm>
#include <string>
#include <math.h>
#include <limits.h>
#include <queue>
#include <map>
#include <set>
#include <iomanip>
#include <bitset>
#include <cassert>
#include <random>
#include <functional>
#include <stack>
#include <iomanip>
#include <cassert>
//#include <boost/multiprecision/cpp_int.hpp>
using namespace std;
const long long MOD = 1e9+7;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef pair<ld, ll> pdl;
typedef pair<ld, ld> pdd;
//typedef boost::multiprecision::cpp_int bigint;
ll A, B;
int main() {
cin >> A >> B;
vector<vector<ll>> MAP; //1->黒 0->白
MAP.resize(100, vector<ll>(100, 0));
if (A > 1) {
ll x = 0;
for (ll c = 0; c < floor((ld)(A - 1) / 50); c++, x += 2) {
for (ll y = 0; y < 100; y += 2) {
MAP[x][y + 1] = 1;
MAP[x + 1][y] = 1;
MAP[x + 1][y + 1] = 1;
}
}
for (ll y = 0; y < (A - 1) % 50; y++) {
MAP[x + 1][2 * y + 1] = 1;
MAP[x + 1][2 * y] = 1;
MAP[x][2 * y + 1] = 1;
}
x += 3;
for (ll b = 2; b <= B; x += 2) {
for (ll y = 0; y < 100 && b <= B; b++, y += 2) {
MAP[x][y] = 1;
}
}
cout << "100 100" << endl;
for (ll y = 0; y < 100; y++) {
for (ll x = 0; x < 100; x++) {
if (MAP[x][y])cout << "#";
else cout << ".";
}
cout << endl;
}
}
else {
for (ll b = 1,x = 1; b <= B; x += 2) {
for (ll y = 0; y < 100 && b <= B; b++, y += 2) {
MAP[x][y] = 1;
}
}
cout << "100 100" << endl;
for (ll y = 0; y < 100; y++) {
for (ll x = 0; x < 100; x++) {
if (MAP[x][y])cout << "#";
else cout << ".";
}
cout << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
double n,m,d,ans;
cin >> n >> m >> d;
ans=0;
if(d != 0){
for(int i=0;i<m-1;i++){
ans+=(2*(n-d))/(n*n);
}
}
else{
for(int i=0;i<m-1;i++){
ans+=(n-d)/(n*n);
}
}
cout<<fixed<<setprecision(20)<<ans<<endl;
return 0;
}
| //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using ld=long double;
using st=string;
using ch=char;
typedef pair<ll,ll> P;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<P> vP;
typedef vector<ch> vc;
typedef vector<vc> vvc;
#define FOR(i,a,b) for(ll i=a;i<b;i++)
#define rep(i,n) FOR(i,0,n)
#define ROF(i,a,b) for(ll i=a;i>=b;i--)
#define per(i,a) ROF(i,a,0)
#define pb push_back
#define mp make_pair
const ll MOD=1000000007;
const ll MOD2=998244353;
const ld PI=acos(-1);
const ll INF=1e18;
st abc="abcdefghijklmnopqrstuvwxyz";
st ABC="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
struct edge{ll to,cost;};
int main() {
ll n,m,d;
cin >> n >> m >> d;
cout << fixed << setprecision(20);
if(d!=0){
cout << (ld)(n-d)*2*(m-1)/(n*n) << endl;
}
else{
cout << (ld)(n-d)*(m-1)/(n*n) << endl;
}
} | 1 |
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int N,M;
cin>>N;
vector<string>S(N);
for(int i=0;i<=N-1;i++){
cin>>S[i];
}
cin>>M;
vector<string>T(M);
for(int i=0;i<=M-1;i++){
cin>>T[i];
}
int countplus=0;
int countminus=0;
int ans=0;
for(int i=0;i<=N-1;i++){
countplus=0;
for(int j=0;j<=N-1;j++){
if(S[i]==S[j])countplus++;
}
countminus=0;
for(int j=0;j<=M-1;j++){
if(S[i]==T[j])countminus++;
}
ans=max(ans,countplus-countminus);
}
cout<<ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<int, ll> pil;
typedef pair<ll, int> pli;
typedef pair<double,double> pdd;
#define SQ(i) ((i)*(i))
#define MEM(a, b) memset(a, (b), sizeof(a))
#define SZ(i) int(i.size())
#define FOR(i, j, k, in) for (int i=j ; i<(k) ; i+=in)
#define RFOR(i, j, k, in) for (int i=j ; i>=(k) ; i-=in)
#define REP(i, j) FOR(i, 0, j, 1)
#define REP1(i,j) FOR(i, 1, j+1, 1)
#define RREP(i, j) RFOR(i, j, 0, 1)
#define ALL(_a) _a.begin(),_a.end()
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define X first
#define Y second
#ifdef jayinnn
#define TIME(i) Timer i(#i)
#define debug(...) do{\
fprintf(stderr,"%s - %d (%s) = ",__PRETTY_FUNCTION__,__LINE__,#__VA_ARGS__);\
_do(__VA_ARGS__);\
}while(0)
template<typename T>void _do(T &&_x){cerr<<_x<<endl;}
template<typename T,typename ...S> void _do(T &&_x,S &&..._t){cerr<<_x<<", ";_do(_t...);}
template<typename _a,typename _b> ostream& operator << (ostream &_s,const pair<_a,_b> &_p){return _s<<"("<<_p.X<<","<<_p.Y<<")";}
template<typename It> ostream& _OUTC(ostream &_s,It _ita,It _itb)
{
_s<<"{";
for(It _it=_ita;_it!=_itb;_it++)
{
_s<<(_it==_ita?"":",")<<*_it;
}
_s<<"}";
return _s;
}
template<typename _a> ostream &operator << (ostream &_s,vector<_a> &_c){return _OUTC(_s,ALL(_c));}
template<typename _a> ostream &operator << (ostream &_s,set<_a> &_c){return _OUTC(_s,ALL(_c));}
template<typename _a> ostream &operator << (ostream &_s,deque<_a> &_c){return _OUTC(_s,ALL(_c));}
template<typename _a,typename _b> ostream &operator << (ostream &_s,map<_a,_b> &_c){return _OUTC(_s,ALL(_c));}
template<typename _t> void pary(_t _a,_t _b){_OUTC(cerr,_a,_b);cerr<<endl;}
#define IOS()
class Timer {
private:
string scope_name;
chrono::high_resolution_clock::time_point start_time;
public:
Timer (string name) : scope_name(name) {
start_time = chrono::high_resolution_clock::now();
}
~Timer () {
auto stop_time = chrono::high_resolution_clock::now();
auto length = chrono::duration_cast<chrono::microseconds>(stop_time - start_time).count();
double mlength = double(length) * 0.001;
debug(scope_name, mlength);
}
};
#else
#define TIME(i)
#define debug(...)
#define pary(...)
#define endl '\n'
#define IOS() ios_base::sync_with_stdio(0);cin.tie(0)
#endif
const ll MOD = 1000000007;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int iNF = 0x3f3f3f3f;
const ll MAXN = 100005;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
/********** Good Luck :) **********/
int main () {
TIME(main);
IOS();
int n;
cin >> n;
vector<int> a(n);
for(int i=0;i<n;i++) cin >> a[i];
ll ans = 0;
for(int i=1;i<n;i++){
if(a[i] < a[i-1]){
ans += a[i-1] - a[i];
a[i] = a[i-1];
}
}
cout << ans << endl;
return 0;
} | 0 |
#include<iostream>
#include<iomanip>
#include<vector>
#include<map>
#include<stack>
#include<queue>
#include<string>
#include<utility>
#include<numeric>
#include<algorithm>
#include<cmath>
#include<climits>
using namespace std;
using ll = long long;
class Stream{
public:
Stream(){
}
//配列以外の入力を受け取る
void read(){
}
template<typename First, typename... Rest>
void read(First& first, Rest&... rest){
cin >> first;
read(rest...);
}
//配列を区切って出力する
template<typename T>
void write_vec(vector<T>& v, char divider){
for(size_t i = 0; i < v.size(); i++){
cout << v[i] << divider;
}
}
};
int main(){
Stream io;
int R, G;
io.read(R, G);
cout << G + G - R;
return 0;
} | #include <iostream>
#include<math.h>
#include<string>
#include<iomanip>
#include <limits>
using namespace std;
int main()
{
long r,g,b; cin>>r>>g;
b=(g*2)-r;
cout<<b;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define MOD 1000000007LL
#define rep(i, n) for(ll (i) = 0LL;(i) < (ll)(n);(i)++)
#define rep2(i, s, e) for(ll (i) = (ll)(s);(i) < (ll)(e);(i)++)
#define repi(i, n) for(ll (i) = 0LL;(i) <= (ll)(n);(i)++)
#define repi2(i, s, e) for(ll (i) = (ll)(s);(i) <= (ll)(e);(i)++)
#define per(i, n) for(ll (i) = (ll)(n) - 1LL;(i) >= 0LL;(i)--)
#define per2(i, s, e) for(ll (i) = (ll)(s) - 1LL;(i) >= (ll)(e);(i)--)
#define peri(i, n) for(ll (i) = (ll)(n);(i) >= 0LL;(i)--)
#define peri2(i, s, e) for(ll (i) = (ll)(s);(i) >= (ll)(e);(i)--)
#define iter(i, it) for(auto &(i): (it))
template<typename T, typename U> ostream& operator<<(ostream &s, const pair<T, U> m) {
cout << "(" << m.first << ", " << m.second << ")";
return s;
}
template<typename T, typename U> ostream& operator<<(ostream &s, const map<T, U> m) {
ll c = 0;
cout << "{ ";
iter(i, m) cout << i << (c++ == m.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const vector<T> &v) {
cout << "{ ";
rep(i, v.size()) cout << v[i] << (i == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const list<T> &v) {
ll c = 0;
cout << "{ ";
iter(i, v) cout << i << (c++ == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
int main(void) {
ll N, M;
cin >> N;
map<string, ll> n, m;
set<string> S;
ll maxi = 0;
rep(i, N) {
string temp;
cin >> temp;
n[temp]++;
S.insert(temp);
}
cin >> M;
rep(i, M) {
string temp;
cin >> temp;
m[temp]++;
S.insert(temp);
}
iter(s, S) maxi = max(maxi, n[s] - m[s]);
cout << maxi << endl;
return 0;
}
| #include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<tuple>
#include<map>
#include<bitset>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
int main(){
int N, M;
cin >> N;
vector<string> vec1(N);
for (int i=0; i<N; i++){
cin >> vec1.at(i);
}
cin >> M;
vector<string> vec2(M);
for (int i=0; i<M; i++){
cin >> vec2.at(i);
}
int max=0;
for (int i=0; i<N; i++){
int sum=0;
for (int j=0; j<N; j++){
if (vec1.at(i)==vec1.at(j)){
sum++;
}
}
for (int k=0; k<M; k++){
if (vec1.at(i)==vec2.at(k)){
sum--;
}
}
if (sum>max){
swap(sum, max);
}
}
cout << max << endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long LL;
typedef long double ld;
typedef vector<ll>VI;
typedef pair<int,int>P;
#define VV(T) vector<vector<T>>
#define sz(x) int(x.size())
#define PI 3.1415926535897932384626433832795
#define rep(i, n) for (ll i = 0; i < (ll)n; i++)
#define reprev(i,n) for (ll i=(ll)n-1;i>=0;i--)
#define ALL(a) (a).begin(),(a).end()
#define rALL(a) (a).rbegin(),(a).rend()
#define c_max(a, b) (((ll)a)>((ll)b)?(a):(b))
#define c_min(a,b) (((ll)a)<((ll)b)?(a):(b))
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; }
#define vmax(v) *max_element(ALL(v))
#define vmin(v) *min_element(ALL(v))
#define $(x) {cout<<#x<<" = " <<(x)<<endl;}
#define fi first
#define se second
#define MAX 100100//5
#define MAX2 200100
#define MAX6 1001001//6
#define MAX7 10010010//7
#define SENTINEL 2000000000//9
#define INF 1<<30
#define INFTY 1LL<<60
#define MAX_INT INT_MAX
#define Endl '\n'
#define CLR(mat) memset(mat, 0, sizeof(mat))
inline ll GCD(ll a,ll b){return b?GCD(b,a%b):a;}//最大公約数
inline ll lcm(ll a,ll b){return a*b/GCD(a,b);}//最小公倍数
template<class T> bool contain(const std::string& s, const T& v) {
return s.find(v) != std::string::npos;
}
const int MOD = 1000000007;
inline ll mod_add(ll a,ll b){return (a+b)%MOD;}
inline ll mod_sub(ll a,ll b){return (a+MOD-b)%MOD;}
inline ll mod_mul(ll a,ll b){return ((a%MOD)*(b%MOD))%MOD;}
inline ll mod_pow(ll x,ll n,ll mod=(ll)MOD){ll res=1;while(n>0){
if(n&1)res=res*x%mod;
x=x*x%mod;n>>=1;}return res;}
inline ll mod_inv(ll x){return mod_pow(x,MOD-2);}
inline ll mod_div(ll a, ll b){return mod_mul(a,mod_inv(b));}
const int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
// vector型から重複を削除 list.erase(unique(ALL(list)),list.end());
// g++ -o a a.cpp -Wall -lm -std=c++17 -I .
//push_back -> emplace_back
string solve(ll n){
string str="";
while(n!=0){
int x=n/(-2);
int y=n%(-2);
if(y<0){
y+=2;
x++;
}
str+=char(y+'0');
n=x;
}
if(str=="")str="0";
reverse(ALL(str));
return str;
}
int main(){
ll n;cin>>n;
cout<<solve(n)<<endl;
} | #include <cstdio>
#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <string>
#include <cmath>
#include <functional>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#define rep(i,n) for (int i=0;i<n;i++)
using ll = long long;
using namespace std;
void solve(){
}
int main (){
ios::sync_with_stdio(0);
cin.tie(0);
ll n;
cin >> n;
if(n==0) {
cout << 0;
return 0;
}
vector<vector<ll>> a(33,vector<ll> (2));
a[0][0] = 1;
a[0][1] = 0;
ll m = 1;
for(int i=1;i<33;i++){
m*=-2;
if(m>0){
a[i][0] = a[i-1][0] + m;
a[i][1] = a[i-1][1];
}else{
a[i][1] = a[i-1][1] + m;
a[i][0] = a[i-1][0];
}
}
ll tmp = n;
vector<int> ans(33,0);
for(int i=32;i>0;i--){
if(tmp>0){
if(a[i][0]>=tmp&&tmp>a[i-1][0]){
ans[i] = 1;
tmp = tmp - m;
}else{
ans[i] = 0;
}
}else{
if(a[i][1]<=tmp&&tmp<a[i-1][1]){
ans[i] = 1;
tmp = tmp - m;
}else{
ans[i] = 0;
}
}
m /= (-2);
}
if(tmp == 1){
ans[0] = 1;
}else{
ans[0] = 0;
}
bool flag = false;
for(int i=32; i >= 0; i--){
if(!flag){
if(ans[i]==1){
cout << ans[i];
flag = true;
}
}else{
cout << ans[i];
}
}
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <map>
#include <cmath>
#include <iomanip>
#include <set>
#include <sstream>
#include <queue>
using namespace std;
typedef long long ll;
int main() {
ll n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
ll min_move = min({a,b,c,d,e});
cout << (n + min_move - 1) / min_move + 4 << endl;
return 0;
} | #include<iostream>
using namespace std;
void swap(int *a,int *b){
int tmp = *a;
*a = *b;
*b = tmp;
}
int main(void){
int a,b,c;
cin >> a >> b >> c;
swap(&a,&b);
swap(&a,&c);
cout << a <<" "<< b << " " << c << endl;
return 0;
}
| 0 |
/**
* created: 24.08.2020 21:32:00
**/
#include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
// using bint = boost::multiprecision::cpp_int;
using namespace std;
using ll = long long;
using P = pair<int,int>;
// #define endl '\n'
#define int long long
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
#define rep2(i,s,n) for (int i = (s); i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define pcnt(bit) __builtin_popcountll(bit)
template<class T> bool chmax(T &a, const T &b) {if (a < b) {a = b; return 1;} return 0;}
template<class T> bool chmin(T &a, const T &b) {if (b < a) {a = b; return 1;} return 0;}
const long double pi = acos(-1.0);
const int MAX = 1000010;
const int INF = 1ll << 60;
const int MOD = 1000000007;
// const int MOD = 998244353;
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n; cin >> n;
vector<int> v;
v.push_back(2);
rep2(i,3,55556) {
bool ok = true;
rep2(j,2,sqrt(i)+1) if (i % j == 0) ok = false;
if (ok) v.push_back(i);
}
vector<int> v1;
for (auto p : v) if (p % 5 == 1) v1.push_back(p);
rep(i,n) {
if (i == 0) cout << v1[i];
else cout << " " << v1[i];
}
cout << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main( void )
{
int a;
cin >> a;
cout << a + pow( a, 2 ) + pow( a, 3 ) << endl;
} | 0 |
#define _USE_MATH_DEFINES
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <cmath>
#include <map>
#include <iomanip>
#include <deque>
#include <set>
#include <climits>
#include <memory>
#include <numeric>
#include <utility>
#define rep(i,a,b) for(int i=a;i<b;++i)
#define rrep(i,a,b) for(int i=a;i>=b;--i)
#define fore(i,a) for(auto &i:a)
#define INF INT_MAX/2;
#define PI 3.14159265358979323846264338327950L;
const int INF2 = 1001001001;
typedef long long ll;
using namespace std;
using vi = vector<int>;
using vll = vector<ll>;
ll mod = 1e9 + 7;
//ll llmax = 10000000000000000000ll;
const ll LINF = 1e18;
using namespace std;
using Graph = vector<vector<int>>;
int cnt_digit(ll N)
{
int digit = 0;
while (N > 0)
{
N /= 10;
digit++;
}
return digit;
}
// 最大公約数計算
ll gcd(ll a, ll b)
{
if (b == 0) {
return a;
}
else {
return gcd(b, a % b);
}
}
// 最小公倍数の計算
ll lcm(ll a, ll b)
{
ll g = gcd(a, b);
return a / g * b;
}
struct union_find
{
vector<int> par, r;
union_find(int n)
{
par.resize(n);
r.resize(n);
init(n);
}
void init(int n)
{
for (int i = 0; i < n; i++) par[i] = i;
for (int i = 0; i < n; i++) r[i] = 0;
}
int find(int x)
{
if (par[x] == x)return x;
else return find(par[x]);
}
void unite(int x, int y)
{
x = find(x);
y = find(y);
if (r[x] < r[y])
{
par[x] = y;
}
else
{
par[y] = x;
if (r[x] == r[y])
{
r[x]++;
}
}
}
};
const int MAX_N = 110000;
int memo[MAX_N];
int rec(int n) {
if (n == 0)return 0;
if (memo[n] != -1)return memo[n];
int res = n;
for (int pow6 = 1; pow6 <= n; pow6 *= 6)res = min(res, rec(n - pow6) + 1);
for (int pow9 = 1; pow9 <= n; pow9 *= 9)res = min(res, rec(n - pow9) + 1);
return memo[n] = res;
}
int calc(int x) {
int ret = 0;
while (x % 2 == 0) {
x /= 2;
ret++;
}
return ret;
}
int a[12][12];
int D;
ll G;
vector<ll> P, C;
//aのp乗を求めるアルゴリズム
long modpow(long a, int p) {
if (p == 0)return 1;
if (p % 2 == 0) {
//pが偶数のとき
int halfP = p / 2;
long half = modpow(a, halfP);
return half * half % mod;
}
else {
//pが奇数の時は、
//pを偶数にするために1減らす
return a * modpow(a, p - 1) % mod;
}
}
//(10*9*8)/(3*2*1);
//10*9*8 -> ansMul
//3*2*1 -> ansDiv;
long calcComb(int a, int b) {
if (b > a - b) return calcComb(a, a - b);
long ansMul = 1;
long ansDiv = 1;
rep(i, 0, b) {
ansMul *= (a - i);
ansDiv *= (i + 1);
ansMul %= mod;
ansDiv %= mod;
}
//ansMul /ansDivをやりたい
//ansDivの逆元を使って求めよう。
long ans = ansMul * modpow(ansDiv, mod - 2) % mod;
return ans;
}
bool is_war(const vector<int>& x, const vector<int>& y) {
for (int Z = -100; Z <= 100; Z++) {
bool is_ok = true;
rep(i, 0, x.size()) {
if (x[i] >= Z) {
is_ok = false;
}
rep(i, 0, y.size()) {
if (y[i] < Z) {
is_ok = false;
}
}
}
if (is_ok)return false;
}
return true;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> x(n + 1),y(m+1);
cin >> x[0] >> y[0];
rep(i, 0, n) {
cin >> x[i + 1];
}
rep(i, 0, m) {
cin >> y[i + 1];
}
if (is_war(x, y)) {
cout << "War" << endl;
}
else {
cout << "No War" << endl;
}
}
| #include<bits/stdc++.h>
#define INF 10000000000ll
#define ll long long
using namespace std;
signed main(){
ll n,m,x,y,a,b;
cin>>n>>m>>x>>y;
for(int i=0;i<n;i++){
cin>>a;
x = max(a,x);
}
for(int i=0;i<m;i++){
cin>>b;
y = min(y,b);
}
if(y > x){
cout<<"No War\n";
}else{
cout<<"War\n";
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
long long inf=1000000007;
int main(){
int x,y;
cin>>x>>y;
vector<long long> score={300000,200000,100000,0};
long long ans=0;
ans+=score.at(min(3,x-1));
ans+=score.at(min(3,y-1));
if(x==1 && y==1) ans+=400000;
cout<<ans<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int num[maxn], x[maxn];
int main()
{
int n, s;
scanf("%d%d", &n, &s);
for(int i = 1; i <= n; i ++)
{
scanf("%d%d",x+i,num+i);
}
int l=1,r=n;
long long ans=0;
long long sum=0;
int nows;
bool flag;
if(num[1]>=num[n]){
nows=x[n];sum+=num[r];
flag=1;
}
else{
nows=x[1];sum+=num[l];
flag=0;
}
while(s<x[r]&&s>x[l]){
//printf("%d %d %lld %lld\n",l,r,ans,sum);
if(flag){
if(num[l]>=sum){
ans+=abs(nows-x[l]);
flag=0;
nows=x[l];
sum+=num[l];
r--;
}
else
sum+=num[l++];
}
else{
if(num[r]>sum){
ans+=abs(x[r]-nows);
flag=1;
nows=x[r];
sum+=num[r];
l++;
}
else
sum+=num[r--];
}
}
//printf("%d %d %lld %lld\n",l,r,ans,sum);
if(s>x[r]){
ans+=abs(nows-x[l]) + abs(nows-s);
}
else ans+=abs(nows-s) + abs(nows-x[r]);
printf("%lld\n",ans);
return 0;
}
| 0 |
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
#define FOR(i,j,k) for(int (i)=(j);(i)<(int)(k);++(i))
#define rep(i,j) FOR(i,0,j)
#define each(x,y) for(auto &(x):(y))
#define mp make_pair
#define MT make_tuple
#define all(x) (x).begin(),(x).end()
#define debug(x) cout<<#x<<": "<<(x)<<endl
#define smax(x,y) (x)=max((x),(y))
#define smin(x,y) (x)=min((x),(y))
#define MEM(x,y) memset((x),(y),sizeof (x))
#define sz(x) (int)(x).size()
#define RT return
using ll = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vll = vector<ll>;
template<class T>
vector<int> kmp(const T &sentence, const T &word) {
int lenS = (int)sentence.size(), lenW = (int)word.size(), idx = -1, head = 0;
vector<int> table(lenW + 1, -1), res;
for (int i = 0; i < lenW; ++i) {
while (idx >= 0 && word[i] != word[idx])idx = table[idx];
table[i + 1] = ++idx;
}
idx = 0;
while (head + idx < lenS) {
if (word[idx] == sentence[head + idx]) {
++idx;
if (idx == lenW) {
res.push_back(head);
head = head + idx - table[idx];
idx = table[idx];
}
} else {
head = head + idx - table[idx];
if (idx > 0)idx = table[idx];
}
}
return res;
}
void solve() {
int N;
cin >> N;
vi A(N), B(N), AA(N), BB(2 * N);
rep(i, N) {
cin >> A[i];
}
rep(i, N) {
cin >> B[i];
}
rep(i, N) {
AA[i] = A[i] ^ A[(i + 1) % N];
BB[i] = B[i] ^ B[(i + 1) % N];
BB[i + N] = BB[i];
}
BB.pop_back();
vi found = kmp(BB, AA);
each(i, found) {
i = (i == 0 ? i : N - i);
}
sort(all(found));
each(i, found) {
cout << i << ' ' << (A[i] ^ B[0]) << endl;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve();
return 0;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define MOD 1000000007
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<int> vi;
typedef vector<vl> vvl;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<ll, ll> pll;
typedef pair<int, int> pi;
typedef vector<pll> vpl;
typedef vector<pi> vpi;
typedef vector<vs> vvs;
typedef vector<pll> vvpl;
typedef vector<vpi> vvpi;
typedef queue<ll> ql;
typedef queue<int> qi;
typedef queue<pll> qpl;
typedef queue<pi> qpi;
template <typename T> void printv(const vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
printf("[%d] %d\n", i, v[i]);
}
}
template <typename T> void printvv(const vector<T> &vv) {
for (int i = 0; i < vv.size(); ++i) {
for (int j = 0; j < vv[i].size(); ++j) {
printf("[%d][%d] %d\n", i, j, vv[i][j]);
}
}
}
template <typename T, typename U> void printp(const pair<T, U> &p) {
cout << p.first << " " << p.second << endl;
}
template <typename T> void printvp(const vector<pair<T, T>> &vp) {
for (int i = 0; i < vp.size(); ++i) {
printf("[%d] %d, %d\n", vp[i].first, vp[i].second);
}
}
template <typename T> void printvvp(const vector<vector<pair<T, T>>> &vvp) {
for (int i = 0; i < vvp.size(); ++i) {
for (int j = 0; j < vvp[i].size(); ++j) {
printf("[%d][%d] %d, %d\n", i, j, vvp[i][j].first, vvp[i][j].second);
}
}
}
int main() {
string S;
cin >> S;
ll tmp = 0;
for (int bit = 0; bit < (1 << (S.length() - 1)); ++bit) {
tmp = S[0] - '0';
for (int i = 1; i < S.length(); ++i) {
if (bit & 1 << (i - 1)) {
tmp += S[i] - '0';
} else {
tmp -= S[i] - '0';
}
}
if (tmp == 7) {
for (int i = 0; i < S.length(); ++i) {
cout << S[i];
if (i < S.length() - 1) {
char op = (bit & (1 << i)) >= 1 ? '+' : '-';
cout << op;
}
}
cout << "=7" << endl;
break;
}
}
return 0;
}
| 0 |
//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx,avx2,fma")
#pragma GCC optimize("O3")
#include<iostream>
#include<algorithm>
#include<string>
#include<cmath>
#include<cstdlib>
#include<set>
#include<vector>
#include<sstream>
#include<queue>
#include <iomanip>
#include<unordered_set>
#include <stack>
#include <unordered_map>
#include <map>
#include<numeric>
#include<chrono>
#include <fstream>
constexpr auto INF = 9223372036854775807;
typedef long long int ll;
typedef unsigned long long int ull;
typedef unsigned long int ul;
#define f(i,a,b) for(ll i=(ll)a;i<(ll)b;i+=1)
#define rf(i,a,b) for(ll i=(ll)a;i>=(ll)b;i-=1)
#define endl '\n'
#define N 1000000007 // prime modulo value
#define M 998244353
#define all(x) x.begin(),x.end()
#define mkp(a,b) make_pair(a,b)
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
inline int mex(unordered_set<int> st)
{
int m = 0;
while (st.find(m) != st.end())
{
m += 1;
}
return m;
}
inline int calculateGrundy(int n)
{
if (n == 1)
return 0;
unordered_set<int> mexi;
for (int i = 1; i <= sqrt(n); i += 1)
{
if (n % i == 0)
{
if (n / i != n)
mexi.insert(calculateGrundy(n / i));
mexi.insert(calculateGrundy(i));
}
}
return mex(mexi);
}
inline ll gcd(ll a, ll b)
{
// This is code taken from geeksforgeek
if (b == 0)
return a;
return gcd(b, a % b);
}
/*ll power(ll x, ll y)
{
// This is code taken from geeksforgeek
ll res = 1;
x = x % N;
if (x == 0) return 0;
while (y > 0)
{
if (y & 1)
res = (res * x) % N;
y = y >> 1;
x = (x * x) % N;
}
return res;
}*/
ll power(ll x, ll y)
{
ll res = 1;
x = x;
while (y > 0)
{
if (y & 1)
res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
/*ll modInverse(ll n, ll p)
{
return power(n, p - 2, p);
}*/
ll sum(ll n)
{
return (n * (n + 1)) / 2;
}
ll sum_digit(ll n)
{
ll ans = 0;
while (n)
{
ans += n % 10;
n /= 10;
}
return ans;
}
ll gp(ll r, ll n)
{
return (pow(r,n)-1)/(r-1);
}
int main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
ll d,t,s;
cin>>d>>t>>s;
ll time=(d-s*t);
if(time<=0)
{
cout<<"Yes";
}
else
{
cout<<"No";
}
return 0;
} | #include<cstdio>
#include<iostream>
using namespace std;
int main(){
int n,d,v;
cin >> n >> d >> v;
double time = (double)n/v;
if(time <= d) cout << "Yes" << endl;
else cout << "No" << endl;
} | 1 |
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <iomanip>
using ll = long long;
using uint = unsigned int;
using graph = std::vector<std::vector<ll>>;
using wGraph = std::vector<std::vector<std::pair<ll,ll>>>;
#define rep(i,n) for (int i=0; i < int(n); i++)
using namespace std;
ll MOD7 = 1000000007;
ll MOD9 = 1000000009;
vector<ll> InputVec(ll N){
vector<ll> A(N);
for (int i = 0; i < N; ++i) {
cin >> A[i];
}
return A;
}
void OutputVec(vector<ll> A){
for (int i = 0; i < A.size(); ++i) {
cout << A[i] << ",";
}
cout << endl;
}
vector<vector<ll>> InputVec2d(ll H,ll W){
vector<vector<ll>> A(H);
for (int yi = 0; yi < H; ++yi) {
A[yi] = vector<ll>(W);
}
for (int yi = 0; yi < H; ++yi) {
for (int xi = 0; xi < W; ++xi) {
cin >> A[yi][xi];
}
}
return A;
}
vector<vector<char>> InputVec2dStr(ll H,ll W){
vector<vector<char>> A(H);
for (int yi = 0; yi < H; ++yi) {
A[yi] = vector<char>(W);
}
for (int yi = 0; yi < H; ++yi) {
string S;
cin >> S;
for (int xi = 0; xi < W; ++xi) {
A[yi][xi] = S[xi];
}
}
return A;
}
void OutputVec2d(vector<vector<ll>> A){
for (int yi = 0; yi < A.size(); ++yi) {
for (int xi = 0; xi < A[yi].size(); ++xi) {
cout << A[yi][xi] << ",";
}
cout << endl;
}
}
graph InputGraph(ll N,ll M){
graph G(N);
for (int i = 0; i < M; ++i) {
ll a,b;
cin >> a >> b;
a--;b--;
G[a].push_back(b);
G[b].push_back(a);
}
return G;
}
graph InputDGraph(ll N,ll M){
graph G(N);
for (int i = 0; i < M; ++i) {
ll a,b;
cin >> a >> b;
a--;b--;
G[a].push_back(b);
}
return G;
}
void OutputGraph(graph G){
for (int i = 0; i < G.size(); ++i) {
cout << i << ":";
for (int j = 0; j < G[i].size(); ++j) {
cout << G[i][j]<< ",";
}
cout << endl;
}
}
void OutputAnswerBool(bool b,bool isUpperCase = false){
if(b){
if(isUpperCase){
cout << "YES" << endl;
}else{
cout << "Yes" << endl;
}
}else{
if(isUpperCase){
cout << "NO" << endl;
}else{
cout << "No" << endl;
}
}
}
int main() {
string S;
cin >> S;
ll w;
cin >> w;
for (int i = 0; i < S.size(); i += w) {
cout << S[i];
}
cout << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
int w;
cin>>S>>w;
int i=0;
while(i<S.size()){
cout<<S[i];
i+=w;
}
cout<<endl;
}
| 1 |
#include <iostream>
#include <string>
using namespace std;
long long solve(const string& S, int k){
int dst = 0;
long long res = 0;
long long cnt = 0;
int m = 0;
int c = 0;
for(int i=0;i<S.size();i++){
while(dst < S.size() && dst - i < k){
if(S[dst] == 'M') ++m;
if(S[dst] == 'C'){ ++c; cnt += m; }
++dst;
}
if(S[i] == 'D') res += cnt;
if(S[i] == 'M') { cnt -= c; --m; }
if(S[i] == 'C') --c;
}
return res;
}
int main(){
int N; cin >> N;
string S; cin >> S;
int Q; cin >> Q;
for(int i=0;i<Q;i++){
int k; cin >> k;
cout << solve(S, k) << endl;
}
} | #include <bits/stdc++.h>
#include <atcoder/fenwicktree>
using namespace std;
using ll = long long;
int main() {
int N, Q; cin >> N >> Q;
atcoder::fenwick_tree<ll> bit(N+1);
for (int i=1;i<=N;i++) {
int a; cin >> a;
bit.add(i, a);
}
for (int q=0; q<Q; q++) {
int d, l, r;
cin >> d >> l >> r;
if (d == 0) {
bit.add(l+1, r);
} else {
cout << bit.sum(l+1, r+1) << "\n";
}
}
} | 0 |
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <map>
#define INF 100000000
#define rep(i,a) for(int i=0;i<(a);i++)
using namespace std;
typedef long long ll;
int main(){
int hosei[]={0,4,0,1,4,6,2,4,0,3,5,1,3};
string day[]={"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"};
int m,n;
while(1){
cin>>m>>n;
if(!(m||n))break;
cout<<day[(hosei[m]+n%7-1)%7]<<endl;
}
return 0;
} | #include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
int main(int argc, char const* argv[])
{
int n,m;
int place[1000];
while( cin >> n >> m && n != 0 ){
for( int i = 0;i < 1000;i++ ) place[i] = 0;
for( int i = 0;i < n;i++ ) cin >> place[i];
sort( place, place + n, greater<int>() );
for( int i = 1;i * m - 1 < n;i++ ) place[i * m - 1] = 0;
int answer = 0;
for( int i = 0;i < n;i++ ) answer += place[i];
cout << answer << endl;
}
return 0;
} | 0 |
#include<iostream>
#include<string>
#include<math.h>
using namespace std;
int main(){
int h,w,s;
while(true){
cin>>h>>w;
if(h==0&&w==0)
break;
bool t=true;
s=h*h+w*w;
h++;
while(true){
if(h*h>=s-h*h)
break;
if(s==h*h+(int)sqrt((double)s-h*h+0.0)*(int)sqrt((double)s-h*h+0.0)){
t=false;
break;
}
h++;
}
s++;
if(t==true){
while(true){
h=1;
while(true){
if(h*h>=s-h*h)
break;
if(s==h*h+((int)sqrt((double)s-h*h+0.0)*(int)sqrt((double)s-h*h+0.0))){
t=false;
break;
}
h++;
}
if(t==false)
break;
s++;
}
}
cout<<h<<" "<<(int)sqrt((double)s-h*h+0.0)<<endl;
}
return 0;
} | #include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
struct rect{
int w,h,v;
bool operator<(const rect& a) const{
return v==a.v ? h < a.h : v < a.v;
}
};
int main(){
int i,j,k,w,h;
vector <rect> rs;
rect r;
for(i=1;i<151;i++){
for(j=1;j<i;j++){
r.w=i;
r.h=j;
r.v=i*i+j*j;
rs.push_back(r);
}
}
sort(rs.begin(),rs.end());
cin >> h >> w;
while(h!=0){
for(i=0;i<rs.size();i++){
if(rs[i].w==w&&rs[i].h==h) cout << rs[i+1].h << " " << rs[i+1].w << endl;
}
cin >> h >> w;
}
return 0;
} | 1 |
# include<bits/stdc++.h>
# include<ext/pb_ds/assoc_container.hpp>
# include<ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;
# define int long long
typedef long long ll;
typedef pair<int, int> pii;
# define S second
# define F first
# define kill(x) return(cout << x << '\n', 0LL)
# define debug(x) cerr<< #x << " = " << (x) << endl
# define ddebug(x, y) cerr<< #x << " = " << (x) << ", " << #y << " = " << (y) << endl
# define tdebug(x, y, z) cerr<< #x << " = " << (x) << ", " << #y << " = " << (y) << ", " << #z << " = " << (z) << endl
# define bin(x) cerr<< #x << " : " << bitset<4>(x) << endl
# define sz(s) (int)s.size()
# define sq(x) (x) * (x)
# define PB(x) push_back(x)
# define smax(x, y) (x) = max((x), (y))
# define smin(x, y) (x) = min((x), (y))
# define all(x) x.begin(), x.end()
# define SP fixed << setprecision(10)
# define uop(x, y) pii(min(x, y), max(x, y))
# define MP(x, y) make_pair(x, y)
const int MAXN = 300 + 10;
int dp[MAXN][MAXN][MAXN];
int32_t main()
{
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
string s;
int k;
cin >> s >> k;
for (int t = 1; t <= sz(s); t ++)
{
for (int i = 0; i + t - 1 < sz(s); i ++)
{
int j = i + t - 1;
for (int l = 0; l <= k; l ++)
{
if (t == 1)
{
dp[i][j][l] = 1;
continue;
}
dp[i][j][l] = max(dp[i + 1][j][l], dp[i][j - 1][l]);
if (l || s[i] == s[j])
smax(dp[i][j][l], dp[i + 1][j - 1][l - (s[i] != s[j])] + 2);
}
}
}
cout << dp[0][sz(s) - 1][k] << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a,b,ans;
cin >> a >> b;
if(a > b){
ans = a;
a--;
}else{
ans = b;
b--;
}
if(a > b){
ans += a;
a--;
}else{
ans += b;
b--;
}
cout <<ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
ll a[114514],b[114514];
int main(){
ll n,inf=1e15;
cin>>n;
b[n+1]=inf;
for(int i=1;i<=n;i++){
cin>>a[i];
b[i]=-inf;
}
ll ans=1;
b[1]=a[1];
b[0]=inf;
b[n+1]=-inf;
for(int i=2;i<=n;i++){
if(b[ans]>=a[i]){
ans++;
b[ans]=a[i];
}else{
ll ng=0,ok=n+1;
while(ok-ng>1){
ll mid=(ok+ng)/2;
if(b[mid]>=a[i])ng=mid;
else ok=mid;
}
b[ok]=a[i];
}
}
//for(int i=0;i<=5;i++)cout<<b[i]<<' ';
cout<<ans;
return 0;
}
| #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
ll MOD = 1000000007;
#define vec vector<int>
#define vecll vector<ll>
#define vecd vector<double>
#define vecst vector<string>
#define vecb vector<bool>
#define v2(v,n,m,init) vector<vector<int>> v(n, vector<int>(m, init))
#define vb2(v,n,m,init) vector<vector<bool>> v(n, vector<bool>(m, init))
#define vll2(v,n,m,init) vector<vector<ll>> v(n, vector<ll>(m, init))
#define rep(i,n) for(ll i=(ll)0; i<(ll)n; i++)
#define REP(i,m,n) for(ll i=(ll)m; i<(ll)n; i++)
#define arr(var, n) vec var(n); rep(i,n){cin >> var[i];}
#define arrll(var, n) vecll var(n); rep(i,n){cin >> var[i];}
#define arrst(var, n) vecst var(n); rep(i,n){cin >> var[i];}
#define all(var) (var).begin(), (var).end()
#define sortall(var) sort(all(var))
#define uniqueall(v) v.erase(unique(v.begin(), v.end()), v.end());
#define pb(var) push_back(var)
#define prt(var) cout << (var) << "\n"
#define prtd(n, var) cout << fixed << setprecision(n) << (var) << "\n"
#define prtfill(n, var) cout << setw(n) << setfill('0') << (var);
#define prt2(v1, v2) cout << (v1) << " " << (v2) << "\n"
#define prt3(v1, v2, v3) cout << (v1) << " " << (v2) << " " << (v3) << "\n"
#define prtall(v) rep(i,v.size()){cout<<v[i]<<(i!=v.size()-1?" ":"\n");}
template <typename T>
bool chmax(T &a, const T& b){if(a<b){a=b; return true;} return false;}
template <typename T>
bool chmin(T &a, const T& b){if(a>b){a=b; return true;} return false;}
//----------------------------------------------------------------
int main(void) {
int n;
cin >> n;
arrll(a,n);
rep(i,n){
a[i] = 1000000000-a[i];
}
ll INF = 1e18;
vecll dp(n, INF);
rep(i,n){
auto tmp = upper_bound(all(dp), a[i]);
*tmp = a[i];
}
auto ans = lower_bound(all(dp), ll(1e18)-1);
prt(ans-dp.begin());
}
| 1 |
#include<bits/stdc++.h>
#define ll long long
#define pii_ pair<int,int>
#define mp_ make_pair
#define pb push_back
#define fi first
#define se second
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define show1(a) cout<<#a<<" = "<<a<<endl
#define show2(a,b) cout<<#a<<" = "<<a<<"; "<<#b<<" = "<<b<<endl
using namespace std;
const ll INF = 1LL<<60;
const int inf = 1<<30;
const int maxn = 2e5+5;
inline void fastio() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);}
int a[55];
int main()
{
fastio();
int n,k;
cin>>n>>k;
rep(i,1,n) cin>>a[i];
int ans = 0;
rep(i,0,min(k,n)){
rep(L,0,i){
int R = i - L;
multiset<int> st;
rep(j,1,L) st.insert(a[j]);
rep(j,1,R) st.insert(a[n-j+1]);
rep(j,1,k-i){
if(st.size()==0) break;
auto it = st.begin();
int v = *it;
if(v >= 0) break;
st.erase(it);
}
int tmp = 0;
for(int x:st) tmp+=x;
ans = max(ans,tmp);
}
}
cout<<ans<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 50 + 5, mod = 1e9 + 7;
int n, k;
int a[N], dp[N][N][102];
int solve(int l, int r, int left)
{
if (l > r)
return 0;
if (dp[l][r][left] != -1)
return dp[l][r][left];
int ans = 0;
if (a[l] < 0)
{
if (left > 0)
ans = max(ans, solve(l + 1, r, left - 1) + a[l]);
if (left > 1)
ans = max(ans, solve(l + 1, r, left - 2));
}
if (a[l] >= 0 && left > 0)
ans = max(ans, solve(l + 1, r, left - 1) + a[l]);
if (a[r] < 0)
{
if (left > 0)
ans = max(ans, solve(l, r - 1, left - 1) + a[r]);
if (left > 1)
ans = max(ans, solve(l, r - 1, left - 2));
}
if (a[r] >= 0 && left > 0)
ans = max(ans, solve(l, r - 1, left - 1) + a[r]);
return dp[l][r][left] = ans;
}
int main()
{
//ios::sync_with_stdio(false);cin.tie(nullptr);ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a[i];
memset(dp, -1, sizeof dp);
cout << solve(0, n - 1, k);
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
template<class T> void ckmin(T &a, T b) { a = min(a, b); }
template<class T> void ckmax(T &a, T b) { a = max(a, b); }
#define pb push_back
#define mp make_pair
#define cotu cout
#define itn int
#define Red ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define F first
#define S second
#define sz(x) (int)x.size()
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for(int i = 0; i < n; ++i)
#define repr(i,n) for(int i = n - 1; i >= 0; --i)
#define Rep(i, a, n) for(int i = (a); i <=(n); ++i)
#define repst(i, n) for(auto it = n.begin(); it != n.end(); ++it)
#define Repr(i, a, n) for(int i = (n); i >= (a); --i)
#define sp(x) fixed << setprecision(x)
#define ordered_set tree<int , null_type,less<int >, rb_tree_tag,tree_order_statistics_node_update>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const int inf = int(1e9);
const int mod = inf + 7;
const int N = 1e6 + 555; // TL MB
const double PI = acos(-1.0);
void mul(ll &x, ll y){
x *= y;
if(x >= mod) x %= mod;
}
void add(ll &x, ll y){
x += y;
if(x >= mod) x -= mod;
if(x < 0) x += mod;
}
ll bp(ll a, ll n){
ll r = 1;
while(n){
if(n & 1) mul(r, a);
mul(a, a);
n >>= 1;
}
}
void solve()
{
int n;
cin >> n;
ll a[n];
vector<ll> p;
rep(i, n) cin >> a[i];
sort(a, a + n);
rep(i, n){
if(i && a[i] == a[i - 1]) p.pb(a[i++]);
}
sort(p.rbegin(), p.rend());
if(sz(p) <= 1) cout << 0;
else cout << p[0] * p[1];
}
int main()
{
// freopen("crosses.in", "r", stdin);
// freopen("crosses.out", "w", stdout);
Red;
int T = 1;
// cin >> T;
for(int i = 1; i <= T; ++i){
solve();
}
return 0;
} | #include <bits/stdc++.h>
#include <climits>
using namespace std;
int main(){
int N;
string A,B,C;
cin >> N;
cin >> A >> B >> C;
int ans = 0;
for(int i = 0; i < N;i++){
if(A[i] == B[i] && B[i] != C[i] && C[i] != A[i])ans++;
else if(A[i] != B[i] && B[i] == C[i] && C[i] != A[i])ans++;
else if(A[i] != B[i] && B[i] != C[i] && C[i] == A[i])ans++;
else if(A[i] != B[i] && B[i] != C[i] && C[i] != A[i])ans+=2;
}
cout << ans << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
vector<vector<char>> ans;
for (int i = 0; i < 50; i++) ans.push_back(vector<char>(100, '#'));
for (int i = 0; i < 50; i++) ans.push_back(vector<char>(100, '.'));
a--, b--;
for (int i = 0; a > 0; i += 2) {
for (int j = 0; j < 100 && a > 0; j += 2, a--) {
ans[i][j] = '.';
}
}
for (int i = 51; b > 0; i += 2) {
for (int j = 0; j < 100 && b > 0; j += 2, b--) {
ans[i][j] = '#';
}
}
cout << 100 << " " << 100 << endl;
for (auto e : ans) cout << string(begin(e), end(e)) << endl;
}
| #include<iostream>
using namespace std;
int main() {
int a, b; cin >> a >> b; a--; b--;
cout << "100 100" << endl;
for (int i = 0; i < 50; i++) {
for (int j = 0; j < 100; j++) {
if (a > 0 && i % 2 == 0 && j % 2 == 1) { cout << '.'; a--; }
else cout << '#';
}
cout << endl;
}
for (int i = 0; i < 50; i++) {
for (int j = 0; j < 100; j++) {
if (b > 0 && i % 2 == 1 && j % 2 == 1) { cout << '#'; b--; }
else cout << '.';
}
cout << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#ifdef LOCAL
#define debug(...) fprintf(stderr, __VA_ARGS__);fflush(stderr);
#else
#define debug(...) 42
#endif
#define sf scanf
#define pf printf
#define nl printf("\n")
#define ps(s) printf("%s",s.c_str())
#define mem(x,val) memset(x,val,sizeof x)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define sz(x) (int)(x).size()
#define test_case int ___t;scanf("%d", &___t);for(int cs=1;cs<=___t;cs++)
inline string getString(int n){char ch[n+5];sf(" %s",ch);return string(ch);}
inline string getLine(int n)
{char ch[n+5];fgets(ch,n+5,stdin);string s=string(ch);s.pop_back();return s;}
//typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> new_data_set;
typedef long long ll;
const int S=100100;
int main()
{
ll a,b;
while(~sf("%lld %lld",&a,&b))
{
ll g=__gcd(a,b);
int cnt=0;
if(g%2==0)
{
cnt++;
while(g%2==0)g/=2;
}
for(int i=3;i<=sqrt(g);i++)
{
if(g%i==0)
{
cnt++;
while(g%i==0)g/=i;
}
}
if(g>1)cnt++;
pf("%d\n",cnt+1);
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
class UnionFind
{
public:
vector<int> parent;
UnionFind(int N)
{
for (int i = 0; i < N; i++)
{
parent.push_back(-1);
}
}
int root(int A)
{
if (parent[A] < 0)
return A;
return parent[A] = root(parent[A]);
}
int size(int A)
{
return -parent[root(A)];
}
bool unite(int A, int B)
{
A = root(A);
B = root(B);
if (A == B)
return false;
if (size(A) < size(B))
swap(A, B);
parent[A] += parent[B];
parent[B] = A;
return true;
}
};
vector<pair<long long, long long>> prime(long long N)
{
vector<pair<long long, long long>> res;
for (long long i = 2; i * i <= N; i++)
{
if (N % i != 0)
continue;
long long ex = 0;
while (N % i == 0)
{
ex++;
N = N / i;
}
res.push_back({i, ex});
}
if (N != 1)
res.push_back({N, 1});
return res;
}
int main(void)
{
long long A, B;
cin >> A >> B;
vector<pair<long long, long long>> PA = prime(A);
vector<pair<long long, long long>> PB = prime(B);
map<long long, long long> result;
for (int i = 0; i < PA.size(); i++)
{
result[PA[i].first]++;
}
for (int i = 0; i < PB.size(); i++)
{
result[PB[i].first]++;
}
long long count = 1;
for (auto ans : result)
{
if (ans.second == 2)
count++;
}
cout << count << endl;
return 0;
}
| 1 |
/**
* author: tourist
* created: 17.11.2019 02:03:54
**/
#include <bits/stdc++.h>
using namespace std;
class dsu {
public:
vector<int> p;
int n;
dsu(int _n) : n(_n) {
p.resize(n);
iota(p.begin(), p.end(), 0);
}
inline int get(int x) {
return (x == p[x] ? x : (p[x] = get(p[x])));
}
inline bool unite(int x, int y) {
x = get(x);
y = get(y);
if (x != y) {
p[x] = y;
return true;
}
return false;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> x(n), y(n);
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
}
vector<tuple<int, int, int>> e;
auto Add = [&](int i, int j) { e.emplace_back(min(abs(x[i] - x[j]), abs(y[i] - y[j])), i, j); };
{
vector<int> order(n);
iota(order.begin(), order.end(), 0);
sort(order.begin(), order.end(), [&](int i, int j) { return x[i] < x[j]; });
for (int i = 0; i < n - 1; i++) Add(order[i], order[i + 1]);
}
{
vector<int> order(n);
iota(order.begin(), order.end(), 0);
sort(order.begin(), order.end(), [&](int i, int j) { return y[i] < y[j]; });
for (int i = 0; i < n - 1; i++) Add(order[i], order[i + 1]);
}
sort(e.begin(), e.end());
dsu d(n);
long long ans = 0;
for (auto& ee : e) {
if (d.unite(get<1>(ee), get<2>(ee))) ans += get<0>(ee);
}
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long> vl;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<string> vs;
// #define INF __INT32_MAX__
#define INF 1e9
#define LINF __LONG_LONG_MAX__
int main() {
int D, G; cin >> D >> G;
vi P(D), C(D); rep(i, D) cin >> P[i] >> C[i];
int res = INF;
for (int i = 0; i < 1<<D; i++) {
vi tmp;
vi notselected;
for (int j = 0; j < D; j++) {
if (i & 1<<j) {
tmp.push_back(j);
} else {
notselected.push_back(j);
}
}
int sum = 0;
int cnt = 0;
for (auto ii : tmp) {
int x = 100 * (ii + 1) * P[ii] + C[ii];
sum += x;
cnt += P[ii];
}
if (sum >= G) {
res = min(res, cnt);
continue;
}
sort(notselected.begin(), notselected.end());
reverse(notselected.begin(), notselected.end());
int diff = G - sum;
for (auto ii : notselected) {
if (diff <= 0) break;
int x = 100 * (ii + 1) * P[ii] + C[ii];
if (diff - x > 0) {
diff -= x;
cnt += P[ii];
continue;
}
for (int jj = 0; jj < P[ii]; jj++) {
diff -= 100 * (ii + 1);
cnt++;
if (jj == P[ii] - 1) diff -= C[ii];
if (diff <= 0) break;
}
}
res = min(res, cnt);
}
cout << res << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, e) for (int i = (int)(s); i <= (int)(e); i++)
#define printYesNo(is_ok) puts(is_ok ? "Yes" : "No");
#define SORT(v) sort(v.begin(), v.end());
#define RSORT(v) sort(v.rbegin(), v.rend());
#define REVERSE(v) reverse(v.begin(), v.end());
template <typename T>
void printlnVector(T v)
{
rep(i, v.size())
{
cout << v[i] << endl;
}
}
template <typename T>
void printVector(T v)
{
rep(i, v.size())
{
cout << v[i] << " ";
}
cout << endl;
}
int main()
{
int X, Y;
cin >> X >> Y;
int money[] = {300000,
200000,
100000};
int ans = 0;
if (X < 4)
ans += money[X - 1];
if (Y < 4)
ans += money[Y - 1];
if (X == 1 && Y == 1)
ans += 400000;
cout << ans << endl;
return 0;
} | #include <iostream>
#include<algorithm>
#include<string>
#include <cmath>
#include <vector>
#include <map>
#include <cstdio>
#include <iomanip>
#pragma region Macros
#define int long long
#define double long double
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,n) for(int i=1;i<=n;i++)
#define LAST(x) x[x.size()-1]
#define ALL(x) (x).begin(),(x).end()
#define swap(a,b) (a += b,b = a - b,a -= b)
#define CEIL(a,b) ((a+b-1)/b)
int FACT(int a) {
if (a == 0)
return 1;
else
return a * FACT(a - 1);
}
int nPr(int n, int r) {
int s = n-r+1;
int sum = 1;
for(int i =s;i<=n;i++)
sum *= i;
return sum;
}
//int nCr1(int n, int r)
//int nCr2(int n, int r)
int GCD(int a, int b) // assuming a,b >= 1
{
if (a < b)
swap(a, b);
if (b == 0)
return a;
if (a % b == 0)
return b;
return GCD(b, a % b);
}
int LCM(int a, int b) // assuming a,b >= 1
{
return a * b / GCD(a, b);
}
double LOG(int a, int b) {
return log(b) / log(a);
}
inline bool BETWEEN(int x, int min, int max) {
if (min <= x && x <= max)
return true;
else
return false;
}
using namespace std;
#pragma endregion
signed main() {
int x, y,z=0;
cin >> x >> y;
if (x == 1 && y == 1)
cout << 1000000;
else
cout << max(z, 100000 * (4 - x)) + max(z, 100000 * (4 - y));
} | 1 |
#include <iostream>
#include <cstdlib>
int main()
{
long long s;
std::cin >> s;
int min = 56562;
int diff;
int num;
int k = 1;
while (true) {
num = s / k % 1000;
if (num < 100) break;
diff = std::abs(753 - num);
if (min > diff) min = diff;
k *= 10;
}
std::cout << min << std::endl;
return 0;
}
| #include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
using namespace std;
int main()
{
string s;
cin >> s;
int ans = 999;
for(unsigned int i = 0; i < s.length() - 2; ++i)
{
int num = (s[i] - '0') * 100 + (s[i+1] - '0') * 10 +(s[i+2] - '0');
ans = min(ans, abs(753 - num));
}
cout << ans << endl;
} | 1 |
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <tuple>
#include <cstring>
#include <functional>
using namespace std;
typedef long long ll;
typedef pair<long long, long long> P;
#define rep(i, n) for(long long i=0; i<n; i++)
#define reps(i, s, e) for(long long i=s; i<e; i++)
#define repr(i, n) for(long long i=n-1; i>=0; i--)
#define reprs(i, s, e) for(long long i=e-1; i>=s; i--)
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n; cin >> n;
ll a[n];
rep(i, n){
cin >> a[i];
}
double a_sum = accumulate(a, a+n, 0LL);
double ave = a_sum / n;
double vmin = 1e18;
ll i_ans = 0;
rep(i, n){
double dif = abs(ave - a[i]);
if(dif < vmin){
i_ans = i;
vmin = dif;
}
}
cout << i_ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep2(i, x, n) for(int i = x; i <= n; i++)
#define rep3(i, x, n) for(int i = x; i >= n; i--)
#define elif else if
#define sp(x) fixed << setprecision(x)
#define pb(x) push_back(x)
#define all(x) x.begin(), x.end()
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const ll MOD = 1e9+7;
//const ll MOD = 998244353;
const int inf = 1e9;
const ll INF = 1e18;
const ld EPS = 1e-10;
int main(){
int N;
cin >> N;
int a[N];
int sum = 0;
rep(i, N) cin >> a[i], sum += a[i];
int ans = 0;
rep(i, N){
if(abs(a[ans]*N-sum) > abs(a[i]*N-sum)) ans = i;
}
cout << ans << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
void read(int &x) {
x=0;int f=1;char ch=getchar();
for(;!isdigit(ch);ch=getchar()) if(ch=='-') f=-f;
for(;isdigit(ch);ch=getchar()) x=x*10+ch-'0';x*=f;
}
void print(int x) {
if(x<0) putchar('-'),x=-x;
if(!x) return ;print(x/10),putchar(x%10+48);
}
void write(int x) {if(!x) putchar('0');else print(x);putchar('\n');}
#define lf double
#define ll long long
const int maxn = 2e3+10;
const int maxm = maxn*maxn;
const int inf = 1e9;
const lf eps = 1e-8;
const int mod = 1e9+7;
int add(int x,int y) {return x+y>mod?x+y-mod:x+y;}
int del(int x,int y) {return x-y<0?x-y+mod:x-y;}
int mul(int x,int y) {return 1ll*x*y-1ll*x*y/mod*mod;}
int n,k,f[maxn][maxn],fac[maxm],ifac[maxm],inv[maxm];
void prepare() {
inv[0]=inv[1]=fac[0]=ifac[0]=f[0][0]=1;
for(int i=2;i<maxm;i++) inv[i]=mul(mod-mod/i,inv[mod%i]);
for(int i=1;i<maxm;i++) fac[i]=mul(fac[i-1],i);
for(int i=1;i<maxm;i++) ifac[i]=mul(ifac[i-1],inv[i]);
}
int c(int nn,int mm) {return mul(fac[nn],mul(ifac[mm],ifac[nn-mm]));}
int main() {
read(n),read(k);prepare();if(k==1) puts("1"),exit(0);
for(int i=1;i<=n;i++)
for(int j=0;j<=i;j++)
f[i][j]=add(f[i-1][j],mul(f[i][j-1],mul(n-j+1,c(n*k-i-(k-1)*(j-1)-1,k-2))));
write(f[n][n]);
return 0;
}
| // IOI 2021
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define ends ' '
#define die(x) return cout << x << endl, 0
#define all(v) v.begin(), v.end()
#define sz(x) (int)(x.size())
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) { cerr << ends << H; debug_out(T...); }
#define debug(...) cerr << "{" << #__VA_ARGS__ << "}:", debug_out(__VA_ARGS__)
typedef long long ll;
typedef pair<int, int> pii;
const ll INF = 1e9;
const ll MOD = 1e9 + 7;
////////////////////////////////////////////////////////////////////
const int N = 2e3 + 5, M = 4e6 + 5;
int DP[N][N], F[M], I[M];
int Power(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = 1LL * a * a % MOD) if (b & 1) res = 1LL * res * a % MOD;
return res;
}
int C(int n, int r) { return r > n ? 0 : 1LL * I[r] * I[n - r] % MOD * F[n] % MOD; }
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
F[0] = 1;
for (int i = 1; i < M; i++) F[i] = 1LL * i * F[i - 1] % MOD;
I[M - 1] = Power(F[M - 1], MOD - 2);
for (int i = M - 2; i >= 0; i--) I[i] = 1LL * (i + 1) * I[i + 1] % MOD;
int n, k; cin >> n >> k;
if (k == 1) die(1);
DP[0][0] = 1;
for (int i = 1; i <= n; i++) {
DP[i][0] = 1LL * DP[i - 1][0] * C(i * (k - 1) - 1, k - 2) % MOD;
for (int j = 1; j <= i; j++) DP[i][j] = (DP[i][j - 1] + 1LL * DP[i - 1][j] * C(i * (k - 1) + j - 1, k - 2) % MOD) % MOD;
}
cout << 1LL * DP[n][n] * F[n] % MOD << endl;
return 0;
}
| 1 |
// ====================================
// author: M_sea
// website: https://m-sea-blog.com/
// ====================================
#include <bits/stdc++.h>
#define file(x) freopen(#x".in","r",stdin); freopen(#x".out","w",stdout)
#define debug(...) fprintf(stderr,__VA_ARGS__)
using namespace std;
typedef long long ll;
int read() {
int X=0,w=1; char c=getchar();
while (c<'0'||c>'9') { if (c=='-') w=-1; c=getchar(); }
while (c>='0'&&c<='9') X=X*10+c-'0',c=getchar();
return X*w;
}
const int N=1000+10;
const int mod=1e9+7;
int qpow(int a,int b) { int c=1;
for (;b;b>>=1,a=1ll*a*a%mod) if (b&1) c=1ll*c*a%mod;
return c;
}
int n,a,b,c,d,dp[N][N];
int fac[N],ifac[N];
void init(int n) {
fac[0]=1;
for (int i=1;i<=n;++i) fac[i]=1ll*fac[i-1]*i%mod;
ifac[n]=qpow(fac[n],mod-2);
for (int i=n;i;--i) ifac[i-1]=1ll*ifac[i]*i%mod;
}
int C(int n,int m) { return 1ll*fac[n]*ifac[m]%mod*ifac[n-m]%mod; }
int main() {
init(1000);
n=read(),a=read(),b=read(),c=read(),d=read();
for (int i=0;i<=b;++i) dp[0][i]=1;
for (int i=1;i<=n;++i)
for (int j=a;j<=b;++j) {
dp[i][j]=dp[i][j-1];
for (int k=c;k<=d;++k) {
if (i-j*k<0) break;
dp[i][j]=(dp[i][j]+1ll*dp[i-j*k][j-1]*C(n-i+j*k,j*k)%mod
*fac[j*k]%mod*ifac[k]%mod*qpow(ifac[j],k))%mod;
}
}
printf("%d\n",dp[n][b]);
return 0;
} | #include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=1005,ha=1e9+7;
inline int add(int x,int y){ x+=y; return x>=ha?x-ha:x;}
inline void ADD(int &x,int y){ x+=y; if(x>=ha) x-=ha;}
inline int ksm(int x,int y){
int an=1;
for(;y;y>>=1,x=x*(ll)x%ha) if(y&1) an=an*(ll)x%ha;
return an;
}
int jc[N],ni[N],f[N],n,a,b,c,d,ans,inv[N];
inline void init(){
jc[0]=1;
for(int i=1;i<=n;i++) jc[i]=jc[i-1]*(ll)i%ha;
ni[n]=ksm(jc[n],ha-2);
for(int i=n;i;i--) ni[i-1]=ni[i]*(ll)i%ha;
}
inline void dp(){
f[0]=1;
for(int i=a;i<=b;i++) // 最外层枚举 队伍的人数
for(int m=i*c,j=min(i*d,n);j>=m;j--) // 第二层枚举 已经选好的人数
for(int k=c,now=ksm(ni[i],c),M=j-c*i;k<=d&&M>=0;k++,M-=i,now=now*(ll)ni[i]%ha)
/* 第三层枚举 这种人数的队伍选几个*/
ADD(f[j],jc[j]*(ll)now%ha*(ll)ni[M]%ha*(ll)f[M]%ha*(ll)ni[k]%ha);
}
int main(){
scanf("%d%d%d%d%d",&n,&a,&b,&c,&d);
init(),dp(),printf("%d\n",f[n]);
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
#define all(v) (v).begin(),(v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
//typedef vector<vector<ll>> mat;
typedef vector<int> vec;
//繰り返し二乗法
ll mod_pow(ll a, ll n, ll m) {
ll res = 1;
while (n) {
if (n & 1)res = res * a%m;
a = a * a%m; n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() :n(0) { ; }
modint(ll m) :n(m) {
if (n >= mod)n %= mod;
else if (n < 0)n = (n%mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) { a.n += b.n; if (a.n >= mod)a.n -= mod; return a; }
modint operator-=(modint &a, modint b) { a.n -= b.n; if (a.n < 0)a.n += mod; return a; }
modint operator*=(modint &a, modint b) { a.n = ((ll)a.n*b.n) % mod; return a; }
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)return modint(1);
modint res = (a*a) ^ (n / 2);
if (n % 2)res = res * a;
return res;
}
//逆元(Eucledean algorithm)
ll inv(ll a, ll p) {
return (a == 1 ? 1 : (1 - p * inv(p%a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
using mP = pair<modint, modint>;
int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };
void solve() {
int H, W, A, B; cin >> H >> W >> A >> B;
vector<string> sv(H, string(W, '0'));
rep(i, H){
rep(j, W){
if(i < B && j < A || i >= B && j >= A){
sv[i][j] = '0';
}else if(i >= B && j < A || i < B && j >= A){
sv[i][j] = '1';
}
}
}
rep(i, H){
cout << sv[i] << endl;
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
//cout << fixed << setprecision(10);
//init_f();
//init();
//int t; cin >> t; rep(i, t)solve();
solve();
// stop
return 0;
}
| #include <iostream>
#include <vector>
int sort(std::vector<int> &v)
{
int size = v.size();
bool flag = true;
int idx = 0;
int swapCount = 0;
while (flag) {
flag = false;
for (int i = size - 1; i >= idx + 1; --i) {
if (v[i] < v[i-1]) {
int tmp = v[i];
v[i] = v[i-1];
v[i-1] = tmp;
++swapCount;
}
flag = true;
}
++idx;
}
return swapCount;
}
int main(void)
{
int n;
std::cin >> n;
std::vector<int> v(n);
for (int i = 0; i < n; ++i) {
std::cin >> v[i];
}
int cnt = sort(v);
for (int i = 0; i < n; ++i) {
std::cout << (i ? " " : "") << v[i];
}
std::cout << std::endl;
std::cout << cnt << std::endl;
return 0;
} | 0 |
#include <stdio.h>
#include <string.h>
#include <string>
#include <iostream>
#include <vector>
#include <sstream>
#include <memory>
#include <iomanip>
std::vector<int> parse_line(std::string const& line) {
using namespace std;
vector<int> result;
istringstream s(line);
string element;
while (getline(s, element, ' ')) {
stringstream buf;
int value = 0;
buf << element;
buf >> value;
result.push_back(value);
}
return std::move(result);
}
int main(int argc, char* argv[])
{
using namespace std;
while (true) {
string line;
getline(std::cin, line);
auto elements = parse_line(line);
auto length = elements[0];
if (length == 0) break;
vector<int> total(length + 1);
size_t width = length + 1;
for (size_t i = 0; i < length; ++i) {
getline(cin, line);
elements = parse_line(line);
int sum = 0;
for (size_t n = 0; n < length; ++n) {
int val = elements[n];
sum += val;
total[n] += val;
cout << setw(5) << val;
}
cout << setw(5) << sum << endl;
total[length] += sum;
}
for (size_t i = 0; i < width; ++i) {
cout << setw(5) << total[i];
}
cout << endl;
}
return 0;
} | #include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<map>
#include<set>
#include<queue>
#include<cstdio>
#include<climits>
#include<cmath>
#include<cstring>
#include<string>
#include<sstream>
#define f first
#define s second
#define mp make_pair
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define FOR(i,c) for(__typeof((c).begin()) i=(c).begin(); i!=(c).end(); i++)
#define ALL(c) (c).begin(), (c).end()
using namespace std;
typedef unsigned int uint;
typedef long long ll;
int main(){
int n;
while(cin>>n, n){
int allsum = 0;
vector<int> v(n);
REP(i, n){
int sum = 0;
REP(j, n){
int tmp;
cin >> tmp;
printf("%5d",tmp);
allsum += tmp; sum += tmp;
v[j] += tmp;
}
printf("%5d\n",sum);
}
REP(i, n)
printf("%5d",v[i]);
printf("%5d\n",allsum);
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
int main() {
map<ll,ll> mp;
ll N, MOD;
cin >> N >> MOD;
ll sum[N+1];
sum[0] =0;
mp[0]++;
for(int i=0;i<N;i++){
ll a;
cin >> a;
sum[i+1] = sum[i] + a;
sum[i+1] %=MOD;
mp[sum[i+1]]++;
}
ll ans =0;
for(auto itr = mp.begin();itr != mp.end();++itr){
ll n = itr->second;
ans += (n*(n-1))/2;
}
cout << ans << endl;
return 0;
} | # include <iostream>
# include <cmath>
# include <algorithm>
# include <stdio.h>
# include <cstdint>
# include <cstring>
# include <string>
# include <cstdlib>
# include <vector>
# include <bitset>
# include <map>
# include <queue>
# include <ctime>
# include <stack>
# include <set>
# include <list>
# include <random>
# include <deque>
# include <functional>
# include <iomanip>
# include <sstream>
# include <fstream>
# include <complex>
# include <numeric>
# include <immintrin.h>
# include <cassert>
# include <array>
# include <tuple>
# include <unordered_map>
# include <unordered_set>
# include <thread>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using ui32 = unsigned int;
constexpr ll INFLL = 1e18;
#define CHECK_IMPL1(cond) \
if (!(cond)) { \
DEBUG("expected cond: " << #cond); \
assert(cond); \
}
#define CHECK_IMPL2(cond, message) \
if (!(cond)) { \
DEBUG("expected cond: " << #cond << " failed with message: " << message); \
assert(cond); \
}
#define CHECK_IMPL(_1, _2, NAME, ...) NAME
#define CHECK(...) CHECK_IMPL(__VA_ARGS__, CHECK_IMPL2, CHECK_IMPL1, CHECK_IMPL0)(__VA_ARGS__)
#ifdef __APPLE__
#define DEBUG(message) std::cerr << message << "\n";
#else
#define DEBUG(message)
#endif
const int MOD = 1000 * 1000 * 1000 + 7;
struct Solver {
void solve() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> b(m);
for (int i = 0; i < m; i++) {
cin >> b[i];
}
int x = 0;
for (int i = 0; i + 1 < n; i++) {
x += 1LL * (a[i + 1] - a[i]) * (i + 1) % MOD * (n - i - 1) % MOD;
if (x >= MOD) {
x -= MOD;
}
}
int y = 0;
for (int i = 0; i + 1 < m; i++) {
y += 1LL * (b[i + 1] - b[i]) * (i + 1) % MOD * (m - i - 1) % MOD;
if (y >= MOD) {
y -= MOD;
}
}
cout << (1LL * x * y) % MOD << "\n";
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
#ifdef __APPLE__
freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
#endif
int t = 1;
// cin >> t;
for (int i = 1; i <= t; i++) {
Solver().solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long llong;
#define rep(i, n) for (int i = 0; i < n; ++i)
char gf[1200][1200];
int main()
{
int n;
scanf("%d", &n);
if (n < 3)
printf("-1");
else if (n == 3)
printf("z..\nz..\n.zz");
else if (n == 7)
printf("a..bbaa\na...abb\n.az.a..\n.az..a.\n..azza.\nbba...a\naabb..a");
else
{
int rn = n;
if (n & 1)
rn -= 5;
for (int i = 0; i < rn; i += 2)
gf[i][i] = gf[i + 1][i] = 'a',
gf[i][i + 1] = gf[i + 1][i + 1] = 'b';
for (int i = 2; i < rn; i += 2)
gf[i][i - 2] = gf[i][i - 1] = 'c',
gf[i + 1][i - 2] = gf[i + 1][i - 1] = 'd';
gf[0][rn - 2] = gf[0][rn - 1] = 'c';
gf[1][rn - 2] = gf[1][rn - 1] = 'd';
if (n & 1)
strcpy(&gf[rn][rn], "aabba"),
strcpy(&gf[rn + 1][rn], "bz..a"),
strcpy(&gf[rn + 2][rn], "bz..b"),
strcpy(&gf[rn + 3][rn], "a.zzb"),
strcpy(&gf[rn + 4][rn], "abbaa");
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < n; ++j)
if (gf[i][j])
printf("%c", gf[i][j]);
else
printf(".");
printf("\n");
}
}
return 0;
} | #include <bits/stdc++.h>
#define uint unsigned long long
#define ll long long
#define db long double
#define ls rt << 1
#define rs rt << 1 | 1
#define pb push_back
#define mp make_pair
#define pii pair<int, int>
#define X first
#define Y second
#define pcc pair<char, char>
#define vi totor<int>
#define vl totor<ll>
#define rep(i, x, y) for(register int i = x; i <= y; i ++)
#define rrep(i, x, y) for(register int i = x; i >= y; i --)
#define eps 1e-15
#define lb(x) x & -x
#define sz(x) (x).size()
using namespace std;
inline int read()
{
int x = 0, f = 1; char ch = getchar();
while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar(); }
while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
return x * f;
}
inline ll read1()
{
ll x = 0, f = 1; char ch = getchar();
while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar(); }
while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
return x * f;
}
const int mod = 1e9 + 7;
char ch[300010];
int n;
ll k, dp[300010][5][3];
int main()
{
scanf("%s", ch);
n = strlen(ch);
dp[0][2][0] = 1;
rep(i, 0, n - 1)
{
if (ch[i] != '0')
{
(dp[i + 1][4][1] += dp[i][4][1]) %= mod;
(dp[i + 1][4][1] += dp[i][3][1]) %= mod;
(dp[i + 1][3][1] += dp[i][2][0]) %= mod;
(dp[i + 1][3][1] += dp[i][2][1]) %= mod;
(dp[i + 1][2][0] += dp[i][1][0]) %= mod;
(dp[i + 1][2][1] += dp[i][1][1]) %= mod;
(dp[i + 1][1][0] += dp[i][0][0]) %= mod;
}
if (ch[i] != '1')
{
(dp[i + 1][4][1] += dp[i][4][1]) %= mod;
(dp[i + 1][2][1] += dp[i][3][1]) %= mod;
(dp[i + 1][1][0] += dp[i][2][0]) %= mod;
(dp[i + 1][1][1] += dp[i][2][1]) %= mod;
(dp[i + 1][0][0] += dp[i][1][0]) %= mod;
(dp[i + 1][2][1] += dp[i][1][1]) %= mod;
(dp[i + 1][1][0] += dp[i][0][0]) %= mod;
}
}
cout << (dp[n][3][1] + dp[n][4][1]) % mod << endl;
return 0;
}
| 0 |
#include<iostream>
using namespace std;
int x[10000000];
int G[20];
int v;
int w;
int cnt=0;
int m;
int n;
void sort1(int x[],int n,int g){
for(int i=g;i<n;i++){
v=x[i];
w=i-g;
while(w>=0 && x[w]>v){
x[w+g]=x[w];
w=w-g;
cnt++;
}
x[w+g]=v;
}
}
void sort2(int x[],int n){
cnt=0;
for(int h=0;h<20;h++){
if(G[h]>n){
m=h;
break;
}
}
cout<<m<<endl;
for(int h=m-1;h>=0;h--){
cout<<G[h];
if(h){
cout<<' ';
}
sort1(x,n,G[h]);
}
cout<<endl;
}
int main(){
G[0]=1;
for(int i=1;i<20;i++){
G[i]=G[i-1]*3+1;
}
cin>>n;
for(int i=0;i<n;i++){
cin>>x[i];
}
sort2(x,n);
cout<<cnt<<endl;
for(int i=0;i<n;i++){
cout<<x[i]<<endl;
}
return 0;
} | #include <iostream>
#include <memory>
#include <cmath>
constexpr int max_size()
{
return static_cast<int>(1e+6);
}
int insert(int* a, const int i, const int gear)
{
if (i < gear) {
return 0;
}
if (a[i - gear] <= a[i]) {
return 0;
}
std::swap(a[i - gear], a[i]);
return 1 + insert(a, i - gear, gear);
}
int insertion_sort(int* arr, const int n, const int gear)
{
int insert_count = 0;
for (int i = 0; i < n; i += gear) {
insert_count += insert(arr, i, gear);
}
return insert_count;
}
int pow(const int a, const int x) {
return x == 0 ? 1 : a * pow(a, x - 1);
}
void print(int* arr, const int n, char const delim) {
int i = 0;
for (; i < n - 1; ++i) {
std::cout << arr[i] << delim;
}
std::cout << arr[i];
}
void shell_sort(int* arr, const int n) {
static const double log3 = std::log(3);
const int gear_index = static_cast<int>(std::log(2 * n + 1) / log3 - 1);
int gear = (pow(3, gear_index + 1) - 1) >> 1;
int gear_cache[100];
int cache_idx = 0;
int insert_count = 0;
for (; gear > 0; gear = (gear - 1) / 3) {
gear_cache[cache_idx] = gear;
for (int i = 0; i < gear; ++i) {
insert_count += insertion_sort(arr + i, n - i, gear);
}
++cache_idx;
}
std::cout << cache_idx << std::endl;
print(gear_cache, cache_idx, ' ');
std::cout << std::endl;
std::cout << insert_count << std::endl;
return;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n;
std::cin >> n;
constexpr int N = max_size();
const auto r = std::make_unique<int[]>(N);
for (int i = 0; i < n; ++i) {
std::cin >> r[i];
}
shell_sort(r.get(), n);
print(r.get(), n, '\n');
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll GCD(ll a, ll b) {
return a % b ? GCD(b, a % b): b;
}
vector<pair<ll, ll> > prime_factorize(ll n) {
vector<pair<ll,ll>> res;
for (ll a = 2; a * a <= n; ++a) {
if (n % a != 0) continue;
ll ex = 0; // 指数
// 割れる限り割り続ける
while (n % a == 0) {
++ex;
n /= a;
}
// その結果を push
res.push_back({a, ex});
}
// 最後に残った数について
if (n != 1) res.push_back({n, 1});
return res;
}
int main() {
ll A, B;
cin >> A >> B;
ll g = GCD(max(A, B), min(A,B));
vector<pair<ll,ll>> vec_f = prime_factorize(g);
cout << vec_f.size() + 1 << endl;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
#define FOR(i,n,j) for(int i=(j);i<(n);++i)
#define ssort(n) sort((n).begin(),(n).end())
#define rsort(n) sort((n).begin(),(n).end(),greater<int>())
using ll=long long;
using ld=long double;
typedef pair<int,int> P;
typedef pair<P,int> COST;
#define repl(i,n) for(ll i=0;i<(n);++i)
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define YES cout << "YES" << endl
#define NO cout << "NO" << endl
using Graf=vector<vector<int>>;
#define MAX 10000000
int main()
{
ll a,b;
vector<ll> num;
cin >> a >> b;
if(a==b&&a==1){
cout << 1 << endl;
return 0;
}
if(a<b){
swap(a,b);
}
ll c=a;
ll i;
for(i=2;i*i<=c;++i){
if(c%i!=0){
continue;
}
while(c%i==0){
c/=i;
}
num.push_back(i);
}
if(c!=1){
num.push_back(c);
}
ssort(num);
ll count=1;
rep(i,num.size()){
if(b>=num[i]){
if(b%num[i]==0){
count++;
}
}
}
cout << count << endl;
} | 1 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int N, M;
cin >> N >> M;
int INF = -1e9;
vector<int> dpk(N + 1, INF), A(M);
for(int i = 0; i < M; i++) cin >> A[i];
sort(A.begin(), A.end());
vector<int> cost(M);
for(int i = 0; i < M; i++){
if(A[i] == 1) cost[i] = 2;
else if(A[i] == 2 || A[i] == 3 || A[i] == 5) cost[i] = 5;
else if(A[i] == 4) cost[i] = 4;
else if(A[i] == 6 || A[i] == 9) cost[i] = 6;
else if(A[i] == 7) cost[i] = 3;
else cost[i] = 7;
}
dpk[0] = 0;
for(int i = 1; i < N + 1; i++){
for(int j = 0; j < M; j++){
if(i - cost[j] >= 0) dpk[i] = max(dpk[i], dpk[i - cost[j]] + 1);
}
}
int keta = dpk[N];
vector<int> ke(keta);
int i = 0;
while(N > 0){
for(int j = M - 1; j >= 0; j--){
if(N - cost[j] >= 0 && dpk[N] == dpk[N - cost[j]] + 1){
ke[i] = A[j];
i++;
N -= cost[j];
break;
}
}
}
for(int i = 0; i < keta; i++){
cout << ke[i];
}
cout << endl;
} | #include<iostream>
#include<stdio.h>
//#include <bits/stdc++.h>
#include<vector>
#include<float.h>
#include<iomanip>
#include<algorithm>
#include<string>
#include<cstring>
#include<math.h>
#include<cmath>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include <cassert>
#include <cmath>
#include<cstdint>
#define INF 1e9
#define rep(i,n)for(int i=0;(i)<(int)(n);i++)
#define REP(i,a,b)for(int i=(int)(a);(i)<=(int)(b);i++)
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define vec(type,n) vector<type>(n)
#define vvec(m,n) vector<vector<int>> (int(m),vector<int>(n))
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using P = pair<ll, ll>;
string dp[20000];
int main(){
int n, m;
cin >> n >> m;
vector<int> a(m);
int cost[10] = {-1, 2, 5, 5, 4, 5, 6, 3, 7, 6};
rep(i, m)cin >> a[i];
rep(i, n + 100)dp[i] = "-";
dp[0] = "";
rep(i, n){
if(dp[i] == "-")continue;
for(int now : a){
if(dp[i + cost[now]].size() == dp[i].size() + 1){
if(dp[i + cost[now]] < dp[i] + to_string(now))dp[i + cost[now]] = dp[i] + to_string(now);
}
else if(dp[i + cost[now]].size() < dp[i].size() + 1)dp[i + cost[now]] = dp[i] + to_string(now);
}
}
cout << dp[n] << endl;
}
| 1 |
#include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
//namespace mp = boost::multiprecision;
using namespace std;
const double PI = 3.14159265358979323846;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef pair<ll, ll> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
double equal(double a, double b) {
return fabs(a - b) < DBL_EPSILON;
}
std::istream &operator>>(std::istream &in, set<int> &o) {
int a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
typedef priority_queue<ll, vector<ll>, greater<ll> > PQ_ASK;
int main() {
// 最小本数
// 最大本数
// 桁数
// 桁目を何にしたか
// 残り
// 大きい順に優先
// 残り桁数＊最小本数＜＝残り本数＆＆残り桁数＊最大本数＞＝残り本数なら可能
map<int, int> u = {
{1, 2},
{2, 5},
{3, 5},
{4, 4},
{5, 5},
{6, 6},
{7, 3},
{8, 7},
{9, 6},
};
int n, m;
cin >> n >> m;
vector<int> v(m);
rep(i, m) cin >> v[i];
sort(v.rbegin(), v.rend());
int mi = INT_MAX;
for (int i : v) cmin(mi, u[i]);
int ma = 0;
for (int i : v) cmax(ma, u[i]);
vector<int> dp(n + 100, -1);
vector<int> prev(n + 100, -1);
dp[0] = 0;
rep(i, n) {
if (dp[i] == -1) continue;
for (int j : v) {
int use = u[j];
int next_keta = dp[i] + 1;
int next_use = i + use;
if (dp[next_use] <= next_keta) {
dp[next_use] = next_keta;
prev[next_use] = j;
}
}
}
int k = dp[n];
int a = n;
while (a > 0) {
for (int i : v) {
int use = u[i];
int back = a - use;
if (back < 0) continue;
if (dp[a] - 1 == dp[back]) {
cout << i;
a = back;
break;
}
}
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n;
int m;
vector<int> v;
int num[10] = {0,2,5,5,4,5,6,3,7,6};
int dp[10010][10];
int pre[10010][10];
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
v.push_back(a);
}
for (int i = 0; i < 10010; i++) {
for (int j = 0; j < 10; j++) {
dp[i][j] = -1;
pre[i][j] = -1;
}
}
sort(v.begin(), v.end());
for (int i = 0; i < m; i++) {
dp[0][i] = 0;
}
int mx = -1;
int pos = -1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = j; k < m; k++) {
int use = num[v[j]];
if (dp[i+use][k] < dp[i][j]+1) {
dp[i+use][k] = dp[i][j]+1;
pre[i+use][k] = j;
}
else if (dp[i+use][k] == dp[i][j]+1) {
pre[i+use][k] = max(pre[i+use][k],j);
}
if (dp[i+use][k] > mx && i+use == n) {
mx = dp[i+use][k];
pos = k;
}
else if (i+use == n && dp[i+use][k] == mx) {
pos = max(pos,k);
}
}
}
}
int y = n;
int x = pos;
// for (int i = 0; i <= n; i++) {
// for (int j = 0; j < m; j++) {
// cout << pre[i][j] << " ";
// }
// cout << endl;
// }
while (1) {
// cout << x << " " << y << endl;
cout << v[pre[y][x]];
int kk = v[pre[y][x]];
x = pre[y][x];
y -= num[kk];
if (y == 0) break;
}
cout << endl;
}
/* 【提出前に確認すること】
・コンパイルできるか
・テストケース試したか
・オーバーフローあるか
*/
| 1 |
#include <iostream>
using namespace std;
struct Dice{
int f[7];
void move(char dir){
int sw;
switch(dir){
case 'E':
sw = f[1];
f[1] = f[4];
f[4] = f[6];
f[6] = f[3];
f[3] = sw;
break;
case 'N':
sw = f[1];
f[1] = f[2];
f[2] = f[6];
f[6] = f[5];
f[5] = sw;
break;
case 'S':
sw = f[1];
f[1] = f[5];
f[5] = f[6];
f[6] = f[2];
f[2] = sw;
break;
case 'W':
sw = f[1];
f[1] = f[3];
f[3] = f[6];
f[6] = f[4];
f[4] = sw;
break;
}
}
};
int main() {
Dice dice;
for(int i = 1; i <= 6; ++i){
cin >> dice.f[i];
}
string com;
cin >> com;
int n = com.length();
for(int i = 0; i < n; ++i){
dice.move(com[i]);
}
cout << dice.f[1] << endl;
return 0;
} | // Vote
#include <iostream>
#include <stdio.h>
using namespace std;
int main(void){
int N, M, i, j, maxp = 0, maxs;
scanf("%d %d", &N, &M);
int a[N], b[M], p[N];
for (i = 0; i < N; ++i){
cin >> a[i];
p[i] = 0;
}
for (j = 0; j < M; ++j){
cin >> b[j];
}
for (j = 0; j < M; ++j){
for (i = 0; i < N; ++i){
if (a[i] <= b[j]){
p[i]++;
break;
}
}
}
for (i = 0; i < N; ++i){
if (p[i] > maxp){
maxp = p[i];
maxs = i+1;
}
}
cout << maxs << endl;
return 0;
} | 0 |
#include <iostream>
#include <string>
using namespace std;
int main()
{
int n; char c; string s;
while(cin >> n)
{
int cd[13]={0},pr[5]={0};
cd[n-1]++;
for(int i=0; i<4; i++)
{
cin >> c >> n;
cd[n-1]++;
}
for(int i=0; i<13; i++)
{
pr[cd[i]]++;
}
bool st=false;
for(int i=0; i<10; i++)
{
int sm=0;
for(int j=0; j<5; j++) sm+=(cd[(i+j)%13]?1:0);
if(sm==5) st=true;
}
s="null";
if(pr[4]) s="four card";
else if(pr[3]&&pr[2]) s="full house";
else if(st) s="straight";
else if(pr[3]) s="three card";
else if(pr[2]==2) s="two pair";
else if(pr[2]) s="one pair";
cout << s << endl;
}
} | #include <iostream>
#include <algorithm>
#include <string>
#include <cmath>
#include <stack>
using namespace std;
int main(){
int hand[5];
char s[4];
while(cin >> hand[0] >> s[0] >> hand[1] >> s[1] >> hand[2] >> s[2] >> hand[3] >> s[3] >> hand[4]){
int trump[14] = {};
for(int i = 0; i < 5; i++)trump[hand[i]]++;
for(int i = 1; i <= 10; i++){
for(int j = 0; j < 5; j++){
int k = i + j;
if(k == 14)k = 1;
if(trump[k] != 1)goto no;
}
cout << "straight" << endl;
goto fin;
no:;
}
sort(trump, trump + 14, greater<int>());
if(trump[0] == 4){
cout << "four card" << endl;
goto fin;
}else if(trump[0] == 3 && trump[1] == 2){
cout << "full house" << endl;
goto fin;
}else if(trump[0] == 3){
cout << "three card" << endl;
goto fin;
}else if(trump[0] == 2 && trump[1] == 2){
cout << "two pair" << endl;
goto fin;
}else if(trump[0] == 2){
cout << "one pair" << endl;
goto fin;
}
cout << "null" << endl;
fin:;
}
}
| 1 |
#include <bits/stdc++.h>
#define s second
#define f first
#define pb push_back
#define endl '\n'
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int INF = 0x3f3f3f3f;
const ll LINF = 0x3f3f3f3f3f3f3f3fLL;
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
vector<string> S(3);
for(int i = 0; i < 3; i++) cin >> S[i];
int i = 0;
while(S[i].size()){
char r = S[i][0];
S[i].erase(S[i].begin());
i = r - 'a';
}
cout << (char)(i + 'A') << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int main(){
int A,B,C,D;
cin>>A>>B>>C>>D;
if(A<=B){
if(C<=D)
cout<<A+C<<endl;
else
cout<<A+D<<endl;
}else{
if(C<=D)
cout<<B+C<<endl;
else
cout<<B+D<<endl;
}
return 0;
} | 0 |
/* ░░█ ▄▀█ █ █▀ █░█ █▀█ █▀▀ █▀▀ █▀█ ▄▀█ █▀▄▀█
█▄█ █▀█ █ ▄█ █▀█ █▀▄ ██▄ ██▄ █▀▄ █▀█ █░▀░█ */
// Author : Udit "luctivud" Gupta @ (https://www.linkedin.com/in/udit-gupta-1b7863135/)
#include <bits/stdc++.h>
#pragma GCC optimize "trapv"
using namespace std;
typedef long long int lld;
typedef unsigned long long int llu;
#define TESTCASES() cin >> (T3X0); T353 = T3X0; while(T3X0--)
#define _input(V3C) for(auto &V3C_I7 : (V3C)) cin >> (V3C_I7)
#define mems(A77AY, V4LU) memset((A77AY), (V4LU), sizeof((A77AY)))
#define CH3K(I7, E4, S7) (((S7)<0) ? (I7)>(E4) : (I7)<(E4))
#define for4(I7,S4,E4,S7) for(auto I7=(S4); CH3K(I7,E4,S7); (I7)+=(S7))
void solveEachTest(lld T35TC453N = 1) {
lld n; cin >> n;
lld temp = n;
lld suum = 0ll;
while (temp) {
suum += temp % 10;
temp /= 10;
}
puts( (n % suum == 0) ? "Yes" : "No" );
return;
}
signed main() {
ios_base::sync_with_stdio(false); cin.tie(0);
lld T3X0 = 0, T353 = 1;
// TESTCASES()
solveEachTest(T353 - T3X0);
return 0;
}
// Random Thought : null | #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<ll,ll>;
//マクロ
//forループ関係
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
//Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define FOR(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 inf 2147483647 //int値の最大値
#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の二つ目の要素
#define CST(x) cout<<fixed<<setprecision(x)//小数点以下の桁数指定
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int gcd(int a, int b) {
if (b==0) return a;
else return gcd(b, a%b);
}
int lcm(int a, int b) {
return a * b / gcd(a, b);
}
int two(int n){
ll ans=1;
rep(i,n){
ans*=2;
}
return ans;
}
int waru(int n){
int s=0;
while(n>0){
s +=n%10;
n=n/10;
}
return s;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int n;
cin>>n;
if(n%waru(n)==0){
cout<<"Yes\n";
}
else{
cout<<"No"<<endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define all(x) (x).begin(), (x).end()
#define pb emplace_back
#define ll long long
const int INF = 2e9 + 1;
const ll INFLL = 1e18 + 1;
const ll mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, r;
cin >> n >> r;
cout << r + 100 * max(0, 10 - n);
return 0;
}
| #include<iostream>
using namespace std;
long long int MOD = 1000000007;
long long modpow(long long a, long long n, long long mod);
long long modinv(long long a, long long mod);
int main() {
//A
int n, r;
cin >> n >> r;
if (n >= 10) {
cout << r << endl;
}
else {
cout << r + 100 * (10 - n) << endl;
}
return 0;
//B
/*int n;
cin >> n;
int k;
cin >> k;
int i = 0;
while (n > 0) {
n = (int)(n / k);
i++;
}
cout << i << endl;
return 0;*/
//C
/*int n;
cin >> n;
int x[100];
int i;
for (i = 0; i < n; i++) {
cin >> x[i];
}
int sum, j, summin = 100000000;
for (i = 0; i <= 100; i++) {
sum = 0;
for (j = 0; j < n; j++) {
sum = sum + (x[j] - i) * (x[j] - i);
}
if (sum < summin)summin = sum;
}
cout << summin << endl;
return 0;
*/
//D
/*
long long int n;
cin >> n;
long long int a, b;
cin >> a >> b;
if (n == 2) {
cout << 0 << endl;
return 0;
}
long long int sum = 1;
int i;
long long int x = 2, m = n;
//2^nを計算
while (m > 0) {
if (m % 2 == 1) {
sum = (sum * x) % MOD;
}
m = (int)(m / 2);
x = (x * x) % MOD;
}
//cout << 1 << endl;
long long int sum1 = 1;
for (i = 1; i <= a; i++) {
sum1 = (sum1 * (n + 1 - i)) % MOD;
}
for (i = 1; i <= a; i++) {
sum1 = (sum1 * modinv(i, MOD)) % MOD;
}
sum = (sum - sum1 + MOD) % MOD;
//cout << 2 << endl;
sum1 = 1;
for (i = 1; i <= b; i++) {
sum1 = (sum1 * (n + 1 - i)) % MOD;
}
for (i = 1; i <= b; i++) {
sum1 = (sum1 * modinv(i, MOD)) % MOD;
}
sum = (sum - sum1 + MOD) % MOD;
sum = (sum + MOD - 1) % MOD;
cout << sum << endl;
return 0;
*/
}
// a^n mod を計算する
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// a^{-1} mod を計算する
long long modinv(long long a, long long mod) {
return modpow(a, mod - 2, mod);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define _for(i,j,N) for(int i = (j);i < (N);i++)
#define _rep(i,j,N) for(int i = (j);i <= (N);i++)
#define _dec(i,N,j) for(int i = (N-1);i >= (j);i--)
#define _rec(i,N,j) for(int i = (N);i >=(j);i--)
#define ALL(x) x.begin(),x.end()
#define MEM(a,n) memset(a,n,sizeof(a))
#define fst first
#define scd second
#define PB push_back
#define MP make_pair
typedef long long LL;
typedef long double LD;
typedef pair<int,int> pii;
typedef pair<LL,LL> pll;
int get_int(){int x;scanf("%d",&x);return x;}
LL get_ll(){LL x;scanf("%lld",&x);return x;}
double get_db(){double x;scanf("%lf",&x);return x;}
template<typename T> int chmin(T &a,T b){if(a > b){a = b;return 1;}else return 0;}
template<typename T> int chmax(T &a,T b){if(a < b){a = b;return 1;}else return 0;}
template<typename T>
ostream& operator<<(ostream& os,const vector<T>& v) {_for(i,0,v.size()) os << v[i] << " ";return os;}
template<typename T>
ostream& operator<<(ostream& os,const set<T>& v){for(auto a:v) os << a <<" ";return os;}
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const pair<T1,T2>& v){os << v.fst <<" "<<v.scd << " ";return os;}
template<typename T1,typename T2>
ostream& operator<<(ostream& os,const map<T1,T2>& v){for(auto a:v) cout << a << endl;return os;}
static const int dx[8] = { -1, 0, 1, 0, 1, -1, 1, -1};
static const int dy[8] = {0, 1, 0, -1, 1, -1, -1, 1};
const double pi = acos(-1.0);
const double eps = 1e-8;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int inf = 0x3f3f3f3f;
const int maxn = 1e5+5;
unsigned long long sum = 0;
LL ans = 0;
LL one = 1;
unsigned long long A[maxn];
int used[maxn];
int cnt[maxn];
char M[62][maxn];
int N;
int Gauss(int H,int W)
{
int i,j,col;
for(col = 0;col < W;col++){
int pivot = -1;
for(int row = 0;row < H;row++){
int bit = 61 - row;
if(used[bit]) continue;
if(M[row][col] == 1){
pivot = row;
break;
}
}
used[61 - pivot] = 1;
for(int row = 0;row < H;row++){
int bit = 61 - row;
if(used[bit]) continue;
if(M[row][col] == 1){
for(j = col;j <= W;j++){
M[row][j] ^= M[pivot][j];
}
}
}
}
return 0;
}
int bit_n(LL t){
int ret = 0;
_for(i,0,N){
if(t & A[i]) ret++;
}
return ret;
}
int main()
{
cin >> N;
_for(i,0,N) {
cin >> A[i];
}
MEM(used,0);
for(int bit = 61;bit >= 0;bit--){
LL t = one<<bit;
cnt[bit] = bit_n(t);
}
MEM(M,0);
LL ans = 0;
for(int bit = 0;bit <= 61;bit++){
LL t = one<<bit;
if(cnt[bit] == 0) {
used[bit] = 1;
continue;
}
else if(cnt[bit] & 1) {
ans += t;
used[bit] = 1;
continue;
}
else M[61 - bit][N] = 1;
_for(i,0,N){
if(t & A[i]){
if(!used[bit])
M[61-bit][i] = 1;
}
}
}
/*
_for(i,54,62){
if(cnt[61-i] == 0 || (cnt[61-i]&1)) continue;
_rep(j,0,N){
printf("%d ",M[i][j]);
}
printf("\n");
}
*/
Gauss(62,N);
_rep(i,0,61){
int bit = 61 - i;
if(cnt[bit] == 0 || (cnt[bit]) & 1) continue;
int ok = 0;
_for(j,0,N) if(M[i][j]) ok = 1;
if(!M[i][N]) ok = 1;
if(ok) ans += (one << (bit+1));
}
/*
_for(i,54,62){
if(cnt[61-i] == 0 || (cnt[61-i]&1)) continue;
_rep(j,0,N){
printf("%d ",M[i][j]);
}
printf("\n");
}
*/
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <algorithm>
#include <iomanip>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <vector>
#include <string>
#include <queue>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <bitset>
using namespace std;
typedef long long ll;
int main() {
ll N; cin >> N;
ll* A = new ll[N];
ll m = 0;
ll sum = 0;
for (int i = 0; i < N; i++) {
cin >> A[i];
sum = sum ^ A[i];
m = m | A[i];
}
ll filter = m - sum;
set<ll, greater<ll>> st;
for (int i = 0; i < N; i++) {
ll a = A[i] & filter;
for (auto itr = st.begin(); itr != st.end(); itr++) {
a = min(a, a ^ *itr);
}
if (a != 0) {
st.insert(a);
}
}
ll s = filter;
for (auto itr = st.begin(); itr != st.end(); itr++) {
s = min(s, (s ^ *itr) & filter);
}
cout << sum + (filter - s) * 2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef vector<vector<long long>> VVL;
typedef vector<string> VS;
typedef pair<int, int> P;
typedef tuple<int,int,int> tpl;
#define ALL(a) (a).begin(),(a).end()
#define SORT(c) sort((c).begin(),(c).end())
#define REVERSE(c) reverse((c).begin(),(c).end())
#define EXIST(m,v) (m).find((v)) != (m).end()
#define LB(a,x) lower_bound((a).begin(), (a).end(), x) - (a).begin()
#define UB(a,x) upper_bound((a).begin(), (a).end(), x) - (a).begin()
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RFOR(i,a,b) for(int i=(a)-1;i>=(b);--i)
#define RREP(i,n) RFOR(i,n,0)
#define en "\n"
constexpr double EPS = 1e-9;
constexpr double PI = 3.1415926535897932;
constexpr int INF = 2147483647;
constexpr long long LINF = 1LL<<60;
constexpr long long MOD = 1000000007; // 998244353;
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
int N, L, LOGN; // LOGN = floor(log2(N))+1;
VI x;
vector<vector<int>> tab,tab2;
void doubling(){
for(int i=0; i<N; i++){
int it = UB(x, x[i]+L);
if(it-1 == i) tab[i][0] = -1;
else tab[i][0] = it-1;
}
for(int k=0; k<LOGN; k++)
for(int i=0; i<N; i++){
if(tab[i][k] == -1) tab[i][k+1] = -1;
else tab[i][k+1] = tab[tab[i][k]][k];
}
}
int query(int n, long long k){
int ret = n, count = 0;
while(k){
if(k&1) ret = tab[ret][count];
count++;
k >>= 1;
if(ret == -1) return ret;
}
return ret;
}
void doubling2(){
for(int i=0; i<N; i++){
int it = LB(x,x[i]-L);
if(it == i) tab2[i][0] = -1;
else tab2[i][0] = it;
}
for(int k=0; k<LOGN; k++)
for(int i=0; i<N; i++){
if(tab2[i][k] == -1) tab2[i][k+1] = -1;
else tab2[i][k+1] = tab2[tab2[i][k]][k];
}
}
int query2(int n, long long k){
int ret = n, count = 0;
while(k){
if(k&1) ret = tab2[ret][count];
count++;
k >>= 1;
if(ret == -1) return ret;
}
return ret;
}
void Main(){
cin >> N; LOGN = floor(log2(N))+1; x.resize(N); tab.resize(N,VI(LOGN+1)), tab2.resize(N,VI(LOGN+1));
REP(i,N) cin >> x[i];
cin >> L;
doubling(); doubling2();
int Q; cin >> Q;
REP(_,Q){
int a,b; cin >> a >> b; a--; b--;
int ans;
if(a < b){
int l = 0, r = N;
while(r-l>1){
int k = (l+r)/2;
int loc = query(a,k);
if(loc<b && loc!=-1) l = k;
else r = k;
}
ans = r;
}
else{
int l = 0, r = N;
while(r-l>1){
int k = (l+r)/2;
int loc = query2(a,k);
if(b<loc) l = k;
else r = k;
}
ans = r;
}
cout << ans << en;
}
return;
}
int main(void){
cin.tie(0);cout.tie(0);ios_base::sync_with_stdio(0);cout<<fixed<<setprecision(15);
int t=1; //cin>>t;
REP(_,t) Main();
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n,q;
vector<int> S,T;
cin >> n;
for(int i=0;i<n;i++) {
int s;
cin >> s;
S.push_back(s);
}
cin >> q;
for(int i=0;i<q;i++) {
int t;
cin >> t;
T.push_back(t);
}
// O(n^2)
int C = 0;
for(int t_itr=0;t_itr<q;t_itr++) {
int key = T[t_itr];
for(int s_itr=0;s_itr<n;s_itr++) {
if(S[s_itr] == key) {
C++;
break;
}
}
}
cout << C << endl;
} | 0 |
#include <bits/stdc++.h>
#define st first
#define nd second
#define mp make_pair
#define pb push_back
#define mod 1000000007
#define N 1100005
using namespace std;
typedef long long ll;
ll n, ans, kac, a[N], pre[N], dp[N], fen[N], of[N];
vector < int > g[N];
ll fe(ll a, ll us){
if(us <= 1)
return (us)?a:1ll;
ll t = fe(a, us/2);
return (us&1)?(t*t%mod)*a%mod : t*t%mod;
}
void up(int x, int y){
for(; x < N; x += x&-x)
fen[x] += y;
}
int qu(int x){
int ans = 0;
for(; x > 0; x -= x&-x)
ans += fen[x];
return ans;
}
int main() {
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
scanf("%lld",&n);
for(int i = 1; i <= n; i++){
scanf("%lld",a + i);
pre[i] = pre[i - 1]^a[i];
g[pre[i]].pb(i);
if(!pre[i])
up(i, 1);
}
if(pre[n] != 0){
ll sif = 1;
ll bir = 0;
for(int i = 1; i <= n; i++){
if(pre[i] == pre[n])
bir = (bir + sif)%mod;
else if(pre[i] == 0)
sif = (sif + bir)%mod;
}
printf("%lld\n", sif);
return 0;
}
kac = (int)g[pre[n]].size();
ans = (ans + fe(2, kac - 1))%mod;
// cout << ans << endl;
for(int i = 1; i < N; i++){
if(g[i].empty())
continue;
int u = (int)g[i].size(), ek = 1;
of[0] = dp[0] = 1;
// cout << i << " " << u << endl << " -> " << g[i][0] << " ";
for(int j = 1; j < u; j++){
int ara = qu(g[i][j]) - qu(g[i][j - 1]);
dp[j] = (dp[j - 1] - 1 + of[j - 1]*ara%mod + 1)%mod;
of[j] = (of[j - 1] + dp[j])%mod;
// cout << "(" << ara << ") " << g[i][j] << " - " << dp[j] << " ";
}
ans = (ans + of[u - 1])%mod;
// cout << " = " << of[u - 1] << endl;
}
printf("%lld\n", ans);
return 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>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
typedef long long ll;
typedef pair<int, int> pii;
#define mp make_pair
const ll MOD = 998244353;
ll add(ll x, ll y) {
x += y;
if (x >= MOD) return x - MOD;
return x;
}
ll sub(ll x, ll y) {
x -= y;
if (x < 0) return x + MOD;
return x;
}
ll mult(ll x, ll y) {
return (x * y) % MOD;
}
ll bin_pow(ll x, ll p) {
if (p == 0) return 1;
if (p & 1) return mult(x, bin_pow(x, p - 1));
return bin_pow(mult(x, x), p / 2);
}
ll Rev(ll x) {
return bin_pow(x, MOD - 2);
}
ll W;
const int LOG = 20;
const int N = 1 << 20;
ll w[N];
int rev[N];
void initFFT() {
for (ll x = 2;; x++) {
ll y = x;
for (int i = 1; i < LOG; i++)
y = mult(y, y);
if (y == MOD - 1) {
W = x;
break;
}
}
w[0] = 1;
for (int i = 1; i < N; i++)
w[i] = mult(w[i - 1], W);
rev[0] = 0;
for (int mask = 1; mask < N; mask++) {
int k = 0;
while(((mask >> k) & 1) == 0) k++;
rev[mask] = rev[mask ^ (1 << k)] ^ (1 << (LOG - 1 - k));
}
}
ll F[2][N];
void FFT(ll *A) {
for (int i = 0; i < N; i++)
F[0][rev[i]] = A[i];
int t = 0, nt = 1;
for (int lvl = 0; lvl < LOG; lvl++) {
int len = 1 << lvl;
for (int st = 0; st < N; st += (len << 1))
for (int i = 0; i < len; i++) {
ll ad = mult(F[t][st + len + i], w[i << (LOG - 1 - lvl)]);
F[nt][st + i] = add(F[t][st + i], ad);
F[nt][st + len + i] = sub(F[t][st + i], ad);
}
swap(t, nt);
}
for (int i = 0; i < N; i++)
A[i] = F[t][i];
}
ll f[N], rf[N];
ll a[N];
ll getC(int n, int k) {
if (k < 0 || k > n) return 0;
return mult(f[n], mult(rf[k], rf[n - k]));
}
int main()
{
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
initFFT();
f[0] = 1;
for (int i = 1; i < N; i++)
f[i] = mult(f[i - 1], i);
rf[N - 1] = Rev(f[N - 1]);
for (int i = N - 1; i > 0; i--)
rf[i - 1] = mult(rf[i], i);
for (int k = 0; k < N / 2; k++) {
a[k] = mult(f[2 * k], mult(rf[k], rf[k]));
}
FFT(a);
for (int i = 0; i < N; i++)
a[i] = mult(a[i], a[i]);
FFT(a);
reverse(a + 1, a + N);
ll rN = Rev(N);
for (int i = 0; i < N; i++) {
a[i] = mult(a[i], rN);
a[i] = mult(a[i], mult(rf[2 * i], mult(f[i], f[i])));
a[i] = sub(a[i], 1);
a[i] = mult(a[i], (MOD + 1) / 2);
a[i] += i;
}
int n, m;
scanf("%d%d", &n, &m);
if (n < m) swap(n, m);
if (n == m) {
printf("%lld\n", a[n]);
return 0;
}
ll ans = 0;
for (int k = 0; k <= m; k++) {
int L = n - m + k - 1;
ll p = getC(L + k, k);
if (k > 0)
p = sub(p, getC(L + k, k - 1));
p = mult(p, getC(2 * (m - k), m - k));
ans = add(ans, mult(p, add(L + 1, a[m - k])));
}
ans = mult(ans, mult(rf[n + m], mult(f[n], f[m])));
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
char conv[256];
int conv2[256];
for (int i = 0; i < 26; i++){
conv[i] = 'a' + i;
conv[i + 26] = 'A' + i;
conv2['a' + i] = i;
conv2['A' + i] = i + 26;
}
while (scanf("%d", &n) && n){
int a[128];
char s[128];
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
scanf("%s", s);
for (int i = 0; s[i]; i++){
printf("%c", conv[(conv2[s[i]] - a[i % n] + 52) % 52]);
}
printf("\n");
}
return (0);
} | #include <iostream>
#include <vector>
#include <map>
using namespace std;
int main(){
int n;
while(cin>>n,n){
vector<int> a;
for(int i=0,t;i<n;++i){
cin>>t;
a.push_back(t);
}
string s,ans;
cin>>s;
string alpha;
map<char, int> alphaM;
int id = 0;
for(char c = 'a'; c <= 'z'; c++) {
alpha.push_back(c);
alphaM[c] = id++;
}
for(char c = 'A'; c <= 'Z'; c++) {
alpha.push_back(c);
alphaM[c] = id++;
}
for(int i=0;i<s.size();++i){
int x=a[i%a.size()];
int id2 = alphaM[s[i]];
ans += alpha[(id2-x+52)%52];
}
cout<<ans<<endl;
}
} | 1 |
#include <iostream>
//#include <vector>
//#include <string>
//#include <algorithm>
//#include <math.h>
//#include <queue>
//#include <stack>
//#include <iomanip>
// sometimes used
//#include <set>
//#include <map>
//#include <numeric>
//#include <list>
//#include <deque>
//#include <unordered_map>
typedef long long LL;
//typedef long double LD;
using namespace std;
//#define MOD 1000000007
//#define MAX 100100
//#define NIL -1
//#define INFTY 1000000000000000000
int main(){
LL a;
LL b;
LL c;
LL d;
cin >> a >> b >> c >> d;
if(a+b>c+d){
cout << "Left" << endl;
}else if(a+b==c+d){
cout << "Balanced" << endl;
}else{
cout << "Right" << endl;
}
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using ld = long double;
const ld pi = 3.141592653589793;
int w[4];
int main() {
for (int i = 0; i < 4; i++) {
cin >> w[i];
}
if (w[0] + w[1] > w[2] + w[3]) {
cout << "Left" << endl;
return 0;
}
if (w[0] + w[1] == w[2] + w[3]) {
cout << "Balanced" << endl;
return 0;
}
if (w[0] + w[1] < w[2] + w[3]) {
cout << "Right" << endl;
return 0;
}
} | 1 |
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
struct Dice {
int d[6], E, S, U;
void init(int a[]) {
rep(i, 6)d[i] = a[i];
E = 2; S = 1; U = 0;
}
void rotate(char C) {
int a = E, b = S, c = U;
switch (C) {
case'E':E = U; U = 5 - a; break;
case'N':U = S; S = 5 - c; break;
case'S':S = U; U = 5 - b; break;
case'W':U = E; E = 5 - c; break;
case'R':S = E; E = 5 - b; break;
case'L':E = S; S = 5 - a; break;
}
}
int rotate(int a, int b) {
rep(k, 2) {
rep(i, 4) {
rep(j, 4) {
if (a == d[U] && b == d[S])return d[E];
rotate('E');
}
rotate('S');
}
rotate('L');
}
}
bool operator==(Dice b) {
rep(k, 2) {
rep(i, 4) {
rep(j, 4) {
if (b.d[b.U] == d[U] && b.d[b.S] == d[S] && b.d[b.E] == d[E] &&
b.d[5 - b.U] == d[5 - U] && b.d[5 - b.S] == d[5 - S] && b.d[5 - b.E] == d[5 - E])
return true;
rotate('E');
}
rotate('S');
}
rotate('L');
}
return false;
}
};
Dice d[100]; int a[100][6];
int main() {
int n; cin >> n;
rep(i, n) {
rep(j, 6)cin >> a[i][j];
d[i].init(a[i]);
}
rep(i, n)for (int j = i + 1; j < n; j++) {
if (d[i] == d[j]) {
puts("No"); return 0;
}
}
puts("Yes");
} | #include <iostream>
using namespace std;
static const int MAX = 101;
static const int INFTY = (1<<21);
static const int WHITE = 0;
static const int GRAY = 1;
static const int BLACK = 2;
int n, M[MAX][MAX];
int prim()
{
int u, mincost;
int d[MAX], p[MAX], color[MAX];
for(int i=0; i<MAX; i++)
{
color[i] = WHITE;
d[i] = INFTY;
p[i] = -1;
}
d[0] = 0;
while(1)
{
mincost = INFTY;
for(int i=0; i<n; i++)
{
if(color[i] != BLACK && d[i] < mincost)
{
mincost = d[i];
u = i;
}
}
if(mincost == INFTY)
break;
color[u] = BLACK;
for(int v=0; v<n; v++)
{
if(color[v] != BLACK && M[u][v] != -1)
{
if(M[u][v] < d[v])
{
d[v] = M[u][v];
p[v] = u;
color[v] = GRAY;
}
}
}
}
int sum = 0;
for(int i=0; i<n; i++)
{
if(p[i] != -1)
sum += M[i][p[i]];
}
return sum;
}
int main()
{
cin >> n;
int e;
for(int i=0; i<n; i++)
{
for(int j=0; j<n; j++)
{
cin >> e;
if(e == -1)
M[i][j] = INFTY;
else
M[i][j] = e;
}
}
cout << prim() << endl;
return 0;
} | 0 |
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define FASTIO ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define endl '\n'
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
using ll = long long;
using P = pair<ll, ll>;
/*追加部分*/
/*main関数*/
int main() {
FASTIO;
int a, b, c, d; cin >> a >> b >> c >> d;
cout << ((a + b) > (c + d) ? "Left" : (a + b) == (c + d) ? "Balanced" : "Right") << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int a,b,c; cin >> a >> b >> c;
string ans = "Yes";
if((a-c)*(b-c)>0) ans ="No";
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
#define PI 3.14159265359
#define NIL (-1)
#define LL long long
using namespace std;
const int64_t MOD = 1e9 + 7;
int main() {
int N;
cin >> N;
int ans = INT_MAX;
for (int i = 0; i < N; i++) {
int n;
cin >> n;
int cnt = 0;
while (n%2==0) {
if (n / 2) {
cnt++;
n /= 2;
}
else {
break;
}
}
ans = min(ans, cnt);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <string>
#include <deque>
using namespace std;
int main() {
//input
int n; cin >> n;
long long sum = 0;
int counter = 0;
vector<long> a(n + 1);
for(int i = 1; i < n + 1; i++) cin >> a[i];
for(int i = 1; i < n + 1; i++){
if(a[i] < 0){
counter += 1;
}
a[i] = abs(a[i]);
}
sort(a.begin() + 1, a.end());
for(int i = 1; i < n + 1; i++) sum += a[i];
if(counter % 2 == 0 ){
cout << sum << endl;
}else{
cout << sum - 2 * a[1] << endl;
}
//output
} | 0 |
#include <cstdio>
#include <vector>
using namespace std;
typedef long long i64;
int main()
{
int n;
vector<i64> as;
scanf("%d", &n);
as.resize(n);
for(int i = 0; i < n; i++) {
scanf("%lld", &as[i]);
}
i64 sum = 0;
for(auto& a : as) {
sum = sum ^ a;
}
for(auto& a : as) {
a = a & (~sum);
}
i64 maxi = 0;
for(int b = 62; b >= 0; b--) {
i64 v = -1;
for(int i = 0; i < n; i++) {
if((as[i] & (1LL << b)) != 0) {
v = as[i];
break;
}
}
if(v == -1) {
continue;
}
for(int i = 0; i < n; i++) {
if((as[i] & (1LL << b)) != 0) {
as[i] = as[i] ^ v;
}
}
maxi = max(maxi ^ v, maxi);
}
i64 ans = maxi * 2 + sum;
printf("%lld\n", ans);
return 0;
}
| #include <algorithm>
#include <climits>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define int long long int
constexpr int INF = std::numeric_limits<int>::max();
constexpr int NINF = std::numeric_limits<int>::min();
using namespace std;
int g[10][10];
int f[10][10];
void solve() {
int M;
cin >> M;
int ans = -1;
int sum = 0;
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
int a = i+j;
g[i][j] = a/10+a%10;
f[i][j] = a >= 10 ? 2 : 1;
}
}
int amari = 0;
while (M--) {
int c, d; cin >> d >> c;
while (c > 1) {
if (c%2 == 1) {
c--;
ans += f[amari][d];
amari = g[amari][d];
}
c /= 2;
ans += c * f[d][d];
d = g[d][d];
}
ans += f[amari][d];
amari = g[amari][d];
}
cout << ans << endl;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4005;
const long long mod = 998244353;
long long C[N][N];
long long pow2[N];
void init(){
C[0][0] = C[1][0] = C[1][1] = 1;
for (int i = 2; i <= 4000; i++){
C[i][0] = 1;
for (int j = 1; j < i; j++) C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
C[i][i] = 1;
}
pow2[0] = 1;
for (int i = 1; i <= 4000; i++) pow2[i] = pow2[i - 1] * 2 % mod;
}
int main(){
init();
int n, k, num1, num2, num3;
long long ans;
scanf("%d %d",&k,&n);
for (int i = 2; i <= k * 2; i++){
ans = 0;
num1 = (min(i - 1, k) - max(i - k, 1) + 1) / 2;
num2 = 1 - i & 1;
num3 = k - num1 * 2 - num2;
for (int p = 0; p <= num2; p++){
for (int j = 0; j <= num1; j++){
ans += C[num1][j] * pow2[j] % mod * C[n - 1 - p + num3][j + num3 - 1] % mod;
ans %= mod;
}
}
printf("%I64d\n", ans);
}
return 0;
} | #include <bits/stdc++.h>
typedef long long ll;
const int N=5005,P=998244353;
int n,k,C[N][N];
inline int Cs(int n,int m){return n<0||m<0||n<m?0:C[n][m];}
int main()
{
scanf("%d%d",&k,&n);
for(int i=C[0][0]=1;i<=5001;++i)
for(int j=C[i][0]=1;j<=i;++j)
if((C[i][j]=C[i-1][j]+C[i-1][j-1])>=P)
C[i][j]-=P;
for(int i=2,j,u,v,s;i<=k<<1;printf("%d\n",s),++i)
for(u=std::min(k,i>>1),v=std::max(1,i-k),s=j=0;j<=u-v+1;++j)
s=(s+(ll)Cs(u-v+1,j)*Cs(n+k-j-j-1,n-j-j)%P*(j&1?P-1:1))%P;
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int n,m,i,j,cnt,xlh,ans,op,a[302][302],b[302],v[302];
int main(){
scanf("%d%d",&n,&m);
for(i=1;i<=m;i++)v[i]=1;
ans=n;
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)scanf("%d",&a[i][j]);
for(cnt=1;cnt<m;cnt++){
for(i=1;i<=m;i++)b[i]=0;
for(i=1;i<=n;i++)
for(j=1;j<=m;j++)if(v[a[i][j]]){
b[a[i][j]]++;break;
}
xlh=0;
for(i=1;i<=m;i++){
if(b[i]>xlh)op=i;
xlh=max(xlh,b[i]);
}
ans=min(ans,xlh);
v[op]=0;
}
printf("%d",ans);
} | #include<cstdio>
#include<iostream>
#include<map>
#include<set>
#include<vector>
#include<cstring>
#include<cassert>
#include<sstream>
#include<cmath>
#include<algorithm>
#include<queue>
#include<limits>
#include<ctime>
#include<stack>
#include<bits/stdc++.h>
#include<string>
#include<stdlib.h>
#include<stdio.h>
typedef long long ll;
using namespace std;
const ll x=1000000007;
int mod(ll a){
return a%x;
}
int main(){
map<string,int> a;
int n,m,maks=0;
cin>>n;
string s;
for(int i=0;i<n;i++){
cin>>s;
a[s]++;
cout<<endl;
}
cin>>m;
for(int i=0;i<m;i++){
cin>>s;
a[s]--;
cout<<endl;
}
for(map<string,int>:: iterator i=a.begin();i!=a.end();i++){
maks=max(maks,i->second);
}
cout<<maks;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string sa,sb,sc;
cin >> sa >> sb >> sc;
queue<char> qa,qb,qc;
for(int i = 0; i < sa.size(); i++) qa.push(sa[i]);
for(int i = 0; i < sb.size(); i++) qb.push(sb[i]);
for(int i = 0; i < sc.size(); i++) qc.push(sc[i]);
qa.push('w'),qb.push('w'),qc.push('w');
char x=qa.front();
qa.pop();
while(!qa.empty() && !qb.empty() && !qc.empty()){
if(x=='a'){
x=qa.front();
qa.pop();
}
if(x=='b'){
x=qb.front();
qb.pop();
}
if(x=='c'){
x=qc.front();
qc.pop();
}
}
if(qa.empty()) cout << 'A' << endl;
else if(qb.empty()) cout << 'B' << endl;
else cout << 'C' << 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<string>
#include<unordered_map>
#include <iomanip>
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,k
#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 sort(a) sort(a.begin(),a.end())
#define push(a,b) (a).push_back(b)
#define llvec vector<vector<ll>>
#define charvec vector<vector<char>>
#define sizeoof(a,b) (a,vector<ll>(b))
#define llpvec vector<pair<ll,ll>>
/*繰り上げ除算*/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;}
ll ans=0;llfor;///////////////////////////////////////////////////////////
int digit(int n){
if(n < 10) return n;
return digit(n/10) + n%10;
}
int main(){
int A,B,C,K;
cin>>A>>B>>C>>K;
cout<<max({A,B,C})*pow(2,K)+A+B+C-max({A,B,C});
return 0;}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
ll factorial(int i) { //階乗
if (i == 0) return 1;
return (factorial(i - 1)) * i;
}
int main() {
int n, q;
cin >> n >> q;
string s;
cin >> s;
vector<int> ac(n);
vector<int> sum(n + 1, 0);
rep(i, n) {
if(i != n) {
if(s[i] == 'A' && s[i + 1] == 'C') {
ac[i]++;
i++;
}
}
}
rep(i, n) {
sum[i + 1] += sum[i] + ac[i];
}
/*cout << endl;
rep(i, n) cout << ac[i] << ' ';
cout << endl;
rep(i, n + 1) cout << sum[i] << ' ';
cout << endl;
//確認済*/
vector<vector<int>> l(q, vector<int>(2));
rep(i, q) {
rep(j, 2) cin >> l[i][j];
}
rep(i, q) {
cout << sum[l[i][1] - 1] - sum[l[i][0] - 1] << endl;
}
} | /**
* author: yuya1234
* created: 17.07.2020 14:32:58
**/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
long double eps = 1.0E-14;
#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--)
#define FORV(i,v) for(auto i=v.begin(); i!=v.end();i++)
#define SORT(s) sort((s).begin(),(s).end())
#define SORTD(s) sort((s).rbegin(),(s).rend())
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );
#define SZ(x) ((int)(x).size())
#define MEMSET(v, h) memset((v), h, sizeof(v))
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template<class T>T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<class T>T lcm(T a,T b){return gcd(a,b)*(a/gcd(a,b))*(b/gcd(a,b));}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
//std::cout << std::fixed << std::setprecision(15);
int n,q;
cin>>n>>q;
string s;
cin>>s;
int l[q],r[q];
REP(i,q)cin>>l[i]>>r[i];
int ss[SZ(s)];
MEMSET(ss,0);
int sum=0;
FOR(i,1,SZ(s)-1)
{
if(s[i-1]=='A' && s[i]=='C')sum++;
ss[i]=sum;
}
//REP(i,SZ(s))cout<<ss[i]<<endl;
REP(i,q)
{
cout<<ss[r[i]-1]-ss[l[i]-1]<<endl;
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define ii pair <int, int>
#define app push_back
#define all(a) a.begin(), a.end()
#define bp __builtin_popcountll
#define ll long long
#define mp make_pair
#define f first
#define s second
#define Time (double)clock()/CLOCKS_PER_SEC
#define debug(x) std::cout << #x << ": " << x << '\n';
const int N = 1e5+7;
int a[3][N];
int col[N * 3];
struct Fen {
int f[N];
void clear() {
for (int i = 0; i < N; ++i) f[i] = 0;
}
void add(int i, int x) {
for (; i < N; i |= i + 1)
f[i] += x;
}
int get(int i) {
int ans = 0;
for (; i >= 0; i &= i + 1, --i) ans += f[i];
return ans;
}
int get(int l, int r) {
//check r < l!
return get(r) - get(l - 1);
}
} f;
signed main() {
#ifdef HOME
freopen("input.txt", "r", stdin);
#else
#define endl '\n'
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
cout.setf(ios::fixed); cout.precision(20);
#endif
auto get = [&] (vector <int> a) {
reverse(all(a));
f.clear();
int ans = 0;
for (auto e : a) {
ans += f.get(e);
f.add(e, 1);
}
return ans & 1;
};
int n;
cin >> n;
for (int i = 0; i < 3; ++i)
for (int j = 0; j < n; ++j) {
cin >> a[i][j];
col[a[i][j]] = j;
}
int x = 1;
vector <int> inv(2);
vector <int> p[2];
for (int i = 0; i < n; ++i) {
int c = col[x];
vector <int> t;
for (int j = 0; j < 3; ++j)
t.app(a[j][c]);
auto t1 = t;
sort(all(t1));
vector <int> w = {x, x + 1, x + 2};
if (t1 != w) {
cout << "No" << endl;
exit(0);
}
if (t[1] != x + 1) {
cout << "No" << endl;
exit(0);
}
p[i&1].app(c);
int was = (x - 1) / 3;
if ((was & 1) != (c & 1)) {
cout << "No" << endl;
exit(0);
}
inv[i&1] ^= t[0] != x;
x += 3;
}
int p_inv = get(p[0]) + get(p[1]);
vector <int> ar(n), did(n);
for (int i = 0; i < n; ++i) {
ar.app(a[0][i] > a[2][i]);
}
for (int i = 0; i + 2 < n; ++i) {
did[i] = ar[i];
for (int j = 1; j <= 2 && j <= i; ++j) {
did[i] ^= did[i - j];
}
}
for (int i = n - 2; i < n; ++i) {
int have = 0;
for (int j = 1; j <= 2 && j <= i; ++j) {
have ^= did[i - j];
}
if (have != ar[i]) {
cout << "No" << endl;
exit(0);
}
}
if (get(p[0]) == inv[1] && get(p[1]) == inv[0]) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
}
| #include<bits/stdc++.h>
using namespace std;
int n,k;
int a[233],odd[3],top;
int main()
{
ios_base::sync_with_stdio(false);
cin>>n>>k;
for(int i=1;i<=k;i++)
{
cin>>a[i];
if(a[i]%2)
{
odd[++top]=i;
}
}
if(top>2)return puts("Impossible"),0;
else if(top==2)
{
swap(a[1],a[odd[1]]);
swap(a[k],a[odd[2]]);
}
else if(top==1)
{
swap(a[1],a[odd[1]]);
}
for(int i=1;i<=k;i++)cout<<a[i]<<' ';cout<<endl;
cout<<k-(a[1]==1)+(k==1)<<endl;
if(a[1]!=1)cout<<a[1]-1<<' ';
for(int i=2;i<k;i++)cout<<a[i]<<' ';
if(k!=1)cout<<a[k]+1<<endl;
else cout<<1<<endl;
return 0;
} | 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> ;
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){
vector<vector<int>> v(n+1,vector<int>(n+1,0));
rep(i,n){
rep(j,n){
cin >> v[j][i];
}
}
rep(i,n){
int sum = 0;
rep(j,n){
scout(5)<< v[j][i] ;
sum += v[j][i];
}
v[n][i] = sum;
scout(5)<< sum << endl;
}
rep(i,n+1){
int sum = 0;
rep(j,n){
sum += v[i][j];
}
scout(5)<< sum ;
}
cout << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define loop(v, f, l) for(int v = (f), v##_ = (l); v < v##_; ++v)
using namespace std;
typedef long long int lint;
static inline int in(){ int x; scanf("%d", &x); return (x); }
static inline lint inl(){ lint x; scanf("%lld", &x); return (x); }
int matrix[11][11];
int main()
{
int n;
while( (n = in()) != 0 )
{
loop(i, 0, 11)
{
loop(j, 0, 11)
{
matrix[i][j] = 0;
}
}
loop(i, 0, n)
{
loop(j, 0, n)
{
matrix[i][j] = in();
}
}
loop(i, 0, n)
{
loop(j, 0, n)
{
matrix[i][n] += matrix[i][j];
matrix[n][i] += matrix[j][i];
}
matrix[n][n] += matrix[i][n];
}
loop(i, 0, n + 1)
{
loop(j, 0, n + 1)
{
printf("%5d", matrix[i][j]);
}
printf("\n");
}
}
return (0);
} | 1 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
#define FOR(i,a,b) for(ll i=(a);i<(b);++i)
#define ALL(v) (v).begin(), (v).end()
#define p(s) cout<<(s)<<endl
#define p2(s, t) cout << (s) << " " << (t) << endl
#define br() p("")
#define pn(s) cout << (#s) << " " << (s) << endl
int sign_x[4] = {1, -1, +1, -1};
int sign_y[4] = {1, -1, -1, +1};
ll board[8][8];
ll queen[8]; // i行目のどこに置いたか
bool in_range(ll x, ll y){
if(0<=x && x<8 && 0<=y && y<8){
return true;
}else{
return false;
}
}
// 盤面に置く or 取り除く
// 置く場合 add = 1
// 除く場合 add = -1
void put(ll x, ll y, ll add){
// cout << "put " << x << " " << y << endl;
if(add>0){
queen[y] = x;
}else{
queen[y] = -1;
}
// row
FOR(i, 0, 8){
board[y][i] += add;
}
// column
FOR(i, 0, 8){
board[i][x] += add;
}
// 足しすぎを引く
board[y][x] -= add;
// diagonal
FOR(i, 1, 8){ // 幅
FOR(j, 0, 4){
ll nx = x + i * sign_x[j];
ll ny = y + i * sign_y[j];
if(in_range(nx, ny)){
board[ny][nx] += add;
}
}
}
}
// 解答用：クイーンの位置をQで表示する
void printQueen(){
FOR(y, 0, 8){
FOR(x, 0, 8){
if(queen[y]==x){
cout << 'Q';
}else{
cout << '.';
}
}
cout << endl;
}
}
// ボードの状態を数字で表示する
void debugBoard(){
FOR(y, 0, 8){
FOR(x, 0, 8){
cout << setw(2) << board[y][x] << ' ';
}
cout << endl;
}
}
void setQueen(ll y){
// pn(y);
if(y==8){
printQueen();
exit(0);
}
// すでに置かれている
if(queen[y]!=-1){
setQueen(y+1);
}
// どこに置こうかな
FOR(x, 0, 8){
// 置いてみる
if(board[y][x]==0){
put(x, y, 1);
setQueen(y+1);
// キャンセル
put(x, y, -1);
}
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
// input
ll N;
cin >> N;
FOR(i, 0, 8){
queen[i] = -1;
}
while(N--){
ll y, x;
cin >> y >> x;
put(x, y, 1);
}
setQueen(0);
return 0;
}
| #include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int N; cin >> N;
int x, y;
vector<int> y_x(8, -1);
for (int i = 0; i < N; i++)
{
cin >> y >> x;
y_x[y] = x;
}
vector<int> perm(8);
for (int i = 0; i < 8; i++) { perm[i] = i; }
bool ok = true;
do
{
ok = true;
for (int y = 0; y < 8; y++)
{
if (y_x[y] != -1 && perm[y] != y_x[y])
{
ok = false;
}
}
if (ok == true)
{
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if (i != j)
{
if (i - perm[i] == j - perm[j] || i + perm[i] == j + perm[j])
{
ok = false;
}
}
}
}
}
if (ok == true)
{
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if (perm[i] == j)
{
cout << 'Q';
}
else
{
cout << '.';
}
}
cout << endl;
}
}
} while (next_permutation(perm.begin(), perm.end()));
return 0;
} | 1 |
#include <iostream>
#include <cmath>
#include <vector>
#include <climits>
using namespace std;
int main()
{
int n;
cin >> n;
vector<int> v;
for(int i = 0;i < n;i++)
{
int t;
cin >> t;
v.push_back(t);
}
bool f = true;
int c = 0;
while(f)
{
f = false;
for(int i = 1;i < v.size();i++)
{
if(v.at(i) < v.at(i - 1))
{
int t = v.at(i - 1);
v.at(i -1) = v.at(i);
v.at(i) = t;
f = true;
c++;
}
}
}
for(int i = 0;i < v.size();i++)
{
cout << v.at(i);
if(i + 1 != v.size())
{
cout << " ";
}
else
{
cout << endl;
}
}
cout << c << endl;
} | #include <algorithm>
#include <cstdio>
#include <string>
#define MAXN 1000001
#define a first
#define b second
char buf[MAXN];
std::pair<int, int> s[MAXN];
int main() {
using namespace std;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", buf);
s[i].a = s[i].b = 0;
for (int j = 0; buf[j]; ++j) {
if (buf[j] == '(')
++s[i].a;
else {
if (s[i].a)
--s[i].a;
else
++s[i].b;
}
}
}
auto cmp = [](const pair<int, int> &l, const pair<int, int> &r) {
if (l.a <= l.b && r.a > r.b)
return true;
else if (l.a > l.b && r.a <= r.b)
return false;
else if (l.a > l.b && r.a > r.b)
return l.b > r.b;
else
return l.a < r.a;
};
std::sort(s, s + n, cmp);
int t = 0;
for (int i = 0; i < n; i++) {
if (t < s[i].a) {
printf("No\n");
return 0;
}
t += s[i].b - s[i].a;
}
if (t)
printf("No\n");
else
printf("Yes\n");
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
long long a,b,i,A,B;int x;
map<int,int>m;
int main()
{
cin>>A>>B;
a=A;b=B;
for(i=2;i*i<=A;i++)
{while(a%i==0){a/=i;m[i]=1;}}
if(a!=1)m[a]=1;
for(i=2;i*i<=B;i++)
{while(b%i==0){b/=i;if(m[i]==1){x++;m[i]=2;}}}
if(b!=1){if(m[b]==1)x++;}
cout<<x+1;
}
| #include <bits/stdc++.h>
using namespace std;
template <typename T> bool chmax(T &u, const T z) { if (u < z) {u = z; return true;} else return false; }
template <typename T> bool chmin(T &u, const T z) { if (u > z) {u = z; return true;} else return false; }
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
//typedef pair<ll, ll> P;
const ll INF=1LL<<60;
ll gcd(ll x,ll y){return y? gcd(y,x%y) :x;}
//写し
vector<pair<ll,int>>factorize(ll n){
vector<pair<ll,int>>res;
for(ll i=2;i*i<=n;++i){
if(n%i)continue;
res.emplace_back(i,0);
while(n%i==0){
n/=i;
res.back().second++;
}
}
if(n!=1)res.emplace_back(n,1);
return res;
}
int main(){
ll a,b;
cin>>a>>b;
ll g=gcd(a,b);
auto f=factorize(g);
int ans=f.size()+1;
cout<<ans<<endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
//#include <atcoder/all>
#define ll long long int
#define MOD 1000000007
#define P pair<ll,ll>
#define INF 1000000000000000000
//using namespace atcoder;
using namespace std;
int main(void){
ll n;
cin >> n;
vector<ll> a(5);
for (int i = 0; i < 5; i++){
cin >> a[i];
}
sort(a.begin(), a.end());
cout << (n + a[0] - 1)/a[0] + 4 << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main(){
int n;
cin >> n;
map<int,int> m;
rep(i,n){
int a;
cin >> a;
m[a]++;
}
for(auto p : m){
if(p.second > 1){
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(){
int n;
while(cin>>n,n){
unsigned long long a[5000]={0},c=0,p,o,u;
rep(i,n){
cin>>p>>o>>u;
a[p]+=o*u;
if(a[p]>=1000000){cout<<p<<endl;c++;}
}
if(!c)cout<<"NA"<<endl;
}
} | #include <iostream>
using namespace std;
int order[4000];
bool search(int);
class Member {
public:
Member() {sum = 0;}
void add(long price, long num) {
sum += (long long int)price*num;
}
bool milion()
{
if (sum >= 1000000) return true;
else return false;
}
private:
long long int sum;
int id;
};
bool search(int num)
{
for (int i=0; i<4000; i++)
if (order[i] == num ) return true;
return false;
}
int main()
{
int n, idx, memNum;
long price, num;
bool nothing;
ios::sync_with_stdio();
while (1) {
Member *member = new Member[4000];
memNum=0;
nothing =true;
for (int i=0; i<4000; i++) order[i] = -1;
if (cin >> n, !n) break;
for (int i=0; i<n; i++) {
scanf("%d %ld %ld", &idx, &price, &num);
member[idx].add(price, num);
if (!search(idx)) order[memNum++] = idx;
}
for (int i=0; i<4000 && order[i] > 0; i++)
if (member[order[i]].milion()) { cout << order[i] << endl; nothing = false; }
if (nothing) cout << "NA" << endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
long long sum(long long n)
{return n*(n+1)/2;}
int main(){
int n;
cin>>n;
long long ans;
ans=sum(n)-sum(n/3)*3-sum(n/5)*5+sum(n/15)*15;
cout<<ans;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long int
#define yorn(f) cout << ((f) ? "Yes" : "No") << endl;
#define YORN(f) cout << ((f) ? "YES" : "NO") << endl;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define put(x) cout << x << endl;
using namespace std;
int main()
{
ll n;
cin >> n;
ll sum = 0;
rep(j, n)
{
ll i = j + 1;
if (i % 15 == 0)
{
}
else if (i % 3 == 0)
{
}
else if (i % 5 == 0)
{
}
else
{
sum += i;
}
}
put(sum)
return 0;
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.