code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include "bits/stdc++.h"
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ub upper_bound
#define lb lower_bound
#define isrt insert
#define clr clear
#define rsz resize
#define ff first
#define ss second
#define lli long long int
#define pb push_back
#define pf push_front
#define mkp make_pair
#define pii pair<int,int>
#define vi vector<int>
#define mii map<lli,lli>
#define pqb priority_queue<int>
#define pqs priority_queue<int,vi,greater<int> >
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define INF 1e9
#define ps(x,y) fixed<<setprecision(y)<<x
#define mk(arr,n,type) type *arr=new type[n];
#define w(x) int x; cin>>x; while(x--)
#define all(v) v.begin(),v.end()
#define endl "\n"
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
lli maxm(lli a, lli b)
{
return (a >= b ? a : b);
}
lli minm(lli a, lli b)
{
return (a <= b ? a : b);
}
lli power(lli x, lli y, lli p)
{
lli res = 1;
x = x % p;
if (x == 0)
return 0;
while (y > 0)
{
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
lli nCrmodp(lli n, lli r, lli p)
{
if (r == 0)
return 1;
if (r == 1)
return n;
lli pro = 1, k = n;
while (k > r)
{
pro *= k;
pro %= p;
--k;
}
k = 2;
while (k <= (n - r))
{
pro *= power(k, (p - 2), p);
pro %= p;
++k;
}
return pro;
}
string num_str(lli n, lli k)
{
string str = "";
lli x = n;
while (x != 0)
{
string s = to_string(x % k);
str = s + str;
x /= k;
}
return str;
}
lli first_big(lli n, lli k, lli arr[])
{
lli l = 0;
lli r = n - 1;
lli leftGreater = n;
while (l <= r) {
lli m = l + (r - l) / 2;
if (arr[m] > k) {
leftGreater = m;
r = m - 1;
}
else
l = m + 1;
}
return leftGreater;
}
void c_p_c()
{
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
}
double dp[302][302][302], n;
double neg = -1.00000000, zer = 0.00000000;
double exp_val(int one, int two, int three)
{
if (one < 0 || two < 0 || three < 0)
return 0;
if (dp[one][two][three] == neg)
{
if (one == 0 && two == 0 && three == 0)
dp[one][two][three] = zer;
else
{
double x = (n + one * exp_val(one - 1, two, three) + two * exp_val(one + 1, two - 1, three) + three * exp_val(one, two + 1, three - 1));
x /= (one + two + three);
dp[one][two][three] = x;
}
}
return dp[one][two][three];
}
int main()
{
c_p_c();
cin >> n;
for (int i = 0; i < 302; ++i)
for (int j = 0; j < 302; ++j)
for (int k = 0; k < 302; ++k)
dp[i][j][k] = neg;
int x, one = 0, two = 0, three = 0;
for (int i = 0; i < n; ++i)
{
cin >> x;
if (x == 1)
++one;
if (x == 2)
++two;
if (x == 3)
++three;
}
cout << ps(exp_val(one, two, three), 16) << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int H,W;
short fid[110][110] = {0};
short dp[110][110][110][110] = {0};
int x,y;
short sum(int y1,int x1,int y2,int x2)
{
if(y1 > y2 || x1 > x2)return 0;
return fid[y1 - 1][x1 - 1] - fid[y1 - 1][x2] - fid[y2][x1 - 1] + fid[y2][x2];
}
int main()
{
scanf("%d%d",&H,&W);
for(int i = 1; i <= H; i++)for(int j = 1; j <= W; j++)
{
char c;
scanf(" %c",&c);
if(c == 'o')fid[i][j] = 1;
if(c == 'E')x = j,y = i;
}
for(int i = 1; i <= H; i++)for(int j = 1; j <= W; j++)fid[i][j] += fid[i - 1][j];
for(int i = 1; i <= H; i++)for(int j = 1; j <= W; j++)fid[i][j] += fid[i][j - 1];
for(int i = 0; i < y; i++)
{
for(int j = 0; j <= H - y; j++)
{
for(int k = 0; k < x; k++)
{
for(int l = 0; l <= W - x; l++)
{
if(i + j + k + l == 0)continue;
if(i)
{
dp[i][j][k][l] = max(dp[i][j][k][l],
(short)(dp[i - 1][j][k][l] + sum(max(y - i,j + 1),max(x - k,l + 1),y - i,min(x + l,W - k))));
}
if(j)
{
dp[i][j][k][l] = max(dp[i][j][k][l],
(short)(dp[i][j - 1][k][l] + sum(y + j,max(x - k,l + 1),min(y + j,H - i),min(x + l,W - k))));
}
if(k)
{
dp[i][j][k][l] = max(dp[i][j][k][l],
(short)(dp[i][j][k - 1][l] + sum(max(y - i,j + 1),max(x - k,l + 1),min(y + j,H - i),x - k)));
}
if(l)
{
dp[i][j][k][l] = max(dp[i][j][k][l],
(short)(dp[i][j][k][l - 1] + sum(max(y - i,j + 1),x + l,min(y + j,H - i),min(x + l,W - k))));
}
}
}
}
}
printf("%d\n",dp[y - 1][H - y][x - 1][W - x]);
return 0;
}
| 0 |
#include <stdio.h>
int main(void)
{
int n,a[4],t[100],p[100],i,j,k;
scanf("%d",&n);
for(i=0;i!=n;++i)
t[i]=0;
for(i=0;i!=n*(n-1)/2;i++){
for(j=0;j!=4;j++)
scanf("%d",&a[j]);
if(a[2]<a[3])
t[a[1]-1]+=3;
else if(a[2]>a[3])
t[a[0]-1]+=3;
else{
t[a[0]-1]+=1;
t[a[1]-1]+=1;
}
}
for(i=0;i!=n;++i)
p[i]=t[i];
for(i=0;i!=n;++i){
for(j=i;j!=n;j++){
if(p[i]<p[j]){
k=p[i];
p[i]=p[j];
p[j]=k;
}
}
}
for(i=0;i!=n;++i){
for(j=0;j!=n;++j){
if(t[i]==p[j]){
printf("%d\n",j+1);
break;
}
}
}
} | #include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
int n;
while(cin>>n){
if( n == 0 ) break;
int score[n];
for(int i = 0; i < n; ++i){
score[i] = 0;
}
for(int i = 0; i < n*(n-1)/2; ++i){
int a,b,c,d;
cin >> a >> b >> c >> d;
--a;
--b;
score[a] += c>d?3:c==d?1:0;
score[b] += d>c?3:c==d?1:0;
}
vector<pair<int,int> > v;
for(int i = 0; i < n; ++i){
v.push_back( make_pair(score[i], i) );
}
sort(v.begin(), v.end());
int rank[n];
/*
for(int i = 0; i < n; ++i){
cout << score[i] << endl;
}
*/
for(int i = n-1; i >= 0; --i){
rank[ v[i].second ] = n-1-i+1;
if( i<n-1 && v[i].first == v[i+1].first){
rank[ v[i].second ] = rank[ v[i+1].second ];
}
}
for(int i = 0; i < n; ++i){
cout << rank[i] << endl;
}
}
return 0;
} | 1 |
#include<iostream>
#include<cstdio>
#include<string>
#include<algorithm>
#define INF 2001
#define MAX 101
using namespace std;
int MAT[MAX][MAX];
int N;
int prim(){
int sum;
bool complete[MAX];
int dist[MAX];
int parent[MAX];
for (int i = 0; i < N; i++) {
complete[i] = false;
dist[i] = INF;
parent[i] = -1;
}
dist[0] = 0;
while (1) {
int u = -1;
int min = INF;
for (int i = 0; i < N; i++) {
if (min > dist[i] && !complete[i]) {
u = i;
min = dist[i];
}
}
if (u == -1) break;
complete[u] = true;
for (int v = 0; v < N; v++) {
if (!complete[v] && MAT[u][v] != INF) {
if (dist[v] > MAT[u][v]) {
dist[v] = MAT[u][v];
parent[v] = u;
}
}
}
}
sum = 0;
for (int i = 1; i < N; i++) {
sum += MAT[parent[i]][i];
}
return sum;
}
int main(){
cin >> N;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
scanf("%d",&MAT[i][j]);
if (MAT[i][j] == -1) MAT[i][j] = INF;
}
}
cout << prim() << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, m, n) for (int i = (m); i < (int)(n); i++)
#define REPS(i, m, n) for (int i = (m); i <= (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define reps(i, n) for (int i = 0; i <= (int)(n); i++)
#define rrep(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define rreps(i, x) for (int i = (int)(x); i >= 0; i--)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define pb push_back
#define fi first
#define se second
typedef long long ll;
typedef pair<int, int> P;
const int inf = INT_MAX;
const ll INF = 1LL << 60;
const ll mod = 1e9 + 7;
const double EPS = 1e-10;
const double PI = acos(-1.0);
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
template<typename A, size_t N, typename T> void Fill(A (&array)[N], const T &val) { fill( (T*)array, (T*)(array+N), val ); }
template <class T1, class T2, class Pred = std::less<T2> >
struct sort_pair_second {
bool operator()(const std::pair<T1,T2>&left, const std::pair<T1,T2>&right) {
Pred p;
return p(left.second, right.second);
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N; cin >> N;
vector<ll> a(N);
rep(i, N) cin >> a[i];
ll s = 0;
rep(i, N) s ^= a[i];
ll ans = s;
rep(i, N) {
// s で１が立っていたビットを強制的にa[i]を0にビットを変換（考慮しない）
a[i] &= ~s;
}
int r = 0;
vector<int> top(N);
for (int i = 60; i >= 0; i--) {
int j = r;
for (; j < N; j++) {
if (a[j] >> i & 1) {
swap(a[r], a[j]);
break;
}
}
if (j == N) continue;
top[r] = i;
rep(k, N) {
if (r == k) continue;
if (a[k] >> i & 1) a[k] ^= a[r];
}
r++;
}
ll x = 0;
for (int i = 60; i >= 0; i--) {
ll nx = x | (1ll << i);
ll b = nx;
rep(j, r) {
if (b >> top[j] & 1) b ^= a[j];
}
if ((b & nx) == 0) {
x = nx;
}
}
ans += x * 2;
cout << ans << endl;
return 0;
} | 0 |
#pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
template<class t> inline t read(t &x){
x=0;char c=getchar();bool f=0;
while(!isdigit(c)) f|=c=='-',c=getchar();
while(isdigit(c)) x=(x<<1)+(x<<3)+(c^48),c=getchar();
if(f) x=-x;return x;
}
template<class t> inline void write(t x){
if(x<0){putchar('-'),write(-x);}
else{if(x>9)write(x/10);putchar('0'+x%10);}
}
const int N=2005;
int n,m,q,a[N][N],s[N][N],sx[N][N],sy[N][N];
void doit(){
int x,y,xx,yy;
read(x);read(y);read(xx);read(yy);
int n=s[xx][yy]-s[xx][y-1]-s[x-1][yy]+s[x-1][y-1];
int m=(sx[xx][yy-1]-sx[xx][y-1]-sx[x-1][yy-1]+sx[x-1][y-1])+(sy[xx-1][yy]-sy[x-1][yy]-sy[xx-1][y-1]+sy[x-1][y-1]);
write(n-m);puts("");
}
signed main(){
read(n);read(m);read(q);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++) scanf("%1d",&a[i][j]);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++){
s[i][j]=s[i-1][j]+s[i][j-1]-s[i-1][j-1]+a[i][j];
sx[i][j]=sx[i-1][j]+sx[i][j-1]-sx[i-1][j-1]+(a[i][j]+a[i][j+1]==2);
sy[i][j]=sy[i-1][j]+sy[i][j-1]-sy[i-1][j-1]+(a[i][j]+a[i+1][j]==2);
}
while(q--) doit();
} | #include <bits/stdc++.h>
// #include <atcoder/all>
using namespace std;
// using namespace atcoder;
// 型定義
typedef long long ll;
typedef pair<ll, ll> P;
// forループ
#define REP(i,n) for(ll i=0; i<(ll)(n); ++i)
// 定数宣言
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
// グラフ表現
using Graph = vector<vector<int>>;
// グラフの辺表現
using Edge = map<pair<int,int>,int>;
// n次元配列の初期化。第２引数の型のサイズごとに初期化していく。
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
std::fill( (T*)array, (T*)(array+N), val );
}
// 最大公約数
ll gcd(ll a,ll b){
if (a%b == 0) return(b);
else return(gcd(b, a%b));
}
// 最小公倍数
ll lcm(ll a, ll b){
return a/gcd(a, b) * b;
}
ll dp[85][85][14000];
int main()
{
cout << fixed << setprecision(15);
ll H, W;
cin >> H >> W;
vector<vector<ll>> A(H+1, vector<ll>(W+1, 0));
vector<vector<ll>> B(H+1, vector<ll>(W+1, 0));
for(ll i=1; i<=H; i++){
for(ll j=1; j<=W; j++){
cin >> A[i][j];
}
}
for(ll i=1; i<=H; i++){
for(ll j=1; j<=W; j++){
cin >> B[i][j];
}
}
Fill(dp, 0);
ll a = A[1][1];
ll b = B[1][1];
dp[1][1][abs(a-b)] = 1;
for(ll i=1; i<=H; i++){
for(ll j=1; j<=W; j++){
REP(k, 13000){
a = A[i][j];
b = B[i][j];
dp[i][j][abs(k+abs(a-b))] = max(dp[i][j][abs(k+abs(a-b))], dp[i-1][j][k]);
dp[i][j][abs(k-abs(a-b))] = max(dp[i][j][abs(k-abs(a-b))], dp[i-1][j][k]);
dp[i][j][abs(k+abs(a-b))] = max(dp[i][j][abs(k+abs(a-b))], dp[i][j-1][k]);
dp[i][j][abs(k-abs(a-b))] = max(dp[i][j][abs(k-abs(a-b))], dp[i][j-1][k]);
}
}
}
// REP(i, H+1){
// REP(j, W+1){
// cout << dp[i][j][0];
// }
// cout << endl;
// }
REP(k, 13000){
// cout << dp[H][W][k] << endl;
if(dp[H][W][k]){
cout << k << endl;
return 0;
}
}
return 0;
} | 0 |
#include <iostream> // cout, endl, cin
#include <string> // string, to_string, stoi
#include <cstring>
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath>
#include <numeric>
#include <float.h>
#include <math.h>
#include <sstream>
#include <iterator>
using namespace std;
using Graph = vector<vector<int>>;
// repマクロの定義
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
// allマクロの定義
#define all(v) v.begin(), v.end()
// 大きい順
#define rall(v) v.rbegin(), v.rend()
#define vi vector<int>
#define vl vector<ll>
const long long INF = 1LL << 60;
typedef long long ll;
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int ctoi(char c) {
switch (c) {
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
default: return 0;
}
}
bool is_prime(const unsigned n){
switch(n){
case 0: // fall-through
case 1: return false;
case 2: // fall-through
case 3: return true;
} // n > 3 が保証された
if(n % 2 == 0 || n % 3 == 0) return false;
// n は 2 と 3 のいずれの倍数でもないことが保証された
// これより n は (6の倍数)-1 か (6の倍数)+1 である
// 6の倍数前後の数を使って試し割りをする
for(unsigned i = 5; i * i <= n; i += 6) {
if(n % i == 0) return false; // (6の倍数)-1
if(n % (i+2) == 0) return false; // (6の倍数)+1
}
return true;
}
map<int,int> mp;
int primeFactorization(int a){ //素因数分解を出力するプログラム
int i,sq;
if(a%2==0){ //偶数の場合
if(!mp.count(2)){
mp[2] = 1;
}
else{
mp[2] +=1;
}
return primeFactorization(a/2); //2で割った値で再帰
}
sq = sqrt(a);
for(i=3;i<=sq;i+=2){ //3以上√a以下の奇数の場合
if(a%i==0){
if(!mp.count(i)){
mp[i] = 1;
}
else{
mp[i] += 1;
}
return primeFactorization(a/i); //割れた値で再帰
}
}
//偶数でも3以上√a以下の奇数の場合でも割り切れない場合
if(a!=1){ //aが1でないなら、a自身は素数
if(!mp.count(a))
mp[a] = 1;
else{
mp[a] += 1;
}
}
return 0;
}
ll kaizyou(ll n){
if(n == 1){
return 1;
}
else{
return (n * kaizyou(n-1)) % 1000000007;
}
}
int main(){
int A,B,M; cin >> A >> B >> M;
vi a(A);
vi b(B);
int p,q;
p = q = 100000000;
rep(i,A){
cin >> a[i];
chmin(p,a[i]);
}
rep(i,B) {
cin >> b[i];
chmin(q,b[i]);
}
int mi = p + q;
rep(i,M){
int x,y,c;cin >> x >> y >> c;
x--;
y--;
chmin(mi,a[x]+b[y]-c);
}
cout << mi << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A,B,M;
cin >> A>>B>>M;
vector<int>veca(A);
vector<int>vecb(B);
for(int i=0;i<A;i++){
cin>>veca.at(i);
}
for(int i=0;i<B;i++){
cin>>vecb.at(i);
}
int countera=999999;
int counterb=999999;
for(int i=0;i<A;i++){
countera=min(countera,veca.at(i));
}
for(int i=0;i<B;i++){
counterb=min(counterb,vecb.at(i));
}
int counter=countera+counterb;
vector<vector<int>>vec(M,vector<int>(3));
for(int i=0;i<M;i++){
for(int j=0;j<3;j++){
cin >> vec.at(i).at(j);
}
}
for(int i=0;i<M;i++){
counter= min(veca.at(vec.at(i).at(0)-1)+vecb.at(vec.at(i).at(1)-1)-vec.at(i).at(2),counter);
}
cout <<counter <<endl;
}
| 1 |
// M
#include<bits/stdc++.h>
using namespace std;
const int N = 303, Mod = 998244353;
int n, k, C[N], dp[N][N][N];
inline void Add(int &a, int b)
{
a += b;
if (a >= Mod)
a -= Mod;
}
int main()
{
string S;
cin >> S >> k;
S = "0" + S;
for (int i = 0; i < (int)S.size();)
{
int r = i + 1;
while (r < (int)S.size() && S[r] == '1')
r ++;
C[n ++] = r - i - 1;
i = r;
}
k = min(k, (int)S.size());
dp[n][0][0] = 1;
int sm = 0;
for (int i = n - 1; ~ i; sm += C[i], i --)
for (int j = sm; j >= 0; j --)
{
for (int h = 0; h <= k; h ++)
Add(dp[i][j][h], dp[i][j + 1][h]),
Add(dp[i][j][h], dp[i + 1][j][h]);
for (int h = 0; h <= k; h ++)
for (int df = 1; df <= C[i]; df ++)
Add(dp[i][j + df][h + df], dp[i + 1][j][h]);
}
int tot = 0;
for (int h = 0; h <= k; h ++)
Add(tot, dp[0][0][h]);
return !printf("%d\n", tot);
}
| #include<stdio.h>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int mod = 1e9+7;
void ad(int &x,int y) { x+=y; if(x>=mod)x-=mod; }
int zy[8][2] = {{6,1},{3,2},{2,2},{4,1},{3,3},{6,1},{7,5},{6,6}};
char ss[300005];
int n;
int dp[300005][8];
int main() {
scanf("%s",&ss[1]);
n = strlen(ss+1);
dp[0][0] = 1;
for(int i=0;i<n;i++) {
for(int j=0;j<8;j++) {
if(ss[i+1]!='0') ad(dp[i+1][zy[j][1]],dp[i][j]);
if(ss[i+1]!='1') ad(dp[i+1][zy[j][0]],dp[i][j]);
}
}
int ans = (dp[n][1] + dp[n][2])%mod;
printf("%d",ans);
} | 0 |
#include <iostream>
#include <queue>
using namespace std;
typedef long long ll;
typedef pair<ll, int> P;
int main()
{
int n;
ll d;
cin >> n >> d;
ll a[200005];
priority_queue<P, vector<P>, greater<P>> que;
for(int i = 0; i < n; i++){
cin >> a[i];
que.push(P(a[i], i));
}
bool used[200005]{0};
ll ans = 0;
while(que.size()){
P p = que.top();
que.pop();
int u = p.second;
if(u > 0 && !used[u]){
ans += d + a[u] + a[u - 1];
if(d + a[u] < a[u - 1]){
a[u - 1] = d + a[u];
que.push(P(a[u - 1], u - 1));
}
used[u] = true;
}
if(u < n - 1 && !used[u + 1]){
ans += d + a[u] + a[u + 1];
if(d + a[u] < a[u + 1]){
a[u + 1] = d + a[u];
que.push(P(a[u + 1], u + 1));
}
used[u + 1] = true;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define f(i,a,b) for (int i = a; i < b; i++)
#define fr(i,a,b) for (int i = b-1; i >= a; i--)
const int mod = 998244353;
const int mxn = 1e5;
int n,K;
void add(ll &a, ll b) { if (b>=mod) b%=mod; a+=b; if (a>=mod) a-=mod; }
ll modpow(ll a, ll b) {
return b?modpow(a*a%mod,b/2)*(b&1?a:1)%mod:1;
}
struct Comb {
ll fac[mxn], inv[mxn], twopow[mxn];
Comb() {
f(i,0,mxn) {
fac[i]=i?fac[i-1]*i%mod:1;
twopow[i]=i?twopow[i-1]*2%mod:1;
}
inv[mxn-1]=modpow(fac[mxn-1],mod-2);
fr(i,0,mxn-1) {
inv[i]=inv[i+1]*(i+1)%mod;
}
}
ll choose(int n, int r) {
if (n<0||n<r||r<0) return 0;
return fac[n]*inv[r]%mod*inv[n-r]%mod;
}
ll multichoose(int n, int k) {
if (!n&&!k) return 1;
return choose(n+k-1,k);
}
ll pow2(int n) {
if (n<0) return 0;
return twopow[n];
}
} C;
ll solve(int x) {
ll ans = 0;
int a = 0, b = 0;
f(i,1,K+1) {
if (i+i==x) b++;
if (i<=K && x-i<=K && x-i>0) a++;
}
a/=2;
f(na,0,a+1) {
f(nb,0,b+1) {
add(ans,C.pow2(na)*C.choose(a,na)%mod*C.multichoose(na+K-2*a-b,n-na-nb));
}
}
return ans;
}
const int DEBUG = 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifdef LOCAL
if (DEBUG) freopen("input.txt", "r", stdin);
if (DEBUG) freopen("output.txt", "w", stdout);
#endif
cin >> K >> n;
for (int x = 2; x <= 2*K; x++)
cout << solve(x) << endl;
cout << endl;
return 0;
}
| 0 |
#include<stdio.h>
int main(){
int M=100000000;
int n,m,i,u,s,c[510],f[20010],t[20010];
while(1){
scanf("%d%d",&n,&m);
if(n==0&&m==0){
break;
}
for(i=u=1;i<=n;i++){
c[i]=M;
}
for(i=s=c[1]=0;i<m*2;i+=2){
scanf("%d %d",&f[i],&t[i]);
f[i+1]=t[i];
t[i+1]=f[i];
}
while(u){
for(i=u=0;i<=m*2;i++){
if(c[f[i]]==M||c[t[i]]<=c[f[i]]+1){
continue;
}
c[t[i]]=c[f[i]]+1;
u=1;
}
}
for(i=2;i<=n;i++){
if(c[i]<3){
s++;
}
}
printf("%d\n",s);
}
return 0;
} | #include <cstdio>
#include <vector>
#define rep(i,n) for(int i = 0; i < n; i++)
using namespace std;
int n, m;
bool used[500];
vector<int> e[500];
int main(){
while(scanf("%d%d", &n, &m), n||m){
rep(i,500) e[i].clear();
rep(i,500) used[i] = false;
rep(i,m){
int x, y; scanf("%d%d", &x, &y);
x--; y--;
e[x].push_back(y);
e[y].push_back(x);
}
used[0] = true;
rep(i,e[0].size()){
used[e[0][i]] = true;
rep(j,e[e[0][i]].size()){
used[e[e[0][i]][j]] = true;
}
}
int ans = -1;
rep(i,500) ans += used[i];
printf("%d\n", ans);
}
} | 1 |
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define repLRE(i, l, r) for (ll i = (l); i <= (r); ++i)
#define rrepLRE(i, l, r) for (ll i = (l); i >= (r); --i)
#define Sort(v) sort(v.begin(), v.end())
#define rSort(v) sort(v.rbegin(), v.rend())
#define Reverse(v) reverse(v.begin(), v.end())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vector<ll>>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;
ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
/* Macros reg. ends here */
const ll INF = 1LL << 50;
int main() {
// ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
ll n, g;
cin >> n >> g;
g /= 100;
vll ps(n), cs(n);
rep(i,n) {
cin >> ps[i] >> cs[i];
cs[i] /= 100;
}
ll ans = INF;
rep(s, 1 << n){
ll tmp = 0;
ll scr = 0;
rep(j, n){
if((s >> j) & 1) {
tmp += ps[j];
scr += (j+1)*ps[j]+cs[j];
}
}
ll cur = n - 1;
ll curn = 0;
bool ok = true;
while(g > scr){
if(cur < 0){
ok = false;
break;
}
if((s >> cur) & 1){
cur--;
curn = 0;
continue;
}
if(curn == ps[cur]-1){
cur--;
tmp += curn-1;
curn = 0;
}
scr += cur + 1;
curn++;
}
tmp += curn;
if(ok) chmin(ans, tmp);
}
cout << ans << endl;
return 0;
}
| #include<cstdio>
#include<math.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
#include<set>
#include<cstring>
#include<map>
using namespace std;
#define int long long int
#define rep(i,n) for(int i=0;i<n;i++)
#define INF 1001001001
#define LLINF 1001001001001001001
#define mp make_pair
#define pb push_back
#define mod 1000000007
//#define mod 998244353
int D,G;
int p[15],c[15];
int dp[15][1500];
signed main(){
scanf("%lld %lld",&D,&G);
int maxp=0;
rep(i,D){
scanf("%lld %lld",&p[i],&c[i]);
maxp=max(maxp,p[i]);
}
rep(i,D+1)rep(j,D*maxp+1)dp[i][j]=-INF;
rep(i,D){
rep(j,D*maxp+1){
if(i==0&&j==0)dp[i][j]=0;
rep(p_num,p[i]+1){
if(p_num!=p[i])dp[i+1][j+p_num]=max(dp[i+1][j+p_num],dp[i][j]+p_num*(i+1)*100);
else dp[i+1][j+p_num]=max(dp[i+1][j+p_num],dp[i][j]+p_num*(i+1)*100+c[i]);
}
}
}
int ans=-1;
rep(j,D*maxp+1){
//printf("%lld/",dp[D][j]);
if(dp[D][j]>=G){ans=j;break;}
}
printf("%lld\n",ans);
} | 1 |
#include<bits/stdc++.h>
//#include<atcoder/all>
// Begin Header {{{
//using namespace atcoder;
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i,n) for(ll i=0; i<n; i++)
#define loop(i, j, n) for(ll i=j; i<n; i++)
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define Sp(p) cout<<setprecision(25)<< fixed<<p<<endl;
constexpr int INF = 0x3f3f3f3f;
const long long mod=1e9+7;
const long double PI = acos(-1);
template<class T, class S> inline bool chmax(T &a, const S &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T, class S> inline bool chmin(T &a, const S &b) { if (a>b) { a = b; return 1; } return 0; }
#define INT(...) \
int __VA_ARGS__; \
IN(__VA_ARGS__)
#define LL(...) \
ll __VA_ARGS__; \
IN(__VA_ARGS__)
#define STR(...) \
string __VA_ARGS__; \
IN(__VA_ARGS__)
#define CHR(...) \
char __VA_ARGS__; \
IN(__VA_ARGS__)
#define DBL(...) \
double __VA_ARGS__; \
IN(__VA_ARGS__)
template<class T> void scan(T &a) { cin >> a; }
void IN() {}
template<class Head, class... Tail> void IN(Head &head, Tail &... tail){ scan(head); IN(tail...); }
// }}} End Header
int main() {
LL(n);
STR(s);
ll west_cnt = 0;
ll east_cnt = 0;
loop(i, 1, n) if(s[i] == 'E') east_cnt++;
ll min = east_cnt;
loop(i, 1, n){
if(s[i-1] == 'W') west_cnt++;
if(s[i] == 'E') east_cnt--;
chmin(min, west_cnt+east_cnt);
}
cout << min << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <iostream>
#include <string>
#include <string.h>
#include <ctype.h>
#include <algorithm>
using namespace std;
int main() {
int n,ans,W[310000] = {},E[310000] = {};
string s;
cin >> n >> s;
for(int i = 1; i <= n-1; i++) {
if(s[i-1] == 'W')
W[i] = W[i-1] + 1;
else W[i] = W[i-1];
}
for(int i = n-2; i >= 0; i--) {
if(s[i+1] == 'E')
E[i] = E[i+1] + 1;
else E[i] = E[i+1];
}
int m = n;
for(int i = 0; i < n; i++)
m = min(m,W[i]+E[i]);
cout << m << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(i = 0;i < n;++i)
#define all(v) v.begin(), v.end()
using ll = int;
int main()
{
ll i,j,k;
ll h,w;
cin >> h >> w;
ll inf = 160*80;
vector<vector<ll>> a(h,vector<ll>(w,0));
vector<vector<ll>> b(h,vector<ll>(w,0));
for(i = 0;i < h;++i){
rep(j,w) cin >> a.at(i).at(j);
}
for(i = 0;i < h;++i){
rep(j,w) cin >> b.at(i).at(j);
}
vector<vector<vector<ll>>> dp(h, vector<vector<ll>>(w, vector<ll>(2*inf+1,0)));
ll tmp = a.at(0).at(0) - b.at(0).at(0);
dp.at(0).at(0).at(inf + tmp) = 1;
dp.at(0).at(0).at(inf - tmp) = 1;
for(i = 0;i < h;++i){
rep(j,w){
ll ni = i + 1;
ll nj = j + 1;
ll t1, t2;
if(ni < h) t1 = a.at(ni).at(j) - b.at(ni).at(j);
if(nj < w) t2 = a.at(i).at(nj) - b.at(i).at(nj);
rep(k, 2*inf+1){
if(dp.at(i).at(j).at(k)){
if(ni < h){
dp.at(ni).at(j).at(k + t1) = 1;
dp.at(ni).at(j).at(k - t1) = 1;
}
if(nj < w){
dp.at(i).at(nj).at(k + t2) = 1;
dp.at(i).at(nj).at(k - t2) = 1;
}
}
}
}
}
ll ans = 1e9;
for(i = 0;i < 2*inf + 1;++i){
if(dp.at(h-1).at(w-1).at(i)){
ans = min(ans, abs(i - inf));
}
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <string>
#include <vector>
#include <set>
#include <stack>
#include <queue>
#include <map>
#include <algorithm>
#include <iomanip>
#include <math.h>
#include <string.h>
#include <cstdio>
#include <tuple>
using namespace std; using ll = long long; using pll = pair<ll, ll>;
using vl = vector<ll>; using vll = vector<vl>; using vpll = vector<pll>;
//**デバッグ準備**//
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
void debug_out() { cerr << endl; }
template<typename Head, typename... Tail>
void debug_out(Head h, Tail... t) {
cerr << " " << h;
if (sizeof...(t) > 0) cerr << " :";
debug_out(t...);
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> vec) {
for (size_t i = 0; i < vec.size(); i++)os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
ll ctoi(char c) {
switch (c) {
case '0': return 0; case '1': return 1; case '2': return 2;
case '3': return 3; case '4': return 4; case '5': return 5;
case '6': return 6; case '7': return 7; case '8': return 8;
case '9': return 9; default: return 0;
}
}
bool pairCompare(const pll firstElof, pll secondElof)
{
return firstElof.first > secondElof.first;
}
//**Snippetリスト**//
//rep, vin, all, iteLoop//
//gcdlcm, isPrime, eratos, Npow, divisor, modinv, bitSearch, bitList, dfs, bfs//
//dijkstra, WarshallFloyd, BellmanFord, UnionFind, COM, digitDP ,RMQ//
ll i, j, k, l; ll N, M, K, H, W, L, X, Y, Z;
ll MOD = 1000000007; ll INF = 1LL << 60; ll ans = 0; ll z = 0, o = 1;
vl flag, color, D; vll path;
//***********//
int main() {
cin >> H >> W;
vll A(H, vl(W, 0));
vll B(H, vl(W, 0));
vll D(H+1, vl(W+1, 0));
for (i = 0; i < H; i++) {
for (j = 0; j < W; j++) {
cin >> A[i][j];
}
}
for (i = 0; i < H; i++) {
for (j = 0; j < W; j++) {
cin >> B[i][j];
D[i+1][j+1] = abs(A[i][j] - B[i][j]);
}
}
ll M = (H + W) * 80;
vector<vll> dp(H+1, vll(W+1, vl(M, 0)));
dp[1][1][D[1][1]] = 1;
for (i = 1; i <= H; i++) {
for (j = 1; j <= W; j++) {
for (k = 0; k < M; k++) {
if (i == H && j == W) continue;
if (i != H) {
if (k + D[i + 1][j] < M) dp[i + 1][j][k + D[i + 1][j]] |= dp[i][j][k];
if (abs(k - D[i + 1][j]) < M) dp[i + 1][j][abs(k - D[i + 1][j])] |= dp[i][j][k];
}
if (j != W) {
if (k + D[i][j + 1] < M) dp[i][j + 1][k + D[i][j + 1]] |= dp[i][j][k];
if (abs(k - D[i][j + 1]) < M) dp[i][j + 1][abs(k - D[i][j + 1])] |= dp[i][j][k];
}
}
}
}
for (i = 1; i <= H; i++) {
for (j = 1; j <= W; j++) {
for (k = 0; k < M; k++) {
//if(dp[i][j][k]) debug(i, j, k, dp[i][j][k]);
}
}
}
for (k = 0; k < M; k++) {
if (dp[H][W][k]) {
cout << k;
exit(0);
}
}
} | 1 |
#pragma region header
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <math.h>
using namespace std;
#define int 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++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define ts to_string
#define all(v) (v).begin(), (v).end()
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vs vector <string>
#define vvs vector <vector<string>>
#define pq priority_queue<int>
using ll = long long;
/* ----------------よく使う数字や配列----------------- */
int dx[] = { 1,0,-1,0 };
int dy[] = { 0,1,0,-1 };
const int INF = 2000000000;
const int MINF=-2000000000;
constexpr ll mod = 1e9 + 7;
constexpr long double pi = 3.141592653589793238462643383279;
/* ----------------------end----------------------- */
/* --------------------ライブラリ-------------------- */
ll fact(int i) { //階乗
if (i == 0) return 1;
return (fact(i - 1)) * i % mod;
}
ll gcd(ll a, ll b) { //最大公約数
if (b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { //最小公倍数
return a * b / gcd(a, b);
}
bool isprime(ll a)//素数判定、primeならtrue,違うならfalse
{
if (a < 2) return false;
else if (a == 2) return true;
else if (a % 2 == 0) return false;
double m = sqrt(a);
for (int i = 3; i <= m; i += 2)
{
if (a % i == 0)
{
return false;
}
}
// 素数である
return true;
}
ll ketasum(ll n) { //各桁の和
ll sum = 0;
while (n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
ll kind(vi SYURUI) {//vector<int>型の配列の要素の種類数
int size = SYURUI.size();
sort(all(SYURUI));
int cnt = 1;
rep(i, size-1) {
if (SYURUI[i] != SYURUI[i + 1])cnt++;
}
return cnt;
}
/* ----------------------end----------------------- */
#pragma endregion
signed main() {
int A, B, C, D, K; cin >> A >> B >> C >> D >> K;
cout << (60 * C + D) - (60 * A + B) - K << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define SZ(x) (int)(x.size())
using ll = long long;
using ld = long double;
using P = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
const double eps = 1e-10;
const int MOD = 1000000007;
const int INF = 1000000000;
const ll LINF = 1ll<<50;
template<typename T>
void printv(const vector<T>& s) {
for(int i=0;i<(int)(s.size());++i) {
cout << s[i];
if(i == (int)(s.size())-1) cout << endl;
else cout << " ";
}
}
vvll mem;
int ng = 0;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
ll n, x, y, z; cin >> n >> x >> y >> z;
ll MAX = 1ll << (x + y + z - 1);
const ll NG_BITS = (1ll<<(x+y+z-1)) | (1ll<<(y+z-1)) | (1ll<<(z-1));
vvll dp(n+1, vll(MAX, 0));
dp[0][0] = 1;
for(int i=0;i<n;++i) {
for(ll j=1;j<=10;++j) {
for(ll k=0;k<MAX;++k) {
ll t = (k << j) | (1ll << (j - 1));
if((NG_BITS & t) != NG_BITS) {
t &= (MAX - 1);
dp[i+1][t] += dp[i][k];
dp[i+1][t] %= MOD;
}
}
}
}
ll ans = 1;
for(int i=0;i<n;++i) {
ans *= 10;
ans %= MOD;
}
for(int i=0;i<MAX;++i) {
ans += MOD - dp[n][i];
ans %= MOD;
}
cout << ans << endl;
}
| 0 |
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<vector>
#include<functional>
#include<algorithm>
#include<stdlib.h>
#include<string>
#include<string.h>
#define _USE_MATH_DEFINES
#include<math.h>
#include<deque>
#include<set>
#include<map>
#include<queue>
#include<list>
#include<iostream>
#include <bitset>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(auto i=a;i<b;i++)
#define rep2(i, a)for(auto i : a)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x, std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x *= x; p /= 2; } else { a *= x; p--; } }return a; }
ll mpower(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x = x * x % mod; p /= 2; } else { a = a * x % mod; p--; } }return a; }
ll co(ll n, ll k) { ll a = 1; rep(i, 1, k) { a *= n - i + 1; a /= i; }return a; }
ll mc(ll n, ll m) { ll k = 1, l = 1; rep(i, n - m + 1, n + 1) k = k * i % mod; rep(i, 1, m + 1) l = l * i % mod; l = mpower(l, mod - 2); return k * l % mod; }
int main()
{
int n;
string s, t, str[4] = {"SS", "SW", "WS", "WW"};
cin >> n >> s;
t.resize(s.size());
//t[s.size()] = 0;
rep(_i, 0, 4) {
t[0] = str[_i][0];
t[1] = str[_i][1];
rep(i, 1, s.size() + 1) {
t[(i+1) % s.size()] = ((s[i % s.size()] == 'o') ^ (t[(i-1) % s.size()] == 'S') ^ (t[i % s.size()] == 'S')) ? 'S' : 'W';
}
if (t[0] == str[_i][0] && t[1] == str[_i][1]) {
puts(t.c_str());
return 0;
}
}
puts("-1");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 100005;
int n;
string s;
bool val = false;
bitset<N> ans;
int main() {
cin.sync_with_stdio(0); cin.tie(0);
cin >> n >> s;
int variations[4][2] = {{0, 1}, {0, 0}, {1, 0}, {1, 1}};
for (int v = 0; v < 4; ++v) {
ans.reset();
ans[0] = variations[v][0];
ans[1] = variations[v][1];
for (int i = 1; i < n - 1; ++i) {
if (!ans[i]) {
if (s[i] == 'o') ans[i + 1] = ans[i - 1];
else ans[i + 1] = !ans[i - 1];
} else {
if (s[i] == 'o') ans[i + 1] = !ans[i - 1];
else ans[i + 1] = ans[i - 1];
}
}
bool good = true;
if (ans[n - 1]) {
if (s[n - 1] == 'o' && ans[n - 2] == ans[0]) {
good = false;
} else if (s[n - 1] == 'x' && ans[n - 2] != ans[0]) {
good = false;
}
} else {
if (s[n - 1] == 'o' && ans[n - 2] != ans[0]) {
good = false;
} else if (s[n - 1] == 'x' && ans[n - 2] == ans[0]) {
good = false;
}
}
if (ans[0]) {
if (s[0] == 'o' && ans[1] == ans[n - 1]) {
good = false;
} else if (s[0] == 'x' && ans[1] != ans[n - 1]) {
good = false;
}
} else {
if (s[0] == 'o' && ans[1] != ans[n - 1]) {
good = false;
} else if (s[0] == 'x' && ans[1] == ans[n - 1]) {
good = false;
}
}
if (good) {
val = true;
break;
}
}
if (!val) {
cout << -1;
return 0;
}
for (int i = 0; i < n; ++i) {
if (!ans[i]) cout << 'S';
else cout << 'W';
}
}
| 1 |
#include <bits/stdc++.h>
#define FOR(i, begin, end) for(int i=(begin);i<(end);i++)
#define REP(i, n) FOR(i,0,n)
#define IFOR(i, begin, end) for(int i=(end)-1;i>=(begin);i--)
#define IREP(i, n) IFOR(i,0,n)
#define SORT(a) sort(a.begin(), a.end())
#define REVERSE(a) reverse(a.begin(), a.end())
#define Lower_bound(v, x) distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define int long long
#define INF 1000000000000000000
using namespace std;
#define ANS(f) if(f) cout << "YES" << endl; else cout << "NO" << endl;
typedef vector<int> vec;
typedef vector<vec> mat;
typedef pair<int, int> Pii;
template<typename T>
void readv(vector<T> &a){ REP(i, a.size()) cin >> a[i]; }
void readi(vector<int> &a){ REP(i, a.size()){cin >> a[i]; a[i]--;} }
void debug(mat m){REP(i, m.size()){ REP(j, m[i].size()){ cout << m[i][j] << ","; } cout << endl; }}
int modpow(int x, int n, int m){
int a = 1;
IREP(i, 64){
a = (a * a) % m;
if(((n >> i) & 1) == 1) a = (a * x) % m;
}
return a;
}
class Combination
{
public:
vec fact, invfact;
int MAX_N, mod;
Combination(int MAX_N, int mod): MAX_N(MAX_N), mod(mod) {
initialize();
}
void initialize(){
fact = vec(MAX_N + 1);
invfact = vec(MAX_N + 1);
fact[0] = 1;
FOR(i, 1, MAX_N + 1){
fact[i] = (fact[i - 1] * i) % mod;
}
invfact[MAX_N] = modpow(fact[MAX_N], mod - 2, mod);
IREP(i, MAX_N){
invfact[i] = (invfact[i + 1] * (i + 1)) % mod;
}
}
int nCr(int n, int r){
if(r > n || r < 0 || n < 0) return 0;
if(n > MAX_N){
MAX_N = n;
initialize();
}
int a = fact[n];
a = (a * invfact[r]) % mod;
a = (a * invfact[n - r]) % mod;
return a;
}
};
signed main(){
int K, N; cin >> K >> N;
int mod = 998244353;
Combination comb(N + K, mod);
FOR(i, 2, 2 * K + 1){
if(i % 2 == 1){
int p = min(i, 2 * K + 2 - i) / 2;
int ans = 0;
REP(j, p + 1){
int k = K - 2 * p + j;
int n = N - j;
ans += ((comb.nCr(n + k - 1, n) * modpow(2, j, mod)) % mod) * comb.nCr(p, j);
ans %= mod;
}
cout << ans << endl;
}else{
int p = min(i, 2 * K + 2 - i) / 2 - 1;
int ans = 0;
REP(j, p + 1){
int k = K - 1 - 2 * p + j;
int n = N - j;
ans += ((comb.nCr(n + k - 1, n) * modpow(2, j, mod)) % mod) * comb.nCr(p, j);
ans %= mod;
n = N - j - 1;
ans += ((comb.nCr(n + k - 1, n) * modpow(2, j, mod)) % mod) * comb.nCr(p, j);
ans %= mod;
}
cout << ans << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, a[maxn];
long long sum[maxn];
long long F(int left, int m, int right) {
return abs(sum[right]-2*sum[m]+sum[left]);
}
int find(int l, int r) {
int left = l-1, right = r+1;
while (r-l >= 3) {
int m1 = l + (r-l)/3;
int m2 = r - (r-l)/3;
if (F(left, m1, right) < F(left, m2, right)) r = m2;
else l = m1;
}
if (l == r) return l;
else if (l == r+1) {
if (F(left, l, right) < F(left, l+1, right)) return l;
else return l+1;
}
else {
if (F(left, l, right) < F(left, l+1, right) && F(left, l+2, right))
return l;
else if (F(left, l+1, right) < F(left, l+2, right))
return l+1;
else return l+2;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> a[i];
sum[0] = 0;
for (int i = 1; i <= n; ++i)
sum[i] = sum[i-1] + a[i];
long long ans = 1e17;
for (int i = 2; i <= n-2; ++i) {
int j = find(1, i-1);
int k = find(i+1, n-1);
long long maxt = max(sum[j], max(sum[i]-sum[j], max(sum[k]-sum[i], sum[n]-sum[k])));
long long mint = min(sum[j], min(sum[i]-sum[j], min(sum[k]-sum[i], sum[n]-sum[k])));
ans = min(ans, maxt-mint);
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
const int mod = 998244353;
typedef long long LL;
void reduce(int & x) { x += x >> 31 & mod; }
int mul(int a, int b) { return (LL) a * b % mod; }
int pow(int a, int b, int res = 1) {
for (; b; b >>= 1, a = mul(a, a)) if (b & 1) res = mul(res, a);
return res;
}
const int MAXS = 1000010;
int fac[MAXS], inv[MAXS];
int C(int a, int b) { return a < b ? 0 : (LL) fac[a] * inv[b] % mod * inv[a - b] % mod; }
int main() {
fac[0] = fac[1] = inv[0] = inv[1] = 1;
for (int i = 2; i != MAXS; ++i) {
fac[i] = mul(fac[i - 1], i);
inv[i] = mul(inv[mod % i], mod - mod / i);
}
for (int i = 2; i != MAXS; ++i) inv[i] = mul(inv[i - 1], inv[i]);
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
int n, m; std::cin >> n >> m;
int ans = std::max(n, m), a2 = 0;
for (int i = std::min(n, m); i; --i)
reduce(a2 += mul(C(i * 2, i), C(n + m - i * 2, n - i)) - mod);
a2 = pow(mul(C(n + m, n), 2), mod - 2, a2);
reduce(ans += a2 - mod);
std::cout << ans << std::endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int,int> pii;
typedef int _loop_int;
#define REP(i,n) for(_loop_int i=0;i<(_loop_int)(n);++i)
#define FOR(i,a,b) for(_loop_int i=(_loop_int)(a);i<(_loop_int)(b);++i)
#define FORR(i,a,b) for(_loop_int i=(_loop_int)(b)-1;i>=(_loop_int)(a);--i)
#define VIN(v) for(auto&elem_: (v) )cin>>elem_
#define VOUT(v, sep) for(_loop_int idx=0; idx<(_loop_int)v.size(); idx++) {cout<<v[idx]; if(idx<(_loop_int)v.size()-1) cout<<sep;} cout<<endl
#define ALL(a) (a).begin(),(a).end()
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define DEBUG2(x,y) cout<<#x<<": "<<x<<" "<<#y<<": "<<y<<endl
#define DEBUG_VEC(v) cout<<#v<<":";REP(debugidx,v.size())cout<<" "<<v[debugidx];cout<<endl
#define DEBUG_ARR(v,n) cout<<#v<<":";REP(debugidx,n)cout<<" "<<v[debugidx];cout<<endl
const ll MOD = 1000000007ll;
const int IINF = numeric_limits<int>::max()/2-1;
const ll LINF = numeric_limits<ll>::max()/2-1;
template<class T> inline bool chmin(T& a, const T b) { if (a>b) { a=b; return true; } return false; }
template<class T> inline bool chmax(T& a, const T b) { if (a<b) { a=b; return true; } return false; }
int main() {
ios::sync_with_stdio(false); cin.tie(0);
int n,y;
cin>>n>>y;
y/=1000;
FOR(i,0,n+1){
FOR(j,0,n+1-i){
int k = n-i-j;
if(i + j*5 + k*10 == y){
printf("%d %d %d", k,j,i);
return 0;
}
}
}
cout << "-1 -1 -1" << endl;
return 0;
} | 0 |
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <fstream>
#include <unordered_map>
using namespace std;
ifstream fin("../data.txt");
int n, x, a1, a2, eat;
long long ans;
int main() {
cin >> n >> x >> a1;
n--;
while (n--) {
cin >> a2;
if (a1 + a2 > x) {
eat = a1 + a2 - x;
ans += eat;
if (eat > a2) {
a2 = 0;
} else {
a2 -= eat;
}
}
a1 = a2;
}
cout << ans;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define reps(i, f, n) for (ll i = (f); i < (n); i++)
#define repv(v) for (auto it = (v).begin(); it != (v).end(); it++)
ll const INF = 1LL << 60;
ll const MAX_N = 510000;
ll const MOD = 1000000007;
// in
// 6 3
// 4 3 1 0 9 8
// out
// 18
int main() {
ll N, x;
cin >> N >> x;
vector<ll> a(N);
rep(i, N) cin >> a[i];
ll ans = 0;
for (ll i = 0; i < N - 1; i++) {
if (a[i] + a[i + 1] > x) {
ans += a[i] + a[i + 1] - x;
a[i + 1] -= min(a[i + 1], (a[i] + a[i + 1] - x));
}
// repv(a) cout << *it << " ";
// cout << endl;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define all(x) (x).begin(),(x).end()
#define m0(x) memset(x,0,sizeof(x))
int dx4[4] = {1,0,-1,0}, dy4[4] = {0,1,0,-1};
int main()
{
int x[2],ans=0;
for (int i = 0; i < 2; i++)
{
cin>>x[i];
if(x[i]==1) ans+=300000;
if(x[i]==2) ans+=200000;
if(x[i]==3) ans+=100000;
}
if(x[0]==1&&x[1]==1) ans+=400000;
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1001001001;
const ll LINF = 1001001001001001;
const int MOD = 1000000007;
template <typename T>
void print(const T &v);
int main()
{
int x, y;
cin >> x >> y;
int ans = 0;
if (x == 1)
{
ans += 300000;
}
else if (x == 2)
{
ans += 200000;
}
else if (x == 3)
{
ans += 100000;
}
if (y == 1)
{
ans += 300000;
}
else if (y == 2)
{
ans += 200000;
}
else if (y == 3)
{
ans += 100000;
}
if (ans == 600000)
{
ans += 400000;
}
cout << ans << endl;
return 0;
}
// Use For Debug
template <typename T>
void print(T const &v)
{
for (int i = 0; i < v.size(); i++)
{
if (i)
cout << ' ';
cout << v[i];
}
cout << endl;
} | 1 |
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
using namespace std;
/*2進数配列+1*/
vector<int> twoadd(vector<int> v, int N){
v[N-1]+=1;
int ind = N-1;
int j=N-1;
for(j=N-1;j>=1;j--){
if(v[j]>1){
v[j-1]+=1;
v[j]=0;
}
}
return v;
}
/*フィボナッチ*/
long long fibonatti(long long d){
long long count = 0;
long long f1 = 1;
long long f2 = 1;/*ここを変える*/
long long temp;
if(d == 1){
count = f1;
}else if(d == 2){
count = f2;
}else if(d==0){
count = 1;
}else{
for(int i=0;i<d-2;i++){
temp = f1+f2;
f1 = f2;
f2 = temp;
}
count = temp;
}
return count;
}
/*最大公約数*/
unsigned long long GCD(long long L,long long R){
if(L>R){
long long temp=R;
R = L;
L = temp;
}
unsigned long long pp=0,ppt=0;
unsigned long long ans=0;
if(R%L==0){
ans = L;
}else{
while(true){
ppt = pp;
pp=R%L;
if(pp == 0){
ans = ppt;
break;
}
R = L;
L = pp;
}
}
return ans;
}
/*最小公倍数*/
unsigned long long LCM(long long L,long long R){
unsigned long long ans;
unsigned long long gcd = GCD(L,R);
ans = (L/gcd)*R;
return ans;
}
/*Combination set*/
#define mod 1000000007
#define maxcomb 3000/*大きいものを求めるときはここを変える*/
vector<long long> fc(maxcomb+1);
vector<long long> ifc(maxcomb+1);
long long modpow(long long x,long long n){
long long ans = 1;
while(n > 0){
if(n & 1) {
ans = ans*x%mod;
}
x = x*x%mod;
n >>= 1;
}
return ans;
}
void Conb(){
fc[0]= 1;
ifc[0]=1;
for(long long i=0;i<maxcomb;i++){
fc[i+1] = fc[i]*(i+1)%mod;//n!(mod)
ifc[i+1] = ifc[i]*modpow(i+1,mod-2)%mod;//k!^{M-2} (mod)
}
}
unsigned long long Combination(long long L,long long R){
unsigned long long up=1,ans;
Conb();
if(L==0&&R==0){
return 1;
}else if(L<R||L<0){
return 0;
}else{
long long t = ifc[L-R]*ifc[R]%mod;
ans = t*fc[L]%mod;
}
return ans;
}
/*Combination set ここまで*/
/*ここから*/
int main() {
int K,X;
cin >> K >> X;
for(int i=X-K+1;i<X+K;i++){
cout << i ;
if(i!=X+K-1){
cout << " ";
}else{
cout << endl;
}
}
return 0;
} | #include<bits/stdc++.h>
#define endl '\n'
using namespace std;
typedef long long ll;
int read()
{
int out = 0, sgn = 1;
char jp = getchar();
while (jp != '-' && (jp < '0' || jp > '9'))
jp = getchar();
if (jp == '-')
sgn = -1, jp = getchar();
while (jp >= '0' && jp <= '9')
out = out * 10 + jp - '0', jp = getchar();
return out * sgn;
}
const int P = 1e9 + 7;
int add(int a, int b)
{
return a + b >= P ? a + b - P : a + b;
}
void inc(int &a, int b)
{
a = add(a, b);
}
const int N = 3e5 + 10;
char s[N];
int trans[9][2] = {{1, 2}, {3, 0}, {4, 5}, {1, 1}, {6, 2}, {7, 5}, {4, 4}, {8, 5}, {7, 7}};
int n, dp[N][9];
int main()
{
scanf("%s", s + 1);
n = strlen(s + 1);
dp[0][0] = 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 9; ++j) if (dp[i][j])
{
if (s[i + 1] != '0')
inc(dp[i + 1][trans[j][1]], dp[i][j]);
if (s[i + 1] != '1')
inc(dp[i + 1][trans[j][0]], dp[i][j]);
}
int ans = 0;
for (int j : {2, 5, 7, 8})
inc(ans, dp[n][j]);
printf("%d\n", ans);
return 0;
}
| 0 |
#include <iostream>
#include <string>
#include <iomanip>
#include <math.h>
#include <utility>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <climits>
#include <queue>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
string table[12];
void dfs(int x,int y){
table[x][y]='0';
for(int i=0;i<4;i++){
int nx=x+dx[i];
int ny=y+dy[i];
if(nx>=0&&nx<12&&ny>=0&&ny<12&&table[nx][ny]=='1'){
dfs(nx,ny);
}
}
}
int main(){
while(cin >> table[0]){
for(int i=1;i<12;i++) cin >> table[i];
int ans=0;
rep(i,12){
rep(j,12){
if(table[i][j]=='1'){
dfs(i,j);
ans++;
}
}
}
cout << ans << endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int ap[1005],bp[1005],cp[1005],abc[1005],r[1005];
int n,n1,n2,n3;
int main(){
while(1){
cin >> n1 >> n2 >> n3;
if(n1==0&&n2==0&&n3==0)break;
cin >> n;
for(int i=0;i<=n1+n2+n3;i++)abc[i]=2;
for(int i=0;i<n;i++){
cin >> ap[i] >> bp[i] >> cp[i] >> r[i];
if(r[i]==1){
abc[ap[i]]=1,abc[bp[i]]=1,abc[cp[i]]=1;
}
}
for(int i=0;i<n;i++){
if(abc[ap[i]]==1&&abc[bp[i]]==1&&r[i]==0)abc[cp[i]]=0;
else if(abc[cp[i]]==1&&abc[bp[i]]==1&&r[i]==0)abc[ap[i]]=0;
else if(abc[cp[i]]==1&&abc[ap[i]]==1&&r[i]==0)abc[bp[i]]=0;
}
for(int i=1;i<n1+n2+n3+1;i++)cout << abc[i] << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int n;
cin >> n;
vector<ll> takahashi(n);
ll sum = 0;
for(int i = 0; i < n; i++){
ll a, b;
cin >> a >> b;
takahashi[i] = a+b;
sum-=b;
}
sort(takahashi.begin(), takahashi.end(), greater<long long>());
for(int i = 0; i < n; i++){
if(i%2 == 0){
sum += takahashi[i];
}
}
cout << sum;
}
| #include <cstdio>
#include <iostream>
#include <string>
#include <cstdlib>
#include <vector>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <stdlib.h>
using namespace std;
int main()
{
int n;
cin >> n;
vector<int> a(n);
int min = 0;
int max = 0;
long long sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
min = a[0];
sort(a.rbegin(), a.rend());
max = a[0];
for (int i = 0; i < n; i++) {
sum += a[i];
}
cout << min << " " << max << " " << sum << endl;
}
| 0 |
#include <iostream>
#include <regex>
#include <stdio.h>
#include <string>
using namespace std;
int main() {
string S;
cin >> S;
regex rx(R"(^A[a-z][a-z]*?C[a-z]*?[a-z]$)");
if (regex_match(S, rx)) {
printf("AC\n");
} else {
printf("WA\n");
}
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double dd;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int,int> pii;
const int mx=1e6+11;
const double PI = acos(-1);
#define MOD 1000000007
#define nl '\n'
#define pb push_back
#define F first
#define S second
#define I insert
#define mp make_pair
#define sz(x) x.size()
#define tt int t; cin>>t; while(t--)
#define lo(i,a,b) for(int i=a;i<b;i++)
#define rlo(i,n) for(int i=n-1;i>=0;i--)
#define be(a) (a).begin(),(a).end()
#define rbe(a) (a).rbegin(),(a).rend()
#define mem(a,b) memset(a,b,sizeof(a))
#define pr(a) {for(auto x:a)cout<<x<<" ";cout<<nl;}
#define ac cout<<"AC"<<nl
#define wa cout<<"WA"<<nl
#define su ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define file freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#define frac cout.unsetf(ios::floatfield); cout.precision(10); cout.setf(ios::fixed,ios::floatfield);
#define dbg(args...) do {cerr << #args << " : "; faltu(args); } while(0)
void faltu () { cerr << endl;}
template < typename T, typename ... hello>void faltu( T arg, const hello &... rest) {cerr << arg << ' ';faltu(rest...);}
void f()
{
string s;
cin>>s;
int n=sz(s),c=0,C=0,a=0;
if(s[0]=='A')
{
for(int i=1;i<n;i++)
{
if(s[i]=='C')
c++;
}
if(c>1||c==0)
wa;
else
{
for(int i=2;i<n-1;i++)
{
if(s[i]=='C')
C++;
}
if(C==1)
{
for(int i=1;i<n;i++)
{
if(s[i]!='C'&&s[i]>='a'&&s[i]<='z')
a++;
}
if(2+a==n)
ac;
else
wa;
}
else
wa;
}
}
else
wa;
}
int main()
{
su;
///tt
f();
return 0;
}
| 1 |
#include <bits/stdc++.h>
#include <ext/rope>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define int long long
#define pb push_back
#define x first
#define y second
#define mk(a,b) make_pair(a,b)
#define rr return 0
#define sqr(a) ((a)*(a))
#define all(a) (a).begin(), (a).end()
#define sz(a) (int)(a).size()
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template<class value, class cmp = less<value> >
using ordered_set = tree<value, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class value, class cmp = less_equal<value> >
using ordered_multiset = tree<value, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class key, class value, class cmp = less<key> >
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
/// find_by_order()
/// order_of_key()
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int randll(int l = INT_MIN, int r = INT_MAX) {
return uniform_int_distribution<int>(l, r)(rng);
}
const int INF = 1e9, MOD = 1e9 + 7; /// think
const ll LINF = 1e18;
const int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
inline bool inside (int x, int y, int n, int m) {
return 0 <= x && 0 <= y && x < n && y < m;
}
template<class T> bool umin (T &a, T b) {return a > b ? (a = b, true) : false; }
template<class T> bool umax (T &a, T b) {return a < b ? (a = b, true) : false; }
main()
{
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
map <int, int> nice;
for (int i = 0, a, b; i < m; i++) {
cin >> a >> b;
--a;
if (nice.count(a)) {
if (nice[a] != b) {
cout << "-1\n";
rr;
}
}
nice[a] = b;
}
if (nice.count(0) && nice[0] == 0) {
if (sz(nice) > 1 || n > 1) {
cout << "-1\n";
rr;
}
cout << "0\n";
rr;
}
if (n == 1 && m == 0) {
cout << "0\n";
rr;
}
if (!nice.count(0)) nice[0] = 1;
cout << nice[0];
int mx = 0;
for (auto &i : nice) umax(mx, i.x);
for (int i = 1; i < n; i++) {
if (!nice.count(i)) nice[i] = 0;
cout << nice[i];
}
cout << '\n';
}
| // 問題の URL を書いておく
//
#include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
//#define ENABLE_PRINT
#if defined(ENABLE_PRINT)
#define Print(v) \
do {\
cout << #v << ": " << v << endl; \
}while(0)
#define PrintVec(v) \
do {\
for(int __i = 0; __i < v.size(); ++__i) \
{ \
cout << #v << "[" << __i << "]: " << v[__i] << endl; \
}\
}while(0)
#else
#define Print(v) ((void)0)
#define PrintVec(v) ((void)0)
#endif
#define rep(i, n) for(int i = 0; i < (int)(n); ++i)
using ll = int64_t;
int main(int, const char**)
{
int n, m;
cin >> n >> m;
auto b = m / n;
int ans = 1;
for(int i = 1; i * i <= m; ++i)
{
if(m % i == 0)
{
int dd[] = {i, m / i};
for(auto d : dd)
{
if(d <= b)
{
ans = max(ans, d);
}
}
}
}
cout << ans << 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>;
int main(void){
int A, B;
cin >> A >> B;
int ans = 0;
for (int a = 1; a < 10; a++){
rep(b,10){
rep(c,10){
int x = 10001 * a + 1010 * b + 100 * c;
if (x >= A && x <= B){
ans++;
}
}
}
}
cout << ans << endl;
}
| /*
* @Author: Nazrul Islam
* @Date: 2020-09-19 22:49:56
* @Last Modified by: Nazrul Islam
* @Last Modified time: 2020-09-19 23:45:48
*/
#include<bits/stdc++.h>
using namespace std;
#define IO ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
typedef long long ll;
typedef double dd;
typedef vector<int> vi;
typedef vector<char> vc;
typedef list<int> li;
typedef set<int> si;
typedef map<int,int> mp;
#define pb push_back
#define pf push_front
#define mk make_pair
#define sc scanf
#define pr printf
#define pi acos(-1.0)
#define endl '\n'
// char s[200009];
// char st[200009];
// int a[600][600];
// int b[29][10];
// int a[200009];
// int c[200009];
void solve()
{
ll m, n;
cin >> m >> n;
ll cn = 0;
for(ll i = m; i <= n; i++)
{
string s = to_string(i);
if(s[0] == s[4] && s[1] == s[3]) cn++;
}
cout << cn << endl;
}
int main()
{
IO;
int t;
t = 1;
// cin >> t;
while(t--)
solve();
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
if ((a < c && c < b) || (b < c && c < a)) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| //神题
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 1000010
using namespace std;
int n, ff, op, cl, d[N], ans, L, R, now;
char s1[N], s2[N];
int main(){
scanf("%d%s%s", &n, s1+1, s2+1); s2[0]='$';
ff=1; for(int i=1; i<=n; i++)if(s1[i]!=s2[i]){ff=0; break;}
if(ff){printf("0"); return 0;}
now=n; R=n;
op=1; cl=ans=0;
for(int i=n-1; i>=0; i--)if(s2[i]!=s2[i+1]){
L=i+1;
while(now&&(now>L||s1[now]!=s2[L]))now--;
if(!now){printf("-1"); return 0;}
while(op<=cl&&R<d[op]-(cl-op))op++;
d[++cl]=now;
ans=max(ans, cl-op+1);
now--; R=i;
}
printf("%d", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
//{{{ graph.hpp
#ifndef INCLUDE_GRAPH_HPP
#define INCLUDE_GRAPH_HPP
#include <vector>
namespace orislib {
struct Edge {
typedef int weight_t;
int from, to;
weight_t w;
Edge(int from, int to, weight_t w) : from(from), to(to), w(w) {}
bool operator<(const Edge& e) const {
return w > e.w;
}
};
typedef std::vector<Edge> Edges;
typedef std::vector<Edges> Graph;
}
#endif
//}}}
using namespace orislib;
using namespace std;
typedef long long ll;
typedef long double ld;
typedef tuple<int, int> duo;
//{{{ templates
#define TMPINL_(...) template<__VA_ARGS__>inline
#define TT_ TMPINL_(typename T)
#define TTF_ TMPINL_(typename T,typename F)
#define TTTS_ TMPINL_(typename T,typename...Ts)
#define TITS_ TMPINL_(size_t I=0,typename...Ts)
TT_ T sq(T x){return x*x;}
TT_ T In(){T x;cin>>x;return x;}
TT_ void Out(T&x){cout<<x;}
TT_ void sort(T&v){sort(begin(v),end(v));}
TT_ void revs(T&v){reverse(begin(v),end(v));}
TT_ void uniq(T&v){sort(v);v.erase(unique(begin(v),end(v)),end(v));}
TT_ int ubnd(T&v,typename T::value_type&x){return upper_bound(begin(v),end(v),x)-begin(v);}
TT_ int lbnd(T&v,typename T::value_type&x){return lower_bound(begin(v),end(v),x)-begin(v);}
TTF_ void inpt(T&v,int n,F f){for(v.reserve(n);n--;v.emplace_back(f()));}
TTF_ void show(T&v,F f,string d=" ",string e="\n"){int i=0;for(auto&x:v)i++&&(cout<<d),f(x);cout<<e;}
TITS_ typename enable_if<I==tuple_size<tuple<Ts...>>::value-1,string>::type join(string s,tuple<Ts...>t){return to_string(get<I>(t));}
TITS_ typename enable_if<I<tuple_size<tuple<Ts...>>::value-1,string>::type join(string s,tuple<Ts...>t){return to_string(get<I>(t))+s+join<I+1>(s,t);}
TT_ string join(string s,T t){return to_string(t);}
TTTS_ string join(string s,T t,Ts...ts){return join(s,t)+s+join(s,ts...);}
inline void fast_io(){ios::sync_with_stdio(0);cin.tie(0);}
inline int in(){int x;scanf("%d",&x);return x;}
inline ll pow_mod(ll a,ll k,ll m){ll r=1;for(;k>0;a=a*a%m,k>>=1)if(k&1)r=r*a%m;return r;}
inline ll mod_inv(ll a,ll p){return pow_mod(a,p-2,p);}
inline int puts(const string&s){ return puts(s.c_str()); }
//}}} priority_queue queue deque front stringstream max_element min_element insert count make_tuple
const int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
const int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
const int Mod = 1000000000 + 0;
void dijkstra(const Graph& g, int s, vector<Edge::weight_t>& dist, vector<int>& prev)
{
const int V = g.size();
const Edge::weight_t INF = INT_MAX;
prev.assign(V, -1);
dist.assign(V, INF);
dist[s] = 0;
priority_queue<Edge> pq;
for (pq.push(Edge(-2, s, 0)); !pq.empty(); pq.pop()){
Edge c = pq.top();
if (prev[c.to] != -1) continue;
prev[c.to] = c.from;
dist[c.to] = c.w;
for (const auto& e : g[c.to]){
pq.push(Edge(e.from, e.to, e.w + c.w));
}
}
}
int main()
{
int V, E, r;
V = in(), E = in(), r = in();
Graph g(V);
for (int i = 0; i < E; i++){
int s, t, d;
s = in(), t = in(), d = in();
g[s].emplace_back(s, t, d);
}
vector<Edge::weight_t> ws;
vector<int> prev;
dijkstra(g, r, ws, prev);
show(ws, [](int v){
if (v == INT_MAX) cout << "INF";
else cout << v;
}, "\n");
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define int long long
const int N = 2e5;
const int INF = 1e9;
typedef pair<int, int> P;
struct edge{ int to,cost; };
vector< edge > G[N];
void dikstra(int s,int V){
priority_queue<P,vector<P>,greater<P>> que;
int d[N]; //sからの最短距離
fill(d,d+N,INF);
d[s] = 0;
que.push({0,s});
while( !que.empty() ){
P p = que.top(); que.pop();
int v = p.second;
if(d[v] < p.first) continue;
for(int i = 0; i < G[v].size(); i++){
edge e = G[v][i];
if(d[e.to] > d[v] + e.cost){
d[e.to] = d[v] + e.cost;
que.push( {d[e.to],e.to} );
}
}
}
for(int i = 0; i < V; i++){
if(d[i] >= INF) cout << "INF" << endl;
else cout << d[i] << endl;
}
}
signed main(){
int V,E,r; cin >> V >> E >> r;
for(int i = 0; i < E; i++){
int s,t,c; cin >> s >> t >> c;
G[s].push_back({t,c});
}
dikstra(r,V);
return 0;
}
| 1 |
/*
AuThOr GaRyMr
*/
#include<bits/stdc++.h>
#define rb(a,b,c) for(int a=b;a<=c;++a)
#define rl(a,b,c) for(int a=b;a>=c;--a)
#define LL long long
#define IT iterator
#define PB push_back
#define II(a,b) make_pair(a,b)
#define FIR first
#define SEC second
#define FREO freopen("check.out","w",stdout)
#define rep(a,b) for(int a=0;a<b;++a)
#define KEEP while(1)
#define SRAND mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#define random(a) rng()%a
#define ALL(a) a.begin(),a.end()
#define POB pop_back
#define ff fflush(stdout)
#define fastio ios::sync_with_stdio(false)
using namespace std;
const int INF=0x3f3f3f3f;
typedef pair<int,int> mp;
typedef pair<mp,mp> superpair;
vector<int> each[30];
int n,bit[200000+1][30];
int z[700000+1];
string b[30];
void z_function(string S){
// cout<<S<<endl;
int len=S.length();
S='$'+S;
int l,r;
memset(z,0,sizeof(z));
rb(i,2,len)
if(S[i]!=S[i-1]) break;
else z[2]++;
l=2,r=z[2]+1;
rb(i,3,len){
if(i<=r){
z[i]=z[i-(l)+1];
z[i]=min(z[i],r-i+1);
if(z[i]+i-1==r){
int ite=z[i]+1;
rb(j,r+1,len){
if(S[j]!=S[ite++]) break;
z[i]++;
}
l=i,r=i+z[i]-1;
}
}
else{
int ite=1;
rb(j,i,len){
if(S[j]!=S[ite++]) break;
z[i]++;
}
l=i,r=i+z[i]-1;
}
}
}
int a[200000+1],sb[200000+1];
void run(int is){
string A="";
rb(i,1,n)
A+=char('0'+bit[i][is]);
z_function(A+'&'+b[is]+b[is]);
rb(i,n+3,n+2+n){
if(z[i]==n){
each[is].PB(n+2+n-i);
}
}
rb(i,1,n)
if(A[i-1]=='0') A[i-1]='1';
else A[i-1]='0';
z_function(A+'&'+b[is]+b[is]);
rb(i,n+3,n+2+n){
if(z[i]==n){
each[is].PB(n+2+n-i);
}
}
}
int main(){
fastio;
cin>>n;
rb(i,1,n)
{
int ai;
cin>>ai;
a[i]=ai;
rep(j,30)
{
bit[i][j]=bool(ai&(1<<j));
}
}
rep(i,30)
b[i]="";//return 0;
rb(i,1,n){
int bi;
cin>>bi;
sb[i]=bi;
rep(j,30){
b[j]+=char('0'+(bool)(bi&(1<<j)));
}
}
rep(i,30){
run(i);
sort(ALL(each[i]));
}
rep(i,n){
int ok=1;
rep(j,30){
if(binary_search(ALL(each[j]),i)){
}
else ok=0;
} if(ok) cout<<i<<" "<<(a[1+i] ^ sb[1])<<endl;
}
return 0;
}
| #include<bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define fst first
#define snd second
using namespace std;
typedef long long ll;
typedef double db;
typedef long double ldb;
template<class T> inline void checkmin(T &a,const T &b){if(b<a) a=b;}
template<class T> inline void checkmax(T &a,const T &b){if(b>a) a=b;}
const int inf=1e9+10;
const int maxn=2e5+10;
const ll base=1e9+7;
const ll mod=2038077799;
ll ha,hb,a[maxn],b[maxn],difa[maxn],difb[maxn];
int n;
ll getval(ll x,ll k,ll mod){
if(k==0) return 1ll;
if(k==1) return x;
ll res=getval(x,k/2,mod);
res=(res*res)%mod;
if(k&1) res=(res*x)%mod;
return res;
}
int main(){
scanf("%d",&n);
for(int i=0;i<n;i++) scanf("%lld",&a[i]);
for(int i=0;i<n;i++) scanf("%lld",&b[i]);
for(int i=0;i<n;i++) difa[i]=a[i]^a[(i+1)%n];
for(int i=0;i<n;i++) difb[i]=b[i]^b[(i+1)%n];
ha=hb=0;
for(int i=0;i<n;i++){
ha*=base; ha%=mod;
ha+=difa[i]; ha%=mod;
}
for(int i=0;i<n;i++){
hb*=base; hb%=mod;
hb+=difb[i]; hb%=mod;
}
ll val=getval(base,n-1,mod);
vector <int> ans;
for(int i=0;i<n;i++){
if(ha==hb){
ans.pb(i);
}
ll now=val*difa[i]; now%=mod;
ha+=mod-now; ha%=mod;
ha*=base; ha%=mod;
ha+=difa[i]; ha%=mod;
}
for(int i=0;i<ans.size();i++){
cout<<ans[i]<<" "<<(a[0]^b[(n-ans[i])%n])<<endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
#define FOR(i, n, m) for(ll (i)=(m);(i)<(n);++(i))
#define REP(i, n) FOR(i,n,0)
#define OF64 std::setprecision(10)
const ll MOD = 1000000007;
const ll INF = (ll) 1e15;
struct Vertex {
vector<ll> node;
};
ll CA[100005];
ll CT[100005];
Vertex V[100005];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, A, T;
cin >> N >> T >> A;
T--;
A--;
REP(i, N) {
CT[i] = CA[i] = INF;
}
REP(i, N - 1) {
ll a, b;
cin >> a >> b;
a--;
b--;
V[a].node.push_back(b);
V[b].node.push_back(a);
}
{
queue<pll> q;
q.push(pll(A, 0));
CA[A] = 0;
while (!q.empty()) {
pll t = q.front();
q.pop();
ll cost = t.second + 1;
for (auto n : V[t.first].node) {
if (CA[n] <= cost)
continue;
CA[n] = cost;
q.push(pll(n, cost));
}
}
}
{
queue<pll> q;
q.push(pll(T, 0));
CT[T] = 0;
while (!q.empty()) {
pll t = q.front();
q.pop();
ll cost = t.second + 1;
for (auto n: V[t.first].node) {
if (CT[n] <= cost)
continue;
CT[n] = cost;
q.push(pll(n, cost));
}
}
}
ll ans = 0;
REP(i, N) {
if (CA[i] >= CT[i])
ans = std::max(ans, CA[i] - 1);
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
#define ll long long
#define ld long double
#define fs first
#define sc second
#define task "tst"
using namespace std;
const ll N = 1e5 + 9;
const ll inf = 1e9 + 7;
typedef pair<ll,ll> LL;
ll n,i,mx[N],p,q,maxx,cur;
LL a[N],b[N];
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
if (fopen(task".inp", "r")){
freopen(task".inp", "r", stdin);
//freopen(task".out", "w", stdout);
}
q = n + 1; a[q].sc = inf;
cin>>n;
for (i = 1;i <= n;i++){
cin>>a[i].fs>>a[i].sc;
a[i].sc++;
maxx = max(maxx,a[i].sc - a[i].fs);
if (a[i].fs > a[p].fs) p = i;
if (a[i].sc < a[q].sc) q = i;
}
p = a[p].fs; q = a[q].sc;
ll ans = maxx + max(0ll,q - p);
for (i = 1;i <= n;i++){
b[i].fs = max(0ll,a[i].sc - p);
b[i].sc = q - a[i].fs;
}
sort(b + 1,b + n + 1);
for (i = n;i >= 1;i--) mx[i] = max(mx[i + 1],b[i].sc);
cur = b[1].sc;
for (i = 1;i <= n;i++){
if (i == 1) ans = max(ans,b[i].fs + mx[i + 1]);
else ans = max(ans,b[i].fs + max(cur,mx[i + 1]));
cur = min(cur,b[i].sc);
}
cout<<ans;
}
| 0 |
//include
//------------------------------------------
#include <string>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <complex>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <ctime>
// namespace
using namespace std;
// type alias
using ll = long long;
using ull = unsigned long long;
using comp = complex<double>;
// constant
static const ll MOD = 1000000007LL;
static const double PI = 3.14159265358979323846;
// conversion
inline ll toint(string s) { ll v; istringstream sin(s); sin >> v; return v; }
template<class t> inline string tostring(t x) { ostringstream sout; sout << x; return sout.str(); }
// print
#define RET(x) return cout << x << endl, 0;
// for loop
#define REP(i, a, b) for ((i) = (ll)(a);(i) < (ll)(b);(i)++)
#define REPD(i, a, b) for (ll i = (ll)(a);(i) < (ll)(b);(i)++)
#define REPI(v, vs) for (auto& v : vs)
//debug
#define DUMP(x) cerr << #x << " = " << (x) << endl
#define DEBUG(x) cerr << #x << " = " << (x) << " (l" << __LINE__ << ")" << " " << __FILE__ << endl
#define MAX_VALUE 9223372036854775807
template<class Integer>
class BinaryIndexedTree
{
private:
ull maxSize_;
vector<Integer> values_;
public:
BinaryIndexedTree(ull maxSize) : maxSize_(maxSize), values_(maxSize_, 0) {}
void update(ll index, Integer increment)
{
if (maxSize_ <= index)
{
throw invalid_argument("Index should be less than maxSize.");
}
++index;
while (index <= maxSize_)
{
values_[index - 1] += increment;
index += index & -index;
}
}
Integer query(ll index)
{
if (maxSize_ <= index)
{
throw invalid_argument("Index should be less than maxSize.");
}
++index;
Integer res = 0;
while (index > 0)
{
res += values_[index - 1];
index -= index & -index;
}
return res;
}
};
using bit = BinaryIndexedTree<ll>;
int solve() {
ll n, q;
cin >> n >> q;
vector<ll> as(n);
vector<tuple<ll, ll, ll>> rlis;
ll l, r;
REPD(i, 0, n) cin >> as[i];
REPD(i, 0, q){
cin >> l >> r;
--l, --r;
rlis.emplace_back(r, l, i);
}
sort(rlis.begin(), rlis.end());
bit counters(n);
map<ll, ll> color_to_max_idx;
vector<ll> results(q);
ll idx, curr_r = 0;
REPD(i, 0, q) {
tie(r, l, idx) = rlis[i];
while(curr_r <= r) {
counters.update(curr_r, 1LL);
if (color_to_max_idx.count(as[curr_r]) != 0LL) {
counters.update(color_to_max_idx[as[curr_r]], -1LL);
}
color_to_max_idx[as[curr_r]] = curr_r;
++curr_r;
}
results[idx] = counters.query(r) - (l > 0LL ? counters.query(l - 1LL) : 0LL);
}
REPD(i, 0, q) cout << results[i] << endl;
return 0;
}
//main function
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
solve();
// ll t;
// cin >> t;
// REPD(i, 0, t) solve();
return 0;
}
| //
// main.cpp
//
#include <algorithm>
#include <array>
#include <assert.h>
#include <complex>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <memory>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = int64_t;
using ull = uint64_t;
[[maybe_unused]] constexpr ll LL_MAX = numeric_limits<ll>::max();
[[maybe_unused]] constexpr ll LL_MIN = numeric_limits<ll>::min();
[[maybe_unused]] constexpr ull ULL_MAX = numeric_limits<ull>::max();
#define rep(i, a, b) for (ll i = (a); i < (b); i++)
#define rrep(i, a, b) for (ll i = (a)-1; i >= (b); i--)
template <typename T>
void chmin(T& x, T y) {
x = min(x, y);
}
template <typename T>
void chmax(T& x, T y) {
x = max(x, y);
}
ll csum(ll x, ll y) {
if (x > 0 && y > 0 && x > LL_MAX - y) {
return LL_MAX;
}
if (x < 0 && y < 0 && x < LL_MIN - y) {
return LL_MIN;
}
return x + y;
}
template<typename T>
vector<T> make_vec_nd(T init, ll size) {
return vector<T>(size, init);
}
template<typename T, typename... Args>
auto make_vec_nd(T init, ll size, Args... rest) {
auto inner = make_vec_nd(init, rest...);
return vector<decltype(inner)>(size, inner);
}
int main() {
ll N, K;
cin >> N >> K;
vector<ll> A(N);
rep(i,0,N) {
cin >> A[i];
}
rep(k,0,K) {
vector<ll> diff(N+1);
rep(i,0,N) {
ll add = i - A[i];
ll subtract = i + 1 + A[i];
auto clamp = [N](ll x){
return min(N, max((ll)0, x));
};
add = clamp(add);
subtract = clamp(subtract);
diff[add] += 1;
diff[subtract] -= 1;
}
ll val = 0;
bool all_N = true;
rep(i,0,N) {
val += diff[i];
A[i] = val;
if (A[i] != N) {
all_N = false;
}
}
if (all_N) {
break;
}
}
rep(i,0,N) {
cout << A[i];
if (i != N-1) {
cout << " ";
}
}
cout << endl;
}
/*
6 100
0 0 0 0 0 0 0
*/
| 0 |
#include <bits/stdc++.h>
#include <iostream>
#include <math.h> //pow(x,y)=x^y 99999とかの場合+1するif文
#include <algorithm> //sort(a.begin(), a.end());reverse(a.begin(), a.end());
#include <ctime> //実行時間を測る
#define ll long long
#define vecvec(h,w,name) vector<vector<ll>> name(h, vector<ll>(w));
#define rep(init, i, n) for (ll i = init; i < (n); i++)
#define rev(s) reverse(s.begin(), s.end())
#define sor(v) sort(v.begin(), v.end())
#define PI 3.14159265358979323846264338327950L
//コード自動整形 Shift + Option + F @vscode
//変数名一括置換 command+fn+f2 @vscode
using namespace std;
using vec = vector<ll>;
//function
ll facctorialMethod(ll k); //階乗を出力する
ll modpow(ll a, ll n, ll mod); // a^n mod を計算する
//
//struct
// UnionFind
// coding: https://youtu.be/TdR816rqc3s?t=726
// comment: https://youtu.be/TdR816rqc3s?t=6822
struct UnionFind
{
vector<ll> d;
UnionFind(ll n = 0) : d(n, -1) {}
ll find(ll x)
{ //根っこを返す
if (d[x] < 0)
return x;
return d[x] = find(d[x]); //根っこの場所を貼り付ける
}
bool unite(ll x, ll y)
{ //くっつける操作、連結成分の情報整理 ABC177,157D参照
x = find(x);
y = find(y);
if (x == y)
return false;
if (d[x] > d[y])
swap(x, y); //dはマイナスをかけたサイズだからxの方がサイズ小さいようにする
d[x] += d[y];
d[y] = x;
return true;
}
bool same(ll x, ll y) { return find(x) == find(y); } //同じ集合に属しているかを判定
ll size(ll x) { return -d[find(x)]; } //あるID、xが所属するグループに所属するIDの数を得る ABC177,157D参照
};
//
/////main/////
int main()
{
int clock_on = 0; //提出時は0!!!!!!!!!!!!!!!!!
int time_clock = clock();
//
ll a,b;
cin>>a>>b;
cout<<a*b<<endl;
//
if (clock_on == 1)
printf("Execution Time: %.4lf sec\n", 1.0 * (clock() - time_clock) / CLOCKS_PER_SEC);
return 0;
}
/////main/////
/////function/////
//階乗を出力する
ll facctorialMethod(ll k)
{
ll sum = 1;
for (ll i = 1; i <= k; ++i)
{
sum *= i;
}
return sum;
}
// a^n mod を計算する
ll modpow(ll a, ll n, ll mod)
{
ll res = 1;
while (n > 0)
{
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
} | #include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for (int i = 0; i < (int)n; i++)
int main() {
int n, r;
cin >> n >> r;
if (n >= 10) cout << r << endl;
else cout << r + (100 * (10 - n)) << endl;
}
| 0 |
#include <bits/stdc++.h>
#include<ext/pb_ds/hash_policy.hpp>
#include<ext/pb_ds/assoc_container.hpp>
#define N 200005
using namespace __gnu_pbds;
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
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);
}
};
LL z = 1;
int read(){
int x, f = 1;
char ch;
while(ch = getchar(), ch < '0' || ch > '9') if(ch == '-') f = -1;
x = ch - '0';
while(ch = getchar(), ch >= '0' && ch <= '9') x = x * 10 + ch - 48;
return x * f;
}
int ksm(int a, int b, int p){
int s = 1;
while(b){
if(b & 1) s = z * s * a % p;
a = z * a * a % p;
b >>= 1;
}
return s;
}
LL s[N];
int main(){
int i, j, n, m, x, y;
LL s1, s2, s3, s4, ans = 1e18, a, b;
n = read();
for(i = 1; i <= n; i++) s[i] = s[i - 1] + read();
x = 1, y = 3;
for(i = 2; i <= n - 2; i++){
while(x + 1 < i && abs(s[i] - s[x] - s[x]) > abs(s[i] - s[x + 1] - s[x + 1])) x++;
while(y + 1 < n && abs(s[n] - s[y] - (s[y] - s[i])) > abs(s[n] - s[y + 1] - (s[y + 1] - s[i]))) y++;
s1 = s[x], s2 = s[i] - s[x];
s3 = s[y] - s[i], s4 = s[n] - s[y];
a = max(s1, s2); a = max(a, max(s3, s4));
b = min(s1, s2); b = min(b, min(s3, s4));
ans = min(ans, a - b);
}
printf("%lld", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
static const long long MOD=1000000007;
int main(){
int N,temp;
cin >> N;
int c1,c2,c3;
c1=0;
c2=0;
c3=0;
long long ans=1;
for(int i=0;i<N;i++){
int cnt=0;
int flag=-1;
cin>>temp;
if(c1==temp){
cnt++;
flag=1;
}
if(c2==temp){
cnt++;
flag=2;
}
if(c3==temp){
cnt++;
flag=3;
}
ans=ans*cnt%MOD;
if(flag==1){
c1++;
}
if(flag==2){
c2++;
}
if(flag==3){
c3++;
}
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <iostream>
using namespace std;
int main(){
int n;
while(cin >> n, n){
int a[5000], ans = -100001;
for(int i = 0; i < n; i++) cin >> a[i];
for(int i = 0; i < n; i++){
int sum = 0;
for(int j = i; j < n; j++){
sum += a[j];
ans = max(ans, sum);
}
}
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef complex<double> P;
typedef pair<int,int> pii;
#define REP(i,n) for(ll i=0;i<n;++i)
#define REPR(i,n) for(ll i=1;i<n;++i)
#define FOR(i,a,b) for(ll i=a;i<b;++i)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define DEBUG_VEC(v) cout<<#v<<":";REP(i,v.size())cout<<" "<<v[i];cout<<endl
#define ALL(a) (a).begin(),(a).end()
#define MOD (ll)(1e9+7)
#define ADD(a,b) a=((a)+(b))%MOD
#define FIX(a) ((a)%MOD+MOD)%MOD
double dot(P a,P b){return real(conj(a)*b);};
double cross(P a,P b){return imag(conj(a)*b);};
int main(){
int n;
while(~scanf("%d",&n)){
if(n==0)break;
ll cur;
cin>>cur;
ll mx = cur;
while(--n){
ll x;
cin>>x;
cur = max(x,cur+x);
mx = max(mx,cur);
}
cout<<mx<<endl;
}
return 0;
} | 1 |
#include <stdio.h>
#include <string.h>
int main() {
char angka[10];
scanf("%s", &angka);
int ada = 0;
for(int i = 0 ; i < strlen(angka); i++) {
if (angka[i] == '7'){
ada = 1;
}
}
if (ada ==1){
printf("Yes");
}
else {
printf("No");
}
puts(" ");
return 0;
} | #include <stdio.h>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main()
{
int N;
cin >> N;
if (N % 10 == 7 ||
(N/10) % 10 == 7 ||
(N/100) % 10 == 7){
cout << "Yes" << endl;
}
else {
cout << "No" << 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
#define all(x) (x).begin(),(x).end()
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b;return true;}return false;}
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int main() {
int N;
cin >> N;
cout << N /3 << endl;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
#define all(x) (x).begin(),(x).end()
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b;return true;}return false;}
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const int INF = 1000000000;
int main() {
string s;
cin >> s;
if (s.size() == 2)cout << s << endl;
else {
reverse(all(s));
cout << s << endl;
}
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define repit(itr,x) for(auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr,x) for(auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
int main(){
int n, m;
cin >> n >> m;
n = 2*m+1;
vector<pair<int, int>> ans;
int r;
if(m % 2 == 0) r = m+1;
else r = m;
rep(i, m/2){
ans.push_back(make_pair(i+1, r-i));
}
int l;
l = r+1;
rep(i, (m+1)/2){
ans.push_back(make_pair(l+i, n-i));
}
rep(i, m){
cout << ans.at(i).first << " " << ans.at(i).second << endl;
}
return 0;
} | #include <cstdio>
#include <algorithm>
using namespace std;
const int MAXN = 3000;
const int MAXM = MAXN*MAXN;
const int MOD = int(1E9) + 7;
int pow_mod(int b, int p) {
int ret = 1;
for(int i=p;i;i>>=1,b=1LL*b*b%MOD)
if( i & 1 ) ret = 1LL*ret*b%MOD;
return ret;
}
int fct[MAXM + 5], ifct[MAXM + 5];
int comb(int n, int m) {
return 1LL*fct[n]*ifct[m]%MOD*ifct[n-m]%MOD;
}
void init() {
fct[0] = 1;
for(int i=1;i<=MAXM;i++)
fct[i] = 1LL*fct[i-1]*i%MOD;
ifct[MAXM] = pow_mod(fct[MAXM], MOD - 2);
for(int i=MAXM-1;i>=0;i--)
ifct[i] = 1LL*ifct[i+1]*(i+1)%MOD;
}
int f[MAXN + 5][MAXN + 5];
int main() {
init();
int N, K; scanf("%d%d", &N, &K);
if( K == 1 ) {
puts("1");
return 0;
}
for(int i=1;i<=N;i++) f[1][i] = 1;
for(int i=2;i<=N;i++) {
for(int j=1;j<=i;j++) {
int m = (K - 1)*(i - 1) + j, n = K - 2;
f[i][j] = 1LL*f[i-1][j]*comb(n+m-1, n)%MOD;
}
for(int j=1;j<=N;j++)
f[i][j] = (f[i][j] + f[i][j-1]) % MOD;
}
printf("%lld\n", 1LL*f[N][N]*fct[N]%MOD);
} | 0 |
#include <iostream>
#include<algorithm>
using namespace std;
//upper_bound, lower_boundを用いた
//のになぜか通らない・・・
int main(){
int n;
long long a;
if(scanf("%d", &n)==EOF){return 0;}
long long top[n];
long long center[n];
long long down[n];
for(int i = 0; i<n; i++){if(scanf("%lld", &a)==EOF){return 0;} top[i] = a;}
for(int i = 0; i<n; i++){if(scanf("%lld", &a)==EOF){return 0;} center[i] = a;}
for(int i = 0; i<n; i++){if(scanf("%lld", &a)==EOF){return 0;} down[i] = a;}
// top, downをソート
sort(top, top+n);
sort(down, down+n);
//for(int i = 0; i<n; i++){cout << top[i] << ", "<<endl;}
//for(int i = 0; i<n; i++){cout << down[i] << ", "<<endl;}
long long sum = 0;
//int ok1, ng1, ok2, ng2, mid;
int ok1, ok2;
for(int i = 0; i< n; i++){
//center[i]より小さいtopの数を探す
ok1 = lower_bound(top, top+n, center[i]) - top;
ok2 = upper_bound(down, down+n, center[i]) - down;
//cout << "top[ok1-1]" << top[ok1-1] << ", center:"<< center[i] <<", top[ok1]:"<< top[ok1] << endl;
//cout << "down[ok2-1]:" << down[ok2-1] <<", center:"<< center[i] <<", down[ok2]:" << down[ok2] << endl;
sum += (long long)ok1 * (long long)(n - ok2);
}
cout << sum << endl;
return 0;
} | #include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<sstream>
#include<cmath>
#include<numeric>
#include<map>
#include<stack>
#include<queue>
#include<list>
using namespace std;
int inf = 1000000000;
int main(void) {
vector<int> l(10);
vector<int> v(2);
while( scanf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d", &l[0], &l[1], &l[2], &l[3], &l[4], &l[5], &l[6], &l[7], &l[8], &l[9], &v[0], &v[1])!= EOF ){
int sum = accumulate(l.begin(), l.end(), 0);
// cerr << sum << " ";
double tmp = sum * v[0] * 1.0 / (v[0]+v[1]);
// cerr << tmp << endl;
for(int i=1; i<10; i++) l[i] += l[i-1];
// int a = 0;
for(int i=1; i<10; i++){
if( l[i-1] == tmp ){
cout << i << endl;
break;
}else if( l[i-1] < tmp && tmp < l[i] ){
// cerr << l[i-1] << " " << l[i] << endl;
cout << i+1 << endl;
// break;
}
}
}
return 0;
}
// EOF | 0 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
long long fpb(long long x, long long y) {
return (y == 0) ? x : fpb(y, x % y);
}
long long kpk(long long x, long long y) {
return x * (y / fpb(x, y));
}
bool cmp(long long a,long long b)
{
return a>b;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
ll n;
cin>>n;
vector <char> ans;
char temp;
while(n>0){
n--;
temp='a'+n%26;
//cout<<temp<<endl;
ans.push_back(temp);
n/=26;
}
reverse(ans.begin(),ans.end());
for(int i=0;i<ans.size();i++){
cout<<ans[i];
}
cout<<endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
typedef vector<vector<int>> vv;
typedef pair<int, int> P;
// input
int N, K;
void input() {
cin >> N >> K;
}
int main() {
input();
int ans = 1;
rep(i, N) {
if (ans < K) ans *= 2;
else ans += K;
}
cout << ans << endl;
}
| 0 |
#include<cstdio>
#include<vector>
#include<algorithm>
#include<iostream>
#include<string>
using namespace std;
const double EPS=1e-8;
struct data{
double b;string Name;
data(double b_,string Name_):b(b_),Name(Name_){}
data(){}
bool operator<(const data &d)const{
return (b-d.b<EPS&&b-d.b>-EPS)?Name>d.Name:b<d.b;
}
};
int main(){
int n;
while(cin>>n,n){
vector<data>V;
for(int i=0;i<n;i++){
string l;
int p,a,b,c,d,e,f,s,m;
cin>>l>>p>>a>>b>>c>>d>>e>>f>>s>>m;
int t=a+b+c+(d+e)*m;
int val=f*s*m-p;
V.push_back(data(1.0*val/t,l));
}
sort(V.rbegin(),V.rend());
for(int i=0;i<n;i++){
cout<<V[i].Name<<endl;
}
cout<<"#"<<endl;
}
return 0;
} | #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
const ld eps=1e-9;
//// < "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\a.txt"
int main() {
while (1) {
int N; cin >> N;
if (!N)break;
map<int, long long int>mp;
vector<int>vs;
for (int i = 0; i < N; ++i) {
long long int a, b, c; cin >> a >> b >> c;
mp[a] += b*c;
if (find(vs.begin(), vs.end(), a) == vs.end())vs.emplace_back(a);
}
bool flag = false;
for (auto v : vs) {
if (mp[v] >= 1000000) {
cout << v << endl;
flag = true;
}
}
if (!flag)cout << "NA" << endl;
}
return 0;
}
| 0 |
#include <cstdio>
#include <cstdlib>
#include <cstdint>
#include <cstring>
#include <cctype>
#include <iostream>
#include <sstream>
#include <vector>
#include <list>
#include <deque>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <functional>
#include <complex>
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef long long ll;
const double PI = 3.141592653589793238462643383279502884L;
const int LARGE_PRIME = 1000000007;
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define tr(c, i) for(auto i = (c).begin(); i != (c).end(); i++)
#define rtr(c, i) for(auto i = (c).rbegin(); i != (c).rend(); i++)
#define repfn(i,a,cont,next) \
for(auto i = (a); [=](){return(cont);}(); i = [=](){return(next);}())
#define repby(i,a,b,s) repfn(i,a,i<b,i+s)
#define repab(i,a,b) repby(i,a,b,1)
#define rep(i,b) repab(i,0,b)
#define pb push_back
#define sz(c) int((c).size())
int main(int argc, char **argv)
{
for (;;) {
int n;
vi v;
cin >> n;
if (!n)
break;
while (n--) {
int tmp;
cin >> tmp;
v.pb(tmp);
}
vi w(v);
for (int i = 1; i < sz(v); i++) {
v[i] = max(v[i-1] + v[i], v[i]);
}
cout << *max_element(all(v)) << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for(int i = 0;i < (n);i++)
#define FOR(i, a, b) for(int i = (a);i < (b);i++)
#define all(x) x.begin(),x.end()
#define fs first
#define sc second
using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;
const double eps = 1e-6;
template<typename A, typename B>inline void chmin(A &a, B b){if(a > b) a = b;}
template<typename A, typename B>inline void chmax(A &a, B b){if(a < b) a = b;}
const int64 mod = 1e9+7;
int main(void){
int32 N, Q;
while(cin >> N >> Q && N+Q){
map<int32, int32> cnt;
REP(i, N){
int32 M;
cin >> M;
REP(j, M){
int32 x;
cin >> x;
cnt[x]++;
}
}
int32 res = 0;
for(auto x : cnt){
if(x.sc >= Q && cnt[res] < x.sc){
res = x.fs;
}
}
cout << res << endl;
}
}
| 0 |
#include <iostream>
using namespace std;
int main() {
int X, Y;
cin >> X >> Y;
if (X < 9 && Y <9){
cout << "Yay!" << endl;
return 0;
}
cout << ":(" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
string s;
int k, is;
cin >> k >> s;
is = s.size();
if(k >= is){
cout << s << endl;
}
else{
for(int i = 0; i < k; i++){
cout << s.at(i);
}
cout << "..." << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
long long n,q;
cin >> n >> q;
long long s[n],t[n],x[n],d[q];
pair<long long, int> p[n];
for(int i=0;i<n;i++){
cin >> s[i] >> t[i] >> x[i];
p[i]=make_pair(x[i], i);
}
sort(p, p+n);
vector<pair<long long, int> > vec;
bool active[n];
for(int i=0;i<n;i++){
vec.push_back(make_pair(s[p[i].second]-x[p[i].second]-1, i));
vec.push_back(make_pair(t[p[i].second]-x[p[i].second]-1, i));
active[i]=false;
}
for(int i=0;i<q;i++){
cin >> d[i];
vec.push_back(make_pair(d[i], -1));
}
sort(vec.begin(), vec.end());
priority_queue<int, vector<int>, greater<int> > que;
for(size_t i=0;i<vec.size();i++){
if(vec[i].second == -1){
if(!que.empty()){
cout << p[que.top()].first << endl;
}else{
cout << -1 << endl;
}
}else{
long long idx = vec[i].second;
if(active[idx]){ //工事終了
active[idx] = false;
if(idx == que.top()){
que.pop();
while(!que.empty()){
if(active[que.top()]){
break;
}else{
que.pop();
}
}
}
}else{ //工事開始
active[idx] = true;
que.push(idx);
}
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template<typename T>
void out(T x) { cout << x << endl; exit(0); }
#define watch(x) cout << (#x) << " is " << (x) << endl
typedef long long ll;
const ll mod = 1e9+7;
const int maxn = 1e6 + 5;
int n,q;
map<int,vector<pair<int,int>>> mp;
int ans[maxn];
int main() {
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin>>n>>q;
for (int i=0; i<n; i++) {
int s,e,x; cin>>s>>e>>x;
mp[x].emplace_back(s,e);
}
for (auto& p: mp) sort(p.second.begin(), p.second.end());
vector<int> v(q);
for (auto& x: v) cin>>x;
set<pair<int,int>> active;
for (int i=0; i<q; i++) {
active.insert({v[i],i});
}
for (auto p: mp) {
int x = p.first;
for (auto cur: p.second) {
int s = cur.first; int e = cur.second;
for (auto iter = active.lower_bound({s-x,0}); iter != active.end() && iter->first < e-x; ) {
int id = iter->second;
ans[id] = x;
iter = active.erase(iter);
}
}
}
for (auto p: active) {
ans[p.second] = -1;
}
for (int i=0; i<q; i++) {
cout<<ans[i]<<"\n";
}
return 0;
}
| 1 |
#include <string>
#include <vector>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <map>
#include <list>
#include <set>
#include <numeric>
#include <queue>
#include <stack>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <climits>
#include <cfloat>
#include <ctime>
#include <complex>
#include <cassert>
#include <array>
#include <bitset>
#include <unordered_map>
#include <random>
using namespace std;
typedef long long LL;
typedef pair<int,int> P;
int c[2][600][600];
int D[2];
int N;
vector<P> ds;
void dfs(int t[600][600],int i, int j, int v){
if(t[i][j]>=0)return;
t[i][j]=v;
for(P d:ds){
int x=i+d.first;
int y=j+d.second;
if(0<=x&&x<2*N&&
0<=y&&y<2*N){
dfs(t,x,y,v^1);
}
}
}
int main() {
cin >> N >> D[0] >> D[1];
memset(c,-1,sizeof(c));
for(int i=0;i<2;i++){
ds.clear();
for(int k=0;k*k<=D[i];k++){
int v=(int)(sqrt(D[i]-k*k)+0.5);
if(v*v+k*k==D[i]){
//cerr << k << ", " << v << endl;
ds.push_back(P(k,v));
ds.push_back(P(k,-v));
ds.push_back(P(-k,v));
ds.push_back(P(-k,-v));
}
}
for(int x=0;x<2*N;x++){
for(int y=0;y<2*N;y++){
if(c[i][x][y]==-1){
dfs(c[i],x,y,0);
}
//cerr << c[i][x][y];
}
//cerr << endl;
}
//cerr << endl;
}
vector<P> ret[2][2];
for(int x=0;x<2*N;x++){
for(int y=0;y<2*N;y++){
auto& r=ret[c[0][x][y]][c[1][x][y]];
r.push_back(P(x,y));
if(r.size()==N*N){
for(auto p:r){
cout << p.first << " " << p.second << endl;
}
return 0;
}
}
}
return 0;
}
| #include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <iomanip>
#include <utility>
#include <tuple>
#include <functional>
#include <bitset>
#include <cassert>
#include <complex>
#include <stdio.h>
#include <time.h>
#include <numeric>
#include <random>
#include <unordered_map>
#include <unordered_set>
#define all(a) a.begin(),a.end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pb push_back
#define debug(x) cerr << #x << ':' << x << '\n'
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> P;
typedef complex<ld> com;
constexpr int inf = 1000000010;
constexpr ll INF = 1000000000000000010;
constexpr ld eps = 1e-12;
constexpr ld pi = 3.141592653589793238;
template<class T, class U> inline bool chmax(T &a, const U &b) { if (a < b) { a = b; return true; } return false; }
template<class T, class U> inline bool chmin(T &a, const U &b) { if (a > b) { a = b; return true; } return false; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int n;
cin >> n;
n *= 2;
vector<vector<int>> a(n, vector<int>(n));
for (int z = 1; z <= 2; z++) {
int d;
cin >> d;
int sz = 1;
while (d % 4 == 0) {
d >>= 2; sz <<= 1;
}
if (d % 4 == 1) rep(i, n) rep(j, n) if (i % (2 * sz) < sz && j % (2 * sz) < sz || i % (2 * sz) >= sz && j % (2 * sz) >= sz) a[i][j] += z;
if (d % 4 == 2) rep(i, n) rep(j, n) if (i % (2 * sz) < sz) a[i][j] += z;
}
vector<int> cnt(4);
rep(i, n) rep(j, n) cnt[a[i][j]]++;
int tmp = 0; int use = 0;
rep(i, 4) if (chmax(tmp, cnt[i])) use = i;
int q = n * n / 4;
rep(i, n) {
rep(j, n) {
if (q == 0) break;
if (a[i][j] == use) {
cout << i << ' ' << j << '\n';
q--;
}
}
}
} | 1 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
using namespace std;
int H, W;
int A[200005], B[200005];
int C[200005];
set<int > S;
int ans[200005];
multiset<int> M;
int p = 0;
int E[200005];
void ADD(int k) {
E[k]++;
}
void DEL(int k) {
E[k]--;
while (E[p] == 0) { p++; }
}
int main(void) {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> H >> W;
for (int i = 1; i <= H; i++) {
cin >> A[i] >> B[i];
}
for (int i = 1; i <= W; i++) { S.insert(i); M.insert(0); /*ADD(0);*/ }
/*if (A[1] == 1 && B[1] == W) { for (int i = 1; i <= H; i++) { cout << -1 << endl; } return 0; }
if (A[1]==1) {}
else if (A[1] == 2) { S.insert(1); M.insert(0); }
else { S.insert(1); M.insert(0); S.insert(A[1] - 1); M.insert(0); }
if (B[1] < W) {
S.insert(B[1] + 1); M.insert(0);
}
ans[1] = 1;*/
for (int i = 1; i <= H; i++) {
//cout << "i= " << i << endl;
//-----------------
auto it = S.upper_bound(B[i] + 1);
//auto it = upper_bound(S.begin(), S.end(), B[i] + 1);
if (it != S.begin()) { --it; }
if (it!=S.end() && *it <= B[i] + 1 && ( B[i]+1<=W)) {
C[B[i] + 1] = C[*it] + B[i] + 1 - (*it);
if (S.find(B[i] + 1) != S.end()) {
auto itr = M.find(C[B[i] + 1]); M.erase(itr);
}
S.insert(B[i] + 1); M.insert(C[B[i] + 1]);
}
//cout << "S: "; for (auto y : S) { cout << " " << y; }cout << endl;
//cout << "M: "; for (auto y : M) { cout << " " << y; }cout << endl;
//--------------------------------------------------------
it = S.upper_bound(A[i] - 1);
//it = upper_bound(S.begin(), S.end(), A[i] - 1);
if (it != S.begin()) { --it; }
if (it!=S.end() && *it <= A[i] - 1 && A[i]-1>=1) {
C[A[i] - 1] = C[*it] + A[i] - 1 - (*it);
if (S.find(A[i] - 1) != S.end()) {
auto itr = M.find(C[A[i]-1]); M.erase(itr);
}
S.insert(A[i] - 1); M.insert(C[A[i] - 1]);
}
//cout << "S: "; for (auto y : S) { cout << " " << y; }cout << endl;
//cout << "M: "; for (auto y : M) { cout << " " << y; }cout << endl;
//--------------------------------
it = S.lower_bound(A[i]);
//it = lower_bound(S.begin(), S.end(), A[i]);
while (it!=S.end() && *it <= B[i]) {
auto itr = M.find(C[*it]); //cout << *itr << " 消去" << endl;
M.erase(itr);
//DEL(C[*it]);
S.erase(it++);
}
//cout << "S: "; for (auto y : S) { cout << " " << y; }cout << endl;
//cout << "M: "; for (auto y : M) { cout << " " << y; }cout << endl;
//cout << "i= " << i << endl;
//cout << "E:"; for (int i = 0; i <= 10; i++) { cout << " " << E[i]; } cout << " p= " << p << endl;
if (S.size() == 0) { ans[i] = -1; }
else { ans[i] = i + *M.begin()/*p*/; }
}
for (int i = 1; i <= H; i++) {
printf("%d\n", ans[i]);
//cout << ans[i] << endl;
}
return 0;
} | #include <iostream>
#ifdef MBP
#include "stdc++.h"
#else
#include <bits/stdc++.h>
#endif
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define REP(i, n) for (long long int i = 0, i##_len = (n); i < i##_len; ++i)
#define REP_R(i, n) for (long long int i = (n - 1); i >= 0; --i)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((long long int)(x).size())
#define BIT(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define INF INT_MAX
#define INFLL LLONG_MAX
#define PB push_back
#define MOD 1000000007LL
#define LSB(x) __builtin_ctzll(x)
#define MSB(x) 64LL - __builtin_clzll(x) - 1LL
#define MSBINT(x) 32LL - __builtin_clz(x)
#define BITCNT(x) __builtin_popcountll(x)
using namespace std;
using uif = uint_fast64_t;
using ll = long long int;
using vec = vector<ll>;
using mat = vector<vector<ll>>;
using pa = pair<ll, ll>;
using tTree = __gnu_pbds::tree<ll, __gnu_pbds::null_type, less<ll>, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update>;
template <class T>
using PQ = priority_queue<T>;
template <class T>
using PQG = priority_queue<T, vector<T>, greater<T>>;
const ll dx[4] = {1, 0, -1, 0};
const ll dy[4] = {0, 1, 0, -1};
const ll dx8[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
template <class T>
bool chmax(T &, const T &);
template <class T>
bool chmin(T &, const T &);
ll qp(ll a, ll b);
ll qp(ll a, ll b, ll mo);
ll mod_pow(ll, ll);
ll mod_add(ll, ll);
ll mod_mul(ll, ll);
ll mod_div(ll, ll);
void make_fact(ll);
void make_invfact(ll);
void init_fact();
ll combination(ll, ll);
#define FACSIZE 200002LL
ll invfac[FACSIZE];
ll fac[FACSIZE];
pa pos(ll x)
{
pa p;
p.first = (x / 49) * 2 + 1;
p.second = (x % 49) * 2 + 1;
return p;
}
int main(void)
{
ll a, b;
cin >> a >> b;
mat field(100, vec(100, 0));
REP(i, 50)
REP(j, 100)
field[i][j] = 1;
REP(i, a - 1)
{
auto p = pos(i);
field[p.first][p.second] = 0;
}
REP(i, b - 1)
{
auto p = pos(i);
field[p.first + 50][p.second] = 1;
}
cout << 100 << " " << 100 << endl;
REP(i, 100)
{
REP(j, 100)
{
auto x = field[i][j];
if (x == 1)
{
cout << '#';
}
else
{
cout << '.';
}
}
cout << endl;
}
return 0;
}
template <class T>
bool chmax(T &a, const T &b)
{
if (a < b)
{
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b)
{
if (b < a)
{
a = b;
return 1;
}
return 0;
}
ll qp(ll a, ll b)
{
ll ans = 1LL;
do
{
if (b & 1LL)
ans = 1LL * mod_mul(ans, a) % MOD;
a = 1LL * mod_mul(a, a) % MOD;
} while (b >>= 1LL);
return ans;
}
ll qp(ll a, ll b, ll mo)
{
ll ans = 1LL;
do
{
if (b & 1LL)
ans = 1LL * (ans % mo) * (a % mo);
a = 1LL * (a % mo) * (a % mo);
} while (b >>= 1LL);
return ans;
}
ll mod_pow(ll x, ll r)
{
if (r == 0)
return 1;
else if (r == 1)
return x % MOD;
else if (r % 2 == 0)
{
ll t = mod_pow(x, r / 2) % MOD;
return t * t % MOD;
}
else
{
ll t = mod_pow(x, r / 2) % MOD;
ll k = t * t % MOD;
return k * x % MOD;
}
}
ll mod_add(ll a, ll b)
{
return (a + b) % MOD;
}
ll mod_mul(ll a, ll b)
{
return (a * b) % MOD;
}
ll mod_div(ll a, ll b)
{
return mod_mul(a, mod_pow(b, MOD - 2));
}
void make_fact(ll n)
{
fac[0] = 1;
REP(i, n)
{
fac[i + 1] = mod_mul(fac[i], i + 1);
}
}
void make_invfact(ll n)
{
invfac[n] = mod_pow(fac[n], MOD - 2);
REP_R(i, n)
{
invfac[i] = mod_mul(invfac[i + 1], i + 1);
}
}
void init_fact()
{
make_fact(FACSIZE - 1);
make_invfact(FACSIZE - 1);
}
ll combination(ll n, ll c)
{
return mod_mul(fac[n], mod_mul(invfac[c], invfac[n - c]));
}
///////////////fact
/*
init_fact();
cout << fac[5] << endl;
cout << invfac[5] << endl;
cout << combination(8, 4) << endl;
cout << combination(31, 8) << endl;
//*/
///////////////////
| 0 |
#include <iostream>
#include <functional>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <set>
#include <queue>
#include <map>
#include <iomanip>
#include <complex>
#include <random>
#include <bitset>
#include <list>
// #include <prettyprint.hpp>
using namespace std;
#define repi(i,n) for(int i=0;i<n;++i)
#define rep(i,n) for(ll i=0;i<n;++i)
#define repinvi(i,n) for(int i=n-1;i>=0;--i)
#define sll(n) scanf("%lld", &n);
#define sii(n) scanf("%d", &n);
#define slf(n) scanf("%lf", &n);
#define pll pair<ll,ll>
#define pii pair<int,int>
#define psi pair<si,si>
typedef long long ll;
typedef double lf;
typedef short int si;
void Main(){
ll N, l;
sll(N);
// vector<ll> ls(N, 0);
map<ll, ll> counter;
rep(i, N){
sll(l);
counter[l] ++;
}
ll ans = 0;
for(auto p1:counter){
for(auto p2:counter){
if(p1.first >= p2.first){
continue;
}
for(auto p3:counter){
if(p1.first >= p3.first){
continue;
}else if(p2.first >= p3.first){
continue;
}
if(p3.first >= p1.first + p2.first){
continue;
}
ans += (p1.second * p2.second * p3.second);
}
}
}
cout << ans <<endl;
}
int main(){
Main();
} | #include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(false); cin.tie(0);
#define st first
#define nd second
#define endl '\n' //toggle off for interactive problems
#define what_is(x) cerr << #x << " is " << x << endl;
#define what_is_v(x) cerr << #x << " is "; for(auto&e: (x)) cerr << e << ' '; cerr << '\n'; //vector, set
#define what_is_a(x, n) cerr << #x << " is "; for(int i=0;i<n;i++) cerr << x[i] << ' '; cerr << '\n'; //n first element of array
#define cerr_pair(x) '{' << x.st << ", " << x.nd << '}'
#define pwhat_is(x) cerr << #x << " is " << cerr_pair(x) << endl;
#define pwhat_is_v(x) cerr << #x << " is "; for(auto&e: (x)) cerr << cerr_pair(e) << ' '; cerr << '\n'; //vector, set
#define pwhat_is_a(x, n) cerr << #x << " is "; for(int i=0;i<n;i++) cerr << cerr_pair(x[i]) << ' '; cerr << '\n'; //n first element of array
// #define int long long
// #define pow mypow
typedef pair<int,int> pii;
const int N = 1e2+5;
const int INF = 1e9+5;
const int MOD = 1e9+7;
int n, a[N];
int32_t main()
{
IOS
// freopen("input.txt", "r", stdin);
cin >> n;
for(int i=0; i<n; i++) cin >> a[i];
sort(a, a+n);
int ans = 0;
for(int i=0; i<n; i++){
for(int j=i+1; j<n; j++){
for(int k=j+1; k<n; k++){
if (a[i] == a[j] || a[j] == a[k]) continue;
if (a[i] + a[j] > a[k]) ans++;
}
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
int main()
{
int x, y;
cin >> x >> y;
vector<int> dx = {1, 0, -1, 0};
vector<int> dy = {0, -1, 0, 1};
vector<string> board(x);
rep(i, x) cin >> board[i];
rep(i, x)
{
rep(j, y)
{
if (board[i][j] == '#')
{
int cnt = 0;
rep(k, 4)
{
int xx = i + dx[k];
int yy = j + dy[k];
if (0 <= xx && xx < x && 0 <= yy && yy < y && board[xx][yy] == '#')
{
cnt++;
}
}
if (!cnt)
{
cout << "No" << '\n';
return 0;
}
}
}
}
cout << "Yes" << '\n';
return 0;
}
| #include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <sstream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <numeric>
#include <cctype>
#include <tuple>
#include <array>
// BEGIN CUT HERE
#ifdef _MSC_VER
#include <agents.h>
#endif
// END CUT HERE
#define FOR(i, a, b) for(int i = (a); i < (int)(b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ALL(v) begin(v), end(v)
#define REV(v) rbegin(v), rend(v)
#define MEMSET(v, s) memset(v, s, sizeof(v))
#define MP make_pair
#define MT make_tuple
#define X first
#define Y second
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int w, h;
const int N = 20;
int v[N][N];
inline bool in(int x, int y){
return 0 <= x && x < w && 0 <= y && y < h;
}
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
int ans;
void dfs(int i, int x, int y){
if (ans < i) return;
if (i == 10) return;
rep(d, 4){
int nx = x + dx[d], ny = y + dy[d];
if (in(nx, ny) && v[ny][nx] == 1) continue;
while (in(nx, ny) && v[ny][nx] == 0){
nx += dx[d], ny += dy[d];
}
if (!in(nx, ny)) continue;
if (v[ny][nx] == 3){
ans = min(ans, i + 1);
break;
}
else{
v[ny][nx] = 0;
dfs(i + 1, nx - dx[d], ny - dy[d]);
v[ny][nx] = 1;
}
}
}
int main(){
while (cin >> w >> h, w){
rep(i, h) rep(j, w) cin >> v[i][j];
ans = 100;
rep(i, h) rep(j, w) if (v[i][j] == 2) v[i][j] = 0, dfs(0, j, i);
cout << (ans == 100 ? -1 : ans) << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define repd(i,a,b) for (int i=(a);i<(b);i++)
#define rep(i,n) repd(i,0,n)
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
const long long INF = 1LL << 60;
int main()
{
while (true) {
int N;
cin >> N;
long long dp[N+1];
if (N == 0) {
break;
}
rep(i, N+1) dp[i] = 0;
dp[0] = 1;
repd(i, 1, N + 1) {
dp[i] += dp[i-1];
if (i > 1) dp[i] += dp[i-2];
if (i > 2) dp[i] += dp[i-3];
}
int ans = dp[N] / 3650;
if (dp[N] % 3650) ans++;
cout << ans << endl;
}
return 0;
}
| #include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <queue>
#include <map>
using namespace std;
typedef long long ll;
int main()
{
int n;
cin >> n;
vector<int> memo;
while (n)
{
int r = n % (-2);
if (r < 0)
r *= -1;
n = (n - r) / -2;
memo.push_back(r);
if (n == 0)
{
break;
}
}
string ans;
for (int i = memo.size() - 1; i >= 0; i--)
{
ans += to_string(memo[i]);
}
if (ans == "")
ans = "0";
cout << ans << endl;
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <ctime>
#include <cmath>
#include <string>
#include <stdlib.h>
#include <fstream>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <deque>
#include <iterator>
#include <iomanip>
using namespace std;
int main(){
long long n, m;
cin >> n >> m;
vector<long long> a(n), ps(n);
map<long long, long long> mp;
long long ans = 0;
for(int i = 0; i < n; ++i){
cin >> a[i];
ps[i] = a[i];
if(i) ps[i] += ps[i - 1];
ps[i] %= m;
if(!ps[i]) ans++;
ans += mp[ps[i]];
mp[ps[i]]++;
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
using ll = long long;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
ll N,M;
cin>>N>>M;
vector<ll> mo(N);
for(ll i = 0LL; i < N; i++) {
ll x;
cin>>x;
if(i==0LL) mo[i]=x%M;
else mo[i]=(mo[i-1]+x)%M;
}
sort(mo.begin(),mo.end());
ll ans = 0LL;
ll k = 0LL;
for(ll i = 0LL; i < N;i++){
k++;
if(i==N-1LL||mo[i]!=mo[i+1LL]){
if(mo[i]==0LL)ans+=(k+k*(k-1LL)/2LL);
else ans+=(k*(k-1LL)/2LL);
k=0LL;
}
}
cout<<ans<<endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef vector<ll> vl;
typedef vector<string> vs;
typedef vector<char> vc;
typedef queue<ll> ql;
typedef deque<ll> dql;
typedef priority_queue<ll, vl/*, greater<ll>*/> pql; //降順(/*昇順*/)
typedef set<ll> sl;
typedef pair<ll, ll> pl;
typedef vector<vl> vvl;
typedef vector<pl> vpl;
#define rep(i, n) for(ll i = 0; i < ll(n); ++i)
#define rep2(i, n) for(ll i = 1; i <= ll(n); ++i)
//#define rep(i, k, n) for(ll i = k-1; i < ll(n); ++i)
//#define rep2(i, k, n) for(ll i = k; i <= ll(n); ++i)
#define all(v) (v).begin(), (v).end()
bool chmin(ll &a, ll b) {if(b < a) {a = b; return 1;} return 0;}
bool chmax(ll &a, ll b) {if(b > a) {a = b; return 1;} return 0;}
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
//const ll MOD = 998244353;
const ll MAX = 1e9;
const char newl = '\n';
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll a, b, c;
cin >> a >> b >> c;
cout << ((a-c)*(c-b)>=0 ? "Yes" : "No") << newl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(n); i++)
#define reps(i,s,n) for(int i=(s); i<(n); i++)
#define all(v) v.begin(),v.end()
#define outve(v) for(auto i : v) cout << i << " ";cout << endl
#define outmat(v) for(auto i : v){for(auto j : i) cout << j << " ";cout << endl;}
#define in(n,v) for(int i=0; i<(n); i++){cin >> v[i];}
#define out(n) cout << (n) << endl
#define fi first
#define se second
#define pb push_back
#define mod 1000000007
#define infi 1900000000
#define infl 1100000000000000000
#define cyes cout << "Yes" << endl
#define cno cout << "No" << endl
#define csp << " " <<
#define outset(n) cout << fixed << setprecision(n);
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
template<typename T> using ve = vector<T>;
template<typename T> using pq2 = priority_queue<T>;
template<typename T> using pq1 = priority_queue<T,vector<T>,greater<T>>;
int main()
{
int a,b,c;
cin >> a >> b >> c;
if((a < c && c < b)||(b < c && c < a)) cyes;
else cno;
return 0;
}
| 1 |
/*#include <bits/stdc++.h>
#define N 300010
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;
}
int n,D[N][3],F[N],ct[2][2],vis[N];
struct BIT
{
int tree[N];
inline void add(int x,int y)
{
for(;x<=n;x+=x&-x)
tree[x]+=y;
}
inline int query(int x)
{
int ret=0;
for(;x;x-=x&-x)
ret+=tree[x];
return ret;
}
}A[2];
int main()
{
n=read();
for(int i=1;i<=n;i++)
D[i][0]=read();
for(int i=1;i<=n;i++)
D[i][1]=read();
for(int i=1;i<=n;i++)
D[i][2]=read();
for(int i=1;i<=n;i++)
{
int x[3];
x[0]=D[i][0];
x[1]=D[i][1];
x[2]=D[i][2];
sort(x,x+3);
if(x[0]%3!=1)
{
puts("No");
return 0;
}
if(fabs(x[1]-x[0])!=1||fabs(x[2]-x[1])!=1)
{
puts("No");
return 0;
}
F[i]=(D[i][0]>D[i][1]);
}
for(int i=1;i<=n;i++)
{
int rg=(D[i][1]-2)/3+1;
if(rg>n||rg<1||vis[rg])
{
puts("No");
return 0;
}
vis[rg]=1;
if((rg&1)!=(i&1))
{
puts("No");
return 0;
}
if(F[i]!=(abs((rg-i)/2)&1))
ct[1][i&1]++;
ct[0][i&1]+=A[i&1].query(n)-A[i&1].query(rg);
A[i&1].add(rg,1);
}
if(ct[0][1]==ct[1][0]&&ct[0][0]==ct[1][1])
puts("Yes");
else puts("No");
return 0;
}*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cassert>
#include <cctype>
using namespace std;
typedef long long lint;
#define cout cerr
#define ni (next_num<int>())
template<class T>inline T next_num(){
T i=0;char c;
while(!isdigit(c=getchar())&&c!='-');
bool flag=c=='-';
flag?c=getchar():0;
while(i=i*10-'0'+c,isdigit(c=getchar()));
return flag?-i:i;
}
template<class T1,class T2>inline void apmax(T1 &a,const T2 &b){if(a<b)a=b;}
template<class T1,class T2>inline void apmin(T1 &a,const T2 &b){if(b<a)a=b;}
const int N=100010;
namespace B{
int c[N],n;
inline void init(int _n){
memset(c+1,0,(n=_n)<<2);
}
inline void add(int x,int v){
for(;x<=n;c[x]+=v,x+=x&-x);
}
inline int sum(int x){
int ans=0;
for(;x;ans+=c[x],x^=x&-x);
return ans;
}
}
inline bool getrev(int a[],int n,int mx){
B::init(mx);
bool ans=0;
for(int i=n-((n&1)^1);i>=1;i-=2){
ans^=B::sum(a[i])&1;
B::add(a[i],1);
}
return ans;
}
bool vis[N];
int a[3][N],b[N];
inline bool Main(){
int n=ni;
for(int i=0;i<3;i++){
for(int j=1;j<=n;j++){
a[i][j]=ni;
}
}
memset(vis,0,sizeof(vis));
bool revt[2]={false,false};
for(int i=1;i<=n;i++){
if(a[1][i]%3!=2)return false;
b[i]=(a[1][i]+1)/3;
if(vis[b[i]]||((i&1)!=(b[i]&1)))return false;
vis[b[i]]=true;
if(a[0][i]==a[1][i]-1&&a[2][i]==a[1][i]+1){
revt[i&1]^=(((b[i]^i)>>1))&1;
}else if(a[0][i]==a[1][i]+1&&a[2][i]==a[1][i]-1){
revt[i&1]^=((((b[i]^i)>>1))&1)==0;
}else return false;
}
revt[0]^=getrev(b,n,n);
revt[1]^=getrev(b+1,n-1,n);
return !revt[0]&&!revt[1];
}
int main(){
puts(Main()?"Yes":"No");
return 0;
} | #include<bits/stdc++.h>
typedef long long ll;
ll gi(){
ll x=0,f=1;
char ch=getchar();
while(!isdigit(ch))f^=ch=='-',ch=getchar();
while(isdigit(ch))x=x*10+ch-'0',ch=getchar();
return f?x:-x;
}
struct __orz_newbie314159_akioi__{
int m,inv,a[50010],t[50010];
void update(int x){while(x<=m)++t[x],x+=x&-x;}
int query(int x){int r=0;while(x)r+=t[x],x-=x&-x;return r;}
ll rev;
void fuck(){
//1-m -> a
for(int i=m;i;--i)rev+=query(a[i]),update(a[i]);
}
}A[2];
int _a[3][100010];
int main(){
#ifdef XZZSB
freopen("in.in","r",stdin);
freopen("out.out","w",stdout);
#endif
int n=gi();
for(int i=0;i<3;++i)for(int j=1;j<=n;++j)_a[i][j]=gi();
for(int i=1;i<=n;++i){
if(std::max(abs(_a[0][i]-_a[1][i]),abs(_a[1][i]-_a[2][i]))>1)return puts("No"),0;
int col=(std::min(_a[0][i],_a[2][i])-1)/3+1;
if(std::max(_a[0][i],_a[2][i])!=col*3||_a[1][i]!=col*3-1)return puts("No"),0;
if(col-i&1)return puts("No"),0;
A[i&1].inv+=_a[0][i]>_a[2][i];
A[i&1].a[++A[i&1].m]=col+1>>1;
}
A[0].fuck(),A[1].fuck();
if(A[0].rev-A[1].inv&1)return puts("No"),0;
if(A[0].inv-A[1].rev&1)return puts("No"),0;
puts("Yes");
return 0;
}
| 1 |
//
// Created on 2020/05/02.
//
#include <iostream> // cout, endl, cin
#include <string> // string, to_string, stoi
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <math.h>
#include <ios>
#include <iomanip>
#include <numeric>
#define all(x) (x).begin(),(x).end()
typedef long long ll;
using namespace std;
const long long LINF =1e18;
const int INF = 1e9;
int main() {
int n,m;
cin>>n>>m;
vector<pair<int,int>>ans;
if(n % 2 == 1){
for (int i = 1; i <= n / 2; ++i) {
ans.push_back({i,(n+1)-i});
}
for (int j = 0; j < m; ++j) {
cout<<ans[j].first<<" "<<ans[j].second<<endl;
}
}else{
int r,l;
r = 1;
l = n -1;
bool frag = false;
while(r < l){
if(l-r <= n / 2 && !frag){
r ++;
frag = true;
continue;
}
ans.push_back({r,l});
r++;
l--;
}
for (int j = 0; j < m; ++j) {
cout<<ans[j].first<<" "<<ans[j].second<<endl;
}
}
return 0;
}
| #include <cstdio>
const int MAXN = 2e5+5;
int seen[MAXN]{ };
int M, N;
int main() {
scanf(" %d%d", &N, &M);
int lhs = 1;
int rhs = N;
for (int i = 0; i < M; ++i) {
printf("%d %d\n", lhs, rhs);
++lhs;
--rhs;
while (seen[rhs - lhs] ||
seen[N - rhs + lhs] ||
(2*rhs == N + 2*lhs)) --rhs;
seen[rhs - lhs] = true;
seen[N - rhs + lhs] = true;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
ll l, r;
cin >> l >> r;
ll ans = 2018;
if (r - l >= 2 * 2019) {
rep(i, 2019) rep(j, 2019) ans = min(ans, (ll)i * j % 2019);
} else if (r - l >= 2019) {
vector<int> cnt(2019, 0);
for (ll i = l; i <= r; ++i) ++cnt[l % 2019];
rep(i, 2019) rep(j, 2019) {
if (i == j && cnt[i] == 1) continue;
ans = min(ans, (ll)i * j % 2019);
}
} else {
for (ll i = l; i <= r; ++i) {
for (ll j = i + 1; j <= r; ++j) {
ans = min(ans, i * j % 2019);
}
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
#define MOD 1000000007
const int INF = 1LL<<30;
int main(){
ll l,r;
cin>>l>>r;
ll ans=3000;
for(int i=l;i<=min(r,l+3000);i++){
for(int j=i+1;j<=min(r,l+3000);j++){
ll tmp=((i%2019)*(j%2019))%2019;
ans=min(ans,tmp);
}
}
cout<<ans<<endl;
} | 1 |
#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define int long long
using namespace std;
const ll INF = 1e18;
const ll MOD = 998244353;
int basis[100];
int cnt = 0;
void insert(int mask) {
for(int i = 61; i >= 0; i--) {
if(!(mask&(1ll << i))) continue;
if(basis[i] == 0) {
basis[i] = mask;
cnt++;
return;
}
mask ^= basis[i];
}
}
bool check(int mask) {
for(int i = 61; i >= 0; i--) {
if(!(mask&(1ll << i))) continue;
if(!basis[i]) return false;
mask ^= basis[i];
}
return (mask == 0);
}
int32_t main() {
ios::sync_with_stdio(!cin.tie(NULL));
int t;
cin >> t;
while(t--) {
int n;
cin >> n;
memset(basis, 0, sizeof(basis));
cnt = 0;
int arr[n];
for(int i = 0; i < n; i++) cin >> arr[i];
string s;
cin >> s;
bool flag = true;
for(int i = n - 1; i >=0; i--) {
if(s[i] == '0') {
insert(arr[i]);
}
else {
if(!check(arr[i])) {
cout << 1 << "\n";
flag = false;
break;
}
}
}
if(flag)
cout << 0 << "\n";
}
}
| #include<bits/stdc++.h>
using namespace std;
#define REP(i,st,ed) for(register int i=st,i##end=ed;i<=i##end;++i)
#define DREP(i,st,ed) for(register int i=st,i##end=ed;i>=i##end;--i)
typedef long long ll;
template<typename T>inline bool chkmin(T &x,T y){return (y<x)?(x=y,1):0;}
template<typename T>inline bool chkmax(T &x,T y){return (y>x)?(x=y,1):0;}
inline int read(){
int x;
char c;
int f=1;
while((c=getchar())!='-' && (c>'9' || c<'0'));
if(c=='-') f=-1,c=getchar();
x=c^'0';
while((c=getchar())>='0' && c<='9') x=(x<<1)+(x<<3)+(c^'0');
return x*f;
}
inline ll readll(){
ll x;
char c;
int f=1;
while((c=getchar())!='-' && (c>'9' || c<'0'));
if(c=='-') f=-1,c=getchar();
x=c^'0';
while((c=getchar())>='0' && c<='9') x=(x<<1ll)+(x<<3ll)+(c^'0');
return x*f;
}
const int inf=0x3f3f3f3f;
int val[15][15],sum[1<<15],dp[15][1<<15],f[15];
int main(){
int n=read(),m=read();
while(m--){
int x=read()-1,y=read()-1,z=read();
val[x][y]=z,val[y][x]=z;
sum[(1<<x)|(1<<y)]=z;
}
REP(i,0,n-1) REP(j,0,(1<<n)-1) if((1<<i)&j) sum[j]+=sum[j^(1<<i)];
REP(i,0,n-1) REP(j,0,(1<<n)-1) dp[i][j]=-inf;
REP(j,1,(1<<n)-1) if(j&1) dp[0][j]=sum[j];
REP(i,1,(1<<n)-1){
REP(j,0,n-1) f[j]=-inf;
REP(j,0,n-1) if(i&(1<<j)) REP(k,0,n-1) if(val[j][k] && (i&(1<<k))==0) chkmax(f[k],dp[j][i]+val[j][k]);
REP(j,0,n-1) if((i&(1<<j))==0)
for(int cur=i|(1<<j),k=cur;k<=iend;k=(k+1)|cur)
chkmax(dp[j][k],f[j]+sum[k^i]);
}
printf("%d\n",sum[(1<<n)-1]-dp[n-1][(1<<n)-1]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,a,b) for(int i=int(a);i<int(b);++i)
#define SIZE 200005
#define INF 1000000005LL
#define MOD 1000000007
using namespace std;
typedef long long int ll;
typedef pair <int,int> P;
int main(){
int n;
cin >> n;
string s,t;
cin >> s>>t;
for(int i=n;i>=1;i--){
if(t.substr(0,i)==s.substr(n-i,i)){
cout<<2*n-i<<endl;
return 0;
}
}
cout<<2*n<<endl;
return 0;
} | #include <bits/stdc++.h>
#define f(i,j,k) for(int i=j;i<k;i++)
#define f2(i,j,k) for(int i=j;i>k;i--)
using namespace std;
int main(){
long long n,now=0;
cin>>n;
string s,t;
cin>>s>>t;
while(1){
if(s.substr(now,n-now)==t.substr(0,n-now)){
break;
}
now++;
}
cout<<n+now<<endl;
return 0;
}
| 1 |
#include<stdio.h>
int s[10], c[10], n, m;
int main() {
int i, ss, cc;
scanf("%d%d", &n, &m);
for(i = 1; i <= m; ++i) {
scanf("%d%d", &ss, &cc);
if(s[ss]) {
if(c[ss] != cc) {
printf("-1\n");
return 0;
}
}
if(ss == 1 && cc == 0 && n != 1) {
printf("-1\n");
return 0;
}
s[ss] = 1;
c[ss] = cc;
}
for(i = 1; i <= n; ++i) {
if(s[i]) printf("%d", c[i]);
else if(i != 1 || n == 1) printf("0");
else printf("1");
}
puts("");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll=long long;
#define rep(i,n) for (ll i=0; i<n; ++i)
#define all(c) begin(c),end(c)
/*
*/
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
ll N,M; cin>>N>>M;
if(M==0){
if (N==1)
cout<<0<<endl;
if (N==2)
cout<<10<<endl;
if (N==3)
cout<<100<<endl;
return 0;
}
vector<pair<ll,ll>> Z(M,{0,0});
rep(i, M){
ll s,c; cin>>s>>c;
Z[i]={N-s,c};
}
ll end=1;
ll low = 1;
rep(i,N) end *= 10;
low = end/10;
if (low < 10) low = 0;
for(ll i=low; i<=end; i++){
ll a,b,c;
a = i/100;
b = (i/10)%10;
c = i%10;
rep(j,M){
ll z1=Z[j].first, z2=Z[j].second;
if (z1 == 0 && c != z2)
break;
if (z1 == 1 && b != z2)
break;
if (z1 == 2 && a != z2)
break;
if (j==M-1){
cout <<i <<endl;
return 0;
}
}
}
cout <<-1 <<endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
// memo fixed setprecision(20);
using vvll = vector<vector<ll>>;
ll mod =1e9+7;
/*"itob" int to "N"base */ template<typename TypeInt> string itob(const TypeInt v, int base){static const char table[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";string ret;static numeric_limits<TypeInt> t;TypeInt n = v;if (t.is_signed) {if (v < 0) n *= -1;}while (n >= base) {ret += table[n%base];n /= base;}ret += table[n];if (t.is_signed) {if (v < 0 && base == 10) ret += '-';}reverse(ret.begin(), ret.end());return ret;}
/*"chmin" a = MAX*/ template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
/*"chmax" a = MIN*/ template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
/*"ctoi" char to int*/ int ctoi(char c) {return c-'0';}
/*"gcd" MAX Euclidean */ ll gcd(ll a,ll b){if(b==0)return a; return gcd(b,a%b);}
/*"lcm" MIN*/ ll lcm(ll a,ll b){ll g = gcd(a,b);return a/g*b;}
/*"primecheck"If prime,return true.*/bool primecheck(ll n){if(n < 2) return false;else{for(int i = 2; i * i <= n; i++){if(n % i == 0) return false;}return true;}}
string reverserange(string s,ll a,ll b){reverse(s.begin()+a-1,s.begin()+b); return s;}
ll modpow(ll a,ll n, ll mod){ll res = 1;while(n>0){if (n%2==1){res = res * a % mod;}a = a * a % mod;n/=2;}return res;}
int main() {
int a;
cin >>a ;
if(a==1){
cout<<"Hello World"<<endl;
return 0;
}
int b,bb;
cin >>b>>bb;
b+=bb;
cout<<b<<endl;
}
| #include <bits/stdc++.h>
#define len(x) ((int)(x).size())
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
// [
// (count_WA_before_passed, is_passed)
// ]
vector<pair<int, bool>> contest_result(105000, make_pair(0, false));
int WA_count = 0;
int AC_count = 0;
while (M--) {
int p;
string S;
cin >> p >> S;
if (contest_result[p].second) continue;
if (S == "AC") {
contest_result[p].second = true;
AC_count++;
WA_count += contest_result[p].first;
} else if (S == "WA") {
contest_result[p].first++;
}
}
cout << AC_count << " " << WA_count << endl;
}
| 0 |
#include <bits/stdc++.h>
#define ri register int
using namespace std;
const int rlen = 1 << 20 | 5;
char buf[rlen], *ib = buf, *ob = buf;
#define gc() (((ib == ob) && (ob = (ib = buf) + fread(buf, 1, rlen, stdin))), ib == ob ? -1 : *ib++)
#define pb push_back
#define rez resize
#define fi first
#define se second
typedef long long ll;
typedef pair <int, int> pii;
inline int read() {
static int ans, f;
static char ch;
for (ans = 0, f = 1, ch = gc(); !isdigit(ch); ch = gc()) f ^= ch == '-';
while (isdigit(ch)) ans = ((ans << 2) + ans << 1) + (ch ^ 48), ch = gc();
return f ? ans : -ans;
}
const int N = 2e5 + 5;
int n, m, a, b;
int main() {
#ifdef ldxcaicai
freopen("lx.in", "r", stdin);
#endif
n = read(), m = read(), a = read(), b = read();
for (ri i = 1; i <= n; ++i, puts("")) for (ri j = 1; j <= m; ++j) cout << ((j <= a) ^ (i <= b));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
#define rep(i,n) for(int i = 0; i < ((int)(n)); i++) // 0-indexed昇順
int main() {
int H,W,A,B; cin >> H >> W >> A >> B;
rep(i,H) {
rep(j,W) {
if (i < B) {
cout << ((j < A) ? 0 : 1);
} else {
cout << ((j < A) ? 1 : 0);
}
}
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
//#define int long long
typedef long long ll;
//const int INF = 2e9;
//const ll INF = 9e18;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<int> p(N); // Male = 1, Female = 2;
string response;
auto ask = [&](int pos) {
cout << pos << endl;
cin >> response;
if (response == "Vacant") return -1;
else if (response == "Male") return 1;
else return 2;
};
p[0] = ask(0);
if (p[0] == -1) return 0;
p[N-1] = ask(N-1);
if (p[N-1] == -1) return 0;
int left = 0;
int right = N-1;
while (right - left > 1){
int mid = (right + left)/2;
p[mid] = ask(mid);
if (p[mid] == -1) return 0;
if ((right - mid)%2 == 0 && p[mid] != p[right]) left = mid;
else if ((right - mid)%2 == 1 && p[mid] == p[right]) left = mid;
else if ((mid - left)%2 == 0 && p[mid] != p[left]) right = mid;
else if ((mid - left)%2 == 1 && p[mid] == p[left]) right = mid;
}
return 0;
} | #include <stdio.h>
int isprime(int n){
for(int i = 2 ; i*i<=n ;i++){
if(n%i==0)return 0;
}
return 1;
}
int main(){
int number[10000+2]={0};
int n ,i , fir ,sec;
while(scanf("%d" ,&n)){
if(n==0)break;
fir = 0 ,sec = 0;
for(i=n ;i>3 ;i--){
if(isprime(i) && isprime(i-2)){
fir = i-2;
sec = i;
break;
}
}
printf("%d %d\n" ,fir ,sec);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rep(i,n) for (int i=0;i<(int)(n);i++)
#define codefor int test;scanf("%d",&test);while(test--)
#define INT(...) int __VA_ARGS__;in(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__;in(__VA_ARGS__)
#define yes(ans) if(ans)printf("yes\n");else printf("no\n")
#define Yes(ans) if(ans)printf("Yes\n");else printf("No\n")
#define YES(ans) if(ans)printf("YES\n");else printf("NO\n")
#define vector1d(type,name,...) vector<type>name(__VA_ARGS__)
#define vector2d(type,name,h,...) vector<vector<type>>name(h,vector<type>(__VA_ARGS__))
#define umap unordered_map
#define uset unordered_set
using namespace std;
using ll = long long;
const int MOD=1000000007;
//入力系
void scan(int& a){scanf("%d",&a);}
void scan(long long& a){scanf("%lld",&a);}
template<class T> void scan(T& a){cin>>a;}
template<class T> void scan(vector<T>& vec){for(auto&& it:vec)scan(it);}
void in(){}
template <class Head, class... Tail> void in(Head& head, Tail&... tail){scan(head);in(tail...);}
//出力系
void print(const int& a){printf("%d",a);}
void print(const long long& a){printf("%lld",a);}
void print(const double& a){printf("%.15lf",a);}
template<class T> void print(const T& a){cout<<a;}
template<class T> void print(const vector<T>& vec){if(vec.empty())return;print(vec[0]);for(auto it=vec.begin();++it!= vec.end();){putchar(' ');print(*it);}}
void out(){putchar('\n');}
template<class T> void out(const T& t){print(t);putchar('\n');}
template <class Head, class... Tail> void out(const Head& head,const Tail&... tail){print(head);putchar(' ');out(tail...);}
//デバッグ系
template<class T> void dprint(const T& a){cerr<<a;}
template<class T> void dprint(const vector<T>& vec){if(vec.empty())return;cerr<<vec[0];for(auto it=vec.begin();++it!= vec.end();){cerr<<" "<<*it;}}
void debug(){cerr<<endl;}
template<class T> void debug(const T& t){dprint(t);cerr<<endl;}
template <class Head, class... Tail> void debug(const Head& head, const Tail&... tail){dprint(head);cerr<<" ";debug(tail...);}
ll intpow(ll a, ll b){ ll ans = 1; while(b){ if(b & 1) ans *= a; a *= a; b /= 2; } return ans; }
ll modpow(ll a, ll b, ll p){ ll ans = 1; while(b){ if(b & 1) (ans *= a) %= p; (a *= a) %= p; b /= 2; } return ans; }
ll updivide(ll a,ll b){if(a%b==0) return a/b;else return (a/b)+1;}
int main(){
INT(n);
vector<tuple<ll,ll,ll>> vec(n);
ll a,b;
rep(i,n){
in(a,b);
vec[i]=make_tuple(a+b,a,b);
}
sort(rall(vec));
a=0,b=0;
rep(i,n){
if(i%2==0)a+=get<1>(vec[i]);
else b+=get<2>(vec[i]);
}
out(a-b);
}
| #include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <string>
#include <cmath>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef pair<ll,ll>PP;
int T[105]={0};
int main(){
int n;cin>>n;int sum=0;
for(int i=0;i<n;i++){
int k;cin>>k;
sum+=k;
T[i]=n*k;
}
int dif=1000000000;
int ans=0;
for(int i=0;i<n;i++){
if(abs(sum-T[i])<dif){ans=i;dif=abs(sum-T[i]);}
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
int n;
int a;
int ans=1000000000;
int main(void){
cin>>n;
for(int i=0;i<n;i++){
cin>>a;
int k=0;
while(a%2==0){
a=a/2;
k++;
}
ans=min(ans,k);
}
cout<<ans<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main()
{
ll n;
cin >> n;
ll a[n];
rep(i,n) cin >> a[i];
int ans = 0;
while(1){
rep(i,n){
if(a[i] % 2 == 0){
a[i] /= 2;
}else{
cout << ans << endl;
return 0;
}
}
ans++;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ct cout
#define in cin
#define el endl
#define rep(i, N) for (int i = 0; i < N; i++)
#define ol(N) cout << N << endl
int main()
{
int s1[4], s2[2];
rep(i, 4){
in >> s1[i];
}
in >> s2[0] >> s2[1];
sort (s1, s1 + 4);
reverse(s1, s1 + 4);
ol(s1[0] + s1[1] + s1[2] + max(s2[0], s2[1]));
return (0);
} | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int maxof(const int a[]) {
int i;
int max = a[0];
for (i = 1; i < 8; i++) {
if (a[i] > max) max = a[i];
}
return max;
}
int main() {
int a, b, c, d, e, f;
int r1, r2, r3,r4,r5, r6, r7, r8;
cin >> a >> b >> c >> d >> e >> f;
r1 = a + b + c + e;
r2 = a + b + c + f;
r3 = a + b + d + e;
r4 = a + b + d + f;
r5 = a + c + d + e;
r6 = a + c + d + f;
r7 = b + c + d + e;
r8 = b + c + d + f;
int ar[] = { r1, r2, r3,r4,r5, r6, r7, r8 };
cout << maxof(ar) << endl;
}
| 1 |
//kruskal tree
#include <cstdio>
#include <algorithm>
using namespace std;
#define M 100000
int parent[M],a[M],b[M];
pair<int,int>node[M];
int root(int a){return parent[a]==a?a:parent[a]=root(parent[a]);}
int unite(int a,int b){
int x=root(a),y=root(b);
if(x==y)return 0;
parent[x]=y;
return 1;
}
int main(){
int i,s,n,m;
for(;scanf("%d%d",&n,&m)>1;printf("%d\n",s)){
for(i=0;i<m;i++)scanf("%d%d%d",a+i,b+i,&node[i].first),node[i].second=i;
sort(node,node+m);
for(i=0;i<n;i++)parent[i]=i;
for(s=i=0;i<m;i++)if(unite(a[node[i].second],b[node[i].second]))s+=node[i].first;
}
} | #include <cstdio>
#include <vector>
#include <algorithm>
#include <queue>
#include <utility>
using namespace std;
template <class T>
using gp_queue=priority_queue<T, deque<T>, less<T>>;
using Weight=long long;
static const Weight INF=1LL<<57;
struct Edge {
size_t src, dst;
Weight weight;
Edge() {}
Edge(size_t src, size_t dst, Weight weight=1):
src(src), dst(dst), weight(weight)
{}
};
bool operator<(const Edge &e, const Edge &f) {
if (e.weight != f.weight) {
return e.weight > f.weight;
} else {
return e.src!=f.src? e.src<f.src : e.dst<f.dst;
}
}
using Edges=vector<Edge>;
using Vertex=vector<Edge>;
using Graph=vector<Vertex>;
void join(Graph &g, size_t s, size_t d, Weight w=1) {
// non-directed
g[s].push_back(Edge(s, d, w));
g[d].push_back(Edge(d, s, w));
}
void connect(Graph &g, size_t s, size_t d, Weight w=1) {
// directed
g[s].push_back(Edge(s, d, w));
}
pair<Weight, Edges> minimum_spanning_tree(const Graph &g, size_t s=0) {
/* Prim */
size_t V=g.size();
Edges T;
Weight total=0;
vector<bool> visited(V);
gp_queue<Edge> q; q.push(Edge(-1, s, 0));
while (!q.empty()) {
Edge e=q.top(); q.pop();
if (visited[e.dst]) continue;
T.push_back(e);
total += e.weight;
visited[e.dst] = true;
for (const Edge &f: g[e.dst])
if (!visited[f.dst])
q.push(f);
}
return make_pair(total, T);
}
int main() {
size_t V, E;
scanf("%zu %zu", &V, &E);
Graph g(V);
for (size_t i=0; i<E; ++i) {
size_t s, t;
Weight w;
scanf("%zu %zu %lld", &s, &t, &w);
join(g, s, t, w);
}
printf("%lld\n", minimum_spanning_tree(g).first);
return 0;
} | 1 |
#include<bits/stdc++.h>
#define llu unsigned long long
#define ll long long
#define INF 0x3f3f3f3f
#define fast ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define endl "\n"
#define to_lower(s) transform(s.begin(), s.end(), s.begin(), ::tolower);
#define to_upper(s) transform(s.begin(), s.end(), s.begin(), ::toupper);
using namespace std;
// scan vector
template <typename T>
inline istream &operator>>(istream &in, vector<T> &a) {
for(auto &x : a) in >> x;
return in;
}
// print vector
template <typename T>
inline ostream &operator<<(ostream &out, vector<T> &a) {
for(auto &x : a) out << x <<" ";
return out;
}
// scan pair
template <typename T, typename U>
inline istream &operator>>(istream &in, pair<T,U> &a) {
in >> a.first >> a.second;
return in;
}
const ll mod=1e9 + 7;
string k;
int D;
ll dp[10010][2][105];
ll solve(int pos, bool flag, int sum)
{
if(pos==k.length())
return sum==0;
if(dp[pos][flag][sum]!=-1)
return dp[pos][flag][sum];
int limit = (flag)?(k[pos]-'0'):9;
ll sum_so_far=0;
for(int i=0; i<=limit; i++)
{
sum_so_far+=solve(pos+1,(flag && (i==limit)), (sum+i)%D);
}
return dp[pos][flag][sum]=sum_so_far%mod;
}
int main()
{
#ifdef SANS
freopen("ongoingin.txt","r",stdin);
freopen("ongoingout.txt","w",stdout);
#endif
fast
int t=1;
// cin>>t;
while(t--)
{
cin>>k>>D;
memset(dp,-1,sizeof(dp));
ll ans=solve(0,1,0)-1;
if(ans==-1)
ans=mod-1;
else if(ans>mod)
ans-=mod;
cout<<ans;
}
#ifdef SANS
cout<<"\nTime Elapsed:"<<1.0*clock()/CLOCKS_PER_SEC <<"sec\n";
#endif
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
int main() {
int n, l; cin >> n >> l;
int sum = 0;
for (int i = 0; i < n; i++) {
sum += l + i;
}
int ans;
int x = 100000000;
for (int i = 0; i < n; i++) {
int tmp = l + i;
if (chmin(x, abs(tmp))) {
ans = sum - tmp;
}
}
cout << ans << endl;
return 0;
} | 0 |
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#define ll long long
using namespace std;
template <class T>
inline void rd(T &x)
{
x=0; char c=getchar(); int f=1;
while(!isdigit(c)){if(c=='-')f=-1; c=getchar();}
while(isdigit(c)) x=x*10-'0'+c,c=getchar(); x*=f;
}
const int N=2e5+10,mod=1e9+7;
char str[N];
int n;
int main() {
rd(n);
scanf("%s",str+1);
int cnt=0,ans=1;
int cur=0;
for(int i=1;i<=2*n;++i) {
int c=str[i]=='B';
if(c!=cur) cnt++;
else ans=ans*(ll)cnt%mod,cnt--;
cur^=1;
}
if(cnt!=0) ans=0;
for(int i=1;i<=n;++i) ans=ans*(ll)i%mod;
printf("%d",ans);
return 0;
} | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define reps(i, f, n) for (ll i = (f); i < (n); i++)
#define repv(v) for (auto it = (v).begin(); it != (v).end(); it++)
ll const INF = 1LL << 60;
ll const MAX_N = 510000;
ll const MOD = 1000000007;
// 約数の列挙 O(√n)
vector<ll> divisor(ll n) {
vector<ll> res;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (i != n / i) res.push_back(n / i);
}
}
return res;
}
int main() {
ll N, M;
cin >> N >> M;
vector<ll> divs = divisor(M);
ll ans = 0;
for (ll i = divs.size() - 1; i >= 0; i--) {
if (M % divs[i] == 0) {
ll sub_m = M / divs[i];
if (sub_m >= N) {
ans = max(ans, divs[i]);
}
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int v,e;
set<pair<int,pair<int,int>>> g;
int a[10005]={};
void init(){
for(int i=0;i<10005;i++)a[i]=i;
}
int find(int x){
if(a[x]==x)return x;
else return (a[x]=find(a[x]));
}
void un(int x,int y){
a[find(x)]=y;
}
int main() {
long long c=0;
init();
cin>>v>>e;
for(int i=0;i<e;i++){
int a,b,l;cin>>a>>b>>l;
g.insert({l,{a,b}});
}
for(auto p:g){
if(find(p.second.first)!=find(p.second.second)){
c+=p.first;
un(p.second.first,p.second.second);
}
}
cout<<c<<endl;
} | #include<bits/stdc++.h>
using namespace std;
#define int long long
#define tc(t) int t; cin>>t; while(t--)
#define f(n) for(int i=0;i<n;i++)
#define endl "\n"
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n,m;
cin>>n>>m;
vector<pair<int,string>>v(m);
vector<pair<int,int>>dp(n,{0,0});
for(int i=0;i<m;i++){
int q;
string verdict;
cin>>q>>verdict;
v[i]={q,verdict};
}
int correct=0,penality=0;
for(int i=0;i<m;i++)
{
int qn=v[i].first;
string verdict=v[i].second;
if(verdict=="WA")
{
if(dp[qn-1].second==0)
{dp[qn-1].first++;}
} else{
if(dp[qn-1].second==0) {
dp[qn - 1].second = 1;
correct++;
penality+=dp[qn-1].first;
}
}
}
cout<<correct<<" "<<penality<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int kN = 100'000 + 5;
const int kMod = 1'000'000'000 + 7;
int x[kN], y[kN];
int f(int *a, int n) {
int sum = 0, res = 0;
for (int i = 0; i < n; ++i) {
a[i] = (a[i] % kMod + kMod) % kMod;
int add = (1LL * a[i] * i + kMod - sum) % kMod;
(res += add) %= kMod;
(sum += a[i]) %= kMod;
}
return res;
}
int main() {
int n, m; scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%d", &x[i]);
for (int i = 0; i < m; ++i) scanf("%d", &y[i]);
int ans = 1LL * f(x, n) * f(y, m) % kMod;
printf("%d\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, N) for (int i = 0; i < (int)N; i++)
#define FOR(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define INF (1 << 30)
#define LLINF (1LL << 62)
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
constexpr int MOD = 1000000007;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <class T>
string to_string(T s);
template <class S, class T>
string to_string(pair<S, T> p);
string to_string(string s) { return s; }
string to_string(const char s[]) { return to_string(string(s)); }
template <class T>
string to_string(T v) {
if (v.empty()) return "{}";
string ret = "{";
for (auto x : v) ret += to_string(x) + ",";
ret.back() = '}';
return ret;
}
template <class S, class T>
string to_string(pair<S, T> p) {
return "{" + to_string(p.first) + "," + to_string(p.second) + "}";
}
void debug() { cerr << endl; }
template <class Head, class... Tail>
void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
struct IO {
#ifdef _WIN32
inline char getchar_unlocked() { return getchar(); }
inline void putchar_unlocked(char c) { putchar(c); }
#endif
string separator = " ";
template <class T>
inline void read(T& x) {
char c;
do {
c = getchar_unlocked();
} while (c != '-' && (c < '0' || '9' < c));
bool minus = 0;
if (c == '-') {
minus = 1;
c = getchar_unlocked();
}
x = 0;
while ('0' <= c && c <= '9') {
x *= 10;
x += c - '0';
c = getchar_unlocked();
}
if (minus) x = -x;
}
inline void read(string& x) {
char c;
do {
c = getchar_unlocked();
} while (c == ' ' || c == '\n');
x.clear();
do {
x += c;
c = getchar_unlocked();
} while (c != ' ' && c != '\n' && c != EOF);
}
template <class T>
inline void read(vector<T>& v) {
for (auto& x : v) read(x);
}
template <class Head, class... Tail>
inline void read(Head& head, Tail&... tail) {
read(head);
read(tail...);
}
template <class T>
inline void write(T x) {
char buf[32];
int p = 0;
if (x < 0) {
x = -x;
putchar_unlocked('-');
}
if (x == 0) putchar_unlocked('0');
while (x > 0) {
buf[p++] = (x % 10) + '0';
x /= 10;
}
while (p) {
putchar_unlocked(buf[--p]);
}
}
inline void write(string x) {
for (char c : x) putchar_unlocked(c);
}
inline void write(const char s[]) {
for (int i = 0; s[i] != 0; ++i) putchar_unlocked(s[i]);
}
template <class T>
inline void write(vector<T> v) {
for (auto itr = v.begin(); itr + 1 != v.end(); ++itr) {
write(*itr);
write(separator);
}
write(v.back());
}
template <class Head, class... Tail>
inline void write(Head head, Tail... tail) {
write(head);
write(separator);
write(tail...);
}
template <class Head, class... Tail>
inline void writeln(Head head, Tail... tail) {
write(head, tail...);
write("\n");
}
void set_separator(string s) { separator = s; }
} io;
int main() {
ll n, m;
io.read(n, m);
vector<ll> x(n), y(m);
io.read(x, y);
ll t = 0;
REP(i, m - 1) {
t = (t + ((y[i + 1] - y[i]) * (i + 1) % MOD) * (m - i - 1)) % MOD;
}
ll ans = 0;
REP(i, n - 1) {
ans = (ans + ((t * (x[i + 1] - x[i]) % MOD) * (i + 1) % MOD) * (n - i - 1) %
MOD) %
MOD;
}
io.writeln(ans);
return 0;
} | 1 |
#include<stdio.h>
int insertionSort(int A[], int n, int g) {
int cnt = 0;
for (int i = g; i < n; i++) {
int v = A[i];
int j = i - g;
while ( j >= 0 && v < A[j]) {
A[j + g] = A[j];
j -= g;
cnt++;
}
A[j + g] = v;
}
return cnt;
}
void shellSort(int A[], int n) {
int im, m = 1, v = 1, G[100], sum = 0;
for ( im = 0; v <= n; im++ ) {
G[im] = v;
m *= 3;
v += m;
}
printf("%d\n", im);
for ( int i = im - 1; i >= 0; i-- ) {
if ( i != (im - 1) ) printf(" ");
printf("%d", G[i]);
sum += insertionSort(A, n, G[i]);
}
printf("\n%d\n", sum);
for ( int i = 0; i < n; i++ ) {
printf("%d\n", A[i]);
}
}
int main() {
int n, A[1000000];
scanf("%d", &n);
for ( int i = 0; i < n; i++ ) scanf("%d", &A[i]);
shellSort(A, n);
return 0;
}
| #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int cnt;
void insertionSort(vector<int> &mat,int g){
for(int i=g;i<mat.size();i++){
int v = mat[i];
int j = i - g;
while(j>=0 && mat[j]>v){
mat[j+g] = mat[j];
j = j - g;
cnt++;
mat[j+g] = v;
}
}
}
void shellSort(vector<int> &mat){
vector<int>g;
cnt = 0;
for(int h=1;h<=mat.size();h=3*h+1)g.push_back(h);
reverse(g.begin(),g.end());
int m = g.size();
cout << m << endl;
for(int i=0;i<g.size();i++){
if(i<g.size()-1) cout << g[i] << " ";
else cout << g[i] << endl;
}
for(int i=0;i<m;i++)insertionSort(mat,g[i]);
}
int main(){
vector<int> mat;
int n,x;
cin >> n;
for(int i=0;i<n;i++){
cin >> x;
mat.push_back(x);
}
shellSort(mat);
cout << cnt << endl;
for(int i=0;i<n;i++) cout << mat[i] << endl;
return 0;
} | 1 |
#include<stdio.h>
//operation a == doubled
//operation b == increase by b
int main(){
int a, b;
scanf("%d %d", &a, &b);
int result = 1;
for(int i = 0; i < a; i++){
if(result < b)//it works if result + b is smaller than doubled
{
result = result * 2;
}
else//it works if result * 2 is smaller than doubled
{
result = result + b;
}
}
printf("%d\n", result);
return 0;
} | #include <stdio.h>
#include <string.h>
int main() {
int A,B;
char S[20];
int C, counts = 0;
scanf("%d %d", &A, &B);
scanf("%s", S);
C = strlen(S);
if(!(S[A] == '-')){
printf("No");
return 0;
}
for(int i=0;i<C;i++){
if(S[i] == '-'){
counts++;
}
}
if(counts > 1){
printf("No");
return 0;
}
printf("Yes");
return 0;
} | 0 |
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <stack>
#include <queue>
#include <map>
#include <algorithm>
#include <iomanip>
#include <math.h>
#include <string.h>
#include <cstdio>
#include <tuple>
#include <numeric>
using namespace std; using ll = long long; using ld = long double; using pll = pair<ll, ll>;
using vl = vector<ll>; using vll = vector<vl>; using vpll = vector<pll>;
using vs = vector<string>; using tll = tuple<ll, ll, ll>; using vtll = vector<tll>;
const ld PI = 3.1415926535897932;
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#define mp make_pair
#define mt make_tuple
void in() {}
void debug_out() { cerr << endl; }
template<typename Head, typename... Tail>
void debug_out(Head h, Tail... t) {
cerr << " " << h;
if (sizeof...(t) > 0) cerr << " :";
debug_out(t...);
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> vec) {
for (size_t i = 0; i < vec.size(); i++)os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
ll ctoi(char c) {
switch (c) {
case '0': return 0; case '1': return 1; case '2': return 2;
case '3': return 3; case '4': return 4; case '5': return 5;
case '6': return 6; case '7': return 7; case '8': return 8;
case '9': return 9; default: return 0;
}
}
bool pairCompare(const pll firstElof, pll secondElof)
{
return firstElof.first > secondElof.first;
}
//**Snippetリスト**//
//rep, vin, all, iteLoop, bitSearch, bitList, nod//
//gcdlcm, isPrime, eratos, primeFactorize, Npow, combination, divisor, modinv, doubling, digitDP//
//dfs, bfs, dijkstra, WarshallFloyd, BellmanFord, UnionFind, Kruskal ,RMQ, LCA//
ll i, j, k, l; ll N, M, K, H, W, L, X, Y, Z, R, Q;
ll MOD = 1000000007, INF = 1LL << 60, ans = 0, z = 0, o = 1;
vl flag, D; vpll path;
//***********//
int main() {
cin >> N;
vl A(N);
map<ll, ll> B;
for (i = 0; i < N; i++) {
cin >> A[i];
B[A[i]]++;
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
for (i = 0; i < N; i++) {
if (B[A[i]] > 0) {
B[A[i]]--;
for (j = 31; j >= 1; j--) {
ll P = pow(2, j) - A[i];
if (P >= 1) {
//debug(P, B[P]);
if (B[P] > 0) {
ans++;
B[P]--;
break;
}
}
}
}
}
cout << ans;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0, i##_len = (n); i < i##_len; ++i)
using ll = long long;
int main() {
ll n, a;
cin >> n;
multiset<ll, greater<>> st;
rep(i, n) {
cin >> a;
st.insert(a);
}
ll ans = 0;
while(!st.empty()) {
auto it = st.begin();
st.erase(it);
ll p = 2;
while(p <= *it) {
p *= 2;
}
auto jt = st.find(p - *it);
if(jt == st.end()) continue;
st.erase(jt);
ans++;
}
cout << ans << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int h, w;
cin >> h >> w;
vector<vector<char>> a(h+2, vector<char>(w+2));
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
cin >> a[i][j];
}
}
int di[] = {1, 0, -1, 0};
int dj[] = {0, 1, 0, -1};
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
if(a[i][j] == '.') {
continue;
}
int x = 0;
for (int k = 0; k < 4; k++) {
x += (a[i + di[k]][j + dj[k]] == '#');
}
if(!x) {
cout << "No";
return;
}
}
}
cout << "Yes";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| // Ref : https://book.mynavi.jp/ec/products/detail/id=35408
// Ref : http://judge.u-aizu.ac.jp/onlinejudge/review.jsp?rid=2679699#1
#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
int NV, NE;
struct artPoint {
int cnt, N;
vector<vector<int> > G;
set<int> AP;
vector<bool> visited;
// DFS木の各頂点について, prenum: DFS木の訪問順番,
// parent: 親の頂点番号, lowest: 親への辺以外から辿れる上位のprenum
vector<int> prenum, parent, lowest;
artPoint(int n):N(n),G(n),visited(n, false),prenum(n),parent(n),lowest(n){}
void addVertex(int a, int b) {
G[a].push_back(b);
G[b].push_back(a);
}
void dfs(int cur, int prev) {
prenum[cur] = lowest[cur] = cnt++;
visited[cur] = true;
int next;
for (unsigned int i = 0; i < G[cur].size(); i++) {
next = G[cur][i];
if (!visited[next]) {
parent[next] = cur;
dfs(next, cur);
// 深さ優先で探索するので、親は子がより上位に辿れれば更新
lowest[cur] = min(lowest[cur], lowest[next]);
}
else if (next != prev) {
// DFS木の訪問順番の上位が辿れれば更新
lowest[cur] = min(lowest[cur], prenum[next]);
}
}
}
// ある点からの1回のDFSで、関節点を求める
void build() {
cnt = 1;
dfs(0, -1); // 頂点番号0をルートとする深さ優先探索
int np = 0;
for (int i = 1; i < N; i++) { // ルート以外を処理する
int p = parent[i];
if (p == 0) np++;
else if (prenum[p] <= lowest[i]) AP.insert(p);
}
if (np > 1) AP.insert(0); // ルートを処理する
}
void print() {
for (set<int>::iterator it = AP.begin(); it != AP.end(); it++) {
cout << *it << endl;
}
}
};
int main() {
cin >> NV >> NE;
artPoint A(NV);
for (int i = 0; i < NE; i++) {
int s, t;
cin >> s >> t;
A.addVertex(s, t);
}
A.build();
A.print();
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int mod=1000000007;
signed main(){
int N,ans=1;
cin>>N;
vector<int> A(3,-1);
while(N--){
int a;
cin>>a;
vector<int> B(0);
for(int i=0;i<3;i++)
if(A[i]+1==a)
B.push_back(i);
if(B.size()==0){
puts("0");
return 0;
}
ans=ans*((int)B.size())%mod;
A[B[0]]++;
}
cout<<ans<<endl;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#define repeat(i, n) for (int i = 0; (i) < (n); ++(i))
#define repeat_from(i, m, n) for (int i = (m); (i) < (n); ++(i))
#define sz(x) int(x.size())
using namespace std;
template <class T>
void setmax(T &a, T const &b) {
if (a < b) a = b;
}
template <class T>
void setmin(T &a, T const &b) {
if (a > b) a = b;
}
template <typename T, typename X>
auto vectors(T a, X x) { return vector<T>(x, a); }
template <typename T, typename X, typename Y, typename... Zs>
auto vectors(T a, X x, Y y, Zs... zs) {
auto cont = vectors(a, y, zs...);
return vector<decltype(cont)>(x, cont);
}
// 高橋が料理i選んだらスコアはAi + Bi増え
// 青木が料理i選んだらスコアは-(Ai + Bi)増える
#define NDEBUG
int main() {
int n;
cin >> n;
vector<int> a(n), b(n);
vector<int> ab(n);
repeat(i, n) {
cin >> a[i] >> b[i];
ab[i] = a[i] + b[i];
}
sort(ab.rbegin(), ab.rend());
long long ans = 0;
repeat(i, n) ans -= b[i];
repeat(i, n) {
if (i % 2 == 0) ans += ab[i];
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void)
{
int a, b;
cin >> a >> b;
cout << a * b << endl;
return (0);
}
| #include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <climits>
#include <ctime>
#include <cassert>
using namespace std;
#define rep(i,a,n) for(int (i)=(a); (i)<(n); (i)++)
#define repq(i,a,n) for(int (i)=(a); (i)<=(n); (i)++)
#define repr(i,a,n) for(int (i)=(a); (i)>=(n); (i)--)
#define all(v) begin(v), end(v)
#define pb(a) push_back(a)
#define fr first
#define sc second
#define INF 2000000000
#define int long long int
#define X real()
#define Y imag()
#define EPS (1e-10)
#define EQ(a,b) (abs((a) - (b)) < EPS)
#define EQV(a,b) ( EQ((a).X, (b).X) && EQ((a).Y, (b).Y) )
#define LE(n, m) ((n) < (m) + EPS)
#define LEQ(n, m) ((n) <= (m) + EPS)
#define GE(n, m) ((n) + EPS > (m))
#define GEQ(n, m) ((n) + EPS >= (m))
typedef vector<int> VI;
typedef vector<VI> MAT;
typedef pair<int, int> pii;
typedef long long ll;
typedef complex<double> P;
typedef pair<P, P> L;
typedef pair<P, double> C;
int dy[]={0, 0, 1, -1};
int dx[]={1, -1, 0, 0};
int const MOD = 1000000007;
namespace std {
bool operator<(const P& a, const P& b) {
return a.X != b.X ? a.X < b.X : a.Y < b.Y;
}
bool comp(const pii& a, const pii& b) {
int t1 = a.fr * a.fr + a.sc * a.sc;
int t2 = b.fr * b.fr + b.sc * b.sc;
return (t1 != t2) ? t1 < t2 : a.fr < b.fr;
}
}
signed main() {
int h, w;
vector<pii> v;
repq(i,1,150) repq(j,i+1,150) {
v.pb(pii(i,j));
}
sort(v.begin(), v.end(), comp);
while(cin >> h >> w, h || w) {
int k = 0;
rep(i,0,v.size()) {
if(v[i].fr == h && v[i].sc == w) {
k = i;
break;
}
}
printf("%lld %lld\n", v[k+1].fr, v[k+1].sc);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int ks(int n){
int ans=1;
for(int i=0;i<n;i++){
ans*=10;
}
return ans;
}
int ki(int n){
if(n==1){
return 0;
}
int ans=1;
for(int i=0;i<n-1;i++){
ans*=10;
}
return ans;
}
bool hantei(int N,int n,int s,int c){
int ss=ks(N-s+1);
int si=ks(N-s+1)/10;
if(n%ss/si==c){
return true;
}
return false;
}
int main(){
int N,M;
cin >> N >> M;
vector<int> s(M);
vector<int> c(M);
for(int i=0;i<M;i++){
cin >> s[i] >> c[i];
}
for(int i=ki(N);i<ks(N);i++){
int flag=0;
for(int j=0;j<M;j++){
if(!hantei(N,i,s[j],c[j])){
flag=1;
}
}
if(flag==1){
continue;
}
else{
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int prime_factors(long long x){
set<int>s;
if(x%2 == 0){
s.insert(2);
while(x%2 == 0){
x /= 2;
}
}
for(int i = 3; i <= sqrt(x); i++){
if(x%i == 0){
s.insert(i);
while(x%i == 0){
x/= i;
}
}
}
if(x > 1){
s.insert(x);
}
return s.size();
}
int main(){
long long a, b;
cin >> a >> b;
long long g = __gcd(a, b);
long long factors = prime_factors(g);
cout << factors + 1 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL<<62
#define inf 1000000007
ll a[50];
int main() {
for(ll i=0;i<50;i++){
a[i]=49-i;
}
ll k;
cin>>k;
for(ll i=0;i<50;i++){
a[i]+=k/50;
}
for(ll i=0;i<k%50;i++){
a[i]++;
}
cout << 50<<endl;
for(ll i=0;i<50;i++){
cout << a[i]<<" ";
}
// your code goes here
return 0;
} | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define _USE_MATH_DEFINES
#include <math.h>
#define NIL = -1;
#define all(x) x.begin(),x.end()
const ll INF = 1e9;
const ll mod = 1e9 + 7;
int digit(ll x) {
if (x / 10 == 0) return 1;
return digit(x / 10) + 1;
}
ll gcd(long long a,long long b) {
if (a < b) swap(a,b);
if (b == 0) return a;
return gcd(b,a%b);
}
bool is_prime(long long N){
if (N == 1) return false;
for (long long i = 2;i * i <= N;i++){
if (N % i == 0) return false;
}
return true;
}
ll lcm(ll a,ll b){
return ((a * b == 0)) ? 0 : (a / gcd(a,b) * b);
}
double DegreeToRadian(double degree){
return degree * M_PI / 180.0;
}
int dx[4] = {0,1,0,-1};
int dy[4] = {1,0,-1,0};
///////////////////////////////////////////////////////////////////////////////////
int main(){
map<long long, int> mp;
int n;
cin >> n;
for (int i = 0;i < n;i++){
int a;
cin >> a;
mp[a]++;
}
int cnt = 0;
for (auto v : mp){
if (v.second % 2 != 0){
cnt++;
}
}
cout << cnt << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define all(x) (x).begin(), (x).end()
#define endl '\n'
#define fsp(x) cout << fixed << setprecision(x)
const ll inf = LLONG_MAX;
const long double pi = M_PI;
void Yes() {cout << "Yes" << endl;}
void No() {cout << "No" << endl;}
void YES() {cout << "YES" << endl;}
void NO() {cout << "NO" << endl;}
int main() {
ll n;
cin >> n;
vector<vll> a(n, vll(2));
long double avg = 0;
for (ll i = 0; i < n; i++) {
cin >> a[i][0];
avg += a[i][0];
a[i][1] = i;
}
avg /= n;
ll m = -1;
sort(all(a));
for (ll i = 0; i < n; i++) {
if (a[i][0] == avg) {
cout << a[i][1] << endl;
return 0;
}
if (a[i][0] > avg) {
while (i > 0 && a[i][0] == a[i - 1][0]) i--;
m = i;
break;
}
}
if (m == 0) {
cout << a[m][1] << endl;
return 0;
}
ll x = m - 1;
while (x > 0 && a[x][0] == a[x - 1][0]) x--;
//cout << a[m][0] - avg << " " << avg - a[x][0] << endl;
if (a[m][0] - avg > avg - a[x][0]) cout << a[x][1] << endl;
else if (a[m][0] - avg < avg - a[x][0]) cout << a[m][1] << endl;
else {
cout << min(a[x][1], a[m][1]) << endl;
}
} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <clocale>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
#define IOS ios::sync_with_stdio(false); cin.tie(0);
#define FOR(i, s, n) for(int i = (s), i##_len=(n); i < i##_len; ++i)
#define FORS(i, s, n) for(int i = (s), i##_len=(n); i <= i##_len; ++i)
#define VFOR(i, s, n) for(int i = (s); i < (n); ++i)
#define VFORS(i, s, n) for(int i = (s); i <= (n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define REPS(i, n) FORS(i, 0, n)
#define VREP(i, n) VFOR(i, 0, n)
#define VREPS(i, n) VFORS(i, 0, n)
#define RFOR(i, s, n) for(int i = (s), i##_len=(n); i >= i##_len; --i)
#define RFORS(i, s, n) for(int i = (s), i##_len=(n); i > i##_len; --i)
#define RREP(i, n) RFOR(i, n, 0)
#define RREPS(i, n) RFORS(i, n, 0)
#define ALL(v) (v).begin(), (v).end()
#define SORT(v) sort(ALL(v))
#define RSORT(v) sort(ALL(v), greater<decltype(v[0])>())
#define SZ(x) ((int)(x).size())
#define REV(x) reverse(ALL(x))
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define MT make_tuple
#define BIT(n) (1LL<<(n))
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end())
using ld = long double;
using ll = long long;
using ui = unsigned int;
using ull = unsigned long long;
using Pi_i = pair<int, int>;
using Pll_ll = pair<ll, ll>;
using VB = vector<bool>;
using VC = vector<char>;
using VD = vector<double>;
using VI = vector<int>;
using VLL = vector<ll>;
using VS = vector<string>;
using VSH = vector<short>;
using VULL = vector<ull>;
const int MOD = 1000000007;
const int INF = 1000000000;
const int NIL = -1;
const double EPS = 1E-10;
template<class T, class S>
bool chmax(T &a, const S &b){
if(a < b){
a = b; return true;
}
return false;
}
template<class T, class S>
bool chmin(T &a, const S &b){
if(b < a){
a = b; return true;
}
return false;
}
int main(){
int N, sum(0); cin >> N;
VI a(N);
REP(i, N){
cin >> a[i];
sum += a[i];
}
int ans = -1, dif(INF);
REP(i, N){
if(dif > abs(N*a[i] - sum)){
dif = abs(N*a[i] - sum);
ans = i;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <cstdio>
#include <string>
#include <iostream>
using namespace std;
string s;
string Replace( string s1, string s2, string s3 )
{
string :: size_type pos( s1.find( s2 ) );
while( pos != string :: npos )
{
s1.replace( pos, s2.size(), s3 );
pos = s1.find( s2, pos + s3.size() );
}
return s1;
}
signed main()
{
int n = 0;
scanf( "%d\n", &n );
while( 0 < n )
{
getline( cin, s );
s = Replace( s, "Hoshino", "Hoshina" );
cout << s << endl;
n--;
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define FOR(i,n,m) for(int i=(int)(n); i<=(int)(m); i++)
#define RFOR(i,n,m) for(int i=(int)(n); i>=(int)(m); i--)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define RITR(x,c) for(__typeof(c.rbegin()) x=c.rbegin();x!=c.rend();x++)
#define setp(n) fixed << setprecision(n)
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; }
#define ll long long
#define vll vector<ll>
#define vi vector<int>
#define pll pair<ll,ll>
#define pi pair<int,int>
#define all(a) (a.begin()),(a.end())
#define rall(a) (a.rbegin()),(a.rend())
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define ins insert
using namespace std;
/* Some Libraries */
//-------------------------------------------------
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int N; cin>>N;
vi A(N),B(N),C(N);
rep(i,N) cin>>A[i];
rep(i,N) cin>>B[i];
rep(i,N) cin>>C[i];
sort(all(A));
sort(all(B));
sort(all(C));
ll ans=0;
rep(i,N){
int a = lower_bound(all(A),B[i])-A.begin();
int c = C.end()-upper_bound(all(C),B[i]);
ans += (ll)a*c;
}
cout<<ans<<"\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
int n = N;
int O,Y,A,U,M,S,H,J,I;
O = N / 100000000;
N = N % 100000000;
Y = N / 10000000;
N = N % 10000000;
A = N / 1000000;
N = N % 1000000;
U = N / 100000;
N = N % 100000;
M = N / 10000;
N = N % 10000;
S = N / 1000;
N = N % 1000;
H = N / 100;
N = N % 100;
J = N / 10;
N = N % 10;
I = N;
int Goukei = O+Y+A+U+M+S+H+J+I;
if(n % Goukei == 0){
cout <<"Yes"<< endl;
}
else{
cout <<"No"<< endl;
}
} | #include<iostream>
#include<string.h>
using namespace std;
int main(){
// int input = 0;
char input[10];
cin >> input;
// int angka1 = input%10;
// int angka2 = input-100-angka1;
// angka2 = angka2/10;
// int angka3 = input-angka2-angka1;
// angka3 = angka3/100;
if(input[0] == '7' || input[1] == '7' || input[2] == '7'){
cout << "Yes" <<endl;
}
else {
cout << "No" << endl;
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
//#include<tr1/unordered_map>
//#include"Bignum/bignum.h"
//#define lll bignum
#define ls(x) ( x << 1 )
#define rs(x) ( x << 1 | 1 )
//#define mid ( ( l + r ) >> 1 )
#define lowbit(x) ( x & -x )
#define debug(x) (cout << "#x = " << x << endl)
#define re register
#define For(i, j, k) for(re int i = (j); i <= (k); i++)
#define foR(i, j, k) for(re int i = (j); i >= (k); i--)
#define Cross(i, j, k) for(re int i = (j); i; i = (k))
using namespace std;
typedef long long ll;
const ll N = 100011;
const ll inf = 0x3f3f3f3f3f3f;
ll n, m, k, x, a[N], b[N], c[N], B[N];
double res = 0;
namespace IO {
#define dd ch = getchar()
inline ll read() {
ll x = 0; bool f = 0; char dd;
for (; !isdigit (ch); dd) f ^= (ch == '-');
for (; isdigit (ch); dd) x = (x << 3) + (x << 1) + (ch ^ 48);
return f? -x: x;
}
#undef dd
inline void write( ll x ) {
if ( x < 0 ) putchar ( '-' ), x = -x;
if ( x > 9 ) write ( x / 10 ); putchar ( x % 10 | 48 );
}
inline void wrn ( ll x ) { write (x); putchar ( ' ' ); }
inline void wln ( ll x ) { write (x); putchar ( '\n' ); }
inline void wlnn ( ll x, ll y ) { wrn (x), wln (y); }
}
using namespace IO;
inline void Redouble ( ll x ) {
for (; x; x >>= 1) {
if (x & 1) {
For ( i, 1, n ) B[i] = a[b[i]];
For ( i, 1, n ) a[i] = B[i];
}
For ( i, 1, n ) B[i] = b[b[i]];
For ( i, 1, n ) b[i] = B[i];
}
}
int main()
{
n = read();
For ( i, 1, n ) a[i] = read(), b[i] = i;
foR ( i, n, 1 ) a[i] = a[i] - a[i - 1];
m = read(), k = read();
For ( i, 1, m ) x = read(), swap ( b[x], b[x + 1] );
Redouble (k);
For ( i, 1, n )
res += a[i], printf ("%.1lf\n", res);
return 0;
}
/*
*/
| #include<iostream>
#include<vector>
#include<set>
#include<queue>
#include<map>
#include<algorithm>
#include<cstring>
#include<string>
#include<cassert>
#include<cmath>
#include<climits>
#include<iomanip>
#include<stack>
#include<unordered_map>
#include<bitset>
#include<limits>
#include<complex>
#include<array>
#include<numeric>
#include<functional>
using namespace std;
#define ll long long
#define ull unsigned long long
#define rrep(i,m,n) for(ll (i)=(ll)(m);(i)>=(ll)(n);(i)--)
#define rep(i,m,n) for(ll (i)=(ll)(m);i<(ll)(n);i++)
#define REP(i,n) rep(i,0,n)
#define FOR(i,c) for(decltype((c).begin())i=(c).begin();i!=(c).end();++i)
#define all(hoge) (hoge).begin(),(hoge).end()
typedef pair<ll, ll> P;
constexpr long double m_pi = 3.1415926535897932L;
constexpr ll MOD = 1000000007;
constexpr ll INF = 1LL << 61;
constexpr long double EPS = 1e-10;
template<typename T> using vector2 = vector<vector<T>>;
template<typename T> using vector3 = vector<vector2<T>>;
typedef vector<ll> Array;
ll dp[65][101010];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
Array x(n);
REP(i, n)cin >> x[i];
ll m, k;
cin >> m >> k;
Array a(m);
REP(i, m)cin >> a[i], a[i]--;
Array d(n - 1);
REP(i, n - 1)d[i] = x[i + 1] - x[i];
Array p(n - 1);
REP(i, n - 1)p[i] = i;
REP(i, m)swap(p[a[i]], p[a[i] - 1]);
REP(i, n - 1) dp[0][i] = p[i];
REP(i, 63)REP(j, n - 1)dp[i + 1][j] = dp[i][dp[i][j]];
cout << x[0] << "\n";
REP(i, n - 1) {
ll now = i;
REP(j, 61)if (k & (1LL << j))now = dp[j][now];
x[i + 1] = x[i] + d[now];
cout << x[i + 1] << "\n";
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define all(a)a.begin(),a.end()
using ll=long long;
const int INF = 1<<30;
const ll INFll =1LL<<62;
const int mod =(1e9)+7;
using P = pair<ll,ll>;
int main(){
string s;cin >>s;
ll n=s.size();
bool flg=true;
if(n%2==1)flg=false;
else {
for (int i = 0; i < n; i += 2) {
if (s.substr(i, 2) != "hi")flg = false;
}
}
if(flg)puts("Yes");
else puts("No");
return 0;
}
| #include<iostream>
int main()
{
int x = 0;
int n = 0;
std::cin >> x;
n = x;
for (int i = 1; i < 3; i++)
n *= x;
std::cout << n << std::endl;
} | 0 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
#include <map>
#include <string>
#include <functional>
#include <math.h>
#include <utility>
using namespace std;
typedef pair<int,int> P;
int n,rnk[101];
P p[100];
int main()
{
cin>>n;
for(int i=0;i<n;i++){
p[i].first=0;
p[i].second=i+1;
}
for(int i=0;i<n*(n-1)/2;i++){
int a,b,c,d;cin>>a>>b>>c>>d;a--;b--;
if(c!=d){
p[c>d?a:b].first+=3;
}else{
p[a].first+=1;
p[b].first+=1;
}
}
sort(p,p+n,greater<P>());
for(int i=1;i<=n;i++){
int r=i;
if(i!=1&&p[i-1].first==p[i-2].first)r=rnk[p[i-2].second];
rnk[p[i-1].second]=r;
}
for(int i=1;i<=n;i++){
cout<<rnk[i]<<endl;
}
} | #include<bits/stdc++.h>
#define rep(i,a,b) for (int i=(a); i<=(b); i++)
#define per(i,a,b) for (int i=(a); i>=(b); i--)
using namespace std;
const int maxn = 2005;
int v[maxn][maxn], e0[maxn][maxn], e1[maxn][maxn];
int n, m, Q, X1, X2, Y1, Y2;
char s[maxn];
int main() {
scanf("%d%d%d", &n, &m, &Q);
rep (i, 1, n) {
scanf("%s", s + 1);
rep (j, 1, m)
v[i][j] = s[j] - '0';
}
rep (i, 1, n) rep (j, 1, m) if (v[i][j]) {
if (v[i-1][j]) e0[i][j]++;
if (v[i][j-1]) e1[i][j]++;
}
rep (i, 1, n) rep (j, 1, m) {
v[i][j] += v[i-1][j] + v[i][j-1] - v[i-1][j-1];
e0[i][j] += e0[i-1][j] + e0[i][j-1] - e0[i-1][j-1];
e1[i][j] += e1[i-1][j] + e1[i][j-1] - e1[i-1][j-1];
}
while (Q--) {
scanf("%d%d%d%d", &X1, &Y1, &X2, &Y2);
printf("%d\n",
v[X2][Y2] - v[X1-1][Y2] - v[X2][Y1-1] + v[X1-1][Y1-1]
- (e0[X2][Y2] - e0[X1][Y2] - e0[X2][Y1-1] + e0[X1][Y1-1])
- (e1[X2][Y2] - e1[X1-1][Y2] - e1[X2][Y1] + e1[X1-1][Y1])
);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long s[200005],sum[200005],a,b,c,d,maxx,minn,ans=1e18;
long long get(int l,int r){
return sum[r]-sum[l-1];
}
int n;
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%lld",&s[i]);
sum[i]=s[i]+sum[i-1];
}
int l=1,r=3;
for(int i=2;i<n-1;i++){
while(l<=(i-2)&&abs(get(1,l)-get(l+1,i))>=abs(get(1,l+1)-get(l+2,i)))l++;
while(r<=(n-2)&&abs(get(i+1,r)-get(r+1,n))>=abs(get(i+1,r+1)-get(r+2,n)))r++;
a=get(1,l);
b=get(l+1,i);
c=get(i+1,r);
d=get(r+1,n);
maxx=max(max(a,b),max(c,d));
minn=min(min(a,b),min(c,d));
ans=min(ans,maxx-minn);
}
printf("%lld\n",ans);
} | #include<iostream>
#include<algorithm>
#include<map>
#include<vector>
#include<cstdint>
#include<cstdlib>
template<typename T>
void fin(T const& t){ std::cout << t << std::endl; exit(0); }
int64_t const INF = 1e18;
int main() {
std::cin.tie(0); std::ios::sync_with_stdio(false);
int N; std::cin >> N;
std::vector<int64_t> A(N), S(N+1, 0);
for(int i = 0; i < N; ++i) std::cin >> A[i];
for(int i = 0; i < N; ++i) S[i+1] = S[i] + A[i];
auto split = [&](auto b, auto e)-> std::pair<int64_t,int64_t> {
int64_t V = (*e + *b)/2;
auto m = std::upper_bound(b, e, V);
int64_t mi = INF;
std::pair<int64_t, int64_t> res;
for(auto i: {m-1, m, m+1}) if(b < i && i < e) {
int64_t cur = std::abs((*i-*b) - (*e-*i));
if(cur < mi) { mi = cur; res = std::make_pair(*i-*b, *e-*i); }
}
return res;
};
auto isOK = [&](int64_t k)->bool {
int64_t vmi = (S[N]+1)/2 - k, vma = S[N]/2 + k;
auto lb = std::lower_bound(S.begin()+2, S.end()-3, vmi);
auto ub = std::upper_bound(S.begin()+2, S.end()-2, vma);
for(auto it = lb; it != ub; ++it) {
auto L = split(S.begin(), it);
if(std::abs(L.first - L.second) > k) continue;
auto R = split(it, S.end()-1);
if(std::abs(R.first - R.second) > k) continue;
if(std::abs(L.first - R.first) > k) continue;
if(std::abs(L.first - R.second) > k) continue;
if(std::abs(L.second - R.first) > k) continue;
if(std::abs(L.second - R.second) > k) continue;
return true;
}
return false;
};
int64_t ng = -1, tmp[6];
tmp[0] = std::abs(S[N] - S[3] - A[0]);
tmp[1] = std::abs(S[N] - S[3] - A[1]);
tmp[2] = std::abs(S[N] - S[3] - A[2]);
tmp[3] = std::abs(A[0] - A[1]);
tmp[4] = std::abs(A[0] - A[2]);
tmp[5] = std::abs(A[1] - A[2]);
int64_t ok = *std::max_element(tmp, tmp+6);
while(ok - ng > 1) {
int64_t mid = (ok+ng)/2;
if(isOK(mid)) ok = mid; else ng = mid;
}
fin(ok);
return 0;
}
| 1 |
#include <iostream>
using namespace std;
class Data{
private:
int a_point, b_point;
public:
Data(){ a_point=0; b_point=0;}
void Add(int a, int b);
void Show();
};
struct DataList{
Data dataset;
struct DataList* next;
};
void Data::Add(int a, int b){
a_point += a;
b_point += b;
}
void Data::Show(){
cout << a_point << " " << b_point << endl;
}
int main(){
int n, a, b;
struct DataList *datalist, *p;
datalist = new DataList;
p = datalist;
datalist->next = NULL;
while(1){
cin >> n;
if(n == 0) break;
p->next = new DataList;
p->next->next = NULL;
p = p->next;
while(n > 0){
cin >> a >> b;
if(a > b) p->dataset.Add(a+b,0);
else if(a < b) p->dataset.Add(0,a+b);
else p->dataset.Add(a,b);
n -= 1;
}
}
p = datalist;
while(p->next != NULL){
p = p->next;
p->dataset.Show();
}
return 0;
} | #include<iostream>
using namespace std;
int main() {
int p1[10000], p2[10000], n, point1, point2, i;
while (true) {
point1 = 0;
point2 = 0;
cin >> n;
if (n == 0) { break; }
for (i = 0; i < n; i++) {
cin >> p1[i] >> p2[i];
}
for (i = 0; i < n; i++) {
if (p1[i] == p2[i]) {
point1 += p1[i];
point2 += p2[i];
}
else if (p1[i] > p2[i]) {
point1 += p1[i] + p2[i];
}
else {
point2 += p1[i] + p2[i];
}
}
cout << point1 << ' ' << point2 << endl;
}
return 0;
} | 1 |
#include <iostream>
#include <string>
using namespace std;
int main() {
string week[7] = {
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
"Sunday",
};
int end_day[13] = {-1,31,29,31,30,31,30,31,31,30,31,30,31};
int month,day;
while(cin >> month >> day) {
if(month == 0) break;
int today = 3; // because, 1/1 is Thursday
for(int m = 1;m <= month;m++) {
for(int d = 1;d <= end_day[m];d++) {
if(m == month && d == day) break;
today = (today + 1) % 7;
}
}
cout << week[today] << endl;
}
} | #include <iostream>
#include <stdio.h>
int main(void){
int month,day,chek;
while(std::cin >> month >> day,month){ int year = 2004;
if(month == 1 || month == 2){year--;month+=12;}
chek = ((year+ year/4-year/100+year/400+(13*month+8)/5+day)%7);
switch (chek) {case 0:puts("Sunday");break; case 1:puts("Monday");break; case 2:puts("Tuesday");break; case 3:puts("Wednesday");break;
case 4:puts("Thursday");break; case 5:puts("Friday");break; case 6:puts("Saturday");break; }}return 0;} | 1 |
#pragma GCC optimize ("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
#include"bits/stdc++.h"
using namespace std;
typedef long long ll;
#define int ll
#define all(x) x.begin(), x.end()
#define trav(i,a) for(auto &i:a)
inline int in(){int x;scanf("%lld",&x);return x;}
int cnt[100][100];
int32_t main()
{
int n=in();
int ans=0;
for(int j=0;j<n;j++)
{
double x;
cin>>x;
int i=llround(x*1e9);
int t=0,f=0;
//cout<<i<<"\n";
while(i%2==0)t++,i/=2;
while(i%5==0)f++,i/=5;
for(int x=max(18-t,0LL);x<70;x++)
for(int y=max(18-f,0LL);y<70;y++)
ans+=cnt[x][y];
cnt[t][f]++;
}
cout<<ans;
}
| // A.
#include <stdio.h>
typedef long long LL;
char buffer[3072000];
LL cnt[20][20];
LL sum[20][20];
LL n;
LL ans;
int main(int argc, char* argv[]) {
char c, *bufptr = buffer;
fread(buffer, 1, 3072000, stdin);
while ((c = *bufptr++) >= '0') {
n = (n * 10) + (c - '0');
}
for (LL i = 0; i < n; ++i) {
LL x = 0, two = 0, five = 0, df = 0;
while ((c = *bufptr++) >= ' ') {
if (c == '.') {
df = -1;
} else {
x = (x * 10) + c - '0';
five += df;
}
}
two = __builtin_ctzll(x);
x >>= two;
two += five;
while (x % 5 == 0) {
++five;
x /= 5;
}
if (two > 9) two = 9;
if (five > 9) five = 9;
cnt[10 + two][10 + five] += 1;
sum[10 - two][10 - five] += 1;
}
for (int i = 0; i < 20; ++i) {
for (int j = 1; j < 20; ++j) {
sum[i][j] += sum[i][j - 1];
}
}
for (int i = 1; i < 20; ++i) {
for (int j = 0; j < 20; ++j) {
sum[i][j] += sum[i - 1][j];
}
}
for (int i = -9; i <= 9; ++i) {
for (int j = -9; j <= 9; ++j) {
ans += sum[10 + i][10 + j] * cnt[10 + i][10 + j];
if (i >= 0 && j >= 0) {
ans -= cnt[10 + i][10 + j];
}
}
}
printf("%lld\n", ans >> 1);
return 0;
}
| 1 |
#include <iostream>
#include <string>
#include <cstring>
#include <sstream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <stack>
#include <queue>
#include <chrono>
#include <numeric>
using namespace std;
class cLSearch
{
int mn, mq;
string mS, mT;
vector<int> vs, vt;
int ans;
void decode();
public:
cLSearch(const int &n, const int &q, const string &s, const string &t)
{
mn = n;
mq = q;
mS = s;
mT = t;
decode();
}
void search();
void output();
};
void cLSearch::search()
{
sort(vs.begin(), vs.end());
sort(vt.begin(), vt.end());
int count = 0;
vector<int>::iterator vis = vs.begin();
vector<int>::iterator vit = vt.begin();
int ts, tt;
while (vis != vs.end() && vit != vt.end())
{
if (*vis == *vit)
{
++count;
ts = *vis;
tt = *vit;
while (vis != vs.end() && ts == *vis)
++vis;
while (vit != vt.end() && tt == *vit)
++vit;
}
else
{
if (vis != vs.end() && vit != vt.end() && *vis > *vit)
++vit;
else
++vis;
}
}
ans = count;
}
void cLSearch::output()
{
cout << ans << endl;
}
void cLSearch::decode()
{
istringstream iss;
iss.str(mS);
int ts;
for (int i = 0; i < mn; ++i)
{
iss >> ts;
vs.push_back(ts);
}
iss.str(mT);
iss.seekg(0, iss.beg);
for (int i = 0; i < mq; ++i)
{
iss >> ts;
vt.push_back(ts);
}
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, q;
string s, t;
cin >> n;
cin.ignore();
getline(cin, s);
cin >> q;
cin.ignore();
getline(cin, t);
cLSearch cls(n, q, s, t);
cls.search();
cls.output();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
const int N = 16;
int a[N + 1][N + 1];
ll value[1 << N];
ll f[1 << N];
int main() {
int n; cin >> n;
for(int i = 0; i < n; ++i) {
for(int j = 0; j < n; ++j) {
cin >> a[i][j];
}
}
for(int i = 1; i < (1 << n); ++i) {
vector<int> vec;
for(int j = 0; j < n; ++j) {
if((i >> j)&1) vec.pb(j);
}
value[i] = 0;
for(int x : vec) {
for(int y : vec) {
value[i] += a[x][y];
}
}
value[i] /= 2;
}
for(int i = 0; i < (1 << n); ++i) {
f[i] = 0;
for(int j = i; j > 0; j = (j - 1)&i) {
f[i] = max(f[i], value[j] + f[i^j]);
}
}
cout << f[(1 << n) - 1] << endl;
} | 0 |
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int scores[2] = {0, 0};
int points[2][10];
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 10; ++j) {
cin >> points[i][j];
}
sort(points[i], points[i]+10);
for (int j = 0; j < 3; ++j) {
scores[i] += points[i][9 - j];
}
}
cout << scores[0] << ' ' << scores[1] << endl;
return 0;
} | #include <iostream>
#include <algorithm>
using namespace std;
// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0533
int main() {
int a[10], b[10];
for (int i = 0; i < 10; i++) cin >> a[i];
for (int i = 0; i < 10; i++) cin >> b[i];
sort(a, a + 10);
sort(b, b + 10);
cout << (a[7] + a[8] + a[9]);
cout << " ";
cout << (b[7] + b[8] + b[9]) << endl;
return 0;
} | 1 |
#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <algorithm>
#include <sstream>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <numeric>
#include <cmath>
#include <climits>
#include <limits>
#include <cfloat>
#include <fstream>
using namespace std;
#define SIZE 12
void init_v (vector <vector <bool> >& v )
{
int size = v.size();
int i, j;
for (i = 0; i < size; ++i){
v[i][0] = true;
v[i][size - 1] = true;
} // end for
for (j = 0; j < size; ++j){
v[0][j] = true;
v[size - 1][j] = true;
} // end for
}
void dfs (vector <vector <bool> >& v, vector <vector <int> > m, int row, int col )
{
const int dir[][2] = { { 0, 1 }, { 1, 0 }, { 0, -1}, { -1, 0 } }; // ツ右ツ可コツ債カツ湘」
int k;
v[row][col] = true;
for (k = 0; k < 4; ++k){
if ( m[ row + dir[k][0] ][ col + dir[k][1] ] == 1
&& !v[ row + dir[k][0] ][ col + dir[k][1] ] ){
dfs (v, m, row + dir[k][0], col + dir[k][1] );
} // end if
} // end for
}
void disp_map (vector <vector <int> > m )
{
int size = m.size();
int len = m[0].size();
int i, j;
for (i = 0; i < size; ++i){
for (j = 0; j < len; ++j){
cout << setw(2) << m[i][j] << ' ';
} // end for
cout << endl;
} // end for
}
void disp_v (vector <vector <bool> > m )
{
int size = m.size();
int len = m[0].size();
int i, j;
for (i = 0; i < size; ++i){
for (j = 0; j < len; ++j){
cout << setw(2) << m[i][j] << ' ';
} // end for
cout << endl;
} // end for
}
int main()
{
// cut here before submit
// freopen("testcase.island", "r", stdin);
string str = "";
int i = 1, j;
vector <vector<int> > Map (SIZE + 2, vector <int> (SIZE + 2, 0 ) );
while (getline (cin, str ) ){
if (str.empty() ){
// Map.clear();
i = 1;
continue;
} // end if
stringstream ss(str);
ss >> str;
for (j = 1; j <= SIZE; ++j){
Map[i][j] = str[j-1] - '0';
} // end for
++i;
if (i <= SIZE){
continue;
} // end if
// cout << "i: " << i << endl;
// disp_map (Map);
int res = 0;
vector <vector<bool> > visit (SIZE + 2, vector<bool> (SIZE + 2, false ) );
init_v (visit );
int row, col;
for (row = 1; row < SIZE + 2; ++row){
for (col = 1; col < SIZE + 2; ++col){
if ( Map[row][col] == 1 && !visit[row][col]){
++res;
dfs (visit, Map, row , col );
// disp_v (visit );
// cout << endl;
} // end if
if (!visit[row][col]){
visit[row][col] = true;
} // end if
} // end for
} // end for
cout << res << endl;
} // end loop
// cout << res << endl;
return 0;
} | #include <stdio.h>
char str[16][16];
/*
void erase(int x, int y)
{
if (x < 0 || x > 11 || y < 0 || y > 11) return;
if (str[y][x] == '0') return;
str[y][x] = '0';
erase(x + 1, y);
erase(x, y + 1);
erase(x - 1, y);
erase(x, y - 1);
}
*/
void is(int i, int j)
{
int n;
int k;
str[i][j] = '0';
k = 1;
for (n = 0; n < 2; n++){
if (str[i + k][j] == '1' && i + k >= 0 && i + k < 12){
is(i + k, j);
}
if (str[i][j + k] == '1' && j + k >= 0 && j + k < 12){
is(i, j + k);
}
k = -1;
}
}
int main(void)
{
int i, j;
int ans;
int a;
// int case_ = 0;
while (1){
// if (case_) fgets(str[0], 16, stdin);
// case_++;
ans = 0;
for (i = 0; i < 12; i++){
if (fgets(str[i], 16, stdin) == NULL){
return (0);
}
}
for (i = 0; i < 12; i++){
for (j = 0; j < 12; j++){
if (str[i][j] == '1'){
is(i, j);
str[i][j] = '1';
ans++;
}
}
}
printf("%d\n", ans);
if (fgets(str[0], 16, stdin) == NULL) return(0);
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int r;
cin >> r;
cout << fixed << setprecision(20) << 2*r*M_PI << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define endl "\n"
#define REP(i,a,n) for(ll i=a;i<n;i++)
#define PER(i,n,a) for(ll i=n;i>a;i--)
#define REP1(i,a,n) for(ll i=a;i<=n;i++)
#define forit(it,x) for(auto it=(x).begin();it!=(x).end();++it)
#define ull unsigned long long int
#define ld long double
#define prec(n) fixed<<setprecision(n)
#define test ll t; cin>>t; while(t--)
#define re return 0
#define pb push_back
#define PI 3.1415926535897932384626
#define MOD (ll)1000000007
#define fi first
#define se second
#define eb emplace_back
#define vll vector<ll>
#define vi vector<int>
#define mpll map<ll,ll>
#define pll pair<ll,ll>
#define mp(x,y) make_pair(x,y)
const ll MAXI = (ll)1e9+7;
int main(){
IOS;
/* test{
int n;
cin>>n;
int ar[n];
REP(i,a,n){
cin>>ar[i];
}
}
*/
string str;
cin>>str;
if(str=="SUN"){
cout<<"7"<<"\n";
}else if(str=="MON"){
cout<<"6"<<"\n";
}else if(str=="TUE"){
cout<<"5"<<"\n";
}else if(str=="WED"){
cout<<"4"<<"\n";
}else if(str=="THU"){
cout<<"3"<<"\n";
}else if(str=="FRI"){
cout<<"2"<<"\n";
}else if(str=="SAT"){
cout<<"1"<<"\n";
}
re;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
signed main () {
int n;
cin >> n;
if (n == 0) {
cout << 0 << '\n';
return 0;
}
string ans;
while (n) {
if (n % (-2) == 0)
ans += '0';
else
--n, ans += '1';
n /= -2;
}
reverse(ans.begin(), ans.end());
cout << ans << '\n';
}
| #include <bits/stdc++.h>
#include <math.h>
using namespace std;
int main() {
int N, sum, digit;
cin >> N;
digit = log10(N);
sum = 0;
for (int i = 0; i <= digit; i++) {
sum += N % (int (pow(10, i + 1))) / (int (pow(10, i)));
}
if (N % sum == 0) {
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
}
| 0 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<ctime>
#include<queue>
#include<set>
#include<map>
#include<stack>
using namespace std;
typedef long long LL;
int gi() {
int w=0;bool q=1;char c=getchar();
while ((c<'0'||c>'9') && c!='-') c=getchar();
if (c=='-') q=0,c=getchar();
while (c>='0'&&c <= '9') w=w*10+c-'0',c=getchar();
return q? w:-w;
}
const int N=110;
int h[N][N],u[N][N];
int f[N][N][N],g[N][N][N];
inline void upd(int &x,int y) { x<y?x=y:0; }
int main()
{
int n=gi(),m=gi(),i,j,x,y,lx,rx,ly,ry,t;
char c;
for (i=1;i<=n;i++)
for (j=1;j<=m;j++) {
h[i][j]=h[i][j-1];u[i][j]=u[i-1][j];
while ((c=getchar())!='.'&&c!='E'&&c!='o');
if (c=='E') x=i,y=j;
else if (c=='o') h[i][j]++,u[i][j]++;
}
for (lx=0;lx<x;lx++) {
memcpy(g,f,sizeof(g));
memset(f,0,sizeof(f));
for (rx=0;rx<=n-x;rx++)
for (ly=0;ly<y;ly++)
for (ry=0;ry<=m-y;ry++) {
t=g[rx][ly][ry];
upd(f[rx][ly][ry],t+(x-lx-1>rx?h[x-lx-1][min(y+ry,m-ly)]-h[x-lx-1][max(y-ly-1,ry)]:0));
upd(g[rx+1][ly][ry],t+(x+rx+1<=n-lx?h[x+rx+1][min(y+ry,m-ly)]-h[x+rx+1][max(y-ly-1,ry)]:0));
upd(g[rx][ly+1][ry],t+(y-ly-1>ry?u[min(x+rx,n-lx)][y-ly-1]-u[max(x-lx-1,rx)][y-ly-1]:0));
upd(g[rx][ly][ry+1],t+(y+ry+1<=m-ly?u[min(x+rx,n-lx)][y+ry+1]-u[max(x-lx-1,rx)][y+ry+1]:0));
}
}
printf("%d\n",g[n-x][y-1][m-y]);
return 0;
}
| #include<bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define all(v) (v).begin(),(v).end()
using namespace std;
using ll=long long;
using pii=pair<int, int>;
using vi=vector<int>;
using vii=vector<vector<int>>;
const ll LINF=1LL<<60;
const int INF=1<<29;
const int MOD=1e9+7;
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;}
const int MAX_N=1005;
const int MAX_V=MAX_N*(MAX_N-1)/2;
vii G(MAX_V);
int id[MAX_N][MAX_N];
bool vis[MAX_V];
bool fin[MAX_V];
int dp[MAX_V];
int dfs(int v){
if(vis[v]){
if(!fin[v]) return -1;
else return dp[v];
}
vis[v]=true;
dp[v]=1;
for(auto &nv : G[v]){
int res=dfs(nv);
if(res == -1) return -1;
dp[v]=max(dp[v], res+1);
}
fin[v]=true;
return dp[v];
}
int main(){
int n; cin >> n;
vii a(n, vi(n-1));
for(int i=0; i<n; i++){
for(int j=0; j<n-1; j++){
cin >> a[i][j];
a[i][j]--;
}
}
int num=0;
for(int i=0; i<n-1; i++) for(int j=i+1; j<n; j++) id[i][j]=num++;
for(int i=0; i<n; i++){
for(int j=0; j<n-1; j++){
if(i > a[i][j]) a[i][j]=id[a[i][j]][i];
else a[i][j]=id[i][a[i][j]];
}
for(int j=0; j<n-2; j++){
G[a[i][j]].push_back(a[i][j+1]);
}
}
int ans=0;
for(int i=0; i<num; i++){
int res=dfs(i);
if(res == -1){
ans=-1;
break;
}
chmax(ans, res);
}
cout << ans << endl;
return 0;
} | 0 |
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <map>
#include <algorithm>
#include <math.h>
#include <cassert>
#define rep(i,n) for(int i = 0; i < n; ++i )
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
ll n,a,b;
cin >> n >> a >> b;
vector<ll> x(n);
rep(i,n) cin >> x[i];
ll ans = 0;
rep(i,n-1) ans += min((x[i+1]-x[i])*a,b);
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
#define int long long
signed main(){
int N,A,B,n;
cin>>N>>A>>B>>n;
vector<int> C(N);
C[0]=n;
int ans=0;
for(int i=1;i<N;i++){
cin>>C[i];
ans+=min((C[i]-C[i-1])*A,B);
}
cout<<ans<<endl;
} | 1 |
#include<bits/stdc++.h> //Ithea Myse Valgulious
namespace chtholly{
typedef long long ll;
#define re0 register int
#define rel register ll
#define rec register char
#define gc getchar
//#define gc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<23,stdin),p1==p2)?-1:*p1++)
#define pc putchar
#define p32 pc(' ')
#define pl puts("")
/*By Citrus*/
char buf[1<<23],*p1=buf,*p2=buf;
inline int read(){
int x=0,f=1;char c=gc();
for (;!isdigit(c);c=gc()) f^=c=='-';
for (;isdigit(c);c=gc()) x=(x<<3)+(x<<1)+(c^'0');
return f?x:-x;
}
template <typename mitsuha>
inline bool read(mitsuha &x){
x=0;int f=1;char c=gc();
for (;!isdigit(c)&&~c;c=gc()) f^=c=='-';
if (!~c) return 0;
for (;isdigit(c);c=gc()) x=(x<<3)+(x<<1)+(c^'0');
return x=f?x:-x,1;
}
template <typename mitsuha>
inline int write(mitsuha x){
if (!x) return 0&pc(48);
if (x<0) pc('-'),x=-x;
int bit[20],i,p=0;
for (;x;x/=10) bit[++p]=x%10;
for (i=p;i;--i) pc(bit[i]+48);
return 0;
}
inline char fuhao(){
char c=gc();
for (;isspace(c);c=gc());
return c;
}
}using namespace chtholly;
using namespace std;
const int aoi=2038,mod=1e9+7;
ll dp[aoi],inv[aoi];
ll kasumi(ll a,ll b=mod-2) {
ll s=1;
for (;b;b>>=1,a=a*a%mod) if (b&1) s=s*a%mod;
return s;
}
int main() {
int n,a,b,c,d,i,j,k;
read(n),read(a),read(b),read(c),read(d);
for (dp[n]=i=1;i<=n;++i) dp[n]=dp[n]*i%mod;
inv[n]=kasumi(dp[n]);
for (i=n;i;--i) inv[i-1]=inv[i]*i%mod;
for (i=a;i<=b;++i)
for (j=0;j<=n;++j)
for (k=c;k<=d&&j+i*k<=n;++k)
dp[j]=(dp[j]+dp[j+i*k]*kasumi(inv[i],k)%mod*inv[k]%mod)%mod;
cout<<*dp<<"\n";
} | #include <bits/stdc++.h>
using namespace std;
inline void prep ()
{
cin.tie (0);
cin.sync_with_stdio (0);
};
const double pi = acos(-1.);
//printf(%.12lf\n,mid);
// __builtin_popcount(int) count 1's in binary
// get decimal part of number
/*
double intpart;
double thiss = modf((double)(n*m)/(double)k, &intpart);
*/
// round = (int)(num+.5)
long long mod = 1000000007;
// 32 mil = ~1 sec
long long mymod(long long num){
if (num< 0 && !(num%mod == 0)){
if (mod == 1){
return 0;
}
return mod-abs(num)%mod;
}else{
return num%mod;
}
}
/*string sentence = And I feel fine...;
istringstream iss(sentence);
*/
double eps = .000000001;
long long modpow(long long x, long long n) {
if (n == 0) return 1%mod;
long long u = modpow(x,n/2);
u = (u*u)%mod;
if (n%2 == 1) u = (u*x)%mod;
return u;
}
long long n, a, b, c, d;
bool memoo[1001][1001];
long long memo[1001][1001];
long long shortmod(long long num){
if (num >= mod){
num -= mod;
}
return num;
}
void EE(int a, int b, int& x, int& y)
{
if(a%b == 0)
{
x=0;
y=1;
return;
}
EE(b,a%b,x,y);
int temp = x;
x = y;
y = temp - y*(a/b);
}
int inverse(int a)
{
int x,y;
EE(a,mod,x,y);
if(x<0) x += mod;
return x;
}
long long facts[1001];
long long invfacts[1001];
long long inverses[1001];
long long func(int left, int grpsze){
if (left == 0 && grpsze > b){
return 1;
}
if (left < 0 || grpsze > b){
return 0;
}
if (memoo[left][grpsze]){
return memo[left][grpsze];
}
long long res = 0;
long long choose = 1;
int templeft = left;
templeft -= grpsze*(c-1);
choose *= modpow(invfacts[grpsze], c-1);
choose %= mod;
choose *= invfacts[c-1];
choose %= mod;
for (int i=c; i <= d; i++){
if (templeft <= 0){
break;
}
choose *= invfacts[grpsze];
choose %= mod;
choose *= inverses[i];
choose %= mod;
templeft -= grpsze;
res += (choose*func(templeft, grpsze+1))%mod;
res = shortmod(res);
}
res += func(left, grpsze+1);
res = shortmod(res);
memoo[left][grpsze] = true;
memo[left][grpsze] = res;
return res;
}
int main ()
{
prep();
cin >> n >> a >> b >> c >> d;
long long cur = 1;
for (int i=1; i<=1000; i++){
cur *= i;
cur %= mod;
facts[i] = cur;
}
facts[0] = 1;
invfacts[0] = 1;
inverses[0] = 1;
cur = 1;
for (int i=1; i<=1000; i++){
cur *= inverse(i);
cur %= mod;
invfacts[i] = cur;
}
for (int i=1; i<=1000; i++){
inverses[i] = inverse(i);
}
cout << (facts[n]*func(n, a))%mod;
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(n); i++)
using namespace std;
using ll=long long;
int main(){
int N,count=0;
cin >> N;
vector<int> L(N);
rep(i,N) cin >> L.at(i);
for(int i=0; i<N-2; i++){
for(int j=i+1;j<N-1;j++){
for(int k=j+1;k<N;k++){
int a=L.at(i),b=L.at(j),c=L.at(k);
if(a+b>c&&a+c>b&&b+c>a&&a!=b&&b!=c&&a!=c) count++;
}
}
}
cout << count << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define forn(i, n) for(int i = 0; i < int(n); i++)
#define fore(i, l, r) for(int i = int(l); i < int(r); i++)
#define pb push_back
#define all(x) x.begin(), x.end()
#define sz(a) int((a).size())
typedef long long ll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef pair<int, int> pii;
const int mod = 1e9 + 7;
template<class T, class U> inline void add_self(T &a, U b){a += b;if (a >= mod) a -= mod;if (a < 0) a += mod;}
template<class T, class U> inline void min_self(T &x, U y) { if (y < x) x = y; }
template<class T, class U> inline void max_self(T &x, U y) { if (y > x) x = y; }
#define _deb(x) cout<<x;
void _print() {cerr << "]\n";} template <typename T, typename... V>void _print(T t, V... v) {_deb(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#define deb(x...) cerr << "[" << #x << "] = ["; _print(x)
template <class T, class U> void print_m(const map<T,U> &m, int w=3){if(m.empty()){cout<<"Empty"<<endl; return;}for(auto x: m)cout<<"("<<x.first<<": "<<x.second<<"),"<<endl;cout<<endl;}
template<class T, class U>void debp(const pair<T, U> &pr, bool end_line=1){cout<<"{"<<pr.first<<" "<<pr.second<<"}"; cout<<(end_line ? "\n" : ", ");}
template <class T> void print_vp(const T &vp, int sep_line=0){if(vp.empty()){cout<<"Empty"<<endl; return;}if(!sep_line) cout<<"{ ";for(auto x: vp) debp(x,sep_line);if(!sep_line) cout<<"}\n";cout<<endl;}
template <typename T>void print(const T &v, bool show_index = false){int w = 2;if(show_index){for(int i=0; i<sz(v); i++)cout<<setw(w)<<i<<" ";cout<<endl;}for(auto &el: v) cout<<setw(w)<<el<<" ";cout<<endl;}
template <typename T>void print_vv(const T &vv){if(sz(vv)==0) {cout<<"Empty"<<endl; return;} int w = 3;cout<<setw(w)<<" ";for(int j=0; j<sz(*vv.begin()); j++)cout<<setw(w)<<j<<" ";cout<<endl;int i = 0;for(auto &v: vv){cout<<i++<<" {";for(auto &el: v) cout<<setw(w)<<el<<" ";cout<<"},\n";}cout<<endl;}
int main(){
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int n;
while(cin>>n){
vl a(n);
forn(i,n) cin>>a[i];
sort(all(a));
ll ans = 0;
fore(i,0,n){
fore(j,i+1,n){
fore(k,j+1,n){
if(a[i]<a[j]+a[k] && a[j]<a[i]+a[k] && a[k]<a[i]+a[j] && a[i]!=a[j] && a[j]!=a[k] && a[i]!=a[k]){
++ans;
}
}
}
}
cout<<ans<<"\n";
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define sz(x) (int)x.size()
#define rep(i,n) for(int i = 0; i < n; i++)
#define REP(i, k , n) for(int i = k; i <= n; i++)
typedef long long ll;
const char nl = '\n' ;
const ll MOD = 1e9 + 7;
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0);
int a[3], k;
cin >> a[0] >> a[1] >> a[2] >> k;
sort(a, a+3);
cout << a[2]*pow(2,k) + a[1] + a[0] << nl;
return 0;
}
| #include <bits/stdc++.h>
#include <ext/rope>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#define int long long
#define pb push_back
#define x first
#define y second
#define mk(a,b) make_pair(a,b)
#define rr return 0
#define sqr(a) ((a)*(a))
#define all(a) (a).begin(), (a).end()
#define sz(a) (int)(a).size()
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template<class value, class cmp = less<value> >
using ordered_set = tree<value, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class value, class cmp = less_equal<value> >
using ordered_multiset = tree<value, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class key, class value, class cmp = less<key> >
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
/// find_by_order()
/// order_of_key()
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int randll(int l = INT_MIN, int r = INT_MAX) {
return uniform_int_distribution<int>(l, r)(rng);
}
const int INF = 1e9, MOD = 1e9 + 7; /// think
const ll LINF = 1e18;
const int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
inline bool inside (int x, int y, int n, int m) {
return 0 <= x && 0 <= y && x < n && y < m;
}
template<class T> bool umin (T &a, T b) {return a > b ? (a = b, true) : false; }
template<class T> bool umax (T &a, T b) {return a < b ? (a = b, true) : false; }
main()
{
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
cout << n + n * n + n * n * n << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
vector<int> a(2);
int k;
cin >> a[0] >> a[1] >> k;
int times = 0;
int side = 0;
while(1){
if(a[side] % 2 == 1) a[side] -= 1;
a[side] /= 2;
a[(side+1)%2] += a[side];
side += 1;
side %= 2;
times += 1;
if(times == k) break;
}
cout << a[0] << " " << a[1] << endl;
return 0;
} | #include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <numeric>
#include <string>
#include <algorithm>
#include <iostream>
#include <vector>
#include <bitset>
#include <queue>
#include <map>
#include <utility>
#include<functional>
#include <iomanip>
#include <unordered_map>
#include <set>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<ll,ll> prll;
#define MOD 1000000007 //10億 = 10^9になってる
#define juu 100000 //10万 10e5
#define hyaku 1000000 //100万 10e6
#define mINF -922337200085470000 //llのmax-1桁の小さい方
#define pINF 922337203600070000 //llのmax-1桁のデカい方
#define uINF 1844674407399900000 //ullのmax-1桁してる
#define pi 3.1415926535897932384
#define all(v) v.begin(), v.end()
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
ll factor[300];
ll memory[300];
/*素朴法で計算
factorは必ずmemset(factor,0,sizeof(factor));
グローバルであるmemoryに個数を書き込む
memory配列の走査にはfactorの要素を使う*/
void primefac(ll num)
{
int i = 0, kosuu = 0;
while (*(factor + i) != 0)
{
while (num % *(factor + i) == 0)
{
num /= *(factor + i);
memory[*(factor + i)] += 1;
}
if (num == 1)
break;
i++;
}
}
/*グローバルにあるfactorに素数書き込む.個数を返すので配列は-1しろforは<*/
int elast(ll number)
{
ll tmp = 0;
int flag = 0;
*factor = 2;
for (int i = 3; i <= number; i++)
{
flag = 0;
for (int j = 0; j <= tmp; j++)
{
if (i % (*(factor + j)) == 0)
{
flag = 1;
break;
}
}
if (flag)
continue;
tmp += 1;
*(factor + tmp) = i;
}
return tmp + 2;
}
/*intで収まる範囲であってくれ*/
ll nCr(ll n, ll r)
{
ll val = 1;
ll i;
if (r == 0)
return 1;
for (i = 0; i < n - r; i++)
{
val *= (n - i);
val /= (i + 1);
}
return val;
}
/*intで収まる範囲であってくれ*/
ll nPr(ll n, ll r)
{
ll val = 1;
ll i;
for (i = 0; i < r; i++)
{
val *= (n - i);
}
return val;
}
template <typename T>
bool chmin(T &a, const T b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
template <typename T>
bool chmax(T &a, const T b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
/*ソートして被りを無くす*/
template <typename T>
void eraseSame(T &a)
{
sort(all(a));
a.erase(unique(all(a)), a.end());
}
/*aとbで大きい方を後ろにする。変更なしならtrue、ありならfalse */
template <typename T>
bool swapmax(T &a, T &b)
{
T temp;
temp = a;
if (a > b)
{
a = b;
b = temp;
return false;
}
return true;
}
ll gcd(ll x, ll y) { return (x % y) ? gcd(y, x % y) : y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
/*一行に入力が何個あるかを1,ぶち込むvectorを2*/
template <typename T>
void splitIn(ll N, vector<T> &array)
{
T temp;
int i = 0;
if(N == 0){
return ;
}
array.resize(N);
while (cin >> temp)
{
array[i] = temp;
i++;
if (i >= N)
{
break;
}
}
return;
}
int main()
{
ll n,k,m;
ll ans = 0;
ll tm1,tm2;
string s;
vector<ll> v;
cin >> n >> m >> k;
rep(i,k){
if(i%2 == 1){
m/=2;
tm2 = m;
n += tm2; }
else{
n/= 2;
tm1 = n;
m += tm1;
}
}
cout << n <<" " << m;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll n;
cin>>n;
vector<vector<pair<ll,ll>>>ro(n+1);
for(int i=0;i<n-1;i++){
ll a,b,c;
cin>>a>>b>>c;
ro[a].push_back({b,c});
ro[b].push_back({a,c});
}
queue<ll>que;
ll q,k;
cin>>q>>k;
ll dis[114514];
for(int i=1;i<=n;i++)dis[i]=-1;
que.push(k);
dis[k]=0;
while(!que.empty()){
ll x=que.front();
que.pop();
for(int i=0;i<ro[x].size();i++){
if(dis[ro[x][i].first]!=-1)continue;
dis[ro[x][i].first]=dis[x]+ro[x][i].second;
que.push(ro[x][i].first);
}
}
for(int i=0;i<q;i++){
ll a,b;
cin>>a>>b;
cout<<dis[a]+dis[b]<<endl;
}
return 0;
}
| #include <iostream>
#include<iomanip>
#include <cmath>
#include <climits>
#include <algorithm>
#include <stdio.h>
#include <vector>
#include <queue>
#include <tuple>
#include <map>
#include <list>
#include <string>
#include <numeric>
#include <utility>
#include <cfloat>
#include <set>
using namespace std;
int sqrtN = 512;
struct SqrtDecomposition{
int N, K;
vector <long long> data;
vector <long long> bucketUpdatedLazy;
SqrtDecomposition(int n){
N = n;
K = (N + sqrtN - 1) / sqrtN;
data.assign(N, ((long long) 1 << 31) - 1);
bucketUpdatedLazy.assign(K, -1);
}
void propagateLazy(int k){
if(bucketUpdatedLazy[k] < 0){
return;
}
for(int i = 0; i < sqrtN; i++){
data[k * sqrtN + i] = bucketUpdatedLazy[k];
}
bucketUpdatedLazy[k] = -1;
}
long long get(int x){
propagateLazy(x / sqrtN);
return data[x];
}
void update(int x, int y, int a){
if(y - x < sqrtN){
propagateLazy(x / sqrtN);
propagateLazy((y - 1) / sqrtN);
for(int i = x; i < y; i++){
data[i] = a;
}
return;
}
for(int i = x / sqrtN + 1; i < y / sqrtN; i++){
bucketUpdatedLazy[i] = a;
//if(bucketUpdatedLazy[i] < 0 && bucketUpdatedLazy[i] != -1){
// cerr << "Warning" << endl;
//}
}
propagateLazy(x / sqrtN);
for(int i = x; i < (x / sqrtN + 1) * sqrtN; i++){
data[i] = a;
}
propagateLazy((y - 1)/ sqrtN);
for(int i = y / sqrtN * sqrtN; i < y; i++){
data[i] = a;
}
}
};
int main(){
int n;
int q;
cin >> n >> q;
SqrtDecomposition sq(n);
for(int i = 0; i < q; i++){
int com;
int s;
int t;
int x;
cin >> com;
if(com == 0){
cin >> s >> t >> x;
sq.update(s, t + 1, x);
} else {
cin >> x;
cout << sq.get(x) << endl;
}
}
return 0;
}
| 0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <deque>
using namespace std;
long long INF = 1e18;
int main() {
int N;
cin >> N;
vector<long long> A(N);
for(int i = 0; i < N; i++) {
cin >> A[i];
}
deque<long long> dp(N, INF);
for(int i = 0; i < N; i++) {
long long p = lower_bound(dp.begin(), dp.end(), A[i]) - dp.begin();
if(p == 0) {
dp.push_front(A[i]);
} else {
dp[p - 1] = A[i];
}
}
cout << lower_bound(dp.begin(), dp.end(), INF) - dp.begin() << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef long double ld;
const int inf=1e9+7;
const ll longinf=1LL<<60;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
#define F first
#define S second
constexpr char ln = '\n';
const int mx=100010;
const ll mod=1e9+7;
#define bit(n,k) ((n>>k)&1) //*n no k bit me 1 or 0*/
vector<vector<ll>> a(20, vector<ll>(20,0));
vector<ll> dp((1<<18),-longinf);
int n;
ll rec(ll x){
if(dp[x]!=-longinf) return dp[x];
ll cur = 0;
rep(i,n)rep(j,i)if(bit(x,i) && bit(x,j)){ cur += a[i][j]; }
for(ll i=(1<<n)-1; i>=0; i--){
i &= x; //x bubun syugo //https://primenumber.hatenadiary.jp/entry/2016/12/01/000000
if(i==x || i==0) continue;
cur = max(cur, rec(i) + rec(i^x));
}
return dp[x] = cur;
}
int main(){
cin >> n;
rep(i,n)rep(j,n){
cin >> a[i][j];
}
ll ans = rec((1<<n)-1);
cout << ans << ln;
return 0;
} | 0 |
#include <iostream>
using namespace std;
static int bubbleSort(int *A, int N){
int temp, count=0;
bool flag;
do{
flag = false;
for (int j = N - 1; j >= 1; j--){
if (A[j] < A[j - 1]){
temp = A[j];
A[j] = A[j - 1];
A[j - 1] = temp;
count++;
flag = true;
}
}
} while (flag);
return count;
}
int main(void){
int N, *A, count;
cin >> N;
A = new int[N];
for (int i = 0; i < N; i++){
cin >> A[i];
}
count = bubbleSort(A, N);
for (int i = 0; i < N; i++){
cout << A[i];
if (i != N - 1){
cout << " ";
}
}
cout << "\n" << count <<"\n";
return 0;
} | #include <iostream>
#include <complex>
#include <cmath>
#include <iomanip>
#include <algorithm>
using namespace std;
void rotate(int a[], string str)
{
for(auto itr = str.begin(); itr != str.end(); ++itr)
{
int tmp;
switch (*itr) {
case 'N':
tmp = a[0];
a[0] = a[1];
a[1] = a[5];
a[5] = a[4];
a[4] = tmp;
break;
case 'S':
tmp = a[0];
a[0] = a[4];
a[4] = a[5];
a[5] = a[1];
a[1] = tmp;
break;
case 'W':
tmp = a[3];
a[3] = a[0];
a[0] = a[2];
a[2] = a[5];
a[5] = tmp;
break;
case 'E':
tmp = a[2];
a[2] = a[0];
a[0] = a[3];
a[3] = a[5];
a[5] = tmp;
break;
}
}
}
int isSame(int a[], int b[])
{
bool flag;
for (int i = 0; i < 6; ++i) {
flag = false;
for (int j = 0; j < 6; ++j) {
if (a[i] == b[j]) {
flag = true;
break;
}
}
if (flag==false)
break;
}
if (flag == false) {
return 0;
}
int t = b[0], f = b[1];
if (t == a[5])
rotate(a, "NN");
else if (t == a[1])
rotate(a, "N");
else if (t == a[3])
rotate(a, "E");
else if (t == a[2])
rotate(a, "W");
else if (t == a[4])
rotate(a, "S");
if (f == a[3])
rotate(a, "ESW");
else if (f == a[2])
rotate(a, "WSE");
else if (f == a[4])
rotate(a, "SENWSE");
for (int i = 0; i < 6; ++i) {
if (a[i] != b[i]) {
return 0;
}
}
return 1;
}
int main(void)
{
int a[100][6], n;
cin >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 6; ++j)
cin >> a[i][j];
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (i == j)
continue;
if (isSame(a[j], a[i]) == 1) {
cout << "No" << endl;
return 0;
}
}
}
cout << "Yes" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define DB double
#define ST string
#define BS bitset
#define VE vector
#define VL vector<LL>
#define VP vector<pair<LL,LL>>
#define VVL vector<vector<LL>>
#define PQ priority_queue<LL>
#define PQS priority_queue<LL, vector<LL>, greater<LL>>
#define PB push_back
#define POB pop_back
#define PF push_front
#define POF pop_front
#define MP make_pair
#define TS to_string
#define TU to_ullong
#define FOR(i,a,n) for(i=a;i<n;i++)
#define rep(i,n) FOR(i,0,n)
#define ALL(a) a.begin(),a.end()
#define RALL(a) a.rbegin(),a.rend()
#define SORT(a) sort(ALL(a))
#define REV(a) reverse(ALL(a))
#define UB(a,n) *upper_bound(ALL(a),n)
#define LB(a,n) *lower_bound(ALL(a),n)
#define INF 1145141919810364364
#define PI 3.14159265358979
//#define MOD 1000000007
#define MOD 998244353
#define ERR 0.00000000000001
#define NUM 200010
void Yn(LL a){if(a)printf("Yes\n");else printf("No\n");}
void YN(LL a){if(a)printf("YES\n");else printf("NO\n");}
LL pwmn(LL a,LL n){LL ans=1;while(ans<a)ans*=n;return ans;}
LL GCD(LL a,LL b){LL c=1,tmp=max(a,b);b=min(a,b);a=tmp;while(c!=0){c=a%b;a=b;b=c;}return a;}
LL LCM(LL a,LL b){return a*b/GCD(a,b);}
LL mod(LL a,LL m){if(a<0)return a%m+m;else return a%m;}
LL DIV(LL a,LL d){LL m=MOD,x=1,y=0,k;while(m){k=d/m;d-=k*m;swap(m,d);x-=k*y;swap(x,y);}return mod(a*mod(x,MOD),MOD);}
LL FAC(LL a){LL i,ans=1;FOR(i,1,a+1){ans*=i;if(MOD>0&&ans>MOD)ans%=MOD;}return ans;}
LL POW(LL a,LL n){LL ans=1;while(n>0){if(n&1)ans=ans*a%MOD;a=a*a%MOD;n>>=1;}return ans;}
LL fact[NUM],finv[NUM],inv[NUM];
void comi(){LL i;fact[0]=fact[1]=1;finv[0]=finv[1]=1;inv[1]=1;FOR(i,2,NUM){fact[i]=fact[i-1]*i%MOD;inv[i]=MOD-inv[MOD%i]*(MOD/i)%MOD;finv[i]=finv[i-1]*inv[i]%MOD;}}
LL com(LL n,LL k){if(n<k||n<0||k<0)return 0;return fact[n]*(finv[k]*finv[n-k]%MOD)%MOD;}
bool cmps(pair<LL,LL> a,pair<LL,LL> b){if(a.second!=b.second)return a.second<b.second;return a.first<b.first;}
struct UF{
private:
VL par;
public:
UF(LL n){par.resize(n,-1);}
LL root(LL x){if(par[x]<0)return x;else return par[x]=root(par[x]);}
LL size(LL x){return -par[root(x)];}
bool same(LL x,LL y){return root(x)==root(y);}
void unite(LL x,LL y){x=root(x);y=root(y);if(x!=y){if(size(x)<size(y))swap(x,y);par[x]+=par[y];par[y]=x;}}
};
typedef struct{LL s,e,c,n;}Edge;
bool cmpc(Edge a,Edge b){return a.c<b.c;}
struct Kruscal{
private:UF *uf;VE<Edge> ed;
public:
VE<Edge> edge;
Kruscal(LL N){uf=new UF(N);}
void add(LL s,LL e,LL c,LL n=0){Edge f;f.s=s,f.e=e,f.c=c,f.n=n;ed.PB(f);}
void run(){sort(ALL(ed),cmpc);for(Edge a:ed){if(uf->same(a.s,a.e))continue;else{edge.PB(a);uf->unite(a.s,a.e);}}}
};
typedef struct{LL x,y,n;}Node;
bool cmpx(Node a,Node b){return a.x<b.x;}
bool cmpy(Node a,Node b){return a.y<b.y;}
int main(){
LL i,N,ans=0;
cin>>N;
VE<Node> v(N);
Kruscal k(2*N-2);
rep(i,N){
cin>>v[i].x>>v[i].y;
v[i].n=i;
}
sort(ALL(v),cmpx);
rep(i,N-1)k.add(v[i].n,v[i+1].n,v[i+1].x-v[i].x);
sort(ALL(v),cmpy);
rep(i,N-1)k.add(v[i].n,v[i+1].n,v[i+1].y-v[i].y);
k.run();
for(Edge a:k.edge)ans+=a.c;
cout<<ans<<endl;
}
| #include <bits/stdc++.h>
//#include<ext/pb_ds/assoc_container.hpp>
//#include<ext/pb_ds/tree_policy.hpp>
#define IOS ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define MAX 2000005
#define MOD 1000000007
#define MOD2 998244353
#define pb push_back
#define mp make_pair
#define pii pair<ll,ll>
#define vi vector<ll>
#define vp vector<pii>
#define all(v) v.begin(),v.end()
#define sz(x) (ll)x.size()
#define F first
#define S second
#define FOR(i,a,b) for(ll i=a;i<b;++i)
#define ROF(i,a,b) for(ll i=a;i>=b;--i)
#define trace(x) cerr<<#x<<": "<<x<<'\n';
typedef long long ll;
using namespace std;
//using namespace __gnu_pbds;
//#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>
ll mexp(ll a, ll b){
ll ans=1;
a%=MOD;
while(b){
if(b&1) ans=ans*a%MOD;
b>>=1;
a=a*a%MOD;
}
return ans;
}
const int N = 100005;
bool cmp1(pair<int,pair<int,int>>a, pair<int,pair<int,int>>b){
return a.S.F<b.S.F;
}
bool cmp2(pair<int,pair<int,int>>a, pair<int,pair<int,int>>b){
return a.S.S<b.S.S;
}
pair<int,pair<int,int>>c[N];
int par[N],siz[N];
int find(int x){
while(par[x]!=x){
x=par[x];
}
return x;
}
void un(int a,int b){
a=find(a);
b=find(b);
if(siz[a]<siz[b]){
par[a]=par[b];
siz[b]+=siz[a];
}
else{
par[b]=par[a];
siz[a]+=siz[b];
}
}
int main(){
IOS
int n;
cin>>n;
FOR(i,1,n+1){
par[i]=i;
siz[i]=1;
c[i].F=i;
cin>>c[i].S.F>>c[i].S.S;
}
vector<pair<int,pair<int,int>>>v;
sort(c+1,c+n+1,cmp1);
FOR(i,1,n){
v.pb(mp(c[i+1].S.F-c[i].S.F,mp(c[i].F,c[i+1].F)));
}
sort(c+1,c+n+1,cmp2);
FOR(i,1,n){
v.pb(mp(c[i+1].S.S-c[i].S.S,mp(c[i].F,c[i+1].F)));
}
sort(all(v));
int cnt=0;
int i=0;
ll ans=0;
while(cnt<n-1){
int x=find(v[i].S.F),y=find(v[i].S.S);
if(x==y){
i++;
continue;
}
un(x,y);
ans+=v[i].F;
i++;
cnt++;
}
cout<<ans;
cerr<<"Time: "<<1.0/CLOCKS_PER_SEC<<" ms"<<endl;
return 0;
} | 1 |
#include <iostream>
using ll = long long int;
constexpr ll mod = (1e9)+7;
constexpr int MAX = 2*1e5+10;
ll fac[MAX];
void init() {
fac[0]=1;
for(int i=1;i<MAX;++i)
fac[i]=(fac[i-1]*i)%mod;
}
ll inv(ll x){
ll n = mod-2;
ll y = 1;
ll z = 1;
for(int i=0;i<40;++i){
if(n&y) z = (z*x)%mod;
x=(x*x)%mod;
y*=2;
}
return z;
}
ll func(ll x, ll y) {
return ((x*(x+1)/2%mod)*y%mod + (y*(y+1)/2%mod)*x%mod)%mod;
}
ll g(ll x){return x*(x+1)/2%mod;}
int main(){
init();
int n, m, k;
std::cin>>n>>m>>k;
ll comb = (fac[n*m-2] * inv(fac[k-2]) % mod) * inv(fac[n*m-k]) % mod;
ll sum = 0;
for(int i=1;i<=n;++i){
for(int j=1;j<=m;++j){
sum+=func(i-1,j-1)+func(i-1,m-j)+func(n-i,j-1)+func(n-i,m-j)+g(i-1)+g(j-1)+g(m-j)+g(n-i);
sum%=mod;
}
}
std::cout<<((comb*sum)%mod)*inv(2)%mod<<std::endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int mod = 1e9 + 7;
ll pwr (ll a, ll b) {
ll res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
ll inv (ll a) {
return pwr (a, mod - 2);
}
ll nCr (ll n, ll r) {
ll ans = 1;
for (int i = 0; i < r; i++) ans = (ans * (n - i)) % mod;
for (int i = 1; i <= r; i++) ans = (ans * inv (i)) % mod;
return ans;
}
int main () {
ios_base::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
int n, m;
ll k;
cin >> n >> m >> k;
ll ans = 0;
for (int i = 1; i <= m; i++) {
ans += (((ll)(m - i) * (m - i + 1)) / 2);
ans %= mod;
}
ll a = (((ll)n * (n - 1)) + n) % mod;
ans = (ans * a) % mod;
ll tmp_ans = 0;
for (int i = 1; i <= n; i++) {
tmp_ans += (((ll)(n - i) * (n - i + 1)) / 2);
tmp_ans %= mod;
}
ll b = (((ll)m * (m - 1)) + m) % mod;
tmp_ans = (tmp_ans * b) % mod;
ans = (ans + tmp_ans) % mod;
ans = (ans * nCr ((ll)n * m - 2, k - 2)) % mod;
cout << ans << '\n';
}
| 1 |
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LL long long
#define mod 998244353
#define inv2 499122177
#define M 1000020
using namespace std;
namespace IO{
int Top=0; char SS[20];
void write(int x){
if(!x){putchar('0');return;} if(x<0) x=-x,putchar('-');
while(x) SS[++Top]=x%10,x/=10;
while(Top) putchar(SS[Top]+'0'),--Top;
}
int read(){
int nm=0,fh=1; char cw=getchar();
for(;!isdigit(cw);cw=getchar()) if(cw=='-') fh=-fh;
for(;isdigit(cw);cw=getchar()) nm=nm*10+(cw-'0');
return nm*fh;
}
}using namespace IO;
int mul(int x,int y){return (LL)x*(LL)y%mod;}
int add(int x,int y){return (x+y>=mod)?x+y-mod:x+y;}
int mus(int x,int y){return (x-y<0)?x-y+mod:x-y;}
int qpow(int x,int sq){
int res=1;
for(;sq;sq>>=1,x=mul(x,x)) if(sq&1) res=mul(res,x);
return res;
}
int n,m,fac[M],ifac[M],ans;
int C(int tot,int tk){return mul(fac[tot],mul(ifac[tot-tk],ifac[tk]));}
int main(){
n=read(),m=read(),fac[0]=1; if(n>m) swap(n,m);
for(int i=1;i<=n+m;i++) fac[i]=mul(fac[i-1],i); ifac[n+m]=qpow(fac[n+m],mod-2);
for(int i=n+m;i;i--) ifac[i-1]=mul(ifac[i],i);
for(int i=1;i<=n;i++) ans=add(ans,mul(C(i<<1,i),C(n+m-(i<<1),n-i)));
write(add(mul(ans,mul(inv2,qpow(C(n+m,m),mod-2))),m)),putchar('\n'); return 0;
} | #include <stdio.h>
using ll = long long;
const int MX = 1000005, MM = 998244353;
ll F[MX], I[MX], IF[MX];
ll C(int x,int y){return F[x+y]*IF[x]%MM*IF[y]% MM;}
int main()
{
int N, M, i;
I[1]=F[0]=IF[0]=F[1]=IF[1]=1;
for(i = 2; i < MX; i++){
I[i] = (MM - MM/i) * I[MM%i] % MM;
F[i] = F[i-1] * i % MM;
IF[i] = IF[i-1] * I[i] % MM;
}
scanf("%d%d", &N, &M);
if( N > M ) N^=M^=N^=M;
ll ans = M, tot = IF[N+M] * F[N] % MM * F[M] % MM;
for(i = 1; i <= N; i++){
ans = (ans + tot * C(N-i, M-i) % MM * C(i, i) % MM * I[2]) % MM;
}
printf("%lld\n", ans);
}
| 1 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define INF 1000000007
using namespace std;
int main(){
long n;
cin >> n;
string ans = "";
while(n){
if(n%2==0){
ans.push_back('0');
}else{
ans.push_back('1');
n -= 1;
}
n /= (-2);
}
if(int(ans.size())==0)ans.push_back('0');
rep(i,int(ans.size())){
cout << ans[int(ans.size())-1-i];
}
cout << endl;
return 0;
} | #include <bits/stdc++.h>
template<class T> inline bool chmin(T&a, T b){if(a > b){a = b; return true;}else{return false;}}
template<class T> inline bool chmax(T&a, T b){if(a < b){a = b; return true;}else{return false;}}
#define ll long long
#define double long double
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
#define mod (ll)(1e9+7)
#define inf (ll)(3e18+7)
#define pi (double) acos(-1.0)
#define P pair<int,int>
#define PiP pair<int,pair<int,int>>
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
using namespace std;
int main() {
ll n;
string ans;
cin >> n;
ll i = 1;
while(n != 0){
ans += (n % (i*(-2)) ? "1" : "0");
if(n % (i*(-2)))n -= i;
i *= (-2);
}
reverse(all(ans));
cout << (ans.size() ? ans : "0") << endl;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.