solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
m=10**9+7
t = int(input())
while(t):
t-=1
n,k = map(int,input().split())
s=input()
p=[]
for i in range(n):
if s[i]=="1":
p.append(i)
if len(p)==0:
print(1+(n-1)//(k+1))
continue
ans=0
for i in range(1,len(p)):
ans += (p[i]-p[i-1])//(k+1)-1
ans += p[0]//(k+1) + (n-p[-1]-1)//(k+1)
print(ans) | 1,300 | PYTHON3 |
import sys
def main():
u = []
r = 0
x = []
q = []
n = int(sys.stdin.readline())
x = list(map(int, sys.stdin.readline().split()))
links = [[] for i in range(n)]
u = [False]*n
p = [0]*n
d = [False]*n
data = sys.stdin.readlines()
for i in range(n-1):
y = data[i].split()
v , c = int(y[0])-1, int(y[1])
links[i+1].append((v,c))
links[v].append((i+1,c))
u[0] = True
q.append((0,0,False))
while len(q)!=0:
z = q.pop()
i, path, al = z[0], z[1],z[2]
for y in links[i]:
j , c = y[0], y[1]
if not u[j] :
u[j] = True
#print("dfs", j, path, c)
al2 = al
np = max(path + c, c)
if np>x[j]:
al2 = True
if al2:
r+=1
#print(j , np , x[j], al2)
q.append((j, np, al2))
print(r)
main()
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
int arr[n][2];
int one = 0, two = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1];
if (arr[i][0] == 1)
one++;
else
two++;
}
int t = 0, w = 0;
int arr1[one + 1];
int arr2[two + 1];
arr1[0] = 0;
arr2[0] = 0;
int a = 1, b = 1;
for (int i = 0; i < n; i++) {
if (arr[i][0] == 1) {
arr1[a] = arr[i][1];
w += arr1[a];
a++;
} else {
arr2[b] = arr[i][1];
w += arr2[b];
b++;
}
}
std::sort(arr1, arr1 + one + 1);
std::sort(arr2, arr2 + two + 1);
while (w > t) {
if (one == 0) {
if (two > 0) {
w = w - arr2[two];
t = t + 2;
two = two - 1;
continue;
} else {
break;
}
}
if (two == 0) {
w = w - arr1[one];
t = t + 1;
one = one - 1;
continue;
}
if ((w - arr1[one]) <= (t + 1)) {
w = w - arr1[one];
t = t + 1;
break;
}
if ((w - arr2[two]) <= (t + 2)) {
w = w - arr2[two];
t = t + 2;
break;
}
if ((arr1[one] + arr1[one - 1]) >= (arr2[two])) {
w = w - arr1[one];
t = t + 1;
one = one - 1;
continue;
} else {
w = w - arr2[two];
t = t + 2;
two = two - 1;
continue;
}
}
cout << t << endl;
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<long long> b[60], ans;
int n, i, j;
long long now;
scanf("%d", &n);
for (i = 0; i < n; ++i) {
scanf("%lld", &now);
for (j = 59; j >= 0; --j)
if (1ll << j & now) {
b[j].push_back(now);
break;
}
}
now = 0;
for (i = 0; i < n; ++i) {
for (j = 0; j < 60; ++j)
if (1ll << j & ~now && !b[j].empty()) break;
if (j >= 60) break;
long long t(*b[j].rbegin());
now ^= t;
ans.push_back(t);
b[j].pop_back();
}
if (i < n)
printf("No\n");
else {
printf("Yes\n");
for (const auto &i : ans) printf("%lld ", i);
printf("\n");
}
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long n, a, b;
cin >> n >> a >> b;
int cnt = 0;
string tmp, s;
cin >> tmp;
s.push_back('0');
for (int i = 1; i < tmp.size(); ++i) {
if (tmp[i] == '0' && tmp[i - 1] == '1')
s += '1';
else
s += tmp[i];
if (tmp[i] == '1') cnt++;
}
s += '0';
if (cnt == 0) {
long long ans = (s.size() - 2) * (a + b) + b + b + a;
cout << ans << '\n';
continue;
}
long long ans = a + b + b;
int l = 1, r = s.size() - 2;
while (l < s.size() - 1 && s[l] == '0') {
ans += b + a;
l++;
}
while (r > 0 && s[r] == '0') {
ans += b + a;
r--;
}
ans += 2 * a;
while (l <= r) {
while (l <= r && s[l] == '1') ans += (2 * b + a), l++;
int ct = 0;
while (l <= r && s[l] == '0') ct++, l++;
long long u = ct * (2 * b + a);
long long d = ct * (a + b) + 2 * a;
ans += min(u, d);
}
cout << ans << '\n';
}
}
| 1,500 | CPP |
t = int(input())
while t :
k = 0
x = int(input())
lst = list(map(int, input().split()))
my_lst = [0] * (x)
for i, v in enumerate(lst):
a = v % x
my_lst[(i+a)%x] += 1
#print(my_lst)
for i in my_lst:
if i > 1:
k = 1
break
if k==1:
print("NO")
else:
print("YES")
t-=1
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long l, r, mod, aim = 1e18;
int main() {
scanf("%lld", &mod);
aim = 1e18;
;
;
;
;
l = mod - aim % mod * 9 % mod * 9 % mod;
r = l + aim - 1;
printf("%lld %lld", l, r);
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const long long LLINF = 9223372036854775807LL;
const int ST = 100010;
const int ST1 = 1000010;
bool myf(pair<int, int> i, pair<long long, int> j) {
if (i.first == j.first)
return (i.second < j.second);
else
return (i.first > j.first);
}
bool myf2(int i, int j) { return (i > j); }
int ABS(int a) {
if (a < 0)
return a * (-1);
else
return a;
}
int mas[10000100];
void gen() {
for (long long i = 1; i * i <= 10000000; i++) {
long long q = i * i;
for (long long j = 1; j * q <= 10000000; j++) {
mas[j * q] = j;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
long long a, n;
cin >> a >> n;
gen();
long long ans = 0;
;
for (int i = a; i < a + n; i++) ans += mas[i];
cout << ans;
}
| 1,500 | CPP |
inp = input()
outp = ''
iscap = True
for i in inp[1:]:
if i.upper() != i:
iscap = False
if iscap:
if inp[0].upper() != inp[0]:
outp+= inp[0].upper()
for i in inp[1:]:
outp+= i.lower()
else:
for i in inp:
outp+= i.lower()
else:
outp = inp
print (outp)
| 1,000 | PYTHON3 |
s1 = input().casefold()
s2 = input().casefold()
if(s1 == s2):
print("0")
for i in range(len(s1)):
if(s1[i] < s2[i]):
print("-1")
break
if(s1[i] > s2[i]):
print("1")
break
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using LD = long double;
const int N = 1e5 + 7, inf = 1e9 + 7, MOD = 998244353;
const long long INF = 2e18 + 7;
const int M = 1 << 17;
int dane[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, q;
cin >> n >> q;
for (int i = 0; i < n; ++i) {
cin >> dane[i];
}
while (q--) {
int l, r;
cin >> l >> r;
--l, --r;
int len = r - l;
vector<int> roznice;
roznice.reserve(len);
for (int i = l; i < r; ++i) {
roznice.push_back(abs(dane[i + 1] - dane[i]));
}
long long res = 0;
stack<pair<int, int> > kolejka;
for (int i = 0; i < roznice.size(); ++i) {
int ileGrup = 1;
while (kolejka.size() && kolejka.top().first <= roznice[i]) {
ileGrup += kolejka.top().second;
res -= (kolejka.top().second) * 1ll * (len - i) * kolejka.top().first;
kolejka.pop();
}
res += roznice[i] * 1ll * ileGrup * (len - i);
kolejka.push({roznice[i], ileGrup});
}
cout << res << '\n';
}
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int fen[100005];
int mod = 1000000007;
void upd(int n, int pos, int val) {
for (; pos <= n; pos |= (pos + 1)) {
fen[pos] += val;
if (fen[pos] >= mod) fen[pos] -= mod;
}
}
int fnd(int pos) {
int ret = 0;
for (; pos >= 0; pos = (pos & (pos + 1)) - 1) {
ret += fen[pos];
if (ret >= mod) ret -= mod;
}
return ret;
}
pair<int, int> v[100005];
pair<int, int> to[100005];
int main() {
int n, a;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a);
v[i] = make_pair(a, i);
}
sort(v, v + n);
int out = 0;
for (int i = 0; i < n;) {
int val = v[i].first, cnt = 0, mul = val;
int g = 0, last = -1;
while (i < n && v[i].first == val) {
g = (1LL * g * val + (fnd(v[i].second) - fnd(last))) % mod;
if (g < 0) g += mod;
int ans = (mul + 1LL * val * g) % mod;
out += ans;
if (out >= mod) out -= mod;
to[cnt++] = make_pair(v[i].second, ans);
last = v[i].second;
++i;
mul = (1LL * mul * val) % mod;
}
for (int j = 0; j < cnt; ++j) upd(n + 1, to[j].first, to[j].second);
}
printf("%d\n", out);
return 0;
}
| 2,000 | CPP |
a = list(input().split())
n = a[0]
k = int(a[1])
c = 0
f = 0
for x in range(-1, -len(n)-1, -1):
if n[x] == "0":
c = c + 1
if c == k:
print( -x-k )
f = 1
break
if f == 0:
print(len(n) - 1)
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool isvowel(char ch) {
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
return true;
return false;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
vector<string> v(n);
map<pair<long long int, char>, vector<string>> mp;
map<long long int, vector<string>> sp;
for (long long int i = 0; i < n; i++) cin >> v[i];
for (long long int i = 0; i < n; i++) {
long long int vw = 0;
long long int l = v[i].size();
for (long long int j = 0; j < l; j++) {
if (isvowel(v[i][j])) vw++;
}
char ch;
for (long long int j = l - 1; j >= 0; j--) {
if (isvowel(v[i][j])) {
ch = v[i][j];
break;
}
}
mp[{vw, ch}].push_back(v[i]);
}
vector<string> fw, sw;
long long int flag = 1;
for (auto it : mp) {
while (it.second.size() >= 2) {
string a = it.second[it.second.size() - 1];
sw.push_back(a);
it.second.pop_back();
string b = it.second[it.second.size() - 1];
sw.push_back(b);
it.second.pop_back();
}
if (it.second.size() > 0) {
sp[it.first.first].push_back(it.second[it.second.size() - 1]);
it.second.pop_back();
}
}
for (auto it : sp) {
while (it.second.size() >= 2) {
fw.push_back(it.second[it.second.size() - 1]);
it.second.pop_back();
fw.push_back(it.second[it.second.size() - 1]);
it.second.pop_back();
}
}
long long int as = fw.size();
long long int bs = sw.size();
long long int diff = bs - as;
if (diff > 0) {
while (sw.size() != fw.size()) {
fw.push_back(sw[sw.size() - 1]);
sw.pop_back();
}
as = bs = fw.size();
}
long long int mn = min(as, bs);
long long int words = mn / 2;
cout << words << "\n";
mn = 2 * words;
for (long long int i = 0; i < mn; i++) {
cout << fw[i] << " " << sw[i] << "\n";
}
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z, k, w, X, Y;
int A[15][2], B[15][2], ans;
int main() {
scanf("%d", &n);
scanf("%d", &x);
for (int i = (0); i < (x); i++) {
scanf("%d", &A[i][0]);
A[i][1] = i;
}
X = x;
scanf("%d", &y);
for (int i = (0); i < (y); i++) {
scanf("%d", &B[i][0]);
B[i][1] = i + x;
}
Y = y;
k = w = 0;
while (1) {
ans++;
if (A[k][0] > B[w][0]) {
if (x >= 10) x = 0;
A[x][0] = B[w][0];
A[x][1] = B[w][1];
x++;
if (x >= 10) x = 0;
A[x][0] = A[k][0];
A[x][1] = A[k][1];
x++;
X++;
Y--;
} else {
if (y >= 10) y = 0;
B[y][0] = A[k][0];
B[y][1] = A[k][1];
y++;
if (y >= 10) y = 0;
B[y][0] = B[w][0];
B[y][1] = B[w][1];
y++;
Y++;
X--;
}
if (X == 0 || Y == 0) break;
k++;
w++;
if (k == 10) k = 0;
if (w == 10) w = 0;
if (ans > 5000000) break;
}
if (X == 0)
printf("%d 2\n", ans);
else if (Y == 0)
printf("%d 1\n", ans);
else
printf("-1\n");
return 0;
}
| 1,400 | CPP |
n, k = map(int, input().split())
num = list(input())
if len(num) == 1 and k > 0:
print(0)
elif k == 0:
print("".join(num))
else:
if num[0] != "1":
num[0] = "1"
k -= 1
i = 1
while k > 0 and i < len(num):
if num[i] != "0":
num[i] = "0"
k -= 1
i += 1
print("".join(num))
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, sum, c;
unordered_map<int, int> mp;
long long ans;
int main() {
cin >> n >> m;
mp[0] = 1;
bool can = 0;
for (int i = 0; i < n; i++) {
cin >> c;
if (c > m)
sum++;
else if (c < m)
sum--;
if (c == m) can = 1;
if (can) {
ans += mp[sum] + mp[sum - 1];
} else {
mp[sum]++;
}
}
cout << ans;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Node {
int mx;
Node* left;
Node* right;
Node() : mx(0), left(nullptr), right(nullptr) {}
};
void Change(Node* t, int tl, int tr, int pos, int x) {
if (tl == tr) {
t->mx = x;
} else {
int tm = (0LL + tl + tr) >> 1;
if (t->left == nullptr) {
t->left = new Node();
}
if (t->right == nullptr) {
t->right = new Node();
}
if (pos <= tm) {
Change(t->left, tl, tm, pos, x);
} else {
Change(t->right, tm + 1, tr, pos, x);
}
t->mx = max(t->left->mx, t->right->mx);
}
}
int Get(Node* t, int tl, int tr, int l, int r) {
if (t == nullptr) {
return 0;
}
if (tl == l && tr == r) {
return t->mx;
} else {
int tm = (0LL + tl + tr) >> 1;
if (r <= tm) {
return Get(t->left, tl, tm, l, r);
} else if (l > tm) {
return Get(t->right, tm + 1, tr, l, r);
} else {
return max(Get(t->left, tl, tm, l, tm),
Get(t->right, tm + 1, tr, tm + 1, r));
}
}
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<pair<int, int> > a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i].first >> a[i].second;
}
sort(a.begin(), a.end());
Node* root = new Node();
const int kLeftBorder = 1;
const int kRightBorder = 2e9;
int mx = 0;
for (int i = 0; i < n; ++i) {
int need = a[i].first - a[i].second;
int max_val = 0;
if (need >= kLeftBorder) {
max_val = Get(root, kLeftBorder, kRightBorder, kLeftBorder, need);
}
Change(root, kLeftBorder, kRightBorder, a[i].first + a[i].second,
max_val + 1);
}
cout << root->mx << endl;
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b;
int main() {
cin >> n >> m;
vector<int> E;
vector<vector<int> > G(n + 1, E);
for (int i = 0; i < m; ++i) {
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
int v[100100];
for (int i = 0; i < n; ++i) v[i] = i + 1;
int times;
int t = 0;
for (times = 0; times < 100; ++times) {
random_shuffle(v, v + n);
bool ok = true;
for (int i = 0; i < m; ++i) {
for (int j = 0; j < G[v[i]].size(); ++j) {
if (G[v[i]][j] == v[(i + 1) % n]) {
ok = false;
break;
}
}
if (!ok) break;
}
if (ok) break;
}
if (times == 100) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < m; ++i) {
cout << v[i] << " " << v[(i + 1) % n] << endl;
}
return 0;
}
| 2,400 | CPP |
numTest = int(input())
for test in range(numTest):
n, m = map(int, input().split())
a = list(map(int, input().strip().split()))
b = list(map(int, input().strip().split()))
dd = {}
for x in b:
dd[x] = 1
for step in range(n):
for i in range(n-1):
if dd.get(i+1) == 1 and a[i] > a[i+1]:
a[i], a[i+1] = a[i+1], a[i]
if (sorted(a) == a):
print("YES")
else:
print("NO") | 1,200 | PYTHON3 |
from sys import stdin, stdout
n = int(stdin.readline().rstrip())
a = list((map(int,stdin.readline().rstrip().split())))
b = list(map(int,stdin.readline().rstrip().split()))
c = [(b[i],i) for i in range(n)]
a.sort(reverse=True)
c.sort(key = lambda x: x[0])
d = [0]*n
for i in range(n):
sentTo = c[i][1]
d[sentTo] = str(a[i])
print(' '.join(d))
| 1,300 | PYTHON3 |
def f(n):
sum = 0
if(n<10):
sum +=n
else:
sum+= (n//10)*10+f((n//10)+n%10)
return sum
t = int(input())
for x in range(t):
s = int(input())
print(f(s)) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int minMatrixDiff = INT_MAX;
vector<string> v, ans;
void Transpose(vector<string> &v) {
int n = v.size(), m = n > 0 ? v[0].size() : 0;
vector<string> u;
for (int y = 0; y < m; ++y) {
string s;
for (int x = 0; x < n; ++x) {
s.push_back(v[x][y]);
}
u.push_back(s);
}
v.clear();
for (string ux : u) {
v.push_back(ux);
}
}
string AlternateString(int n, char a, char b) {
string s;
for (int i = 0; i < n; ++i, swap(a, b)) {
s.push_back(a);
}
return s;
}
int Diff(string &s, string &t) {
int ans = 0;
for (int i = 0; i < s.size(); ++i) {
ans += (s[i] != t[i]);
}
return ans;
}
void CheckAndUpdate(string s, bool transpose) {
int n = v.size(), m = n > 0 ? v[0].size() : 0;
int matrixDiff = 0;
vector<string> u;
for (int x = 0; x < n; ++x) {
char a = s[2 * (x % 2 != 0)];
char b = s[1 + 2 * (x % 2 != 0)];
int minRowDiff = INT_MAX;
string ux;
for (int k = 0; k < 2; ++k, swap(a, b)) {
string t = AlternateString(m, a, b);
int rowDiff = Diff(t, v[x]);
if (rowDiff < minRowDiff) {
minRowDiff = rowDiff;
ux = t;
}
}
matrixDiff += minRowDiff;
u.push_back(ux);
}
if (matrixDiff < minMatrixDiff) {
minMatrixDiff = matrixDiff;
if (transpose) {
Transpose(u);
}
ans = u;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
v.push_back(s);
}
for (int k = 0; k < 2; ++k) {
CheckAndUpdate("ACGT", k);
CheckAndUpdate("AGCT", k);
CheckAndUpdate("ATCG", k);
CheckAndUpdate("CGAT", k);
CheckAndUpdate("CTAG", k);
CheckAndUpdate("GTCA", k);
Transpose(v);
}
for (int x = 0; x < n; ++x) {
cout << ans[x] << '\n';
}
return 0;
}
| 2,100 | CPP |
t = int(input())
for _ in range(t):
x, y, z = map(int, input().split())
if x == y and x >= z: # a > b, c
print('YES')
print(x, z, z)
elif x == z and x >= y: # b > a, c
print('YES')
print(x, y, y)
elif y == z and y >= x: # c > a, b
print('YES')
print(y, x, x)
else:
print('NO')
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct ekedge {
int flow, cap, from, to, revid;
ekedge(int flow, int cap, int from, int to, int revid)
: flow(flow), cap(cap), from(from), to(to), revid(revid) {}
};
struct EdmondsKarp {
vector<ekedge*> edgelist;
vector<vector<ekedge*> > adj;
vector<ekedge*> par;
queue<ekedge*> q;
int source;
int sink;
int INFI = 2000000000;
bool calledMaxFlow = false;
int nodeNumber;
EdmondsKarp(int nodeNumber, int source, int sink) {
if (nodeNumber >= 1000000000) {
cout << "WARNING: flow graph node count is very large; this will "
"segmentation fault"
<< endl;
}
this->source = source;
this->sink = sink;
this->nodeNumber = nodeNumber;
par.resize(nodeNumber);
adj.resize(nodeNumber);
}
void add_edge(int cap, int from, int to) {
if (from >= nodeNumber || to >= nodeNumber)
cout << "Warning: Edge from " << from << " to " << to << " with capacity"
<< cap << "is out of bounds." << endl;
ekedge* v = new ekedge(0, cap, from, to, edgelist.size() + 1);
ekedge* v_rev = new ekedge(0, 0, to, from, edgelist.size());
edgelist.push_back(v);
edgelist.push_back(v_rev);
adj[from].push_back(v);
adj[to].push_back(v_rev);
}
bool find_aug_path() {
for (int i = 0; i < par.size(); i++) par[i] = NULL;
while (!q.empty()) q.pop();
q.push(new ekedge(0, 0, source, source, -1));
while (!q.empty()) {
ekedge* curedge = q.front();
int curnode = curedge->to;
q.pop();
if (curnode == sink) return true;
for (int i = 0; i < adj[curnode].size(); i++) {
if (par[adj[curnode][i]->to] == NULL &&
adj[curnode][i]->cap - adj[curnode][i]->flow > 0) {
par[adj[curnode][i]->to] = adj[curnode][i];
q.push(adj[curnode][i]);
}
}
}
return false;
}
long long get_max_flow() {
for (int i = 0; i < edgelist.size(); i++) edgelist[i]->flow = 0;
calledMaxFlow = true;
long long maxflow = 0;
while (find_aug_path()) {
int curnode = sink;
int augment_flow = INFI;
while (curnode != source) {
ekedge* curpar = par[curnode];
augment_flow = min(augment_flow, curpar->cap - curpar->flow);
curnode = curpar->from;
}
curnode = sink;
while (curnode != source) {
ekedge* curpar = par[curnode];
curpar->flow += augment_flow;
edgelist[curpar->revid]->flow -= augment_flow;
curnode = curpar->from;
}
maxflow += augment_flow;
}
return maxflow;
}
vector<int> get_flow_values() {
vector<int> flow_values;
if (calledMaxFlow) {
for (int i = 0; i < edgelist.size(); i += 2) {
flow_values.push_back(edgelist[i]->flow);
}
} else {
cout << "Error: cannot get flow values since get_max_flow has not been "
"called"
<< endl;
}
return flow_values;
}
vector<ekedge*> get_edges() {
vector<ekedge*> edges;
for (int i = 0; i < edgelist.size(); i += 2) {
edges.push_back(edgelist[i]);
}
return edges;
}
};
vector<pair<int, int> > adj[601];
int INF = 1000000;
vector<int> assign[601];
int ans[601];
int n, m, k;
int main() {
int t;
cin >> t;
while (t--) {
bool pos = true;
long long totmatch = 0;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
adj[i].clear();
assign[i].clear();
}
for (int i = 1; i <= m; i++) ans[i] = 0;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
adj[a].emplace_back(i, b);
adj[b].emplace_back(i, a);
}
EdmondsKarp* ek = new EdmondsKarp(n + m + 2, 0, 1);
for (int i = 1; i <= n; i++) {
if (adj[i].size() > 2 * k) pos = false;
ek->add_edge(2 * max((int)adj[i].size() - k, 0), 0, 1 + i);
totmatch += 2 * max((int)adj[i].size() - k, 0);
for (int j = 0; j < adj[i].size(); j++)
ek->add_edge(INF, 1 + i, 2 + n + adj[i][j].first);
}
for (int i = 0; i < m; i++) {
ek->add_edge(1, 2 + n + i, 1);
}
if (ek->get_max_flow() == totmatch && pos) {
vector<ekedge*> edges = ek->get_edges();
for (int i = 0; i < edges.size(); i++) {
if (edges[i]->from != 0 && edges[i]->to != 1 && edges[i]->flow != 0)
assign[edges[i]->from - 2].push_back(edges[i]->to - n - 1);
}
int compcnt = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < assign[i].size(); j += 2) {
ans[assign[i][j]] = compcnt;
ans[assign[i][j + 1]] = compcnt++;
}
}
for (int i = 1; i <= m; i++) {
if (ans[i] != 0)
cout << ans[i] << ' ';
else
cout << compcnt++ << ' ';
}
cout << '\n';
} else {
for (int i = 0; i < m; i++) cout << 0 << ' ';
cout << '\n';
}
}
}
| 2,400 | CPP |
for i in range(int(input())):
n = int(input())
if n % 4 != 0:
print('NO')
continue
left = []
right = []
last = -1
for i in range(n // 4):
l = last + 2
r = last + 6
right.append(l + 1)
right.append(r - 1)
left.append(l)
left.append(r)
last = r
print('YES')
print(*(right + left))
| 800 | PYTHON3 |
s = input()
t = input()
a = list(map(int, input().split()))
def exist(m):
vis = [0] * len(s)
for i in range(m):
vis[a[i] - 1] = 1
j = 0
for i in range(len(s)):
if vis[i] == 0:
if s[i] == t[j]:
j += 1
if j == len(t):
return 1
return 0
l, r = 0, len(s)
while l < r:
mid = (l + r + 1) // 2
if exist(mid):
l = mid
else:
r = mid - 1
print(l)
| 1,700 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long LIM = 1000000;
int n, m;
vector<vector<long long> > G, GCD, LCM;
vector<bool> vis;
vector<int> res;
vector<vector<int> > adj;
long long gcd(long long a, long long b) {
while (b != 0) {
long long t = a % b;
a = b;
b = t;
}
return a;
}
long long lcm(long long a, long long b) {
long long g = gcd(a, b);
return g * (a / g) * (b / g);
}
bool dfs(int prev, int v) {
long long nv = G[prev][v] / res[prev];
long long pv = res[prev];
if (nv < 1 || pv < 1 || nv > LIM || pv > LIM || nv * pv != G[prev][v] ||
gcd(nv, pv) != GCD[prev][v] || lcm(nv, pv) != LCM[prev][v])
return false;
if (vis[v]) {
if (nv != res[v]) return false;
return true;
}
vis[v] = true;
res[v] = nv;
bool ok = true;
for (int i = 0; i < adj[v].size(); i++) {
int t = adj[v][i];
if (!dfs(v, t)) {
ok = false;
break;
}
}
if (!ok) {
vis[v] = false;
res[v] = -1;
}
return ok;
}
int main() {
istream &in = cin;
in >> n >> m;
G = vector<vector<long long> >(n, vector<long long>(n, -1));
GCD = G;
LCM = G;
vis = vector<bool>(n, false);
res = vector<int>(n, -1);
adj = vector<vector<int> >(n);
vector<int> deg(n, 0);
for (int i = 0; i < m; i++) {
int f, t, gcd, lcm;
in >> f >> t >> gcd >> lcm;
if (lcm % gcd != 0) {
cout << "NO";
return 0;
}
f--;
t--;
GCD[f][t] = GCD[t][f] = gcd;
LCM[f][t] = LCM[t][f] = lcm;
G[f][t] = G[t][f] = (long long)lcm * gcd;
deg[f]++;
deg[t]++;
adj[t].push_back(f);
adj[f].push_back(t);
}
for (int i = 0; i < n; i++)
if (deg[i] > 0 && res[i] == -1) {
long long max_mul = 0;
for (int j = 0; j < adj[i].size(); j++)
max_mul = max(max_mul, G[i][adj[i][j]]);
set<long long> divs;
bool ok = false;
for (long long first = 1; first * first <= max_mul; first++) {
bool divall = true;
for (int j = 0; j < adj[i].size(); j++)
if (G[i][adj[i][j]] % first != 0) {
divall = false;
break;
}
if (!divall) continue;
divs.insert(first);
for (int j = 0; j < adj[i].size(); j++)
divs.insert(G[i][adj[i][j]] / first);
}
for (set<long long>::iterator it = divs.begin(); it != divs.end(); it++) {
res[i] = *it;
bool all_neib = true;
for (int j = 0; j < adj[i].size(); j++) {
vis = vector<bool>(n, false);
vis[i] = true;
if (!dfs(i, adj[i][j])) {
all_neib = false;
break;
}
}
if (all_neib) {
ok = true;
break;
}
}
if (!ok) {
cout << "NO";
return 0;
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << (deg[i] == 0 ? 1 : res[i]) << " ";
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
char str[maxn];
int main() {
int n;
scanf("%d", &n);
while (n--) {
scanf("%s", str);
int len = strlen(str + 4), year = atoi(str + 4), F = 0, ten = 10;
for (int i = 1; i < len; i++) {
F += ten;
ten *= 10;
}
while (year < 1989 + F) year += ten;
printf("%d\n", year);
}
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x, y;
cin >> n >> x >> y;
long long chis = y - n + 1;
if (n - 1 + chis * chis >= x && chis > 0) {
for (long long i = 0; i < n - 1; i++) cout << "1" << '\n';
cout << chis;
} else
cout << "-1";
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100005], lst = -1, d[100005];
int n, k;
int main() {
cin >> n >> k;
memset(d, -1, sizeof(lst));
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) {
if (i < n && a[i] == a[i - 1])
continue;
else {
if (lst < 0 || i == n || a[lst] != a[i])
d[a[i - 1]]++;
else
d[a[i - 1]] += 2;
lst = i - 1;
}
}
int id = 1;
for (int i = 1; i <= k; ++i)
if (d[i] > d[id]) id = i;
cout << id << endl;
return 0;
}
| 1,600 | CPP |
n = int(input())
for k in range(n):
a, b = map(int, input().split())
a_1 = 0
for i in range(2, a + 1):
if a % i == 0:
a_1 = a + i
break
if b == 1:
print(a_1)
else:
for j in range(2, a_1 + 1):
if a_1 % j == 0:
min_div = j
break
print(a_1 + min_div * (b - 1))
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
const int INF = (int)1e9 + 1;
const long double EPS = 1e-9;
int readTime() {
int h, m, s;
scanf("%d:%d:%d", &h, &m, &s);
return (h * 60 + m) * 60 + s;
}
const int maxn = (int)2e4 + 10;
int a[maxn], d[maxn];
bool solve() {
int n, m, t;
if (scanf("%d%d%d", &n, &m, &t) < 3) {
return 0;
}
for (int i = 0; i < n; ++i) {
a[i] = readTime();
if (i) {
assert(a[i] >= a[i - 1]);
}
}
int res = 0;
bool been = 0;
for (int i = 0, j = 0; i < n; ++i) {
while (j < i && a[j] + t <= a[i]) {
++j;
}
int inside = (i == j) ? 0 : (d[i - 1] - d[j] + 1);
if (inside < m) {
d[i] = res++;
if (inside == m - 1) {
been = 1;
}
} else {
d[i] = d[i - 1];
been = 1;
}
}
if (!been) {
printf("No solution\n");
return 1;
}
printf("%d\n", res);
for (int i = 0; i < n; ++i) {
printf("%d\n", d[i] + 1);
}
return 1;
}
int main() {
srand(rdtsc());
while (1) {
if (!solve()) {
break;
}
}
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn * 2];
bool is_prime[2750140];
int prime[maxn];
int num[2750140];
int Map[2750140];
bool vis[maxn];
int sieve(int n) {
int cnt = 0;
for (int i = 0; i <= n; i++) is_prime[i] = true;
is_prime[0] = is_prime[1] = false;
for (int i = 2; i <= n; i++)
if (is_prime[i]) {
prime[++cnt] = i;
Map[i] = cnt;
for (int j = 2 * i; j <= n; j += i) is_prime[j] = false;
}
return cnt;
}
int nn;
int main() {
scanf("%d", &nn);
memset(num, 0, sizeof(num));
int Max = 0;
for (int i = 1; i <= 2 * nn; i++) {
scanf("%d", &a[i]);
Max = max(Max, a[i]);
num[a[i]]++;
}
sieve(Max);
queue<int> q;
for (int i = Max; i >= 1; i--) {
while (num[i] >= 1) {
num[i]--;
if (is_prime[i]) {
q.push(Map[i]);
num[Map[i]]--;
} else if (!is_prime[i]) {
q.push(i);
for (int j = 2; j <= i; j++) {
if (i % j == 0) {
num[i / j]--;
break;
}
}
}
}
}
printf("%d", q.front());
q.pop();
while (!q.empty()) {
printf(" %d", q.front());
q.pop();
}
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long Map[10][10];
long long dp[44][9][9];
long long gao(long long n, long long from, long long to) {
if (n == 0) return 0;
if (~dp[n][from][to]) return dp[n][from][to];
long long mid = 6 - from - to;
long long ret;
long long tt = gao(n - 1, from, mid) + Map[from][to] + gao(n - 1, mid, to);
long long tt1 = gao(n - 1, from, to) + Map[from][mid] + gao(n - 1, to, from) +
Map[mid][to] + gao(n - 1, from, to);
ret = min(tt, tt1);
return dp[n][from][to] = ret;
}
int main() {
long long n;
memset(dp, -1, sizeof(dp));
for (long long i = 1; i <= 3; i++)
for (long long j = 1; j <= 3; j++) scanf("%I64d", &Map[i][j]);
scanf("%I64d", &n);
cout << gao(n, 1, 3) << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int k, l, m, n, d, rs;
int main() {
cin >> k >> l >> m >> n >> d;
rs = 0;
for (int i = d; i >= 1; i--)
if (i % k == 0 || i % l == 0 || i % m == 0 || i % n == 0) rs++;
cout << rs;
return 0;
}
| 800 | CPP |
l = list(map(int, input().split()))
if sum(l) % len(l) == 0 and sum(l) != 0:
print(int(sum(l) / len(l)))
else:
print('-1') | 1,100 | PYTHON3 |
a=int(input())
b=int(input())
c=int(input())
k=[];
k.append(a+b*c)
k.append(a*(b+c))
k.append(a*b*c);
k.append((a+b)*c)
k.append(a+b+c)
k.sort()
print(k[4])
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 1005;
int N, M, K, A[MN][MN], D[MN][MN][41], F[MN][MN], Q, r1, c1, r2, c2, ans;
bool ch[41];
queue<pair<pair<int, int>, int> > Qu[41];
vector<pair<int, int> > V[41];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> N >> M >> K;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) {
for (int k = 1; k <= K; k++) D[i][j][k] = 200;
int c;
cin >> c;
A[i][j] = c;
D[i][j][c] = 0;
Qu[c].emplace(pair<int, int>(i, j), 0);
V[c].emplace_back(i, j);
}
for (int k = 1; k <= K; k++) {
for (int i = 1; i <= K; i++) ch[i] = 0;
while (Qu[k].size()) {
pair<int, int> p = Qu[k].front().first;
int c = A[p.first][p.second], dis = Qu[k].front().second;
Qu[k].pop();
if (!ch[c]) {
for (pair<int, int> q : V[c]) {
if (D[q.first][q.second][k] != 200) continue;
D[q.first][q.second][k] = dis + 1;
Qu[k].emplace(q, dis + 1);
}
ch[c] = 1;
}
if (p.second < M && D[p.first][p.second + 1][k] == 200) {
D[p.first][p.second + 1][k] = dis + 1;
Qu[k].emplace(pair<int, int>(p.first, p.second + 1), dis + 1);
}
if (p.second > 1 && D[p.first][p.second - 1][k] == 200) {
D[p.first][p.second - 1][k] = dis + 1;
Qu[k].emplace(pair<int, int>(p.first, p.second - 1), dis + 1);
}
if (p.first < N && D[p.first + 1][p.second][k] == 200) {
D[p.first + 1][p.second][k] = dis + 1;
Qu[k].emplace(pair<int, int>(p.first + 1, p.second), dis + 1);
}
if (p.first > 1 && D[p.first - 1][p.second][k] == 200) {
D[p.first - 1][p.second][k] = dis + 1;
Qu[k].emplace(pair<int, int>(p.first - 1, p.second), dis + 1);
}
}
}
cin >> Q;
for (int i = 1; i <= Q; i++) {
cin >> r1 >> c1 >> r2 >> c2;
ans = abs(r2 - r1) + abs(c2 - c1);
for (int k = 1; k <= K; k++) {
ans = min(ans, D[r1][c1][k] + D[r2][c2][k] + 1);
}
cout << ans << '\n';
}
}
| 2,600 | CPP |
t = int(input())
while t:
t -= 1
n, x, a, b = list(map(int, input().split()))
ans = min(n-1, abs(b-a) + x)
print(ans)
| 800 | PYTHON3 |
a,b=input().rjust(10**6,"0"),input().rjust(10**6,"0")
print(">" if a>b else ("<" if a<b else "=")) | 900 | PYTHON3 |
a = int(input())
b = int(input())
c = int(input())
res = a + b + c
res = max(res, a + b * c)
res = max(res, (a + b) * c)
res = max(res, a * b + c)
res = max(res, a * (b + c))
res = max(res, a * b * c)
print(res)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long double x, y, z;
long double arr[15];
string s[15];
s[1] = "x^y^z";
s[2] = "x^z^y";
s[3] = "(x^y)^z";
s[4] = "(x^z)^y";
s[5] = "y^x^z";
s[6] = "y^z^x";
s[7] = "(y^x)^z";
s[8] = "(y^z)^x";
s[9] = "z^x^y";
s[10] = "z^y^x";
s[11] = "(z^x)^y";
s[12] = "(z^y)^x";
while (cin >> x >> y >> z) {
arr[1] = log(x) * pow(y, z);
arr[2] = log(x) * pow(z, y);
arr[3] = z * y * log(x);
arr[4] = arr[3];
arr[5] = log(y) * pow(x, z);
arr[6] = log(y) * pow(z, x);
arr[7] = z * x * log(y);
arr[8] = arr[7];
arr[9] = log(z) * pow(x, y);
arr[10] = log(z) * pow(y, x);
arr[11] = x * y * log(z);
arr[12] = arr[11];
long double zd = -1e16;
int shu = 0;
for (int i = 1; i <= 12; i++) {
if (arr[i] > zd) {
zd = arr[i];
shu = i;
}
}
cout << s[shu] << endl;
}
return 0;
}
| 2,400 | CPP |
#author : dokueki
import sys
INT_MAX = sys.maxsize
INT_MIN = -(sys.maxsize)
sys.setrecursionlimit(10**7)
mod = 1000000007
def IOE():
sys.stdin = open("input.txt", "r")
sys.stdout = open("output.txt", "w")
def main():
t = int(sys.stdin.readline())
for _ in range(t):
a, b, c, d = map(int, sys.stdin.readline().split())
if (b == c):
print(b, c, c)
elif (b != c):
print(a,c,c)
if __name__ == "__main__":
try:
IOE()
except:
pass
main()
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int INFMEM = 63;
const int INF = 1061109567;
const long long LINF = 4557430888798830399LL;
const double DINF = numeric_limits<double>::infinity();
const long long MOD = 1000000007;
const int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
const double PI = 3.141592653589793;
inline void fastll(long long &input_number) {
input_number = 0;
int ch = getchar_unlocked();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar_unlocked();
}
while (ch >= '0' && ch <= '9') {
input_number = (input_number << 3) + (input_number << 1) + ch - '0';
ch = getchar_unlocked();
}
input_number *= sign;
}
inline void open(string a) {
freopen((a + ".in").c_str(), "r", stdin);
freopen((a + ".out").c_str(), "w", stdout);
}
inline void fasterios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
struct dt {
long long m, c;
};
long long gety(dt line, long long x) { return line.m * x + line.c; }
long double getintersection(dt linea, dt lineb) {
return (long double)(linea.c - lineb.c) / (long double)(lineb.m - linea.m);
}
long long isi[200005];
long long sum[200005];
long long psum[200005];
long long n, ans, tot;
vector<dt> hull;
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> isi[i];
sum[i] = sum[i - 1] + isi[i];
psum[i] = psum[i - 1] + (isi[i] * i);
}
ans = -LINF;
for (long long i = n; i >= 1; i--) {
dt nx = {-i, -sum[i]};
while (hull.size() > 1) {
long long blkg = hull.size() - 1;
if (getintersection(nx, hull[blkg]) >
getintersection(hull[blkg], hull[blkg - 1]))
break;
hull.pop_back();
}
hull.push_back(nx);
long long kiri = 0;
long long kanan = hull.size() - 1;
while (kiri < kanan) {
long long mid = (kiri + kanan) / 2;
if (gety(hull[mid], -isi[i]) > gety(hull[mid + 1], -isi[i]))
kanan = mid;
else
kiri = mid + 1;
}
ans = max(ans, gety(hull[kiri], -isi[i]) - (i * isi[i]) + sum[i]);
}
hull.clear();
for (long long i = 1; i <= n; i++) {
dt nx = {i, -sum[i - 1]};
while (hull.size() > 1) {
long long blkg = hull.size() - 1;
if (getintersection(nx, hull[blkg]) >
getintersection(hull[blkg], hull[blkg - 1]))
break;
hull.pop_back();
}
hull.push_back(nx);
long long kiri = 0;
long long kanan = hull.size() - 1;
while (kiri < kanan) {
long long mid = (kiri + kanan) / 2;
if (gety(hull[mid], isi[i]) > gety(hull[mid + 1], isi[i]))
kanan = mid;
else
kiri = mid + 1;
}
ans = max(ans, gety(hull[kiri], isi[i]) - (i * isi[i]) + sum[i - 1]);
}
cout << ans + psum[n] << '\n';
return 0;
}
| 2,600 | CPP |
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def check(mid,arr,k):
i,j = 0,0
while j != len(arr) and arr[j]-arr[i] <= 2*mid:
j += 1
ans = j-i
ind = (arr[i]+arr[j-1])//2
while j != len(arr):
i = i+1
j = max(j,i+1)
while j != len(arr) and arr[j]-arr[i]<=2*mid:
j += 1
if ans < j-i:
ans = j-i
ind = (arr[i]+arr[j-1])//2
if ans <= k:
return 0
return ind+1
def main():
for _ in range(int(input())):
n,k = map(int,input().split())
a = list(map(int,input().split()))
hi,lo,ans = 10**9,0,10**10
while hi >= lo:
mid = (hi+lo)//2
x = check(mid,a,k)
if x:
hi = mid-1
ans = x-1
else:
lo = mid+1
print(ans)
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == '__main__':
main() | 1,600 | PYTHON3 |
T=int(input())
for z in range(T):
n=int(input())
i=0
a=4
while i<n:
if a*2>4*n and a*4>4*n:
print(a,end=" ")
i+=1
a+=2
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 123;
const int mod = 1e9 + 7;
const int INF = 1e9 + 1;
const long long INFL = 1e18 + 1;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n, k, second, t, mn = INF;
pair<int, int> a[N];
int g[N];
int arrive(int len, int volume) {
int l = 0, r = len, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (mid * 2 + len - mid <= volume) {
l = mid + 1;
ans = mid;
} else
r = mid - 1;
}
return ans + (len - ans) * 2;
}
bool can(int volume) {
int pos = 0, when = 0;
for (int i = 1; i <= k; i++) {
int len = g[i] - pos;
if (len > volume) return 0;
when += arrive(len, volume);
if (when > t) return 0;
pos = g[i];
}
return (when <= t);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> second >> t;
for (int i = 1; i <= n; i++) {
int c, v;
cin >> c >> v;
a[i] = make_pair(v, c);
}
for (int i = 1; i <= k; i++) cin >> g[i];
g[++k] = second;
sort(g + 1, g + k + 1);
sort(a + 1, a + n + 1);
int l = 1, r = n, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (can(a[mid].first)) {
r = mid - 1;
ans = a[mid].first;
} else
l = mid + 1;
}
if (ans == -1) {
cout << ans;
return 0;
}
for (int i = 1; i <= n; i++)
if (a[i].first >= ans) mn = min(mn, a[i].second);
cout << (mn == -INF ? -1 : mn);
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, i, x, count = 0;
cin >> n >> k;
vector<long long int> v(n);
long long int a[10];
for (i = 0; i < 10; i++) a[i] = 0;
for (i = 0; i < n; i++) {
cin >> v[i];
x = v[i] % 10;
a[x]++;
count += v[i] / 10;
}
for (i = 9; i > 0; i--) {
while (a[i] > 0) {
if (k > 0) {
a[i]--;
k -= 10 - i;
count++;
} else
break;
}
if (k < 0) {
count--;
break;
}
}
if (k > 0) {
for (i = 0; i < n; i++) {
if (v[i] % 10 != 0) v[i] = (v[i] / 10) * 10 + 10;
}
for (i = 0; i < n; i++) {
while (k > 0 && v[i] < 100) {
count++;
k -= 10;
v[i] += 10;
}
if (k < 0) {
count--;
break;
}
}
}
cout << count << "\n";
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 7;
const int INF = MAXN;
const int MOD = 1000000007;
int C[MAXN][MAXN];
int f[MAXN >> 1][MAXN >> 1][MAXN >> 1][MAXN];
void add(int &x, const int y) {
x += y;
(x >= MOD) && (x -= MOD);
}
int main() {
for (int i = 0, j; i < MAXN; ++i)
for (C[i][0] = C[i][i] = 1, j = 1; j < i; ++j) {
C[i][j] = min(C[i - 1][j - 1] + C[i - 1][j], INF);
}
int tot = 0;
int N, M, K;
scanf("%d%d%d", &N, &M, &K), N >>= 1;
f[0][1][0][1] = 1;
for (int i = 0; i <= N && i < M; ++i)
for (int j = 1; j <= N; ++j) {
for (int k = 0; k <= N; ++k)
for (int w = 0; w <= K; ++w) {
int cc = f[i][j][k][w];
if (!cc) continue;
if (i) tot = (tot + (long long)cc * (M - i)) % MOD;
for (int x = 1; x + k <= N; ++x) {
int nw = w * C[j + x - 1][x];
if (nw > K) continue;
add(f[i + 1][x][k + x][nw], cc);
}
}
}
printf("%d\n", tot);
return 0;
}
| 2,800 | CPP |
for _ in range(int(input())):
x1,y1,z1 = map(int,input().split())
x2,y2,z2 = map(int,input().split())
sum = 0
if z2 - x1 > 0:
z2 = z2 - x1
if z2 - z1 > 0:
z2 = z2 - z1
sum = z2*(-2)
else:
z1 = z1 - z2
sum = min(z1,y2)*2
else:
sum = min(z1,y2)*2
print(sum)
| 1,100 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
l.sort()
l = [0]+l
for i in range(len(l)-1,-1,-1):
if l[i]<= i:
print(i+1)
break | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<complex<double> > fft(vector<complex<double> > v, bool rev = false) {
int n = v.size(), i, j, m;
for (i = 0, j = 1; j < n - 1; j++) {
for (int k = n >> 1; k > (i ^= k); k >>= 1)
;
if (i > j) swap(v[i], v[j]);
}
for (int m = 2; m <= n; m *= 2) {
double deg = (rev ? -1 : 1) * 2 * acos(-1) / m;
complex<double> wr(cos(deg), sin(deg));
for (i = 0; i < n; i += m) {
complex<double> w(1, 0);
for (int j1 = i, j2 = i + m / 2; j2 < i + m; j1++, j2++) {
complex<double> t1 = v[j1], t2 = w * v[j2];
v[j1] = t1 + t2, v[j2] = t1 - t2;
w *= wr;
}
}
}
if (rev)
for (i = 0; i < (n); i++) v[i] *= 1.0 / n;
return v;
}
vector<complex<double> > MultPoly(vector<complex<double> > P,
vector<complex<double> > Q) {
P = fft(P), Q = fft(Q);
for (int i = 0; i < P.size(); i++) P[i] *= Q[i];
return fft(P, true);
}
int T, N;
string S;
int NG[505050];
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> T;
while (T--) {
cin >> N >> S;
int L = 1;
while (L <= 2 * N) L *= 2;
vector<complex<double> > VA(L, 0), KA(L, 0), VB(L, 0), KB(L, 0);
for (i = 0; i < (N); i++) {
if (S[i] == 'V') VA[i] = VB[N - 1 - i] = 1;
if (S[i] == 'K') KA[i] = KB[N - 1 - i] = 1;
}
auto A = MultPoly(VA, KB);
auto B = MultPoly(KA, VB);
for (i = 0; i < (N + 1); i++) NG[i] = 0;
int cnt = 1;
for (i = N - 1; i >= 1; i--) {
if ((int)(A[N - 1 - i].real() + 0.2) > 0 ||
(int)(B[N - 1 - i].real() + 0.2) > 0)
NG[i] = 1;
for (j = i * 2; j <= N; j += i) NG[i] |= NG[j];
if (NG[i] == 0) cnt++;
}
(void)printf("%d\n", cnt);
for (i = 1; i <= N; i++)
if (NG[i] == 0) (void)printf("%d%c", i, (i == N) ? '\n' : ' ');
}
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
solve();
return 0;
}
| 2,700 | CPP |
year = int(input()) + 1
while 1:
if len(list(str(year))) == len(set(str(year))):
print(year)
break
year += 1 | 800 | PYTHON3 |
score_board = {}
state = []
for i in range(int(input())):
x,y = [char for char in input().split()]
y = int(y)
score_board[x] = score_board.get(x,0) + y
state.append((x,score_board[x]))
max_sco = max(score_board.values())
for i,j in state:
if score_board[i] == max_sco and j >= max_sco:
print(i)
break
| 1,500 | PYTHON3 |
for _ in range(int(input())):
x,y,z=map(int,input().split())
if x==y==z:
print("YES")
print(x,x,x,)
elif x==y and z<x:
print("YES")
print(x,end=" ")
print(z,z)
elif y==z and x<y:
print("YES")
print(y,end=" ")
print(x,x)
elif z==x and y<z:
print("YES")
print(z,end=" ")
print(y,y)
else:
print("NO") | 800 | PYTHON3 |
def wczytywanie():
n = int(input())
lista = []
lista_i = []
for i in range(1, n+1):
lista.append(i)
lista_i = list(map(int, input().split()))
return lista, lista_i
def ile_dni():
lista, lista_i = wczytywanie()
for i in range(1,len(lista)+1):
pozycja = lista_i[i-1]-1
ile_dni = 1
while pozycja != i-1:
ile_dni += 1
pozycja = lista_i[pozycja]-1
print(ile_dni, end = " ")
n = int(input())
for i in range(n):
ile_dni()
print()
| 1,000 | PYTHON3 |
for _ in range(int(input())):
n,m = map(int,input().split())
l = list(map(int,input().split()))
w = l.copy()
q = m
if n>2:
if m>=n:
c = 2*sum(l)
q-=n
asd = min(l)
w.remove(min(w))
asd+=min(w)
c+=(q*asd)
print(c)
for i in range(1,n):
print(i,i+1)
print(n,1)
w = l.copy()
z = w.index(min(w))
w.remove(min(w))
v = w.index(min(w))
if z>v:
z+=1
v+=1
else:
z+=1
v+=2
for i in range(q):
print(z,v)
else:
print(-1)
else:
print(-1)
| 1,100 | PYTHON3 |
a,b = input().split()
a = int(a)
b = int(b)
s = input()
d = list(input().strip().split())
j = 0
for i in range(0,len(s)):
if(s[i] in d):
j = i
# print(j)
break
ans = 0
finalans = 0
for i in range(j,len(s)):
if(s[i] not in d):
finalans += (ans)*(ans + 1)//2
# finalans = finalans//2
# print(finalans)
ans = 0
else:
ans += 1
if(ans > 0):
finalans += (ans)*(ans + 1)//2
print(finalans) | 1,200 | PYTHON3 |
Datos=input()
Datos=Datos.split()
a=int(Datos[0])
b=int(Datos[1])
hora=0
cont=0
while a>=b:
if a%b==0:
hora+=a
a=a//b
else:
cont+=a%b
hora+=a
a=a//b
if cont>=b:
a+=1
cont=cont%b
hora+=a
if a+cont>=b:
hora+=1
print(hora)
| 1,000 | PYTHON3 |
replacements = {
"A":"+BF-AFA-FB+",
"B":"-AF+BFB+FA-",
"+":"+",
"-":"-",
"F":"F",
}
def curve_sequence(n):
if n==0:
yield "A"
return
for t in curve_sequence(n-1):
yield from replacements[t]
a, b = map(int, input().split())
def location(a, b):
i = 0
x, y = 0, 0
direction = 0
for move in curve_sequence(a):
if i == b:
return x, y
if move == "+":
direction += 1
direction %= 4
elif move == "-":
direction -= 1
direction %= 4
if move != "F":
continue
i += 1
if direction == 0:
x += 1
elif direction == 1:
y += 1
elif direction == 2:
x -= 1
else:
y -= 1
print(*location(a, b))
| 1,500 | PYTHON3 |
from sys import stdout,stdin
from collections import defaultdict
#t=int(input())
#for _ in range(t):
n=int(input())
l=list(map(int,input().split()))
#n,a,b=map(int,input().split())
v=[0]*(100001)
for i in l:
v[i]+=1
sq,re=0,0
for i in v:
if i>0:
t=i//4
sq+=t
r=i%4
t=r//2
re+=t
q=int(input())
for i in range(q):
s=input()
m=s[0]
a=int(s[2:])
if m=='+':
v[a]+=1
if v[a]%2==0:
if v[a]%4==0:
re-=1
sq+=1
else:
re+=1
if sq>=2 or (sq==1 and re>=2):
stdout.write('YES'+'\n')
else:
stdout.write('NO'+'\n')
else:
if v[a]==0:
raise Exception('KKS')
if v[a]%2==0:
if v[a]%4==0:
sq-=1
re+=1
else:
re-=1
v[a]-=1
if sq>=2 or (sq==1 and re>=2):
stdout.write('YES'+'\n')
else:
stdout.write('NO'+'\n')
| 1,400 | PYTHON3 |
entered = input()
list(entered)
h = entered.count("H")
q = entered.count("Q")
nine = entered.count("9")
if(h>0 or q>0 or nine>0 ):
print("YES")
else:
print("NO")
| 900 | PYTHON3 |
import re
n = int(input())
x = 0
if 1 <= n <= 150:
for i in range(n):
s = str(input())
if re.findall('\S[+]', s):
x += 1
if re.findall('\S[-]', s):
x -= 1
print(x) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, percent;
double posb[1001];
long long one(long long x) {
if (x == 0) return 0;
long long ret = 0;
for (long long i = 1;; i *= 10) {
if (x < i) break;
if (x / 10 >= i)
ret += i;
else if (x / i == 1)
ret += x - i * (x / i) + 1;
else
ret += i;
if (i == 1000000000000000000LL) break;
}
return ret;
}
bool done[1001][1001];
double mem[1001][1001];
double dp(int cur, int need) {
need = max(need, 0);
if (done[cur][need]) return mem[cur][need];
if (cur == n + 1) {
if (need == 0) return 1.0;
return 0.0;
}
mem[cur][need] = 0;
mem[cur][need] += posb[cur] * dp(cur + 1, need - 1);
mem[cur][need] += (1.0 - posb[cur]) * dp(cur + 1, need);
done[cur][need] = true;
return mem[cur][need];
}
int main() {
cout << fixed << setprecision(16);
while (cin >> n) {
for (int i = 1; i <= n; i++) {
long long a, b;
cin >> a >> b;
a--;
posb[i] = (double)(one(b) - one(a)) / (double)(b - a);
}
int C;
cin >> C;
int L = 0;
while (100 * L < n * C) L++;
memset(done, false, sizeof(done));
cout << dp(1, L) << endl;
}
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &t) {
t = 0;
char ch = getchar();
int f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
do {
(t *= 10) += ch - '0';
ch = getchar();
} while ('0' <= ch && ch <= '9');
t *= f;
}
const int maxn = (1e5) + 10;
int T, n, m, k;
bool flag;
vector<int> ans;
unordered_set<int> g[maxn];
priority_queue<pair<int, int> > q;
unordered_set<int>::iterator it, it2;
int main() {
int x, y;
read(T);
while (T--) {
read(n), read(m), read(k);
ans.clear();
for (int i = 1; i <= n; i++) g[i].clear();
for (int i = 1; i <= m; i++) {
read(x), read(y);
g[x].insert(y), g[y].insert(x);
}
if (k == 1) {
printf("2\n1\n");
continue;
}
q = priority_queue<pair<int, int> >();
for (int i = 1; i <= n; i++) q.push(make_pair(-(int)g[i].size(), i));
flag = 0;
while (!q.empty()) {
int u = q.top().second;
q.pop();
if (g[u].empty()) continue;
if ((int)g[u].size() >= k) {
flag = 1;
break;
}
if ((int)g[u].size() == k - 1 && (long long)k * (k - 1) / 2 <= m) {
bool f = 1;
for (it = g[u].begin(); f && it != g[u].end(); it++)
for (it2 = it, it2++; f && it2 != g[u].end(); it2++) {
f &= g[*it].find(*it2) != g[*it].end();
}
if (f) {
for (it = g[u].begin(); it != g[u].end(); it++) ans.push_back(*it);
ans.push_back(u);
break;
}
}
for (it = g[u].begin(); it != g[u].end(); it++)
g[*it].erase(u), q.push(make_pair(-(int)g[*it].size(), *it));
g[u].clear();
}
if (ans.size()) {
printf("2\n");
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
printf("\n");
} else if (flag) {
for (int i = 1; i <= n; i++)
if ((int)g[i].size()) ans.push_back(i);
printf("1 %d\n", (int)ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
printf("\n");
} else
printf("-1\n");
}
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int *arr = new long long int[n + 1];
long long int odd = 0, eve = 0;
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
if (arr[i] != 0) {
if (arr[i] % 2)
odd++;
else
eve++;
}
}
long long int teve = n / 2, todd = n - teve;
teve -= eve;
todd -= odd;
vector<long long int> vec1, vec2, vec3, vec4, vec5;
long long int count = 0, i = 0;
while (i < n) {
long long int start = arr[i];
long long int j = i + 1, count1 = 0;
while (j < n) {
if (arr[j] != 0) break;
j++;
count1++;
}
if (j == n) {
if (start % 2)
vec4.push_back(count1);
else
vec5.push_back(count1);
count1 = 0;
} else if (start == 0) {
if (arr[j] % 2)
vec4.push_back(count1 + 1);
else
vec5.push_back(count1 + 1);
} else if ((start % 2) == (arr[j] % 2)) {
if (start % 2)
vec1.push_back(count1);
else
vec2.push_back(count1);
} else
vec3.push_back(count1);
count1 = 0;
i = j;
}
sort(vec1.begin(), vec1.end());
sort(vec2.begin(), vec2.end());
sort(vec3.begin(), vec3.end());
sort(vec4.begin(), vec4.end());
sort(vec5.begin(), vec5.end());
long long int ans = vec3.size();
for (long long int i = 0; i < vec1.size(); i++) {
if (vec1[i] <= todd) {
todd -= vec1[i];
continue;
} else
ans += 2;
}
for (long long int i = 0; i < vec2.size(); i++) {
if (vec2[i] <= teve) {
teve -= vec2[i];
continue;
} else
ans += 2;
}
for (long long int i = 0; i < vec4.size(); i++) {
if (vec4[i] <= todd) {
todd -= vec4[i];
continue;
}
ans++;
}
for (long long int i = 0; i < vec5.size(); i++) {
if (vec5[i] <= teve) {
teve -= vec5[i];
continue;
}
ans++;
}
cout << ans << endl;
return 0;
}
| 1,800 | CPP |
#This code sucks, you know it and I know it.
#Move on and call me an idiot later.
n = int(input())
cmn = {}
cmnn = []
a = {}
for i in range(n):
ai, xi = map(int, input().split())
cmn[ai] = 1
a[ai] = xi
m = int(input())
b = {}
for i in range(m):
bi, xi = map(int, input().split())
b[bi] = xi
if cmn.get(bi, 0) == 1:
if a[bi] > b[bi]:
del(b[bi])
else:
del(a[bi])
# print(a)
# print(b)
print(sum(a.values()) + sum(b.values())) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
pair<int, int> p[100005];
int frq[100005], l[100005], cost[205];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < (n); i++) {
cin >> p[i].first;
p[i].second = i;
frq[p[i].first]++;
}
sort(p, p + n);
for (int i = 0; i < (n); i++) {
cin >> l[i];
cost[l[i]]++;
}
long long ans = 2134567891, sum = 0, mx = 0, m = n, summ = 0;
int pre = -1;
for (int i = n - 1; i >= 0; i--) {
int val = p[i].first;
int id = p[i].second;
int rest = m - frq[val];
summ = 0;
long long tot = 0;
while (p[i].first == val && i >= 0) {
cost[l[p[i].second]]--;
tot += l[p[i].second];
i--;
m--;
}
i++;
if (rest >= frq[val]) {
rest = rest - frq[val] + 1;
for (long long j = 1; j <= 200; j++) {
summ += min(cost[j], rest) * j;
rest -= min(cost[j], rest);
if (!rest) break;
}
}
ans = min(ans, sum + summ);
sum += tot;
}
cout << ans << endl;
return 0;
}
| 1,900 | CPP |
a=[];b=[]
n=(int(input()))
for i in range(n):
x,y=map(int,input().split())
a.append(x)
b.append(y)
c=[1]*n
for i in range(n):
for j in range(n):
if(a[i]==b[j] and i!=j):
c[i]=0
print(sum(c))
| 1,400 | PYTHON3 |
def minimum_subtract (n,k,seq):
new_unique = sorted(list(set(seq)))
times = 0
pointer_non_zero = 0
previous = 0
while times < k :
if pointer_non_zero >= len(new_unique) :
print (0)
else :
print (new_unique[pointer_non_zero]-previous)
previous += new_unique[pointer_non_zero]-previous
pointer_non_zero += 1
times += 1
n,k = list(map(int,input().split()))
seq = list(map(int,input().split()))
minimum_subtract(n,k,seq)
| 1,000 | PYTHON3 |
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
a.sort()
o,e=0,0
for z in a:
if z&1:
o+=1
else:
e+=1
diff=0
for i in range(1,n):
if a[i]-a[i-1]==1:
diff+=1
f=1
if (o&1) and diff==0:
f=0
if f:
print("YES")
else:
print("NO")
| 1,100 | PYTHON3 |
t=int(input())
ar=[]
c=0
for i in range(t):
ele=list(map(int,input().split()))
ar.append(ele)
for i in ar:
if sum(i)>=2:
c+=1
print(c) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline int qpow(int b, int e, int m = 998244353) {
int a = 1;
for (; e; e >>= 1, b = (long long)b * b % m)
if (e & 1) a = (long long)a * b % m;
return a;
}
long long ans = 0;
void dfs(long long i, long long p, vector<vector<long long>> &adj,
vector<long long> &stsize) {
if (adj[i].size() == 1 && adj[i][0] == p) {
stsize[i] = 1;
return;
}
for (long long j = 0; j < adj[i].size(); j++) {
long long v = adj[i][j];
if (v == p) continue;
dfs(v, i, adj, stsize);
stsize[i] += stsize[v];
}
stsize[i]++;
}
void solve() {
long long n;
cin >> n;
vector<vector<long long>> adj(n + 1);
for (int i = 1; i < n; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
if (n % 2 == 1) {
cout << -1 << endl;
return;
}
vector<long long> stsize(n + 1);
dfs(1, 0, adj, stsize);
for (int i = 2; i <= n; i++)
if (stsize[i] != 0 && stsize[i] % 2 == 0) ans++;
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
t = 1;
while (t--) solve();
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
constexpr int MAX_M = 1e5 + 5;
using i64 = std::int64_t;
using state = std::pair<i64, int>;
struct Point {
Point() {}
Point(int _x, int _y, int _id) : x(_x), y(_y), id(_id) {}
int x, y, id;
};
struct Edge {
Edge(int _from, int _to, int _w) : from(_from), to(_to), w(_w) {}
int from, to, w;
};
int n, m;
std::vector<Edge> g[MAX_M];
Point pts[MAX_M];
int manhattan(int i, int j) {
return std::abs(pts[i].x - pts[j].x) + std::abs(pts[i].y - pts[j].y);
}
int cost(int i, int j) {
return std::min(std::abs(pts[i].x - pts[j].x), std::abs(pts[i].y - pts[j].y));
}
std::vector<i64> dijkstra(int s, int t) {
std::vector<i64> dist(m + 2, -1);
std::priority_queue<state, std::vector<state>, std::greater<state>> pq;
dist[s] = 0;
pq.emplace(0, s);
while (!pq.empty()) {
i64 d;
int cur;
std::tie(d, cur) = pq.top();
pq.pop();
for (const auto &ed : g[cur]) {
if (dist[ed.to] == -1 || d + ed.w < dist[ed.to]) {
dist[ed.to] = d + ed.w;
pq.emplace(dist[ed.to], ed.to);
}
}
}
return dist;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cin >> n >> m;
std::cin >> pts[0].x >> pts[0].y;
pts[0].id = 0;
std::cin >> pts[1].x >> pts[1].y;
pts[1].id = 1;
for (int i = 0; i < m; i++) {
std::cin >> pts[2 + i].x >> pts[2 + i].y;
pts[2 + i].id = 2 + i;
}
g[0].emplace_back(0, 1, manhattan(0, 1));
for (int i = 2; i < 2 + m; i++) {
g[0].emplace_back(0, i, cost(0, i));
g[i].emplace_back(i, 1, manhattan(i, 1));
}
std::sort(pts + 2, pts + 2 + m,
[&](const Point &a, const Point &b) { return a.x < b.x; });
for (int i = 2; i < m + 2; i++) {
if (i > 2) {
g[pts[i].id].emplace_back(pts[i].id, pts[i - 1].id, cost(i, i - 1));
}
if (i + 1 < m + 2) {
g[pts[i].id].emplace_back(pts[i].id, pts[i + 1].id, cost(i, i + 1));
}
}
std::sort(pts + 2, pts + 2 + m,
[&](const Point &a, const Point &b) { return a.y < b.y; });
for (int i = 2; i < m + 2; i++) {
if (i > 2) {
g[pts[i].id].emplace_back(pts[i].id, pts[i - 1].id, cost(i, i - 1));
}
if (i + 1 < m + 2) {
g[pts[i].id].emplace_back(pts[i].id, pts[i + 1].id, cost(i, i + 1));
}
}
std::sort(pts + 2, pts + 2 + m,
[&](const Point &a, const Point &b) { return a.id < b.id; });
std::cout << dijkstra(0, 1)[1] << "\n";
return 0;
}
| 2,300 | CPP |
n,m=map(int,input().split(' '))
l=sorted(list(map(int,input().split(' '))))
minm=l[m-1]-l[0]
t=m-n+1
for i in range(t):
minm=min(minm,l[n-1+i]-l[i])
print(minm)
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long int MAXN = 2e5 + 10, INF = 8e18, MOD = 1e9 + 7;
long long int n, m, ans, par[MAXN], par2[MAXN], cnt;
long long int u, v, w;
map<long long int, vector<pair<long long int, long long int>>> E;
vector<pair<long long int, long long int>> vec, chg;
set<long long int> st;
long long int Find(long long int u) {
if (par[u] == -1) return u;
return par[u] = Find(par[u]);
}
long long int Find2(long long int u) {
if (par2[u] == -1) return u;
return par2[u] = Find2(par2[u]);
}
long long int Union(long long int u, long long int v, long long int w) {
long long int pu = Find2(u), pv = Find2(v);
if (pu != pv) {
par2[pv] = pu;
chg.push_back({pv, pu});
st.insert(pu);
} else {
long long int pu2 = Find(u), pv2 = Find(v);
if (pu2 == pv2) {
return 0;
}
if (st.count(pu)) {
cnt++;
E[w + 1].push_back({u, v});
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
fill(par, par + MAXN, -1);
fill(par2, par2 + MAXN, -1);
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
cin >> u >> v >> w;
E[w].push_back({u, v});
}
for (auto i : E) {
vec = i.second;
st.clear();
chg.clear();
cnt = 0;
for (pair<long long int, long long int> e : vec) {
Union(e.first, e.second, i.first);
}
ans += cnt;
for (pair<long long int, long long int> j : chg) {
par[j.first] = j.second;
}
}
cout << ans << "\n";
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int MAXN = 300005;
const long long mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
vector<int> a[MAXN];
vector<int> b[MAXN];
int n;
struct Node {
int l, r;
int val;
int val1;
} node[MAXN << 2];
int aa[MAXN];
int bb[MAXN];
int book[MAXN];
void pushup(int i) {
node[i].val = min(node[i << 1].val, node[i << 1 | 1].val);
node[i].val1 = max(node[i << 1].val1, node[i << 1 | 1].val1);
}
void build(int l, int r, int i) {
node[i].l = l;
node[i].r = r;
if (l == r) {
node[i].val = bb[l];
node[i].val1 = bb[l];
return;
}
int mid = (l + r) / 2;
build(l, mid, i << 1);
build(mid + 1, r, i << 1 | 1);
pushup(i);
}
int query(int l, int r, int i, int f) {
if (node[i].l >= l && node[i].r <= r) {
if (f)
return node[i].val;
else
return node[i].val1;
}
int mid = (node[i].r + node[i].l) / 2;
if (f == 1) {
int ans = inf;
if (l <= mid) {
ans = query(l, r, i << 1, f);
}
if (r >= mid + 1) {
ans = min(ans, query(l, r, i << 1 | 1, f));
}
return ans;
} else {
int ans = 0;
if (l <= mid) {
ans = query(l, r, i << 1, f);
}
if (r >= mid + 1) {
ans = max(ans, query(l, r, i << 1 | 1, f));
}
return ans;
}
}
void update(int i, int x, int tt) {
if (node[i].l == node[i].r) {
if (tt == inf)
node[i].val = tt;
else
node[i].val1 = tt;
return;
}
int mid = (node[i].r + node[i].l) / 2;
if (x <= mid)
update(i << 1, x, tt);
else
update(i << 1 | 1, x, tt);
pushup(i);
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
a[i].clear();
b[i].clear();
}
for (int i = 1; i <= n; i++) {
scanf("%d", &bb[i]);
b[bb[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
book[i] = 0;
scanf("%d", &aa[i]);
a[aa[i]].push_back(i);
}
int flag = 0;
for (int i = 1; i <= n; i++) {
if (a[i].size() != b[i].size()) {
flag = 1;
break;
}
for (int j = 0; j < a[i].size(); j++) {
book[a[i][j]] = b[i][j];
}
}
if (flag) {
printf("NO\n");
continue;
}
build(1, n, 1);
for (int i = 1; i <= n; i++) {
int t = book[i];
int minn = query(1, t, 1, 1);
if (minn == aa[i]) {
update(1, t, inf);
} else {
flag = 1;
break;
}
}
if (flag) {
flag = 0;
for (int i = n; i >= 1; i--) {
int t = book[i];
int maxn = query(t, n, 1, 0);
if (maxn == aa[i]) {
update(1, t, 0);
} else {
flag = 1;
break;
}
}
if (flag) {
printf("NO\n");
} else
printf("YES\n");
} else
printf("YES\n");
}
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long num[110];
long long au[110];
long long a[110];
long long cnt;
bool cmp(long long x, long long y) { return x > y; }
int main() {
cin >> n >> m;
long long sum = 0;
for (int i = 1; i <= n; i++) {
cin >> num[i];
sum += num[i];
}
for (int i = 1; i <= m; i++) {
cin >> au[i];
sum -= num[au[i]];
a[++cnt] = num[au[i]];
}
sort(a + 1, a + 1 + m, cmp);
for (int i = 1; i <= m; i++)
if (sum >= a[i])
sum += sum;
else
sum += a[i];
cout << sum << endl;
return 0;
}
| 1,400 | CPP |
######################################################################
# Write your code here
import sys
from math import *
input = sys.stdin.readline
#import resource
#resource.setrlimit(resource.RLIMIT_STACK, [0x10000000, resource.RLIM_INFINITY])
#sys.setrecursionlimit(0x100000)
# Write your code here
RI = lambda : [int(x) for x in sys.stdin.readline().strip().split()]
rw = lambda : input().strip().split()
ls = lambda : list(input().strip()) # for strings to list of char
from collections import defaultdict as df
import heapq
#heapq.heapify(li) heappush(li,4) heappop(li)
#import random
#random.shuffle(list)
infinite = float('inf')
#######################################################################
n,m=RI()
l=RI()
k=RI()
l.sort()
s=l[0]*2
s=max(s,l[n-1])
k.sort()
if(s<k[0]):
print(s)
else:
print(-1)
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
#include <iostream>
#include <set>
#define vi vector<int>
#define ve vector
#define ll long long
#define vf vector<float>
#define vll vector<pair<ll,ll>>
#define ii pair<int,int>
#define vvi vector<vi>
#define vii vector<ii>
#define gii greater<ii>
#define pii pair<int,int>
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define INF 1e9
#define optmise ios_base::sync_with_stdio(false);cin.tie(NULL);
using namespace std;
int dp[25][550][550];
int main()
{
optmise;
int n,m,k;
cin >> n >> m >> k;
int hor[n][m], ver[n][m];
if(k%2 == 1){
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < m; ++j)
{
cout << -1 << " ";
}
cout << endl;
}
} else {
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < m-1; ++j)
{
int a;
cin >> a;
hor[i][j] = a;
}
}
for (int i = 0; i < n-1; ++i)
{
for (int j = 0; j < m; ++j)
{
int a;
cin >> a;
ver[i][j] = a;
}
}
k /= 2;
for (int l = 1; l <= k; ++l)
{
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < m; ++j)
{
dp[l][i][j] = INF;
if(i > 0)
dp[l][i][j] = min(dp[l][i][j], dp[l-1][i-1][j] + ver[i-1][j]);
if(j > 0)
dp[l][i][j] = min(dp[l][i][j], dp[l-1][i][j-1] + hor[i][j-1]);
if(i < n-1)
dp[l][i][j] = min(dp[l][i][j], dp[l-1][i+1][j] + ver[i][j]);
if(j < m-1)
dp[l][i][j] = min(dp[l][i][j], dp[l-1][i][j+1] + hor[i][j]);
}
}
}
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < m; ++j)
{
cout << dp[k][i][j]*2 << " ";
}
cout << endl;
}
}
}
| 1,800 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:64000000")
using namespace std;
struct Lesson {
long long L, R;
int D, N;
Lesson() {}
Lesson(long long L, long long R, int D, int N) : L(L), R(R), D(D), N(N) {}
bool operator<(const Lesson& lesson) const { return D < lesson.D; }
};
struct Prev {
int num, exc;
Prev() {}
Prev(int num, int exc) : num(num), exc(exc) {}
};
long long dp[55][55][111];
Prev pr[55][55][111];
int main() {
int need, m, k;
scanf("%d %d %d", &need, &m, &k);
vector<Lesson> v(m);
for (int(i) = 0; (i) < (m); (i)++) {
long long L, R;
int D;
cin >> L >> R >> D;
v[i] = Lesson(L, R, D, i + 1);
}
sort((v).begin(), (v).end());
memset(dp, 0, sizeof(dp));
memset(pr, -1, sizeof(pr));
for (int(i) = 0; (i) < (m); (i)++)
for (int(j) = 0; (j) < ((int)(v[i].R - v[i].L) + 1); (j)++)
dp[1][i][j] = v[i].L + j;
for (int done = 1; done < need; done++) {
for (int cur = 0; cur < m; cur++) {
for (int exc = 0; exc <= (int)(v[cur].R - v[cur].L); exc++) {
long long did = v[cur].L + exc;
if (dp[done][cur][exc] == 0) continue;
for (int nxt = cur + 1; nxt < m; nxt++) {
if (v[nxt].D > v[cur].D) {
long long val[2];
val[0] = did + k;
if (did > (long long)(1e16 + 10)) {
val[1] = -1;
} else {
val[1] = did * k;
}
for (int(j) = 0; (j) < (2); (j)++) {
if (v[nxt].L <= val[j] && val[j] <= v[nxt].R) {
int t = (int)(val[j] - v[nxt].L);
if (dp[done + 1][nxt][t] < dp[done][cur][exc] + val[j]) {
dp[done + 1][nxt][t] = dp[done][cur][exc] + val[j];
pr[done + 1][nxt][t] = Prev(cur, exc);
}
}
}
}
}
}
}
}
int B = -1, C = -1;
for (int(i) = 0; (i) < (111); (i)++)
for (int(j) = 0; (j) < (111); (j)++) {
if (dp[need][i][j] > 0 && (B == -1 || dp[need][i][j] > dp[need][B][C])) {
B = i, C = j;
}
}
if (B != -1) {
vector<pair<int, long long> > res(need);
for (int A = need; A >= 1; A--) {
res[A - 1] = make_pair(v[B].N, v[B].L + C);
int b = B, c = C;
B = pr[A][b][c].num;
C = pr[A][b][c].exc;
}
cout << "YES\n";
for (int(i) = 0; (i) < ((int)(res).size()); (i)++) {
cout << res[i].first << " " << res[i].second << "\n";
}
} else {
cout << "NO\n";
}
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int tot(int h, int m) { return (60 * h + m); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int i, j, k, n, s;
cin >> n >> s;
vector<pair<int, int> > v;
int day = 0;
for (int i = 0; i < n; i++) {
int h, m;
cin >> h >> m;
if (i > 0 and h < v[i - 1].first) day++;
v.push_back(make_pair(day * 24 + h, m));
}
if (tot(v[0].first, v[0].second) >= s + 1) {
cout << "0 0";
return 0;
}
for (int i = 1; i < n; i++) {
int t1, t2;
t1 = tot(v[i - 1].first, v[i - 1].second);
t2 = tot(v[i].first, v[i].second);
if (t2 - t1 >= 2 * s + 2) {
int ans = t1 + 1 + s;
int hh = ans / 60;
int mm = ans % 60;
cout << hh << " " << mm;
return 0;
}
}
int ans = tot(v[n - 1].first, v[n - 1].second) + 1 + s;
int hh = ans / 60;
int mm = ans % 60;
cout << hh << " " << mm;
return 0;
}
| 1,100 | CPP |
n=int(input())
a=list(map(int, input().split()))
a=[ai-1 for ai in a]
a[n:n] = [n - 1]
dp=[0]*n
ans=0
i=n-2
nmax=2**17
tree=[[0,0]]*2*nmax;
#Build Segment tree
j=0
while j<n:
tree[nmax + j] = [a[j], j]
j=j+1
j=nmax-1
while j>0:
tree[j]=max(tree[j*2],tree[j*2+1])
j=j-1
#get max of a interval [left, right]
def get(left, right):
ans=[-1,-1]
left=left+nmax
right=right+nmax+1
while left<right:
if (left & 1):
ans = max(ans, tree[left])
left = left + 1
if (right & 1):
right = right - 1
ans = max(ans, tree[right])
left = left // 2
right = right // 2
return ans[1]
while i>=0:
m = get(i + 1, a[i]);
dp[i] = dp[m] - (a[i] - m) + n - i - 1
ans += dp[i]
i=i-1
print(ans) | 2,300 | PYTHON3 |
#!/usr/bin/python3
count = 0
for _ in range(int(input())):
x, y, z = map(int, input().split())
if (x == 1 and y == 1) or (x == 1 and z == 1) or (z == 1 and y == 1):
count += 1
print(count)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
using namespace std;
const int N = 110002;
const int Lg = 16;
int n, a[N], m;
int l[Lg][N * 3], r[Lg][N * 3];
int tmin[Lg][N * 3 * 4], tmax[Lg][N * 3 * 4];
int x, y;
void read(int &x) {
char ch = getchar();
x = 0;
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = (x << 3) + (x << 1) + ch - '0';
}
inline char nc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline void _read(int &sum) {
char ch = nc();
sum = 0;
while (!(ch >= '0' && ch <= '9')) ch = nc();
while (ch >= '0' && ch <= '9') sum = sum * 10 + ch - 48, ch = nc();
}
inline int Min(int a, int b) { return a < b ? a : b; }
inline int Max(int a, int b) { return a > b ? a : b; }
int build(int t[], int a[], int node, int L, int r, int (*M)(int, int)) {
int mid = (L + r) >> 1;
return L == r ? t[node] = a[L]
: t[node] = M(build(t, a, (node << 1), L, mid, M),
build(t, a, (node << 1 | 1), mid + 1, r, M));
}
int query(int t[], int node, int L, int r, int (*M)(int, int)) {
if (L >= x && r <= y) return t[node];
int mid = (L + r) >> 1, ans = -1, v;
if (x <= mid) {
v = query(t, (node << 1), L, mid, M);
ans = (ans == -1 ? v : M(ans, v));
};
if (y > mid) {
v = query(t, (node << 1 | 1), mid + 1, r, M);
ans = (ans == -1 ? v : M(ans, v));
};
return ans;
}
int main() {
_read(n);
m = n * 3;
for (int i = (0); i < (n); i++) _read(a[i]);
for (int i = (0); i < (m); i++)
l[0][i] = max(i - a[i % n], 0), r[0][i] = min(i + a[i % n], m - 1);
build(tmin[0], l[0], 1, 0, m - 1, Min);
build(tmax[0], r[0], 1, 0, m - 1, Max);
for (int i = (1); i < (Lg); i++) {
for (int j = (0); j < (m); j++) {
x = l[i - 1][j], y = r[i - 1][j];
l[i][j] = query(tmin[i - 1], 1, 0, m - 1, Min);
r[i][j] = query(tmax[i - 1], 1, 0, m - 1, Max);
}
build(tmin[i], l[i], 1, 0, m - 1, Min);
build(tmax[i], r[i], 1, 0, m - 1, Max);
}
for (int i = (n); i < (n << 1); i++) {
int L = i, R = i, ans = 0;
for (int j = (Lg - 1); j >= (0); j--) {
x = L, y = R;
int LL = query(tmin[j], 1, 0, m - 1, Min),
RR = query(tmax[j], 1, 0, m - 1, Max);
if (RR - LL + 1 < n) {
ans += 1 << j;
L = LL;
R = RR;
if (R - L + 1 == n - 1) break;
}
}
if (n == 1) ans = -1;
printf("%d ", ans + 1);
}
puts("");
return 0;
}
| 2,900 | CPP |
#872
for _ in range(int(input())):
n=int(input())
ss=0
if(n==1):
print(0)
else:
while(n%6==0):
ss+=1
n//=6
while(n%3==0):
ss+=2
n//=3
if(n==1):
print(ss)
else:
print(-1) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, k, a, b, c, v;
cin >> a >> b >> c;
v = a * c;
v -= b * c;
cout << (v - 1) / b + 1;
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MX = 26 * 205, INF = 1e6;
long long dp[205][MX];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n = 0, k = 0;
cin >> n >> k;
vector<pair<long long, long long> > ft;
long long a = 0;
for (long long i = 0; i < n; i++) {
cin >> a;
long long curt = 0, curf = 0;
for (long long j = 2; j <= 5; j++) {
while (a % j == 0) {
a /= j;
curt += (j == 2);
curf += (j == 5);
}
}
ft.push_back(make_pair(curt, curf));
}
for (long long i = 0; i <= k; i++)
for (long long j = 1; j < MX; j++) dp[i][j] = -INF;
for (long long i = 0; i < n; i++) {
long long x = ft[i].second, y = ft[i].first;
for (long long j = min(k - 1, i); j >= 0; j--)
for (long long l = 0; l + x < MX; l++)
dp[j + 1][l + x] = max(dp[j + 1][l + x], dp[j][l] + y);
}
long long ans = 0;
for (long long i = 0; i < MX; i++) ans = max(ans, min(dp[k][i], i));
cout << ans;
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> a(n);
for (auto &x : a) cin >> x;
map<long long, long long> d;
d[n - 1] = a[n - 1];
for (long long i = n - 2; i >= 0; i--) {
d[i] = max(d[i + 1] - 1, a[i]);
}
vector<long long> b(n);
long long k = b[0] = 1;
for (long long i = (1); i < (long long)(n); i++) {
if (d[i] >= k) {
k++;
}
b[i] = k;
}
long long total = 0;
for (long long i = (0); i < (long long)(n); i++) {
total += b[i] - a[i] - 1;
}
printf("%lld\n", total);
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i;
scanf("%lld", &n);
long long int wn;
wn = 1;
for (i = 2; i * i <= n; i++) {
if (n % i == 0) {
if ((n / i) % i == 0) {
n = n / i;
i--;
}
}
}
printf("%lld\n", n);
}
| 1,300 | CPP |
d=int(input())
n=int(input())
a=list(map(int,input().split()))
z=0
for i in range(n-1):
if(a[i]<d):
z=z+d-a[i]
print(z) | 1,000 | PYTHON3 |
for _ in range(int(input())):
n=int(input())
ff=0
for i in range(n+1):
f=0
for j in range(n+1):
k=n-i*3-j*5
if k%7==0 and i>=0 and j>=0 and k>=0:
print(i,j,k//7)
f=1; break
if f: ff=1; break
if not ff: print(-1) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long a[200005];
int dp[200005];
int main() {
int n, m, k, i, j;
cin >> n >> m >> k;
for (i = 0; i < n; i++) scanf("%lld", a + i + 1);
for (i = 2; i <= n; i++) a[i] += a[i - 1];
dp[n] = 1;
for (i = n - 1; i > 0; i--) {
j = lower_bound(a + i, a + n + 1, a[i - 1] + k + 1) - a;
dp[i] = 1 + dp[j];
if (dp[i] > m) break;
}
printf("%d\n", n - i);
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 1e2 + 10;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int a[N][N];
void check(int n, int m) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int o = 0; o < 4; o++) {
int x = a[i][j];
int y = a[i + dx[o]][j + dy[o]];
if (abs(x - y) == 1) return;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%d%c", a[i][j], " \n"[j == m]);
}
}
exit(0);
}
void solve(vector<int>& v, int n, int m) {
random_shuffle(v.begin(), v.end());
int ptr = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
a[i][j] = v[ptr++];
}
}
check(n, m);
}
int main() {
int n, m;
cin >> n >> m;
memset((a), (0x3f), sizeof(a));
vector<int> v;
for (int i = 1; i <= n * m; i++) v.push_back(i);
int cnt = 1000;
while (cnt--) {
solve(v, n, m);
}
puts("-1");
return 0;
}
| 1,800 | CPP |
n = input()
cc = input().split(" ")
sum =0
for i in range(len(cc)):
sum = sum + (int(cc[i]) *((i)*4))
print(sum)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool dp[202][202][202];
int n, i, j, k;
bool vis[3];
string s, ans = "";
int g, b, r;
void rec(int blue, int green, int red) {
if (blue + green + red <= 1) {
if (blue && !vis[0]) {
ans += "B";
vis[0] = true;
}
if (green && !vis[1]) {
ans += "G";
vis[1] = true;
}
if (red && !vis[2]) {
ans += "R";
vis[2] = true;
}
return;
}
if (dp[blue][green][red]) return;
if (blue >= 2) rec(blue - 1, green, red);
if (green >= 2) rec(blue, green - 1, red);
if (red >= 2) rec(blue, green, red - 1);
if (blue >= 1 && green >= 1) rec(blue - 1, green - 1, red + 1);
if (blue >= 1 && red >= 1) rec(blue - 1, green + 1, red - 1);
if (green >= 1 && red >= 1) rec(blue + 1, green - 1, red - 1);
dp[blue][green][red] = true;
}
int main() {
cin >> n;
cin >> s;
for (i = 0; i < n; i++) {
if (s[i] == 'R')
r++;
else if (s[i] == 'G')
g++;
else
b++;
}
rec(b, g, r);
sort(ans.begin(), ans.end());
cout << ans << endl;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void mine(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void maxe(T1 &x, T2 y) {
if (x < y) x = y;
}
ostream &operator<<(ostream &a, const vector<long long> &b) {
for (auto k : b) cout << k << ' ';
return a;
}
const long long MOD = 1000000007;
const long long INF = 1000000050;
const long long BIG = (long long)2e18 + 50;
const long long MX = 200010;
const double EPS = 1e-9;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long n, k;
long long f(long long x) {
if (x > n) return 0;
long long res = 0;
if (x % 2 == 0) res = f(x + 1);
long long len = 0;
while ((x << (len + 1)) <= n) {
res += 1ll << len;
++len;
}
long long delta = n - (x << len) + 1;
delta = min(delta, 1ll << len);
return (res + delta);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
long long l = 0;
long long r = n / 2 + 3;
while (r - l > 1) {
long long m = (r + l) / 2;
if (f(2 * m + 1) >= k)
l = m;
else
r = m;
}
long long res1 = 2 * l + 1;
l = 1;
r = n / 2 + 3;
while (r - l > 1) {
long long m = (r + l) / 2;
if (f(2 * m) >= k)
l = m;
else
r = m;
}
long long res2 = 2 * l;
if (f(res2) < k) res2 = -INF;
if (f(res1) < k) res1 = -INF;
cout << max(res1, res2);
assert(res2 != -INF || res1 != -INF);
}
| 2,100 | CPP |
a = int(input())
b = int(input())
c = int(input())
ans = a+b+c
ans = max(ans, a*b*c)
ans = max(ans, a*(b+c))
ans = max(ans, (a+b)*c)
print(ans)
| 1,000 | PYTHON3 |
t = int(input())
while t>0:
t=t-1
s = input()
cf = []
sums=0
for ele in s:
if ele == '+':
sums+=1
else:
sums-=1
cf.append(sums)
res = len(s)
curr=0
for i in range(len(cf)):
if s[i] == '+':
curr += 1
else:
if curr==0:
res += i+1
else:
curr -=1
print(res)
| 1,300 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.