solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
n = int(input())
num = [int(x) for x in input().split()]
maxlen = 0
lenc = 0
pre = 0
for i in range(0, n):
if (num[i] >= pre):
lenc += 1
else:
maxlen = max(maxlen, lenc)
lenc = 1
pre = num[i]
maxlen = max(maxlen, lenc)
print(maxlen) | 900 | PYTHON3 |
import sys
a, b = [int(x) for x in input().split()]
p = [int(y) for y in input().split()]
if p[0] == 0:
print(0)
sys.exit()
while p[b-1] == 0:
b -= 1
if b == 0:
print(1)
c = p[b-1]
wyn = b
for i in p[b:]:
if i == c:
wyn += 1
print(wyn) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
string s;
string s1;
int a[5005];
int q[5005];
bool vis[5005];
int main() {
while (cin >> s1) s = s + s1;
int l = s.size();
int cnt = 0;
for (int i = 0; i < l;) {
if (s[i + 2] == 'a') {
a[cnt++] = 1;
i += 7;
} else if (s[i + 2] == 'r') {
a[cnt++] = 2;
i += 4;
} else if (s[i + 2] == 'd') {
a[cnt++] = 3;
i += 4;
} else if (s[i + 3] == 'a') {
a[cnt++] = 4;
i += 8;
} else if (s[i + 3] == 'r') {
a[cnt++] = 2;
i += 5;
} else if (s[i + 3] == 'd') {
a[cnt++] = 3;
i += 5;
}
}
int r = -1, mm = -1;
memset(vis, 0, sizeof(vis));
for (int i = 0; i < cnt; i++) {
if (a[i] == 1) {
q[++mm] = 0;
r = mm;
} else if (a[i] == 4) {
vis[r] = 1;
while (vis[r]) r--;
} else if (a[i] == 3)
q[r]++;
}
sort(q, q + mm + 1);
for (int i = 0; i <= mm; i++) cout << q[i] / 2 << " ";
cout << endl;
return 0;
}
| 1,700 | CPP |
t = int(input())
for j in range(t):
n, x = map(int, input().split())
d = [list(map(int, input().split())) for a in range(n)]
max_kick = 0
max_damage = 0
for i in range(n):
if d[i][0] > max_kick:
max_kick = d[i][0]
if (d[i][0] - d[i][1]) > max_damage:
max_damage = (d[i][0] - d[i][1])
if max_kick >= x:
print(1)
continue
else:
if max_kick == 0 or (max_kick != 0 and max_damage == 0) or (max_kick + max_damage == 0):
print(-1)
continue
kicks_to_win = (
(x - max_kick) // max_damage if
((x - max_kick) % max_damage == 0 and x - max_kick >= max_damage) else
(x - max_kick) // max_damage + 1
)
print(kicks_to_win + 1)
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool deb_mode = 0;
class debugger {
vector<string> vars;
public:
template <typename T>
debugger &operator,(const T v) {
stringstream ss;
ss << v, vars.push_back(ss.str());
return *this;
}
void printall() {
int j = 0, l = vars.size();
for (int i = 0; i < (l - 1); i++) {
if (i) cout << ", ";
for (j; j < vars[l - 1].size(); j++) {
if (vars[l - 1][j] == ',') {
j++;
break;
}
cout << vars[l - 1][j];
}
cout << " = " << vars[i];
}
vars.clear();
}
} Dbug;
template <typename T1, typename T2>
inline ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << "(" << p.first << "," << p.second << ")";
}
template <typename T>
inline ostream &operator<<(ostream &os, const vector<T> &v) {
bool first = true;
os << "{";
for (unsigned int i = 0; i < v.size(); i++) {
if (!first) os << ",";
os << v[i];
first = false;
}
return os << "}";
}
template <typename T>
inline ostream &operator<<(ostream &os, const set<T> &v) {
bool first = true;
os << "{";
for (typename set<T>::const_iterator ii = v.begin(); ii != v.end(); ++ii) {
if (!first) os << ",";
os << *ii;
first = false;
}
return os << "}";
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &os, const map<T1, T2> &v) {
bool first = true;
os << "{";
for (typename map<T1, T2>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ",";
os << *ii;
first = false;
}
return os << "}";
}
template <typename T>
void getarray(T a[], int b, int e) {
for (int i = b; i < e + b; i++) cin >> a[i];
}
template <typename T>
void printarray(T a[], int b, int e) {
for (int i = b; i < e - 1 + b; i++) cout << a[i] << " ";
if (e - 1 + b >= 0) cout << a[e - 1 + b] << endl;
}
template <typename T>
void printV(vector<T> v) {
int sz = v.size();
if (sz) cout << v[0];
for (int i = 1; i < sz; i++) cout << " " << v[i];
puts("");
}
template <typename T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <typename T>
T BigMod(T b, T p, T m) {
if (p == 0) return 1;
if (p % 2 == 0) {
T s = BigMod(b, p / 2, m);
return ((s % m) * (s % m)) % m;
}
return ((b % m) * (BigMod(b, p - 1, m) % m)) % m;
}
template <typename T>
T ModInv(T b, T m) {
return BigMod(b, m - 2, m);
}
template <class T>
inline void read(T &x) {
bool Minus = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') Minus = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (Minus) x = -x;
}
char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
int CI(int &_x) { return scanf("%d", &_x); }
int CI(int &_x, int &_y) { return scanf("%d %d", &_x, &_y); }
int CI(int &_x, int &_y, int &_z) { return scanf("%d %d %d", &_x, &_y, &_z); }
int CI(int &_a, int &_b, int &_c, int &_d) {
return scanf("%d %d %d %d", &_a, &_b, &_c, &_d);
}
template <class T>
string toString(T n) {
ostringstream oss;
oss << n;
return oss.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
long long int toLong(string s) {
long long int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
bool isVowel(char ch) {
ch = tolower(ch);
if (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')
return true;
return false;
}
bool isUpper(char c) { return c >= 'A' && c <= 'Z'; }
bool isLower(char c) { return c >= 'a' && c <= 'z'; }
int dr8[8] = {+1, -1, +0, +0, +1, -1, -1, +1};
int dc8[8] = {+0, +0, -1, +1, +1, +1, -1, -1};
int dr4[4] = {+0, +0, +1, -1};
int dc4[4] = {-1, +1, +0, +0};
int kn8r[8] = {+1, +2, +2, +1, -1, -2, -2, -1};
int kn8c[8] = {+2, +1, -1, -2, -2, -1, +1, +2};
const double EPS = 1e-9;
const int INF = (1 << 30) - 1;
const long long int LINF = (1ll << 62) - 1;
const int mod = (int)1e9 + 7;
const int MAX = (int)1e5;
string S;
int ans;
vector<string> names;
void solve() {
int inx = 0;
while (inx < S.size()) {
if (S[inx] == '.') {
names.pop_back();
inx++;
continue;
}
if (S[inx] == ':' || S[inx] == ',') {
inx++;
continue;
}
string s = "";
while (isUpper(S[inx])) {
s += S[inx];
inx++;
}
if (!s.empty()) {
for (int i = 0; i < names.size(); i++) {
if (names[i] == s) ans++;
}
names.push_back(s);
}
}
}
int main() {
if (deb_mode) srand(int(time(NULL)));
int i, j, k, l, n, m, q, a, b, c;
cin >> S;
solve();
cout << ans << "\n";
if (deb_mode) cerr << "TIME = " << clock() << " ms" << endl;
return 0;
}
| 1,700 | CPP |
d, sumTime = map(int, input().split())
minTime = []
maxTime = []
for i in range(d):
curMinTime, curMaxTime = map(int, input().split())
minTime.append(curMinTime)
maxTime.append(curMaxTime)
if sum(minTime) <= sumTime <= sum(maxTime):
print('YES')
needTime = sumTime
leftMaxTime = sum(maxTime)
spentEverday = []
for i in range(d):
leftMaxTime -= maxTime[i]
if leftMaxTime >= needTime:
spentEverday.append(minTime[i])
needTime -= minTime[i]
else:
spentEverday.append(needTime - leftMaxTime)
needTime = leftMaxTime
print(' '.join(map(str, spentEverday)))
else:
print('NO')
| 1,200 | PYTHON3 |
import math
def gcd(x, y):
if(y == 0):
return x
return gcd(y,x%y)
n = int(input())
ans = 0
m = int(math.sqrt(n))
for a in range(1,m+1):
for b in range(a,m+1):
c = a*a+b*b
if(c > n):
break
if((b-a) % 2 == 0 or gcd(a,b) != 1):
continue
ans += n//c
print(ans)
| 1,200 | PYTHON3 |
# import sys
# sys.stdin=open("input.in",'r')
# sys.stdout=open("out.out",'w')
n,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
x=min(a)
y=min(b)
s=100
for i in range(n):
if a[i] in b:
s=min(s,a[i])
if s==100:
s=min(x,y)*10+max(x,y)
print(s) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long mymod2(long long x) { return llabs(x) % 2; }
int main() {
int n;
long long k;
scanf("%d%I64d", &n, &k);
vector<long long> a(n + 1);
vector<long long> aa(n + 1);
for (int i = 0; i <= n; ++i) {
scanf("%I64d", &a[i]);
aa[i] = a[i];
}
for (int i = 0; i < n; ++i) {
if (a[i] > 1 || a[i] < 0) {
long long newai = mymod2(a[i]);
long long diff = newai - a[i];
assert(diff % 2 == 0);
a[i + 1] -= diff / 2;
a[i] = newai;
}
}
int maxans = 0;
while (a[maxans] == 0) {
++maxans;
}
assert(maxans <= n);
long long val = 0;
for (int i = n; i >= maxans; --i) {
val = val * 2 + a[i];
if (val > k * 2 || val < k * -2) {
break;
}
}
int ans = 0;
for (int i = maxans; i >= 0; --i) {
if (val > k * 2 || val < k * -2) {
break;
}
long long newval = aa[i] - val;
if (newval <= k && newval >= -k) {
if (i == n && newval == 0) {
} else {
++ans;
}
}
val *= 2;
}
printf("%d\n", ans);
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
const long long base = 998244353;
const int maxn = 100;
long long A, B;
long long sol(long long l, long long r, vector<long long> h) {
if (h.empty()) return A;
if (r == l) return B * h.size();
vector<long long> first, second;
long long mid = (l + r) / 2;
for (int i = 0; i < h.size(); ++i) {
if (h[i] <= mid)
first.push_back(h[i]);
else
second.push_back(h[i]);
}
return min(B * (r - l + 1) * (long long)(h.size()),
sol(l, mid, first) + sol(mid + 1, r, second));
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, k;
cin >> n >> k >> A >> B;
vector<long long> h(k);
for (int i = 0; i < k; ++i) {
cin >> h[i];
}
sort(h.begin(), h.end());
cout << sol(1, 1 << n, h);
return 0;
}
| 1,700 | CPP |
n=int(input())
feeling=''
for i in range(n):
if (i+1)%2==1:
feeling+='I hate that'+' '
else:
feeling+='I love that'+' '
if i==n-1:
feeling=feeling.strip(' ')
feeling=feeling.strip('that')
feeling+='it'
print(feeling,end='') | 800 | PYTHON3 |
def f(x,y):
if y >= x*2:
return x*3
return (y//2)*3
def main():
import sys,bisect
input = sys.stdin.readline
t = int(input())
for __ in [0]*t:
a,b,c = map(int,input().split())
res = 0
if b >= 2*a:
res = max(res,3*a+f(b-2*a,c))
if b >= c//2:
res = max(res,(c//2)*3+f(a,b-c//2))
for k in range(b+1):
if c >= 2*k:
res = max(res,3*k+f(a,b-k))
print(res)
if __name__ == '__main__':
main() | 800 | PYTHON3 |
from math import sqrt
from collections import deque
it = lambda: list(map(int, input().strip().split()))
INF = float('inf')
# def getSum(v, k):
# t = 0
# for _ in range(k + 1):
# w = v
# while w:
# t += w % 10
# w //= 10
# v += 1
# return t
def solve():
n, k = it()
a = INF
e = 0
s = 0
q = deque()
for i in range(k + 1):
q.append(i)
s += i
r = False
while True:
if n >= s + e and (n - s - e) % (k + 1) == 0:
v = q[0]
c = (n - s - e) // (k + 1)
m = 1 if q[0] == 0 and c == 0 else 10
if v + k >= 10 and c >= 9:
v += 8 * m
m *= 10
c -= 8
while c >= 9:
v += 9 * m
m *= 10
c -= 9
v += c * m
a = min(a, v)
q.append((q[-1] + 1) % 10)
s -= q.popleft()
s += q[-1]
if q[-1] == 0:
r = True
if r:
e += 1
if q[0] == 0:
break
return a if a != INF else -1
T = int(input())
for _ in range(T):
print(solve()) | 2,200 | PYTHON3 |
#include <bits/stdc++.h>
#define ll long long
#define sz(x) ((int) (x).size())
#define all(x) (x).begin(), (x).end()
#define vi vector<int>
#define pii pair<int, int>
#define rep(i, a, b) for(int i = (a); i < (b); i++)
using namespace std;
template<typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
template <class Cap, class Cost> struct mcmf {
public:
mcmf() {}
mcmf(int n) : _n(n), g(n) {}
int add_edge(int from, int to, Cap cap, Cost cost) {
assert(0 <= from && from < _n);
assert(0 <= to && to < _n);
assert(0 <= cap);
assert(0 <= cost);
int m = int(pos.size());
pos.push_back({from, int(g[from].size())});
int from_id = int(g[from].size());
int to_id = int(g[to].size());
if (from == to) to_id++;
g[from].push_back(_edge{to, to_id, cap, cost});
g[to].push_back(_edge{from, from_id, 0, -cost});
return m;
}
struct edge {
int from, to;
Cap cap, flow;
Cost cost;
};
edge get_edge(int i) {
int m = int(pos.size());
assert(0 <= i && i < m);
auto _e = g[pos[i].first][pos[i].second];
auto _re = g[_e.to][_e.rev];
return edge{
pos[i].first, _e.to, _e.cap + _re.cap, _re.cap, _e.cost,
};
}
std::vector<edge> edges() {
int m = int(pos.size());
std::vector<edge> result(m);
for (int i = 0; i < m; i++) {
result[i] = get_edge(i);
}
return result;
}
std::pair<Cap, Cost> flow(int s, int t) {
return flow(s, t, std::numeric_limits<Cap>::max());
}
std::pair<Cap, Cost> flow(int s, int t, Cap flow_limit) {
return slope(s, t, flow_limit).back();
}
std::vector<std::pair<Cap, Cost>> slope(int s, int t) {
return slope(s, t, std::numeric_limits<Cap>::max());
}
std::vector<std::pair<Cap, Cost>> slope(int s, int t, Cap flow_limit) {
assert(0 <= s && s < _n);
assert(0 <= t && t < _n);
assert(s != t);
// variants (C = maxcost):
// -(n-1)C <= dual[s] <= dual[i] <= dual[t] = 0
// reduced cost (= e.cost + dual[e.from] - dual[e.to]) >= 0 for all edge
std::vector<Cost> dual(_n, 0), dist(_n);
std::vector<int> pv(_n), pe(_n);
std::vector<bool> vis(_n);
struct Q {
Cost key;
int to;
bool operator<(Q r) const { return key > r.key; }
};
std::vector<Q> que;
auto dual_ref = [&]() {
std::fill(dist.begin(), dist.end(),
std::numeric_limits<Cost>::max());
std::fill(vis.begin(), vis.end(), false);
que.clear();
dist[s] = 0;
que.push_back(Q{0, s});
std::push_heap(que.begin(), que.end());
while (!que.empty()) {
int v = que.front().to;
std::pop_heap(que.begin(), que.end());
que.pop_back();
if (vis[v]) continue;
vis[v] = true;
if (v == t) break;
// dist[v] = shortest(s, v) + dual[s] - dual[v]
// dist[v] >= 0 (all reduced cost are positive)
// dist[v] <= (n-1)C
for (int i = 0; i < int(g[v].size()); i++) {
auto e = g[v][i];
if (vis[e.to] || !e.cap) continue;
// |-dual[e.to] + dual[v]| <= (n-1)C
// cost <= C - -(n-1)C + 0 = nC
Cost cost = e.cost - dual[e.to] + dual[v];
if (dist[e.to] - dist[v] > cost) {
dist[e.to] = dist[v] + cost;
pv[e.to] = v;
pe[e.to] = i;
que.push_back(Q{dist[e.to], e.to});
std::push_heap(que.begin(), que.end());
}
}
}
if (!vis[t]) {
return false;
}
for (int v = 0; v < _n; v++) {
if (!vis[v]) continue;
// dual[v] = dual[v] - dist[t] + dist[v]
// = dual[v] - (shortest(s, t) + dual[s] - dual[t]) + (shortest(s, v) + dual[s] - dual[v])
// = - shortest(s, t) + dual[t] + shortest(s, v)
// = shortest(s, v) - shortest(s, t) >= 0 - (n-1)C
dual[v] -= dist[t] - dist[v];
}
return true;
};
Cap flow = 0;
Cost cost = 0, prev_cost_per_flow = -1;
std::vector<std::pair<Cap, Cost>> result;
result.push_back({flow, cost});
while (flow < flow_limit) {
if (!dual_ref()) break;
Cap c = flow_limit - flow;
for (int v = t; v != s; v = pv[v]) {
c = std::min(c, g[pv[v]][pe[v]].cap);
}
for (int v = t; v != s; v = pv[v]) {
auto& e = g[pv[v]][pe[v]];
e.cap -= c;
g[v][e.rev].cap += c;
}
Cost d = -dual[s];
flow += c;
cost += c * d;
if (prev_cost_per_flow == d) {
result.pop_back();
}
result.push_back({flow, cost});
prev_cost_per_flow = d;
}
return result;
}
private:
int _n;
struct _edge {
int to, rev;
Cap cap;
Cost cost;
};
std::vector<std::pair<int, int>> pos;
std::vector<std::vector<_edge>> g;
};
const ll INF = 1e12;
int x[4], y[4];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int te;
cin >> te;
while(te--) {
rep(i, 0, 4) {
cin >> x[i] >> y[i];
}
vi perm(4, 0);
rep(i, 0, 4) perm[i] = i;
ll ans = INF;
do {
mcmf<ll, ll> F(8);
rep(i, 0, 4) rep(j, 4, 6) {
F.add_edge(i, j, INF, 1);
F.add_edge(j, i, INF, 1);
}
vi w(6, 0);
w[0] = x[perm[2]] - x[perm[0]];
w[1] = x[perm[1]] - x[perm[3]];
w[2] = y[perm[0]] - y[perm[1]];
w[3] = y[perm[3]] - y[perm[2]];
w[4] = x[perm[0]] + y[perm[2]] - x[perm[1]] - y[perm[0]];
w[5] = x[perm[3]] + y[perm[1]] - x[perm[2]] - y[perm[3]];
rep(i, 0, 6) {
if(w[i] > 0) {
F.add_edge(6, i, w[i], 0);
}else {
F.add_edge(i, 7, -w[i], 0);
}
}
ans = min(ans, F.flow(6, 7).second);
}while(next_permutation(all(perm)));
cout << ans << '\n';
}
} | 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long b;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long n, m, sum = 0, p, c = 0, s = 0, d = 0, j;
cin >> n >> m;
vector<long long> v, v1;
for (long long i = 0; i < n; i++) {
cin >> b;
v.push_back(b);
sum += b;
}
p = sum / m;
for (long long i = 0; i < n; i++) {
s += v[i];
d++;
if (s == p) {
c++;
v1.push_back(d);
j = i;
d = 0;
s = 0;
}
}
if ((c == m) && (j == n - 1)) {
cout << "Yes" << endl;
for (long long i = 0; i < (long long)v1.size(); i++) {
cout << v1[i] << " ";
}
} else
cout << "No";
}
| 1,100 | CPP |
n = int(input())
a = []
c = 0
for i in range(n):
b = input()
if '++' in b:
c += 1
elif '--' in b:
c -= 1
print(c)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool sortbysec(const pair<long long int, long long int>& a,
const pair<long long int, long long int>& b) {
return (a.second < b.second);
}
bool sortbys(pair<char, long long int> a, pair<char, long long int> b) {
return a.second < b.second;
}
bool sortby(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
if (a.second == b.second)
return a.first > b.first;
else
return a.second > b.second;
}
bool sortbyfirst(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return a.first < b.first;
}
long long int mpow(long long int x, long long int y) {
long long int ans = 1;
while (y) {
if (y % 2 != 0) ans = (ans % 1000000007) * (x % 1000000007) % 1000000007;
y /= 2;
x = ((x % 1000000007) * (x % 1000000007)) % 1000000007;
}
return ans;
}
long long int modInverse(long long int n) { return mpow(n, 1000000007 - 2); }
bool sortbyletter(vector<char> a, vector<char> b) {
for (int i = 0; i < a.size(); i++) {
if (a[i] > b[i])
return 1;
else if (a[i] < b[i])
return 0;
}
if (a.size() > b.size())
return 1;
else
return 0;
}
void reverseStr(string& str) {
int n = str.length();
for (int i = 0; i < n / 2; i++) swap(str[i], str[n - i - 1]);
}
long long int kadanesum(long long int arr[], long long int n) {
long long int curr = 0, best = INT_MIN, i;
for (i = 0; i < n; i++) {
curr += arr[i];
best = max(best, curr);
if (curr < 0) curr = 0;
}
return best;
}
long long int nCrModPFermat(long long int n, long long int r) {
if (r == 0) return 1;
long long int fac[n + 1];
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % 1000000007;
return (fac[n] * modInverse(fac[r]) % 1000000007 * modInverse(fac[n - r]) %
1000000007) %
1000000007;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t, i, j;
cin >> t;
while (t--) {
long long int n, f = 1, ans = 0;
cin >> n;
string a, b;
cin >> a >> b;
map<char, vector<long long int>> m1;
map<char, set<char>> m;
for (i = 0; i < a.size(); i++) {
if (a[i] > b[i]) f = 0;
m1[a[i]].push_back(i);
}
if (f == 0) {
cout << "-1";
} else {
for (i = 0; i < b.size(); i++) {
if (a[i] != b[i]) m[b[i]].insert(a[i]);
}
for (auto i = m.begin(); i != m.end(); i++) {
set<char> s;
for (j = 0; j < a.size(); j++) {
if ((a[j] != b[j]) && b[j] == i->first) s.insert(a[j]);
}
ans += s.size();
for (auto j : s) {
for (long long int k = 0; k < a.size(); k++) {
if (a[k] == (j) && a[k] != b[k]) a[k] = i->first;
}
}
}
cout << ans;
}
cout << endl;
}
return 0;
}
| 1,700 | CPP |
n = int(input())
l, r = -1, 10**100
while r > l + 1:
m = (l + r) // 2
if (m * (m + 1) * (m + 2) <= 6 * n):
l = m
else:
r = m
print(l) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int OO = 1e9;
const long long INF = 1e18;
const int irand(int lo, int hi) {
return ((double)rand() / (RAND_MAX + 1.0)) * (hi - lo + 1) + lo;
}
const long long lrand(long long lo, long long hi) {
return ((double)rand() / (RAND_MAX + 1.0)) * (hi - lo + 1) + lo;
}
const int N = 200005;
const long long MOD = (long long)1e9 + 7;
long long fact[N];
long long F(int x) {
if (x < 0)
return 0;
else
return fact[x];
}
int n, m;
char in[N];
int pre[N];
long long exp(long long a, long long e) {
if (e < 0)
return 1;
else if (e == 1)
return a;
else {
long long ret = exp(a, e / 2);
ret = (ret * ret) % MOD;
if (e & 1) ret = (ret * a) % MOD;
return ret;
}
}
long long C(int a, int b) {
if (b > a) return 0;
return (F(a) * exp((F(a - b) * F(b)) % MOD, MOD - 2)) % MOD;
}
int main() {
ios_base::sync_with_stdio(0);
fact[0] = 1;
for (int i = 1; i <= N - 5; i += 1) {
fact[i] = (fact[i - 1] * i) % MOD;
}
scanf("%s", in);
m = strlen(in);
n = 0;
for (int i = 0; i <= m - 1; i += 1) {
if (in[i] == '(') n++;
}
for (int i = m - 1, nn = n, cnt = 0; i >= 0; i--) {
if (in[i] == ')') {
cnt++;
} else {
pre[nn--] = cnt;
}
}
long long ans = 0;
for (int i = 1; i <= n; i += 1) {
ans = (ans + C(i + pre[i] - 1, i)) % MOD;
}
cout << ans << endl;
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int r[100005] = {0};
pair<pair<int, int>, int> grp[100005];
vector<pair<int, int> > res;
bool cmp(pair<pair<int, int>, int> x, pair<pair<int, int>, int> y) {
return (x.second < y.second);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int i, j, min, k, x, y, ans;
for (i = 1; i <= n; i++) {
cin >> x >> y;
grp[i] = {{i, x}, y};
}
cin >> k;
for (j = 1; j <= k; j++) {
cin >> r[j];
}
sort(grp + 1, grp + n + 1, cmp);
ans = 0;
for (i = n; i >= 1; i--) {
min = 0;
r[min] = INT_MAX;
for (j = 1; j <= k; j++) {
if (r[j] >= grp[i].first.second) {
if (r[min] > r[j]) {
min = j;
}
}
}
if (min != 0) {
res.push_back({grp[i].first.first, min});
ans = ans + grp[i].second;
r[min] = 0;
}
}
cout << res.size() << " " << ans << "\n";
for (auto it : res) {
cout << it.first << " " << it.second << "\n";
}
return 0;
}
| 1,600 | CPP |
import copy
R = lambda : map(int, input().split())
s = list(R())
r = 0
for i in range(14):
a = s[i]
if a!=0:
s1 = s.copy()
s1[i]=0
#print(s1)
a1,a2 = a//14,a%14
s2 = [a1+1]*a2
s2.extend([a1]*(14-a2))
#print(s2)
#print('-')
s3 = s1[i+1:14]
s3.extend(s1[0:i+1])
#print(s3)
r1 = sum(list(filter(lambda x:x%2==0,map(lambda x:sum(x),zip(s2,s3)))))
r = max(r,r1)
#print('-----')
print(r)
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9;
int n, cost[5], col[1001], dp[5][1002][1 << 12 + 1], fl[5][5];
string g[4];
int calc(int r, int c, int msk) {
if (c == n) return 0;
if (r == 4) {
if ((msk & col[c]) != col[c]) return 1e9;
return calc(0, c + 1, msk >> 4);
}
int &ret = dp[r][c][msk];
if (ret != -1) return ret;
ret = calc(r + 1, c, msk);
for (int s = 1; s <= 4 && c + s <= n && r + s <= 4; ++s) {
if (s == 4)
ret = min(ret, cost[s] + calc(0, c + 1, (1 << 12) - 1));
else {
ret = min(ret, cost[s] + calc(r + 1, c, msk | fl[r][s]));
}
}
return ret;
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d", &n);
for (int i = 1; i <= 4; ++i) scanf("%d", &cost[i]);
for (int i = 0; i < 4; ++i) {
cin >> g[i];
}
for (int r = 0; r < 4; ++r) {
for (int s = 1; s <= 3 && s + r <= 4; ++s) {
for (int d1 = 0; d1 < s; ++d1) {
for (int d2 = 0; d2 < s; ++d2) {
int nwR = d1 + r;
fl[r][s] |= (1 << (d2 * 4 + nwR));
}
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 4; ++j) {
if (g[j][i] == '*') col[i] = col[i] | (1 << j);
}
}
printf("%d\n", calc(0, 0, 0));
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int s, e, l, h;
int v[10];
bool operator<(const Edge& x) const { return s < x.s; }
} edge[50];
int n, m, cur[10], flow, price;
void dfs(int idx, int ret) {
if (idx == m + 1) {
for (int i = 1; i <= n - 1; i++) {
if (cur[i] > 0) return;
}
price = max(price, ret);
} else {
int u = edge[idx].s;
int v = edge[idx].e;
for (int i = 1; i <= u - 1; i++) {
if (cur[i] > 0) return;
}
int low = edge[idx].l;
int high = edge[idx].h;
for (int i = low; i <= high && i <= cur[u]; i++) {
cur[u] -= i;
cur[v] += i;
dfs(idx + 1, ret + edge[idx].v[i]);
cur[u] += i;
cur[v] -= i;
}
}
}
int main(int argc, char** argv) {
cin >> n;
m = n * (n - 1) / 2;
for (int i = 1; i <= m; i++) {
cin >> edge[i].s >> edge[i].e;
cin >> edge[i].l >> edge[i].h;
cin >> edge[i].v[0];
for (int j = 1; j <= 8; j++) edge[i].v[j] = edge[i].v[0] + j * j;
edge[i].v[0] = 0;
}
sort(edge + 1, edge + m + 1);
price = -1;
flow = 0;
while (price == -1) {
memset(cur, 0, sizeof(cur));
cur[1] = flow;
dfs(1, 0);
flow += 1;
if (flow == 30) break;
}
if (price == -1)
cout << "-1 -1" << endl;
else
cout << flow - 1 << " " << price << endl;
return (EXIT_SUCCESS);
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 10;
namespace Geometry {
const double PI = acos(-1.0);
const double eps = 1e-6;
int sgn(double x) {
if (fabs(x) < eps) return 0;
return x > 0 ? 1 : -1;
}
struct Point {
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y){};
bool operator==(const Point &b) const {
return !sgn(x - b.x) && !sgn(y - b.y);
}
Point operator+(const Point &b) const { return Point(x + b.x, y + b.y); }
Point operator-(const Point &b) const { return Point(x - b.x, y - b.y); }
double operator^(const Point &b) const { return x * b.y - y * b.x; }
double operator*(const Point &b) const { return x * b.x + y * b.y; }
double dis(const Point &b) const {
return (x - b.x) * (x - b.x) + (y - b.y) * (y - b.y);
}
void input() { scanf("%lf%lf", &x, &y); }
double len() { return sqrt(x * x + y * y); }
double len2() { return x * x + y * y; }
};
struct Line {
Point st, ed;
double len, ang;
bool isSeg;
Line(Point st = Point(), Point ed = Point(), double len = 0, double ang = 0,
bool isSeg = 0)
: st(st), ed(ed), len(len), ang(ang), isSeg(isSeg){};
void input() {
st.input(), ed.input();
len = st.dis(ed);
ang = atan2(ed.y - st.y, ed.x - st.x);
}
bool SegisCross(Line l1, Line l2) const {
Point p1 = l1.st, p2 = l1.ed;
Point q1 = l2.st, q2 = l2.ed;
return min(p1.x, p2.x) <= max(q1.x, q2.x) &&
min(q1.x, q2.x) <= max(p1.x, p2.x) &&
min(p1.y, p2.y) <= max(q1.y, q2.y) &&
min(q1.y, q2.y) <= max(p1.y, p2.y) &&
((p2 - p1) ^ (q1 - p1)) * ((p2 - p1) ^ (q2 - p1)) <= 0 &&
((q2 - q1) ^ (p1 - q2)) * ((q2 - q1) ^ (p2 - q2)) <= 0;
};
pair<Point, int> operator&&(const Line &b) const {
Point res = st;
if (sgn((st - ed) ^ (b.st - b.ed)) == 0) {
if (sgn((b.st - st) ^ (b.ed - st)) == 0)
return make_pair(res, 0);
else
return make_pair(res, 1);
}
if (!SegisCross(Line(st, ed), b)) return make_pair(res, 3);
double t = ((st - b.st) ^ (b.st - b.ed)) / ((st - ed) ^ (b.st - b.ed));
res = res + (ed - st) * t;
return make_pair(res, 2);
}
};
double dis(Point a, Point b) {
return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
double dis1(Point a, Point b) {
return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
bool SegInline(Line a, Line b) {
return sgn((a.st - b.st) ^ (a.ed - b.st)) *
sgn((a.st - b.ed) ^ (a.ed - b.ed)) <=
0;
}
double Dot(Point A, Point B) { return A.x * B.x + A.y * B.y; }
double Cross(Point A, Point B) { return A.x * B.y - A.y * B.x; }
double Length(Point A) { return sqrt(Dot(A, A)); }
double Angle(Point A, Point B) {
return acos(Dot(A, B) / Length(A) / Length(B));
}
double torad(double angle) { return angle / 180 * PI; }
double toangle(double rad) { return 180 / PI * rad; }
Point GetIntersection(Line x, Line y) {
Point a = x.ed - x.st, b = y.ed - y.st, c = y.st - x.st;
return y.st + b * ((c ^ a) / (a ^ b));
}
double Area(Point *p, int n) {
double ans = 0;
for (int i = 3; i <= n; i++) ans += (p[i] - p[1]) ^ (p[i - 1] - p[1]);
return fabs(ans) / 2;
}
struct Polygon {
int n;
Point p[N];
void input(int n) {
this->n = n;
for (int i = 1; i <= n; i++) p[i].input();
p[n + 1] = p[1];
}
double getArea() {
double ans = 0;
for (int i = 3; i <= n; i++) {
ans += (p[i] - p[1]) ^ (p[i - 1] - p[1]);
}
return fabs(ans) / 2;
}
double getCircumference() {
double ans = 0;
for (int i = 1, j = n; i <= n; j = i++) ans += (p[i] - p[j]).len();
return ans;
}
struct cmp {
Point p;
cmp(const Point &p0) { p = p0; }
bool operator()(const Point &p1, const Point &p2) {
double tmp = Cross(p1 - p, p2 - p);
if (tmp > 0) return 1;
if (tmp == 0 && dis(p, p1) < dis(p, p2)) return 1;
return 0;
}
};
void hull() {
Point s[N];
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (p[1].y > p[i].y || (p[1].y == p[i].y && p[1].x > p[i].x))
swap(p[1], p[i]);
}
sort(p + 2, p + n + 1, cmp(p[1]));
s[++cnt] = p[1];
for (int i = 2; i <= n; i++) {
while (cnt > 1 && Cross(s[cnt] - s[cnt - 1], p[i] - s[cnt]) <= 0) cnt--;
s[++cnt] = p[i];
}
s[cnt + 1] = p[1];
}
};
struct Circle {
Point o;
double r;
Circle(Point o = Point(), double r = 0) : o(o), r(r){};
void input() { o.input(), scanf("%lf", &r); }
double S() const { return PI * r * r; }
pair<Point, double> getCircle(Point a, Point b, Point c) {
double B = (a.x * a.x + a.y * a.y) * (b.y - c.y) +
(b.x * b.x + b.y * b.y) * (c.y - a.y) +
(c.x * c.x + c.y * c.y) * (a.y - b.y);
double A = a.x * (b.y - c.y) - a.y * (b.x - c.x) + b.x * c.y - c.x * b.y;
double C = (a.x * a.x + a.y * a.y) * (c.x - b.x) +
(b.x * b.x + b.y * b.y) * (a.x - c.x) +
(c.x * c.x + c.y * c.y) * (b.x - a.x);
double D = (a.x * a.x + a.y * a.y) * (c.x * b.y - b.x * c.y) +
(b.x * b.x + b.y * b.y) * (a.x * c.y - c.x * a.y) +
(c.x * c.x + c.y * c.y) * (b.x * a.y - a.x * b.y);
double x = -B / (2 * A);
double y = -C / (2 * A);
double R = sqrt((B * B + C * C - 4 * A * D) / (4 * A * A));
return make_pair(Point(x, y), R);
}
pair<pair<Point, Point>, int> getLineCircleIntersection(const Line &B) {
Point p = B.st;
Point v = B.ed - B.st;
double a = v.x, b = p.x - o.x, c = v.y, d = p.y - o.y;
double e = a * a + c * c, f = 2 * (a * b + c * d),
g = b * b + d * d - r * r;
double delta = f * f - 4 * e * g;
if (sgn(delta) < 0) return make_pair(make_pair(o, o), 0);
if (sgn(delta) == 0) {
double t1 = -f / (2 * e);
return make_pair(make_pair(p + v * t1, p + v * t1), 1);
}
double t1 = (-f - sqrt(delta)) / (2 * e), t2 = (-f + sqrt(delta)) / (2 * e);
return make_pair(make_pair(p + v * t1, p + v * t2), 2);
}
double getCircleCircleArea(const Circle &b) const {
double d = (o - b.o).len();
if (sgn(d - r - b.r) >= 0) return 0;
if (sgn(fabs(r - b.r) - d) >= 0) return sgn(r - b.r) > 0 ? b.S() : S();
long double ang1 = acos(((long double)r * r + (long double)d * d -
(long double)b.r * b.r) /
((long double)2 * r * d)) *
2;
long double ang2 = acos(((long double)b.r * b.r + (long double)d * d -
(long double)r * r) /
((long double)2 * b.r * d)) *
2;
return (0.5 * ang1 * r * r - 0.5 * r * r * sin(ang1)) +
(0.5 * ang2 * b.r * b.r - 0.5 * b.r * b.r * sin(ang2));
}
};
}; // namespace Geometry
using namespace Geometry;
int main() {
Circle a, b;
a.input(), b.input();
printf("%.10lf\n", a.getCircleCircleArea(b));
return 0;
}
| 2,000 | CPP |
def main():
t=int(input())
while(t!=0):
a,b,c=map(int,input().split())
s=a+c-b
print(s//2+b)
t-=1
main() | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int N = 5e5 + 5;
const int mo = 998244353;
long long mi[N];
struct edge {
int x, nxt;
} e[N * 2];
int h[N], tot;
int n;
void inse(int x, int y) {
e[++tot].x = y;
e[tot].nxt = h[x];
h[x] = tot;
}
bool vis[N];
long long ans;
int siz[N];
long long f[N][2], g[N][2];
int fa[N];
void dfs(int x) {
siz[x] = 1;
for (int p = h[x]; p; p = e[p].nxt)
if (!siz[e[p].x]) {
fa[e[p].x] = x;
dfs(e[p].x);
siz[x] += siz[e[p].x];
}
g[x][0] = 1;
for (int p = h[x]; p; p = e[p].nxt)
if (fa[e[p].x] == x) {
int y = e[p].x;
long long f0 = f[x][0], f1 = f[x][1], g0 = g[x][0], g1 = g[x][1];
f[x][0] = f[x][1] = g[x][0] = g[x][1] = 0;
f[x][0] = f0 * mi[siz[y] - 1] % mo;
f[x][1] = f1 * mi[siz[y] - 1] % mo;
g[x][0] = g0 * mi[siz[y] - 1] % mo;
g[x][1] = g1 * mi[siz[y] - 1] % mo;
g[x][1] = (g[x][1] + g0 * g[y][0]) % mo;
f[x][1] = (f[x][1] + g0 * f[y][0] + f0 * g[y][0]) % mo;
g[x][0] = (g[x][0] + g0 * g[y][1]) % mo;
f[x][0] = (f[x][0] + g0 * f[y][1] + f0 * g[y][1] + g0 * g[y][1]) % mo;
g[x][1] = (g[x][1] + g1 * g[y][0]) % mo;
f[x][1] = (f[x][1] + g1 * f[y][0] + f1 * g[y][0]) % mo;
g[x][1] = (g[x][1] + g1 * g[y][1]) % mo;
f[x][1] = (f[x][1] + g1 * f[y][1] + f1 * g[y][1] + g1 * g[y][1]) % mo;
}
if (x == 1)
ans = (ans + f[x][0] + f[x][1] + g[x][1]) % mo;
else
ans = (ans + (f[x][0] + f[x][1] + g[x][1]) % mo * mi[n - siz[x] - 1]) % mo;
}
int main() {
n = get();
for (int i = 2; i <= n; i++) {
int x = get(), y = get();
inse(x, y), inse(y, x);
}
mi[0] = 1;
for (int i = 1; i <= n; i++) mi[i] = mi[i - 1] * 2 % mo;
dfs(1);
ans = ans * 2 % mo;
cout << ans << endl;
return 0;
}
| 2,800 | CPP |
import math
t = int(input())
for _ in range(t):
ali = list(map(int, input().split()))
ali.sort()
if(ali[2] > ali[0]+ali[1]):
print(ali[0] + ali[1])
else:
q = math.floor(sum(ali)/2)
print(q)
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
cin >> n;
vector<long long> f, f1;
long long a[n];
for (long long i = 0; i < n; ++i) cin >> a[i];
sort(a, a + n);
long long cnt = 1;
for (long long i = 1; i < n; ++i) {
if (a[i] == a[i - 1])
cnt++;
else {
f.push_back(cnt);
f1.push_back(a[i - 1]);
cnt = 1;
}
}
f.push_back(cnt);
f1.push_back(a[n - 1]);
long long c = f[0], mx = -1, s = a[0], i = 1, j = 0;
long long p = 0;
while (i < f1.size() && j < f1.size()) {
if (f1[i] - s <= 5)
c += f[i], i++;
else
mx = max(mx, c), j++, c = f[j], s = f1[j], i = j + 1;
p++;
}
mx = max(mx, c);
cout << mx;
return 0;
}
| 1,200 | CPP |
s=input()
n=len(s)
ans=''
if(s[0]!='9' and s[0]>='5'):
ans+=str(9-int(s[0]))
else:
ans=s[0]
for i in range(1,n):
if(s[i]>'4'):
ans+=str(9-int(s[i]))
else:
ans+=s[i]
print(ans) | 1,200 | PYTHON3 |
n = int(input())
A = list(map(int, input().split()))
m = max(A)
ans = 0
for i in A:
ans += m - i
print(ans)
| 800 | PYTHON3 |
txt = input().split(' ')
w = int(txt[0]) - 2
h = int(txt[1])
k = int(txt[2])
P = 0
i = 0
while i < k:
P1 = (2 * w + 2 * h)
P += P1
w -= 4
h -= 4
i += 1
print(P) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
int i, j = 0, moves = 0;
cin >> a >> b;
for (i = 0; i < a.length() - 1; i++) {
for (j; j < b.length();) {
if (a[i] == b[j]) {
++moves;
++j;
break;
}
++j;
}
}
cout << moves + 1;
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, t;
cin >> n >> m >> k >> t;
vector<int> arr(k);
for (int i = 0; i < k; i++) {
int a, b;
cin >> a >> b;
arr[i] = (a - 1) * m + b;
}
sort(arr.begin(), arr.end());
while (t--) {
int a, b;
cin >> a >> b;
int ans =
lower_bound(arr.begin(), arr.end(), (a - 1) * m + b) - arr.begin();
if (arr[ans] == (a - 1) * m + b) {
cout << "Waste\n";
continue;
}
ans = (a - 1) * m + b - ans;
ans = ans % 3;
if (ans == 0) {
cout << "Grapes\n";
continue;
}
if (ans == 1) {
cout << "Carrots\n";
continue;
}
if (ans == 2) {
cout << "Kiwis\n";
continue;
}
}
}
| 1,400 | CPP |
q = int(input())
for _ in range(q):
n = int(input())
if n == 1:
print(0)
else:
output = 0
while n != 1:
if n % 2 == 0:
n //= 2
output += 1
elif n % 3 == 0:
n = 2*n // 3
output += 1
elif n % 5 == 0:
n = 4*n // 5
output += 1
else:
output = -1
break
print(output)
| 800 | PYTHON3 |
x = input()
x = int(x)
if x != 2 and x % 2 == 0:
print("YES")
else:
print("NO")
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e3 + 5;
int cross(complex<int> a, complex<int> b) { return (conj(a) * b).imag(); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
complex<int> points[MAX];
for (int i = 0; i <= n; i++) {
int x, y;
cin >> x >> y;
points[i] = {x, y};
}
int ans = 0;
for (int i = 1; i < n; i++)
ans += cross(points[i] - points[i - 1], points[i + 1] - points[i]) > 0;
cout << ans << "\n";
}
| 1,500 | CPP |
for _ in range(int(input().strip())):
n,a,b = map(int,input().strip().split(' '))
if b < a * 2:
if n % 2 == 0:
print(n//2*b)
else:
print((n // 2) * b + a)
else:
print(n * a) | 800 | PYTHON3 |
n = int(input())
if n % 2 == 0:
n = n // 2
while n:
print('1', end='')
n -= 1
else:
n -= 1
n = n // 2
ans_= []
while n:
ans_.append('1')
n -= 1
ans_[0] = '7'
print(''.join(ans_))
| 1,200 | PYTHON3 |
n=int(input())
l=[]
x=0
for c in range(0,n):
w=input()
l.append(w)
for v in l:
if v[1] is '+':
x+=1
else:
x-=1
print(x) | 800 | PYTHON3 |
"""
T=int(input())
for _ in range(0,T):
N=int(input())
s=input()
a,b=map(int,input().split())
s=[int(x) for x in input().split()]
"""
n,p,w,d=map(int,input().split())
temp=-1
for i in range(0,w):
if((p-(d*i))%w==0 and ((p-(d*i))//w)+i<=n and (p-(d*i))//w>=0):
print((p-(d*i))//w,i,n-((p-(d*i))//w)-i)
temp=1
break
if(temp==-1):
print(-1)
| 2,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > adj;
map<int, int> myMap;
map<int, int> nextState;
map<int, int> nextMove;
int n;
int dp(int state) {
if (myMap.find(state) != myMap.end()) return myMap[state];
if (state == ((1 << n) - 1)) {
myMap[state] = 0;
nextState[state] = -1;
nextMove[state] = -1;
return myMap[state];
}
myMap[state] = 30;
for (int i = 0; i < n; i++) {
if ((state & (1 << i)) != 0 || (state == 0)) {
int temp = state | (1 << i);
for (int j = 0; j < adj[i].size(); j++) {
int v = adj[i][j];
temp = (temp | (1 << v));
}
int claim = 1 + dp(temp);
if (myMap[state] > claim) {
myMap[state] = claim;
nextState[state] = temp;
nextMove[state] = i;
}
}
}
return myMap[state];
}
int main() {
int m;
cin >> n >> m;
adj.clear();
adj.resize(n);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
myMap.clear();
nextState.clear();
nextMove.clear();
if (n <= 2 || m == (n * (n - 1)) / 2) {
cout << 0 << endl;
} else {
int ans = dp(0);
cout << ans << endl;
int state = 0;
while (true) {
if (nextState[state] == -1) break;
cout << nextMove[state] + 1 << " ";
state = nextState[state];
}
cout << endl;
}
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int col, row, k, b[101];
char s[101];
bool win() {
for (int j = 0, sum; j < 7; j++) {
sum = 0;
for (int i = 0; i < row; i++)
if ((1 << j) & b[i]) sum++;
if (sum % (k + 1)) return true;
}
return false;
}
int main() {
bool gF = false, rF = false;
cin >> row >> col >> k;
for (int i = 0, R, G, r, g; i < row; i++) {
cin >> s;
R = G = -1;
r = g = 0;
for (int j = 0; j < col; j++) {
if (s[j] == 'R') R = j, r++;
if (s[j] == 'G') G = j, g++;
}
if (R == -1 && G == -1) {
b[i] = 0;
continue;
}
if (R == -1 || G == -1) {
if (R == -1 && g != col) gF = true;
if (G == -1 && r != col) rF = true;
b[i] = 0;
} else {
b[i] = abs(R - G) - 1;
}
}
if (gF && rF)
cout << "Draw\n";
else {
if (gF)
cout << "First\n";
else if (rF)
cout << "Second\n";
else {
if (win())
cout << "First\n";
else
cout << "Second\n";
}
}
return 0;
}
| 2,600 | CPP |
n = int(input())
arr = []
xx = 0
for i in range(n):
ff_gg = list(map(int, input().split()))
arr.append(ff_gg)
if (sum(ff_gg) >= 2):
xx += 1
print(xx)
| 800 | PYTHON3 |
from sys import stdin
n=int(stdin.readline())
from math import factorial as f
lst=[int(stdin.readline()) for _ in range(n)]
summa=sum(lst)
res=1
for i,x in enumerate(reversed(lst)):
x-=1
summa-=1
res*=(f(summa)//(f(summa-x)*f(x)))
res=res%1000000007
summa-=x
print(res) | 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 1000;
long long v[N];
long long binarysearch(long long h, long long lo, long long hi) {
long long ans = 1;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (v[mid] < h) {
lo = mid + 1;
} else if (v[mid] > h) {
hi = mid - 1;
} else {
ans = 0;
break;
}
}
return ans;
}
signed main() {
ios ::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long b1, q, l, m;
cin >> b1 >> q >> l >> m;
long long tmp = b1;
long long ans = 0;
for (long long i = 1; i <= m; i++) {
cin >> v[i];
}
sort(v + 1, v + m + 1);
bool f = false;
long long cnt = 0;
while (1) {
cnt += 1;
if (f) {
b1 = tmp * q;
}
if (cnt > N) {
if (ans > 1000) ans = -1;
break;
}
f = true;
if (abs(b1) <= l) {
if (binarysearch(b1, 1, m)) {
ans += 1;
tmp = b1;
} else {
tmp = b1;
}
} else {
break;
}
}
if (ans == -1) {
cout << "inf" << endl;
} else {
cout << ans << endl;
}
return 0;
}
| 1,700 | CPP |
n, q = map(int, input().split())
a = [int(i) for i in input().split()]
sm = sum(a)
for _ in range(q):
t, i = map(int, input().split())
if t == 1:
sm -= a[i - 1]
a[i - 1] ^= 1
sm += a[i - 1]
else:
print(1 if i <= sm else 0)
| 800 | PYTHON3 |
q=int(input())
for i in range(q):
N=int(input())
a=[int(i)%3 for i in input().split(" ")]
one=a.count(1)
two=a.count(2)
ans=min(one,two)
one-=ans
two-=ans
ans+=one//3
ans+=two//3
print(ans+a.count(0))
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f |= ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
const int N = 1000005;
int n, m, k, ub;
int a[N];
long long s = 0;
int nows = 0;
int ans[N];
vector<int> opt[N];
struct Node {
int id, v;
Node() {}
Node(int _id, int _v) { id = _id, v = _v; }
friend bool operator<(Node a, Node b) { return a.v < b.v; }
};
priority_queue<Node> Q;
Node bak[N];
int check(int x) {
int cnt = 0, tot = 0;
for (int i = 1; i <= ub; i++)
if ((tot += bak[i].v / x) >= k || bak[i].v < x) break;
return tot >= k;
}
int get() {
int cnt = 0;
for (int i = 1; i <= ub; i++) bak[++cnt] = Q.top(), Q.pop();
int L = 1, R = n - nows, ans = 0;
while (L <= R) {
int mid = (L + R) >> 1;
if (check(mid))
L = mid + 1, ans = mid;
else
R = mid - 1;
}
while (cnt) Q.push(bak[cnt--]);
return ans;
}
vector<Node> vec;
int main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) a[i] = read(), s += a[i];
k = (s + n - 1) / n;
ub = min(k, m);
a[1] += k * n - s;
for (int i = 1; i <= m; i++) Q.push(Node(i, a[i]));
for (int i = 1; i <= m; i++) opt[i].clear();
for (int i = 1; i <= m; i++) {
int now = get();
ans[i] = now;
nows += ans[i];
vec.clear();
for (int j = 1; j <= ub; j++) {
Node v = Q.top();
Q.pop();
while (v.v >= now && (int)opt[i].size() < k) {
v.v -= now;
a[v.id] -= now;
opt[i].push_back(v.id);
}
vec.push_back(v);
if ((int)opt[i].size() == k) break;
}
while ((int)opt[i].size() < k) opt[i].push_back(1);
while (!vec.empty()) Q.push(vec.back()), vec.pop_back();
}
printf("%d\n", k);
for (int i = 1; i <= m; i++) printf("%d ", ans[i]);
puts("");
for (int i = 0; i <= k - 1; i++) {
for (int j = 1; j <= m; j++) printf("%d ", opt[j][i]);
puts("");
}
return 0;
}
| 3,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int x = 0;
char ch = gc();
bool positive = 1;
for (; !isdigit(ch); ch = gc())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = gc()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
string an;
inline void write(int a) {
if (a >= 10) write(a / 10);
an += '0' + a % 10;
}
inline void writeln(int a) {
if (a < 0) {
a = -a;
an += '-';
}
write(a);
an += '\n';
}
const int N = 200005;
int nedge, peo[N], f[N], father[N], q[N], tot, top, son[N], nextt[N << 1],
ed[N << 1], sum, vis[N], n;
int ans[N * 2][3], gen[N];
inline void aedge(int a, int b) {
nextt[++nedge] = son[a];
son[a] = nedge;
ed[nedge] = b;
}
void get(int p, int fa) {
peo[p] = 1;
f[p] = 0;
for (int i = son[p]; i; i = nextt[i])
if (!vis[ed[i]] && ed[i] != fa) {
get(ed[i], p);
peo[p] += peo[ed[i]];
f[p] = max(f[p], peo[ed[i]]);
}
f[p] = max(f[p], sum - peo[p]);
if (f[p] * 2 <= n) gen[p] = vis[p] = 1;
}
void solve(int p) {
vis[p] = 1;
for (int i = son[p]; i; i = nextt[i])
if (!vis[ed[i]]) {
father[ed[i]] = p;
solve(ed[i]);
}
q[++top] = p;
}
int main() {
n = read();
f[0] = 1e9;
for (int i = 1; i < n; i++) {
int a = read(), b = read();
aedge(a, b);
aedge(b, a);
}
sum = n;
get(1, 0);
for (int i = 1; i <= n; i++)
if (gen[i]) {
for (int j = son[i]; j; j = nextt[j])
if (!gen[ed[j]]) {
top = 0;
solve(ed[j]);
ans[++tot][0] = i;
ans[tot][1] = ed[j];
ans[tot][2] = q[1];
for (int j = 2; j <= top; j++) {
ans[++tot][0] = q[j - 1];
ans[tot][1] = father[q[j - 1]];
ans[tot][2] = q[j];
}
for (int j = top - 1; j; j--) {
ans[++tot][0] = q[j];
ans[tot][1] = q[j + 1];
ans[tot][2] = q[top];
}
ans[++tot][0] = i;
ans[tot][1] = q[1];
ans[tot][2] = q[top];
}
}
sum = 0;
for (int i = 1; i <= tot; i++)
if (ans[i][1] != ans[i][2]) sum++;
writeln(sum);
for (int i = 1; i <= tot; i++)
if (ans[i][1] != ans[i][2]) {
write(ans[i][0]);
an += ' ';
write(ans[i][1]);
an += ' ';
writeln(ans[i][2]);
}
cout << an;
}
| 2,600 | CPP |
import sys
sys.setrecursionlimit(10**9)
def find(a):
if par[a]==a:
return a
par[a]=find(par[a])
return par[a]
n,m=map(int,input().split())
ed=[]
par=[i for i in range(n)]
size=[1 for i in range(n)]
for _ in range(n-1):
a,b,c=map(int,input().split())
ed.append([a-1,b-1,c])
ed.sort(key=lambda x:x[2])
it=list(map(int,input().split()))
it=[[i,j,0] for j,i in enumerate(it)]
it.sort()
ind=0
tot=0
j=0
#print(it)
ss={}
for i in it[:]:
while ind<n-1:
if ed[ind][2]<=i[0]:
a=find(ed[ind][0])
b=find(ed[ind][1])
if a!=b:
tot+=size[a]*size[b]
# print(a,b,j,tot)
if size[a]>=size[b]:
par[b]=a
size[a]+=size[b]
size[b]=0
else:
par[a]=b
size[b]+=size[a]
size[a]=0
ind+=1
else:
break
it[j][2]=tot
#ss[it[j][1]]=tot
j+=1
it.sort(key=lambda x:x[1])
aa=[i[2] for i in it]
#for i in range(len(it)):
# print(ss[i],end=" ")
print(*aa)
| 1,800 | PYTHON3 |
for _ in range(int(input())):
n, x, y = map(int,input().split())
diff = y - x
for i in range(1, diff+1):
if diff % i:
continue
if diff / i + 1 > n:
continue
k = int(min(( y-1) / i, n - 1))
a0 = y - k * i
for j in range(n):
print(a0 + j * i, end = ' ')
print('')
break
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline void _RD(int &x) { scanf("%d", &x); }
inline void _RD(long long &x) { scanf("%lld", &x); }
inline void _RD(double &x) { scanf("%lf", &x); }
inline void _RD(long double &x) { scanf("%Lf", &x); }
inline void _RD(char &x) { scanf(" %c", &x); }
inline void RD() {}
template <class T, class... U>
inline void RD(T &head, U &...tail) {
_RD(head);
RD(tail...);
}
using PII = pair<int, int>;
using LL = long long;
using VI = vector<int>;
using VLL = vector<LL>;
using VVI = vector<VI>;
const int MAXN = 1007;
VI e[MAXN];
int n, m;
int ind[MAXN], oud[MAXN];
bool self[MAXN];
const int INF = 0x3f3f3f3f;
bool bfs(const int ignore, int M[], int d[]) {
queue<int> q;
for (auto i = (1); i <= (n); ++i)
if (i != ignore)
if (M[i])
d[i] = INF;
else
d[i] = 0, q.push(i);
else {
}
d[0] = INF;
while (!q.empty()) {
int u = q.front();
q.pop();
if (d[u] < d[0])
for (auto v : (e[u]))
if (v != n + ignore && d[M[v]] == INF) {
d[M[v]] = d[u] + 1;
q.push(M[v]);
}
}
return d[0] != INF;
}
bool dfs(int u, const int ignore, int M[], int d[]) {
if (!u) return true;
int dt = d[u];
d[u] = INF;
for (auto v : (e[u]))
if (v != n + ignore && d[M[v]] == dt + 1 && dfs(M[v], ignore, M, d)) {
M[u] = v, M[v] = u;
return true;
}
return false;
}
int hpk(int ignore) {
int M[n << 1 | 1], d[n << 1 | 1], ans = 0;
memset(M, 0, sizeof(M));
while (bfs(ignore, M, d))
for (auto i = (1); i <= (n); ++i)
if (i != ignore && !M[i] && dfs(i, ignore, M, d)) ++ans;
return ans;
}
int solve(int l, int r) {
int ans = INT_MAX;
for (auto i = (l); i <= (r); ++i) {
int cnt = 0;
cnt = self[i] ? 2 * n - ind[i] - oud[i] : 2 * n - ind[i] - oud[i] - 1;
int mc = hpk(i);
cnt = cnt + m - (ind[i] + oud[i] - self[i]) + n - 1 - 2 * mc;
ans = min(ans, cnt);
}
return ans;
}
int main() {
RD(n, m);
for (auto i = (1); i <= (m); ++i) {
int u, v;
RD(u, v);
e[u].push_back(n + v);
++ind[v], ++oud[u];
if (u == v) self[u] = true;
}
int ans = INT_MAX;
ans = solve(1, n);
printf("%d\n", ans);
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
double r, x1, y1, x2, y2;
cin >> r >> x1 >> y1 >> x2 >> y2;
double dis = sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
int answer = dis / (2 * r);
if (dis != answer * 2 * r) answer++;
cout << answer;
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 60;
long long toInt(string s) {
long long res;
stringstream ss;
ss << s;
ss >> res;
return res;
}
string toString(long long n) {
stringstream ss;
ss << n;
return ss.str();
}
vector<string> fdst;
long long ans;
long long flip_col[2010];
long long flip_jiku[2010];
void run() {
long long n;
cin >> n;
fdst = vector<string>(n);
for (long long i = (0); i < (n); ++i) {
cin >> fdst[i];
}
ans = 0;
for (long long i = (0); i < (n); ++i) flip_col[i] = 0, flip_jiku[i] = 0;
for (long long i = 0; i < n; i++) {
long long flip = 0;
for (long long j = n - 1; j > i; j--) {
if (((flip_col[j] + flip) % 2) + '0' != fdst[i][j]) {
ans++;
flip++;
flip_col[j]++;
flip_jiku[j] += 1;
}
}
flip_jiku[i] += flip % 2;
}
for (long long i = (0); i < (n); ++i) flip_col[i] = 0;
for (long long i = n - 1; i >= 0; i--) {
long long flip = 0;
for (long long j = 0; j < i; j++) {
if (((flip_col[j] + flip) % 2) + '0' != fdst[i][j]) {
ans++;
flip++;
flip_col[j]++;
flip_jiku[j] += 1;
}
}
flip_jiku[i] += flip % 2;
}
for (long long i = (0); i < (n); ++i) {
if ((flip_jiku[i] % 2) + '0' != fdst[i][i]) ans++;
}
cout << ans << endl;
}
int main(int argc, char *argv[]) {
run();
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
void run() {
char *str = "abcd";
int n;
cin >> n;
for (int i = 0; i < n; i++) cout << str[i % 4] << (i == n - 1 ? "\n" : "");
}
int main() {
run();
return 0;
}
| 1,100 | CPP |
n=int(input())
mod=((10**9)+7)
for j in range(n):
x=int(input())
sleft=str(input())
length=len(sleft)
l=0
while len(sleft)<x:
l+=1
if sleft[l-1]=="2":
sright=sleft[l:]
sleft+=sright
elif sleft[l-1]=="3":
sright=sleft[l:]
sleft+=sright*2
else:
continue
for l in range(1,x+1):
mult=int(sleft[l-1])
length=l+mult*((length-l)%mod)
length=length%mod
print(length)
| 1,700 | PYTHON3 |
for _ in range(int(input())):
n=int(input())
a=[int(x) for x in input().split()]
for i in reversed(range(n)):
print(a[i],end=" ")
print() | 800 | PYTHON3 |
a,b = map(int,input().split())
s = str(a)
j = 0
for x in range((b-a)+1):
k = list(s)
d = list(s)
e = set(s)
e = list(e)
e.sort()
d.sort()
if e == d:
j += 1
if j == 1:
break
s = str(int(s)+1)
if j == 1:
print("".join(k))
else:
print(-1)
| 800 | PYTHON3 |
n = int(input())
s = input()
t = []
first = 0
second = first + 1
if n == 1:
print(1)
else:
while (first and second) <= len(s) - 1:
if s[first] == s[second]:
first = second
second = first + 1
else:
t.append(s[first])
t.append(s[second])
first = second + 1
second = first + 1
if first == len(s) - 1:
t.append(s[first])
if len(t) % 2 != 0:
t.pop()
print(len(s) - len(t))
for i in t:
print(i, end='') | 1,300 | PYTHON3 |
def find_repost_rank(user_name):
n = int(input())
repost_list = []
i = 0
while i < n:
r = input()
repost_list.append([r.split()[0], r.split()[2]])
i += 1
return find_max(repost_list, user_name)
def find_max(repost_array, user_name, current=0, max_rank=1):
while current < len(repost_array):
current_rank = 1
if repost_array[current][1].lower() == user_name.lower():
current_rank += find_max(repost_array, repost_array[current][0], current + 1, current_rank)
if current_rank > max_rank:
max_rank = current_rank
current += 1
return max_rank
print(find_repost_rank("Polycarp"))
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class V>
ostream &operator<<(ostream &s, pair<T, V> a) {
s << a.first << ' ' << a.second;
return s;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
for (int qq = 1; qq <= T; qq++) {
vector<long long int> a(6);
for (auto &x : a) cin >> x;
int n;
cin >> n;
vector<pair<long long int, long long int> > all(6 * n);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
for (int j = 0; j < 6; j++) all[i * 6 + j] = {x - a[j], i};
}
vector<long long int> cnt(n);
int l = 0, r = 0, d = 0;
sort(all.begin(), all.end());
long long int ans = 2000000000;
while (1) {
while (d < n && r < 6 * n)
cnt[all[r].second]++, d += (cnt[all[r++].second] == 1 ? 1 : 0);
if (d != n) break;
ans = min(ans, all[r - 1].first - all[l].first);
cnt[all[l].second]--;
if (cnt[all[l++].second] == 0) d--;
}
cout << ans << endl;
}
}
| 1,900 | CPP |
for _ in range(int(input())):
n=int(input())
l=[2**x for x in range(1,n+1)]
x,y=sum(l[:n//2 -1])+l[-1],sum(l[n//2 -1:])-l[-1]
print(abs(x-y)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
long long N, A, B;
cin >> N >> A >> B;
vector<long long> P(N, 0);
for (long long i = 0; i < N; i++) {
P[i] = i + 1;
}
long long n, m;
for (n = N / A; n >= 0; n--) {
long long l = 0, r = N;
bool found = false;
while (l != r) {
m = (l + r) / 2;
long long D = n * A + m * B;
if (D == N) {
found = true;
break;
} else if (D < N) {
if (l == m) {
break;
}
l = m;
} else {
if (r == m) {
break;
}
r = m;
}
}
if (found) {
break;
}
}
if (n * A + m * B == N) {
long long idx = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < A; j++, idx++) {
P[idx]++;
if (j == A - 1) {
P[idx] -= A;
}
}
}
for (long long i = 0; i < m; i++) {
for (long long j = 0; j < B; j++, idx++) {
P[idx]++;
if (j == B - 1) {
P[idx] -= B;
}
}
}
for (long long i = 0; i < N; i++) {
cout << P[i];
if (i == N - 1) {
cout << endl;
} else {
cout << " ";
}
}
return 0;
}
cout << -1 << endl;
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> edge[400001];
vector<int> ch[400001];
int sz[400001];
int mx[400001];
bool ok[400001];
bool ans[400001];
int n;
void dfs(int u, int p) {
sz[u] = 1;
mx[u] = 0;
for (auto v : edge[u]) {
if (v != p) {
dfs(v, u);
sz[u] += sz[v];
mx[u] = max(mx[u], mx[v]);
if (sz[v] * 2 <= n) {
mx[u] = max(mx[u], sz[v]);
}
ch[u].push_back(v);
}
}
if ((sz[u] - mx[u]) * 2 <= n) {
ok[u] = true;
}
}
void dfs1(int u, bool up, int mxu) {
ans[u] = up;
for (auto v : ch[u]) {
ans[u] &= ok[v];
}
vector<int> mxp(ch[u].size());
for (int i = 1; i < ch[u].size(); i++) {
mxp[i] = mxp[i - 1];
mxp[i] = max(mxp[i], mx[ch[u][i - 1]]);
if (sz[ch[u][i - 1]] * 2 <= n) {
mxp[i] = max(mxp[i], sz[ch[u][i - 1]]);
}
}
int mxs = 0;
for (int i = ch[u].size() - 1; i >= 0; i--) {
int mxu1 = mxu;
if ((n - sz[ch[u][i]]) * 2 <= n) {
mxu1 = max(mxu1, (n - sz[ch[u][i]]));
}
int mx1 = max(mxu, max(mxp[i], mxs));
bool ok1 = (2 * (n - sz[ch[u][i]] - mx1)) <= n;
dfs1(ch[u][i], ok1, max(mxu1, max(mxp[i], mxs)));
mxs = max(mxs, mx[ch[u][i]]);
if (sz[ch[u][i]] * 2 <= n) {
mxs = max(mxs, sz[ch[u][i]]);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
edge[a].push_back(b);
edge[b].push_back(a);
}
dfs(0, 0);
dfs1(0, 1, 0);
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
return 0;
}
| 2,300 | CPP |
t=int(input())
for _ in range(t):
n=int(input())
l=sorted(list(map(int,input().split())))
m=sorted(list(map(int,input().split())))
print(*l)
print(*m) | 800 | PYTHON3 |
for case in range(int(input())):
a, b = [int(x) for x in input().split()]
k = ''
while int(k + '9') <= b:
k += '9'
# print(a * (len(str(b))-1))
print(a * len(k)) | 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void getre() {
int x = 0;
printf("%d\n", 1 / x);
}
void gettle() {
int res = 1;
while (1) res <<= 1;
printf("%d\n", res);
}
template <typename T, typename S>
inline bool upmin(T &a, const S &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T, typename S>
inline bool upmax(T &a, const S &b) {
return a < b ? a = b, 1 : 0;
}
template <typename N, typename PN>
inline N flo(N a, PN b) {
return a >= 0 ? a / b : -((-a - 1) / b) - 1;
}
template <typename N, typename PN>
inline N cei(N a, PN b) {
return a > 0 ? (a - 1) / b + 1 : -(-a / b);
}
template <typename N>
N gcd(N a, N b) {
return b ? gcd(b, a % b) : a;
}
template <typename N>
inline int sgn(N a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
inline void gn(long long &x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
inline void gn(int &x) {
long long t;
gn(t);
x = t;
}
inline void gn(unsigned long long &x) {
long long t;
gn(t);
x = t;
}
inline void gn(double &x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gn(long double &x) {
double t;
scanf("%lf", &t);
x = t;
}
inline void gs(char *s) { scanf("%s", s); }
inline void gc(char &c) {
while ((c = getchar()) > 126 || c < 33)
;
}
inline void pc(char c) { putchar(c); }
inline long long sqr(long long a) { return a * a; }
inline double sqrf(double a) { return a * a; }
const int inf = 0x3f3f3f3f;
const double pi = 3.14159265358979323846264338327950288L;
const double eps = 1e-6;
const int mo = 1;
int qp(int a, long long b) {
int n = 1;
do {
if (b & 1) n = 1ll * n * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return n;
}
int n;
int a[222];
int nok[33333];
int ok[33333];
int bo[222][222];
const int dinic_inf = 0x3f3f3f3f;
const int DINIC_MAXV = 555 + 5;
const int DINIC_MAXE = 55555 + 5;
int s, t, vtot;
struct edge {
int v, next;
int f;
} e[DINIC_MAXE * 2];
int g[DINIC_MAXV], etot, eid;
int ae(int u, int v, int f) {
upmax(vtot, u);
upmax(vtot, v);
e[etot].v = v;
e[etot].f = f;
e[etot].next = g[u];
g[u] = etot++;
e[etot].v = u;
e[etot].f = 0;
e[etot].next = g[v];
g[v] = etot++;
return eid++;
}
int d[DINIC_MAXV];
bool lb() {
for (int i = 0; i <= vtot; i++) d[i] = 0;
static int qu[DINIC_MAXV];
int p = 0, q = 0;
qu[q++] = s, d[s] = 1;
while (p != q) {
int u = qu[p++];
for (int i = g[u]; ~i; i = e[i].next)
if (e[i].f && !d[e[i].v]) {
d[e[i].v] = d[u] + 1;
if (e[i].v == t) return 1;
qu[q++] = e[i].v;
}
}
return 0;
}
int aug(int u, int mi) {
if (u == t) return mi;
int su = 0, del;
for (int i = g[u]; ~i; i = e[i].next)
if (e[i].f && d[e[i].v] == d[u] + 1) {
del = aug(e[i].v, min(mi, e[i].f));
e[i].f -= del;
e[i ^ 1].f += del;
mi -= del;
su += del;
if (!mi) break;
}
if (!su) d[u] = -1;
return su;
}
int dinic() {
int su = 0;
while (lb()) su += aug(s, dinic_inf);
return su;
}
void dinic_init() {
static bool ini = 0;
if (!ini) {
ini = 1;
memset(g, -1, sizeof(g));
} else {
for (int i = 0; i <= vtot; i++) g[i] = -1;
}
etot = eid = 0;
vtot = 2, s = 1, t = 2;
}
inline int capaof(int ei) { return e[ei << 1].f + e[ei << 1 ^ 1].f; }
inline int flowof(int ei) { return e[ei << 1 ^ 1].f; }
inline int resiof(int ei) { return e[ei << 1].f; }
inline int uof(int ei) { return e[ei << 1 ^ 1].v; }
inline int vof(int ei) { return e[ei << 1].v; }
vector<int> nei[222];
int vis[222];
int cur = 0;
vector<int> ans[222];
void dfs(int u) {
if (vis[u]) return;
ans[cur].push_back(u);
vis[u] = 1;
dfs(nei[u][0]);
dfs(nei[u][1]);
}
int main() {
nok[1] = 1;
for (int i = 2; i <= 30000; i++)
if (!nok[i])
for (int j = i + i; j <= 30000; j += i) nok[j] = 1;
for (int i = 2; i <= 30000; i++) ok[i] = !nok[i];
gn(n);
for (int i = (1), _ed = (n + 1); i < _ed; i++) gn(a[i]);
for (int i = (1), _ed = (n + 1); i < _ed; i++)
for (int j = (1), _ed = (n + 1); j < _ed; j++)
if (i != j && ok[a[i] + a[j]]) bo[i][j] = 1;
int nu0 = 0, nu1 = 0;
for (int i = (1), _ed = (n + 1); i < _ed; i++)
if (a[i] & 1)
nu1++;
else
nu0++;
if (nu0 != nu1) {
printf("Impossible\n");
return 0;
}
dinic_init();
for (int i = (1), _ed = (n + 1); i < _ed; i++)
if (a[i] & 1)
for (int j = (1), _ed = (n + 1); j < _ed; j++)
if (bo[i][j]) ae(i, j, 1);
s = n + 1, t = n + 2;
for (int i = (1), _ed = (n + 1); i < _ed; i++)
if (a[i] & 1)
ae(s, i, 2);
else
ae(i, t, 2);
int su = dinic();
if (su != n) {
printf("Impossible\n");
return 0;
}
for (int i = (0), _ed = (eid); i < _ed; i++)
if (uof(i) != s && vof(i) != t && flowof(i) == 1) {
nei[uof(i)].push_back(vof(i));
nei[vof(i)].push_back(uof(i));
}
for (int i = (1), _ed = (n + 1); i < _ed; i++)
if (!vis[i]) {
++cur;
dfs(i);
}
printf("%d", cur);
for (int i = (1), _ed = (cur + 1); i < _ed; i++) {
printf("\n%d", ans[i].size());
for (int j = (0), _ed = (((int)(ans[i]).size())); j < _ed; j++)
printf(" %d", ans[i][j]);
}
return 0;
}
| 2,300 | CPP |
for _ in range(int(input())):
h,a,b = map(int,input().split())
c = h
kk = 0
while a>0:
w = c
if w == 20:
break
c = w//2 + 10
q = c - 10*b
ss = w-10*b
if q<=0 or ss<=0:
kk = 1
break
a-=1
if c-10*b <=0:
print("YES")
else:
if kk == 1:
print("YES")
else:
print("NO")
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define sc(x) scanf("%d", &(x))
#define sclld(x) scanf("%lld", &(x))
#define sz(x) int((x).size())
#define all(x) (x).begin(), (x).end()
#define MT make_tuple
#define MP make_pair
#define lastOne(x) (31 - __builtin_clz(x))
#define debug(x) cout<<(#x)<<": \""<<x<<"\""<<endl
#define debugVec(vec) cout<<(#vec)<<": "; for (auto& i: vec) cout<<i<<" "; cout<<endl
typedef long long ll;
typedef pair<int, int> ii;
const double PI = 2*acos(0);
const double EPS = 1e-9;
const int oo = 2e9;
const ll OO = 1e18;
const ll MOD = 1e9+7;
const int N = 5e5+5;
int a[N], l[N], r[N], f[N], dp[N];
int main()
{
int n;
sc(n);
for (int i = 0; i < n; i++)
{
sc(a[i]);
r[a[i]] = i;
if (l[a[i]] == 0 && a[0] != a[i])
l[a[i]] = i;
}
dp[n-1] = 1;
f[a[n-1]]++;
for (int i = n - 2; i >= 0; i--)
{
f[a[i]]++;
if (l[a[i]] == i)
dp[i] = f[a[i]] + dp[r[a[i]]+1];
dp[i] = max(dp[i], f[a[i]]);
dp[i] = max(dp[i], dp[i+1]);
}
printf("%d\n", n-dp[0]);
return 0;
} | 2,500 | CPP |
t=input().split('+')
print('+'.join(sorted(t)))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long fact(long long j) {
long long a = 1;
for (long long i = 1; i <= j; i++) a *= i;
return a;
}
long long pw(long long a, long long b) {
if (b == 0) return 1;
if (b % 2)
return pw(a, b - 1) * a;
else {
long long x = pw(a, b / 2);
return x * x;
}
}
long long sum2(long long c) {
long long s = 0;
while (c != 0) {
s += (c % 10) * (c % 10);
c /= 10;
}
return s;
}
vector<int> merge(const vector<int> &a, const vector<int> &b) {
long long p1 = 0, p2 = 0;
vector<int> c;
for (; p1 < a.size() && p2 < b.size();)
if (a[p1] == b[p2]) {
c.push_back(a[p1]);
p1++;
p2++;
} else if (a[p1] < b[p2])
p1++;
else
p2++;
return c;
}
bool prime(long long a) {
if (a == 0 || a == 1) return false;
for (int i = 2; i <= sqrt(a); i++)
if (a % i == 0) return false;
return true;
}
long long C(long long n, long long k) {
vector<vector<long long> > dp(n + 1, vector<long long>(n + 1, 1));
for (int i = 0; i < (n + 1); i++) {
for (int j = 1; j < i; j++) {
dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
}
}
return dp[n][k];
}
struct st {
int h, m, s;
};
bool operator<(st A, st B) {
return (A.h < B.h || A.h == B.h && A.m < B.m ||
A.h == B.h && A.m == B.m && A.s < B.s);
}
bool cmp(long long a, long long b) {
if (a % 10 < b % 10) return true;
if (a % 10 > b % 10) return false;
if (a % 10 == b % 10) {
return (a < b);
}
}
long long phi(long long n) {
long long ans = n;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) {
while (n % i == 0) n /= i;
ans -= ans / i;
}
if (n > 1) ans -= ans / n;
return ans;
}
vector<long long> rech(200005, 1);
void reh() {
rech[0] = 0;
rech[1] = 0;
for (long long i = 2; i < 100000; i++)
for (long long j = i * i; j < 100000; j += i)
if (rech[j]) rech[j] = 0;
}
struct Node {
long long i, mx;
};
Node tr[4 * 1000000 + 10];
void build(vector<long long> &a, long long v, long long l, long long r) {
if (l == r)
tr[v].i = l, tr[v].mx = a[l];
else {
long long m = (l + r) / 2;
build(a, 2 * v, l, m);
build(a, 2 * v + 1, m + 1, r);
if (tr[2 * v].mx >= tr[2 * v + 1].mx)
tr[v].i = tr[2 * v].i, tr[v].mx = tr[2 * v].mx;
else
tr[v].i = tr[2 * v + 1].i, tr[v].mx = tr[2 * v + 1].mx;
}
}
Node find(long long x, long long y, long long v, long long l, long long r) {
if (x == l && y == r) return tr[v];
long long m = (l + r) / 2;
if (y <= m)
return find(x, y, 2 * v, l, m);
else if (x > m)
return find(x, y, 2 * v + 1, m + 1, r);
else {
Node a, b, c;
a = find(x, m, 2 * v, l, m);
b = find(m + 1, y, 2 * v + 1, m + 1, r);
if (a.mx >= b.mx)
c.i = a.i, c.mx = a.mx;
else
c.i = b.i, c.mx = b.mx;
return c;
}
}
void update(long long i, long long x, long long v, long long l, long long r) {
if (l == r) {
if (tr[v].mx != 0)
tr[v].mx = x;
else
return;
} else {
long long m = (l + r) / 2;
if (i <= m)
update(i, x, 2 * v, l, m);
else
update(i, x, 2 * v + 1, m + 1, r);
if (tr[2 * v].mx >= tr[2 * v + 1].mx)
tr[v].i = tr[2 * v].i, tr[v].mx = tr[2 * v].mx;
else
tr[v].i = tr[2 * v + 1].i, tr[v].mx = tr[2 * v + 1].mx;
}
}
int main() {
long long a, b, n;
cin >> n >> a;
while (cin >> b) {
cout << a + b << " ";
a = b;
}
cout << a;
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 5;
int n, m;
int i, j, k;
int q;
int l[maxn], r[maxn], a[maxn];
int main() {
scanf("%d", &q);
while (q--) {
scanf("%d", &n);
for (i = 1; i <= n; i++) l[i] = r[i] = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (!l[a[i]]) l[a[i]] = i;
r[a[i]] = i;
}
int cnt = 0, last = 0, sum = 0, res = 0;
for (i = 1; i <= n; i++) {
if (l[i]) {
if (last < l[i])
cnt++;
else
cnt = 1;
res = max(cnt, res);
++sum;
last = r[i];
}
}
printf("%d\n", sum - res);
}
return 0;
}
| 2,000 | CPP |
n = int(input())
pre = input()
ans = 1
for i in range(n - 1):
cur = input()
if cur != pre:
ans += 1
pre = cur
print(ans)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 + 50;
long long n, m;
long long a[maxn];
long long b[maxn];
vector<long long> v[maxn];
vector<pair<long long, char> > vec;
int main() {
scanf("%lld", &n);
long long x1 = 0, y1 = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
x1 += a[i];
}
scanf("%lld", &m);
for (int i = 1; i <= m; i++) {
scanf("%lld", &b[i]);
y1 += b[i];
}
if (x1 != y1) {
puts("NO");
return 0;
}
long long sum = 0;
int idx = 1;
for (int i = 1; i <= n; i++) {
v[idx].push_back(a[i]);
sum += a[i];
if (sum > b[idx]) {
puts("NO");
return 0;
}
if (sum == b[idx]) {
sum = 0;
idx++;
}
}
for (int i = 1; i <= m; i++) {
if (v[i].size() == 1) {
continue;
}
long long temp = v[i][0];
long long mx = temp;
bool flag = 0;
for (int j = 1; j < v[i].size(); j++) {
if (temp != v[i][j]) {
flag = 1;
}
if (v[i][j] > mx) {
mx = v[i][j];
}
}
if (!flag) {
puts("NO");
return 0;
}
int id, lr = 0;
for (int j = 0; j < v[i].size() - 1; j++) {
if (v[i][j] == mx && v[i][j + 1] < mx) {
lr = 1;
id = j;
break;
}
}
if (!lr) {
for (int j = v[i].size() - 1; j > 0; j--) {
if (v[i][j] == mx && v[i][j - 1] < mx) {
lr = -1;
id = j;
break;
}
}
}
if (lr == 1) {
for (int j = id + 1; j < v[i].size(); j++) {
vec.push_back(make_pair(id + i, 'R'));
}
for (int j = id - 1; j >= 0; j--) {
vec.push_back(make_pair(i + j + 1, 'L'));
}
} else {
for (int j = id - 1; j >= 0; j--) {
vec.push_back(make_pair(i + j + 1, 'L'));
}
for (int j = id + 1; j < v[i].size(); j++) {
vec.push_back(make_pair(i, 'R'));
}
}
}
puts("YES");
for (int i = 0; i < vec.size(); i++) {
cout << vec[i].first << " " << vec[i].second << endl;
}
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e5 + 7;
const long long int inf = 1e17;
vector<vector<long long int> > v(N);
vector<long long int> ans;
long long int ori[N], req[N], cnt = 0;
void bfs() {
queue<long long int> q;
long long int dis[N], odd[N], even[N];
dis[0] = 0;
q.push(1);
bool vis[N];
memset(vis, 0, sizeof vis);
vis[1] = 1;
if (ori[1] != req[1]) {
even[1]++;
cnt++;
ans.push_back(1);
}
while (!q.empty()) {
long long int top = q.front();
q.pop();
for (auto it = v[top].begin(); it != v[top].end(); it++) {
if (!vis[*it]) {
vis[*it] = 1;
q.push(*it);
dis[*it] = dis[top] + 1;
if (dis[*it] % 2 == 0) {
long long int cur = (ori[*it] + even[top]) % 2;
long long int mgn = 0;
if (cur != req[*it]) {
cnt++;
ans.push_back(*it);
mgn++;
}
odd[*it] = odd[top];
even[*it] = even[top] + mgn;
}
if (dis[*it] % 2 != 0) {
long long int cur = (ori[*it] + odd[top]) % 2;
long long int mgn = 0;
if (cur != req[*it]) {
cnt++;
ans.push_back(*it);
mgn++;
}
even[*it] = even[top];
odd[*it] = odd[top] + mgn;
}
}
}
}
cout << cnt << endl;
for (auto it = ans.begin(); it != ans.end(); it++) {
printf("%lld\n", *it);
}
}
int main() {
long long int n, i, j, k;
cin >> n;
for (i = 0; i < n - 1; i++) {
scanf("%lld%lld", &j, &k);
v[j].push_back(k);
v[k].push_back(j);
}
for (i = 1; i <= n; i++) scanf("%lld", &ori[i]);
for (i = 1; i <= n; i++) scanf("%lld", &req[i]);
bfs();
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int sol, nr, op1, x, n, a[5000005], x2[1000005];
char s[101];
char op[1000002][16];
char in1[7] = {'i', 'n', 's', 'e', 'r', 't'};
char gm1[7] = {'g', 'e', 't', 'M', 'i', 'n'};
char rm1[10] = {'r', 'e', 'm', 'o', 'v', 'e', 'M', 'i', 'n'};
void in() {
for (int i = 0; i <= 5; ++i) op[sol][i] = in1[i];
}
void gm() {
for (int i = 0; i <= 5; ++i) op[sol][i] = gm1[i];
}
void rm() {
for (int i = 0; i <= 8; ++i) op[sol][i] = rm1[i];
}
int main() {
scanf("%d", &n);
op1 = 6;
int fr = 1;
for (int i = 1; i <= 1000000; ++i) a[i] = -2000000000;
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
int l = strlen(s);
if (l == 6) {
scanf("%d", &x);
if (s[0] == 'i') {
int p = lower_bound(a + fr, a + nr + 1, x) - a;
++nr;
for (int i = nr; i > p; --i) a[i] = a[i - 1];
a[p] = x;
++sol;
in();
x2[sol] = x;
} else {
if (a[fr] == x) {
++sol;
gm();
x2[sol] = x;
} else if (a[fr] > x) {
++sol;
x2[sol] = x;
in();
if (fr == 1) {
for (int i = nr + 1; i >= 1; --i) a[i] = a[i - 1];
a[1] = x;
++nr;
} else
a[--fr] = x;
x2[++sol] = x;
gm();
} else if (a[fr] < x) {
while (a[fr] < x && fr <= nr) {
++fr;
++sol;
rm();
}
if (fr > nr) {
fr = 1, nr = 0;
a[fr] = -2000000000;
}
if (a[fr] == x) {
x2[++sol] = x;
gm();
} else {
++sol;
x2[sol] = x;
in();
if (fr == 1) {
for (int i = nr + 1; i >= 1; --i) a[i] = a[i - 1];
a[1] = x;
++nr;
} else
a[--fr] = x;
x2[++sol] = x;
gm();
}
}
}
} else {
if (fr > nr) {
++sol;
in();
x2[sol] = 0;
++sol;
rm();
} else {
++fr;
++sol;
rm();
}
}
}
printf("%d\n", sol);
for (int i = 1; i <= sol; ++i) {
printf("%s", op[i]);
if (op[i][0] != 'r') printf(" %d", x2[i]);
printf("\n");
}
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const int MAXn = 100;
int a[MAXn];
int t[MAXn][MAXn];
int n;
bool check() {
long long s = 0;
for (int i = 0, __e = n; i < __e; i++) s += t[0][i];
for (int i = 0, __e = n; i < __e; i++) {
long long x = 0;
for (int j = 0, __e = n; j < __e; j++) x += t[i][j];
if (x != s) return false;
}
for (int i = 0, __e = n; i < __e; i++) {
long long x = 0;
for (int j = 0, __e = n; j < __e; j++) x += t[j][i];
if (x != s) return false;
}
long long x = 0;
for (int i = 0, __e = n; i < __e; i++) x += t[i][i];
if (x != s) return false;
x = 0;
for (int i = 0, __e = n; i < __e; i++) x += t[i][n - 1 - i];
if (x != s) return false;
return true;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
int m = n * n;
for (int i = 0, __e = m; i < __e; i++) cin >> a[i];
sort(a, a + m);
do {
int c = 0;
for (int i = 0, __e = n; i < __e; i++)
for (int j = 0, __e = n; j < __e; j++) t[i][j] = a[c++];
if (check()) {
long long sum = 0;
for (int i = 0, __e = n; i < __e; i++) sum += t[0][i];
cout << sum << endl;
for (int i = 0, __e = n; i < __e; i++) {
for (int j = 0, __e = n; j < __e; j++) cout << t[i][j] << " ";
cout << endl;
}
return 0;
}
} while (next_permutation(a, a + m));
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * f;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
write(-x);
return;
}
if (x >= 10) write(x / 10);
putchar(x % 10 + 48);
return;
}
inline void writeln(long long x) {
write(x);
puts("");
return;
}
inline void writesp(long long x) {
write(x);
putchar(' ');
return;
}
struct Node {
long long to;
long long nxt;
} edge[1145140];
long long n, m, root, cnt, len;
long long a[1145140], ans[1145140], head[1145140];
bool vis[1145140];
inline void add(long long x, long long y) {
edge[++cnt].to = y;
edge[cnt].nxt = head[x];
head[x] = cnt;
}
inline void dfs(long long x, long long fa) {
vis[x] = 1;
ans[++len] = x;
a[x] ^= 1;
for (long long i = head[x]; i; i = edge[i].nxt) {
long long to = edge[i].to;
if (!vis[to]) {
dfs(to, x);
ans[++len] = x;
a[x] ^= 1;
}
}
if (fa && a[x]) {
ans[++len] = fa;
a[fa] ^= 1;
ans[++len] = x;
a[x] ^= 1;
}
return;
}
signed main() {
n = read(), m = read();
for (long long i = 1; i <= m; ++i) {
long long x = read(), y = read();
add(x, y);
add(y, x);
}
for (long long i = 1; i <= n; ++i) {
a[i] = read();
if (a[i]) root = i;
}
if (root) {
dfs(root, 0);
for (long long i = 1; i <= n; ++i)
if (!vis[i] && a[i]) {
puts("-1");
return 0;
}
}
if (a[root]) {
writeln(len - 1);
for (long long i = 2; i <= len; ++i) writesp(ans[i]);
} else {
writeln(len);
for (long long j = 1; j <= len; ++j) writesp(ans[j]);
}
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N, X[100010], Y[100010], sumx1 = 0, sumy1 = 0, sumx = 0, sumy = 0,
ans = 0;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> X[i] >> Y[i];
sumx1 += (N - 1) * X[i] * X[i];
sumy1 += (N - 1) * Y[i] * Y[i];
sumx += X[i];
sumy += Y[i];
}
ans = sumx1 + sumy1;
for (int i = 0; i < N - 1; i++) {
ans -= 2 * (sumx - X[i]) * X[i];
sumx = sumx - X[i];
ans -= 2 * (sumy - Y[i]) * Y[i];
sumy = sumy - Y[i];
}
cout << ans << "\n";
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long phi(long long n) {
long long result = n;
for (long long i = 2; i * i <= n; ++i)
if (n % i == 0) {
while (n % i == 0) n /= i;
result -= result / i;
}
if (n > 1) result -= result / n;
return result;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k;
cin >> n >> k;
for (long long i = 0; i < (k + 1) / 2; ++i) {
n = phi(n);
if (n == 1) break;
}
cout << (n % (1000000007)) << "\n";
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pll = pair<ll, ll>;
using pii = pair<int, int>;
const int MOD = 1e9 + 7;
const int MAX = 1e5 + 5;
const ll INF = 1e18 + 1;
void err(...) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
for (auto i : *it) cerr << i;
cerr << " = " << a << "\n";
err(++it, args...);
}
template <class Ch, class Tr, class Container>
basic_ostream<Ch, Tr>& operator<<(basic_ostream<Ch, Tr>& os,
Container const& x) {
os << "{ ";
for (auto& y : x) os << y << " ";
return os << "}";
}
template <class X, class Y>
ostream& operator<<(ostream& os, pair<X, Y> const& p) {
return os << "[" << p.first << " : " << p.second << "]";
}
void primeFactors(vector<ll>& v, ll n) {
for (ll i = 2; i <= sqrt(n); i++)
while (n % i == 0) {
v.emplace_back(i);
n /= i;
}
if (n > 2) v.emplace_back(n);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n;
cin >> n;
vector<ll> pr;
primeFactors(pr, n);
if (pr.empty()) {
cout << 1 << "\n" << 0 << "\n";
return 0;
}
if (pr.back() == n) pr.pop_back();
if (pr.empty()) {
cout << 1 << "\n" << 0 << "\n";
return 0;
}
if (pr.size() == 2)
cout << 2;
else {
cout << 1 << "\n";
cout << pr[0] * pr.back();
}
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
//Warsaw debug template
#define LOCAL
#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
enable_if<sizeof dud<c>(0) x 1,debug&>::type operator<<(c i){
sim > struct rge {c b,e;};
sim > rge<c> range(c i, c j) {return rge<c>{i,j};}
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug{
#ifdef LOCAL
~debug() {cerr<<endl; }
eni(!=) cerr<< boolalpha << i; ris;}
eni(==) ris <<range(begin(i),end(i)); }
sim, class b dor(pair<b,c> d){
ris<<"("<<d.first<<","<<d.second<<")";
}
sim dor(rge<c> d){
*this << "[";
for(auto it=d.b;it!=d.e;++it)
*this <<"," +(it==d.b)<< *it;
ris<<"]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) "["<<#__VA_ARGS__":"<<(__VA_ARGS__)<<"]"
//End of debug template
#define FOR(i,n) for (int i = 0; i < (n); ++i)
using ll = long long;
//codeforces
//^
//odfrces
//c o d e f o r c e s
//^ find first occur
//^ pointer from 0 to any s
//^ find occur
//^ pointer from 0 to any r
//^ from here to sz -1, all chars set to be true
//^ find occur
//^ pointer from 0 to first o
//check from this index til end insert to be true
void solve(){
string s;
cin >> s;
int n = s.size();
vector<bool> exists(26);
FOR(i,n) exists[s[i] - 'a'] = true;
int idx = 0;
while(true){
bool isOK = false;
for(int i = 25; i>=0;i--){
if(exists[i]){
int where = idx;
while(s[where]-'a' != i){
where++;
}
vector<bool> suffix(26);
for(int j = where;j < n;j++){
if(exists[s[j]-'a']){
suffix[s[j]-'a'] = true;
}
}
if(suffix == exists){
cout << s[where];
idx = where + 1;
exists[s[where] - 'a'] = false;
isOK = true;
break;
}
}
}
if(!isOK) break;
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while(t--){
solve();
}
return 0;
}
//void solve(){
//string s;
//cin>>s;
//vector<int> h(130),vis(130);
//vector<char> a;
//for(auto i:s)h[i]++;
//for(auto i:s){
//h[i]--;
//if(!vis[i]){
//while(!a.empty()){
//if(h[a.back()]==0 or a.back()>i)break;
//vis[a.back()]=0;
//a.pop_back();
//}
//a.push_back(i);
//vis[i]=1;
//}
//}
//cout<<string(a.begin(),a.end())<<"\n";
//}
//int main()
//{
//int t;cin>>t;
//while(t--)solve();
//}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0 && cin.tie(0) && cout.tie(0));
;
int n;
cin >> n;
int p;
cin >> p;
set<int> s1;
for (int i = 0; i < p; i++) {
int a;
cin >> a;
s1.insert(a);
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int a;
cin >> a;
s1.insert(a);
}
if (s1.size() == n)
cout << "I become the guy.";
else
cout << "Oh, my keyboard!";
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename Tp>
inline void outarr(Tp _begin, Tp _end, const char* _delim = " ") {
for (Tp current = _begin; current != _end; ++current) {
std::cout << *current << _delim;
}
std::cout << '\n';
}
using ll = long long;
using pii = std::pair<int, int>;
constexpr int INF = 0x3f3f3f3f;
constexpr int MOD = static_cast<const int>(1e9 + 7);
constexpr int MAXN = 1000;
constexpr int MAXT = 1560;
struct Task {
double dprob;
int prob;
int score_small;
int score_large;
int time_small;
int time_large;
};
Task arr[MAXN];
pair<ll, double> dp[2][MAXT + 1];
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, time;
cin >> n >> time;
const int infa100 = 1000000;
for (int i = 0; i < (n); ++i) {
cin >> arr[i].score_small >> arr[i].score_large >> arr[i].time_small >>
arr[i].time_large >> arr[i].dprob;
arr[i].prob = infa100 - int(arr[i].dprob * infa100 + 0.5);
}
sort(arr, arr + n, [](const Task& lhs, const Task& rhs) {
return 1LL * lhs.time_large * rhs.prob * (infa100 - lhs.prob) <
1LL * rhs.time_large * lhs.prob * (infa100 - rhs.prob);
});
int cur = 0;
for (int i = 0; i < (n); ++i) {
const int pre = cur;
cur ^= 1;
const int dt = arr[i].time_small + arr[i].time_large;
const ll score_small = 1LL * arr[i].score_small * infa100;
const ll score_large = score_small + 1LL * arr[i].score_large * arr[i].prob;
for (int t = 0; t <= time; ++t) {
dp[cur][t] = dp[pre][t];
if (t >= arr[i].time_small) {
auto cur_val = make_pair(
dp[pre][t - arr[i].time_small].first + score_small,
dp[pre][t - arr[i].time_small].second - arr[i].time_small);
dp[cur][t] = max(dp[cur][t], cur_val);
}
if (t >= dt) {
auto cur_val = make_pair(
dp[pre][t - dt].first + score_large,
(dp[pre][t - dt].second - arr[i].time_small) * arr[i].dprob -
(1 - arr[i].dprob) * t);
dp[cur][t] = max(dp[cur][t], cur_val);
}
}
}
pair<ll, double> ans;
for (int i = 1; i <= time; ++i) {
ans = max(ans, dp[cur][i]);
}
cout.setf(ios::fixed);
cout.precision(10);
cout << (long double)ans.first / infa100 << ' ' << -ans.second << "\n";
return 0;
}
| 2,800 | CPP |
n = int(input())
flag = 0
arr = [4,7,47,74,444,447,474,477,744,747,774,777]
for i in range(len(arr)):
if(n%arr[i]==0):
flag=1
if(flag==1):
print("YES")
else:
print("NO") | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
int fu = 1;
char c = getchar();
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = getchar();
}
while (c <= 57 && c >= 48) {
x = (x << 3) + (x << 1) + c - 48;
c = getchar();
}
x *= fu;
}
template <typename T>
inline void fprint(T x) {
if (x < 0) putchar(45), x = -x;
if (x > 9) fprint(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void fprint(T x, char ch) {
fprint(x);
putchar(ch);
}
int n, m;
int a[300005];
int ck = 0, one = 0;
vector<pair<int, int> > vec[300005];
int fa[300005];
pair<int, int> f[300005];
int fd(int x) {
if (fa[x] == x) return x;
return fa[x] = fd(fa[x]);
}
bitset<300005> b;
int d[300005];
void dfs(int x, int pre) {
f[x].first = pre;
for (int i = 0; i < vec[x].size(); i++) {
if (vec[x][i].first == pre) continue;
d[x]++;
f[vec[x][i].first].second = vec[x][i].second;
dfs(vec[x][i].first, x);
}
}
queue<int> q;
void bfs() {
for (register int i = 1; i <= n; i++) {
if (!d[i]) q.push(i);
}
while (!q.empty()) {
int x = q.front();
q.pop();
if (a[x]) b[f[x].second] = 1, a[f[x].first] ^= 1;
d[f[x].first]--;
if (!d[f[x].first]) q.push(f[x].first);
}
}
int main() {
read(n);
read(m);
for (int i = 1; i <= n; i++) {
read(a[i]);
if (~a[i])
one ^= a[i];
else
ck = 1;
fa[i] = i;
}
if (one && !ck) return printf("-1\n"), 0;
for (register int i = 1; i <= n; i++) {
if (a[i] == -1) {
if (one)
a[i] = 1, one = 0;
else
a[i] = 0;
}
}
for (int i = 1; i <= m; i++) {
int u, v;
read(u);
read(v);
int uu = fd(u), vv = fd(v);
if (uu ^ vv) {
fa[uu] = vv;
vec[u].push_back(make_pair(v, i));
vec[v].push_back(make_pair(u, i));
}
}
dfs(1, 0);
bfs();
fprint(b.count(), 10);
for (int i = 1; i <= m; i++) {
if (b[i]) fprint(i, 10);
}
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 16) + 1e3;
struct node {
int degree;
int si;
node() {}
node(int _degree, int _si) : degree(_degree), si(_si) {}
} nd[N];
struct edge {
int u, v;
edge() {}
edge(int _u, int _v) : u(_u), v(_v) {}
} edges[N];
int cnt;
int n;
queue<int> que;
int main() {
scanf("%d", &n);
while (!que.empty()) que.pop();
for (int i = 0; i < n; i++) {
int d, s;
scanf("%d %d", &d, &s);
nd[i] = node(d, s);
if (d == 1) que.push(i);
}
cnt = 0;
while (!que.empty()) {
int p = que.front();
que.pop();
if (nd[p].degree == 0) continue;
int u = nd[p].si, v = p;
edges[cnt++] = edge(u, v);
nd[u].si ^= p;
nd[u].degree--;
if (nd[u].degree == 1) que.push(u);
}
printf("%d\n", cnt);
for (int i = 0; i < cnt; i++) {
printf("%d %d\n", edges[i].u, edges[i].v);
}
return 0;
}
| 1,500 | CPP |
#!/usr/bin/env python3
#-*- encoding: utf-8 -*-
import sys
import bisect
from collections import Counter
read_int = lambda : int(sys.stdin.readline())
read_ints = lambda : map(int,sys.stdin.readline().split())
read_int_list = lambda : list(read_ints())
read = lambda : sys.stdin.readline().strip()
read_list = lambda : sys.stdin.readline().split()
def main():
n,k = read_ints()
s = read()
d = Counter(s)
res = k*min(d.values()) if len(d) == k else 0
print(res)
main()
| 800 | PYTHON3 |
n,m=map(int,input().split())
numbers=list(map(int,input().split()))
secondNumbers=[]
for i in range(0,m,1):
x=int(input())
secondNumbers.append(x)
mysets=set()
answer=[0]*n
count=0
for j in range(n-1,-1,-1):
mysets.add(numbers[j])
length=len(mysets)
if(count<length):
answer[j] = length
count+=1
else:
answer[j]=length
for k in range(0,m,1):
print(answer[secondNumbers[k]-1])
| 1,100 | PYTHON3 |
n=int(input())
if n%2==0:
x=n-8
y=n-x
else:
x=n-9
y=n-x
if x>y:
x,y=y,x
print(str(x)+" "+str(y))
| 800 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
p = list(map(int, input().strip().split()))
print(*p[::-1])
| 800 | PYTHON3 |
k,n,w=map(int,input().split())
p=0
for i in range(1,w+1):
p=(k*i)+p
if p>n:
res=p-n
print(res)
else:
print("0") | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int findK(int k, long long int s[], int start, int end) {
if (start > end) return -1;
if (k > s[start] && k <= s[start + 1]) {
return start + 1;
}
int mid = start + (end - start) / 2;
if (k > s[mid]) {
return findK(k, s, mid, end);
}
if (k <= s[mid - 1]) {
return findK(k, s, start, mid - 1);
}
return mid;
}
int getIthDigit(int x, int i) {
string s = to_string(x);
return s[i - 1] - '0';
}
int findK1(int toSearch, long long int f[], int x) {
if (f[x] == toSearch) return x % 10;
int flag = -1;
int pow10 = 10;
for (int i = 1; i <= 5; i++) {
if (toSearch <= f[pow10 - 1]) {
flag = i;
break;
}
pow10 *= 10;
}
pow10 /= 10;
int updatedSearch = toSearch - f[pow10 - 1];
int y = (pow10 - 1) + (updatedSearch / flag);
if (updatedSearch % flag == 0) return y % 10;
return getIthDigit(y + 1, updatedSearch % flag);
}
int main() {
long long int f[100000];
long long int s[100000];
f[0] = 0;
s[0] = 0;
int increment = 1;
int pow10 = 10;
for (int i = 1; i < 100000; i++) {
if (i == pow10) {
increment++;
pow10 *= 10;
}
f[i] = f[i - 1] + increment;
s[i] = s[i - 1] + f[i];
}
int q;
cin >> q;
while (q--) {
int k;
cin >> k;
int x = findK(k, s, 1, 100000 - 1);
int k1 = k - s[x - 1];
int y = findK1(k1, f, x);
cout << y << endl;
}
}
| 1,900 | CPP |
def check(yr):
if(len(set(yr))!=len(yr)):
return 0
return 1
yr=input()
n=int(yr)
n+=1
yr=str(n)
while(check(yr)!=1):
n=int(yr)
n+=1
yr=str(n)
print(n) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
if (m == 1) {
cout << n;
return 0;
}
long long o = 0;
int i = 0;
while (n) {
o += (long long)((long long)1 << i);
i++;
n /= 2;
}
cout << o;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long n, k;
cin >> n >> k;
long long x = 1, y = n;
while (true) {
x = max(1ll, x - k), y = min(n, y + k);
long long m, l, r;
if (y - x + 1 > 5 * k) {
m = (x + y) / 2;
l = x, r = m;
} else {
m = x + uniform_int_distribution<int>(0, (int)(y - x))(rng);
l = m, r = m;
}
cout << l << ' ' << r << '\n';
fflush(stdout);
string s;
cin >> s;
if (s == "No") {
if (y - x + 1 > 5 * k) {
x = m + 1;
}
} else {
if (l == r) {
break;
} else {
if (y - x + 1 > 5 * k) {
y = m;
}
}
}
}
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int iin() {
int x;
scanf("%d", &x);
return x;
}
void arrayin(int *l, int *r) {
for (int *p = l; p < r; p++) scanf("%d", p);
}
void iprint(int x) { printf("%d ", x); }
const int N = 1e5;
int n, a[N];
vector<int> primes;
bool isp[N];
void seive() {
for (int i = 2; i < N; i++) {
if (isp[i]) continue;
primes.push_back(i);
for (int j = i * i; j < N; j += i) isp[j] = true;
}
}
vector<pair<int, int> > getFactors(int x) {
vector<pair<int, int> > ans;
ans.push_back({-1, 0});
for (int i = 0; primes[i] * primes[i] < x; i++) {
while (x % primes[i] == 0) x /= primes[i], ans.back().second++;
if (ans.back().second) ans.back().first = primes[i], ans.push_back({-1, 0});
}
if (x != 1)
ans.back().first = x, ans.back().second = 1;
else
ans.pop_back();
return ans;
}
vector<int> sorted_divisors(int x) {
vector<int> ans[2];
int i = 1;
for (; i * i < x; i++) {
if (x % i == 0) ans[0].push_back(i), ans[1].push_back(x / i);
}
if (i * i == x) ans[0].push_back(i);
for (int i = ans[1].size() - 1; i > -1; i--) ans[0].push_back(ans[1][i]);
return ans[0];
}
int powm(int x, int p) {
int ans = 1;
while (p) {
if (p & 1) ans = 1ll * ans * x % 1000000007;
p >>= 1;
x = 1ll * x * x % 1000000007;
}
return ans;
}
int tAns(vector<int> divis) {
int ans = 0;
int gt = a + n - lower_bound(a, a + n, divis.back());
if (gt == 0) return 0;
ans =
(1LL * powm(divis.size(), gt) + 1000000007 - powm(divis.size() - 1, gt)) %
1000000007;
for (int i = divis.size() - 2; i > -1; i--) {
int t = a + n - lower_bound(a, a + n, divis[i]);
t -= gt;
gt += t;
ans = 1ll * ans * powm(i + 1, t) % 1000000007;
}
return ans;
}
int main() {
n = iin();
arrayin(a, a + n);
sort(a, a + n);
int ans = 0;
for (int i = 1; i <= N; i++) {
ans += tAns(sorted_divisors(i));
if (ans >= 1000000007) ans -= 1000000007;
}
iprint(ans);
}
| 2,000 | CPP |
x,y,z = map(int,input().split())
res1=x%z
res2=y%z
if res1 + res2 < z:
print( (x+y)//z ,0)
else:
print( (x+y)//z, z-max(res1,res2))
| 1,000 | PYTHON3 |
t = int(input())
for i in range(t):
n =int(input())
arr =list(map(int,input().split()))
d = {}
count =0
for i in arr:
if(i in d):
continue
d[i] = 1
count+=1
print(count)
| 1,200 | PYTHON3 |
x,y=map(int,input().split())
max=999999999999
num=list(map(int,input().split()))
num=sorted(num)
for i in range(0,y-x+1):
if num[i+x-1]-num[i]<max:
max=num[i+x-1]-num[i]
print(max) | 900 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.