solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
t = int(input())
check = 0
for i in range(t):
n = int(input())
string = input()
a = string[:n//2]
b = string[-1:-n//2-1:-1]
for i in range(n//2):
if abs(ord(a[i]) - ord(b[i])) > 2 or abs(ord(a[i]) - ord(b[i])) == 1:
print("NO")
check = 1
break
if check == 0:
print("YES")
check = 0 | 7 | PYTHON3 |
#include<bits/stdc++.h>
#define fo(i,a,b)for(int i=a,_e=b;i<=_e;++i)
#define fd(i,a,b)for(int i=b,_e=a;i>=_e;--i)
#define P pair<int,int>
#define fi first
#define se second
#define pb push_back
using namespace std;
const int N=1005,M=2e5+5;
int n,m,x,y;
int d[N];
vector<P>e[N];
vector<int>e2[N];
bool can[M],bz[N],bz2[N];
void cover(int x){
if(bz2[x])return;
bz2[x]=1;d[1]=x;
for(int l=0,r=1;x=d[++l],l<=r;)
for(P i:e[x])if(!bz2[i.fi])
bz2[i.fi]=1,d[++r]=i.fi;
}
int main(){
ios::sync_with_stdio(0);
cin>>n>>m;
fo(i,1,m){
cin>>x>>y;
e[x].pb(P(y,i));
e2[y].pb(x);
}
fo(i,1,n){
fo(j,1,n)bz2[j]=bz[j]=0;
d[1]=i;bz[i]=1;
for(int l=0,r=1;x=d[++l],l<=r;)
for(int i:e2[x])if(!bz[i])
bz[i]=1,d[++r]=i;
bz2[i]=1;
for(P j:e[i]){
can[j.se]=bz2[j.fi];
cover(j.fi);
}
fo(j,1,n)bz2[j]=0;
bz2[i]=1;
fd(j,0,e[i].size()-1){
x=e[i][j].fi;
y=e[i][j].se;
can[y]|=bz2[x];
cover(x);
can[y]=can[y]?(bz[x]?0:1):(bz[x]?1:0);
}
}
fo(i,1,m)printf(can[i]?"diff\n":"same\n");
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5;
string s;
vector<long long> a;
long long dp[N][2];
long long n;
long long solve(long long idx, long long flag) {
if (idx == n) {
return 0;
}
if (dp[idx][flag] != -1) return dp[idx][flag];
long long ans = 0;
if (flag) {
ans = solve(idx + 1, flag);
ans = max(ans, a[idx] + solve(idx + 1, flag));
} else {
if (s[idx] == '0') {
ans = solve(idx + 1, flag);
} else {
ans = solve(idx + 1, 1);
ans = max(ans, a[idx] + solve(idx + 1, flag));
}
}
dp[idx][flag] = ans;
return ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
a.push_back(x);
}
reverse(a.begin(), a.end());
cin >> s;
reverse(s.begin(), s.end());
memset(dp, -1, sizeof(dp));
cout << solve(0, 0);
}
| 9 | CPP |
n=int(input())
f=0
x=0
for i in range(n):
a=input()
x=0
a=a.split(' ')
for i in a:
if(int(i)==1):
x=x+1
if x>=2:
f+=1;
print(f)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
const int kk[2] = {37, 41};
const int nn = 200005;
const int mod[2] = {(int)1e9 + 271, (int)1e9 + 321};
const int pp[11] = {1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 31};
long long r[2][nn];
long long s[2][11][nn];
long long ir[2][nn];
long long h[2][18];
struct sgt {
vector<pair<long long, long long> > tree;
int idx;
void update(int le, int ri, long long val, int nodele, int noderi, int node) {
if (tree[node].second) {
long long now = tree[node].second;
int len = noderi - nodele + 1;
tree[node].second = 0;
tree[node].first = (s[idx][now][len] * r[idx][n - noderi - 1]) % mod[idx];
if (nodele != noderi) {
tree[node * 2].second = now;
tree[node * 2 + 1].second = now;
}
}
if (le > noderi || ri < nodele) return;
if (le <= nodele && noderi <= ri) {
long long now = val;
int len = noderi - nodele + 1;
tree[node].first = (s[idx][now][len] * r[idx][n - noderi - 1]) % mod[idx];
if (nodele != noderi) {
tree[node * 2].second = now;
tree[node * 2 + 1].second = now;
}
return;
}
int mid = (nodele + noderi) / 2;
update(le, ri, val, nodele, mid, node * 2);
update(le, ri, val, mid + 1, noderi, node * 2 + 1);
tree[node].first =
(tree[node * 2].first + tree[node * 2 + 1].first) % mod[idx];
}
long long query(int le, int ri, int nodele, int noderi, int node) {
if (tree[node].second) {
long long now = tree[node].second;
int len = noderi - nodele + 1;
tree[node].second = 0;
tree[node].first = (s[idx][now][len] * r[idx][n - noderi - 1]) % mod[idx];
if (nodele != noderi) {
tree[node * 2].second = now;
tree[node * 2 + 1].second = now;
}
}
if (le > noderi || ri < nodele) return 0;
if (le <= nodele && noderi <= ri) return tree[node].first;
int mid = (nodele + noderi) / 2;
return (query(le, ri, nodele, mid, node * 2) +
query(le, ri, mid + 1, noderi, node * 2 + 1)) %
mod[idx];
}
};
sgt tree[2];
long long _pow(long long a, long long b, int t) {
long long ret = 1;
while (b) {
if (b & 1) ret = (ret * a) % mod[t];
a = (a * a) % mod[t];
b /= 2;
}
return ret;
}
void init() {
for (int t = 0; t < 2; t++) {
r[t][0] = 1;
ir[t][0] = 1;
for (int i = 1; i < nn; i++) r[t][i] = (r[t][i - 1] * kk[t]) % mod[t];
ir[t][nn - 1] = _pow(r[t][nn - 1], mod[t] - 2, t);
for (int i = nn - 2; i > 0; i--) ir[t][i] = (ir[t][i + 1] * kk[t]) % mod[t];
for (int i = 1; i <= 10; i++) {
for (int j = 1; j < nn; j++)
s[t][i][j] = (s[t][i][j - 1] * kk[t] + pp[i]) % mod[t];
}
}
}
bool possi(int b, int c, int d) {
for (int t = 0; t < 2; t++) {
int len = c - b + 1;
int p = len / d;
int q = len % d;
h[t][0] = (tree[t].query(b - 1, b - 1 + d - 1, 0, n - 1, 1) *
ir[t][n - 1 - (b - 1 + d - 1)]) %
mod[t];
for (int i = 1; (1 << i) <= p; i++)
h[t][i] = (h[t][i - 1] * r[t][d * (1 << (i - 1))] + h[t][i - 1]) % mod[t];
long long now = 0;
for (int i = 17; i >= 0; i--) {
if (p >= (1 << i)) {
now = (now * r[t][d * (1 << i)] + h[t][i]) % mod[t];
p -= (1 << i);
}
}
long long md = (tree[t].query(b - 1, b - 1 + q - 1, 0, n - 1, 1) *
ir[t][n - 1 - (b - 1 + q - 1)]) %
mod[t];
now = (now * r[t][q] + md) % mod[t];
long long there =
(tree[t].query(b - 1, c - 1, 0, n - 1, 1) * ir[t][n - 1 - (c - 1)]) %
mod[t];
if (now != there) return false;
}
return true;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
tree[0].idx = 0;
tree[1].idx = 1;
tree[0].tree = vector<pair<long long, long long> >(4 * n);
tree[1].tree = vector<pair<long long, long long> >(4 * n);
init();
for (int i = 0; i < n; i++) {
int x;
scanf("%1d", &x);
tree[0].update(i, i, x + 1, 0, n - 1, 1);
tree[1].update(i, i, x + 1, 0, n - 1, 1);
}
for (int i = 0; i < m + k; i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
if (a == 1) {
d++;
tree[0].update(b - 1, c - 1, d, 0, n - 1, 1);
tree[1].update(b - 1, c - 1, d, 0, n - 1, 1);
} else {
if (possi(b, c, d))
printf("YES\n");
else
printf("NO\n");
}
}
return 0;
}
| 11 | CPP |
A,B,C=map(int, input().split())
if A+B<C:
print('No')
else:
print('Yes') | 0 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
//INSERT ABOVE HERE
const int MAX = 2020;
bool a[MAX][MAX]={};
using BS = bitset<MAX>;
BS st[MAX],dpL[MAX],dpR[MAX];
signed main(){
int n;
cin>>n;
for(int i=1;i<n;i++){
string s;
cin>>s;
for(int j=0;j<i;j++){
a[i][j]=s[j]-'0';
a[j][i]=!a[i][j];
}
}
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
if(a[i][j]) st[i].set(j);
for(int i=0;i<n;i++){
dpL[i].set(i);
dpR[i].set(i);
}
for(int w=2;w<=n;w++){
for(int i=0;i+w<=n;i++){
int l=i,r=i+w-1;
{
BS x=dpR[l+1]&dpL[r]&st[l];
if((((x>>(r+1))<<(r+1))^((x>>(l+1))<<(l+1))).any()) dpL[r].set(l);
}
{
BS x=dpR[l]&dpL[r-1]&st[r];
if((((x>>r)<<r)^((x>>l)<<l)).any()) dpR[l].set(r);
}
}
}
cout<<(dpR[0]&dpL[n-1]).count()<<endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 5;
long long a[N], pref[N], suf[N];
typedef struct data {
data* bit[2];
long long cnt = 0;
} trie;
trie* head;
void insert(long long x) {
trie* node = head;
for (long long i = 40; i >= 0; i--) {
long long curbit = (x >> i) & 1;
if (node->bit[curbit] == NULL) {
node->bit[curbit] = new trie();
}
node = node->bit[curbit];
node->cnt++;
}
}
void remove(long long x) {
trie* node = head;
for (long long i = 40; i >= 0; i--) {
long long curbit = (x >> i) & 1;
node = node->bit[curbit];
node->cnt--;
}
}
long long maxxor(long long x) {
trie* node = head;
long long ans = 0;
for (long long i = 40; i >= 0; i--) {
long long curbit = (x >> i) & 1;
if (node->bit[curbit ^ 1] != NULL && node->bit[curbit ^ 1]->cnt > 0) {
ans += (1LL << i);
node = node->bit[curbit ^ 1];
} else
node = node->bit[curbit];
}
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
head = new trie();
insert(0);
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
pref[i] = pref[i - 1] ^ a[i];
insert(pref[i]);
}
for (long long i = n; i >= 1; i--) suf[i] = suf[i + 1] ^ a[i];
long long ans = maxxor(0);
for (long long i = n; i >= 1; i--) {
remove(pref[i]);
ans = max(ans, maxxor(suf[i]));
}
cout << ans;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, sum;
set<int> s1, s2;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
s1.insert(a);
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> a;
s2.insert(a);
}
auto x = s1.end(), y = s2.end();
x--;
y--;
cout << *x << " " << *y;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int INF = 1e9 + 5;
const double PI = acos(-1);
const int X[] = {1, -1, 0, 0};
const int Y[] = {0, 0, 1, -1};
const int mod = 1e9 + 7;
char a[55][55];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, c = 1;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
if (i % 2 == 1)
for (int j = 1; j <= m; j++) a[i][j] = '#';
else {
if (c)
a[i][m] = '#';
else
a[i][1] = '#';
c ^= 1;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == '#')
cout << a[i][j];
else
cout << '.';
}
cout << "\n";
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const long long mod = 998244353;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long binpow(long long a, long long b, long long m) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
struct dsu {
struct op {
int u, l, t;
op() {}
op(int u, int l, int t) : u(u), l(l), t(t) {}
};
vector<int> pai, tam;
stack<op> old_pai;
stack<op> old_tam;
vector<int> g[200200];
dsu() {}
dsu(int n) {
pai.resize(n);
tam = pai;
for (int i = 0; i < n; i++) {
pai[i] = i;
tam[i] = 1;
}
}
vector<int> at, deleted;
void init(vector<int> &v) {
at.resize(v.size() + 1);
deleted.resize(v.size() + 1);
for (int i = 0; i < v.size(); i++) {
g[i].emplace_back(v[i]);
at[v[i]] = i;
}
}
int find(int u) {
if (pai[u] == u) return u;
return find(pai[u]);
}
void merge(int u, int v, int t) {
int a = find(u);
int b = find(v);
if (a == b) return;
if (tam[a] > tam[b]) swap(a, b);
old_pai.emplace(a, pai[a], t);
old_tam.emplace(b, tam[b], t);
pai[a] = b;
tam[b] += tam[a];
for (int &x : g[a]) {
g[b].push_back(x);
at[x] = b;
}
}
void query(int v) {
v = find(v);
int go = 0;
while (!g[v].empty()) {
int u = g[v].back();
g[v].pop_back();
if (u == 0 or at[u] != v or deleted[u])
continue;
else {
go = u;
deleted[u] = 1;
break;
}
}
cout << go << "\n";
}
void rollback(int t) {
while (!old_pai.empty() && old_pai.top().t >= t) {
pai[old_pai.top().u] = old_pai.top().l;
tam[old_tam.top().u] = old_tam.top().l;
for (int &x : g[old_pai.top().l]) {
at[x] = old_pai.top().l;
}
old_pai.pop();
old_tam.pop();
}
}
};
void solve() {
int n, m, q;
cin >> n >> m >> q;
vector<int> p(n), er(m);
{
for (auto &_re : p) cin >> _re;
};
vector<pair<int, int> > e(m);
for (int i = 0; i < m; i++) {
cin >> e[i].first >> e[i].second;
e[i].first--;
e[i].second--;
}
vector<pair<int, int> > qs(q);
for (int i = 0; i < q; i++) {
cin >> qs[i].first >> qs[i].second;
qs[i].second--;
if (qs[i].first == 2) er[qs[i].second] = 1;
}
dsu D(n);
D.init(p);
for (int i = 0; i < m; i++) {
if (er[i]) continue;
D.merge(e[i].first, e[i].second, 0);
}
int t = 1;
for (int i = q - 1; i >= 0; i--) {
if (qs[i].first == 2) {
D.merge(e[qs[i].second].first, e[qs[i].second].second, t++);
}
}
for (int i = 0; i < n; i++) sort(D.g[i].begin(), D.g[i].end());
for (int i = 0; i < q; i++) {
if (qs[i].first == 1) {
D.query(qs[i].second);
} else {
D.rollback(--t);
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * flag;
}
bitset<505> f[2][65][505], t, pre;
long long ans;
int main() {
int n = read(), m = read();
while (m--) {
int x = read(), y = read(), t = read();
f[t][0][x][y] = 1;
}
for (int s = 1; s <= 60; ++s)
for (int p = 0; p <= 1; ++p)
for (int x = 1; x <= n; ++x)
for (int k = 1; k <= n; ++k)
if (f[p][s - 1][x][k]) f[p][s][x] |= f[p ^ 1][s - 1][k];
for (int i = 1; i <= n; ++i)
if (f[0][60][1][i]) {
puts("-1");
return 0;
}
int now = 0;
pre[1] = 1;
for (int s = 59; s >= 0; --s) {
t.reset();
for (int i = 1; i <= n; ++i)
if (pre[i]) t |= f[now][s][i];
if (t.count()) {
pre = t;
now ^= 1;
ans += (1ll << s);
if (ans > 1e18) {
puts("-1");
return 0;
}
}
}
printf("%I64d", ans);
}
| 12 | CPP |
import os
import sys
import math
import heapq
from decimal import *
from io import BytesIO, IOBase
from collections import defaultdict, deque
def r():
return int(input())
def rm():
return map(int,input().split())
def rl():
return list(map(int,input().split()))
'''a'''
n=r()
a=rl()
have=defaultdict(int)
for i in a:
have[i]+=1
print(max(have.values()))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll M = 1000000007;
const ll M1 = 998244353;
using vl = vector<ll>;
using pll = pair<ll, ll>;
ll power(ll x, ll y) {
if (y == 0) return 1;
ll res = power(x, y / 2);
res = (res * res);
if (y & 1) res = (res * x);
return res;
}
ll powermod(ll x, ll y, ll mod) {
if (y == 0) return 1;
ll res = powermod(x, y / 2, mod);
res = (res * res) % mod;
if (y & 1) res = (res * x) % mod;
return res;
}
ll findxor(ll a) {
switch (a & 3) {
case 0:
return a;
case 1:
return 1;
case 2:
return a + 1;
case 3:
return 0;
}
return -1;
}
int n;
vector<int> visi;
vector<string> gr;
void dfs(int node, vector<int> &rec_visit) {
visi[node] = 1;
rec_visit.push_back(node);
for (int con_node = 0; con_node < n; con_node++) {
if (visi[con_node] || gr[node][con_node] == '0') continue;
dfs(con_node, rec_visit);
}
}
void solve() {
cin >> n;
int ans[n];
for (int i = 0; i < n; i++) cin >> ans[i];
gr.resize(n);
visi.resize(n, 0);
for (int i = 0; i < n; i++) cin >> gr[i];
for (int i = 0; i < n; i++) {
if (visi[i]) continue;
vector<int> rec_visit;
dfs(i, rec_visit);
vector<int> val;
for (int j = 0; j < rec_visit.size(); j++) val.push_back(ans[rec_visit[j]]);
sort(val.begin(), val.end());
sort(rec_visit.begin(), rec_visit.end());
for (int j = 0; j < rec_visit.size(); j++) ans[rec_visit[j]] = val[j];
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MN = 110;
int a[MN];
int b[MN];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int N, K;
cin >> N >> K;
int maxB = -1;
for (int i = 1; i <= N; i++) {
cin >> a[i] >> b[i];
maxB = max(maxB, b[i]);
}
if (a[1] > 0 || maxB < K) {
cout << "NO\n";
return 0;
} else {
maxB = b[1];
if (maxB >= K) {
cout << "YES\n";
return 0;
}
for (int i = 2; i <= N; i++) {
if (a[i] > maxB) {
cout << "NO\n";
return 0;
}
maxB = max(maxB, b[i]);
if (maxB >= K) {
cout << "YES\n";
return 0;
}
}
}
cout << "NO\n";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void sci(T& t) {
cin >> t;
}
template <typename T, typename... Ts>
void sci(T& t, Ts&... ts) {
sci(t);
sci(ts...);
}
int32_t main() {
cin.tie(nullptr);
cout.tie(nullptr);
ios_base::sync_with_stdio(false);
int64_t n, k;
cin >> n >> k;
vector<int64_t> a(n);
for (int64_t(i) = 0; (i) < (int64_t)(n); ++(i)) {
cin >> a[i];
}
int64_t sum = 0;
long double ans = 0;
int64_t i = 0;
for (; i < k; ++i) {
sum += a[i];
}
ans = sum;
int64_t j = 0;
while (i < n) {
sum -= a[j];
sum += a[i];
j++, i++;
ans += sum;
}
cout << fixed << setprecision(9) << ans / (n - k + 1);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma optimize("-O3")
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(const bool& b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(const A& v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) res += ", ";
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
template <typename T>
inline void _read(T& x) {
cin >> x;
}
template <typename A, typename B>
inline void _read(pair<A, B>& x) {
_read(x.first);
_read(x.second);
}
template <typename T>
inline void _read(vector<T>& x) {
for (auto& v : x) _read(v);
}
void R() {}
template <typename T, typename... U>
void R(T& head, U&... tail) {
_read(head);
R(tail...);
}
template <typename T>
inline void _write(const T& x) {
cout << x << ' ';
}
template <typename A, typename B>
inline void _write(const pair<A, B>& x) {
_write(x.first);
_write(x.second);
}
template <typename T>
inline void _write(const vector<T>& in) {
for (const auto& x : in) _write(x);
}
void W() { cout << '\n'; }
template <typename T, typename... U>
void W(const T& head, const U&... tail) {
_write(head);
W(tail...);
}
void go();
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
go();
return 0;
}
const int INF = 0x3f3f3f3f;
void go() {
int n, m, t, tp, tu, td;
R(n, m, t, tp, tu, td);
vector<vector<int>> G(n, vector<int>(m));
R(G);
vector<vector<vector<int>>> dp(4, vector<vector<int>>(n, vector<int>(m)));
auto f = [&](int x, int y) {
if (x > y) return tu;
if (x < y) return td;
return tp;
};
for (int i = 0; i < n; i++) {
dp[0][i][0] = 0;
for (int j = 1; j < m; j++)
dp[0][i][j] = dp[0][i][j - 1] + f(G[i][j], G[i][j - 1]);
dp[1][0][m - 1] = 0;
for (int j = m - 2; ~j; j--)
dp[1][i][j] = dp[1][i][j + 1] + f(G[i][j], G[i][j + 1]);
}
for (int j = 0; j < m; j++) {
dp[2][0][j] = 0;
for (int i = 1; i < n; i++)
dp[2][i][j] = dp[2][i - 1][j] + f(G[i][j], G[i - 1][j]);
dp[3][n - 1][j] = 0;
for (int i = n - 2; ~i; i--)
dp[3][i][j] = dp[3][i + 1][j] + f(G[i][j], G[i + 1][j]);
}
int ans = INF;
pair<pair<int, int>, pair<int, int>> ret;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = i + 2; k < n; k++)
for (int l = j + 2; l < m; l++) {
int t0 = dp[0][i][l] - dp[0][i][j];
int t1 = dp[1][k][j] - dp[1][k][l];
int t2 = dp[2][k][l] - dp[2][i][l];
int t3 = dp[3][i][j] - dp[3][k][j];
if (abs(t0 + t1 + t2 + t3 - t) < ans) {
ans = abs(t0 + t1 + t2 + t3 - t);
ret = {{i + 1, j + 1}, {k + 1, l + 1}};
}
}
42;
;
W(ret);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
int t;
int n;
const int N = 2e6 + 5;
int c[N];
int s, cnt[N], minv;
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(false);
int t;
cin >> t;
for (int kk = 0; kk < t; ++kk) {
cin >> n;
memset(cnt, 0, sizeof(int) * (n + 1));
for (int i = 1; i <= n; ++i) {
cin >> c[i];
++cnt[c[i]];
}
minv = n + 1;
vector<int> checklist;
for (int i = 1; i <= n; ++i) {
if (cnt[i] > 0) {
checklist.push_back(cnt[i]);
minv = min(minv, cnt[i] + 1);
}
}
int ans = n;
for (int i = minv; i >= 1; --i) {
int s = i;
bool flag = true;
for (int x : checklist) {
if (x % s > 0 && (x / s) < ((s - 1) - (x % s))) {
flag = false;
break;
}
}
if (flag) {
int tans = 0;
for (int x : checklist) {
tans += ((x + s - 1) / s);
}
ans = min(ans, tans);
}
}
cout << ans << endl;
}
return 0;
}
| 16 | CPP |
for i in range(int(input())):
s = input().split()
a = int(s[0])
b = int(s[1])
x = 23
y = 60
hr = x - a
mi = y - b
ans = (hr * 60) + mi
print(ans)
| 7 | PYTHON3 |
for _ in range(int(input())):
n,a,b=map(int,input().split())
ans=''
for i in range(n):
ans+=chr(97+i%b)
print(ans) | 8 | PYTHON3 |
w = int(input())
if w%2 == 0 and 1<=w<=100 and w != 2 :
print ("YES")
elif 1<=w<=100:
print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
string s;
cin >> n >> s;
if (n % 2 == 1)
cout << "contest";
else
cout << "home";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<long long> nums(n);
for (long long i = 0; i < n; i++) {
cin >> nums[i];
}
vector<long long> numsSorted(n);
numsSorted = nums;
sort(numsSorted.begin(), numsSorted.end());
long long startingP = 0, endingP = 0;
for (long long i = 0; i < n; i++) {
if (nums[i] != numsSorted[i]) {
startingP = i;
break;
}
}
for (long long i = startingP + 1; i < n; i++) {
if (numsSorted[i] == nums[startingP]) {
endingP = i;
break;
}
}
for (long long i = startingP; i <= startingP + (endingP - startingP) / 2;
i++) {
long long num = nums[i];
nums[i] = nums[endingP - (i - startingP)];
nums[endingP - i + startingP] = num;
}
string ans = "yes";
for (long long i = 0; i < n; i++) {
if (nums[i] != numsSorted[i]) {
ans = "no";
break;
}
}
cout << ans << endl;
if (ans == "yes") {
cout << startingP + 1 << " " << endingP + 1;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
long long int a[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
vector<long long int> v;
v.push_back(sqrt((a[0][1] * a[0][2]) / a[1][2]));
v.push_back(sqrt((a[1][0] * a[1][2]) / a[0][2]));
for (int i = 2; i < n; i++) {
v.push_back(sqrt((a[i][0] * a[i][1]) / a[0][1]));
}
for (int i = 0; i < n; i++) {
cout << v[i] << " ";
}
cout << endl;
}
| 8 | CPP |
import heapq
n, k = map(int, input().split())
x, y, z = [], [], []
heapq.heapify(x)
heapq.heapify(y)
heapq.heapify(z)
for _ in range(n):
t, a, b = map(int, input().split())
if a == b == 1:
heapq.heappush(x, t)
elif a == 1:
heapq.heappush(y, t)
elif b == 1:
heapq.heappush(z, t)
lx, ly, lz = len(x), len(y), len(z)
u, v = len(x), min(len(y), len(z))
ans = 0
if u + v >= k:
i, j = 0, 0
for _ in range(k):
if i < u and j < v:
if x[0] <= y[0] + z[0]:
ans += heapq.heappop(x)
i += 1
else:
ans += (heapq.heappop(y) + heapq.heappop(z))
j += 1
elif i < u:
ans += heapq.heappop(x)
i += 1
elif j < v:
ans += (heapq.heappop(y) + heapq.heappop(z))
j += 1
else:
ans = -1
print(ans) | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T>
using vv = vector<vector<T>>;
template <class T>
inline bool MX(T &l, const T &r) {
return l < r ? l = r, 1 : 0;
}
template <class T>
inline bool MN(T &l, const T &r) {
return l > r ? l = r, 1 : 0;
}
const ll MOD = 1e9 + 7;
const int nn = 112345;
int bit[nn + 1];
int minf(int i) {
++i;
int s = MOD;
while (i > 0) {
s = min(s, bit[i]);
i -= i & -i;
}
return s;
}
void upd(int i, int val) {
++i;
while (i <= nn) {
bit[i] = min(bit[i], val);
i += i & -i;
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(0);
int xm, ym, zm, n, m, q;
cin >> xm >> ym >> zm >> n >> m >> q;
int x = xm, y = ym, z = zm, first = 0, second = 0, Z = 0;
for (int(_) = 0; (_) < (n); ++(_)) {
int a, b, c;
cin >> a >> b >> c;
MX(first, a);
MX(second, b);
MX(Z, c);
MN(x, a);
MN(y, b);
MN(z, c);
}
using TP = tuple<int, int, int, int>;
vector<TP> tps(m + q);
for (auto &tp : tps) cin >> get<0>(tp) >> get<1>(tp) >> get<2>(tp);
for (int(i) = 0; (i) < (m); ++(i)) get<3>(tps[i]) = -1;
for (int(i) = m; (i) < (m + q); ++(i)) get<3>(tps[i]) = i - m;
vector<int> re(q);
for (auto tp : tps) {
int a, b, c, i;
tie(a, b, c, i) = tp;
if (x <= a && a <= first && y <= b && b <= second && z <= c && c <= Z) {
if (i < 0) {
cout << "INCORRECT"
<< "\n";
exit(0);
} else {
re[i] = 1;
}
}
}
for (int(_) = 0; (_) < (2); ++(_)) {
for (int(_) = 0; (_) < (2); ++(_)) {
for (int(_) = 0; (_) < (2); ++(_)) {
sort((tps).begin(), (tps).end());
fill(bit, bit + nn + 1, MOD);
for (auto tp : tps) {
int a, b, c, i;
tie(a, b, c, i) = tp;
if (a < x) continue;
if (b < y) continue;
if (c < z) continue;
if (i < 0) {
upd(b, c);
} else if (re[i] == 0) {
if (minf(b) <= c) re[i] = 2;
}
};
for (auto &tp : tps) get<2>(tp) = zm + 1 - get<2>(tp);
tie(z, Z) = pii(zm + 1 - Z, zm + 1 - z);
}
for (auto &tp : tps) get<1>(tp) = ym + 1 - get<1>(tp);
tie(y, second) = pii(ym + 1 - second, ym + 1 - y);
}
for (auto &tp : tps) get<0>(tp) = xm + 1 - get<0>(tp);
tie(x, first) = pii(xm + 1 - first, xm + 1 - x);
};
cout << "CORRECT"
<< "\n";
vector<string> strs{"UNKNOWN", "OPEN", "CLOSED"};
for (int i : re) cout << strs[i] << "\n";
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int chk(int n, int m, int t, vector<tuple<int, int, int>> &Q, int k) {
vector<vector<int>> C(n + 1, vector<int>(m + 1, 0));
for (auto z : Q) {
int x, y, tx;
tie(x, y, tx) = z;
if (tx <= t) C[x][y] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
C[i][j] = C[i - 1][j] + C[i][j - 1] - C[i - 1][j - 1] + C[i][j];
if (i >= k && j >= k &&
C[i][j] - C[i][j - k] - C[i - k][j] + C[i - k][j - k] == k * k) {
return true;
}
}
}
return false;
}
int main() {
int n, m, k, q;
cin >> n >> m >> k >> q;
vector<tuple<int, int, int>> Q;
for (int i = 1; i <= q; i++) {
int x, y, t;
cin >> x >> y >> t;
Q.push_back(make_tuple(x, y, t));
}
int L = 0, R = 1000000000, ans = -1;
while (L <= R) {
int mid = (L + R) >> 1;
if (chk(n, m, mid, Q, k))
R = mid - 1, ans = mid;
else
L = mid + 1;
}
cout << ans << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s1,s2;
cin>>s1>>s2;
int mi=1000000000;
for(int i=0;i<=s1.size()-s2.size();i++){
int cnt=0;
for(int j=0;j<s2.size();j++){
if(s1[i+j]!=s2[j]){
cnt++;
}
}
mi=min(mi,(int)(cnt));
}
cout<<mi<<endl;
} | 0 | CPP |
#include<iostream>
#include<string>
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,n,d[123456];
cin>>n;
for(int i=0;i<n;i++)cin>>d[i];
sort(d,d+n);
a=d[n/2]-d[n/2-1];
cout<<a<<endl;
}
| 0 | CPP |
#include<iostream>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<vector>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<time.h>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
#define it vector<int>::iterator
const double PI=acos(-1);
const double EPS=1e-10;
const int inf=1e8;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
using namespace std;
int main(){
ll dp[10][1010]={0};
dp[0][0]=1;
rep(k,101)for(int i=8;i>=0;i--)rep(j,1010-k)
dp[i+1][j+k]+=dp[i][j];
int n,s;
while(cin>>n>>s,n+s){
cout<<dp[n][s]<<endl;
}
} | 0 | CPP |
#include <stdio.h>
int main(void)
{
int n=1,i=1;
while(scanf("%d",&n),n!=0){
printf("Case %d: %d\n",i++,n);
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d;
while(cin >> d){
int s = 0;
for(int i = 1; i < 600 / d; ++i){
s += pow(d * i, 2) * d;
}
cout << s << endl;
}
return 0;
} | 0 | CPP |
for _ in range(int(input())):
n = int(input())
a = list(input().strip())
res = 0
vis = [0]*n
out = [0]*n
from collections import defaultdict
gr = defaultdict(list)
cnt = 0
st = set()
for i in range(n):
if a[i]=="-":
st.add(i)
st.add((i+1)%n)
cnt+=1
vis[i] += 1
out[i] += 1
vis[(i+1)%n] += 1
out[(i+1)%n] += 1
res+=len(st)
cnt2 = cnt
for i in range(n):
if a[i]==">":
cnt+=1
vis[(i+1)%n] +=1
out[i]+=1
elif a[i]=="<":
cnt2 +=1
vis[i] += 1
out[(i+1)%n]+=1
# print(*vis)
# print(*out)
if cnt==n or cnt2==n:
res = n
# res = 0
# for i in range(n):
# res+= (vis[i]!=0) and (out[i]!=0)
print(res)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
double n, W, w[200001], somma = 0, a[200001];
int indice = 0;
bool ok = false;
cin >> n >> W;
for (int i = 0; i < n; i++) cin >> w[i];
for (int i = 0; i < n && !ok; i++) {
if ((w[i] >= ceil(W / 2)) && (w[i] <= W)) {
cout << 1 << endl << i + 1 << endl;
ok = true;
} else if (w[i] < ceil(W / 2)) {
somma += w[i];
a[indice] = i + 1;
indice++;
if (somma >= W / 2) {
cout << indice << endl;
for (int j = 0; j < indice; j++) cout << a[j] << " ";
cout << endl;
ok = true;
}
}
}
if (!ok) cout << -1 << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vii;
typedef vector<vi> vvi;
typedef vector<pll> vll;
typedef vector<vl> vvl;
#define fori(i, n) for (int i = 0; i < n; i++)
#define ford(i, n) for (int i = n - 1; i >= 0; i--)
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define repd(i, a, b) for (int i = a; i >= b; i--)
#define trav(x, a) for (auto &x : a)
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define eb emplace_back
#define endl '\n'
#define sz(a) (int)(a).size()
#define fi first
#define se second
clock_t time_p = clock();
void time_taken()
{
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
const ll mod = 1e9 + 7;
const ll INF = 1e18;
int main()
{
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int n;
cin >> n;
n = min(n, 5000);
vi a(n);
fori(i, n) cin >> a[i];
map<int, pii> m;
fori(i, n)
{
rep(j, i + 1, n - 1)
{
if (m.count(a[i] + a[j]))
{
auto pp = m[a[i] + a[j]];
if(pp.fi == i or pp.se == j or pp.se == i or pp.fi == j)
continue;
cout << "YES" << endl;
cout << pp.fi + 1 << " " << pp.se + 1 << " " << i + 1 << ' ' << j + 1 << endl;
return 0;
}
else{
m[a[i] + a[j]] = {i, j};
}
}
}
cout << "NO" << endl;
time_taken();
return 0;
} | 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct apple {
int v, nxt;
} edge[100011 * 4];
struct node {
int l, r, lson, rson, sum, len;
} tree[100011 * 30];
int indexx[100011], tt[100011], root[100011], f[100011], max_son[100011],
wgt[100011], fa[100011], top[100011], tot, siz, Root, deep[100011];
int sumx, ti, sum, ans, n, m;
void addedge(int x, int y) {
edge[++tot].v = y;
edge[tot].nxt = indexx[x];
indexx[x] = tot;
}
void push_up(int now) {
int l = tree[now].lson, r = tree[now].rson;
tree[now].sum = tree[l].sum + tree[r].sum;
}
void build(int l, int r, int &now) {
now = ++siz;
tree[now].l = l;
tree[now].r = r;
tree[now].len = (r - l + 1);
if (l == r) {
tree[now].sum = 0;
return;
}
int mid = (l + r) / 2;
build(l, mid, tree[now].lson);
build(mid + 1, r, tree[now].rson);
push_up(now);
}
void add(int &now, int k, int p, int x) {
now = ++siz;
tree[now] = tree[k];
if (tree[now].l == tree[now].r) {
tree[now].sum++;
return;
}
int mid = (tree[now].l + tree[now].r) / 2;
if (p <= mid)
add(tree[now].lson, tree[k].lson, p, x);
else
add(tree[now].rson, tree[k].rson, p, x);
push_up(now);
}
int query(int now, int k, int l, int r) {
if (l <= tree[now].l && tree[now].r <= r) {
return tree[now].len - (tree[now].sum - tree[k].sum);
}
int mid = (tree[now].l + tree[now].r) / 2, ret = 0;
if (l <= mid) ret += query(tree[now].lson, tree[k].lson, l, r);
if (r > mid) ret += query(tree[now].rson, tree[k].rson, l, r);
return ret;
}
void basic_dfs(int u, int dep) {
deep[u] = dep;
wgt[u] = 1;
int t = indexx[u], vv, maxx = 0;
while (t) {
vv = edge[t].v;
if (vv != fa[u]) {
basic_dfs(vv, dep + 1);
wgt[u] += wgt[vv];
if (wgt[vv] > maxx) {
max_son[u] = vv;
maxx = wgt[vv];
}
}
t = edge[t].nxt;
}
}
void build_dfs(int u, int anc) {
top[u] = anc;
tt[u] = ++ti;
f[ti] = u;
if (max_son[u]) {
build_dfs(max_son[u], anc);
}
int t = indexx[u], vv;
while (t) {
vv = edge[t].v;
if (vv != max_son[u]) build_dfs(vv, vv);
t = edge[t].nxt;
}
}
int bin(int head, int tail, int i, int k, int num) {
int s = tail, mid, ret;
while (head <= tail) {
mid = (head + tail) / 2;
if (query(root[i], root[k], mid, s) >= num) {
ret = mid;
head = mid + 1;
} else
tail = mid - 1;
}
return ret;
}
int solve1(int x, int y, int i, int k) {
int ret = 0, t;
t = query(root[i], root[k], tt[x], tt[x]);
sumx -= t;
ret -= t;
ret -= query(root[i], root[k], tt[y], tt[y]);
while (top[x] != top[y]) {
if (deep[top[x]] > deep[top[y]]) {
t = query(root[i], root[k], tt[top[x]], tt[x]);
ret += t;
sumx += t;
x = fa[top[x]];
} else {
ret += query(root[i], root[k], tt[top[y]], tt[y]);
y = fa[top[y]];
}
}
if (deep[x] >= deep[y]) {
t = query(root[i], root[k], tt[y], tt[x]);
ret += t;
sumx += t;
} else {
ret += query(root[i], root[k], tt[x], tt[y]);
}
return ret;
}
int solve2(int x, int num, int i, int k) {
int temp, ret;
num += query(root[i], root[k], tt[x], tt[x]);
while (x) {
temp = query(root[i], root[k], tt[top[x]], tt[x]);
if (num > temp) {
num -= temp;
x = fa[top[x]];
} else {
ret = bin(tt[top[x]], tt[x], i, k, num);
return f[ret];
}
}
return 0;
}
void Attack(int i) {
int x;
scanf("%d", &x);
add(root[i], root[i - 1], tt[x], 1);
}
void Travel(int i) {
int x, y, k, pre;
root[i] = root[i - 1];
scanf("%d%d%d%d", &x, &y, &k, &pre);
sumx = 0;
sum = solve1(x, y, i, pre);
if (sum < k) {
printf("-1\n");
return;
}
if (sumx >= k) {
ans = solve2(x, k, i, pre);
} else {
ans = solve2(y, sum - k + 1, i, pre);
}
printf("%d\n", ans);
}
int main() {
int op;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &fa[i]);
if (fa[i])
addedge(fa[i], i);
else
Root = i;
}
basic_dfs(Root, 1);
build_dfs(Root, Root);
build(1, n, root[0]);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &op);
if (op == 1) {
Attack(i);
} else {
Travel(i);
}
}
return 0;
}
| 11 | CPP |
from sys import stdin
n = int(stdin.readline())
s = (n * (n + 1)) // 2
print(s%2) | 7 | PYTHON3 |
t=int(input())
for _ in range(t):
n=int(input())
arr=list(map(int,input().split()))
sor=sorted(arr)
ch=0
last=-2
flag=0
for i in range(n):
if(arr[i]!=sor[i]):
if(last!=-2 and last!=i-1):
flag=1
last=i
ch+=1
if(ch==0):
print(0)
elif(ch==n or flag==0):
print(1)
else:
print(2)
| 9 | PYTHON3 |
// https://respect2d.hatenadiary.org/entry/20110209/1297332247
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <unordered_map>
#include <vector>
#include <string.h>
#include <set>
using namespace std;
#define COUT(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << endl
template<class T> void printvec(const vector<T>& v) {
for (auto x : v) { cout << x << " "; }
cout << endl;
}
template<class T> void printtree(const vector< vector<T> >& tree) {
for (long long i = 0; i < tree.size(); ++i) {
cout << i + 1 << ": "; printvec(tree[i]);
}
}
template<class T, class U> void printmap(const map<T, U>& mp) {
for (auto x : mp) { cout << x.first << "=>" << x.second << endl; }
}
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
#define rep(i, n) for(ll i = 0; i < n; ++i)
#define all(s) s.begin(), s.end()
#define sz(x) (ll)(x).size()
#define fr first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> triple;
typedef double D;
typedef vector<ll> vl;
typedef vector<P> vp;
const ll INF = 1e9;
const ll MOD = 1000000007; // 1e9 + 7
const ll MAX_X = 15;
const ll MAX_N = 100005;
#define MAX_X 15
#define MAX_N 100005
// dp[i][j] .. probability for using [0,i) and succeeds j times in a row.
double dp[MAX_N][MAX_X];
double per[MAX_X];
double ans[MAX_N];
int main(int argc, char** argv) {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(false);
cout << setprecision(10) << fixed;
rep(i,MAX_X) {
per[i] = pow(0.5,i);
}
dp[0][0] = 1.0;
double sum = 0;
rep(i,MAX_N) {
rep(j,MAX_X) {
if(dp[i][j] > 0) {
sum += dp[i][j] * per[j];
dp[i+1][0] += dp[i][j] * (1-per[j]); // lose
dp[i+1][j+1] += dp[i][j] * per[j]; // win
}
}
ans[i] = sum;
}
while (true) {
ll n;
cin >> n;
if (n == 0) { break; }
cout << ans[n-1] << endl;
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
set<int> st;
vector<priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > > >
taxis;
void add_taxi(int i, int j, long long t) {
if (taxis[i].empty()) st.insert(i);
taxis[i].push(pair<long long, int>(t, j));
}
int main() {
int N, M, Q;
cin >> N >> M >> Q;
priority_queue<long long, vector<long long>, greater<long long> > events;
map<long long, vector<pair<int, int> > > mp;
taxis.resize(N);
for (int j = 0; j < M; j++) {
int i;
scanf("%d", &i), i--;
add_taxi(i, j, 0);
}
vector<long long> t(Q);
vector<int> a(Q), b(Q);
for (int q = 0; q < Q; q++) {
scanf("%lld%d%d", &t[q], &a[q], &b[q]), a[q]--, b[q]--;
events.push(t[q]);
}
int q = 0;
while (!events.empty()) {
long long t0 = events.top();
events.pop();
for (pair<int, int> z : mp[t0]) add_taxi(z.first, z.second, t0);
mp[t0].clear();
for (; q < Q && t[q] <= t0 && !st.empty(); q++) {
int i0 = a[q];
vector<vector<long long> > v;
{
auto it = st.upper_bound(i0);
if (it != st.begin()) {
it--;
int i = *it;
pair<long long, int> z = taxis[i].top();
v.push_back({i0 - i, z.first, z.second, i});
}
}
{
auto it = st.lower_bound(i0);
if (it != st.end()) {
int i = *it;
pair<long long, int> z = taxis[i].top();
v.push_back({i - i0, z.first, z.second, i});
}
}
sort(v.begin(), v.end());
int i = v[0][3], j = v[0][2];
taxis[i].pop();
if (taxis[i].empty()) st.erase(i);
long long t1 = t0 + abs(i - a[q]) + abs(a[q] - b[q]);
events.push(t1);
mp[t1].push_back(pair<int, int>(b[q], j));
printf("%d %lld\n", j + 1, t0 + abs(i - a[q]) - t[q]);
}
}
}
| 19 | CPP |
n = int(input())
a = [int(x) for x in input().split()]
dollars = [0,0] # 25, 50
ans = "YES"
for i in range(n):
if a[i] == 25:
dollars[0]+=1
elif a[i] == 50:
if dollars[0] == 0:
ans="NO"
break
else:
dollars[0]-=1
dollars[1]+=1
else:
if (dollars[0] == 0 or dollars[1] == 0) and dollars[0]<3:
ans="NO"
break
else:
if dollars[1]>=1:
dollars[0]-=1
dollars[1]-=1
else:
dollars[0]-=3
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 20], *p1, *p2;
inline int _R() {
int d = 0;
bool ty = 1;
char t;
while (t = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin),
p1 == p2)
? 0
: *p1++),
(t < '0' || t > '9') && t != '-')
;
t == '-' ? (ty = 0) : (d = t - '0');
while (t = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin),
p1 == p2)
? 0
: *p1++),
t >= '0' && t <= '9')
d = (d << 3) + (d << 1) + t - '0';
return ty ? d : -d;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
long long n;
scanf("%lld", &n);
long long x = 0, y = 0;
int ans;
for (int i = 1; i <= 30; i++) {
y = y * 2 + 1;
x += y * (y + 1) / 2;
if (x <= n)
ans = i;
else
break;
}
printf("%d\n", ans);
}
}
| 8 | CPP |
t=int(input())
while t>0:
b=input()
n=len(b)
l=[]
for i in range(0,n,2):
l.append(b[i])
l.append(b[n-1])
new_s = "".join(l)
print(new_s)
t-=1
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 1;
const double pi = acos(-1);
int modif = 0;
void output(int i, int j) { cout << i + modif << ' ' << j + modif << '\n'; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
int n, d, h;
cin >> n >> d >> h;
if (d > 2 * h) {
cout << -1 << endl;
return 0;
}
if (d == 1 && h == 1 && n > 2) {
cout << -1 << endl;
return 0;
}
if (d == h) {
h -= 1;
modif = 1;
cout << 1 << ' ' << 2 << '\n';
}
for (int i = 1; i <= h; ++i) output(i, i + 1);
if (h + 2 + modif > n) {
return 0;
}
output(1, h + 2);
for (int i = h + 2; i <= d; ++i) output(i, i + 1);
for (int i = max(d + 2, h + 3) + modif; i <= n; ++i)
cout << 1 + modif << ' ' << i << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int l1, r1, l2, r2;
cin >> l1 >> r1 >> l2 >> r2;
if (l1 != l2) {
cout << l1 << " " << l2 << endl;
} else if (r1 != r2) {
cout << r1 << " " << r2 << endl;
} else {
cout << l1 << " " << l1 + 1 << endl;
}
}
return 0;
}
| 7 | CPP |
a,b=input().split();print('DH'[a==b]) | 0 | PYTHON3 |
k = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
sum = 0
for i in range(len(a) + 1):
if sum >= k:
print(i)
break
if i == len(a):
print(-1)
break
sum += a[i]
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct sabuild {
int i, val[2];
} temp[600010];
string t[100010];
queue<sabuild> Q[600010];
vector<int> S;
int ord[600010], sa[600010], lcp[600010], from[600010], len[600010];
int n, c[100010];
long long pre[600010];
void sortit(sabuild v[], int wh) {
int maxv = 0;
for (int i = 0; i < S.size(); ++i) {
Q[v[i].val[wh]].push(v[i]);
maxv = max(maxv, v[i].val[wh]);
}
int nr = 0;
for (int i = 0; i <= maxv; ++i) {
while (!Q[i].empty()) {
v[nr++] = Q[i].front();
Q[i].pop();
}
}
}
void radix_sort(sabuild v[]) {
sortit(v, 1);
sortit(v, 0);
}
void build_SA() {
for (int i = 0; i < S.size(); ++i) {
ord[i] = S[i];
}
for (int sz = 0; (1 << sz) <= S.size(); ++sz) {
for (int i = 0; i < S.size(); ++i) {
temp[i].val[0] = ord[i];
temp[i].val[1] = (i + (1 << sz) < S.size() ? ord[i + (1 << sz)] : 0);
temp[i].i = i;
}
radix_sort(temp);
int nr = 1;
for (int i = 0; i < S.size(); ++i) {
if (i != 0 && (temp[i].val[0] != temp[i - 1].val[0] ||
temp[i].val[1] != temp[i - 1].val[1]))
++nr;
ord[temp[i].i] = nr;
}
}
for (int i = 0; i < S.size(); ++i) sa[ord[i]] = i;
}
void build_LCP() {
int k = 0;
for (int i = 0; i < S.size(); ++i) {
if (ord[i] == S.size()) {
lcp[ord[i]] = 0;
continue;
}
for (int j = sa[ord[i] + 1];
i + k < S.size() && j + k < S.size() && S[i + k] == S[j + k]; ++k)
;
lcp[ord[i]] = k;
if (k) --k;
}
}
void solve() {
for (int i = 1; i <= S.size(); ++i) pre[i] = pre[i - 1] + c[from[sa[i]]];
stack<int> sval, sind;
sval.push(-1);
sind.push(0);
long long ans = 0;
for (int i = 1; i <= S.size(); ++i) {
while (len[sa[i]] == sval.top()) {
sval.pop();
sind.pop();
}
sval.push(len[sa[i]]);
sind.push(i);
while (lcp[i] <= sval.top()) {
int val = sval.top();
sval.pop();
sind.pop();
if (val != lcp[i]) ans = max(ans, 1LL * val * (pre[i] - pre[sind.top()]));
}
sval.push(lcp[i]);
sind.push(i);
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> t[i];
for (int i = 1; i <= n; ++i) cin >> c[i];
int chars = 26;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < t[i].length(); ++j) {
from[S.size()] = i;
len[S.size()] = t[i].length() - j;
S.push_back(t[i][j] - 'a' + 1);
}
from[S.size()] = 0;
len[S.size()] = 1;
S.push_back(++chars);
}
build_SA();
build_LCP();
solve();
}
| 12 | CPP |
for _ in range(int(input())):
a,b,n,s=map(int,input().split())
if n*a+b>=s and s%n<=b:
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long t, id, n, m, x, y, k, c, p, dif, ans, sum, pre, rem, cur, tmp, tot, r,
l, u, d, xx, yy;
long long a[N], vis[N], f[N], b[N], cu[N];
vector<int> v, adj[N];
bool fl, ok;
long long calc(long long pos) {
long long sit = 1, siz = 1, od = 0, ev = 0, rem = pos;
while (rem > 0) {
if (sit & 1) {
od += min(siz, rem);
od %= 1000000007;
} else {
ev += min(siz, rem);
ev %= 1000000007;
}
rem -= siz;
++sit;
siz <<= 1;
}
long long ret = ev * (ev + 1);
ret %= 1000000007;
ret += od * od;
ret %= 1000000007;
return ret;
}
int main() {
scanf("%lld%lld", &l, &r);
ans = calc(r) - calc(l - 1) + 1000000007;
printf("%lld\n", ans % 1000000007);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long long> graph[100002];
vector<long long> respect(100002);
set<long long> s;
vector<bool> vis(100002, false);
void dfs(long long p) {
long long val = respect[p];
vis[p] = true;
for (auto it : graph[p]) {
if (vis[it]) continue;
val *= respect[it];
dfs(it);
}
if (val) s.insert(p);
}
void solve() {
long long n, k;
cin >> n >> k;
map<long long, long long> cnt;
vector<pair<long long, pair<long long, long long>>> v;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
v.push_back(make_pair(x, make_pair(i, -1)));
cnt[x]++;
if (cnt[x] > k) {
cout << "NO"
<< "\n";
return;
}
}
sort(v.begin(), v.end(),
[](pair<long long, pair<long long, long long>> &x,
pair<long long, pair<long long, long long>> &y) {
return x.first < y.first;
});
for (long long i = 0, temp = 1; i < v.size(); i++) {
v[i].second.second = temp;
temp++;
if (temp > k) temp = 1;
}
sort(v.begin(), v.end(),
[](pair<long long, pair<long long, long long>> &x,
pair<long long, pair<long long, long long>> &y) {
return x.second.first < y.second.first;
});
cout << "YES"
<< "\n";
for (auto i : v) {
cout << i.second.second << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
;
int kse = 1;
while (kse--) {
solve();
}
}
| 8 | CPP |
t = int(input())
in_data = []
endings = {"po": "FILIPINO", "desu": "JAPANESE", "masu": "JAPANESE", "mnida": "KOREAN"}
for _ in range(t):
in_data.append(input())
for s in in_data:
for ending, lang in endings.items():
if s.endswith(ending):
print(lang)
break | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char str1[1002], str2[1002];
int l1, l2, sum1, sum2;
int main() {
int i;
scanf("%s%s", str1, str2);
l1 = strlen(str1);
l2 = strlen(str2);
for (i = 0; i < l1; i++) {
if (str1[i] == '1') sum1++;
}
for (i = 0; i < l2; i++) {
if (str2[i] == '1') sum2++;
}
if (sum1 % 2) sum1++;
if (sum1 >= sum2)
puts("YES");
else
puts("NO");
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void in(T &x) {
x = 0;
bool f = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while ('0' <= c && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
if (f) x = -x;
}
int v[2005 * 2005], nx[2005 * 2005];
int head[2005], cnte;
inline void adde(int uu, int vv) {
v[++cnte] = vv, nx[cnte] = head[uu];
head[uu] = cnte;
}
char tc[2005];
int tot;
int q[2005], hd, tl;
int d[2005];
bool vis[2005];
int n, m;
signed main() {
in(n), in(m);
tot = n + m;
for (register int i = 1; i <= n; ++i) {
scanf("%s", tc + 1);
for (register int j = 1; j <= m; ++j)
if (tc[j] == '#') {
adde(i, n + j);
adde(n + j, i);
}
}
memset(d, -1, sizeof d);
q[hd = tl = 1] = n;
d[n] = 0;
while (hd <= tl) {
int x = q[hd++];
for (register int i = head[x]; i; i = nx[i])
if (!vis[v[i]]) {
vis[v[i]] = 1;
d[v[i]] = d[x] + 1;
q[++tl] = v[i];
}
}
printf("%d", d[1]);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool setmax(T &_a, T _b) {
if (_b > _a) {
_a = _b;
return true;
}
return false;
}
template <class T>
bool setmin(T &_a, T _b) {
if (_b < _a) {
_a = _b;
return true;
}
return false;
}
template <class T>
T gcd(T _a, T _b) {
return _b == 0 ? _a : gcd(_b, _a % _b);
}
template <class T>
class SegmentTree {
std::vector<T> tr;
int n;
int v0;
void release(int x) {
if (tr[x] != v0) {
tr[x * 2] = tr[x * 2 + 1] = tr[x];
tr[x] = v0;
}
}
void _paint(int x, int s, int t, int st, int en, int val) {
if (st <= s && t <= en) {
tr[x] = val;
return;
}
release(x);
int mid = (s + t) / 2;
if (st <= mid) _paint(x * 2, s, mid, st, en, val);
if (mid < en) _paint(x * 2 + 1, mid + 1, t, st, en, val);
}
T _get(int x, int s, int t, int ind) {
if (s == t || tr[x] != v0) return tr[x];
release(x);
int mid = (s + t) / 2;
if (ind <= mid)
return _get(x * 2, s, mid, ind);
else
return _get(x * 2 + 1, mid + 1, t, ind);
}
public:
SegmentTree() {}
SegmentTree(int _n, T _v) : tr(size_t(_n + 1) * 4, _v), n(_n), v0(_v) {}
void paint(int l, int r, T v) { _paint(1, 1, n, l, r, v); }
T get(int x) { return _get(1, 1, n, x); }
};
template <class T>
class FenwickTree {
std::vector<T> a;
int n;
T v0;
public:
FenwickTree() {}
FenwickTree(int _n, T _v) : a(size_t(_n + 1), _v), n(_n), v0(_v) {}
void add(int x, T v) {
for (; x <= n; x += (x & -x)) a[(size_t)x] += v;
}
T get(int x) const {
T r = v0;
for (; x >= 1; x -= (x & -x)) r += a[(size_t)x];
return r;
}
};
const int MAXN = 500050;
char op[MAXN];
int ox[MAXN], oy[MAXN];
int n, m;
int ind[MAXN], pos[MAXN], l[MAXN], r[MAXN];
int last_clear[MAXN];
vector<int> to_clear[MAXN];
long long ans[MAXN];
void pre(int c1, int c2) {
vector<bool> here(n + 1, true);
vector<vector<int> > sons(n + 1);
for (int k = int(1); k <= int(m); ++k)
if (op[k] == c1) {
sons[ox[k]].push_back(oy[k]);
here[oy[k]] = false;
}
int cnt = 0;
function<void(int)> dfs = [&cnt, &dfs, &sons](int x) -> void {
++cnt;
ind[cnt] = x, pos[x] = cnt;
for (int y : sons[x]) dfs(y);
};
for (int i = int(1); i <= int(n); ++i)
if (here[i]) dfs(i);
static pair<int, int> p[MAXN];
for (int i = int(1); i <= int(n); ++i) p[i] = make_pair(pos[i], pos[i]);
for (int k = int(1); k <= int(m); ++k) {
auto merge = [](pair<int, int> a, pair<int, int> b) {
return make_pair(min(a.first, b.first), max(a.second, b.second));
};
if (op[k] == c1) {
p[ox[k]] = merge(p[ox[k]], p[oy[k]]);
}
if (op[k] == c2) {
l[k] = p[ox[k]].first;
r[k] = p[ox[k]].second;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = int(1); i <= int(m); ++i) {
scanf("%s", op + i);
scanf("%d", &ox[i]);
if (op[i] == 'U' || op[i] == 'M') scanf("%d", &oy[i]);
}
pre('M', 'Z');
memset(last_clear, 0, sizeof(last_clear));
SegmentTree<int> tmax(n, 0);
for (int k = int(1); k <= int(m); ++k) {
if (op[k] == 'Z') {
tmax.paint(l[k], r[k], k);
}
if (op[k] == 'Q') last_clear[k] = tmax.get(pos[ox[k]]);
}
for (int k = int(0); k <= int(m); ++k) to_clear[k].clear();
for (int k = int(1); k <= int(m); ++k) to_clear[last_clear[k]].push_back(k);
pre('U', 'A');
FenwickTree<long long> tsum(n, 0);
for (int k = int(1); k <= int(m); ++k) {
if (op[k] == 'A') {
int v = r[k] - l[k] + 1;
tsum.add(l[k], v);
tsum.add(r[k] + 1, -v);
}
if (op[k] == 'Q') {
ans[k] += tsum.get(pos[ox[k]]);
}
for (int k2 : to_clear[k]) ans[k2] -= tsum.get(pos[ox[k2]]);
}
for (int k = int(1); k <= int(m); ++k)
if (op[k] == 'Q') printf("%lld\n", ans[k]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int N = 100100;
const int M = N * 20;
int cnt[M], ls[M], rs[M], tot = 0;
int build(int l, int r) {
int x = tot++;
cnt[x] = 0;
if (l != r) {
int m = l + r >> 1;
ls[x] = build(l, m);
rs[x] = build(m + 1, r);
}
return x;
}
int add(int o, int p, int l, int r) {
int x = tot++;
cnt[x] = cnt[o];
if (l == r) {
cnt[x]++;
return x;
}
int m = l + r >> 1;
if (p <= m) {
ls[x] = add(ls[o], p, l, m);
rs[x] = rs[o];
} else {
ls[x] = ls[o];
rs[x] = add(rs[o], p, m + 1, r);
}
cnt[x] = cnt[ls[x]] + cnt[rs[x]];
return x;
}
int query(int o, int p, int l, int r) {
if (l == p) return cnt[o];
int md = l + r >> 1;
if (p <= md)
return query(ls[o], p, l, md) + cnt[rs[o]];
else
return query(rs[o], p, md + 1, r);
}
int a[N], p[N], nxt[N], now[N], num[N], tr[N];
int main() {
int n, k;
scanf("%d %d", &n, &k);
build(1, n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
if (!now[a[i]]) now[a[i]] = i;
nxt[p[a[i]]] = i;
p[a[i]] = i;
if (num[a[i]]++ > k) now[a[i]] = nxt[now[a[i]]];
tr[i] = num[a[i]] > k ? add(tr[i - 1], now[a[i]], 1, n) : tr[i - 1];
}
int q, ans = 0;
scanf("%d", &q);
while (q--) {
int x, y;
scanf("%d %d", &x, &y);
x = (x + ans) % n + 1;
y = (y + ans) % n + 1;
if (x > y) swap(x, y);
ans = y - x + 1 - query(tr[y], x, 1, n);
printf("%d\n", ans);
}
}
| 11 | CPP |
# -*- coding: utf-8 -*-
"""
Created on Sat Jun 8 09:46:36 2019
@author: avina
"""
s = input()
r = 'HQ9'
t = False
for i in s:
if i in r:
t = True
break
if t:
print('YES')
else:
print('NO')
| 7 | PYTHON3 |
for u in range(int(input())):
a,b,x,y=map(int,input().split())
if(x>=a-x-1):
n=x
else:
n=a-x-1
if(y>=b-y-1):
m=y
else:
m=b-y-1
s1=n*b
s2=m*a
print(max(s1,s2))
| 7 | PYTHON3 |
'''input
4 3
'''
import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
mod=10**9+7
n,k=[int(i) for i in input().split()]
ans=k//n
if k%n!=0:
print(ans+1)
else:
print(ans)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int second[100010 * 4];
int first[100010 * 4];
int arr[100010];
int n;
void update(int x, int val, int c = 1, int b = 1, int e = n) {
if (b == e) {
if (val > 0) {
first[c] = 1;
second[c] = 0;
} else {
first[c] = 0;
second[c] = 1;
}
return;
}
int m = (b + e) >> 1;
int l = c << 1;
int r = l + 1;
if (x <= m)
update(x, val, l, b, m);
else
update(x, val, r, m + 1, e);
int rel = first[l] - second[r];
second[c] = second[l];
first[c] = first[r];
if (rel < 0)
second[c] += -rel;
else
first[c] += rel;
}
int get(int c = 1, int b = 1, int e = n, int carry = 0) {
if (first[c] - carry <= 0) return -1;
if (b == e) {
return arr[b];
}
int m = (b + e) >> 1;
int l = c << 1;
int r = l + 1;
if (first[r] - carry > 0)
return get(r, m + 1, e, carry);
else
return get(l, b, m, carry - first[r] + second[r]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int p, t;
scanf("%d %d", &p, &t);
if (t == 1) {
scanf("%d", arr + p);
update(p, 1);
} else {
update(p, -1);
}
printf("%d\n", get());
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
int main() {
ll su = 0;
ll n;
cin >> n;
ll ar[n];
for (ll i = 0; i < n; i++) {
cin >> ar[i];
su += ar[i];
}
ll c1 = 0, c2 = 0, cx = 0;
sort(ar, ar + n);
ll fl = 1;
for (ll i = 0; i < n - 1; i++) {
if (ar[i] == ar[i + 1]) {
if (c1 == 0 && i && ar[i - 1] < ar[i] - 1) {
c1 = 1;
ar[i]--;
} else if (c1 == 0 && i == 0 && ar[0]) {
c1 = 1;
ar[0]--;
} else {
fl = 0;
break;
}
}
}
if (!fl || !su) {
cout << "cslnb\n";
return 0;
}
ll xx = (n * (n - 1)) / 2;
if ((su - xx) & 1) {
cout << "sjfnb\n";
} else {
cout << "cslnb\n";
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int maxn = 3e5 + 50;
const int mod = 1e9 + 7;
int a[maxn];
long long pre[maxn], lg[maxn << 2];
long long la[maxn << 2], lb[maxn << 2];
void build(int rt, int l, int r) {
if (l == r)
lg[rt] = a[l];
else {
int mid = (l + r) >> 1;
build((rt << 1), l, mid);
build((rt << 1 | 1), mid + 1, r);
lg[rt] = lg[(rt << 1)] + lg[(rt << 1 | 1)];
}
}
inline void down(int rt) {
lb[(rt << 1)] += lb[rt];
lb[(rt << 1 | 1)] += lb[rt];
la[(rt << 1)] += la[rt];
la[(rt << 1 | 1)] += la[rt] + lg[(rt << 1)] * lb[rt];
la[rt] = lb[rt] = 0;
}
inline void update(int rt, int l, int r, int L, int R, long long b, int s) {
if (L <= l and r <= R) {
la[rt] += b;
lb[rt] += s;
} else {
if (la[rt] or lb[rt]) down(rt);
int mid = (l + r) >> 1;
if (L <= mid and R > mid) {
update((rt << 1), l, mid, L, mid, b, s);
update((rt << 1 | 1), mid + 1, r, mid + 1, R,
b + (pre[(mid)] - pre[(L - 1)]) * s, s);
} else if (L <= mid) {
update((rt << 1), l, mid, L, R, b, s);
} else {
update((rt << 1 | 1), mid + 1, r, L, R, b, s);
}
}
}
inline long long query(int rt, int l, int r, int pos) {
if (l == r)
return la[rt];
else {
if (la[rt] or lb[rt]) down(rt);
int mid = (l + r) >> 1;
if (pos <= mid) return query((rt << 1), l, mid, pos);
return query((rt << 1 | 1), mid + 1, r, pos);
}
}
int od[maxn], b[maxn], s[maxn];
deque<int> qu;
int le[maxn], ri[maxn];
inline int fl(int k) { return le[k] ? le[k] = fl(le[k]) : k; }
inline int fr(int k) { return ri[k] ? ri[k] = fr(ri[k]) : k; }
set<pair<long long, int> > use;
long long add;
pair<long long, int> my[maxn];
inline void check_merge(int r, int s, int cc) {
if (use.empty()) {
add -= s;
return;
}
while (!use.empty()) {
pair<long long, int> f = *use.begin();
if (f.first + add > s) break;
use.erase(use.begin());
int pos = f.second;
le[pos] = pos - 1;
ri[pos - 1] = pos;
int g = fr(pos);
if (g != r) {
++g;
use.erase(my[g]);
int an = fl(g - 1);
long long a = query(1, 1, cc, an), b = query(1, 1, cc, g),
len = (pre[(g - 1)] - pre[(an - 1)]);
my[g].first = (a - b + len - 1) / len - add;
use.insert(my[g]);
}
}
add -= s;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
qu.push_back(n);
int pos = 1;
for (int i = 1; i <= m; ++i) {
cin >> od[i];
if (od[i] == 1) {
int len;
cin >> len;
qu.push_front(len);
++pos;
} else if (od[i] == 2) {
int len;
cin >> len;
qu.push_back(len);
} else {
cin >> b[i] >> s[i];
}
}
int cc = 0;
for (int i = 1; !qu.empty(); ++i) {
a[i] = qu.front();
qu.pop_front();
cc = i;
}
for (int i = 1; i <= cc; ++i) pre[i] = pre[i - 1] + a[i];
build(1, 1, cc);
int ul = pos, ur = pos;
for (int i = 1; i <= m; ++i) {
if (od[i] == 1) {
le[ul] = ul - 1;
ri[ul - 1] = ul;
--ul;
for (auto it = use.begin(); it != use.end(); ++it) {
int pos = it->second;
le[pos] = pos - 1;
ri[pos - 1] = pos;
}
use.clear();
} else if (od[i] == 2) {
++ur;
my[ur].second = ur;
long long val = query(1, 1, cc, fl(ur - 1));
if (val == 0) {
le[ur] = ur - 1;
ri[ur - 1] = ur;
} else {
int r = ur;
int an = fl(r - 1);
long long a = query(1, 1, cc, an), b = query(1, 1, cc, r),
len = (pre[(r - 1)] - pre[(an - 1)]);
my[r].first = (a - b + len - 1) / len - add;
use.insert(my[r]);
}
} else {
check_merge(ur, s[i], cc);
update(1, 1, cc, ul, ur, b[i], s[i]);
}
int p = fl(ur);
cout << (pre[(p - 1)] - pre[(ul - 1)]) + 1 << " " << query(1, 1, cc, p)
<< "\n";
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[101], s = 0, k = 0;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], s += a[i];
for (int i = 1; i <= n; i++)
if ((s - a[i]) % 2 == 0) k++;
cout << k;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k, m, t;
cin >> n >> k >> m >> t;
int d = n, p = k;
for (int i = 0; i < t; i++) {
int type, pos;
cin >> type >> pos;
if (type) {
d++;
if (pos <= p) {
p++;
}
} else {
if (pos < p) {
d -= pos;
p -= pos;
} else
d = pos;
}
cout << d << ' ' << p << '\n';
}
}
| 10 | CPP |
n = int(input())
a = n
a = list(map(int, input().split()))
c = 0
for i in a:
if i - c <= 15:
c = i
if a[0] - 0 > 15:
print(15)
elif 90 - c >= 15:
print(c + 15)
elif 90 - c < 15:
print(90) | 7 | PYTHON3 |
n = int(input())
l = list(map(int, input().split(" ")))
for i in range(n):
if i == 0:
print(str(l[1]-l[0]) + " " + str(l[n-1]-l[0]))
elif i == n-1:
print(str(l[n-1]-l[n-2]) + " " + str(l[n-1]-l[0]))
else:
print(str(min(l[i]-l[i-1], l[i+1] - l[i])) + " " + str(max(l[i]-l[0], l[n-1]-l[i])))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int dp[5 * 1000007], fr[30];
int tot, n, m;
bool on(int mask, int x) { return (mask & (1 << x)) == (1 << x); }
bool in(int mask, int x) { return (mask & fr[x]) == fr[x]; }
int go(int mask) {
if (mask == tot) return 0;
int &ret = dp[mask];
if (ret != -1) return ret;
ret = 0x3f3f3f3f;
for (int i = 0; i < n; i++) {
if (on(mask, i) and !in(mask, i)) {
ret = min(ret, go(mask | fr[i]) + 1);
}
}
return ret;
}
void print(int mask) {
if (mask == tot) return;
int guy, ret = 0x3f3f3f3f;
for (int i = 0; i < n; i++) {
if (on(mask, i) and !in(mask, i)) {
if (ret > go(mask | fr[i]) + 1) {
ret = go(mask | fr[i]) + 1;
guy = i;
}
}
}
cout << guy + 1 << " ";
print(mask | fr[guy]);
}
int main(int argc, char const *argv[]) {
memset(dp, -1, sizeof dp);
cin >> n >> m;
tot = (1 << n) - 1;
if (m == n * (n - 1) / 2) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
fr[a] += (1 << b);
fr[b] += (1 << a);
}
int ans = 0x3f3f3f3f, st;
for (int i = 0; i < n; i++) {
if (ans > go(1 << i)) {
ans = go(1 << i);
st = i;
}
}
cout << ans << endl;
print(1 << st);
return 0;
}
| 11 | CPP |
import sys
import math
#import random
#sys.setrecursionlimit(100000000)
input = sys.stdin.readline
############ ---- USER DEFINED INPUT FUNCTIONS ---- ############
def inp():
return(int(input()))
def inara():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
################################################################
############ ---- THE ACTUAL CODE STARTS BELOW ---- ############
n,k=invr()
div=[]
limit=int(math.sqrt(n+1))
for i in range(1,limit+1):
if n%i==0:
div.append(i)
if i*i!=n:
div.append(n//i)
div.sort()
if len(div)<k:
print(-1)
else:
print(div[k-1])
| 7 | PYTHON3 |
#include <bits/stdc++.h>
static long long gcd(long long x, long long y) {
return y == 0 ? x : gcd(y, x % y);
}
static long long pwm(long long x, long long n, long long m) {
long long r = 1;
while (n) {
if (n & 1) r = r * x % m;
x = x * x % m;
n >>= 1;
}
return r;
}
struct vertex {
char type;
int in[2];
bool val;
bool change;
};
std::vector<vertex> g;
int n;
int dfs1(int v) {
switch (g[v].type) {
case 'A':
g[v].val = (dfs1(g[v].in[0]) & dfs1(g[v].in[1]));
break;
case 'O':
g[v].val = (dfs1(g[v].in[0]) | dfs1(g[v].in[1]));
break;
case 'X':
g[v].val = (dfs1(g[v].in[0]) ^ dfs1(g[v].in[1]));
break;
case 'N':
g[v].val = (!dfs1(g[v].in[0]));
break;
}
return g[v].val;
}
void dfs2(int v) {
if (g[v].change == false) {
g[g[v].in[0]].change = false;
g[g[v].in[1]].change = false;
} else {
switch (g[v].type) {
case 'A':
g[g[v].in[0]].change =
g[v].val != (!g[g[v].in[0]].val & g[g[v].in[1]].val);
g[g[v].in[1]].change =
g[v].val != (g[g[v].in[0]].val & !g[g[v].in[1]].val);
break;
case 'O':
g[g[v].in[0]].change =
g[v].val != (!g[g[v].in[0]].val | g[g[v].in[1]].val);
g[g[v].in[1]].change =
g[v].val != (g[g[v].in[0]].val | !g[g[v].in[1]].val);
break;
case 'X':
g[g[v].in[0]].change =
g[v].val != (!g[g[v].in[0]].val ^ g[g[v].in[1]].val);
g[g[v].in[1]].change =
g[v].val != (g[g[v].in[0]].val ^ !g[g[v].in[1]].val);
break;
case 'N':
g[g[v].in[0]].change = g[v].val != (!!g[g[v].in[0]].val);
break;
case 'I':
break;
}
}
switch (g[v].type) {
case 'A':
case 'O':
case 'X':
dfs2(g[v].in[0]);
dfs2(g[v].in[1]);
break;
case 'N':
dfs2(g[v].in[0]);
break;
}
}
int readInt() {
int x = 0, c = 0;
c = getchar();
while (!(c >= '0' && c <= '9')) c = getchar();
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x;
}
int readType() {
int c = getchar();
while (c <= 32) c = getchar();
int type = c;
while (c > 32) c = getchar();
return type;
}
int solve() {
int x, y;
n = readInt();
g.resize(n + 1);
for (int i = 1; i <= n; ++i) {
g[i].type = readType();
switch (g[i].type) {
case 'A':
case 'O':
case 'X':
g[i].in[0] = readInt();
g[i].in[1] = readInt();
break;
case 'N':
g[i].in[0] = readInt();
break;
case 'I':
g[i].val = readInt();
break;
}
}
dfs1(1);
g[1].change = true;
dfs2(1);
char* ans = (char*)malloc(n + 2);
int j = 0;
for (int i = 1; i <= n; ++i) {
if (g[i].type == 'I') {
ans[j++] = '0' + (g[i].change ^ g[1].val);
}
}
ans[j] = '\0';
puts(ans);
free(ans);
return 0;
}
int main(int argc, char* argv[]) {
::std::ios::sync_with_stdio(false);
::std::cin.tie(0);
::std::cout.tie(0);
int t = 1;
while (t--) solve();
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int P[310][310];
int C[310];
void solve() {
int i, j, l, ok, sol = 0;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
ok = 1;
sol = P[i][j];
for (l = 1; P[i][j] != P[n + 1][l]; l++) {
if (P[n + 1][l] != i && P[n + 1][l] < P[i][j]) {
ok = 0;
break;
}
}
if (i != P[i][j] && ok) {
printf("%d ", sol);
break;
}
}
}
printf("\n");
}
void citire() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n + 1; i++)
for (j = 1; j <= n; j++) scanf("%d", &P[i][j]);
}
int main() {
citire();
solve();
return 0;
}
| 8 | CPP |
s = input()
t = input()
if s[-1]!=t[-1]:
ans = len(s)+len(t)
else:
same = 0
for i in range(-1,-(min(len(s),len(t))+1),-1):
if s[i] == t[i]:
same += 1
else:
break
ans = len(s)+len(t)-2*same
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, -1, 0, 1, -1, 0, 1};
int kx8[] = {1, 1, 2, 2, -1, -1, -2, -2};
int ky8[] = {2, -2, 1, -1, 2, -2, 1, -1};
int sum[1005];
vector<pair<long long, long long> > b;
vector<int> a[1005];
int v[1005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < (m); i++) {
int typ, l, r;
cin >> typ >> l >> r;
if (typ == 1) {
a[l].push_back(r + 1);
} else
b.push_back({l, r});
}
int cnt = 1e5, pre = 0;
for (int i = 1; i <= n; i++) {
sum[i] += sum[i - 1];
if (!sum[i]) {
cnt--;
pre = cnt;
}
v[i] = pre;
for (auto x : a[i]) {
sum[i]++;
sum[x]--;
}
}
for (auto x : b) {
int pre = 0;
bool flg = 0;
for (int i = x.first; i <= x.second; i++) {
if (v[i] >= pre)
;
else {
flg = 1;
break;
}
pre = v[i];
}
if (!flg) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
for (int i = 0; i < (n); i++) cout << v[i + 1] << " ";
cout << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long be(long long x, long long n) {
long long ret = 1;
while (n > 0) {
if (n % 2 == 1) ret = ret * x;
x = x * x;
n /= 2;
}
return ret;
}
signed main() {
long long t;
cin >> t;
while (t--) {
long long n, i;
cin >> n;
long long m = n;
long long ind = -1;
vector<long long> a;
while (n > 0) {
a.push_back(n % 3);
n /= 3;
}
a.push_back(0);
for (i = 0; i < a.size(); i++) {
if (a[i] == 2) {
ind = i;
}
}
if (ind == -1) {
cout << m << "\n";
continue;
}
for (i = 0; i < ind; i++) a[i] = 0;
long long fl = 1;
for (i = ind + 1; i < a.size(); i++) {
if (a[i] != 0)
a[i] = 0;
else {
a[i] = 1;
break;
}
}
long long sum = 0;
for (i = 0; i < a.size(); i++) {
if (a[i] == 1) sum += (be(3, i));
}
cout << sum << "\n";
}
return 0;
}
| 9 | CPP |
t=int(input())
for tt in range(t):
n=int(input())
if((n//2)%2==1):
print("NO")
else:
print("YES")
ans=[]
bns=[]
for i in range(2,n+1,2):
ans.append(i)
if(i<=n//2):
bns.append(i-1)
else:
bns.append(i+1)
for j in bns:
ans.append(j)
for i in ans:
print(i,end=' ')
print()
| 8 | PYTHON3 |
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstdio>
#include <vector>
#include <string>
#include <array>
#include <queue>
#include <deque>
#include <set>
#include <list>
#include <map>
#include <stack>
#include <utility>
#include <algorithm>
#include <numeric>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <cstring>
#include <climits>
#include <bitset>
#include <random>
#include <functional>
#include <sstream>
#include <iomanip>
using namespace std;
#define rep(i, n) for(int i=0; i<(n); i++)
#define FOR(i, m, n) for(int i=(m);i<(n);i++)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define SORT(x) sort((x).begin(),(x).end())
#define REVE(x) reverse((x).begin(),(x).end())
#define mp make_pair
#define pb push_back
#define F first
#define S second
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<vector<int>> VVI;
typedef pair<int, int> PII;
typedef long long LL;
int main() {
int n, q;
cin >> n;
VI a(n); rep(i, n)cin >> a[i];
cin >> q;
rep(i, q) {
int b, e;
cin >> b >> e;
reverse(a.begin() + b, a.begin() + e);
}
rep(i, sz(a)) {
cout << a[i];
printf(i == sz(a) - 1 ? "\n" : " ");
}
}
| 0 | CPP |
n = int(input())
ans = 0
p = 0
for i in range(n):
a, b = map(int, input().split())
p = p - a + b
ans = max(ans, p)
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
double p[100005];
double e[100005];
int main() {
int n;
cin >> n;
double m = 0;
for (int i = 0; i < n; i++) {
cin >> p[i];
if (i == 0)
e[0] = p[0];
else
e[i] = p[i] * (e[i - 1] + 1);
m += (2 * e[i - 1] + 1) * p[i];
}
printf("%.10lf\n", m);
return 0;
}
| 10 | CPP |
/* -*- coding: utf-8 -*-
*
* 2927.cc: Presents
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
using namespace std;
/* constant */
const int MAX_N = 100000;
const int MAX_k = 17;
/* typedef */
typedef long long ll;
/* global variables */
ll dp[2][MAX_N + 1];
/* subroutines */
/* main */
int main() {
int n, k;
scanf("%d%d", &n, &k);
if ((n >> (k - 1)) == 0) {
puts("0");
return 0;
}
fill(dp[0] + 1, dp[0] + n + 1, 1);
int cur = 0, nxt = 1;
for (int i = 1; i < k; i++) {
memset(dp[nxt], 0, sizeof(dp[nxt]));
int minj0 = 1 << (i - 1), maxj0 = n >> (k - i);
int maxj1 = n >> (k - i - 1);
for (int j = minj0; j <= maxj0; j++)
for (int x = 2; j * x <= maxj1; x++)
dp[nxt][j * x] += dp[cur][j];
cur ^= 1, nxt ^= 1;
}
//for (int i = 1; i <= n; i++) printf("%lld ", dp[cur][i]); putchar('\n');
ll sum = 0;
for (int i = 1; i <= n; i++) sum += dp[cur][i];
printf("%lld\n", sum);
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, A = 2e5 + 5;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
q;
vector<vector<int>> v, v_rev;
int level[A], path[A];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, m, p;
cin >> n >> m;
v.resize(n + 1);
v_rev.resize(n + 1);
for (int i = 0; i <= n; i++) level[i] = 2e9;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v_rev[y].push_back(x);
}
cin >> p;
for (int i = 0; i < p; i++) cin >> path[i];
level[path[p - 1]] = 0;
q.push({0, path[p - 1]});
while (!q.empty()) {
int lvl = q.top().first;
int node = q.top().second;
q.pop();
if (level[node] != lvl) continue;
for (auto to : v_rev[node]) {
if (level[to] > lvl + 1) {
level[to] = lvl + 1;
q.push({lvl + 1, to});
}
}
}
int mx = 0, mn = 0;
for (int i = 0; i < p - 1; i++) {
int cnt = 0;
for (auto to : v[path[i]]) {
if (level[path[i]] == level[to] + 1) cnt++;
}
if (level[path[i]] <= level[path[i + 1]])
mn++, mx++;
else if (cnt > 1)
mx++;
}
cout << mn << ' ' << mx;
return 0;
}
| 10 | CPP |
N=input().split()
S=input().split()
k=int(N[1])
t=0
for i in S:
if int(i)>0 and int(i)>=int(S[k-1]):
t+=1
print(t)
| 7 | PYTHON3 |
#include<stdio.h>
long long h,ans=0,p=1;
int main(void)
{
scanf("%lld",&h);
while(h!=0){
ans+=p;
h/=2;
p*=2;
}
printf("%lld\n",ans);
return 0;
} | 0 | CPP |
n=int(input())
a=[int(x) for x in input().split()]
b=[int(x) for x in input().split()]
c=set()
c.update(a[1:])
c.update(b[1:])
if c=={int(x) for x in range(1,n+1)}:
print("I become the guy.")
else:
print("Oh, my keyboard!")
| 7 | PYTHON3 |
#include<iostream>
#include<string>
#include<vector>
#include<utility>
#include<queue>
#include<algorithm>
#include<cmath>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<complex>
#define INF 2147483647
#define llINF 9223372036854775807
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define ll long long
using namespace std;
int main(){
int a,b,c,d,e,f;
while(cin>>a>>b>>c>>d>>e>>f,a+b+c+d+e+f){
ll ans=100;
ans-=(f-(e+a*5+b*3))*3;
ans-=(a*5+b*3)*2;
ans+=(a*15+b*15+(a*5+b*3)*15+(c)*7+d*2);
cout<<ans<<endl;
}
return 0;
}
| 0 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;cin>>n;
int S=0,M=0,L;
for(int i=0;i<n;i++){
cin>>L;
S+=L;
M=max(M,L);
}
if(S>M*2) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
} | 0 | CPP |
#include <stdio.h>
long long n, m, k;
long long ans;
long long x, y;
long long p = 1000 * 1000 * 1000 + 7;
long long rui(long long a, long long b) {
a %= p;
if (b == 0) return 1;
if (b == 1)return a % p;
if (b == 2)return a * a % p;
if (b % 2) {
return rui(rui(a, b / 2), 2) * a % p;
}
return rui(rui(a, b / 2), 2);
}
long long inv(long long a) {
a %= p;
return rui(a, p - 2);
}
int main() {
scanf("%lld%lld%lld", &n, &m, &k);
ans = 1;
for (int i = 0; i < n; i++) {
x += i * (n - i); x %= p;
}
for (int i = 0; i < m; i++) {
y += i * (m - i); y %= p;
}
ans *= (x * m % p * m % p + y * n % p * n % p); ans %= p;
ans *= 2; ans %= p;
ans *= inv(n * m - 1); ans %= p;
ans *= inv(n * m); ans %= p;
ans *= k; ans %= p;
ans *= (k - 1); ans %= p;
ans *= inv(2); ans %= p;
for (long long i = 0; i < k; i++) {
ans *= (n * m - i); ans %= p;
ans *= inv(i + 1); ans %= p;
}
printf("%lld\n", ans);
} | 0 | CPP |
# by the authority of GOD author: manhar singh sachdev #
import os,sys
from io import BytesIO, IOBase
def main():
mod = 998244353
n,m = map(int,input().split())
arr = [list(map(int,input().split())) for _ in range(n)]
ans,fac = 0,1
for i in range(1,n+1):
fac = (fac*i)%mod
for tt in range(m):
x = sorted([arr[i][tt] for i in range(n)])
val = 1
for i in range(n):
val = (val*(x[i]-i-1))%mod
val = (fac-val)%mod
ans = (ans+val*pow(fac,mod-2,mod))%mod
print(ans)
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main() | 11 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int ans[600909], v = 0, a[600099], b[600099];
int main() {
int i, l, r, n, q;
cin >> n >> q;
for (i = 0; n > i; i++) cin >> a[i];
for (i = 0; q > i; i++) {
cin >> l >> r;
l--;
r--;
b[l]++;
if (r < n - 1) b[r + 1]--;
}
for (i = 0; n > i; i++) {
v += b[i];
ans[i] = v;
}
long long res = 0;
sort(a, a + n);
sort(ans, ans + n);
for (i = 0; n > i; i++) {
res += a[i] * 1ll * ans[i];
}
cout << res << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 300;
void print() { cout << "\n"; }
template <typename T, typename... Types>
void print(const T& arg, const Types&... args) {
cout << arg << " ";
print(args...);
}
long long power(long long a, long long b) {
if (!b) return 1;
return (power((a * a), b >> 1) * ((b & 1) ? a : 1));
}
long long power(long long a, long long b, long long p) {
if (!b) return 1;
return (power((a * a) % p, b >> 1, p) * ((b & 1) ? a : 1)) % p;
}
long long solve(string s, long long a, long long b) {
long long r = 0;
for (auto ch : s) {
if (ch - '0' == a) {
r++;
swap(a, b);
}
}
if (a != b && r & 1) r--;
return r;
}
int main() {
long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
long long result = 0;
for (__typeof(10) i = (0) - ((0) > (10)); i != (10) - ((0) > (10));
i += 1 - 2 * ((0) > (10))) {
for (__typeof(10) j = (0) - ((0) > (10)); j != (10) - ((0) > (10));
j += 1 - 2 * ((0) > (10)))
result = max(result, solve(s, i, j));
}
print(s.length() - result);
}
}
| 9 | CPP |
# JAI SHREE RAM
import math; from collections import *
import sys; from functools import reduce
# sys.setrecursionlimit(10**6)
def get_ints(): return map(int, input().strip().split())
def get_list(): return list(get_ints())
def get_string(): return list(input().strip().split())
def printxsp(*args): return print(*args, end="")
def printsp(*args): return print(*args, end=" ")
UGLYMOD = int(1e9)+7; SEXYMOD = 998244353; MAXN = int(1e5)
# sys.stdin=open("input.txt","r");sys.stdout=open("output.txt","w")
# for _testcases_ in range(int(input())):
k = int(input())
l = int(input())
m = int(input())
n = int(input())
d = int(input())
harmed = [False] * (d+1)
for i in [k, l, m, n]:
for j in range(i, d+1, i):
harmed[j] = True
print(harmed.count(True))
'''
>>> COMMENT THE STDIN!! CHANGE ONLINE JUDGE !!
THE LOGIC AND APPROACH IS MINE @luctivud ( UDIT GUPTA )
Link may be copy-pasted here if it's taken from other source.
DO NOT PLAGIARISE.
>>> COMMENT THE STDIN!! CHANGE ONLINE JUDGE !!
''' | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool ret;
int dp[505][505][2], N, K;
int go(int n, int k, bool flag) {
if (n == N) return (flag || ret);
if (dp[n][k][flag] != -1) return dp[n][k][flag];
int ans = go(n + 1, 1, flag);
if (k != K)
ans = (ans + go(n + 1, k + 1, (flag || (k + 1) == K))) % 998244353;
return dp[n][k][flag] = ans;
}
int main() {
int k;
scanf("%d%d", &N, &k);
k--;
long long ans = 0;
for (int mx = 1; mx <= min(N, k); mx++) {
memset(dp, -1, sizeof(dp));
K = mx;
ret = 0;
long long tmp = go(1, 1, K == 1);
memset(dp, -1, sizeof(dp));
K = k / mx;
ret = 1;
tmp = (tmp * go(1, 1, K == 1) * 2LL) % 998244353;
if (K) ans = (ans + tmp) % 998244353;
}
printf("%I64d", ans);
}
| 11 | CPP |
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c for j in range(b)] for i in range(a)]
def list3d(a, b, c, d): return [[[d for k in range(c)] for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e for l in range(d)] for k in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
INF = 10**19
MOD = 10**9 + 7
EPS = 10**-10
def RLE(data):
from itertools import groupby
return [(x, len(list(grp))) for x, grp in groupby(data)]
for _ in range(INT()):
a, b = MAP()
S = input()
rle = RLE(S)
if len(rle) == 1:
if rle[0][0] == '0':
print(0)
else:
print(a)
else:
if rle[-1][0] =='0':
rle.pop()
if rle[0][0] == '0':
rle.pop(0)
ans = 0
for s, cnt in rle:
if s == '0':
ans += min(0, cnt*b-a)
else:
ans += a
print(ans)
| 8 | PYTHON3 |
#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
using namespace std;
/*
AOJ :: 0110
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0110
Wrong Answer.
*/
char in[3][130];
bool iseq(){
int tmp[130];
int na = strlen(in[0]), nb = strlen(in[1]), nc = strlen(in[2]);
int i;
memset(tmp, 0, sizeof(tmp));
for(i=0; i<na; i++) tmp[i] += in[0][na-i-1] - '0';
for(i=0; i<nb; i++) tmp[i] += in[1][nb-i-1] - '0';
for(i=1; i<130; i++){
tmp[i] += tmp[i-1] / 10;
tmp[i-1] %= 10;
}
for(i=0; i<nc; i++){
if( tmp[i] != in[2][nc-i-1] - '0' ) return false;
}
for(; i<130; i++) if( tmp[i] != 0 ) return false;
return true;
}
bool ischeck(int n, int p, int num){
int i;
bool res = false;
if( n == 3 ){ // end
return iseq();
}
if( in[n][p] == '\0' ){ // next str
return ischeck(n+1, 0, num);
}
if( in[n][p] == 'X' ){
if( p == 0 && num == 0 && strlen(in[n]) > 1 ) return false;
in[n][p] = num + '0';
res = ischeck(n, p+1, num);
in[n][p] = 'X';
}
else{
res = ischeck(n, p+1, num);
}
return res;
}
int main(){
int num;
while( ~scanf(" %[^+]+%[^=]=%s ", in[0], in[1], in[2]) ){
for(num=0; num<=9; num++){
if( ischeck(0, 0, num) ) break;
}
if( num > 9 ){
puts("NA");
}
else{
printf("%d\n",num);
}
}
return 0;
} | 0 | CPP |
print(('NO', 'YES')[input().rstrip(' ?')[-1].upper() in 'AEIOUY'])
| 7 | PYTHON3 |
k = int(input())
a = [int(i) for i in input().split(' ')]
months = 0
height = 0
while len(a) > 0 and height < k:
step = max(a)
height += step
a.remove(step)
months += 1
if height < k:
print(str(-1))
else:
print(str(months))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int fx[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const int fxx[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
template <typename T, typename TT>
ostream& operator<<(ostream& s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T> t) {
s << "[";
for (int i = 0; i < ((int)(t.size())) - 1; i++) s << t[i] << ", ";
s << t[((int)(t.size())) - 1] << "]";
return s;
}
const int MOD = 1e9 + 7;
template <typename T>
inline T gcD(T a, T b) {
if (a < b) swap(a, b);
while (b) {
a = a % b;
b ^= a;
a ^= b;
b ^= a;
};
return a;
}
template <typename T>
inline T pow_mod(T a, T b) {
T res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
int main() {
int a, b, c;
scanf("%d", &a);
scanf("%d", &b);
scanf("%d", &c);
if (c == 0) {
if (b == a)
puts("YES");
else
puts("NO");
} else if ((b - a) % c == 0) {
if (c > 0 && b >= a)
puts("YES");
else if (c < 0 && b <= a)
puts("YES");
else
puts("NO");
} else
puts("NO");
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i;
long long req;
cin >> req;
long long bot = 1;
long long top = 9017199254740992;
while (top - bot > 1) {
long long mid = (bot + top) / 2;
long long i = 2;
long long ans = 0;
bool flag = 0;
long long hh = 8;
while (hh <= mid) {
ans += mid / hh;
++i;
hh = i * i * i;
if (ans >= req) {
flag = 1;
break;
}
}
if (flag) {
top = mid;
} else
bot = mid;
}
long long mid = bot;
i = 2;
long long ans = 0;
long long hh = 8;
while (hh > 0 && hh <= mid) {
ans += mid / hh;
++i;
hh = i * i * i;
}
if (ans != req) {
long long mid = top;
i = 2;
long long ans = 0;
long long hh = 8;
while (hh > 0 && hh <= mid) {
ans += mid / hh;
++i;
hh = i * i * i;
}
if (ans != req)
printf("-1\n");
else
cout << top << "\n";
} else
cout << bot << "\n";
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n,a,b,anstyoka=0,ansika=1000000000;
cin >> n >> a >> b;
vector<long> h(n);
for(long i=0;i<n;i++) cin >> h[i];
while(anstyoka+1!=ansika) {
long test=anstyoka+(1+ansika-anstyoka)/2;
long sum=0;
for(long i=0;i<n;i++) if(b*test<h[i]) sum+=(h[i]-b*test+(a-b-1))/(a-b);
if(sum>test) anstyoka=test;
else ansika=test;
}
cout << ansika << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, t;
double c;
cin >> n >> t >> c;
long long s[n + 1];
double real[n + 1], approx[n + 1], error[n + 1];
s[0] = 0;
approx[0] = 0;
for (long long i = 1; i <= n; i++) {
long long a;
cin >> a;
s[i] = s[i - 1] + a;
approx[i] = (approx[i - 1] + ((double)a) / t) / c;
if (i < t) continue;
real[i] = ((double)s[i] - s[i - t]) / t;
error[i] = abs(approx[i] - real[i]) / real[i];
}
long long m;
cin >> m;
for (long long i = 1; i <= m; i++) {
long long p;
cin >> p;
cout << real[p] << ' ' << approx[p] << ' ' << error[p] << endl;
}
}
| 8 | CPP |
k = int(input())
nc = [0 for i in range(14)]
for i in range(1, 14):
nc[i] += nc[i - 1] + 9 * (10 ** (i - 1)) * i
for i in range(13):
if nc[i] < k <= nc[i + 1]:
cif = i + 1
if cif == 1:
print(k)
quit()
c = k - nc[cif - 1]
if c % cif == 0:
nnr = c // cif
ncif = cif
else:
nnr = 1 + c // cif
ncif = c % cif
number = nnr + 10 ** (cif - 1) - 1
while cif != ncif:
number //= 10
cif -= 1
print(number % 10) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long sigma(long long n) { return (n * (n + 1) / 2); }
long long MOD(long long x) {
if (x >= 0) return x;
return (-x);
}
bool great(long long a, long long b) { return a > b; }
long long max3(long long a, long long b, long long c) {
return (max(a, max(b, c)));
}
long long max4(long long a, long long b, long long c, long long d) {
return (max(max(a, b), max(c, d)));
}
long long min3(long long a, long long b, long long c) {
return (min(a, min(b, c)));
}
long double min4(long double a, long double b, long double c, long double d) {
return (min(min(a, b), min(c, d)));
}
vector<long long> factors(long long x) {
vector<long long> v;
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) {
v.push_back(i);
if (i != x / i) {
v.push_back(x / i);
}
}
}
return v;
}
vector<long long> min_prime;
unordered_map<long long, long long> prime_fact(long long x) {
unordered_map<long long, long long> mp;
while (x != 1) {
mp[min_prime[x]]++;
x /= min_prime[x];
}
return mp;
}
map<long long, long long> factorizee(long long n) {
map<long long, long long> mp;
for (long long i = 2; i * i <= n; ++i) {
while (n % i == 0) {
mp[i]++;
n /= i;
}
}
if (n != 1) {
mp[n]++;
}
return mp;
}
long long power(long long a, long long b, long long m) {
long long ans = 1;
while (b > 0) {
if (b % 2) {
ans = (ans * a) % m;
}
a = (a * a) % m;
b = b / 2;
}
return ans;
}
long long dp[101][2][3005];
vector<pair<long long, long long> > a;
long long doer(long long in, long long z, long long l) {
if (l == 0) {
return 1;
}
if (l < 0) {
return 0;
}
if (dp[in][z][l] != -1) {
return dp[in][z][l];
}
long long h = a[in].first;
long long b = a[in].second;
if (z) {
swap(h, b);
}
dp[in][z][l] = 0;
for (long long i = 0; i < a.size(); i++) {
if (i == in) {
continue;
}
if (a[i].first == a[i].second) {
if (a[i].first == b) {
dp[in][z][l] += doer(i, 0, l - a[i].first);
dp[in][z][l] %= 1000000007;
}
continue;
}
if (a[i].first == b) {
dp[in][z][l] += doer(i, 0, l - a[i].first);
dp[in][z][l] %= 1000000007;
continue;
}
if (a[i].second == b) {
dp[in][z][l] += doer(i, 1, l - a[i].second);
dp[in][z][l] %= 1000000007;
}
}
return dp[in][z][l];
}
int main() {
memset(dp, -1, sizeof(dp));
long long n, l;
cin >> n >> l;
a.resize(n);
for (long long i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (a[i].first == a[i].second) {
ans += doer(i, 0, l - a[i].first);
ans %= 1000000007;
continue;
}
ans += doer(i, 0, l - a[i].first);
ans %= 1000000007;
ans += doer(i, 1, l - a[i].second);
ans %= 1000000007;
}
cout << ans << endl;
}
| 11 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.