solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int GRAPH_SIZE = 1050;
int pin[GRAPH_SIZE], s = 0, t = GRAPH_SIZE - 1;
long long dep[GRAPH_SIZE];
struct EDGE {
int u, v;
long long c;
};
vector<EDGE> e;
vector<int> each[GRAPH_SIZE];
bool bfs() {
queue<int> Q;
Q.push(s);
while (!Q.empty()) {
int now = Q.front();
Q.pop();
for (auto it : each[now]) {
int next = e[it].v;
if (e[it].c)
if (dep[next] > dep[now] + 1) {
dep[next] = dep[now] + 1;
Q.push(next);
}
}
}
return dep[t] != INF;
}
long long dfs(int now, long long flow) {
if (now == t) {
return flow;
}
for (int& i = pin[now]; i < each[now].size(); i++) {
int it = each[now][i];
if (e[it].c && dep[e[it].v] == dep[now] + 1) {
long long tmp;
if (tmp = dfs(e[it].v, min(flow, e[it].c))) {
e[it].c -= tmp;
e[it ^ 1].c += tmp;
return tmp;
}
}
}
return 0ll;
}
long long Dinic() {
long long max_flow = 0;
for (int i = 0; i < GRAPH_SIZE; ++i) {
dep[i] = INF;
}
dep[s] = 0;
while (bfs()) {
for (int i = 0; i < GRAPH_SIZE; ++i) {
pin[i] = 0;
}
long long tmp;
while (tmp = dfs(s, INF)) {
max_flow += tmp;
}
for (int i = 0; i < GRAPH_SIZE; ++i) {
dep[i] = INF;
}
dep[s] = 0;
}
return max_flow;
}
void make_edge(int U, int V, long long C) {
EDGE tmp;
tmp.u = U;
tmp.v = V;
tmp.c = C;
e.push_back(tmp);
each[U].push_back(e.size() - 1);
swap(tmp.u, tmp.v);
tmp.c = 0;
e.push_back(tmp);
each[V].push_back(e.size() - 1);
}
void init() {
e.clear();
for (int i = 0; i < GRAPH_SIZE; ++i) {
each[i].clear();
}
}
int a[1001];
vector<pair<int, int> > edge;
int answer[1001];
vector<int> b;
int ans[1001];
bool in[GRAPH_SIZE];
void tour(int now) {
in[now] = 1;
for (auto it : each[now]) {
if (e[it].c && !in[e[it].v]) {
tour(e[it].v);
}
}
}
void solve(vector<int> v, int l, int r) {
if (l == r || v.empty()) {
for (auto it : v) ans[it] = b[l];
return;
}
memset(in, 0, sizeof(in));
for (auto it : v) in[it] = 1;
init();
int mid = (l + r) / 2;
for (auto it : v) {
make_edge(s, it, (long long)(1e13) + abs(b[mid + 1] - a[it]));
make_edge(it, t, (long long)(1e13) + abs(b[mid] - a[it]));
}
for (auto it : edge) {
int u, v;
tie(u, v) = it;
if (in[u] && in[v]) make_edge(v, u, INF);
}
Dinic();
memset(in, 0, sizeof(in));
tour(s);
vector<int> L, R;
for (auto it : e) {
int u, v;
u = it.u;
v = it.v;
if (in[u] && !in[v]) {
if (u == s) {
R.push_back(v);
}
if (v == t) {
L.push_back(u);
}
}
}
sort(L.begin(), L.end());
L.erase(unique(L.begin(), L.end()), L.end());
sort(R.begin(), R.end());
R.erase(unique(R.begin(), R.end()), R.end());
solve(L, l, mid);
solve(R, mid + 1, r);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
edge.push_back(make_pair(u, v));
}
for (int i = 1; i <= n; ++i) b.push_back(a[i]);
sort(b.begin(), b.end());
b.erase(unique(b.begin(), b.end()), b.end());
vector<int> v;
for (int i = 1; i <= n; ++i) v.push_back(i);
solve(v, 0, b.size() - 1);
for (int i = 1; i <= n; ++i) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 14 | CPP |
#include<stdio.h>
#include<string.h>
char so[30001];
int main(){
int t,i,j,c,b;
memset(so,0,sizeof(so));
for(i=2;i*i<=30000;i++){
for(j=2*i;j<=30000;j+=i){
so[j]=1;
}
}
while(scanf("%d",&t)){
if(t==0)break;
c=0;
for(i=2;i<=t/3+1;i++){
if(t%2==0 && c==1)break;
if(i!=2 && i%2==0)++i;
if(i!=3 && i%3==0)++i;
if(i!=5 && i%5==0)++i;
if(i!=7 && i%7==0)++i;
for(j=(i>t/2-i-1?i:t/2-i-1);j<=t/2+1;j++){
if(t<i+j+j)break;
/* if(j!=2 && j%2==0)continue;
if(j!=3 && j%3==0)continue;
if(t-i-j!=2 && (t-i-j)%2==0)continue;
if(t-i-j!=3 && (t-i-j)%3==0)continue;
*/ if(2*(i+j)<=t)continue;
if(so[i]==0 && so[j]==0 && so[t-i-j]==0)++c;
}
}
// if(t%100==0){
printf("%d\n",c);
// }
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
bool onmp(int x,int y){return x>=0&&y>=0&&x<n&&y<n;}
int count(int x,int y,const vector<string> &A){
int res=0;
for(int i=-1;i<=1;i++)
for(int j=-1;j<=1;j++){
int nx = x+i,ny = y+j;
if((!i&&!j)||!onmp(nx,ny))continue;
res += A[ny][nx]=='#'||A[ny][nx]=='@';
}
return res;
}
bool check(const vector<string> &A){
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)if(A[i][j]=='#')return 0;
return 1;
}
vector<string> mkmp(const vector<string> &A){
vector<string> res(n,string(n,'.'));
for(int i=0;i<n;i++)
for(int j=0;j<n;j++){
int cnt = count(j,i,A);
if(A[i][j]=='#')res[i][j]=(cnt==2||cnt==3)? '#':'.';
if(A[i][j]=='.')res[i][j]=(cnt==3)? '#':'.';
if(A[i][j]=='@')res[i][j]='@';
}
return res;
}
map<vector<string>,int> mem;
int ans,flg;
void dfs(int x,int y,int cnt,vector<string> A){
if(check(A))ans=min(cnt,ans),flg=1;
if(cnt>=ans) return;
if(mem.count(A)&&mem[A]<=cnt)return;
mem[A]=cnt;
A[y][x] = '.';
for(int dy=-1;dy<=1;dy++){
for(int dx=-1;dx<=1;dx++){
int nx = x+dx,ny = y+dy;
if((!dx&&!dy)||!onmp(nx,ny)||A[ny][nx]=='#')continue;
A[ny][nx] = '@';
dfs(nx,ny,cnt+1,mkmp(A));
A[ny][nx] = '.';
}
}
}
int main(){
while(cin>>n,n){
vector<string> mp(n);
for(int i=0;i<n;i++)cin>>mp[i];
int sx,sy;
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)if(mp[i][j]=='@')sy=i,sx=j;
ans = 10;flg=0;
mem.clear();
dfs(sx,sy,0,mp);
cout<<(flg? ans:-1)<<endl;
}
return 0;
} | 0 | CPP |
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n = int(input())
left, right = 1, 30
while left < right:
mid = right - (right - left) // 2
cur = (4 ** mid - 1) * 2 // 3 - 2 ** mid + 1
if cur <= n: left = mid
else: right = mid - 1
print(left) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename tn>
inline void read(tn &a) {
tn x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 + c - 48, c = getchar();
a = x * f;
}
struct line {
int l, r, v, id;
} a[400500], b[400500];
int n, m, ans_i, ans_j;
long long ans = 0;
bool cmp1(line p, line q) { return p.l < q.l; }
void solve1() {
sort(a + 1, a + n + 1, cmp1);
sort(b + 1, b + m + 1, cmp1);
int pos = 1, Max_rgt = 0, Max_i;
for (int i = 1; i <= m; i++) {
while (a[pos].l <= b[i].l && pos <= n) {
if (Max_rgt < a[pos].r) Max_rgt = a[pos].r, Max_i = pos;
pos++;
}
int l = b[i].l, r = min(Max_rgt, b[i].r);
long long tmp = (long long)(r - l) * b[i].v;
if (tmp > ans) ans = tmp, ans_i = a[Max_i].id, ans_j = b[i].id;
}
}
bool cmp2(line p, line q) { return p.r > q.r; }
void solve2() {
sort(a + 1, a + n + 1, cmp2);
sort(b + 1, b + m + 1, cmp2);
int pos = 1, Min_lft = 1e9, Min_i;
for (int i = 1; i <= m; i++) {
while (a[pos].r >= b[i].r && pos <= n) {
if (Min_lft > a[pos].l) Min_lft = a[pos].l, Min_i = pos;
pos++;
}
int l = max(Min_lft, b[i].l), r = b[i].r;
long long tmp = (long long)(r - l) * b[i].v;
if (tmp > ans) ans = tmp, ans_i = a[Min_i].id, ans_j = b[i].id;
}
}
struct node {
int ans, id;
};
node Max(node p, node q) {
if (p.ans > q.ans) return p;
return q;
}
struct Segment_tree {
struct Sgt_point {
int lc, rc, max, id;
} tree[400500 * 20];
int cnt, root;
void init() { cnt = 0; }
void push_up(int k, int son1, int son2) {
node p = {tree[son1].max, tree[son1].id},
q = {tree[son2].max, tree[son2].id};
node tmp = Max(p, q);
tree[k].max = tmp.ans, tree[k].id = tmp.id;
}
void modify(int &pos, int l, int r, int P, int x, int id) {
if (!pos) pos = ++cnt;
if (l == r) {
if (tree[pos].max < x) tree[pos].max = x, tree[pos].id = id;
return;
}
int mid = (l + r) / 2;
if (P <= mid)
modify(tree[pos].lc, l, mid, P, x, id);
else
modify(tree[pos].rc, mid + 1, r, P, x, id);
push_up(pos, tree[pos].lc, tree[pos].rc);
}
void modify(int P, int x, int id) { modify(root, 0, 1e9, P, x, id); }
node query(int pos, int l, int r, int L, int R) {
if (!pos) {
node p = {0, 0};
return p;
}
if (L <= l && R >= r) return (node){tree[pos].max, tree[pos].id};
int mid = (l + r) / 2;
node ans = {0, 0};
if (L <= mid) ans = query(tree[pos].lc, l, mid, L, R);
if (R >= mid) ans = Max(ans, query(tree[pos].rc, mid + 1, r, L, R));
return ans;
}
node query(int L, int R) { return query(root, 0, 1e9, L, R); }
} Sgt;
bool cmp3(line p, line q) { return p.r < q.r; }
void solve3() {
Sgt.init();
sort(a + 1, a + n + 1, cmp3);
sort(b + 1, b + m + 1, cmp3);
int pos = 1;
for (int i = 1; i <= m; i++) {
while (a[pos].r <= b[i].r && pos <= n)
Sgt.modify(a[pos].l, a[pos].r - a[pos].l, pos), pos++;
node p = Sgt.query(b[i].l, b[i].r);
long long tmp = (long long)p.ans * b[i].v;
if (tmp > ans) ans = tmp, ans_i = a[p.id].id, ans_j = b[i].id;
}
}
int main() {
read(n);
read(m);
for (int i = 1; i <= n; i++) read(a[i].l), read(a[i].r), a[i].id = i;
for (int i = 1; i <= m; i++)
read(b[i].l), read(b[i].r), read(b[i].v), b[i].id = i;
solve1();
solve2();
solve3();
cout << ans << endl;
if (ans) cout << ans_i << ' ' << ans_j << endl;
return 0;
}
| 7 | CPP |
def gcd(a,b):
if(b==0):
return a
else:
return gcd(b,a%b)
n = int(input())
x = list(map(int,input().split()))
i = 0
for i in range(n):
x[0] = gcd(x[0],x[i])
print(n*x[0])
| 7 | PYTHON3 |
t=int(input())
for _ in range(t):
n=int(input())
a=list(map(int,input().split()))
a=sorted(a)
if n==1:
print('YES')
else:
c=0
for i in range(n-1):
if a[i+1]-a[i]==0 or a[i+1]-a[i]==1:
c=0
else:
c=1
break
if c==0:
print('YES')
else:
print('NO') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool yes[3000010];
int main() {
int n, num = 1, last, count = 0, nu;
memset(yes, false, sizeof(yes));
scanf("%d", &n);
cout << 1;
last = n;
for (int i = 1; i <= n; i++) {
scanf("%d", &nu);
yes[nu] = true;
count = 0;
while (last >= 0 && yes[last]) {
last--;
count++;
}
num += (1 - count);
cout << " " << num;
}
return 0;
}
| 10 | CPP |
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<map>
#include<cstdlib>
#define ll long long
using namespace std;
bool used[100];
int a[100];
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
memset(used,0,sizeof(used));
int n;
scanf("%d",&n);
for(int i=1;i<=n;++i)
scanf("%d",a+i);
int ans=0;
for(int i=1;i<=n;++i)
for(int j=i+1;j<=n;++j)
if(!used[a[j]-a[i]])
{
used[a[j]-a[i]]=1;
++ans;
}
printf("%d\n",ans);
}
return 0;
} | 7 | CPP |
#include<cstdio>
using namespace std;
int main()
{
int n,A,B;
scanf("%d%d%d",&n,&A,&B);
if (n==1) printf("%d\n",A==B);
else printf("%lld\n",1ll*(A<=B)*(n-2)*(B-A)+(A<=B));
} | 0 | CPP |
if __name__ == '__main__':
n = int(input())
nums = list(map(int, input().split()))
if len(nums) % 2 == 0:
print("No")
elif nums[0] % 2 == 0 or nums[-1] % 2 == 0:
print("No")
else:
print("Yes")
| 7 | PYTHON3 |
x = int(input(''))
for ii in range(x):
aa = input('')
b = 0
c = 0
a = aa.strip('0')
for i in a:
if i == '1':
c += b
b = 0
if i == '0':
b += 1
print(c)
| 7 | PYTHON3 |
n,k = map(int,input().split())
if k<n:
ans = [1]
count = 0
for i in range(2,n+1):
if count == k:
ans.append(i+1)
else:
ans.append(i)
count+=1
hare = set(ans)
for i in range(1,n+1):
if i not in hare:
ans[0] = i
ans[-1] = 1
break
print(*ans)
else:
print(-1) | 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,k;
cin>>n>>k;
long long int val=0;
for(int i=0;i<n-1;i++){
val=val+(val/(k-1)+1);
}
cout<<val<<endl;
return 0;
} | 0 | CPP |
#http://codeforces.com/problemset/problem/281/D
#SC = TC = o(n)
n = int(input())
a = list(map(int, input().strip().split()))
stack = [] #decreasing stack
max_xor = 0
for k in range(n):
#if stack empty
if not stack:
stack.append(a[k])
#if less than top of stack
elif a[k]<stack[-1]:
max_xor = max(max_xor, a[k]^stack[-1])
stack.append(a[k])
#input will be distinct so no equal condition
#if greater than top of stack
elif a[k]>stack[-1]:
#pop and xor
while stack and a[k]>stack[-1]:
popped = stack.pop()
max_xor = max(max_xor, a[k]^popped)
#now if stack is not empty means below element is greater
#so xor will it and push #case 9 8 3 5 7
if stack:
max_xor = max(max_xor, a[k]^stack[-1])
stack.append(a[k])
print(max_xor) | 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char a[200011];
set<int> s[233];
struct BIT {
int a[200011];
BIT() { memset(a, 0, sizeof(a)); }
void add(int x, int v) {
for (; x <= n; x += x & -x) a[x] += v;
}
int query(int x) {
int ans = 0;
for (; x; x -= x & -x) ans += a[x];
return ans;
}
int find(int x) {
int now = 0, tot = 0;
for (int j = 20; j >= 0; j--) {
now += 1 << j;
if (now <= n && a[now] + tot < x)
tot += a[now];
else
now -= 1 << j;
}
return now + 1;
}
} t;
int main() {
scanf("%d%d", &n, &m);
scanf("%s", a + 1);
for (int i = 1; i <= n; i++) s[a[i]].insert(i);
for (int i = 1; i <= n; i++) t.a[i] = i & -i;
int x, y;
char id[5];
while (m--) {
scanf("%d%d%s", &x, &y, id);
int L = t.find(x), R = t.find(y);
set<int>::iterator it = s[id[0]].lower_bound(L);
for (; it != s[id[0]].end() && *it <= R;) {
set<int>::iterator tmp = it;
it++;
t.add(*tmp, -1);
s[id[0]].erase(tmp);
}
}
for (int i = 1; i <= n; i++)
if (t.query(i) - t.query(i - 1)) putchar(a[i]);
return 0;
}
| 12 | CPP |
import math
def delsfrom(a, b, delim):
return delfromzero(b, delim) - delfromzero(a, delim)
def delfromzero(a, delim):
return a // delim
for _ in range(int(input())):
n, k = map(int, input().split())
prev = k
a = delfromzero(prev, n)
next = prev + a
s = a
while a > 0:
a = delsfrom(prev, next, n)
prev = next
next = prev + a
s += a
print(k + s)
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
long long f(long long x, int n, int m) {
long long res = 0;
--x;
for (int i = 1; i <= n; ++i) res += min((long long)m, x / i);
return res;
}
int main() {
int n, m;
cin >> n >> m;
long long k;
cin >> k;
long long l = 1, r = 1LL * n * m + 1;
while (l < r) {
long long x = (l + r) >> 1;
if (f(x, n, m) < k)
l = x + 1;
else
r = x;
}
cout << l - 1 << endl;
return 0;
}
| 10 | CPP |
#include <stdio.h>
int main() {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
printf(c - b == b - a ? "YES\n" : "NO\n");
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 50, K = 22 + 1;
int n, k, T, trm[K], mt[K][K], nxt[N][K], f[1 << K];
char str[N];
inline bool have(int l, int r, int c) { return nxt[l - 1][c] <= r; }
inline int get_set(int l, int r) {
int ret = 0;
for (int i = 0; i < k; ++i)
if (have(l, r, i)) ret |= 1 << i;
return ret;
}
int main() {
scanf("%d%d%d%s", &n, &k, &T, str + 1);
for (int i = 0; i < k; ++i) scanf("%d", &trm[i]);
for (int i = 0; i < k; ++i)
for (int j = 0; j < k; ++j) scanf("%d", &mt[i][j]);
for (int i = 0; i < k; ++i) nxt[n][i] = nxt[n + 1][i] = n + 1;
for (int i = n - 1; i >= 0; --i)
for (int j = 0; j < k; ++j) {
if (str[i + 1] == 'A' + j)
nxt[i][j] = i + 1;
else
nxt[i][j] = nxt[i + 1][j];
}
for (int i = 0; i < k; ++i) f[1 << i] = trm[i];
for (int a = 0; a < k; ++a) {
for (int i = nxt[0][a]; nxt[i][a] <= n; i = nxt[i][a]) {
int s = get_set(i + 1, nxt[i][a] - 1);
f[s] += mt[a][a];
f[s | (1 << a)] -= mt[a][a];
}
}
for (int a = 0; a < k; ++a)
for (int b = 0; b < k; ++b)
if (a != b) {
for (int i = min(nxt[0][a], nxt[0][b]); min(nxt[i][a], nxt[i][b]) <= n;
i = min(nxt[i][a], nxt[i][b])) {
if (str[i] != 'A' + a || nxt[i][a] <= nxt[i][b]) continue;
int s = get_set(i + 1, nxt[i][b] - 1);
f[s] += mt[a][b];
f[s | (1 << a)] -= mt[a][b];
f[s | (1 << b)] -= mt[a][b];
f[s | (1 << a) | (1 << b)] += mt[a][b];
}
}
for (int i = 0; i < k; ++i)
for (int j = 0; j < (1 << k); ++j)
if (j >> i & 1) f[j] += f[j ^ (1 << i)];
int trashmask = 0;
for (int i = 0; i < k; ++i)
if (nxt[0][i] > n) trashmask |= 1 << i;
int ans = 0;
for (int i = 0; (i | trashmask) < (1 << k) - 1; ++i)
if (!(i & trashmask) && f[i] <= T) ++ans;
printf("%d\n", ans);
return 0;
}
| 9 | CPP |
from collections import*
n,*t=map(int,open(0).read().split())
e=[[]for _ in range(n)]
for v,w,c in zip(t[::3],t[1::3],t[2::3]):
e[v-1].append((w-1,c))
e[w-1].append((v-1,c))
q=deque([(0,0)])
f=[0]+[-1]*~-n
while q:
v,c=q.pop()
for w,d in e[v]:
if-1<f[w]:continue
d=(c+d)%2
f[w]=d
q.append((w,d))
print(*f,sep='\n') | 0 | PYTHON3 |
from sys import stdin, stdout
x, y, z = [int(x) for x in stdin.readline().rstrip().split()]
r1 = (x % z);
r2 = (y % z);
r = (r1 + r2) // z;
stdout.write( str((x + y) // z) + " ")
if r > 0:
if r1 > r2:
stdout.write( str(z - r1) + " \n" )
else:
stdout.write( str(z - r2) + " \n" )
else:
stdout.write(" 0\n") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> a(n);
int bla;
for (int i = 0; i < n; i++) {
scanf("%d%d", &bla, &a[i]);
}
int k;
scanf("%d", &k);
for (int i = 0; i < n; i++) {
if (k <= a[i]) {
printf("%d\n", n - i);
return 0;
}
}
return 0;
}
| 7 | CPP |
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
using namespace std;
int**dp;
void func(int N,int C){
int beat[N][16],push[C][16];
int maximum = 0;
for(int i = 0; i < N; i++){
for(int k = 0; k < 16; k++)scanf("%d",&beat[i][k]);
}
for(int i = 0; i < C; i++){
for(int k = 0; k < 16; k++)scanf("%d",&push[i][k]);
}
int tmp,S,code;
int work[C][16];
S = 1;
code = 0;
for(int i = 0; i < 16; i++){
code += S*beat[0][i];
S *= 2;
}
dp[1][code] = 0;
for(int k = 0; k < C; k++){
tmp = 0;
for(int p = 0; p < 16; p++){
work[k][p] = beat[0][p];
if(work[k][p] == 1){
if(push[k][p] == 1){
work[k][p] = 0;
tmp++;
}
}
}
S = 1;
code = 0;
for(int i = 0; i < 16; i++){
code += S*work[k][i];
S *= 2;
}
dp[1][code] = max(dp[1][code],tmp);
maximum = max(maximum,dp[1][code]);
}
for(int i = 1; i < N; i++){
for(int state = 0; state < 65536; state++){
if(dp[i][state] != -1){
S = 1;
code = 0;
for(int loop = 0; loop < 16; loop++){
if(state & (1 << loop)){
code += S;
}else{
code += S*beat[i][loop];
}
S *= 2;
}
dp[i+1][code] = dp[i][state];
for(int k = 0; k < C; k++){
tmp = 0;
for(int p = 0; p < 16; p++){
if(state & (1 << p)){
if(push[k][p] == 1){
work[k][p] = 0;
tmp++;
}else{
work[k][p] = 1;
}
}else{
work[k][p] = beat[i][p];
if(work[k][p] == 1){
if(push[k][p] == 1){
work[k][p] = 0;
tmp++;
}
}
}
}
S = 1;
code = 0;
for(int a = 0; a < 16; a++){
code += S*work[k][a];
S *= 2;
}
dp[i+1][code] = max(dp[i+1][code],tmp+dp[i][state]);
maximum = max(dp[i+1][code],maximum);
}
}
}
}
printf("%d\n",maximum);
}
int main(){
int N,C;
dp = new int*[31];
for(int i = 0; i < 31; i++){
dp[i] = new int[65536];
}
while(true){
scanf("%d %d",&N,&C);
if(N == 0 && C == 0)break;
for(int i = 0; i <= N; i++){
for(int k = 0; k < 65536; k++)dp[i][k] = -1;
}
func(N,C);
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
bool g;
int n, m[5001] = {0}, x;
cin >> n;
if (n % 2 == 1) {
v.push_back(1);
m[1] = 1;
} else {
v.push_back(2);
m[2] = 1;
}
while (true) {
g = false;
for (int i = 1; i <= n; i++) {
if (!m[i] && abs(v.back() - i) != 1) {
v.push_back(i);
m[i] = 1;
g = true;
}
}
if (!g) break;
}
cout << v.size() << "\n";
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
return 0;
}
| 7 | CPP |
array = []
count = 0
n = int(input())
i = n + 1
while True :
k = str(i)
for j in range(0, 4) :
array.append(int(k[j]))
for t in range(0, 10) :
if array.count(t) == 1 : count += 1
if count == 4 :
print(i)
break
else :
count = 0
array =[]
i += 1 | 7 | PYTHON3 |
#include<iostream>
using namespace std;
int main()
{
int n;
cin>>n;
int b,a;
int c=0;
cin>>c;
a=c;
b=c;
for(int i=1;i<n-1;i++)
{
cin>>b;
if(a>b) {
c+=b;}
else c+=a;
a=b;
}
c+=b;
cout<<c;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
while (scanf("%lld", &n) != EOF) {
for (long long i = 2; i * i <= n; i++) {
if (n % i) {
continue;
}
while ((n / i) % i == 0) {
n /= i;
}
}
printf("%lld\n", n);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const unsigned mod = 998244353;
const unsigned _mod = 1e9 + 7;
const long long infi = 0x3f3f3f3f3f3f3f3fll;
const int inf = 0x3f3f3f3f;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long qpow(long long x, long long y, long long m) {
long long ret = 1;
while (y) {
if (y & 1ll) ret = ret * x % m;
y >>= 1ll;
x = x * x % m;
}
return ret;
}
long long ksm(long long x, long long y) {
long long ret = 1;
while (y) {
if (y & 1ll) ret = ret * x % mod;
y >>= 1ll;
x = x * x % mod;
}
return ret;
}
long long _gcd(long long x, long long y) { return y ? _gcd(y, x % y) : x; }
string s;
int n, ans = 1, l;
int main() {
cin >> s;
s += s;
for (register int i = 0; i < s.size(); ++i) {
if (s[i] == s[i - 1]) l = i;
ans = max(ans, i - l + 1);
}
cout << min(ans, (int)s.length() / 2) << '\n';
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct Seg {
long long sum[100100 << 2];
int ma[100100 << 2], se[100100 << 2], cnt[100100 << 2];
void up(int o) {
sum[o] = sum[(o << 1)] + sum[((o << 1) | 1)];
ma[o] = max(ma[(o << 1)], ma[((o << 1) | 1)]);
cnt[o] = 0;
if (ma[o] == ma[(o << 1)]) cnt[o] += cnt[(o << 1)];
if (ma[o] == ma[((o << 1) | 1)]) cnt[o] += cnt[((o << 1) | 1)];
se[o] = max(se[(o << 1)], se[((o << 1) | 1)]);
if (ma[(o << 1)] != ma[((o << 1) | 1)])
se[o] = max(se[o], min(ma[(o << 1)], ma[((o << 1) | 1)]));
}
void build(int o, int l, int r) {
if (l == r) {
ma[o] = 0x3f3f3f3f;
sum[o] = 0x3f3f3f3f;
se[o] = -1;
cnt[o] = 1;
return;
}
build((o << 1), l, ((l + r) >> 1));
build(((o << 1) | 1), ((l + r) >> 1) + 1, r);
up(o);
}
void deal(int o, int val) {
if (val >= ma[o]) return;
sum[o] -= 1LL * cnt[o] * (ma[o] - val);
ma[o] = val;
}
void down(int o) {
deal((o << 1), ma[o]);
deal(((o << 1) | 1), ma[o]);
}
void update(int o, int l, int r, int y1, int y2, int val) {
if (val >= ma[o]) return;
if (y1 <= l && y2 >= r && val > se[o]) {
deal(o, val);
return;
}
down(o);
if (y1 <= ((l + r) >> 1)) update((o << 1), l, ((l + r) >> 1), y1, y2, val);
if (y2 > ((l + r) >> 1))
update(((o << 1) | 1), ((l + r) >> 1) + 1, r, y1, y2, val);
up(o);
}
long long query(int o, int l, int r, int y1, int y2) {
if (y1 <= l && y2 >= r) return sum[o];
long long ans = 0;
down(o);
if (y1 <= ((l + r) >> 1)) ans += query((o << 1), l, ((l + r) >> 1), y1, y2);
if (y2 > ((l + r) >> 1))
ans += query(((o << 1) | 1), ((l + r) >> 1) + 1, r, y1, y2);
return ans;
}
} tr[4][2];
set<int> hs[4];
int q, n = 100000, typ, l, r;
void solve(int u, int v, int w, int k) {
while (true) {
auto t = hs[u].lower_bound(l);
if (t != hs[u].end() && *t <= r) {
tr[u][0].update(1, 1, n, *t, *t, 0);
tr[u][1].update(1, 1, n, *t, *t, 0);
if (w != -1) {
tr[w][0].update(1, 1, n, *t, *t, 0);
tr[w][1].update(1, 1, n, *t, *t, 0);
}
hs[u].erase(t);
hs[v].insert(*t);
} else
break;
}
}
int main() {
scanf("%d", &q);
for (int i = 0; i < 4; ++i) {
tr[i][0].build(1, 1, n);
tr[i][1].build(1, 1, n);
}
for (int i = 1; i < n; ++i) hs[0].insert(i);
while (q--) {
scanf("%d%d%d", &typ, &l, &r);
--r;
if (typ == 1) {
int k;
scanf("%d", &k);
if (k > 0) {
for (int j = 0; j < 4; ++j) tr[j][0].update(1, 1, n, l, r, k);
solve(0, 2, 1, k);
solve(1, 3, -1, k);
} else {
for (int j = 0; j < 4; ++j) tr[j][1].update(1, 1, n, l, r, -k);
solve(0, 1, 2, -k);
solve(2, 3, -1, -k);
}
} else {
long long ans = 0;
for (int j = 0; j < 4; ++j) {
if (j == 0 || j == 3)
ans += tr[j][0].query(1, 1, n, l, r) + tr[j][1].query(1, 1, n, l, r);
else
ans -= tr[j][0].query(1, 1, n, l, r) + tr[j][1].query(1, 1, n, l, r);
}
printf("%I64d\n", ans);
}
}
return 0;
}
| 12 | CPP |
n,k,l,c,d,p,nl,np=map(int,input().split())
A=(k*l)//(n*nl)
B=(c*d)//n
C=p//(n*np)
print(min(A,B,C)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
class SegTree {
struct Node {
int l, r;
Node *left, *right;
bool delay;
long long int bits[10];
int change[10];
Node(int a, int b)
: l(a), r(b), left(nullptr), right(nullptr), delay(false) {
for (int i = 0; i < 10; ++i) {
change[i] = i;
bits[i] = 0;
}
}
};
public:
SegTree(vector<int> &arr) { root = create(arr, 0, arr.size() - 1); }
~SegTree() { del(root); }
void change(int a, int b, int prev, int now) {
if (prev != now) change(root, a, b, prev, now);
}
long long int sum(int a, int b) { return sum(root, a, b); }
private:
Node *root;
Node *create(vector<int> &arr, int a, int b) {
Node *root = new Node(a, b);
if (a == b) {
long long int i = 1;
while (arr[a]) {
root->bits[arr[a] % 10] += i;
arr[a] /= 10;
i *= 10;
}
} else {
int mid = (a + b) / 2;
root->left = create(arr, a, mid);
root->right = create(arr, mid + 1, b);
for (int i = 0; i < 10; ++i) {
root->bits[i] = root->left->bits[i] + root->right->bits[i];
}
}
return root;
}
void update(Node *p, int *change) {
vector<long long int> tmp(10, 0);
for (int i = 0; i < 10; ++i) {
tmp[change[i]] += p->bits[i];
}
for (int i = 0; i < 10; ++i) {
p->change[i] = change[p->change[i]];
p->bits[i] = tmp[i];
}
p->delay = true;
}
void change(Node *p, int a, int b, int prev, int now) {
if (a == p->l && b == p->r) {
p->bits[now] += p->bits[prev];
p->bits[prev] = 0;
for (int i = 0; i < 10; ++i) {
if (p->change[i] == prev) {
p->change[i] = now;
}
}
p->delay = true;
} else {
int mid = (p->l + p->r) / 2;
if (p->delay) {
update(p->left, p->change);
update(p->right, p->change);
p->delay = false;
for (int i = 0; i < 10; ++i) p->change[i] = i;
}
if (b <= mid) {
change(p->left, a, b, prev, now);
} else if (a > mid) {
change(p->right, a, b, prev, now);
} else {
change(p->left, a, mid, prev, now);
change(p->right, mid + 1, b, prev, now);
}
for (int i = 0; i < 10; ++i) {
p->bits[i] = p->left->bits[i] + p->right->bits[i];
}
}
}
long long int sum(Node *p, int a, int b) {
long long int ret = 0;
if (a == p->l && b == p->r) {
long long int tmp;
for (int i = 0; i < 10; ++i) {
tmp = p->bits[i];
tmp *= i;
ret += tmp;
}
} else {
int mid = (p->l + p->r) / 2;
if (p->delay) {
update(p->left, p->change);
update(p->right, p->change);
p->delay = false;
for (int i = 0; i < 10; ++i) p->change[i] = i;
}
if (b <= mid) {
ret = sum(p->left, a, b);
} else if (a > mid) {
ret = sum(p->right, a, b);
} else {
ret += sum(p->left, a, mid);
ret += sum(p->right, mid + 1, b);
}
}
return ret;
}
void del(Node *p) {
if (p == nullptr) return;
del(p->left);
del(p->right);
delete p;
}
};
int main() {
int n, q;
cin >> n >> q;
vector<int> v(n, 0);
for (int i = 0; i < n; ++i) {
int tmp;
cin >> tmp;
v[i] = tmp;
}
SegTree foo(v);
int op, a, b, c, d;
for (int i = 0; i < q; ++i) {
cin >> op;
if (op == 1) {
cin >> a >> b >> c >> d;
foo.change(--a, --b, c, d);
} else if (op == 2) {
cin >> a >> b;
cout << foo.sum(--a, --b) << '\n';
}
}
return 0;
}
| 12 | CPP |
n = int(input())
left, right = [], []
L = R = 0
for _ in range(n):
l,r = map(int, input().split())
left.append(l)
right.append(r)
L += l
R += r
max_k, max_i = abs(L-R), -1
for i in range(n):
Li = L - left[i] + right[i]
Ri = R - right[i] + left[i]
k = abs(Li-Ri)
if k > max_k:
max_k, max_i = k, i
print(max_i+1) | 8 | PYTHON3 |
#include <bits/stdc++.h>
const long long INF = (long long)0x3f3f3f3f3f3f3f, MAX = 9e18, MIN = -9e18;
const double PI = acos(-1.0);
const double eps = 1e-6;
const long long mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const int maxn = 500 + 10;
const int maxm = 100 + 10;
using namespace std;
int n, m, k;
int danger[12][12];
string s[maxn], t[maxn];
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
struct node {
int x, y;
};
int vis1[12][12];
int tim;
void getdanger(int x, int y) {
queue<node> q;
while (!q.empty()) {
q.pop();
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
vis1[i][j] = 0;
}
}
node now;
now.x = x;
now.y = y;
vis1[x][y] = 1;
q.push(now);
while (!q.empty()) {
now = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int xx = dir[i][0] + now.x;
int yy = dir[i][1] + now.y;
if (xx < 1 || yy < 1 || xx > n || yy > m ||
danger[xx][yy] < danger[now.x][now.y] + 1 || vis1[xx][yy] ||
s[xx][yy] == 'Y')
continue;
danger[xx][yy] = min(danger[now.x][now.y] + 1, danger[xx][yy]);
node tmp;
tmp.x = xx;
tmp.y = yy;
vis1[xx][yy] = 1;
q.push(tmp);
}
}
}
long long dis[12][12][12][12];
void getdis(int x, int y) {
queue<node> q;
while (!q.empty()) {
q.pop();
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
vis1[i][j] = 0;
}
}
node now;
now.x = x;
now.y = y;
vis1[x][y] = 1;
dis[x][y][x][y] = 0;
q.push(now);
while (!q.empty()) {
now = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
int xx = dir[i][0] + now.x;
int yy = dir[i][1] + now.y;
if (xx < 1 || yy < 1 || xx > n || yy > m || s[xx][yy] == 'Z' ||
s[xx][yy] == 'Y' || vis1[xx][yy] ||
dis[x][y][now.x][now.y] + 1 > danger[xx][yy])
continue;
dis[x][y][xx][yy] = min(dis[x][y][now.x][now.y] + 1, dis[x][y][xx][yy]);
if (dis[x][y][xx][yy] == danger[xx][yy]) {
if (t[xx][yy] > '9' || t[xx][yy] < '1') {
dis[x][y][xx][yy] = inf;
continue;
} else {
vis1[xx][yy] = 1;
continue;
}
}
vis1[xx][yy] = 1;
node tmp;
tmp.x = xx;
tmp.y = yy;
q.push(tmp);
}
}
}
int st, ed;
int cur[maxn];
int d[maxn];
struct edge {
int from, to, cap, flow;
};
vector<edge> edges;
vector<int> G[maxn];
void addedge(int from, int to, int cap, int flow) {
edges.push_back((edge){from, to, cap, 0});
edges.push_back((edge){to, from, 0, 0});
int sz = edges.size();
G[from].push_back(sz - 2);
G[to].push_back(sz - 1);
}
int vis[maxn];
bool bfs() {
queue<int> q;
d[st] = 0;
memset(vis, 0, sizeof(vis));
vis[st] = 1;
q.push(st);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < G[u].size(); i++) {
edge& e = edges[G[u][i]];
int v = e.to;
if (!vis[v] && e.cap - e.flow > 0) {
d[v] = d[u] + 1;
vis[v] = 1;
if (v == ed) return true;
q.push(v);
}
}
}
return false;
}
int dfs(int u, int a) {
if (u == ed || a == 0) return a;
int f, flow = 0;
for (int& i = cur[u]; i < G[u].size(); i++) {
edge& e = edges[G[u][i]];
int v = e.to;
if (d[v] == d[u] + 1 && e.cap - e.flow > 0) {
f = dfs(v, min(a, e.cap - e.flow));
e.flow += f;
edges[G[u][i] ^ 1].flow -= f;
flow += f;
a -= f;
if (a == 0) break;
}
}
return flow;
}
int maxflow() {
int flow = 0;
while (bfs()) {
memset(cur, 0, sizeof(cur));
flow += dfs(st, inf);
}
return flow;
}
void init() {
for (int i = 0; i < maxn; i++) G[i].clear();
edges.clear();
}
void run_case() {
cin >> n >> tim;
m = n;
init();
for (int i = 1; i <= n; i++) {
cin >> s[i];
s[i] = " " + s[i];
}
for (int i = 1; i <= n; i++) {
cin >> t[i];
t[i] = " " + t[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
danger[i][j] = inf;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (t[i][j] >= '1' && t[i][j] <= '9') {
danger[i][j] = inf;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i][j] == 'Z') {
danger[i][j] = 0;
getdanger(i, j);
}
}
}
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= n; y++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
dis[x][y][i][j] = INF;
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i][j] >= '1' && s[i][j] <= '9') {
getdis(i, j);
}
}
}
st = n * m * 2 + 10;
ed = st + 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i][j] <= '9' && s[i][j] >= '1') {
addedge(st, (i - 1) * m + j, s[i][j] - '0', 0);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (t[i][j] <= '9' && t[i][j] >= '1') {
addedge(n * m + (i - 1) * m + j, ed, t[i][j] - '0', 0);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (int x = 1; x <= n; x++) {
for (int y = 1; y <= m; y++) {
if (s[i][j] <= '9' && s[i][j] >= '1' && t[x][y] <= '9' &&
t[x][y] >= '1') {
if (dis[i][j][x][y] <= danger[x][y] && dis[i][j][x][y] <= tim) {
addedge((i - 1) * m + j, n * m + (x - 1) * m + y, inf, 0);
}
}
}
}
}
}
cout << maxflow() << "\n";
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
run_case();
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
const long long MOD = 1e9 + 7;
long long n, m, r, k;
set<pair<long long, long long> > vis;
map<pair<long long, long long>, pair<long long, long long> > store;
priority_queue<pair<long long, pair<long long, long long> >,
vector<pair<long long, pair<long long, long long> > > >
pq;
long long getrow(long long x) {
return min(x, min(n - x + 1, min(r, n - r + 1)));
}
long long getcol(long long y) {
return min(y, min(m - y + 1, min(r, m - r + 1)));
}
void addneighbours(long long x, long long y, long long r, long long c) {
for (long long dx = -1; dx <= 1; dx++) {
for (long long dy = -1; dy <= 1; dy++) {
long long newx = x + dx;
long long newy = y + dy;
pair<long long, long long> cur = {newx, newy};
if (vis.find(cur) != vis.end()) {
continue;
}
long long rowcontrib = getrow(newx);
long long colcontrib = getcol(newy);
pq.push(make_pair(rowcontrib * colcontrib, cur));
vis.insert(cur);
pair<long long, long long> cur2 = {rowcontrib, colcontrib};
store[cur] = cur2;
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m >> r >> k;
long long nosq = 1;
long long lensq = 1;
long long ans = 0;
if (n % 2 && m % 2) {
long long x = (n + 1) / 2;
long long y = (m + 1) / 2;
pair<long long, long long> p = {x, y};
long long rowcontrib = getrow(x);
long long colcontrib = getcol(y);
store[p] = {getrow(x), getcol(y)};
vis.insert(p);
pq.push(make_pair(rowcontrib * colcontrib, p));
} else if (n % 2 != m % 2) {
if (n % 2) swap(n, m);
long long x = (n + 1) / 2;
long long y = (m + 1) / 2;
pair<long long, long long> p = {x, y};
long long rowcontrib = getrow(x);
long long colcontrib = getcol(y);
store[p] = {getrow(x), getcol(y)};
vis.insert(p);
pq.push(make_pair(rowcontrib * colcontrib, p));
x = (n + 1) / 2 + 1;
y = (m + 1) / 2;
p = {x, y};
rowcontrib = getrow(x);
colcontrib = getcol(y);
store[p] = {getrow(x), getcol(y)};
vis.insert(p);
pq.push(make_pair(rowcontrib * colcontrib, p));
} else {
long long x = (n + 1) / 2;
long long y = (m + 1) / 2;
pair<long long, long long> p = {x, y};
long long rowcontrib = getrow(x);
long long colcontrib = getcol(y);
store[p] = {getrow(x), getcol(y)};
vis.insert(p);
pq.push(make_pair(rowcontrib * colcontrib, p));
x = (n + 1) / 2 + 1;
y = (m + 1) / 2;
p = {x, y};
rowcontrib = getrow(x);
colcontrib = getcol(y);
store[p] = {getrow(x), getcol(y)};
vis.insert(p);
pq.push(make_pair(rowcontrib * colcontrib, p));
x = (n + 1) / 2 + 1;
y = (m + 1) / 2 + 1;
p = {x, y};
rowcontrib = getrow(x);
colcontrib = getcol(y);
store[p] = {getrow(x), getcol(y)};
vis.insert(p);
pq.push(make_pair(rowcontrib * colcontrib, p));
x = (n + 1) / 2;
y = (m + 1) / 2 + 1;
p = {x, y};
rowcontrib = getrow(x);
colcontrib = getcol(y);
store[p] = {getrow(x), getcol(y)};
vis.insert(p);
pq.push(make_pair(rowcontrib * colcontrib, p));
}
while (k > 0) {
pair<long long, pair<long long, long long> > p = pq.top();
pq.pop();
k--;
pair<long long, long long> q = store[p.second];
ans += p.first;
addneighbours(p.second.first, p.second.second, q.first, q.second);
}
long double finans = ans;
finans /= (n - r + 1);
finans /= (m - r + 1);
cout << fixed << setprecision(12) << finans;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
char arr[105][105];
int n, res;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int x = 0; x < n; x++) {
for (int y1 = 0; y1 < n; y1++) {
for (int y2 = y1 + 1; y2 < n; y2++) {
if (arr[x][y1] == 'C' && arr[x][y2] == 'C') {
res++;
}
if (arr[y1][x] == 'C' && arr[y2][x] == 'C') {
res++;
}
}
}
}
cout << res << endl;
return 0;
}
| 7 | CPP |
N = int(input())
a = [int(t) for t in input().split()]
print(sum(a) - N)
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
if (n % 2 == 0)
for (int i = 1; i <= n; i += 2) cout << i + 1 << ' ' << i << ' ';
else {
cout << 1;
for (int i = 2; i <= n; i += 2) cout << ' ' << i + 1 << ' ' << i;
}
}
| 9 | CPP |
def main():
a, b = map(int, input().split())
h = b - a
a, b = map(int, input().split())
h -= a * 8
if h <= 0:
res = 0
elif a <= b:
res = -1
else:
a = (a - b) * 12
res = (h + a - 1) // a
print(res)
if __name__ == '__main__':
main()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return a > val ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
void solve() {
int n;
cin >> n;
vector<int> v;
for (int i = (0); i < (n); i++) {
int x;
cin >> x;
v.push_back(x);
}
sort((v).begin(), (v).end());
int q;
cin >> q;
while (q--) {
int m;
cin >> m;
cout << upper_bound((v).begin(), (v).end(), m) - v.begin() << "\n";
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
if (n % 2 != 0) {
cout << "0";
} else {
n /= 2;
long long val = 1;
for (int i = 0; i < n; i++) {
val *= 2;
}
cout << val;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
char a[100005];
int main() {
int n;
scanf("%d", &n);
scanf("%s", a);
int sum = 0, tot = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 'A')
sum++;
else
tot++;
}
if (sum > tot)
printf("Anton\n");
else if (sum < tot)
printf("Danik\n");
else
printf("Friendship\n");
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100001, maxD = 7001, maxP = 6;
bitset<maxD> init[maxD], ans[maxD], T[maxN];
bool sqfree[maxD];
void f0() {
for (int i = (1); (i) < (maxD); (i)++) {
sqfree[i] = true;
for (int j = i; j < maxD; j += i) init[j].set(i);
}
for (int i = (2); (i) < (maxD); (i)++)
for (int j = i * i; j < maxD; j += i * i) sqfree[j] = false;
for (int i = (1); (i) < (maxD); (i)++)
for (int j = (i); (j) < (maxD); (j)++)
if (j % i == 0 and sqfree[j / i]) ans[i].set(j);
}
int main() {
f0();
int n, q;
scanf("%d%d", &n, &q);
while (q--) {
int ev, i;
scanf("%d%d", &ev, &i);
if (ev == 1) {
int v;
scanf("%d", &v);
T[i] = init[v];
}
if (ev == 2) {
int a, b;
scanf("%d%d", &a, &b);
T[i] = T[a] ^ T[b];
}
if (ev == 3) {
int a, b;
scanf("%d%d", &a, &b);
T[i] = T[a] & T[b];
}
if (ev == 4) {
int v;
scanf("%d", &v);
printf("%d", (int)(T[i] & ans[v]).count() % 2);
}
}
printf("\n");
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O2,no-stack-protector,unroll-loops,fast-math")
const long long maxn = 1e2 + 10, maxm = 1e3 + 10, lg = 14, mod = 1e9 + 7,
inf = 1e11;
long long n;
pair<long long, long long> p[maxn];
long double C, T, dp[maxn][maxm];
long double get(long double d, long double t) { return d / (C * t + 1) + t; }
void MAIN() {
for (int i = 0; i < maxn; i++)
for (int j = 0; j < maxm; j++) dp[i][j] = inf;
cin >> n >> C >> T;
for (int i = 0; i < n; i++) cin >> p[i].first >> p[i].second;
sort(p, p + n);
dp[0][0] = 0;
for (int i = 0; i < n; i++)
for (int tt = i + 1; tt >= 1; tt--)
for (int ts = p[i].second; ts < maxm; ts++)
if (dp[tt - 1][ts - p[i].second] < inf)
dp[tt][ts] = min(
dp[tt][ts], (dp[tt - 1][ts - p[i].second] + p[i].first) * 10 / 9);
for (int ts = maxm; ts; ts--)
for (int tt = 1; tt <= n; tt++) {
if (dp[tt][ts] >= inf) continue;
long double TT = T - 10 * tt;
if (TT < 0) continue;
long double l = 0, r = TT, md1, md2;
for (int _ = 0; _ < 80; _++) {
md1 = (l + l + r) / 3, md2 = (l + r + r) / 3;
if (get(dp[tt][ts], md1) < get(dp[tt][ts], md2))
r = md2;
else
l = md1;
}
if (get(dp[tt][ts], l) <= TT) {
cout << ts << endl;
return;
}
}
cout << 0 << endl;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long tc;
cin >> tc;
while (tc--) MAIN();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
vector<long long> vis(n);
for (int i = 0, ggdem = m; i < ggdem; ++i) {
long long a, b, c;
cin >> a >> b >> c;
a--;
b--;
c--;
vis[b] = 1;
}
long long ve = -1;
for (int i = 0, ggdem = n; i < ggdem; ++i) {
if (vis[i] == 0) ve = i;
}
for (int i = 0, ggdem = n; i < ggdem; ++i) {
if (i != ve) {
cout << i + 1 << " " << ve + 1 << "\n";
}
}
}
return 0;
}
| 8 | CPP |
n=list(input())
ans=n+n[::-1]
print(''.join(ans)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> iP;
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
int main() {
while (1) {
int M, T, P, R;
cin >> M >> T >> P >> R;
if (M == 0) break;
int mt[60]{}, pt[60]{}, f[60][15]{};
REP(i, R) {
int m, t, p, j;
cin >> m >> t >> p >> j;
if (j==0) {
pt[t]++;
mt[t] += m + f[t][p] * 20;
} else {
f[t][p]++;
}
}
vector<pair<iP, int> > ls;
for (int i = 1; i <= T; i++) {
ls.push_back({{pt[i],1000000-mt[i]},i});
}
sort(ls.rbegin(),ls.rend());
cout << ls[0].second;
for(int i=1;i<T;i++){
if(ls[i-1].first == ls[i].first){
cout << "=";
}
else cout << ",";
cout << ls[i].second;
}
cout << endl;
}
return 0;
}
| 0 | CPP |
s = input()
for x in s:
if x != ' ' and x != '?':
t = x
if t in 'aeiouyAEIOUY':
print('YES')
else:
print('NO')
| 7 | PYTHON3 |
hello = ['h', 'e', 'l', 'l', 'o']
flag = True
s = input()
for a in hello:
if s.count(a) > 0:
k = s.index(a)
s = s[k+1:]
else:
flag = False
print('NO')
break
if flag:
print('YES') | 7 | PYTHON3 |
import sys
n, k = map(int, sys.stdin.readline().split())
for i in range(k):
if n % 10 == 0:
n = n // 10
else:
n = n - 1
print(n)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, b;
cin >> r >> b;
if (r > b) swap(r, b);
b = (b - r) / 2;
cout << r << " " << b << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e3 + 2;
const long long M = 2e5 + 5;
const long long Mod = 1e9 + 7;
int n, m, k;
pair<int, int> p[N];
int dp[N][2];
int Fact[M], invFact[M];
long long fp(long long x, long long y, long long m = Mod) {
long long res = 1;
for (int i = 0; (1LL << i) <= y; i++, x = x * x % m)
if (y & 1LL << i) res = res * x % m;
return res;
}
int C(int n, int k) {
if (n < 0 || k < 0 || n - k < 0) return 0;
return (long long)Fact[n] * invFact[k] % Mod * invFact[n - k] % Mod;
}
long long f(pair<int, int>& a, pair<int, int>& b) {
auto [i1, j1] = a;
auto [i2, j2] = b;
if (i1 > i2 || j1 > j2) return 0;
return C(i2 - i1 + j2 - j1, i2 - i1);
}
int main() {
Fact[0] = invFact[0] = 1;
for (int i = 1; i < M; i++)
Fact[i] = (long long)Fact[i - 1] * i % Mod,
invFact[i] = fp(Fact[i], Mod - 2);
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < k; i++) cin >> p[i].first >> p[i].second;
p[k++] = {1, 1};
p[k++] = {n, m};
sort(p, p + k);
dp[k - 1][1] = 1;
for (int i = k - 2; i >= 0; i--)
for (int b = 0; b <= 1; b++) {
for (int j = i + 1; j < k; j++)
dp[i][b] = (dp[i][b] + f(p[i], p[j]) * dp[j][!b] % Mod) % Mod;
}
cout << ((long long)dp[0][0] - dp[0][1] + Mod) % Mod << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define R(i,a,b) for(int i=a;i<b;i++)
int main(){
int t;
int a,b,c,d;
cin >> t;
while(cin >> a >> b >> c >> d){
int f1 = max(a,b);
int f2 = max(c,d);
if((f1 < c & f1 < d) | (f2<a) & f2 < b){
cout << "NO" <<endl;
}
else{
cout << "YES" << endl;
}
}
} | 7 | CPP |
a= (input())
b = input()
k = a.lower()
l = b.lower()
i = 0
for s in range(len(k)):
if(k[s]!=l[s]):
if(k[s]>=l[s]):
i=1
if(k[s]<=l[s]):
i=-1
break
print(i) | 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m,p;
while(1){
cin >> n >> m >> p;
if(n==0 && m==0){
if(p==0) break;
}
int x[n+1],sum=0;
for(int i=1;i<=n;i++){
cin >> x[i];
sum+=x[i];
}
sum*=100;
if(x[m]==0){
cout << 0 << endl;
}else{
sum=sum*100;
sum=sum-(sum/100*p);
sum=sum/100;
sum=sum/x[m];
cout << sum << endl;
}
}
}
| 0 | CPP |
n=int(input())
a=[]
a=list(map(int,input().split()))
a.sort()
k=1
c=0
for i in a:
if i>=k:
k+=1
print(k-1) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll maxL = 14;
ll dp[maxL+1][3][maxL*9+1][18601] = {0};
ll toLL(string str) {
stringstream ss; ss << str;
ll res; ss >> res;
return res;
}
int main() {
string strN; cin >> strN;
ll N = toLL(strN);
ll L = strN.size();
set<ll> s[maxL+1];
s[0].insert(1);
for (ll i = 0; i < L; ++i) {
for (set<ll>::iterator it = s[i].begin(); it != s[i].end(); ++it) {
for (ll j = 1; j <= 10; ++j) {
s[i+1].insert(*it * j);
}
}
}
ll ids = s[L].size();
vector<ll> prods;
for (set<ll>::iterator it = s[L].begin(); it != s[L].end(); ++it) {
prods.push_back(*it);
}
map<ll, ll> tbl;
for (ll i = 0; i < ids; ++i) {
tbl[prods[i]] = i;
}
ll G[18601][10]; fill(G[0], G[18601], -1);
for (ll i = 0; i < ids; ++i) {
for (ll j = 0; j < 10; ++j) {
ll v = prods[i]*(j+1);
if (tbl.count(v) > 0) {
G[i][j] = tbl[v];
}
}
}
dp[0][1][0][0] = 1;
for (ll i = 0; i < L; ++i) {
for (ll j = 0; j < 3; ++j) {
for (ll ds = 0; ds <= L*9; ++ds) {
for (ll k = 0; k < ids; ++k) {
if (dp[i][j][ds][k]) {
if (j == 1) {
ll dl = strN[i]-'0';
for (ll d = 0; d < 10; ++d) {
ll nj = d > dl ? 2 : d == dl ? 1 : 0;
dp[i+1][nj][ds+d][G[k][d]] += dp[i][j][ds][k];
}
}
else {
for (ll d = 0; d < 10; ++d) {
dp[i+1][j][ds+d][G[k][d]] += dp[i][j][ds][k];
}
}
}
}
}
}
}
ll KK = 1; for (ll i = 0; i < L; ++i) KK *= (strN[i]-'0')+1;
ll K = tbl[KK];
ll DS = 0; for (ll i = 0; i < L; ++i) DS += strN[i]-'0';
ll ans = 0;
for (ll j = 0; j < 3; ++j) {
for (ll ds = 0; ds <= DS; ++ds) {
for (ll k = 0; k < ids; ++k) {
if (ds < DS || (ds == DS && k < K) || (ds == DS && k == K && j != 2)) {
ans += dp[L][j][ds][k];
}
}
}
}
cout << ans-1 << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[100010];
vector<int> ans;
struct fuck {
int id, val;
} f[100010];
bool cmp(fuck a, fuck b) { return a.val > b.val; }
int root;
void dfs(int k, int fa) {
int cnt = 0;
for (int i = 0; i < v[k].size(); i++) {
if (v[k][i] == fa) continue;
cnt++;
dfs(v[k][i], k);
}
if (cnt == 0) ans.push_back(k);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) f[i].id = i;
for (int i = 1; i <= n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
f[a].val++;
f[b].val++;
}
sort(f + 1, f + 1 + n, cmp);
if (f[2].val >= 3) {
cout << "No" << endl;
return 0;
}
root = f[1].id;
dfs(root, 0);
cout << "Yes" << endl;
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) printf("%d %d\n", root, ans[i]);
return 0;
}
| 9 | CPP |
t = int(input())
for _ in range(t):
n, m, a, b = map(int, input().split())
if n * a == m * b:
print("YES")
L = [["0" for i in range(m)] for j in range(n)]
x = m * b
r, c = 0, 0
ss, st = 0, 0
for i in range(x):
L[r][c] = "1"
r += 1
c += 1
r %= n
c %= m
if r == ss and c == st:
if n <= m:
st += 1
c += 1
c %= m
else:
ss += 1
r += 1
r %= n
for i in range(n):
for j in range(m):
print(L[i][j], end = '')
print()
else:
print("NO") | 13 | PYTHON3 |
#include <bits/stdc++.h>
int main(int argc, char* argv[]) {
char dna[100];
int i, j, cont, seq;
gets(dna);
for (i = 0; dna[i] != '\0'; i++)
if (dna[i] != 'A' && dna[i] != 'C' && dna[i] != 'G' & dna[i] != 'T') {
printf(
"Error: the string contains characters not allowed; please "
"reinsert:\n");
gets(dna);
}
for (i = 0, cont = 0; dna[i] != '\0'; i = j) {
for (j = i, seq = 1; dna[j] == dna[i]; j++, seq++)
;
seq--;
if (seq % 2 == 0) cont++;
}
printf("%d\n", cont);
return 0;
}
| 7 | CPP |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int INF = (int)1e9 + 7;
int main() {
int n;
while (cin >> n, n) {
vector<int> a(n);
for (auto &ai: a) cin >> ai;
sort(begin(a), end(a));
int mi = INF;
for (int i = 0; i + 1 < n; i++) mi = min(mi, a[i + 1] - a[i]);
cout << mi << endl;
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int countSubstring(const std::string& str, const std::string& sub) {
if (sub.length() == 0) return 0;
int count = 0;
for (size_t offset = str.find(sub); offset != std::string::npos;
offset = str.find(sub, offset + sub.length()))
++count;
return count;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
string s1, s2;
cin >> s1 >> s2;
cout << countSubstring(s1, s2) << "\n";
return 0;
}
| 8 | CPP |
'''
5
3
3 5 6
3 2 3
5
1 2 3 4 5
5 4 3 2 1
3
1 1 1
2 2 2
6
1 1000000000 1000000000 1000000000 1000000000 1000000000
1 1 1 1 1 1
3
10 12 8
7 5 4
'''
def main():
amount_of_tests = int(input())
for _ in range(amount_of_tests):
n = int(input())
candies = [int(i) for i in input().split()]
oranges = [int(i) for i in input().split()]
min_candy = min(candies)
min_orange = min(oranges)
ts = []
for c, o in zip(candies, oranges):
to = o - min_orange
tc = c - min_candy
ts.append(max(to, tc))
print(sum(ts))
if __name__ == '__main__':
main() | 8 | PYTHON3 |
import math
n = (int(input()))
a = list(map(int , input().split()))
cnt_one = 0
for i in range(n):
if(a[i] == 1):
cnt_one += 1
if(cnt_one > 0):
print(n - cnt_one)
quit()
L = n + 1
for i in range(n):
cur = a[i]
for j in range(i , n):
cur = math.gcd(cur , a[j])
if cur == 1:
L = min(L , j - i + 1)
break
if(L == n + 1):
print(-1)
else:
print(L + n - 2)
| 7 | PYTHON3 |
import sys
import time
import math
from functools import lru_cache
INF = 10 ** 18 + 3
EPS = 1e-10
MAX_CACHE = 10 ** 9
MOD = 1 << 30
# Decorators
def time_it(function, output=sys.stderr):
def wrapped(*args, **kwargs):
start = time.time()
res = function(*args, **kwargs)
elapsed_time = time.time() - start
print('"%s" took %f ms' % (function.__name__, elapsed_time * 1000),
file=output)
return res
return wrapped
@lru_cache(MAX_CACHE)
def calc_prime_divs(n):
if n == 1:
return ()
sieve = [True] * (n // 2)
for i in range(3, int(n ** 0.5) + 1, 2):
if sieve[i // 2]:
sieve[i * i // 2::i] = [False] * ((n - i * i - 1) // (2 * i) + 1)
return (2,) + tuple(2 * i + 1 for i in range(1, n // 2) if sieve[i])
divisors = calc_prime_divs(100**3)
@lru_cache(MAX_CACHE)
def calc_num_of_divs(n):
if n == 1:
return 1
k = 1
for div in divisors:
if n < div:
return 2
while n % div == 0:
k += 1
n //= div
if k > 1:
return k * calc_num_of_divs(n)
@time_it
def main():
a, b, c = map(int, input().split())
print(sum(calc_num_of_divs(i * j * k) % MOD
for i in range(a, 0, -1)
for j in range(b, 0, -1)
for k in range(c, 0, -1)))
def set_input(file):
global input
input = lambda: file.readline().strip()
def set_output(file):
global print
local_print = print
def print(*args, **kwargs):
kwargs["file"] = kwargs.get("file", file)
return local_print(*args, **kwargs)
if __name__ == '__main__':
set_input(open("input.txt", "r") if "MINE" in sys.argv else sys.stdin)
set_output(sys.stdout)
main()
| 8 | PYTHON3 |
# code by RAJ BHAVSAR
for _ in range(int(input())):
n,k1,k2 = map(int,input().split())
first = list(map(int,input().split()))
second = list(map(int,input().split()))
maxx1,maxx2 = max(first),max(second)
if(maxx1 > maxx2):
print('YES')
else:
print('NO') | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int dirx[4] = {0, 0, -1, 1};
int diry[4] = {-1, 1, 0, 0};
char dir[4] = {'L', 'R', 'U', 'D'};
char revDir[4] = {'R', 'L', 'D', 'U'};
bool used[501][501];
char f[3000000];
int a[501][501];
int n, askjasf, asfxnv, sz;
void addToAnswer(char q) { f[sz++] = q; }
void dfs(int x, int y) {
used[x][y] = true;
if (a[x][y] == 0) {
a[x][y] = 1;
addToAnswer('1');
}
for (int i = 0; i < 4; ++i) {
for (int j = 1; j <= n; ++j) {
int xT, yT;
xT = x + j * dirx[i];
yT = y + j * diry[i];
if (xT >= 0 && xT < n && yT >= 0 && yT < n) {
if (a[xT][yT] == 0 || used[x + dirx[i]][y + diry[i]]) continue;
addToAnswer(dir[i]);
dfs(x + dirx[i], y + diry[i]);
addToAnswer(revDir[i]);
} else
break;
}
}
a[x][y] = 0;
addToAnswer('2');
}
int main() {
ios ::sync_with_stdio(false);
cin >> n >> askjasf >> asfxnv;
askjasf--;
asfxnv--;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) cin >> a[i][j];
dfs(askjasf, asfxnv);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (a[i][j] == 1) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
for (int i = 0; i < sz; ++i) cout << f[i];
}
| 11 | CPP |
#include<bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define rep(i, a, b) for(int i = (a); i < (b); ++i)
#define per(i, a, b) for(int i = (b) - 1; i >= (a); --i)
#define sz(a) (int)a.size()
#define de(c) cout << #c << " = " << c << endl
#define dd(c) cout << #c << " = " << c << " "
#define all(a) a.begin(), a.end()
#define pw(x) (1ll<<(x))
#define endl "\n"
typedef long long ll;
typedef double db;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef db T;
struct P{
T x,y; P(){} P(T x,T y):x(x),y(y){}
P operator - (const P&b) const {return P(x-b.x,y-b.y);}
P operator + (const P&b) const {return P(x+b.x,y+b.y);}
T operator * (const P&b) const {return x*b.x+y*b.y;}
P operator * (const T&k) const {return P(x*k,y*k);}
};
T norm(P a){return a*a;}
P proj(P p,P a,P b){return (b-a)*((p-a)*(b-a)/norm(b-a))+a;}
P a, b, p;
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
cin >> a.x >> a.y >> b.x >> b.y;
int q;
cin >> q;
cout << setiosflags(ios::fixed);
cout << setprecision(10);
while(q--) {
cin >> p.x >> p.y;
P r = proj(p, a, b);
cout << r.x << " " << r.y << endl;
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dp[10500], a[100005];
int main(void) {
int n;
int i, j, k;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 0; i <= 1024; i++) dp[i] = 5000;
dp[0] = 0;
for (i = 1; i <= n; i++) {
for (j = 1024; j >= 0; j--) {
if (a[i] > dp[j]) {
dp[j ^ a[i]] = min(dp[j ^ a[i]], a[i]);
}
}
}
int sum = 0;
for (i = 0; i <= 1024; i++) {
if (dp[i] != 5000) sum++;
}
printf("%d\n", sum);
for (i = 0; i <= 1024; i++)
if (dp[i] != 5000) printf("%d ", i);
}
| 12 | CPP |
n = int(input())
a = [int(i) for i in input().split()]
a.sort()
first = a.count(a[0])
last = a.count(a[len(a)-1])
if a[0] == a[len(a)-1]:
print(a[len(a)-1] - a[0], int((first * (first - 1)) / 2))
else:
print(a[len(a)-1] - a[0], first * last)
| 8 | PYTHON3 |
import bisect
import os
from collections import Counter
import bisect
from collections import defaultdict
import math
import random
import heapq as hq
from math import sqrt
import sys
from functools import reduce, cmp_to_key
from collections import deque
import threading
from itertools import combinations
from io import BytesIO, IOBase
from itertools import accumulate
# sys.setrecursionlimit(200000)
# mod = 10**9+7
def sort_dict(key_value):
return sorted(key_value.items(), key = lambda kv:(kv[1], kv[0]))
def list_input():
return list(map(int,input().split()))
def num_input():
return map(int,input().split())
def string_list():
return list(input())
for _ in range(int(input())):
a,b,x,y = num_input()
print(max((a-x-1)*b,x*b,a*y,a*(b-y-1)))
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
int a, b, x, y;
while (T--) {
cin >> a >> b >> x >> y;
cout << max({b * (a - x - 1), b * x, a * (b - y - 1), a * y}) << "\n";
}
return 0;
}
| 7 | CPP |
#include<iostream>
using namespace std;
int main()
{
int n;cin>>n;
cout<<(3*n*n);
return 0;
} | 0 | CPP |
string = input().split(' ')
a = int(string[0])
b = int(string[1])
string = input().split(' ')
yellow = int(string[0])
green = int(string[1])
blue = int(string[2])
needed = 0
aNeeded = yellow*2 + green
bNeeded = green + 3*blue
aAdditional = max(aNeeded-a, 0)
bAdditional = max(bNeeded-b, 0)
print(str(aAdditional + bAdditional)) | 7 | PYTHON3 |
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=1e5+5;
int n,m,k,x,y,cnt[maxn],fa[maxn],sum[maxn];
int findd(int x){
if(x==fa[x])
return x;
return fa[x]=findd(fa[x]);
}
int main(){
scanf("%d %d %d",&n,&m,&k);
for(int i=1;i<=n;i++){//初始化
sum[i]=1,fa[i]=i;
}
for(int i=1;i<=m;i++){
scanf("%d %d",&x,&y);
cnt[x]++,cnt[y]++;
if(findd(x)!=findd(y)){
sum[findd(y)]+=sum[findd(x)];
fa[findd(x)]=findd(y);
}
}
// for(int i=1;i<=n;i++){
// printf("%d ",sum[findd(i)]);
// }
// printf("\n");
for(int i=1;i<=k;i++){
scanf("%d %d",&x,&y);
if(findd(x)==findd(y)){
cnt[x]++,cnt[y]++;
}
}
for(int i=1;i<=n;i++){
int ans=sum[findd(i)]-cnt[i]-1;
printf("%d%c",ans,i==n?'\n':' ');
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
char S[100003];
int st[100003];
int len[100003];
int N;
void rin() {
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%s", S + st[i]);
len[i] = strlen(S + st[i]);
st[i + 1] = st[i] + len[i];
}
}
class poi {
public:
int l, r, mx, len;
bool same;
char lc, rc;
poi() {
l = 0;
r = 0;
mx = 0;
len = 0;
}
poi(char c) {
l = 1;
r = 1;
mx = 1;
len = 1;
lc = rc = c;
same = true;
}
};
inline poi mg(const poi &a, const poi &b) {
poi ans;
ans.lc = a.lc;
ans.rc = b.rc;
ans.len = a.len + b.len;
if (a.same)
ans.l = a.len + (a.rc == b.lc ? b.l : 0);
else
ans.l = a.l;
if (b.same)
ans.r = (a.rc == b.lc ? a.r : 0) + b.len;
else
ans.r = b.r;
ans.mx = max(a.mx, b.mx);
if (a.rc == b.lc) {
ans.mx = max(ans.mx, a.r + b.l);
ans.same = (a.same & b.same);
} else
ans.same = false;
return ans;
}
poi count(int x, poi last) {
poi ans;
ans = last;
for (int i = 0; i < len[x]; i++) {
ans = mg(ans, poi(S[st[x] + i]));
ans = mg(ans, last);
}
return ans;
}
void work() {
poi last;
last = poi(S[st[N - 1]]);
for (int i = 1; i < len[N - 1]; i++) last = mg(last, poi(S[st[N - 1] + i]));
poi u;
for (int i = N - 2; i >= 0; i--) {
u = count(i, last);
last = u;
}
printf("%d\n", last.mx);
}
int main() {
rin();
work();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 300010;
const double eps = 1e-8;
const int iinf = INT_MAX;
const long long linf = 2e18;
const double dinf = 1e30;
const int MOD = 1000000007;
inline int read() {
int X = 0, w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
return w ? -X : X;
}
void write(int x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
void print(int x) {
cout << x << '\n';
exit(0);
}
void PRINT(string x) {
cout << x << '\n';
exit(0);
}
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
int n, k;
int b[N], a[300000];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
int x;
cin >> x;
b[x]++;
}
priority_queue<pair<int, int> > pq, res;
for (int i = 0; i < 300000; i++) {
if (b[i]) pq.push({b[i], i});
}
for (int i = 0; i < k; i++) {
cout << pq.top().second << " ";
pair<int, int> h = pq.top();
pq.pop();
a[h.second]++;
h.first = b[h.second] / (a[h.second] + 1);
pq.push(h);
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll A,B,C,D;
cin >> A>>B>>C>>D;
if(D%2==0)cout <<A-B<<endl;
else cout <<B-A<<endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long MOD = 1000000007;
template <class T>
int getbit(T x, int pos) {
return (x >> (pos - 1)) & 1;
}
template <class T>
void turn_on(T &x, int pos) {
x = x | ((T)1 << (pos - 1));
}
template <class T>
void turn_off(T &x, int pos) {
x = x & ~((T)1 << (pos - 1));
}
template <class T>
T sqr(T a) {
return a * a;
}
int a[1000002], n;
long long f[1000002];
long long dp(int pos) {
if (f[pos] > -1) return f[pos];
int fn = min(a[pos], a[pos - 1]);
f[pos] = fn - 1;
fn = min(fn, a[pos + 1]);
f[pos] = (f[pos] + dp(pos + 1) * (fn - 1)) % MOD;
return f[pos];
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
a[n + 1] = inf + 1;
memset(f, -1, sizeof(f));
f[n + 1] = 0;
long long res = 0;
for (int i = 1; i <= n; ++i) {
int fn;
fn = min(a[i], a[i + 1]);
res = (res + a[i] - 1 + (fn - 1) * dp(i + 1)) % MOD;
}
printf("%I64d", res);
}
| 13 | CPP |
#include <bits/stdc++.h>
#define rep(i, a, n) for(int i = a; i < n; i++)
#define REP(i, n) rep(i, 0, n)
#define repb(i, a, b) for(int i = a; i >= b; i--)
#define all(a) a.begin(), a.end()
#define int long long
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
typedef pair<int, int> P;
const int mod = 1000000007;
const int INF = 1e12;
signed main(){
ios::sync_with_stdio(false);
cin.tie(0);
int t, n;
while(cin >> t >> n, t, n){
string s = to_string(n);
int l = s.size();
int MAX = -1;
vector<int> ans;
bool f = false;
rep(i, 0, (1LL << (l - 1))){
int now = s[0] - '0';
int sum = 0;
vector<int> tmp;
rep(j, 0, l - 1){
if(i & (1LL << j)){
tmp.push_back(now);
sum += now;
now = s[j + 1] - '0';
}else{
now = now * 10 + s[j + 1] - '0';
}
}
tmp.push_back(now);
sum += now;
if(sum <= t && MAX < sum){
MAX = sum;
ans = tmp;
f = true;
}else if(sum <= t && MAX == sum){
f = false;
}
}
if(MAX == -1) cout << "error" << endl;
else if(f == false) cout << "rejected" << endl;
else{
cout << MAX << " ";
for(int ii = 0; ii < ans.size(); ii++){
if(ii) cout << ' ';
cout << ans[ii];
}
cout << endl;
}
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
string a[4];
int main() {
cin >> a[0] >> a[1] >> a[2];
sort(a, a + 3);
if (a[0][1] == a[1][1] && a[1][1] == a[2][1]) {
if (a[0][0] == a[1][0] && a[1][0] == a[2][0]) {
printf("0\n");
return 0;
}
if (a[0][0] + 1 == a[1][0] && a[1][0] + 1 == a[2][0]) {
printf("0\n");
return 0;
}
}
if (a[0] == a[1] || a[0] == a[2] || a[1] == a[2]) {
printf("1\n");
return 0;
}
if ((a[0][0] + 1 == a[1][0] && a[0][1] == a[1][1]) ||
(a[0][0] + 1 == a[2][0] && a[0][1] == a[2][1]) ||
(a[1][0] + 1 == a[2][0] && a[1][1] == a[2][1])) {
printf("1\n");
return 0;
}
if ((a[0][0] + 2 == a[1][0] && a[0][1] == a[1][1]) ||
(a[0][0] + 2 == a[2][0] && a[0][1] == a[2][1]) ||
(a[1][0] + 2 == a[2][0] && a[1][1] == a[2][1])) {
printf("1\n");
return 0;
}
printf("2\n");
return 0;
}
| 8 | CPP |
q = int(input())
for i in range(q) :
n = int(input())
a = list(map(int,input().strip().split()))[:n]
flag = 1
a.sort()
for j in range(n-1) :
diff = a[j+1] - a[j]
if diff == 1 :
flag = 0
if flag == 1 :
print(1)
else :
print(2)
# 3
# 4 6 1 | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[100001];
long long gcd(long long a, long long b) {
if (a < b) return gcd(b, a);
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; ++i) cin >> arr[i];
sort(arr + 1, arr + (n + 1));
long long tot = 0;
long long pr = 0;
for (long long i = 1; i <= n; ++i) {
pr = i * (arr[i] - arr[i - 1]) + pr;
tot += pr;
}
pr = 0;
for (long long i = n - 1; i >= 1; --i) {
pr = (n - i) * (arr[i + 1] - arr[i]) + pr;
tot += pr;
}
cout << (tot / gcd(tot, n)) << " " << (n / gcd(tot, n)) << endl;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
#define For(i, j, k) for(int i = j; i <= k; i++)
#define pb push_back
using namespace std;
const int N = 1e5 + 10;
vector<int> G[N];
int n, sg[N];
void DFS(int o, int f){
for(int v : G[o]){
if(v == f) continue;
DFS(v, o);
sg[o] ^= sg[v] + 1;
}
}
int main(){
scanf("%d", &n);
For(i, 2, n){
int u, v;
scanf("%d%d", &u, &v);
G[u].pb(v), G[v].pb(u);
}
DFS(1, 0);
puts(sg[1] ? "Alice" : "Bob");
return 0;
} | 0 | CPP |
from itertools import combinations
import bisect
line = input()
l = len(line)
if l & 1:
ans = "4"*(l//2+1)+"7"*(l//2+1)
else:
if int(line)==10**9:
exit(print("4444477777"))
half = l//2
if line > "7"*half+"4"*half:
ans = "4"*(half+1)+"7"*(half+1)
# elif line <= "4"*half+"7"*half:
# ans = "4"*half+"7"*half
else:
lst = []
if l==2:
lst = ["47","74"]
elif l==4:
lst = ["4477","4747","4774","7447","7474","7744"]
elif l==6:
num = list("777777")
for i,j,k in combinations(range(6),3):
num[i]=num[j]=num[k]="4"
lst.append("".join(num))
num = list("777777")
elif l==8:
num = list("77777777")
for i,j,k,m in combinations(range(8),4):
num[i]=num[j]=num[k]=num[m]="4"
lst.append("".join(num))
num = list("77777777")
idx = bisect.bisect_left(lst,line)
ans = lst[idx]
print(ans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int long long p = 1000000007;
int k;
long long s, n[25], inv[25];
long long pow(long long a, long long b, long long p) {
long long ans = 1;
while (b) {
if (b % 2) ans = (ans * a) % p;
b /= 2;
a = (a * a) % p;
}
return ans;
}
void get_inv(long long n, long long p) {
inv[1] = 1;
for (long long i = 2; i <= n; i++) {
inv[i] = inv[p % i] * (p - p / i) % p;
}
}
int C(long long y, long long x) {
if (y < 0 || x < 0 || y < x) return 0;
y %= p;
if (y == 0 || x == 0) return 1;
long long ans = 1;
for (int i = 0; i < x; i++) {
ans = 1ll * ans * (y - i) % p;
}
for (int i = 1; i <= x; i++) {
ans = 1ll * ans * inv[i] % p;
}
return ans;
}
int main() {
get_inv(20, p);
scanf("%d%lld", &k, &s);
long long ans = C(k + s - 1, k - 1);
for (int i = 1; i <= k; i++) {
scanf("%lld", &n[i]);
}
for (int x = 1; x < 1 << k; x++) {
long long t = k + s, num = 0;
for (int i = 0; i < k; i++) {
if (x >> i & 1) num++, t -= n[i + 1];
}
t -= num + 1;
if (num % 2 == 1)
ans = (ans - C(t, k - 1)) % p;
else
ans = (ans + C(t, k - 1)) % p;
}
printf("%lld\n", (ans + p) % p);
return 0;
}
| 11 | CPP |
rn=lambda:int(input())
rl=lambda:list(map(int,input().split()))
rns=lambda:map(int,input().split())
rs=lambda:input()
yn=lambda x:print('Yes') if x else print('No')
YN=lambda x:print('YES') if x else print('NO')
for _ in range(rn()):
n=rn()
l=list(range(4*n,2*n,-2))
print(*l) | 7 | PYTHON3 |
# -*- coding: utf-8 -*-
"""
Created on Sun May 31 16:45:30 2020
@author: Mohit
"""
"""
Created on Sun May 31 16:25:54 2020
@author: Mohit
"""
x= input()
countl=0
countu=0
for i in x:
if(i.isupper()):
countu= countu+1
elif(i.islower()):
countl = countl+1
if(countl <countu):
print(x.upper())
else :
print(x.lower())
| 7 | PYTHON3 |
N = int(input())
AB = [list(map(int,input().split(' '))) for i in [0]*N]
AB.sort(key=lambda x:x[1])
t = 0
for a,b in AB:
t += a
if t > b:
print("No")
exit()
print("Yes")
| 0 | PYTHON3 |
n = int(input())
p = map(int, input().split())
p = [x - 1 for x in p]
b = map(int, input().split())
s = int(sum(b))
c = 0
done = set()
for i in range(n):
if i not in done:
c += 1
j = i
while j not in done:
done.add(j)
j = p[j]
modif = 0
if c > 1:
modif = c
res = modif + (s + 1) % 2
print(res)
| 7 | PYTHON3 |
n, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
#arr.sort()
i = 0
while True:
if k > 0 and i < len(arr) and arr[i] < 0:
arr[i] = arr[i] * (-1)
k -= 1
i += 1
else:
break
#print(arr)
arr.sort()
#print(arr)
if k % 2 == 1:
arr[0] = - arr[0]
print(sum(arr))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
string s1;
cin >> t;
while (t--) {
cin >> n;
cin.ignore();
getline(cin, s1);
int f1 = 0;
int l1 = 0;
bool ef1 = false;
for (int i = 0; i < n; i++) {
if (s1[i] == '1') {
f1 = i;
ef1 = true;
break;
}
}
for (int i = n - 1; i >= 0; i--) {
if (s1[i] == '1') {
l1 = i;
ef1 = true;
break;
}
}
if (ef1) {
f1 += 1;
l1 += 1;
cout << max(n + 1 - f1, l1) * 2;
} else
cout << n;
cout << endl;
}
return 0;
}
| 8 | CPP |
n = int(input())
a = list(map(int, input().split()))
a = a[::-1]
tans = a[0]
exist = a[0] - 1
for i in range(1, n):
tans += min(exist, a[i])
exist = min(exist, a[i]) - 1
if exist <= 0:
break
print(tans)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
map<string, string> ma;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int l = 0, u = 0, n = 0, t, i = 0, d = 0, mx2 = -1, g = 0, mul = 1,
m = 0, c = 0, x, y, j = 0, f = 0, k = 0, sum1 = 0, sum = 0,
s = 0, mn = INT_MIN, mx = INT_MAX;
string a;
cin >> a;
sum = (a[0] - '0') * 10 + (a[1] - '0');
f = (sum % 10) * 10 + sum / 10;
c = (a[3] - '0') * 10 + (a[4] - '0');
if ((sum == 5 && c > 49) or (sum > 5 && sum < 10)) {
cout << "10:01" << endl;
} else if ((sum == 15 && c > 50) or (sum > 15 && sum < 20)) {
cout << "20:02" << endl;
} else if (f > c) {
if (sum < 10) {
cout << "0";
}
cout << sum << ":";
if (f < 10) {
cout << "0";
}
cout << f << endl;
} else {
sum++;
sum %= 24;
if (sum < 10) {
cout << "0" << sum << a[2];
} else
cout << sum << a[2];
cout << sum % 10 << sum / 10 << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
enum class OperationType { no_op, set, add };
struct Operation {
OperationType type;
ll x;
};
Operation compose(Operation a, Operation b) {
if (a.type == OperationType::no_op) return b;
if (b.type == OperationType::no_op)
return a;
else if (b.type == OperationType::set)
return b;
else
return {a.type, a.x + b.x};
}
ll distance_to_next_power(ll x) {
auto power = 1LL;
while (power < x) power *= 42;
return power - x;
}
struct Segment {
ll closest_value;
ll distance;
int index;
Operation lazy_operation;
Segment(ll closest_value, ll distance, int index, Operation lazy_operation)
: closest_value(closest_value),
distance(distance),
index(index),
lazy_operation(lazy_operation) {}
Segment() : Segment(0, numeric_limits<ll>::max(), 0, {}) {}
Segment(int index, ll value)
: Segment(value, distance_to_next_power(value), index, {}) {}
void apply(Operation op) {
if (op.type == OperationType::no_op)
return;
else if (op.type == OperationType::set) {
closest_value = op.x;
distance = distance_to_next_power(closest_value);
} else {
closest_value += op.x;
distance -= op.x;
}
lazy_operation = compose(lazy_operation, op);
}
};
Segment operator+(Segment a, Segment b) {
auto c = a.distance <= b.distance ? a : b;
c.lazy_operation = {};
return c;
}
Segment& operator+=(Segment& a, Segment b) { return a = a + b; }
struct SegmentTree {
int n;
vector<Segment> data;
SegmentTree(int n, vector<int> initial) : n(n) {
data = vector<Segment>(2 * n);
for (auto i = 0; i < n; i++) data[n + i] = Segment(i, initial[i]);
for (auto i = n - 1; i >= 1; i--) data[i] = data[2 * i] + data[2 * i + 1];
}
Segment query(int a, int b) {
pull(a + n);
pull(b + n);
auto result = Segment();
for (auto i = a + n, j = b + n + 1; i < j; i /= 2, j /= 2) {
if (i % 2) result += data[i++];
if (j % 2) result += data[--j];
}
return result;
}
void pull(int i) {
if (i == 1) return;
auto parent = i / 2;
pull(parent);
propagate(parent);
}
void propagate(int i) {
auto op = data[i].lazy_operation;
data[2 * i].apply(op);
data[2 * i + 1].apply(op);
data[i].lazy_operation = {};
}
void update(int a, int b, Operation op) {
pull(a + n);
pull(b + n);
for (auto i = a + n, j = b + n + 1; i < j; i /= 2, j /= 2) {
if (i % 2) data[i++].apply(op);
if (j % 2) data[--j].apply(op);
}
push(a + n);
push(b + n);
}
void push(int i) {
for (i /= 2; i >= 1; i /= 2) {
auto op = data[i].lazy_operation;
data[i] = data[2 * i] + data[2 * i + 1];
data[i].apply(op);
}
}
ll point_query(int a) {
pull(a + n);
return data[a + n].closest_value;
}
void repeat_add(int a, int b, int k) {
add(a, b, k);
while (query(a, b).distance == 0) add(a, b, k);
}
void add(int a, int b, int k) {
update(a, b, {OperationType::add, k});
while (query(a, b).distance < 0) {
auto segment = query(a, b);
set(segment.index, segment.closest_value);
}
}
void set(int a, ll x) {
pull(a + n);
data[a + n] = Segment(a, x);
push(a + n);
}
};
int main() {
int n, q;
scanf("%d %d", &n, &q);
auto initial = vector<int>(n);
for (auto& x : initial) scanf("%d", &x);
auto tree = SegmentTree(n, initial);
for (auto i = 0; i < q; i++) {
int type;
scanf("%d", &type);
if (type == 1) {
int a;
scanf("%d", &a);
a--;
printf("%lld\n", tree.point_query(a));
} else if (type == 2) {
int a, b, x;
scanf("%d %d %d", &a, &b, &x);
a--;
b--;
tree.update(a, b, {OperationType::set, x});
} else if (type == 3) {
int a, b, x;
scanf("%d %d %d", &a, &b, &x);
a--;
b--;
tree.repeat_add(a, b, x);
} else
throw invalid_argument("Invalid operation type: " + to_string(type));
}
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int oo = 2139063143;
const int N = 6010;
const int P = 1000000007;
const double eps = 1e-7;
template <typename T>
inline void sc(T &x) {
x = 0;
static int p;
p = 1;
static char c;
c = getchar();
while (!isdigit(c)) {
if (c == '-') p = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c - 48);
c = getchar();
}
x *= p;
}
template <typename T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void pr(T x) {
print(x), putchar('\n');
}
template <typename T1, typename T2>
void chkmax(T1 &A, T2 B) {
A = A >= B ? A : B;
}
template <typename T1, typename T2>
void chkmin(T1 &A, T2 B) {
A = A <= B ? A : B;
}
int n, m, f, k;
int a[N][N];
int get(int lx, int rx, int ly, int ry) {
return a[rx][ry] - a[lx - 1][ry] - a[rx][ly - 1] + a[lx - 1][ly - 1];
}
int calc(int u) {
int ans = 0;
for (int i = 1, p = 1; i <= m; i++) {
while (p <= m && get(u, n, i, p) < k) ++p;
if (p > m) break;
ans += m - p + 1;
}
return ans;
}
vector<int> h[N], l[N];
int pre[N], suf[N], w[N], s[N];
void del(int x) {
--w[x];
if (!w[x]) suf[pre[x]] = suf[x], pre[suf[x]] = pre[x];
}
int q[N], he = 1, ta = 0;
int x[N], y[N];
int main() {
sc(n), sc(m), sc(f), sc(k);
for (int i = 1; i <= f; i++) {
sc(x[i]), sc(y[i]);
++a[x[i]][y[i]];
h[x[i]].push_back(y[i]), l[y[i]].push_back(x[i]);
}
for (int i = 1; i <= n; i++) sort(h[i].begin(), h[i].end());
for (int i = 1; i <= n + 1; i++)
for (int j = 1; j <= m + 1; j++)
a[i][j] += a[i][j - 1] + a[i - 1][j] - a[i - 1][j - 1] +
((i > n || j > m) ? 20 : 0);
long long ans = 0;
for (int u = 1; u <= n; u++) {
memset(w, 0, sizeof(int) * (m + 2));
for (int i = 1; i <= f; i++)
if (x[i] >= u) ++w[y[i]];
w[0] = w[m + 1] = n * m;
for (int i = 1; i <= m; i++) pre[i] = w[i - 1] ? i - 1 : pre[i - 1];
for (int i = m; i >= 1; i--) suf[i] = w[i + 1] ? i + 1 : suf[i + 1];
int an = calc(u);
ans += an;
for (int d = n; d > u; d--) {
for (int x : h[d]) {
he = k + 1, ta = k - 1;
he += 10, ta += 10;
for (int i = x, j = 0; i >= 0; i = pre[i]) {
q[--he] = i;
if (!i) break;
j += w[i];
if (j > k) break;
}
for (int i = x, j = 0; i <= m + 1; i = suf[i]) {
q[++ta] = i;
if (i == m + 1) break;
j += w[i];
if (j > k) break;
}
s[he - 1] = 0;
for (int i = he; i <= ta; i++) s[i] = s[i - 1] + w[q[i]];
for (int l = he + 1, r = k + 10; l <= k + 10; l++) {
while (r < ta && s[r] - s[l - 1] < k) ++r;
if (s[r] - s[l - 1] == k) an -= (q[l] - q[l - 1]) * (q[r + 1] - q[r]);
}
del(x);
}
ans += an;
}
}
pr(ans);
return 0;
}
| 12 | CPP |
from __future__ import division, print_function
# import threading
# threading.stack_size(2**27)
# import sys
# sys.setrecursionlimit(10**7)
# sys.stdin = open('inpy.txt', 'r')
# sys.stdout = open('outpy.txt', 'w')
from sys import stdin, stdout
import bisect #c++ upperbound
import math
import heapq
i_m=9223372036854775807
def inin():
return int(input())
def stin():
return input()
def spin():
return map(int,stin().split())
def lin(): #takes array as input
return list(map(int,stin().split()))
def matrix(n):
#matrix input
return [list(map(int,input().split()))for i in range(n)]
################################################
def string2intlist(s):
return list(map(int, s))
def calculate_sum(a, N): #sum of a to N
# Number of multiples
m = N / a
# sum of first m natural numbers
sum = m * (m + 1) / 2
# sum of multiples
ans = a * sum
return ans
def series(N):
return (N*(N+1))//2
def count2Dmatrix(i,list):
return sum(c.count(i) for c in list)
def modinv(n,p):
return pow(n,p-2,p)
def GCD(x, y):
x=abs(x)
y=abs(y)
if(min(x,y)==0):
return max(x,y)
while(y):
x, y = y, x % y
return x
def LCM (x, y):
return (x * y) // GCD(x, y)
def Divisors(n) :
l = []
for i in range(1, int(math.sqrt(n) + 1)) :
if (n % i == 0) :
if (n // i == i) :
l.append(i)
else :
l.append(i)
l.append(n//i)
return l
def isprime(n):
for i in range(2, int(math.sqrt(n))+1):
if n%i==0:
return False
return True
prime=[]
def SieveOfEratosthenes(n):
global prime
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
f=[]
for p in range(2, n):
if prime[p]:
f.append(p)
return f
q=[]
def dfs(n,d,v,c):
global q
v[n]=1
x=d[n]
q.append(n)
j=c
for i in x:
if i not in v:
f=dfs(i,d,v,c+1)
j=max(j,f)
# print(f)
return j
# d = {}
"""*******************************************************"""
for _ in range(inin()):
n = inin()
s = stin()
for i in range(n):
print(s[n-1], end="")
print()
# if n%2==0:
# print(s[:n//2]+s[+n//2-n:])
# else:
# if n==1:
# if s=='0':
# print(0)
# else:
# print(1)
# continue
# print(s[:n//2+1]+s[+(n//2+1)-n:])
# print(7//2) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, c;
cin >> a >> c;
if (a % 2 == 1) a++;
if (a + 2 > c)
cout << -1 << endl;
else
cout << a << " " << a + 1 << " " << a + 2 << endl;
return 0;
}
| 7 | CPP |
q=int(input())
for t in range(q):
s=input()
ans=[]
i=1
p=1
while i<len(s):
if s[i]==s[i-1]:
p+=1
else:
if p%2==1:
ans.append(s[i-1])
p=1
i+=1
if p%2==1:
ans.append(s[-1])
ans=list(set(ans))
ans.sort()
for i in range(len(ans)):
print(ans[i],end='')
print() | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
int n = 0, k = 0, w = 0, nopoc = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> w;
if (w % k == 0)
nopoc += w / k;
else
nopoc += (w / k) + 1;
}
cout << (nopoc + 1) / 2 << endl;
}
| 7 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.