solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int INFI = (1LL << 30) - 100;
const long long INFL = (1LL << 62) - 100;
const double eps = 1e-10;
const long double pi = acos(-1.0);
const int MAXN = 200010;
int cows[MAXN], clf[MAXN];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &cows[i]);
}
for (int i = n; i >= 1; i--) {
clf[i] += clf[i + 1] + !cows[i];
}
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (cows[i]) {
sum += clf[i + 1];
}
}
printf("%I64d", sum);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
vector<long long int> input;
long long int numbers[200003] = {0};
long long int flag = 0;
for (long long int i = 0; i < n; ++i) {
long long int temp;
cin >> temp;
input.push_back(temp);
}
for (long long int i = 0; i < n; ++i) {
long long int inp = i + (input[i] % n) + n;
inp %= n;
numbers[inp] = 1;
}
for (long long int i = 0; i < n; ++i) {
if (!numbers[i]) {
flag = 1;
break;
}
}
if (flag == 1)
cout << "NO" << endl;
else {
cout << "YES" << endl;
}
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX_N = 577;
const ll INF = LLONG_MAX / 2;
int N;
ll A[MAX_N][MAX_N], cost1[MAX_N][MAX_N], cost2[MAX_N][MAX_N];
ll dp[MAX_N][MAX_N];
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (i == j) continue;
scanf("%lld", &A[i][j]);
if (i < j) cost1[i][j] = A[i][j];
else cost2[j][i] = A[i][j];
}
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
cost1[i][j] += cost1[i][j - 1];
}
}
for (int i = N; i; i--) {
for (int j = 1; j <= N; j++) {
cost1[i][j] += cost1[i + 1][j];
}
}
for (int i = 1; i <= N; i++) {
for (int j = N; j; j--) {
cost2[i][j] += cost2[i][j + 1];
}
}
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
cost2[i][j] += cost2[i - 1][j];
}
}
for (int i = 1; i < N; i++) {
dp[0][i] = cost1[1][i];
for (int j = 1; j < i; j++) {
dp[j][i] = INF;
for (int k = 0; k < j; k++) {
dp[j][i] = min(dp[j][i], dp[k][j] + cost1[j + 1][i] + cost2[j][i + 1] - cost2[k][i + 1]);
}
}
}
ll ans = INF;
for (int i = 1; i < N; i++) {
for (int j = 0; j < i; j++) {
ans = min(ans, dp[j][i] + cost1[i + 1][N]);
}
}
printf("%lld\n", ans);
}
| 0 | CPP |
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int>P;
int n,l,r,imos[100007],ans1,ans2,sum;
vector<P>v;
vector<int>v1,v2;
int main(){
cin>>n;
for(int i=0;i<n;i++){
cin>>l>>r;
v.push_back(P(l,r));
v1.push_back(l);
v2.push_back(r);
imos[l]++;
imos[r]--;
}
sort(v1.begin(),v1.end());
sort(v2.begin(),v2.end());
for(int i=0;i<n;i++){
int sum1=upper_bound(v2.begin(),v2.end(),v[i].first)-v2.begin();
int sum2=v1.end()-lower_bound(v1.begin(),v1.end(),v[i].second);
ans1=max(ans1,n-sum1-sum2);
}
for(int i=0;i<100007;i++){
sum+=imos[i];
ans2=max(ans2,sum);
}
cout<< ans1 << ' ' << ans2 <<endl;
} | 0 | CPP |
''' ===============================
-- @uthor : Kaleab Asfaw
-- Handle : Kaleab_Asfaw
-- Bio : High-School Student
==============================='''
# Fast IO
import sys
import os
from io import BytesIO, IOBase
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")
# Others
# from math import floor, ceil, gcd
# from decimal import Decimal as d
mod = 10**9+7
def lcm(x, y): return (x * y) / (gcd(x, y))
def fact(x, mod=mod):
ans = 1
for i in range(1, x+1): ans = (ans * i) % mod
return ans
def arr2D(n, m, default=0): return [[default for j in range(m)] for i in range(n)]
def arr3D(n, m, r, default=0): return [[[default for k in range(r)] for j in range(m)] for i in range(n)]
def sortDictV(x): return {k: v for k, v in sorted(x.items(), key = lambda item : item[1])}
class DSU:
def __init__(self, length): self.length = length; self.parent = [-1] * self.length # O(log(n))
def getParent(self, node, start): # O(log(n))
if node >= self.length: return False
if self.parent[node] < 0:
if start != node: self.parent[start] = node
return node
return self.getParent(self.parent[node], start)
def union(self, node1, node2): # O(log(n))
parent1 = self.getParent(node1, node1); parent2 = self.getParent(node2, node2)
if parent1 == parent2: return False
elif self.parent[parent1] <= self.parent[parent2]: self.parent[parent1] += self.parent[parent2]; self.parent[parent2] = parent1
else: self.parent[parent2] += self.parent[parent1]; self.parent[parent1] = parent2
return True
def getCount(self, node): return -self.parent[self.getParent(node, node)] # O(log(n))
def exact(num):
if abs(num - round(num)) <= 10**(-9):return round(num)
return num
def solve(lst):
n = len(lst)
grid = arr2D(4, 4)
for i in lst:
if i == "0":
if grid[2][0] == 1:
print("1 1")
grid[2][0] = 0
grid[3][0] = 0
else:
print("3 1")
grid[2][0] = 1
grid[3][0] = 1
else:
if grid[0][2] == 1:
print("1 1")
grid[0][2] = 0
grid[0][3] = 0
else:
print("1 3")
grid[0][2] = 1
grid[0][3] = 1
lst = input()
solve(lst)
# grid = [[1, 1, 1, 0],
# [1, 1, 1, 0],
# [1, 1, 0, 0],
# [1, 1, 0, 0]]
# for i in clearGrid(grid):
# print(i) | 9 | PYTHON3 |
n, b, d= list(map(int, input().split()))
oranges = list(map(int, input().split()))
ans = 0
juicer = 0
for i in range(n):
if oranges[i] <= b:
juicer += oranges[i]
if juicer > d:
ans += 1
juicer = 0
print(ans) | 7 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
a = []
b = []
for i in range(n):
ai, bi = map(int, input().split())
a.append(ai)
b.append(bi)
if n == 1:
print(0)
else:
if max(a) < min(b):
print(0)
else:
print(max(a) - min(b))
| 7 | PYTHON3 |
n=int(input())
array=list(map(int,input().split()))
c=[]
for i in range(n):
for j in range(n):
if i+1==array[j]:
c.append(j+1)
for i in range(n):
print(c[i],end=" ") | 7 | PYTHON3 |
for _ in range(int(input())):
a,b,c = map(int,input().split())
if a==b==c==0: print(0)
elif a==b==0 or b==c==0 or a==c==0: print(1)
elif (a==0 and min(b,c)==1) or (b==0 and min(a,c)==1) or (c==0 and min(a,b)==1): print(2)
elif (a==0 and min(b,c)>1) or (b==0 and min(a,c)>1) or (c==0 and min(a,b)>1): print(3)
elif a==b==1 or b==c==1 or a==c==1: print(3)
elif min(a,b,c)==1 or a==b==c==2: print(4)
elif min(a,b,c)==2: print(5)
elif min(a,b,c)==3: print(6)
else: print(7) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> twos;
void gen() {
for (long long i = 1; i <= 1e18; i *= 2) {
twos.push_back(i);
}
}
int main() {
int n, m;
cin >> n >> m;
int arr[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
int maxx = 0;
for (int i = 0; i < n; i++) {
int minn = 1e9;
for (int j = 0; j < m; j++) {
minn = min(arr[i][j], minn);
}
maxx = max(minn, maxx);
}
cout << maxx << endl;
}
| 8 | CPP |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
struct query{
int type;//0=empty, 1=add-sum ,2=set-min
ll value;
query(int a=0,ll b=0):type(a),value(b) {}
};
ll INF=(1LL<<60);
struct segtree{
int SIZE;
vector<query> s;
vector<ll> t;// sum-add
vector<ll> u;// min-set
segtree(int n=1){
SIZE=1;
while(SIZE<n)SIZE*=2;
s.clear();
t.clear();
u.clear();
s.resize(SIZE*2, query());
t.resize(SIZE*2, 0);
u.resize(SIZE*2, 0);
}
void func(int k,int l,int r,query q){
if(q.type==1){
if(s[k].type==0)s[k]=q;
else s[k].value+=q.value;
t[k]+=q.value*(r-l);
u[k]+=q.value;
}
if(q.type==2){
s[k]=q;
t[k]=q.value*(r-l);
u[k]=q.value;
}
}
void compute(int k,int l,int r){
query q=s[k];
s[k]=query();
if(q.type==0||r-l==1)return;
int m=(l+r)/2;
func(k*2+1,l,m,q);
func(k*2+2,m,r,q);
}
void Update(int a,int b,query x,int k,int l,int r){
if(b<=l || r<=a)return;
compute(k,l,r);
if(a<=l && r<=b){
func(k,l,r,x);
}else{
int m=(l+r)/2;
Update(a,b,x,k*2+1,l,m);
Update(a,b,x,k*2+2,m,r);
t[k]=t[k*2+1]+t[k*2+2];
u[k]=min(u[k*2+1],u[k*2+2]);
}
}
ll Dfs(int type,int a,int b,int k,int l,int r){
if(b<=l || r<=a){
if(type==1)return 0; //add
if(type==2)return INF; // min
}
compute(k,l,r);
if(a<=l && r<=b){
if(type==1)return t[k];
if(type==2)return u[k];
}else{
int m=(l+r)/2;
ll lv=Dfs(type,a,b,k*2+1,l,m);
ll rv=Dfs(type,a,b,k*2+2,m,r);
if(type==1)return lv+rv; // add
if(type==2)return min(lv,rv); // min
}
}
void Add(int a,int b,ll x){
Update(a,b,query(1,x), 0,0,SIZE);
}
void Set(int a,int b,ll x){
Update(a,b,query(2,x), 0,0,SIZE);
}
ll Getsum(int a,int b){
return Dfs(1,a,b, 0,0,SIZE);
}
ll Getmin(int a,int b){
return Dfs(2,a,b, 0,0,SIZE);
}
};
int main(){
int n,q;
scanf("%d %d",&n,&q);
segtree T(n);
for(int i=0;i<q;i++){
int type,a,b,c;
scanf("%d %d %d",&type,&a,&b);
if(type==0){
scanf("%d",&c);
T.Add(a,b+1,c);
}else{
printf("%lld\n", T.Getmin(a,b+1) );
}
}
return 0;
}
| 0 | CPP |
n = int(input())
a = list(map(int, input().split()))
m = int(input())
b = list(map(int, input().split()))
for i in range(n):
for j in range(m):
if a[i] + b[j] not in a and a[i] + b[j] not in b:
print(a[i], b[j])
break
else:
continue
break | 7 | PYTHON3 |
def fact(x):
if x<=1:
return 1
else:
return x*fact(x-1)
n=int(input())
print(int(fact(2*n-2)/(fact(n-1)**2))) | 7 | PYTHON3 |
t=int(input())
for i in range(t):
st,n=list(map(int,input().split()))
c=n%4
k=(n//4)*4+1
if(st%2==0):
for j in range(c):
if(st%2==0):
st-=k
k+=1
else:
st+=k
k+=1
print(st)
else:
for j in range(c):
if(st%2==0):
st-=k
k+=1
else:
st+=k
k+=1
print(st)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
long long d, n, m;
pair<long long, long long> p[MAXN];
long long nxt[MAXN];
bool comp(pair<long long, long long> a, pair<long long, long long> b) {
return a.first < b.first;
}
signed main() {
memset(nxt, -1, sizeof nxt);
cin >> d >> n >> m;
p[0] = {0, 0};
p[m + 1] = {d, 0};
for (long long i = 1; i <= m; i++) cin >> p[i].first >> p[i].second;
sort(p, p + m + 1, comp);
deque<long long> fila;
fila.push_back(m + 1);
for (long long i = m; i >= 0; i--) {
while (!fila.empty()) {
long long at = fila.back();
if (p[at].first - p[i].first > n) {
fila.pop_back();
continue;
} else
break;
}
while (!fila.empty()) {
long long at = fila.front();
if (p[at].second > p[i].second) {
if (fila.size() == 1) nxt[i] = fila.front();
fila.pop_front();
} else
break;
}
if (!fila.empty()) nxt[i] = fila.front();
fila.push_front(i);
}
long long resp = 0;
long long at = 0;
long long tank = n;
while (true) {
if (at == m + 1) break;
if (nxt[at] == -1) {
cout << -1 << endl;
return 0;
}
if (at == 0) {
at = nxt[0];
tank -= p[nxt[0]].first;
continue;
}
long long b = nxt[at];
if (p[b].second > p[at].second)
resp += (n - tank) * p[at].second, tank = n - (p[b].first - p[at].first);
else {
long long h = p[b].first - p[at].first;
if (tank < h)
resp += (h - tank) * p[at].second, tank = 0;
else
tank -= h;
}
at = b;
}
cout << resp << endl;
}
| 11 | CPP |
#include <bits/stdc++.h>
const int N = 4e5 + 5;
const int dx[] = {1, -1, 0, 0, 0, 0}, dy[] = {0, 0, 1, -1, 0, 0},
dz[] = {0, 0, 0, 0, 1, -1};
std::vector<int> sensors[N];
int n, m, k, a[N], c;
inline int id(int x, int y, int z) { return (x - 1) * m * k + (y - 1) * k + z; }
inline bool in(int x, int y, int z) {
return x >= 1 && x <= n && y >= 1 && y <= m && z >= 1 && z <= k;
}
void color(int d, int x, int y, int z, int c) {
if (!in(x, y, z)) {
if (c) {
puts("-1");
exit(0);
}
return;
}
int t = id(x, y, z);
auto erase = [&]() {
while (!sensors[t].empty()) {
int d = sensors[t].back();
sensors[t].pop_back();
color(d, x + dx[d], y + dy[d], z + dz[d], a[t]);
}
a[t] = 0;
};
if (!c) {
if (a[t] > 0) {
erase();
} else {
a[t] = 0;
}
color(d, x + dx[d], y + dy[d], z + dz[d], c);
} else if (a[t] == -1 || a[t] == c) {
a[t] = c;
sensors[t].push_back(d);
} else if (!a[t]) {
color(d, x + dx[d], y + dy[d], z + dz[d], c);
} else {
erase();
color(d, x + dx[d], y + dy[d], z + dz[d], c);
}
}
int main() {
std::memset(a, -1, sizeof(a));
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= k; ++j) {
scanf("%d", &c);
color(0, 1, i, j, c);
}
}
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= k; ++j) {
scanf("%d", &c);
color(1, n, i, j, c);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= k; ++j) {
scanf("%d", &c);
color(2, i, 1, j, c);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= k; ++j) {
scanf("%d", &c);
color(3, i, m, j, c);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
scanf("%d", &c);
color(4, i, j, 1, c);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
scanf("%d", &c);
color(5, i, j, k, c);
}
}
for (int i = 1; i <= n * m * k; ++i) {
printf("%d ", std::max(a[i], 0));
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
double prec = 0.00000001;
void calcHistory(vector<double>& history, int hp2, double p1, int l1, int h1) {
double h[201];
double newh[201];
memset(h, 0, sizeof(h));
memset(newh, 0, sizeof(newh));
h[hp2] = 1.;
for (int i = 0; i < history.size(); ++i) {
for (int j = 1; j <= hp2; ++j)
if (h[j] > 0) {
double pHit = (1. - p1) / (h1 - l1 + 1.);
for (int idx = l1; idx <= h1; ++idx) {
int nIdx = j - idx > 0 ? j - idx : 0;
newh[nIdx] += pHit * h[j];
}
newh[j] += p1 * h[j];
}
history[i] = newh[0];
newh[0] = 0;
for (int idx = 0; idx <= 200; ++idx)
if (newh[idx] > prec)
h[idx] = newh[idx];
else
h[idx] = 0.;
memset(newh, 0, sizeof(newh));
}
}
int main(int argc, char* argv[]) {
stringstream strStr;
int hp1;
int dt1;
int l1;
int h1;
int pp1;
double p1;
int hp2;
int dt2;
int l2;
int h2;
int pp2;
double p2;
cin >> hp1;
cin >> dt1;
cin >> l1;
cin >> h1;
cin >> pp1;
cin >> hp2;
cin >> dt2;
cin >> l2;
cin >> h2;
cin >> pp2;
strStr >> hp1;
strStr >> dt1;
strStr >> l1;
strStr >> h1;
strStr >> pp1;
strStr >> hp2;
strStr >> dt2;
strStr >> l2;
strStr >> h2;
strStr >> pp2;
p1 = double(pp1) / 100.;
p2 = double(pp2) / 100.;
vector<double> history(6000, 0.);
calcHistory(history, hp2, p1, l1, h1);
double res = 0;
double h[201];
double newh[201];
memset(h, 0, sizeof(h));
memset(newh, 0, sizeof(newh));
h[hp1] = 1.;
int k = 0;
double p = 0.;
double pp = 0.;
for (int i = 0; i < history.size(); ++i) {
double histP1 = history[i];
while (dt2 * k < dt1 * i) {
++k;
for (int j = 1; j <= hp1; ++j)
if (h[j] > 0) {
double pHit = (1. - p2) / (h2 - l2 + 1.);
for (int idx = l2; idx <= h2; ++idx) {
int nIdx = j - idx > 0 ? j - idx : 0;
newh[nIdx] += pHit * h[j];
}
newh[j] += p2 * h[j];
}
pp += newh[0];
for (int idx = 0; idx <= 200; ++idx)
if (newh[idx] > prec)
h[idx] = newh[idx];
else
h[idx] = 0.;
memset(newh, 0, sizeof(newh));
}
res += histP1 * (1. - pp);
p += histP1;
}
cout << showpoint << res;
return 0;
}
| 10 | CPP |
import pprint
max_value = 1000000000000000000
cache = []
cache.append((1, 1))
index = 0
while True:
el = cache[index][0] * 2
su = cache[index][1] + el
cache.append((el, su))
if su > max_value:
break
index += 1
# pprint.pprint(cache)
l, r = list(map(int, input().split()))
if r == 1:
print(1)
exit(0)
def get_by_index(index):
i = 0
while cache[i][1] < index:
i += 1
group, alle = 0, 0
for j in range(0, i):
if i % 2 == j % 2:
group += cache[j][0]
alle += cache[j][0]
pos = group + index - alle
sol = pos * 2 - ((i + 1) % 2)
return sol
# print(get_by_index(22))
# print(get_by_index(27))
def prefix_solve(index):
prev_index = 0
while prev_index < len(cache) and cache[prev_index + 1][1] < index:
prev_index += 1
curr_element = get_by_index(index)
prev_element = get_by_index(cache[prev_index][1])
min_elemenet = min(curr_element, prev_element)
max_elemenet = max(curr_element, prev_element)
s1 = ((1 + min_elemenet) * min_elemenet) >> 1
a1 = min_elemenet + 1
a2 = max_elemenet
n = ((a2 - a1) >> 1) + 1
s2 = ((a1 + a2) * n) >> 1
sol = s1 + s2
return sol
mod_value = 1000000007
sr = prefix_solve(r)
sl = 0 if l == 1 else prefix_solve(l - 1)
sol = (sr - sl) % mod_value
print(sol)
| 9 | PYTHON3 |
from sys import stdin,stdout
from math import gcd
input=stdin.readline
print=stdout.write
def gcda(l):
if len(l)==0:
return 1
res=l[0]
for i in range(1,len(l)):
res=gcd(res,l[i])
return res
t=int(input())
for i in range(t):
n=int(input())
l=list(map(int,input().split()))
l.sort()
for i in range(1,n):
if l[i-1]+1<l[i]:
print("NO")
break;
else:
print("YES")
print("\n")
| 7 | PYTHON3 |
a=int(input())
if (a>2) and a%2==0:
print('YES')
else:
print('NO') | 7 | PYTHON3 |
import math
game_score = int(input())
def verify_spent(score):
for a in range(1000):
for b in range(1000):
c = (score - b*123456 - a*1234567)/1234
if c >= 0 and (c - math.floor(c) == 0):
print("YES")
return
print("NO")
verify_spent(game_score)
| 8 | PYTHON3 |
n = int(input())
s = input()
l = n // 2;
if n % 2 == 0:
l -= 1
r = n // 2
if n % 2 != 0:
r += 1
while (s[l] == '0' and l > 0):
l -= 1
while (s[r] == '0' and r < n - 1):
r += 1
if (s[r] != '0'):
a = int(s[:r]) + int(s[r:])
else:
a = int(s)
if (l != 0):
b = int(s[:l]) + int(s[l:])
else:
b = a;
print (min(a, b))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> x(500000);
long long s = 0;
int mx = 0, mn = 1e9;
long long ss, sss;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> x[i];
s += x[i];
mx = max(x[i], mx);
mn = min(x[i], mn);
}
int l = (s + n - 1) / n, r = mx;
while (l <= r) {
long long sum = 0;
int mid = (l + r) / 2;
for (int i = 0; i < n; i++)
if (x[i] > mid) sum += (x[i] - mid);
if (sum <= k) {
ss = mid;
r = mid - 1;
} else
l = mid + 1;
}
l = mn;
r = s / n;
while (l <= r) {
long long sum = 0;
int mid = (l + r) / 2;
for (int i = 0; i < n; i++)
if (x[i] < mid) sum += (mid - x[i]);
if (sum <= k) {
sss = mid;
l = mid + 1;
} else
r = mid - 1;
}
cout << ss - sss;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using db = long double;
using row = vector<int>;
using ii = pair<int, int>;
const int N = 5e5 + 5, M = 1e6 + 5, A = 6561, LG = 17, MOD = 1e9 + 7;
const int BLOCK = 1900;
const int BLOCKN = N / BLOCK + 1;
const long double EPS = 1e-7;
vector<int> g[2];
map<int, int> cnt[2];
int n, m, s, f;
int count(bool f, int l, int r) {
return upper_bound(g[f].begin(), g[f].end(), r) -
lower_bound(g[f].begin(), g[f].end(), l);
}
pair<int, ll> ans;
void addToMax(int val, ll cnt) {
if (!cnt) return;
if (ans.first < val) ans = make_pair(val, 0);
if (ans.first == val) ans.second += cnt;
}
void solveMax(bool k) {
if (g[k].empty()) return;
if (g[k].size() >= 3) {
int cntL = cnt[k][g[k][0]];
int cntR = cnt[k][g[k].back()];
int cntM = g[k].size() - cntL - cntR;
int val = (g[k].back() - g[k][0]) * 2;
ll sum = 0;
if (g[k][0] == g[k].back()) {
addToMax(val, 1ll * cntL * (cntL - 1) * (cntL - 2) / 6);
} else {
sum += 1ll * cntL * cntM * cntR;
sum += 1ll * cntL * (cntL - 1) / 2 * cntR;
sum += 1ll * cntL * cntR * (cntR - 1) / 2;
addToMax(val, sum);
}
}
for (auto x : g[k]) {
{
int L = count(k ^ 1, 1, x);
int R = count(k ^ 1, x, n);
int val = cnt[k ^ 1][x];
addToMax(2 * n,
1ll * L * R - 1ll * val * val + 1ll * val * (val - 1) / 2);
}
{
int idx =
upper_bound(g[k ^ 1].begin(), g[k ^ 1].end(), x) - g[k ^ 1].begin();
if (idx != g[k ^ 1].size()) {
addToMax(2 * (n + x - g[k ^ 1][idx]),
1ll * cnt[k ^ 1][g[k ^ 1][idx]] *
count(k ^ 1, g[k ^ 1][idx] + 1, n));
addToMax(2 * (n + x - g[k ^ 1][idx]),
1ll * cnt[k ^ 1][g[k ^ 1][idx]] *
(cnt[k ^ 1][g[k ^ 1][idx]] - 1) / 2);
}
}
{
int idx =
lower_bound(g[k ^ 1].begin(), g[k ^ 1].end(), x) - g[k ^ 1].begin();
--idx;
if (~idx) {
addToMax(2 * (n + g[k ^ 1][idx] - x),
1ll * cnt[k ^ 1][g[k ^ 1][idx]] *
count(k ^ 1, 1, g[k ^ 1][idx] - 1));
addToMax(2 * (n - x + g[k ^ 1][idx]),
1ll * cnt[k ^ 1][g[k ^ 1][idx]] *
(cnt[k ^ 1][g[k ^ 1][idx]] - 1) / 2);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> s >> f;
g[s].push_back(f);
cnt[s][f]++;
}
sort(g[0].begin(), g[0].end());
sort(g[1].begin(), g[1].end());
solveMax(0);
solveMax(1);
cerr << ans.first << '\n';
cout << ans.second << '\n';
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int inp[110];
int main() {
int n, i, s, t, sum = 0, allsum = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", inp + i);
allsum += inp[i];
}
scanf("%d%d", &s, &t);
if (s > t) {
swap(s, t);
}
for (i = s; i < t; i++) {
sum += inp[i];
}
printf("%d", min(sum, allsum - sum));
}
| 7 | CPP |
n,m=map(int,input().split())
re=1.5
for i in range(1,n+1):
if i%2 !=0:
for j in range(m):
print('#',end='')
print()
elif i%2 ==0 and re%2 == 0:
for j in range(m-1):
print('.',end='')
print('#',end='')
print()
elif i%2 ==0 and re%2 != 0:
print('#',end='')
for k in range(m-1):
print('.',end='')
print()
re+=0.5 | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char s[256], v[] = {"hello"};
int n, nrh, nre, nrl, nro, ok, x, i;
int main() {
cin.getline(s, 256);
nrh = nre = nrl = nro = 0;
ok = 0;
x = 0;
for (i = 0; i <= strlen(s); i++) {
if (s[i] == 'h' && nrh < 1 && v[x] == 'h') {
ok++;
x++;
nrh++;
}
if (s[i] == 'e' && nre < 1 && v[x] == 'e') {
ok++;
x++;
nre++;
}
if (s[i] == 'l' && nrl < 2 && v[x] == 'l') {
ok++;
x++;
nrl++;
}
if (s[i] == 'o' && nro < 1 && v[x] == 'o') {
ok++;
x++;
nro++;
}
}
if (ok == 5)
cout << "YES";
else
cout << "NO";
return 0;
}
| 7 | CPP |
x = 0
n = (int)(input())
for a in range(0,n):
st = input()
if "+" in st:
x += 1
if "-" in st:
x -= 1
print (x) | 7 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,inline")
#pragma GCC target("bmi,bmi2,lzcnt,popcnt")
#pragma GCC target("aes,pclmul,rdrnd")
#pragma GCC target("avx,avx2,f16c,fma,sse3,ssse3,sse4.1,sse4.2")
using namespace std;
template <class T>
using pq = priority_queue<T>;
template <class T>
using pqg = priority_queue<T, vector<T>, greater<T>>;
void _print(long long int x) { cerr << x; }
void _print(long x) { cerr << x; }
void _print(unsigned x) { cerr << x; }
void _print(unsigned long x) { cerr << x; }
void _print(unsigned long long x) { cerr << x; }
void _print(float x) { cerr << x; }
void _print(double x) { cerr << x; }
void _print(long double x) { cerr << x; }
void _print(char x) { cerr << '\'' << x << '\''; }
void _print(const char *x) { cerr << '\"' << x << '\"'; }
void _print(const string &x) { cerr << '\"' << x << '\"'; }
void _print(bool x) { cerr << (x ? "true" : "false"); }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T>
void _print(unordered_set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T, class V>
void _print(unordered_map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(unordered_set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(unordered_map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int expo(long long int a, long long int n) {
long long int ans = 1;
while (n) {
if (n & 1) {
ans *= a;
}
a *= a;
n >>= 1;
}
return ans;
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
bool mutiple_test_case = 1;
long long int dx[] = {1, -1, 0, 0};
long long int dy[] = {0, 0, -1, 1};
const long long int MOD = 1000000007;
const long long int N = 1e5 + 1;
void solve() {
long long int n, k;
cin >> n >> k;
long long int ans = 0;
n--;
long long int sticks = 1;
while (n > 0) {
n -= sticks;
ans++;
long long int tmp = sticks * 2;
if (tmp > k) {
sticks = k;
break;
} else {
sticks = tmp;
}
}
ans += ceil((long double)n / sticks);
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
if (mutiple_test_case) cin >> t;
while (t--) {
solve();
}
return 0;
}
| 8 | CPP |
a,b = map(int,input().split())
ans = 0
while a % b != 0:
ans += a // b
a,b = max(a % b,b),min(a % b,b)
ans += a // b
print(ans) | 7 | PYTHON3 |
#include<iostream>
#include<algorithm>
using namespace std;
int dp[1<<16],n;
int L[100],t[100];
int main()
{
while(cin>>n,n)
{
for(int i=0;i<n;i++)
{
t[i]=0;
int m;
cin>>m>>L[i];
for(;m--;)
{
int l,r;cin>>l>>r;
l-=6;r-=6;
for(int j=l;j<r;j++)
{
t[i]|=1<<j;
}
}
}
for(int i=0;i<1<<16;i++)dp[i]=0;
for(int i=0;i<1<<16;i++)
{
for(int j=0;j<n;j++)
{
if(~i&t[j])continue;
dp[i]=max(dp[i],L[j]+dp[i&~t[j]]);
}
}
cout<<dp[(1<<16)-1]<<endl;
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005];
set<int> s1, s2, ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; ++i) {
int ret = a[i];
if (i == 1) {
s1.insert(ret);
ans.insert(ret);
} else if (i % 2 == 0) {
s2.insert(ret);
ans.insert(ret);
for (auto c : s1) {
s2.insert(ret | c);
ans.insert(ret | c);
}
s1.clear();
} else {
s1.insert(ret);
ans.insert(ret);
for (auto c : s2) {
s1.insert(ret | c);
ans.insert(ret | c);
}
s2.clear();
}
}
printf("%d\n", (int)ans.size());
return 0;
}
| 7 | CPP |
d = {}
def solve(a, b):
if a > b:
a, b = b, a
if a == b:
return 0
args = [(a % 2, (a // 2, b)),
(a % 3, (a // 3, b)),
(a % 5, (a // 5, b)),
(b % 2, (a, b // 2)),
(b % 3, (a, b // 3)),
(b % 5, (a, b // 5))]
res = []
for cond, (arg1, arg2) in args:
if not cond:
tmp = d.get((arg1, arg2))
if tmp is None:
tmp = solve(arg1, arg2)
d[(arg1, arg2)] = tmp
if tmp != -1:
res.append(tmp + 1)
if res:
return min(res)
else:
return -1
if __name__ == "__main__":
a, b = map(int, input().split())
print(solve(a, b))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
int max_e = -INF;
for (int i = 0; i < n; i++) {
cin >> a[i];
max_e = max(max_e, a[i]);
}
int index = -1;
for (int i = 0; i < n; i++) {
if (a[i] == max_e && i > 0 && a[i - 1] < max_e) {
index = i + 1;
break;
}
if (a[i] == max_e && i < n - 1 && a[i + 1] < max_e) {
index = i + 1;
break;
}
}
cout << index << endl;
}
return 0;
}
| 9 | CPP |
capital = input()
print(capital[0].upper() + capital[1:])
| 7 | PYTHON3 |
import math
#r,g,b=map(int,input().split())
#list1 = input().split()
#for i in range(len(list1)):
# list1[i] = int(list1[i])
#print(list1)
#print(r, g, b)
# arr = [[0 for x in range(columns)] for y in range(rows)]
t=int(input())
for i in range(t):
string = ""
n = int(input())
list1 = input().split()
for i in range(len(list1)):
list1[i] = int(list1[i])
pos = n-1
notmax = True
if(pos == 0 or list1[pos] > list1[pos-1]):
notmax = False
while(notmax):
pos -= 1
if(pos == 0 or list1[pos] > list1[pos-1]):
notmax = False
notmin = True
if(pos == 0 or list1[pos] < list1[pos-1]):
notmin = False
while(notmin):
pos -= 1
if(pos == 0 or list1[pos] < list1[pos-1]):
notmin = False
print(pos)
| 9 | PYTHON3 |
input()
k,m=map(int,input().split())
l1=[int(x) for x in input().split()]
l2=[int(x) for x in input().split()]
if l1[k-1]<l2[-m]:
print("YES")
else:
print("NO") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
using ll = long long;
int n, m, a[N], b[N], x[N], y[N], del, fl, mid;
ll ans;
int main() {
ios::sync_with_stdio(false);
cin >> n;
m = (n + 1) / 2;
for (int i = 1; i <= n; i++) cin >> x[i] >> y[i], a[i] = x[i], b[i] = y[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + n + 1);
del = min(a[m + 1] - a[m], b[m + 1] - b[m]);
if (n & 1) del = min(del, min(a[m] - a[m - 1], b[m] - b[m - 1]));
for (int i = 1; i <= n; i++) {
ans += abs(x[i] - a[m]) + abs(y[i] - b[m]);
fl |= (x[i] > a[m] && y[i] > b[m]) << 1;
fl |= (x[i] > a[m] && y[i] <= b[m]);
mid |= (x[i] == a[m] && y[i] == b[m]);
}
if (fl == 3 && (!(n & 1) || mid)) ans -= del;
cout << ans * 2 << endl;
return 0;
}
| 11 | CPP |
n = int(input())
a = list(map(int, input().split()))
s = {4:0, 8:0, 15:0, 16:0, 23:0, 42:0}
d = 0
for i in range(n):
if a[i] == 4:
s[4] += 1
else:
m = s[4]
for j in s:
if j < a[i]:
m = min(m, s[j])
s[a[i]] = min(m, s[a[i]] + 1)
print(n - min(s.values()) * 6)
| 9 | PYTHON3 |
s = input()
count = 0
for i in range(len(s)):
if s[i] in ['H','Q','9']:
count = count + 1
else:
count = count
if count > 0:
print("YES")
else:
print("NO")
| 7 | PYTHON3 |
N = int(input())
A = [int(input()) for k in range(N)]
A = sorted(A)
k = N//2
if N%2 == 1:
print(max(-2*sum(A[:k])+sum(A[k:k+2])+2*sum(A[k+2:]),-2*sum(A[:k-1])-sum(A[k-1:k+1])+2*sum(A[k+1:])))
else:
print(-2*sum(A[:k-1])-A[k-1]+A[k]+2*sum(A[k+1:]))
| 0 | PYTHON3 |
n,k = map(int,input().split())
stringn = str(n)
while(k!=0):
if stringn.endswith('0'):
stringn = stringn[:-1]
k = k-1
else:
stringn = stringn[:-1] + str(int(stringn[-1:])-1)
k = k-1
print(int(stringn))
| 7 | PYTHON3 |
t=int(input())
x=0
for i in range(t):
s=input()
if(s[1]=='+'):
x=x+1
else:
x=x-1
print(x)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
int start = 0;
for (int i = 'z'; i >= 'a'; --i)
for (int j = start; j < s.size(); ++j)
if (s[j] == i) {
start = j + 1;
cout << s[j];
}
cout << endl;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b);
long long int gcd(long long int a, long long int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long int modulo(long long int a, long long int b) {
long long int r = a % b;
return r < 0 ? r + b : r;
}
unsigned long long int ncr(unsigned long long int n, unsigned long long int r) {
if (r > n - r) r = n - r;
unsigned long long int ans = 1;
unsigned long long int i;
for (i = 1; i <= r; i++) {
ans *= n - r + i;
ans /= i;
}
return ans;
}
class abc {
public:
long long int x;
long long int y;
};
bool fun1(abc xx, abc yy) {
return (abs(xx.x) + abs(xx.y)) < (abs(yy.x) + abs(yy.y));
}
long long int a[16] = {};
bool chk(int s, int e) {
for (int i = s + 1; i <= e; i++) {
if (a[i] < a[i - 1]) return false;
}
return true;
}
long long int ans = 0;
void solve(long long int l, long long int r) {
if (l > r) {
return;
}
if (chk(l, r)) {
ans = max(ans, r - l + 1);
return;
}
long long int mid = (l + r) / 2;
solve(l, mid);
solve(mid + 1, r);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, m, cl, ce, v;
cin >> n >> m >> cl >> ce >> v;
vector<long long int> ladder(cl);
vector<long long int> lift(ce);
for (long long int i = 0; i < cl; i++) cin >> ladder[i];
for (long long int i = 0; i < ce; i++) cin >> lift[i];
long long int q;
cin >> q;
while (q--) {
long long int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
long long int delx;
long long int dely = abs(y2 - y1);
long long int byladder = abs(x2 - x1);
long long int bylift = ceil((long double)(byladder) / (long double)v);
{
long long int lad = lower_bound(ladder.begin(), ladder.end(), y1) -
ladder.begin(),
lif = lower_bound(lift.begin(), lift.end(), y1) -
lift.begin();
vector<long long int> hm;
if (x1 == x2) {
cout << abs(y2 - y1) << '\n';
continue;
}
if (lad < cl) {
long long int as = 0;
as += byladder;
as += abs(ladder[lad] - y1);
as += abs(ladder[lad] - y2);
hm.push_back(as);
}
if (lif < ce) {
long long int as = 0;
as += bylift;
as += abs(lift[lif] - y1);
as += abs(lift[lif] - y2);
hm.push_back(as);
}
lad--;
lif--;
if (lad >= 0) {
long long int as = 0;
as += byladder;
as += abs(ladder[lad] - y1);
as += abs(ladder[lad] - y2);
hm.push_back(as);
}
if (lif >= 0) {
long long int as = 0;
as += bylift;
as += abs(lift[lif] - y1);
as += abs(lift[lif] - y2);
hm.push_back(as);
}
sort(hm.begin(), hm.end());
cout << hm[0] << '\n';
}
}
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
int n, m;
pair<int, int> p[111111];
int ans;
string s;
bool bl;
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
int j = 1;
int qq = n - 2;
int ww = 0;
int q = n - 1;
int w = n;
for (int i = 1; i <= n / 2; i++) {
p[j] = make_pair(q - qq, w - ww);
ww += 2;
qq -= 2;
j++;
}
for (int i = 1; i <= n / 2; i++) {
ans++;
if (p[i].first == m || p[i].second == m) break;
}
cout << ans;
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 1e9;
auto ask = [&](int x, int y) {
printf("? %d %d\n", x, y);
fflush(stdout);
int t;
scanf("%d", &t);
return t;
};
int res = ask(n, 1);
auto ok = [&](int y) {
int res2 = ask(n, y);
return res - res2 == y - 1;
};
int l = 2, r = n - 1;
int t1 = l;
while (l <= r) {
int mid = (l + r) / 2;
if (ok(mid))
t1 = mid, l = mid + 1;
else
r = mid - 1;
}
int s2 = n - ask(n, t1);
int s1 = ask(1, 1) - t1 + 2;
int t2 = n - (ask(n, n) - (n - s2));
printf("! %d %d %d %d\n", s1, t1, s2, t2);
fflush(stdout);
return 0;
}
| 14 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[305][305];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int id = 1;
for (int i = 1; i <= n; i++) {
if (i % 2 == 1)
for (int j = 1; j <= n; j++) {
a[j][i] = id;
id++;
}
else
for (int j = n; j >= 1; j--) {
a[j][i] = id;
id++;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) cout << a[i][j] << ' ';
cout << '\n';
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
for (T& x : v) is >> x;
return is;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
if (!v.empty()) {
os << v.front();
for (int i = 1; i < v.size(); ++i) os << ' ' << v[i];
}
return os;
}
int R, C, k;
long long ans;
void solve(int l, int r, vector<pair<int, int>> orch) {
if (l > r) return;
vector<int> ys;
for (const auto& pr : orch) ys.push_back(pr.second);
int mid = (l + r) / 2;
if (!ys.empty()) {
nth_element(ys.begin(), ys.begin() + ys.size() / 2, ys.end());
mid = ys[ys.size() / 2];
}
vector<pair<int, int>> left, right;
vector<int> lstk, rstk;
int cnt = 0;
int lx = 1;
function<void(int)> calc = [&](int con) {
if (cnt >= k) return;
int p = rstk.size();
for (int i = 0; i <= lstk.size(); ++i) {
while (i + p + cnt >= k) --p;
while (p > 0 && p < rstk.size() && rstk[p - 1] == rstk[p]) --p;
if (p < 0) break;
int llen =
(i == 0 ? mid : lstk[i - 1]) - (i == lstk.size() ? l - 1 : lstk[i]);
int rlen = (p == rstk.size() ? r : rstk[p] - 1) - (mid - 1);
ans += llen * (long long)rlen * con;
}
};
for (const auto& p : orch)
if (p.second < mid) {
left.push_back(p);
} else if (p.second > mid) {
right.push_back(p);
}
for (int i = 0; i <= orch.size(); ++i) {
lstk.clear();
rstk.clear();
cnt = 0;
lx = 1 + ((i == 0) ? 0 : orch[i - 1].first);
int con = (i == orch.size() ? R : orch[i].first) -
(i == 0 ? 0 : orch[i - 1].first);
if (!con) continue;
for (int j = i; j < orch.size(); ++j) {
const auto& p = orch[j];
if (p.first > lx) {
if (j == i) {
calc(con * (con - 1) / 2);
} else {
calc((p.first - lx) * con);
}
lx = p.first;
}
if (p.second == mid)
++cnt;
else if (p.second < mid) {
lstk.insert(
lower_bound(lstk.begin(), lstk.end(), p.second, greater<int>()),
p.second);
if (lstk.size() > k) lstk.pop_back();
} else if (p.second > mid) {
rstk.insert(lower_bound(rstk.begin(), rstk.end(), p.second), p.second);
if (rstk.size() > k) rstk.pop_back();
}
}
if (i == orch.size())
calc(con * (con + 1) / 2);
else
calc((R + 1 - lx) * con);
}
solve(l, mid - 1, left);
solve(mid + 1, r, right);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> R >> C >> n >> k;
vector<pair<int, int>> orch(n);
for (int i = 0; i < n; ++i) cin >> orch[i].first >> orch[i].second;
sort(orch.begin(), orch.end());
solve(1, C, orch);
ans = (R * (R + 1LL) / 2) * (C * (C + 1LL) / 2) - ans;
cout << ans;
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const int maxn = 2020;
int n, m, k;
int q;
long long g[maxn][maxn];
void update(int i, int _j, long long dx) {
while (i <= n) {
int j = _j;
while (j <= m) {
g[i][j] += dx;
j += j & -j;
}
i += i & -i;
}
}
long long get(int i, int _j) {
long long res = 0;
while (i > 0) {
int j = _j;
while (j > 0) {
res += g[i][j];
j -= j & -j;
}
i -= i & -i;
}
return res;
}
struct node {
int i, j;
long long w;
};
vector<node> gar[maxn];
int state[maxn], edit[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
cin >> k;
for (int i = 1; i <= k; i++) {
int len;
cin >> len;
while (len--) {
int x, y, w;
cin >> x >> y >> w;
gar[i].push_back({x, y, w});
}
state[i] = edit[i] = 1;
}
cin >> q;
while (q--) {
string z;
cin >> z;
if (z[0] == 'S') {
int idx;
cin >> idx;
state[idx] ^= 1;
edit[idx] ^= 1;
} else {
for (int i = 1; i <= k; i++) {
if (edit[i]) {
if (state[i]) {
for (auto p : gar[i]) {
update(p.i, p.j, p.w);
}
} else {
for (auto p : gar[i]) {
update(p.i, p.j, -p.w);
}
}
edit[i] = 0;
}
}
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
long long res =
get(x2, y2) - get(x2, y1 - 1) - get(x1 - 1, y2) + get(x1 - 1, y1 - 1);
cout << res << "\n";
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int aa[100005];
int num[105];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> num[i];
for (int i = n; i > 1; i--)
for (int j = 1; j < i; j++) {
if (num[j] > num[j + 1]) {
swap(num[j], num[j + 1]);
cout << j << " " << j + 1 << endl;
}
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int maxn = 101010;
int n, last;
int arr[maxn], sum[maxn];
bool judge(int x) {
arr[2] = (sum[2] + sum[3] - last) / 2;
arr[1] = sum[2] - arr[2];
for (int i = 3; i <= n; i++) {
arr[i] = sum[i] - arr[i - 1];
}
for (int i = 1; i <= n; i++) {
if (arr[i] < 1 || arr[i] > 100000) return 0;
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
printf("? %d %d\n", i, i + 1);
fflush(stdout);
scanf("%d", &sum[i + 1]);
}
printf("? 1 3\n");
fflush(stdout);
scanf("%d", &last);
for (int i = 1; i <= 100000; i++) {
if (judge(i)) {
printf("! ");
for (int i = 1; i <= n; i++) {
printf("%d", arr[i]);
if (i == n)
printf("\n");
else
printf(" ");
}
break;
}
}
return 0;
}
| 9 | CPP |
for _ in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
arr.sort()
even,odd=0,0
for i in arr:
if(i%2==0):
even+=1
else:
odd+=1
flag=False
if(even%2==0 and odd%2==0):
print("YES")
else:
for i in range(1,n):
if(abs(arr[i]-arr[i-1])==1):
flag=True
break
if(flag):
print("YES")
else:
print("NO")
| 9 | PYTHON3 |
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
#define MAX 10
double d;
int main() {
while (1) {
scanf("%lf", &d);
if (d < 0)
return 0;
if(d >= 256 || fmod(d, .0625) != 0)
puts("NA");
else {
double r = 128;
for(int i = 0; i < 12; i++, r *= .5) {
if(i == 8)
printf(".");
printf("%d", d / r >= 1);
d = fmod(d, r);
}
puts("");
}
}
} | 0 | CPP |
n, m = map(int, input().split())
answer = 0
answer += n * (m // 5)
for i in range(1, 1 + m % 5):
x = 0
if n % 5 >= 5 - i:
x = 1
answer += n // 5 + x
print(answer)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
template <typename T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T LCM(T a, T b) {
return a * (b / gcd(a, b));
}
template <typename T, typename second>
T expo(T b, second e, const T &m) {
if (e <= 1) return e == 0 ? 1 : b;
return (e & 1) == 0 ? expo((b * b) % m, e >> 1, m)
: (b * expo((b * b) % m, e >> 1, m)) % m;
}
template <typename T, typename second>
T expo(T b, second e) {
if (e <= 1) return e == 0 ? 1 : b;
return (e & 1) == 0 ? expo((b * b), e >> 1) : (b * expo((b * b), e >> 1));
}
template <typename T, typename second>
T modinv(T a, second mod) {
return expo(a, mod - 2, mod);
}
template <class T, class second>
std::ostream &operator<<(std::ostream &os, const std::pair<T, second> &t) {
os << "(" << t.first << ", " << t.second << ")";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &t) {
os << "[";
for (__typeof(t.begin()) it = t.begin(); it != t.end(); it++) {
if (it != t.begin()) os << ", ";
os << *it;
}
os << "]";
return os;
}
template <typename T>
void scanint(T &x) {
T c = getchar();
while (((c < 48) || (c > 57)) && (c != '-')) c = getchar();
bool neg = false;
if (c == '-') neg = true;
x = 0;
for (; c < 48 || c > 57; c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) x = (x * 10) + (c - 48);
if (neg) x = -x;
}
const int MAXN = 2e5 + 3;
int n, arr[MAXN];
long long freq[MAXN];
bool vis[MAXN];
long long ans[MAXN];
int main() {
scanint(n);
for (int i = 1; i <= n; i++) scanint(arr[i]), freq[arr[i]]++;
if (freq[1]) {
long long sum = 0;
for (int i = 1; i <= n; i++) {
sum += (long long)arr[i];
}
printf("%lld\n", sum);
return 0;
}
for (int i = 1; i < MAXN; i++) {
freq[i] = freq[i - 1] + freq[i];
}
for (long long al = 1; al < MAXN; al++) {
for (long long v = al; v < MAXN; v += al) {
long long temp =
(freq[min(v + al - 1, MAXN - 1ll)] - freq[v - 1]) * (v / al) * al;
ans[al] += temp;
}
}
long long res = 0;
for (int i = 1; i <= n; i++) {
res = max(res, ans[arr[i]]);
}
printf("%I64d\n", res);
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) cout << a[i] << " ";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int x1, y1, x2, y2, ans = 0;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 < x2) {
if (y1 <= y2)
ans = abs(x2 - 1 - x1) + abs(y2 - y1) + 5 + abs(x2 + 1 - x1) +
abs(y2 - 1 - y1);
else
ans = abs(x2 - 1 - x1) + abs(y2 - y1) + 5 + abs(x2 + 1 - x1) +
abs(y2 + 1 - y1);
} else if (x1 == x2)
ans = abs(x2 - x1) + abs(y2 - 1 - y1) + 5 + abs(x2 - 1 - x1) +
abs(y2 + 1 - y1);
else {
if (y1 <= y2)
ans = abs(x2 + 1 - x1) + abs(y2 - 1 - y1) + 5 + abs(x2 - 1 - x1) +
abs(y2 - y1);
else
ans = abs(x2 + 1 - x1) + abs(y2 + 1 - y1) + 5 + abs(x2 - 1 - x1) +
abs(y2 - y1);
}
cout << ans;
return 0;
}
| 20 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char zf = 1;
char ch = getchar();
while (ch != '-' && !isdigit(ch)) ch = getchar();
if (ch == '-') zf = -1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * zf;
}
void write(long long y) {
if (y < 0) putchar('-'), y = -y;
if (y > 9) write(y / 10);
putchar(y % 10 + 48);
}
void writeln(const long long y) {
write(y);
putchar('\n');
}
int i, j, k, m, n, x, y, z, cnt;
long long f[3030][3030], qz[3030][3030];
int d[3030], fa[3030];
int q[3030];
int ksm(long long x, int y) {
if (!y) return 1;
int ew = 1;
while (y > 1) {
if (y & 1) y--, ew = x * ew % 1000000007;
y >>= 1, x = x * x % 1000000007;
}
return x * ew % 1000000007;
}
int main() {
n = read();
m = read();
for (register int i = 2; i <= n; i++) {
x = read();
d[x]++;
fa[i] = x;
}
int h = 0, t = 0;
for (register int i = 1; i <= n; i++)
if (!d[i]) {
q[++t] = i;
for (register int j = 1; j <= n; j++) f[i][j] = 1;
}
for (register int i = 1; i <= n; i++)
for (register int j = 1; j <= n; j++) f[i][j] = 1;
while (h < t) {
x = q[++h];
for (register int j = 1; j <= n; j++)
qz[x][j] = (qz[x][j - 1] + f[x][j]) % 1000000007,
(f[fa[x]][j] *= qz[x][j]) %= 1000000007;
if (x == 1) break;
if (!--d[fa[x]]) q[++t] = fa[x];
}
qz[1][0] = 0;
long long ans = 0, s1, s2;
for (register int i = 0; i <= n; i++) {
s1 = 1;
s2 = 1;
for (register int j = 0; j <= n; j++)
if (i != j) {
s1 = s1 * (m - j) % 1000000007;
s2 = s2 * (i - j) % 1000000007;
}
(ans += qz[1][i] * s1 % 1000000007 * ksm(s2, 1000000007 - 2)) %= 1000000007;
}
cout << ans;
return 0;
}
| 12 | CPP |
n,k=map(int,input().split())
t=list(map(int,input().split()))
j=0
maxx=0
a=1
for i in t:
if i>maxx:
maxx=i
h=1
if a==1:
h=h-1
a=0
else:
h+=1
if h==k:
break
print(maxx)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433;
const long long M = 1e9;
map<long long, set<long long>> ms;
long long a[200100];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m, x, t = 0, s = 0, p, r;
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> a[i];
ms[a[i] % m].insert(i);
}
r = n / m;
for (auto i : ms) {
if (i.first == m - 1) break;
if (i.second.size() > r) {
p = i.second.size() - r;
for (auto j : i.second) {
p--;
while ((ms[t].size() >= r || t <= i.first) && t < m - 1) t++;
ms[t].insert(j);
a[j] += (t - i.first);
s += (t - i.first);
ms[i.first].erase(j);
if (p == 0) break;
}
}
}
t = 0;
bool q = true;
for (auto i : ms[m - 1]) {
while (q && ms[t].size() >= r && t < m - 1) t++;
if (t >= m - 1) break;
if (q) {
p = ms[t].size();
q = false;
}
if (p < r) {
a[i] += t + 1;
s += t + 1;
p++;
if (p == r) {
q = true;
t++;
}
}
}
cout << s << endl;
for (long long i = 0; i < n; i++) cout << a[i] << " ";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int N = 2e6 + 5;
vector<int> g[N];
int a[N], vis[N], sta[N], dis[N], ss;
int dfs(int x, int _dis) {
vis[x] = 1;
sta[++ss] = x;
dis[x] = _dis;
int t;
for (auto v : g[x]) {
if (vis[v]) {
sta[++ss] = v;
return _dis - dis[v] + 1;
} else if (t = dfs(v, _dis + 1))
return t;
}
ss--;
return 0;
}
int main() {
int _ = 0;
for (scanf("%d", &_); _; _--) {
int n, t;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), g[i].push_back(i - a[i]);
for (int i = 1; i <= n; i++) {
if (t = dfs(i, 0)) {
printf("%d\n", t);
for (int j = ss - t + 1; j <= ss; j++) printf("%d ", sta[j]);
putchar('\n');
break;
}
}
for (int i = 1; i <= n; i++) g[i].clear(), vis[i] = 0, ss = 0;
}
return 0;
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
string t, s1 = "";
cin >> t;
for (auto c : t)
if (c != 'a') s1.push_back(c);
if (s1.size() % 2) {
cout << ":(";
return 0;
}
string subs1 = s1.substr(s1.size() / 2, s1.size() / 2);
string subs1_2 = s1.substr(0, s1.size() / 2);
if (subs1 != subs1_2) {
cout << ":(";
return 0;
}
string subt = t.substr(t.size() - s1.size() / 2, s1.size() / 2);
if (subs1 != subt) {
cout << ":(";
return 0;
}
for (int i = 0; i < t.size() - s1.size() / 2; ++i) cout << t[i];
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
void amax(X& x, const Y& y) {
if (x < y) x = y;
}
template <class X, class Y>
void amin(X& x, const Y& y) {
if (x > y) x = y;
}
const int INF = 1e9 + 10;
const long long INFL = 1e18 + 10;
const int MAX = 30;
int n;
int a[MAX];
int gcd(int a, int b) {
while (b != 0) {
int r = a % b;
a = b;
b = r;
}
return a;
}
void process() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int x = a[0];
for (int i = 1; i < n; i++) x = gcd(x, a[i]);
for (int i = x; i >= 1; i--)
if (x % i == 0) {
if (i & 1) {
int last = -1, cnt = 0;
string s;
for (int j = 0; j < n; j++) {
if ((a[j] / i) & 1) {
cnt++;
last = j;
}
for (int k = 0; k < (a[j] / i) / 2; k++) s += (char)(j + 'a');
}
if (cnt > 1) continue;
if (last != -1) s += (char)(last + 'a');
int ns = int(s.size());
for (int j = ns - 1 - (cnt > 0); j >= 0; j--) s += s[j];
cout << i << '\n';
for (int j = 0; j < i; j++) cout << s;
return;
} else {
string s[2];
for (int j = 0; j < n; j++)
for (int k = 0; k < a[j] / i; k++) s[0] += (char)(j + 'a');
for (int j = n - 1; j >= 0; j--)
for (int k = 0; k < a[j] / i; k++) s[1] += (char)(j + 'a');
cout << i << '\n';
for (int j = 0; j < i; j++) cout << s[j & 1];
return;
}
}
cout << 0 << '\n';
for (int i = 0; i < n; i++)
for (int j = 0; j < a[i]; j++) cout << (char)(i + 'a');
}
int main() {
ios_base::sync_with_stdio(false);
process();
}
| 9 | CPP |
t=int(input())
Maxn=210000
while(t>0):
t-=1
n,m=map(int,input().split())
to=[[]]
for i in range(0,n):
to.append([])
d=[0]*(n+1)
ran=[0]*(n+1)
q=[]
cnt=0
to[0].append(1)
for i in range(0,m):
bj,u,v=map(int,input().split())
if(bj):
(to[u]).append(v)
d[v]+=1
q.append((u,v))
else:
q.append((u,v))
que=[]
for i in range(1,n+1):
if(d[i]==0): que.append(i)
while(len(que)):
now=que.pop()
cnt+=1
ran[now]=cnt
for i in to[now]:
d[i]-=1
if(d[i]==0):
que.append(i)
if(cnt!=n):
print("NO")
continue
print("YES")
for i in q:
if(ran[i[0]]<ran[i[1]]):
print(i[0],i[1])
else :
print(i[1],i[0]) | 11 | PYTHON3 |
#include <bits/stdc++.h>
int L[70];
int S[300005];
int E[300005];
int O[300005];
long long T[300005];
int A[300005];
int f(long long x) {
int ret = 0;
while (x) {
if (x & 1) ret++;
x >>= 1;
}
return ret;
}
int main() {
int N;
scanf("%d", &N);
E[0] = 1;
for (int i = 1; i <= N; i++) scanf("%lld", &T[i]);
for (int i = 1; i <= N; i++) A[i] = f(T[i]);
for (int i = 1; i <= N; i++) S[i] = S[i - 1] + A[i];
for (int i = 1; i <= N; i++) {
O[i] = O[i - 1];
E[i] = E[i - 1];
if (S[i] & 1)
O[i]++;
else
E[i]++;
}
long long ans = 0;
for (int i = 1; i <= N; i++) {
int b = 0;
L[A[i]] = i;
for (int j = 63; j >= 1; j--) {
if (L[j] <= b) continue;
int l = b + 1, r = i;
while (l <= r) {
int m = (l + r) >> 1;
if (S[i] - S[m - 1] < 2 * j)
r = m - 1;
else
l = m + 1;
}
if (r <= b) {
b = L[j];
continue;
}
if (r > L[j]) r = L[j];
int o = (b == 0 ? 0 : O[b - 1]);
int e = (b == 0 ? 0 : E[b - 1]);
if (S[i] & 1) {
ans += (O[r - 1] - o);
} else {
ans += (E[r - 1] - e);
}
b = L[j];
}
}
printf("%lld\n", ans);
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e6 + 6, inf = 1e9 + 7;
inline bool isDigit(char c) { return '0' <= c && c <= '9'; }
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline bool isSquare(T x) {
T y = sqrt(x + 0.5);
return (y * y) == x;
}
template <class T1, class T2>
inline T1 gcd(T1 a, T2 b) {
return b ? gcd(b, a % b) : a;
}
template <class T1, class T2>
inline T1 eqMin(T1 &x, const T2 &y) {
if (T1(y) < x) return x = y;
return x;
}
template <class T1, class T2>
inline T1 eqMax(T1 &x, const T2 &y) {
if (T1(y) > x) return x = y;
return x;
}
template <class T1, class T2>
inline T1 min(const T1 &x, const T2 &y) {
return x < (T1)y ? x : (T1)y;
}
template <class T1, class T2>
inline T1 max(T1 &x, const T2 &y) {
return x > (T1)y ? x : (T1)y;
}
template <typename T>
inline T getint() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * p;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.fi << ", " << p.se << ')';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
string s;
cin >> s;
int sz = s.size();
bool flg = 0;
int i = 0;
for (i = 0; i < sz - 1; i++) {
if (s[i] > s[i + 1]) {
flg = 1;
break;
}
}
if (flg) {
for (int j = 0; j < n; j++) {
if (i == j) continue;
cout << s[j];
}
cout << "\n";
} else {
for (int i = 0; i < n - 1; i++) cout << s[i];
cout << "\n";
}
}
| 7 | CPP |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int N;
ll F[1000010] = {1},R[1000010];
ll mem[1000010];
ll mod = 1000000007;
ll ans;
ll pow_mod(ll a,ll b)
{
if(b == 0)return 1;
ll res = pow_mod(a * a % mod, b / 2);
if(b & 1)res = res * a % mod;
return res;
}
ll con(int a,int b)
{
if(a < b)return 0;
return F[a] * R[b] % mod * R[a - b] % mod;
}
int main()
{
scanf("%d",&N);
if(N == 2)
{
printf("1\n");
return 0;
}
for(int i = 1; i < 1000010; i++)F[i] = F[i - 1] * i % mod;
for(int i = 0; i < 1000010; i++)R[i] = pow_mod(F[i],mod - 2);
for(int i = 0; i < N; i++)
{
if((N + 1) / 2 > i)continue;
mem[i] = con(i - 1,N - 1 - i) * F[i] % mod * F[N - 1 - i] % mod;
ans += (mem[i] - mem[i - 1]) * (ll)i % mod;
ans = (ans + mod) % mod;
}
printf("%lld\n",ans);
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
template<class T> inline T sqr(T x) {return x*x;}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define mp make_pair
#define each(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define exist(s,e) ((s).find(e)!=(s).end())
#define range(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) range(i,0,n)
#define clr(a,b) memset((a), (b) ,sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
const double eps = 1e-10;
const double pi = acos(-1.0);
const ll INF =1LL << 62;
const int inf =1 << 29;
map<string,vi> variable;
int main(void){
int n,m;
cin >> m;
rep(i,m){
string var;cin >> var;
int lb,rb;cin >> lb >> rb;
vi in(256,0);
for(int i=lb;i<=rb;++i) in[i]=1;
variable[var]=in;
}
bool ok=true;
cin >> n;
stack<vi> stk;
rep(loop,n){
string e; cin >> e;
if(isdigit(e[0])){vi in(256,0);int num=stoi(e);in[num]=1;stk.push(in);}
else if(isalpha(e[0])){vi in=variable[e];stk.push(in);}
else{
vi a,b,res(256,0);
b=stk.top();stk.pop();a=stk.top();stk.pop();
switch(e[0]){
case '+':
rep(i,256)rep(j,256) if(a[i]&&b[j]) res[(i+j)%256]=1;
break;
case '-':
rep(i,256)rep(j,256) if(a[i]&&b[j]) res[(i-j+256)%256]=1;
break;
case '*':
rep(i,256)rep(j,256) if(a[i]&&b[j]) res[(i*j)%256]=1;
break;
case '/':
rep(i,256)rep(j,256){
if(a[i]&&b[j]){
if(j==0){ok=false; continue;}
res[(i/j)%256]=1;
}
}
break;
}
stk.push(res);
}
}
if(ok)
puts("correct");
else
puts("error");
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 1000 + 10;
int a[M][M];
long long int downleft[M][M];
long long int down[M][M];
long long int downright[M][M];
long long int Right[M][M];
long long int rightup[M][M];
long long int rightdown[M][M];
long long int ans[M][M];
int main() {
time_t t_start, t_end;
t_start = clock();
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
for (int c = 1; c <= m; c++) {
down[n][c] = a[n][c];
}
for (int r = n - 1; r >= 1; r--) {
for (int c = 1; c <= m; c++) {
down[r][c] = down[r + 1][c] + a[r][c];
}
}
for (int c = 1; c <= m; c++) {
for (int r = n; r >= 1; r--) {
long long int n1 = 0;
if (r + 1 <= n && c - 1 >= 1) {
n1 = downleft[r + 1][c - 1];
}
downleft[r][c] = n1 + down[r][c];
}
}
for (int c = m; c >= 1; c--) {
for (int r = n; r >= 1; r--) {
long long int n1 = 0;
if (r + 1 <= n && c + 1 <= m) {
n1 = downright[r + 1][c + 1];
}
downright[r][c] = n1 + down[r][c];
}
}
for (int r = 1; r <= n; r++) {
Right[r][m] = a[r][m];
}
for (int c = m - 1; c >= 1; c--) {
for (int r = 1; r <= n; r++) {
Right[r][c] = Right[r][c + 1] + a[r][c];
}
}
for (int c = m; c >= 1; c--) {
for (int r = 1; r <= n; r++) {
long long int n1 = 0;
if (r - 1 >= 1 && c + 1 <= m) {
n1 = rightup[r - 1][c + 1];
}
rightup[r][c] = n1 + Right[r][c];
}
}
for (int c = m; c >= 1; c--) {
for (int r = n; r >= 1; r--) {
long long int n1 = 0;
if (r + 1 <= n && c + 1 <= m) {
n1 = rightdown[r + 1][c + 1];
}
rightdown[r][c] = n1 + Right[r][c];
}
}
long long int s1 = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
s1 = s1 + a[i][j] * max(0, k - abs(i - k) - abs(j - k));
}
}
ans[k][k] = s1;
for (int r = k + 1; r <= n - k + 1; r++) {
int c = k;
int r1 = r - 1;
int c1 = c;
long long int a1 = rightup[r1][c - k + 1];
int r2 = r1 - k;
int c2 = c1 + 1;
long long int a2 = 0;
if (r2 >= 1 && c2 <= m) {
a2 = rightup[r2][c2];
}
int r3 = r1 - k + 1;
int c3 = c1 + 1;
long long int a3 = 0;
if (r3 >= 1 && c3 <= m) {
a3 = rightdown[r3][c3];
}
int r4 = r1 + 1;
int c4 = c1 + k + 1;
long long int a4 = 0;
if (r4 <= n && c4 <= m) {
a4 = rightdown[r4][c4];
}
long long int t1 = a1 - a2 - (a3 - a4);
r1 = r;
c1 = c;
a1 = rightdown[r][c - k + 1];
r2 = r1 + k;
c2 = c1 + 1;
a2 = 0;
if (r2 <= n && c2 <= m) {
a2 = rightdown[r2][c2];
}
r3 = r2 - 1;
c3 = c2;
a3 = 0;
if (r3 <= n && c3 <= m) {
a3 = rightup[r3][c3];
}
r4 = r1 - 1;
c4 = c1 + k + 1;
a4 = 0;
if (r4 >= 1 && c4 <= m) {
a4 = rightup[r4][c4];
}
long long int t2 = a1 - a2 - (a3 - a4);
ans[r][k] = ans[r - 1][k] - t1 + t2;
}
for (int r = k; r <= n - k + 1; r++) {
for (int c = k + 1; c <= m - k + 1; c++) {
int r1 = r;
int c1 = c - 1;
long long int a1 = downleft[r1 - k + 1][c1];
int r2 = r1 + 1;
int c2 = c1 - k;
long long int a2 = 0;
if (r2 <= n && c2 >= 1) {
a2 = downleft[r2][c2];
}
int r3 = r2;
int c3 = c2 + 1;
long long int a3 = 0;
if (r3 <= n && c3 <= m) {
a3 = downright[r3][c3];
}
int r4 = r1 + k + 1;
int c4 = c1 + 1;
long long int a4 = 0;
if (r4 <= n && c4 <= m) {
a4 = downright[r4][c4];
}
long long int t1 = a1 - a2 - (a3 - a4);
r1 = r;
c1 = c;
a1 = downright[r1 - k + 1][c1];
r2 = r1 + 1;
c2 = c1 + k;
a2 = 0;
if (r2 <= n && c2 <= m) {
a2 = downright[r2][c2];
}
r3 = r1 + 1;
c3 = c1 + k - 1;
a3 = 0;
if (r3 <= n && c3 <= m) {
a3 = downleft[r3][c3];
}
r4 = r1 + k + 1;
c4 = c1 - 1;
a4 = 0;
if (r4 <= n && c4 >= 1) {
a4 = downleft[r4][c4];
}
long long int t2 = a1 - a2 - (a3 - a4);
ans[r][c] = ans[r][c - 1] - t1 + t2;
}
}
int ansr = k;
int ansc = k;
long long int ansv = ans[k][k];
for (int r = k; r <= n - k + 1; r++) {
for (int c = k; c <= m - k + 1; c++) {
if (ans[r][c] > ansv) {
ansv = ans[r][c];
ansr = r;
ansc = c;
}
}
}
cout << ansr << " " << ansc << endl;
t_end = clock();
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
int type(char *str, int len) {
if (str[0] == 'R' && str[1] <= '9' && str[1] >= '0') {
int i;
for (i = 2; i < len; i++)
if (str[i] == 'C') return 1;
}
return 2;
}
int toNumber(char *str, int len) {
int i, n;
for (i = 0, n = 0; i < len; i++) n = n * 26 + (str[i] - 'A' + 1);
return n;
}
void convertToRC(char *str, int len) {
char *prow;
int col_len;
for (prow = str, col_len = 0; *prow <= 'Z' && *prow >= 'A'; prow++, col_len++)
;
printf("R%sC%d\n", prow, toNumber(str, col_len));
}
void toLetter(char *str, int len) {
char ch[16 / 2];
int i, n;
for (i = 0, n = atoi(str); n > 0; i++) {
if (n % 26 == 0) {
ch[i] = 'Z';
n = n / 26 - 1;
} else {
ch[i] = 'A' + n % 26 - 1;
n = n / 26;
}
}
for (i = i - 1; i > -1; i--) printf("%c", ch[i]);
}
void convertToCR(char *str, int len) {
char *pcol;
int row_len;
for (pcol = &str[1], row_len = 0; *pcol <= '9' && *pcol >= '0';
pcol++, row_len++)
;
toLetter(pcol + 1, len - 2 - row_len);
int i;
for (i = 1; i <= row_len; i++) printf("%c", str[i]);
printf("\n");
}
void convert(char *str, int len) {
int t;
t = type(str, len);
if (t == 1)
convertToCR(str, len);
else if (t == 2)
convertToRC(str, len);
}
int main() {
int i, n;
scanf("%d", &n);
char in[16];
for (i = 0; i < n; i++) {
scanf("%s", in);
convert(in, strlen(in));
}
return 0;
}
| 8 | CPP |
import io, os
from functools import reduce
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
int10 = lambda n: int(n, 10)
t = int10(input().decode())
def cal(a: list):
while 1:
n = len(a)
for i in range(n):
for j in range(i+1, n):
if abs(a[i] - a[j]) not in a:
a.append(abs(a[i] - a[j]))
if len(a) > 300:
return None
if len(a) == n:
break
return a
for _ in range(t):
n = int10(input().decode())
a = list(map(int,input().decode().split()))
failed = False
for ai in a:
if ai < 0:
failed = True
break
if failed:
print('no')
continue
res = cal(a)
if res:
print('yes')
print(len(res))
print(' '.join([str(c) for c in res]))
else:
print('no')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXSN = 1000;
const int MAXSM = MAXSN - 1;
const int MAXTN = 12;
const int MAXTM = MAXTN - 1;
const int MOD = 1000000007;
int sn;
int shead[MAXSN], snxt[2 * MAXSM], sto[2 * MAXSM];
int tn;
int thead[MAXTN], tnxt[2 * MAXTM], tto[2 * MAXTM];
int tsz[2 * MAXTM];
int calctsz(int x) {
if (tsz[x] != 0)
return tsz[x];
else
tsz[x] = 1;
int at = tto[x];
for (int y = thead[at]; y != -1; y = tnxt[y])
if ((y ^ 1) != x) tsz[x] += calctsz(y);
return tsz[x];
}
int memst[MAXSN + 2 * MAXSM][MAXTN + 2 * MAXTM];
int memtt[MAXTN + 2 * MAXTM][MAXTN + 2 * MAXTM];
int z[MAXTN], nz;
int dp[1 << MAXTN];
int calcst(int av, int pax, int bv, int pbx) {
int aid = pax == -1 ? av : sn + pax, bid = pbx == -1 ? bv : tn + pbx;
int &ret = memst[aid][bid];
if (ret == -1) {
ret = 0;
for (int ax = shead[av]; ax != -1; ax = snxt[ax])
if (pax == -1 || (ax ^ 1) != pax) {
int aw = sto[ax];
for (int bx = thead[bv]; bx != -1; bx = tnxt[bx])
if (pbx == -1 || (bx ^ 1) != pbx) {
int bw = tto[bx];
calcst(aw, ax, bw, bx);
}
}
int bx1 = -1, nbx1 = 0, bx2 = -1, nbx2 = 0;
nz = 0;
for (int bx = thead[bv]; bx != -1; bx = tnxt[bx])
if (pbx == -1 || (bx ^ 1) != pbx) {
if (tsz[bx] == 1)
bx1 = bx, nbx1++;
else if (tsz[bx] == 2)
bx2 = bx, nbx2++;
else
z[nz++] = bx;
}
int n = (nbx1 + 1) * (nbx2 + 1) * (1 << nz);
for (int i = (0); i < (n); ++i) dp[i] = 0;
dp[0] = 1;
for (int ax = shead[av]; ax != -1; ax = snxt[ax])
if (pax == -1 || (ax ^ 1) != pax) {
int aw = sto[ax];
for (int k1 = nbx1; k1 >= 0; --k1)
for (int k2 = nbx2; k2 >= 0; --k2)
for (int kz = (1 << nz) - 1; kz >= 0; --kz) {
int k = k1 + (nbx1 + 1) * (k2 + (nbx2 + 1) * kz);
if (dp[k] == 0) continue;
for (int j = (0); j < (nz + 2); ++j) {
int nk1 = k1, nk2 = k2, nkz = kz, times = 1;
int bx = j < nz ? z[j] : j == nz ? bx1 : bx2;
if (bx == -1) continue;
int bw = tto[bx];
int cur = calcst(aw, ax, bw, bx);
if (j < nz)
if (kz & (1 << j))
continue;
else
nkz |= 1 << j;
if (j == nz)
if (k1 == nbx1)
continue;
else
++nk1, times *= nbx1 - k1;
if (j == nz + 1)
if (k2 == nbx2)
continue;
else
++nk2, times *= nbx2 - k2;
int nk = nk1 + (nbx1 + 1) * (nk2 + (nbx2 + 1) * nkz);
dp[nk] = (dp[nk] + (long long)dp[k] * cur * times) % MOD;
}
}
}
ret = dp[n - 1];
}
return ret;
}
int calctt(int av, int pax, int bv, int pbx) {
int aid = pax == -1 ? av : tn + pax, bid = pbx == -1 ? bv : tn + pbx;
int &ret = memtt[aid][bid];
if (ret == -1) {
ret = 0;
for (int ax = thead[av]; ax != -1; ax = tnxt[ax])
if (pax == -1 || (ax ^ 1) != pax) {
int aw = tto[ax];
for (int bx = thead[bv]; bx != -1; bx = tnxt[bx])
if (pbx == -1 || (bx ^ 1) != pbx) {
int bw = tto[bx];
calctt(aw, ax, bw, bx);
}
}
int bx1 = -1, nbx1 = 0, bx2 = -1, nbx2 = 0;
nz = 0;
for (int bx = thead[bv]; bx != -1; bx = tnxt[bx])
if (pbx == -1 || (bx ^ 1) != pbx) {
if (tsz[bx] == 1)
bx1 = bx, nbx1++;
else if (tsz[bx] == 2)
bx2 = bx, nbx2++;
else
z[nz++] = bx;
}
int n = (nbx1 + 1) * (nbx2 + 1) * (1 << nz);
for (int i = (0); i < (n); ++i) dp[i] = 0;
dp[0] = 1;
for (int ax = thead[av]; ax != -1; ax = tnxt[ax])
if (pax == -1 || (ax ^ 1) != pax) {
int aw = tto[ax];
for (int k1 = nbx1; k1 >= 0; --k1)
for (int k2 = nbx2; k2 >= 0; --k2)
for (int kz = (1 << nz) - 1; kz >= 0; --kz) {
int k = k1 + (nbx1 + 1) * (k2 + (nbx2 + 1) * kz);
if (dp[k] == 0) continue;
for (int j = (0); j < (nz + 2); ++j) {
int nk1 = k1, nk2 = k2, nkz = kz, times = 1;
int bx = j < nz ? z[j] : j == nz ? bx1 : bx2;
if (bx == -1) continue;
int bw = tto[bx];
int cur = calctt(aw, ax, bw, bx);
if (j < nz)
if (kz & (1 << j))
continue;
else
nkz |= 1 << j;
if (j == nz)
if (k1 == nbx1)
continue;
else
++nk1, times *= nbx1 - k1;
if (j == nz + 1)
if (k2 == nbx2)
continue;
else
++nk2, times *= nbx2 - k2;
int nk = nk1 + (nbx1 + 1) * (nk2 + (nbx2 + 1) * nkz);
dp[nk] = (dp[nk] + (long long)dp[k] * cur * times) % MOD;
}
}
}
ret = dp[n - 1];
}
return ret;
}
int mypow(int x, int n) {
int ret = 1;
while (true) {
if (n & 1) ret = (long long)ret * x % MOD;
if ((n >>= 1) == 0) return ret;
x = (long long)x * x % MOD;
}
}
void run() {
scanf("%d", &sn);
for (int i = (0); i < (sn); ++i) shead[i] = -1;
for (int i = (0); i < (sn - 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
snxt[2 * i + 0] = shead[a], shead[a] = 2 * i + 0, sto[2 * i + 0] = b,
snxt[2 * i + 1] = shead[b], shead[b] = 2 * i + 1,
sto[2 * i + 1] = a;
}
scanf("%d", &tn);
for (int i = (0); i < (tn); ++i) thead[i] = -1;
for (int i = (0); i < (tn - 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
tnxt[2 * i + 0] = thead[a], thead[a] = 2 * i + 0, tto[2 * i + 0] = b,
tnxt[2 * i + 1] = thead[b], thead[b] = 2 * i + 1,
tto[2 * i + 1] = a;
}
memset(tsz, 0, sizeof(tsz));
for (int i = (0); i < (2 * (tn - 1)); ++i) calctsz(i);
int cnt = 0;
memset(memst, -1, sizeof(memst));
for (int i = (0); i < (sn); ++i) {
int cur = calcst(i, -1, 0, -1);
if ((cnt += cur) >= MOD) cnt -= MOD;
}
int times = 0;
memset(memtt, -1, sizeof(memtt));
for (int i = (0); i < (tn); ++i) {
int cur = calctt(i, -1, 0, -1);
if ((times += cur) >= MOD) times -= MOD;
}
int ret = (long long)cnt * mypow(times, MOD - 2) % MOD;
printf("%d\n", ret);
}
int main() {
run();
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long z;
cin >> z;
long long l = (sqrt(z)) + 1;
bool found = false;
for (long long i = 1; i <= l; i++) {
long long b = (i * i) + i + 1;
long long a = 2 * i;
if (z <= b) break;
if (z - b > 0 && (z - b) % a == 0) {
found = true;
cout << i << " " << (z - b) / a << endl;
break;
}
}
if (!found) cout << "NO" << endl;
return 0;
}
| 7 | CPP |
n,k=list(map(int,input().split()))
s= input()
d={}
for i in range(k):
d[chr(ord('A')+i)]=0
for i in s:
d[i]+=1
m = min(d.values())
l= m*k
print(l)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
class HungarianAlgorithm {
public:
HungarianAlgorithm();
~HungarianAlgorithm();
double Solve(vector<vector<double> > &DistMatrix, vector<int> &Assignment);
private:
void assignmentoptimal(int *assignment, double *cost, double *distMatrix,
int nOfRows, int nOfColumns);
void buildassignmentvector(int *assignment, bool *starMatrix, int nOfRows,
int nOfColumns);
void computeassignmentcost(int *assignment, double *cost, double *distMatrix,
int nOfRows);
void step2a(int *assignment, double *distMatrix, bool *starMatrix,
bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns,
bool *coveredRows, int nOfRows, int nOfColumns, int minDim);
void step2b(int *assignment, double *distMatrix, bool *starMatrix,
bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns,
bool *coveredRows, int nOfRows, int nOfColumns, int minDim);
void step3(int *assignment, double *distMatrix, bool *starMatrix,
bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns,
bool *coveredRows, int nOfRows, int nOfColumns, int minDim);
void step4(int *assignment, double *distMatrix, bool *starMatrix,
bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns,
bool *coveredRows, int nOfRows, int nOfColumns, int minDim,
int row, int col);
void step5(int *assignment, double *distMatrix, bool *starMatrix,
bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns,
bool *coveredRows, int nOfRows, int nOfColumns, int minDim);
};
HungarianAlgorithm::HungarianAlgorithm() {}
HungarianAlgorithm::~HungarianAlgorithm() {}
double HungarianAlgorithm::Solve(vector<vector<double> > &DistMatrix,
vector<int> &Assignment) {
unsigned int nRows = DistMatrix.size();
unsigned int nCols = DistMatrix[0].size();
double *distMatrixIn = new double[nRows * nCols];
int *assignment = new int[nRows];
double cost = 0.0;
for (unsigned int i = 0; i < nRows; i++)
for (unsigned int j = 0; j < nCols; j++)
distMatrixIn[i + nRows * j] = DistMatrix[i][j];
assignmentoptimal(assignment, &cost, distMatrixIn, nRows, nCols);
Assignment.clear();
for (unsigned int r = 0; r < nRows; r++) Assignment.push_back(assignment[r]);
delete[] distMatrixIn;
delete[] assignment;
return cost;
}
void HungarianAlgorithm::assignmentoptimal(int *assignment, double *cost,
double *distMatrixIn, int nOfRows,
int nOfColumns) {
double *distMatrix, *distMatrixTemp, *distMatrixEnd, *columnEnd, value,
minValue;
bool *coveredColumns, *coveredRows, *starMatrix, *newStarMatrix, *primeMatrix;
int nOfElements, minDim, row, col;
*cost = 0;
for (row = 0; row < nOfRows; row++) assignment[row] = -1;
nOfElements = nOfRows * nOfColumns;
distMatrix = (double *)malloc(nOfElements * sizeof(double));
distMatrixEnd = distMatrix + nOfElements;
for (row = 0; row < nOfElements; row++) {
value = distMatrixIn[row];
if (value < 0)
cerr << "All matrix elements have to be non-negative." << endl;
distMatrix[row] = value;
}
coveredColumns = (bool *)calloc(nOfColumns, sizeof(bool));
coveredRows = (bool *)calloc(nOfRows, sizeof(bool));
starMatrix = (bool *)calloc(nOfElements, sizeof(bool));
primeMatrix = (bool *)calloc(nOfElements, sizeof(bool));
newStarMatrix = (bool *)calloc(nOfElements, sizeof(bool));
if (nOfRows <= nOfColumns) {
minDim = nOfRows;
for (row = 0; row < nOfRows; row++) {
distMatrixTemp = distMatrix + row;
minValue = *distMatrixTemp;
distMatrixTemp += nOfRows;
while (distMatrixTemp < distMatrixEnd) {
value = *distMatrixTemp;
if (value < minValue) minValue = value;
distMatrixTemp += nOfRows;
}
distMatrixTemp = distMatrix + row;
while (distMatrixTemp < distMatrixEnd) {
*distMatrixTemp -= minValue;
distMatrixTemp += nOfRows;
}
}
for (row = 0; row < nOfRows; row++)
for (col = 0; col < nOfColumns; col++)
if (fabs(distMatrix[row + nOfRows * col]) < DBL_EPSILON)
if (!coveredColumns[col]) {
starMatrix[row + nOfRows * col] = true;
coveredColumns[col] = true;
break;
}
} else {
minDim = nOfColumns;
for (col = 0; col < nOfColumns; col++) {
distMatrixTemp = distMatrix + nOfRows * col;
columnEnd = distMatrixTemp + nOfRows;
minValue = *distMatrixTemp++;
while (distMatrixTemp < columnEnd) {
value = *distMatrixTemp++;
if (value < minValue) minValue = value;
}
distMatrixTemp = distMatrix + nOfRows * col;
while (distMatrixTemp < columnEnd) *distMatrixTemp++ -= minValue;
}
for (col = 0; col < nOfColumns; col++)
for (row = 0; row < nOfRows; row++)
if (fabs(distMatrix[row + nOfRows * col]) < DBL_EPSILON)
if (!coveredRows[row]) {
starMatrix[row + nOfRows * col] = true;
coveredColumns[col] = true;
coveredRows[row] = true;
break;
}
for (row = 0; row < nOfRows; row++) coveredRows[row] = false;
}
step2b(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix,
coveredColumns, coveredRows, nOfRows, nOfColumns, minDim);
computeassignmentcost(assignment, cost, distMatrixIn, nOfRows);
free(distMatrix);
free(coveredColumns);
free(coveredRows);
free(starMatrix);
free(primeMatrix);
free(newStarMatrix);
return;
}
void HungarianAlgorithm::buildassignmentvector(int *assignment,
bool *starMatrix, int nOfRows,
int nOfColumns) {
int row, col;
for (row = 0; row < nOfRows; row++)
for (col = 0; col < nOfColumns; col++)
if (starMatrix[row + nOfRows * col]) {
assignment[row] = col;
break;
}
}
void HungarianAlgorithm::computeassignmentcost(int *assignment, double *cost,
double *distMatrix,
int nOfRows) {
int row, col;
for (row = 0; row < nOfRows; row++) {
col = assignment[row];
if (col >= 0) *cost += distMatrix[row + nOfRows * col];
}
}
void HungarianAlgorithm::step2a(int *assignment, double *distMatrix,
bool *starMatrix, bool *newStarMatrix,
bool *primeMatrix, bool *coveredColumns,
bool *coveredRows, int nOfRows, int nOfColumns,
int minDim) {
bool *starMatrixTemp, *columnEnd;
int col;
for (col = 0; col < nOfColumns; col++) {
starMatrixTemp = starMatrix + nOfRows * col;
columnEnd = starMatrixTemp + nOfRows;
while (starMatrixTemp < columnEnd) {
if (*starMatrixTemp++) {
coveredColumns[col] = true;
break;
}
}
}
step2b(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix,
coveredColumns, coveredRows, nOfRows, nOfColumns, minDim);
}
void HungarianAlgorithm::step2b(int *assignment, double *distMatrix,
bool *starMatrix, bool *newStarMatrix,
bool *primeMatrix, bool *coveredColumns,
bool *coveredRows, int nOfRows, int nOfColumns,
int minDim) {
int col, nOfCoveredColumns;
nOfCoveredColumns = 0;
for (col = 0; col < nOfColumns; col++)
if (coveredColumns[col]) nOfCoveredColumns++;
if (nOfCoveredColumns == minDim) {
buildassignmentvector(assignment, starMatrix, nOfRows, nOfColumns);
} else {
step3(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix,
coveredColumns, coveredRows, nOfRows, nOfColumns, minDim);
}
}
void HungarianAlgorithm::step3(int *assignment, double *distMatrix,
bool *starMatrix, bool *newStarMatrix,
bool *primeMatrix, bool *coveredColumns,
bool *coveredRows, int nOfRows, int nOfColumns,
int minDim) {
bool zerosFound;
int row, col, starCol;
zerosFound = true;
while (zerosFound) {
zerosFound = false;
for (col = 0; col < nOfColumns; col++)
if (!coveredColumns[col])
for (row = 0; row < nOfRows; row++)
if ((!coveredRows[row]) &&
(fabs(distMatrix[row + nOfRows * col]) < DBL_EPSILON)) {
primeMatrix[row + nOfRows * col] = true;
for (starCol = 0; starCol < nOfColumns; starCol++)
if (starMatrix[row + nOfRows * starCol]) break;
if (starCol == nOfColumns) {
step4(assignment, distMatrix, starMatrix, newStarMatrix,
primeMatrix, coveredColumns, coveredRows, nOfRows,
nOfColumns, minDim, row, col);
return;
} else {
coveredRows[row] = true;
coveredColumns[starCol] = false;
zerosFound = true;
break;
}
}
}
step5(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix,
coveredColumns, coveredRows, nOfRows, nOfColumns, minDim);
}
void HungarianAlgorithm::step4(int *assignment, double *distMatrix,
bool *starMatrix, bool *newStarMatrix,
bool *primeMatrix, bool *coveredColumns,
bool *coveredRows, int nOfRows, int nOfColumns,
int minDim, int row, int col) {
int n, starRow, starCol, primeRow, primeCol;
int nOfElements = nOfRows * nOfColumns;
for (n = 0; n < nOfElements; n++) newStarMatrix[n] = starMatrix[n];
newStarMatrix[row + nOfRows * col] = true;
starCol = col;
for (starRow = 0; starRow < nOfRows; starRow++)
if (starMatrix[starRow + nOfRows * starCol]) break;
while (starRow < nOfRows) {
newStarMatrix[starRow + nOfRows * starCol] = false;
primeRow = starRow;
for (primeCol = 0; primeCol < nOfColumns; primeCol++)
if (primeMatrix[primeRow + nOfRows * primeCol]) break;
newStarMatrix[primeRow + nOfRows * primeCol] = true;
starCol = primeCol;
for (starRow = 0; starRow < nOfRows; starRow++)
if (starMatrix[starRow + nOfRows * starCol]) break;
}
for (n = 0; n < nOfElements; n++) {
primeMatrix[n] = false;
starMatrix[n] = newStarMatrix[n];
}
for (n = 0; n < nOfRows; n++) coveredRows[n] = false;
step2a(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix,
coveredColumns, coveredRows, nOfRows, nOfColumns, minDim);
}
void HungarianAlgorithm::step5(int *assignment, double *distMatrix,
bool *starMatrix, bool *newStarMatrix,
bool *primeMatrix, bool *coveredColumns,
bool *coveredRows, int nOfRows, int nOfColumns,
int minDim) {
double h, value;
int row, col;
h = DBL_MAX;
for (row = 0; row < nOfRows; row++)
if (!coveredRows[row])
for (col = 0; col < nOfColumns; col++)
if (!coveredColumns[col]) {
value = distMatrix[row + nOfRows * col];
if (value < h) h = value;
}
for (row = 0; row < nOfRows; row++)
if (coveredRows[row])
for (col = 0; col < nOfColumns; col++)
distMatrix[row + nOfRows * col] += h;
for (col = 0; col < nOfColumns; col++)
if (!coveredColumns[col])
for (row = 0; row < nOfRows; row++) distMatrix[row + nOfRows * col] -= h;
step3(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix,
coveredColumns, coveredRows, nOfRows, nOfColumns, minDim);
}
int getnum(char x) {
if (x >= 'a') return x - 'a';
return x - 'A' + 26;
}
char getalpha(int x) {
if (x >= 26) return 'A' + x - 26;
return 'a' + x;
}
int main() {
int n, k;
cin >> n >> k;
string a, b;
cin >> a >> b;
vector<vector<double> > A(k);
std::vector<int> B(k);
for (int i = 0; i < k; i++) {
A[i].resize(k);
for (int j = 0; j < k; j++) A[i][j] = 10000000;
}
for (int i = 0; i < n; i++) {
A[getnum(a[i])][getnum(b[i])] -= 1;
}
HungarianAlgorithm abc;
cout << ((k * 10000000) - abc.Solve(A, B)) << endl;
for (int i : B) cout << getalpha(i);
}
| 9 | CPP |
n=input()
dm=0
while(1):
if len(n)==1:
break
else:
data=[]
for i in n:
data.append(int(i))
n=str(sum(data))
dm+=1
print(dm) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct race {
int begin, end, profit;
inline bool operator<(const race &r) const { return end < r.end; }
};
vector<race> races;
vector<int> cost;
struct iTree {
struct node {
long long int modif, max;
node(int val = 0) { modif = max = val; }
};
static const int N = 1 << 18;
node *tab;
iTree() {
tab = new node[2 * N];
for (int i = 0; i < 2 * N; i++) tab[i] = 0;
}
long long int getmax() { return tab[1].max; }
void propagate(int ind) {
do
tab[ind].max =
tab[ind].modif +
(ind >= N ? 0 : max(tab[2 * ind].max, tab[2 * ind + 1].max));
while (ind /= 2);
}
void update(int a, int b, long long int change) {
a += N;
b += N;
while (a < b) {
if (a & 1) {
update(a, change);
a += 1;
}
if (!(b & 1)) {
update(b, change);
b -= 1;
}
a /= 2;
b /= 2;
}
if (a == b) update(a, change);
}
void set(int ind, long long int val) {
ind += N;
tab[ind].modif = val;
propagate(ind);
}
private:
void update(int ind, long long int change) {
tab[ind].modif += change;
propagate(ind);
}
};
int main() {
iTree TT;
int n, m;
scanf("%d %d", &n, &m);
cost.resize(n);
for (int i = 0; i < n; i++) scanf("%d", &cost[i]);
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
a--;
b--;
races.push_back((race){a, b, c});
}
sort(races.begin(), races.end());
long long int DPM1 = 0;
for (int k = 0, rind = 0; k < n; k++) {
;
long long int maxless = max(DPM1, TT.getmax());
TT.set(k, maxless);
DPM1 -= cost[k];
TT.update(0, k - 1, -cost[k]);
;
while (rind < races.size() && races[rind].end == k) {
DPM1 += races[rind].profit;
TT.update(0, races[rind].begin - 1, races[rind].profit);
rind++;
}
}
cout << max(DPM1, TT.getmax()) << endl;
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
stack<pair<int, int> > targetPoints;
queue<pair<int, int> > q;
int penalty;
int tx[] = {0, 1};
int ty[] = {1, 0};
bool visited[51][51];
bool validTargetPoint(int x, int y, int maxX, int maxY) {
if (x > maxX || y > maxY || x < 1 || y < 1) return 0;
if (visited[x][y]) return 0;
visited[x][y] = true;
return 1;
}
void findTargetPoints(int n, int m, int k) {
penalty = 2;
targetPoints.push(pair<int, int>(1, 1));
q.push(pair<int, int>(1, 1));
visited[1][1] = true;
k--;
if (k) {
while (!q.empty()) {
struct pair<int, int> xyPair = q.front();
q.pop();
for (int p = 0; p < 2; p++) {
if (validTargetPoint(xyPair.first + tx[p], xyPair.second + ty[p], n,
m)) {
targetPoints.push(
pair<int, int>(xyPair.first + tx[p], xyPair.second + ty[p]));
q.push(pair<int, int>(xyPair.first + tx[p], xyPair.second + ty[p]));
k--;
penalty += xyPair.first + tx[p] + xyPair.second + ty[p];
if (k == 0) break;
}
}
if (k == 0) break;
}
}
penalty -= targetPoints.size();
}
void printPathFor(pair<int, int> coordinate) {
int targetX = coordinate.first;
int targetY = coordinate.second;
int i = 1, j = 1;
for (i = 1; i < targetX; i++) {
printf("(%d,%d) ", i, 1);
}
if (targetY != 1)
printf("(%d,%d) ", i, 1);
else
printf("(%d,%d)\n", i, 1);
for (j = 2; j < targetY; j++) {
printf("(%d,%d) ", i, j);
}
if (targetY != 1) printf("(%d,%d)\n", i, j);
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
findTargetPoints(n, m, k);
printf("%d\n", penalty);
while (!targetPoints.empty()) {
pair<int, int> targetCoordinate = targetPoints.top();
printPathFor(targetCoordinate);
targetPoints.pop();
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, d, t;
cin >> k >> d >> t;
t *= 2;
if (k <= d) {
long long rs = 0;
long long c = k + d;
rs += 2 * d * (t / c);
long long tt = t - c * (t / c);
if (tt <= 2 * k) {
rs += tt;
} else {
rs += 2 * k;
long long ttt = tt - 2 * k;
rs += 2 * ttt;
}
if (rs % 2)
cout << to_string(rs / 2) << ".5" << endl;
else
cout << to_string(rs / 2) << endl;
return 0;
}
long long rs = 0;
long long c = k / d;
if (k % d) ++c;
long long ct = 2 * k + c * d - k;
rs += 2 * c * d * (t / ct);
long long tt = t - ct * (t / ct);
if (tt <= 2 * k) {
rs += tt;
} else {
rs += 2 * k;
long long ttt = tt - 2 * k;
rs += 2 * ttt;
}
if (rs % 2)
cout << to_string(rs / 2) << ".5" << endl;
else
cout << to_string(rs / 2) << endl;
return 0;
}
| 7 | CPP |
n,m,k=list(map(int,input().split()))
for i in range(k):
sx,sy=map(int,input().split())
for i in range(k):
fx,fy=map(int,input().split())
ans="L"*(m-1)+"U"*(n-1)
for i in range(n):
if(i!=0):
ans=ans+"D"
if(i%2==0):
ans=ans+"R"*(m-1)
elif(i%2!=0):
ans=ans+"L"*(m-1)
print(len(ans))
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int NMax = 105, MMax = 55, INF = 1000000007;
int N, M, K;
int dp[MMax][NMax][MMax][NMax], C[NMax][NMax], Q[NMax][NMax];
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int i = 0; i <= 100; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
if (C[i][j] > 200) C[i][j] = 200;
}
}
for (int i = 0; i <= 100; i++)
for (int j = 0; j <= 100; j++) {
if (i == 0 || j == 0) {
Q[i][j] = 1;
continue;
}
for (int k = 0; k < i; k++) {
if (C[i][k] * C[j - 1][i - k - 1] >= 200) {
Q[i][j] = 200;
break;
}
Q[i][j] = Q[i][j] + C[i][k] * C[j - 1][i - k - 1];
if (Q[i][j] >= 200) {
Q[i][j] = 200;
break;
}
}
}
for (int i = 0; i <= 10; i++) {
for (int j = 0; j <= 10; j++) {
}
}
dp[1][0][0][1] = 1;
int ret = 0;
for (int i = 1; i <= min(M, N / 2 + 1); i++) {
for (int j = 0; j <= N; j++) {
for (int k = 0; k <= (N + 1) / 2; k++) {
for (int l = 1; l <= K; l++) {
int s = dp[i][j][k][l];
if (!s) continue;
if (j > 0)
ret = (ret + (int)(((long long)(M - i + 1) * (long long)s) %
(long long)INF)) %
INF;
for (int d = 1; d <= (N + 1) / 2; d++) {
if (d * 2 + j > N) break;
int way = l * Q[k][d];
if (way <= K) {
int t = dp[i + 1][d * 2 + j][d][way];
dp[i + 1][d * 2 + j][d][way] = (t + dp[i][j][k][l]) % INF;
}
}
}
}
}
}
printf("%d\n", ret);
return 0;
}
| 11 | CPP |
n,m = map(int , input().split())
l = []
for i in range(n):
a = input()
l.append(a)
d = 1
for i in range(n):
for j in range(m):
t = 0
if i>0 and l[i-1][j]=="*":
t+=1
if i<n-1 and l[i+1][j]=="*":
t+=1
if j>0 and l[i][j-1]=="*":
t+=1
if j<m-1 and l[i][j+1]=="*":
t+=1
if i>0 and j>0 and l[i-1][j-1]=="*":
t+=1
if i>0 and j<m-1 and l[i-1][j+1]=="*":
t+=1
if i<n-1 and j>0 and l[i+1][j-1]=="*":
t+=1
if i<n-1 and j<m-1 and l[i+1][j+1]=="*":
t+=1
if l[i][j]=="." and t!=0:
d = 0
break
elif l[i][j]!="*" and l[i][j]!="." and int(l[i][j])!=t:
d = 0 ;
break
if d==1:print('YES')
else:
print("NO")
| 8 | PYTHON3 |
from sys import stdin , stdout
from collections import defaultdict
import math
def get_list(): return list(map(int, stdin.readline().strip().split()))
def get_int(): return int(stdin.readline())
def get_ints(): return map(int, stdin.readline().strip().split())
def get_string(): return stdin.readline()
def printn(n) : stdout.write(str(n) + "\n")
def solve() :
n = get_int()
a = get_list()
tot = 0; cur = 0
stk = [[0,0]]
for i in range(0,n-1,2):
x = a[i] ; y = a[i+1]
cur += x-y
tot += min(y, cur + y- stk[0][0])
while stk and stk[-1][0] > cur :
tot += stk[-1][1]
stk.pop(-1)
if stk and stk[-1][0] == cur :
tot += stk[-1][1]
stk[-1][1]+=1
else :
if stk : stk.append([cur,1])
else : stk.append([cur,0])
printn(tot)
return
if __name__ == "__main__" :
# t = get_int()
t = 1
while t:
t-=1
solve() | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long c(0);
while (n--) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
c += (x2 - x1 + 1) * (y2 - y1 + 1);
}
cout << c;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long tc, x, y, z, b, c, d, e, k, p, q = 0, r, n, m, i, j;
long long a[4] = {1, 3, 20, 7};
string s, t, ss = "ABC";
char ch;
vector<char> u, v;
set<char> st;
set<char>::iterator it;
map<char, long long> mp;
cin >> s >> t;
n = s.length();
m = t.length();
i = n - 1;
j = m - 1;
while (i >= 0 && j >= 0) {
if (s[i] == t[j])
q++;
else
break;
i--;
j--;
}
cout << n - q + m - q << endl;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
long long a, b, c;
cin >> a >> b >> c;
if (c <= 1) {
if (c == 1) cout << b;
if (c == 0) cout << a;
cout << "\n";
} else {
if (c % 3 == 0)
cout << a;
else if (c % 3 == 1)
cout << b;
else
cout << (a ^ b);
cout << "\n";
}
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2010;
vector<int> G[maxn];
int n, m, d[maxn], par[maxn], a[maxn], vis[maxn], flag = 1;
char s[1005][1005];
int find(int u) {
if (par[u] != u) par[u] = find(par[u]);
return par[u];
}
struct node {
int u, w;
node(int a, int b) { u = a, w = b; }
};
void topo() {
queue<node> q;
for (int i = 1; i <= n + m; i++) {
int fa = find(i);
if (!d[fa] && !vis[fa]) q.push(node(fa, 1)), vis[fa] = 1;
}
while (!q.empty()) {
node e = q.front();
q.pop();
int u = e.u;
a[u] = max(a[u], e.w);
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
a[v] = max(a[u] + 1, a[v]);
d[v]--;
if (d[v] == 0) q.push(node(v, a[v]));
}
}
for (int i = 1; i <= n + m; i++)
if (d[i]) puts("No"), exit(0);
}
void add(int i, int j) {
int fa = find(i), fb = find(j);
if (fa == fb) puts("No"), exit(0);
d[fa]++;
G[fb].push_back(fa);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n + m; i++) par[i] = i;
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= m; j++)
if (s[i][j] == '=') {
int fa = find(i), fb = find(j + n);
par[fa] = fb;
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (s[i][j] == '>')
add(i, n + j);
else if (s[i][j] == '<')
add(n + j, i);
topo();
puts("Yes");
for (int i = 1; i < n; i++) printf("%d ", a[find(i)]);
printf("%d\n", a[find(n)]);
for (int i = 1; i < m; i++) printf("%d ", a[find(i + n)]);
printf("%d\n", a[find(n + m)]);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
t = 1;
while (t--) {
map<char, char> mp1;
string s;
cin >> s;
long long int k;
cin >> k;
for (long long int i = 1; i <= k; i++) {
string s1;
cin >> s1;
mp1[s1[0]] = s1[1];
mp1[s1[1]] = s1[0];
}
vector<pair<char, int>> v1;
long long int x = 0;
for (long long int i = 0; i < s.size(); i++) {
if (i == 0)
x++;
else {
if (s[i] == s[i - 1])
x++;
else {
v1.push_back({s[i - 1], x});
x = 1;
}
}
}
v1.push_back({s[s.size() - 1], x});
long long int dp[v1.size() + 1][2];
memset(dp, 0, sizeof(dp));
for (long long int i = 1; i < v1.size(); i++) {
char c = v1[i].first;
if (mp1.find(c) != mp1.end() and v1[i - 1].first == mp1[c]) {
if (i == 1 or v1[i].first != v1[i - 2].first) {
dp[i][0] = dp[i - 1][1] + v1[i - 1].second;
dp[i][1] = dp[i - 1][0] + v1[i].second;
} else {
dp[i][0] = dp[i - 1][1];
dp[i][1] = dp[i - 1][0] + v1[i].second;
}
} else {
dp[i][1] = dp[i][0] = min(dp[i - 1][0], dp[i - 1][1]);
}
}
cout << min(dp[v1.size() - 1][0], dp[v1.size() - 1][1]);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
char wall[2][100010];
bool mark[2][100010];
struct Data {
int x, y, step;
} que[500000];
int main() {
int n, k;
while (cin >> n >> k) {
bool flag = 0;
cin >> wall[0] >> wall[1];
memset(mark, 0, sizeof(mark));
int head = 0, tail = 1;
que[0].x = 0, que[0].y = 1, que[0].step = 1;
mark[0][1] = 1;
while (head < tail) {
int x = que[head].x;
int y = que[head].y;
int step = que[head++].step;
if (y + 1 > n || y + k > n) {
flag = 1;
break;
}
if (y - 1 > step && wall[x][y - 1 - 1] == '-' && mark[x][y - 1] == 0) {
mark[x][y - 1] = 1;
que[tail].x = x;
que[tail].y = y - 1;
que[tail++].step = step + 1;
}
if (wall[x][y + 1 - 1] == '-' && mark[x][y + 1] == 0) {
mark[x][y + 1] = 1;
que[tail].x = x;
que[tail].y = y + 1;
que[tail++].step = step + 1;
}
if (wall[1 ^ x][y + k - 1] == '-' && mark[1 ^ x][y + k] == 0) {
mark[1 ^ x][y + k] = 1;
que[tail].x = 1 ^ x;
que[tail].y = y + k;
que[tail++].step = step + 1;
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 10 | CPP |
def shortSubStrings():
n = int(input())
l = []
for i in range(n):
string = input()
if len(string) <=2:
l.append(string)
else:
l.append(string[::2]+string[-1])
for i in l:
print(i)
shortSubStrings() | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int inf;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T, class T2>
int chkmin(T &a, T2 b) {
return a > b ? a = b, 1 : 0;
}
template <class T, class T2>
int chkmax(T &a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T, class T2>
T mmin(T a, T2 b) {
return a < b ? a : b;
}
template <class T, class T2>
T mmax(T a, T2 b) {
return a > b ? a : b;
}
template <class T>
T aabs(T a) {
return a < 0 ? -a : a;
}
template <class T>
int dcmp(T a, T b) {
return a > b;
}
template <int *a>
int cmp_a(int first, int second) {
return a[first] < a[second];
}
template <class T>
bool sort2(T &a, T &b) {
return a > b ? swap(a, b), 1 : 0;
}
struct __INIT__ {
__INIT__() {
fill((unsigned char *)&inf, (unsigned char *)&inf + sizeof(inf), 0x3f);
}
} __INIT___;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char first) {
*oS++ = first;
if (oS == oT) flush();
}
template <typename A>
inline bool read(A &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(char &first) {
while ((first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == ' ' ||
first == '\n' || first == '\r')
;
return first != EOF;
}
inline bool read(char *first) {
while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*first == ' ' || *first == '\r')
;
if (*first == EOF) return 0;
while (!(*first == '\n' || *first == ' ' || *first == '\r' || *first == EOF))
*(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*first = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &first, B &...second) {
return read(first) && read(second...);
}
template <typename A>
inline bool write(A first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char first) {
putc(first);
return 0;
}
inline bool write(const char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
inline bool write(char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A first, B... second) {
return write(first) || write(second...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
int a[200005];
vector<pair<int, int> > to[200005];
double ans = 1e20;
int id;
bitset<200005> vis;
int rts, mns, rt;
int siz[200005], mxs[200005];
void dfs1(int first, int f) {
siz[first] = 1;
mxs[first] = 0;
for (auto i : to[first])
if (i.first != f && !vis[i.first]) {
dfs1(i.first, first);
chkmax(mxs[first], siz[i.first]);
siz[first] += siz[i.first];
}
}
void dfs2(int first, int f) {
if (chkmin(mns, mmax(mxs[first], rts - siz[first]))) rt = first;
for (auto i : to[first])
if (i.first != f && !vis[i.first]) {
dfs2(i.first, first);
}
}
double cur, inc, d[200005];
void dfs3(int first, int f, int d, double &dc) {
double a = d * sqrt(d) * ::a[first], b = (d + 1) * sqrt(d + 1) * ::a[first],
c = (d - 1) * sqrt(d - 1) * ::a[first];
cur += a;
inc += b - a;
dc += b - c;
for (auto i : to[first])
if (i.first != f) {
dfs3(i.first, first, d + i.second, dc);
}
}
void solve(int first) {
dfs1(first, 0);
rts = siz[first];
mns = rts;
rt = 0;
dfs2(first, 0);
first = rt;
vis[first] = 1;
int t = 0;
cur = 0;
inc = a[first];
for (auto i : to[first]) {
d[++t] = 0;
dfs3(i.first, first, i.second, d[t]);
}
t = 0;
if (chkmin(ans, cur)) id = first;
for (auto i : to[first]) {
if (inc < d[++t] && !vis[i.first]) {
solve(i.first);
return;
}
}
}
signed main() {
int n, u, v, w;
read(n);
for (int i = 1; i <= n; ++i) {
read(a[i]);
}
for (int i = 1; i < n; ++i) {
read(u, v, w);
to[u].emplace_back(v, w);
to[v].emplace_back(u, w);
}
solve(1);
printf("%d %.9lf\n", id, ans);
return 0;
}
| 9 | CPP |
from math import *
from collections import defaultdict as dt
from sys import stdin
inp = lambda : stdin.readline().strip()#input()
I = lambda : int(inp())#int(input())
M = lambda : map(int,stdin.readline().split())#map(input())
L = lambda : list(map(int,stdin.readline().split()))#list(input())
mod = 1000000009
inf = 100000000000000000000
ss = "abcdefghijklmnopqrstuvwxyz"
############## All the best start coding ###########################################
def solve():
n=I()
a=L()
b=[[0 for j in range(i+1)] for i in range(n)]
for i in range(n):
j=k=i
x=y=a[i]
while x:
if j<0 or b[k][j]!=0:
j=j+1
k=k+1
b[k][j]=y
x=x-1
j=j-1
for i in b:
print(*i)
##################### Submit now ##############################
tt=1
#tt=I()
for _ in range(tt):
solve() | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; ++i) cin >> arr[i];
int a, b;
cin >> a >> b;
sort(arr, arr + n);
n = unique(arr, arr + n) - arr;
int ans = 0;
while (b != a) {
int m = a - 1;
for (int i = 0; i < n; ++i)
if (a - (a % arr[i]) >= b) m = min(m, a - (a % arr[i]));
a = m;
while (n and a - (a % arr[n - 1]) < b) n--;
ans++;
}
cout << ans << "\n";
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
pair<int, int> flip(pair<int, int> p) { return make_pair(p.second, p.first); }
int rev(int x) {
int r = 0;
for (; x; x /= 10) {
r = r * 10 + x % 10;
}
return r;
}
pair<int, int> get(int x) {
int rx = rev(x);
int d = gcd(x, rx);
pair<int, int> p(x / d, rx / d);
return p;
}
int main() {
int maxx, maxy, w;
cin >> maxx >> maxy >> w;
map<pair<int, int>, vector<int> > m;
for (int i = 1; i <= 100000; ++i) {
m[get(i)].push_back(i);
}
int y = maxy;
int s = 0;
int ansX = -1, ansY = -1;
long long mn = 1LL << 60;
for (int x = 1; x <= maxx; ++x) {
pair<int, int> py = flip(get(x));
s += upper_bound((m[py]).begin(), (m[py]).end(), y) - m[py].begin();
while (y >= 1) {
pair<int, int> px = flip(get(y));
int d = upper_bound((m[px]).begin(), (m[px]).end(), x) - m[px].begin();
if (s - d >= w) {
s -= d;
--y;
} else {
break;
}
}
if (s >= w && (long long)x * y < mn) {
mn = (long long)x * y;
ansX = x;
ansY = y;
}
}
if (mn == 1LL << 60)
puts("-1");
else
printf("%d %d\n", ansX, ansY);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, k, s;
int main() {
scanf("%lld%lld%lld", &n, &k, &s);
if ((n - 1) * k < s) {
printf("NO\n");
return 0;
} else if (k > s) {
printf("NO\n");
return 0;
}
printf("YES\n");
long long sum = s;
int flag = 0;
long long now = 1;
long long x = n - 1;
while (k) {
if (sum - x < k - 1) {
break;
} else {
if (now == 1)
now = n;
else
now = 1;
sum -= x;
}
if (flag) {
printf(" %lld", now);
} else {
flag = 1;
printf("%lld", now);
}
k--;
}
if (sum != 0) {
if (now == 1) {
if ((sum - k + 1) != 0) {
printf(" %lld", now + (sum - k + 1));
now += sum - k + 1;
k--;
}
int p = 0;
while (k--) {
if (p == 0) {
printf(" %lld", ++now);
} else {
printf(" %lld", --now);
}
p = !p;
}
} else {
if ((sum - k + 1) != 0) {
printf(" %lld", now - (sum - k + 1));
now -= (sum - k + 1);
k--;
}
int p = 0;
while (k--) {
if (p == 0) {
printf(" %lld", --now);
} else {
printf(" %lld", ++now);
}
p = !p;
}
}
}
return 0;
}
| 10 | CPP |
#include <iostream>
using namespace std;
int main(){
long long N,A,B;
cin >> N >> A >> B;
long long answer = N/(A+B)*A + min(N%(A+B),A);
cout << answer << endl;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int M = 1 << 10;
const int MOD = 998244353;
int k;
int pw10[N];
int bitCnt[M];
pair<long long, int> dp[N][M][2];
int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
if (a < 0) a += MOD;
return a;
}
int mul(int a, int b) { return a * 1ll * b % MOD; }
int calc(const string &s) {
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
dp[i][j][0] = dp[i][j][1] = {0ll, 0};
}
}
int len = s.size();
dp[0][0][1] = {1ll, 0};
for (int i = 0; i < len; ++i) {
int cdig = s[i] - '0';
for (int mask = 0; mask < M; ++mask) {
for (int dig = (i == 0); dig <= 9; ++dig) {
int nmask = mask | (1 << dig);
long long cnt = dp[i][mask][0].first;
int sum = add(dp[i][mask][0].second,
mul(dig, mul(pw10[len - i - 1], cnt % MOD)));
dp[i + 1][nmask][0].first += cnt;
dp[i + 1][nmask][0].second = add(dp[i + 1][nmask][0].second, sum);
}
for (int dig = (i == 0); dig <= cdig; ++dig) {
int nmask = mask | (1 << dig);
long long cnt = dp[i][mask][1].first;
int sum = add(dp[i][mask][1].second,
mul(dig, mul(pw10[len - i - 1], cnt % MOD)));
dp[i + 1][nmask][dig == cdig].first += cnt;
dp[i + 1][nmask][dig == cdig].second =
add(dp[i + 1][nmask][dig == cdig].second, sum);
}
}
}
int ans = 0;
for (int mask = 0; mask < M; ++mask) {
if (bitCnt[mask] > k) continue;
ans = add(ans, dp[len][mask][0].second);
ans = add(ans, dp[len][mask][1].second);
}
return ans;
}
int calc(long long n) {
int len = to_string(n).size();
int ans = 0;
for (int l = 1; l < len; ++l) {
ans = add(ans, calc(string(l, '9')));
}
ans = add(ans, calc(to_string(n)));
return ans;
}
int main() {
pw10[0] = 1;
for (int i = 1; i < N; ++i) {
pw10[i] = mul(pw10[i - 1], 10);
}
for (int i = 0; i < M; ++i) {
bitCnt[i] = __builtin_popcount(i);
}
long long l, r;
cin >> l >> r >> k;
int ans = add(calc(r), -calc(l - 1));
cout << ans << endl;
return 0;
}
| 11 | CPP |
#include<bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#endif
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef std::vector<vector<int> > vvi;
typedef pair<int, int> pi;
typedef pair<ll, ll> pll;
typedef vector<ll> vll;
typedef vector<pi> vpi;
typedef vector<pll> vpll;
typedef vector<vll> vvll;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vector<double>> vvd;
typedef vector<ld> vld;
typedef vector<vld> vvld;
typedef vector<bool> vb;
typedef vector<vb> vvb;
#define rep(i, a, b) for (int i = (int)a; i < (int)b; i++)
#define repi(i, a, b) for (int i = (int)a; i >= (int)b; i--)
#define pb push_back
#define fi first
#define se second
#define all(a) a.begin(), a.end()
#define sz(a) (int)(a.size())
#define umin(a, x) a = min(a, x)
#define umax(a, x) a = max(a, x)
ll nxt() {
ll x; cin >> x; return x;
}
void setIO(string s) {
#ifndef LOCAL
ios_base::sync_with_stdio(0); cin.tie(0);
freopen((s+".in").c_str(),"r",stdin);
freopen((s+".out").c_str(),"w",stdout);
#endif
}
const int inf = 1e9;
struct SegmentTree
{
vi a, t;
int n;
SegmentTree(int n): n(n){
a.resize(n+1, inf);
t.resize(4*n+1, inf);
}
void update(int pos, int val){
updatehelper(pos, val, 1, 1, n); //pos, val, node, left, right
//node is the index in the tree
}
int get(int l, int r){
return gethelper(l, r, 1, 1, n);
}
void updatehelper(int pos, int val, int node, int left, int right){
if(pos < left || pos > right) return;
else if(left == right){
a[pos] = val;
t[node] = val;
}
else{
updatehelper(pos, val, 2*node, left, (left+right)/2);
updatehelper(pos, val, 2*node + 1, (left+right)/2 + 1, right);
t[node] = min(t[2*node], t[2*node+1]);
}
}
int gethelper(int l, int r, int node, int left, int right){
if(r < left || l > right) return inf;
else if( l <= left && right <= r) return t[node];
else{
return min(gethelper(l, r, 2*node, left, (left + right)/2), gethelper(l, r, 2*node+1, (left+right)/2 + 1, right));
}
}
};
void solve() {
int n = nxt();
SegmentTree seg(n + 2);
vi a(n + 1); rep(i, 1, n + 1) {
cin >> a[i];
seg.update(i, a[i]);
}
vi pref_max(n + 2), suf_max(n + 2);
map<int, int> first_occ, last_occ;
rep(i, 1, n + 1) {
pref_max[i] = max(pref_max[i - 1], a[i]);
int x = suf_max[n - i + 1] = max(suf_max[n - i + 2], a[n - i + 1]);
if (!last_occ.count(x)) {
last_occ[x] = n - i + 1;
}
first_occ[x] = n - i + 1;
}
suf_max[0] = inf;
vi negs = suf_max;
rep(i, 0, sz(negs)) negs[i] = -suf_max[i];
debug("###############");
debug(n, a);
debug(suf_max);
debug(first_occ);
debug(last_occ);
rep(x, 1, n - 1) {
int cur = pref_max[x];
int id1, id2;
if (first_occ.count(cur)) {
id1 = first_occ[cur];
id2 = last_occ[cur];
id1 = max(x + 1, id1);
if (id2 < id1) continue;
} else {
continue;
}
int lo = max(id1 - 1, x + 1), hi = max(id2 - 1, x + 1);
assert(id1 >= x + 1 && id1 <= id2);
debug(x, cur, lo, hi);
while (lo < hi) {
int mid = (lo + hi) / 2;
int mn = seg.get(x + 1, mid);
if (mn > cur) {
lo = mid + 1;
} else {
hi = mid;
}
}
assert(lo == hi);
if (lo >= x + 1 && lo < id2 && seg.get(x + 1, lo) == cur) {
cout << "YES\n";
int y = lo - x, z = n - lo;
cout << x << " " << lo - x << " " << n - lo << "\n";
debug(id1, id2, cur);
assert(x >= 1 && y >= 1 && z >= 1 && x + y + z == n);
assert(pref_max[x] == suf_max[n - z + 1]
&& pref_max[x] == seg.get(x + 1, x + y));
return;
}
}
cout << "NO\n";
}
int32_t main(){
// setIO("trapped");
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(10);
int T = 1;
cin >> T;
for (int tc = 1; tc <= T; tc++) {
// cout << "Case #" << tc << ": ";
solve();
}
}
| 12 | CPP |
n = int(input())
for _ in range(n):
a = sum([int(input()) for _ in range(2)])
print(a if a < 10**80 else 'overflow') | 0 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.