solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y, z, g, p, b;
cin >> x >> y >> z;
cin >> g >> p >> b;
if (x > g)
cout << "NO" << endl;
else if (x + y > g + p)
cout << "NO" << endl;
else if (x + y + z > g + p + b)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| 800 | CPP |
s=input()
lst,k,length=[],1,0
for i,x in enumerate(s[:-1]):
if x==s[i+1]:k+=1
else:lst.append(k);k=1;length+=1
lst.append(k);length+=1
if s[0]=='o':lst.pop(0);length-=1
if length%2==0:
if length>0:
lst.pop();length-=1
summa1,summa2,res=0,0,0
for i in range(0,length,2):
summa1+=lst[i]-1
for i in range(1,length,2):
summa2+=lst[i-1]-1
res+=summa2*max(0,(summa1-summa2))*lst[i]
print(res) | 1,300 | PYTHON3 |
string = list(input())
x = "a"
total = 0
for i in string:
s = abs(ord(i) - ord(x))
if s<13:
total+=s
else:
total+=26-s
x = i
print(total) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
template <typename T>
using vc = vector<T>;
using pii = pair<long long, long long>;
long long transform(string a) {
long long n = a.length();
long long cur = 0;
for (long long i = 0; i < n; i++) {
cur <<= 1;
if ((a[i] - '0') % 2 == 1) cur |= 1;
}
return cur;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long t;
cin >> t;
map<long long, long long> ss;
while (t--) {
char type;
cin >> type;
string a;
cin >> a;
if (type == '+') {
long long cur = transform(a);
ss[cur]++;
} else if (type == '-') {
long long cur = transform(a);
ss[cur]--;
} else {
long long cur = 0;
for (long long i = 0; i < a.length(); i++) {
cur <<= 1;
if (a[i] == '1') cur |= 1;
}
cout << ss[cur] << endl;
}
}
return 0;
}
| 1,400 | CPP |
t = int(input())
for i in range(t):
n, k = map(int, input().split())
a = list(map(int, input().split()))
w = list(map(int, input().split()))
a.sort(reverse = True)
w.sort()
sum = 0
val_x, l, r = k, 0, n-1
for x in range(k):
if w[x] > 1:
val_x = x
break
sum += a[l]*2
l += 1
for p in range(k-1, val_x-1, -1):
val = w[p]
sum += a[l] + a[r]
r = r - val + 1
l += 1
print(sum)
| 1,400 | PYTHON3 |
# https://codeforces.com/contest/50/problem/A
n, m = map(int, input().split())
if m % 2 == 0:
print( n * ( m // 2))
else:
print( n * ( m // 2) + (n//2)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10010;
int n, m, k, flag, x[N], y[N], dis[N], vis[N];
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++)
scanf("%d%d", x + i, y + i), flag |= x[i] == n && y[i] == m;
if (flag)
++k, x[k] = n, y[k] = m;
else
++k, x[k] = n + 1, y[k] = m + 1;
for (int i = 0; i <= k; i++) dis[i] = 60010;
dis[0] = 0;
x[0] = y[0] = 1;
for (int i = 0; i <= k; i++) {
int mn = k;
for (int j = 0; j <= k - 1; j++)
if (vis[j] == 0 && dis[j] < dis[mn]) mn = j;
vis[mn] = 1;
for (int j = 0; j <= k; j++) {
if (vis[j]) continue;
int dx = abs(x[j] - x[mn]), dy = abs(y[j] - y[mn]);
if (dx + dy <= 1)
dis[j] = min(dis[j], dis[mn]);
else if (dx <= 2 || dy <= 2)
dis[j] = min(dis[j], dis[mn] + 1);
}
}
if (dis[k] == 60010)
printf("-1\n");
else
printf("%d\n", dis[k]);
}
| 2,200 | CPP |
if __name__=="__main__":
t=int(input())
while t!=0:
t-=1
x,y=[int(a) for a in input().split()]
if(x-y<2):
print("NO")
else:
print("YES") | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n;
int* a = new int[n + 1];
int* sum = new int[n + 1];
sum[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
cin >> m;
int* q = new int[m];
for (int j = 0; j < m; j++) {
cin >> q[j];
}
for (int k = 0; k < m; k++) {
int x = lower_bound(sum, sum + n, q[k]) - sum;
cout << x << endl;
}
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
long long dist[300005], ans[300005];
vector<pair<int, long long>> vec[300005];
vector<pair<int, int>> qrs[300005];
int par[300005];
set<int> se[300005];
struct edge {
int u, v;
long long c;
edge(int u, int v, long long c) : u(u), v(v), c(c) {}
bool operator<(const edge& rhs) const { return c < rhs.c; }
};
int main() {
int n, m, k, q;
scanf("%d %d %d %d", &n, &m, &k, &q);
for (int i = 1; i <= m; i++) {
int u, v;
long long w;
scanf("%d %d %lld", &u, &v, &w);
vec[u].push_back({v, w});
vec[v].push_back({u, w});
}
for (int i = 1; i <= q; i++) {
int a, b;
scanf("%d %d", &a, &b);
qrs[a].push_back({b, i});
qrs[b].push_back({a, i});
}
for (int i = 1; i <= n; i++) dist[i] = INF;
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
for (int i = 1; i <= k; i++) {
dist[i] = 0;
pq.push({dist[i], i});
}
while (!pq.empty()) {
pair<long long, int> cur = pq.top();
pq.pop();
int u = cur.second;
if (cur.first > dist[u]) continue;
for (pair<int, long long> nxt : vec[u]) {
int v = nxt.first;
long long c = nxt.second;
if (dist[v] > dist[u] + c) {
dist[v] = dist[u] + c;
pq.push({dist[v], v});
}
}
}
vector<edge> edges;
for (int i = 1; i <= n; i++) {
for (pair<int, long long> p : vec[i]) {
int v = p.first;
long long w = p.second;
edges.push_back(edge(i, v, dist[i] + dist[v] + w));
}
}
sort(edges.begin(), edges.end());
for (int i = 1; i <= n; i++) {
par[i] = i;
se[i].insert(i);
}
for (edge e : edges) {
int u = e.u, v = e.v;
long long c = e.c;
if (par[u] == par[v]) continue;
if (se[par[u]].size() > se[par[v]].size()) swap(u, v);
int pp = par[u];
for (int x : se[pp]) {
for (pair<int, int> p : qrs[x]) {
int nv = p.first, idx = p.second;
if (par[nv] == par[v]) ans[idx] = c;
}
}
for (int x : se[pp]) {
par[x] = par[v];
se[par[v]].insert(x);
}
se[pp].clear();
}
for (int i = 1; i <= q; i++) printf("%lld\n", ans[i]);
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, m, k, x[1003] = {}, a, z = 0;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) cin >> x[i];
cin >> a;
for (int i = 0; i < m; i++) {
int l = 0;
for (int j = 0; j <= 21; j++) {
if ((x[i] >> j) % 2 != (a >> j) % 2) l++;
}
if (l <= k) z++;
}
cout << z;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int mod = 998244353;
const int M = 2e5 + 10;
const int N = 5e2 + 10;
inline long long read() {
long long b = 1, sum = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') b = -1;
c = getchar();
}
while (isdigit(c)) {
sum = sum * 10 + c - '0';
c = getchar();
}
return b * sum;
}
int hs, gs;
int n, m, k, T;
int h, g, a[1 << 22];
long long sum;
vector<int> ans;
void change(int x) {
int l = 2 * x, r = 2 * x + 1;
if (a[l] == 0 && a[r] == 0) {
a[x] = 0;
} else {
if (a[l] > a[r]) {
a[x] = a[l];
change(l);
} else {
a[x] = a[r];
change(r);
}
}
}
int pull(int x) {
int l = 2 * x, r = 2 * x + 1;
if (a[l] == 0 && a[r] == 0) {
return x;
} else {
if (a[l] > a[r]) {
return pull(l);
} else {
return pull(r);
}
}
}
void solv(int x) {
if (a[x] == 0) return;
int l = 2 * x, r = 2 * x + 1;
while (pull(x) >= gs) {
ans.push_back(x);
sum -= a[x];
change(x);
}
solv(l);
solv(r);
}
int main() {
int i, j;
T = read();
while (T--) {
sum = 0;
h = read(), g = read();
hs = (1 << h);
gs = (1 << g);
n = hs - gs;
for (i = 1; i <= hs - 1; i++) {
a[i] = read();
a[i + n] = a[i + 2 * n] = 0;
sum += a[i];
}
ans.clear();
solv(1);
printf("%lld\n", sum);
for (i = 0; i < ans.size(); i++) {
printf("%d ", ans[i]);
}
printf("\n");
}
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2020;
const int Mod = 1e9 + 7;
void add_self(int& x, int y) {
if ((x += y) >= Mod) x -= Mod;
}
int n, m;
string s;
int Dp[N][N][2];
int ExtraL, ExtraR;
int Rec(int k = n - m, int Open = 0, bool Taken = false) {
if (k < 0) return 0;
if (Open < 0) return 0;
if (Open >= N) return 0;
if (!k && Taken) return !Open;
if (Dp[k][Open][Taken] + 1) return Dp[k][Open][Taken];
int Res = 0;
add_self(Res, Rec(k - 1, Open + 1, Taken));
add_self(Res, Rec(k - 1, Open - 1, Taken));
if (!Taken && Open >= ExtraR)
add_self(Res, Rec(k, Open - ExtraR + ExtraL, true));
return Dp[k][Open][Taken] = Res;
}
int main() {
cin >> n >> m >> s;
for (char c : s) {
if (c == '(')
ExtraL++;
else if (ExtraL)
ExtraL--;
else
ExtraR++;
}
memset(Dp, -1, sizeof(Dp));
cout << Rec() << endl;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long modPow(long long a, long long b);
long long modInv(long long a);
vector<long long> prim;
void seive(long long n) {
prim.resize(n + 1);
for (long long i = 0; i < n + 1; i++) prim[i] = 1;
prim[0] = prim[1] = 0;
for (long long i = 2; i <= sqrt(n); i++) {
for (long long j = i * i; j <= n; j += i) {
prim[j] = 0;
}
}
}
long long is_prime(long long n) {
if (prim.size() <= n) {
cout << "Initiate Seive"
<< "\n";
return 0;
}
return prim[n];
}
vector<long long> kmp(string s) {
long long n = (long long)s.length();
vector<long long> pi(n);
for (long long i = 0; i < n; i++)
for (long long k = 0; k <= i; k++)
if (s.substr(0, k) == s.substr(i - k + 1, k)) pi[i] = k;
return pi;
}
vector<long long> fact(1);
long long facto(long long n) {
fact[0] = 1;
if (fact.size() > n) return fact[n];
fact.push_back((n * facto(n - 1)) % 1000000007);
return fact[n];
}
const long long maxN = 2005;
long long parent[maxN];
long long size[maxN];
void make_set(long long v) {
parent[v] = v;
size[v] = 1;
}
long long find_parent(long long v) {
if (parent[v] == v) {
return v;
}
parent[v] = find_parent(parent[v]);
return parent[v];
}
void join(long long a, long long b) {
a = find_parent(a);
b = find_parent(b);
if (a != b) {
if (size[a] < size[b]) {
swap(a, b);
}
parent[b] = a;
size[a] += size[b];
}
}
pair<long long, long long> a[maxN];
vector<long long> gr[maxN];
bool vis1[maxN];
long long c[maxN], k[maxN];
long long N;
bool tower[maxN];
set<pair<long long, long long> > joins;
long long cost = 0;
pair<long long, pair<long long, long long> > minn;
pair<long long, long long> min_tower_point = {1000000000000000000, -1};
vector<long long> towers;
void dfs(long long n) {
if (vis1[n]) return;
vis1[n] = 1;
pair<long long, long long> close_city = {1000000000000000000,
1000000000000000000};
for (long long i = 1; i < N + 1; i++) {
if (i == n || find_parent(i) == find_parent(n)) continue;
if ((abs(a[n].first - a[i].first) + abs(a[n].second - a[i].second)) *
(k[i] + k[n]) <
close_city.first) {
close_city = {
(abs(a[n].first - a[i].first) + abs(a[n].second - a[i].second)) *
(k[i] + k[n]),
i};
}
}
if (close_city.first < minn.first) {
minn.first = close_city.first;
minn.second = {n, close_city.second};
}
if (c[n] < min_tower_point.first) {
min_tower_point = {c[n], n};
}
for (auto i : gr[n]) {
dfs(i);
}
}
void solve() {
long long n;
cin >> n;
N = n;
for (long long i = 1; i < n + 1; i++) cin >> a[i].first >> a[i].second;
for (long long i = 1; i < n + 1; i++) cin >> c[i];
for (long long i = 1; i < n + 1; i++) cin >> k[i];
for (long long i = 1; i < n + 1; i++) make_set(i);
while (true) {
long long f1 = 0;
for (long long i = 0; i < n + 1; i++) vis1[i] = 0;
for (long long i = 1; i < n + 1; i++) {
if (tower[find_parent(i)])
continue;
else
f1 = 1;
minn = {1000000000000000000, {-1, -1}};
min_tower_point = {1000000000000000000, -1};
if (!vis1[i])
dfs(i);
else
continue;
if (minn.first < min_tower_point.first) {
if (tower[find_parent(minn.second.first)] == 1 ||
tower[find_parent(minn.second.second)] == 1) {
tower[find_parent(minn.second.first)] = 1;
tower[find_parent(minn.second.second)] = 1;
}
join(minn.second.first, minn.second.second);
joins.insert({min(minn.second.first, minn.second.second),
max(minn.second.first, minn.second.second)});
cost += minn.first;
gr[min(minn.second.first, minn.second.second)].push_back(
max(minn.second.first, minn.second.second));
gr[max(minn.second.first, minn.second.second)].push_back(
min(minn.second.first, minn.second.second));
dfs(minn.second.second);
} else {
cost += min_tower_point.first;
towers.push_back(min_tower_point.second);
tower[find_parent(min_tower_point.second)] = 1;
}
}
if (!f1) break;
}
cout << cost << "\n";
cout << towers.size() << "\n";
for (auto i : towers) cout << i << " ";
cout << "\n";
cout << joins.size() << "\n";
for (auto i : joins) cout << i.first << " " << i.second << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
}
long long modPow(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) {
long long x = a * a;
x %= 1000000007;
return modPow(x, b / 2);
}
return (a * modPow(a, b - 1)) % 1000000007;
}
long long modInv(long long a) { return modPow(a, 1000000007 - 2); }
| 1,900 | CPP |
for _ in range(int(input())):
n = int(input())
two = three = 0
while n % 2 == 0:
two += 1
n >>= 1
while n % 3 == 0:
three += 1
n //= 3
if n != 1 or two > three:
print(-1)
else:
print(2 * three - two) | 900 | PYTHON3 |
n,m,a = map(int, input().split())
lo = n/a
la = m/a
if lo > int(lo):
lo+=1
if la > int(la):
la+=1
print(int(la) * int(lo))
| 1,000 | PYTHON3 |
s=str(input())
ls=s.split("+")
ls.sort()
lm=[]
for i in range(len(ls)):
lm.append(ls[i])
lm.append('+')
lm.pop(len(s))
print("".join(lm)) | 800 | PYTHON3 |
def solve():
n = int(input())
arr = [int(i) for i in input().split(' ')]
freq = [0 for i in range(n+1)]
for x in arr:
freq[x] += 1
cnt = 0
for i in range(n):
summ = 0
for j in range(i, n):
summ += arr[j]
if(i==j):
continue
if(summ<=n):
cnt += freq[summ]
freq[summ] = 0
print(cnt)
for _ in range(int(input())):
solve()
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(false);
std::array<int, 4> numbers{};
for (int& number : numbers) {
std::cin >> number;
}
std::sort(numbers.begin(), numbers.end());
std::cout << numbers[0] + numbers[1] - numbers[3] << '\n'
<< numbers[0] + numbers[2] - numbers[3] << '\n'
<< numbers[1] + numbers[2] - numbers[3];
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2147483647;
long long read() {
long long first = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
first = first * 10 + ch - '0';
ch = getchar();
}
return first * f;
}
void print(long long first) {
if (first < 0) putchar('-'), first = -first;
short a[20] = {}, sz = 0;
while (first > 0) a[sz++] = first % 10, first /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
int used[111111];
int max_health[111111];
int base_health[111111];
int regen[111111];
int n, m, wager, increase, damage;
tuple<int, int, int> health_points[222222];
map<int, int> cnt;
set<int> updates[111111];
int main() {
n = read(), m = read(), wager = read(), increase = read(), damage = read();
for (int i = 1; i <= n; i++) {
max_health[i] = read();
base_health[i] = read();
regen[i] = read();
health_points[i] = make_tuple(0, i, base_health[i]);
if (increase > 0 && max_health[i] <= damage) {
puts("-1");
return 0;
}
}
for (int i = 1; i <= m; i++) {
int time = read(), enemy = read(), health = read();
health_points[n + i] = make_tuple(time, enemy, health);
updates[enemy].insert(time);
}
sort(health_points + 1, health_points + n + m + 1);
for (int i = 1; i <= n + m; i++) {
int time, enemy, health;
tie(time, enemy, health) = health_points[i];
if (health <= damage) {
if (!used[enemy]) {
cnt[time]++;
used[enemy] = 1;
}
if (regen[enemy] > 0) {
long long at = time + (damage - health) / regen[enemy] + 1;
if (max_health[enemy] > damage &&
updates[enemy].upper_bound(at) ==
updates[enemy].upper_bound(time)) {
cnt[at]--;
(--cnt[at - 1])++;
used[enemy] = 0;
}
} else {
if (updates[enemy].upper_bound(time) == updates[enemy].end() &&
increase > 0) {
puts("-1");
return 0;
}
}
} else {
if (used[enemy]) {
cnt[time]--;
(--cnt[time - 1])++;
used[enemy] = 0;
}
}
}
long long ans = 0;
int tot = 0;
for (auto p : cnt) {
long long at, val;
tie(at, val) = p;
tot += val;
ans = max(ans, tot * (wager + increase * at));
}
print(ans);
return 0;
}
| 2,500 | CPP |
import sys
#py import math
import bisect
input = sys.stdin.readline
# Läser in ett heltal
# n = int(input())
# 3 4 5
# Läser in tre heltal
# x,y,z = map(int,input().split())
# Läser in en lista av heltal (om man inte vet hur många)
# a = list(map(int,input().split()))
# Vanlig start (första raden är antal test)
tests = int(input())
for test in range(tests):
n,m = map(int,input().split())
persons = list(map(int,input().split()))
sortedPersons = sorted(persons)
maxInRow = []
for row in range(n):
maxInRow.append(sortedPersons[((row+1)*m)-1])
rowForLevel = {}
lastLevel = 0
for level in sortedPersons:
if level > lastLevel:
for idx, maxInThisRow in enumerate(maxInRow):
if level <= maxInThisRow:
rowForLevel[level] = idx
break
lastLevel = level
# print(maxInRow)
# print(rowForLevel)
inconvenience = 0
seatmap = [[] for i in range(n)]
# print (seatmap)
for idx, person in enumerate(persons):
#print(idx, person)
# print(str(person) + " får gå till rad " + str(rowForLevel[person]))
row = rowForLevel[person]
inconvenience += len([seated for seated in seatmap[row] if seated < person])
bisect.insort(seatmap[row], person)
# print ("Inconvinience: " + str(inconvenience))
# print (seatmap)
if person == maxInRow[row]:
# print("Validating:")
# print(sortedPersons[row*m:(row+1)*m])
if seatmap[row].count(person) == sortedPersons[row*m:(row+1)*m].count(person):
rowForLevel[person] += 1
print (inconvenience)
| 1,600 | PYTHON3 |
n,m=map(int,input().split())
arr=[]
dict1={}
dict2={}
ans=n*n
for i in range(m):
x,y=map(int,input().split())
try:
dict1[x]+=1
except:
KeyError
dict1[x]=1
try:
dict2[y]+=1
except:
KeyError
dict2[y]=1
val=(len(dict1))*n
val+=len(dict2)*n
val-=len(dict1)*len(dict2)
arr.append(ans-val)
print(*arr)
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1, c;
while (c = getchar(), c < '0' || c > '9')
if (c == '-') f = -1;
while (c >= '0' && c <= '9') x += x + (x << 3) + c - '0', c = getchar();
return x * f;
}
const int maxn = 13;
const int maxm = 30;
const int maxq = 105;
int n, m, q;
int u[maxm], v[maxm];
int a[maxq], b[maxq], c[maxq];
long long f[maxn][1 << maxn];
void input() {
n = read();
m = read();
q = read();
for (int i = 0; i < m; ++i) u[i] = read() - 1, v[i] = read() - 1;
for (int i = 0; i < q; ++i)
a[i] = read() - 1, b[i] = read() - 1, c[i] = read() - 1;
}
long long dp(int x, int s) {
long long &ans = f[x][s];
if (~ans) return ans;
if (s == 0) return ans = 1;
ans = 0;
for (int i = 0; i < q; ++i)
if (c[i] != x && (a[i] == x && (s >> b[i] & 1) ||
b[i] == x && (s >> a[i] & 1) || a[i] == x && b[i] == x))
return ans;
int rt = s & -s;
for (int S = s; S; S = S - 1 & s)
if (S & rt) {
int T = s ^ S;
for (int i = 0; i < n; ++i)
if (S >> i & 1) {
bool ok = 1;
for (int j = 0; j < q; ++j)
if (c[j] == x && (S >> a[j] & 1) && (S >> b[j] & 1)) {
ok = 0;
break;
} else if (c[j] != x)
if ((S >> a[j] & 1) && (T >> b[j] & 1) ||
(S >> b[j] & 1) && (T >> a[j] & 1) ||
(S >> a[j] & 1) && (T >> c[j] & 1) ||
(S >> c[j] & 1) && (T >> a[j] & 1) ||
(S >> b[j] & 1) && (T >> c[j] & 1) ||
(S >> c[j] & 1) && (T >> b[j] & 1)) {
ok = 0;
break;
}
for (int j = 0; j < m; ++j) {
if ((S >> u[j] & 1) && (T >> v[j] & 1) ||
(S >> v[j] & 1) && (T >> u[j] & 1)) {
ok = 0;
break;
}
if (u[j] == x && v[j] == i || v[j] == x && u[j] == i) continue;
if (u[j] == x && (S >> v[j] & 1) || v[j] == x && (S >> u[j] & 1)) {
ok = 0;
break;
}
}
if (ok) ans += dp(i, S ^ (1 << i)) * dp(x, T);
}
}
return ans;
}
void solve() {
memset(f, -1, sizeof(f));
cout << dp(0, (1 << n) - 2) << endl;
}
int main() {
input();
solve();
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 10;
char s[maxn], t[maxn], l[maxn];
vector<int> ans;
int cnt[26];
int n;
void shl(int k) {
for (int i = k, j = n; i; i--, j--) l[j] = s[i];
for (int i = n, j = 1; i > k; i--, j++) l[j] = s[i];
swap(s, l);
}
int main() {
scanf("%d", &n);
scanf("%s%s", s + 1, t + 1);
for (int i = 1; i <= n; i++) cnt[s[i] - 'a']++, cnt[t[i] - 'a']--;
for (int i = 0; i < 26; i++)
if (cnt[i] != 0) return puts("-1") * 0;
for (int i = 1; i <= n; i++) {
if (i & 1) {
int j = n;
while (t[i] != s[j]) j--;
shl(j - 1);
ans.push_back(n - j + 1);
shl(n - j);
ans.push_back(j);
shl(j);
ans.push_back(n - j);
} else {
int j = 1;
while (t[i] != s[j]) j++;
shl(j);
ans.push_back(n - j);
shl(n - 1);
ans.push_back(1);
}
}
for (int i = 1; i <= n; i++)
if (s[i] != t[i]) {
shl(0);
ans.push_back(n);
break;
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
puts("");
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int count1 = 0, count2 = 0;
int res = 0;
vector<int> ar;
cin >> n;
if (n == 1) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
if (temp == 1) {
count1++;
} else {
count2++;
}
}
do {
if (count1 > 0 && count2 > 0) {
res++;
} else {
break;
}
count1--;
count2--;
} while (count1 > 0 && count2 > 0);
do {
if (count1 >= 3) {
res++;
count1 -= 3;
} else {
count1--;
}
} while (count1 > 0);
cout << res << endl;
return 0;
}
| 800 | CPP |
from sys import stdin, stdout
line1 = stdin.readline().split(" ")
n = int(line1[0])
k = int(line1[1])
line2 = stdin.readline().split(" ")
scores = list(map(int, line2))
advance = 0
i = 0
while i < k:
if scores[i] > 0:
advance +=1
else:
break
i += 1
k_score = scores[k-1]
if k_score > 0:
while i < n:
if scores[i] == k_score:
advance += 1
else:
break
i += 1
print(advance) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int conta[15];
int contb[15];
int main() {
int n;
string a, b;
scanf("%d", &n);
cin >> a >> b;
for (int i = 0; i < n; i++) {
conta[b[i] - '0']++;
contb[b[i] - '0']++;
}
int menor = 0;
int maior = 0;
for (int i = 0; i < n; i++) {
int d = a[i] - '0';
int j = d;
for (; j <= 9; j++) {
if (conta[j] > 0) {
conta[j]--;
break;
}
}
if (j == 10) menor++;
j = d + 1;
for (; j <= 9; j++) {
if (contb[j] > 0) {
contb[j]--;
maior++;
break;
}
}
}
printf("%d\n%d\n", menor, maior);
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int weight[N], cost[N];
pair<int, int> edges[N];
int arr[N], isUsed[N];
int parent[N], height[N];
vector<pair<int, int>> adj[N];
int dp[N][20];
int dp2[N][20];
int depth[N];
int logtable[N];
bool cmp(const int a, const int b) { return weight[a] < weight[b]; }
int findP(int x) {
if (parent[x] == x)
return x;
else
return parent[x] = findP(parent[x]);
}
void unionP(int a, int b) {
if (height[a] > height[b]) swap(a, b);
parent[a] = b;
height[b] = max(height[b], 1 + height[a]);
}
void dfs(int v, int p, int d, int e) {
depth[v] = d;
dp[v][0] = p;
dp2[v][0] = e;
for (int i = 1; i <= logtable[depth[v]]; i++) {
dp[v][i] = dp[dp[v][i - 1]][i - 1];
dp2[v][i] = max(dp2[v][i - 1], dp2[dp[v][i - 1]][i - 1]);
}
for (auto c : adj[v]) {
if (c.first != p) dfs(c.first, v, d + 1, c.second);
}
}
int lca(int a, int b) {
if (depth[a] > depth[b]) swap(a, b);
int s = 0;
for (int i = logtable[depth[b]]; i >= 0; i--) {
if (depth[b] - (1 << i) >= depth[a]) {
s = max(s, dp2[b][i]);
b = dp[b][i];
}
}
if (a != b) {
for (int i = logtable[depth[b]]; i >= 0; i--) {
if (dp[b][i] != dp[a][i]) {
s = max(s, max(dp2[a][i], dp2[b][i]));
a = dp[a][i];
b = dp[b][i];
}
}
s = max(s, max(dp2[a][0], dp2[b][0]));
}
return s;
}
int main() {
int n, m, u, v, e;
scanf("%d %d", &n, &m);
long long e2, e3;
for (int i = 1; i <= n; i++) parent[i] = i;
for (int i = 1; i <= m; i++) scanf("%d", weight + i);
for (int i = 1; i <= m; i++) scanf("%d", cost + i);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &u, &v);
edges[i].first = u, edges[i].second = v;
arr[i] = i;
}
int S;
scanf("%d", &S);
sort(arr + 1, arr + 1 + m, cmp);
long long total = 0;
int count = 0;
for (int i = 1; i <= m; i++) {
e = arr[i];
u = findP(edges[e].first);
v = findP(edges[e].second);
if (u == v) continue;
isUsed[e] = 1;
unionP(u, v);
total += weight[e];
u = edges[e].first;
v = edges[e].second;
count++;
adj[u].push_back({v, weight[e]});
adj[v].push_back({u, weight[e]});
}
long long best = total;
logtable[0] = -1;
for (int i = 1; i <= n; i++) {
logtable[i] = logtable[i - 1];
if ((i & -i) == i) logtable[i]++;
}
dfs(1, 0, 0, 0);
int ind = -1;
long long xx = 0;
for (int i = 1; i <= m; i++) {
e = lca(edges[i].first, edges[i].second);
e2 = weight[i] - (S / cost[i]);
e3 = total - e + e2;
if (e3 <= best) {
best = e3;
ind = i;
xx = e2;
}
}
cout << best << endl;
cout << ind << " " << xx << endl;
for (int i = 1; i <= n; i++) {
parent[i] = i;
height[i] = 0;
}
unionP(edges[ind].first, edges[ind].second);
for (int i = 1; i <= m; i++) {
e = arr[i];
u = findP(edges[e].first);
v = findP(edges[e].second);
if (u == v) continue;
unionP(u, v);
printf("%d %d\n", e, weight[e]);
}
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
int main() {
long long n, m;
std::cin >> n >> m;
std::cout << m % (int)std::pow(2, n) << '\n';
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
string a[50];
int n, m, x[2], y[2];
int numb, f[50][50];
bool ok(int x, int y) { return (x >= 0) && (x < n) && (y >= 0) && (y < m); }
int dfs(int x, int y) {
f[x][y] = numb;
int cnt = 1;
for (int i = 0; i < 4; i++)
if (ok(x + dx[i], y + dy[i]) && a[x + dx[i]][y + dy[i]] == '#' &&
f[x + dx[i]][y + dy[i]] != numb)
cnt += dfs(x + dx[i], y + dy[i]);
return cnt;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i];
int cnt = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] == '#') {
if (cnt < 2) {
x[cnt] = i;
y[cnt] = j;
}
cnt++;
}
if (cnt <= 2) {
cout << -1;
return 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] == '#') {
a[i][j] = '.';
for (int k = 0; k < 2; k++)
if (x[k] != i || y[k] != j) {
numb++;
if (dfs(x[k], y[k]) != cnt - 1) {
cout << 1;
return 0;
}
break;
}
a[i][j] = '#';
}
cout << 2;
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1 * 1e5 + 55;
bool vis[maxn];
int n;
string x;
int l[maxn], r[maxn];
int main() {
memset(vis, false, sizeof vis);
scanf("%d", &n);
cin >> x;
int con = 0, inf = maxn, ans = 0, cnt = 0;
for (int i = 0; i < n; i++) {
if (x[i] == 'G') {
con++, cnt++;
r[inf] = con;
} else {
r[inf] = l[i] = con;
inf = i;
con = 0;
}
ans = max(ans, con);
}
for (int i = 0; i < n; i++) {
if (x[i] == 'S') {
if (l[i] + r[i] < cnt)
ans = max(ans, l[i] + r[i] + 1);
else
ans = max(ans, l[i] + r[i]);
}
}
printf("%d\n", ans);
}
| 1,600 | CPP |
t = int(input())
for i in range(t):
n = int(input())
monsters = list(map(int, input().split()))
m = int(input())
dct = {}
lst = []
now = 0
index = 0
for j in range(m):
a, b = list(map(int, input().split()))
if b > now or (b == now and dct[index][0] < a):
index = j
now = b
dct[j] = [a, b]
lst.append([a, j])
lst.sort()
sfx = []
sfx.append([dct[lst[m - 1][1]][1], lst[m - 1][1]])
for j in range(m - 2, -1, -1):
result1, i1 = sfx[-1]
i2 = lst[j][1]
result2 = dct[i2][1]
if result2 > result1:
sfx.append([result2, i2])
else:
sfx.append(sfx[-1])
days = 1
count = 0
endurance = now
strength = dct[index][0]
for j in range(n):
if endurance == 0:
endurance = now
strength = dct[index][0]
days += 1
count = 0
if lst[-1][0] < monsters[j]:
days = -1
break
if monsters[j] > strength:
left = -1
right = m - 1
while left + 1 < right:
mid = (left + right) // 2
if lst[mid][0] >= monsters[j]:
right = mid
else:
left = mid
nxt = sfx[m - right - 1][1]
strength = dct[nxt][0]
endurance = dct[nxt][1] - count
if endurance <= 0:
endurance = dct[nxt][1]
days += 1
count = 0
count += 1
endurance -= 1
print(days)
| 1,700 | PYTHON3 |
str=input()
num=1
now=str[0]
ans=0
for i in range(1,len(str)):
if(str[i]==now):
num=num+1
else:
num=1
now=str[i]
if (num == 7):
ans = 1
break
if(ans==0):
print('NO')
else:
print('YES')
| 900 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef long double LD;
typedef pair<LL,LL> pii;
typedef pair<LL,pii> ppi;
typedef pair<pii,pii> ppp;
#define FOR(i, n) for(int i = 1; i<=n; i++)
#define F0R(i, n) for(int i = 0; i<n; i++)
#define mp make_pair
#define pb push_back
#define f first
#define s second
template<typename A, typename B> ostream& operator<<(ostream &cout, pair<A, B> const &p) { return cout << "(" << p.f << ", " << p.s << ")"; }
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v) {cout << "["; F0R(i, v.size()) {if (i) cout << ", "; cout << v[i];} return cout << "]";}
//var
const LL MOD = 1e9 + 7;
LL T, n, sub[205], dep[205], tin[205], tout[205], cc = 0, dp[205][205], fac[205], inv[205];
vector<LL> e[205];
LL v[205][205], bl[205][205];
LL cho(LL g, LL z){return (((fac[g] * inv[z]) % MOD) * inv[g - z]) % MOD;}
LL pwo(LL a1, LL b1){
LL res = 1, mul = a1;
for(; b1; b1 >>= 1){
if(b1 & 1) res = (res * mul) % MOD;
mul = (mul * mul) % MOD;
} return res;
}
void dfs(LL g, LL p, LL d){
cc++; tin[g] = cc;
sub[g] = 1; dep[g] = d;
bl[g][0] = p;
FOR(i, 9) bl[g][i] = bl[bl[g][i-1]][i-1];
for(auto u : e[g]){
if(u == p) continue;
dfs(u, g, d + 1);
sub[g] += sub[u];
}
cc++; tout[g] = cc;
}
bool anc(LL hi, LL lo){return (tin[hi] <= tin[lo] && tout[hi] >= tout[lo]);}
LL LCA(LL a1, LL b1){
if(dep[a1] < dep[b1]) swap(a1, b1);
for(int i = 9; i>=0; i--){
if(dep[bl[a1][i]] < dep[b1]) continue;
a1 = bl[a1][i];
}
if(a1 == b1) return a1;
for(int i = 9; i>=0; i--){
if(bl[a1][i] == bl[b1][i]) continue;
a1 = bl[a1][i];
b1 = bl[b1][i];
}
return bl[a1][0];
}
void solve(){
cin >> n;
fac[0] = 1; inv[0] = 1;
FOR(i, n){
fac[i] = (fac[i-1] * (LL)i) % MOD;
inv[i] = pwo(fac[i], MOD - 2);
}
F0R(i, n+1) dp[0][i] = 1;
LL i2 = pwo(2, MOD - 2);
//FOR(i, n) dp[i][0] = (dp[i-1][0] * i2) % MOD;
FOR(i, n) FOR(j, n)
dp[i][j] = (((dp[i-1][j] + dp[i][j-1]) % MOD) * i2) % MOD;
LL t1, t2;
FOR(i, n-1){
cin >> t1 >> t2;
e[t1].pb(t2);
e[t2].pb(t1);
}
LL ans = 0, ivn = pwo(n, MOD-2);
FOR(root, n){
cc = 0;
dfs(root, 0, 1);
FOR(i, n) FOR(j, n){
LL cnt = 0;
if(i <= j) continue;
if(anc(i, j)){
cnt++;
cnt %= MOD;
}
else if(anc(j, i))
continue;
else{
LL L = LCA(i, j);
cnt += dp[dep[i] - dep[L]][dep[j] - dep[L]];
cnt %= MOD;
}
ans = (ans + (cnt * ivn) % MOD) % MOD;
}
//cout << root << ' ' << cnt << "\n";
}
cout << ans << "\n";
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
T = 1;
//cin >> T;
FOR(t, T)
solve();
cout.flush();
return 0;
} | 2,300 | CPP |
n,m = map(int,input().split())
a = len(list(filter(lambda x: x % 2 == 0,[int(i) for i in input().split()])))
b = len(list(filter(lambda x: x % 2 == 0,[int(i) for i in input().split()])))
print(min(a,m-b)+min(b,n-a)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int s[3];
scanf("%d %d %d", &s[0], &s[1], &s[2]);
sort(s, s + 3);
int a = s[0], b = s[1], c = s[2];
int ans = 0;
if (a + b <= c)
printf("%d\n", a + b);
else
printf("%d\n", (a + b - c) / 2 + c);
}
}
| 1,100 | CPP |
# Queue at the school (Hard :3)
# Queue of n people
# Initially in order they entered
# 'Girls' move forward each second bc boys felt awkward
# Pos 1 served first (Pos 1 to Pos n)
# At time x, if a boy is on the i-th pos and a girl is on the (i + 1)-th pos,
# at time x + 1, the i-th position will have a girl and the (i + 1)-th pos will have a boy
# ^^^ boy and girl switch places if boy is in front each second
# Given initial position and initial time, determine how the queue will look after t seconds
n, t = input().split() # Num of children and amount of times the queue will change
t = int(t)
s = input() # Initial Queue
while t > 0:
s = s.replace("BG", "GB") # Simple method just replaces BG with GB :)
t -= 1
print(s)
| 800 | PYTHON3 |
from collections import defaultdict
import sys, os, math
if __name__ == "__main__":
#n, m = list(map(int, input().split()))
#sys.stdout.flush()
n = int(input())
s = input()
ans = []
cnt = 0
for i in range(len(s)):
if s[i] == 'B':
cnt += 1
if i == len(s) - 1:
ans.append(cnt)
else:
if cnt > 0:
ans.append(cnt)
cnt = 0
print(len(ans))
print(' '.join(str(num) for num in ans)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void inline MIN(long long &A, long long B) { A = min(A, B); }
int n, c[200005], dd[200005][2], res[200005];
vector<int> g[200005];
long long dp[200005][2];
void setup() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 2; i <= n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v), g[v].push_back(u);
}
}
void dpSolve(int u, int p) {
if (u > 1 && g[u].size() == 1) {
dp[u][0] = 0;
dp[u][1] = c[u];
return;
}
long long sumDp = 0;
for (auto v : g[u]) {
if (v == p) continue;
dpSolve(v, u);
sumDp += dp[v][1];
}
dp[u][0] = dp[u][1] = sumDp;
for (auto v : g[u])
if (v != p) MIN(dp[u][0], sumDp - dp[v][1] + dp[v][0]);
MIN(dp[u][1], dp[u][0] + c[u]);
}
void trace(int u, int state, int p) {
if (dd[u][state]) return;
dd[u][state] = 1;
if (u > 1 && g[u].size() == 1) {
res[u] = state;
return;
}
long long sumDp = 0;
for (auto v : g[u])
if (v != p) sumDp += dp[v][1];
if (state == 1) {
if (dp[u][1] == dp[u][0] + c[u]) {
res[u] = 1;
trace(u, 0, p);
}
if (dp[u][1] == sumDp)
for (auto v : g[u])
if (v != p) trace(v, 1, u);
} else {
int cnt = 0;
for (auto v : g[u])
if (v != p)
if (dp[u][0] == sumDp - dp[v][1] + dp[v][0]) cnt++;
if (cnt == 1) {
for (auto v : g[u])
if (v != p) {
if (dp[u][0] == sumDp - dp[v][1] + dp[v][0])
trace(v, 0, u);
else
trace(v, 1, u);
}
} else if (cnt > 1) {
for (auto v : g[u])
if (v != p) {
if (dp[u][0] == sumDp - dp[v][1] + dp[v][0]) trace(v, 0, u);
trace(v, 1, u);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
setup();
dpSolve(1, -1);
trace(1, 1, -1);
vector<int> vAns;
for (int i = 1; i <= n; i++)
if (res[i]) vAns.push_back(i);
cout << dp[1][1] << ' ' << vAns.size() << '\n';
for (auto v : vAns) cout << v << ' ';
}
| 2,500 | CPP |
import sys
input=sys.stdin.readline
T=int(input())
for _ in range(T):
n=int(input())
G={}
for i in range(1,n+1):
G[i]=[]
xv,yv=0,0
LR=[]
for i in range(n-1):
x,y=map(int,input().split())
G[x].append(y)
G[y].append(x)
LR.append([x,y])
xv,yv=x,y
Fd=[[0] for i in range(n+1)]
v=[0 for i in range(n+1)]
vis=[0 for i in range(n+1)]
Q=[1]
vis[1]=1
A=[]
while(len(Q)!=0):
a=Q.pop()
A.append(a)
val=vis[a]
for i in G[a]:
if (vis[i]==0):
vis[i]=val+1
Q.append(i)
A=A[::-1]
v=max(vis)
vis1=[0 for i in range(n+1)]
for i in range(n):
val=A[i]
if (vis[val]==v):
vis1[val]=1
else:
for i in G[val]:
if (vis1[i]==1):
Fd[val].append(sum(Fd[i])+1)
vis1[val]=1
#print(Fd)
cp=[]
val=n
for i in range(1,n+1):
v=max(max(Fd[i]),n-sum(Fd[i])-1)
if (v<val):
cp=[i]
val=v
elif(v==val):
cp.append(i)
#print(cp)
if (len(cp)==1):
print(yv,xv)
print(yv,xv)
else:
val=cp[0]
yv=0
for i in G[val]:
if (i!=cp[1]):
print(val,i)
print(i,cp[1])
break
| 1,700 | PYTHON3 |
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n,k=map(int,input().split())
s= input().rstrip()
s = ('0'*k + s + '0'*k).split('1')
ans=0
for i in s:
ans+=max((len(i)-k)//(k+1),0)
print(ans)
| 1,300 | PYTHON3 |
text=input("")
text1=text.replace("WUB"," ")
print(text1) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
long long x, y;
Point() : x(), y() {}
Point(long long _x, long long _y) : x(_x), y(_y) {}
void scan() { scanf("%lld%lld", &x, &y); }
void print() { 42; }
Point operator+(const Point &a) const { return Point(x + a.x, y + a.y); }
Point operator-(const Point &a) const { return Point(x - a.x, y - a.y); }
long long operator%(const Point &a) const { return x * a.x + y * a.y; }
long long operator*(const Point &a) const { return x * a.y - y * a.x; }
long long sqrLen() const { return *this % *this; }
bool operator<(const Point &a) const {
if (x != a.x) return x < a.x;
return y < a.y;
}
};
Point minP;
bool cmp(pair<Point, int> A, pair<Point, int> B) {
Point v = A.first - minP, u = B.first - minP;
long long x = v * u;
if (x != 0) return x > 0;
return v.sqrLen() < u.sqrLen();
}
const int N = 1010;
int n;
Point a[N];
pair<Point, int> b[N];
bool bad[N];
bool was[N];
int col[N];
int ans[N][2];
int ansSz;
int m;
void addEdge(int v, int u) {
ans[ansSz][0] = v;
ans[ansSz][1] = u;
ansSz++;
}
void buildHull() {
m = 0;
for (int i = 0; i < n; i++)
if (!bad[i]) b[m++] = make_pair(a[i], i);
minP = b[0].first;
for (int i = 0; i < m; i++)
if (b[i].first < minP) minP = b[i].first;
sort(b, b + m, cmp);
int sz = 0;
for (int i = 0; i < m; i++) {
Point P = b[i].first;
while (sz > 1 && (P - b[sz - 1].first) * (P - b[sz - 2].first) >= 0) sz--;
b[sz++] = b[i];
}
m = sz;
}
int main() {
scanf("%d", &n);
if (n == 1) {
printf("0\n");
return 0;
}
for (int i = 0; i < n; i++) {
a[i].scan();
scanf("%f", &col[i]);
}
buildHull();
int cntCh = 0;
for (int i = 0; i < m - 1; i++) {
if (col[b[i].second] != col[b[i + 1].second]) cntCh++;
}
if (cntCh > 2) {
printf("Impossible\n");
return 0;
}
for (int i = 0; i < m; i++) was[b[i].second] = 1;
while (ansSz < n - 2) {
int pos = 0;
while (pos < m - 1 && col[b[pos].second] == col[b[pos + 1].second]) pos++;
int rg = (pos + 1) % m, lf = (pos + m - 1) % m;
if (col[b[rg].second] != col[b[pos].second] &&
col[b[lf].second] != col[b[pos].second])
pos = (pos + 1) % m;
rg = (pos + 1) % m, lf = (pos + m - 1) % m;
if (col[b[rg].second] != col[b[pos].second] &&
col[b[lf].second] != col[b[pos].second])
throw;
if (col[b[rg].second] == col[b[pos].second])
addEdge(b[rg].second, b[pos].second);
else
addEdge(b[lf].second, b[pos].second);
int me = b[pos].second;
bad[me] = 1;
int myCol = col[me];
bool fnd = true;
while (fnd) {
buildHull();
fnd = false;
for (int i = 0; !fnd && i < m; i++) {
int pp = b[i].second;
if (!was[pp] && col[pp] == myCol) {
fnd = true;
bad[pp] = 1;
addEdge(me, pp);
}
}
}
for (int i = 0; i < m; i++) was[b[i].second] = 1;
}
buildHull();
if (m > 2) throw;
if (m == 2) {
int p = b[0].second, q = b[1].second;
if (col[p] == col[q]) addEdge(p, q);
}
printf("%d\n", ansSz);
for (int i = 0; i < ansSz; i++) printf("%d %d\n", ans[i][0], ans[i][1]);
return 0;
}
| 3,200 | CPP |
# -*- coding: utf - 8 -*-
"""""""""""""""""""""""""""""""""""""""""""""
| author: mr.math - Hakimov Rahimjon |
| e-mail: [email protected] |
| created: 27.01.2018 10:48 |
"""""""""""""""""""""""""""""""""""""""""""""
# inp = open("input.txt", "r"); input = inp.readline; out = open("output.txt", "w"); print = out.write
TN = 1
# ===========================================
def solution():
n = int(input())
ans = 1
for i in range(2,1024):
if int(bin(i)[2:])>n: break
else: ans+=1
print(ans)
# ===========================================
while TN != 0:
solution()
TN -= 1
# ===========================================
# inp.close()
# out.close()
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
string s;
int cnt, i, k, n;
int main() {
cin >> n >> k >> s;
if (!k) return cout << s, 0;
if (n == 1) return cout << 0, 0;
if (s[0] != '1') s[0] = '1', ++cnt;
for (i = 1; i <= s.size() && cnt < k; ++i) {
if (s[i] != '0') {
s[i] = '0';
++cnt;
}
}
cout << s;
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
vector<pair<long long, long long> > a(n);
for (auto &x : a) cin >> x.first;
for (auto &x : a) cin >> x.second;
long long ans = 0;
sort(a.begin(), a.end());
priority_queue<long long> pq;
long long sum = 0;
for (long long i = 0; i < n; ++i) {
if (!pq.empty()) {
long long dif = a[i].first - a[i - 1].first - 1;
long long j = 0;
while (!pq.empty()) {
if (j >= dif) break;
long long top = pq.top();
pq.pop();
ans += top * j;
sum -= top;
++j;
}
assert(sum >= 0);
ans += sum * dif;
}
long long j = i;
while (j < n and a[i].first == a[j].first) {
pq.push(a[j].second);
sum += a[j].second;
++j;
}
long long top = pq.top();
pq.pop();
sum -= top;
assert(sum >= 0);
ans += sum;
i = j - 1;
}
long long j = 0;
while (!pq.empty()) {
ans += pq.top() * j;
++j;
pq.pop();
}
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
for (long long i = 0; i < t; ++i) {
solve();
}
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[1000001], n, i, t, w, l, r;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
t = 1;
w = n;
l = 1;
r = 1000000;
for (i = 1; i <= 1000000; i++) {
l++;
r--;
if (a[t] == l) t++;
if (a[w] == r) w--;
if (t > w) break;
}
printf("%d\n", i);
}
| 1,100 | CPP |
#include <bits/stdc++.h>
const int N = 110000, K = 1100000, M = 1000000007;
struct item {
int tgt, dir;
item *next;
item() {}
item(int tgt, int dir, item *next) : tgt(tgt), dir(dir), next(next) {}
} * list[N], storage[2 * N];
struct query {
int tgt, id;
query *next;
query() {}
query(int tgt, int id, query *next) : tgt(tgt), id(id), next(next) {}
} * qlist[N], qstorage[2 * K];
bool vis[K];
int lca[K], ufa[N];
int ufind(int a) {
if (ufa[a] == a) {
return a;
}
int r = ufind(ufa[a]);
ufa[a] = r;
return r;
}
void tarjan(int a, int fa) {
vis[a] = true;
for (query *p = qlist[a]; p; p = p->next) {
if (vis[p->tgt]) {
lca[p->id] = ufind(p->tgt);
}
}
for (item *p = list[a]; p; p = p->next) {
if (p->tgt != fa) {
tarjan(p->tgt, a);
ufa[p->tgt] = a;
}
}
}
int lv[N][2], _2[K];
int dfs(int a, int fa) {
int r = 0;
for (item *p = list[a]; p; p = p->next) {
if (p->tgt != fa) {
r = (r + dfs(p->tgt, a)) % M;
if (p->dir >= 0) {
r = (r + _2[lv[p->tgt][p->dir]]) % M;
}
for (int d = 0; d < 2; d++) {
lv[a][d] += lv[p->tgt][d];
}
}
}
return r;
}
int qin[K];
int main() {
int n;
scanf("%d", &n);
item *loc = storage;
memset(list, 0, sizeof(list));
for (int i = 0; i < n - 1; i++) {
int a, b, d;
scanf("%d%d%d", &a, &b, &d);
a--;
b--;
list[a] = new (loc++) item(b, d ? 0 : -1, list[a]);
list[b] = new (loc++) item(a, d ? 1 : -1, list[b]);
}
int q;
scanf("%d", &q);
_2[0] = 0;
for (int i = 1; i <= q; i++) {
_2[i] = ((_2[i - 1] << 1) | 1) % M;
}
for (int i = 0; i < q; i++) {
scanf("%d", qin + i);
qin[i]--;
}
int prev = 0;
query *qloc = qstorage;
memset(qlist, 0, sizeof(qlist));
for (int i = 0; i < q; i++) {
qlist[prev] = new (qloc++) query(qin[i], i, qlist[prev]);
qlist[qin[i]] = new (qloc++) query(prev, i, qlist[qin[i]]);
prev = qin[i];
}
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++) {
ufa[i] = i;
}
tarjan(0, -1);
memset(lv, 0, sizeof(lv));
prev = 0;
for (int i = 0; i < q; i++) {
lv[prev][0]++;
lv[qin[i]][1]++;
lv[lca[i]][0]--;
lv[lca[i]][1]--;
prev = qin[i];
}
printf("%d\n", dfs(0, -1));
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int f(long long int n) {
long long int i;
for (i = 2; i * i <= n; i++)
if (n % (i * i) == 0) {
return 0;
}
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, ans = -1, i;
cin >> n;
if (f(n)) {
ans = n;
cout << ans << endl;
return 0;
}
for (i = 2; i * i <= n; i++) {
if (n % i == 0) {
if (f(i)) ans = max(ans, i);
if (f(n / i)) ans = max(ans, n / i);
}
}
cout << ans << endl;
}
| 1,300 | CPP |
def dfs(i, j):
if a[i][j] != -1:
return a[i][j]
d1 = dfs(i - 1, j - 1) + (s1[i - 1] == s2[j - 1]) * s1[i - 1]
d2 = dfs(i - 1, j)
d3 = dfs(i, j - 1)
a[i][j] = max(d1, d2, d3, key=lambda x: [len(x), -x.count(virus)])
return a[i][j]
s1, s2, virus = input(), input(), input()
#s1, s2, virus = 'SLO', 'LL', 'asda'
n1, n2 = len(s1), len(s2)
a = [[''] * (n2 + 1)] + [[''] + [-1] * n2 for i in range(n1)]
#a[1][0] = 'hjkhj'
ans = dfs(n1, n2)
while virus in ans:
ans = min(ans.replace(virus, virus[:-1]), ans.replace(virus, virus[1:]), key=lambda x: x.count(virus))
print(0 if ans == '' else ans) | 2,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<long long> num;
void gen(long long a) {
if (a > n) return;
num.push_back(a);
gen(a * 10 + 4);
gen(a * 10 + 7);
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
gen(4);
gen(7);
sort(num.begin(), num.end());
cout << lower_bound(num.begin(), num.end(), n) - num.begin() + 1;
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int n, m;
bool check(long long int mid) {
long long int a = mid / 2;
long long int b = mid / 3;
long long int c = mid / 6;
long long int total = a + b - c;
if (total >= n + m && n <= a && m <= b)
return true;
else
return false;
}
long long int bin() {
long long int low, high, mid, ans, b = 1;
low = 1;
high = max(2 * n, 6 * m);
while (low <= high) {
mid = (low + high) / 2;
if (check(mid)) {
high = mid - 1;
ans = mid;
} else
low = mid + 1;
}
return ans;
}
int main() {
long long int i, j;
while (cin >> n >> m) {
i = bin();
cout << i << endl;
}
return 0;
}
| 1,600 | CPP |
a,b,c=map(int,input().split())
i=0
s='NO'
while i<=c:
if(c-i)%b:
s=s
else:
s='YES'
i+=a
print(s)
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
static const double pi = acos(-1);
long double answer{0};
int32_t main() {
vector<pair<int, int>> v;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, k;
cin >> n >> k;
vector<int> a;
pair<int, int> pai;
int temp;
for (int i = 0; i < n; i++) {
cin >> temp;
v.push_back(make_pair(temp, i));
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
if (k >= v.at(i).first) {
k -= v.at(i).first;
a.push_back(v.at(i).second + 1);
answer++;
}
}
cout << answer << endl;
for (int g : a) {
cout << g << ' ';
}
return 0;
}
| 1,000 | CPP |
for _ in range(int(input())):
n = int(input())
p = n
for i in range(2, 100000):
if n % i == 0:
p = i
break
print(int(n / p), n - int(n / p)) | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
string s, ans;
cin >> s;
int i, L = 0, R, cnt = 1, n = s.size();
vector<int> v(n);
R = n - 1;
for (int i = 0; i < n; i++) {
if (s[i] == 'l')
v[R--] = cnt++;
else
v[L++] = cnt++;
}
for (auto it : v) cout << it << '\n';
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, ans;
int main() {
cin >> n;
n--;
for (long long i = 1; i <= n; i <<= 1) ans += i * ((n - i) / (2 * i) + 1);
cout << ans << '\n';
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, now, d[100001], s[100001], x[100001], y[100001];
queue<int> q;
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d", &d[i], &s[i]);
if (d[i] == 1) q.push(i);
}
while (!q.empty()) {
now = q.front();
q.pop();
if (d[now] == 1) {
s[s[now]] ^= now;
m++;
x[m] = now;
y[m] = s[now];
if ((--d[s[now]]) == 1) q.push(s[now]);
}
}
printf("%d\n", m);
for (i = 1; i <= m; i++) printf("%d %d\n", x[i], y[i]);
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
long long int b;
cin >> b;
vector<pair<int, int> > V(n);
for (int i = 0; i < n - 1; i++) {
cin >> V[i].first;
V[i].second = i + 1;
}
sort((V).begin(), (V).end(), greater<pair<int, int> >());
long long int S = 0;
for (int i = 0; i < k; i++) S += V[i].first;
if (S <= b) {
cout << n;
return (0);
}
int res = n;
for (int i = 0; i < n; i++)
if (S - V[k - 1].first + V[i].first > b) res = min(res, V[i].second);
cout << res;
return (0);
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T &t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T &t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
string direc = "URDL";
const long long MOD2 = (long long)1000000007 * (long long)1000000007;
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
vector<int> mp[100035];
long long X[100035];
int d[100035];
void dfs(int x, int pa) {
d[x] = d[pa] + 1;
for (int c : mp[x])
if (c != pa) {
dfs(c, x);
}
}
int Ans;
inline void dfs1(int x, int pa, vector<pair<int, long long>> &vp) {
assert(vp.size() < 50);
int cd = d[x];
for (auto &p : vp) {
addmod(Ans, p.second * (cd - d[p.first]) % 1000000007);
cd = d[p.first];
}
for (int c : mp[x])
if (c != pa) {
vector<pair<int, long long>> tmp;
tmp.push_back({x, X[c]});
for (auto &p : vp) {
long long z = tmp.back().second;
long long y = gcd1(z, p.second);
if (y == z) {
tmp[tmp.size() - 1].first = p.first;
} else {
tmp.push_back({p.first, y});
}
}
dfs1(c, x, tmp);
}
}
void fmain(int tid) {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%lld", X + i);
for (int i = 0, u, v; i < n - 1; i++) {
scanf("%d%d", &u, &v);
mp[u].push_back(v);
mp[v].push_back(u);
};
dfs(1, 0);
vector<pair<int, long long>> tmp;
tmp.push_back({0, X[1]});
dfs1(1, 0, tmp);
printf("%d\n", Ans);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> l[100005];
int c[100005];
bool f = false;
long long ans, n, m, sz[3];
void dfs(int k) {
sz[c[k]]++;
for (int i = 0; i < l[k].size(); i++) {
int p = l[k][i];
if (!c[p]) {
c[p] = 3 - c[k];
dfs(p);
} else if (c[p] != (3 - c[k]))
f = true;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
l[u].push_back(v);
l[v].push_back(u);
}
ans = 0;
for (int i = 1; i <= n; i++)
if (!c[i]) {
c[i] = 1;
sz[2] = sz[1] = 0;
dfs(i);
ans += (long long)sz[2] * (sz[2] - 1) / 2 + sz[1] * (sz[1] - 1) / 2;
}
if (f)
cout << 0 << " " << 1 << endl;
else if (ans != 0)
cout << 1 << " " << ans << endl;
else if (m == 0)
cout << 3 << " " << (long long)n * (n - 1) * (n - 2) / 6 << endl;
else
cout << 2 << " " << (long long)m * (n - 2) << endl;
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char ch = getchar();
int f = 1;
while (!isdigit(ch)) {
if (ch == '-') f *= -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
const int N = 200020;
int n, q, fa, a[N], b[N];
long long c[N] = {0}, d[N] = {0};
vector<int> G[N];
int dfn[N], sz[N], tim = 1;
void dfs(int num) {
c[num] += a[num];
d[num] += b[num];
dfn[num] = tim;
tim += 1;
sz[num] = 1;
for (auto ct : G[num]) {
c[ct] = c[num];
d[ct] = d[num];
dfs(ct);
sz[num] += sz[ct];
}
}
struct P {
int id;
long long x, y;
P(long long cx = 0, long long cy = 0, long long nid = 0)
: x(cx), y(cy), id(nid) {}
P operator-(const P &rhs) const { return P(x - rhs.x, y - rhs.y); }
bool operator<(const P &rhs) const {
if (x != rhs.x) return x < rhs.x;
return y < rhs.y;
}
long long operator*(const P &rhs) const {
if (abs(1.0 * x * rhs.y - 1.0 * y * rhs.x) > 1e5) {
if (1.0 * x * rhs.y - 1.0 * y * rhs.x > 0)
return 1;
else
return -1;
}
return x * rhs.y - y * rhs.x;
}
};
struct convex {
int l = 1e9, r = 0, cpo = 0;
long long accu = 0, cans = 0;
vector<P> cp;
vector<P> alp;
void rebuild() {
alp.clear();
for (int i = 0; i < cp.size(); i++) {
cp[i].y += cp[i].x * accu;
while (alp.size() >= 2 && (alp[alp.size() - 1] - alp[alp.size() - 2]) *
(cp[i] - alp[alp.size() - 1]) >=
0)
alp.pop_back();
alp.push_back(cp[i]);
}
assert(alp.size() != 0);
accu = cpo = 0;
while (cpo < (int)alp.size() - 1 && alp[cpo + 1].y > alp[cpo].y) cpo += 1;
cans = alp[cpo].y;
}
void build() {
sort(cp.begin(), cp.end());
rebuild();
}
void add(int cl, int cr, int cx) {
if (cr < l || cl > r) return;
if (cl <= l && r <= cr) {
accu += cx;
if (cx > 0)
while (cpo < (int)alp.size() - 1 &&
alp[cpo + 1].y + alp[cpo + 1].x * accu >=
alp[cpo].y + alp[cpo].x * accu)
cpo += 1;
if (cx < 0)
while (cpo > 0 && alp[cpo - 1].y + alp[cpo - 1].x * accu >=
alp[cpo].y + alp[cpo].x * accu)
cpo -= 1;
cans = alp[cpo].y + alp[cpo].x * accu;
return;
}
for (int i = 0; i < cp.size(); i++) {
if (cp[i].id <= cr && cp[i].id >= cl) cp[i].y += cp[i].x * cx;
}
rebuild();
}
long long qans(int cl, int cr) {
if (cr < l || cl > r) return -1e18;
if (cl <= l && r <= cr) return cans;
long long ans = -1e18;
for (auto ct : cp)
if (ct.id <= cr && ct.id >= cl) ans = max(ans, ct.y + ct.x * accu);
return ans;
}
} C[2020], rC[2020];
int main() {
read(n);
read(q);
for (int i = 2; i <= n; i++) {
read(fa);
G[fa].push_back(i);
}
for (int i = 1; i <= n; i++) read(a[i]);
for (int i = 1; i <= n; i++) read(b[i]);
dfs(1);
int blc = sqrt(n / 6) + 2, blcn = n / blc;
for (int i = 1; i <= n; i++) {
d[i] = abs(d[i]);
C[dfn[i] / blc].l = min(C[dfn[i] / blc].l, dfn[i]);
C[dfn[i] / blc].r = max(C[dfn[i] / blc].r, dfn[i]);
C[dfn[i] / blc].cp.push_back(P(d[i], c[i] * d[i], dfn[i]));
rC[dfn[i] / blc].cp.push_back(P(d[i], -c[i] * d[i], dfn[i]));
}
for (int i = 0; i <= blcn; i++) {
C[i].build();
rC[i].l = C[i].l;
rC[i].r = C[i].r;
rC[i].build();
}
while (q--) {
int typ, v, x;
read(typ);
read(v);
int l = dfn[v], r = dfn[v] + sz[v] - 1;
if (typ == 1) {
read(x);
for (int i = 0; i <= blcn; i++) {
rC[i].add(l, r, -x);
C[i].add(l, r, x);
}
} else {
long long ans = -1e18;
for (int i = 0; i <= blcn; i++) {
ans = max(ans, C[i].qans(l, r));
ans = max(ans, rC[i].qans(l, r));
}
cout << ans << endl;
}
}
return 0;
}
| 3,000 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:16777216")
using namespace std;
const int INF = 1000000000;
const int MAX = 1 << 17;
const int MOD = 1000000007;
int main() {
int n;
cin >> n;
vector<pair<pair<long long, long long>, pair<long long, long long> > > a;
for (int i = (0); i < (n); ++i) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
a.push_back(make_pair(make_pair(x1, y1), make_pair(x2, y2)));
}
for (int mask = (1); mask < (1 << n); ++mask) {
mask = (1 << n) - 1;
long long s = 0;
long long mx = INF;
long long my = INF;
long long Mx = -INF;
long long My = -INF;
for (int i = (0); i < (n); ++i)
if (mask & (1 << i)) {
s += (a[i].second.first - a[i].first.first) *
(a[i].second.second - a[i].first.second);
mx = min(mx, a[i].first.first);
my = min(my, a[i].first.second);
Mx = max(Mx, a[i].second.first);
My = max(My, a[i].second.second);
}
if (Mx - mx == My - my && (Mx - mx) * (My - my) == s) {
cout << "YES\n";
return 0;
}
}
cout << "NO\n";
return 0;
}
| 1,500 | CPP |
n,w=map(int,input().split())
min = 10**9
max = -10**9
arr = list(map(int,input().split()))
n = len(arr)
curr=0
for i in range(n):
curr+=arr[i]
if curr<min:
min=curr
if curr>max:
max=curr
if min <= 0:
min = -1 *min
else:
min=0
if max<=0:
max=w
else:
max = w-max
if min<0 or max>w or max<min:
print(0)
else:
print(max-min+1)
| 1,400 | PYTHON3 |
for _ in range(int(input())):
a,b,n,s=map(int,input().split())
if s//n <= a and s%n <= b :
print("YES")
elif s//n>a and s-(n*a)<=b:
print("YES")
else:
print("NO") | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char s[10005], las = -1;
int len;
int main() {
cin.getline(s, 10005);
len = strlen(s);
for (int i = (0); i <= (len - 1); i++) {
if (s[i] >= 'a' && s[i] <= 'z') {
if (las != -1) {
if (las != 32) printf("%c", las);
printf(" ");
}
printf("%c", s[i]);
las = -1;
} else {
if (s[i] != 32)
las = s[i];
else if (las == -1)
las = s[i];
}
}
if (las != -1 && las != 32) printf("%c", las);
printf("\n");
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> result;
long long seq[5];
int main() {
long long sum = 0;
for (int i = 0; i < 5; i++) {
cin >> seq[i];
sum += seq[i];
if (result.count(seq[i]) == 0) {
result[seq[i]] = 1;
} else {
result[seq[i]]++;
}
}
long long ans;
if (result.size() == 1) {
ans = seq[0] * 2;
} else if (result.size() == 2) {
bool flag4 = true;
for (int i = 0; i < 5; i++)
if (result[seq[i]] == 3) flag4 = false;
if (flag4) {
int i;
for (i = 0; i < 5; i++)
if (result[seq[i]] == 4) break;
ans = sum - 3 * seq[i];
} else {
int i, j;
for (i = 0; i < 5; i++)
if (result[seq[i]] == 3) break;
for (j = 0; j < 5; j++)
if (result[seq[j]] == 2) break;
ans = sum - max(2 * seq[j], 3 * seq[i]);
}
} else if (result.size() == 3) {
bool flag3 = true;
for (int i = 0; i < 5; i++)
if (result[seq[i]] == 2) flag3 = false;
if (flag3) {
int i;
for (i = 0; i < 5; i++)
if (result[seq[i]] == 3) break;
ans = sum - seq[i] * 3;
} else {
int i, j;
for (i = 0; i < 5; i++)
if (result[seq[i]] == 2) break;
for (j = 4; j >= 0; j--)
if (result[seq[j]] == 2) break;
ans = sum - max(seq[i], seq[j]) * 2;
}
} else if (result.size() == 4) {
int i;
for (i = 0; i < 5; i++)
if (result[seq[i]] == 2) break;
ans = sum - 2 * seq[i];
} else if (result.size() == 5) {
ans = sum;
}
cout << ans << endl;
}
| 800 | CPP |
c, v0, v1, a, l = list(map(int, input().split()))
count = 1
i = 1
c = c-v0
while c>0:
c += l
if v0+a*i < v1:
c -= (v0+a*i)
i +=1
count +=1
else:
c -= v1
count +=1
print(count) | 900 | PYTHON3 |
t = int(input())
while t > 0:
t -= 1
n, k = [int (x) for x in input().split()]
a = [int (x) for x in input().split()]
b = [int (x) for x in input().split()]
for x in range(k):
if min(a) < max(b):
a[a.index(min(a))], b[b.index(max(b))] = b[b.index(max(b))], a[a.index(min(a))]
tot = 0
for x in range(len(a)):
tot += a[x]
print(tot)
| 800 | PYTHON3 |
n=int(input())
c=0
while(n>=1):
if(n%2!=0):
c+=1
n-=1
else:
n=n//2
print(c) | 1,000 | PYTHON3 |
def amount(n, s, t):
return max(n - s, n - t) + 1
T = int(input())
for i in range(T):
n, s, t = map(int, input().split())
print(amount(n, s, t)) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000];
map<long long, long long> c1;
long long b[1000];
map<long long, long long> c2;
int main() {
long long n, x1 = 0, an = 0, anss, i, j, j2, j1, maxn = 0, minn = 2e18, p;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
b[i] = b[i - 1] + a[i];
}
j1 = 1;
for (j = 1; j <= n; j++) {
for (j2 = 1; j2 <= j; j2++) {
p = b[j] - b[j2 - 1];
if (c2[p] < j2) {
c1[p]++;
if (c1[p] > an) {
an = c1[p];
anss = p;
}
c2[p] = j;
}
}
}
cout << an << endl;
j1 = 1;
for (i = 1; i <= n; i++) {
for (j2 = j1; j2 <= i; j2++) {
if ((b[i] - b[j2 - 1]) == anss) {
cout << j2 << " " << i << endl;
j1 = i + 1;
break;
}
}
}
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 505;
const int MaxM = 505;
const int MaxP = (MaxN + MaxM) << 1;
const double pi = acos(-1.0);
const double eps = 1e-8;
int sgn(double x) { return x < -eps ? -1 : x > eps; }
struct pt {
double x, y;
int id;
pt() {}
pt(double x, double y) : x(x), y(y) {}
pt operator+(const pt& p) const { return pt(x + p.x, y + p.y); }
pt operator-(const pt& p) const { return pt(x - p.x, y - p.y); }
double operator*(const pt& p) const { return x * p.y - y * p.x; }
pair<double, int> to_pt(const pt& p) const {
return make_pair(atan2(y - p.y, x - p.x), id);
}
void init(int _id) {
id = _id;
scanf("%lf%lf", &x, &y);
}
} red[MaxN], black[MaxM];
int n, m, pn;
int dp[MaxN][MaxN], idx1[MaxN][MaxN], idx2[MaxN][MaxN];
pair<double, int> p[MaxP];
int xmult(const pt& p1, const pt& p2, const pt& p) {
return sgn((p1 - p) * (p2 - p));
}
void doit() {
int cnt, cot;
for (int i = 0; i < n; i++) {
pn = 0;
for (int j = 0; j < n; j++)
if (i != j) p[pn++] = red[j].to_pt(red[i]);
for (int j = 0; j < m; j++) p[pn++] = black[j].to_pt(red[i]);
sort(p, p + pn);
for (int j = 0; j < pn; j++) {
p[pn + j] = p[j];
p[pn + j].first += 2 * pi;
}
cnt = cot = 0;
for (int j = 0, k = 0; j < pn; j++) {
while (p[k].first - p[j].first < pi - eps)
if (p[k++].second >= n) cnt++;
if (p[j].second < n) {
idx1[i][p[j].second] = cot;
idx2[i][p[j].second] = j;
dp[i][p[j].second] = m - (p[j].second >= n) - cnt;
} else {
cot++;
cnt--;
}
}
}
}
int g(int a, int b, int c) {
if (idx2[a][c] >= idx2[a][b])
return idx1[a][c] - idx1[a][b];
else
return m - (idx1[a][b] - idx1[a][c]);
}
bool doit(int a, int b, int c) {
int ret = 0;
if (xmult(red[b], red[c], red[a]) < 0) swap(b, c);
ret += dp[a][b];
ret += dp[b][c];
ret += dp[c][a];
ret += g(a, b, c);
ret += g(b, c, a);
ret += g(c, a, b);
ret -= 2 * m;
return ret == 0;
}
int main() {
int ret;
while (scanf("%d%d", &n, &m) == 2) {
for (int i = 0; i < n; i++) red[i].init(i);
for (int i = 0; i < m; i++) black[i].init(i + n);
doit();
ret = 0;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
for (int k = j + 1; k < n; k++)
if (doit(i, j, k)) ret++;
printf("%d\n", ret);
}
return 0;
}
| 2,600 | CPP |
from math import *
a, b = input().split()
c, d = input().split()
a = int(a)
b = int(b)
c = int(c)
d = int(d)
e = abs(a-c)
f = abs(b-d)
g = 0
if e >= f:
print(e)
elif f >= e:
print(f)
# 1481129669675 | 800 | PYTHON3 |
num = int(input())
lst = []
p = 0
j = 0
for i in range(num):
n = int(input())
if n in lst and n == lst[0]:
p += 1
continue
elif n in lst and n == lst[1]:
j += 1
continue
else:
lst.append(n)
if len(lst) == 2 and p == j:
print('YES')
print(f'{lst[0]} {lst[1]}')
else:
print('NO') | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
#define LL long long
#define rep(i, s, t) for (register int i = (s), i##end = (t); i <= i##end; ++i)
#define dwn(i, s, t) for (register int i = (s), i##end = (t); i >= i##end; --i)
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -f;
for (; isdigit(ch); ch = getchar()) x = 10 * x + ch - '0';
return x * f;
}
int a[500010], fa[500010], vis[500010], mod = 1e9 + 7;
inline int find(int x) { return x==fa[x]?x:fa[x]=find(fa[x]); }
int main() {
int n = read(), m = read(), T = 0;
rep(i, 1, m) fa[i] = i;
rep(i, 1, n) {
int opt = read();
if(opt == 2) {
int u = read(), v = read();
u = find(u), v = find(v);
if((vis[u] && vis[v]) || u == v) continue;
fa[u] = v; vis[v] |= vis[u];
a[i] = 1; ++T;
} else {
int u = read(); u = find(u);
if(!vis[u]) a[i] = 1, T++, vis[u] = 1;
}
}
int cur = T, pns = 1, bs = 2;
rep(i, 1, T) pns = 2LL * pns % mod;
cout << pns << " " << T << endl;
rep(i, 1, n) if(a[i]) cout << i << " ";
} | 2,100 | CPP |
n = int(input().strip())
ochered = list(map(int,input().split()))
kup = [0] * 3
t = True
for i in ochered:
if i == 100:
if kup[1] > 0:
kup[1] -= 1
if kup[0] > 0:
kup[0] -= 1
else:
t = False
break
else:
if kup[0] > 2:
kup[0] -= 3
else:
t = False
break
elif i == 50:
kup[1] += 1
if kup[0] == 0:
t = False
break
else:
kup[0] -= 1
else:
kup[0] += 1
if t == False:
print('NO')
else:
print('YES')
| 1,100 | PYTHON3 |
input()
s=input()
print(s[0]+'0'*s[1:].count('0')) | 800 | PYTHON3 |
y,b=map(int,input().split())
p,q,r=map(int,input().split())
reqy=2*p+q
reqb=3*r+q
res=0
if reqy>y:
res+=reqy-y
if reqb>b:
res+=reqb-b
print(res) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int dp[10005];
int main() {
int k, n1, n2, n3, t1, t2, t3, i;
while (scanf("%d %d %d %d %d %d %d", &k, &n1, &n2, &n3, &t1, &t2, &t3) !=
EOF) {
memset(dp, 0, sizeof(dp));
for (i = 1; i <= k; i++) {
if (i > n3) dp[i] = max(dp[i], dp[i - n3] + t3);
if (i > n2) dp[i] = max(dp[i], dp[i - n2] + t2);
if (i > n1) dp[i] = max(dp[i], dp[i - n1] + t1);
}
printf("%d\n", dp[k] + t1 + t2 + t3);
}
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int Array[1000005];
int main() {
ios ::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
cout << 2 * (n / 3) + (n % 3 != 0);
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long M = 2000 + 100;
long long n, a[M][M], r[M], c[M], kol[M], d, ans;
char ci[M][M];
void clr() { fill(r, r + M, 0), fill(c, c + M, 0); }
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (long long i = (0); i <= (n - 1); i++) cin >> ci[i];
for (long long i = (0); i <= (n - 1); i++) {
for (long long j = (0); j <= (n - 1); j++) {
a[i + 1][j + 1] = (ci[i][j] - '0');
}
}
for (long long i = 1; i <= n; ++i) {
for (long long j = n; j > i; --j) {
d = (r[i] + c[j] + a[i][j]) % 2;
if (d == 1) {
r[i] ^= 1, c[j] ^= 1, kol[i] ^= 1, kol[j] ^= 1;
ans++;
}
}
}
clr();
for (long long i = n; i; --i) {
for (long long j = 1; j < i; ++j) {
d = (r[i] + c[j] + a[i][j]) % 2;
if (d == 1) {
r[i] ^= 1, c[j] ^= 1, kol[i] ^= 1, kol[j] ^= 1;
ans++;
}
}
}
for (long long i = 1; i <= n; i++) ans += (kol[i] + a[i][i]) % 2;
cout << ans;
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000 + 7;
const double esp = 1e-13;
const double pi = 3.141592653589;
int n, m, f[100 + 10][100 + 10];
char a[100 + 10][100 + 10];
int main() {
ios ::sync_with_stdio(false);
cin >> n >> m;
for (int i = (1), _b = (n); i <= _b; i++)
for (int j = (1), _b = (m); j <= _b; j++) cin >> a[i][j];
memset(f, 0, sizeof(f));
for (int i = (1), _b = (n); i <= _b; i++)
for (int j = (1), _b = (m); j <= _b; j++) {
for (int k = (1), _b = (m); k <= _b; k++)
if (a[i][j] == a[i][k] && j != k) f[i][j] = 1, f[i][k] = 1;
for (int k = (1), _b = (n); k <= _b; k++)
if (a[i][j] == a[k][j] && i != k) f[i][j] = 1, f[k][j] = 1;
}
for (int i = (1), _b = (n); i <= _b; i++)
for (int j = (1), _b = (m); j <= _b; j++)
if (f[i][j] == 0) cout << a[i][j];
}
| 1,100 | CPP |
a,b,c = map(int,input().split())
if a == b:
print("YES")
elif a > b and c < 0 and (a-b)%c == 0:
print("YES")
elif a < b and c >0 and (b-a)%c == 0:
print("YES")
else:
print("NO") | 1,100 | PYTHON3 |
def check(a,b) :
for i in range (len(a)) :
p = a[i]
for j in range(len(b)):
q = b[j]
z = p+q
if ((z in a) or (z in b)) :
pass
else :
return(p,q)
m = int(input())
a = set(map(int , input().split()))
a = list(a)
n = int(input())
b = set(map(int , input().split()))
b = list(b)
v = check(a,b)
print(*v) | 800 | PYTHON3 |
for t in range(int(input())):
n=int(input())
a=[9 for i in range(n)]
rem=n%4
b=n//4
k=n-1
while b>0:
a[k]=8
k=k-1
b=b-1
if rem:
a[k]=8
for i in range(n):
print(a[i],end="")
print() | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int zi[30], m;
char a[110000];
int main() {
cin >> m;
scanf("%s", &a);
for (int i = 0; i < strlen(a); ++i) zi[a[i] - 'a']++;
for (char Maxa = 'a'; Maxa <= 'z'; ++Maxa) {
int sum = 0, wei = -1, maywei = -1, i = 0;
for (i = 0; i < strlen(a); ++i) {
if (a[i] < Maxa)
wei = i;
else if (a[i] == Maxa)
maywei = i;
if (i - wei == m) {
if (i - maywei < m) {
sum++;
wei = maywei;
} else
break;
}
}
if (i == strlen(a)) {
for (char r = 'a'; r < Maxa; ++r) cout << string(zi[r - 'a'], r);
cout << string(sum, Maxa);
break;
}
}
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, v = 999, p = 0, c = 999;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
v = min(v, a);
p = max(p, a);
}
for (int i = 0; i < m; i++) {
int a;
scanf("%d", &a);
c = min(c, a);
}
if (max(2 * v, p) < c)
printf("%d\n", max(2 * v, p));
else
printf("-1\n");
return 0;
}
| 1,200 | CPP |
s = str(input())
CountN = 0;
CountI = 0;
CountE = 0;
CountT = 0;
for word in s:
if word == "n":
CountN += 1
elif word == "i":
CountI += 1
elif word == "e":
CountE += 1
elif word == "t":
CountT += 1
if ( (CountN < 3) or (CountE < 3) or (CountT < 1) or (CountI < 1)):
print(0)
else:
print(min((CountN-1)//2, CountE // 3 , CountT, CountI)) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
vector<long long int> snow(n);
vector<long long int> temperature(n);
vector<long long int> pref(n);
vector<long long int> count(n + 1, 0);
vector<long long int> partial(n + 1, 0);
for (long long int i = 0; i < n; i++) {
cin >> snow[i];
}
long long int add = 0;
for (long long int i = 0; i < n; i++) {
cin >> temperature[i];
add += temperature[i];
pref[i] = add;
}
for (long long int i = 0; i < n; i++) {
long long int val = snow[i];
if (i != 0) {
val += pref[i - 1];
}
count[i] += 1;
long long int itr =
lower_bound(pref.begin(), pref.end(), val) - pref.begin();
if (itr < n) {
count[itr]--;
}
partial[itr] += temperature[itr] - (pref[itr] - val);
}
long long int sum = 0;
for (long long int i = 0; i < n; i++) {
sum += count[i];
count[i] = sum;
}
for (long long int i = 0; i < n; i++) {
cout << count[i] * temperature[i] + partial[i] << " ";
}
cout << "\n";
}
| 1,600 | CPP |
[n,d] = [int(i) for i in input().split()]
coords = [int(i) for i in input().split()]
count = 2
hotels = set()
if n > 1:
for i in range(n):
if i == 0:
if coords[i+1]-(coords[i]+d) >= d:
if coords[i]+d not in hotels:
count += 1
hotels.add(coords[i]+d)
elif i == n-1:
if (coords[i]-d)-coords[i-1] >= d:
if coords[i]-d not in hotels:
count += 1
hotels.add(coords[i]-d)
else:
if (coords[i]-d)-coords[i-1] >= d:
if coords[i]-d not in hotels:
count += 1
hotels.add(coords[i]-d)
if coords[i+1]-(coords[i]+d) >= d:
if coords[i]+d not in hotels:
count += 1
hotels.add(coords[i]+d)
else:
pass
print(count) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool checksq(int k) {
for (int i = 0; i <= sqrt(k); i++) {
if (i * i == k) {
return true;
}
}
return false;
}
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = n - 1; i >= 0; i--) {
if (checksq(a[i]) == 0) {
cout << a[i];
break;
}
}
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const int maxn = 5000;
int n, x;
int l[maxn + 10], r[maxn + 10];
int hs[maxn * 2 + 10];
int tot = 0;
long long dp[maxn * 2 + 10];
int main() {
scanf("%d%d", &n, &x);
for (int i = 0; i < n; ++i) {
scanf("%d%d", l + i, r + i);
hs[tot++] = l[i];
hs[tot++] = r[i];
}
hs[tot++] = x;
sort(hs, hs + tot);
tot = unique(hs, hs + tot) - hs;
int p = lower_bound(hs, hs + tot, x) - hs;
memset(dp, 0x3f, sizeof dp);
dp[p] = 0;
for (int i = 0; i < n; ++i) {
int pl = lower_bound(hs, hs + tot, l[i]) - hs;
int pr = lower_bound(hs, hs + tot, r[i]) - hs;
long long minn = inf;
for (int j = 0; j <= pl; j++) {
dp[j] += hs[pl] - hs[j];
minn = min(minn, dp[j]);
dp[j] = min(minn, dp[j]);
}
minn = inf;
for (int j = tot - 1; j >= pr; j--) {
dp[j] += hs[j] - hs[pr];
minn = min(minn, dp[j]);
dp[j] = min(minn, dp[j]);
}
}
long long ans = inf;
for (int i = 0; i < tot; ++i) {
ans = min(ans, dp[i]);
}
printf("%I64d\n", ans);
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long v[10005], d[10005], p[10005];
vector<int> gennady;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &v[i]);
scanf("%lld", &d[i]);
scanf("%lld", &p[i]);
}
for (int i = 1; i <= n; i++) {
if (p[i] < 0) continue;
gennady.push_back(i);
long long till = 0;
int pos = -1;
for (int j = i + 1; j <= n; j++) {
if (p[j] < 0) continue;
if (pos < v[i]) pos++;
p[j] -= v[i] - pos + till;
if (p[j] < 0) {
till += d[j];
}
}
}
int sz = gennady.size();
printf("%d\n", sz);
for (int i = 0; i < sz; i++) printf("%d ", gennady[i]);
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 5;
struct Variable {
string value;
string operand1;
string operand2;
string op;
};
unordered_map<string, int> var_map;
Variable vars[N];
int m;
int n;
bool GetValue(const string& s, int bit_ind, int bit_val, short* values) {
bool val;
if (s == "?") {
val = bit_val;
} else {
val = values[var_map[s]];
}
return val;
}
bool GetRes(const string& op, bool a, bool b) {
if (op == "AND") return a & b;
if (op == "OR") return a | b;
if (op == "XOR") return a ^ b;
}
void Solve() {
string res_min(m, '0');
string res_max(m, '0');
for (int bit_ind = 0; bit_ind < m; ++bit_ind) {
int best_min = N;
int best_max = 0;
for (int bit_val = 0; bit_val < 2; ++bit_val) {
int cnt = 0;
short values[N];
for (int var_ind = 0; var_ind < n; ++var_ind) {
const auto& var = vars[var_ind];
if (!var.value.empty()) {
values[var_ind] = var.value[bit_ind] - '0';
continue;
}
bool op1_val = GetValue(var.operand1, bit_ind, bit_val, values);
bool op2_val = GetValue(var.operand2, bit_ind, bit_val, values);
bool val = GetRes(var.op, op1_val, op2_val);
values[var_ind] = val;
cnt += val;
}
if (cnt < best_min) {
best_min = cnt;
res_min[bit_ind] = bit_val + '0';
}
if (cnt > best_max) {
best_max = cnt;
res_max[bit_ind] = bit_val + '0';
}
}
}
cout << res_min << '\n' << res_max << '\n';
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
string var_name;
cin >> var_name;
var_map[var_name] = i;
string tmp;
cin >> tmp;
string value;
cin >> value;
if (isdigit(value[0])) {
vars[i].value = value;
} else {
Variable var;
var.operand1 = value;
cin >> var.op >> var.operand2;
vars[i] = var;
}
}
Solve();
}
| 1,800 | CPP |
num = int(input())
arr = list(map(int,input().split()))
if(1 in arr):
print("HARD")
else:
print("EASY")
| 800 | PYTHON3 |
n = int(input())
x1, x2 = map(int, input().split())
ps = [map(int, input().split()) for _ in range(n)]
ys = [0] * n
for i, (k, b) in enumerate(ps):
ys[i] = k * x1 + b, k * x2 + b
ys.sort()
max_y = -float('inf')
ok = False
for y1, y2 in ys:
if y2 < max_y:
ok = True
break
max_y = max(max_y, y2)
print('YES' if ok else 'NO')
| 1,600 | PYTHON3 |
n=int(input())
s=input()
d={'L':0,'R':0}
for i in s:
d[i]+=1
#print(d)
print(d['L']+d['R']+1) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, count = 0;
cin >> n >> a >> b;
int x[n];
for (int i = 0; i < n; i++) cin >> x[i];
for (int i = 0; i < n; i++) {
if (x[i] == 1) {
if (a != 0)
a--;
else
count++;
} else {
if (b != 0)
b--;
else {
if (a != 0)
a--;
else
count++;
}
}
}
cout << count;
return 0;
}
| 900 | CPP |
n=int(input())
if n==1:
print('5')
if n>=2:
print('25')
| 800 | PYTHON3 |
Subsets and Splits