solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
long long int aa[10];
long long int mx[10];
long long int my[10];
long long int mz[10];
double sq(double a) { return ((a) * (a)); }
double sqdis(long long int a, long long int b, long long int c, double first,
double second, double z) {
double ans = sq(a - first) + sq(b - second) + sq(c - z);
return (ans);
}
bool valid(double xx, double yy, double zz, double first, double second,
double z) {
bool ok = (0 <= xx) and (xx <= first) and (0 <= yy) and (yy <= second) and
(0 <= zz) and (zz <= z);
return (ok);
}
int main() {
long long int first, second, z;
long long int a, b, c;
cin >> a >> b >> c;
cin >> first >> second >> z;
for (int i = 0; i < (6); i++) cin >> aa[i];
first *= 2;
second *= 2;
z *= 2;
a *= 2;
b *= 2;
c *= 2;
mx[0] = first / 2ll;
mx[1] = first / 2ll;
mx[2] = first / 2ll;
mx[3] = first / 2ll;
mx[4] = 0ll;
mx[5] = first;
my[0] = 0ll;
my[1] = second;
my[2] = second / 2ll;
my[3] = second / 2ll;
my[4] = second / 2ll;
my[5] = second / 2ll;
mz[0] = z / 2ll;
mz[1] = z / 2ll;
mz[2] = 0ll;
mz[3] = z;
mz[4] = z / 2ll;
mz[5] = z / 2ll;
int ans = 0;
for (int i = 0; i < (6); i++) {
double d = sqdis(a, b, c, mx[i], my[i], mz[i]);
double cand = d + 10;
double lam;
if (a != mx[i]) {
lam = -a / (a - mx[i] + 0.0);
double xx = 0;
double yy = lam * (b - my[i]) + b;
double zz = lam * (c - mz[i]) + c;
if (valid(xx, yy, zz, first, second, z))
cand = min(cand, sqdis(a, b, c, xx, yy, zz));
lam = (first - a) / (a - mx[i] + 0.0);
xx = first;
yy = lam * (b - my[i]) + b;
zz = lam * (c - mz[i]) + c;
if (valid(xx, yy, zz, first, second, z))
cand = min(cand, sqdis(a, b, c, xx, yy, zz));
}
if (b != my[i]) {
lam = -b / (b - my[i] + 0.0);
double yy = 0;
double xx = lam * (a - mx[i]) + a;
double zz = lam * (c - mz[i]) + c;
if (valid(xx, yy, zz, first, second, z))
cand = min(cand, sqdis(a, b, c, xx, yy, zz));
lam = (second - b) / (b - my[i] + 0.0);
yy = second;
xx = lam * (a - mx[i]) + a;
zz = lam * (c - mz[i]) + c;
if (valid(xx, yy, zz, first, second, z))
cand = min(cand, sqdis(a, b, c, xx, yy, zz));
}
if (c != mz[i]) {
lam = -c / (c - mz[i] + 0.0);
double zz = 0;
double yy = lam * (b - my[i]) + b;
double xx = lam * (a - mx[i]) + a;
if (valid(xx, yy, zz, first, second, z))
cand = min(cand, sqdis(a, b, c, xx, yy, zz));
lam = (z - c) / (c - mz[i] + 0.0);
zz = z;
xx = lam * (a - mx[i]) + a;
yy = lam * (b - my[i]) + b;
if (valid(xx, yy, zz, first, second, z))
cand = min(cand, sqdis(a, b, c, xx, yy, zz));
}
if (cand >= d) {
ans += aa[i];
}
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <vector>
#include <string>
#include <queue>
#include <deque>
#include <stack>
#include <set>
#include <map>
#include <utility>
#include <algorithm>
#include <iostream>
#include <sstream>
#include <numeric>
using namespace std;
#ifdef DBG
#define dbg 1
#define dpf(...) fprintf(stderr, __VA_ARGS__);fflush(stderr);
#else
#define dbg 0
#define dpf(...) 42
#endif
#define SIZE(x) int((x).size())
#define REP(i,c) for(auto &i : c)
#define pb push_back
#define eb emplace_back
typedef long long i64;
typedef unsigned long long u64;
const double EPS = 1e-12;
const int INF = 999999999;
typedef vector<int> VI;
typedef vector<string> VS;
const char DNA[]="ANOT";
int n;
char buf[100005];
VI a;
int c[4];
i64 Com(VI& start) {
i64 res=0;
for(int i=0;i<n;++i) {
int d=a[i];
res+=start[d]-i;
++start[d];
for (int j = 0; j < 4; ++j)
if (start[j] < start[d])
++start[j];
}
return res;
}
int Find(char c) {
return find(DNA,DNA+4,c)-DNA;
}
void Solve() {
scanf("%s",buf);
n=strlen(buf);
a.resize(n);
fill(c,c+4,0);
for(int i=0;i<n;++i) {
a[i]=Find(buf[i]);
++c[a[i]];
}
VI p={0,1,2,3};
VI start(4,0);
VI ansp;
i64 maxw=-1;
do {
int now=0;
for(int i=0;i<4;++i) {
start[p[i]]=now;
now+=c[p[i]];
}
i64 w=Com(start);
if(w>maxw) {
maxw=w;
ansp=p;
}
} while(next_permutation(p.begin(),p.end()));
for(int i=0;i<4;++i) {
int d=ansp[i];
for(int j=0;j<c[d];++j) printf("%c",DNA[d]);
}
printf("\n");
}
int main() {
int t;
scanf("%d", &t);
for (int i = 1; i <= t; ++i) {
Solve();
}
return 0;
}
| 10 | CPP |
for _ in range(int(input())):
b,p,f=map(int,input().split())
h,c=map(int,input().split())
cost=0
while b>=2:
if p==0:
h=0
if f==0:
c=0
if h>c and p>0:
b-=2
cost+=h
p-=1
#print("beef")
elif f>0 and c>=h:
b-=2
cost+=c
f-=1
#print("chicken")
else:
break
print(cost)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, j, g = 0, b = 0, g1 = 0, b1 = 0, ans = 0, g2, b2;
cin >> n >> m;
long long a[n + 2];
a[0] = 0;
for (i = 1; i <= n; i++) {
cin >> a[i];
}
a[n + 1] = m;
for (i = 1; i <= n + 1; i++) {
if (i % 2 == 1) {
g = g + a[i] - a[i - 1];
} else {
b = b + a[i] - a[i - 1];
}
}
g2 = 0, b2 = 0;
for (i = 1; i <= n + 1; i++) {
g2 = g1, b2 = b1;
if (i % 2 == 1) {
g1 = g1 + a[i] - a[i - 1];
} else {
b1 = b1 + a[i] - a[i - 1];
}
if (a[i] - a[i - 1] > 1) {
ans = max(ans, g2 + b - b1 + a[i] - a[i - 1] - 1);
}
}
cout << max(ans, g) << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:65000000")
#pragma warning(disable : 4996)
using namespace std;
string s1, s2;
vector<int> vec;
set<pair<char, char>> st;
int main() {
cin >> s1 >> s2;
int m = s1.size();
vec.resize(27, -1);
for (int i = 0; i < m; i++) {
int a1 = s1[i] - 'a' + 1;
int a2 = s2[i] - 'a' + 1;
if (a1 > a2) swap(a1, a2);
if ((vec[a1] != -1 && vec[a1] != a2) || (vec[a2] != -1 && vec[a2] != a1)) {
cout << -1;
return 0;
}
vec[a1] = a2;
vec[a2] = a1;
}
for (int i = 1; i <= 26; i++) {
if (vec[i] != -1) {
char c1 = 'a' + i - 1;
char c2 = 'a' + vec[i] - 1;
if (c1 < c2) {
st.insert({char('a' + i - 1), char('a' + vec[i] - 1)});
}
}
}
cout << st.size() << endl;
for (auto it = st.begin(); it != st.end(); ++it) {
cout << it->first << ' ' << it->second << endl;
}
return 0;
}
| 8 | CPP |
s = input()
a = s.count('-')
b = s.count('o')
if(b == 0 or a % b == 0):
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
#define EB emplace_back
typedef std::vector <int> vector;
typedef long long ll;
const int N = 162, mod = 1000000007;
int n, len, ans = 0;
int fact[N], inv[N], finv[N], C[N][N];
int a[N], b[N];
vector rem[N][N];
inline void add(int &x, const int y) {x += y - mod, x += x >> 31 & mod;}
ll PowerMod(ll a, int n, ll c = 1) {for (; n; n >>= 1, a = a * a % mod) if (n & 1) c = c * a % mod; return c;}
void init() {
int i, j;
for (inv[1] = 1, i = 2; i < N; ++i) inv[i] = ll(mod - mod / i) * inv[mod % i] % mod;
for (*C[0] = i = 1; i < N; ++i)
for (*C[i] = j = 1; j <= i; ++j) add(C[i][j] = C[i - 1][j], C[i - 1][j - 1]);
}
void dfs(int dep, int last, int cur, int n_r, int prod) {
int i, s = 0, nxt = cur + 2, n_rb = dep - n_r;
vector &U = rem[n_r][n_rb];
if (U.empty()) return;
for (i = n_rb - 1; i >= 0; --i)
if ((s += a[i] - 1) > U[n_rb - i]) return;
ans = (ans + (ll)prod * C[n + 1 + n_rb * 2][(s + n_rb * 2 + n_r) * 2]) % mod;
prod = prod * (dep + 1ll) % mod;
if (nxt <= n + 1)
a[dep] = 0, b[dep] = (last ? 0 : b[dep - 1]) + 1,
dfs(dep + 1, 0, nxt, n_r + 1, (ll)prod * inv[b[dep]] % mod);
for (i = 1; i <= last && nxt <= n + 1; ++i, nxt += 2)
a[dep] = i, b[dep] = (i == last ? b[dep - 1] : 0) + 1,
dfs(dep + 1, i, nxt, n_r, (ll)prod * inv[b[dep]] % mod);
}
int main() {
int i, j, k, n_B, c_R, c_RB, poi[N];
int h, t, que[N];
bool used[N]; char s[N];
scanf("%d%d%s", &n, &len, s), init();
n_B = std::count(s, s + len, 98);
for (i = 0; i <= len; ++i)
for (j = 0; j <= n_B; ++j) {
c_R = c_RB = h = t = 0, memset(used, false, len);
for (k = 0; k < len && c_RB < j; ++k)
if (s[k] == 114) que[t++] = k;
else if (h != t) used[ poi[c_RB++] = k ] = used[ que[h++] ] = true;
for (k = 0; k < len && c_R < i; ++k)
if (!used[k] && s[k] == 114) ++c_R, used[k] = true;
if (c_RB < j || c_R < i) continue;
vector &res = rem[i][j];
res.reserve(j + 1), res.EB(0);
for (t = 0, k = len - 1; k >= 0 && c_RB; --k)
if (t += !used[k], k == poi[c_RB - 1]) res.EB(t), --c_RB;
assert((int)res.size() == j + 1);
}
dfs(0, INT_MAX, 0, 0, 1);
printf("%d\n", ans);
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, cnt = 0, nm, ind;
cin >> n;
map<int, int> mp;
vector<pair<int, pair<int, int> > > first;
vector<pair<int, pair<int, int> > >::iterator it;
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> k;
v.push_back(k);
mp[k]++;
if (mp[k] > cnt) {
cnt = mp[k];
nm = k;
}
if (v[i] == nm) {
ind = i;
}
}
for (int i = ind - 1; i >= 0; i--) {
if (v[i] != nm) {
if (v[i] < nm) {
first.push_back(make_pair(1, make_pair(i + 1, i + 2)));
} else if (v[i] > nm) {
first.push_back(make_pair(2, make_pair(i + 1, i + 2)));
}
}
}
for (int i = ind + 1; i < n; i++) {
if (v[i] != nm) {
if (v[i] < nm) {
first.push_back(make_pair(1, make_pair(i + 1, i)));
} else if (v[i] > nm) {
first.push_back(make_pair(2, make_pair(i + 1, i)));
}
}
}
cout << n - cnt << endl;
for (it = first.begin(); it != first.end(); it++) {
cout << it->first << " " << it->second.first << " " << it->second.second
<< endl;
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int line_len = 0;
vector<string> lines;
int main() {
string s;
while (!cin.eof()) {
getline(cin, s);
if (cin.eof()) break;
lines.push_back(s);
if (s.size() > line_len) line_len = s.size();
}
string top_bot = "";
for (int i = 0; i < line_len + 2; i++) top_bot += "*";
cout << top_bot << endl;
bool left = true;
int left_spaces, right_spaces;
for (int i = 0; i < lines.size(); i++) {
left_spaces = (line_len - lines[i].size()) / 2;
right_spaces = (line_len - lines[i].size() + 1) / 2;
if ((line_len - lines[i].size()) % 2 != 0) {
if (left) {
left_spaces = (line_len - lines[i].size()) / 2;
right_spaces = (line_len - lines[i].size() + 1) / 2;
} else {
left_spaces = (line_len - lines[i].size() + 1) / 2;
right_spaces = (line_len - lines[i].size()) / 2;
}
left = !left;
}
cout << "*";
for (int j = 0; j < left_spaces; j++) cout << " ";
cout << lines[i];
for (int j = 0; j < right_spaces; j++) cout << " ";
cout << "*" << endl;
}
cout << top_bot << endl;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 505;
string s1, s;
long long n, n1;
long long dp[maxn][maxn];
long long dfs(int l, int r) {
if (dp[l][r] != -1) return dp[l][r];
long long ans = 1ll + dfs(l + 1, r);
for (int i = l + 1; i <= r; i++) {
if (s[i] == s[l]) {
ans = min(ans, dfs(l + 1, i - 1) + dfs(i, r));
}
}
return dp[l][r] = ans;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n1;
cin >> s1;
s1 = " " + s1;
s = " ";
for (int i = 1; i <= n1; i++) {
if (s1[i] != s1[i - 1]) {
string tp = " ";
tp[0] = s1[i];
s += tp;
n++;
}
}
for (int i = 1; i <= n; i++) dp[i][i] = 1;
cout << dfs(1, n) << endl;
}
| 12 | CPP |
t = int(input())
ans = []
m = [int(input()) for x in range(t)]
for x in range(t):
targetM = m[x]
mass = 1
n = 1
night = 0
prevMass = 0
prevN = 0
splits = []
while mass < targetM :
prevMass = mass
prevN = n
splits.append(n)
mass = (2*mass)+1
n = 2*n
night += 1
if mass == targetM:
ans.append(night)
ans.append(" ".join(str(elem) for elem in splits))
#print("Target mass: %d \nCurrent Mass: %d \nNumber of bacteria: %d\nNights: %d"%(targetM,mass,n,night))
else:
s = targetM - prevMass - prevN
if s >= 0:
splits[-1] = s
else:
s = int(targetM - (prevMass-(0.5*prevN)) - (0.5*prevN))
prevN = prevN/2
if s > prevN:
splits[-2] = int(s%prevN)
splits[-1] = s-(2*splits[-2])
else:
splits[-2] = 0
splits[-1] = s
ans.append(night)
ans.append(" ".join(str(elem) for elem in splits))
#print("Target mass: %d \nCurrent Mass: %d \nNumber of bacteria: %d\nNights: %d"%(targetM, prevMass, prevN, night))
for elem in ans:
print(elem)
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define max(a, b) ((a)>(b) ? (a):(b))
#define min(a, b) ((a)<(b) ? (a):(b))
#define mod 1000000007
typedef struct node{
int first;
int second;
}node;
bool operator<(const node &a, const node &b) {
return a.first > b.first;
}
void solve() {
int i;
int n, m, x;
cin >> n >> m >> x;
node h[n];
int belong[n];
priority_queue <node> th;
for(i=0; i<n; i++) {
cin >> h[i].first;
h[i].second = i;
}
node tmp;
for(i=0; i<m; i++) {
tmp.first = 0;
tmp.second = i;
th.push(tmp);
}
sort(h, h+n);
for(i=0; i<n; i++) {
tmp = th.top();
tmp.first += h[i].first;
th.pop();
th.push(tmp);
belong[h[i].second] = tmp.second;
}
int fth[m];
i = 0;
while(!th.empty()) {
tmp = th.top();
//cout << tmp.first << " " << tmp.second << "\n";
fth[i++] = tmp.first;
th.pop();
}
if(fth[m-1] - fth[0] > x) {
cout << "NO\n";
return;
}
cout << "YES\n";
for(int i: belong)
cout << i+1 << " ";
cout << "\n";
}
int main() {
//freopen("Input.txt", "r", stdin);
int t=1;
cin >> t;
for(int i=1; i<=t; i++) {
solve();
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int X[N], inv[N];
pair<int, int> B[N];
int n, m, a, l;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", X + i);
B[i] = {X[i], i};
}
sort(B + 1, B + n + 1);
for (int i = 1; i <= n; ++i) inv[B[i].second] = i;
while (m--) {
scanf("%d %d", &a, &l);
a = inv[a];
int prev = -1;
bool ok = 1;
int lo, hi;
while (l) {
if (ok) {
lo = a;
hi = n;
while (lo < hi) {
int mid = lo + (hi - lo + 1) / 2;
if (B[mid].first - B[a].first <= l)
lo = mid;
else
hi = mid - 1;
}
} else {
lo = 1;
hi = a;
while (lo < hi) {
int mid = lo + (hi - lo) / 2;
if (B[a].first - B[mid].first > l)
lo = mid + 1;
else
hi = mid;
}
}
if (lo == prev) {
if (lo == a) break;
l %= 2 * abs(B[a].first - B[lo].first);
if (l == 0) break;
}
if (l >= abs(B[a].first - B[lo].first)) {
l -= abs(B[a].first - B[lo].first);
prev = a;
a = lo;
ok ^= 1;
}
}
cout << B[a].second << endl;
}
return 0;
}
| 10 | CPP |
n = int(input())
print(n)
x = [1] * n
print(*x)
| 7 | PYTHON3 |
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
for(int z;cin>>z,z;){
long long res=1ll<<50;
for(int i=1;i<z;i++)
for(int j=1;j<z;j++){
long long temp=(long long)z*z*z-i*i*i-j*j*j;
if(temp>0)
res=min(res,temp);
}
cout<<res<<endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a,b; cin>>a>>b;
cout<<a*b<<' '<<2*(a+b)<<'\n';
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, i, stat, l0, ans0, ans1;
string s;
bool islet(int k) {
if (s[k] >= 'A' && s[k] <= 'Z' || s[k] >= 'a' && s[k] <= 'z')
return true;
else
return false;
}
int main() {
cin >> n;
cin >> s;
s = "_" + s + "_";
n++;
for (i = 1; i < n; i++) {
if (islet(i) && islet(i - 1) == false) {
if (stat == 1)
ans1++;
else
l0 = 1;
}
if (islet(i) && islet(i - 1) && stat == 0) l0++;
if (s[i] == '(') stat = 1;
if (s[i] == ')') stat = 0;
ans0 = max(ans0, l0);
}
cout << ans0 << " " << ans1 << endl;
}
| 8 | CPP |
x = abs(int(input()))
jump = 0
pos = 0
while pos < x:
jump += 1
pos += jump
# if (x - pos) % 2 == 0 we can change the sign of (x - pos) // 2
while (x - pos) % 2 != 0:
jump += 1
pos += jump
print(jump)
| 8 | PYTHON3 |
#include <iostream>
#include <algorithm>
using namespace std;
#define rep(i,n) for (int i = 0; i < int(n); i++)
int main() {
int T;
cin >> T;
rep (_, T) {
long long gx, gy, p, x1, x2, y1, y2, a[20][20], b[20][20];
rep (i,20) rep (j,20) a[i][j] = b[i][j] = 0;
a[0][0] = 1;
cin >> gx >> gy >> p;
rep (i,p) {
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) b[x1][min(y1, y2)] += 1;
if (y1 == y2) b[min(x1, x2)][y1] += 2;
}
rep (i,19) rep (j,19) {
if (b[i][j] != 1 && b[i][j] != 3)
a[i][j+1] += a[i][j];
if (b[i][j] != 2 && b[i][j] != 3)
a[i+1][j] += a[i][j];
}
// rep (j, 20) {
// rep (i,20) cout << a[i][j] << " ";
// cout << endl;
// }
// cout << endl;
// rep (j, 20) {
// rep (i,20) cout << b[i][j] << " ";
// cout << endl;
// }
// cout << endl;
// rep (j, 20) {
// rep (i,20) cout << (b[i][j] & 1) << " ";
// cout << endl;
// }
// cout << endl;
// rep (j, 20) {
// rep (i,20) cout << (b[i][j] & 2) << " ";
// cout << endl;
// }
if (a[gx][gy] == 0) {
cout << "Miserable Hokusai!" << endl;
} else {
cout << a[gx][gy] << endl;
}
}
} | 0 | CPP |
from sys import stdin, stdout
from math import *
from heapq import *
from collections import *
def main():
ntest=int(stdin.readline())
for testcase in range(ntest):
x,y=[int(z) for z in stdin.readline().split()]
a,b=[int(z) for z in stdin.readline().split()]
res=0
dist=abs(x-y)
res=((min(x,y)*min(a*2,b))+(dist*a))
stdout.write("%d\n"%res)
return 0
if __name__ == "__main__":
main() | 7 | PYTHON3 |
inp=input()
length=len(inp)
lucky = ['4','7']
list1 = []
def checklucky(b):
a=list(str(b))
for i in a:
if i not in lucky:
return False
else:
continue
return True
def countdigit(b):
a=list(str(b))
count=0
for i in a:
if i in lucky:
count+=1
continue
else:
continue
return count
for i in range(4, length+1):
if checklucky(i)==True:
list1.append(i)
continue
else:
continue
if countdigit(int(inp)) in list1:
print('YES')
else:
print('NO')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const int INF = 0x3f3f3f3f, N = 2000005, M = 2000005, MOD = 1e9 + 7;
int sgn(double x) { return x < -eps ? -1 : (x < eps ? 0 : 1); }
int Rand(int x) { return rand() * rand() % x + 1; }
struct node {
int x, y, bel, id;
} a[N];
int Solve() {
int n;
cin >> n;
int sn = sqrt(1000000);
for (int i = 1; i <= n; i++) {
cin >> a[i].x >> a[i].y;
a[i].bel = a[i].x / sn;
a[i].id = i;
}
sort(a + 1, a + 1 + n, [](node a, node b) {
if (a.bel != b.bel) return a.bel < b.bel;
if (a.bel & 1)
return a.y < b.y;
else
return a.y > b.y;
});
for (int i = 1; i <= n; i++) {
cout << a[i].id;
if (i == n)
cout << '\n';
else
cout << " ";
}
return 0;
}
void Pre() {}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
Pre();
while (Solve())
;
return 0;
}
| 9 | CPP |
#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;const int N=2*1e5+10;
int w[N];int d[N];int cnt[20];int res;int n;int st;bool book[N];int sxr[N];
int main()
{
scanf("%d",&n);
for(int i=1,u,v,va;i<n;i++){scanf("%d%d%d",&u,&v,&va);w[u]^=va;w[v]^=va;}
for(int i=0;i<n;i++){cnt[w[i]]++;}
for(int i=1;i<=15;i++)res+=cnt[i]/2,st|=(cnt[i]&1)<<(i-1);
for(int i=1;i<(1<<15);i++)d[i]=d[i>>1]+(i&1);
for(int i=1;i<(1<<15);i++)d[i]-=1;
for(int i=1;i<(1<<15);i++)
for(int j=0;j<15;j++)if((i>>j)&1)sxr[i]^=(j+1);
for(int i=1;i<(1<<15);i++)
{
if(sxr[i]!=0)continue;
for(int k=(i-1)&i;k;k=(k-1)&i)
if(sxr[k]==0)d[i]=min(d[i],d[k]+d[i^k]);
}printf("%d",res+d[st]);return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
cin >> n;
for (int a = 1; a <= n; a++) {
for (int b = a + 1; b <= n; b++) {
int c = a ^ b;
if (a + b > c && c > a && c > b && c <= n) ans++;
}
}
cout << ans;
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
vector<long long int> v;
for (int i = 0; i < t; i++) {
long long int k;
cin >> k;
v.push_back(k);
}
for (int i = 0; i < v.size(); i++) {
if (v[i] % 2 == 0) {
v[i] = v[i] - 1;
}
}
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f;
using namespace std;
char in[4][105][105];
char cur[205][205];
int u[4];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < 4; i++)
for (int j = 0; j < n; j++) scanf("%s", in[i][j]);
for (int i = 0; i < 4; i++) u[i] = i;
int ans = INF;
do {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
cur[(i / 2) * n + j][(i % 2) * n + k] = in[u[i]][j][k];
}
int cnt = 0;
for (int i = 0; i < 2 * n; i++) {
for (int j = 0; j < 2 * n; j++) {
char c = '0' + (i + j) % 2;
if (c != cur[i][j]) cnt++;
}
}
ans = min(ans, cnt);
} while (next_permutation(u, u + 4));
return printf("%d\n", ans), 0;
}
| 9 | CPP |
from math import gcd
t = int(input())
for _ in range(t):
r, b, k = (int(x) for x in input().split(' '))
g = gcd(r, b)
if (k - 1) * min(r / g, b / g) + 1 >= max(r / g, b / g):
print('OBEY')
else:
print('REBEL')
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int getint() {
int ret = 0;
bool ok = false, neg = false;
for (;;) {
int c = getchar();
if (c >= '0' && c <= '9')
ret = (ret << 3) + ret + ret + c - '0', ok = true;
else if (ok)
return neg ? -ret : ret;
else if (c == '-')
neg = true;
}
}
struct item {
long long d;
int m, f, r;
bool operator<(const item &k2) const { return d < k2.d; }
item() {}
item(long long _d, int _m, int _f, int _r) : d(_d), m(_m), f(_f), r(_r) {}
};
item A[250010];
int n;
int T[1 << 19], M = 1;
const int inf = ~0U >> 1;
inline int minm(int a, int b) { return A[a].m < A[b].m ? a : b; }
void remove(int i) {
i += M;
T[i] = 0;
for (i >>= 1; i; i >>= 1) T[i] = minm(T[i + i], T[i + i + 1]);
}
int getpos(int r) {
item t = item((long long)r * r, 0, 0, 0);
return upper_bound(A + 1, A + n + 1, t) - A - 1;
}
int query(int l, int r) {
if (l > r) return 0;
int ret = 0;
for (l += M - 1, r += M + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
if (~l & 1) ret = minm(ret, T[l + 1]);
if (r & 1) ret = minm(ret, T[r - 1]);
}
return ret;
}
queue<pair<int, int> > Q;
int main() {
int x0 = getint(), y0 = getint(), f0 = getint(), r0 = getint();
n = getint();
for (int i = 1; i <= n; i++) {
long long x = getint() - x0, y = getint() - y0, d = x * x + y * y;
int m = getint(), f = getint(), r = getint();
A[i] = item(d, m, f, r);
}
sort(A + 1, A + n + 1);
while (M - 2 < n) M <<= 1;
A[0].m = inf;
for (int i = 1; i <= n; i++) T[i + M] = i;
for (int i = M; i; i--) T[i] = minm(T[i + i], T[i + i + 1]);
int ans = 0;
Q.push(make_pair(f0, r0));
while (!Q.empty()) {
int f = Q.front().first, r = Q.front().second;
Q.pop();
int R = getpos(r);
for (;;) {
int t = query(1, R);
if (t && A[t].m <= f)
ans++, Q.push(make_pair(A[t].f, A[t].r)), remove(t);
else
break;
}
}
printf("%d\n", ans);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long INF = INT_MAX;
const long long LINF = LLONG_MAX;
const long long N = 1e5 + 1;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, i, j, q;
string s;
cin >> s >> q;
n = s.size();
set<int> a[26];
for (i = 0; i < n; i++) a[s[i] - 'a'].insert(i + 1);
while (q--) {
int aa;
cin >> aa;
if (aa == 1) {
int pos;
char c;
cin >> pos >> c;
a[s[pos - 1] - 'a'].erase(pos);
s[pos - 1] = c;
a[c - 'a'].insert(pos);
} else {
int l, r, ans = 0;
cin >> l >> r;
for (i = 0; i < 26; i++) {
auto w = a[i].lower_bound(l);
if (w != a[i].end() && *w <= r) ans++;
}
cout << ans << '\n';
}
}
return 0;
}
| 10 | CPP |
cases = int(input())
for case in range(cases):
n = int(input())
l = [int(s) for s in input().split()]
end = max(l)+2
d = {}
for i in range(end):
d[i] = 0
for k in l:
d[k] +=1
m1 = 0
m2 = 0
for i in range(end):
if d[i]<1:
m1 = i
break
for i in range(end):
if d[i]<2:
m2 = i
break
print(max(0,m1)+max(0,m2)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300000000;
const int BLOCK = 100000;
const int NUM = 3000;
const int num[] = {
4784, 4194, 4003, 3920, 3831, 3791, 3726, 3667, 3669, 3591, 3642, 3612,
3532, 3554, 3507, 3500, 3517, 3449, 3496, 3432, 3462, 3406, 3394, 3376,
3378, 3445, 3362, 3368, 3371, 3305, 3369, 3386, 3336, 3320, 3302, 3273,
3356, 3286, 3307, 3284, 3327, 3291, 3247, 3251, 3306, 3241, 3278, 3231,
3271, 3248, 3239, 3184, 3227, 3204, 3235, 3210, 3216, 3191, 3211, 3222,
3193, 3206, 3234, 3157, 3149, 3191, 3188, 3193, 3225, 3192, 3182, 3138,
3152, 3135, 3106, 3167, 3211, 3130, 3141, 3137, 3125, 3129, 3135, 3122,
3125, 3160, 3154, 3168, 3106, 3117, 3076, 3149, 3118, 3135, 3063, 3171,
3091, 3103, 3099, 3075, 3087, 3126, 3071, 3086, 3114, 3074, 3101, 3069,
3091, 3080, 3080, 3101, 3067, 3111, 3079, 3117, 3093, 3089, 3103, 3073,
3040, 3054, 3122, 3079, 3021, 3024, 3098, 3068, 3057, 3013, 3014, 3077,
3020, 3073, 3038, 3027, 3039, 3044, 3061, 3012, 2998, 3043, 3054, 3066,
3018, 3025, 3037, 3035, 3015, 3010, 3004, 3014, 3018, 2931, 2994, 3015,
3025, 3032, 3075, 3031, 2990, 2994, 3030, 2994, 3050, 2997, 2973, 3008,
3017, 3034, 2998, 2962, 3052, 2980, 2996, 3025, 3000, 2994, 2973, 3022,
2961, 2981, 3039, 2964, 2968, 2941, 3016, 2992, 3014, 2978, 2983, 3006,
2970, 2968, 2999, 2936, 2985, 2983, 2950, 3034, 2953, 2964, 2930, 2950,
2965, 2996, 2968, 2960, 2962, 2952, 2972, 2933, 3012, 2982, 3002, 2904,
2965, 2963, 2974, 3012, 2915, 2921, 2947, 2908, 2934, 2998, 2925, 2951,
2971, 2936, 2986, 2949, 2951, 2958, 2936, 2930, 2957, 2895, 2926, 2934,
2899, 2971, 3011, 2951, 2937, 2925, 2916, 2968, 2931, 2927, 2944, 2913,
2902, 2936, 2912, 2925, 2955, 2939, 2936, 2912, 2935, 2905, 2928, 2956,
2968, 2923, 2953, 2902, 2938, 2928, 2928, 2902, 2886, 2942, 2873, 2980,
2886, 2911, 2920, 2922, 2968, 2876, 2924, 2904, 2952, 2885, 2910, 2924,
2901, 2928, 2887, 2887, 2961, 2911, 2882, 2896, 2897, 2874, 2941, 2958,
2898, 2926, 2916, 2933, 2873, 2969, 2886, 2907, 2938, 2845, 2855, 2898,
2883, 2900, 2902, 2887, 2889, 2877, 2905, 2879, 2901, 2891, 2867, 2867,
2869, 2906, 2888, 2893, 2870, 2921, 2878, 2910, 2914, 2864, 2879, 2898,
2841, 2919, 2943, 2856, 2817, 2837, 2899, 2823, 2901, 2878, 2824, 2888,
2880, 2906, 2855, 2854, 2907, 2902, 2862, 2859, 2918, 2890, 2835, 2847,
2898, 2844, 2923, 2857, 2884, 2917, 2840, 2875, 2831, 2880, 2907, 2916,
2859, 2861, 2831, 2841, 2871, 2854, 2898, 2849, 2905, 2896, 2903, 2868,
2835, 2845, 2853, 2926, 2874, 2849, 2832, 2876, 2859, 2885, 2887, 2853,
2913, 2828, 2842, 2820, 2900, 2805, 2866, 2860, 2877, 2834, 2852, 2923,
2817, 2850, 2840, 2884, 2796, 2860, 2885, 2826, 2842, 2842, 2843, 2799,
2817, 2871, 2909, 2841, 2853, 2791, 2809, 2854, 2815, 2832, 2818, 2866,
2800, 2872, 2877, 2865, 2774, 2846, 2881, 2890, 2847, 2805, 2869, 2789,
2850, 2828, 2844, 2850, 2846, 2827, 2821, 2783, 2882, 2855, 2823, 2845,
2853, 2821, 2840, 2792, 2822, 2788, 2859, 2846, 2819, 2805, 2890, 2830,
2846, 2881, 2755, 2890, 2829, 2813, 2862, 2820, 2835, 2828, 2871, 2810,
2840, 2826, 2778, 2865, 2835, 2837, 2809, 2800, 2840, 2826, 2836, 2807,
2829, 2834, 2822, 2843, 2815, 2806, 2861, 2805, 2786, 2842, 2792, 2813,
2841, 2840, 2817, 2827, 2795, 2816, 2780, 2799, 2796, 2897, 2789, 2820,
2738, 2852, 2791, 2818, 2863, 2787, 2765, 2826, 2773, 2820, 2823, 2817,
2784, 2812, 2770, 2814, 2856, 2793, 2778, 2781, 2822, 2779, 2809, 2850,
2793, 2835, 2765, 2790, 2760, 2869, 2785, 2801, 2769, 2866, 2861, 2767,
2812, 2767, 2790, 2765, 2841, 2805, 2816, 2811, 2808, 2894, 2762, 2769,
2810, 2756, 2848, 2802, 2760, 2762, 2776, 2802, 2837, 2832, 2802, 2813,
2785, 2757, 2828, 2785, 2791, 2765, 2781, 2835, 2755, 2835, 2779, 2784,
2802, 2765, 2765, 2800, 2756, 2746, 2808, 2797, 2802, 2800, 2830, 2795,
2793, 2772, 2783, 2822, 2839, 2768, 2826, 2800, 2797, 2776, 2769, 2727,
2790, 2774, 2821, 2716, 2761, 2788, 2755, 2812, 2854, 2782, 2796, 2789,
2746, 2762, 2767, 2807, 2770, 2774, 2784, 2805, 2744, 2805, 2772, 2761,
2768, 2844, 2807, 2778, 2792, 2812, 2842, 2775, 2773, 2728, 2792, 2757,
2783, 2777, 2831, 2752, 2829, 2711, 2844, 2745, 2803, 2774, 2780, 2752,
2791, 2809, 2749, 2806, 2771, 2777, 2801, 2768, 2725, 2786, 2728, 2779,
2792, 2809, 2820, 2767, 2745, 2771, 2768, 2815, 2729, 2783, 2791, 2766,
2807, 2753, 2769, 2811, 2743, 2764, 2783, 2807, 2713, 2813, 2769, 2777,
2820, 2728, 2741, 2748, 2765, 2791, 2760, 2745, 2781, 2788, 2755, 2741,
2739, 2746, 2767, 2767, 2808, 2735, 2778, 2787, 2766, 2695, 2826, 2731,
2794, 2743, 2777, 2765, 2769, 2780, 2801, 2754, 2789, 2751, 2768, 2691,
2752, 2778, 2740, 2795, 2771, 2750, 2779, 2710, 2718, 2741, 2764, 2799,
2749, 2788, 2741, 2785, 2768, 2735, 2761, 2728, 2759, 2777, 2809, 2775,
2738, 2771, 2786, 2776, 2731, 2760, 2702, 2774, 2749, 2760, 2765, 2724,
2747, 2798, 2763, 2766, 2758, 2767, 2749, 2717, 2700, 2758, 2733, 2747,
2734, 2766, 2764, 2765, 2728, 2757, 2705, 2792, 2683, 2754, 2773, 2739,
2720, 2747, 2781, 2726, 2769, 2756, 2734, 2698, 2765, 2732, 2771, 2769,
2752, 2724, 2721, 2765, 2766, 2733, 2806, 2754, 2717, 2729, 2773, 2737,
2774, 2734, 2757, 2797, 2772, 2680, 2716, 2745, 2736, 2758, 2746, 2748,
2776, 2777, 2723, 2669, 2760, 2689, 2758, 2748, 2750, 2718, 2809, 2824,
2664, 2749, 2717, 2774, 2775, 2713, 2685, 2758, 2725, 2767, 2724, 2710,
2719, 2785, 2782, 2755, 2715, 2762, 2700, 2695, 2778, 2724, 2706, 2752,
2740, 2747, 2702, 2700, 2739, 2716, 2792, 2717, 2765, 2704, 2700, 2783,
2750, 2743, 2771, 2747, 2744, 2710, 2765, 2729, 2760, 2638, 2781, 2735,
2739, 2725, 2708, 2779, 2769, 2706, 2729, 2717, 2718, 2690, 2762, 2688,
2692, 2720, 2759, 2756, 2727, 2739, 2683, 2736, 2710, 2697, 2731, 2724,
2806, 2707, 2693, 2649, 2741, 2725, 2700, 2751, 2724, 2765, 2710, 2749,
2752, 2714, 2760, 2747, 2754, 2670, 2699, 2730, 2717, 2736, 2731, 2699,
2677, 2697, 2714, 2789, 2778, 2702, 2705, 2677, 2701, 2761, 2749, 2699,
2781, 2755, 2697, 2699, 2733, 2710, 2769, 2736, 2699, 2701, 2727, 2757,
2706, 2747, 2669, 2727, 2700, 2722, 2754, 2726, 2714, 2734, 2735, 2687,
2730, 2669, 2725, 2745, 2688, 2729, 2722, 2737, 2691, 2722, 2728, 2683,
2699, 2772, 2725, 2659, 2731, 2676, 2769, 2683, 2680, 2721, 2697, 2737,
2704, 2708, 2709, 2735, 2721, 2714, 2721, 2663, 2718, 2695, 2745, 2691,
2684, 2749, 2713, 2707, 2723, 2704, 2712, 2669, 2763, 2668, 2701, 2737,
2719, 2696, 2749, 2769, 2676, 2723, 2729, 2683, 2746, 2688, 2735, 2624,
2698, 2700, 2729, 2684, 2704, 2676, 2692, 2779, 2710, 2719, 2744, 2724,
2705, 2699, 2697, 2697, 2727, 2685, 2734, 2674, 2712, 2714, 2699, 2716,
2680, 2709, 2679, 2696, 2732, 2704, 2712, 2661, 2702, 2735, 2695, 2663,
2726, 2645, 2758, 2735, 2696, 2755, 2696, 2668, 2744, 2717, 2695, 2622,
2708, 2712, 2711, 2715, 2747, 2700, 2745, 2701, 2684, 2720, 2688, 2749,
2726, 2652, 2759, 2665, 2714, 2716, 2700, 2764, 2701, 2644, 2677, 2656,
2727, 2658, 2743, 2695, 2723, 2693, 2705, 2698, 2657, 2731, 2674, 2698,
2705, 2761, 2728, 2717, 2743, 2722, 2699, 2698, 2633, 2686, 2703, 2750,
2680, 2662, 2714, 2716, 2656, 2696, 2685, 2655, 2694, 2652, 2671, 2653,
2668, 2713, 2685, 2697, 2685, 2642, 2782, 2694, 2664, 2675, 2710, 2689,
2736, 2651, 2702, 2698, 2673, 2705, 2632, 2732, 2707, 2682, 2684, 2726,
2622, 2688, 2670, 2657, 2680, 2711, 2694, 2654, 2722, 2697, 2681, 2730,
2674, 2673, 2666, 2701, 2717, 2717, 2692, 2681, 2698, 2710, 2670, 2626,
2674, 2696, 2719, 2689, 2699, 2690, 2674, 2727, 2675, 2688, 2687, 2677,
2688, 2640, 2709, 2627, 2691, 2664, 2714, 2664, 2724, 2675, 2733, 2680,
2641, 2684, 2706, 2717, 2611, 2696, 2662, 2693, 2712, 2636, 2651, 2719,
2685, 2673, 2689, 2708, 2729, 2677, 2678, 2735, 2693, 2703, 2661, 2710,
2680, 2686, 2656, 2732, 2674, 2674, 2713, 2699, 2670, 2640, 2689, 2709,
2646, 2717, 2646, 2705, 2690, 2677, 2660, 2660, 2664, 2721, 2676, 2689,
2675, 2697, 2709, 2616, 2671, 2714, 2675, 2653, 2661, 2717, 2742, 2662,
2656, 2688, 2716, 2658, 2701, 2675, 2681, 2678, 2725, 2649, 2679, 2656,
2641, 2720, 2708, 2735, 2734, 2665, 2643, 2719, 2659, 2670, 2718, 2679,
2676, 2742, 2578, 2697, 2638, 2646, 2626, 2720, 2656, 2628, 2697, 2719,
2666, 2710, 2658, 2678, 2715, 2704, 2688, 2683, 2702, 2658, 2630, 2700,
2665, 2684, 2711, 2646, 2670, 2707, 2655, 2673, 2690, 2613, 2737, 2674,
2584, 2703, 2695, 2667, 2643, 2651, 2645, 2710, 2661, 2671, 2699, 2691,
2720, 2641, 2677, 2670, 2659, 2695, 2709, 2646, 2677, 2631, 2709, 2585,
2655, 2687, 2638, 2653, 2637, 2667, 2635, 2686, 2732, 2672, 2695, 2658,
2631, 2658, 2643, 2629, 2693, 2671, 2705, 2686, 2665, 2707, 2629, 2577,
2650, 2669, 2590, 2681, 2662, 2688, 2649, 2647, 2705, 2684, 2653, 2705,
2636, 2693, 2726, 2693, 2684, 2680, 2639, 2727, 2724, 2652, 2609, 2662,
2643, 2669, 2656, 2619, 2598, 2707, 2612, 2648, 2696, 2710, 2609, 2703,
2671, 2698, 2657, 2664, 2699, 2642, 2671, 2706, 2635, 2615, 2669, 2659,
2671, 2639, 2707, 2627, 2709, 2687, 2657, 2649, 2654, 2690, 2657, 2680,
2672, 2671, 2681, 2701, 2645, 2652, 2704, 2605, 2653, 2655, 2684, 2647,
2678, 2649, 2669, 2639, 2646, 2654, 2694, 2672, 2663, 2667, 2676, 2652,
2670, 2650, 2653, 2671, 2662, 2678, 2697, 2616, 2647, 2687, 2675, 2678,
2603, 2630, 2639, 2687, 2683, 2618, 2646, 2652, 2661, 2667, 2639, 2652,
2670, 2611, 2641, 2669, 2623, 2690, 2642, 2670, 2625, 2704, 2671, 2628,
2643, 2655, 2632, 2650, 2668, 2629, 2641, 2667, 2615, 2617, 2664, 2636,
2658, 2655, 2646, 2633, 2628, 2703, 2639, 2693, 2641, 2604, 2596, 2601,
2666, 2623, 2663, 2670, 2633, 2641, 2687, 2627, 2609, 2669, 2642, 2706,
2688, 2670, 2701, 2618, 2679, 2643, 2645, 2637, 2628, 2658, 2649, 2602,
2682, 2654, 2660, 2614, 2679, 2584, 2662, 2711, 2637, 2617, 2640, 2652,
2730, 2665, 2639, 2663, 2658, 2651, 2670, 2666, 2645, 2655, 2599, 2608,
2677, 2652, 2698, 2651, 2620, 2617, 2634, 2659, 2678, 2590, 2653, 2667,
2648, 2535, 2634, 2616, 2632, 2686, 2653, 2650, 2596, 2645, 2672, 2691,
2602, 2667, 2659, 2648, 2588, 2695, 2645, 2641, 2673, 2653, 2634, 2603,
2717, 2621, 2725, 2641, 2626, 2588, 2653, 2646, 2635, 2639, 2621, 2625,
2611, 2657, 2662, 2673, 2648, 2648, 2649, 2663, 2634, 2623, 2645, 2631,
2678, 2642, 2628, 2692, 2710, 2639, 2667, 2661, 2612, 2611, 2695, 2629,
2616, 2652, 2671, 2597, 2648, 2621, 2587, 2639, 2644, 2632, 2679, 2610,
2602, 2632, 2647, 2682, 2559, 2641, 2671, 2658, 2697, 2604, 2614, 2647,
2604, 2650, 2646, 2646, 2636, 2610, 2706, 2584, 2628, 2629, 2673, 2640,
2632, 2628, 2644, 2636, 2631, 2626, 2708, 2594, 2651, 2628, 2703, 2671,
2641, 2672, 2683, 2635, 2597, 2638, 2646, 2583, 2677, 2662, 2624, 2648,
2644, 2618, 2607, 2583, 2660, 2623, 2671, 2630, 2665, 2643, 2641, 2621,
2603, 2666, 2628, 2604, 2665, 2652, 2638, 2644, 2624, 2638, 2632, 2644,
2631, 2622, 2627, 2694, 2621, 2681, 2641, 2660, 2658, 2572, 2626, 2654,
2635, 2636, 2625, 2640, 2648, 2620, 2558, 2675, 2651, 2618, 2629, 2651,
2668, 2619, 2646, 2662, 2613, 2605, 2621, 2645, 2628, 2599, 2649, 2657,
2616, 2613, 2654, 2640, 2605, 2670, 2652, 2635, 2604, 2691, 2610, 2617,
2614, 2647, 2652, 2668, 2660, 2647, 2621, 2604, 2629, 2623, 2649, 2630,
2706, 2579, 2672, 2618, 2629, 2657, 2641, 2614, 2652, 2697, 2659, 2630,
2645, 2610, 2622, 2607, 2623, 2645, 2600, 2634, 2599, 2583, 2645, 2587,
2671, 2646, 2613, 2604, 2649, 2635, 2599, 2693, 2620, 2667, 2622, 2545,
2597, 2604, 2640, 2635, 2593, 2605, 2656, 2627, 2587, 2623, 2633, 2631,
2654, 2618, 2605, 2624, 2623, 2631, 2670, 2639, 2629, 2648, 2645, 2655,
2615, 2635, 2625, 2669, 2625, 2647, 2603, 2584, 2608, 2612, 2620, 2658,
2653, 2637, 2584, 2617, 2641, 2602, 2630, 2617, 2668, 2619, 2626, 2671,
2618, 2635, 2663, 2576, 2557, 2642, 2603, 2650, 2646, 2688, 2567, 2614,
2627, 2614, 2674, 2616, 2562, 2615, 2640, 2691, 2630, 2635, 2638, 2614,
2620, 2625, 2621, 2681, 2622, 2607, 2588, 2649, 2553, 2606, 2592, 2568,
2565, 2591, 2665, 2600, 2595, 2623, 2640, 2596, 2578, 2617, 2571, 2625,
2611, 2602, 2605, 2640, 2629, 2633, 2666, 2626, 2668, 2613, 2665, 2619,
2558, 2603, 2629, 2635, 2676, 2599, 2623, 2619, 2632, 2611, 2613, 2627,
2634, 2583, 2631, 2627, 2640, 2649, 2618, 2640, 2565, 2616, 2620, 2627,
2623, 2648, 2597, 2629, 2630, 2587, 2588, 2621, 2645, 2620, 2580, 2596,
2648, 2584, 2606, 2572, 2656, 2548, 2598, 2602, 2584, 2610, 2628, 2630,
2570, 2623, 2592, 2653, 2630, 2635, 2654, 2635, 2555, 2592, 2598, 2584,
2638, 2697, 2592, 2614, 2606, 2566, 2610, 2685, 2664, 2686, 2616, 2547,
2628, 2632, 2562, 2638, 2607, 2588, 2679, 2650, 2604, 2637, 2614, 2562,
2613, 2620, 2632, 2657, 2626, 2654, 2589, 2640, 2577, 2635, 2566, 2606,
2645, 2569, 2610, 2630, 2616, 2670, 2630, 2565, 2646, 2601, 2626, 2629,
2592, 2598, 2551, 2627, 2661, 2621, 2654, 2576, 2643, 2614, 2591, 2583,
2618, 2596, 2586, 2585, 2590, 2664, 2601, 2587, 2629, 2608, 2635, 2576,
2620, 2625, 2530, 2660, 2628, 2634, 2562, 2598, 2640, 2621, 2636, 2628,
2596, 2609, 2543, 2619, 2562, 2625, 2591, 2584, 2619, 2585, 2615, 2639,
2587, 2592, 2605, 2573, 2563, 2662, 2659, 2607, 2673, 2641, 2578, 2607,
2596, 2664, 2614, 2625, 2557, 2613, 2617, 2555, 2603, 2594, 2615, 2681,
2632, 2633, 2644, 2561, 2636, 2581, 2631, 2611, 2595, 2572, 2635, 2632,
2620, 2615, 2641, 2593, 2590, 2675, 2620, 2589, 2600, 2623, 2609, 2606,
2624, 2561, 2594, 2631, 2622, 2623, 2577, 2581, 2603, 2574, 2639, 2616,
2620, 2640, 2642, 2627, 2587, 2637, 2612, 2603, 2621, 2599, 2606, 2639,
2645, 2617, 2633, 2618, 2596, 2596, 2592, 2600, 2616, 2581, 2590, 2606,
2598, 2646, 2576, 2545, 2591, 2636, 2556, 2604, 2636, 2635, 2599, 2575,
2527, 2616, 2607, 2610, 2572, 2589, 2643, 2545, 2650, 2608, 2615, 2585,
2627, 2536, 2603, 2587, 2612, 2643, 2597, 2654, 2544, 2610, 2605, 2558,
2618, 2553, 2616, 2604, 2688, 2559, 2577, 2581, 2642, 2619, 2550, 2609,
2642, 2613, 2616, 2544, 2599, 2675, 2639, 2594, 2547, 2645, 2595, 2618,
2602, 2551, 2637, 2667, 2596, 2600, 2590, 2515, 2615, 2577, 2635, 2647,
2605, 2590, 2568, 2592, 2657, 2672, 2627, 2578, 2544, 2563, 2560, 2609,
2593, 2617, 2660, 2562, 2638, 2567, 2575, 2599, 2599, 2593, 2636, 2649,
2665, 2569, 2608, 2638, 2585, 2626, 2563, 2547, 2525, 2543, 2581, 2597,
2595, 2608, 2572, 2570, 2555, 2581, 2648, 2624, 2545, 2632, 2578, 2625,
2564, 2578, 2629, 2569, 2579, 2576, 2568, 2637, 2630, 2598, 2566, 2595,
2598, 2625, 2614, 2621, 2578, 2531, 2608, 2580, 2594, 2595, 2611, 2568,
2640, 2577, 2612, 2635, 2571, 2602, 2606, 2588, 2624, 2567, 2611, 2638,
2590, 2604, 2549, 2585, 2550, 2576, 2601, 2619, 2600, 2604, 2541, 2600,
2590, 2599, 2578, 2553, 2573, 2606, 2610, 2599, 2637, 2594, 2587, 2571,
2644, 2591, 2621, 2633, 2570, 2563, 2578, 2592, 2601, 2644, 2581, 2595,
2577, 2598, 2586, 2658, 2609, 2596, 2578, 2595, 2587, 2594, 2578, 2663,
2561, 2584, 2609, 2576, 2622, 2624, 2583, 2614, 2583, 2551, 2651, 2613,
2579, 2588, 2544, 2591, 2601, 2582, 2641, 2540, 2623, 2542, 2584, 2560,
2632, 2564, 2631, 2621, 2618, 2631, 2558, 2556, 2615, 2587, 2561, 2664,
2597, 2603, 2597, 2599, 2524, 2594, 2593, 2606, 2552, 2564, 2520, 2597,
2599, 2555, 2526, 2599, 2628, 2572, 2602, 2503, 2642, 2538, 2596, 2598,
2623, 2578, 2635, 2568, 2525, 2635, 2589, 2562, 2594, 2618, 2617, 2581,
2673, 2595, 2572, 2616, 2616, 2590, 2605, 2597, 2577, 2579, 2587, 2561,
2512, 2621, 2566, 2574, 2584, 2601, 2571, 2575, 2611, 2579, 2573, 2604,
2519, 2590, 2620, 2570, 2532, 2579, 2558, 2615, 2538, 2613, 2631, 2623,
2585, 2571, 2596, 2593, 2602, 2591, 2578, 2604, 2565, 2600, 2518, 2591,
2576, 2585, 2570, 2596, 2570, 2601, 2597, 2567, 2556, 2561, 2626, 2613,
2635, 2627, 2563, 2540, 2566, 2585, 2555, 2590, 2597, 2547, 2579, 2545,
2645, 2584, 2537, 2548, 2599, 2578, 2506, 2602, 2605, 2552, 2587, 2594,
2621, 2607, 2585, 2665, 2548, 2564, 2577, 2567, 2567, 2600, 2615, 2574,
2607, 2582, 2636, 2556, 2621, 2605, 2585, 2560, 2534, 2645, 2589, 2559,
2602, 2592, 2557, 2601, 2583, 2603, 2588, 2559, 2557, 2566, 2583, 2545,
2610, 2664, 2557, 2633, 2632, 2579, 2561, 2573, 2560, 2531, 2582, 2625,
2598, 2546, 2595, 2580, 2608, 2603, 2611, 2602, 2612, 2550, 2559, 2586,
2620, 2578, 2593, 2597, 2548, 2523, 2576, 2549, 2597, 2585, 2576, 2598,
2607, 2582, 2582, 2600, 2582, 2642, 2580, 2620, 2575, 2572, 2585, 2590,
2561, 2551, 2569, 2567, 2579, 2628, 2589, 2607, 2670, 2572, 2547, 2571,
2615, 2593, 2617, 2612, 2560, 2588, 2563, 2533, 2568, 2614, 2581, 2531,
2573, 2616, 2597, 2598, 2556, 2562, 2583, 2545, 2651, 2578, 2528, 2611,
2613, 2626, 2587, 2587, 2583, 2607, 2572, 2614, 2555, 2598, 2565, 2530,
2584, 2514, 2575, 2550, 2613, 2543, 2600, 2559, 2584, 2566, 2555, 2630,
2571, 2532, 2594, 2576, 2637, 2525, 2525, 2588, 2594, 2644, 2581, 2547,
2601, 2621, 2561, 2580, 2582, 2606, 2529, 2541, 2537, 2561, 2567, 2559,
2521, 2590, 2595, 2622, 2597, 2584, 2592, 2540, 2587, 2544, 2535, 2554,
2568, 2569, 2530, 2610, 2603, 2621, 2591, 2525, 2556, 2564, 2589, 2597,
2596, 2557, 2548, 2533, 2579, 2538, 2577, 2524, 2554, 2618, 2604, 2598,
2570, 2577, 2580, 2604, 2582, 2608, 2563, 2589, 2533, 2610, 2622, 2566,
2523, 2623, 2517, 2561, 2610, 2569, 2542, 2625, 2566, 2561, 2577, 2596,
2565, 2534, 2620, 2601, 2516, 2568, 2553, 2598, 2562, 2595, 2560, 2544,
2614, 2525, 2592, 2595, 2599, 2584, 2531, 2591, 2545, 2525, 2575, 2561,
2529, 2613, 2555, 2559, 2525, 2600, 2555, 2574, 2554, 2571, 2518, 2596,
2583, 2646, 2518, 2611, 2521, 2589, 2558, 2544, 2589, 2647, 2557, 2524,
2557, 2520, 2556, 2586, 2625, 2539, 2619, 2554, 2598, 2580, 2569, 2554,
2478, 2581, 2583, 2580, 2559, 2573, 2543, 2564, 2551, 2585, 2562, 2568,
2558, 2612, 2543, 2631, 2578, 2565, 2570, 2556, 2554, 2569, 2610, 2571,
2527, 2584, 2553, 2596, 2603, 2537, 2492, 2529, 2567, 2641, 2560, 2573,
2555, 2591, 2527, 2580, 2586, 2526, 2556, 2574, 2510, 2574, 2552, 2555,
2608, 2551, 2643, 2599, 2567, 2564, 2588, 2557, 2556, 2541, 2577, 2578,
2606, 2524, 2557, 2603, 2543, 2562, 2617, 2547, 2598, 2578, 2532, 2463,
2549, 2566, 2583, 2589, 2604, 2588, 2545, 2569, 2540, 2573, 2540, 2637,
2546, 2537, 2577, 2596, 2608, 2601, 2611, 2585, 2546, 2571, 2520, 2516,
2543, 2603, 2584, 2601, 2557, 2567, 2597, 2577, 2555, 2515, 2547, 2550,
2524, 2530, 2600, 2570, 2615, 2543, 2556, 2552, 2583, 2552, 2564, 2557,
2570, 2599, 2573, 2547, 2605, 2551, 2559, 2594, 2544, 2595, 2533, 2541,
2538, 2574, 2568, 2585, 2553, 2570, 2539, 2551, 2570, 2516, 2531, 2553,
2575, 2600, 2642, 2566, 2516, 2547, 2562, 2541, 2616, 2557, 2544, 2528,
2567, 2564, 2525, 2635, 2538, 2576, 2541, 2591, 2596, 2582, 2476, 2567,
2543, 2511, 2537, 2530, 2511, 2570, 2599, 2531, 2544, 2620, 2530, 2558};
bool is_prime(int x) {
if (x < 2) return 0;
if (x == 2) return 1;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) return 0;
}
return 1;
}
int main() {
int l, r, ans = 0;
while (cin >> l >> r) {
ans = 0;
if (l <= 2 && r >= 2) ans++;
if (l <= 2) {
l = 3;
}
int L = l / BLOCK, R = r / BLOCK;
if (L == R) {
for (int i = l; i <= r; i++) {
if ((i & 1) && i % 4 == 1 && is_prime(i)) {
ans++;
}
}
} else {
for (int i = L + 1; i < R; i++) {
ans += num[i];
}
for (int i = l; i < (L + 1) * BLOCK; i++) {
if ((i & 1) && i % 4 == 1 && is_prime(i)) {
ans++;
}
}
for (int i = R * BLOCK; i <= r; i++) {
if ((i & 1) && i % 4 == 1 && is_prime(i)) {
ans++;
}
}
}
cout << ans << endl;
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c <= '9' && c >= '0') x = x * 10 + c - '0', c = getchar();
return x * f;
}
const long long MAXN = 3e5 + 10, inf = 1e9 + 10;
long long n, m, ans;
struct node {
long long a, t;
friend bool operator<(node x, node y) { return x.a < y.a; }
} q[MAXN];
priority_queue<long long> f;
signed main() {
n = read();
for (long long i = 1; i <= n; i++) q[i].a = read();
for (long long i = 1; i <= n; i++) q[i].t = read();
for (long long i = 1; i <= n; i++) ans -= q[i].a * q[i].t;
sort(q + 1, q + n + 1);
long long p = 0, tot = 1;
while (tot <= n || !f.empty()) {
if (f.empty()) p = q[tot].a;
while (tot <= n && q[tot].a <= p) {
f.push(q[tot].t);
tot++;
}
ans += p * f.top();
p++;
f.pop();
}
printf("%lld\n", ans);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int x1, Y1, x2, y2;
int ok() {
printf("? %d %d %d %d\n", x1, Y1, x2, y2);
fflush(stdout);
int t;
cin >> t;
return t;
}
int getl(int l, int r, int &v, int d) {
int ans = r;
while (l <= r) {
int mid = (l + r) / 2;
v = mid;
if (ok() >= 1) {
r = mid - 1;
ans = mid;
} else {
l = mid + 1;
}
}
return ans;
}
int getu(int l, int r, int &v, int d) {
int ans = r;
while (l <= r) {
int mid = (l + r) / 2;
v = mid;
if (ok() >= d) {
l = mid + 1;
ans = mid;
} else {
r = mid - 1;
}
}
return ans;
}
vector<int> ans;
int n;
void solve(int l, int r, int d, int u) {
x1 = l, x2 = r, Y1 = d, y2 = u;
l = getu(x1, x2, x1, 1);
x1 = l, x2 = r, Y1 = d, y2 = u;
r = getl(x1, x2, x2, 0);
x1 = l, x2 = r, Y1 = d, y2 = u;
d = getu(Y1, y2, Y1, 1);
x1 = l, x2 = r, Y1 = d, y2 = u;
u = getl(Y1, y2, y2, 0);
x1 = l, x2 = r, Y1 = d, y2 = u;
ans.push_back(l);
ans.push_back(d);
ans.push_back(r);
ans.push_back(u);
}
int main() {
cin >> n;
x1 = Y1 = 1;
x2 = y2 = n;
int line1 = getl(x1, x2, x2, 0);
x2 = n;
int line2 = getu(x1, x2, x1, 1);
x1 = 1;
if (line2 <= line1) {
int line3 = getl(Y1, y2, y2, 0);
y2 = n;
solve(1, n, 1, line3);
solve(1, n, line3 + 1, n);
} else {
solve(1, line1, 1, n);
solve(line1 + 1, n, 1, n);
}
printf("!");
for (int i = 0; i < 8; i++) printf(" %d", ans[i]);
}
| 8 | CPP |
n=int(input())
A = sorted(map(abs, map(int, input().split())))
j=0
count=0
for i in range(n-1):
while j<n-1 and A[j+1]<=2*A[i]:
j+=1
count+=(j-i)
print(count) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long ans[100009] = {0};
bool set_col[100009];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long arr[3];
long long setp = -1;
for (long long j = 0; j < 3; j++) {
cin >> arr[j];
if (set_col[arr[j]] == true) setp = j;
}
if (setp == -1) ans[arr[0]] = 0, setp = 0, set_col[arr[0]] = true;
for (long long i1 = 0; i1 < 2; i1++) {
ans[arr[(setp + i1 + 1) % 3]] = (ans[arr[(setp + i1) % 3]] + 1) % 3;
set_col[arr[(setp + i1 + 1) % 3]] = true;
}
}
for (long long i = 0; i < n; i++) {
cout << ans[i + 1] + 1 << " ";
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101;
vector<int> v[maxn];
int n, m, x, y, a[maxn];
pair<int, int> p[maxn];
bool mark[maxn];
void dfs(int x) {
mark[x] = true;
for (int i = 0; i < v[x].size(); i++) {
int next = v[x][i];
if (a[next] == a[x]) {
cout << "Impossible" << endl;
exit(0);
}
if (!mark[next]) {
a[next] = (a[x] + 1) % 2;
dfs(next);
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
p[i].first = x;
p[i].second = y;
for (int j = 0; j < i; j++) {
if (p[j].first == p[i].first || p[j].first == p[i].second ||
p[j].second == p[i].first || p[j].second == p[i].second)
continue;
int h = 0;
for (int k = min(p[i].first, p[i].second) + 1;
k < max(p[i].first, p[i].second); k++) {
if (p[j].first == k || p[j].second == k) h++;
}
if (h == 1) {
v[i].push_back(j);
v[j].push_back(i);
}
}
}
fill(a, a + m, -1);
for (int i = 0; i < m; i++) {
if (a[i] == -1) {
a[i] = 0;
dfs(i);
}
}
for (int i = 0; i < m; i++) {
if (a[i] == 0)
cout << 'i';
else
cout << 'o';
}
cout << endl;
return 0;
}
| 10 | CPP |
from collections import Counter
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
counta = Counter(a)
countb = Counter(b)
ab = [0]*n
for i in range(n):
if a[i] == b[i]: ab[i] =a[i]
#print(ab)
test = set(list(range(1,n+1)))
#abtup = set([])
for i in range(n):
setab = set(ab)
realtest = test - setab
if ab[i] == 0:
if a[i] in setab and b[i] in setab:
if len(realtest) != 0:
ab[i] = realtest.pop()
elif a[i] in setab:
ab[i] = b[i]
elif b[i] in setab:
ab[i] = a[i]
else:
if counta[a[i]] > 1 and countb[b[i]] > 1:
if len(realtest) != 0:
ab[i] = realtest.pop()
else:
ab[i] = a[i]
elif counta[a[i]] > 1 and not countb[b[i]] > 1:
ab[i] = b[i]
elif not counta[a[i]] > 1 and countb[b[i]] > 1:
ab[i] = a[i]
print(" ".join(list(map(str,ab))))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int MOD = 998244353;
struct Mint {
int val;
Mint() { val = 0; }
Mint(ll x) {
val = (-MOD <= x && x < MOD) ? x : x % MOD;
if (val < 0) val += MOD;
}
template <typename U>
explicit operator U() const {
return (U)val;
}
friend bool operator==(const Mint& a, const Mint& b) {
return a.val == b.val;
}
friend bool operator!=(const Mint& a, const Mint& b) { return !(a == b); }
friend bool operator<(const Mint& a, const Mint& b) { return a.val < b.val; }
Mint& operator+=(const Mint& m) {
if ((val += m.val) >= MOD) val -= MOD;
return *this;
}
Mint& operator-=(const Mint& m) {
if ((val -= m.val) < 0) val += MOD;
return *this;
}
Mint& operator*=(const Mint& m) {
val = (ll)val * m.val % MOD;
return *this;
}
friend Mint modex(Mint a, ll p) {
assert(p >= 0);
Mint ans = 1;
for (; p; p >>= 1, a *= a)
if (p & 1) ans *= a;
return ans;
}
Mint& operator/=(const Mint& m) { return *this *= modex(m, MOD - 2); }
Mint& operator++() { return *this += 1; }
Mint& operator--() { return *this -= 1; }
Mint operator++(int) {
Mint result(*this);
*this += 1;
return result;
}
Mint operator--(int) {
Mint result(*this);
*this -= 1;
return result;
}
Mint operator-() const { return Mint(-val); }
friend Mint operator+(Mint a, const Mint& b) { return a += b; }
friend Mint operator-(Mint a, const Mint& b) { return a -= b; }
friend Mint operator*(Mint a, const Mint& b) { return a *= b; }
friend Mint operator/(Mint a, const Mint& b) { return a /= b; }
friend ostream& operator<<(ostream& os, const Mint& x) { return os << x.val; }
friend string to_string(const Mint& b) { return to_string(b.val); }
};
int main() {
int k, A, h;
scanf("%d%d%d", &k, &A, &h);
vector<Mint> powA(33);
powA[0] = 1;
for (int i = 1; i <= 32; ++i) powA[i] = powA[i - 1] * A;
array<array<vector<pair<Mint, ll>>, 2>, 2> val;
for (int rot = 0; rot < 2; ++rot) {
int init = 1 + (rot << (k - 1));
vector<int> p = {-1};
for (int i = 0; i < k - 1; ++i) {
for (int j = 0; j < (1 << i); ++j) p.push_back(i + 1);
}
42;
do {
bool bad = false;
for (int b = 1; !bad && b < k; ++b) {
for (int i = 0; !bad && i < p.size(); i += (1 << b)) {
int num = 0;
for (int j = i; j < i + (1 << b); ++j) num += p[j] == (k - b);
if (num != 1) bad = true;
}
}
if (bad) continue;
Mint cur = 0;
int z = -1;
ll q = 0;
for (int i = (int)p.size() - 1; i >= 0; --i) {
cur += (init + i) * powA[p[i] == -1 ? 1 : 1 + (1 << p[i])];
if (p[i] == -1) z = i;
q <<= 3;
q += p[i] + 1;
}
val[rot][0].push_back({cur, q});
q += (1LL << (3 * z));
cur += (init + z) * (powA[2] - powA[1]);
val[rot][1].push_back({cur, q});
} while (next_permutation(p.begin(), p.end()));
}
for (int t = 0; t < 2; ++t) {
auto& hay = val[1][1 - t];
sort(hay.begin(), hay.end());
for (auto& v : val[0][t]) {
Mint need = h - v.first;
auto it = lower_bound(hay.begin(), hay.end(), make_pair(need, 0LL));
if (it == hay.end()) continue;
if (it->first != need) continue;
ll tmp = v.second;
for (int i = 0; i < (1 << (k - 1)); ++i) {
int x = tmp % 8;
printf("%d ", x == 0 ? 1 : 1 + (1 << (x - 1)));
tmp >>= 3;
}
tmp = it->second;
for (int i = 0; i < (1 << (k - 1)); ++i) {
int x = tmp % 8;
printf("%d ", x == 0 ? 1 : 1 + (1 << (x - 1)));
tmp >>= 3;
}
printf("\n");
return 0;
}
}
printf("-1\n");
}
| 11 | CPP |
#include <cstdio>
#include <cstring>
#include <algorithm>
#define MAXN 800010
#define LL long long
#define P 924844033
using namespace std;
LL getPow(LL x,LL y){
LL res=1;
while(y){
if(y&1) res=res*x%P;
x=x*x%P;
y>>=1;
}
return res;
}
struct edge{
int to,next;
edge(int _to=0,int _next=0):to(_to),next(_next){}
}e[MAXN<<1];
int n,sizew;
int g[MAXN],nume;
int size[MAXN];
LL fac[MAXN],invfac[MAXN];
LL c[MAXN],d[MAXN],f[MAXN];
void addEdge(int u,int v){
e[nume]=edge(v,g[u]);
g[u]=nume++;
}
void dfs(int x,int p){
size[x]=1;
for(int i=g[x];~i;i=e[i].next)
if(e[i].to^p){
dfs(e[i].to,x);
size[x]+=size[e[i].to];
}
}
void init(){
fac[0]=1;
for(int i=1;i<MAXN;i++) fac[i]=fac[i-1]*i%P;
invfac[MAXN-1]=getPow(fac[MAXN-1],P-2);
for(int i=MAXN-2;i>=0;i--) invfac[i]=invfac[i+1]*(i+1)%P;
}
LL getC(int x,int y){
if(x<y) return 0;
return fac[x]*invfac[y]%P*invfac[x-y]%P;
}
void FFT(LL *a,int len,int flag){
static int rev[MAXN];
rev[0]=0;
for(int i=1;i<len;i++) rev[i]=rev[i>>1]>>1|((i&1)?(len>>1):0);
for(int i=0;i<len;i++)
if(i<rev[i])
swap(a[i],a[rev[i]]);
for(int l=2;l<=len;l<<=1){
LL w=getPow(5,(P-1)/l);
int l2=l/2;
for(int i=0;i<len;i+=l){
LL temp=1;
for(int j=0;j<l2;j++){
LL t1=a[i+j],t2=a[i+j+l2]*temp%P;
a[i+j]=(t1+t2)%P;
a[i+j+l2]=(t1-t2)%P;
temp=temp*w%P;
}
}
}
if(flag==-1){
LL invn=getPow(len,P-2);
for(int i=0;i<len;i++)
a[i]=a[i]*invn%P;
for(int i=1;i<len;i++)
if(i<len-i)
swap(a[i],a[len-i]);
}
}
int main(){
#ifdef DEBUG
freopen("F.in","r",stdin);
#endif
init();
memset(g,-1,sizeof g);
scanf("%d",&n);
for(sizew=1;sizew<=n;sizew<<=1);
sizew<<=1;
for(int i=1;i<n;i++){
int u,v;
scanf("%d%d",&u,&v);
addEdge(u,v);
addEdge(v,u);
}
dfs(1,0);
for(int i=2;i<=n;i++){
c[size[i]]++;
c[n-size[i]]++;
}
for(int i=1;i<=n;i++) c[i]=c[i]*fac[i]%P;
for(int i=0;i<=n;i++) d[i]=invfac[n-i];
FFT(c,sizew,1); FFT(d,sizew,1);
for(int i=0;i<sizew;i++) f[i]=c[i]*d[i]%P;
FFT(f,sizew,-1);
for(int i=1;i<=n;i++){
f[i]=f[i+n]*invfac[i]%P;
f[i]=((getC(n,i)*n-f[i])%P+P)%P;
printf("%lld\n",f[i]);
}
return 0;
}
| 0 | CPP |
from sys import stdin, stdout
t=int(stdin.readline())
while t:
t-=1
n,m = map(int , stdin.readline().split())
mul,rem = divmod(n-m, m+1)
ans = n*(n+1)//2 - (m+1-rem)*mul*(mul+1)//2 - rem*(mul+1)*(mul+2)//2
stdout.write(str(ans)+'\n') | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const double eps = 1e-10;
const double pi = acos(-1.0);
const int maxn = 1e6 + 10;
const long long inf = 0x3f3f3f3f;
const int dir[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int n, m;
long long a[110][110], dp[110][110];
long long solve(long long v) {
if (v > a[1][1]) return 9e18;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= m; j++) dp[i][j] = 9e18;
dp[1][1] = a[1][1] - v;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (i == 1 && j == 1) continue;
if (a[i][j] >= v)
dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + a[i][j] - v;
}
return dp[n][m];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int _;
cin >> _;
while (_--) {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
a[i][j] -= i - 1;
a[i][j] -= j - 1;
}
long long ans = 9e18;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) ans = min(ans, solve(a[i][j]));
cout << ans << '\n';
}
return 0;
}
| 12 | CPP |
print('Heisei' if '2019/04/30' >= input() else 'TBD')
| 0 | PYTHON3 |
b = [4, 7, 44, 47, 74, 77, 444, 447, 474, 477, 744, 747, 774, 777]
a = int(input())
t = 0
for i in range(len(b)):
if a % b[i] == 0:
t = 1
if t == 1:
print('YES')
else:
print('NO')
| 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
char a[105],b[105];
int ans;
int main()
{
int l;
scanf("%d",&l);
scanf("%s",a);
scanf("%s",b);
for(int k=1;k<=l;k++)
{
bool p=true;
for(int i=0;i<k;i++)
{
if(a[l-k+i]!=b[i])p=false;
}
if(p)ans=k;
}
printf("%d",l+l-ans);
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, q, timer, vis[N], parent[N], level[N], in[N], out[N];
vector<int> adj[N];
void dfs(int u) {
vis[u] = 1;
in[u] = timer++;
for (auto v : adj[u]) {
if (!vis[v]) {
level[v] = 1 + level[u];
parent[v] = u;
dfs(v);
}
}
out[u] = timer++;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> q;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
parent[1] = -1;
dfs(1);
for (int i = 0; i < q; i++) {
int k;
cin >> k;
vector<int> nodes(k);
int start = 1, mx = 0;
for (int j = 0; j < k; j++) {
int x;
cin >> x;
nodes[j] = x;
if (mx < level[x]) {
mx = level[x];
start = x;
}
}
for (auto &it : nodes) {
if (it == start || parent[it] == -1) {
continue;
}
it = parent[it];
}
bool flag = 1;
for (auto it : nodes) {
if (in[it] <= in[start] && out[it] >= out[start]) {
continue;
}
flag = 0;
}
if (!flag) {
cout << "NO\n";
} else {
cout << "YES\n";
}
}
return 0;
}
| 11 | CPP |
import math
n = int(input())
result = ((n*n) * ((n-1)*(n-1)) * ((n-2)*(n-2)) * ((n-3)*(n-3)) * ((n-4)*(n-4)))//math.factorial(5)
print(int(result)) | 14 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > slo[100005];
set<pair<long long int, long long int> > secik;
set<pair<long long int, pair<int, int> > > krusk;
long long int dis[100005];
int spar[100005];
long long int n, m;
void dijkstra(long long int v) {
secik.clear();
for (int i = 0; i <= n + 1; i++) {
dis[i] = 1000000000000000000ll;
secik.insert(make_pair(1000000000000000000ll, i));
}
dis[v] = 0;
secik.erase(make_pair(1000000000000000000ll, v));
secik.insert(make_pair(0, v));
long long int newv;
long long int aktv, aktdis;
long long int bla;
while (!secik.empty()) {
aktv = (*secik.begin()).second;
aktdis = (*secik.begin()).first;
secik.erase(*secik.begin());
for (int i = 0; i < slo[aktv].size(); i++) {
newv = slo[aktv][i].first;
bla = aktdis + slo[aktv][i].second;
if (dis[newv] > bla) {
secik.erase(make_pair(dis[newv], newv));
dis[newv] = bla;
secik.insert(make_pair(dis[newv], newv));
}
}
}
}
int rep[100005];
int find(int v) {
if (spar[v] == v) {
return v;
} else {
spar[v] = find(spar[v]);
return spar[v];
}
}
void unionn(int v1, int v2) {
int r1 = find(v1);
int r2 = find(v2);
if (r1 != r2) {
spar[r1] = r2;
}
}
int port[100005];
void dijkstra2() {
secik.clear();
for (int i = 0; i <= n + 1; i++) {
if (port[i] == 1) {
dis[i] = 0;
spar[i] = i;
secik.insert(make_pair(0, i));
} else {
dis[i] = 1000000000000000000ll;
secik.insert(make_pair(1000000000000000000ll, i));
}
}
long long int newv;
long long int aktv, aktdis;
long long int bla;
while (!secik.empty()) {
aktv = (*secik.begin()).second;
aktdis = (*secik.begin()).first;
secik.erase(*secik.begin());
for (int i = 0; i < slo[aktv].size(); i++) {
newv = slo[aktv][i].first;
bla = aktdis + slo[aktv][i].second;
if (dis[newv] > bla) {
secik.erase(make_pair(dis[newv], newv));
dis[newv] = bla;
spar[newv] = spar[aktv];
secik.insert(make_pair(dis[newv], newv));
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int v1, v2, k;
cin >> v1 >> v2 >> k;
slo[v1].push_back(make_pair(v2, k));
slo[v2].push_back(make_pair(v1, k));
}
int por;
cin >> por;
for (int i = 1; i <= por; i++) {
int z;
cin >> z;
port[z] = 1;
}
dijkstra(1);
long long int wynik = 1000000000000000000ll;
for (int i = 1; i <= n; i++) {
if (port[i] == 1) {
wynik = min(wynik, dis[i]);
slo[0].push_back(make_pair(i, 0));
rep[i] = i;
}
}
secik.clear();
dijkstra2();
for (int i = 1; i <= n; i++) {
for (int j = 0; j < slo[i].size(); j++) {
int aktv = slo[i][j].first;
if (i > aktv || spar[i] == spar[aktv]) {
continue;
} else {
krusk.insert(make_pair(slo[i][j].second + dis[i] + dis[aktv],
make_pair(spar[i], spar[aktv])));
}
}
}
int licz = 0;
while (licz < por - 1) {
pair<long long int, pair<int, int> > cos = *krusk.begin();
krusk.erase(krusk.begin());
int f1 = find(cos.second.first);
int f2 = find(cos.second.second);
if (f1 != f2) {
wynik += cos.first;
unionn(f1, f2);
licz++;
}
}
cout << wynik << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 5, mod = 998244353;
int n, lim[N];
long long f[N], fac[N], inv[N], a[N];
void init() {
fac[0] = 1;
for (int i = 1; i < N; ++i) fac[i] = fac[i - 1] * i % mod;
inv[0] = inv[1] = 1;
for (int i = 2; i < N; ++i) inv[i] = (mod - mod / i) * inv[mod % i] % mod;
for (int i = 1; i < N; ++i) inv[i] = inv[i - 1] * inv[i] % mod;
}
long long A(int d, int u) {
if (u < 0 || u > d) return 0;
return fac[d] * inv[d - u] % mod;
}
int main() {
init();
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; ++i)
for (int j = 1; j < i; ++j) {
if (a[j] * 2 <= a[i])
lim[i] = j;
else
break;
}
f[0] = 1;
lim[0] = -1;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= lim[i]; ++j)
f[i] = (f[i] + f[j] * A(n - lim[j] - 2, lim[i] - lim[j] - 1) % mod) % mod;
printf("%lld\n", lim[n] == n - 1 ? f[n] : 0);
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3000;
std::vector<pair<long long, long long> > v[N];
bool visited[N];
long long color[N];
bool flag;
void dfs(long long n) {
visited[n] = 1;
for (auto i : v[n]) {
if (visited[i.first] == 0)
color[i.first] = color[n] ^ i.second, dfs(i.first);
else {
if (color[i.first] != (color[n] ^ i.second)) {
flag = 0;
}
}
}
}
long long mod_expo(long long a, long long b, long long c) {
long long ans = 1;
while (b) {
if (b & (long long)1) ans = (ans * a) % c;
a = (a * a) % c;
b = b >> 1;
}
return ans;
}
void check(long long n, bool now, long long k) {
if (n == k) {
if (now == true) {
flag = 0;
return;
}
}
visited[n] = 1;
for (auto i : v[n]) {
if (visited[i.first] == 0) {
if (i.second) {
check(i.first, !now, k);
} else {
check(i.first, now, k);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
string a;
a = s;
long long n = s.size();
reverse(s.begin(), s.end());
long long ans = 0;
for (long long k = 1; k < n; k++) {
long long index = n + 2;
for (long long i = 0; i < (index + k); i++)
v[i].clear(), visited[i] = 0, color[i] = 0;
for (long long i = 0; i < n / 2; i++) {
v[i].push_back(make_pair(n - 1 - i, 0));
v[n - 1 - i].push_back(make_pair(i, 0));
}
for (long long i = 0; i < k / 2; i++) {
v[index + i].push_back(make_pair(index + k - 1 - i, 0));
v[index + k - 1 - i].push_back(make_pair(index + i, 0));
}
for (long long i = 0; i < k; i++) {
if (s[i] == '0') {
v[i].push_back(make_pair(index + i, 0));
v[index + i].push_back(make_pair(i, 0));
} else if (s[i] == '1') {
v[i].push_back(make_pair(index + i, 1));
v[index + i].push_back(make_pair(i, 1));
}
}
for (long long i = k; i < n; i++) {
if (s[i] == '0') {
v[i].push_back(make_pair(n + 1, 0));
v[n + 1].push_back(make_pair(i, 0));
} else if (s[i] == '1') {
v[i].push_back(make_pair(n, 0));
v[n].push_back(make_pair(i, 0));
}
}
v[index + k - 1].push_back(make_pair(n, 0));
v[n].push_back(make_pair(index + k - 1, 0));
flag = 1;
memset(visited, 0, sizeof(visited));
visited[n] = visited[n + 1] = 1;
color[n] = 1;
color[n + 1] = 0;
dfs(n);
{
dfs(n + 1);
long long count = 0;
for (long long i = 0; i < (index + k); i++) {
if (visited[i] == 0) {
dfs(i);
count++;
}
}
if (flag) ans = (ans + mod_expo(2, count, 998244353)) % 998244353;
}
}
cout << ans << endl;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[5], A[20], B[20], Ans[20], was[20];
int v[20][5], ai, bi, stand[10], ans, u[20];
string s;
bool check() {
bool f = 1;
memset(stand, 0, sizeof stand);
memset(was, 0, sizeof was);
for (int j = 0; j < 4; j++) stand[a[j]] = j, was[a[j]] = 1;
for (int j = 0; j < n; j++) {
ai = bi = 0;
for (int i = 0; i < 4; i++)
if (was[v[j][i]])
if (stand[v[j][i]] == i)
ai++;
else
bi++;
if (ai == A[j] && bi == B[j])
f &= 1;
else
f &= 0;
}
return f;
}
void F(int i, int k) {
a[i] = k;
u[k] = 1;
if (i == 3) {
if (check()) {
ans++;
if (ans > 1) {
cout << "Need more data\n";
exit(0);
}
for (int j = 0; j < 4; j++) Ans[j] = a[j];
}
u[k] = 0;
return;
}
for (int j = 0; j < 10; j++)
if (!u[j]) F(i + 1, j);
u[k] = 0;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s >> A[i] >> B[i];
for (int j = 0; j < s.size(); j++) v[i][j] = s[j] - '0';
}
for (int i = 0; i < 10; i++) F(0, i);
if (!ans)
cout << "Incorrect data\n";
else
for (int j = 0; j < 4; j++) cout << Ans[j];
return 0;
}
| 9 | CPP |
n, d=[int(i) for i in input().split()]
m=int(input())
a=[]
for i in range(m):
x, y = [int(i) for i in input().split()]
if x+y < d or x+y > 2*n-d or abs(x-y) > d:
a.append('NO')
else:
a.append('YES')
for i in a:
print(i) | 8 | PYTHON3 |
L,R=map(int,input().split())
if L==R:
print(L)
else:
print(2)
| 7 | PYTHON3 |
n = int(input())
numbers = list(map(int, input().split()))
flag = 0
for i in range(1,len(numbers) - 1):
if numbers[i] < numbers[i-1] and numbers[i] < numbers[i+1]:
flag = 1
print("NO")
break
if flag == 0:
print("YES")
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3 * 1e5 + 5;
int colors[N], re[N];
vector<int> inter[N];
vector<int> tree[N];
void dfs(int i, int p = -1) {
int s = inter[i].size();
for (int j = 0; j < s; ++j) {
if (re[inter[i][j]] != -1) colors[re[inter[i][j]]] = i;
}
int col = 0;
for (int j = 0; j < s; ++j) {
if (re[inter[i][j]] == -1) {
while (colors[col] == i) ++col;
re[inter[i][j]] = col;
++col;
}
}
for (int j : tree[i]) {
if (j != p) dfs(j, i);
}
}
int main() {
std::ios::sync_with_stdio(false);
memset(re, -1, sizeof(re));
memset(colors, -1, sizeof(colors));
int n, m;
cin >> n >> m;
int res = 1;
for (int i = 0; i < n; ++i) {
int s;
cin >> s;
res = max(res, s);
for (int j = 0; j < s; ++j) {
int a;
cin >> a;
inter[i].push_back(a);
}
}
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
tree[u].push_back(v);
tree[v].push_back(u);
}
dfs(0);
cout << res << endl;
for (int i = 1; i <= m; ++i) {
if (re[i] == -1)
cout << 1 << endl;
else
cout << re[i] + 1 << " ";
}
cout << endl;
return 0;
}
| 9 | CPP |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll a,v,b,w,t;
cin>>a>>v>>b>>w>>t;
if(llabs(a-b)<=t*(v-w))
cout<<"YES";
else cout<<"NO";
return 0;
} | 0 | CPP |
#!/usr/bin/env python3
# 664B_rebus.py - Codeforces.com/problemset/problem/664/B by Sergey 2016
import unittest
import sys
import re
###############################################################################
# Rebus Class (Main Program)
###############################################################################
class Rebus:
""" Rebus representation """
def __init__(self, test_inputs=None):
""" Default constructor """
it = iter(test_inputs.split("\n")) if test_inputs else None
def uinput():
return next(it) if it else sys.stdin.readline().rstrip()
# Reading single elements
self.str = uinput()
# End value
self.n = 0
m = re.search("(\d+)", self.str)
if m:
self.n = int(m.group(1))
# Signs
self.signs = ["+"] + re.findall("\? ([+-])", self.str)
def summ(self, nums, signs):
result = 0
for i in range(len(self.signs)):
if self.signs[i] == "+":
result += nums[i]
else:
result -= nums[i]
return result
def calculate(self):
""" Main calcualtion function of the class """
nums = [0] * len(self.signs)
for i in range(len(self.signs)):
nums[i] = 1
sum = self.summ(nums, self.signs)
for i in range(len(self.signs)):
if sum != self.n:
if self.signs[i] == "+" and sum < self.n:
nums[i] = min(self.n - sum + 1, self.n)
sum -= 1
sum += nums[i]
if self.signs[i] == "-" and sum > self.n:
nums[i] = min(sum + 1 - self.n, self.n)
sum += 1
sum -= nums[i]
if sum == self.n:
result = "Possible\n"
for i in range(len(self.signs)):
if i != 0:
result += self.signs[i] + " "
result += str(nums[i]) + " "
result += "= " + str(self.n)
else:
result = "Impossible"
return str(result)
###############################################################################
# Unit Tests
###############################################################################
class unitTests(unittest.TestCase):
def test_single_test(self):
""" Rebus class testing """
# Constructor test
test = "? + ? - ? + ? + ? = 42"
d = Rebus(test)
self.assertEqual(d.str, "? + ? - ? + ? + ? = 42")
self.assertEqual(d.n, 42)
self.assertEqual(d.signs, ["+", "+", "-", "+", "+"])
# Sample test
self.assertEqual(Rebus(test).calculate(), "Possible\n40 + 1 - 1 + 1 + 1 = 42")
# Sample test
test = "? - ? = 1"
self.assertEqual(Rebus(test).calculate(), "Impossible")
# Sample test
test = "? = 1000000"
self.assertEqual(Rebus(test).calculate(), "Possible\n1000000 = 1000000")
test = "? + ? + ? + ? - ? = 2"
self.assertEqual(Rebus(test).calculate(), "Possible\n1 + 1 + 1 + 1 - 2 = 2")
# My tests
test = ""
# self.assertEqual(Rebus(test).calculate(), "0")
# Time limit test
# self.time_limit_test(5000)
def time_limit_test(self, nmax):
""" Timelimit testing """
import random
import timeit
# Random inputs
test = str(nmax) + " " + str(nmax) + "\n"
numnums = [str(i) + " " + str(i+1) for i in range(nmax)]
test += "\n".join(numnums) + "\n"
nums = [random.randint(1, 10000) for i in range(nmax)]
test += " ".join(map(str, nums)) + "\n"
# Run the test
start = timeit.default_timer()
d = Rebus(test)
calc = timeit.default_timer()
d.calculate()
stop = timeit.default_timer()
print("\nTimelimit Test: " +
"{0:.3f}s (init {1:.3f}s calc {2:.3f}s)".
format(stop-start, calc-start, stop-calc))
if __name__ == "__main__":
# Avoiding recursion limitaions
sys.setrecursionlimit(100000)
if sys.argv[-1] == "-ut":
unittest.main(argv=[" "])
# Print the result string
sys.stdout.write(Rebus().calculate())
| 7 | PYTHON3 |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Codeforces
@author: neb0123
"""
def solution(A,n,m):
cnt = 0
for s in range((n+m-1)//2):
diag1 = []
diag2 = []
for i in range(s+1):
j = s - i
if i < n and j >= 0 and j < m and i >= 0:
diag1.append(A[i][j])
diag2.append(A[-i-1][-j-1])
k = len(diag1)
cnt += min(sum(diag1)+sum(diag2), k-sum(diag1)+k-sum(diag2))
return cnt
if __name__ == "__main__":
t = int(input())
for _ in range(t):
n, m = map(int, input().split(' '))
A = []
for _ in range(n):
A.append(list(map(int, input().split(' '))))
print(solution(A,n,m))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
int a[100001];
int t[100001];
inline int read() {
int X = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
X = (X << 1) + (X << 3) + ch - '0';
ch = getchar();
}
return X * f;
}
int main() {
int n = read();
cin >> a[0];
int mi = a[0];
for (int i = 1; i < n; i++) cin >> a[i], mi = min(a[i], mi);
sort(a, a + n);
int flag = 1;
for (int i = 0; i < n; i++) {
if (a[i] - mi >= 100001) {
flag = 0;
break;
}
t[a[i] - mi]++;
}
for (int i = 1; i < a[n - 1] - mi + 1; i++) {
if (t[i] == 0) {
flag = 0;
break;
}
if (i != a[n - 1] - mi && t[i] <= t[i - 1]) {
flag = 0;
break;
}
if (i == a[n - 1] - mi && t[i] != t[i - 1]) {
flag = 0;
break;
}
t[i] -= t[i - 1];
}
if (flag == 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 10 | CPP |
import operator as op
from functools import reduce
def ncr(n, r):
r = min(r, n-r)
numer = reduce(op.mul, range(n, n-r, -1), 1)
denom = reduce(op.mul, range(1, r+1), 1)
return numer // denom
n = int(input())
print(ncr(3+n-1,n-1)*ncr(5+n-1,n-1)) | 13 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
const int inf = (int)2e9;
const long long INF = (long long)2e18;
const int M = (int)1e6 + 10;
const int N = 500500;
int t;
long long n, k;
long long lvl, sum, lft, a;
vector<long long> v;
void solve() {
sum = lvl = lft = a = 0;
v.clear();
cin >> n >> k;
while (sum + (1ll << (lvl + 1)) - 1 <= k && (lvl + 1) <= n) {
lvl++;
sum += (1ll << lvl) - 1;
}
lft = k - sum;
a = n - lvl;
long long cur = 0;
long long d = 0;
while (d + 1 <= min(n, 59 * 1ll)) {
d++;
cur += (1ll << d) - 1;
v.push_back(cur);
}
bool can = false;
if ((int((v).size())) == 0) can = true;
cur = 1;
long long st = 1;
for (int i = 0; i < (int((v).size())); i++) {
if (cur - v[i] >= lft) {
can = true;
break;
}
st *= 4;
cur += st;
}
if (!can) {
cout << "NO\n";
return;
}
cout << "YES " << a << "\n";
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> t;
for (int i = 1; i <= t; i++) solve();
return 0;
}
| 10 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,i;
long long ans=0;
cin>>n;
long long a[n+1],h[n+1];
memset(h,0,sizeof(h));
for(i=1;i<=n;++i){
cin>>a[i];
++h[a[i]];
}
for(i=1;i<=n;++i){
ans+=h[i]*(h[i]-1)>>1;
}
for(i=1;i<=n;++i){
cout<<ans-h[a[i]]+1<<endl;
}
return 0;
} | 0 | CPP |
n = int(input())
a = (n + 1) // 2
b = n // 2
print(b * (b + 1) - a * a) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ara[32];
for (int i = 0; i <= 30; i++) {
ara[i] = pow(2, i) - 1;
}
int x = n;
vector<int> v;
int f = 0;
int cnt = 0;
for (int i = 0;; i++) {
for (int j = 0; j <= 30; j++) {
if (x == ara[j]) {
f = 1;
break;
}
}
if (f == 1) {
break;
}
if (i % 2 == 0) {
int g = log(x) / log(2);
for (int j = g; j >= 0; j--) {
int e = pow(2, j) - 1;
int m = x ^ e;
if (m > x) {
x = m;
v.push_back(j);
break;
}
}
} else {
x++;
}
cnt++;
}
cout << cnt << endl;
for (int i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
return 0;
}
| 8 | CPP |
"""
Codeforces Contest 281 Div 2 Problem C
Author : chaotic_iak
Language: Python 3.3.4
"""
def main():
n, = read()
a = read()
res = [(i,0) for i in a]
m, = read()
b = read()
res.extend((i,1) for i in b)
res.sort()
mxa = 3*n
mnb = 3*m
cra = 3*n
crb = 3*m
for _,i in res:
if i:
crb -= 1
if cra-crb > mxa-mnb:
mxa = cra
mnb = crb
else:
cra -= 1
print(str(mxa) + ":" + str(mnb))
################################### NON-SOLUTION STUFF BELOW
def read(mode=2):
# 0: String
# 1: List of strings
# 2: List of integers
inputs = input().strip()
if mode == 0: return inputs
if mode == 1: return inputs.split()
if mode == 2: return list(map(int, inputs.split()))
def write(s="\n"):
if s is None: s = ""
if isinstance(s, list): s = " ".join(map(str, s))
s = str(s)
print(s, end="")
write(main()) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long a[200010];
map<long long, long long> m, vis;
vector<long long> v;
int main() {
long long t, n, i, j, k, l, mn = 0, num = 0, mx = 0;
scanf("%lld", &n);
m.clear();
for (i = 0; i < n; i++) {
scanf("%lld", &a[i]);
m[a[i]]++;
if (m[a[i]] > mx) {
mx = m[a[i]];
num = a[i];
}
}
for (i = 0; i < n; i++) {
if (a[i] == num) {
v.push_back(i), vis[i] = 1;
}
}
if (v.size() == n)
cout << 0 << "\n";
else
cout << n - v.size() << "\n";
if (v[0] > 0) {
long long p = v[0] - 1;
for (j = p; j >= 0; j--) {
if (a[j] > num)
cout << 2 << " " << j + 1 << " " << j + 2 << "\n";
else
cout << 1 << " " << j + 1 << " " << j + 2 << "\n";
}
}
long long pp = 0;
for (i = v[0]; i < n; i++) {
if (vis[i] == 0) {
if (a[i] > num)
cout << 2 << " " << i + 1 << " " << i << "\n";
else
cout << 1 << " " << i + 1 << " " << i << "\n";
}
}
}
| 10 | CPP |
n, t = map(int, input().strip().split(" "))
arr = list(map(int, input().strip().split(" ")))
found = arr[0]
done = False
while(found < t):
if found == t-1:
print("YES")
done = True
break
found += arr[found]
if not done:
print("NO")
| 7 | PYTHON3 |
x, y, z, t1, t2, t3 = map(int, input().split())
if x == y:
print("NO")
else:
tS = abs(x - y) * t1
tE = ((abs(y - x) + abs(x - z)) * t2) + 3 * t3
if tS >= tE: print("YES")
else: print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char s1[2103], s2[2103];
char arr[4509];
int z[4509], sz;
void ZAlgo() {
int l = 0, r = 0;
for (int i = 1; i < sz; ++i) {
if (i > r) {
l = r = i;
while (r < sz && arr[r - l] == arr[r]) ++r;
z[i] = r - l;
--r;
} else {
int k = i - l;
if (z[k] < r - i + 1)
z[i] = z[k];
else {
l = i;
while (r < sz && arr[r - l] == arr[r]) ++r;
z[i] = r - l;
--r;
}
}
}
}
pair<int, int> ans[2103];
int main() {
int ansSz = 0;
scanf("%s", s1);
scanf("%s", s2);
int n = strlen(s1), m = strlen(s2);
int cur = 0;
while (cur < m) {
sz = 0;
for (int i = cur; i < m; ++i) arr[sz++] = s2[i];
arr[sz++] = '?';
for (int i = 0; i < n; ++i) arr[sz++] = s1[i];
ZAlgo();
int mx = 0, ind = -1;
for (int i = m - cur + 1; i < sz; ++i)
if (z[i] > mx) mx = z[i], ind = i - m + cur - 1;
if (ind == -1) {
puts("-1");
return 0;
}
reverse(arr + m - cur + 1, arr + sz);
ZAlgo();
bool rev = 0;
for (int i = m - cur + 1, j = n - 1; i < sz; ++i, --j)
if (z[i] > mx) mx = z[i], ind = j, rev = 1;
ans[ansSz++] =
rev ? make_pair(ind, ind - mx + 1) : make_pair(ind, ind + mx - 1);
cur += mx;
}
printf("%d\n", ansSz);
for (int i = 0; i < ansSz; ++i)
printf("%d %d\n", ans[i].first + 1, ans[i].second + 1);
return 0;
}
| 9 | CPP |
def sim(eat,n,post):
nn=n-eat
res=(nn*(nn+1))//2
return (res-(post+eat))
n,end=map(int,input().split())
l=0
r=n
i=0
while True:
i+=1
if i>100:
print("lol")
c=(r+l)//2
res=sim(c,n,end)
if res==0:
print(c)
break
else:
if res>0:
l=c
if res<0:
r=c | 8 | PYTHON3 |
t = int(input())
for _ in range(t):
n = int(input())
a = []
for i in range(n):
a += [input()]
s1, s2, f1, f2 = a[0][1], a[1][0], a[n-1][n-2], a[n-2][n-1]
if s1 == s2:
if f1 != f2:
if f1 == s1:
print(1)
print(n, n-1)
elif f2 == s1:
print(1)
print(n-1, n)
else:
if f1 != s1:
print(0)
else:
print(2)
print(n, n-1)
print(n-1, n)
else:
if f1 != f2:
print(2)
if f1 == s1:
print(n, n-1)
print(2, 1)
else:
print(n-1, n)
print(2, 1)
else:
print(1)
if f1 == s1:
print(1, 2)
else:
print(2, 1)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char s[105];
char t[105];
char p[105];
int vis[105];
int vis1[105];
int main() {
int T;
int n, k;
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &k);
if (k > n) {
if (n % 3 == 0)
printf("Bob\n");
else
printf("Alice\n");
} else if (k % 3 != 0) {
if (n % 3 == 0)
printf("Bob\n");
else
printf("Alice\n");
} else if (k % 3 == 0) {
if (k == 3) {
if (n % 4 == 0)
printf("Bob\n");
else
printf("Alice\n");
} else if (k != 3) {
if ((n - k) % (k + 1) % 3 == 1)
printf("Bob\n");
else
printf("Alice\n");
}
}
}
return 0;
}
| 10 | CPP |
t = int(input())
for _ in range(t):
n,d = map(int, input().split())
a = list(map(int, input().split()))
i = 1
while i < n:
while a[i] > 0 and i <= d:
a[0] += 1
a[i] -= 1
d -= i
i += 1
print(a[0])
| 7 | PYTHON3 |
n=int(input())
a = list(map(int, input().split()))
if 1 in a:
print(-1)
else:
i=1
while i in a:
i+=1
print(i) | 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long n,a,b,ans;
cin >> n >> a >> b;
ans=(b-a)*(n-2)+1;
cout << (ans<0?0:ans) << endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[200010];
bool OK(int val) {
int k2 = n;
bool u = 1;
for (int i = 1; i <= n; i++) {
if (u && a[i] > val) {
k2--;
continue;
} else
u = !u;
}
if (k2 >= k) return 1;
k2 = n, u = 1;
for (int i = 1; i <= n; i++) {
if (!u && a[i] > val) {
k2--;
continue;
} else
u = !u;
}
return k2 >= k;
return 0;
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
int st = 1, dr = 1e9;
while (st <= dr) {
int mid = (st + dr) / 2;
if (OK(mid))
dr = mid - 1;
else
st = mid + 1;
}
cout << dr + 1;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, x, i, s = 0;
scanf("%I64d%I64d", &n, &x);
int a[n];
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
for (i = 0; i < n; i++) {
s = s + a[i] * x;
if (x > 1) {
x--;
}
}
printf("%I64d", s);
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[30];
int main()
{
char c;
int n,i;
long long ans=1;
scanf("%d",&n);
getchar();
for(i=1;i<=n;i++)
{
scanf("%c",&c);
a[c-'a']++;
}
for(i=0;i<26;i++)
ans=ans*(a[i]+1)%1000000007;
printf("%lld",(ans+1000000006)%1000000007);
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1009;
const int maxv = 10;
const int maxf = 128;
const int maxb = 258;
int n;
int dp[maxn][maxf][maxb];
int v[maxn], sfreq[maxn][maxv];
int can(int val, int sl, int want) {
int l = sl, r = n;
int ans = 9999;
while (l <= r) {
int h = (l + r) / 2;
int here = sfreq[h][val] - sfreq[sl - 1][val];
if (here == want) ans = min(ans, h);
if (here < want)
l = h + 1;
else
r = h - 1;
}
return ans == 9999 ? -1 : ans;
}
int calc(int pos, int freq, int mask) {
if (mask == 255) return 0;
if (pos == n + 1) {
if (freq == 1) return 0;
return -9999;
}
int& ref = dp[pos][freq][mask];
if (ref != -1) return ref;
ref = calc(pos + 1, freq, mask);
if ((mask & (1 << v[pos])) == 0) {
int minpf1 = can(v[pos], pos, freq - 1);
if (minpf1 != -1)
ref = max(ref, (freq - 1) + calc(minpf1 + 1, freq, mask | (1 << v[pos])));
int minpf = can(v[pos], pos, freq);
if (minpf != -1)
ref = max(ref, freq + calc(minpf + 1, freq, mask | (1 << v[pos])));
}
return ref;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> v[i];
--v[i];
++sfreq[i][v[i]];
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < maxv; ++j) sfreq[i][j] += sfreq[i - 1][j];
}
memset(dp, 0xff, sizeof(dp));
int ans = 0;
for (int i = 0; i < maxf; ++i) ans = max(ans, calc(1, i, 0));
cout << ans << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int get() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const int N = 1005;
int n, a[N], f[N][N], pre[N][N];
void dfs(int x, int y) {
if (!x) return;
int lst = pre[x][y];
dfs(x - 1, lst);
int a = 0, b = 0;
if (x == 1) {
if (y == 1) a = 2, b = 3;
if (y == 2) a = 1, b = 3;
if (y == 3) a = 1, b = 2;
} else {
if (y == x * 2)
a = lst, b = x * 2 + 1;
else if (y == x * 2 + 1)
a = lst, b = x * 2;
else if (y == lst)
a = x * 2, b = x * 2 + 1;
}
if (a <= n) printf("%d ", a);
if (b <= n) printf("%d ", b);
printf("\n");
}
int main() {
n = get();
for (int i = 1; i <= n; i++) a[i] = get();
memset(f, 0x3f, sizeof(f));
f[1][1] = max(a[2], a[3]), f[1][2] = max(a[1], a[3]),
f[1][3] = max(a[1], a[2]);
pre[1][1] = 2, pre[1][2] = 1, pre[1][3] = 1;
for (int i = 2; i <= (n + 1) / 2; i++)
for (int j = 1; j < 2 * i; j++) {
int x = j, y = 2 * i, z = 2 * i + 1;
if (f[i - 1][j] + max(a[y], a[z]) < f[i][x])
f[i][x] = f[i - 1][j] + max(a[y], a[z]), pre[i][x] = j;
if (f[i - 1][j] + max(a[x], a[z]) < f[i][y])
f[i][y] = f[i - 1][j] + max(a[x], a[z]), pre[i][y] = j;
if (f[i - 1][j] + max(a[x], a[y]) < f[i][z])
f[i][z] = f[i - 1][j] + max(a[x], a[y]), pre[i][z] = j;
}
printf("%d\n", f[(n + 1) / 2][n + 1]);
dfs((n + 1) / 2, n + 1);
return 0;
}
| 10 | CPP |
for _ in range(int(input())):
n = int(input())
l = [int(s)-1 for s in input().split()]
visited = [0]*n
ans = [0]*n
d = {}
for i in range(n):
j = l[i]
ann = 1
if not visited[i]:
d[i] = i
while j != i:
ann += 1
d[j] = i
j = l[j]
ans[i] = ann
for i in range(n):
print(ans[d[i]], end=" ")
print()
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100002;
int n, m, f[N], g[N], h[N], r[N];
set<int> s;
int main() {
std::ios::sync_with_stdio(false);
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", f + i);
s.insert(f[i]);
}
m = s.size();
int cnt = 1;
for (set<int>::iterator it = s.begin(); it != s.end(); it++)
h[cnt++] = *it, r[*it] = cnt - 1;
for (int i = 1; i <= m; i++) g[h[i]] = i;
for (int i = 1; i <= n; i++) {
if (g[i] == 0) {
g[i] = r[f[i]];
}
}
for (int i = 1; i <= n; i++)
if (h[g[i]] != f[i]) {
puts("-1");
return 0;
}
for (int i = 1; i <= m; i++)
if (g[h[i]] != i) {
puts("-1");
return 0;
}
printf("%d\n", m);
for (int i = 1; i <= n; i++) printf("%d ", g[i]);
puts("");
for (int i = 1; i <= m; i++) printf("%d ", h[i]);
puts("");
return 0;
}
| 10 | CPP |
import io
import os
from sys import stdout,stdin
#input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
input=stdin.readline
for t in range(int(input())):
n=int(input())
count=0
flag=0
while n!=1:
if n%6==0:
n=n//6
flag=0
else:
n=n*2
flag+=1
if flag==2:
count=-1
break
count+=1
print(count) | 8 | PYTHON3 |
def main():
n = int(input())
if n == 2:
print("2\n2 1")
return
line = "2\n"
line += str(n) + " " + str(n - 2) + '\n'
line += str(n -1) + " " + str(n - 1) + '\n'
for i in range(n - 1, 2, -1):
line += str(i) + " " + str(i - 2) + '\n'
print(line, end="")
if __name__ == '__main__':
t = int(input())
for i in range(t):
main()
"""
1 2 3 4 5
1 2 4 4
1 2 4
1 3
2
1 2 3 4 5 6
1 2 3 5 5
1 2 3 5
1 2 4
1 3
2
1 2 3 4 5 6 7 ( max, max - 2)
1 2 3 4 6 6 (max - 1, max - 1)
1 2 3 4 6 (max - 1, max - 3)
1 2 3 5 (max - 2 max - 4)
1 2 4
1 3
2
1 2 3 4 5 6 7 8 (6, 8)
1 2 3 4 5 7 7 (7, 7)
1 2 3 4 5 7 (5, 7)
1 2 3 4 6 (4, 6)
1 2 3 5 (3, 5)
1 2 4 (2, 4)
1 3 (1, 3)
2
""" | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int A[222222];
int tree[222222];
void update(int idx, int n) {
while (idx <= n) {
tree[idx]++;
idx += (idx & -idx);
}
}
int read(int idx) {
int sum = 0;
while (idx > 0) {
sum += tree[idx];
idx -= (idx & -idx);
}
return sum;
}
int GetKth(int n, int k) {
int low = 1;
int high = n;
while (low < high) {
int mid = (low + high) / 2;
if (read(mid) < k) {
low = mid + 1;
} else {
high = mid;
}
}
return low;
}
vector<pair<int, int>> reqd[222222];
int ans[222222];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> A[i];
vector<pair<int, int>> val_id;
for (int i = 1; i <= n; i++) {
val_id.push_back({A[i], -i});
}
sort(val_id.begin(), val_id.end());
for (int i = 1; i <= n; i++) tree[i] = 0;
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
int k, pos;
cin >> k >> pos;
reqd[k].push_back({pos, i});
}
for (int j = n - 1; j >= 0; j--) {
int id = -val_id[j].second;
update(id, n);
for (pair<int, int> k_i : reqd[n - j]) {
int k = k_i.first;
int i = k_i.second;
ans[i] = GetKth(n, k);
}
}
for (int i = 1; i <= m; i++) cout << A[ans[i]] << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename X>
inline X abs(const X& a) {
return a < 0 ? -a : a;
}
template <typename X>
inline X sqr(const X& a) {
return a * a;
}
const int size = 1e5 + 2;
const double eps = 0.0001;
const long double PI = 3.1415926535897932384626433832795;
const long long MOD = 1000000007;
const long long INF = 1LL << 60;
const long long MAX5 = 100001;
const long long MAX6 = 1000001;
const long long MAX17 = 99999999999999999;
const double DMAX = 2e18 + 5;
void solution();
void include_file();
int main() {
ios_base::sync_with_stdio(false);
solution();
return 0;
}
void include_file() {
ios_base::sync_with_stdio(true);
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
inline bool isPrime(long long n) {
for (int i = 2; i * i <= n; ++i)
if (n % i == 0) return false;
return true;
}
string ekv(string a) {
if (a.size() & 1) return a;
string x = ekv(a.substr(0, a.size() / 2));
string y = ekv(a.substr(a.size() / 2));
return min(x + y, y + x);
}
long long cubic_root(long long x) {
long long l = 0, r = MAX6;
while (l != r) {
long long m = (l + r + 1) / 2;
if (m * m * m > x)
r = m - 1;
else
l = m;
}
return l;
}
float FastInvSqrt(float x) {
float xhalf = 0.5f * x;
int i = *(int*)&x;
i = 0x5f3759df - (i >> 1);
x = *(float*)&i;
x = x * (1.5f - (xhalf * x * x));
return x;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
void yes() { cout << "YES"; }
void no() { cout << "NO"; }
void yes(bool res) {
if (res)
cout << "YES";
else
cout << "NO";
}
void dabl(double x) { printf("%.10lf", x); }
namespace bits {
template <typename X>
inline X MAX(const X& a, const X& b) {
return b & ((a - b) >> 31) | a & (~(a - b) >> 31);
}
template <typename X>
inline X MIN(const X& a, const X& b) {
return a & ((a - b) >> 31) | b & (~(a - b) >> 31);
}
bool check2(const long long n) { return n > 0 && (n & (n - 1)); }
long long ostatok2(const long long n, const long long m) { return m & (n - 1); }
template <typename X>
void SWAP(X& a, X& b) {
a ^= b;
b ^= a;
a ^= b;
}
size_t count_1_in_LL(unsigned long long n) {
std::size_t i(0);
for (; n; ++i) n &= n - 1;
return i;
}
} // namespace bits
vector<vector<int> > g;
inline void solution() {
long long n, k;
cin >> n >> k;
int a[n];
for (long long i = 0; i < n; ++i) cin >> a[i];
;
map<int, int> q;
for (long long i = 0; i < n; ++i) q[a[i]]++;
sort(a, a + n);
int res = 0;
auto it = q.begin();
it++;
for (; it != q.end(); ++it) {
auto ita = it;
ita--;
if ((*ita).first + k >= (*it).first) res += (*ita).second;
}
cout << n - res;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 10;
const long long INF = 1e10;
const long long inf = -1e18;
const long long MOD = 1e9 + 7;
const long long base = 1000 * 1000 * 1000;
long long n, p[N], a[N], ans, us[N], mn, x;
vector<long long> g[N];
void dfs(long long v, long long last) {
if (g[v].empty()) {
return;
}
if (a[v] == -1) {
long long mn = 1e9;
for (int y : g[v]) {
mn = min(mn, a[y]);
}
if (mn < last) {
cout << -1 << "\n";
exit(0);
}
ans += mn - last;
for (int y : g[v]) {
ans += a[y] - mn;
dfs(y, last);
}
} else {
for (int y : g[v]) {
dfs(y, a[v]);
}
}
}
void solve() {
cin >> n;
for (int i = 2; i <= n; i++) {
cin >> x;
g[x].push_back(i);
}
for (int i = 1; i <= n; i++) cin >> a[i];
ans = a[1];
dfs(1, 0);
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
long long t = 1;
while (t--) {
solve();
}
}
| 7 | CPP |
#ashu@2022
s=input()
zero="0000000"
one="1111111"
if zero in s or one in s:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
def best_subsegent2(n, a):
maxx=0
v=max(a)
x=1
if n==1:
return(1)
for i in range(1,n):
if a[i-1]==v and a[i]==v:
x+=1
elif a[i]==v:
x=1
maxx=max(x, maxx)
return(maxx)
n = input()
a = input().strip().split()
a = list(map(int, a))
print(best_subsegent2(int(n),a)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int Add(int &a, int b) { a = (a + b) % 1000000007; }
int Min(int &a, int b) { a = (a + 1000000007 - b) % 1000000007; }
int Mul(int &a, int b) { a = (long long)a * b % 1000000007; }
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long pow(long long a, long long b) {
long long res(1);
while (b) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
b >>= 1;
}
return res;
}
long long powM(long long a, long long b, long long mod) {
long long res(1);
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
const int infi = 2147483647;
const long long infl = 9223372036854775807;
int n, m, k, T, a[100010];
int main() {
scanf("%d", &n);
int mi = 1e5 + 10, ma = -1e5 - 10;
for (int i = 1; i <= (n); ++i)
scanf("%d", &a[i]), mi = min(mi, a[i]), ma = max(ma, a[i]);
if (mi != ma - 2) {
printf("%d", (n)), putchar('\n');
for (int i = 1; i <= (n); ++i)
printf("%d", (a[i])), i < n ? putchar(' ') : putchar('\n');
} else {
int x = 0, y = 0, z = 0;
for (int i = 1; i <= (n); ++i)
if (a[i] == mi)
x++;
else if (a[i] == ma)
z++;
else
y++;
if (min(x, z) >= (y >> 1)) {
printf("%d", (n - 2 * min(x, z))), putchar('\n');
for (int i = 1; i <= (y + 2 * min(x, z)); ++i)
printf("%d", (ma - 1)), putchar(' ');
for (int i = 1; i <= (x - min(x, z)); ++i)
printf("%d", (mi)), putchar(' ');
for (int i = 1; i <= (z - min(x, z)); ++i)
printf("%d", (ma)), putchar(' ');
} else {
printf("%d", (n - 2 * (y >> 1))), putchar('\n');
for (int i = 1; i <= (y & 1); ++i) printf("%d", (ma - 1)), putchar(' ');
for (int i = 1; i <= (x + (y >> 1)); ++i)
printf("%d", (mi)), putchar(' ');
for (int i = 1; i <= (z + (y >> 1)); ++i)
printf("%d", (ma)), putchar(' ');
}
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
void run_case() {
int n, d;
cin >> n >> d;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int t = gcd(n, d);
int ans = 0;
for (int i = 0; i < t; i++) {
vector<int> b;
for (int j = 0; j < n / t; j++) {
b.push_back(a[(i + j * 1LL * d) % n]);
}
if (count(b.begin(), b.end(), 0) == 0) {
cout << "-1\n";
return;
}
for (int i = 0, j = 0; i < n / t; i++) {
while (j < i || b[j % (n / t)] != 0) {
j++;
}
ans = max(ans, j - i);
}
}
cout << ans << '\n';
}
auto clk = clock();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
run_case();
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2 * 1e5 + 4;
long long add(long long a, long long b, long long m) {
if (a < 0) a += m;
if (b < 0) b += m;
long long res = ((a % m) + (b % m)) % m;
res %= m;
return res;
}
long long mul(long long a, long long b, long long m) {
if (a < 0) a += m;
if (b < 0) b += m;
long long res = ((a % m) * (b % m)) % m;
res %= m;
return res;
}
long long sub(long long a, long long b, long long m) {
long long res = (a - b + m) % m;
res %= m;
return res;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
string second;
cin >> second;
vector<long long> dp(n + 1, 1e12), pref(n + 1, 0);
dp[0] = 0;
for (long long i = 1; i <= n; i++) {
if (second[i - 1] == '1') pref[i] = 1;
pref[i] += pref[i - 1];
}
for (long long i = 1; i <= n; i++) {
long long a = 0, b = 0;
if (second[i - 1] == '0') a++, b++;
long long prev = i - k;
if (prev < 1)
a += pref[i - 1];
else
a += dp[prev] + pref[i - 1] - pref[prev];
b += pref[i - 1];
dp[i] = min(a, b);
}
long long res = pref[n];
for (long long i = 1; i <= n; i++) {
res = min(res, dp[i] + pref[n] - pref[i]);
}
cout << res << '\n';
}
return 0;
}
| 11 | CPP |
#include<bits/stdc++.h>
using namespace std;
#define MOD 998244353
typedef long long ll;
#define rep(i,a,b) for(ll i=a;i<b;++i)
#define pii pair<int,int>
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
int tt=1;
cin>>tt;
while(tt--)
{
ll n;
cin>>n;
if(n&1) cout<<"-1\n";
else
{
vector<bool> v;
v.push_back(1);
n-=2;
ll p;
while(n>4)
{
p=4;
while(n>p)
{
v.push_back(0);
n-=p;
p*=2;
}
v.push_back(1);
n-=2;
}
rep(i,0,n/2)
v.push_back(1);
cout<<v.size()<<"\n";
rep(i,0,v.size())
cout<<v[i]<<" ";
cout<<"\n";
}
}
} | 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
char s1[110], s2[110], virus[110], ans[110];
int F[110], dp[110][110][110], s1size, s2size, virusSize, ans_i = 0;
void calc_failure_fuction() {
int k, psize = virusSize;
F[1] = 0;
F[0] = 0;
for (int i = 2; i <= psize; i++) {
k = F[i - 1];
while (true) {
if (virus[k] == virus[i - 1]) {
F[i] = k + 1;
break;
}
if (k == 0) {
F[i] = 0;
break;
}
k = F[k];
}
}
}
int f(int i, int j, int k) {
if (k >= virusSize) return -1000;
if (i >= s1size || j >= s2size) return 0;
if (dp[i][j][k] != -1) return dp[i][j][k];
int down = f(i + 1, j, k);
int right = f(i, j + 1, k);
int ret = max(right, down);
if (s1[i] == s2[j]) {
int tk = k;
while (tk > 0 && s1[i] != virus[tk]) tk = F[tk];
if (s1[i] == virus[tk]) {
tk++;
}
ret = max(ret, f(i + 1, j + 1, tk) + 1);
}
dp[i][j][k] = ret;
return ret;
}
void printAnswer(int i, int j, int k) {
if (k >= virusSize) return;
if (i >= s1size || j >= s2size) return;
int valInThisState = f(i, j, k);
if (valInThisState == f(i + 1, j, k)) {
printAnswer(i + 1, j, k);
return;
}
if (valInThisState == f(i, j + 1, k)) {
printAnswer(i, j + 1, k);
return;
}
if (s1[i] == s2[j]) {
int tk = k;
while (tk > 0 && s1[i] != virus[tk]) tk = F[tk];
if (s1[i] == virus[tk]) {
tk++;
}
if (valInThisState == f(i + 1, j + 1, tk) + 1) {
ans[ans_i++] = s1[i];
printAnswer(i + 1, j + 1, tk);
}
}
return;
}
int main() {
scanf("%s\n%s\n%s", s1, s2, virus);
s1size = strlen(s1), s2size = strlen(s2), virusSize = strlen(virus);
calc_failure_fuction();
memset(dp, -1, sizeof dp);
int f_ans = f(0, 0, 0);
printAnswer(0, 0, 0);
if (f_ans > 0)
printf("%s\n", ans);
else
printf("0\n");
return 0;
}
| 8 | CPP |
import copy
a, b = map(int, input().split(" "))
a1 = a
inp = list(map(int, input().split()))
lst = copy.deepcopy(inp)
i = ans = cnt = 0
ans1 = 0
lst.sort()
inp.sort()
# min datvla
while i < len(lst):
while lst[i] != 0:
if cnt == a:
break
ans += lst[i]
lst[i] -= 1
cnt += 1
i += 1
# max datvla
while a != 0:
inp.sort(reverse=True)
ans1 += inp[0]
inp[0] -= 1
a -= 1
print(ans1, ans)
| 8 | PYTHON3 |
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
//typedef long long ll;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,a) FOR(i,0,a)
using namespace std;
const int MAX_N=600;
int N,M;
vector<int> G[MAX_N];
double dp[MAX_N];
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
scanf("%d %d",&N,&M);
REP(i,M){
int s,t;
scanf("%d %d",&s,&t);
s--;
t--;
G[s].push_back(t);
}
dp[N-1]=0;
double ans=N;
REP(k,N){
for(int i=N-2;i>=0;i--){
double mdp=0;
dp[i]=0;
for(auto e:G[i]){
dp[i]+=dp[e];
mdp=max(mdp,dp[e]);
}
if(i==k&&G[i].size()>=2){
dp[i]-=mdp;
dp[i]/=G[i].size()-1;
}else{
dp[i]/=G[i].size();
}
dp[i]++;
}
ans=min(ans,dp[0]);
}
printf("%.8f\n",ans);
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline void read(t& res) {
char ch;
while (ch = getchar(), !isdigit(ch))
;
res = ch ^ 48;
while (ch = getchar(), isdigit(ch)) res = res * 10 + (ch ^ 48);
}
const int e = 1e5 + 5;
struct node {
int id;
long long v;
node() {}
node(int _id, long long _v) : id(_id), v(_v) {}
};
long long ans, b[e], a[e], h[e];
int n, m, k, p;
priority_queue<node> q;
inline bool operator<(node a, node b) { return a.v > b.v; }
inline bool check(long long mid) {
while (!q.empty()) q.pop();
int i, j;
for (i = 1; i <= n; i++) {
h[i] = mid;
if (h[i] - m * a[i] < b[i]) q.push(node(i, mid / a[i]));
}
for (i = 1; i <= m; i++)
for (j = 1; j <= k; j++) {
if (q.empty()) return 1;
node u = q.top();
q.pop();
if (u.v < i) return 0;
int x = u.id;
h[x] += p;
if (h[x] - m * a[x] < b[x]) q.push(node(x, h[x] / a[x]));
}
return q.empty();
}
int main() {
int i;
long long l = 0, r = 0;
read(n);
read(m);
read(k);
read(p);
for (i = 1; i <= n; i++) {
read(b[i]), read(a[i]);
r = max(r, b[i] + (long long)m * a[i]);
}
while (l <= r) {
long long mid = l + r >> 1;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
const int N = 400005;
int n, q[N], head, tail;
long long s[N], dp[N], c;
void trans(int x, int y) {
dp[x] = std::max(dp[x], dp[y] + std::min(c, s[2 * x - 1] - s[2 * y]));
}
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
int tc = 1;
while (tc--) {
int t = -1;
std::cin >> n >> c;
for (int i = 1; i < n << 1; ++i) std::cin >> s[i], s[i] += s[i - 1];
q[head = tail = 1] = 0;
for (int i = 1; i <= n; ++i) {
dp[i] = 0;
while (t < i - 1 && s[t * 2 + 2] < s[i * 2 - 1] - c) ++t;
while (head <= tail && s[q[head] * 2] < s[i * 2 - 1] - c) ++head;
if (~t) trans(i, t);
if (head <= tail) trans(i, q[head]);
while (head <= tail && dp[i] - s[2 * i] >= dp[q[tail]] - s[2 * q[tail]])
--tail;
q[++tail] = i;
}
std::cout << dp[n] << '\n';
}
return 0;
}
| 12 | CPP |
n, a = input(), list(sorted(map(int, input().split())))
print(min(a[-2] - a[0], a[-1] - a[1])) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int t = 1;
cin >> t;
while (t--) {
string n, k;
cin >> n >> k;
string A, B, C, other;
for (int i = 0; i < n.size(); i++) {
if (n[i] == 'a')
A.push_back('a');
else if (n[i] == 'b')
B.push_back('b');
else if (n[i] == 'c')
C.push_back('c');
else
other.push_back(n[i]);
}
sort(n.begin(), n.end());
sort(other.begin(), other.end());
if (A.size() == 0 || B.size() == 0 || C.size() == 0)
cout << n;
else {
if (k[0] == 'a') {
if (k[1] == 'b')
cout << A << C << B;
else
cout << A << B << C;
} else {
cout << A << B << C;
}
if (other.size() != 0) cout << other;
}
cout << "\n";
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long t;
cin >> t;
for (int i = 0; i < t; i++) {
long a, b, x, y;
cin >> a >> b >> x >> y;
vector<long> a1;
long z = (a - x - 1) * b;
long z1 = (x - 0) * b;
long z2 = (b - y - 1) * a;
long z3 = (y - 0) * a;
a1.push_back(z);
a1.push_back(z1);
a1.push_back(z2);
a1.push_back(z3);
sort(a1.begin(), a1.end());
cout << a1[a1.size() - 1] << endl;
}
}
| 7 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.