solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
for i in range(int(input())):
i = int(input())
b = i//2
if b%2 == 0:
print("YES")
a = [0]*(i-1)
s = 0
c = 1
s1 = 0
g = 0
for i in range(b):
g += 2
a[i] = g
s += a[i]
if i == b - 1:
break
a[i+b] = max(0, c)
s1 = s1 + a[i+b]
c += 2
a.append(s-s1)
for i in a:
print(i, end=" ")
else:
print("NO") | 8 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
const int M = 1e9+7;
int main(){
int n;
cin>>n;
vector<int> arr(n);
for(int i=0;i<n;i++) cin>>arr[i];
vector<int> pos(n);
for(int i=0;i<n;i++) pos[arr[i]]++;
if(pos[0]>1){
cout<<0;
return 0;
}
for(int p : arr){
if(pos[p]>2){
cout<<0;
return 0;
}
}
long long int res = 1;
for(int i=1;i<=n/2;i++){
res*=2;
if(res>M) res-=M;
}
cout<<res;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double pi = 2.0 * acos(0.0);
const double eps = 1.0e-9;
const int dr[] = {-1, 0, 1, 0}, dc[] = {0, 1, 0, -1};
const int dr6[] = {1, 1, 0, -1, -1, 0}, dc6[] = {0, 1, 1, 0, -1, -1};
const int dr8[] = {-1, -1, 0, 1, 1, 1, 0, -1},
dc8[] = {0, 1, 1, 1, 0, -1, -1, -1};
int main(void) {
istream& is = cin;
ostream& os = cout;
int kase = 1000000000;
for (int ks = 1, n, x[128], d[128]; ks <= kase && is >> n; ++ks) {
for (int i = 0; i < n; ++i) is >> x[i] >> d[i];
bool yes = false;
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j)
if (x[i] + d[i] == x[j] && x[i] == x[j] + d[j]) yes = true;
os << (yes ? "YES" : "NO") << endl;
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int l[200010], r[200010];
int P[200010], sum[200010];
inline int Power(int x, int y) {
int ret = 1;
while (y) {
if (y & 1) ret = 1ll * ret * x % 1000000007;
x = 1ll * x * x % 1000000007;
y >>= 1;
}
return ret;
}
inline int min(int a, int b, int c) { return min(a, min(b, c)); }
inline int max(int a, int b, int c) { return max(a, max(b, c)); }
inline int calc(int l, int r) {
if (l > r) return 0;
int ret = sum[r] - sum[l - 1] + 1000000007;
if (ret >= 1000000007) ret -= 1000000007;
return ret;
}
inline void Add(int &x, int y) {
x += y;
if (x >= 1000000007) x -= 1000000007;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &l[i]);
--l[i];
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &r[i]);
}
P[1] = 1;
for (int i = 2; i <= n; ++i) {
int B = 1ll * (r[i - 1] - l[i - 1]) * (r[i] - l[i]) % 1000000007;
int A = min(r[i - 1], r[i]) - max(l[i - 1], l[i]);
if (A < 0) A = 0;
P[i] = 1ll * (B - A + 1000000007) * Power(B, 1000000007 - 2) % 1000000007;
}
for (int i = 1; i <= n; ++i) {
sum[i] = sum[i - 1] + P[i];
if (sum[i] >= 1000000007) sum[i] -= 1000000007;
}
int Ans = 0;
for (int i = 1; i <= n; ++i) {
Add(Ans, P[i]);
Add(Ans, 1ll * P[i] * calc(1, i - 2) % 1000000007);
Add(Ans, 1ll * P[i] * calc(i + 2, n) % 1000000007);
}
for (int i = 2; i <= n; ++i) {
if (i == 2) {
Add(Ans, 2 * P[i] % 1000000007);
continue;
}
int E = 1;
E -= (1 - P[i] + 1000000007);
if (E < 0) E += 1000000007;
E -= (1 - P[i - 1] + 1000000007);
if (E < 0) E += 1000000007;
int B = 1ll * (r[i - 2] - l[i - 2]) * (r[i - 1] - l[i - 1]) % 1000000007 *
(r[i] - l[i]) % 1000000007;
int A = min(r[i - 2], r[i - 1], r[i]) - max(l[i - 2], l[i - 1], l[i]);
if (A < 0) A = 0;
E += 1ll * A * Power(B, 1000000007 - 2) % 1000000007;
if (E >= 1000000007) E -= 1000000007;
Add(Ans, E * 2 % 1000000007);
}
printf("%d\n", Ans);
}
| 12 | CPP |
#include <iostream>
#include <vector>
using namespace std;
vector<int> sieve(int n) {
vector<int> prime(n);
for(int i=2; i<n; i++) prime[i]=i;
for(int i=2; i*i<n; i++) {
if(prime[i]) {
for(int j=i*i; j<n; j+=i) prime[j]=0;
}
}
return prime;
}
int main() {
vector<int> prime=sieve(50001);
int n;
while(cin >> n && n!=0) {
int cnt=0;
for(int i=2; i<=n/2; i++) {
if(prime[n-i] && prime[i]) cnt++;
}
cout << cnt << endl;
}
return 0;
}
| 0 | CPP |
# import numpy as np
# import sys
# q=int(input())
for i in range(int(input())):
n,k=map(int,input().split())
a=list(map(int,input().split()))
w=list(map(int,input().split()))
a.sort()
w.sort()
posmin=0
posmax=1
posi=0
posx=1
sum=0
while posi<k and w[posi]==1:
sum+=a[-posmax]*2
posmax+=1
posi+=1
while posi<k and w[posi]==2:
sum+=a[-posmax]+a[-posmax-1]
posmax+=2
posi+=1
while posi<=k-posx:
sum+=a[-posmax]+a[posmin]
posmax+=1
posmin+=w[-posx]-1
posx+=1
print(sum)
| 9 | PYTHON3 |
def tanos_sort(item):
center = len(item) // 2
if sorted(item) == item:
return len(item)
return max(tanos_sort(item[:center]), tanos_sort(item[center:]))
n = int(input())
item = list(map(int, input().split()))
print(tanos_sort(item)) | 7 | PYTHON3 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,ans,P;
int a[1000001],g[100001],ni=0,gg[100001],nt;
signed main(){
cin>>n>>a[1]>>P;
int np=a[1],lp=np;
while(!g[np]){
ans+=np;gg[np]=ans;
g[np]=++ni;if(ni>=n)break;lp=np;np=np*np%P;
}
if(ni>=n){
printf("%lld\n",ans);
return 0;
}
ni++;nt=ans-gg[np]+np;
int nn=(n-g[lp])%(ni-g[np]);ans+=(n-g[lp])/(ni-g[np])*nt;
for(int i=np,ni=1;ni<=nn;ni++,i=i*i%P)ans+=i;
printf("%lld\n",ans);
return 0;
}
/*
100 4 17
10 4 7
*/ | 0 | CPP |
a,b = input().split()
h = int(a)
l = int(b)
out = (l*l-h*h)/(2*h)
print(out) | 8 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
lis=sorted(map(int,input().split()))
ans=0
for i in range(n):
if n-i>=lis[i]:
ans=max(ans,lis[i])
elif n-i<lis[i]:
ans=max(ans,n-i)
print(ans)
| 7 | PYTHON3 |
'''
# CodeForce Equalize Prices 900 points
# a = old price / b = new price / k =value input
def Computer_Game():
for _ in range(int(input())):
k, n, a, b = map(int, input().split()) # init charge, num turns in game, a,b bat value
max_turns=0
for turns in range(n):
if k/b > n and (k-a)/b < n-1 and turns == 0:
max_turns=0
break
else:
if k > a:
k -= a
max_turns += 1
elif k > b:
k -= b
if k/b == n-turns:
max_turns = 1
break
else:
max_turns = -1
break
print(max_turns)
return
def bit_plus_plus():
summe = 0
for _ in range(int(input())):
statement = input()
if '+' in statement:
summe += 1
else:
summe -= 1
print(summe)
return
def petya_and_strings():
str_a, str_b = input().lower(), input().lower()
a=(str_a<str_b)
print((str_a>str_b)-(str_a<str_b))
return
'''
def beautiful_matrix():
for idx in range(5):
row_input = list(map(int,input().split()))
if 1 in row_input:
row = idx+1
for idx1, elem in enumerate(row_input):
if elem == 1:
column = idx1+1
output = abs(3 - row) + abs(3 - column)
print(output)
#for row_num in range(4):
# if 1 in row(row_num)
return
if __name__ == '__main__':
beautiful_matrix()
'''
if __name__ == '__main__':
num_queries = int(input())
for querie in range(num_queries):
num_products, value_products = map(int, input().split())
price_products = list(map(int, input().split()))
B_Max = min(price_products)+value_products
B_Min = max(price_products)-value_products
if B_Max >= B_Min:
print(B_Max)
else:
print(-1)
'''
| 7 | PYTHON3 |
def solve(a,b,c):
k=abs(a-b)
l=abs(b-c)
m=abs(a-c)
sum=k+l+m
sum-=4
if(sum<0):
print(0)
else:
print(sum)
t=int(input())
while(t):
t-=1
k,l,m=map(int,input().split())
solve(k,l,m) | 7 | PYTHON3 |
# Boxes Packing
if __name__ == "__main__":
n = int(input())
nums = [int(a) for a in input().strip().split()]
large = max(nums)
result_dict = {}
max_count = 0
for i in range(n):
if nums[i] not in result_dict:
result_dict[nums[i]] = 1
else:
result_dict[nums[i]] += 1
max_count = max(max_count, result_dict[nums[i]])
print(str(max_count))
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int k, a[110][110], n = 0, d[110], j, l, i;
int main() {
scanf("%d", &k);
a[1][2] = 1;
a[2][1] = 1;
d[3] = 1;
for (i = 4; i <= 100; i++) d[i] = d[i - 1] + (i - 2);
i = 2;
while (k > 0) {
i++;
if (d[i] <= k) {
k -= d[i];
for (j = 1; j <= i - 1; j++) a[i][j] = 1, a[j][i] = 1;
} else {
j = i;
while (d[j] > k) j--;
k -= d[j];
for (j = j - 1; j >= 1; j--) a[i][j] = 1, a[j][i] = 1;
}
}
printf("%d\n", i);
for (j = 1; j <= i; j++) {
for (l = 1; l <= i; l++) printf("%d", a[j][l]);
printf("\n");
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 22, Inf = 1 << 28;
int n, a[N][N] = {}, b[N][N] = {}, day[N] = {}, v[N][N] = {}, ans = 0,
state[200000] = {};
int match[N] = {}, nx[N] = {}, ny[N] = {}, now = 0, vx[N] = {}, vy[N] = {},
slack[N] = {};
int calctime = 0;
void init() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) scanf("%d", &b[i][j]);
}
int dfs(int s) {
if (nx[s] == now) return 0;
nx[s] = now;
for (int i = 1; i <= n; ++i)
if (vx[s] + vy[i] == v[s][i]) {
if (match[i] == 0 || dfs(match[i])) {
match[i] = s;
return 1;
}
ny[i] = now;
} else
slack[i] = min(slack[i], vx[s] + vy[i] - v[s][i]);
return 0;
}
int calc() {
fill(match + 1, match + n + 1, 0);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) v[i][j] = day[i] == 1 ? a[i][j] : b[i][j];
if (rand() % 2)
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j) swap(v[i][j], v[j][i]);
fill(vx + 1, vx + n + 1, 0);
fill(vy + 1, vy + n + 1, 0);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
vx[i] = max(vx[i], v[i][j]), vy[j] = max(vy[j], v[i][j]);
if (accumulate(vy + 1, vy + n + 1, 0) <= ans) return 0;
fill(vy + 1, vy + n + 1, 0);
int sum = accumulate(vx + 1, vx + n + 1, 0);
if (sum <= ans) return 0;
calctime += 8;
for (int i = 1; i <= n; ++i) {
fill(slack + 1, slack + n + 1, Inf);
while (++now && !dfs(i)) {
int d = Inf;
for (int j = 1; j <= n; ++j)
if (ny[j] != now) d = min(d, slack[j]);
for (int j = 1; j <= n; ++j)
if (nx[j] == now) vx[j] -= d, sum -= d;
for (int j = 1; j <= n; ++j)
if (ny[j] == now)
vy[j] += d, sum += d;
else
slack[j] -= d;
if (sum <= ans) return 0;
calctime += 6;
}
}
return sum;
}
void work() {
int tot = 0;
for (int i = 0; i < (1 << n); ++i) {
int t = 0;
for (int x = i; x; x -= x & (-x)) ++t;
if (t == n / 2) state[++tot] = i;
}
random_shuffle(state + 1, state + tot + 1);
for (int i = 1; i <= tot; ++i) {
for (int d = 0; d < n; ++d) day[d + 1] = !!(state[i] & (1 << d)) + 1;
ans = max(ans, calc());
if (calctime >= 10000000) break;
}
printf("%d\n", ans);
}
int main() {
srand(time(0));
init();
cerr << clock() << endl;
work();
cerr << clock() << endl;
cerr << "calc=" << calctime << endl;
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
static inline int Rint() {
struct X {
int dig[256];
X() {
for (int i = '0'; i <= '9'; ++i) dig[i] = 1;
dig['-'] = 1;
}
};
static X fuck;
int s = 1, v = 0, c;
for (; !fuck.dig[c = getchar()];)
;
if (c == '-')
s = 0;
else if (fuck.dig[c])
v = c ^ 48;
for (; fuck.dig[c = getchar()]; v = v * 10 + (c ^ 48))
;
return s ? v : -v;
}
template <typename T>
static inline void cmax(T& a, const T& b) {
if (b > a) a = b;
}
template <typename T>
static inline void cmin(T& a, const T& b) {
if (b < a) a = b;
}
const int maxn = 300005;
long long t1[maxn], t2[maxn];
int d[maxn], l[maxn], r[maxn];
vector<int> adj[maxn];
int n;
int now;
const int mod = 1000000007;
void dfs(int curr, int depth) {
d[curr] = depth;
l[curr] = ++now;
vector<int>& vec = adj[curr];
const int size = ((int)(vec).size());
for (int i = 0; i < size; ++i) dfs(vec[i], depth + 1);
r[curr] = now;
}
static inline void update(long long* tree, int x, long long val) {
for (; x <= n; x += x & -x) {
tree[x] += val;
if (tree[x] >= mod) tree[x] -= mod;
}
}
static inline long long query(int v) {
long long a = 0, b = 0;
for (int x = l[v]; x; x -= x & -x) a += t1[x], b += t2[x];
b %= mod;
a = (a - b * d[v]) % mod;
a = (a + mod) % mod;
return a;
}
int main() {
n = Rint();
for (int i = 2; i <= n; ++i) adj[Rint()].push_back(i);
dfs(1, 0);
int q = Rint();
while (q--) {
int cmd = Rint();
if (cmd == 2) {
printf("%I64d\n", query(Rint()));
} else {
int v = Rint(), x = Rint(), k = Rint();
long long val = (long long)k * d[v] + x;
val %= mod;
update(t1, l[v], val);
val = (mod - val) % mod;
update(t1, r[v] + 1, val);
update(t2, l[v], k);
k = (mod - k) % mod;
update(t2, r[v] + 1, k);
}
}
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
unsigned int dp[100005];
int n;
char str[100005];
int main() {
scanf("%d", &n);
if (n & 1) {
puts("0");
return 0;
}
scanf("%s", str + 1);
int q = 0;
for (int i = 1; i <= n; i++) {
if (str[i] != '?') q++;
}
if (q > (n >> 1)) {
puts("0");
return 0;
}
dp[0] = 1;
for (int i = 1; i <= n; i++) {
int l = max(1, i - (n >> 1)), r = i >> 1;
if (str[i] == '?')
for (int j = r; j >= l; j--) dp[j] += dp[j - 1];
}
unsigned int ans = dp[n >> 1];
q = (n >> 1) - q;
for (int i = 0; i < q; i++) ans = ans * 25;
printf("%u\n", ans);
return 0;
}
| 11 | CPP |
#include <cstdio>
int N, M, a[500][500];
int main()
{
scanf("%d%d", &N, &M);
for (int i = 0; i < N; i++)
{
static char _i[501];
scanf("%s", _i);
for (int j = 0; j < M; j++)
a[i][j] = _i[j] == '#';
}
for (int i = 0; i < N; puts(""), i++)
for (int j = 0; j < M; j++)
putchar(a[i][j] || (j == 0 || !(i & 1)) && j != M - 1 ? '#' : '.');
puts("");
for (int i = 0; i < N; puts(""), i++)
for (int j = 0; j < M; j++)
putchar(a[i][j] || (j == M - 1 || (i & 1)) && j != 0 ? '#' : '.');
return 0;
}
| 0 | CPP |
n=int(input())
l=list(map(int,input().split()))[:n]
l.sort()
for u in l:
print(u,end=" ")
| 7 | PYTHON3 |
''' ุจูุณูู
ู ุงูููููู ุงูุฑููุญูู
ููฐูู ุงูุฑููุญููู
ู '''
#codeforces1208B_live
from collections import Counter
gi = lambda : list(map(int,input().split()))
n, = gi()
l = gi()
occ = Counter(l)
mid = 0
ans = n
rep = n - len(occ)
def f(x):
oc = Counter(l)
for k in range(x):
oc[l[k]] -= 1
s = set(oc.values())
if s == {1} or s == {1, 0}:
return 1
for k in range(x, n):
oc[l[k]] -= 1
oc[l[k - x]] += 1
s = set(oc.values())
if s == {1} or s == {1, 0}:
return 1
return 0
lo, hi = 0, n
while lo <= hi:
mid = (lo + hi) // 2
if f(mid):
ans = min(ans, mid)
hi = mid - 1
else:
lo = mid + 1
print(ans) | 8 | PYTHON3 |
n = int(input())
line = ''.join(map(str, range(1,1001)))
print(line[n-1]) | 7 | PYTHON3 |
from collections import Counter
n,k=map(int,input().split())
a=list(map(int,input().split()))
d=Counter(a)
c=0
for x,y in d.items():
if x>=a[k-1] and x>0:
c+=y
print(c) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(int a, int b) { return a > b; }
int main() {
string s;
cin >> s;
vector<int> a, b;
vector<int> dec1, dec2;
int sum1 = s[0] - '0' + (s[1] - '0') + (s[2] - '0');
int sum2 = (s[3] - '0') + (s[4] - '0') + (s[5] - '0');
if (sum1 == sum2) {
cout << 0 << endl;
return 0;
} else if (sum1 > sum2)
for (int i = 0; i < 6; ++i) {
if (i < 3)
dec1.push_back((s[i] - '0'));
else
dec2.push_back(9 - (s[i] - '0'));
}
else {
for (int i = 0; i < 6; ++i) {
if (i < 3)
dec1.push_back(9 - (s[i] - '0'));
else
dec2.push_back(s[i] - '0');
}
}
sort(dec1.begin(), dec1.end());
sort(dec2.begin(), dec2.end());
int x = abs(sum1 - sum2);
int cnt = 0, i = 2, j = 2;
while (x > 0) {
if (dec1[i] > dec2[j]) {
x -= dec1[i];
cnt++;
i--;
} else {
x -= dec2[j];
cnt++;
j--;
}
}
cout << cnt << endl;
return 0;
}
| 8 | CPP |
a,b=list(map(int,input().split()))
c2=max(a,b)
c1=0
while a!=0 and b!=0:
c1=c1+1
a=a-1
b=b-1
print(c1,end=" ")
print(int((c2-c1)/2)) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int MOD = 1e9 + 7;
char str[N];
vector<char> ve;
int main() {
int n;
scanf("%d", &n);
scanf("%s", str + 1);
for (int i = 1; i <= n; i++) {
if (ve.size()) {
if (str[i] == ve[ve.size() - 1] && ((ve.size() + 1) % 2 == 0))
continue;
else
ve.push_back(str[i]);
} else
ve.push_back(str[i]);
}
int m = ve.size();
if (m & 1) m--;
if (m == n && m & 1) m = n - 1;
printf("%d\n", n - m);
for (int i = 0; i < m; i++) printf("%c", ve[i]);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, y1;
int x2, y2;
int a, b, c;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
a = abs(x1 - x2);
b = abs(y1 - y2);
c = max(a, b);
printf("%d\n", c);
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
if (n == 1)
cout << 0 << " " << 1 << endl;
else
cout << "-" << n - 1 << " " << n << endl;
}
return 0;
}
| 7 | CPP |
a = int(input())
for i in range(a):
b=[]
c = int(input())
de = 10
kol = 0
n = 1
while n!=0:
n = int(str(c // int(de ** (len(str(c)) - 1))) + '0' * (len(str(c)) - 1))
c %= de ** (len(str(c)) - 1)
if n!=0:
b.append(n)
print(len(b))
print(*b)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
vector<vector<int> > edges(n);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
edges[a].push_back(b);
}
mt19937 mt(chrono::steady_clock::now().time_since_epoch().count());
for (int _ = 0; _ < 60; _++) {
int st = uniform_int_distribution<int>(0, n - 1)(mt);
vector<int> bfs = {st};
vector<int> vis(n, 0);
int s = 0;
vis[st] = 1;
vector<int> par(n);
vector<int> d(n);
par[st] = st;
d[st] = 0;
while (s < (int)bfs.size()) {
int v = bfs[s];
s++;
for (int w : edges[v]) {
if (vis[w]) continue;
par[w] = v;
d[w] = d[v] + 1;
bfs.push_back(w);
vis[w] = 1;
}
}
if ((int)bfs.size() != n) {
continue;
}
const int MAXJ = 18;
vector<vector<int> > jmp(MAXJ, vector<int>(n));
jmp[0] = par;
for (int j = 1; j < MAXJ; j++) {
for (int i = 0; i < n; i++) {
jmp[j][i] = jmp[j - 1][jmp[j - 1][i]];
}
}
vector<int> count_over(n, 0);
bool fail = false;
vector<int> up_where(n, -1);
for (int v = 0; v < n; v++) {
for (int w : edges[v]) {
if (par[w] == v) continue;
int dv = d[v];
int dw = d[w];
if (dv <= dw) {
fail = true;
} else {
int dist = dv - dw;
int cv = v;
for (int j = 0; j < MAXJ; j++) {
if (dist & (1 << j)) {
cv = jmp[j][cv];
}
}
if (cv != w) {
fail = true;
} else {
count_over[v] += 1;
count_over[w] -= 1;
if (up_where[v] == -1 || d[w] < d[up_where[v]]) {
up_where[v] = w;
}
}
}
}
}
if (fail) {
continue;
}
vector<int> answers;
for (int g = n - 1; g > 0; g--) {
int v = bfs[g];
int p = par[v];
count_over[p] += count_over[v];
if (up_where[v] != -1) {
if (up_where[p] == -1 || d[up_where[v]] < d[up_where[p]]) {
up_where[p] = up_where[v];
}
}
}
vector<int> good(n, 1);
for (int g = 1; g < n; g++) {
int v = bfs[g];
if (count_over[v] != 1 || !good[up_where[v]]) {
good[v] = 0;
}
}
for (int i = 0; i < n; i++) {
if (good[i]) answers.push_back(i);
}
if ((int)answers.size() * 5 < n) {
cout << -1 << '\n';
} else {
for (int a : answers) {
cout << a + 1 << ' ';
}
cout << '\n';
}
return;
}
cout << -1 << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
int T;
cin >> T;
while (T--) solve();
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
const int N = 300009;
const int LOG = 20;
int as(int node, int k, vector<vector<int>> &anc) {
if (k == 0) return node;
for (int i = 0; i < LOG; i++) {
if (k & (1 << i)) {
node = anc[node][i];
}
}
return node;
}
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
}
vector<vector<int>> x(n);
for (int i = 0; i < n; i++) {
x[a[i]].push_back(i);
}
for (int i = 0; i < n; i++) {
sort(x[i].begin(), x[i].end());
}
bool valid = true;
int count = 0;
vector<int> g(n);
vector<int> h;
for (int i = 0; i < n; i++) {
if (x[i].size() != 0 && !binary_search(x[i].begin(), x[i].end(), i)) {
valid = false;
break;
} else if (x[i].size() != 0) {
h.push_back(i);
for (auto c : x[i]) g[c] = count;
count++;
}
}
if (!valid) {
cout << -1 << "\n";
return;
}
cout << h.size() << "\n";
for (int i = 0; i < n; i++) {
cout << g[i] + 1 << " ";
}
cout << "\n";
for (int i = 0; i < h.size(); i++) {
cout << h[i] + 1 << " ";
}
cout << "\n";
}
int main() {
auto start = high_resolution_clock::now();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
for (int i = 0; i < t; i++) {
solve();
}
auto stop = high_resolution_clock::now();
auto duration = duration_cast<milliseconds>(stop - start);
}
| 10 | CPP |
test=int(input())
for i in range(test):
n=int(input())
if(n%2==0):
print((n//2)-1)
else:
print(n//2) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int N;
int coor[3010][2];
int dist[5000010][3];
int i, x, y, c;
bitset<3010> existed[3010];
int QSDist(const void *x, const void *y) {
int *A = (int *)x;
int *B = (int *)y;
if (A[0] > B[0]) return -1;
if (A[0] < B[0]) return 1;
return 0;
}
int ComputeDist(int V1, int V2) {
int dx = coor[V1][0] - coor[V2][0];
int dy = coor[V1][1] - coor[V2][1];
return dx * dx + dy * dy;
}
int Ans() {
for (i = 0; i < c; i++) {
int V1 = dist[i][1];
int V2 = dist[i][2];
if ((existed[V1] & existed[V2]) != 0) return dist[i][0];
existed[V1][V2] = 1;
existed[V2][V1] = 1;
}
return 0;
}
int main() {
scanf("%d", &N);
for (i = 0; i < N; i++)
for (x = 0; x < 2; x++) scanf("%d", &coor[i][x]);
c = 0;
for (i = 0; i < N; i++)
for (x = i + 1; x < N; x++) {
dist[c][0] = ComputeDist(i, x);
dist[c][1] = i;
dist[c][2] = x;
c++;
}
qsort(dist, c, sizeof(dist[0]), QSDist);
printf("%.7lf\n", sqrt((double)Ans()) * 0.5);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,a) for(int i=0;i<(a);i++)
const ll MOD=1000000007;
int A[505][505];
int main(){
int H,W,h,w; cin>>H>>W>>h>>w;
if(H%h==0&&W%w==0){
cout<<"No\n";
return 0;
}
ll a=(1e9-1)/(h*w-1);
rep(i,H) rep(j,W){
if(i%h==h-1&&j%w==w-1) A[i][j]=-(a*(h*w-1)+1);
else A[i][j]=a;
}
cout<<"Yes\n";
rep(i,H){
rep(j,W) cout<<A[i][j]<<" ";
cout<<endl;
}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k;
cin >> k;
string v = "aeiou";
for (long long i = 1; i <= k; i++) {
if (i >= 5 && k % i == 0 && k / i >= 5) {
for (long long j = 0; j < i; j++) {
for (long long l = 0; l < k / i; l++) cout << v[(j + l) % 5];
}
cout << "\n";
return 0;
}
}
cout << -1 << endl;
cout << "\n";
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
mt19937_64 rnd(time(0));
vector<pair<int, int> > v[2][31];
long long n, m, k, d, T, Q, a[600001], pr[600001];
bool tt[600001];
long long binpow(long long h, long long r, long long md = MOD) {
long long l = 1;
while (r) {
if (r & 1) l *= h, l %= md;
h *= h;
h %= md;
r /= 2;
}
return l;
}
long long gcd(int x, int y) {
if (x < y) swap(x, y);
while (x && y) {
x %= y;
swap(x, y);
}
return x + y;
}
long long solve(int h) {
vector<pair<int, int> > v0 = v[0][h], v1 = v[1][h];
long long mx = 0;
for (int i = 1; i <= n; i++) a[i] = 0, tt[i] = 0;
for (int i = 0; i < v1.size(); i++)
a[v1[i].first] = max((long long)v1[i].second, a[v1[i].first]);
long long p = 0;
for (int i = 1; i <= n; i++) {
p = max(p, a[i]);
if (i > p) tt[i] = 1;
}
for (int i = 1; i <= n; i++) a[i] = 0;
for (int i = 0; i < v0.size(); i++) {
a[v0[i].second + 1] = max((long long)v0[i].first, a[v0[i].second + 1]);
mx = max(mx, (long long)v0[i].first);
}
for (int i = 1; i <= n; i++) a[i] = max(a[i], a[i - 1]);
pr[0] = 1;
long long l = 0;
if (mx == 0) l = 1;
for (int i = 1; i <= n; i++) {
if (tt[i]) {
long long o = 0;
if (a[i] == 0)
o = pr[i - 1];
else
o = pr[i - 1] - pr[a[i] - 1];
if (o < 0) o += MOD;
pr[i] = pr[i - 1] + o;
pr[i] %= MOD;
if (i >= mx) l += o, l %= MOD;
} else
pr[i] = pr[i - 1], pr[i] %= MOD;
}
return l;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> m;
for (int i = 1; i <= m; i++) {
long long x, y, z;
cin >> x >> y >> z;
long long j = 0;
while (j < k) {
v[z % 2][j].push_back(make_pair(x, y));
j++;
z /= 2;
}
}
long long ans = 1;
for (int i = 0; i < k; i++) {
ans *= (solve(i));
ans %= MOD;
}
cout << ans << "\n";
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:800000000")
using namespace std;
const long long INF = 2000000000000200;
void Dkst(vector<vector<pair<int, int> > >& g, vector<long long>& dist,
vector<int>& parent, int n, int start) {
dist = vector<long long>(n, INF);
dist[start] = 0;
set<pair<long long, long long> > q;
q.insert(make_pair(dist[start], start));
while (!q.empty()) {
long long v = q.begin()->second;
q.erase(q.begin());
for (size_t j = 0; j < g[v].size(); ++j) {
long long to = g[v][j].first, len = g[v][j].second;
if (dist[v] + len < dist[to]) {
q.erase(make_pair(dist[to], to));
dist[to] = dist[v] + len;
parent[to] = v;
q.insert(make_pair(dist[to], to));
}
}
}
}
struct People {
int sx;
int sy;
int ex;
int ey;
};
void Bfs(vector<vector<int> >& g, vector<bool>& used, vector<int>& dist,
vector<int>& parent, int n, int start) {
queue<int> q;
q.push(start);
used[start] = 1;
q.push(start);
dist[start] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (!used[to]) {
q.push(to);
used[to] = 1;
parent[to] = v;
dist[to] = dist[v] + 1;
}
}
}
}
void Dfs(vector<vector<int> >& g, vector<vector<int> >& g2, string* a,
string* obr, vector<bool>& used, vector<int>& parent, int n, int start,
int obk, bool& da, int k = 0) {
if (da) {
return;
}
if (k % 2 == 0) {
for (size_t i = 0; i < g[start].size(); i++) {
int per = g[start][i];
if (a[per] == obr[k]) {
if (!used[per]) {
used[per] = 1;
parent[per] = start;
if (k == obk) {
return;
}
Dfs(g, g2, a, obr, used, parent, n, per, obk, da, k + 1);
parent[per] = -1;
used[per] = 0;
}
}
}
} else {
for (size_t i = 0; i < g2[start].size(); i++) {
int per = g2[start][i];
if (a[per] == obr[k]) {
if (!used[per]) {
used[per] = 1;
parent[per] = start;
if (k == obk) {
return;
}
Dfs(g, g2, a, obr, used, parent, n, per, obk, da, k + 1);
parent[per] = -1;
used[per] = 0;
}
}
}
}
}
void Dfs(int n, int first, vector<vector<int> >& g, vector<bool>& used,
vector<int>& parent) {
used[first] = 1;
for (int i = 0; i < g[first].size(); i++) {
int s = g[first][i];
if (!used[s]) {
parent[s] = first;
Dfs(n, s, g, used, parent);
}
}
}
void Dfs4(int n, int first, vector<vector<int> >& g, vector<bool>& used,
vector<int>& parent) {
used[first] = 1;
for (int i = 0; i < g[first].size(); i++) {
int s = g[first][i];
if (!used[s]) {
parent[s] = first;
Dfs4(n, s, g, used, parent);
}
}
}
void Dfs2(int n, int first, vector<vector<int> >& g, vector<int>& used,
vector<int>& parent) {
used[first] = 1;
stack<int> v;
v.push(first);
while (!v.empty()) {
int f = v.top();
if (g[f].size() > used[f]) {
v.push(g[f][used[f]]);
used[f]++;
} else {
v.pop();
}
}
}
void Dfs3(int n, int first, vector<vector<int> >& g, vector<int>& used,
vector<int>& parent) {
used[first] = 1;
stack<int> v;
v.push(first);
while (!v.empty()) {
int f = v.top();
if (g[f].size() > 0) {
for (int i = 0; i < g[f].size(); i++) {
v.push(g[f][i]);
}
used[f] = 1;
} else {
v.pop();
}
}
}
void peres(int& a, int& b, int a1, int b1, int a2, int b2) {
if (a1 > b2) {
a = -1;
b = -1;
return;
}
if (a1 > a2) {
int a = a1;
int b = min(b1, b2);
return;
}
if (a2 > b1) {
a = -1;
b = -1;
return;
}
if (a2 > a1) {
int a = a2;
int b = min(b1, b2);
return;
}
}
int ceil(int a, int b) {
if (a % b == 0) {
return a / b;
}
return a / b + 1;
}
int binSearchMax(vector<int> a, int b) {
int i = ceil(a.size(), 2);
int mx = -1;
int mn = -1;
int pr = ceil(i, 2);
if (a.size() < 2) {
if (a.size() > 0) {
if (b <= a[0]) {
return 0;
} else {
return -1;
}
} else {
return -1;
}
}
int da = 0;
while (da < 2) {
if (pr <= 1) {
da++;
}
if (a[i] == b) {
mn = i;
return mn;
} else if (a[i] > b) {
mx = i;
i = max(i - pr, 0);
} else {
mn = i;
int cn = a.size() - 1;
i = min(i + pr, cn);
}
pr = ceil(pr, 2);
}
if (mn != -1) {
if (a[mn] == b) {
return mn;
}
}
return mx;
}
int binSearchMin(vector<int> a, int b) {
int i = ceil(a.size(), 2);
int mx = -1;
int mn = -1;
int pr = i;
if (a.size() < 2) {
if (a.size() > 0) {
if (b >= a[0]) {
return 0;
} else {
return -1;
}
} else {
return -1;
}
}
int da = 0;
while (da < 2) {
if (pr <= 1) {
da++;
}
if (a[i] == b) {
return i;
} else if (a[i] > b) {
mx = i;
i = max(i - pr, 0);
} else {
mn = i;
int cn = a.size() - 1;
i = min(i + pr, cn);
}
pr = ceil(pr, 2);
}
if (mx > -1) {
if (a[mx] == b) {
return mx;
}
}
return mn;
}
void obrez(vector<int>& ans, int a, int b) {
if (a == b) {
ans.clear();
ans.push_back(a);
} else if (a < b) {
int gr1 = binSearchMin(ans, a);
if (gr1 >= 0) {
if (ans[gr1] == a) {
gr1--;
}
}
for (int i = 0; i <= gr1; i++) {
ans.erase(ans.begin());
}
int gr2 = binSearchMax(ans, b) - gr1 - 1;
if (gr2 > 0) {
if (ans[gr2] == b) {
gr2++;
}
int ansize = ans.size();
for (int i = gr2; i < ansize; i++) {
ans.erase(ans.begin() + gr2);
}
}
} else {
int gr1 = binSearchMax(ans, b);
int gr2 = binSearchMin(ans, a);
if (gr1 >= 0) {
if (ans[gr1] == b) {
gr1++;
}
}
if (gr2 >= 0) {
if (ans[gr2] == a) {
gr2--;
}
}
for (int i = gr1; i <= gr2; i++) {
ans.erase(ans.begin() + gr1);
}
}
}
bool check;
void Dfs32(int n, int anssize, int first, int& gran, set<int>& ans,
vector<int>& num, vector<vector<int> >& g, vector<int>& used,
vector<int>& parent) {
used[first] = 1;
stack<int> v;
v.push(first);
while (!v.empty()) {
int f = v.top();
v.pop();
if (g[f].size() > 0) {
bool ka = 0;
for (int i = 0; i < g[f].size(); i++) {
int shakal1 = -4;
int shakal2 = -4;
int shakal = 0;
if (ans.size() > 0) {
shakal = 1;
}
int s = g[f][i];
parent[s] = f;
if (num[s] == -1) {
if (used[s] == 0) {
ka = 1;
used[s] = 1;
v.push(s);
} else if (used[s] == 2) {
used[f] = 2;
int f1 = gran;
int s1 = num[first];
if (f1 != -1) {
if (f1 <= s1) {
set<int>::iterator ff1 = ans.lower_bound(f1);
set<int>::iterator ss1 = ans.upper_bound(s1);
ans.erase(ans.begin(), ff1);
ans.erase(ss1, ans.end());
if (check && ans.size() < 6) {
}
} else {
set<int>::iterator ff1 = ans.lower_bound(f1);
set<int>::iterator ss1 = ans.upper_bound(s1);
ans.erase(ss1, ff1);
if (check && ans.size() < 6) {
}
}
if (check) {
}
}
int jwefwe2qwd = 23;
} else {
int ads = 0;
}
} else {
used[f] = 2;
used[s] = 2;
if (gran == -1) {
gran = num[s];
}
int f1 = num[s];
int s1 = num[first];
int sg1;
int sg2;
if (s1 - gran >= 0) {
sg1 = s1 - gran + 1;
} else {
sg1 = s1 - gran + anssize + 1;
}
if (s1 - f1 >= 0) {
sg2 = s1 - f1 + 1;
} else {
sg2 = s1 - f1 + anssize + 1;
}
if (sg2 < sg1) {
gran = f1;
}
if (check) {
}
if (f1 <= s1) {
auto ff1 = ans.lower_bound(f1);
auto ss1 = ans.upper_bound(s1);
ans.erase(ans.begin(), ff1);
ans.erase(ss1, ans.end());
if (check && ans.size() < 6) {
}
} else {
auto ff1 = ans.lower_bound(f1);
auto ss1 = ans.upper_bound(s1);
ans.erase(ss1, ff1);
if (check && ans.size() < 6) {
}
}
if (check && s1 != 1) {
}
int jwefwe = 23;
}
}
used[f] = max(1, used[f]);
if (!ka) {
for (int d = 0; d < g[f].size(); d++) {
if (used[g[f][d]] == 2) {
used[f] = 2;
break;
}
}
}
}
{
for (int d = 0; d < g[f].size(); d++) {
if (used[g[f][d]] == 2) {
used[f] = 2;
break;
}
}
if (!v.empty()) {
}
}
}
}
void Cycle(int n, int first, vector<int>& num, vector<int>& spnum,
vector<vector<int> >& g, vector<int>& used, vector<int>& parent,
bool& da) {
used[first] = 1;
if (da) {
return;
}
for (int i = 0; i < g[first].size(); i++) {
if (da) {
return;
}
int s = g[first][i];
if (used[s] == 0) {
parent[s] = first;
if (da) {
return;
}
Cycle(n, s, num, spnum, g, used, parent, da);
if (da) {
return;
}
} else if (used[s] == 1) {
if (da) {
return;
}
parent[s] = first;
spnum.push_back(s);
num[s] = 1;
int por = 2;
int par = first;
while (num[par] != 1) {
num[par] = por;
spnum.push_back(par);
par = parent[par];
por++;
}
por--;
while (por != 0) {
num[par] = por;
par = parent[par];
por--;
}
da = 1;
return;
}
if (da) {
return;
}
}
if (da) {
return;
}
used[first] = 2;
}
void CycleSearch(int n, int first, vector<int>& num, vector<int>& spnum,
vector<vector<int> >& g, vector<int>& used,
vector<int>& parent, bool& da) {
used[first] = 1;
if (da) {
return;
}
for (int i = 0; i < g[first].size(); i++) {
if (da) {
return;
}
int s = g[first][i];
if (used[s] == 0) {
parent[s] = first;
if (da) {
return;
}
CycleSearch(n, s, num, spnum, g, used, parent, da);
if (da) {
return;
}
} else if (used[s] == 1) {
if (da) {
return;
}
parent[s] = first;
spnum.push_back(s);
num[s] = 1;
int por = 2;
int par = first;
while (num[par] != 1) {
num[par] = por;
spnum.push_back(par);
par = parent[par];
por++;
}
da = 1;
return;
}
if (da) {
return;
}
}
if (da) {
return;
}
used[first] = 2;
}
int main() {
int n, m;
cin >> n;
cin >> m;
int count = 0;
vector<vector<int> > g(n + 1, vector<int>());
vector<vector<int> > g2(n + 1, vector<int>());
vector<int> parent(n, -1);
vector<int> parent1(n, -1);
vector<int> parent2(n, -1);
vector<int> parent228(n, -1);
vector<int> num(n + 1, -1);
check = 0;
for (int i = 0; i < m; i++) {
int f, s;
cin >> f >> s;
f--;
s--;
g[f].push_back(s);
g2[f].push_back(s);
if (i == 0 && n == 1000 && m == 100000) {
if (f == 681 && s == 484) {
check = 1;
}
}
}
stack<int> st;
for (int i = 0; i < n; i++) {
if (g[i].size() == 0) {
st.push(i);
}
}
vector<int> used(n + 1, 0);
vector<int> used1(n + 1, 0);
vector<int> used2(n + 1, 0);
vector<int> spnum;
set<int> ans;
bool da1 = 0;
for (int i = 0; i < n; i++) {
if (used1[i] == 0) {
Cycle(n, i, num, spnum, g, used1, parent1, da1);
}
}
reverse(spnum.rbegin(), spnum.rend());
for (int i = 1; i <= spnum.size(); i++) {
ans.insert(i);
}
int numi = -1;
int numcount = spnum.size();
for (int i = 0; i < spnum.size(); i++) {
numi = num[spnum[i]];
for (int d = 0; d < g[spnum[i]].size(); d++) {
if (num[g[spnum[i]][d]] == numi + 1 ||
(numi == numcount && num[g[spnum[i]][d]] == 1)) {
g[spnum[i]].erase(g[spnum[i]].begin() + d);
}
}
}
if (check) {
for (auto d : ans) {
}
}
int gran = -1;
set<int> ans2;
int ansize = ans.size();
ans2 = ans;
for (auto d : ans2) {
Dfs32(n, ansize, spnum[d - 1], gran, ans, num, g, used, parent);
if (check) {
}
}
if (ans.size() > 0) {
int ans1 = *ans.begin();
int gs = g2[ans1].size();
g2[spnum[ans1 - 1]].clear();
bool da2 = 0;
for (int i = 0; i < n; i++) {
if (n == 100000) {
}
CycleSearch(n, i, num, spnum, g2, used2, parent2, da2);
}
if (da2) {
cout << -1;
} else {
cout << spnum[ans1 - 1] + 1;
}
} else {
cout << -1;
}
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long double epsylon = 1e-9;
const std::string PROGRAM_NAME = "ivo";
long long mod = 1000000000 + 7;
struct matrix {
matrix(const vector<vector<long long> >& a_) {
a = a_;
n = (int)a.size();
if (a_[0].size() != a_.size()) {
wrong_input("The matrix is not square!\n");
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
a[i][j] %= mod;
}
}
}
matrix(const vector<vector<int> >& a_) {
n = (int)a_.size();
a.resize(n);
if (a_[0].size() != a_.size()) {
wrong_input("The matrix is not square!\n");
}
for (int i = 0; i < n; ++i) {
a[i].resize(n);
for (int j = 0; j < n; ++j) {
a[i][j] = a_[i][j] % mod;
}
}
}
matrix& operator+=(const matrix& o) {
if (a.size() != o.a.size()) {
wrong_input("The sizes of the matrices is not the same!\n");
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
a[i][j] = (a[i][j] + o.a[i][j]) % mod;
}
}
return *this;
}
matrix operator+(const matrix& o) {
matrix res = *this;
res += o;
return res;
}
matrix& operator-=(const matrix& o) {
if (a.size() != o.a.size()) {
wrong_input("The sizes of the matrices is not the same!\n");
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
a[i][j] = (a[i][j] - o.a[i][j] + mod) % mod;
}
}
return *this;
}
matrix operator-(const matrix& o) {
matrix res = *this;
res -= o;
return res;
}
matrix& operator*=(const matrix& o) {
if (a.size() != o.a.size()) {
wrong_input("The sizes of the matrices is not the same!\n");
}
vector<vector<long long> > res(n);
for (int i = 0; i < n; ++i) {
res[i].resize(n, 0);
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < n; ++k) {
res[i][j] = (res[i][j] + (a[i][k] * o.a[k][j]) % mod) % mod;
}
}
}
a = res;
return *this;
}
matrix operator*(const matrix& o) {
matrix res = *this;
res *= o;
return res;
}
long long stepen(long long x, long long y) {
long long res = 1;
long long p = x;
while (y) {
if (y % 2) {
res = (res * p) % mod;
}
p = (p * p) % mod;
y /= 2;
}
return res;
}
matrix stepen(long long power) {
matrix res = unary(n);
matrix temp = *this;
while (power) {
if (power % 2LL) {
res *= temp;
}
temp *= temp;
power /= 2LL;
}
return res;
}
void wrong_input(const string& str) { cerr << str; }
static matrix unary(int n) {
vector<vector<long long> > res(n);
for (int i = 0; i < n; ++i) {
res[i].resize(n, 0);
res[i][i] = 1;
}
return matrix(res);
}
public:
int n;
vector<vector<long long> > a;
};
int main() {
int n, l, m;
cin >> n >> l >> m;
vector<long long> cur(m, 0), mid(m, 0), last(n, 0);
for (int i = 0; i < n; ++i) {
int temp;
scanf("%d", &temp);
cur[temp % m] += 1;
}
for (int i = 0; i < n; ++i) {
int temp;
scanf("%d", &temp);
mid[temp % m] += 1;
last[i] = temp;
}
for (int i = 0; i < n; ++i) {
int temp;
scanf("%d", &temp);
last[i] = (last[i] + temp) % m;
}
vector<vector<int> > ma(m, vector<int>(m, 0));
for (int i = 0; i < m; ++i) {
for (int j = 0; j < m; ++j) {
ma[i][j] = mid[(j - i + m) % m];
}
}
matrix a(ma);
matrix s = a.stepen(l - 2);
vector<int> nxt(m, 0);
for (int i = 0; i < m; ++i) {
for (int j = 0; j < m; ++j) {
nxt[i] = (int)((nxt[i] + (cur[j] * s.a[j][i]) % mod) % mod);
}
}
for (int i = 0; i < m; ++i) {
cur[i] = nxt[i];
}
long long answer = 0;
for (int i = 0; i < n; ++i) {
int other = (m - last[i]) % m;
answer = (answer + cur[other]) % mod;
}
cout << answer << endl;
return 0;
}
| 8 | CPP |
a = (input().lower())
b = (input().lower())
if a == b:
print(0)
elif a > b:
print(1)
else:
print(-1) | 7 | PYTHON3 |
s=[int(n) for n in input().split()]
j=0
for n in s:
if s.count(n)>=4:
j=n
break
if j==0:
print('Alien')
else:
s.sort()
del s[s.index(j):s.index(j)+4]
if s[0]==s[1]:
print('Elephant')
else:
print('Bear') | 7 | PYTHON3 |
#include<iostream>
int main(){
int n;
std::cin >> n;
int cnt = 0;
for(int i = 1; i <= n; i++){
int S;
std::cin >> S;
for(int j = 1; 2 * j * j <= S; j++){
if((S - j) % (2 * j + 1) == 0){
cnt++;
break;
}
}
}
std::cout << n - cnt << std::endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
int main(){
int H,W;
cin >> H >> W;
string S[H];
rep(i,H){
cin >> S[i];
}
int a[H][W];
rep(i,H)rep(j,W){
a[i][j]=-1;
}
int dh[4]={0,1,0,-1};
int dw[4]={1,0,-1,0};
int cnt=0;
ll ans=0;
queue<pii> q;
rep(i,H)rep(j,W){
if(a[i][j]==-1){
ll w=0;
ll b=0;
q.push(pii(i,j));
cnt++;
a[i][j]=cnt;
while(!q.empty()){
pii n=q.front();
q.pop();
if(S[n.first][n.second]=='#') b++;
else w++;
rep(k,4){
int nh=n.first+dh[k];
int nw=n.second+dw[k];
if(nh>=0 and nh<H and nw>=0 and nw<W){
if(S[n.first][n.second]!=S[nh][nw] and a[nh][nw]==-1){
q.push(pii(nh,nw));
a[nh][nw]=cnt;
}
}
}
}
ans+=b*w;
}
}
cout << ans << endl;
return 0;
}
| 0 | CPP |
n = int(input())
def f(n):
x = 'that I love '
y = 'that I hate '
z = 'it'
out = 'I hate '
for i in range(1, n):
if i%2 == 0:
out += y
else:
out+= x
out += z
return out
print(f(n))
| 7 | PYTHON3 |
try:
l=[x for x in input()]
l=set(l)
if len(l)%2==0:
print("CHAT WITH HER!")
else:
print("IGNORE HIM!")
except:
pass
| 7 | PYTHON3 |
n=int(input())
c=0
for i in range(1,n):
m=n-i
if(m%i==0):
c+=1
print(c) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int t, n, A[200005], m, an, ans, l, r, mid, fo, cnt;
int main() {
scanf("%d", &t);
for (int x = 1; x <= t; x++) {
scanf("%d %d", &n, &m), an = 1e9, m++;
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
sort(A + 1, A + n + 1);
for (int i = m; i <= n; i++) {
fo = (A[i] - A[i - m + 1] + 1) >> 1, l = (A[i] + A[i - m + 1]) >> 1;
if (fo < an) an = fo, ans = l;
}
printf("%d\n", ans);
}
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[205], b[205], c[205];
int main() {
int n, k;
while (~scanf("%d%d", &n, &k)) {
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < k; i++) scanf("%d", &b[i]);
sort(b, b + k);
int len = 0;
for (int i = n - 1; i >= 0; i--) {
if (a[i] == 0) {
a[i] = b[len++];
}
c[i] = a[i];
}
int flag = 0;
sort(c, c + n);
for (int i = 0; i < n; i++) {
if (a[i] == c[i]) flag++;
}
if (flag == n) {
printf("No\n");
} else {
printf("Yes\n");
}
}
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1003;
int n, A[N], dp[N][N];
int Solve(int id, int pr) {
if (dp[id][pr]) return (dp[id][pr]);
if (id >= n) return (dp[id][pr] = max(A[id], A[pr]));
dp[id][pr] = min({max(A[id], A[pr]) + Solve(id + 2, id + 1),
max(A[id], A[id + 1]) + Solve(id + 2, pr),
max(A[pr], A[id + 1]) + Solve(id + 2, id)});
return (dp[id][pr]);
}
void Prnt(int id, int pr) {
if (id == n) {
printf("%d %d\n", pr, id);
return;
}
if (id > n) {
printf("%d\n", pr);
return;
}
if (dp[id][pr] == max(A[id], A[pr]) + dp[id + 2][id + 1]) {
printf("%d %d\n", pr, id);
Prnt(id + 2, id + 1);
return;
}
if (dp[id][pr] == max(A[id], A[id + 1]) + dp[id + 2][pr]) {
printf("%d %d\n", id, id + 1);
Prnt(id + 2, pr);
return;
}
printf("%d %d\n", pr, id + 1);
Prnt(id + 2, id);
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
memset(dp, 0, sizeof(dp));
printf("%d\n", Solve(2, 1));
Prnt(2, 1);
return (0);
}
| 10 | CPP |
n = int(input())
s = list(input())
i = 0
rep = {
('B','R') : 'G',
('R','B') : 'G',
('G','R') : 'B',
('R','G') : 'B',
('B','G') : 'R',
('G','B') : 'R',
('R','R') : 'B',
('B','B') : 'R',
('G','G') : 'R'
}
count=0
while i<n-2:
if s[i] == s[i+1]:
count+=1
s[i+1] = rep[ (s[i],s[i+2]) ]
i+=1
if n > 1 and s[-1] == s[-2]:
if s[-2] == 'R': s[-1] = 'G'
elif s[-2] == 'G': s[-1] = 'B'
else: s[-1] = 'R'
count+=1
print(count)
print("".join(s)) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const long long INFL = 2e18;
const int N = 1e5, LOG = 35;
const long long K = 1e10;
int n;
long long k;
int m[N + 5][LOG + 5], p[N + 5][LOG + 5];
long long s[N + 5][LOG + 5];
void qr(int u, long long k) {
int Min = 1e9;
long long S = 0;
for (int i = (LOG), _b = (0); i >= _b; --i)
if ((k - (1LL << i)) >= 0) {
k -= (1LL << i);
S += s[u][i];
Min = min(Min, m[u][i]);
u = p[u][i];
}
cout << S << ' ' << Min << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
for (int i = (1), _b = (n); i <= _b; ++i) {
int tmp;
cin >> tmp;
p[i][0] = tmp + 1;
}
for (int i = (1), _b = (n); i <= _b; ++i) {
int tmp;
cin >> tmp;
m[i][0] = s[i][0] = tmp;
}
for (int j = (1), _b = (LOG); j <= _b; ++j)
for (int i = (1), _b = (n); i <= _b; ++i) {
p[i][j] = p[p[i][j - 1]][j - 1];
s[i][j] = s[i][j - 1] + s[p[i][j - 1]][j - 1];
m[i][j] = min(m[i][j - 1], m[p[i][j - 1]][j - 1]);
}
for (int i = (1), _b = (n); i <= _b; ++i) qr(i, k);
return 0;
}
| 11 | CPP |
# Code Forces 71A - Way too long words
n = int(input())
s = [input() for x in range(n)]
ans = []
for x in s:
if len(x) > 10:
ans.append(x[0] + str(len(x)-2) + x[-1])
else:
ans.append(x)
for x in ans:
print(x)
| 7 | PYTHON3 |
t=int(input())
while t>0:
t-=1
#a,b=map(int,input().split())
n=int(input())
l=list(map(int,input().split()))
l.sort()
dic={}
for i in l:
if i in dic.keys():
dic[i]+=1
else:
dic[i]=1
party=1
spare=0
#print(dic)
for k,v in dic.items():
#print(k,v)
if party+v-1 + spare>=k:
party=party+v+spare
spare=0
else:
spare+=v
print(party)
| 8 | PYTHON3 |
def main():
a = sorted(input(), reverse=True)
b = int(input())
k = ""
while len(a) > 0:
for i in range(len(a)):
num = k + a[i] + "".join(sorted(a[:i] + a[i + 1:]))
if int(num) <= b:
k += a[i]
a = a[:i] + a[i + 1:]
break
print(k)
if __name__ == "__main__":
main()
| 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int64_t N = 1e6 + 7;
int64_t q, n, k;
string s;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
cin >> q;
while (q--) {
cin >> n >> k;
cin >> s;
map<int64_t, int64_t> zero;
int64_t cpos = 0;
for (int64_t i = 0; i < n; i++) {
if (s[i] == '1') continue;
int64_t req = i - cpos;
if (k >= req)
zero[cpos] = 1, cpos++, k -= req;
else
zero[i - k] = 1, k = 0;
}
for (int64_t i = 0; i < n; i++) {
if (zero[i])
cout << '0';
else
cout << '1';
}
cout << "\n";
}
return 0;
}
| 10 | CPP |
n, t = map(int, input().split())
z = input()
s = []
for i in range(n):
s.append(z[i])
j = 0
for i in range(t):
while j < n - 1:
if s[j] == 'B' and s[j + 1] == 'G':
s[j], s[j + 1] = s[j + 1], s[j]
j += 1
j += 1
j = 0
print(''.join(s)) | 8 | PYTHON3 |
#include <bits/stdc++.h>
namespace competitive_programming {
inline namespace utility {}
namespace debugging {}
namespace io {}
} // namespace competitive_programming
namespace competitive_programming::utility {
class timer {
private:
std::chrono::time_point<std::chrono::steady_clock> begin, end;
public:
timer() : begin(), end() {}
~timer() {}
};
} // namespace competitive_programming::utility
constexpr bool test_cases = true;
auto solve() -> void {
int64_t n, m;
std::cin >> n >> m;
std::vector<std::string> v(n);
for (int i = 0; i < n; ++i) {
std::cin >> v[i];
}
int64_t k = (1ULL << m) - n;
int64_t pos = (k - 1) / 2;
int64_t low = 0, high = (1ULL << m) - 1;
while (low < high) {
int64_t mid = (low + high) / 2, copy = mid;
std::string bin;
while (copy) {
bin += char(copy % 2) + '0';
copy /= 2;
}
while ((int)bin.size() < m) bin += '0';
std::reverse(begin(bin), end(bin));
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (v[i] <= bin) ++cnt;
}
if (mid < pos + cnt)
low = mid + 1;
else
high = mid;
}
std::string bin;
while (low) {
bin += char(low % 2) + '0';
low /= 2;
}
while ((int)bin.size() < m) bin += '0';
std::reverse(begin(bin), end(bin));
std::cout << bin << '\n';
}
auto main() -> int32_t {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.precision(10);
std::cerr.precision(10);
std::cout << std::fixed << std::boolalpha;
std::cerr << std::fixed << std::boolalpha;
competitive_programming::timer t;
int32_t cases = 1;
if (test_cases) std::cin >> cases;
while (cases--) solve();
return 0;
}
| 14 | CPP |
#IQ test 25A
x=input()
y=input().split()
y=[int(p) for p in y]
a=y[0]%2
l=[]
for i in y:
l.append(i%2)
#print(l)
if l.count(0)>1:
x=l.index(1)+1
print(x)
else:
x=l.index(0)+1
print(x) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
void solve() {
int l, w;
cin >> l >> w;
vector<int> a(l);
vector<int> s(l, 0);
int ans = 1e9;
for (int i = 1; i < l; i++) {
cin >> a[i];
}
for (int i = 1; i < l; i++) {
s[i] = s[i - 1] + a[i];
}
for (int i = w; i < l; i++) {
ans = min(ans, s[i] - s[i - w]);
}
cout << (ans) << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 10 | CPP |
a = input()
a, b, c = a.split()
print(c, a, b)
| 0 | PYTHON3 |
n=input()
up=0
lo=0
for i in n:
if(i>="A" and i<="Z"):
up+=1
else:
lo+=1
if(up>lo):
print(n.upper())
else:
print(n.lower()) | 7 | PYTHON3 |
a = int(input())
b = int(a/2)
c = a/2
if c > b or a == 2 :
print("NO")
else:
print("YES") | 7 | PYTHON3 |
#include<bits/stdc++.h>
using namespace std;
set<string> st;
int n,k;
int flag[10];
string v[10];
void dfs(int maisu,string s){
if(maisu==k){
st.insert(s);
return;
}
for(int i=0;i<n;i++){
if(flag[i]==0){
flag[i]=1;
dfs(maisu+1,s+v[i]);
flag[i]=0;
}
}
return;
}
int main(){
while(1){
cin>>n>>k;
if(n==0 && k==0) break;
for(int i=0;i<n;i++){
cin>>v[i];
flag[i]=0;
}
st.clear();
dfs(0,"");
cout<<st.size()<<endl;
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define F(i,a,b) for(int i=a;i<=b;++i)
#define R(i,a,b) for(int i=a;i<b;++i)
#define mem(a,b) memset(a,b,sizeof(a))
int n, k;
int a[100100], b[100100];
ll ans, ret;
int c;
int main()
{
cin >> n >> k;
F(i, 1, n) scanf("%d %d", a + i, b + i);
ans = 0;
F(i, 1, n)
{
if ((a[i] | k) == k) ans += b[i];
}
F(i, 0, 30)if ((1 << i)&k)
{
c = (k - (1 << i)) | ((1 << i) - 1);
ll ret = 0;
F(j, 1, n) if ((c | a[j]) == c) ret += b[j];
ans = max(ans, ret);
}
cout << ans << endl;
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101;
int n, a[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
if (n % 2 == 0) {
for (int i = 1; i <= n; i += 2) printf("%d ", a[i]);
for (int i = n; i >= 1; i -= 2) printf("%d ", a[i]);
} else {
for (int i = 1; i <= n; i += 2) printf("%d ", a[i]);
for (int i = n - 1; i >= 1; i -= 2) printf("%d ", a[i]);
}
return 0;
}
| 9 | CPP |
import os
import sys
from io import BytesIO, IOBase
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline()
# ------------------------------
def RL(): return map(int, sys.stdin.readline().split())
def RLL(): return list(map(int, sys.stdin.readline().split()))
def N(): return int(input())
def print_list(l):
print(' '.join(map(str,l)))
# sys.setrecursionlimit(100000)
# import random
# from functools import reduce
# from functools import lru_cache
# from heapq import *
from collections import deque as dq
# from math import ceil,floor,sqrt,pow,gcd,log
# import math
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
for _ in range(N()):
n = N()
a = RLL()
aa = set(a)
b = [i for i in range(1, 2*n+1) if i not in aa]
l = 0
bb = dq(b)
for v in a:
if bb[0] > v:
bb.pop()
l += 1
else:
bb.popleft()
r = 0
bb = dq(b)
for v in a[::-1]:
if bb[-1] < v:
bb.popleft()
r += 1
else:
bb.pop()
r = n - r
print(r - l + 1)
| 10 | PYTHON3 |
n=int(input())
a=[int(x) for x in input().split()]
dic={}
maxim=0
for item in a:
if item not in dic:
dic[item]=1
else:
dic[item]+=1
for item in dic:
if dic[item]>maxim:
maxim=dic[item]
Item=item
k=0
flag=False
answer=[]
for item in a:
if item==Item:
for i in range(k-1,-1,-1):
if k!=0 and a[i]>a[i+1]:
flag=True
answer.append([2,i+1,i+2])
a[i]=a[i+1]
elif k!=0 and a[i]<a[i+1]:
flag=True
answer.append([1,i+1,i+2])
a[i]=a[i+1]
for i in range(k+1,n):
if a[i]>a[i-1]:
flag=True
answer.append([2,i+1,i])
a[i]=a[i-1]
elif a[i]<a[i-1]:
flag=True
answer.append([1,i+1,i])
a[i]=a[i-1]
break
k+=1
if flag==False:
print(0)
else:
print(len(answer))
for i in answer:
print(*i)
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2, t;
cin >> s1 >> s2 >> t;
int cnt1[100] = {}, cnt2[100] = {};
for (int i = 0; i < s1.size(); i++) {
cnt1[s1[i]]++;
}
for (int i = 0; i < s2.size(); i++) {
cnt1[s2[i]]++;
}
for (int i = 0; i < t.size(); i++) {
cnt2[t[i]]++;
}
for (int i = 65; i <= 90; i++) {
if (cnt1[i] != cnt2[i]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 7 | CPP |
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
typedef vector<int> vec;
typedef vector<vector<int>> mat;
int n, m, a, b, c, t;
mat mul(const mat& A, const mat& B) {
mat C(A.size(), vec(B[0].size(), 0));
for(int i = 0; i < (int)A.size(); ++i) {
for(int k = 0; k < (int)B.size(); ++k) {
for(int j = 0; j < (int)B[0].size(); ++j) {
C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % m;
}
}
}
return C;
}
mat pow(mat A, long long n) {
mat B(A.size(), vec(A.size(), 0));
for(int i = 0; i < (int)A.size(); ++i) {
B[i][i] = 1;
}
while(n > 0) {
if(n & 1) B = mul(B, A);
A = mul(A, A);
n >>= 1;
}
return B;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while(cin >> n >> m >> a >> b >> c >> t && n) {
vec s(n);
for(int i = 0; i < n; ++i) {
cin >> s[i];
}
mat matrix(n, vec(n, 0));
for(int i = 0; i < n; ++i) {
if(i) matrix[i - 1][i] = a;
matrix[i][i] = b;
if(i < n - 1) matrix[i + 1][i] = c;
}
matrix = pow(move(matrix), t);
vector<int> ans(n, 0);
for(int i = 0; i < n; ++i) {
for(int j = 0; j < n; ++j) {
ans[j] += s[i] * matrix[i][j];
ans[j] %= m;
}
}
for(int i = 0; i < n; ++i) {
cout << ans[i] << (i == n - 1 ? "\n" : " ");
}
}
return EXIT_SUCCESS;
} | 0 | CPP |
"""
Template written to be used by Python Programmers.
Use at your own risk!!!!
Owned by enraged(rating - 5 star at CodeChef and Specialist at Codeforces).
"""
import sys
import heapq
from math import ceil, floor, gcd, fabs, factorial, fmod
from collections import defaultdict as dd, deque, Counter as c
from itertools import combinations as comb
from bisect import bisect_left as bl, bisect_right as br, bisect
# sys.setrecursionlimit(2*pow(10, 6))
# sys.stdin = open("input.txt", "r")
# sys.stdout = open("output.txt", "w")
mod = pow(10, 9) + 7
mod2 = 998244353
def data(): return sys.stdin.readline().strip()
def out(var): sys.stdout.write(var)
def l(): return list(map(int, data().split()))
def sl(): return list(map(str, data().split()))
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [[val for i in range(n)] for j in range(m)]
p, d = ssp()
d = int(d)
temp = int(p)
k = int(p)
i = 1
while i <= len(p):
if p[-i] != '9':
k = k-(int(p[-i])+1)*pow(10, i-1)
if temp-k <= d:
p = str(k)
else:
break
i += 1
out(str(p))
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[1000100];
long long brr[1000100];
void solve() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> brr[i];
}
for (long long i = 1; i <= n; i++) {
cin >> arr[i];
}
long long sum = arr[1];
long long add = 0;
long long del = sum;
for (long long i = 2; i <= n; i++) {
if (brr[i] > sum + arr[i]) {
cout << "NO" << endl;
return;
}
long long k = sum - brr[i];
if (k > 0) {
add += (del - max(0ll, del - k));
del = max(0ll, del - k);
}
sum = min(arr[i], sum + arr[i] - brr[i]);
del = min(del, sum);
}
if (sum + add >= brr[1]) {
cout << "YES" << endl;
return;
} else {
cout << "NO" << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 12 | CPP |
class SegmentTree():
def __init__(self, n, mapping, id):
self.n = n
self.id = id
self.log = (n - 1).bit_length()
self.size = 1 << self.log
self.data = [self.id] * (2 * self.size)
self.mapping = mapping
def get(self, p):
#assert 0 <= p < self.n
res = self.id
p += self.size
for _ in range(self.log+1):
res = self.mapping(res, self.data[p])
p >>= 1
return res
def set(self, p, x):
#assert 0 <= p < self.n
p += self.size
self.data[p] = x
def range_set(self, l, r, x):
#assert 0 <= l <= r <= self.n
l += self.size
r += self.size
while l < r:
if l & 1:
self.data[l] = self.mapping(self.data[l], x)
l += 1
if r & 1:
r -= 1
self.data[r] = self.mapping(self.data[r], x)
l >>= 1
r >>= 1
import sys
input = sys.stdin.readline
N, M = map(int, input().split())
id = 10**18
lst = SegmentTree(N,min,id)
lst.set(0,0)
A = [list(map(int, input().split())) for _ in range(M)]
A.sort(key=lambda x:(x[0],x[1]))
for l,r,c in A:
lst.range_set(l-1,r,lst.get(l-1)+c)
ans = lst.get(N-1)
print(ans if ans<id else -1) | 0 | PYTHON3 |
def die_roll(y, w):
d = 6 - max(y, w) + 1
if d == 6:
resp = "1/1"
elif d == 3:
resp = "1/2"
elif d % 2 == 0:
resp = str(d // 2) + "/3"
else:
resp = str(d) + "/6"
return resp
y, w = list(map(int, input().strip().split()))
print(die_roll(y, w)) | 7 | PYTHON3 |
n=int(input())
for i in range(n):
a=int(input())
if a==0:
print(4)
elif a==1:
print(3)
elif a==2:
print(2)
elif a%2==1:
print(1)
else:
print(0) | 7 | PYTHON3 |
n, b = map(int, input().split())
a = list(map(int, input().split()))
r = []
eo = [0, 0]
for i in range(len(a)):
if eo[0] == eo[1] and eo[0] != 0:
r.append(abs(a[i - 1] - a[i]))
eo = [0, 0]
eo[a[i] % 2] += 1
r.sort()
r.append(b + 1)
i = 0
while b >= 0:
b -= r[i]
i += 1
print(i - 1) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int up[N], dw[N], x = 1, y = 1;
long long su[N], sd[N];
char s[N];
int main() {
long long n, i, j, ind, u, v, siu, sid;
cin >> n;
scanf("%s", s);
for (i = 1; i <= n; ++i) {
if (s[i - 1] == 'U')
up[x] = i, su[x] = su[x - 1] + i, ++x;
else
dw[y] = i, sd[y] = sd[y - 1] + i, ++y;
}
dw[y] = n + 1;
sd[y] = sd[y - 1] + n + 1;
++y;
long long ret;
for (i = 1; i <= n; ++i) {
u = lower_bound(up + 1, up + x, i) - up;
--u;
v = lower_bound(dw + 1, dw + y, i) - dw;
if (s[i - 1] == 'U') {
siu = u + 1;
sid = y - v;
if (siu >= sid) {
if (sid == 1)
ret = n + 1 - i;
else {
ret = sd[y - 1] - sd[v - 1];
ret -= sid * i;
ret += (sid - 1) * i;
ret -= su[u] - su[u - sid + 1];
ret *= 2;
ret -= n + 1 - i;
}
} else {
ret = sd[v + siu - 1] - sd[v - 1];
ret -= siu * i;
ret -= su[u];
ret += siu * i;
ret *= 2;
ret -= i;
}
} else {
++v;
siu = u + 1;
sid = y - v;
if (siu <= sid) {
if (siu == 1)
ret = i;
else {
ret = sd[v + siu - 2] - sd[v - 1];
ret -= i * (siu - 1);
ret -= su[u];
ret += siu * i;
ret *= 2;
ret -= i;
}
} else {
ret = sd[y - 1] - sd[v - 1];
ret -= sid * i;
ret -= su[u] - su[u - sid];
ret += sid * i;
ret *= 2;
ret -= n + 1 - i;
}
}
printf("%I64d\n", ret);
}
}
| 11 | CPP |
#include<bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef long double louble;
template<typename T1,typename T2> inline T1 max(T1 a,T2 b){return a<b?b:a;}
template<typename T1,typename T2> inline T1 min(T1 a,T2 b){return a<b?a:b;}
namespace ae86
{
const int bufl = 1<<15;
char buf[bufl],*s=buf,*t=buf;
inline int fetch()
{
if(s==t){t=(s=buf)+fread(buf,1,bufl,stdin);if(s==t)return EOF;}
return *s++;
}
inline int ty()
{
int a=0,b=1,c=fetch();
while(!isdigit(c))b^=c=='-',c=fetch();
while(isdigit(c))a=a*10+c-48,c=fetch();
return b?a:-a;
}
}
using ae86::ty;
const int _ = 153;
int mo;
template<typename T1,typename T2> inline T1 ad(T1 &a,T2 b){return a=a+b>=mo?a+b-mo:a+b;}
template<typename T1,typename T2> inline T1 dl(T1 &a,T2 b){return a=a>=b?a-b:a-b+mo;}
int n,tran;
namespace whentraniseven
{
lint f[_][_];
int main()
{
memset(f,0,sizeof(f)),f[0][0]=1;
int lim=tran/2,len=(n+1)/2;
for(int i=1;i<=len;i++)
{
for(int j=0;j<=lim;j++)ad(f[i][0],f[i-1][j]);
for(int j=1;j<=lim;j++)ad(f[i][j],f[i-1][j-1]);
}
lint anse=0,anso=0;
for(int i=0;i<=lim;i++)ad(anse,f[n/2][i]);
for(int i=0;i<=lim;i++)ad(anso,f[(n+1)/2][i]);
printf("%lld\n",anse*anso%mo);
return 0;
}
}
namespace whentranisodd
{
lint f[_][_][_];
int main()
{
memset(f,0,sizeof(f)),f[0][0][0]=1;
int lim=tran+1;
for(int i=1;i+i-tran<=n;i++)
for(int j=0;j<=n;j++)
for(int k=0;k<=lim;k++)
{
if(!f[i-1][j][k])continue;
lint x=f[i-1][j][k];
ad(f[i][0][0],x);
if(i+i<=n)ad(f[i][j+1][0],x);
if(i+i-tran>=1)ad(f[i][0][k==0?0:k+1],x);
if(i+i<=n && i+i-tran>=1)ad(f[i][j+1][max(j+2,k+1)],x);
}
lint ans=0;
for(int i=0;i<=n;i++)
for(int j=0;j<=lim;j++)
ad(ans,f[(n+tran)/2][i][j]);
printf("%lld\n",ans);
return 0;
}
}
int main()
{
n=ty(),tran=ty(),mo=ty();
if(tran%2==0)return whentraniseven::main();
return whentranisodd::main();
}
| 0 | CPP |
#include<cstdio>
#include<algorithm>
int main(){
int n,a[100];
scanf("%d",&n);
for(int i=0;i<n;i++)scanf("%d",&a[i]);
std::sort(a,a+n);
printf("%d",a[n-1]-a[0]);
return 0;
} | 0 | CPP |
def isLeep(year):
if year % 400 == 0:
return 1;
else:
if year % 4 == 0 and year % 100 != 0:
return 1;
return 0;
def cmp(y1, m1, d1, y2, m2, d2):
if y1 > y2:
return 0;
else:
if y1 == y2 and m1 > m2:
return 0;
else:
if y1 == y2 and m1 == m2 and d1 > d2:
return 0;
return 1;
y1, m1, d1 = map(int, input().split(':'))
y2, m2, d2 = map(int, input().split(':'))
days = [31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
if cmp(y1, m1, d1, y2, m2, d2) == 0:
t = y1; y1 = y2; y2 = t;
t = m1; m1 = m2; m2 = t;
t = d1; d1 = d2; d2 = t;
res = 0;
while True:
res = res + 1;
if y1 == y2 and m1 == m2 and d1 == d2:
break;
d1 = d1 + 1;
if d1 <= days[m1]:
continue;
else:
if d1 == 29:
if isLeep(y1):
continue;
else:
m1 = 3;
d1 = 1;
else:
if d1 == 30:
m1 = 3;
d1 = 1;
else:
if d1 == 31:
m1 = m1 + 1;
d1 = 1;
else:
if d1 == 32:
if m1 == 12:
y1 = y1 + 1;
m1 = 1;
d1 = 1;
else:
m1 = m1 + 1;
d1 = 1;
print (res - 1)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int a[N], n;
int dp[N][2];
int solve(int idx, int player) {
if (idx >= n) return 0;
if (dp[idx][player] != -1) return dp[idx][player];
int op1 = solve(idx + 1, 1 - player) + (player * a[idx]);
int op2 = solve(idx + 2, 1 - player) + ((player) * (a[idx] + a[idx + 1]));
return dp[idx][player] = min(op1, op2);
}
int main() {
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
memset(dp, -1, sizeof(dp));
cout << solve(0, 1) << endl;
}
return 0;
}
| 9 | CPP |
N=input()
n=int(N)
if n>=0:
print(n)
else:
a=N[:-1]
b=N[:-2]+N[-1]
print(max(int(a),int(b))) | 7 | PYTHON3 |
input()
s = input()
t = input()
l = []
for i in range(26):
l.append([])
for i in range(len(s)):
l[ord(s[i])-ord('a')].append(i)
l2 = []
for i in range(len(t)):
l2.append([])
l3 = [0]*len(t)
for i in range(len(t)):
c = t[i]
pos = l[ord(c)-ord('a')]
for p in pos:
start = i-p
if len(t)-len(s) >= start >= 0:
l3[start] += 1
l2[start].append(p)
best = max(l3)
posb = l3.index(best)
print(len(s)-best)
things = l2[posb]
k = []
for i in range(len(s)):
if not i in things:
k.append(str(i+1))
print(' '.join(k))
| 8 | PYTHON3 |
n,m,a=map(int,input().split())
s=-n//a*(-m//a)
print(s) | 7 | PYTHON3 |
#include <bits/stdc++.h>
struct node {
int index;
int data;
} s[110], s1[110];
int main() {
int n, a[110], k;
while (~scanf("%d%d", &n, &k)) {
int i, j, sum = 0;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int b[110];
for (i = 0; i < n; i++) {
if (a[i] & 1) {
s[i].data = a[i] / 2 + 1;
s[i].index = i;
} else {
s[i].data = a[i] / 2;
s[i].index = i;
}
}
for (i = 0; i < n; i++) sum += s[i].data;
if (sum > k) {
printf("-1\n");
continue;
}
for (i = 0; i < n - 1; i++) {
for (j = i + 1; j < n; j++) {
if (a[s[i].index] > a[s[j].index]) {
s1[i] = s[i];
s[i] = s[j];
s[j] = s1[i];
}
}
}
while (sum != k) {
if (sum < k)
for (i = n - 1; i >= 0; i--) {
if (s[i].data + 1 <= a[s[i].index]) {
s[i].data = s[i].data + 1;
sum++;
}
if (sum == k) break;
}
if (sum > k)
for (i = 0; i < n; i++) {
if (s[i].data - 1 >= 0) {
s[i].data = s[i].data - 1;
sum--;
}
if (sum == k) break;
}
}
int x = 0;
while (x < n) {
for (i = 0; i < n; i++) {
if (s[i].index == x) {
printf("%d ", s[i].data);
break;
}
}
x++;
}
printf("\n");
}
return 0;
}
| 9 | CPP |
q = int(input())
w = input().split()
a = []
n = 0
for i in w:
if i == '1':
n += 1
else:
a.append(n)
n = 0
if w[-1] == '1':
a.append(n+a[0])
print(max(a))
| 8 | PYTHON3 |
'''
Little girl Tanya is learning how to decrease a number by one, but she does it
wrong with a number consisting of two or more digits. Tanya subtracts one from
a number by the following algorithm:
if the last digit of the number is non-zero, she decreases the number by one;
if the last digit of the number is zero, she divides the number by 10 (i.e.
removes the last digit).
You are given an integer number n. Tanya will subtract one from it k times.
Your task is to print the result after all k subtractions.
It is guaranteed that the result will be positive integer number.
Input
The first line of the input contains two integer numbers n and k (2โคnโค109,
1โคkโค50) โ the number from which Tanya will subtract and the number of
subtractions correspondingly.
Output
Print one integer number โ the result of the decreasing n by one k times.
It is guaranteed that the result will be positive integer number.
'''
n, k = [int(i) for i in input().split()]
for i in range(k):
if(n % 10 == 0):
n //= 10
else:
n -= 1
print(n)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 105;
int N, M, K;
vector<pair<int, int> > primes[NMAX];
namespace Matching {
const int NMAX = 10005;
int N, ans;
int cpl[NMAX], prm[NMAX];
int F, f[NMAX];
vector<int> edg[NMAX];
void addEdge(int x, int y) {
edg[x].push_back(y);
edg[y].push_back(x);
}
bool match(int nod) {
if (f[nod] == F) return false;
f[nod] = F;
for (auto nxt : edg[nod])
if (cpl[nxt] == 0) {
cpl[nxt] = nod;
cpl[nod] = nxt;
return true;
}
for (auto nxt : edg[nod])
if (match(cpl[nxt])) {
cpl[nod] = nxt;
cpl[nxt] = nod;
return true;
}
return false;
}
int solve() {
for (int i = 1; i <= N; i++) prm[i] = i;
mt19937 g(chrono::high_resolution_clock::now().time_since_epoch().count());
shuffle(prm + 1, prm + N + 1, g);
for (int i = 1; i <= N; i++)
for (auto &x : edg[i]) x = prm[x];
for (int i = 1; i <= N; i++)
while (prm[i] != i) {
swap(edg[i], edg[prm[i]]);
swap(prm[i], prm[prm[i]]);
}
bool newMatch = true;
for (int i = 1; i <= N; i++) cpl[i] = 0;
while (newMatch) {
newMatch = false;
F++;
for (int i = 1; i <= N; i++)
if (!cpl[i]) newMatch |= match(i);
}
for (int i = 1; i <= N; i++)
if (cpl[i] > i) ans++;
return ans;
}
} // namespace Matching
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
int val;
scanf("%d", &val);
for (int j = 2; j * j <= val; j++)
while (val % j == 0) {
primes[i].push_back({j, ++K});
val /= j;
}
if (val > 1) primes[i].push_back({val, ++K});
}
Matching::N = K;
for (int i = 1; i <= M; i++) {
int x, y;
scanf("%d%d", &x, &y);
for (auto &a : primes[x])
for (auto &b : primes[y])
if (a.first == b.first) Matching::addEdge(a.second, b.second);
}
int ans = Matching::solve();
printf("%d\n", ans);
return 0;
}
| 9 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v(n), temp1(n), temp2(n);
for (int i = 0; i < n; i++) cin >> v[i];
int indf = -1, indb = -1;
for (int i = 0; i < n; i++) {
if (v[i] < i) {
break;
}
indf = i;
}
for (int i = n - 1; i >= 0; i--) {
if (v[i] < (n - 1) - i) {
break;
}
indb = i;
}
if (indb <= indf) {
cout << "Yes\n";
} else
cout << "No\n";
}
return 0;
}
| 8 | CPP |
k=list(map(int,input().split()))
p=(k[0]*((k[2]*(k[2]+1))//2))-k[1]
print(p if p>0 else '0')
| 7 | PYTHON3 |
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
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")
#-------------------game starts now-----------------------------------------------------
n,k=map(int,input().split())
p=list(map(int,input().split()))
r=[-1]*256
for i in p:
for u in range(i,max(i-k,-1),-1):
if r[u]>=0: u+=1;break
if u<=i:
if u>0 and r[u-1]+k>i: r[i]=r[u-1]
else:
for j in range(u,i+1): r[j]=u
print(r[i]) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n,f[5005];
struct eming
{
long long a,b;
};
eming e[5005];
long long cmp(eming x,eming y)
{
return (x.a+x.b<y.a+y.b)?1:0;
}
int main()
{
scanf("%lld",&n);
for(long long i=1;i<=n;i++)
{
f[i]=99999999999;
scanf("%lld %lld",&e[i].a,&e[i].b);
}
sort(e+1,e+n+1,cmp);
for(long long i=1;i<=n;i++)
{
for(long long j=n;j>=1;j--)
{
if(f[j]>f[j-1]+e[i].b&&e[i].a>=f[j-1])
{
f[j]=f[j-1]+e[i].b;
}
}
}
for(long long i=n;i>=0;i--)
{
if(f[i]<9999999999)
{
printf("%lld\n",i);
return 0;
}
}
return 0;
} | 0 | CPP |
#map(int, input().split())
n = int(input())
s = input()
res = 0
for i in range(1,n + 1):
if int(s[i - 1]) % 2 == 0:
res += i
print(res)
| 7 | PYTHON3 |
t=int(input())
while t>0:
s=input()
if s[-1]=='o':
print("FILIPINO")
elif s[-1]=='u':
print("JAPANESE")
else:
print("KOREAN")
t-=1 | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int sum = 0, p = 1;
char ch = getchar();
while (!(('0' <= ch && ch <= '9') || ch == '-')) ch = getchar();
if (ch == '-') p = -1, ch = getchar();
while ('0' <= ch && ch <= '9') sum = sum * 10 + ch - 48, ch = getchar();
return sum * p;
}
const int maxn = 5e5 + 20;
int n, m;
struct node {
int v, next;
};
node e[maxn << 1];
int cnt = 1, start[maxn];
inline void addedge(int u, int v) {
e[++cnt] = (node){v, start[u]};
start[u] = cnt;
}
int deep[maxn], col[maxn];
int sz[maxn], son[maxn];
int f[maxn];
struct Query {
int x, dep;
};
Query qu[maxn];
vector<int> to[maxn];
inline void init() {
n = read();
m = read();
for (int i = (2), _end_ = (n); i <= _end_; i++) addedge(read(), i);
for (int i = (1), _end_ = (n); i <= _end_; i++)
col[i] = 1 << (getchar() - 'a');
for (int i = (1), _end_ = (m); i <= _end_; i++) {
int x = read(), dep = read();
qu[i] = (Query){x, dep};
to[x].push_back(i);
}
}
bool ans[maxn];
void dfs(int u, int fa) {
sz[u] = 1;
deep[u] = deep[fa] + 1;
f[u] = 1;
for (int i = start[(u)]; i; i = e[i].next) {
int v = e[i].v;
if (v == fa) continue;
dfs(v, u);
f[u] = max(f[u], f[v] + 1);
sz[u] += sz[v];
if (sz[v] > sz[son[u]]) son[u] = v;
}
}
int s[maxn];
inline void Add(int x) { s[deep[x]] ^= col[x]; }
void update(int u, int fa) {
Add(u);
for (int i = start[(u)]; i; i = e[i].next) {
int v = e[i].v;
if (v == fa) continue;
update(v, u);
}
}
void dfs1(int u, int fa) {
for (int i = start[(u)]; i; i = e[i].next) {
int v = e[i].v;
if (v == fa || v == son[u]) continue;
dfs1(v, u);
}
if (son[u]) dfs1(son[u], u);
Add(u);
for (int i = start[(u)]; i; i = e[i].next) {
int v = e[i].v;
if (v == fa || v == son[u]) continue;
update(v, u);
}
for (int v : to[u]) {
int dep = qu[v].dep;
for (int i = (0), _end_ = (25); i <= _end_; i++)
if (s[dep] == (1 << i)) {
ans[v] = 1;
break;
}
if (!s[dep]) ans[v] = 1;
}
if (son[fa] != u) update(u, fa);
}
inline void doing() {
dfs(1, 0);
dfs1(1, 0);
for (int i = (1), _end_ = (m); i <= _end_; i++)
if (ans[i])
puts("Yes");
else
puts("No");
}
int main() {
init();
doing();
return 0;
}
| 10 | CPP |
#!/usr/bin/env python
# coding: utf-8
# In[35]:
# n=int(input())
# for i in range(n):
# nkz=input().split()
# n=int(nkz[0])
# k=int(nkz[1])
# z=int(nkz[2])
# arr=[int(i) for i in input().split()]
# sum=0
# if arr==sorted(arr) or z==0:
# for i in range(k+1):
# sum+=arr[i]
# print(sum)
# else:
# arr2=arr[:k]
# a=max(arr2)
# a=arr2.index(a)
# i=0
# count=0
# while count<k+1:
# if i==0 or i==1:
# sum+=arr[i]
# i+=1
# elif i==a+1 and z>0:
# sum+=arr[i]
# i=i-1
# k=k-1
# z=z-1
# else:
# sum+=arr[i]
# i+=1
# count+=1
# print(sum)
# In[ ]:
#problem1
n=int(input())
for i in range(n):
lr=input().split()
l=int(lr[0])
r=int(lr[1])
if 2*l>r:
print(-1,-1)
else:
print(l,2*l)
| 7 | PYTHON3 |
n,m=map(int,input().split())
a=sorted(map(int,input().split()))
print(min(a[i+n-1]-a[i]for i in range(m-n+1))) | 7 | PYTHON3 |
n = int(input().strip())
ans = 0
cur = 0
for i in range(n):
[a, b] = [int(x) for x in input().strip().split(' ')]
cur = cur - a + b
ans = max(ans, cur)
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2100000000;
const int MOD = 1000000007;
struct SegTree {
int n, h;
vector<int> mn;
vector<stack<pair<int, int> > > st;
SegTree() {}
SegTree(int siz) {
n = siz;
mn.resize(4 * n, INF);
st.resize(n);
}
int query(int l, int r, int node, int nl, int nr, int height) {
if (r < nl || nr < l || mn[node] > height) return 0;
if (nl == nr) {
int ret = 0;
while (!st[nl].empty() && st[nl].top().first <= height) {
int h = st[nl].top().first, val = st[nl].top().second;
st[nl].pop();
ret = (ret + val) % MOD;
}
if (!st[nl].empty())
mn[node] = st[nl].top().first;
else
mn[node] = INF;
return ret;
}
int mid = (nl + nr) / 2;
int a = query(l, r, node * 2, nl, mid, height);
int b = query(l, r, node * 2 + 1, mid + 1, nr, height);
mn[node] = min(mn[node * 2], mn[node * 2 + 1]);
return (a + b) % MOD;
}
int query(int l, int r, int height) {
return query(l, r, 1, 0, n - 1, height);
}
int update(int idx, int height, int val, int node, int nl, int nr) {
if (idx < nl || nr < idx) return mn[node];
if (nl == nr) {
st[nl].push(make_pair(height, val));
return mn[node] = height;
}
int mid = (nl + nr) / 2;
return mn[node] = min(update(idx, height, val, node * 2, nl, mid),
update(idx, height, val, node * 2 + 1, mid + 1, nr));
}
int update(int idx, int height, int val) {
if (!height) return 0;
return update(idx, height, val, 1, 0, n - 1);
}
};
SegTree st(100005);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int H, W, N;
cin >> H >> W >> N;
for (int i = 1; i <= W; i++) st.update(i, H + 1, 1);
vector<pair<pair<int, int>, pair<int, int> > > bar;
for (int i = 0; i < N; i++) {
int u, l, r, s;
cin >> u >> l >> r >> s;
bar.push_back(make_pair(make_pair(u, l), make_pair(r, s)));
}
sort(bar.rbegin(), bar.rend());
for (int i = 0; i < N; i++) {
int u = bar[i].first.first, l = bar[i].first.second,
r = bar[i].second.first, s = bar[i].second.second;
int ret = st.query(l, r, u + s);
if (l == 1)
st.update(r + 1, u, (ret + ret) % MOD);
else if (r == W)
st.update(l - 1, u, (ret + ret) % MOD);
else {
st.update(r + 1, u, ret);
st.update(l - 1, u, ret);
}
}
cout << st.query(1, W, H + 5) << '\n';
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-6;
const int N = 505;
int dp[N][N];
char s[N];
int main() {
memset(dp, 0x3f, sizeof(dp));
memset(dp[0], 0, sizeof(dp[0]));
int n, m, t;
cin >> n >> m >> t;
for (int i = 1; i <= n; i++) {
cin >> s;
int tt = 0;
for (int j = 0; j < m; j++) tt += s[j] == '1';
for (int j = 0; j < tt; j++) {
int mm = INF;
queue<int> q;
for (int k = 0; k < m; k++) {
if (s[k] == '1') q.push(k);
if (q.size() == tt - j) mm = min(mm, q.back() - q.front() + 1), q.pop();
}
for (int k = j; k <= t; k++)
dp[i][k] = min(dp[i][k], dp[i - 1][k - j] + mm);
}
for (int k = tt; k <= t; k++) dp[i][k] = min(dp[i][k], dp[i - 1][k - tt]);
}
int ans = INF;
for (int i = 0; i <= t; i++) ans = min(ans, dp[n][i]);
cout << ans << endl;
return 0;
}
| 10 | CPP |
p=input().lower()
q=input().lower()
if p>q:
print("1")
elif q>p:
print("-1")
else:
print("0") | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
#define oo 1000000010
const int N = 6010;
int n , mod;
int dp[N][2 * N];
inline void add(int &x,int y){x += y; if(x >= mod) x -= mod; if(x < 0) x += mod;}
int main(){
scanf("%d%d",&n,&mod);
n *= 3;
for(int j = 0 ;j <= n;j++) dp[0][j] = 1;
for(int i = 1;i <= n;i++){
for(int j = 0 ;j <= 2 * n;j++){
dp[i][j] = 0;
if(i >= 3) add(dp[i][j] , (long long)dp[i - 3][j] * ((i - 1) * (i - 2)) % mod);
if(j > 0) add(dp[i][j] , dp[i - 1][j - 1]);
if(i >= 2) add(dp[i][j] , ((long long)dp[i - 2][j + 1] * (i - 1)) % mod);
//printf("dp[%d][%d]=%d\n",i,j - n,dp[i][j]);
}
}
cout << dp[n][n] << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
#define For(i, a, b) for(int (i)=(int)(a); (i)<(int)(b); ++(i))
#define rFor(i, a, b) for(int (i)=(int)(a)-1; (i)>=(int)(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef unsigned long long ulint;
typedef pair<int, int> pii;
typedef pair<int, lint> pil;
typedef pair<lint, lint> pll;
template<class T> bool chmax(T &a, const T &b){if(a<b){a=b; return true;} return false;}
template<class T> bool chmin(T &a, const T &b){if(a>b){a=b; return true;} return false;}
template<class T> T div_floor(const T a, const T b){return a>=0 ? a/b : (a+1)/b-1;}
template<class T> T div_ceil(const T a, const T b){return a>=0 ? (a-1)/b+1 : a/b;}
constexpr lint mod = 1e9+7;
constexpr lint INF = mod*mod;
constexpr int MAX = 100010;
int main(){
int L, K;
scanf("%d%d", &L, &K);
lint dp[L+1][2];
rep(i, L+1)rep(j, 2) dp[i][j] = 0;
dp[0][0] = 1;
rep(i, L)rep(j, 2)if(dp[i][j]){
dp[i+1][j^1] += dp[i][j];
if(j==0 && i+K<=L) dp[i+K][1] += dp[i][j];
}
lint ans = 0;
rep(i, L+1) ans += dp[i][1];
printf("%lld\n", ans);
}
| 0 | CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.