solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x;
cin >> x;
for (int i = 0; i < x; i++) {
int y;
cin >> y;
int k = y;
for (int i = 0; i < y; i++) {
cout << k << " ";
}
cout << endl;
}
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long pos;
char answer;
void In() { cin >> pos; }
int Lentgh(int num) {
int result = 0;
while (num > 0) {
num /= 10;
result++;
}
return result;
}
long long LinearSum(long long start, long long finish, long long num) {
return (start + finish) * num / 2;
}
long long GetRedactedSize() {
long long total_size = 0, first_size = 0, next_size = 0;
for (long long num_elem = 9, num_digits = 1;; num_digits++, num_elem *= 10) {
next_size = LinearSum(first_size + num_digits,
first_size + num_digits * num_elem, num_elem);
if (total_size + next_size >= pos) {
long long l = 1, r = num_elem;
for (long long mid = l + (r - l + 1) / 2; l != r;
mid = l + (r - l + 1) / 2)
total_size + LinearSum(first_size + num_digits,
first_size + num_digits * mid, mid) >=
pos
? r = mid - 1
: l = mid;
next_size =
LinearSum(first_size + num_digits, first_size + num_digits * l, l);
if (total_size + next_size < pos) total_size += next_size;
return total_size;
}
total_size += next_size;
first_size += num_digits * num_elem;
}
}
char Solve() {
pos -= GetRedactedSize();
for (long long num_elem = 9, prev_len = 0, num_digits = 1;;
prev_len += num_elem * num_digits, num_elem *= 10, num_digits++)
if (prev_len + num_elem * num_digits >= pos) {
pos -= prev_len + 1;
return to_string(pow(10, num_digits - 1) +
pos / num_digits)[pos % num_digits];
}
}
void Out() { cout << answer << endl; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
In();
answer = Solve();
Out();
}
}
| 1,900 | CPP |
n = int(input())
for i in range(n):
a = 0
num = int(input())
lista = [0,0,0,0,0]
lista[0] = num%10
if lista[0] != 0:
a += 1
lista[1] = (num//10)%10 *10
if lista[1] != 0:
a += 1
lista[2] = (num//100)%10 *100
if lista[2] != 0:
a += 1
lista[3] = (num//1000)%10 *1000
if lista[3] != 0:
a += 1
lista[4] = (num//10000)%10 *10000
if lista[4] != 0:
a += 1
print(a)
for j in lista:
if j != 0:
print(j,end=" ") | 800 | PYTHON3 |
n,k = map(int,input().split(" "))
nf = 0
nt = 0
m = n
while m%2==0 :
nt += 1
m //= 2
m = n
while m % 5 == 0:
nf += 1
m //= 5
n *= 2**(max(0,k-nt))
n *= 5**(max(0,k-nf))
print(n)
| 1,100 | PYTHON3 |
t=int(input())
for _ in range(t):
n,k=map(int,input().split())
arr=list(map(int,input().split()))
s=set(arr)
l=len(s)
if(k==1):
if(l>1):
print(-1)
else:
print(1)
else:
if(l<=k):
print(1)
else:
if((l-k)%(k-1)==0):
print(1+(l-k)//(k-1))
else:
print(2+(l-k)//(k-1)) | 1,400 | PYTHON3 |
w = int(input())
def f(w):
p = 0
b = 0
while w>=4:
p += 2
b += 2
w -= 4
if w%2==0:
return 'YES'
else:
return 'NO'
if w < 4:
print('NO')
else:
print(f(w))
| 800 | PYTHON3 |
import sys
# sys.setrecursionlimit(10000)
from collections import defaultdict
from itertools import permutations
from math import sqrt
from functools import reduce
def solve(n, W, w):
sum = 0
ret = []
for i in range(n):
if (W + 1) // 2 <= sum <= W:
return ret
if w[i] > W:
continue
if (W + 1) // 2 <= w[i] <= W:
return [i + 1]
sum += w[i]
ret.append(i + 1)
if sum < (W + 1) // 2:
return []
return ret
t = int(input())
for _ in range(t):
n, W = map(int, input().split())
w = list(map(int, input().split()))
ans = solve(n, W, w)
if len(ans) == 0:
print(-1)
else:
print(len(ans))
print(*ans)
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int q;
scanf("%d", &q);
while (q--) {
int n, u = 0, i, j, p, q;
scanf("%d", &n);
int arr[n];
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
for (j = 0; j < n; j++) {
p = arr[j];
q = p + 1;
if (p == n) {
q = 1;
}
if (j == 0 && arr[j + 1] != q && arr[n - 1] != q) {
printf("NO\n");
u = 1;
break;
} else if (j == n - 1 && arr[0] != q && arr[j - 1] != q) {
printf("NO\n");
u = 1;
break;
} else if (j != 0 && j != n - 1 && arr[j + 1] != q && arr[j - 1] != q) {
printf("NO\n");
u = 1;
break;
}
}
if (u == 0) {
printf("YES\n");
}
}
}
| 1,000 | CPP |
def solve(x):
if x < 0:
return float('-inf')
if x == 0: return 0
if ready[x]:
return dp[x]
best = float('-inf')
for r in ribbons:
best = max(best, solve(x - r) + 1)
dp[x] = best
ready[x] = True
return best
i = input().split(' ')
n = int(i[0])
ribbons = list(map(int, i[1:]))
dp = [0 for v in range(n + 1)]
import sys
sys.setrecursionlimit(10**6)
ready = [False for v in range(n+1)]
print(solve(n))
| 1,300 | PYTHON3 |
a,b,n=[int(x) for x in input().split()]
move=0
def fun2(a,b):
while a != b:
if a > b:
a = a - b
else:
b = b - a
return b
while n!=0:
if move%2==0:
n-=fun2(a,n)
move+=1
else:
n-=fun2(b,n)
move+=1
if move%2!=0:
print(0)
else:
print(1) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
if (n <= 2) {
cout << n << endl;
return 0;
}
vector<int> a(n);
for (auto &x : a) cin >> x;
vector<int> pref(n), suf(n);
for (int i = 0; i < n; i++) {
pref[i] = 1;
if (i > 0)
if (a[i - 1] < a[i]) pref[i] = max(pref[i], pref[i - 1] + 1);
}
for (int i = n - 1; i >= 0; i--) {
suf[i] = 1;
if (i < n - 1)
if (a[i + 1] > a[i]) suf[i] = max(suf[i], suf[i + 1] + 1);
}
int ans = 1;
for (int i = 0; i < n; i++) {
if (i < n - 1) ans = max(ans, suf[i + 1] + 1);
if (i > 0) ans = max(ans, pref[i - 1] + 1);
if (i < n - 1 and i > 0) {
if (a[i + 1] > a[i - 1] + 1) ans = max(ans, pref[i - 1] + 1 + suf[i + 1]);
}
}
cout << ans << endl;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long x, y, xx, yy, p, q;
bool gd(long long mid) {
yy = mid * q;
xx = mid * p;
if (xx < x || yy < y || xx - x > yy - y) return 0;
return 1;
}
long long solve() {
long long low = 0, hi = 1000000000, mid, ans = -1;
while (low <= hi) {
mid = (low + hi) >> 1;
bool ok = gd(mid);
if (ok) {
hi = mid - 1;
ans = mid * q - y;
} else
low = mid + 1;
}
return ans;
}
int main() {
int t;
cin >> t;
while (t--) {
cin >> x >> y >> p >> q;
cout << solve() << "\n";
}
return 0;
}
| 1,700 | CPP |
n,m,k=map(int,input().split())
l=list(map(int,input().split()))
l[m-1]=0
l1=[]
ans=0
for i in range(0,len(l)):
if l[i]<=k and l[i]!=0:
d=abs(m-(i+1))
l1.append(d)
l1.sort()
ans=10*l1[0]
print(ans)
| 800 | PYTHON3 |
from fractions import Fraction
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
arr = []
cnt = 0
for i in range(n):
if a[i] != 0:
arr.append(Fraction(-b[i], a[i]))
if a[i] == b[i] == 0:
cnt += 1
if len(arr) == 0:
print(cnt)
__import__('sys').exit(0)
d = dict()
for i in range(len(arr)):
d[arr[i]] = d.get(arr[i], 0) + 1
res = 0
for x in d.values():
res = max(res, x)
print(res + cnt)
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
void solve() {
cin >> n >> k;
int zero = 0, one = 0;
string s;
cin >> s;
for (int i = 0; i < k; i++) {
if (s[i] == '?') {
for (int j = i + k; j < n; j += k) {
if (s[j] != '?') {
s[i] = s[j];
break;
}
}
}
}
for (int i = 0; i < k; i++) {
if (s[i] != '?') {
for (int j = i + k; j < n; j += k) {
if (s[j] == '?')
s[j] = s[i];
else if (s[j] != s[i]) {
cout << "NO\n";
return;
}
}
}
}
for (int i = 0; i < k; i++) {
if (s[i] == '1')
one++;
else if (s[i] == '0')
zero++;
}
if (zero <= k / 2 && one <= k / 2)
cout << "YES\n";
else
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 1,500 | CPP |
n=int(input())
elist=[i%2 for i in map(int,input().split())]
print(elist.index([0,1][elist.count(1)==1])+1)
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int s, n, i, j, k, kindnum = 0, maxsw = 0;
int shop[200][3], lis[200][3];
scanf("%d%d", &n, &s);
for (i = 0; i < n; i++) {
scanf("%d%d", &shop[i][0], &shop[i][1]);
if (shop[i][1] != 0) shop[i][1] = 100 - shop[i][1];
if (shop[i][0] < s) {
lis[kindnum][0] = shop[i][0];
lis[kindnum][1] = shop[i][1];
kindnum++;
}
if (shop[i][0] == s && shop[i][1] == 0) {
lis[kindnum][0] = shop[i][0];
lis[kindnum][1] = shop[i][1];
kindnum++;
}
}
if (kindnum == 0) {
printf("-1");
return 0;
} else {
for (i = 0; i < kindnum; i++) {
if (maxsw < lis[i][1]) maxsw = lis[i][1];
}
}
printf("%d", maxsw);
return 0;
}
| 1,200 | CPP |
from sys import stdin
input = stdin.readline
def present(n):
array = [0] + list(map(int, input().split()))
chars = [0] * (n + 1)
for i in range(1, n + 1):
chars[array[i]] = i
return ' '.join(map(str, chars[1:]))
print(present(int(input()))) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500050;
int n, m, limit;
int a[maxn];
int f[maxn][22];
int main() {
memset(f, 0, sizeof(f));
cin >> n >> m;
limit = -1;
for (int i = 1; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[x] = max(a[x], y);
limit = max(limit, y);
}
for (int i = 1; i <= limit; i++) a[i] = max(a[i - 1], a[i]);
for (int i = 0; i <= limit; i++) f[i][0] = a[i];
for (int j = 1; j <= 20; j++)
for (int i = 0; i <= limit; i++) {
if (f[i][j - 1] == -1) {
f[i][j] = -1;
continue;
}
if (f[f[i][j - 1]][j - 1] == f[i][j - 1])
f[i][j] = -1;
else
f[i][j] = f[f[i][j - 1]][j - 1];
}
int ans, now;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
ans = 0, now = x;
for (int j = 20; j >= 0; j--) {
if (f[now][j] <= y && f[now][j] != -1) {
ans += 1 << j;
now = f[now][j];
if (now == y) break;
}
}
if (now == y)
cout << ans << endl;
else if (f[now][0] > y)
cout << ++ans << endl;
else
puts("-1");
}
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, c = 0;
cin >> n >> k;
string s = "0123456789", z;
while (n--) {
cin >> z;
bool flag = 1;
for (int i = 0; i <= k; ++i) {
if (z.find(s[i]) == -1) {
flag = 0;
break;
}
}
if (flag) c++;
}
cout << c;
return 0;
}
| 1,100 | CPP |
n, t = map(int, input().split())
if t < 10:
print("".join(str(t) for _ in range(n)))
elif n > 1:
print("1" + "".join("0" for _ in range(n - 1)))
else:
print(-1)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 6;
const int mod = 1e9 + 7;
int mult(int a, int b) {
long long res = a;
res *= b;
if (res >= mod) {
return res % mod;
}
return res;
}
bool visited[N];
int p, k;
int ans = 1;
int nxt[N];
void dfs(int node, int val) {
if (visited[node]) {
if (val == 1) {
ans = mult(ans, p);
}
return;
}
visited[node] = 1;
dfs(nxt[node], (1LL * val * k) % p);
}
int main() {
cin >> p >> k;
if (k == 0) {
for (int i = 1; i < p; ++i) {
ans = mult(ans, p);
}
cout << ans;
return 0;
}
for (int i = 0; i < p; ++i) {
nxt[i] = (1LL * i * k) % p;
}
for (int i = 0; i < p; i++) {
if (!visited[i]) {
dfs(i, 1);
}
}
cout << ans;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
long long need[3], have[3], cost[3];
long long func(long long mid) {
long long i, ar[3];
for (i = 0; i < 3; i++) ar[i] = mid * need[i];
long long c = 0;
for (i = 0; i < 3; i++)
if (have[i] < ar[i]) c += (ar[i] - have[i]) * cost[i];
return c;
}
int main() {
memset(need, 0, sizeof(need));
char c;
int i;
string s;
cin >> s;
for (i = 0; i < s.length(); i++) {
c = s[i];
if (c == 'B')
need[0]++;
else if (c == 'S')
need[1]++;
else
need[2]++;
}
for (i = 0; i < 3; i++) cin >> have[i];
for (i = 0; i < 3; i++) cin >> cost[i];
long long R;
cin >> R;
long long ans = 0;
if (need[0] != 0) ans = have[0] / need[0];
if (need[1] != 0) ans = min(ans, have[1] / need[1]);
if (need[2] != 0) ans = min(ans, have[2] / need[2]);
long long ans1 = 0;
for (i = 0; i < 3; i++) have[i] = have[i] - ans * need[i];
long long l = 0, r = 10e12, mid;
while (l <= r) {
mid = (l + r) / 2;
if (func(mid) <= R) {
ans1 = mid;
l = mid + 1;
} else
r = mid - 1;
}
cout << ans1 + ans << endl;
return 0;
}
| 1,600 | CPP |
from math import ceil
for _ in range(int(input())):n=int(input());print(ceil((n**0.5-1)*2)) | 1,100 | PYTHON3 |
#include<bits/stdc++.h>
#define ios std::ios::sync_with_stdio(false)
#define rep(i,a,n) for (int i=a;i<=n;i++)
#define per(i,n,a) for (int i=n;i>=a;i--)
#define repp(i,a,b) for(int i=a;i<b;i++)
#define mm(a,n) memset(a, n, sizeof(a))
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define il inline
#define int long long
#define ll long long
#define ull unsigned long long
#define MOD 1000000007
#define pi 3.14159265358979323
#define SZ(x) ((ll)(x).size())
#define debug(x) cout<<#x<<": "<<x<<endl;
#define debug2(x,y) cout<<#x<<": "<<x<<" | "<<#y<<": "<<y<<endl;
#define debug3(x,y,z) cout<<#x<<": "<<x<<" | "<<#y<<": "<<y<<" | "<<#z<<": "<<z<<endl;
#define debug4(a,b,c,d) cout<<#a<<": "<<a<<" | "<<#b<<": "<<b<<" | "<<#c<<": "<<c<<" | "<<#d<<": "<<d<<endl;
using namespace std;
template<typename T>void read(T &res){bool flag=false;char ch;while(!isdigit(ch=getchar()))(ch=='-')&&(flag=true);
for(res=ch-48;isdigit(ch=getchar());res=(res<<1)+(res<<3)+ch - 48);flag&&(res=-res);}
template<typename T>void Out(T x){if(x<0)putchar('-'),x=-x;if(x>9)Out(x/10);putchar(x%10+'0');}
const int N = 1e6 + 10;
void NO()
{
cout << "No\n";
exit(0);
}
int vis[N];
signed main()
{
__int128 k , l , r , t , x , y;
read(k) , read(l) , read(r) , read(t) , read(x) , read(y);
k -= l , r -= l;
__int128 d = k / x , s = k % x;
if(t * x <= k) return cout << "Yes\n" , 0;
if(x >= y && y + k <= r && (x - y) * t <= k) return cout << "Yes\n" , 0;
t -= d;
if(s + y > r) NO();
vis[s] = 1;
while(t > 0)
{
__int128 ma = t * x;
k = s + y;
d = k / x;
s = k % x;
if(!d) NO();
if(k - ma >= 0) return cout << "Yes\n" , 0;
if(s + y > r) NO();
if(vis[s]) return cout << "Yes\n" , 0;
vis[s] = 1;
t -= d;
}
NO();
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int i = 0; i < q; i++) {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
int count0 = 0;
int j = 0;
bool flag = false;
while (j < n && k > 0) {
if (s[j] == '1') {
j++;
continue;
}
if (j <= k + count0) {
k = k - j + count0;
count0++;
j++;
} else {
flag = true;
break;
}
}
if (!flag) {
for (int l = 0; l < count0; l++) cout << 0;
for (int l = 0; l < n; l++) {
if (s[l] == '1') {
if (!flag) {
cout << 1;
continue;
}
if (k > 0) {
k--;
cout << 1;
continue;
}
}
if (count0 > 0) {
count0--;
continue;
}
cout << 0;
}
} else {
for (int l = 0; l < count0; l++) cout << 0;
int w = 0;
for (int l = 0; l < n; l++) {
if (s[l] == '1') {
if (!flag) {
cout << 1;
continue;
}
w++;
continue;
}
if (count0 > 0) {
count0--;
continue;
}
if (flag) {
string s2(w - k, '1');
string s3(k, '1');
cout << s2 << 0 << s3;
flag = false;
continue;
}
cout << 0;
}
}
cout << endl;
}
return 0;
}
| 1,500 | CPP |
for _ in range(int(input())):
l1,r1,l2,r2 = list(map(int,input().split()))
r3=0
l3=0
if l2<l1:
print(r1,l2)
else:
print(l1,r2) | 800 | PYTHON3 |
r=int(input())-1
a=*map(int,input().split()),
s=''
l=e=0
while l<=r and max(a[l],a[r])>e:
L,R=a[l],a[r]
if L>e>R or R>L>e:e=L;l+=1;s+='L'
else:e=R;r-=1;s+='R'
print(len(s),s) | 1,300 | PYTHON3 |
n=int(input())
a=list(input())
x=a.count('1')
y=a.count('0')
print(abs(x-y)) | 900 | PYTHON3 |
a=input()
b=a.split('+')
c=len(b)
b.sort()
s=''
for i in range(c):
if i!=c-1:
s+=b[i]+'+'
elif i==c-1:
s+=b[i]
print(s)
| 800 | PYTHON3 |
n = int(input())
sum = 0
for _ in range(n):
sum += 1 if input().count("1") >= 2 else 0
print(sum) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
struct bigint {
int l, num[30];
bigint(int n = 0) {
memset(num, 0, sizeof num);
l = 1;
num[1] = n;
}
bigint operator*(const bigint &b) {
bigint c;
for (int i = 1; i <= l; i++) {
for (int j = 1; j <= b.l; j++) {
c.num[i + j - 1] += num[i] * b.num[j];
}
}
c.l = l + b.l;
for (int i = 1; i < c.l; i++) {
c.num[i + 1] += c.num[i] / 10000;
c.num[i] %= 10000;
}
if (!c.num[c.l]) c.l--;
return c;
}
bool operator<(const bigint &b) {
if (l < b.l)
return 1;
else if (l > b.l)
return 0;
for (int i = l; i >= 1; i--) {
if (num[i] < b.num[i])
return 1;
else if (num[i] > b.num[i])
return 0;
}
return 0;
}
void operator=(const bigint &b) {
l = b.l;
for (int i = 1; i <= l; i++) num[i] = b.num[i];
}
void print() {
printf("%d", num[l]);
for (int i = l - 1; i; i--) printf("%04d", num[i]);
puts("");
}
};
bigint max(bigint a, bigint b) { return a < b ? b : a; }
bigint f[707][707], F[707], g[707][707];
vector<int> v[707];
int son[707], n, a, b;
bool vis[707];
void dfs(int x) {
vis[x] = 1;
int pnt = 1;
f[x][1] = bigint(1);
g[x][1] = bigint(1);
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (vis[y]) continue;
dfs(y);
for (int j = 1; j <= pnt; j++) f[x][j] = g[x][j] * F[y];
for (int j = 1; j <= pnt; j++) {
for (int k = 1; k <= son[y]; k++) {
f[x][j + k] = max(f[x][j + k], g[x][j] * f[y][k]);
}
}
pnt += son[y];
for (int j = 1; j <= pnt; j++) g[x][j] = f[x][j];
}
for (int j = 1; j <= pnt; j++) F[x] = max(F[x], f[x][j] * bigint(j));
son[x] = pnt;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d %d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
dfs(1);
F[1].print();
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
void dfs(long long node, long long parent, long long ancestors[][21],
long long levels[], long long log, vector<vector<long long> >& graph) {
ancestors[node][0] = parent;
for (long long i = 1; i <= log; i++) {
if (ancestors[node][i - 1] == -1) break;
ancestors[node][i] = ancestors[ancestors[node][i - 1]][i - 1];
}
for (long long i = 0; i < graph[node].size(); i++) {
long long curNode = graph[node][i];
if (parent != curNode) {
levels[curNode] = levels[node] + 1;
dfs(curNode, node, ancestors, levels, log, graph);
}
}
}
long long lca(long long u, long long v, long long log, long long levels[],
long long ancestors[][21]) {
u--;
v--;
if (levels[u] < levels[v]) {
swap(u, v);
}
long long dist = levels[u] - levels[v];
for (long long i = log; i >= 0; i--) {
if (levels[u] - levels[v] >= pow(2, i)) {
u = ancestors[u][i];
}
}
if (u == v) return u;
for (long long i = log; i >= 0; i--) {
if (ancestors[u][i] != ancestors[v][i]) {
u = ancestors[u][i];
v = ancestors[v][i];
}
}
return ancestors[u][0];
}
long long dfs2(long long node, long long parent,
vector<vector<long long> >& graph,
map<pair<long long, long long>, long long>& mp,
long long nums[]) {
long long curRes = nums[node];
for (long long i = 0; i < graph[node].size(); i++) {
long long curNode = graph[node][i];
if (curNode != parent) {
long long res = dfs2(curNode, node, graph, mp, nums);
mp[make_pair(node, curNode)] = res;
mp[make_pair(curNode, node)] = res;
curRes += res;
}
}
return curRes;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
vector<vector<long long> > graph(n, vector<long long>());
map<pair<long long, long long>, long long> mp;
vector<pair<long long, long long> > edges;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
u--;
v--;
graph[u].push_back(v);
graph[v].push_back(u);
edges.push_back(make_pair(u, v));
}
long long log = 20;
long long ancestors[n][21];
long long levels[n];
memset(ancestors, -1, sizeof(ancestors));
memset(levels, 0, sizeof(levels));
dfs(0, -1, ancestors, levels, log, graph);
long long k;
cin >> k;
long long nums[n];
memset(nums, 0, sizeof(nums));
for (long long i = 0; i < k; i++) {
long long a, b;
cin >> a >> b;
nums[a - 1]++;
nums[b - 1]++;
long long ancestor = lca(a, b, log, levels, ancestors);
nums[ancestor] -= 2;
}
dfs2(0, -1, graph, mp, nums);
std::map<pair<long long, long long>, long long>::iterator it;
for (long long i = 0; i < edges.size(); i++) {
pair<long long, long long> curp = edges[i];
cout << mp[curp] << " ";
}
return 0;
}
| 1,900 | CPP |
t=int(input())
while(t>0):
t-=1
n=int(input())
if(n%2==0):
k=n//2
print('1'*k)
else:
k=(n-3)//2
print('7','1'*k,sep='')
| 900 | PYTHON3 |
t = int(input())
for _ in range(t):
#n = int(input())
n,x = map(int,input().split())
lol= [int(n) for n in input().split()]
e = 0
o = 0
f = 0
for i in lol:
if(i%2==0 and i!= 0):
e+= 1
else:
o+=1
if(o>0 and o%2==0):
o-=1
if(x&1):
if(o>=1 and o+e >= x):
print('YES')
else:
print('NO')
else:
if(o+e>=x and e>=1 and o>=1):
print('YES')
else:
print('NO')
| 1,200 | PYTHON3 |
import sys
def solve():
s = input()
t = input()
n = len(s)
s = sorted(s)[:(n + 1) // 2]
t = sorted(t, reverse=True)[:n // 2]
ans = [''] * n
ansl = 0
ansr = n - 1
olgl = 0
olgr = len(s) - 1
igol = 0
igor = len(t) - 1
for i in range(n):
if i % 2 == 0:
if igol > igor or s[olgl] < t[igol]:
ans[ansl] = s[olgl]
ansl += 1
olgl += 1
else:
ans[ansr] = s[olgr]
ansr -= 1
olgr -= 1
else:
if olgl > olgr or t[igol] > s[olgl]:
ans[ansl] = t[igol]
ansl += 1
igol += 1
else:
ans[ansr] = t[igor]
ansr -= 1
igor -= 1
print(''.join(ans))
if __name__ == '__main__':
solve() | 1,800 | PYTHON3 |
n,k = map(int,input().split())
a = list(map(int,input().split()))
pos = []
for i in range(n):
x = a[i]
while x > 0:
pos.append(x)
x //= 2
ans = 1000000000
for res in pos:
cnt = []
for i in range(n):
x = a[i]
cur = 0
while x > res:
x //= 2
cur += 1
if x == res:cnt.append(cur)
if len(cnt) < k:continue
cnt.sort()
ans = min(ans,sum(cnt[:k]))
print(ans)
| 2,200 | PYTHON3 |
#include <bits/stdc++.h>
struct Point {
long long size, depth, fa, val;
} point[100100];
struct Edge {
long long to, nxt;
} edge[200100];
long long cnt, head[100100], n, Q, fa[100100], size[100100], x, y;
long long ans;
void addedge(long long x, long long y) {
edge[++cnt].to = y;
edge[cnt].nxt = head[x];
head[x] = cnt;
}
void dfs(long long x, long long fa) {
point[x].depth = point[fa].depth + 1;
point[x].fa = fa;
point[x].size = 1;
for (long long i = head[x]; i; i = edge[i].nxt) {
long long upup = edge[i].to;
if (upup == fa) continue;
dfs(upup, x);
point[x].size += point[upup].size;
point[x].val += point[upup].size * point[upup].size;
}
ans -= (point[x].val += (n - point[x].size) * (n - point[x].size));
}
long long find(long long x) {
if (x == fa[x]) return x;
return fa[x] = find(fa[x]);
}
long long calc(long long x) {
long long res = size[x];
return res * (res - 1) * (res - 2);
}
void merge(long long x, long long y) {
ans -= ((n - size[x]) * (n - size[x]) - point[x].val) * size[x];
ans -= ((n - size[y]) * (n - size[y]) - point[y].val) * size[y];
ans -= (n - size[x]) * size[x] * (size[x] - 1) * 2;
ans -= (n - size[y]) * size[y] * (size[y] - 1) * 2;
ans -= calc(x) + calc(y);
fa[y] = x;
size[x] += size[y];
point[x].val += point[y].val - point[y].size * point[y].size -
(n - point[y].size) * (n - point[y].size);
ans += ((n - size[x]) * (n - size[x]) - point[x].val) * size[x] + calc(x);
ans += (n - size[x]) * size[x] * (size[x] - 1) * 2;
}
signed main() {
scanf("%lld", &n);
for (long long i = 1; i < n; i++) {
scanf("%lld%lld", &x, &y);
addedge(x, y);
addedge(y, x);
}
ans = n * (n - 1) * (n - 1);
dfs(1, 0);
for (long long i = 1; i <= n; i++) fa[i] = i, size[i] = 1;
printf("%lld\n", ans);
scanf("%lld", &Q);
while (Q--) {
scanf("%lld%lld", &x, &y);
x = find(x), y = find(y);
while (x != y) {
if (point[x].depth < point[y].depth) x ^= y ^= x ^= y;
long long tmp = find(point[x].fa);
merge(tmp, x);
x = tmp;
}
printf("%lld\n", ans);
}
}
| 3,300 | CPP |
n,m = map(int,input().split())
s = input()
t = input()
l = []
l1 = []
i = 0
j = 0
while i<n and j<m:
if s[i]==t[j]:
l.append(i+1)
i+=1
j+=1
else:
i+=1
i = n-1
j = m-1
while i>=0 and j>=0:
if s[i]==t[j]:
l1.append(i+1)
i-=1
j-=1
else:
i-=1
#print(l, l1)
l1.reverse()
mi = 0
for i in range(len(l)-1):
x = l1[i+1]-l[i]
mi = max(mi,x)
print(mi)
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T a) {
return a * a;
}
set<int> adj[33];
bool mark[33];
int dis[33];
void dfs(int v) {
int _deg = -(1 << 30);
int vic = -1;
bool temp = false;
mark[v] = true;
for (__typeof((adj[v]).begin()) it = (adj[v]).begin(); it != (adj[v]).end();
it++)
if (mark[*it] == false)
if (temp == false or dis[*it] < _deg) {
temp = true;
_deg = dis[*it];
vic = (*it);
}
if (vic != -1) dfs(vic);
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
memset(dis, 0, sizeof dis);
for (register int i = (0); i < (int)(m); (i)++) {
int a, b;
cin >> a >> b;
if (a != b) {
int _a = (int)(adj[a - 1].size());
int _b = (int)(adj[b - 1].size());
adj[a - 1].insert(b - 1);
adj[b - 1].insert(a - 1);
if ((int)(adj[a - 1].size()) > _a) dis[a - 1]++;
if ((int)(adj[b - 1].size()) > _b) dis[b - 1]++;
}
}
for (register int i = (0); i < (int)(n); (i)++) {
memset(mark, false, sizeof mark);
dfs(i);
bool temp = false;
for (register int j = (0); j < (int)(n); (j)++)
if (mark[j] == false) {
temp = true;
break;
}
if (temp == false) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| 2,800 | CPP |
import sys, math
import io, os
#data = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
#from bisect import bisect_left as bl, bisect_right as br, insort
#from heapq import heapify, heappush, heappop
#from collections import defaultdict as dd, deque, Counter
#from itertools import permutations,combinations
def data(): return sys.stdin.buffer.readline().strip()
def mdata(): return list(map(int, data().split()))
def outl(var) : sys.stdout.write(' '.join(map(str, var))+'\n')
def out(var) : sys.stdout.write(str(var)+'\n')
#sys.setrecursionlimit(100000)
#INF = float('inf')
mod = int(1e9)+7
#from decimal import Decimal
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
def fix():
global sumL, cntL, sumDouble
while len(Double)<cntL:
temp=LF[-1]
Double.add(temp)
LF.remove(temp)
sumDouble+=temp
while len(Double)>cntL:
temp=Double[0]
Double.remove(temp)
LF.add(temp)
sumDouble-=temp
while Double and LF and Double[0]<LF[-1]:
temp1,temp2=Double[0],LF[-1]
LF.remove(temp2)
Double.remove(temp1)
LF.add(temp1)
Double.add(temp2)
sumDouble+=temp2-temp1
if sumDouble==sumL and cntL:
temp1=Double[0]
Double.remove(temp1)
if LF:
temp2=LF[-1]
LF.remove(temp2)
Double.add(temp2)
sumDouble+=temp2
LF.add(temp1)
sumDouble-=temp1
def add(tp,d):
global sumF,sumL, sumDouble, cntL
if not tp:
sumF+=d
else:
sumL+=d
cntL+=1
LF.add(d)
def remove(tp,d):
global sumF, sumL, sumDouble, cntL
if not tp:
sumF-=d
else:
sumL-=d
cntL-=1
if d in LF:
LF.remove(d)
else:
Double.remove(d)
sumDouble-=d
n=int(data())
sumL,sumF,sumDouble,cntL=0,0,0,0
LF=SortedList()
Double=SortedList()
for _ in range(n):
tp,d=mdata()
if d<0:
remove(tp,-d)
else:
add(tp,d)
fix()
print(sumDouble+sumL+sumF)
| 2,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int arr[210];
int main() {
int n, i, max_ = 0, index, ans = 0;
scanf("%d", &n);
for (i = 0; i < n; ++i) {
scanf("%d", &arr[i]);
if (arr[i] >= max_) {
max_ = max(max_, arr[i]);
index = i;
}
}
while (index != 0) {
++arr[0];
--arr[index];
++ans;
max_ = 0;
for (i = 0; i < n; ++i) {
if (arr[i] >= max_) {
max_ = max(max_, arr[i]);
index = i;
}
}
}
printf("%d\n", ans);
return 0;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int const inf = 1000 * 1000 * 1000;
long long const inf64 = 1ll * inf * inf;
int const MAXN = 3005;
int n;
int a[MAXN];
int N, S, T;
vector<pair<int, int> > g[MAXN * 2];
vector<int> cp, fl, co;
vector<pair<int, int> > ed;
inline int getTo(int id, int v) {
return ed[id].first == v ? ed[id].second : ed[id].first;
}
inline void addEdge(int u, int v, int capacity, int cost) {
cp.push_back(capacity);
fl.push_back(0);
co.push_back(cost);
g[u].push_back(make_pair(v, (int)cp.size() - 1));
ed.push_back(make_pair(u, v));
}
int phi[MAXN * 2];
bool used[MAXN * 2];
int dfs(int v) {
if (used[v]) return phi[v];
used[v] = 1;
int mn = INT_MAX;
for (pair<int, int> iter : g[v]) {
int to, id;
tie(to, id) = iter;
if (id % 2 == 0) continue;
mn = min(mn, dfs(to) + co[id ^ 1]);
}
return phi[v] = mn;
}
int dist[MAXN * 2];
int from[MAXN * 2];
set<pair<int, int> > pq;
pair<int, int> dkstra() {
for (int i = 1; i <= N; i++) {
dist[i] = inf;
from[i] = -1;
}
dist[S] = 0;
pq.insert(make_pair(dist[S], S));
while (!pq.empty()) {
int v = pq.begin()->second;
pq.erase(pq.begin());
for (pair<int, int> iter : g[v]) {
int to, id;
tie(to, id) = iter;
int we = co[id] + phi[v] - phi[to];
if (fl[id] < cp[id]) {
if (dist[to] > dist[v] + we) {
pq.erase(make_pair(dist[to], to));
dist[to] = dist[v] + we;
from[to] = id;
pq.insert(make_pair(dist[to], to));
}
}
}
}
int afl = 0;
int ale = 0;
if (dist[T] != inf) {
int mn = inf;
for (int u = T; u != S; u = getTo(from[u], u)) {
mn = min(mn, cp[from[u]] - fl[from[u]]);
}
afl = mn;
for (int u = T; u != S; u = getTo(from[u], u)) {
ale += mn * co[from[u]];
fl[from[u]] += mn;
fl[from[u] ^ 1] -= mn;
}
for (int i = 1; i <= N; i++) {
phi[i] += dist[i];
}
}
return make_pair(afl, ale);
}
void mcmf() {
phi[S] = 0;
used[S] = 1;
dfs(T);
int res = 0;
pair<int, int> add;
int len = 0;
while (res < 4) {
add = dkstra();
if (add.first == 0) break;
res += add.first;
len += add.second;
}
printf("%d\n", len >= 0 ? len : -len);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
N = 2 * n + 2;
S = 2 * n + 1;
T = 2 * n + 2;
for (int i = 1; i <= n; i++) {
addEdge(S, i, 1, 0);
addEdge(i, S, 0, 0);
addEdge(i + n, T, 1, 0);
addEdge(T, i + n, 0, 0);
addEdge(i, i + n, 1, -1);
addEdge(i + n, i, 0, +1);
}
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
if (abs(a[i] - a[j]) == 1 || a[i] % 7 == a[j] % 7) {
addEdge(i + n, j, 1, 0);
addEdge(j, i + n, 0, 0);
}
}
}
mcmf();
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int c(int s, int n) {
if (n == 1) return s;
return c(s + 1, (n + 3) / 4);
}
int main() {
int ans, num, tmps, tmpn;
while (scanf("%d", &num) != EOF) {
ans = -1;
while (num--) {
scanf("%d%d", &tmps, &tmpn);
if (tmpn == 1)
ans = max(ans, tmps + 1);
else
ans = max(ans, c(tmps, tmpn));
}
printf("%d\n", ans);
}
return 0;
}
| 1,600 | CPP |
from __future__ import print_function,division
import os,sys,atexit
if sys.version_info[0] < 3:
range = xrange
from cStringIO import StringIO as BytesIO
sys.stdout = BytesIO()
else:
from io import BytesIO
sys.stdout = BytesIO()
_write = sys.stdout.write
sys.stdout.write = lambda s: _write(s.encode())
atexit.register(lambda: os.write(1, sys.stdout.getvalue()))
from collections import defaultdict as dd, deque
n = int(input())
A = [int(x) for x in input().split()]
cA = [0]
for a in A:
cA.append(cA[-1] + a)
B = dd(list)
for l in range(1,n+1):
for i in range(n-l+1):
s = cA[i+l] - cA[i]
B[s].append((i,i+l))
best = 0
bestb = None
for b in sorted(B, key=lambda b: len(B[b]), reverse=True):
if best > len(B[b]):
break
A = sorted(B[b], key=lambda x: x[1])
res = 0
lr = -1
for l,r in A:
if lr <= l:
lr = r
res += 1
if res > best:
best = res
bestb = b
print(best)
A = sorted(B[bestb], key=lambda x: x[1])
res = 0
lr = -1
for l,r in A:
if lr <= l:
lr = r
res += 1
print(l+1,r)
| 1,900 | PYTHON3 |
n = int(input())
for i in range(0,n):
w = input()
if len(w) > 10:
print(w[0],end="")
print(len(w[1:len(w)])-1,end="")
print(w[len(w)-1])
else:
print(w) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 77, inf = 1000000000 + 77;
int n, m, q;
int A[N], lz[N << 2], Mx[N << 2];
vector<int> V[N];
vector<pair<int, int> > Q[N];
inline void Shift(int l, int r, int id) {
int x = lz[id];
if (x == inf) return;
lz[id] = inf;
Mx[id] = min(Mx[id], x);
if (r - l > 1)
lz[id << 1] = min(lz[id << 1], x),
lz[id << 1 ^ 1] = min(lz[id << 1 ^ 1], x);
}
void Update(int ql, int qr, int x, int l = 1, int r = n + 1, int id = 1) {
Shift(l, r, id);
if (qr <= l || r <= ql) return;
if (ql <= l && r <= qr) {
lz[id] = x;
Shift(l, r, id);
return;
}
int mid = ((l + r) >> 1);
Update(ql, qr, x, l, mid, id << 1);
Update(ql, qr, x, mid, r, id << 1 ^ 1);
Mx[id] = max(Mx[id << 1], Mx[id << 1 ^ 1]);
}
pair<int, int> Get(int ql, int x, int l = 1, int r = n + 1, int id = 1) {
Shift(l, r, id);
if (Mx[id] <= x || r <= ql) return make_pair(-1, -1);
if (r - l < 2) return make_pair(l, Mx[id]);
int mid = ((l + r) >> 1);
if (ql <= l) {
Shift(l, mid, id << 1);
Shift(mid, r, id << 1 ^ 1);
if (Mx[id << 1] > x) return Get(ql, x, l, mid, id << 1);
return Get(ql, x, mid, r, id << 1 ^ 1);
}
pair<int, int> t = Get(ql, x, l, mid, id << 1);
if (t.second <= x || t.first < ql) return Get(ql, x, mid, r, id << 1 ^ 1);
return t;
}
int main() {
fill(lz, lz + (N << 2), inf);
fill(Mx, Mx + (N << 2), inf);
scanf("%d %d", &n, &m);
for (int x, y, i = 1; i <= m; ++i) scanf("%d %d", &x, &y), V[x].push_back(y);
scanf("%d", &q);
for (int x, y, i = 1; i <= q; ++i)
scanf("%d %d", &x, &y), Q[x].push_back(make_pair(y, i));
for (int i = n; i > 0; --i) {
for (int x : V[i]) Update(i, x, x);
for (pair<int, int> x : Q[i])
A[x.second] = min(x.first, Get(i, x.first).first);
}
for (int i = 1; i <= q; ++i) printf("%d\n", A[i]);
return 0;
}
| 3,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const char *names[] = {"Anka", "Chapay", "Cleo", "Troll",
"Dracul", "Snowy", "Hexadecimal"};
bool g[7][7];
int id(char *name) {
for (int i = 0; i < 7; i++)
if (!strcmp(name, names[i])) return i;
return -1;
}
int main() {
int n;
scanf("%d", &n);
memset(g, 0, sizeof(g));
for (int i = 0; i < n; i++) {
char name1[1024], name2[1024], temp[1024];
scanf("%s%s%s", name1, temp, name2);
g[id(name1)][id(name2)] = true;
}
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
int diff = INT_MAX;
int liking = INT_MIN;
for (int i = 0; i < (1 << 14); i++) {
int sel[7];
int z[3] = {};
bool valid = true;
for (int j = 0; j < 7; j++) {
sel[j] = (i >> j * 2) & 3;
if (sel[j] == 3) {
valid = false;
break;
}
z[sel[j]]++;
}
if (!valid) continue;
if (z[0] == 0 || z[1] == 0 || z[2] == 0) continue;
z[0] = a / z[0];
z[1] = b / z[1];
z[2] = c / z[2];
sort(z, z + 3);
if (diff < z[2] - z[0]) continue;
int count = 0;
for (int y = 0; y < 7; y++)
for (int x = 0; x < 7; x++) {
if (sel[y] != sel[x]) continue;
if (g[y][x]) count++;
}
if (diff > z[2] - z[0] || (diff == z[2] - z[0] && liking < count)) {
diff = z[2] - z[0];
liking = count;
}
}
printf("%d %d\n", diff, liking);
return 0;
}
| 1,400 | CPP |
for _ in range(int(input())):
N = int(input())
S = input();s = [*S];a=""
for i in s:
if int(i) % 2 !=0:
a+=i
if len(a) >=2:
print(a[0]+a[1])
else:
print(-1) | 900 | PYTHON3 |
#include <bits/stdc++.h>
const int N = 400;
int a[N], b[N];
char C;
int n, x, y, ans = 0;
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> C >> x >> y;
if (C == 'F')
for (int j = x; j <= y; j++) a[j]++;
else
for (int j = x; j <= y; j++) b[j]++;
}
for (int i = 1; i <= 366; i++) ans = max(ans, min(a[i], b[i]));
cout << ans * 2 << endl;
}
| 1,100 | CPP |
n = int(input())
a = []
for i in range(n):
x, y = map(int, input().split())
a.append([x,y])
c = 0
for i in range(n):
for j in range(n):
if i == j:
continue
if a[i][0] == a[j][1]:
c += 1
print(c)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
int main() {
cin >> n >> k;
cout << (n + k - n % k);
return 0;
}
| 800 | CPP |
T=int(input())
for _ in range(T):
n=int(input())
students=[]
for _ in range(n):
s=list(map(int,input().split(' ')))
students.append(s)
days=[0,0,0,0,0]
for s in students:
for x in range(5):
days[x]+=s[x]
def check(d1,d2):
n1=0
n2=0
n12=0
for s in students:
if s[d1]and s[d2]:
n12+=1
elif s[d1]:
n1+=1
elif s[d2]:
n2+=1
else:
return False
# print(n1,n2,n12,'asddsa')
if n12+n1+n2!=n:
return False
if max(n1,n2)-min(n1,n2)>n12:
return False
n12-=max(n1,n2)-min(n1,n2)
if n12%2:
return False
# if (max(n1,n2)+n12//2)%2:
# return False
return True
res=False
while 1:
# print(days)
if res:
break
top=max(days)
topD=days.index(top)
days[topD]=0
if top<n//2:
res=False
break
for d_i in range(5):
d=days[d_i]
if d<n//2:
days[d_i]=0
else:
# print(topD,d_i)
if check(topD,d_i):
res=True
break
if res:
print('YES')
else:
print('NO') | 1,000 | PYTHON3 |
t=int(input())
for _ in range(t):
n=int(input())
a=list(map(int,input().split()))
c=0
m=10**7
for i in range(n-1,-1,-1):
if(i==n-1):
m=a[i]
continue
else:
if(a[i]>m):
c+=1
continue
if(a[i]<=m):
m=a[i]
print(c) | 1,100 | PYTHON3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:200000000")
using namespace std;
template <typename T>
inline T Abs(T x) {
return (x >= 0) ? x : -x;
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
inline string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
template <typename T>
inline int bit(T mask, int b) {
return (b >= 0 && (mask & (T(1) << b)) != 0) ? 1 : 0;
}
inline int nextInt() {
int x;
if (scanf("%d", &x) != 1) throw;
return x;
}
inline long long nextInt64() {
long long x;
if (scanf("%I64d", &x) != 1) throw;
return x;
}
inline double nextDouble() {
double x;
if (scanf("%lf", &x) != 1) throw;
return x;
}
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int MAXN = 1100;
const int MOD = INF + 7;
int n, m, k, a[MAXN][MAXN], s[MAXN][MAXN], res[MAXN][MAXN];
int orcolor[MAXN], mycolor[MAXN];
int f[MAXN], c[MAXN][MAXN];
int C(int n, int k) {
if (n == k || k == 0) return 1;
int &ans = c[n][k];
if (ans == -1) ans = (C(n - 1, k) + C(n - 1, k - 1)) % MOD;
return ans;
}
int get(int x, int y, int c, int c1) {
if (c > k) return 0;
if (x == n) return (1LL * C(k - c1, c - c1) * f[c - c1]) % MOD;
if (y == m) return get(x + 1, 0, c, c1);
int mask = 0;
if (x > 0) mask |= s[x - 1][y];
if (y > 0) mask |= s[x][y - 1];
int ans = 0;
for (int i = 0; i < (int)(c + 1); i++) {
if (bit(mask, i)) continue;
int need = a[x][y];
if (need == -1) {
res[x][y] = i;
s[x][y] = mask | (1 << i);
ans = (ans + get(x, y + 1, max(c, i + 1), c1)) % MOD;
continue;
}
if (mycolor[need] != -1 && mycolor[need] != i) continue;
if (orcolor[i] != -1 && orcolor[i] != need) continue;
if (mycolor[need] == -1) {
mycolor[need] = i;
orcolor[i] = need;
res[x][y] = i;
s[x][y] = mask | (1 << i);
ans = (ans + get(x, y + 1, max(c, i + 1), c1 + 1)) % MOD;
mycolor[need] = -1;
orcolor[i] = -1;
} else {
res[x][y] = i;
s[x][y] = mask | (1 << i);
ans = (ans + get(x, y + 1, max(c, i + 1), c1)) % MOD;
}
}
return ans;
}
int main() {
n = nextInt();
m = nextInt();
k = nextInt();
if (n + m - 1 > k) {
cout << 0 << endl;
return 0;
}
for (int i = 0; i < (int)(k + 1); i++)
f[i] = (i == 0) ? 1 : (1LL * f[i - 1] * i) % MOD;
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(m); j++) a[i][j] = nextInt() - 1;
memset(c, 255, sizeof c);
memset(orcolor, 255, sizeof orcolor);
memset(mycolor, 255, sizeof mycolor);
cout << get(0, 0, 0, 0) << endl;
return 0;
}
| 2,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
void c_p_c() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i += 6) {
if (n % i == 0 || n % (i + 2) == 0) return false;
}
return true;
}
vector<bool> Sieve(long long n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (long long i = 2; i * i <= n; i++) {
if (prime[i]) {
for (long long j = i * i; j <= n; j += i) {
prime[j] = false;
}
}
}
vector<bool> primes(n + 1);
primes[0] = false;
primes[1] = false;
for (long long i = 2; i <= n; i++) {
if (prime[i]) primes[i] = true;
}
return primes;
}
set<long long> primeFactors(long long n) {
set<long long> factors;
while (n % 2 == 0) {
n /= 2;
factors.insert(2);
}
for (long long i = 3; i <= sqrt(n); i += 2) {
while (n % i == 0) {
factors.insert(i);
n /= i;
}
}
if (n > 2) factors.insert(n);
return factors;
}
bool func(long long n) {
while (n % 2 == 0) n /= 2;
while (n % 3 == 0) n /= 3;
return (n == 1);
}
int32_t main() {
c_p_c();
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long x = n - (k - 1);
if ((x > 0) && (x & 1)) {
cout << "YES" << '\n';
for (long long i = 1; i <= k - 1; i++) cout << "1 ";
cout << x << '\n';
continue;
}
x = n - 2 * (k - 1);
if ((x > 0) && (!(x & 1))) {
cout << "YES" << '\n';
for (long long i = 1; i <= k - 1; i++) cout << "2 ";
cout << x << '\n';
continue;
}
cout << "NO" << '\n';
}
}
| 1,200 | CPP |
n = int(input())
n=str(n)
c = 0
for i in n:
if(i == '4' or i == '7'):
c = c + 1;
if (c== 4 or c == 7):
print("YES")
else:
print("NO") | 800 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
l = list(map(int, input().split()))
ans = n-1
while ans > 0 and l[ans] <= l[ans-1]:
ans-=1
while ans > 0 and l[ans] >= l[ans-1]:
ans-=1
print(ans)
| 1,200 | PYTHON3 |
n1,m1=input().split()
n=int(n1)
m=int(m1)
s=input().split()
s.sort(key=int,reverse=False)
p=0
C=1000000000000
while p<=m-n:
c=int(s[n-1+p])-int(s[p])
if c<C:
C=c
p=p+1
print(C)
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int t=1;
cin>>t;
while(t--){
int n;
cin>>n;
string a,b;
cin>>a>>b;
vector<int> dp(n,0);
if(a[0]=='0'){
dp[0]=1;
}else{
dp[0]=-1;
}
for(int i=1;i<n;i++){
if(a[i]=='0'){
dp[i]=dp[i-1]+1;
}else{
dp[i]=dp[i-1]-1;
}
}
int used=0;
bool gamovida=true;
for(int i=n-1;i>-1;i--){
if(a[i]==b[i]&&used%2==1&&dp[i]!=0){
gamovida=false;
break;
}if(a[i]!=b[i]&&used%2==0&&dp[i]!=0){
gamovida=false;
break;
}
if(a[i]==b[i]&&used%2==0||a[i]!=b[i]&&used%2==1){
continue;
}else{
used++;
}
}
if(gamovida){
cout<<"YES"<<endl;
}else{
cout<<"NO"<<endl;
}
}
return 0;
} | 1,200 | CPP |
if __name__ == '__main__':
t = int(input())
ans = []
for i in range(t):
n = int(input())
if(n%4 == 0):
print('YES')
else:
print("NO") | 800 | PYTHON3 |
nm=list(map(int,input().split()))
r=nm[0]*nm[1]
p=int(r/2)
print(p)
| 800 | PYTHON3 |
_ = int(input())
while _:
_-=1
n,q = list(map(int, input().split()))
num = list(map(int, input().split()))
dp = [[0, 0] for i in range(n)]
maxn = 0
minn = 0
for i in range(n-1, -1, -1):
dp[i][0] = num[i] - minn
dp[i][1] = num[i] - maxn
maxn = max(maxn, dp[i][0])
minn = min(minn, dp[i][1], 0)
print(maxn) | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long a, b;
cin >> a >> b;
if (a == b)
cout << b;
else
cout << 2 << endl;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10, maxl = 22;
int a, b, d, q, n;
int h[maxn];
int p[maxn][maxl];
int lca(int v, int u) {
if (h[v] > h[u]) swap(v, u);
int dist = h[u] - h[v];
for (int i = maxl - 1; i >= 0; i--)
if (dist & (1 << i)) u = p[u][i];
if (v == u) return v;
for (int i = maxl - 1; i >= 0; i--)
if (p[v][i] != -1 and p[v][i] != p[u][i]) v = p[v][i], u = p[u][i];
return p[v][0];
}
int dis(int v, int u) {
int par = lca(v, u);
return h[v] + h[u] - 2 * h[par];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
memset(p, -1, sizeof p);
cin >> q;
n = 4;
p[2][0] = p[3][0] = p[4][0] = 1;
h[1] = 0;
h[2] = h[3] = h[4] = 1;
a = 2, b = 3, d = 2;
while (q--) {
int v;
cin >> v;
int c1 = n + 1, c2 = n + 2;
n += 2;
p[c1][0] = p[c2][0] = v;
h[c1] = h[c2] = h[v] + 1;
for (int i = 1; i < maxl and p[c1][i - 1] != -1; i++)
p[c1][i] = p[c2][i] = p[p[c1][i - 1]][i - 1];
int dac = dis(a, c1), dbc = dis(b, c1);
if (dac > d) d = dac, b = c1;
if (dbc > d) d = dbc, a = c1;
cout << d << '\n';
}
return 0;
}
| 2,400 | CPP |
n = int(input())
a=0
for i in range (1,n):
if (n-i)%i == 0:
a+=1
print(a) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long A[400000];
long long inf = 1e16;
long long dp[5001][5001];
int n, k, nums, maxskips;
long long f(int pos, int skipped) {
int index = skipped + pos * nums;
if (pos > k || skipped > maxskips) return inf;
if (k == pos && skipped == maxskips) return 0;
if (dp[pos][skipped] != -1) return dp[pos][skipped];
long long o1 = inf, o2 = inf;
if (index + nums < n)
o1 = A[index + nums] - A[index] + f(pos + 1, skipped + 1);
if (index + nums - 1 < n)
o2 = A[index + nums - 1] - A[index] + f(pos + 1, skipped);
return dp[pos][skipped] = min(o1, o2);
}
int main(int argc, char const *argv[]) {
cin >> n >> k;
nums = n / k;
maxskips = n - nums * k;
int tmp;
for (int i = 0; i < n; i++) {
scanf("%d", &tmp);
A[i] = tmp;
}
sort(A, A + n);
memset(dp, -1, sizeof(dp));
cout << f(0, 0) << endl;
return 0;
}
| 2,000 | CPP |
'''
count = 0
n = int(input())
for i in range(n):
p,v,t = map(int, input().split())
if p+v+t > 1: count += 1
print(count)
'''
''' can be written in one line '''
print(sum(input().count('1')>1 for x in range(int(input())))) | 800 | PYTHON3 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
template <typename T>
using pqmin = priority_queue<T, vector<T>, greater<T> >;
template <typename T>
using pqmax = priority_queue<T>;
template <typename T>
using V = vector<T>;
inline char gc() {
static char buf[1 << 20], *h = buf, *t = buf;
return (h == t && (t = (h = buf) + fread(buf, 1, 1 << 20, stdin), h == t)
? -1
: *h++);
}
template <typename T>
inline bool read(T &x) {
static int f;
static char c;
for (c = gc(), f = 1; !isdigit(c); c = gc()) {
if (c == -1)
return false;
else if (c == 45)
f = -1;
}
for (x = c - 48; isdigit(c = gc()); x = x * 10 + c - 48)
;
return x *= f, true;
}
template <typename A, typename B>
inline bool read(A &x, B &y) {
return read(x) && read(y);
}
template <typename A, typename B, typename C>
inline bool read(A &x, B &y, C &z) {
return read(x) && read(y) && read(z);
}
const int N = 100005;
V<int> e[N];
int n, m;
int pos[N], fin[N], value[N], clk;
void change1(const int &pos, const int &x, int l, int r, int rt);
void dfs(int u, int fa) {
pos[u] = ++clk;
change1(clk, value[u], 1, n, 1);
for (const int &v : e[u])
if (v != fa) dfs(v, u);
fin[u] = clk;
}
int lzy[N << 2];
bitset<1003> s[N << 2];
inline void my_add(int rt, int val) {
val %= m;
s[rt] = (s[rt] << val) | (s[rt] >> (m - val));
}
inline void push_up(int rt) { s[rt] = s[rt << 1] | s[rt << 1 | 1]; }
inline void add(int &x, int y) {
x += y;
if (x >= m) x -= m;
}
void push_down(int rt) {
if (lzy[rt]) {
add(lzy[rt << 1], lzy[rt]);
add(lzy[rt << 1 | 1], lzy[rt]);
my_add(rt << 1, lzy[rt]);
my_add(rt << 1 | 1, lzy[rt]);
lzy[rt] = 0;
}
}
void change1(const int &pos, const int &x, int l, int r, int rt) {
if (l == r) {
s[rt].set(x);
return;
}
int mid = l + r >> 1;
if (pos <= mid)
change1(pos, x, l, mid, rt << 1);
else
change1(pos, x, mid + 1, r, rt << 1 | 1);
push_up(rt);
}
void change(const int &L, const int &R, const int &x, int l, int r, int rt) {
if (l >= L && r <= R) {
my_add(rt, x);
add(lzy[rt], x);
return;
}
int mid = l + r >> 1;
push_down(rt);
if (L <= mid) change(L, R, x, l, mid, rt << 1);
if (R > mid) change(L, R, x, mid + 1, r, rt << 1 | 1);
push_up(rt);
}
bitset<1003> query(const int &L, const int &R, int l, int r, int rt) {
if (l >= L && r <= R) return s[rt];
int mid = l + r >> 1;
push_down(rt);
if (L > mid) return query(L, R, mid + 1, r, rt << 1 | 1);
if (R <= mid) return query(L, R, l, mid, rt << 1);
return query(L, R, l, mid, rt << 1) | query(L, R, mid + 1, r, rt << 1 | 1);
}
bitset<1003> p;
inline bool ck_prime(int x) {
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) return false;
return true;
}
int main() {
read(n, m);
p.reset();
for (int i = 2; i < m; ++i) p[i] = ck_prime(i);
for (int i = 1; i <= n; ++i) read(value[i]), value[i] %= m;
for (int i = 1, u, v; i < n; ++i) {
read(u, v);
e[u].push_back(v);
e[v].push_back(u);
}
dfs(1, 0);
int Q;
for (read(Q); Q--;) {
static int tp, x, y;
read(tp);
if (tp == 1) {
read(x, y);
change(pos[x], fin[x], y % m, 1, n, 1);
} else {
read(x);
printf("%d\n", (int)(p & query(pos[x], fin[x], 1, n, 1)).count());
}
}
return 0;
}
| 2,800 | CPP |
import sys
# inf = open('input.txt', 'r')
# reader = (line.rstrip() for line in inf)
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__
t = int(input())
for _ in range(t):
n = int(input())
coms = list(input())
pos = {(0, 0):-1}
x = y = 0
l = -1
r = float('inf')
for i, d in enumerate(coms):
if d == 'L':
x -= 1
elif d == 'R':
x += 1
elif d == 'U':
y += 1
else:
y -= 1
if (x, y) in pos:
prev = pos[(x, y)]
if i - prev < r - l:
r, l = i, prev
pos[(x, y)] = i
if r == float('inf'):
print(-1)
else:
print(l + 2, r + 1)
# inf.close()
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > GG;
int main() {
ios::sync_with_stdio(false);
string s;
int k;
cin >> s >> k;
string ans;
if ((long long)s.length() * (s.length() + 1) / 2 < k) {
cout << "No such line.";
return 0;
}
GG.resize(26, vector<int>());
long long a[27], b[27], temp = 0;
bool ok = true;
int iteration = 0;
a[0] = b[0] = 0;
int last = -1;
while (ok) {
vector<vector<int> > tempp(26, vector<int>());
for (int i = 1; i <= 26; ++i) {
tempp[i - 1].clear();
b[i] = a[i] = 0;
}
if (iteration == 0) {
for (int i = 0; i < s.length(); ++i) {
a[s[i] - 'a' + 1] += s.length() - i;
++b[s[i] - 'a' + 1];
if (i + 1 < s.length()) tempp[s[i] - 'a'].push_back(i + 1);
}
++iteration;
} else {
for (int i = 0; i < GG[last].size(); ++i) {
a[s[GG[last][i]] - 'a' + 1] += s.length() - GG[last][i];
++b[s[GG[last][i]] - 'a' + 1];
if (GG[last][i] + 1 < s.length())
tempp[s[GG[last][i]] - 'a'].push_back(GG[last][i] + 1);
}
}
for (int i = 0; i <= 26; ++i) {
if (temp + a[i] >= k) {
if (i == 0) {
ok = false;
} else {
ans += (char)(i - 1 + 'a');
a[0] = b[i];
last = i - 1;
}
break;
}
temp += a[i];
}
GG = tempp;
}
cout << ans;
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long n, now, next;
long long a[1000000];
bool nt[1000000];
long long MOD(long long a, long long b) { return ((a % b) + b) % b; }
long long GCD(long long a, long long b) {
if (b == 0) return a;
return GCD(b, a % b);
}
long long LCM(long long a, long long b) { return a / GCD(a, b) * b; }
long long ExEuclid(long long a, long long b, long long &x, long long &y) {
long long xx = y = 0, yy = x = 1;
while (b) {
long long q = a / b, t = b;
b = a % b;
a = t;
t = xx;
xx = x - q * xx;
x = t;
t = yy;
yy = y - q * yy;
y = t;
}
return a;
}
long long MOD_Inverse(long long a, long long n) {
long long x, y;
long long d = ExEuclid(a, n, x, y);
if (d > 1) return -1;
return MOD(x, n);
}
void sang() {
long j, i;
memset(nt, true, sizeof(nt));
nt[0] = false;
nt[1] = false;
for (i = 2; i <= 200000; i++)
if (nt[i]) {
j = i;
while (j + i <= 200000) {
j = j + i;
nt[j] = false;
}
}
}
int main() {
sang();
cin >> n;
if (n == 1) {
cout << "YES" << endl;
cout << 1;
return 0;
}
if (n == 4) {
cout << "YES" << endl;
cout << 1 << endl;
cout << 3 << endl;
cout << 2 << endl;
cout << 4 << endl;
return 0;
}
if (!nt[n]) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
a[1] = 1;
a[2] = 2;
now = 2;
for (long long i = 3; i < n; i++) {
long long tg = MOD_Inverse(now, n);
long long k = tg * now / n;
a[i] = (k * n + i) / now;
now = i;
}
a[n] = n;
for (int i = 1; i <= n; i++) cout << a[i] << endl;
return 0;
}
| 2,300 | CPP |
t = int(input())
for _ in range(t):
s = input()
n = len(s)
ans = [0]*10
for i in range(n):
ans[ord(s[i]) - ord('0')] = ans[ord(s[i]) - ord('0')] + 1
ans.sort()
mx = ans[9]
for i in range(10):
for j in range(10):
c = 0
if(j==i):
continue
b = 0
for k in range(n):
if(b==0 and (ord(s[k]) - ord('0')) == i):
b = 1
c = c + 1
elif(b == 1 and (ord(s[k]) - ord('0')) == j):
b = 0
c = c+1
mx = max(c - c%2, mx)
print(n - max(mx, ans[9])) | 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 7;
int w[N], took[N];
set<pair<int, int>> first, second;
void zero() {
int row = (first.begin()->second), value = (first.begin()->first);
cout << row << ' ';
took[row]++;
first.erase(first.begin());
if (took[row] == 1) {
second.insert(make_pair(value, row));
}
}
void one() {
int row = (second.rbegin()->second);
cout << row << ' ';
took[row]++;
second.erase(--second.end());
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> w[i];
first.insert(make_pair(w[i], i));
}
string query;
cin >> query;
for (auto x : query) {
if (x == '0') {
zero();
} else {
one();
}
}
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long solve(int spt, long long ans, long long e) {
if (ans == 0) return 0ll;
long long ret;
if (spt == 0) {
long long v = (1ll << (ans - 1));
if (e <= v)
ret = solve(!spt, ans - 1, e) + 1;
else
ret = solve(spt, ans - 1, e - v) + (1ll << ans);
} else {
long long v = (1ll << (ans - 1));
if (e > v)
ret = solve(!spt, ans - 1, e - v) + 1;
else
ret = solve(spt, ans - 1, e) + (1ll << ans);
}
return ret;
}
int main() {
long long ans, n;
cin >> ans >> n;
cout << solve(0, ans, n);
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<long long> g;
long long root(long long x) {
long long left = 0, right = 1e9;
long long mid, ans;
while (left <= right) {
mid = (left + right) >> 1;
if (mid * mid <= x) {
ans = mid;
left = mid + 1;
} else
right = mid - 1;
}
return ans;
}
void init() {
g.clear();
for (long long i = 2; i <= 1e6; i++) {
double t = 1.0 * i * i * i;
long long s = i * i * i;
while (t < 2e18) {
long long root_s = root(s);
if (root_s * root_s < s) g.push_back(s);
t *= i;
s *= i;
}
}
sort(g.begin(), g.end());
int sz = unique(g.begin(), g.end()) - g.begin();
}
int main() {
init();
int q;
scanf("%d", &q);
long long l, r;
while (q--) {
scanf("%I64d %I64d", &l, &r);
int ans1 =
upper_bound(g.begin(), g.end(), r) - lower_bound(g.begin(), g.end(), l);
int ans2 = root(r) - root(l - 1);
printf("%d\n", ans1 + ans2);
}
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200340;
int T, n, k;
int cost[maxn];
int w[maxn], line[maxn], use[maxn], line2[maxn], que[maxn];
bool cmp(int a, int b) { return w[a] > w[b]; }
bool cmp2(int a, int b) { return cost[a] < cost[b]; }
long long type1() {
long long ans1 = 0ll;
int cnt = 0;
memset(use, 0, sizeof(use));
int e = w[line[k]], t = 0, fail = 0;
for (int i = 1; i < k; i++)
if (w[line[i]] == e) fail++;
for (int i = 1; i <= n; i++)
if (w[line[i]] == e || w[line[i]] == e - 1) que[++cnt] = line[i];
sort(que + 1, que + cnt + 1, cmp2);
for (int i = 1; i <= cnt - fail; i++) {
ans1 += cost[que[i]];
use[que[i]] = 1;
}
int need = max(e - (cnt - fail), 0);
for (int i = 1; i <= n; i++)
if (!use[line2[i]]) {
if (need == 0) break;
ans1 += cost[line2[i]];
need--;
}
if (need) return 0x7ffffffffffffffll;
return ans1;
}
long long type2() {
long long ans1 = 0;
int cnt = 0;
memset(use, 0, sizeof(use));
int e = w[line[k]] + 1, t = 0, fail = 0;
for (int i = 1; i < k; i++)
if (w[line[i]] == e) fail++;
for (int i = 1; i <= n; i++)
if (w[line[i]] == e || w[line[i]] == e - 1) que[++cnt] = line[i];
sort(que + 1, que + cnt + 1, cmp2);
for (int i = 1; i <= cnt - fail; i++) {
ans1 += cost[que[i]];
use[que[i]] = 1;
}
int need = max(e - (cnt - fail), 0);
for (int i = 1; i <= n; i++)
if (!use[line2[i]]) {
if (need == 0) break;
ans1 += cost[line2[i]];
need--;
}
return ans1;
}
long long type3() {
long long ans1 = 0;
int need = w[line[k]] + 2;
for (int i = 1; i <= n; i++) {
if (need == 0) break;
ans1 += cost[line2[i]];
need--;
}
return ans1;
}
long long mincost() {
long long ans = 0x7ffffffffffffffll;
ans = min(ans, type1());
ans = min(ans, type2());
ans = min(ans, type3());
return ans;
}
int main() {
scanf("%d%d", &n, &k);
if (k > n) {
printf("0\n");
return 0;
}
for (int i = 1; i <= n; i++) {
scanf("%d%d", &w[i], &cost[i]);
line[i] = i;
line2[i] = i;
}
int cnt = 0;
for (int i = 1; i <= n; i++)
if (w[i] > n) cnt++;
if (cnt >= k) {
printf("-1\n");
return 0;
}
sort(line + 1, line + n + 1, cmp);
sort(line2 + 1, line2 + n + 1, cmp2);
long long ans = mincost();
cout << ans << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
const long long BOUND = 1e15;
const long long DELTA_X[] = {-1, 0, 0, 1};
const long long DELTA_Y[] = {0, -1, 1, 0};
long long x[4], y[4], xx[4], yy[4], x_low[2], x_high[2], y_low[2], y_high[2],
X[2], Y[2];
void update_range(long long& low, long long& high, long long dx, long long x0,
long long max_t) {
if (dx < 0) {
low = std::max(low, x0 - max_t);
high = std::min(high, x0);
} else if (dx == 0) {
low = std::max(low, x0);
high = std::min(high, x0);
} else {
low = std::max(low, x0);
high = std::min(high, x0 + max_t);
}
}
std::pair<long long, long long> solve(long long* low, long long* high) {
long long sol_lo = std::max(1LL, low[1] - high[0]);
long long sol_hi = high[1] - low[0];
return {sol_lo, sol_hi};
}
bool check(long long max_t) {
for (int d0 = 0; d0 < 4; ++d0) {
for (int d1 = 0; d1 < 4; ++d1) {
for (int d2 = 0; d2 < 4; ++d2) {
for (int d3 = 0; d3 < 4; ++d3) {
int d[4] = {d0, d1, d2, d3};
std::vector<long long> c(4);
std::iota(c.begin(), c.end(), 0);
do {
x_low[0] = x_low[1] = y_low[0] = y_low[1] = -1e18;
x_high[0] = x_high[1] = y_high[0] = y_high[1] = 1e18;
for (long long i = 0; i < 4; ++i) {
long long x_id = c[i] >> 1;
long long y_id = c[i] & 1;
update_range(x_low[x_id], x_high[x_id], DELTA_X[d[i]], x[i],
max_t);
update_range(y_low[y_id], y_high[y_id], DELTA_Y[d[i]], y[i],
max_t);
}
bool valid = true;
valid &= x_low[0] <= x_high[0];
valid &= x_low[1] <= x_high[1];
valid &= y_low[0] <= y_high[0];
valid &= y_low[1] <= y_high[1];
if (!valid) {
continue;
}
auto range_x = solve(x_low, x_high);
auto range_y = solve(y_low, y_high);
if (std::max(range_x.first, range_y.first) <=
std::min(range_x.second, range_y.second)) {
long long l = std::max(range_x.first, range_y.first);
X[0] = std::max(x_low[0], x_low[1] - l);
X[1] = X[0] + l;
Y[0] = std::max(y_low[0], y_low[1] - l);
Y[1] = Y[0] + l;
for (long long i = 0; i < 4; ++i) {
long long x_id = c[i] >> 1;
long long y_id = c[i] & 1;
xx[i] = X[x_id];
yy[i] = Y[y_id];
}
return true;
}
} while (std::next_permutation(c.begin(), c.end()));
}
}
}
}
return false;
}
void work() {
for (long long i = 0; i < 4; ++i) {
std::cin >> x[i] >> y[i];
}
long long low = 0;
long long high = BOUND;
while (low < high) {
long long middle = low + high >> 1;
if (check(middle)) {
high = middle;
} else {
low = middle + 1;
}
}
if (check(high)) {
std::cout << high << std::endl;
for (long long i = 0; i < 4; ++i) {
std::cout << xx[i] << " " << yy[i] << std::endl;
}
} else {
puts("-1");
}
}
int main() {
long long t;
std::cin >> t;
while (t--) {
work();
}
}
| 3,000 | CPP |
from sys import stdin
input = stdin.readline
q = int(input())
def nbr(r,c,x,y):
res = []
if x > 0:
res.append([x-1,y])
if x < r-1:
res.append([x+1,y])
if y > 0:
res.append([x,y-1])
if y < c-1:
res.append([x,y+1])
return res
for _ in range(q):
r,c = map(int,input().split())
mat = [list(map(int,input().split())) for i in range(r)]
for i in range(r):
for j in range(c):
if mat[i][j] == 0:
mat[i][j] = 1
res = True
for i in range(r):
for j in range(c):
if mat[i][j] > len(nbr(r,c,i,j)):
res = False
if not res:
print("NO")
else:
print("YES")
for i in range(r):
if i == 0 or i == r-1:
dupa = [3] * c
dupa[0] = 2
dupa[-1] = 2
print(*dupa)
else:
dupa = [4] * c
dupa[0] = 3
dupa[-1] = 3
print(*dupa)
| 1,200 | PYTHON3 |
a,b = map(int,input().split())
if b != a*(b//a): print (b//a+1)
else: print (b//a) | 800 | PYTHON3 |
"""
Oh, Grantors of Dark Disgrace,
Do Not Wake Me Again.
"""
ii = lambda: int(input())
si = lambda: input()
for _ in range(ii()):
s = si()
if len(s) > 10: print(f"{s[0]}{len(s)-2}{s[-1]}")
else: print(s)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int t = ((int)s[0] - 48) * 600 + ((int)s[1] - 48) * 60 +
((int)s[3] - 48) * 10 + ((int)s[4] - 48);
cin >> s;
t = t + ((int)s[0] - 48) * 600 + ((int)s[1] - 48) * 60 +
((int)s[3] - 48) * 10 + ((int)s[4] - 48);
t = t / 2;
if (t / 60 > 9)
cout << t / 60 << ":";
else
cout << "0" << t / 60 << ":";
if (t % 60 > 9)
cout << t % 60;
else
cout << "0" << t % 60;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
int arr[105][105], a[10005];
int main() {
int n, m, i, j, k = 0, d, val, med, ans = 0;
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &d);
scanf("%d", &arr[1][1]);
a[k] = arr[1][1];
k++;
val = a[0] % d;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (i == 1 && j == 1) continue;
scanf("%d", &arr[i][j]);
a[k] = arr[i][j];
if (a[k] % d != val) {
cout << -1 << endl;
return 0;
}
k++;
}
}
sort(a, a + k);
med = a[k / 2];
for (i = 0; i < k; i++) {
ans = ans + (abs(med - a[i])) / d;
}
cout << ans << endl;
return 0;
}
| 1,400 | CPP |
import math
import string
t1=input().replace(' ','')
t2=input().replace(' ','')
t3=input().replace(' ','')
t4=input().replace(' ','')
t5=input().replace(' ','')
count=0
m=0
s=0
l=0
#print (t1)
ax=[t1,t2,t3,t4,t5]
for i in range(0,5):
#print (ax[i])
r=ax[i].find('1')
if (r!=-1):
#print ('found in ',i,r)
count = abs(2-i)+abs(2-r)
break;
#print (*ax)
print (count )
| 800 | PYTHON3 |
#include <bits/stdc++.h>
const int N = 150;
int n;
int a[N];
void init() {
std::cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
}
void work() {
static bool visit[N];
memset(visit, false, sizeof(visit));
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += a[i];
}
for (int i = 1; i <= n; i++) {
if (visit[i] == false) {
for (int j = i + 1; j <= n; j++) {
if (visit[j] == false && a[i] + a[j] == sum / (n / 2)) {
printf("%d %d\n", i, j);
visit[i] = visit[j] = true;
break;
}
}
}
}
}
int main() {
init();
work();
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[210000], ans, anx[510000], any[510000];
int nbs[210000], nxt[510000], dst[510000], idx[510000], enm;
int rou[210000], cov[210000], fat[210000], vst[210000], sta[210000], top;
set<int> s[3];
static void mark(const int u, const int v) {
a[u] ^= 1;
a[v] ^= 2;
anx[ans] = u;
any[ans] = v;
ans++;
}
static void addedge(const int u, const int v, const int k) {
nxt[++enm] = nbs[u];
nbs[u] = enm;
dst[enm] = v;
idx[enm] = k;
nxt[++enm] = nbs[v];
nbs[v] = enm;
dst[enm] = u;
idx[enm] = k;
}
static int set_pop(set<int> &s) {
set<int>::iterator it = s.begin();
int ret = *it;
s.erase(it);
return ret;
}
static void build(const int u) {
vst[u] = 1;
sta[++top] = u;
for (int i = nbs[u]; i; i = nxt[i]) {
int v = dst[i];
if (vst[v]) continue;
rou[v] = idx[i];
fat[v] = u;
build(v);
}
}
static void do_cov() {
for (int i = top; sta[i]; i--) {
int u = sta[i];
if (!cov[u]) continue;
swap(anx[rou[u]], any[rou[u]]);
cov[fat[u]] ^= 1;
}
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
memset(nbs, 0, sizeof(nbs));
enm = 0;
memset(a, 0, sizeof(a));
ans = 0;
for (int i = 0; i < 3; i++) s[i].clear();
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
mark(u, v);
addedge(u, v, ans - 1);
}
for (int u = 0; u < n; u++) {
if (a[u]) s[a[u] - 1].insert(u);
}
memset(vst, 0, sizeof(vst));
top = 0;
build(0);
memset(cov, 0, sizeof(cov));
while (s[2].size() > 1) {
int x = set_pop(s[2]);
int y = set_pop(s[2]);
cov[x] ^= 1;
cov[y] ^= 1;
}
for (int p = 0; p < 2; p++) {
int q = p ^ 1;
if (!s[2].empty() && s[p].size() > s[q].size()) {
int x = set_pop(s[2]);
int y = set_pop(s[p]);
cov[x] ^= 1;
cov[y] ^= 1;
s[q].insert(y);
}
while (s[p].size() > s[q].size() + 2) {
int x = set_pop(s[p]);
int y = set_pop(s[p]);
cov[x] ^= 1;
s[q].insert(x);
cov[y] ^= 1;
s[q].insert(y);
}
}
for (set<int>::iterator it = s[2].begin(); it != s[2].end(); it++)
mark(*it, *it);
while (!s[0].empty() && !s[1].empty()) {
int x = set_pop(s[0]);
int y = set_pop(s[1]);
mark(x, y);
}
while (!s[0].empty()) mark(set_pop(s[0]), 0);
while (!s[1].empty()) mark(0, set_pop(s[1]));
do_cov();
printf("%d\n", ans);
for (int i = 0; i < ans; i++) printf("%d %d\n", anx[i] + 1, any[i] + 1);
}
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pll;
#define all(x) (x).begin(),(x).end()
#define X first
#define Y second
#define sep ' '
#define endl '\n'
#define debug(x) cerr << #x << ": " << x << endl;
const ll MAXN = 1e6 + 10;
const ll INF = 8e18;
const ll MOD = 1e9 + 7; // 998244353; // 1e9 + 9;
const ll LOG = 20;
int n, m, P[MAXN], H[MAXN], t_0, par[MAXN][LOG];
vector<int> adj[MAXN];
vector<pll> adj2[MAXN];
vector<pair<int, pll>> edges, mst_edges;
set<int> un_vis;
ll ans;
bool w_0[MAXN][LOG];
set<pll> used;
int Find(int v) {
if (v == P[v]) return v;
return P[v] = Find(P[v]);
}
inline bool Union(int v, int u, int w) {
int pu = u, pv = v;
v = Find(v), u = Find(u);
if (v == u) return false;
P[v] = u;
ans += w;
used.insert({pv, pu});
used.insert({pu, pv});
if (w == 0) t_0++;
mst_edges.push_back({w, {pu, pv}});
return true;
}
void dfs(int v) {
un_vis.erase(v);
int lst = 0;
while (true) {
auto it = un_vis.upper_bound(lst);
if (it == un_vis.end()) break;
lst = *it;
if (binary_search(all(adj[v]), lst)) continue; //
Union(v, lst, 0);
dfs(lst);
}
}
void dfs2(int v, int p, int w) {
par[v][0] = p;
w_0[v][0] = (w == 0);
for (pll e : adj2[v]) {
int u = e.X, w = e.Y;
if (u == p) continue;
H[u] = H[v] + 1;
dfs2(u, v, w);
}
}
pair<int, bool> kth_par(int v, int k) {
bool b = false;
for (int i = LOG - 1; i >= 0; i--)
if (k & (1 << i))
b |= w_0[v][i], v = par[v][i];
return {v, b};
}
bool LCA(int u, int v) {
if (H[v] < H[u]) swap(v, u);
pair<int, bool> p = kth_par(v, H[v] - H[u]);
v = p.X;
bool b = p.Y;
if (v == u) return b;
for (int i = LOG - 1; i >= 0; i--) {
if (par[v][i] != par[u][i]) {
b |= w_0[v][i];
b |= w_0[u][i];
v = par[v][i];
u = par[u][i];
}
}
b |= w_0[v][0];
b |= w_0[u][0];
return b;
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin >> n >> m;
int x = 0;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
x ^= w;
edges.push_back({w, {u, v}});
adj[v].push_back(u);
adj[u].push_back(v);
}
for (int i = 1; i <= n; i++) {
sort(all(adj[i]));
un_vis.insert(i);
P[i] = i;
}
while (!un_vis.empty()) dfs(*un_vis.begin());
sort(all(edges));
for (auto e : edges) Union(e.Y.X, e.Y.Y, e.X);
for (auto e : mst_edges) {
adj2[e.Y.X].push_back({e.Y.Y, e.X});
adj2[e.Y.Y].push_back({e.Y.X, e.X});
}
dfs2(1, 0, 1);
for (int i = 1; i < LOG; i++) {
for (int v = 1; v <= n; v++) {
par[v][i] = par[par[v][i - 1]][i - 1];
w_0[v][i] = w_0[v][i - 1] | w_0[par[v][i - 1]][i - 1];
}
}
ll tot = 1ll * n * (n - 1) / 2 - m;
if (tot == t_0) {
for (pair<int, pll> et : edges) {
pll e = et.Y;
if (used.find(e) != used.end()) continue;
bool b = LCA(e.X, e.Y);
if (b) return cout << min(ans + et.X, ans + x) << endl, 0;
}
cout << ans + x << endl;
return 0;
}
cout << ans << endl;
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
template <class T>
inline void read(T &res) {
char ch;
while (ch = getchar(), !isdigit(ch))
;
res = ch ^ 48;
while (ch = getchar(), isdigit(ch)) res = res * 10 + ch - 48;
}
template <class T>
inline void put(T x) {
if (x > 9) put(x / 10);
putchar(x % 10 + 48);
}
using std::pair;
using std::vector;
const int N = 1e5 + 5;
const int M = 2e5 + 5;
int que[N];
bool vis[N];
int n, q, z, tot, qr, opt;
struct Edge {
int to, cst;
Edge *nxt;
} p[M], *lst[N], *P = p;
inline void Link(int x, int y, int z) {
(++P)->nxt = lst[x];
lst[x] = P;
P->to = y;
P->cst = z;
(++P)->nxt = lst[y];
lst[y] = P;
P->to = x;
P->cst = z;
}
template <class T>
inline T Max(T x, T y) {
return x > y ? x : y;
}
struct tree {
pair<int, int> pos[N];
int anc[N][20], dis[N];
int cst[N], pre[N], mx[N], son[N];
int ed[N], _rank[N], id[N], sum[N];
int rt, T;
inline void findRoot(int src) {
rt = src;
for (int i = 1; i <= n; ++i) vis[i] = false;
que[qr = 1] = src;
vis[src] = true;
dis[src] = 0;
for (int i = 1, x, y; i <= qr; ++i) {
x = que[i];
for (Edge *e = lst[x]; e; e = e->nxt)
if (y = e->to, !vis[y]) {
que[++qr] = y;
vis[y] = true;
dis[y] = dis[x] + e->cst;
if (dis[y] > dis[rt]) rt = y;
}
}
}
inline void dfs1(int x) {
for (int i = 0; anc[x][i]; ++i) anc[x][i + 1] = anc[anc[x][i]][i];
for (Edge *e = lst[x]; e; e = e->nxt) {
int y = e->to;
if (y == anc[x][0]) continue;
anc[y][0] = x;
cst[y] = e->cst;
dis[y] = dis[x] + cst[y];
dfs1(y);
int tmp = mx[y] + cst[y];
if (tmp > mx[x]) mx[x] = tmp, son[x] = y;
}
}
inline void dfs2(int x) {
if (son[x]) {
id[son[x]] = id[x];
sum[id[x]] += cst[son[x]];
dfs2(son[x]);
} else
ed[id[x]] = x;
for (Edge *e = lst[x]; e; e = e->nxt) {
int y = e->to;
if (y == anc[x][0] || y == son[x]) continue;
id[y] = ++T;
sum[T] = cst[y];
dfs2(y);
}
}
inline void init() {
dis[rt] = 0;
dfs1(rt);
id[rt] = T = 1;
dfs2(rt);
for (int i = 1; i <= T; ++i) pos[i] = std::make_pair(sum[i], i);
std::sort(pos + 1, pos + T + 1);
std::reverse(pos + 1, pos + T + 1);
for (int i = 1; i <= T; ++i) pre[i] = pre[i - 1] + pos[i].first;
for (int i = 1; i <= T; ++i) _rank[pos[i].second] = i;
}
inline int query_case1(int x, int y) {
int u = x;
for (int i = 16; i >= 0; --i)
if (anc[u][i] && _rank[id[anc[u][i]]] >= y) u = anc[u][i];
u = anc[u][0];
return pre[y - 1] + dis[ed[id[x]]] - dis[u];
}
inline int query_case2(int x, int y) {
int u = x;
for (int i = 16; i >= 0; --i)
if (anc[u][i] && _rank[id[anc[u][i]]] > y) u = anc[u][i];
u = anc[u][0];
return pre[y] - mx[u] + dis[ed[id[x]]] - dis[u];
}
inline int calc(int x, int y) {
return _rank[id[x]] <= y ? pre[y]
: Max(query_case1(x, y), query_case2(x, y));
}
} t1, t2;
int main() {
read(n);
read(q);
opt = 1;
for (int i = 1, x, y, z; i < n; ++i) {
read(x);
read(y);
read(z);
Link(x, y, z);
tot += z;
}
t1.findRoot(1);
t2.findRoot(t1.rt);
t1.init();
t2.init();
int last_ans = 0, x, y;
while (q--) {
read(x);
read(y);
if (opt) {
x = (x + last_ans - 1) % n + 1;
y = (y + last_ans - 1) % n + 1;
}
y = (y << 1) - 1;
put(last_ans = y >= t1.T ? tot : Max(t1.calc(x, y), t2.calc(x, y))),
putchar('\n');
}
return 0;
}
| 3,300 | CPP |
l, d, v, g, r = map(int, input().split())
seconds_to_traffic_light = (d / v)
seconds_to_final_point = (l - d) / v
def get_waiting_time(t, g, r):
while t > (g + r):
t -= (g + r)
if t < g:
return 0
return (g + r - t)
# endfold
waiting_time = get_waiting_time(seconds_to_traffic_light, g, r)
answer = seconds_to_traffic_light + waiting_time + seconds_to_final_point
print("%.9f" % answer)
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long n, d, m, l;
int main() {
cin >> n >> d >> m >> l;
for (int i = 1; i < n; i++) {
unsigned long long pos =
d * (((i - 1) * m + l + 1) / d + (((i - 1) * m + l + 1) % d > 0));
if (pos > (i - 1) * m + l && pos < i * m) {
cout << pos;
return 0;
}
}
cout << d * (((n - 1) * m + l + 1) / d + (((n - 1) * m + l + 1) % d > 0));
return 0;
}
| 1,700 | CPP |
n=int(input())
l=[]
for i in range(n):
l.append(input())
if len(l[i])>10:
print(l[i][0]+str(len(l[i])-2)+l[i][-1])
else:
print(l[i]) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 262151;
const int SIZE = 300030;
int a[SIZE];
long long sum[SIZE], sumPos[SIZE];
vector<int> v[2 * MOD];
void init() {
memset(sum, 0, sizeof(sum)), memset(sumPos, 0, sizeof(sumPos));
for (int i = 0; i < 2 * MOD; i++) v[i].clear();
}
long long gao(int Left, int Right) {
if (a[Left] >= 0) return sumPos[Right] - sumPos[Left - 1];
return sumPos[Right] - sumPos[Left - 1] + 2 * a[Left];
}
int main() {
int n;
init();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
v[a[i] % MOD + MOD].push_back(i);
sum[i] = sum[i - 1] + a[i];
sumPos[i] = sumPos[i - 1] + (a[i] >= 0 ? a[i] : 0);
}
long long Max = -(1 << 31);
int mark1, mark2;
for (int i = 0; i < 2 * MOD; i++) {
int tmp = v[i].size();
if (!tmp || tmp == 1) continue;
tmp = v[i][0];
for (int j = 1; j < v[i].size(); j++) {
if (a[v[i][j]] != a[tmp]) {
long long t = gao(tmp, v[i][j - 1]);
if (Max < t) {
Max = t;
mark1 = tmp, mark2 = v[i][j - 1];
}
tmp = v[i][j];
continue;
}
}
long long t = gao(tmp, v[i][v[i].size() - 1]);
if (Max < t) {
Max = t;
mark1 = tmp, mark2 = v[i][v[i].size() - 1];
}
}
int ans = mark1 - 1 + n - mark2;
for (int i = mark1 + 1; i < mark2; i++)
if (a[i] < 0) ans++;
printf("%I64d %d\n", Max, ans);
for (int i = 1; i < mark1; i++) printf("%d ", i);
for (int i = mark1 + 1; i < mark2; i++)
if (a[i] < 0) printf("%d ", i);
for (int i = mark2 + 1; i <= n; i++) printf("%d ", i);
puts("");
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int bears[200002];
int sel[200002];
priority_queue<pair<int, int> > pq;
int select_bear() {
pair<int, int> tmp = pq.top();
int pos = tmp.second;
int left, right;
left = pos - sel[pos - 1];
right = pos + sel[pos + 1];
return sel[left] = sel[right] = right - left + 1;
}
int main() {
int n, now, gsize;
memset(sel, 0, sizeof(sel));
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &bears[i]);
for (int i = 1; i <= n; i++) pq.push(make_pair(bears[i], i));
now = 0;
while (now < n) {
gsize = select_bear();
for (; now < gsize; now++) printf("%d ", pq.top().first);
pq.pop();
}
printf("\n");
while (!pq.empty()) pq.pop();
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, ok[300];
int viz[300];
string s[105];
vector<char> gr[300], gt[300];
string st;
void dfs(char s) {
ok[s] = 1;
for (vector<char>::iterator i = gr[s].begin(); i != gr[s].end(); ++i)
if (!ok[*i]) dfs(*i);
st += s;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> s[i];
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) {
int k;
for (k = 0; k < s[i].size() && k < s[j].size() && s[i][k] == s[j][k]; ++k)
;
if (k >= s[i].size()) continue;
if (k >= s[j].size() && k < s[i].size()) {
cout << "Impossible\n";
return 0;
}
gr[s[i][k]].push_back(s[j][k]);
gt[s[j][k]].push_back(s[i][k]);
}
for (char c = 'a'; c <= 'z'; ++c)
if (!ok[c]) dfs(c);
reverse(st.begin(), st.end());
for (int i = 0; i < st.size(); ++i) {
for (vector<char>::iterator j = gt[st[i]].begin(); j != gt[st[i]].end();
++j)
if (!viz[*j]) {
cout << "Impossible\n";
return 0;
}
viz[st[i]] = 1;
}
cout << st;
}
| 1,600 | CPP |
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 2020/6/19
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
from functools import lru_cache
NUMS_REP = ['1110111', '0010010', '1011101', '1011011', '0111010', '1101011', '1101111', '1010010', '1111111', '1111011']
def diff(s, t):
d = 0
for i in range(7):
sone = (s & (1 << i)) > 0
tone = (t & (1 << i)) > 0
if sone and not tone:
return -1
if not sone and tone:
d += 1
return d
def str2int(s):
v = 0
for c in s:
v <<= 1
v |= 1 if c == '1' else 0
return v
NUMS = [str2int(s) for s in NUMS_REP]
dist = [[0 for _ in range(10)] for _ in range(128)]
for s in range(128):
for t in range(10):
dist[s][t] = diff(s, NUMS[t])
def solve(N, K, A):
A = [0] + A[::-1]
dp = [[False for _ in range(K+1)] for _ in range(N+1)]
dp[0][0] = True
for i in range(1, N+1):
for k in range(min(K, 7 * i)+1):
for t in range(10):
d = dist[A[i]][t]
if 0 <= d <= k and dp[i-1][k-d]:
dp[i][k] = True
break
if not dp[N][K]:
return -1
ans = []
x, y = N, K
while x > 0:
s = A[x]
for t in range(9, -1, -1):
d = dist[s][t]
if 0 <= d <= y and dp[x-1][y-d]:
ans.append(t)
x -= 1
y -= d
break
return ''.join(map(str, ans))
if __name__ == '__main__':
N, K = map(int, input().split())
A = []
for i in range(N):
A.append(str2int(input()))
print(solve(N, K, A))
| 1,700 | PYTHON3 |
import sys
try:
n = int(input())
r1 = tuple(map(lambda c: int(c) - 1, input().split()))
r2 = tuple(map(lambda c: int(c) - 1, input().split()))
m = [[*map(int, input())] for _ in range(n)]
except:
print('oopsie1')
def adj(i, j):
l = []
if i > 0: l.append((i - 1, j))
if i < n - 1: l.append((i + 1, j))
if j > 0: l.append((i, j - 1))
if j < n - 1: l.append((i, j + 1))
return l
seen = set()
def dfs(i, j):
sys.setrecursionlimit(sys.getrecursionlimit() + 1)
try:
seen.add((i, j))
res = [(i, j)]
for x, y in adj(i, j):
if (x, y) not in seen and m[x][y] == 0:
t = dfs(x, y)
res.extend(t)
return res
except Exception as e:
print(e)
c1 = dfs(r1[0], r1[1])
res = float('inf')
if r2 in seen:
res = 0
else:
c2 = dfs(r2[0], r2[1])
try:
for x1 in c1:
for x2 in c2:
v = ((x1[0] - x2[0]) ** 2) + ((x1[1] - x2[1]) ** 2)
res = min(res, v)
except:
print('oopsie3')
print(res) | 1,400 | PYTHON3 |
import math
t=int(input())
for _ in range(t):
n,m,k=[int(x) for x in input().split()]
p=n//k
l=[]
if m==p or m==0 :
print(m)
elif m>p:
f=p
m-=p
r=k-1
w=math.ceil(m/r)
print(f-w)
else:
print(m)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
const long long int MOD = 1e9 + 7;
const long long int INF = 1e18;
using namespace std;
void solve() {
long long int arr[5][5];
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
cin >> arr[i][j];
}
}
std::vector<int> perm = {0, 1, 2, 3, 4};
long long int maxS = 0;
do {
long long int score = 0;
score = arr[perm[0]][perm[1]] + arr[perm[1]][perm[0]];
score += arr[perm[2]][perm[3]] + arr[perm[3]][perm[2]];
score += arr[perm[1]][perm[2]] + arr[perm[2]][perm[1]];
score += arr[perm[3]][perm[4]] + arr[perm[4]][perm[3]];
score += arr[perm[2]][perm[3]] + arr[perm[3]][perm[2]];
score += arr[perm[4]][perm[3]] + arr[perm[3]][perm[4]];
maxS = max(maxS, score);
} while (next_permutation(perm.begin(), perm.end()));
cout << maxS << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
for (int t = 1; t <= T; t++) {
solve();
}
return 0;
}
| 1,200 | CPP |
n = int(input())
for i in range(1 , n + 1):
if (i * (i + 1)) // 2 == n:
print('YES')
break
if (i * (i + 1)) // 2 > n:
print('NO')
break | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void next_int(T &x) {
x = 0;
char c;
bool neg = false;
while (!isdigit(c = getchar()))
if (c == '-') neg = true;
do x = x * 10 + c - 48;
while (isdigit(c = getchar()));
if (neg) x = -x;
}
template <typename T>
inline void write_int(T x, char last = 0) {
if (x < 0) putchar('-'), x = abs(x);
char tmp[20];
int cnt = 0;
while (x >= 10) tmp[cnt++] = x % 10 + 48, x /= 10;
tmp[cnt] = x + 48;
for (int i = (cnt); i >= (0); --i) putchar(tmp[i]);
if (last) putchar(last);
}
const int N = 205;
int n, m, q, cnt, mask[N * N], a[N * N], nxt[N * N], vis[N * N];
bool vis2[N * N];
pair<int, int> dir[10];
vector<int> c[N * N], rev[N * N], st;
char s[(int)1e6 + 5];
void dfs_cycle(int u) {
st.push_back(u), vis[u] = 1;
if (!vis[nxt[u]])
dfs_cycle(nxt[u]);
else if (vis[nxt[u]] == 1) {
++cnt;
while (((int)st.size()) && st.back() != nxt[u]) {
c[cnt].push_back(st.back()), mask[cnt] |= (1 << a[st.back()]);
st.pop_back();
}
c[cnt].push_back(nxt[u]), mask[cnt] |= (1 << a[nxt[u]]), st.pop_back();
}
vis[u] = 2;
}
void getcycles() {
for (int i = (1); i <= (n); ++i)
if (!vis[i]) dfs_cycle(i);
}
void reverse_graph() {
for (int i = (1); i <= (n); ++i) rev[nxt[i]].push_back(i);
}
bool dfs_work(int u, int pos, const int &len) {
vis2[u] = true;
if (pos > len) return true;
for (int i = (0); i < (((int)rev[u].size())); ++i) {
int v = rev[u][i], c = a[rev[u][i]];
if (vis2[v]) continue;
bool ok = false;
if (c == s[pos] - '0')
ok = dfs_work(v, pos + 1, len);
else
ok = dfs_work(v, pos, len);
if (ok) return ok;
}
return false;
}
bool solve(int idcycle) {
int len = strlen(s + 1), smask = 0;
for (int i = (1); i <= (len); ++i) {
smask |= (1 << (s[i] - '0'));
if ((smask & mask[idcycle]) != smask)
return dfs_work(c[idcycle][0], i, len);
}
return true;
}
int main() {
next_int(n), next_int(m), next_int(q);
for (int i = (1); i <= (n); ++i) {
scanf("%s", s + 1);
for (int j = (1); j <= (m); ++j) a[(i - 1) * m + j] = s[j] - '0';
}
for (int i = (0); i < (10); ++i)
next_int(dir[i].first), next_int(dir[i].second);
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (m); ++j) {
int d = a[(i - 1) * m + j], ni = i + dir[d].first, nj = j + dir[d].second;
if (!(ni > 0 && ni <= n && nj > 0 && nj <= m)) ni = i, nj = j;
nxt[(i - 1) * m + j] = (ni - 1) * m + nj;
}
n *= m;
getcycles();
reverse_graph();
while (q--) {
scanf("%s", s + 1);
int len = strlen(s + 1);
reverse(s + 1, s + len + 1);
memset(vis2, false, sizeof(vis2));
bool ok = false;
for (int i = (1); i <= (cnt); ++i)
if (solve(i)) {
puts("YES");
ok = true;
break;
}
if (!ok) puts("NO");
}
return 0;
}
| 2,500 | CPP |
Subsets and Splits