solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
string s;
map<string, int> mp;
map<string, int> id;
int kunset[100005];
int mn[100005];
int a[100005];
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int n, m, k, x;
cin >> n >> k >> m;
for (int i = 1; i <= n; i++) cin >> s, mp[s] = i;
for (int i = 1; i <= n; i++) cin >> a[i], mn[i] = 1e9 + 5;
for (int i = 1, j; i <= k; i++) {
cin >> x;
while (x--) cin >> j, kunset[j] = i, mn[i] = min(mn[i], a[j]);
}
long long ans = 0;
while (cin >> s) {
ans += mn[kunset[mp[s]]];
}
cout << ans;
}
| 1,200 | CPP |
n=int(input())
d={'Tetrahedron':4,'Cube':6,'Octahedron':8,'Dodecahedron':12,'Icosahedron':20}
c=0
for i in range(n):
s=input()
c=c+d[s]
print(c)
| 800 | PYTHON3 |
from collections import Counter
l1=input()
l2 = [int(x) for x in input().split()]
l3 = [int(x) for x in input().split()]
l4 = [int(x) for x in input().split()]
ct = Counter(l2)
ct2=Counter(l3)
ct3=Counter(l4)
ans1 = ct-ct2
print(list(ans1.keys())[0])
ans2=ct2 - ct3
print(list(ans2.keys())[0])
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 300;
int a[N], b[N];
int n, m;
int check(int x) {
int y = 0;
for (int i = 0; i < n; i++) {
if (a[i] <= y) {
if (y - a[i] <= x) {
b[i] = y;
} else {
return false;
}
} else {
if (m - a[i] + y <= x) {
b[i] = y;
} else {
b[i] = a[i];
}
}
y = b[i];
}
return true;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int l = -1, r = m;
while (r - l > 1) {
int mid = (l + r) / 2;
if (check(mid)) {
r = mid;
} else {
l = mid;
}
}
cout << r << " ";
}
| 1,700 | CPP |
a = int(input())
b = int(input())
c = int(input())
d = int(input())
e = int(input())
f = int(input())
s = 0
if e>=f:
l = [a,d]
s += min(l)*e
d -= min(l)
l = [b,c,d]
s += min(l)*f
d -= min(l)
else:
l = [b,c,d]
s += min(l)*f
d -= min(l)
l = [a,d]
s += min(l)*e
d -= min(l)
print(s)
| 800 | PYTHON3 |
x=int(input())
a=list(map(int,input().split()))
a.sort(reverse=True)
z=sum(a)
chu=0
k=0
while z>=chu:
chu+=a[0]
a.pop(0)
z=sum(a)
k+=1
print(k) | 900 | PYTHON3 |
n = int(input())
a = n + 1
while True:
used = []
b = a
a0 = b // 1000
b = b % 1000
a1 = b // 100
b = b % 100
a2 = b // 10
b = b % 10
a3 = b // 1
used.append(a0)
if a1 not in used:
used.append(a1)
if a2 not in used:
used.append(a2)
if a3 not in used:
used.append(a3)
if len(used) == 4:
print(a)
break
else:
a += 1 | 800 | PYTHON3 |
t = int(input())
for i in range(t):
n = int(input())
models = list(map(int, input().split()))
costs = [1] * n
for divisor in range(1, (n // 2) + 2):
for division in range(divisor - 1, n, divisor):
if models[division] > models[divisor - 1]:
if costs[divisor - 1] + 1 > costs[division]:
costs[division] = costs[divisor - 1] + 1
print(max(costs))
| 1,400 | PYTHON3 |
t = int(input())
while t>0:
t -= 1
s = input()
sp = s.split("1")[1:-1]
ans = 0
for p in sp:
ans += len(p)
print(ans) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, maxw, w[1011], b[1011], cnt, wcc[1011], bcc[1011], dp[1011][1011];
bool vis[1011];
vector<int> vt[1011], cc[1011];
void Visit(int x) {
cc[cnt].push_back(x);
wcc[cnt] = wcc[cnt] + w[x];
bcc[cnt] = bcc[cnt] + b[x];
vis[x] = true;
for (int j = 0; j < vt[x].size(); j++) {
int y = vt[x][j];
if (!vis[y]) Visit(y);
}
}
int slv(int i, int j) {
if (j > maxw) return -1e9;
if (i == cnt + 1) return 0;
if (dp[i][j] != -1) return dp[i][j];
int nw = 0;
for (int k = 0; k < cc[i].size(); k++) {
int x = cc[i][k];
nw = max(nw, slv(i + 1, j + w[x]) + b[x]);
}
nw = max(nw, slv(i + 1, j + wcc[i]) + bcc[i]);
nw = max(nw, slv(i + 1, j));
return dp[i][j] = nw;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> maxw;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= n; i++) cin >> b[i];
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
vt[u].push_back(v);
vt[v].push_back(u);
}
for (int i = 1; i <= n; i++)
if (!vis[i]) {
cnt++;
Visit(i);
}
memset(dp, -1, sizeof(dp));
cout << slv(1, 0);
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int limN = 1e5 + 5;
int g[limN];
int main() {
int _N;
scanf("%d", &_N);
for (int n = 1; n <= _N; n++) {
set<int> ats;
for (int s = 3, s2, k = 2; s <= n; k++, s = s2) {
s2 = s + (k + 1);
if ((n - s) % k) continue;
int b = (n - s) / k;
ats.insert(g[b + k] ^ g[b]);
}
if (!ats.empty()) {
auto it = ats.begin();
if (*it == 0) {
int u = *it;
it++;
for (; it != ats.end(); it++) {
if (*it != u + 1) break;
u = *it;
}
g[n] ^= u + 1;
}
}
g[n] ^= g[n - 1];
}
if ((g[_N] ^ g[_N - 1]) == 0) {
printf("-1\n");
return 0;
}
for (int s = 3, s2, k = 2; s <= _N; k++, s = s2) {
s2 = s + (k + 1);
if ((_N - s) % k) continue;
int b = (_N - s) / k;
if ((g[b + k] ^ g[b]) == 0) {
printf("%d\n", k);
return 0;
}
}
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1.01e9;
const double eps = 1e-9;
const int N = 3010;
pair<int, int> a[N];
set<int> second;
int d[N];
int R[N];
int L[N];
int to[N];
int cnt[N];
long long val = 0;
int c, k;
inline int f(int y) {
if (cnt[y] >= k) return (c - to[y]) * (y - L[y]);
return 0;
}
void upd(int y) {
if (d[y] == 0) {
set<int>::iterator it = second.lower_bound(y);
to[y] = y;
if (it != second.end()) {
R[y] = *it;
int z = R[y];
while (z < c && cnt[y] < k) {
cnt[y] += d[z];
if (cnt[y] >= k) break;
z = R[z];
}
to[y] = z;
}
if (it != second.begin()) {
--it;
L[y] = *it;
R[L[y]] = y;
int z = L[y];
while (z >= 0) {
if (cnt[z] >= k) break;
to[z] = max(to[z], y);
z = L[z];
}
}
val += f(y);
if (R[y] < c) {
val -= f(R[y]);
L[R[y]] = y;
val += f(R[y]);
}
L[R[y]] = y;
if (to[y] == c) to[y] = L[c];
second.insert(y);
}
d[y]++;
int z = y;
while (z >= 0) {
if (to[z] < y) break;
val -= f(z);
cnt[z] += 1;
val += f(z);
if (to[z] < c) {
if (cnt[z] - d[to[z]] >= k) {
val -= f(z);
cnt[z] -= d[to[z]];
to[z] = L[to[z]];
val += f(z);
}
}
z = L[z];
}
}
int main() {
int r, n;
scanf("%d%d%d%d", &r, &c, &n, &k);
for (int i = 0; (i) < (n); ++i) {
int x, y;
scanf("%d%d", &x, &y);
--x, --y;
a[i] = make_pair(x, y);
}
sort(a, a + n);
long long res = 0;
for (int rst = 0; rst < r; ++rst) {
int pos = 0;
while (pos < n && a[pos].first < rst) pos++;
val = 0;
second.clear();
for (int i = 0; (i) < (c + 1); ++i) R[i] = c;
for (int i = 0; (i) < (c + 1); ++i) L[i] = -1;
for (int i = 0; (i) < (c); ++i) d[i] = 0, to[i] = 0, cnt[i] = 0;
for (int ren = rst; ren < r; ++ren) {
while (pos < n && a[pos].first == ren) {
upd(a[pos].second);
pos++;
}
res += val;
}
}
printf("%I64d\n", res);
return 0;
}
| 3,000 | CPP |
from collections import Counter
colors_count = len(Counter(input().split(' ')))
print(4 - colors_count)
| 800 | PYTHON3 |
t=int(input())
cnt=0
for _ in range(t):
team = list(map(int, input().split()))
if sum(team)>1:
cnt+=1
print(cnt)
| 800 | PYTHON3 |
import sys, random
from bisect import bisect_left, bisect_right
input = sys.stdin.readline
def main():
inf = 10 ** 20
t = int(input())
# t, a, b = map(int, input().split())
# t = 1
for _ in range(1, t+1):
# print("Case #{}: ".format(_), end = '')
ab = [[int(x) for x in input().split()] for i in range(2)]
ok = 1
if(ab[0][0] == ab[1][0]):
ok = 1
elif(ab[0][0] == ab[1][1]):
ab[1][0], ab[1][1] = ab[1][1], ab[1][0]
elif(ab[0][1] == ab[1][0]):
ab[0][0], ab[0][1] = ab[0][1], ab[0][0]
elif(ab[0][1] == ab[1][1]):
ab[0][0], ab[0][1] = ab[0][1], ab[0][0]
ab[1][0], ab[1][1] = ab[1][1], ab[1][0]
else:
ok = 0
ok1 = 0
if(ab[0][0] == ab[1][0] and ab[0][0] == ab[0][1] + ab[1][1]):
ok1 = 1
if(ab[0][1] == ab[1][1] and ab[0][1] == ab[0][0] + ab[1][0]):
ok1 = 1
if(ok and ok1):
print("YES")
else:
print("NO")
main() | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MD = 998244353;
const int INF = 1e9 + 9;
const long long LINF = 1e18 + 9;
const int N = 5e5 + 33;
long long n, m, k, t;
long long arr[N];
int main() {
cin >> m >> n;
int mid = (m + 1) / 2;
for (int i = 0; i < n; i++) {
cout << 1 << endl << flush;
cin >> arr[i];
if (arr[i] == 0) return 0;
}
int i = 0;
int l = 1, r = m;
while (l <= r) {
mid = (l + r) / 2;
cout << mid << endl << flush;
int p = 0;
cin >> p;
if (p == 0) break;
if (p * arr[i] == 1) {
l = mid + 1;
} else {
r = mid;
}
i++;
if (i == n) i = 0;
}
return 0;
}
| 1,800 | CPP |
def main():
t = int(input())
for i in range(t):
solve()
def solve():
n = int(input())
print(n // 2)
main() | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long, long long> > adj[100005];
priority_queue<pair<long long, long long> > pq;
stack<long long> q;
long long dist[100005], a, b, w, n, m, bef[100005];
bool processed[100005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a >> b >> w;
adj[a].push_back(make_pair(w, b));
adj[b].push_back(make_pair(w, a));
}
for (int i = 1; i <= n; i++) dist[i] = 1e18;
memset(processed, 0, sizeof processed);
memset(bef, -1, sizeof bef);
dist[1] = 0;
bef[1] = 0;
pq.push(make_pair(0, 1));
while (!pq.empty()) {
long long a = pq.top().second;
pq.pop();
if (processed[a]) {
continue;
}
processed[a] = true;
for (auto u : adj[a]) {
if (dist[u.second] > dist[a] + u.first) {
dist[u.second] = dist[a] + u.first;
bef[u.second] = a;
pq.push(make_pair(-dist[u.second], u.second));
}
}
}
if (bef[n] == -1) {
cout << "-1" << '\n';
return 0;
}
long long x = n;
bef[1] = 0;
while (x != 0) {
q.push(x);
if (bef[x] == -1) {
cout << "-1" << '\n';
return 0;
}
x = bef[x];
}
long long qs = q.size();
cout << q.top();
q.pop();
for (int i = 2; i <= qs; i++) {
cout << " " << q.top();
q.pop();
}
cout << '\n';
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int t;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v(n);
for (int &x : v) {
cin >> x;
}
int c = 0, u = 0;
for (int i = 0; i < n; i++) {
if (v[i] == 1) {
u++;
} else {
c++;
}
}
if (c >= n / 2) {
cout << n / 2 << "\n";
for (int i = 0; i < n / 2; i++) {
cout << 0 << " ";
}
cout << "\n";
} else {
int mid = n / 2;
if (mid % 2 == 0) {
cout << n / 2 << "\n";
for (int i = 0; i < n / 2; i++) {
cout << 1 << " ";
}
cout << "\n";
} else {
cout << (n / 2) + 1 << "\n";
for (int i = 0; i < (n / 2) + 1; i++) {
cout << 1 << " ";
}
cout << "\n";
}
}
}
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-12;
int main() {
double x0, y0, v, t;
scanf("%lf %lf %lf %lf", &x0, &y0, &v, &t);
double r0 = v * t;
int n;
scanf("%d", &n);
vector<pair<double, double> > list;
while (n--) {
double x, y, r;
scanf("%lf %lf %lf", &x, &y, &r);
double d = sqrt((x - x0) * (x - x0) + (y - y0) * (y - y0));
if (d < r + eps) {
printf("%lf\n", 1.0);
return 0;
}
if (r + r0 < d - eps) continue;
double mid = atan2(y - y0, x - x0);
if (mid < 0) mid += 2 * pi;
double range;
double tan = sqrt(d * d - r * r);
if (tan < r0 + eps)
range = asin(r / d);
else
range = acos((r0 * r0 - r * r + d * d) / (2 * d * r0));
double begin = mid - range;
double end = mid + range;
if (begin < 0)
list.push_back(pair<double, double>(begin + 2 * pi, 2 * pi)), begin = 0;
if (end > 2 * pi)
list.push_back(pair<double, double>(0, end - 2 * pi)), end = 2 * pi;
list.push_back(pair<double, double>(begin, end));
}
double sum = 0;
double begin = -1;
double end = -1;
sort(list.begin(), list.end());
for (auto p : list) {
if (p.first < end)
end = max(end, p.second);
else {
sum += (end - begin);
begin = p.first;
end = p.second;
}
}
sum += (end - begin);
printf("%lf\n", sum / (2 * pi));
}
| 2,500 | CPP |
#list(map(int,input().split()))
t=int(input())
for _ in range(t):
n=int(input())
aa=list(map(int,input().split()))
bb=list(map(int,input().split()))
aa.sort()
bb.sort()
print(*aa)
print(*bb)
| 800 | PYTHON3 |
MAX = 2e10
def solution(nums):
dis = dict()
dista = MAX
for i in range(0,len(nums)-1):
mini = abs(nums[i]-nums[i+1])
if dis.get(mini) == None:
dis[mini] = 1
else:
dis[mini] += 1
dista = min(dista,mini)
return "{} {}".format(dista, dis[dista])
def main():
n = input()
nums = sorted([int(x) for x in input().split()])
print(solution(nums))
main()
| 1,100 | PYTHON3 |
t=int(input())
for _ in range(t):
n=int(input())
if n==1:
print(0)
else:
a=(n-1)//2
b=a*(a+1)*((2*a)+1)
print((8*b)//6) | 1,000 | PYTHON3 |
k=int(input())
n=input().split()
for i in range (k):
n[i]=int(n[i])
if k>=2 and k<=100000:
for i in range(0,k-1):
n[i]=int(n[i])+int(n[i+1])
print(n[i],'',end='')
print (n[k-1])
| 800 | PYTHON3 |
try:
for _ in range(int(input())):
a=input()
b=[0]
for i in range(len(a)):
if a[i]=='1':
b[-1]=b[-1]+1
else:
if b[-1]!=0:
b.append(0)
b.sort()
b.reverse()
ans=0
for i in range(0,len(b),2):
ans+=b[i]
print(ans)
except Exception as e:
print(e) | 800 | PYTHON3 |
input()
f = input()
if f.count('xxx') == 0:
print("0")
else:
i = 0
p = f.find('xxx')
while p != -1:
f = f.replace('xxx', 'xx', 1)
i += 1
p = f.find('xxx')
print(i)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long int f[100010];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%I64d", &f[i]);
long long int mini, maxi;
long long int t1, t2, t3, t4;
maxi = f[n] - f[1];
mini = f[2] - f[1];
cout << mini << " " << maxi << endl;
for (int i = 2; i <= n - 1; i++) {
t1 = f[i] - f[i - 1];
t2 = f[i + 1] - f[i];
if (t1 > t2)
mini = t2;
else
mini = t1;
t3 = f[i] - f[1];
t4 = f[n] - f[i];
if (t3 > t4)
maxi = t3;
else
maxi = t4;
cout << mini << " " << maxi << endl;
}
maxi = f[n] - f[1];
mini = f[n] - f[n - 1];
cout << mini << " " << maxi << endl;
return 0;
}
| 900 | CPP |
n=int(input())
arr=[int(x) for x in input().split()]
for i in range(n):
arr[i]-=1
s=False
for i in range(n):
pos=arr[i]
count=1
while(count<3):
count+=1
pos=arr[pos]
if(pos==i):
print("YES")
s=True
break
if(s==False):
print("NO") | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
string name;
int a;
int high;
};
bool cmp(node x, node y) { return x.a < y.a; }
int main() {
int n;
scanf("%d", &n);
node people[n + 1];
for (int i = 1; i <= n; ++i) {
cin >> people[i].name >> people[i].a;
people[i].high = 0;
}
sort(people + 1, people + n + 1, cmp);
bool k = true;
if (people[1].a != 0) {
k = false;
}
if (k) {
for (int i = 1; i < n + 1; ++i) {
if (i - 1 < people[i].a) {
k = false;
break;
}
people[i].high = i - people[i].a;
for (int j = 1; j < i; ++j) {
if (people[j].high >= people[i].high) {
people[j].high++;
}
}
}
}
if (!k) {
printf("-1\n");
} else {
for (int i = 1; i <= n; ++i) {
cout << people[i].name << " " << people[i].high << endl;
}
}
return 0;
}
| 1,800 | CPP |
from collections import Counter
t = list(map(int, input().split()))
c = Counter(t)
cc = []
for elem in c:
if c[elem] > 1:
cc.append(elem)
m = sum(t)
for elem in cc:
m = min(m, sum(t) - min(c[elem], 3) * elem)
print(m)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int N;
double sum = 0, x, y;
scanf("%d", &N);
for (int i = 0; i < (N); i++) {
scanf("%lf%lf", &x, &y);
sum += y;
}
printf("%.4lf\n", 5 + sum / N);
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a, t, sum, b[500005], ans, n;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a;
sum += a;
b[i] = sum;
}
for (int i = 1; i <= n; i++) {
if (i > 1 && i < n && b[i] * 3 == b[n] * 2) ans += t;
if (b[i] * 3 == b[n]) t++;
}
cout << ans << endl;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long x, y, c[6], ans;
void solve() {
cin >> x >> y;
ans = 0;
for (int i = 0; i < 6; i++) cin >> c[i];
for (int i = 0; i < 100; i++) {
c[0] = min(c[0], c[1] + c[5]);
c[1] = min(c[1], c[0] + c[2]);
c[2] = min(c[2], c[3] + c[1]);
c[3] = min(c[3], c[4] + c[2]);
c[4] = min(c[4], c[3] + c[5]);
c[5] = min(c[5], c[0] + c[4]);
}
if (x * y <= 0) {
if (x > 0)
ans += c[5] * x;
else
ans += c[2] * llabs(x);
if (y > 0)
ans += c[1] * y;
else
ans += c[4] * llabs(y);
} else if (x < 0) {
ans += llabs(max(x, y)) * c[3];
if (x < y)
ans += (y - x) * c[2];
else
ans += (x - y) * c[4];
} else {
ans += min(x, y) * c[0];
if (x < y)
ans += (y - x) * c[1];
else
ans += (x - y) * c[5];
}
cout << ans << '\n';
}
int main() {
int t;
cin >> t;
while (t--) solve();
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
void Solve() {
int n;
cin >> n;
int tmp = n / 3;
cout << (tmp + ((n % 3) == 1)) << " " << tmp + ((n % 3) == 2) << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
Solve();
}
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long const inf = 1e9;
int main() {
long long n;
cin >> n;
long long len[n], maxi[n];
long long MAX = 0;
for (int i = (0); i < (n); i++) {
long long m;
cin >> m;
long long x;
len[i] = m;
maxi[i] = 0;
for (int j = (0); j < (m); j++) {
cin >> x;
maxi[i] = max(maxi[i], x);
MAX = max(x, MAX);
}
}
long long r = 0;
for (int i = (0); i < (n); i++) {
r += len[i] * (MAX - maxi[i]);
}
cout << r << endl;
return 0;
}
| 1,300 | CPP |
n = int(input())
level1 = [int(x) for x in input().split()]
level1.pop(0)
level2 = [int(x) for x in input().split()]
level2.pop(0)
level1 = list(set(level1))
level2 = list(set(level2))
level = level1 + level2
for i in range(1, n + 1):
if i not in level:
print("Oh, my keyboard!")
quit()
print("I become the guy.")
| 800 | PYTHON3 |
n = int(input().strip())
c = 0
for i in range(0, n):
p, q = map(int, input().strip().split(' '))
if abs(q - p) >= 2:
c += 1
print(c) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int dfn[2005], low[2005], fg[2005], cnt, n, head[2005], cmp, te, num;
int sta[2005];
struct st {
int to, next;
} qe[4000005];
void addedge(int u, int v) {
cmp++;
qe[cmp].to = v;
qe[cmp].next = head[u];
head[u] = cmp;
}
void tarjan(int u) {
te++;
low[u] = dfn[u] = te;
fg[u] = 0;
num++;
sta[num] = u;
for (int i = head[u]; i != -1; i = qe[i].next) {
int j = qe[i].to;
if (!dfn[j]) {
tarjan(j);
low[u] = min(low[u], low[j]);
} else if (fg[j] == 0)
low[u] = min(low[u], dfn[j]);
}
if (dfn[u] == low[u]) {
cnt++;
while (sta[num] != u) {
fg[sta[num]] = cnt;
num--;
}
fg[u] = cnt;
num--;
}
}
int main() {
cin >> n;
int i, j, k;
memset(head, -1, sizeof(head));
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) {
scanf("%d", &k);
if (k != 0 && i != j) addedge(i, j);
}
for (i = 1; i <= n; i++)
if (!dfn[i]) tarjan(i);
if (cnt == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 2,200 | CPP |
for _ in range(int(input())):
n = int(input())
fSt = list(input())
sSt = list(input())
flag, res = True, []
for i in range(n):
if fSt[i] == sSt[i]:continue
fP, sP = -1, -1
for j in range(i+1, n, 1):
if fSt[j] != sSt[j] and fP == -1:fP = j
if fSt[i] == sSt[j]:
sP = j
break
if sP == -1:
for j in range(i+1, n, 1):
if fSt[j] == fSt[i]:
sP = j
break
if sP == -1:
flag = False
break
res.append((sP+1, i+1))
fSt[sP], sSt[i] = sSt[i], fSt[sP]
else:
if fP == -1:fP = i+1
fSt[fP], sSt[sP] = sSt[sP], fSt[fP]
res.append((fP+1, sP+1))
fSt[fP], sSt[i] = sSt[i], fSt[fP]
res.append((fP+1, i+1))
if flag == False:print("No")
else:
print("Yes")
print(len(res))
for j in range(len(res)):
print(res[j][0], res[j][1])
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int path[N], region[N];
bool mark[N];
int findUnion(int x) {
if (path[x] == x) return x;
return path[x] = findUnion(path[x]);
}
void mergeUnion(int x, int y) {
int u = findUnion(x), v = findUnion(y);
if (region[u] > region[v]) swap(u, v);
path[u] = v;
region[v] += region[u];
}
void solve() {
int n;
cin >> n;
vector<pair<int, int> > v(n + 1);
for (int i = 1; i <= n; i++) {
cin >> v[i].first;
v[i].second = i;
}
iota(path, path + n + 2, 0);
fill(region + 1, region + n + 2, 1);
sort(v.rbegin(), v.rend());
int idx = 0;
for (int i = 0; i < n; i++) {
int val = v[i].first, pos = v[i].second;
mark[pos] = true;
if (mark[pos - 1]) mergeUnion(pos, pos - 1);
if (mark[pos + 1]) mergeUnion(pos, pos + 1);
int mx = region[findUnion(pos)];
while (idx < mx) {
cout << val << " ";
++idx;
}
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int tc = 1;
while (tc--) {
solve();
}
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x[6];
for (int i = 0; i < 6; ++i) {
cin >> x[i];
}
sort(x, x + 6);
if (x[0] == x[3]) {
if (x[4] == x[5]) {
cout << "Elephant";
} else {
cout << "Bear";
}
} else if (x[2] == x[5]) {
if (x[0] == x[1]) {
cout << "Elephant";
} else {
cout << "Bear";
}
} else if (x[1] == x[4]) {
cout << (x[0] == x[5] ? "Elephant" : "Bear");
} else {
cout << "Alien";
}
return 0;
}
| 1,100 | CPP |
import math
r, h = [int(r) for r in input().split(' ')]
print(math.floor((h / r * 2 + 1) + math.floor((h % r) / r + 0.15)))
# print((h % r) / r)
| 1,900 | PYTHON3 |
t=int(input())
for i in range(t):
n=int(input())
a=[int(x) for x in input().split()]
c=sorted(a)
v=0
for i in range(n):
if a[i]%c[0]!=0 and a[i]!=c[i]:
v=1
if v==1:
print("NO")
else:
print("YES") | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-4;
const int maxn = 61;
int n, m;
int k;
char tnam[25];
int t, p;
struct skill {
char name[25];
int exp;
} ans[maxn];
int cmp(const void *a, const void *b) {
return strcmp(((skill *)a)->name, ((skill *)b)->name);
}
int search(char *sr) {
for (int i = 0; i < p; i++) {
if (strcmp(sr, ans[i].name) == 0) return i;
}
return -1;
}
void read() {
char c;
int ps = 0;
while (true) {
c = getchar();
if ((('0') <= (c) && (c) <= ('9'))) break;
if (c == '\n') {
while (tnam[ps - 1] == ' ') ps--;
tnam[ps] = '\0';
return;
}
tnam[ps++] = c;
}
while (tnam[ps - 1] == ' ') ps--;
tnam[ps] = '\0';
t = c - '0';
while (true) {
c = getchar();
if (c == '\n') return;
t = 10 * t + c - '0';
}
}
int main(void) {
p = 0;
scanf("%d %d 0.%d%*c", &n, &m, &k);
for (int i = 0; i < n; i++) {
read();
if (k * t >= 10000) {
strcpy(ans[p++].name, tnam);
ans[p - 1].exp = k * t / 100;
}
}
for (int i = 0; i < m; i++) {
read();
int cur = search(tnam);
if (cur == -1) {
strcpy(ans[p++].name, tnam);
ans[p - 1].exp = 0;
}
}
printf("%d\n", p);
qsort(ans, p, sizeof(skill), cmp);
for (int i = 0; i < p; i++) {
printf("%s %d\n", ans[i].name, ans[i].exp);
}
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[200005], gSign[200005], gBracket[200005], gBracketSign[200005];
vector<int> edgeInBracket[200005], edgeInVar[200005];
vector<int> varToBracket[200005], varSign[200005];
int cntVar[200005], sumVar[200005];
bool trueBracket[200005];
bool usedVar[200005];
int n, m;
vector<int> varMatchInd;
int bracketIndToMatchInd[200005];
int bracketsMatch, varMatch;
bool fVar[200005], fBracket[200005];
vector<int> q;
int ans[200005];
void NO() {
printf("NO\n");
exit(0);
}
void YES() {
printf("YES\n");
for (int i = 1; i <= m; i++)
if (ans[i] == -1) ans[i] = 0;
for (int i = 1; i <= m; i++) printf("%d", ans[i]);
printf("\n");
exit(0);
}
int sgn(int a) {
if (a > 0) return 1;
if (a < 0) return -1;
return 0;
}
void deleteVar(int var) {
while (g[var].size() != 0) {
int curBracket = g[var].back();
int bracketEdgeInd = edgeInBracket[var].back();
if (bracketEdgeInd == gBracket[curBracket].size()) {
gBracket[curBracket].pop_back();
gBracketSign[curBracket].pop_back();
edgeInVar[curBracket].pop_back();
} else {
int varTemp = gBracket[curBracket].back();
int varEdgeTemp = edgeInVar[curBracket].back();
edgeInBracket[varTemp][varEdgeTemp] = bracketEdgeInd;
gBracket[curBracket][bracketEdgeInd] = gBracket[curBracket].back();
gBracketSign[curBracket][bracketEdgeInd] =
gBracketSign[curBracket].back();
edgeInVar[curBracket][bracketEdgeInd] = edgeInVar[curBracket].back();
gBracket[curBracket].pop_back();
gBracketSign[curBracket].pop_back();
edgeInVar[curBracket].pop_back();
}
if (!fBracket[curBracket] && gBracket[curBracket].size() == 1) {
q.push_back(curBracket);
}
g[var].pop_back();
gSign[var].pop_back();
edgeInBracket[var].pop_back();
}
}
void workBracket(int bracket) {
if (fBracket[bracket]) return;
if (gBracket[bracket].size() == 0) NO();
int var = gBracket[bracket].front();
int sign = gBracketSign[bracket].front();
ans[varMatchInd[var]] = sign;
fVar[var] = true;
fBracket[bracket] = true;
deleteVar(var);
}
void walkComponent(int startBracket) {
int bracket = startBracket;
while (bracket != -1) {
int chosenVar = -1;
for (int i = 0; i < (int)gBracket[bracket].size(); i++) {
int var = gBracket[bracket][i];
if (fVar[var]) continue;
chosenVar = var;
int varEdge = edgeInVar[bracket][i];
ans[varMatchInd[chosenVar]] = gSign[chosenVar][varEdge];
fVar[var] = true;
fBracket[bracket] = true;
break;
}
if (chosenVar == -1) NO();
bracket = -1;
for (int i = 0; i < (int)g[chosenVar].size(); i++) {
if (!fBracket[g[chosenVar][i]]) {
bracket = g[chosenVar][i];
break;
}
}
deleteVar(chosenVar);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
int size;
scanf("%d", &size);
for (int j = 0; j < size; j++) {
int x;
scanf("%d", &x);
int xAbs = abs(x);
cntVar[xAbs]++;
sumVar[xAbs] += x;
varToBracket[xAbs].push_back(i);
varSign[xAbs].push_back(sgn(x));
}
}
for (int i = 1; i <= m; i++) {
if (cntVar[i] == 0 || (cntVar[i] > 0 && sumVar[i] != 0) ||
(cntVar[i] == 2 && sumVar[i] == 0 &&
varToBracket[i][0] == varToBracket[i][1])) {
usedVar[i] = true;
if (cntVar[i] == 0 || varSign[i][0] == 1)
ans[i] = 1;
else
ans[i] = -1;
for (int j = 0; j < (int)varToBracket[i].size(); j++) {
int cur = varToBracket[i][j];
trueBracket[cur] = true;
}
}
}
bracketsMatch = 0;
for (int i = 0; i < n; i++) {
if (!trueBracket[i]) {
bracketIndToMatchInd[i] = bracketsMatch;
bracketsMatch++;
}
}
for (int i = 1; i <= m; i++) {
if (!usedVar[i]) {
int varInd = (int)varMatchInd.size();
varMatchInd.push_back(i);
for (int j = 0; j < (int)varToBracket[i].size(); j++) {
if (trueBracket[varToBracket[i][j]]) continue;
int bracketInd = bracketIndToMatchInd[varToBracket[i][j]];
int curSign = varSign[i][j];
g[varInd].push_back(bracketInd);
gSign[varInd].push_back(curSign);
gBracket[bracketInd].push_back(varInd);
gBracketSign[bracketInd].push_back(curSign);
edgeInBracket[varInd].push_back((int)gBracket[bracketInd].size() - 1);
edgeInVar[bracketInd].push_back((int)g[varInd].size() - 1);
}
}
}
varMatch = (int)varMatchInd.size();
for (int i = 0; i < varMatch; i++) fVar[i] = false;
for (int i = 0; i < bracketsMatch; i++) fBracket[i] = false;
for (int i = 0; i < bracketsMatch; i++)
if (gBracket[i].size() == 1) q.push_back(i);
for (int i = 0; i < bracketsMatch;) {
if (q.size() != 0) {
int curBracket = q.back();
q.pop_back();
workBracket(curBracket);
} else {
if (!fBracket[i]) {
if (gBracket[i].size() == 0) NO();
walkComponent(i);
}
i++;
}
}
YES();
return 0;
}
| 2,500 | CPP |
n,l,a= list(map(int, input().split(" ")))
count,j=0,0
for i in range(n):
x = list(map(int, input().split(" ")))
count+=(x[0]-j)//a
j=x[1]+x[0]
print(count+(l-j)//a)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)6e5 + 50;
const long long INF = (long long)1e18;
struct Seg {
int l, r;
};
int n, m;
int a[N];
vector<Seg> segs[N];
long long dp[N][2];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
cin >> n >> m;
a[n + 1] = (int)(1e9 + 5);
for (int i = 1; i < (n + 1); ++i) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 0; i < (n + 1); ++i) segs[i].clear();
for (int i = 1; i < (m + 1); ++i) {
int l, r;
cin >> l >> r;
int li = lower_bound(a + 1, a + n + 2, l) - a;
int ri = lower_bound(a + 1, a + n + 2, r) - a;
if (a[li] == l || a[ri] == r || li != ri) continue;
segs[li - 1].push_back({l, r});
}
long long mx = a[n];
for (auto p : segs[n]) mx = max(mx, (long long)p.l);
dp[n][0] = (mx - a[n]), dp[n][1] = (mx - a[n]) * 2LL;
for (int i = n - 1; i >= 1; i--) {
multiset<int> S;
sort(begin(segs[i]), end(segs[i]),
[](const Seg &s1, const Seg &s2) { return s1.l < s2.l; });
for (auto &p : segs[i]) S.insert(p.r);
dp[i][0] = dp[i][1] = INF;
long long curmx = a[i];
for (int j = -1; j < (int)(segs[i]).size(); j++) {
if (j >= 0) {
auto &p = segs[i][j];
curmx = max(curmx, (long long)p.l);
S.erase(S.find(p.r));
}
long long mn = S.empty() ? a[i + 1] : *S.begin();
dp[i][0] = min({
dp[i][0],
(a[i + 1] - mn) * 2LL + dp[i + 1][0] + (curmx - a[i]),
(a[i + 1] - mn) + dp[i + 1][1] + (curmx - a[i]),
});
dp[i][1] = min({
dp[i][1],
(a[i + 1] - mn) * 2LL + dp[i + 1][0] + (curmx - a[i]) * 2LL,
(a[i + 1] - mn) + dp[i + 1][1] + (curmx - a[i]) * 2LL,
});
}
}
long long res = INF;
long long mn = a[1];
for (auto p : segs[0]) mn = min(mn, (long long)p.r);
res = min(dp[1][0] + 2LL * (a[1] - mn), dp[1][1] + (a[1] - mn));
cout << res << '\n';
}
}
| 2,600 | CPP |
import sys
if not 'DEBUG' in globals(): readline = sys.stdin.readline
def readint(): return int(readline())
def readints(): return list(map(int, readline().rstrip().split()))
def readnints(n): return [readint() for _ in range(n)]
def readmat(n): return [readints() for _ in range(n)]
# Logic HERE
w = readint()
if w == 2:
print('NO')
else:
print('YES' if w % 2 == 0 else 'NO') | 800 | PYTHON3 |
from sys import stdin, stdout
import sys
import math
def get_int(): return int(stdin.readline().strip())
def get_ints(): return map(int,stdin.readline().strip().split())
def get_array(): return list(map(int,stdin.readline().strip().split()))
def get_string(): return stdin.readline().strip()
def op(c): return stdout.write(c)
#from collections import defaultdict
#for _ in range(int(stdin.readline())):
n=get_int()
p=get_array()
q=get_array()
a=[0]*(n+1)
for i in range(1,len(p)):
a[p[i]]+=1
for i in range(1,len(q)):
a[q[i]]+=1
for i in range(1,n+1):
if a[i]==0:
print("Oh, my keyboard!")
break
else:
print("I become the guy.") | 800 | PYTHON3 |
guest=input()
host=input()
initialname=guest+host
pile=input()
error=0
if len(pile)!=len(initialname):
print("NO")
else:
s=set(initialname)
for x in s:
if initialname.count(x)!=pile.count(x):
print("NO")
break
else:
print('YES') | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int x = 0, sgn = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sgn = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return sgn * x;
}
const int maxn = 50000 + 5;
int T, n, r[maxn][5];
bool cmp(int i, int j) {
int cnt = 0;
for (int k = 0; k < (5); ++k)
if (r[i][k] < r[j][k] && ++cnt == 3) break;
return cnt == 3;
}
int main() {
T = read();
while (T--) {
n = read();
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (5); ++j) {
r[i][j] = read();
}
int winner = 0;
for (int i = 0; i < (n); ++i)
if (winner != i && !cmp(winner, i)) winner = i;
bool ok = true;
for (int i = 0; i < (n); ++i)
if (winner != i && !cmp(winner, i)) {
ok = false;
break;
}
if (ok)
cout << winner + 1 << endl;
else
cout << -1 << endl;
}
return 0;
}
| 1,500 | CPP |
"""
This template is made by Satwik_Tiwari.
python programmers can use this template :)) .
"""
#===============================================================================================
#importing some useful libraries.
import sys
import bisect
import heapq
from math import *
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl #
from bisect import bisect_right as br
from bisect import bisect
#===============================================================================================
#some shortcuts
mod = pow(10, 9) + 7
def inp(): return sys.stdin.readline().strip() #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def lcm(a,b): return (a*b)//gcd(a,b)
#===============================================================================================
# code here ;))
def solve():
n = int(inp())
a = lis()
for i in range(0,n):
if(a[i]*2 in a or (a[i]%3==0 and a[i]//3 in a)):
continue
else:
start = a[i]
break
new = [start]
# print(start)
f = 0
while(f == 0):
# print('hehe')
if( start%2==0 and (start//2 in a)):
new.append(start//2)
start = start//2
elif(start*3 in a):
new.append(start*3)
start = start*3
else:
f = 1
print(*new[::-1])
testcase(1)
| 1,400 | PYTHON3 |
def main():
n, m = map(int, input().split())
lst_vert = [0 for _ in range(n)]
lst_hor = [0 for _ in range(m)]
for i in range(n):
line = list(map(int, input().split()))
if 1 in line:
lst_vert[i] = 1
for i in range(m):
if line[i] == 1:
lst_hor[i] = 1
vert = n
hor = m
for i in lst_hor:
if i == 1:
hor -= 1
for i in lst_vert:
if i == 1:
vert -= 1
if min(hor, vert) % 2 == 0:
print('Vivek')
else:
print('Ashish')
if __name__ == '__main__':
t = int(input())
for i in range(t):
main()
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
class Solution {
string s;
int n;
vector<int> digit;
vector<int> statistic;
set<int> deletelist(int num, int dig) {
set<int> res;
if (statistic[dig] < num) return res;
int c = 0;
for (int i = n - 1; i >= 0; i--) {
if (digit[i] % 3 == dig) {
c++;
res.insert(i);
if (c == num) {
if (i > 0) return res;
for (int j = 1; j < n - 1; j++) {
if (res.find(j) == res.end() && digit[j] != 0) return res;
if (digit[j] == 0) res.insert(j);
}
if (res.size() == n && res.size() > num) res.erase(next(res.begin()));
return res;
}
}
}
cout << "should never get here!";
}
void del(set<int> dlist) {
if (dlist.size() == n) {
cout << -1 << endl;
return;
}
for (int i = 0; i < n; i++) {
if (dlist.find(i) == dlist.end()) {
cout << s[i];
}
}
return;
}
public:
void sol() {
cin >> s;
n = s.size();
digit = vector<int>(n);
statistic = vector<int>(3, 0);
for (int i = 0; i < n; i++) {
digit[i] = s[i] - '0';
statistic[digit[i] % 3] += 1;
}
int total = statistic[1] + 2 * statistic[2];
total = total % 3;
if (total == 0) {
cout << s << '\n';
return;
}
if (total == 1) {
if (statistic[1] < 1 && statistic[2] < 2) {
cout << -1 << endl;
return;
}
set<int> l1 = deletelist(1, 1);
set<int> l2 = deletelist(2, 2);
if (!l2.empty() && (l1.size() > l2.size() || l1.empty()))
del(l2);
else
del(l1);
} else {
if (statistic[1] < 2 && statistic[2] < 1) {
cout << -1 << endl;
return;
}
set<int> l1 = deletelist(1, 2);
set<int> l2 = deletelist(2, 1);
if (!l2.empty() && (l1.size() > l2.size() || l1.empty()))
del(l2);
else
del(l1);
}
}
};
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
Solution s;
s.sol();
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
long long tt;
for (cin >> tt; tt; --tt) {
long long n;
cin >> n;
long long cnt = 0;
bool arr[n];
for (long long i = 0; i < n; i++) {
cin >> arr[i];
}
long long i = 0, j = n - 1;
while (i < n and !arr[i]) {
i++;
}
while (j >= 0 and !arr[j]) {
j--;
}
for (long long it = i; it <= j; it++) cnt += (!arr[it]);
cout << cnt << endl;
}
}
| 800 | CPP |
#include <bits/stdc++.h>
constexpr int P = 1000000007;
using i64 = long long;
int norm(int x) {
if (x < 0) {
x += P;
}
if (x >= P) {
x -= P;
}
return x;
}
template <class T>
T power(T a, int b) {
T res = 1;
for (; b; b /= 2, a *= a) {
if (b % 2) {
res *= a;
}
}
return res;
}
struct Z {
int x;
Z(int x = 0) : x(norm(x)) {}
int val() const { return x; }
Z operator-() const { return Z(norm(P - x)); }
Z inv() const {
assert(x != 0);
return power(*this, P - 2);
}
Z &operator*=(const Z &rhs) {
x = i64(x) * rhs.x % P;
return *this;
}
Z &operator+=(const Z &rhs) {
x = norm(x + rhs.x);
return *this;
}
Z &operator-=(const Z &rhs) {
x = norm(x - rhs.x);
return *this;
}
Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
friend Z operator*(const Z &lhs, const Z &rhs) {
Z res = lhs;
res *= rhs;
return res;
}
friend Z operator+(const Z &lhs, const Z &rhs) {
Z res = lhs;
res += rhs;
return res;
}
friend Z operator-(const Z &lhs, const Z &rhs) {
Z res = lhs;
res -= rhs;
return res;
}
friend Z operator/(const Z &lhs, const Z &rhs) {
Z res = lhs;
res /= rhs;
return res;
}
};
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int n;
std::cin >> n;
std::vector<int> deg(n);
for (int i = 0; i < n - 1; i++) {
int u, v;
std::cin >> u >> v;
u--;
v--;
deg[u]++;
deg[v]++;
}
int leaves = 0;
for (int i = 0; i < n; i++) {
leaves += deg[i] == 1;
}
Z ans = 0;
for (int i = 0; i < n; i++) {
ans += power(Z(2), n - (leaves - (deg[i] == 1)));
}
std::cout << ans.val() << "\n";
return 0;
}
| 2,100 | CPP |
s = input()
s = s.lower()
q = ''
for i in s:
if i not in ('a','e','i','o','u','y'):
q+=('.%s'%i)
print(q)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inv = numeric_limits<int>::max();
const int minv = numeric_limits<int>::min();
const int max_n = 500010;
int n;
int a[max_n];
int b[max_n] = {0};
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
int c = 0;
for (int i = n - 2; i >= 0; --i) {
if (i > 0 and a[i - 1] != a[i] and a[i] != a[i + 1])
++c;
else {
b[i + 1] = c;
c = 0;
}
}
int res = 0;
for (int i = 1; i <= n - 2; ++i)
if (b[i] > 0) {
res = max(res, (b[i] + 1) / 2);
if (b[i] & 1)
for (int j = i; j < i + b[i]; ++j) a[j] = a[i - 1];
else {
for (int j = i; j < i + b[i] / 2; ++j) a[j] = a[i - 1];
for (int j = i + b[i] / 2; j < i + b[i]; ++j) a[j] = a[i + b[i]];
}
}
printf("%d\n", res);
for (int i = 0; i < n; ++i) printf("%d ", a[i]);
printf("\n");
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) cout << "(";
for (int j = 1; j <= n - i; j++) cout << "()";
for (int j = 0; j < i; j++) cout << ")";
cout << endl;
}
}
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a[1000000], n, sum = 0;
long long pre[1000000], two[1000000];
void _pre() {
for (long long i = 0; i < n; i++) {
if (i == 0)
pre[i] = a[i];
else
pre[i] = a[i] + pre[i - 1];
}
for (long long i = n - 2; i >= 0; i--) {
if (pre[i] == 2 * sum)
two[i] = two[i + 1] + 1;
else
two[i] = two[i + 1];
}
}
int main() {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
if (sum % 3 != 0 or n < 3) {
cout << 0;
return 0;
}
sum /= 3;
_pre();
long long ans = 0;
for (long long i = 0; i < n - 2; i++) {
if (pre[i] == sum) ans += two[i + 1];
}
cout << ans;
return 0;
}
| 1,700 | CPP |
def fun():
N=int(input())
arr=list(map(int,input().split()))
new_arr=[0]
for i in arr:
new_arr.append(i)
new_arr.append(1001)
ans=0
count=0
for i in range(1,N+2):
#print(new_arr[i],new_arr[i-1])
if(new_arr[i]==1 +new_arr[i-1]):
count+=1
else:
ans= max(ans,count)
count=0
ans=max(ans,count)
print(max(0,ans-1))
fun() | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T, t;
cin >> T;
for (t = 0; t < T; ++t) {
int n;
cin >> n;
if (n == 1) {
cout << "-1" << endl;
continue;
}
string ans = "2";
for (int i = 0; i < n - 1; ++i) ans += "3";
cout << ans << endl;
}
return 0;
}
| 1,000 | CPP |
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 29 14:19:43 2020
@author: 86133
"""
n = int(input())
i = 0
while i<n:
s = input()
if len(s) <= 10 :
print(s)
else:
print(s[0], len(s)-2, s[len(s)-1], sep='')
i += 1
| 800 | PYTHON3 |
#include <bits/stdc++.h>
const double eps = 1e-10;
const int INF = 0x3f3f3f3f;
const long long inf = 0x3f3f3f3f3f3f3f3f;
using namespace std;
const int N = 1e5 + 7;
int t, n, m, ans = 0, fl = 0;
vector<int> v[100005], one;
int qi = 0;
void dfs(int x, int y, int z) {
int aa = 0;
if (ans) return;
if (y != -1 && v[x].size() == 1) {
if (z % 2) ans = 1;
return;
}
for (long long i = 0; i <= v[x].size() - 1; i++) {
if (v[x][i] == y) continue;
dfs(v[x][i], x, z + 1);
}
return;
}
int main() {
scanf("%d", &n);
int minn = 0, maxn = n - 1;
for (long long i = 1; i <= n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
for (long long i = 1; i <= n; i++) {
if (v[i].size() == 1 && qi == 0) {
qi = i;
}
int cnt = 0;
for (long long j = 0; j <= v[i].size() - 1; j++) {
if (v[v[i][j]].size() == 1) cnt++;
}
if (cnt >= 2) fl += cnt - 1;
}
dfs(qi, -1, 0);
if (ans == 0)
minn = 1;
else
minn = 3;
maxn -= fl;
printf("%d %d\n", minn, maxn);
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, ar[100005], a[100005], h[100005], q, sum1, sum2, sum3;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &ar[i]), sum1 += ar[i];
for (int i = 1; i < n; i++) scanf("%d", &ar[i]), sum2 += ar[i];
for (int i = 1; i < n - 1; i++) scanf("%d", &ar[i]), sum3 += ar[i];
printf("%d\n%d", sum1 - sum2, sum2 - sum3);
}
| 1,100 | CPP |
n=int(input())
import math
a=list(map(int,input().split()))
dic={}
x=max(a)
maxp=math.ceil(math.log2(x))
ans=0
for i in a:
try:
dic[i]+=1
except:
dic[i]=1
for j in range(1,maxp+2):
y=(2**j)-i
# print(j,i,y)
if(y<0):
continue
else:
if(y==i):
if(y in dic and dic[y]>1):
ans+=dic[y]
ans-=1
else:
if(y in dic):
ans+=dic[y]
# print("ans",ans)
print(ans)
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int x) {
if (x == 2) return true;
if (x % 2 == 0 || x < 2) return false;
for (int i = 3; i * i <= x; i += 2)
if (x % i == 0) return false;
return true;
}
long long GCD(long long x, long long y) { return y ? GCD(y, x % y) : x; }
long long LCM(long long x, long long y) { return x * (y / GCD(x, y)); }
struct Fraction {
long long nom, denom;
Fraction(long long nom = 0, long long denom = 1) {
this->nom = nom;
this->denom = denom;
this->Simplify();
}
void Simplify() {
long long G = GCD(nom, denom);
nom /= G;
denom /= G;
}
Fraction operator+(const Fraction& f) {
Fraction A = *this, B = f;
A.Simplify();
B.Simplify();
long long L = LCM(A.denom, B.denom);
long long x1 = L / A.denom;
long long x2 = L / B.denom;
Fraction Res = Fraction(x1 * A.nom + x2 * B.nom, L);
Res.Simplify();
return Res;
}
Fraction operator-(const Fraction& f) {
Fraction Res = *this + Fraction(-f.nom, f.denom);
Res.Simplify();
return Res;
}
Fraction operator*(const Fraction& f) {
Fraction A = *this, B = f;
A.Simplify();
B.Simplify();
swap(A.nom, B.nom);
A.Simplify();
B.Simplify();
Fraction Res = Fraction(A.nom * B.nom, A.denom * B.denom);
Res.Simplify();
return Res;
}
Fraction operator/(const Fraction& f) {
Fraction A = *this, B = f;
swap(A.nom, B.denom);
Fraction Res = A * B;
Res.Simplify();
return Res;
}
Fraction operator+=(const Fraction& f) { return (*this) = (*this) + f; }
Fraction operator-=(const Fraction& f) { return (*this) = (*this) - f; }
Fraction operator*=(const Fraction& f) { return (*this) = (*this) * f; }
Fraction operator/=(const Fraction& f) { return (*this) = (*this) / f; }
void Print() { printf("%I64d/%I64d\n", nom, denom); }
};
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
long long Nxt;
for (int i = n + 1;; i++)
if (isPrime(i)) {
Nxt = i;
break;
}
long long Pre;
for (int i = n;; i--)
if (isPrime(i)) {
Pre = i;
break;
}
long long Counter = n - Pre + 1;
Fraction Ans;
Ans += Fraction(1, 2);
Ans += Fraction(-1, Pre);
Ans += Fraction(Counter, Nxt * Pre);
Ans.Print();
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<string> ss;
char s[100];
string tmp;
scanf("%s", s);
tmp = s;
ss.insert(tmp);
int n = tmp.size();
for (int i = 0; i < n; i++) {
tmp = tmp.substr(1) + tmp[0];
ss.insert(tmp);
}
printf("%d\n", (int)ss.size());
}
| 900 | CPP |
def main():
testCases = int(input())
for t in range(testCases):
x = int(input())
print(1, x-1)
main()
| 800 | PYTHON3 |
l=input()
l=l.lower()
s=["a","e","i","o","u","y"]
p=[]
for i in l:
if i not in s:
p.append(".")
p.append(i)
print("".join(p)) | 1,000 | PYTHON3 |
t=int(input())
while t:
t-=1
n=int(input())
x=list(map(int,input().split()))
x.sort()
for i in range(n-1):
if x[i+1]-x[i]>1:
print("NO")
break
else:
print("YES") | 800 | PYTHON3 |
n=input()[::-1]
for x in n:
if int(x)<5:
print("O-|","O"*int(x),"-","O"*(4-int(x)),sep="")
elif int(x)>=5:
print("-O|","O"*(int(x)-5),"-","O"*(4-(int(x)-5)),sep="")
| 800 | PYTHON3 |
for i in range(int(input())):
n,m = map(int, input().split())
arr = list(map(int, input().split()))
count = sum(arr)
if int(count)==m:
print("YES")
else:
print("NO") | 800 | PYTHON3 |
# cook your dish here
n=int(input())
a=list(map(int,input().split()))
a.sort()
max1=0
for i in range(n-2):
if(a[i]+a[i+1]>max1):
max1=a[i]+a[i+1]
if(a[n-1]<max1):
print("YES")
for i in range(n-2):
print(a[i],end=" ")
print(a[n-1],end=" ")
print(a[n-2])
else:
print("NO") | 1,100 | PYTHON3 |
n = int(input())
vit = {}
for i in range(n):
li = input().strip().split(" ")
c, v = int(li[0]), "".join(sorted(li[1]))
if v in vit:
vit[v] = min(c, vit[v])
else:
vit[v] = c
if 'ABC' in vit:
mcost = vit['ABC']
vit.pop('ABC', None)
else:
mcost = -1
vitl = list(k for k in vit.keys())
vitc = list(vit[k] for k in vit.keys())
for i in range(len(vitl)):
for j in range(i, len(vitl)):
key1 = vitl[i]+vitl[j]
if 'A' in key1 and 'B' in key1 and 'C' in key1:
ssum = vitc[i]+vitc[j]
if ssum<mcost or mcost==-1:
mcost = ssum
if 'A' in vitl and 'B' in vitl and 'C' in vitl:
ssum = vit['A'] + vit['B'] + vit['C']
if ssum<mcost or mcost==-1:
mcost = ssum
if 'A' in vitl and 'BC' in vitl:
ssum = vit['A'] + vit['BC']
if ssum<mcost or mcost==-1:
mcost = ssum
if 'B' in vitl and 'AC' in vitl:
ssum = vit['B'] + vit['AC']
if ssum<mcost or mcost==-1:
mcost = ssum
if 'C' in vitl and 'AB' in vitl:
ssum = vit['C'] + vit['AB']
if ssum<mcost or mcost==-1:
mcost = ssum
print(mcost)
| 1,200 | PYTHON3 |
val = [int(x) for x in input().split()]
val.sort(reverse = True)
tot = val[0]
print(tot - val[1], tot - val[2], tot - val[3]) | 800 | PYTHON3 |
#include <bits/stdc++.h>
const long long T00B1G = 9223372036854775807LL;
const int maskl = 5;
bool mask[64][5];
template <class TEl>
using TTable = std::vector<std::vector<TEl>>;
template <class TEl>
void spacecreator(long long first, long long second, TTable<TEl>& vec) {
vec.resize(first);
for (auto& sub : vec) {
sub.resize(second);
}
}
template <class T>
void makemask(long long nn, T& mask) {
long long ulim = 1 << nn;
for (long long st = 0; st < ulim; st++) {
for (auto pos = 0; pos < nn; pos++) {
mask[st][pos] = (st >> pos) & 1;
}
}
}
int main() {
long long nn, mm;
TTable<long long> dp;
TTable<long long> left, down;
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cin >> nn >> mm;
spacecreator(mm + 5, 64, dp);
spacecreator(maskl, mm + 5, left);
spacecreator(maskl, mm + 5, down);
for (auto col = 1; col < mm; col++) {
for (auto row = 0; row < nn; row++) {
std::cin >> left[row][col];
}
}
for (auto col = 0; col < mm; col++) {
for (auto row = 0; row < nn; row++) {
std::cin >> down[row][col];
}
}
makemask(nn, mask);
long long ulim = 1 << nn, fix, t1;
for (auto col = 1; col < mm; col++) {
for (long long st = 0; st < ulim; st++) {
fix = 0;
dp[col][st] = T00B1G;
for (auto row = 0; row < nn; row++) {
auto next = row + 1;
if (next >= nn) {
next = 0;
}
if (mask[st][row] ^ mask[st][next]) {
fix += down[row][col];
}
}
for (long long prev = 0; prev < ulim; prev++) {
if (col == 1 && prev != 0) {
break;
}
t1 = 0;
for (auto row = 0; row < nn; row++) {
if ((mask[st][row] ^ mask[prev][row]) == 1) {
t1 += left[row][col];
}
}
dp[col][st] = std::min(dp[col][st], dp[col - 1][prev] + t1 + fix);
}
}
}
std::cout << dp[mm - 1][ulim - 1];
return 0;
}
| 2,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, t[200005], sl, a[200005], ds;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
int dem = 0;
for (int i = 1; i <= n; ++i) {
cin >> t[i];
if (t[i] < 0) --k;
if (t[i] >= 0 && t[i - 1] < 0) {
dem = 1;
++ds;
} else if (t[i] >= 0) {
if (dem) ++dem;
} else if (t[i - 1] >= 0) {
if (dem) a[++sl] = dem;
++ds;
}
}
sort(a + 1, a + sl + 1);
if (k < 0)
cout << -1;
else {
int u = 1;
while (u <= sl && k - a[u] >= 0) {
k -= a[u];
++u;
ds -= 2;
}
if (dem)
if (k >= dem) ds -= 1;
cout << ds;
}
}
| 1,800 | CPP |
#include <bits/stdc++.h>
const int N = 1005;
int n, k, e[N][N], pw, mx;
int d[N][N];
int main() {
scanf("%d%d", &n, &k);
pw = 1;
while (pw < n) ++mx, pw = k * pw;
--mx;
for (int i = 0; i < n; ++i) {
int x = i, tp = 0;
while (x) d[i][tp++] = x % k, x /= k;
}
for (int i = 1; i < n; ++i) {
for (int j = 0; j < i; ++j) {
int t = 0;
while (d[i][t] <= d[j][t]) ++t;
e[j + 1][i + 1] = t + 1;
}
}
printf("%d\n", mx + 1);
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j) printf("%d ", e[i][j]);
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline void normal(long long int &a) { a = (a + 998244353) % 998244353; }
inline int modMul(long long int a, long long int b) {
a %= 998244353, b %= 998244353;
normal(a), normal(b);
return (a * b) % 998244353;
}
inline int modAdd(long long int a, long long int b) {
a %= 998244353, b %= 998244353;
normal(a), normal(b);
return (a + b) % 998244353;
}
inline int modSub(long long int a, long long int b) {
a %= 998244353, b %= 998244353;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline int modPow(long long int b, long long int p) {
int r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline int modInv(int a) { return modPow(a, 998244353 - 2); }
inline int modDiv(int a, int b) { return modMul(a, modInv(b)); }
inline int fact(int r) {
int ans = 1;
while (r) ans = modMul(ans, r), r--;
return ans;
}
inline int invfact(int r) {
int ans = 1;
while (r) ans = modMul(ans, modInv(r)), r--;
return ans;
}
inline double dgcd(double a, double b) {
if (a < b) return dgcd(b, a);
if (b < .0001) return a;
return dgcd(b, fmod(a, b));
}
const long long int N = 305;
const long long int INF = (long long int)1e12;
long long int power(long long int base, long long int exp) {
long long int res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base);
base = (base * base);
exp /= 2;
}
return res;
}
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
void Abesaale() {
long long int u, v;
cin >> u >> v;
if (u > v)
cout << -1;
else {
if ((v - u) % 2 != 0)
cout << -1;
else {
long long int k1 = (v - u) / 2;
if ((k1 + u) == (k1 ^ u)) {
if (k1 == 0 && u == 0) {
cout << 0 << endl;
return;
} else if (k1 == 0) {
cout << 1 << endl;
cout << v << endl;
return;
}
cout << 2 << endl;
cout << k1 + u << " " << k1;
} else {
cout << 3 << endl;
cout << k1 << " " << k1 << " " << u << endl;
}
}
}
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
clock_t start, end;
start = clock();
cout << fixed << setprecision(11);
while (t--) {
Abesaale();
}
end = clock();
double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)5e2 + 2;
const int mod = (int)1e9 + 7;
int n, m;
char a[maxn][maxn];
long long dp[2][maxn][maxn];
long long res;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
if (a[1][1] != a[n][m]) return cout << 0, 0;
dp[1][1][m] = 1;
for (int len = 2, f = 0; len <= (m + n) / 2; len++, f ^= 1) {
memset(dp[f], 0, sizeof dp[f]);
for (int c1 = 1; c1 <= min(len, m); c1++) {
for (int c2 = m; c2 >= max(1, m - len + 1); c2--) {
int r1 = len + 1 - c1;
int r2 = n - (len - (m - c2 + 1));
if (a[r1][c1] == a[r2][c2]) {
dp[f][c1][c2] += dp[f ^ 1][c1][c2];
dp[f][c1][c2] += dp[f ^ 1][c1 - 1][c2];
dp[f][c1][c2] += dp[f ^ 1][c1][c2 + 1];
dp[f][c1][c2] += dp[f ^ 1][c1 - 1][c2 + 1];
while (dp[f][c1][c2] >= mod) dp[f][c1][c2] -= mod;
}
if (r1 == r2 && abs(c1 - c2) <= 1) {
res += dp[f][c1][c2];
while (res >= mod) res -= mod;
} else if (c1 == c2 && abs(r1 - r2) <= 1) {
res += dp[f][c1][c2];
while (res >= mod) res -= mod;
}
}
}
}
cout << res;
}
| 2,300 | CPP |
for _ in range(int(input())):
n=int(input())
y=0
while n>0:
y+=1
n-=y
if n==-1:
y+=1
print(y) | 1,200 | PYTHON3 |
n=int(input())
string=input()
listkeys=[0]*26
count=0
q=2*n-2
#ans=ord(string[0])
#print(ans)
for i in range(0,q):
if(i%2==0):
#print(string[0])
k=ord(string[i])
#print(k)
k2=k-97
listkeys[k2]=listkeys[k2]+1
else :
k3=ord(string[i])
k4=k3+32
#print(k4-97)
if(listkeys[k4-97]>=1):
listkeys[k4-97]=listkeys[k4-97]-1
else :
count=count+1
print(count)
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T poww(T b, T p) {
long long a = 1;
while (p) {
if (p & 1) {
a = (a * b);
}
p >>= 1;
b = (b * b);
}
return a;
}
template <class T>
inline T gcd(T a, T b) {
if (b > a) return gcd(b, a);
return ((b == 0) ? a : gcd(b, a % b));
}
template <class T>
inline T modpoww(T b, T p, T modd) {
long long a = 1;
while (p) {
if (p & 1) {
a = (a * b) % modd;
}
p >>= 1;
b = (b * b) % modd;
}
return a % modd;
}
const int m = 998244353;
long long fact[5010];
long long ncr(int n, int r) {
long long temp = fact[n] * modpoww<long long>(fact[r], m - 2, m);
temp %= m;
temp = temp * modpoww<long long>(fact[n - r], m - 2, m);
return temp % m;
}
long long getcount(int a, int b) {
int k;
long long ct = 0, tmp;
for ((k) = 0; (k) < (min(a, b) + 1); (k)++) {
tmp = ncr(a, k) * ncr(b, k);
tmp %= m;
tmp = (tmp * fact[k]) % m;
ct = (ct + tmp) % m;
}
return ct;
}
int main() {
int a, b, c, i, j;
fact[0] = 1;
for ((i) = (1); (i) < (5010); (i) += 1) {
fact[i] = (fact[i - 1] * i) % m;
}
cin >> a >> b >> c;
long long ans = 0;
long long ab, bc, ac;
ab = bc = ac = 0;
ab = getcount(a, b);
bc = getcount(b, c);
ac = getcount(a, c);
cout << ((ab * bc) % m * ac) % m << "\n";
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
struct heap {
vector<pair<int, int> > v;
int loc[N];
heap() {
v.push_back(make_pair(-1, -1));
memset(loc, -1, sizeof loc);
}
void push(pair<int, int> p) {
int cur;
cur = v.size();
loc[p.second] = cur;
v.push_back(p);
while (v[cur] < v[cur >> 1]) {
swap(v[cur], v[cur >> 1]);
swap(loc[v[cur].second], loc[v[cur >> 1].second]);
cur >>= 1;
}
}
void pop() {
if (empty()) return;
swap(v[1], v.back());
loc[v[1].second] = 1;
loc[v.back().second] = -1;
v.pop_back();
int cur = 1;
while ((cur << 1) < v.size()) {
if ((cur << 1) + 1 == v.size()) {
if (v[cur] > v[cur << 1])
swap(v[cur], v[cur << 1]),
swap(loc[v[cur].second], loc[v[cur << 1].second]);
break;
}
if (v[cur] < min(v[cur << 1], v[(cur << 1) + 1])) break;
if (v[cur << 1] < v[(cur << 1) + 1]) {
swap(v[cur], v[cur << 1]);
swap(loc[v[cur].second], loc[v[cur << 1].second]);
cur <<= 1;
} else {
swap(v[cur], v[(cur << 1) + 1]);
swap(loc[v[cur].second], loc[v[(cur << 1) + 1].second]);
cur = (cur << 1) + 1;
}
}
}
pair<int, int> top() { return v[1]; }
bool empty() { return v.size() == 1; }
};
int n, m;
vector<int> bad[N];
vector<pair<int, int> > v[N];
int d[N];
heap pq;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
--a, --b;
v[a].push_back(make_pair(b, c));
v[b].push_back(make_pair(a, c));
}
for (int i = 0; i < n; i++) {
int num;
cin >> num;
while (num--) {
int a;
cin >> a;
bad[i].push_back(a);
}
}
for (int i = 0; i < n; i++) d[i] = 0x3f3f3f3f;
d[0] = 0;
pq.push(make_pair(0, 0));
while (!pq.empty()) {
pair<int, int> tp = pq.top();
pq.pop();
int t = tp.first;
int cur = tp.second;
if (t != d[cur]) continue;
int j = 0;
while (j < bad[cur].size() && bad[cur][j] < t) j++;
while (j < bad[cur].size() && bad[cur][j] == t) t++, j++;
for (int i = 0; i < v[cur].size(); i++) {
int to = v[cur][i].first, cost = v[cur][i].second;
if (t + cost < d[to]) {
d[to] = t + cost;
pq.push(make_pair(d[to], to));
}
}
}
if (d[n - 1] >= 0x3f3f3f3f)
puts("-1");
else
cout << d[n - 1] << endl;
return 0;
}
| 1,700 | CPP |
def denomination(n):
c = 0
i = 0
ls = [100, 20, 10, 5, 1]
while(n > 0):
if(n >= ls[i]):
c = c + int(n / ls[i])
n = n % ls[i]
else:
i = i + 1
return c
n = int(input())
print(denomination(n)) | 800 | PYTHON3 |
k,d=map(int, input().split())
if(d==0 and k>1):
print("No solution")
exit()
s=str(d)+"0"*(k-1)
print(s) | 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int EPS = 1e-6;
const long long INF = 1e15;
const long long mod = (int)(1e+9 + 7);
const int N = (int)(0);
int r3(int n) {
int i = 1;
for (; i * i * i <= n; i++)
;
return i - 1;
}
int main() {
int n;
cin >> n;
long long M = 0, m = INF;
int a[3];
for (a[0] = 1; (a[0]) * (a[0]) * (a[0]) <= n; a[0]++) {
if (n % a[0] != 0) continue;
for (a[1] = 1; (a[1]) * (a[1]) <= n / a[0]; a[1]++) {
if ((n / a[0]) % a[1] != 0) continue;
a[2] = (n / a[0]) / a[1];
for (int i = 0; i < 3; i++) {
M = max(M,
1LL * (a[i] + 1) * (a[(i + 1) % 3] + 2) * (a[(i + 2) % 3] + 2));
m = min(m,
1LL * (a[i] + 1) * (a[(i + 1) % 3] + 2) * (a[(i + 2) % 3] + 2));
}
}
}
cout << m - n << " " << M - n;
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, d;
cin >> n >> m >> d;
vector<int> nums(n * m);
int k = 0;
set<int> rem;
set<int> nums_set;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> nums[k];
rem.insert(abs(nums[k] % d));
nums_set.insert(nums[k]);
++k;
}
}
if (rem.size() != 1) {
cout << -1 << endl;
return 0;
}
if (nums_set.size() == 1) {
cout << 0 << endl;
return 0;
}
sort(nums.begin(), nums.end());
int ans = INT_MAX;
for (int i = 0; i < nums.size(); ++i) {
int cur = 0;
for (int j = 0; j < nums.size(); ++j) {
if (nums[i] == nums[j]) continue;
cur += abs(nums[j] - nums[i]) / d;
}
ans = min(ans, cur);
}
cout << ans << endl;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
#endif
int n; cin >> n;
vector<set<int>> G(n);
for (int i = 0, a, b; i < n - 1; i++) {
cin >> a >> b;
a--; b--;
G[a].insert(b);
G[b].insert(a);
}
unordered_map<int, int> par, sz;
vector<int> v;
function<bool(int, int)> check = [&](int i, int n) {
if (n == 1) return true;
int x = 1, y = 1;
while (x + y < n) {
int tmp = x;
x = y, y += tmp;
}
if (x + y != n) return false;
v.clear();
par[i] = -1;
function<void(int)> dfs = [&](int i) {
v.push_back(i);
sz[i] = 1;
for (int j: G[i]) {
if (j != par[i]) {
par[j] = i;
dfs(j);
sz[i] += sz[j];
}
}
};
dfs(i);
int p = -1, q = -1;
for (int i: v) if (sz[i] == x || sz[i] == y) p = i, q = par[i];
if (p == -1) return false;
G[p].erase(q);
G[q].erase(p);
if (sz[p] == y) swap(x, y);
return check(p, x) && check(q, y);
};
cout << (check(0, n) ? "YES" : "NO") << endl;
return 0;
} | 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, int> mapp;
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long x, y, l, r;
cin >> l >> r >> x >> y;
long long sq = sqrt(y);
for (long long i = 1; i <= sq; i++) {
if (y % i == 0) {
long long t = y / i;
long long w = i * x;
long long gcdd = gcd(t, w);
long long lcm = t / gcdd * w;
if (t >= l && t <= r && w >= l && w <= r && gcdd == x && lcm == y) {
mapp[make_pair(t, w)] = 1;
mapp[make_pair(w, t)] = 1;
}
t = y / (y / i);
w = (y / i) * x;
gcdd = gcd(t, w);
lcm = t / gcdd * w;
if (t >= l && t <= r && w >= l && w <= r && gcdd == x && lcm == y) {
mapp[make_pair(t, w)] = 1;
mapp[make_pair(w, t)] = 1;
}
}
}
cout << mapp.size() << endl;
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N = 1000000;
int Last[1000010];
vector<int> H;
int calc(int val) {
int sz = H.size();
int ret = 0;
for (int i = 0; i < (1 << sz); ++i) {
int sign = 0;
int prod = 1;
for (int j = 0; j < sz; ++j) {
if ((i >> j) & 1) prod = prod * H[j], ++sign;
}
sign = sign & 1;
sign = sign ^ 1;
sign = sign * 2 - 1;
ret = ret + sign * (val / prod);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T;
cin >> T;
for (int i = 2; i <= N; ++i) {
if (!Last[i])
for (int j = i; j <= N; j += i) Last[j] = i;
}
while (T--) {
int x, p, k;
cin >> x >> p >> k;
H.clear();
while (p != 1) {
int div = Last[p];
H.push_back(div);
while (p % div == 0) {
p = p / div;
}
}
int d = calc(x);
k = k + d;
int l = 1, r = 1e9;
while (l <= r) {
int mid = (l + r) / 2;
if (calc(mid) >= k)
r = mid - 1;
else
l = mid + 1;
}
cout << r + 1 << '\n';
}
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long inf;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T, class T2>
long long chkmin(T &a, T2 b) {
return a > b ? a = b, 1 : 0;
}
template <class T, class T2>
long long chkmax(T &a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T, class T2>
T mmin(T a, T2 b) {
return a < b ? a : b;
}
template <class T, class T2>
T mmax(T a, T2 b) {
return a > b ? a : b;
}
template <class T>
T aabs(T a) {
return a < 0 ? -a : a;
}
template <class T>
long long dcmp(T a, T b) {
return a > b;
}
template <long long *a>
long long cmp_a(long long first, long long second) {
return a[first] < a[second];
}
struct __INIT__ {
__INIT__() { memset(&inf, 0x3f, sizeof(inf)); }
} __INIT___;
namespace io {
const long long SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
long long f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char first) {
*oS++ = first;
if (oS == oT) flush();
}
template <typename A>
inline bool read(A &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(char &first) {
while ((first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == ' ' ||
first == '\n' || first == '\r')
;
return first != EOF;
}
inline bool read(char *first) {
while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*first == ' ' || *first == '\r')
;
if (*first == EOF) return 0;
while (!(*first == '\n' || *first == ' ' || *first == '\r' || *first == EOF))
*(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*first = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &first, B &...second) {
return read(first) && read(second...);
}
template <typename A>
inline bool write(A first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char first) {
putc(first);
return 0;
}
inline bool write(const char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
inline bool write(char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A first, B... second) {
return write(first) || write(second...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
long long a[200005], b[200005];
vector<long long> to[200005];
long long dp[200005][2];
long long xmp[200005], cur[200005];
long long ans;
void dfs(long long first, long long f) {
for (auto i : to[first])
if (i != f) dfs(i, first);
long long m = to[first].size();
long long s1 = 0, t = 0, c = 0;
for (long long i = 0; i <= m; ++i) xmp[i] = inf;
for (auto i : to[first])
if (i != f) {
if (b[first] == b[i]) {
s1 += dp[i][0];
cur[++t] = dp[i][1] - dp[i][0];
} else if (b[first] > b[i])
s1 += dp[i][0];
else if (b[first] < b[i]) {
s1 += dp[i][1];
++c;
}
}
xmp[c] = s1;
sort(cur + 1, cur + t + 1);
for (long long i = 1; i <= t; ++i) xmp[c + i] = xmp[c + i - 1] + cur[i];
if (first == 1) {
for (long long i = 0; i <= m; ++i)
chkmin(ans, xmp[i] + a[first] * mmax(m - i, i));
} else {
for (long long second = 0; second < 2; ++second) {
dp[first][second] = inf;
if (second && b[first] < b[f]) continue;
if (!second && b[first] > b[f]) continue;
for (long long j = 0; j < m; ++j)
chkmin(dp[first][second],
xmp[j] + a[first] * mmax(m - j - !second, j + !second));
}
}
}
signed main() {
long long n, u, v;
read(n);
for (long long i = 1; i <= n; ++i) read(a[i]);
for (long long i = 1; i <= n; ++i) read(b[i]);
for (long long i = 1; i < n; ++i) {
read(u, v);
to[u].emplace_back(v);
to[v].emplace_back(u);
}
ans = inf;
dfs(1, 0);
write(ans, '\n');
return 0;
}
| 2,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 2e4 + 5;
int main() {
int n, m, k, t;
cin >> n >> k >> m >> t;
int flag = k, nn = n;
for (int i = 0; i < t; i++) {
int a, b;
cin >> a >> b;
if (a == 0) {
if (b < flag) {
nn -= b;
flag -= b;
} else if (b >= flag) {
int ans = nn - b;
nn -= ans;
}
cout << nn << ' ' << flag << endl;
} else if (a == 1) {
if (b <= flag) {
nn++;
flag++;
} else {
nn++;
}
cout << nn << ' ' << flag << endl;
}
}
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
const double eps = 1e-8;
const long long mod = 1000000007;
const long long inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long dx[4] = {-1, 1, 0, 0};
const long long dy[4] = {0, 0, -1, 1};
long long qpow(long long a, long long b) {
long long s = 1;
while (b > 0) {
if (b % 2 == 1) {
s = s * a;
}
a = a * a;
b = b >> 1;
}
return s;
}
long long qpowmod(long long a, long long b, long long c) {
long long res, t;
res = 1;
t = a % c;
while (b) {
if (b & 1) {
res = res * t % c;
}
t = t * t % c;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long read() {
long long k = 0, f = 1;
char ch = getchar();
while (ch<'0' | ch> '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
k = k * 10 + ch - '0';
ch = getchar();
}
return k * f;
}
inline void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const long long maxn = 2e5 + 5;
long long t, n, k;
vector<long long> v1, v2;
void f1(long long x, long long now) {
if (now <= 1e12)
v1.push_back(now);
else
return;
if (now * 10 + x != 0) f1(x, now * 10 + x);
}
void f2(long long x, long long y, long long now) {
if (now <= 1e12)
v2.push_back(now);
else
return;
if (now * 10 + x != 0) f2(x, y, now * 10 + x);
if (now * 10 + y != 0) f2(x, y, now * 10 + y);
}
signed main() {
for (long long i = 0; i <= 9; i++) {
f1(i, 0);
}
v1.erase(unique(v1.begin(), v1.end()), v1.end());
sort(v1.begin(), v1.end());
for (long long i = 0; i <= 9; i++) {
for (long long j = i + 1; j <= 9; j++) {
f2(i, j, 0);
}
}
v2.erase(unique(v2.begin(), v2.end()), v2.end());
sort(v2.begin(), v2.end());
cin >> t;
while (t--) {
cin >> n >> k;
if (k == 1) {
long long pos = lower_bound(v1.begin(), v1.end(), n) - v1.begin();
cout << v1[pos] << "\n";
} else {
long long pos = lower_bound(v2.begin(), v2.end(), n) - v2.begin();
cout << v2[pos] << "\n";
}
}
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int arr[10] = {2, 7, 2, 3, 3, 4, 2, 5, 1, 2}, n;
cin >> n;
cout << arr[n / 10] * arr[n % 10] << endl;
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
int a[n];
for (int &i : a) cin >> i;
int b[m];
for (int &i : b) cin >> i;
int pos[n + 1];
for (int i = 0; i < n; i++) pos[a[i]] = i;
long long ans = 0;
for (int i = 0, dep = 0; i < m; i++) {
if (pos[b[i]] < dep) {
++ans;
} else {
ans += 2 * (pos[b[i]] - i) + 1;
dep = pos[b[i]];
}
}
cout << ans << "\n";
}
int main() {
int t;
cin >> t;
while (t--) solve();
}
| 1,400 | CPP |
n=int(input())
avt=[]
yes=False
for i in range(n):
s=input()
if s[0]=='O' and s[1]=='O' or s[3]=='O' and s[4]=='O':
if s[0]=='O' and s[1]=='O' and not yes:
s='++'+s[2:]
yes=True
if s[3]=='O' and s[4]=='O' and not yes:
s=s[:3]+'++'
yes=True
avt.append(s)
if not yes:
print("NO")
exit()
else:
print('YES')
for i in range(n):
print(avt[i])
| 800 | PYTHON3 |
def func():
n, k = map(int, input().strip().split())
l = 0
r = n
while l <= r:
mid = (l + r) // 2
if mid*(mid+1)/2 - (n-mid) < k:
l = mid + 1
elif mid*(mid+1)/2 - (n-mid) > k:
r = mid
else:
print(n - mid)
return mid
if __name__ == '__main__':
func() | 1,000 | PYTHON3 |
import sys
from collections import defaultdict
input = sys.stdin.readline
from types import GeneratorType
def bootstrap(f, stack=[]):
def wrappedfunc(*args, **kwargs):
if stack:
return f(*args, **kwargs)
else:
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
else:
stack.pop()
if not stack:
break
to = stack[-1].send(to)
return to
return wrappedfunc
def get_adj_mat(src, dst, n):
matrix = defaultdict(list)
for src_i, dst_i in zip(src, dst):
matrix[src_i].append(dst_i)
matrix[dst_i].append(src_i)
return matrix
@bootstrap
def get_num(src, adj_mat, seen):
seen[src] = True
num_el, num_seg = 1, 0
for dst in adj_mat[src]:
if not seen[dst]:
num_el_i, num_seg_i = yield get_num(dst, adj_mat, seen)
num_el += num_el_i
num_seg += num_seg_i
if num_el % 2 == 0:
num_el = 0
num_seg += 1
yield num_el, num_seg
def solve(src, dst, n):
adj_mat = get_adj_mat(src, dst, n)
seen = [False] * n
#print(get_num(0, adj_mat, seen))
num_el, num_seg = get_num(0, adj_mat, seen)
if num_el == 0:
return num_seg-1
else:
return -1
if __name__ == "__main__":
n = int(input())
src, dst = [], []
for _ in range(n-1):
src_i, dst_i = [int(val) for val in input().split()]
src.append(src_i-1), dst.append(dst_i-1)
print(solve(src, dst, n))
| 1,500 | PYTHON3 |
Subsets and Splits