solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, ans;
bool a[26], ex;
string s;
char c, l;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
while (n--) {
cin >> c >> s;
if (c == '.')
for (auto i : s) a[i - 'a'] = 1;
if (c == '!') {
if (ex) ans++;
bool x[26] = {};
for (auto i : s) x[i - 'a'] = 1;
for (int i = 0; i < 26; i++)
if (!x[i]) a[i] = 1;
}
if (c == '?') {
if (ex && s[0] != l) ans++;
a[s[0] - 'a'] = 1;
}
if (!ex) {
int cnt = 0;
for (int i = 0; i < 26; i++) cnt += a[i];
if (cnt == 25) {
ex = 1;
for (int i = 0; i < 26; i++)
if (!a[i]) l = (char)(i + 'a');
}
}
}
cout << ans;
}
| 9 | CPP |
#include<bits/stdc++.h>
#define ll long long
#define fornum(A,B,C) for(A=B;A<C;A++)
#define mp make_pair
#define pii pair<int,int>
#define pll pair<ll,ll>
using namespace std;
/////////////////////////////////////////////////////
ll N;
vector<ll> Av;
ll B;
ll i, j, k, ans;
int main(){
scanf("%lld", &N);
fornum(i,0,N){
ll a;
scanf("%lld", &a);
Av.push_back(a);
B ^= a;
}
fornum(i,0,N){
Av[i] &= ~B;
}
j = 0;
for (i = 59; i >= 0;i--)
{
fornum(k,j,N){
if(Av[k]&(1ll<<i))
break;
}
if(k==N)
continue;
if(j<k){
Av[j] ^= Av[k];
}
fornum(k, j+1, N){
ll a = Av[j] ^ Av[k];
Av[k] = min(Av[k], a);
}
j++;
}
fornum(i,0,N){
ll a = ans ^ Av[i];
ans = max(a, ans);
}
printf("%lld", ans*2 + B);
return 0;
} | 0 | CPP |
n = int(input())
a = list(map(int,input().split()))
s = 0
for i in range(1,n):
if a[i] > max(a[:i]) or a[i] < min(a[:i]):
s += 1
print (s)
| 7 | PYTHON3 |
# -*- coding: utf-8 -*-
"""
Created on Sat Feb 22 16:50:06 2020
@author: Lenovo
"""
#https://codeforces.com/problemset/problem/469/A
def wanna_be():
levels = int(input())
littlex = input().split()
littley = input().split()
dic = {}
for i in range(1,len(littlex)):
if littlex[i] not in dic:
dic[littlex[i]] = 1
for i in range(1,len(littley)):
if littley[i] not in dic:
dic[littley[i]] = 1
if len(dic) == levels:
print('I become the guy.')
else:
print('Oh, my keyboard!')
wanna_be()
| 7 | PYTHON3 |
x = int(input())
print((x//500)*1000+(x%500//5)*5) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int num, x, n, m, i;
bool ans;
cin >> num;
while (num--) {
cin >> x >> n >> m;
if (m == 0) {
cout << "no" << endl;
continue;
} else if (x <= 10) {
cout << "yes" << endl;
continue;
} else if (m * 10 >= x) {
cout << "yes" << endl;
continue;
} else {
for (i = n; i >= 0; i--) {
if (m * 10 >= x) {
cout << "yes" << endl;
break;
} else {
x = (x / 2) + 10;
}
}
if (i == -1) {
cout << "no" << endl;
}
}
}
return 0;
}
| 8 | CPP |
// #include {{{
#include <iostream>
#include <cassert>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <ctime>
#include <queue>
#include <set>
#include <map>
#include <stack>
#include <string>
#include <bitset>
#include <vector>
#include <complex>
#include <algorithm>
using namespace std;
// }}}
// #define {{{
typedef long long ll;
typedef double db;
typedef pair<int,int> pii;
typedef vector<int> vi;
#define de(x) cout << #x << "=" << x << endl
#define rep(i,a,b) for(int i=a;i<(b);++i)
#define per(i,a,b) for(int i=(b)-1;i>=(a);--i)
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
// }}}
typedef ll T;
struct P{
T x,y;
P(){} P(T x,T y):x(x),y(y){}
void read(){scanf("%lld%lld",&x,&y);}
P operator - (const P&b) const {return P(x-b.x,y-b.y);}
P operator + (const P&b) const {return P(x+b.x,y+b.y);}
T operator * (const P&b) const {return x*b.x+y*b.y;}
P operator * (const T&k) const {return P(x*k,y*k);}
T operator ^ (const P&b) const {return x*b.y-y*b.x;}
};
typedef vector<P> polygon;
bool isconvex(polygon A){
bool ok=1;int n=sz(A);
rep(i,0,2) A.pb(A[i]);
rep(i,0,n) ok&=((A[i+1]-A[i])^(A[i+2]-A[i]))>=0;
return ok;
}
int main(){
int n;scanf("%d",&n);
polygon A;
rep(i,0,n){
P p;p.read();
A.pb(p);
}
printf("%d\n",isconvex(A));
return 0;
} | 0 | CPP |
#include<stdio.h>
#include<stdlib.h>
typedef long long int lli;
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
int i,l,r;
lli s=0;
scanf("%d %d",&l,&r);
while(l||r)
{
s+=r-l;
l/=10;
r/=10;
}
printf("%lld\n",s);
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
int CNT;
map<pair<int, int>, int> tko;
int n, R[MAXN];
char s[MAXN];
stack<int> st;
int mogu[MAXN], dep[MAXN];
int maks, boja[MAXN];
void calc(int l, int r, int d) {
tko[make_pair(l, r)] = ++CNT;
maks = max(maks, d);
dep[tko[make_pair(l, r)]] = d;
for (int i = (l); i < int(r + 1); i++) {
if (s[i] == '(') {
calc(i + 1, R[i] - 1, d + 1);
i = R[i];
}
}
}
void rek(int l, int r) {
int cvor = tko[make_pair(l, r)];
if (dep[cvor] == maks) mogu[cvor] = 1;
for (int i = (l); i < int(r + 1); i++) {
if (s[i] == '(') {
rek(i + 1, R[i] - 1);
mogu[cvor] |= mogu[tko[make_pair(i + 1, R[i] - 1)]];
i = R[i];
}
}
if (dep[cvor] >= maks / 2 && mogu[cvor]) {
if (dep[cvor] == maks)
boja[l - 1] = 1;
else
boja[l] = 1;
}
}
int main() {
scanf("%d %s", &n, s);
for (int i = (0); i < int(n); i++) {
if (s[i] == '(')
st.push(i);
else {
R[st.top()] = i;
st.pop();
}
}
int tmp = 0;
for (int i = (0); i < int(n); i++) {
if (s[i] == '(')
tmp++;
else
tmp--;
maks = max(maks, tmp);
}
tmp = 0;
for (int i = (0); i < int(n); i++) {
if (s[i] == '(')
tmp++;
else
tmp--;
if (tmp <= maks / 2 && s[i] == '(') boja[i] = boja[R[i]] = 1;
}
for (int i = (0); i < int(n); i++) printf("%d", boja[i]);
puts("");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#define clr(x) memset(x,0,sizeof x)
#define For(i,a,b) for (int i=(a);i<=(b);i++)
#define Fod(i,b,a) for (int i=(b);i>=(a);i--)
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define fi first
#define se second
#define outval(x) cerr<<#x" = "<<x<<endl
#define outtag(x) cerr<<"-----------------"#x"-----------------\n"
#define outarr(a,L,R) cerr<<#a"["<<L<<".."<<R<<"] = ";\
For(_x,L,R) cerr<<a[_x]<<" ";cerr<<endl;
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair <int,int> pii;
LL read(){
LL x=0,f=0;
char ch=getchar();
while (!isdigit(ch))
f=ch=='-',ch=getchar();
while (isdigit(ch))
x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
return f?-x:x;
}
const int N=25005,K=405,mod=1e9+7;
int Pow(int x,int y){
int ans=1;
for (;y;y>>=1,x=(LL)x*x%mod)
if (y&1)
ans=(LL)ans*x%mod;
return ans;
}
void Add(int &x,int y){
if ((x+=y)>=mod)
x-=mod;
}
void Del(int &x,int y){
if ((x-=y)<0)
x+=mod;
}
int Add(int x){
return x>=mod?x-mod:x;
}
int Del(int x){
return x<0?x+mod:x;
}
int n,k,m;
int a[N];
int dp[N][K],s[N][K];
int vis[K];
int Fac[N],Inv[N];
void prework(){
int n=N-1;
Fac[0]=1;
For(i,1,n)
Fac[i]=(LL)Fac[i-1]*i%mod;
Inv[n]=Pow(Fac[n],mod-2);
Fod(i,n,1)
Inv[i-1]=(LL)Inv[i]*i%mod;
}
int C(int n,int m){
if (m<0||m>n)
return 0;
return (LL)Fac[n]*Inv[m]%mod*Inv[n-m]%mod;
}
int check(){
static int las[N];
if (m<k)
return 0;
int s=0;
For(i,1,m){
s=max(s,las[a[i]]);
las[a[i]]=i;
if (i-s>=k)
return 1;
}
return 0;
}
int main(){
prework();
n=read(),k=read(),m=read();
For(i,1,m)
a[i]=read();
For(i,1,k-1)
dp[0][i]=1,s[0][i]=i;
For(i,1,n)
For(j,1,k-1){
dp[i][j]=((LL)dp[i-1][j+1]*(k-j)+s[i-1][j])%mod;
s[i][j]=Add(s[i][j-1]+dp[i][j]);
}
if (check()){
outtag(1);
int ans=(LL)(n-m+1)*Pow(k,n-m)%mod;
cout<<ans<<endl;
return 0;
}
clr(vis);
int pR=m;
while (pR>0&&!vis[a[pR]])
vis[a[pR--]]=1;
clr(vis);
int pL=1;
while (pL<m+1&&!vis[a[pL]])
vis[a[pL++]]=1;
int ans=0;
if (!pR){
For(i,1,n-m+1){
int now=Pow(k,n-m);
if (i+m-1<k)
Del(now,(LL)C(k-m,i-1)*Fac[i-1]%mod
*dp[n-(i+m-1)][i+m-1]%mod);
For(j,1,min(i-1,k-m)){
int tmp=(LL)C(k-m,j-1)*Fac[j-1]%mod;
tmp=(LL)tmp*dp[n-(i+m-1)][m+j-1]%mod;
tmp=(LL)tmp*s[i-j-1][m+j-1]%mod;
Del(now,tmp);
}
Add(ans,now);
}
}
else {
For(i,1,n-m+1){
Add(ans,Pow(k,n-m));
Del(ans,(LL)dp[i-1][pL-1]*dp[n-(i+m-1)][m-pR]%mod);
}
}
cout<<ans<<endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const int maxl = 200005 + maxn;
const int maxlog = 20;
const int maxnode = maxlog * maxn;
char s[maxl];
int n, l, logn, len[maxn], pos[maxn], sa[maxl], rk[maxl], h[maxlog][maxl],
sz[maxl];
int rt[maxn], lc[maxnode], rc[maxnode], val[maxnode], tot;
inline void build(int n) {
int i, *x = rk, *y = h[0], m = 128, k, p;
for (i = 0; i < m; i++) sz[i] = 0;
for (i = 0; i < n; i++) sz[x[i] = s[i]]++;
for (i = 1; i < m; i++) sz[i] += sz[i - 1];
for (i = n - 1; i >= 0; i--) sa[--sz[x[i]]] = i;
for (k = 1;; k <<= 1) {
for (i = n - k, p = 0; i < n; i++) y[p++] = i;
for (i = 0; i < n; i++)
if (sa[i] >= k) y[p++] = sa[i] - k;
for (i = 0; i < m; i++) sz[i] = 0;
for (i = 0; i < n; i++) sz[x[i]]++;
for (i = 1; i < m; i++) sz[i] += sz[i - 1];
for (i = n - 1; i >= 0; i--) sa[--sz[x[y[i]]]] = y[i];
swap(x, y);
for (x[sa[0]] = 0, i = 1, p = 1; i < n; i++)
x[sa[i]] =
(y[sa[i]] == y[sa[i - 1]] && (sa[i] < n - k) == (sa[i - 1] < n - k) &&
(sa[i] >= n - k || y[sa[i] + k] == y[sa[i - 1] + k]))
? p - 1
: (p++);
if (p >= n) break;
m = p;
}
for (i = 0; i < n; i++) rk[sa[i]] = i;
for (h[0][0] = p = 0, i = 0; i < n; i++) {
if (p) p--;
if (!rk[i]) continue;
while (s[i + p] == s[sa[rk[i] - 1] + p]) p++;
h[0][rk[i]] = p;
}
for (logn = 0; (1 << logn) < n; logn++)
;
for (p = 1; p <= logn; p++)
for (i = 0; i + (1 << p) <= n; i++)
h[p][i] = min(h[p - 1][i], h[p - 1][i + (1 << (p - 1))]);
}
void insert(int &rt, int l, int r, int x) {
int pre = rt;
rt = ++tot, val[rt] = val[pre] + 1, lc[rt] = lc[pre], rc[rt] = rc[pre];
if (l == r) return;
int mid = (l + r) >> 1;
if (x <= mid)
insert(lc[rt], l, mid, x);
else
insert(rc[rt], mid + 1, r, x);
}
int query(int rtr, int rtl, int l, int r, int x, int y) {
if (x <= l && r <= y) return val[rtr] - val[rtl];
int mid = (l + r) >> 1, res = 0;
if (x <= mid) res += query(lc[rtr], lc[rtl], l, mid, x, y);
if (mid < y) res += query(rc[rtr], rc[rtl], mid + 1, r, x, y);
return res;
}
int main() {
int q, i, L, R, k, lb, rb;
l = 0;
scanf("%d%d", &n, &q);
for (i = 1; i <= n; i++)
pos[i] = l, scanf("%s", s + l), len[i] = strlen(s + l), l += len[i] + 1,
s[l - 1] = '#';
s[l] = '\0', build(l);
tot = 0, rt[0] = 0, lc[0] = rc[0] = val[0] = 0;
for (i = 1; i <= n; i++) {
rt[i] = rt[i - 1];
for (k = pos[i]; k < pos[i] + len[i]; k++) insert(rt[i], 0, l - 1, rk[k]);
}
while (q--) {
scanf("%d%d%d", &L, &R, &k);
lb = rb = rk[pos[k]];
for (i = logn; i >= 0; i--) {
if (lb - (1 << i) >= 0 && h[i][lb - (1 << i) + 1] >= len[k]) lb -= 1 << i;
if (rb + (1 << i) < l && h[i][rb + 1] >= len[k]) rb += 1 << i;
}
printf("%d\n", query(rt[R], rt[L - 1], 0, l - 1, lb, rb));
}
return 0;
}
| 11 | CPP |
import sys
f = sys.stdin
while True:
n = int(f.readline())
if n == 0:
break
a = [int(f.readline()) for i in range(n)]
sum_max = now = 0
for ai in a:
now = max(0, now + ai)
sum_max = max(sum_max, now)
print(sum_max if sum_max else max(a)) | 0 | PYTHON3 |
# -*- coding: utf-8 -*-
from bisect import bisect_left
N = int(input())
A = [int(input()) for _ in range(N)]
L = [A[0]]
for i in range(1, N):
if L[-1] < A[i]:
L.append(A[i])
else:
L[bisect_left(L, A[i])] = A[i]
print(len(L)) | 0 | PYTHON3 |
#include <iostream>
void solve()
{
int n;
scanf("%d", &n);
if (n == 1) {
printf("9\n");
} else if (n == 2) {
printf("98\n");
} else {
printf("989");
for (int i = 3; i < n; i++) {
printf("%d", (i - 3) % 10);
}
printf("\n");
}
}
int main()
{
int t;
scanf("%d", &t);
while (t--) {
solve();
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using pii = pair<int, int>;
const int N = 3e5 + 10;
int ans[N];
LL r[N], h[N];
set<int> adj[N];
void erase(int u, int v) {
adj[u].erase(v);
adj[v].erase(u);
}
void add(int u, int v) {
adj[u].insert(v);
adj[v].insert(u);
}
void NO() {
puts("NO");
exit(0);
}
LL get(int u) {
LL ans = r[u];
for (auto v : adj[u]) ans += r[v];
return ans;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0, u, v; i < m; i++) scanf("%d %d", &u, &v), add(u, v);
for (int i = 1; i <= n; i++)
r[i] = ((1ll * rand()) << 30) + (rand() << 15) + rand();
for (int i = 1; i <= n; i++) h[i] = get(i);
set<int> L, R;
for (int crr = 1, u = 0;; crr++) {
if (crr == 1) {
for (int i = 1; !u && i <= n; i++) {
set<LL> tmp;
tmp.insert(h[i]);
for (auto j : adj[i]) {
tmp.insert(h[j]);
if (tmp.size() > 3) NO();
}
if (tmp.size() < 3) u = i;
}
if (!u) NO();
L.insert(u);
for (auto v : adj[u]) {
if (adj[v].size() == adj[u].size())
L.insert(v);
else
R.insert(v);
}
} else {
u = *L.begin();
for (auto v : adj[u])
if (!L.count(v)) R.insert(v);
}
for (auto v : L)
if (adj[v].size() != adj[u].size()) NO();
for (auto u : L) {
for (auto v : R)
if (!adj[u].count(v)) NO();
for (auto v : L)
if (u != v && !adj[u].count(v)) NO();
}
for (auto u : L) ans[u] = crr;
if (R.empty()) break;
for (auto u : L)
while (adj[u].size()) erase(u, *adj[u].begin());
L.clear();
for (auto u : R) L.insert(u);
R.clear();
}
puts("YES");
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], " \n"[i == n]);
return 0;
}
| 10 | CPP |
n = int(input())
mil = list(map(int, input().split()))
count = 0
maxx_index = mil.index(max(mil))
while maxx_index - 1 >= 0:
mil[maxx_index-1], mil[maxx_index] = mil[maxx_index], mil[maxx_index-1]
count += 1
maxx_index -= 1
mil = mil[::-1]
minn_index = mil.index(min(mil))
while minn_index - 1 >= 0:
mil[minn_index-1], mil[minn_index] = mil[minn_index], mil[minn_index-1]
count += 1
minn_index -= 1
print(count)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
int n, m, k, arr[N], a, nxt[N], nj;
bool blocked[N];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i++) {
scanf("%d", &a);
blocked[a] = true;
}
nxt[0] = -1;
for (int i = 1; i <= n; i++) {
if (blocked[i - 1])
nxt[i] = nxt[i - 1];
else
nxt[i] = i - 1;
}
for (int i = 1; i <= k; i++) scanf("%d", &arr[i]);
long long ans = (long long)4e18, cur;
for (int i = 1; i <= k; i++) {
cur = 0;
for (int j = 0; j < n;) {
if (blocked[j]) {
cur = (long long)4e18;
break;
}
nj = j + i;
if (nj < n && blocked[nj]) {
nj = nxt[nj];
}
if (nj <= j) {
cur = (long long)4e18;
break;
}
cur += arr[i];
j = nj;
}
ans = min(ans, cur);
}
if (ans >= (long long)3e18) ans = -1;
cout << ans << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
class Div2 {
public:
int n;
string ans, cmp;
int recur(string s, int idx, int cmp_idx) {
if (cmp_idx > 4 or idx >= n) {
return 0;
}
if (s[idx] == cmp[cmp_idx]) {
ans += s[idx];
cmp_idx++;
}
return recur(s, idx + 1, cmp_idx);
}
void solve() {
string s;
cin >> s;
n = (int)s.size();
ans = "";
cmp = "hello";
recur(s, 0, 0);
cout << (ans == cmp ? "YES" : "NO") << "\n";
}
void testcases() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
solve();
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
Div2 s;
s.solve();
return 0;
}
| 7 | CPP |
t=int(input())
while t!=0:
t-=1
n=int(input())
l=list(map(int,input().split()))
if n==1:
print("YES")
else:
l.sort()
fl=0
for i in range(0,n-1):
if abs(l[i+1]-l[i])>1:
print("NO")
fl=1
break
if fl==0:
print("YES")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<int, unordered_map<int, int> > m1;
void update(int time, int index, int value) {
while (time <= 300005) {
int ind = index;
while (ind <= 300005) {
m1[time][ind] += value;
ind += (ind & -ind);
}
time += (time & -time);
}
}
int sum(int time, int index) {
int s = 0;
while (time > 0) {
int ind = index;
while (ind > 0) {
s += m1[time][ind];
ind -= (ind & -ind);
}
time -= (time & -time);
}
return s;
}
int main() {
int n;
scanf("%d", &n);
vector<pair<int, pair<int, int> > > v1;
vector<int> v2;
for (int i = 0; i < n; i++) {
int x, y, z;
scanf("%d", &x);
scanf("%d", &y);
scanf("%d", &z);
v1.push_back(make_pair(x, make_pair(y, z)));
v2.push_back(y);
v2.push_back(z);
}
sort(v2.begin(), v2.end());
int ctr = 1;
unordered_map<int, int> m2;
for (int i = 0; i < v2.size(); i++) {
if (m2[v2[i]] == 0) {
m2[v2[i]] = ctr;
ctr++;
}
}
for (int i = 0; i < n; i++) {
v1[i].second.first = m2[v1[i].second.first];
v1[i].second.second = m2[v1[i].second.second];
}
for (int i = 0; i < n; i++) {
if (v1[i].first == 1) {
update(v1[i].second.first, v1[i].second.second, 1);
} else if (v1[i].first == 2) {
update(v1[i].second.first, v1[i].second.second, -1);
} else if (v1[i].first == 3) {
printf("%d\n", sum(v1[i].second.first, v1[i].second.second) -
sum(v1[i].second.first, v1[i].second.second - 1));
}
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
double a, b, r, s, d;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
cin >> d;
a = 0, b = d;
r = 1, s = 0;
while (r >= 0.0000000000001) {
s = 0;
double x = a, y = b;
while (s < 10 * r) {
if ((a + s) * (b - s) > x * y and (a + s) * (b - s) <= d) {
x = a + s;
y = b - s;
}
s += r;
}
a = x, b = y;
r /= 10;
}
double diff = d - a * b;
if (diff > 0.000001) {
cout << "N\n";
} else {
cout << "Y ";
cout << setprecision(12) << a << " " << b << "\n";
}
}
return 0;
}
| 9 | CPP |
# 50A
# py3.6
a,b = [int(i) for i in input().split()]
if a%2==1 and b%2==1:
print(int((a*b-1)/2))
else:
print(int(a*b/2))
| 7 | PYTHON3 |
def double_matrix(n, m, matrix_1, matrix_2):
for i in range(n):
if matrix_1[i][0]>matrix_2[i][0]:
matrix_1[i][0],matrix_2[i][0]=matrix_2[i][0],matrix_1[i][0]
for j in range(1,m):
if matrix_1[i][j]>matrix_2[i][j]:
matrix_1[i][j],matrix_2[i][j]=matrix_2[i][j],matrix_1[i][j]
if not matrix_1[i][j]>matrix_1[i][j-1] or not matrix_2[i][j]>matrix_2[i][j-1]:
return "Impossible"
for k in range(m):
for l in range(1,n):
if not matrix_1[l][k]>matrix_1[l-1][k] or not matrix_2[l][k]>matrix_2[l-1][k]:
return "Impossible"
return "Possible"
n,m=map(int, input().split())
matrix_1=[]
matrix_2=[]
for _ in range(n):
matrix_1.append(list(map(int, input().split())))
for __ in range(n):
matrix_2.append(list(map(int, input().split())))
print(double_matrix(n, m, matrix_1, matrix_2))
| 8 | PYTHON3 |
t = int(input())
for c in range(t):
a = input()
s = input()
if '8' in s:
r = (len(s)-s.find('8'))
if (r>=11):
print('YES')
else:
print('NO')
else:
print('NO')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
set<pair<int, int> > s;
int x[20005], y[20005];
int a[20005];
int t;
int top;
int input;
void out() {
for (int i = 0; i < m; i++) {
if (x[i] == input) {
if (s.find(pair<int, int>(a[y[i]], y[i])) == s.end()) continue;
printf("%d\n", y[i]);
fflush(stdout);
s.erase(pair<int, int>(a[y[i]], y[i]));
return;
} else if (y[i] == input) {
if (s.find(pair<int, int>(a[x[i]], x[i])) == s.end()) continue;
printf("%d\n", x[i]);
fflush(stdout);
s.erase(pair<int, int>(a[x[i]], x[i]));
return;
}
}
while (top < m) {
int now;
if (a[x[top]] > a[y[top]])
now = x[top];
else
now = y[top];
if (s.find(pair<int, int>(a[now], now)) == s.end()) {
top++;
continue;
}
printf("%d\n", now);
fflush(stdout);
s.erase(pair<int, int>(a[now], now));
top++;
return;
}
auto iter = s.end();
iter--;
printf("%d\n", iter->second);
fflush(stdout);
s.erase(iter);
}
void in() {
int now;
scanf("%d", &now);
s.erase(pair<int, int>(a[now], now));
input = now;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= 2 * n; i++) {
scanf("%d", &a[i]);
s.insert(pair<int, int>(a[i], i));
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &x[i], &y[i]);
}
top = 0;
input = 0;
cin >> t;
if (t == 1) out();
while (!s.empty()) {
in();
if (s.empty()) break;
out();
}
return 0;
}
| 9 | CPP |
a=input()
b=a.lower()
c=b.replace('a','').replace('o','').replace('y','').replace('e','').replace('u','').replace('i','')
d='.'.join(c)
print('.',d,sep='') | 7 | PYTHON3 |
A=[int(input()) for _ in range(5)]
print("Yay!" if (A[-1]-A[0])<=int(input()) else ":(")
| 0 | PYTHON3 |
n=int(input())
if (n%2 == 0):
print(8,(n-8),sep=' ')
else:
print(9,(n-9),sep=' ') | 7 | PYTHON3 |
#include <bits/stdc++.h>
const int maxn = 100005;
using namespace std;
int main() {
string a, b;
int Max = 0;
cin >> a >> b;
for (int i = 0; i < a.size(); i++) Max = max(Max, a[i] - '0');
for (int i = 0; i < b.size(); i++) Max = max(Max, b[i] - '0');
Max++;
int l = 0, r = 0;
for (int i = 0; i < a.size(); i++) l = l * Max + a[i] - '0';
for (int i = 0; i < b.size(); i++) r = r * Max + b[i] - '0';
int c = l + r;
int cnt = 0;
while (c) {
c /= Max;
cnt++;
}
cout << cnt << endl;
}
| 8 | CPP |
p = input()
def inp(s):
j = 0
a = []
for i in range(len(s)):
if s[i] == " ":
a.append(int(s[j:i]))
j = i+1
if i == len(s)-1:
a.append(int(s[j:]))
return a
s = input()
a = inp(s)
print (a[1]-a[0],a[len(a)-1]-a[0])
for i in range(1,len(a)-1):
if a[i]-a[i-1]>=a[i+1]-a[i] and a[i]-a[0]>=a[len(a)-1]-a[i]:
print(a[i+1]-a[i],a[i]-a[0])
elif a[i]-a[i-1]<a[i+1]-a[i] and a[i]-a[0]>=a[len(a)-1]-a[i]:
print(a[i]-a[i-1],a[i]-a[0])
elif a[i]-a[i-1]>=a[i+1]-a[i] and a[i]-a[0]<a[len(a)-1]-a[i]:
print(a[i+1]-a[i],a[len(a)-1]-a[i])
elif a[i]-a[i-1]<a[i+1]-a[i] and a[i]-a[0]<a[len(a)-1]-a[i]:
print(a[i]-a[i-1],a[len(a)-1]-a[i])
print(a[len(a)-1]-a[len(a)-2],a[len(a)-1]-a[0])
| 7 | PYTHON3 |
#include <iostream>
using namespace std;
int main() {
int n, nn, l;
int ans;
while (cin >> n) {
if (n<=1000 || n>=3000) {
nn = (n<=1000) ? n : 4000-n;
ans = (nn+3)*(nn+2)*(nn+1)/6;
} else {
ans = 0;
nn = (n>2000) ? 4000-n : n;
l = nn-1000;
ans = 167167*(3*nn-1997);
ans += l*(l+1)*(999-l)>>1;
}
cout << ans << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O500")
#pragma comment(linker, "/STACK:1677777216")
#pragma warning(default : 4)
using namespace std;
const double eps = 1e-12;
const int oo = 0x3F3F3F3F;
const long long ooLL = 0x3F3F3F3F3F3F3F3FLL;
const int MOD = 1000000007;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
void debpr(const T &);
template <typename T1, typename T2>
void debpr(const pair<T1, T2> &);
template <typename T1, typename T2>
void debpr(const vector<T1, T2> &);
template <typename T>
void debpr(const set<T> &);
template <typename T1, typename T2>
void debpr(const map<T1, T2> &);
template <typename T>
void prcont(T be, T en, const string &st, const string &fi, const string &mi) {
debpr(st);
bool ft = 0;
while (be != en) {
if (ft) debpr(mi);
ft = 1;
debpr(*be);
++be;
}
debpr(fi);
}
template <typename T>
void debpr(const T &a) {}
template <typename T1, typename T2>
void debpr(const pair<T1, T2> &p) {
debpr("(");
debpr(p.first);
debpr(", ");
debpr(p.second);
debpr(")");
}
template <typename T1, typename T2>
void debpr(const vector<T1, T2> &a) {
prcont(a.begin(), a.end(), "[", "]", ", ");
}
template <typename T>
void debpr(const set<T> &a) {
prcont(a.begin(), a.end(), "{", "}", ", ");
}
template <typename T1, typename T2>
void debpr(const map<T1, T2> &a) {
prcont(a.begin(), a.end(), "{", "}", ", ");
}
void deb(){};
template <typename T1>
void deb(const T1 &t1) {
debpr(t1);
debpr('\n');
}
template <typename T1, typename T2>
void deb(const T1 &t1, const T2 &t2) {
debpr(t1);
debpr(' ');
debpr(t2);
debpr('\n');
}
template <typename T1, typename T2, typename T3>
void deb(const T1 &t1, const T2 &t2, const T3 &t3) {
debpr(t1);
debpr(' ');
debpr(t2);
debpr(' ');
debpr(t3);
debpr('\n');
}
template <typename T1, typename T2, typename T3, typename T4>
void deb(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4) {
debpr(t1);
debpr(' ');
debpr(t2);
debpr(' ');
debpr(t3);
debpr(' ');
debpr(t4);
debpr('\n');
}
const double PI = acos(-1.);
long long Round(double x) { return x < 0 ? x - .5 : x + .5; }
template <typename T>
void ass(bool v, const T &x, string m = "Fail") {
if (!v) {
deb(m);
deb(x);
throw;
}
}
int main() {
void run();
run();
return 0;
}
int add(int a, int b) {
a += b;
return a >= MOD ? a - MOD : a;
}
int mul(int a, long long b) { return a * b % MOD; }
int pw(int a, long long b) {
int rs = 1;
for (; b; b >>= 1, a = mul(a, a))
if (b & 1) rs = mul(rs, a);
return rs;
}
const int T = 102;
int n, k, d[T][T * T], h[T][T], c[T][T];
long long m;
void run() {
for (int i = (0), _b(T - 1); i < _b; ++i) {
c[i][0] = 1;
for (int j = (0), _b(i); j < _b; ++j)
c[i][j + 1] = add(c[i - 1][j], c[i - 1][j + 1]);
}
cin >> n >> m >> k;
d[0][0] = 1;
for (int i = (0), _b(n); i < _b; ++i) {
for (int t = (0), _b(n + 1); t < _b; ++t)
h[i][t] = pw(c[n][t], m / n + (i < m % n));
for (int j = (0), _b(k + 1); j < _b; ++j)
for (int t = (0), _b(min(j + 1, n + 1)); t < _b; ++t)
d[i + 1][j] = add(d[i + 1][j], mul(d[i][j - t], h[i][t]));
}
printf("%d\n", d[n][k]);
}
| 10 | CPP |
t = int(input())
for _ in range(t):
n, x = (int(i) for i in input().split())
if n == x == 1: print(1)
else: print((2*x + n-3)//x) | 7 | PYTHON3 |
from heapq import heappop, heappush
manhattan = tuple(tuple(abs((i % 4) - (j % 4)) + abs((i // 4) - (j // 4)) for j in range(16)) for i in range(16))
movables = ((1, 4), (0, 2, 5), (1, 3, 6), (2, 7), (0, 5, 8), (1, 4, 6, 9), (2, 5, 7, 10), (3, 6, 11),
(4, 9, 12), (5, 8, 10, 13), (6, 9, 11, 14), (7, 10, 15), (8, 13), (9, 12, 14), (10, 13, 15), (11, 14))
swap_mul = tuple(tuple((1 << mf) - (1 << mt) for mt in range(0, 64, 4)) for mf in range(0, 64, 4))
destination = 0xfedcba9876543210
i = 0
board_init = 0
blank_init = 0
for _ in range(4):
for n in map(int, input().split()):
if n:
n -= 1
else:
n = 15
blank_init = i
board_init += n * 16 ** i
i += 1
estimation_init = sum(manhattan[i][((board_init >> (4 * i)) & 15)] for i in range(16) if i != blank_init)
queue = [(estimation_init, board_init, blank_init)]
visited = set()
while True:
estimation, board, blank = heappop(queue)
if board in visited:
continue
elif board == destination:
print(estimation)
break
visited.add(board)
for new_blank in movables[blank]:
num = (board >> (4 * new_blank)) & 15
new_board = board + swap_mul[new_blank][blank] * (15 - num)
if new_board in visited:
continue
new_estimation = estimation + 1 - manhattan[new_blank][num] + manhattan[blank][num]
if new_estimation > 45:
continue
heappush(queue, (new_estimation, new_board, new_blank))
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int x, y, x1, y1, x2, y2;
cin >> x >> y >> x1 >> y1 >> x2 >> y2;
if (x1 <= x && y1 <= y &&
((x - x1 >= x2 && y >= y2) || (x >= x2 && y - y1 >= y2)))
return cout << "YES", 0;
swap(x, y);
if (x1 <= x && y1 <= y &&
((x - x1 >= x2 && y >= y2) || (x >= x2 && y - y1 >= y2)))
return cout << "YES", 0;
swap(x, y);
swap(x2, y2);
if (x1 <= x && y1 <= y &&
((x - x1 >= x2 && y >= y2) || (x >= x2 && y - y1 >= y2)))
return cout << "YES", 0;
swap(x, y);
if (x1 <= x && y1 <= y &&
((x - x1 >= x2 && y >= y2) || (x >= x2 && y - y1 >= y2)))
return cout << "YES", 0;
cout << "NO";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const double pi = acos(-1.0);
const int inf = INT_MAX;
const int N = 85;
int n, m, a[N], pos[N];
int dp[N][N][N * N];
int f(int x) { return (x * x - x) / 2; }
int recurse(int i, int j, int moves) {
if (moves < 0) {
return INT_MAX;
}
if (pos[j + 1] == -1) {
return f(n - i);
}
int& ans = dp[i][j][moves];
if (ans != -1) {
return ans;
}
ans = INT_MAX;
for (int ii = i; ii <= n - (m - j); ii++) {
int rec = recurse(ii + 1, j + 1, moves - abs(pos[j + 1] - ii));
if (rec != INT_MAX) {
ans = min(ans, f(ii - i) + rec);
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
memset(pos, -1, sizeof(pos));
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
if (a[i]) {
pos[++m] = i;
}
}
int total = f(n - accumulate(a, a + n, 0));
memset(dp, -1, sizeof(dp));
for (int i = 0; i <= (n * n - n) / 2; i++) {
cout << total - recurse(0, 0, i) << ' ';
}
cout << '\n';
return 0;
}
| 11 | CPP |
n = int(input())
l = [ int(x) for x in str(input()).split(' ')]
l.sort()
sum = 0
cnt = 0
for i in range(n):
if sum <= l[i] :
cnt = cnt + 1
sum = sum + l[i]
print(cnt)
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string input;
cin >> input;
string dic[10];
int start = 0;
for (int i = 0; i < 10; i++) {
cin >> dic[i];
}
string ans = "";
string find[10];
for (int i = 0; i < 8; i++) {
find[i] = input.substr(start, 10);
start += 10;
}
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 10; j++) {
if (find[i] == dic[j]) {
ans += char(j + 48);
}
}
}
cout << ans;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
char num[N];
int n;
int c[N];
int ans[N];
bool judge() {
if (n == 0) return false;
int i = 0;
while (i < n / 2) {
int j = n - i - 1;
if (c[i] == c[j]) {
i++;
j--;
} else if (c[i] == c[j] + 1 || c[i] == c[j] + 11) {
c[i]--;
c[i + 1] += 10;
} else if (c[i] == c[j] + 10) {
c[j] += 10;
c[j - 1]--;
} else
return false;
}
if (c[0] == 0) return false;
if (n % 2 && (c[i] > 18 || c[i] % 2 || c[i] < 0)) return false;
while (i >= 0) {
int j = n - i - 1;
if (c[i] > 18 || c[i] < 0) return false;
ans[i] = (c[i] + 1) / 2;
ans[j] = c[i] / 2;
i--;
}
return true;
}
bool check() {
for (int i = 0; i < n; i++) c[i] = num[i] - '0';
if (judge()) return true;
if (num[0] == '1') {
for (int i = 0; i < n - 1; i++) num[i] = num[i + 1];
n--;
for (int i = 0; i < n; i++) c[i] = num[i] - '0';
c[0] += 10;
if (judge()) return true;
}
return false;
}
int main() {
scanf("%s", num);
n = strlen(num);
if (check()) {
for (int i = 0; i < n; i++) printf("%c", ans[i] + '0');
printf("\n");
} else
printf("0\n");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int vo[30];
int k;
char s[10009][10002];
bool rhyme(int x, int y) {
int i = 0;
int cnt = 0;
while (s[x][i] && s[y][i]) {
if (s[x][i] != s[y][i]) return false;
cnt += vo[s[x][i] - 'a'];
if (cnt == k) return true;
i++;
}
return false;
}
bool ans[6] = {1, 1, 1, 1};
int main() {
vo[0] = true;
vo['e' - 'a'] = true;
vo['i' - 'a'] = true;
vo['o' - 'a'] = true;
vo['u' - 'a'] = true;
int n;
scanf("%d%d", &n, &k);
for (int i = 0; i < 4 * n; i++) {
scanf("%s", s[i]);
reverse(s[i], s[i] + strlen(s[i]));
if ((i + 1) % 4 != 0) continue;
bool eq[5][5] = {{0}};
for (int j = i - 3; j <= i; j++)
for (int x = j + 1; x <= i; x++) {
eq[j - i + 3][x - i + 3] = rhyme(j, x);
}
ans[0] &= (eq[0][1] && eq[2][3]);
ans[1] &= (eq[0][2] && eq[1][3]);
ans[2] &= (eq[0][3] && eq[1][2]);
ans[3] &= (eq[0][1] && eq[0][2] && eq[0][3]);
}
if (ans[3])
puts("aaaa");
else if (ans[0])
puts("aabb");
else if (ans[1])
puts("abab");
else if (ans[2])
puts("abba");
else
puts("NO");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long w[2050000], a[2050000], w1[2050000], b[2050000];
long long n, m, k;
struct node {
long long t;
long long x;
long long y;
long long money;
} f[2050000];
bool cmp(node x, node y) {
if (x.y == 0 && y.y != 0) {
return true;
} else if (x.y != 0 && y.y == 0) {
return false;
} else
return x.t < y.t;
}
int main() {
long long maxx = 0;
scanf("%I64d%I64d%I64d", &n, &m, &k);
for (int i = 0; i < m; i++) {
scanf("%I64d%I64d%I64d%I64d", &f[i].t, &f[i].x, &f[i].y, &f[i].money);
}
for (long long i = 0; i < 2050000; i++) {
w[i] = 100010000000;
w1[i] = 100010000000;
}
maxx = (long long)1 * 100010000000 * n;
int len1 = 0;
sort(f, f + m, cmp);
int i = 0;
for (i; i < m; i++) {
if (f[i].y != 0) {
break;
}
if (f[i].money <= w[f[i].x]) {
long long k = w[f[i].x] - f[i].money;
maxx -= k;
w[f[i].x] = f[i].money;
a[f[i].t] = maxx;
len1 = f[i].t;
}
}
maxx = (long long)1 * 100010000000 * n;
int sum = 0;
int len2 = f[m - 1].t;
for (int j = m - 1; j >= i; j--) {
if (f[j].money <= w1[f[j].y]) {
long long k = w1[f[j].y] - f[j].money;
maxx -= k;
w1[f[j].y] = f[j].money;
b[f[j].t] = maxx;
}
}
a[0] = -1;
for (i = 1; i < 2050000; i++) {
if (!a[i]) {
a[i] = a[i - 1];
}
if (a[i] >= 100010000000) {
a[i] = -1;
}
}
for (int i = len2; i >= 0; i--) {
}
for (int i = 0; i < 2050000; i++) {
if (a[i - 1] != -1) {
a[i] = min(a[i - 1], a[i]);
}
}
b[0] = -1;
for (i = len2 - 1; i >= 0; i--) {
if (b[i]) {
b[i] = min(b[i + 1], b[i]);
} else {
b[i] = b[i + 1];
}
}
long long ans = n * 100010000000;
for (int i = 1; i + k + 1 <= len2; i++) {
if (a[i] != -1 && b[i + k + 1] != -1) {
ans = min(ans, a[i] + b[i + k + 1]);
}
}
if (ans >= 100010000000 || ans < 0) {
printf("-1");
} else
printf("%I64d\n", ans);
}
| 10 | CPP |
#include <iostream>
using namespace std;
int main() {
double ax, ay, bx, by, cx, cy, dx, dy;
while (cin >> ax >> ay >> bx >> by >> cx >> cy >> dx >> dy) {
if (ax > dx || bx < cx || ay > dy || by < cy) {
cout << "NO";
} else {
cout << "YES";
}
cout << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
double a[N], b[N];
char s[N];
int n, m;
int main() {
scanf("%d%s", &n, &s);
m = n;
for (int i = 0; i < n; i++) a[i] = s[i] - '0';
for (int i = 2; i <= n; i++)
if (m % i == 0) {
while (i >= 2 && m % i == 0) m /= i;
for (int j = 0; j < n; j++) b[j] = a[j];
for (int j = 0; j < n; j++) a[j] = b[(j + n / i) % n] - b[j];
}
for (int i = 0; i < n; i++)
if (fabs(a[i]) > 1e-8) return puts("NO"), 0;
puts("YES");
return 0;
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n, m, u, v, color[N], f[N], sz[N], cycle[N], res;
vector<int> g[N];
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
void merge(int u, int v) {
if ((u = find(u)) == (v = find(v))) return;
if (sz[u] < sz[v]) swap(u, v);
sz[u] += sz[v];
f[v] = u;
}
void dfs(int u) {
color[u] = 1;
for (int x : g[u]) {
merge(u, x);
if (color[x] == 0)
dfs(x);
else if (color[x] == 1) {
cycle[x] = 1;
}
}
color[u] = 2;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = (int)(1); i <= (int)(m); ++i) {
scanf("%d %d", &u, &v);
g[u].push_back(v);
}
for (int i = (int)(1); i <= (int)(n); ++i) f[i] = i, sz[i] = 1;
for (int i = (int)(1); i <= (int)(n); ++i)
if (!color[i]) {
dfs(i);
}
for (int i = (int)(1); i <= (int)(n); ++i) cycle[find(i)] |= cycle[i];
for (int i = (int)(1); i <= (int)(n); ++i)
if (find(i) == i) {
if (cycle[i])
res += sz[i];
else
res += sz[i] - 1;
}
printf("%d\n", res);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, q, val[200000 + 5], pos[200000 + 5];
int fa[200000 + 5][18 + 1], ct;
long long read() {
long long x = 0, F = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') F = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * F;
}
struct init_tree {
int dep[200000 + 5], in[200000 + 5], ot[200000 + 5];
vector<int> G[200000 + 5];
void dfs(int x, int f) {
in[x] = ++ct;
for (int i = 0; i < G[x].size(); i++) {
int nxt = G[x][i];
if (x == f) continue;
fa[nxt][0] = x;
dep[nxt] = dep[x] + 1;
dfs(nxt, x);
}
ot[x] = ++ct;
}
bool subtree(int x, int y) { return (in[x] <= in[y] && ot[x] >= ot[y]); }
int LCA(int u, int v) {
if (subtree(u, v)) return u;
if (subtree(v, u)) return v;
int k = u;
for (int i = 18; i >= 0; i--)
if (!subtree(fa[k][i], v)) k = fa[k][i];
return fa[k][0];
}
int dist(int u, int v) {
int c = LCA(u, v);
return dep[u] + dep[v] - 2 * dep[c];
}
void prepare() {
for (int i = 1; i <= n; i++) {
val[i] = read() + 1;
pos[val[i]] = i;
}
for (int i = 2; i <= n; i++) G[read()].push_back(i);
fa[1][0] = 1;
dfs(1, 0);
for (int k = 1; k <= 18; k++)
for (int i = 1; i <= n; i++) fa[i][k] = fa[fa[i][k - 1]][k - 1];
}
} B;
struct Seg_tree {
struct node {
int x, y;
} p[(200000 << 2) + 5];
node merge(node A, int c) {
int a = A.x, b = A.y;
int D1 = B.dist(a, b), D2 = B.dist(b, c), D3 = B.dist(a, c);
if (D1 + D2 == D3) return (node){a, c};
if (D1 + D3 == D2) return (node){c, b};
if (D2 + D3 == D1) return (node){a, b};
return (node){-1, -1};
}
node Merge(node a, node b) {
if (a.x < 0 || b.x < 0) return (node){-1, -1};
node tmp = merge(a, b.x);
if (tmp.x < 0) return (node){-1, -1};
return merge(tmp, b.y);
}
void modf(int x, int l, int r, int ps) {
if (l == r) {
p[x] = (node){pos[l], pos[l]};
return;
}
int mid = (l + r) >> 1;
if (ps <= mid)
modf(x << 1, l, mid, ps);
else
modf(x << 1 | 1, mid + 1, r, ps);
p[x] = Merge(p[x << 1], p[x << 1 | 1]);
}
int query(int x, int l, int r, node &pre) {
if (p[x].x >= 0) {
if (pre.x < 0) {
pre = p[x];
return r + 1;
}
node tmp = Merge(pre, p[x]);
if (tmp.x >= 0) {
pre = tmp;
return r + 1;
}
}
if (l == r) return l;
int mid = (l + r) >> 1;
int res = query(x << 1, l, mid, pre);
if (res <= mid) return res;
return query(x << 1 | 1, mid + 1, r, pre);
}
int Query() {
node pre = (node){-1, -1};
return query(1, 1, n, pre) - 1;
}
} T;
int main() {
n = read();
B.prepare();
for (int i = 1; i <= n; i++) T.modf(1, 1, n, i);
q = read();
while (q--) {
int opt = read();
if (opt == 1) {
int a = read(), b = read();
swap(pos[val[a]], pos[val[b]]);
swap(val[a], val[b]);
T.modf(1, 1, n, val[a]);
T.modf(1, 1, n, val[b]);
} else
printf("%d\n", T.Query());
}
}
| 12 | CPP |
import sys
import heapq
input = sys.stdin.readline
tc = int(input())
def push(y, a, b, c):
if a:
heapq.heappush(y, (a, b, c))
def do4(k):
x = [0]*k
y = [(-k, 0, k)]
for i in range(1, 1+k):
d, l, r = heapq.heappop(y)
m = (l+r-1) // 2
x[m] = i
push(y, l - m, l, m)
push(y, m + 1 - r, m + 1, r)
print(*x)
for _ in range(tc):
do4(int(input()))
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 5;
const int logN = 18;
const int inf = 1e9;
const int N = 1e5 + 44;
int P[N], in[N][2], out[N][2], sum[N], h[N], val[N];
int X, n, m, mod, k, x, y, S, center, C, T;
vector<int> v[N];
pair<int, int> a[N], b[N];
int FE(int x, int k) {
if (!k) return 1;
int temp = FE(x, k / 2);
if (k & 1) return (long long)temp * temp % mod * x % mod;
return (long long)temp * temp % mod;
}
int prep(int node, int root) {
sum[node] = 1;
for (__typeof(v[node].begin()) it = v[node].begin(); it != v[node].end();
it++)
if (*it != root && !h[*it]) sum[node] += prep(*it, node);
return sum[node];
}
int find(int node, int root, int S) {
for (__typeof(v[node].begin()) it = v[node].begin(); it != v[node].end();
it++)
if (*it != root && !h[*it] && sum[*it] > S) return *it;
return node;
}
void dfs(int T, int node, int root, int l, int up, int down) {
a[++C] = make_pair(((X - up) * (long long)T % mod + mod) % mod, node);
b[C] = make_pair(down, node);
for (__typeof(v[node].begin()) it = v[node].begin(); it != v[node].end();
it++)
if (*it != root && !h[*it])
dfs(((long long)T * ::T) % mod, *it, node, l + 1,
((long long)up * k + val[*it]) % mod,
(down + (long long)val[*it] * P[l + 1] % mod) % mod);
}
void calculate(int l, int r, int mul) {
sort(a + l, a + r + 1);
sort(b + l, b + r + 1);
for (int i = l; i <= r; i++) {
out[a[i].second][1] +=
mul * (upper_bound(b + l, b + r + 1, make_pair(a[i].first, inf)) -
lower_bound(b + l, b + r + 1, make_pair(a[i].first, 0)));
in[b[i].second][1] +=
mul * (upper_bound(a + l, a + r + 1, make_pair(b[i].first, inf)) -
lower_bound(a + l, a + r + 1, make_pair(b[i].first, 0)));
}
}
void solve(int node) {
prep(node, 0);
S = 0;
int center = ::center = find(node, 0, sum[node] / 2);
C = 0;
h[center] = 1;
a[++C] = make_pair(X, center);
b[C] = make_pair(val[center] % mod, center);
for (__typeof(v[center].begin()) it = v[center].begin();
it != v[center].end(); it++)
if (!h[*it]) {
int last = C;
dfs(T, *it, center, 1, val[*it],
((long long)k * val[*it] + val[center]) % mod);
calculate(last + 1, C, -1);
}
calculate(1, C, 1);
for (__typeof(v[center].begin()) it = v[center].begin();
it != v[center].end(); it++)
if (!h[*it]) solve(*it);
}
int main() {
scanf("%d %d %d %d", &n, &mod, &k, &X);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
for (int i = 2; i <= n; i++) {
scanf("%d %d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
P[0] = 1;
for (int i = 1; i <= n; i++) P[i] = (long long)k * P[i - 1] % mod;
T = FE(k, mod - 2);
solve(1);
long long ans = 0;
int all = 0;
for (int i = 1; i <= n; i++) {
all += in[i][1];
all -= out[i][1];
out[i][0] = n - out[i][1];
in[i][0] = n - in[i][1];
ans += 2LL * out[i][0] * out[i][1] + (long long)in[i][0] * out[i][1] +
(long long)in[i][1] * out[i][0] + 2LL * in[i][0] * in[i][1];
}
assert(!all);
cout << (long long)n * n * n - ans / 2 << '\n';
}
| 11 | CPP |
x = int(input())
ans = 0
while x:
if x % 2 == 1: ans += 1
x //= 2
print(ans)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, j, k, l, r, x, y, z, q, t;
cin >> q;
while (q--) {
cin >> n >> k;
long long a[n + 5];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
reverse(a, a + n);
x = a[0];
for (i = 1; i < n; i++) {
if (k) {
x += a[i];
k--;
} else {
break;
}
}
cout << x << endl;
}
}
| 8 | CPP |
n = int(input())
s = set()
l = map(int, input().split()[1:] + input().split()[1:])
for i in l:
s.add(i)
i = 1
while i <= n:
if i not in s:
print("Oh, my keyboard!")
break
i += 1
else:
print("I become the guy.")
| 7 | PYTHON3 |
from sys import stdin
mx = 10 ** 5 + 1
# main starts
t, k = list(map(int, stdin.readline().split()))
dp = [1] * mx
dp[0] = 0
dp[k] = 2
for i in range(k + 1, mx):
dp[i] = (dp[i - 1] + dp[i - k]) % (10 ** 9 + 7)
cum = [0] * mx
for i in range(1, mx):
cum[i] = (cum[i - 1] + dp[i]) % (10 ** 9 + 7)
#print(dp[1:10])
for _ in range(t):
a, b = list(map(int, stdin.readline().split()))
print((cum[b] - cum[a - 1]) % (10 ** 9 + 7)) | 10 | PYTHON3 |
#include<bits/stdc++.h>
#define fo(i, x, y) for(int i = x, B = y; i <= B; i ++)
#define ff(i, x, y) for(int i = x, B = y; i < B; i ++)
#define fd(i, x, y) for(int i = x, B = y; i >= B; i --)
#define ll long long
#define pp printf
#define hh pp("\n")
using namespace std;
const int mo = 1e9 + 7;
ll ksm(ll x, ll y) {
ll s = 1;
for(; y; y /= 2, x = x
* x % mo)
if(y & 1) s = s * x % mo;
return s;
}
const ll ni2 = ksm(2, mo - 2);
const int N = 2e5 + 5;
int n, a[N], d[N];
int cnt[N];
ll b[N], c[N];
int cmp(int x, int y) {
return a[x] < a[y];
}
ll w[N];
ll sum, ans;
void dg(int x, int y, int u, int v) {
if(u >= v) return;
if(x == y) {
ans = (ans + sum * (v - u + 1) % mo * (v - u) % mo * ni2 % mo * ni2) % mo;
sort(d + u, d + v + 1);
return;
}
int mi = x + y >> 1, m = u - 1;
while(m < v && a[d[m + 1]] <= mi) m ++;
dg(x, mi, u, m); dg(mi + 1, y, m + 1, v);
w[mi] = 1;
fd(i, mi - 1, x) w[i] = w[i + 1] * c[i + 1] % mo;
w[mi + 1] = c[mi + 1];
fo(i, mi + 2, y) w[i] = w[i - 1] * c[i] % mo;
int l = u; ll s = 0;
fo(i, m + 1, v) {
while(l <= m && d[l] <= d[i]) s = (s + w[a[d[l]]]) % mo, l ++;
ans = (ans + sum * s % mo * w[a[d[i]]] % mo * ni2) % mo;
}
l = m, s = 0;
fd(i, v, m + 1) {
while(l >= u && d[l] > d[i]) s = (s + w[a[d[l]]]) % mo, l --;
ans = (ans + sum * (m - l) - sum * s % mo * w[a[d[i]]] % mo * ni2) % mo;
}
sort(d + u, d + v + 1);
}
int main() {
scanf("%d", &n);
fo(i, 1, n) {
scanf("%d", &a[i]);
if(a[i] > n) a[i] = n;
cnt[a[i]] ++;
}
fd(i, n, 1) cnt[i] += cnt[i + 1];
sum = 1;
fo(i, 1, n) {
b[i] = cnt[i] - n + i;
sum = sum * max(0ll, b[i]) % mo;
}
fo(i, 1, n) {
c[i] = ksm(b[i], mo - 2) * (b[i] - 1) % mo;
}
fo(i, 1, n) d[i] = i;
sort(d + 1, d + n + 1, cmp);
dg(1, n, 1, n);
ans = (ans % mo + mo) % mo;
pp("%lld\n", ans);
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int m, j = 0, x, c = 0;
cin >> m;
vector<int> a(m, 0);
while (m > 0) {
x = m % 10;
if (x != 0) {
a[j] = x * pow(10, c);
j++;
}
m = m / 10;
c++;
}
cout << j << "\n";
for (int i = 0; i < j; i++) cout << a[i] << " ";
cout << "\n";
a.clear();
}
return 0;
}
| 7 | CPP |
arr = ['1','2','3','4','5','6','7','8','9','0','.']
a = list(input())
s = []
x = ""
for i in a:
if not (i in arr):
if x != "":
y = int("".join(x.split(".")))
if len(x) < 3:
y*=100
elif x[-3] != '.':
y*=100
s.append(y)
x = ""
else:
x += i
if x != "":
y = int("".join(x.split(".")))
if len(x) < 3:
y*=100
elif x[-3] != '.':
y*=100
s.append(y)
x = ""
ans = 0
for i in s:
# print(i)
ans+=i
ans = str(ans)
res = []
p = ""
for i in range(len(ans)-1, -1, -1):
p += ans[i]
#print(p)
if len(p) < 3:
if len(p) < 2:
print("0.0" + str(p))
else:
print("0." + p[1] + p[0])
else:
res = []
if (p[0] != "0" or p[1] != "0"):
res.append(p[0])
res.append(p[1])
res.append(".")
x = 0
for i in range(2, len(p)):
x+=1
res.append(p[i])
if not (i == len(p)-1) and x % 3 == 0:
res.append(".")
#print("".join(res))
res = "".join(res)
ans = ""
for i in range(len(res)):
ans += res[-i-1]
print(ans) | 8 | PYTHON3 |
a, b, M = map(int,input().split())
A = list(map(int,input().split()))
B = list(map(int,input().split()))
ans = min(A)+min(B)
for _ in range(M):
x, y, c = map(int, input().split())
ans = min(ans, A[x-1]+B[y-1]-c)
print(ans) | 0 | PYTHON3 |
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int N,count=0;
//読み込み
cin >> N;
int A[N];
for(int i=0;i<N;i++)
cin >> A[i];
//整列
for(int i=0;i<N;i++)
for(int j=N-1;j>i;j--)
if(A[j]<A[j-1]){
swap(A[j],A[j-1]);
count++;
}
//出力
for(int i=0;i<N;i++){
if(i>0) cout<<" ";
cout<< A[i];
}
cout<< endl << count << endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2205;
void upd(pair<long long, int> &a, pair<long long, int> b) {
if (a.first > b.first || (a.first == b.first && a.second < b.second)) a = b;
}
int n, k;
long long a[N], b[N];
pair<long long, int> dp[N][N];
const pair<long long, int> neutr = {(long long)2e18 + 7, 0};
pair<long long, int> get(long long lambda) {
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= n; ++j) dp[i][j] = neutr;
}
dp[0][0] = {0, 0};
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= n; ++j) {
if (dp[i][j] != neutr) {
if (j < n)
upd(dp[i + 1][j + 1], {dp[i][j].first + a[i], dp[i][j].second});
if (j > 0)
upd(dp[i + 1][j - 1],
{dp[i][j].first + b[i] + lambda, dp[i][j].second + 1});
upd(dp[i + 1][j],
{dp[i][j].first + a[i] + b[i] + lambda, dp[i][j].second + 1});
upd(dp[i + 1][j], dp[i][j]);
}
}
}
auto ans = neutr;
for (int i = 0; i <= n; ++i) upd(ans, dp[n][i]);
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
long long l = -1e13, r = 1e13;
while (r - l > 1) {
long long mid = (l + r) / 2;
auto have = get(mid);
if (have.second >= k)
l = mid;
else
r = mid;
}
auto ans = get(l);
cout << ans.first - l * ans.second;
return 0;
}
| 21 | CPP |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import time
(n, d) = (int(i) for i in input().split())
ms = {}
for i in range(n):
(m, s) = (int(i) for i in input().split())
if m in ms.keys():
ms[m] += s
else:
ms[m] = s
start = time.time()
l = sorted(ms.keys())
ans = 0
j = 0
while ((j < len(l)) and (l[j] - l[0] < d)):
ans += ms[l[j]]
j += 1
i = 0
now = ans
while j < len(l):
now = now - ms[l[i]]
i += 1
while ((j < len(l)) and (l[j] - l[i] < d)):
now += ms[l[j]]
j += 1
if now > ans:
ans = now
print(ans)
finish = time.time()
#print(finish - start)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const int mod = 1e9 + 7;
bool vis[26];
char s[55];
int main() {
int n;
scanf("%d%s", &n, s);
for (int i = 0; i < n; i++)
if (s[i] != '*') {
vis[s[i] - 'a'] = 1;
}
int m;
scanf("%d", &m);
int ans = (1 << 26) - 1;
for (int i = 0; i < m; i++) {
char t[55];
scanf("%s", t);
int now = 0;
bool ok = 1;
for (int j = 0; j < n; j++) {
if (vis[t[j] - 'a']) {
if (t[j] != s[j]) ok = 0;
} else {
if (s[j] != '*') ok = 0;
now |= (1 << (t[j] - 'a'));
}
}
if (ok) ans &= now;
}
int cnt = 0;
for (int i = 0; i < 26; i++)
if (ans & (1 << i)) cnt++;
printf("%d\n", cnt);
return 0;
}
| 11 | CPP |
#include <iostream>
#include <algorithm>
using namespace std;
const int Z = 63;
int N, A[Z+1][200200];
long long K;
int main()
{
cin.tie(NULL);ios_base::sync_with_stdio(false);
cin >> N >> K;
for (int i = 1; i <= N; i++) cin >> A[0][i];
for (int j = 1; j <= Z; j++) for (int i = 1; i <= N; i++) A[j][i] = A[j - 1][A[j - 1][i]];
int x = 1;
for (int j = 0; K; j++, K /= 2){
if (K & 1) x = A[j][x];
}
cout << x << endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using ld = double;
using namespace std;
const double eps = (1e-12);
const int INF = 2e9 + 9;
const int logn = 21;
const int lyh = 1e9 + 7;
const double pi = acos(-1.0);
char s[700005];
int nums[700005];
int n;
int pre[700005];
signed main() {
scanf("%d", &n);
scanf("%s", s);
for (int i = 0; i < n; i++) {
int p = i + 1;
if (s[i] == '(') {
nums[p] = nums[p + n] = 1;
} else {
nums[p] = nums[p + n] = -1;
}
}
for (int i = 1; i <= 2 * n; i++) {
pre[i] = pre[i - 1] + nums[i];
}
if (pre[n]) {
printf("0\n1 1");
return 0;
}
int beg = min_element(pre + 1, pre + 1 + n) - pre;
int minv = pre[beg];
for (int i = 1; i <= 2 * n; i++) {
pre[i] -= minv;
}
int cl = -1, cc = 0;
int mx = 0, ansl = 1, ansr = 1;
int cl2 = 0, cc2 = 0;
int mx2 = 0, ans2l = 1, ans2r = 1;
for (int i = 1; i <= n; i++) {
if (pre[i + beg] == 1) {
if (cc > mx) {
mx = cc;
ansl = cl, ansr = i;
}
cl = i + 1;
cc = 0;
} else if (pre[i + beg] == 2)
++cc;
if (pre[i + beg] == 0) {
if (cc2 > mx2) {
mx2 = cc2;
ans2l = cl2 + 1, ans2r = i;
}
cl2 = i;
cc2 = 0;
} else if (pre[i + beg] == 1)
++cc2;
}
for (int i = 1; i <= n; i++) {
if (pre[i + beg] == 0) ++mx;
}
if (mx2 > mx) {
mx = mx2;
ansl = ans2l;
ansr = ans2r;
}
printf("%d\n", mx);
ansl = (ansl + beg - 1 + n) % n + 1;
ansr = (ansr + beg - 1 + n) % n + 1;
printf("%d %d", ansl, ansr);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> primes;
using ll = long long int;
using dl = double;
ll aarray[100000 + 10];
char magic[1][100000];
const int N = 2e5 + 10;
int main() {
ios_base::sync_with_stdio(false);
string ptr = "AHIMOTUVWXY", str, ktr;
ll m1, m2, m3, m4, i, j, x = INT_MIN, b, p, y, n, k, m5, m, ta, t, flag = 0,
sum = 0;
ll w1, w2, w3, w4, w5;
ll ar[100000 + 10];
vector<pair<ll, ll>> dvi;
ll d, month, cnt = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> w1 >> w2;
dvi.push_back(make_pair(w1, w2));
}
sort(dvi.begin(), dvi.end());
for (auto it = dvi.begin(); it != dvi.end(); it++) {
for (auto jt = it + 1; jt != dvi.end(); jt++) {
if (it->second + it->first == jt->first &&
(it->first == jt->first + jt->second)) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
}
| 7 | CPP |
#include <cstdio>
#include <cstring>
#include <algorithm>
#define P 1000000007ll
#define int long long
using namespace std;
typedef long long ll;
int n, A[100010], Fac[100010], S[100010];
ll powmod(ll x, ll y = P - 2, ll p = P) {
ll ans = 1;
while(y) {
if(y & 1) ans = ans * x % p;
x = x * x % p;
y >>= 1;
}
return ans;
}
signed main() {
scanf("%lld", &n);
Fac[0] = 1;
for(int i = 1; i <= n; i++) Fac[i] = Fac[i - 1] * i % P;
for(int i = 1; i <= n; i++) S[i] = (S[i - 1] + powmod(i)) % P;
int ans = 0;
for(int i = 1; i <= n; i++) {
int x;
scanf("%lld", &x);
ans = (ans + x * (S[i] - S[0] + S[n - i + 1] - S[1])) % P;
}
printf("%lld\n", (ans * Fac[n] % P + P) % P);
return 0;
} | 0 | CPP |
for i in range(int(input())):
a=int(input())
l=list(map(int,input().split()))
m=l.count(1)
if m>int(a/2):
i=0
while i<len(l):
if not l[i]:
l.pop(i)
i-=1
i+=1
if m%2==1:
l.remove(1)
else:
i=0
while i<len(l):
if l[i]:
l.pop(i)
i-=1
i+=1
print(len(l))
for i in range(len(l)-1):
print(l[i],end=' ')
print(l[len(l)-1])
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v;
void fn(long long int n) {
if (n > 1e9) return;
v.push_back(n);
if ((n * 10) + 4 <= 1e9) fn((n * 10) + 4);
if ((n * 10) + 7 <= 1e9) fn((n * 10) + 7);
}
int main() {
long long int l, r;
fn(4);
fn(7);
v.push_back(4444444444);
sort(v.begin(), v.end());
cin >> l >> r;
long long int lower = upper_bound(v.begin(), v.end(), l) - v.begin();
long long int upper = upper_bound(v.begin(), v.end(), r) - v.begin();
if (find(v.begin(), v.end(), l) != v.end()) lower--;
if (find(v.begin(), v.end(), r) != v.end()) upper--;
if (abs(upper - lower) == 0) {
long long int dif = (r - l) + 1;
cout << dif * v[lower] << endl;
return 0;
}
long long int ans = 0;
long long int raka = (v[lower] - l) + 1;
if (raka > 0) ans += (v[lower] * raka);
long long int com = v[lower];
for (long long int i = lower + 1; i <= upper; i++) {
raka = (v[i] - com);
if (i == upper) raka = min(raka, r - com);
if (raka > 0) ans += (v[i] * raka);
com = v[i];
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N; cin >> N;
vector<int> A(N+1);
for (int i = 0; i < N+1; i++) cin >> A.at(i);
vector<long long> M(N+1), m(N+1);
M.at(N) = m.at(N) = A.at(N);
for (int i = N-1; i >= 0; i--) {
M.at(i) = M.at(i+1) + A.at(i);
m.at(i) = (m.at(i+1) + 1) / 2 + A.at(i);
}
if (m.at(0) > 1) { cout << -1 << endl; return 0; }
long long ans = 0, tmp = 1;
for (int i = 0; i <= N; i++) {
ans += tmp;
tmp = (tmp - A.at(i)) * 2;
if (i != N && tmp > M.at(i+1)) tmp = M.at(i+1);
}
cout << ans << endl;
} | 0 | CPP |
a = input()
q1, q2, q3, q4 = int(a[0]), int(a[1]), int(a[3]), int(a[4])
b = input()
w1, w2, w3, w4 = int(b[0]), int(b[1]), int(b[3]), int(b[4])
ww = (q3*10 + q4) + (q1*10 + q2)*60
qq = (w3*10 + w4) + (w1*10 + w2)*60
s = ""
if ww == qq:
print("00:00")
elif (ww - qq) > 0:
if(ww - qq) // 60 > 9:
d = str((ww - qq)//60)
s += d
else:
s += "0"
d = str((ww - qq)//60)
s += d
s += ":"
if (ww - qq) % 60 > 9:
d = str((ww - qq)%60)
s += d
else:
s += "0"
d = str((ww - qq)%60)
s += d
print(s)
else:
if(ww - qq + 1440) // 60 > 9:
d = str((ww - qq+ 1440)//60)
s += d
else:
s += "0"
d = str((ww - qq+ 1440)//60)
s += d
s += ":"
if (ww - qq + 1440) % 60 > 9:
d = str((ww - qq + 1440)%60)
s += d
else:
s += "0"
d = str((ww - qq + 1440)%60)
s += d
print(s)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
unordered_map<int, int> h, v;
map<pair<int, int>, int> p;
int x, y;
for (int ctr1 = 0; ctr1 < n; ctr1++) {
cin >> x >> y;
h[x]++;
v[y]++;
p[make_pair(x, y)]++;
}
long long rez = 0;
for (pair<const int, int> &t : h) {
long long k = t.second;
rez += (k * (k - 1)) / 2;
}
for (pair<const int, int> &t : v) {
long long k = t.second;
rez += (k * (k - 1)) / 2;
}
for (pair<const pair<int, int>, int> t : p) {
long long k = t.second;
rez -= (k * (k - 1)) / 2;
}
cout << rez << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int na, nb;
int k, m;
const int maxn = 1e5 + 10;
int a[maxn], b[maxn];
int main(int argc, const char* argv[]) {
cin >> na >> nb;
cin >> k >> m;
for (int i = 1; i <= na; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= nb; i++) {
scanf("%d", &b[i]);
}
if (a[k] < b[nb + 1 - m])
puts("YES");
else
puts("NO");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int BIT = (1 << 17), M = 110, N = 25;
int n, m, cnt[BIT], a[M];
long long f[BIT][N], b[N], p[N], year;
void solve(int x) {
memset(f, 0, sizeof(f));
f[0][0] = 1;
int maxb = (1 << n);
for (int i = 0; i < maxb; i++) {
for (int j = 0; j <= n; j++) {
int y = cnt[i] + 1;
if (b[y]) {
if ((a[b[y]] & i) != a[b[y]]) continue;
if ((1 << (b[y] - 1) & i) == (1 << b[y] - 1)) continue;
f[i | (1 << b[y] - 1)][j | ((b[y] == x) * y)] += f[i][j];
} else {
for (int k = 1; k <= n; k++) {
if (!(i & (1 << k - 1))) {
if ((a[k] & i) != a[k]) continue;
f[i | (1 << k - 1)][j | ((k == x) * y)] += f[i][j];
}
}
}
}
}
}
int main() {
scanf("%d%lld%d", &n, &year, &m);
year -= 2000;
for (int i = 1; i < BIT; i++) cnt[i] = cnt[i ^ (i & (-i))] + 1;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[y] |= (1 << x - 1);
}
for (int i = 1; i <= n; i++) {
solve(i);
long long sum = 0;
for (int j = 1; j <= n; j++) {
if (!b[j] && sum + f[(1 << n) - 1][j] >= year) {
b[j] = i;
p[i] = j;
year -= sum;
break;
}
sum += f[(1 << n) - 1][j];
}
if (!p[i]) {
puts("The times have changed");
return 0;
}
}
for (int i = 1; i <= n; i++) printf("%d ", p[i]);
puts("");
return 0;
}
| 9 | CPP |
n, S = [int(i) for i in input().split(' ')]
a = [int(i) for i in input().split(' ')]
l, r = 1, n
ans_k, ans_cost = 0, 0
while l <= r:
k = int((l + r) / 2)
cost = [a[i] + (i+1) * k for i in range(n)]
cost = sorted(cost)
cost_sum = sum(cost[:k])
if cost_sum <= S:
ans_k = k
ans_cost = cost_sum
l = k + 1
else:
r = k - 1
print('{} {}'.format(ans_k, ans_cost)) | 9 | PYTHON3 |
n = int(input())
a = [[] for _ in range(n)]
for i in range(n):
num = int(input())
for j in range(num):
person, state = map(int, input().split())
a[i].append([person-1, state])
honest = 0
for i in range(1, 2**n):
flag = True
for j in range(n):
if (i>>j)&1 == 1:
for x, y in a[j]:
if (i>>x)&1 != y:
flag = False
break
if flag:
honest = max(honest, bin(i)[2:].count('1'))
print(honest) | 0 | PYTHON3 |
#include <bits/stdc++.h>
inline long long MAX2(long long a, long long int b) {
return (a) > (b) ? (a) : (b);
}
inline long long MAX3(long long a, long long b, long long c) {
return (a) > (b) ? ((a) > (c) ? (a) : (c)) : ((b) > (c) ? (b) : (c));
}
inline long long MIN2(long long a, long long b) {
return (a) < (b) ? (a) : (b);
}
inline long long MIN3(long long a, long long b, long long c) {
return (a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c));
}
using namespace std;
int main() {
int i, n, t, a[105];
cin >> n >> t;
for (i = 0; i < n; i++) {
cin >> a[i];
a[i] = 86400 - a[i];
}
for (i = 0; i < n; i++) {
t -= a[i];
if (t <= 0) {
cout << i + 1;
break;
}
}
}
| 7 | CPP |
#include <iostream>
using namespace std;
int main()
{
int A,B;
cin >> A >> B;
if(B%A == 0)
cout << B+A;
else
cout << B - A;
}
| 0 | CPP |
"""do not use with graph questions"""
from sys import stdin
for _ in range(int(stdin.readline())):
a,b = map(int,stdin.readline().split())
j= max(min(a//2,b),min(a,b//2))
if b//2<a and a//2<b:
x = (2*a-b)//3+(2*b-a)//3
if (2*a-b)%3==2 and (2*a-b)%3>=1 or (2*a-b)%3>=1 and (2*a-b)%3==2:
x+=1
j = max(j,x)
print(j) | 7 | PYTHON3 |
n = int(input())
day = 24 * 60
v = []
for i in range(n) :
s = input()
h = int(s[0]) * 10 + int(s[1])
m = int(s[3]) * 10 + int(s[4])
tim = h * 60 + m
v.append(int(tim))
v.append(int(tim + day))
v.append(int(tim + day + day))
v.sort()
ans = 0
for i in range (len(v)) :
if i > 0:
ans = max(ans, v[i] - v[i - 1] - 1)
m = ans % 60
h = ans // 60
print(str(h // 10) + str(h % 10) + ':' + str(m // 10) + str(m % 10)) | 15 | PYTHON3 |
for _ in range(int(input())):
n, x = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.sort()
cnt = 0
gp = 0
for i in range(n - 1, -1, -1):
gp += 1
if arr[i] * gp >= x:
cnt += 1
gp = 0
print(cnt)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, res = 0;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
if (v[i] == 0) res++;
}
for (long long i = 0; i < n; i++) {
if (v[i] == 0)
res--;
else
break;
}
for (long long i = n - 1; i > -1; i--) {
if (v[i] == 0)
res--;
else
break;
}
cout << res << endl;
}
return 0;
}
| 8 | CPP |
#include <cstdio>
#include <utility>
#include <vector>
#include <complex>
#include <cmath>
#include <algorithm>
#include <set>
using namespace std;
static const double EPS=1e-12;
static const double INF=1e24;
using Point=complex<double>;
using Plane=vector<Point>;
using Polygon=vector<Point>;
namespace std {
bool operator<(const Point &a, const Point &b) {
return real(a)!=real(b)? real(a)<real(b) : imag(a)<imag(b);
}
}
double cross_prod(const Point &a, const Point &b) {
return imag(conj(a)*b);
}
double dot_prod(const Point &a, const Point &b) {
return real(conj(a)*b);
}
struct Line: public pair<Point, Point> {
Line() {}
Line(const Point &a, const Point &b) {
first = a;
second = b;
}
};
struct Circle {
Point p;
double r;
Circle() {}
Circle(const Point &p, const double r): p(p), r(r) {}
};
pair<Point, Point> get_tangents(const Circle &c, const Point &p) {
Point v=c.p-p;
double w=sqrt(norm(v)-c.r*c.r);
Point p1=p+w*Point(w, c.r)*v/norm(v);
Point p2=p+w*Point(w, -c.r)*v/norm(v);
if (p2 < p1)
swap(p1, p2);
return make_pair(p1, p2);
}
int main() {
double x, y, r;
scanf("%lf %lf", &x, &y);
Point p(x, y);
scanf("%lf %lf %lf", &x, &y, &r);
Circle c(Point(x, y), r);
pair<Point, Point> tangents=get_tangents(c, p);
printf("%.9f %.9f\n", real(tangents.first), imag(tangents.first));
printf("%.9f %.9f\n", real(tangents.second), imag(tangents.second));
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
void Mo35() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
Mo35();
int a, b;
int n, x;
cin >> n >> x;
while (cin >> a >> b)
if (a == x || b == x || a == 7 - x || b == 7 - x) return cout << "NO", 0;
cout << "YES";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3000;
const int inf = 0x3f3f3f3f;
inline long long read() {
long long res = 0, sgn = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
res = res * 10 + c - '0';
c = getchar();
}
return res * sgn;
}
int main() {
int cases;
cin >> cases;
while (cases--) {
long long a = read(), b = read(), c = read(), n = read();
if ((n + a + b + c) % 3 == 0) {
long long ans = (n + a + b + c) / 3;
if (ans >= a && ans >= b && ans >= c)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else
cout << "NO" << endl;
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long c[2005], t[2005], dp[2005][4005], n;
void input() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> t[i] >> c[i];
}
long long solve(long long i, long long tmp) {
if (i < 1) {
if (tmp >= 0) return 0;
return 4444444444444444444;
}
if (tmp >= i) return 0;
if (~dp[i][tmp + 2005]) return dp[i][tmp + 2005];
return dp[i][tmp + 2005] =
min(c[i] + solve(i - 1, tmp + t[i]), solve(i - 1, tmp - 1));
}
void output() { cout << solve(n, 0); }
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(dp, -1, sizeof dp);
input();
output();
}
| 8 | CPP |
for i in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
m=0
e=0
b=set(a)
if sum(a)%2==1:
print('YES')
continue
for i in b:
if i%2==0:
e+=1
else:
m+=1
if (m>0 and e>0 ):
print('YES')
break
if m<1 or e<1:
print('NO')
| 7 | PYTHON3 |
def solve(n,a):
e = 0
o = 0
for x in a:
if x%2 == 0:
e += 1
else:
o +=1
if e and o:
return "NO"
else:
return "YES"
t = int(input())
while t:
n = int(input())
a = list(map(int,input().split()))
print(solve(n,a))
t-=1 | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec;
int main() {
int n;
cin >> n;
int A = 0, B = 0;
for (int i = 0; i < n; i++) {
int s;
cin >> s;
for (int j = 0; j < s / 2; j++) {
int x;
cin >> x;
A += x;
}
if (s % 2) {
int x;
cin >> x;
vec.push_back(x);
}
for (int j = 0; j < s / 2; j++) {
int x;
cin >> x;
B += x;
}
}
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
for (int i = 0; i < vec.size(); i++) {
if (i % 2)
B += vec[i];
else
A += vec[i];
}
cout << A << ' ' << B << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, t;
struct data {
int x, y;
} w[7];
long long a, b, c, x, y;
long long min(long long a, long long b) { return a > b ? b : a; }
int main() {
scanf("%lld", &a);
if (a == 0) {
printf("0 0\n");
return 0;
}
w[1] = {-2, 0};
w[2] = {-1, -2};
w[3] = {+1, -2};
w[4] = {+2, 0};
w[5] = {+1, +2};
w[6] = {-1, +2};
b = 1, c = 0;
long long l = 1, r = 1000000000;
while (l <= r) {
long long mid = l + r >> 1;
if (1 + (1 + mid) * mid * 3ll + mid < a)
b = 1 + (1 + mid) * mid * 3ll + mid, c = mid, l = mid + 1;
else
r = mid - 1;
}
c++;
a -= b;
x = c;
y = c * 2;
if (!a) {
printf("%lld %lld\n", x, y);
return 0;
}
x += min(c, a) * w[1].x;
y += min(c, a) * w[1].y;
if (a <= c) {
printf("%lld %lld\n", x, y);
return 0;
}
a -= c;
x += min(c, a) * w[2].x;
y += min(c, a) * w[2].y;
if (a <= c) {
printf("%lld %lld\n", x, y);
return 0;
}
a -= c;
x += min(c, a) * w[3].x;
y += min(c, a) * w[3].y;
if (a <= c) {
printf("%lld %lld\n", x, y);
return 0;
}
a -= c;
x += min(c, a) * w[4].x;
y += min(c, a) * w[4].y;
if (a <= c) {
printf("%lld %lld\n", x, y);
return 0;
}
a -= c;
x += min(c, a) * w[5].x;
y += min(c, a) * w[5].y;
if (a <= c) {
printf("%lld %lld\n", x, y);
return 0;
}
a -= c;
x += w[5].x;
y += w[5].y;
if (a <= 1) {
printf("%lld %lld\n", x, y);
return 0;
}
a -= 1;
x += min(c, a) * w[6].x;
y += min(c, a) * w[6].y;
if (a <= c) {
printf("%lld %lld\n", x, y);
return 0;
}
a -= c;
return 0;
}
| 11 | CPP |
def value_dif(a_string, b_string, size_a, size_b):
count = [0,0]
check = 0
for i in range(size_b):
check ^= int(a_string[i]) ^ int(b_string[i])
count[check] = 1
for i in range(0, size_a-size_b):
check ^= int(a_string[i]) ^int(a_string[i+size_b])
count[check] += 1
return count[0]
def main():
a = input()
b = input()
a_len = len(a)
b_len = len(b)
even = value_dif(a,b,a_len, b_len)
print(even)
main()
| 9 | PYTHON3 |
#include <iostream>
using namespace std;
int n[3]; // 0: Math+DP, 1: Greedy+Graph 2: Geometry+Other
bool all(int p, int* n, int size) {
for (int i = 0; i < size; i++) if (n[i] != p) return false;
return true;
}
int main() {
int _n[6];
while (cin >> _n[0] >> _n[1] >> _n[2] >> _n[3] >> _n[4] >> _n[5]) {
if (all(0, _n, 6)) break;
n[0] = _n[0] + _n[3];
n[1] = _n[1] + _n[4];
n[2] = _n[2] + _n[5];
int lim = 2;
for (int i = 0; i < 3; i++)
lim = min(lim, n[i]);
int max_count = 0;
for (int i = 0; i <= lim; i++) {
int _count = i;
_count += (n[0]-i) / 3;
_count += (n[1]-i) / 3;
_count += (n[2]-i) / 3;
max_count = max(max_count, _count);
}
cout << max_count << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int x[] = {-1, 2, 1};
int main() {
int a[5][5];
for (int i = 0; i < 4; i++) {
bool done = 0;
for (int j = 0; j < 4; j++) {
cin >> a[i][j];
done |= j < 3 & a[i][j];
}
if (done && a[i][3]) {
cout << "YES";
return 0;
}
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 3; j++) {
if (!a[i][j]) continue;
int k = (i + x[j] + 4) % 4;
if (a[k][3]) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
const int inf = 1e9;
const int mo = 998244353;
int main() {
int t;
cin >> t;
while (t--) {
long long a, b, c, d;
scanf("%lld%lld%lld%lld", &a, &b, &c, &d);
if (a > b * c)
cout << "-1\n";
else {
long long k = a / (b * d) + 1;
long long ans = (a + a - (k - 1) * b * d) * (k) / 2;
cout << ans << endl;
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
string s;
cin >> n >> k;
cin >> s;
for (int i = 1; i < n && k > 0; i++) {
if (s[i - 1] == '4' && s[i] == '7') {
if (i % 2 != 0) {
if (i == n - 1 || s[i + 1] != '7')
s[i] = '4', k--;
else {
if (k % 2 != 0) s[i] = '4';
break;
}
} else {
if (i == 1 || s[i - 2] != '4')
s[i - 1] = '7', k--;
else {
if (k % 2 != 0) s[i - 1] = '7';
break;
}
}
}
}
cout << s << endl;
}
| 10 | CPP |
#include<bits/stdc++.h>
using namespace std;
signed main(){
int a,b,c;cin>>a>>b>>c;
cout<<(a-b+1)*(a-c+1)<<endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long u, long long v) {
long long r;
while (v) {
r = u % v;
u = v;
v = r;
}
return u;
}
long long modpow(long long a, long long p, long long mod) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
p /= 2;
}
return ret;
}
long long power(long long a, long long p) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * a);
a = (a * a);
p /= 2;
}
return ret;
}
int main() {
int i, j, tmp;
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long n;
cin >> n;
if (n % 2)
cout << "black\n";
else {
cout << "white\n";
cout << "1 2\n";
}
return 0;
}
| 10 | CPP |
S=input()
N=len(S)-1
ans=0
for i in range(2**N):
f=S[0]
for j in range(N):
f+="+"*((i>>j)&1)+S[j+1]
ans+=eval(f)
print(ans) | 0 | PYTHON3 |
n = input()
a = input()
total = 0
sum = 0
for i in a:
if int(i)%2 is 0:
sum = sum + total +1
total = total + 1
print(sum) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int l;
cin >> l;
char s1[l], s2[l];
cin >> s1;
cin >> s2;
int flag = 0;
int sam[l];
for (int i = 0; i < l; i++) {
if (s1[i] > s2[i]) {
flag = 1;
break;
}
sam[i] = 0;
if (s1[i] == s2[i]) {
sam[i] = 1;
}
}
if (flag) {
cout << "-1" << endl;
continue;
} else {
int cnt = 0;
for (char w = 'a' + 0; w < 'a' + 20; w++) {
char mc = 'z' + 1;
int tt = 0;
for (int i = 0; i < l; i++) {
if (s1[i] == w && sam[i] == 0) {
tt++;
if (s2[i] < mc) mc = s2[i];
}
}
if (tt != 0) {
cnt++;
for (int i = 0; i < l; i++) {
if (s1[i] == w && sam[i] == 0) {
s1[i] = mc;
if (s2[i] == s1[i]) sam[i] = 1;
}
}
}
}
cout << cnt << endl;
}
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dp[105][150005], tk[105], po2[25];
int arrbt[105][150005], vl[105][150005], p[105], pr[105];
vector<int> pri;
vector<int> kn[150005], cals, pv[150000];
map<int, int> mp;
void re(int cur, int val, int bm) {
if (val > 60) {
return;
}
if (mp[val] == 0) {
kn[bm].push_back(val);
}
mp[val] = 1;
re(cur, val * pri[cur], bm | po2[cur]);
if (cur + 1 < pri.size()) re(cur + 1, val, bm);
}
void ss(int bm, int lv) {
if (lv == pri.size()) {
return;
}
}
int main() {
po2[0] = 1;
for (int i = 1; i < 22; i++) {
po2[i] = po2[i - 1] * 2;
}
int t;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
scanf("%d", &p[i]);
}
for (int i = 2; i <= 60; i++) {
if (pr[i] == 0) {
for (int j = 2 * i; j <= 100; j += i) {
pr[j] = 1;
}
pri.push_back(i);
}
}
re(0, 1, 0);
for (int i = 0; i < 150005; i++) {
if (!kn[i].empty()) {
cals.push_back(i);
}
}
for (int i = 0; i < 105; i++) {
for (int j = 0; j < 150005; j++) dp[i][j] = 1e9;
}
dp[0][0] = 0;
for (int i = 0; i < t; i++) {
for (int j = 0; j < 150005; j++) {
if (dp[i][j] != 1e9) {
for (int k = 0; k < cals.size(); k++) {
if ((cals[k] & j) == 0) {
int pos = cals[k];
for (int l = 0; l < kn[pos].size(); l++) {
if (dp[i + 1][j | pos] > dp[i][j] + abs(kn[pos][l] - p[i])) {
dp[i + 1][j | pos] = dp[i][j] + abs(kn[pos][l] - p[i]);
arrbt[i + 1][j | pos] = j;
vl[i + 1][j | pos] = kn[pos][l];
}
}
}
}
}
}
}
int mn = 1e9, pos = -1;
int cc = t, cc2 = cc;
for (int i = 0; i < 150005; i++) {
if (mn > dp[cc2][i]) {
mn = dp[cc2][i];
pos = i;
}
}
while (cc > 0) {
tk[cc] = vl[cc][pos];
pos = arrbt[cc][pos];
cc--;
}
for (int i = 1; i <= cc2; i++) {
printf("%d ", tk[i]);
}
}
| 8 | CPP |
from collections import deque
def main():
n = int(input())
trees = [None for _ in range(n)]
for i in range(n):
tree = list(map(int, input().split()))
trees[tree[0]] = tree[2:]
# 根を探す
candidates = set()
have_parents = set()
children = []
for i in range(len(trees)):
if len(trees[i]):
candidates.add(i)
children.extend(trees[i])
children = set(children)
have_parents = {c for c in candidates if c in children}
if n == 1:
root_node = 0
else:
root_node = list(candidates - have_parents)[0]
depth = []
q = deque()
seen = [0]*n
depth = [0]*n
parents = [0]*n
q.append(root_node)
seen[root_node] = 1
parents[root_node] = -1
while len(q):
v = q.pop()
d = depth[v] + 1
for t in trees[v]:
if seen[t]:
continue
seen[t] += 1
parents[t] = v
q.append(t)
depth[t] = d
for i in range(n):
if not depth[i]:
print(
"node {}: parent = {}, depth = {}, root, {}"
.format(i, parents[i], depth[i], trees[i]))
elif depth and len(trees[i]):
print(
"node {}: parent = {}, depth = {}, internal node, {}"
.format(i, parents[i], depth[i], trees[i]))
else:
print(
"node {}: parent = {}, depth = {}, leaf, {}"
.format(i, parents[i], depth[i], trees[i]))
if __name__ == '__main__':
main()
| 0 | PYTHON3 |
t = int(input())
while t:
n = int(input())
arr = list(map(int, input().split()))
freq = [0 for i in range(101)]
for i in arr:
freq[i] += 1
b = c = -1
for i in range(101):
if freq[i] > 0:
freq[i] -= 1
else:
b = i
break
for i in range(106):
if freq[i] > 0:
freq[i] -= 1
else:
c = i
break
print(b+c)
t -= 1
| 7 | PYTHON3 |
#include <bits/stdc++.h>
const int inf = 1039074182;
const int mod = 1e9 + 7;
using namespace std;
int w[8];
struct Matrix {
vector<vector<int> > a;
int row;
int column;
bool initialized = false;
void error() {
cout << "Error occured in Matrix!!\n";
exit(0);
}
void init(int n, int m) {
initialized = true;
row = n;
column = m;
a.resize(n);
for (int i = 0; i < n; i++) {
a[i].resize(m);
}
clear();
}
void clear() {
if (!initialized) {
error();
}
for (int i = 0; i < row; i++) {
for (int j = 0; j < column; j++) {
a[i][j] = 0;
}
}
}
void E() {
clear();
if (row != column) {
error();
}
for (int i = 0; i < row; i++) {
a[i][i] = 1;
}
}
void print() {
if (!initialized) {
error();
}
cout << "Matrix: \n";
for (int i = 0; i < row; i++) {
for (int j = 0; j < column; j++) {
cout << a[i][j] << ' ';
}
cout << endl;
}
cout << endl;
}
};
Matrix operator*(Matrix a, Matrix b) {
int n = a.row;
int m = b.column;
if (a.column != b.row) {
a.error();
}
int l = a.column;
Matrix res;
res.init(n, m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < l; k++) {
res.a[i][j] += (1LL * a.a[i][k] * b.a[k][j]) % mod;
res.a[i][j] %= mod;
}
}
}
return res;
}
Matrix fastpow(Matrix basic, long long n) {
if (basic.row != basic.column) basic.error();
Matrix res;
res.init(basic.row, basic.row);
res.E();
while (n) {
if (n & 1) res = res * basic;
basic = basic * basic;
n >>= 1;
}
return res;
}
Matrix base[8];
inline bool valid(int l, int m, int r, int len) {
if (len == 1) {
return (l == 0 || r == 0);
}
for (int i = 0; i < len; i++) {
if (((1 << i) & l) == false) continue;
if (((1 << i) & r) == false) continue;
if (i && ((1 << (i - 1)) & m) == false) continue;
if (i != len - 1 && ((1 << i) & m) == false) continue;
return false;
}
return true;
}
void calc(int x) {
base[x].init((1 << x), (1 << x));
for (int left = 0; left < (1 << x); left++) {
for (int mid = 0; mid < (1 << (x - 1)); mid++) {
for (int right = 0; right < (1 << x); right++) {
if (!valid(left, mid, right, x)) continue;
base[x].a[left][right]++;
}
}
}
}
Matrix hyperdim(int x) {
Matrix res;
res.init((1 << (x + 1)), 1 << x);
for (int i = (1 << (x)); i < (1 << (x + 1)); i++) {
res.a[i][i - (1 << x)] = 1;
}
return res;
}
int main() {
for (int i = 1; i <= 7; i++) {
cin >> w[i];
}
for (int i = 1; i <= 7; i++) {
calc(i);
}
Matrix now;
now.init(2, 1);
now.a[1][0] = 1;
for (int i = 1; i <= 7; i++) {
now = fastpow(base[i], w[i]) * now;
now = hyperdim(i) * now;
}
cout << now.a[(1 << 8) - 1][0] << endl;
return 0;
}
| 11 | CPP |
Subsets and Splits