code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int max_gcd(int n, int m) {
if (n == 1) return m;
for (int gcd = m / n; gcd > 0; --gcd) {
if (m % (gcd * n) % gcd == 0) return gcd;
}
return 1;
}
int main() {
int N, M;
std::cin >> N >> M;
std::cout << max_gcd(N, M) << '\n';
return 0;
} | // 7/12
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
using ll = long long;
using P = pair<int, int>;
int main() {
int N;
ll M;
cin >> N >> M;
// int M2 = M;
// map<int, int> mp; // 素因数、個数
// for (int i = 2; i * i <= 1000000000; i++) {
// while (M % i == 0) {
// mp[i]++;
// M /= i;
// }
// }
// if (M != 1) mp[M]++;
// int res = 1;
// for (auto p : mp) {
// int prime = p.first;
// int num = p.second;
// printf("prime, num = %d, %d\n", prime, num);
// // while (num >= N) {
// // res *= prime;
// // num -= N;
// // }
// for (int i = 0; i < num; i++) {
// int now = res * prime;
// if ((M2 / now) >= N) {
// res *= prime;
// }
// else {
// break;
// }
// }
// }
vector<ll> div;
div.push_back(1);
for (int i = 2; i * i <= M; i++) {
if (M % i == 0) {
div.push_back(i);
if (i != (M/i)) {
div.push_back(M/i);
}
}
}
div.push_back(M);
sort(div.rbegin(), div.rend());
ll res = 0;
// for (int i = div.size() - 1; i >= 0; i--) {
rep(i, div.size()) {
if ((M / div[i]) >= N) {
res = div[i];
break;
}
}
cout << res << endl;
return 0;
} | 1 |
#include <iostream>
#include <vector>
using namespace std;
bool linearSearch(const vector<int>& ary, int key) {
for (auto i = 0; i < ary.size(); i++) {
if (ary[i] == key) {
return true;
}
}
return false;
}
int main(void) {
int n;
cin >> n;
vector<int> S(n);
for (int i = 0; i < n; i++) {
cin >> S[i];
}
int q;
cin >> q;
int cnt = 0;
for (int i = 0; i < q; i++) {
int key;
cin >> key;
if (linearSearch(S, key)) cnt++;
}
cout << cnt << endl;
return 0;
} | #include <bits/stdc++.h>
#pragma GCC optimize("O3")
#define fi first
#define se second
#define em emplace
#define eb emplace_back
#define mp make_pair
#define pi pair<int,int>
#define vi vector<int>
#define vpi vector<pair<int,int>>
#define vll vector<ll>
#define vpll vector<pair<ll,ll>>
#define endl '\n'
#define si(v) int((v).size())
#define all(v) (v).begin(), (v).end()
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define rep2(i, n, m) for (ll i = n; i <= (ll)(m); ++i)
#define rep3(i, n, m) for (ll i = n; i >= (ll)(m); --i)
template<class T, class U> bool chmax(T &a, U b) { if (a < b) a = b; return true; }
template<class T, class U> bool chmin(T &a, U b) { if (a > b) a = b; return true; }
using ll = long long;
using ld = long double;
using namespace std;
constexpr ll MOD = 1000000007;
signed main()
{
cout << fixed << setprecision(20);
ios::sync_with_stdio(false);
cin.tie(0);
vi d(3);
rep(i, 3) cin >> d[i];
int k; cin >> k;
sort(all(d));
rep(i, k) d[2] *= 2;
cout << accumulate(all(d),0) << endl;
return (0);
}
| 0 |
/*#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")*/
#include<bits/stdc++.h>
#define ll long long
#define inf 1000000005
#define put putchar('\n')
#define F(i,a,b) for (int i=(a);i<=(b);i++)
#define D(i,a,b) for (int i=(a);i>=(b);i--)
#define go(i,t) for (int i=head[t];i;i=Next[i])
#define sqr(x) ((x)*(x))
#define re register
#define mp make_pair
#define fi first
#define se second
#define pa pair<int,int>
#define pb push_back
#define be begin()
#define en end()
#define ret return puts("-1"),0;
#define mod 1000000007
#define N 500055
#define int ll
using namespace std;
inline char gc(){
static char buf[100000],*p1=buf,*p2=buf;
return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
#define gc getchar
inline int read(){char c=getchar();int tot=1;while ((c<'0'|| c>'9')&&c!='-') c=getchar();if (c=='-'){tot=-1;c=getchar();}
int sum=0;while (c>='0'&&c<='9'){sum=sum*10+c-'0';c=getchar();}return sum*tot;}
inline void wr(int x){if (x<0) {putchar('-');wr(-x);return;}if(x>=10)wr(x/10);putchar(x%10+'0');}
inline void wrn(int x){wr(x);put;}inline void wri(int x){wr(x);putchar(' ');}
inline void wrn(int x,int y){wri(x);wrn(y);}inline void wrn(int a,int b,int c){wri(a);wrn(b,c);}
int n,m,vis[N],co[N],I,P,Q;
int nedge,Next[N*2],head[N],to[N*2];
#define V to[i]
void add(int a,int b){
Next[++nedge]=head[a];head[a]=nedge;to[nedge]=b;
}
void add_ne(int a,int b){add(a,b);add(b,a);}
bool dfs(int x){
vis[x]=1;
bool num=1;
go(i,x){
if (vis[V]) num&=(co[x]!=co[V]);
else co[V]=co[x]^1,num&=dfs(V);
}
return num;
}
signed main(){
n=read();m=read();
F(i,1,m){
add_ne(read(),read());
}
F(i,1,n){
if (!vis[i]){
if (head[i]==0) I++;
else if (dfs(i)) Q++;
else P++;
}
}
wrn(I*I+I*(n-I)*2+P*Q*2+P*P+Q*Q*2);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
#define EPS (1e-7)
#define INF (1e9)
#define PI (acos(-1))
//const ll mod = 1000000007;
ll N, S, X[100500], P[100500];
int main() {
//cout.precision(10);
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> S;
for(int i = 1; i <= N; i++) cin >> X[i] >> P[i];
vector<l_l> before;
vector<l_l> after;
for(int i = 1; i <= N; i++) {
if(X[i] >= S) break;
before.push_back({X[i], P[i]});
}
for(int i = N; i >= 1; i--) {
if(X[i] <= S) break;
after.push_back({X[i], P[i]});
}
ll sum = 0;
int cheer = 1;
vector<l_l> que;
int after_index = 0;
int before_index = 0;
for(int time = 1; time <= N; time++) {
if(after_index >= after.size()) {
que.push_back(before[before_index]);
before_index++;
continue;
}
if(before_index >= before.size()) {
que.push_back(after[after_index]);
after_index++;
continue;
}
ll left = before[before_index].second;
ll right = after[after_index].second;
if(cheer == 1) {
left += sum;
} else {
right += sum;
}
if(right > left) {
que.push_back(before[before_index]);
sum += before[before_index].second;
before_index++;
cheer = 0;
} else {
que.push_back(after[after_index]);
sum += after[after_index].second;
after_index++;
cheer = 1;
}
}
ll ans = 0;
ll now = S;
for(int i = que.size() - 1; i >= 0; i--) {
ans += abs(que[i].first - now);
now = que[i].first;
}
cout << ans << endl;
return 0;
}
| 0 |
#define _USE_MATH_DEFINES
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <clocale>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#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 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 ll = long long;
using ui = unsigned int;
using ull = unsigned long long;
using Pi_i = pair<int, int>;
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; cin >> N;
cout << (N - 2) * 180 << endl;
return 0;
}
| #include <algorithm>
#include <climits>
#include <iostream>
#include <string>
#include <utility>
#include<vector>
#include<iomanip>
#include<map>
#include <queue>
#include<cmath>
#include<cstdio>
#include<iomanip>
#include<set>
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++) //REP(i, 5) cout<<i;
#define REPD(i,n) for(ll i=(ll)(n)-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=(a);i<=(b);i++)
#define MOD 1000000007 //10^9+7
//#define MOD 1
ll gcd(ll a, ll b) {
ll tmp;
if ( b > a) {
tmp = a;
a = b;
b = tmp;
}
while (a % b !=0) {
tmp = b;
b = a % b;
a = tmp;
}
return b;
}
const int MAX = 1000;
ll table[MAX][MAX];
// テーブルを作る前処理
void COMinit() {
table[0][0] = table[0][1] = 1;
FOR(i, 1, MAX-1){
FOR(j, 0, i+1){
if(j==0) table[i][j] = 1;
else if(j == i+1) table[i][j] = 1;
else table[i][j] = table[i-1][j-1]+table[i-1][j];
}
}
}
// 二項係数計算
ll COM(ll n, ll k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return table[n-1][k];
}
void sosuu(ll n, vector<ll> &v){
vector<ll> num(n, 0);
FOR(i, 1, sqrt(n)){
if(num[i]==0){
FOR(j, 0, n/i){
num[i+(j*i)] = 1;
}
}
}
REP(i, n){
if(num[i]==0) v.push_back(i+1);
}
}
int main(void){
double n;
cin>>n;
cout<<(n-2)*180.0<<endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
int N;
cin >> N;
vector<int> A(N);
rep(i,N){
cin >> A[i];
}
map<int, int> K;
for(int i = 0; i < N; i++){
K[A[i]]++;
}
int ans = 0;
for(auto m:K){
if(m.second % 2 != 0){
ans++;
}
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
signed main(){
int n,ans=0;
string a,b,c;
cin >> n;
cin >> a >> b >> c;
for (int i = 0; i < n; i++){
if (a[i] == b[i]){
if (b[i] != c[i]){
ans++;
}
}else if (b[i] == c[i]){
ans++;
}else if (a[i] == c[i]){
ans++;
}else{
ans += 2;
}
}
cout << ans << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vint;
typedef vector<double> vd;
typedef vector<ll> vll;
typedef vector<string> vstr;
typedef vector<vector<int>> vvint;
typedef vector<pair<int, int>> vpii;
typedef vector<pair<ll, ll>> vpll;
typedef priority_queue<int, vector<int>, greater<int>> spqint; //小さい順に取り出し
typedef priority_queue<ll, vector<ll>, greater<ll>> spqll; //小さい順に取り出し
typedef priority_queue<int, vector<int>, less<int>> bpqint; //大きい順に取り出し
typedef priority_queue<ll, vector<ll>, less<ll>> bpqll; //大きい順に取り出し
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define FOR(i, a, b) for (ll i = (ll)a; i < (ll)b; i++)
#define IREP(i, v) for (auto i = (v).begin(); i != (v).end(); i++)
#define FI first
#define SE second
#define MP make_pair
#define MT make_tuple
#define PB push_back
#define PF push_front
#define TS to_string
#define BS binary_search
#define LB lower_bound
#define UB upper_bound
#define NP next_permutation
#define ALL(v) (v).begin(), (v).end()
#define SZ(x) (ll) x.size()
#define SP(x) setprecision((ll)x)
int INF = 1e9;
int NIL = -1;
ll MOD = 1000000007;
ll LINF = 1e18;
double EPS = 1e-9;
double PI = M_PI;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; } //最大公約数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; } //最小公倍数
void yes(){ cout << "Yes" << endl;}
void no(){ cout << "No" << endl;}
//-----------------------------------------
//-----------------------------------------
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
std::chrono::system_clock::time_point start,end;
start = std::chrono::system_clock::now();
ll n, k ;
cin >> n >> k ;
vll pa ;
vll ma ;
pa.PB(0) ;
ma.PB(0) ;
REP(i,n){
ll a ;
cin >> a ;
if(a==0){
k-- ;
}
else if(a>0){
pa.PB(a) ;
}
else{
ma.PB(-a) ;
}
}
sort(ALL(ma)) ;
sort(ALL(pa)) ;
ll sp = SZ(pa) ;
ll sm = SZ(ma) ;
ll ans = LINF ;
for(ll i=0;i<=k;i++){
ll tmp ;
if(k-i<sm && i<sp){
tmp = 2*min(pa[i],ma[k-i]) + max(pa[i],ma[k-i]) ;
ans = min(ans,tmp) ;
}
}
cout << ans <<endl;
end = std::chrono::system_clock::now();
auto elapsed = std::chrono::duration_cast< std::chrono::milliseconds >(end - start).count();
//std::cout << elapsed <<"ms"<< std::endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int INF=1001001001;
vector<pair<int64_t,int64_t>>prime_factorize(int64_t x){
vector<pair<int64_t,int64_t>>p;
for(int64_t i=2;i*i<=x;i++){
int cnt=0;
if(x%i==0){
while(x%i==0){cnt++;x/=i;}
p.push_back(make_pair(i,cnt));
}
}
if(x!=1){p.push_back(make_pair(x,1));}
return p;
}
int main() {
int N,K;
cin>>N>>K;
vector<int>x(N);
for(int i=0;i<N;i++){
cin>>x[i];
}
vector<int>dis;
for(int i=0;i<N-1;i++){
dis.push_back(x[i+1]-x[i]);
}
vector<int64_t>table(N+2);
for(int i=0;i<N-1;i++){
table[i+1]=table[i]+dis[i];
}
int64_t ans=999999999999999;
for(int i=0;i<N;i++){
if(N-K>=i){
int64_t sum=0;
int start=min(abs(x[i]),abs(x[i+K-1]));
sum=start+table[i+K-1]-table[i];
//cout<<sum<<endl;
ans=min(ans,sum);
}
}
cout<<ans<<endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
// repetition
#define FOR(i, a, b) for(ll i = (a); i < (b); ++i)
#define rep(i, n) for(ll i = 0; i < (ll)(n); i++)
// container util
#define all(x) (x).begin(), (x).end()
// typedef
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VLL;
typedef vector<VLL> VVLL;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
// const value
// const ll MOD = 1e9 + 7;
// const int dx[] = {0,1,0,-1};//{0,0,1,1,1,-1,-1,-1};
// const int dy[] = {1,0,-1,0};//{1,-1,0,1,-1,0,1,-1};
// conversion
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
inline ll toLL(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();
}
template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) {
return a > b && (a = b, true);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a, b, c, d;
cin >> a >> b >> c >> d;
int l = a + b;
int r = c + d;
if(l > r) {
cout << "Left" << endl;
} else if(r > l) {
cout << "Right" << endl;
} else {
cout << "Balanced" << endl;
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long i,j,k,l,m,n,o,p,q;
while(cin>>m>>n>>o>>p)
{
if(m+n>o+p)
cout<<"Left"<<endl;
else if(m+n<o+p)
cout<<"Right"<<endl;
else
cout<<"Balanced"<<endl;
}
return 0;
} | 1 |
#include"bits/stdc++.h"
#define PB push_back
#define PF push_front
#define LB lower_bound
#define UB upper_bound
#define fr(x) freopen(x,"r",stdin)
#define fw(x) freopen(x,"w",stdout)
#define iout(x) printf("%d\n",x)
#define lout(x) printf("%lld\n",x)
#define REP(x,l,u) for(ll x = (l);x<=(u);x++)
#define RREP(x,l,u) for(ll x = (l);x>=(u);x--)
#define mst(x,a) memset(x,a,sizeof(x))
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define MP make_pair
#define se second
#define fi first
#define dbg(x) cout<<#x<<" = "<<(x)<<endl;
#define sz(x) ((int)x.size())
#define cl(x) x.clear()
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ld;
using namespace std;
const int maxn = 100010;
const int mod = 1e9+7;
const int MAX = 1000000010;
const double eps = 1e-6;
const double PI = acos(-1);
template<typename T> inline void read(T &x){
x=0;T f=1;char ch;do{ch=getchar();if(ch=='-')f=-1;}while(ch<'0'||ch>'9');do x=x*10+ch-'0',ch=getchar();while(ch<='9'&&ch>='0');x*=f;
}
template<typename A,typename B> inline void read(A&x,B&y){read(x);read(y);}
template<typename A,typename B,typename C> inline void read(A&x,B&y,C&z){read(x);read(y);read(z);}
template<typename A,typename B,typename C,typename D> inline void read(A&x,B&y,C&z,D&w){read(x);read(y);read(z);read(w);}
template<typename A,typename B> inline A fexp(A x,B p){A ans=1;for(;p;p>>=1,x=1LL*x*x%mod)if(p&1)ans=1LL*ans*x%mod;return ans;}
template<typename A,typename B> inline A fexp(A x,B p,A mo){A ans=1;for(;p;p>>=1,x=1LL*x*x%mo)if(p&1)ans=1LL*ans*x%mo;return ans;}
int n,m,TOT;
int G[16][16];
int f[(1<<15)+5][16];
int All[(1<<15)+5];
void Work(){
REP(sta,0,(1<<n)-1)REP(i,1,n)f[sta][i]=-1000000000;f[1][1]=0;
REP(sta,0,(1<<n)-1)
REP(i,1,n)if((sta>>i-1)&1){
REP(j,1,n)if(j!=i&&((sta>>j-1)&1)&&G[i][j])f[sta][i]=max(f[sta][i],f[sta^(1<<i-1)][j]+G[i][j]);
for(int s=sta;s;s=(s-1)&sta)if(!((s>>i-1)&1))f[sta][i]=max(f[sta][i],f[sta^s][i]+All[s^(1<<i-1)]);
}
iout(TOT-f[(1<<n)-1][n]);
}
void Init(){
read(n,m);
REP(i,1,m){
int u,v,w;
read(u,v,w);
G[u][v]=G[v][u]=w;
TOT+=w;
}
REP(sta,0,(1<<n)-1){
REP(i,1,n)if((sta>>i-1)&1)
REP(j,i+1,n)if((sta>>j-1)&1)All[sta]+=G[i][j];
}
}
int main(){
Init();
Work();
return 0;
}
| // main.cpp
// ABC174F2
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <tuple>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
// Binary Indexed Tree (Fenwick Tree)
// 使い方 : BIT<int>bit
// BIT<int> bt(n + 1); BITを初期化して
// bt.add(x, 1); xに1を加算
// bt.sum(x); 0～xの累積和
template<typename T> // T: type of cost
struct BIT {
private:vector<T> array;
const int n;
public:BIT(int _n):array(_n+1,0),n(_n) {}
// iまでの累積和
T sum(int i) {
T x = 0;
while(i>0){
x += array[i];
i-=i&-i; // LSBからの減算
}
return x;
}
// iからjの区間和
T sum(int i,int j){
T ret_i=sum(i-1);
T ret_j=sum(j);
return ret_j-ret_i;
}
// i番目にxを追加
void add(int i, T x) {
while(i<=n) {
array[i] += x;
i+=i&-i; // LSBへの加算
}
}
};
int main(int argc, const char * argv[]) {
int n, q;
cin >> n >> q;
vector<int>c(n + 1);
vector<int>p(n + 1, -1); // -1で初期化しておく
vector<int> st(n + 1,0);
// st(s)=t 左がsで右がtの矢印
// ２回目の登場以降ならiをtとして登録
for (int i = 1; i <= n; i++) {
cin >> c.at(i);
if (p.at(c.at(i)) != -1) {
st.at(p.at(c.at(i)))=i;
}
p.at(c.at(i)) = i;
}
/*rep(i,n){
cout<<i<<" "<<st.at(i)<<endl;
}*/
// クエリを整理する
// q(l)=(r,i) q(左端)=(右端、読み込みの順番)
int l, r;
vector<int>len(q);
vector<vector<P>> query(n+1,vector<P>()); // lの値によってクエリを整理する
rep(i, q) {
cin >> l >> r;
query.at(l).emplace_back(r,i);
len.at(i)=r-l+1;
}
/*for(int i=n-1;i>=0;i--){
for(auto& x:query.at(i)){
cout<<i<<" "<<x.first<<" "<<x.second<<endl;
}
}*/
// BITを使う
vector<int> cnt(q);
BIT<int> bt(n + 1); // BITを初期化
for (int s = n; s >= 1; s--) {
if (st.at(s) > 0) {
bt.add(st.at(s), 1);
}
for(auto& x:query.at(s)){
cnt.at(x.second)=bt.sum(x.first);
}
}
rep(i, q) {
cout << len.at(i)-cnt.at(i) << endl;
}
return 0;
}
| 0 |
#include <memory.h>
#include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <utility>
#include <vector>
using namespace std;
#define MOD 998244353
#define INIT -1
int main()
{
string n;
cin >> n;
// result[i][0] : i - 1桁めまで払ってる 繰り下がりはない
// result[i][1] : i - 1桁目まで払ってる 繰り下がりあり
int result[1000010][2] = {};
result[0][0] = 0;
result[0][1] = 1;
for (int i = 1; i <= n.length(); i++)
{
result[i][0] = min(result[i - 1][0] + (n[i - 1] - '0'), result[i - 1][1] + (10 - (n[i - 1] - '0')));
result[i][1] = min(result[i - 1][1] + (10 - (n[i - 1] - '0') - 1), result[i - 1][0] + (n[i - 1] - '0' + 1));
}
cout << result[n.length()][0] << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define REP(i, n) for(int (i) = 0; (i) < (n); ++(i))
#define REPR(i, n) for(int (i) = (n); (i) >= 0; --(i))
#define FOR(i, n, m) for(int (i) = (n); (i) < (m); ++(i))
constexpr int INF = 1e9;
//constexpr ll INF = 1LL<<61;
constexpr ll mod = 1e9+7;
int main(){
string S;
cin >> S;
int N = S.size();
int ans = 0;;
int c = 0;
REPR(i, N-1){
int x = S[i] - '0';
if((x+c) > 5){
ans += 10 - (x+c);
c = 1;
}
else if((x+c) == 5){
if(i > 0 && S[i-1] >= '5'){
ans += 10 -(x+c);
c= 1;
}
else{
ans += (x+c);
c = 0;
}
}
else{
ans+= x+c;
c = 0;
}
}
ans += c;
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define REP(i, n) for(int (i)=0;(i)<(n);++(i))
#define REPV(iter, v) for(auto (iter)=(v).begin(); (iter)!=(v).end();++(iter))
#define ALL(v) (v).begin(),(v).end()
#define MOD 1000000007
using namespace std;
typedef long long ll;
int main()
{
ll H, W, A, B;
cin >> H >> W >>A >> B;
vector<string> ansS(H);
vector<ll> countH(W, 0);
REP(i, H)
{
REP(j, W)
{
if (i < B)
{
if (j < A)
{
ansS[i].push_back('0');
}
else
{
ansS[i].push_back('1');
}
}
else
{
if (j < A)
{
ansS[i].push_back('1');
}
else
{
ansS[i].push_back('0');
}
}
}
}
REP(i, H)
{
cout << ansS[i] << endl;
}
}
| #include <iostream>
#include <vector>
#include <map>
using namespace std;
int main() {
long long n,i,p,q;
while(cin>>n,n){
vector<int> ids;
map<int,long long> m;
while(n--){
cin>>i>>p>>q;
if(!m.count(i))ids.push_back(i);
m[i]+=p*q;
}
int na=1;
for (int k=0;k<(int)ids.size();++k) {
if(1000000<=m[ids[k]]){
cout<<ids[k]<<endl;
na=0;
}
}
if(na) cout<<"NA\n";
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(void){
int n;
cin>>n;
vector<vector<int>> x(n);
vector<vector<int>> y(n);
for(int i=0;i<n;i++){
int a;
cin>>a;
for(int j=0;j<a;j++){
int b,c;
cin>>b>>c;
x.at(i).push_back(b);
y.at(i).push_back(c);
}
}
int count=0;
bool check=true;
for(int tmp=0;tmp<1<<15;tmp++) {
if (tmp>=(1<<n)) continue;
bitset<15> s(tmp);
for(int i=0;i<n;i++) {
if (s[i]==0) continue;
int a=x.at(i).size();
for(int j=0;j<a;j++) {
if (s[x.at(i).at(j)-1]!=y.at(i).at(j)) {
check=false;
break;
}
}
}
int count1=s.count();
if(check)count=max(count1,count);
check=true;
}
cout<<count<<endl;
return 0;
} | #include <iostream>
#include <fstream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <deque>
#include <bitset>
#include <algorithm>
#include <complex>
#include <array>
#include <functional>
using namespace std;
#define REP(i,n) for(int i=0; i<n; ++i)
#define FOR(i,a,b) for(int i=a; i<=b; ++i)
#define FORR(i,a,b) for (int i=a; i>=b; --i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<double> VD;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef vector<VD> VVD;
typedef pair<int,int> P;
typedef pair<ll,ll> PL;
template<typename T> void chmin(T &a, T b) { if (a > b) a = b; }
template<typename T> void chmax(T &a, T b) { if (a < b) a = b; }
int in() { int x; scanf("%d", &x); return x; }
ll lin() { ll x; scanf("%lld", &x); return x; }
int main() {
int n;
cin >> n;
VVI x(n), y(n);
REP(i,n){
int a = in();
REP(j,a){
x[i].push_back(in() - 1);
y[i].push_back(in());
}
}
int ans = 0;
REP(mask,1<<n){
bool f = true;
int cnt = 0;
REP(i,n) if ((mask >> i) & 1) cnt++;
REP(i,n){
if (((mask >> i) & 1) == 0) continue;
REP(j,x[i].size()){
if (((mask >> x[i][j]) & 1) != y[i][j]) f = false;
}
}
if (f) chmax(ans, cnt);
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define repit(it, li) for(auto it=li.begin(); it!=li.end(); it++)
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define M 1000000007
#define gb(co, k) ((co)>>(k)&1)
int main(){
int n;
cin>>n;
vector<ll> a(n);
rep(i, n) cin>>a[i];
vector<vector<int>> sb(n);
rep(i, n) sb[i]=vector<int>(60);
rep(i, n){
rep(j, 60) sb[i][j]=((i==0)?0:sb[i-1][j]) + gb(a[i], j);
}
int ans=0;
for(int i=1; i<n; i++) rep(j, 60){
int c;
if(gb(a[i], j))
c=((ll)(i-sb[i-1][j]) * (((ll)1<<j)%M))%M;
else
c=((ll)sb[i-1][j] * (((ll)1<<j)%M))%M;
ans=(ans+c)%M;
}
cout<<ans<<endl;
return 0;
}
| //thuanqvbn03
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100005;
const int Mod = 1000000007;
int n, D;
string s;
long long dp[MaxN], tmp[MaxN];
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
cin >> D;
n = s.size();
for (int i = s[0] - '0' - 1; i >= 0; i--)
{
dp[i % D]++;
}
int Sums = (s[0] - '0') % D;
for (int i = 1; i < n; i++)
{
int x = s[i] - '0';
for (int k = 0; k < D; k++)
{
tmp[k] = tmp[k] + dp[k];
tmp[k + 10] = tmp[k + 10] - dp[k] + Mod;
}
tmp[Sums]++;
tmp[Sums + x]--;
Sums = (Sums + x) % D;
dp[0] = tmp[0];
tmp[0] = 0;
for (int k = 1; k < D + 10; k++)
{
dp[k] = (tmp[k] + dp[k - 1]) % Mod;
tmp[k] = 0;
}
for (int k = D; k < D + 10; k++)
{
dp[k % D] = (dp[k % D] + dp[k]) % Mod;
}
}
long long ans = (dp[0] + (Sums % D == 0) - 1 + Mod) % Mod;
cout << ans;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=205,up=60;
int n;
ll a[N],p[N];
char s[N];
void add(ll x)
{
for(int i=up;i>=0;i--)
if(x>>i&1)
{
if(!p[i]) {p[i]=x;break;}
else x=x^p[i];
}
}
bool query(ll x)
{
for(int i=up;i>=0;i--)
if(x>>i&1)
{
if(!p[i]) return true;
else x=x^p[i];
}
return false;
}
int main()
{
int t;scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
scanf("%s",s+1);
if(s[n]=='1')
{
printf("1\n");continue;
}
memset(p,0,sizeof(p));
int ans=0;
for(int i=n;i>=1;i--)
if(s[i]=='0') add(a[i]);
else if(query(a[i]))
{
ans=1;break;
}
printf("%d\n",ans);
}
}
| #include<bits/stdc++.h>
using namespace std;
int b[100000];
int main()
{
int n;
cin>>n;
long long int a[n+5];
for(int i=0;i<n;i++)
{
cin>>a[i];
}
sort(a,a+n);
int j=0;
for(int i=1;i<n;i++)
{
if(a[i]==a[i-1])
{
b[j]=a[i];
i++;
j++;
}
}
if(j>=2)
{
long long int x=b[j-1],y=b[j-2];
cout<<x*y<<endl;
}
else
cout<<0<<endl;
}
| 0 |
#pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
using vi = vector<int>;
constexpr char newl = '\n';
constexpr double eps = 1e-10;
#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define F0R(i,b) FOR(i,0,b)
#define RFO(i,a,b) for (int i = ((b)-1); i >=(a); i--)
#define RF0(i,b) RFO(i,0,b)
#define fi first
#define se second
#define show(x) cout << #x << " = " << x << '\n';
#define rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()
#define sz(x) (int)(x).size()
#define YesNo {cout<<"Yes";}else{cout<<"No";}
#define YESNO {cout<<"YES";}else{cout<<"NO";}
#define v(T) vector<T>
template<typename T1, typename T2> inline void chmin(T1& a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> inline void chmax(T1& a, T2 b) { if (a < b) a = b; }
template<class T> bool lcmp(const pair<T, T>& l, const pair<T, T>& r) {
return l.first < r.first;
}
template<class T> istream& operator>>(istream& i, v(T)& v) {
F0R(j, sz(v)) i >> v[j];
return i;
}
template<class A, class B> istream& operator>>(istream& i, pair<A, B>& p) {
return i >> p.first >> p.second;
}
template<class A, class B, class C> istream& operator>>(istream& i, tuple<A, B, C>& t) {
return i >> get<0>(t) >> get<1>(t) >> get<2>(t);
}
template<class T> ostream& operator<<(ostream& o, const vector<T>& v) {
F0R(i, v.size()) {
o << v[i] << ' ';
}
o << newl;
return o;
}
template<class T1, class T2> ostream& operator<<(ostream& o, const map<T1, T2>& m) {
for (auto& p : m) {
o << p.first << ": " << p.second << newl;
}
o << newl;
return o;
}
#if 1
template <typename U>
map<U, int> primeFactorization(U n) {
map<U, int> rs;
while (!(n & 1)) {
n >>= 1;
rs[2]++;
}
for (U i = 3; i * i <= n; /*NOP*/) {
auto q = n / i;
auto r = n - i * q;
if (r == 0) {
rs[i]++;
n = q;
}
else {
i += 2;
}
}
if (n > 1) {
rs[n]++;
}
return rs;
}
template<typename T>
vector<T> getCompositeNums(map<T, int> primeNums) {
vector<T> results;
if (primeNums.empty()) {
return results;
}
// どの素数を何個ずつ掛け合わせるか
auto cur(primeNums);
for (auto& c : cur) {
c.second = 0;
}
auto it = cur.begin();
while (true) {
if (++it == cur.end()) {
u64 com = 1;
for (auto& c : cur) {
com *= pow<u64>(c.first, c.second);
#if 0
cout << c.first << "," << c.second << '\n';
#endif
}
if (com > 1) {
results.push_back(com);
#if 0
cout << com << '\n';
#endif
}
bool end = false;
while (true) {
if (it == cur.begin()) {
end = true;
break;
}
it--;
if (++(it->second) > primeNums[it->first]) {
it->second = 0;
continue;
}
break;
}
if (end) {
break;
}
}
}
sort(results.begin(), results.end());
return results;
}
// INSERT ABOVE HERE
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int N, M;
cin >> N >> M;
auto cn = getCompositeNums(primeFactorization(M));
cn.insert(cn.begin(), 1);
//cout << cn;
M /= *lower_bound(rng(cn), N);
cout << M;
}
#endif
| #include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
vector<pair<int64_t,int64_t>>prime_factorize(int64_t x){
vector<pair<int64_t,int64_t>>p;
for(int64_t i=2;i*i<=x;i++){
int cnt=0;
if(x%i==0){
while(x%i==0){cnt++;x/=i;}
p.push_back(make_pair(i,cnt));
}
}
if(x!=1){p.push_back(make_pair(x,1));}
return p;
}
int main() {
int N,M;
cin>>N>>M;
int a=M/N;
for(int i=a;i>=1;i--){
if(M%i==0){cout<<i<<endl;return 0;}
}
return 0;
} | 1 |
#include <unordered_map>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <vector>
#include <set>
using namespace std;
typedef long long ll;
typedef pair <ll, ll> pii;
const ll MAX_N = 6e5 + 25, MAX_M = 1500000, MOD = 1e9 + 7;
ll n, ans;
ll Arr[MAX_N];
ll dp[MAX_N];
ll DP[MAX_N];
ll ind;
vector <ll> vec[MAX_N];
vector <pii> P[MAX_M];
unordered_map <ll, ll> Map;
ll _sum (ll a, ll b) {
ll c = a + b;
if (MOD <= c)
c -= MOD;
return c;
}
ll _mul (ll a, ll b) {
ll c = 1LL * a * b % MOD;
return c;
}
ll _pow (ll a, ll b) {
if (!b)
return 1;
ll res = _pow(a, b >> 1);
res = _mul(res, res);
if (b & 1)
res = _mul(res, a);
return res;
}
void solve1(ll tmp) {
ll a = 1, b = 0, x = 0;
for (ll i = 0; i < n; i++) {
x ^= Arr[i];
if (x != 0 && x != tmp)
continue;
if (x == 0) {
dp[i] = b;
a = _sum(a, dp[i]);
}
else {
dp[i] = a;
b = _sum(b, dp[i]);
}
}
cout << dp[n - 1] << "\n";
}
ll calc1() {
ll x = 0, cnt = 0;
for (ll i = 0; i < n; i++) {
x ^= Arr[i];
if (!x)
cnt++;
}
return _pow(2, cnt - 1);
}
ll calc2(ll tmp) {
ll res = P[tmp][0].second;
DP[0] = 0;
dp[0] = P[tmp][0].second;
for (ll i = 1; i < P[tmp].size(); i++) {
dp[i] = _mul(_mul(dp[i - 1], P[tmp][i].second), P[tmp][i].first - P[tmp][i - 1].first);
ll f = _mul(dp[i - 1], _pow(P[tmp][i - 1].second, MOD - 2));
f = _sum(f, _mul(P[tmp][i].first - P[tmp][i - 1].first, DP[i - 1]));
dp[i] = _sum(dp[i], _mul(f, P[tmp][i].second));
DP[i] = _sum(DP[i - 1], dp[i - 1]);
res = _sum(res, dp[i]);
}
return res;
}
void process1() {
ll x = 0;
for (ll i = 0; i < n; i++) {
vec[ind].push_back(Arr[i]);
x ^= Arr[i];
if (!x)
ind++;
}
}
void process2() {
for (ll i = 0; i < ind; i++) {
Map.clear();
ll x = 0;
for (ll j = 0; j + 1 < vec[i].size(); j++) {
x ^= vec[i][j];
Map[x]++;
}
for (auto t: Map)
P[t.first].push_back({i, t.second});
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n;
for (ll i = 0; i < n; i++)
cin >> Arr[i];
ll tmp = 0;
for (ll i = 0; i < n; i++)
tmp ^= Arr[i];
if (tmp) {
solve1(tmp);
return 0;
}
ans = calc1();
process1();
process2();
for (ll i = 0; i < MAX_M; i++)
if (P[i].size())
ans = _sum(ans, calc2(i));
cout << ans << "\n";
return 0;
}
| #include<bits/stdc++.h>
int main(){
using namespace std;
constexpr unsigned long MOD = 1000000007;
unsigned long N;
cin >> N;
vector<unsigned long> a(N + 1);
for(unsigned long i = 1, A; i <= N; ++i){
cin >> A;
a[i] = a[i - 1] ^ A;
}
auto f = [&MOD](auto& a, auto k){(a.second += (a.first += a.second * k) %= MOD) %= MOD; return a.first;};
if(a.back()){
unsigned long k = 0;
pair<unsigned long, unsigned long> p{1, 0};
for(const auto i : a)
if(i == a.back())f(p, k), k = 0;
else if(!i) ++k;
cout << p.first << endl;
}else{
vector<pair<pair<unsigned long, unsigned long>, unsigned long>> tapi(1048576, {{1, 0}, 0});
vector<unsigned long> zeros(N + 2);
unsigned long ans{0}, t{250000002};
for(unsigned long i = 0; i <= N; ++i){
zeros[i + 1] = zeros[i] + !a[i];
if(a[i]){
ans += f(tapi[a[i]].first, zeros[i + 1] - zeros[tapi[a[i]].second]);
tapi[a[i]].second = i + 1;
}else (t *= 2) %= MOD;
}
cout << (ans + t) % MOD << endl;
}
return 0;
} | 1 |
#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
using namespace std;
int main() {
int P, Q, R;
cin >> P >> Q >> R;
int A = max(P, Q);
int B = max(A, R);
cout << P + Q + R - B << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
int main(){
vi v(3);
rep(i,3) cin >> v[i];
sort(v.begin(),v.end());
cout << v[0]+v[1] << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A,B;
int ans;
cin >> A >> B;
if(B == 1){
cout << "0" << endl;
return 0;
}
ans = ((B-A) + (A-2))/(A-1) + 1;
cout << ans << endl;
} | #include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main(){
int a, b;
cin >> a >> b;
int sum = 1;
rep(i,22){
if(sum >= b){
cout << i << endl;
return 0;
}
sum--;
sum += a;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN=2020,MOD=998244353;
template <class T>
inline bool read(T &ret)
{
char c;
int sgn;
if (c = getchar(), c == EOF)
{
return 0;
}
while (c != '-' && (c < '0' || c > '9'))
{
c = getchar();
}
sgn = (c == '-') ? -1 : 1;
ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9')
{
ret = ret * 10 + (c - '0');
}
ret *= sgn;
return 1;
}
template <class T>
inline void write(T x)
{
if (x > 9)
{
write(x / 10);
}
putchar(x % 10 + '0');
}
int C[MAXN<<1][MAXN<<1],pw[MAXN<<1],n,k;
inline int add(int x,int y)
{
return (1LL*x+y)%MOD;
}
inline int mul(int x,int y)
{
return 1LL*x*y%MOD;
}
inline void init(int n)
{
C[0][0]=1;
for(int i=1;i<=n;i++)
{
C[i][0]=1,C[i][i]=1;
for(int j=1;j<i;j++)
C[i][j]=add(C[i-1][j-1],C[i-1][j]);
}
pw[0]=1;
for(int i=1;i<=n;i++) pw[i]=mul(pw[i-1],2);
}
inline int f(int x,int y,int z)
{
if(y<0) return 0;
int ret=0;
for(int q=0;q<=z&&q<=x;++q)
{
if (q+y-1<=z+y-1&&q+y-1>=0)
{
ret=add(ret,mul(C[x][q],mul(pw[q],C[z+y-1][q+y-1])));
}
}
return ret;
}
int cnt,ans;
int main()
{
read(k),read(n);
init(n+k);
for(int i=2;i<=2*k;i++)
{
cnt=0;
for (int j=1;j<=k;++j)
{
if (1<=i-j&&i-j<=k) ++cnt;
}
if(i&1)
ans=f(cnt/2,k-cnt,n);
else
{
ans=f((cnt-1)/2,k-cnt,n);
ans=add(ans,f((cnt-1)/2,k-cnt,n-1));
}
cout<<ans<<endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define REP(i, n) for(int i = 0; i < n; ++i)
using namespace std;
using LLONG = long long;
const LLONG MOD = 998244353;
class ModCalc
{
LLONG m_mod = MOD;
vector<LLONG> m_fac;
vector<LLONG> m_ifac;
public:
ModCalc(const LLONG mod)
{
m_mod = mod;
}
// Combinationを計算したいときの前処理：O(max)
ModCalc(const int max, const LLONG mod)
{
m_mod = mod;
m_fac = vector<LLONG>(max + 1);
m_ifac = vector<LLONG>(max + 1);
m_fac[0] = m_ifac[0] = 1;
for (int i = 0; i < max; ++i)
{
m_fac[i + 1] = m_fac[i] * (i + 1) % mod; // n! (mod M)
m_ifac[i + 1] = m_ifac[i] * ModPow(i + 1, mod - 2) % mod; // k!^(M-2) (mod M)
}
}
const LLONG ModAdd(LLONG a, LLONG b) const
{
return (a + b) % m_mod;
}
const LLONG ModSubtract(LLONG a, LLONG b) const
{
LLONG diff = a - b;
return diff >= 0 ? diff : diff + m_mod;
}
const LLONG ModMulti(LLONG a, LLONG b) const
{
LLONG prod = a * b % m_mod;
return prod >= 0 ? prod : prod + m_mod;
}
const LLONG ModDiv(LLONG a, LLONG b) const
{
LLONG c = m_mod, u = 1, v = 0;
while (c)
{
LLONG t = b / c;
b -= t * c; swap(b, c);
u -= t * v; swap(u, v);
}
u %= m_mod;
if (u < 0) u += m_mod;
return (a % m_mod) * u % m_mod;
}
const LLONG ModPow(LLONG x, LLONG n) const
{
LLONG ret = 1;
while (n != 0)
{
if (n & 1) ret = ret * x % m_mod;
x = x * x % m_mod;
n = n >> 1;
}
return ret;
}
const LLONG ModComb(LLONG n, LLONG r) const
{
if (n == 0 && r == 0) return 1;
if (n < r || n < 0) return 0;
LLONG tmp = m_ifac[n - r] * m_ifac[r] % m_mod;
return tmp * m_fac[n] % m_mod;
}
};
int main()
{
int N; cin >> N;
vector<int> ds(N); REP(i, N) cin >> ds[i];
map<int, int> d2NumMap;
REP(i, N)
{
++d2NumMap[ds[i]];
}
if (ds.front() != 0 || d2NumMap[0] > 1)
{
cout << 0 << endl;
}
else
{
int maxD = d2NumMap.rbegin()->first;
LLONG ans = 1;
ModCalc mod(MOD);
for (int d = 1; d <= maxD; ++d)
{
if (d2NumMap.count(d) == 0)
{
ans = 0;
break;
}
ans = mod.ModMulti(ans, mod.ModPow(d2NumMap[d - 1], d2NumMap[d]));
}
cout << ans << endl;
}
}
| 0 |
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <algorithm>
#include <cctype>
#include <cmath>
#include <queue>
#include <map>
#include <numeric>
#include <unordered_map>
#include <iomanip>
#include <functional>
#include <bitset>
#include <complex>
#include <stack>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define rrep(i, n) for(int i = (int)(n-1); i >= 0; i--)
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define all(x) (x).begin(),(x).end()
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
typedef long long ll;
using namespace std;
template <class Monoid>
class SegmentTree
{
public:
using Func = function<Monoid(Monoid, Monoid)>;
const Func F;
const Monoid M1;
int sz;
vector<Monoid> seg;
SegmentTree(int n,const Func fu, const Monoid &m1): F(fu) , M1(m1) {init(n);}
void init(int n)
{
sz= 1;
while (sz < n) sz *= 2;
seg.assign(sz * 2, M1);
}
void update(int k,const Monoid &x)
{
k+=sz;
seg[k]=x;
while(k>>=1)
{
seg[k]=F(seg[k*2],seg[k*2+1]);
}
}
Monoid query(int l,int r)
{
Monoid L=M1,R=M1;
l+=sz;r+=sz;
for(;l<r;l>>=1,r>>=1)
{
if(l&1)L=F(L,seg[l++]);
if(r&1)R=F(seg[--r],R);
}
return F(L,R);
}
Monoid &operator[](int n){
return seg[n+sz];
}
};
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
ll n;cin>>n;
ll m;cin>>m;
SegmentTree<ll>st(n+1,[](ll a,ll b){return a+b;},0);
vector<vector<ll>>g(n+1);
rep(i,n)g[0].push_back(n-i);
n++;
rep(i,m){
ll a,b;cin>>a>>b;
g[a].push_back(b);
}
vector<ll>visited(n),ls(n);
ll id=0,cn=0;
ll mi=1e9,tcnt=0;
function<void(ll,ll&,ll&)>dfs=[&](ll v,ll& idx,ll&cnt){
ls[v]=idx++;
st.update(ls[v],1);
visited[v]=1;
for(auto nv:g[v]){
cnt++;
if(ls[nv]!=0&&st[ls[nv]]){
//cout<<"test"<<nv<<" "<<v<<" "<<ls[nv]<<" "<<ls[v]<<endl;
if(chmin(mi,st.query(ls[nv],ls[v]+1))){
tcnt=cnt;
}
}
if(visited[nv])continue;
dfs(nv,idx,cnt);
cnt++;
}
st.update(ls[v],0);
};
vector<ll>et;
function<void(ll,ll&)>dfs2=[&](ll v,ll&cnt){
// cout<<"cnt"<<cnt<<endl;
st.update(ls[v],v);
visited[v]=1;
et.push_back(v);
for(auto nv:g[v]){
cnt++;
if(ls[nv]!=0&&st[ls[nv]]){
if(cnt==tcnt){
cout<<mi<<"\n";
//cout<<ls[nv]<<" "<<ls[v]<<endl;
repi(i,ls[nv],ls[v]+1){
if(st[i]>0)cout<<st[i]<<"\n";
}
cout<<flush;
}
}
if(visited[nv])continue;
dfs2(nv,cnt);
cnt++;
// et.push_back(v);
}
st.update(ls[v],0);
};
dfs(0,id,cn);
cn=0;
visited.assign(n,0);
dfs2(0,cn);
cout<<endl;
if(mi==1e9){
cout<<-1<<endl;
}
return 0;
}
| #include<iostream>
#include<vector>
#include<queue>
using namespace std;
int h, w, dx[] = { -1,0,1,0 }, dy[] = { 0,-1,0,1 };
vector<string>m;
int main() {
cin >> h >> w;
m.resize(h);
int sum = 0;
for (int i = 0; i < h; i++) {
cin >> m[i];
for (int j = 0; j < w; j++) {
if (m[i][j] == '.')sum++;
}
}
vector<vector<int>>d(h, vector<int>(w, 0));
queue<pair<int, int>>q;
q.push({ 0,0 });
while (!q.empty()) {
int x = q.front().first, y = q.front().second; q.pop();
for (int i = 0; i < 4; i++) {
int nx = x + dx[i], ny = y + dy[i];
if (nx < 0 || nx >= h || ny < 0 || ny >= w)continue;
if (m[nx][ny] == '#'||d[nx][ny])continue;
q.push({ nx,ny });
d[nx][ny] = d[x][y] + 1;
}
}
if (d[h - 1][w - 1]) {
cout << sum - (d[h - 1][w - 1] + 1) << endl;
}
else cout << -1 << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
int N;
cin>>N;
vector<int> A(1010);
for(int i=1;i<=N;i++){
int n=i;
for(int j=2;j<=n/j;j++)
for(;n%j==0;n/=j)
A[j]++;
if(n!=1)
A[n]++;
}
int ans=1;
for(int i:A)
ans=ans*(i+1)%1000000007;
cout<<ans<<endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
#define all(v) v.begin(), v.end()
const ll mod=1000000007;
ll countBits(ll in){
int res=0;
for(;in>0;in>>=1){
if((in&0x01)!=0){
res++;
}
}
return res;
}
template<typename T>
void show2dVector(vector<vector<T>>& v){
for(int i=0;i<v.size();i++){
int m=v[i].size();
cout<<i<<" : ";
for(int j=0;i<m;i++){
cout<<v[i][j]<<" ";
}
cout<<endl;
}
}
void bfs(const vector<vector<int>>&g, int v, vector<bool>& seen){
seen[v]=true;
cout<<v<<" ";
for(auto next: g[v]){
if(seen[next]){
continue;
}
bfs(g,next,seen);
}
}
bool dfs(vector<vector<int>> &g,int start,int goal,vector<bool>&seen){
bool res=false;
seen[start]=true;
if(start==goal){
return true;
}
for(auto next: g[start]){
if(seen[next]){
continue;
}
res=dfs(g,next,goal,seen);
if(res){
break;
}
}
return res;
}
ll gcd(ll a,ll b) {
return b? gcd(b,a%b): a;
}
ll lcm(ll a,ll b) {
return a*b/gcd(a,b);
}
bool isLowerCase(char c){
return (c>='a'&&c<='z');
}
char toLowerCase(char c){
if(isLowerCase(c)){
return c;
}else{
return c+'a'-'A';
}
}
char toUpperCase(char c){
if(isLowerCase(c)){
return c-('a'-'A');
}else{
return c;
}
}
ll powm(ll a,ll n, ll m){
ll ret=1;
while(n>0){
if(n%2==1){
ret=(ret*a)%m;
}
n>>=1;
a=(a*a)%m;
}
return ret;
}
const string yesno(bool ans){
return (ans?"Yes":"No");
}
int main() {
string n;cin>>n;
if(n.size()==3){
char c=n[0];
n[0]=n[2];
n[2]=c;
}
cout<<n<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep1(i, n) for(int i = 1; i < n+1; i++)
#define all(A) A.begin(),A.end()
typedef long long ll;
int main(){
int a,b,c;
cin >> a >> b >> c;
int A = min(a,b);
int B = max(a,b);
for(int i=A;i<=B;i++){
if(i == c){
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
} | #include <bits/stdc++.h>
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (ll)n; ++i)
#define INF 10e7
#define MOD 1000000000 + 7
#define MAX 51000
#define all(x) (x).begin(), (x).end()
#define MX(x) *max_element(all(x))
#define MN(x) *min_element(all(x))
using namespace std;
void solve(void)
{
int a, b, c;
cin >> a >> b >> c;
if ((a <= c && c <= b) || (b < c && c <= a))
cout << "Yes" << endl;
else
cout << "No" << endl;
}
int main(void)
{
solve();
}
| 1 |
#include <bits/stdc++.h>
#define rep(a,n) for (ll a = 0; a < (n); ++a)
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
typedef vector<vector<ll> > Graph;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const ll INF = 1e18;
//エラトステネスの篩
std::vector<bool> IsPrime;
void sieve(size_t max){
if(max+1 > IsPrime.size()){ // resizeで要素数が減らないように
IsPrime.resize(max+1,true); // IsPrimeに必要な要素数を確保
}
IsPrime[0] = false; // 0は素数ではない
IsPrime[1] = false; // 1は素数ではない
for(size_t i=2; i*i<=max; ++i) // 0からsqrt(max)まで調べる
if(IsPrime[i]) // iが素数ならば
for(size_t j=2; i*j<=max; ++j) // (max以下の)iの倍数は
IsPrime[i*j] = false; // 素数ではない
}
int main(){
int n;
cin >> n;
vector<int>ans;
sieve(56000);
int now = 11;
while(ans.size()!=n){
if(IsPrime[now]){
ans.push_back(now);
}
now += 10;
}
rep(i,n){
cout << ans[i] << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, a, b) for(ll i=(a); i<(b); i++)
#define PER(i, a, b) for(ll i=(a); i>=(b); i--)
#define rep(i, n) REP(i, 0, n)
#define per(i, n) PER(i, n, 0)
#define ALL(a) (a).begin(),(a).end()
const ll INF = 1e18+18;
const ll MAX = 200000;
const ll MOD = 1000000007;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define YES(n) cout << ((n) ? "YES" : "NO") << endl;
static const double pi = 3.141592653589793;
int main(){
ll N;
cin>>N;
if(N==0){
cout<<0<<endl;
return 0;
}
if(N==1){
cout<<1<<endl;
return 0;
}
if(N>0){
ll Num=0;
ll Key=1;
ll Keta=-2;
while(Num<N){
Num+=Key;
Key*=4;
Keta+=2;
}
ll Dif=Num-N;
ll J=1;
cout<<1;
vector<ll> W(Keta, 0);
ll i=0;
while(Dif>0){
W[i]=Dif%2;
i++;
Dif/=2;
}
rep(i, Keta){
if(J+1){
cout<<W[Keta-1-i];
}else{
cout<<(1-W[Keta-1-i]);
}
J*=-1;
}
}
if(N==-1){
cout<<11<<endl;
return 0;
}
if(N<0){
ll Num=0;
ll Key=2;
ll Keta=-1;
while(Num<N*-1){
Num+=Key;
Keta+=2;
Key*=4;
}
ll Dif=Num-N*-1;
cout<<1;
vector<ll> W(Keta, 0);
ll i=0;
while(Dif>0){
W[i]=Dif%2;
i++;
Dif/=2;
}
ll J=1;
rep(i, Keta){
if(J+1){
cout<<W[Keta-1-i];
}else{
cout<<(1-W[Keta-1-i]);
}
J*=-1;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcountll
#define INF 1e18
#define mod 1000000007
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin>>N;
vector<ll> X(N),Y(N),K(N);
rep(i,N){
char c;
cin>>X[i]>>Y[i]>>c;
if(c=='R')K[i]=0;
if(c=='U')K[i]=1;
if(c=='L')K[i]=2;
if(c=='D')K[i]=3;
}
ll res=INF;
{
vector<ll> keys;
rep(i,N){
keys.push_back(Y[i]-X[i]);
}
sort(all(keys)); uni(keys);
map<ll,vector<ll>> xs[4];
rep(i,N){
xs[K[i]][Y[i]-X[i]].push_back(X[i]);
}
for(ll k : keys){
vector<ll> nids[4];
rep(dir,4){
vector<ll> tmp=xs[dir][k];
sort(all(tmp));
nids[dir]=tmp;
}
rep(i,nids[1].size()){
ll x=nids[1][i];
auto it=lower_bound(all(nids[2]),x);
if(it==nids[2].end())continue;
minch(res,(*it-x)*10);
}
rep(i,nids[0].size()){
ll x=nids[0][i];
auto it=lower_bound(all(nids[3]),x);
if(it==nids[3].end())continue;
minch(res,(*it-x)*10);
}
}
}
{
vector<ll> keys;
rep(i,N){
keys.push_back(Y[i]+X[i]);
}
sort(all(keys)); uni(keys);
map<ll,vector<ll>> xs[4];
rep(i,N){
xs[K[i]][Y[i]+X[i]].push_back(X[i]);
}
for(ll k : keys){
vector<ll> nids[4];
rep(dir,4){
vector<ll> tmp=xs[dir][k];
sort(all(tmp));
nids[dir]=tmp;
}
rep(i,nids[0].size()){
ll x=nids[0][i];
auto it=lower_bound(all(nids[1]),x);
if(it==nids[1].end())continue;
minch(res,(*it-x)*10);
}
rep(i,nids[3].size()){
ll x=nids[3][i];
auto it=lower_bound(all(nids[2]),x);
if(it==nids[2].end())continue;
minch(res,(*it-x)*10);
}
}
}
{
vector<ll> keys;
rep(i,N){
keys.push_back(X[i]);
}
sort(all(keys)); uni(keys);
map<ll,vector<ll>> xs[4];
rep(i,N){
xs[K[i]][X[i]].push_back(Y[i]);
}
for(ll k : keys){
vector<ll> nids[4];
rep(dir,4){
vector<ll> tmp=xs[dir][k];
sort(all(tmp));
nids[dir]=tmp;
}
rep(i,nids[1].size()){
ll x=nids[1][i];
auto it=lower_bound(all(nids[3]),x);
if(it==nids[3].end())continue;
minch(res,(*it-x)*5);
}
}
}
{
vector<ll> keys;
rep(i,N){
keys.push_back(Y[i]);
}
sort(all(keys)); uni(keys);
map<ll,vector<ll>> xs[4];
rep(i,N){
xs[K[i]][Y[i]].push_back(X[i]);
}
for(ll k : keys){
vector<ll> nids[4];
rep(dir,4){
vector<ll> tmp=xs[dir][k];
sort(all(tmp));
nids[dir]=tmp;
}
rep(i,nids[0].size()){
ll x=nids[0][i];
auto it=lower_bound(all(nids[2]),x);
if(it==nids[2].end())continue;
minch(res,(*it-x)*5);
}
}
}
if(res==INF)cout<<"SAFE"<<endl;
else cout<<res<<endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
const int MAX=100000+5;
int n;
pair<int,int> coord[MAX];
vector<int> par(MAX,0);
vector<pair<int,pair<int,int> > > edges;
int root(int x)
{
while(par[x]!=x)
{
par[x]=par[par[x]];
x=par[x];
}
return x;
}
void union1(int x,int y)
{
int u=root(x);
int v=root(y);
par[u]=v;
}
int main()
{
cin>>n;
vector<pair<int,int> > xc;
vector<pair<int,int> > yc;
for(int i=1;i<=n;i++)
{
int x,y;
cin>>x>>y;
coord[i]={x,y};
xc.push_back({x,i});
yc.push_back({y,i});
}
for(int i=1;i<=n;i++)
{
par[i]=i;
}
sort(xc.begin(),xc.end());
sort(yc.begin(),yc.end());
for(int i=0;i<n-1;i++)
{
edges.push_back({abs(xc[i].first-xc[i+1].first),{xc[i].second,xc[i+1].second}});
}
for(int i=0;i<n-1;i++)
{
edges.push_back({abs(yc[i].first-yc[i+1].first),{yc[i].second,yc[i+1].second}});
}
long long int sum=0;
//kruskal
for(int i=1;i<=n;i++)
par[i]=i;
sort(edges.begin(),edges.end());
for(int i=0;i<edges.size();i++)
{
int w=edges[i].first;
int u=edges[i].second.first;
int v=edges[i].second.second;
if(root(u)!=root(v))
{
union1(u,v);
sum+=w;
}
}
cout<<sum<<endl;
} | 0 |
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main()
{
int h,w,n;
cin >> h >> w >>n;
int a=max(h,w);
cout<<(a + n - 1) / a<<endl;
return 0;
} | #include <iostream>
#include <string>
#include <algorithm>
#include <vector>
//#include <stack>
//#include <queue>
//#include <cstdio>
#include <cmath>
#include <iterator>
#include <map>
//#include <list>
#include <iomanip>
using namespace std;
#define IOS ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define prec std::cout << std::fixed << std::setprecision(15);
#define endl "\n"
#define MOD 1000000007
#define Int int64_t
#define PI 3.14159265358979
#define ssort(z) sort(z.begin(), z.end())
#define rsort(z) sort(z.rbegin(), z.rend())
#define eerase(z) z.erase(unique(z.begin(), z.end()), z.end())
#define ccnt(z, w) count(z.begin(), z.end(), w)
#define rep(i,a,n) for(Int (i)=(a); (i)<(n); (i)++)
#define repq(i,a,n) for(Int (i)=(a); (i)<=(n); (i)++)
const int MAX_N = 1000000;
const Int MAX_N_Int = 1000000000000;
template <typename T>
void printV(const std::vector<T>& v, const char * const separator = " ")
{
if(!v.empty())
{
std::copy(v.begin(),
--v.end(),
std::ostream_iterator<T>(std::cout, separator));
std::cout << v.back() << "\n";
}
}
bool isPrime(int num)
{
if (num < 2) return false;
else if (num == 2) return true;
else if (num % 2 == 0) return false; // 偶数はあらかじめ除く
double sqrtNum = sqrt(num);
for (int i = 3; i <= sqrtNum; i += 2)
{
if (num % i == 0)
{
// 素数ではない
return false;
}
}
// 素数である
return true;
}
Int gcd(Int a, Int b) {
return b != 0 ? gcd(b, a % b) : a;
}
Int lcm(Int a, Int b) {
return a / gcd(a, b) * b;
//a*bは64bit integer overflow
}
int Max(int a, int b, int c) {
int temp = max(a, b);
return max(temp, c);
}
int Min(int a, int b, int c) {
int temp = min(a, b);
return min(temp, c);
}
bool integer(double num) {
return floor(num) == num;
}
Int fact(int num) {
if (num == 0)
return 1;
else
return num * fact(num - 1);
}
Int yakusu(int n) {
int cnt = 0;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
cnt++;
if (i * i != n) cnt++;
}
}
return cnt;
}
Int fact_mod(Int n, Int mod) {
Int f = 1; repq(i,2,n) f = f * (i % MOD) % MOD;
return f;
}
// 繰り返し二乗法 (modの世界での累乗)
Int mod_pow(Int x, Int n, Int mod) {
Int res = 1;
while(n > 0) {
if(n & 1) res = (res * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return res;
}
// 組み合わせ nCr を求める
Int combination_mod(Int n, Int r, Int mod) {
if(r > n-r) r = n-r;
if(r == 0) return 1;
Int a = 1;
rep(i, 0, r) a = a * ((n-i) % mod) % mod;
Int b = mod_pow(fact_mod(r, mod), mod-2, mod);
return (a % mod) * (b % mod) % mod;
}
Int cntZero(string s){
int cnt=0;
reverse(s.begin(),s.end());
for (int i = 0; i < s.length(); ++i) {
if(s[i]=='0')cnt++;
else break;
}
return cnt;
}
int main() {
//COMinit();
IOS;
prec;
Int a,b,c,d,n,m,k,x,y=0,ans=0,ans1=0;
string str,s="",t,u;
Int h,w;
cin>>h>>w>>n;
Int cnt=0;
rep(i,0,min(h,w)){
ans+=max(h,w);
cnt++;
if(ans>=n){
cout<<cnt<<endl;
return 0;
}
}
rep(i,0,max(h,w)){
ans+=min(h,w);
cnt++;
if(ans>=n){
cout<<cnt<<endl;
return 0;
}
}
cout<<endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
// #define int long long
#define rep(i, n) for (long long i = (long long)(0); i < (long long)(n); ++i)
#define reps(i, n) for (long long i = (long long)(1); i <= (long long)(n); ++i)
#define rrep(i, n) for (long long i = ((long long)(n)-1); i >= 0; i--)
#define rreps(i, n) for (long long i = ((long long)(n)); i > 0; i--)
#define irep(i, m, n) for (long long i = (long long)(m); i < (long long)(n); ++i)
#define ireps(i, m, n) for (long long i = (long long)(m); i <= (long long)(n); ++i)
#define SORT(v, n) sort(v, v + n);
#define REVERSE(v, n) reverse(v, v+n);
#define vsort(v) sort(v.begin(), v.end());
#define all(v) v.begin(), v.end()
#define mp(n, m) make_pair(n, m);
#define cout(d) cout<<d<<endl;
#define coutd(d) cout<<std::setprecision(10)<<d<<endl;
#define cinline(n) getline(cin,n);
#define replace_all(s, b, a) replace(s.begin(),s.end(), b, a);
#define PI (acos(-1))
#define FILL(v, n, x) fill(v, v + n, x);
#define sz(x) long long(x.size())
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vs = vector<string>;
using vpll = vector<pair<ll, ll>>;
using vtp = vector<tuple<ll,ll,ll>>;
using vb = vector<bool>;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const ll INF = 1e9+10;
const ll MOD = 1e9+7;
const ll LINF = 1e18;
signed main()
{
cin.tie( 0 ); ios::sync_with_stdio( false );
ll n,k; cin>>n>>k;
ll ans=n-k+1;
if(ans<0) ans=0;
cout<<ans<<endl;
} | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
constexpr int inf = 0x3f3f3f3f;
constexpr ll linf = 0x3f3f3f3f3f3f3f3fLL;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, k; cin >> n >> k;
cout << n - k + 1 << endl;
return 0;
} | 1 |
#include <cstdio>
#include <algorithm>
#include <vector>
#define file(x) freopen(#x".in", "r", stdin), freopen(#x".out", "w", stdout)
inline int read()
{
int data = 0, w = 1; char ch = getchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (ch >= '0' && ch <= '9') data = data * 10 + (ch ^ 48), ch = getchar();
return data * w;
}
const int N(2e5 + 10), Mod(1e9 + 7);
int fac[N], inv[N], f[N], n, m, A, B;
int C(int n, int m) { return 1ll * fac[n + m] * inv[m] % Mod * inv[n] % Mod; }
int fastpow(int x, int y)
{
int ans = 1;
for (; y; y >>= 1, x = 1ll * x * x % Mod)
if (y & 1) ans = 1ll * ans * x % Mod;
return ans;
}
int main()
{
n = read() - 1, m = read() - 1, A = read() - 1, B = read() - 1, fac[0] = inv[0] = 1;
if (A == n || B == m) return puts("0"), 0;
for (int i = 1; i <= n + m; i++) fac[i] = 1ll * fac[i - 1] * i % Mod;
inv[n + m] = fastpow(fac[n + m], Mod - 2);
for (int i = n + m - 1; i; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % Mod;
int ans = C(n, m);
for (int i = 0; i <= A; i++)
ans = (ans - 1ll * C(i, m - B - 1) * C(n - i, B) % Mod + Mod) % Mod;
printf("%d\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
int pref[250005], suff[250005], ans, prefix[250005], h , w, a, b;
const int mod = 1e9 + 7;
int BinPow(int x,int n){
if(n == 0)
return 1;
if(n == 1)
return x;
else{
int sum = BinPow(x, n / 2) % mod;
sum*=sum; sum%=mod;
if(n % 2 != 0)
sum *= x, sum%=mod;
return sum;
}
}
int C(int x,int n){
if(x < 0 || x > n || n < 0) return 0;
int sum = pref[n] * suff[x]; sum %= mod;
sum*=suff[n - x]; sum %= mod;
return sum;
}
signed main(){
cin.tie(0), ios::sync_with_stdio(0);
cin >> h >> w >> a >> b;
pref[0] = 1;
for(int i = 1; i <= 250000; i++){
pref[i] = pref[i - 1]*i;
pref[i] %= mod;
}
suff[0] = 1;
for(int i = 1; i <= 250000; i++)
suff[i] = BinPow(pref[i], mod - 2);
for(int i = 1; i <= 100000; i++){
if(i >= h - a + 1){
prefix[i] += C(b - 1, i + b - 2);
pref[i] %= mod;
prefix[i] += prefix[i - 1];
}
}
ans = C(h - 1,h + w - 2);
for(int i = 1; i <= h; i++){
if(i >= h - a + 1){
int dist = w - b;
int dist1 = h - i + 1;
ans -= C(b - 1, i + b - 2)*C(dist1 - 1,dist + dist1 -2 );
ans %= mod;
if(ans < 0) ans += mod;
}
}
cout << ans;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define pi pair<ll,ll>
#define pii pair<ll,pi>
#define pb push_back
#define mk make_pair
#define db double long
const int siz = 2 * 1e5 + 7;
int parent1[siz];
int nodesize1[siz];
int parent2[siz];
int nodesize2[siz];
int get2(int x) {
if (parent2[x] == x)return x;
return parent2[x] = get2(parent2[x]);
}
void dsu2(int u, int v) {
u = get2(u);
v = get2(v);
if (v != u) {
if (rand() & 1)swap(u, v);
parent2[v] = u;
nodesize2[u] += nodesize2[v];
nodesize2[v] = 0;
}
}
int get1(int x) {
if (parent1[x] == x)return x;
return parent1[x] = get1(parent1[x]);
}
void dsu1(int u, int v) {
u = get1(u);
v = get1(v);
if (v != u) {
if (rand() & 1)swap(u, v);
parent1[v] = u;
nodesize1[u] += nodesize1[v];
nodesize1[v] = 0;
}
}
void clear() {
for (int i = 0; i < siz; i++) {
parent1[i] = i;
nodesize1[i] = 1;
parent2[i] = i;
nodesize2[i] = 1;
}
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k, l;
cin >> n >> k >> l;
clear();
for (int i = 0; i < k; i++) {
int a, b;
cin >> a >> b;
if (get1(a) != get1(b)) {
dsu1(a, b);
}
}
for (int i = 0; i < l; i++) {
int a, b;
cin >> a >> b;
if (get2(a) != get2(b)) {
dsu2(a, b);
}
}
map<pi, int>m;
for (int i = 1; i <= n; i++) {
m[mk(get1(i), get2(i))]++;
}
for (int i = 1; i <= n; i++) {
cout << m[mk(get1(i), get2(i))] << " ";
}
cout << endl;
}
| #include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pqueue priority_queue
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
int K, T;
cin>>K>>T;
int tmp;
priority_queue<pair<int, int> > que;
for(int i=0;i<T;++i) {
cin>>tmp;
que.push(mp(tmp, i));
}
pair<int, int> tmp1, tmp2;
int bef = -1;
int ans = 0;
for(int i=0;i<K;++i) {
if(que.size()==1) {
tmp1 = que.top();que.pop();
if(bef==tmp1.se) ans++;
tmp1.fi--;
bef = tmp1.se;
if(tmp1.fi>0) que.push(tmp1);
}
else {
tmp1 = que.top();que.pop();
tmp2 = que.top();que.pop();
if(bef==tmp1.se) {
tmp2.fi--;
bef = tmp2.se;
}
else {
tmp1.fi--;
bef = tmp1.se;
}
if(tmp1.fi>0) que.push(tmp1);
if(tmp2.fi>0) que.push(tmp2);
}
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,M;cin>>N>>M;bool F=false;int A=-1,B=-1,C=-1;
for (int X=0;X<=N;X++){
for (int Y=0;Y<=N;Y++){
if (X+Y<=N&&X*10000+Y*5000+(N-X-Y)*1000==M){
A=X;B=Y;C=(N-X-Y);F=true;break;
}
}
}
if(!F){
cout<<-1<<" "<<-1<<" "<<-1<<endl;return 0;
}
cout<<A<<" "<<B<<" "<<C<<endl;
} | #include <iostream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
using namespace std;
long long cnt;
void print(vector<int> &data){
for (int i = 0; i < data.size(); ++i){
cout << data[i] << endl;
}
}
void insertSort(vector<int> &data, int d){
int n = data.size();
for (int i = d; i < n; ++i) {
int v = data[i];
int j = i - d;
while (j >= 0 && data[j] > v) {
data[j + d] = data[j];
j -= d;
cnt++;
}
data[j + d] = v;
}
}
void insertSort2(vector<int> &data, int d){
int n = data.size();
for (int i = d; i < 2 * d; ++i) {
int v = data[i];
int j = i - d;
while (data[j] > v) {
data[j + d] = data[j];
j -= d;
cnt++;
}
data[j + d] = v;
}
}
void shellSort(vector<int> &data){
vector<int> dist;
for (int i = 1; i <= data.size(); i = 3 * i + 1)
dist.push_back(i);
int n = dist.size();
cout << n << endl;
for (int i = n - 1; i >= 0; --i)
{
insertSort(data, dist[i]);
cout << dist[i];
if (i != 0) cout << " ";
else cout << endl;
}
cout << cnt << endl;
print(data);
}
int main(){
int n; cin >> n;
vector<int> data(n);
for (int i = 0; i < n; ++i) cin >> data[i];
shellSort(data);
return 0;
} | 0 |
//こんなプログラムを組んではいけない(戒め
//マージの仕様が複雑だし、空白マスを引く処理忘れやすいし、ひどいコードだ。
#include<iostream>
#include<queue>
using namespace std;
const int h = 12;
const int w = 12;
const int dy[4] = {-1, 0, 1, 0};
const int dx[4] = {0, 1, 0, -1};
char data[h][w+2];
//データ構造をマージする一般的なテクなし。
class UnionFind {
public:
int oya[2521], size;
void ini(int size) { this->size = size; for( int i = 0;i < size; i++ ) oya[i] = i; }
int root(int x) { if( oya[x] == x ) return x; return (oya[x] = root(oya[x]) ); }
void marge(int x, int y) { x = root(x); y = root(y); if ( x != y ) { size--; oya[x] = y; } }
}uf;
void bfs(int sy, int sx) {
queue<int> que;
que.push(sy*w + sx);
while( !que.empty() ) {
int now = que.front();
que.pop();
if ( data[now/w][now%w] == '0' )
continue;
if ( uf.root(now) != now ) //すでに調べている(マージされている)ならcontinue
continue;
uf.marge(now, sy*w + sx); //nowをsy*w + sxにくっつける(逆にしたら無限ループするかも)
for(int i = 0; i < 4; i++ ) {
int ny = now/w + dy[i];
int nx = now%w + dx[i];
if ( 0 <= ny && ny < h && 0 <= nx && nx < w )
que.push(ny * w + nx);
}
}
}
int main() {
int i, j;
while( cin >> data[0] ) {
for( i = 1; i < h; i++ )
cin >> data[i];
uf.ini(h*w);
int minus = 0;
for( i = 0; i < h; i++ ) {
for( j = 0; j < w; j++ ) {
minus += (data[i][j] == '0');
bfs(i, j);
}
}
cout << uf.size - minus << endl;
}
return 0;
} | #include<iostream>
using namespace std;
char map[20][20];
void dfs(int i, int j) {
map[i][j] = '0';
if (map[i - 1][j] == '1')dfs(i - 1, j);
if (map[i + 1][j] == '1')dfs(i + 1, j);
if (map[i][j - 1] == '1')dfs(i, j - 1);
if (map[i][j + 1] == '1')dfs(i, j + 1);
return;
}
int main() {
for (int i = 0; i <= 13; i++) {
for (int j = 0; j <= 13; j++) {
map[i][j] = '0';
}
}
while (cin >> map[1][1]) {
int ans = 0;
for (int i = 1; i <= 12; i++) {
for (int j = 1; j <= 12; j++) {
if (i == 1 && j == 1)continue;
cin >> map[i][j];
}
}
for (int i = 1; i <= 12; i++) {
for (int j = 1; j <= 12; j++) {
if (map[i][j] == '1') {
dfs(i, j);
ans++;
}
}
}
cout << ans << endl;
}
return 0;
} | 1 |
#include <iostream>
using namespace std;
int main(){
int x;
int ans =0;
cin >> x;
ans = x * x * x;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define FOR(i,a,b) for(int i=(a); i<=(b); i++)
#define rep(i,n) for(int i = 0; i < (n); i++)
#define loop(k) rep(author_is_masa,k)
#define chmin(a,b) if((a)>(b)) (a)=(b);
#define chmax(a,b) if((a)<(b)) (a)=(b);
#define vi vector<int>
#define pii pair<int,int>
#define all(v) (v).begin(),(v).end()
#define allr(v) (v).rbegin(),(v).rend()
#define pb push_back
#define pf push_front
int gcd(int a,int b){/*a>=0,b>=0,￢(a=b=0)*/
while(min(a,b)>0){if(a<b)swap(a,b);a%=b;}return max(a,b);
}
int dx[]={1,0,-1,0,1,-1,-1,1};
int dy[]={0,1,0,-1,1,1,-1,-1};
const int MOD = 1e9+7;
const long long INF = 1e18+10;
/*--------------------------------------------------------------------*/
signed main(){
int a,b;cin>>a>>b;
cout<<a*b<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define PB emplace_back
using namespace std;
const int N = 17;
long long int a[N][N], dp[1<<N];
int main () {
ios::sync_with_stdio(0);
int n;
cin >> n;
for(int i = 0 ; i < n ; i++ ) {
for(int j = 0 ; j < n ; j++ ) {
cin >> a[i][j];
}
}
long long int ans = -1e18;
for(int i = 1 ; i < (1 << n ) ; i++ ) {
long long int mas = 0;
vector<int>v;
for(int j = 0 ; j < n ; j++ ) {
if((1<<j)&i) v.PB(j);
}
for(int u: v) {
for(int uu: v) {
if(u <= uu)continue;
mas += a[u][uu];
}
}
for(int j = i ; j > 0 ; j = (j - 1) & i) {
mas = max(mas, dp[j] + dp[i^j]);
}
if(ans < mas)ans = mas;
dp[i] = mas;
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> l_l;
typedef pair<int, int> i_i;
template<class T>
inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
}
template<class T>
inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
}
const ll INF = 1e18;
const ll MOD = 998244353;
const ll MX = 1000001;
ll N;
void solve() {
cin >> N;
vector<string> a(N);
vector<l_l> adds, subs;
int tlc = 0, trc = 0;
for (int i = 0; i < N; i++) {
int lc = 0, rc = 0;
cin >> a[i];
for (auto& c : a[i]) {
if (c == '(') {
lc++;
} else {
if (lc) lc--;
else rc++;
}
}
if (lc && !rc) tlc += lc;
else if (!lc && rc) trc += rc;
else if (lc && rc) {
if (lc >= rc) adds.push_back({rc, lc});
else subs.push_back({lc, rc});
}
}
sort(adds.begin(), adds.end());
sort(subs.begin(), subs.end(), greater<pair<int, int>>());
bool pos = true;
for (auto& i : adds) {
if (i.first > tlc) {
pos = false;
break;
} else {
tlc -= i.first;
tlc += i.second;
}
}
for (auto& i : subs) {
if (i.second > tlc) {
pos = false;
break;
} else {
tlc -= i.second;
tlc += i.first;
}
}
if (pos && tlc == trc) cout << "Yes";
else cout << "No";
}
int main() {
cin.sync_with_stdio(0); cin.tie(0);
ll T = 1; // cin >> T;
while (T--) solve();
return 0;
// You should actually read the stuff at the bottom
}
/* Stuff to Look For
* -----------------
* Int overflow, array bounds
* Initializing all variables, avoid weird behavior
* Edge cases(n = 0, n = 1)
* Just return 0 after result
*/
| 0 |
#include <iostream>
#include <algorithm>
using namespace std;
const int INF = 100000000;
int cost[101][101];
int d[101];
bool used[101];
int n,k;
int dijkstra(int s, int g) {
fill(d,d+n,INF);
fill(used,used+n,false);
d[s] = 0;
while(true) {
int v = -1;
for (int u = 0; u < n; u++ ) {
if (!used[u] && ( v == -1 || d[u] < d[v])) v = u;
}
if (v == -1) break;
used[v] = true;
for (int u = 0; u < n; u++ ) {
d[u] = min(d[u],d[v] + cost[v][u]);
}
}
if ( d[g] == INF ) return INF;
else return d[g];
}
int main() {
while (cin >> n >> k, n||k) {
for ( int i = 0; i < n; i++ ) {
for ( int j = 0; j < n; j++ ) {
cost[i][j] = INF;
}
}
for ( int i = 0; i < k; i++ ) {
int order; cin >> order;
if ( order == 0 ) {
int a,b; cin >> a >> b;
a--; b--;
int ans = dijkstra(a,b);
if ( ans == INF ) cout << -1 << endl;
else cout << ans << endl;
} else if ( order == 1 ) {
int c,d,e; cin >> c >> d >> e;
c--; d--;
cost[c][d] = min(e,cost[c][d]);
cost[d][c] = min(e,cost[d][c]);
}
}
}
return 0;
} | #include<iostream>
using namespace std;
class meb{
public:
int num;
unsigned long long tanka;
unsigned long long count;
unsigned long long sum;
};
int main(){
int n;
while(1){
int cc=0;
cin>>n;
meb st[n];
if(n==0)break;
for(int i=0;i<n;i++){
cin>>st[i].num>>st[i].tanka>>st[i].count;
}
for(int k=0;k<n;k++){
st[k].sum=st[k].tanka*st[k].count;
}
for(int j=0;j<n;j++){
for(int l=j+1;l<n;l++){
if(st[j].num==st[l].num){
(st[j].sum)=(st[j].sum)+(st[l].sum);
st[l].sum=0;
}
}
}
for(int a=0;a<n;a++){
if(st[a].sum>=1000000)cout<<st[a].num<<endl;
else cc++;
}
if(cc==n)cout<<"NA"<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long lol;
//マクロ
//forループ関係
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
//Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define REP(i,n) for(lol i=0;i<lol(n);i++)
#define REPD(i,n) for(lol i=n-1;i>=0;i--)
#define FOR(i,a,b) for(lol i=a;i<=lol(b);i++)
#define FORD(i,a,b) for(lol i=a;i>=lol(b);i--)
//xにはvectorなどのコンテナ
#define ALL(x) x.begin(),x.end() //sortなどの引数を省略したい
#define SIZE(x) lol(x.size()) //sizeをsize_tからllに直しておく
//定数
#define PI 3.1415926535897932385 //pi
#define INF 1000000000000 //10^12:極めて大きい値,∞
#define MOD 1000000007 //10^9+7:合同式の法
#define MAXR 100000 //10^5:配列の最大のrange(素数列挙などで使用)
//最大値最小値
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int main()
{
lol result{0};
string n; cin >> n;
//lol k; cin >> k;
/*
vector<lol> a(n);
REP(i, n)
{
cin >> a[i];
}
*/
REP(i, 3)
{
if(n[i] == '7')
result = 1;
}
if(result)
cout << "Yes" << endl;
else
{
cout << "No" << endl;
}
return 0;
} | #include <iostream>
#include <math.h>
#include <numeric>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <queue>
#include <queue>
#include <stack>
#include <sstream>
#include <set>
typedef long long ll;
const int dx[8]={1,0,-1,0,1,-1,-1,1};
const int dy[8]={0,1,0,-1,1,1,-1,-1};
const int dr[4] = {-1, 0, 1, 0};
const int dc[4] = { 0, 1, 0,-1};
const int INF = 1e9;
#define FOR(i, a, n) for(int i = (int)(a); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define SORT(a) sort(a.begin(),a.end())
#define REVERSE(a) reverse(a.begin(),a.end())
int guki (int a){
if(a%2==0) return 0;
else return 1;
}
int gcd(int a, int b){
if(a%b==0){
return b;
}else{
return (gcd(b,a%b));
}
}
int lcm(int a, int b){
int x = gcd(a,b);
return (a*b/x);
}
using namespace std;
// now
struct UnionFind {
vector<int> d;
UnionFind(int n=0) : d(n,-1){}
int Find (int x){//根の番号を探す
if(d[x] < 0) return x;
return d[x] = Find(d[x]);
}
bool unite (int x, int y){
x = Find(x); y = Find(y);
if(x == y ) return false;
if(d[x] < d[y]){
swap(x,y);
}
d[x] += d[y];
d[y] = x;
return true;
}
bool same(int x, int y){
return Find(x) == Find(y);
}
int size(int x) {
return (-d[Find(x)]);
}
};
ll nCr (ll n, ll r){
ll ans = 1;
for(ll i = n ; i > n-r ; i --){
ans *= i;
}
for(ll i = 1 ; i<= r; i ++){
ans /= i;
}
return ans ;
}
int nPr (int n,int r){
int ans = 1;
for(int i = n ; i > n-r ; i --){
ans *= i;
}
return ans ;
}
ll modd = 1e9+ 7;
ll wa (ll n,ll mi, ll ma){
ll ans = n * (mi+ma) /2;
return ans;
}
int main(){
ll n;
cin >> n;
string s = "";
while(n){
n--;
s += ((n%26) + 'a');
n /= 26;
}
reverse(s.begin(), s.end());
cout << s <<endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef pair<double,string> P;
int main(){
int n;
while(cin>>n,n){
P pr[55];
for(int i=0;i<n;i++){
string l;
cin>>l;
int p,a,b,c,d,e,f,s,m;
cin>>p>>a>>b>>c>>d>>e>>f>>s>>m;
double sumi=f*s*m-p;
double sumt=a+b+c+(d+e)*m;
pr[i]=P(-(sumi/sumt),l);
}
sort(pr,pr+n);
for(int i=0;i<n;i++)cout<<pr[i].second<<endl;
cout<<"#"<<endl;
}
return 0;
}
| #include <stdio.h>
#include <string.h>
int main(void){
int p, sum, d, e, f, s, m, n, i, j, x, max_i;
double tmp1, eff[50];
char str[50][21], C, tmp2[21];
while(1){
scanf("%d%*c",&n);
if(n == 0)
break;
for(i = 0;i < n;i++){
j = 0;
while((C = getchar()) != ' ')
str[i][j++] = C;
str[i][j] = '\0';
scanf("%d",&p);
sum = 0;
for(j = 0;j < 3;j++){
scanf("%d",&x);
sum += x;
}
scanf("%d%d%d%d%d%*c",&d,&e,&f,&s,&m);
for(j = 0;j < m;j++)
sum += d + e;
eff[i] = (double)(m * f * s - p) / sum; // 期作 * 1つの種からできる実の数 * 実の価格 - 種の値段
}
for(i = 0;i < n - 1;i++){
max_i = i;
for(j = i + 1;j < n;j++){
if(eff[max_i] < eff[j])
max_i = j;
else if(eff[max_i] == eff[j] && strcmp(str[max_i],str[j]) > 0)
max_i = j;
}
if(i != max_i){
tmp1 = eff[i];
strcpy(tmp2,str[i]);
eff[i] = eff[max_i];
strcpy(str[i],str[max_i]);
eff[max_i] = tmp1;
strcpy(str[max_i],tmp2);
}
}
for(i = 0;i < n;i++)
printf("%s\n",str[i]);
printf("#\n");
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define rep(i,m,n) for(int i=m;i<n;i++)
ll mod=1e9+7;
int main(){
int n;
cin>>n;
cout<<n/3<<endl;
} | #include<bits/stdc++.h>
using namespace std;
///Welcome to Nasif's Code
#define bug printf("bug\n");
#define bug2(var) cout<<#var<<" "<<var<<endl;
#define co(q) cout<<q<<endl;
#define all(q) (q).begin(),(q).end()
typedef long long int ll;
typedef unsigned long long int ull;
const int MOD = (int)1e9+7;
const int MAX = 1e6;
#define pi acos(-1)
#define inf 1000000000000000LL
#define FastRead ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int main()
{
FastRead
//freopen("output.txt", "w", stdout);
int n;
cin>>n;
string s;
if(n==0)
s="0";
while(n!=0){
int cur=n%(-2);
n/=(-2);
if(cur<0){
cur=abs(cur);
n++;
}
s+=cur+48;
}
reverse(all(s));
cout<<s<<endl;
return 0;
}
| 0 |
#include<iostream>
#include<algorithm>
using namespace std;
int main (void)
{
int a,b;
cin>>a>>b;
int start=1;
b=b-1;
int ans;
ans=b/(a-1);
if(b%(a-1)!=0)ans++;
cout<<ans<<endl;
} | #include <stdio.h>
typedef long long ll;
int main(void) {
ll h, w, n, m;
scanf("%lld%lld%lld", &h, &w, &n);
m = h > w ? h : w;
printf("%lld", (n + m - 1) / m);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int,int>;
using pll = pair<long long, long long>;
const long long INF = 1<<29;
const int MOD = 1000000007;
long long ruizyou(long long m,long long n){
if(m == 0)return 0;
if(m == 1)return 1;
long long ans = 1;
long long tmp = m;
for(int i=0;i<=30;i++){
if(n & (1<<i)){
ans *= tmp;
ans %= MOD;
}
tmp *= tmp;
tmp %= MOD;
}
return ans;
}
long long kaizyou(long long x){
if(x == 0)return 1;
return x * kaizyou(x-1) % MOD;
}
long long comb(long long x,long long y){
long long bunsi = kaizyou(x);
long long bunbo = kaizyou(x-y) * kaizyou(y) % MOD;
return bunsi * ruizyou((int)bunbo,MOD-2) % MOD;
}
struct unionfind{
vector<int> par;
vector<int> hukasa;
unionfind(int n){
par = vector<int>(n);
hukasa = vector<int>(n,0);
for(int i=0;i<n;i++){
par.at(i) = i;
}
}
int root(int x){
if(par.at(x) == x)return x;
return root(par.at(x));
}
void unite(int x,int y){
int rx = root(x);
int ry = root(y);
if(rx == ry)return;
if(hukasa.at(rx) >= hukasa.at(ry)){
par.at(ry) = rx;
hukasa.at(rx) = max(hukasa.at(ry) + 1,hukasa.at(rx));
}
else{
par.at(rx) = ry;
}
}
bool same(int x,int y){
return root(x) == root(y);
}
};
int ctoi(char a){
return a - '0';
}
long long gcd(long long a,long long b){
long long c = max(a,b);
long long d = min(a,b);
if(d % c == 0)return c;
return gcd(c,d%c);
}
long long lcm(long long a,long long b){
return a * b / gcd(a,b);
}
int main(){
int a;
cin >> a;
cout << a + a*a + a*a*a << endl;
} | #include <iostream>
#include <cstdio>
using namespace std;
int n, a, b;
int main() {
cin >> n;
if(n==1) cout << "Hello World";
else {
cin >> a >> b;
cout << a+b;
}
return 0;
}
| 0 |
#include<iostream>
#include<vector>
#include<cstring>
#include<algorithm>
using namespace std;
const int N_MAX = 100;
const int INF = 1000000;
struct edge{
int to, cap, rev;
edge(int t, int c, int r): to(t), cap(c), rev(r){}
};
vector<edge> G[N_MAX * 2];
bool used[N_MAX * 2];
void add_edge(int from, int to, int cap){
G[from].emplace_back(to, cap, G[to].size());
G[to].emplace_back(from, 0, G[from].size()-1);
}
int dfs(int v, int t, int f){
if (v == t) return f;
used[v] = true;
for(int i = 0; i < G[v].size(); i++){
edge &e = G[v][i];
if (!used[e.to] && e.cap > 0){
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0){
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
int max_flow(int s, int t){
int flow = 0;
for(;;){
memset(used, 0, sizeof(used));
int f = dfs(s, t, INF);
if (f == 0) return flow;
flow += f;
}
}
int main(){
int n;
cin >> n;
vector<pair<int, int>> RED;
vector<pair<int, int>> BLUE;
for(int i = 0; i < n; i++){
int a, b;
cin >> a >> b;
RED.emplace_back(a, b);
}
for(int i = 0; i < n; i++){
int c, d;
cin >> c >> d;
BLUE.emplace_back(c, d);
}
for(int i = 1; i <= n; i++){
int a = RED[i-1].first, b = RED[i-1].second;
for(int j = 1; j <= n; j++){
int c = BLUE[j-1].first, d = BLUE[j-1].second;
if (a < c && b < d){
add_edge(i, n+j, 1);
}
}
}
for(int i = 1; i <= n; i++){
add_edge(0, i, 1);
add_edge(n+i, 2 * n + 1, 1);
}
cout << max_flow(0, 2 * n + 1) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
#define fi first
#define se second
long long mo = 1e9 + 7;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> Pii;
typedef pair<ll,ll> Pll;
template<class T, class S> void cmin(T &a, const S &b) { if (a > b)a = b; }
template<class T, class S> void cmax(T &a, const S &b) { if (a < b)a = b; }
template<class A>void PR(A a,ll n){rep(i,n){if(i)cout<<' ';cout<<a[i];}cout << "\n";}
ld PI=3.14159265358979323846;
int main(){
ll N;
cin >> N;
vector<ll> a(N), b(N), c(N), d(N);
vector<Pll> R(N), B(N);
rep(i,N){
cin >> a[i] >> b[i];
//a[i];
//b[i];
R[i] = Pll(a[i], b[i]);
}
vector<vector<ll>> note(2*N+100,vector<ll>(2*N+100));
rep(i,N){
cin >> c[i] >> d[i];
//c[i]++;
//d[i]++;
B[i] = Pll(c[i], d[i]);
/*rep(j,c[i]){
rep(k,d[i]){
note[j][k]++;
}
}*/
}
sort(R.begin(), R.end());
sort(B.begin(), B.end());
vector<ll> memo(N*2+100);
ll ans = 0;
rep(i,N){
ll cc = B[i].fi;
ll dd = B[i].se;
ll id = -1;
ll score = -1e18;
rep(j,N){
if(memo[j]) continue;
ll aa = R[j].fi;
ll bb = R[j].se;
if(aa < cc && bb < dd){
if(bb >= score){
//if(score > note[aa][bb]){
// score = note[aa][bb];
id = j;
score = bb;
}
//}
}
}
if(id != -1){
memo[id] = 1;
ans++;
}
/*
rep(j,cc){
rep(k,dd){
note[j][k]--;
}
}*/
}
cout << ans << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
//ライブラリ始まり
//定数
//円周率
const double pi = 3.1415926535897932384;
//天井
const int INF = 1000000000; // = 10^9
const ll LINF = 1000000000000000; // = 10^15
//ABC文字列
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZABC";
const string abc = "abcdefghijklmnopqrstuvwxyzabc";
//よくあるmodくん
const ll MOD = 1000000007; // = 10^9 + 7
//データ構造
//Union_Find木
struct UnionFind {
vector<int> UF; // UF.at(i) : iの親の番号
vector<int> SIZE; // SIZE.at(root(i)) : iと連結されてる要素の数
UnionFind(int N) : UF(N), SIZE(N, 1) { // 最初は全てが根であるとして初期化
for(int i = 0; i < N; i++) {
UF.at(i) = i;
}
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (UF.at(x) == x) {
return x;
}
return UF.at(x) = root(UF.at(x));
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); // xの根をrx
int ry = root(y); // yの根をry
if (rx == ry) {
return; // xとyの根が同じ(=同じ木にある)時はそのまま
}
// xとyの根が同じでない(=同じ木にない)時：小さい方の根を大きい方の根につける
if (SIZE.at(rx) < SIZE.at(ry)) {
UF.at(rx) = ry;
SIZE.at(ry) += SIZE.at(rx);
SIZE.at(rx) = 0;
}
else {
UF.at(ry) = rx;
SIZE.at(rx) += SIZE.at(ry);
SIZE.at(ry) = 0;
}
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
int size(int x) { // xと連結されてる要素の数を返す
return SIZE.at(root(x));
}
};
//関数 (計算量)
//ctoi (O(1))
int ctoi(char c){
if (c == '0') return 0;
if (c == '1') return 1;
if (c == '2') return 2;
if (c == '3') return 3;
if (c == '4') return 4;
if (c == '5') return 5;
if (c == '6') return 6;
if (c == '7') return 7;
if (c == '8') return 8;
if (c == '9') return 9;
return -1;
}
//to_char (O(1))
char to_char(int i){
if (i == 0) return '0';
if (i == 1) return '1';
if (i == 2) return '2';
if (i == 3) return '3';
if (i == 4) return '4';
if (i == 5) return '5';
if (i == 6) return '6';
if (i == 7) return '7';
if (i == 8) return '8';
if (i == 9) return '9';
return ' ';
}
//素数判定
//一つ一つの判定ではこっちの方が速い(一つ当たりO(√N))
//一方100までに何個あるかなどはエストネスの篩の方が良い（O(NlogN))
bool PN(int x) {
if (x <= 1) return false; // 1や0,-1は素数ではない
if (x == 2) return true; // √2 + 1 > 2 なので下でやると 2 ％ 2 = 0 となり判定できない
for (int i = 2; i < sqrt(x) + 1; i++) {
if (x % i == 0) return false; // 割れたら素数じゃない
}
return true;
}
// A^N mod M を計算する。modしたくなかったらM = LINFとかにすればよい。(O(√N))
ll modpow(ll A, ll N, ll M) {
long long ans = 1;
while (N > 0) {
if (N & 1) ans = ans * A % M;
A = A * A % M;
N >>= 1;
}
return ans;
}
//ライブラリ終わり
//メイン処理
int main() {
cout << fixed << setprecision(16); //精度向上
//ここまでテンプレ
int N, M, Q;
cin >> N >> M >> Q;
vector<vector<int>> T(N + 2, vector<int>(N + 1, 0));
for (int i = 0; i < M; i++) {
int L, R;
cin >> L >> R;
T.at(L).at(R)++;
}
for (int i = 1; i < N; i++) {
for (int j = 1; j <= N - i; j++) {
T.at(j).at(j + i) += (T.at(j + 1).at(j + i) + T.at(j).at(j + i - 1));
T.at(j).at(j + i) -= T.at(j + 1).at(j + i - 1);
}
}
for (int i = 0; i < Q; i++) {
int S, G;
cin >> S >> G;
cout << T.at(S).at(G) << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, q;
string s;
cin >> n >> s >> q;
while (q--) {
int k;
cin >> k;
vector<ll> d(n), m(n), dm(n);
ll ans = 0;
for (int i = 0; i < n; i++) {
if (i == 0) {
if (s.at(i) == 'D') d.at(i)++;
if (s.at(i) == 'M') m.at(i)++;
continue;
}
d.at(i) = d.at(i - 1);
m.at(i) = m.at(i - 1);
dm.at(i) = dm.at(i - 1);
if (i >= k) {
if (s.at(i - k) == 'D') {
d.at(i)--;
dm.at(i) -= m.at(i - 1);
}
if (s.at(i - k) == 'M') {
m.at(i)--;
}
}
if (s.at(i) == 'D') {
d.at(i)++;
}
if (s.at(i) == 'M') {
m.at(i)++;
dm.at(i) += d.at(i);
}
if (s.at(i) == 'C') {
ans += dm.at(i);
}
}
cout << ans << '\n';
}
} | 0 |
#include <algorithm>
#include <iostream>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int n, m;
int p[1003];
void solve() {
sort(p, p + n);
reverse(p, p+n);
int ans = 0;
rep(i, n) ans += p[i];
for (int i = 0; i + m - 1 < n; i += m) {
ans -= p[i + m - 1];
}
cout << ans << endl;
}
int main() {
while (cin >> n >> m) {
rep(i, n) cin >> p[i];
if (n == 0 && m == 0) break;
solve();
}
return 0;
} | #include<stdio.h>
#include<iostream>
using namespace std;
void insert_sort(long int *num,long int n,long int g,long int *cnt);
int main(){
long int cnt[1];
long int num[1000000];
long int n;
long int i;
long int m[1000000];
long int count=0;
long int k;
int yn=0;
cnt[0]=0;
cin>>n;
for(i=0;i<n;i++){
cin>>num[i];
}
m[0]=n-1;
while(yn==0){
yn=1;
insert_sort(num,n,m[count],cnt);
count++;
m[count]=m[count-1]/2;
for(i=0;i<n-1;i++){
if(num[i]>num[i+1]){
yn=0;
break;
}
}
}
cout<<count<<endl;
for(i=0;i<count;i++){
cout<<m[i];
if(i<count-1){
cout<<" ";
}else{
cout<<endl;
}
}
cout<<cnt[0]<<endl;
for(i=0;i<n;i++){
cout<<num[i]<<endl;
}
return 0;
}
void insert_sort(long int *num,long int n,long int g,long int *cnt){
long int i;
long int j;
long int k;
long int tmp;
long a;
a=cnt[0];
for(i=g;i<n;i++){
tmp=num[i];
j=i-g;
while((j>=0)&&(tmp<num[j])){
num[j+g]=num[j];
j-=g;
cnt[0]++;
}
num[j+g]=tmp;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main () {
int A, B;
cin >> A >> B;
int tasu = A + B;
int hiku = A - B;
int kake = A * B;
if (tasu >= hiku && tasu >= kake) {
cout << tasu << endl;
}
else if (hiku >= kake && hiku >= tasu) {
cout << hiku << endl;
}
else {
cout << kake << endl;
}
}
| #include <bits/stdc++.h>
#define INF 5000000000000000000
#define ll long long
#define pll pair<ll, ll>
using namespace std;
int main() {
ll a, b;
cin >> a >> b;
ll ans = max(a + b, a - b);
ans = max(ans, a * b);
cout << ans << endl;
} | 1 |
#include <algorithm>
#include <boost/optional.hpp>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define REP(i, n) for(int i = 0, i##_MACRO = (n); i < i##_MACRO; i++)
#define RANGE(i, a, b) for(int i = (a), i##_MACRO = (b); i < i##_MACRO; i++)
#define EACH(e, a) for(auto&& e : a)
#define ALL(a) std::begin(a), std::end(a)
#define RALL(a) std::rbegin(a), std::rend(a)
#define FILL(a, n) memset((a), n, sizeof(a))
#define FILLZ(a) FILL(a, 0)
#define INT(x) (static_cast<int>(x))
#define PRECISION(x) std::fixed << std::setprecision(x)
using namespace std;
using ll = long long;
using VI = std::vector<int>;
using VI2D = std::vector<vector<int>>;
using VLL = std::vector<long long>;
using VLL2D = std::vector<vector<long long>>;
constexpr int INF = 2e9;
constexpr double EPS = 1e-10;
constexpr double PI = acos(-1.0);
constexpr int dx[] = {-1, 0, 1, 0};
constexpr int dy[] = {0, -1, 0, 1};
template <typename T>
constexpr int sign(T x) {
return x < 0 ? -1 : x > 0 ? 1 : 0;
}
template <>
constexpr int sign(double x) {
return x < -EPS ? -1 : x > EPS ? 1 : 0;
}
template <typename T, typename U>
constexpr void chmax(T& m, U x) {
m = max(m, x);
}
template <typename T, typename U>
constexpr void chmin(T& m, U x) {
m = min(m, x);
}
template <typename T>
constexpr T square(T x) {
return x * x;
}
int main() {
int n, k;
cin >> n >> k;
VI v(n);
REP(i, n) { cin >> v[i]; }
int res_max = 0;
REP(i, n) { res_max += max(v[i], 0); }
VI left(k + 1, 0);
REP(ope, k + 1) {
REP(bound, ope + 1) {
int tmp = 0;
priority_queue<int, VI, greater<int>> pq;
REP(index, ope) {
if(index < min(n, bound)) {
tmp += v[index];
pq.push(v[index]);
} else if(!pq.empty() && pq.top() < 0) {
tmp -= pq.top();
pq.pop();
}
}
chmax(left[ope], tmp);
}
}
reverse(ALL(v));
VI right(k + 1, 0);
REP(ope, k + 1) {
REP(bound, ope + 1) {
int tmp = 0;
priority_queue<int, VI, greater<int>> pq;
REP(index, ope) {
if(index < min(n, bound)) {
tmp += v[index];
pq.push(v[index]);
} else if(!pq.empty() && pq.top() < 0) {
tmp -= pq.top();
pq.pop();
}
}
chmax(right[ope], tmp);
}
}
int result = 0;
REP(i, k + 1) { chmax(result, left[i] + right[k - i]); }
cout << min(result, res_max) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using E = pair<ll, P>;
const ll INF = 1LL << 60;
int n;
ll D;
ll a[200005];
vector< E > edges;
void solve(int L, int R) {
if (R - L <= 1) return;
int mid = (R + L) / 2;
ll lval = INF;
int lidx = -1;
for (int i = L; i < mid; i++) {
ll tmp = a[i] - D * i;
if (lval > tmp) {
lidx = i;
lval = tmp;
}
}
ll rval = INF;
int ridx = -1;
for (int i = mid; i < R; i++) {
ll tmp = a[i] + D * i;
if (rval > tmp) {
ridx = i;
rval = tmp;
}
}
for (int i = L; i < mid; i++) {
edges.emplace_back(a[i] + a[ridx] + D * (ridx - i), P(i, ridx));
}
for (int i = mid; i < R; i++) {
edges.emplace_back(a[i] + a[lidx] + D * (i - lidx), P(lidx, i));
}
solve(L, mid);
solve(mid, R);
}
struct UnionFind {
//各要素が属する集合の代表(根)を管理する
//もし、要素xが根であればdata[x]は負の値を取り、-data[x]はxが属する集合の大きさに等しい
vector<int> data;
UnionFind(int sz) : data(sz, -1) {}
bool unite(int x, int y) {
x = find(x);
y = find(y);
bool is_union = (x != y);
if (is_union) {
if (data[x] > data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
}
return is_union;
}
int find(int x) {
if (data[x] < 0) { //要素xが根である
return x;
} else {
data[x] = find(data[x]); //data[x]がxの属する集合の根でない場合、根になるよう更新される
return data[x];
}
}
bool same(int x, int y) {
return find(x) == find(y);
}
int size(int x) {
return -data[find(x)];
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> D;
for (int i = 0; i < n; i++) cin >> a[i];
solve(0, n);
sort(edges.begin(), edges.end());
UnionFind uf(n);
ll ans = 0;
for (E& e : edges) {
ll cost = e.first;
int u = e.second.first, v = e.second.second;
if (!uf.same(u, v)) {
uf.unite(u, v);
ans += cost;
}
}
cout << ans << endl;
return 0;
} | 0 |
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
#define MAX 10000000
int b[110];
bool used[110];
struct edge{int from, to, cost;};
int solve(int a[110][110], int n, int s, int e){
fill(b, b+110, MAX);
fill(used, used+110, false);
b[s] = 0;
while(1){
int v = -1;
for(int i = 1;i <= n;i++){
if(!used[i] && (v == -1 || b[v] > b[i]))v = i;
}
if(v == -1)break;
used[v] = true;
for(int i = 1;i <= n;i++){
if(a[v][i] != -1)b[i] = min(b[i], b[v] + a[v][i]);
}
}
return 0;
}
int main(){
int a[110][110], n, k;
while(cin >> n >> k, k){
fill((int*)a, (int*)(a+110), -1);
int c, d, e, f;
for(int i = 0;i < k;i++){
cin >> c;
if(c == 0){
cin >> d >> e;
solve(a, n, d, e);
if(b[e] != MAX)cout << b[e] << endl;
else cout << -1 << endl;
}else {
cin >> d >> e >> f;
if(a[d][e] > f || a[d][e] == -1)
a[d][e] = a[e][d] = f;
}
}
}
return 0;
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define mp make_pair
#define pb(x) push_back(x)
#define vll vector<long long>
#define pll pair<long long, long long>
#define mll map<long long, long long>
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(), (v).end()
#define gcd __gcd
#define clr(x) memset(x, 0, sizeof(x))
#define mod 1000000007LL
#define mod2 998244353LL
#define INF 1e18
typedef long long ll;
typedef long double ld;
typedef tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update> o_tree;
const int N=1e5+5;
vll v[N];
ll vis[N];
vll path;
ll maxh[N];
ll f=0;
void dfs(ll x,ll s,ll dest)
{
if(f)return;
if(x==dest)
{
f=1;
path.pb(x);
return;
}
path.pb(x);
for(auto it:v[x])
{
if(it==s)continue;
dfs(it,x,dest);
}
if(f)return;
path.pop_back();
}
void dfs2(ll x,ll s)
{
ll f=0;
// cout<<x+1<<"\n";
for(auto it:v[x])
{
if(it==s)continue;
f=1;
dfs2(it,x);
maxh[x]=max(maxh[x],maxh[it]+1ll);
}
if(!f)
{
maxh[x]=1;
}
}
void solve()
{
ll n;
cin>>n;
ll aa,bb;
cin>>aa>>bb;
aa--,bb--;
ll i,j;
for(i=1;i<n;i++)
{
ll x,y;
cin>>x>>y;
x--,y--;
v[x].pb(y);
v[y].pb(x);
};
dfs(aa,-1,bb);
// for(auto it:path)
// {
// cout<<it+1<<" ";
// }
// all i need is max height of subtree
dfs2(bb,-1);
ll maxi=0;
for(i=1;i<sz(path);i++)
{
// distance travelled to reach node path[i] = i;
ll dist_1 = i;
ll dist_from_bb = sz(path)-1-i;
if(dist_1>dist_from_bb)continue;
ll maxheight = maxh[path[i]]-1;
ll dif = dist_from_bb-dist_1;
ll tans = dist_1;
tans+=(dif+(maxheight-1));
// ll tans = (maxheight)+dist_from_bb;
// cout<<dif<<" "<<maxheight<<" "<<dist_from_bb<<" ";
// cout<<path[i]+1<<"<-- "<<tans<<"\n";
maxi=max(maxi,tans);
}
cout<<maxi<<"\n";
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("input.txt","r" ))
{
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
cout<<setprecision(20);
ll t=1;
// cin>>t;
while(t--)
{
solve();
}
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iomanip>
#include <numeric>
#include <queue>
#include <cmath>
using namespace std;
int main() {
int n, m;
cin >> n;
unordered_map<string, int> um;
int res = 0;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
um[s]++;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> s;
um[s]--;
}
for (auto p : um) {
res = max(res, p.second);
}
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(), (x).end()
const int N = 200200;
const int MAXN = 600600;
int ans = 59408656;
int n;
vector<int> on0[MAXN][4];
vector<int> on1[MAXN][4];
vector<int> on2[MAXN][4];
vector<int> on3[MAXN][4];
int Upd(vector<int> a, vector<int> b)
{
int ans = 59408656;
int j = 0;
for (int i = 0; i < a.size(); i++)
{
while (j < b.size() && a[i] > b[j]) j++;
if (j < b.size())
{
ans = min(ans, b[j] - a[i]);
}
}
return ans;
}
int main()
{
cin >> n;
for (int i = 0; i < n; i++)
{
int x, y;
char dir;
cin >> x >> y >> dir;
x += N;
int z;
if (dir == 'U') z = 0;
if (dir == 'R') z = 1;
if (dir == 'D') z = 2;
if (dir == 'L') z = 3;
on0[x][z].push_back(y);
on1[y][z].push_back(x);
on2[x + y][z].push_back(x);
on3[x - y][z].push_back(x);
}
for (int i = 0; i < MAXN; i++)
{
for (int z = 0; z < 4; z++)
{
sort(all(on0[i][z]));
sort(all(on1[i][z]));
sort(all(on2[i][z]));
sort(all(on3[i][z]));
}
ans = min(ans, Upd(on0[i][0], on0[i][2]));
ans = min(ans, Upd(on1[i][1], on1[i][3]));
ans = min(ans, 2 * Upd(on3[i][0], on3[i][3]));
ans = min(ans, 2 * Upd(on3[i][1], on3[i][2]));
ans = min(ans, 2 * Upd(on2[i][1], on2[i][0]));
ans = min(ans, 2 * Upd(on2[i][2], on2[i][3]));
}
if (ans == 59408656) cout << "SAFE";
else cout << ans * 5;
}
| 0 |
#include <bits/stdc++.h>
#include <ctime>
#define rep(i,a,b) for(int i =a;i<b;i++)
using namespace std;
typedef unsigned long long ll;
inline int cine() {int a; return scanf("%d", &a) ? a : 1e9;}
void solve() {
int train, bus, mine = 1e9, sum = 0 ;
rep(i, 0, 2) {
cin >> train;
mine = min(mine, train);
}
sum += mine;
mine = 1e9;
rep(i, 0, 2) {
cin >> bus;
mine = min(mine, bus);
}
sum += mine;
cout << sum;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("i.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
solve();
#ifndef ONLINE_JUDGE
cout << "\nTime Elapsed :" << 0.1 * clock() / CLOCKS_PER_SEC << "s\n";
#endif
} | #include <bits/stdc++.h>
#define rep(i,n) for (int (i) = 0; (i) < (n); i++)
#define ll long long
using namespace std;
int main() {
int q,w,e,r; cin >>q>>w>>e>>r;
cout << min(q,w) + min(e,r);
} | 1 |
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <fstream>
#include <cassert>
#include <cstring>
#include <numeric>
#include <ctime>
#include <complex>
#include <bitset>
#include <random>
#include <stack>
using namespace std;
typedef long long ll;
typedef long double ld;
#define int ll
#define double ld
#define loop(i, n) for(int i = 0; i < (int)n; ++i)
#define loop1(i, n) for(int i = 1; i <= (int)n; ++i)
#define F first
#define S second
#define pb push_back
#define pi pair <int, int>
#define all(x) begin(x), end(x)
#define ti tuple <int, int, int>
#define Point Vect
#define mkt make_tuple
#define no {cout << -1; return;}
void solve() {
int L = 0, R = 1000000;
int n, m;
cin >> n >> m;
loop(i, m) {
int l, r;
cin >> l >> r;
L = max(l, L);
R = min(R, r);
}
if (R < L)
cout << 0;
else
cout << R - L + 1;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
//int t; cin >> t; loop(i, t)
solve();
return 0;
} | #include<iostream>
#include<algorithm>
#include<vector>
#include<iomanip>
#include<cmath>
using namespace std;
#define rep(i,N) for(int i=0;i<N;i++) //0から
#define REP(i,N) for(int j=i;j<N;j++) //iから
typedef long long ll;
ll binary_search(vector<ll> a, ll n, ll key){
ll right = n, left = -1;
ll md = (right + left) / 2;
while(right - left > 1){
if(a[md] <= key){
right = md;
}else{
left = md;
}
md = (right + left) / 2;
}
if(left == -1) return -1; //無い場合
return right;
}
vector<ll> prime;
void Prime(ll n){ //線形篩,素数列挙
vector<ll> p(n,0);
p[0]=1;
p[1]=1;
for(ll i=2;i<n;i++){
if(p[i]==0){
prime.push_back(i);
p[i]=i;
}
ll k=prime.size();
for(ll j=0;j<k && i*prime[j]<n && prime[j]<=p[i];j++){
p[i*prime[j]]=prime[j];
}
}
}
#define MOD ((ll)1e+9 + 7)
//cout<<fixed<<setprecision(10);
int main(){
int n,m;
cin>>n>>m;
vector<int> L(m),R(m+1);
rep(i,m){
cin>>L[i]>>R[i];
L[i]--;
}
vector<int> cnt(n+1,0);
rep(i,m){
cnt[L[i]]++;
cnt[R[i]]--;
}
rep(i,n){
cnt[i+1]+=cnt[i];
}
int ans=0;
rep(i,n){
if(cnt[i]==m){
ans++;
}
}
cout<<ans<<endl;
return 0;
}
| 1 |
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <math.h>
#include <map>
using namespace std;
int main(){
double n;
cin >> n;
cout << n*(180-(360/n)) << endl;
return 0;
}
| #include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<set>
#include<iomanip>
#define pi 3.14159265358979323846
#define ll long long
#define rep(i, a, n) for(int i = a; i < n; i++)
using namespace std;
int main(){
string s;
cin >> s;
if(s == "RRR"){
cout << "3\n";
return 0;
}
if(s == "RRS" || s == "SRR"){
cout << "2\n";
return 0;
}
if(s == "SSS"){
cout << "0\n";
return 0;
}
cout << "1\n";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,x;
cin >> N;
x = N%10 + ((N%100) / 10) + ((N%1000) / 100 ) + ((N%10000) / 1000) + ((N%100000) / 10000) + ((N%1000000) / 100000) + ((N%10000000)/1000000)+((N%1000000000) / 10000000);
if(N%x == 0)
cout << "Yes" << endl;
if(N%x != 0){
cout << "No" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
int n; cin >> n;
int a;
string s = to_string(n);
for (char c : s)
{
a += (c - '0');
}
if (!(n % a))
{
cout << "Yes" << endl;
}
else
{
cout << "No" << endl;
}
} | 1 |
#include <iostream>
#include <string>
using namespace std;
int main(){
string s; cin >> s;
int cnt = 0;
for(int i = 2; i < s.size()-1; i++){
if(s[i] == 'C') {
cnt++;
if(cnt == 1) s[i] = 'c';
}
}
if(cnt != 1){
puts("WA");
return 0;
}
for(int i = 0; i < s.size(); i++){
if(i == 0) {
if(s[i] != 'A'){
puts("WA");
return 0;
}
}
else{
if(s[i] - 'a' < 0){
puts("WA");
return 0;
}
}
}
puts("AC");
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int dp[1005];
const char domino[15][15][15] = {
{}, // 0
{}, // 1
{}, // 2
{}, // 3
{"aacd", "bbcd", "efgg", "efhh"}, // 4
{"aabbc", "dee.c", "d..fg", "j..fg", "jiihh"}, // 5
{}, // 6
{"aabbcc.", "dd.ee.f", "..h..gf", "..h..gm", "ii.jj.m", "..k..ln", "..k..ln"} // 7
};
char ans[1005][1005];
int main(){
int N;
scanf("%d", &N);
memset(ans, 0, sizeof(ans));
if(N < 3){printf("-1"); return 0;}
if(N == 3){
printf("aa.\n..b\n..b\n");
return 0;
}else if(N == 6){
printf("aa....\n..b...\n..b...\n...aa.\n.....b\n.....b\n");
return 0;
}
dp[0] = 0;
dp[1] = 1001;
dp[2] = 1001;
dp[3] = 1001;
dp[4] = 1;
dp[5] = 1;
dp[6] = 1001;
dp[7] = 1;
for(int i = 8; i <= N; i ++){
dp[i] = N;
for(int j: {4,5,7}){
//printf("i=%d j=%d\n", i, j);
dp[i] = min(dp[i], 1+dp[i-j]);
}
//printf("dp[%d]=%d\n", i, dp[i]);
}
for(int i = 0; i < N; i ++){
for(int j = 0; j < N; j ++){
ans[i][j] = '.';
}
}
int n = N;
while(n){
for(int j: {4,5,7}){
if(dp[n] == dp[n-j]+1){
//printf("n=%d j=%d\n", n, j);
for(int i = n-j; i < n; i ++){
for(int k = n-j; k < n; k ++){
ans[i][k] = domino[j][i-(n-j)][k-(n-j)];
}
}
n -= j;
break;
}
}
}
for(int i = 0; i < N; i ++){
printf("%s\n", ans[i]);
}
}
| 0 |
#include <stdio.h>
int main() {
char x[102];
char g[102];
scanf ("%s %s", x, g);
printf("%s%s", g ,x);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int INF = (1<<30) - 1;
const ll LINF = (1LL<<60) - 1;
int main(){
string s,t;
cin >> s >> t;
cout << t + s << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); ++i)
int main(void)
{
int n, cnt=0;
string a,b,c;
cin >> n >> a >> b >> c;
rep(i,n) cnt += set<char>({a[i], b[i], c[i]}).size() - 1;
cout << cnt << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i,j,n) for(int i=(int)(j);i<(int)(n);i++)
#define REP(i,j,n) for(int i=(int)(j);i<=(int)(n);i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(),(a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<int,int>
#define priq priority_queue<int>
#define disup(A,key) distance(A.begin(),upper_bound(ALL(A),(int)(key)))
#define dislow(A,key) distance(A.begin(),lower_bound(ALL(A),(int)(key)))
#define tii tuple<int,int,int>
#define Priq priority_queue<int,vi,greater<int>>
#define pb push_back
#define mp make_pair
signed main(){
int N; cin>>N;
vector<string> S(3);
rep(i,0,3) cin>>S[i];
int ans=0;
rep(i,0,N){
set<char> T;
rep(j,0,3)
T.insert(S[j][i]);
ans+=T.size()-1;
}
cout<<ans<<endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
int a;
for(int i=0;i*i<=n;i++)
a=i*i;
cout<<a<<endl;
} | /** author: __nishad__ **/
//#pragma GCC optimize(2)
//#pragma GCC optimize(3, "Ofast", "inline")
#include<bits/stdc++.h>
using namespace std;
typedef long long ll ;
typedef vector<ll> vll ;
#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define all(v) (v).begin(),(v).end()
#define precision(k) cout<<setprecision(k)<<fixed;
#define loop(i,a,b) for(ll i=(a);i<=(b);++i)
#define minv(v) *min_element(all(v))
#define maxv(v) *max_element(all(v))
#define getpos(v,x) (lower_bound(v.begin(),v.end(),x)-v.begin())
#define unq(v) sort(all(v)),(v).erase(unique((v).begin(),(v).end()),(v).end())
#define pb push_back
#define mp make_pair
#define pi 3.14159265358979323
#define endl "\n"
int main()
{
IOS;
ll n, max=0;
cin>>n;
int i;
for(i=n; i>0; i--){
if(sqrt(i) == int(sqrt(i))){
max = i;
cout<<max;
return 0;
}
}
}
| 1 |
#include <cstdio>
#include <algorithm>
#define mod 998244353
#define maxn 200010
#define LL long long
using namespace std;
LL fact[maxn],inv[maxn],ans,t[maxn],p;
int n,m,k,nm;
LL quick_pow(LL a,LL b){//a^b
LL ans=1;
while(b){
if(b&1)ans=ans*a%mod;
a=a*a%mod;
b>>=1;
}
return ans%mod;
}
void init(){
int i;
scanf("%d%d%d",&n,&m,&k);
nm=n,nm=max(nm,m),fact[0]=1;
for(i=1;i<=nm;i++)fact[i]=fact[i-1]*i%mod;//fact[i]代表i!
inv[nm]=quick_pow(fact[nm],mod-2);
for(i=nm-1;i>=0;i--)inv[i]=inv[i+1]*(i+1)%mod;//inv[i]代表i!的乘法逆元
}
LL C(LL a,LL b){//组合数计算
return fact[a]*inv[a-b]%mod*inv[b]%mod;
}
int main(){
int i;
init();
ans=0,p=quick_pow(m-1,n-k-1);
for(i=n-k;i<=n;i++){
ans=(ans+m*p%mod*C(n-1,i-1)%mod)%mod;//C(n-1,i-1)隔板法
p=p*(m-1)%mod;
}
printf("%lld\n",ans);
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include<bits/stdc++.h>
#include <unordered_map>
//#include"testlib.h"
#define endl "\n"
#define all(v) v.begin(),v.end()
#define allr(s) s.rbegin(),s.rend()
#define RT(s) return cout<<s,0
#define sz(s) (int)(s.size())
#define PI acos(-1)
#define EPS 1e-8
#define watch(x) cout << (#x)<<" = "<<x<<endl
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
int dy[] = { 1, -1, 0, 0, -1, 1, 1, -1 };
int dx[] = { 0, 0, 1, -1, 1, -1, 1, -1 };
void file() {
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
//freopen("out.txt", "w", stdout);
#else
//freopen("street.in", "r", stdin);
//freopen("out.txt", "w", stdout);
#endif
}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
int mod = 998244353;
ll fpow(ll x, ll p) {
if (!p)
return 1;
ll sq = fpow(x, p / 2);
sq *= sq;
sq %= mod;
if (p & 1)
sq *= x;
return sq % mod;
}
const int N = 2e5 + 9;
ll fact[N];
void preProc() {
fact[0] = fact[1] = 1;
for (int i = 2; i < N; i++)
fact[i] = (fact[i - 1] * i) % mod;
}
ll nCrMod(ll n, ll r) {
// you must call preProc before using nCr
// you must modify mod first
// you must modify N
if (n < r) return 0;
return (fact[n] * fpow((fact[n - r] * fact[r]) % mod, mod - 2LL)) % mod;
}
int main() {
file();
fast();
preProc();
ll n, m, k; cin >> n >> m >> k;
if (k == n - 1)
RT(fpow(m, n) << endl);
ll ans = 0;
for (int i = 0; i <= k; i++) {
ll num = m * nCrMod(n - 1, i);
num %= mod;
num *= fpow(m - 1, n - i - 1);
num %= mod;
ans += num;
ans %= mod;
}
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned ui;
typedef unsigned long long ul;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef pair<bool, bool> pbb;
typedef vector<int> vi;
#define pb push_back
#define fi first
#define se second
#define mid ((l + r) >> 1)
#define ls (i << 1)
#define rs (i << 1 | 1)
#define enum(i, j, k) for(int i = j; i <= (k); i ++)
#define open(i, j, k) for(int i = j; i < (k); i ++)
#define dec(i, j, k) for(int i = j; i >= (k); i --)
#define ae(x) for(node *p = h[x]; p; p = p->nxt)
#define fill(x, k) memset(x, k, sizeof x)
#define copy(x, y) memcpy(x, y, sizeof x)
#define fio(x) freopen(x".in", "r", stdin); freopen(x".out", "w", stdout);
template <class T> bool chkmin(T &x, T y)
{ return y < x ? (x = y , true) : false; }
template <class T> bool chkmax(T &x, T y)
{ return y > x ? (x = y , true) : false; }
void __init()
{
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cout << fixed << setprecision(16);
srand(time(0) ^ ui(ul(new char)));
}
/* default code ends here */
const int maxn = 2e3 + 10;
int n, m, q;
int a[maxn][maxn], b[maxn][maxn], c[maxn][maxn];
int main()
{
__init();
cin >> n >> m >> q;
string foo;
enum(i, 1, n)
{
cin >> foo;
enum(j, 1, m)
a[i][j] = foo[j - 1] - '0';
}
/*enum(i, 1, n)
{
enum(j, 1, m)
cerr << a[i][j] << ' ';
cerr << endl;
}*/
enum(i, 1, n)
enum(j, 2, m)
b[i][j] = b[i - 1][j] + b[i][j - 1] - b[i - 1][j - 1] + bool(a[i][j] && a[i][j - 1]);
/*enum(i, 1, n)
{
enum(j, 1, m)
cerr << b[i][j] << ' ';
cerr << endl;
}*/
enum(i, 2, n)
enum(j, 1, m)
c[i][j] = c[i - 1][j] + c[i][j - 1] - c[i - 1][j - 1] + bool(a[i][j] && a[i - 1][j]);
enum(i, 1, n)
enum(j, 1, m)
a[i][j] += a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1];
int x1, y1, x2, y2;
while(q --)
{
cin >> x1 >> y1 >> x2 >> y2;
//cerr << (a[x2][y2] - a[x2][y1 - 1] - a[x1 - 1][y2] + a[x1 - 1][y1 - 1]) << ' ' << (b[x2][y2] - b[x2][y1] - b[x1 - 1][y2] + b[x1 - 1][y1]) << ' ' << (c[x2][y2] - c[x2][y1 - 1] - c[x1][y2] + c[x1][y1 - 1]) << endl;
cout << (a[x2][y2] - a[x2][y1 - 1] - a[x1 - 1][y2] + a[x1 - 1][y1 - 1]) - (b[x2][y2] - b[x2][y1] - b[x1 - 1][y2] + b[x1 - 1][y1]) - (c[x2][y2] - c[x2][y1 - 1] - c[x1][y2] + c[x1][y1 - 1]) << '\n';
}
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;
const int inf=1e9+10;
const int maxn=16;
int dp[1<<maxn][maxn],dp2[1<<maxn],n,m,cost[maxn][maxn];
vector <int> g[1<<maxn];
int main(){
for(int i=0;i<maxn;i++) for(int j=0;j<maxn;j++)
cost[i][j]=0;
scanf("%d%d",&n,&m);
for(int i=0;i<m;i++){
int u,v,c;
scanf("%d%d%d",&u,&v,&c);
u--; v--;
cost[u][v]=c;
cost[v][u]=c;
}
for(int mask=0;mask<(1<<n);mask++)
for(int i=0;i<n;i++) for(int j=0;j<n;j++)
if((mask&(1<<i))&&(mask&(1<<j)))
dp2[mask]=dp2[mask]+cost[i][j];
for(int mask=0;mask<(1<<n);mask++) dp2[mask]=dp2[mask]/2;
for(int mask=0;mask<(1<<n);mask++) for(int i=0;i<n;i++) dp[mask][i]=-inf;
for(int mask=0;mask<(1<<n);mask++) if(mask&1) dp[mask][0]=dp2[mask];
for(int mask=0;mask<(1<<n);mask++)
for(int i=0;i<n;i++){
if((dp[mask][i]==-inf)||!(mask&(1<<i))) continue;
for(int mask2=(1<<n)-1-mask;mask2>0;mask2=(mask2-1)&((1<<n)-1-mask)){
for(int j=0;j<n;j++){
if(mask2&(1<<j)&&cost[i][j]>0){
dp[mask|mask2][j]=max(dp[mask|mask2][j],dp[mask][i]+cost[i][j]+dp2[mask2]);
}
}
}
}
printf("%d\n",dp2[(1<<n)-1]-dp[(1<<n)-1][n-1]);
return 0;
} | 0 |
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
using namespace std;
int main(){
string str;
while(cin >> str){
// cout << str << endl;
string strtmp;
for(int i=0;i<str.size();i++){
strtmp.push_back(str[str.size()-1-i]);
}
cout << strtmp << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
//型名省略
typedef long long ll;
typedef vector<long long> vl;
typedef vector<vector<long long>> vll;
typedef vector<char> vc;
typedef vector<vector<char>> vcc;
typedef vector<string> vs;
//マクロ
#define rep(i,n) for(ll i = 0; i < (ll) n; i++)
#define rep2(i,x,n) for(ll i = (ll) x; i < (ll) n; i++)
#define all(A) A.begin(), A.end()
int main() {
ll a,b; cin >> a >> b;
cout << a * b << endl;
} | 0 |
#include<cstdio>
#include<queue>
#include<utility>
using namespace std;
typedef pair<int, int> P;
const int MAX_N = 400;
const int di[] = {1, 0, -1, 0};
const int dj[] = {0, 1, 0, -1};
bool color[MAX_N][MAX_N];
int H, W;
char ch[MAX_N + 1];
void input(){
scanf("%d%d", &H, &W);
for(int i = 0; i < H; ++i){
scanf("%s", ch);
for(int j = 0; j < W; ++j){
color[i][j] = (ch[j] == '#');
}
}
}
bool isin_(int i, int j){
return i >= 0 && i < H && j >= 0 && j < W;
}
bool check_(int i, int j, int d){
int ni = i + di[d];
int nj = j + dj[d];
if(!isin_(ni, nj)) return false;
if(color[i][j] == color[ni][nj]) return false;
return true;
}
bool used[MAX_N][MAX_N];
long long solve(){
long long ans = 0;
long long b = 0, w = 0;
for(int i = 0; i < H; ++i){
for(int j = 0; j < W; ++j){
if(used[i][j]) continue;
b = 0;
w = 0;
queue<P> que;
used[i][j] = true;
que.push(P(i, j));
while(!que.empty()){
P p = que.front();
que.pop();
int ci = p.first, cj = p.second;
if(color[ci][cj]) b++;
else w++;
for(int d = 0; d < 4; ++d){
if(!check_(ci, cj, d)) continue;
int ni = ci + di[d], nj = cj + dj[d];
if(used[ni][nj]) continue;
used[ni][nj] = true;
que.push(P(ni, nj));
}
}
ans += b * w;
}
}
return ans;
}
int main(){
input();
long long ans = solve();
printf("%lld\n", ans);
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int main() {
int INFTY = 1000000000;
int n;
scanf("%d", &n);
int p[n + 1];
for (int i = 0; i < n; i++) {
scanf("%d %d", p + i, p + i + 1);
}
int m[n + 1][n + 1];
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
m[i][j] = 0;
}
}
for (int l = 2; l <= n; ++l) {
for (int i = 1; i <= n - l + 1; ++i) {
int j = i + l - 1;
m[i][j] = INFTY;
for (int k = i; k < j; ++k) {
m[i][j] = min(m[i][j], m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]);
}
}
}
cout << m[1][n] << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double H, W, N;
cin >> H >> W >> N;
if(H >= W) cout << ceil(N/H) << endl;
else cout << ceil(N/W) << endl;
} | #include <iostream>
#include <string>
namespace ABC169
{
class A
{
public:
A() = default;
~A() = default;
void Run()
{
int A = 0;
int B = 0;
std::cin >> A;
std::cin >> B;
std::cout << A*B << std::endl;
}
};
}
int main()
{
ABC169::A prob;
prob.Run();
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
//constructor: LCA(graph);
template<class T>
class LCA_weight {
private:
int n;
int D = 30; //hight
vector<int> depth; //depth from root
vector<vector<pair<int,T>>> hen; //tree
vector<vector<int>> par; //doubling array
vector<T> dista; //distance form root
void dfs(int v, int p, int dep, T dep_dist) {
par[v][0] = p;
depth[v] = dep;
dista[v] = dep_dist;
for(auto i : hen[v]) {
if(i.first == p)continue;
dfs(i.first, v, dep + 1, dep_dist + i.second);
}
}
public:
LCA_weight(const vector<vector<pair<int,T>>>& hen):hen(hen) {
n = hen.size();
par.resize(n, vector<int>(D + 1));
depth.resize(n);
dista.resize(n);
dfs(0, -1, 0, 0);
for(int i = 0; i < D; i++) {
for(int j = 0; j < n; j++) {
if(par[j][i] == -1)par[j][i + 1] = -1;
else par[j][i + 1] = par[par[j][i]][i];
}
}
}
//go back to root
int back(int v, int dist) {
for(int i = 0; i < D; i++)if((1 << i) & dist) {
if(v == -1)return v;
v = par[v][i];
}
return v;
}
//get LCA
int get(int u, int v) {
int ret = 0;
if(depth[u] > depth[v])swap(u, v);
ret = depth[v] - depth[u];
v = back(v, ret);
if(u == v)return v;
for(int i = D; i >= 0; i--) {
if(par[u][i] != par[v][i]) {
u = par[u][i];
v = par[v][i];
}
}
return par[u][0];
}
//u-v path distance
T dist(int u, int v) {
int lca = get(u, v);
return (dista[u] + dista[v]) - dista[lca] * 2;
}
//print parents
void print(int i) {
cerr << "[";
for(int j = 0; j < n; j++)cerr << par[j][i] << (j == n - 1 ? "" : ",");
cerr << "]";
}
};
int main()
{
int n; cin >> n;
vector<vector<pair<int,ll>>> hen(n);
for(int i = 0; i < n - 1; i++) {
int a, b, c; cin >> a >> b >> c;
a--, b--;
hen[a].emplace_back(b, c);
hen[b].emplace_back(a, c);
}
LCA_weight<ll> lca(hen);
int q, k; cin >> q >> k;
k--;
while(q--) {
int s, t; cin >> s >> t; s--, t--;
cout << lca.dist(s, k) + lca.dist(t, k) << endl;
}
} | #include <bits/stdc++.h>
// #include <atcoder/all>
#define ll long long int
#define ld long double
#define yorn(f) cout<<((f)?"Yes":"No")<<endl;
#define YORN(f) cout<<((f)?"YES":"NO")<<endl;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repi(i, n) for (ll i = 1; i < (ll)(n); i++)
#define all(x) (x).begin(), (x).end()
#define put(x) cout << x << endl;
#define println(x) cout << x << endl;
using namespace std;
// using namespace atcoder;
struct Edge {
ll to;
ll cost;
Edge(ll t, ll c) {
to = t;
cost = c;
}
};
typedef vector<vector<Edge>> Graph;
Graph G;
vector<int> seen;
vector<ll> d;
void dfs(ll node, ll value) {
seen[node] = 1;
d[node] = value;
for (Edge e: G[node]) {
if (seen[e.to] == 0) {
dfs(e.to, value + e.cost);
}
}
}
void Main()
{
ll n;
cin >> n;
vector<ll> a(n-1), b(n-1), c(n-1);
rep(i, n-1) cin >> a[i] >> b[i] >> c[i];
ll Q, K;
cin >> Q >> K;
vector<ll> x(Q), y(Q);
rep(i, Q) cin >> x[i] >> y[i];
G.assign(n, vector<Edge>());
seen.assign(n, 0);
d.assign(n, 0);
rep(i, n-1) {
G[b[i]-1].push_back(Edge{a[i]-1, c[i]});
G[a[i]-1].push_back(Edge{b[i]-1, c[i]});
}
dfs(K - 1, 0);
rep(i, Q) {
ll res = d[x[i] -1] + d[y[i] - 1];
put(res);
}
}
signed main(){ Main();return 0;} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define gc getchar_unlocked
#define fo(i, n) for (i = 0; i < n; i++)
#define Fo(i, k, n) for (i = k; k < n ? i < n : i > n; k < n ? i += 1 : i -= 1)
#define ll long long
#define si(x) scanf("%d", &x)
#define sl(x) scanf("%lld", &x)
#define ss(s) scanf("%s", s)
#define pi(x) printf("%d\n", x)
#define pl(x) printf("%lld\n", x)
#define ps(s) printf("%s\n", s)
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for (auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626
typedef pair<int, int> pii;
typedef pair<ll, ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<char> vc;
typedef vector<vc> vcc;
typedef vector<pii> vpii;
typedef vector<pl> vpl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
mt19937_64 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
int rng(int lim)
{
uniform_int_distribution<int> uid(0, lim - 1);
return uid(rang);
}
int mpow(int base, int exp);
void ipgraph(int n, int m);
void dfs(int u, int par);
const int mod = 1'000'000'007;
const int N = 3e5, M = N;
//=======================
vi g[N];
int a[N];
void solve()
{
ll i, j, n, m;
cin >> n >> m;
vi a(10);
fo(i, m)
{
cin >> j;
a[j] = 1;
}
for (i = n; i <= 100000; i++)
{
string s = to_string(i);
bool k = true;
fo(j, s.size())
{
if (a[s[j] - '0'])
{
k = false;
break;
}
else
{
continue;
}
}
if (k)
{
cout << i << endl;
return;
}
else
{
continue;
}
}
}
int main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
int t = 1;
//cin >> t;
while (t--)
{
solve();
}
return 0;
}
int mpow(int base, int exp)
{
base %= mod;
int result = 1;
while (exp > 0)
{
if (exp & 1)
result = ((ll)result * base) % mod;
base = ((ll)base * base) % mod;
exp >>= 1;
}
return result;
}
void ipgraph(int n, int m)
{
int i, u, v;
while (m--)
{
cin >> u >> v;
u--, v--;
g[u].pb(v);
g[v].pb(u);
}
}
void dfs(int u, int par)
{
for (int v : g[u])
{
if (v == par)
continue;
dfs(v, u);
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> Pl;
const int INT_INF = 2147483646;
const ll LL_INF = 9223372036854775807;
const double PI=3.1415926535897932;
bool SecondCompare(const pair<int,int> &a,const pair<int,int> &b)
{
return a.second<b.second;
}
bool SecondCompareDes(const pair<int,int> &a,const pair<int,int> &b)
{
return a.second>b.second;
}
ll minll(ll a, ll b){
if(a >= b) return b;
else return a;
}
ll maxll(ll a, ll b){
if(a >= b) return a;
else return b;
}
ll n,k;
int main(){
cin >> n >> k;
if(n%k == 0) cout << "0\n";
else
{
cout << "1\n";
}
} | 0 |
#include <bits/stdc++.h>
#define rep(i, f, n) for (ll i = (f); i < (ll)(n); i++)
#define repe(i, f, n) for (ll i = (f); i <= (ll)(n); i++)
using namespace std;
using ll = long long;
using pint = pair<int, int>;
int main() {
int N;
cin >> N;
for (int i = N; i > 0; i--) {
double a = sqrt(i);
if (ceil(a) == floor(a)) {
cout << i << endl;
return 0;
}
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
///Welcome to Nasif's Code
#define bug printf("bug\n");
#define bug2(var) cout<<#var<<" "<<var<<endl;
#define co(q) cout<<q<<endl;
#define all(q) (q).begin(),(q).end()
typedef long long int ll;
typedef unsigned long long int ull;
const int MOD = (int)1e9+7;
const int MAX = 1e6;
#define pi acos(-1)
#define inf 1000000000000000LL
#define FastRead ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int main()
{
FastRead
//freopen("output.txt", "w", stdout);
ll n,m;
cin>>n;
m=sqrt(n);
cout<<m*m<<endl;
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int main(){
int a,b;
cin >> a >> b;
if(a>8)cout << ":(";
else if(b>8)cout << ":(";
else cout << "Yay!";
}
| #include <bits/stdc++.h>
using namespace std;
#define ALL(v) v.begin(), v.end()
#define V vector
#define P pair
using ll = long long;
using ld = long double;
const int MOD = 1e9+7;
int main() {
int a, b; cin >> a >> b;
cout << max({a+b, a*b, a-b}) << endl;
return 0;
}
| 0 |
#include <iostream>
using namespace std;
#include <algorithm>
int main() {
int n;
while (1) {
cin >> n;
if (n==0) break;
int p1=0, p2=0;
int c1, c2;
for (int i=0; i<n; i++) {
cin >> c1 >> c2;
if (c1==c2) p1+=c1, p2+=c2;
if (c1>c2) p1+=c1+c2;
if (c1<c2) p2+=c1+c2;
}
cout << p1 << " " << p2 << endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int n;
string str;
cin >> n;
for(int i=0;i<n;i++){
int out = 0;
int a[4] = {};
while(out != 3){
cin >> str;
if(str == "OUT") out++;
else if(str == "HOMERUN"){
a[3] += a[0]+a[1]+a[2]+1;
a[0] = a[1] = a[2] = 0;
}
else if(str == "HIT"){
a[3] += a[2];
a[2] = 0;
a[2] = a[1];
a[1] = 0;
a[1] = a[0];
a[0] = 1;
}
}
cout << a[3] << endl;
}
return (0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define int long long
#define ar array<int,2>
#define inf 1000000000000000000
int mod=1e9+7;
int min(int a,int b){return (a<b)?a:b;}
int max(int a,int b){return (a>b)?a:b;}
int fp(int a,int b){if(b==0) return 1;int x=fp(a,b/2);x=(x*x)%mod;if(b&1) x=(x*a)%mod;return x;}
const int N=1e4+5;
int d;
string s,tmp;
int sz;
int dp[N][2][101];
int pw[N];
void solve(int pos,int lm)
{
if(dp[pos][lm][0]!=-1)
return;
if(pos==s.size())
{
// cout<<tmp<<endl;
for(int i=0;i<d;i++)
dp[pos][lm][i]=0;
dp[pos][lm][0]=1;
return;
}
for(int i=0;i<d;i++)
dp[pos][lm][i]=0;
int l=0;
int r=9;
if(lm)
r=s[pos]-'0';
for(int i=l;i<=r;i++)
{
// tmp.push_back(i+'0');
int nlm=0;
if(lm&&i==r)
nlm=1;
solve(pos+1,nlm);
for(int j=0;j<d;j++)
{
int x=(i+j)%d;
dp[pos][lm][x]+=dp[pos+1][nlm][j];
if(dp[pos][lm][x]>=mod)
dp[pos][lm][x]-=mod;
}
}
}
signed main() {
ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
memset(dp,-1,sizeof(dp));
int n;
cin>>s>>d;
sz=s.size();
pw[0]=1;
for(int i=1;i<=sz;i++)
pw[i]=(pw[i-1]*10)%d;
solve(0,1);
int ans=(dp[0][1][0]-1+mod)%mod;
cout<<ans<<endl;
} | #include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<(n); i++)
#define rep2(i,x,n) for(int i=x; i<(n); i++)
#define ALL(c) (c).begin(), (c).end()
#define pb push_back
#define eb emplace_back
using namespace std;
const long long INF = 1LL<<60; // 仮想的な無限大の値;
using ll = long long;
using P = pair<int, int>;
#define vi vector<int>
#define vll vector<ll>
#define vs vector<string>
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main()
{
int N;
string S;
cin >> N >> S;
ll cnt[3] {0, 0,0};
rep(i, N){
if(S[i] == 'R') {cnt[0]++;}
if(S[i] == 'G') {cnt[1]++;}
if(S[i] == 'B') {cnt[2]++;}
}
ll tot = cnt[0]*cnt[1]*cnt[2];
rep(i, N)rep2(j, i+1, N){
int k = j+j-i;
if(k < N)
{
if(S[i] == S[j]) continue;
if(S[k] == S[j]) continue;
if(S[i] == S[k]) continue;
--tot;
}
}
cout << tot << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
vector<int>adj[100003],leaf;
int par[100003],depth[100005],sparse[100005][20],root=0,lz=0;
int lca(int p,int q)
{
int a,b,c,d,lp,i,j;
if(depth[p]<depth[q])
{
c=p; p=q; q=c;
}
for(j=19;j>=0;j--)
{
if((depth[p]-(1 << j))>=depth[q])
{
p=sparse[p][j]; if(depth[p]==depth[q])break;
}
}
if(p==q){ return p; }
else
{
for(j=19;j>=0;j--)
{
if(sparse[p][j]!=0 && sparse[p][j]!=sparse[q][j])
{
p=sparse[p][j]; q=sparse[q][j];
if(par[p]==par[q])break;
}
}
return par[p];
}
}
void dfs(int src)
{
int sz=adj[src].size();
if(sz==1 && src!=root){ leaf.push_back(src); lz++; }
for(int lp=0;lp<sz;lp++)
{
int u=adj[src][lp];
if(u!=root && par[u]==0)
{
par[u]=src; sparse[u][0]=src; depth[u]=depth[src]+1;
dfs(u);
}
}
}
int main()
{
int n,m,a,b,i,j,u,v,ans,z,x,y,fr,sc,tr,w;
scanf("%d %d %d",&n,&u,&v);
for(i=1;i<=n-1;i++)
{
scanf("%d %d",&a,&b);
adj[a].push_back(b); if(root==0){ if(adj[a].size()==2)root=a; }
adj[b].push_back(a); if(root==0){ if(adj[b].size()==2)root=b; }
}
if(n==2)printf("0\n");
else
{
dfs(root);
for(j=1;j<=19;j++)
{
for(i=1;i<=n;i++)
{
if(sparse[i][j-1]!=0)
{
sparse[i][j]=sparse[sparse[i][j-1]][j-1];
}
}
}
m=lca(u,v);
ans=(depth[v]-depth[m])+(depth[u]-depth[m]); ans=ans-1;
for(i=0;i<lz;i++)
{
y=leaf[i]; m=lca(u,y); w=lca(v,y);
fr=(depth[u]-depth[m])+(depth[y]-depth[m]);
sc=(depth[v]-depth[w])+(depth[y]-depth[w]);
if(fr<sc)
{
if(sc-1>ans)ans=sc-1;
}
}
printf("%d\n",ans);
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
using ll = long long;
using P = pair<int,int>;
using T = tuple<int,int,int>;
int main(){
int h, w;
cin >> h >> w;
map<int,int> ns; //（現在地、スタート地点の最大値）
multiset<int> dist; //現在地ースタート地点の最大値
rep(i,w) ns[i] = i; //キーiにiを代入
rep(i,w) dist.insert(0); //はじめは距離0
rep(i,h){
int a, b;
cin >> a >> b;
--a; --b;
auto it = ns.lower_bound(a);
int ms = -1; //最も右にある開始点を保持
while(1){
//壁を1だけ超えるスタート地点を取得（b+1）
if(it == ns.end() || it -> first > b+1) break;
ms = max(ms, it -> second);
dist.erase(dist.find(it->first - it->second));
ns.erase(it++);
}
//要素が見つからない、wを超えてしまう時を除く。
if(ms != -1 && b+1 != w){
dist.insert(b+1 - ms);
ns[b+1] = ms;
}
int ans = -1;
if(dist.size() > 0){
ans = *dist.begin();
ans += i+1;
}
cout << ans << endl;
}
return 0;
} | 0 |
#include <vector>
#include <algorithm>
#include <iostream>
#include <climits>
using namespace std;
typedef long long int int64;
vector<int64> P,Q;
int64 N,M,T;
int main(void)
{
while(true)
{
N = 0;
M = 0;
P.clear();
Q.clear();
P.shrink_to_fit();
Q.shrink_to_fit();
cin >> N >> M;
if(N == 0 && M == 0)
{
exit(0);
}
for(int i = 0;i < N;i++)
{
cin >> T;
P.push_back(T);
}
P.push_back(0);
for(auto itr = P.begin();itr < P.end();itr++)
{
for(auto itr2 = P.begin();itr2 < P.end();itr2++)
{
Q.push_back(*itr + *itr2);
}
}
Q.push_back(LLONG_MAX / 2);
Q.push_back(LLONG_MIN / 2);
sort(Q.begin(),Q.end());
int64 ms = 0;
for(auto itr = Q.begin();itr < Q.end()+1;itr++)
{
ms = max(ms,*itr + *(lower_bound(Q.begin(),Q.end() - 1,M-*itr+1) - 1));
}
cout << ms << endl;
}
} | #include <iostream>
#include <vector>
#include <string>
using namespace std;
char Decryption(int k, char s) {
char station[] = {'a','b','c','d','e','f','g','h','i','j','k','l','m',
'n','o','p','q','r','s','t','u','v','w','x','y','z',
'A','B','C','D','E','F','G','H','I','J','K','L','M',
'N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
int num;
for(int i = 0; i < 52; i++) {
if(s >= 'a' && s <= 'z')
num = s - 'a';
else
num = s - 39;
}
return station[(52 + num - k) % 52];
}
int main() {
vector<int> K;
int n;
string s_in;
string s_out;
while(1) {
cin >> n;
if(n == 0)
break;
for(int i = 0; i < n; i++) {
int k;
cin >> k;
K.push_back(k);
}
cin >> s_in;
for(int i = 0; i < s_in.size(); i++) {
s_out += Decryption(K[i%n], s_in[i]);
}
cout << s_out << endl;
s_out.erase();
K.clear();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,Y;
cin >> N >> Y;
int ansi=-1, ansj=-1, ansk=-1;
for(int i=0; i<=N; i++){
for(int j=0; j<=N-i; j++){
int k = N-i-j;
int total = i*10000 + j*5000 + k*1000;
if(total == Y){
ansi = i;
ansj = j;
ansk = k;
}
}
}
cout << ansi << " " << ansj << " " << ansk << endl;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int64_t N, M;
cin >> N >> M;
int64_t res = 1;
for (int64_t m = 1; m <= sqrt(M); ++m) {
if (M % m) continue;
int64_t m2 = M / m;
if (m >= N) res = max(res, m2);
if (m2 >= N) res = max(res, m);
}
cout << res << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long i,j,k,l,m,n,o,p,q;
while(cin>>m>>n>>o>>p)
{
if(m+n>o+p)
cout<<"Left"<<endl;
else if(m+n<o+p)
cout<<"Right"<<endl;
else
cout<<"Balanced"<<endl;
}
return 0;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define FASTIO ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define endl '\n'
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
using ll = long long;
using P = pair<ll, ll>;
/*追加部分*/
/*main関数*/
int main() {
FASTIO;
int a, b, c, d; cin >> a >> b >> c >> d;
cout << ((a + b) > (c + d) ? "Left" : (a + b) == (c + d) ? "Balanced" : "Right") << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define all(x) x.begin(),x.end()
#define dbg(x) cout<<#x<<":"<<x<<endl
typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<ll,P> PP;
vector<int> g[111111];
int p[111111];
ll ans;
ll n,k;
int dfs(int n){
int ma=0;
for(int i=0;i<g[n].size();i++){
ma=max(ma,dfs(g[n][i]));
}
if(n==0)return 0;
if(ma==k-1&&p[n]!=0){
ans++;
return 0;
}
return ma+1;
}
int main(){
cin>>n>>k;
for(int i=0;i<n;i++){
cin>>p[i];
p[i]--;
if(i==0&&p[i]!=0){
ans++;
p[i]=0;
}
if(i){
g[p[i]].pb(i);
}
}
dfs(0);
cout<<ans<<endl;
return 0;
}
| #include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <cmath>
#include <map>
#include <vector>
#include <set>
#include <queue>
#include <stack>
using namespace std;
typedef long long ll;
int n,m;
ll x,sum,ans;
map<ll,int>mmp;
int main()
{
scanf("%d%d",&n,&m);
sum=0;
ans=0;
for(int i=0;i<n;i++)
{
scanf("%lld",&x);
sum+=x;
ans+=mmp[sum%m];
if(sum%m==0) ans++;
mmp[sum%m]++;
}
printf("%lld\n",ans);
return 0;
} | 0 |
#include<iostream>
#include<stdio.h>
#include<string.h>
#include<ctype.h>
#include<cmath>
#include<iomanip>
using namespace std;
int main(void){
int N,A[1000],c,hokan,flag,j,i,kaisuu;
cin>>N;
for(c=0;c<N;c++){
cin>>A[c];
}
flag=1;
i=0;
kaisuu=0;
while(flag){
flag=0;
for(j=N-1;i<j;j--){
if(A[j]<A[j-1]){
hokan=A[j];
A[j]=A[j-1];
A[j-1]=hokan;
flag=1;
kaisuu++;
}
}i++;
} for(c=0;c<N;c++){
cout<<A[c];
if(c!=N-1){
cout<<" ";
}else{
cout<<endl;
}
}cout<<kaisuu<<endl;
return 0;
}
| #include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <complex>
#include <string>
#include <sstream>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <stack>
#include <functional>
#include <iostream>
#include <map>
#include <set>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-9
#define INF 2000000000
#define sz(x) ((int)(x).size())
#define fi first
#define sec second
#define SORT(x) sort((x).begin(),(x).end())
#define all(x) (x).begin(),(x).end()
#define EQ(a,b) (abs((a)-(b))<eps)
const int MAX=100000;
const int geta=100;
struct BIT
{
int bit[MAX+1];
void add(int i,int x)
{
while(i<=MAX)
{
bit[i]+=x;
i+=i&-i;
}
}
int sum(int i)
{
int res=0;
while(i>0)
{
res+=bit[i];
i-=i&-i;
}
return res;
}
};
BIT bit;
int N,a[105];
int main()
{
scanf("%d",&N);
for(int i=0;i<N;i++)
{
scanf("%d",&a[i]);
a[i]+=geta;
}
int ans=0;
for(int i=0;i<N;i++)
{
ans+=bit.sum(a[i]);
bit.add(a[i],1);
}
sort(a,a+N);
for(int i=0;i<N;i++)printf("%d%c",a[i]-geta,(i==N-1)?'\n':' ');
printf("%d\n",N*(N-1)/2-ans);
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N, L;
cin >> N >> L;
int eated_apple = 10000000;
int sum_taste = 0;
for(int i=1; i<=N; i++){
sum_taste += L+i-1;
if(abs(eated_apple)>abs(L+i-1)) eated_apple = L+i-1;
}
cout << sum_taste-eated_apple << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
///////////////////////////////////////////
const long long int INF = 1LL<<60;
const long long int Mod = 1000000007;
const long long int sMod = 998244353;
using ll = long long int; using ci = const int;
using vi = vector<int>; using Vi = vector<long long int>;
using P = pair<int, int>; using PLL = pair<ll, ll>;
using matrix = vector<vector<ll>>;
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define fi first
#define se second
#define all(x) (x).begin(),(x).end()
#define rp(i,N) for(ll i = 0; i < (ll)N; i++)
#define repi(i,a,b) for(ll i = ll(a); i < ll(b); ++i)
template<class T>bool chmax(T &former, const T &b) { if (former<b) { former=b; return true; } return false; }
template<class T>bool chmin(T &former, const T &b) { if (b<former) { former=b; return true; } return false; }
template<class T>T sqar(T x){ return x*x; }//sqrt(x)は平方根;
#define Sort(v) std::sort(v.begin(), v.end(), std::greater<decltype(v[0])>()) //降順でVをソート
#define p_queue(v) priority_queue<v, vector<v>, greater<v> >
template<class T> inline void princ(T x){cout<<x<<" ";};
template<class T> inline void print(T x){cout<<x<<"\n";};
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
template<class T> inline void YES(T condition){ if(condition) cout << "YES" << endl; else cout << "NO" << endl; }
///////////////////////////////////////////////////////////////////////////////////
void solve(){
ll n;
ll l;
cin >> n >> l;
if(l>=0) print((l+l+n-1)*n/2-l);
else if(l+n-1>=0) print((l+l+n-1)*n/2);
else print((l+l+n-1)*n/2-(l+n-1));
return;
}
int main(){
cin.tie(0);ios::sync_with_stdio(false);
std::cout<<std::fixed<<std::setprecision(30);
solve();
return 0;
} | 1 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,t,f,ans;
double a[200001];
map<pair<int,int>,int> m;
signed main()
{
scanf("%lld",&n);
for(int i=1;i<=n;i++)
{
scanf("%lf",&a[i]);
int b=round(a[i]*1000000000);
t=f=-9;
while(b%2==0)
{
b/=2;
t++;
}
while(b%5==0)
{
b/=5;
f++;
}
m[make_pair(t,f)]++;
}
for(auto i:m)
for(auto l:m)
if(i.first.first+l.first.first>=0&&i.first.second+l.first.second>=0)
{
if(i==l)
ans+=i.second*(i.second-1)/2;
if(i<l)
ans+=i.second*l.second;
}
cout<<ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int cnt[80][50];
int cnt2[200100], cnt5[200100];
char str[50];
long long inp()
{
memset(str, 0, sizeof(str));
scanf("%s", str);
long long ret = 0;
int point = 0;
int pointflag = 0;
for(int i = 0; str[i] ; ++i)
{
if(pointflag)
{
point++;
}
if(str[i] == '.'){
pointflag = 1;
}else{
ret = ret*10+str[i]-'0';
}
}
while(point < 9) ret *= 10, point++;
return ret;
}
int main()
{
#ifdef CitricAcid
freopen ("input.txt", "rt", stdin);
#endif
int n;
scanf("%d", &n);
for(int i = 1; i <= n; ++i)
{
long long xint = inp();
while(xint%2 == 0) cnt2[i]++, xint /= 2;
while(xint%5 == 0) cnt5[i]++, xint /= 5;
cnt[cnt2[i]][cnt5[i]]++;
}
for(int i = 64; i >= 0; --i)
for(int j = 25; j >= 0; --j)
cnt[i][j] = cnt[i][j] + cnt[i+1][j] + cnt[i][j+1] - cnt[i+1][j+1];
long long ans = 0;
for(int i = 1; i <= n; ++i)
{
int tmp2 = max(0, 18-cnt2[i]);
int tmp5 = max(0, 18-cnt5[i]);
ans += cnt[tmp2][tmp5];
if(cnt2[i] >= tmp2 && cnt5[i] >= tmp5) ans--;
}
printf("%lld\n", ans/2);
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) repi(i,0,n)
#define repi(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define pb push_back
int main(){
int x,y,z;
while(1){
cin>>x>>y>>z;
if(x==0&&y==0&&z==0)break;
int a[114514];
int b[114514];
rep(i,x){
cin>>a[i];
}
rep(i,z-y+1){
b[i]=a[i+y-1]-a[i+y];
}
rep(i,z-y+1){
// cout<<i<<" "<<b[i]<<endl;
}
int count=0;
int tmp=0;
int ans=0;
for(int i=0;i<z-y+1;i++){
if(tmp<=b[i]){
tmp=b[i];
ans=i+y;
}
}
cout<<ans<<endl;
// repi(i,y-1,z){
// // cout<<a[i]<<endl;
// // cout<<a[i+1]<<endl;
// if(tmp<=a[i]-a[i+1]){
// tmp=max(tmp,a[i]-a[i+1]);
// ans=i-1+y;
// }
// // cout<<"tmp:"<<tmp<<endl;
// // cout<<"ans:"<<ans<<endl;
// count++;
// }
// // cout<<count<<endl;
// // cout<<"tmp:"<<tmp<<endl;
// // cout<<"ans:"<<ans<<endl;
// if(y==1){
// cout<<ans+1<<endl;
// }else{
// cout<<ans<<endl;
// }
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> VI;
typedef vector<VI> VVI;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const int INF = numeric_limits<int>::max() / 2;
const int NEG_INF = numeric_limits<int>::min() / 2;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int e;
while(cin >>e,e){
int ans=1000000;
for(int y=0;y*y<=e;y++){
for(int z=0;z*z*z<=e-y*y;z++){
int x=e-z*z*z-y*y;
ans = min(ans,x+y+z);
}
}
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
#define endl '\n'
using namespace std;
template<class T, class T2> inline void chkmax(T &x, const T2 &y) { if(x < y) x = y; }
template<class T, class T2> inline void chkmin(T &x, const T2 &y) { if(x > y) x = y; }
const int MAXN = (int)3e5 + 17;
const int mod = (int)1e9 + 7;
const int OFFSET = 5;
int n, suff[MAXN];
string s;
void read()
{
cin >> s;
n = s.size();
}
int dp[MAXN][10][4];
int rec(int pos, int len, int bd)
{
if(bd > 2)
{
if(bd % 2 == 0) len += (bd - 2), bd = 2;
if(bd % 2 == 1) len += (bd - 1), bd = 1;
}
if(bd < 0) bd = 0;
if(len > 4) len = 4;
if(pos == n)
{
if(len > 0) return 1;
return 0;
}
int &memo = dp[pos][len + OFFSET][bd];
if(memo != -1) return memo;
memo = 0;
if(s[pos] == '1' || s[pos] == '?') memo = (memo + rec(pos + 1, len + 1, bd - 1)) % mod;
if(s[pos] == '0' || s[pos] == '?') memo = (memo + rec(pos + 1, len - 1, bd + 1)) % mod;
return memo;
}
void solve()
{
suff[n] = 1;
for(int i = n - 1; i >= 0; i--)
{
suff[i] = suff[i + 1];
if(s[i] == '?') suff[i] = (2ll * suff[i + 1]) % mod;
}
memset(dp, -1, sizeof(dp));
cout << rec(0, 0, 0) << endl;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
string s;
int dp[2][3][300004];
void sub(const string& s) {
dp[1][0][0] = 1;
for (int i = 1; i < s.size(); ++i) {
for (int c : {0, 1}) {
if (c == 1 && s[i] == '0'
|| c == 0 && s[i] == '1') continue;
for (int pc : {0, 1}) {
for (int k : {0, 1, 2}) {
int nk =
k == 2 ? 2
: k == 1 ? (i % 2 == 0 && c == 1 && pc == 1 ? 2 : 1)
: (i % 2 == 1 && c == 1 && pc == 1 ? 1 : 0);
dp[c][nk][i] += dp[pc][k][i - 1];
if (dp[c][nk][i] >= mod) dp[c][nk][i] -= mod;
}
}
}
}
}
int main() {
cin >> s;
s = '1' + s + '1';
sub(s);
const int n = s.size();
cout << dp[1][2][n - 1] << endl;
}
| 1 |
#include <bits/stdc++.h>
using i64 = long long;
int main() {
int n, m;
scanf("%d%d", &n, &m);
std::vector<std::tuple<int, int, int>> es;
std::vector<std::pair<int, int>> w;
for (int i = 0; i < m; i++) {
int p, q, c;
scanf("%d%d%d", &p, &q, &c);
--p; --q;
es.emplace_back(p, q, c);
w.emplace_back(p, c);
w.emplace_back(q, c);
}
std::sort(w.begin(), w.end());
w.erase(std::unique(w.begin(), w.end()), w.end());
auto get = [&](int v, int c) {
return n + std::lower_bound(w.begin(), w.end(), std::make_pair(v, c)) - w.begin();
};
std::vector<std::vector<std::pair<int, int>>> g(w.size() + n);
for (const auto &e : w) {
int v = get(e.first, e.second);
g[e.first].emplace_back(v, 1);
g[v].emplace_back(e.first, 0);
}
for (const auto &e : es) {
auto p = std::get<0>(e), q = std::get<1>(e), c = std::get<2>(e);
int pv = get(p, c), qv = get(q, c);
g[pv].emplace_back(qv, 0);
g[qv].emplace_back(pv, 0);
}
constexpr int inf = std::numeric_limits<int>::max() / 2;
std::vector<int> dist(g.size(), inf);
std::deque<int> q { 0 };
dist[0] = 0;
while (!q.empty()) {
int v = q.front();
q.pop_front();
for (auto to : g[v]) {
if (dist[to.first] <= dist[v] + to.second) continue;
dist[to.first] = dist[v] + to.second;
if (to.second) q.push_back(to.first);
else q.push_front(to.first);
}
}
printf("%d\n", dist[n - 1] == inf ? -1 : dist[n - 1]);
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define f1(a,b,c) for(int c=a;c<=b;c++)
#define f2(a,b,c) for(int c=a;c>=b;c--)
#define f3(a,b,c) for(int c=a;c;c=b)
#define so1(a,n) sort(a+1,a+n+1,mycmp);
#define so2(a,n) sort(a+1,a+n+1);
#define ll long long
#define itn int
#define ubt int
#define pii pair<int,int>
#define mp make_pair
const int twx=1e6+100;
const int inf=0x7fffffff;
ll read()
{
ll sum=0;
ll flag=1;
char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-')
{
flag=-1;
}
c=getchar();
}
while(c>='0'&&c<='9')
{
sum=((sum*10)+c-'0');
c=getchar();
}
return sum*flag;
}
int n,m;
struct LV
{
int Next;
int y;
int v;
}a[twx<<1];
int Link[twx];
int len;
map<pii,int> p;
int cnt=0;
bool v[twx];
int d[twx];
void Insert(int x,int y,int z)
{
a[++len].y=y;
a[len].Next=Link[x];
a[len].v=z;
Link[x]=len;
}
int get(int x,int y)
{
if(p.find(mp(x,y))!=p.end())
{
return p[mp(x,y)];
}
else
{
return p[mp(x,y)]=++cnt;
}
}
void spfa()
{
memset(d,0x3f,sizeof d);
queue<int> q;
q.push(1);
v[1]=1;
d[1]=0;
while(!q.empty())
{
int x=q.front();
q.pop();
f3(Link[x],a[i].Next,i)
{
int y=a[i].y;
int vs=a[i].v;
if(d[y]>d[x]+vs)
{
d[y]=d[x]+vs;
if(!v[y])
{
v[y]=1;
q.push(y);
}
}
}
v[x]=0;
}
}
void init()
{
n=read();
m=read();
cnt=n;
f1(1,m,i)
{
int x=read();
int y=read();
int z=read();
int xz=get(x,z);
int yz=get(y,z);
Insert(xz,yz,0);
Insert(yz,xz,0);
Insert(x,xz,1);
Insert(xz,x,1);
Insert(y,yz,1);
Insert(yz,y,1);
}
spfa();
printf("%d\n",d[n]==0x3f3f3f3f?-1:d[n]/2);
}
void work()
{
}
void print()
{
}
int main()
{
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
init();
return 0;
}
| 1 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cstring>
#include <cctype>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <stdio.h>
#include <string.h>
#include <cstdlib>
#include <math.h>
#define INF 2000000000
using namespace std;
int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
#define ll long long
#define PL pair<long long, long long>
#define P pair<int,int>
#define mk make_pair
#define en endl;
#define WHITE 0
#define BLACK 2
#define GRAY 1
#define RE return 0;
#define MAX 505
int n,m;
int main(){
while(1){
cin>>n>>m;
vector<int> G[MAX];
int num[n+5];
int used[n+5];
int ans=0;
if(n==0&&m==0) break;
for(int i=0; i<n+5; i++) for(int j=0; j<n+5; j++) {num[i]=INF; used[i]=0;}
for(int i=0; i<m; i++){
int a,b;
cin>>a>>b;
G[a].push_back(b);
G[b].push_back(a);
}
queue<int> que;
que.push(1);
num[1]=0;
used[1]=true;
while(!que.empty()){
int v=que.front(); que.pop();
for(int i=0; i<G[v].size(); i++){
int e=G[v][i];
if(used[e]) continue;
num[e]=num[v]+1;
used[e]=true;
que.push(e);
}
}
for(int i=1; i<=n; i++){
if(num[i]<=2) {
ans++;
}
}
cout<<ans-1<<en
}
}
| #include <iostream>
#include <fstream>
using namespace std;
int main() {
//ifstream cin("INPUT.txt");
//ofstream cout("OUTPUT.txt");
int n, m, sum, i;
int a, b;
while(cin >> n >> m, n != 0 && m != 0) {
int friends[500] = {0}; //1=友達 2=友達の友達
int m1[10000] = {0};
int m2[10000] = {0};
for(i = 0; i < m; i++) {
cin >> m1[i] >> m2[i];
}
for(i = 0; i < m; i++) {
a = m1[i];
b = m2[i];
if(friends[a-1] == 1 && friends[b-1] == 1) {
} else if(a == 1) {
friends[b-1] = 1;
} else if(b == 1) {
friends[a-1] = 1;
} else if(friends[a-1] == 1) {
friends[b-1] = 2;
} else if(friends[b-1] == 1) {
friends[a-1] = 2;
}
}
for(i = 0; i < m; i++) {
a = m1[i];
b = m2[i];
if(friends[a-1] == 1 && friends[b-1] == 1) {
} else if(a == 1) {
friends[b-1] = 1;
} else if(b == 1) {
friends[a-1] = 1;
} else if(friends[a-1] == 1) {
friends[b-1] = 2;
} else if(friends[b-1] == 1) {
friends[a-1] = 2;
}
}
sum = 0;
for(i = 0; i < n; i++) {
if(friends[i] > 0)
sum++;
}
cout << sum << endl;
}
return 0;
} | 1 |
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pp pair<int,int>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define ld long double
#define al(a) (a).begin(),(a).end()
#define mk make_pair
#define check cout<<"?"<<endl;
ll MOD=1000000007;
ll mod=998244353;
int inf=1000001000;
ll INF=1e18+5;
int main(){
string s; cin>>s;
vector<int> v(26,0);
for(auto ch:s) v[ch-'a']=1;
rep(i,26){
if(v[i]==0){
cout<<(char)('a'+i)<<endl;
return 0;
}
}
cout<<"None"<<endl;
}
| #include <iostream>
#include <vector>
template<typename T>
void Dump(const std::vector<T>& xs)
{
for (int i = 0; i < xs.size()-1; ++i)
{
std::cout << xs[i] << ' ';
}
std::cout << xs.back() << std::endl;
}
template<typename T>
int BubbleSort(std::vector<T>* src)
{
std::vector<T>& xs = *src;
bool change {true};
int count = {0};
while (change) {
change = false;
for (int i = xs.size()-1; i > 0; --i)
{
if (xs[i] < xs[i-1]) {
T buf = xs[i];
xs[i] = xs[i-1];
xs[i-1] = buf;
change = true;
++count;
}
}
}
return count;
}
int main()
{
int n {};
std::vector<int> xs {};
std::cin >> n;
xs.resize(n);
for (int i = 0; i < n; ++i)
{
std::cin >> xs[i];
}
int cnt{BubbleSort(&xs)};
Dump(xs);
std::cout << cnt << std::endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
int k;
cin>>n>>k;
if(n%k==0){
cout<<0<<endl;
}
else{
cout<<1<<endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MOD (int)1e9+7
#define rep(i,a,b) for(int i=a;i<b;++i)
#define rrep(i,a,b) for(int i=a;i>b;--i)
#define vi vector<int>
#define vl vector<ll>
#define ld long double
#define vvi vector<vector<int>>
#define vvl vector<vector<long long>>
#define pii pair<int,int>
#define pll pair<long,long>
#define vpii vector<pii>
#define vpll vector<pll>
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define PI 3.1415926535897932384626433832795
#define fix(f,n) fixed<<setprecision(n)<<f
#define all(x) x.begin(),x.end()
ll powM(ll a,ll b,ll m )
{
a%=m;
ll ans=1;
while(b>0)
{
if(b&1)ans=ans*a%m;
a=a*a%m;
b>>=1;
}
return ans;
}
ll c(ll a,ll b)
{
if(a==0)return b==0?1:0;
if(b>a)return 0;
ll val=1;
ll fac=1;
for(int i=1;i<=b;i++)fac*=i;
for(int i=a;i>=a-b+1;i--)val*=i;
return val/fac;
}
ll f(ll n)
{
ll ans=1LL;
while(ans<=n)ans<<=1;
return ans;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n,k;
cin>>n>>k;
ll ans=0;
if(n%k)ans=1;
cout<<ans<<"\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(long long i=0;i<(long long)(n);i++)
#define REP(i,k,n) for(long long i=k;i<(long long)(n);i++)
#define all(a) a.begin(),a.end()
#define pb emplace_back
#define eb emplace_back
#define lb(v,k) (lower_bound(all(v),k)-v.begin())
#define ub(v,k) (upper_bound(all(v),k)-v.begin())
#define fi first
#define se second
#define pi M_PI
#define PQ(T) priority_queue<T>
#define SPQ(T) priority_queue<T,vector<T>,greater<T>>
#define dame(a) {out(a);return 0;}
#define decimal cout<<fixed<<setprecision(15);
#define dupli(a) a.erase(unique(all(a)),a.end())
typedef long long ll;
typedef pair<ll,ll> P;
typedef tuple<ll,ll,ll> PP;
typedef tuple<ll,ll,ll,ll> PPP;
typedef multiset<ll> S;
using vi=vector<ll>;
using vvi=vector<vi>;
using vvvi=vector<vvi>;
using vvvvi=vector<vvvi>;
using vp=vector<P>;
using vvp=vector<vp>;
using vb=vector<bool>;
using vvb=vector<vb>;
const ll inf=1001001001001001001;
const ll INF=1001001001;
const ll mod=1000000007;
const double eps=1e-10;
template<class T> bool chmin(T&a,T b){if(a>b){a=b;return true;}return false;}
template<class T> bool chmax(T&a,T b){if(a<b){a=b;return true;}return false;}
template<class T> void out(T a){cout<<a<<'\n';}
template<class T> void outp(T a){cout<<'('<<a.fi<<','<<a.se<<')'<<'\n';}
template<class T> void outvp(T v){rep(i,v.size())cout<<'('<<v[i].fi<<','<<v[i].se<<')';cout<<'\n';}
template<class T> void outvvp(T v){rep(i,v.size())outvp(v[i]);}
template<class T> void outv(T v){rep(i,v.size()){if(i)cout<<' ';cout<<v[i];}cout<<'\n';}
template<class T> void outvv(T v){rep(i,v.size())outv(v[i]);}
template<class T> bool isin(T x,T l,T r){return (l)<=(x)&&(x)<=(r);}
template<class T> void yesno(T b){if(b)out("yes");else out("no");}
template<class T> void YesNo(T b){if(b)out("Yes");else out("No");}
template<class T> void YESNO(T b){if(b)out("YES");else out("NO");}
template<class T> void noyes(T b){if(b)out("no");else out("yes");}
template<class T> void NoYes(T b){if(b)out("No");else out("Yes");}
template<class T> void NOYES(T b){if(b)out("NO");else out("YES");}
void outs(ll a,ll b){if(a>=inf-100)out(b);else out(a);}
ll gcd(ll a,ll b){if(b==0)return a;return gcd(b,a%b);}
ll modpow(ll a,ll b){a%=mod;if(b==0)return 1;if(b&1)return a*modpow(a,b-1)%mod;ll k=modpow(a,b/2);return k*k%mod;}
vp seg;
ll N=1;
void init(vi v){
while(N<v.size())N*=2;
seg=vp(N*2-1,P(-inf,-1));
rep(i,v.size())seg[i+N-1]=P(v[i],i);
for(int i=N-2;i>=0;i--)seg[i]=max(seg[i*2+1],seg[i*2+2]);
}
void add(ll i,ll x){
i=N+i-1;
seg[i].first+=x;
while(i>0){
i=(i-1)/2;
seg[i]=max(seg[i*2+1],seg[i*2+2]);
}
}
P getma(ll a,ll b,ll k,ll l,ll r){
if(r<=a||b<=l)return P(-inf,-1);
if(a<=l&&r<=b)return seg[k];
P c1=getma(a,b,k*2+1,l,(l+r)/2);
P c2=getma(a,b,k*2+2,(l+r)/2,r);
return max(c1,c2);
}
int main(){
ll n;cin>>n;
vi a(n),b(n);
rep(i,n)cin>>a[i]>>b[i];
vp v(n);
rep(i,n)v[i]=P(a[i]+b[i],i);
sort(all(v));
vi dp(n+1,inf);
dp[0]=0;
rep(i,n){
for(int j=i;j>=0;j--){
if(dp[j]<=a[v[i].se])chmin(dp[j+1],dp[j]+b[v[i].se]);
}
}
for(int i=n;i>=0;i--)if(dp[i]!=inf)dame(i);
} | #include <bits/stdc++.h>
using namespace std;
const long long inf = (long long) 1e18;
const int N = 5010;
long long f[N][N];
bool cmp(pair<int,int> a,pair<int,int> b){
return a.first < b.first;
}
int main() {
int n;
scanf("%d", &n);
vector< pair<int,int> > a(n);
for (int i = 0; i < n; i++) {
scanf("%d %d", &a[i].first, &a[i].second);
a[i].first += a[i].second;
}
sort(a.begin(), a.end(),cmp);
for (int i = 0; i < n; i++) {
a[i].first -= a[i].second;
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= i; j++) {
f[i][j] = inf;
}
}
f[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
long long ft = f[i][j];
if (ft == inf) {
continue;
}
f[i + 1][j] = min(f[i + 1][j], ft);
if (ft <= a[i].first) {
f[i + 1][j + 1] = min(f[i + 1][j + 1], ft + a[i].second);
}
}
}
int ans = 0;
for (int j = 0; j <= n; j++) {
if (f[n][j] != inf) {
ans = j;
}
}
printf("%d\n", ans);
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) REP(i, 0, n)
#define rrep(i, n) for (int i = (int)(n-1); i >= 0; i--)
#define sz(x) int(x.size())
#define bitsz(x) int(__builtin_popcount(x))
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define INF 2e9
#define LINF 1e18
#define mod 1000000007
template<class T> inline bool chmax(T &a, const T &b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, const T &b) { if (a > b) { a = b; return 1; } return 0; }
typedef long long ll;
typedef pair<int, int> P;
int dx[4] = {1,0,-1,0};
int dy[4] = {0,1,0,-1};
int main() {
int n; cin >> n;
vector<int> 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(c));
ll ans = 0;
rep(i,n) {
ll anibu = lower_bound(all(a),b[i]) - a.begin(); //b[i]より小となる個数
ll cnibu = c.end() - upper_bound(all(c),b[i]); //b[i]より大となる個数
ans += anibu*cnibu;
}
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
#define rep(i,n) for(int i=0; i<(n); i++)
int N;
int A[3][100001];
LL dp[3][100001] = {};
int main() {
scanf("%d", &N);
rep(j, 3) { rep(i, N) scanf("%d", &A[j][i]); A[j][N] = 1000000001; }
rep(j, 3) sort(A[j], A[j] + N);
rep(i, N + 1) dp[0][i] = i;
rep(j, 2) {
int p = 0;
rep(i, N) {
while (A[j][p] < A[j + 1][i]) p++;
dp[j + 1][i + 1] += dp[j + 1][i] + dp[j][p];
}
}
printf("%lld\n", dp[2][N]);
return 0;
} | 1 |
#include<cstdio>
#include<utility>
#include<algorithm>
#include<vector>
#include<queue>
#define MAX_N 262144
#define INF 1000000000000000
typedef long long ll;
using namespace std;
int used[MAX_N];
ll n,d,a[MAX_N],ans=0,two[20];
pair<ll,ll> p[MAX_N],t[2*MAX_N][2];
vector<pair<ll,ll> > g[MAX_N];
void init(){
for(ll i=0;i<2*MAX_N;i++){
t[i][0]=t[i][1]=make_pair(INF,i);
}
two[0]=1;
for(int i=1;i<20;i++){
two[i]=two[i-1]*2;
}
}
void change(ll i){
ll y=p[i].second+MAX_N;
t[y][0].first=d*(y-MAX_N)+p[i].first;
t[y][1].first=d*(n-1-y+MAX_N)+p[i].first;
y/=2;
while(y>0){
t[y][0]=min(t[2*y][0],t[2*y+1][0]);
t[y][1]=min(t[2*y][1],t[2*y+1][1]);
y/=2;
}
}
pair<ll,ll> smq(ll l,ll r,int y){
ll cnt=1,x=l;
if(l==r){
return t[l][y];
}
while(x>0){
if(x/2*two[cnt]==l&&(x/2+1LL)*two[cnt]-(1LL)==r){
return t[x/2][y];
}
else if(x/2*two[cnt]<l||(x/2+1LL)*two[cnt]-(1LL)>r){
return min(t[x][y],smq((x+1LL)*two[cnt-1],r,y));
}
x/=2;
cnt++;
}
return t[x][y];
}
int main(){
pair<ll,ll> x;
priority_queue<pair<ll,ll> ,vector<pair<ll,ll>>, greater<pair<ll,ll>>> q;
scanf("%lld %lld",&n,&d);
for(ll i=0;i<n;i++){
scanf("%lld",&a[i]);
p[i]=make_pair(a[i],i);
}
init();
sort(p,p+n);
change(0);
for(ll i=1;i<n;i++){
x=smq(p[i].second+MAX_N,n-1+MAX_N,0);
if(x.first<INF){
g[p[i].second].push_back(make_pair(x.first-d*p[i].second+p[i].first,x.second-MAX_N));
g[x.second-MAX_N].push_back(make_pair(x.first-d*p[i].second+p[i].first,p[i].second));
}
x=smq(MAX_N,p[i].second+MAX_N,1);
if(x.first<INF){
g[p[i].second].push_back(make_pair(x.first-d*(n-1-p[i].second)+p[i].first,x.second-MAX_N));
g[x.second-MAX_N].push_back(make_pair(x.first-d*(n-1-p[i].second)+p[i].first,p[i].second));
}
change(i);
}
used[p[n-1].second]=1;
for(int i=0;i<g[p[n-1].second].size();i++){
q.push(g[p[n-1].second][i]);
}
while(!q.empty()){
x=q.top();
q.pop();
if(used[x.second]==0){
ans+=x.first;
for(int i=0;i<g[x.second].size();i++){
q.push(g[x.second][i]);
}
used[x.second]=1;
}
}
printf("%lld\n",ans);
} | #include<cstdio>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;
typedef long long ll;
typedef pair<ll,int> pli;
#define fir first
#define sec second
#define Mp make_pair
const int MAXN = 2e5 + 5;
const int inf = 0x3f3f3f3f;
const ll linf = 0x3f3f3f3f3f3f3f3f;
template<typename T>
void chk_min(T &a,T b){ if(a>b) a=b;}
ll a[MAXN];
int main(void)
{
int n;
ll d;
scanf("%d%lld",&n,&d);
for(int i=1; i<=n; ++i) scanf("%lld",&a[i]);
ll ans=0;
for(int i=1; i<=n; ++i) ans += a[i];
for(int i=2; i<=n; ++i) chk_min(a[i], a[i-1]+d);
for(int i=n-1; i>=1; --i) chk_min(a[i], a[i+1]+d);
for(int i=1; i<=n; ++i) ans += a[i];
printf("%lld",ans + d*(n-1) - a[1] - a[n]);
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
#define all(x) x.begin(),x.end()
#define rep(i,j,n) for (long long i = j; i < (long long)(n); i++)
#define _GLIBCXX_DEBUG
#define MOD 1000000007
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; }
//name[i][j]-> vvl name(i,vl(j))
//map<int,int>mp
//余りを切り上げる => (a + b - 1) / b
vi vx={-1,0,1,0};
vi vy={0,1,0,-1};
using pi = pair<int,int>;
signed main(){
int a,b; cin>>a>>b;
vvi v(a,vi(b));
queue<pi> q;
rep(i,0,a){
rep(j,0,b){
char c; cin>>c;
if(c=='#'){
v[i][j]=1;
q.push(make_pair(i,j));
}
else v[i][j]=0;
}
}
while(!q.empty()){
pi p=q.front(); q.pop();
int k,l; tie(k,l)=p;
bool ok=false;
rep(i,0,4){
k+=vx[i]; l+=vy[i];
if(k>=0 && k<a){
if(l>=0 && l<b){
if(v[k][l]==1)ok=true;
}
}
k-=vx[i]; l-=vy[i];
}
if(!ok){
cout<<"No"<<endl;
return 0;
}
}
cout<<"Yes"<<endl;
return 0;
} | #include <cstdio>
#include <iostream>
#include <vector>
#define lson (idx << 1)
#define rson (idx << 1 | 1)
#define INF 1000000000000LL
#define MAXN 200010
using namespace std;
typedef long long ll;
// `lo` is the current minimum of the segment.
// `lh` is the current value of the left endpoint.
// `lazy` is the lazy tag for addition.
struct Node {
int l, r;
ll lo;
bool flag = false;
} s[MAXN << 2];
int h, w;
// Push up
void calc(int idx) {
s[idx].lo = min(s[lson].lo, s[rson].lo);
}
void build(int idx, int l, int r) {
s[idx].l = l, s[idx].r = r;
if (l == r) return;
int mid = (l + r) >> 1;
build(lson, l, mid);
build(rson, mid + 1, r);
}
// Lazy propagation
void pushdown(int idx) {
if (s[idx].flag) {
ll L = s[idx].lo;
int l = s[idx].l;
for (int i = lson; i <= rson; ++i) {
s[i].lo = L + s[i].l - l;
s[i].flag = true;
}
}
s[idx].flag = false;
}
// Assign segment [l, r] according to f[l-1] = L
void update(int idx, int l, int r, ll L) {
if (s[idx].l >= l && s[idx].r <= r) {
s[idx].lo = L + s[idx].l - l + 1;
s[idx].flag = true;
return;
}
pushdown(idx);
int mid = (s[idx].l + s[idx].r) >> 1;
if (l <= mid)
update(lson, l, r, L);
if (mid + 1 <= r)
update(rson, l, r, L);
calc(idx);
}
// Range minimum query
ll query(int idx, int l, int r) {
if (r < 1 || l > w)
return INF;
if (s[idx].l >= l && s[idx].r <= r)
return s[idx].lo;
pushdown(idx);
ll ans = INF;
int mid = (s[idx].l + s[idx].r) >> 1;
if (l <= mid)
ans = min(ans, query(lson, l, r));
if (mid + 1 <= r)
ans = min(ans, query(rson, l, r));
return ans;
}
void solve() {
scanf("%d%d",&h,&w);
vector<int> l(h), r(h);
for (int i = 0; i < h; ++i)
scanf("%d%d",&l[i],&r[i]);
vector<ll> ans(h, INF);
build(1, 1, w);
for (int i = 0; i < h; ++i) {
ll L = query(1, l[i] - 1, l[i] - 1);
update(1, l[i], r[i], L);
ans[i] = min(ans[i], query(1, 1, w))+i+1;
if (ans[i] == INF) break;
}
for (ll i : ans) cout << (i >= INF ? -1 : i) << endl;
}
int main() {
ios::sync_with_stdio(false);cin.tie(0);
solve();
} | 0 |
#include<algorithm>
#include<iostream>
#include<cstring>
#include<string>
#include<vector>
#include<cstdio>
#include<cmath>
#include<map>
#include<set>
using namespace std;
long long n,d,a[200005],r[200005],l[200005];
int main()
{
cin>>n>>d;
long long ret=0;
for(int i=0;i<n;i++)
{
cin>>a[i];
ret+=a[i];
}
ret+=(n-1)*d;
//cout<<ret<<endl;
r[0]=a[0];
for(int i=1;i<n;i++)
r[i]=min(a[i],r[i-1]+d);
l[n-1]=a[n-1];
for(int i=n-2;i>=0;i--)
l[i]=min(a[i],l[i+1]+d);
for(int i=1;i<n-1;i++)
ret+=min(l[i],r[i]);
cout<<ret;
return 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;
}
| 1 |
#include <iostream>
#include <string>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <queue>
#include <stack>
#include <functional>
#include <bitset>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll,ll> P;
typedef vector<P> vpl;
#define rep(i,n) for(ll i=0; i<(n); i++)
#define REP(i,a,b) for(ll i=(a); i<(b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1<<30;
const ll linf = 1LL<<62;
const int MAX = 510000;
ll dy[8] = {0,1,0,-1,1,-1,1,-1};
ll dx[8] = {1,0,-1,0,1,-1,-1,1};
const double pi = acos(-1);
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
template<typename T1,typename T2> inline void print2(T1 a, T2 b){cout << a << " " << b << endl;}
template<typename T1,typename T2,typename T3> inline void print3(T1 a, T2 b, T3 c){
cout << a << " " << b << " " << c << endl;
}
const int mod = 1e9 + 7;
vector<ll> fac(MAX), finv(MAX), inv(MAX);
void comInit(){
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(ll i=2; i<MAX; i++){
fac[i] = fac[i-1]*i % mod;
inv[i] = mod - inv[mod%i] * (mod/i) % mod;
finv[i] = finv[i-1] * inv[i] % mod;
}
}
ll com(ll n, ll k){
if(n < k) return 0;
if(n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n-k] % mod) % mod;
}
int main(){
ll n,m,k; cin >> n >> m >> k;
comInit();
ll sum = 0;
REP(i,1,m){
sum += n*n%mod*i%mod*(m-i)%mod;
sum %= mod;
}
REP(i,1,n){
sum += m*m%mod*i%mod*(n-i)%mod;
sum %= mod;
}
cout << sum*com(n*m-2,k-2)%mod << endl;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <queue>
#include <map>
using ll = long long;
using namespace std;
constexpr ll inf = 1e15;
#define MAX_N 1000
constexpr int MAX = 10000;
constexpr int MOD = 1e9+7;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// dp[i][j] := 最大のグループ人数がj人であるとき、i人をグループ分けする場合の数
ll dp[MAX_N+1][MAX_N+1] = {0};
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int N, A, B, C, D;
cin>>N>>A>>B>>C>>D;
for (int i = 0; i <= B; i++) dp[0][i] = 1;
COMinit();
for (int n = 1; n <= N; n++) {
for (int i = A; i <= B; i++) {
ll comb = 1;
dp[n][i] = dp[n][i-1];
for (int j = 1; j < C; j++) comb = (((comb * COM(n - i * (j - 1), i)) % MOD) * inv[j]) % MOD;
for (int j = C; j <= min(D, (n/i)); j++) {
ll F = i * j;
comb = (((comb * COM(n - i * (j - 1), i)) % MOD) * inv[j]) % MOD;
dp[n][i] = (dp[n][i] + (dp[n - F][i - 1] * comb % MOD)) % MOD;
}
}
}
cout<<dp[N][B]<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef double D;
typedef long long int LL;
#define st first
#define nd second
#define pb push_back
#define PLL pair <LL, LL>
#define PII pair <int, int>
const int N = 507;
const int MX = 1e9 + 7;
const LL INF = 1e18 + 9LL;
int n;
LL tab[N][N];
vector <int> primes;
LL nwd(LL a, LL b){
if(b == 0)
return a;
return nwd(b, a%b);
}
LL get(LL a, LL b, LL c, LL d){
LL ret = a / nwd(a, b) * b;
ret = ret / nwd(ret, c) * c;
ret = ret / nwd(ret, d) * d;
return ret;
}
bool ok(int a){
for(int i = 2; i * i <= a; ++i)
if(a%i == 0)
return false;
return true;
}
int main(){
scanf("%d", &n);
if(n == 2){
puts("2 3\n5 4");
return 0;
}
for(int i = 2; primes.size() < n + n; ++i)
if(ok(i))
primes.push_back(i);
for(int i = 0; i <= n + 1; ++i)
for(int j = 0; j <= n + 1; ++j)
tab[i][j] = 1;
int sx = n - 1 + (n & 1), sy = 1;
for(int i = 1; i <= n - 1 + (n & 1); ++i){
int cx = sx, cy = sy;
while(cx <= n && cy <= n){
tab[cx][cy] *= primes.back();
++cx, ++cy;
}
if(sx > 2)
sx -= 2;
else{
if(sy == 1 && sx == 2)
sx = 1, sy++;
else
sy += 2;
}
primes.pop_back();
}
sx = 1, sy = 1;
for(int i = 1; i <= n; ++i){
int cx = sx, cy = sy;
while(cx <= n && cy >= 1){
tab[cx][cy] *= primes.back();
++cx, --cy;
}
if(sy + 1 < n)
sy += 2;
else{
if(sx == 1 && sy + 1 == n)
sy = n, ++sx;
else
sx += 2;
}
primes.pop_back();
}
for(int i = 1; i <= n; ++i){
for(int j = 1; j <= n; ++j){
if((i + j) & 1)
tab[i][j] = get(tab[i - 1][j], tab[i][j - 1], tab[i + 1][j], tab[i][j + 1]) + 1;
printf("%lld ", tab[i][j]);
}
puts("");
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define lor(a,b,c) for(register int a=b;a<=c;++a)
#define ror(a,b,c) for(register int a=c;a>=b;--a)
typedef long long ll;
const int MAXN=505,MAXD=7919;
const int movx[4]={-1,0,1,0},movy[4]={0,1,0,-1};
int n; ll a[MAXN][MAXN];
bool vis[MAXD]; ll prime[MAXN<<1];
inline ll gcd(ll a,ll b){
return b?gcd(b,a%b):a;
}
inline ll lcm(ll a,ll b){
if(!a||!b) return a|b;
return a/gcd(a,b)*b;
}
inline void judge(){
int x,a[505][505];
scanf("%d",&x); lor(i,1,x) lor(j,1,x) scanf("%d",&a[i][j]);
}
int main(){
scanf("%d",&n);
if(n==2) return printf("4 7\n23 10\n"),0;
lor(i,2,MAXD){
if(!vis[i]) prime[++prime[0]]=i;
for(register int j=1;j<=prime[0]&&i*prime[j]<=MAXD;++j) vis[i*prime[j]]=true;
}
lor(i,1,n) lor(j,1,n) if(!((i+j)&1)){
a[i][j]=prime[(i+j)>>1]*prime[n+(n+1)/2+(i-j)/2];
}
lor(i,1,n) lor(j,1,n) if((i+j)&1){
a[i][j]=lcm(lcm(a[i-1][j],a[i][j-1]),lcm(a[i+1][j],a[i][j+1]))+1;
}
lor(i,1,n){
lor(j,1,n) printf("%lld ",a[i][j]); printf("\n");
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i, start, end) for (long long i = start; i < end; ++i)
#define repreverse(i, start, end) for (long long i = start; i >= end; --i)
#define all(x) (x).begin(), (x).end()
#define len(x) ((long long)(x).size())
#define lcm(a, b) ((a) / __gcd((a), (b)) * (b))
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vllvll = vector<vll>;
using pll = pair<ll, ll>;
template<class T>void print1d(T x,ll n=-1){if(n==-1)n=x.size();rep(i,0,n){cout<<x[i]<<' ';}cout<<'\n';}
template<class T>void print2d(T x,ll r=-1,ll c=-1){if(r==-1)r=x.size();if(c==-1)c=x[0].size();rep(i,0,r)print1d(x[i],c);}
template<class T, class U>bool haskey(T mp, U key) { return mp.find(key) != mp.end(); }
template<class T, class U>bool isin(T el, U container) { return find(all(container), el) != container.end(); }
template<class T>bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
template<class T>bool even(T n) { return ! (n & 1); }
template<class T>bool odd(T n) { return n & 1; }
template<class T>ld deg2rad(T deg) { return M_PI * deg / 180.0; }
template<class T>ld rad2deg(T rad) { return 180.0 * rad / M_PI; }
ll intpow(ll a,ll n){ll p=1;while(n){if(n&1)p*=a;a*=a;n>>=1;}return p;}
const long double pi = M_PI;
const long long big = 1LL << 50;
const long long inf = 1LL << 60;
const long long mod = 1e9 + 7;
int main()
{
ll N, A, B;
cin >> N >> A >> B;
vll X(N+1);
rep(i, 1, N+1) {
cin >> X[i];
}
vll dp(N+1);
rep(i, 2, N+1) {
dp[i] += dp[i-1] + min(A * (X[i]-X[i-1]), B);
}
cout << dp.back() << endl;
} | #include <iostream>
using namespace std;
typedef long long int LLI;
int main()
{
LLI n, a, b, save;
cin >> n >> a >> b;
LLI first, second, ans = 0;
cin >> first >> second;
save = ( second - first ) * a;
if( save > b )
ans += b;
else
ans += save;
first = second;
for(int i = 2; i < n; i++)
{
cin >> second;
save = ( second - first ) * a;
if( save > b )
ans += b;
else
ans += save;
first = second;
}
cout << ans;
} | 1 |
#include <iostream>
#include <string>
using namespace std;
int main(){
string text;
while(getline(cin,text,'\n')){
for(int i=0;i<26;i++){
for(int w=0;w<text.size();w++){
if ('a'<=text[w]&&text[w]<'z')
text[w]++;
else if(text[w]=='z')
text[w] = 'a';
}
if (text.find("this") != string::npos||text.find("that") != string::npos||text.find("the") != string::npos){
cout << text << endl;
break;
}
}
}
} | #include <iostream>
#include <string>
using namespace std;
const int ALPHA = 26;
int main(){
string input;
while(cin && getline(cin, input)){
string cand[ALPHA];
for(int i=0; i<ALPHA; i++){
cand[i] = "";
for(int n=0; n<input.size(); n++){
if('a'<=input[n]&&input[n]<='z'){
cand[i] += (input[n]-'a'+i)%ALPHA + 'a';
} else {
cand[i] += input[n];
}
}
if(cand[i].find("the") != string::npos
|| cand[i].find("this") != string::npos
|| cand[i].find("that") != string::npos){
cout<<cand[i]<<endl;
}
}
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
struct edge{
int to, cost;
};
int main(int argc, char *argv[]){
int n, m, r;
cin >> n >> m >> r;
vector<vector<edge> > g(n);
int from;
for (int i = 0; i < m; i++) {
edge e;
cin >> from >> e.to >> e.cost;
g[from].push_back(e);
}
int dp[n];
for (int i = 0; i < n; i++) {
dp[i] = 1e9;
}
dp[r] = 0;
//???????????§?????????
//????????????????????????????????????
bool update = true;
int cnt = 0;
while(update){
if(cnt > n)break;
cnt++;
update = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < g[i].size(); j++) {
edge e = g[i][j];
if(dp[e.to] > dp[i] + e.cost){
dp[e.to] = dp[i] + e.cost;
update = true;
}
}
}
}
if(cnt > n){
std::cout << "NEGATIVE CYCLE" << std::endl;
}else{
for (int i = 0; i < n; i++) {
if(dp[i] == 1e9)std::cout << "INF" << std::endl;
else std::cout << dp[i] << std::endl;
}
}
return 0;
} | #include <iostream>
using namespace std;
#define full (m == 100 || e == 100 || j == 100)
#define avg(n) (m + e + j >= n)
#define me80 (m >= 80 || e >= 80)
int main() {
int n, m, e, j;
while (1) {
cin >> n; if (n == 0)break;
for (int i = 0; i < n; i++) {
cin >> m >> e >> j;
if (full || m + e >= 180 || avg(240)) cout << "A" << endl;
else if (avg(210) || (avg(150) && me80)) cout << "B" << endl;
else cout << "C" << endl;
}
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define endl "\n"
#define F first
#define S second
#define mod 1000000007
#define pb push_back
#define FOR(i,a,n) for(int i=a;i<n;i++)
#define REV(i,a,n) for(int i=a;i>=n;i--)
#define all(a) a.begin(),a.end()
const int NUM = 2e5 + 5;
int32_t main(){
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int num_tests=1;
//cin >> num_tests;
while(num_tests-->0){
int n; cin >> n;
int ans = 0;
while(n >= 500)
{
int x = n/500;
ans += x*1000;
n -= (x)*500;
}
while(n >= 5)
{
int y = n/5;
ans += y*5;
n -= y*5;
}
cout << ans;
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < n; i++)
static const long long INF = 1000000;
using p = pair<int,int>;
int main(){
int64_t x,ans;
cin >> x;
int a,b,c;
a = x/500;
b = x - 500*a;
c = b/5;
ans = 1000*a + c*5;
cout << ans << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
char S;
int mix=0;
int a=0;
for(int i=0; i<3;i++){
cin >> S;
if (S=='R'){
a++;
mix=max(a,mix);
} else {
a=0;
}
}
cout << mix << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
int main()
{
string S;
cin >> S;
if (S.find("RRR") != string::npos) {
cout << 3 << endl;
} else {
if (S.find("RR") != string::npos) {
cout << 2 << endl;
} else {
if (S.find("R") != string::npos) {
cout << 1 << endl;
} else {
cout << 0 << endl;
}
}
}
return 0;
} | 1 |
#include<bits/stdc++.h>
#define ll long long
#define mod 998244353
#define N 1000009
#define cbn(x,y) ((ll)fac[x]*inv[y]%mod*inv[(x)-(y)]%mod)
using namespace std;
int m,n,fac[N],inv[N];
int ksm(int x,int y){
int z=1; for (; y; y>>=1,x=(ll)x*x%mod) if (y&1) z=(ll)z*x%mod;
return z;
}
int main(){
scanf("%d%d",&m,&n); if (m<n) swap(m,n);
int i,ans=0;
fac[0]=inv[0]=inv[1]=1;
for (i=1; i<N; i++) fac[i]=(ll)fac[i-1]*i%mod;
for (i=2; i<N; i++) inv[i]=mod-(ll)inv[mod%i]*(mod/i)%mod;
for (i=2; i<N; i++) inv[i]=(ll)inv[i-1]*inv[i]%mod;
for (i=1; i<=n; i++) ans=(ans+(ll)cbn(i<<1,i)*cbn(m+n-(i<<1),m-i))%mod;
printf("%lld\n",((ll)ans*ksm(cbn(m+n,m)<<1,mod-2)+m)%mod);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <vector>
#include <functional>
#include <cstdlib>
#include <map>
#include <set>
#include <iostream>
#include <string>
#include <ctype.h>
#include <climits>
#include <queue>
using namespace std;
typedef long long ll;
#define REP(i, n) for(ll i = 0; i < (ll)(n); ++i)
template<class T> inline bool chmax(T& a, T b) { if(a < b){ a=b; return 1; } return 0;}
template<class T> inline bool chmin(T& a, T b) { if(a > b){ a=b; return 1; } return 0;}
int main(){
int n;
string s;
cin >> n >> s;
vector<int> w(n+1), e(n+1);
w[0] = 0;
e[0] = 0;
REP(i,n){
w[i+1] = w[i];
e[i+1] = e[i];
if(s[i]=='W') w[i+1]++;
if(s[n-1-i]=='E') e[i+1]++;
}
int ans=1000000;
REP(i,n){
chmin(ans, w[i+1]+e[n-i]-1);
}
cout << ans << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,q;
cin>>n>>q;
vector<int>a(n);
for(int i=0;i<n;i++)cin>>a[i];
vector<vector<int> >d(n);
vector<int>f(n);
vector<int>ans(q);
vector<vector<int> >id(n);
for(int i=0;i<q;i++)
{
int l,r;
cin>>l>>r;
l--;
r--;
d[r].push_back(l);
id[r].push_back(i);
}
vector<int>p(n+1,-1);
for(int i=0;i<n;i++)
{
if(p[a[i]]!=-1)
{
for(int j=p[a[i]];j<n;j=(j|(j+1)))f[j]-=1;
}
p[a[i]]=i;
for(int j=p[a[i]];j<n;j=(j|(j+1)))f[j]+=1;
for(int j=0;j<d[i].size();j++)
{
int lsum=0;
int rsum=0;
for(int t=i;t>=0;t=(t&(t+1))-1)rsum+=f[t];
if(d[i][j]>0)
{
for(int t=d[i][j]-1;t>=0;t=(t&(t+1))-1)lsum+=f[t];
}
ans[id[i][j]]=rsum-lsum;
}
}
for(auto x:ans)cout<<x<<endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int ff;
int n,m,col[500100],blo,tot,le,ri,ans[500100],cnt[500100];
pair<pair<int,int>,int> que[500100];
bool pp(pair<pair<int,int>,int> x,pair<pair<int,int>,int> y){
return x.first.second<y.first.second;
}
inline void inser(int val){cnt[val]++;if(cnt[val]==1) ff++;}
inline void eras(int val){cnt[val]--;if(cnt[val]==0) ff--;}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) scanf("%d",&col[i]);
for(int i=1;i<=m;i++){
scanf("%d%d",&que[i].first.first,&que[i].first.second);
que[i].second=i;
}
sort(que+1,que+m+1);
blo=max(1,(int)(sqrt(m)));
tot=(m+blo-1)/blo;
for(int i=1;i<=tot;i++){
le=blo*(i-1)+1;
ri=min(blo*i,m);
sort(que+le,que+ri+1,pp);
for(int j=1;j<=n;j++) cnt[j]=0;
ff=0;
for(int j=que[le].first.first;j<=que[le].first.second;j++)
inser(col[j]);
ans[que[le].second]=ff;
for(int j=le+1;j<=ri;j++){
for(int kk=que[j-1].first.first;kk<que[j].first.first;kk++)
eras(col[kk]);
for(int kk=que[j].first.first;kk<que[j-1].first.first;kk++)
inser(col[kk]);
for(int kk=que[j-1].first.second+1;kk<=que[j].first.second;kk++)
inser(col[kk]);
ans[que[j].second]=ff;
}
}
for(int i=1;i<=m;i++) printf("%d\n",ans[i]);
return 0;
}
| 1 |
#include<iostream>
#include<algorithm>
using namespace std;
int main() {
int l[5];
char c;
while (cin >> l[0] >> c >> l[1] >> c >> l[2] >> c >> l[3] >> c >> l[4]) {
sort(l, l + 5);
if (l[0] == l[1] && l[1] == l[2] && l[2] == l[3])
cout << "four card";
else if (l[4] == l[1] && l[1] == l[2] && l[2] == l[3])
cout << "four card";
else if (l[0] == l[1] && l[1] == l[2] && l[4] == l[3])
cout << "full house";
else if (l[0] == l[1] && l[3] == l[2] && l[4] == l[3])
cout << "full house";
else if (l[4] == l[3] + 1 && l[3] == l[2] + 1 && l[2] == l[1] + 1 && l[1] == l[0] + 1)
cout << "straight";
else if (l[0] == 1 && l[1] == 10 && l[2] == 11 && l[3] == 12 && l[4] == 13)
cout << "straight";
else if (l[0] == l[1] && l[1] == l[2])
cout << "three card";
else if (l[3] == l[1] && l[1] == l[2])
cout << "three card";
else if (l[3] == l[4] && l[3] == l[2])
cout << "three card";
else if (l[0] == l[1] && l[2] == l[3])
cout << "two pair";
else if (l[0] == l[1] && l[4] == l[3])
cout << "two pair";
else if (l[2] == l[1] && l[4] == l[3])
cout << "two pair";
else if (l[0] == l[1] || l[1] == l[2] || l[2] == l[3] || l[3] == l[4])
cout << "one pair";
else cout << "null";
cout << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, s, n) for(int i = s; i < (int)n; i++)
#define per(i, n) for(int i = n; i >= 0; i--)
#define ROF(i, s, n) for(int i = s; i >= (int)n; i--)
#define FORIT(i, A) for (auto i : A)
#define PRINT(x) cout << (x) << "\n"
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define MP make_pair
#define EACH(i, n) for (__typeof((n).begin()) i = (n).begin(); i != (n).end(); ++i)
#define SZ(a) int((a).size())
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define CLR(a) memset((a), 0 ,sizeof(a))
#define NCLR(a) memset((a), -1 ,sizeof(a))
#define dump(x) cout << #x << " = " << (x) << "\n";
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << "\n";
#define sq(n) (n) * (n)
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef priority_queue<int> maxpq;
typedef priority_queue< int, vector<int>, greater<int> > minpq;
static const double EPS = 1e-10;
static const double PI = acos( -1.0 );
static const int mod = 1000000007;
static const int INF = 1 << 25;
static const LL LL_INF = 1152921504606846976;
static const int dx[] = { -1, 0, 1, 0, 1, -1, 1, -1 };
static const int dy[] = { 0, -1, 0, 1, 1, 1, -1, -1 };
string _str[ 7 ] = { "null", "one pair", "two pair", "three card", "straight", "full house", "four card" };
int ans = 0;
int _hand[ 5 ];
int main() {
while ( ~scanf( "%d,%d,%d,%d,%d", &_hand[ 0 ], &_hand[ 1 ], &_hand[ 2 ], &_hand[ 3 ], &_hand[ 4 ] ) ) {
ans = 0;
sort( _hand, _hand + 5 );
bool is_straight = true;
for ( int i = 0; i < 4; i++ ) {
if ( _hand[ i + 1 ] - _hand[ i ] != 1 ) {
is_straight = false;
break;
}
}
if ( is_straight ) {
ans = 4;
}
for ( int i = 0; i < 5; i++ ) {
if ( _hand[ i ] == 1 ) {
_hand[ i ] += 13;
}
}
sort( _hand, _hand + 5 );
is_straight = true;
for ( int i = 0; i < 4; i++ ) {
if ( _hand[ i + 1 ] - _hand[ i ] != 1 ) {
is_straight = false;
break;
}
}
if ( is_straight ) {
ans = 4;
}
bool is_three_card = false;
bool is_one_pair = false;
for ( int i = 1; i <= 20; i++ ) {
int many = upper_bound( _hand, _hand + 5, i ) - lower_bound( _hand, _hand + 5, i );
if ( many == 4 ) {
ans = 6;
break;
}
if ( many == 3 ) {
is_three_card = true;
ans = 3;
if ( is_one_pair ) {
ans = 5;
break;
}
}
if ( many == 2 ) {
if ( is_one_pair ) {
ans = 2;
break;
}
if ( is_three_card ) {
ans = 5;
break;
}
is_one_pair = true;
ans = 1;
}
}
printf( "%s\n", _str[ ans ].c_str() );
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
inline int read()
{
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9')
{
if(c=='-')
f=-1;
c=getchar();
}
while(c<='9'&&c>='0')
{
x=x*10+c-'0';
c=getchar();
}
return x*f;
}
int main()
{
int d=read(),t=read(),s=read();
if(t*s>=d)
puts("Yes");
else
puts("No");
return 0;
}
| #include <iostream>
using namespace std;
#define fin(ans) cout << (ans) << '\n'
int main()
{
int A[3];
cin >> A[0] >> A[1] >>A[2];
sort(A,A+3);
if(A[0] == A[1] && A[1] == A[2]){
fin("No");
}else if ((A[0] != A[1] && A[1] != A[2]) ){
fin("No");
}else{
fin("Yes");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.size() != 2)
reverse(s.begin(), s.end());
cout << s << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
char s[1500];
int i,n;
cin>>s;
n=strlen(s);
if(n==2){
cout<<s;
}
else{
for(i=n-1;i>=0;i--){
cout<<s[i];
}
}
return 0;
}
| 1 |
#include<iostream>
#include<vector>
#include<map>
#include<utility>
#include<algorithm>
#include<queue>
#include<stack>
#include<string>
#include<stdlib.h>
#include<stdio.h>
#include<cmath>
#include<cstdlib>
#include<typeinfo>
#include<sstream>
#include<list>
#include<set>
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define fori(i,k,n) for(int i=k;i<(int)n;i++)
using namespace std;
int in()
{
int x;cin>>x;
return x;
}
int stringInt(string a)
{
return atoi(a.c_str());
}
string intString(int a)
{
stringstream ss;
ss<<a;
return ss.str();
}
vector<int> SieveOfEratosthenes(int x)
{
vector<int> a;
vector<int> b(x+1,0);
for(int i=2;i<=x;i++)
{
if(b[i]==0)
{
a.push_back(i);
for(int l=i;l<=x;l+=i)
{
b[l]=1;
}
}
}
return a;
}
int main ()
{
int n,m;
while(cin>>n>>m&&n&&m)
{
vector<long long > a,b;
b.push_back(0);
rep(i,n)
{
b.push_back(in());
}
rep(i,n+1)
{
rep(l,n+1)
{
a.push_back(b[i]+b[l]);
}
}
long long ans = 0;
sort(a.begin(),a.end());
rep(i,a.size())
{
vector<long long>::iterator t=upper_bound(a.begin(),a.end(),m-a[i]);
if(t==a.begin())continue;
t--;
ans=max(ans,*t+a[i]);
}
cout<<ans<<endl;
}
} | // 0529.cpp
// 2012/12/14.
#if 1
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <iostream>
#include <cctype>
#include <sstream>
#include <string>
#include <list>
#include <vector>
#include <queue>
#include <set>
#include <stack>
#include <map>
#include <utility>
#include <numeric>
#include <algorithm>
#include <iterator>
#include <bitset>
#include <complex>
#include <fstream>
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
typedef vector<int> vint;
typedef pair<int, int> pint;
#define rep(i, n) REP(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define MSG(a) cout << #a << " " << a << endl;
#define REP(i, x, n) for(int i = x; i < n; i++)
template<class T> T RoundOff(T a){ return int(a+.5-(a<0)); }
template<class T, class C> void chmax(T& a, C b){ if(a < b) a = b; }
template<class T, class C> void chmin(T& a, C b){ if(b < a) a = b; }
template<class T, class C> pair<T, C> mp(T a, C b){ return make_pair(a, b); }
int main()
{
for(int N, M; cin >> N >> M && (N || M); )
{
vint points(N);
rep(i, N) cin >> points[i];
points.push_back(0);
vint pair;
rep(i, N+1) REP(j, i, N+1) pair.push_back(points[i] + points[j]);
sort(ALL(pair));
int ans = 0;
rep(i, pair.size())
{
int s = M - pair[i];
int idx = lower_bound(ALL(pair), s) - pair.begin() - 1;
if(0 <= idx && pair[i] + pair[idx] <= M) chmax(ans, pair[i] + pair[idx]);
}
cout << ans << endl;
}
}
#endif | 1 |
#include <bits/stdc++.h>
using namespace std;
using pint = pair<int, int>;
using ll = long long;
using ull = unsigned long long;
using vll = vector<long long>;
using pll = pair<ll, ll>;
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
#define VREP(s, ite) for (auto ite = s.begin(); ite != s.end(); ++ite)
#define FI first
#define SE second
#define ALL(v) v.begin(), v.end()
//#define endl "\n"
#define ciosup \
cin.tie(0); \
ios::sync_with_stdio(false);
#define eb emplace_back
#define vint vector<int>
constexpr ll INF = 1e15 + 7LL;
constexpr ll MOD = 998244353LL;
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (int i = 0; i < v.size(); ++i) {
is >> v[i];
}
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size() - 1; ++i) {
os << v[i] << " ";
}
if (v.size() > 0) {
os << v[v.size() - 1] << endl;
}
return os;
}
int main() {
ll n;
cin >> n;
priority_queue<pint> pque_plus;
priority_queue<pint> pque_nplus;
ll max_memo = 0;
REP(i, n) {
string s;
cin >> s;
pint cur{0, 0};
ll now = 0, minval = 0, maxval = 0;
REP(j, s.size()) {
now += (s[j] == '(' ? 1 : -1);
minval = min(minval, now);
maxval = max(maxval, now);
}
cur.SE = now;
if (cur.SE > 0){
cur.FI = minval;
pque_plus.push(cur);
} else if (cur.SE < 0) {
now = minval = maxval = 0;
IREP(j, s.size()) {
now += (s[j] == ')' ? 1 : -1);
minval = min(minval, now);
}
cur.FI = minval;
cur.SE = now;
pque_nplus.push(cur);
} else {
max_memo = max(max_memo, abs(minval));
now = minval = maxval = 0;
IREP(j, s.size()) {
now += (s[j] == ')' ? 1 : -1);
minval = min(minval, now);
}
max_memo = max(max_memo, abs(minval));
}
}
ll now = 0;
while (pque_plus.size()){
pint cur_val = pque_plus.top();
pque_plus.pop();
if (now + cur_val.FI < 0){
cout << "No" << endl;
return 0;
}
now += cur_val.SE;
}
ll now2 = 0;
while (pque_nplus.size()) {
pint cur_val = pque_nplus.top();
pque_nplus.pop();
if (now2 + cur_val.FI < 0) {
cout << "No" << endl;
return 0;
}
now2 += cur_val.SE;
}
if (now != now2) {
cout << "No" << endl;
return 0;
}
if (now < abs(max_memo)) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
}
| #include "bits/stdc++.h"
using namespace std;
int main() {
int N;
cin >> N;
vector<int>A(N + 2);
A[0] = 0;
A[N + 1] = 0;
for (int i = 0; i < N; ++i) {
int a;
cin >> a;
A[i + 1] = a;
}
int ans = 0;
for (int i = 0; i < N + 1; ++i) {
ans += abs(A[i + 1] - A[i]);
}
for (int i = 0; i < N; ++i) {
cout << ans + abs(A[i + 2] - A[i]) - abs(A[i + 1] - A[i]) - abs(A[i + 2] - A[i + 1]) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int ans = 111;
for (int i = 1; i < 10; i++) {
if (N <= ans * i) {
cout << ans * i << endl;
break;
}
else if (i == 9) {
cout << 1111 << endl;
}
}
} | #include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <complex>
#include <string>
#include <vector>
#include <list>
#include <deque>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
#include <functional>
#include <utility>
#include <algorithm>
#include <numeric>
#include <typeinfo>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
#include <ctime>
using namespace std;
#define dump(n) cout<<"# "<<#n<<"="<<(n)<<endl
#define debug(n) cout<<__FILE__<<","<<__LINE__<<": #"<<#n<<"="<<(n)<<endl
#define repi(i,a,b) for(int i=int(a);i<int(b);i++)
#define rep(i,n) repi(i,0,n)
#define iter(c) __typeof((c).begin())
#define foreach(i,c) for(iter(c) i=(c).begin();i!=(c).end();i++)
#define allof(c) (c).begin(),(c).end()
#define mp make_pair
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int,int> pii;
int main()
{
int n;
cin>>n;
for(int i=0;i<n;i++){
int score=0;
int runner=0;
for(int j=0;j<3;){
string s;
cin>>s;
if(s=="HIT"){
if(runner==3)
score++;
else
runner++;
}
else if(s=="HOMERUN"){
score+=runner+1;
runner=0;
}
else
j++;
}
cout<<score<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<ll, int> Pli;
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll MOD3 = 1812447359;
const ll INF = 1ll << 62;
const double PI = 2 * asin(1);
void yes() {printf("yes\n");}
void no() {printf("no\n");}
void Yes() {printf("Yes\n");}
void No() {printf("No\n");}
void YES() {printf("YES\n");}
void NO() {printf("NO\n");}
int N, A[int(2e5+5)], now[int(2e5+5)];
vector <int> ans;
int main(){
cin >> N;
for (int i = 1; i <= N; i++) cin >> A[i];
for (int i = N; i >= 1; i--){
if (now[i] % 2 == A[i]) continue;
ans.push_back(i);
for (int j = 1; j * j <= i; j++){
if (i % j != 0) continue;
now[j]++;
if (j * j != i) now[i/j]++;
}
}
if (now[1] % 2 != A[1]){
cout << -1 << endl;
return 0;
}
int M = ans.size();
cout << M << endl;
if (M > 0){
cout << ans[0];
for (int i = 1; i < M; i++) cout << " " << ans[i];
cout << endl;
}
return 0;
}
| /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <iostream>
#include <vector>
class DPreparingBoxes {
public:
void solve(std::istream& in, std::ostream& out) {
long long n;
std::vector<int> ans, a(200020), b(200020);
in >> n;
for(int i = 0; i < n; i++){
in >> a[i];
}
for(int i = n-1; i >= 0; i--){
int count = 0;
for(int j = 2*(i+1); j <= n; j += (i+1)){
count += b[j-1];
}
if((count % 2) != a[i]){
b[i] = 1;
ans.push_back(i+1);
}
}
out << ans.size() << std::endl;
for(auto i : ans){
out << i << " ";
}
out << std::endl;
}
};
int main() {
DPreparingBoxes solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int maxsize(0);
vector<int> input;
while (1)
{
int tmp;
cin >> tmp;
if (!tmp)
{
break;
}
input.push_back(tmp);
(maxsize < tmp) ? (maxsize = tmp) : (0);
}
vector<int> prime, ans;
for (int i(2); i <= maxsize; ++i)
{
for (vector<int>::iterator i2(prime.begin()), n2(prime.end()); i2 != n2; ++i2)
{
if ((i % *i2) == 0)
{
goto nx;
}
}
prime.push_back(i);
if (i != *prime.begin() && binary_search(prime.begin(), prime.end(), i - 2))
{
ans.push_back(i);
}
nx:;
}
for (vector<int>::iterator i(input.begin()), n(input.end()); i != n; ++i)
{
int out(*(--upper_bound(ans.begin(), ans.end(), *i)));
cout << out - 2 << ' ' << out << endl;
}
return 0;
} | #include<stdio.h>
#include<iostream>
using namespace std;
int main(){
int card[20000],i,j,a=0,b=0,c=1,n;
cin>>n;
while(n!=0){
for(i=0;i<2*n;i++){
cin>>card[i];
}
for(i=0;i<2*n;i=i+2){
if(card[i]>card[c]){
a=a+card[i]+card[c];
}
else if (card[i]==card[c]){
a=a+card[i];
b=b+card[c];
}
else{
b=b+card[i]+card[c];
}
c=c+2;
}
cout<<a<<" "<<b<<endl;
c=1;
a=0;
b=0;
cin>>n;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pi 3.141592653589793238
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
ll MOD=1e9+7;
void solve()
{
ll a[5];
for(ll i=0;i<5;i++)
cin>>a[i];
ll k;
cin>>k;
for(ll i=0;i<5;i++)
for(ll j=0;j<5;j++)
if(a[j]-a[i]>k)
{
cout<<":(";
return;
}
cout<<"Yay!";
return;
}
int main()
{
fast;
ll q;
q=1;
// cin>>q;
while(q--)
solve();
return 0;
}
| #include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#include <algorithm>
#include <iostream>
#include <string>
#include <cmath>
using namespace std;
#define ll long long
#define rep(i,n) for (ll i = 0; i < (n); i++)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
#define FORR(i,a,b)for(ll i=(a);i<=(b);i++)
#define repR(i,n) for(ll i=n;i>=0;i--)
#define all(v)(v).begin(),(v).end()
#define rall(v)(v).rbegin(),(v).rend()
#define F first
#define S second
#define pb push_back
#define pu push
#define COUT(x) cout<<(x)<<"\n"
#define PQ priority_queue<ll>
#define PQR priority_queue<ll,vector<ll>,greater<ll>>
#define YES(n) cout << ((n) ? "YES\n" : "NO\n" )
#define Yes(n) cout << ((n) ? "Yes\n" : "No\n" )
#define mp make_pair
#define sz(x) (ll)(x).size()
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const ll MOD = 1000000007LL;
const ll INF = 1LL << 60;
using vll = vector<ll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using vvll = vector<vll>;
using vstr = vector<string>;
using vc = vector<char>;
using vvc = vector<vc>;
template<class T> inline bool chmax(T& a, T b) {
if (a < b) { a = b; return true; } return false;
}
template<class T> inline bool chmin(T& a, T b) {
if (a > b) { a = b; return true; } return false;
}
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
ll dx[4]={0,1,0,-1};
ll dy[4]={1,0,-1,0};
int main(){
ll h,w;
cin>>h>>w;
vvll a(h,vll(w));
vvll b(h,vll(w));
rep(i,h)rep(j,w) cin>>a[i][j];
rep(i,h)rep(j,w) cin>>b[i][j];
vector<vvb> dp(h,vvb(w,vb(160*80,false)));
dp[0][0][abs(a[0][0]-b[0][0])]=true;
rep(i,h)rep(j,w)rep(z,160*80){
if(dp[i][j][z]){
if(i+1<h){
dp[i+1][j][z+abs(a[i+1][j]-b[i+1][j])]=true;
dp[i+1][j][abs(z-abs(a[i+1][j]-b[i+1][j]))]=true;
}
if(j+1<w){
dp[i][j+1][z+abs(a[i][j+1]-b[i][j+1])]=true;
dp[i][j+1][abs(z-abs(a[i][j+1]-b[i][j+1]))]=true;
}
}
}
rep(i,160*80){
if(dp[h-1][w-1][i]){
COUT(i);
return 0;
}
}
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.