code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <bits/stdc++.h>
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) for(int i=0;i<(n);++i)
#define REPr(i,n) for(int i=(n)-1;i>=0; --i)
#define FORq(i, m, n) for(int i = (m);i <= (n);++i)
#define FORqr(i, m , n) for(int i = (n);i >=(m);--i)
#define SCD(n) scanf("%d",&n)
#define SCD2(m,n) scanf("%d%d",&m,&n)
#define SCD3(m,n,k) scanf("%d%d%d",&m,&n,&k)
#define SCLLD(n) scanf("%lld",&n)
#define SCLLD2(m,n) scanf("%lld%lld",&m,&n)
#define SCLLD3(m,n,k) scanf("%lld%lld%lld",&m,&n,&k)
#define PB push_back
#define MP make_pair
#define ARSCD(A,N) REP(i,N){SCD(A[i]);}
#define ARSCD1(A,N) FORq(i,1,N){SCD(A[i]);}
#define VSCD(v,N) REP(i,N){int (x); SCD(x); v.PB(x);}
#define VSCLLD(v,N) REP(i,N){long long (x); SCLLD(x); v.PB(x);}
#define PRINTD(n) printf("%d\n",n)
#define PRINTLLD(n) printf("%lld\n",n)
#define DEBUG printf("%s\n","debug")
#define fst first
#define snd second
#define SIN(x,S) (S.count(x) != 0)
#define M0(x) memset(x,0,sizeof(x))
#define FILL(x,y) memset(x,y,sizeof(x))
#define MM(x) memset(x,-1,sizeof(x))
#define ALL(x) (x).begin(),(x).end()
using namespace std;
typedef pair<int,int> PII;
typedef pair<long long,long long> PLL;
typedef vector<int> VI;
typedef vector < VI > VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
///////////////////////////////////////////////
const ll MOD = 1000000007;
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
///////////////////////////////////////////////
int main(){
ll K;
SCLLD(K);
ll Q,R;
Q = K / 50;
R = K % 50;
ll a[50] = {};
REP(i,50){
a[i] = 49 + Q;
}
REP(i,50-R){
a[i] += -R;
}
REP(i,R){
if (R != 0) a[50-R +i] += 50 + 1 - R;
}
printf("50\n");
REP(i,49){
printf("%lld ",a[i]);
}
printf("%lld\n",a[49]);
}
| #include <bits/stdc++.h>
#define ll unsigned long long
using namespace std;
const int MOD = 1000000007;
int main()
{
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
ll k;
cin >> k;
int n = 50;
ll x = (k + n*n - n) / n;
ll arr[50];
for(int i = 0;i < 50;i++){
arr[i] = x;
}
ll rem = k - (x * n - n*n + n);
for(int i = 0;i < rem;i++){
arr[i] += n;
for(int j = 0;j < 50;j++){
if(i != j)
arr[j]--;
}
}
cout << 50 << endl;
for(int i = 0;i < n;i++)
cout << arr[i] << ' ';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
//TEMPLATE
#define pb push_back
#define mp make_pair
#define ll long long
#define ld long double
#define pii pair <ll, ll>
#define piii pair <ll, pii>
#define F first
#define S second
#define newline printf("\n")
#define minusone printf("-1\n")
#define zeroo printf("0\n")
#define scl1(a) scanf("%lld", &a)
#define scl2(a, b) scanf("%lld %lld", &a, &b)
#define scl3(a, b, c) scanf("%lld %lld %lld", &a, &b, &c)
#define prl1(a) printf("%lld\n", a)
#define prl2(a, b) printf("%lld %lld\n", a, b)
#define ssl1(s) scanf(" %[^\n]", s)
#define scd1(a) scanf("%lf", &a)
#define scd2(a, b) scanf("%lf %lf", &a, &b)
#define prd(a) printf("%lf\n", a)
#define prld(a) printf("%Lf\n", a)
#define prcase(cs) printf("Case %lld: ", cs)
#define cin1(a) cin >> a
#define cin2(a, b) cin >> a >> b
#define cin3(a, b, c) cin >> a >> b >> c
#define cin4(a, b, c, d) cin >> a >> b >> c >> d
#define cot1(a) cout << a << "\n"
#define cot2(a, b) cout << a << " " << b << "\n"
#define cot3(a, b, c) cout << a << " " << b << " " << c << "\n"
#define cot4(a, b, c, d) cout << a << " " << b << " " << c << " " << d << "\n"
#define cotline cout << "\n"
#define cotminus cout << "-1\n"
#define cot0 cout << "0\n"
#define cotyes cout << "YES\n"
#define cotno cout << "NO\n"
#define cotcase(cs) cout << "Case " << cs << ": "
#define reversed(s) reverse(s.begin(), s.end())
#define asort(s) sort(s.begin(), s.end())
#define dsort(s) sort(s.rbegin(), s.rend())
#define all(s) s.begin(), s.end()
#define uniq(s) s.resize(distance(s.begin(),unique(s.begin(), s.end())))
#define found(s, x) (s.find(x) != s.end())
#define for0(i, n) for (i = 0; i < n; i++)
#define for1(i, n) for (i = 1; i <= n; i++)
#define fora(i, a, b) for (i = a; i <= b; i++)
#define forb(i, b, a) for (i = b; i >= a; i--)
#define fori(it, s) for(auto it = s.begin(); it != s.end(); it++)
#define FR ios_base::sync_with_stdio(false);cin.tie(NULL)
#define ms(a, x) memset(a, x, sizeof a)
#define bitcount(n) __builtin_popcountll(n)
//#define pi 3.1415926536
#define pi acos(-1)
const ll INF = LLONG_MAX;
const ll SZ = 2e3+5;
const ll mod = 1e9+7;
/**
6 9
1 5
1 2
2 6
2 3
3 4
3 1
6 3
4 1
5 2
*/
ll n, m, cycle;
struct data {
ll u, v;
} edg[SZ];
vector <ll> sg, adj[SZ];
ll vis[SZ];
bool f[SZ];
void dfs(ll u, ll p) {
if(vis[u] == 2 || f[u] || cycle) return;
if(vis[u] == 1) {
cycle = 1;
return;
}
vis[u] = 1;
for(auto v: adj[u]) {
dfs(v, u);
}
vis[u] = 2;
}
int main() {
ll cs = 0, tc = 1, x, y, z, i, j, k, g, p, q, ans = 0, sum = 0, c = 0, t = 0;
// ll a, b, d;
string s, s1, s2;
cin2(n, m);
for1(i, m) {
cin2(x, y);
adj[x].pb(y);
}
for1(i, n) {
if(!vis[i]) dfs(i, 0);
}
if(!cycle) {
cotminus;
return 0;
}
for1(i, n) {
f[i] = 1;
cycle = 0;
ms(vis, 0);
for1(j, n) if(!vis[j]) dfs(j, 0);
if(!cycle) {
f[i] = 0;
sg.pb(i);
}
}
cot1(sg.size());
for(auto v: sg) cot1(v);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> ii;
typedef tuple<ll, ll, ll> iii;
typedef vector<ll> vi;
typedef vector<ii> vii;
typedef vector<iii> viii;
typedef vector<vi> vvi;
typedef vector<vii> vvii;
#define REP(i,n) for (ll i = 0; i < n; ++i)
#define REPR(i,n) for (ll i = n-1; i >= 0; --i)
#define FOR(i,m,n) for (ll i = m; i < n; ++i)
#define FORR(i,m,n) for (ll i = n-1; i >= m; --i)
#define FORE(x,xs) for (const auto& x : xs)
#define ALL(v) v.begin(), v.end()
#define CHMIN(x,y) x = min(x, y)
#define CHMAX(x,y) x = max(x, y)
const int MAX = 1010;
int N, M;
vi G[MAX];
int pos = -1;
bool vis[MAX], fin[MAX];
vi hist;
int idx[MAX];
void dfs(int v) {
vis[v] = true;
hist.push_back(v);
FORE (nv, G[v]) {
if (fin[nv]) continue;
if (vis[nv]) {
pos = nv;
return;
}
dfs(nv);
if (pos != -1) return;
}
hist.pop_back();
fin[v] = true;
}
void solve() {
REP (v, N) {
dfs(v);
if (pos != -1) break;
}
if (pos == -1) {
cout << -1 << endl;
return;
}
vi cycle;
while (!hist.empty()) {
int t = hist.back();
cycle.push_back(t);
hist.pop_back();
if (t == pos) break;
}
reverse(ALL(cycle));
while(1) {
bool done = false;
REP (i, MAX) idx[i] = -1;
REP (i, cycle.size()) idx[cycle[i]] = i;
REP (i, cycle.size()) {
int cur = cycle[i];
FORE (next, G[cur]) if (idx[next] >= 0) {
if (idx[next] == (idx[cur] + 1) % cycle.size()) continue;
vi v;
bool get = false;
for (int r = 0;; r++) {
if (cycle[r%cycle.size()] == next) get = true;
if (get){
v.push_back(cycle[r%cycle.size()]);
if (cycle[r%cycle.size()] == cur) break;
}
}
cycle = v;
done = true;
break;
}
if (done) break;
}
if (!done) break;
}
cout << cycle.size() << endl;
FORE (r, cycle) cout << r+1 << "\n";
return;
}
int main() {
cin >> N >> M;
REP (i, M) {
int a, b;
cin >> a >> b;
G[a-1].push_back(b-1);
}
solve();
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int ac = 2e5 + 5, bc = (1 << 18);
ll PR[ac];
ll CS[ac];
struct Tree
{
vector<ll> T;
Tree()
{
T.resize(bc * 2);
}
void update(int a, ll b)
{
a += bc;
T[a] = b;
while (a)
{
a /= 2;
T[a] = min(T[a * 2], T[a * 2 + 1]);
}
}
ll query(int a, int b)
{
a += bc; b += bc;
ll m = min(T[a], T[b]);
while (a / 2 != b / 2)
{
if (a % 2 == 0) m = min(m, T[a + 1]);
if (b % 2 == 1) m = min(m, T[b - 1]);
a /= 2; b /= 2;
}
return m;
}
};
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, q, a, b; cin >> n >> q >> a >> b; a--; b--;
vector<ll> Q; Q.push_back(a);
for (int i = 0; i < q; i++) { int x; cin >> x; x--; Q.push_back(x); }
ll s = 0;
for (int i = 1; i <= q; i++) CS[i] = abs(Q[i] - Q[i - 1]), s += CS[i];
Tree t1, t2;
for (int i = 0; i < n; i++) t1.update(i, (ll)1e12), t2.update(i, (ll)1e12);
t1.update(b, b); t2.update(b, -b);
for (int i = 1; i <= q; i++)
{
ll w = min(t2.query(0, Q[i]) + Q[i], t1.query(Q[i], n - 1) - Q[i]) - CS[i];
if (w < t1.query(Q[i - 1], Q[i - 1]))
{
t1.update(Q[i - 1], w + Q[i - 1]);
t2.update(Q[i - 1], w - Q[i - 1]);
}
}
ll m = 1e18;
for (int i = 0; i < n; i++)
m = min(m, t1.query(i, i) - i);
cout << m + s << '\n';
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
const int MAX = 510000;
const int MOD = 1000000007;
template <typename T,typename E>
struct SegmentTree{
using F = function<T(T,T)>;
using G = function<T(T,E)>;
using H = function<E(E,E)>;
int n,height;
F f;
G g;
H h;
T ti;
E ei;
vector<T> dat;
vector<E> laz;
SegmentTree(int n_,F f,G g,H h,T ti,E ei,vector<T> v=vector<T>()):
f(f),g(g),h(h),ti(ti),ei(ei){
init(n_);
if(n_==(int)v.size()) build(n_,v);
}
void init(int n_){
n=1;height=0;
while(n<n_) n<<=1,height++;
dat.assign(2*n,ti);
laz.assign(2*n,ei);
}
void build(int n_,const vector<T> &v){
for(int i=0;i<n_;i++) dat[n+i]=v[i];
for(int i=n-1;i;i--)
dat[i]=f(dat[(i<<1)|0],dat[(i<<1)|1]);
}
inline T reflect(int k){
return laz[k]==ei?dat[k]:g(dat[k],laz[k]);
}
inline void propagate(int k){
if(laz[k]==ei) return;
laz[(k<<1)|0]=h(laz[(k<<1)|0],laz[k]);
laz[(k<<1)|1]=h(laz[(k<<1)|1],laz[k]);
dat[k]=reflect(k);
laz[k]=ei;
}
inline void thrust(int k){
for(int i=height;i;i--) propagate(k>>i);
}
inline void recalc(int k){
while(k>>=1)
dat[k]=f(reflect((k<<1)|0),reflect((k<<1)|1));
}
void update(int a,int b,E x){
if(a>=b) return;
thrust(a+=n);
thrust(b+=n-1);
for(int l=a,r=b+1;l<r;l>>=1,r>>=1){
if(l&1) laz[l]=h(laz[l],x),l++;
if(r&1) --r,laz[r]=h(laz[r],x);
}
recalc(a);
recalc(b);
}
void set_val(int a,T x){
thrust(a+=n);
dat[a]=x;laz[a]=ei;
recalc(a);
}
T query(int a,int b){
if(a>=b) return ti;
thrust(a+=n);
thrust(b+=n-1);
T vl=ti,vr=ti;
for(int l=a,r=b+1;l<r;l>>=1,r>>=1) {
if(l&1) vl=f(vl,reflect(l++));
if(r&1) vr=f(reflect(--r),vr);
}
return f(vl,vr);
}
template<typename C>
int find(int st,C &check,T &acc,int k,int l,int r){
if(l+1==r){
acc=f(acc,reflect(k));
return check(acc)?k-n:-1;
}
propagate(k);
int m=(l+r)>>1;
if(m<=st) return find(st,check,acc,(k<<1)|1,m,r);
if(st<=l&&!check(f(acc,dat[k]))){
acc=f(acc,dat[k]);
return -1;
}
int vl=find(st,check,acc,(k<<1)|0,l,m);
if(~vl) return vl;
return find(st,check,acc,(k<<1)|1,m,r);
}
template<typename C>
int find(int st,C &check){
T acc=ti;
return find(st,check,acc,1,0,n);
}
};
SegmentTree<int,int> seg(200003, [](int a,int b){return max(a,b);},
[](int a,int b){return b;},[](int a,int b){return b;},0,0);
signed main(){
int n,q;
cin>>n>>q;
int x[q+2],y[q+2]={},ans=0;
for(int i=0;i<q+2;i++)cin>>x[i];
auto f = [&](int a,int z) -> int{
if(a==0)return 0;
return abs(z-x[q+2-a])+y[q+2-a];
};
for(int i=1;i<=q;i++){
y[q+2-i]+=f(seg.query(x[q+1-i],x[q+1-i]+1),x[q+1-i])-abs(x[q+2-i]-x[q+1-i]);
ans+=abs(x[q+2-i]-x[q+1-i]);
int ok=x[q+1-i],ng,mid;
if(x[q+2-i]>x[q+1-i]){
ng=n+1;
while(abs(ok-ng)>1){
mid=(ok+ng)/2;
if(f(i,mid)<=f(seg.query(mid,mid+1),mid))ok=mid;
else ng=mid;
}
seg.update(x[q+1-i],ng,i);
}else{
ng=0;
while(abs(ok-ng)>1){
mid=(ok+ng)/2;
if(f(i,mid)<=f(seg.query(mid,mid+1),mid))ok=mid;
else ng=mid;
}
seg.update(ok,x[q+1-i],i);
}
}
cout<<ans+f(seg.query(x[0],x[0]+1),x[0])<<endl;
}
| 1 |
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <cmath>
#include <set>
#include <algorithm>
#include <iomanip>
typedef long long ll;
const ll MOD = 1e9 + 7;
const long long INF = 1LL<<60;
const double PI=3.14159265358979323846;
const int NMAX=100005;
using namespace std;
int main(){
int n;
cin >> n;
vector<vector<pair<int,int>>> a(n);
for(int i = 0; i < n; i++){
int an;
cin >> an;
for(int j = 0; j < an; j++){
int x,y;
cin >> x >> y;
x--;
a[i].push_back({x,y});
}
}
int ans = 0;
for(int i = 0; i < (2<<n); i++){
vector<bool> honest(n,false);
int cnt = 0;
for(int j = 0; j < n; j++){
if((i>>j) & 1){
honest[j] = true;
cnt++;
}
}
for(int j = 0; j < n; j++){
if(honest[j] == false) continue;
for(int k = 0; k < a[j].size(); k++){
int x = a[j][k].first;
int y = a[j][k].second;
if((honest[x] == false && y == 1) ||
(honest[x] == true && y == 0)){
cnt = -1;
break;
}
}
if(cnt == -1) break;
}
ans = max(ans, cnt);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1<<29;
enum Face : int { Top, Front, Right, Left, Back, Bottom };
struct cube {
int f[6];
unordered_map<int, string> mp;
cube(){}
/*
1(Top)
4(Left) 2(Front) 3(Right) 5(Back)
6(Bottom)
*/
cube(vector<int> const& vs){ for(int i=0; i<6; i++) f[i] = vs[i]; }
cube(vector<string> const& vs) { for(int i=0; i<6; i++) mp[i+1] = vs[i]; }
void roll_z() { roll(1, 2, 4, 3); }
void roll_y() { roll(0, 2, 5, 3); }
void roll_x() { roll(0, 1, 5, 4); }
void roll(int i, int j, int k, int l) {
int t = f[i]; f[i] = f[j]; f[j] = f[k]; f[k] = f[l]; f[l] = t;
}
void roll(int k) {
if(k == 0) roll_y();
if(k == 1) roll_x();
if(k == 2) for(int i=0; i<3; i++) roll_y();
if(k == 3) for(int i=0; i<3; i++) roll_x();
}
bool roll_top_front(int top, int front) {
for(int k = 0; k < 6; (k & 1 ? roll_y() : roll_x()), k++)
for(int i = 0; i < 4; roll_z(), ++i)
if(top == f[Top] && front == f[Front]) return true;
return false;
}
bool operator== (cube const& rhs) const {
for(int i=0; i<6; i++)
if(f[i] != rhs.f[i]) return false;
return true;
}
bool isomorphic(cube rhs) const {
for(int k = 0; k < 6; (k & 1 ? rhs.roll_y() : rhs.roll_x()), k++)
for(int i = 0; i < 4; rhs.roll_z(), ++i)
if(operator==(rhs)) return true;
return false;
}
};
int main() {
int N; cin >> N;
vector<cube> cs(N); rep(i, N) rep(j, 6) cin >> cs[i].f[j];
cout << ([&]() {
rep(i, N) REP(j, i+1, N)
if(cs[i].isomorphic(cs[j])) return false;
return true;
}() ? "Yes\n" : "No\n");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
vector<vector<ll>> cnt(62, vector<ll>(62, 0));
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (find(s.begin(), s.end(), '.') == s.end()) s.push_back('.');
int pos = 0;
while (s[pos] != '.') pos++;
s += string(10 - s.size() + pos, '0');
ll y = 0;
for (auto c : s) {
if (isdigit(c)) y = y * 10 + c - '0';
}
int p2 = 0, p5 = 0;
for (; y % 2 == 0; y /= 2, p2++);
for (; y % 5 == 0; y /= 5, p5++);
cnt[p2][p5]++;
}
ll ans = 0;
for (int p2 = 0; p2 < 62; p2++) {
for (int p5 = 0; p5 < 62; p5++) {
for (int pp2 = 0; pp2 < 62; pp2++) {
for (int pp5 = 0; pp5 < 62; pp5++)
ans += cnt[p2][p5] * cnt[pp2][pp5] * (min(p2 + pp2, p5 + pp5) >= 18) *
(pair<int, int>{p2, p5} != pair<int, int>{pp2, pp5});
}
}
}
for (int p2 = 0; p2 < 62; p2++) {
for (int p5 = 0; p5 < 62; p5++) ans += cnt[p2][p5] * (cnt[p2][p5] - 1) * (min(p2, p5) * 2 >= 18);
}
cout << ans / 2 << '\n';
}
| #include <bits/stdc++.h>
using namespace std;
template<class T> ostream& operator<<(ostream &os, vector<T> V) { os << "[ ";
for(auto v:V)os << v << " "; return os << "]";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){ os << "{ ";
for(auto s:S) os<<s<<" "; return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
return os<<"("<<P.first<<","<< P.second << ")";
}
template<class L, class R> ostream& operator<<(ostream &os, map<L,R> M) {
os<<"{ ";for(auto m:M)os<<"("<<m.first<<":"<<m.second<<")";
return os<<"}";
}
#define cerr cout
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...) 1
#endif
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// #define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
// find_by_order(k) returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;
//For multiset use less_equal operator but it does support erase operations for multiset
#define ll long long
#define ld long double
#define vll vector<ll>
#define pll pair<ll,ll>
#define vpll vector<pll>
#define I insert
#define pb push_back
#define F first
#define S second
#define endl "\n"
#define all(v) (v).begin(),(v).end()
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef pair<pii,int> ppi;
typedef vector<pii> vpii;
#define fio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define mp make_pair
const int mod = 1e9+7;
inline int add(int a,int b){a+=b;if(a>=mod)a-=mod; return a;}
inline int sub(int a,int b){a-=b;if(a<0) a += mod; return a;}
inline int mul(int a, int b){ return a*1ll*b%mod;}
inline int power(int x, ll y){
int res = 1;
while(y){
if(y&1) res = mul(res , x);
x = mul(x,x);
y >>= 1;
}
return res;
}
pii sovle(ll n){
int a = 0 , b = 0;
while(n%2 == 0){
++a;
n /= 2;
}
while(n%5 == 0){
++b;
n /= 5;
}
return mp(a,b);
}
const int N = 18;
ll pwr[N];
int main(){
fio; cout<<fixed<<setprecision(25);
pwr[0] = 1;
for(int i = 1;i < N ; ++i) pwr[i] = pwr[i-1]*10;
int n; cin >> n;
map<pii,ll> m;
string s;
for(int i =1 ;i <= n ; ++i){
cin >> s;
int id = -1;
int j = 0;
for(auto it :s){
if(it == '.'){
id = j;
break;
}
++j;
}
ll a = 1 , b = 1;
if(id == -1){
a = stoll(s);
}
else{
int len = s.size()-j-1;
b = pwr[len];
s.erase(s.begin()+id);
a = stoll(s);
}
ll gd = __gcd(a,b);
a /= gd;
b /= gd;
pll p1 = sovle(a);
pll p2 = sovle(b);
p1.F -= p2.F;
p1.S -= p2.S;
m[p1]++;
}
ll ans = 0;
for(auto &it : m){
for(auto &it2 : m){
if(it.F.F+it2.F.F >= 0 && it.F.S+it2.F.S >= 0){
ans += it.S*it2.S;
if(it == it2)
ans -= it.S;
}
}
}
cout << ans/2 << endl;
return 0;
}
| 1 |
// AtCoder Beginner Contest 167 - Problem F: Bracketing Sequencing (https://atcoder.jp/contests/abc167/tasks/abc167_f)
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<ll, ll>;
string solve(int N, const vector<string>& xs)
{
vector<int> cs;
vector<ii> ds, es;
int open = 0, close = 0;
for (int i = 0; i < N; ++i)
{
int a = 0, b = 0;
for (auto c : xs[i])
{
open += (c == '(' ? 1 : 0);
close += (c == ')' ? 1 : 0);
b += (c == '(' ? 1 : -1);
if (b < 0)
{
a--;
b = 0;
}
}
if (b + a >= 0)
ds.push_back(ii(-a, i));
else
es.push_back(ii(b, i));
}
if (open != close)
return "No";
sort(ds.begin(), ds.end());
sort(es.begin(), es.end(), greater<ii>());
int s = 0;
for (auto p : ds)
{
auto i = p.second;
for (auto c : xs[i])
{
s += (c == '(' ? 1 : -1);
if (s < 0)
return "No";
}
}
for (auto p : es)
{
auto i = p.second;
for (auto c : xs[i])
{
s += (c == '(' ? 1 : -1);
if (s < 0)
return "No";
}
}
return "Yes";
}
int main()
{
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<string> xs(N);
for (int i = 0; i < N; ++i)
cin >> xs[i];
auto ans = solve(N, xs);
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vii;
typedef vector<ll> vll;
typedef pair<ll,ll> pii;
#define pb push_back
#define odd(x) ((x)&1)
#define even(x) (!odd(x))
#define ff it->first
#define ss it->second
#define all(v) (v).begin(),(v).end()
#define rep(i,n) for(auto i=0;i<n;++i)
#define LOOP_IT(it,s) for(auto it=(s).begin();it!=(s).end();++it)
#define FASTIO ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#ifdef LOCAL
#define cerr cout
#else
#endif
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cerr.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
vector<pii> v;
pii fxn(string s)
{
ll n = s.size();
ll cnt=0;
ll x=0,y=0;
rep(i,n)
{
if(s[i]=='(')
++cnt;
else
--cnt;
if(cnt<0)
{++x;cnt=0;}
}
y = cnt;
pii p = {x,y};
return p;
}
bool cmp1(pii a,pii b)
{
if(a.first!=b.first)
return (a.first<b.first);
return (a.second>b.second);
}
bool cmp2(pii a,pii b)
{
if(a.second!=b.second)
return (a.second>b.second);
return (a.first<b.first);
}
bool chk(vector<pii> &v)
{
ll sum=0;
ll n = v.size();
for(auto p:v)
{
sum-=p.first;
if(sum<0)
{
return false;
}
sum+=p.second;
}
if(sum)
{
return false;
}
for(ll i=n-1;i>=0;--i)
{
pii p = v[i];
sum+=p.first;
sum-=p.second;
if(sum<0)
{
return false;
}
}
if(sum)
{
return false;
}
return true;
}
bool cmp3(pii a,pii b)
{
ll x = a.second-a.first;
ll y = b.second-b.first;
return (x>y);
}
int main(int argv, char* argc[])
{
FASTIO
ll n;
cin>>n;
string s[n];
v.resize(n);
rep(i,n)
{
cin>>s[i];
v[i] = fxn(s[i]);
}
sort(all(v),cmp3);
ll ind =-1;
for(ll i=0;i<n;++i)
{
if(v[i].second-v[i].first<=0)
{
ind = i;break;
}
}
if(ind==-1)
goto label;
sort(v.begin(),v.begin()+ind,cmp1);
sort(v.begin()+ind,v.end(),cmp2);
if(chk(v))
{
cout<<"Yes";
return 0;
}
label:
cout<<"No";
return 0;
}
| 1 |
///f. fizzbuzz sequence
#include <stdio.h>
#include <math.h>
int main()
{
long long int n;
scanf("%lld",&n);
long long int d3,d5,d15;
d3=n/3; d5=n/5; d15=n/15;
long long sum = (n*(n+1)-3*d3*(d3+1)-5*d5*(d5+1)+15*d15*(d15+1))/2;
printf("%lld",sum);
return 0;
} | #include <iostream>
#include <vector>
#include <map>
#include <cmath>
using namespace std;
#define MOD 1000000007;
void solve(){
int n; cin >> n;
long long ans = 1;
vector<int> pn;
map<int, int> mp;
for(int i = 2; i <= n; ++i){
int cnt = 0;
for(int j = 1; j <= i; ++j){
if(i % j == 0)cnt++;
}
if(cnt == 2) pn.push_back(i);
}
for(int i = 2; i <= n; ++i){
int tmp = i;
while(tmp !=1){
for(auto p : pn){
if(tmp%p == 0) {
mp[p]++;
tmp/=p;
if(tmp == 1)break;
}
}
}
}
for(auto m: mp){
ans *= (m.second+1);
ans %= MOD;
}
cout << ans << endl;
}
int main(){
solve();
return 0;
} | 0 |
#include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const LL INF = 0x3f3f3f3f3f3f3f3fLL;
const LL MOD = 1e9 + 7;
const int MAXV = 1e5 + 5;
double solve(int a, int b, int c, auto &dp, int n) {
if (dp[a][b][c] != -1) return dp[a][b][c];
double sum = 0;
if (a - 1 >= 0)
sum += solve(a - 1, b, c, dp, n) / n * a;
if (b - 1 >= 0)
sum += solve(a + 1, b - 1, c, dp, n) / n * b;
if (c - 1 >= 0)
sum += solve(a, b + 1, c - 1, dp, n) / n * c;
sum++;
sum *= n, sum /= a + b + c;
return dp[a][b][c] = sum;
}
void marmot0814() {
int n; cin >> n;
vector<LL> cnt(3, 0);
for (int i = 0 ; i < n ; i++) {
int v; cin >> v; v--;
cnt[v]++;
}
vector<vector<vector<double>>> dp(n + 1, vector<vector<double>>(n + 1, vector<double>(n + 1, -1)));
dp[0][0][0] = 0;
cout << fixed << setprecision(20) << solve(cnt[0], cnt[1], cnt[2], dp, n) << '\n';
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
int t = 1, kase = 0; // cin >> t;
while (t--) {
// cout << "Case #" << ++kase << ":";
marmot0814();
}
} | /* Bismillahir Rahmanir Rahim */
#include<bits/stdc++.h>
#include<vector>
#include<cmath>
#include<string>
#include<stdlib.h>
#define mod 1000000007
#define lp(i,a,b) for(ll i=a;i<=b;i++)
#define ll long long int
#define ull unsigned long long int
#define tst int t;cin>>t;while(t--)
#define pb push_back
#define vi(v) vector<int>v;
#define vl(v) vector<ll>v;
#define vs vector<string>v
#define rslt(x) cout<<x<<endl;
#define mp(x,y) make_pair(x,y)
#define yes rslt("YES");
#define no cout<<"NO"<<endl;
#define srt(v) sort(v.begin(),v.end())
#define rvs(v) reverse(v.begin(),v.end());
#define AR ios::sync_with_stdio(false);cin.tie(0);
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) (a/gcd(a,b))*b
#define max 1000007
#define str int s[200000];
#define coutv(v) for(auto it:v)cout<<it<<' ';cout<<endl;
#define cinv(v) for(auto &it:v)cin>>it;
using namespace std;
int main()
{
ll n,x=0;
str
cin>>n;
ll cnt=0;
lp(i,0,n-1)
cin>>s[i];
sort(s,s+n);
for(int i=0; i<n-2; i++)
{
for(int j=i+1; j<n-1; j++)
{
for(int k=j+1; k<n; k++)
{
x=0;
if(s[i]!=s[j] && s[j]!=s[k])
{
if(s[i]+s[j]>s[k])
x++;
if(s[i]+s[k]>s[j])
x++;
if(s[j]+s[k]>s[i])
x++;
if(x==3)
cnt++;
}
}
}
}
cout<<cnt<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(long long i=0; i<n; i++)
#define Rep(i,n) for(long long i=1; i<n; i++)
#define ll long long
#include <math.h>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define PI acos(-1)
int main(){
ll N;
cin>>N;
cout<<2*N*PI<<endl;
return 0;
}
| #include <iostream>
using namespace std;
int main()
{
int x, coin500, coin5;
cin >> x;
coin500 = x / 500;
x -= coin500 * 500;
coin5 = x / 5;
cout << coin500 * 1000 + coin5 * 5 << endl;
return 0;
} | 0 |
#include <cstdio>
#include <cstring>
using namespace std;
const int Max_L(50);
typedef long long int LL;
int L, len, D[Max_L], N[Max_L], X[Max_L];
char input[Max_L];
LL Ans;
int work(int p, int x)
{
int Ret(0);
for (int c = (p == len - 1 ? 1 : 0);c <= 9;++c)
if (0 <= c - x && c - x <= 9)
++Ret;
return Ret;
}
bool check()
{
for (int i = len - 1, j;i >= 0;--i)
{
X[j = i] = N[i];
while (X[j] < 0)
{
if (j == len - 1)
return false;
X[j] += 10, --X[++j];
}
}
for (int i = 0;i <= len - 1;++i)
if (X[i] != D[i])
return false;
return true;
}
void dfs(int p, int a, int b, int v, LL Ret = 1LL)
{
if (!Ret)
return;
if (a <= b)
{
if (a == b)
Ret *= work(a, 0);
if (check())
Ans += Ret;
return;
}
int x = (D[p] + v) % 10;
if (x == 0)
if (D[p] + v == 0)
N[p] = 0, N[len - 1 - p] = 0, dfs(p + 1, a - 1, b + 1, 0, Ret * work(a, 0));
else
N[p] = 0, N[len - 1 - p] = 0, dfs(p + 1, a - 1, b + 1, 1, Ret * work(a, 0));
else
{
N[p] = x, N[len - 1 - p] = -x, dfs(p + 1, a - 1, b + 1, 0, Ret * work(a, x));
N[p] = x - 10, N[len - 1 - p] = 10 - x, dfs(p + 1, a - 1, b + 1, 1, Ret * work(a, x - 10));
}
}
int main()
{
scanf("%s", input), L = strlen(input);
for (int i = 0;i <= L - 1;++i)
D[i] = input[L - 1 - i] - '0';
for (len = L;len <= 19;++len)
memset(N, 0, sizeof(N)), dfs(0, len - 1, 0, 0);
printf("%lld", Ans);
return 0;
} | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <locale>
#include <iostream>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define ALL(x) (x).begin(),(x).end()
using namespace std;
using ll = long long;
using ld = long double;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> int len(const T &x) { return x.size(); }
template<typename T>
vector<T> table(int n, T v) { return vector<T>(n, v); }
template <class... Args>
auto table(int n, Args... args) {
auto val = table(args...);
return vector<decltype(val)>(n, move(val));
}
struct yes_no : numpunct<char> {
string_type do_truename() const { return "YES"; }
string_type do_falsename() const { return "NO"; }
};
ll tens[32];
ll dp(const int digit, const ll D, bool zero) {
if (digit == 1) return (D == 0 ? 10 : 0);
if (digit == 0) return (D == 0 ? 1 : 0);
if (abs(D) > tens[digit]) return 0;
ll res = 0;
for (int diff = -9; diff <= 9; ++diff) {
int count = 10 - abs(diff) - (zero ? 1 : 0);
ll nD = D - diff * (tens[digit - 1] - 1);
if (nD % 10 == 0) res += dp(digit - 2, nD / 10, false) * count;
}
return res;
}
void solve(const ll D) {
tens[0] = 1;
REP(i,18) tens[i + 1] = tens[i] * 10;
ll res = 0;
for (int digit = 1; digit <= 18; ++digit) {
res += dp(digit, D, true);
}
cout << res << endl;
}
int main() {
locale loc(locale(), new yes_no);
cout << boolalpha << setprecision(12) << fixed;
cout.imbue(loc);
ll D;
scanf("%lld", &D);
solve(D);
return 0;
}
| 1 |
#include<iostream>
#include<iomanip>
#include<queue>
#include<string>
#include<stack>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<cstring>
#include<cassert>
#include<ctime>
#include<algorithm>
#include<utility>
#include<map>
#include<set>
#include<vector>
#include<functional>
using namespace std;
#ifdef DEBUG
#define dprintf printf
#define dout(x) cout<<#x" = "<<(x)<<endl
#define darray(x,n) {int i;rep(i,n)cout<<#x"["<<i<<"] = "<<*((x)+i)<<endl;}
#define dloop(i,s,g) for((i)=(s);(i)<(g);(i)++)
#define drep(i,n) for((i)=0;(i)<(n);(i)++)
#define dstop() scanf("%*c")
#else
#define dprintf (1)?0:printf
#define dout(x)
#define darray(x,n)
#define dloop(i,s,g) if(1){}else
#define drep(i,n) if(1){}else
#define dstop() if(1){}else
#endif
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define loop(i,s,g) for((i)=(s);(i)<(g);(i)++)
#define rep(i,n) for((i)=0;(i)<(n);(i)++)
#define all(x) (x.begin(),x.end())
#define in(T,...) T __VA_ARGS__; impl(__VA_ARGS__);
#define array(T,id,n) T id[n]; rep(i,n)cin>>id[i];
//#define int long long;
#ifndef int
#define INF (0x7fffffff)
#else
#define LINF (0x7fffffffffffffff)
#endif
typedef long long ll;
typedef unsigned ui;
typedef unsigned long long ull;
typedef pair<int,int> i_i;
typedef pair<ll,int> ll_i;
typedef pair<ll,ll> ll_ll;
typedef pair<double,int> d_i;
typedef pair<double,double> d_d;
void impl(){};
template <typename T,typename... TS >
void impl(T &head,TS &... tail)
{
cin>>head;
impl(tail ...);
}
#define UNION_FIND_MAX_N (112345)
int union_find_par[UNION_FIND_MAX_N];
int union_find_rank[UNION_FIND_MAX_N];
void init(int n)
{
int i;
for(i=0;i<n;i++)
{
union_find_par[i]=i;
union_find_rank[i]=0;
}
}
int find(int x)
{
if(union_find_par[x]==x)
return x;
else
return union_find_par[x]=find(union_find_par[x]);
}
void unite(int x,int y)
{
x=find(x);
y=find(y);
if(x==y)
return;
if(union_find_rank[x]<union_find_rank[y])
union_find_par[x]=y;
else
union_find_par[y]=x;
if(union_find_rank[x]==union_find_rank[y])
union_find_rank[x]++;
}
int nsame(int x,int y)
{
return find(x)!=find(y);
}
typedef struct edge
{
int u;
int v;
int cost;
bool operator>(const edge&right)const
{
return cost>right.cost;
}
bool operator<(const edge&right)const
{
return cost<right.cost;
}
}Edge;
signed main(void)
{
int n;
Edge edge[112345]={};
int i,j,k=0;
int sum=0;
cin>>n;
init(n);
rep(i,n)rep(j,n)
{
cin>>edge[k].cost;
edge[k].u=i;
edge[k].v=j;
k++;
}
sort(edge,edge+k);
rep(i,k)
if(edge[i].cost!=-1)
if(nsame(edge[i].u,edge[i].v))
unite(edge[i].u,edge[i].v),sum+=edge[i].cost;
cout<<sum<<endl;
return 0;
} | #include<bits/stdc++.h>
#include<ctype.h>
# define pb push_back
#define fst first
#define sec second
#define For(i,a,b) for(int i=a;i<b;i++)
#define ll long long int
#define ull unsigned long long int
#define mod 1000000007
#define fo(i,n) for(ll i=0;i<n;i++)
#define endl "\n"
#define rev(i,n) for(ll i=n-1;i>=0;i--)
#define fo1(i,n) for(ll i=1;i<=n;i++)
#define boolsize 1000001
#define pi pair<ll,ll>
#define vi vector<ll>
#define vii vector<pi>
using namespace std;
template<typename T>
void showvector(vector <T> v)
{
for(T x:v)
cout<<x<<" ";
cout<<endl;
}
template<typename T>
void showvector1(vector <T> v)
{
ll n=v.size();
fo1(i,n-1)
cout<<v[i]<<endl;
}
template<typename T>
void showset(set <T> s)
{
for(T x: s)
cout<<x<<" ";
cout<<endl;
}
template<class T>
void showvectorpair(vector<T> v)
{
for(auto it=v.begin();it!=v.end();it++)
cout<<it->first<<" "<<it->second<<endl;
cout<<endl;
}
template<typename T,typename P>
void showmap(map <T,P> m)
{
for(auto it=m.begin();it!=m.end();it++)
cout<<it->first<<" "<<it->second<<endl;
cout<<endl;
}
template<typename T>
bool comp(T a,T b)
{
return (a>b);
}
template<class T>
bool comppair(T a,T b)
{
if(a.first==b.first)
return(a.second>b.second);
return (a.first>b.first);
}
bool sameparity(ll a,ll b)
{
return (a%2==b%2);
}
bool difparity(ll a,ll b)
{
return !(a%2==b%2);
}
bool isprime(ll x)
{ if(x<=1)
return false;
for(ll i=2;i<=sqrt(x);i++)
{
if(x%i==0)
return false;
}
return true;
}
bool iseven(ll x)
{
return !(x%2);
}
bool isodd(ll x)
{
return (x%2);
}
//vector <bool> prime(boolsize,1);
//void seive()
//{
// ll n=boolsize;
// prime[0]=prime[1]=0;
// for(ll i=2;i<=sqrt(boolsize);i++)
// {
// if(prime[i]==1)
// {
// for(ll j=i*i;j<=n;j+=i)
// {
// prime[j]=0;
// }
// }
// }
//}
/// check for test case before submitting
void vfun()
{
ll n,k;
cin>>n>>k;
vi v(n);
fo(i,n)
cin>>v[i];
sort(v.begin(),v.end(),comp<ll>);
ll sum=0;
fo(i,k)
sum+=v[i];
cout<<sum<<endl;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0); ///cant use scanf, printf
cin.tie(0);cout.tie(0); /// no longer auto flush cout before each cin, remove for interactive
//cout << fixed << setprecision(11); /// no scientific output
ll test=1;
//cin>>test;
while(test--)
{
//fun();
vfun();
// if(vfun())
// cout<<"YES\n";
// else
// cout<<"NO\n";
}
}
///before sub
/// check for value of zero and single input in array
///loop vars,1LL in mult, equal, one, bounds, int v ll, endl, finish taking inputs
/// check whether test cases are given or not
| 0 |
/**
* @copyright (c) 2020 Daisuke Hashimoto
*/
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using Pair = pair<int64_t, int64_t>;
// std::cout << std::setprecision(20) << 1.1 << endl;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int64_t N;
string s, t;
cin >> N >> s >> t;
int64_t overwrap = 0;
for (int64_t ov = 1; ov <= N; ++ov) {
if (s.substr(N - ov, ov) == t.substr(0, ov)) {
overwrap = ov;
}
}
// const int64_t L = static_cast<int64_t>(T.length());
cout << (N * 2 - overwrap) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
const int N=2e2+5,mod=1e9+7;
ll n,m,k,dp[N][N],num[N][N];
int main(){
cin>>n>>m>>k;
for(int s=0;s<(1<<(m-1));s++){
bool ok=true;
for(int j=0;j<m-1;j++){
int b1=(s>>j)&1;
int b2=(s>>(j+1))&1;
if(b1==b2&&b1) ok=false;
}
if(!ok) continue;
for(int j=0;j<m;){
if((s>>j)&1){
num[j][j+1]++,num[j+1][j]++;
j+=2;
}
else{
num[j][j]++;
j++;
}
}
}
dp[0][0]=1;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
for(int p=0;p<m;p++) dp[i+1][p]=(dp[i+1][p]+(dp[i][j]*num[j][p])%mod)%mod;
cout<<dp[n][k-1]<<'\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
#define int long long
using namespace std;
int dp[111][111],n,L[111],R[111];
int dfs(int l,int r){
if(dp[l][r]!=-1)return dp[l][r];
if(l==r)return dp[l][r]=0;
int res=1e17;
for(int i=l;i<r;i++){
res=min(res,dfs(l,i)+dfs(i+1,r)+L[l]*R[i]*R[r]);
}
return dp[l][r]=res;
}
signed main(){
memset(dp,-1,sizeof(dp));
cin>>n;
r(i,n)cin>>L[i]>>R[i];
dfs(0,n-1);
cout<<dp[0][n-1]<<endl;
}
| #include <stdio.h>
#define INF 10000000
int main(){
int n,i,j,k,l,t,m[101],c,o;
int mm[101][101];
scanf("%d",&n);
for(i = 1 ; i < n+1; i++){
scanf("%d%d",&m[i-1],&m[i]);
}
for( i = 1 ; i <= n ; i++ ){
mm[i][i] = 0;
}
for(l = 2 ; l <n+1 ; l++){
for(i=1;i<n-l+2;i++) {
o=i+l-1;
mm[i][o] = INF;
for(k = i ; k < o ; k++){
t=mm[i][k] + mm[k+1][o] + m[i-1] * m[k] *m[o];
if(t < mm[i][o])
mm[i][o] = t;
}
}
}
printf("%d\n",mm[1][n]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T, class U> using Pa = pair<T, U>;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
int main(){
int X,Y;
cin >> X >> Y;
int ans = 2e9+1;
for(int i=0;i<2;i++) for(int j=0;j<2;j++){
int x = (i? -X:X),y = (j? -Y:Y);
if(x<=y) ans = min(ans,i+j+y-x);
}
cout << ans << "\n";
} | #include <bits/stdc++.h>
#include <vector>
#include <math.h>
using namespace std;
int main(){
long long x,y;
cin>>x>>y;
if(x*y < 0) cout<<abs(abs(x) - abs(y))+1<<endl;
else if(x*y == 0){
if(x<y) cout<<y-x<<endl;
else cout<<x-y+1<<endl;
}
else {
if(x<y) cout<<y-x<<endl;
else
cout<<x-y+2<<endl;
}
return 0;
}
| 1 |
#include <iostream>
using namespace std;
void solve()
{
int l[10];
while(cin >> l[0])
{
for(int i = 1; i <= 9; ++i)
{
scanf(",%d", &l[i]);
}
int v[2];
scanf(",%d,%d", &v[0], &v[1]);
int sum = 0;
for(int i = 0; i < 10; ++i)
{
sum += l[i];
}
double time = (double)sum / (v[0] + v[1]);
double dist = time * (double)v[0];
int pos = 0;
int d = 0;
while(true)
{
d += l[pos];
if(d >= dist)
{
cout << pos + 1 << endl;
break;
}
++pos;
}
}
}
int main()
{
solve();
return(0);
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
int main() {
int n,k;
cin >> n >> k;
vector<int> l(n);
for (int i = 0; i < n; i++)
{
cin >> l[i];
}
sort(l.begin(),l.end());
reverse(l.begin(),l.end());
int x = 0;
for (int i = 0; i < k; i++)
{
x += l.at(i);
}
cout << x << endl;
return 0;
} | 0 |
#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 (int i = j; i < (int)(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
signed main(){
int s; cin>>s;
cout<<s/3;
return 0;
} | // A - Rated for Me
#include <bits/stdc++.h>
using namespace std;
int main(){
int r; cin>>r;
string ans = "ARC";
if(r < 1200) ans = "ABC";
if(2800 <= r) ans = "AGC";
cout<< ans <<endl;
}
| 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;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define per1(i,n) for(int i=n;i>0;i--)
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef pair<ll,ll> P;
typedef vector<ll> vec;
typedef vector<vec> mat;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n,m,d;
cin>>n>>m>>d;
cout<<setprecision(10)<<(double)(n-d)*(m-1)/n/n*(2-(!d));
} | #include<stdio.h>
#include<math.h>
int main(){
double a,b,c,d;
scanf("%lf %lf %lf %lf",&a,&b,&c,&d);
printf("%.8lf\n",sqrt(pow(c-a,2.0)+pow((d-b),2.0)));
} | 0 |
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPS(I, a, b) for (int i = (a); i < (b); ++i)
using namespace std;
using ll = long long;
int main() {
string s;
cin >> s;
bool ok = false;
REP(i,3){
if(s[i] == '7') ok = true;
}
if(ok) cout << "Yes" << endl;
else cout << "No" << 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() {
string s;
cin >> s;
rep(i, s.size()-8) cout << s[i];
cout << endl;
return 0;
} | 0 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <cmath>
#include <iomanip>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<long long>;
template<class T>using vv = vector<vector<T>>;
using vvi = vv<int>;
using vvl = vv<long long>;
#define in(v) v; cin >> v;
void ins() {}
template<class T,class... Rest>void ins(T& v,Rest&... rest){cin>>v;ins(rest...);}
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) for(int i=0,_i=(n);i<_i;++i)
#define repi(i,a,b) for(int i=(a),_i=(b);i<_i;++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(f,c,...) (([&](decltype((c)) cccc) { return (f)(begin(cccc), end(cccc), ## __VA_ARGS__); })(c))
// debug
template<class T>ostream& operator<<(ostream& os,const vector<T>& vec){os<<"{";for(size_t i=0;i<vec.size();++i)os<<(i?", ":"")<<vec[i];os<<"}";return os;}
ostream& operator<<(ostream& os,const vector<char>&v){for(size_t i=0;i<v.size();++i)os<<v[i];return os;}
template<class T1,class T2>ostream& operator<<(ostream& os,const pair<T1,T2>& rhs){os<<"("<<rhs.first<<", "<<rhs.second<<")";return os;}
#ifdef LOCAL
void debug() {cerr << "\n";}
template<class First> void debug(const First& first) {cerr<<first<<"\n";}
template<class First, class... Rest> void debug(const First& first, const Rest&... rest) {cerr<<first<<",";debug(rest...);}
void debug2() {cerr << "\n";}
template<class First> void debug2(const First& first) {cerr<<first<<" ";}
template<class First, class... Rest> void debug2(const First& first, const Rest&... rest) {cerr<<first<<" ";debug2(rest...);}
#else
#define debug(...) 42
#define debug2(...) 42
#endif
int N;
vv<int> A;
ll dp[1<<16][16];
const ll INF = 1e15;
ll dfs(int used, int i) {
if (i == N)
return 0;
if (dp[used][i] != INF)
return dp[used][i];
if (used & (1 << i))
return dfs(used, i+1);
ll ans = 0;
vi notUsed;
rep(j, N)
if (!(used & (1 << j))) {
if (j < i)
return -INF;
notUsed.push_back(j);
}
rep(bit, 1 << (notUsed.size())) {
ll tmp = 0;
int used2 = 0;
rep(j, notUsed.size()) {
if (bit & (1 << j)) {
used2 |= 1 << notUsed[j];
rep(k, j+1, notUsed.size()) {
if (bit & (1 << k))
tmp += A[notUsed[j]][notUsed[k]];
}
}
}
ans = max(ans, tmp + dfs(used | used2, i+1));
}
return dp[used][i] = ans;
}
int main() {
in(N);
A.resize(N, vector<int>(N, 0));
rep(i, 1<<16) rep(j, 16) dp[i][j] = INF;
rep(i, N) rep(j, N) {
cin >> A[i][j];
}
cout << dfs(0, 0) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const LL INF = 0x3f3f3f3f3f3f3f3fLL;
const LL MOD = 1e9 + 7;
LL cal(int S, auto &arr, auto &sum) {
if (~sum[S]) return sum[S];
sum[S] = 0; int n = arr.size();
for (int i = 0 ; i < n ; i++)
for (int j = i + 1 ; j < n ; j++)
if (((S >> i) & 1) & ((S >> j) & 1))
sum[S] += arr[i][j];
return sum[S];
}
LL solve(int S, auto &dp, auto &arr, auto &sum) {
if (~dp[S]) return dp[S];
dp[S] = 0;
for (int s = S ; s ; s = (s - 1) & S)
dp[S] = max(dp[S], solve(S ^ s, dp, arr, sum) + cal(s, arr, sum));
return dp[S];
}
void marmot0814() {
int n; cin >> n;
vector<vector<LL>> arr(n, vector<LL>(n));
for (auto &vv : arr)
for (auto &v : vv)
cin >> v;
vector<LL> dp(1 << n, -1); dp[0] = 0;
vector<LL> sum(1 << n, -1);
cout << solve((1 << n) - 1, dp, arr, sum) << '\n';
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
int t = 1, kase = 0; // cin >> t;
while (t--) {
// cout << "Case #" << ++kase << ":";
marmot0814();
}
} | 1 |
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repr(i, a, n) for (int i = n - 1; i >= a; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> l(n * 2);
rep(i, 0, n * 2) cin >> l[i];
sort(l.begin(), l.end());
int ans = 0;
rep(i, 1, n * 2) {
ans += min(l[i], l[i - 1]);
i++;
}
cout << ans << endl;
}
| #include <iostream>
#include <map>
#include <set>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <fstream>
#include <bitset>
#include <queue>
#include <stack>
#include <deque>
#include <complex>
#include <iomanip>
#include <stdio.h>
#include <string.h>
#include <random>
#include <functional>
using std::cin;
using std::cout;
using std::cerr;
using std::endl;
using std::map;
using std::set;
using std::bitset;
using std::vector;
using std::string;
using std::multimap;
using std::multiset;
using std::deque;
using std::queue;
using std::stack;
using std::pair;
using std::iterator;
using std::sort;
using std::stable_sort;
using std::reverse;
using std::max_element;
using std::min_element;
using std::unique;
using std::ios_base;
using std::swap;
using std::fill;
using std::setprecision;
using std::fixed;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<long long> vl;
typedef string S;
ll min(ll a, ll b) {return a < b ? a : b;}
ll min(int a, ll b) {return a < b ? a : b;}
ll min(ll a, int b) {return a < b ? a : b;}
ll min(int a, int b) {return a < b ? a : b;}
ll max(ll a, ll b) {return a > b ? a : b;}
ll max(int a, ll b) {return a > b ? a : b;}
ll max(ll a, int b) {return a > b ? a : b;}
ll max(int a, int b) {return a > b ? a : b;}
namespace MySpace{
};
#define F(i, n) for (int (i) = 0; (i) != (n); (i)++)
#define fi first
#define se second
#define re return
#define all(x) (x).begin(), (x).end()
const int MOD = 1e9 + 7;
ll n, m, k;
vector<int> mul(vector<int> a, vector<int> b)
{
vector<int> c(a.size());
for (int i = 0; i < a.size(); i++)
{
c[i] = a[b[i]];
}
return c;
}
vector<double> mul(vector<double> a, vector<int> b)
{
vector<double> c(a.size());
for (int i = 0; i < a.size(); i++)
{
c[i] = a[b[i]];
}
return c;
}
vector<int> inq(vector<int> perm, ll k)
{
if (k == 0)
{
vector<int> c;
for (int i = 0; i < perm.size(); i++) c.push_back(i);
return c;
}
vector<int> l = inq(perm, k / 2);
if (k % 2) return mul(mul(l, l), perm);
return mul(l, l);
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
vector<double> x(n);
for (int i = 0; i < n; i++)
{
cin >> x[i];
}
cin >> m >> k;
vector<int> perm(n - 1);
iota(all(perm), 0);
for (int i = 0; i < m; i++)
{
int x;
cin >> x;
x--;
swap(perm[x - 1], perm[x]);
}
vector<int> c = inq(perm, k);
vector<int> y(n - 1);
for (int i = 0; i + 1 < n; i++)
{
y[i] = x[i + 1] - x[i];
}
y = mul(y, c);
double s = x[0];
for (int i = 0; i < n; i++)
{
printf("%.9f\n", s);
if (i != n - 1)
s += y[i];
}
}
| 0 |
#include <iostream>
#include <cmath>
#include <algorithm>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
int main()
{
int n; cin >> n;
vector<int> a(n), groups;
rep(i, n) cin >> a[i];
groups.push_back(a[0]);
rep(i, n-1){
int ng = -1, ok = groups.size();
while(ok - ng > 1){
int mid = (ng + ok) / 2;
if(groups[mid] < a[i + 1])
ok = mid;
else
ng = mid;
}
if(ok == groups.size())
groups.push_back(a[i + 1]);
else
groups[ok] = a[i + 1];
}
cout << groups.size() << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<int> A(N);
for(int i=0; i<N; i++) cin >> A[i];
multiset<int> ms;
for(auto a : A)
{
if(ms.empty() || *ms.begin() >= a) ms.insert(a);
else
{
auto itr = ms.lower_bound(a);
if(itr == ms.end() || *itr >= a) itr--;
ms.erase(itr);
ms.insert(a);
}
}
cout << ms.size() << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
//-------------------------------------------------------
string S;
int N,K;
const ll mo=998244353;
ll from[303][306];
ll to[303][306];
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>S>>K;
vector<int> V;
V.push_back(0);
int sum=0;
FORR(c,S) {
if(c=='1') V.back()++, sum++;
else V.push_back(0);
}
K=min(K,sum);
N=V.size();
from[K][0]=1;
FOR(y,V.size()) {
int v=V[y];
ZERO(to);
for(j=K;j>=0;j--) {
for(i=0;i<=sum;i++) if(from[j][i]) {
for(int tar=0;tar<=min(v+j,sum);tar++) {
if(y==V.size()-1 && tar>v) break;
if(tar<=v) {
if(i+(tar-v)>=0) (to[j][i+(tar-v)]+=from[j][i])%=mo;
}
else {
(to[j-(tar-v)][i+(tar-v)]+=from[j][i])%=mo;
}
}
}
}
swap(from,to);
}
ll ret=0;
FOR(i,K+1) ret+=from[i][0];
cout<<ret%mo<<endl;
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false), cin.tie(0);
FOR(i,argc-1) s+=argv[i+1],s+='\n'; FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
cout.tie(0); solve(); return 0;
}
| #include <cstdio>
#include <algorithm>
#include <iostream>
// 18:45 -
using namespace std;
int main(void)
{
while(1){
int n, p;
scanf("%d %d", &n, &p);
if(n == 0 & p == 0)
break;
int mine[n];
for(int i = 0; i < n; i++) mine[i] = 0;
int all = 0;
int count = 0;
while(1){
all = 0;
if(p > 0){
p--;
mine[count % n]++;
for(int i = 0; i < n; i++) all += mine[i];
all -= mine[count % n];
if(all == 0 && p == 0){
break;
}
} else if(p == 0){
p += mine[count % n];
mine[count % n] = 0;
}
count++;
}
printf("%d\n", count % n);
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n; cin>>n;
string s; cin >> s;
string t; cin >> t;
int cnt=0;
bool flg = false;
for(int i=0; i<s.length(); i++){
string s_sub = s.substr(i, s.length()-i);
for(int j=0; j<t.length(); j++){
string t_sub = t.substr(0, t.length()-j);
if(s_sub==t_sub){
cnt = s_sub.length(); flg = true;
break;
}
}
if(flg) break;
}
string res = s + t.substr(cnt, t.length()-cnt);
int ans = res.length();
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iostream>
#include <istream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <tuple>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> vec;
typedef vector<vec> mat;
#define rep(i, n) for(ll i = 0; i < (n); i++)
#define revrep(i, n) for(ll i = (n)-1; i >= 0; i--)
#define pb push_back
#define f first
#define s second
ll max(ll a, ll b){return (a > b) ? a : b;}
ll min(ll a, ll b){return (a < b) ? a : b;}
ll max3(ll a, ll b, ll c){return max(a, max(b, c));};
ll min3(ll a, ll b, ll c){return min(a, min(b, c));};
ll max4(ll a, ll b, ll c, ll d){return max(max(a, b), min(c, d));};
ll min4(ll a, ll b, ll c, ll d){return min(min(a, b), min(c, d));};
ll max5(ll a, ll b, ll c, ll d, ll e){return max(max(a, b), max3(c, d, e));};
ll min5(ll a, ll b, ll c, ll d, ll e){return min(min(a, b), min3(c, d, e));};
const ll INFL = 1LL << 60;//10^18 = 2^60
const int INF = 1 << 30;//10^9
ll MOD = 1000000007;
//ll MOD = 998244353;
vector<ll> dy = {0, 0, 1, -1, 1, 1, -1, -1, 0};
vector<ll> dx = {1, -1, 0, 0, 1, -1, 1, -1, 0};
ll pow_long(ll x, ll k){
ll res = 1;
while(k > 0){
if(k % 2) res *= x;
x *= x;
k /= 2;
}
return res;
}
ll pow_mod(ll x, ll k){
x %= MOD; x += MOD; x %= MOD;
ll res = 1;
while(k > 0){
if(k % 2){
res *= x; res %= MOD;
}
x *= x; x %= MOD;
k /= 2;
}
return res;
}
ll inverse(ll x){return pow_mod(x, MOD - 2);};
ll gcd(ll a, ll b){
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll x, ll y){return x / gcd(x, y) * y;};
ll kai_mod(ll x){
if(x == 0) return 1;
return x * kai_mod(x-1) % MOD;
}
/*
//コンビネーション
const int MAXcomb = 200010;
ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];
//facはn!,finvは1/n!
//invは逆元
void COMinit(){
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i = 2; i < MAXcomb; 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 comb(int n, int k){
if(n < k) return 0;
if(n < 0 || k < 0) return 0;
return fac[n] * finv[k] % MOD * finv[n-k] % MOD;
}
*/
ll N, M;
vector<ll> A, B;
void solve(){
ll ans = 1;
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
A.pb(-1);
sort(B.begin(), B.end());
reverse(B.begin(), B.end());
rep(i, N-1)if(A[i] == A[i+1]) ans = 0;
rep(i, M-1)if(B[i] == B[i+1]) ans = 0;
B.pb(-1);
ll a = 0, b = 0;
for(ll i = N * M; i >= 1; i--){
if(A[a] == i && B[b] == i){
ans *= 1;
a++, b++;
}else if(A[a] == i){
ans *= b;
a++;
}else if(B[b] == i){
ans *= a;
b++;
}else{
ans *= a * b - (N*M-i);
}
ans %= MOD;
}
cout << ans << endl;
}
int main(){
cin >> N >> M;
A.resize(N);
B.resize(M);
rep(i, N) cin >> A[i];
rep(i, M) cin >> B[i];
solve();
}
| 0 |
#include "bits/stdc++.h"
#define int long long
#define endl '\n'
using namespace std;
typedef long long ll;
#define db(x) cerr << #x << ": " << x << '\n';
#define read(a) int a; cin >> a;
#define readb(a, b) int a, b; cin >> a >> b;
#define readc(a, b, c) int a, b, c; cin >> a >> b >> c;
#define readarr(a, n) int a[(n) + 1] = {}; FOR(i, 1, (n)) {cin >> a[i];}
#define readmat(a, n, m) int a[n + 1][m + 1] = {}; FOR(i, 1, n) {FOR(j, 1, m) cin >> a[i][j];}
#define print(a) cout << a << endl;
#define printarr(a, n) FOR (i, 1, n) cout << a[i] << " "; cout << endl;
#define printv(v) for (int i: v) cout << i << " "; cout << endl;
#define printmat(a, n, m) FOR (i, 1, n) {FOR (j, 1, m) cout << a[i][j] << " "; cout << endl;} cout << endl;
#define all(v) v.begin(), v.end()
#define sz(v) (int)(v.size())
#define rz(v, n) v.resize((n) + 1);
#define pb push_back
#define fi first
#define se second
#define vi vector <int>
#define pi pair <int, int>
#define vpi vector <pi>
#define vvi vector <vi>
#define FOR(i, a, b) for (int i = (a); i <= (b); i++)
#define FORD(i, a, b) for (int i = (a); i >= (b); i--)
const ll inf = 1e18;
const ll mod = 1e9 + 7;
const ll N = 2e5 + 1;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
readc(n, h, w);
int cnt = 0;
FOR (i, 1, n)
FOR (j, 1, n)
if (i + h - 1 <= n && j + w - 1 <= n) cnt++;
print(cnt);
}
| #include <bits/stdc++.h>
#define rep(a,n) for (ll a = 0; a < (n); ++a)
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
typedef vector<vector<ll> > Graph;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const ll INF = 1e18;
int main(){
ll n,h,w;
cin >> n >> h >> w;
cout << (n-h+1)*(n-w+1) << endl;
return 0;
}
| 1 |
#include <iostream>
#include <sstream>
#include <iomanip>
#include <stdio.h>
#include <string>
#include <cstdlib>
#include <vector>
#include <cmath>
#include <math.h>
#include <stdexcept>
#include <algorithm>
#include <set>
#include <map>
#include <stdlib.h>
#include <cctype>
#include <bitset>
using namespace std;
int main()
{
int N;
cin >> N;
cout << (N - (N % 3)) / 3 << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int64_t ans=1;
int m,j,k,y,mod=1e9+7;
bool f;
cin>>m;
vector<int> p={2};
for(j=3;j<=m;j+=2){
f=true;
for(k=0;k<(int)p.size();k++){
if(j%p.at(k)==0){
f=false;
break;
}
}
if(f==true) p.push_back(j);
}
int l=p.size();
vector<int> x(l);
for(j=2;j<=m;j++){
y=j;
for(k=0;k<l;k++){
while(y%p.at(k)==0){
x.at(k)++;
y/=p.at(k);
}
if(y==1) break;
}
}
for(auto z:x) ans=ans*(z+1)%mod;
cout<<ans<<endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define len(v) ll(v.size())
#define fi first
#define se second
template <class T>
void cout_vec(const vector<T> &vec){
for(auto itr:vec) cout<<itr<<' ';
cout<<endl;
}
typedef pair<ll,ll> P;
const ll mod=1e9+7;
const ll inf=1e15;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n,x,y,z;
cin>>n>>x>>y>>z;
vector<vector<int>> dp(n+1,vector<int>((1<<(x+y+z-1)),0));
int mask=(1ll<<(x+y+z-1))-1;
int ng=(1<<(x+y+z-1))|(1<<(y+z-1))|(1<<(z-1));
dp[0][0]=1;
rep(i,n){
rep(S,1<<(x+y+z-1)){
if((S & ng)==ng) continue;
FOR(j,1,11){
int T=(S<<j) | (1<<(j-1));
if((T & ng)==ng) continue;
T&=mask;
(dp[i+1][T]+=dp[i][S])%=mod;
}
}
}
ll ans=1;
rep(i,n) (ans*=10)%=mod;
rep(i,1<<(x+y+z-1)) (ans-=dp[n][i])%=mod;
cout<<(ans+mod)%mod<<endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) REP(i,0,n)
#define REP(i,s,e) for(int i=(s); i<(int)(e); i++)
#define repr(i, n) REPR(i, n, 0)
#define REPR(i, s, e) for(int i=(int)(s-1); i>=(int)(e); i--)
#define pb push_back
#define all(r) r.begin(),r.end()
#define rall(r) r.rbegin(),r.rend()
#define fi first
#define se second
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll INF = 1e9;
const ll MOD = 1e9 + 7;
const double EPS = 1e-8;
template<typename T> T chmax(T& a, const T& b){return a = (a > b ? a : b);}
template<typename T> T chmin(T& a, const T& b){return a = (a < b ? a : b);}
ll modPow(ll x, ll n) {
ll ret = 1;
while(n) {
if(n&1LL) (ret *= x) %= MOD;
n >>= 1;
(x *= x) %= MOD;
}
return ret;
}
ll dp[41][(1<<17)+10];
int main(){
int n;
vi v(3);
cin >> n;
rep(i, 3) cin >> v[i];
int sum_v = v[0] + v[1] + v[2];
dp[0][0] = 1;
auto check = [&](int mask) {
bool f = true;
f &= (mask >>=(v[2]-1)) & 1;
f &= (mask >>=v[1]) & 1;
f &= (mask >>=v[0]) & 1;
return f;
};
auto pop_mask = [&](int mask) {
if(mask == 0) return 0;
bool f = true;
repr(i, sum_v) {
if(mask & (1<<i)) {
if(f) {
mask -= (1<<i);
f = false;
break;
}
}
}
return mask;
};
auto getSize = [&](int mask) {
if(mask == 0) return 0;
repr(i, sum_v) {
if(mask&(1<<i)) {
return i+1;
}
}
return 0;
};
auto push_mask = [&](int mask, int add) {
if(add > sum_v) return 0;
while(getSize(mask)+add > sum_v) {
mask = pop_mask(mask);
}
mask <<= add;
mask |= 1<<(add-1);
return mask;
};
rep(i, n) rep(mask, 1<<sum_v) {
REP(k, 1, 11) {
int nxt = push_mask(mask, k);
if(check(mask) || check(nxt)) continue;
(dp[i+1][nxt] += dp[i][mask]) %= MOD;
}
}
ll sum = 0LL;
rep(mask, 1<<sum_v) (sum += dp[n][mask]) %= MOD;
ll ans = modPow(10, n);
(ans += MOD - sum) %= MOD;
cout << ans << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define all(x) (x).begin(),(x).end()
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
const ll MOD9=1000000007;
const ll MOD=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
using Graph = vector<vector<int>>;
double nCk(int n, int k) {
double res=1.0;
for(int i=0; i<n; i++){
res*=0.5;}
for(int i=0; i<k; i++){
res*=(double)(n-i);
res/=(double)(k-i);
}
return res;}
struct edge{ll to, cost;};
typedef pair<ll,ll> P;
struct graph{
ll V;
vector<vector<edge> > G;
vector<ll> d;
graph(ll n){
init(n);
}
void init(ll n){
V = n;
G.resize(V);
d.resize(V);
rep(i,V){
d[i] = INF;
}
}
void add_edge(ll s, ll t, ll cost){
edge e;
e.to = t, e.cost = cost;
G[s].push_back(e);
}
void dijkstra(ll s){
rep(i,V){
d[i] = INF;
}
d[s] = 0;
priority_queue<P,vector<P>, greater<P> > que;
que.push(P(0,s));
while(!que.empty()){
P p = que.top(); que.pop();
ll v = p.second;
if(d[v]<p.first) continue;
for(auto e : G[v]){
if(d[e.to]>d[v]+e.cost){
d[e.to] = d[v]+e.cost;
que.push(P(d[e.to],e.to));
}
}
}
}
};
class UnionFind
{
public:
int par[100005];
int depth[100005];
int nGroup[100005];
UnionFind(int n) {
init(n);
}
void init(int n) {
for(int i=0; i<n; i++) {
par[i] = i;
depth[i] = 0;
nGroup[i] = 1;
}
}
int root(int x) {
if(par[x] == x) {
return x;
} else {
return par[x] = root(par[x]);
}
}
bool same(int x, int y) {
return root(x) == root(y);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if(x == y) return;
if(depth[x] < depth[y]) {
par[x] = y;
nGroup[y] += nGroup[x];
nGroup[x] = 0;
} else {
par[y] = x;
nGroup[x] += nGroup[y];
nGroup[y] = 0;
if(depth[x] == depth[y])
depth[x]++;
}
}
};
const ll MAX = 510000;
ll 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;
}
}
// 二項係数計算
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;
}
vector<ll> depth;
vector<ll> f;
vector<ll> g;
void dfs(const Graph &G, ll v, ll p, ll d) {
depth[v] = d;
for (auto nv : G[v]) {
if (nv == p) continue; // nv が親 p だったらダメ
dfs(G, nv, v, d+1);
}
// 帰りがけ時に、部分木サイズを求める
f[v] = 1;
g[v] = 1;// 自分自身
for (auto c : G[v]) {
if (c == p) continue;
f[v]*=g[c];
f[v]%=MOD;
g[v]*=f[c];
g[v]%=MOD;
}
f[v]+=g[v];
f[v]%=MOD;
}
int main() {
ll n,m,k; cin>>n>>m>>k;
ll ca = 0;
ll q = 1;
COMinit();
for(ll i=0; i<n-k-1; i++){
q*=m-1;
q%=MOD;}
q*=m;
q%=MOD;
for(ll i=k; i>0; i--){
ll c = 1;
c*=(COM(n-1,i))%MOD;
//c*=m;
//c%=MOD;
c*=q;
c%=MOD;
q*=(m-1);
q%=MOD;
ca+=c;
ca%=MOD;}
//cout << q << endl;
//q*=m;
//q%=MOD;
//cout << q << endl;
ca+=q;
ca%=MOD;
//ll p = 1;
//for(ll i =1; i<100; i++){
//p*=99;
//p%=MOD;
//}
//cout << p << endl;
//p*=100;
//p%=MOD;
cout << ca << endl;}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
using vll = vector<vl>;
using Pll = pair<ll, ll>;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(v) v.begin(), v.end()
#define sz(x) ((int) x.size())
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define F first
#define S second
const int MOD = 1e9+7;
const int INF = 2e9;
template<class T> void print(const T& t){ cout << t << endl; }
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 gcd(int a,int b){return b?gcd(b,a%b):a;}
int main(){
ll a, b, k;
cin >> a >> b >> k;
ll count = 0;
while(count<k){
if(a%2==1){
a--;
}
b += a / 2;
a /= 2;
count++;
if(count==k){
break;
}
if(b%2==1){
b--;
}
a += b / 2;
b /= 2;
count++;
}
cout << a << " " << b << endl;
} | 0 |
#include <bits/stdc++.h>
#define pb push_back
#define pll pair <ll, ll>
#define mp make_pair
#define pyshnapyshnakaa ios_base :: sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define x first
#define y second
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#define plll pair <pair <ll, ll>, ll>
#define pllll pair <pair <ll, ll>, pair <ll, ll> >
#define psl pair <string, ll>
#define all(a) a.begin(), a.end()
typedef long long ll;
typedef long double ld;
using namespace std;
ll n, m, k, t;
const ll maxn = 6e3 + 100;
const ll shift = 2e3;
ll mod;
inline ll step(ll a, ll x) {
if (x == 0) {
return 1;
}
if (x % 2 == 1) {
return step(a, x - 1) * a % mod;
}
ll t = step(a, x / 2);
return t * t % mod;
}
inline ll del(ll a, ll b) {
return a * step(b, mod - 2) % mod;
}
ll D[maxn][2 * maxn + 200]; /// s, 1 - 2
ll F[maxn];
ll R[maxn];
int main() {
ll q, w, e, a, b, d;
cin >> n >> mod;
n *= 3;
for (q = 1; q <= n; q++) {
R[q] = del(1, q);
}
F[0] = 1;
for (q = 1; q < maxn; q++) {
F[q] = (F[q - 1] * q) % mod;
}
D[0][shift] = F[n];
for (q = 0; q < n; q++) {
for (w = 0; w < maxn * 2 + 100; w++) {
for (e = 1; e <= 3; e++) {
ll nw = w;
if (e == 1) {
nw = nw + 1;
}
if (e == 2) {
nw = nw - 1;
}
if (q + e > maxn || nw > 3 * maxn || q + e < 0 || nw < 0) {
continue;
}
// D[q + e][nw] += del(D[q][w], q + e);
D[q + e][nw] += D[q][w] * R[q + e] % mod;
D[q + e][nw] %= mod;
}
}
}
ll ans = 0;
for (q = 0; q < 2 * maxn + 200; q++) {
if (q - shift >= 0) {
ans += D[n][q];
ans %= mod;
}
}
cout << ans;
return 0;
}
| #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define MOD 1000000007
using namespace std;
int main()
{
int x,y;
cin >> x >> y;
int ans = 0;
if(x < 4)
{
ans += (4 - x) * 100000;
}
if(y < 4)
{
ans += (4 - y) * 100000;
}
if(x == 1 && y == 1)
{
ans += 400000;
}
cout << ans << "\n";
return 0;
} | 0 |
#include<bits/stdc++.h>
#define ll long long
#define rep(i, n) for(int i=0;i<(n);++i)
#define per(i, n) for(int i=(n)-1;i>=0;--i)
#define repa(i, n) for(int i=1;i<(n);++i)
#define foreach(i, n) for(auto &i:(n))
#define pii pair<int, int>
#define pll pair<long long, long long>
#define all(x) (x).begin(), (x).end()
#define bit(x) (1ll << (x))
const ll MOD = (ll)1e9+7;
const ll INF = (ll)1e9+7;
const ll INFLL = (ll)1e18;
using namespace std;
template<class t, class u> bool chmax(t &a, u b){if(a<b){a=b;return true;}return false;}
template<class t, class u> bool chmin(t &a, u b){if(a>b){a=b;return true;}return false;}
ll modpow(ll x, ll b){
ll res = 1;
while(b){
if(b&1)res = res * x % MOD;
x = x * x % MOD;
b>>=1;
}
return res;
}
ll modinv(ll x){
return modpow(x, MOD-2);
}
int main(){
int n;
cin >> n;
vector<vector<ll>> citys(n, vector<ll>(2));
foreach(i, citys){
foreach(j, i)cin>>j;
}
vector<vector<pll>> roads(n);
rep(i, 2){
vector<pll> line;
rep(j, n){
line.emplace_back(citys[j][i], j);
}
sort(all(line));
rep(j, n-1){
pll a = line[j];
pll b = line[j+1];
roads[a.second].emplace_back(abs(a.first-b.first), b.second);
roads[b.second].emplace_back(abs(a.first-b.first), a.second);
}
}
vector<bool> used(n, false);
priority_queue<pll, vector<pll>, greater<pll>> pq;
ll ans = 0;
pq.emplace(0, 0);
while(pq.size()){
pll d = pq.top();
pq.pop();
if(used[d.second])continue;
used[d.second] = true;
ans += d.first;
foreach(i, roads[d.second]){
if(used[i.second])continue;
pq.push(i);
}
}
cout << ans << endl;
return 0;
}
| #include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<set>
#include<queue>
#include<stack>
using namespace std;
#define int long long
#define vel vector<long long>
#define vvel vector<vel>
#define rep(i,n) for(long long i=0;i<n;i++)
#define rp(i,n) for(long long i=1;i<n;i++)
#define sor(v) sort(v.begin(),v.end())
#define mmax(a,b) a=max(a,b)
#define mmin(a,b) a=min(a,b)
#define mkp make_pair
#define pin pair<int,int>
#define V vector
long long p = 1000000007;
vel rui(19, 1);
vel par;
int root(int ser) {
if (par[ser] == -1) { return ser; }
int ans = root(par[ser]);
par[ser] = ans;
return ans;
}
bool marge(pin a) {
int x = root(a.first);
int y = root(a.second);
if (x != y) {par[x] = y;}
return x != y;
}
signed main() {
int n; cin >> n;
vel x(n), y(n);
V<pair<pin, int>> xy(n);
V<pair<pin, int>> yx(n);
rep(i, n) {
cin >> x[i] >> y[i];
xy[i] = mkp(mkp(x[i], y[i]), i);
yx[i] = mkp(mkp(y[i], x[i]), i);
}
sor(xy); sor(yx);
V<pair<int, pin>> way(0);
rep(i, n - 1) {
int diff = xy[i + 1].first.first - xy[i].first.first;
pin path = mkp(xy[i].second, xy[i+1].second);
way.push_back(mkp(diff, path));
}
rep(i, n - 1) {
int diff = yx[i + 1].first.first - yx[i].first.first;
pin path = mkp(yx[i].second, yx[i + 1].second);
way.push_back(mkp(diff, path));
}
sor(way);
int ans = 0;
par = vel(n, -1);
rep(i, way.size()) {
if (marge(way[i].second)) { ans += way[i].first; }
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
int a;
cin>>a;
int ans =0;
for(int i=0;i<3;i++){
ans+=pow(a,i+1);
}
cout<<ans<<endl;
} | #include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cmath>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
int a;
cin >> a;
cout << a + a * a + a * a * a;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define P pair<int,int>
int main(){
int sx, sy, tx, ty;
cin >> sx >> sy >> tx >> ty;
string ans;
rep(i,ty-sy) ans+='U';
rep(i,tx-sx) ans+='R';
rep(i,ty-sy) ans+='D';
rep(i,tx-sx) ans+='L';
ans+='L';
rep(i,ty-sy+1) ans+='U';
rep(i,tx-sx+1) ans+='R';
ans+='D';
ans+='R';
rep(i,ty-sy+1) ans+='D';
rep(i,tx-sx+1) ans+='L';
ans+='U';
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i=0; i<(n); ++i)
#define REP(i, d, n) for(int i=(d); i<(n); ++i)
#define all(v) v.begin(), v.end()
using ll = long long;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
vector<double> a(n);
double sum = 0;
rep(i, n){
cin >> a[i];
sum += a[i];
}
double k = sum / n;
double mi = 100000;
int ans = 0;
rep(i, n){
if(mi > abs(a[i]-k)){
mi = abs(a[i]-k);
ans = i;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int d, t, s;
cin >> d >> t >> s;
string ans;
if((double)d/s <= t){
ans = "Yes";
}else{
ans = "No";
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1e18;
const ll MOD = 1e9+7;
#define REP(i,j,n) for(int i=j;i<n;i++)
#define rep(i,n) REP(i,0,n)
// Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int d,t,s;
cin >> d >> t >> s;
if (d <= t * s)
{
cout << "Yes" << endl;
}
else
{
cout << "No" << endl;
}
}
| 1 |
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iostream>
#include <istream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <tuple>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> vec;
typedef vector<vec> mat;
#define rep(i, n) for(ll i = 0; i < (n); i++)
#define revrep(i, n) for(ll i = (n)-1; i >= 0; i--)
#define pb push_back
#define f first
#define s second
ll max(ll a, ll b){return (a > b) ? a : b;}
ll min(ll a, ll b){return (a < b) ? a : b;}
ll max3(ll a, ll b, ll c){return max(a, max(b, c));};
ll min3(ll a, ll b, ll c){return min(a, min(b, c));};
ll max4(ll a, ll b, ll c, ll d){return max(max(a, b), min(c, d));};
ll min4(ll a, ll b, ll c, ll d){return min(min(a, b), min(c, d));};
ll max5(ll a, ll b, ll c, ll d, ll e){return max(max(a, b), max3(c, d, e));};
ll min5(ll a, ll b, ll c, ll d, ll e){return min(min(a, b), min3(c, d, e));};
const ll INFL = 1LL << 60;//10^18 = 2^60
const int INF = 1 << 30;//10^9
ll MOD = 1000000007;
//ll MOD = 998244353;
vector<ll> dy = {0, 0, 1, -1, 1, 1, -1, -1, 0};
vector<ll> dx = {1, -1, 0, 0, 1, -1, 1, -1, 0};
ll pow_long(ll x, ll k){
ll res = 1;
while(k > 0){
if(k % 2) res *= x;
x *= x;
k /= 2;
}
return res;
}
ll pow_mod(ll x, ll k){
x %= MOD; x += MOD; x %= MOD;
ll res = 1;
while(k > 0){
if(k % 2){
res *= x; res %= MOD;
}
x *= x; x %= MOD;
k /= 2;
}
return res;
}
ll inverse(ll x){return pow_mod(x, MOD - 2);};
ll gcd(ll a, ll b){
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll x, ll y){return x / gcd(x, y) * y;};
ll kai_mod(ll x){
if(x == 0) return 1;
return x * kai_mod(x-1) % MOD;
}
/*
//コンビネーション
const int MAXcomb = 200010;
ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];
//facはn!,finvは1/n!
//invは逆元
void COMinit(){
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i = 2; i < MAXcomb; 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 comb(int n, int k){
if(n < k) return 0;
if(n < 0 || k < 0) return 0;
return fac[n] * finv[k] % MOD * finv[n-k] % MOD;
}
*/
string S;
ll K;
ll memo[310][310][310];//[)
ll solve(ll l, ll r, ll rest){
if(l > r) return -INFL;
if(l == r) return 0;
if(l + 1 == r) return 1;
if(memo[l][r][rest] != -1) return memo[l][r][rest];
ll res = max(solve(l, r-1, rest), solve(l+1, r, rest));
if(S[l] == S[r-1]){
res = max(res, solve(l+1, r-1, rest) + 2);
}else{
if(rest >= 1) res = max(res, solve(l+1, r-1, rest - 1) + 2);
}
return memo[l][r][rest] = res;
}
int main(){
cin >> S >> K;
rep(i, 310)rep(j, 310)rep(k, 310) memo[i][j][k] = -1;
cout << solve(0, S.size(), K) << endl;
}
| #include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<ctime>
#include<map>
#include<bitset>
#include<set>
#include<assert.h>
#define LL long long
#define mp(x,y) make_pair(x,y)
#define pll pair<long long,long long>
#define pii pair<int,int>
#define SZ(x) ((int)x.size())
using namespace std;
inline LL read()
{
LL f=1,x=0;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
int stack[20];
template<typename T>inline void write(T x)
{
if(x<0){putchar('-');x=-x;}
if(!x){putchar('0');return;}
int top=0;
while(x)stack[++top]=x%10,x/=10;
while(top)putchar(stack[top--]+'0');
}
template<typename T>inline void pr1(T x){write(x);putchar(' ');}
template<typename T>inline void pr2(T x){write(x);putchar('\n');}
template<typename T>inline void chkmin(T &x,T y){x=x<y?x:y;}
template<typename T>inline void chkmax(T &x,T y){x=x>y?x:y;}
const int MAXN=305;
int f[MAXN][MAXN][MAXN],n,K;char ch[MAXN];
int main()
{
scanf("%s",ch+1);n=strlen(ch+1);K=read();
f[0][n+1][0]=0;int ans=0;
for(int i=0;i<=n;i++)for(int j=n+1;j>=i;j--)for(int k=0;k<=K;k++)
{
int ad=(ch[i]==ch[j]?0:1);
if(i-1>=0)chkmax(f[i][j][k],f[i-1][j][k]);
if(j+1<=n+1)chkmax(f[i][j][k],f[i][j+1][k]);
if(i-1>=0&&j+1<=n+1&&k-ad>=0)chkmax(f[i][j][k],f[i-1][j+1][k-ad]+1);
if(i<j)chkmax(ans,2*f[i][j][k]);
else chkmax(ans,2*f[i][j][k]-1);
}pr2(ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,x) for(int i=0;i<x;i++)
#define put(ans) cout << ans << endl;
double kaijyo(int n){
int k(1);
for(int i=n;i>0;i--){
k *= i;
}
return k;
}
double distance(int x[],int y[],int i,int j){
int dx = (x[i] - x[j]) * (x[i] - x[j]);
int dy = (y[i] - y[j]) * (y[i] - y[j]);
return sqrt(dx+dy);
}
int main(){
string s,t;
cin >> s >> t;
cout << t << s << endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int main()
{
ll n,Y; cin >> n >> Y;
ll sum;
REP(i,n+1){
REP(j,n-i+1){
int k = n - i - j;
sum = 10000 * i + 5000 * j + 1000 * k;
if(sum == Y){
printf("%d %d %d",i,j,k);
return 0;
}
}
}
printf("-1 -1 -1");
} | 0 |
#include <iostream>
#include <vector>
using namespace std;
struct FenwickTree {
vector<int> bit; // binary indexed tree
int n;
FenwickTree(int n) {
this->n = n;
bit.assign(n, 0);
}
FenwickTree(vector<int> a) : FenwickTree(a.size()) {
for (size_t i = 0; i < a.size(); i++)
add(i, a[i]);
}
int sum(int r) {
int ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1)
ret += bit[r];
return ret;
}
int sum(int l, int r) {
return sum(r) - sum(l - 1);
}
void add(int idx, int delta) {
for (; idx < n; idx = idx | (idx + 1))
bit[idx] += delta;
}
};
int main() {
const int MAXN = 200000;
int a[MAXN], b[MAXN]={0};
int n, k;
cin>>n>>k;
for(int i=0;i<n;i++) cin>>a[i];
const int iterations = 41;
for(int i=1;i<=min(k, iterations);i++) {
FenwickTree t1(n), t2(n);
for(int j=0;j<n;j++) {
b[j] += t1.sum(j, n-1);
t1.add(min(n-1,j+a[j]), 1);
}
for(int j=n-1;j>=0;j--) {
t2.add(max(0,j-a[j]), 1);
b[j] += t2.sum(j);
}
for(int j=0;j<n;j++) {
a[j]=b[j];
b[j]=0;
}
}
for(int i=0;i<n;i++) cout<<a[i]<<" ";
cout<<endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define rep(i,N) for(ll (i)=0;(i)<(N);(i)++)
const int mod = 1000000007;
int main() {
int n, q;
cin >> n >> q;
vector<tuple<int, int, int>> a(n);
rep(i, n) {
int s, t, x;
cin >> s >> t >> x;
s -=x;
t -= x;
a[i] = tie(x, s, t);
}
sort(a.begin(), a.end());
set<P> st;
rep(i, q) {
int d;
cin >> d;
st.insert(P(d, i));
}
vector<int> ans(q, -1);
rep(i, n) {
int s, t, x;
tie(x, s, t) = a[i];
auto it = st.lower_bound(P(s, -1));
while(it != st.end()) {
if(it->first >= t) break;
ans[it->second] = x;
st.erase(it++);
}
}
rep(i, q) {
cout << ans[i] << endl;
}
} | 0 |
#include <iostream>
#include <cstdint>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cctype>
#include <cassert>
#include <climits>
#include <string>
#include <bitset>
#include <cfloat>
#include <unordered_set>
#pragma GCC optimize("Ofast")
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
typedef vector<vector<ll>> vvll;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define irep(it, stl) for (auto it = stl.begin(); it != stl.end(); it++)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define mes(a) cout << (a) << endl
#define dmes(a, b) cout << (a) << " " << (b) << endl
#define re0 return 0
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define rSort(a) sort(a.rbegin(), a.rend())
#define MATHPI acos(-1)
#define itn int;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
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;
}
struct io
{
io()
{
ios::sync_with_stdio(false);
cin.tie(0);
}
};
const int INF = INT_MAX;
const ll LLINF = 1LL << 60;
const ll MOD = 1000000007;
const double EPS = 1e-9;
bool isPrime(ll x){
ll i;
if(x < 2)return 0;
else if(x == 2) return 1;
if(x%2 == 0) return 0;
for(i = 3; i*i <= x; i += 2) if(x%i == 0) return 0;
return 1;
}
signed main(void)
{
ll l, r;
cin >> l >> r;
ll ans = 2020;
if (r-l > 2020) {
mes(0);
re0;
}
for(ll i = l; i < r; i++) {
for (ll j = i+1; j <= r; j++) {
ans = min(ans, (i*j)%2019);
}
}
mes(ans);
} | #include <bits/stdc++.h>
typedef long long int ll;
typedef long double ld;
using namespace std;
const long long int INF = 1e18;
const long long int mod = 1e9+7;
typedef pair<ll,ll> pairs;
vector<pairs> p;
ll gcd(ll A,ll B){
if (A%B==0)return(B);
else return(gcd(B,A%B));
}
ll keta(ll N){
int tmp{};
while( N > 0 ){
tmp += ( N % 10 );
N /= 10;
}
N = tmp;
return N;
}
vector<vector<ll>> combination(ll n, ll r){
vector<vector<ll>> v(n + 1, vector<ll>(n + 1, 0));
for(ll i=0;i<v.size();++i){
v[i][0] = 1;
v[i][i] = 1;
}
for(ll i=1;i<v.size();++i){
for(ll j=0;j<i;++j){
v[i][j] = (v[i - 1][j - 1] + v[i - 1][j]);
}
}
return v;
}
bool kai(string S){
bool flag = true;
for(ll i=0;i<S.size()/2;++i){
if(S[i] != S[S.size()-i-1]){
flag = false;
break;
}
}
return flag;
}
// ---------------------------------------------
int main(){
string s;
cin>>s;
ll w;
cin>>w;
for(ll i=0;i<s.size();i+=w){
cout<<s[i];
}
cout<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int a,b,c,k;
int64_t target;
int64_t remains;
cin >> a >> b >> c >> k;
target = max(a,max(b,c));
remains = a + b + c - target;
target = target * pow(2,k);
cout << target + remains << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
double n, x, t;
cin>>n>>x>>t;
double t1 = ceil(double(n/x));
//cout<<n/x<<endl;
//cout<<t1<<endl;
ll t11 = ll(t1)*ll(t);
cout<<t11<<endl;
}
| 0 |
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <queue>
#include <cstring>
#include <vector>
#include <map>
#include <algorithm>
#include <cctype>
#include <cmath>
#include <bitset>
#include <set>
#include <stack>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define RREP(i,n) for(int i=n-1;i>=0;i--)
#define FOR(i,k,n) for(int i=(k);i<(int)(n);i++)
#define all(i,n) (i),(i+n)
int dx4[4]={1,0,-1,0};
int dy4[4]={0,-1,0,1};
int dx8[8]={1,0,-1,1,-1,1,0,-1};
int dy8[8]={1,1,1,0,0,-1,-1,-1};
int dx9[9]={0,1,0,-1,1,-1,1,0,-1};
int dy9[9]={0,1,1,1,0,0,-1,-1,-1};
typedef pair<int, int> P;
typedef pair<string, int> SP;
typedef long long ll;
typedef pair<ll, ll> PLL;
const int INF = 1e9;
const ll LLINF = 1e18;
const int MAX_V = 1e6+1;
const ll mod = 1000000007;
// << fixed << setprecision
// --------------------------------------
int n, q;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> q;
set<P> vp;
vector<tuple<int, int, int>> ve;
REP(i, n) {
int l, r, x;
cin >> l >> r >> x;
l -= x; r -= x;
ve.push_back(tie(x, l, r));
}
sort(ve.begin(), ve.end());
REP(i, q) {
int d;
cin >> d;
vp.insert(P(d, i));
}
vector<int> ans(q, -1);
REP(i, n) {
int x, l, r;
tie(x, l, r) = ve[i];
auto it = vp.lower_bound(P(l, -1));
while(it != vp.end()) {
if(it->first >= r) break;
ans[it->second] = x;
vp.erase(it++);
}
}
REP(i, q) cout << ans[i] << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> duo;
#define TT template<typename T>
TT T sq(T x){ return x*x; }
TT int ubnd(vector<T>& v,T x){ return upper_bound(v.begin(), v.end(), x) - v.begin(); }
TT int lbnd(vector<T>& v,T x){ return lower_bound(v.begin(), v.end(), x) - v.begin(); }
TT void sort(T& v){ sort(v.begin(), v.end()); }
TT void revs(T& v){ reverse(v.begin(), v.end()); }
TT void uniq(T& v){ sort(v); v.erase(unique(v.begin(), v.end()), v.end()); }
TT void show(T& v,char d=' ',char e='\n'){for(int i=0;i<v.size();++i)cout<<v[i]<<((i==v.size()-1)?e:d);}
TT void inpt(vector<T>& v,int n){ v.reserve(n);for(int i=0;i<n;++i){T x; cin>>x; v.push_back(x);} }
TT T In(T& x){ cin >> x; return x; }
static inline void fast_io(){ ios::sync_with_stdio(0); cin.tie(0); }
static inline int in(){ int x; scanf("%d", &x); return x; }
static inline string instr(){ string x; cin >> x; return x; }
static const int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
static const int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
struct Rect {
int h, w, d;
Rect(int h, int w) : h(h), w(w), d(sq(h) + sq(w)) {}
bool operator<(const Rect& x) const {
return d == x.d ? h < x.h : d < x.d;
}
};
int main()
{
vector<Rect> v;
int h, w;
for (int x = 1; x <= 150; x++){
for (int y = 1; y < x; y++){
v.push_back(Rect(y, x));
}
}
sort(v);
while (h = in(), w = in(), h || w){
Rect r = Rect(h, w);
int index = ubnd(v, r);
printf("%d %d\n", v[index].h, v[index].w);
}
return (0);
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,i,a[10]={99,111,222,333,444,555,666,777,888,999};
cin>>n;
for(i=0;i<10;i++){
if(a[i]==n){
cout<<n;
return 0;
}
if(a[i]<n && a[i+1]>n){
cout<<a[i+1];
return 0;
}}
}
| #pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep2(i,a,b) for(ll i=a;i<=b;++i)
#define rep(i,n) for(ll i=0;i<n;i++)
#define rep3(i,a,b) for(ll i=a;i>=b;i--)
#define pii pair<int,int>
#define pll pair<ll,ll>
#define pq priority_queue<int>
#define pb push_back
#define eb emplace_back
#define vec vector<int>
#define vecll vector<ll>
#define vecpii vector<pii>
#define vec2 vector<vec>
#define vecll2 vector<vecll>
#define vec3 vector<vec2d>
#define vecll3 vector<vecll2d>
#define fi first
#define se second
#define endl "\n"
#define all(c) begin(c),end(c)
#define ios ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
using namespace std;
int in() {int x;cin>>x;return x;}
ll lin() {ll x;cin>>x;return x;}
template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
template<class T> inline void print(vector<T> v){for(T e:v)cout<<e<<" ";cout<<endl;}
template<class T> inline void print(pair<T,T> p){cout<<"("<<p.first<<","<<p.second<<") ";}
template<class T> inline void print(vector<pair<T,T>> v){for(auto e:v)print(e); cout<<endl;}
void print(vector<vec> v){for(auto e:v){for(auto ee:e)cout<<ee<<" ";cout<<endl;}}
void print(map<int,int> mp){for(auto e:mp)cout<<e.first<<" "<<e.second<<endl;cout<<endl;}
int m[1100][1100];
int tmp[2200][2200];
int r1[2200][2200];
int r2[2200][2200];
main(){
int n=in();
vec a;rep(i,n)a.pb(in());
int sum=0;
rep(i,n)sum+=a[i];
int d=INT_MAX;
int ans;
rep(i,n){
if(abs(sum-a[i]*n)<d){
d=abs(sum-a[i]*n);
ans=i;
}
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
using ll = long long;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int INF = 1<<30;
const ll mod = 1000000007LL;
int main() {
string S;
cin>>S;
reverse(S.begin(),S.end());
int l = S.size();
int ans = 0;
int over = 0;
for(int i = 0; i < l; i++){
int t = S[i]-'0';
t+=over;
over = 0;
if(t>=10) {
t-=10;
over = 1;
}
if(t<=4) ans += t;
if(t==5){
int s;
if(i!=l-1) s = S[i+1]-'0';
if(i==l-1||s<=4) ans+=t;
else if(s>=5) {
ans+=(10-t);
over=1;
}
}
if(t>=6) {
ans += (10-t);
over = 1;
}
if(i==l-1&&over!=0) ans+=over;
}
cout<<ans<<endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define rep(i,r) for (ll i = 0; i < (ll)(r); i++)
ll dp[1000010][2];
int main(){
string s; cin >> s;
s = '0' + s;
int n = s.size();
dp[0][1] = 1;
for(int i=1;i<n;i++){
int c = s[i]-'0';
dp[i][0] = min(dp[i-1][0]+c, dp[i-1][1]+(10-c) );
dp[i][1] = min(dp[i-1][0]+c+1, dp[i-1][1]+(10-c-1));
}
cout << dp[n-1][0] << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define ull unsigned long long
#define ld long double
#define vi vector<int>
#define vll vector<ll>
#define vc vector<char>
#define vs vector<string>
#define vpii vector<pii>
#define vpll vector<pll>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define repr(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rep1r(i, n) for (int i = ((int)(n)); i >= 1; i--)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define RSORT(x) sort(rall(x));
#define pb push_back
#define mp make_pair
#define INF (1e9)
#define PI (acos(-1))
#define EPS (1e-7)
ull gcd(ull a, ull b) { return b ? gcd(b, a % b) : a; }
ull lcm(ull a, ull b) { return a / gcd(a, b) * b; }
int main(){
int n, k;
cin >> n >> k;
cout << (n-k+1) << endl;
return 0;
}
| #include<bits/stdc++.h>
#include<boost/dynamic_bitset.hpp>
using namespace std;
using u64 = uint64_t;
using s64 = int64_t;
int main(void) {
u64 N, M;
cin >> N >> M;
u64 lM = M / 2;
u64 lN = N / 2;
u64 rM = M - lM;
u64 rN = N - lN;
if(lN == rN) {
lN--;
}
for(u64 i=0, l=1, r=lN; i<lM; i++, l++, r--) {
cout << l << " " << r << endl;
}
for(u64 i=0, l=N/2+1, r=N; i<rM; i++, l++, r--) {
cout << l << " " << r << endl;
}
return 0;
} | 0 |
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long
#define double long double
#define itn int
#define endl '\n'
#define co(ans) cout<<ans<<endl
#define COYE cout<<"YES"<<endl
#define COYe cout<<"Yes"<<endl
#define COye cout<<"yes"<<endl
#define CONO cout<<"NO"<<endl
#define CONo cout<<"No"<<endl
#define COno cout<<"no"<<endl
#define FORE(i,a) for(auto &i:a)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define FFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) FFOR(i,1,n)
#define PB push_back
#define MP make_pair
#define ALL(V) (V).begin(),(V).end()
#define SORT(V) sort((V).begin(),(V).end())
#define REVERSE(V) reverse((V).begin(),(V).end())
#define EACH(V,i) for(typeof((V).begin()) i=(V).begin();i!=(V).end();++i)
#define INF ((1LL<<62)-(1LL<<31))
#define EPS 1e-10
#define PI 3.141592653589793238
#define MOD 1000000007
#define MAX 5100000
using namespace std;
using Graph=vector<vector<int>>;
inline int toInt(string s){int v;istringstream sin(s);sin>>v;return v;}
template<class T>inline string toString(T x){ostringstream sout;sout<<x;return sout.str();}
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 vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
const int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
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;}
int main(){
int N,M,Q;
cin>>N>>M>>Q;
string SS[N+1];
int S[N+1][M+1];
int C[N+1][M+1]; // 横に連続する1のマスの総数
int R[N+1][M+1]; // 縦に連続する1のマスの総数
int SUM[N+1][M+1]; // 存在する1のマスの総数
for(int i=1; i<=N; ++i){
cin>>SS[i];
for(int j=1; j<=M; ++j){
if(SS[i][j-1]=='0') S[i][j]=0;
else S[i][j]=1;
}
}
for(int i=0; i<=N; ++i){
for(int j=0; j<=M; ++j){
if(i*j==0){
S[i][j]=0;
C[i][j]=0;
R[i][j]=0;
SUM[i][j]=0;
}
}
}
for(int i=1; i<=N; ++i){
for(int j=1; j<=M; ++j){
SUM[i][j]=SUM[i-1][j]+SUM[i][j-1]-SUM[i-1][j-1]+S[i][j];
C[i][j]=C[i-1][j]+C[i][j-1]-C[i-1][j-1]+S[i][j];
R[i][j]=R[i-1][j]+R[i][j-1]-R[i-1][j-1]+S[i][j];
if(S[i][j]==1){
if(S[i][j-1]==0) C[i][j]--;
if(S[i-1][j]==0) R[i][j]--;
}
}
}
for(int i=1; i<=Q; ++i){
int X,Y,XX,YY,ans=0;
cin>>X>>Y>>XX>>YY;
ans+=SUM[XX][YY]+SUM[X-1][Y-1]-SUM[X-1][YY]-SUM[XX][Y-1];
ans-=R[XX][YY]+R[X][Y-1]-R[XX][Y-1]-R[X][YY];
ans-=C[XX][YY]+C[X-1][Y]-C[X-1][YY]-C[XX][Y];
co(ans);
}
return 0;
} | #include <iostream>
#include <vector>
#include <climits>
#include <algorithm>
using namespace std;
int main() {
while(true) {
int N, K;
cin >> N >> K;
if(!N && !K) break;
vector<vector<int> > v(N, vector<int>(N, -1));
while(K--) {
int cmd;
cin >> cmd;
if(cmd == 0) {
int a, b;
cin >> a >> b;
--a; --b;
cout << v[a][b] << endl;
}
else {
int c, d, e;
cin >> c >> d >> e;
--c; --d;
if(v[c][d] == -1 || e < v[c][d]) {
v[c][d] = v[d][c] = e;
for(int k = 0; k < 2; ++k) {
int mid = k ? c : d;
for(int i = 0; i < N; ++i) {
for(int j = 0; j < N; ++j) {
if(v[i][mid] != -1 && v[mid][j] != -1) {
if(v[i][j] == -1) v[i][j] = v[i][mid]+v[mid][j];
else v[i][j] = min(v[i][j], v[i][mid]+v[mid][j]);
v[j][i] = v[i][j];
}
}
}
}
}
}
}
}
return 0;
} | 0 |
#include <iostream>
#include <cmath>
#include <cstring>
using namespace std;
int main()
{
int n, q, m, d, dt, days[101];
while(cin >> n >> q && n && q) {
memset(days, 0, sizeof(days));
for(int i = 0; i < n; i++) {
cin >> d;
for(int j = 0; j < d; j++) {
cin >> dt;
days[dt]++;
}
}
int ans = 0;
for(int i = 1; i <= 100; i++)
if(days[i] >= q && days[i] > days[ans])
ans = i;
cout << ans << endl;
}
} | #define _USE_MATH_DEFINES
#define INF 100000000
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P> PP;
static const double EPS = 1e-8;
int main(){
int N,Q;
while(~scanf("%d %d",&N,&Q)){
if(N==0 && Q==0) break;
map<int,int> freq;
for(int i=0;i<N;i++){
int num;
scanf("%d",&num);
for(int j=0;j<num;j++){
int day;
scanf("%d",&day);
freq[day]++;
}
}
int maxv=0;
int min_day=INF;
for(map<int,int>::iterator it = freq.begin(); it!=freq.end();it++){
if(it->second >= Q){
if(maxv < it->second){
maxv = it->second;
min_day=it->first;
}
else if(maxv == it->second){
min_day=min(min_day,it->first);
}
}
}
printf("%d\n",min_day >= INF ? 0 : min_day);
}
} | 1 |
#include <stdio.h>
const long long int INF=100000000000000000;
int main(){
int n,m,l,r,c;
long long int g[110][110];
scanf("%d%d",&n,&m);
for(int i=0;i<n;i++)for(int j=0;j<n;j++){
if(i==j)g[i][j]=0;
else g[i][j]=INF;
}
while(m--){
scanf("%d%d%d",&l,&r,&c);
g[l][r]=c;
}
for(int k=0;k<n;k++)for(int i=0;i<n;i++)for(int j=0;j<n;j++){
if(g[i][k]==INF||g[k][j]==INF)continue;
if(g[i][k]+g[k][j]<g[i][j])g[i][j]=g[i][k]+g[k][j];
}
for(int i=0;i<n;i++)if(g[i][i]<0){
printf("NEGATIVE CYCLE\n");
return 0;
}
for(int i=0;i<n;i++){
if(g[i][0]==INF)printf("INF");
else printf("%lld",g[i][0]);
for(int j=1;j<n;j++){
if(g[i][j]==INF)printf(" INF");
else printf(" %lld",g[i][j]);
}
printf("\n");
}
} | #include "bits/stdc++.h"
#define ll long long
#define lld long double
#define MOD 1000000007
#define inf 1000000007
#define pii pair<int,int>
#define f first
#define s second
#define pb push_back
#define mp make_pair
#define all(v) v.begin(),v.end()
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
// ll power(ll x,ll y, ll md=inf){ll res = 1;x%=md;while(y){if(y&1)res = (res*x)%md;x *= x; if(x>=md) x %= md; y >>= 1;}return res;}
using namespace std;
#define endl '\n'
// #define int ll
signed main() {
fast;
int h,w;
cin>>h>>w;
pii v[200002];
for(int i=0;i<h;i++) cin>>v[i].f>>v[i].s;
map<int,int> mp;
for(int i=1;i<=w;i++) mp[i] = 0;
map<int,int> mini = {{0,w}};
for(int i=0;i<h;i++) {
int r = v[i].s;
auto it = mp.lower_bound(v[i].f);
if(r==w) {
while(it!=mp.end() && it->f <= r) {
auto it1 = it++;
auto it2 = mini.find(it1->s);
if(it2->s==1) mini.erase(it2);
else it2->s --;
mp.erase(it1);
}
if(mini.size()==0) cout<<-1<<endl;
else cout<<mini.begin()->f+i+1<<endl;
}
else {
int mn = inf;
while(it!=mp.end() && it->f <= r) {
mn = min(mn, r+1-(it->f)+(it->s));
auto it1 = it++;
auto it2 = mini.find(it1->s);
if(it2->s==1) mini.erase(it2);
else it2->s --;
mp.erase(it1);
}
if(mn<inf) {
if(it!=mp.end() && it->f == r + 1) {
if(it->s > mn) {
auto it1 = mini.find(it->s);
if(it1->s ==1) mini.erase(it1);
else it1->s --;
mini[mn]++;
it->s = mn;
}
}
else {
mp.emplace_hint(it,r+1,mn);
mini[mn]++;
}
cout<<mini.begin()->f+i+1<<endl;
}
else {
if(mini.size()==0) cout<<-1<<endl;
else cout<<mini.begin()->f+i+1<<endl;
}
}
}
} | 0 |
#include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <sstream>
#include <vector>
#include <stack>
#include <set>
#include <map>
#include <cmath>
#include <queue>
#include <deque>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
using namespace std;
typedef unsigned long long int ll;
int main()
{
ll N,T;
cin>>N>>T;
ll sum = T * N;
ll *t = new ll[N];
cin>>t[0];
for(int i = 1; i < N; i++){
cin>>t[i];
if( T > (t[i] - t[i-1])){
ll deltaT = t[i] - t[i-1];
sum -= (T - deltaT);
}
}
cout<<sum<<endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define rep(i, begin, n) for (int i = begin; i < n; i++)
#define repe(i, begin, n) for (int i = begin; i <= n; i++)
#define repr(i, begin, n) for (int i = begin; i > begin - n; i--)
#define repre(i, begin, end) for (int i = begin; i >= end; 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;
}
const int inf = INT_MAX;
const int MOD = 1000000007;
const long long INF = LLONG_MAX;
// -------------------------------------------------------
ll N, T;
vector<Pll> ev;
int main() {
cin >> N >> T;
rep(i, 0, N) {
ll t;
cin >> t;
ev.push_back(Pll(t, 1));
ev.push_back(Pll(t + T, 0));
}
sort(ev.begin(), ev.end());
ll st = 0;
ll end = T;
ll ans = 0;
for (auto e : ev) {
if (e.second == 1) {
if (e.first <= end) {
end = e.first + T;
} else {
ans += end - st;
st = e.first;
end = e.first + T;
}
} else {
if (e.first <= end) {
continue;
} else {
ans += end - st;
st = -1;
end = -1;
}
}
}
ans += end - st;
cout << ans;
}
| 1 |
#include <iostream>
#include <cmath>
#include <vector>
#include <map>
#include <iomanip>
#include <algorithm>
#include <sstream>
#include <string>
#include <math.h>
#include <set>
#include <deque>
#include <queue>
using namespace std;
typedef long long ll;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
int a, b;
string s;
cin >> a >> b >> s;
for (int i = 0 ; i < a ; i++) {
if (s[i] < '0' || s[i] > '9') {
cout << "No";
return 0;
}
}
if (s[a] != '-') {
cout << "No";
return 0;
}
for (int i = a + 1 ; i < s.length() ; i++) {
if (s[i] < '0' || s[i] > '9') {
cout << "No";
return 0;
}
}
cout << "Yes";
} | #include <stdio.h>
int main () {
int a, b;
scanf("%d %d", &a, &b);
int flag = 0;
char str [a+b+1];
scanf("%s", str);
int atr = 0;
for ( int i = 0 ; i < a+b+1 ; i++) {
if (str[i] == '-' && i == a ) {
flag = 1;
}
if (str[i] >= '0' && str[i] <= '9') {
++atr;
}
}
int total = a+b;
if (flag == 1 && atr == total) {
printf("Yes\n");
} else {
printf("No\n");
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int bzmax = 60;
typedef class LinearBasis {
public:
ll a[bzmax];
void insert(ll x) {
for (int i = bzmax; i-- && x; ) {
if ((x >> i) & 1) {
x ^= a[i];
}
if ((x >> i) & 1) {
a[i] = x;
break;
}
}
}
bool query(ll x) {
for (int i = bzmax; i-- && x; ) {
if ((x >> i) & 1) {
x ^= a[i];
}
}
return !x;
}
void reset() {
memset(a, 0, sizeof(a));
}
} LinearBasis;
const int N = 205;
int T, n;
ll a[N];
char s[N];
LinearBasis lb;
void solve() {
lb.reset();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", a + i);
}
scanf("%s", s + 1);
for (int i = n; i; i--) {
if (s[i] == '1') {
if (!lb.query(a[i])) {
puts("1");
return;
}
} else {
lb.insert(a[i]);
}
}
puts("0");
}
int main() {
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
| #include<bits/stdc++.h>
#define rep(i,a) for(int i=(int)0;i<(int)a;++i)
#define rrep(i,a) for(int i=(int)a-1;i>=0;--i)
#define REP(i,a,b) for(int i=(int)a;i<(int)b;++i)
#define RREP(i,a,b) for(int i=(int)a-1;i>=b;--i)
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
typedef std::vector<int> vi;
typedef std::vector<std::vector<int>> vvi;
typedef std::vector<long long> vl;
typedef std::vector<std::vector<long long>> vvl;
using ll=long long;
constexpr ll mod = 1e9 + 7;
constexpr ll INF = 1LL << 60;
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll gcd(ll n, ll m) {
ll tmp;
while (m!=0) {
tmp = n % m;
n = m;
m = tmp;
}
return n;
}
ll lcm(ll n, ll m) {
return abs(n) / gcd(n, m)*abs(m);//gl=xy
}
using namespace std;
ll dp[200005][3];
void solve()
{
int n;
cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a[i];
rep(i,200005){
rep(j,3)dp[i][j] = -INF;
}
rep(i,3)dp[0][i] = 0;
if(n%2==1){
rep(i, n/2)
{
int id = 2 * i;
rep(j,3)
{
if(j==0){
chmax(dp[i + 1][0], dp[i][0] + a[id]);
chmax(dp[i + 1][1], dp[i][0] + a[id+1]);
chmax(dp[i + 1][2], dp[i][0] + a[id + 2]);
}
else if(j==1){
chmax(dp[i + 1][1], dp[i][1] + a[id+1]);
chmax(dp[i + 1][2], dp[i][1] + a[id + 2]);
}
else{
chmax(dp[i + 1][2], dp[i][2] + a[id + 2]);
}
}
}
ll ans = -INF;
rep(i,3){
chmax(ans, dp[n / 2][i]);
}
cout << ans;
}
else{
rep(i,n/2){
int id = i * 2;
rep(j,2){
if(j==0){
chmax(dp[i + 1][0], dp[i][0] + a[id]);
chmax(dp[i + 1][1], dp[i][0] + a[id + 1]);
}
else{
chmax(dp[i + 1][1], dp[i][1] + a[id + 1]);
}
}
}
ll ans = -INF;
rep(i,2){
chmax(ans, dp[n / 2][i]);
}
cout << ans;
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout<<fixed<<setprecision(15);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define irep(i,n) for(int i = 0; i < (int)(n); i++)
#define irep2(i,a,n) for(int i = (int)(a); i <= (int)(n); i++)
#define irrep(i,n) for(int i = (int)(n-1); i > -1; i--)
#define irrep2(i,n,a) for(int i = (int)(n); i >= (int)(a); i--)
#define fi first
#define se second
using namespace std;
using ll = long long;
using v_int = vector<int>;
using v2_int = vector<v_int>;
using v_ll = vector<ll>;
using v2_ll = vector<v_ll>;
using v_string = vector<string>;
using v_bool = vector<bool>;
using v2_bool = vector<v_bool>;
using pii = pair<int, int>;
using mii = map<int, int>;
const double PI = 3.1415926535897932;
const int INF = (int)2e9;
const ll LINF = (ll)2e18;
const ll MOD = 1000000007;
const int dc[8] = {1, -1, 0, 0, 1, -1, 1, -1};
const int dr[8] = {0, 0, 1, -1, 1, 1, -1, -1};
template<typename T, typename U> inline
ostream& operator<<(ostream &o, pair<T,U> &p) {
return o << "{" << p.first << "," << p.second << "}";
}
template<typename T> inline
istream& operator>>(istream &is, vector<T> &vec) {
for(auto &v : vec) { is >> v; }
return is;
}
template<typename T> inline
ostream& operator<<(ostream &os, vector<T> &vec) {
for(auto &v : vec) { os << v << ",";}
return os;
}
template<typename T> inline
ostream& operator<<(ostream &os, vector<vector<T> > &mat) {
for(auto &row : mat) { os << row << endl; }
return os;
}
template<typename T> inline
void chmin(T &a, T b) { a = min(a, b); }
template<typename T> inline
void chmax(T &a, T b) { a = max(a, b); }
int main(void)
{
int n, m;
cin >> n >> m;
v_int input(n+5, 0);
irep(i, m) {
int l, r;
cin >> l >> r;
input[l] += 1;
input[r+1] -= 1;
}
v_int card(n+5, 0);
irep2(i, 1, n) {
card[i] = card[i-1] + input[i];
}
int ans = 0;
irep2(i, 1, n) {
if(card[i] == m) {
ans++;
}
}
cout << ans << endl;
return 0;
} /*atcoder*/
| #include <iostream>
#include <cstdio>
#include <cstring>
#define ll long long
#define ls(_o) (_o << 1)
#define rs(_o) ((_o << 1) | 1)
#define abs(_o) ((_o < 0) ? -(_o) : _o)
using namespace std;
namespace ywy {
inline int get() {
int n = 0;
char c;
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
break;
if (c == '-')
goto s;
}
n = c - '0';
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
n = n * 10 + c - '0';
else
return (n);
}
s:
while ((c = getchar()) || 23333) {
if (c >= '0' && c <= '9')
n = n * 10 - c + '0';
else
return (n);
}
}
ll min1[1000001], min2[1000001], adds[1000001];
int x[200001];
inline void down(int tree) {
if (!adds[tree])
return;
ll c = adds[tree];
adds[tree] = 0;
adds[ls(tree)] += c;
adds[rs(tree)] += c;
min1[ls(tree)] += c;
min2[ls(tree)] += c;
min1[rs(tree)] += c;
min2[rs(tree)] += c;
}
inline void up(int tree) {
min1[tree] = min(min1[ls(tree)], min1[rs(tree)]);
min2[tree] = min(min2[ls(tree)], min2[rs(tree)]);
}
void setpt(int l, int r, int tree, int pt, ll num) {
if (l == r) {
min1[tree] = min(min1[tree], num - l);
min2[tree] = min(min2[tree], num + l);
return;
}
int mid = (l + r) >> 1;
down(tree);
if (pt <= mid)
setpt(l, mid, ls(tree), pt, num);
else
setpt(mid + 1, r, rs(tree), pt, num);
up(tree);
}
ll query1(int rl, int rr, int l, int r, int tree) {
if (rl == l && rr == r)
return (min1[tree]);
int mid = (l + r) >> 1;
down(tree);
if (rl > mid)
return (query1(rl, rr, mid + 1, r, rs(tree)));
if (rr <= mid)
return (query1(rl, rr, l, mid, ls(tree)));
return (min(query1(rl, mid, l, mid, ls(tree)), query1(mid + 1, rr, mid + 1, r, rs(tree))));
}
ll query2(int rl, int rr, int l, int r, int tree) {
if (rl == l && rr == r)
return (min2[tree]);
int mid = (l + r) >> 1;
down(tree);
if (rl > mid)
return (query2(rl, rr, mid + 1, r, rs(tree)));
if (rr <= mid)
return (query2(rl, rr, l, mid, ls(tree)));
return (min(query2(rl, mid, l, mid, ls(tree)), query2(mid + 1, rr, mid + 1, r, rs(tree))));
}
ll query(int l, int r, int tree) {
if (l == r)
return (min1[tree] + l);
int mid = (l + r) >> 1;
down(tree);
return (min(query(l, mid, ls(tree)), query(mid + 1, r, rs(tree))));
}
void ywymain() {
int n = get(), q = get(), a = get(), b = get();
x[0] = a;
memset(min1, 0x3f, sizeof(min1));
memset(min2, 0x3f, sizeof(min2));
setpt(1, n, 1, b, 0);
for (register int i = 1; i <= q; i++) {
x[i] = get();
ll cjr = min(query1(1, x[i], 1, n, 1) + x[i], query2(x[i], n, 1, n, 1) - x[i]);
adds[1] += abs(x[i] - x[i - 1]);
min1[1] += abs(x[i] - x[i - 1]);
min2[1] += abs(x[i] - x[i - 1]);
setpt(1, n, 1, x[i - 1], cjr);
}
cout << query(1, n, 1) << endl;
}
}
int main() {
ywy::ywymain();
return (0);
} | 0 |
#include <bits/stdc++.h>
#include <iostream>
#include <iomanip>
#include <string>
#include <string.h>
using namespace std;
int main() {
int n,m;
string s[200],t[200];
cin >> n;
for(int i = 0; i < n; i++)
cin >> s[i];
cin >> m;
for(int i = 0; i < m; i++)
cin >> t[i];
int sum = 0;
for(int i = 0; i < n; i++) {
int cnt = 1;
for(int j = i+1; j < n; j++)
if(s[i] == s[j]) cnt++;
for(int j = 0; j < m; j++)
if(s[i] == t[j]) cnt--;
sum = max(sum, cnt);
}
cout << sum << endl;
} | #include <iostream>
#include <algorithm>
#include <map>
#include <string>
#include <set>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
#include <bitset>
#include <random>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <complex>
#include <functional>
using namespace std;
#define rep(i,a,b) for(int i = (a); i < int(b); ++i)
#define rrep(i,a,b) for(int i = (b); i --> int(a);)
#define all(v) v.begin(),v.end()
#define trav(x, v) for(auto &x : v)
#define sz(v) int((v).size())
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef long double ld;
void fail(){
puts("No");
exit(0);
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<vi> a(3, vi(n));
trav(v, a) trav(x, v) cin >> x;
vi perm(n);
bool sign[2] = {};
rep(i,0,n){
int ix = (a[0][i]-1)/3;
if(a[1][i] != 3*ix+2) fail();
if(min(a[0][i], a[2][i]) != 3*ix+1
|| max(a[0][i],a[2][i]) != 3*ix+3) fail();
sign[i&1] ^= a[0][i] > a[2][i];
perm[i] = ix;
if((i+ix)&1) fail();
}
int numofcycles[2] = {};
vector<bool> vis(n);
rep(i,0,n) if(!vis[i]){
++numofcycles[i&1];
int j = i;
do {
vis[j] = 1;
j = perm[j];
} while(j != i);
}
int nn[2] = {n/2+(n&1), n/2};
if(sign[0] != (nn[1]+numofcycles[1])%2
|| sign[1] != (nn[0]+numofcycles[0])%2)
fail();
puts("Yes");
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int e;
cin >>e;
while(e)
{
int x=0;
int y=0;
int z=0;
int m=0;
for(z=0;z*z*z<=e;z++)
for(y=0;z*z*z+y*y<=e;y++)
{
x = e-z*z*z-y*y;
if(x<0)
continue;
int t = x+y+z;
if(m ==0||m>t)
m=t;
}
cout <<m<<endl;
cin >>e;
}
return 0;
}
| #include <bits/stdc++.h>
template <typename T> inline void rd(T& x) {
int si = 1; char c = getchar(); x = 0;
while(!isdigit(c)) si = c == '-' ? -1 : si, c = getchar();
while(isdigit(c)) x = x * 10 + c - 48, c = getchar();
x *= si;
}
template <typename T, typename... Args>
inline void rd(T& x, Args&... args) { rd(x); rd(args...); }
#define fi first
#define se second
typedef long long ll;
typedef double ff;
typedef std::pair<int, int> pii;
const int kN = 1e5 + 5;
int a[kN], n;
int Gcd(int x, int y) { return y ? Gcd(y, x % y) : x; }
void Div() {
int g = a[1];
for(int i = 2; i <= n; ++i) g = Gcd(g, a[i]);
for(int i = 1; i <= n; ++i) a[i] /= g;
}
int main() {
int cur = 0; rd(n);
for(int i = 1; i <= n; ++i) rd(a[i]);
while(true) {
int cnt = 0, ecnt = 0, p; bool flag = false;
for(int i = 1; i <= n; ++i) {
if(a[i] % 2 == 0) ++cnt;
else p = i, ++ecnt;
if(a[i] == 1) flag = true;
}
if(flag) return printf((cnt % 2 == 1) ^ cur ? "First" : "Second"), 0;
if(cnt % 2 == 1) return printf(cur ? "Second" : "First"), 0;
if(ecnt > 1 && cnt % 2 == 0) return printf(cur ? "First" : "Second"), 0;
--a[p]; Div(); cur ^= 1;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
const int maxN = 1000009;
int N, X, b[maxN], p[maxN], l[maxN], r[maxN];
/*int lg, N, X, aib[2 * maxN], val[2 * maxN];
long long aibSum[2 * maxN], ans = 1LL << 60;
pair < int, int > h[2 * maxN];
pair < int, pair < int, int > > v[maxN];
set < int > S;
void able (int pos, int x)
{
///val = +-1 (aka enable or disable)
if (x < 0) S.erase (pos);
else S.insert (pos);
int y = val[pos] * x;
while (pos <= 2 * N)
aibSum[pos] += y,
aib[pos] += x,
pos += pos - (pos & (pos - 1));
}
void attempt (long long need)
{
///max aibSum * X < need
int pos = 0, used = 0;
for (int i=lg; i>=0; i--)
if (pos + (1 << i) <= 2 * N && 1LL * X * aibSum[pos + (1 << i)] < need)
pos |= 1 << i, need -= 1LL * X * aibSum[pos], used += aib[pos];
for (auto it : S)
printf ("%d ", it);
printf ("? >= %d\n", pos);
auto it = S.lower_bound (pos + 1);
assert (it != S.end ());
int leftover = (need + val[*it] - 1) / val[*it];
long long curr = 1LL * X * used + leftover;
if (curr < ans)
ans = curr;
}*/
long long f (int i)
{
return 1LL * (X - b[i]) * r[i] + 1LL * b[i] * l[i];
}
bool cmp (int i, int j)
{
return f (i) > f (j);
}
bool ok (long long moves)
{
int cnt = moves / X, smth = moves % X;
long long toOvercome = 0;
for (int i=1; i<=N; i++)
toOvercome += 1LL * l[i] * b[i];
long long firstCntSum = 0;
for (int i=1; i<=cnt; i++)
firstCntSum += f(p[i]);
for (int i=1; i<=N; i++)
{
///assume i is smth
long long curr = toOvercome;
int pos = p[i];
if (b[pos] >= smth) curr -= 1LL * smth * l[pos];///unimportant
else curr += 1LL * b[pos] * (r[pos] - l[pos]), curr -= (1LL * smth * r[pos]);
curr -= firstCntSum;
if (i <= cnt)
curr -= f (p[cnt + 1]) - f (pos); ///this should've been in firstCntSum
if (curr <= 0)
return 1;
}
return 0;
}
int main ()
{
//freopen ("input", "r", stdin);
//freopen ("output", "w", stdout);
scanf ("%d %d", &N, &X);
/*for (int i=1; i<=N; i++)
scanf ("%d %d %d", &v[i].first, &v[i].second.first, &v[i].second.second);
sort (v + 1, v + N + 1, cmp);
for (int i=1; i<=N; i++)
h[2 * i - 1] = {-v[i].second.first, i},
h[2 * i] = {-v[i].second.second, -i};
sort (h + 1, h + 2 * N + 1);
for (int i=1; i<=2 * N; i++)
{
val[i] = -h[i].first;
if (h[i].second > 0) v[h[i].second].second.first = i;
else v[-h[i].second].second.second = i;
}
lg = 0;
while ((2 << lg) <= 2 * N)
lg ++;
long long opponentValue = 0;
for (int i=1; i<=N; i++)
opponentValue += 1LL * v[i].first * val[v[i].second.first],
able (v[i].second.first, +1); ///all unimportant
attempt (opponentValue);
for (int i=1; i<=N; i++)
opponentValue += 1LL * v[i].first * (val[v[i].second.second] - val[v[i].second.first]),
able (v[i].second.first, -1),
able (v[i].second.second, +1),
attempt (opponentValue);
printf ("%lld\n", ans);*/
for (int i=1; i<=N; i++)
scanf ("%d %d %d", &b[i], &l[i], &r[i]), p[i] = i;
sort (p + 1, p + N + 1, cmp);
{
long long p = 0, u = 1LL * N * X - 1, mid, ras = 1LL * N * X;
while (p <= u)
{
mid = (p + u) >> 1;
if (ok (mid))
ras = mid, u = mid - 1;
else p = mid + 1;
}
printf ("%lld\n", ras);
}
return 0;
}
| #pragma GCC optimize("O3")
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using T = tuple<int, int, int>;
template <class T> inline T chmax(T &a, const T b) {return a = (a < b) ? b : a;}
template <class T> inline T chmin(T &a, const T b) {return a = (a > b) ? b : a;}
constexpr int MOD = 1e9 + 7;
constexpr int inf = 1e9;
constexpr long long INF = 1e18;
constexpr double pi = acos(-1);
constexpr double EPS = 1e-10;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
typedef complex<double> Point, Vector;
typedef pair<Point, Point> Segment, Line;
typedef vector<Point> Polygon;
typedef pair<Point, double> Circle;
#define X real()
#define Y imag()
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)
namespace std{
bool operator<(const Point &a, const Point &b){
return !equals(a.X, b.X) ? a.X < b.X : a.Y < b.Y;
}
bool cmp_y(const Point &a, const Point &b) {
return !equals(a.Y, b.Y) ? a.Y < b.Y : a.X < b.X;
}
}
double dot(Vector a, Vector b){
return a.X * b.X + a.Y * b.Y;
}
double cross(Vector a, Vector b){
return a.X * b.Y - a.Y * b.X;
}
double norm(Vector a){
return a.X * a.X + a.Y * a.Y;
}
double abs(Vector a){
return sqrt(norm(a));
}
static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;
int ccw(Point p0, Point p1, Point p2){
Vector a = p1 - p0;
Vector b = p2 - p0;
if(cross(a, b) > EPS) return COUNTER_CLOCKWISE;
if(cross(a, b) < -EPS) return CLOCKWISE;
if(dot(a, b) < -EPS) return ONLINE_BACK;
if(norm(a) < norm(b)) return ONLINE_FRONT;
return ON_SEGMENT;
}
Polygon convexHull(Polygon ps){
int n = ps.size();
sort(ps.begin(), ps.end(), cmp_y);
int k = 0;
Polygon convex(n * 2);
for(int i=0; i<n; i++){
while(k >= 2 && ccw(convex[k-2], convex[k-1], ps[i]) == CLOCKWISE) k--;
convex[k++] = ps[i];
}
for(int i=n-2, t=k; i>=0; i--){
while(k > t && ccw(convex[k-2], convex[k-1], ps[i]) == CLOCKWISE) k--;
convex[k++] = ps[i];
}
convex.resize(k-1);
return convex;
}
double arg(Vector p){
return atan2(p.Y, p.X);
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin>>n;
Polygon pol;
vector<double> x(n), y(n);
for(int i=0; i<n; i++){
cin>>x[i]>>y[i];
pol.emplace_back(x[i], y[i]);
}
pol = convexHull(pol);
int m = pol.size();
map<pair<double, double>, double> ans;
for(int i=0; i<m; i++){
Vector A = pol[(i+1)%m] - pol[i];
Vector B = pol[(i-1+m)%m] - pol[i];
Vector C = pol[(i+1)%m] - pol[(i-1+m)%m];
double cos_i = (abs(A) * abs(A) + abs(B) * abs(B) - abs(C) * abs(C)) / (2 * abs(A) * abs(B));
double theta = acos(cos_i);
theta = pi - theta;
double alpha = theta / 2 / pi;
ans[make_pair(pol[i].X, pol[i].Y)] = alpha;
}
for(int i=0; i<n; i++){
printf("%.8f\n", ans[make_pair(x[i], y[i])]);
}
} | 0 |
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
typedef long long ll;
using Graph = vector<vector<int>>;
const int MOD = 1000000007;
const int INF_32 = 1LL << 30;
const int64_t INF_64 = 1LL << 60;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T& val)
{
std::fill((T*)array, (T*)(array + N), val);
}
// dp[c1][c2][c3]: (1個の皿がc1枚，2個の皿がc2枚，3個の皿がc3枚の状態ですべて食べるまでの操作回数の期待値)
double dp[305][305][305];
int N;
double rec(int c1, int c2, int c3)
{
if (dp[c1][c2][c3] != -1.0)
return dp[c1][c2][c3];
double ret = N;
if (c1 >= 1) {
ret += c1 * rec(c1 - 1, c2, c3);
}
if (c2 >= 1) {
ret += c2 * rec(c1 + 1, c2 - 1, c3);
}
if (c3 >= 1) {
ret += c3 * rec(c1, c2 + 1, c3 - 1);
}
ret /= (c1 + c2 + c3);
return dp[c1][c2][c3] = ret;
}
int main()
{
cin >> N;
Fill(dp, -1.0);
dp[0][0][0] = 0;
int c1, c2, c3;
c1 = c2 = c3 = 0;
for (int i = 0; i < N; i++) {
int a;
cin >> a;
if (a == 1)
c1++;
if (a == 2)
c2++;
if (a == 3)
c3++;
}
cout << fixed << setprecision(9);
cout << rec(c1, c2, c3) << endl;
return 0;
} | #include "bits/stdc++.h"
#define ll long long
#define mp(a, b) make_pair(a, b)
using namespace std;
typedef pair<ll, ll> pairs;
typedef pair<ll, pairs> tpl;
ll c[4];
double dp[301][301][301];
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
ll n, a;
cin >> n;
for (ll i = 0; i < n; i++)
cin >> a, c[a]++;
dp[0][0][0] = 0;
for (ll i = 0; i <= n; i++)
{
for (ll j = 0; j <= n; j++)
{
for (ll k = 0; k <= n; k++)
{
double z = n - (i + j + k), val = 1;
if (z == n)
continue;
if (i + j + k > n)
continue;
if (i > 0)
val += (1.0 * i / n) * dp[i - 1][j + 1][k];
if (j > 0)
val += (1.0 * j / n) * dp[i][j - 1][k + 1];
if (k > 0)
val += (1.0 * k / n) * dp[i][j][k - 1];
if (z > 0)
val /= (1.0 - 1.0 * z / n);
dp[i][j][k] = val;
}
}
}
cout << setprecision(9) << fixed << dp[c[3]][c[2]][c[1]];
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
vector<int> AB(2);
for (int i=0;i<2;++i) cin >> AB[i];
int K; cin >> K;
for (int i=0;i<K;++i){
if (AB[i&1]&1) --AB[i&1];
AB[(i&1)^1]+=AB[i&1]/2;
AB[i&1]/=2;
}
cout << AB[0] << ' ' << AB[1] << '\n';
} | #define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
using namespace std;
typedef long long int lli;
typedef unsigned long long int ulli;
typedef long double ld;
#define vec(s) vector<s>
#define vvec(s) vector<vector<s>>
typedef vector<lli> vi;
typedef vector<vi> vvi;
typedef pair<lli,lli> pii;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define Yes(x) cout<<(x?"Yes":"No")<<endl;
#define YES(x) cout<<(x?"YES":"NO")<<endl;
#define out(s) cout<<s<<endl;
#define Reverse(x) reverse(all(x));
#define Sort(x) sort(all(x));
#define pb(s) push_back(s);
#define sp " "
#define INF 10000000000
#define LINF 9000000000000000000
#define all(s) s.begin(),s.end()
void vout(vi v){
for(lli i=0;i<v.size();i++)
cout<<v.at(i)<<endl;
}
int main(){
cout << std::fixed << std::setprecision(10);
lli a, b,k;
cin >> a >> b >> k;
lli c = true;
rep(i, k) {
if(c)
{
if(a%2!=0)
{
a--;
}
b += a / 2;
a -= a / 2;
c = false;
}
else
{
if(b%2!=0)
{
b--;
}
a += b / 2;
b -= b / 2;
c = true;
}
}
out(a << sp << b);
} | 1 |
#include<bits/stdc++.h>
typedef long long ll;
typedef std::pair<ll,ll> P;
#define rep(i,n) for(int i = 0; i < int(n); i++)
using namespace std;
template<class T> inline bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
constexpr ll mod = 1e9 + 7;
struct UnionFind {
public:
vector <ll> par; //
vector <ll> siz; //
UnionFind() {}
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
ll root(ll x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) {
return root(x) == root(y);
}
ll size(ll x) {
return siz[root(x)];
}
};
int main() {
ll n;
cin >> n;
vector<int> ans;
for (int i = 0; i < 60; i++) {
ll m = n % (1LL << (i+1));
if (m) {
ans.push_back(1);
ll sub = 1LL << i;
if (i % 2 == 1) {
sub *= -1;
}
n -= sub;
}
else ans.push_back(0);
if (n == 0) break;
}
reverse(ans.begin(), ans.end());
for (auto a : ans) {
cout << a;
}
cout << endl;
return 0;
}
| //高知能系Vtuberの高井茅乃です。
//Twitter: https://twitter.com/takaichino
//YouTube: https://www.youtube.com/channel/UCTOxnI3eOI_o1HRgzq-LEZw
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INTINF 1999999999
#define REP(i,n) for(int i=0;i<n;i++)
#define REP1(i,n) for(int i=1;i<=n;i++)
#define MODA 1000000007
int main() {
ll ans = 0;
ll tmp = 0;
ll n;
cin >> n;
string s = "";
if(n==0) cout << 0 << endl;
else {
while(tmp != n){
//cout << s.size() << " " << tmp << " " << s << endl;
if(abs(n-tmp)%((ll)1<<(s.size()+1))==0) s = "0" + s;
else {
tmp += (ll)pow(-1, s.size()) * ((ll)1<<s.size());
s = "1" + s;
}
}
cout << s << endl;
}
} | 1 |
#include<bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define fst first
#define snd second
using namespace std;
typedef long long ll;
typedef double db;
typedef long double ldb;
template<class T> inline void checkmin(T &a,const T &b){if(b<a) a=b;}
template<class T> inline void checkmax(T &a,const T &b){if(b>a) a=b;}
const int inf=1e9+10;
const int maxn=2e5+10;
const ll base=1e9+7;
const ll mod=2038077799;
ll ha,hb,a[maxn],b[maxn],difa[maxn],difb[maxn];
int n;
ll getval(ll x,ll k,ll mod){
if(k==0) return 1ll;
if(k==1) return x;
ll res=getval(x,k/2,mod);
res=(res*res)%mod;
if(k&1) res=(res*x)%mod;
return res;
}
int main(){
scanf("%d",&n);
for(int i=0;i<n;i++) scanf("%lld",&a[i]);
for(int i=0;i<n;i++) scanf("%lld",&b[i]);
for(int i=0;i<n;i++) difa[i]=a[i]^a[(i+1)%n];
for(int i=0;i<n;i++) difb[i]=b[i]^b[(i+1)%n];
ha=hb=0;
for(int i=0;i<n;i++){
ha*=base; ha%=mod;
ha+=difa[i]; ha%=mod;
}
for(int i=0;i<n;i++){
hb*=base; hb%=mod;
hb+=difb[i]; hb%=mod;
}
ll val=getval(base,n-1,mod);
vector <int> ans;
for(int i=0;i<n;i++){
if(ha==hb){
ans.pb(i);
}
ll now=val*difa[i]; now%=mod;
ha+=mod-now; ha%=mod;
ha*=base; ha%=mod;
ha+=difa[i]; ha%=mod;
}
for(int i=0;i<ans.size();i++){
cout<<ans[i]<<" "<<(a[0]^b[(n-ans[i])%n])<<endl;
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
struct Stat {
int unmatchedOpening, unmatchedClosing, index;
Stat(int _uo, int _uc, int _index): unmatchedOpening(_uo), unmatchedClosing(_uc), index(_index) {}
};
//Comparing two stats which unmatchedOpening - unmatchedClosing >= 0
bool cmpFirst(Stat a, Stat b) {
return a.unmatchedClosing < b.unmatchedClosing;
}
//Comparing two stats which unmatchedOpening - unmatchedClosing < 0
bool cmpSecond(Stat a, Stat b) {
return a.unmatchedOpening > b.unmatchedOpening;
}
//{unmatchedOpening, unmatchedClosing}
pair<int, int> getStat(string s) {
int unmatchedOpening = 0;
int unmatchedClosing = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '(') {
unmatchedOpening += 1;
} else {
if (unmatchedOpening > 0)
unmatchedOpening -= 1;
else
unmatchedClosing += 1;
}
}
return make_pair(unmatchedOpening, unmatchedClosing);
}
int main() {
int n;
vector<Stat> first; //unmatchedOpening - unmatchedClosing >= 0
vector<Stat> second; //unmatchedOpening - unmatchedClosing < 0
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
auto stat = getStat(s);
if (stat.first - stat.second >= 0)
first.push_back(Stat(stat.first, stat.second, i));
else
second.push_back(Stat(stat.first, stat.second, i));
}
sort(first.begin(), first.end(), cmpFirst);
sort(second.begin(), second.end(), cmpSecond);
bool valid = true;
int balance = 0;
for (auto f: first) {
if (balance - f.unmatchedClosing < 0) {
valid = false;
break;
}
balance -= f.unmatchedClosing;
balance += f.unmatchedOpening;
}
for (auto s: second) {
if (balance - s.unmatchedClosing < 0) {
valid = false;
break;
}
balance -= s.unmatchedClosing;
balance += s.unmatchedOpening;
}
if (balance != 0)
valid = false;
if (valid) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
/*
Test cases:
4
(
))(((
)((
)))
*/
| 0 |
#include<iostream>
#include<algorithm>
using namespace std;
int a[105];
int bubble_sort(int a[], int n)
{
bool flag = true;
int cnt = 0;
for(int i = n-1; i >= 0; i--)
{
flag = true;
for(int j = 0; j < i; j++)
{
if(a[j+1] < a[j])
{
swap(a[j+1], a[j]);
cnt++;
flag = false;
}
}
if(flag)
{
for(int i = 0; i < n; i++)
{
if(i)
cout << " ";
cout << a[i];
}
cout << endl;
return cnt;
}
}
}
int main ()
{
int n;
cin >> n;
for(int i = 0; i < n; i++)
{
cin >> a[i];
}
cout << bubble_sort(a, n) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define PB push_back
#define F first
#define S second
#define MP make_pair
#define all(x) x.begin(), x.end()
#define watch(x) cout<<#x<<" : "<<x<<endl
#define tr(container, it) for(typeof(container.begin()) it = container.begin(); it != container.end(); it++)
#define testCases int tt;cin>>tt; while(tt--)
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<pair<int, int>> vpii;
typedef vector<string> vs;
int main() {
fastio;
int n;
cin >> n;
set<int> s;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
s.insert(temp);
}
if (s.size() == n) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define ll long long
#define BIT_FLAG_0 (1<<0) // 0000 0000 0000 0001
#define BIT_FLAG_1 (1<<1) // 0000 0000 0000 0010
#define BIT_FLAG_2 (1<<2) // 0000 0000 0000 0100
#define BIT_FLAG_3 (1<<3) // 0000 0000 0000 1000
#define BIT_FLAG_4 (1<<4) // 0000 0000 0001 0000
#define BIT_FLAG_5 (1<<5) // 0000 0000 0010 0000
#define BIT_FLAG_6 (1<<6) // 0000 0000 0100 0000
#define BIT_FLAG_7 (1<<7) // 0000 0000 1000 0000
int main(){
int r;
long double ans;
cin >> r;
ans=r*2*M_PI;
cout << fixed << setprecision(20) << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
int main()
{
double U = 3.14;
int R;
cin >> R >> U;
cout << R * 2 * U <<"\n";
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,N) for(i=0;i<N;i++)
typedef long long ll;
typedef pair<int, int> P;
typedef struct{
int first;
int second;
int third;
}T;
//昇順
bool comp_Se(T& l, T& r){
return l.second < r.second;
}
ll mod = 1e9+7;
int main(void){
int i,j,N,X;
cin >> N >> X;
vector<ll> v(N);
REP(i,N) cin >> v[i];
sort(v.begin(),v.end());
//dp[i][j]:jをXの最初として，i+1回操作(ただしi+1番目まで)を行った時の総和
ll dp[N][X+1];
REP(j,X+1){
dp[0][j] = j%v[0];
}
for(i=1;i<N;i++){
REP(j,X+1){
//dp[i-1][j%v[i]]:最初に行う場合
//dp[i-1][j]*i 最初に行わない場合
dp[i][j] = dp[i-1][j%v[i]] + dp[i-1][j] * i;
dp[i][j] %= mod;
}
}
cout << dp[N-1][X] << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <list>
#include <cassert>
#include <ctime>
#include <climits>
using namespace std;
#define PB push_back
#define MP make_pair
#define SZ(v) ((int)(v).size())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) FORE(i,0,n)
#define FORSZ(i,a,v) FOR(i,a,SZ(v))
#define REPSZ(i,v) REP(i,SZ(v))
typedef long long ll;
typedef unsigned long long ull;
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a%b); }
const int MAXN=200;
const int MAXX=100000;
const int MOD=1000000007;
void inc(int &a,int b) { if((a+=b)>=MOD) a-=MOD; }
int n,sx;
int a[MAXN];
int ways[MAXN+1][MAXX+1];
int solve() {
sort(a,a+n); reverse(a,a+n);
memset(ways,0,sizeof(ways)); ways[0][sx]=1;
REP(i,n) REPE(x,sx) if(ways[i][x]!=0) {
inc(ways[i+1][x],(ll)(n-i-1)*ways[i][x]%MOD);
inc(ways[i+1][x%a[i]],ways[i][x]);
}
int ret=0; REPE(x,sx) inc(ret,(ll)x*ways[n][x]%MOD); return ret;
}
void run() {
scanf("%d%d",&n,&sx);
REP(i,n) scanf("%d",&a[i]);
printf("%d\n",solve());
}
int main() {
run();
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>;
const int INF = 1e9;
const int dx[] = {-1,0,1,0};
const int dy[] = {0,-1,0,1};
#define PI 3.14159265358979323846264338327950L
#define MOD 1000000007
//setprecision(15)
int main() {
int A, B; cin >> A >> B;
if (B == 1) {
cout << "0" << endl; return 0;
}
if (B - A <= 0) {
cout << "1" << endl; return 0;
}
B -= A;
int cnt = 1;
while (1) {
cnt++;
if (B - (A - 1) <= 0) {
cout << cnt << endl;
return 0;
} else {
B -= A - 1;
}
}
} | #include<bits/stdc++.h>
#define INF 2000000000
#define MOD 1000000007
#define EPS (1e-10)
using namespace std;
int main(int argc, char *argv[]) {
int A,B; cin >> A >> B;
int skt = 1;
int ans = 0;
while(B > skt) {
skt--;
skt += A;
ans++;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <string>
#include <numeric>
#include <cmath>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
using P = pair<ll, ll>;
template<class T> inline bool chmin(T& a,T b) {if (a > b) {a = b; return true;} return false;}
template<class T> inline bool chmax(T& a,T b) {if (a < b) {a = b; return true;} return false;}
const ll MOD = 1000000007;
const int INF = 1<<30;
//const ll INF = (ll)1e18 + 1;
int main(){
int N, K; cin >> N >> K;
vector<ll> x(N); rep(i, N) cin >> x[i];
ll ans = INF;
for (int i = 0; i < N; ++i){
if (i + K - 1 >= N) continue;
ll tmp = min(abs(x[i]) + abs(x[i + K - 1] - x[i]), abs(x[i + K - 1]) + abs(x[i + K - 1] - x[i]));
//cout << x[i] << " " << x[i + K] << endl;
ans = min(ans, tmp);
}
cout << ans << endl;
}
| #include<bits/stdc++.h>
using namespace std;
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cout<<fixed; cout<<setprecision(12);
#define randomINT mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#define newl cout<<"\n"
#define DISP(as) for(auto it : as) cout<<it<<" ";newl;
#define all(x) (x).begin(),(x).end()
#define mset(x,val) memset(x,val,sizeof(x))
#define newl cout<<"\n"
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define dline cerr<<"///REACHED///\n";
#define deb1(x) cerr<<#x<<" = "<<x<<'\n';
#define deb2(x,y) cerr<<'['<<#x<<','<<#y<<"] = "<<'['<<x<<','<<y<<']'<<'\n';
#define deb3(x,y,z) cerr<<'['<<#x<<','<<#y<<','<<#z<<"] = "<<'['<<x<<','<<y<<','<<z<<']'<<'\n';
typedef long long ll;
typedef long double ld;
typedef vector<ll> vll;
typedef pair<ll , ll> pll;
typedef pair<ld, ld> pld;
typedef unordered_map<ll, ll> um;
typedef vector<pll> vpll;
const ll MAX5 = 1e+5 + 7;
const ll MAX7 = 1e+7 + 7;
const ll MAXN = MAX7;
const ll INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
const ll MOD = 1e+9 + 7;
// <------------- Declare Variables Here ------------> //
ll T = 1;
ll n, x, m, y, k, z, N;
string s, t, d, c;
// <------------- Implement Functions Here ----------> //
// <------------- Start of main() -------------------> //
void MAIN() {
cin >> n >> k ;
vll pos,neg;
bool zero = false;
for(ll i=0;i<n;i++) {
cin>>x;
if(x == 0) zero = true;
if(x > 0) pos.pb(x);
if(x < 0) neg.pb(x);
}
reverse(all(neg));
//for(ll i=1;i<pos.size();i++) pos[i]+=pos[i-1];
//for(ll i=1;i<neg.size();i++) neg[i]+=neg[i-1];
for(ll i=0;i<neg.size();i++) neg[i]=-neg[i];
k-=zero;
ll ans = INT_MAX;
ll i=k,j=0;
while(i>=0) {
if(neg.size() >= i && pos.size() >= j) {
ll val = ((i)?neg[i-1]:0) + ((j)?pos[j-1]:0);
//cout<<i<<" "<<j<<" "<<val;newl;
if(i && j) val += min(neg[i-1],pos[j-1]);
//cout<<i<<" "<<j<<" "<<val;newl;
ans = min(ans, val);
}
i--;
j++;
}
cout<<ans;
}
int main() {
fastio; randomINT;
//cin >> T;
while (T--) {
MAIN();
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0; i<n; i++)
#define INF 1000000
using namespace std;
int main(){
//木曜日を０とする
int table[12][31];
int cnt=0,day;
for(int i=1; i<=12; i++){
if(i == 4 || i == 6 || i == 9 || i == 11) day = 30;
else if(i == 2) day = 29;
else day = 31;
for(int j=1; j<=day; j++) {
if(cnt == 7) cnt = 0;
table[i-1][j-1] = cnt;
cnt++;
}
}
int a,b;
while(cin >> a >> b){
if(a == 0 && b == 0) break;
if(table[a-1][b-1] == 0) cout << "Thursday" << endl;
if(table[a-1][b-1] == 1) cout << "Friday" << endl;
if(table[a-1][b-1] == 2) cout << "Saturday" << endl;
if(table[a-1][b-1] == 3) cout << "Sunday" << endl;
if(table[a-1][b-1] == 4) cout << "Monday" << endl;
if(table[a-1][b-1] == 5) cout << "Tuesday" << endl;
if(table[a-1][b-1] == 6) cout << "Wednesday" << endl;
}
return 0;
}
| #include<iostream>
#include<string>
using namespace std;
int main()
{
string day[]={"Wednesday","Thursday","Friday","Saturday","Sunday","Monday","Tuesday"};
int Mon[12]={31,29,31,30,31,30,31,31,30,31,30,31};
int m,d;
while(cin>>m>>d,m*d){
int allDay=d;
for(int i=0;i<m-1;i++){
allDay += Mon[i];
}
cout<<day[allDay%7]<<endl;
}
} | 1 |
#include <iostream>
#include <utility>
#include <map>
#include <vector>
#include <algorithm>
#include <queue>
#include <math.h>
#include <stack>
#include <set>
#include <deque>
#include <cmath>
using namespace std;
typedef long long ll;
ll mod = 1e9+7;
//ll mod = 998244353;
#define rep(i,n) for(int i = 0; i < (n); ++i)
int main() {
int n;
cin >> n;
string s, t;
cin >> s >> t;
int ans = n;
rep(i, n) {
bool ok = true;
rep(j, n - i) {
if (s[i+j] != t[j]) {
ok = false;
}
}
if (ok) {
cout << ans << endl;
return 0;
}
++ans;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define rep2(i,n) for(int i=0;i<=n;i++)
#define repr(i,a,n) for(int i=a;i<n;i++)
#define all(a) a.begin(),a.end()
#define P pair<long long,long long>
#define uni(e) e.erase(unique(e.begin(),e.end()),e.end())
#define double long double
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 INF=1e10;
int MOD=1e9+7;
signed main(){
int a,b,c;
cin>>a>>b>>c;
cout<<max(a+b,max(a-b,a*b))<<endl;
} | 0 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <cmath>
#include <climits>
#include <iomanip>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
int main(){
ll n;
cin >> n;
cout << n / 3 << endl;
} | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i=0;i<(n);++i)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define all(x) (x).begin(), (x).end()
#define PI 3.14159265358979323846264338327950L
using namespace std;
typedef long long ll;
typedef long double ld;
int main() {
string s,t;
cin>>s>>t;
cout<<t<<s;
} | 0 |
#include<bits/stdc++.h>
#define ri register int
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> poly;
#define pb push_back
#define fi first
#define se second
const int rlen=1<<18|1;
char buf[rlen],*ib=buf,*ob=buf;
#define gc() (((ib==ob)&&(ob=(ib=buf)+fread(buf,1,rlen,stdin)),ib==ob)?-1:*ib++)
inline int read() {
int ans=0;
char ch=gc();
while(!isdigit(ch)) ch=gc();
while(isdigit(ch)) ans=((ans<<2)+ans<<1)+(ch^48),ch=gc();
return ans;
}
char c3[3][3]={
{'.','.','a'},
{'.','.','a'},
{'a','a','.'}
};
char c4[4][4]={
{'a','b','e','e'},
{'a','b','f','f'},
{'c','c','g','h'},
{'d','d','g','h'}
};
char c5[5][5]={
{'a','a','b','b','a'},
{'b','c','c','.','a'},
{'b','.','.','c','b'},
{'a','.','.','c','b'},
{'a','b','b','a','a'}
};
char c7[7][7]={
{'a','.','a','a','.','a','a'},
{'a','b','.','.','b','b','.'},
{'.','b','.','a','a','.','a'},
{'a','.','a','.','.','.','a'},
{'a','.','a','.','.','b','.'},
{'.','b','b','.','.','b','a'},
{'a','a','.','a','a','.','a'}
};
int n;
char ans[1005][1005];
int main() {
#ifdef ldxcaicai
freopen("lx.in","r",stdin);
#endif
cin>>n;
if(n<3) puts("-1");
else {
for(ri i=1;i<=n;++i) for(ri j=1;j<=n;++j) ans[i][j]='.';
if(n%3==0) {
for(ri i=1;i<=n;i+=3) for(ri dx=0;dx<3;++dx)
for(ri dy=0;dy<3;++dy)ans[i+dx][i+dy]=c3[dx][dy];
}
else {
int x=-1,y=-1,z=-1;
for(ri i=0;i*4<=n&&x==-1;++i) for(ri j=0;i*4+j*5<=n;++j) if((n-i*4-j*5)%7==0) {
x=i,y=j,z=(n-i*4-j*5)/7;
break;
}
int ps=1;
while(x--) {
for(ri dx=0;dx<4;++dx) for(ri dy=0;dy<4;++dy) ans[ps+dx][ps+dy]=c4[dx][dy];
ps+=4;
}
while(y--) {
for(ri dx=0;dx<5;++dx) for(ri dy=0;dy<5;++dy) ans[ps+dx][ps+dy]=c5[dx][dy];
ps+=5;
}
while(z--) {
for(ri dx=0;dx<7;++dx) for(ri dy=0;dy<7;++dy) ans[ps+dx][ps+dy]=c7[dx][dy];
ps+=7;
}
}
for(ri i=1;i<=n;++i,puts("")) for(ri j=1;j<=n;++j) cout<<ans[i][j];
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#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=(b)-1; i>=(a); --i)
#define DEBUG(x) cout<<#x<<": "<<(x)<<'\n'
#define DEBUG_VEC(v) cout<<#v<<":";REP(i, v.size())cout<<' '<<v[i];cout<<'\n'
#define ALL(a) (a).begin(), (a).end()
template<typename T> inline void CHMAX(T& a, const T b) {if(a<b) a=b;}
template<typename T> inline void CHMIN(T& a, const T b) {if(a>b) a=b;}
constexpr ll MOD=1000000007ll;
// constexpr ll MOD=998244353ll;
#define FIX(a) ((a)%MOD+MOD)%MOD
const double EPS=1e-11;
#define EQ0(x) (abs((x))<EPS)
#define EQ(a, b) (abs((a)-(b))<EPS)
char ans[1252][1252];
string three[3]={"aa.", "..a", "..a"};
string four[4]={"aabc", "ddbc", "bcaa", "bcdd"};
string five[5]{"aabba", "bcc.a", "b..cb", "a..cb", "abbaa"};
string six[6]={"aabc..", "ddbc..", "..aabc", "..ddbc", "bc..aa", "bc..dd"};
string seven[7]={"aabbcc.", "dd.dd.a", "..d..da", "..d..db", "dd.dd.b", "..d..dc", "..d..dc"};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout<<setprecision(10)<<fixed;
int n;
cin>>n;
REP(i, n){
REP(j, n){
ans[i][j]='.';
}
}
if(n==2){
cout<<-1<<'\n';
return 0;
}
int cur=n;
while(cur>7){
REP(i, 4){
REP(j, 4){
ans[i+n-cur][j+n-cur]=four[i][j];
}
}
cur-=4;
}
if(cur==3){
REP(i, 3){
REP(j, 3){
ans[i+n-cur][j+n-cur]=three[i][j];
}
}
}
else if(cur==4){
REP(i, 4){
REP(j, 4){
ans[i+n-cur][j+n-cur]=four[i][j];
}
}
}
else if(cur==5){
REP(i, 5){
REP(j, 5){
ans[i+n-cur][j+n-cur]=five[i][j];
}
}
}
else if(cur==6){
REP(i, 6){
REP(j, 6){
ans[i+n-cur][j+n-cur]=six[i][j];
}
}
}
else{
REP(i, 7){
REP(j, 7){
ans[i+n-cur][j+n-cur]=seven[i][j];
}
}
}
REP(i, n){
REP(j, n){
cout<<ans[i][j];
}
cout<<'\n';
}
return 0;
}
| 1 |
#include <iostream>
using namespace std;
const int MAX = 100000;
int seq[MAX];
int partition(int a[], int l, int r) {
int x = a[r];
int i = l - 1;
for (int j = l; j < r; ++j) {
if (a[j] <= x) {
++i;
swap(a[j], a[i]);
}
}
swap(a[i+1], a[r]);
return i + 1;
}
int
main(int argc, const char *argv[])
{
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> seq[i];
int q = partition(seq, 0, n-1);
for (int i = 0; i < n; ++i) {
if (i) cout << " ";
if (i == q) cout << "[";
cout << seq[i];
if (i == q) cout << "]";
}
cout << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int,int> pi;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pi> vpi;
typedef vector<pll> vpll;
#define ff first
#define ss second
#define pb push_back
#define IOS ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define D(x) cout << #x << " - " << x << endl;
#define D2(x) cout << "[" << #x << ": "; for(auto it:x) cout << it << " "; cout << "]" << endl;
#define all(x) (x).begin(), (x).end()
#define D2p(x) cout << #x << " ~ [ "; for(auto n: x) cout << n.first << "-" << n.second << " / "; cout << "]" << endl;
#define ps(x,y) fixed<<setprecision(y)<<x
#define rep(i,a,b) for(ll i=a ; i<b ; ++i)
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
const ll maxn = 1e6 + 4;
void solve(){
ll n;
cin >> n;
vector<ll> v(n);
vi bits(64);
for(int i=0;i<n;i++){
cin >> v[i];
}
for(int i=0;i<n;i++){
ll k = v[i];
int j =0;
while(k>0){
bits[j++] += (k%2);
k/=2;
}
}
ll prod = 1;
ll lst=0;
ll finalans=0;
for(int i=0;i<63;i++){
ll k = bits[i]*(n-bits[i]);
ll st = (lst+k)%2;
lst = (lst+k)/2;
finalans = (finalans + (st*prod))%MOD;
prod = (prod%MOD*2%MOD)%MOD;
}
while(lst>0){
ll st = (lst)%2;
finalans = (finalans+(st)*prod)%MOD;
lst=(lst)/2;
prod = (prod%MOD*2%MOD)%MOD;
}
cout << finalans;
}
int main(){
IOS
solve();
cerr <<endl <<"[ Time : " << (float)clock() / CLOCKS_PER_SEC << " secs ]" << endl;
}
// integer overflow
// remember to clear visited array
// take input as vector<string> while using grid
// don't assign after modifying
| 0 |
#include<bits/stdc++.h>
#define reg register int
#define il inline
#define fi first
#define se second
#define mk(a,b) make_pair(a,b)
#define numb (ch^'0')
#define pb push_back
#define solid const auto &
#define enter cout<<endl
#define pii pair<int,int>
using namespace std;
typedef long long ll;
template<class T>il void rd(T &x){
char ch;x=0;bool fl=false;while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);
for(x=numb;isdigit(ch=getchar());x=x*10+numb);(fl==true)&&(x=-x);}
template<class T>il void output(T x){if(x/10)output(x/10);putchar(x%10+'0');}
template<class T>il void ot(T x){if(x<0) putchar('-'),x=-x;output(x);putchar(' ');}
template<class T>il void prt(T a[],int st,int nd){for(reg i=st;i<=nd;++i) ot(a[i]);putchar('\n');}
namespace Modulo{
const int mod=1e9+7;
int ad(int x,int y){return (x+y)>=mod?x+y-mod:x+y;}
void inc(int &x,int y){x=ad(x,y);}
int mul(int x,int y){return (ll)x*y%mod;}
void inc2(int &x,int y){x=mul(x,y);}
int qm(int x,int y=mod-2){int ret=1;while(y){if(y&1) ret=mul(x,ret);x=mul(x,x);y>>=1;}return ret;}
}
using namespace Modulo;
namespace Miracle{
const int N=2002;
const int M=4000000+5+N+N;
int n,k;
int f[2][N];
int jie[M],inv[M];
int C(int n,int m){
if(n<0||m<0||n<m) return 0;
return mul(jie[n],mul(inv[m],inv[n-m]));
}
int main(){
rd(n);rd(k);
if(k==1){
puts("1");return 0;
}
int lim=n*k+n+n;
jie[0]=1;
for(reg i=1;i<=lim;++i) jie[i]=mul(jie[i-1],i);
inv[lim]=qm(jie[lim]);
for(reg i=lim-1;i>=0;--i) inv[i]=mul(inv[i+1],i+1);
int tmp=0;
f[0][0]=1;
for(reg i=2*n;i>=1;--i){
tmp^=1;
memset(f[tmp],0,sizeof f[tmp]);
int re=2*n-i;
for(reg j=0;j<=min(re,n);++j){
if(!f[tmp^1][j]) continue;
int le=re-j;
if(le+1<=j) f[tmp][j]=ad(f[tmp][j],f[tmp^1][j]);
if(j!=n){
f[tmp][j+1]=ad(f[tmp][j+1],mul(f[tmp^1][j],C(k-2+le+j*(k-1),le+j*(k-1))));
}
}
}
ll ans=mul(f[tmp][n],jie[n]);
ot(ans);
return 0;
}
}
signed main(){
Miracle::main();
return 0;
}
/*
Author: *Miracle*
*/ | #include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
#include<complex>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
typedef pair<int, int>P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-6;
const ld pi = acos(-1.0);
typedef vector<vector<ll>> mat;
typedef vector<ll> vec;
void debug(vec &v) {
int n = v.size();
rep(i, n) {
if (i > 0)cout << " ";
cout << v[i];
}
cout << endl;
}
ll mod_pow(ll x, ll n) {
ll ret = 1;
while (n > 0) {
if (n % 2)ret = ret * x%mod;
x = x * x%mod; n >>= 1;
}
return ret;
}
struct perm {
private:
int sz;
vector<ll> p, invp;
public:
perm(int n) {
sz = n + 1;
p.resize(sz), invp.resize(sz);
p[0] = 1;
rep1(i, sz - 1) {
p[i] = p[i - 1] * i%mod;
}
invp[sz - 1] = 1;
ll cop = mod - 2, x = p[sz - 1];
while (cop) {
if (cop % 2)invp[sz - 1] = invp[sz - 1] * x%mod;
cop >>= 1; x = x * x % mod;
}
per(i, sz - 1) {
invp[i] = invp[i + 1] * (i + 1) % mod;
}
}
ll comb(ll x, ll y) {
if (x < y || y < 0)return 0;
ll ret = p[x];
(ret *= invp[y]) %= mod;
(ret *= invp[x - y]) %= mod;
return ret;
}
ll combP(ll x, ll y) {
if (x < y || y < 0)return 0;
return p[x] * invp[x - y] % mod;
}
};
perm pm(1 << 22);
ll dp[2001];
ll rdp[2002];
ll nex[2001];
void solve() {
int n, k; cin >> n >> k;
if (k == 1) {
cout << 1 << endl; return;
}
dp[1] = 1;
for (int i = 2; i < 2002; i++)rdp[i] = 1;
rep1(i, n - 1) {
for (int j = 1; j <= i + 1; j++) {
int num = i * k - (j - 1);
nex[j] = (rdp[i + 1] - rdp[j - 1])*pm.comb(num + k - 2, num);
nex[j] = (nex[j] % mod + mod) % mod;
}
for (int j = 1; j <= i + 1; j++) {
dp[j] = nex[j];
rdp[j + 1] = (rdp[j] + dp[j]) % mod;
}
}
ll ans = rdp[n + 1];
rep1(i, n)ans = ans * i%mod;
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
//cout << fixed << setprecision(12);
//init();
//int t; cin >> t; rep(i, t)solve();
solve();
//stop
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define PI 3.141592653L
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
const ll INF = (ll)1e18;
const int N = 2e5 + 5;
const ll MOD = 1e9+7;
int parent[N];
int gcd(int a, int b) {
if (a == 0)
return b;
return gcd(b%a, a);
}
int lcm(int a, int b) {
return (a*b)/gcd(a,b);
}
ll pow(ll x, ll y, ll p) {
if(y == 0) return 1;
ll res = 1;
x %= p;
if(x == 0) return 0LL;
while(y > 0) {
if(y & 1) res = (res*x) % p;
y >>= 1;
x = (x*x) % p;
}
return res;
}
int find(int x) {
return x == parent[x] ? x : parent[x] = find(parent[x]);
}
void Union(int x, int y) {
int xPar = find(x), yPar = find(y);
if(xPar != yPar) parent[xPar] = yPar;
}
ll nCr(ll n, ll r) {
ll res = 1;
for(ll i=1;i<=r;i++) {
res = res * (n - r + i) / i;
// is different from
// res *= (n -r + i) / i;
}
return res;
}
int ask(int i, int j) {
cout << "? " << i + 1 << ' ' << j + 1 << endl;
int v;
cin >> v;
return v;
}
void solve() {
int n, x, t;
cin >> n >> x >> t;
cout << (int)(ceil)(n / (double)x) * t << endl;
return;
}
int main()
{
IOS
//int t;
//cin >> t;
//while(t--)
solve();
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int dy[]={1,0,-1,0};
int dx[]={0,1,0,-1};
const ll INF=1e18;
int main() {
double n,x,t;
cin >> n >> x >> t;
x = ceil(n/x);
cout << int(x * t) << endl;
} | 1 |
#include <bits/stdc++.h>
//#include <atcoder/all>
#define ll long long int
#define MOD 1000000007
#define P pair<ll,ll>
#define INF 1000000000000000000
//using namespace atcoder;
using namespace std;
int main(void){
ll n;
cin >> n;
vector<ll> a(5);
for (int i = 0; i < 5; i++){
cin >> a[i];
}
sort(a.begin(), a.end());
cout << (n + a[0] - 1)/a[0] + 4 << endl;
return 0;
}
| #define _USE_MATH_DEFINES
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll LINF = 1e18;
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define MP make_pair
#define F first
#define S second
#define PB push_back
#define dump(x) cout << #x << " = " << (x) << endl; // debug
#define SZ(x) ((ll)(x).size())
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (ll i = (a); i >= (b); i--)
#define ps(s) cout << #s << endl;
#define pv(v) cout << (v) << endl;
#define pvd(v) cout << setprecision(16) << (v) << endl;
#define ALL(a) (a).begin(),(a).end()
#define RANGE(a, left, right) (a).begin()+(left),(a).begin()+(right) // left to (right-1)
int main() {
ll n, a, b, c, d, e;
cin >> n >> a >> b >> c >> d >> e;
ll bn = min({ a, b, c, d, e });
ll res = (n + bn - 1) / bn + 4;
pv(res)
return 0;
} | 1 |
#include <iostream>
#include <iomanip>
#include <string>
#include <stack>
#include <vector>
#include <math.h>
#include <stdio.h>
#include <algorithm>
#include <utility>
#include <functional>
#include <iterator>
#include <map>
#include <set>
#include <queue>
#include <list>
#include <regex>
#include <time.h>
#include <complex>
using namespace std;
using pii = pair<int,int>;
using ll=long long;
using ld=long double;
#define pb push_back
#define mp make_pair
#define sc second
#define fr first
#define stpr setprecision
#define cYES cout<<"YES"<<endl
#define cNO cout<<"NO"<<endl
#define cYes cout<<"Yes"<<endl
#define cNo cout<<"No"<<endl
#define rep(i,n) for(ll i=0;i<(n);++i)
#define Rep(i,a,b) for(ll i=(a);i<(b);++i)
#define rrep(i,n) for(int i=n-1;i>=0;i--)
#define rRep(i,a,b) for(int i=a;i>=b;i--)
#define crep(i) for(char i='a';i<='z';++i)
#define psortsecond(A,N) sort(A,A+N,[](const pii &a, const pii &b){return a.second<b.second;});
#define ALL(x) (x).begin(),(x).end()
#define debug(v) cout<<#v<<":";for(auto x:v){cout<<x<<' ';}cout<<endl;
#define endl '\n'
int ctoi(const char c){
if('0' <= c && c <= '9') return (c-'0');
return -1;
}
ll gcd(ll a,ll b){return (b == 0 ? a : gcd(b, a%b));}
ll lcm(ll a,ll b){return a*b/gcd(a,b);}
constexpr ll MOD=1000000007;
constexpr ll INF=1000000011;
constexpr ll MOD2=998244353;
constexpr ll LINF = 1001002003004005006ll;
constexpr ld EPS=10e-8;
template <class T, class U> inline bool chmax(T& lhs, const U& rhs) { if (lhs < rhs) { lhs = rhs; return 1; } return 0; }
template <class T, class U> inline bool chmin(T& lhs, const U& rhs) { if (lhs > rhs) { lhs = rhs; return 1; } return 0; }
template<typename T> istream& operator>>(istream& is,vector<T>& v){for(auto&& x:v)is >> x;return is;}
template<typename T,typename U> istream& operator>>(istream& is, pair<T,U>& p){ is >> p.first; is >> p.second; return is;}
template<typename T,typename U> ostream& operator>>(ostream& os, const pair<T,U>& p){ os << p.first << ' ' << p.second; return os;}
template<class T> ostream& operator<<(ostream& os, vector<T>& v){
for(auto i=begin(v); i != end(v); ++i){
if(i !=begin(v)) os << ' ';
os << *i;
}
return os;
}
int main(){
ll N,A[200007],B[200007],T=0;
cin >> N ;
rep(i,N){
cin >> A[i];
}
rep(i,N){
cin >> B[i];
}
rep(i,N){
if(clock()>1900000){
return 0;
}
if(T==0){
ll K=A[i]^B[0],L=0,P=0;
if((A[i]^B[0])==(A[(i+1)%N]^B[1])){
P=1;
}
rep(j,N){
if((A[(i+j)%N]^B[j])!=K){
L=1;
break;
}
}
if(L==0){
cout << i << " " << K << endl;
T=1;
}
}
else{
if((A[i]^B[0])==(A[(i+1)%N]^B[1])){
cout << i << " " << (A[i]^B[0]) << endl;
}
}
}
} | #include<iostream>
using namespace std;
struct Node {
int key;
Node* parent;
Node* left;
Node* right;
Node(int key_in){
key = key_in;
parent = NULL;
left = NULL;
right = NULL;
}
};
class Tree {
Node* root;
void inorder(Node* n){
if (n == NULL) return;
inorder(n->left);
cout << " " << n->key;
inorder(n->right);
}
void preorder(Node* n){
if (n == NULL) return;
cout << " " << n->key;
preorder(n->left);
preorder(n->right);
}
public:
Tree(){
root = NULL;
}
void insert(int key){
Node* z = new Node(key);
if (root == NULL) {
root = z;
return;
}
Node* x = root;
while (1) {
Node** child_p;
if (key < x->key) {
child_p = &(x->left);
} else {
child_p = &(x->right);
}
if (*child_p == NULL) {
*child_p = z;
z->parent = x;
return;
}
x = *child_p;
}
}
void print(){
inorder(root);
cout << endl;
preorder(root);
cout << endl;
}
Node* find(int key){
for (Node* x = root; x != NULL;) {
if (key == x->key) return x;
if (key < x->key) {
x = x->left;
} else {
x = x->right;
}
}
return NULL;
}
void delete_1_child(Node* x){
Node* child;
if (x->left == NULL && x->right == NULL) {
child = NULL;
} else if (x->left != NULL) {
child = x->left;
} else {
child = x->right;
}
if (x == root) {
root = child;
delete x;
return;
}
Node* p = x->parent;
if (x == p->left) {
p->left = child;
} else {
p->right = child;
}
if (child != NULL) {
child->parent = x->parent;
}
delete x;
}
Node* next_node(Node* x){
if (x->left == NULL) return x;
return next_node(x->left);
}
void delete_(int key){
Node* x = find(key);
if (x == NULL) return;
if (x->left == NULL || x->right == NULL) {
delete_1_child(x);
return;
}
Node* y = next_node(x->right);
x->key = y->key;
if (y->left == NULL || y->right == NULL) {
delete_1_child(y);
return;
}
}
};
int main(){
int m;
cin >> m;
Tree T;
for (int i = 0; i < m; i++) {
string str;
cin >> str;
if (str == "print") {
T.print();
continue;
}
int num;
cin >> num;
if (str == "insert") {
T.insert(num);
continue;
}
if (str == "find") {
if (T.find(num) == NULL) {
cout << "no" << endl;
} else {
cout << "yes" << endl;
}
continue;
}
if (str == "delete") {
T.delete_(num);
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,x,n) for(int i=x; i<(int)(n); i++)
#define rep_eq(i,x,n) for(int i=x; i<=(int)(n); i++)
using namespace std;
using ll=int64_t;
int main() {
int N; cin >>N;
vector<ll> check;
rep(i,0,N) {
ll A; cin >>A;
check.push_back(A);
}
sort(check.rbegin(),check.rend());
ll temp=0;
rep(i,1,N) {
if (check[i-1]==check[i]) {
if (!temp) {
temp=check[i];
i++;
} else {
cout <<check[i]*temp <<endl;
return 0;
}
}
}
cout <<0 <<endl;
return 0;
}
| #pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#define int long long
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define resort(v) sort((v).rbegin(), (v).rend())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
using ll = long long;
using P = pair<int, int>;
/* ----------------よく使う数字や配列----------------- */
int dx[] = {1,0,-1,0};
int dy[] = {0,1,0,-1};
constexpr ll mod = 1e9+7;
constexpr int inf = INT32_MAX/2;
constexpr ll INF = LLONG_MAX/2;
constexpr long double eps = DBL_EPSILON;
constexpr long double pi = 3.141592653589793238462643383279;
/* ----------------------end----------------------- */
/* --------------------テンプレート------------------ */
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
/* ----------------------end----------------------- */
/* --------------------ライブラリ-------------------- */
ll fact(int i) { //階乗
if (i == 0) return 1;
return (fact(i - 1)) * i % mod;
}
ll gcd(ll a, ll b) { //最大公約数
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { //最小公倍数
return a / gcd(a, b) * b ;
}
int keta(ll n) { //桁数を求める
if(n == 0) return 1;
int count = 0;
while(n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) { //各桁の和
ll sum = 0;
while(n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
/* ----------------------end----------------------- */
signed main() {
int n;cin >> n;
map<int,int> mp;
rep(i,n) {
int a;cin >> a;
mp[a]++;
}
vector<P> v;
for(auto p:mp) v.pb({p.first,p.second});
resort(v);
//for(auto p:v) cout << p.first << " " << p.second << endl;
int k=0,l=0;
rep(i, v.size()) {
//cout << "OK" << endl;
if(k>0&&l>0) break;
if(k==0&&l==0) {
if(v[i].second>=4) k=v[i].first,l=v[i].first;
else if(v[i].second>=2) k=v[i].first;
}
else if(k>0) {
if(v[i].second>=2) l=v[i].first;
}
}
cout << k*l << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
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 ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
typedef long long ll;
bool check(int m, char c, int l, int r){
bool res = true;
if(m == 0){
if(c == 'o'){
if(l != r) res = false;
}else{
if(l == r) res = false;
}
}else{
if(c == 'o'){
if(l == r) res = false;
}else{
if(l != r) res = false;
}
}
return res;
}
int main(){
int n; cin >> n;
string s; cin >> s;
string v[4] = {"00", "01", "10", "11"};
rep(i,4){
vector<int> t(n);
rep(j,2) t[j] = (v[i][j] == '0') ? 0 : 1;
FOR(k, 1, n-1){
if(t[k] == 0){
if(s[k] == 'o'){
t[k+1] = t[k-1];
}else{
t[k+1] = 1-t[k-1];
}
}else{
if(s[k] == 'o'){
t[k+1] = 1-t[k-1];
}else{
t[k+1] = t[k-1];
}
}
}
if(!check(t[n-1], s[n-1], t[n-2], t[0])) continue;
if(!check(t[0], s[0], t[n-1], t[1])) continue;
rep(l, n) printf("%c", t[l] == 0 ? 'S' : 'W');
cout << endl;
return 0;
}
cout << "-1" << endl;
return 0;
} | #include <bits/stdc++.h>
const double PI = 3.14159265358979323846;
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
//#define rep(i, n) for (ll i = 0; i < (n); ++i)
typedef pair<ll, ll> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
std::istream &operator>>(std::istream &in, set<ll> &o) {
ll a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
//ifstream myfile("C:\\Users\\riku\\Downloads\\0_00.txt");
//ofstream outfile("log.txt");
//outfile << setw(6) << setfill('0') << prefecture << setw(6) << setfill('0') << rank << endl;
// std::cout << std::bitset<8>(9);
//const ll mod = 1e10;
//typedef priority_queue<P, vector<P>, greater<P> > PQ_ASK;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> v(n, vector<int>(m));
rep(i, n) rep(j, m) cin >> v[i][j], v[i][j]--;
// rep(i, n) reverse(v[i].begin(), v[i].end());
vector<bool> exclude(m, false);
int ans = INT_MAX;
while (count(exclude.begin(), exclude.end(), false) > 0) {
vector<int> join(m);
rep(i, n) {
rep(j, m) {
int t = v[i][j];
if (!exclude[t]) {
join[t]++;
break;
}
}
}
int now = *max_element(join.begin(), join.end());
// cout << now << endl;
cmin(ans, now);
rep(i, m) {
if (join[i] == now) {
exclude[i] = true;
}
}
}
cout << ans << endl;
} | 0 |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> xs(n + 1), ys(m + 1);
cin >> xs[0] >> ys[0];
for (int i = 1; i <= n; ++i)
cin >> xs[i];
for (int i = 1; i <= m; ++i)
cin >> ys[i];
if (*max_element(xs.begin(), xs.end()) < *min_element(ys.begin(), ys.end()))
cout << "No War" << endl;
else
cout << "War" << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main()
{
int n,m,X,Y;
cin >> n >> m >> X >> Y;
int x[n],y[m];
rep(i,n) cin >> x[i];
rep(i,m) cin >> y[i];
int flag = 0;
for(int z = X+1; z <= Y; z++){
rep(i,n){
if(z <= x[i]){
flag = 1;
break;
}//if
}//rep
rep(i,m){
if(z > y[i]){
flag = 1;
break;
}//if
}//rep
if(flag == 0){
cout << "No War" << endl;
return 0;
}
flag = 0;
}//for
cout << "War" << endl;
} | 1 |
#include <iostream>
using namespace std;
int a,b,sum,dif,tim;
int main(){
cin >> a >> b;
sum = a + b;
dif = a - b;
tim = a * b;
if((sum > dif)&&(sum > tim)){
cout << sum;
}else{
if(dif > tim){
cout << dif;
}else{
cout << tim;
}
}
cout << endl;
} | #include <iostream> // cout, endl, cin
#include <string> // string, to_string, stoi
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <cmath>
#include <iomanip>
using namespace std;
using ll = long long;
#define rep(i,N) for(int i=0;i<(int)N;++i)
ll GCD(ll x, ll y) {
if (y == 0) return x;
else return GCD(y, x % y);
}
#include <iostream>
int main()
{
int A, B;
cin >> A >> B;
int C = A + B;
int D = A - B;
int E = A * B;
cout << max(C,max(D,E)) << endl;
}
| 1 |
#include <bits/stdc++.h>
#define REP(i, n) for (int (i) = 0; (i) < (int)(n); i++)
#define FOR(i, a, b) for(int (i) = a; (i) < (int)b; i++)
#define RREP(i, n) for(int (i)=((int)(n)-1); (i)>=0; i--)
#define RFOR(i, a, b) for(int (i) =((int)(b)-1); (i)>=(int)a; i--)
#define ALL(v) (v).begin(),(v).end()
#define MOD 1000000007
#define FI first
#define SE second
#define MP make_pair
#define PB push_back
#define SZ(x) (int)x.size()
#define SP(x) setprecision((int)x)
using namespace std ;
typedef long long ll;
typedef vector<int> vint;
typedef vector<vint> vvint;
typedef vector<string> vstr;
typedef pair<int, int> pii;
const int INF = 1e9;
const ll LINF = 1e18;
const double EPS = 1e-9;
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;}
int main()
{
int n ;
cin >> n ;
cout <<(n-2)*180 <<endl ;
return 0 ;
}
| #include <bits/stdc++.h>
using namespace std;
#define LL long long int
#define FOR(I,A,B) for( int I = A; I < B; ++I )
#define SFI(X) scanf("%d",&X)
#define SFL(X) scanf("%lld",&X)
int main() {
// SAT, SUN, MON, TUE, WED, THU, FRI
// 1 2 3 4 5 6 7
string S;
cin >> S;
if(S == "MON") {
printf("6\n");
} else if(S == "TUE") {
printf("5\n");
} else if(S == "WED") {
printf("4\n");
} else if(S == "THU") {
printf("3\n");
} else if(S == "FRI") {
printf("2\n");
} else if(S == "SAT") {
printf("1\n");
}else {
printf("7\n");
}
return 0;
}
| 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 each(itr,v) for(auto itr:v)
#define pb push_back
#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_popcount
#define INF INT_MAX/3
#define BV_SIZE 64ULL // 64bit
#define MAX_BV_NUM 100 // m <= 100*64 = 6400
unsigned long long Peq[MAX_BV_NUM][0x100];
int levenshteinDistance(string a,string b) {
int m=a.size(),n=b.size();
int num_of_bv = (m + BV_SIZE -1) / BV_SIZE;
for (int i = 0; i < m; i++) {
Peq[i / BV_SIZE][a[i]] |= 1ULL << ((unsigned long long)i % BV_SIZE);
}
int score = m;
unsigned long long Pv[MAX_BV_NUM], Mv[MAX_BV_NUM], Ph[MAX_BV_NUM], Mh[MAX_BV_NUM], Xv[MAX_BV_NUM], Xh[MAX_BV_NUM], Eq[MAX_BV_NUM], Xt[MAX_BV_NUM], Xa[MAX_BV_NUM];
unsigned long long top = 1ULL << (((unsigned long long)m - 1ULL) % BV_SIZE);
for(int i = 0; i < num_of_bv; i++) {
Pv[i] = ~0ULL; Mv[i] = 0ULL;
}
for (int j = 0; j < n; j++) {
for(int i = 0; i < num_of_bv; i++){
Eq[i] = Peq[i][b[j]];
Xv[i] = Eq[i] | Mv[i];
Xt[i] = Eq[i] & Pv[i];
}
unsigned long long carry = 0ULL;
for(int i = 0; i < num_of_bv; i++){
Xa[i] = Xt[i] + Pv[i] + carry;
if(Xt[i] == ~0ULL && carry == 1ULL){
carry = 1ULL;
}else{
unsigned long long cXt = Xt[i] + carry;
carry = (((cXt & Pv[i]) | ((cXt | Pv[i]) & ( ~ (cXt + Pv[i]) ))) >> 63ULL) & 1ULL;
}
}
for(int i = 0; i < num_of_bv; i++){
Xh[i] = (Xa[i] ^ Pv[i]) | Eq[i];
Ph[i] = Mv[i] | ( ~ (Xh[i] | Pv[i]) );
Mh[i] = Pv[i] & Xh[i];
}
if((Ph[num_of_bv - 1] & top) != 0ULL)score++;
else if((Mh[num_of_bv - 1] & top) != 0ULL)score--;
unsigned long long Ph_carry = 1ULL;
unsigned long long Mh_carry = 0ULL;
for(int i = 0; i < num_of_bv; i++){
unsigned long long nxt_Ph_carry = (Ph[i] >> 63ULL) & 1ULL;
Ph[i] = (Ph[i] << 1ULL) | Ph_carry;
Ph_carry = nxt_Ph_carry;
unsigned long long nxt_Mh_carry = (Mh[i] >> 63ULL) & 1ULL;
Pv[i] = ((Mh[i] << 1ULL) | Mh_carry ) | ( ~ (Xv[i] | Ph[i]) );
Mh_carry = nxt_Mh_carry;
Mv[i] = Ph[i] & Xv[i];
}
}
return score;
}
int main(){
string a,b;
cin>>a>>b;
cout<<levenshteinDistance(a,b)<<endl;
return 0;
} | // C - Grid Repainting 2
#include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define uli unsigned long long int
#define rep(i, m, n) for (lli i = m; i < (n); i++)
#define repe(i, m, n) for (lli i = m; i <= (n); i++)
#define ALL(x) (x).begin(), (x).end()
#define SIZE(x) ((lli)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define _GLIBCXX_DEBUG
const lli INF = 2147483647;
const lli MINF = -2147483648;
const lli LINF = 9223372036854775807;
const lli MOD = 1000000007; //10^9+7
const double PI = acos(-1);
#define SORT(n) sort(n.begin(), n.end())
#define SORTR(n) sort(n.begin(), n.end(), greater<int>())
#define REV(n) reverse(n.begin(), n.end())
#define pb push_back
#define eb emplace_back
#define mp make_pair
#pragma GCC optimize("Ofast")
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vlli = vector<lli>;
using vvli = vector<vlli>;
using vs = vector<string>;
using vvs = vector<vs>;
using vb = vector<bool>;
using vvb = vector<vb>;
using ll = long long;
// vector入力
template <typename T>
istream &operator>>(istream &is, vector<T> &vec)
{
for (T &x : vec)
is >> x;
return is;
}
// vector出力
template <typename T>
ostream &operator<<(ostream &os, vector<T> &vec)
{
// os << '{';
for (int i = 0; i < vec.size(); i++)
{
os << vec[i] << (i + 1 == vec.size() ? "" : "");
}
// os << '}';
return os;
}
// aよりもbが大きいならばaをbで更新する(更新されたならばtrueを返す)
template <typename T>
bool chmax(T &a, const T &b)
{
if (a < b)
{
a = b; // aをbで更新
return true;
}
return false;
}
// aよりもbが小さいならばaをbで更新する(更新されたならばtrueを返す)
template <typename T>
bool chmin(T &a, const T &b)
{
if (a > b)
{
a = b; // aをbで更新
return true;
}
return false;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
lli a, b, c, h, n, w, ans = 0, count = 0;
vector<pair<string, pair<lli, lli>>> pr;
cin >> h >> w;
vs s(h);
rep(i, 0, h)
{
cin >> s[i];
}
vlli dx = {0, 1, 0, -1};
vlli dy = {1, 0, -1, 0};
rep(i, 0, h)
{
rep(j, 0, w)
{
if (s[i][j] == '.')
{
continue;
}
rep(k, 0, 4)
{
a = i + dy[k];
b = j + dx[k];
if (a < 0 || a >= h)
continue;
if (b < 0 || b >= w)
continue;
if (s[a][b] == '#')
count++;
}
if (count == 0)
{
cout << "No" << endl;
return 0;
}
count = 0;
}
}
cout << "Yes" << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
// 型定義
typedef long long ll;
typedef pair<ll, ll> P;
// forループ
#define REP(i,n) for(ll i=0; i<(ll)(n); ++i)
// 定数宣言
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
// グラフ表現
using Graph = vector<vector<int>>;
// グラフの辺表現
using Edge = map<pair<int,int>,int>;
// n次元配列の初期化。第２引数の型のサイズごとに初期化していく。
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
std::fill( (T*)array, (T*)(array+N), val );
}
// 最大公約数
ll gcd(ll a,ll b){
if (a%b == 0) return(b);
else return(gcd(b, a%b));
}
// 最小公倍数
ll lcm(ll a, ll b){
return a/gcd(a, b) * b;
}
int main()
{
cout << fixed << setprecision(15);
string s;
cin >> s;
ll N = s.length();
REP(i, N-1){
if(s[i] == s[i+1]){
cout << i+1 << " " << i+2 << endl;
return 0;
}
}
REP(i, N-2){
if(s[i] == s[i+2]){
cout << i+1 << " " << i+3 << endl;
return 0;
}
}
cout << -1 << " " << -1 << endl;
return 0;
} | #include <stdio.h>
#define _USE_MATH_DEFINES
#include <math.h>
#include <vector>
#include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main(){
string x;
cin >> x;
int n = x.length();
if(n == 2){
if(x[0] == x[1]){
printf("1 2");
}
else {
printf("-1 -1");
}
return 0;
}
for(int i = 0; i < n-2; i++){
if(x[i] == x[i + 1] || x[i + 1] == x[i + 2] || x[i + 2] == x[i]){
printf("%d %d", i+1, i+3);
return 0;
}
}
printf("-1 -1");
return 0;
}
| 1 |
#include<iostream>
#include<map>
#include<set>
#include<string>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<stack>
#include<limits>
#include<sstream>
#include<unordered_map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef int itn;
const int inf = numeric_limits<int>::max() >> 2;
const ll linf = numeric_limits<ll>::max() >> 2;
const ull ulinf = numeric_limits<ull>::max() >> 2;
const double pi = acos(-1);
const int dx[4]={1,0,-1,0};
const int dy[4]={0,1,0,-1};
const int dx8[8]={-1,0,1,-1,1,-1,0,1};
const int dy8[8]={-1,-1,-1,0,0,1,1,1};
#define p_queue(i) priority_queue<i>
#define rp_queue(i) priority_queue<i, vector<i>, greater<i>>
#define umap(i,j) unordered_map<i,j>
#define P(p) cout<<(p)<<endl
#define PS(p) cout<<(p)<< " "
#define PN cout << endl
#define rep(i,m,n) for(int i = (m); i < (int)(n); i++)
#define rrep(i,m,n) for(int i = (n-1); i >= (int)(m); i--)
#define inrep(n,a) for(int i = 0; i < (int)(n); i++)cin >> a[i];
#define mod(i) ((i)%(ll)( 998244353))
#define divm(a,b) (mod(a * modpow((ll)b,(ll)(1e9+5))))
#define rsort(a,b,c) sort(a, b, greater<c>())
#define vsort(v) sort(v.begin(), v.end())
#define rvsort(v,c) sort(v.begin(), v.end(), greater<c>())
#define ft first
#define sd second
#define pb push_back
#define it insert
#define sz(x) ((int)(x).size())
#define lb(a,n,k) (lower_bound(a,a+n,k) - (a))
#define vlb(a,k) (lower_bound(a.begin(),a.end(),k) - a.begin())
#define ub(a,n,k) (upper_bound(a,a+n,k) - (a))
#define vub(a,k) (upper_bound(a.begin(),a.end(),k) - a.begin())
#define YES cout<<"YES"<< endl
#define NO cout<<"NO"<<endl
#define Yes cout<<"Yes"<<endl
#define No cout<<"No"<<endl
#define yes cout<<"yes"<<endl
#define no cout<<"no"<<endl
#define ret return
ll modpow(ll i,ll j){ ll tmp=1; while(j){ if(j%2)tmp=mod(tmp*i);i=mod(i*i);j/=2;}return tmp;}
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; }
/*
vector<string> split(const string &str, char sep){
vector<string> v;
stringstream ss(str);
string buffer;
while( getline(ss, buffer, sep) ) {
v.push_back(buffer);
}
return v;
}
*/
/*
ll ncr[100][100];
ll nCr(int n, int r){if(n==r) ret ncr[n][r] = 1; if(r==0) ret ncr[n][r] = 1; if(r==1) ret ncr[n][r] = n;if(ncr[n][r]) ret ncr[n][r]; ret ncr[n][r] = nCr(n-1,r) + nCr(n-1,r-1);}
ll npr[100][100]={};
ll nPr(int n,int r){if(npr[n][r])ret npr[n][r];if(r==0)ret npr[n][r] = 1;if(r==1)ret npr[n][r] = n;ret npr[n][r] = n * nPr(n-1,r-1);}
ll nHr(int n,int r){ret nCr(n+r-1,r);}
*/
///////////////////////////////////////////////////////////////////////////
int main(){
ll n;
cin >> n;
map<ll,ll> d;
ll max_d= 0;
rep(i,0,n){
ll a;
cin >> a;
d[a]++;
if(i == 0){
if(a != 0){
P(0);
ret 0;
}
}
max_d = max(max_d,a);
}
ll ans = 0;
if(d[0] == 1){
ans = 1;
ll num = 1;
while(num <= max_d){
ans *= modpow( d[num-1] , d[num]);
ans = mod(ans);
num++;
}
}
P(ans);
return 0;
}
| #include<bits/stdc++.h>
//#include<pair>
using namespace std;
typedef long long ll;
typedef int ii;
//typedef vector<ll> vi;
#define INF 1000000007
#define pi 3.141592654
#define T while(t--)
#define for2(i,a,b) for(i=a;i>=b;i--)
#define for3(i,a,b) for(i=a;i<=b;i=i+2)
#define for1(i,a,b) for(i=a;i<=b;i++)
#define pb push_back
#define mp make_pair
#include<sstream>
#define si set<ll>
#define se multiset<ll>
typedef long double ld;
typedef vector<int64_t> vi;
#define bb(arr,nn,xx) upper_bound(arr,arr+nn,xx)-arr
#define aa(arra,nna,xxa) lower_bound(arra,arra+nna,xxa)-arra
#define all(v) sort(v.begin(),v.end())
#define all1(v) sort(v.rbegin(),v.rend())
ii main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int64_t n,i; cin>>n; vi v; ll x;
for1(i,1,n)
{
cin>>x;
v.pb(x);
}
ll sum1=0; ll sum=0;
for2(i,n-1,1)
{
sum1+=v[i];
sum+=(((v[i-1]%INF)*(sum1%INF))%INF)%INF;
}
cout<<sum%(INF)<<"\n";
}
| 0 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
#define rep(i,n) for(int i=0, i##_len=(int)(n); i<i##_len; i++)
#define reps(i,n) for(int i=1 , i##_len=(int)(n);i<=i##_len;i++)
#define rrep(i,n) for(int i=((int)(n)-1);i>=0;i--)
#define rreps(i,n) for(int i=((int)(n));i>0;i--)
#define all(x) (x).begin(), (x).end()
#define F first
#define S second
#define mp make_pair
#define pb push_back
#define solve(a) ((a)?"Yes":"No")
typedef vector<long long> V;
typedef vector<V> VV;
typedef pair<long long , long long> P;
typedef vector<P> VP;
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 long long INFLL = 1LL<<62;
const int INF = 1<<30;
const double PI=acos(-1);
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {// テーブルを作る前処理
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k){ // 二項係数:nCk計算
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main(){
COMinit();
int n,m;
ll ans=1LL;
cin >>n>>m;
int bef=m;
map<int,int>co;
int c=0;
for(int i=2;i<=sqrt(bef);i++){
c=0;
while(bef%i==0){
bef/=i;
c++;
}
if(c){
co[i]+=0;
co[i]+=c;
}
}
if(bef!=1){
co[bef]+=0;
co[bef]++;
}
for(auto itr=co.begin();itr!=co.end();itr++){
ans*=COM(itr->S + n-1 , n-1);
ans%=MOD;
}
cout<<ans<<endl;
} | #include <bits/stdc++.h>
using namespace std;
string s;
int n, dp[305][305][305];
int go(int l, int r, int k) {
if (dp[l][r][k] != -1) return dp[l][r][k];
if (l == r) {
return dp[l][r][k] = 1;
}
if (l + 1 == r) {
if (s[l] == s[r] || k) {
return dp[l][r][k] = 2;
} else {
return dp[l][r][k] = 1;
}
}
dp[l][r][k] = max(go(l + 1, r, k), go(l, r - 1, k));
if (s[l] == s[r]) {
dp[l][r][k] = max(dp[l][r][k], go(l + 1, r - 1, k) + 2);
} else if (k) {
dp[l][r][k] = max(dp[l][r][k], go(l + 1, r - 1, k - 1) + 2);
}
return dp[l][r][k];
}
int main() {
int k;
cin >> s >> k;
n = s.size();
memset(dp, -1, sizeof(dp));
cout << go(0, n - 1, k) << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
using ll = long long;
using ull = unsigned long long;
using P = pair<int,int>;
const int INF = 1001001001;
int main(){
int n;
cin >> n;
vector<ll> A(n);
rep(i,n) cin >> A[i];
sort(A.begin(),A.end());
rep(i,n-1){
if(A[i]!=A[i+1])continue;
cout << "NO" <<endl;
return 0;
}
cout << "YES" << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
int main()
{
int n,m,x,y,z;
string ans="War";
cin>>n>>m>>x>>y;
vector<int> a(n);
vector<int> b(m);
for(int i=0;i<n;i++)
{
cin>>a.at(i);
}
for(int i=0;i<m;i++)
{
cin>>b.at(i);
}
sort(a.begin(),a.end());
reverse(a.begin(),a.end());
sort(b.begin(),b.end());
for(int i=x+1;i<=y;i++)
{
if((a.at(0)<i)&&(b.at(0)>=i))
{
ans="No War";
break;
}
}
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define REP(i,m,n) for(int i=(int)(m); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define RREP(i,m,n) for(int i=(int)(m); i>=(int)(n); i--)
#define rrep(i,n) RREP(i,(n)-1,0)
#define all(v) v.begin(), v.end()
#define endk '\n'
const int inf = 1e9+7;
const ll longinf = 1LL<<60;
const ll mod = 1e9+7;
const ll mod2 = 998244353;
const ld eps = 1e-10;
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;}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin >> n;
vector<ll> A(n); rep(i, n) cin >> A[i];
vector<vector<int>> B(n+1, vector<int>(60));
ll ans = 0;
rep(i, n) {
rep(j, 60) {
(ans += ((A[i]>>j)&1 ? i-B[i][j] : B[i][j]) * ((1LL<<j) % mod)) %= mod;
B[i+1][j] = B[i][j] + ((A[i]>>j)&1);
}
}
cout << ans << endk;
return 0;
}
| #if __has_include("debug.h")
#include "debug.h"
#else
#include <bits/stdc++.h>
using namespace std;
#define d(...) 2;
#endif
#define int long long int
#define ld long double
#define fast ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define endl "\n"
#define all(c) (c).begin(),(c).end()
#define rall(c) (c).rbegin(),(c).rend()
#define ff first
#define ss second
#define eps 1e-10
#define PI acos(-1LL)
int MOD = 1e9 + 7;
inline int mul(int a,int b,int mod=MOD){return ((a%mod)*(b%mod))%mod;}
inline int sum(int a,int b,int mod=MOD){return ((a%mod)+(b%mod))%mod;}
int power(int a,int n,int mod=MOD){int ans=1;while(n){if(n&1)ans=mul(ans,a,mod);a=mul(a,a,mod);n>>=1;}return ans;}
inline int sub(int a,int b,int mod=MOD){ return (((a) % mod)-((b) % mod) + mod) % mod; }
int inv[1000006];
void find_inverse(int m) //m should be prime..
{
inv[1] = 1;
for(int i = 2; i < m; ++i)
inv[i] = (m - (m/i) * inv[m%i] % m) % m;
}
#define gcd(a,b) __gcd((a),(b))
#define lcm(a,b) ((a*b)/gcd(a,b))
void solve();
int32_t main()
{
#ifdef DEBUG
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
fast
int t = 1;
// cin>>t;
while(t--)
solve();
return 0;
}
void solve()
{
int i,j;
int n;
cin>>n;
vector<int>a(n);
for(i=0;i<n;i++)
{
cin>>a[i];
}
int ans=0;
for(i=0;i<60;i++)
{
int cnt=0;
for(j=0;j<n;j++)
{
if(a[j]&(1LL<<i))
{
cnt++;
}
}
int one=cnt;
int zero=n-cnt;
ans=sum(ans,mul(power(2,i),mul(one,zero)));
}
cout<<ans<<endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
vector<pair<int, int>> v1(1e5+1);
vector<pair<int, int>> v2(1e5+1);
for(int i=0; i<n; i++){
int in;
cin>> in;
if(i % 2 == 0){
v1[in].first++;
v1[in].second = in;
}else{
v2[in].first++;
v2[in].second = in;
}
}
sort(v1.begin(), v1.end(), greater<pair<int, int>>());
sort(v2.begin(), v2.end(), greater<pair<int, int>>());
int cnt;
if(v1[0].second != v2[0].second){
cnt = v1[0].first + v2[0].first;
}else{
cnt = max(v1[0].first + v2[1].first, v1[1].first + v2[0].first);
}
cout<< n - cnt <<endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end());
int ans = 0;
int last = 0;
int exist = 0;
rep(i, n) {
if (a[i] == last) exist = 1 - exist;
else {
ans += exist;
last = a[i];
exist = 1;
}
}
ans += exist;
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#include <string>
using namespace std;
typedef long long ll;
int main(){
std::vector<string> d(3);
for(ll i=0;i<3;++i){
cin>>d[i];
}
ll a=0,b=0,c=0;
char now='a';
while(1){
switch(now){
case 'a':
if(a>=d[0].length()){
cout<<char(now+'A'-'a');
return 0;
}
now=d[0][a];
a++;
break;
case 'b':
if(b>=d[1].length()){
cout<<char(now+'A'-'a');
return 0;
}
now=d[1][b];
b++;
break;
case 'c':
if(c>=d[2].length()){
cout<<char(now+'A'-'a');
return 0;
}
now=d[2][c];
c++;
break;
}
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long int ll ;
#define fast ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
const ll inf=1e9+7;
string a,b,c;
queue<char>q[3];
void scan(int n)
{
char c;
while((c=getchar() )!='\n')
{
q[n].push(c);
}
}
int main()
{
fast;
scan(0);
scan(1);
scan(2);
ll k=0;
while(!q[k].empty())
{
char c=q[k].front();
q[k].pop();
k=c-'a';
}
cout<<char(k +'A');
}
| 1 |
#include <bits/stdc++.h>
#define LL long long
using namespace std;
int main(){
LL N;
cin >> N;
int f = 10;
for(LL A=1; A*A<=N; A++){
if(N%A != 0) continue;
LL a = A;
LL b = N/A;
int B_d = 0;
int A_d = 0;
while(a>0){
a /= 10;
A_d++;
}
while(b>0){
b /= 10;
B_d++;
}
f = min(f,max(A_d,B_d));
}
cout << f << endl;
} | #include<vector>
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include <iostream>
#include <algorithm>
#include <map>
#include <cmath>
#define INF 100000000000000
using namespace std;
typedef long long llong;
//int isalpha(char ch): ch がアルファベットなら true を返す
//int isdigit(char ch): ch が数字なら true を返す
//int islower(char ch): ch が小文字なら true を返す
//int isupper(char ch): ch が大文字なら true を返す
//int tolower(char ch): ch の小文字を返す
//int toupper(char ch): ch の大文字を返す
//string型
//size() 文字数を返す
//insert() （指定した場所に）文字・文字列を挿入する
//erase() （指定した場所の）文字・文字列を削除する
//clear() すべての文字を削除する
//substr() 文字列の（指定した）部分文字列を返す
//replace() （指定した）部分文字列を新しい文字列に置換する
//文字列の比較は、<=や==などを使え
//replace関数を使い、簡単に文字列を置換
//リバース関数：reverse(str.begin(), str.end());
//map<type, type> dict;で宣言
//グラフ理論用変数
//vector<vector<llong> > graph(N);
//ソート
//降順sort(v.begin(), v.end(), std::greater<Type>());
//大文字から小文字へんかん
//w[i] = w[i]-'A'+'a';
bool isprime(llong num){
if(num==1){
return false;
}
if(num==2){
return true;
}
for(int i=2; i<=sqrt(num); i++){
if(num%i==0){
return false;
}
}
return true;
}
//約数列挙
void EnumerateFactor(vector<vector<llong> > &factor_list, llong num){
llong cnt=0;
for(int i=1; i<=sqrt(num); i++){
if(num%i==0){
factor_list[cnt].push_back(i);
factor_list[cnt].push_back(num/i);
cnt++;
}
}
}
int main(){
llong n;
llong ans=INF;
llong temp=-1*INF;
vector<vector<llong> > factor_list(100000);
string A, B;
scanf("%lld", &n);
EnumerateFactor(factor_list, n);
for(int i=0; i<factor_list.size(); i++){
if(factor_list[i].size()==0){
break;
}
A = to_string(factor_list[i][0]);
B = to_string(factor_list[i][1]);
temp = max(A.size(), B.size());
ans = min(temp, ans);
}
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(int)(n); i++)
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n, m; cin >> n >> m;
vector<int> p(n+1,0);
vector<bool> ac(n+1);
int ac_cnt = 0, pe_cnt = 0;
rep(i,m) {
int pi; string si; cin >> pi >> si;
if (!ac[pi]) {
if (si == "WA") {
p[pi]++;
} else {
ac_cnt++;
pe_cnt += p[pi];
ac[pi] = true;
}
}
}
cout << ac_cnt << " " << pe_cnt << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main () {
int d, g;
cin >> d >> g;
vector<pair<int,int>> p(d);
for (int i = 0; i < d; i++)
cin >> p[i].first >> p[i].second;
vector<int> v(d);
iota (v.begin(), v.end(), 0);
int ans = 1000;
do {
int sum = 0, c = 0;
for (int i = 0; i < d; i++) {
int x = v[i];
int i100 = 100 * (x+1);
int pi100 = p[x].first * i100;
if (g > sum + pi100 + p[x].second) {
sum += pi100 + p[x].second;
c += p[x].first;
}
else if (sum + pi100 <= g &&
g <= sum + pi100 + p[x].second) {
c += p[x].first;
break;
}
else {
c += (g - sum + i100-1) / i100;
break;
}
}
ans = min(ans, c);
}
while (next_permutation(v.begin(), v.end()));
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
string S;
vector<vector<int>> color;
void hantei(int i){
if(S[i]=='R'){
color[0][i]++;
}
else if(S[i]=='G'){
color[1][i]++;
}
else if(S[i]=='B'){
color[2][i]++;
}
}
int main(){
int N;
cin >> N >> S;
vector<vector<int>> c(3,vector<int>(N,0));
color=c;
ll ans=0;
hantei(0);
for(int i=0;i<N;i++){
color[0][i]=color[0][i-1];
color[1][i]=color[1][i-1];
color[2][i]=color[2][i-1];
hantei(i);
}
for(int i=0;i<N;i++){
for(int j=i+1;j<N;j++){
if(S[i]==S[j]){
continue;
}
if((S[i]=='R' && S[j]=='G') || (S[i]=='G' && S[j]=='R')){
ans+=color[2][N-1]-color[2][j];
if(i+2*(j-i)<N && S[i+2*(j-i)]=='B'){
ans--;
}
}
else if((S[i]=='G' && S[j]=='B') || (S[i]=='B' && S[j]=='G')){
ans+=color[0][N-1]-color[0][j];
if(i+2*(j-i)<N && S[i+2*(j-i)]=='R'){
ans--;
}
}
else if((S[i]=='B' && S[j]=='R') || (S[i]=='R' && S[j]=='B')){
ans+=color[1][N-1]-color[1][j];
if(i+2*(j-i)<N && S[i+2*(j-i)]=='G'){
ans--;
}
}
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<ll> vl;
typedef pair<ll, ll> PP;
#define rep(i, n) for(ll i = 0; i < ll(n); i++)
#define all(v) v.begin(), v.end()
#define inputv(v, n) \
vl v; \
rep(i, n) { \
ll x; \
cin >> x; \
v.push_back(x); \
}
bool chmin(ll& a, ll b) { if (b < a) { a = b; return 1; } return 0; }
bool chmax(ll& a, ll b) { if (b > a) { a = b; return 1; } return 0; }
const ll INF = 999999999999999;
const ll MOD = 1000000007;
const ll MAX_N = 500010;
ll a, b, c, d, e, f, p, t, x, y, z, q, m, n, r, h, k, w, l, ans;
struct Gragh {
ll N;
vector<vl> G;
vl visited;
Gragh(ll n) {
N = n;
G.resize(N);
resetv();
}
void add(ll a, ll b) { G[a].push_back(b); }
void resetv(void) { visited = vl(N, 0); }
//重さ無し
void dfs(ll x) {
visited[x] = 1;
for (ll i : G[x]) {
if (visited[i] == 0) {
dfs(i);
}
}
}
};
int main() {
cin >> n >> m;
Gragh G(2 * n);
rep(i, m) {
cin >> a >> b;
a--;
b--;
G.add(a * 2, b * 2 + 1);
G.add(b * 2, a * 2 + 1);
G.add(a * 2+1, b * 2);
G.add(b * 2+1, a * 2);
}
G.dfs(0);
vl dp(2, 0);
rep(i, n * 2) {
if (G.visited[i] == 1)dp[i % 2]++;
}
x=dp[0];
y=dp[1];
k=x+y-n;
ans=k*(n-k)+k*(k-1)/2+(x-k)*(y-k)-m;
cout << ans << endl;
} | 0 |
#include<cstdio>
#include<iostream>
#include<string>
#include<algorithm>
#include<stdio.h>
#include<locale.h>
#include<set>
#include<stack>
#include<queue>
using namespace std;
int main()
{
int d,g,p[11],c[11],scr[11][1001]={};
scanf("%d %d",&d,&g);
int sm=0;
for(int i=1;i<=d;i++)
{
scanf("%d %d",&p[i],&c[i]);
sm+=p[i];
}
for(int i=1;i<=d;i++)
{
for(int j=0;j<=sm;j++)
{
//scr[i][j]の最大値はscr[i-1][j]かscr[i-1][j-N]+N*i*100かコンプリートが入るやつか
for(int k=0;k<=min(j,p[i]);k++)
{
if(k==p[i]){scr[i][j]=max(scr[i-1][j],(scr[i-1][j-k]+i*100*k+c[i]));}
else{scr[i][j]=max(scr[i-1][j],(scr[i-1][j-k]+i*100*k));}
}
}
}
for(int i=0;i<=1000;i++)
{
if(scr[d][i]>=g){printf("%d",i);break;}
}
}
| #include<bits/stdc++.h>
using namespace std;
int main(){
int d,g,i,j,y,z,ans=1000;
cin>>d>>g;
vector<int> p(d),c(d);
for(i=0;i<d;i++) cin>>p.at(i)>>c.at(i);
for(i=0;i<(1<<d);i++){
bitset<10> b(i);
y=0;z=0;
for(j=0;j<d;j++){
if(b.test(j)){
y+=p.at(j);
z+=100*(j+1)*p.at(j)+c.at(j);
}
}
for(j=d-1;j>=0;j--){
if(g<=z) break;
else if(!b.test(j)){
if(g-z>100*(j+1)*(p.at(j)-1)){
y+=p.at(j)-1;
z+=100*(j+1)*(p.at(j)-1);
}
else{
y+=(g-z)/(100*(j+1));
if((g-z)%(100*(j+1))>0) y++;
z=g;
}
}
}
if(g<=z&&y<ans) ans=y;
}
cout<<ans<<endl;
} | 1 |
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const ll mod = 1000000007;
const ll INF = 1001001001;
const ll LINF = 1001001001001001001;
void prvec(vector<ll> vec){
ll n = vec.size();
rep(i,n) cout << "i" << " " << vec.at(i) << "\n";
}
void pr2d(vector<vector<ll>> vvec){
ll h = vvec.size();
ll w = vvec.at(0).size();
rep(i,h){
rep(j,w){
cout << vvec.at(i).at(j) << " ";
}
cout << "\n";
}
}
int main(){
ll n ; cin >> n;
ll prev ; cin >> prev;
bool NG = false;
if(prev!=0) NG = true;
ll ans = 0;
rep(i,n-1){
ll x ; cin >> x;
if(x == prev + 1){
ans++;
}else if(x>prev+1){
NG = true;
}else{
ans+=x;
}
prev = x;
}
if(NG){
cout << -1 << endl;
}else{
cout << ans << endl;
}
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<vector>
#include<functional>
#include<algorithm>
#include<stdlib.h>
#include<string>
#include<string.h>
#define _USE_MATH_DEFINES
#include<math.h>
#include<deque>
#include<set>
#include<map>
#include<queue>
#include<list>
#include<iostream>
#include <bitset>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(auto i=a;i<b;i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x, std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x *= x; p /= 2; } else { a *= x; p--; } }return a; }
ll mpower(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x = x * x % mod; p /= 2; } else { a = a * x % mod; p--; } }return a; }
ll ac(ll n, ll k) { ll a = 1; rep(i, 1, k) { a *= n - i + 1; a /= i; }return a; }
ll mc(ll n, ll m) { ll k = 1, l = 1; rep(i, n - m + 1, n + 1) k = k * i % mod; rep(i, 1, m + 1) l = l * i % mod; l = mpower(l, mod - 2); return k * l % mod; }
typedef struct { ll n, m; } p2;
int main()
{
int N;
cin >> N;
vector<int> A(N);
ll ans = 0;
rep(i, 0, N) {
cin >> A[i];
if (A[i] > i || i && A[i] - A[i - 1] > 1) {
puts("-1");
return 0;
}
if (i && A[i] != A[i - 1] + 1) {
ans += (ll)A[i - 1];
}
}
ans += (ll)A[N-1];
printf("%lld\n", ans);
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(a) (a).begin(), (a).end()
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define rc(s) return cout<<s,0
#define pi pair <int, int>
#define sz(x) (int)((x).size())
#define int long long
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const ll inf = 0x3f3f3f3f3f3f3f;
const ll mod = 1e9 + 7;
const int N = 20;
const int NMAX = 1e4 + 11;
const ll INF64 = 3e18 + 1;
const double lil = 0.0000000000001;
//ifstream cin ("test.in");
//ofstream cout ("test.out");
int n, a[N][N], dp[(1 << N)];
int32_t main(){
ios_base :: sync_with_stdio(0); cin.tie(); cout.tie();
cin >> n;
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
cin >> a[i][j];
}
}
//create groups
for(int mask = 0; mask < (1 << n); mask++){
int ans = 0;
for(int i = 0; i < n; i++){
if(!(mask & (1 << i)))continue;
for(int j = 0; j < i; j++){
if(!(mask & (1 << j)))continue;
ans += a[i][j];
}
}
dp[mask] = ans;
}
for(int mask = 1; mask < (1 << n); mask++){
for(int i = mask; i; i = (mask & (i - 1))){
if(dp[mask] < dp[mask - i] + dp[i])dp[mask] = dp[mask - i] + dp[i];
}
}
rc(dp[(1 << n) - 1]);
}
| //Author:xht37
#include <bits/stdc++.h>
#define ui unsigned int
#define ll long long
#define ul unsigned ll
#define ld long double
#define pi pair <int, int>
#define fi first
#define se second
#define mp make_pair
#define ls (p << 1)
#define rs (ls | 1)
#define md ((t[p].l + t[p].r) >> 1)
#define vi vector <int>
#define pb push_back
#define pq priority_queue
#define dbg(x) cerr << #x" = " << x << endl
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define fl(x) freopen(x".in", "r", stdin), freopen(x".out", "w", stdout)
using namespace std;
namespace io {
const int SI = 1 << 21 | 1;
char IB[SI], *IS, *IT, OB[SI], *OS = OB, *OT = OS + SI - 1, c, ch[100];
int f, t;
#define gc() (IS == IT ? (IT = (IS = IB) + fread(IB, 1, SI, stdin), IS == IT ? EOF : *IS++) : *IS++)
inline void flush() {
fwrite(OB, 1, OS - OB, stdout), OS = OB;
}
inline void pc(char x) {
*OS++ = x;
if (OS == OT) flush();
}
template <class I>
inline void rd(I &x) {
for (f = 1, c = gc(); c < '0' || c > '9'; c = gc()) if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + (c & 15), c = gc());
x *= f;
}
template <class I>
inline void rd(I &x, I &y) {
rd(x), rd(y);
}
template <class I>
inline void rd(I &x, I &y, I &z) {
rd(x), rd(y), rd(z);
}
template <class I>
inline void rda(I *a, int n) {
for (int i = 1; i <= n; i++) rd(a[i]);
}
inline void rdc(char &c) {
for (c = gc(); c < 33 || c > 126; c = gc());
}
inline void rds(char *s, int &n) {
for (c = gc(); c < 33 || c > 126; c = gc());
for (n = 0; c >= 33 && c <= 126; s[++n] = c, c = gc());
s[n+1] = '\0';
}
inline void rds(string &s) {
for (c = gc(); c < 33 || c > 126; c = gc());
for (s.clear(); c >= 33 && c <= 126; s.pb(c), c = gc());
}
template <class I>
inline void print(I x, char k = '\n') {
if (!x) pc('0');
if (x < 0) pc('-'), x = -x;
while (x) ch[++t] = x % 10 + '0', x /= 10;
while (t) pc(ch[t--]);
pc(k);
}
template <class I>
inline void print(I x, I y) {
print(x, ' '), print(y);
}
template <class I>
inline void print(I x, I y, I z) {
print(x, ' '), print(y, ' '), print(z);
}
template <class I>
inline void printa(I *a, int n) {
for (int i = 1; i <= n; i++) print(a[i], " \n"[i==n]);
}
inline void printc(char c) {
pc(c);
}
inline void prints(char *s, int n) {
for (int i = 1; i <= n; i++) pc(s[i]);
pc('\n');
}
inline void prints(string s) {
int n = s.length();
while (t < n) pc(s[t++]);
pc('\n'), t = 0;
}
struct Flush {
~Flush() {
flush();
}
} flusher;
}
using io::rd;
using io::rda;
using io::rdc;
using io::rds;
using io::print;
using io::printa;
using io::printc;
using io::prints;
const int N = 1e5 + 7;
int n, m, v, p, a[N];
ll s[N];
int main() {
rd(n, m), rd(v, p), rda(a, n);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) s[i] = a[i] + s[i-1];
// for (int i = 1; i <= n; i++) debug("%d%c", a[i], " \n"[i==n]);
for (int i = 1; i <= n; i++) {
int c = n + 1 - (upper_bound(a + 1, a + n + 1, a[i] + m) - a);
if (c + 1 > p) continue;
int d = (upper_bound(a + 1, a + n + 1, a[i]) - a) - 2;
// debug("%d %d %d\n", i, c, d);
ll o = 1ll * m * (v - 1 - c - d) - (1ll * (a[i] + m) * (n - 1 - c - d) - (s[n-c] - s[d+1]));
// dbg(o);
if (o <= (s[n-c] - s[n-p+1]) - 1ll * (p - 1 - c) * a[i]) {
print(n - i + 1);
break;
}
}
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <cmath>
template<typename T>
auto print(std::vector<T> array,bool reverse = false)
-> void{
if(reverse){
auto iterator = array.rbegin();
std::cout<<*iterator;
iterator++;
for(;iterator != array.rend();++iterator){
std::cout<<" "<< *iterator;
}
}else{
auto iterator = array.begin();
std::cout<<*iterator;
iterator++;
for(;iterator != array.end();++iterator){
std::cout<<" "<< *iterator;
}
}
std::cout<<"\n";
}
template<typename T>
auto println(std::vector<T> array)
-> void{
for(auto v : array){
std::cout<< v <<"\n";
}
}
int cnt = 0;
template<typename T>
auto insertionSort(std::vector<T> *A,int n,int g)
-> void{
for(int i = g;i < n;i++){
auto v = (*A)[i];
auto j = i - g;
while(j >= 0 && (*A)[j] > v){
(*A)[j+g] = (*A)[j];
j = j - g;
cnt++;
}
(*A)[j+g] = v;
}
}
template<typename T>
auto shellSort(std::vector<T> *A,int n)
-> void{
cnt = 0;
int h = 0;
std::vector<int> G;
for(int k = 1;;k++){
h = static_cast<int>((pow(3,k)-1)/2);
if(h > n)
break;
G.push_back(h);
}
std::cout<< G.size() <<std::endl;
print(G, true);
for(auto it = G.rbegin();it != G.rend();++it){
insertionSort<T>( A, n, (*it));
}
}
auto main()
-> int{
std::cin.tie(0);
std::ios_base::sync_with_stdio(false);
int n;
std::cin>>n;
std::vector<int> array(n);
for(int i=0;i < n;i++)
std::cin>>array[i];
shellSort( &array, n);
std::cout<< cnt <<"\n";
println(array);
return 0;
} | #include<stdio.h>
int main(){
int n;
scanf("%d",&n);
int array[n];
for(int i = 0;i < n;i++) scanf("%d",&array[i]);
for(int i = n;i > 0;i--){
if(i != 1){
printf("%d ",array[i-1]);
} else{
printf("%d\n",array[i-1]);
}
}
}
| 0 |
#include<stdio.h>
#define N 101
int main(){
int n;
int p[N];
int m[N][N];
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%d%d",&p[i-1],&p[i]);}
for(int i=1;i<=n;i++)
m[i][i]=0;
for(int l=2;l<=n;l++){
for(int i=1;i<=n-l+1;i++){
int j=i+l-1;
/*2<<21*/
m[i][j]=2097152;
for(int k=i;k<=j-1;k++){
/*さいしょう比較*/
if(m[i][j]<m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j])
m[i][j]=m[i][j];
else
m[i][j]=m[i][k]+m[k+1][j]+p[i-1]*p[k]*p[j];
}
}
}
printf("%d\n",m[1][n]);
return 0;
}
| #include <stdio.h>
const int N=110;
const int INF=1<<30;
int min(int a,int b){
return a>b?b:a;
}
int main(){
int n,dp[N][N],a[N];
scanf("%d%d%d",&n,&a[0],&a[1]);
for(int i=1;i<n;i++)scanf("%d%d",&a[i],&a[i+1]);
for(int k=1;k<n;k++){
for(int i=0;i<n-k;i++){
dp[i][i+k]=INF;
for(int j=i;j<i+k;j++)dp[i][i+k]=min(dp[i][i+k],dp[i][j]+dp[j+1][i+k]+a[i]*a[j+1]*a[i+k+1]);
}
}
printf("%d\n",dp[0][n-1]);
}
| 1 |
#include <bits/stdc++.h>
#include <iomanip>
#include <math.h>
#include <unistd.h>
#include <stdio.h>
#define rep(i,x) for(ll i = 0;i<x;i++)
#define all(a) (a).begin(),(a).end()
#define vecin(a) rep(i,a.size())cin >> a[i]
#define vecout(a) rep(i,a.size())cout << a[i] << " ";cout << "\n"
#define vecvec(a) vector<vector<(a)>>
using ll = long long;
using ld = long double;
using namespace std;
using dou = double;
const ll inf = 2147483647;
const ll INF = 1LL << 60;
const ld pi = 3.14159265358;
const ll mod = 1000000007;
typedef pair<ll,ll> P;
using graph = vector<vector<ll>>;
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;}
template<class T> inline bool change(T a,T b){if(a > b){swap(a,b);return true;}return false;}
ll gcd(ll a,ll b){
if(a < b)swap(a,b);
if(a % b == 0)return b;
else return gcd(b,a%b);
}
//素数判定O(sqrt(N))
bool isp(ll n){
bool res = true;
if(n == 1)return false;
else{
for(ll i = 2;i * i <= n;i++){
if(n % i == 0){
res = false;
break;
}
}
return res;
}
}
const ll cmax = 1000000;
ll fac[cmax], finv[cmax], inv[cmax];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < cmax; 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 nCk(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;
}
//nのm乗をMODで割ったあまりO(logN)
ll modpow(ll n,ll m,ll MOD){
ll res = 1;
while(m){
if(m & 1)res = (res * n) % MOD;
m >>= 1;
n *= n;
n %= MOD;
}
return res;
}
//printf("%.10f\n", N);
/* vector<ll> vec = {1,2,5,6,8,9,10};
cout << binary_search(all(vec),5) << endl; -> true*/
/*
vector<ll> vec = {1,2,5,6,8,9,10};
auto n = upper_bound(all(vec),4);
cout << *n << endl; -> 5*/
// cout << fixed << setprecision(15);
struct edge{ll to,cost;};
ll N;const ll NMAX = 100005LL;
vector<edge> G[NMAX];
vector<ll> dist(NMAX,INF);
void dfs(ll from,ll par,ll d){
dist[from] = d;
for(auto x : G[from]){
if(x.to != par){
dfs(x.to,from,d + x.cost);
}
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
ll a,b,c;
cin >> N;
rep(i,N - 1){
cin >> a >> b >> c;
a--;b--;
G[a].push_back({b,c});
G[b].push_back({a,c});
}
ll Q,K;
cin >> Q >> K;
dist[K - 1] = 0;
dfs(K - 1,-1,0);
ll A,B;
rep(i,Q){
cin >> A >> B;
cout << dist[A - 1] + dist[B - 1] << "\n";
}
} | #include <bits/stdc++.h>
#define ll long long
#define ld long double
#define mp make_pair
#define pb push_back
#define vll vector<ll>
#define endl "\n"
#define pll pair<ll,ll>
#define all(x) (x).begin() , (x).end()
#define f first
#define s second
#define pr(x) cout<<x<<endl;
#define pr2(x,y) cout<<x<<" "<<y<<endl;
#define pr3(x,y,z) cout<<x<<" "<<y<<endl;
#define prv(v) for(auto x:v) cout<<x<<" ";
using namespace std;
const ll N =(2e5+5);
const ll MOD = 1e9+7;
const ll INF = 1e16;
const ll LOG = 29;
long long binpow(long long a, long long b) {
a %= MOD;
long long res = 1;
while (b > 0) {
if (b & 1)
res = (res * a)%MOD ;
a = (a * a)%MOD ;
b >>= 1;
}
res%=MOD;
return res;
}
vll adj[N];
vll adj2[N];
ll col[N];
ll col2[N];
bool vis[N];
bool vis2[N];
map<pll,ll> gg;
void dfs(ll x,ll c)
{
vis[x]=true;
col[x]=c;
for(auto i : adj[x])
{
if(vis[i]==false)
{
dfs(i,c);
}
}
}
void dfs2(ll x,ll c)
{
vis2[x]=true;
col2[x]=c;
for(auto i : adj2[x])
{
if(vis2[i]==false)
{
dfs2(i,c);
}
}
}
void solve(){
ll n,k,l;
cin>>n>>k>>l;
for(int i =1;i<=k;i++){
ll u,v;
cin>>u>>v;
adj[u].pb(v);
adj[v].pb(u);
}
for(int i = 1;i<=l;i++){
ll u,v;
cin>>u>>v;
adj2[u].pb(v);
adj2[v].pb(u);
}
ll cur = 1;
for(int i =1;i<=n;i++){
if(!vis[i]){
dfs(i,cur);
cur++;
}
}
cur =1;
for(int i =1;i<=n;i++){
if(!vis2[i]){
dfs2(i,cur);
cur++;
}
}
for(int i =1;i<=n;i++){
gg[mp(col[i],col2[i])]++;
}
for(int i =1;i<=n;i++){
cout<<gg[mp(col[i],col2[i])]<<" ";
}
cout<<endl;
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(NULL);
ll t=1;
while(t--){
solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int k;
string s, r;
cin >> k >> s;
if(s.size()<=k) cout << s << endl;
else{
for(int i=0;i<k;i++){
r += s.at(i);
}
cout << r << "..." << endl;
}
} | #include <bits/stdc++.h>
#define INF INT_MAX
#define ll long long
#define ull unsigned long long
#define rep(i,n) for(ll i=0; i<n; ++i)
#define FOR(i, s, e) for(ll i=s; i<e; ++i)
#define MOD 1000000007
using namespace std;
template<class T> inline bool chmin(T& a, T b) { if(a>b) {a=b; return true;} return false;}
template<class T> inline bool chmax(T& a, T b) { if(a<b) {a=b; return true;} return false;}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int K; cin >> K;
string S; cin >> S;
if(S.size() > K) {
S = S.substr(0,K) + "...";
}
cout << S << endl;
}
| 1 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;
#define int ll
vector<ll> node[100005];
ll group[100005]={0},group_num[100005]={0},col[100005]={0};
ll nibu[100005]={0};
bool used[100005]={0};
bool dfs(ll pos,ll k,ll cl){
used[pos]=true;
group[pos]=k;
col[pos]=cl;
ll nc=cl%2;
nc++;
bool res=true;
for(int i=0;i<node[pos].size();i++){
ll to=node[pos][i];
if(!used[to]){
used[to]=true;
dfs(to,k,nc);
}
if(col[to]!=nc){
res=false;
}
}
return res;
}
signed main(){
ll n,m;
cin>>n>>m;
for(int i=0;i<m;i++){
ll s,t;
cin>>s>>t;
node[s].push_back(t);
node[t].push_back(s);
}
for(int i=1;i<=n;i++) used[i]=false;
ll cnct_num=0,a=0,b=0,c=0;
for(int i=1;i<=n;i++){
if(!used[i]){
used[i]=true;
group[i]=cnct_num;
if(node[i].size()==0) {
c++;
continue;
}
bool f=dfs(i,cnct_num,1);
b++;
cnct_num++;
}
}
for(int i=1;i<=n;i++){
for(int j=0;j<node[i].size();j++){
ll to=node[i][j];
if(col[i]==col[to]){
nibu[group[i]]=1;
}
}
}
for(int i=0;i<cnct_num;i++){
if(nibu[i]==1){
b--;
a++;
}
}
cout<<a*a+2*a*b+2*b*b+c*(n*2-c)<<endl;
}
| #include<bits/stdc++.h>
using namespace std;
int main()
{
int t,r,c,i,j,k=0;
cin>>r>>c;
int ar[r][c];
int cn[r*c][4];
for(i=0;i<r;i++)
{
for(j=0;j<c;j++)
{
cin>>ar[i][j];
}
}
for(i=0;i<r;i++)
{
for(j=0;j<c-1;j++)
{
if(ar[i][j]%2!=0)
{
k++;
ar[i][j+1]=ar[i][j+1]+1;
ar[i][j]=ar[i][j]-1;
cn[k-1][0]=i;
cn[k-1][1]=j;
cn[k-1][2]=i;
cn[k-1][3]=j+1;
}
}
}
for(j=0;j<c;j++)
{
for(i=0;i<r-1;i++)
{
if(ar[i][j]%2!=0)
{
k++;
ar[i+1][j]=ar[i+1][j]+1;
ar[i][j]=ar[i][j]-1;
cn[k-1][0]=i;
cn[k-1][1]=j;
cn[k-1][2]=i+1;
cn[k-1][3]=j;
}
}
}
cout<<k<<endl;
for(i=0;i<k;i++)
{
for(j=0;j<4;j++)
{
if(j!=3)cout<<cn[i][j]+1<<" ";
else
cout<<cn[i][j]+1<<endl;
}
//cout<<endl;
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
void computeLPSArray(string pattern, int m, int lps[]){
int len=0;
lps[0]=0; //lps[0] is always 0
int i=1;
while(i<m){
if(pattern[i]==pattern[len]){
len++;
lps[i]=len;
i++;
}else{
if(len!=0)
len=lps[len-1];
else{
lps[i]=0;
i++;
}
}
}
}
void kmpSearch(string str,string pattern){
int m=pattern.length();
int n=str.length();
int lps[m]; //longest prefix suffix array
computeLPSArray(pattern,m,lps);
int i=0; //text
int j=0; //pattern
bool found=0;
while(i<n){
if(pattern[j]==str[i]){
i++;
j++;
}
if(j==m){
j=lps[j-1];
found=1;
break;
}else if(i<n && pattern[j]!=str[i]){
if(j!=0) j=lps[j-1];
else i=i+1;
}
}
if(!found)cout<<"No"<<endl;
else cout<<"Yes"<<endl;
}
int main(){
//freopen("input.txt","r",stdin);
//freopen("output.txt","w",stdout);
string str,pattern;
while(cin>>str){
pattern="AC";
kmpSearch(str,pattern);
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int (i)=0;(i)<(n);i++)
#define INF 1001001001
#define LLINF 1001001001001001001
#define MOD 1000000007
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
#define ALL(v) v.begin(), v.end()
typedef long long ll;
int main(){
ll x;cin >> x;
int t=x/500;
int f=(x-t*500)/5;
cout << 1000*t+5*f << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<int> G[1010];
bool H[1010][1010];
bool visited[1010];
vector<int> path;
vector<int> cycle;
void dfs(int v) {
visited[v] = true;
path.push_back(v);
for (int u : G[v]) {
if (!cycle.empty()) continue;
if (find(path.begin(), path.end(), u) != path.end()) {
cycle = path;
return;
} else {
dfs(u);
}
}
path.pop_back();
}
int main() {
int N, M;
cin >> N >> M;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
a--, b--;
G[a].push_back(b);
H[a][b] = true;
}
for (int i = 0; i < N; i++) {
if (visited[i]) continue;
path.clear();
dfs(i);
if (cycle.size() > 0) {
while (!H[cycle[cycle.size() - 1]][cycle[0]]) cycle.erase(cycle.begin());
bool f = true;
while (f) {
f = false;
bool used[1010] = {};
for (int u : cycle) used[u] = true;
int from, to;
for (int i = 0; i < cycle.size(); i++) {
int v = cycle[i];
for (int u = 0; u < N; u++) {
if (!used[u]) continue;
if (u == v) continue;
if (u == cycle[(i + 1) % cycle.size()]) continue;
if (H[v][u]) {
f = true;
from = v, to = u;
break;
}
}
}
if (f) {
vector<int> tmp;
tmp.push_back(from);
while (to != tmp[0]) {
tmp.push_back(to);
for (int u : G[to]) {
if (used[u] && H[to][u]) {
to = u;
break;
}
}
}
cycle = tmp;
}
}
cout << cycle.size() << endl;
for (int v : cycle) {
cout << v + 1 << endl;
}
return 0;
}
}
cout << -1 << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
const int N = 1003;
int n, m, dis[N], par[N];
vector<int> adj[N], ans;
int main(int argc, char const *argv[])
{
scanf("%d %d\n", &n, &m);
for (int i = 0; i < m; ++i)
{
int u, v;
scanf("%d %d\n", &u, &v);
adj[u].push_back(v);
}
for (int s = 1; s <= n; ++s)
{
queue<int> q;
for (int i = 1; i <= n; ++i)
{
par[i] = dis[i] = -1;
}
q.push(s);
dis[s] = 0;
while (!q.empty())
{
int u = q.front();
q.pop();
for (int v: adj[u])
{
if (dis[v] == -1)
{
par[v] = u;
dis[v] = 1 + dis[u];
q.push(v);
}
else if (v == s)
{
int cur = u;
vector<int> temp;
while (cur != -1)
{
temp.push_back(cur);
cur = par[cur];
}
if (temp.size() < ans.size() || ans.empty())
{
ans.clear();
for (int node: temp)
ans.push_back(node);
}
}
}
}
}
if (ans.empty())
printf("%d\n", -1);
else
{
printf("%d\n", (int)ans.size());
for (int node: ans)
printf("%d\n", node);
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
template< typename T >
struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template< typename T >
using Edges = vector< edge< T > >;
template< typename T >
using WeightedGraph = vector< Edges< T > >;
using UnWeightedGraph = vector< vector< int > >;
template< typename T >
using Matrix = vector< vector< T > >;
template< typename T >
T prim(WeightedGraph< T > &g) {
using Pi = pair< T, int >;
T total = 0;
vector< bool > used(g.size(), false);
priority_queue< Pi, vector< Pi >, greater< Pi > > que;
que.emplace(0, 0);
while(!que.empty()) {
auto p = que.top();
que.pop();
if(used[p.second]) continue;
used[p.second] = true;
total += p.first;
for(auto &e : g[p.second]) {
que.emplace(e.cost, e.to);
}
}
return total;
}
int main() {
int V, E;
scanf("%d %d", &V, &E);
WeightedGraph< int > g(V);
for(int i = 0; i < E; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
g[a].emplace_back(b, c);
g[b].emplace_back(a, c);
}
printf("%d\n", prim(g));
}
| //BINARY_BOY!!
//THINK TWICE CODE ONCE { TRUE }
// ##### ### ## # ### ##### # # ##### #####
// # # # # # # # # # # # # # # # #
// ##### # # # # ##### ##### # ##### # #
// # # # # ## # # # # # # # # #
// ##### ### # # # # # # # ##### #####
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int MAXN = 10000 + 5;
vector < pair < int , pair < int , int > > > v ;
vector< int > v2 [ MAXN ];
int n , m, sum = 0, num [ MAXN ];
bool cmd(pair < int , pair<int , int> > p1 , pair < int , pair<int , int> > p2 )
{
return p1.first < p2.first;
}
int main() {
ios::sync_with_stdio(false) , cin.tie(0) , cout.tie(0);
cin >> n >> m;
for(int i = 0 ; i < m ; i++)
{
int a , b, c;
cin >> a >> b >> c;
v.push_back(make_pair(c , make_pair(a , b)));
}
sort(v.begin() , v.end() , cmd);
for(int i = 0 ; i <= n ; i++)
{
v2[ i ].push_back(i);
num [ i ] = i;
}
for(int i = 0 , j = 0 ; i < v.size() && j < n - 1; i++)
{
if(num [ v [ i ].second.first ] != num [ v [ i ].second.second ] )
{
sum += v [ i ].first;
j++;
if(v2 [ num [v [ i ].second.first ]].size() < v2 [num[ v [ i ].second.second ]].size())
{
for(int f = 0 , l = v2 [ num [v [ i ].second.first ] ].size() , k = num [v [ i ].second.first]; f < l ; f++)
{
v2 [ num [v [ i ].second.second ] ].push_back(v2 [ k ][ f ]);
num [v2 [ k ][ f ]] = num [v [ i ].second.second];
}
}
else {
for(int f = 0 , l = v2 [ num [v [ i ].second.second ] ].size() , k = num [v [ i ].second.second] ; f < l ; f++)
{
v2 [ num [v [ i ].second.first] ].push_back(v2 [ k ][ f ]);
num [v2 [ k ][ f ]] = num [v [ i ].second.first];
}
}
}
}
cout << sum << endl;
} | 1 |
#include<iostream>
#include<vector>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
using namespace std;
int main(){
int n;
cin>>n;
vector<int>in(n);
rep(i,n)cin>>in[i];
rep(i,n-1)cout<<in[n-i-1]<<" ";
cout<<in[0]<<endl;
} | // class point の練習（クラスの高度な実装）
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <cstring>
#define INF 1000001
typedef long long llong;
using namespace std;
int main() {
int n;
int a_i;
vector<int> vt;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a_i;
vt.push_back(a_i);
}
reverse(vt.begin(), vt.end());
for (vector<int>::iterator it = vt.begin(); it != vt.end(); it++) {
if (it == vt.begin())cout << *it;
else cout << " " << *it;
}
cout << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
typedef long long ll;
using namespace std;
int main()
{
int A,B,M;
cin>>A>>B>>M;
int a[100010],b[100010],x[100010],y[100010],z[100010];
rep(i,A)cin>>a[i];
rep(i,B)cin>>b[i];
rep(i,M)cin>>x[i]>>y[i]>>z[i];
int min=200100;
rep(i,M){
int sum=0;
sum+=a[x[i]-1]+b[y[i]-1]-z[i];
// cout<<sum<<endl;
if(sum<min)min=sum;
}
if(*min_element(a,a+A)+*min_element(b,b+B)<min)min=*min_element(a,a+A)+*min_element(b,b+B);
cout<<min<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)n;i++)
int main() {
int A, B, C;
cin >> A >> B >> C;
vector<int> ac(A);
vector<int> bc(B);
int minA = 1<<30, minB = 1<<30;
rep(i, A) {
cin >> ac.at(i);
minA = min(minA, ac.at(i));
}
rep(j, B) {
cin >> bc.at(j);
minB = min(minB, bc.at(j));
}
int ans = minA + minB;
rep(i, C) {
int m;
int tmp=0;
cin >> m;
tmp += ac.at(m-1);
cin >> m;
tmp += bc.at(m - 1);
cin >> m;
tmp -= m;
ans = min(ans, tmp);
}
cout << ans << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
int main() {
ll n; cin >> n;
vector<int> x(n);
vector<int> y(n);
for (int i = 0; i < n; ++i) {
cin >> x[i] >> y[i];
}
vector<int> perm(n);
for (int i = 0; i < n; ++i) perm[i] = i;
double dist = 0;
do {
for (int i = 0; i < n - 1; ++i) {
int xi = x[perm[i]];
int nextxi = x[perm[i + 1]];
int yi = y[perm[i]];
int nextyi = y[perm[i + 1]];
dist += sqrt(pow((nextxi - xi), 2) + pow((nextyi - yi), 2));
}
} while (next_permutation(perm.begin(), perm.end()));
for (int i = 2; i <= n; ++i) {
dist /= i;
}
cout << setprecision(20);
cout << dist << endl;
} | #include<bits/stdc++.h>
using namespace std;
using UL = unsigned int;
using ULL = unsigned long long;
using LL = long long;
#define rep(i,n) for(UL i=0; i<(n); i++)
UL buf[9][8][8]={};
UL mask[9]={};
UL ans[8][8];
void put(int x, int y, int k){
buf[k][x][y]=2;
for(int xx=0; xx<8; xx++) for(int yy=0; yy<8; yy++){
if(buf[k][xx][yy]) continue;
if(xx==x || yy==y || (x+y)==(xx+yy) || (x-y)==(xx-yy))
buf[k][xx][yy]=1;
}
}
bool proc(UL k){
if(k==8){ rep(x,8)rep(y,8) ans[x][y]=buf[8][x][y]; return true; }
UL y=0; rep(i,8) if(~mask[k] & (1<<i)) y=i;
mask[k+1] = mask[k] | (1<<y);
rep(x,8){
rep(xx,8)rep(yy,8) buf[k+1][xx][yy]=buf[k][xx][yy];
if(buf[k+1][x][y]) continue;
put(x,y,k+1);
if(proc(k+1)) return true;
}
return false;
}
int main() {
mask[0]=0;
UL K; scanf("%u",&K);
rep(i,K){
UL x,y; scanf("%u%u",&y,&x);
mask[K] |= (1<<y);
put(x,y,K);
}
proc(K);
rep(y,8){
rep(x,8) printf((ans[x][y]==2)?"Q":".");
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> ans(2);
if(n%2 == 1){
for(int l = 1, r = n-1; l < r; l++, r--){
ans.at(0).push_back(l);
ans.at(1).push_back(r);
}
}
else{
bool flag = false;
for(int l = 1, r = n-1; l < r; l++, r--){
if(!flag && r-l <= n/2){
--r;
flag = true;
}
ans.at(0).push_back(l);
ans.at(1).push_back(r);
}
}
for(int i = 0; i < m; i++){
cout << ans.at(0).at(i) << " " << ans.at(1).at(i) << endl;
}
} | #include <iostream>
int main()
{
int sx, sy, tx, ty;
std::cin >> sx >> sy >> tx >> ty;
for (int i = 0; i < ty - sy; ++i)
{
std::cout << 'U';
}
for (int i = 0; i < tx - sx; ++i)
{
std::cout << 'R';
}
// tに到達した
for (int i = 0; i < ty - sy; ++i)
{
std::cout << 'D';
}
for (int i = 0; i < tx - sx; ++i)
{
std::cout << 'L';
}
// sに戻った
std::cout << 'L';
for (int i = 0; i < ty - sy + 1; ++i)
{
std::cout << 'U';
}
for (int i = 0; i < tx - sx + 1; ++i)
{
std::cout << 'R';
}
std::cout << 'D';
// 2回目のt
std::cout << 'R';
for (int i = 0; i < ty - sy + 1; ++i)
{
std::cout << 'D';
}
for (int i = 0; i < tx - sx + 1; ++i)
{
std::cout << 'L';
}
std::cout << 'U';
std::cout << std::endl;
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.