solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m, s, t;
long long d1[100002], d2[100002], sl1[100002], sl2[100002];
vector<pair<int, long long> > ke1[2 * 100002], ke2[2 * 100002];
struct dd {
int u, v;
long long l;
};
dd way[2 * 100002];
void in() {
cin >> n >> m >> s >> t;
int u, v;
long long l;
for (int i = 1; i <= m; i++) {
cin >> u >> v >> l;
ke1[u].push_back(make_pair(v, l));
ke2[v].push_back(make_pair(u, l));
way[i].u = u;
way[i].v = v;
way[i].l = l;
}
}
bool check(long long a, long long b, long long c) {
long long aa = a;
long long bb = b;
long long cc = c;
aa = aa % 116547253;
bb = bb % 116547253;
long long ab = (aa * bb) % 116547253;
if (ab == cc % 116547253) return true;
return false;
}
void IJK(vector<pair<int, long long> > ke[], long long d[], long long sl[],
int S) {
memset(sl, 0, sizeof(sl));
priority_queue<pair<long long, int> > P;
for (int i = 1; i <= n; i++) d[i] = 1e18 + 1;
d[S] = 0;
sl[S] = 1;
P.push(make_pair(0, S));
while (!P.empty()) {
int u = P.top().second;
long long ll = -P.top().first;
P.pop();
if (d[u] != ll) continue;
for (int i = 0; i < ke[u].size(); i++) {
int v = ke[u][i].first;
long long l = ke[u][i].second;
if (d[v] > d[u] + l) {
d[v] = d[u] + l;
sl[v] = sl[u];
P.push(make_pair(-d[v], v));
} else {
if (d[v] == d[u] + l) {
sl[v] += sl[u] % 116547253;
sl[v] = sl[v] % 116547253;
}
}
}
}
}
void Solve_() {
IJK(ke1, d1, sl1, s);
IJK(ke2, d2, sl2, t);
long long minway = d1[t];
for (int i = 1; i <= m; i++) {
int u = way[i].u;
int v = way[i].v;
long long l = way[i].l;
if (d1[u] + l + d2[v] == minway) {
if (check(sl1[u], sl2[v], sl1[t])) {
cout << "YES" << endl;
continue;
}
}
if (d1[u] + l + d2[v] >= minway) {
if (d1[u] + l + d2[v] - minway + 1 >= l)
cout << "NO" << endl;
else
cout << "CAN"
<< " " << d1[u] + l + d2[v] - minway + 1 << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
in();
Solve_();
return 0;
}
| 2,200 |
CPP
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,-ffloat-store")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
using namespace std;
const int xbit = (1 << 18) + 5;
const int maxn = 20;
long long dp[xbit][maxn], g[maxn][xbit], res[xbit], cur[xbit], pre[20][xbit];
int n, a[maxn][maxn], x[20];
map<vector<int>, vector<int> > state;
vector<int> arr;
void readf() {
cin >> n;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
char ch;
cin >> ch;
a[i][j] = (ch == '1');
}
}
void trys(int i, int sum) {
if (sum == n) {
long long ans = 0;
int full = (1 << n) - 1;
for (int mask = 0; mask < (1 << n); ++mask)
if (__builtin_popcount((mask)) & 1)
ans -= cur[full ^ mask];
else
ans += cur[full ^ mask];
for (auto mask : state[arr]) res[mask] += ans;
return;
}
for (int mask = 0; mask < (1 << n); ++mask) pre[i][mask] = cur[mask];
for (int j = x[i - 1]; j + sum <= n; ++j) {
if (sum + j != n && sum + j + j > n) continue;
x[i] = j;
for (int mask = 0; mask < (1 << n); ++mask) cur[mask] *= g[x[i]][mask];
arr.emplace_back(x[i]);
trys(i + 1, j + sum);
for (int mask = 0; mask < (1 << n); ++mask) cur[mask] = pre[i][mask];
arr.pop_back();
}
}
void solve() {
for (int u = 1; u <= n; ++u) dp[1 << u - 1][u] = 1;
for (int mask = 0; mask < (1 << n); ++mask)
for (int u = 0; u < n; ++u)
if ((((mask) >> (u)) & 1))
for (int v = 0; v < n; ++v)
if (a[u + 1][v + 1] && (((mask) >> (v)) & 1) == 0)
dp[mask ^ (1 << v)][v + 1] += dp[mask][u + 1];
for (int mask = 0; mask < (1 << n); ++mask)
for (int u = 1; u <= n; ++u)
g[__builtin_popcount((mask))][mask] += dp[mask][u];
for (int len = 1; len <= n; ++len)
for (int i = 0; i < n; ++i)
for (int mask = 0; mask < (1 << n); ++mask)
if ((((mask) >> (i)) & 1)) g[len][mask] += g[len][mask ^ (1 << i)];
for (int mask = 0; mask < (1 << n - 1); ++mask) {
vector<int> tmp;
int sz = 0;
for (int i = 0; i + 1 < n; ++i)
if ((((mask) >> (i)) & 1)) {
int len = 1;
while (i + 1 < n && (((mask) >> (i)) & 1)) {
i++;
len++;
}
tmp.emplace_back(len);
sz += len;
}
while (sz < n) tmp.emplace_back(1), sz++;
sort(tmp.begin(), tmp.end());
state[tmp].emplace_back(mask);
}
x[0] = 1;
for (int mask = 0; mask < (1 << n); ++mask) cur[mask] = 1;
trys(1, 0);
for (int i = 0; i < n - 1; ++i)
for (int mask = 0; mask < (1 << n - 1); ++mask)
if (!(((mask) >> (i)) & 1)) res[mask] -= res[mask ^ (1 << i)];
for (int mask = 0; mask < (1 << n - 1); ++mask) cout << res[mask] << ' ';
}
int main() {
srand(time(NULL));
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
readf();
solve();
}
| 3,200 |
CPP
|
x=int(input())
if x==2:
print("no")
else:
if x%2==0:
print (" yes")
else:
print("no")
| 800 |
PYTHON3
|
##__________________________________________________________________
##
## Author: GogolGrind
##__________________________________________________________________
from sys import *
from math import *
def main ():
k = int(input())
d = {}
m = -1
names = []
scores = []
for i in range(k):
n,s = list(map(str,input().split()))
s = int(s)
names.append(n)
scores.append(s)
if (d.get(n) == None):
d[n] = s
else:
d[n] += s
winn = []
for k,v in d.items():
m = max(m,v)
for n,s in zip(names,scores):
if (d[n] == m):
winn.append(n)
d = {}
winn = set(winn)
for n,s in zip(names,scores):
if (n in winn):
if (d.get(n) == None):
d[n] = 0
d[n] += s
if (d[n] >= m):
print(n)
return 0
if __name__ == '__main__':
main()
| 1,500 |
PYTHON3
|
#include <bits/stdc++.h>
const int MAXS = 100;
char buffer[MAXS];
int main() {
bool normal = false;
for (int i = 0; i < 10; ++i) {
std::printf("%d\n", i);
std::fflush(stdout);
std::fgets(buffer, sizeof(buffer), stdin);
if (std::strstr(buffer, "great") || std::strstr(buffer, "think") ||
std::strstr(buffer, "touch") || std::strstr(buffer, "bad") ||
std::strstr(buffer, "cool")) {
normal = true;
break;
} else if (std::strstr(buffer, "way") || std::strstr(buffer, "even") ||
std::strstr(buffer, "serious") || std::strstr(buffer, "die") ||
std::strstr(buffer, "worse") || std::strstr(buffer, "terrible"))
break;
}
std::puts(normal ? "normal" : "grumpy");
}
| 1,900 |
CPP
|
n,k1=map(int,input().split())
li=list(map(int,input().split()))
d={}
for i in li:
k=0
while i!=0:
try:
d[i].append(k)
except KeyError:
d[i]=[k]
k+=1
i=i//2
mi=100000000
for i in d.values():
if len(i)>=k1:
i.sort()
mi=min(mi,sum(i[:k1]))
print(mi)
| 1,500 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
const long long int maxn = 3e5 + 16, md = 1e9 + 7, inf = 2e16;
long long int gcd(long long int a, long long int b) {
if (a < b) swap(a, b);
if (b == 0) return a;
return gcd(b, a % b);
}
long long int tav(long long int n, long long int k) {
long long int res = 1;
while (k > 0) {
if (k & 1) {
res *= n;
res %= md;
}
n *= n;
n %= md;
k >>= 1;
}
return res;
}
struct segtree {
long long int sz = 1;
vector<vector<long long int>> val;
vector<long long int> res;
void init(long long int n) {
while (sz < n) sz <<= 1;
val.resize(sz << 1);
return;
}
void add(long long int l, long long int r, long long int k, long long int x,
long long int lx, long long int rx) {
if (rx <= l || lx >= r) return;
if (rx <= r && lx >= l) {
val[x].push_back(k);
return;
}
long long int m = (rx + lx) >> 1, ln = (x << 1) + 1, rn = ln + 1;
add(l, r, k, ln, lx, m);
add(l, r, k, rn, m, rx);
return;
}
void add(long long int l, long long int r, long long int k) {
add(l, r, k, 0, 0, sz);
return;
}
void cal(long long int i, long long int x, long long int lx,
long long int rx) {
for (auto v : val[x]) {
res.push_back(v);
}
val[x].clear();
if (rx - lx == 1) return;
long long int m = (rx + lx) >> 1, ln = (x << 1) + 1, rn = ln + 1;
if (i < m) {
cal(i, ln, lx, m);
} else {
cal(i, rn, m, rx);
}
return;
}
void cal(long long int i) {
res.clear();
cal(i, 0, 0, sz);
return;
}
};
segtree st;
long long int a[maxn], b[maxn], dp[maxn], par[maxn];
vector<long long int> adj[maxn], u;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(dp, 63, sizeof(dp));
long long int n;
cin >> n;
st.init(n + 1);
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
st.add(i - a[i], i + 1, i);
}
for (long long int i = 1; i <= n; i++) {
cin >> b[i];
long long int h = i + b[i];
adj[h].push_back(i);
}
adj[0].push_back(0);
u.push_back(0);
dp[0] = 0;
long long int x = 0;
while (x < (long long int)(u.size())) {
long long int v = u[x++];
for (auto i : adj[v]) {
st.cal(i);
for (auto j : st.res) {
if (dp[j] > dp[v] + 1) {
dp[j] = dp[v] + 1;
u.push_back(j);
par[j] = i;
}
}
}
}
if (dp[n] > n) {
cout << "-1\n";
return 0;
}
cout << dp[n] << '\n';
long long int h = n;
while (h > 0) {
cout << par[h] << ' ';
h = par[h];
h += b[h];
}
cout << '\n';
return 0;
}
| 1,900 |
CPP
|
t = int(input())
while(t>0):
n=int(input())
a=list(map(int,input().split()))
a = list(dict.fromkeys(a))
print(len(a))
t-=1
| 800 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int n, m, L, s, t, u[20005], v[20005];
long long ow[20005], w[20005];
vector<int> G[1005];
long long d[1005];
long long dijkstra() {
for (int i = 0; i < n; i++) d[i] = 1LL << 50;
priority_queue<pair<long long, int> > q;
d[s] = 0;
q.push({0, s});
while (!q.empty()) {
pair<long long, int> t = q.top();
q.pop();
for (int j : G[t.second]) {
if (-t.first + w[j] < d[v[j]]) {
d[v[j]] = -t.first + w[j];
q.push({-d[v[j]], v[j]});
}
}
}
return d[t];
}
int main() {
scanf("%d %d %d %d %d", &n, &m, &L, &s, &t);
for (int i = 0; i < m; i++) {
scanf("%d %d %I64d", &u[i], &v[i], &ow[i]);
v[i + m] = u[i];
u[i + m] = v[i];
ow[i + m] = ow[i];
G[u[i]].push_back(i);
G[v[i]].push_back(i + m);
}
for (int i = 0; i < 2 * m; i++) {
if (ow[i] == 0)
w[i] = 1;
else
w[i] = ow[i];
}
long long lowerbound = dijkstra();
for (int i = 0; i < 2 * m; i++) {
if (ow[i] == 0)
w[i] = 1LL << 50;
else
w[i] = ow[i];
}
long long upperbound = dijkstra();
if ((L < lowerbound) || (upperbound < L)) {
printf("NO\n");
return 0;
}
int Li = 0, Ri = m - 1;
while (Li <= Ri) {
int mid = (Li + Ri) / 2;
for (int i = 0; i < m; i++) {
if (ow[i] != 0) {
w[i] = ow[i];
w[i + m] = ow[i];
continue;
}
if (i >= mid) {
w[i] = w[i + m] = 1;
} else {
w[i] = w[i + m] = 1LL << 50;
}
}
long long L_ = dijkstra();
if (L_ == L) break;
if (L_ > L) {
Ri = mid - 1;
} else {
w[mid] = w[mid + m] += L - L_;
L_ = dijkstra();
if (L_ == L)
break;
else {
Li = mid + 1;
}
}
}
printf("YES\n");
for (int i = 0; i < m; i++) printf("%d %d %I64d\n", u[i], v[i], w[i]);
return 0;
}
| 2,300 |
CPP
|
#https://codeforces.com/problemset/problem/112/A
s=input()
a=input()
s=s.lower()
a=a.lower()
if(s>a):
print(1)
elif(s<a):
print(-1)
else:
print(0)
| 800 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
set<long long int> s;
bool ar[100001];
void seive() {
ar[0] = ar[1] = true;
for (long long int p = 2; p * p <= 100001; p++) {
if (ar[p] == false) {
for (long long int i = p * p; i <= 100001; i += p) ar[i] = true;
}
}
for (long long int p = 2; p <= 100001; p++) {
if (ar[p] == false) s.insert(p);
}
}
bool is_palindrome(string str) {
long long int len = str.length();
for (long long int i = 0; i <= len / 2; i++) {
if (str[i] != str[len - 1 - i]) return false;
}
return true;
}
long long int binexpo(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void solve() {
long long int n, k;
cin >> n >> k;
vector<long long int> v(n);
vector<double> prefix;
for (long long int i = 0; i < n; i++) cin >> v[i];
prefix.push_back(v[0]);
double sum = v[0];
for (long long int i = 1; i < n; i++) {
sum += v[i];
prefix.push_back(sum);
}
long long int start;
double ans, mx = 0.0000000;
for (long long int i = k; i <= n; i++) {
start = 0;
for (long long int j = i - 1; j < n; j++) {
if (j == i - 1) {
ans = prefix[j] / i;
if (ans > mx) mx = ans;
} else {
ans = (prefix[j] - prefix[start]) / i;
start++;
if (ans > mx) mx = ans;
}
}
}
std::cout << std::fixed;
std::cout << std::setprecision(6);
(mx);
cout << mx;
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
solve();
return 0;
}
| 1,300 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n - 1], i, d1, d2, c1 = 0, c2 = 0;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
if (n == 1) {
cout << -1;
return 0;
}
for (i = 1; i < n; i++) b[i - 1] = a[i] - a[i - 1];
sort(b, b + n - 1);
vector<int> v;
v.push_back(b[0]);
for (i = 1; i < n - 1; i++) {
if (b[i - 1] != b[i]) v.push_back(b[i]);
}
if (n == 2 && v[0] != 0) {
if ((a[1] + a[0]) % 2 == 0) {
cout << 3 << endl;
cout << a[0] - v[0] << " " << (a[1] + a[0]) / 2 << " ";
cout << a[n - 1] + v[0] << endl;
return 0;
}
}
if (v.size() == 1) {
if (v[0] == 0) {
cout << 1 << endl << a[0] << endl;
} else {
cout << 2 << endl << a[0] - v[0] << " " << a[n - 1] + v[0] << endl;
}
} else if (v.size() >= 3) {
cout << 0 << endl;
} else {
d1 = v[0];
d2 = v[1];
for (i = 0; i < n - 1; i++)
if (b[i] == d1)
c1++;
else
c2++;
if (c1 > c2) {
if (d2 / 2 == d1 && d2 % 2 == 0 && c2 == 1) {
cout << 1 << endl;
for (i = 1; i < n; i++)
if (a[i] - a[i - 1] == d2) break;
cout << a[i - 1] + d1 << endl;
} else
cout << 0 << endl;
} else if (c2 > c1) {
if (d1 / 2 == d2 && d1 % 2 == 0 && c1 == 1) {
cout << 1 << endl;
for (i = 1; i < n; i++)
if (a[i] - a[i - 1] == d1) break;
cout << a[i - 1] + d2 << endl;
} else
cout << 0 << endl;
} else {
if (d1 > d2) {
if (d1 / 2 == d2 && d1 % 2 == 0 && c1 == 1) {
cout << 1 << endl;
for (i = 1; i < n; i++)
if (a[i] - a[i - 1] == d1) break;
cout << a[i - 1] + d2;
} else
cout << 0 << endl;
} else {
if (d2 / 2 == d1 && d2 % 2 == 0 && c2 == 1) {
cout << 1 << endl;
for (i = 1; i < n; i++)
if (a[i] - a[i - 1] == d2) break;
cout << a[i - 1] + d1;
} else
cout << 0 << endl;
}
}
}
return 0;
}
| 1,700 |
CPP
|
q = int(input())
for re in range(q):
s = input()
dob = set()
n = len(s)
s = '0' + s + '0'
i = 1
while i < n + 2:
pocz = s[i]
i += 1
dupa = 1
while True:
if i == n + 2:
break
if s[i] == pocz:
dupa += 1
i += 1
else:
break
if dupa % 2 == 1:
dob.add(pocz)
l = []
for i in dob:
if i != '0':
l.append(i)
l.sort()
if len(l) == 0:
print("")
else:
for i in range(len(l)):
if i < len(l) - 1:
print(l[i], end = "")
else:
print(l[i])
| 1,000 |
PYTHON3
|
def solve():
n = int(input())
a = list(map(int, input().split()))
a.sort()
for i in range(n-1, -1, -1):
if a[i] <= i + 1:
print(i + 2)
return
print(1)
t = int(input())
while t != 0:
solve()
t = t-1
| 1,000 |
PYTHON3
|
I=input
n,m=map(int,I().split())
b=[1]*n*2
b[0]=b[n-1]=b[n]=b[2*n-1]=0
for i in range(m):
r,c=map(int,I().split())
b[r-1]=b[n+c-1]=0
if n%2 and b[n//2] and b[n+n//2]:b[n//2]=0
print(sum(b))
| 1,800 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << "\t|";
__f(comma + 1, args...);
}
const int MOD = 1e9 + 7;
long long mod(long long a) { return (long long)(a % MOD + MOD) % MOD; }
long long mul(long long a, long long b) {
return (long long)mod(mod(a) * mod(b));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long n, k, z;
cin >> n >> k >> z;
vector<int> a(n), pre(n);
for (int i = 0; i < n; i++) cin >> a[i];
pre[0] = a[0];
for (int i = 1; i < n; i++) pre[i] = a[i] + pre[i - 1];
k++;
long long ans = pre[k - 1];
for (int i = 0; i < n - 1; i++) {
if (i + 2 > k) break;
long long cur = pre[i + 1];
long long taken = i + 2;
long long temp = ceil((k - taken) / 2.0);
long long l_max = min(temp, z);
cur += a[i] * l_max;
long long rem = k - taken - l_max;
if (rem == l_max - 1) {
cur += a[i + 1] * (l_max - 1);
rem = 0;
} else if (rem >= l_max) {
cur += a[i + 1] * l_max;
rem -= l_max;
}
if (rem) cur += pre[i + rem + 1] - pre[i + 1];
ans = max(ans, cur);
}
cout << ans << '\n';
}
return 0;
}
| 1,600 |
CPP
|
def f(n,a):
if n % a == 0:
return n // a
return n // a + 1
n, m, a = map(int, input().split(' '))
print (f(n,a)*f(m,a))
| 1,000 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y, n;
cin >> x >> y >> n;
long long t;
if (n < y)
t = abs(y - n);
else
t = 0;
double m = INT_MAX;
long long p, q;
if (x < y) {
while (y - t > 0) {
long long i = t * x / y;
double a;
long long u, l;
if (abs(double(x - i - 1) / (y - t) - double(x) / y) <=
abs(double(x - i) / (y - t) - double(x) / y)) {
a = abs(double(x - i - 1) / (y - t) - double(x) / y);
u = x - i - 1;
l = y - t;
} else {
a = abs(double(x - i) / (y - t) - double(x) / y);
u = x - i;
l = y - t;
}
if (a < m) {
m = a;
p = u;
q = l;
} else if (a == m) {
if (q > l) {
p = u;
q = l;
}
}
t++;
}
} else {
while (y - t > 0) {
long long i = ceil(double(t * x) / y);
double a;
long long u, l;
if (abs(double(x - i + 1) / (y - t) - double(x) / y) >=
abs(double(x - i) / (y - t) - double(x) / y)) {
a = abs(double(x - i) / (y - t) - double(x) / y);
u = x - i;
l = y - t;
} else {
a = abs(double(x - i + 1) / (y - t) - double(x) / y);
u = x - i + 1;
l = y - t;
}
if (a < m) {
m = a;
p = u;
q = l;
} else if (a == m) {
if (q > l) {
p = u;
q = l;
}
}
t++;
}
}
cout << p << "/" << q << endl;
}
| 1,700 |
CPP
|
import math
import sys
def calc_dist(x1,x2,y1,y2):
dist=math.sqrt((pow(x2-x1,2))+pow(y2-y1,2))
return dist
a,b=map(int,input().split())
n=int(input())
time=sys.maxsize
for _ in range(n):
x,y,v=map(int,input().split())
distance=calc_dist(x,a,y,b)
time=min(time,(distance/v))
print(time)
| 900 |
PYTHON3
|
#include <bits/stdc++.h>
template <typename Tp>
void read(Tp &res) {
static char ch;
static bool flag;
ch = getchar(), flag = 0, res = 0;
while (!std::isdigit(ch)) flag = (ch == '-'), ch = getchar();
while (std::isdigit(ch)) res = res * 10 + ch - 48, ch = getchar();
if (flag) res = -res;
}
void read(char *s) {
static char ch;
ch = getchar();
while (!std::isalpha(ch)) ch = getchar();
while (std::isalpha(ch)) *(s++) = ch, ch = getchar();
*s = '\0';
}
std::mt19937_64 __rng(std::time(0));
template <typename Tp>
Tp rnd(const Tp &l, const Tp &r) {
return std::uniform_int_distribution<Tp>(l, r)(__rng);
}
template <typename Tp>
Tp frnd(const Tp &l, const Tp &r) {
return std::uniform_real_distribution<Tp>(l, r)(__rng);
}
const int maxn = 2e3 + 19, mod = 998244353;
int n, k, h[maxn], cnt, dp[maxn][maxn << 1];
int main() {
read(n), read(k);
for (int i = 1; i <= n; ++i) read(h[i]);
if (k == 1) {
std::puts("0");
return 0;
}
for (int i = 1; i <= n; ++i) {
if (h[i] == h[i % n + 1])
continue;
else
++cnt;
}
dp[0][cnt] = 1;
for (int i = 1; i <= cnt; ++i)
for (int j = -i; j <= i; ++j) {
if (j <= i - 1 && j >= -(i - 1))
dp[i][j + cnt] = (std::int_fast64_t)dp[i - 1][j + cnt] * (k - 2) % mod;
if (j + 1 <= i - 1 && j + 1 >= -(i - 1))
dp[i][j + cnt] = (dp[i][j + cnt] + dp[i - 1][j + cnt + 1]) % mod;
if (j - 1 <= i - 1 && j - 1 >= -(i - 1))
dp[i][j + cnt] = (dp[i][j + cnt] + dp[i - 1][j + cnt - 1]) % mod;
}
int ans = 0;
for (int i = 1; i <= cnt; ++i) ans = (ans + dp[cnt][i + cnt]) % mod;
for (int i = 1; i <= n - cnt; ++i) ans = (std::int_fast64_t)ans * k % mod;
std::printf("%d\n", ans);
}
| 2,200 |
CPP
|
import sys
import os
import time
import collections
from collections import Counter, deque
import itertools
import math
import timeit
import random
from io import BytesIO, IOBase
from bisect import bisect_left as bl
from bisect import bisect_right as br
#########################
# imgur.com/Pkt7iIf.png #
#########################
def sieve(n):
if n < 2: return list()
prime = [True for _ in range(n + 1)]
p = 3
while p * p <= n:
if prime[p]:
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 2
r = [2]
for p in range(3, n + 1, 2):
if prime[p]:
r.append(p)
return r
def divs(n, start=1):
divisors = []
for i in range(start, int(math.sqrt(n) + 1)):
if n % i == 0:
if n / i == i:
divisors.append(i)
else:
divisors.extend([i, n // i])
return divisors
def divn(n, primes):
divs_number = 1
for i in primes:
if n == 1:
return divs_number
t = 1
while n % i == 0:
t += 1
n //= i
divs_number *= t
def flin(d, x, default=-1):
left = right = -1
for i in range(len(d)):
if d[i] == x:
if left == -1: left = i
right = i
if left == -1:
return (default, default)
else:
return (left, right)
def modpow(b,p,m):
res=1
b=b%m
while(p):
if p&1:
res=(res*b)%m
b=(b*b)%m
p>>=1
return res
def mod_inv(a,m):
return modpow(a,m-2,m)
def ncr(n,r,m):
res=1
if r==0:
return 1
if n-r<r:
r=n-r
p,k=1,1
while(r):
res=((res%m)*(((n%m)*mod_inv(r,m))%m))%m
n-=1
r-=1
return res
def ncrlis(n,r,m,fact):
return (fact[n]*(mod_inv(fact[r],m)*mod_inv(fact[n-r],m))%m)%m
def dfs(u,lis):
vis[u]=True
lis.append(u)
for v in g[u]:
if not vis[v]:
lis=dfs(v,lis)
return lis
def dfsutil():
cnc=[]
for i in range(1,n+1):
if not vis[i]:
tmp=[]
cnc.append(dfs(i,tmp))
return cnc
def bfs(s,prev):
q=deque()
q.append(s)
vis[s]=True
while q:
u=q.popleft()
for v in g[u]:
if not vis[v]:
q.append(v)
vis[v]=True
#lvl[v]=lvl[u]+1
prev[v]=u
def path(s,e):
prev=[False for i in range(n+1)]
bfs(s,prev)
at=e
res=[]
while at!=False:
res.append(at)
at=prev[at]
res.reverse()
if res[0]==s:
return res
else:
return []
def ceil(n, k): return n // k + (n % k != 0)
def ii(): return int(input())
def mi(): return map(int, input().split())
def li(): return list(map(int, input().split()))
def lcm(a, b): return abs(a * b) // math.gcd(a, b)
def prr(a, sep=' '): print(sep.join(map(str, a)))
def dd(): return collections.defaultdict(int)
def ddl(): return collections.defaultdict(list)
def ddd(): return collections.defaultdict(collections.defaultdict(int))
# region fastio
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")
mod= 998244353
n,k=mi()
a=li()
b=sorted(a,reverse=True)
d=dd()
for i in range(n):
d[a[i]]=i
sm,nm=0,[0 for i in range(k)]
for i in range(k):
sm+=b[i]
nm[i]=d[b[i]]
nm.sort()
res=1
for i in range(k-1):
res=(res*((nm[i+1]-nm[i])%mod))%mod
print(sm,res)
| 1,300 |
PYTHON3
|
import sys
def input(): return sys.stdin.readline().strip()
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)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10 ** 19
MOD = 10 ** 9 + 7
def digit_sum(S):
res = 0
for s in S:
res += int(s)
return res
MAX = 150
ans = list2d(MAX+1, 10, -1)
last = list2d(10, 10, 0)
for i in range(10):
for j in range(i, i+10):
cnt = 0
for k in range(i, j+1):
k %= 10
cnt += k
last[i][j%10] = cnt
for i in range(MAX+1):
s = ''
tmp = i
while tmp-9 >= 0:
s += '9'
tmp -= 9
if tmp:
s += str(tmp)
s = s[::-1]
for j in range(10):
cnt = i * (j+1)
if cnt > MAX:
break
for k in range(10):
if k+j >= 10:
break
res = cnt + last[k][k+j]
if res <= MAX:
if ans[res][j] == -1 or ans[res][j] > int(s+str(k)):
ans[res][j] = int(s+str(k))
for i in range(MAX+1):
x = 0
while x*9 <= i:
tmp = i
s1 = '9' * x
tmp -= x * 9
if tmp-8 >= 0:
s1 += '8'
tmp -= 8
while tmp-9 >= 0:
s1 += '9'
tmp -= 9
if tmp:
s1 += str(tmp)
if not s1:
s1 = '0'
s1 = s1[::-1]
s2 = str(int(s1)+1)
dsm1 = digit_sum(s1)
dsm2 = digit_sum(s2)
for j in range(1, 10):
for k in range(10):
if k+j < 10:
continue
a = 10 - k
b = (j+1) - a
cnt = dsm1 * a + dsm2 * b
if cnt > MAX:
continue
if k+j < 10:
continue
res = cnt + last[k][(k+j)%10]
if res <= MAX:
if ans[res][j] == -1 or ans[res][j] > int(s1+str(k)):
ans[res][j] = int(s1+str(k))
x += 1
for _ in range(INT()):
N, K = MAP()
print(ans[N][K])
| 2,200 |
PYTHON3
|
def long_word(string):
if len(string)>10:
return string[0]+str(len(string)-2)+string[len(string)-1]
else:
return string
test_cases=int(input())
n=0
while n!=test_cases:
string1=input()
print(long_word(string1))
n+=1
| 800 |
PYTHON3
|
from sys import stdin,stdout
from math import *
input = stdin.readline
# print=stdout.write
n,k=map(int,input().split())
m=list(map(int,input().split()))
c=list(map(int,input().split()))
for i in range(1,k):
if(c[i]>c[i-1]):
c[i]=c[i-1]
m.sort()
h=[0]*(k)
for i in range(n):
h[m[i]-1]+=1
for i in range(k-2,-1,-1):
h[i]+=h[i+1]
ans=0
for i in range(k):
ans=max(ceil(h[i]/c[i]),ans)
rslt=[[] for i in range(ans)]
for i in range(n):
rslt[i%ans].append(m[i])
print(ans)
for i in range(ans):
print(len(rslt[i]),*rslt[i])
# print(*rslt[i])
| 1,900 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int m, n, t, q, r, w, a, b;
int p[3000], cnt[3000] = {0};
bool ok[3000];
int find(int x) { return x == p[x] ? x : (p[x] = find(p[x])); }
void uni(int x, int y) { p[find(x)] = find(y); }
bool eqi(int x, int y) { return find(x) == find(y); }
int main() {
for (int i = 0; i < 3000; i++) {
ok[i] = 1;
p[i] = i;
}
scanf("%d", &t);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a, &b);
uni(a, b);
}
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
if (eqi(a, b)) {
ok[find(a)] = 0;
}
}
for (int i = 1; i <= t; i++) {
if (ok[find(i)]) cnt[find(i)]++;
}
int ret = 0;
for (int i = 1; i <= t; i++)
if (cnt[i] > ret) ret = cnt[i];
printf("%d\n", ret);
return 0;
}
| 1,500 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int c, id;
};
struct cmp {
bool operator()(const node &a, const node &b) { return a.c > b.c; }
};
priority_queue<node, vector<node>, cmp> q;
int t[101000], n, m, c[101000], w[101000], z[101000];
int main() {
scanf("%d%d", &n, &m);
long long ans = 0;
while (!q.empty()) q.pop();
for (int i = 1; i <= n; i++)
scanf("%d", &c[i]), t[i] = c[i], c[i] = (c[i] - 1) % 100 + 1;
for (int i = 1; i <= n; i++) scanf("%d", &w[i]);
int l = 1;
while (l <= n) {
m -= c[l];
q.push(node{(100 - c[l]) * w[l], l});
if (m < 0) {
m += 100;
ans += q.top().c;
z[q.top().id] = 1;
q.pop();
}
l++;
}
printf("%lld\n", ans);
for (int i = 1; i <= n; i++) {
if (t[i] % 100 == 0)
printf("%d 0\n", t[i] / 100);
else {
if (z[i] == 0)
printf("%d %d\n", t[i] / 100, c[i] % 100);
else
printf("%d 0\n", t[i] / 100 + 1);
}
}
}
| 2,400 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const int mod = 1e9 + 7;
long long binpow(long long num, long long pow);
int extendedEuclid(int a, int b, int &x, int &y);
inline int mul(int a, int b) { return (a * 1ll * b) % mod; }
inline int add(int a, int b) { return (a + 0ll + b) % mod; }
inline int sub(int a, int b) { return ((a + 0ll - b) % mod + mod) % mod; }
inline void intarr(vector<int> &a) {
for (auto &i : a) cin >> i;
}
inline void larr(vector<long long> &a) {
for (auto &i : a) cin >> i;
}
const int N = 200200;
inline void solve() {
int n, k;
cin >> n >> k;
vector<pair<int, int>> a(n);
vector<int> cnt(N);
vector<vector<int>> ev(N);
for (int i = (int)0; i < (int)n; i++) {
cin >> a[i].first >> a[i].second;
cnt[a[i].first]++;
cnt[a[i].second + 1]--;
ev[a[i].first].emplace_back(i + 1);
ev[a[i].second + 1].emplace_back(-i - 1);
}
for (int i = (int)1; i < (int)N; i++) cnt[i] += cnt[i - 1];
vector<int> ans(n), sub(N);
set<pair<int, int>> segs;
int curr = 0;
for (int i = (int)0; i < (int)N; i++) {
curr += sub[i];
for (auto it : ev[i]) {
if (it > 0)
segs.insert(make_pair(a[it - 1].second, it - 1));
else {
auto iter = segs.find(make_pair(a[-it - 1].second, -i - 1));
if (iter != segs.end()) segs.erase(iter);
}
}
while (cnt[i] - curr > k) {
int pos = segs.rbegin()->second;
segs.erase(prev(segs.end()));
curr++;
--sub[a[pos].second + 1];
ans[pos] = 1;
}
}
cout << accumulate(ans.begin(), ans.end(), 0) << endl;
for (int i = (int)0; i < (int)n; i++)
if (ans[i]) cout << i + 1 << " ";
cout << endl;
}
int main() {
auto start = high_resolution_clock::now();
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
while (t--) {
solve();
}
auto stop = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop - start);
cerr << duration.count() << " microseconds\n";
return 0;
}
long long binpow(long long num, long long pow) {
if (pow == 0) return 1;
long long val = binpow(num, pow / 2);
val *= val;
if (pow & 1) val *= num;
return val;
}
int extendedEuclid(int a, int b, int &x, int &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
int x1, y1;
int d = extendedEuclid(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * (a / b);
return d;
}
| 1,800 |
CPP
|
import math
x = int(input())
q = int(math.sqrt(x))
c = x - q*q
print(4 * q + 2 * math.ceil(c / q))
| 1,000 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
long long int binomialCoeff(long long int n, long long int k) {
long long int res = 1;
if (k > n - k) k = n - k;
for (int i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
long long int power(long long int x, long long int y) {
long long int temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else
return x * temp * temp;
}
vector<long long int> primes;
void Sieve(int n) {
vector<bool> prime(n + 1, true);
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p]) primes.push_back(p);
}
const int Nmax = 4e5 + 6;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
int v[100];
memset(v, 0, sizeof(v));
long long int val = 2;
int j = 0;
int jmax = 0;
while (true) {
for (int i = 0; i < n; i++) {
v[j] += arr[i] % 2;
arr[i] /= 2;
}
jmax = max(j, jmax);
if (arr[n - 1] == 0) break;
j++;
}
bool draw = true;
for (int i = jmax; j >= 0; j--) {
if (v[j] % 2) {
if ((v[j] + 1) / 2 % 2) {
draw = false;
cout << "WIN\n";
break;
}
if (n % 2) {
draw = false;
cout << "LOSE\n";
break;
} else {
draw = false;
cout << "WIN\n";
break;
}
}
}
if (draw) cout << "DRAW\n";
}
}
| 1,900 |
CPP
|
n, d = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
minCost = len(a)
for i in range(len(a)-1):
for j in range(i+1, len(a)):
if a[j]-a[i] <= d:
cost = i+(len(a)-j-1)
minCost = min(cost, minCost)
print (min(minCost, len(a)-1) if len(a) > 1 else 0)
| 1,200 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long row = 0, col = 0;
vector<pair<long long, long long>> ans;
for (long long i = 0; i <= n; i++) {
ans.push_back({row, col});
ans.push_back({row + 1, col});
ans.push_back({row, col + 1});
row++;
col++;
}
ans.push_back({row, col});
cout << ans.size() << '\n';
for (auto &i : ans) cout << i.first << " " << i.second << '\n';
return 0;
}
| 1,500 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int N;
string s1, s2;
inline void solve() {
cin >> s1 >> s2;
vector<int> ret;
int i = s1.size() - 1, j = s2.size() - 1;
while (i >= 0 and j >= 0) {
int cur_s1 = s1[i] - '0', cur_s2 = s2[j] - '0';
if (cur_s2 >= cur_s1) {
ret.push_back(cur_s2 - cur_s1);
i -= 1, j -= 1;
} else {
if (j == 0) {
cout << -1 << endl;
return;
} else {
cur_s2 = cur_s2 + (s2[j - 1] - '0') * 10;
int potential = cur_s2 - cur_s1;
if (potential >= 10 or potential < 0) {
cout << -1 << endl;
return;
} else {
ret.push_back(potential);
i -= 1, j -= 2;
}
}
}
}
if (i != -1) {
cout << -1 << endl;
return;
}
while (j >= 0) {
ret.push_back(s2[j] - '0');
j -= 1;
}
while (ret.size() > 1 and ret.back() == 0) ret.pop_back();
reverse(ret.begin(), ret.end());
for (int i : ret) cout << i;
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> N;
while (N--) {
solve();
}
return 0;
}
| 1,200 |
CPP
|
q = int(input())
for i in range(0,q):
x,y = [int(x) for x in input().split()]
l = min(x,y)
r = max(x,y)
if l % 2 == 0:
if r % 2 == 0:
print(int(l+int((r-l)/2)))
else:
print(-int((r-l+1)/2))
else:
if r % 2 == 0:
print(int((r-l+1)/2))
else:
print(int(-l-int((r-l)/2)))
| 900 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a[200010];
bool visited[200010];
vector<int> path;
void dfs(int u) {
visited[u] = 1;
path.push_back(u);
bool t = false;
for (int i = 0; i < a[u].size(); i++) {
int v = a[u][i];
if (!visited[v]) {
dfs(v);
path.push_back(u);
}
}
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x].push_back(y);
a[y].push_back(x);
}
dfs(1);
int N = path.size();
int rem = N % k;
int u = 0;
for (int i = 0; i < k; ++i) {
int t = N / k;
if (i < rem) ++t;
printf("%d ", t);
for (int j = 0; j < t; ++j) printf("%d ", path[u++]);
cout << endl;
}
return 0;
}
| 2,100 |
CPP
|
n=int(input())
a=list(map(int,input().split()))
m=min(a)
for i in range(n):
if a[i]%m!=0:
print(-1)
exit()
print(m)
| 1,000 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
bool a[3005] = {false};
for (long long int i = 1; i <= n; i++) {
long long int g;
cin >> g;
a[g] = true;
}
for (long long int i = 1; i < 3005; i++) {
if (a[i] == false) {
cout << i;
break;
}
}
}
| 1,200 |
CPP
|
# @author: sgshubham98
# @created: 2020-05-27 14:43:24
s = input()
r = input()
if s == r[::-1]:
print("YES")
else:
print("NO")
| 800 |
PYTHON3
|
a,b=map(int,input().split())
lop=0
a1=a
while 5!=1:
lop+=1
if a%10==b or a%10==0:
break
if a%10!=b:
a=a+a1
print(lop)
| 800 |
PYTHON3
|
x,y=map(int,input().split())
n=int(input())
n=n%6
if(n==0):
print((x-y)%1000000007)
elif(n==1):
print((x)%1000000007)
elif(n==2):
print((y)%1000000007)
elif(n==3):
print((y-x)%1000000007)
elif(n==4):
print((-1*x)%1000000007)
elif(n==5):
print((-y)%1000000007)
| 1,300 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
string s, t;
bool flag = false, name = false;
map<char, int> mp;
map<char, int> mp2;
int j = 0, u = 0, sum = 0;
;
cin >> s >> t;
if (t.size() <= s.size()) {
for (int k = 0; k < t.size(); k++) {
for (int l = u; l < s.size(); l++) {
if (t[k] == s[l]) {
sum++;
u = l + 1;
break;
}
}
}
j = s.find(t);
if (j > -1 || sum == t.size()) {
cout << "automaton";
return 0;
} else {
for (int k = 0; k < s.size(); k++) {
if (k < t.size()) {
mp[t[k]]++;
}
mp2[s[k]]++;
}
for (int k = 0; k < mp.size(); k++) {
if (mp[t[k]] > mp2[t[k]]) flag = true;
if (mp[t[k]] != mp2[t[k]]) name = true;
}
if (name == false && t.size() == s.size()) {
cout << "array";
return 0;
} else if (flag == false && t.size() != s.size()) {
cout << "both";
return 0;
}
}
}
cout << "need tree";
return 0;
}
| 1,400 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
constexpr int TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
int main() {
ll n, m;
cin >> n >> m;
n--;
m--;
int a = 0, b = 0;
ll n2 = n, m2 = m;
while (n2) {
a++;
n2 /= 7;
}
while (m2) {
b++;
m2 /= 7;
}
a = max(a, 1);
b = max(b, 1);
if (7 < a + b) {
printf("0\n");
return 0;
}
int ans = 0;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= m; j++) {
int x = i, y = j;
bool used[7] = {};
bool A = true;
for (int f = 0; f < a; f++) {
if (used[x % 7]) {
A = false;
break;
}
used[x % 7] = true;
x /= 7;
}
for (int f = 0; f < b; f++) {
if (used[y % 7]) {
A = false;
break;
}
used[y % 7] = true;
y /= 7;
}
if (A) {
ans++;
}
}
}
printf("%d\n", ans);
return 0;
}
| 1,700 |
CPP
|
from sys import stdin,stdout
from collections import defaultdict
input=stdin.buffer.readline
t=int(input())
for _ in range(t):
n=int(input())
a=list(map(int,input().split()))
dc=defaultdict(int)
for i in range(n-1):
sm=a[i]
for j in range(i+1,n):
sm+=a[j]
if sm<=n:
dc[sm]=1
cnt=0
for x in a:
if dc[x]==1:
cnt+=1
print(cnt)
| 1,500 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, dp[5005][5005], sizek, num, a[500005];
int main() {
cin.tie(0), cout.tie(0), ios::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
sizek = n / k;
num = n % k;
sort(a + 1, a + 1 + n);
for (int i = 0; i <= 5000; i++) {
for (int j = 0; j <= 5000; j++) dp[i][j] = LLONG_MAX;
}
dp[0][0] = 0;
for (int i = 1; i <= k; i++) {
for (int j = 0; j <= num; j++) {
long long posy = i * sizek + j, posx = (i - 1) * sizek + 1 + j,
posy1 = (i - 1) * sizek + j;
if (dp[i - 1][j] != LLONG_MAX)
dp[i][j] = dp[i - 1][j] + a[posy] - a[posx];
if (j && dp[i - 1][j - 1] != LLONG_MAX)
dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] + a[posy] - a[posy1]);
}
}
cout << dp[k][num];
}
| 2,000 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
const double EPS = 1e-6;
const int INF = 0x3fffffff;
const long long LINF = INF * 1ll * INF;
const double PI = acos(-1.0);
class SCC {
public:
int head[200005];
struct Edge {
int to, next;
Edge() {}
Edge(int to, int next) : to(to), next(next) {}
} e[200005 << 1];
void addEdge(int u, int v) {
e[cnt].to = v;
e[cnt].next = head[u];
head[u] = cnt++;
}
int belong[200005];
int dfn[200005];
int low[200005];
int ind[200005];
int outd[200005];
stack<int> sta;
vector<int> nG[200005];
int n, k;
int cnt;
int dfs_clock, scc_cnt;
char ans[200005];
void init(int n, int k) {
this->n = n;
this->k = k;
dfs_clock = scc_cnt = 0;
memset(dfn, 0, sizeof(dfn));
memset(belong, 0, sizeof(belong));
}
void tarjan(int u) {
dfn[u] = low[u] = ++dfs_clock;
sta.push(u);
for (int i = head[u]; ~i; i = e[i].next) {
int v = e[i].to;
if (!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else if (!belong[v])
low[u] = min(low[u], dfn[v]);
}
if (dfn[u] == low[u]) {
scc_cnt++;
while (!sta.empty()) {
int temp = sta.top();
belong[temp] = scc_cnt;
sta.pop();
if (u == temp) break;
}
}
}
void get_scc() {
memset(ind, 0, sizeof(ind));
memset(outd, 0, sizeof(outd));
for (int i = 1; i <= n; i++) {
for (int j = head[i]; ~j; j = e[j].next) {
int v = e[j].to;
if (belong[i] != belong[v]) {
ind[belong[v]]++;
outd[belong[i]]++;
nG[belong[i]].push_back(belong[v]);
}
}
}
}
void topoSort() {
queue<int> q;
for (int i = 1; i <= scc_cnt; i++) {
if (!ind[i]) q.push(i);
}
int id = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
ans[u] = id + 'a';
if (id < 25) id++;
for (int i = 0; i < nG[u].size(); i++) {
int v = nG[u][i];
ind[v]--;
if (!ind[v]) q.push(v);
}
}
}
void buildGraph() {
cnt = 0;
memset(head, -1, sizeof(head));
int u, v;
scanf("%d", &u);
for (int i = 1; i < n; i++) {
scanf("%d", &v);
addEdge(u, v);
u = v;
}
scanf("%d", &u);
for (int i = 1; i < n; i++) {
scanf("%d", &v);
addEdge(u, v);
u = v;
}
}
void solve() {
buildGraph();
for (int i = 1; i <= n; i++) {
if (!dfn[i]) tarjan(i);
}
if (scc_cnt < k) {
puts("NO");
return;
}
get_scc();
topoSort();
puts("YES");
for (int i = 1; i <= n; i++) printf("%c", ans[belong[i]]);
puts("");
}
} scc;
int main() {
int n, k;
scanf("%d%d", &n, &k);
scc.init(n, k);
scc.solve();
return 0;
}
| 2,100 |
CPP
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse4")
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
template <typename T, typename TT>
ostream &operator<<(ostream &os, const pair<T, TT> &t) {
return os << t.first << " " << t.second;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &t) {
for (auto &i : t) os << i << " ";
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &t : v) is >> t;
return is;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, vector<pair<T1, T2>> &v) {
for (pair<T1, T2> &t : v) is >> t.first >> t.second;
return is;
}
const long long mod = 998244353;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long q;
cin >> q;
while (q--) {
long long l, r, d;
cin >> l >> r >> d;
if (l > d) {
cout << d << '\n';
continue;
}
cout << r - (r % d) + d << '\n';
}
return 0;
}
| 1,000 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int main() {
map<string, int> mp;
mp["scissorsrock"] = 0;
mp["rockscissors"] = 1;
mp["scissorspaper"] = 1;
mp["paperscissors"] = 0;
mp["paperrock"] = 1;
mp["scissorsrock"] = 0;
mp["scissorsscissors"] = 0;
mp["rockrock"] = 0;
mp["paperpaper"] = 0;
int f, m, s;
string s1, s2, s3;
cin >> s1 >> s2 >> s3;
f = (mp[s1 + s2] && mp[s1 + s3]);
m = (mp[s2 + s1] && mp[s2 + s3]);
s = (mp[s3 + s1] && mp[s3 + s2]);
if (f)
cout << "F";
else if (m)
cout << "M";
else if (s)
cout << "S";
else
cout << "?";
return 0;
}
| 900 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
int c = 0;
vector<int> v;
cin >> s >> t;
for (int i = 0; i < s.size(); i++) {
if (s[i] != t[i]) {
c++;
v.push_back(i);
}
}
if (c % 2 != 0) {
cout << "impossible";
} else {
for (int i = 0; i < c / 2; i++) {
if (s[v[i]] == '0')
s[v[i]] = '1';
else if (s[v[i]] == '1')
s[v[i]] = '0';
}
cout << s;
}
return 0;
}
| 1,100 |
CPP
|
num = int(input())
outputs = []
for i in range(0, num):
list1 = input().split(" ")
w, h, n = int(list1[0]), int(list1[1]), int(list1[2])
hpieces = 1
while h % 2 == 0:
h /= 2
hpieces *= 2
wpieces = 1
while w % 2 == 0:
w /= 2
wpieces *= 2
if hpieces*wpieces >= n:
outputs.append("YES")
else:
outputs.append("NO")
for j in outputs:
print(j)
| 800 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007LL;
long long base = 37;
long long large = 1000000000000000000LL;
int main() {
int n;
cin >> n;
long long k;
cin >> k;
vector<long long> a(n, 0);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) k += a[i];
long long sum = 0LL;
for (int i = 0; i < n; i++) sum += a[i];
long long ans = 1;
vector<pair<long long, pair<long long, long long> > > eve;
for (int i = 0; i < n; i++) {
vector<long long> b;
for (long long j = 1;; j++) {
b.push_back(j);
long long t = (a[i] - 1) / j + 1;
if (t > j) {
b.push_back(t);
} else {
break;
}
}
sort(b.begin(), b.end());
for (int j = 1; j < (int)b.size(); j++) {
eve.push_back(pair<long long, pair<long long, long long> >(
b[j], pair<long long, long long>(a[i], b[j - 1])));
}
}
sort(eve.begin(), eve.end());
for (int i = 0; i < (int)eve.size(); i++) {
long long d = eve[i].first;
long long pre = eve[i].second.second;
long long val = eve[i].second.first;
sum -= (val - 1) / pre + 1;
sum += (val - 1) / d + 1;
if (i + 1 >= (int)eve.size() || eve[i + 1].first > d) {
if (sum * d <= k) {
ans = max(ans, k / sum);
}
}
}
if (eve.size() == 0) {
ans = max(ans, k / sum);
}
cout << ans << endl;
return 0;
}
| 2,300 |
CPP
|
n = int(input())
a = list(map(int, input().split()))
s = sum(a)
m = max(a)
if s % 2 or m * 2 > s:
print("NO")
exit(0)
print("YES")
| 1,500 |
PYTHON3
|
from math import *
from sys import *
def conv(s):
if s=="S" or s=="S\n":
return 1
if s=="M" or s=="M\n":
return 2
if s=="L" or s=="L\n":
return 3
if s=="XL" or s=="XL\n":
return 4
if s=="XXL" or s=="XXL\n":
return 5
return 6
def uncon(x):
if x==1:
return "S"
if x==2:
return "M"
if x==3:
return "L"
if x==4:
return "XL"
if x==5:
return "XXL"
return "XXXL"
s=[]
m=[]
l=[]
xl=[]
xxl=[]
sp,mp,lp,xp,xxp=0,0,0,0,0
t=[0]
t+=[int(z) for z in stdin.readline().split()]
n=int(stdin.readline())
ans=[0]*n
#print(t)
for i in range(n):
e=[conv(z) for z in stdin.readline().split(",")]
#print(e)
if len(e)==1:
ans[i]=e[0]
t[e[0]]-=1
if t[e[0]]<0:
print("NO")
exit(0)
else:
if e[0]==1:
s.append(i)
if e[0]==2:
m.append(i)
if e[0]==3:
l.append(i)
if e[0]==4:
xl.append(i)
if e[0]==5:
xxl.append(i)
while len(s)!=sp and t[1]:
ans[s[sp]]=1
sp+=1
t[1]-=1
while len(s)!=sp and t[2]:
ans[s[sp]]=2
sp+=1
t[2]-=1
if len(s)!=sp:
print("NO")
exit(0)
while len(m)!=mp and t[2]:
ans[m[mp]]=2
mp+=1
t[2]-=1
while len(m)!=mp and t[3]:
ans[m[mp]]=3
mp+=1
t[3]-=1
if len(m)!=mp:
print("NO")
exit(0)
while len(l)!=lp and t[3]:
ans[l[lp]]=3
lp+=1
t[3]-=1
while len(l)!=lp and t[4]:
ans[l[lp]]=4
lp+=1
t[4]-=1
if len(l)!=lp:
print("NO")
exit(0)
while len(xl)!=xp and t[4]:
ans[xl[xp]]=4
xp+=1
t[4]-=1
while len(xl)!=xp and t[5]:
ans[xl[xp]]=5
xp+=1
t[5]-=1
if len(xl)!=xp:
print("NO")
exit(0)
while len(xxl)!=xxp and t[5]:
ans[xxl[xxp]]=5
xxp+=1
t[5]-=1
while len(xxl)!=xxp and t[6]:
ans[xxl[xxp]]=6
xxp+=1
t[6]-=1
if len(xxl)!=xxp:
print("NO")
exit(0)
res=[uncon(z) for z in ans]
print("YES")
for i in res:
print(i)
| 1,800 |
PYTHON3
|
t = int(input())
for _ in range(t):
n = input()
n = n[::-1]
ANS = []
d = 1
for x in n:
x = int(x)
y = x*d
if y != 0:
ANS.append(x*d)
d *= 10
print(len(ANS))
print(*ANS)
| 800 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
string FILE_NAME = "testcase.D";
string NAME;
string itos(int n) {
stringstream ss;
ss << n;
return ss.str();
}
long long dp[2][1 << 20];
struct FRIEND {
long long x, k;
int solve;
bool operator<(const FRIEND &a) const { return k < a.k; }
};
int main() {
ios_base::sync_with_stdio(0);
int n, m, b;
cin >> n >> m >> b;
vector<FRIEND> fri(n);
for (int i = 0; i < (2); i++)
for (int j = 0; j < (1 << m); j++) dp[i][j] = 1LL << 60;
for (int i = 0; i < (n); i++) {
int qn;
cin >> fri[i].x >> fri[i].k >> qn;
for (int j = 0; j < (qn); j++) {
int qq;
cin >> qq;
fri[i].solve |= 1 << (qq - 1);
}
}
sort(fri.begin(), fri.end());
dp[0][0] = 0LL;
long long res = 1LL << 60;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << m); j++) {
if (dp[(i - 1) % 2][j] != 1LL << 60) {
dp[i % 2][j | fri[i - 1].solve] = min(
dp[i % 2][j | fri[i - 1].solve], dp[(i - 1) % 2][j] + fri[i - 1].x);
dp[i % 2][j] = min(dp[i % 2][j], dp[(i - 1) % 2][j]);
}
}
if (dp[i % 2][(1 << m) - 1] != 1LL << 60)
res = min(res, dp[i % 2][(1 << m) - 1] + b * fri[i - 1].k);
for (int j = 0; j < (1 << m); j++) dp[(i - 1) % 2][j] = 1LL << 60;
}
cout << (res == 1LL << 60 ? -1 : res) << endl;
return 0;
}
| 1,900 |
CPP
|
def solve():
temp = input()
temp.strip()
a,b = temp.split()
a = int(a)
b = int(b)
ans = min(a,b,(a+b)//3)
print(ans)
def main():
tt = int(input())
while tt>0:
solve()
tt-=1
main()
| 1,100 |
PYTHON3
|
if __name__ == '__main__':
n = int(input())
a = list(map(int, input().split()))
ct, m, best = 0, a.pop(0), max(a)
while m <= best:
m += 1
ct += 1
a[a.index(best)] -= 1
best = max(a)
print(ct)
| 1,200 |
PYTHON3
|
n, m = map(int, input().split())
f = 1
for i in range(n):
for j in input().split():
if j != 'W' and j != 'B' and j != 'G':
f = 0
print('#Color') if not f else print('#Black&White')
| 800 |
PYTHON3
|
a,b = map(int,input().split())
list = [i for i in str(input())]
for j in range(b):
i = 0
while i < a-1:
if list[i]=='B' and list[i+1]=='G':
list[i],list[i+1]='G','B'
i += 1
i += 1
print(''.join(list))
| 800 |
PYTHON3
|
# region fastio # from https://codeforces.com/contest/1333/submission/75948789
import sys, io, os
BUFSIZE = 8192
class FastIO(io.IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = io.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(io.IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#endregion
N = int(input())
A = list(map(int, input().split()))
ans_count = 0
ans_x = 0
C = [A[:]]
for b in range(31, 0, -1):
C_new = []
D = {}
for a in A:
if a>>b not in D:
D[a>>b] = [a>>b-1&1]
else:
D[a>>b].append(a>>b-1&1)
count_inv_0 = count_inv_1 = 0
for v in D.values():
if len(v) <= 1:
continue
cnt_1 = 0
cnt_0 = 0
cnt_inv_0 = 0
cnt_inv_1 = 0
for zero_one in v:
if zero_one:
cnt_1 += 1
cnt_inv_1 += cnt_0
else:
cnt_0 += 1
cnt_inv_0 += cnt_1
count_inv_0 += cnt_inv_0
count_inv_1 += cnt_inv_1
if count_inv_0 <= count_inv_1:
ans_count += count_inv_0
else:
ans_count += count_inv_1
ans_x |= 1<<b-1
print(ans_count, ans_x)
| 2,000 |
PYTHON3
|
a,b,k=map(int,input().split())
prime=[True]*(b+1)
p=[]
for i in range(2,b+1):
if prime[i]:
if i>=a:
p.append(i)
for j in range(i,b+1,i):
prime[j]=False
if len(p)<k:
print(-1)
else:
arr1=[p[i]-p[i-k] for i in range(k,len(p))]
arr2=[b-p[-k]+1,p[k-1]-a+1]
arr=arr1+arr2
print(max(arr))
| 1,600 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<long long, long long> > v;
for (int i = 3; i <= 180; i++) {
if (180 % i == 0) v.push_back(make_pair((180 / i), i));
}
while (n--) {
long long b;
cin >> b;
long long flag = 0;
long long flag1 = 0;
long long flag2 = 0;
if (b == 135) {
cout << 8 << endl;
flag2 = 1;
}
if (b == 165) {
cout << 24 << endl;
flag2 = 1;
}
if (b == 171) {
cout << 40 << endl;
flag2 = 1;
}
if (b == 175) {
cout << 72 << endl;
flag2 = 1;
}
if (b == 177) {
cout << 120 << endl;
flag2 = 1;
}
if (flag2 == 0) {
for (int i = 0; i < v.size(); i++) {
if (b % v[i].first == 0 && (b / v[i].first) <= v[i].second - 2) {
cout << v[i].second << endl;
flag = 1;
break;
}
}
}
if (flag == 0 && (b == 179 || b == 180) && flag2 == 0) {
cout << 360 << endl;
flag1 = 1;
}
if (flag == 0 && flag1 == 0 && flag2 == 0) cout << -1 << endl;
}
}
| 1,600 |
CPP
|
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().rstrip().split())
inl = lambda: list(map(int, input().split()))
out = lambda x, s='\n': print(s.join(map(str, x)))
t = ini()
for _ in range(t):
n = ini()
a = inl()
if n == 1 or len(a) == len(set(a)):
print(-1)
else:
count = {}
ans = n
for i in range(n):
if a[i] not in count:
count[a[i]] = i
else:
ans = min(ans, i - count[a[i]])
count[a[i]] = i
print(ans + 1)
| 1,200 |
PYTHON3
|
def main():
W = int(input())
if (W %2==0 and W >= 1 and W <= 100 and W !=2):
print("YES")
else:
print('NO')
main()
| 800 |
PYTHON3
|
#include "bits/stdc++.h"
using namespace std;
#define pb push_back
#define fst first
#define snd second
#define fr(i,n) for (int i = 0; i < n; i++)
#define frr(i,n) for (int i = 1; i <= n; i++)
// #define endl '\n'
#define gnl cout << endl
#define chapa cout << "oi meu chapa" << endl
#define dbg(x) cout << #x << " = " << x << endl
#define all(x) x.begin(), x.end()
typedef long long int ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<pii> vii;
const int INF = 0x3f3f3f3f;
const ll llINF = (long long)(1e18) + 100;
const int MAXN = 3e5 + 10;
int n;
vi adj[MAXN], g[MAXN];
int clk, in[MAXN], out[MAXN];
void dfs_time(int v){
in[v] = clk++;
for (int x : g[v])
dfs_time(x);
out[v] = clk;
}
set<pii> q;
int inside(int v, int u){
return in[v] <= in[u] and out[u] <= out[v];
}
int ans, now;
void dfs(int v){
int before = now;
auto it = q.lower_bound({in[v], 0}); // primeiro intervalo que não começa antes de in[v]
if (it != q.end()) // eu contenho o intervalo que começa depois?
now += 1 - inside(v, it->snd); // se não, aumenta, se sim, mantem o valor
if (it != q.begin()){
auto nxt = it--; // guardei o proximo e voltei
now += 1 - inside(it->snd, v); // o anterior me contém
if (nxt != q.end()) // entrei em ambos os casos, conserta
now -= 1 - inside(it->snd, nxt->snd);
}
q.insert({in[v], v});
ans = max(ans, now);
for (auto x : adj[v])
dfs(x);
q.erase({in[v], v});
now = before;
}
void solve(){
cin>>n;
fr(i, n + 10){
adj[i].clear();
g[i].clear();
}
int x;
for (int i = 2; i <= n; i++){ // vizinhos
cin>>x;
adj[x].pb(i);
}
for (int i = 2; i <= n; i++){ // independentes
cin>>x;
g[x].pb(i);
}
clk = 0;
dfs_time(1);
ans = now = 1;
dfs(1);
cout<<ans<<endl;
}
int32_t main(){
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
int T;
cin>>T;
while (T--)
solve();
}
| 2,300 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int neg = 1, num = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') neg = -1;
for (; isdigit(c); c = getchar()) num = (num << 1) + (num << 3) + c - '0';
return neg * num;
}
int n, q, path[210][210 * 210], tp[210][210 * 210], a[210];
signed main() {
path[1][0] = -1;
for (int i = 2; i <= 100; i++)
for (int k = i; k <= i * (i + 1) / 2; k++) {
for (int j = 2; j <= i; j++)
if (k >= j * (j + 1) / 2 - 1 &&
path[i - j + 1][k - j * (j + 1) / 2 + 1])
path[i][k] = j, tp[i][k] = 1;
for (int j = 4; j <= i; j++)
if (path[i - j + 1][k - j]) path[i][k] = j, tp[i][k] = 2;
}
for (q = read(); q--;) {
n = read();
int k = read() - 1;
if (!path[n][k]) {
puts("NO");
continue;
}
puts("YES");
int l = 1, r = n, rev = 0;
for (int i; l < r;) {
int w = path[n][k];
if (tp[n][k] == 1) {
if (rev) {
for (i = r; i >= r - w + 2; i--) printf("%d ", i);
r = i;
} else {
for (i = l; i <= l + w - 2; i++) printf("%d ", i);
l = i;
}
rev ^= 1;
k -= w * (w + 1) / 2 - 1;
} else {
int cnt = 0;
for (i = l + 1; i <= l + w - 1; i += 2) a[++cnt] = i;
for (i = l; i <= l + w - 1; i += 2) a[++cnt] = i;
if (w & 1)
a[w / 2] = r - 1, a[w - 1] = r, r -= 2, l += w - 3;
else
a[w / 2] = r--, l += w - 2;
for (int i = 1; i < cnt; i++) printf("%d ", a[i]);
k -= w;
}
n -= w - 1;
}
printf("%d\n", l);
}
return 0;
}
| 3,400 |
CPP
|
for __ in range(int(input())):
n = int(input())
ar = list(map(int, input().split()))
ans = 'NO'
for elem in ar:
i = 2
while i * i <= elem:
while elem % i == 0 and elem % (i * i) == 0:
elem //= i
elem //= i
i += 1
if elem != 1:
ans = 'YES'
break
print(ans)
| 800 |
PYTHON3
|
a,b=input().split()
a=int(a)
b=int(b)
if(a<b):
print(-1)
elif(a==b):
print(int(a))
else:
if(a%2==0):
ans=a/2
else:
ans=(a-1)/2+1
if(ans%b==0):
print(int(ans))
else:
while(ans%b!=0):
ans=ans+1
print(int(ans))
| 1,000 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2147483647;
int a[205], x[205], y[205], f[205], n, d, bj[205], g[205 * 100];
void init() {
int i;
scanf("%d%d", &n, &d);
for (i = 2; i <= n - 1; ++i) scanf("%d", a + i);
for (i = 1; i <= n; ++i) {
scanf("%d%d", x + i, y + i);
}
}
void work() {
int i, p, head, tail;
for (i = 1; i <= n; ++i) f[i] = -inf;
bj[1] = 1;
f[1] = 0;
g[1] = 1;
for (head = tail = 1; head <= tail; head++) {
p = g[head];
for (i = 1; i <= n; ++i)
if (i != p) {
if (f[p] - d * (abs(x[i] - x[p]) + abs(y[i] - y[p])) + a[i] > f[i]) {
f[i] = f[p] - d * (abs(x[i] - x[p]) + abs(y[i] - y[p])) + a[i];
if (bj[i] == 0) {
bj[i] = 1;
g[++tail] = i;
}
}
}
bj[p] = 0;
}
cout << -f[n] << endl;
}
int main() {
init();
work();
}
| 2,100 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
using LL = int64_t;
int main() {
LL n, k, ans = 1e18;
cin >> n >> k;
for (LL i = 1; i * i <= n; i++) {
if (n % i == 0) {
LL tans = i * k + n / i;
if ((tans / k) * (tans % k) == n) ans = min(ans, tans);
tans = (n / i) * k + i;
if ((tans / k) * (tans % k) == n) ans = min(ans, tans);
}
}
cout << ans;
return 0;
}
| 1,100 |
CPP
|
n=int(input())
s=input()
s2=''
k=0
for i in range(1,n,2):
if (s[i]=='a' and s[i-1]=='a') or (s[i]=='b' and s[i-1]=='b'):
s2+='ab'
k+=1
else:
s2+=s[i-1]+s[i]
print(k)
print(s2)
| 800 |
PYTHON3
|
for _ in range(int(input())):
n = int(input())
s = input()
for i in range(n):
print(s[n-1], end = '')
print()
| 800 |
PYTHON3
|
n = int(input())
dic = {}
arr = list(map(int , input().split()))
for i in arr :
try :
dic[i]+=1
except:
dic[i]=1
for i,j in dic.items() :
if j > (n+1)/2 :
print('NO')
exit()
print('YES')
| 1,100 |
PYTHON3
|
n, k, l, c, d, p, nl, np = map(int, input().split())
print(min(((l*k) // nl) // n, (c*d) // n, (p // np) // n))
| 800 |
PYTHON3
|
#include <bits/stdc++.h>
const long long N = 100100;
const long long Q = 100100;
const long long mod = 998244353;
const long long block = 500;
using namespace std;
int n;
int s1;
int s2;
int a[N];
int L[N];
int mn[N][20];
int mx[N][20];
pair<int, int> get(int l, int r) {
int g = L[r - l + 1];
return {min(mn[l][g], mn[r - (1 << g) + 1][g]),
max(mx[l][g], mx[r - (1 << g) + 1][g])};
}
bool can(int mi) {
if (abs(s1 - s2) > mi) {
return false;
}
int mx = 0;
for (int i = 1; i <= n; i++) {
if (abs(s1 - a[i]) <= mi) {
mx = i;
} else {
break;
}
}
for (int i = 1; i <= n; i++) {
if (abs(s2 - a[i]) <= mi) {
mx = max(mx, i);
} else {
break;
}
}
for (int i = 1; i <= n; i++) {
if (mx < i) {
return false;
}
int l = i, r = n;
while (l < r) {
int m = (l + r) / 2 + 1;
pair<int, int> p = get(i, m);
if (p.first >= a[i] - mi && p.second <= a[i] + mi) {
l = m;
} else {
r = m - 1;
}
}
mx = max(mx, l);
}
return true;
}
void solve() {
for (int i = 2; i < N; i++) {
L[i] = L[i / 2] + 1;
}
cin >> n >> s1 >> s2;
for (int i = 1; i <= n; i++) {
cin >> a[i];
mn[i][0] = mx[i][0] = a[i];
}
for (int i = 1; i < 20; i++) {
for (int j = 1; j <= n; j++) {
if (j + (1 << i) - 1 <= n) {
mn[j][i] = min(mn[j][i - 1], mn[j + (1 << i) / 2][i - 1]);
mx[j][i] = max(mx[j][i - 1], mx[j + (1 << i) / 2][i - 1]);
}
}
}
int l = 0, r = 1e9 + 10;
while (l < r) {
int m = (l + r) / 2;
if (can(m)) {
r = m;
} else {
l = m + 1;
}
}
cout << l << "\n";
}
bool mtest = false;
int main() {
ios_base::sync_with_stdio(0);
int TE = 1;
if (mtest) cin >> TE;
while (TE--) solve();
return 0;
}
| 2,600 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
const int N = 1e6 + 10;
long long factorial[N];
long long power(long long a, long long b) {
if (b < 0) return 1;
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
long long mod_inv(long long n) { return power(n, mod - 2); }
long long nck(long long n, long long a) {
if (n < a) return 0;
long long top = factorial[n];
long long bot = mod_inv(factorial[a]) * mod_inv(factorial[n - a]);
bot %= mod;
long long res = top * bot % mod;
return res;
}
void init() {
factorial[0] = 1;
for (int i = 1; i < N; i++) {
factorial[i] = factorial[i - 1] * i;
factorial[i] %= mod;
}
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int n, m;
cin >> n >> m;
mod = m;
init();
long long ans = 0;
for (int i = 0; i < n; i++) {
long long order = factorial[i + 1];
long long rem = factorial[n - i - 1];
long long tmp = 1LL * (n - i) * (n - i) % mod;
tmp *= order;
tmp %= mod;
tmp *= rem;
tmp %= mod;
ans += tmp;
ans %= mod;
}
cout << ans;
}
| 1,600 |
CPP
|
s=input()
mi=6
for a in range(10):
for b in range(10):
for c in range(10):
for d in range(10):
for e in range(10):
for f in range(10):
if (a+b+c==d+e+f):
#print(a,b,c,d,e,f)
k=0
if (a!=int(s[0])):
k+=1
if (b!=int(s[1])):
k+=1
if (c!=int(s[2])):
k+=1
if (d!=int(s[3])):
k+=1
if (e!=int(s[4])):
k+=1
if (f!=int(s[5])):
k+=1
if (k<mi):
mi=k
print(mi)
| 1,600 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t n;
cin >> n;
vector<int64_t> nums;
nums.reserve(n + 1);
for (int i = 0; i < n; ++i) {
int64_t cur;
cin >> cur;
nums.push_back(cur);
while (nums.size() >= 2) {
int64_t last = nums[(int)nums.size() - 1];
int64_t pre_last = nums[(int)nums.size() - 2];
if (last == pre_last) {
nums.pop_back();
nums.pop_back();
nums.push_back(last + 1);
} else {
break;
}
}
}
cout << nums.size() << "\n";
for (auto x : nums) {
cout << x << " ";
}
cout << "\n";
}
| 1,900 |
CPP
|
t = int(input())
for k in range(t):
s, a, b, c = map(int, input().split())
x = s // c
print(x // a * (a + b) + x % a)
| 800 |
PYTHON3
|
import sys;
n = int(input());
arr = list(map(int,input().split()));
ans = 0;
for i in range(30,0,-1):
maxsum = 0;
for j in range(n):
if(arr[j]>i):
maxsum=0;
continue;
maxsum += arr[j];
maxsum = max(maxsum,0);
ans = max(ans,maxsum-i);
print(ans);
| 2,000 |
PYTHON3
|
for _ in range(int(input())):
n = int(input())
s = list(map(int,input().split()))
temp = []; i = 0
while(i<n):
if(s[i]<0):
mx = s[i]
while(i<n and s[i]<0):
if(abs(s[i])<abs(mx)):
mx = s[i]
i+=1
temp.append(mx)
else:
mx = s[i]
while(i<n and s[i]>0):
if(s[i]>mx):
mx = s[i]
i+=1
temp.append(mx)
print(sum(temp))
| 1,200 |
PYTHON3
|
s = input()
s = s.strip('o')
v = []
o = []
cnt_v = 0
cnt_o = 0
for i in range(len(s)):
if s[i] == 'v':
if cnt_o:
o.append(cnt_o)
cnt_o = 0
cnt_v += 1
else:
if cnt_v:
v.append(cnt_v)
cnt_v = 0
cnt_o += 1
v.append(cnt_v)
left = v[0]
left_cnt = 1
ans = 0
all_v = sum(v)
len_v = len(v)
for i in range(len(o)):
ans += (left - left_cnt) * o[i] * (all_v - left - len_v + left_cnt)
left += v[i + 1]
left_cnt += 1
print(ans)
| 1,300 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e5 + 10;
const int Mod = 1e9 + 7;
const long long int Inf = 1LL << 62;
int heavy_sz[Max];
int light_sz[Max];
int isLight[Max];
int isHeavy[Max];
long long int ar[100010];
vector<int> inp_light[Max];
vector<int> inp_heavy[Max];
vector<int> intersection[Max];
int hSelf[1003][1003];
long long int inc[Max];
long long int sum[Max];
int main() {
int n, m, q, szh = 0, szl = 0;
scanf("%d %d %d", &n, &m, &q);
int sq = 3000;
for (int i = 1; i <= n; i++) {
scanf("%lld", &ar[i]);
}
for (int i = 1; i <= m; i++) {
int x;
scanf("%d", &x);
if (x <= sq) {
szl++;
light_sz[szl] = x;
isLight[i] = szl;
for (int j = 1; j <= x; j++) {
int y;
scanf("%d", &y);
inp_light[szl].push_back(y);
}
sort(inp_light[szl].begin(), inp_light[szl].end());
} else {
szh++;
heavy_sz[szh] = x;
isHeavy[i] = szh;
for (int j = 1; j <= x; j++) {
int y;
scanf("%d", &y);
sum[szh] += ar[y];
inp_heavy[szh].push_back(y);
}
sort(inp_heavy[szh].begin(), inp_heavy[szh].end());
}
}
for (int i = 1; i <= szl; i++) {
intersection[i].push_back(0);
for (int j = 1; j <= szh; j++) {
intersection[i].push_back(0);
int tot = 0;
int p = light_sz[i] - 1;
int q = heavy_sz[j] - 1;
int x = 0;
int y = 0;
for (int k = 1; k <= p + q + 2; k++) {
while (inp_light[i][x] < inp_heavy[j][y] && x < p) {
x++;
}
while (inp_heavy[j][y] < inp_light[i][x] && y < q) {
y++;
}
if (inp_light[i][x] == inp_heavy[j][y] && x <= p && y <= q) {
tot++;
x++;
y++;
}
}
intersection[i][j] = tot;
}
}
for (int i = 1; i <= szh; i++) {
for (int j = 1; j <= szh; j++) {
if (i == j) {
continue;
}
int tot = 0;
int p = heavy_sz[i] - 1;
int q = heavy_sz[j] - 1;
int x = 0;
int y = 0;
for (int k = 1; k <= p + q + 2; k++) {
while (inp_heavy[i][x] < inp_heavy[j][y] && x < p) {
x++;
}
while (inp_heavy[j][y] < inp_heavy[i][x] && y < q) {
y++;
}
if (inp_heavy[i][x] == inp_heavy[j][y] && x <= p && y <= q) {
tot++;
x++;
y++;
}
}
hSelf[i][j] = tot;
}
}
char ch;
int x, y;
while (q--) {
getchar();
scanf("%c", &ch);
if (ch == '+') {
scanf("%d %d", &y, &x);
if (isLight[y]) {
int pos = isLight[y];
for (int i = 0; i < light_sz[pos]; i++) {
ar[inp_light[pos][i]] += x;
}
for (int i = 1; i <= szh; i++) {
int tot = intersection[pos][i];
sum[i] += 1LL * tot * x;
}
} else {
int pos = isHeavy[y];
inc[pos] += x;
for (int i = 1; i <= szh; i++) {
if (i != pos) {
sum[i] += 1LL * hSelf[pos][i] * x;
}
}
}
} else {
scanf("%d", &y);
long long int ans = 0;
if (isLight[y]) {
int pos = isLight[y];
for (int i = 0; i < light_sz[pos]; i++) {
ans += ar[inp_light[pos][i]];
}
for (int i = 1; i <= szh; i++) {
int tot = intersection[pos][i];
ans += 1LL * tot * inc[i];
}
printf("%lld\n", ans);
} else {
int pos = isHeavy[y];
long long int ans = sum[pos] + 1LL * inc[pos] * heavy_sz[pos];
printf("%lld\n", ans);
}
}
}
return 0;
}
| 2,500 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int n, p[100010], a[100010], h[100010], S, q, r;
long long ans;
vector<int> V[100010];
int num[20002000];
void dfs(int v) {
int mx = 0;
for (int i = 0; i < V[v].size(); i++) {
int vv = V[v][i];
dfs(vv);
mx = max(mx, h[vv]);
}
h[v] = mx + 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 2; i <= n; i++) {
scanf("%d", &p[i]);
V[p[i]].push_back(i);
}
dfs(1);
for (int i = 1; i <= n; i++)
if (h[i] % 2) {
S ^= a[i];
q++;
num[a[i]]++;
}
r = n - q;
if (!S) ans += 1LL * (q - 1) * q / 2 + 1LL * r * (r - 1) / 2;
for (int i = 1; i <= n; i++)
if (h[i] % 2 == 0) ans += num[S ^ a[i]];
printf("%I64d", ans);
}
| 2,300 |
CPP
|
def gcd(a,b):
if b==0:
return a
else:
return gcd(b,a%b)
a,b,n=map(int,input().split())
while True:
n-=gcd(a,n)
if n==0:
print(0)
break
n-=gcd(b,n)
if n==0:
print(1)
break
| 800 |
PYTHON3
|
t = int(input())
for i in range(t):
a, b, c = map(int, input().split())
mn = 9999999999
for i in range(a - 1, a + 2):
for j in range(b - 1, b + 2):
for k in range(c - 1, c + 2):
mn = min(mn, abs(i - j) + abs(i - k) + abs(j - k))
print(mn)
| 900 |
PYTHON3
|
number = int(input())
last = ""
i = 0
group = 0
while i < number:
aux = input()
i += 1
if aux != last:
group += 1
last = aux
print(group)
| 800 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int a[111], b[111], N, ans;
void dfs(int step, int mm) {
if (step + 1 >= ans) return;
if (mm > N) return;
for (int i = 1; i <= step; ++i)
for (int k = 1; k < 4; ++k)
if (a[i] * (1 << k) == N) {
ans = step + 1;
for (int p = 1; p <= step; ++p) b[p] = a[p];
b[ans] = N;
return;
}
for (int i = 1; i <= step; ++i)
for (int j = 1; j <= step; ++j)
for (int k = 0; k < 4; ++k)
if (a[i] + a[j] * (1 << k) == N) {
ans = step + 1;
for (int p = 1; p <= step; ++p) b[p] = a[p];
b[ans] = N;
return;
}
for (int i = 1; i <= step; ++i)
for (int k = 1; k < 4; ++k)
if (a[i] * (1 << k) > mm) {
a[step + 1] = a[i] * (1 << k);
dfs(step + 1, a[step + 1]);
a[step + 1] = 0;
}
for (int i = 1; i <= step; ++i)
for (int j = 1; j <= step; ++j)
for (int k = 0; k < 4; ++k)
if (a[i] + a[j] * (1 << k) > mm) {
a[step + 1] = a[i] + a[j] * (1 << k);
dfs(step + 1, a[step + 1]);
a[step + 1] = 0;
}
}
void find(int p) {
for (int i = 1; i < p; ++i)
for (int k = 1; k < 4; ++k)
if (b[i] * (1 << k) == b[p]) {
printf("lea e%cx, [%d*e%cx]\n", 'a' + p - 1, 1 << k, 'a' + i - 1);
return;
}
for (int i = 1; i < p; ++i)
for (int j = 1; j < p; ++j)
for (int k = 0; k < 4; ++k)
if (b[i] + b[j] * (1 << k) == b[p]) {
printf("lea e%cx, [e%cx + %d*e%cx]\n", 'a' + p - 1, 'a' + i - 1,
1 << k, 'a' + j - 1);
return;
}
}
int main() {
scanf("%d", &N);
if (N == 1) {
puts("0");
exit(0);
}
a[1] = 1;
ans = 7;
dfs(1, 1);
printf("%d\n", ans - 1);
for (int p = 2; p <= ans; ++p) find(p);
return 0;
}
| 2,500 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5, M = 500;
int n, a[N], lst[2 * N + 1], f = 0, nxt[N], prv[N], s[N];
vector<int> p[N];
int solve1(int v) {
int sol = 0;
for (int i = 0; i <= 2 * n; i++) lst[i] = -1;
int sum = 0;
for (int i = 0; i < n; i++) {
if (a[i] == v)
sum++;
else if (a[i] == f)
sum--;
lst[sum + n] = i;
}
for (int i = 2 * n - 1; 0 <= i; i--) lst[i] = max(lst[i], lst[i + 1]);
sum = 0;
for (int i = 0; i < n; i++) {
sol = max(sol, lst[n + sum] - i + 1);
if (a[i] == v)
sum++;
else if (a[i] == f)
sum--;
}
return sol;
}
int solve2(int v) {
int sol = 0;
int l = p[v].size();
for (int i = 0; i <= 2 * l; i++) lst[i] = -1;
int e = n;
for (int i : p[v]) {
int db = s[e - 1] - s[i];
if (db) {
for (int j = 0; j + db - 1 <= 2 * l; j++) lst[j] = lst[j + db - 1];
for (int j = max(2 * l - db + 2, 0); j <= 2 * l; j++) lst[j] = -1;
} else
for (int j = 2 * l; 1 <= j; j--) lst[j] = lst[j - 1];
db = 0;
int act = i;
while (act < e && db <= l + 1) {
act = nxt[act];
lst[l + 1 - db] = max(lst[l + 1 - db], act - 1);
db++;
}
for (int j = 2 * l - 1; 0 <= j; j--) lst[j] = max(lst[j], lst[j + 1]);
act = i;
db = 0;
while (0 <= act && db <= l) {
act = prv[act];
sol = max(sol, lst[l + db] - act);
db++;
}
e = i;
}
return sol;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = n - 1; 0 <= i; i--) p[--a[i]].push_back(i);
for (int i = 1; i < n; i++)
if (p[i].size() > p[f].size()) f = i;
nxt[n - 1] = n;
prv[0] = -1;
s[0] = (a[0] == f ? 1 : 0);
for (int i = n - 2; 0 <= i; i--)
nxt[i] = (a[i + 1] == f ? i + 1 : nxt[i + 1]);
for (int i = 1; i < n; i++) prv[i] = (a[i - 1] == f ? i - 1 : prv[i - 1]);
for (int i = 1; i < n; i++) s[i] = (a[i] == f ? s[i - 1] + 1 : s[i - 1]);
int sol = 0;
for (int v = 0; v < n; v++)
if (v != f && !p[v].empty())
sol = max(sol, (p[v].size() >= M ? solve1(v) : solve2(v)));
cout << sol << "\n";
return 0;
}
| 3,000 |
CPP
|
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = a; i <= b; ++i)
#define per(i, b, a) for(int i = b; i >= a; --i)
#define pb push_back
#define ll long long
#define ull unsigned long long
#define vi vector<int>
#define PI pair<int, int>
#define all(x) x.begin(), x.end()
#define MS(arr, val) memset(arr, 0, sizeof(arr))
using namespace std;
inline void rd(int &x){scanf("%d", &x);}
inline void rd(ll &x){scanf("%lld", &x);}
inline void rd(double &x){scanf("%lf", &x);}
inline void rd(char *s){scanf("%s", s);}
template<typename T, typename ...U> inline void rd(T &a, U &...b){rd(a), rd(b...);}
const int maxn = 814;
ll mod;
ll f[maxn * maxn], s[maxn * maxn], ans[maxn], N;
const int B = 130000;
int main()
{
rd(N, mod);
rep(i, B, 2 * B) s[i] = 1;
rep(n, 1, N - 1)
{
MS(f, 0);
rep(k, B - n * (n - 1) / 2, B + n * (n - 1) / 2)
{
f[k] = ((f[k - 1] + (s[k + n - 1] - s[k - 1]) + mod) % mod + mod - (s[k - 1] - s[k - n - 1])) % mod;
// cerr << "f(" << n << ", " << k - B << ") -> " << f[k] << endl;
}
MS(s, 0);
rep(k, 1, 2 * B)
{
s[k] = s[k - 1] + f[k], s[k] %= mod;
}
rep(d, 1, n)
ans[n + 1] += (s[n * (n - 1) / 2 + B] - s[d + B] + mod) % mod * (n - d + 1) % mod, ans[n + 1] %= mod;
// 上面一行，注意是 d + B 不是 d - 1 + B，后者计算了逆序数恰好相等的情况
// cerr << "ans[" << n + 1 << "] -> " << ans[n + 1] << endl;
}
ll ret = 0, now = 1;
rep(i, 0, N - 1) // 前面有 i 位一模一样
{
if(i) now *= (N - i + 1), now %= mod;
ret += now * ans[N - i] % mod, ret %= mod;
}
printf("%lld\n", ret);
}
| 2,700 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000 * 1000 * 1000 + 7;
const int INF = 2000 * 1000 * 1000;
const double EPS = 1e-9;
const double pi = acos(-1.0);
const int maxn = 1010;
const int maxsum = 10010;
const long long lim = (int)1e13;
template <typename T>
inline T sqr(T n) {
return (n * n);
}
int n, a[maxn], mem[maxn][2 * maxsum];
int* dp[maxn];
long long ans;
int read_int() {
char c;
do {
c = getc(stdin);
} while (c < '0' || c > '9');
int res = 0;
do {
res = res * 10 + c - '0';
c = getc(stdin);
} while (c >= '0' && c <= '9');
return res;
}
int main() {
n = read_int();
dp[0] = mem[0] + maxsum;
for (int i = 1; i <= n; i++) {
a[i] = read_int();
dp[i] = mem[i] + maxsum;
}
dp[0][0] = 1;
ans = 0;
for (int i = 1; i <= n; i++) {
for (int sum = -10000; sum <= 10000; sum++) {
if (sum + a[i] <= 10000) dp[i][sum] += dp[i - 1][sum + a[i]];
if (sum - a[i] >= -10000) dp[i][sum] += dp[i - 1][sum - a[i]];
dp[i][sum] %= MOD;
}
ans += dp[i][0];
if (ans > lim) ans %= MOD;
dp[i][0]++;
}
printf("%I64d", ans % MOD);
return 0;
}
| 2,300 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const double eps = 1e-18;
const unsigned long long base = 13331;
const int mod = 2333;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
long long u, v;
cin >> u >> v;
if (u > v) {
cout << -1;
} else if ((v - u) % 2 != 0) {
cout << -1;
} else if (!u && !v) {
cout << 0;
} else if (u == v) {
cout << 1 << '\n';
cout << u;
} else {
long long ff = (v - u) / 2;
long long gg = u ^ ff;
if (ff + gg == v) {
cout << 2 << '\n';
cout << ff << " " << gg;
} else {
cout << 3 << '\n';
cout << u << " " << ff << " " << ff;
}
}
}
| 1,700 |
CPP
|
def tup(st):
lt=st.split()
tp=tuple(lt)
return tp
s1=input()
t1=tup(s1)
s2=input()
t2=tup(s2)
s3=input()
t3=tup(s3)
s4=input()
t4=tup(s4)
s5=input()
t5=tup(s5)
lst=[]
lst.append(t1)
lst.append(t2)
lst.append(t3)
lst.append(t4)
lst.append(t5)
count=0
for N,x in enumerate(lst):
for n,y in enumerate(x):
if y=='1':
if n<2:
count=count+(2-n)
else:
count=count+(n-2)
if N<2:
count=count+(2-N)
else:
count=count+(N-2)
break
else:
pass
print(count)
| 800 |
PYTHON3
|
"""
pppppppppppppppppppp
ppppp ppppppppppppppppppp
ppppppp ppppppppppppppppppppp
pppppppp pppppppppppppppppppppp
pppppppppppppppppppppppppppppppp
pppppppppppppppppppppppp
ppppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppp
pppppppppppppppppppppppppppppppppppppppppppppppp ppppppppppppppppppppp
ppppppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppp
ppppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppppp
pppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppppppp
ppppppppppppppppppppppppppppppppppppppppppppp pppppppppppppppppppppppppppp
pppppppppppppppppppppppppppppppp pppppppppppppppppppppppppppppppp
pppppppppppppppppppppppppppp pppppppppppppppppppppppppppppppppppppppppppppp
ppppppppppppppppppppppppppp pppppppppppppppppppppppppppppppppppppppppppppppp
pppppppppppppppppppppppp pppppppppppppppppppppppppppppppppppppppppppppppppp
ppppppppppppppppppppppp ppppppppppppppppppppppppppppppppppppppppppppppppp
pppppppppppppppppppppp ppppppppppppppppppppppppppppppppppppppppppppppp
ppppppppppppppppppppp ppppppppppppppppppppppppppppppppppppppppppppp
pppppppppppppppppppppppp
pppppppppppppppppppppppppppppppp
pppppppppppppppppppppp pppppppp
ppppppppppppppppppppp ppppppp
ppppppppppppppppppp ppppp
pppppppppppppppppppp
"""
import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nsmallest
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
from decimal import Decimal
# sys.setrecursionlimit(pow(10, 6))
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(var, end="\n"): sys.stdout.write(str(var)+end)
def outa(*var, end="\n"): sys.stdout.write(' '.join(map(str, var)) + end)
def l(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
for _ in range(int(data())):
a, b = sp()
temp = abs(b - a)
answer = temp // 10 + (1 if (temp % 10) else 0)
out(answer)
| 800 |
PYTHON3
|
for _ in range(int(input())):
m,n,a,b = map(int,input().split())
if (n * b != m * a):
print("NO")
else:
print("YES")
p = "1"*a + "0"*(n-a)
for i in range(m):
print(p)
p = "".join(p[i] for i in range(n-a,n)) + "".join(p[i] for i in range(n-a))
| 1,900 |
PYTHON3
|
#import sys
#sys.stdin = open('input.txt', 'r')
#sys.stdout = open('output.txt', 'w')
t = int(input())
for _ in range(t):
n = int(input())
mx = -1
a = list(map(int, input().split()))
mx = max(a)
cond = True
for i in range(n):
if( (mx - a[i])%2 != 0):
cond = False
break
if(cond):
print('YES')
else :
print('NO')
| 900 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int q;
cin >> q;
int minn[2][100005], inf = 1000000007;
for (int i = 1; i <= 100000; i++) minn[0][i] = minn[1][i] = inf;
while (q--) {
int t;
cin >> t;
if (t == 1) {
int l, r, k;
cin >> l >> r >> k;
bool s = (k > 0);
k = abs(k);
for (int i = l; i < r; i++) minn[s][i] = min(minn[s][i], k);
} else {
int l, r;
cin >> l >> r;
long long int tot = 0;
for (int i = l; i < r; i++)
if (minn[0][i] != inf && minn[1][i] != inf)
tot += minn[0][i] + minn[1][i];
cout << tot << '\n';
}
}
}
| 3,100 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int arr[200005], n;
vector<int> adj[200005];
int lvl[200005], par[200005], table[200005][25];
void dfs(int u, int p) {
if (u == 1)
lvl[u] = 0;
else
lvl[u] = lvl[p] + 1;
par[u] = p;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v != p) dfs(v, u);
}
}
void pre() {
memset(table, -1, sizeof table);
for (int i = 1; i <= n; i++) table[i][0] = par[i];
for (int j = 1; j < 25; j++) {
for (int i = 1; i <= n; i++) {
if (table[i][j - 1] != -1) table[i][j] = table[table[i][j - 1]][j - 1];
}
}
}
int query(int u, int v) {
if (u == v) return 0;
if (lvl[u] > lvl[v]) swap(u, v);
int diff = lvl[v] - lvl[u];
int ans = 0;
for (int i = 0; i < 25; i++) {
if (diff & (1 << i)) {
ans += (1 << i);
v = table[v][i];
}
}
if (u == v) return ans;
for (int i = 25 - 1; i >= 0; i--) {
if (table[u][i] != -1 && (table[u][i] != table[v][i])) {
u = table[u][i];
v = table[v][i];
ans += 2 * (1 << i);
}
}
ans += 2;
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int v, u = i;
scanf("%d", &v);
arr[i] = v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, -1);
pre();
pair<int, int> P = make_pair(1, 1);
int ans = 0;
for (int i = 2; i <= n; i++) {
int u = P.first, v = P.second, w = i;
int d1 = query(u, w);
if (d1 > ans) {
ans = d1;
P = make_pair(u, w);
}
int d2 = query(v, w);
if (d2 > ans) {
ans = d2;
P = make_pair(v, w);
}
int d3 = query(u, v);
if (d3 > ans) {
ans = d3;
P = make_pair(u, v);
}
printf("%d ", ans);
}
}
| 2,200 |
CPP
|
n=int(input())
z=[]
for i in range(n):
a,b,c=map(int,input().split())
z.append((a+b+c)//2)
for i in range(n):
print(z[i])
| 800 |
PYTHON3
|
n = int(input())
block = list(input())
W=0
B=0
moves = []
for x in block:
if x == 'W':
W += 1
else:
B += 1
status = 0
if W%2 == 1 and B%2 ==1:
print(-1)
status = -1
else:
if W%2 == 0:
for i in range(len(block)-1):
if block[i] == 'W':
if block[i] == block[i+1]:
moves.append(i+1)
block[i] = 'B'
block[i+1] = 'B'
else:
moves.append(i+1)
block[i], block[i+1] = block[i+1], block[i]
else:
for i in range(len(block)-1):
if block[i] == 'B':
if block[i] == block[i+1]:
moves.append(i+1)
block[i] = 'W'
block[i+1] = 'W'
else:
moves.append(i+1)
block[i], block[i+1] = block[i+1], block[i]
if status != -1:
moves = list(map(str, moves))
print(len(moves))
print(" ".join(moves))
| 1,300 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long q;
cin >> q;
while (q--) {
long long n, i, x, cnt = 0;
cin >> n;
while (n) {
x = n * 2 / 3;
x = sqrt(x);
long long d = (((x * (x + 1)) / 2) * 3) - x;
if (x == 0 || d == 0) break;
if (d > n) {
x--;
d = (((x * (x + 1)) / 2) * 3) - x;
}
n -= d;
cnt++;
}
cout << cnt << endl;
}
}
| 1,100 |
CPP
|
#include <bits/stdc++.h>
void set_p(int board[8][8]) {
int i, j, k, l;
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++)
if (!(board[i][j] > 0 || board[i][j] == -4)) board[i][j] = 0;
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++)
if (board[i][j] > 0) {
if (board[i][j] == 1) {
for (k = j - 1; k >= 0 && board[i][k] <= 0; k--) board[i][k] = -1;
for (k = j + 1; k < 8 && board[i][k] <= 0; k++) board[i][k] = -1;
for (k = i - 1; k >= 0 && board[k][j] <= 0; k--) board[k][j] = -1;
for (k = i + 1; k < 8 && board[k][j] <= 0; k++) board[k][j] = -1;
} else if (board[i][j] == 2) {
for (k = i - 1; k <= i + 1; k++)
for (l = j - 1; l <= j + 1; l++)
if (k >= 0 && k < 8 && l >= 0 && l < 8 && board[k][l] <= 0)
board[k][l] = -1;
}
}
}
void cpy_board(int dest[8][8], int source[8][8]) {
int i, j;
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++) dest[i][j] = source[i][j];
}
int main() {
int x, y;
char _x;
int i, j;
int other = 0;
int board[8][8];
int temp_board[8][8];
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++) board[i][j] = 0;
scanf("%c%d ", &_x, &y);
x = _x - 'a';
y--;
board[x][y] = 1;
scanf("%c%d ", &_x, &y);
x = _x - 'a';
y--;
board[x][y] = 1;
scanf("%c%d ", &_x, &y);
x = _x - 'a';
y--;
board[x][y] = 2;
scanf("%c%d", &_x, &y);
x = _x - 'a';
y--;
board[x][y] = -4;
set_p(board);
if (board[x][y] == -4)
printf("OTHER\n");
else {
other = 0;
for (i = x - 1; i <= x + 1; i++)
for (j = y - 1; j <= y + 1; j++) {
if (i >= 0 && i < 8 && j >= 0 && j < 8)
if (board[i][j] == 0) other = 1;
if (i >= 0 && i < 8 && j >= 0 && j < 8 && board[i][j] == 1) {
cpy_board(temp_board, board);
temp_board[x][y] = 0;
temp_board[i][j] = -4;
set_p(temp_board);
other = other || (temp_board[i][j] == -4);
}
}
if (other)
printf("OTHER\n");
else
printf("CHECKMATE\n");
}
return 0;
}
| 1,700 |
CPP
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.