solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
const int MAX = 1e6 + 10;
char S[MAX];
char L[MAX];
char R[MAX];
int main() {
scanf("%s", S);
int n = strlen(S);
int left = 0, right = n - 1;
int t = 0;
while (true) {
if (left + 1 >= right - 1) break;
if (S[left] == S[right]) {
L[t] = S[left];
R[t] = S[right];
}
if (S[left] == S[right - 1]) {
L[t] = S[left];
R[t] = S[right - 1];
}
if (S[left + 1] == S[right]) {
L[t] = S[left + 1];
R[t] = S[right];
}
if (S[left + 1] == S[right - 1]) {
L[t] = S[left + 1];
R[t] = S[right - 1];
}
t++;
left += 2;
right -= 2;
}
if (left <= right) {
L[t] = S[left];
for (int i = 0; i < t + 1; i++) {
printf("%c", L[i]);
}
for (int i = t - 1; i >= 0; i--) {
printf("%c", R[i]);
}
} else {
for (int i = 0; i < t; i++) {
printf("%c", L[i]);
}
for (int i = t - 1; i >= 0; i--) {
printf("%c", R[i]);
}
}
printf("\n");
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (!a) return b;
return gcd(b % a, a);
}
long long power(long long x, long long n) {
if (x == 0) return 0;
if (n == 0) return 1;
if (n == 1) return x;
long long res = power(x, n / 2);
res = (res * res) % 1000000007;
if (n % 2) return (res * x) % 1000000007;
return res;
}
long long nCr(long long n, long long r) {
if (r == 0) return 1;
vector<long long> f(n + 1);
f[0] = 1;
for (long long i = 1; i <= n; i++) f[i] = (f[i - 1] * i) % 1000000007;
return ((f[n] * power(f[r], 1000000007 - 2)) % 1000000007 *
power(f[n - r], 1000000007 - 2)) %
1000000007;
}
const long long MAX = 1000001;
long long factor[MAX] = {0};
void gen_Prime_Fac() {
factor[1] = 1;
for (long long i = 2; i < MAX; i++) factor[i] = i;
for (long long i = 4; i < MAX; i += 2) factor[i] = 2;
for (long long i = 3; i * i < MAX; i++) {
if (factor[i] == i) {
for (long long j = i * i; j < MAX; j += i) {
if (factor[j] == j) factor[j] = i;
}
}
}
}
long long no_of_fac(long long n) {
if (n == 1) return 1;
long long ans = 1;
long long dup = factor[n];
long long c = 1;
long long j = n / factor[n];
while (j != 1) {
if (factor[j] == dup)
c += 1;
else {
dup = factor[j];
ans = ans * (c + 1);
c = 1;
}
j /= factor[j];
}
ans *= (c + 1);
return ans;
}
long long fact(long long n) {
if (n == 1) return 1;
return n * fact(n - 1);
}
bool is_pow_2(long long n) {
long long i = 1;
while (i < n) {
i *= 2;
}
return i == n;
}
class DSU {
public:
vector<long long> parent;
vector<long long> comp;
DSU(long long n) {
parent.resize(n + 1);
comp.resize(n + 1);
for (long long i = 1; i <= n; i++) {
parent[i] = comp[i] = i;
}
}
void join(long long a, long long b) {
long long pa = find(a), pb = find(b);
comp[pa] = max(comp[pa], comp[pb]);
parent[pb] = pa;
}
long long find(long long a) {
return a == parent[a] ? a : parent[a] = find(parent[a]);
}
bool check(long long a, long long b) { return find(a) == find(b); }
};
int32_t main() {
long long n;
cin >> n;
long long ans = 0;
cout << fact(n - 1) / (n / 2);
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m, a[N], b[N];
pair<long long, long long> ans(-1, -1);
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 0; i < n; cin >> a[i++])
;
cin >> m;
for (int i = 0; i < m; cin >> b[i++])
;
sort(a, a + n);
sort(b, b + m);
a[n] = 2e9;
for (int i = 0; i <= n; i++) {
if (i && a[i] == a[i - 1]) continue;
int low = 0, high = m - 1, mid, loc = -1;
while (low <= high) {
mid = (low + high) / 2;
if (b[mid] < a[i])
loc = mid, low = mid + 1;
else
high = mid - 1;
}
long long sa = 2 * (i) + 3 * (n - i);
long long sb = 2 * (loc + 1) + 3 * (m - loc - 1);
if (sa - sb > ans.first - ans.second ||
sa - sb == ans.first - ans.second && sa > ans.first || ans.first == -1)
ans = {sa, sb};
}
cout << ans.first << ":" << ans.second << '\n';
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MX_SZ = 105;
struct request {
int type;
int r;
int x, y, val;
request(int type0, int r0) {
type = type0;
r = r0;
}
request(int type0, int x0, int y0, int val0) {
type = type0;
x = x0;
y = y0;
val = val0;
}
};
int main() {
ios_base::sync_with_stdio(false);
int n, m, q;
cin >> n >> m >> q;
int a[MX_SZ][MX_SZ];
memset(a, 0, sizeof(a));
vector<request> v;
for (int i = 0; i < q; i++) {
int type;
cin >> type;
if (type != 3) {
int r;
cin >> r;
v.push_back(request(type, r));
} else {
int x, y, val;
cin >> x >> y >> val;
v.push_back(request(type, x, y, val));
}
}
reverse(v.begin(), v.end());
int tmp[MX_SZ];
for (int i = 0; i < q; i++) {
if (v[i].type == 1) {
for (int j = 1; j <= m; j++) {
if (j == m) {
tmp[1] = a[v[i].r][j];
} else {
tmp[j + 1] = a[v[i].r][j];
}
}
for (int j = 1; j <= m; j++) {
a[v[i].r][j] = tmp[j];
}
}
if (v[i].type == 2) {
for (int j = 1; j <= n; j++) {
if (j == n) {
tmp[1] = a[j][v[i].r];
} else {
tmp[j + 1] = a[j][v[i].r];
}
}
for (int j = 1; j <= n; j++) {
a[j][v[i].r] = tmp[j];
}
}
if (v[i].type == 3) {
a[v[i].x][v[i].y] = v[i].val;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << a[i][j] << " ";
}
cout << '\n';
}
}
| 1,400 | CPP |
#include <bits/stdc++.h>
int n, vis[1005], dis[1005], flag = 0;
std::vector<int> a[1005], b[1005];
void add(int x, int y, long long v) {
a[x].push_back(y);
b[x].push_back(v);
}
void spfa(int s) {
std::queue<int> q;
for (int i = 0; i <= n; i++) vis[i] = 0, dis[i] = -1000000000;
dis[s] = 0;
vis[s] = 1;
q.push(s);
while (!q.empty()) {
int v = q.front();
q.pop();
vis[v] = 0;
for (int i = 0; i < a[v].size(); i++) {
int u = a[v][i], s = b[v][i];
if (dis[u] < dis[v] + s) {
dis[u] = dis[v] + s;
if (!vis[u]) q.push(u), vis[u] = 1;
}
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
char ch = ' ';
while (ch != 'R' && ch != 'L' && ch != '=') ch = getchar();
if (ch == 'L') add(i + 1, i, 1);
if (ch == 'R') add(i, i + 1, 1);
if (ch == '=') add(i + 1, i, 0), add(i, i + 1, 0);
}
for (int i = 1; i <= n; i++) add(0, i, 1);
spfa(0);
for (int i = 1; i <= n; i++) printf("%d ", dis[i]);
printf("\n");
return 0;
}
| 1,800 | CPP |
t = int(input())
for it in range(t):
a0, a1, a2 = [int(i) for i in input().split()]
b0, b1, b2 = [int(i) for i in input().split()]
ans = min(a2, b1)
a2 -= ans
b1 -= ans
ans *= 2
b2 -= a2 + a0
print(ans - 2 * max(0, b2))
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 201005;
long long aib[2][maxn];
int n, m, a[maxn], uniq;
map<long long, int> ind;
map<int, long long> rev;
struct input {
int op, p, x;
long long v;
};
inline int lsb(int x) { return x & (-x); }
inline void update(int type, int node, int value) {
for (int i = node; i <= uniq; i += lsb(i)) aib[type][i] += value;
}
inline long long query(int type, int node) {
long long sum = 0;
for (int i = node; i > 0; i -= lsb(i)) sum += aib[type][i];
return sum;
}
vector<input> q;
inline long long check(int d) {
long long t = query(1, d - 1);
long long v1 = t * rev[d] - query(0, d - 1);
return v1;
}
inline int getans(long long v) {
int st = 1, dr = uniq, ans = uniq;
while (st <= dr) {
int mid = ((st + dr) >> 1);
if (check(mid) >= v) {
ans = mid;
dr = mid - 1;
} else
st = mid + 1;
}
return ans;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
ind[a[i]];
}
for (int i = 1; i <= m; ++i) {
input act;
cin >> act.op;
if (act.op == 1) {
cin >> act.p >> act.x;
ind[act.x];
} else
cin >> act.v;
q.push_back(act);
}
for (map<long long, int>::iterator it = ind.begin(); it != ind.end(); ++it) {
ind[it->first] = ++uniq;
rev[uniq] = it->first;
}
for (int i = 1; i <= n; ++i) {
update(0, ind[a[i]], a[i]);
update(1, ind[a[i]], 1);
}
for (vector<input>::iterator it = q.begin(); it != q.end(); ++it) {
input act = *it;
if (act.op == 1) {
int i = act.p;
update(0, ind[a[i]], -a[i]);
update(1, ind[a[i]], -1);
a[i] = act.x;
update(0, ind[a[i]], a[i]);
update(1, ind[a[i]], 1);
} else {
int ans = getans(act.v);
long long t = query(1, ans - 1);
long long v1 = rev[ans] * t - query(0, ans - 1);
if (v1 >= act.v && t)
cout << ((long double)rev[ans] - (long double)(v1 - act.v) / t) << '\n';
else
cout << (long double)(rev[ans] + (long double)(act.v - v1) / n) << '\n';
}
}
}
| 2,200 | CPP |
import sys
def main():
t = sys.stdin.readline().split()
n = int(t[0])
h = int(t[1])
k = int(t[2])
line = sys.stdin.readline()
x = list(map(int,line.split()))
res = 0
cur = 0
for i in range(n):
cur += x[i]
if i!=n-1:
if x[i+1]+cur <= h:
continue
v = int(cur/k)
if v*k != cur :
cur = cur - v*k
res+= v
if i!=n-1:
if x[i+1]+cur > h:
res+=1
cur=0
else:
res+=1
else :
cur =0
res +=v
print(res)
main() | 1,400 | PYTHON3 |
a, b = [int(i) for i in input().split()]
ans = 0
while a <= b:
a *= 3
b *= 2
ans += 1
print(ans) | 800 | PYTHON3 |
a = int(input())
for i in range(a):
L, v, l, r = map(int, input().split())
temp = L // v - (r - (l - 1) // v * v) // v
print(temp) | 1,100 | PYTHON3 |
n,k = map(int, input().split())
a = list(map(int, input().split()))
ans = list()
cnt = 0
while cnt < k:
i = a.index(max(a))
j = a.index(min(a))
if i == j:
break
ans.append((i+1, j+1))
a[i] -= 1
a[j] += 1
cnt += 1
stability = max(a) - min(a)
print(stability, cnt)
for i,j in ans:
print(i,j) | 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool Fill(int a, int b, int x, bool print) {
vector<int> in_a, in_b;
for (; x > 0; x--) {
if (x <= a) {
a -= x;
if (print) {
in_a.push_back(x);
}
continue;
}
if (x <= b) {
b -= x;
if (print) {
in_b.push_back(x);
}
continue;
}
return false;
}
if (print) {
cout << in_a.size() << "\n";
for (int i = 0; i < in_a.size(); i++) {
cout << in_a[i] << " ";
}
cout << "\n";
cout << in_b.size() << "\n";
for (int i = 0; i < in_b.size(); i++) {
cout << in_b[i] << " ";
}
cout << "\n";
}
return true;
}
int main() {
int a, b;
cin >> a >> b;
int start = 0, end = 100000, mid;
while (start + 1 < end) {
mid = (start + end) / 2;
if (Fill(a, b, mid, false)) {
start = mid;
} else {
end = mid - 1;
}
}
if (Fill(a, b, end, false)) {
Fill(a, b, end, true);
} else {
Fill(a, b, start, true);
}
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int T, n, m, k;
int pr[23333], fl[23333], top;
const long long lim = 1000000000000000000ll;
int main() {
ios_base::sync_with_stdio(false);
for (int i = 2; i <= 10000; i++) {
if (!fl[i]) pr[++top] = i;
for (int j = i + i; j <= 10000; j += i) fl[j] = 1;
}
cin >> T;
while (T--) {
int qcnt = 0, cur = 1, last = 1, ans = 1;
int zz = 0;
while (qcnt <= 20) {
long long tmp = 1, gg;
while ((__int128)tmp * pr[cur] <= lim) tmp *= pr[cur], cur++;
qcnt++;
cout << "? " << tmp << endl;
cin >> gg;
for (int i = last; i < cur; i++) {
if (gg % pr[i] == 0) {
if (!zz)
zz = pr[i];
else if (qcnt <= 20) {
long long xx = 1, yy = 1, ggg;
while (xx * zz <= 1e9) xx *= zz;
while (yy * pr[i] <= 1e9) yy *= pr[i];
qcnt++;
cout << "? " << xx * yy << endl;
cin >> ggg;
int cnt = 1;
while (ggg % zz == 0) ggg /= zz, cnt++;
ans *= cnt;
cnt = 1;
while (ggg % pr[i] == 0) ggg /= pr[i], cnt++;
ans *= cnt;
zz = 0;
} else
ans *= 2;
}
}
last = cur;
}
if (zz) {
long long xx = 1, ggg;
while (xx * zz <= 1e9) xx *= zz;
qcnt++;
cout << "? " << xx << endl;
cin >> ggg;
int cnt = 1;
while (ggg % zz == 0) ggg /= zz, cnt++;
ans *= cnt;
}
cout << "! " << max(ans * 2, ans + 7) << endl;
}
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return a % b ? gcd(b, a % b) : b; }
const long long mod = 998244353;
const long long inf = 1e18;
long long qpow(long long a, long long b) {
long long t = 1;
while (b != 0) {
if (b & 1) t = (t * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return t;
}
template <typename T>
void re(T& a) {
for (auto& t : a) cin >> t;
}
template <typename T>
void pr(T& a) {
for (auto& t : a) cout << t << " ";
cout << endl;
}
const int N = 5e5 + 5;
long long a[N];
long long dp[N];
long long pd[N];
int n;
void add(long long& x, long long y) { x = ((x + y) % mod + mod) % mod; }
void solve() {
cin >> n;
for (int i = 0; i <= n; ++i) {
dp[i] = 0;
pd[i] = 0;
}
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
long long x = a[i];
long long tmp = dp[x];
if (x == 0) {
add(tmp, 1);
} else {
add(tmp, dp[x - 1]);
}
add(dp[x], tmp);
x += 2;
add(pd[x], pd[x]);
x -= 2;
if (x == 0) {
continue;
}
tmp = pd[x];
if (x == 1) {
add(tmp, 1);
} else {
add(tmp, dp[x - 2]);
}
add(pd[x], tmp);
}
long long ans = 0;
for (int i = 0; i <= n; ++i) {
add(ans, dp[i]);
add(ans, pd[i]);
}
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int query_no[1200000], MX = 999999999, x[300100];
int query(int node, int it, int f, int q);
void update(int node, int it, int f, int q1, int q2, int id);
void insert(int node, int it, int f);
int main() {
int n, m, i, l, r, id;
scanf("%d%d", &n, &m);
insert(1, 1, n);
for (i = 1; i <= m; i++) {
scanf("%d%d%d", &l, &r, &x[i]);
if (x[i] - 1 >= l) update(1, 1, n, l, x[i] - 1, i);
if (x[i] + 1 <= r) update(1, 1, n, x[i] + 1, r, i);
}
update(1, 1, n, x[m], x[m], 0);
for (i = 1; i <= n; i++) {
id = query(1, 1, n, i);
printf("%d", x[id]);
if (i < n) printf(" ");
}
printf("\n");
return 0;
}
void insert(int node, int it, int f) {
query_no[node] = MX;
if (it == f) return;
insert(2 * node, it, (it + f) / 2);
insert(2 * node + 1, (it + f) / 2 + 1, f);
}
void update(int node, int it, int f, int q1, int q2, int id) {
if (it == q1 && f == q2) {
query_no[node] = min(id, query_no[node]);
return;
}
int m = (it + f) / 2;
if (q2 <= m)
update(2 * node, it, m, q1, q2, id);
else if (q1 > m)
update(2 * node + 1, m + 1, f, q1, q2, id);
else {
update(2 * node, it, m, q1, m, id);
update(2 * node + 1, m + 1, f, m + 1, q2, id);
}
}
int query(int node, int it, int f, int q) {
if (it == f) return query_no[node];
int m = (it + f) / 2;
if (q <= m)
return min(query_no[node], query(2 * node, it, m, q));
else
return min(query_no[node], query(2 * node + 1, m + 1, f, q));
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
bool possible = true;
cin >> n >> m;
int matrix[n][m];
int sumMatrix = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> matrix[i][j];
sumMatrix += matrix[i][j];
}
}
int i = n - 1;
while (possible && i >= 0) {
for (int j = m - 1; j >= 0; j--) {
if (matrix[i][j] == 0) {
matrix[i][j] = min(matrix[i + 1][j], matrix[i][j + 1]) - 1;
sumMatrix += matrix[i][j];
}
}
i--;
}
i = 0;
while (possible && i < n) {
for (int j = 0; j < m; j++) {
if (i > 0 && j > 0) {
if (matrix[i][j] <= max(matrix[i - 1][j], matrix[i][j - 1])) {
possible = false;
break;
}
} else if (i == 0 && j != 0) {
if (matrix[i][j] <= matrix[i][j - 1]) {
possible = false;
break;
}
} else if (j == 0 && i != 0) {
if (matrix[i][j] <= matrix[i - 1][j]) {
possible = false;
break;
}
}
}
i++;
}
if (possible) {
cout << sumMatrix << endl;
} else {
cout << -1 << endl;
}
}
| 1,100 | CPP |
n=int(input())
k=n//2
print(3*k) | 900 | PYTHON3 |
# your code goes here
n,c = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
stairs,lift = 0,c
print(0,end=' ')
for i in range(n-1):
stairs = min(stairs+a[i],lift+b[i])
lift = min(stairs+c,lift+b[i])
print(min(stairs,lift),end=' ') | 1,700 | PYTHON3 |
t=int(input())
for _ in range(t):
n=int(input())
s=list(map(int,input().split()))
s.sort()
ans=1e8
for i in range(1,n):
ans=min(ans,s[i]-s[i-1])
print(ans) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
constexpr int INF = 1e9 + 7;
constexpr long long INFL = 1e18;
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
constexpr int maxn = 1005;
vector<pair<int, int>> P, Q;
vector<pair<int, int>> pkt, pom;
map<pair<int, int>, int> M;
vector<int> G[maxn];
int vis[maxn], skoj[maxn * 2], lp = 1;
bool mark[maxn * 2];
int fu[maxn], best[maxn];
int fin(int a) { return fu[a] == a ? a : fu[a] = fin(fu[a]); }
bool intersect(pair<int, int> a, pair<int, int> b) {
auto a1 = pom[a.first], a2 = pom[a.second];
auto b1 = pom[b.first], b2 = pom[b.second];
assert(a1.second < a2.second and b1.first < b2.first);
if (a1.second < b1.second and b1.second < a2.second and
b1.first < a1.first and a1.first < b2.first)
return true;
return false;
}
bool dfs(int a) {
vis[a] = lp;
for (auto v : G[a]) {
if (skoj[v] == -1 or (vis[skoj[v]] != lp and dfs(skoj[v]))) {
skoj[a] = v;
skoj[v] = a;
return true;
}
}
return false;
}
void dfs_mark(int a) {
if (a == -1) return;
if (mark[a]) return;
mark[a] = true;
for (auto v : G[a]) {
if (not mark[v] and skoj[v] != a) {
mark[v] = true;
dfs_mark(skoj[v]);
}
}
}
void solve() {
int n = P.size(), m = Q.size();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (intersect(P[i], Q[j])) {
G[i].push_back(j + n);
}
}
}
fill(skoj, skoj + n + m + 1, -1);
for (int i = 0; i < n; i++) {
if (not dfs(i)) {
lp++;
dfs(i);
}
}
for (int i = 0; i < n; i++) {
if (skoj[i] != -1 or mark[i]) continue;
dfs_mark(i);
}
vector<pair<int, int>> pr, qr;
for (int i = 0; i < n; i++)
if (mark[i]) pr.emplace_back(P[i]);
for (int j = 0; j < m; j++)
if (not mark[j + n]) qr.emplace_back(Q[j]);
P = pr, Q = qr;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
pkt.emplace_back(x, y);
M[{x, y}] = i;
}
pom = pkt;
sort((pkt).begin(), (pkt).end());
for (int i = 0; i < n;) {
int j = i;
while (j < n and pkt[j].first == pkt[i].first) j++;
for (int k = i; k + 1 < j; k++) P.emplace_back(M[pkt[k]], M[pkt[k + 1]]);
i = j;
}
sort((pkt).begin(), (pkt).end(), [](pair<int, int> a, pair<int, int> b) {
return make_pair(a.second, a.first) < make_pair(b.second, b.first);
});
for (int i = 0; i < n;) {
int j = i;
while (j < n and pkt[j].second == pkt[i].second) j++;
for (int k = i; k + 1 < j; k++) Q.emplace_back(M[pkt[k]], M[pkt[k + 1]]);
i = j;
}
solve();
cout << n - (int)(Q).size() << endl;
iota(fu, fu + n + 1, 0);
for (auto p : Q) {
auto a = fin(p.first), b = fin(p.second);
fu[b] = a;
}
for (int i = 0; i < n; i++) best[fin(i)] = max(best[fin(i)], pom[i].first);
for (int i = 0; i < n; i++)
if (fu[i] == i)
cout << pom[i].first << " " << pom[i].second << " " << best[i] << " "
<< pom[i].second << "\n";
cout << n - (int)(P).size() << endl;
iota(fu, fu + n + 1, 0);
for (auto p : P) {
auto a = fin(p.first), b = fin(p.second);
fu[b] = a;
}
fill(best, best + n + 1, 0);
for (int i = 0; i < n; i++) best[fin(i)] = max(best[fin(i)], pom[i].second);
for (int i = 0; i < n; i++)
if (fu[i] == i)
cout << pom[i].first << " " << pom[i].second << " " << pom[i].first << " "
<< best[i] << "\n";
}
| 2,700 | CPP |
def solve(n):
if n%2==0:
a = n-4
else:
a = n-9
b = n-a
return str(a)+' '+str(b)
if __name__ == '__main__':
n = int(input())
print(solve(n))
| 800 | PYTHON3 |
#!/usr/bin/env python3.9
for _ in range(int(input())):
s = input()
idx = 0
if not s.startswith('11'):
idx = s.find('011')
if idx == -1:
print('YES')
continue
idx = s.find('100', idx)
if idx == -1:
print('YES')
continue
print('NO') | 1,000 | PYTHON3 |
def sol():
n = int(input())
if n % 4 != 0 :
return '==='
S = input()
if '?' not in S :
if len(set(S)) == 4:
return S
else:
return '==='
tmp , tmpn = 'AGCT' , n//4
l = [S.count(i) for i in tmp]
if tmpn < max(l):
return '==='
S = S.replace("?","A",tmpn-l[0])
S = S.replace('?','G' , tmpn-l[1] )
S = S.replace('?','C' , tmpn-l[2] )
S = S.replace('?','T' , tmpn-l[-1] )
return S
print(sol()) | 900 | PYTHON3 |
"""
Oh, Grantors of Dark Disgrace,
Do Not Wake Me Again.
"""
ii = lambda: int(input())
n = ii()
if n%2==0 and n!=2: print("YES")
else: print("NO") | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long t[400000];
long long a[1 << 17];
void build_segment_tree(long long v, long long tl, long long tr, bool op) {
if (tl == tr) {
t[v] = a[tl];
return;
}
long long tm = tl + (tr - tl) / 2;
build_segment_tree(2 * v, tl, tm, !op);
build_segment_tree(2 * v + 1, tm + 1, tr, !op);
if (op)
t[v] = t[2 * v] | t[2 * v + 1];
else
t[v] = t[2 * v] ^ t[2 * v + 1];
}
void update_lazy_propagation(long long v, long long tl, long long tr,
long long pos, long long val, bool op) {
if (tl == tr) {
t[v] = val;
return;
}
long long tm = tl + (tr - tl) / 2;
if (pos <= tm)
update_lazy_propagation(2 * v, tl, tm, pos, val, !op);
else
update_lazy_propagation(2 * v + 1, tm + 1, tr, pos, val, !op);
if (op)
t[v] = t[2 * v] | t[2 * v + 1];
else
t[v] = t[2 * v] ^ t[2 * v + 1];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, q;
cin >> n >> q;
long long size = 1 << n;
for (long long i = 0; i < size; i++) cin >> a[i];
build_segment_tree(1, 0, size - 1, n & 1);
while (q--) {
long long pos, val;
cin >> pos >> val;
pos--;
update_lazy_propagation(1, 0, size - 1, pos, val, n & 1);
cout << t[1] << '\n';
}
}
| 1,700 | CPP |
s = input()
t = input()
list1 = []
list2 = []
list_1 = []
list_2 = []
list_2_2 = []
for j in range(len(t)):
indices = [i for i, x in enumerate(s) if x == t[j]]
list1.append(indices)
for j in range(len(t)):
indices = [i for i, x in enumerate(s) if x == t[j]]
list_2_2.append(indices)
for j in range(len(t)):
indices = [i for i, x in enumerate(s) if x == t[j]]
list_1.append(indices)
for j in range(len(t)):
indices = [i for i, x in enumerate(s) if x == t[j]]
list_2.append(indices)
for j in range(len(t)):
indices = [i for i, x in enumerate(s) if x == t[j]]
list2.append(indices)
m = 0
for i in range(len(list1)-1):
a = list_1[i][0]
b = list1[i+1]
for j in b:
if j>a:break
list_1[i+1].remove(j)
for i in range(len(list2) - 1 , 0 , -1):
a = list_2[i][len(list_2[i]) - 1]
b = list2[i-1]
for j in range(len(b) - 1 , -1 , -1):
if b[j] < a:break
list_2[i-1].remove(b[j])
for i in range(len(list2) - 1 , 0 , -1):
a = list_2_2[i][len(list_2_2[i]) - 1]
b = list2[i-1]
for j in range(len(b) - 1 , -1 , -1):
if b[j] < a:break
list_2_2[i-1].remove(b[j])
for i in range(len(list_2)-1):
a = list_2_2[i][0]
b = list_2[i+1]
for j in b:
if j>a:break
list_2_2[i+1].remove(j)
for i in range(len(list_2_2) - 1):
if list_2_2[i+1][len(list_2_2[i+1]) - 1] - list_2_2[i][0] - 1 > m: m = list_2_2[i+1][len(list_2_2[i+1]) - 1] - list_2_2[i][0] - 1
print(max(m, list_2_2[0][len(list_2_2[0]) - 1], len(s) - 1 - list_2_2[len(list_2_2) - 1][0])) | 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
pair<long long, long long> points[1000];
bool vis[100010];
int n;
long long dr[4] = {0, 1, 0, -1};
long long dc[4] = {1, 0, -1, 0};
int mp[5] = {2, 3, 0, 1, 4};
bool can = 1;
void DFS(int i, long long r, long long c, long long dis, int pre) {
if (vis[i]) return;
points[i] = make_pair(r, c);
vis[i] = 1;
int si = g[i].size();
if (si > 4) {
can = 0;
return;
}
int idx = 0;
for (int j = 0; j < si; j++) {
if (vis[g[i][j]]) continue;
if (idx == mp[pre]) idx++;
long long nr = r + dr[idx] * dis;
long long nc = c + dc[idx] * dis;
DFS(g[i][j], nr, nc, dis / 2, idx);
idx++;
}
}
int main() {
cin >> n;
g.resize(n + 10);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
DFS(1, 0, 0, 5e17, 4);
if (can) {
puts("YES");
for (int i = 1; i <= n; i++) {
cout << points[i].first << " " << points[i].second << endl;
}
} else
puts("NO");
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
string s;
cin >> s;
while (t--) {
for (int i = 1; i < s.size(); i++) {
if (s[i] == 'G' && s[i - 1] == 'B') {
swap(s[i], s[i - 1]);
i++;
}
}
}
cout << s;
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a = 0, b;
cin >> n;
b = n;
bool result = false;
for (int i = 1; i <= n + 1 / 2; i++) {
a += i;
if (a == b) {
result = true;
cout << "YES";
break;
}
}
if (!result) cout << "NO";
}
| 800 | CPP |
#include <bits/stdc++.h>
constexpr int N = 600005;
constexpr long long inf = 1e18;
using namespace std;
int n;
priority_queue<long long> q;
long long f1[N], f2[N], sum[N], low[N], up[N], d[N];
long long cal(int L, int R, long long k) {
long long ans = 0;
for (int i = L; i <= R; ++i) ans += min(d[i], k);
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &d[i]);
sort(d + 1, d + 1 + n);
reverse(d + 1, d + 1 + n);
for (int i = 1; i <= n; ++i) sum[i] = sum[i - 1] + d[i];
d[0] = n;
d[n + 1] = 0;
for (int i = 0; i <= n; ++i) up[i] = inf, low[i] = -inf;
long long tmp = 0;
for (long long i = n; i >= 0; --i) {
while (!q.empty() && q.top() > i) tmp -= q.top(), q.pop();
f2[i] = tmp + 1ll * (n - i - q.size()) * i;
if (d[i] <= i) q.push(d[i]), tmp += d[i];
f1[i] = tmp + 1ll * (n - i + 1 - q.size()) * i;
}
for (long long i = n; i >= 0; --i) {
if (i != n) {
up[i] = min(up[i + 1], 1ll * i * (i + 1) + f1[i + 1] - sum[i]);
} else
up[i] = 1ll * i * (i + 1) - sum[i];
}
for (int i = 1; i <= n; ++i) {
low[i] = max(low[i - 1], sum[i] - 1ll * i * (i - 1) - f2[i]);
}
for (int i = 0; i <= n; ++i)
low[i] = max(low[i], d[i + 1]), up[i] = min(up[i], d[i]);
long long L = inf, R = -inf;
for (long long i = 0; i <= n; ++i)
if (low[i] <= up[i]) L = min(L, low[i]), R = max(R, up[i]);
if (L > R) printf("-1");
for (long long i = L; i <= R; ++i)
if (!((sum[n] - i) & 1)) printf("%lld ", i);
puts("");
return 0;
}
| 2,400 | CPP |
n = int(input())
s = input()
numab = 0
numa = 0
res = 0
kol_s = 1
m = 10 ** 9 + 7
for x in s:
if x == 'a':
numa += kol_s
if x == 'b':
numab += numa
if x == 'c':
res += numab
if x == '?':
res *= 3
res += numab
numab *= 3
numab += numa
numa *= 3
numa += kol_s
kol_s *= 3
numa %= m
numab %= m
res %= m
kol_s %= m
print(res)
# babc | 2,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[10005];
bool vis[10005][1005];
long long dis[10005][1005];
const long long inf = 1e18 + 7;
struct node {
int pos;
int step;
};
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i]);
}
int g, r;
scanf("%d%d", &g, &r);
sort(a + 1, a + 1 + m);
deque<node> q;
dis[1][0] = 0;
q.push_front(node{1, 0});
vis[1][0] = true;
long long ans = -1;
while (!q.empty()) {
node fa = q.front();
q.pop_front();
if (fa.step == 0) {
long long tmp = n - a[fa.pos];
if (tmp <= g) {
tmp = dis[fa.pos][fa.step] * (g + r) + tmp;
if (ans == -1 || tmp < ans) {
ans = tmp;
}
}
}
if (fa.step == g) {
if (!vis[fa.pos][0]) {
vis[fa.pos][0] = true;
dis[fa.pos][0] = dis[fa.pos][fa.step] + 1;
q.push_back(node{fa.pos, 0});
}
continue;
}
if (fa.pos > 1) {
int pos = fa.pos - 1;
int step = fa.step + a[fa.pos] - a[pos];
if (step <= g && !vis[pos][step]) {
vis[pos][step] = true;
dis[pos][step] = dis[fa.pos][fa.step];
q.push_front(node{pos, step});
}
}
if (fa.pos < m) {
int pos = fa.pos + 1;
int step = fa.step + a[pos] - a[fa.pos];
if (step <= g && !vis[pos][step]) {
vis[pos][step] = true;
dis[pos][step] = dis[fa.pos][fa.step];
q.push_front(node{pos, step});
}
}
}
printf("%lld\n", ans);
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k, a, b, c, d;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> a >> b >> c >> d;
if (n == 4 or k < n + 1)
cout << "-1\n";
else {
cout << a << " " << c << " ";
for (int i = 1; i <= n; i++) {
if (i == a or i == b or i == c or i == d) continue;
cout << i << " ";
}
cout << d << " " << b << "\n";
cout << c << " " << a << " ";
for (int i = 1; i <= n; i++) {
if (i == a or i == b or i == c or i == d) continue;
cout << i << " ";
}
cout << b << " " << d << "\n";
}
return 0;
}
| 1,600 | CPP |
a,b,c=map(int,input().split())
if a<b<c or c<b<a:
print(abs(a-b) + abs(c-b))
if b<a<c or c<a<b:
print(abs(a-b) + abs(a-c))
if a<c<b or b<c<a:
print(abs(c-b) + abs(c-a))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> field(n + 2, vector<int>(m + 2, -1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char a;
cin >> a;
field[i + 1][j + 1] = a - 'a' + 1;
}
}
vector<vector<int>> len(n + 2, vector<int>(m + 2));
for (int i = 2; i < n; i++) {
for (int j = 1; j <= m; j++) {
if (field[i][j] == field[i - 1][j]) {
continue;
}
int e = i;
while (field[i][j] == field[e][j]) {
e++;
}
len[i][j] = e - i;
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int w = 0, lent = 0;
int c1 = -1, c2 = -1, c3 = -1;
for (int j = 1; j <= m; j++) {
if (len[i][j] == 0) {
w = 0;
lent = 0;
c1 = -1;
c2 = -1;
c3 = -1;
continue;
}
int e = i - 2;
while (e >= 0 && field[e][j] == field[e + 1][j]) {
e--;
}
bool up = false, down = false;
if (i - max(e, 0) - 1 >= len[i][j]) {
up = true;
}
e = i + len[i][j] + 1;
while (e <= n + 1 && field[e][j] == field[e - 1][j]) {
e++;
}
if (min(n + 1, e) - (i + len[i][j]) >= len[i][j]) {
down = true;
}
if (up && down) {
if (c1 == field[i - 1][j] && c2 == field[i][j] &&
c3 == field[i + len[i][j]][j] && len[i][j] == lent) {
w++;
} else {
w = 1;
lent = len[i][j];
c1 = field[i - 1][j];
c2 = field[i][j];
c3 = field[i + len[i][j]][j];
}
} else {
w = 0;
lent = 0;
c1 = -1;
c2 = -1;
c3 = -1;
}
ans += w;
}
}
cout << ans;
return 0;
}
| 1,900 | CPP |
n = int(input())
s = input()
c1 = 0
c2 = 0
for i in range(n):
w = s[i]
if w == 'A':
c1 += 1
else:
c2 += 1
if c1 == c2:
print("Friendship")
elif c1 > c2:
print("Anton")
else:
print("Danik")
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000002;
int n, a[N], dp[N];
int main() {
scanf("%d", &n);
for (int i = (1); i <= (int)(n); ++i) scanf("%d", &a[i]);
a[0] = 1;
long long ans = 0;
for (int i = (1); i <= (int)(n); ++i) {
ans = (ans + a[i] - 1) % 1000000007;
long long ways = a[i] > a[i - 1] ? a[i - 1] - 1 : a[i] - 1;
ans = (ans + 1ll * dp[i - 1] * ways % 1000000007) % 1000000007;
if (a[i] > a[i + 1])
dp[i] =
(a[i + 1] - 1 + min(ways, a[i + 1] - 1ll) * dp[i - 1] % 1000000007) %
1000000007;
else
dp[i] = (a[i] - 1 + min(ways, a[i] - 1ll) * dp[i - 1] % 1000000007) %
1000000007;
}
cout << ans;
}
| 2,300 | CPP |
n = int (input())
c=1
for i in range ( 2 , n//2+1):
if (n-i)%i==0:
c+=1
print(c)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define li long long int
#define le long double5
#define mod 1000000007
#define maxe 100006
vector<bool> pu(maxe + 1, false);
vector<li> pr;
vector<li> prevprime(maxe + 1, 1);
class dop
{
public:
li n,k,p,r;
void get();
};
void seive()
{
for (li i = 2; (i) <= maxe; i++)
{
if (!pu[i])
{
prevprime[i] = i;
for (li j = (2 * i); j <= maxe; j += i)
{
if (!pu[j])
{
prevprime[j] = i;
}
pu[j] = true;
}
pr.push_back(i);
}
}
}
li power(li x, li n)
{
li res = 1;
while (n > 0)
{
if (n & 1)
{
res = ((res % mod) * (x % mod)) % mod;
}
n = n >> 1;
x = ((x % mod) * (x % mod)) % mod;
}
return res;
}
li inv(li x)
{
return power(x, mod - 2);
}
void factor(li x)
{
while (x != 1)
{
li div = prevprime[x];
while (prevprime[x] == div)
{
x /= div;
}
}
}
li gcd(li a, li b)
{
if (a == 0)
{
return b;
}
return gcd(b % a, a);
}
void dop::get()
{cin>>n>>k;
p=0;
cout<<p<<endl;cout.flush();
cin>>r;
if(r==1){return ;}
for(int i=2;i<=n;i++){
p=((i-1)^(i-2));
cout<<p<<endl;cout.flush();
cin>>r;
if(r==1){return ;}
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
li t = 1;
cin >> t;
dop obj[t];
// seive();
for (li i = 0; i < t; i++)
{
obj[i].get();
}
return 0;
} | 1,700 | CPP |
t = int(input())
for x in range(t):
n = int(input())
lastp, lastc = 0,0
ans = 'YES'
done = False
for _ in range(n):
p, c = map(int, input().split())
if done:
continue
if p>=lastp and c>=lastc and c-lastc<=p-lastp:
lastp = p
lastc = c
continue
else:
ans = 'NO'
done = True
print(ans) | 1,200 | PYTHON3 |
n = int(input())
l = list(map(int, input().split()))
dp = [0 for i in range(n + 1)]
pos = []
for i in range(n):
flag = 0
if l[i] <= n:
if dp[l[i]] == 0:
dp[l[i]] = 1
flag = 1
if not flag:
pos.append(i)
j = 0
for i in range(1, n + 1):
if dp[i] == 0:
l[pos[j]] = i
j += 1
for i in range(n):
print (l[i], end = ' ')
print ()
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int mape[3005][3005] = {0};
vector<int> in[3005], out[3005];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
out[a].push_back(b);
in[b].push_back(a);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < in[i].size(); j++)
for (int k = 0; k < out[i].size(); k++) mape[in[i][j]][out[i][k]]++;
}
long long ans = 0;
for (int i = 1; i < n; i++)
for (int j = i + 1; j <= n; j++) {
ans += (mape[i][j] * (mape[i][j] - 1)) / 2 +
(mape[j][i] * (mape[j][i] - 1)) / 2;
}
cout << ans << endl;
}
| 1,700 | CPP |
def mirror(text):
for i in range(len(text)):
if text[i] not in 'AHIMOoTUVvWwXxY':
try:
rules = {'b': 'd', 'd': 'b', 'p': 'q', 'q': 'p'}
if rules[text[i]] != text[-i-1]:
return 'NIE'
except Exception:
return 'NIE'
else:
if text[i] != text[-i-1]:
return 'NIE'
return 'TAK'
print(mirror(input()))
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 1e5 + 1e2;
char s[maxn];
int vis[1000000];
int sum[maxn];
int n;
int a[maxn];
int p[maxn];
int cnt;
void init(int n) {
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
p[++cnt] = i;
if (n / i != i) p[++cnt] = n / i;
}
}
}
int main() {
n = read();
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) a[i] = s[i] - '0';
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
for (int i = 1; i <= n; i++) vis[sum[i]]++;
init(sum[n]);
if (sum[n] == 0 && n >= 2) {
cout << "YES";
return 0;
}
for (int i = 1; i <= cnt; i++) {
int tmp1 = 0, tmp2 = 0;
for (int j = p[i]; j <= sum[n]; j += p[i]) {
if (vis[j]) ++tmp1;
tmp2++;
}
if (tmp1 == tmp2 && tmp2 >= 2) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 1,300 | CPP |
import math
t=int(input())
temp=[]
for i in range(30):
temp.append(math.pow(2,i+1))
for z in range(t):
n=int(input())
print(int(abs(sum(temp[n//2-1:n-1])-(sum(temp[:n//2-1])+temp[n-1]))))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MAXN = 1e5 + 10;
long long t, k;
long long dp[MAXN];
long long add(long long a, long long b) { return (a % MOD + b % MOD) % MOD; }
void solve() {
for (int ii = 0; ii < k; ii++) {
dp[ii] = 1;
}
for (int ii = k; ii < MAXN; ii++) {
dp[ii] = add(dp[ii - 1], dp[ii - k]);
}
for (int ii = 1; ii < MAXN; ii++) {
dp[ii] = add(dp[ii], dp[ii - 1]);
}
}
int main() {
scanf("%I64d%I64d", &t, &k);
solve();
while (t--) {
int a, b;
scanf("%d%d", &a, &b);
printf("%I64d\n", (dp[b] - dp[a - 1] + MOD) % MOD);
}
}
| 1,700 | CPP |
from math import floor
for _ in range(int(input())):
n = int(input())
print(int(floor(n/2))) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long F[1111];
int a[1111];
int was[1111][3];
long long f[1111][3];
int num, sz;
long long rec(int n, int m) {
if (n == 0) return m == 0;
if (was[n][m] == num) return f[n][m];
was[n][m] = num;
long long &res = f[n][m];
res = 0;
if (m + a[n] > 2) return res;
if (m + a[n] == 0)
res = rec(n - 1, 0);
else {
if (m + a[n] == 1) res += rec(n - 1, 2);
res += rec(n - 1, m + a[n] - (int)(m == 0 || a[n] == 0));
}
return res;
}
long long solve(long long n) {
for (int i = sz - 1; i > 0; --i) {
a[i] = n >= F[i] ? 1 : 0;
if (a[i]) n -= F[i];
}
assert(!n);
num++;
return rec(sz - 1, 0);
}
int main() {
F[1] = 1;
F[2] = 2;
for (sz = 2; F[sz] <= (long long)1e+18;) {
sz++;
F[sz] = F[sz - 1] + F[sz - 2];
}
memset((f), (0), sizeof(f));
memset((was), (0), sizeof(was));
num = 0;
int T;
cin >> T;
while (T--) {
long long n;
cin >> n;
cout << solve(n) << endl;
}
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = int(2e5) + 99;
long long x, y, n, m, a, b, st, v, mil = 0;
bool cmp(pair<double, int>& a, pair<double, int>& b) {
if (a.first > b.first) return 1;
return a.second < b.second;
}
int main(int argc, char const* argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, ta, tb, k;
cin >> n >> k;
std::vector<int> v(n);
y = 0;
for (int i = 0; i < n; i++) {
cin >> v[i];
if (v[i] < 0 and k) {
v[i] = v[i] * -1;
k -= 1;
} else {
if (k) {
if (i - 1 > -1) {
if (v[i - 1] < v[i]) {
y = y - v[i - 1];
if (k % 2) v[i - 1] = v[i - 1] * -1;
y += v[i - 1];
} else {
if (k % 2) v[i] = v[i] * -1;
}
} else {
if (k % 2) v[i] = v[i] * -1;
}
k = 0;
}
}
y += v[i];
}
if (k) {
y = y - v[n - 1];
if (k % 2 == 1) v[n - 1] = (v[n - 1] * -1);
y += v[n - 1];
}
cout << y;
return 0;
}
| 1,200 | CPP |
# cook your dish here
# cook your dish here
#from functools import reduce
#mod=int(1e9+7)
#import resource
#resource.setrlimit(resource.RLIMIT_STACK, [0x100000000, resource.RLIM_INFINITY])
#import threading
#threading.stack_size(2**26)
"""fact=[1]
#for i in range(1,100001):
# fact.append((fact[-1]*i)%mod)
#ifact=[0]*100001
#ifact[100000]=pow(fact[100000],mod-2,mod)
#for i in range(100000,0,-1):
# ifact[i-1]=(i*ifact[i])%mod"""
#from collections import deque, defaultdict, Counter, OrderedDict
#from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd
#from heapq import heappush, heappop, heapify, nlargest, nsmallest
# sys.setrecursionlimit(10**6)
from sys import stdin, stdout
import bisect #c++ upperbound
from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
from bisect import bisect_right as br #c++ upperbound
import itertools
from collections import Counter
from math import sqrt
import collections
import math
import heapq
import re
def modinv(n,p):
return pow(n,p-2,p)
def cin():
return map(int,sin().split())
def ain(): #takes array as input
return list(map(int,sin().split()))
def sin():
return input()
def inin():
return int(input())
def Divisors(n) :
l = []
for i in range(1, int(math.sqrt(n) + 1)) :
if (n % i == 0) :
if (n // i == i) :
l.append(i)
else :
l.append(i)
l.append(n//i)
return l
def most_frequent(list):
return max(set(list), key = list.count)
def GCD(x,y):
while(y):
x, y = y, x % y
return x
def ncr(n,r,p): #To use this, Uncomment 19-25
t=((fact[n])*((ifact[r]*ifact[n-r])%p))%p
return t
def Convert(string):
li = list(string.split(""))
return li
def SieveOfEratosthenes(n):
global prime
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
f=[]
for p in range(2, n):
if prime[p]:
f.append(p)
return f
prime=[]
q=[]
def dfs(n,d,v,c):
global q
v[n]=1
x=d[n]
q.append(n)
j=c
for i in x:
if i not in v:
f=dfs(i,d,v,c+1)
j=max(j,f)
# print(f)
return j
#Implement heapq
#grades = [110, 25, 38, 49, 20, 95, 33, 87, 80, 90]
#print(heapq.nlargest(3, grades)) #top 3 largest
#print(heapq.nsmallest(4, grades))
#Always make a variable of predefined function for ex- fn=len
#n,k=map(int,input().split())
"""*******************************************************"""
def main():
for _ in range(int(input())):
a,b=map(int,input().split())
print(a^b)
"""*******************************************************"""
######## Python 2 and 3 footer by Pajenegod and c1729
py2 = round(0.5)
if py2:
from future_builtins import ascii, filter, hex, map, oct, zip
range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192
class FastIO(BytesIO):
newlines = 0
def __init__(self, file):
self._file = file
self._fd = file.fileno()
self.writable = "x" in file.mode or "w" in file.mode
self.write = super(FastIO, self).write if self.writable else None
def _fill(self):
s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
return s
def read(self):
while self._fill(): pass
return super(FastIO,self).read()
def readline(self):
while self.newlines == 0:
s = self._fill(); self.newlines = s.count(b"\n") + (not s)
self.newlines -= 1
return super(FastIO, self).readline()
def flush(self):
if self.writable:
os.write(self._fd, self.getvalue())
self.truncate(0), self.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
if py2:
self.write = self.buffer.write
self.read = self.buffer.read
self.readline = self.buffer.readline
else:
self.write = lambda s:self.buffer.write(s.encode('ascii'))
self.read = lambda:self.buffer.read().decode('ascii')
self.readline = lambda:self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
if __name__== "__main__":
main()
#threading.Thread(target=main).start()
| 800 | PYTHON3 |
n = int(input())
a = list(map(int,input().split()))
for i in range(n):
a[i] = (a[i],-i)
a.sort()
m = int(input())
for j in range(m):
t = list(map(int, input().split()))
k = t[0]
p = t[1]
print(sorted(a[-k:], key = lambda x: -x[1])[p-1][0]) | 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void Read(T &x) {
x = 0;
char ch = getchar();
int64_t f = 1;
while (!isdigit(ch)) {
if (ch == '-') f *= -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
template <typename T, typename... Args>
void Read(T &x, Args &...args) {
Read(x);
Read(args...);
}
template <typename T>
int64_t __lcm(T a, T b) {
return a / __gcd(a, b) * b;
}
template <typename T>
int64_t __ceil(T a, T b) {
return (a + b - 1) / b;
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int64_t __rand(int64_t a, int64_t b) { return a + rng() % (b - a + 1); }
inline int64_t QuickPow(int64_t base, int64_t n, int64_t Mod = 0) {
int64_t ret(1);
while (n) {
if (n & 1) {
ret *= base;
if (Mod) ret %= Mod;
}
base *= base;
if (Mod) base %= Mod;
n >>= 1;
}
return Mod ? ret % Mod : ret;
}
inline int64_t __inv(int64_t x, int64_t p) { return QuickPow(x, p - 2, p); }
class DSU {
public:
std::vector<int> p, size;
int n, setCount;
DSU(int _n) : n(_n), setCount(_n), p(_n), size(_n, 1) {
std::iota(p.begin(), p.end(), 0);
}
int find(int x) { return p[x] = x == p[x] ? x : find(p[x]); }
bool unite(int x, int y) {
if (size[x] < size[y]) return unite(y, x);
return p[y] = x, size[x] += size[y], --setCount, true;
}
bool helper(int x, int y) {
int pX = find(x), pY = find(y);
return pX != pY ? unite(pX, pY) : false;
}
};
class BIT {
public:
BIT(int size) : n(size), tree(size + 10, 0LL) {}
virtual ~BIT() { tree.clear(); }
vector<int64_t> tree;
int n;
int lowbit(int x) { return ((x) & -(x)); }
void update(int64_t x, int64_t d) {
while (x <= n) {
tree[x] += d;
x += lowbit(x);
}
}
int64_t query(int x) {
int64_t res = 0;
while (x > 0) {
res += tree[x];
x -= lowbit(x);
}
return res;
}
};
class SegmentTree {
public:
struct node {
int64_t l, r;
int64_t sum;
int64_t dat;
int64_t lazy;
};
std::vector<node> tree;
std::vector<int64_t> arr;
int n;
SegmentTree(int _n, vector<int64_t> a) : n(_n), tree(_n << 1 | 1), arr(a) {}
void pushup(int64_t p) {
tree[p].sum = tree[p << 1].sum + tree[p << 1 | 1].sum;
tree[p].dat = max(tree[p << 1].dat, tree[p << 1 | 1].dat);
}
void pushdown(int64_t p) {
if (tree[p].lazy) {
tree[p << 1].sum += tree[p].lazy * (tree[p << 1].r - tree[p << 1].l + 1);
tree[p << 1 | 1].sum +=
tree[p].lazy * (tree[p << 1 | 1].r - tree[p << 1 | 1].l + 1);
tree[p << 1].dat += tree[p].lazy;
tree[p << 1 | 1].sum += tree[p].lazy;
tree[p << 1].lazy += tree[p].lazy;
tree[p << 1 | 1].lazy += tree[p].lazy;
tree[p].lazy = 0;
}
}
void build(int64_t p, int64_t l, int64_t r) {
tree[p].l = l, tree[p].r = r;
if (l == r) {
tree[p].sum = tree[p].dat = arr[l];
return;
}
int64_t mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
pushup(p);
}
void ChangeSegment(int64_t p, int64_t l, int64_t r, int64_t d) {
if (l <= tree[p].l && r >= tree[p].r) {
tree[p].sum += (int64_t)d * (tree[p].r - tree[p].l + 1);
tree[p].lazy += d;
tree[p].dat += d;
return;
}
pushdown(p);
int64_t mid = (tree[p].l + tree[p].r) / 2;
if (l <= mid) ChangeSegment(p << 1, l, r, d);
if (r > mid) ChangeSegment(p << 1 | 1, l, r, d);
pushup(p);
}
int64_t QuerySum(int64_t p, int64_t l, int64_t r) {
if (l <= tree[p].l && r >= tree[p].r) return tree[p].sum;
pushdown(p);
int64_t mid = (tree[p].l + tree[p].r) / 2;
int64_t sum = 0;
if (l <= mid) sum += QuerySum(p << 1, l, r);
if (r > mid) sum += QuerySum(p << 1 | 1, l, r);
return sum;
}
int64_t AskDat(int64_t p, int64_t l, int64_t r) {
if (l <= tree[p].l && r >= tree[p].r) return tree[p].dat;
pushdown(p);
int64_t mid = (tree[p].l + tree[p].r) / 2;
int64_t res = -(1 << 30);
if (l <= mid) res = max(res, AskDat(p << 1, l, r));
if (r > mid) res = max(res, AskDat(p << 1 | 1, l, r));
return res;
}
void show(int n) {
for (int i = 1; i <= n; i++) cout << QuerySum(1, i, i) << " ";
cout << '\n';
}
};
const double pi = acos(-1.0);
const int64_t kInf(1e18 + 10);
const int64_t kMod(998244353);
const int64_t kMax(2e5 + 10);
int64_t group(1);
inline void Solve() {
int n;
Read(n);
vector<vector<int64_t>> dp(2, vector<int64_t>(n + 2));
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
int64_t num;
Read(num);
dp[0][num + 1] = (dp[0][num + 1] + dp[0][num + 1]) % kMod;
dp[0][num + 1] = (dp[0][num + 1] + dp[0][num]) % kMod;
if (num > 0) dp[1][num - 1] = (dp[1][num - 1] + dp[1][num - 1]) % kMod;
if (num > 0) dp[1][num - 1] = (dp[1][num - 1] + dp[0][num - 1]) % kMod;
dp[1][num + 1] = (dp[1][num + 1] + dp[1][num + 1]) % kMod;
}
int64_t res = -1;
for (int i = 0; i <= n; i++)
res = ((res + dp[0][i]) % kMod + dp[1][i]) % kMod;
cout << (res) % kMod << '\n';
}
int main() {
Read(group);
while (group--) {
Solve();
}
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
long long yin[maxn];
int cntyin;
bool isgen(long long n, long long m) {
long long ret = 1, nn = n;
if (m <= 1) return 0;
while (n > 1) n /= m, ret *= m;
return nn == ret;
}
long long calgen(long long n) {
int i, j;
n--;
long long m = n;
if (n <= 1) return 0;
for (long long ii = 2; ii * ii <= n; ii++)
if (n % ii == 0) {
if (isgen(m, ii)) return ii;
return 0;
}
return n;
}
vector<pair<long long, long long> > vec;
map<long long, long long> valueToId;
long long dp[maxn], dp1[maxn];
int main() {
long long n;
int i, j, k;
cin >> n;
for (i = 1; i * (long long)i <= n; i++)
if (n % i == 0) {
yin[++cntyin] = i;
if (n / i - i) yin[++cntyin] = n / i;
}
sort(yin + 1, yin + 1 + cntyin);
for (i = 1; i <= cntyin; i++) {
long long gen = calgen(yin[i]);
if (gen) vec.push_back(make_pair(gen, yin[i]));
valueToId[yin[i]] = i;
}
if (n == 1) {
puts("1");
return 0;
}
sort(vec.begin(), vec.end());
if (vec.empty()) {
puts("0");
return 0;
}
dp[1] = 1;
for (i = 0; i < vec.size(); i++) {
memcpy(dp1, dp, sizeof(dp));
for (j = i; j < vec.size() && vec[j].first == vec[i].first; j++) {
for (k = 1; k <= cntyin; k++)
if (dp[k]) {
if (n / yin[k] >= vec[j].second &&
valueToId.count(yin[k] * vec[j].second))
dp1[valueToId[yin[k] * vec[j].second]] += dp[k];
}
}
memcpy(dp, dp1, sizeof(dp));
i = j - 1;
}
cout << dp[cntyin] << endl;
}
| 2,600 | CPP |
'''
@judge CodeForces
@id 1312A
@name Two Regular Polygons
@tag Geometry
'''
from sys import stdin
input()
for _, arr in zip(*[ iter(stdin) ] * 2):
print(' '.join(sorted(arr.split(), key=lambda x: -int(x)))) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 512345;
int p[17][N];
int carac[N];
vector<pair<int, int>> adj[N];
int d[N];
long long fpow(long long b, long long e, long long mod) {
long long r = 1;
while (e) {
if (e & 1) r = (r * b) % mod;
b = (b * b) % mod;
e >>= 1;
}
return r;
}
void dfs(int u, int a = -1, int h = 0) {
p[0][u] = a;
d[u] = h;
for (auto& e : adj[u])
if (e.first != a) {
carac[e.first] = e.second;
dfs(e.first, u, h + 1);
}
}
int lca(int u, int v) {
if (d[u] < d[v]) swap(u, v);
int diff = d[u] - d[v];
for (int i = 0; i < 17; i++) {
if ((diff >> i) & 1) {
u = p[i][u];
}
}
if (u == v) return u;
for (int i = 16; i >= 0; i--) {
if (p[i][u] != p[i][v]) {
u = p[i][u];
v = p[i][v];
}
}
return p[0][u];
}
int h[2][110];
int mod[] = {1000000007, 1000000009};
int inv[2];
unordered_map<long long, int> hashes;
int cnt_h;
vector<vector<int>> ap;
int ans[N];
vector<tuple<int, int, int, long long>> qr[N];
void go(int u, int a = -1) {
for (auto& t : qr[u]) {
int da, tam, id;
long long fh;
tie(da, tam, id, fh) = t;
if (hashes.count(fh)) {
fh = hashes[fh];
auto& vec = ap[fh];
ans[id] += end(vec) - lower_bound(begin(vec), end(vec), da + tam);
}
}
int old_101[2];
for (auto& e : adj[u]) {
int v, c;
tie(v, c) = e;
if (v == a) continue;
old_101[0] = h[0][101];
old_101[1] = h[1][101];
for (int tam = 101; tam > 0; tam--) {
h[0][tam] = (31ll * h[0][tam - 1] + c) % mod[0];
h[1][tam] = (31ll * h[1][tam - 1] + c) % mod[1];
if (d[u] + 1 >= tam && tam <= 100) {
long long th = 1ll * mod[1] * h[0][tam] + h[1][tam];
int aux = 0;
auto it = hashes.find(th);
if (it == hashes.end()) continue;
ap[it->second].push_back(d[u] + 1);
}
}
go(v, u);
for (int tam = 0; tam <= 100; tam++) {
h[0][tam] = (h[0][tam + 1] - c) * 1ll * inv[0] % mod[0];
if (h[0][tam] < 0) h[0][tam] += mod[0];
h[1][tam] = (h[1][tam + 1] - c) * 1ll * inv[1] % mod[1];
if (h[1][tam] < 0) h[1][tam] += mod[1];
}
for (int tam = 100; tam > 0; tam--) {
long long x1 = (31ll * h[0][tam - 1] + c) % mod[0];
long long x2 = (31ll * h[1][tam - 1] + c) % mod[1];
if (d[u] + 1 >= tam) {
long long th = 1ll * mod[1] * x1 + x2;
auto it = hashes.find(th);
if (it == hashes.end()) continue;
ap[it->second].pop_back();
}
}
h[0][101] = old_101[0];
h[1][101] = old_101[1];
}
}
char buf[110];
int pi[210];
int main() {
inv[0] = fpow(31, mod[0] - 2, mod[0]);
inv[1] = fpow(31, mod[1] - 2, mod[1]);
memset(p, -1, sizeof p);
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
char c;
scanf("%d%d %c", &u, &v, &c);
adj[u].emplace_back(v, c - 'a' + 1);
adj[v].emplace_back(u, c - 'a' + 1);
}
dfs(1);
for (int i = 1; i < 17; i++) {
for (int j = 1; j <= n; j++) {
if (p[i - 1][j] != -1) {
p[i][j] = p[i - 1][p[i - 1][j]];
}
}
}
int q;
scanf("%d", &q);
for (int id = 0; id < q; id++) {
int u, v;
scanf("%d%d %s", &u, &v, buf);
int k = strlen(buf);
int hd[2] = {0, 0};
for (int i = 0; i < k; i++) {
for (int j = 0; j < 2; j++) {
hd[j] = (31ll * hd[j] + buf[i] - 'a' + 1) % mod[j];
}
}
int hr[2] = {0, 0};
for (int i = k - 1; i >= 0; i--) {
for (int j = 0; j < 2; j++) {
hr[j] = (31ll * hr[j] + buf[i] - 'a' + 1) % mod[j];
}
}
int a = lca(u, v);
if (a == u) {
long long h = 1ll * mod[1] * hd[0] + hd[1];
if (!hashes.count(h)) hashes[h] = cnt_h++;
qr[v].emplace_back(d[a], k, id, h);
} else if (a == v) {
long long h = 1ll * mod[1] * hr[0] + hr[1];
if (!hashes.count(h)) hashes[h] = cnt_h++;
qr[u].emplace_back(d[a], k, id, h);
} else {
long long h = 1ll * mod[1] * hr[0] + hr[1];
qr[u].emplace_back(d[a], k, id, h);
if (!hashes.count(h)) hashes[h] = cnt_h++;
h = 1ll * mod[1] * hd[0] + hd[1];
qr[v].emplace_back(d[a], k, id, h);
if (!hashes.count(h)) hashes[h] = cnt_h++;
int cu = u;
if (d[u] - d[a] >= k) {
int diff = d[u] - d[a] - k + 1;
for (int i = 0; i < 17; i++) {
if ((diff >> i) & 1) {
cu = p[i][cu];
}
}
}
int cv = v;
if (d[v] - d[a] >= k) {
int diff = d[v] - d[a] - k + 1;
for (int i = 0; i < 17; i++) {
if ((diff >> i) & 1) {
cv = p[i][cv];
}
}
}
string w;
while (cu != a) {
w += carac[cu] - 1 + 'a';
cu = p[0][cu];
}
string ww;
while (cv != a) {
ww += carac[cv] - 1 + 'a';
cv = p[0][cv];
}
reverse(begin(ww), end(ww));
w += ww;
pi[0] = 0;
for (int i = 1; i < k; i++) {
pi[i] = pi[i - 1];
while (pi[i] and buf[pi[i]] != buf[i]) pi[i] = pi[pi[i] - 1];
pi[i] += buf[pi[i]] == buf[i];
}
int xd = 0;
for (int i = 0; i < w.size(); i++) {
while (xd and buf[xd] != w[i]) xd = pi[xd - 1];
xd += buf[xd] == w[i];
if (xd == k) ans[id]++;
}
}
}
for (int i = 0; i < cnt_h; i++) {
vector<int> lul;
ap.push_back(lul);
}
go(1);
for (int id = 0; id < q; id++) {
printf("%d\n", ans[id]);
}
return 0;
}
| 2,600 | CPP |
for _ in range(int(input())):
n,m,x,y = map(int,input().split())
S=[]
A1=0
for i in range(n):
s = input();s = list(s)
S.append(s)
A1+=s.count(".")*x
A2=0
for i in range(0,n):
for j in range(0,m-1):
if(S[i][j]=="." and S[i][j+1]=="."):
S[i][j]="*";S[i][j+1]="*"
A2+=y
for i in range(n):
for j in range(m):
if(S[i][j]=="."):
A2+=x
print(min(A1,A2))
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3005;
int match[N], p = 0;
bool vis[N];
vector<int> adj[N];
vector<pair<int, int> > a[N];
bool dfs(int x) {
if (vis[x]) return 0;
vis[x] = 1;
int u, i;
for (i = 0; i < adj[x].size(); ++i) {
u = adj[x][i];
if (match[u] == -1 || dfs(match[u])) {
match[u] = x;
return 1;
}
}
return 0;
}
int main() {
int k, n, m, i, j, x, y;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) {
scanf("%d", &x);
y = sqrt(x);
for (j = 2; j <= y; ++j) {
while (x % j == 0) {
x /= j;
a[i].push_back(make_pair(j, p++));
}
}
if (x != 1) a[i].push_back(make_pair(x, p++));
}
for (i = 0; i < m; ++i) {
scanf("%d%d", &x, &y);
if (x & 1) swap(x, y);
for (j = 0; j < a[x].size(); ++j)
for (k = 0; k < a[y].size(); ++k) {
if (a[x][j].first == a[y][k].first)
adj[a[x][j].second].push_back(a[y][k].second);
}
}
memset(match, -1, sizeof(match));
int ret = 0;
for (i = 0; i < p; ++i) {
memset(vis, 0, sizeof(vis));
if (dfs(i)) ++ret;
}
cout << ret << endl;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> acc;
int accNum;
int loss;
double test(double n) { return 0.0; }
double CheckEnergy(double en) {
vector<double> temp;
int i;
for (i = 0; i < acc.size(); i++) temp.push_back(acc[i] * 1.0);
int j = 0;
double extra = 0.0;
for (i = (acc.size() - 1); i > j; i--) {
extra = (temp[i] - en) * (100 - loss) / 100.0;
temp[i] = en;
while (j < i) {
double tt = temp[j];
if (tt > en) return 1;
if ((en - tt) >= extra) {
temp[j] += extra;
extra = 0;
break;
} else {
temp[j] = en;
extra -= (en - tt);
j++;
}
}
}
for (i = 0; i < temp.size(); i++) {
if (temp[i] > en)
return 1;
else if (temp[i] < en)
return -1;
}
if (extra > 0) return 1;
return 0;
}
int main() {
int i;
cin >> accNum;
cin >> loss;
for (i = 0; i < accNum; i++) {
int temp;
cin >> temp;
acc.push_back(temp);
}
sort(acc.begin(), acc.end());
double down = acc[0] * 1.0;
double upper = acc[accNum - 1] * 1.0;
while ((upper - down) > 0.00000001) {
double t = (upper - down) * (1 - loss * 1 / 100.0);
t = t / (accNum - 1);
double energy = (upper + down) / 2.0;
double tt = CheckEnergy(energy);
if (tt > 0) {
down = energy;
} else if (tt < 0) {
upper = energy;
} else {
cout << (upper + down) / 2.0 << "\n";
}
}
printf("%lf\n", upper);
return 0;
}
| 1,600 | CPP |
t = int(input())
for _ in range(t):
k = int(input())
one = -1
gens = [False] * (k+1)
for j in range(1, k+1):
ee = False
g = list(map(int, input().split()))
for i in range(1, g[0]+1):
if gens[g[i]] is False:
gens[g[i]] = True
ee = True
break
if not ee:
one = j
if one > 0:
print("IMPROVE")
o = gens.index(False, 1)
print("{0} {1}".format(one, o))
else:
print("OPTIMAL")
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
const long long inf = 1e18;
int n, q, cnt, hd[N], fa[19][N], dep[N];
long long a[N], d[N];
bool vis[N];
struct edge {
int tt, nxt;
long long w0, w1;
} e[N << 1];
struct node {
long long s[2][2];
} mn[19][N];
priority_queue<pair<long long, int> > Q;
void addedge(int u, int v, long long w0, long long w1) {
e[++cnt] = (edge){v, hd[u], w0, w1}, hd[u] = cnt;
}
node mg(node a, node b) {
node c;
c.s[0][0] = min(a.s[0][0] + b.s[0][0], a.s[0][1] + b.s[1][0]);
c.s[0][1] = min(a.s[0][0] + b.s[0][1], a.s[0][1] + b.s[1][1]);
c.s[1][0] = min(a.s[1][0] + b.s[0][0], a.s[1][1] + b.s[1][0]);
c.s[1][1] = min(a.s[1][0] + b.s[0][1], a.s[1][1] + b.s[1][1]);
return c;
}
void dijkstra() {
for (int i = (1); i <= (n); ++i) d[i] = a[i], Q.push(make_pair(-d[i], i));
while (!Q.empty()) {
int x = Q.top().second;
Q.pop();
if (vis[x]) continue;
vis[x] = 1;
for (int i = hd[x]; i; i = e[i].nxt) {
int v = e[i].tt;
if (d[v] > d[x] + e[i].w1 + e[i].w0)
d[v] = d[x] + e[i].w1 + e[i].w0, Q.push(make_pair(-d[v], v));
}
}
}
void dfs(int x) {
dep[x] = dep[fa[0][x]] + 1;
for (int j = (1); j <= (18); ++j) {
fa[j][x] = fa[j - 1][fa[j - 1][x]];
if (fa[j][x]) mn[j][x] = mg(mn[j - 1][x], mn[j - 1][fa[j - 1][x]]);
}
for (int i = hd[x]; i; i = e[i].nxt) {
int v = e[i].tt;
if (!dep[v]) {
node c = mg((node){0, d[v], d[v], 0}, (node){e[i].w0, inf, inf, e[i].w1});
mn[0][v] = mg(c, (node){0, d[x], d[x], 0});
fa[0][v] = x, dfs(v);
}
}
}
node qpath(int u, int v) {
bool ty = 0;
if (dep[u] < dep[v]) swap(u, v), ty = 1;
node res1 = (node){0, d[u], d[u], 0}, res2 = (node){0, d[v], d[v], 0};
for (int j = (18); j >= (0); --j)
if (dep[u] - dep[v] >= (1 << j)) res1 = mg(res1, mn[j][u]), u = fa[j][u];
if (u == v) {
if (ty) swap(res1.s[0][1], res1.s[1][0]);
return res1;
}
for (int j = (18); j >= (0); --j)
if (fa[j][u] != fa[j][v]) {
res1 = mg(res1, mn[j][u]), res2 = mg(res2, mn[j][v]);
u = fa[j][u], v = fa[j][v];
}
res1 = mg(res1, mn[0][u]), res2 = mg(res2, mn[0][v]);
swap(res2.s[0][1], res2.s[1][0]);
node res = mg(res1, res2);
if (ty) swap(res.s[0][1], res.s[1][0]);
return res;
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); ++i) scanf("%lld", &a[i]);
for (int i = (1); i <= (n - 1); ++i) {
int u, v;
long long w0, w1;
scanf("%d%d%lld%lld", &u, &v, &w1, &w0);
addedge(u, v, w0, w1), addedge(v, u, w0, w1);
}
dijkstra(), dfs(1);
scanf("%d", &q);
while (q--) {
int u, v;
scanf("%d%d", &u, &v);
printf("%lld\n", qpath((u + 1) >> 1, (v + 1) >> 1).s[u & 1][v & 1]);
}
return 0;
}
| 2,700 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
long long prime[1000001];
using namespace std;
int Prime(int a) {
for (int i = 2; i <= a / 2; ++i) {
if (a % i == 0) {
return 0;
}
}
return 1;
}
void sieve() {
for (int i = 2; i <= 1000000; i++) prime[i] = 1;
int maxn = 1000000;
for (int i = 2; i * i <= maxn; i++) {
if (prime[i] == 1) {
for (int j = i; j * j <= maxn; j += i) {
prime[j] = 0;
}
}
}
}
void fibo(long long a[], long long n) {
long long x = 0;
long long y = 1;
a[0] = 0;
a[1] = 1;
for (long long i = 2; i < n; ++i) {
a[i] = (x + y) % 10;
x = y;
y = a[i];
}
}
bool binarySearch(vector<long long> arr, int l, int r, int x) {
if (r >= l) {
int mid = l + (r - l) / 2;
if (arr[mid] == x) return 1;
if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return 0;
}
long long fact[10];
void sol() {
fact[0] = fact[1] = 1;
for (long long i = 2; i < 10; ++i) {
fact[i] = i * fact[i - 1];
}
}
bool check(long long r, long long c) {
if (r >= 8 || r < 0 || c < 0 || c > 7) {
return false;
}
return true;
}
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
long long t, n, c, d, k, b;
string x, y, z;
cin >> x >> y;
long long r1 = x[0] - 'a', c1 = x[1] - '1', r2 = y[0] - 'a', c2 = y[1] - '1',
a[8][8];
for (long long i = 0; i < 8; ++i) {
for (long long j = 0; j < 8; ++j) {
a[i][j] = 0;
}
}
a[r2][c2] = -1;
for (long long i = 0; i < 8; ++i) {
a[i][c1] = a[r1][i] = -1;
}
if (check(r1 + 2, c1 + 1)) {
a[r1 + 2][c1 + 1] = -1;
}
if (check(r1 + 2, c1 - 1)) {
a[r1 + 2][c1 - 1] = -1;
}
if (check(r1 - 2, c1 + 1)) {
a[r1 - 2][c1 + 1] = -1;
}
if (check(r1 - 2, c1 - 1)) {
a[r1 - 2][c1 - 1] = -1;
}
if (check(r1 + 1, c1 + 2)) {
a[r1 + 1][c1 + 2] = -1;
}
if (check(r1 + 1, c1 - 2)) {
a[r1 + 1][c1 - 2] = -1;
}
if (check(r1 - 1, c1 + 2)) {
a[r1 - 1][c1 + 2] = -1;
}
if (check(r1 - 1, c1 - 2)) {
a[r1 - 1][c1 - 2] = -1;
}
if (check(r2 + 2, c2 + 1)) {
a[r2 + 2][c2 + 1] = -1;
}
if (check(r2 + 2, c2 - 1)) {
a[r2 + 2][c2 - 1] = -1;
}
if (check(r2 - 2, c2 + 1)) {
a[r2 - 2][c2 + 1] = -1;
}
if (check(r2 - 2, c2 - 1)) {
a[r2 - 2][c2 - 1] = -1;
}
if (check(r2 + 1, c2 + 2)) {
a[r2 + 1][c2 + 2] = -1;
}
if (check(r2 + 1, c2 - 2)) {
a[r2 + 1][c2 - 2] = -1;
}
if (check(r2 - 1, c2 + 2)) {
a[r2 - 1][c2 + 2] = -1;
}
if (check(r2 - 1, c2 - 2)) {
a[r2 - 1][c2 - 2] = -1;
}
c = 0;
for (long long i = 0; i < 8; ++i) {
for (long long j = 0; j < 8; ++j) {
if (a[i][j] == 0) {
++c;
}
}
}
cout << c;
return 0;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k = 5, ki = 1, ans;
int main() {
cin >> n;
while (n > k) {
n -= k;
k *= 2;
ki *= 2;
}
ans = ((n + ki - 1) / ki);
if (ans == 1) {
cout << "Sheldon" << endl;
}
if (ans == 2) {
cout << "Leonard" << endl;
}
if (ans == 3) {
cout << "Penny" << endl;
}
if (ans == 4) {
cout << "Rajesh" << endl;
}
if (ans == 5) {
cout << "Howard" << endl;
}
}
| 1,100 | CPP |
n = input()
n_list = []
for i in range(0,len(n)):
n_list.append(n[i])
m = set(n_list)
if len(m)%2 == 0:
print('CHAT WITH HER!')
else:
print('IGNORE HIM!') | 800 | PYTHON3 |
n=int(input())
x=0
for i in range(0,n):
a=input()
if a[1]=="+":
x+=1
else:
x-=1
print(x)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
namespace zyt {
const int N = 1e5 + 10, K = 110, p = 1e9 + 7;
int n, k, ans;
int fa[N], size[N];
int f(const int x) { return x == fa[x] ? x : fa[x] = f(fa[x]); }
int power(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) ans = (long long)ans * a % p;
a = (long long)a * a % p;
b >>= 1;
}
return ans;
}
int work() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) fa[i] = i, size[i] = 1;
for (int i = 1; i < n; i++) {
int a, b, x;
scanf("%d%d%d", &a, &b, &x);
if (!x) size[f(b)] += size[f(a)], fa[f(a)] = f(b);
}
for (int i = 1; i <= n; i++)
if (fa[i] == i) ans = (ans + power(size[i], k)) % p;
printf("%d", (power(n, k) - ans + p) % p);
return 0;
}
} // namespace zyt
int main() { return zyt::work(); }
| 1,500 | CPP |
for _ in range(int(input())):
n,k=map(int,input().split())
arr=list(map(int,input().split()))
div=0
lis=[]
if(sum(arr)%k!=0):
print(n)
else:
for i in range(n):
if(arr[i]%k!=0):
lis.append(min(i+1,n-i))
else:
div+=1
if(div==n):
print(-1)
else:
print(n-min(lis)) | 1,200 | PYTHON3 |
import sys
input=sys.stdin.readline
for test in range(int(input().strip())):
n=int(input().strip())
ls1=list(map(int,input().strip().split()))
lis2=list(map(int,input().strip().split()))
nlis=[]
c=d=0
for i in range(n):
c+=ls1[i]
ls1[i]=c
d+=lis2[i]
nlis.append(d)
ans=ls1[-1]+nlis[-1]
for i in range(n):
ans=min(ans,max((ls1[-1]-ls1[i]),nlis[i]-lis2[i]))
print(ans)
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <class T>
void pvp(T a, T b) {
for (T i = a; i != b; ++i)
cout << "(" << i->first << ", " << i->second << ") ";
cout << endl;
}
template <class T>
void chmin(T &t, T f) {
if (t > f) t = f;
}
template <class T>
void chmax(T &t, T f) {
if (t < f) t = f;
}
int in_c() {
int c;
for (; (c = getchar()) <= ' ';) {
if (!~c) throw ~0;
}
return c;
}
int in() {
int x = 0, c;
for (; (unsigned)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -in();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned)((c = getchar()) - '0') < 10);
return x;
}
long long In() {
long long x = 0, c;
for (; (unsigned)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -In();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned)((c = getchar()) - '0') < 10);
return x;
}
int sig(int x) { return (x < 0) ? -1 : (x > 0) ? +1 : 0; }
int M, N;
char SS[100020], *S;
char T[100020];
int pos[8][100020], val[8][100020];
bool greaterThan74() {
int i;
for (i = 0; i < N / 2; ++i) {
if (S[i] - '0' > 7) return 1;
if (S[i] - '0' < 7) return 0;
}
for (i = N / 2; i < N; ++i) {
if (S[i] - '0' > 4) return 1;
if (S[i] - '0' < 4) return 0;
}
return 0;
}
int main() {
int g;
int i;
for (; S = SS, ~scanf("%s", S);) {
N = strlen(S);
if (N % 2 != 0) ++N, *--S = '0';
if (greaterThan74()) ++N, *--S = '0';
if (N % 2 != 0) ++N, *--S = '0';
for (g = 4; g <= 7; ++g) {
pos[g][N] = N;
val[g][N] = 0;
for (i = N; i--;) {
if (S[i] - '0' != g) {
pos[g][i] = i;
val[g][i] = S[i] - '0';
} else {
pos[g][i] = pos[g][i + 1];
val[g][i] = val[g][i + 1];
}
}
}
int flg = 0;
int a4, a7;
a4 = a7 = N / 2;
for (i = 0; i < N; ++i) {
if (!a4) {
T[i] = '7';
} else if (!a7) {
T[i] = '4';
} else {
if (flg) {
T[i] = '4';
} else {
int cmp = 0;
if (pos[4][i] < i + 1) {
cmp += sig(4 - val[4][i]) * 1000000;
}
if (pos[7][i + 1] < i + 1 + a7) {
cmp += sig(7 - val[7][i + 1]) * 1000;
}
if (pos[4][i + 1 + a7] < N) {
cmp += sig(4 - val[4][i + 1 + a7]) * 1;
}
if (cmp >= 0) {
T[i] = '4';
} else {
T[i] = '7';
}
}
}
if (S[i] - '0' < T[i] - '0') {
flg = 1;
}
if (T[i] == '4') {
--a4;
} else {
--a7;
}
}
T[N] = 0;
puts(T);
}
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
const int N = 1005;
const ll mod = 1e9 + 7;
const int base = 311;
ll m, n, k, t, T, ans, u, v, tong;
ll a[N], b[N], d[N], f[N][N][4];
string s[105];
vector<ll> kq;
ll C(ll u, ll v) {
if (u > v) return 0;
return a[v] * b[u] % mod * b[v - u] % mod;
}
ll pw(ll k, ll n) {
ll total = 1;
for (; n; n >>= 1) {
if (n & 1) total = (total * k) % mod;
k = (k * k) % mod;
}
return total;
}
void sol() {
cin >> n >> k;
a[0] = b[0] = 1;
for (int i = 1; i <= n; i++) {
a[i] = a[i - 1] * i % mod;
b[i] = pw(i, mod - 2);
b[i] = b[i - 1] * b[i] % mod;
}
f[0][0][1] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++) {
for (int z = 0; z < 4; z++) {
if (i < n)
f[i][j + 1][z / 2 + 2] =
(f[i][j + 1][z / 2 + 2] + f[i - 1][j][z]) % mod;
f[i][j][z / 2] = (f[i][j][z / 2] + f[i - 1][j][z]) % mod;
if (z % 2 == 0)
f[i][j + 1][z / 2] = (f[i][j + 1][z / 2] + f[i - 1][j][z]) % mod;
}
}
}
for (int i = 0; i <= n; i++) {
for (int z = 0; z < 4; z++)
d[i] = (d[i] + f[n][i][z] * a[n - i] % mod) % mod;
}
for (int i = n - 1; i >= k; i--) {
for (int j = i + 1; j <= n; j++) {
d[i] = (d[i] - d[j] * C(i, j) % mod + mod) % mod;
}
}
cout << d[k];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (fopen("LAZY"
".inp",
"r")) {
freopen(
"LAZY"
".inp",
"r", stdin);
freopen(
"LAZY"
".out",
"w", stdout);
}
sol();
}
| 2,600 | CPP |
for _ in range(int(input())):
l1,r1,l2,r2=list(map(int,input().split()))
if(r1!=r2):
print(r1,r2)
if(r1==r2):
print(l1,r2) | 800 | PYTHON3 |
s,k=input().split()
k=int(k)
i=-1
count=0
while k>0:
try:
if s[i]=='0':
k-=1
i-=1
else:
i-=1
count+=1
except:
if '0' in s:
count=len(s)-1
else:
count=len(s)
break
print(count)
| 1,100 | PYTHON3 |
for i in range(int(input())):
s=int(input())
print(s-1,1) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void qread(T& x) {
char c;
bool f = 0;
while ((c = getchar()) < '0' || '9' < c) f |= (c == '-');
for (x = (c ^ 48); '0' <= (c = getchar()) && c <= '9';
x = (x << 1) + (x << 3) + (c ^ 48))
;
if (f) x = -x;
}
template <class T>
inline T qread(const T sample) {
T x = 0;
char c;
bool f = 0;
while ((c = getchar()) < '0' || '9' < c) f |= (c == '-');
for (x = (c ^ 48); '0' <= (c = getchar()) && c <= '9';
x = (x << 1) + (x << 3) + (c ^ 48))
;
return f ? -x : x;
}
template <class T>
inline T Max(const T x, const T y) {
return x > y ? x : y;
}
template <class T>
inline T Min(const T x, const T y) {
return x < y ? x : y;
}
template <class T>
inline T fab(const T x) {
return x > 0 ? x : -x;
}
inline int gcd(const int a, const int b) { return b ? gcd(b, a % b) : a; }
inline void getInv(int inv[], const int lim, const int MOD) {
inv[0] = inv[1] = 1;
for (int i = 2; i <= lim; ++i)
inv[i] = 1ll * inv[MOD % i] * (MOD - MOD / i) % MOD;
}
template <class T>
void fwrit(const T x) {
if (x < 0) return (void)(putchar('-'), fwrit(-x));
if (x > 9) fwrit(x / 10);
putchar(x % 10 ^ 48);
}
inline long long mulMod(const long long a, const long long b,
const long long mod) {
return ((a * b - (long long)((long double)a / mod * b + 1e-8) * mod) % mod +
mod) %
mod;
}
const int MAXN = 2e5;
struct liner_basic {
int f[31 + 5], siz, failed;
liner_basic() { memset(f, siz = failed = 0, sizeof f); }
inline void clear() { memset(f, siz = failed = 0, sizeof f); }
inline void Insert(int num) {
for (signed i = (31), i_end_ = (0); i >= i_end_; --i) {
if (!(num >> i)) continue;
if (!f[i]) {
f[i] = num;
++siz;
return;
}
num ^= f[i];
}
++failed;
}
friend liner_basic operator+(liner_basic lhs, const liner_basic rhs) {
for (signed i = (0), i_end_ = (31); i <= i_end_; ++i) lhs.Insert(rhs.f[i]);
return lhs;
}
};
int n, q;
int a[MAXN << 2 | 2], b[MAXN + 5], tag[MAXN << 2 | 2];
liner_basic B[MAXN << 2 | 2];
void Bmodify(const int p, const int x, const int i = 1, const int l = 1,
const int r = n + 1) {
if (l == r) {
B[i].clear();
B[i].Insert(x);
return;
}
if (p <= ((l + r) >> 1))
Bmodify(p, x, (i << 1), l, ((l + r) >> 1));
else
Bmodify(p, x, (i << 1 | 1), ((l + r) >> 1) + 1, r);
B[i] = B[(i << 1)] + B[(i << 1 | 1)];
}
void pushdown(const int i) {
a[(i << 1)] ^= tag[i], a[(i << 1 | 1)] ^= tag[i];
tag[(i << 1)] ^= tag[i], tag[(i << 1 | 1)] ^= tag[i];
tag[i] = 0;
}
void Amodify(const int L, const int R, const int x, const int i = 1,
const int l = 1, const int r = n) {
if (L <= l && r <= R) {
a[i] ^= x, tag[i] ^= x;
return;
}
if (tag[i]) pushdown(i);
if (L <= ((l + r) >> 1)) Amodify(L, R, x, (i << 1), l, ((l + r) >> 1));
if (((l + r) >> 1) < R) Amodify(L, R, x, (i << 1 | 1), ((l + r) >> 1) + 1, r);
}
liner_basic Bquery(const int L, const int R, const int i = 1, const int l = 1,
const int r = n + 1) {
liner_basic ret;
if (L > R) return ret;
if (L <= l && r <= R) return B[i];
if (L <= ((l + r) >> 1))
ret = ret + Bquery(L, R, (i << 1), l, ((l + r) >> 1));
if (((l + r) >> 1) < R)
ret = ret + Bquery(L, R, (i << 1 | 1), ((l + r) >> 1) + 1, r);
return ret;
}
int Aquery(const int p, const int i = 1, const int l = 1, const int r = n) {
if (p < 1 || p > n) return 0;
if (l == r) return a[i];
if (tag[i]) pushdown(i);
if (p <= ((l + r) >> 1)) return Aquery(p, (i << 1), l, ((l + r) >> 1));
return Aquery(p, (i << 1 | 1), ((l + r) >> 1) + 1, r);
}
void buildtre(const int i = 1, const int l = 1, const int r = n) {
if (l == r) {
cin >> a[i];
return;
}
buildtre((i << 1), l, ((l + r) >> 1));
buildtre((i << 1 | 1), ((l + r) >> 1) + 1, r);
}
inline void Init() {
cin >> n >> q;
buildtre();
for (signed i = (1), i_end_ = (n + 1); i <= i_end_; ++i)
b[i] = Aquery(i - 1) ^ Aquery(i);
for (signed i = (1), i_end_ = (n + 1); i <= i_end_; ++i) Bmodify(i, b[i]);
}
inline void Getquery() {
int opt, l, r, t;
while (q--) {
cin >> opt >> l >> r;
if (opt == 1) {
cin >> t;
Amodify(l, r, t);
b[l] ^= t, b[r + 1] ^= t;
Bmodify(l, b[l]);
Bmodify(r + 1, b[r + 1]);
} else {
liner_basic G = Bquery(l + 1, r);
G.Insert(Aquery(r));
cout << (1 << G.siz) << endl;
}
}
}
signed main() {
Init();
Getquery();
return 0;
}
| 2,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
void display(vector<int> v) {
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << "\n";
}
int main() {
int n, num, i, f = 0;
cin >> n;
vector<int> v;
for (i = 0; i < n; i++) {
cin >> num;
v.push_back(num);
}
sort(v.begin(), v.end());
vector<int>::iterator it;
it = unique(v.begin(), v.end());
v.resize(it - v.begin());
for (i = 0; i < v.size() - 1; i++) {
if (!(v[i] <= (v[i + 1] / 2))) {
f = 1;
break;
}
}
if (f == 1)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 1000011;
long long sumu[MAXN], sumd[MAXN];
int pu, pd;
int n;
char s[MAXN];
int ucnt[MAXN], dcnt[MAXN];
long long ans[MAXN];
int main() {
scanf("%d", &n);
scanf("%s", s);
pu = pd = 1;
sumu[0] = sumd[0] = ucnt[0] = dcnt[0] = 0;
for (int i = 0; i < n; ++i) {
if (s[i] == 'U') {
sumu[pu] = sumu[pu - 1] + i + 1;
pu++;
ucnt[i + 1] = ucnt[i] + 1;
dcnt[i + 1] = dcnt[i];
} else if (s[i] == 'D') {
sumd[pd] = sumd[pd - 1] + i + 1;
pd++;
ucnt[i + 1] = ucnt[i];
dcnt[i + 1] = dcnt[i] + 1;
}
}
for (int i = 1; i <= n; i++) {
if (s[i - 1] == 'U') {
long long rd = pd - 1 - dcnt[i];
long long lu = ucnt[i] - 1;
if (lu >= rd) {
ans[i] = 2 * (-rd * i + sumd[pd - 1] - sumd[dcnt[i]]);
ans[i] += 2 * ((rd)*i - sumu[ucnt[i] - 1] + sumu[ucnt[i] - 1 - rd]);
ans[i] += n - i + 1;
} else {
ans[i] = 2 * (lu * i - sumu[ucnt[i] - 1]);
ans[i] += 2 * (-(lu + 1) * i + sumd[dcnt[i] + lu + 1] - sumd[dcnt[i]]);
ans[i] += i;
}
} else {
long long rd = pd - 1 - dcnt[i];
long long lu = ucnt[i];
if (rd >= lu) {
ans[i] = 2 * (lu * i - sumu[ucnt[i]]);
ans[i] += 2 * (-lu * i + sumd[dcnt[i] + lu] - sumd[dcnt[i]]);
ans[i] += i;
} else {
ans[i] = 2 * (-rd * i + sumd[pd - 1] - sumd[dcnt[i]]);
ans[i] += 2 * ((rd + 1) * i - sumu[ucnt[i]] + sumu[ucnt[i] - rd - 1]);
ans[i] += n - i + 1;
}
}
}
for (int i = 1; i <= n; i++) {
printf("%I64d ", ans[i]);
}
return 0;
}
| 2,400 | CPP |
na, nb = map(int, input().split())
k, m = map(int, input().split())
la = [int(x) for x in input().split()]
lb = [int(y) for y in input().split()]
la = la[:k]
lb = lb[len(lb)-m:]
if la[-1] < lb[0]:
print("YES")
else:
print("NO") | 900 | PYTHON3 |
n = int(input())
for i in range(n):
x = int(input())
a = []
count = 0
while x != 0:
if int(x % 10) != 0:
a.append(int(x % 10) * 10 ** count)
count += 1
x = int(x/10)
print(a.__len__())
for j in range(a.__len__()):
print(a[j], end=" ")
| 800 | PYTHON3 |
def mnoz (v):
res = []
i = 2
while v > 1:
if i * i > v:
res.append(v)
break
while v % i == 0:
v /= i
res.append(i)
i += 1
return res;
n, b = map(int, input().split())
mz = mnoz(b);
ress = -1
for every in mz:
every_count = 0;
for i in mz:
if every == i:
every_count += 1
res = 0
cevry = every
while(cevry <= n):
res += int(n // cevry)
cevry *= every
res = int(res // every_count)
if ress == -1 or ress > res:
ress = res
print(ress) | 1,700 | PYTHON3 |
n1=int(input())
sum1=0
a=n1
while(a>0):
sum1=sum1+1/a
a=a-1
print(sum1)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 23;
const int MOD = (int)1e9 + 7;
bool vis[101];
vector<int> p;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 2; i <= 100; i++) {
if (vis[i] == 0) {
for (int j = i * 2; j <= 100; j += i) {
vis[j] = true;
}
p.push_back(i);
}
}
bool found = 0;
int o;
string s;
for (int i : p) {
if (i > 10) break;
cout << i << endl;
cin >> s;
if (s[0] == 'y') {
found = true;
o = i;
break;
}
}
if (!found) {
cout << "prime" << endl;
return 0;
}
for (int i : p) {
if (i * o > 100) break;
cout << i * o << endl;
cin >> s;
if (s[0] == 'y') {
cout << "composite" << endl;
return 0;
}
}
cout << "prime" << endl;
return 0;
}
| 1,400 | CPP |
#include<bits/stdc++.h>
using namespace std;
const int maxN=100000+5;
const long long mod=998244353ll;
char tem[maxN];
long long fct[maxN];
long long inv[maxN];
int n;
int main()
{
int t,cnt;
inv[0]=1ll;
inv[1]=1ll;
fct[0]=1ll;
fct[1]=1ll;
for(int i=2;i<=100000;i++)
{
fct[i]=fct[i-1]*i;
fct[i]%=mod;
}
for(long long i=2;i<=100000;i++)
{
inv[i]=((mod-mod/i)*inv[mod%i])%mod;
inv[i]%=mod;
}
for(int i=2;i<=100000;i++)
{
inv[i]*=inv[i-1];
inv[i]%=mod;
}
scanf("%d",&t);
while(t--)
{
int zeo=0,one=0;
long long ans=1;
scanf("%d",&n);
scanf("%s",tem);
cnt=0;
for(int i=0;i<n;i++)
{
if(tem[i]=='0')zeo++,cnt=0;
else
{
cnt++;
if(cnt==2)
{
cnt=0;
one++;
}
}
}
ans*=fct[zeo+one];
ans%=mod;
ans*=inv[zeo];
ans%=mod;
ans*=inv[one];
ans%=mod;
printf("%lld\n",ans);
}
cout<<flush;
}
| 1,900 | CPP |
N = int(input())
a = list(map(int, input().split()))
odds = []
evens = []
for n in a:
if n % 2 == 0:
evens.append(n)
else:
odds.append(n)
odds.sort()
evens.sort()
lo = len(odds)
le = len(evens)
if abs(lo-le) < 1:
print(0)
exit(0)
if lo > le:
print(sum(odds[0:lo-le-1]))
else:
print(sum(evens[0:le-lo-1]))
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, t, m, i, j, x, l, r, y;
cin >> n >> k >> m >> t;
l = 1;
r = n;
int len = n;
for (i = 0; i < t; i++) {
cin >> j >> x;
if (j == 0) {
if (k > x) {
len = len - x;
k = k - x;
} else {
len = x;
}
cout << len << " " << k << endl;
} else {
if (k >= x && len < m) {
k++;
len++;
} else if (len < m) {
len++;
}
cout << len << ' ';
cout << k << endl;
}
}
}
| 1,600 | CPP |
#include <bits/stdc++.h>
const long long int MAX = (long long int)(1e18 + 1);
const long long int MIN = (long long int)(-1e18 - 1);
const long long int mod = (long long int)(1e9 + 7);
using namespace std;
long long int max(long long int a, long long int b, long long int c) {
return max(max(a, b), c);
}
long long int min(long long int a, long long int b, long long int c) {
return min(min(a, b), c);
}
long long int max(long long int a, long long int b) { return (a > b) ? a : b; }
long long int min(long long int a, long long int b) { return (a < b) ? a : b; }
long long int power(long long int a, long long int n) {
long long int p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long int power_mod(long long int a, long long int n, long long int mod_) {
long long int p = 1;
while (n) {
if (n % 2) {
p = (p * a) % mod_;
}
n /= 2;
a = (a * a) % mod_;
}
return p % mod_;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
long long int mn = MAX, mx = MIN;
long long int n, t, k, i, j, sum = 0, prev, flag = 0, cnt = 0;
long long int x = 0, y = 0, fx, diff, tot = 0, l, r;
int TC = 1;
cin >> TC;
while (TC--) {
cin >> n;
vector<long long int> a(n);
for (i = 0; i < n; i++) cin >> a[i];
sort((a).begin(), (a).end());
for (i = 0; i < n - 1; i++) {
if ((a[i + 1] - a[i]) % 2) {
cout << "NO\n";
break;
}
}
if (i == n - 1) cout << "YES\n";
}
return 0;
}
| 900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double EPS = (1e-10);
int main() {
int tc;
cin >> tc;
while (tc--) {
int n;
cin >> n;
vector<pair<int, int> > stud(n);
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
stud[i] = make_pair(a, b);
}
int ans[n];
ans[0] = stud[0].first;
int cs = ans[0] + 1;
for (int i = 1; i < n; i++) {
if (cs < stud[i].first) {
ans[i] = stud[i].first;
cs = ans[i] + 1;
} else {
if (cs <= stud[i].second) {
ans[i] = cs;
cs++;
} else {
ans[i] = 0;
}
}
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
}
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, i, j, l;
cin >> n >> k;
double a[n + 1], b, s = 0, r = -1;
a[0] = 0;
for (i = 1; i <= n; i++) {
cin >> b;
s += b;
a[i] = s;
}
for (i = k; i <= n; i++) {
l = 1;
for (j = i; j <= n; j++) {
r = max(r, (a[j] - a[l - 1]) / i);
l++;
}
}
printf("%.10f", r);
return 0;
}
| 1,300 | CPP |
q = int(input())
for _ in range(q):
n, x = map(int, input().split())
print(2*x) | 800 | PYTHON3 |
a = list(input())
print('CHAT WITH HER!') if len(set(a))%2 == 0 else print('IGNORE HIM!') | 800 | PYTHON3 |
n=int(input())
mas=[]
itog=[]
for i in range(n):
a=list(map(int,input().split()))
mas.append(a)
itog.append(1)
p=0
while len(itog)<n-1:
if (mas[p][1] in mas[mas[p][0]-1]):
itog.append(mas[p][0])
p=mas[p][0]-1
else:
itog.append(mas[p][1])
p=mas[p][1]-1
if (mas[p][1] in mas[mas[p][0]-1]) and not(mas[p][0] in itog):
itog.append(mas[p][0])
p=mas[p][0]-1
else:
itog.append(mas[p][1])
p=mas[p][1]-1
for i in itog:
print(i,end=" ")
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
enum { North, East, South, West };
int mi[] = {-1, 0, 1, 0, -1, 1, 1, -1};
int mj[] = {0, 1, 0, -1, 1, 1, -1, -1};
vector<int> graph[10000 + 35];
bool vis[10000 + 35];
int ans;
void dfs(int x) {
if (vis[x]) return;
vis[x] = true;
for (int i = 0; i < graph[x].size(); i++) {
int v = graph[x][i];
ans += graph[v].size() - 1;
dfs(v);
}
}
void init() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
cout << "[FREOPEN]" << endl;
return;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--, y--;
graph[x].push_back(y);
graph[y].push_back(x);
}
ans = 0;
for (int i = 0; i < n; i++) dfs(i);
printf("%d\n", ans / 2);
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using pii = pair<int, int>;
using vi = vector<int>;
mt19937 mrand(time(0));
ll get(ll r) { return ((ll)mrand() * mrand() % r + r) % r; }
ll get(ll l, ll r) { return get(r - l + 1) + l; }
const int P = 998244353;
int qpow(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % P;
a = 1ll * a * a % P;
b >>= 1;
}
return ret;
}
signed main() {
int n, m;
cin >> n >> m;
int ex = (1ll * n * qpow(m + 1, P - 2) + 1) % P;
int k = 0;
for (int i = 1; i <= n; i++) k = (k + qpow(i, P - 2)) % P;
k = 1ll * k * m % P;
k++;
printf("%d\n", 1ll * ex * k % P);
fprintf(stderr, "time=%.4f\n", (db)clock() / CLOCKS_PER_SEC);
return 0;
}
| 3,000 | CPP |
import os
import sys
from io import BytesIO, IOBase
# --------------------------------- SOLUTION ---------------------------------
def main():
n, m, k, t = map(int, input().split())
wastes = []
for _ in range(k):
a, b = map(int, input().split())
wastes.append((a-1,b-1))
wastes.sort()
queries = []
for _ in range(t):
i, j = map(int, input().split())
queries.append((i-1,j-1))
queries_copy = queries.copy()
queries_copy.sort()
queries_d = {}
waste_count = 0
for query in queries_copy:
while waste_count < k and wastes[waste_count] < query:
waste_count += 1
if waste_count < k and wastes[waste_count] == query:
queries_d[query] = 'Waste'
else:
plant = (query[0]*m + query[1] - waste_count) % 3
if plant == 0:
queries_d[query] = 'Carrots'
elif plant == 1:
queries_d[query] = 'Kiwis'
elif plant == 2:
queries_d[query] = 'Grapes'
for query in queries:
print(queries_d[query])
# --------------------------------- FAST IO ---------------------------------
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# --------------------------------- MAIN ---------------------------------
if __name__ == "__main__":
main() | 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int h[200010];
long long int dp[200010], temp[200010];
int main() {
scanf("%d %d", &n, &k);
int minn = 1e9;
int maxx = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &h[i]);
temp[h[i]]++;
minn = min(minn, h[i]);
maxx = max(maxx, h[i]);
}
for (int i = maxx; i >= 1; i--) {
temp[i] = temp[i] + temp[i + 1];
dp[i] = temp[i] + dp[i + 1];
}
int last = -1;
int answer = 0;
long long int cost = 0;
for (int i = maxx; i > minn; i--) {
if (dp[i] - cost > k) {
cost = dp[i + 1];
answer++;
last = i + 1;
} else if (dp[i] - cost == k) {
cost = dp[i];
answer++;
last = i;
}
}
if (last != minn + 1 && minn != maxx) answer++;
printf("%d", answer);
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1000000000")
long long binpo(long long a, long long b) {
if (b == 0) return 1;
long long c = binpo(a, b / 2);
if (b & 1) return c * c % (long long)1000000007 * a % (long long)1000000007;
return c * c % (long long)1000000007;
}
long long bk(long long n, long long k) {
if (n < 0 || k > n || k < 0) return 0;
if (n - k < k) return bk(n, n - k);
long long a = 1, b = 1;
for (long long i = n - k + 1; i <= n; ++i) a = a * i % (long long)1000000007;
for (long long i = 1; i <= k; ++i) b = b * i % (long long)1000000007;
return a * binpo(b, (long long)1000000007 - 2) % (long long)1000000007;
}
bool chk(long long n) {
while (n) {
if (n % 10 != 4 && n % 10 != 7) return 0;
n /= 10;
}
return 1;
}
static long long m1[1000000], m2[1000000], m3[1200];
static vector<long long> vc;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k, al = 0;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> m1[i];
if (chk(m1[i])) vc.push_back(m1[i]);
}
al = vc.size();
sort(vc.begin(), vc.end());
vc.resize(unique(vc.begin(), vc.end()) - vc.begin());
for (int i = 0; i < n; ++i)
if (chk(m1[i])) {
m2[lower_bound(vc.begin(), vc.end(), m1[i]) - vc.begin()]++;
}
m3[0] = 1;
for (int i = 0; i < vc.size(); ++i) {
for (int j = i; j >= 0; --j)
m3[j + 1] = (m3[j + 1] + m3[j] * m2[i]) % (long long)1000000007;
}
long long res = 0;
for (int i = 0; i <= vc.size(); ++i)
res = (res + m3[i] * bk(n - al, k - i)) % (long long)1000000007;
cout << res << endl;
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double P = 3.141592653589793;
int n, m;
string s[2000];
int tl[2000][2000], tr[2000][2000], dl[2000][2000], dr[2000][2000];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
long long ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
tl[i][j] = tr[i][j] = dl[i][j] = dr[i][j] = 1;
}
}
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
if (s[i][j] == s[i - 1][j] and s[i][j] == s[i][j - 1]) {
tl[i][j] = min(tl[i - 1][j], tl[i][j - 1]) + 1;
}
}
}
for (int i = 1; i < n; i++) {
for (int j = m - 2; j >= 0; j--) {
if (s[i][j] == s[i - 1][j] and s[i][j] == s[i][j + 1]) {
tr[i][j] = min(tr[i - 1][j], tr[i][j + 1]) + 1;
}
}
}
for (int i = n - 2; i >= 0; i--) {
for (int j = 1; j < m; j++) {
if (s[i][j] == s[i + 1][j] and s[i][j] == s[i][j - 1]) {
dl[i][j] = min(dl[i + 1][j], dl[i][j - 1]) + 1;
}
}
}
for (int i = n - 2; i >= 0; i--) {
for (int j = m - 2; j >= 0; j--) {
if (s[i][j] == s[i + 1][j] and s[i][j] == s[i][j + 1]) {
dr[i][j] = min(dr[i + 1][j], dr[i][j + 1]) + 1;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ans += min({tl[i][j], tr[i][j], dl[i][j], dr[i][j]});
}
}
cout << ans << endl;
return 0;
}
| 2,100 | CPP |
n,m=[int(i) for i in input().split()]
l=[int(i) for i in input().split()]
l.sort()
if m==n:
print(max(l)-min(l))
else:
d=[]
for i in range(m-n+1):
d.append(l[i+n-1]-l[i])
print(min(d)) | 900 | PYTHON3 |
import math
from collections import defaultdict
for _ in range(int(input())):
n=int(input())
temp=(n//2)+1
print(n-temp)
| 800 | PYTHON3 |
n = int(input())
leng = list(map(int, input().split()))
energy = list(map(int, input().split()))
sum = 0
lenSum = {}
lenCount = {}
custos = {}
for i in range(n):
length, custo = leng[i], energy[i]
sum += custo
lenSum[length] = lenSum.setdefault(length, 0) + custo
lenCount[length] = lenCount.setdefault(length, 0) + 1
custos.setdefault(custo, []).append(length)
conjuntoLen = set(leng)
for leng in custos.values():
leng.sort()
listaEnergia = list(reversed(sorted(custos.keys())))
ans = -1
for length in conjuntoLen:
total = sum - lenSum[length]
find = lenCount[length] - 1
if find != 0:
for custo in listaEnergia:
for x in custos[custo]:
if x >= length:
break
total -= custo
find -= 1
if find == 0:
break
if find == 0:
break
if ans == -1 or total < ans:
ans = total
print(ans)
| 1,900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool check(long long int k, long long int n, long long int a, long long int b,
long long int val) {
long long int tot = 0;
k -= a * val;
if (k < 0) return false;
if (k == 0) {
return false;
}
tot += val;
tot += k / b;
k = k % b;
if (k == 0) tot--;
if (tot >= n) return true;
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long int k, n, a, b;
cin >> k >> n >> a >> b;
long long int ans = -1;
long long int l = 0, r = 1e9 + 10;
while (l <= r) {
long long int mid = (l + r) / 2;
if (check(k, n, a, b, mid)) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
if (ans == -1)
cout << ans << '\n';
else
cout << min(ans, n) << '\n';
}
return 0;
}
| 1,400 | CPP |
from collections import *
import sys
# "". join(strings)
def ri():
return int(input())
def rl():
return list(map(int, input().split()))
t = ri()
for _ in range(t):
n = ri()
str = input()
sens_unique = 1;
#test for circular
direction = '-';
for thing in str:
if thing != direction:
direction = thing
break
for thing in str:
if thing != direction and thing != '-':
sens_unique = 0;
if sens_unique == 1:
print(n)
continue
good_spots = set()
for i in range(n):
if str[i] == '-':
good_spots.add(i)
good_spots.add((i + 1)%n)
print(len(good_spots)) | 1,200 | PYTHON3 |
Subsets and Splits