solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
---|---|---|
Case_num = 1
while True:
W = int(input())
if W == 0:
break
N = int(input())
List = [[0] * (W + 1)] * (N + 1) #????????? w??\????????°n??\?????§??????????????????????????§
for i in range(1,N + 1):
v,w = map(int,input().split(","))
for j in range(W,w - 1,-1):
List[i][j] = max(List[i - 1][j] ,List[i - 1][j - w] + v)
print("Case",Case_num,end = ":\n")
print(List[N][W])
print(List[N].index(List[N][W]))
Case_num += 1 | 0 | PYTHON3 |
p=input()
p=p.split(" ")
p=int(p[1])
s=input()
s=s.split(" ")
a=0
for i in s:
i=int(i)
if i >=int(s[p-1]):
if i>0:
a+=1
print(a)
| 7 | PYTHON3 |
def sum(a):
a = list(str(a))
a = list(map(int,a))
su = 0
for i in a:
su+=i
return str(su)
s = str(input())
res = 0
while(len(s)!=1):
res+=1
s = sum(s)
print (res) | 8 | PYTHON3 |
for _ in range(int(input())):
s=input()
print(sum(sorted(map(len,s.split('0')))[::-2])) | 8 | PYTHON3 |
def solve(n,m):
if n%2 == 0: #n is even
print(int(m*(n//2)))
return
else: #n is odd
if m%2 == 0:
print(int(((n-1)//2) * m + m//2))
return
else:
print(int(((n-1)//2) * m + (m-1)//2 + 1))
return
if __name__ == '__main__':
t = int(input())
for _ in range(t):
n,m = map(int, input().split())
solve(n,m) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int K = 10;
int n, k;
vector<int> g[N];
int maxp[N], siz[N], vis[N], rt;
void getRt(int u, int fa, int all) {
siz[u] = 1, maxp[u] = 0;
for (auto &v : g[u])
if (v != fa && !vis[v]) {
getRt(v, u, all);
siz[u] += siz[v];
maxp[u] = max(maxp[u], siz[v]);
}
maxp[u] = max(maxp[u], all - siz[u]);
if (maxp[u] < maxp[rt]) rt = u;
}
long long sum[K], cnt[K], tsum[K], tcnt[K], ans;
void dfs2(int u, int fa, int d) {
tsum[d % k] += (d + k - 1) / k, tcnt[d % k]++;
for (auto &v : g[u])
if (!vis[v] && v != fa) dfs2(v, u, d + 1);
}
void calc(int u) {
for (int i = 0; i < k; i++) sum[i] = 0, cnt[i] = 0;
cnt[0] = 1;
for (auto &v : g[u])
if (!vis[v]) {
for (int i = 0; i < k; i++) tsum[i] = 0, tcnt[i] = 0;
dfs2(v, u, 1);
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) {
ans += cnt[i] * (tsum[j] - (j > 0) * tcnt[j]) +
(sum[i] - (i > 0) * cnt[i]) * tcnt[j];
ans += (i + j + k - 1) / k * cnt[i] * tcnt[j];
}
for (int i = 0; i < k; i++) sum[i] += tsum[i], cnt[i] += tcnt[i];
}
}
void dfs(int u) {
vis[u] = 1;
calc(u);
for (auto &v : g[u])
if (!vis[v]) {
maxp[rt = 0] = N;
getRt(v, 0, siz[v]);
dfs(rt);
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
maxp[rt = 0] = N;
getRt(1, 0, N);
dfs(rt);
printf("%lld\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int banyak, putar, waktu;
int jarak[1000005], balik[1000005];
int main() {
scanf("%d %d %d", &banyak, &putar, &waktu);
for (int i = 0; i < banyak; ++i) {
scanf("%d", &jarak[i]);
balik[i] = jarak[i] + putar;
}
double jawab = 0.0;
double lap = (double)(waktu / putar);
waktu %= putar;
for (int i = 1; i < banyak; ++i) {
jawab += lap * (double)i;
if (jarak[i] - jarak[0] <= 2 * waktu)
jawab += (double)i / 4.0;
else if (jarak[i] - jarak[i - 1] > 2 * waktu)
jawab += 0.0;
else {
int kiri = 0;
int kanan = i - 1;
while (kanan - kiri > 1) {
int tengah = (kanan + kiri) / 2;
if (jarak[i] - jarak[tengah] > 2 * waktu)
kiri = tengah;
else
kanan = tengah;
}
jawab += (double)(i - kanan) / 4.0;
}
if (jarak[i] - jarak[0] + putar <= 2 * waktu)
jawab += (double)i / 4.0;
else if (jarak[i] - jarak[i - 1] + putar > 2 * waktu)
jawab += 0.0;
else {
int kiri = 0;
int kanan = i - 1;
while (kanan - kiri > 1) {
int tengah = (kanan + kiri) / 2;
if (jarak[i] - jarak[tengah] + putar > 2 * waktu)
kiri = tengah;
else
kanan = tengah;
}
jawab += (double)(i - kanan) / 4.0;
}
if (balik[i - 1] - jarak[i] <= 2 * waktu)
jawab += (double)i / 4.0;
else if (balik[0] - jarak[i] > 2 * waktu)
jawab += 0.0;
else {
int kiri = 0;
int kanan = i - 1;
while (kanan - kiri > 1) {
int tengah = (kanan + kiri) / 2;
if (balik[tengah] - jarak[i] <= 2 * waktu)
kiri = tengah;
else
kanan = tengah;
}
jawab += (double)(kiri + 1) / 4.0;
}
if (balik[i - 1] - jarak[i] + putar <= 2 * waktu)
jawab += (double)i / 4.0;
else if (balik[0] - jarak[i] + putar > 2 * waktu)
jawab += 0.0;
else {
int kiri = 0;
int kanan = i - 1;
while (kanan - kiri > 1) {
int tengah = (kanan + kiri) / 2;
if (balik[tengah] - jarak[i] + putar <= 2 * waktu)
kiri = tengah;
else
kanan = tengah;
}
jawab += (double)(kiri + 1) / 4.0;
}
}
printf("%.6lf\n", jawab);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool solve(long long a, long long b) {
if (a == 0 && b == 0) return true;
if (a == 1 && b == 2) return true;
if (a == 2 && b == 1) return true;
if (a == b && a % 3 == 0) return true;
if ((a != 0 && b != 0) && (2 * a == b || 2 * b == a)) return true;
long long dif = abs(a - b);
if (min(a, b) - dif < 3)
return false;
else {
if ((min(a, b) - dif) % 3 == 0)
return true;
else
return false;
}
}
int main() {
int t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
if (solve(a, b))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, Max, M, len, k;
class rec {
public:
int x, y, r, dp, num;
} p[5000];
int ll[5000], f[5000], g[5000], h[5000], n[5000], st[5000];
int ans[30000000];
int find(int x) {
int l = 1;
int r = M;
for (; l < r;) {
int mid = (l + r + 1) / 2;
if (ll[mid] > x)
r = mid - 1;
else
l = mid;
}
return l;
}
bool cmp(int a, int b) { return p[a].x < p[b].x; }
bool cmpr(rec a, rec b) { return a.r < b.r; }
bool cmpall(rec a, rec b) { return a.r < b.r || (a.r == b.r && a.x < b.x); }
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d %d", &p[i].x, &p[i].r), p[i].num = i;
p[++N].x = 0;
p[N].r = 2000000000;
p[N].num = N;
for (int i = 1; i <= N; i++) {
p[i].y = p[i].x + p[i].r;
p[i].x = p[i].x - p[i].r;
ll[++len] = p[i].x;
ll[++len] = p[i].y;
}
sort(ll + 1, ll + len + 1);
M = 1;
for (int i = 2; i <= len; i++)
if (ll[M] != ll[i]) ll[++M] = ll[i];
for (int i = 1; i <= N; i++) {
p[i].x = find(p[i].x);
p[i].y = find(p[i].y);
}
sort(p + 1, p + N + 1, cmpr);
for (int i = 1; i <= N; i++) n[i] = i;
sort(n + 1, n + N + 1, cmp);
len = 0;
for (int t = 1; t <= N; t++) {
memset(f, 0, sizeof(f));
int j = 1;
Max = 0;
k = 0;
for (int i = p[t].x; i <= p[t].y; i++) {
if (f[i] > Max) {
Max = f[i];
k = i;
}
if (j <= N)
for (; j <= N; j++) {
if (p[n[j]].x < p[t].x || p[n[j]].y > p[t].y) continue;
if (p[n[j]].x == p[t].x && p[n[j]].y == p[t].y) continue;
if (p[n[j]].x != i) break;
if (f[p[n[j]].y] < Max + p[n[j]].dp) {
f[p[n[j]].y] = Max + p[n[j]].dp;
g[p[n[j]].y] = k;
h[p[n[j]].y] = n[j];
}
}
}
p[t].dp = Max + 1;
st[t] = len;
ans[++len] = p[t].num;
for (; k;) {
for (int j = st[h[k]] + 1; j <= st[h[k] + 1]; j++) ans[++len] = ans[j];
k = g[k];
}
}
if (p[N].dp != len - st[N]) printf("= =\n");
printf("%d\n", len - st[N] - 1);
for (int j = st[N] + 2; j <= len; j++) printf("%d ", ans[j]);
return 0;
}
| 9 | CPP |
t = int(input())
p,n = 0,0
for i in range(t):
x,y = map(int,input().split())
if(x < 0): n += 1
else: p += 1
if(p <= 1 or n <= 1):
print("Yes")
else:
print("No")
| 7 | PYTHON3 |
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
#define pb push_back
#define IOS ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define mem(a) memset(a, 0, sizeof(a))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef double db;
typedef pair<int, int> P;
typedef __int128_t int128;
const int maxn = 1e3 + 10;
const ll mod = 1e9 + 7;
char a[maxn][maxn];
char b[maxn][maxn];
bitset<maxn> bit[maxn];
bitset<maxn> bit1;
int n;
int main()
{
IOS;
int t;
cin >> t;
bit1.set();
while (t--)
{
cin>>n;
for (int i = 1; i <= n;i++)
cin >> a[i] + 1;
for (int i = 1; i <= n;i++)
cin >> b[i] + 1;
for (int i = 1; i <= n;i++)
{
for (int j = 1; j <= n;j++)
{
bit[i][j] = (a[i][j] - '0') ^ (b[i][j] - '0');
}
}
for (int i = 1; i <= n;i++)
{
if(bit[i][1])
bit[i] ^= bit1;
}
bool f = 1;
for (int i = 1; i <= n;i++)
{
int tmp1 = bit[1][i];
for (int j = 1;j<=n;j++)
{
if(bit[j][i]!=tmp1)
f = 0;
if(!f)
break;
}
if(!f)
break;
}
cout << (f ? "YES" : "NO") << endl;
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[300005];
long long f[600005], Size[600005];
int Find(int first) {
if (f[first] == first) return first;
return f[first] = Find(f[first]);
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
char c[300005];
scanf("%s", c + 1);
for (int i = 0; i < k; i++) {
int first;
scanf("%d", &first);
while (first--) {
int second;
scanf("%d", &second);
v[second].push_back(i);
}
}
for (int i = 0; i < 2 * k; i++) {
f[i] = i;
if (i >= k)
Size[i] = 1;
else
Size[i] = 0;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (c[i] == '0') {
if (v[i].size() == 1) {
int first = Find(v[i][0]);
int second = Find(v[i][0] + k);
if (Size[first] < Size[second]) ans = ans - Size[first] + Size[second];
Size[first] += 1e9;
} else {
assert(v[i].size() == 2);
int a = Find(v[i][0]);
int aa = Find(v[i][0] + k);
int b = Find(v[i][1]);
int bb = Find(v[i][1] + k);
if (b != aa) {
ans -= min(Size[a], Size[aa]);
ans -= min(Size[b], Size[bb]);
f[b] = aa;
Size[aa] += Size[b];
f[a] = bb;
Size[bb] += Size[a];
ans += min(Size[aa], Size[bb]);
}
}
} else {
if (v[i].size() == 1) {
int first = Find(v[i][0] + k);
int second = Find(v[i][0]);
if (Size[first] < Size[second]) ans = ans - Size[first] + Size[second];
Size[first] += 1e9;
} else {
if (!v[i].empty()) {
assert(v[i].size() == 2);
int a = Find(v[i][0]);
int aa = Find(v[i][0] + k);
int b = Find(v[i][1] + k);
int bb = Find(v[i][1]);
if (b != aa) {
ans -= min(Size[a], Size[aa]);
ans -= min(Size[b], Size[bb]);
f[b] = aa;
Size[aa] += Size[b];
f[a] = bb;
Size[bb] += Size[a];
ans += min(Size[aa], Size[bb]);
}
}
}
}
printf("%d\n", ans);
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500050;
int A[MAXN];
int Ans, N;
bool Check(int m) {
int j;
for (int i = N - m; i < N; i++) {
j = i - (N - m);
if (A[i] < A[j] * 2) return false;
}
return true;
}
int BinarySearch(int l, int r) {
if (l == r) return l;
int m = (l + r + 1) >> 1;
if (Check(m))
return BinarySearch(m, r);
else
return BinarySearch(l, m - 1);
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) cin >> A[i];
sort(A, A + N);
Ans = BinarySearch(0, N - (N + 1) / 2);
cout << N - Ans << endl;
return 0;
}
| 9 | CPP |
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
cnt = a.count(0)
cnt += sum(a) + cnt == 0
print(cnt)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const long long linf = 1e18 + 7;
const long long hh = 523;
const int mod = 1073741824;
int n, m, q;
int w[17];
int sum[1 << 12];
int ans[1 << 12][107];
int h[1 << 12];
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < n; i++) {
scanf("%d", w + i);
}
for (int i = 0; i < (1 << n); i++) {
int t = 0;
for (int j = 0; j < n; j++) {
if (!(i & (1 << j))) {
t += w[n - j - 1];
}
}
h[i] = min(t, 101);
}
char c;
for (int i = 0; i < m; i++) {
int t = 0;
cin.ignore();
for (int j = 0; j < n; j++) {
c = getchar();
t = t * 2 + int(c - '0');
}
sum[t]++;
}
for (int i = 0; i < (1 << n); i++) {
int t;
for (int j = 0; j < (1 << n); j++) {
if (!sum[j]) {
continue;
}
t = h[i ^ j];
if (t > 100) {
t = 101;
}
ans[i][t] += sum[j];
}
for (int j = 1; j <= 100; j++) {
ans[i][j] += ans[i][j - 1];
}
}
int k;
while (q--) {
int t = 0;
cin.ignore();
for (int j = 0; j < n; j++) {
c = getchar();
t = t * 2 + int(c - '0');
}
scanf(" %d", &k);
printf("%d\n", ans[t][k]);
}
return 0;
}
| 10 | CPP |
#include<iostream>
using namespace std;
int main()
{
int a, b;
char c;
while (1)
{
cin >> a >> c >> b;
if (c == '?')break;
if (c == '+')cout << a + b << endl;
if (c == '-')cout << a - b << endl;
if (c == '/')cout << a / b << endl;
if (c == '*')cout << a * b << endl;
}
return 0;
}
| 0 | CPP |
for _ in range(int(input())):
n=int(input())+1
l=[0]+list(map(int,input().split()))
visited=[1]*n
for i in range(1,n):
for j in range(i+i,n,i):
if(l[j]>l[i]):
visited[j]=max(visited[j],visited[i]+1)
print(max(visited)) | 8 | PYTHON3 |
n = int(input())
ans=0
for i in range(n,0,-1):
ans += 1/i
print('%.12f'%ans) | 8 | PYTHON3 |
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#define debug(...) fprintf(stderr,__VA_ARGS__)
#define inver(a,mod) power(a,mod-2,mod)
#define idx(a,b) ((ll)(a)*mod[1]+(b))
using namespace std;
template<class T> void rd(T &x) {
x=0; int f=1,ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10-'0'+ch;ch=getchar();}
x*=f;
}
typedef long long ll;
const int mod[2]={998244353,1004535809};
const int maxn=250000+50;
int bs[2],rb[2];
int n; char s[maxn];
int c[2];
map<ll,int> cnt;
struct func {
int k,b;
func(int k=1,int b=0):k(k),b(b){}
inline int f(int x,int mod) {
return ((ll)k*x+b)%mod;
}
} a[maxn][2];
inline func mer(func a,func b,int mod) {
return func((ll)a.k*b.k%mod,((ll)a.b*b.k+b.b)%mod);
}
inline int add(int x,int mod) {return x>=mod?x-mod:x;}
inline int sub(int x,int mod) {return x<0?x+mod:x;}
ll power(ll x,ll y,int mod) {
ll re=1;
while(y) {
if(y&1) re=re*x%mod;
x=x*x%mod;
y>>=1;
}
return re;
}
void init() {
srand((unsigned long long)(new char));
bs[0]=rand(),rb[0]=inver(bs[0],mod[0]);
bs[1]=rand(),rb[1]=inver(bs[1],mod[1]);
}
int main() {
init();
rd(n);
scanf("%s",s+1);
for(int i=n;i>=1;--i) for(int k=0;k<2;++k) {
func f; switch(s[i]) {
case '+': f=func(1,mod[k]-1),c[k]=add(c[k]+1,mod[k]); break;
case '-': f=func(1,1),c[k]=sub(c[k]-1,mod[k]); break;
case '>': f=func(rb[k],0),c[k]=(ll)c[k]*bs[k]%mod[k]; break;
case '<': f=func(bs[k],0),c[k]=(ll)c[k]*rb[k]%mod[k]; break;
}
a[i][k]=mer(f,a[i+1][k],mod[k]);
}
ll an=0;
++cnt[0];
for(int i=n;i>=1;--i) {
an+=cnt[idx(a[i][0].f(c[0],mod[0]),a[i][1].f(c[1],mod[1]))];
++cnt[idx(a[i][0].f(0,mod[0]),a[i][1].f(0,mod[1]))];
}
printf("%lld\n",an);
return 0;
} | 0 | CPP |
n = int(input())
for test in range(n):
num = int(input())
res = ((1 + num)*num)>>1
deg = 0
while 2**deg <= num:
deg += 1
res -= 2*(2**deg-1)
print(res)
| 7 | PYTHON3 |
t = int(input())
for _ in range(t):
n = int(input())
xs = []
ys = []
coords = []
for _ in range(n):
x, y = map(int, input().split())
xs.append(x)
ys.append(y)
coords.append((x, y))
xs.sort()
ys.sort()
if n&1:
print(1)
else:
xdiff = xs[n//2] - xs[n//2 - 1] + 1
ydiff = ys[n//2] - ys[n//2 - 1] + 1
print(xdiff*ydiff) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
int l = 0, r = s.size() - 1;
char cur = '?';
int cnt = 0;
vector<pair<int, char>> v;
while (l <= r) {
if (s[l] != s[r]) {
cout << 0 << endl;
return 0;
}
cur = s[l];
cnt = 0;
while (s[l] == cur && l <= r) {
cnt++;
l++;
}
while (s[r] == cur && l <= r) {
cnt++;
r--;
}
v.push_back(make_pair(cnt, cur));
}
bool y = 1;
for (int i = 0; i < v.size() - 1; i++) {
if (v[i].first < 3) y = 0;
}
if (y && v[v.size() - 1].first >= 2)
cout << v[v.size() - 1].first + 1 << endl;
else
cout << 0 << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
void RD(int &x) { scanf("%d", &x); }
void RD(long long &x) { scanf("%I64d", &x); }
void RD(double &x) { scanf("%lf", &x); }
void RD(int &x, int &y) { scanf("%d%d", &x, &y); }
void RD(long long &x, long long &y) { scanf("%I64d%I64d", &x, &y); }
void RD(double &x, double &y) { scanf("%lf%lf", &x, &y); }
void RD(char *s) { scanf("%s", s); }
void RD(char &s) { scanf("%c", &s); }
void RD(string &s) { cin >> s; }
void PR(int x) { printf("%d\n", x); }
void PR(int x, int y) { printf("%d %d\n", x, y); }
void PR(long long x) { printf("%I64d\n", x); }
void PR(char x) { printf("%c\n", x); }
void PR(char *x) { printf("%s\n", x); }
void PR(string x) { cout << x << endl; }
const long long inf = 1LL << 28;
const long long mod = 1LL;
struct data {
int p, q;
data() {}
data(int a, int b) { p = a, q = b; }
};
data arr[100010];
map<pair<int, int>, int> mp1;
map<int, int> mp2;
map<int, int> mp3;
int n;
bool found;
bool col[100010];
vector<int> v[100010];
vector<int> v1[100010];
void dfs(int x, int y) {
if (found) return;
if (x == n || y == 1) {
found = true;
return;
}
col[mp1[make_pair(x, y)]] = 1;
int i, k, p, q;
if (mp2.find(x + 1) != mp2.end()) {
k = (int)v[mp2[x + 1]].size();
for ((i) = 0; (i) < (int)(k); (i)++) {
p = x + 1;
q = v[mp2[x + 1]][i];
if (q >= y - 1 && col[mp1[make_pair(p, q)]] == 0) dfs(p, q);
}
}
if (mp3.find(y - 1) != mp3.end()) {
k = (int)v1[mp3[y - 1]].size();
for ((i) = 0; (i) < (int)(k); (i)++) {
q = y - 1;
p = v1[mp3[y - 1]][i];
if (p - 1 <= x && col[mp1[make_pair(p, q)]] == 0) dfs(p, q);
}
}
return;
}
int main() {
int m, i, j, k, cnt, cnt1;
while (scanf("%d %d", &n, &m) == 2) {
(mp1.clear());
(mp2.clear());
(mp3.clear());
memset(col, 0, sizeof(col));
for ((i) = 0; (i) < (int)(100001); (i)++) (v[i].clear()), (v1[i].clear());
cnt = cnt1 = 0;
for ((i) = 0; (i) < (int)(m); (i)++) {
RD(j, k);
arr[i] = data(j, k);
mp1[make_pair(j, k)] = i;
if (mp2.find(j) == mp2.end()) mp2[j] = cnt++;
v[mp2[j]].push_back(k);
if (mp3.find(k) == mp3.end()) mp3[k] = cnt1++;
v1[mp3[k]].push_back(j);
}
found = false;
for ((i) = 0; (i) < (int)(m); (i)++) {
if (arr[i].p == 1 || arr[i].q == n) {
dfs(arr[i].p, arr[i].q);
if (found) goto HELL;
}
}
HELL:;
found ? printf("-1\n") : printf("%d\n", 2 * n - 2);
}
return 0;
}
| 8 | CPP |
#------------------------------what is this I don't know....just makes my mess faster--------------------------------------
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#----------------------------------Real game starts here--------------------------------------
'''
___________________THIS IS AESTROIX CODE________________________
KARMANYA GUPTA
'''
#_______________________________________________________________#
import math
def fact(x):
if x == 0:
return 1
else:
return x * fact(x-1)
def lower_bound(li, num): #return 0 if all are greater or equal to
answer = -1
start = 0
end = len(li)-1
while(start <= end):
middle = (end+start)//2
if li[middle] >= num:
answer = middle
end = middle - 1
else:
start = middle + 1
return answer #index where x is not less than num
def upper_bound(li, num): #return n-1 if all are small or equal
answer = -1
start = 0
end = len(li)-1
while(start <= end):
middle = (end+start)//2
if li[middle] <= num:
answer = middle
start = middle + 1
else:
end = middle - 1
return answer #index where x is not greater than num
def abs(x):
return x if x >=0 else -x
def binary_search(li, val, lb, ub):
ans = 0
while(lb <= ub):
mid = (lb+ub)//2
#print(mid, li[mid])
if li[mid] > val:
ub = mid-1
elif val > li[mid]:
lb = mid + 1
else:
ans = 1
break
return ans
#_______________________________________________________________#
n = int(input())
nums = list(map(int, input().split()))
check = [1]*n
pieces, cnt, ans, last = 0,0,1,0
while(check.count(0)!=n):
for i in range(n):
if pieces >= nums[i] and check[i] == 1:
check[i] = 0
pieces += 1 #collect piece
if i > last: #right
if ans == 0:
cnt += 1
ans ^= 1
elif i < last: #left
if ans == 1:
cnt += 1
ans ^= 1
last = i
for i in range(n-1,-1,-1):
if pieces >= nums[i] and check[i] == 1:
check[i] = 0
pieces += 1 #collect piece
if i > last: #right
if ans == 0:
cnt += 1
ans ^= 1
elif i < last: #left
if ans == 1:
cnt += 1
ans ^= 1
last = i
print(cnt)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int ps1[100005], ps2[100005];
int main() {
int n, k, w;
cin >> n >> k >> w;
for (int i = 1; i <= (n); i++) {
char c;
cin >> c;
c -= 48;
ps1[i] = c + ps1[i - 1];
if (i >= k) ps2[i] = c + ps2[i - k];
}
while (w--) {
int l, r;
cin >> l >> r;
int ans = ps1[r] - ps1[l - 1] + (r - l + 1) / k;
ans -= ((ps2[r] - ps2[l - 1]) << 1);
cout << ans << endl;
}
}
| 9 | CPP |
N,K=list(map(int,input().split()))
i=0
while N>0:
N//=K
i+=1
print(i) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int N;
int K;
int T;
cin >> N >> K >> T;
if (T <= K) {
cout << T << endl;
} else if (T > K && T <= N) {
cout << K << endl;
} else {
cout << N + K - T << endl;
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, a[200001], b[200001], i, dp[200001][2] = {0};
scanf("%d%d", &n, &c);
for (i = 1; i <= n - 1; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n - 1; i++) {
scanf("%d", &b[i]);
}
dp[1][0] = dp[1][1] = 0;
printf("0 ");
dp[2][0] = a[1];
dp[2][1] = b[1] + c;
printf("%d ", min(dp[2][0], dp[2][1]));
for (i = 3; i <= n; i++) {
dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]) + a[i - 1];
dp[i][1] = min(dp[i - 1][0] + c + b[i - 1], dp[i - 1][1] + b[i - 1]);
printf("%d ", min(dp[i][0], dp[i][1]));
}
printf("\n");
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int tc = 1;
while (tc--) {
long long int n;
cin >> n;
int k = 2;
vector<pair<int, int>> ans;
ans.push_back({1, 1});
ans.push_back({0, 0});
ans.push_back({1, 0});
ans.push_back({0, 1});
for (int i = 0; i < n; i++) {
ans.push_back({k, k});
ans.push_back({k, k - 1});
ans.push_back({k - 1, k});
k++;
}
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << "\n";
}
}
return 0;
}
| 9 | CPP |
def isPrime(n):
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
primes = set()
for i in range(2, 100000):
if isPrime(i):
primes.add(i)
c = [1] + [0] * 100000
n = input()
s = list(map(int, input().split()))
x = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313]
for i in s:
for p in x:
if i in primes:
c[i] += 1
break
if p**2 > i:
break
if i % p == 0:
c[p] += 1
while i and i % p == 0:
i //= p
#if i != 1:
# c[i] +=1
m = max(c)
print(m) | 8 | PYTHON3 |
#include<iostream>
using namespace std;
int main(){
int A,B,C,D;
cin>>A>>B>>C>>D;
cout<<(A*B<C*D?C*D:A*B)<<endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int x[3], y[3], X, Y, now, best = 1e9;
int main() {
for (int i = (0); i <= (2); ++i) scanf("%d%d", &x[i], &y[i]);
for (int i = (0); i <= (1000); ++i)
for (int j = (0); j <= (1000); ++j) {
now = 4;
for (int k = (0); k <= (2); ++k) {
if (i == x[k] && j == y[k])
now--;
else
now += abs(i - x[k]) + abs(j - y[k]) - 1;
}
if (now < best) X = i, Y = j, best = now;
}
printf("%d\n", best);
printf("%d %d\n", X, Y);
for (int k = (0); k <= (2); ++k) {
if (X == x[k] && Y == y[k]) continue;
printf("%d %d\n", x[k], y[k]);
for (int i = (min(X, x[k]) + 1); i <= (max(X, x[k]) - 1); ++i)
printf("%d %d\n", i, y[k]);
for (int i = (min(Y, y[k]) + 1); i <= (max(Y, y[k]) - 1); ++i)
printf("%d %d\n", X, i);
if (X != x[k] && Y != y[k]) printf("%d %d\n", X, y[k]);
}
return 0;
}
| 7 | CPP |
a = [int(i) for i in input()]
def product(x):
tt = 1
for i in x:
tt *= i
return tt
maximum = product(a)
for i in range(len(a)):
nombre = a[:i] + [a[i] - 1] + [9]*(len(a)-i-1)
index = 0
while index < len(a) and not nombre[index]:
index += 1
produit = product( nombre[index:] )
maximum = max(maximum, produit)
print(maximum) | 8 | PYTHON3 |
t = int(input())
while(t > 0):
x, y, n = map(int, input().split(' '))
if (n - n % x + y <= n):
print(n - n % x + y)
else:
print(n - n % x - (x - y))
t -= 1 | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const int siz = 200010;
long long int arr[100005], n;
vector<long long int> vec;
long long int calc(long long int k) {
long long int sum = 0;
for (long long int i = 1; i <= n; ++i) vec.push_back(arr[i] + i * k);
sort(vec.begin(), vec.end());
for (long long int i = 0; i < k; ++i) sum += vec[i];
vec.clear();
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long int s;
cin >> n >> s;
for (long long int i = 1; i <= n; ++i) cin >> arr[i];
long long int ans = 0, sum = 0;
long long int lo = 1, hi = n, mid, tmp;
while (lo <= hi) {
mid = (lo + hi) / 2;
tmp = calc(mid);
if (tmp <= s) {
if (ans < mid) {
ans = mid;
sum = tmp;
}
lo = mid + 1;
} else
hi = mid - 1;
}
cout << ans << " " << sum << endl;
return 0;
}
| 9 | CPP |
num=int(input())
L=[]
for i in range(0,num):
word=input()
alist=list(word)
total=0
for n in alist:
total=total+1
if total<=10:
output=word
else:
tot=str(total-2)
a=alist[0]
b=alist[-1]
output='%s%s%s'%(a,tot,b)
L.append(output)
for i in range(0,num):
print('%s'%L[i])
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<char, int> > res(const string& s) {
vector<pair<char, int> > ret;
const int sz = s.size();
int cnt = 0;
char ch = '_';
for (int i = 0; i < sz; ++i) {
if (s[i] == ch) {
++cnt;
} else {
if (cnt > 0) {
ret.push_back({ch, cnt});
}
cnt = 1;
ch = s[i];
}
}
if (cnt > 0) {
ret.push_back({ch, cnt});
}
return ret;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
string a;
string b;
cin >> a;
cin >> b;
vector<pair<char, int> > aCnt = res(a);
vector<pair<char, int> > bCnt = res(b);
bool suc = true;
if (aCnt.size() != bCnt.size()) suc = false;
if (suc) {
int sz = aCnt.size();
for (int i = 0; i < sz; ++i) {
if (aCnt[i].first != bCnt[i].first) {
suc = false;
break;
}
if (aCnt[i].second > bCnt[i].second) {
suc = false;
break;
}
}
}
if (suc) {
printf("%s\n", "YES");
} else {
printf("%s\n", "NO");
}
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244853, N = 1e5;
long long fac[N], ifac[N];
long long power(long long x, long long y, long long m) {
if (y == 0) return 1;
long long p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
long long modInverse(long long a, long long m) { return power(a, m - 2, m); }
const int N1 = 2e3 + 1;
int dp[N1][N1];
int n, m;
int ncr(int n, int r) {
if (r > n) return 0;
long long ret = ifac[r] * ifac[n - r] % mod;
return ret * fac[n] % mod;
}
int always_great_equal(int n, int m) {
if (n < m) return 0;
int ret = ncr(n + m, m) - ncr(n + m, m - 1);
if (ret < 0) ret += mod;
return ret;
}
int cal(int n, int m) {
if (!n) return 0;
if (!m) return n;
int &ans = dp[n][m];
if (ans != -1) return ans;
ans = cal(n - 1, m) + ncr(n - 1 + m, m);
if (ans >= mod) ans -= mod;
ans += cal(n, m - 1) - ncr(n + m - 1, n);
if (ans >= mod) ans -= mod;
if (ans < 0) ans += mod;
ans += always_great_equal(m - 1, n);
if (ans >= mod) ans -= mod;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(dp, -1, sizeof dp);
fac[0] = 1;
for (int i = 1; i < N; ++i) {
fac[i] = fac[i - 1] * i % mod;
}
ifac[N - 1] = modInverse(fac[N - 1], mod);
for (int i = N - 2; i >= 0; --i) {
ifac[i] = (i + 1) * ifac[i + 1] % mod;
}
cin >> n >> m;
cout << cal(n, m);
return 0;
}
| 11 | CPP |
N = int(input())
a = 0
for n in range(N):
x,u = input().split()
if u=="JPY":
a+=int(x)
else:
a+=380000*float(x)
print(a) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int N, K, X;
int64_t A[200];
int64_t dp[200][200][200];
int64_t rec(int i, int k, int x) {
if (i == N) {
if (x == 0 && k < K) return 0;
return LLONG_MIN;
}
if (k == K) return LLONG_MIN;
if (x == 0) {
if (N - i + k < K) return 0;
return LLONG_MIN;
}
if (dp[i][k][x] != -1) return dp[i][k][x];
dp[i][k][x] = max(A[i] + rec(i + 1, 0, x - 1), rec(i + 1, k + 1, x));
return dp[i][k][x];
}
int main() {
for (int i = 0; i < 200; ++i)
for (int j = 0; j < 200; ++j)
for (int k = 0; k < 200; ++k) dp[i][j][k] = -1;
cin >> N >> K >> X;
for (int i = 0; i < N; ++i) cin >> A[i];
int64_t ret = rec(0, 0, X);
if (ret < 0)
cout << -1 << endl;
else
cout << ret << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,sse3,sse4,popcnt,abm,mmx")
using namespace std;
inline bool isvowel(char c) {
c = tolower(c);
if (c == 'a' || c == 'e' || c == 'i' || c == 'y' || c == 'o' || c == 'u')
return 1;
return 0;
}
const double eps = 0.000001;
const long double pi = acos(-1);
const int maxn = 1e7 + 9;
const int mod = 1e9 + 7;
const long long MOD = 1e18 + 9;
const long long INF = 1e18 + 123;
const int inf = 2e9 + 11;
const int mxn = 1e6 + 9;
const int N = 3e5 + 123;
const int PRI = 555557;
const int pri = 997;
const int Magic = 2101;
inline void randomizer3000() {
unsigned int seed;
asm("rdtsc" : "=A"(seed));
srand(seed);
}
int n, m, k;
long long a[N];
long long ans = INF;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] += a[i - 1];
}
for (long long len = 1; len <= n; len++) {
if (len * len >= ans) break;
for (int i = 1; i + len <= n; i++) {
ans = min(ans, len * len + (a[i + len] - a[i]) * (a[i + len] - a[i]));
}
}
cout << ans;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#define all(vec) vec.begin(), vec.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
constexpr ll INF = (1LL << 30) - 1LL;
constexpr ll LINF = (1LL << 60) - 1LL;
constexpr ll MOD = 1e9 + 7;
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); }
template <typename T> struct Segtree {
inline T merge(T a, T b) { return a + b; }
inline void act(T &a, T b) { a += b; }
vector<T> dat;
int n;
T e;
Segtree(int n_, T e) : e(e) {
n = 1;
while (n < n_) {
n <<= 1;
}
dat.resize(2 * n, e);
}
void set(const int &a, const int &b, const T &x, int k, int l, int r) {
if (b <= l || r <= a) {
return;
}
if (a <= l && r <= b) {
act(dat[k], x);
return;
}
set(a, b, x, k << 1, l, (l + r) >> 1);
set(a, b, x, k << 1 | 1, (l + r) >> 1, r);
}
inline void set(const int &a, const int &b, const T &x) {
if (a >= b) {
return;
}
set(a, b, x, 1, 0, n);
}
T get(int k) {
k += n;
T res = dat[k];
k >>= 1;
while (k > 0) {
res = merge(res, dat[k]);
k >>= 1;
}
return res;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, q;
cin >> n >> q;
Segtree<int> seg(n, 0);
while (q--) {
int t;
cin >> t;
if (t == 0) {
int l, r, x;
cin >> l >> r >> x;
--l;
seg.set(l, r, x);
} else {
int i;
cin >> i;
--i;
cout << seg.get(i) << "\n";
}
}
}
| 0 | CPP |
n=int(input())
for i in range(n-1):
if i%2:
print("I love that ",end='')
else:
print("I hate that ",end='')
if n%2:
print("I hate it",end='')
else:
print("I love it",end='') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
char s1[maxn], s2[maxn];
int a[maxn], b[maxn], vis1[maxn], vis2[maxn];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
int n;
while (cin >> n) {
memset(vis1, 0, sizeof(vis1));
memset(vis2, 0, sizeof(vis2));
cin >> s1 >> s2;
for (int i = 0; s1[i]; i++) a[i] = s1[i] - '0', b[i] = s2[i] - '0';
sort(b, b + n);
int mn = 0, mx = 0;
for (int j, i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (!vis1[j] && b[j] >= a[i]) {
vis1[j] = 1;
break;
}
}
if (j == n) mn++;
for (j = 0; j < n; j++) {
if (!vis2[j] && b[j] > a[i]) {
vis2[j] = 1;
mx++;
break;
}
}
}
cout << mn << endl << mx << endl;
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[1000005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
stack<pair<long long, int> > st;
for (int i = 1; i <= n; i++) {
st.push(make_pair(a[i], 1));
while (st.size() > 1) {
auto p = st.top();
st.pop();
auto x = st.top();
long long sum = x.first;
sum += p.first;
int base = p.second + x.second;
if (sum * x.second < x.first * base) {
st.pop();
st.push({sum, base});
} else {
st.push(p);
break;
}
}
}
vector<double> vec;
while (!st.empty()) {
auto p = st.top();
st.pop();
for (int i = 0; i < p.second; i++) vec.push_back(p.first * 1.0 / p.second);
}
reverse(vec.begin(), vec.end());
for (double x : vec) printf("%.9f\n", x);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, mod = 1000000007;
int t;
int n, x, a, b;
vector<int> G[N];
bool vs[N];
int edg[N];
int s;
void DFS(int u) {
vs[u] = true;
for (int v : G[u])
if (!vs[v]) {
edg[u]++;
DFS(v);
}
s += edg[u];
return;
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio();
cin >> t;
while (t--) {
cin >> n >> x;
for (int i = 0; i <= n; i++) G[i].clear();
for (int i = 0; i <= n; i++) {
vs[i] = false;
edg[i] = 0;
s = 0;
}
for (int i = 1; i < n; i++) {
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
DFS(x);
if (n == 1 || edg[x] <= 1) {
cout << "Ayush";
cout << "\n";
} else {
s = n - edg[x] - 1;
s %= 2;
int r = edg[x] - 1;
r %= 2;
s += r;
s %= 2;
if (s == 1)
cout << "Ashish";
else
cout << "Ayush";
cout << "\n";
}
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
static const int INF = 500000000;
template <class T>
void debug(T a, T b) {
for (; a != b; ++a) cerr << *a << ' ';
cerr << endl;
}
int n, len, h, m;
int b[200005], ar[200005], val[200005];
struct segtree {
int val[800005], lazy[800005];
int n;
void init(int n_) {
n = 1;
while (n < n_) n <<= 1;
for (int i = 0; i < n * 2; ++i) val[i] = lazy[i] = 0;
}
void push(int i) {
if (lazy[i]) {
lazy[i * 2 + 1] += lazy[i];
lazy[i * 2 + 2] += lazy[i];
val[i * 2 + 1] += lazy[i];
val[i * 2 + 2] += lazy[i];
lazy[i] = 0;
}
}
void add(int a, int b, int i, int l, int r, int v) {
if (a <= l && r <= b) {
lazy[i] += v;
val[i] += v;
return;
}
if (b <= l || r <= a) return;
int md = (l + r) >> 1;
push(i);
add(a, b, i * 2 + 1, l, md, v);
add(a, b, i * 2 + 2, md, r, v);
val[i] = max(val[i * 2 + 1], val[i * 2 + 2]);
}
int query() { return val[0]; }
};
segtree seg;
int main() {
cin >> n >> len >> h;
for (int i = 0; i < len; ++i) cin >> b[i];
for (int i = 0; i < n; ++i) cin >> ar[i];
m = len;
sort(b, b + m, greater<int>());
for (int i = 0; i < m; ++i) b[i] = h - b[i];
seg.init(m);
for (int i = 0; i < n; ++i) ar[i] = upper_bound(b, b + m, ar[i]) - b;
for (int i = 0; i < m; ++i) seg.add(i, i + 1, 0, 0, seg.n, m - i);
int res = 0;
for (int i = 0; i < m; ++i) seg.add(0, ar[i], 0, 0, seg.n, -1);
if (seg.query() <= 0) ++res;
for (int i = m; i < n; ++i) {
int ad = ar[i], ers = ar[i - m];
seg.add(0, ad, 0, 0, seg.n, -1);
seg.add(0, ers, 0, 0, seg.n, 1);
if (seg.query() <= 0) ++res;
}
cout << res << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
void Read(int& x) {
char c = nc();
for (; c < '0' || c > '9'; c = nc())
;
for (x = 0; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + c - 48, c = nc())
;
}
const int N = 300010;
const int M = 19;
int n, m, x, y;
int t[N << 1], nx[N << 1], h[N], num;
int f[N], c[N], dp[N][M];
int a[N], l, cur[N];
vector<pair<int, int> > g[N];
long long Res, Ans;
void Add(int x, int y) {
t[++num] = y;
nx[num] = h[x];
h[x] = num;
}
bool Cmp(int x, int y) { return x > y; }
void Dfs(int x, int y) {
dp[x][1] = n;
f[x] = y;
for (int i = h[x]; i; i = nx[i])
if (t[i] != y) Dfs(t[i], x), c[x] = max(c[x], c[t[i]]);
for (int j = 2; j < M; j++) {
l = 0;
for (int i = h[x]; i; i = nx[i])
if (t[i] != y && dp[t[i]][j - 1]) a[++l] = dp[t[i]][j - 1];
sort(a + 1, a + l + 1, Cmp);
for (int k = l; k > 1; k--)
if (a[k] >= k) {
dp[x][j] = k;
break;
}
if (dp[x][j]) g[dp[x][j]].push_back(pair<int, int>(x, j));
}
Ans += ++c[x];
}
void Update(int x, int y) {
while (x) {
if (cur[x] >= y) break;
Res += y - cur[x];
cur[x] = y;
x = f[x];
}
}
int main() {
Read(n);
for (int i = 1; i < n; i++) Read(x), Read(y), Add(x, y), Add(y, x);
Dfs(1, 1);
for (int i = 1; i <= n; i++) cur[i] = 1;
Res = n;
for (int k = n; k > 1; k--) {
for (int j = 0; j < g[k].size(); j++) Update(g[k][j].first, g[k][j].second);
Ans += Res;
}
cout << Ans << endl;
return 0;
}
| 12 | CPP |
#include<iostream>
#include<vector>
using namespace std;
int main(){
int n;
cin>>n;
vector<int> v;
int firstN,secondN;
for(int i=0;i<n;i++){
cin>>firstN;
if(firstN==0){
cin>>secondN;
v.push_back(secondN);
}else if(firstN==1){
cin>>secondN;
cout<<v[secondN]<<endl;
}else{
v.pop_back();
}
}
return 0;
}
| 0 | CPP |
#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <string>
using namespace std;
#define LL long long
#define mp make_pair
#define fr first
#define sc second
#define pb push_back
#define lc (x<<1)
#define rc ((x<<1)|1)
const int N=505;
char s[N];
int a[N][N],cnt[N],ct[N];
int main(){
// freopen("in.txt","r",stdin);freopen("out.txt","w",stdout);
int i,j,n,ff=0;
scanf("%d",&n);
for (i=1;i<=n;i++){
scanf("%s",s+1);
for (j=1;j<=n;j++) if (s[j]=='.') a[i][j]=0; else a[i][j]=1,ff=1;
}
if (!ff) {puts("-1");return 0;}
for (i=1;i<=n;i++)
for (j=1;j<=n;j++)
cnt[j]+=a[i][j],ct[i]+=a[i][j];
int tot=n,ans=n+1;
for (i=1;i<=n;i++) if (cnt[i]==n) tot--;
for (i=1;i<=n;i++) if (cnt[i]) ans=min(ans,n-ct[i]); else ans=min(ans,n-ct[i]+1);
ans+=tot;
cout<<ans<<endl;
// system("pause");
return 0;
}
| 0 | CPP |
k = 0
s = "hello"
a = input()
for l in a:
if l == s[k]:
k += 1
if k == len(s):
break
if k == len(s):
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e8;
const long long MOD = (long long)(5000011);
const long long MAXV = (long long)((1 << 16) + 10);
const long long MAXE = (long long)(500000 + 10);
string s;
int n, tt;
double dp[12][12];
double flujo[12][12];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
double a;
double r, falta, t;
cin >> n >> tt;
while (tt--) {
memset(flujo, 0.0, sizeof(flujo));
flujo[0][0] = 2.0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
t = flujo[i - 1][j - 1] / 2.0 + flujo[i - 1][j] / 2.0;
dp[i][j] += t;
if (dp[i][j] >= 1.0) {
flujo[i][j] = dp[i][j] - 1.0;
dp[i][j] = 1.0;
}
}
}
}
int sol = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (dp[i][j] >= 1.0) sol++;
cout << sol << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class _T>
inline string tostr(const _T& a) {
ostringstream os("");
os << a;
return os.str();
}
int a[200], b[200], n, V;
long double c[200];
int main() {
cout.flags(ios::fixed);
cout.precision(8);
cin >> n >> V;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < n; i++) {
c[i] = (long double)b[i] / (long double)a[i];
}
long double m = 100000000.0, ans = 0;
for (int i = 0; i < n; i++) {
m = min(m, c[i]);
}
for (int i = 0; i < n; i++) {
ans = ans + a[i] * m;
}
cout << min(ans, (long double)V * 1.0);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int maxn = 1e6 + 10;
template <class T>
T mymin(const T a, const T b) {
return a < b ? a : b;
}
template <class T>
T mymax(const T a, const T b) {
return a > b ? a : b;
}
int A, B, C, N, T, ans;
int main() {
ios::sync_with_stdio(false);
cin >> N >> A >> B >> C >> T;
if (C >= B) {
for (int i = 1; i <= N; i++) {
int a;
cin >> a;
ans += A + (C - B) * (T - a);
}
} else {
map<int, int> mp;
for (int i = 1; i <= N; i++) {
int a;
cin >> a;
ans += A;
}
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
from sys import stdin
input=lambda : stdin.readline().strip()
from math import ceil,sqrt,factorial,gcd
from collections import deque
def travel(x,y):
stack=[[x,y]]
flag=0
while stack:
x=stack.pop()
if visited[x[0]][x[1]]==0:
lakes[-1].append(x)
visited[x[0]][x[1]]=1
else:
continue
if x[0]==0 or x[0]==n-1 or x[1]==0 or x[1]==m-1:
flag=1
try:
if l[x[0]][x[1]+1]=='.' and visited[x[0]][x[1]+1]==0:
stack.append([x[0],x[1]+1])
except:
pass
try:
if l[x[0]][x[1]-1]=='.' and visited[x[0]][x[1]-1]==0:
stack.append([x[0],x[1]-1])
except:
pass
try:
if l[x[0]+1][x[1]]=='.' and visited[x[0]+1][x[1]]==0:
stack.append([x[0]+1,x[1]])
except:
pass
try:
if l[x[0]-1][x[1]]=='.' and visited[x[0]-1][x[1]]==0:
stack.append([x[0]-1,x[1]])
except:
pass
if flag==1:
lakes.pop()
n,m,k=map(int,input().split())
visited=[[0 for i in range(m)] for i in range(n)]
l=[]
for i in range(n):
s=input()
l.append(list(s))
lakes=[]
for i in range(n):
for j in range(m):
if l[i][j]=="." and visited[i][j]==0:
lakes.append([])
travel(i,j)
z=[]
for i in range(len(lakes)):
z.append([len(lakes[i]),i])
z.sort(key=lambda a:a[0])
a=0
count=0
# print(lakes)
for i in range(len(z)-k):
for t in lakes[z[i][1]]:
count+=1
l[t[0]][t[1]]='*'
print(count)
for i in l:
print("".join(i))
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
const int mod = 998244353;
inline long long fastpow(long long a, long long b) {
long long ans = 1;
for (; b; b >>= 1, a = a * a % mod)
if (b & 1) ans = ans * a % mod;
return ans;
}
long long fac[maxn] = {1}, ifac[maxn], inv[maxn] = {0, 1};
inline long long C(long long n, long long m) {
return fac[n] * ifac[n - m] % mod * ifac[m] % mod;
}
inline long long A(long long n, long long m) {
return fac[n] * ifac[n - m] % mod;
}
inline void init() {
for (int i = 2; i < maxn; ++i) inv[i] = (mod - mod / i) * inv[mod % i] % mod;
for (int i = 1; i < maxn; i++) fac[i] = fac[i - 1] * i % mod;
ifac[maxn - 1] = fastpow(fac[maxn - 1], mod - 2);
for (int i = maxn - 2; ~i; i--) ifac[i] = ifac[i + 1] * (i + 1) % mod;
}
int main() {
init();
long long n, k;
cin >> n >> k;
if (k >= n) return cout << 0 << endl, 0;
if (k == 0) return cout << fac[n] << endl, 0;
long long x = n - k;
long long ans = 0;
for (int i = 0; i <= x; i++) {
ans = ans + (i % 2 ? -1ll : 1ll) * C(x, i) % mod * fastpow(x - i, n) % mod;
ans %= mod;
}
cout << ((2ll * ans * C(n, x)) % mod + mod) % mod << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mn = 1e6 + 5;
int f[mn], d[mn], n, t, ans[mn];
void cal() {
for (int i = 2; i <= 1000; ++i) {
int j = i;
if (d[j]) continue;
while (j <= mn - 5) {
j += i;
if (j > mn - 5) break;
d[j] = 1;
}
}
for (int i = 1; i <= mn - 5; ++i) {
f[i] = f[i - 1] + (1 - d[i]);
ans[i] = 1 + f[i] - f[(int)sqrt(i)];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cal();
for (cin >> t; t--; cout << ans[n] << "\n") cin >> n;
return 0;
}
| 17 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
int n, m, v, p;
cin >> n >> m >> v >> p;
vector<int> an(n);
for(int i=0; i<n; ++i) cin >> an[i];
sort(an.begin(),an.end());
vector<ll> ep(n+1,0);
for(int i=1; i<=n; ++i) ep[i] = ep[i-1] + an[i-1];
int ans = p;
int bord = an[n-p];
for(int i=n-p-1; i>=0; --i){
bool flag = (ep[n-p+1] - ep[i]) - (ll)(n-v)*m <= (ll)an[i]*(n-p-i+1);
//cout << ep[n-p+1] - ep[i] << '-' << (n-v)*m << ':' << (ll)an[i]*(n-p-i+1) << endl;
if(bord-an[i] <= m && flag){
++ans;
}
}
cout << ans << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
int o = 0, t = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1)
o++;
else
t++;
}
if (o == 0) {
for (int i = 0; i < t; i++) cout << "2 ";
return 0;
}
if (t == 0) {
for (int i = 0; i < o; i++) cout << "1 ";
return 0;
}
cout << "2 1 ";
for (int i = 0; i < t - 1; i++) cout << "2 ";
for (int i = 0; i < o - 1; i++) cout << "1 ";
}
| 9 | CPP |
#include<bits/stdc++.h>
using namespace std;
const int mod=1e9+7;
const int maxn=5e5+5;
int f[maxn],ans[maxn];
int _find(int x){return x!=f[x]?f[x]=_find(f[x]):f[x];}
int main(){
int n,m,id=0,num=1;scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)f[i]=i;
for(int i=1;i<=n;i++){
int k,a,b;scanf("%d",&k);
if(k==1)a=0,scanf("%d",&b);
else scanf("%d%d",&a,&b);
int aa=_find(a),bb=_find(b);
if(aa!=bb){
f[aa]=bb;
ans[id++]=i;
(num*=2)%=mod;
}
}
printf("%d %d\n",num,id);
for(int i=0;i<id;i++)printf("%d ",ans[i]);printf("\n");
return 0;
}
| 12 | CPP |
t=int(input())
count=0
for i in range(1,t):
if t>i and t%i==0:
count=count+1
print(count)
| 7 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
s = str(input())
ans = 0
for i in range(-1, n-1):
if (int(s[i+1]) - int(s[i])) == 0 and int(s[i+1])==int(s[i])==1:
ans += 1
else :
continue
print(ans)
| 8 | PYTHON3 |
from math import factorial
n = int(input())
val = list(map(int,input().split()))
for i in range(1,n):
val[i] += val[i-1]
total = val[-1]
flag = True
count1 = 0
count2 = 0
result = 0
if total%3 !=0:
flag = False
print(0)
elif n<3:
print(0)
else:
if total!=0:
for i in range(n-2,-1,-1):
if val[i] == 2*total/3:
count2 += 1
if val[i] == total/3:
result += count2
print(result)
else:
for i in range(n-1):
if val[i] == 0:
count1+=1
#print(count1)
if (n>2):
res = int(factorial(count1)/(factorial(2)*factorial(count1-2)))
print(res)
else:
print(0) | 9 | PYTHON3 |
def get_inputs():
inp_string = input()
return inp_string.strip().split(' ')
n, k = (int(x) for x in get_inputs())
scores = [int(x) for x in get_inputs()]
count = 0
for score in scores:
if score >= scores[k - 1] and score > 0:
count += 1
print(count)
| 7 | PYTHON3 |
def checkGoodString(string, char):
if(len(string) == 1):
return string[0] == char
h = len(string)//2
s1 = string[:h]
s2 = string[h:]
good = False
for c in s1:
if(c != char):
break
else:
good = checkGoodString(s2, chr(ord(char) + 1))
if(good):
return True
for c in s2:
if(c != char):
return False
return checkGoodString(s1, chr(ord(char) +1))
def solve(string, char):
#stop condition, only 1 char
if(len(string) == 1):
return 0 if string[0] == char else 1
#stop condition, already char-good string
if(checkGoodString(string, char)):
return 0
h = len(string)//2
s1 = string[:h]
s2 = string[h:]
#try to solve first half
dif = 0
for c in s1:
if(c != char):
dif += 1
dif += solve(s2, chr(ord(char)+1))
#and the second half
dif2 = 0
for c in s2:
if(c!= char):
dif2+= 1
dif2 += solve(s1, chr(ord(char)+1))
#return the best solution
return min(dif, dif2)
n = int(input())
for i in range(n):
input()
print(solve(input(),'a'))
| 10 | PYTHON3 |
def main():
import sys
from operator import itemgetter
input = sys.stdin.readline
N = int(input())
K = N.bit_length() - 1
A_raw = list(map(int, input().split()))
flg = 1
A = []
for i, a in enumerate(A_raw):
if flg:
if a == -1:
flg = 0
else:
A.append(0)
else:
A.append(A_raw[i])
inf = 1<<40
dp = [[inf] * (K+1) for _ in range(N)]
dp[0][0] = 0
for i in range(N):
for j in range(K+1):
if dp[i][j] < inf:
if j < K:
dp[i+1][j+1] = min(dp[i+1][j+1], dp[i][j] + A[N-2-i])
if N - 2**(K-j) > i:
dp[i+1][j] = min(dp[i+1][j], dp[i][j])
print(dp[-1][-1])
if __name__ == '__main__':
main() | 11 | PYTHON3 |
l = input().split()
for a in range(4):
l[a] = int(l[a])
l.sort()
#a + b = l[0]
#b + c = l[1]
#a + c = l[2]
#a+b+c = l[3]
a = int((l[0]-l[1]+l[2])/2)
b = l[0] - a
c = l[2] - a
print(a,b,c)
| 7 | PYTHON3 |
from collections import Counter
def read_int():
return int(input())
def read_int_list():
return list(map(int, input().split(" ")))
def resolve():
for _ in range(read_int()):
_ = read_int()
participants_weight_list = sorted(read_int_list(), reverse=False)
result = [0]*101
frequency = Counter(participants_weight_list)
for index1 in frequency:
for index2 in frequency:
result[index1+index2] += min(frequency[index1], frequency[index2])
print(max(result) // 2)
if __name__ == "__main__":
resolve()
| 9 | PYTHON3 |
#include <cstdio>
#include <algorithm>
#include <vector>
#include <map>
#include <utility>
using namespace std;
int main() {
size_t n;
scanf("%zu", &n);
vector<int> w(n);
map<int, size_t> m;
int minw=1e8;
for (size_t i=0; i<n; ++i) {
scanf("%d", &w[i]);
m[w[i]] = 0;
if (minw > w[i])
minw = w[i];
}
{
size_t k=0;
for (pair<const int, size_t> &p: m)
p.second = k++;
}
int res=0;
vector<bool> done(n);
for (size_t i=0; i<n; ++i) {
if (done[i]) continue;
int count_=0, minc=1e8, sum=0;
size_t cur=i;
for (count_=0; ; ++count_) {
if (done[cur]) break;
done[cur] = true;
if (minc > w[cur])
minc = w[cur];
sum += w[cur];
cur = m[w[cur]];
}
res += sum + min((count_-2)*minc, minc+minw*(count_+1));
}
printf("%d\n", res);
return 0;
} | 0 | CPP |
import math
# https://codeforces.com/problemset/problem/1372/B
t = int(input())
res = []
i = 0
while i < t:
n = int(input())
if n % 2 == 0:
# a == b
a = int(n / 2)
res.append([a, a])
else:
k = 3
divisor = 1
while k <= math.sqrt(n):
if n % k == 0:
divisor = k
break
k += 1
if divisor == 1:
res.append([1,n - 1])
else:
b = int(n / divisor)
res.append([b, n - b])
i += 1
for e in res:
print(e[0], e[1])
| 8 | PYTHON3 |
#include <bits/stdc++.h>
int tt, n, m, i, t1, t2, t;
long long s, x, y, min;
int main() {
scanf("%d", &tt);
for (; tt > 0; --tt) {
scanf("%d%d", &n, &m);
if (m > n / 2) m = n / 2;
t1 = 0, t2 = n;
while (t1 < t2) {
t = (t1 + t2) / 2;
s = 1LL * t * m, x = n, y = 1;
for (i = 0; (i <= t) && (s >= 0) && (x > 0); ++i) {
if (x < y)
min = x;
else
min = y;
x -= min;
s -= min * i;
y = y * (t - i) / (i + 1);
}
if ((s < 0) || (x > 0))
t1 = t + 1;
else
t2 = t;
}
printf("%d\n", t1);
}
}
| 11 | CPP |
print(["IGNORE HIM!", "CHAT WITH HER!"][len(set(input()))%2 == 0]) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
bool flag = false;
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
if (flag) x = -x;
}
long long n, m, s, s1, s2;
long long a[200010], w[200010], f[3010][3010], g[3010][3010];
long long inv(long long x) {
long long v = 1, y = 998244353 - 2;
while (y) {
if (y & 1) v = v * x % 998244353;
x = x * x % 998244353, y >>= 1;
}
return v;
}
int main() {
read(n), read(m);
for (int i = 1; i <= n; ++i) read(a[i]);
for (int i = 1; i <= n; ++i) {
read(w[i]), s += w[i];
if (a[i])
s1 += w[i];
else
s2 += w[i];
}
for (int i = m; i >= 0; --i) {
f[i][m - i] = g[i][m - i] = 1;
for (int j = min(s2, m - i - 1); j >= 0; --j) {
long long iv = inv(s + i - j);
f[i][j] = ((s1 + i + 1) * iv % 998244353 * f[i + 1][j] % 998244353 +
(s2 - j) * iv % 998244353 * f[i][j + 1] % 998244353) %
998244353;
g[i][j] = ((s1 + i) * iv % 998244353 * g[i + 1][j] % 998244353 +
(s2 - j - 1) * iv % 998244353 * g[i][j + 1] % 998244353) %
998244353;
}
}
for (int i = 1; i <= n; ++i)
printf("%lld\n", w[i] * (a[i] ? f[0][0] : g[0][0]) % 998244353);
return 0;
}
| 9 | CPP |
import sys
input = sys.stdin.readline
def solve():
n, m = map(int, input().split())
if n > m:
print(0)
return
for i in range(31):
c = (1<<i)
if c > n and c > m:
r = 0
for j in range(i,-1,-1):
if n ^ r > m:
print(r)
break
if ((n ^ r) | ((1<<(j+1))-1)) <= m:
r ^= (1<<(j+1))
print(r)
return
if (m & (1<<j)) != 0:
if (n & (1<<j)) == 0:
r |= (1<<j)
if n ^ r > m:
print(r)
return
if (n ^ r) <= m:
r ^= 1
print(r)
return
print(r)
break
'''
for x in range(1000000000):
if n ^ x > m:
print(bin(n),bin(m),bin(x))
print(x)
return
'''
for i in range(int(input())):
solve()
| 9 | PYTHON3 |
n = int(input())
names = {}
for i in range(0, n):
s = input()
if s in names:
names[s] = names[s] + 1
print(s + str(names[s]))
else:
names[s] = 0
print("OK")
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, r, l, m, n, p, q, np, nl;
int flag;
while (cin >> m >> n) {
int ans = 0;
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
cin >> p >> q;
if (p == 1 || q == 1) ans++;
}
}
cout << ans << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
long long answers[t][2];
for (int i = 0; i < t; ++i) {
long long a, b, c;
cin >> a >> b >> c;
if (a < c) {
answers[i][0] = 1;
} else {
answers[i][0] = -1;
}
if (c < b * a) {
answers[i][1] = b;
} else {
answers[i][1] = -1;
}
}
for (int i = 0; i < t; ++i) {
cout << answers[i][0] << " " << answers[i][1] << endl;
}
return 0;
}
| 7 | CPP |
if __name__ == '__main__':
kirito_str, dragon_count = map(int, input().split())
dragon_list = list()
while dragon_count:
a, b = map(int, input().split())
dragon_list.append((a, b))
dragon_count-=1
dragon_list.sort()
flag = False
for a, b in dragon_list:
if kirito_str > a:
kirito_str+=b
else:
flag = True
if flag:
print("NO")
else:
print("YES") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, a;
long long ct;
int ord[600100], id[600100];
int taps(int a) { return (a + k - 1) / k; }
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i) {
cin >> ord[i];
id[ord[i]] = i;
}
for (int i = 1; i <= m; ++i) {
cin >> a;
ct += 1ll * taps(id[a]);
if (id[a] != 1) {
int prev = ord[id[a] - 1];
swap(ord[id[a]], ord[id[a] - 1]);
id[a]--;
id[prev]++;
}
}
cout << ct;
return 0;
}
| 9 | CPP |
print(sum({'Tetrahedron': 4, 'Cube': 6, 'Octahedron': 8, 'Dodecahedron': 12, 'Icosahedron': 20}[input()] for _ in range(int(input()))))
| 7 | PYTHON3 |
n=int(input())
a=[]
a=list(map(int,input().strip().split()))[:n]
m=int(input())
b=list(map(int,input().strip().split()))[:m]
print(max(a),max(b))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
namespace fast_io {
char buf[1 << 12], *p1 = buf, *p2 = buf, sr[1 << 23], z[23], nc;
int C = -1, Z = 0, Bi = 0, ny;
inline char gc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 12, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
ny = 1;
while (nc = gc(), (nc < 48 || nc > 57) && nc != EOF)
if (nc == 45) ny = -1;
Bi = 1;
if (nc < 0) return nc;
x = nc - 48;
while (nc = gc(), 47 < nc && nc < 58 && nc != EOF)
x = (x << 3) + (x << 1) + (nc ^ 48), Bi++;
return x * ny;
}
inline double find() {
int a = read(), y = ny, b = (nc != '.') ? 0 : read();
return (b ? a + (double)b / pow(10, Bi) * y : a);
}
inline int gs(char *s) {
char c, *t = s;
while (c = gc(), c <= 32)
;
*s++ = c;
while (c = gc(), c > 32) *s++ = c;
return s - t;
}
inline void ot() {
fwrite(sr, 1, C + 1, stdout);
C = -1;
}
inline void flush() {
if (C > 1 << 22) ot();
}
template <typename T>
inline void write(T x, char t) {
int y = 0;
if (x < 0) y = 1, x = -x;
while (z[++Z] = x % 10 + 48, x /= 10)
;
if (y) z[++Z] = '-';
while (sr[++C] = z[Z], --Z)
;
sr[++C] = t;
flush();
}
inline void write(char *s) {
int l = strlen(s);
for (int i = 0; i < l; i++) sr[++C] = *s++;
sr[++C] = '\n';
flush();
}
} // namespace fast_io
using namespace fast_io;
const int N = 5e5 + 5, p = 998244353, iv2 = 499122177;
int n, c, ans, f[N];
vector<int> e[N];
inline void add(int u, int v) { e[u].push_back(v), e[v].push_back(u); }
inline void M(int &x) {
x -= p;
x += x >> 31 & p;
}
void dfs(int u, int fa) {
int res = 1;
for (int v : e[u])
if (v ^ fa) dfs(v, u), res = 1ll * res * (f[v] + 1) % p * iv2 % p;
M(ans += (f[u] = p + 1 - res));
}
int main() {
n = read(), c = 1;
for (int i = 1; i < n; i++) add(read(), read()), M(c <<= 1);
dfs(1, 0);
write(2ll * ans * c % p, '\n');
return ot(), 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
const int N = 100005;
int n, m;
vector<int> g[N];
int vis[N];
int cnt;
int up[N];
bool dp[N];
int par[N];
bool dfs(int u) {
vis[u] = 1;
cnt++;
for (int v : g[u]) {
if (vis[v] == 2) return false;
if (!vis[v]) {
par[v] = u;
if (!dfs(v)) return false;
up[u] += up[v];
} else
up[u]++, up[v]--;
}
vis[u] = 2;
return true;
}
multiset<int> edges[N];
int sv[N];
void f(int u) {
vis[u] = 1;
for (int v : g[u]) {
if (!vis[v]) {
f(v);
if (edges[u].size() < edges[v].size())
;
for (int x : edges[v]) edges[u].insert(x);
edges[v].clear();
} else
edges[u].insert(v);
}
edges[u].erase(u);
if (up[u] == 1) sv[u] = *edges[u].begin();
}
void prop(int u) {
if (sv[u]) {
dp[u] &= dp[sv[u]];
}
vis[u] = 1;
for (int v : g[u])
if (!vis[v]) prop(v);
}
mt19937 rng(58);
void solve() {
int it = 100;
vector<int> ids(n);
iota(ids.begin(), ids.end(), 1);
shuffle(ids.begin(), ids.end(), rng);
for (int u : ids) {
if (--it == 0) break;
memset(vis, 0, (n + 2) * sizeof(vis[0]));
memset(up, 0, (n + 2) * sizeof(up[0]));
if (!dfs(u) or cnt < n) continue;
for (int i = 1; i <= n; i++) dp[i] = up[i] == 1;
dp[u] = 1;
par[u] = -1;
memset(vis, 0, (n + 2) * sizeof(vis[0]));
memset(sv, 0, (n + 2) * sizeof(sv[0]));
f(u);
memset(vis, 0, (n + 2) * sizeof(vis[0]));
prop(u);
vector<int> ans;
for (int i = 1; i <= n; i++)
if (dp[i]) {
ans.push_back(i);
}
if ((int)ans.size() * 5 < n) break;
for (int x : ans) printf("%d ", x);
printf("\n");
return;
}
printf("-1\n");
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
}
solve();
for (int i = 1; i <= n; i++) g[i].clear(), edges[i].clear();
}
}
| 11 | CPP |
a, b, c, k = list(map(int, input().split()))
if k % 2:
print(b - a)
else:
print(a - b) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int tele(string str, int l);
int main() {
int t;
cin >> t;
while (t--) {
int l;
cin >> l;
string str;
cin >> str;
int x = tele(str, l);
if (x == 1)
cout << "YES"
<< "\n";
if (x == -1)
cout << "NO"
<< "\n";
}
return 0;
}
int tele(string str, int l) {
int i;
for (i = 0; i < l; i++) {
if (str[i] == '8' && (l - i) >= 11) return 1;
}
return -1;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = INT_MAX;
const long long LINF = LLONG_MAX;
int a;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> a;
cout << a % 2 << endl;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
void itval(istream_iterator<string> it) {}
template <typename T, typename... Args>
void itval(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
itval(++it, args...);
}
const long long int MOD = 1e9 + 7;
template <typename T>
inline void print(T x) {
cout << x << "\n";
}
template <typename T>
inline void printvec(T x) {
for (auto a : x) cout << a << ' ';
cout << '\n';
}
struct custom {
bool operator()(
const pair<pair<long long int, long long int>, long long int> &p1,
const pair<pair<long long int, long long int>, long long int> &p2) const {
if (p1.first.first == p2.first.first) {
return p1.first.second < p2.first.second;
}
return p1.first.first < p2.first.first;
}
};
long long int get_pow(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
const long long int N = 1e5 + 5, inf = 1e18;
void solve() {
long long int n, sum = 0;
cin >> n;
vector<long long> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
sum += v[i];
}
long long int pen = 0, done = 0, time = 10, i = 0;
sort(v.begin(), v.end());
while (i < n) {
time += v[i];
if (time > 720) break;
done++;
i++;
pen += max(0ll, time - 360);
}
cout << done << ' ' << pen << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int test = 1;
clock_t z = clock();
for (long long int tes = (long long int)0; tes < (long long int)(test);
tes++) {
solve();
}
fprintf(stderr, "Total Time:%.4f\n", (double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
return 0;
}
| 10 | CPP |
t = int(input())
for _ in range(t):
n, a, b, c, d = [int(x) for x in input().split()]
if (a - b) * n > c + d or (a + b) * n < c - d:
print("No")
else:
print("Yes")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
stack<int> st;
vector<int> ds[N];
int pre[N], up[N];
int order;
bool ok;
void dfs(int u, int pa) {
pre[u] = up[u] = ++order;
st.push(u);
for (auto v : ds[u]) {
if (v == pa) continue;
if (pre[v] == 0) {
dfs(v, u);
up[u] = min(up[u], up[v]);
} else
up[u] = min(up[u], pre[v]);
}
if (pre[u] == up[u]) {
if (st.top() != u) ok = true;
while (st.top() != u) st.pop();
st.pop();
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
ds[u].push_back(v);
ds[v].push_back(u);
}
order = 0;
int ans = 0;
for (int i = 1; i <= n; i++) {
if (pre[i] != 0) continue;
ok = false;
dfs(i, 0);
if (!ok) ans++;
}
printf("%d", ans);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long n;
string ans;
cin >> n;
while(n>=1){
n--;
ans += 'a'+n%26;
n /= 26;
}
reverse(ans.begin(), ans.end());
cout << ans;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long cross(long long ax, long long ay, long long bx, long long by) {
return ax * by - bx * ay;
}
int main(int argc, char **argv) {
int N;
cin >> N;
int X[N], Y[N];
for (int i = (0); i < (N); ++i) scanf("%d%d", X + i, Y + i);
int Q;
cin >> Q;
for (int T = (0); T < (Q); ++T) {
int first, second;
cin >> first >> second;
int sep[N];
long long res = 0;
memset(sep, 0, sizeof(sep));
int next = 1;
bool valid = 1;
for (int i = (0); i < (N) && (valid); ++i)
valid = (cross(X[i] - first, Y[i] - second, X[(i + 1) % N] - first,
Y[(i + 1) % N] - second) < 0);
if (!valid) {
puts("0");
continue;
}
for (int i = (0); i < (N); ++i) {
for (sep[i] = next;; sep[i] = next) {
int next_next = (next + 1) % N;
if (cross(X[i] - first, Y[i] - second, X[next_next] - first,
Y[next_next] - second) > 0)
break;
next = next_next;
}
long long cnt = (sep[i] > i) ? (sep[i] - i) : (N + sep[i] - i);
res += (cnt * (cnt - 1)) / 2;
}
cout << ((long long)N * (N - 1) * (N - 2) / 6 - res) << endl;
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 503, mod = 998244353;
int n, m, ans;
int f[2][maxn][maxn], s[maxn];
int inv(int a) {
int b = mod - 2, ans = 1;
while (b) {
if (b & 1) ans = 1ll * ans * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
f[1][1][1] = 2;
for (int i = 2; i <= n; i++) {
memset(f[i & 1], 0, sizeof(f[i & 1]));
for (int j = 1; j <= i - 1; j++)
for (int k = 1; k <= j; k++) {
(f[i & 1][max(j, k + 1)][k + 1] += f[(i - 1) & 1][j][k]) %= mod;
(f[i & 1][j][1] += f[(i - 1) & 1][j][k]) %= mod;
}
}
for (int j = 1; j <= n; j++)
for (int k = 1; k <= n; k++) (s[j] += f[n & 1][j][k]) %= mod;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i * j < m) (ans += 1ll * s[i] * s[j] % mod) %= mod;
printf("%d", 1ll * ans * inv(2) % mod);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
int ff[17] = {0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0};
cin >> x;
cout << ff[x] << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long modular(long long a, long long b, long long c) {
if (b == 0) {
return 1;
}
if (b % 2 == 0) {
return modular(((a * a) % c), b / 2, c);
} else {
return ((a % c) * (modular(((a * a) % c), b / 2, c) % c)) % c;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
string arr[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
arr[i] = bitset<32>(a[i]).to_string();
}
long long turn = 0;
long long flag = 0;
for (long long i = 0; i < 32; i++) {
long long c1 = 0;
long long c2 = 0;
for (long long j = 0; j < n; j++) {
if (arr[j][i] == '1') {
c1++;
} else {
c2++;
}
}
if ((c1 % 4 == 1) || ((c1 % 4 == 3) && (n % 2 == 0))) {
if (turn == 0) {
flag = 1;
break;
} else {
flag = 2;
break;
}
}
if ((c1 % 4 == 3) && (n % 2 != 0)) {
if (turn == 0) {
flag = 2;
break;
} else {
flag = 1;
break;
}
}
}
if (flag == 0) {
cout << "DRAW"
<< "\n";
} else {
if (flag == 1) {
cout << "WIN"
<< "\n";
} else {
cout << "LOSE"
<< "\n";
}
}
}
return 0;
}
| 8 | CPP |
N, M = map(int, input().split())
S = [0]*M
for i in range(M):
s = list(map(int, input().split()))
for j in s[1:]:
S[i] += 2**(j-1)
p = list(map(int, input().split()))
ans = 0
for b in range(2**N):
tmp = True
for i, s in enumerate(S):
tmp &= bin(b&s).count('1')%2==p[i]
if tmp:
ans += 1
print(ans) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int>>> g;
vector<int> used;
vector<int> tout;
int timer = 0;
bool dfs(int v, int cost) {
timer++;
used[v] = 1;
for (auto to : g[v]) {
if (to.second > cost) {
if (used[to.first] == 0) {
if (!dfs(to.first, cost)) {
return false;
}
} else {
if (used[to.first] == 1) {
return false;
}
}
}
}
used[v] = 2;
++timer;
tout[v] = timer;
return true;
}
struct edge {
int a, b, c, index;
};
int main() {
int n, m;
int a, b, c;
cin >> n >> m;
g.resize(n);
tout.resize(n);
vector<pair<int, int>> index;
vector<edge> E;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
--a;
--b;
g[a].push_back(make_pair(b, c));
index.push_back(make_pair(i + 1, c));
edge e;
e.a = a;
e.b = b;
e.c = c;
e.index = i + 1;
E.push_back(e);
}
int L = -1;
int R = 1e9;
while (R - L > 1) {
int M = (R + L) / 2;
used.clear();
used.resize(n, 0);
bool q = true;
for (int i = 0; i < n; i++) {
if (used[i] == 0) {
if (!dfs(i, M)) {
q = false;
break;
}
}
}
if (q) {
R = M;
} else {
L = M;
}
}
int k = 0;
timer = 0;
used.clear();
used.resize(n, 0);
bool q = true;
for (int i = 0; i < n; i++) {
if (used[i] == 0) {
if (!dfs(i, R)) {
q = false;
break;
}
}
}
vector<int> ans;
for (int i = 0; i < m; i++) {
if (E[i].c <= R && tout[E[i].a] <= tout[E[i].b]) {
k += 1;
ans.push_back(E[i].index);
}
}
cout << R << " " << k << endl;
for (int i = 0; i < k; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b;
cin >> n >> m >> a >> b;
cout << min(n * a, (n / m) * b + min(b, (n % m) * a));
}
| 7 | CPP |
#include <iostream>
#include<bits/stdc++.h>
using namespace std;
vector<int> G[200000];
int bi[200000];
int n,m;
bool dfs(int v,int c){
bi[v]=c;
for(auto p:G[v]){
if(bi[p]==c)return false;
if(bi[p]==0&&!dfs(p,-c))return false;
}
return true;
}
int main(void){
cin>>n>>m;
for(int i=0;i<n;i++){
int k;
cin>>k;
for(int j=0;j<k;j++){
int K;
cin>>K;
G[i].push_back(n-1+K);
G[n-1+K].push_back(i);
}
}
bool ok=true;
dfs(0,1);
for(int i=0;i<n;i++){
if(!bi[i])ok=false;
}
if(ok)cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(){
int A,B,C; long long K; cin >> A >> B >> C >> K;
cout << (K%2==0?A-B:B-A) << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct EDGE {
int u, v;
} edge[1000000];
vector<int> conn[1000000];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
int i;
for (i = 0; i < m; ++i) {
scanf("%d%d", &edge[i].u, &edge[i].v);
--edge[i].u;
--edge[i].v;
conn[edge[i].u].push_back(edge[i].v);
conn[edge[i].v].push_back(edge[i].u);
}
long long total = 0;
for (i = 0; i < n; ++i)
total += (n - 1 - conn[i].size()) * (long long)conn[i].size();
total /= 2;
total = (long long)n * (n - 1) / 2 * (n - 2) / 3 - total;
printf("%I64d\n", total);
}
}
| 11 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.