solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
s1 = str(input())
s2 = str(input())
s1 = s1.lower()
s2 = s2.lower()
c1=0
c2=0
r = 0
for i in range(len(s1)):
c1 = ord(s1[i])
c2 = ord(s2[i])
if c1 > c2:
r = 1
break
elif c2 > c1:
r = -1
break
print(r)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3f;
template <typename T>
inline void read(T& X) {
X = 0;
int w = 0;
char ch = 0;
while (!isdigit(ch)) {
w |= ch == '-';
ch = getchar();
}
while (isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
if (w) X = -X;
}
long long a[20], p[20];
int main() {
int t;
for (int i = 0; i <= 9; i++) p[i] = pow(10, i);
scanf("%d", &t);
while (t--) {
long long k, n;
long long ans = 0;
scanf("%lld %lld", &n, &k);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
a[i] = p[a[i]];
}
for (int i = 1; i <= n; i++) {
if (i == n) {
ans = ans + (k + 1) * a[i];
break;
}
long long now = (a[i + 1] - a[i]) / a[i];
if (now <= k) {
ans = ans + a[i + 1] - a[i];
k = k - now;
} else {
ans = ans + a[i] * (k + 1);
break;
}
}
printf("%lld\n", ans);
}
return 0;
}
| 1,400 | CPP |
a = int(input())
maxx = 0
for i in range(a):
x, y = map(int, input().split())
maxx = max(maxx, x + y)
print(maxx) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1073741824;
int prim[2010];
bool ok[2010];
int cntpri = 0;
int a, b, c;
map<int, long long> f[4010101];
int p[4010101], rm[4010101], cnt[4010101];
int d[4010101];
void preprim() {
for (int i = 2; i <= 2000; ++i) {
if (!ok[i]) {
prim[++cntpri] = i;
for (int j = i + i; j <= 2000; j += i) {
ok[j] = true;
}
}
}
}
int getd(int x) {
if (x == 1) return 1;
if (d[x]) return d[x];
long long dx = 1;
int x1 = x;
int now = 1;
int cnt1 = 0;
while (x >= prim[now]) {
if (now > cntpri) break;
if (x % prim[now] == 0) {
cnt1 = 0;
while (x % prim[now] == 0) {
x /= prim[now];
cnt1++;
}
dx = 1LL * getd(x) * (cnt1 + 1);
dx %= MOD;
d[x1] = dx;
return d[x1];
}
now++;
}
return d[x1] = 2;
}
int f1(int x, int y) {
if (!y) return 0;
if (f[x][y]) return f[x][y];
if (y == 1) return f[x][y] = getd(x);
if (x == 1) {
f[x][y] = 0;
for (int i = 1; i <= y; ++i) f[x][y] += getd(i);
f[x][y] %= MOD;
return f[x][y];
}
f[x][y] =
1LL * f1(rm[x], y) * (cnt[x] + 1) - 1LL * f1(rm[x], y / p[x]) * cnt[x];
f[x][y] %= MOD;
return f[x][y];
}
long long ans = 0;
int main() {
ios::sync_with_stdio(false);
cin >> a >> b >> c;
preprim();
int x1, x2;
for (int i = 1; i <= c; ++i) f[1][i] = f1(1, i);
ans = f[1][c];
for (int i = 1; i <= a; i++) {
for (int j = 1; j <= b; ++j) {
x1 = i * j;
if (x1 == 1) continue;
for (p[x1] = 1; p[x1] <= cntpri; ++p[x1]) {
if (x1 % prim[p[x1]] == 0) {
p[x1] = prim[p[x1]];
break;
}
if (p[x1] == cntpri) {
p[x1] = x1;
break;
}
}
cnt[x1] = 0;
x2 = x1;
while (x2 % p[x1] == 0) {
cnt[x1]++;
x2 /= p[x1];
}
rm[x1] = x2;
ans += f1(x1, c);
ans %= MOD;
}
}
cout << ans << endl;
return 0;
}
| 2,600 | CPP |
# |
# _` | __ \ _` | __| _ \ __ \ _` | _` |
# ( | | | ( | ( ( | | | ( | ( |
# \__,_| _| _| \__,_| \___| \___/ _| _| \__,_| \__,_|
import sys
import math
def read_line():
return sys.stdin.readline()[:-1]
def read_int():
return int(sys.stdin.readline())
def read_int_line():
return [int(v) for v in sys.stdin.readline().split()]
n =read_int()
a = read_int_line()
b = read_int_line()
c = [0]*n
for i in range(n):
c[i] = a[i]-b[i]
c.sort()
i = 0
j = n-1
cnt = 0
while i<=j:
if c[i]+c[j]>0:
cnt+=(j-i)
j-=1
else:
i+=1
print(cnt)
| 1,400 | PYTHON3 |
# !/bin/env python3
# encoding: UTF-8
# ✪ H4WK3yE乡
# Mohd. Farhan Tahir
# Indian Institute Of Information Technology and Management,Gwalior
# Question Link
# https://codeforces.com/contest/1096/problem/B
#
# ///==========Libraries, Constants and Functions=============///
import sys
from math import factorial
inf = float("inf")
mod = 998244353
def get_array(): return list(map(int, sys.stdin.readline().split()))
def get_ints(): return map(int, sys.stdin.readline().split())
def input(): return sys.stdin.readline()
# ///==========MAIN=============///
def main():
n = int(input())
s = input().strip()
x = 0
for i in range(n-1):
if s[i] == s[i+1]:
x += 1
else:
break
y = 0
for i in range(n-1, 0, -1):
if s[i] == s[i-1]:
y += 1
else:
break
count = 3
count = (count+x) % mod
count = (count+y) % mod
if s[0] == s[-1]:
count += 1
count = (count+x) % mod
count = (count+y) % mod
count = (count+(x*y)) % mod
print(count)
if __name__ == "__main__":
main()
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int a[100005], b[100005];
bool cmp(int x, int y) { return x > y; }
int main() {
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int j = 1; j <= m; j++) scanf("%d", &b[j]);
sort(a + 1, a + 1 + n, cmp);
sort(b + 1, b + 1 + m, cmp);
int qa = 1, qb = 1;
int num1 = 0, num2 = 0;
int cur1, cur2;
int flag = 0;
while (qa <= n) {
num1++;
cur1 = a[qa];
while (qa < n && (a[qa] == a[qa + 1])) {
qa++;
num1++;
}
while (qb <= m && b[qb] >= cur1) {
num2++;
qb++;
}
if (num1 > num2) {
flag = 1;
break;
}
qa++;
}
if (flag)
puts("YES");
else
puts("NO");
}
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n;
string A, B;
vector<ll> c;
unordered_map<char, set<int>> m;
int lowbit(int x) { return x & -x; }
ll sum(int x) {
x++;
ll ret = 0;
while (x > 0) {
ret += c[x];
x -= lowbit(x);
}
return ret;
}
void add(int x, int d) {
x++;
while (x < c.size()) {
c[x] += d;
x += lowbit(x);
}
}
int main() {
cin >> n >> A;
B = A;
reverse(B.begin(), B.end());
c.resize(n + 1);
for (int i = 0; i < n; i++) {
m[A[i]].insert(i);
}
for (int i = 0; i < n; i++) {
add(i, 1);
}
ll ans = 0;
for (int i = 0; i < n; i++) {
int x = *m[B[i]].begin();
ans += sum(x) - 1;
add(x, -1);
m[B[i]].erase(m[B[i]].begin());
}
cout << ans;
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long MAXS = 1000000;
const long MOD = 1000000007;
const double PI = 3.1415926535;
int main() {
ios_base::sync_with_stdio(0);
setlocale(LC_ALL, "");
long n, t;
cin >> n;
vector<long> m(n);
for (long i = 0; i < n; i++) cin >> m[i];
cin >> t;
long res = 0;
sort(m.begin(), m.end());
for (long i = 0; i < n; i++) {
long k = 0;
for (long j = i; j < n; j++) {
if (m[j] - m[i] > t) break;
k++;
}
res = max(res, k);
}
printf("%d", res);
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
const double pi = acos(-1.0);
const int inf = INT_MAX;
const int N = 3e5 + 5;
int n, m, a[N];
ll pref[N], ans[N];
vector<pair<int, int>> queries[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
cin >> m;
for (int i = 0, x, y; i < m; i++) {
cin >> x >> y;
queries[y].emplace_back(--x, i);
}
for (int d = 1; d < N; d++) {
if (queries[d].empty()) continue;
sort(queries[d].begin(), queries[d].end());
for (auto& [l, i] : queries[d]) {
if (pref[l]) {
ans[i] = pref[l];
continue;
}
int last = l;
for (int j = l; j < n; j += d) {
last = j;
pref[j] = a[j];
}
for (int j = last - d; j >= l; j -= d) {
pref[j] += pref[j + d];
}
ans[i] = pref[l];
}
for (auto& [l, i] : queries[d]) {
if (!pref[l]) continue;
for (int i = l; i < n; i += d) pref[i] = 0;
}
}
for (int i = 0; i < m; i++) cout << ans[i] << '\n';
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
int p[305];
bool np[305];
struct qnode {
int opt, l, r, x;
} q[400000 + 5];
int a[400000 + 5];
long long inv[305];
long long qp(long long a, int k) {
long long res = 1;
while (k) {
if (k & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
k >>= 1;
}
return res;
}
struct SEGTREEmul {
long long s[400000 * 4 + 5], mark[400000 * 4 + 5];
void pu(int i) { s[i] = s[i * 2] * s[i * 2 + 1] % 1000000007; }
void pd(int i, int l, int r) {
if (mark[i] != 1) {
mark[i * 2] = mark[i * 2] * mark[i] % 1000000007;
mark[i * 2 + 1] = mark[i * 2 + 1] * mark[i] % 1000000007;
int mid = (l + r) >> 1;
s[i * 2] = s[i * 2] * qp(mark[i], mid - l + 1) % 1000000007;
s[i * 2 + 1] = s[i * 2 + 1] * qp(mark[i], r - mid) % 1000000007;
mark[i] = 1;
}
}
void build(int i, int l, int r) {
mark[i] = 1;
if (l == r)
s[i] = a[l];
else {
int mid = (l + r) >> 1;
build(i * 2, l, mid);
build(i * 2 + 1, mid + 1, r);
pu(i);
}
}
void add(int i, int l, int r, int ql, int qr, int x) {
if (ql <= l && r <= qr) {
s[i] = s[i] * qp(x, r - l + 1) % 1000000007;
mark[i] = mark[i] * x % 1000000007;
return;
}
if (qr < l || r < ql) return;
pd(i, l, r);
int mid = (l + r) >> 1;
add(i * 2, l, mid, ql, qr, x);
add(i * 2 + 1, mid + 1, r, ql, qr, x);
pu(i);
}
long long ask(int i, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return s[i];
if (qr < l || r < ql) return 1;
pd(i, l, r);
int mid = (l + r) >> 1;
return ask(i * 2, l, mid, ql, qr) * ask(i * 2 + 1, mid + 1, r, ql, qr) %
1000000007;
}
} tmul;
struct SEGTREEflag {
bool s[400000 * 4 + 5], mark[400000 * 4 + 5];
void pu(int i) { s[i] = s[i * 2] || s[i * 2 + 1]; }
void pd(int i) {
if (mark[i]) {
mark[i * 2] = mark[i * 2 + 1] = 1;
s[i * 2] = s[i * 2 + 1] = 1;
mark[i] = 0;
}
}
void build(int i, int l, int r, int pr) {
mark[i] = 0;
if (l == r)
s[i] = a[l] % pr == 0;
else {
int mid = (l + r) >> 1;
build(i * 2, l, mid, pr);
build(i * 2 + 1, mid + 1, r, pr);
pu(i);
}
}
void set(int i, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
s[i] = 1;
mark[i] = 1;
return;
}
if (qr < l || r < ql) return;
pd(i);
int mid = (l + r) >> 1;
set(i * 2, l, mid, ql, qr);
set(i * 2 + 1, mid + 1, r, ql, qr);
pu(i);
}
bool ask(int i, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return s[i];
if (qr < l || r < ql) return 0;
pd(i);
int mid = (l + r) >> 1;
return ask(i * 2, l, mid, ql, qr) || ask(i * 2 + 1, mid + 1, r, ql, qr);
}
} tf;
long long ans[400000 + 5];
int main() {
int num = 0;
for (int i = 2; i <= 300; i++)
if (np[i] == 0) {
p[++num] = i;
for (int j = i * 2; j <= 300; j += i) np[j] = 1;
}
inv[1] = 1;
for (int i = 2; i <= 300; i++)
inv[i] = inv[1000000007 % i] * (1000000007 - 1000000007 / i) % 1000000007;
int n, Q;
scanf("%d%d", &n, &Q);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= Q; i++) {
char s[15];
scanf("%s%d%d", s, &q[i].l, &q[i].r);
if (s[0] == 'T')
q[i].opt = 2;
else {
q[i].opt = 1;
scanf("%d", &q[i].x);
}
}
tmul.build(1, 1, n);
for (int i = 1; i <= Q; i++) ans[i] = 1;
for (int i = 1; i <= Q; i++) {
if (q[i].opt == 1)
tmul.add(1, 1, n, q[i].l, q[i].r, q[i].x);
else
ans[i] = ans[i] * tmul.ask(1, 1, n, q[i].l, q[i].r);
}
for (int r = 1; r <= num; r++) {
int pr = p[r];
tf.build(1, 1, n, pr);
for (int i = 1; i <= Q; i++) {
if (q[i].opt == 1) {
if (q[i].x % pr == 0) tf.set(1, 1, n, q[i].l, q[i].r);
} else {
if (tf.ask(1, 1, n, q[i].l, q[i].r))
ans[i] = ans[i] * (1 - inv[pr] + 1000000007) % 1000000007;
}
}
}
for (int i = 1; i <= Q; i++)
if (q[i].opt == 2) printf("%I64d\n", ans[i]);
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:102400000,102400000")
const double eps = 1e-9;
vector<int> f[100010];
int deep[100010];
int p[17][100010], lev;
int num[100010];
void dfs(int x, int fu) {
deep[x] = deep[fu] + 1;
num[x] = 1;
p[0][x] = fu;
for (int i = 0; i < f[x].size(); i++) {
int v = f[x][i];
if (v != fu) {
dfs(v, x);
num[x] += num[v];
}
}
}
int LCA(int a, int b) {
int i, j;
if (deep[a] < deep[b]) swap(a, b);
for (j = lev; j >= 0; j--)
if (deep[a] - (1 << j) >= deep[b]) a = p[j][a];
if (a == b) return a;
for (j = lev; j >= 0; j--)
if (p[j][a] != p[j][b]) {
a = p[j][a];
b = p[j][b];
}
return p[0][a];
}
int get(int x, int k) {
for (int i = lev; i >= 0; i--)
if (k >> i & 1) x = p[i][x];
return x;
}
int main() {
int n, m, i, j, k;
cin >> n;
for (i = 0; i <= n; i++) f[i].clear();
for (i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
f[a].push_back(b);
f[b].push_back(a);
}
deep[0] = 0;
dfs(1, 0);
for (i = 1; (1 << i) < n; i++) {
for (j = 1; j <= n; j++) p[i][j] = p[i - 1][p[i - 1][j]];
}
lev = i - 1;
cin >> m;
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
if (deep[a] < deep[b]) swap(a, b);
int c = LCA(a, b);
int tmpa = a, tmpb = b;
if ((deep[a] + deep[b] - 2 * deep[c]) % 2 == 1) {
printf("0\n");
continue;
}
int d = (deep[a] + deep[b] - 2 * deep[c]) / 2 - 1;
tmpa = get(tmpa, d);
if (deep[a] == deep[b]) {
tmpb = get(tmpb, d);
printf("%d\n", n - num[tmpa] - num[tmpb]);
} else
printf("%d\n", num[p[0][tmpa]] - num[tmpa]);
}
}
| 2,100 | CPP |
#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef long long ll;
const int mod=1e9+7,inv2=(mod+1)/2;
int ksm(int b,int n){
int res=1;
while(n){
if(n&1) res=1ll*res*b%mod;
b=1ll*b*b%mod; n>>=1;
}
return res;
}
int ans,dis[405],dep[405],f[405][405],c[405][405],fa[405][10];
vector<int> e[405];
vector<int> vec[405];
void dfs(int u,int fath){
vec[u].clear(); vec[u].push_back(u);
dep[u]=dep[fath]+1;
for(int v:e[u])
if(v!=fath){
dfs(v,u);
for(int x:vec[v])
for(int y:vec[u]){
int a=x,b=y;
if(a<b) swap(a,b);
ans=(ans+f[dep[a]-dep[u]][dep[b]-dep[u]])%mod;
}
for(int x:vec[v]) vec[u].push_back(x);
}
}
int fac[405],inv[405];
void init(int n){
fac[0]=1;
for(int i=1;i<=n;++i)
fac[i]=1ll*fac[i-1]*i%mod;
inv[n]=ksm(fac[n],mod-2);
for(int i=n-1;i>=0;--i)
inv[i]=1ll*inv[i+1]*(i+1)%mod;
}
int C(int n,int m){
if(n<0||m<0||n<m) return 0;
return 1ll*fac[n]*inv[m]%mod*inv[n-m]%mod;
}
void solve(){
int n;cin>>n;
for(int i=1;i<n;++i){
int u,v;cin>>u>>v;
e[u].push_back(v),e[v].push_back(u);
}
init(n+n);
for(int y=1;y<=n;++y) f[0][y]=1;
for(int i=1;i<=n;++i)
for(int j=1;j<=n;++j)
for(int k=0;k<j;++k)
f[i][j]=(f[i][j]+1ll*ksm(inv2,i+k)*C(i+k-1,k))%mod;
for(int k=1;k<=n;++k){
dfs(k,0);
}
cout<<1ll*ans*ksm(n,mod-2)%mod;
}
signed main(){
ios::sync_with_stdio(false);
cin.tie(0),cout.tie(0);
int T=1;
//cin>>T;
while(T--) solve();
return 0;
} | 2,300 | CPP |
import sys
input = lambda: sys.stdin.readline().strip("\r\n")
r, g, b = map(int, input().split())
ans = 0
for i in range(min(3, r, g, b)+1):
ans = max(ans, i + (r-i)//3 + (g-i)//3 + (b-i)//3)
print(ans)
| 1,600 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MAXN = 35, MAXK = 50 + 10;
int t, dp[MAXN][MAXN][MAXK];
vector<int> res;
void make_dp() {
for (int i = 0; i < MAXN; i++)
for (int j = 0; j < MAXN; j++)
for (int k = 0; k < MAXK; k++) dp[i][j][k] = INF;
dp[0][0][0] = 0;
dp[1][1][1] = 0;
dp[1][1][0] = 0;
for (int n = 0; n < MAXN; n++) {
for (int m = 0; m < MAXN; m++) {
for (int k = 0; k < MAXK; k++) {
if (n == 0 || m == 0) dp[n][m][k] = 0;
if (k == 0) dp[n][m][k] = 0;
if (m * n == k) dp[n][m][k] = 0;
if (k > m * n) continue;
for (int i = 1; i < n; i++)
for (int j = 0; j <= k; j++)
dp[n][m][k] =
min(dp[n][m][k], dp[i][m][j] + m * m + dp[n - i][m][k - j]);
for (int i = 1; i < m; i++)
for (int j = 0; j <= k; j++)
dp[n][m][k] =
min(dp[n][m][k], dp[n][i][j] + n * n + dp[n][m - i][k - j]);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
make_dp();
for (int SinaKhare_Dadasham = 0; SinaKhare_Dadasham < t;
SinaKhare_Dadasham++) {
int n, m, k;
cin >> n >> m >> k;
cout << dp[n][m][k] << endl;
}
}
| 2,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
struct FAIL {
FAIL() {
cout << "CHANGE!!!"
<< "\n";
}
};
struct Z {
int x;
int v;
int t;
};
const int FINISH = 1000000;
double f(double x, double vx, double vs, double time) {
double vmid = x / time;
double t1 = -time / vs * (vmid - vx - vs);
return min(t1 * vs + (time - t1) * (vs + vx), 2e6);
}
bool ok(const vector<Z> &v, int s, double mid) {
vector<int> pos1(FINISH + 2);
vector<int> pos2(FINISH + 2);
int n = v.size();
for (int i = (0); i < (n); ++i) {
if (v[i].t == 1) {
if (v[i].x <= mid * v[i].v) {
++pos1[0];
--pos1[FINISH + 1];
continue;
}
if (v[i].x > mid * (v[i].v + s)) {
continue;
}
int pos = f(v[i].x, v[i].v, s, mid);
pos = min(pos, FINISH);
++pos1[v[i].x];
--pos1[pos + 1];
} else {
if ((FINISH - v[i].x) <= mid * v[i].v) {
++pos2[0];
--pos2[FINISH + 1];
continue;
}
if ((FINISH - v[i].x) > mid * (v[i].v + s)) {
continue;
}
int pos = FINISH - (int)f(FINISH - v[i].x, v[i].v, s, mid);
pos = max(pos, 0);
++pos2[pos];
--pos2[v[i].x + 1];
}
}
for (int i = (1); i < (FINISH + 2); ++i) {
pos1[i] += pos1[i - 1];
pos2[i] += pos2[i - 1];
}
for (int i = (0); i < (FINISH + 2); ++i) {
if (pos1[i] && pos2[i]) {
return true;
}
}
return false;
}
int main() {
int n, s;
cin >> n >> s;
cout << fixed << setprecision(10);
vector<Z> v(n);
for (int i = (0); i < (n); ++i) {
cin >> v[i].x >> v[i].v >> v[i].t;
}
double l = 0;
double r = FINISH;
for (int t = (0); t < (70); ++t) {
double mid = (l + r) / 2;
if (ok(v, s, mid)) {
r = mid;
} else {
l = mid;
}
}
cout << l << "\n";
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n;
int q[N], res[N][3], top;
int main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &q[i]);
sort(q, q + n);
priority_queue<pair<int, int> > heap;
q[n] = -1;
for (int i = 0, t = 0; i <= n; i++)
if (i && q[i] != q[i - 1])
heap.push(make_pair(t, q[i - 1])), t = 1;
else
t++;
pair<int, int> r[3];
while (1) {
int t = 0;
while (!heap.empty() && t < 3) r[t++] = heap.top(), heap.pop();
if (t != 3) break;
for (int i = 0; i < 3; i++) {
res[top][i] = r[i].second, r[i].first--;
if (r[i].first) heap.push(r[i]);
}
sort(res[top], res[top] + 3);
top++;
}
printf("%d\n", top);
for (int i = 0; i < top; i++) {
for (int j = 2; ~j; j--) printf("%d ", res[i][j]);
puts("");
}
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int interact(int i, int j) {
cout << "? " << i + 1 << ' ' << j + 1 << endl;
int sum;
cin >> sum;
return sum;
}
int main() {
int n;
cin >> n;
vector<int> ans(n);
int sum1to3 = interact(0, 2);
int sum2to3 = interact(1, 2);
int sum1to2 = interact(0, 1);
ans[0] = sum1to3 - sum2to3;
ans[2] = sum1to3 - sum1to2;
ans[1] = sum1to3 - (ans[0] + ans[2]);
for (int i = 3; i < n; i++) {
ans[i] = interact(i - 1, i) - ans[i - 1];
}
cout << "! ";
for (auto i : ans) cout << i << ' ';
}
| 1,400 | CPP |
def Watermelon(n):
if n % 2 == 0 and n != 2:
print("YES")
else:
print("NO")
n = input()
Watermelon(int(n)) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int p, l;
cin >> p >> l;
vector<string> L;
for (int i = 1; i <= 9; i++) {
int x = i, y = 0;
vector<int> V;
for (int j = 0; j < p; j++) {
V.push_back(x);
int z = x * l + y;
x = z % 10;
y = z / 10;
}
if (y == 0 && x == i) {
string str = "";
for (int k = p - 1; k >= 1; k--) str += '0' + V[k];
str += '0' + V[0];
if (str[0] != '0') L.push_back(str);
}
}
if (L.size() == 0) {
cout << "Impossible";
return 0;
}
sort(L.begin(), L.end());
cout << L[0];
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 300000 + 5;
int mod = 998244353;
void add(long long &x, long long y) { (x += y) %= mod; }
void mul(long long &x, long long y) { (x *= y) %= mod; }
long long power(long long a, long long n) {
long long b = 1;
for (; n; n /= 2, mul(a, a)) {
if (n & 1) {
mul(b, a);
}
}
return b;
}
long long f[N][3];
vector<int> g[N];
void dfs(int u, int fa) {
long long prod02 = 1, prod0 = 1;
if (g[u].size() == 1 && fa != 0) {
f[u][1] = 1;
f[u][0] = 1;
return;
}
for (int v : g[u]) {
if (v != fa) {
dfs(v, u);
mul(prod02, (f[v][0] + f[v][2]) % mod);
mul(prod0, f[v][0]);
}
}
f[u][0] = prod0;
f[u][1] = prod02;
for (int v : g[u]) {
if (v != fa) {
add(f[u][2], prod02 * power((f[v][0] + f[v][2]) % mod, mod - 2) % mod *
f[v][1] % mod);
}
}
add(f[u][0], f[u][2]);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
printf("%lld\n", f[1][0]);
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, k, s = 0;
cin >> n >> k;
vector<int> f(n);
for (i = 0; i < n; i++) cin >> f[i];
sort(f.begin(), f.end());
while (!f.empty()) {
s += 2 * (f.back() - 1);
for (i = 1; (i <= k && !f.empty()); i++) f.pop_back();
}
cout << s;
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int N, M, L;
char board[100][100];
int dy[] = {-1, 0, 1, 0};
int dx[] = {0, 1, 0, -1};
int save_r[100][100][4];
int save_c[100][100][4];
int R, C, DP, CP;
bool on_board(int r, int c) { return 0 <= r && r < M && 0 <= c && c < L; }
void move_in_dir(int dir) {
int *mem_r = &save_r[R][C][dir];
int *mem_c = &save_c[R][C][dir];
if (*mem_r == -1) {
int next_r = R + dy[dir];
int next_c = C + dx[dir];
while (on_board(next_r, next_c) && board[next_r][next_c] == board[R][C]) {
R = next_r;
C = next_c;
next_r += dy[dir];
next_c += dx[dir];
}
*mem_r = R;
*mem_c = C;
} else {
R = *mem_r;
C = *mem_c;
}
}
void step() {
move_in_dir(DP);
move_in_dir((DP + CP) % 4);
int next_r = R + dy[DP];
int next_c = C + dx[DP];
if (!on_board(next_r, next_c) || board[next_r][next_c] == '0') {
if (CP == 3)
CP = 1;
else {
CP = 3;
DP = (DP + 1) % 4;
}
} else {
R = next_r;
C = next_c;
}
}
int main() {
scanf("%d %d ", &M, &N);
for (int i = 0; i < M; i++) gets(board[i]);
L = strlen(board[0]);
memset(save_r, -1, sizeof(save_r));
memset(save_c, -1, sizeof(save_c));
R = C = 0;
DP = 1;
CP = 3;
for (int i = 0; i < N; i++) step();
printf("%c\n", board[R][C]);
return 0;
}
| 2,100 | CPP |
def melon(b):
for i in b :
for j in b :
if i+j==n :
return 'YES'
else :
return 'NO'
n=int(input( ))
a=list(range(2,n))
b=list(filter(lambda x :x%2==0,a))
res=melon(b)
print(res) | 800 | PYTHON3 |
import sys
input=sys.stdin.readline
n,m=list(map(int,input().split()))
a=[]
b=[]
for i in range(n):
a.append(list(map(int,input().split())))
for i in range(n):
b.append(list(map(int,input().split())))
d=[]
for i in range(m+n-1):
c=[]
for j in range(n):
if 0<=i-j<m:
c.append(a[j][i-j])
c.sort()
d.append(c)
e=[]
for i in range(m+n-1):
c=[]
for j in range(n):
if 0<=i-j<m:
c.append(b[j][i-j])
c.sort()
e.append(c)
f=0
for i in range(len(d)):
if d[i]!=e[i]:
f=1
break
if f==1:
print("NO")
else:
print("YES") | 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int fibb(long long N) {
long long a = 1, b = 2, c;
long long i = 1;
if (N == 2) return 1;
while (1) {
i++;
c = a + b;
a = b;
b = c;
if (c > N)
return i - 1;
else if (c == N)
return i;
}
}
int main() {
long long N;
cin >> N;
cout << fibb(N);
return 0;
}
| 1,600 | CPP |
s = input()
p = list(set(s))
if len(p) % 2 == 0:
print('CHAT WITH HER!')
else:
print('IGNORE HIM!') | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, maxn = 1 << 7;
int full;
long long ans[maxn][maxn], res[maxn][maxn];
void mul(long long x[maxn][maxn], long long y[maxn][maxn]) {
long long z[maxn][maxn];
for (int i = 0; i < full; i++)
for (int j = 0; j < (1 << 7); j++) {
z[i][j] = 0;
for (int k = 0; k < full; k++)
z[i][j] = (z[i][j] + x[i][k] * y[k][j]) % mod;
}
memcpy(x, z, sizeof(z));
}
int main() {
memset(ans, 0, sizeof(ans));
for (int i = 0; i < maxn; i++) ans[i][i] = 1;
for (int t = 1; t <= 7; t++) {
int w;
cin >> w;
full = (1 << t);
for (int i = 0; i < full; i++)
for (int j = 0; j < full; j++) {
res[i][j] = 0;
for (int h = 0; h < (full / 2); h++) {
if ((i | j | h | (h << 1)) == full - 1) res[i][j]++;
}
}
for (; w; w >>= 1) {
if (w & 1) mul(ans, res);
mul(res, res);
}
}
cout << ans[0][0];
return 0;
}
| 2,700 | CPP |
n,b,d = list(map(int,input().split()))
res = 0
total = 0
lst = list(map(int,input().split()))
for i in lst:
if i <= b:
total += i
if total >d:
res+=1
total = 0
print(res)
| 900 | PYTHON3 |
# -*- coding: utf-8 -*-
import sys
from collections import Counter
from itertools import accumulate
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
# sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
for _ in range(INT()):
N, M = MAP()
S = [ord(s)-97 for s in input()]
A = LIST()
imos = [0] * (N+1)
imos[0] += 1
imos[N] -= 1
for a in A:
imos[0] += 1
imos[a] -= 1
imos = list(accumulate(imos))
ans = [0] * 26
for i, s in enumerate(S):
ans[s] += imos[i]
print(*ans)
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
struct Tpoint {
int x, y;
} pnt[maxn];
int b[maxn];
int n, m, K, Q;
int ent[4], nent;
long long dent[4];
bool cmp(const Tpoint &a, const Tpoint &b) {
if (a.x == b.x)
return a.y < b.y;
else
return a.x < b.x;
}
int main() {
int i, j, jj, h, lh, x;
int l, r;
long long dl, dr, dt;
scanf("%d%d%d%d", &n, &m, &K, &Q);
for (i = 0; i < K; ++i) scanf("%d%d", &pnt[i].x, &pnt[i].y);
for (i = 0; i < Q; ++i) scanf("%d", b + i);
sort(pnt, pnt + K, cmp);
sort(b, b + Q);
lh = 1;
if (pnt[0].x > 1) {
x = lower_bound(b, b + Q, 1) - b;
nent = 1;
ent[0] = b[x];
dent[0] = b[x] - 1;
} else {
nent = 1;
ent[0] = 1;
dent[0] = 0;
}
long long ans = 0;
for (i = 0; i < K; i = j) {
for (j = i; j < K && pnt[j].x == pnt[i].x; ++j)
;
l = pnt[i].y;
r = pnt[j - 1].y;
h = pnt[i].x;
dl = -1;
dr = -1;
for (jj = 0; jj < nent; ++jj) {
dt = dent[jj] + h - lh;
if (ent[jj] < r)
dt += r - ent[jj] + r - l;
else
dt += ent[jj] - l;
if (dl == -1 || dt < dl) dl = dt;
dt = dent[jj] + h - lh;
if (ent[jj] > l)
dt += ent[jj] - l + r - l;
else
dt += r - ent[jj];
if (dr == -1 || dt < dr) dr = dt;
}
lh = h;
if (j == K) ans = min(dl, dr);
nent = 0;
x = lower_bound(b, b + Q, l) - b;
if (x > 0) {
ent[nent] = b[x - 1];
dent[nent] = dl + l - b[x - 1];
++nent;
}
if (x < Q) {
ent[nent] = b[x];
dent[nent] = dl + b[x] - l;
++nent;
}
x = lower_bound(b, b + Q, r) - b;
if (x > 0) {
ent[nent] = b[x - 1];
dent[nent] = dr + r - b[x - 1];
++nent;
}
if (x < Q) {
ent[nent] = b[x];
dent[nent] = dr + b[x] - r;
++nent;
}
}
cout << ans << endl;
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
struct Graph {
vector<int> edges[100010];
vector<int> redges[100010];
int d[100010];
bool visited[100010];
int V = 100010;
void add_edge(int from, int to) {
edges[from].push_back(to);
redges[to].push_back(from);
}
void bfs() {
fill(visited, visited + V + 1, 0);
for (int i = 1; i <= V; i++)
if (!visited[i]) bfs(i);
}
void bfs(int s) {
queue<int> q;
q.push(s);
visited[s] = 1;
d[s] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int next : edges[v]) {
if (!visited[next]) {
visited[next] = 1;
d[next] = d[v] + 1;
q.push(next);
} else {
ans.push_back(abs(d[next] - d[v] - 1));
if (ans.back() == 0) ans.pop_back();
}
}
for (int next : redges[v]) {
if (!visited[next]) {
visited[next] = 1;
d[next] = d[v] - 1;
q.push(next);
} else {
ans.push_back(abs(d[next] - d[v] + 1));
if (ans.back() == 0) ans.pop_back();
}
}
}
}
};
int gcd(int m, int n) {
if (n == 0) return m;
return gcd(n, m % n);
}
Graph g;
int main() {
int n, m;
cin >> n >> m;
g.V = n;
int u, v;
while (m--) {
scanf("%d%d", &u, &v);
g.add_edge(u, v);
}
g.bfs();
if (ans.size() == 0) {
cout << n << endl;
return 0;
}
int sol = ans[0];
for (int i : ans) sol = gcd(sol, i);
cout << sol << endl;
return 0;
}
| 2,200 | CPP |
n = map(int, input())
s = input()
t = input()
count = 0
moves = []
m = dict()
for c in s:
if c in m:
m[c] = m.get(c) + 1
else:
m[c] = 1
for c in t:
if c in m:
m[c] = m.get(c) - 1
else:
m[c] = -1
for keys in m.keys():
if (m[keys] != 0):
print(-1)
exit()
s = list(s)
t = list(t)
for i in range(0,len(s)):
if s[i] != t[i]:
pos = i + s[i:].index(t[i])
if (pos == -1):
print(-1)
exit()
for j in range(pos-1, i-1, -1):
c = s[j]
s[j] = s[j+1]
s[j+1] = c
moves.append(j+1)
print(len(moves))
print(' '.join(map(str, moves)))
| 1,200 | PYTHON3 |
import math
from decimal import *
#getcontext().prec = 10
l1 = int(input())
#l2 = input()
l2 = input().split()
#l1 = [int(i) for i in l1]
l2 = [int(i) for i in l2]
#l2 = [int(i) for i in l2]
l2.insert(0,0)
for i in range (1, l2.__len__()):
l2[i] += l2[i-1];
n = (l1 - 1) % l2[l2.__len__()-1] + 1;
for i in range (1, l2.__len__()):
if (l2[i] >= n):
print(i)
break;
| 1,000 | PYTHON3 |
# https://codeforces.com/problemset/problem/519/B
from collections import Counter
n = int(input())
arr = [int(x) for x in input().split()]
first = [int(x) for x in input().split()]
second = [int(x) for x in input().split()]
freq = dict(Counter(arr))
first = dict(Counter(first))
second = dict(Counter(second))
for item in freq:
if item not in first or first[item]!=freq[item]:
print(item)
break
for item in first:
if item not in second or first[item]!=second[item]:
print(item)
break | 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(const pair<int, string> &p1, const pair<int, string> &p2) {
return p1.first < p2.first;
}
void solve() {
int n;
scanf("%d", &n);
vector<pair<int, string>> a;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int n;
cin >> n;
a.push_back({n, s});
}
sort(a.begin(), a.end(), cmp);
vector<pair<int, string>> res;
for (int i = 0; i < n;) {
if (a[i].first > i) {
puts("-1");
return;
}
if (a[i].first == i) {
int val = a[i].first;
while (a[i].first == val && i < n) {
res.push_back({a[i].first, a[i].second});
i++;
}
} else {
int val = a[i].first;
while (a[i].first == val && i < n) {
res.insert(res.begin() + a[i].first, {a[i].first, a[i].second});
i++;
}
}
}
for (int i = 0; i < n; i++) {
cout << res[i].second << " " << 4000 - res[i].first << "\n";
}
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
cin >> n >> x >> y;
if (x >= n && y >= n)
cout << "Yes";
else
cout << "No";
}
| 800 | CPP |
"""
70*70*70
70*70*70
dp[num][k] = ?
"""
import math
from sys import stdin
import sys
sys.setrecursionlimit(300000)
n,m,k = map(int,stdin.readline().split())
a = []
for i in range(n):
tmp = list(map(int,stdin.readline().split()))
a.append(tmp)
maxlis = []
for i in range(n):
tdp = [[float("-inf")] * k for i in range(m//2+1)]
tdp[0][0] = 0
for j in range(m):
for x in range(len(tdp)-2,-1,-1):
for y in range(k):
tdp[x+1][(y+a[i][j])%k] = max(tdp[x+1][(y+a[i][j])%k] , tdp[x][y] + a[i][j])
udp = [float("-inf")] * k
for x in range(len(tdp)):
for y in range(k):
udp[y] = max(udp[y] , tdp[x][y])
maxlis.append(udp)
dp = maxlis[0]
for i in range(1,len(maxlis)):
now = maxlis[i]
ndp = [float("-inf")] * k
for x in range(k):
for y in range(k):
ndp[(x+y)%k] = max(ndp[(x+y)%k] , dp[x]+now[y])
dp = ndp
#print (maxlis)
print (dp[0]) | 2,100 | PYTHON3 |
a=list(input())
a=set(a)
if len(a)%2==0:
print("CHAT WITH HER!")
else:
print("IGNORE HIM!") | 800 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
arr = []
for i in range(n):
a = input().strip()
arr.append(a)
ans = 0
for i,b in enumerate(arr):
if arr.count(b)>1:
for x in '0123456789':
arr[i] = x+b[1:]
if arr.count(arr[i])==1:
break
ans+=1
print(ans)
for x in arr:
print(x)
| 1,400 | PYTHON3 |
# your code goes here
p=[]
n=int(input())
for _ in range(n):
p.append(int(input()))
r = 0
for i in range(n):
# print("for",i)
c = 0
j=i
while j >= 0:
# print("in",j)
j = p[j] - 1
c += 1
r = max(r, c)
print(r)
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
long long x;
cin >> x;
if (x < 15) {
cout << "NO"
<< "\n";
continue;
}
long long rem = x % 14;
if (rem > 6 || rem < 1)
cout << "NO"
<< "\n";
else
cout << "YES"
<< "\n";
}
return 0;
}
| 1,000 | CPP |
# -*- coding: utf-8 -*-
"""
Created on Fri Jun 26 21:50:48 2020
@author: pc612
"""
a, b = map(int, input().split())
print(min(a, b), int(((a+b)-(min(a, b)*2))/2))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long int n;
int a[10];
string s = "codeforces";
cin >> n;
long long int p = 1, ans = 0;
int pos = 0;
for (int i = 0; i < 10; i++) a[i] = 1;
while (p < n) {
p = p / a[pos];
a[pos]++;
p = p * a[pos];
pos++;
pos = pos % 10;
}
for (int i = 0; i < 10; i++) {
cout << string(a[i], s[i]);
}
}
| 1,500 | CPP |
n=int(input())
lst=input()
lst=lst.split()
for i in range(0,len(lst)):
lst[i]=int(lst[i])
mini=min(lst)
maxi=max(lst)
lst1=[i for i,val in enumerate(lst) if val==mini]
if lst.index(maxi)>max(lst1):
count = lst.index(maxi) + abs(max(lst1) - (len(lst) - 1)) - 1
else:
count=lst.index(maxi)+abs(max(lst1)-(len(lst) - 1))
print(count)
| 800 | PYTHON3 |
print(sum([int(i) for i in input().split()]))
| 1,500 | PYTHON3 |
n = int(input())
counter = 0
for i in range(n):
votes = list(map(int, input().split()))
if votes[0] + votes[1] + votes[2] > 1:
counter += 1
print(counter) | 800 | PYTHON3 |
p,q,t1=map(int,input().split())
if p-q>t1:
print(t1+1)
elif p-q==t1:
print(t1)
else:
print(p-q) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> a;
int n, t;
while (cin >> n) {
a.clear();
for (int i = 0; i < n; i++) {
cin >> t;
a.push_back(t);
}
sort(a.begin(), a.end());
t = a[0];
a[0] = a[a.size() - 1];
a[a.size() - 1] = t;
for (int i = 0; i < a.size(); i++) {
if (i == 0)
cout << a[i];
else
cout << " " << a[i];
}
cout << endl;
}
return 0;
}
| 1,300 | CPP |
n = int(input())
s = str(input())
test_list = s.split()
sum = 0
for i in range(0, len(test_list)):
test_list[i] = int(test_list[i])
sum += test_list[i]
list.sort(test_list, reverse = True)
temp = test_list[0]
for i in range(1,n+1):
if(temp > sum-temp):
print(i)
break
temp += (test_list[i])
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class L>
bool smax(T &x, L y) {
return x < y ? (x = y, 1) : 0;
}
template <class T, class L>
bool smin(T &x, L y) {
return y < x ? (x = y, 1) : 0;
}
const int maxn = 1e3 + 17;
int n, a[maxn][maxn];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < n - 1; j++)
if (i != j) a[i][j] = (i + j) % (n - 1) + 1;
for (int i = 0; i < n - 1; i++)
a[i][n - 1] = a[n - 1][i] = 2 * i % (n - 1) + 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cout << a[i][j] << " \n"[j == n - 1];
return 0;
}
| 2,100 | CPP |
a, b, c, d, e, f = map(int, input().split())
ca = a * 2 + 1
lo = 1
hi = min(b, f)
l = hi - lo + 1
sol = ca * l + l * (l-1)
#print(ca, sol)
ca = a * 2 + 1 + l + (l-1)
lo = hi + 1
hi = max(b, f)
l = hi - lo + 1
sol += ca * l
#print(ca, sol)
ca = d * 2 + 1
lo = 1
hi = min(c, e)
l = hi - lo + 1
sol += ca * l + l * (l-1)
#print(ca, sol)
print(sol)
| 1,600 | PYTHON3 |
from math import gcd
n, m, k = [int(i) for i in input().split()]
if 2 * n * m % k != 0:
print("NO")
else:
flag = False
if k % 2 == 0:
k //= 2
flag = True
g = gcd(n, k)
ks, ns = k // g, n // g
b = m // ks
if flag is False:
if ns < n:
ns *= 2
else:
b *= 2
print("YES")
print(0, 0)
print(ns, 0)
print(0, b)
| 1,800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 17000;
const int M = 1000;
const int mod = 1e9 + 7;
int n, k;
long long c[N][M];
map<int, int> g;
void init() {
c[0][0] = 1;
for (int i = 1; i < N; i++) {
for (int j = 0; j <= i && j < M; j++) {
if (j == 0 || j == i)
c[i][j] = 1;
else
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
}
}
void solve(long long k) {
for (int j = 2; j * j <= k; j++)
if (k % j == 0) {
int cnt = 0;
while (k % j == 0) {
k /= j;
cnt++;
}
g[j] += cnt;
}
if (k > 1) g[k] += 1;
}
int main() {
init();
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &k);
solve(k);
}
long long ans = 1;
for (map<int, int>::iterator i = g.begin(); i != g.end(); i++) {
int t = (*i).second;
ans = (ans * c[t + n - 1][n - 1]) % mod;
}
cout << ans << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 101000;
int l[N], r[N], l2[N], r2[N], f[N], col[N], chs[N], vis[N];
int n, T, t, m, cnt, u, v;
vector<int> e[N], vec;
vector<pair<int, pair<int, int> > > Evt, evt;
multiset<int> ml, mr;
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
void dfs(int u, int c) {
vis[u] = 1;
vec.push_back(u);
col[u] = c;
for (auto v : e[u]) {
if (!vis[v]) {
dfs(v, c ^ 1);
} else {
if ((col[v] ^ col[u]) != 1) throw 1;
}
}
}
void add(int x1, int x2, int y1, int y2) {
assert(x1 <= x2 && y1 <= y2);
Evt.push_back(make_pair(x1, make_pair(y1, 1)));
Evt.push_back(make_pair(x1, make_pair(y2, 2)));
Evt.push_back(make_pair(x2, make_pair(y1, 3)));
Evt.push_back(make_pair(x2, make_pair(y2, 4)));
}
void build(int x1, int x2, int y1, int y2) {
assert(x1 <= x2 && y1 <= y2);
evt.clear();
evt.push_back(make_pair(x1 * 2, make_pair(y1, 1)));
evt.push_back(make_pair(x1 * 2, make_pair(y2, 2)));
evt.push_back(make_pair(x2 * 2 + 1, make_pair(y1, 3)));
evt.push_back(make_pair(x2 * 2 + 1, make_pair(y2, 4)));
swap(x1, y1);
swap(x2, y2);
evt.push_back(make_pair(x1 * 2, make_pair(y1, 1)));
evt.push_back(make_pair(x1 * 2, make_pair(y2, 2)));
evt.push_back(make_pair(x2 * 2 + 1, make_pair(y1, 3)));
evt.push_back(make_pair(x2 * 2 + 1, make_pair(y2, 4)));
sort((evt).begin(), (evt).end());
ml.clear();
mr.clear();
for (int i = 0; i < ((int)(evt).size()); i++) {
if (evt[i].second.second == 1) ml.insert(evt[i].second.first);
if (evt[i].second.second == 2) mr.insert(evt[i].second.first);
if (evt[i].second.second == 3) ml.erase(ml.find(evt[i].second.first));
if (evt[i].second.second == 4) mr.erase(mr.find(evt[i].second.first));
if (i != ((int)(evt).size()) - 1 && evt[i].first != evt[i + 1].first) {
if (((int)(ml).size()))
add(evt[i].first, evt[i + 1].first, *ml.begin(), *mr.rbegin());
}
}
}
void gao(int x, int y) {
puts("POSSIBLE");
printf("%d %d\n", x, y);
for (int i = 1; i < n + 1; i++)
if (find(i) == i) {
if (l[i] <= x && x <= r[i] && l2[i] <= y && y <= r2[i])
chs[i] = 0;
else
chs[i] = 1;
}
for (int i = 1; i < n + 1; i++) putchar('1' + (chs[find(i)] ^ col[i]));
}
bool check(int x1, int x2, int y1, int y2) {
if (x1 > x2 || y1 > y2) return 0;
if (x2 + y2 < t || x1 + y1 > T) return 0;
if (t <= x1 + y1 && x2 + y2 <= T) {
gao(x1, y1);
return 1;
}
if (x1 + y1 < t && x2 + y2 <= T) {
gao(x2, y2);
return 1;
}
if (t <= x1 + y1 && T < x2 + y2) {
gao(x1, y1);
return 1;
}
if (x1 + y1 < t && T < x2 + y2) {
if (T - x1 <= y2 && T - x1 >= y1)
gao(x1, T - x1);
else if (t - x1 <= y2 && t - x1 >= y1)
gao(x1, t - x1);
else if (T - y1 <= x2 && T - y1 >= x1)
gao(T - y1, y1);
else if (t - y1 <= x2 && t - y1 >= x1)
gao(t - y1, y1);
else if (T - x2 <= y2 && T - x2 >= y1)
gao(x2, T - x2);
else if (t - x2 <= y2 && t - x2 >= y1)
gao(x2, t - x2);
else if (T - y2 <= x2 && T - y2 >= x1)
gao(T - y2, y2);
else if (t - y2 <= x2 && t - y2 >= x1)
gao(t - y2, y2);
return 1;
}
}
bool cmp(pair<int, pair<int, int> > a, pair<int, pair<int, int> > b) {
return make_pair(a.first, make_pair(-a.second.second, a.second.first)) <
make_pair(b.first, make_pair(-b.second.second, b.second.first));
}
int main() {
scanf("%d%d", &t, &T);
scanf("%d%d", &n, &m);
for (int i = 1; i < n + 1; i++)
scanf("%d%d", l + i, r + i), l2[i] = 0, r2[i] = 1000000001;
for (int i = 1; i < n + 1; i++) f[i] = i;
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
f[find(u)] = find(v);
e[u].push_back(v);
e[v].push_back(u);
}
for (int i = 1; i < n + 1; i++)
if (!vis[i]) {
vec.clear();
try {
dfs(i, 0);
} catch (int e) {
puts("IMPOSSIBLE");
return 0;
}
int pl = 0, pr = 1000000001, ql = 0, qr = 1000000001;
for (auto j : vec) {
if (col[j] == 0)
pl = max(pl, l[j]), pr = min(pr, r[j]);
else
ql = max(ql, l[j]), qr = min(qr, r[j]);
}
if (pl > pr || ql > qr) {
puts("IMPOSSIBLE");
return 0;
}
int p = find(i);
l[p] = pl, r[p] = pr;
l2[p] = ql, r2[p] = qr;
}
for (int i = 1; i < n + 1; i++)
if (find(i) == i) {
build(l[i], r[i], l2[i], r2[i]);
cnt++;
}
evt = Evt;
sort((evt).begin(), (evt).end(), cmp);
ml.clear();
mr.clear();
for (int i = 0; i < ((int)(evt).size()); i++) {
if (evt[i].second.second == 1) ml.insert(evt[i].second.first);
if (evt[i].second.second == 2) mr.insert(evt[i].second.first);
if (evt[i].second.second == 3) ml.erase(ml.find(evt[i].second.first));
if (evt[i].second.second == 4) mr.erase(mr.find(evt[i].second.first));
if (i != ((int)(evt).size()) - 1 && evt[i].first != evt[i + 1].first &&
((int)(ml).size()) == cnt) {
if (check((evt[i].first + 1) / 2, (evt[i + 1].first + 1) / 2 - 1,
*ml.rbegin(), *mr.begin())) {
return 0;
}
}
}
puts("IMPOSSIBLE");
}
| 3,200 | CPP |
'''
6
1 1 1
1 2 1
4 1 1
7 4 10
8 1 4
8 2 8
'''
n=int(input())
for i in range(0,n):
p=input().rstrip().split(' ')
p.sort(key=int,reverse=True)
A=int(p[0])-int(p[1])
if A>=int(p[2]):
print(int(p[2])+int(p[1]))
else:
p[2]=int(p[2])-A;
ans = A;
p[0]=int(p[0])-A;
D=(int(p[0])+int(p[1])+int(p[2]))//2;
ans+=D;
print(ans) | 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, k = 0;
cin >> n >> m;
long long int a[n + 5], b[m + 5], c[n + m + 5];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (b[i] == a[j]) {
c[k] = j;
k++;
}
}
}
sort(c, c + k);
for (int i = 0; i < k; i++) {
cout << a[c[i]] << " ";
}
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int M = 32768;
enum { IF_RET, RET, GT, LT, EQ, ADD, SUB, MUL, DIV, VAR, NUM, FUNC };
struct Node {
int op, v;
Node *pt0, *pt1;
Node() {}
void set(int _op, int _v, Node *_pt0, Node *_pt1) {
op = _op, v = _v, pt0 = _pt0, pt1 = _pt1;
}
void print() {
switch (op) {
case IF_RET:
printf("if (");
pt0->print();
printf(") return ");
pt1->print();
puts(";");
break;
case RET:
printf("return ");
pt0->print();
puts(";");
break;
case GT:
pt0->print();
printf(">");
pt1->print();
break;
case LT:
pt0->print();
printf("<");
pt1->print();
break;
case EQ:
pt0->print();
printf("==");
pt1->print();
break;
case ADD:
pt0->print();
printf("+");
pt1->print();
break;
case SUB:
pt0->print();
printf("-");
pt1->print();
break;
case MUL:
pt0->print();
printf("*");
pt1->print();
break;
case DIV:
pt0->print();
printf("/");
pt1->print();
break;
case VAR:
putchar('n');
break;
case NUM:
printf("%d", v);
break;
case FUNC:
printf("f(");
pt0->print();
printf(")");
break;
}
}
};
typedef vector<Node *> vnpt;
char s[8], ss[128][8];
Node buf[128], *bpt = buf;
int fs[M];
int readword(char *cpt) {
int c = getchar();
while (c <= ' ') c = getchar();
*(cpt++) = c;
int l = 1;
if (!islower(c) && !isdigit(c)) {
*cpt = '\0';
return l;
}
while (islower(c = getchar()) || isdigit(c)) {
*(cpt++) = c;
l++;
}
*cpt = '\0';
ungetc(c, stdin);
return l;
}
Node *expr(int &pos);
Node *multiplier(int &pos) {
Node *npt = bpt++;
if (ss[pos][0] == 'n') {
npt->set(VAR, 0, NULL, NULL);
pos++;
} else if (isdigit(ss[pos][0])) {
npt->set(NUM, atoi(ss[pos]), NULL, NULL);
pos++;
} else {
pos += 2;
Node *npt0 = expr(pos);
pos++;
npt->set(FUNC, 0, npt0, NULL);
}
return npt;
}
Node *product(int &pos) {
Node *npt = multiplier(pos);
while (ss[pos][0] == '*' || ss[pos][0] == '/') {
char op = ss[pos++][0];
Node *npt0 = npt;
Node *npt1 = multiplier(pos);
npt = bpt++;
npt->set((op == '*') ? MUL : DIV, 0, npt0, npt1);
}
return npt;
}
Node *expr(int &pos) {
Node *npt = product(pos);
while (ss[pos][0] == '+' || ss[pos][0] == '-') {
char op = ss[pos++][0];
Node *npt0 = npt;
Node *npt1 = product(pos);
npt = bpt++;
npt->set((op == '+') ? ADD : SUB, 0, npt0, npt1);
}
return npt;
}
Node *lexpr(int &pos) {
Node *npt0 = expr(pos);
char op = ss[pos++][0];
if (op == '=') pos++;
Node *npt1 = expr(pos);
Node *npt = bpt++;
npt->set((op == '>') ? GT : (op == '<') ? LT : EQ, 0, npt0, npt1);
return npt;
}
void parse_func(vnpt &fv, int &pos) {
fv.clear();
pos += 7;
while (ss[pos][0] != '}') {
Node *npt = bpt++;
if (ss[pos][0] == 'i') {
pos += 2;
Node *npt0 = lexpr(pos);
pos += 2;
Node *npt1 = expr(pos);
pos++;
npt->set(IF_RET, 0, npt0, npt1);
} else {
pos++;
Node *npt0 = expr(pos);
pos++;
npt->set(RET, 0, npt0, NULL);
}
fv.push_back(npt);
}
}
int calc_expr(Node *npt, int n);
int calc_multiplier(Node *npt, int n) {
if (npt->op == VAR) return n;
if (npt->op == NUM) return npt->v;
return fs[calc_expr(npt->pt0, n)];
}
int calc_product(Node *npt, int n) {
if (npt->op != MUL && npt->op != DIV) return calc_multiplier(npt, n);
int p0 = calc_product(npt->pt0, n);
int p1 = calc_multiplier(npt->pt1, n);
return (npt->op == MUL) ? p0 * p1 % M : p0 / p1;
}
int calc_expr(Node *npt, int n) {
if (npt->op != ADD && npt->op != SUB) return calc_product(npt, n);
int e0 = calc_expr(npt->pt0, n);
int e1 = calc_product(npt->pt1, n);
return (npt->op == ADD) ? (e0 + e1) % M : (e0 + M - e1) % M;
}
int calc_lexpr(Node *npt, int n) {
int e0 = calc_expr(npt->pt0, n);
int e1 = calc_expr(npt->pt1, n);
if (npt->op == GT) return (e0 > e1);
if (npt->op == LT) return (e0 < e1);
return (e0 == e1);
}
int calc_f(vnpt &fv, int n) {
for (vnpt::iterator vit = fv.begin(); vit != fv.end(); vit++) {
Node *npt = *vit;
if (npt->op == IF_RET) {
int le = calc_lexpr(npt->pt0, n);
if (le) return calc_expr(npt->pt1, n);
} else
return calc_expr(npt->pt0, n);
}
return 0;
}
int main() {
int fn;
scanf("%d", &fn);
for (int k = 0; readword(ss[k]) && ss[k][0] != '}'; k++)
;
vnpt fv;
int pos = 0;
parse_func(fv, pos);
int ans = -1;
for (int n = 0; n < M; n++) {
fs[n] = calc_f(fv, n);
if (fs[n] == fn) ans = n;
}
printf("%d\n", ans);
return 0;
}
| 2,400 | CPP |
a,b=map(int,input().split())
k=0
for i in range(a,b+1):
c=0
x=list(str(i))
for j in range(0,len(x)):
if(x.count(x[j])==1):
c=c+1
if(c==len(x)):
print(i)
k=-1
break
if(k==0):
print(-1) | 800 | PYTHON3 |
"""
author: picpanda
dated : 8:02 PM
"""
n = int(input())
s = input()
count = 0
for i in range(1, n):
if (s[i-1] == s[i]):
count += 1
print(count) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 323;
int a[maxN][maxN], n, m;
bool fl1, fl2;
int t(int x, int y) {
if (min(x, y) < 0) return 0;
return a[x][y];
}
bool ok(int x, int y, int color) {
if (min(x, y) < 0 || x >= n || y >= m) return 1;
return t(x, y) != color;
}
int best(int x, int y) {
if (y >= m || x >= n) return 5;
for (int c = 1; c <= 4; c++)
if (ok(x - 1, y, c) && ok(x, y - 1, c) && ok(x + 1, y, c) &&
ok(x, y + 1, c))
return c;
}
void paint(int x, int y) {
if (y >= m || x >= n) return;
int c = best(x, y), d;
d = 1;
a[x][y] = c;
int c2 = best(x, y + 1);
a[x][y] = 0;
if (c2 >= c) {
bool flag = 1;
while (flag) {
d++;
for (int i = 0; i < d; i++)
for (int j = 0; j < d; j++) {
x += i;
y += j;
if (!(x < n && y < m && !a[x][y] && ok(x - 1, y, c) &&
ok(x, y - 1, c) && ok(x + 1, y, c) && ok(x, y + 1, c)))
flag = 0;
x -= i;
y -= j;
}
}
d--;
}
for (int xs = 0; xs < d; xs++)
for (int ys = 0; ys < d; ys++) a[x + xs][y + ys] = c;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (!a[i][j]) paint(i, j);
for (int i = 0; i < n; i++, cout << endl)
for (int j = 0; j < m; j++) cout << char(a[i][j] - 1 + 'A');
cin >> n;
}
| 2,300 | CPP |
def main():
N = 505
C = []
for i in range(N):
C.append([])
for j in range(N):
C[i].append(0)
for i in range(N):
C[i][i] = 1
for i in range(N):
C[i][0] = 1
for i in range(2, N):
for k in range(1, i):
C[i][k] = C[i - 1][k - 1] + C[i - 1][k]
n = int(input())
print(C[n][5] * C[n][5] * 120)
main() | 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
scanf("%d%d", &a, &b);
if (b == a) {
printf("infinity");
return 0;
}
if (b > a) {
printf("0");
return 0;
}
int ans = 0;
int m = a - b;
int sq = sqrt(m);
for (int i = 1; i <= sq; i++) {
if (m % i == 0) {
int temp = m / i;
if (a % i == b) ans++;
if (a % temp == b && temp != i) ans++;
}
}
printf("%d", ans);
return 0;
}
| 1,600 | CPP |
n = int(input())
p = list(map(int,input().split()))
a = 0
count = 0
for i in p:
a += i
print(a/n)
| 800 | PYTHON3 |
n=int(input())
A=[int(item)for item in input().split()]
for i in range(n):
if(A[i]%2==0):
A[i]-=1
if(i==n-1):
print(A[i])
else:
print(A[i],end=" ")
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n, p;
long double sum = 0;
pair<int, int> a[100007];
scanf("%d%d", &n, &p);
for (long long i = 0; i <= (long long)n - 1; ++i) {
int l, r;
scanf("%d%d", &l, &r);
a[i] = {r / p - (l - 1) / p, r - l + 1};
}
for (int i = 0; i < n; i++) {
long long aa = a[i].second - a[i].first;
long long bb = a[(i + 1) % n].second - a[(i + 1) % n].first;
long double k =
1 - ((aa * 1.0 / a[i].second) * (bb * 1.0 / a[(i + 1) % n].second));
sum += k * 2000;
}
cout << fixed << setprecision(10) << sum;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
int main() {
long long a[maxn];
for (int i = 1; i < maxn; i++) {
int x = 2 * i - 1;
a[i] = (x * x) / 2 + 1;
}
long long x;
cin >> x;
if (x == 3)
printf("5\n");
else {
long long ans = lower_bound(a + 1, a + maxn + 1, x) - a;
cout << 2 * (ans)-1 << endl;
}
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, A[200010];
cin >> n;
int total = 0;
for (int i = 0; i < n; i++) {
cin >> A[i];
total += A[i];
}
int cur = 0;
int d = 0;
while (cur * 2 < total) {
cur += A[d++];
}
cout << d << endl;
return 0;
}
| 1,300 | CPP |
t=int(input())
a=[]
count=0
for z in range(t):
n,m=map(int,input().split())
a.append(n)
a.append(m)
k=int(input())
for i in a:
if(i>k):
count+=1
print(count//2 + 1) | 800 | PYTHON3 |
#include <bits/stdc++.h>
const int N = 505, INF = 0x7f7f7f7f;
int num[N], dp[N][N];
inline void Min(int &a, int b) {
if (b < a) a = b;
}
int DP(int L, int R) {
if (dp[L][R] < INF) return dp[L][R];
int &res = dp[L][R];
if (L > R)
res = 0;
else if (L == R)
res = 1;
else {
res = DP(L + 1, R) + 1;
if (num[L] == num[L + 1]) Min(res, DP(L + 2, R) + 1);
for (int k = L + 2; k <= R; ++k)
if (num[k] == num[L]) Min(res, DP(L + 1, k - 1) + DP(k + 1, R));
}
return res;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &num[i]);
memset(dp, 127, sizeof(dp));
printf("%d\n", DP(1, n));
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t, n;
cin >> t;
vector<pair<int, pair<int, int>>> v;
for (int j = 0; j < t; j++) {
cin >> n;
int a[n], su = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
su += a[i];
}
for (int i = 0; i < n; i++) {
v.push_back({su - a[i], {j, i}});
}
}
int in = 1;
sort(v.begin(), v.end());
for (int i = 0; i < v.size() - 1; i++) {
if (v[i].first == v[i + 1].first &&
v[i].second.first != v[i + 1].second.first) {
cout << "YES\n";
cout << v[i].second.first + 1 << " " << v[i].second.second + 1 << endl;
cout << v[i + 1].second.first + 1 << " " << v[i + 1].second.second + 1
<< endl;
in = 0;
break;
}
}
if (in == 1) cout << "NO\n";
}
| 1,400 | CPP |
print('9' * 200 + '0' * 199 + '1')
print('9' * 200) | 1,200 | PYTHON3 |
matrix = []
loop = 0
moves = 0
while loop < 5:
usr = input('')
usr = usr.split(' ')
usr = [int(n) for n in usr]
matrix.append(usr)
loop += 1
for items in matrix:
if 1 in items:
row_index = matrix.index(items)
one_index = items.index(1)
if row_index == 2:
if one_index == 2:
print(0)
break
else:
if one_index > 2:
print(one_index-2)
else:
print(2-one_index)
break
else:
if one_index == 2:
if row_index > 2:
print(row_index-2)
else:
print(2-row_index)
else:
if row_index > 2:
moves += row_index - 2
else:
moves += 2 - row_index
if one_index > 2:
moves += one_index - 2
else:
moves += 2 - one_index
print(moves)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int ms = 2e5 + 100;
const int sigma = 30;
int n, m, k, t;
string s, c;
int vert[ms];
void solve() {
cin >> n >> m;
memset(vert, 0, sizeof vert);
int ans = 5;
int qt = 0, total = 0;
for (int i = 0; i < n; i++) {
cin >> s;
total += s.size();
bool v = 1;
for (int j = 0; j < m; j++) {
if (s[j] != 'A') v = 0;
}
if (v) {
int cur = 2;
if (i == 0) cur--;
if (i == n - 1) cur--;
ans = min(ans, cur);
}
for (int j = 0; j < m; j++) {
if (s[j] == 'A') {
qt++;
vert[j]++;
int cur = 4;
if (vert[j] == n) {
ans = min(ans, 2 - ((j == 0) + (j == m - 1)));
}
if (i == 0) cur--;
if (i == n - 1) cur--;
if (j == 0) cur--;
if (j == m - 1) cur--;
ans = min(ans, cur);
}
}
}
if (qt == total) {
ans = 0;
}
if (ans == 5) {
cout << "MORTAL" << endl;
return;
}
cout << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
while (t--) {
solve();
}
}
| 1,800 | CPP |
#include <bits/stdc++.h>
template <class T>
inline T sqr(T x) {
return x * x;
}
#pragma comment(linker, "/STACK:64000000")
using namespace std;
using namespace std;
struct point {
int x, y, ind;
};
bool is_rect(vector<point> p) {
return ((p[1].x - p[0].x) * (p[2].x - p[1].x) +
(p[1].y - p[0].y) * (p[2].y - p[1].y) ==
0 &&
(p[2].x - p[1].x) * (p[3].x - p[2].x) +
(p[2].y - p[1].y) * (p[3].y - p[2].y) ==
0 &&
(p[3].x - p[2].x) * (p[0].x - p[3].x) +
(p[3].y - p[2].y) * (p[0].y - p[3].y) ==
0 &&
(p[0].x - p[3].x) * (p[1].x - p[0].x) +
(p[0].y - p[3].y) * (p[1].y - p[0].y) ==
0);
}
bool is_q(vector<point> p) {
return (sqr(p[0].x - p[1].x) + sqr(p[0].y - p[1].y) ==
sqr(p[1].x - p[2].x) + sqr(p[1].y - p[2].y) &&
sqr(p[1].x - p[2].x) + sqr(p[1].y - p[2].y) ==
sqr(p[2].x - p[3].x) + sqr(p[2].y - p[3].y) &&
sqr(p[2].x - p[3].x) + sqr(p[2].y - p[3].y) ==
sqr(p[3].x - p[0].x) + sqr(p[3].y - p[0].y));
}
void wr(vector<point> p1, vector<point> p2) {
cout << "YES" << endl;
for (int i = 0; i < 4; ++i) cout << p1[i].ind << " ";
cout << endl;
for (int i = 0; i < 4; ++i) cout << p2[i].ind << " ";
}
bool comper(point l, point r) {
if (l.x == r.x) return l.y < r.y;
return l.x < r.x;
}
int main() {
point p[8];
for (int i = 0; i < 8; ++i) {
scanf("%d %d", &p[i].x, &p[i].y);
p[i].ind = i + 1;
}
int a[8];
memset(a, 0, sizeof a);
for (int i = 0; i < (1 << 8) + 1; ++i) {
for (int j = 0; j < 8; ++j) {
if (a[j]) {
a[j] = 0;
continue;
}
a[j] = 1;
break;
}
int q = 0;
vector<point> sol(4), sol1(4);
for (int j = 0; j < 8; ++j)
if (a[j]) {
if (q == 4) {
q++;
break;
}
sol[q++] = p[j];
}
if (q != 4) continue;
q = 0;
for (int j = 0; j < 8; ++j)
if (!a[j]) sol1[q++] = p[j];
sort(sol.begin(), sol.end(), comper);
sort(sol1.begin(), sol1.end(), comper);
if ((sol[1].x - sol[0].x) * (sol[3].y - sol[1].y) -
(sol[1].y - sol[0].y) * (sol[3].x - sol[1].x) >
0)
swap(sol[1], sol[2]);
if ((sol1[1].x - sol1[0].x) * (sol1[3].y - sol1[1].y) -
(sol1[1].y - sol1[0].y) * (sol1[3].x - sol1[1].x) >
0)
swap(sol1[1], sol1[2]);
swap(sol[3], sol[2]);
swap(sol1[3], sol1[2]);
if (is_rect(sol) && is_rect(sol1)) {
if (is_q(sol)) {
wr(sol, sol1);
return 0;
}
if (is_q(sol1)) {
wr(sol1, sol);
return 0;
}
}
}
cout << "NO";
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 70000;
int l[N], r[N], fa[N];
int n, m;
long long ans = 0;
struct mes {
long long sumS;
int sz;
int xu;
long long xuS;
long long dui;
} a[N], val[N];
inline mes operator+(const mes &a, const mes &b) {
mes c;
c.sumS = a.sumS + b.sumS;
c.sz = a.sz + b.sz;
c.xu = a.xu + b.xu;
c.xuS = a.xuS + b.xuS;
return c;
}
inline bool top(int x) { return (!fa[x]) || (l[fa[x]] != x && r[fa[x]] != x); }
inline void up(int x) {
a[x] = val[x];
if (l[x]) a[x] = a[x] + a[l[x]];
if (r[x]) a[x] = a[x] + a[r[x]];
}
inline void left(int x) {
int y = fa[x];
int z = fa[y];
r[y] = l[x];
if (l[x]) fa[l[x]] = y;
fa[x] = z;
if (l[z] == y)
l[z] = x;
else if (r[z] == y)
r[z] = x;
fa[y] = x;
l[x] = y;
up(y);
up(x);
}
inline void right(int x) {
int y = fa[x];
int z = fa[y];
l[y] = r[x];
if (r[x]) fa[r[x]] = y;
fa[x] = z;
if (l[z] == y)
l[z] = x;
else if (r[z] == y)
r[z] = x;
fa[y] = x;
r[x] = y;
up(y);
up(x);
}
inline void splay(int x) {
while (!top(x)) {
int y = fa[x];
int z = fa[y];
if (top(y)) {
if (l[y] == x)
right(x);
else
left(x);
} else {
if (r[z] == y) {
if (r[y] == x)
left(y), left(x);
else
right(x), left(x);
} else {
if (l[y] == x)
right(y), right(x);
else
left(x), right(x);
}
}
}
}
int getL(int x) {
while (l[x]) x = l[x];
return x;
}
inline int access(int x) {
int y = 0;
for (; x; y = x, x = fa[x]) {
splay(x);
int rx = r[x];
r[x] = 0;
if (rx) {
rx = getL(rx);
splay(rx);
val[x].xu += a[rx].xu + a[rx].sz;
val[x].dui += (a[rx].xu + a[rx].sz) * 1ll * (a[rx].xu + a[rx].sz);
val[x].xuS = val[x].xu * 1ll * val[x].sumS;
up(x);
}
if (y) {
splay(y);
val[x].xu -= a[y].xu + a[y].sz;
val[x].xuS = val[x].xu * 1ll * val[x].sumS;
val[x].dui -= (a[y].xu + a[y].sz) * 1ll * (a[y].xu + a[y].sz);
r[x] = y;
up(x);
}
}
return y;
}
int p[N];
vector<int> son[N];
void dfs(int x) {
val[x].sz = 1;
ans += val[x].sumS;
for (vector<int>::iterator it = son[x].begin(); it != son[x].end(); it++) {
dfs(*it);
ans += val[x].sz * 2ll * val[*it].sz * val[x].sumS;
val[x].xu += val[*it].sz;
val[x].sz += val[*it].sz;
val[x].dui += val[*it].sz * 1ll * val[*it].sz;
fa[*it] = x;
}
val[x].xuS = val[x].xu * 1ll * val[x].sumS;
}
void duan(int x) {
access(p[x]);
int v = p[x];
splay(x);
fa[x] = 0;
p[x] = 0;
int SS = a[x].sz + a[x].xu;
splay(v);
val[v].dui -= SS * 1ll * SS;
val[v].xu -= SS;
val[v].xuS = val[v].xu * 1ll * val[v].sumS;
up(v);
ans -= a[v].xuS * 2ll * SS;
ans -= a[v].sumS * 2ll * SS;
}
void lian(int x, int v) {
access(x);
access(v);
splay(x);
splay(v);
fa[x] = v;
p[x] = v;
int SS = a[x].sz + a[x].xu;
ans += a[v].xuS * 2ll * SS;
ans += a[v].sumS * 2ll * SS;
val[v].dui += 1ll * SS * SS;
val[v].xu += SS;
val[v].xuS = val[v].xu * 1ll * val[v].sumS;
up(v);
}
int main() {
scanf("%d", &n);
for (int i = (2); i <= (int)n; i++) {
scanf("%d", &p[i]);
son[p[i]].push_back(i);
}
for (int i = (1); i <= (int)n; i++) {
scanf("%I64d", &val[i].sumS);
}
dfs(1);
for (int i = (1); i <= (int)n; i++) {
val[i].sz = 1;
up(i);
}
scanf("%d", &m);
while (m--) {
printf("%.10lf\n", ans / (1. * n * n));
char opt[3];
scanf("%s", opt + 1);
if (opt[1] == 'P') {
int u, v;
scanf("%d%d", &v, &u);
access(u);
int lca = access(v);
if (lca == v) {
duan(u);
lian(u, v);
} else {
duan(v);
lian(v, u);
}
} else {
int u, v;
scanf("%d%d", &u, &v);
access(u);
splay(u);
int del = v - val[u].sumS;
val[u].sumS = v;
val[u].xuS = val[u].sumS * 1ll * val[u].xu;
up(u);
ans += 1ll * del * ((1 + val[u].xu) * 1ll * (1 + val[u].xu) - val[u].dui);
}
}
printf("%.10lf\n", ans / (1. * n * n));
return 0;
}
| 3,200 | CPP |
s=input()
r,l,d,u=s.count('R'),s.count('L'),s.count('U'),s.count('D')
a,b=abs(r-l),abs(d-u)
if((a+b)%2==1):
print(-1)
else:
print(int(abs(a-b)+(a+b-2*abs(a-b))/2))
| 1,100 | PYTHON3 |
t = int(input())
def solve(n, nums):
if n == 1:
return 0
mx = 0
cnts = {}
st = set()
for num in nums:
if num not in cnts:
cnts[num] = 0
cnts[num] += 1
st.add(num)
cnts = {k: v for k, v in sorted(cnts.items(), key=lambda item: -item[1])}
for k in cnts.keys():
cur = cnts[k]
sol1 = min(cur - 1, len(st))
sol2 = min(cur, len(st) - 1)
mx = max(mx, max(sol1, sol2))
return mx
for _ in range(t):
n = int(input())
nums = list(map(int, input().split()))
print(solve(n, nums)) | 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int limit = 1000000;
int amount[limit];
void insert(int pos, int a) {
for (; pos; pos -= pos & -pos) amount[pos] += a;
}
int amountnext(int pos) {
int s = 0;
for (; pos < limit; pos += pos & -pos) s += amount[pos];
return s;
}
void insertinv(int pos, int a) {
for (; pos < limit; pos += pos & -pos) amount[pos] += a;
}
int amountinv(int pos) {
int s = 0;
for (; pos; pos -= pos & -pos) s += amount[pos];
return s;
}
int n, m;
vector<int> g[limit];
vector<int> ginv[limit];
queue<int> q;
int arity[limit];
int arityinv[limit];
int nnode = 1;
int node[limit];
int position[limit];
int sol;
int desp[limit];
int init[limit];
int initinv[limit];
bool compare(int u, int v) { return position[u] < position[v]; }
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
ginv[v].push_back(u);
arity[v]++;
arityinv[u]++;
}
for (int u = 1; u <= n; u++) {
if (arity[u] == 0) init[u] = 1;
if (arityinv[u] == 0) initinv[u] = 1;
}
for (int u = 1; u <= n; u++) {
if (arity[u] == 0) {
q.push(u);
position[u] = nnode;
node[nnode++] = u;
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
vector<int> &ar = g[u];
for (int i = 0; i < int(ar.size()); i++) {
int v = ar[i];
arity[v]--;
if (arity[v] == 0) {
q.push(v);
position[v] = nnode;
node[nnode++] = v;
}
}
}
for (int u = 1; u <= n; u++) {
vector<int> &ar = g[u];
sort(ar.begin(), ar.end(), compare);
vector<int> &arinv = ginv[u];
sort(arinv.begin(), arinv.end(), compare);
reverse(arinv.begin(), arinv.end());
}
for (int i = 1; i <= n; i++) {
int u = node[i];
int add = amountnext(i);
desp[u] += add;
vector<int> &aru = g[u];
if (int(aru.size()) == 0) {
insert(n, 1);
continue;
}
int ri = position[aru[0]];
insert(ri - 1, 1);
int v = node[ri];
vector<int> &arv = g[v];
if (int(arv.size()) == 0) {
int RI = n + 1;
if (1 < int(aru.size())) RI = position[aru[1]];
insert(ri, -2);
insert(RI - 1, 2);
continue;
}
int RI = position[arv[0]];
if (1 < int(aru.size())) RI = min(RI, position[aru[1]]);
insert(ri, -2);
insert(RI - 1, 2);
}
for (int i = 0; i < limit; i++) amount[i] = 0;
for (int i = n; i >= 1; i--) {
int u = node[i];
int add = amountinv(i);
desp[u] += add;
vector<int> &aru = ginv[u];
if (int(aru.size()) == 0) {
insertinv(1, 1);
continue;
}
int le = position[aru[0]];
insertinv(le + 1, 1);
int v = node[le];
vector<int> &arv = ginv[v];
if (int(arv.size()) == 0) {
int LE = 0;
if (1 < int(aru.size())) LE = position[aru[1]];
insertinv(le, -2);
insertinv(LE + 1, 2);
continue;
}
int LE = position[arv[0]];
if (1 < int(aru.size())) LE = max(LE, position[aru[1]]);
insertinv(le, -2);
insertinv(LE + 1, 2);
}
for (int u = 1; u <= n; u++) sol += desp[u] <= 1;
cout << sol << endl;
}
| 2,900 | CPP |
for _ in range(int(input())):
n=int(input())
l=[1]*n
print(*l) | 800 | PYTHON3 |
t = int(input())
for i in range(t):
n, x = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
if n == 1:
if a[0]+ b[0] <= x: print("Yes")
else: print("No")
else:
tracker = False
for j in range(n):
if a[j] + b[n-j-1] > x:
tracker = True
break
if not tracker: print("Yes")
else: print("No")
if i != t-1:
s = input() | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<string> ans;
map<string, int> lo;
string s[100], V[55];
long long int n, m, k, done[100], fyes = -1;
void give() {
string T = "abcdef";
do {
ans.push_back(T);
} while (next_permutation(T.begin(), T.end()));
for (int i = 0; i < ans.size(); i++) lo[ans[i]] = i;
}
int main() {
give();
cin >> n >> k;
for (int i = 0; i < (n - k + 1); i++) {
cin >> s[i];
if (s[i] == "YES" && fyes == -1) fyes = i;
}
if (fyes != -1) {
for (int i = fyes, j = 0; j < k; i++, j++) V[i] = ans[j];
for (int i = fyes + 1; i < n - k + 1; i++) {
if (s[i] == "YES") {
V[i + k - 1] = ans[lo[V[i]] + k - 1];
} else {
V[i + k - 1] = V[i];
}
}
for (int i = 0; i < fyes; i++) V[i] = V[fyes];
} else {
for (int i = 0; i < n; i++) V[i] = "fuchka";
}
for (int i = 0; i < n; i++) {
V[i][0] = V[i][0] + 'A' - 'a';
cout << V[i] << " ";
}
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5;
int N, K, v[maxn];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> N >> K;
for (int i = 1; i <= N; i++) {
cin >> v[i];
}
int ans, sans = INT_MAX, aux = 0;
for (int l = 1, r = 1; r <= N; r++) {
aux += v[r];
if (r - l + 1 == K) {
if (aux < sans) {
sans = aux;
ans = l;
}
aux -= v[l++];
}
}
cout << ans << '\n';
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxm = 1e6;
struct node {
int to, next;
};
node edge[maxm];
int head[maxn], tot;
void add_edge(int u, int v) {
edge[tot].to = v;
edge[tot].next = head[u];
head[u] = tot++;
}
void init_edge() {
memset(head, -1, sizeof(head));
tot = 0;
}
int p[maxn], ans[maxn];
int dfs(int u) {
if (head[u] == -1) {
ans[u] = 1;
return ans[u];
}
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].to;
dfs(v);
ans[u] += ans[v];
}
}
int main() {
int n;
cin >> n;
init_edge();
for (int i = 2; i <= n; i++) {
cin >> p[i];
add_edge(p[i], i);
}
dfs(1);
sort(ans + 1, ans + 1 + n);
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
const int maxn = 1e5 + 5;
const double Inf = 10000.0;
const double PI = acos(-1.0);
using namespace std;
double h, c, t;
double a;
double f1(int x) { return ((x)*h + (x - 1) * c) / (1.0 * (2 * x - 1)); }
double f2(int x) { return ((x - 1) * h + (x)*c) / (1.0 * (2 * x - 1)); }
int b_1() {
int l = 1, r = 0x3f3f3f3f;
while (l < r) {
int mid = (l + r) / 2;
if (f1(mid) > t)
l = mid + 1;
else
r = mid;
}
double del1 = fabs(t - f1(l));
double del2;
l == 1 ? del2 = 0x3f3f3f3f : del2 = fabs(t - f1(l - 1));
double del3 = fabs(t - a);
if (del3 <= del1 && del3 <= del2) return 2;
if (del1 < del2)
return 2 * l - 1;
else
return 2 * l - 3;
}
int b_2() {
int l = 1, r = 0x3f3f3f3f;
while (l < r) {
int mid = (l + r + 1) / 2;
if (f2(mid) < t)
l = mid;
else
r = mid - 1;
}
double del1 = fabs(t - f1(l));
double del2;
del2 = fabs(t - f1(l + 1));
double del3 = fabs(t - a);
if (del3 <= del1 && del3 <= del2) return 2;
if (del1 < del2)
return 2 * l - 1;
else
return 2 * l + 1;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%lf%lf%lf", &h, &c, &t);
a = (h + c) / 2;
if ((fabs(a - t) < 1e-8) && (fabs(h - t) < 1e-8))
puts("1");
else if ((fabs(a - t) < 1e-8))
puts("2");
else if (t > a) {
printf("%d\n", b_1());
} else
printf("%d\n", b_2());
}
return 0;
}
| 1,700 | CPP |
n,m = int,input; a=n(m()); b=n(m()); c=n(m()); x = [a+b+c,a*b*c,(a+b)*c,a*(b+c),a+b*c,a*b+c]
print(max(x)) | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = LLONG_MAX;
long long int power(long long int a, long long int b) {
if (b == 0) return 1;
long long int ans = power(a, b / 2);
ans = (ans * ans) % mod;
if (b % 2) ans *= a;
return ans % mod;
}
long long int mul(long long int a, long long int n, long long int mod) {
long long int ret;
if (n == 0) return 0;
ret = mul(a, n / 2, mod);
ret = (ret + ret) % mod;
if (n % 2) ret = (ret + a) % mod;
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cin.tie(NULL);
long long int t, n, m, l, r, a, b;
cin >> t;
while (t--) {
cin >> l >> r >> m;
for (long long int i = l; i <= r; i++) {
a = m % i;
if (r - i >= a && m / i > 0) {
cout << i << " " << r << " " << r - a << "\n";
break;
}
if (i - l >= a && m / i > 0) {
cout << i << " " << l + a << " " << l << "\n";
break;
}
a = i - m % i;
if (r - i >= a) {
cout << i << " " << r - a << " " << r << "\n";
break;
}
if (i - l >= a) {
cout << i << " " << i - a << " " << i << "\n";
break;
}
}
}
}
| 1,500 | CPP |
from math import ceil
for _ in range(int(input())):
n, x = map(int, input().split())
a = set(map(int, input().split()))
ans = ceil(x / max(a))
if ans == 1:
if x in a:
pass
else:
ans += 1
print(ans) | 1,300 | PYTHON3 |
points = []
for i in range(3):
a, b = list(map(int, input().split()))
points.append((a, b))
a = points[0]
b = points[1]
c = points[2]
res1 = (b[0] + c[0] - a[0], b[1] + c[1] - a[1])
res2 = (a[0] + b[0] - c[0], a[1] + b[1] - c[1])
res3 = (a[0] + c[0] - b[0], a[1] + c[1] - b[1])
results = list(set(list((res1, res2, res3))))
print(len(results))
for i in range(len(results)):
print(results[i][0], results[i][-1])
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, q;
cin >> n >> q;
vector<int> arr(n + 1);
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
arr.emplace_back(0);
long long up = 0;
long long down = 0;
vector<bool> valid(n + 1);
for (int i = 1; i <= n; i++) {
if (arr[i] > arr[i - 1] && arr[i] > arr[i + 1]) {
up += arr[i];
valid[i] = true;
}
if (arr[i] < arr[i - 1] && arr[i] < arr[i + 1]) {
down += arr[i];
valid[i] = true;
}
}
cout << up - down << '\n';
auto remover = [&](int i) {
if (!valid[i]) {
return;
}
if (arr[i] > arr[i - 1] && arr[i] > arr[i + 1]) {
up -= arr[i];
valid[i] = false;
}
if (arr[i] < arr[i - 1] && arr[i] < arr[i + 1]) {
down -= arr[i];
valid[i] = false;
}
};
auto adicionar = [&](int i) {
if (valid[i]) {
return;
}
if (arr[i] > arr[i - 1] && arr[i] > arr[i + 1]) {
up += arr[i];
valid[i] = true;
}
if (arr[i] < arr[i - 1] && arr[i] < arr[i + 1]) {
down += arr[i];
valid[i] = true;
}
};
while (q--) {
int l, r;
cin >> l >> r;
for (int i = max(1, l - 1); i <= min(n, l + 1); i++) {
remover(i);
}
for (int i = max(1, r - 1); i <= min(n, r + 1); i++) {
remover(i);
}
swap(arr[l], arr[r]);
for (int i = max(1, l - 1); i <= min(n, l + 1); i++) {
adicionar(i);
}
for (int i = max(1, r - 1); i <= min(n, r + 1); i++) {
adicionar(i);
}
cout << up - down << '\n';
}
}
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long N, M;
cin >> N >> M;
vector<vector<long long>> G(N, vector<long long>(N));
vector<long long> deg(N);
for (long long i = 0; i < M; i++) {
long long a, b;
cin >> a >> b;
a--;
b--;
G[a][b] = G[b][a] = 1;
deg[a]++;
deg[b]++;
}
queue<long long> Q;
for (long long i = 0; i < N; i++)
if (deg[i] == 1) {
Q.push(i);
}
long long ans = 0;
while (!Q.empty()) {
ans++;
long long sz = Q.size();
while (sz--) {
long long v = Q.front();
Q.pop();
for (long long u = 0; u < N; u++)
if (G[v][u]) {
G[v][u] = G[u][v] = 0;
deg[v]--;
deg[u]--;
}
}
for (long long i = 0; i < N; i++)
if (deg[i] == 1) {
Q.push(i);
}
}
cout << ans << endl;
return 0;
}
| 1,200 | CPP |
t = int(input())
i = 0
while i < t:
n, p, d = input().split()
n = int(n)
p = int(p)
d = int(d)
if n>d:
print(d)
i = i+1
continue
r = p//d
print(d*(r+1))
i = i + 1 | 1,000 | PYTHON3 |
inp = input()
inpL = inp.split(" ")
n = int(inpL[0])
t = int(inpL[1])
a = input()
x = []
for c in a:
x.append(c)
for j in range(t):
i = 0
while i < n-1:
if x[i] == "B" and x[i+1] == "G":
x[i] = "G"
x[i+1] = "B"
i = i +2
else:
i = i + 1
print("".join(x))
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, i, j, t, x, s, X, Y, xc, yc, minn;
bool f, a[110][110];
int main() {
cin >> n >> k;
xc = (k + 1) / 2;
yc = (k + 1) / 2;
while (n--) {
cin >> x;
minn = INT_MAX;
for (i = 1; i <= k; i++)
for (j = 1; j <= k - x + 1; j++) {
f = true;
s = 0;
for (t = j; t < j + x; t++) {
if (a[i][t]) {
f = false;
break;
}
s = s + abs(i - xc) + abs(t - yc);
}
if (f && s < minn) {
minn = s;
X = i;
Y = j;
}
}
if (minn == INT_MAX) {
cout << -1 << endl;
} else {
for (i = Y; i < Y + x; i++) {
a[X][i] = true;
}
cout << X << " " << Y << " " << Y + x - 1 << endl;
}
}
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[1005], b[1005], n, k;
int solve(int x) {
int i, y, z;
z = k;
for (i = 0; i < n; i++) {
y = b[i] - (a[i] * x);
if (y < 0) z += y;
if (z < 0) return 0;
}
if (z < 0) return 0;
return 1;
}
int main() {
int i;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n; i++) scanf("%d", &b[i]);
int lo = 0, hi = 3000, md, p, x;
while (lo <= hi) {
md = (lo + hi) / 2;
x = solve(md);
if (x) {
p = md;
lo = md + 1;
} else
hi = md - 1;
}
printf("%d\n", p);
return 0;
}
| 1,400 | CPP |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Oct 18 11:34:25 2019
@author: wwy
"""
n = int(input())
num = 0
for i in range(n):
a,b,c = map(int,input().split())
if (a+b+c) >= 2:
num += 1
print(num)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
char vow[] = {'a', 'e', 'i', 'o', 'u', 'y'};
int main() {
cin.sync_with_stdio(0);
int n;
int pattern[101];
cin >> n;
for (int i = 0; i < n; i++) cin >> pattern[i];
string str;
bool ok = true;
for (int i = 0; getline(cin, str); i++) {
if (i == 0) continue;
int cnt = 0;
for (int j = 0; j < str.size(); j++) {
for (int k = 0; k < 6; k++) {
if (str[j] == vow[k]) {
cnt++;
}
}
}
if (cnt != pattern[i - 1]) ok = false;
}
if (ok)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int SIZE = 3e5 + 10;
int v[SIZE];
int nxt[SIZE][26], sz[SIZE];
char s[SIZE];
vector<int> e[SIZE];
void merge(int x, int y, int &num) {
for (int i = 0; i < (26); ++i) {
if (nxt[y][i]) {
if (!nxt[x][i]) {
num += sz[nxt[y][i]];
nxt[x][i] = nxt[y][i];
} else {
sz[x] -= sz[nxt[x][i]];
merge(nxt[x][i], nxt[y][i], sz[nxt[x][i]]);
sz[x] += sz[nxt[x][i]];
}
}
}
}
void dfs(int x, int lt) {
sz[x] = 1;
for (int i = 0; i < (((int)(e[x]).size())); ++i) {
int y = e[x][i];
if (y == lt) continue;
dfs(y, x);
int c = s[y];
if (!nxt[x][c]) {
sz[x] += sz[y];
nxt[x][c] = y;
} else {
sz[x] -= sz[nxt[x][c]];
if (sz[nxt[x][c]] < sz[y]) {
swap(y, nxt[x][c]);
}
merge(nxt[x][c], y, sz[nxt[x][c]]);
sz[x] += sz[nxt[x][c]];
}
}
v[x] += sz[x];
}
int main() {
int(N);
scanf("%d", &N);
for (int i = 0; i < (N); ++i) scanf("%d", &(v[i]));
scanf("%s", (s));
for (int i = 0; i < (N); ++i) s[i] -= 'a';
for (int i = (1); i < (N); ++i) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
e[x].push_back(y);
e[y].push_back(x);
}
dfs(0, 0);
pair<int, int> an = make_pair(0, 0);
for (int i = 0; i < (N); ++i) {
if (an.first < v[i]) {
an = make_pair(v[i], 1);
} else if (an.first == v[i])
an = make_pair(v[i], an.second + 1);
}
printf("%d\n%d\n", an.first, an.second);
return 0;
}
| 2,400 | 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 S(): return input().strip()
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
# import math
# import bisect as bs
# from collections import Counter
# from collections import defaultdict as dc
def judge(p, s):
now = [0, 0]
for c in s:
if c == 'L':
if (now[0] - 1, now[1]) == p: continue
now[0] -= 1
elif c == 'R':
if (now[0] + 1, now[1]) == p: continue
now[0] += 1
elif c == 'U':
if (now[0], now[1] + 1) == p: continue
now[1] += 1
else:
if (now[0], now[1] - 1) == p: continue
now[1] -= 1
return now == [0, 0]
for _ in range(N()):
s = S()
candidate = set()
now = [0, 0]
for c in s:
if c == 'L':
now[0] -= 1
elif c == 'R':
now[0] += 1
elif c == 'U':
now[1] += 1
else:
now[1] -= 1
candidate.add(tuple(now))
if now == [0, 0]:
print(10000, 10000)
continue
f = False
for p in candidate:
if judge(p, s):
print(p[0], p[1])
f = True
break
if not f:
print(0, 0) | 1,600 | PYTHON3 |
t = int(input());
for test in range(t):
n,p,k = map(int,input().split());
arr = list(map(int,input().split()));
arr.sort();
carr = [ 0 for i in range(n+5)];
carr[0] = arr[0];
for i in range(1,k-1):
carr[i] = carr[i-1]+arr[i];
carr[k-1] = arr[k-1];
for i in range(k,n):
carr[i]=carr[i-k]+arr[i];
count = 0;
for i in range(n):
if(carr[i]<=p):
count = i+1;
print(count)
| 1,400 | PYTHON3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.