solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1000, OO = 1e9, M = 1e9 + 7, P = 6151, SQ = 1000, lg = 12;
int dp[(1 << lg)][(1 << lg)];
vector<int> v[N];
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--, y--;
v[x].push_back(y);
v[y].push_back(x);
dp[(1 << x) + (1 << y)][(1 << x) + (1 << y)] = 1;
}
for (int msk = 1; msk < (1 << n); msk++) {
if (__builtin_popcount(msk) <= 2) continue;
for (int sub = 1; sub < (1 << n); sub++) {
if ((sub & -sub) == sub || (msk & sub) != sub) continue;
for (int i = 0; i < n; i++) {
if (!(sub & (1 << i))) continue;
int sb = sub ^ (1 << i), mk = msk ^ (1 << i);
for (auto u : v[i]) {
if (!(mk & (1 << u)) || (sub & (1 << u))) continue;
dp[msk][sub] += (dp[mk][sb] + dp[mk][sb ^ (1 << u)]);
}
}
int sz = __builtin_popcount(sub);
dp[msk][sub] /= sz;
}
}
int ans = 0, msk = (1 << n) - 1;
for (int sub = 0; sub < (1 << n); sub++) {
if (__builtin_popcount(sub) != k) continue;
ans += dp[msk][sub];
}
cout << ans << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, kangaroo[500000];
int main() {
cin >> n;
for (int _n = n, i = 0; i < _n; ++i) cin >> kangaroo[i];
sort(kangaroo, kangaroo + n);
int middle = (n / 2) - !(n % 2);
int i = middle, j = n - 1;
while (i >= 0 && j > middle) {
if (kangaroo[i] * 2 <= kangaroo[j]) j--;
i--;
}
cout << j + 1 << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
char c[150];
int a[150];
int main() {
memset(a, 0, sizeof(a));
int n;
scanf("%d", &n);
getchar();
for (int i = 0; i < n; i++) {
scanf("%c", &c[i]);
a[c[i]]++;
}
printf("%d\n", 2 * (min(a['U'], a['D']) + min(a['R'], a['L'])));
}
| 8 | CPP |
N = int(input())
i = 1
K = []
while(1):
k = i * (i+1) // 2
if k > 10**5:
break
K.append(k)
i+=1
if not N in K:
print ('No')
exit()
print ('Yes')
S = [[],[]]
i = 0
for n in range(1,N+1):
S[i].append(n)
S[-1].append(n)
i+=1
if n in K:
if n==N:
break
i = 0
S.append([])
print(len(S))
for s in S:
print(str(len(s)) + ' ' + ' '.join(map(str,s)))
| 0 | PYTHON3 |
import sys
input = sys.stdin.readline
n,m = map(int,input().split())
G = [[] for _ in range(n)]
for _ in range(m):
u,v = map(int,input().split())
u -= 1
v -= 1
if u >= 48 or v >= 48:
continue
G[u].append(v)
G[v].append(u)
if n >= 48:
G = G[:48]
def ok(a,b,c,d,e):
allfd = True
nofd = True
people = [a,b,c,d,e]
for x in people:
for y in people:
if x == y:
continue
if x in G[y]:
nofd = False
else:
allfd = False
return allfd or nofd
sz = len(G)
for a in range(sz):
for b in range(a+1,sz):
for c in range(b+1,sz):
for d in range(c+1,sz):
for e in range(d+1,sz):
if ok(a,b,c,d,e):
ans = [a,b,c,d,e]
print(*[x+1 for x in ans])
exit()
print(-1)
| 12 | PYTHON3 |
m = 10**9
def compute_lcm(x, y):
if x > y:
greater = x
else:
greater = y
while(True):
if((greater % x == 0) and (greater % y == 0)):
lcm = greater
break
greater += 1
return lcm
def computeGCD(x, y):
while(y):
x, y = y, x % y
return x
for _ in range(int(input())):
x = int(input())
for i in range(1,m):
comp = x - i
if comp < 0: break
if compute_lcm(i,comp) + computeGCD(i,comp) == x:
print(i,comp)
break
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long masks[9][9][1563];
bool good[9][9][9][9];
bool selfgood[9][9];
int ans;
int c[9];
void rec(int cur) {
if (cur == k) {
ans++;
return;
}
for (int i = 0; i <= cur; i++) {
bool ok = selfgood[cur][i];
for (int j = 0; j < cur && ok; j++)
if (!good[j][c[j]][cur][i]) {
ok = false;
break;
}
if (ok) {
c[cur] = i;
rec(cur + 1);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
vector<vector<pair<int, int>>> adj(n);
while (m--) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
adj[u].emplace_back(w, v);
}
for (int i = 0; i < n; i++) sort(adj[i].begin(), adj[i].end());
memset(masks, 0, sizeof(masks));
memset(selfgood, true, sizeof(selfgood));
for (int i = 0; i < n; i++) {
int d = adj[i].size();
for (int j = 0; j < d; j++) {
int v = adj[i][j].second;
int x = v >> 6;
int y = v & 63;
if (masks[d - 1][j][x] & (1LL << y)) selfgood[d - 1][j] = false;
masks[d - 1][j][x] |= (1LL << y);
}
}
memset(good, true, sizeof(good));
for (int i = 0; i < k; i++)
for (int j = 0; j <= i; j++)
for (int kk = i + 1; kk < k; kk++)
for (int t = 0; t <= kk; t++) {
bool ok = true;
for (int a = 0; a < 1563; a++)
if (masks[i][j][a] & masks[kk][t][a]) {
ok = false;
break;
}
if (!ok) {
good[i][j][kk][t] = good[kk][t][i][j] = false;
}
}
ans = 0;
rec(0);
cout << ans << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
const long long mod = 1e9 + 7;
using namespace std;
int main() {
int n;
cin >> n;
map<long long, vector<pair<long long, long long>>> idxs;
map<long long, vector<pair<long long, long long>>> highests;
long long temphigh = 0, tempidx = 0;
for (int i = 0; i < n; i++) {
long long c, s;
cin >> c >> s;
idxs[c].push_back({s, i + 1});
if (s > temphigh) {
temphigh = s;
tempidx = i + 1;
}
}
long long mx = 0;
for (auto it : idxs) {
long long curr = 0;
sort(it.second.rbegin(), it.second.rend());
for (int i = 1; i <= it.second.size(); i++) {
int idx = i - 1;
it.second[idx].first;
curr += it.second[idx].first;
highests[i].push_back({curr, it.first});
}
mx = max(mx, (long long)it.second.size());
}
long long high = 0;
long long c1 = -1, h1 = 0;
long long c2 = -1, h2 = 0;
bool found = false;
for (int i = 1; i <= mx; i++) {
sort(highests[i].rbegin(), highests[i].rend());
if (highests[i].size() >= 2) {
if (highests[i][0].first + highests[i][1].first > high) {
high = highests[i][0].first + highests[i][1].first;
c1 = highests[i][0].second;
h1 = i;
c2 = highests[i][1].second;
h2 = i;
found = true;
}
}
if (i - 1 >= 1) {
int q = 0;
while (q < highests[i - 1].size() &&
highests[i - 1][q].second == highests[i][0].second)
q++;
if (q < highests[i - 1].size()) {
if (highests[i].size() && highests[i - 1].size()) {
if (highests[i][0].first + highests[i - 1][q].first > high) {
high = highests[i][0].first + highests[i - 1][q].first;
c1 = highests[i][0].second;
h1 = i;
c2 = highests[i - 1][q].second;
h2 = i - 1;
found = true;
}
}
}
}
if (i + 1 <= n) {
int q = 0;
while (q < highests[i + 1].size() &&
highests[i + 1][q].second == highests[i][0].second)
q++;
if (q < highests[i + 1].size()) {
if (highests[i].size() && highests[i + 1].size()) {
if (highests[i][0].first + highests[i + 1][q].first > high) {
high = highests[i][0].first + highests[i + 1][q].first;
c1 = highests[i + 1][q].second;
h1 = i + 1;
c2 = highests[i][0].second;
h2 = i;
found = true;
}
}
}
}
}
if (!found) {
cout << temphigh << '\n' << 1 << '\n' << tempidx;
return 0;
}
cout << high << '\n';
cout << h1 + h2 << '\n';
sort(idxs[c1].rbegin(), idxs[c1].rend());
sort(idxs[c2].rbegin(), idxs[c2].rend());
if (h1 == h2) {
for (int i = 0; i < h2; i++)
cout << idxs[c1][i].second << ' ' << idxs[c2][i].second << ' ';
} else {
cout << idxs[c1][0].second << ' ';
for (int i = 0; i < h2; i++) {
cout << idxs[c2][i].second << ' ' << idxs[c1][i + 1].second << ' ';
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, x, cnt = 0;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
if ((x - x / i * i) == 0 && (x / i) <= n) cnt++;
}
cout << cnt << endl;
return 0;
}
| 7 | CPP |
# ===============================================================================================
# importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
# If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
# If the element is already present in the list,
# the right most position where element has to be inserted is returned
# ==============================================================================================
# fast I/O 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")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
# ===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
def wrapped_func(*args, **kwargs):
if stack: return f(*args, **kwargs)
to = f(*args, **kwargs)
while True:
if type(to) is GeneratorType:
stack.append(to)
to = next(to)
continue
stack.pop()
if not stack: break
to = stack[-1].send(to)
return to
return wrapped_func
###### END ITERATE RECURSION ####
# ===============================================================================================
# some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") # for fast input
def integer(): return int(inp())
def out(var): sys.stdout.write(str(var)) # for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def zerolist(n): return [0] * n
def nextline(): out("\n") # as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def printlist(a):
for p in range(0, len(a)):
out(str(a[p]) + ' ')
from functools import reduce
def factors(n):
return set(reduce(list.__add__,
([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
def solve():
n=int(inp())
ar=lis()
c=counter(ar)
a1=[]
a2=[]
for i in c.keys():
if c[i]>=3:
print("NO")
exit()
if c[i]==2:
a1.append(i)
a2.append(i)
else:
a1.append(i)
print("YES")
a1.sort()
a2.sort(reverse=True)
print(len(a1))
printlist(a1)
print()
print(len(a2))
printlist(a2)
#testcase(int(inp()))
solve() | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[222222];
vector<pair<int, int> > lower, upper, polygon;
long double area(pair<long long, long long> a, pair<long long, long long> b,
pair<long long, long long> c) {
return 0.5 * (a.first * b.second + a.second * c.first + b.first * c.second -
c.first * b.second - c.second * a.first - b.first * a.second);
}
void solve(pair<long long, long long> a, pair<long long, long long> b,
pair<long long, long long> c) {
cout << a.first + b.first - c.first << " " << a.second + b.second - c.second
<< "\n";
cout << -a.first + b.first + c.first << " " << -a.second + b.second + c.second
<< "\n";
cout << a.first - b.first + c.first << " " << a.second - b.second + c.second
<< "\n";
}
int main() {
ios_base::sync_with_stdio(0);
long long s;
int n;
cin >> n >> s;
for (int i = 1; i <= n; i++) cin >> a[i].first >> a[i].second;
sort(a + 1, a + n + 1);
upper.push_back(a[1]);
lower.push_back(a[1]);
for (int i = 2; i <= n; i++) {
if (i == n || area(a[1], a[i], a[n]) < 0) {
while (upper.size() >= 2 &&
area(upper[upper.size() - 2], upper[upper.size() - 1], a[i]) >= 0)
upper.pop_back();
upper.push_back(a[i]);
}
if (i == n || area(a[1], a[i], a[n]) > 0) {
while (lower.size() >= 2 &&
area(lower[lower.size() - 2], lower[lower.size() - 1], a[i]) <= 0)
lower.pop_back();
lower.push_back(a[i]);
}
}
for (int i = 0; i < upper.size(); i++) polygon.push_back(upper[i]);
for (int i = (int)(lower.size()) - 2; i > 0; i--) polygon.push_back(lower[i]);
int m = polygon.size();
int nm1 = 0, nm2 = 0, nm3 = 0;
long double mx = 0;
for (int i = 0; i < m; i++) polygon.push_back(polygon[i]);
for (int i = 0; i < polygon.size() / 2; i++) {
int l = i + 2;
for (int j = i + 1; j < polygon.size() / 2; j++) {
while (l < polygon.size() - 1 &&
abs(area(polygon[i], polygon[j], polygon[l])) <
abs(area(polygon[i], polygon[j], polygon[l + 1])))
l++;
if (abs(area(polygon[i], polygon[j], polygon[l])) > mx) {
mx = abs(area(polygon[i], polygon[j], polygon[l]));
nm1 = i;
nm2 = j;
nm3 = l;
}
}
}
solve(polygon[nm1], polygon[nm2], polygon[nm3]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct node {
bool bracket, flag;
vector<int> op;
};
map<string, node> def;
map<char, int> op;
void del_space(string tmp) {
int x = tmp.find_first_not_of(" ");
tmp.erase(0, x);
x = tmp.find_last_not_of(" ");
tmp.erase(x + 1, tmp.length());
string s = "";
for (int i = 0; i < tmp.length(); i++) {
if (tmp[i] != ' ') {
s += tmp[i];
} else {
if (tmp[i + 1] != ' ') s += tmp[i];
}
}
x = s.find("define") + 7;
int y = x;
while (s[y] != ' ') y++;
string s1, s2;
s1.append(s.begin() + x, s.begin() + y);
for (int i = y + 1; i < s.length(); i++) {
if (s[i] != ' ') s2 += s[i];
}
node tmp_node;
tmp_node.flag = 0;
int cnt = 0;
for (int i = 0; i < s2.length(); i++) {
if (s2[i] == '(') cnt++;
if (s2[i] == ')') cnt--;
if (op[s2[i]] && cnt == 0) {
tmp_node.op.push_back(op[s2[i]]);
}
}
for (int i = 0; i < s2.length(); i++) {
if (s2[i] == '*' || s2[i] == '/') {
string ss1, ss2;
bool bracket = 0;
if (s2[i + 1] == '(') bracket = 1;
for (int j = i + 1; s2[j] != ')' && !op[s2[j]] && j < s2.length(); j++) {
ss1 += s2[j];
}
map<string, node>::iterator it = def.find(ss1);
if (it != def.end()) {
bracket = bracket | def[ss1].bracket;
if (def[ss1].flag == 1) {
tmp_node.flag = 1;
}
if (bracket == 0) {
for (int k = 0; k < def[ss1].op.size(); k++) {
if (def[ss1].op[k] == 1 || def[ss1].op[k] == 2) {
tmp_node.flag = 1;
}
}
}
}
bracket = 0;
for (int j = i - 1; s2[j] != '(' && !op[s2[j]] && j >= 0; j--) {
ss2 += s2[j];
}
reverse(ss2.begin(), ss2.end());
it = def.find(ss2);
if (it != def.end()) {
bracket = bracket | def[ss2].bracket;
if (def[ss2].flag == 1) {
tmp_node.flag = 1;
}
if (bracket == 0) {
for (int k = 0; k < def[ss2].op.size(); k++) {
if (def[ss2].op[k] == 1 || def[ss2].op[k] == 2) {
tmp_node.flag = 1;
}
}
}
}
}
if (s2[i] == '-') {
string ss1;
bool bracket = 0;
if (s2[i + 1] == '(') bracket = 1;
for (int j = i + 1; s2[j] != ')' && !op[s2[j]] && j < s2.length(); j++) {
ss1 += s2[j];
}
map<string, node>::iterator it = def.find(ss1);
if (it != def.end()) {
bracket = bracket | def[ss1].bracket;
if (def[ss1].flag == 1) {
tmp_node.flag = 1;
}
if (bracket == 0) {
for (int k = 0; k < def[ss1].op.size(); k++) {
if (def[ss1].op[k] == 1 || def[ss1].op[k] == 2) {
tmp_node.flag = 1;
}
}
}
}
}
if (s2[i] == '/') {
string ss1;
bool bracket = 0;
if (s2[i + 1] == '(') bracket = 1;
for (int j = i + 1; s2[j] != ')' && !op[s2[j]] && j < s2.length(); j++) {
ss1 += s2[j];
}
map<string, node>::iterator it = def.find(ss1);
if (it != def.end()) {
bracket = bracket | def[ss1].bracket;
if (def[ss1].flag == 1 || (bracket == 0 && !def[ss1].op.empty())) {
tmp_node.flag = 1;
}
}
}
}
tmp_node.bracket = 1;
cnt = 0;
if (s2[0] == '(') cnt++;
for (int i = 1; i < s2.length() - 1; i++) {
if (s2[i] == '(') cnt++;
if (s2[i] == ')') cnt--;
if (cnt == 0) tmp_node.bracket = 0;
}
def[s1] = tmp_node;
}
int main() {
op['+'] = 1;
op['-'] = 2;
op['*'] = 3;
op['/'] = 4;
int n, flag = 1;
cin >> n;
getchar();
while (n--) {
string tmp;
getline(cin, tmp);
del_space(tmp);
}
string tmp, exp;
getline(cin, tmp);
int x = tmp.find_first_not_of(" ");
tmp.erase(0, x);
x = tmp.find_last_not_of(" ");
tmp.erase(x + 1, tmp.length());
for (int i = 0; i < tmp.length(); i++) {
if (tmp[i] != ' ') {
exp += tmp[i];
}
}
for (map<string, node>::iterator it = def.begin(); it != def.end(); ++it) {
if (exp.find(it->first) != string::npos && it->second.flag == 1) {
cout << "Suspicious" << endl;
return 0;
}
}
for (int i = 0; i < exp.length(); i++) {
if (exp[i] == '*' || exp[i] == '/') {
string s1, s2;
bool bracket = 0;
if (exp[i + 1] == '(') bracket = 1;
for (int j = i + 1; exp[j] != ')' && !op[exp[j]] && j < exp.length();
j++) {
s1 += exp[j];
}
map<string, node>::iterator it = def.find(s1);
if (it != def.end()) {
bracket = bracket | def[s1].bracket;
if (def[s1].flag == 1) {
cout << "Suspicious" << endl;
return 0;
}
if (bracket == 0) {
for (int k = 0; k < def[s1].op.size(); k++) {
if (def[s1].op[k] == 1 || def[s1].op[k] == 2) {
cout << "Suspicious" << endl;
return 0;
}
}
}
}
bracket = 0;
for (int j = i - 1; exp[j] != '(' && !op[exp[j]] && j >= 0; j--) {
s2 += exp[j];
}
reverse(s2.begin(), s2.end());
it = def.find(s2);
if (it != def.end()) {
bracket = bracket | def[s2].bracket;
if (def[s2].flag == 1) {
cout << "Suspicious" << endl;
return 0;
}
if (bracket == 0) {
for (int k = 0; k < def[s2].op.size(); k++) {
if (def[s2].op[k] == 1 || def[s2].op[k] == 2) {
cout << "Suspicious" << endl;
return 0;
}
}
}
}
}
if (exp[i] == '-') {
string s1;
bool bracket = 0;
if (exp[i + 1] == '(') bracket = 1;
for (int j = i + 1; exp[j] != ')' && !op[exp[j]] && j < exp.length();
j++) {
s1 += exp[j];
}
map<string, node>::iterator it = def.find(s1);
if (it != def.end()) {
bracket = bracket | def[s1].bracket;
if (def[s1].flag == 1) {
cout << "Suspicious" << endl;
return 0;
}
if (bracket == 0) {
for (int k = 0; k < def[s1].op.size(); k++) {
if (def[s1].op[k] == 1 || def[s1].op[k] == 2) {
cout << "Suspicious" << endl;
return 0;
}
}
}
}
}
if (exp[i] == '/') {
string s1;
bool bracket = 0;
if (exp[i + 1] == '(') bracket = 1;
for (int j = i + 1; exp[j] != ')' && !op[exp[j]] && j < exp.length();
j++) {
s1 += exp[j];
}
map<string, node>::iterator it = def.find(s1);
if (it != def.end()) {
bracket = bracket | def[s1].bracket;
if (def[s1].flag == 1 || (bracket == 0 && !def[s1].op.empty())) {
cout << "Suspicious" << endl;
return 0;
}
}
}
}
cout << "OK" << endl;
return 0;
}
| 11 | CPP |
price, cost_of_first_banana, number_of_banana = map(int, input().split())
number_of_banana = number_of_banana * (number_of_banana+1)/2
borrow_money = price*number_of_banana - cost_of_first_banana
if borrow_money <= 0:
print("0")
else:
print(int(borrow_money)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char g[1010][1010];
int vis[1010];
int n;
void dfs(int u, char pat) {
vis[u] = 1;
for (int i = (1); i <= (n); ++i)
if (!vis[i] && g[u][i] == pat) dfs(i, pat);
}
int solve(int d) {
char pat = d ? '1' : '0';
memset(vis, 0, sizeof(vis));
int color = 0;
for (int i = (1); i <= (n); ++i) {
if (!vis[i]) dfs(i, pat), color++;
;
}
return color;
}
void gen(int num) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) g[i][j] = '0';
if (num == 0) return;
for (int i = (2); i <= (n); ++i) {
int x = i;
for (int j = 1; j < (n - i + 1) + 1; j++) {
g[x][j] = '1';
g[j][x] = '1';
x++;
num--;
if (num == 0) return;
}
}
}
void gen2(int num) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) {
if (i == j)
g[i][j] = '0';
else
g[i][j] = '1';
}
if (num == 0) return;
for (int i = (2); i <= (n); ++i) {
int x = i;
for (int j = 1; j < (n - i + 1) + 1; j++) {
g[x][j] = '0';
g[j][x] = '0';
x++;
num--;
if (num == 0) return;
}
}
}
void output() {
for (int i = (1); i <= (n); ++i) {
for (int j = (1); j <= (n); ++j) cout << g[i][j];
cout << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(20);
int a, b;
cin >> n >> a >> b;
if (a > 1 && b > 1) return 0 * puts("NO");
if (a == 1 && b == 1 && (n == 3 || n == 2)) return 0 * puts("NO");
cout << "YES\n";
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) g[i][j] = '0';
if (n == 1) return 0 * puts("0");
int mid = n * (n - 1) / 2;
if (a == 1 && b == 1) {
gen(n - 1);
} else {
if (a > 1) {
gen(n - a);
} else {
gen2(n - b);
}
}
output();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n >> x >> y;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int j = i - x;
int k = i + y;
if (j < 0) j = 0;
if (k > n - 1) k = n - 1;
int min = INT_MAX, index = -1;
for (int l = j; l <= k; l++) {
if (min > a[l]) {
min = a[l];
index = l;
}
}
if (index == i) {
cout << index + 1 << "\n";
break;
} else {
i = index - 1;
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x20202020;
const int mod = 1000000007;
template <class T>
inline void read(T& first) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (first = 0; c > 32; c = getchar()) first = first * 10 + c - '0';
if (fu) first = -first;
};
template <class T>
inline void read(T& first, T& second) {
read(first);
read(second);
}
template <class T>
inline void read(T& first, T& second, T& z) {
read(first);
read(second);
read(z);
}
template <class T>
inline void read(T& first, T& second, T& z, T& q) {
read(first);
read(second);
read(z);
read(q);
}
const int DX[] = {1, 0, -1, 0}, DY[] = {0, 1, 0, -1};
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const int N = 111111, M = 111111;
int l, m, n, t, C, tot;
pair<int, int> a[N], ans[N];
void put(int first, int second) {
ans[++tot] = make_pair(a[second].second, a[first].second);
a[first].first -= a[second].first;
a[second].first <<= 1;
}
void work() {
sort(a + 1, a + 1 + 3);
if (a[1].first == 0) return;
int b = a[2].first / a[1].first;
for (; b; b >>= 1)
if (b & 1)
put(2, 1);
else
put(3, 1);
work();
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) scanf("%d", &a[i].first), a[i].second = i;
for (int i = (3); i <= (n); ++i) {
if (i > 3) swap(a[1], a[i]);
work();
}
if ((a[1].first == 0) + (a[2].first == 0) + (a[3].first == 0) != 1)
puts("-1");
else {
printf("%d\n", tot);
for (int i = (1); i <= (tot); ++i)
printf("%d %d\n", ans[i].first, ans[i].second);
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
long long int gcd(long long int a, long long int b) {
return (b ? gcd(b, a % b) : a);
}
long long int P(long long int B, long long int power, long long int modulo) {
long long int ans = 1LL;
while (power > 0LL) {
if (power % 2LL == 1LL) {
ans = (ans * B) % modulo;
}
B = (B * B) % modulo;
power /= 2LL;
}
return ans;
}
bool isPrime(long long int n) {
if (n <= 1LL) {
return false;
}
if (n <= 3LL) {
return true;
}
if (n % 2 == 0LL || n % 3 == 0LL) {
return false;
}
for (long long int i = 5LL; (i * i) <= n; i += 6LL) {
if (n % i == 0LL || n % (i + 2LL) == 0LL) {
return false;
}
}
return true;
}
using namespace std;
bool sortbysec(const pair<pair<int, int>, int> &a,
const pair<pair<int, int>, int> &b) {
return (a.first.second < b.first.second);
}
bool sortbysecll(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return (a.second < b.second);
}
long long int modinv(long long int x, long long int y, long long int modulo) {
return ((x % modulo) * (P(y, modulo - 2LL, modulo) % modulo)) % modulo;
}
void vok() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
}
int main() {
vok();
vector<long long int> fact, ifact;
fact.push_back(1);
for (long long int i = 1; i < 200001; i++) {
fact.push_back((fact[i - 1] * i) % 998244353);
}
for (long long int i = 0; i < 200001; i++) {
ifact.push_back(P(fact[i], 998244353 - 2, 998244353) % 998244353);
}
long long int n, k;
cin >> n >> k;
if (k >= n) {
cout << 0 << "\n";
return 0;
}
long long int ans = 0;
for (long long int i = 0; i < n - k + 1; i++) {
long long int temp = fact[n - k];
temp %= 998244353;
temp *= ifact[i];
temp %= 998244353;
temp *= ifact[n - k - i];
temp %= 998244353;
temp *= P(n - k - i, n, 998244353);
temp %= 998244353;
if (i % 2) {
ans -= temp;
ans += 998244353;
ans %= 998244353;
} else {
ans += temp;
ans %= 998244353;
}
}
ans *= fact[n];
ans %= 998244353;
ans *= ifact[k];
ans %= 998244353;
ans *= ifact[n - k];
ans %= 998244353;
if (k) {
ans *= 2LL;
ans %= 998244353;
}
cout << ans << "\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef vector<ld> vd;
typedef vector<ll> vll;
typedef vector<string> vstr;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
typedef vector<pair<ll, ll>> vpll;
typedef priority_queue<ll, vector<ll>, greater<ll>> spqll; // 小さい順に取り出し
typedef priority_queue<ll, vector<ll>, less<ll>> bpqll; // 大きい順に取り出し
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define FOR(i, a, b) for (ll i = (ll)a; i < (ll)b; i++)
#define IREP(i, v) for (auto i = (v).begin(); i != (v).end(); i++)
#define FI first
#define SE second
#define MP make_pair
#define MT make_tuple
#define PB push_back
#define TS to_string
#define NP next_permutation
#define ALL(v) (v).begin(), (v).end()
#define SZ(x) (ll) x.size()
#define SP(x) setprecision((ll)x)
ll INF = 1e9;
ll MOD = 1000000007;
ll LINF = 1e18;
ld EPS = 1e-9;
ld PI = M_PI;
vll dx = {1, 0, -1, 0, 1, -1, -1, 1};
vll dy = {0, 1, 0, -1, 1, 1, -1, -1};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a;} //最大公約数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b;} //最小公倍数
void yes(){ cout << "Yes" << endl;}
void no(){ cout << "No" << endl;}
//-----------------------------------------
//-----------------------------------------
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
ll n;
cin >> n;
ll ans = 0;
ans += n / 25;
n %= 25;
ans += n / 10;
n %= 10;
ans += n / 5;
n %= 5;
ans += n;
cout << ans <<endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000 + 5;
struct edge {
int to, val, nxt;
} e[N << 1];
vector<int> v[N];
int dep[N], son[N], fa[N], head[N], cnt, sz[N], top[N], tot, dfn[N];
void add(int x, int y, int z) {
e[++cnt].to = y;
e[cnt].val = z;
e[cnt].nxt = head[x];
head[x] = cnt;
}
void dfs2(int x, int topfa) {
dfn[x] = ++tot;
top[x] = topfa;
if (son[x]) dfs2(son[x], topfa);
for (int i = head[x]; i; i = e[i].nxt)
if (!dfn[e[i].to]) {
dfs2(e[i].to, e[i].to);
}
}
void dfs1(int x) {
sz[x] = 1;
for (int i = head[x]; i; i = e[i].nxt)
if (e[i].to != fa[x]) {
fa[e[i].to] = x;
dep[e[i].to] = dep[x] + 1;
dfs1(e[i].to);
sz[x] += sz[e[i].to];
if (sz[e[i].to] > sz[son[x]]) son[x] = e[i].to;
}
}
int LCA(int x, int y) {
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
x = fa[top[x]];
}
if (dep[x] > dep[y]) swap(x, y);
return x;
}
void add_edge(int x, int y) { v[x].push_back(y); }
int rd() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f = (ch == '-' ? -1 : f), ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
int key[N], s[N], Top, K, a[N], b[N], ans[N];
int col[N], f[N], pos[N], spd[N];
void insert(int x) {
if (x == 1) return;
int lca = LCA(x, s[Top]);
while (Top > 1 && dfn[s[Top - 1]] >= dfn[lca]) {
add_edge(s[Top - 1], s[Top]), --Top;
}
if (lca ^ s[Top]) add_edge(lca, s[Top--]), s[++Top] = lca;
s[++Top] = x;
}
bool cmp(int i, int j) { return dfn[i] < dfn[j]; }
void solve() {
sort(a + 1, a + K + 1, cmp);
s[Top = 1] = 1;
for (int i = 1; i <= K; ++i)
if (a[i] != a[i - 1]) insert(a[i]);
for (int i = 1; i < Top; ++i) add_edge(s[i], s[i + 1]);
}
inline int dis(int x, int y) {
int lca = LCA(x, y);
return dep[x] + dep[y] - (dep[lca] << 1);
}
void redfs(int x) {
int tp1, tp2;
for (int to : v[x]) {
if (col[x]) {
if (!col[to])
col[to] = col[x];
else {
tp1 = ceil(1.0 * dis(to, pos[col[x]]) / spd[col[x]]),
tp2 = ceil(1.0 * dis(to, pos[col[to]]) / spd[col[to]]);
if (tp1 < tp2 || (tp1 == tp2 && col[x] < col[to])) col[to] = col[x];
}
}
redfs(to);
}
v[x].clear();
ans[x] = col[x];
col[x] = 0;
}
void dfs(int x) {
int tp1, tp2;
for (int to : v[x]) {
dfs(to);
if (col[to]) {
if (!col[x])
col[x] = col[to];
else {
tp1 = ceil(1.0 * dis(x, pos[col[x]]) / spd[col[x]]),
tp2 = ceil(1.0 * dis(x, pos[col[to]]) / spd[col[to]]);
if (tp1 > tp2 || (tp1 == tp2 && col[x] > col[to])) col[x] = col[to];
}
}
}
}
void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(int x) {
write(x);
puts("");
}
void writep(int x) {
write(x);
putchar(' ');
}
int main() {
int x, y, n = rd();
for (int i = 1; i < n; ++i) {
x = rd();
y = rd();
add(x, y, 1);
add(y, x, 1);
}
dep[1] = 1;
dfs1(1);
dfs2(1, 1);
int q = rd();
int m, k;
while (q--) {
k = rd();
m = rd();
K = 0;
for (int i = 1; i <= k; ++i)
x = rd(), y = rd(), a[++K] = x, pos[i] = x, spd[i] = y, col[x] = i;
for (int i = 1; i <= m; ++i) b[i] = rd(), a[++K] = b[i];
solve();
dfs(1);
redfs(1);
for (int i = 1; i <= m; ++i) writep(ans[b[i]]);
puts("");
}
return 0;
}
| 11 | CPP |
#include <cmath>
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <iomanip>
#include <map>
#include <stack>
#include <queue>
using namespace std;
typedef long long ll;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n,x,s[210];
int d=1e9+7;
cin>>n>>x;
for(int i=0;i<n;i++) cin>>s[i];
vector<vector<ll>> dp(n+1,vector<ll>(x+1,0));
sort(s,s+n);
for(int h=0;h<=x;h++){
dp[0][h]=h;
for(int i=0;i<n;i++){
dp[i+1][h]=dp[i][h%s[i]]+i*dp[i][h];
dp[i+1][h]%=d;
}
}
cout<<dp[n][x]<<endl;
} | 0 | CPP |
a=input()
print(["ABC","ABD"][len(a) > 3]) | 0 | PYTHON3 |
#include <bits/stdc++.h>
#define aaa(i,n) for ((i)=1;(i)<=(n);(i)++)
#define bbb(i,x,y) for ((i)=(x);(i)<=(y);(i)++)
using namespace std;
int n,m,i,j,f[200005][19],g[200005][19],a[200005],l[200005],lg[200005],t,ans,ys;int qrymi(int x,int y){int k=lg[y-x+1];return min(f[x][k],f[y-(1<<k)+1][k]);}int qrymx(int x,int y){ int k=lg[y-x+1]; return max(g[x][k],g[y-(1<<k)+1][k]);}
int main(){bbb(i,2,200000){ lg[i]=lg[i/2]+1; } scanf("%d%d",&n,&m); aaa(i,n){ scanf("%d",&a[i]); g[i][0]=f[i][0]=a[i]; }
aaa(j,18)aaa(i,n-(1<<j)+1){ f[i][j]=min(f[i][j-1],f[i+(1<<(j-1))][j-1]); g[i][j]=max(g[i][j-1],g[i+(1<<(j-1))][j-1]); } aaa(i,n){ if(i>1&&a[i-1]<a[i]) l[i]=l[i-1]+1; else l[i]=1; }
if(l[m]>=m) ys=1; else ans=1; bbb(i,m+1,n){ if(l[i]>=m){ ys=1; continue; } if(qrymi(i-m,i)==a[i-m]&&qrymx(i-m,i)==a[i]){ continue;
} else{ ans++; } } cout<<ans+ys<<endl; return 0;} | 0 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 45000;
int h, lgn, n, t, r, x, y, a[N], dis[N], lp[N], dp[N][17];
vector<pair<int, int> > e1, e2;
vector<int> g[N];
bool mark[N];
int lg(int xx) {
int l = 0;
while (xx > 1) {
xx /= 2;
++l;
}
return l;
}
void bfs(int d, vector<int> &v) {
vector<int> w;
for (int i = 0; i < v.size(); i++) {
for (int j = 0; j < g[v[i]].size(); j++) {
if (dis[g[v[i]][j]] == INT32_MAX) {
dis[g[v[i]][j]] = d + 1;
w.push_back(g[v[i]][j]);
}
}
}
if (!w.empty()) bfs(d + 1, w);
}
void dfs(int v) {
mark[v] = true;
for (int i = 0; i < g[v].size(); i++) {
if (!mark[g[v][i]]) {
dis[g[v][i]] = dis[v] + 1;
dp[g[v][i]][0] = v;
for (int j = 1; j <= lgn; j++)
dp[g[v][i]][j] = dp[dp[g[v][i]][j - 1]][j - 1];
dfs(g[v][i]);
}
}
}
int par(int v, int p) {
while (p > 0) {
int pp = p & (-p);
v = dp[v][lg(pp)];
p -= pp;
}
return v;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> h >> t >> r >> x;
int hh, tt;
for (int i = 0; i < x; i++) {
cin >> hh >> tt;
e1.push_back({hh, tt});
}
cin >> y;
for (int i = 0; i < y; i++) {
cin >> hh >> tt;
e2.push_back({hh, tt});
}
for (int i = r; i >= 0; i--) {
for (int j = r - i; j >= 0; j--) {
for (int k = 0; k < min(x, i); k++) {
if ((i - k - 1 + e1[k].first + j + e1[k].second) <= r)
g[(r + 1) * i + j].push_back((i - k - 1 + e1[k].first) * (r + 1) + j +
e1[k].second);
}
for (int k = 0; k < min(y, j); k++) {
if ((i + e2[k].first + j - k - 1 + e2[k].second) <= r)
g[(r + 1) * i + j].push_back((i + e2[k].first) * (r + 1) + j - k - 1 +
e2[k].second);
}
}
}
n = (r + 1) * (r + 1);
lgn = lg(n);
int s = h * (r + 1) + t;
fill(dis, dis + n, INT32_MAX);
vector<int> v;
v.push_back(s);
dis[s] = 0;
bfs(0, v);
if (dis[0] != INT32_MAX) {
cout << "Ivan\n" << dis[0];
return 0;
}
for (int i = 0; i < n; i++) fill(dp[i], dp[i] + 17, s);
dfs(s);
for (int i = 0; i < n; i++) {
if (dis[i] != INT32_MAX) {
for (int j = 0; j < g[i].size(); j++) {
if (dis[g[i][j]] <= dis[i] &&
g[i][j] == par(i, dis[i] - dis[g[i][j]])) {
cout << "Draw";
return 0;
}
}
}
}
for (int i = 0; i < n; i++) {
if (dis[i] != INT32_MAX) {
for (int j = 0; j < g[i].size(); j++) ++a[g[i][j]];
}
}
vector<int> w;
w.push_back(s);
while (!w.empty()) {
int u = w[w.size() - 1];
w.pop_back();
for (int i = 0; i < g[u].size(); i++) {
--a[g[u][i]];
lp[g[u][i]] = max(lp[g[u][i]], lp[u] + 1);
if (a[g[u][i]] == 0) w.push_back(g[u][i]);
}
}
int ans = 0;
for (int i = 0; i < n; i++) ans = max(ans, lp[i]);
cout << "Zmey\n" << ans + 1;
}
| 11 | CPP |
n=int(input())
S1=input()
S2=input()
k=0
for i in range(n):
a=int(S1[i])
b=int(S2[i])
k=k+min((10+a-b)%10,(10+b-a)%10)
print(k) | 7 | PYTHON3 |
#include <iostream>
using namespace std;
int main() {
int t;
cin >> t;
cout << t / 3600 << ":" << t / 60 % 60 << ":" << t % 60 << endl;
}
| 0 | CPP |
t=int(input())
for _ in range(t):
n=int(input())
A=list(map(int,input().split()))
z=A.count(0)
o=A.count(1)
if(z>=o):
print(z)
print(' '.join(map(str,[0]*z)))
else:
if(o%2!=0):
o-=1
print(o)
print(' '.join(map(str,[1]*o))) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int cmax = 0;
int a[n];
for (int i = 0; i < n; i++) {
if (s[i] == 'a')
a[i] = 1;
else
a[i] = -1;
}
int k1 = k;
int l = 0;
int r = 0;
int total = 0;
while (r < n) {
if (a[r] == 1) {
total += 1;
r++;
} else {
if (k1 > 0) {
total += 1;
k1--;
r++;
} else {
if (l < r) {
if (a[l] == 1) {
l++;
total--;
} else {
l++;
total--;
k1++;
}
} else {
l++;
r++;
}
}
}
cmax = max(cmax, total);
}
int b[n];
for (int i = 0; i < n; i++) {
if (s[i] == 'b')
b[i] = 1;
else
b[i] = -1;
}
k1 = k;
l = 0;
r = 0;
total = 0;
while (r < n) {
if (b[r] == 1) {
total += 1;
r++;
} else {
if (k1 > 0) {
total += 1;
k1--;
r++;
} else {
if (l < r) {
if (b[l] == 1) {
l++;
total--;
} else {
l++;
total--;
k1++;
}
} else {
l++;
r++;
}
}
}
cmax = max(cmax, total);
}
cout << cmax;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 500009;
int n, m, t = 0;
int in[N], out[N], p[N], l[N], hl[N] = {0}, ll[N] = {0};
vector<int> g[N], a;
void dfs(int v, int lv) {
t++;
in[v] = t, l[v] = lv;
for (int u : g[v]) dfs(u, lv + 1);
t++;
out[v] = t;
}
inline int fp(int v, int u) {
if (in[v] < in[u] and out[v] > out[u])
return 0;
else if (out[v] < in[u])
return 1;
else
return -1;
}
int32_t main() {
scanf("%d%d", &n, &m);
char st[N];
for (int i = 2; i <= n; i++) {
scanf("%d", &p[i]);
g[p[i]].push_back(i);
}
p[1] = 0, g[0].push_back(1);
scanf("%s", st);
dfs(1, 1);
a.push_back(0);
int po = 0;
while (po <= n) {
int c = a[po];
po++;
for (int u : g[c]) a.push_back(u);
}
int f[n + 1][26];
memset(f, 0, sizeof f);
for (int i = 1; i <= n; i++) {
hl[l[a[i]]] = i;
if (!ll[l[a[i]]]) ll[l[a[i]]] = i;
f[i][st[a[i] - 1] - 'a']++;
for (int j = 0; j < 26; j++) f[i][j] += f[i - 1][j];
}
while (m--) {
int v, d;
scanf("%d%d", &v, &d);
if (l[v] >= d) {
printf("Yes\n");
continue;
}
int hi = hl[d], lo = ll[d], lf = 1, rt = 0;
if (hi == 0 and lo == 0) {
printf("Yes\n");
continue;
}
while (hi >= lo) {
int mid = (hi + lo) / 2;
if (fp(v, a[mid]) == 0 and (mid == ll[d] or fp(v, a[mid - 1]) == -1)) {
lf = mid;
break;
} else if (fp(v, a[mid]) == -1)
lo = mid + 1;
else
hi = mid - 1;
}
hi = hl[d], lo = ll[d];
while (hi >= lo) {
int mid = (hi + lo) / 2;
if (fp(v, a[mid]) == 0 and (mid == hl[d] or fp(v, a[mid + 1]) == 1)) {
rt = mid;
break;
} else if (fp(v, a[mid]) == 1)
hi = mid - 1;
else
lo = mid + 1;
}
lf--;
int sum = 0;
for (int i = 0; i < 26; i++) sum += (f[rt][i] - f[lf][i]) % 2;
if (sum <= 1)
printf("Yes\n");
else
printf("No\n");
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, m, b[110][10010], i, j, k, minn, l, p, w, ind;
string a[10005];
int main() {
cin >> n >> m;
p = false;
w = false;
for (i = 0; i < n; i++) {
k = -1;
cin >> a[i];
for (j = 0; j < m; j++) {
if (a[i][j] == '1') {
p = true;
b[i][j] = 0;
k = 0;
k++;
ind = j;
} else {
b[i][j] = k;
if (k > 0) k++;
}
}
j = 0;
while (b[i][j] != 0) {
b[i][j] = m - ind + j;
j++;
}
if (p == false) {
w = true;
break;
}
p = false;
k = -1;
for (j = m - 1; j >= 0; j--) {
if (a[i][j] == '1') {
b[i][j] = 0;
k = 0;
k++;
ind = j;
} else {
if (b[i][j] < 0 || (k < b[i][j] && k >= 0)) b[i][j] = k;
if (k > 0) k++;
}
}
j = m - 1;
while (b[i][j] != 0) {
if (b[i][j] > ind + m - j) b[i][j] = ind + m - j;
j--;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
b[i][j] = min(b[i][j], m - b[i][j]);
}
}
minn = 9999999;
for (i = 0; i < m; i++) {
l = 0;
for (j = 0; j < n; j++) l = l + b[j][i];
if (l < minn) minn = l;
}
if (w == true)
cout << "-1";
else
cout << minn;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int n, a, x = 0, y = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
x = a > x ? a : x;
y = gcd(y, a);
}
puts((x / y - n) & 1 ? "Alice" : "Bob");
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, pos = 1, res = 0;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int tmp;
cin >> tmp;
if (tmp < pos) {
res += n - pos + tmp;
} else {
res += tmp - pos;
}
pos = tmp;
}
cout << res;
return 0;
}
| 8 | CPP |
t = int(input())
for _ in range(t):
n = int(input())
brackets = input()
open_ = 0
close_ = 0
for br in brackets:
if br == '(':
open_ += 1
if open_ != 0 and br == ')':
open_ -= 1
elif open_ == 0 and br == ')':
close_ += 1
if open_ == close_:
print(open_) | 9 | PYTHON3 |
def cz(l):
d=0
for i in l:
if i=='1':
break
else:
d+=1
return d
n=int(input())
ans=[]
for i in range(n):
a=input()
if a.count('1')==0:
ans.append(0)
else:
ans.append(a.count('0')-(cz(a)+cz(a[::-1])))
print(*ans,sep='\n')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int result = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i + 1] <= a[i]) {
int k = (a[i] - a[i + 1]) / d;
a[i + 1] += k * d;
if (a[i + 1] > a[i])
result += k;
else {
a[i + 1] += d;
result += k + 1;
}
}
}
cout << result << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
long long ans = 0;
char str[N];
long long len[N], energe[N], d[N];
inline void init() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", len + i);
scanf("%s", str + 1);
}
inline void solve() {
bool have_w = false;
for (int i = 1; i <= n; i++) {
long long &E = energe[i];
E = energe[i - 1];
if (str[i] == 'L') {
ans += len[i];
E -= len[i];
if (E < 0) {
if (have_w) {
ans += -E * 3;
} else {
ans += -E * 5;
}
E = 0;
}
} else if (str[i] == 'W') {
ans += len[i] * 3;
E += len[i];
have_w = true;
} else if (str[i] == 'G') {
ans += len[i] * 5;
E += len[i];
}
}
long long min_E = energe[n];
for (int i = n; i && min_E; i--) {
min_E = min(min_E, energe[i]);
if (str[i] == 'G') {
long long take = min(min_E, len[i] << 1);
min_E -= take;
d[i] += take;
ans -= take << 1;
}
}
for (int i = 1; i <= n; i++) {
energe[i] -= (d[i] += d[i - 1]);
}
min_E = energe[n];
for (int i = n; i && min_E; i--) {
min_E = min(min_E, energe[i]);
if (str[i] == 'W') {
long long take = min(min_E, len[i] << 1);
min_E -= take;
ans -= take;
}
}
printf(
"%lld"
"\n",
ans);
}
int main() {
init();
solve();
return 0;
}
| 12 | CPP |
n=int(input())
r=list(set(list(map(int,input().split()))))
r.sort()
if len(r)==1:
print("NO")
else:
print(r[1]) | 7 | PYTHON3 |
#include <bits/stdc++.h>
#define MAX_V 100000
using namespace std;
int V; //????????°
vector<int> G[MAX_V]; //??°???????????£??\??????????????¨???
int ord[MAX_V]; //???????????????
int parent[MAX_V]; //???
int low[MAX_V]; //
set<int> AP; //??¢??????
void dfs(int u,int p,int &c){
ord[u] = low[u] = c++;
for(int i=0; i<G[u].size(); i++){
int v=G[u][i];
if(ord[v] == -1){
parent[v] = u;
dfs(v, u, c);
low[u] = min(low[u], low[v]);
}
else if(v != p) low[u] = min(low[u], ord[v]);
}
}
void art_points(){
memset(ord,-1,sizeof(ord));
int c=1;
dfs(0, -1, c);
int np=0;
for(int i=1; i<V ;i++){
int p = parent[i];
if(p == 0 ) np++;
else if(ord[p] <= low[i]) AP.insert(p);
}
if(np > 1) AP.insert(0);
}
int main(){
int E;
cin>>V>>E;
for(int i=0;i<E;i++){
int s,t;
cin>>s>>t;
G[s].push_back(t);
G[t].push_back(s);
}
art_points();
set<int>::iterator it=AP.begin();
while(it!=AP.end())cout<<*(it++)<<endl;
return 0;
} | 0 | CPP |
# By Kaleab Asfaw
def main(num ,granny):
granny = sorted(granny)
for i in range(num, 0, -1):
if granny[i-1] <= i:
return i+1
return 1
for i in range(int(input())):
print(main(int(input()), map(int, input().split())))
| 8 | PYTHON3 |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define MOD 1000000007
#define REP(i, N) for (int i = 0; i < N; ++i)
#define REP1(i, N) for (int i = 1; i <= N; ++i)
#define RREP(i, N) for (int i = N - 1; i >= 0; --i)
#define ALL(a) a.begin(), a.end()
int main() {
int n;
ll W;
cin >> n >> W;
ll v[n], w[n];
REP(i, n) cin >> v[i] >> w[i];
vector<P> vc1;
int n2 = n / 2;
REP(i, 1 << n2) {
ll sw = 0, sv = 0;
REP(j, n2) {
if (i >> j & 1) {
sw += w[j];
sv += v[j];
}
}
if (sw <= W) {
vc1.push_back(P(sw, sv));
}
}
sort(ALL(vc1));
vector<P> vc2;
REP(i, 1 << (n - n2)) {
ll sw = 0, sv = 0;
REP(j, n - n2) {
if (i >> j & 1) {
sw += w[n2 + j];
sv += v[n2 + j];
}
}
if (sw <= W) {
vc2.push_back(P(sw, sv));
}
}
sort(ALL(vc2));
ll ans = 0, mx = 0;
int j = 0;
RREP(i, vc1.size()) {
while (j < vc2.size() && vc1[i].first + vc2[j].first <= W) {
mx = max(mx, vc2[j].second);
j++;
}
ans = max(ans, vc1[i].second + mx);
}
cout << ans << endl;
return 0;
}
| 0 | CPP |
import sys,os,io
from sys import stdin
from math import log, gcd, ceil
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop
from bisect import bisect_left , bisect_right
import math
alphabets = list('abcdefghijklmnopqrstuvwxyz')
def isPrime(x):
for i in range(2,x):
if i*i>x:
break
if (x%i==0):
return False
return True
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
def primeFactors(n):
l = []
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3,int(math.sqrt(n))+1,2):
while n % i== 0:
l.append(int(i))
n = n / i
if n > 2:
l.append(n)
return list(set(l))
def power(x, y, p) :
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1 # y = y/2
x = (x * x) % p
return res
def SieveOfEratosthenes(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def si():
return input()
def prefix_sum(arr):
r = [0] * (len(arr)+1)
for i, el in enumerate(arr):
r[i+1] = r[i] + el
return r
def divideCeil(n,x):
if (n%x==0):
return n//x
return n//x+1
def ii():
return int(input())
def li():
return list(map(int,input().split()))
def ws(s): sys.stdout.write(s + '\n')
def wi(n): sys.stdout.write(str(n) + '\n')
def wia(a): sys.stdout.write(' '.join([str(x) for x in a]) + '\n')
def power_set(L):
"""
L is a list.
The function returns the power set, but as a list of lists.
"""
cardinality=len(L)
n=2 ** cardinality
powerset = []
for i in range(n):
a=bin(i)[2:]
subset=[]
for j in range(len(a)):
if a[-j-1]=='1':
subset.append(L[j])
powerset.append(subset)
#the function could stop here closing with
#return powerset
powerset_orderred=[]
for k in range(cardinality+1):
for w in powerset:
if len(w)==k:
powerset_orderred.append(w)
return powerset_orderred
def fastPlrintNextLines(a):
# 12
# 3
# 1
#like this
#a is list of strings
print('\n'.join(map(str,a)))
def sortByFirstAndSecond(A):
A = sorted(A,key = lambda x:x[0])
A = sorted(A,key = lambda x:x[1])
return list(A)
#__________________________TEMPLATE__________________OVER_______________________________________________________
if(os.path.exists('input.txt')):
sys.stdin = open("input.txt","r") ; sys.stdout = open("output.txt","w")
else:
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
t = 1
# t = int(input())
for _ in range(t):
n = ii()
a = ii()
b = ii()
f = 0
for x in range(n+1):
by = (n-a*x)
if by%b==0 and by>=0:
print("YES")
print(x,by//b)
f = 1
break
if f==0:
print("NO") | 8 | PYTHON3 |
import math
import sys
from itertools import permutations
input = sys.stdin.readline
t=int(input())
for i in range(t):
s=list(input())
if s[-1]=="\n":
s.pop()
arr=[]
cur=0
for j in range(len(s)):
if s[j]=="-":
cur+=1
arr.append(cur)
else:
cur-=1
arr.append(cur)
maxx=0
ans=0
# print(arr)
for j in range(len(arr)):
if arr[j]>maxx:
ans+=(j+1)
maxx=arr[j]
ans+=len(arr)
print(ans)
| 9 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
a, b = [list(map(int, input().split())) for i in range(2)]
x, y = min(a), min(b)
ans = 0
for i in range(n):
temp = min(a[i] - x, b[i] - y)
ans += temp+a[i]+b[i]-(x+y+2*temp)
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
using namespace std;
void setIO() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
int main() {
setIO();
int n;
cin >> n;
vector<string> grid(n);
for (auto &i : grid) {
cin >> i;
}
vector<int> dx = {0, -1, 0, 1};
vector<int> dy = {-1, 0, 1, 0};
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int cnt = 0;
for (int dir = 0; dir < 4; dir++) {
int ni = i + dx[dir];
int nj = j + dy[dir];
if (ni >= 0 && ni < n && nj >= 0 && nj < n && grid[ni][nj] == 'o') {
cnt++;
}
}
if (cnt % 2 == 1) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
}
| 7 | CPP |
def fact(x):
if (x == 1):
return 1
cal = 0
for i in range(1, x):
cal += i
return cal
n = int(input().strip())
a = [int(x) for x in input().strip().split()]
p, q = max(a), min(a)
r, s = sum([1 for x in a if x == p]), sum([1 for x in a if x == q])
if (p != q):
print(p-q, r*s)
else:
print(p-q, fact(r))
| 8 | PYTHON3 |
qNumbers = int(input())
k = list(map(int, input().split()))
minScnds = k[0] * 15
itms = list(map(int, input().split()))
for i in range(k[0]):
minScnds += itms[i] * 5
for i in range(1, qNumbers):
scnds = k[i] * 15
itms = list(map(int, input().split()))
for j in range(k[i]):
scnds += itms[j] * 5
minScnds = min(scnds, minScnds)
print (minScnds) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int to[1000];
int from[1000];
int id[1000];
int head[1000];
int sz[1000];
vector<int> comp;
int dp[1001];
int main() {
int n, k;
scanf("%d%d", &n, &k);
memset(from, -1, sizeof(from));
for (int i = 0; i < (n); i++) {
int v;
scanf("%d", &v);
v--;
to[i] = v;
from[v] = i;
if (v == -1) head[i] = 1;
}
for (int i = 0; i < (n); i++) {
if (head[i]) {
bool iAmHere = false;
int cnt = 0;
int cur = i;
while (cur != -1) {
cnt++;
id[cur] = cnt;
if (cur == k - 1) iAmHere = true;
cur = from[cur];
}
if (!iAmHere) comp.push_back(cnt);
}
}
dp[0] = 1;
for (int i = 0; i < comp.size(); i++)
for (int j = n - comp[i]; j >= 0; j--) dp[j + comp[i]] |= dp[j];
bool first = true;
for (int i = 0; i <= n; i++) {
if (dp[i]) {
printf("%d\n", i + id[k - 1]);
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
int N;
int a[100000];
int main() {
memset(a, 0, sizeof(a));
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%d", &a[i]);
}
std::sort(a, a + N);
if (N == 1 && a[0] == 1) {
printf("2");
return 0;
}
printf("1");
if (N > 1) {
for (int t = 1; t + 1 < N; ++t) printf(" %d", a[t - 1]);
if (a[N - 1] != 1)
printf(" %d", a[N - 2]);
else
printf(" 2");
}
printf("\n");
return 0;
}
| 9 | CPP |
o=int(input())
for _ in range(o):
n,k,h=map(int,input().split())
l=list(map(int,input().split()))
y=list(map(int,input().split()))
if max(l)>max(y) :
print('YES')
else :
print('NO')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int alpha[26];
for (int i = 0; i < 26; i++) alpha[i] = -1;
char s[50005];
cin >> s;
int start = -1, end = 0;
int len = strlen(s);
while (end <= (start + 26) && end <= len) {
if (s[end] != '?') {
if (end <= (alpha[s[end] - 'A'] + 26)) {
if (alpha[s[end] - 'A'] != -1)
start = alpha[s[end] - 'A'] > start ? alpha[s[end] - 'A'] : start;
}
alpha[s[end] - 'A'] = end;
}
end++;
}
if (end == start + 27) {
int k = 0;
while (k < start) {
if (s[k] != '?')
cout << s[k];
else
cout << 'A';
k++;
}
int pointer = 0;
while (k < end) {
if (s[k] != '?')
cout << s[k];
else {
while (alpha[pointer] > start) pointer++;
printf("%c", pointer + 'A');
pointer++;
}
k++;
}
while (k < len) {
if (s[k] != '?')
cout << s[k];
else
cout << 'A';
k++;
}
} else
cout << -1 << endl;
return 0;
}
| 8 | CPP |
n=int(input())
if n%4==0 or n%7==0 or n%47==0 or n%74==0 or n%44==0 or n%77==0 or n%444==0 or n%447==0 or n%474==0 or n%744==0 or n%477==0 or n%747==0 or n%774==0 or n%777==0:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <cstdio>
#include <utility>
#include <map>
using namespace std;
char s[510], ans[510];
inline void upd(char &p, int &m, char c, char d) {
if (p > c) p = c, m = 0;
if (p == c) m |= 1 << d;
}
void solve() {
int n, k;
scanf("%d%d%s", &n, &k, s);
for (int i = 0; i < n; i++) {
s[i] -= 'a';
}
if (n == 1) {
if (s[0] == k - 1) {
s[0] = 0;
} else if (s[0]) {
s[0]--;
}
s[0] += 'a';
puts(s);
return;
}
int m1 = 1 << 26, m2 = 0;
char pp = -1, p2 = -1;
for (int i = 0; i < n; i++) {
char z, u = s[i];
int n1 = 0, n2 = 0;
if (u == k - 1) {
u = 0;
} else if (u) {
--u;
}
if (m2 && p2 != -1 && s[i] < pp) {
z = s[i];
pp = p2;
p2 = 26;
n1 = m2;
n2 = 0;
} else {
z = pp;
int f = pp == p2;
pp = p2 = 26;
for (int j = 0; j < k; j++) {
if (m1 >> j & 1) {
upd(pp, n1, s[i], j);
if (i + 1 < n) upd(p2, n2, j, s[i]);
upd(pp, n1, j, u);
}
if (f && (m2 >> j & 1)) {
upd(pp, n1, j, s[i]);
upd(pp, n1, u, j);
}
}
if (m1 >> 26 & 1) {
if (i + 1 < n) upd(p2, n2, -1, s[i]);
upd(pp, n1, -1, u);
}
}
if (i > 1) ans[i-2] = z;
m1 = n1;
m2 = n2;
}
ans[n-2] = pp;
for (int i = 0; i < k; i++) {
if ((m1 | m2) >> i & 1) {
ans[n-1] = i;
break;
}
}
for (int i = 0; i < n; i++) {
ans[i] += 'a';
}
ans[n] = 0;
puts(ans);
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
solve();
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> wt;
set<pair<int, int> > st;
int main() {
int n, i, k;
char c;
cin >> n;
for (i = 0; i < n; i++) {
cin >> k;
wt.push_back(k);
st.insert(make_pair(k, i + 1));
}
set<pair<int, int> >::iterator it;
pair<int, int> pr;
priority_queue<pair<int, int> > pq;
it = st.begin();
for (i = 0; i < 2 * n; i++) {
cin >> c;
k = c - '0';
if (k == 0) {
pr = *it;
it++;
cout << pr.second << " ";
pq.push(make_pair(pr.first, pr.second));
} else {
pr = pq.top();
pq.pop();
cout << pr.second << " ";
}
}
}
| 8 | CPP |
f=input; n=int(f()); s=list(f())
d={chr(97+i):[0]*(n+1) for i in range(26)}
def bsum(k,i):
s=0
while i: s+=d[k][i]; i-=i&-i
return s
def badd(k,i,x):
while i<=n: d[k][i]+=x; i+=i&-i
for i in range(n): badd(s[i],i+1,1)
for i in range(int(f())):
a,b,c=f().split(); b=int(b)-1
if a>'1': print(sum(1 for k in d.keys() if bsum(k,int(c))-bsum(k,b)))
else: badd(s[b],b+1,-1); s[b]=c; badd(c,b+1,1) | 0 | PYTHON3 |
a=0
for i in range (int(input())):
p,q,r=map(int,input().split())
if p+q+r>=2:
a+=1
print(a)
| 7 | PYTHON3 |
t=int(input())
words={}
for i in range(t):
line=str(input())
if line not in words:
words[line]=0
print("OK")
else:
words[line]+=1
print(line+str(words[line]))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to, id;
Edge(int to, int id) : to(to), id(id) {}
};
const int MAXN = 1e5 + 5;
int n, cnt[MAXN];
vector<Edge> adj[MAXN];
long long S, w[MAXN];
void dfs(int u, int p = -1) {
if (adj[u].size() == 1) cnt[p] = 1;
for (auto& e : adj[u]) {
if (e.id == p) continue;
dfs(e.to, e.id);
if (p != -1) cnt[p] += cnt[e.id];
}
}
long long contribution(int id) {
return w[id] * (long long)cnt[id] - (w[id] / 2) * (long long)cnt[id];
}
void solve() {
cin >> n >> S;
for (int i = 0; i < n; i++) adj[i].clear();
memset(w, 0, sizeof(w));
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < n - 1; i++) {
int v, u;
cin >> v >> u >> w[i];
v--, u--;
adj[v].emplace_back(Edge(u, i));
adj[u].emplace_back(Edge(v, i));
}
dfs(0);
set<pair<long long, int>> edges;
long long sum = 0;
for (int i = 0; i < n - 1; i++) {
sum += w[i] * cnt[i];
edges.insert({contribution(i), i});
}
int ans = 0;
while (sum > S) {
int id = edges.rbegin()->second;
edges.erase(prev(edges.end()));
sum -= contribution(id);
ans++;
w[id] /= 2;
edges.insert({contribution(id), id});
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 11 | CPP |
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n=int(input())
L=list(map(int,input().split()))
L.sort()
for i in range(n-1):
if L[i+1]-L[i]>1:
print('NO')
break
else:
print('YES')
| 7 | PYTHON3 |
for i in range(int(input())):
s = str(input())
i=0
n=len(s)-1
l=[]
while i<len(s):
temp = s[i] +'0'*(n)
temp = int(temp)
if temp!=0:
l.append(temp)
n = n-1
i=i+1
print(len(l))
print(*l) | 7 | PYTHON3 |
i=input;print(['NO','YES'][int(i())==len(set(i().split()))]) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e5 + 10;
long long rem[M], n, m, sqc, mark[M], dep[M];
vector<long long> lst, g[M];
void dfs(long long v) {
mark[v] = true;
lst.push_back(v);
dep[v] = lst.size();
for (auto u : g[v])
if (!mark[u])
dfs(u);
else if (dep[v] - dep[u] + 1 >= sqc) {
cout << 2 << endl << dep[v] - dep[u] + 1 << endl;
for (long long i = dep[v] - 1; i >= dep[u] - 1; i--)
cout << lst[i] << " ";
exit(0);
}
if (!rem[v])
for (auto u : g[v]) rem[u] = true;
lst.pop_back();
}
int32_t main() {
cin >> n >> m;
while (m--) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
sqc = sqrt(n);
if (sqc * sqc < n) sqc++;
dfs(1);
cout << 1 << endl;
for (long long i = 1; sqc; i++)
if (!rem[i]) cout << i << " ", sqc--;
return 0;
}
| 12 | CPP |
num = input().split()
num = [int(x) for x in num]
list1 = input().split()
list2 = input().split()
need_year = int(input())
year_list = []
for i in range(need_year):
year_list.append(int(input()))
work_list1 = [(year_list[i] % num[0]) for i in range(need_year)]
work_list2 = [(year_list[i] % num[1]) for i in range(need_year)]
for i in range(need_year):
if work_list1[i] == 0:
work_list1[i] = list1[-1]
else:
work_list1[i] = list1[work_list1[i]-1]
for i in range(need_year):
if work_list2[i] == 0:
work_list2[i] = list2[-1]
else:
work_list2[i] = list2[work_list2[i]-1]
work_list =[(work_list1[i] + work_list2[i]) for i in range(need_year)]
for i in work_list:
print(i)
| 7 | PYTHON3 |
n,x,y = map(int, input().split())
g = [0]*(n)
for i in range(1,n+1):
for j in range(1,i):
e = abs(y-i)+1+abs(x-j)
f = i-j
g[min(e,f)]+=1
for i in g[1:]:
print(i) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
long long n, m;
cin >> n;
vector<pair<long long, long long>> a(n);
for (long long i = 0; i < (long long)n; i++) cin >> a[i].first >> a[i].second;
cin >> m;
vector<pair<long long, long long>> b(m);
for (long long i = 0; i < (long long)m; i++) cin >> b[i].first >> b[i].second;
sort((a).begin(), (a).end());
sort((b).begin(), (b).end());
long long ai = 0, bi = 0, c = 0;
while (ai < n || bi < m) {
if (ai == n && bi == m)
break;
else if (ai == n) {
c += b[bi].second;
bi++;
} else if (bi == m) {
c += a[ai].second;
ai++;
} else if (a[ai].first == b[bi].first) {
c += max(a[ai].second, b[bi].second);
ai++;
bi++;
} else if (a[ai].first > b[bi].first) {
c += b[bi].second;
bi++;
} else if (a[ai].first < b[bi].first) {
c += a[ai].second;
ai++;
}
}
cout << c;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int numMarks, mark;
double highestMark;
cin >> numMarks >> highestMark;
double sum;
sum = 0;
int counter = 0;
while (counter < numMarks) {
cin >> mark;
sum += mark;
counter++;
}
double num = numMarks;
double average = sum / num;
while (average < highestMark - 0.5) {
sum += highestMark;
num++;
average = sum / num;
}
cout << num - numMarks;
}
| 7 | CPP |
from sys import stdin, stdout
n = int(stdin.readline())
values = sorted(list(map(int, stdin.readline().split())), reverse = True)
i = 1
while sum(values[:i]) <= sum(values) / 2:
i += 1
stdout.write(str(i)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long x;
vector<pair<long long, long long> > a(n);
for (int i = 0; i < n; i++) {
cin >> x;
a[i].first = x;
a[i].second = i;
}
sort(a.begin(), a.end());
long long arr[3 * n], l = 0, len = 0;
for (int i = 0; i < n; i++) {
if (a[i].first < 2E9) {
len++;
arr[l++] = 1;
int y = l - 1;
arr[l++] = a[i].second + 1;
a[i].first = 2E9;
x = a[i].second;
while (i != x) {
arr[y]++;
a[x].first = 2E9;
x = a[x].second;
arr[l++] = x + 1;
}
arr[l++] = 0;
}
}
cout << len << endl;
for (int i = 0; i < l; i++) {
if (arr[i] == 0)
cout << endl;
else
cout << arr[i] << " ";
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int dp[100001], a[100001], n, k;
long long int ok(long long int x) {
for (long long int i = 1; i <= n; i++) {
dp[i] = i - 1;
for (long long int j = 1; j < i; j++) {
if (abs(a[i] - a[j]) <= (i - j) * x)
dp[i] = min(dp[i], dp[j] + i - j - 1);
}
if (dp[i] + n - i <= k) return 1;
}
return 0;
}
int main() {
long long int lo, mid, hi, i, j;
ios::sync_with_stdio(false);
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
lo = 0;
hi = 2e9;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (ok(mid))
hi = mid - 1;
else
lo = mid + 1;
}
cout << lo;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
class segtree {
public:
long long s;
pair<int, int> seg[(1 << 20)];
int lazy[(1 << 20)];
void init(int n) {
for (int i = 0;; i++) {
if ((1 << i) >= n + 5) {
s = (1 << i);
for (int j = s - 1; j < 2 * s; j++) {
seg[j] = make_pair(0, j - s + 1);
}
for (int j = s - 2; j >= 0; j--) {
seg[j] = seg[j * 2 + 1];
}
for (int j = 0; j < 2 * s; j++) {
lazy[j] = 0;
}
return;
}
}
}
void lazy_evaluate(int k) {
if (k * 2 + 2 >= s * 2) return;
lazy[k * 2 + 2] += lazy[k];
lazy[k * 2 + 1] += lazy[k];
seg[k * 2 + 2].first += lazy[k];
seg[k * 2 + 1].first += lazy[k];
lazy[k] = 0;
}
pair<int, int> update(int beg, int end, int idx, int lb, int ub, int num) {
if (ub < beg || end < lb) {
return seg[idx];
}
if (beg <= lb && ub <= end) {
lazy[idx] += num;
seg[idx].first += num;
return seg[idx];
}
if (lazy[idx]) {
lazy_evaluate(idx);
}
return seg[idx] =
min(update(beg, end, idx * 2 + 1, lb, (lb + ub) / 2, num),
update(beg, end, idx * 2 + 2, (lb + ub) / 2 + 1, ub, num));
}
pair<int, int> query(int beg, int end, int idx, int lb, int ub) {
if (ub < beg || end < lb) {
return make_pair(1000000000, 1000000000);
}
if (beg <= lb && ub <= end) {
return seg[idx];
}
if (lazy[idx]) {
lazy_evaluate(idx);
}
return min(query(beg, end, idx * 2 + 1, lb, (lb + ub) / 2),
query(beg, end, idx * 2 + 2, (lb + ub) / 2 + 1, ub));
}
pair<int, int> update(int beg, int end, int num) {
return update(beg, end, 0, 0, s - 1, num);
}
pair<int, int> query(int beg, int end) {
return query(beg, end, 0, 0, s - 1);
}
} kaede;
int q;
int n;
int p[500005];
vector<pair<int, int> > go[500005];
int ans[500005];
int main() {
scanf("%d", &q);
for (int r = 0; r < q; r++) {
scanf("%d", &n);
kaede.init(n + 2);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
p[i]--;
go[i].clear();
}
for (int i = 0; i < n; i++) {
if (p[i] == -2) continue;
if (p[i] != n) {
go[p[i]].push_back(make_pair(i, i));
kaede.update(i, i, 1);
}
if (p[i] > i + 1) {
go[i].push_back(make_pair(i + 1, p[i] - 1));
kaede.update(i + 1, p[i] - 1, 1);
}
}
int cnt = 0;
while (cnt < n) {
pair<int, int> p = kaede.query(0, n - 1);
if (p.first != 0) break;
ans[p.second] = n - cnt;
cnt++;
for (int x = 0; x < go[p.second].size(); x++) {
int L = go[p.second][x].first;
int R = go[p.second][x].second;
kaede.update(L, R, -1);
}
kaede.update(p.second, p.second, 1000000000 / 10);
}
if (cnt != n) {
puts("-1");
} else {
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
puts("");
}
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int vis[100000];
int grundy[30] = {0, 1, 2, 1, 4, 3, 2, 1, 5, 6, 2, 1, 8, 7, 5,
9, 8, 7, 3, 4, 7, 4, 2, 1, 10, 9, 3, 6, 11, 12};
int main() {
long long n, i, j, temp, rem = 0;
scanf("%I64d", &n);
long long maxx = sqrt(n);
long long ans = 1;
for (i = 2; i <= maxx; i++) {
if (vis[i] == 1) continue;
j = i;
temp = 0;
while (j <= n) {
temp++;
if (j <= maxx)
vis[j] = 1;
else
rem++;
j *= i;
}
ans ^= grundy[temp];
}
temp = n - maxx - rem;
if (temp & 1) ans ^= 1;
if (ans == 0)
printf("Petya\n");
else
printf("Vasya\n");
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
const long long int inf = 1e9 + 7;
using namespace std;
long long int fac(long long int x) {
long long int p = 1;
for (long long int i = 1; i <= x; i++) {
p = p * i;
p = p % inf;
}
return p;
}
long long int power(long long int a, long long int n) {
long long int ans = 1;
while (n > 0) {
if (n & 1) {
ans *= a;
}
a = a * a;
n >>= 1;
}
return ans;
}
bool check(vector<long long int> v, long long int k) {
long long int x = 1;
for (int i = 0; i < v.size(); i++) {
x = x * v[i];
}
if (x >= k) {
return true;
} else {
return false;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, q;
cin >> n >> q;
vector<int> v;
for (int i = 0; i < n; i++) {
int c;
cin >> c;
v.push_back(c);
}
sort(v.begin(), v.end());
int arr[200005] = {};
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
l--;
r--;
arr[l]++;
if (r < n - 1) {
arr[r + 1]--;
}
}
int b = arr[0];
for (int i = 1; i < 200005; i++) {
arr[i] += b;
b = arr[i];
}
sort(arr, arr + n);
long long int ans = 0;
for (int i = 0; i < n; i++) {
ans += (long long int)v[i] * (long long int)arr[i];
}
cout << ans << endl;
}
| 9 | CPP |
#include <bits/stdc++.h>
void build_population_count(unsigned int[]);
void read_and_find_frequency(int[], unsigned long long);
unsigned long long count_k_interesting_pairs(int[], int, unsigned int[]);
int main() {
int count[10000 + 1] = {0}, k;
unsigned int population_count[2 * 10000];
unsigned long long no_of_k_interesting_pairs, no_of_elements;
scanf("%I64u %d", &no_of_elements, &k);
build_population_count(population_count);
read_and_find_frequency(count, no_of_elements);
no_of_k_interesting_pairs =
count_k_interesting_pairs(count, k, population_count);
printf("%I64u\n", no_of_k_interesting_pairs);
return 0;
}
void build_population_count(unsigned int population_count[]) {
unsigned int i;
population_count[0] = 0;
for (i = 1; i <= 2 * 10000; i++) {
population_count[i] = population_count[i >> 1] + (i % 2);
}
}
unsigned long long count_k_interesting_pairs(int count[], int k,
unsigned int population_count[]) {
unsigned int i, j;
unsigned long long k_interesting_count = 0;
for (i = 0; i <= 10000; i++) {
if (count[i] > 0) {
if (k == 0) {
k_interesting_count += count[i] * 1ll * (count[i] - 1) / 2;
} else {
for (j = i + 1; j <= 10000; j++) {
if ((count[j] > 0) && (population_count[i ^ j] == k)) {
k_interesting_count += (long long)count[i] * count[j];
}
}
}
}
}
return k_interesting_count;
}
void read_and_find_frequency(int count[], unsigned long long no_of_elements) {
unsigned long long num, i;
for (i = 0; i < no_of_elements; i++) {
scanf("%I64u", &num);
count[num]++;
}
}
| 10 | CPP |
# https://codeforces.com/contest/1400/problem/B
'''
Author @Subhajit Das (sdsubhajitdas.github.io)
SWE @Turbot HQ India PVT Ltd.
30/08/2020
'''
def main():
myCapacity, folCapacity = map(int, input().strip().split())
# 33 27
swords, axes = map(int, input().strip().split())
# 6 10
swordWeight, axeWeight = map(int, input().strip().split())
# 5 6
if(swordWeight > axeWeight):
swordWeight, axeWeight = axeWeight, swordWeight
swords, axes = axes, swords
maxWeapons = 0
for takenSword in range(swords+1):
if(takenSword*swordWeight > myCapacity):
continue
folTakenSword = min(swords-takenSword, folCapacity//swordWeight)
leftMyCapacity = myCapacity - swordWeight*takenSword
leftFolCapacity = folCapacity - swordWeight*folTakenSword
takenAxe = min(leftMyCapacity//axeWeight, axes)
folTakenAxe = min(leftFolCapacity//axeWeight, axes - takenAxe)
maxWeapons = max(maxWeapons, takenSword+folTakenSword+takenAxe+folTakenAxe)
print(maxWeapons)
if __name__ == "__main__":
for _ in range(int(input())):
main()
# main()
| 8 | PYTHON3 |
a=input()
b=input()
c=str(a)
l1=list(c)
d=str(b)
l2=list(d)
k=len(l1)
l=[]
for i in range(k):
if l1[i]==l2[i]:
l.append('0')
else:
l.append('1')
s=''
print(s.join(l)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, x[100003], h[100003], hh[100003], ti, iv, in, f[100003],
p[100003], tv, hhh[100003], s;
char c[100003];
int main() {
cin >> n >> m;
for (i = 1; i <= m; i++) {
cin >> c[i] >> x[i];
if (c[i] == '-' && !h[x[i]]) ti++, iv++;
if (c[i] == '+') ti++, hh[x[i]]++, h[x[i]] = 1;
}
k = iv;
for (i = 1; i <= m; i++) {
if (x[i] == x[i - 1] && c[i] == '+' && c[i - 1] == '-' && !iv) {
iv++;
p[x[i]] = 0;
} else if (c[i] == '+') {
if (iv || k) {
p[x[i]] = 1;
}
iv++;
k++;
hhh[x[i]]++;
} else if (c[i] == '-') {
iv--;
if (iv || (ti - k) - (hh[x[i]] - hhh[x[i]])) {
p[x[i]] = 1;
}
}
}
for (i = 1; i <= n; i++)
if (!p[i]) s++;
printf("%d\n", s);
for (i = 1; i <= n; i++)
if (!p[i]) printf("%d ", i);
}
| 8 | CPP |
#include <stdio.h>
#include <iostream>
using namespace std;
void hantei (double k[], double t, int kk[], int tt) {
if (k[1] > t) {
k[1] = t;
kk[1] = tt;
}
if (k[0] > k[1]) {
k[1] = k[0];
kk[1] = kk[0];
k[0] = t;
kk[0] = tt;
}
}
int main() {
double a[4] = {100.0, 100.0, 100.0, 100.0};
double b[4] = {100.0, 100.0, 100.0, 100.0};
double c[4] = {100.0, 100.0, 100.0, 100.0};
double k[2] = {100.0, 100.0};
int aa[4];
int bb[4];
int cc[4];
int kk[2];
double d;
int dd;
for (int i = 0; i < 8; i++) {
cin >> dd >> d;
if (a[3] > d) {
a[3] = d;
aa[3] = dd;
}
for (int j = 2; j >= 0; j--) {
if (a[j] > a[j+1]) {
a[j+1] = a[j];
aa[j+1] = aa[j];
a[j] = d;
aa[j] = dd;
}
}
}
for (int i = 0; i < 8; i++) {
cin >> dd >> d;
if (b[3] > d) {
b[3] = d;
bb[3] = dd;
}
for (int j = 2; j >= 0; j--) {
if (b[j] > b[j+1]) {
b[j+1] = b[j];
bb[j+1] = bb[j];
b[j] = d;
bb[j] = dd;
}
}
}
for (int i = 0; i < 8; i++) {
cin >> dd >> d;
if (c[3] > d) {
c[3] = d;
cc[3] = dd;
}
for (int j = 2; j >= 0; j--) {
if (c[j] > c[j+1]) {
c[j+1] = c[j];
cc[j+1] = cc[j];
c[j] = d;
cc[j] = dd;
}
}
}
hantei(k,a[2],kk,aa[2]);
hantei(k,a[3],kk,aa[3]);
hantei(k,b[2],kk,bb[2]);
hantei(k,b[3],kk,bb[3]);
hantei(k,c[2],kk,cc[2]);
hantei(k,c[3],kk,cc[3]);
printf("%d %.2f\n%d %.2f\n%d %.2f\n%d %.2f\n%d %.2f\n%d %.2f\n%d %.2f\n%d %.2f\n", aa[0], a[0], aa[1], a[1], bb[0], b[0], bb[1], b[1], cc[0], c[0], cc[1], c[1], kk[0], k[0], kk[1], k[1]);
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void _read(T& x) {
cin >> x;
}
void R() {}
template <typename T, typename... U>
void R(T& head, U&... tail) {
_read(head);
R(tail...);
}
template <typename T>
inline void _write(const T& x) {
cout << x << ' ';
}
void W() { cout << endl; }
template <typename T, typename... U>
void W(const T& head, const U&... tail) {
_write(head);
W(tail...);
}
template <typename T>
void debug(vector<T> V) {
for (auto x : V) {
cout << x << " ";
}
cout << endl;
}
void go();
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
go();
return 0;
}
void go() {
int t;
R(t);
while (t--) {
long long a, b;
R(a, b);
long long ans = 0;
while (a) {
if (a % b == 0) {
ans++;
a /= b;
} else {
long long w = a % b;
ans += w;
a -= w;
}
}
W(ans);
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct apple {
int first, second;
bool operator<(const apple &other) const {
if (first == other.first) return second < other.second;
return first < other.first;
}
} tt, sol[1000011];
struct point {
int v, nxt;
} edge[1000011 * 3];
map<int, int> hashh;
map<apple, int> fan;
int ans[111], s[101111], n = 4, cnt, dp[1000011], vist[1000011], tot, head,
tail, indexx[1000011], tot1;
int que[1000011 * 11], d[1000011];
void change_back(int *a, int temp) {
for (int i = n; i >= 0; i--) {
a[i] = temp % 10;
temp /= 10;
}
}
int change(int *a) {
int ret = 0;
for (int i = 0; i <= n; i++) {
ret = ret * 10 + a[i];
}
return hashh[ret];
}
void find(int dep, int rest) {
if (dep == 5) {
int temp = 0;
for (int i = 0; i <= 4; i++) {
temp = temp * 10 + ans[i];
}
s[++cnt] = temp;
hashh[temp] = cnt;
return;
}
if (dep == 4) {
ans[dep] = rest;
find(dep + 1, 0);
return;
}
for (int i = 0; i <= rest; i++) {
ans[dep] = i;
find(dep + 1, rest - i);
}
}
void addedge(int x, int y) {
edge[++tot1].v = y;
edge[tot1].nxt = indexx[x];
indexx[x] = tot1;
d[y]++;
}
void put_edge(int nn) {
int a[11], b[11], x, y, temp, vv;
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
x = sol[nn].first;
y = sol[nn].second;
change_back(a, s[x]);
change_back(b, s[y]);
if (b[0] == 8) {
dp[nn] = 2;
if (vist[nn]) return;
vist[nn] = 1;
que[++tail] = nn;
return;
}
for (int i = 1; i <= n; i++) {
if (!a[i]) continue;
for (int j = 1; j <= n; j++) {
if (!b[j]) continue;
a[(i + j) % 5]++;
a[i]--;
temp = change(a);
tt.first = y;
tt.second = temp;
vv = fan[tt];
addedge(vv, nn);
a[(i + j) % 5]--;
a[i]++;
}
}
}
void bfs() {
int t, vv, u;
while (head < tail) {
head++;
u = que[head];
t = indexx[u];
while (t) {
vv = edge[t].v;
d[vv]--;
if (!vist[vv]) {
if (dp[u] == 2) {
dp[vv] = 1;
vist[vv] = 1;
que[++tail] = vv;
} else if (d[vv] == 0) {
dp[vv] = 2;
vist[vv] = 1;
que[++tail] = vv;
}
}
t = edge[t].nxt;
}
}
}
int main() {
int a[11], b[11], x, y, T, op;
find(0, 8);
for (int i = 1; i <= cnt; i++) {
for (int j = 1; j <= cnt; j++) {
tt.first = i;
tt.second = j;
tot++;
sol[tot] = tt;
fan[tt] = tot;
}
}
for (int i = 1; i <= tot; i++) {
put_edge(i);
}
bfs();
scanf("%d", &T);
while (T--) {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
scanf("%d", &op);
for (int i = 1; i <= 8; i++) {
scanf("%d", &x);
a[x]++;
}
for (int i = 1; i <= 8; i++) {
scanf("%d", &x);
b[x]++;
}
x = change(a);
y = change(b);
tt.first = x;
tt.second = y;
int nn = fan[tt];
if (op == 0) {
if (dp[nn] == 0)
printf("Deal\n");
else if (dp[nn] == 1)
printf("Alice\n");
else if (dp[nn] == 2)
printf("Bob\n");
} else {
tt.first = y;
tt.second = x;
nn = fan[tt];
if (dp[nn] == 0)
printf("Deal\n");
else if (dp[nn] == 1)
printf("Bob\n");
else if (dp[nn] == 2)
printf("Alice\n");
}
}
return 0;
}
| 12 | CPP |
n,t=input().split()
n=int(n)
t=int(t)
l=list(map(int,input().split()))
c=0
for i in range(n):
if l[i]<=t:
c=c+1
else:
c=c+2
print(c)
| 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int ans[600010],A,B,n,f[600010],g[600010],len,nw,lenn,nww;
char s[200010],ss[200010];
int main()
{
scanf("%d%s",&n,s),len=strlen(s),A=B=1;
for (int i=1; i<=(n+1)/2; i++) A*=3;
for (int i=(n+1)/2; i<n; i++) B*=3;
for (int i=0; i<A*B; i++) f[i]=f[i/3]*3+(i*2%3),g[i]=(i+1)%(A*B);
for (int i=0; i<A; i++)
{
nw=i,lenn=0,ss[0]='P';
for (int j=0; j<len; j++)
if (s[j]=='R')
{
nw=g[nw];
if (nw%A==0) ss[++lenn]='R';
} else
{
nw=f[nw];
if (ss[lenn]=='S') lenn--; else ss[++lenn]='S';
}
ans[i]=nw,nw%=A;
for (int j=1; j<B; j++)
{
nww=j;
for (int k=1; k<=lenn; k++)
if (ss[k]=='R') nww=g[nww]; else nww=f[nww];
ans[j*A+i]=nww%B*A+nw;
}
}
for (int i=0; i<A*B; i++) printf("%d ",ans[i]);
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[405], cnum[405];
void greedy(int w) {
for (int i = 1; i <= n; i++) {
cnum[i] = w / a[i];
w = w - cnum[i] * a[i];
}
}
int main() {
int ans = (1 << 30);
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
greedy(a[i] - 1);
cnum[j]++;
int num1 = 0, w = 0, num2 = 0;
for (int k = 1; k <= j; k++) num1 += cnum[k], w += (a[k] * cnum[k]);
if (w >= ans) continue;
greedy(w);
for (int k = 1; k <= n; k++) num2 += cnum[k];
if (num1 < num2 && w < ans) ans = w;
}
}
if (ans == (1 << 30)) ans = -1;
printf("%d\n", ans);
}
| 11 | CPP |
t=int(input())
a=list(map(int,input().split()))
b=[]
for i in a[::-1]:
if a.count(i)>1 and i not in b:
b.append(i)
a.remove(i)
if a.count(i)==1 and i not in b:
b.append(i)
print(len(b))
for j in b[::-1]:
print(j,end=" ") | 7 | PYTHON3 |
#include <iostream>
#include <algorithm>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
#define F first
#define S second
#define PB push_back
typedef long long int ll;
constexpr int kN = int(5E1 + 10);
constexpr ll kInf = ll(1E16 + 10);
string s[kN];
int c[kN], sz[kN], idx[kN][kN];
vector<pair<int, ll>> graph[kN * kN];
ll dp[kN * kN];
int main() {
int n, now, tot = 0, lpos, rpos;
ll ans = kInf;
priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<pair<ll, int>>> pq;
pair<ll, int> nxt;
cin >> n;
for (int i = 1; i <= n; i++) cin >> s[i] >> c[i];
for (int i = 1; i <= n; i++) sz[i] = int(s[i].size());
for (int i = 1; i <= n; i++) for (int j = 0; j <= (sz[i] << 1) + 1; j++) idx[i][j] = ++tot;
for (int i = 1; i <= n; i++) for (int j = 0; j < sz[i]; j++) {
for (int k = 1; k <= n; k++) {
now = 0;
while (now < sz[k] && now + j < sz[i]) {
if (s[i][now + j] == s[k][sz[k] - 1 - now]) now++;
else break;
}
if (now == sz[k]) graph[idx[i][j]].PB({idx[i][now + j], c[k]});
else if (now + j == sz[i]) graph[idx[i][j]].PB({idx[k][now + sz[k] + 1], c[k]});
now = 0;
while (now < sz[k] && now + j < sz[i]) {
if (s[i][sz[i] - now - j - 1] == s[k][now]) now++;
else break;
}
if (now == sz[k]) graph[idx[i][j + sz[i] + 1]].PB({idx[i][now + j + sz[i] + 1], c[k]});
else if (now + j == sz[i]) graph[idx[i][j + sz[i] + 1]].PB({idx[k][now], c[k]});
}
}
for (int i = 1; i <= tot; i++) dp[i] = kInf;
for (int i = 1; i <= n; i++) pq.push({dp[idx[i][0]] = c[i], idx[i][0]});
while (!pq.empty()) {
nxt = pq.top();
pq.pop();
if (dp[nxt.S] < nxt.F) continue;
for (pair<int, ll> i : graph[nxt.S]) if (dp[i.F] > nxt.F + i.S) {
dp[i.F] = nxt.F + i.S;
pq.push({dp[i.F], i.F});
}
}
for (int i = 1; i <= n; i++) ans = min(ans, dp[idx[i][sz[i]]]);
for (int i = 1; i <= n; i++) ans = min(ans, dp[idx[i][sz[i] << 1 | 1]]);
for (int i = 1; i <= n; i++) for (int j = 0; j < sz[i]; j++) {
lpos = j, rpos = sz[i] - 1;
while (lpos < rpos) {
if (s[i][lpos] == s[i][rpos]) lpos++, rpos--;
else break;
}
if (lpos >= rpos) ans = min(ans, dp[idx[i][j]]);
lpos = j, rpos = sz[i] - 1;
while (lpos < rpos) {
if (s[i][sz[i] - 1 - lpos] == s[i][sz[i] - 1 - rpos]) lpos++, rpos--;
else break;
}
if (lpos >= rpos) ans = min(ans, dp[idx[i][j + sz[i] + 1]]);
}
if (ans == kInf) ans = -1;
cout << ans << '\n';
}
| 0 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
std::pair<int, int> DR[] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1},
{-1, 1}, {-1, -1}, {1, 1}, {1, -1}};
using namespace std;
const long long mod = 1e9 + 7;
long long dp[1 << 17][3][42];
long long pd[3][42];
vector<long long> vec[1 << 17];
long long a, b, n, m, k, x;
void dfs(long long nod, long long par) {
dp[nod][0][0] = k - 1;
dp[nod][1][1] = 1;
dp[nod][2][0] = m - k;
if ((long long)((vec[nod]).size()) == 1 && nod != 1) return;
for (auto it : vec[nod]) {
if (it != par) {
dfs(it, nod);
for (long long i = 0; i < 3; i++) memset(pd[i], 0, sizeof(pd[i]));
for (long long sum = x; sum + 1; sum--) {
for (long long rudi = 0; rudi <= sum; rudi++) {
pd[0][sum] +=
(((dp[it][0][rudi] + dp[it][1][rudi] + dp[it][2][rudi]) % mod) *
dp[nod][0][sum - rudi]) %
mod;
pd[1][sum] +=
(((dp[it][0][rudi]) % mod) * dp[nod][1][sum - rudi]) % mod;
pd[2][sum] += (((dp[it][0][rudi] + dp[it][2][rudi]) % mod) *
dp[nod][2][sum - rudi]) %
mod;
pd[0][sum] %= mod;
pd[1][sum] %= mod;
pd[2][sum] %= mod;
}
}
for (long long i = 0; i < 3; i++)
for (long long sum = x; sum + 1; sum--) {
dp[nod][i][sum] = pd[i][sum];
dp[nod][i][sum] %= mod;
}
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cerr.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 1; i < n; i++) {
cin >> a >> b;
vec[a].push_back(b);
vec[b].push_back(a);
}
cin >> k >> x;
dfs(1, 0);
long long ans = 0;
for (long long i = 0; i <= x; i++) {
ans += (dp[1][0][i] + dp[1][1][i] + dp[1][2][i]) % mod;
ans %= mod;
}
return cout << ans, 0;
}
| 9 | CPP |
# Anton and Danik
n = int(input()) # Number of games played
s = input()
if s.count("A") > s.count("D"):
print("Anton")
elif s.count("D") > s.count("A"):
print("Danik")
else:
print("Friendship")
| 7 | PYTHON3 |
print(min(int(input()),int(input())//2,int(input())//4)*7)
| 7 | PYTHON3 |
#include <iostream>
using namespace std;
int n;
long long int a;
bool ok = true;
int main()
{
cin >> n;
while (n--)
{
cin >> a;
if (a % 2 == 1)
ok = false;
}
if (ok)
cout << "second";
else
cout << "first";
}
| 0 | CPP |
n = str(input().lower())
s = set(n)
l = len(s)
if l % 2 == 0:
print("CHAT WITH HER!")
else:
print("IGNORE HIM!") | 7 | PYTHON3 |
N = int(input())
L = list(map(int,input().split()))
s = sum(L)
p = 0
for a in L:
p += a*a
ans=(s*s-p)/2
print(int(ans)) | 0 | PYTHON3 |
N = int(input())
S =input()
if S.count('B') < S.count('R'):
print('Yes')
else:
print('No') | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<int,P> P1;
typedef pair<P,P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define mod 1000000007
#define fi first
#define sc second
#define rep(i,x) for(int i=0;i<x;i++)
#define repn(i,x) for(int i=1;i<=x;i++)
#define SORT(x) sort(x.begin(),x.end())
#define ERASE(x) x.erase(unique(x.begin(),x.end()),x.end())
#define POSL(x,v) (lower_bound(x.begin(),x.end(),v)-x.begin())
#define POSR(x,v) (upper_bound(x.begin(),x.end(),v)-x.begin())
int n,m;
char f[305][305],ff[305][305];
ll ans ;
int pos[605][305][305];
vector<int>cnt[605];
ll sol(){
rep(i,605) {cnt[i].clear(); rep(j,305)rep(k,305) pos[i][j][k]=0;}
rep(i,n) rep(j,m){
if(f[i][j] != '#') continue;
cnt[i+j].pb(i);
}
rep(i,605) SORT(cnt[i]);
rep(i,605){
if(cnt[i].empty()) continue;
rep(j,cnt[i].size()) for(int k=j+1;k<cnt[i].size();k++){
int dif = cnt[i][k]-cnt[i][j];
pos[i][dif][cnt[i][j]]++;
}
}
rep(i,605)rep(j,305)rep(k,305){ if(k) pos[i][j][k] += pos[i][j][k-1];}
ll ret = 0;
rep(i,n) rep(j,m){
if(f[i][j] != '#') continue;
for(int k=i+j+2;k<=n-1+m-1;k+=2){
int lb = i+1, ub = k-j-(k-i-j)/2-1;
int x = 0;
if(0<=lb-1 && lb-1<305) x+=pos[k][(k-i-j)/2][lb-1];//POSL(pos[k][(k-i-j)/2],lb);
int y = 0;
if(0<=ub) y+=pos[k][(k-i-j)/2][min(303,ub)];//POSR(pos[k][(k-i-j)/2],ub);
ans += y-x;
}
for(int k=i+j-2;k>=0;k-=2){
int lb = k-j+1, ub = i-(i+j-k)/2-1;
int x = 0;
if(0<=lb-1 && lb-1<305) x+=pos[k][(i+j-k)/2][lb-1];//POSL(pos[k][(i+j-k)/2],lb);
int y = 0;
if(0<=ub) y+=pos[k][(i+j-k)/2][min(303,ub)];//POSR(pos[k][(i+j-k)/2],ub);
ans += y-x;
}
}
return ret;
}
int main(){
scanf("%d%d",&n,&m);
rep(i,n) scanf("%s",&f[i]);
rep(i,n){
rep(j,m) for(int k=j+1;k<m;k++){
if(f[i][j]=='#'&&f[i][k]=='#'&&j%2==k%2){
int mm = (j+k)/2;
int d = (k-j)/2;
if(0<=i-d&&i-d<n&&f[i-d][mm]=='#') ans++;
if(0<=i+d&&i+d<n&&f[i+d][mm]=='#') ans++;
}
}
}
rep(i,m){
rep(j,n) for(int k=j+1;k<n;k++){
if(f[j][i]=='#'&&f[k][i]=='#'&&j%2==k%2){
int mm = (j+k)/2;
int d = (k-j)/2;
if(0<=i-d&&i-d<m&&f[mm][i-d]=='#') ans++;
if(0<=i+d&&i+d<m&&f[mm][i+d]=='#') ans++;
}
}
}
//本質
ans += sol();
rep(i,n)rep(j,m) ff[i][j] = f[i][m-1-j];
rep(i,n)rep(j,m) f[i][j] = ff[i][j];
ans += sol();
cout << ans << endl;
} | 0 | CPP |
for z in range(int(input())):
b = []
c = 9
a = int(input())
b = list(map(int, input().split()))
for j in range(len(b)):
for i in range(j):
# print(j,i,b[j],b[i])
if b[j] == b[i]:
c = 8
break
# print(c)
if c != 8:
print(b[j], end=" ")
c = 9
print("\n") | 8 | PYTHON3 |
import sys
import os
from io import IOBase, BytesIO
# import heapq
import math
# import collections
# import itertools
# import bisect
mod = 10 ** 9 + 7
pie = 3.1415926536
# import resource
# resource.setrlimit(resource.RLIMIT_STACK, [0x100000000, resource.RLIM_INFINITY])
# import threading
# threading.stack_size(2**27)
# import sys
# sys.setrecursionlimit(10**6)
# fact=[1]
# for i in range(1,1000001):
# fact.append((fact[-1]*i)%mod)
# ifact=[0]*1000001
# ifact[1000000]=pow(fact[1000000],mod-2,mod)
# for i in range(1000000,0,-1):
# ifact[i-1]=(i*ifact[i])%mod
# from random import randint as rn
# from Queue import Queue as Q
def modinv(n, p):
return pow(n, p-2, p)
def ncr(n, r, p): # for using this uncomment the lines calculating fact and ifact
t = ((fact[n])*((ifact[r]*ifact[n-r]) % p)) % p
return t
def ain(): # takes array as input
return list(map(int, sin().split()))
def sin():
return input().strip()
def GCD(x, y):
while(y):
x, y = y, x % y
return x
def read2DIntArray(row, col):
arr = []
for i in range(0, row):
temp = list(map(int, sin().split()))
arr.append(temp)
return arr
def read2DCharArray(row, col):
arr = []
for i in range(0, row):
temp = str(sin())
arr.append(temp)
return arr
"""****************** SMALLEST NO. BY REARRANGING DIGITS OF n (WITHOUT TRAILING ZEROS) *********************"""
def smallestNumber(n):
lst = list(str(n))
lst.sort()
tmp = ""
for i, n in enumerate(lst):
if (n != '0'):
tmp = lst.pop(i)
break
return str(tmp) + ''.join(lst)
"""*********************** GENERATE ALL PRIME NUMBERS SMALLER THAN OR EQUAL TO n ***************************"""
def SieveOfEratosthenes(n):
prime = [True for i in range(n + 1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 1
prime[0] = False
prime[1] = False
lst = []
for p in range(n + 1):
if prime[p]:
lst.append(p)
return lst
"""*************************************** FIND nCr ********************************************************"""
def nCr(n, r):
a = 1
b = 1
c = 1
for i in range(1, n + 1):
c *= i
for i in range(1, r + 1):
b *= i
for i in range(1, n - r + 1):
a *= i
return (c // (a * b))
"""************************* GET PRIME FACTORS AND THEIR POWERS FOR AN INTEGER *****************************"""
def sieveOfEratosthenes1(N, s):
prime = [False] * (N+1)
for i in range(2, N+1, 2):
s[i] = 2
for i in range(3, N+1, 2):
if (prime[i] == False):
s[i] = i
for j in range(i, int(N / i) + 1, 2):
if (prime[i*j] == False):
prime[i*j] = True
s[i * j] = i
def generatePrimeFactors(N):
s = [0] * (N+1)
sieveOfEratosthenes1(N, s)
# print("Factor Power")
curr = s[N]
cnt = 1
factors = []
power = []
while (N > 1):
N //= s[N]
if (curr == s[N]):
cnt += 1
continue
# curr is factor and cnt in the power of this factor
factors.append(curr)
power.append(cnt)
curr = s[N]
cnt = 1
return factors, power
"""----------------------------------------------MAIN------------------------------------------------------"""
def main():
for _ in range(int(sin())):
n = int(sin())
s = sin()
dic = {}
dic[(0, 0)] = [0]
x, y = 0, 0
l = -1
r = -1
length = 2 * 10 ** 5 + 1
for i in range(n):
d = s[i]
if d == "R":
x += 1
elif d == "L":
x -= 1
elif d == "U":
y += 1
else:
y -= 1
if (x, y) in dic.keys():
dic[(x, y)].append(i + 1)
else:
dic[(x, y)] = [i + 1]
for ele in dic:
l1 = dic[ele]
if len(l1) > 1:
for i in range(len(l1) - 1):
if l1[i + 1] - l1[i] < length:
length = l1[i + 1] - l1[i]
l = l1[i] + 1
r = l1[i + 1]
if l == -1 and r == -1:
print("-1")
else:
print(l, r)
# l = -1
# length = 2*10**5+1
# for i in range(n - 1):
# if s[i] == "L":
# if s[i + 1] == "R":
# l = i + 1
# length = min(length, 2)
# elif i + 2 < n and i + 3 < n and s[i + 1] == "U" and s[i + 2] == "R" and s[i + 3] == "D":
# l = i + 1
# length = min(length, 4)
# elif i + 2 < n and i + 3 < n and s[i + 1] == "D" and s[i + 2] == "R" and s[i + 3] == "U":
# l = i + 1
# length = min(length, 4)
# elif s[i] == "R":
# if s[i + 1] == "L":
# l = i + 1
# length = min(length, 2)
# elif i + 2 < n and i + 3 < n and s[i + 1] == "U" and s[i + 2] == "L" and s[i + 3] == "D":
# l = i + 1
# length = min(length, 4)
# elif i + 2 < n and i + 3 < n and s[i + 1] == "D" and s[i + 2] == "L" and s[i + 3] == "U":
# l = i + 1
# length = min(length, 4)
# elif s[i] == "U":
# if s[i + 1] == "D":
# l = i + 1
# length = min(length, 2)
# elif i + 2 < n and i + 3 < n and s[i + 1] == "R" and s[i + 2] == "D" and s[i + 3] == "L":
# l = i + 1
# length = min(length, 4)
# elif i + 2 < n and i + 3 < n and s[i + 1] == "L" and s[i + 2] == "D" and s[i + 3] == "R":
# l = i + 1
# length = min(length, 4)
# elif s[i] == "D":
# if s[i + 1] == "U":
# l = i + 1
# length = min(length, 2)
# elif i + 2 < n and i + 3 < n and s[i + 1] == "R" and s[i + 2] == "U" and s[i + 3] == "L":
# l = i + 1
# length = min(length, 4)
# elif i + 2 < n and i + 3 < n and s[i + 1] == "L" and s[i + 2] == "U" and s[i + 3] == "R":
# l = i + 1
# length = min(length, 4)
# if length == 2:
# break
# if l == -1:
# print("-1")
# else:
# print(str(l) + " " + str(l + length - 1))
"""--------------------------------------------------------------------------------------------------------"""
# Python 2 and 3 footer by Pajenegod and j1729
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0, 2),
super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill():
pass
return super(FastIO, self).read()
def readline(self):
while self.newlines == 0:
s = self._fill()
self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
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)
def input(): return sys.stdin.readline().rstrip('\r\n')
if __name__ == '__main__':
main()
# threading.Thread(target=main).start()
| 9 | PYTHON3 |
n=int(input())
s=input()
l=s.lower()
if(len(set(l))==26):
print("YES")
else:
print("NO") | 7 | PYTHON3 |
import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
p = 10**9+7
n = int(input())
a = list( map(int, input().split()))
count = [0]*n
for i in range(n+1):
count[a[i]-1] += 1
if count[a[i]-1] == 2:
right = i
left = a.index(a[i])
break
def nCr_mod_p(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10 ** 9 + 7
N = 10 ** 5 # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p), 0! = 1! = 1
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p), 0! = 1! = 1
inv = [0, 1] # inv[n] = n^(-1) mod p, 0! = 1 だけど便宜上inv[0]=0にしてる
for i in range(2, N + 2):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
for i in range(1,n+2):
ans = nCr_mod_p(n+1,i,p) - nCr_mod_p(n-right+left,i-1,p)
print(ans%p)
| 0 | PYTHON3 |
import math
for _ in range(int(input())):
a,b=map(int,input().split())
c=abs(a-b)
if(a==b):
print(c)
else:
k=c//10
if(c%10==0):
print(math.floor(k))
else:
print(math.floor(k)+1) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const char en = '\n';
void solve() {
int n;
scanf("%d", &n);
int i;
vector<int> a(n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int ans = a[0];
for (i = 1; i < n; i++) {
ans = ans & a[i];
}
cout << ans << en;
}
int main() {
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> temp(100005);
vector<int> v(100005);
int fn(int l, int h, int x) {
while (h - l > 1) {
int mid = (h + l) / 2;
if (temp[mid] >= x) {
h = mid;
} else {
l = mid;
}
}
if (temp[h] > x)
return h;
else
return l;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int len = 1;
temp[0] = v[0];
for (int i = 1; i < n; i++) {
if (temp[0] > v[i]) {
temp[0] = v[i];
} else if (v[i] > temp[len - 1]) {
temp[len] = v[i];
len++;
} else {
int index = fn(0, len - 1, v[i]);
temp[index] = v[i];
}
}
cout << len;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 30;
const int MAXM = 30;
int N, M;
int X[MAXN][MAXM];
int total_cost;
vector<vector<int>> answer;
void cycle(vector<pair<int, int>> vec) {
assert(!vec.empty());
vector<int> vals;
for (auto it : vec) {
assert(0 <= it.first && it.first < N);
assert(0 <= it.second && it.second < M);
vals.push_back(X[it.first][it.second]);
}
total_cost += int(vals.size());
answer.push_back(vals);
int prv = vals.back();
for (auto it : vec) {
int cur = X[it.first][it.second];
X[it.first][it.second] = prv;
prv = cur;
}
}
void cycleDown(int i, int j) {
assert(0 <= i && i + 1 < N);
assert(0 <= j && j + 1 < M);
cycle(vector<pair<int, int>>{{i, j}, {i + 1, j}, {i + 1, j + 1}, {i, j + 1}});
}
void cycleRight(int i, int j) {
assert(0 <= i && i + 1 < N);
assert(0 <= j && j + 1 < M);
cycle(vector<pair<int, int>>{{i, j}, {i, j + 1}, {i + 1, j + 1}, {i + 1, j}});
}
void moveRight(int& i, int& j) {
assert(j + 1 < M);
if (i < N - 1) {
cycleRight(i, j);
} else {
cycleDown(i - 1, j);
}
j++;
}
void moveLeft(int& i, int& j) {
assert(j - 1 >= 0);
if (i < N - 1) {
cycleDown(i, j - 1);
} else {
cycleRight(i - 1, j - 1);
}
j--;
}
void moveUp(int& i, int& j) {
assert(i - 1 >= 0);
if (j < M - 1) {
cycleRight(i - 1, j);
} else {
cycleDown(i - 1, j - 1);
}
i--;
}
void moveDown(int& i, int& j) {
assert(i + 1 < N);
if (j < M - 1) {
cycleDown(i, j);
} else {
cycleRight(i, j - 1);
}
i++;
}
void swapBot() {
cycle(vector<pair<int, int>>{{N - 2, M - 3},
{N - 2, M - 2},
{N - 2, M - 1},
{N - 1, M - 1},
{N - 1, M - 2},
{N - 1, M - 3}});
cycleDown(N - 2, M - 3);
cycleDown(N - 2, M - 2);
}
void swapRight() {
cycleRight(N - 2, M - 2);
swapBot();
cycleDown(N - 2, M - 2);
}
void find(int v, int& i, int& j) {
for (i = 0; i < N; i++) {
for (j = 0; j < M; j++) {
if (X[i][j] == v) return;
}
}
assert(false);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> N >> M;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
cin >> X[i][j];
X[i][j]--;
}
}
for (int di = 0; di < N - 2; di++) {
for (int dj = 0; dj < M; dj++) {
int v = di * M + dj;
int si, sj;
find(v, si, sj);
assert(si >= di);
while (sj > dj) {
moveLeft(si, sj);
}
while (sj < dj) {
moveRight(si, sj);
}
assert(sj == dj);
assert(si >= di);
if (dj < M - 1) {
while (si > di) {
moveUp(si, sj);
}
assert(si == di && sj == dj);
} else {
if (si == di) continue;
assert(si > di);
if (si == di + 1) {
moveDown(si, sj);
}
while (si > di + 2) {
moveUp(si, sj);
}
assert(si == di + 2);
cycleRight(di, dj - 1);
cycleRight(di, dj - 1);
cycle(vector<pair<int, int>>{{di + 2, dj},
{di + 1, dj},
{di, dj},
{di, dj - 1},
{di + 1, dj - 1},
{di + 2, dj - 1}});
cycle(vector<pair<int, int>>{{di + 2, dj},
{di + 1, dj},
{di, dj},
{di, dj - 1},
{di + 1, dj - 1},
{di + 2, dj - 1}});
assert(X[di][dj] == v);
}
}
}
for (int dj = 0; dj < M - 2; dj++) {
for (int di = N - 2; di < N; di++) {
int v = di * M + dj;
int si, sj;
find(v, si, sj);
while (si > di) {
moveUp(si, sj);
}
while (si < di) {
moveDown(si, sj);
}
assert(si == di);
assert(sj >= dj);
if (di == N - 2) {
while (sj > dj) {
moveLeft(si, sj);
}
assert(si == di && sj == dj);
continue;
} else {
if (sj == dj) continue;
assert(sj > dj);
if (sj == dj + 1) {
moveRight(si, sj);
}
while (sj > dj + 2) {
moveLeft(si, sj);
}
assert(sj == dj + 2);
cycleRight(di - 1, dj);
cycleRight(di - 1, dj);
cycle(vector<pair<int, int>>{{di, dj + 2},
{di, dj + 1},
{di, dj},
{di - 1, dj},
{di - 1, dj + 1},
{di - 1, dj + 2}});
cycle(vector<pair<int, int>>{{di, dj + 2},
{di, dj + 1},
{di, dj},
{di - 1, dj},
{di - 1, dj + 1},
{di - 1, dj + 2}});
assert(X[di][dj] == v);
}
}
}
int va = (N - 2) * M + (M - 2);
while (X[N - 2][M - 2] != va) cycleRight(N - 2, M - 2);
int vd = (N - 1) * M + (M - 1);
if (X[N - 1][M - 2] == vd) {
swapBot();
}
if (X[N - 2][M - 1] == vd) {
swapRight();
}
assert(X[N - 1][M - 1] == vd);
if (X[N - 2][M - 1] != (N - 2) * M + (M - 1)) {
swapBot();
swapRight();
swapBot();
}
cerr << total_cost << ' ' << "moves" << '\n';
cout << answer.size() << '\n';
for (const auto& vec : answer) {
cout << vec.size();
for (int v : vec) {
cout << ' ' << v + 1;
}
cout << '\n';
}
}
| 11 | CPP |
n = int(input())
first = sorted(list(map(int,input().split())))
second = sorted(list(map(int,input().split())))
third = sorted(list(map(int,input().split())))
f = False
for i in range(n-1):
if first[i] != second[i]:
print(first[i])
f = True
break
if f == False:
print(first[n-1])
else:
f = False
for i in range(n-2):
if second[i] != third[i]:
print(second[i])
f = True
break
if f == False:
print(second[n-2])
else:
pass
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define PI 3.14159265358979323
#define ll int
#define vi vector <int>
#define vl vector <ll>
#define all(v) (v).begin(),(v).end()
#define pb push_back
#define ff first
#define ss second
#define MOD 1000000007
ll power(ll a, ll b) { //a^b
ll res = 1;
a = a % MOD;
while (b > 0) {
if (b & 1) {res = (res * a) % MOD; b--;}
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
ll gcd(ll a, ll b) {return (b == 0) ? a : gcd(b, a % b);}
vector <vl> adj(400005);
vl vis(400005);
vl vis2(400005);
vl top;
void dfs(ll u) {
for (auto i : adj[u]) {
if (vis[i] == 0) {
vis[i] = 1;
dfs(i);
}
}
}
void dfs2(ll u) {
for (auto i : adj[u]) {
if (!vis2[i]) {
vis2[i] = 1;
dfs2(i);
}
}
top.pb(u);
}
int main() {
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t;
cin >> t;
while (t--) {
ll n, m;
cin >> n >> m;
top.clear();
for (ll i = 0; i < n; i++) {
adj[i].clear();
vis[i] = 0;
vis2[i] = 0;
}
vector <pair<ll, ll>> edges;
for (ll i = 0; i < m; i++) {
ll u, v;
cin >> u >> v;
u--;
v--;
adj[u].pb(v);
edges.pb({u, v});
}
vis[0] = 1;
dfs(0);
for (ll i = 0; i < n; i++) {
if (!vis2[i]) {
vis2[i] = 1;
dfs2(i);
}
}
reverse(all(top));
vl ans(n, 0);
map <ll, ll> pos;
for (ll i = 0; i < n; i++) {
if (vis[i])
ans[i] = 1;
pos[top[i]] = i;
}
set <ll> cyc;
for (auto i : edges) {
if (pos[i.ff] < pos[i.ss])
continue;
if (vis[i.ff] && ans[i.ff] != -1) {
ans[i.ff] = -1;
cyc.insert(i.ff);
}
if (vis[i.ss] && ans[i.ss] != -1) {
ans[i.ss] = -1;
cyc.insert(i.ss);
}
}
queue <ll> q;
for (auto i : cyc)
q.push(i);
while (!q.empty()) {
ll cur = q.front();
q.pop();
for (auto i : adj[cur]) {
if (ans[i] != -1) {
ans[i] = -1;
q.push(i);
}
}
}
vl cnt(n, 0);
cnt[0] = 1;
for (ll i = pos[0]; i < n; i++) {
ll cur = top[i];
if (!vis[cur])
continue;
for (auto j : adj[cur]) {
if (cnt[j] == 0)
cnt[j] = cnt[cur];
else
cnt[j] = 2;
}
}
for (ll i = 0; i < n; i++) {
if (ans[i] == 1 && cnt[i] > 1)
ans[i] = 2;
cout << ans[i] << " ";
}
cout << "\n";
}
}
| 13 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.