solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e3 + 1;
void nos() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int n, k;
int a[Max][Max];
int mcolor;
void read() { cin >> n >> k; }
void paint(int left, int right, int color) {
if (left >= right) return;
mcolor = max(color, mcolor);
int len = right - left + 1;
int split = len / k;
int lenplus = len % k;
vector<pair<int, int> > splits;
int start = left;
int i;
for (i = 1; i <= lenplus; i++)
splits.push_back({start, start + split}), start += split + 1;
for (; i <= k; i++)
splits.push_back({start, start + split - 1}), start += split;
for (auto imp : splits) {
for (int k = imp.first; k <= imp.second; k++)
for (int j = imp.second + 1; j <= right; j++) a[k][j] = color;
paint(imp.first, imp.second, color + 1);
}
}
void solve() {
paint(1, n, 1);
int i, j;
cout << mcolor << '\n';
for (i = 1; i <= n; i++)
for (j = i + 1; j <= n; j++) cout << a[i][j] << ' ';
}
void restart() {}
int32_t main() {
nos();
read();
solve();
restart();
return 0;
}
| 2,500 | CPP |
t=int(input())
s=input().split("W")
while "" in s:
s.remove("")
print(len(s))
for i in s:
print(len(i),end=" ") | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long a[100000];
int l;
long long oc(long long n) {
long long ans = 0;
int i, j, k;
for (i = 0; i <= n; i += 2) ans += n - i;
return ans;
}
long long ec(long long n) {
long long ans = 0;
int i, j, k;
for (i = 1; i <= n; i += 2) ans += n - i;
return ans;
}
int main() {
string s;
int i, j, k;
cin >> s;
k = 0;
for (i = 1; i < s.size(); i++) {
if (s[i] != s[k]) {
a[l++] = i - k;
k = i;
}
}
a[l++] = i - k;
long long aodd = 0, aeven = 0, bodd = 0, beven = 0;
long long oans = 0, eans = 0, t1, t2;
for (i = l - 1; i >= 0; i--) {
oans += oc(a[i]);
eans += ec(a[i]);
if (i < (l - 1))
k = a[i + 1];
else
k = 0;
if (i % 2 == 0) {
if (k % 2 == 0) {
oans += ((a[i] + 1) / 2) * aeven + (a[i] / 2) * aodd;
eans += ((a[i] + 1) / 2) * aodd + (a[i] / 2) * aeven;
} else {
oans += ((a[i] + 1) / 2) * aodd + (a[i] / 2) * aeven;
eans += ((a[i] + 1) / 2) * aeven + (a[i] / 2) * aodd;
}
if ((k + a[i]) % 2 == 1) {
t1 = aeven;
aeven = aodd;
aodd = t1;
}
aodd += (a[i] + 1) / 2;
aeven += a[i] / 2;
} else {
if (k % 2 == 0) {
oans += ((a[i] + 1) / 2) * beven + (a[i] / 2) * bodd;
eans += ((a[i] + 1) / 2) * bodd + (a[i] / 2) * beven;
} else {
oans += ((a[i] + 1) / 2) * bodd + (a[i] / 2) * beven;
eans += ((a[i] + 1) / 2) * beven + (a[i] / 2) * bodd;
}
if ((k + a[i]) % 2 == 1) {
t1 = beven;
beven = bodd;
bodd = t1;
}
bodd += (a[i] + 1) / 2;
beven += a[i] / 2;
}
}
cout << eans << " " << oans << endl;
return 0;
}
| 2,000 | CPP |
n, k = map(int, input().split())
red = 2*n//k if 2*n%k == 0 else 2*n//k + 1
green = 5*n//k if 5*n%k == 0 else 5*n//k + 1
blue = 8*n//k if 8*n%k == 0 else 8*n//k + 1
print(red + green + blue)
| 800 | PYTHON3 |
def steps(n, idx):
return min(idx+1, n-idx)
def solve(n, a):
x, y = sorted([a.index(min(a)), a.index(max(a))])
b, c = steps(n, x), steps(n, y)
if b < c:
result = b + steps(n-b, y-b)
else:
result = c + steps(n-c, x)
return result
T = int(input())
for _ in range(T):
n = int(input())
a = [int(x) for x in input().split()]
result = solve(n, a)
print(result)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
long long sum = 0, sum1 = 0;
for (int i = 1; i <= 10; i++) {
sum1 = sum1 + (m * i) % 10;
}
long long k = n / m;
long long t = k / 10;
sum = sum1 * t;
for (int i = 1; i <= k % 10; i++) {
sum = sum + (m * i) % 10;
}
cout << sum << endl;
}
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct r {
int x1, x2, y1, y2;
};
int Ask(int a, int b, int c, int d) {
int ret;
printf("? %d %d %d %d\n", a, b, c, d);
fflush(stdout);
scanf("%d", &ret);
return ret;
}
r Find(int x1, int y1, int x2, int y2) {
r ret;
int s, e, m, k;
s = x1, e = x2;
while (s <= e) {
m = (s + e) / 2;
k = Ask(m, y1, x2, y2);
if (k == 0)
e = m - 1;
else
s = m + 1;
}
ret.x1 = s - 1;
s = x1, e = x2;
while (s <= e) {
m = (s + e) / 2;
k = Ask(x1, y1, m, y2);
if (k == 0)
s = m + 1;
else
e = m - 1;
}
ret.x2 = e + 1;
s = y1, e = y2;
while (s <= e) {
m = (s + e) / 2;
k = Ask(x1, m, x2, y2);
if (k == 0)
e = m - 1;
else
s = m + 1;
}
ret.y1 = s - 1;
s = y1, e = y2;
while (s <= e) {
m = (s + e) / 2;
k = Ask(x1, y1, x2, m);
if (k == 0)
s = m + 1;
else
e = m - 1;
}
ret.y2 = e + 1;
return ret;
}
int main() {
int n, s, e, m, k;
int _row1, _row2, _col1, _col2;
r r1, r2;
scanf("%d", &n);
s = 1, e = n;
while (s <= e) {
m = (s + e) / 2;
k = Ask(1, 1, m, n);
if (k == 0)
s = m + 1;
else
e = m - 1;
}
_row1 = e + 1;
s = 1, e = n;
while (s <= e) {
m = (s + e) / 2;
k = Ask(m, 1, n, n);
if (k == 0)
e = m - 1;
else
s = m + 1;
}
_row2 = s - 1;
if (_row1 < _row2) {
r1 = Find(1, 1, _row1, n);
r2 = Find(_row2, 1, n, n);
} else {
s = 1, e = n;
while (s <= e) {
m = (s + e) / 2;
k = Ask(1, 1, n, m);
if (k == 0)
s = m + 1;
else
e = m - 1;
}
_col1 = e + 1;
s = 1, e = n;
while (s <= e) {
m = (s + e) / 2;
k = Ask(1, m, n, n);
if (k == 0)
e = m - 1;
else
s = m + 1;
}
_col2 = s - 1;
r1 = Find(1, 1, n, _col1);
r2 = Find(1, _col2, n, n);
}
printf("! %d %d %d %d %d %d %d %d\n", r1.x1, r1.y1, r1.x2, r1.y2, r2.x1,
r2.y1, r2.x2, r2.y2);
fflush(stdout);
return 0;
}
| 2,200 | CPP |
import sys
import math
def II():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
def MI():
return map(int, sys.stdin.readline().split())
def SI():
return sys.stdin.readline().strip()
t = II()
for q in range(t):
n,r = MI()
if r<n:
s = r*(r+1)//2
else:
s = (n-1)*n//2+1
print(s) | 1,200 | PYTHON3 |
t=int(input())
while(t!=0):
t=t-1
n,r=map(int,input().split())
if(n==r):
n=n-1
print(n*(n+1)//2+1)
elif(n<r):
n=n-1
print(n*(n+1)//2+1)
else:
print(r*(r+1)//2)
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50000 + 10;
struct Event {
bool operator<(const Event& b) const { return x == b.x ? t < b.t : x < b.x; }
int t, x, y;
} ev[MAXN * 5];
struct Ver {
int x, a, b;
} ver[MAXN];
struct Hor {
int y, a, b;
} hor[MAXN];
int n, m, maxl;
int cnt;
inline bool check(int mid) {
cnt = 0;
int i;
for (i = 1; i <= m; i++) {
if (hor[i].b - hor[i].a >= 2 * mid) {
ev[++cnt] = (Event){0, hor[i].a + mid, hor[i].y};
ev[++cnt] = (Event){2, hor[i].b - mid, hor[i].y};
}
}
for (i = 1; i <= n; i++) {
ev[++cnt] = (Event){1, ver[i].x, i};
}
sort(ev + 1, ev + cnt + 1);
multiset<int> s;
for (i = 1; i <= cnt; i++) {
if (ev[i].t == 0) {
s.insert(ev[i].y);
} else if (ev[i].t == 1) {
if (ver[ev[i].y].b - ver[ev[i].y].a >= mid * 2 &&
s.lower_bound(ver[ev[i].y].a + mid) !=
s.upper_bound(ver[ev[i].y].b - mid)) {
return true;
}
} else {
s.erase(s.find(ev[i].y));
}
}
return false;
}
void solve() {
int L = 0, R = maxl / 2 + 1, M;
int ans = 0;
while (L < R) {
M = (L + R + 1) >> 1;
if (check(M)) {
ans = L = M;
} else {
R = M - 1;
}
}
printf("%d\n", ans);
}
void read() {
scanf("%d%d", &n, &m);
int i, x, y, l;
for (i = 1; i <= n; i++) {
scanf("%d%d%d", &x, &y, &l);
ver[i] = (Ver){x, y, y + l};
maxl = max(maxl, l);
}
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &l);
hor[i] = (Hor){y, x, x + l};
}
}
int main() {
read();
solve();
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
inline T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return (POW(B, P / 2) * POW(B, P / 2));
}
template <typename T>
inline T Gcd(T a, T b) {
if (a < 0) return Gcd(-a, b);
if (b < 0) return Gcd(a, -b);
return (b == 0) ? a : Gcd(b, a % b);
}
template <typename T>
inline T Lcm(T a, T b) {
if (a < 0) return Lcm(-a, b);
if (b < 0) return Lcm(a, -b);
return a * (b / Gcd(a, b));
}
long long Bigmod(long long base, long long power, long long MOD) {
long long ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % MOD;
base = (base * base) % MOD;
power >>= 1;
}
return ret;
}
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
long long ModInverse(long long number, long long MOD) {
return Bigmod(number, MOD - 2, MOD);
}
bool isConst(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
int toInt(string s) {
int sm;
stringstream second(s);
second >> sm;
return sm;
}
string Dekhi(string s) {
string ans = s;
for (int i = 1; i <= 9; i++) {
string a;
for (int j = 0; j < s.size(); j++) {
int tp = ((int)(s[j] - '0') + i) % 10;
a += (tp + '0');
}
ans = min(ans, a);
}
return ans;
}
string Rot(string s) {
string a;
for (int i = 1; i < s.size(); i++) a += s[i];
a += s[0];
return a;
}
int main() {
int n;
string s;
cin >> n >> s;
string ans = s;
for (int i = 0; i < n; i++) {
ans = min(ans, Dekhi(s));
s = Rot(s);
}
cout << ans << endl;
return 0;
}
| 1,500 | CPP |
n, m = map(int, input().split())
x= [3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47]
for i in range(n):
if i % 2 != 0 and i not in x:
for j in range(m):
if j == (m-1):
print('#', end='')
else:
print('.', end='')
elif i % 2 != 0 and i in x:
for j in range(m):
if j == (0):
print('#', end='')
else:
print('.', end='')
else:
for j in range(m):
print('#', end='')
print()
| 800 | PYTHON3 |
import sys
mp = {};
n = int(sys.stdin.readline())
A = list(map(int, sys.stdin.readline().split()))
ans = 0
ele = 0
sel = 0
for x in A:
ans = ans + ele * x - sel
if x-1 in mp:
ans = ans - mp[x-1]
if x+1 in mp:
ans = ans + mp[x+1]
if x in mp:
mp[x] += 1
else:
mp[x] = 1
sel += x
ele += 1
print(ans)
| 2,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
map<int, vector<pair<pair<int, int>, int> > > all;
vector<int> tree[2][1000005];
int n, m;
void build(void) {
int i;
for (i = 0; i < n; i++) tree[0][i] = vector<int>(4 * (m + 5), 0);
for (i = 0; i < m; i++) tree[1][i] = vector<int>(4 * (n + 5), 0);
}
void modify(int wh, int num, int pos, int val, int id, int l, int r) {
if (r - l < 2) {
tree[wh][num][id] = val;
return;
}
int mid = (l + r) >> 1;
if (pos < mid)
modify(wh, num, pos, val, 2 * id, l, mid);
else
modify(wh, num, pos, val, 2 * id + 1, mid, r);
tree[wh][num][id] = max(tree[wh][num][2 * id], tree[wh][num][2 * id + 1]);
}
int par[1000005];
int root(int v) { return par[v] < 0 ? v : (par[v] = root(par[v])); }
void union_set(int u, int v) {
if ((u = root(u)) == (v = root(v))) return;
if (par[u] > par[v]) swap(u, v);
par[u] += par[v];
par[v] = u;
}
void do_it(vector<pair<pair<int, int>, int> > &v) {
vector<pair<int, int> > tmp;
int i;
for (i = 0; i < v.size(); i++)
tmp.push_back(make_pair(v[i].first.first, v[i].second));
sort(tmp.begin(), tmp.end());
for (i = 1; i < tmp.size(); i++)
if (tmp[i].first == tmp[i - 1].first)
union_set(tmp[i].second, tmp[i - 1].second);
tmp.clear();
for (i = 0; i < v.size(); i++)
tmp.push_back(make_pair(v[i].first.second, v[i].second));
sort(tmp.begin(), tmp.end());
for (i = 1; i < tmp.size(); i++)
if (tmp[i].first == tmp[i - 1].first)
union_set(tmp[i].second, tmp[i - 1].second);
}
int answer[1000005], rtval[1000005];
int main() {
scanf("%d", &n);
scanf("%d", &m);
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
int x;
scanf("%d", &x);
all[x].push_back(make_pair(make_pair(i, j), i * m + j));
}
}
build();
memset(par, -1, sizeof(par));
for (map<int, vector<pair<pair<int, int>, int> > >::iterator it = all.begin();
it != all.end(); it++) {
vector<pair<pair<int, int>, int> > &vec = (it->second);
do_it(vec);
for (i = 0; i < vec.size(); i++) {
int x = vec[i].first.first, y = vec[i].first.second, ind = vec[i].second;
ind = root(ind);
rtval[ind] = max(rtval[ind], tree[0][x][1] + 1);
rtval[ind] = max(rtval[ind], tree[1][y][1] + 1);
}
for (i = 0; i < vec.size(); i++) {
int x = vec[i].first.first, y = vec[i].first.second, ind = vec[i].second;
ind = root(ind);
answer[x * m + y] = rtval[ind];
modify(0, x, y, rtval[ind], 1, 0, m);
modify(1, y, x, rtval[ind], 1, 0, n);
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) printf("%d ", answer[i * m + j]);
printf("\n");
}
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int in[9];
int n, k;
int a[9];
string s[9];
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < k; i++) in[i] = i;
int m = 100000000000;
do {
int m1 = 0, m2 = 100000000;
for (int j = 0; j < n; j++) {
int a = 0;
for (int l = 0; l < k; l++) a = a * 10 + s[j][in[l]] - '0';
m1 = max(m1, a);
m2 = min(m2, a);
}
m = min(m, m1 - m2);
} while (next_permutation(in, in + k));
cout << m;
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
int i, j, n, m, k;
int myabs(int a) { return a < 0 ? -a : a; }
int getit(char* s) {
int i, a = -1, b = -1;
bool empty = 0;
for (i = 0; s[i]; i++) {
if (s[i] == '-') {
empty = true;
continue;
}
if (s[i] == 'G') {
a = i;
}
if (s[i] == 'R') {
b = i;
}
}
if (a < 0 || b < 0) {
if (a < 0 && b < 0) return 0;
if (a < 0) {
if (empty) return -2;
}
if (b < 0) {
if (empty) return -1;
}
return 0;
}
return myabs(a - b) - 1;
}
inline void second() { printf("Second\n"); }
inline void first() { printf("First\n"); }
int p[1000], t;
char s[1000];
int main() {
scanf("%d %d %d", &n, &m, &k);
if (m == 1) {
second();
return 0;
}
bool fr = 0, se = 0;
for (i = 1; i <= n; i++) {
scanf("%s", s);
j = getit(s);
if (j == -1) {
fr = 1;
} else if (j == -2) {
se = 1;
} else {
p[t++] = j;
}
}
if (fr || se) {
if (fr && se) {
printf("Draw\n");
return 0;
}
if (fr) {
first();
return 0;
} else {
second();
return 0;
}
}
int ii, jj;
for (ii = 0, jj = 1; ii < 28; ii++) {
j = 0;
for (i = 0; i < t; i++) {
if (p[i] & jj) {
j++;
}
}
if (j % (k + 1) != 0) {
first();
return 0;
}
jj *= 2;
}
second();
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int const nax = 53;
using ll = long long;
ll const inf = 1e18 + 42;
ll add(ll x, ll y) { return min(inf, x + y); }
ll mul(ll x, ll y) {
if (y > inf / x) return inf;
return min(inf, x * y);
}
int pa[60];
ll f[60];
ll dp[60];
int find(int x) { return pa[x] == x ? x : pa[x] = find(pa[x]); }
vector<int> gen_cycle(int n, ll k) {
vector<int> res(n);
res[0] = n;
iota(pa, pa + n, 0);
set<int> used;
used.insert(n - 1);
pa[find(n - 1)] = find(0);
for (int i = 1; i < n; ++i) {
for (int t = 0; t < n; ++t) {
if (!used.count(t) && ((find(i) != find(t)) || i == n - 1)) {
ll w = (i < n - 1) ? f[n - i - 2] : 1;
if (w <= k) {
k -= w;
continue;
}
used.insert(t);
res[i] = t + 1;
pa[find(t)] = find(i);
goto survive;
}
}
throw;
survive:;
}
return res;
}
vector<int> solve(int n, ll k) {
if (n == 0) return vector<int>();
for (int i = 1; i <= n; ++i) {
ll x = mul(i == 1 ? 1 : f[i - 2], dp[n - i]);
if (x <= k) {
k -= x;
continue;
}
vector<int> cyc = gen_cycle(i, k / dp[n - i]);
vector<int> ret = solve(n - i, k % dp[n - i]);
for (int j : ret) cyc.push_back(i + j);
return cyc;
}
throw;
}
int main() {
int T;
int n;
ll k;
f[0] = 1;
for (int i = 1; i <= 55; ++i) f[i] = mul(i, f[i - 1]);
dp[0] = dp[1] = 1;
for (int i = 2; i <= 55; ++i) {
dp[i] = dp[i - 1];
for (int j = 2; j <= i; ++j) dp[i] = add(dp[i], mul(f[j - 2], dp[i - j]));
}
for (scanf("%d", &T); T--;) {
scanf("%d %lld", &n, &k);
if (dp[n] < k) {
printf("-1\n");
continue;
}
--k;
vector<int> ans = solve(n, k);
for (int i : ans) {
printf("%d ", i);
}
printf("\n");
}
}
| 2,700 | CPP |
n = int(input())
for i in range(n):
m = input()
if len(m) > 10:
print(m[0], len(m) - 2, m[-1], sep = '')
else:
print(m)
| 800 | PYTHON3 |
def equality(values):
count=0
maximum=max(values)
for i in range(len(values)):
count=count+(maximum-values[i])
return count
n=int(input())
values=list(map(int,input().split()))
print(equality(values)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct Star {
Star(int r, int x, int y) : r(r), x(x), y(y) {}
bool operator<(const Star& other) const {
if (r == other.r) {
if (x == other.x) {
return y < other.y;
}
return x < other.x;
}
return r < other.r;
}
int r;
int x;
int y;
};
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<string> p(n);
for (int i = 0; i < n; ++i) cin >> p[i];
vector<Star> s;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (p[i][j] == '*') {
for (int l = 1; i - l >= 0 && i + l < n && j - l >= 0 && j + l < m;
++l) {
if (p[i - l][j] == '*' && p[i + l][j] == '*' && p[i][j - l] == '*' &&
p[i][j + l] == '*') {
s.push_back(Star(l, i, j));
}
}
}
}
}
sort(s.begin(), s.end());
if (s.size() < k) {
cout << -1 << endl;
} else {
int x = s[k - 1].x + 1;
int y = s[k - 1].y + 1;
int r = s[k - 1].r;
cout << x << " " << y << endl;
cout << x - r << " " << y << endl;
cout << x + r << " " << y << endl;
cout << x << " " << y - r << endl;
cout << x << " " << y + r << endl;
}
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
const int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
const int Mod = 1000000000 + 0;
template <typename T>
inline T sq(T x) {
return x * x;
}
template <typename T>
inline T In() {
T x;
cin >> x;
return x;
}
template <typename T>
inline void Out(T& x) {
cout << x;
}
template <typename T>
inline void sort(T& v) {
sort(begin(v), end(v));
}
template <typename T>
inline void revs(T& v) {
reverse(begin(v), end(v));
}
template <typename T>
inline void uniq(T& v) {
sort(v);
v.erase(unique(begin(v), end(v)), end(v));
}
template <typename T>
inline int ubnd(T& v, typename T::value_type& x) {
return upper_bound(begin(v), end(v), x) - begin(v);
}
template <typename T>
inline int lbnd(T& v, typename T::value_type& x) {
return lower_bound(begin(v), end(v), x) - begin(v);
}
template <typename T, typename F>
inline void inpt(T& v, int n, F f) {
for (v.reserve(n); n--; v.emplace_back(f()))
;
}
template <typename T, typename F>
inline void show(T& v, F f, string d = " ", string e = "\n") {
int i = 0;
for (auto& x : v) i++ && (cout << d), f(x);
cout << e;
}
template <typename T>
inline typename T::iterator minel(T& v) {
return min_element(begin(v), end(v));
}
template <typename T>
inline typename T::iterator maxel(T& v) {
return max_element(begin(v), end(v));
}
inline void fast_io() {
ios::sync_with_stdio(0);
cin.tie(0);
}
inline int in() {
int x;
scanf("%d", &x);
return x;
}
inline long long pow_mod(long long a, long long k, long long m) {
long long r = 1;
for (; k > 0; a = a * a % m, k >>= 1)
if (k & 1) r = r * a % m;
return r;
}
inline long long mod_inv(long long a, long long p) {
return pow_mod(a, p - 2, p);
}
int main() {
vector<long long> xs, ys;
int n = in();
for (int i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
xs.emplace_back(x);
ys.emplace_back(y);
}
sort(xs);
sort(ys);
long long xx = abs(xs[0] - xs[n - 1]);
long long yy = abs(ys[0] - ys[n - 1]);
cout << sq(max(xx, yy)) << endl;
return 0;
}
| 1,300 | CPP |
# https://codeforces.com/contest/731/problem/A
# zeus
inp = input()
start = 'a'
my_dict = {'a':1}
for i in range(2,27):
start = chr(ord(start) + 1)
my_dict[start] = i
#print(my_dict)
rotation = 0
counter = 'a'
for i in inp:
distance1 = my_dict[counter] - my_dict[i]
distance2 = my_dict[i] - my_dict[counter]
#print('\t i:{}'.format(i))
#print(' d1:{};d2:{};min_steps:{}'
#.format(distance1,distance2,min(distance1, distance2)), end='')
if distance1 < 0:
distance1 += 26
if distance2 < 0:
distance2 += 26
rotation += min(distance1, distance2)
#print(' d1:{};d2:{};min_steps:{}'
#.format(distance1,distance2,min(distance1, distance2)))
counter = i
print(rotation)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long three[40];
long long n;
void calc() {
long long base = 3;
three[0] = 1;
three[1] = 3;
for (int i = 2; i <= 36; i++) {
base *= 3;
three[i] = base;
}
}
int main() {
calc();
while (cin >> n) {
for (int i = 1; i <= 36; i++) {
if (n % three[i] == 0) continue;
cout << n / three[i] + 1 << endl;
break;
}
}
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int count = 0;
int z = s[6] - '0';
cout << z % 2 << endl;
return 0;
}
| 0 | CPP |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Nov 6 15:55:24 2018
@author: LX
"""
stopnums = int(input())
passenger = 0
space = 0
for i in range(stopnums):
a, b = [int(x) for x in input().split()]
passenger = passenger -a +b
space = max(passenger, space)
print(space)
| 800 | PYTHON3 |
import os, sys
from io import BytesIO, IOBase
from types import GeneratorType
from bisect import *
from collections import defaultdict, deque, Counter
import math, string
from heapq import *
from operator import add, le
from itertools import accumulate
BUFSIZE = 8192
sys.setrecursionlimit(10 ** 5)
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
inf = float("inf")
en = lambda x: list(enumerate(x))
ceil_ = lambda a, b: (a + b - 1) // b
ii = lambda: int(input())
r = lambda: map(int, input().split())
rr = lambda: list(r())
# --------------------------
def solve():
a , x = r()
b , y = r()
c = len(str(a)) + x
d = len(str(b)) + y
if c < d:
print("<")
return
if c > d:
print(">")
return
a = list(str(a))
b = list(str(b))
while a[-1] == '0':
a.pop()
x += 1
while b[-1] == '0':
b.pop()
y += 1
if a == b and x == y:
print("=")
return
a = "".join(a)
b = "".join(b)
if len(a) < len(b):
while len(a) < len(b):
a += "0"
else:
while len(b) < len(a):
b += '0'
a = int(a)
b = int(b)
# print(a , b)
if a < b:
print("<")
else:
print(">")
for _ in " " * ii():
solve() | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 123;
const int mod = 1e9 + 7;
const int INF = 1e9 + 1;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n, m;
vector<pair<int, int> > g[MAXN];
set<pair<long long, int> > q;
long long d[MAXN];
map<int, bool> cnt[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
while (m--) {
int u, v, c;
cin >> u >> v >> c;
g[u].push_back(make_pair(c, v));
g[v].push_back(make_pair(c, u));
}
for (int i = 1; i <= n; i++) {
d[i] = INF * 1ll * INF;
int k;
cin >> k;
for (int j = 1; j <= k; j++) {
int x;
cin >> x;
cnt[i][x] = 1;
}
}
d[1] = 0;
q.insert(make_pair(0, 1));
while (!q.empty()) {
int v = q.begin()->second;
q.erase(q.begin());
long long t = d[v];
while (cnt[v][t]) {
t++;
}
for (int i = 0; i < g[v].size(); i++) {
long long to = g[v][i].second;
if (g[v][i].first + t < d[to]) {
q.erase(make_pair(d[to], to));
d[to] = g[v][i].first + t;
q.insert(make_pair(d[to], to));
}
}
}
cout << (d[n] == INF * 1ll * INF ? -1 : d[n]);
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
const long long N = 100011;
void solve() {
long long n, ans = 0;
cin >> n;
pair<long long, long long> a[n + 17];
multiset<long long> s;
for (long long i = 1; i <= n; i++) cin >> a[i].first;
for (long long i = 1; i <= n; i++) cin >> a[i].second;
sort(a + 1, a + n + 1);
long long sum = 0;
long long mn = 0;
a[n + 1].first = -1;
for (long long ind = 1; ind <= n; ind++) {
mn += 1;
if (s.empty()) mn = a[ind].first;
long long j = ind;
while (a[j].first == mn) {
s.insert(a[j].second);
sum += a[j].second;
j += 1;
}
long long mx = *(--s.end());
sum -= mx;
s.erase(s.find(mx));
ans += sum;
ind = j - 1;
}
while (s.size()) {
int mx = *(--s.end());
sum -= mx;
s.erase(s.find(mx));
ans += sum;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
cout << endl;
}
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int main() {
string s;
cin >> s;
set<char> s1;
int arr[150];
for (int i = 0; i < 128; i++) {
arr[i] = 0;
}
for (int i = 0; i < s.size(); i++) {
s1.insert(s[i]);
int temp = s[i];
arr[temp]++;
}
int e = 0, o = 0;
for (int i = 96; i < 128; i++) {
if (arr[i] >= 2) {
e++;
} else if (arr[i] == 1) {
o++;
}
}
if (s1.size() > 4) {
cout << "No" << endl;
} else if (s1.size() == 2) {
if (e > 1) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} else if (s1.size() == 3) {
if (o == 3) {
cout << "No" << endl;
} else {
cout << "Yes" << endl;
}
} else if (s1.size() == 4) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, ans, a;
cin >> n;
ans = 0;
long long p[n], arr[n + 1];
p[0] = 1;
for (int i = 1; i < n; i++) p[i] = (p[i - 1] * 2) % 998244353;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
for (int i = 1; i <= n; i++) {
ans = (ans +
(((p[n - i] + ((n - i) * p[n - i - 1]) % 998244353) % 998244353) *
arr[i]) %
998244353) %
998244353;
}
cout << ans << endl;
return 0;
}
| 2,000 | CPP |
s=(input())
n=len(s)
a=s.count('o')
l,y= a*[0],a*[0]
b,c=0,0
z,x=0,-1
for i in range(n-1) :
if s[i]=='v':
if s[i+1]=='v' :
b+=1
else :
l[z]=b
z+=1
for j in range(n-1):
if s[-j-1]=='v':
if s[-j-2]=='v':
c+=1
else :
y[x]=c
x-=1
d=0
for u in range(a) :
d+=l[u]*y[u]
print(d)
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
string s, s2, s3;
cin >> t;
while (t--) {
cin >> s;
int l = s.size();
if (l % 2 == 1)
cout << "NO" << endl;
else {
int mid = l / 2;
s2 = s.substr(0, mid);
s3 = s.substr(mid, l - mid);
if (s2 == s3)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
}
| 800 | CPP |
count = int(input())
res = 0
for i in range(count):
st = str(input())
if st[1] == '+':
res += 1
elif st[1] == '-':
res -= 1
print(res) | 800 | PYTHON3 |
# cook your dish here
a1,a2,a3,a4=map(int,input().split(" "))
x=[a1,a2,a3,a4]
x=sorted(x)
if x[0]+x[-1]==x[1]+x[2]:
print("YES")
elif x[0]+x[2]+x[1]==x[3]:
print("YES")
else:
print("NO") | 800 | PYTHON3 |
#include <bits/stdc++.h>
#define ll long long
#define all(v) v.begin(),v.end()
using namespace std;
void fast()
{
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main()
{
fast();
int tt; cin >> tt;
while (tt--)
{
int n, k; cin >> n >> k;
cout << (n - k) + (k / 2) << endl;
for (int i = k + 1; i <= n; i++)
cout << i << ' ';
for (int i = (k + 1) / 2; i < k; i++)
cout << i << ' ';
cout << endl;
}
return 0;
} | 800 | CPP |
#include <bits/stdc++.h>
int main() {
int a, b, c;
std::cin >> a >> b >> c;
if (a > b) {
std::swap(a, b);
}
if (a > c) {
std::swap(a, c);
}
if (b > c) {
std::swap(b, c);
}
if ((a == 1) || (a == 2 && b == 2) || (a == 2 && b == 4 && c == 4) ||
(a == 3 && b == 3 && c == 3)) {
std::cout << "YES" << std::endl;
} else {
std::cout << "NO" << std::endl;
}
return 0;
}
| 1,400 | CPP |
m=input()
n=input()
s=0
for i in range(len(n)):
if(n[i]==m[s]):
s=s+1
print(s+1) | 800 | PYTHON3 |
a=input()
b=len(a)
r=int(a)
if b<2:
k=r%4
if k==0 :
print(4)
elif k==1 :
print(0)
elif k==2 :
print(0)
else :
print(0)
else :
c=int(a[-2:])
i=c%4
if i==0 :
print(4)
elif i==1 :
print(0)
elif i==2 :
print(0)
else :
print(0) | 1,200 | PYTHON3 |
hmmm = int(input())
hm = list(input())
i = 0
newList = []
cur = ""
nex = ""
while i < hmmm:
cur = hm[i]
if i+1 < hmmm:
nex = hm[i+1]
if(cur == "R" and nex == "U") or (cur == "U" and nex == "R"):
i += 1
newList.append("D")
else:
newList.append(cur)
i += 1
print(len(newList))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
int dp[2001][1 << 12];
int A;
int main() {
scanf("%d%d", &N, &K);
K--;
dp[0][0] = 1;
int res = 0;
for (int(i) = 0; (i) < (N); (i)++) {
scanf("%d", &A);
if (A == 0) res = (res + res) % 1000000007;
if (A != 4) {
for (int(b) = 0; (b) < (1 << K); (b)++)
if (dp[i][b])
dp[i + 1][b + 1] = (dp[i + 1][b + 1] + dp[i][b]) % 1000000007;
}
if (A != 2) {
for (int(b) = 0; (b) < (1 << K); (b)++)
if (dp[i][b]) {
if (b % 2 == 0)
dp[i + 1][b + 2] = (dp[i + 1][b + 2] + dp[i][b]) % 1000000007;
if (b % 2 == 1) dp[i + 1][2] = (dp[i + 1][2] + dp[i][b]) % 1000000007;
}
}
if (dp[i + 1][1 << K]) res = (res + dp[i + 1][1 << K]) % 1000000007;
if (dp[i + 1][(1 << K) + 1])
res = (res + dp[i + 1][(1 << K) + 1]) % 1000000007;
}
printf("%d\n", res);
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e6 + 3;
long long get(long long n, long long p) {
long long res = 0;
for (long long x = p; n >= x; x *= p) {
res += n / x;
}
return res;
}
long long QPow(long long x, long long n) {
long long res = 1;
x %= mod;
while (n) {
if (n & 1) {
res *= x;
res %= mod;
}
x *= x;
x %= mod;
n >>= 1;
}
return res;
}
long long cal(long long x, long long k) {
if (k - 1 >= mod) return 0;
long long res = 1;
for (int i = 1; i <= k - 1; i++) {
res *= x - i;
res %= mod;
}
return res;
}
int main() {
long long n, k;
scanf("%I64d%I64d", &n, &k);
long long st = 0;
while (k > (1LL << st)) {
st++;
}
st--;
if (st >= n) {
printf("1 1\n");
return 0;
}
long long cnt = get(k - 1, 2);
long long x = QPow(2, cnt);
long long y = QPow(2, n);
long long inv = QPow(x, mod - 2);
long long up = (cal(y, k) * inv) % mod;
long long down = (QPow(y, k - 1) * inv) % mod;
up = (down - up + mod) % mod;
printf("%I64d %I64d\n", up, down);
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int N = 1000005;
const double PI = 4 * atan(1);
const double eps = 1e-7;
long long n, m, w;
long long a[N];
long long pos[N];
bool ok(long long u) {
vector<long long> v;
long long res = 0;
long long troll = 0;
memset(pos, 0, sizeof(pos));
for (int i = 0; i < n; i++) {
res += pos[i];
if (a[i] + res < u) {
long long x = u - (a[i] + res);
pos[i + w] -= x;
troll += x;
res += x;
}
}
return troll <= m;
}
int main() {
scanf("%lld %lld %lld ", &n, &m, &w);
long long res = (long long)1e9;
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
res = min(res, a[i]);
}
long long l = res;
long long r = 1e10;
long long ans = res;
while (l <= r) {
long long mid = (l + r) / 2;
if (ok(mid)) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
printf("%lld", ans);
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int s[101010], f[101010], h[101010], t[5050];
vector<int> pos[5050], c[5050];
struct Pa {
int h, f;
} cow[101010];
bool cmp(Pa A, Pa B) { return A.h < B.h; }
const int mod = 1000000007;
long long tans = 0, atot = 0;
inline int getl(int col, int tag) { return pos[col][tag - 1]; }
inline int getr(int col, int tag) { return pos[col][t[col] - tag]; }
int n, m;
void calc(int col, int pos, int tot, long long ans) {
for (int i = 1; i <= n; i++) {
if (col == i) continue;
int cntl = 0, cntr = 0, cntb = 0, l, r;
for (int j = c[i].size() - 1; ~j; j--) {
if (c[i][j] > t[i]) continue;
l = getl(i, c[i][j]);
r = getr(i, c[i][j]);
if (l <= pos) cntl++;
if (r > pos) cntr++;
if (l <= pos && r > pos) cntb++;
}
if (cntl && cntr && (cntl > min(cntb, 1) || cntr > min(1, cntb)))
(ans *= cntl * cntr - cntb) %= mod, tot += 2;
else if (cntl || cntr)
(ans *= cntl + cntr) %= mod, tot++;
}
if (tot > atot)
atot = tot, tans = ans;
else if (tot == atot)
tans += ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &s[i]);
t[s[i]]++;
pos[s[i]].push_back(i);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &cow[i].f, &cow[i].h);
}
sort(cow + 1, cow + m + 1, cmp);
for (int i = 1; i <= m; i++) {
c[cow[i].f].push_back(cow[i].h);
}
int tot = 0;
for (int i = 1; i <= n; i++) {
for (int j = c[i].size() - 1; ~j; j--) {
if (c[i][j] > t[i]) continue;
int cnt = 0;
for (int k = c[i].size() - 1; ~k; k--) {
if (k == j) continue;
if (c[i][j] + c[i][k] <= t[i]) cnt++;
}
if (cnt == 0)
calc(i, getl(i, c[i][j]), 1, 1);
else
calc(i, getl(i, c[i][j]), 2, cnt);
}
}
calc(n + 1, -1, 0, 1);
printf("%lld %lld", atot, tans % mod);
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, p, i, sum1, sum2, n;
cin >> t;
while (t--) {
cin >> n;
p = 1;
sum1 = 0;
sum2 = 0;
for (i = 1; i <= (n / 2) - 1; i++) {
p = p * 2;
sum1 = sum1 + p;
}
for (i = 1; i <= n / 2; i++) {
p = p * 2;
sum2 = sum2 + p;
}
sum1 = sum1 + 2 * p;
cout << sum1 - sum2 << endl;
}
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5+10;
int n;
bool chip[maxn];
int dist[maxn];
int ans[maxn];
vector<int> grafo[maxn];
void bfs(void)
{
queue<int> fila;
for (int i = 1; i <= n; i++)
{
if (chip[i])
{
dist[i] = 0;
fila.push(i);
}
}
while (!fila.empty())
{
int u = fila.front(); fila.pop();
for (auto v: grafo[u])
{
if (dist[v] == -1)
{
dist[v] = dist[u]+1;
fila.push(v);
}
}
}
}
struct SegmentTree
{
int tree[4*maxn];
void upd(int node, int l, int r, int pos, int v)
{
if (l == r)
{
tree[node] = v;
return;
}
int mid = (l+r)>>1;
if (pos <= mid) upd(2*node, l, mid, pos, v);
else upd(2*node+1, mid+1, r, pos, v);
tree[node] = max(tree[2*node], tree[2*node+1]);
}
int get(int node, int l, int r, int v)
{
if (tree[node] <= v) return -1;
if (l == r) return l;
int mid = (l+r)>>1;
if (tree[2*node+1] > v) return get(2*node+1, mid+1, r, v);
return get(2*node, l, mid, v);
}
} seg;
struct Centroid
{
int sz[maxn];
bool mark[maxn];
multiset<int> st[maxn];
void dfs(int u, int p)
{
sz[u] = 1;
for (auto v: grafo[u])
{
if (v == p || mark[v]) continue;
dfs(v, u);
sz[u] += sz[v];
}
}
int centroid(int u, int p, int S)
{
for (auto v: grafo[u])
if (v != p && !mark[v] && sz[v] > S/2)
return centroid(v, u, S);
return u;
}
void upd(int u, int p, int d, bool add)
{
if (dist[u] >= d)
{
if (add) st[dist[u]].insert(dist[u]-d);
else st[dist[u]].erase(st[dist[u]].find(dist[u]-d));
if (st[dist[u]].size() == 0) seg.upd(1, 0, n, dist[u], 0);
else seg.upd(1, 0, n, dist[u], *st[dist[u]].rbegin());
}
for (auto v: grafo[u])
{
if (v == p || mark[v]) continue;
upd(v, u, d+1, add);
}
}
void get(int u, int p, int d)
{
if (!chip[u]) ans[u] = max(ans[u], seg.get(1, 0, n, d));
for (auto v: grafo[u])
{
if (v == p || mark[v]) continue;
get(v, u, d+1);
}
}
void decompose(int u)
{
dfs(u, 0);
int c = centroid(u, 0, sz[u]);
mark[c] = 1;
st[dist[c]].insert(dist[c]);
seg.upd(1, 0, n, dist[c], dist[c]);
for (auto v: grafo[c])
{
if (mark[v]) continue;
get(v, c, 1);
upd(v, c, 1, 1);
}
if (!chip[c]) ans[c] = max(ans[c], seg.get(1, 0, n, 0));
for (auto v: grafo[c])
{
if (mark[v]) continue;
upd(v, c, 1, 0);
get(v, c, 1);
}
st[dist[c]].erase(st[dist[c]].find(dist[c]));
seg.upd(1, 0, n, dist[c], 0);
for (auto v: grafo[c])
if (!mark[v])
decompose(v);
}
} CD;
int main(void)
{
scanf("%d", &n);
for (int i = 1; i < n; i++)
{
int u, v;
scanf("%d %d", &u, &v);
grafo[u].push_back(v);
grafo[v].push_back(u);
}
int k;
scanf("%d", &k);
while (k--)
{
int u;
scanf("%d", &u);
chip[u] = 1;
}
memset(dist, -1, sizeof dist);
bfs();
CD.decompose(1);
for (int i = 1; i <= n; i++)
printf("%d ", ans[i]);
printf("\n");
} | 2,700 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,sse3,sse4,popcnt,abm,mmx")
using namespace std;
const double eps = 0.000001;
const long double pi = acos(-1);
const int maxn = 1e7 + 9;
const int mod = 1e9 + 7;
const long long MOD = 1e18 + 9;
const long long INF = 1e18 + 123;
const int inf = 2e9 + 11;
const int mxn = 1e6 + 9;
const int N = 3e5 + 123;
const int PRI = 555557;
const int pri = 997;
const int add = 1e5;
int tests = 1;
int n, m, k;
int a[N];
long long s;
int cur, res;
int ans;
int cnt[N];
inline void Solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (i == 1) {
cur = a[i], res = a[i];
}
cur = min(cur, a[i]);
res = max(res, a[i]);
s += a[i];
cnt[a[i] + add]++;
}
sort(a + 1, a + n + 1);
if (res - cur <= 1) {
cout << n << '\n';
for (int i = 1; i <= n; i++) cout << a[i] << ' ';
exit(0);
}
int mn = min(cnt[cur + add], cnt[add + res]);
int MN = mn;
if (mn + mn < cnt[cur + add + 1]) {
MN = cnt[cur + add + 1] / 2;
cout << n - MN * 2 << '\n';
mn = MN;
for (int i = 1; mn; i++) {
if (a[i] != cur + 1) continue;
a[i]++, mn--;
}
for (int i = n; MN; i--) {
if (res - 1 != a[i]) continue;
a[i]--, MN--;
}
for (int i = 1; i <= n; i++) cout << a[i] << ' ';
exit(0);
}
cout << n - mn * 2 << '\n';
for (int i = 1; mn; i++) {
a[i]++, mn--;
}
for (int i = n; MN; i--) {
a[i]--, MN--;
}
for (int i = 1; i <= n; i++) cout << a[i] << ' ';
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
while (tests--) {
Solve();
}
return 0;
}
| 1,700 | CPP |
n = int(input())
groups = 1
prevalue = int(input())
for i in range(1,n):
a = int(input())
if prevalue != a:
groups = groups + 1
prevalue = a
print(groups) | 800 | PYTHON3 |
n, m = map(int, input().split())
t = [int(input()) for i in range(n)]
s, p = 0, [0] * (n + 1)
for i in t:
if i < 0:
m -= 1
p[-i] -= 1
else: p[i] += 1
q = {i for i in range(1, n + 1) if p[i] == m}
if len(q) == 0: print('Not defined\n' * n)
elif len(q) == 1:
j = q.pop()
print('\n'.join(['Truth' if i == j or (i < 0 and i + j) else 'Lie' for i in t]))
else:
q.update({-i for i in q})
print('\n'.join(['Not defined' if i in q else ('Truth' if i < 0 else 'Lie') for i in t])) | 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long BM(long long b, long long p) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
p >>= 1LL;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
int k;
long long n = 1, a, p = 1, q = 1, m = 1;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> a;
n *= a;
n &= 1;
m *= (a % (mod - 1));
m %= (mod - 1);
}
m--;
m %= (mod - 1);
m += (mod - 1);
m %= (mod - 1);
p = (p * BM(2, m)) % mod;
q = (q * BM(2, m)) % mod;
if (n & 1)
p--;
else
p++;
p %= mod;
p += mod;
p %= mod;
p *= BM(3, mod - 2);
p %= mod;
cout << p << "/" << q << "\n";
return 0;
}
| 2,000 | CPP |
n,m=map(int,input().split())
v=[]
for i in range(n):
a,b=map(int,input().split())
v.append((a,b))
v = sorted(v,key=lambda e:e[0]-e[1],reverse=True)
tot=sum(e[0] for e in v)
c = 0
i=0
# print(v)
while i < n and tot > m:
e = v[i]
diff = e[0] - e[1]
tot -= diff
c+=1
# print(tot)
i+=1
if tot > m:
print(-1)
else:
print(c)
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, sum, num, maxi = -10e9, maxn = -10e9, mini = 10e9, minn = 10e9,
a[101];
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) {
if (a[i] <= 8) {
sum += a[i];
if (num > 8 - a[i]) {
sum += 8 - a[i];
num -= 8 - a[i];
} else {
sum += num;
num = 0;
}
} else {
num += a[i] - 8;
sum += 8;
}
if (sum >= k) {
cout << i;
return 0;
}
}
cout << -1;
return 0;
}
| 900 | CPP |
n, m = map(int, input().split())
a = set()
for i in range(n):
elems = list(map(int, input().split()))
for j in range(1, elems[0] + 1):
a.add(elems[j])
print("YES" if len(a) == m else "NO")
| 800 | PYTHON3 |
def main(n, a):
for i in range(n):
while a[i] % 3 == 0 or a[i] % 2 == 0:
if a[i] % 3 == 0:
a[i] //= 3
if a[i] % 2 == 0:
a[i] //= 2
for i in range(n - 1):
if a[i] != a[i + 1]:
return "No"
return "Yes"
print(main(int(input()), list(map(int, input().split(' ')))))
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, t, now;
char z;
long long ans, tmp;
int a[600][600], s[600][600];
int main() {
cin >> n >> m >> t;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> z;
if (z == '1')
a[i][j] = 1;
else
a[i][j] = 0;
s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1];
if ((i > 2) && (j > 2) && (a[i][j - 1] == 1) && (a[i - 1][j - 2] == 1) &&
(a[i - 1][j - 1] == 1) && (a[i - 1][j] == 1) &&
(a[i - 2][j - 1] == 1))
++s[i][j];
}
}
for (int i = 3; i <= n; i++)
for (int j = 3; j <= m; j++) {
now = m;
tmp = (n - i + 1) * (m - j + 1);
for (int k = i; k <= n; k++) {
if (now > m) now = m;
while ((now >= j) &&
(s[k][now] - s[k][j - 1] - s[i - 1][now] + s[i - 1][j - 1] >= t))
--now;
if (now <= m) ++now;
tmp -= now - j;
}
ans += tmp;
}
cout << ans << endl;
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int main() {
int n, s;
scanf("%d %d", &n, &s);
std::vector<int> a(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
s--;
int ans = 0;
if (a[s] != 0) {
a[s] = 0;
ans++;
}
std::vector<int> cnt(n, 0);
for (int i = 0; i < n; i++) {
cnt[a[i]]++;
}
int r = n - 1;
while (cnt[r] == 0) r--;
deque<int> skipped;
for (int i = 1; i < r; i++)
if (cnt[i] == 0) skipped.push_back(i);
while (cnt[0] > 1) {
cnt[0]--;
ans++;
if (!skipped.empty()) {
cnt[skipped.front()]++;
skipped.pop_front();
}
}
while (!skipped.empty() && skipped.front() < r) {
cnt[skipped.front()]++;
ans++;
skipped.pop_front();
cnt[r]--;
while (cnt[r] == 0) r--;
}
cout << ans;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
void parseArray(long long* A, long long n) {
for (long long k = 0; k < n; k++) {
scanf("%lld", A + k);
}
}
long long memo[101000][16];
char s[101000];
long long A[101000];
long long n;
long long dp(long long, long long);
int main() {
cin >> n;
scanf("%s", s);
parseArray(A, n);
memset(memo, -1, sizeof memo);
cout << dp(0, 0) << endl;
return 0;
}
long long dp(long long idx, long long v) {
if (idx == n) {
if (v < 15) {
return 0;
} else {
return 1000000000000000l;
}
}
if (memo[idx][v] != -1) {
return memo[idx][v];
}
long long ans = 0;
if (s[idx] == 'h') {
ans = ((A[idx] + dp(idx + 1, v)) < (dp(idx + 1, v | 1))
? (A[idx] + dp(idx + 1, v))
: (dp(idx + 1, v | 1)));
} else if (s[idx] == 'a' && (v & 1)) {
ans = ((A[idx] + dp(idx + 1, v)) < (dp(idx + 1, v | 2))
? (A[idx] + dp(idx + 1, v))
: (dp(idx + 1, v | 2)));
} else if (s[idx] == 'r' && (v & 2) && (v & 1)) {
ans = ((A[idx] + dp(idx + 1, v)) < (dp(idx + 1, v | 4))
? (A[idx] + dp(idx + 1, v))
: (dp(idx + 1, v | 4)));
} else if (s[idx] == 'd' && (v & 2) && (v & 1) && (v & 4)) {
ans = ((A[idx] + dp(idx + 1, v)) < (dp(idx + 1, v | 8))
? (A[idx] + dp(idx + 1, v))
: (dp(idx + 1, v | 8)));
} else {
ans = dp(idx + 1, v);
}
return memo[idx][v] = ans;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, strengh[300300];
vector<int> graph[300300];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &strengh[i]);
for (int i = 0; i < n - 1; i++) {
scanf("%d %d", &a, &b);
graph[a].push_back(b);
graph[b].push_back(a);
}
int ans = 2000000000;
multiset<int> aux;
for (int i = 1; i <= n; i++) aux.insert(strengh[i]);
for (int i = 1; i <= n; i++) {
int x = strengh[i];
aux.erase(aux.find(strengh[i]));
if (graph[i].size() > 0) {
x = max(x, *(aux.rbegin()) + 1);
for (int v : graph[i]) aux.erase(aux.find(strengh[v]));
if (!aux.empty()) x = max(x, *(aux.rbegin()) + 2);
}
aux.insert(strengh[i]);
for (int v : graph[i]) aux.insert(strengh[v]);
ans = min(ans, x);
}
printf("%d\n", ans);
return 0;
}
| 1,900 | CPP |
s = input()
l = len(s)
count=0
trig = []
for i in range(l-1):
if s[i]=='A' and s[i+1]=='B':
count=1
m = i
trig.append(m)
# print(m)
# print(trig)
if count>0:
for i in range(l-1):
if s[i]=='B' and s[i+1]=='A':
# print(i)
for m in trig:
if i!=m+1 and i+1!=m:
count+=1
break
if count>=2:
res = "YES"
else:
res = "NO"
print(res) | 1,500 | PYTHON3 |
n = int(input())
x = [int(i) for i in input().split()]
x.sort()
def binSrch(lo,hi,m):
mid = (lo+hi)//2
if x[mid]<=m:
if x[mid+1]>m:
return mid+1
else:
return binSrch(mid+1,hi,m)
else:
return binSrch(lo,mid-1,m)
q = int(input())
for i in range(q):
m = int(input())
if m<x[0]:
print(0)
elif m>=x[n-1] :
print(n)
else:
print(binSrch(0,n-1,m))
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j;
scanf("%d", &n);
int a[n], b[n], ans[n], flag;
for (i = 0; i < n - 1; i++) scanf("%d", &a[i]);
for (i = 0; i < n - 1; i++) scanf("%d", &b[i]);
for (i = 0; i <= 3; i++) {
ans[0] = i;
flag = 1;
for (j = 0; j < n - 1; j++) {
ans[j + 1] = -1;
if (((ans[j] | 0) == a[j]) && ((ans[j] & 0) == b[j]))
ans[j + 1] = 0;
else if (((ans[j] | 1) == a[j]) && ((ans[j] & 1) == b[j]))
ans[j + 1] = 1;
else if (((ans[j] | 2) == a[j]) && ((ans[j] & 2) == b[j]))
ans[j + 1] = 2;
else if (((ans[j] | 3) == a[j]) && ((ans[j] & 3) == b[j]))
ans[j + 1] = 3;
if (ans[j + 1] == -1) {
flag = 0;
break;
}
}
if (flag == 1) break;
}
if (flag == 1) {
printf("YES\n");
for (i = 0; i < n; i++) printf("%d ", ans[i]);
} else
printf("NO");
return 0;
}
| 1,500 | CPP |
def find_width(n,h,hlist):
width=0
for i in hlist:
if i>h:
width=width+2
else:
width+=1
return width
(n,h)=map(int,input().rstrip().split())
hlist=list(map(int,input().rstrip().split()))
print(find_width(n,h,hlist)) | 800 | PYTHON3 |
import math
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
ans=list()
b=[0]*n
mm=max(a)
ans.append(mm)
maxi=-math.inf
for k in range(n):
if a[k]==mm:
b[k]=1
break
GG=mm
cc=-1
for i in range(n-1):
maxi=-math.inf
for j in range(n):
if b[j]!=1:
temp=math.gcd(GG,a[j])
if temp>maxi:
maxi=temp
bb=a[j]
cc=j
if j==n-1:
GG=maxi
ans.append(bb)
if cc!=-1:
b[cc]=1
for i in range(len(ans)):
print(ans[i],end=" ")
print()
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
const int MAXE = 200005;
const long long INF = 1e18;
struct Edge {
int v, n;
Edge() {}
Edge(int v, int n) : v(v), n(n) {}
};
Edge E[MAXE];
int H[MAXN], cntE;
int val[MAXN];
long long dp[MAXN][2];
int n;
void clear() {
cntE = 0;
memset(H, -1, sizeof H);
}
void addedge(int u, int v) {
E[cntE] = Edge(v, H[u]);
H[u] = cntE++;
}
void dfs(int u) {
long long maxv = -INF;
long long sum = 0;
int cnt = 0;
for (int i = H[u]; ~i; i = E[i].n) {
int v = E[i].v;
dfs(v);
if (dp[v][0] >= dp[v][1]) {
sum += dp[v][0];
maxv = max(maxv, dp[v][1] - dp[v][0]);
} else {
sum += dp[v][1];
cnt ^= 1;
maxv = max(maxv, dp[v][0] - dp[v][1]);
}
}
if (cnt) {
dp[u][0] = sum + maxv;
dp[u][1] = max(sum + maxv + val[u], sum);
} else {
dp[u][0] = sum;
dp[u][1] = val[u] + sum;
}
}
void solve() {
int u;
clear();
for (int i = (1); i <= (n); ++i) {
scanf("%d%d", &u, &val[i]);
if (~u) addedge(u, i);
}
dfs(1);
printf("%I64d\n", max(dp[1][0], dp[1][1]));
}
int main() {
while (~scanf("%d", &n)) solve();
return 0;
}
| 2,000 | CPP |
t = int(input())
for q in range(t):
n = int(input())
a = [int(i) for i in input().split()]
a.sort()
k1 = a[n - 1]
k2 = a[n - 2]
print(min(a[n - 2] - 1, n - 2)) | 900 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using vi = std::vector<int>;
using vvi = std::vector<vi>;
template <class C>
C& reuniq(C& c) {
c.erase(std::unique((c).begin(), (c).end()), c.end());
return c;
}
template <class C, class X>
int lowpos(const C& c, const X& x) {
return int(std::lower_bound((c).begin(), (c).end(), x) - c.begin());
}
template <class X, class Y>
X& remax(X& x, const Y& y) {
return x = (x < y ? y : x);
}
struct Pair {
int x, y;
};
const int INF = (int)1e9 + 7;
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int n, last, k;
std::cin >> n >> last >> k;
std::vector<Pair> queries(n);
vi coord{0, 1, last};
for (auto& q : queries) {
std::cin >> q.x >> q.y;
coord.insert(coord.end(), {q.x - 1, q.x, q.x + 1, q.y - 1, q.y, q.y + 1});
}
std::sort((coord).begin(), (coord).end());
reuniq(coord);
vvi open((int)(coord).size()), close((int)(coord).size());
for (int i = 0; i < n; i++) {
auto& q = queries[i];
q.x = lowpos(coord, q.x);
q.y = lowpos(coord, q.y);
open[q.x].push_back(i);
close[q.y].push_back(i);
}
vi currStack(k, -1), prevStack;
auto openSegments = [&](int i) {
int p = 0;
for (int id : open[i]) {
while (p < k && currStack[p] != -1) p++;
assert(p < k);
currStack[p] = id;
}
};
auto closeSegments = [&](int i) {
for (int id : close[i]) {
bool was = 0;
for (int j = 0; j < k; j++) {
if (currStack[j] == id) {
was = 1;
currStack[j] = -1;
break;
}
}
assert(was);
}
};
vi dp(1 << k, -INF), max(1 << k, -INF);
dp[0] = 0;
for (int i = 1; i < (int)(coord).size(); i++) {
std::cerr && false && std::cerr << "-------------------" << std::endl;
prevStack = currStack;
openSegments(i);
const int cnt = coord[i] - coord[i - 1];
int prevFilter = 0, currFilter = 0;
for (int bit = 0; bit < k; bit++) {
if (prevStack[bit] == currStack[bit] && prevStack[bit] != -1) {
prevFilter |= (1 << bit);
}
if (currStack[bit] != -1) {
currFilter |= (1 << bit);
}
}
std::cerr && false &&
std::cerr << "i = " << i << ", coord = " << coord[i]
<< ", cnt = " << cnt << std::endl;
std::cerr && false && std::cerr << "prevStack:";
for (int j = k - 1; j >= 0; j--) {
std::cerr && false && std::cerr << std::setw(4) << prevStack[j];
}
std::cerr && false && std::cerr << std::endl;
std::cerr && false && std::cerr << "currStack:";
for (int j = k - 1; j >= 0; j--) {
std::cerr && false && std::cerr << std::setw(4) << currStack[j];
}
std::cerr && false && std::cerr << std::endl;
std::cerr && false && std::cerr << "prevFilter = ";
for (int j = k - 1; j >= 0; j--) {
std::cerr && false &&
std::cerr << std::setw(4) << ((prevFilter >> j) & 1);
}
std::cerr && false && std::cerr << std::endl;
std::cerr && false && std::cerr << "currFilter = ";
for (int j = k - 1; j >= 0; j--) {
std::cerr && false &&
std::cerr << std::setw(4) << ((currFilter >> j) & 1);
}
std::cerr && false && std::cerr << std::endl;
for (int mask = 0; mask < (1 << k); mask++) {
std::cerr && false && std::cerr << "dp[";
for (int j = k - 1; j >= 0; j--)
std::cerr && false && std::cerr << ((mask >> j) & 1);
std::cerr && false && std::cerr << "]" << dp[mask] << std::endl;
}
std::fill((max).begin(), (max).end(), -INF);
for (int mask = 0; mask < (1 << k); mask++) {
remax(max[mask & prevFilter], dp[mask]);
}
for (int mask = 0; mask < (1 << k); mask++) {
std::cerr && false && std::cerr << "mx[";
for (int j = k - 1; j >= 0; j--)
std::cerr && false && std::cerr << ((mask >> j) & 1);
std::cerr && false && std::cerr << "]" << max[mask] << std::endl;
}
for (int mask = 0; mask < (1 << k); mask++) {
dp[currFilter & mask] =
__builtin_parity(currFilter & mask) * cnt + max[mask & prevFilter];
}
for (int mask = 0; mask < (1 << k); mask++) {
std::cerr && false && std::cerr << "dp[";
for (int j = k - 1; j >= 0; j--)
std::cerr && false && std::cerr << ((mask >> j) & 1);
std::cerr && false && std::cerr << "]" << dp[mask] << std::endl;
}
closeSegments(i);
}
std::cout << *std::max_element((dp).begin(), (dp).end()) << std::endl;
return 0;
}
| 2,500 | CPP |
t = int(input())
for _ in range(t):
x, y = map(int, input().split())
a, b = map(int, input().split())
if x == y == 0:
print(0)
else:
output = 0
if a*2 > b:
output = min(x, y)*b + abs(x-y)*a
else:
output = (x+y) * a
print(output) | 1,000 | PYTHON3 |
t=int(input())
while t:
t=t-1
s=input()
p=''
if '1' not in s:
print(s)
elif '0' not in s:
print(s)
else:
for w in range(len(s)-1):
if s[w]!=s[w+1]:
p+=s[w]
else:
p+=s[w]
if s[w]=='0':
p+='1'
else:
p+='0'
p+=s[-1]
print(p)
| 1,100 | PYTHON3 |
from sys import stdin, stdout
from collections import Counter
import math
def rsingle_int():
return int(stdin.readline().rstrip())
def rmult_int():
return [ int(x) for x in stdin.readline().rstrip().split() ]
def rmult_str():
return stdin.readline().rstrip().split()
def r_str():
return stdin.readline().rstrip()
def rsingle_char():
return stdin.read(1)
def sortFirst(val):
return val[0]
def main():
n, k = rmult_int()
a = rmult_int()
cnts = {}
a.sort()
for el in a:
cnt = 0
while el != 0:
if el not in cnts:
cnts[el] = []
cnts[el].append(cnt)
el = int(math.floor(el / 2))
cnt += 1
if el not in cnts:
cnts[el] = []
cnts[el].append(cnt)
min_cost = float(math.inf)
for el in cnts.keys():
arr = cnts[el]
if len(arr) >= k:
sum_ = 0
for i in range(k):
sum_ += arr[i]
if sum_ < min_cost:
min_cost = sum_
print(min_cost)
main() | 2,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int val[300000 + 100], sum[300000 + 100][2], head[300000 + 100];
int f[300000 + 100];
vector<int> V[300000 + 100];
int n, k;
int ans;
int findd(int x) {
if (f[x] == x) return x;
int F = f[x];
f[x] = findd(f[x]);
val[x] = val[x] ^ val[F];
return f[x];
}
char s[300000 + 100];
void init() {
for (int i = 0; i <= max(n, k); i++) f[i] = i;
for (int i = 1; i <= max(n, k); i++) {
sum[i][0] = 0;
sum[i][1] = 1;
}
memset(head, -1, sizeof(head));
}
int get(int x) {
if (head[x] == -1) return min(sum[x][0], sum[x][1]);
return sum[x][head[x]];
}
void build(int x, int y, int v) {
int X = findd(x);
int Y = findd(y);
if (X != Y) {
ans -= get(X);
ans -= get(Y);
sum[Y][0] += sum[X][v ^ val[x] ^ val[y]];
sum[Y][1] += sum[X][1 ^ v ^ val[x] ^ val[y]];
if (head[X] != -1 && head[Y] == -1) {
head[Y] = v ^ val[x] ^ val[y] ^ head[X];
}
val[X] = val[x] ^ val[y] ^ v;
f[X] = Y;
ans += get(Y);
}
}
void work(int x, int v) {
int X = findd(x);
ans -= get(X);
if (head[X] == -1) head[X] = v ^ val[x];
ans += get(X);
}
int main() {
int T;
cin >> n >> k;
scanf("%s", s + 1);
for (int i = 1; i <= k; i++) {
scanf("%d", &T);
int cpy = T;
int x;
while (T--) {
scanf("%d", &x);
V[x].push_back(i);
}
}
init();
for (int i = 1; i <= n; i++) {
if (V[i].size() == 1) {
work(V[i][0], 1 ^ (s[i] - '0'));
} else if (V[i].size() == 2) {
build(V[i][0], V[i][1], 1 ^ (s[i] - '0'));
}
printf("%d\n", ans);
}
}
| 2,400 | CPP |
x=input()
a=int(x)
y=input()
r="EASY"
for i in range(len(y.split(" "))):
if int(y.split(" ")[i])==1:
r="HARD"
break
print(r)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
vector<int> G[200000 + 5];
int n, oe[200000 + 5], tsiz[200000 + 5];
void DFS(int u, int fa) {
tsiz[u] = 1;
int siz = G[u].size();
for (int i = 0; i < siz; i++) {
int v = G[u][i];
if (v == fa) continue;
oe[v] = !oe[u];
DFS(v, u);
tsiz[u] += tsiz[v];
}
return;
}
int main() {
n = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
G[u].push_back(v), G[v].push_back(u);
}
DFS(1, 0);
long long ans = 0, cnt = 0;
for (int i = 1; i <= n; i++) {
if (oe[i]) cnt++;
ans += 1ll * tsiz[i] * (n - tsiz[i]);
}
ans += cnt * (n - cnt);
printf("%lld\n", ans / 2);
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y;
vector<pair<int, int> > adj[1010], adj2[1010];
long long d[1010][1010], d2[1010];
set<pair<long long, int> > st;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> x >> y;
for (int i = 0; i < m; i++) {
int v, u, w;
cin >> v >> u >> w;
adj[v].push_back({u, w});
adj[u].push_back({v, w});
}
for (int r = 1; r <= n; r++) {
for (int i = 1; i <= n; i++) d[r][i] = -1;
d[r][r] = 0;
st.insert({0, r});
while (st.size()) {
int v = st.begin()->second;
st.erase(st.begin());
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i].first;
long long w = adj[v][i].second;
if (d[r][u] == -1 || d[r][u] > d[r][v] + w) {
st.erase({d[r][u], u});
d[r][u] = d[r][v] + w;
st.insert({d[r][u], u});
}
}
}
}
for (int v = 1; v <= n; v++) {
int t, c;
cin >> t >> c;
for (int u = 1; u <= n; u++)
if (d[v][u] != -1 && d[v][u] <= t) adj2[v].push_back({u, c});
}
for (int i = 1; i <= n; i++) d2[i] = -1;
d2[x] = 0;
st.insert({0, x});
while (st.size()) {
int v = st.begin()->second;
st.erase(st.begin());
for (int i = 0; i < adj2[v].size(); i++) {
int u = adj2[v][i].first;
long long w = adj2[v][i].second;
if (d2[u] == -1 || d2[u] > d2[v] + w) {
st.erase({d2[u], u});
d2[u] = d2[v] + w;
st.insert({d2[u], u});
}
}
}
cout << d2[y] << '\n';
return 0;
}
| 1,900 | CPP |
'''
INPUT SHORTCUTS
N, K = map(int,input().split())
N ,A,B = map(int,input().split())
string = str(input())
arr = list(map(int,input().split()))
N = int(input())
'''
def main():
string =str(input())
if len(string)<=2:
print(string)
return
cnt = 1
for i in range(len(string)-1):
if string[i]==string[i+1]:
cnt+=1
if cnt==len(string):
# print("same")
print(string)
return
cntone = 0
cntzero = 0
indexone = 10000
indexzero = 10000
for i in range(len(string)):
if string[i]=='0':
indexzero = min(indexzero,i)
cntzero+=1
else:
indexone = min(indexone,i)
cntone +=1
res = ''
if indexone>indexzero:
string2 = '01'
else:
string2 = '10'
for _ in range(cntzero+cntone):
res += string2
print(res)
return
n = int(input())
while n:
main()
n-=1 | 1,100 | PYTHON3 |
n=int(input())
unis=[]
ans=0
for i in range(n):
unis.append([])
x,y=map(int,input().split())
unis[i].append(x)
unis[i].append(y)
for i in range(n):
for j in range(n):
if unis[i][0]==unis[j][1]:
ans+=1
print(ans)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
const int N = 2007, M = 65537;
using std::pair;
using pi = pair<int, int>;
int a[16], c[16], low[M], n, k, U, s;
std::bitset<N> f[M];
std::priority_queue<pi> q;
int read() {
int x;
scanf("%d", &x);
return x;
}
void dfs(int st, int x) {
if (!st) return;
for (; x * k <= s && f[st][x * k]; x *= k)
for (int i = 0; i < n; ++i)
if (st >> i & 1) ++c[i];
for (int i = 0; i < n; ++i)
if (st >> i & 1 && x >= a[i] && f[st ^ 1 << i][x - a[i]])
return dfs(st ^ 1 << i, x - a[i]);
}
int main() {
n = read(), k = read(), U = (1 << n) - 1, f[0][0] = 1;
for (int i = 0; i < n; ++i) s += (a[i] = read()), low[1 << i] = i;
for (int i = 1; i <= U; ++i) low[i] = low[i & -i];
for (int i = 1; i <= U; ++i) {
for (int j = 0; j < n; ++j)
if (i >> j & 1) f[i] |= f[i ^ 1 << j] << a[j];
for (int j = s / k; j; --j)
if (f[i][j * k]) f[i][j] = 1;
}
if (!f[U][1]) return puts("NO"), 0;
puts("YES"), dfs(U, 1);
for (int i = 0; i < n; ++i) q.push({c[i], a[i]});
for (pi u, v; q.size() > 1;) {
u = q.top(), q.pop(), v = q.top(), q.pop(),
printf("%d %d\n", u.second, v.second), u.second += v.second;
while (!(u.second % k)) u.second /= k, --u.first;
q.push(u);
}
}
| 3,100 | CPP |
t = int(input())
for _ in range(t):
n = int(input())
temp = 3
while temp<=n:
if n%temp==0:
print(n//temp)
break
temp+=1
temp*=2
temp-=1
| 900 | PYTHON3 |
d={}
f={}
p={}
n= int(input())
for i in range(n):
l=input()
f[l[0]]=1
t=0
for x in range(len(l)-1,-1,-1):
if l[x] in d:
d[l[x]]+=10**t
else:
d[l[x]]=10**t
t+=1
y=list(d.items())
l=y[:]
y.sort(reverse=True,key=lambda x :x[1])
for (a,b) in y:
if a not in f:
p[a]='0'
y.remove((a,b))
break
t='123456789'
q=0
for (a,b) in y:
p[a]=t[q]
q+=1
def f(m):
return p[m]
qa=[]
for (a,b) in l:
w=int(f(a))*b
qa.append(w)
print(sum(qa)) | 1,700 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
pair<int, int> a[300010];
int main() {
while (scanf("%d%d", &n, &k) != EOF) {
for (int i = 1; i <= n; ++i) scanf("%d%d", &a[i].first, &a[i].second);
sort(a + 1, a + 1 + n, [](pair<int, int> a, pair<int, int> b) {
return a.second > b.second;
});
priority_queue<int, vector<int>, greater<int> > pq;
long long len = 0;
long long res = 0;
for (int i = 1; i <= n; ++i) {
len += a[i].first;
pq.push(a[i].first);
if ((int)pq.size() > k) {
len -= pq.top();
pq.pop();
}
res = max(res, len * a[i].second);
}
printf("%lld\n", res);
}
return 0;
}
| 1,600 | CPP |
for i in range(int(input())):
n,m = map(int,input().split())
l = list(map(int,input().split()))
if(sum(l) == m):
print("YES")
else:
print("NO") | 800 | PYTHON3 |
read = input().split()
n = int(read[0])
k = int(read[1])
d = [0] * k
sol = 0
for i in range(n):
hlp = int(input()) - 1
d[hlp] += 1
if (d[hlp] == 2):
d[hlp] -= 2
sol += 2
n -= 2
for i in range(k):
if (d[i]):
d[i] -= 1
sol += 1
n -= 2
if (n <= 0):
break
print(sol) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, y, h, ym;
int v[302][302];
double s[302];
int D = 4000;
inline int quickMax(int a, int b) { return a > b ? a : b; }
int main() {
cin >> n >> k;
for (int i = 0, _n = (n); i < _n; i++)
for (int j = 0, _n = (k + 1); j < _n; j++) cin >> v[i][j];
for (int x = 0, _n = (k); x < _n; x++) {
for (int d = 0, _n = (D + 1); d < _n; d++) {
ym = 0;
for (int i = 0, _n = (n); i < _n; i++) {
y = v[i][x] * (D - d) + v[i][x + 1] * d;
h = quickMax(0, y - ym);
ym = quickMax(ym, y);
s[i] += h;
if (d != 0 && d != D) s[i] += h;
}
}
}
for (int i = 0, _n = (n); i < _n; i++) cout << s[i] / D / 2 / D << endl;
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
unordered_map<int, string> m;
m[1] = "January";
m[2] = "February";
m[3] = "March";
m[4] = "April";
m[5] = "May";
m[6] = "June";
m[7] = "July";
m[8] = "August";
m[9] = "September";
m[10] = "October";
m[11] = "November";
m[12] = "December";
int n;
cin >> n;
if (s == "January") {
n++;
}
if (s == "February") {
n += 2;
}
if (s == "March") {
n += 3;
}
if (s == "April") {
n += 4;
}
if (s == "May") {
n += 5;
}
if (s == "June") {
n += 6;
}
if (s == "July") {
n += 7;
}
if (s == "August") {
n += 8;
}
if (s == "September") {
n += 9;
}
if (s == "October") {
n += 10;
}
if (s == "November") {
n += 11;
}
if (s == "December") {
n += 12;
}
int j = n % 12;
if (j == 0) {
j = 12;
}
cout << m[j] << endl;
}
| 900 | CPP |
import time,math,bisect,sys
from sys import stdin,stdout
from collections import deque
from fractions import Fraction
from collections import Counter
from collections import OrderedDict
pi=3.14159265358979323846264338327950
def II(): # to take integer input
return int(stdin.readline())
def IO(): # to take string input
return stdin.readline()
def IP(): # to take tuple as input
return map(int,stdin.readline().split())
def L(): # to take list as input
return list(map(int,stdin.readline().split()))
def P(x): # to print integer,list,string etc..
return stdout.write(str(x))
def PI(x,y): # to print tuple separatedly
return stdout.write(str(x)+" "+str(y)+"\n")
def lcm(a,b): # to calculate lcm
return (a*b)//gcd(a,b)
def gcd(a,b): # to calculate gcd
if a==0:
return b
elif b==0:
return a
if a>b:
return gcd(a%b,b)
else:
return gcd(a,b%a)
def readTree(): # to read tree
v=int(input())
adj=[set() for i in range(v+1)]
for i in range(v-1):
u1,u2=In()
adj[u1].add(u2)
adj[u2].add(u1)
return adj,v
def bfs(adj,v): # a schema of bfs
visited=[False]*(v+1)
q=deque()
while q:
pass
def sieve():
li=[True]*1000001
li[0],li[1]=False,False
for i in range(2,len(li),1):
if li[i]==True:
for j in range(i*i,len(li),i):
li[j]=False
prime=[]
for i in range(1000001):
if li[i]==True:
prime.append(i)
return prime
def setBit(n):
count=0
while n!=0:
n=n&(n-1)
count+=1
return count
#####################################################################################
def solve():
a,b,n=IP()
x,y=max(a,b),min(a,b)
mov=0
while x<=n:
y+=x
x,y=max(x,y),min(x,y)
mov+=1
print(mov)
t=II()
for i in range(t):
solve()
#######
#
#
####### # # # #### # # #
# # # # # # # # # # #
# #### # # #### #### # #
###### # # #### # # # # # | 800 | PYTHON3 |
try:
for _ in range(int(input())):
n=int(input())
caa=bin(n).replace('0b',"")
caa=caa.count("1")
print(2*n-caa)
except:
pass
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int BASE = 1000000;
const int N = 1000050;
int need[N][10], cost[N][10];
long long n;
int cal(int x) {
int ret = 0;
while (x) ret = max(ret, x % 10), x /= 10;
return ret;
}
int main() {
for (int i = 1; i <= BASE; i++)
for (int j = 0; j < 10; j++) {
int m = max(cal(i), j);
if (i < m)
need[i][j] = 1, cost[i][j] = m;
else
need[i][j] = need[i - m][j] + 1, cost[i][j] = cost[i - m][j] + m;
}
cin >> n;
long long ans = 0;
while (n > BASE) {
int ret = cal(n / BASE);
if (n % BASE == 0)
n -= ret, ans++;
else
ans += need[n % BASE][ret], n -= cost[n % BASE][ret];
}
if (n) ans += need[n][0];
cout << ans << endl;
return 0;
}
| 2,400 | CPP |
# input :
# 0<T<1000 then read T times l,r
# l <= x
# y <= r
# y%x=0
t = int(input())
result = []
for i in range(t):
line = (input()).split()
l = int(line[0])
r = int(line[1])
if l == r:
result.append([l, r])
else:
result.append([l, l*2])
# while r >= l:
# brah = False
# poty = r
# for potx in range(l, r):
# if poty % potx == 0:
# result.append([potx, poty])
# brah = True
# break
# r -= 1
# if brah:
# break
for out in result:
print('%d %d' % (out[0], out[1]))
| 800 | PYTHON3 |
"""
import sys
sys.stdin = open('test.inp', 'r')
sys.stdout = open('test.out', 'w')
"""
def sol():
n=int(input())
L=list(map(int,input().split()))
L=[0]+L
sum=0
for i in range(1,n+1):
sum=sum+L[i]
if (sum*2) % (n*(n+1)) != 0:
print("NO")
return
sum=sum*2//(n*(n+1))
res=[]
cc=L[1]-L[n]
cc=sum-cc
if(cc<=0 or cc%n != 0):
print("NO")
return
res.append(cc//n)
for i in range(2,n+1):
cc=L[i]-L[i-1]
cc=sum-cc
if(cc<=0 or cc%n != 0):
print("NO")
return
res.append(cc//n)
print("YES")
for i in res:
print(i,end=" ")
print("")
Test=int(input())
for i in range(1,Test+1):
sol() | 1,700 | PYTHON3 |
from bisect import bisect_right as br
from bisect import bisect_left as bl
from collections import defaultdict
from itertools import combinations
import functools
import sys
import math
MAX = sys.maxsize
MAXN = 10**6+10
MOD = 10**9+7
def isprime(n):
n = abs(int(n))
if n < 2:
return False
if n == 2:
return True
if not n & 1:
return False
for x in range(3, int(n**0.5) + 1, 2):
if n % x == 0:
return False
return True
def mhd(a,b,x,y):
return abs(a-x)+abs(b-y)
def numIN():
return(map(int,sys.stdin.readline().strip().split()))
def charIN():
return(sys.stdin.readline().strip().split())
def chk(x):
print('Hello',x)
def ncr(n,k):
res = 1
c = [0]*(k+1)
c[0]=1
for i in range(1,n+1):
for j in range(min(i,k),0,-1):
c[j] = (c[j]+c[j-1])%MOD
return c[k]
n,k,m = numIN()
l = [0]+list(numIN())
l.sort()
s = sum(l)
mx = -1
for i in range(min(n,m+1)):
s-=l[i]
x = s+min(m-i,k*(n-i))
mx = max(mx,x/(n-i))
print(mx)
| 1,700 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, a[100005];
long long sum[100005];
bool ok(long long x) {
for (int i = 0; i < n; ++i) sum[i] = 0;
long long needed = 0;
for (int i = 0; i < n; ++i) {
long long val = x - a[i];
if (val > 0) {
val -= sum[i];
if (val > 0) {
needed += val;
sum[i] += val;
if (i + k < n) sum[i + k] -= val;
}
}
sum[i + 1] += sum[i];
if (needed > m) return false;
}
return true;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
long long le = 0, ri = 2000000000;
while (le + 1 < ri) {
long long mid = (le + ri) >> 1;
if (ok(mid))
le = mid;
else
ri = mid;
}
cout << le << endl;
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
int a[N];
int main() {
string s;
int i, j, k, n, l;
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
cin >> s;
int ans = 0;
for (j = 'a'; j <= 'z'; ++j) {
int ct = 0, tk = 0;
for (i = 0; i < s.size(); ++i)
if (s[i] != j)
tk = 0;
else {
++tk;
ct += tk / k;
tk %= k;
}
ans = max(ans, ct);
}
cout << ans;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, V = 0, K = 0, X = 0, cv[100], ck[100], cx[100], pv[100], pk[100],
px[100], f[100][100][100][2];
int MAX(int pos, int v, int k, int x) {
return max(v - cv[pos], 0) + max(k - ck[pos], 0) + max(x - cx[pos], 0);
}
int main() {
cin >> n;
char c;
for (int i = 1; i <= n; i++) {
cin >> c;
cv[i] = cv[i - 1];
ck[i] = ck[i - 1];
cx[i] = cx[i - 1];
if (c == 'V') {
cv[i]++;
pv[++V] = i;
} else if (c == 'K') {
ck[i]++;
pk[++K] = i;
} else {
cx[i]++;
px[++X] = i;
}
}
for (int v = 0; v <= V; v++)
for (int k = 0; k <= K; k++)
for (int x = 0; x <= X; x++) {
f[v][k][x][0] = 1e9;
f[v][k][x][1] = 1e9;
}
f[0][0][0][0] = 0;
for (int v = 0; v <= V; v++)
for (int k = 0; k <= K; k++)
for (int x = 0; x <= X; x++) {
if (v > 0)
f[v][k][x][1] =
min(f[v][k][x][1],
min(f[v - 1][k][x][0], f[v - 1][k][x][1]) +
abs(v + k + x - pv[v] - MAX(pv[v], v - 1, k, x)));
if (k > 0)
f[v][k][x][0] = min(f[v][k][x][0],
f[v][k - 1][x][0] + abs(v + k + x - pk[k] -
MAX(pk[k], v, k - 1, x)));
if (x > 0)
f[v][k][x][0] =
min(f[v][k][x][0],
min(f[v][k][x - 1][0], f[v][k][x - 1][1]) +
abs(v + k + x - px[x] - MAX(px[x], v, k, x - 1)));
}
cout << min(f[V][K][X][0], f[V][K][X][1]);
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, i, ans;
int main() {
char a[500000];
cin >> n;
cin >> a;
while (i < n && a[i] == '<') ans++, i++;
while (n-- && a[n] == '>') ans++;
cout << ans;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
int main() {
int n, i = 0, s = 0, s1 = 0;
scanf("%d", &n);
int a[n], a1[n];
while (i != n) {
scanf("%d", &a[i]);
s += a[i];
i++;
}
i = 0;
while (i != n) {
scanf("%d", &a1[i]);
s1 += a1[i];
i++;
}
if (s1 > s)
printf("NO\n");
else
printf("YES\n");
return 0;
}
| 800 | CPP |
n, k= map(int,input().split())
ids = input().split()
mess = [0] * k
for i in ids:
if i not in mess:
mess.append(i)
mess.pop(0)
kk=k-mess.count(0)
print(kk)
mess.reverse()
print(' '.join(mess[:kk])) | 1,000 | PYTHON3 |
n = int(input())
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
indices = [0] * n
for i, x in enumerate(b):
indices[x-1] = i
offsets = [0] * n
for i in range(n):
offsets[(indices[a[i]-1] - i) % n] += 1
print(max(offsets)) | 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100010];
double dp[100010], tot = 0.0, sum = 0.0, C[100010], Cn[100010];
void update(int x, double v) {
for (register int i = x; i <= n; i += (i & (-i))) C[i] += v;
}
double query(int x) {
double res = 0.0;
for (register int i = x; i; i -= (i & (-i))) res += C[i];
return res;
}
void UPDATE(int x, double v) {
for (register int i = x; i <= n; i += (i & (-i))) Cn[i] += v;
}
double QUERY(int x) {
double res = 0.0;
for (register int i = x; i; i -= (i & (-i))) res += Cn[i];
return res;
}
int main() {
scanf("%d", &n);
for (register int i = 1; i <= n; ++i) scanf("%d", &a[i]);
dp[1] = 0.0;
for (register int i = 2; i <= n; ++i)
dp[i] = dp[i - 1] + (1.0 * i - 1.0) / 2.0;
for (register int i = n; i >= 1; --i) {
tot += QUERY(a[i] - 1);
UPDATE(a[i], 1.0);
sum += i * query(a[i] - 1);
update(a[i], n * 1.0 - i * 1.0 + 1.0);
}
sum /= (n * 1.0 * (n * 1.0 + 1.0) / 2.0);
tot -= sum;
for (register int i = 2; i <= n; ++i)
tot +=
dp[i] * (n * 1.0 - i * 1.0 + 1.0) / (n * 1.0 * (n * 1.0 + 1.0) / 2.0);
printf("%.15f\n", tot + (1e-15));
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
inline int read() {
char c, _c;
int x;
for (c = _c = getchar(); !isdigit(c); c = getchar()) {
_c = c;
}
for (x = 0; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
return _c == '-' ? -x : x;
}
const int mod = 1e9 + 7;
inline int add(int x, int y) { return x + y >= mod ? x + y - mod : x + y; }
const int N = 1e5 + 5;
struct Edge {
int v, p, q, i;
};
int n, m, ans[2], deg[N], sgn[N], f[2][2][2], g[2][2][2];
bool vis[N];
std::vector<Edge> e[N];
inline void update(int res0, int res1) {
int ans0 = ans[0], ans1 = ans[1];
ans[0] = (1ll * ans0 * res0 + 1ll * ans1 * res1) % mod;
ans[1] = (1ll * ans0 * res1 + 1ll * ans1 * res0) % mod;
}
void solve(int s) {
int res[2] = {0, 0};
memset(f, 0, sizeof(f));
for (int x = 0; x < 2; x++) {
f[sgn[s] == -1 || deg[s] == 1 ? 0 : sgn[s] ^ x][x][x] = 1;
}
for (int u = s, v, w = -1;; u = v) {
memcpy(g, f, sizeof(g));
memset(f, 0, sizeof(f));
vis[u] = true;
Edge e = (Edge){0, 0, 0, -1};
for (auto i : ::e[u]) {
if (i.i != w) {
e = i;
break;
}
}
v = e.v;
w = e.i;
if (w == -1) {
for (int z = 0; z < 2; z++) {
for (int x0 = 0; x0 < 2; x0++) {
for (int y = 0; y < 2; y++) {
int zz = z ^ (sgn[u] == -1 ? 0 : sgn[u] ^ y);
res[zz] = add(res[zz], g[z][x0][y]);
}
}
}
break;
}
if (v == s) {
for (int z = 0; z < 2; z++) {
for (int x0 = 0; x0 < 2; x0++) {
for (int y = 0; y < 2; y++) {
int zz = z ^ ((y ^ e.p) | (x0 ^ e.q));
res[zz] = add(res[zz], g[z][x0][y]);
}
}
}
break;
}
for (int z = 0; z < 2; z++) {
for (int x0 = 0; x0 < 2; x0++) {
for (int y = 0; y < 2; y++) {
for (int x = 0; x < 2; x++) {
int zz = z ^ ((y ^ e.p) | (x ^ e.q));
f[zz][x0][x] = add(f[zz][x0][x], g[z][x0][y]);
}
}
}
}
}
update(res[0], res[1]);
}
int main() {
m = read();
n = read();
ans[0] = 1;
for (int u = 1; u <= n; u++) {
sgn[u] = -1;
}
for (int i = 0; i < m; i++) {
int k = read();
if (k == 1) {
int u = read(), p;
p = u < 0;
u = std::abs(u);
deg[u]++;
if (sgn[u] == -1) {
sgn[u] = p;
} else {
vis[u] = true;
if (sgn[u] == p) {
update(2, 0);
} else {
update(0, 2);
}
}
} else {
int u = read(), v = read(), p, q;
p = u < 0;
u = std::abs(u);
q = v < 0;
v = std::abs(v);
deg[u]++;
deg[v]++;
e[u].push_back((Edge){v, p, q, i});
e[v].push_back((Edge){u, q, p, i});
}
}
for (int u = 1; u <= n; u++) {
if (vis[u]) {
continue;
}
if (deg[u] == 2 && sgn[u] == -1) {
continue;
}
solve(u);
}
for (int u = 1; u <= n; u++) {
if (vis[u]) {
continue;
}
solve(u);
}
printf("%d\n", ans[1]);
return 0;
}
| 2,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-ffloat-store")
#pragma GCC optimize("-fno-defer-pop")
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int t = power(a, b / 2, m) % m;
t = (t * t) % m;
if (b & 1) t = ((t % m) * (a % m)) % m;
return t;
}
long long int modInverse(long long int a, long long int m) {
return power(a, m - 2, m);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long int i, j, k, l, n, p;
cin >> n >> p >> k;
long long int ar[n + 1];
for (i = 1; i <= n; i++) {
cin >> ar[i];
}
sort(ar + 1, ar + n + 1);
long long int a, b, mid, an = 0;
a = 1;
b = n;
while (b >= a) {
mid = (a + b) / 2;
long long int cur = 0;
for (i = mid; i >= 1; i -= k) {
cur += ar[i];
}
if (cur <= p) {
an = mid;
a = mid + 1;
} else
b = mid - 1;
}
cout << an << "\n";
}
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long seg[4000006], lazy[4000006];
bool lz[4000006];
void propagate(long long n) {
lz[n * 2] = lz[n * 2 + 1] = 1;
lazy[n * 2] += lazy[n];
seg[n * 2] += lazy[n];
lazy[n * 2 + 1] += lazy[n];
seg[n * 2 + 1] += lazy[n];
lz[n] = lazy[n] = 0;
return;
}
void update(long long n, long long s, long long e, long long l, long long r,
long long val) {
if (s >= l && e <= r) {
lz[n] = 1;
lazy[n] += val;
seg[n] += val;
return;
}
if (s > r || e < l) return;
if (lz[n]) propagate(n);
long long mid = (s + e) >> 1;
update(n * 2, s, mid, l, r, val);
update(n * 2 + 1, mid + 1, e, l, r, val);
seg[n] = max(seg[n * 2], seg[n * 2 + 1]);
return;
}
void upd(long long n, long long s, long long e, long long indx, long long val) {
if (s == indx && e == indx) {
seg[n] = val;
return;
}
if (s > indx || e < indx) return;
long long mid = (s + e) >> 1;
upd(n * 2, s, mid, indx, val);
upd(n * 2 + 1, mid + 1, e, indx, val);
seg[n] = max(seg[n * 2], seg[n * 2 + 1]);
return;
}
vector<pair<pair<long long, long long>, long long> > vec;
vector<pair<long long, long long> > temp;
int main() {
long long n, m, k, x, y, z, res = -1000000000000000ll;
scanf("%lld %lld %lld", &n, &m, &k);
for (long long i = 0; i < n; i++)
scanf("%lld %lld", &x, &y), vec.push_back({{x, -1}, y});
for (long long i = 1; i <= 1000001; i++)
upd(1, 1, 1000001, i, -1000000000000000ll);
for (long long i = 0; i < m; i++)
scanf("%lld %lld", &x, &y), temp.push_back({x, y});
sort(temp.begin(), temp.end());
for (int i = m - 1; i >= 0; i--)
upd(1, 1, 1000001, temp[i].first, -temp[i].second);
for (long long i = 0; i < k; i++)
scanf("%lld %lld %lld", &x, &y, &z), vec.push_back({{x, y}, z});
sort(vec.begin(), vec.end());
for (long long i = 1, j = 0; i <= 1000001 && j < vec.size(); i++) {
while (j < vec.size() && vec[j].first.first == i &&
vec[j].first.second == -1)
res = max(res, -vec[j].second + seg[1]), j++;
while (j < vec.size() && vec[j].first.first == i &&
vec[j].first.second != -1)
update(1, 1, 1000001, vec[j].first.second + 1, 1000001, vec[j].second),
j++;
}
printf("%lld\n", res);
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long rd() {
long long x = 0;
bool neg = false;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') neg = true, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
if (neg) x = -x;
return x;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const long long N = 2e5;
long long n, m, k, q, b[N + 2], L[N + 2], R[N + 2], have[N + 2], val[N + 2];
pair<long long, long long> a[N + 2];
void input() {
n = rd();
m = rd();
k = rd();
q = rd();
for (long long _b = k, i = 1; i <= _b; ++i)
a[i].first = rd(), a[i].second = rd();
for (long long _b = q, i = 1; i <= _b; ++i) b[i] = rd();
}
vector<pair<long long, long long> > tmp;
long long tox(long long first, long long second, long long k) {
return abs(k - second) + abs(second - first);
}
long long toy(long long first, long long second, long long k) {
return abs(k - first) + abs(first - second);
}
void solve() {
sort(a + 1, a + k + 1);
for (long long _b = q, i = 1; i <= _b; ++i) L[b[i]] = b[i], R[b[i]] = b[i];
for (long long _b = m, i = 1; i <= _b; ++i)
if (!L[i]) L[i] = L[i - 1];
for (long long _b = 1, i = m; i >= _b; --i)
if (!R[i]) R[i] = R[i + 1];
tmp.push_back({1, 0});
if (a[1].first != 1) {
tmp.clear();
tmp.push_back({R[1], R[1] - 1 + a[1].first - 1});
}
long long l = 1;
while (l <= k) {
long long r = l;
while (r + 1 <= k && a[r + 1].first == a[l].first) ++r;
long long first = a[l].second;
long long second = a[r].second;
long long btx = 1e15, bty = 1e15;
for (auto c : tmp) {
btx = min(btx, c.second + tox(first, second, c.first));
bty = min(bty, c.second + toy(first, second, c.first));
}
if (r == k) {
cout << min(btx, bty);
exit(0);
}
tmp.clear();
if (L[first])
tmp.push_back({L[first], abs(L[first] - first) + btx + a[r + 1].first -
a[r].first});
if (R[first])
tmp.push_back({R[first], abs(R[first] - first) + btx + a[r + 1].first -
a[r].first});
if (L[second])
tmp.push_back({L[second], abs(L[second] - second) + bty + a[r + 1].first -
a[r].first});
if (R[second])
tmp.push_back({R[second], abs(R[second] - second) + bty + a[r + 1].first -
a[r].first});
l = r + 1;
}
exit(1);
}
int main() {
input();
solve();
return 0;
}
| 2,100 | CPP |
Subsets and Splits