solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (b > 0) {
long long tmp = a;
a = b;
b = tmp % b;
}
return a;
}
const int M = 1e9 + 7;
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res % mod;
}
const int N = 1e5 + 1;
const long long inf = 1e18 + 10;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long ans = n;
vector<long long> div;
for (long long i = 2; i * i <= n; ++i) {
if (n % i == 0) {
div.push_back(i);
if (i != n / i) div.push_back(n / i);
}
}
long long g = 0;
for (int i = 0; i < div.size(); ++i) {
g = gcd(div[i], g);
}
if (g != 0) ans = g;
cout << ans << endl;
return 0;
}
| 7 | CPP |
da, db = map(int,input().split())
if da == db:
print(str(da) + "12", str(db) + "13")
elif da == 9 and db == 1:
print(9, 10)
elif da+1 == db:
print(str(da) + "9", str(db) + "0")
else:
print(-1)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s; cin >> s; int c = 0;
for (char e : s) if (e - 'x') c++;
cout << (7 + c) * 100 << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, c = 0, d = 0, e = 0, f = 0;
cin >> n;
string a, b;
cin >> a >> b;
for (int i = 0; i < n; i++) {
if (a[i] == '1') c++;
if ((a[i] == '0') && (b[i] == '0')) d++;
if (a[i] == '0' and (b[i] == '1')) e++;
if ((a[i] == '1') and (b[i] == '0')) f++;
}
cout << (c * d) + (e * f);
}
| 8 | CPP |
a, b=[int(j) for j in input().split()]
p, v, n=0, 0, 0
for i in range(6):
if abs(i+1-a)<abs(i+1-b):
p+=1
elif abs(i+1-b)<abs(i+1-a):
v+=1
else:
n+=1
print(p, n, v) | 7 | PYTHON3 |
m = int(input())
pos = dict()
arr = list()
for i in range(m):
p = eval(input())
arr.append(p)
if p in pos:
pos[p] += 1
else:
pos[p] = 1
for i in arr:
print(pos[i])
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, k, a[N], d[N];
int main() {
cin >> n >> k;
for (int i = (1); i <= (n); i++) scanf("%d", &a[i]);
for (int i = (1); i <= (n); i++) scanf("%d", &d[i]);
long long ans = 0;
if (k == 0) {
long long su = 0;
for (int i = (n); i >= (1); i--) su += a[i], ans = max(ans, su - d[i]);
} else if (k == 1) {
long long su = 0;
int mi = 1e9;
for (int i = (1); i <= (n - 1); i++) su += a[i], mi = min(mi, d[i]);
ans = max(ans, su - mi);
su = 0, mi = 1e9;
for (int i = (n); i >= (2); i--)
su += a[i], ans = max(ans, su - d[i]), mi = min(mi, a[i]);
ans = max(ans, su + a[1] - mi - d[1]);
sort(d + 1, d + n + 1);
ans = max(ans, su + a[1] - d[1] - d[2]);
} else {
long long su = 0;
int mi = 1e9;
for (int i = (1); i <= (n - 1); i++) su += a[i], mi = min(mi, d[i]);
ans = max(ans, max(0LL + a[n] - d[n], su + a[n] - mi));
}
cout << ans;
return 0;
}
| 11 | CPP |
# from itertools import *
# from collections import Counter
def line(conv=int, fl=0):
inp = input().split()
if len(inp)==1 and not fl:
return conv(inp[0])
return map(conv, inp)
n = line()
h = [list(line(fl=1)), list(line(fl=1))]
a = zip(*h)
m = [0,0]
for a0,a1 in a:
nm=[0,0]
nm[0] = max(m[0], m[1]+a0)
nm[1] = max(m[1], m[0]+a1)
m = nm
print(max(m)) | 9 | PYTHON3 |
import sys
from math import gcd
n = int(input())
a = list(map(int, input().split()))
ans = [a[0]]
for i in range(1, n):
if gcd(a[i-1], a[i]) != 1:
for j in range(2, 10**9):
if gcd(a[i-1], j) == 1 and gcd(a[i], j) == 1:
ans.append(j)
break
ans.append(a[i])
print(len(ans) - n)
print(*ans)
| 7 | PYTHON3 |
N = int(input())
crimes = list(map(int,input().split()))
sol = hired=0
for el in crimes:
if el>0:
hired+=el
continue
if hired>0 and el<0:
hired-=1
continue
if el<0:
sol+=1
print(sol) | 7 | PYTHON3 |
from sys import stdin
input = stdin.readline
def main():
test = int(input())
for _ in range(test):
n = int(input())
l = [int(i) for i in input().split(" ")]
# s = input().strip()
# n = l[0]
# m = l[1]
# a = l[2]
# b = l[3]
#
# l = []
# l = [int(i) for i in input().split(" ")]
#
# for i in l:
# print(i, end=' ')
l.sort()
count = 1
i = 0
while i < n:
if i+1 >= l[i]:
count = max(count, i+2)
i += 1
print(count)
main()
| 8 | PYTHON3 |
#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstdio>
#include<cassert>
#include<vector>
#include<deque>
using namespace std;
typedef pair<int,int> P;
int n,m,cnt;
int mincost[110][110];
bool visited[110][110];
int dx[2][6] = {{-1,+0,1,0,-1,-1},{+0,+1,1,1,0,-1}};
int dy[2][6] = {{-1,-1,0,1,+1,+0},{-1,-1,0,1,1,+0}};
bool f;
void dfs(int x,int y,int cost)
{
//if(!f)
//cout << "xy = " << x << "," << y << " cost = " << cost << endl;
for(int i=0;i<6;i++)
{
int nx = x + dx[y%2][i];
int ny = y + dy[y%2][i];
if(!(0 <= nx && nx < m && 0 <= ny && ny < n))
continue;
//if(!f)cout << "mincost["<<ny<<"]["<<nx<<"] = " << mincost[ny][nx] << " = cost + 1 = " << cost + 1 << endl;
if(mincost[ny][nx] > cost+1)
{
if(!visited[ny][nx])
cnt++;
visited[ny][nx] = true;
mincost[ny][nx] = cost + 1;
dfs(nx,ny,cost+1);
}
}
}
int main()
{
while(true)
{
cin >> m;
if(!m) break;
cin >> n;
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
mincost[i][j] = (1<<29);
f = true;
int s,t,mex = 0;
scanf("%d",&s);
for(int i=0;i<s;i++)
{
int x,y;
scanf("%d %d",&x,&y);
x--,y--;
mincost[y][x] = 0;
dfs(x,y,0);
}
f = false;
scanf("%d",&t);
for(int i=0;i<t;i++)
{
int pre_mincost[n][m];
for(int j=0;j<n;j++)
for(int k=0;k<m;k++)
pre_mincost[j][k] = mincost[j][k],visited[j][k] = false;
int p,q;
scanf("%d %d",&p,&q);
cnt = 1,p--,q--;
mincost[q][p] = 0,visited[q][p] = true;
dfs(p,q,0);
mex = max(mex,cnt);
for(int j=0;j<n;j++)
for(int k=0;k<m;k++)
mincost[j][k] = pre_mincost[j][k];
}
cout << mex << endl;
}
return 0;
} | 0 | CPP |
#include <queue>
#include <vector>
#include <iostream>
#include <functional>
#pragma warning(disable : 4996)
#define INF (1 << 23)
using namespace std;
int main()
{
int N, M, s, t, u, v;
scanf("%d", &N);
scanf("%d", &M);
scanf("%d", &s); s--;
scanf("%d", &t); t--;
vector<vector<int> > G(N);
for (int i = 0; i < M; i++)
{
scanf("%d", &u);
scanf("%d", &v);
G[u - 1].push_back(v - 1);
G[v - 1].push_back(u - 1);
}
vector<int> d1(N, INF); d1[s] = 0;
vector<int> d2(N, INF); d2[t] = 0;
queue<int> que;
que.push(s);
while (!que.empty())
{
int node = que.front(); que.pop();
for (int i = 0; i < G[node].size(); i++)
{
if (d1[G[node][i]] == INF)
{
d1[G[node][i]] = d1[node] + 1; que.push(G[node][i]);
}
}
}
que.push(t);
while (!que.empty())
{
int node = que.front(); que.pop();
for (int i = 0; i < G[node].size(); i++)
{
if (d2[G[node][i]] == INF)
{
d2[G[node][i]] = d2[node] + 1; que.push(G[node][i]);
}
}
}
int shortest = d1[t];
vector<int> r1(shortest - 1, 0); for (int i = 0; i < N; i++) { if (d1[i] < shortest - 1) { r1[d1[i]]++; } }
vector<int> r2(shortest - 1, 0); for (int i = 0; i < N; i++) { if (d2[i] < shortest - 1) { r2[d2[i]]++; } }
long long ret = 0;
for (int i = 0; i < shortest - 1; i++)
{
ret += 1LL * r1[i] * r2[shortest - i - 2];
}
printf("%lld\n", ret);
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MAXN = 1000 * 1000;
set<pair<int, int> > is;
int deg[MAXN], x[MAXN];
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> deg[i] >> x[i];
is.insert(make_pair(deg[i], i));
}
vector<pair<int, int> > ans;
while (!is.empty()) {
int v = is.begin()->second;
is.erase(is.begin());
if (deg[v] > 0) {
int ne = x[v];
ans.push_back(make_pair(v, ne));
is.erase(is.find(make_pair(deg[ne], ne)));
deg[ne]--;
x[ne] ^= v;
is.insert(make_pair(deg[ne], ne));
}
}
cout << ans.size() << "\n";
for (int i = 0; i < (int)ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << "\n";
}
return 0;
}
| 7 | CPP |
n,k = map(int, input().split())
res = 10000000000000
for x in map(int, input().split()):
if k%x == 0 and k//x < res:
res = k//x
print(res) | 7 | PYTHON3 |
s1=input()
s2=input()
s1=str(s1)
s2=str(s2)
S1=[]
S2=[]
S1=list(s1)
S2=list(s2)
ln=len(S1)
y=0
l1=int(0)
l2=int(0)
i=int(0)
while(i<ln+1):
if(i==ln):
y=1
break
p=ord(S1[i])
q=ord(S2[i])
if(p>90):
p=p-32
if(q>90):
q=q-32
if(p<q):
print(-1)
break
elif(q<p):
print(1)
break
i+=1
if(y==1):
print(0)
| 7 | PYTHON3 |
from sys import stdin, stdout
input, print = stdin.readline, stdout.write
def main():
answers = []
for q11 in range(int(input())):
n = int(input())
a = sorted(list(map(int, input().split())))
ans = q1 = max1 = 0
for q in range(n):
max1 = max(max1, a[q]+q1-1)
if max1 <= q:
ans += 1
q1 = max1 = q+1
answers.append(str(ans))
print('\n'.join(answers))
print('\n')
main()
| 8 | PYTHON3 |
a=input()
b=input()
c=input()
info=a.split()
info=list(map(int, info))
y=b.split()
powers=list(map(int, y))
z=c.split()
coins=list(map(int, z))
l=sorted(zip(powers,coins,range(info[0])))
final=[0]*info[0]
s=0
w=[]
for _, c, i in l:
s+=c
final[i]=s
w=sorted(w+[c])
if len(w)>info[1]:
s-=w[0]
del w[0]
print(*final)
| 8 | PYTHON3 |
n=int(input())
l=list(input().split())
l=[int(i) for i in l]
winner=1
for i in l:
if not i%2:
winner=not winner
print(int(winner)+1)
else:
print(int(winner)+1)
| 8 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
if n >= 3:
if n % 4 == 0:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <iostream>
int main() {
int a, b, c, d;
std::cin >> a >> b >> c >> d;
std::cout << std::min(a, b) + std::min(c, d) << std::endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
namespace fastIO {
bool IOerror = 0;
inline char nc() {
static char buf[100000], *p1 = buf + 100000, *pend = buf + 100000;
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, 100000, stdin);
if (pend == p1) {
IOerror = 1;
return -1;
}
}
return *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline void read(long long &x) {
char ch;
while (blank(ch = nc()))
;
if (IOerror) return;
for (x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0')
;
}
}; // namespace fastIO
using namespace fastIO;
char ss[100][100];
int n, m;
int mark[60][60];
int dir[4][2] = {0, 1, 0, -1, 1, 0, -1, 0};
int flag = 0;
void dfs(int y, int x, char c, int k) {
mark[y][x] = 1;
for (int i = 0; i < 4; i++) {
if (i == 3 && k == 2) {
continue;
}
if (i == 2 && k == 3) {
continue;
}
if (i == 1 && k == 0) {
continue;
}
if (i == 0 && k == 1) {
continue;
}
int xx = x + dir[i][0];
int yy = y + dir[i][1];
if (xx >= 0 && xx < m && yy >= 0 && yy < n) {
if (ss[yy][xx] == c && mark[yy][xx] == 1) {
flag = 1;
return;
}
if (ss[yy][xx] == c && mark[yy][xx] == 0) {
dfs(yy, xx, c, i);
}
if (flag == 1) {
return;
}
}
}
}
int main() {
int num[27] = {0};
cin >> n >> m;
for (int i = 0; i < n; i++) {
scanf("%s", ss[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
num[ss[i][j] - 'A']++;
}
}
for (int j = 0; j <= 26; j++) {
if (num[j] >= 4) {
char c = 'A' + j;
memset(mark, 0, sizeof(mark));
for (int i = 0; i < n; i++) {
for (int k = 0; k < m; k++) {
if (mark[i][k] == 0 && ss[i][k] == c) {
dfs(i, k, c, -1);
if (flag == 1) {
printf("Yes\n");
return 0;
}
}
}
}
}
}
printf("No\n");
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
long long a, b, x, y;
long long gcd(long long q, long long w) {
if (!w) return q;
return gcd(w, q % w);
}
int main() {
scanf("%I64d %I64d %I64d %I64d", &a, &b, &x, &y);
long long G = gcd(x, y);
x /= G;
y /= G;
long long ans = std::min((long long)(a / x), (long long)(b / y));
printf("%I64d", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 21, M = 1 << 20;
int n, m, Cnt[M + 5];
double p[N], f[2][M + 5], g[M + 5];
void solve(int l, int r) {
if (l == r - 1) return;
int mid = l + r >> 1;
solve(l, mid);
solve(mid, r);
for (int i = l, j = mid; i < mid; i++, j++)
f[0][j] += f[0][i], f[1][j] += f[1][i];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%lf", &p[i]);
int T = 1 << n;
for (int i = 0; i < T; i++) {
if (i) Cnt[i] = Cnt[i ^ (i & -i)] + 1;
if (Cnt[i] >= m) continue;
double s = 0;
for (int j = 0; j < n; j++)
if (((1 << j) & i) > 0) s += p[j];
f[Cnt[i] & 1][i] = (s < 1) ? 1.0 / (1 - s) : 0;
f[(Cnt[i] & 1) ^ 1][i] = 0;
}
solve(0, T);
for (int i = 0; i < T; i++) g[i] = f[Cnt[i] & 1][i] - f[(Cnt[i] & 1) ^ 1][i];
for (int i = 0; i < n; i++) {
double ans = 0;
for (int j = 0; j < T; j++)
if (((1 << i) & j) == 0 && Cnt[j] < m) ans += p[i] * g[j];
printf("%.10lf ", ans);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
set<pair<int, double> > arrivePoints, leavePoints;
int n, width, busSpeed, walkSpeed;
void addEdge(pair<int, int> newPoint, pair<int, int> lastPoint) {
if (newPoint.second > lastPoint.second) {
leavePoints.insert(pair<int, double>(
lastPoint.second, ((double)lastPoint.first) / ((double)busSpeed)));
leavePoints.insert(pair<int, double>(
newPoint.second, ((double)newPoint.first) / ((double)busSpeed)));
} else if (newPoint.second < lastPoint.second) {
arrivePoints.insert(pair<int, double>(
lastPoint.second, ((double)lastPoint.first) / ((double)busSpeed)));
arrivePoints.insert(pair<int, double>(
newPoint.second, ((double)newPoint.first) / ((double)busSpeed)));
} else if (newPoint.first > lastPoint.first) {
leavePoints.insert(pair<int, double>(
lastPoint.second, ((double)lastPoint.first) / ((double)busSpeed)));
arrivePoints.insert(pair<int, double>(
newPoint.second, ((double)newPoint.first) / ((double)busSpeed)));
} else {
arrivePoints.insert(pair<int, double>(
lastPoint.second, ((double)lastPoint.first) / ((double)busSpeed)));
leavePoints.insert(pair<int, double>(
newPoint.second, ((double)newPoint.first) / ((double)busSpeed)));
}
}
double maximum(double a, double b) { return (a > b ? a : b); }
int main() {
scanf("%d %d %d %d", &n, &width, &busSpeed, &walkSpeed);
pair<int, int> lastPoint, firstPoint;
scanf("%d %d", &lastPoint.first, &lastPoint.second);
firstPoint.first = lastPoint.first;
firstPoint.second = lastPoint.second;
for (int i = 0; i < n - 1; i++) {
pair<int, int> newPoint;
scanf("%d %d", &newPoint.first, &newPoint.second);
addEdge(newPoint, lastPoint);
lastPoint.first = newPoint.first;
lastPoint.second = newPoint.second;
}
addEdge(firstPoint, lastPoint);
bool goFirst = true;
for (set<pair<int, double> >::iterator it = arrivePoints.begin();
goFirst && it != arrivePoints.end(); ++it) {
if (it->second < ((double)it->first) / ((double)walkSpeed)) {
goFirst = false;
}
}
if (goFirst) {
printf("%0.14f", ((double)width) / ((double)walkSpeed));
} else {
double maxDelay = 0;
for (set<pair<int, double> >::iterator it = leavePoints.begin();
it != leavePoints.end(); ++it) {
maxDelay = maximum(
maxDelay, it->second - (((double)it->first) / ((double)walkSpeed)));
}
printf("%0.14f", maxDelay + ((double)width) / ((double)walkSpeed));
}
scanf("%d", &n);
}
| 9 | CPP |
n,x,y=map(int,input().split())
l=list(map(int,input().split()))
for i in range(0,n):
day=l[i]
p=i-x
if p<0:
p=0
li1=l[p:i]
k=i+y+1
if k>n:
k=n
li2=l[i+1:k]
li1.append(9999999999)
li2.append(9999999999)
if min(li1)>day and min(li2)>day:
break
print(l.index(day)+1) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int c = 0, r, d, a, s;
a = n;
while (n) {
if (n >= 10) {
r = n / 10;
n -= r * 10;
n += r;
c += r * 10;
} else {
c += n;
n /= 10;
}
}
cout << c << endl;
}
}
| 8 | CPP |
t=int(input())
for i in range(t):
a,b= map(int,input().split())
if a > b:
a,b=b,a
if((a+b)%3==0 and a*2>=b):
print("YES")
else:
print("NO") | 8 | PYTHON3 |
import math
def counter(n):
z=[]
i=1
while i<=math.sqrt(n):
if n%i==0:
if n/i==i:
z.append(i)
else:
z.append(i)
z.append(n/i)
i+=1
print(len(z))
n=int(input())
a=list(map(int,input().split()))
if n==1:
counter(a[0])
else:
gc=math.gcd(a[0],a[1])
for i in range(2,n):
gc=math.gcd(gc,a[i])
counter(gc)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int id;
char c;
} tmp;
stack<Node> s;
char cc[100005];
int x[100005];
int dis[100005];
bool ok(char a, char b) {
if (a == '[' && b == ']') return 1;
if (a == '(' && b == ')') return 1;
return 0;
}
int main(int argc, char** argv) {
while (!s.empty()) s.pop();
int n;
scanf(" %s", cc);
n = strlen(cc);
tmp.id = 0;
tmp.c = '.';
s.push(tmp);
memset(dis, 0, sizeof(dis));
for (int i = (0); i < (n); i++) {
if (ok(s.top().c, cc[i])) {
s.pop();
x[i + 1] = s.top().id;
} else {
tmp.c = cc[i];
tmp.id = i + 1;
s.push(tmp);
x[i + 1] = i + 1;
}
}
for (int i = (0); i < (n); i++) {
if (cc[i] == '[')
dis[i + 1] = dis[i] + 1;
else
dis[i + 1] = dis[i];
}
int u = -1;
int tmp = -1;
for (int i = (1); i < (n + 1); i++) {
if (x[i] != i) {
if (dis[i] - dis[x[i]] > tmp) {
u = i;
tmp = dis[i] - dis[x[i]];
}
}
}
if (u == -1) {
printf("0\n");
return 0;
}
printf("%d\n", tmp);
for (int i = (x[u]); i < (u); i++) printf("%c", cc[i]);
printf("\n");
return 0;
}
| 9 | CPP |
i = input()
n = int(i.split(' ')[0])
k = int(i.split(' ')[1])
a = input()
a = [int(x) for x in a.split(' ')]
limit = a[k-1]
cnt = 0
for x in a:
cnt = cnt+1 if x > 0 and x >= limit else cnt
print(cnt) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
struct data {
int ok, open, close;
data() {}
data(int _ok, int _open, int _close) {
ok = _ok, open = _open, close = _close;
}
data operator+(const data &temp) const {
data ret;
ret = data(ok + min(open, temp.close) + temp.ok,
temp.open + open - min(open, temp.close),
close + temp.close - min(open, temp.close));
return ret;
}
void print() {
cout << "(" << ok << "," << open << "," << close << ")" << endl;
}
};
string s;
int n;
data T[maxn * 4];
void build(int node, int b, int e) {
if (b == e) {
if (s[b] == '(') {
T[node] = data(0, 1, 0);
} else {
T[node] = data(0, 0, 1);
}
return;
}
build((node << 1), b, ((b + e) >> 1));
build(((node << 1) | 1), ((b + e) >> 1) + 1, e);
T[node] = T[(node << 1)] + T[((node << 1) | 1)];
}
data query(int node, int b, int e, int i, int j) {
if (b > j or e < i) return data(0, 0, 0);
if (i <= b and e <= j) return T[node];
return query((node << 1), b, ((b + e) >> 1), i, j) +
query(((node << 1) | 1), ((b + e) >> 1) + 1, e, i, j);
}
int main() {
cin >> s;
n = s.size();
build(1, 0, n - 1);
int m;
cin >> m;
while (m--) {
int l, r;
cin >> l >> r;
l--, r--;
cout << query(1, 0, n - 1, l, r).ok * 2 << endl;
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int number = 0;
int si;
cin >> si;
int ar[si];
for (int i = 0; i < si; i++) {
cin >> ar[i];
if (ar[i] == 0) {
number++;
}
}
if (si == 1) {
if (ar[0] == 1) {
cout << "YES";
} else {
cout << "NO";
}
} else if (number == 1) {
cout << "YES";
} else {
cout << "NO";
}
ar[0];
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool tomax(T &x, T y) {
if (x < y) return x = y, 1;
return 0;
}
template <class T>
bool tomin(T &x, T y) {
if (x > y) return x = y, 1;
return 0;
}
int A[300005], n;
long long ans;
int mark[300005], Ti;
int cnt[300005 + 300005], Mi[300005], Mx[300005];
void Move(int r, int &p, int to) {
if (p > to) return;
for (; p <= r && p != to; p++) cnt[Mx[p] + p]--;
}
void Move2(int l, int &p, int to) {
for (; l <= p && Mx[p] <= to; p--) cnt[Mx[p] + p]--;
}
long long Solve(int L, int mid, int R) {
Ti++;
int mx = 0, lok;
long long ret = 0;
for (int i = mid, sz = 1; i >= L; i--, sz++) {
if (mark[A[i]] == Ti) break;
mark[A[i]] = Ti;
tomax(mx, A[i]);
if (mx == sz) ret++;
lok = i;
}
Ti++, mx = 0;
for (int i = mid, sz = 1; i <= R; i++, sz++) {
if (mark[A[i]] == Ti) break;
mark[A[i]] = Ti;
tomax(mx, A[i]);
if (mx == sz) ret++;
}
ret--;
if (L == mid || R == mid || lok == mid) return ret;
for (int i = L; i <= R; i++) Mi[A[i]] = -1;
for (int i = L; i <= mid; i++) Mi[A[i]] = i;
Mx[mid] = 0;
for (int i = mid - 1; i >= lok; i--) Mx[i] = max(Mx[i + 1], A[i]);
for (int i = lok; i < mid; i++) cnt[Mx[i] + i] = 0;
for (int i = mid + 1; i <= R; i++) cnt[i + 1] = 0;
for (int i = lok; i < mid; i++) cnt[Mx[i] + i]++;
Mx[mid] = 1;
Ti++, mx = 0;
int lx = lok, rx = mid - 1;
for (int i = mid + 1; i <= R; i++) {
if (mark[A[i]] == Ti) break;
mark[A[i]] = Ti;
tomax(mx, A[i]);
Move(mid - 1, lx, Mi[A[i]] + 1);
Move2(L, rx, mx);
int Lp = i - mx + 1;
if (Lp >= lx && Lp < mid && Mx[Lp] <= mx) ret++;
if (rx >= lx) ret += cnt[i + 1];
}
return ret;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
vector<int> g;
for (int i = 1; i <= n; i++)
if (A[i] == 1) g.push_back(i);
int sz = (int)g.size();
if (!sz) return cout << 0, 0;
if (sz == 1)
return cout << Solve(1, g[0], n), 0;
else {
int last = 0;
for (int i = 0; i < sz - 1; i++)
ans += Solve(last + 1, g[i], g[i + 1] - 1), last = g[i];
ans += Solve(last + 1, g[sz - 1], n);
}
printf("%lld\n", ans);
return 0;
}
| 12 | CPP |
#include<iostream>
using namespace std;
int main(){
int days,sj,sm,j,m;
cin >> days >> sj >> sm >> j >> m;
while(1){
if(sj<=0 && sm<=0)break;
sj-=j;
sm-=m;
days--;
}
cout << days << endl;
return 0;
} | 0 | CPP |
s=[]
for i in range(1,11):
s1=int(input())
s.append(s1)
print(sum(s))
| 0 | PYTHON3 |
x = int(input())
sum = 0
for i in range(x):
ls = [int(i) for i in input().split()]
if ls.count(1) > ls.count(0):
sum += 1
print(sum)
| 7 | PYTHON3 |
import sys
n = int(input())
blocks = []
for line in sys.stdin.readlines():
w, s, v = map(int, line.split())
blocks.append((w + s, w, s, v))
blocks.sort()
dp = [-1] * 20001
dp[0] = 0
for _, w, s, v in blocks:
for i in range(min(s, 20000 - w), -1, -1):
dp[i + w] = max(dp[i + w], dp[i] + v)
print(max(dp))
| 0 | PYTHON3 |
n = int(input())
a = list(map(int, input().split()))
def factorization(n):
ret = dict()
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
ret[i] = cnt
if temp!=1:
ret[temp] = 1
if len(ret) == 0:
ret[n] = 1
return ret
import math
L = [0]*(n)
R = [0]*(n)
L[0] = a[0]
R[-1] = a[-1]
for i in range(1,n):
L[i] = math.gcd(L[i-1], a[i])
for i in range(n-2,-1,-1):
R[i] = math.gcd(R[i+1], a[i])
d = dict()
for i in range(n):
k = 1
if i == 0:
k = R[i+1]
elif i == n-1:
k = L[i-1]
else:
k = math.gcd(L[i-1], R[i+1])
primes = factorization(k)
for x in primes:
if x not in d:
d[x] = 0
d[x] = max(d[x], primes[x])
ans = 1
for x in d:
ans *= x**d[x]
print(ans) | 7 | PYTHON3 |
import sys, os
import heapq, functools, collections
import math, random
from collections import Counter, defaultdict
# available on Google, not available on Codeforces
# import numpy as np
# import scipy
def solve_(g,n,m):
og = [[x for x in row] for row in grid]
# your solution here
x,y = 0,0
res = []
# leave the last two rows out
# crawl based on top row
for y in range(n-2): # special consideration for last two rows
for x in range(m-1): # special consideration for last column
if g[y][x] == 0:
continue
if g[y][x] == 1 and g[y][x+1] == 1:
if g[y+1][x] == 1:
r = [(y,x), (y,x+1), (y+1,x)]
else:
r = [(y,x), (y,x+1), (y+1,x+1)]
if g[y][x] == 1 and g[y][x+1] == 0:
r = [(y,x), (y+1,x), (y+1,x+1)]
#
assert len(r) == 3
assert len(set(r)) == 3
res.append(r)
for yy,xx in r:
g[yy][xx] = 1-g[yy][xx]
#
assert x+1 == m-1
if g[y][x] == 0 and g[y][x+1] == 0:
continue
elif g[y][x] == 1 and g[y][x+1] == 0:
r = [(y,x), (y+1,x), (y+1,x+1)]
elif g[y][x] == 0 and g[y][x+1] == 1:
r = [(y,x+1), (y+1,x), (y+1,x+1)]
elif g[y][x] == 1 and g[y][x+1] == 1:
r = [(y,x), (y,x+1), (y+1,x)]
#
assert len(r) == 3
assert len(set(r)) == 3
res.append(r)
for yy,xx in r:
g[yy][xx] = 1-g[yy][xx]
#
# console(y, n-3)
# assert y == n-3
for x in range(m-2):
if g[-2][x] == 0 and g[-1][x] == 0:
continue
if g[-2][x] == 1 and g[-1][x] == 0:
r = [(-2,x), (-2,x+1), (-1,x+1)]
if g[-2][x] == 0 and g[-1][x] == 1:
r = [(-1,x), (-2,x+1), (-1,x+1)]
if g[-2][x] == 1 and g[-1][x] == 1:
if g[-2][x+1] == 1:
r = [(-2,x), (-1,x), (-2,x+1)]
else:
r = [(-2,x), (-1,x), (-1,x+1)]
#
assert len(r) == 3
assert len(set(r)) == 3
res.append(r)
for yy,xx in r:
g[yy][xx] = 1-g[yy][xx]
#
l4 = [(-2,-2), (-2,-1), (-1,-2), (-1,-1)]
if g[-2][-2] + g[-2][-1] + g[-1][-2] + g[-1][-1] == 4:
console("resolve 4")
r = l4[:3]
#
assert len(r) == 3
assert len(set(r)) == 3
res.append(r)
for yy,xx in r:
g[yy][xx] = 1-g[yy][xx]
# console(grid)
#
if g[-2][-2] + g[-2][-1] + g[-1][-2] + g[-1][-1] == 1:
console("resolve 1")
for i,(y,x) in enumerate(l4 + l4):
if g[y][x] == 1:
r = (l4+l4)[i:i+3]
break
#
assert len(r) == 3
assert len(set(r)) == 3
res.append(r)
for yy,xx in r:
g[yy][xx] = 1-g[yy][xx]
# console(grid)
#
if g[-2][-2] + g[-2][-1] + g[-1][-2] + g[-1][-1] == 2:
console("resolve 2")
sett = set()
for i,(y,x) in enumerate(l4 + l4 + l4):
if g[y][x] == 0:
sett.add((y,x))
if len(sett) == 2:
sett.add((y,x))
if len(sett) == 3:
break
r = list(sett)
#
assert len(r) == 3
assert len(set(r)) == 3
res.append(r)
for yy,xx in r:
g[yy][xx] = 1-g[yy][xx]
#
# console(grid)
if g[-2][-2] + g[-2][-1] + g[-1][-2] + g[-1][-1] == 3:
console("resolve 3")
r = []
for i,(y,x) in enumerate(l4):
if g[y][x] == 1:
r.append((y,x))
#
assert len(r) == 3
assert len(set(r)) == 3
res.append(r)
for yy,xx in r:
g[yy][xx] = 1-g[yy][xx]
#
# console(res)
res2 = []
for re in res:
re2 = []
for a,b in re:
if a < 0:
a = n+a
if b < 0:
b = m+b
re2.extend((a+1,b+1))
res2.append(re2)
# console(res2)
# console(grid)
assert sum(sum(row) for row in grid) == 0
for x1,y1,x2,y2,x3,y3 in res2:
x1,y1,x2,y2,x3,y3 = x1-1,y1-1,x2-1,y2-1,x3-1,y3-1
og[x1][y1] = 1 - og[x1][y1]
og[x2][y2] = 1 - og[x2][y2]
og[x3][y3] = 1 - og[x3][y3]
assert sum(sum(row) for row in og) == 0
assert len(res2) <= n*m
return res2
def console(*args):
# print on terminal in different color
print('\033[36m', *args, '\033[0m', file=sys.stderr)
pass
# import random
# while True:
# grid = [[int(random.random()) for _ in range(4)] for _ in range(4)]
# solve_(grid,3,3)
# # break
ONLINE_JUDGE = False
# if Codeforces environment
if os.path.exists('input.txt'):
ONLINE_JUDGE = True
if ONLINE_JUDGE:
sys.stdin = open("input.txt","r")
sys.stdout = open("output.txt","w")
def console(*args):
pass
def solve(*args):
# screen input
if not ONLINE_JUDGE:
console("----- solving ------")
console(*args)
console("----- ------- ------")
return solve_(*args)
if True:
# if memory is not a constraint
inp = iter(sys.stdin.readlines())
input = lambda: next(inp)
else:
# if memory is a constraint
input = sys.stdin.readline
for case_num in range(int(input())):
# read line as a string
# strr = input()
# read line as an integer
# k = int(input())
# read one line and parse each word as a string
# lst = input().split()
# read one line and parse each word as an integer
n,m = list(map(int,input().split()))
# read matrix and parse as integers (after reading read nrows)
# lst = list(map(int,input().split()))
# nrows = lst[0] # index containing information, please change
grid = []
for _ in range(n):
grid.append(list(map(int,list(input().strip()))))
res = solve(grid,n,m) # please change
# print result
# Google - case number required
# print("Case #{}: {}".format(case_num+1, res))
# Codeforces - no case number required
print(len(res))
for r in res:
print(*r) # if printing a list | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long a[55], b[55];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t, n;
cin >> t;
while (t-- > 0) {
cin >> n;
long long mina = 1000000005LL, minb = 1000000005LL, ans = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
mina = min(mina, a[i]);
}
for (long long i = 0; i < n; i++) {
cin >> b[i];
minb = min(minb, b[i]);
}
for (long long i = 0; i < n; i++) {
ans += max(a[i] - mina, b[i] - minb);
}
cout << ans << '\n';
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
const vector<long long int> dx = {1, -1, 0, 0};
const vector<long long int> dy = {0, 0, 1, -1};
template <typename T = long long int>
vector<T> ga(long long int n, bool oneIndexed = false) {
vector<T> a = vector<T>(n + oneIndexed);
for (long long int i = 0; i < n; i++) {
T p;
cin >> p;
a[i + oneIndexed] = p;
}
return move(a);
}
template <typename T, typename A>
void pa(vector<T, A> const &a, long long int begin = 0,
long long int end = -1) {
if (end == -1) end = (long long int)a.size() - 1;
for (long long int i = begin; i <= end; i++) {
cout << a[i] << " ";
}
cout << "\n";
}
const long long int MX = 2001;
const long long int jump = 1e8 / 2000;
vector<long long int> p(MX);
vector<long long int> c(MX);
vector<vector<long long int> > adjList(MX, vector<long long int>(0));
long long int counter = 1;
long long int add = 2000;
long long int n;
vector<long long int> a(MX);
vector<pair<long long int, long long int> > dfs(long long int curr = 1,
long long int prev = -1) {
vector<pair<long long int, long long int> > childs;
for (auto neigh : adjList[curr]) {
if (neigh == prev) continue;
vector<pair<long long int, long long int> > res = dfs(neigh, curr);
childs.insert(childs.end(), res.begin(), res.end());
}
long long int cc = c[curr];
if (cc > (long long int)childs.size()) {
{
cout << "NO\n";
exit(0);
};
}
if ((long long int)childs.size()) {
sort(childs.begin(), childs.end());
long long int upper = 1e9;
long long int lower = 0;
if (cc == (long long int)childs.size()) {
lower = childs.back().first;
} else {
upper = childs[cc].first;
if (cc > 0) {
lower = childs[cc - 1].first;
}
}
a[curr] = lower + add;
while (cc < (long long int)childs.size() && a[childs[cc].second] == a[curr])
cc++;
for (long long int i = cc; i < (long long int)childs.size(); i++) {
a[childs[i].second] += add;
childs[i].first = a[childs[i].second];
}
add--;
} else {
a[curr] = jump * counter;
counter++;
}
childs.push_back({a[curr], curr});
return childs;
}
void solve() {
cin >> n;
long long int root = 0;
for (long long int i = 1; i <= n; i++) {
cin >> p[i] >> c[i];
if (p[i] != 0) {
adjList[p[i]].push_back(i);
adjList[i].push_back(p[i]);
} else
root = i;
}
dfs(root);
cout << "YES\n";
;
pa(a, 1, n);
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long func(long long xorr, long long andd) {
if (xorr == 0 && andd == 0) return 1;
if (andd < 0 || xorr < 0) return 0;
long long bit1 = xorr % 2;
long long bit2 = andd % 2;
xorr = xorr / 2;
andd = andd / 2;
long long mul = 1;
if (bit1 == 0 && bit2 == 1) mul = 1;
if (bit1 == 1 && bit2 == 0) mul = 2;
if (bit1 == 1 && bit2 == 1) mul = 0;
if (bit1 == 0 && bit2 == 0) mul = 1;
return (mul * func(xorr, andd));
}
int main() {
long long sum, xorr;
long long andd;
cin >> sum >> xorr;
andd = sum - xorr;
if (andd % 2 == 1) {
cout << 0 << endl;
return 0;
}
andd = andd / 2;
long long ans = func(xorr, andd);
if (sum == xorr) ans = ans - 2;
cout << ans << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int left(int pos, int k, int) { return max(1, pos - k); }
int right(int pos, int k, int n) { return min(n, pos + k); }
int intersect(int l_pos, int r_pos, int k, int n) {
return max(0, right(l_pos, k, n) - left(r_pos, k, n) + 1);
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
vector<int> prev(n + 1);
for (size_t i = 1; i <= n; ++i) {
scanf("%d", &prev[i]);
}
vector<int> ans(n + 1);
for (int start = 1; start <= n; ++start) {
ans[start] = right(start, k, n) - left(start, k, n) + 1;
if (prev[start] != 0) {
ans[start] += ans[prev[start]] - intersect(prev[start], start, k, n);
}
}
for (size_t i = 1; i <= n; ++i) {
printf("%d ", ans[i]);
}
puts("");
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9, N = 10010;
const double eps = 1e-8;
inline void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= f;
}
int n, p, s;
char ch[N];
bool flag = 0;
int mi = 0;
stack<int> sta;
int ne[N];
int f[N][110][2];
int tmp[110][2];
int dfs(int u) {
int nex = 0, OP = 0, op = 0;
for (int i = u + 1; i < ne[u]; i = nex + 1) {
if (ch[i] == '(') {
op = dfs(i);
nex = ne[i] + 1;
} else {
nex = i + 1;
f[i][0][0] = f[i][0][1] = ch[i] - '0';
op = 0;
}
if (i == u + 1) {
OP += op;
for (int j = 0; j <= mi; j++) {
f[u][j][1] = f[i][j][1];
f[u][j][0] = f[i][j][0];
}
} else {
OP += op + 1;
for (int j = 0; j <= min(mi, OP); j++) {
tmp[j][1] = f[u][j][1];
f[u][j][1] = -INF;
tmp[j][0] = f[u][j][0];
f[u][j][0] = INF;
}
for (int j = 0; j <= min(mi, OP); j++)
for (int k = 0; k <= j; k++)
if (!flag) {
if (j - k <= op) {
f[u][j][1] = max(f[u][j][1], tmp[k][1] + f[i][j - k][1]);
f[u][j][0] = min(f[u][j][0], tmp[k][0] + f[i][j - k][0]);
}
if (j - k - 1 >= 0 && j - k - 1 <= op) {
f[u][j][0] = min(f[u][j][0], tmp[k][0] - f[i][j - k - 1][1]);
f[u][j][1] = max(f[u][j][1], tmp[k][1] - f[i][j - k - 1][0]);
}
} else {
if (j - k <= op) {
f[u][j][0] = min(f[u][j][0], tmp[k][0] - f[i][j - k][1]);
f[u][j][1] = max(f[u][j][1], tmp[k][1] - f[i][j - k][0]);
}
if (j - k - 1 >= 0 && j - k - 1 <= op) {
f[u][j][1] = max(f[u][j][1], tmp[k][1] + f[i][j - k - 1][1]);
f[u][j][0] = min(f[u][j][0], tmp[k][0] + f[i][j - k - 1][0]);
}
}
}
}
return OP;
}
int main() {
scanf("%s", ch + 1);
n = strlen(ch + 1);
read(p);
read(s);
if (n == 1) {
printf("%d\n", ch[1] - '0');
return 0;
}
for (int i = 1; i <= n; i++) {
if (ch[i] == '(') {
sta.push(i);
} else if (ch[i] == ')') {
ne[sta.top()] = i;
sta.pop();
}
}
flag = (p <= s);
mi = min(p, s);
for (int i = 1; i <= n; i++)
for (int j = 0; j <= mi; j++) {
f[i][j][0] = INF;
f[i][j][1] = -INF;
}
dfs(1);
printf("%d\n", f[1][mi][1]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long a, b, r, i, j;
cin >> a >> b;
if (a < b) swap(a, b);
while (a%b != 0) {
r = a%b; a = b; b = r;
}
int ans = 1, lim = sqrt(b);
for (i = 2; i <= lim; i++) {
if (b%i == 0) {
ans++; while (b%i == 0) b /= i;
}
}
if (b > lim) ans++;
cout << ans << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 7;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
vector<long long> v(n);
for (long long i = 0; i < n; i++) cin >> v[i];
sort(v.rbegin(), v.rend());
pair<long long, long long> pos = {0, 0};
long long ch = 1;
long long i = 0, j = n - 1;
while (i <= j) {
if (ch == 1) {
pos = {pos.first + v[i], pos.second};
i++;
} else {
pos = {pos.first, pos.second + v[j]};
j--;
}
ch *= -1;
}
cout << (long long)(pow((pos.first), 2) + pow((pos.second), 2));
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> occ(26);
for (int i = 0; i < 26; i++) occ[i] = 0;
for (int i = 0; i < n; i++) {
char x;
cin >> x;
occ[x - 'A']++;
}
sort(occ.rbegin(), occ.rend());
long long ans = 0;
for (auto el : occ) {
long long x = min(k, el);
ans += x * x;
k -= x;
if (k == 0) break;
}
cout << ans << endl;
return 0;
}
| 8 | CPP |
n=int(input())
for i in range(n):
for j in range(9):
x=list(x for x in input())
for k in range(9):
if(x[k]=="2"):
x[k]="1"
break
print("".join(x))
| 10 | PYTHON3 |
import math
def ciclos(arr, i):
de = {i:0}
cnt = 1
while True:
i = arr[i]-1
if i in de:
return de[i],cnt-de[i]
de[i] = cnt
cnt+=1
def mcm(a,b):
return (a*b//math.gcd(a,b))
n = int(input())
a = [int(x) for x in input().split()]
max_offset = -float('inf')
act_mcm = 1
aux_max = -float('inf')
for i in range(n):
off, lon = ciclos(a,i)
aux = lon if (off==0) else lon*math.ceil(off/lon)
max_offset = max(max_offset,off)
aux_max = max(aux_max, aux)
act_mcm = mcm(act_mcm,lon)
print(act_mcm*math.ceil(aux_max/act_mcm))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
char s1[1002][502];
char s2[1002][502];
int main() {
int n, m;
scanf("%d %d", &n, &m);
int i;
for (i = 1; i <= n; i++) scanf("%s", s1[i]);
for (i = 1; i <= m; i++) scanf("%s", s2[i]);
int j, cnt = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
int k = 0;
int f = 0;
if (strlen(s1[i]) == strlen(s2[j])) {
while (s1[i][k] != '\0' && s2[j][k] != '\0') {
if (s1[i][k] != s2[j][k]) {
f = 1;
break;
}
k++;
}
if (k == strlen(s1[i])) cnt++;
}
}
}
if (n > m) {
printf("YES\n");
return 0;
}
if (m > n) {
printf("NO\n");
}
if (n == m && cnt == 0) {
printf("NO\n");
return 0;
}
if (n == m && cnt % 2 == 1) {
printf("YES\n");
}
if (n == m && cnt % 2 == 0) {
printf("NO\n");
return 0;
}
}
| 8 | CPP |
for w in range(int(input())):
n,k = tuple(map(int,input().split()))
s = str(input())
s= list(s)
ans = 0
i = 0
while(i<n):
if(s[i]=='*'):
ans+=1
s[i]='x'
j = i + k
if(j>n-1):
i = n
break
while(j<n and j>i and s[j]!='*'):
j-=1
i = min(j,n-1)
else:
i+=1
for i in reversed(range(n)):
if(s[i]=='x'):
break
elif(s[i]=='*'):
ans+=1
break
print(ans) | 8 | PYTHON3 |
t= int(input())
for _ in range(t):
n,x = list(map(int,input().split()))
if n <=2:
print(1)
else:
res= (n-2)//x
if (n-2) % x != 0:
res+=1
res+=1
print(res)
# 5//3 = 1 rem = 2
# 20//5 = 4 rem = 0
# 985//13 = 75 rem = 10
| 7 | PYTHON3 |
#include <iostream>
#include <vector>
#include <cstring>
using namespace std;
int main(){
int N, W;
long long dp[101][500];
while(cin >> N >> W){
vector<int> w(N), v(N);
for(int i=0;i<N;i++){
cin >> w[i] >> v[i];
}
int w1 = w[0];
for(int i=0;i<N;i++) w[i] -= w1;
long long res = 0;
for(int u=1;u<=N;u++){
long long rest = W - (long long)u * w1;
if(rest < 0) break;
rest = min(rest, 499LL);
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for(int i=0;i<N;i++){
for(int num=u-1;num>=0;num--){
for(int j=rest;j>=0;j--){
if(dp[num][j] == -1) continue;
if(j + w[i] > rest) continue;
dp[num+1][j+w[i]] = max(dp[num+1][j+w[i]], dp[num][j]+v[i]);
}
}
}
for(int i=0;i<500;i++) res = max(res, dp[u][i]);
}
cout << res << endl;
}
}
| 0 | CPP |
a = input()
b = input()
a = a.lstrip('0')
b = b.lstrip('0')
if len(a) > len(b):
print('>')
elif len(a) < len(b):
print('<')
else :
f = 0
for i in range(len(a)):
if int(a[i]) - 48 > int(b[i]) - 48 :
print('>')
f = 1
break
elif int(a[i]) - 48 < int(b[i]) - 48 :
print('<')
f = 1
break
if f == 0 :
print('=')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(long long &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const long long &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
int MOD = 1e9 + 7;
void ADD(long long &x, long long v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e6 + 10;
vector<int> e[SIZE];
int deg[SIZE];
vector<int> lv[SIZE];
int MA_TT;
void f2(int x, int lt, int tt = 0) {
MA_TT = max(MA_TT, tt);
lv[tt].push_back(x);
for (int y : e[x]) {
if (y == lt) continue;
f2(y, x, tt + 1);
}
}
bool check(int x) {
for (int i = (0); i <= (MA_TT); ++i) lv[i].clear();
MA_TT = 0;
f2(x, x);
for (int i = (0); i <= (MA_TT); ++i) {
for (int j = (1); j < (((int)(lv[i]).size())); ++j) {
if (((int)(e[lv[i][j]]).size()) != ((int)(e[lv[i][0]]).size())) return 0;
}
}
return 1;
}
bool u[SIZE];
int from[SIZE];
bool cmp(int x, int y) { return ((int)(e[x]).size()) < ((int)(e[y]).size()); }
int find(int x) {
if (!from[x]) return x;
return find(from[x]);
}
int main() {
int n;
R(n);
if (n == 1) {
W(1);
return 0;
}
for (int i = (1); i < (n); ++i) {
int x, y;
R(x, y);
e[x].push_back(y);
e[y].push_back(x);
}
vector<int> AA[2];
for (int i = (1); i <= (n); ++i) {
deg[i] = ((int)(e[i]).size());
if (((int)(e[i]).size()) == 1) {
u[i] = 1;
AA[0].push_back(i);
}
}
int now = 0, nxt = 1;
while (1) {
AA[nxt].clear();
for (int x : AA[now]) {
for (int y : e[x]) {
if (!u[y]) {
u[y] = 1;
from[y] = x;
AA[nxt].push_back(y);
}
}
}
if (((int)(AA[nxt]).size()) == 0) {
int v = find(AA[now][0]);
if (check(v)) {
W(v);
return 0;
}
v = find(AA[now].back());
if (check(v)) {
W(v);
return 0;
}
W(-1);
return 0;
}
if (((int)(AA[nxt]).size()) == 1) {
W(AA[nxt][0]);
return 0;
}
int m = ((int)(AA[nxt]).size());
sort((AA[nxt]).begin(), (AA[nxt]).end(), cmp);
if (((int)(e[AA[nxt][0]]).size()) != ((int)(e[AA[nxt][m - 1]]).size())) {
int v = find(AA[nxt][0]);
if (check(v)) {
W(v);
return 0;
}
v = find(AA[nxt][m - 1]);
if (check(v)) {
W(v);
return 0;
}
W(-1);
return 0;
}
swap(now, nxt);
}
return 0;
}
| 10 | CPP |
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <fstream>
#include <map>
#include <cstring>
#include <vector>
using namespace std;
int n,m;
string bits[1001];
const int INF=1000000000;
//bitset<int> nums[1<<11];
map<set<int>,int> sets;
int id;
map<int,int> dp[1<<11];
//map<set<int>,int > dp[1<<11];
// »ÝgÁ½¿âA»Ì¿âÉæÁľç꽪̤¿AÇ̪ð©Ä¢é©AÅ»
int dfs(int s,int pos,set<int> &si,int sel){
// WÌTCYª1Ⱥ
if(si.size()<=1)return 0;
if(s==(1<<m)-1)return INF;
if(sets.find(si)==sets.end())
sets[si]=id++;
if(dp[s].find(sets[si])!=dp[s].end())return dp[s][sets[si]];
int res=INF;
// ÇÌ¿âðg¤©
for(int i=0;i<m;i++){
// ·ÅÉgpÏÝ
if((s>>i)&1)continue;
// ªðs¤
set<int> si1,si2;
for(set<int>::iterator it=si.begin();it!=si.end();it++){
int idx=*it;
if(bits[idx][i]=='1')si1.insert(idx);
else si2.insert(idx);
}
res=min(res,max(dfs(s|(1<<i),i,si1,0),dfs(s|(1<<i),i,si2,1))+1);
}
return dp[s][sets[si]]=res;
}
int main(){
while(cin>>m>>n&&!(m==0&&n==0)){
//memset(dp,-1,sizeof(dp));
for(int i=0;i<(1<<11);i++)dp[i].clear();
sets.clear();
id=0;
//for(int i=0;i<(1<<11);i++)
//nums[i]=i;
for(int i=0;i<n;i++)cin>>bits[i];
set<int> init;
for(int i=0;i<n;i++)init.insert(i);
int res=INF;
res=dfs(0,0,init,0);
cout<<res<<endl;
}
return 0;
} | 0 | CPP |
class Converter:
d = {
1: { 2: 3, 3: 5, 4: 2, 5: 4, },
2: { 1: 4, 3: 1, 4: 6, 6: 3, },
3: { 1: 2, 2: 6, 5: 1, 6: 5, },
4: { 1: 5, 2: 1, 5: 6, 6: 2, },
5: { 1: 3, 3: 6, 4: 1, 6: 4, },
6: { 2: 4, 3: 2, 4: 5, 5: 3, }
}
def __init__(self, s):
l = s.split()
self.tbl = dict(zip(l, range(1,7)))
self.pip = dict(zip(range(1,7), l))
def __call__(self, s):
l, r = s.split()
print(self.pip[self.d[self.tbl[l]][self.tbl[r]]])
cv = Converter(input())
n = int(input())
for _ in range(n):
cv(input()) | 0 | PYTHON3 |
#include<iostream>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)(n);i++)
int sum;
int a[20];
bool bit(unsigned int a, int k) {
return ((a >> (k + 1)) & 1);
}
int diff(int m, int n) {
return ((m - n > 0) ? m - n : n - m);
}
int pow(int a, int n) {
int ans = 1;
REP(i, n) {
ans *= a;
}
return ans;
}
int solve(int n) {
int repeat = pow(2, n), min = sum;
for (unsigned int bitset = 0; bitset < repeat; bitset++) {
int agroup = 0;
REP(k, n) {
if (bit(bitset, k))
agroup += a[k];
}
int d = diff(agroup, sum - agroup);
if (min > d) min = d;
}
return min;
}
int main() {
unsigned int n;
while (cin >> n and n != 0) {
sum = 0;
REP(i, n) {
cin >> a[i];
sum += a[i];
}
cout << solve(n) << endl;/*
int k;
cin >> k;
cout << bit(n, k) << endl;*/
}
} | 0 | CPP |
# -*- coding: utf-8 -*-
length = int(input())
string = str(input())
_dict = dict()
for i in range(length - 1):
Count = _dict.get(string[i:i + 2], 0)
_dict.update({string[i:i + 2]: int(Count) + 1})
maxElement, maxElementCount = 0, -1
for key in _dict:
if _dict[key] > maxElementCount:
maxElementCount = _dict[key]
maxElement = key
print(maxElement) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, v;
cin >> n >> v;
if (n - 1 <= v) {
cout << n - 1 << endl;
return 0;
}
int result = v;
int ex = 2;
for (int i = 1; i <= n - 1 - v; i++) {
result += ex;
ex++;
}
cout << result << endl;
}
| 7 | CPP |
p = int(input())
d = int(input())
h = int(input())
m = int(input())
t = int(input())
c = 0
for i in range(1,t+1):
if i % p == 0 or i % d == 0 or i % m == 0 or i % h == 0:
c+=1
print(c)
| 7 | PYTHON3 |
n,p=map(int, input().split())
a=[]
for i in range(n):
l,r=map(int, input().split())
a.append((r//p-(l-1)//p)/(r-l+1))
a.append(a[0])
ans=0
for i in range(n):
ans+=2000*(a[i]*(1-a[i+1])+(1-a[i])*(a[i+1])+(a[i]*a[i+1]))
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
int table[1001][1001];
int next239[1001][1001];
string s1, s2;
int getans(int p1, int p2) {
if (p1 == n && p2 == m) return 0;
int &ans = table[p1][p2];
if (ans != -1) return ans;
ans = 5000;
if (p1 < n) {
int b = getans(p1 + 1, p2) + 1;
if (b < ans) {
ans = b;
next239[p1][p2] = 3;
}
}
if (p2 < m) {
int b = getans(p1, p2 + 1) + 1;
if (b < ans) {
ans = b;
next239[p1][p2] = 1;
}
if (p1 < n && s1[p1] == s2[p2]) {
int b = getans(p1 + 1, p2 + 1);
if (b < ans) {
ans = b;
next239[p1][p2] = 0;
}
}
if (p1 < n) {
int b = getans(p1 + 1, p2 + 1) + 1;
if (b < ans) {
ans = b;
next239[p1][p2] = 2;
}
}
}
return ans;
}
int main() {
cin >> s1 >> s2;
n = ((int)(s1).size());
m = ((int)(s2).size());
memset(table, -1, sizeof(table));
cout << getans(0, 0) << endl;
int cp1 = 0;
int p1 = 0, p2 = 0;
while (p1 < n || p2 < m) {
int a = next239[p1][p2];
if (a == 0) {
p1++;
p2++;
}
if (a == 1) {
cout << "INSERT " << cp1 + p1 + 1 << ' ' << s2[p2] << endl;
p2++;
cp1++;
}
if (a == 2) {
cout << "REPLACE " << cp1 + p1 + 1 << ' ' << s2[p2] << endl;
p1++;
p2++;
}
if (a == 3) {
cout << "DELETE " << cp1 + p1 + 1 << endl;
p1++;
cp1--;
}
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
string ans = "AC";
if (S.front() != 'A') ans = "WA";
if (count(S.begin() + 2, S.end() - 1, 'C') != 1) ans = "WA";
int cnt = 0;
for (int i = 0; i < S.size(); i++) {
if(isupper(S.at(i))) cnt++;
}
if (cnt != 2) ans = "WA";
cout << ans << "\n";
} | 0 | CPP |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int max = -1, ind = -1, sec_max = -1;
for (int i = 0; i < n; i++) {
int p;
scanf("%d", &p);
if (p > max) {
sec_max = max;
ind = i;
max = p;
} else if (p > sec_max)
sec_max = p;
}
printf("%d %d\n", ind + 1, sec_max);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void mine(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void maxe(T1 &x, T2 y) {
if (x < y) x = y;
}
ostream &operator<<(ostream &a, const vector<long long> &b) {
for (auto k : b) cout << k << ' ';
return a;
}
const long long MOD = 1000000007;
const long long INF = 1000000050;
const long long BIG = (long long)2e18 + 50;
const long long MX = 2001;
const long double EPS = 1e-6;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
bool lt(long double x, long double y) { return x + EPS < y; }
bool eq(long double x, long double y) { return abs(x - y) < EPS; }
struct pt {
long double x;
long double y;
long double z;
pt(long double a, long double b, long double c) {
x = a;
y = b;
z = c;
}
bool operator<(const pt &p) const {
return lt(x, p.x) ||
(eq(x, p.x) && (lt(y, p.y) || (eq(y, p.y) && lt(z, p.z))));
}
bool operator==(const pt &p) const {
return eq(x, p.x) && eq(y, p.y) && eq(z, p.z);
}
};
long double vx[MX], vy[MX], x[MX], y[MX];
bool can[MX][MX];
long double tt[MX][MX];
bool cmp(pair<long double, long double> a, pair<long double, long double> b) {
return a.second < b.second;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
for (long long i = 0; i < n; i++) {
long double t1, x1, y1, t2, x2, y2;
cin >> t1 >> x1 >> y1 >> t2 >> x2 >> y2;
vy[i] = (y2 - y1) / (t2 - t1);
vx[i] = (x2 - x1) / (t2 - t1);
x[i] = x1 - vx[i] * t1;
y[i] = y1 - vy[i] * t1;
}
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j < n; j++) {
long double tim = 0;
if (!eq(vx[i], vx[j])) tim = (x[i] - x[j]) / (vx[j] - vx[i]);
if (!eq(vy[i], vy[j])) tim = (y[i] - y[j]) / (vy[j] - vy[i]);
long double xx = x[i] + vx[i] * tim;
long double yy = y[i] + vy[i] * tim;
if (eq(xx, x[j] + vx[j] * tim) && eq(yy, y[j] + vy[j] * tim)) {
can[i][j] = can[j][i] = true;
tt[i][j] = tt[j][i] = tim;
}
}
}
long long ans = 1;
for (long long i = 0; i < n; i++) {
vector<pair<long double, long double>> kek;
vector<long double> colis;
for (long long j = 0; j < n; j++) {
if (!can[i][j]) continue;
colis.push_back(tt[i][j]);
long double xx = vx[j] - vx[i];
long double yy = vy[j] - vy[i];
long double ang = atan2(yy, xx);
if (ang < -EPS) ang += 4 * atan(1);
kek.push_back({ang, sin(ang) * yy + cos(ang) * xx});
}
sort(colis.begin(), colis.end());
long long it = 0;
while (it < (long long)colis.size()) {
long long it2 = it + 1;
while (it2 < (long long)colis.size() && eq(colis[it2], colis[it])) ++it2;
maxe(ans, it2 - it + 1);
it = it2;
}
sort(kek.begin(), kek.end());
long long her = 0;
it = 0;
while (it < (long long)kek.size()) {
long long it2 = it + 1;
while (it2 < (long long)kek.size() &&
kek[it2].first - kek[it].first < EPS)
++it2;
sort(kek.begin() + it, kek.begin() + it2, cmp);
long long dif = 1;
for (long long k = it + 1; k < it2; k++)
dif += !eq(kek[k].second, kek[k - 1].second);
maxe(her, dif + 1);
it = it2;
}
maxe(ans, her);
}
cout << ans << '\n';
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<bool> isprime(1000001, true);
isprime[0] = isprime[1] = false;
for (int i = 2; i * i <= 1000000; i++)
if (isprime[i])
for (int j = i * i; j <= 1000000; j += i) isprime[j] = false;
int sp = n - 1;
while (!isprime[sp]) sp++;
cout << sp << " " << sp << endl;
cout << 1 << " " << 2 << " " << sp - n + 2 << endl;
for (int i = 2; i <= n - 1; i++)
cout << i << " " << i + 1 << " " << 1 << endl;
m -= n - 1;
for (int i = 1; i <= n && m > 0; i++)
for (int j = i + 2; j <= n && m > 0; j++) {
cout << i << " " << j << " " << 10000000 << endl;
m--;
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void read(Tp &x) {
static char c;
static bool neg;
x = 0, c = getchar(), neg = false;
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = true;
}
}
for (; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
if (neg) {
x = -x;
}
}
const int N = 1e4 + 5;
string str, temp;
int n;
bool vis[N];
vector<string> vec;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cin >> str;
if (str.length() == 5UL) {
puts("0");
return 0;
}
str = str.substr(5);
n = (int)str.length();
vis[n] = true;
for (int i = n - 1; i >= 0; --i) {
for (int len = 2; len <= 3; ++len) {
if (i + len <= n) {
temp = str.substr(i, len);
if ((str.find(temp, i + len) == str.npos || vis[i + 5]) &&
vis[i + len]) {
vec.emplace_back(temp);
vis[i] = true;
}
}
}
}
sort(vec.begin(), vec.end());
vec.erase(unique(vec.begin(), vec.end()), vec.end());
cout << vec.size() << "\n";
for (const auto &s : vec) {
cout << s << "\n";
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const long long linf = 1e18;
const int inf = 1e9;
const int N = 1e6 + 5;
int n, m, k, way, x, y, z, p[N];
pair<int, int> a[N];
pair<pair<int, int>, int> b[N];
vector<pair<int, int> > v1[N], v2[N], e1[N], e2[N];
long long ans;
int F[6][N];
map<int, int> w, h;
int merge(int w, int x, int y) { return w == 1 ? min(x, y) : max(x, y); }
void update(int w, int x, int t) {
if (w == 2 || w == 5 || w == 4)
for (; x < N && x > 0; x += x & -x) F[w][x] = merge(w, F[w][x], t);
else
for (; x > 0; x -= x & -x) F[w][x] = merge(w, F[w][x], t);
}
int query(int w, int x) {
int ans = ((w == 1) ? inf : 0);
if (w == 2 || w == 5 || w == 4)
for (; x > 0; x -= x & -x) ans = merge(w, F[w][x], ans);
else
for (; x < N && x > 0; x += x & -x) ans = merge(w, F[w][x], ans);
return ans;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i].first, &a[i].second);
h[a[i].first] = h[a[i].second] = true;
}
for (int i = 1; i <= m; i++) {
scanf("%d %d %d", &b[i].first.first, &b[i].first.second, &b[i].second);
h[b[i].first.first] = h[b[i].first.second] = true;
}
int s = 0;
for (__typeof(h.begin()) it = h.begin(); it != h.end(); it++) {
w[it->first] = ++s;
p[s] = it->first;
}
for (int i = 1; i <= N; i++) F[1][i] = inf;
for (int i = 1; i <= n; i++) {
a[i].first = w[a[i].first];
a[i].second = w[a[i].second];
v1[a[i].first].push_back(make_pair(a[i].second, i));
e1[a[i].second].push_back(make_pair(a[i].first, i));
}
for (int i = 1; i <= m; i++) {
b[i].first.first = w[b[i].first.first];
b[i].first.second = w[b[i].first.second];
v2[b[i].first.first].push_back(make_pair(b[i].first.second, i));
e2[b[i].first.second].push_back(make_pair(b[i].first.first, i));
}
long long x = 0;
for (int i = s; i >= 1; i--) {
for (__typeof(v1[i].begin()) it = v1[i].begin(); it != v1[i].end(); it++) {
update(1, it->first, i);
update(2, it->first, p[it->first] - p[i]);
}
for (__typeof(v2[i].begin()) it = v2[i].begin(); it != v2[i].end(); it++) {
x = query(1, it->first + 1);
if (x < it->first &&
ans < (long long)(p[it->first] - p[x]) * b[it->second].second) {
ans = (long long)(p[it->first] - p[x]) * b[it->second].second;
way = it->second;
}
x = query(2, it->first);
if (ans < x * b[it->second].second) {
ans = x * b[it->second].second;
way = it->second;
}
}
}
for (int i = 1; i <= s; i++) {
for (__typeof(e1[i].begin()) it = e1[i].begin(); it != e1[i].end(); it++) {
update(3, it->first, p[i] - p[it->first]);
update(4, it->first, i);
}
for (__typeof(v1[i].begin()) it = v1[i].begin(); it != v1[i].end(); it++)
update(5, i, it->first);
for (__typeof(e2[i].begin()) it = e2[i].begin(); it != e2[i].end(); it++) {
x = query(4, it->first);
if (ans < (long long)(p[x] - p[it->first]) * b[it->second].second) {
ans = (long long)(p[x] - p[it->first]) * b[it->second].second;
way = it->second;
}
x = query(3, it->first);
if (ans < x * b[it->second].second) {
ans = x * b[it->second].second;
way = it->second;
}
x = query(5, it->first);
if (x >= i &&
b[it->second].second * (long long)(p[i] - p[it->first]) > ans) {
ans = b[it->second].second * (long long)(p[i] - p[it->first]);
way = it->second;
}
}
}
cout << ans << '\n';
if (!ans) return 0;
for (int i = 1; i <= n; i++)
if ((p[min(b[way].first.second, a[i].second)] -
(long long)p[max(a[i].first, b[way].first.first)]) *
b[way].second ==
ans) {
cout << i << ' ' << way << '\n';
return 0;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
void cmn(long long &x, long long y) {
if (x > y) x = y;
}
int n, a[15], b[15];
char str[15];
long long ans = 1e18;
long long dp[1 << 14];
long long bin[1 << 14];
void calc(int *a) {
memset(dp, 0x3f, sizeof dp);
int U = 1 << n;
dp[0] = 0;
for (int i = 0; i < U; i++) {
int x = __builtin_ctz(i & -i);
bin[i] = bin[i - (i & -i)] + a[x];
}
for (int S = 0; S < U; S++)
for (int j = 0; j < n; j++)
if (!(S >> j & 1)) {
int T = S | (1 << j);
if (0 <= bin[T] && bin[T] < 16)
cmn(dp[T], dp[S] + (bin[S] << (j << 2)));
}
cmn(ans, dp[U - 1]);
}
int main() {
scanf("%s", str);
n = strlen(str);
for (int i = 0; i < n; i++)
a[n - i - 1] = isdigit(str[i]) ? str[i] - '0' : 10 + str[i] - 'a';
for (int S = 0; S < (1 << n); S++) {
int d = 0, t = 0;
for (int j = 0; j < n; j++) {
int x = a[j] + t;
t = 0;
if (x == 16) t = 1, x = 0;
if (S >> j & 1) {
if (!x) {
d = 1e9;
break;
}
t = 1, x -= 16;
}
d += x, b[j] = x;
}
if (!t && d == 0) calc(b);
}
if (ans == 1e18) return puts("NO"), 0;
for (int i = 0; i < n; i++) b[i] = ans & 15, ans >>= 4;
for (int i = n - 1; ~i; i--) {
if (b[i] < 10)
cout << b[i];
else
cout << (char)('a' + b[i] - 10);
}
return 0;
}
| 11 | CPP |
def main():
N = 20; M = 15
MP = [[-1]*M for i in range(N)]
L = 0
for i in range(N-1):
s = input()
for j in range(M):
c = s[j]
if c == 'O':
sx = j; sy = i
elif c == 'X':
MP[i][j] = L
L += 1
dd = ((-1, 0), (-1, -1), (0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1))
INF = 30
D = {}
def dfs(state, x, y):
key = (state, x, y)
if key in D:
return D[key]
if y >= N-2:
return 0
r = INF
for dx, dy in dd:
nx = x + dx; ny = y + dy
if not 0 <= nx < M or not 0 <= ny < N:
continue
k = MP[ny][nx]
if k == -1 or state & (1 << k) == 0:
continue
n_state = state ^ (1 << k)
nx += dx; ny += dy
while 0 <= nx < M and 0 <= ny < N:
k = MP[ny][nx]
if k == -1 or state & (1 << k) == 0:
break
n_state ^= (1 << k)
nx += dx; ny += dy
else:
if (nx == -1 or nx == M) and ny == N-1:
return 1
continue
r = min(r, dfs(n_state, nx, ny) + 1)
D[key] = r
return D[key]
r = dfs(2**L-1, sx, sy)
print(r if r < INF else -1)
main()
| 0 | PYTHON3 |
from collections import defaultdict
t = int(input())
for _ in range(t):
zeroes = defaultdict(int)
ones = defaultdict(int)
n, m = map(int, input().split())
g = []
for i in range(n):
g.append(list(map(int, input().split())))
for i in range(n):
for j in range(m):
if g[i][j]:
ones[min(i+j, n+m-i-j-2)] += 1
else:
zeroes[min(i+j, n+m-i-j-2)] += 1
ct = 0
for i in range((n+m-1)//2):
ct += min(zeroes[i], ones[i])
print(ct) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1234567;
const int INF = 10000000;
int prime[N / 10], top = 0;
bool f[N];
void get_prime() {
f[1] = 1;
for (int i = 2; i < N; i++) {
if (!f[i]) prime[top++] = i;
for (int j = 0; j < top && i * prime[j] < N; j++) {
f[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
}
}
}
long long a[N];
int n;
int vis[1 << 9], FF[1 << 9];
int get_ans(long long n) {
if (n == 1) return 0;
long long m = n;
int ret = 0;
for (int i = 0; i < top && (long long)prime[i] * prime[i] <= n; i++) {
int cnt = 0;
while (n % prime[i] == 0) {
n /= prime[i];
cnt++;
}
ret += cnt;
}
if (m == n) return 1;
if (n != 1) ret++;
return ret + 1;
}
int is_prime(long long n) {
if (n < N) {
if (f[n])
return 0;
else
return 1;
}
for (int i = 0; i < top && (long long)prime[i] * prime[i] <= n; i++)
if (n % prime[i] == 0) return 0;
return 1;
}
int deal(int tot) {
if (vis[tot] != -1) return vis[tot];
vector<long long> hh;
hh.clear();
int ans = 0;
for (int i = 0; i < n; i++)
if (tot & (1 << i)) {
int find = 0;
for (int j = 0; j < hh.size(); j++)
if (hh[j] % a[i] == 0) {
if (!is_prime(a[i])) ans++;
hh.push_back(hh[j] / a[i]);
hh[j] = a[i];
find = 1;
break;
}
if (!find) {
if (hh.size() > 0) return vis[tot] = INF;
ans += get_ans(a[i]);
hh.push_back(a[i]);
}
sort(hh.begin(), hh.end());
}
return vis[tot] = ans;
}
int calc(int tot) {
if (tot == 0) return 0;
if (FF[tot] != -1) return FF[tot];
int ret = INF;
for (int i = tot; i != 0; i = (i - 1) & tot) {
int tmp = calc(tot ^ i) + deal(i);
if (tmp < ret) ret = tmp;
}
return FF[tot] = ret;
}
bool cmpr(long long i, long long j) { return i > j; }
int main() {
get_prime();
memset(vis, -1, sizeof(vis));
memset(FF, -1, sizeof(FF));
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n, cmpr);
n = unique(a, a + n) - a;
int tot = (1 << n) - 1;
int ans = deal(tot);
for (int i = (tot - 1) & tot; i != 0; i = (i - 1) & tot) {
int tmp = calc(tot ^ i) + deal(i) + 1;
if (tmp < ans) ans = tmp;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include<bits/stdc++.h>
using namespace std;
int n,ans;
int main(){
cin>>n;
for(int i = 1; i <= n; i++){
for(int j = 1; j <= n && (i * j) < n; j++)ans++;
}
cout<<ans;
return 0;
} | 0 | CPP |
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
#from fractions import *
from bisect import *
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
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")
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
#vsInput()
n,x=value()
a=sorted(array())
hours=0
for i in a:
hours+=max(1,x)*i
x-=1
print(hours) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> v[N];
int n;
int sz[N];
double ans[N];
void dfs(int x) {
sz[x] = 1;
for (auto u : v[x]) {
dfs(u);
sz[x] += sz[u];
}
}
void dfs2(int x) {
for (auto u : v[x]) {
ans[u] = ans[x] + (sz[x] - sz[u] - 1) / 2.00 + 1.00;
dfs2(u);
}
}
int main() {
scanf("%d", &n);
for (int i(2); i <= (n); ++i) {
int x;
scanf("%d", &x);
v[x].push_back(i);
}
dfs(1);
ans[1] = 1;
dfs2(1);
for (int i(1); i <= (n); ++i) printf("%.1f\n", ans[i]);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
int main() {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
if (c == 0) {
if (a > b)
printf("+");
else if (b > a)
printf("-");
else
printf("0");
}
if (c != 0) {
if (a == b)
printf("?");
else if (a == (b + c))
printf("?");
else if (b == (a + c))
printf("?");
else if (a >= (b + c))
printf("+");
else if (b >= (a + c))
printf("-");
else if ((a + c) >= b && (b + c) >= a)
printf("?");
else
printf("invalid");
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto& i : v) is >> i;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> v) {
for (auto& i : v) os << i << '\n';
return os;
}
void solve() {
int64_t n;
n = 6;
vector<string> a(n);
cin >> a;
int maxi = 0;
int imax = 0;
int jmax = 0;
vector<vector<int>> v(n, vector<int>(8, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < a[i].size(); j++) {
if (j == 2 || j == 5) continue;
v[i][j] = (3 - i / 2) + ((j - 1) / 2 == 1);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < a[i].size(); j++) {
if (a[i][j] == '-') continue;
if (a[i][j] == '.') {
if (v[i][j] > maxi) {
maxi = v[i][j];
imax = i;
jmax = j;
}
}
}
}
a[imax][jmax] = 'P';
cout << a;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 10 | CPP |
t=int(input())
while t:
n=int(input())
if(n==1 or n==2):print(0)
elif(n%2==0):
print(n//2-1)
else:
print(n//2)
t-=1 | 7 | PYTHON3 |
x, k = list(map(int, input().split()))
while k > 0:
if x % 10 == 0:
x = int(str(x)[:-1])
else:
x -= 1
k -= 1
print(x)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int dp[35][105][((105) * (105 + 1)) / 2];
int dir[35][105][((105) * (105 + 1)) / 2];
int n, ara[35];
int solve(int now, int k, int sum) {
if ((k * (k - 1)) / 2 > sum) return 105;
if (now == n) {
if (sum == (k * (k - 1)) / 2) return 0;
return 105;
}
int &ret = dp[now][k][sum];
if (ret != -1) return ret;
ret = 105;
for (int i = 1; k + i < 105; i++) {
if (i >= ret) break;
int tmp = i + solve(now + 1, k + i, sum + i * ara[now]);
if (tmp < ret) {
ret = tmp;
dir[now][k][sum] = i;
}
}
return ret;
}
int deg[105];
void go(int now, int k, int sum) {
if (now == n) return;
for (int i = 0; i < dir[now][k][sum]; i++) deg[k + i] = ara[now];
go(now + 1, k + dir[now][k][sum], sum + ara[now] * dir[now][k][sum]);
}
const int MAX_E = 60003;
const int MAX_V = 5003;
int ver[MAX_E], cap[MAX_E], nx[MAX_E], last[MAX_V], ds[MAX_V], st[MAX_V],
now[MAX_V], edge_count, S, T;
inline void reset() {
memset(nx, -1, sizeof(nx));
memset(last, -1, sizeof(last));
edge_count = 0;
}
inline void addedge(const int v, const int w, const int capacity,
const int reverse_capacity) {
ver[edge_count] = w;
cap[edge_count] = capacity;
nx[edge_count] = last[v];
last[v] = edge_count++;
ver[edge_count] = v;
cap[edge_count] = reverse_capacity;
nx[edge_count] = last[w];
last[w] = edge_count++;
}
inline bool bfs() {
memset(ds, -1, sizeof(ds));
int a, b;
a = b = 0;
st[0] = T;
ds[T] = 0;
while (a <= b) {
int v = st[a++];
for (int w = last[v]; w >= 0; w = nx[w]) {
if (cap[w ^ 1] > 0 && ds[ver[w]] == -1) {
st[++b] = ver[w];
ds[ver[w]] = ds[v] + 1;
}
}
}
return ds[S] >= 0;
}
int dfs(int v, int cur) {
if (v == T) return cur;
for (int &w = now[v]; w >= 0; w = nx[w]) {
if (cap[w] > 0 && ds[ver[w]] == ds[v] - 1) {
int d = dfs(ver[w], min(cur, cap[w]));
if (d) {
cap[w] -= d;
cap[w ^ 1] += d;
return d;
}
}
}
return 0;
}
inline long long flow() {
long long res = 0;
while (bfs()) {
for (int i = 0; i < MAX_V; i++) now[i] = last[i];
while (1) {
int tf = dfs(S, 2000000000);
res += tf;
if (!tf) break;
}
}
return res;
}
int mat[105][105];
int main() {
int i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &ara[i]);
sort(ara, ara + n);
memset(dp, -1, sizeof(dp));
int nd = solve(0, 0, 0);
if (nd == 105) {
printf("=(\n");
return 0;
}
go(0, 0, 0);
reset();
int cnt = 1, bam = (nd * (nd - 1)) / 2;
S = 0;
T = bam + 1 + nd;
for (i = 0; i < nd; i++) {
for (j = i + 1; j < nd; j++) {
addedge(S, cnt, 1, 0);
addedge(cnt, i + bam + 1, 1, 0);
addedge(cnt, j + bam + 1, 1, 0);
cnt++;
}
}
for (i = 0; i < nd; i++) addedge(bam + i + 1, T, deg[i], 0);
flow();
cnt = 0;
for (i = 0; i < nd; i++) {
for (j = i + 1; j < nd; j++) {
cnt += 2;
if (cap[cnt])
mat[j][i] = 1;
else
mat[i][j] = 1;
cnt += 4;
}
}
printf("%d\n", nd);
for (i = 0; i < nd; i++) {
for (j = 0; j < nd; j++) printf("%d", mat[i][j]);
printf("\n");
}
return 0;
}
| 10 | CPP |
a=(str(input())).lower()
b=(str(input())).lower()
if a>b:
print("1")
elif a<b:
print("-1")
else:
print("0")
| 7 | PYTHON3 |
import sys
try:
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
except:
pass
input = sys.stdin.readline
n,s = map(int,input().split())
arr = [1]*(n-1)
arr.append(s - (n-1))
# print(arr)
start = n; end = arr[-1]-1
# print(start,end)
for i in range(start, end+1):
if start<=s-i<=end:
ans = i
break
else:
ans = -1
if ans==-1:
print("NO")
else:
print("YES")
print(*arr,sep=" ")
print(ans) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
char s[100];
char ss[100];
int main() {
scanf("%s", s);
scanf("%s", ss);
int m = strlen(ss);
int n = strlen(s);
int k;
for (int i = 0; i < n; i++)
if (s[i] == '|') {
k = i;
break;
}
int a = k;
int b = n - k - 1;
if (min(a, b) + m < max(a, b) || (n + m) % 2 == 0) {
printf("Impossible");
return 0;
}
for (int i = 0; i < a; i++) printf("%c", s[i]);
for (int i = 0; i < (b + m - a) / 2; i++) printf("%c", ss[i]);
printf("|");
for (int i = k + 1; i < n; i++) printf("%c", s[i]);
for (int i = (b + m - a) / 2; i < m; i++) printf("%c", ss[i]);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, d[8037], b[2];
string f[27], s, a[2], ps;
void pre(void) {
f[1] = "a";
f[2] = "b";
for (int i = 3; f[i - 1].length() < 8037; ++i)
f[i] = f[i - 1] + f[i - 2], m = i;
a[m % 2] = f[m];
a[(m - 1) % 2] = f[m - 1];
}
void din(void) {
int len = s.length(), del, le;
b[0] = b[1] = 0;
for (int i = 0; i < 2; ++i) {
ps = a[i] + f[m], del = a[i].length();
le = ps.length();
for (int j = 0; j + len <= le; ++j)
if (j < del && j + len > del && ps.substr(j, len) == s) b[i]++;
}
d[1] = (s == "a" ? 1 : 0);
d[2] = (s == "b" ? 1 : 0);
for (int i = 3; i <= n; ++i) {
d[i] = d[i - 1] + d[i - 2];
if (i <= m) {
ps = f[i], del = f[i - 1].length();
le = ps.length();
for (int j = 0; j + len <= le; ++j)
if (j < del && j + len > del && ps.substr(j, len) == s) d[i]++;
} else
d[i] += b[(i - 1) % 2];
if (d[i] >= 1000000007) d[i] -= 1000000007;
}
cout << d[n] << "\n";
}
int main() {
int t;
pre();
cin >> n >> t;
while (t--) {
cin >> s;
din();
}
return 0;
}
| 13 | CPP |
a,b=map(int,input().split())
us=240
ss=0
zaman=0
for i in range(1,a+1):
zaman+=i*5
if b+zaman <= 240:
ss+=1
print(ss)
| 7 | PYTHON3 |
#include <iostream>
using namespace std;
long long N, dp[59][59][59], nr[59][59], mod = 1000000007;
void init() {
for (int i = 0; i < 59; i++) {
for (int j = 0; j < 59; j++) {
if (i == 0 || j == 0) nr[i][j] = 1;
else nr[i][j] = (nr[i - 1][j] + nr[i][j - 1]) % mod;
}
}
}
long long ncr(long long n, long long r) {
return nr[n - r][r];
}
long long solve(int pos, int ca, int cb) {
if (pos == N) {
if (ca == 0 && cb == 0) return 1;
return 0;
}
if (dp[pos][ca][cb] >= 0) return dp[pos][ca][cb];
long long sum = 0;
for (int i = 0; i <= N - pos; i++) {
for (int j = 0; j <= N - pos; j++) {
if ((i + j) < (ca + cb)) continue;
if ((i + j) % 2 != (ca + cb) % 2) continue;
if (pos + i + j > N || i + j == 0) continue;
long long la = 0, lb = 0;
if ((ca - cb) > (i - j)) la = ((ca - cb) - (i - j)) / 2;
else lb = ((i - j) - (ca - cb)) / 2;
long long P1 = ncr(pos + i, i);
long long P2 = ncr(pos + i + j, j);
long long P3 = solve(pos + i + j, la, lb);
sum += (P1*P2%mod)*P3%mod; sum %= mod;
}
}
dp[pos][ca][cb] = sum;
return sum;
}
int main() {
cin >> N; init();
for (int i = 0; i <= N; i++) { for (int j = 0; j <= N; j++) { for (int k = 0; k <= N; k++) dp[i][j][k] = -1; } }
long long A = solve(1, 0, 0);
long long B = solve(1, 1, 0);
cout << (A + B) % mod << endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
if (n == 1) {
cout << 1 << endl;
return 0;
}
if (b < 0) {
b = abs(b);
while (b != 0) {
if (a == 1) a = n + 1;
a--;
b--;
}
cout << a << endl;
} else if (b >= 0) {
while (b != 0) {
if (a == n) a = 0;
a++;
b--;
}
cout << a << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#define FOR(i,a,b) for( ll i = (a); i < (ll)(b); i++ )
#define REP(i,n) FOR(i,0,n)
#define YYS(x,arr) for(auto& x:arr)
#define ALL(x) (x).begin(),(x).end()
#define SORT(x) sort( (x).begin(),(x).end() )
#define REVERSE(x) reverse( (x).begin(),(x).end() )
#define UNIQUE(x) (x).erase( unique( ALL( (x) ) ) , (x).end() )
#define PW(x) (1LL<<(x))
#define SZ(x) ((ll)(x).size())
#define SHOW(x) cout << #x << " = " << x << endl
#define pb emplace_back
#define fi first
#define se second
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef pair<int,int> pi;
typedef pair<ll,ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<bool> vb;
typedef vector<ld> vd;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<vpl> gr;
typedef vector<vl> ml;
typedef vector<vd> md;
typedef vector<vi> mi;
const ll INF = (ll)1e9 + 10;
const ll INFLL = (ll)1e18 + 10;
const ld EPS = 1e-12;
const ll MOD = 1e9+7;
template<class T> T &chmin( T &a , const T &b ){ return a = min(a,b); }
template<class T> T &chmax( T &a , const T &b ){ return a = max(a,b); }
template<class T> inline T sq( T a ){ return a * a; }
ll in(){ ll x; scanf( "%lld" , &x ); return x; }
char yuyushiki[1000010]; string stin(){ scanf( "%s" , yuyushiki ); return yuyushiki; }
// head
int n;
int a[100010];
string s;
int lens[100010];
set<int> so, sz;
priority_queue<pi,vpi,greater<pi> > qo, qz;
void add( int p , int l , bool f ){
lens[p] = l;
if( f ){
so.insert( p );
qo.emplace( l , p );
} else {
sz.insert( p );
qz.emplace( l , p );
}
}
bool check( int x ){
while( !qo.empty() ){
qo.pop();
}
while( !qo.empty() ){
qz.pop();
}
so.clear();
sz.clear();
REP( i , n ){
lens[i] = -1;
}
bool cur = a[0] >= x;
int prv = 0;
FOR( i , 1 , n ){
if( cur != ( a[i] >= x ) ){
add( prv , i-prv , cur );
prv = i;
cur = a[i] >= x;
}
}
add( prv , n-prv , cur );
int one = 0;
int zero = 0;
YYS( w , s ){
if( w == 'M' ){
one++;
} else if( 'm' ){
zero++;
} else {
assert( false );
}
// cout << w << endl;
while( !qz.empty() and qz.top().fi + zero - one <= 0 ){
assert( qz.top().fi + zero - one == 0 );
int len = qz.top().fi;
int p = qz.top().se;
qz.pop();
if( lens[p] != len ){
continue;
}
// cout << "Z " << len << " " << p << endl;
sz.erase( sz.find( p ) );
auto r = so.upper_bound( p );
if( r == so.begin() or r == so.end() ){
continue;
}
auto l = r;
l--;
lens[*l] = lens[*r] + lens[*l] + one - zero;
lens[*r] = -1;
so.erase( r );
qo.emplace( lens[*l] , *l );
}
while( !qo.empty() and qo.top().fi + one - zero <= 0 ){
assert( qo.top().fi + one - zero == 0 );
int len = qo.top().fi;
int p = qo.top().se;
qo.pop();
if( lens[p] != len ){
continue;
}
// cout << "O " << len << " " << p << endl;
so.erase( so.find( p ) );
auto r = sz.upper_bound( p );
if( r == sz.begin() or r == sz.end() ){
continue;
}
auto l = r;
l--;
lens[*l] = lens[*r] + lens[*l] + zero - one;
lens[*r] = -1;
sz.erase( r );
qz.emplace( lens[*l] , *l );
}
}
int ans = 0;
YYS( w , sz ){
int l = w - zero;
int r = w + lens[w] - one;
if( l <= 0 and 0 < r ){
assert( ans == 0 );
// cout << l << " " << r << endl;
ans = 1;
}
}
YYS( w , so ){
int l = w - one;
int r = w + lens[w] - zero;
if( l <= 0 and 0 < r ){
// cout << l << " " << r << endl;
assert( ans == 0 );
ans = 2;
}
}
assert( ans != 0 );
if( ans == 1 ){
return false;
} else {
return true;
}
}
int main(){
n = in();
REP( i , n ){
a[i] = in();
}
s = stin();
// check( 12 );
/*
REP( j , n ){
cout << ( a[j] >= 12 ) << " ";
}
cout << endl;
int b[20];
REP( i , n-1 ){
if( s[i] == 'm' ){
REP( j , n-i-1 ){
b[j] = min( a[j] , a[j+1] );
}
} else {
REP( j , n-i-1 ){
b[j] = max( a[j] , a[j+1] );
}
}
REP( j , n-i-1 ){
a[j] = b[j];
cout << ( a[j] >= 12 ) << " ";
}
cout << endl;
}
*/
int lb = 0, ub = n + 1;
while( ub - lb > 1 ){
int md = ( lb + ub ) / 2;
if( check( md ) ){
lb = md;
} else {
ub = md;
}
}
cout << lb << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> temp(100005);
vector<int> v(100005);
int fn(int l, int h, int x) {
while (h - l > 1) {
int mid = (h + l) / 2;
if (temp[mid] < x) {
l = mid + 1;
} else {
h = mid;
}
}
if (temp[l] > x)
return l;
else
return h;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int len = 1;
temp[0] = v[0];
for (int i = 1; i < n; i++) {
if (v[i] > temp[len - 1]) {
temp[len] = v[i];
len++;
} else {
int index = fn(0, len - 1, v[i]);
temp[index] = v[i];
}
}
cout << len;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
template <class T>
T SQR(const T &a) {
return a * a;
}
struct vert {
vector<int> inc;
bool was;
int f;
int h;
int comp;
vert() {
was = 0;
h = 0;
}
} g[100100];
struct vertLCA {
vector<int> inc;
int up[20];
bool was;
int h;
vertLCA() {
h = 0;
was = 0;
}
} gl[100100];
int ST[100100];
int pos = 0;
int Cnt = 0;
void dfs(int k, int fr) {
ST[pos++] = k;
g[k].was = 1;
g[k].f = g[k].h;
for (int i = (0), ei = (g[k].inc.size()); i < ei; i++)
if (!g[g[k].inc[i]].was) {
g[g[k].inc[i]].h = g[k].h + 1;
dfs(g[k].inc[i], k);
if (g[g[k].inc[i]].f > g[k].h) {
int lst = -1;
do {
lst = ST[--pos];
g[lst].comp = Cnt;
} while (lst != g[k].inc[i]);
Cnt++;
}
{
if (g[k].f > (g[g[k].inc[i]].f)) g[k].f = (g[g[k].inc[i]].f);
};
} else if (g[k].inc[i] != fr) {
if (g[k].f > (g[g[k].inc[i]].h)) g[k].f = (g[g[k].inc[i]].h);
};
}
void dfsLca(int k, int pr) {
gl[k].was = 1;
if (gl[k].h != 0) {
gl[k].up[0] = pr;
for (int i = (1), ei = (20); i < ei; i++)
gl[k].up[i] = gl[gl[k].up[i - 1]].up[i - 1];
}
for (int i = (0), ei = (gl[k].inc.size()); i < ei; i++)
if (!gl[gl[k].inc[i]].was) {
gl[gl[k].inc[i]].h = gl[k].h + 1;
dfsLca(gl[k].inc[i], k);
}
}
int getAns(int a, int b) {
if (gl[a].h > gl[b].h) swap(a, b);
int d = gl[b].h - gl[a].h;
int res = d;
for (int i = (0), ei = (20); i < ei; i++)
if (d & (1 << i)) b = gl[b].up[i];
if (a == b) return d;
int st = 0;
while ((1 << st) <= gl[a].h) st++;
st--;
for (int j = st; j >= 0; j--)
if (gl[a].up[j] != gl[b].up[j]) {
res += 1 << (j + 1);
a = gl[a].up[j];
b = gl[b].up[j];
}
return res + 2;
}
void run() {
int n, m;
scanf("%d%d", &n, &m);
pair<int, int> E[100100];
for (int i = (0), ei = (m); i < ei; i++) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
g[a].inc.push_back(b);
g[b].inc.push_back(a);
E[i].first = a;
E[i].second = b;
}
dfs(0, -1);
int lst = -1;
do {
lst = ST[--pos];
g[lst].comp = Cnt;
} while (lst != 0);
Cnt++;
for (int i = (0), ei = (m); i < ei; i++)
if (g[E[i].first].comp != g[E[i].second].comp) {
gl[g[E[i].first].comp].inc.push_back(g[E[i].second].comp);
gl[g[E[i].second].comp].inc.push_back(g[E[i].first].comp);
}
for (int i = (0), ei = (Cnt); i < ei; i++) {
sort((gl[i].inc).begin(), (gl[i].inc).end());
gl[i].inc.resize(unique((gl[i].inc).begin(), (gl[i].inc).end()) -
gl[i].inc.begin());
}
dfsLca(0, -1);
int k;
cin >> k;
for (int i = (0), ei = (k); i < ei; i++) {
int a, b;
scanf("%d%d", &a, &b);
--a;
--b;
int ca = g[a].comp;
int cb = g[b].comp;
int res = getAns(ca, cb);
printf("%d\n", res);
}
}
int main() {
time_t beg = clock();
run();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define uint unsigned int
#define pb push_back
#define str string
#define mp make_pair
#define fi first
#define se second
#define sz(a) (int)(a.size())
#define REP(i, n) for(int i = 0; i < (int)n; ++i)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
const double PI = acos(-1.0);
const int maxn = (int)5e5 + 13;
void solve(){
int u, v; cin >> u >> v;
if(u > v){
puts("no");
return;
}
vector<int> abit, bbit;
REP(i, 31){
int p = 1 << i;
if(u & p)
abit.pb(i);
if(v & p)
bbit.pb(i);
}
if(sz(abit) < sz(bbit)){
puts("no");
return;
}
for(int i = 0; i < sz(bbit); ++i){
if(abit[i] > bbit[i]){
puts("no");
return;
}
}
puts("yes");
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int q; cin >> q;
while(q--)
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int n, m;
int cost[MAXN];
struct Race {
int l, r, profit;
bool operator<(const Race &race) const {
if (r == race.r) {
return l < race.l;
}
return r < race.r;
}
} race[MAXN];
struct Tree {
int l, r;
long long lazy, maxVal;
} tree[MAXN * 3];
long long dp[MAXN];
inline int lc(int x) { return x * 2; }
inline int rc(int x) { return lc(x) + 1; }
inline void pushUp(int x) {
tree[x].maxVal = max(tree[lc(x)].maxVal, tree[rc(x)].maxVal);
}
void pushDown(int x) {
if (tree[x].lazy) {
tree[lc(x)].lazy += tree[x].lazy;
tree[rc(x)].lazy += tree[x].lazy;
tree[lc(x)].maxVal += tree[x].lazy;
tree[rc(x)].maxVal += tree[x].lazy;
tree[x].lazy = 0;
}
}
void build(int x, int l, int r) {
tree[x].l = l;
tree[x].r = r;
tree[x].lazy = 0;
tree[x].maxVal = 0;
if (tree[x].l == tree[x].r) {
return;
}
int mid = (l + r) / 2;
build(lc(x), l, mid);
build(rc(x), mid + 1, r);
}
void update(int x, int l, int r, long long val) {
if (tree[x].l == l && tree[x].r == r) {
tree[x].lazy += val;
tree[x].maxVal += val;
return;
}
pushDown(x);
int mid = (tree[x].l + tree[x].r) / 2;
if (r <= mid) {
update(lc(x), l, r, val);
} else if (l > mid) {
update(rc(x), l, r, val);
} else {
update(lc(x), l, mid, val);
update(rc(x), mid + 1, r, val);
}
pushUp(x);
}
inline long long query() { return tree[1].maxVal; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &cost[i]);
}
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &race[i].l, &race[i].r, &race[i].profit);
}
sort(race, race + m);
int idx = 0;
build(1, 0, n);
for (int i = 1; i <= n; ++i) {
update(1, 0, i - 1, -cost[i]);
while (idx < m && race[idx].r <= i) {
update(1, 0, race[idx].l - 1, race[idx].profit);
++idx;
}
dp[i] = max(dp[i - 1], query());
update(1, i, i, dp[i]);
}
cout << dp[n] << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
void precalc() {}
const int maxn = 2e3 + 10;
int n;
vector<vector<int> > to[2];
vector<vector<int> > inv[2];
bool read() {
int m[2];
if (scanf("%d%d%d", &n, &m[0], &m[1]) < 3) {
return false;
}
for (int it = 0; it < 2; ++it) {
to[it] = vector<vector<int> >(2 * n);
inv[it] = vector<vector<int> >(2 * n);
for (int i = 0; i < m[it]; ++i) {
int x, y;
scanf("%d%d", &x, &y);
if (x < 0) {
x = -x;
} else {
x += n;
}
if (y < 0) {
y = -y;
} else {
y += n;
}
--x, --y;
x = (x + n) % (2 * n);
for (int q = 0; q < 2; ++q) {
to[it][x].push_back(y);
inv[it][y].push_back(x);
x = (x + n) % (2 * n);
y = (y + n) % (2 * n);
swap(x, y);
}
}
}
return true;
}
bool used[maxn];
int clr[2][maxn];
vector<vector<int> > cto[2];
int cnt[2];
vector<int> top;
void topsort(int v, int it) {
used[v] = true;
for (auto u : to[it][v]) {
if (!used[u]) {
topsort(u, it);
}
}
top.push_back(v);
}
void condense(int v, int it) {
used[v] = true;
for (auto u : inv[it][v]) {
if (used[u]) {
continue;
}
clr[it][u] = clr[it][v];
condense(u, it);
}
}
bitset<maxn> b[2][maxn];
bool cool[2];
int ans[maxn];
void solve(int it, const vector<int>& st) {
bitset<maxn> tmp;
tmp.reset();
for (auto v : st) {
tmp[v] = 1;
}
for (int v = 0; v < n; ++v) {
bool fnd = false;
for (int q = 0; q < 2; ++q) {
bitset<maxn> tmp2 = tmp | b[it][clr[it][v + q * n]];
if ((tmp2 & (tmp2 >> n)).count()) {
continue;
}
fnd = true;
tmp = tmp2;
ans[v] = q;
break;
}
assert(fnd);
}
for (int i = 0; i < n; ++i) {
printf("%d%c", ans[i], " \n"[i == n - 1]);
}
}
void solve() {
for (int it = 0; it < 2; ++it) {
memset(used, 0, sizeof(used[0]) * (2 * n));
top.clear();
for (int i = 0; i < 2 * n; ++i) {
if (!used[i]) {
topsort(i, it);
}
}
assert(((int)(top).size()) == 2 * n);
reverse(top.begin(), top.end());
cnt[it] = 0;
memset(used, 0, sizeof(used[0]) * (2 * n));
for (auto v : top) {
if (used[v]) {
continue;
}
clr[it][v] = cnt[it]++;
condense(v, it);
}
cto[it] = vector<vector<int> >(cnt[it]);
for (int v = 0; v < 2 * n; ++v) {
for (auto u : to[it][v]) {
if (clr[it][v] == clr[it][u]) {
continue;
}
cto[it][clr[it][v]].push_back(clr[it][u]);
}
}
for (int v = 0; v < cnt[it]; ++v) {
b[it][v].reset();
}
for (int v = 0; v < 2 * n; ++v) {
b[it][clr[it][v]][v] = 1;
}
for (int v = cnt[it] - 1; v >= 0; --v) {
for (auto u : cto[it][v]) {
b[it][v] |= b[it][u];
}
}
cool[it] = true;
for (int v = 0; v < n; ++v) {
int c1 = clr[it][v], c2 = clr[it][n + v];
if (c1 == c2) {
cool[it] = false;
break;
}
}
}
if (!cool[0] && !cool[1]) {
printf("SIMILAR\n");
return;
}
if (!cool[0] || !cool[1]) {
solve(cool[0] ? 0 : cool[1], vector<int>());
return;
}
for (int it = 0; it < 2; ++it) {
for (int v = 0; v < 2 * n; ++v) {
for (auto u : to[it][v]) {
int x = v, y = (u + n) % (2 * n);
bitset<maxn> tmp = b[!it][clr[!it][x]] | b[!it][clr[!it][y]];
if (!((tmp >> n) & tmp).count()) {
solve(!it, {x, y});
return;
}
}
}
}
printf("SIMILAR\n");
}
int main() {
srand(rdtsc());
precalc();
while (true) {
if (!read()) {
break;
}
solve();
}
return 0;
}
| 12 | CPP |
# ///==========Libraries, Constants and Functions=============///
#mkraghav
import sys
inf = float("inf")
mod = 1000000007
def get_array(): return list(map(int, sys.stdin.readline().split()))
def get_ints(): return map(int, sys.stdin.readline().split())
def input(): return sys.stdin.readline()
def int1():return int(input())
import string
import math
from itertools import combinations
# ///==========MAIN=============///
def main():
t=int(input())
while t>0:
n,s,k=get_array()
print(n - min(s,k) + 1)
t=t-1
if __name__ == "__main__":
main()
| 7 | PYTHON3 |
k=int(input())
l=int(input())
m=int(input())
n=int(input())
d=int(input())
temp=[]
for i in range(d):
temp.append(False)
arr=[k,l,m,n]
arr=sorted(arr)
#print(arr)
k=arr[0]
l=arr[1]
m=arr[2]
n=arr[3]
i=1
while k*i <= d:
temp[k*i-1]=True
if l*i <d:
temp[l*i-1]=True
if m*i <d:
temp[m*i-1]=True
if n*i <d:
temp[n*i-1]=True
#print(i)
i=i+1
# for i in temp:
# print(i,end=' ')
# print()
count=0
for i in range(d):
if temp[i]:
count=count+1
print(count)
| 7 | PYTHON3 |
"""
Author : co_devil Chirag Garg
Institute : JIIT
"""
from __future__ import division, print_function
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
# from heapq import nsmallest, nlargest, heapify, #heappop ,heappush, heapreplace
from math import ceil,floor,log,sqrt,factorial,pow,pi
# from bisect import bisect_left,bisect_right
# from decimal import *,threading
"""from io import BytesIO, IOBase
if sys.version_info[0] < 3:
from __builtin__ import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
else:
from builtins import str as __str__
str = lambda x=b'': x if type(x) is bytes else __str__(x).encode()
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._buffer = BytesIO()
self._fd = file.fileno()
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):
return self._buffer.read() if self._buffer.tell() else os.read(self._fd, os.fstat(self._fd).st_size)
def readline(self):
while self.newlines == 0:
b, ptr = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE)), self._buffer.tell()
self._buffer.seek(0, 2), self._buffer.write(b), self._buffer.seek(ptr)
self.newlines += b.count(b'\n') + (not b)
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)
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
input = lambda: sys.stdin.readline().rstrip(b'\r\n')
def print(*args, **kwargs):
sep, file = kwargs.pop('sep', b' '), kwargs.pop('file', sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop('end', b'\n'))
if kwargs.pop('flush', False):
file.flush()
"""
def ii(): return int(input())
def si(): return str(input())
def mi(): return map(int,input().split())
def li(): return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12,
'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24,
'z': 25}
mod = 1000000007
dx, dy = [-1, 1, 0, 0], [0, 0, 1, -1]
def getKey(item): return item[0]
def sort2(l): return sorted(l, key=getKey)
def d2(n, m, num): return [[num for x in range(m)] for y in range(n)]
def isPowerOfTwo(x): return (x and (not (x & (x - 1))))
def decimalToBinary(n): return bin(n).replace("0b", "")
def ntl(n): return [int(i) for i in str(n)]
def powerMod(x, y, p):
res = 1
x %= p
while y > 0:
if y & 1:
res = (res * x) % p
y = y >> 1
x = (x * x) % p1
return res
def gcd(x, y):
while y:
x, y = y, x % y
return x
# For getting input from input.txt file
# sys.stdin = open('input.txt', 'r')
# Printing the Output to output.txt file
# sys.stdout = open('output.txt', 'w')
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000
def dfs(v, c):
if visited[v]:
if col[v] != c:
print('-1')
exit()
return
col[v] = c
visited[v] = 1
for i in graph[v]:
dfs(i, c ^ 1)
def bfs(d,v):
q=[]
q.append(v)
visited[v]=1
while len(q)!=0:
x=q[0]
q.pop(0)
for i in d[x]:
if visited[i]!=1:
visited[i]=1
q.append(i)
print(x)
def make_graph():
d={}
v,e=mi()
for i in range(e):
x,y=mi()
if x not in d.keys():
d[x]=[y]
else:
d[x].append(y)
if y not in d.keys():
d[y] = [x]
else:
d[y].append(x)
return d
def gr2(l,n):
d={}
for i in range(1,n+1):
if i not in d.keys():
d[i]=l[i]
else:
d[i].append(l[i])
return d
n=ii()
s=si()
r = 1
l = 1
for i in range(1, n):
if s[0] == s[i]:
l += 1
else:
break
for i in range(2, n):
if s[-1] == s[-i]:
r += 1
else:
break
if s[0] == s[-1]:
print(((l + 1) * (r + 1)) % 998244353)
else:
print((l + r + 1) % 998244353) | 8 | PYTHON3 |
s = input()
n = int(input())
result = [0]
score = 0
for i in range(len(s)-1):
if s[i]==s[i+1]:
score += 1
else:
score += 0
result.append(score)
for i in range(n):
a,b = [int(i) for i in input().split(' ')]
print(result[b-1]-result[a-1]) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define f first
#define s second
ll n , m , mod = 998244353 , a[22][55555] , dp[22] , P[22][22];
ll fp(ll base, ll exp)
{
if (exp == 0)
return 1;
ll ans = fp(base, exp / 2);
ans = (ans * ans) % mod;
if (exp % 2 != 0)
ans = (ans * (base % mod)) % mod;
return ans;
}
void calc(vector<ll> v)
{
sort(v.begin() , v.end() , greater<ll>() );
memset(dp , 0 , sizeof(dp));
int j=0 , valid=0;
dp[0] = 1;
for(int i=1; i<=n; i++) //dp[i] = probability that first i cities will not have curr point
{
while(j < v.size() && n-i+1 < v[j])
{
valid++;
j++;
}
if (!valid) return;
int rem = n-i+1;
dp[i] = (P[valid][rem] * dp[i-1])%mod;
valid--;
}
}
int main()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
for(int i=1; i<=20; i++)
{
for(int j=1; j<=20; j++)
{
P[i][j] = (1ll*i*fp(j , mod-2))%mod;
}
}
cin >> n >> m;
for(int i=1; i<=n; i++)
{
for(int j=1; j<=m; j++)
cin >> a[i][j];
}
ll ans = 0;
for(ll i=1; i<=m; i++)
{
vector<ll> v;
for(int j=1; j<=n; j++)
{
v.push_back(a[j][i]);
}
calc(v);
ans = (ans + (1 - dp[n] + mod))%mod;
}
cout << ans << '\n';
return 0;
} | 11 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.