solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
import math
n,m,a=[int(x) for x in input().split()]
ans=math.ceil(n/a)*math.ceil(m/a)
print(ans) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
long long mod = 1000000007;
using namespace std;
int n, m;
struct node {
string x;
string a, b;
int type = -1;
} que[2 * 100005];
char a1[2 * 100005];
char formax[2 * 1000];
char formin[2 * 1000];
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int main() {
int i, j, fl, test;
scanf("%d%d", &n, &m);
getchar();
for (i = 0; i < n; i++) {
scanf("%[^\n]s", a1);
getchar();
string z = "";
int wc = 0;
for (j = 0;; j++) {
if (!a1[j] || a1[j] == ' ') {
wc++;
if (wc == 1) {
que[i].x = z.c_str();
} else if (wc == 3) {
que[i].a = z.c_str();
} else if (wc == 4) {
if (z[0] == 'X')
que[i].type = 2;
else if (z[0] == 'A')
que[i].type = 0;
else
que[i].type = 1;
} else if (wc == 5)
que[i].b = z.c_str();
z = "";
} else
z = z + a1[j];
if (a1[j] == '\0') break;
}
}
for (i = 0; i < m; i++) {
unordered_map<string, int> M;
int cnt[2] = {0};
for (j = 0; j < 2; j++) {
M["?"] = j;
for (int k = 0; k < n; k++) {
if (que[k].type == -1) {
if (que[k].a[0] != '0' && que[k].a[0] != '1') {
M[que[k].x] = M[que[k].a];
} else
M[que[k].x] = que[k].a[i] - '0';
} else {
int bit1, bit2;
if (que[k].a[0] != '0' && que[k].a[0] != '1') {
bit1 = M[que[k].a];
} else
bit1 = que[k].a[i] - '0';
if (que[k].b[0] != '0' && que[k].b[0] != '1') {
bit2 = M[que[k].b];
} else
bit2 = que[k].b[i] - '0';
if (que[k].type == 0)
M[que[k].x] = bit1 & bit2;
else if (que[k].type == 1)
M[que[k].x] = bit1 | bit2;
else
M[que[k].x] = bit1 ^ bit2;
}
if (M[que[k].x] == 1) cnt[j]++;
}
}
if (cnt[0] == cnt[1]) {
formax[i] = '0';
formin[i] = '0';
} else if (cnt[0] > cnt[1]) {
formax[i] = '0';
formin[i] = '1';
} else {
formin[i] = '0';
formax[i] = '1';
}
}
formax[i] = '\0';
formin[i] = '\0';
printf("%s\n", formin);
printf("%s\n", formax);
return 0;
}
| 1,800 | CPP |
mystr = input()
left = ['']
count = 0
for ch in mystr:
if ch == left[-1]:
left.pop()
count +=1
else:
left.append(ch)
if count%2 == 1:
print('YES')
else:
print('NO') | 1,200 | PYTHON3 |
import math
t = int(input())
for _ in range(t):
n, k = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
ma = -1
d = {}
for i in a:
if i%k == 0:
continue
r = i%k
r = k - r
if r not in d:
d[r] = 0
d[r] += 1
ma = max(ma, r + ((d[r]-1)*k))
print(ma + 1)
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int m = 1, k, p;
std::cin >> p >> k;
if (k == 0)
m = p - 1;
else if (k == 1)
m = p;
else {
long long x = k;
while (x != 1) {
x = x * k % p;
m++;
}
m = (p - 1) / m;
}
long long res = 1;
while (m--) res = res * p % 1000000007;
std::cout << res;
}
| 1,800 | CPP |
# mcd
n = int(input())
arr = list(map(int, input().split()))
tmp = []
max_s = -10**10
for i in range(n):
ans = [0 for i in range(n)]
ans[i] = arr[i]
#forward checks
for j in range(i+1, n):
ans[j] = min(arr[j], ans[j-1])
#backward checks
for j in range(i-1, -1, -1):
ans[j] = min(arr[j], ans[j+1])
tocheck = sum(ans)
if max_s < tocheck:
tmp = ans[::]
max_s = tocheck
print(*tmp) | 1,500 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops")
using namespace std;
const long long inf = 1ll << 60;
const long long iinf = 2147483647;
const long long mod = 998244353;
const long long maxn = 1e3 + 5;
long long pw(long long x, long long p) {
long long ret = 1;
while (p > 0) {
if (p & 1) {
ret *= x;
ret %= mod;
}
x *= x;
x %= mod;
p >>= 1;
}
return ret;
}
long long inv(long long x) { return pw(x, mod - 2); }
long long n, m;
vector<long long> vc, posa, posb;
void reca(long long x, long long sum) {
posa.push_back(0);
for (long long i = (0); i < (n / 2); i++) {
long long second = (long long)(posa.size());
for (long long j = (0); j < (second); j++) {
posa.push_back((posa[j] + vc[i]) % m);
}
}
}
void recb(long long x, long long sum) {
posb.push_back(0);
for (long long i = (n / 2); i < (n); i++) {
long long second = (long long)(posb.size());
for (long long j = (0); j < (second); j++) {
posb.push_back((posb[j] + vc[i]) % m);
}
}
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
cin >> n >> m;
vc.resize(n);
for (long long i = (0); i < (n); i++) {
cin >> vc[i];
vc[i] %= m;
}
reca(0, 0);
sort(posa.begin(), posa.end(), greater<long long>());
posa.resize(unique(posa.begin(), posa.end()) - posa.begin());
recb(n / 2, 0);
sort(posb.begin(), posb.end());
posb.resize(unique(posb.begin(), posb.end()) - posb.begin());
long long r = 0, ans = vc[0];
long long ma = (long long)(posa.size()), mb = (long long)(posb.size());
for (long long i = (0); i < (ma); i++) {
while (r + 1 < mb && (posa[i] + posb[r + 1]) < m) {
r++;
}
ans = max(ans, (posa[i] + posb[r]) % m);
}
cout << ans << '\n';
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int m;
cin >> m;
int h1[100008] = {0}, h2[100009] = {0};
int a[100009], f[100009], res[100009], b[100009];
for (int i = 0; i < n; i++) {
cin >> f[i];
h1[f[i]]++;
res[f[i]] = i;
}
for (int i = 0; i < m; i++) {
cin >> b[i];
h2[b[i]]++;
}
for (int i = 0; i < m; i++) {
if (h2[b[i]] > 0 && h1[b[i]] == 0) {
cout << "Impossible";
return 0;
}
}
for (int i = 0; i < m; i++) {
if (h1[b[i]] > 1) {
cout << "Ambiguity";
return 0;
}
}
for (int i = 0; i < m; i++) {
a[i] = res[b[i]];
}
cout << "Possible" << endl;
for (int i = 0; i < m; i++) {
cout << a[i] + 1 << " ";
}
return 0;
}
| 1,500 | CPP |
import string
def check_code():
for _ in range(int(input())):
s = input()
if s[1].isdigit() and 'R' in s and 'C' in s:
# R34C51 => AY34
i = s.find('C')
c = int(s[i+1:])
x = ''
while(c):
c -= 1
x = string.ascii_uppercase[c%26] + x
c = c // 26
print(x + s[1:i])
else:
# AY34 => R34C51
i, c = 0, 0
while s[i].isalpha():
c = c*26+string.ascii_uppercase.find(s[i])+1
i += 1
print('R' + s[i:] + 'C' + str(c))
if __name__ == "__main__":
check_code()
exit()
| 1,600 | PYTHON3 |
n, k = map(int, input().split())
if n % 2 == 0:
odd = n//2
else:
odd = n//2+1
if k <= odd:
print(2*k-1)
else:
print((k-odd)*2)
| 900 | PYTHON3 |
#include <bits/stdc++.h>
int member[101][101];
int n;
int search(void) {
int i, j, k = 0;
int list[101], count;
for (i = 1; i <= n; i++) {
count = 0;
for (j = 1; j <= n; j++) {
if (member[i][j] == 1) count++;
}
if (count == 1) {
list[k] = i;
k++;
}
}
if (k != 0) {
for (i = 0; i < k; i++) {
for (j = 1; j <= n; j++) {
member[j][list[i]] = 0;
member[list[i]][j] = 0;
}
}
return 1 + search();
} else
return 0;
}
int main(void) {
int a, b, m;
int i, j;
scanf("%d %d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
member[a][b] = 1;
member[b][a] = 1;
}
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) {
if (member[i][j] != 1) member[i][j] = 0;
}
}
a = search();
printf("%d\n", a);
return 0;
}
| 1,200 | CPP |
n,m=map(int,input().split())
l = [0]*(n*m+1)
for i in range(n):
x = list(map(int,input().split()))
for j in range(m):
if(x[j]==1):
l[i*m+j+1] =1
c= 0
b = [0]*(n*m+1)
ans = []
for i in range(n-1):
for j in range(m-1):
if(l[i*m+1+j]==1 and l[i*m+j+2]==1 and l[(i+1)*m + j +1]==1 and l[(i+1)*m + j +2]==1):
c=c+1
b[i*m+1+j] =1
b[i*m+j+2] =1
b[(i+1)*m + j +1]=1
b[(i+1)*m + j +2]=1
ans.append([i+1,j+1])
if(l==b):
print(c)
for i in ans:
print(i[0]," ",i[1])
else:
print(-1)
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
if (n == 3) {
cout << "7" << endl;
return;
}
long long int num = n / 2;
if (num < 998244353 + 1) {
if (n & 1) {
cout << "7";
num--;
}
for (int i = 0; i < num; i++) cout << "1";
cout << endl;
return;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 900 | CPP |
a=int(input())
d=[int(i) for i in input().split()]
start_amaze=d[0]
last_amaze=d[0]
count=0
for i in range(len(d)-1):
if (start_amaze > d[i+1]):
start_amaze=d[i+1]
count=count+1
if (last_amaze < d[i+1]):
last_amaze=d[i+1]
count=count+1
print(count)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
double sqr(double a) { return a * a; }
const long long int inf = 100000000000000000LL;
struct Node {
vector<int> nbr;
int used;
int o;
Node() { used = 0; }
};
void merge(vector<deque<int> >& q) {
deque<int> ans;
while (q.size() >= 3) {
for (int i = 0; i < 3; ++i) {
int k = q.size() - 1;
while (q[k].size() > 1) {
ans.push_back(*q[k].begin());
q[k].pop_front();
}
if (i == 2) {
ans.push_back(*q[k].begin());
}
q.pop_back();
}
q.push_back(ans);
}
}
vector<deque<int> > dfs(vector<Node>& arr, int v) {
arr[v].used = true;
vector<deque<int> > res;
for (int i = 0; i < arr[v].nbr.size(); ++i) {
int to = arr[v].nbr[i];
if (!arr[to].used) {
vector<deque<int> > r = dfs(arr, to);
for (int j = 0; j < r.size(); ++j) {
r[j].push_back(v);
r[j].push_front(v);
merge(r);
res.push_back(r[j]);
merge(res);
}
}
}
if (arr[v].o) {
deque<int> c;
c.push_back(v);
res.push_back(c);
}
merge(res);
return res;
}
void solve(vector<Node>& arr, int ind) {
auto q = dfs(arr, ind);
for (int i = 0; i < arr.size(); ++i) {
if (arr[i].o == 1 && arr[i].used == 0) {
cout << -1;
exit(0);
}
}
vector<int> ans;
while (q.size() > 0) {
int k = q.size() - 1;
while (q[k].size() > 1) {
ans.push_back(*q[k].begin());
q[k].pop_front();
}
q.pop_back();
}
int a = 0;
for (int i = 0; i < ans.size(); ++i) {
if (ans[i] == ind) {
++a;
}
}
if (a % 2 == 0) ans.push_back(ind);
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i] + 1 << " ";
}
}
int main() {
clock_t start = clock();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
int n, m;
cin >> n >> m;
vector<Node> arr(n);
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
--a, --b;
arr[a].nbr.push_back(b);
arr[b].nbr.push_back(a);
}
for (int i = 0; i < n; ++i) {
cin >> arr[i].o;
}
for (int i = 0; i < n; ++i) {
if (arr[i].o) {
solve(arr, i);
return 0;
}
}
cout << "0";
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<vector<int> > g;
vector<int> m;
vector<int> color;
vector<int> way;
bool check = false;
void read() {
int c, x;
cin >> n >> k;
g.resize(n + 1);
color.resize(n + 1);
m.resize(k);
for (int i = 0; i < k; i++) cin >> m[i];
for (int i = 1; i < n + 1; i++) {
cin >> c;
for (int j = 0; j < c; j++) {
cin >> x;
g[i].push_back(x);
}
}
}
void dps(int v) {
int to;
if (color[v] == 0) {
color[v] = 1;
for (int i = 0; i < g[v].size(); i++) {
to = g[v][i];
dps(to);
}
color[v] = 2;
way.push_back(v);
} else if (color[v] == 1) {
check = true;
}
}
int main() {
read();
for (int i = 0; i < m.size(); i++) {
if (color[m[i]] == 0) dps(m[i]);
}
if (check)
cout << -1;
else {
cout << way.size() << endl;
for (int i = 0; i < way.size(); i++) cout << way[i] << " ";
}
return 0;
}
| 1,500 | CPP |
s=input()
s=s.split()
c=int(s[0])*int(s[1])
print(c//2) | 800 | PYTHON3 |
n,k=map(int,input().split())
a=[1]*k
n-=k
i=0
while i<k and n:
while a[i]<=n:
n-=a[i]
a[i]*=2
i+=1
if n:
print('NO')
else:
print('YES',*a) | 1,400 | PYTHON3 |
val=['H','Q','9']
x=input()
res=[]
x=list(x)
for v in x:
if v in val :
res.append(True)
else:
res.append(False)
if any(k==True for k in res):
print("YES")
else:
print('NO')
| 900 | PYTHON3 |
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const ll mod = 998244353;
const int max_n = 2e5+100;
ll J[max_n];
int suffix[max_n],rak[max_n],n,k;
inline ll POW(ll base,ll p){ll ans=1;while (p){if (p&1)ans=ans*base%mod;base=base*base%mod;p>>=1;}return ans;}
inline ll inv(ll num){return POW(num,mod-2);}
inline ll C(int n,int m){if (n<0||m<0||m>n)return 0;return J[n]*inv(J[m]*J[n-m]%mod)%mod;}
int main()
{
ios::sync_with_stdio(0);
J[0]=1;
for (int i=1;i<max_n;++i)J[i]=J[i-1]*i%mod;
cin>>n>>k;
for (int i=1;i<=n;++i)
{
cin>>suffix[i];
++suffix[i];
rak[suffix[i]]=i;
}
int cnt=0;
for (int i=1;i<n;++i)cnt+=(rak[suffix[i]+1]<rak[suffix[i+1]+1]);
ll ans = 0;
for (int i=n;i>=1;--i)ans = (ans+C(k,i)*C(cnt,n-i)%mod)%mod;
cout<<ans<<endl;
} | 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[555555], vis1[555555];
long long int dp1[555555], dp2[555555], val1[555555], val2[555555], ans[555555];
int main(void) {
int n;
scanf("%d", &n);
for (int e = 1; e <= n; e++) scanf("%d", &arr[e]);
for (int e = 1; e <= n; e++) dp1[e] = arr[e] + dp1[e - 1];
for (int e = n; e >= 1; e--) dp2[e] = arr[e] + dp2[e + 1];
priority_queue<pair<int, int> > q;
for (int e = 1; e <= n; e++) {
val1[e] = val1[e - 1];
int la = e, err = 0;
long long int ttot = 0;
while (!q.empty()) {
int now = q.top().first, wh = q.top().second;
if (now > arr[e]) {
ttot += (long long int)(now - arr[e]) * (long long int)(la - wh);
la = min(la, wh);
q.pop();
} else {
if (now == arr[e]) err++;
break;
}
}
val1[e] += ttot;
if (err == 0) q.push(make_pair(arr[e], la));
}
q = priority_queue<pair<int, int> >();
for (int e = n; e >= 1; e--) {
val2[e] = val2[e + 1];
int la = e, err = 0;
long long int ttot = 0;
while (!q.empty()) {
int now = q.top().first, wh = q.top().second;
if (now > arr[e]) {
ttot += (long long int)(now - arr[e]) * (long long int)(wh - la);
la = max(la, wh);
q.pop();
} else {
if (now == arr[e]) err++;
break;
}
}
val2[e] += ttot;
if (err == 0) q.push(make_pair(arr[e], la));
}
int wh = -1;
long long int mm = 1e18;
for (int e = 1; e <= n; e++) {
if (val1[e] + val2[e] < mm) {
mm = val1[e] + val2[e];
wh = e;
}
}
ans[wh] = arr[wh];
int m2 = arr[wh];
for (int e = wh - 1; e >= 1; e--) {
m2 = min(m2, arr[e]);
ans[e] = m2;
}
m2 = arr[wh];
for (int e = wh + 1; e <= n; e++) {
m2 = min(m2, arr[e]);
ans[e] = m2;
}
for (int e = 1; e <= n; e++) printf("%d ", ans[e]);
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct CentroidD {
long long n, val_vis;
vector<vector<long long> > adj, pes;
vector<long long> cparent, szt, vis;
vector<vector<long long> > cdTree;
CentroidD(){};
CentroidD(long long n) : n(n) {
val_vis = 0;
vis.resize(n, -1);
cparent.resize(n, -1);
szt.resize(n, 0);
adj.resize(n);
pes.resize(n);
cdTree.resize(n);
}
void addEdge(long long u, long long v, long long w) {
adj[u].push_back(v);
adj[v].push_back(u);
pes[u].push_back(w);
pes[v].push_back(w);
return;
}
long long dfs(long long u, long long p) {
szt[u] = 1;
vis[u] = val_vis;
for (long long v : adj[u]) {
if (v != p && cparent[v] == -1 && vis[v] != val_vis) szt[u] += dfs(v, u);
}
return szt[u];
}
void decompotition(long long u, long long p, long long sz, long long pc) {
for (long long v : adj[u]) {
if (v != p && cparent[v] == -1 && (szt[v] << 1ll) > sz) {
decompotition(v, u, sz, pc);
return;
}
}
cparent[u] = pc;
if (pc != -2) {
cdTree[u].push_back(pc);
cdTree[pc].push_back(u);
}
for (long long v : adj[u]) {
if (cparent[v] == -1) {
dfs(v, -1);
val_vis++;
decompotition(v, -1, szt[v], u);
}
}
}
void build(long long u) {
dfs(u, -1);
val_vis++;
decompotition(u, -1, szt[u], -2);
}
};
const long long MX = 1e5 + 10;
CentroidD G;
vector<pair<long long, long long> > lc;
vector<pair<long long, long long> > cl;
bool visCentroid[MX];
long long pot[MX];
long long ans, MOD;
long long inverse(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m;
a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) {
x += m0;
}
return x;
}
void getVector(long long u, long long p, long long w_lc, long long w_cl,
long long d) {
for (long long i = 0; i < G.adj[u].size(); i++) {
long long v = G.adj[u][i];
long long w = G.pes[u][i];
if (v != p && !visCentroid[v]) {
getVector(v, u, (w * pot[d] + w_lc) % MOD, (w_cl * 10 + w) % MOD, d + 1);
}
}
lc.push_back({w_lc, d});
cl.push_back({w_cl, d});
return;
}
void calculate(long long u) {
vector<vector<pair<long long, long long> > > leaf_cent, cent_leaf;
for (long long i = 0; i < G.adj[u].size(); i++) {
long long v = G.adj[u][i];
long long w = G.pes[u][i];
if (!visCentroid[v]) {
lc.clear();
cl.clear();
getVector(v, u, w, w, 1);
leaf_cent.push_back(lc);
cent_leaf.push_back(cl);
}
}
for (long long i = 0; i < cent_leaf.size(); i++) {
for (long long j = 0; j < cent_leaf[i].size(); j++) {
if (cent_leaf[i][j].first % MOD == 0) ans++;
}
}
for (long long i = 0; i < leaf_cent.size(); i++) {
for (long long j = 0; j < leaf_cent[i].size(); j++) {
if (leaf_cent[i][j].first % MOD == 0) ans++;
}
}
map<long long, long long> cnt;
for (long long i = 0; i < cent_leaf.size(); i++) {
for (long long j = 0; j < cent_leaf[i].size(); j++) {
long long num = (MOD - cent_leaf[i][j].first) % MOD;
long long den = pot[cent_leaf[i][j].second];
cnt[(num * inverse(den, MOD)) % MOD]++;
}
}
for (long long i = 0; i < leaf_cent.size(); i++) {
vector<long long> aux;
for (long long j = 0; j < cent_leaf[i].size(); j++) {
long long num = (MOD - cent_leaf[i][j].first) % MOD;
long long den = pot[cent_leaf[i][j].second];
long long rp = (num * inverse(den, MOD)) % MOD;
aux.push_back(rp);
cnt[rp]--;
}
for (long long j = 0; j < leaf_cent[i].size(); j++) {
ans += cnt[leaf_cent[i][j].first];
}
for (long long xx : aux) cnt[xx]++;
}
return;
}
void dfs(long long u, long long p) {
visCentroid[u] = true;
calculate(u);
for (long long v : G.cdTree[u]) {
if (v != p) dfs(v, u);
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(10);
cout << fixed;
long long n, x, y, w;
cin >> n >> MOD;
G = CentroidD(n);
for (long long i = 1; i < n; i++) {
cin >> x >> y >> w;
G.addEdge(x, y, w % MOD);
}
G.build(0);
long long centroid = -1;
for (long long i = 0; i < n; i++) {
if (G.cparent[i] == -2) centroid = i;
}
pot[0] = 1 % MOD;
for (long long i = 1; i < MX; i++) pot[i] = (pot[i - 1] * 10) % MOD;
ans = 0;
dfs(centroid, -1);
cout << ans << "\n";
return 0;
}
| 2,700 | CPP |
# from collections import defaultdict
rr = lambda: input()
rri = lambda: int(input())
rrm = lambda: list(map(int, input().split()))
INF=float('inf')
def solve(N,S):
invalid = 0
bal = 0
for b in S:
if b == ')':
bal -= 1
if bal < 0:
bal = 0
invalid += 1
else:
bal += 1
# balance at end is something
return invalid
t = rri()
for _ in range(t):
n = rri()
s = rr()
print(solve(n,s))
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int q = 1000000007, t = 30;
const long long inf = 1000000010;
int n, m, x[200010], p, u, v, ww, pp[100010];
struct orz {
int a, b, c, d, e;
} w;
vector<orz> f[400010];
inline void xds(int i, int l, int r) {
if (l < r) {
xds(i << 1, l, l + r >> 1);
xds(i << 1 | 1, (l + r >> 1) + 1, r);
}
int j, k, u, v, b, c;
for (j = 0;;) {
w.b = 1;
w.c = 0;
w.a = w.d = w.e = j;
for (k = r, b = c = 0, u = 0; k >= l; k--) {
if (w.d <= 0) {
if (!u) {
u = k;
v = -w.d;
}
b = (b + w.b * 2ll) % q;
c = (c + w.c * 2ll) % q;
w.b = w.c = w.d = w.e = 0;
}
w.b = (w.b << 1) % q;
w.c = (w.c * 2ll + x[k]) % q;
w.d = min(w.d * 2ll + x[k], inf);
w.e = (w.e * 2ll + x[k]) % q;
}
w.b = b;
w.c = c;
f[i].push_back(w);
if (!u) break;
if (r - u > t)
j++;
else {
j += v / (1 << r - u) + 1;
}
}
}
inline int xxx(int i) {
if (i > t)
return inf;
else
return 1 << i;
}
inline void query(int i, int l, int r, int j, int k) {
if (j <= l && r <= k) {
int p;
if (ww < 0) {
v = (v + ww * 2ll) % q;
u = ww = 0;
}
for (p = 0; p + 1 < f[i].size() && ww >= f[i][p + 1].a; p++)
;
v = (v + (long long)f[i][p].b * u + f[i][p].c) % q;
if (p + 1 == f[i].size()) {
u = (f[i][p].e + (long long)(u - f[i][p].a) * pp[r - l + 1]) % q;
ww = min(inf, f[i][p].d + (long long)(ww - f[i][p].a) * xxx(r - l + 1));
} else {
u = f[i][p].e;
ww = f[i][p].d;
}
} else {
if (k > (l + r >> 1)) query(i << 1 | 1, (l + r >> 1) + 1, r, j, k);
if (j <= (l + r >> 1)) query(i << 1, l, l + r >> 1, j, k);
}
}
int main() {
int i, j;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &x[i]);
for (p = 1; p < n; p <<= 1)
;
xds(1, 1, p);
pp[0] = 1;
for (i = 1; i <= n; i++) pp[i] = (pp[i - 1] << 1) % q;
while (m--) {
scanf("%d%d", &i, &j);
u = v = ww = 0;
query(1, 1, p, i, j);
printf("%d\n", ((u + v) % q + q) % q);
}
return 0;
}
| 3,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long total[100002];
int main() {
long long n, i, x, max_val = -1e+9;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
total[x] += x;
max_val = max(max_val, x);
}
long long points;
for (i = 2; i <= max_val; i++) {
total[i] = max(total[i - 1], total[i - 2] + total[i]);
}
points = total[max_val];
cout << points;
}
| 1,500 | CPP |
def kek():
n, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
arr.sort(reverse=True)
for i in range(1, k + 1):
t = arr[i]
arr[0] += t
arr[i] -= t
print(arr[0] - min(arr))
t = int(input())
for i in range(t):
kek()
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> ans;
string code, x;
cin >> code;
string num0, num1, num2, num3, num4, num5, num6, num7, num8, num9;
cin >> num0 >> num1 >> num2 >> num3 >> num4 >> num5 >> num6 >> num7 >> num8 >>
num9;
for (int i = 0; i < 80; i += 10) {
x = code.substr(i, 10);
if (x == num0)
ans.push_back(0);
else if (x == num1)
ans.push_back(1);
else if (x == num2)
ans.push_back(2);
else if (x == num3)
ans.push_back(3);
else if (x == num4)
ans.push_back(4);
else if (x == num5)
ans.push_back(5);
else if (x == num6)
ans.push_back(6);
else if (x == num7)
ans.push_back(7);
else if (x == num8)
ans.push_back(8);
else if (x == num9)
ans.push_back(9);
}
for (int j = 0; j < ans.size(); j++) {
cout << ans[j];
}
}
| 900 | CPP |
from sys import stdin
for _ in range(int(stdin.readline())):
n = int(stdin.readline())
array = list(map(int, stdin.readline().split()))
flag = True
for i in range(1, n):
if array[i] >= array[i - 1]:
flag = False
if flag:
print("NO")
else:
print("YES") | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int inf = 50000000;
const int maxn = 100010;
int check(vector<int> &v) {
int i, first, cur, j;
for (i = 0; i < v.size(); i++) {
first = j = 0;
cur = v[i];
while (j < 8) {
if (cur == 1) {
first = 1;
break;
}
cur = v[cur];
j++;
}
if (!first) return 0;
}
return 1;
}
int generator(vector<int> &v, int left, int k) {
if (left == 0) return check(v);
int i, ret = 0;
for (i = 1; i <= k; i++) {
v.push_back(i);
ret += generator(v, left - 1, k);
v.pop_back();
}
return ret;
}
long long modpow(long long a, long long b) {
long long x = 1, y = a;
while (b) {
if (b % 2) x = (x * y) % mod;
y = (y * y) % mod;
b /= 2;
}
return x;
}
long long temp[] = {0, 1, 2, 9, 64, 625, 7776, 117649, 2097152};
int main() {
int n, k;
scanf("%d", &n), scanf("%d", &k);
vector<int> v;
long long ans = temp[k];
ans = (ans * modpow(n - k, n - k)) % mod;
cout << ans << "\n";
return 0;
}
| 1,500 | CPP |
# print ("Input n")
n = int(input())
# print ("Enter the string")
st = input()
answer = 0
done = False
if len(st) > 26:
done = True
else:
d = {}
for ch in st:
d[ch] = d.get(ch, 0) + 1
if not done:
for key in d:
answer += d[key]-1
else:
answer = -1
print(answer)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> e[100005];
long long par[100005];
long long limit = 0;
long long depth[100005];
long long num[100005] = {0};
long long maxd = 0;
bool flag = false;
void dfs(long long u) {
num[depth[u] % (limit - 1)]++;
maxd = max(maxd, depth[u]);
if (!flag) {
for (long long i = 0; i < e[u].size(); i++) {
long long v = e[u][i];
if (depth[v] == -1) {
par[v] = u;
depth[v] = depth[u] + 1;
dfs(v);
} else if (depth[u] - depth[v] + 1 >= limit && flag == false) {
flag = true;
printf("2\n%lld\n", depth[u] - depth[v] + 1);
for (long long i = u; i != par[v]; i = par[i]) {
printf("%lld ", i);
}
printf("\n");
}
}
}
}
int main(void) {
long long n, m;
scanf("%lld%lld", &n, &m);
for (long long i = 0; i < m; i++) {
long long from, to;
scanf("%lld%lld", &from, &to);
e[from].push_back(to);
e[to].push_back(from);
}
limit = (long long)(sqrt(n));
if (limit * limit < n) limit++;
for (long long i = 0; i <= n; i++) {
depth[i] = -1;
}
depth[1] = 0;
dfs(1);
if (!flag) {
printf("1\n");
long long num1 = -1;
for (long long i = 0; i < limit - 1; i++) {
if (num[i] >= limit) {
num1 = i;
break;
}
}
long long num2 = 0;
for (long long i = 1; i <= n; i++) {
if (num2 < limit && depth[i] % (limit - 1) == num1) {
printf("%lld ", i);
num2++;
}
}
}
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
int main() {
v.push_back(0);
v.push_back(0);
v.push_back(1);
v.push_back(2);
v.push_back(4);
long long n;
cin >> n;
int x;
for (long long i = 2; i < 100000; i++) {
x = i * i;
v.push_back(x + i);
v.push_back((i + 1) * (i + 1));
}
for (int i = 2; i < v.size(); i++) {
if (n == v[i]) {
cout << i << endl;
return 0;
}
if (n < v[i + 1] && n > v[i]) {
cout << i + 1 << endl;
return 0;
}
}
return 0;
}
| 1,100 | CPP |
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
def main():
for _ in range(int(input())):
n = int(input())
a = list(input())
b = list(input())
ind = []
for i in range(n):
if a[i] != b[i]:
ind.append(i+1)
ind.append(1)
ind.append(i+1)
print(len(ind), *ind)
# print(a)
# print(b)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main()
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int N, H;
long long K;
long long f[52][2][2];
int p[52], all0;
long long dfs(int nw, int R, int I) {
if (f[nw][R][I] != -1) return f[nw][R][I];
if (nw * 2 > N) {
if (N % 2) {
int yl = 0;
if (p[nw] != 1) yl++;
if (p[nw] != 0 && I) yl++;
return yl;
}
return 1;
}
long long yl = 0;
if (p[nw] != 1) {
if (p[N - nw + 1] != 0) yl += dfs(nw + 1, R | 1, I);
if (p[N - nw + 1] != 1) yl += dfs(nw + 1, R, I | 1);
}
if (p[nw] != 0) {
if (p[N - nw + 1] != 0 && I) yl += dfs(nw + 1, R, I);
if (p[N - nw + 1] != 1 && R) yl += dfs(nw + 1, R, I);
}
return f[nw][R][I] = yl;
}
int main() {
scanf("%d", &N);
cin >> K;
memset(p, -1, sizeof(p));
memset(f, -1, sizeof(f));
p[1] = 0;
if (N == 1 && K == 1) {
printf("1");
return 0;
}
if (dfs(1, 0, 0) - 1 < K) {
printf("-1\n");
return 0;
}
printf("0");
memset(f, -1, sizeof(f));
for (int i = 2; i <= N; i++) {
p[i] = 0;
long long tll = dfs(1, 0, 0);
if (!all0) tll--;
memset(f, -1, sizeof(f));
if (tll >= K) {
printf("0");
} else {
K -= tll;
printf("1");
p[i] = all0 = 1;
}
}
}
| 2,600 | CPP |
n,m,z=map(int,input().split())
from math import gcd
lcm=n*m//gcd(n,m)
print(z//lcm)
| 800 | PYTHON3 |
import sys,math
from collections import deque,defaultdict
import operator as op
from functools import reduce
#sys.setrecursionlimit(10**6)
I=sys.stdin.readline
#s="abcdefghijklmnopqrstuvwxyz"
"""
x_move=[-1,0,1,0,-1,1,1,-1]
y_move=[0,1,0,-1,1,1,-1,-1]
"""
def ii():
return int(I().strip())
def li():
return list(map(int,I().strip().split()))
def mi():
return map(int,I().strip().split())
"""def ncr(n, r):
r = min(r, n-r)
numer = (reduce(op.mul, range(n, n-r, -1), 1))%(10**9+7)
denom = (reduce(op.mul, range(1, r+1), 1))%(10**9+7)
return (numer // denom)%(10**9+7)"""
def ncr(n, r, p):
# initialize numerator
# and denominator
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
def gcd(x, y):
while y:
x, y = y, x % y
return x
def valid(row,col,rows,cols,rcross,lcross):
return rows[row]==0 and cols[col]==0 and rcross[col+row]==0 and lcross[col-row]==0
def div(n):
tmp=[]
for i in range(2,int(n**.5)+1):
if n%i==0:
cnt=0
while(n%i==0):
n=n//i
cnt+=1
tmp.append((i,cnt))
if n>1:
tmp.append((n,1))
return tmp
def isPrime(n):
if n<=1:
return False
elif n<=2:
return True
else:
flag=True
for i in range(2,int(n**.5)+1):
if n%i==0:
flag=False
break
return flag
def s(b):
d=defaultdict(int)
while b>0:
tmp=b%10
if d[tmp]>0:
return False
d[tmp]=1
b=b//10
return True
def main():
#ans=""
for _ in range(ii()):
n=ii()
s=I().strip()
s2=I().strip()
ans=[]
for i in range(1,n):
if s[i]!=s[i-1]:
ans.append(i)
if s[n-1]=='1':
ans.append(n)
tmp=[]
for i in range(1,n):
if s2[i]!=s2[i-1]:
tmp.append(i)
if s2[n-1]=='1':
tmp.append(n)
ans+=tmp[::-1]
ans=[len(ans)]+ans
print(*ans)
#print(ans)
if __name__ == '__main__':
main() | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
string s;
string t;
int m;
typedef struct node {
int open;
int close;
int rez;
} NODE;
NODE tree[4000001];
void build(int pos, int l, int r) {
if (l == r) {
tree[pos] = {0, 0, 0};
if (s[l] == '(')
tree[pos].open++;
else
tree[pos].close++;
return;
}
int mid = (l + r) / 2;
build(2 * pos, l, mid);
build(2 * pos + 1, mid + 1, r);
tree[pos] = {0, 0, 0};
NODE a = tree[2 * pos];
NODE b = tree[2 * pos + 1];
int buff = min(a.open, b.close);
tree[pos].open = a.open + b.open - buff;
tree[pos].close = a.close + b.close - buff;
tree[pos].rez = a.rez + b.rez + 2 * buff;
}
NODE query(int pos, int l, int r, int ll, int rr) {
if (ll > r || rr < l) return {0, 0, 0};
if (l >= ll && r <= rr) return tree[pos];
int mid = (l + r) / 2;
NODE a = query(2 * pos, l, mid, ll, rr);
NODE b = query(2 * pos + 1, mid + 1, r, ll, rr);
NODE c = {0, 0, 0};
c.open = a.open + b.open - min(a.open, b.close);
c.close = a.close + b.close - min(a.open, b.close);
c.rez = a.rez + b.rez + 2 * min(a.open, b.close);
return c;
}
int main() {
cin >> s;
build(1, 0, s.size() - 1);
cin >> m;
for (int i = 0; i < m; i++) {
int x;
cin >> x;
int y;
cin >> y;
cout << query(1, 0, s.size() - 1, x - 1, y - 1).rez << endl;
}
return 0;
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
n = n - (n / 2 + n / 3 + n / 5 + n / 7 - n / 6 - n / 10 - n / 14 - n / 15 -
n / 21 - n / 35 + n / 30 + n / 42 + n / 70 + n / 105 - n / 210);
cout << n << endl;
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
const int N = 1 << 17, P = 1e9 + 7;
int n, Fib[N], s[N], a[18][N], b[18][N], c[N], d[N], e[N], f[N], Ans;
inline void re(int &x) { x += x >> 31 & P; }
void fwtor(int *f, int o) {
for (int l = 1; l < 131072; l <<= 1)
for (int i = 0; i < 131072; i += l << 1)
for (int j = i; j < i + l; j++)
if (!o)
re(f[j + l] += f[j] - P);
else
re(f[j + l] -= f[j]);
}
void fwtxor(int *f, int o) {
int x, y;
for (int l = 1; l < 131072; l <<= 1)
for (int i = 0; i < 131072; i += l << 1)
for (int j = i; j < i + l; j++) {
x = f[j];
y = f[j + l];
re(f[j] = x + y - P);
re(f[j + l] = x - y);
if (o) {
f[j] = (long long)f[j] * 500000004 % P;
f[j + l] = (long long)f[j + l] * 500000004 % P;
}
}
}
void fwtand(int *f, int o) {
for (int l = 1; l < 131072; l <<= 1)
for (int i = 0; i < 131072; i += l << 1)
for (int j = i; j < i + l; j++)
if (!o)
re(f[j] += f[j + l] - P);
else
re(f[j] -= f[j + l]);
}
int main() {
scanf("%d", &n);
for (int i = 1, x; i <= n; i++) {
scanf("%d", &x);
++s[x];
}
Fib[1] = 1;
for (int i = 2; i < 131072; i++) Fib[i] = (Fib[i - 1] + Fib[i - 2]) % P;
for (int i = 0; i < 131072; i++) {
a[__builtin_popcount(i)][i] = s[i];
d[i] = (long long)s[i] * Fib[i] % P;
e[i] = s[i];
}
for (int i = 0; i <= 17; i++) fwtor(a[i], 0);
for (int i = 0; i <= 17; i++)
for (int j = 0; j <= 17; j++)
if (i + j <= 17)
for (int k = 0; k < 131072; k++)
b[i + j][k] = (b[i + j][k] + (long long)a[i][k] * a[j][k]) % P;
for (int i = 0; i <= 17; i++) fwtor(b[i], 1);
for (int i = 0; i < 131072; i++)
c[i] = (long long)b[__builtin_popcount(i)][i] * Fib[i] % P;
fwtxor(e, 0);
for (int i = 0; i < 131072; i++) e[i] = (long long)e[i] * e[i] % P;
fwtxor(e, 1);
for (int i = 0; i < 131072; i++) e[i] = (long long)e[i] * Fib[i] % P;
fwtand(c, 0);
fwtand(d, 0);
fwtand(e, 0);
for (int i = 0; i < 131072; i++) f[i] = (long long)c[i] * d[i] % P * e[i] % P;
fwtand(f, 1);
for (int i = 0; i < 17; i++) Ans = (Ans + f[1 << i]) % P;
printf("%d", Ans);
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, w, res = 0, r[2000];
char s[2000][20][20];
vector<int> e[2000];
vector<pair<int, int> > ans;
vector<pair<int, pair<int, int> > > v;
int dif(int x, int y) {
int r = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) r += s[x][i][j] != s[y][i][j];
return r;
}
int find(int x) {
if (x != r[x]) r[x] = find(r[x]);
return r[x];
}
void join(int x, int y) {
x = find(x);
y = find(y);
if (rand() % 2) {
int t = x;
x = y;
y = t;
}
r[x] = r[y] = x;
}
void build(int cur, int from) {
if (from != -1) ans.push_back(make_pair(cur, from));
for (int i = 0; i < (int)e[cur].size(); i++) {
int v = e[cur][i];
if (v != from) build(v, cur);
}
}
int main() {
scanf("%d %d %d %d", &n, &m, &k, &w);
for (int i = 0; i < k; i++)
for (int j = 0; j < n; j++) scanf("%s", s[i][j]);
for (int i = 0; i < k; i++) {
for (int j = i + 1; j < k; j++) {
int dd = dif(i, j) * w;
v.push_back(make_pair(dd, make_pair(i + 1, j + 1)));
v.push_back(make_pair(dd, make_pair(j + 1, i + 1)));
}
v.push_back(make_pair(n * m, make_pair(i + 1, 0)));
v.push_back(make_pair(n * m, make_pair(0, i + 1)));
}
sort(v.begin(), v.end());
for (int i = 0; i <= k; i++) r[i] = i;
for (int i = 0; i < (int)v.size(); i++) {
int w = v[i].first;
int x = v[i].second.first;
int y = v[i].second.second;
if (find(x) != find(y)) {
res += w;
join(x, y);
e[x].push_back(y);
e[y].push_back(x);
}
}
printf("%d\n", res);
build(0, -1);
for (int i = 0; i < (int)ans.size(); i++)
printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int arr[m + 1];
map<int, int> mp;
set<int> st;
for (int i = 0; i < m; i++) {
cin >> arr[i];
mp[arr[i]]++;
st.insert(arr[i]);
if (st.size() == n) {
cout << 1;
st.clear();
for (auto it = mp.begin(); it != mp.end(); it++) {
mp[(*it).first]--;
if (mp[(*it).first] != 0) {
st.insert((*it).first);
}
}
} else
cout << 0;
}
cout << endl;
return 0;
}
| 1,300 | CPP |
import math
MOD = 10**9 + 7
l, r = map(int, input().split())
def calc(r):
cnt_o = 0
cnt_e = 0
x = 0
while cnt_o + cnt_e + (1 << x) <= r:
if not x & 1:
cnt_o += (1 << x)
else:
cnt_e += (1 << x)
x += 1
if x & 1:
cnt_e = r - cnt_o
else:
cnt_o = r - cnt_e
return cnt_o ** 2 + (cnt_e + 1) * cnt_e
print((calc(r) - calc(l-1)) % MOD)
| 1,800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int MAX = 100010;
int MOD = (long long)1000000000 + 7;
long long INF = 1e17;
const double pi = acos(-1);
const double EPS = 1e-10;
typedef pair<long long, int> P;
int main() {
int N;
string S;
cin >> N >> S;
int ans = 0;
for (int i = 0; i < N; i++) {
if (S[i] == '+') {
ans = max(ans + 1, 0);
} else {
ans = max(ans - 1, 0);
}
}
cout << ans << endl;
;
}
| 800 | CPP |
x, y=[int(i) for i in input().split()]
if y>1 and x>=y-1:
if y%2==0:
if x%2==1:
print("Yes")
else:
print("No")
if y%2==1:
if x%2==0:
print("Yes")
else:
print("No")
elif y==1 and x==0:
print("Yes")
else:
print("No") | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= 2 * n / 3; i++) printf("%d %d\n", i, 1);
for (int i = 1; i <= n - 2 * n / 3; i++) printf("%d %d\n", i * 2, 4);
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1LL << 31) - 1;
const long long int LINF = (1LL << 62) - 1;
const int NMAX = 100000 + 5;
const int MMAX = 100000 + 5;
const int KMAX = 100000 + 5;
const int PMAX = 100000 + 5;
const int LMAX = 100000 + 5;
const int VMAX = 100000 + 5;
int N, Q;
long long int V[NMAX];
long long int AIB[NMAX];
void update(int poz, int val) {
for (; poz <= N; poz += poz & (-poz)) AIB[poz] += val;
}
long long int query(int poz) {
long long int ans = 0;
for (; poz; poz -= poz & (-poz)) ans += AIB[poz];
return ans;
}
int main() {
int i, j, op, p;
int left, right, flipped;
scanf("%d%d", &N, &Q);
for (i = 1; i <= N; i++) {
update(i, 1);
V[i] = 1;
}
left = 1;
right = N;
while (Q--) {
scanf("%d", &op);
op--;
if (!op) {
scanf("%d", &p);
if (!flipped) {
if ((right - left + 1) - p >= p) {
for (i = left + p, j = left + p - 1; j >= left; i++, j--) {
update(i, V[j]);
V[i] += V[j];
}
left += p;
} else {
p = (right - left + 1) - p;
for (i = right - p, j = right - p + 1; j <= right; i--, j++) {
update(i, V[j]);
V[i] += V[j];
}
right -= p;
flipped ^= 1;
}
} else {
if ((right - left + 1) - p >= p) {
for (i = right - p, j = right - p + 1; j <= right; i--, j++) {
V[i] += V[j];
update(i, V[j]);
}
right -= p;
} else {
p = (right - left + 1) - p;
for (i = left + p, j = left + p - 1; j >= left; i++, j--) {
V[i] += V[j];
update(i, V[j]);
}
left += p;
flipped ^= 1;
}
}
} else {
scanf("%d%d", &i, &j);
i++;
if (!flipped)
printf("%I64d\n", query(left + j - 1) - query(left + i - 2));
else
printf("%I64d\n", query(right - i + 1) - query(right - j));
}
}
return 0;
}
| 2,200 | CPP |
array = []
h = 0
res = 0
cards = 0
maxi_cards = 10 ** 9 + 1
# maxi_cards = 30
while cards <= maxi_cards:
cards += 2 * (h + 1) + h
h += 1
array.append(cards)
len_array = len(array)
def search(array, n, begin, end):
if begin == end:
return begin
middle = (begin + end) // 2
# print(begin, end, middle)
if array[middle] <= n:
res = search(array, n, middle + 1, end)
else:
res = search(array, n, begin, middle)
return res
T = int(input())
for t in range(T):
n = int(input())
res = 0
# print(array)
while True:
# print("--")
# print("n", n)
# print(0, len_array)
r = search(array, n, 0, len_array)
# print("r", r)
cards = array[r - 1]
n -= cards
if r == 0:
break
res += 1
print(res)
| 1,100 | PYTHON3 |
n = int(input())
nums = list(map(int,input().split(" ")))
evens=[]
odds=[]
for item in nums:
if(item%2==0):
evens.append(item)
else:
odds.append(item)
if(len(odds) == 1):
print(nums.index(odds[0])+1)
else:
print(nums.index(evens[0])+1) | 1,300 | PYTHON3 |
K = int(input())
number = input()
number = list(number)
number = [int(i) for i in number]
number.sort()
sum = 0
for i in number:
sum += i
j = 0
while sum < K:
sum = sum + 9 - number[j]
j += 1
print(j) | 1,100 | PYTHON3 |
# Main maut ko takiya, aur kafan ko chadaar banakar audhta hoon!
a=int(input())
b=input()
ant=0
den=0
for i in b:
if(i=='A'):
ant+=1
else:
den+=1
if(ant==den):
print("Friendship")
elif(ant>den):
print("Anton")
else:
print("Danik")
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 110;
const int MAX_R = 3e4 + 100;
int n, r;
pair<int, int> p[2][MAX_N];
int idx[2];
int a[MAX_N];
bool cmp(pair<int, int> a, pair<int, int> b) {
return a.first + a.second > b.first + b.second;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> r;
int ai, bi;
for (int i = 0; i < n; ++i) {
cin >> ai >> bi;
int id = (bi < 0);
p[id][idx[id]].first = ai;
p[id][idx[id]++].second = bi;
}
sort(p[0], p[0] + idx[0]);
int ans = 0;
for (int i = 0; i < idx[0]; ++i) {
if (r >= p[0][i].first) {
r += p[0][i].second;
++ans;
}
}
int m = idx[1];
sort(p[1], p[1] + m, cmp);
vector<vector<int> > dp(m + 1, vector<int>(r + 1, 0));
dp[0][r] = ans;
for (int i = 0; i < m; ++i) {
for (int cr = 0; cr <= r; ++cr) {
if (cr >= p[1][i].first && cr + p[1][i].second >= 0) {
dp[i + 1][cr + p[1][i].second] =
max(dp[i + 1][cr + p[1][i].second], dp[i][cr] + 1);
}
dp[i + 1][cr] = max(dp[i + 1][cr], dp[i][cr]);
}
}
ans = 0;
for (int cr = 0; cr <= r; ++cr) ans = max(ans, dp[m][cr]);
cout << ans << endl;
return 0;
}
| 2,300 | CPP |
a=[]
n, k=input().split()
count=0
a= list(map(int, input().split()))
for i in range(int(n)):
if(int(k)>=(a[i])):
count=count+1
else:
for j in range(int(n)-i):
if(int(k)>=a[int(n)-j-1]):
#count=count+1
count=count+1
else:
break
break
print(count)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
cout << pow(2, (n / 2) + 1) - 2 << endl;
}
}
| 800 | CPP |
s = input().split('WUB')
res = ''
for i in s:
if i != '':
res += ' ' + i
print(res.strip()) | 900 | PYTHON3 |
import math
def main():
total = int(input())
x = [int(number) for number in input().split()]
y = [int(number) for number in input().split()]
dp = [[0,0,0] for i in range(total)]
dp[0][0] = 0
dp[0][1] = x[0]
dp[0][2] = y[0]
for i in range(1, total, 1):
dp[i][0] = max(dp[i-1][0], dp[i-1][1], dp[i-1][2])
dp[i][1] = max(dp[i-1][0], dp[i-1][2]) + x[i]
dp[i][2] = max(dp[i-1][0], dp[i-1][1]) + y[i]
print(max(dp[total-1][0], dp[total-1][1] ,dp[total-1][2]))
if __name__ == "__main__":
main() | 1,400 | PYTHON3 |
n = int(input())
times = [0] * 2880
for _ in range(n):
hh, mm = map(int, input().split(':'))
t = hh * 60 + mm
times[t] = 1
times[t + 1440] = 1
i = 0
res = -1
while i < 1440:
for j in range(i, i + 1440):
if times[j] == 1:
break
res = max(res, j - i)
i = j + 1
hh, mm = divmod(res, 60)
print('{:02d}:{:02d}'.format(hh, mm)) | 1,700 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, k, n) for (i = k; i < n; i++)
#define repr(i, k, n) for (i = k; i >= n; i--)
#define inf(i, s) for (i = s;; i++)
#define ll long long
#define pb(i) push_back(i)
#define pop pop_back();
#define all(s) s.begin(), s.end()
#define maxl 9223372036854775807
#define up upper_bound
#define lb lower_bound
#define mod 1000000007
#define vll vector<ll>
#define vii vector<int>
#define mkp make_pair
#define llsize 1000000000
template <typename T>
inline void debug(vector<T> v)
{
cout << "\ndebug(vector)\n";
ll i;
rep(i, 0, v.size()) cout << v[i] << " ";
cout << "\n\n";
} // debug<ll>(v);
inline bool prime(int n)
{
int i;
for (i = 2; i * i <= n; i++)
if (n % i == 0)
return false;
return true;
}
bool palindrome(string s)
{
for(int i=0;i<s.length()/2;i++)
{
if(s[i]!=s[s.length()-1-i])
return 0;
}
return 1;
}
void solve()
{
int n;
cin>>n;
vii odd;
vii even;
int flag=1;
if(n==2)
{
int a,b;
cin>>a>>b;
cout<<a<<" "<<b;
cout<<endl;
return;
}
else
{
for(int i=0;i<n;i++)
{
int a;
cin>>a;
if(a%2==0)
even.pb(a);
else
odd.pb(a);
}
for(int i=0;i<odd.size();i++)
{
cout<<odd[i]<<" ";
}
for(int i=0;i<even.size();i++)
{
cout<<even[i]<<" ";
}
cout<<endl;
}
return;
}
int main(void)
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--)
{
solve();
}
return 0;
} | 800 | CPP |
from sys import stdin;
def main():
'''
name: Kevin S. Sanchez
Problem: A. Theatre Square
'''
inp = stdin;
n,m,a = map(int, inp.readline().strip().split());
print(-n// a* (-m// a))
main()
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
double S, a, b, c, lx, rx, ly, ry, midx1, midx2, midy1, midy2, remy;
double g(double statx, double staty) {
return a * log(statx) + b * log(staty) + c * log(S - statx - staty);
}
double f(double statx) {
ly = 0;
ry = S;
for (int i = 1; i <= 1000; i++) {
midy1 = ly + (ry - ly) / 3;
midy2 = ry - (ry - ly) / 3;
if (g(statx, midy1) < g(statx, midy2))
ly = midy1;
else
ry = midy2;
}
remy = (ly + ry) / 2.0;
return g(statx, remy);
}
int main() {
cin >> S >> a >> b >> c;
lx = 0;
rx = S;
for (int i = 1; i <= 1000; i++) {
midx1 = lx + (rx - lx) / 3;
midx2 = rx - (rx - lx) / 3;
if (f(midx1) < f(midx2))
lx = midx1;
else
rx = midx2;
}
printf("%0.10lf %0.10lf %0.10lf\n", (lx + rx) / 2.0, remy,
S - (lx + rx) / 2.0 - remy);
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, i, k;
cin >> n >> k;
int a[n], c = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (i = 0; i < n; i += 3) {
if (a[i] <= 5 && a[i + 1] <= 5 && a[i + 2] <= 5) {
if ((a[i] += k) <= 5 && (a[i + 1] += k) <= 5 && (a[i + 2] += k) <= 5) c++;
}
}
cout << c;
}
| 800 | CPP |
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")
n,m=map(int,input().split())
a=input()
b=input()
fc=[]
t=0
for i in b:
while t<n and a[t]!=i:
t+=1
fc.append(t)
t+=1
t=n-1
bc=[]
for i in reversed(b):
while t>=0 and a[t]!=i:
t-=1
bc.append(t)
t-=1
ans=0
bc=bc[::-1]
for i in range(m-1):
ans=max(ans,bc[i+1]-fc[i])
print(ans)
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long cur[501][501];
long long pr[501][501];
int main() {
ios_base::sync_with_stdio(false);
long long n, m, b, mod;
cin >> n >> m >> b >> mod;
vector<long long> a;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
a.push_back(x);
}
pr[0][0] = 1;
for (int i = 0; i <= b; i++) {
pr[0][i] = 1;
}
for (auto i = 0; i < n; i++) {
for (auto lines = 0; lines <= m; lines++) {
for (auto errors = 0; errors <= b; errors++) {
cur[lines][errors] = pr[lines][errors];
if (errors >= a[i] && lines > 0) {
cur[lines][errors] =
(cur[lines][errors] + cur[lines - 1][errors - a[i]]) % mod;
}
}
}
memcpy(pr, cur, sizeof(cur));
}
cout << pr[m][b];
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
inline void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
inline void judge() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
int n;
struct bit {
long long sum[maxn];
inline void add(int x, long long v) {
while (x <= n) {
sum[x] += v;
x += (x & -x);
}
}
inline long long query(int x) {
long long res = 0;
while (x) {
res += sum[x];
x -= (x & -x);
}
return res;
}
} tree1, tree2;
int v[maxn], k, a, b, q;
int main() {
read(n);
read(k);
read(a);
read(b);
read(q);
for (int i = (1); i <= (q); i++) {
int op;
read(op);
if (op == 1) {
int d, aa;
read(d);
read(aa);
tree1.add(d, max(min(aa, b - v[d]), 0));
tree2.add(d, max(min(aa, a - v[d]), 0));
v[d] += aa;
}
if (op == 2) {
int p;
read(p);
long long ans =
tree1.query(p - 1) + tree2.query(n) - tree2.query(p + k - 1);
printf("%I64d\n", ans);
}
}
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
int n, m, k;
string s;
vector<int> g[1000010];
vector<int> ans, path;
int cnt;
int v[1000010], dep[1000010];
int find_path(int t) {
v[t] = 1;
ans.push_back(t);
if (ans.size() == cnt) {
return 1;
}
for (int i : g[t]) {
if (v[i]) continue;
if (find_path(i)) {
return 1;
}
}
ans.pop_back();
return 0;
}
void dfs(int t, int f) {
v[t] = 1;
dep[t] = path.size();
path.push_back(t);
int ok = 1;
for (int i : g[t]) {
if (i == f) continue;
if (!v[i]) {
dfs(i, t);
ok = 0;
}
}
if (ok && cnt) {
int x = -1, y = -1;
for (int i : g[t]) {
if (i == f) continue;
if (x == -1)
x = i;
else {
y = i;
break;
}
}
int l = -1, r = -1;
if ((dep[t] - dep[x] + 1) % 3 != 0) {
l = t;
r = x;
} else if ((dep[t] - dep[y] + 1) % 3 != 0) {
l = t;
r = y;
} else {
l = x;
r = y;
}
if (dep[l] > dep[r]) swap(l, r);
if (r != t) {
printf("%d\n", dep[r] - dep[l] + 2);
printf("%d ", t);
} else {
printf("%d\n", dep[r] - dep[l] + 1);
}
for (int i = dep[r]; i >= dep[l]; --i) {
printf("%d ", path[i]);
}
printf("\n");
cnt--;
}
path.pop_back();
}
void find_circle() {
memset(v, 0, sizeof(v));
dfs(1, 1);
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
cnt = (n + k - 1) / k;
memset(v, 0, sizeof(v));
if (find_path(1)) {
printf("PATH\n");
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); ++i) {
printf("%d ", ans[i]);
}
printf("\n");
} else {
cnt = k;
printf("CYCLES\n");
find_circle();
}
}
| 2,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n, k1, k2;
cin >> n >> k1 >> k2;
int max1 = 0;
int max2 = 0;
int x;
for (int j = 0; j < k1; j++) {
cin >> x;
if (x > max1) {
max1 = x;
}
}
for (int j = 0; j < k2; j++) {
cin >> x;
if (x > max2) {
max2 = x;
}
}
if (max1 > max2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 800 | CPP |
from collections import Counter
n = int(input())
count = Counter(list(map(int,input().split())))
total = count[4] + count[3] + count[2]// 2
count[1] -= count[3]
if (count[2] % 2 == 1):
total += 1
count[1] -= 2
if (count[1] > 0):
total += (count[1] + 3) // 4
print(total)
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define fastio ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL)
#define lli long long int
#define rep(i,n,z) for(int i=z;i<n;i++)
#define rrep(i,z) for(int i=z;i>=0;i--)
#define nl cout<<endl
#define vi vector<int>
#define vlli vector<long long int>
#define umap unordered_map
#define pb push_back
#define mp make_pair
#define ss second
#define ff first
#define ipair pair <int,int>
#define llipair pair <lli,lli>
#define pq priority_queue
#define displaymatrix(a,m,n) for(int i=0;i<m;i++){for(int j=0;j<n;j++)cout<<a[i][j]<<" ";cout<<endl;}
#define printarray(a,n) for(int i=0;i<n;i++){cout<<a[i]<<" ";}nl;
#define vinput(a,n) vlli a(n);rep(i,n,0)cin>>a[i]
#define ainput(a,n) rep(i,n,0)cin>>a[i]
#define SO(a) sort(a.begin(),a.end())
#define all(x) (x).begin(),(x).end()
#define SOP(a,comp) sort(a.begin(),a.end(),comp)
#define inf INT_MAX
#define endl '\n'
int main()
{
fastio;
int t;
cin>>t;
const int S = 5e5 + 5;
vector<bool> vis(S,false);
priority_queue <llipair> PQ;
queue <lli> Q;
int cust = 1;
while(t--){
lli ch,x,y;
cin>>ch;
if(ch == 1){
cin>>x;
PQ.emplace(x,-cust);
Q.push(cust);
cust++;
}
// cout<<Q.size()<<" "<<PQ.size()<<endl;
if(ch == 2){
while(vis[Q.front()])Q.pop();
cout<<Q.front()<<" ";
vis[Q.front()] = true;
Q.pop();
}
if(ch == 3){
while(vis[-PQ.top().ss])PQ.pop();
cout<<-PQ.top().ss<<" ";
vis[-PQ.top().ss] = true;
PQ.pop();
}
}
nl;
} | 1,400 | CPP |
import math as m
def solve():
n = int(input())
if n == 1:
print(4)
else:
l = []
a = 4*n
while len(l) < n:
flag = 1
for i in l:
if (a) % i == 0 or m.gcd(a,i) == 1:
flag = 0
break
if flag == 1:
l.append(a)
a-=1
print(*l)
if __name__ == '__main__':
for _ in range (int(input())):
solve() | 800 | PYTHON3 |
from sys import stdin
input()
print(max(sum(map(int, s.split())) for s in stdin.read().splitlines())) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, x, y;
vector<int> c;
cin >> m;
c.resize(m);
int sum = 0;
for (int i = 0; i < c.size(); i++) {
cin >> c[i];
sum += c[i];
}
cin >> x >> y;
int beginners = 0;
int k = 0;
for (int i = 0; i < c.size(); i++) {
int rest = sum - beginners;
if (beginners >= x && rest >= x && beginners <= y && rest <= y) k = i + 1;
beginners += c[i];
}
cout << k << endl;
return 0;
}
| 1,000 | CPP |
def func():
for i in range(n-1):
if (x[i][0] == x[i][1] == '1') or x[-1][1] == '1':
print('NO')
return
print('YES')
for _ in range(int(input())):
n = int(input())
a = list(input())
b = list(input())
x = list(zip(a, b))
func()
| 800 | PYTHON3 |
import re
message = input()
regex = re.compile('[^a-zA-Z]')
message = regex.sub('', message)
#print(message) regex.sub('', message) fasakh ay haja differente de [^a-zA-Z]
nbupper = sum(1 for c in message if c.isupper())
nblower = sum(1 for c in message if c.islower())
#print(nbupper)
#print(nblower)
if (nbupper>nblower):
print(message.upper())
else:
print(message.lower())
| 800 | PYTHON3 |
n = int(input(""))
output = ""
while n > 2:
output += "I hate that I love that "
n -= 2
if n % 2 == 0 and n > 0:
output += "I hate that I love it"
if n % 2 != 0:
output += "I hate it"
print(output)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400000 + 10;
int n, a[N];
namespace ZYH {
int n, T, stk[N], top;
struct Tree {
int lson, rson, val, id;
} tree[N];
struct Nod {
int l, r, rt, d;
};
int build() {
if (n == 0) return 0;
stk[top = 1] = 1;
for (int i = 2; i <= n; i++) {
while (top >= 1 && tree[i].val > tree[stk[top]].val) top--;
if (top)
tree[i].lson = tree[stk[top]].rson, tree[stk[top]].rson = i;
else
tree[i].lson = stk[1];
stk[++top] = i;
}
queue<Nod> q;
q.push((Nod){1, n, stk[1], 1});
int mx = 0;
while (q.size()) {
Nod now = q.front();
q.pop();
int l = now.l, r = now.r, rt = now.rt;
if (r == l) continue;
int mid = tree[rt].id;
if (l <= mid - 1) q.push((Nod){l, mid - 1, tree[rt].lson, now.d + 1});
if (r >= mid + 1) q.push((Nod){mid + 1, r, tree[rt].rson, now.d + 1});
mx = max(mx, now.d + 1);
}
return mx;
}
}; // namespace ZYH
int getDep(int l, int r) {
ZYH::n = r - l + 1;
for (int i = 1; i <= r - l + 1; i++) {
ZYH::tree[i].val = -a[i + l - 1];
ZYH::tree[i].id = i;
}
return ZYH::build();
}
int main() {
scanf("%d", &n);
int p1, p2;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i + n] = a[i];
if (a[i] == 1) {
p1 = i;
p2 = i + n;
}
}
int lef = 0, rig = n - 1;
while (rig - lef > 1) {
int mid = (lef + rig) >> 1;
int vL = getDep(p2 - mid, p2 - 1);
int vR = getDep(p1 + 1, p1 + n - 1 - mid);
if (vL <= vR) {
lef = mid;
} else {
rig = mid;
}
}
int ans = N, bst = 0;
for (int mid = max(lef - 2, 0); mid <= min(n - 1, lef + 2); mid++) {
int vL = getDep(p2 - mid, p2 - 1);
int vR = getDep(p1 + 1, p1 + n - 1 - mid);
if (ans > max(vL, vR) + 1) {
ans = max(vL, vR) + 1;
bst = mid;
}
}
printf("%d ", ans);
int id = bst + 1;
if (id < p1) {
printf("%d\n", p1 - id == n ? 0 : p1 - id);
} else {
printf("%d\n", p1 + n - id == n ? 0 : p1 + n - id);
}
}
| 2,700 | CPP |
n = int(input())
s = input()
i = 0
ans = 0
while i < n - 1:
if s[i] != s[i + 1]:
i += 1
i += 1
ans += 1
print(ans + int(i < n))
| 800 | PYTHON3 |
from sys import setrecursionlimit, exit, stdin
from math import ceil, floor, acos, pi
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
from functools import reduce
import itertools
setrecursionlimit(10**7)
RI=lambda x=' ': list(map(int,input().split(x)))
RS=lambda x=' ': input().rstrip().split(x)
dX= [-1, 1, 0, 0,-1, 1,-1, 1]
dY= [ 0, 0,-1, 1, 1,-1,-1, 1]
mod=int(1e9+7)
eps=1e-6
MAX=1000
#################################################
a, b, c = RI()
print(a*b + b*c + a*c - a - b -c +1)
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long 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 * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, x, y;
vector<int> e[200005];
long long f[200005][3];
int min3(int a, int b, int c) { return min(min(a, b), c); }
void dp(int x, int fa) {
for (int i = 0; i < e[x].size(); i++) {
int y = e[x][i];
if (y != fa) {
dp(y, x);
long long g0 = f[x][0], g1 = f[x][1], g2 = f[x][2];
f[x][0] = min(g1 + f[y][1], g0 + min3(f[y][0], f[y][1], f[y][2]) + 1);
f[x][1] = g1 + min3(f[y][0], f[y][1], f[y][2]) + 1;
f[x][1] = min(f[x][1], g2 + f[y][1]);
f[x][2] = g2 + min3(f[y][0], f[y][1], f[y][2]) + 1;
}
}
}
int main() {
n = read();
x = read();
y = read();
for (int i = 1; i <= n - 1; i++) {
int u = read(), v = read();
e[u].push_back(v);
e[v].push_back(u);
}
if (x >= y) {
for (int i = 1; i <= n; i++)
if (e[i].size() == n - 1) {
cout << (long long)(n - 2) * y + x;
return 0;
}
cout << (long long)(n - 1) * y;
return 0;
}
dp(1, 0);
long long ans = 1000000000;
for (int i = 0; i < 2; i++) ans = min(ans, f[1][i]);
cout << ans * y + (n - 1 - ans) * x;
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long sum = 1;
if (n >= 1) sum += 6 * n + ((n - 1) * n * 6) / 2;
cout << sum << endl;
return 0;
}
| 1,100 | CPP |
import math
for i in range(int(input())):
n = int(input())
print((n-1)//2)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int next_x[8] = {0, 1, -1, 0, 1, 1, -1, -1};
const int next_y[8] = {1, 0, 0, -1, 1, -1, -1, 1};
const int inf = 1e9 + 5;
const long long linf = 1e18 + 5;
const double PI = acos(-1.0);
const long double eps = 1e-6;
const int MAXN = 4e5 + 5;
const int N = 1e6;
const long long fix = 1e12;
int n, m;
queue<int> a, b;
int work() {
scanf("%d%d", &n, &m);
for (register int i = (1), I = (n) + 1; i < I; ++i) {
int t;
scanf("%d", &t);
a.push(t);
}
for (register int i = (1), I = (m) + 1; i < I; ++i) {
int t;
scanf("%d", &t);
b.push(t);
}
int ans = 1;
int aa = a.front();
a.pop();
int bb = b.front();
b.pop();
while (!a.empty() || !b.empty()) {
if (aa == bb) {
ans++;
aa = a.front(), a.pop();
bb = b.front(), b.pop();
} else if (aa > bb)
bb += b.front(), b.pop();
else
aa += a.front(), a.pop();
}
return printf("%d\n", ans);
}
int main() {
work();
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
ll mod = 10e+7;
void fast(bool tieIO = 1) {
cout << fixed << setprecision(9);
if (tieIO) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
}
void piSquared() {
int n;
cin >> n;
vll a(n), b(n), cT(n + 1), cD(n + 1);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
cT[a[i]]++;
cD[b[i]]++;
}
ll total = 1ll * n * (n - 1) * (n - 2) / 6;
for (int i = 0; i < n; i++) {
total -= 1ll * (cT[a[i]] - 1) * (cD[b[i]] - 1);
}
cout << total << '\n';
return;
}
int main() {
fast();
ll t;
cin >> t;
while (t--) {
piSquared();
}
return 0;
}
| 1,700 | CPP |
a=int(input())
b=[]
cnt=1
a=map(int,input().split())
for i in a:
b.append((i,cnt))
cnt+=1
b.sort()
b=b[::-1]
ans=0
cnt=0
for i in b:
ans+=i[0]*cnt+1
cnt+=1
print(ans)
for i in b:
print(i[1],end=" ")
| 900 | PYTHON3 |
l = input().split("+")
l.sort()
n = len(l)
for i in range(n-1):
print(l[i],end="")
print("+",end="")
print(l[n-1])
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[100], n, temp, m, ans;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < (n - 1); i++) {
for (int j = 0; j < n - i - 1; j++) {
if (a[j] < a[j + 1]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
for (int i = 0; i < n; i++) {
if (m % a[i] == 0) {
ans = max(0, m / a[i]);
cout << ans << endl;
return 0;
}
}
return 0;
}
| 900 | CPP |
for _ in range(int(input())):
S=input()
if S.endswith("po"):
print("FILIPINO")
elif S.endswith("mnida"):
print("KOREAN")
else:
print("JAPANESE") | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
unsigned long long n;
cin >> n;
unsigned long long arr[200000];
unsigned long long hash[200000] = {0};
unsigned long long dp[200000] = {0};
for (unsigned long long i = 0; i <= n; i++) {
cin >> arr[i];
hash[arr[i]]++;
}
dp[0] = 0;
dp[1] = hash[1];
for (unsigned long long i = 2; i < 200000; i++) {
dp[i] = max(dp[i - 2] + hash[i] * i, dp[i - 1]);
}
cout << dp[200000 - 1];
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, k, l = 0, first, a[200005], b[200005], c[200005] = {0};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
set<long long> second;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i];
if (c[a[i]] == 0) j++;
c[a[i]]++;
}
cout << n - j << endl;
if (j == n) {
for (i = 0; i < n; i++) cout << a[i] << " ";
return 0;
}
for (i = 0; i < n; i++) {
b[a[i]] = i;
}
vector<long long> v;
for (i = 1; i <= n; i++) {
if (!c[i]) v.push_back(i);
}
k = 0;
long long must[200005] = {0};
for (i = 0; i < n && k < v.size(); i++) {
if (a[i] > v[k] && b[a[i]] != i || must[a[i]])
a[i] = v[k], k++;
else
must[a[i]] = 1;
}
for (i = 0; i < n; i++) cout << a[i] << " ";
return 0;
}
| 1,500 | CPP |
l,r=map(int,input().split())
l=l-1
m=bin(l)
n=bin(r)
q=len(m)-3
j=len(n)-3
k=0
c=0
flag=1
for i in range(0,q):
if(i%2==0):
k=k+pow(2,i)
flag=0
else:
flag=1
c=c+pow(2,i)
x=pow(2,q)-1
z=l-x
if flag==1:
k=k+z
else:
c=c+z
odd1=k*k
even1=(c+1)*(c)
sum1=odd1+even1
k=0
c=0
flag=1
q=j
for i in range(0,q):
if(i%2==0):
k=k+pow(2,i)
flag=0
else:
flag=1
c=c+pow(2,i)
x=pow(2,q)-1
z=r-x
if flag==1:
k=k+z
else:
c=c+z
odd2=k*k
even2=(c+1)*(c)
sum2=odd2+even2
t=(sum2-sum1)%1000000007
print(t) | 1,800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
cout.tie(0);
int n, m, b;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < m; i++) {
cin >> b;
cout << upper_bound(a, a + n, b) - a << " ";
}
return 0;
}
| 1,300 | CPP |
def f(s):
if len(s)<2:
return 0
for i in range(len(s)-1):
if s[i]!=s[i+1]:
return 1+f(s[:i]+s[i+2:])
return 0
for tc in range(int(input())):
s=input()
if f(s)%2==0:
print("NET")
else:
print("DA") | 900 | PYTHON3 |
k = int(input())
l = int(input())
i=k
count =0
while i<l:
i = i*k
count = count+1
if i==l:
print("YES")
print(count)
else:
print("NO") | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int maxn = 1e5 + 10, MOD = 1e9 + 7;
int N;
int A[maxn];
vector<int> D;
long long Pow(long long, int, int);
int work(int);
int main() {
while (~scanf("%d", &N)) {
for (int i = 0; i < N; i++) scanf("%d", &A[i]);
sort(A, A + N);
int now, ans = 0;
for (int tmax = A[N - 1]; tmax >= 1; tmax--) {
now = work(tmax);
ans = (ans + now) % MOD;
}
ans = (ans + MOD) % MOD;
printf("%d\n", ans);
}
return 0;
}
int work(int tmax) {
if (tmax == 1) return 1;
D.clear();
int lim = sqrt(tmax);
for (int i = 1; i <= lim; i++)
if (tmax % i == 0) {
if (i * i == tmax)
D.push_back(i);
else
D.push_back(i), D.push_back(tmax / i);
}
sort(D.begin(), D.end());
int res = 1, now, tim, cnt = 0;
for (int i = 2; i <= (int)D.size(); i++) {
now = D[i - 1];
tim = lower_bound(A, A + N, now) - A;
res = (long long)res * Pow(i - 1, tim - cnt, MOD) % MOD;
cnt = tim;
}
int left = N - cnt;
res = (long long)res *
(Pow(D.size(), left, MOD) - Pow(D.size() - 1, left, MOD)) % MOD;
return res;
}
long long Pow(long long x, int n, int p) {
long long res = 1;
while (n) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
| 2,000 | CPP |
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
temp = [0 for i in range(32)]
ans = 0
for i in a[::-1]:
b = bin(i)[2:]
#print (b)
if b[0] == "1":
ans += temp[len(b) - 1]
#print (temp[len(b) - 1], "ds")
# for j in range(32):
# temp[j] += (i>>j) &1
temp[len(b) - 1] += i >> (len(b) - 1)
#print (temp)
print (ans)
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vec = vector<T>;
const int inf = pow(2, 57);
const int mod = 1e9 + 7;
int dx[8] = {1, 0, -1, 0, -1, 1, -1, 1};
int dy[8] = {0, 1, 0, -1, -1, -1, 1, 1};
const string alpha = "abcdefghijklmnopqrstuvwxyz";
int input() {
int tmp;
cin >> tmp;
return tmp;
}
string raw_input() {
string tmp;
cin >> tmp;
return tmp;
}
string readline() {
string s;
getline(cin, s);
return s;
}
template <class T>
void printx(T n) {
cout << n;
}
template <class T, class U>
void printx(pair<T, U> p) {
cout << "(" << p.first << "," << p.second << ")";
}
template <class T>
void printx(vector<T> v) {
cout << "{";
for (int i = 0; i < v.size(); i++) {
printx(v[i]);
if (i != v.size() - 1) printx(",");
}
cout << "}";
}
template <class T>
void print(T n) {
printx(n);
cout << endl;
}
template <class T>
void print(set<T> s) {
cout << "{";
for (auto(e) = s.begin(); (e) != s.end(); (e)++) {
if (e != s.begin()) printx(",");
printx(*e);
}
cout << "}" << endl;
}
template <class T, class U>
void print(map<T, U> mp) {
cout << "{";
for (auto(e) = mp.begin(); (e) != mp.end(); (e)++) {
cout << "(" << e->first << "," << e->second << ")";
}
cout << "}" << endl;
}
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n = input();
vector<int> arr;
for (int i = 0; i < n; i++) arr.push_back(input());
sort((arr).begin(), (arr).end());
print(min(arr.back() - arr[1], arr[n - 2] - arr.front()));
}
| 900 | CPP |
import math
a,b,x,y=map(int,input().split())
g=math.gcd(x,y)
x=x/g
y=y/g
ans=min(a//x,b//y)
print(int(ans)) | 1,000 | PYTHON3 |
'''
3 3
4 3 5
'''
from math import *
def solve():
n, s = map(int, input().split())
l = list(map(int, input().split()))
answer = sum(l)
if n == 1 and s == l[0]:
return 0
if answer < s:
return -1
minn = min(l)
answer = 0
for i in range(len(l)):
if l[i] > minn:
if answer + l[i] - minn >= s:
l[i] -= l[i] - minn
return min(l)
answer += l[i] - minn
l[i] -= l[i] - minn
ch = max(l)
ll = len(l)
p = ceil((s - answer) / len(l))
return ch - p
print(solve())
| 1,200 | PYTHON3 |
n=int(input())
arr=list(map(int,input().split()))
if n==1:
print(1,end=" "),print(1)
print(0)
print(1,end=" "),print(1)
print(0)
print(1,end=" "),print(1)
print(-arr[0])
else:
print("1",end=" ")
print(n)
for i in range(0,n):
print(-arr[i]*n,end=" ")
print()
print("1",end=" ") ,print(n-1)
for i in range(0,n-1):
print(arr[i]*(n-1),end=" ")
print()
print("2",end=" "),print(n)
for i in range(1,n-1):
print(0,end=" ")
print(arr[n-1]*(n-1))
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int64_t res = 0, res1;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '1') {
res1 = 1;
for (int j = 0; j < i; j++) res1 = (res1 * 2) % 1000000007;
for (int j = 0; j < s.size() - i - 1; j++) res1 = (res1 * 2) % 1000000007;
for (int j = 0; j < s.size() - i - 1; j++) res1 = (res1 * 2) % 1000000007;
res = (res + res1) % 1000000007;
}
}
cout << res;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
long long mpow(long long a, long long n, long long mod) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
n >>= 1;
}
return (long long)ret;
}
using namespace std;
vector<int> G[(int)(2e3 + 5)], rG[(int)(2e3 + 5)];
bool vis[(int)(2e3 + 5)];
int a[(int)(2e3 + 5)][(int)(2e3 + 5)], cnt = 0;
void dfs1(int x) {
cnt++;
vis[x] = 1;
for (int i = 0; i < G[x].size(); i++) {
int to = G[x][i];
if (!vis[to]) {
dfs1(to);
}
}
}
void dfs2(int x) {
vis[x] = 0;
cnt++;
for (int i = 0; i < rG[x].size(); i++) {
int to = rG[x][i];
if (vis[to]) dfs2(to);
}
}
void solve() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
if (a[i][j] > 0) {
G[i].push_back(j);
rG[j].push_back(i);
}
}
}
for (int i = 1; i <= n; i++) {
if (a[i][i] == 0) continue;
dfs1(i);
if (cnt < n) {
printf("NO\n");
return;
}
dfs2(i);
if (cnt == 2 * n) {
printf("YES\n");
return;
} else {
printf("NO\n");
return;
}
}
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 2,200 | CPP |
n = int(input())
lis = list(map(int,input().split()))
maxi = lis[-1]
k = n - 1
flag = 1
ans = []
if maxi > n:
flag = -1
if flag == -1:
print(-1)
else:
xtra = 0
points = []
if lis[0] == 0:
ans.append(maxi+1)
xtra = xtra + 1
points.append(0)
elif lis[0] == 1:
ans.append(0)
else:
flag = -1
if flag != -1:
for i in range(1,n):
l = lis[i]
if l == lis[i-1]:
ans.append(maxi+1)
xtra = xtra + 1
points.append(i)
else:
if lis[i] == lis[i-1] + 1:
ans.append(lis[i-1])
else:
dif = lis[i] - lis[i-1] - 1
if dif > xtra:
flag = -1
break
else:
for j in range(lis[i-1] + 1,lis[i]):
ans[points[0]] = j
points.pop(0)
xtra = xtra - 1
ans.append(lis[i-1])
if flag == -1:
print(-1)
else:
print(*ans,sep= " ") | 1,600 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.