solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int arrn = 1e6 + 10;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
os << v[i];
os << " ";
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &v) {
os << '(' << v.first << ',' << v.second << ')';
return os;
}
long long N = 1e9 + 7;
long long mpow(long long a, long long n, long long m = 1e9 + 7) {
long long r = 1;
while (n) {
if (n & 1) r = (r * a) % m;
a = (a * a) % m;
n >>= 1;
}
return r;
}
long long inv(int a) { return mpow(a, N - 2); }
int last = 0;
long long factmemo[1000] = {1};
long long fact(int n) {
if (n <= last)
return factmemo[n];
else {
for (long long i = last + 1; i <= n; i++) {
factmemo[i] = (i * factmemo[i - 1]) % N;
}
last = n;
return factmemo[n];
}
}
long long vectprod(vector<long long> v) {
long long ans = 1;
for (int i = 0; i < v.size(); i++) {
ans = (ans * v[i]) % N;
}
return ans;
}
int n, m, k;
int main() {
cin >> n >> m >> k;
if ((m - 1) < 2 * k || (n - 1) < 2 * k) {
cout << 0;
return 0;
}
vector<long long> up = {fact(n - 1), fact(m - 1)};
vector<long long> down = {fact(2 * k), fact(2 * k), fact(n - 1 - 2 * k),
fact(m - 1 - 2 * k)};
cout << (vectprod(up) * inv(vectprod(down))) % N << endl;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 10000 + 10;
string s;
int node[3][2] = {2, 5, 5, 0, 7, 5};
vector<int> vec[2];
int change(int p1, int p2) {
if (s.size() == 2) return 0;
int cnt = 0;
for (int i = 0; i < s.size(); i++) {
if (i == p1 || i == p2) continue;
if (s[i] == '0')
cnt++;
else
return cnt;
}
return INF;
}
int main() {
ios::sync_with_stdio(0);
cin >> s;
int len = s.size();
int minn = INF;
int lc1 = -1, lc2 = -1;
for (int i = len - 1; i >= 0 && lc2 == -1; i--) {
if (s[i] == '0') lc1 == -1 ? (lc1 = i) : (lc2 = i);
}
if (lc1 != -1 && lc2 != -1) minn = (len - 1 + len - 2) - (lc1 + lc2);
for (int i = 0; i < 3; i++) {
vec[0].clear();
vec[1].clear();
for (int j = 0; j < 2; j++) {
for (int k = len - 1; k >= 0; k--) {
if (s[k] - '0' == node[i][j]) {
vec[j].push_back(k);
}
}
}
for (int j = 0; j < vec[0].size(); j++) {
for (int k = 0; k < vec[1].size(); k++) {
int tmp = abs(len - 1 - vec[1][k]);
tmp += len - 2 - vec[0][j] + (vec[0][j] > vec[1][k] ? 1 : 0) +
change(vec[0][j], vec[1][k]);
minn = min(minn, tmp);
}
}
}
printf("%d\n", minn >= INF ? -1 : minn);
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
long long v1[N], v2[N];
long long inv[N];
long long inv2;
long long dp[N];
long long m, n;
const long long MOD = 1000000007;
long long fastpow(long long n, long long p) {
if (p == 0) return 1;
if (p % 2) return n * fastpow(n, p - 1) % MOD;
long long aux = fastpow(n, p / 2);
return aux * aux % MOD;
}
long long calc(long long i) {
auto &ret = dp[i];
if (ret != -1) return ret;
if (n == i) return ret = 0;
long long x1 = v1[i];
long long x2 = v2[i];
if (x1 && x2) {
if (x1 > x2) return ret = 1;
if (x1 < x2) return ret = 0;
if (x1 == x2) return ret = calc(i + 1) % MOD;
}
if (!x1 && !x2) {
return ret = (calc(i + 1) * m % MOD * inv2 % MOD +
(m * (m - 1) / 2) % MOD * inv2 % MOD) %
MOD;
}
if (!x1) {
return ret = ((m - x2) * inv[m] + 1 * inv[m] * calc(i + 1)) % MOD;
}
if (!x2) {
return ret = ((x1 - 1) * inv[m] + 1 * inv[m] * calc(i + 1)) % MOD;
}
}
int main() {
memset(dp, -1, sizeof dp);
for (long long i = 0; i < N; i++) inv[i] = fastpow(i, MOD - 2);
scanf("%lld %lld", &n, &m);
inv2 = fastpow(m * m % MOD, MOD - 2);
for (long long i = 0; i < n; i++) {
scanf("%lld", v1 + i);
}
for (long long i = 0; i < n; i++) {
scanf("%lld", v2 + i);
}
cout << calc(0) << endl;
return 0;
}
| 1,900 | CPP |
n = int(input())
a = input()
ff = {}
ff['z'] = 0
ff['e'] = 0
ff['r'] = 0
ff['o'] = 0
ff['n'] = 0
for i in a:
ff[i] += 1
if ff['o'] and ff['n'] and ff['e']:
min_ = min(ff['o'], ff['n'], ff['e'])
ff['o'] -= min_
ff['n'] -= min_
ff['e'] -= min_
zeros = min(ff['z'], ff['e'], ff['r'], ff['o'])
print(' '.join(['1'] * min_), ' '.join(['0'] * (0 if zeros < 1 else zeros)), sep=' ')
else:
zeros = min(ff['z'], ff['e'], ff['r'], ff['o'])
print(' '.join(['0'] * zeros)) | 800 | PYTHON3 |
n, m = map(int, input().split())
mat = [list(input().strip()) for i in range(n)]
left = -1
tmat = list(zip(*mat))
for i in range(m):
if '*' in tmat[i]:
left = i
break
for i in range(m - 1, -1, -1):
if '*' in tmat[i]:
right = i
break
for i in range(n):
if '*' in mat[i]:
top = i
break
for i in range(n - 1, -1, -1):
if '*' in mat[i]:
bottom = i
break
for i in range(top, bottom + 1):
ch = ''
for j in range(left, right + 1):
ch += mat[i][j]
print(ch)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int ARRLEN = 100;
int val[ARRLEN];
bool Cmp(int x, int y) { return x > y; }
int main() {
int n, k;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
scanf("%d", &val[i]);
}
sort(val, val + n, Cmp);
int len = 0, ind = 0;
while (k--) {
printf("%d", len + 1);
for (int i = 0; i < len; ++i) {
printf(" %d", val[i]);
}
printf(" %d\n", val[ind]);
ind++;
if (ind == n) {
len++;
ind = len;
}
}
return 0;
}
| 1,600 | CPP |
import sys
input=sys.stdin.readline
for i in range(int(input())):
r,b,d=map(int,input().split())
if (1+d)*min(r,b)>=max(r,b):
print("YES")
else:
print("NO")
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x;
int y;
int num;
int typ;
node(int a, int b, int c, int d) { x = a, y = b, num = c, typ = d; }
};
int a[100][100];
bool vis[11][11][111][11];
pair<int, int> dist[11][11][111][11];
int n;
int mv1[][2] = {{2, 1}, {1, 2}, {2, -1}, {-1, 2},
{1, -2}, {-1, -2}, {-2, -1}, {-2, 1}};
int mv2[][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int mv3[][2] = {{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
void bfs() {
queue<node> q;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == 1) {
q.push(node(i, j, 1, 0));
q.push(node(i, j, 1, 1));
q.push(node(i, j, 1, 2));
vis[i][j][1][0] = 1;
vis[i][j][1][1] = 1;
vis[i][j][1][2] = 1;
dist[i][j][1][0] = {0, 0};
dist[i][j][1][1] = {0, 0};
dist[i][j][1][2] = {0, 0};
}
}
}
while (!q.empty()) {
node v = q.front();
q.pop();
if (v.typ == 0) {
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 4; j++) {
int X = v.x + i * mv2[j][0];
int Y = v.y + i * mv2[j][1];
if (X < 0 || X >= n || Y < 0 || Y >= n) continue;
if (vis[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ]) {
if (dist[v.x][v.y][v.num][v.typ].first + 1 ==
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ].first) {
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ]
.second = min(
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ].second,
dist[v.x][v.y][v.num][v.typ].second);
}
continue;
}
vis[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ] = 1;
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ] =
dist[v.x][v.y][v.num][v.typ];
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ].first++;
q.push(node(X, Y, v.num + ((a[X][Y] == (v.num + 1))), v.typ));
}
}
} else if (v.typ == 1) {
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 4; j++) {
int X = v.x + i * mv3[j][0];
int Y = v.y + i * mv3[j][1];
if (X < 0 || X >= n || Y < 0 || Y >= n) continue;
if (vis[X][Y][v.num + (a[X][Y] == (v.num + 1))][v.typ]) {
if (dist[v.x][v.y][v.num][v.typ].first + 1 ==
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ].first) {
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ]
.second = min(
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ].second,
dist[v.x][v.y][v.num][v.typ].second);
}
continue;
}
vis[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ] = 1;
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ] =
dist[v.x][v.y][v.num][v.typ];
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ].first++;
q.push(node(X, Y, v.num + ((a[X][Y] == (v.num + 1))), v.typ));
}
}
} else {
for (int j = 0; j < 8; j++) {
int X = v.x + mv1[j][0];
int Y = v.y + mv1[j][1];
if (X < 0 || X >= n || Y < 0 || Y >= n) continue;
if (vis[X][Y][v.num + (a[X][Y] == (v.num + 1))][v.typ]) {
if (dist[v.x][v.y][v.num][v.typ].first + 1 ==
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ].first) {
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ].second = min(
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ].second,
dist[v.x][v.y][v.num][v.typ].second);
}
continue;
}
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ] =
dist[v.x][v.y][v.num][v.typ];
dist[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ].first++;
vis[X][Y][v.num + ((a[X][Y] == (v.num + 1)))][v.typ] = 1;
q.push(node(X, Y, v.num + ((a[X][Y] == (v.num + 1))), v.typ));
}
}
for (int i = 0; i <= 2; i++) {
if (i != v.typ) {
if (vis[v.x][v.y][v.num][i]) {
if (dist[v.x][v.y][v.num][v.typ].first + 1 ==
dist[v.x][v.y][v.num][i].first)
dist[v.x][v.y][v.num][i].second =
min(dist[v.x][v.y][v.num][i].second,
dist[v.x][v.y][v.num][v.typ].second + 1);
continue;
}
vis[v.x][v.y][v.num][i] = 1;
dist[v.x][v.y][v.num][i] = dist[v.x][v.y][v.num][v.typ];
dist[v.x][v.y][v.num][i].first++;
dist[v.x][v.y][v.num][i].second++;
q.push(node(v.x, v.y, v.num, i));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n * n; k++)
for (int x = 0; x < 3; x++) dist[i][j][k][x] = {1e9, 1e9};
bfs();
pair<int, int> ret = {1e9, 1e9};
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == n * n) {
ret = min(ret, dist[i][j][n * n][0]);
ret = min(ret, dist[i][j][n * n][1]);
ret = min(ret, dist[i][j][n * n][2]);
}
}
}
cout << ret.first << ' ' << ret.second << endl;
}
| 2,200 | CPP |
T=int(input())
II=0
while II<T:
#n=int(input())
s=input().split()
a=int(s[0])
b=int(s[1])
if a<b:
a,b=b,a
print(max(2*b,a)**2)
II+=1
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct _cert {
template <typename T>
_cert& operator<<(T) {
return *this;
}
};
_cert _cer;
template <typename T>
void dprint(T begin, T end) {
for (auto i = begin; i != end; i++) {
_cer << (*i) << " ";
}
_cer << "\n";
}
set<pair<long long, long long> > ss;
int q;
long long m;
int bd(pair<long long, long long> a, pair<long long, long long> b,
pair<long long, long long> c) {
b.first -= a.first;
b.second -= a.second;
c.first -= a.first;
c.second -= a.second;
return ((long double)b.first * (long double)c.second -
(long double)b.second * (long double)c.first) <= 0;
}
int main() {
scanf("%d%lld", &q, &m);
int ij = 0;
ss.insert(make_pair(0, 0));
for (int i = 0; i < q; ++i) {
int k, t, h;
long long x, y, a, b;
scanf("%d%d%d", &k, &t, &h);
if (k == 1) {
x = (t + ij) % 1000000 + 1;
y = (h + ij) % 1000000 + 1;
auto it = ss.lower_bound(make_pair(x, 0));
if (it != ss.end() && it->second <= y) continue;
auto it2 = prev(it);
if (it != ss.end() && bd(*it2, make_pair(x, y), *it)) continue;
it = ss.insert(make_pair(x, y)).first;
while (next(it) != ss.end() && next(it)->first == x) ss.erase(next(it));
while (prev(it) != ss.begin() && bd(*prev(prev(it)), *prev(it), *it))
ss.erase(prev(it));
} else {
b = (t + ij) % 1000000 + 1;
a = (h + ij) % 1000000 + 1;
auto it = ss.lower_bound(make_pair((a + b - 1) / b, 0));
int fl = 0;
if (it != ss.end()) {
if (it->second * b <= m)
fl = 1;
else {
auto it2 = prev(it);
if (bd(make_pair(it2->first * b, it2->second * b), make_pair(a, m),
make_pair(it->first * b, it->second * b)))
fl = 1;
}
}
if (fl) {
printf("YES\n");
ij = i + 1;
} else {
printf("NO\n");
}
}
}
return 0;
}
| 3,100 | CPP |
n = int(input())
arr = [int(x) for x in input().split()]
for i in range(n):
while arr[i]%2==0:
arr[i]/=2
while arr[i]%3==0:
arr[i]/=3
print("Yes" if all(arr[0]==arr[i] for i in range(n))else "No") | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, h;
long long md = 2e9;
bool judge(long long x) {
long long sum = 0;
if (x >= md) return true;
if (x <= h) {
sum = (x + 1) * x / 2;
} else {
sum += (x + x - h + 1) * h / 2;
x = x - h - 1;
if (sum >= n) return true;
if (x % 2 == 1) {
sum += (x + 1) * ((x + 1) / 2) / 2;
} else {
sum += (x + 0) * (x / 2 + 1) / 2;
}
}
if (sum >= n) {
return true;
} else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
while (cin >> n >> h) {
long long low = 1, high = n;
long long result = n;
while (low <= high) {
long long mid = (low + high) / 2;
if (judge(mid)) {
result = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
cout << result << endl;
}
return 0;
}
| 2,100 | CPP |
import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log2, ceil,pi,sin,cos,acos,atan
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from bisect import insort
from collections import Counter
from collections import deque
from heapq import heappush,heappop,heapify
from itertools import permutations,combinations
mod = int(1e9)+7
ip = lambda : int(stdin.readline())
inp = lambda: map(int,stdin.readline().split())
ips = lambda: stdin. readline().rstrip()
out = lambda x : stdout.write(str(x)+"\n")
t = ip()
for _ in range(t):
n,x = inp()
arr = list(inp())
arr2 = list(arr)
arr = [x-i for i in arr]
test = [0]*n
if arr == test:
ans = 0
else:
if sum(arr) == 0:
ans = 1
else:
flag = False
for i in arr2:
if i == x:
flag = True
if flag:
ans = 1
else:
ans = 2
out(ans)
| 1,500 | PYTHON3 |
k=list(map(int,input().split()))
s=list(map(int,input().split()))
li=[]
for i in s:
if k[1]+i<6:
li.append(i)
print(len(li)//3) | 800 | PYTHON3 |
x=input()
a=[]
result= 0
for i in range(int(x)):
newElement=input()
a.append(newElement)
for i in range(len(a)):
yes=0
no=0
for j in range(3):
z=a[i].split()
if int(z[j])==1:
yes+=1
else:
no+=1
if yes>no :
result+=1
print(result)
| 800 | PYTHON3 |
info = int(input())
data = []
for i in range(info):
data.append([info for info in input().split(' ')])
flag = 'NO'
for i in data:
if int(i[1]) < int(i[2]) and int(i[1]) >= 2400:
flag = 'YES'
print(flag)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
long long binpow(long long x, long long ind) {
if (!ind) return 1;
if (ind % 2) return (binpow(x, ind - 1) * x) % mod;
long long y = binpow(x, ind / 2);
return (y * y) % mod;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long place = m % n;
vector<long long> d(n + 1);
d[0] = 1;
d[1] = 1;
for (int j = 2; j <= n; ++j) {
vector<long long> e(n + 1);
e[0] = 1;
for (int i = 1; i <= min(k, n); ++i) e[i] = (d[i] + d[i - 1]) % mod;
d = e;
}
vector<vector<long long> > c(n + 1, vector<long long>(2));
for (int i = 0; i <= min(k, n); ++i) c[i][0] = binpow(d[i], m / n);
if (m % n)
for (int i = 0; i <= min(k, n); ++i) c[i][1] = (c[i][0] * d[i]) % mod;
vector<vector<long long> > dyn(n, vector<long long>(k + 1));
for (int i = 0; i <= min(k, n); ++i)
if (place)
dyn[0][i] = c[i][1];
else
dyn[0][i] = c[i][0];
for (long long i = 1; i < n; ++i) {
long long start = 0;
if (k - (n - i - 1) * n > 0) start = k - (n - i - 1) * n;
for (long long j = start; j <= min(k, (i + 1) * n); ++j)
for (long long u = 0; u <= min(k, n); ++u)
if (j >= u)
if (i >= place)
dyn[i][j] = (dyn[i][j] + dyn[i - 1][j - u] * c[u][0]) % mod;
else
dyn[i][j] = (dyn[i][j] + dyn[i - 1][j - u] * c[u][1]) % mod;
}
cout << dyn[n - 1][k];
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
template <class T>
inline void read(T& x, T& y) {
read(x);
read(y);
}
template <class T>
inline void read(T& x, T& y, T& z) {
read(x);
read(y);
read(z);
}
inline char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
int n, m, K, i, j, l, p;
long long best, res;
struct arr {
int a[110], b[110], c[110];
} a[11];
char s[11111];
pair<long long, long long> t[111];
long long calc(arr x, arr y) {
int i, j, g = 0, k = K;
for (i = 1; i <= m; i++)
if (x.a[i] < y.b[i] && x.c[i] > 0)
t[++g] = make_pair(y.b[i] - x.a[i], x.c[i]);
sort(t + 1, t + 1 + g);
reverse(t + 1, t + 1 + g);
long long ans = 0;
for (i = 1; i <= g; i++) {
if (k == 0) break;
k--;
ans += t[i].first;
if (--t[i].second == 0)
;
else
i--;
}
return ans;
}
int main() {
read(n, m, K);
for (i = 1; i <= n; i++) {
scanf("%s", s + 1);
for (j = 1; j <= m; j++) read(a[i].a[j], a[i].b[j], a[i].c[j]);
}
long long ans = 0;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++)
if (i != j) ans = max(ans, calc(a[i], a[j]));
cout << ans << endl;
return 0;
}
| 1,200 | CPP |
n = int(input())
a = list(map(int,input().split()))
dv = a.count(2)
od = n - dv
k = 0
if od >= dv:
k += dv
od -= dv
k += od // 3
else:
k += od
print(k) | 800 | PYTHON3 |
from math import tan,pi
for _ in range(int(input())):
n = int(input())
angle = pi/(2*n)
ans = 1/tan(angle)
print("{:.9f}".format(ans)) | 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 15;
const long long int inf = 1e18;
long long int dist(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return abs(a.first - b.first) + abs(a.second - b.second);
}
void solve() {
long long int ans = 1e18;
long long int n, x1, x2, y1, y2;
cin >> n >> x1 >> y1 >> x2 >> y2;
pair<long long int, long long int> start = {x1, y1};
pair<long long int, long long int> end = {x2, y2};
vector<long long int> a[N];
vector<pair<long long int, long long int> > v;
v.push_back({x1, y1});
v.push_back({0, 0});
v.push_back({n, 0});
v.push_back({0, n});
v.push_back({n, n});
v.push_back({x2, y2});
for (long long int i = 0; i < 6; i++) {
for (long long int j = 0; j < 6; j++) {
if (i == j) continue;
if ((v[i].first == v[j].first and (v[i].first == 0 or v[i].first == n))) {
a[i].push_back(j);
a[j].push_back(i);
} else if (v[i].second == v[j].second and
(v[i].second == 0 or v[i].second == n)) {
a[i].push_back(j);
a[j].push_back(i);
}
}
}
vector<long long int> dp(6, 1e18);
dp[0] = 0;
queue<long long int> q;
q.push(0);
while (!q.empty()) {
long long int u = q.front();
q.pop();
for (auto vv : a[u]) {
if (dp[vv] > dp[u] + dist(v[u], v[vv])) {
dp[vv] = dp[u] + dist(v[u], v[vv]);
q.push(vv);
}
}
}
cout << dp[5];
}
void debug(long long int tt) {}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long M = 1000000007;
long long power(long long a, long long b) {
long long res = 1;
while (b != 0) {
if (b & 1) {
res = (res * a) % M;
}
a = (a * a) % M;
b = b >> 1;
}
return res % M;
}
long long factorial(long long n) {
long long ans = 1;
for (long long i = 1; i <= n; i++) {
ans = (ans % M) * (i % M);
}
return ans % M;
}
long long ncr(long long n, long long r) {
long long fact_n = factorial(n);
long long fact_r = factorial(r);
long long fact_t = factorial(n - r);
long long inverse_r = power(fact_r, M - 2);
long long inverse_t = power(fact_t, M - 2);
long long ans = (((fact_n * inverse_r) % M) * inverse_t) % M;
return ans;
}
void solve() {
long long n, a, b, c, ans = 0, count = 0, sum = 0;
long long x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 > x2 || y1 > y2) {
cout << 0 << endl;
return;
}
long long f = abs(x1 - x2);
long long g = abs(y1 - y2);
n = f + g - 2;
long long r = g - 1;
cout << f * g + 1 << endl;
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
int a[N][N];
vector<int> x[N], y[N], xx[N], yy[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
x[i].push_back(a[i][j]);
y[j].push_back(a[i][j]);
}
}
for (int i = 1; i <= n; i++) {
sort(x[i].begin(), x[i].end());
xx[i].push_back(x[i][0]);
for (int j = 1; j < x[i].size(); j++) {
if (x[i][j] != x[i][j - 1]) xx[i].push_back(x[i][j]);
}
}
for (int i = 1; i <= m; i++) {
sort(y[i].begin(), y[i].end());
yy[i].push_back(y[i][0]);
for (int j = 1; j < y[i].size(); j++) {
if (y[i][j] != y[i][j - 1]) yy[i].push_back(y[i][j]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int valx =
upper_bound(xx[i].begin(), xx[i].end(), a[i][j]) - xx[i].begin();
int valy =
upper_bound(yy[j].begin(), yy[j].end(), a[i][j]) - yy[j].begin();
int val = max(valx, valy);
int lol = val + max(xx[i].size() - valx, yy[j].size() - valy);
cout << lol << " ";
}
cout << endl;
}
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000010;
char s[maxn];
int main() {
int i, j, is1 = 0, is2 = 0;
scanf("%s", s);
for (i = 0; s[i]; i++) {
if (s[i] == 'M')
is1 = 1;
else
is2 = 1;
}
if (is1 + is2 < 2)
puts("0");
else {
int ans = 0, p;
for (i = 0; s[i] == 'F'; i++)
;
j = i;
for (; s[i] == 'M'; i++)
;
if (!s[i]) {
puts("0");
return 0;
}
ans = i - j;
p = i;
j++;
for (i++; s[i]; i++)
if (s[i] == 'F') {
ans = max(i - j, ans + 1);
j++;
}
printf("%d\n", ans);
}
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 100000 + 10, MOD = 1000 * 1000 * 1000 + 7,
INF = 1000 * 1000 * 1000;
const long long LINF = (1ll) << 60;
const double EPS = 1e-9, PI = 2. * acos(0.0);
int board[11][11];
int n, m, k;
int colCnt[11];
int all_colors;
int ans;
int banCol[11][11][11];
int add(int a, int b) { return (a + b) % MOD; }
int mul(int a, int b) { return (a * 1ll * b) % MOD; }
void DFS(int x, int y) {
int next_x = x;
int next_y = y + 1;
if (x == n) {
int new_cols = -all_colors;
for (int i = 0; i < k; i++) {
if (colCnt[i] != 0) {
new_cols++;
}
}
int curAns = 1;
for (int i = k - all_colors; i > k - all_colors - new_cols; i--) {
curAns = mul(curAns, i);
}
ans = add(ans, curAns);
return;
}
if (next_y == m) {
next_x++;
next_y = 0;
}
if (board[x][y] != 0) {
DFS(next_x, next_y);
return;
}
bool newOne = true;
for (int i = 0; i < k; i++) {
if (banCol[x][y][i] == 0) {
if (colCnt[i] == 0) {
if (newOne) {
newOne = false;
} else {
continue;
}
}
colCnt[i]++;
for (int ii = x; ii < n; ii++) {
for (int jj = y; jj < m; jj++) {
banCol[ii][jj][i]++;
}
}
DFS(next_x, next_y);
colCnt[i]--;
for (int ii = x; ii < n; ii++) {
for (int jj = y; jj < m; jj++) {
banCol[ii][jj][i]--;
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
if (n + m - 1 > k) {
cout << 0 << "\n";
return 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> board[i][j];
if (board[i][j] != 0) {
if (banCol[i][j][board[i][j] - 1] != 0) {
cout << 0 << "\n";
return 0;
}
for (int ii = 0; ii < n; ii++) {
for (int jj = 0; jj < m; jj++) {
if (ii <= i && jj <= j || ii >= i && jj >= j) {
banCol[ii][jj][board[i][j] - 1]++;
}
}
}
colCnt[board[i][j] - 1]++;
}
}
}
for (int i = 0; i < k; i++) {
if (colCnt[i] != 0) {
all_colors++;
}
}
DFS(0, 0);
cout << ans << "\n";
return 0;
}
| 2,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const int INF = 1034567890;
const long long LL_INF = 1234567890123456789ll;
const double PI = acos(-1);
const long double ERR = 1E-10;
int main() {
int n, q;
cin >> n >> q;
set<pair<int, int>> cells;
int bad_nei{};
for (auto i{0}; i < q; i++) {
int row, col;
cin >> row >> col;
bool was_forbidden = cells.count({row, col});
for (auto r{row - 1}; r < row + 2; r++) {
for (auto c{col - 1}; c < col + 2; c++) {
if (r == row) continue;
if (!(1 <= r && r <= 2 && 1 <= c && c <= n)) {
continue;
}
if (cells.count({r, c})) {
if (was_forbidden)
bad_nei--;
else
bad_nei++;
}
}
}
if (cells.count({row, col}))
cells.erase({row, col});
else
cells.insert({row, col});
if (bad_nei >= 1)
puts("NO");
else
puts("YES");
}
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
string arr[100];
vector<int> a, b;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
a.clear();
b.clear();
string s;
cin >> s;
for (int i = 0; i < s.size(); ++i) {
int x = s[i] - '0';
if (x & 1)
a.push_back(x);
else
b.push_back(x);
}
string ans = "";
int i, j;
for (i = 0, j = 0; i < a.size() && j < b.size();) {
if (a[i] < b[j])
ans += '0' + a[i++];
else
ans += '0' + b[j++];
}
while (i < a.size()) ans += '0' + a[i++];
while (j < b.size()) ans += '0' + b[j++];
printf("%s\n", ans.c_str());
}
return 0;
}
| 1,600 | CPP |
n = int(input())
for i in range(n+1, 90000):
s = list(str(i))
temp = 0
for j in s:
if s.count(j) == 1:
temp += 1
continue
else:
break
if temp == len(str(i)):
print(i)
break | 800 | PYTHON3 |
n=int(input())
ans=0
tmp=0
for i in range(n):
a,b=[int(i) for i in input().split()]
tmp-=a
tmp+=b
ans=max(ans, tmp)
print(ans) | 800 | PYTHON3 |
def check(i, j, dj):
val = d[i][j]
while i < n:
if d[i][j] == val:
i+=1
j+=dj
j%=n
else:
break
if i == n:
return True
return False
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a.sort()
b.sort()
d = [[0 for i in range(n)] for i in range(n)]
for i in range(n):
for j in range(n):
d[i][j] = (b[j] - a[i])%m
ans = []
for x in range(n):
i, j = 0, x
if check(i, j, 1) or check(i, j, -1):
ans.append(d[i][j])
print(min(ans)) | 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int MOD[] = {1000000007, 998244353, 998244853};
template <int ITH>
struct modular {
constexpr modular() : val(0) {}
constexpr modular(const modular& _m) : val(_m.val) {}
template <typename U>
constexpr modular(const U& _r = U()) {
val = -MOD[ITH] <= _r && _r < MOD[ITH] ? _r : _r % MOD[ITH];
if (val < 0) {
val += MOD[ITH];
}
}
const int operator()() { return val; }
template <typename U>
explicit operator U() const {
return static_cast<U>(val);
}
modular& operator+=(const modular& _m) {
if ((val += _m.val) >= MOD[ITH]) {
val -= MOD[ITH];
}
return *this;
}
modular& operator-=(const modular& _m) {
if ((val -= _m.val) < 0) {
val += MOD[ITH];
}
return *this;
}
modular& operator*=(const modular& _m) {
val = modular(static_cast<int64_t>(val) * static_cast<int64_t>(_m.val)).val;
return *this;
}
modular& operator/=(const modular& _m) {
int a = _m.val, b = MOD[ITH], u = 0, v = 1;
while (a != 0) {
int q = b / a;
b -= q * a;
swap(a, b);
u -= q * v;
swap(u, v);
}
return *this *= u;
}
modular& operator=(const modular& _m) {
val = _m.val;
return *this;
}
template <typename U>
modular& operator+=(const U& _r) {
return *this += modular(_r);
}
template <typename U>
modular& operator-=(const U& _r) {
return *this -= modular(_r);
}
template <typename U>
modular& operator*=(const U& _r) {
return *this *= modular(_r);
}
template <typename U>
modular& operator/=(const U& _r) {
return *this /= modular(_r);
}
template <typename U>
modular& operator=(const U& _r) {
val = modular(_r).val;
return *this;
}
modular operator-() { return modular(-val); }
template <typename U>
friend bool operator==(const modular&, const modular&);
friend std::istream& operator>>(std::istream& os, modular& _m) {
os >> _m.val;
_m *= 1;
return os;
}
friend std::ostream& operator<<(std::ostream& os, const modular& _m) {
return os << _m.val;
}
template <typename U>
modular exp(U e) {
modular res = 1;
modular b = val;
if (e < 0) {
b = 1 / b;
e *= -1;
}
for (; e; e >>= 1) {
if (e & 1) {
res *= b;
}
b *= b;
}
return res;
}
private:
int val;
};
template <int ITH>
inline modular<ITH> operator+(const modular<ITH>& _lhs,
const modular<ITH>& _rhs) {
return modular<ITH>(_lhs) += _rhs;
}
template <int ITH, typename U>
inline modular<ITH> operator+(const modular<ITH>& _lhs, const U& _rhs) {
return modular<ITH>(_lhs) += _rhs;
}
template <int ITH, typename U>
inline modular<ITH> operator+(const U& _lhs, const modular<ITH>& _rhs) {
return modular<ITH>(_lhs) += _rhs;
}
template <int ITH>
inline modular<ITH> operator-(const modular<ITH>& _lhs,
const modular<ITH>& _rhs) {
return modular<ITH>(_lhs) -= _rhs;
}
template <int ITH, typename U>
inline modular<ITH> operator-(const modular<ITH>& _lhs, const U& _rhs) {
return modular<ITH>(_lhs) -= _rhs;
}
template <int ITH, typename U>
inline modular<ITH> operator-(const U& _lhs, const modular<ITH>& _rhs) {
return modular<ITH>(_lhs) -= _rhs;
}
template <int ITH>
inline modular<ITH> operator*(const modular<ITH>& _lhs,
const modular<ITH>& _rhs) {
return modular<ITH>(_lhs) *= _rhs;
}
template <int ITH, typename U>
inline modular<ITH> operator*(const modular<ITH>& _lhs, const U& _rhs) {
return modular<ITH>(_lhs) *= _rhs;
}
template <int ITH, typename U>
inline modular<ITH> operator*(const U& _lhs, const modular<ITH>& _rhs) {
return modular<ITH>(_lhs) *= _rhs;
}
template <int ITH>
inline modular<ITH> operator/(const modular<ITH>& _lhs,
const modular<ITH>& _rhs) {
return modular<ITH>(_lhs) /= _rhs;
}
template <int ITH, typename U>
inline modular<ITH> operator/(const modular<ITH>& _lhs, const U& _rhs) {
return modular<ITH>(_lhs) /= _rhs;
}
template <int ITH, typename U>
inline modular<ITH> operator/(const U& _lhs, const modular<ITH>& _rhs) {
return modular<ITH>(_lhs) /= _rhs;
}
template <int ITH>
inline bool operator==(const modular<ITH>& _lhs, const modular<ITH>& _rhs) {
return _lhs.val == _rhs.val;
}
template <int ITH, typename U>
inline bool operator==(const modular<ITH>& _lhs, const U& _rhs) {
return _lhs == modular<ITH>(_rhs);
}
template <int ITH, typename U>
inline bool operator==(const U& _lhs, const modular<ITH>& _rhs) {
return modular<ITH>(_lhs) == _rhs;
}
template <int ITH>
inline bool operator!=(const modular<ITH>& _lhs, const modular<ITH>& _rhs) {
return !(_lhs == _rhs);
}
template <int ITH, typename U>
inline bool operator!=(const modular<ITH>& _lhs, const U& _rhs) {
return !(_lhs == _rhs);
}
template <int ITH, typename U>
inline bool operator!=(const U& _lhs, const modular<ITH>& _rhs) {
return !(_lhs == _rhs);
}
vector<modular<0> > fall_table(int x, int n) {
vector<modular<0> > res(n + 1);
res[0] = 1;
for (int i = 1; i <= n; i++) {
res[i] = res[i - 1] * (x - i + 1);
}
return res;
}
vector<modular<0> > rise_table(int x, int n) {
vector<modular<0> > res(n + 1);
res[0] = 1;
for (int i = 1; i <= n; i++) {
res[i] = res[i - 1] * (x + i - 1);
}
return res;
}
const int N = 5022;
modular<0> dp[N][N];
modular<0> rec[2][N];
void solve() {
int n, m;
cin >> n >> m >> MOD[0];
dp[1][1] = 1;
for (int i = 1; i < N - 1; i++) {
for (int j = 1; j < N - 1; j++) {
dp[i + 1][j + 1] += dp[i][j];
dp[i + 1][j] += dp[i][j] * (j - 1);
}
}
auto fall = fall_table(m, N);
auto fac = rise_table(1, N);
rec[0][0] = 1;
modular<0> sum = 1;
int crt = 0;
for (int _ = 0, pre_len = 0; _ < n; _++) {
int len;
cin >> len;
int nxt = crt ^ 1;
for (int j = 1; j <= len; j++) {
rec[nxt][j] += sum * dp[len][j] * fall[j];
rec[nxt][j] -= rec[crt][j] * dp[len][j] * fac[j];
}
memset(rec[crt], 0, 4 * (pre_len + 1));
pre_len = len;
sum = 0;
for (int j = 1; j <= len; j++) {
sum += rec[nxt][j];
}
crt ^= 1;
}
cout << sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 2,600 | CPP |
l, b = map(int, input().split())
totalSquare = l * b
if totalSquare % 2 != 0:
totalSquare -= 1
ans = totalSquare / 2
print(round(ans)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 710;
int gcd(int x, int y) { return y == 0 ? x : gcd(y, x % y); }
int dp[MAXN][MAXN][2];
int ddiv[MAXN][MAXN];
void Run() {
int n;
cin >> n;
vector<int> a(n + 1);
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) ddiv[i][j] = gcd(a[i], a[j]);
for (int i = 1; i <= n + 1; ++i) dp[i][i - 1][0] = dp[i][i - 1][1] = 1;
for (int lft = n; lft >= 1; --lft) {
for (int rgt = lft; rgt <= n; ++rgt) {
for (int side = 0; side < 2; ++side) {
int v = (!side ? lft - 1 : rgt + 1);
for (int x = lft; x <= rgt; ++x) {
if (v <= 0 || v > n || ddiv[x][v] > 1) {
dp[lft][rgt][side] |= (dp[lft][x - 1][1] & dp[x + 1][rgt][0]);
}
}
}
}
}
cout << (dp[1][n][0] ? "Yes" : "No") << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
Run();
return 0;
}
| 2,100 | CPP |
for _ in range(int(input())):
c, s = map(int, input().split())
if s < c:
print(s)
else:
div = s//c
mod = s % c
ans = pow((div + 1), 2) * mod
ans += pow(div, 2) * (c-mod)
print(ans) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using i64 = long long;
void solve() {
int n, q;
std::cin >> n >> q;
std::string s;
std::cin >> s;
int sum[n + 1];
sum[0] = 0;
for (int i = 0; i < n; i++) {
sum[i + 1] = sum[i] + (s[i] == '+' ? 1 : -1) * (i % 2 == 0 ? 1 : -1);
}
std::vector<int> p[4 * n + 1];
for (int i = 0; i < n; i++) {
p[sum[i] + sum[i + 1] + 2 * n].push_back(i);
}
auto get = [&](int l, int r) {
int x = sum[l] + sum[r] + 2 * n;
auto it = std::lower_bound(p[x].begin(), p[x].end(), l);
assert(it != p[x].end() && *it < r);
return *it;
};
for (int i = 0; i < q; i++) {
int l, r;
std::cin >> l >> r;
l--;
if ((r - l) % 2 == 1) {
std::cout << "1\n";
std::cout << get(l, r) + 1 << "\n";
} else if (sum[l] == sum[r]) {
std::cout << "0\n";
} else {
std::cout << "2\n";
std::cout << l + 1 << " " << get(l + 1, r) + 1 << "\n";
}
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int t;
std::cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
char s[maxn], buf[maxn];
int main() {
while (scanf("%s", s) != EOF) {
int len = 0;
for (int i = 0; s[i]; i++) {
if (len != 0 && buf[len - 1] == s[i]) {
len--;
} else {
buf[len++] = s[i];
}
}
buf[len] = 0;
printf("%s\n", buf);
}
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 5;
const double Pi = acos(-1);
struct Complex {
double x, y;
Complex(double x = 0, double y = 0) : x(x), y(y){};
inline Complex operator+(const Complex b) const {
return Complex(x + b.x, y + b.y);
}
inline Complex operator-(const Complex b) const {
return Complex(x - b.x, y - b.y);
}
inline Complex operator*(const Complex b) const {
return Complex(x * b.x - y * b.y, x * b.y + y * b.x);
}
};
namespace FFT {
const double Pi = acos(-1);
const int N = 3e6 + 5;
Complex F[N], G[N];
int r[N];
void FFT(Complex *A, int limit, int type) {
for (int i = 0; i < limit; i++)
if (i < r[i]) swap(A[i], A[r[i]]);
for (int mid = 1; mid < limit; mid <<= 1) {
Complex Wn(cos(Pi / mid), type * sin(Pi / mid));
for (int R = mid << 1, j = 0; j < limit; j += R) {
Complex w(1, 0);
for (int k = 0; k < mid; k++, w = w * Wn) {
Complex x = A[j + k], y = w * A[j + mid + k];
A[j + k] = x + y;
A[j + mid + k] = x - y;
}
}
}
}
void mul(bool *a, bool *b, int &n, int &m) {
for (int i = 0; i <= n; i++) F[i].x = a[i];
for (int i = 0; i <= m; i++) G[i].x = b[i];
int l = 0;
int limit;
for (limit = 1; limit <= m + n; limit *= 2, l++)
;
for (int i = 0; i < limit; i++)
r[i] = (r[i >> 1] >> 1) | ((i & 1) << (l - 1));
FFT(F, limit, 1);
FFT(G, limit, 1);
for (int i = 0; i <= limit; i++) F[i] = F[i] * G[i];
FFT(F, limit, -1);
for (int i = 0; i <= n + m; i++) a[i] = (int)(F[i].x / limit + 0.5);
for (int i = 0; i <= limit; i++) F[i].y = G[i].y = F[i].x = G[i].x = 0;
}
} // namespace FFT
bool a[N], ans[N];
int n, m;
int ansn, an;
void ksm(int x) {
while (x) {
if (x & 1) {
FFT::mul(ans, a, ansn, an);
ansn += an;
}
FFT::mul(a, a, an, an);
an += an;
x >>= 1;
}
}
int main() {
int N, q;
scanf("%d%d", &N, &q);
for (int i = 1; i <= N; i++) {
int x;
scanf("%d", &x);
a[x] = 1;
ans[x] = 1;
ansn = max(ansn, x);
}
an = ansn;
ksm(--q);
for (int i = q + 1; i <= ansn + 5; i++) {
if (ans[i]) {
printf("%d ", i);
}
}
return 0;
}
| 2,400 | CPP |
n=int(input())
s=set(map(int,input().split()))
m=max(s)
p=0
for x in s:
d=1
while x+d<=m:
y=x+d
if y in s:
p=x,y
if y+d in s:
print(3)
print(x,y,y+d)
exit()
d*=2
if p:
print(2)
print(*p)
else:
print('1\n'+str(m)) | 1,800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int f[200005], in[200005], out[200005];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> f[i];
--f[i];
if (f[i] != -1) {
++out[i];
++in[f[i]];
}
}
vector<int> loops;
for (int i = 0; i < n; ++i) {
if (in[i] == 0 && out[i] == 0) {
loops.push_back(i);
}
}
if (loops.size() == 1) {
int idx = loops[0];
for (int i = 0; i < n; ++i) {
if (in[i] == 0 && i != idx) {
f[idx] = i;
++out[idx];
++in[i];
break;
}
}
} else if (loops.size() > 1) {
for (int i = 0; i < int(loops.size()); ++i) {
int cur = loops[i];
int nxt = loops[(i + 1) % int(loops.size())];
f[cur] = nxt;
++out[cur];
++in[nxt];
}
}
loops.clear();
vector<int> ins, outs;
for (int i = 0; i < n; ++i) {
if (in[i] == 0) ins.push_back(i);
if (out[i] == 0) outs.push_back(i);
}
assert(ins.size() == outs.size());
for (int i = 0; i < int(outs.size()); ++i) {
f[outs[i]] = ins[i];
}
for (int i = 0; i < n; ++i) {
cout << f[i] + 1 << " ";
}
cout << endl;
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)5e5 + 7, MOD = (int)1e9 + 7;
int n;
int a[N];
string c1 =
"31283130313031313031303131283130313031313031303131283130313031313031303131"
"2831303130313130313031";
string c2 =
"31283130313031313031303131293130313031313031303131283130313031313031303131"
"2831303130313130313031";
string c3 =
"31283130313031313031303131283130313031313031303131293130313031313031303131"
"2831303130313130313031";
string second;
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
string x = "";
cin >> x;
second += x;
}
if (c1.find(second) < 96) {
cout << "YES" << endl;
exit(0);
}
if (c2.find(second) < 96) {
cout << "YES" << endl;
exit(0);
}
if (c3.find(second) < 96) {
cout << "YES" << endl;
exit(0);
}
cout << "NO" << endl;
exit(0);
}
| 1,200 | CPP |
n = int(input())
l = []
a = list(map(int, input().split()))
l.append(a[0])
x = 0
for i in range(1,n):
if a[i] not in l:
l.append(a[i])
if max(l)==a[i] or min(l)==a[i]:
x+=1
print(x) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 321, MOD = 1e9 + 7;
int64_t dp[2][NMAX][NMAX];
int64_t tdp[2][NMAX][NMAX];
int main() {
ios::sync_with_stdio(false);
int n, m, x;
cin >> n >> m >> x;
if (n > m) {
cout << "0\n";
return 0;
}
dp[0][0][0] = tdp[0][0][0] = 1;
for (int i = 1, u = 1; i <= m; ++i, u ^= 1) {
for (int j = 0; j <= n; ++j) {
for (int k = 0; k <= n; ++k) {
dp[u][j][k] = dp[u ^ 1][j][k];
tdp[u][j][k] = tdp[u ^ 1][j][k];
}
}
for (int j = 0; j <= n; ++j) {
for (int k = 0; k <= n; ++k) {
if (j > 0) {
dp[u][j][k] += dp[u ^ 1][j - 1][k + 1];
tdp[u][j][k] += tdp[u ^ 1][j - 1][k + 1];
}
if (k > 0) {
if (i != x) {
dp[u][j][k] += dp[u ^ 1][j][k - 1];
}
tdp[u][j][k] += tdp[u ^ 1][j][k - 1];
}
if (j > 0) {
if (i != x) {
dp[u][j][k] += dp[u ^ 1][j - 1][k];
}
tdp[u][j][k] += tdp[u ^ 1][j - 1][k];
}
dp[u][j][k] %= MOD;
tdp[u][j][k] %= MOD;
}
}
}
int ans = (tdp[m & 1][n][0] - dp[m & 1][n][0]) % MOD;
for (int i = 1; i <= n; ++i) {
ans = (int64_t)ans * i % MOD;
}
if (ans < 0) ans += MOD;
cout << ans << '\n';
}
| 2,700 | CPP |
n=int(input())
i=0
while((2**i)<=n):
i+=1
print(i) | 1,300 | PYTHON3 |
a=input()
b=input()
if list(b)==list(reversed(a)):
print('YES')
else:
print('NO') | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, k, m;
map<string, int> f;
string s[N];
long long a[N], cost;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> m;
for (int i = 1; i <= n; i++) {
cin >> s[i];
f[s[i]] = i;
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= k; i++) {
int sz;
cin >> sz;
long long mini = 1e18;
vector<int> v(sz);
for (int j = 0; j < sz; j++) {
cin >> v[j];
mini = min(mini, a[v[j]]);
}
for (auto e : v) {
a[e] = mini;
}
}
for (int i = 1; i <= m; i++) {
string k;
cin >> k;
cost += a[f[k]];
}
cout << cost << "\n";
return 0;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, arr[100000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
while (arr[i] % 2 == 0) arr[i] /= 2;
while (arr[i] % 3 == 0) arr[i] /= 3;
}
for (int i = 0; i < n - 1; i++) {
if (arr[i] != arr[i + 1]) {
cout << "No";
return 0;
}
}
cout << "Yes";
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
vector<int> e[N];
int used[N];
void addedge(int u, int v) {
e[u].push_back(v);
e[v].push_back(u);
}
void dfs(int cur) {
if (cur == 0) used[cur] = 1;
for (int nxt : e[cur]) {
if (!used[nxt]) {
used[nxt] = 1;
dfs(nxt);
}
}
}
map<int, int> mp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int> > segs;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
segs.push_back(make_pair(l, r));
}
sort(segs.begin(), segs.end());
int cnt = 0;
for (int i = 0; i < n; i++) {
for (auto it = mp.lower_bound(-segs[i].second); it != mp.end(); it++) {
int val = -(it->first), idx = it->second;
if (val < segs[i].first) break;
cnt++;
if (cnt == n) {
cout << "NO\n";
return 0;
}
addedge(idx, i);
}
mp[-segs[i].second] = i;
}
if (cnt != n - 1) {
cout << "NO\n";
return 0;
}
dfs(0);
for (int i = 0; i < n; i++)
if (!used[i]) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100005;
int n, m, head[Maxn], cnt, maxi, ct[Maxn], dfn[Maxn], ans[Maxn], tot, vis[Maxn];
struct edg {
int nxt, to, w;
} edge[Maxn];
void add(int x, int y, int w) {
edge[++cnt] = (edg){head[x], y, w};
head[x] = cnt;
}
int lim;
bool dfs(int u, int id) {
vis[u] = -1;
for (int i = head[u]; i; i = edge[i].nxt) {
int to = edge[i].to;
if (edge[i].w <= lim) continue;
if (vis[to] != -1 && vis[to]) continue;
if (vis[to] == -1 || dfs(to, id)) return true;
}
vis[u] = id;
return false;
}
bool in[Maxn];
void work(int x) {
queue<int> Qu;
int c = 0;
for (int i = 1; i <= m; i++)
if (edge[i].w > lim) ct[edge[i].to]++;
for (int i = 1; i <= n; i++)
if (!ct[i]) Qu.push(i), in[i] = true;
while (!Qu.empty()) {
int u = Qu.front();
Qu.pop();
dfn[u] = ++c;
for (int i = head[u]; i; i = edge[i].nxt) {
int to = edge[i].to;
if (edge[i].w > lim) {
ct[to]--;
if (!ct[to] && !dfn[to] && !in[to]) in[to] = true, Qu.push(to);
}
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int x, y, w;
scanf("%d%d%d", &x, &y, &w);
add(x, y, w);
maxi = max(maxi, w);
}
int lt = 0, rt = maxi;
while (lt + 1 <= rt) {
int mid = (lt + rt) / 2;
lim = mid;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++)
if (!vis[i] && dfs(i, i)) {
lt = mid + 1;
goto A;
}
rt = mid;
A:;
}
lim = lt;
work(lt);
for (int u = 1; u <= n; u++)
for (int i = head[u]; i; i = edge[i].nxt) {
int to = edge[i].to;
if (edge[i].w <= lt)
if (dfn[to] < dfn[u]) ans[++tot] = i;
}
printf("%d %d\n", lt, tot);
for (int i = 1; i <= tot; i++) printf("%d ", ans[i]);
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
template <class T>
inline void read(T &res) {
res = 0;
bool bo = 0;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-')
bo = 1;
else
res = c - 48;
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + (c - 48);
if (bo) res = ~res + 1;
}
const int N = 1e6 + 5;
int n, top, stk[N];
long long h[N], cur, cnt, ans[N];
bool is[N];
int main() {
read(n);
for (int i = 1; i <= n; i++) read(h[i]);
cur = h[1];
for (int i = 2; i <= n; i++) {
cur = h[i] - (h[i - 1] - cnt);
cnt = 0;
while (top && cur > 1)
if (i - stk[top] + 1 <= cur)
cur -= i - stk[top] + 1, cnt += i - stk[top], top--;
else {
stk[top] += cur - 1;
cnt += cur - 1;
cur = 1;
break;
}
if (!top && (cnt += cur / i * (i - 1), cur %= i) > 1)
stk[++top] = cur, cnt += cur - 1, cur = 1;
if (!cur) stk[++top] = i;
}
for (int i = 1; i <= top; i++) is[stk[i]] = 1;
ans[n] = h[n] - cnt;
for (int i = n - 1; i >= 1; i--) ans[i] = ans[i + 1] - (!is[i + 1]);
for (int i = 1; i <= n; i++) printf("%lld ", ans[i]);
return puts(""), 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline void reads(string& x) {
char kk[((int)2e5 + 123)];
scanf("%s", kk);
x = kk;
}
long long ans, n, m, l, r, d;
vector<long long> sum[10];
void solve() {
scanf("%lld %lld", &n, &m);
if (m > n || m % 10 == 0) {
printf("0\n");
return;
}
l = m;
r = (n / m) * m;
d = (r - l) / m + 1;
m = m % 10;
ans = (d / (long long)sum[m].size()) * sum[m].back();
d = d % sum[m].size();
if (d) ans += sum[m][d - 1];
printf("%lld\n", ans);
}
int main() {
ios_base::sync_with_stdio(0);
for (int i = 1, tam; i < 10; i++) {
tam = 0;
for (int j = 1; j < 100; j++) {
if (j % i == 0) {
sum[i].emplace_back(j % 10);
if (tam) sum[i][tam] += sum[i][tam - 1];
tam++;
if (j % 10 == 0) break;
}
}
}
int t = 1;
scanf("%d", &t);
for (int caso = 1; caso <= t; caso++) {
solve();
}
}
| 1,200 | CPP |
s=input()
s=s.lower()
for c in s:
if(c not in {'a','e','i','o','u','y'}):
print('.'+c,end="") | 1,000 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
m = 0
ans = []
while n > 0:
rest = n % 10
if rest > 0:
ans.append(rest*10**m)
n -= rest
else:
n //= 10
m += 1
print(len(ans))
print(*ans) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void _dbg(char const* s, const T& t) {
cout << s << "=" << t << endl;
}
template <typename T, typename... TA>
void _dbg(char const* s, const T& t, const TA&... ta) {
while (*s != ',') cout << *s++;
cout << "=" << t << ",";
_dbg(s + 1, ta...);
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ",";
os << *it;
}
return os << "}";
}
template <typename T1, typename T2>
ostream& operator<<(ostream& os, const map<T1, T2>& mp) {
os << "{";
for (auto it = mp.begin(); it != mp.end(); ++it) {
if (it != mp.begin()) os << ",";
os << *it;
}
return os << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& s) {
os << "{";
for (auto it = s.begin(); it != s.end(); ++it) {
if (it != s.begin()) os << ",";
os << *it;
}
return os << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const multiset<T>& s) {
os << "{";
for (auto it = s.begin(); it != s.end(); ++it) {
if (it != s.begin()) os << ",";
os << *it;
}
return os << "}";
}
template <size_t N>
ostream& operator<<(ostream& os, const bitset<N>& bs) {
os << "{";
for (size_t i = 0; i < N; ++i) {
cout << bs[i];
}
return os << "}";
}
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<ld, ld>;
using namespace std;
struct S {
ll first;
ll second;
ll third;
};
void solve() {
string str;
cin >> str;
cout << '0' << " ";
if (str.size() == 1) return;
for (int i = 1; i < str.size() - 1; ++i)
if (str[i] != str[i + 1])
cout << '1' << " ";
else
cout << '0' << " ";
if (str.back() == 'b' && str.size() > 1)
cout << 0;
else
cout << '1';
}
int main() {
solve();
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int sad = 0;
int* visited;
vector<int>* adj;
void dfs(int curr, int prev) {
visited[curr] = 1;
for (auto& e : adj[curr]) {
if (e == prev) continue;
if (visited[e])
sad++;
else
dfs(e, curr);
}
}
int main() {
int n, k;
cin >> n >> k;
visited = new int[n];
memset(visited, 0, n * sizeof(int));
adj = new vector<int>[n];
unordered_set<string> chk;
int dups = 0;
for (int i = 0; i < k; i++) {
int a, b;
scanf("%d%d", &a, &b);
int tmp = min(a, b);
int tmp2 = max(a, b);
string key = to_string(tmp) + to_string(tmp2);
if (chk.count(key)) {
dups++;
continue;
}
chk.insert(key);
adj[a - 1].push_back(b - 1);
adj[b - 1].push_back(a - 1);
}
for (int i = 0; i < n; i++) {
if (visited[i]) continue;
dfs(i, -1337);
}
cout << sad / 2 + dups;
}
| 1,700 | CPP |
t = int(input())
while t>0:
n = int(input())
a = list(map(int,input().split()))
fin = False
ind = 0
for i in range(n):
if a[i]%2 == 0:
fin = True
ind=i
break
if fin:
print('1')
print(ind+1)
elif n>=2:
print('2')
print('1 2')
else:
print('-1')
t-=1
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
int s[100], r[100], h[100], c[100];
bool f[100];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i] >> r[i] >> h[i] >> c[i];
f[i] = 1;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if ((s[i] < s[j]) && (r[i] < r[j]) && (h[i] < h[j])) f[i] = 0;
int i1 = 0;
for (; f[i1] == 0; i1++)
;
for (int i = i1; i < n; i++)
if (f[i] && (c[i] < c[i1])) i1 = i;
cout << i1 + 1;
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long M = 1000000007;
int n, a, b;
long long w = 1;
int cel[200001];
long long ilm[200001];
int o[200001];
vector<int> s[200001];
void DFS(int v) {
o[v] = 1;
if (!o[cel[v]] && cel[v])
DFS(cel[v]);
else if (o[cel[v]] == 1 && cel[v] != v) {
w *= 2;
w %= M;
}
o[v] = 2;
}
void DFS2(int v) {
ilm[v] = 1;
for (int i = 0; i < s[v].size(); i++) DFS2(s[v][i]);
for (int i = 0; i < s[v].size(); i++) ilm[v] += ilm[s[v][i]];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a >> b;
cel[a] = b;
s[b].push_back(a);
}
for (int i = 1; i <= 2 * n; i++)
if (!o[i] && cel[i] && cel[i] != i) DFS(i);
for (int i = 1; i <= 2 * n; i++) {
if (s[i].size() && !cel[i]) {
DFS2(i);
w *= ilm[i];
w %= M;
}
}
cout << w;
return 0;
}
| 2,100 | CPP |
k2,k3,k5,k6=map(int,input().split())
min1=min(k2,k5,k6)
ans1=256*min1
k2=k2-min1
k5=k5-min1
k6=k6-min1
min2=min(k2,k3)
ans2=32*min2
print(ans1+ans2) | 800 | PYTHON3 |
n=int(input())
a=list(map(int,input().split()))
s=sum(a)
s=s/n
if s%1!=0:
print("0")
exit()
else:
l=[]
g=0
for i in range(n):
if a[i]==s:
g=g+1
l.append(i+1)
print(g)
for i in range(g):
print(l[i],end=" ")
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e2 + 7;
int n, a, b, cnt;
string s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> a >> b;
cin >> s;
for (int i = 0; i < n; i++) {
if (!a && !b) break;
if (s[i] == '.') {
if (a > b) {
if (s[i - 1] != 'A')
s[i] = 'A', a--;
else if (b && s[i - 1] != 'B')
s[i] = 'B', b--;
else
--cnt;
++cnt;
} else {
if (s[i - 1] != 'B')
s[i] = 'B', b--;
else if (a && s[i - 1] != 'A')
s[i] = 'A', a--;
else
--cnt;
++cnt;
}
}
}
cout << cnt;
}
| 1,300 | CPP |
a,b = map(int,input().split())
if b == 1 and a == 1:
print(1,0)
elif a == 1 and b != 1:
print(1,int((b-1)/2))
elif a != 1 and b == 1:
print(1,int((a-1)/2))
elif a > b:
c = b
d = int((a - b)/2)
print(c,d)
else:
c = a
d = int((b - a)/2)
print(c,d)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int MAXN = (int)1e6 + 10;
const int MOD = 998244353;
pair<ll, int> dp[MAXN][10];
void precalc() {
for (int n = 10; n < MAXN; n++) {
string s = to_string(n);
int big = *max_element(s.begin(), s.end()) - '0';
for (int d = 0; d < 10; d++) {
int best = max(big, d);
dp[n][d].first = 1 + dp[n - best][d].first;
dp[n][d].second = best + dp[n - best][d].second;
}
}
}
ll go(ll n) {
ll ans = 0;
if (n == 0) return 0;
while (n > MAXN) {
ll high = n;
int c = 0;
string s;
while (s.size() < 6) {
s += (high % 10) + '0';
high /= 10;
}
reverse(s.begin(), s.end());
ll low = stoll(s);
string S = to_string(high);
ll best = *max_element(S.begin(), S.end()) - '0';
if (!low) {
ans++;
n -= best;
continue;
}
int steps = dp[low][best].first;
ll nxt = n - dp[low][best].second;
ll nxt_step = max(nxt % 10, best);
ans += 1 + steps;
n = nxt - nxt_step;
}
ans += 1 + dp[n][0].first;
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
ll n;
cin >> n;
precalc();
cout << go(n) << '\n';
return 0;
}
| 2,400 | CPP |
for _ in range(int(input())):
a,b,c=map(int,input().split())
ans=[]
if(a<c):
ans.append(1)
else:
ans.append(-1)
if(b*a>c):
ans.append(b)
else:
ans.append(-1)
print(*ans) | 1,000 | PYTHON3 |
I=lambda:map(int,input().split())
n,c=I()
a,b=[],[]
for _ in range(n):x,y=I();a.append(x);b.append(y)
if max(a)==0:print([0,-1][n==c]);exit()
def f(x):
r=0
for i in range(n):
r+=1+a[i]*x//b[i]
if r>c:break
return r
l=-1
r=10**18
while l<r-1:
m=(l+r)//2
if f(m)<c:l=m
else:r=m
L=r
l=-1
r=10**18
while l<r-1:
m=(l+r)//2
if f(m)<=c:l=m
else:r=m
while f(r)>c:r-=1
if r<1:r=1
if L<1:L=1
if f(r)!=c:print(0)
else:print(r-L+1) | 1,900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int N = 1e6 + 5;
long long n, pw[N];
int t = 3;
void Solve() {
pw[n + 1] = 1;
for (long long i = n; i >= 3; i--) pw[i] = (pw[i + 1] * i) % mod;
long long res = 0;
res = (pw[3] * (n - 1)) % mod;
for (long long i = n - 2; i >= 1; i--) {
res = res + ((pw[t + 1] * (t - 1)) % mod * i) % mod;
t++;
}
cout << (res + 1) % mod << '\n';
}
int main() {
cin >> n;
Solve();
return 0;
}
| 1,700 | CPP |
a,b,c,d,e,f,g,h=map(int,input().split())
v1=int(b*c/g)
v2=d*e
v3=int(f/h)
a1=min(v1,v2,v3)
ans=int(a1/a)
print(ans) | 800 | PYTHON3 |
from collections import defaultdict
t = int(input())
for test in range(t):
s = input()
# n = len(s)
m = int(input())
b = list(map(int,input().split()))
count = defaultdict(int)
for i in s:
count[i] += 1
order = sorted(list(set(s)))
while b.count(0)!=0:
pos = []
req = b.count(0)
while count[order[-1]]<req:
order.pop()
for i in range(m):
if b[i]==0:
pos.append(i)
b[i] = order[-1]
order.pop()
for i in range(m):
if str(b[i]).isdigit():
for j in pos:
b[i] -= abs(i-j)
print("".join(b))
| 1,800 | PYTHON3 |
k2, k3, k5, k6 = map(int, input().split())
k5 = min(k5, k6)
if k2 >= k3 + k5:
print(k5 * 256 + k3 * 32)
elif k2 >= k5:
print(k5 * 256 + (k2 - k5) * 32)
else:
print(256 * k2)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5, mod = 1e9 + 7;
struct edge {
long long to, next;
} e[N << 1];
long long po[N] = {1}, vis[N], dfn[N];
long long tot, head[N], az, ans = 1, n, m, a;
inline void add(long long u, long long v) {
e[++tot] = (edge){v, head[u]};
head[u] = tot;
}
inline long long read() {
char c = getchar();
long long fh = 0;
while (!isdigit(c)) c = getchar();
while (isdigit(c)) fh = (fh << 1) + (fh << 3) + (c ^ 48), c = getchar();
return fh;
}
void dfs(long long u, long long d) {
dfn[u] = d;
vis[u] = 1;
for (long long i = head[u]; i; i = e[i].next) {
long long v = e[i].to;
if (!vis[v])
dfs(v, d + 1);
else if (vis[v] == 1)
az = dfn[u] - dfn[v] + 1, ans = (ans * (po[az] - 2 + mod)) % mod, m -= az;
}
vis[u] = 2;
}
signed main() {
n = m = read();
for (long long i = 1; i <= n; ++i) po[i] = (po[i - 1] << 1) % mod;
for (long long i = 1; i <= n; ++i) a = read(), add(i, a);
for (long long i = 1; i <= n; ++i)
if (!vis[i]) {
az = 0;
dfs(i, 0);
}
ans = (ans * po[m]) % mod;
cout << ans;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 300000 + 10;
long long a[N];
long long sum[N];
int last[N];
map<long long, int> Map;
map<long long, int> L;
map<long long, int> B;
int main() {
srand(time(0));
int n, i;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%I64d", &a[i]);
L[a[i]] = i;
Map[a[i]]++;
if (Map[a[i]] == 1) B[a[i]] = i;
}
sum[0] = 0;
for (i = 1; i <= n; ++i) sum[i] = sum[i - 1] + (a[i] >= 0 ? a[i] : 0);
long long ans = -0x1f1f1f1f1f1f1f1fLL;
pair<int, int> mark;
for (map<long long, int>::iterator e = Map.begin(); e != Map.end(); ++e)
if (e->second >= 2) {
long long tmp =
sum[L[e->first] - 1] - sum[B[e->first]] + 2 * a[L[e->first]];
if (tmp > ans) {
ans = tmp;
mark = make_pair(B[e->first], L[e->first]);
}
}
int cnt = 2;
for (i = mark.first + 1; i < mark.second; ++i)
if (a[i] >= 0) cnt++;
printf("%I64d %d\n", ans, n - cnt);
for (i = 1; i < mark.first; ++i) printf("%d ", i);
for (i = mark.first + 1; i < mark.second; ++i)
if (a[i] < 0) printf("%d ", i);
for (i = mark.second + 1; i <= n; ++i) printf("%d ", i);
puts("");
return 0;
}
| 1,500 | CPP |
t=int(input())
m=[]
for i in range(t):
n=int(input())
m.append([str(j) for j in range(1,n+1)])
if n>1:
m[i][1]=m[i][n-1]
m[i][n-1]='2'
for i in range(t):
print(' '.join(m[i])) | 800 | PYTHON3 |
read = lambda: [int(i) for i in input().split()]
t = int(input())
for _ in range(t):
x, y = read()
print('YES' if x - y > 1 else 'NO') | 900 | PYTHON3 |
t = int(input())
for i in range(t):
n = int(input())
a = list(map(int, input().split()))
l = list(map(int, input().split()))
s = []
out = [10**6] * n
for i in range(n):
if l[i]:
out[i] = a[i]
else:
s.append(a[i])
s.sort()
for i in range(n):
if out[i] == 10**6:
out[i] = s.pop()
print(' '.join(map(str,out)))
| 1,300 | PYTHON3 |
w=input()
w=list(w)
if w[0].islower():
w[0]=w[0].upper()
print(''.join(w)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main(void) {
int tt;
cin >> tt;
while (tt--) {
string str;
cin >> str;
int ls = str.length();
vector<int> f;
vector<int> c;
f.push_back(str[0] - '0');
c.push_back(1);
int sz = 1;
for (int i = 1; i < ls; i++)
if (str[i] == str[i - 1]) {
c[sz - 1]++;
} else {
f.push_back(str[i] - '0');
c.push_back(1);
sz++;
}
if (sz <= 2) {
cout << 0 << endl;
continue;
}
auto t0 = vector<int>(sz, 0);
auto t1 = vector<int>(sz, 0);
t0[0] = f[0] == 0 ? 0 : c[0];
t1[0] = f[0] == 1 ? 0 : c[0];
for (int i = 1; i < sz; i++) {
t0[i] = t0[i - 1] + (f[i] == 0 ? 0 : c[i]);
t1[i] = t1[i - 1] + (f[i] == 1 ? 0 : c[i]);
}
auto a0 = vector<int>(sz, 0);
auto a1 = vector<int>(sz, 0);
a0[sz - 1] = f[sz - 1] == 0 ? 0 : c[sz - 1];
a1[sz - 1] = f[sz - 1] == 1 ? 0 : c[sz - 1];
for (int i = sz - 2; i >= 0; i--) {
a0[i] = a0[i + 1] + (f[i] == 0 ? 0 : c[i]);
a1[i] = a1[i + 1] + (f[i] == 1 ? 0 : c[i]);
}
int min_t = min(t0[sz - 1], t1[sz - 1]);
for (int i = 0; i < sz; i++) {
int aa = t0[i] + (i + 1 < sz ? a1[i + 1] : 0);
int bb = t1[i] + (i + 1 < sz ? a0[i + 1] : 0);
min_t = min(min_t, min(aa, bb));
}
cout << min_t << endl;
}
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
static const int MAXN = 1e5 + 4;
int n, m, k, q;
int par[MAXN];
int taken[MAXN];
std::vector<int> ch[MAXN];
int start[MAXN], end[MAXN];
inline void dfs(int u) {
static int epoch = 0;
start[u] = epoch++;
for (std::vector<int>::iterator v = ch[u].begin(); v != ch[u].end(); ++v)
dfs(*v);
end[u] = epoch;
}
inline bool subtree_contains(int u, int v) {
return (start[v] >= start[u] && start[v] < end[u]);
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &q);
for (int i = 0; i < n; ++i) par[i] = -1;
for (int i = 0; i < m; ++i) taken[i] = -1;
int u, v;
for (int i = 0; i < k; ++i) {
scanf("%d%d", &u, &v);
--u, --v;
if (taken[v] != -1) {
par[u] = taken[v];
ch[taken[v]].push_back(u);
}
taken[v] = u;
}
for (int i = 0; i < n; ++i)
if (par[i] == -1) dfs(i);
for (int i = 0; i < q; ++i) {
scanf("%d%d", &u, &v);
--u, --v;
if (taken[v] == -1)
puts("0");
else {
if (subtree_contains(u, taken[v]))
printf("%d\n", end[u] - start[u]);
else
puts("0");
}
}
return 0;
}
| 2,700 | CPP |
# cook your dish here
def countDistinct(arr, n):
arrr=0
ar=[]
for elem in arr:
if elem not in ar:
arrr+=1
ar.append(elem)
return arrr
n=int(input())
x=[]
y=[]
for i in range(n):
a,b=map(int,input().split())
x.append(a)
y.append(b)
print(min(countDistinct(x,n),countDistinct(y,n))) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f3f;
const int maxn = 210;
int d[maxn][maxn], di[maxn][maxn];
int rk[maxn][maxn];
int main() {
int n, m, a, b, c;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
d[i][i] = 0;
di[i][i] = 0;
for (int j = i + 1; j <= n; j++) {
di[i][j] = di[j][i] = inf;
d[i][j] = d[j][i] = inf;
}
}
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &a, &b, &c);
d[a][b] = d[b][a] = c;
di[a][b] = di[b][a] = c;
}
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) rk[i][j] = j;
for (int j = 1; j <= n; j++) {
for (int k = j + 1; k <= n; k++) {
if (d[i][rk[i][j]] > d[i][rk[i][k]]) {
swap(rk[i][j], rk[i][k]);
}
}
}
}
int ans = inf;
for (int u = 1; u <= n; u++) {
for (int v = 1; v <= n; v++)
if (u != v) {
ans = min(ans, d[u][rk[u][n]] << 1);
ans = min(ans, d[v][rk[v][n]] << 1);
for (int cmp = n, i = n - 1; i >= 1; i--) {
if (d[v][rk[u][i]] > d[v][rk[u][cmp]]) {
ans = min(ans, d[u][rk[u][i]] + d[v][rk[u][cmp]] + di[u][v]);
cmp = i;
}
}
}
}
printf("%lf\n", (double)ans / 2);
return 0;
}
| 2,400 | CPP |
def solve(n):
# if n == 2:
# print("NO")
# return
if (n // 2) % 2 == 1:
print("NO")
return
else:
res = []
for i in range(0, n // 2):
res.append((i+1)*2)
for i in range(0, n // 2):
res.append((i + 1) * 2 - 1)
res[n - 1] = res[n - 1] + (n // 2)
print("YES")
print(" ".join(map(str, res)))
t = int(input())
for i in range(0, t):
n = int(input())
solve(n)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 70 + 5, M = 1e5 + 5;
const long long INF = 1e18 + 5;
inline long long read() {
long long sum = 0, fh = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fh = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
sum = sum * 10 + c - '0';
c = getchar();
}
return sum * fh;
}
inline int read2() {
char c = getchar();
while (c < '0' || c > '9') {
c = getchar();
}
return c - '0';
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline int gcd(int x, int y) { return y == 0 ? x : gcd(y, x % y); }
inline long long ab(long long x) { return x < 0 ? -x : x; }
inline long long fpow(long long qwe, long long asd, long long zxc) {
long long a = qwe, b = 1, c = asd;
while (c) {
if (c & 1) b = b * a % zxc;
a = a * a % zxc;
c >>= 1;
}
return b;
}
struct miaow {
int f, t, c, l;
miaow(int f = 0, int t = 0, int c = 0, int l = 0) : f(f), t(t), c(c), l(l) {}
} imap[N * 2 + 5];
int str[N * 2 + 5] = {0}, cou = 1;
inline void jb(int f, int t, int c) {
imap[cou] = miaow(f, t, c, str[f]);
str[f] = cou++;
imap[cou] = miaow(t, f, c, str[t]);
str[t] = cou++;
}
int dp[N][N][N];
int main() {
int n = read(), m = read(), m2 = m / 2, k = read();
for (int a = 0; a <= m2; ++a) {
for (int b = 0; b < k; ++b) {
dp[1][a][b] = -1e9;
}
}
dp[1][0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
int x = read();
int x2 = x / k, x3 = x % k;
for (int a = 0; a <= m2; ++a) {
for (int b = 0; b < k; ++b) {
dp[j + 1][a][b] = dp[j][a][b];
}
}
for (int a = 0; a < m2; ++a) {
for (int b = 0; b < k; ++b) {
dp[j + 1][a + 1][(b + x3) % k] =
max(dp[j + 1][a + 1][(b + x3) % k],
dp[j][a][b] + x2 + ((b + x3) >= k ? 1 : 0));
}
}
}
for (int a = 0; a <= m2; ++a) {
for (int b = 0; b < k; ++b) {
dp[1][a][b] = -1e9;
}
}
for (int a = 0; a <= m2; ++a) {
for (int b = 0; b < k; ++b) {
dp[1][0][b] = max(dp[1][0][b], dp[m + 1][a][b]);
}
}
}
cout << dp[1][0][0] * k << endl;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool comp(const pair<long long, long long>& i,
const pair<long long, long long>& j);
int main() {
int n, i, j;
long long x, a, sum;
vector<pair<long long, long long> > neg, pos;
while (cin >> n) {
for (i = 0; i < n; i++) {
cin >> x >> a;
if (x > 0)
pos.push_back(pair<long long, long long>(x, a));
else
neg.push_back(pair<long long, long long>(x * (-1), a));
}
sort(pos.begin(), pos.end(), comp);
sort(neg.begin(), neg.end(), comp);
i = pos.size();
j = neg.size();
sum = 0;
int c = 0;
while (c < min(i, j)) {
sum += pos[c].second;
sum += neg[c].second;
c++;
}
if (i > j)
sum += pos[c].second;
else if (j > i)
sum += neg[c].second;
cout << sum << endl;
pos.clear();
neg.clear();
}
return 0;
}
bool comp(const pair<long long, long long>& i,
const pair<long long, long long>& j) {
return i.first < j.first;
}
| 1,100 | CPP |
# problem link : https://codeforces.com/problemset/problem/231/A
no_problem = int(input())
no_sol = 0
while no_problem != 0:
x,y,z = map(int,input().split())
if x==y==1 or y==z==1 or z==x==1:
no_sol +=1
no_problem -= 1
print(no_sol)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long su, id;
} a[1000003];
long long n, x, y, vis[1000003], ans, fa[1000003], fv, siz[1000003];
vector<long long> l[1000003];
long long cmp(node nx, node ny) { return nx.su < ny.su; }
long long find(long long x1) {
while (fa[x1] != x1) fa[x1] = fa[fa[x1]], x1 = fa[x1];
return x1;
}
void f(long long x1, long long sum) {
for (long long j = 0; j < l[x1].size(); j++) {
fv = find(l[x1][j]);
if (vis[fv] == 0) continue;
ans += siz[fv] * siz[x1] * sum, siz[x1] += siz[fv], fa[fv] = x1;
}
}
signed main() {
scanf("%d", &n);
for (long long i = 1; i <= n; i++) {
a[i].id = i, fa[i] = i, siz[i] = 1;
scanf("%d", &a[i].su);
}
for (long long i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
l[x].push_back(y), l[y].push_back(x);
}
sort(a + 1, a + n + 1, cmp);
for (long long i = 1; i <= n; i++) {
f(a[i].id, a[i].su);
vis[a[i].id] = 1, a[i].su *= -1;
}
for (long long i = 1; i <= n; i++) fa[i] = i, siz[i] = 1, vis[i] = 0;
for (long long i = n; i >= 1; i--) {
f(a[i].id, a[i].su);
vis[a[i].id] = 1;
}
cout << ans;
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int A[n];
int max = 0;
int min = 0;
int x = 0;
for (int i = 0; i < n; i++) {
cin >> A[i];
if (A[i] < A[min]) min = i;
if (A[i] > A[max]) max = i;
}
for (int i = 0; i < n; i++) {
if (A[i] < A[max] && A[i] > A[min]) x++;
}
cout << x << endl;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
int x[maxn];
vector<int> R, J;
int main() {
int n, m, s, d;
while (~scanf("%d%d%d%d", &n, &m, &s, &d)) {
for (int i = 0; i < n; i++) scanf("%d", &x[i]);
if (n == 0) {
printf("RUN %d\n", m);
continue;
}
sort(x, x + n);
R.clear();
J.clear();
if (x[0] - 1 < s)
printf("IMPOSSIBLE\n");
else {
R.push_back(x[0] - 1);
bool pos = true;
int j;
for (int i = 0; i < n && pos; i = j + 1) {
bool ok = false;
for (j = i; j < n; j++) {
if (x[j] + 1 - (x[i] - 1) > d) break;
if (j == n - 1) {
ok = true;
J.push_back(x[j] + 1 - (x[i] - 1));
if (x[j] + 1 < m) R.push_back(m - (x[j] + 1));
break;
} else if (x[j + 1] - 1 - (x[j] + 1) >= s) {
ok = true;
J.push_back(x[j] + 1 - (x[i] - 1));
R.push_back(x[j + 1] - 1 - (x[j] + 1));
break;
}
}
if (!ok) {
pos = false;
break;
}
}
if (!pos)
printf("IMPOSSIBLE\n");
else {
for (int i = 0; i < J.size(); i++)
printf("RUN %d\nJUMP %d\n", R[i], J[i]);
if (R.size() > J.size()) printf("RUN %d\n", R.back());
}
}
}
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
struct ura {
int x, y, z;
};
bool operator<(ura a, ura b) {
if (a.z != b.z)
return (a.z < b.z);
else if (a.x != b.x)
return (a.x < b.x);
else
return (a.y < b.y);
}
using namespace std;
int i, j, d, k, q, c, e, f, a, b, n, t, arr3[200066][3];
ura arr[200066], arr2[200066];
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d", &a, &b);
arr[i].x = a;
arr[i].y = b;
arr[i].z = (b - a);
}
for (i = 0; i < n; i++) {
scanf("%d", &t);
arr2[i].x = i;
arr2[i].z = t;
}
sort(arr, arr + n);
sort(arr2, arr2 + n);
for (i = 0; i < n; i++)
if (arr[i].z != arr2[i].z) f = 1;
if (f == 1)
printf("NO");
else {
f = 0;
for (i = 0; i < n; i++) {
arr3[arr2[i].x][0] = arr[i].x;
arr3[arr2[i].x][1] = arr[i].y;
}
for (i = 0; i < n; i++) {
if (i > 0)
if (arr3[i][0] <= arr3[i - 1][0] && arr3[i][1] <= arr3[i - 1][1]) f = 1;
}
if (!f) {
printf("YES\n");
for (i = 0; i < n; i++) printf("%d %d\n", arr3[i][0], arr3[i][1]);
} else
printf("NO");
}
}
| 1,700 | CPP |
ones = "1111111"
zeros = "0000000"
m = input()
if ones in m or zeros in m:
print('YES')
else:
print('NO') | 900 | PYTHON3 |
for _ in range(int(input())):
n=int(input())
a=list(map(int,input().split()))
a1=[]
a2=[]
for i in range(0,n-1,2):
a1.append(a[i+1]-a[i])
for i in range(1,n-1,2):
a2.append(a[i]-a[i+1])
ans=0
tot=0
for i in range(len(a1)):
tot+=a1[i]
if tot<0:
tot=0
ans=max(ans,tot)
tot=0
for i in range(len(a2)):
tot+=a2[i]
if tot < 0:
tot = 0
ans=max(ans,tot)
tot=0
for i in range(0,n,2):
tot+=a[i]
print(tot+ans) | 1,600 | PYTHON3 |
t=int(input())
for i in range(t):
s=list(input())
l=len(s)
ans=""
flag=-1
ans=''.join(s)
if ans[::-1]!=ans:
print(ans)
continue
if l%2==0:
for j in range(1,l):
if s[j]!=s[j-1]:
flag=0
tm=s[j]
s[j]=s[j-1]
s[j-1]=tm
break
else:
tmp=s[l//2]
for j in range(1,l):
if s[j]!=s[j-1] and j!=l//2 and j!=l//2+1:
flag=0
tm=s[j]
s[j]=s[j-1]
s[j-1]=tm
break
elif s[j]!=tmp and j!=l//2:
s[l//2]=s[j]
s[j]=tmp
break
ans=''.join(s)
if ans[::-1]!=ans:
print(ans)
else:
print(-1)
| 900 | PYTHON3 |
a=list(map(int,input().split()))
b=[]
c=[]
s=a[0]
for i in range(a[1]):
l,m=input().split()
b.append(int(l))
c.append(int(m))
count=a[1]
for i in range(a[1]):
if s<=min(b):
print('NO')
break
else:
d=b.index(min(b))
s+=c[d]
del b[d]
del c[d]
count-=1
if count==0:
print('YES')
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ii = pair<long long int, long long int>;
class prioritize {
public:
bool operator()(ii &p1, ii &p2) { return p1.first < p2.first; }
};
bool checker(long long int x, long long int n, long long int s) {
if (x <= s - n)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
long long int arr[n];
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
long long int p1 = 0, p2 = 0, cnt = 0;
while (p1 < n && p2 < n) {
if (arr[p1] == arr[p2]) {
p2++;
continue;
}
if (arr[p2] > arr[p1]) {
cnt++;
p1++;
p2++;
} else
p2++;
}
cout << cnt << "\n";
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, m, a, pos = 1;
long long int s = 0;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> a;
if (a >= pos)
s += 1ll * (a - pos);
else
s += 1ll * (n + a - pos);
pos = a;
}
cout << s << endl;
return 0;
}
| 1,000 | CPP |
a = list(map(int, input().split(' ')))
best = 0
for i in range(len(a)):
c = a[i]
aa = a.copy()
aa[i] = 0
p = int(c/14)
m = c % 14
aaa = [aa[j] + p for j in range(14)]
for j in range(m):
aaa[(i + j + 1) % 14] += 1
sum = 0
for j in range(14):
if(aaa[j]%2 == 0):
sum += aaa[j]
if sum > best:
best = sum
print(best) | 1,100 | PYTHON3 |
import math,sys,bisect,heapq
from collections import defaultdict,Counter,deque
from itertools import groupby,accumulate
#sys.setrecursionlimit(200000000)
int1 = lambda x: int(x) - 1
#def input(): return sys.stdin.readline().strip()
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda: map(int,input().split())
alele = lambda: list(map(int, input().split()))
ilelec = lambda: map(int1,input().split())
alelec = lambda: list(map(int1, input().split()))
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
#MOD = 1000000000 + 7
def Y(c): print(["NO","YES"][c])
def y(c): print(["no","yes"][c])
def Yy(c): print(["No","Yes"][c])
n,p = ilele()
if p == 0:
print(0)
exit(0)
G = defaultdict(list)
P= defaultdict(set)
def addEdge(a,b,c):
G[a].append(b)
G[b].append(a)
P[a].add(c)
P[b].add(c)
vis = [False]*(n+1)
def dfs(node):
Ans = []
vis[node] = True
s = deque()
mini = 1e9
s.append(node)
while s:
x = s.pop()
Ans.append(x)
if P[x]:
mini = min(mini,min(P[x]))
for i in G.get(x,[]):
if not vis[i]:
s.append(i)
vis[i] = True
return Ans,mini
tap = set()
tank = set()
for i in range(p):
a,b,c = ilele()
addEdge(a,b,c)
tap.add(b)
tank.add(a)
#print(tank,tap,G)
Ans2 = []
for i in range(1,n+1):
if not vis[i]:
Ans,mini = dfs(i)
t1 = t2 = None
for j in Ans:
x = j in tap
y = j in tank
if x^y:
if x:
t1 = j
else:
t2 = j
if t1 and t2 and mini != None:
Ans2.append((t2,t1,mini))
print(len(Ans2))
Ans2.sort()
if Ans2:
for i,j,k in Ans2:
print(i,j,k)
| 1,400 | PYTHON3 |
inp=input
li=list
iinp=lambda : int(inp())
ent=lambda : map(int,inp().split())
lient=lambda : [int(i) for i in inp().split()]
li0= lambda x: [0 for i in range(x)]
stent=lambda : [i for i in inp()]
s,v1,v2,t1,t2=ent()
primero=s*v1+t1*2
segundo=s*v2+t2*2
if primero<segundo: print("First")
elif segundo<primero:print("Second")
else: print("Friendship") | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 107;
const int MX = 1e9 + 7;
const long long int INF = 1e18 + 9LL;
int n;
int res;
int val[N];
int cnt[N];
bitset<N> dp[N][N * N];
void countDp(vector<int> &cur, int v, int cntv) {
int m = v * cntv;
for (int i = 1; i <= (int)cur.size(); ++i)
for (int j = 0; j <= m; ++j) dp[i][j].reset();
dp[0][0][0] = true;
for (int i = 0; i < (int)cur.size(); ++i) {
for (int j = 0; j + cur[i] <= m; ++j)
dp[i + 1][j + cur[i]] |= (dp[i][j] << 1);
for (int j = 0; j <= m; ++j) dp[i + 1][j] |= dp[i][j];
}
for (int i = 1; i <= cntv; ++i)
if (!dp[cur.size()][i * v][i])
res = max(res, i);
else
break;
}
int main() {
scanf("%d", &n);
int diff = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &val[i]);
cnt[val[i]]++;
if (cnt[val[i]] == 1) ++diff;
}
if (diff <= 2) {
printf("%d\n", n);
return 0;
}
for (int i = 1; i <= 100; ++i) {
if (cnt[i] == 0) continue;
vector<int> t;
for (int j = 1; j <= n; ++j)
if (val[j] != i) t.push_back(val[j]);
countDp(t, i, cnt[i]);
}
printf("%d\n", res);
return 0;
}
| 2,100 | CPP |
import random
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
a.sort(reverse = True)
print(*a)
| 1,000 | PYTHON3 |
n = int(input())
l = list(map(int,input()))
ans = 0
for i in range(n):
if l[i]%2==0:
ans += i + 1
print(ans) | 800 | PYTHON3 |
t=int(input())
for i in range(t):
n=int(input())
s=input()
b=[]
for j in s:
b.append(j)
j=0
f=0
ans=0
while(j<n):
if b[j]=="-" or b[(j+1)%n]=="-":
ans+=1
j+=1
if b.count(">")==0 or b.count("<")==0:
print(n)
else:
print(ans)
| 1,200 | PYTHON3 |
n=int(input())
s=input()
i=0
ans=0
lst=[]
while i<n:
cnt=0
while i<n and s[i]=="B":
cnt+=1
i+=1
if cnt>0:
lst.append(cnt)
ans+=1
i-=1
i+=1
print(ans)
for num in lst:
print(num,end=" ")
| 800 | PYTHON3 |
Subsets and Splits