solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
t = int(input())
for _ in range(t) :
n = int(input())
l =list(map(int,input().split()))
l.sort()
f = 0
for i in range(1,n) :
if l[i]-l[i-1]==1 :
f = 1
break
if f==1 :
print("2")
else :
print("1") | 800 | PYTHON3 |
#include <bits/stdc++.h>
const int N = 400200;
const int Q = 400200;
using namespace std;
int n;
int tim;
int dip[N];
int tin[N];
int tout[N];
int f[N][20];
vector<int> v[N];
void dfs(int x, int p) {
tin[x] = ++tim;
f[x][0] = p;
for (int i = 1; i < 20; i++) f[x][i] = f[f[x][i - 1]][i - 1];
for (int y : v[x]) {
if (y == p) continue;
dip[y] = dip[x] + 1;
dfs(y, x);
}
tout[x] = ++tim;
}
bool isp(int x, int y) { return tin[x] <= tin[y] && tout[x] >= tout[y]; }
int lca(int x, int y) {
if (isp(x, y)) return x;
if (isp(y, x)) return y;
for (int i = 19; i >= 0; i--)
if (!isp(f[x][i], y)) x = f[x][i];
return f[x][0];
}
int V[N];
int s[N];
int a[N];
int id[N];
int inv[N];
int spec[N];
vector<pair<int, int> > g[N];
int get_len(int x, int y) { return dip[x] + dip[y] - 2 * dip[lca(x, y)]; }
void make(set<pair<pair<int, int>, int> > &S, int x) {
int i = a[x];
for (auto p : g[x]) {
if (a[p.first]) {
continue;
}
S.insert({{(get_len(V[i], inv[p.first]) - 1) / s[i] + 1, i}, p.first});
}
}
pair<int, int> T[N];
void upd_(int x, int y) {
while (x < N) {
T[x] = max(T[x], make_pair(tin[y], y));
x += x & -x;
}
}
void cler(int x) {
while (x < N) {
T[x] = {0, 0};
x += x & -x;
}
}
pair<int, int> get_(int x) {
pair<int, int> res = {0, 0};
while (x > 0) {
res = max(res, T[x]);
x -= x & -x;
}
return res;
}
void solve() {
int k, m;
scanf("%d%d", &k, &m);
vector<int> v;
for (int i = 1; i <= k; i++) {
scanf("%d%d", V + i, s + i);
v.push_back(V[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d", spec + i);
v.push_back(spec[i]);
}
sort(v.begin(), v.end(), [&](int x, int y) { return tin[x] < tin[y]; });
int len = v.size();
for (int i = 1; i < len; i++) {
if (v[i] == v[i - 1]) {
continue;
}
v.push_back(lca(v[i - 1], v[i]));
}
sort(v.begin(), v.end(), [&](int x, int y) {
return make_pair(tin[x], x) < make_pair(tin[y], y);
});
vector<int> nv = {v[0]};
for (int i = 1; i < v.size(); i++)
if (v[i] != v[i - 1]) nv.push_back(v[i]);
v = nv;
for (int i = 1; i <= v.size(); i++) g[i].clear();
for (int i = 0, len; i < v.size(); i++) {
auto q = get_(N - tin[v[i]]);
id[v[i]] = i + 1;
inv[i + 1] = v[i];
if (q.second > 0) {
len = dip[v[i]] - dip[q.second];
g[id[q.second]].push_back({i + 1, len});
g[i + 1].push_back({id[q.second], len});
}
upd_(N - tout[v[i]], v[i]);
}
for (int i = 0; i < v.size(); i++) {
cler(N - tout[v[i]]);
}
for (int i = 1; i <= v.size(); i++) a[i] = 0;
set<pair<pair<int, int>, int> > S;
for (int i = 1; i <= k; i++) {
int x = V[i];
a[id[x]] = i;
}
for (int i = 1; i <= k; i++) {
make(S, id[V[i]]);
}
while (!S.empty()) {
auto shit = *S.begin();
S.erase(S.begin());
if (a[shit.second]) {
continue;
}
a[shit.second] = shit.first.second;
make(S, shit.second);
}
for (int i = 1; i <= m; i++) {
printf("%d ", a[id[spec[i]]]);
}
printf("\n");
}
int main() {
ios_base::sync_with_stdio(0);
scanf("%d", &n);
for (int i = 1, x, y; i < n; i++) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, 1);
int q;
scanf("%d", &q);
while (q--) {
solve();
}
}
| 3,000 | CPP |
from collections import deque, Counter, OrderedDict
from heapq import nsmallest, nlargest
from math import ceil,floor,log,log2,sqrt
def binNumber(n,size=1):
return bin(n)[2:].zfill(size)
def gcd(a,b):
if a == 0:
return b
return gcd(b%a,a)
def iar():
return list(map(int,input().split()))
def ini():
return int(input())
def isp():
return map(int,input().split())
def sti():
return str(input())
# ========= /\ /| |====/|
# | / \ | | / |
# | /____\ | | / |
# | / \ | | / |
# ========= / \ ===== |/====|
# code
if __name__ == "__main__":
n = ini()
x = []
y = []
z = []
for _ in range(n):
a = iar()
x.append(a[0])
y.append(a[1])
z.append(a[2])
if abs(sum(x)) + abs(sum(y)) + abs(sum(z)) == 0:
print("YES")
else:
print("NO")
| 1,000 | PYTHON3 |
a,b=input().split()
n=int(a)
k=int(b)-1
s=input().split()
s1=list(s)
L=[]
for i in s1:
sd=int(i)
L.append(sd)
sum=0
for i in range(n):
if (L[i]>=L[k])&(L[i]>0):
sum=sum+1
print(sum)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using piii = pair<int, pii>;
using pib = pair<int, bool>;
using ld = long double;
struct node {
int l, r;
ll v;
};
int n, x;
ll psa1[300001], psa2[300001], kv[300001], jv[300001];
node st[1200000];
void b1(int l, int r, int i) {
st[i] = {l, r, 0};
if (l != r) {
int mid = (l + r) / 2;
b1(l, mid, i * 2 + 1);
b1(mid + 1, r, i * 2 + 2);
st[i].v = min(st[i * 2 + 1].v, st[i * 2 + 2].v);
} else
st[i].v = psa1[l];
}
void b2(int l, int r, int i) {
if (l != r) {
int mid = (l + r) / 2;
b2(l, mid, i * 2 + 1);
b2(mid + 1, r, i * 2 + 2);
st[i].v = min(st[i * 2 + 1].v, st[i * 2 + 2].v);
} else
st[i].v = kv[l];
}
void b3(int l, int r, int i) {
if (l != r) {
int mid = (l + r) / 2;
b3(l, mid, i * 2 + 1);
b3(mid + 1, r, i * 2 + 2);
st[i].v = max(st[i * 2 + 1].v, st[i * 2 + 2].v);
} else
st[i].v = jv[l];
}
ll q1(int l, int r, int i) {
if (st[i].l >= l && st[i].r <= r) {
return st[i].v;
} else {
int mid = (st[i].l + st[i].r) / 2;
if (r <= mid)
return q1(l, r, i * 2 + 1);
else if (l > mid)
return q1(l, r, i * 2 + 2);
else {
return min(q1(l, r, i * 2 + 1), q1(l, r, i * 2 + 2));
}
}
}
ll q2(int l, int r, int i) {
if (st[i].l >= l && st[i].r <= r) {
return st[i].v;
} else {
int mid = (st[i].l + st[i].r) / 2;
if (r <= mid)
return q2(l, r, i * 2 + 1);
else if (l > mid)
return q2(l, r, i * 2 + 2);
else {
return max(q2(l, r, i * 2 + 1), q2(l, r, i * 2 + 2));
}
}
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> psa1[i];
psa2[i] = psa1[i] * x + psa2[i - 1];
psa1[i] += psa1[i - 1];
}
b1(0, n, 0);
for (int i = 1; i <= n; i++) {
kv[i] = psa2[i] - psa1[i] + q1(0, i, 0);
}
b2(0, n, 0);
for (int i = 1; i <= n; i++) {
jv[i] = psa2[i] - psa1[i] - q1(0, i, 0);
}
b3(0, n, 0);
ll ans = 0;
for (int i = 1; i <= n; i++) {
ans = max(ans, psa1[i] + q2(0, i, 0));
}
cout << ans << "\n";
return 0;
}
| 1,900 | CPP |
log_word = input()
i = 0
hello_word = 'hello'
for val in log_word:
if val == hello_word[i]:
i += 1
if(i == 5): break
print('YES' if i == 5 else 'NO')
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int r, b;
cin >> r >> b;
int xr[b], xb[b], yr[b], yb[b];
for (int i = 0; i < b; i++) {
cin >> xr[i] >> yr[i];
}
for (int i = 0; i < b; i++) {
cin >> xb[i] >> yb[i];
}
if (r != b) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const int dx[] = {1, 0, -1, 0, -1, -1, 1, 1};
const int dy[] = {0, 1, 0, -1, -1, 1, -1, 1};
const double PI = M_PI;
const int OO = INT_MAX;
template <class A, class B>
A convert(B x) {
stringstream s;
s << x;
A r;
s >> r;
return r;
}
int main() {
double arr[6];
for (int i = 0; i < 5; i++) {
cin >> arr[i];
}
double distance = sqrt((arr[1] - arr[3]) * (arr[1] - arr[3]) +
(arr[2] - arr[4]) * (arr[2] - arr[4]));
cout << ceil(distance / (2.0 * arr[0])) << '\n';
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long ret = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') ret = ret * 10 + ch - '0', ch = getchar();
return ret * f;
}
const long long maxn = 55;
const double eps = 1e-5, INF = 1.0e9;
long long n;
double ans = -1.0;
double f[maxn][maxn][maxn];
pair<long long, long long> tasks[maxn];
bool check(double now) {
for (long long i = 0; i <= n; i++)
for (long long j = 0; j <= n; j++)
for (long long k = 0; k <= n; k++) f[i][j][k] = INF;
f[0][0][0] = 0.0;
for (long long i = 1; i <= n; i++)
for (long long j = 0; j <= i; j++)
for (long long k = 0; k <= i; k++)
if (f[i - 1][j][k] != INF) {
double delta = (double)tasks[i].first - now * (double)tasks[i].second;
if (tasks[i - 1].first == tasks[i].first || i == 1) {
f[i][j][k] = min(f[i][j][k], f[i - 1][j][k] + delta);
if (j - 1 >= 0)
f[i][j - 1][k] = min(f[i][j - 1][k], f[i - 1][j][k] + delta);
f[i][j][k + 1] = min(f[i][j][k + 1], f[i - 1][j][k]);
} else {
if (j + k <= n)
f[i][j + k][0] = min(f[i][j + k][0], f[i - 1][j][k] + delta);
if (j + k - 1 >= 0 && j + k - 1 <= n)
f[i][j + k - 1][0] =
min(f[i][j + k - 1][0], f[i - 1][j][k] + delta);
if (j + k <= n)
f[i][j + k][1] = min(f[i][j + k][1], f[i - 1][j][k]);
}
}
return f[n][0][0] < 0.0;
}
bool cmp(pair<long long, long long> aa, pair<long long, long long> bb) {
return aa.first < bb.first;
}
signed main() {
n = read();
for (long long i = 1; i <= n; i++) tasks[i].first = read();
for (long long i = 1; i <= n; i++) tasks[i].second = read();
sort(tasks + 1, tasks + 1 + n, cmp);
double L = 0.0001, R = 1.0e8;
while (L <= R) {
double mid = (L + R) / 2.0;
if (check(mid))
R = mid - eps;
else
ans = mid, L = mid + eps;
}
printf("%lld\n", (long long)ceil(ans * 1000.0));
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[105][105], b[105][105];
vector<pair<int, int>> p;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) cin >> a[i][j];
for (int i = (1); i <= (n - 1); i++)
for (int j = (1); j <= (m - 1); j++)
if (a[i][j] && a[i + 1][j] && a[i][j + 1] && a[i + 1][j + 1])
b[i][j] = b[i][j + 1] = b[i + 1][j] = b[i + 1][j + 1] = 1;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++)
if (a[i][j] != b[i][j]) return cout << -1, 0;
for (int i = (1); i <= (n - 1); i++)
for (int j = (1); j <= (m - 1); j++)
if (a[i][j] && a[i + 1][j] && a[i][j + 1] && a[i + 1][j + 1])
p.push_back(make_pair(i, j));
cout << p.size() << '\n';
for (auto v : p) cout << v.first << " " << v.second << '\n';
}
| 1,200 | CPP |
import sys
input=sys.stdin.readline
t=int(input())
for tt in range(t):
n = int(input())
a1 = input().strip("\n")
b1 = input().strip("\n")
ans = []
a = []
b = []
for i in a1:
a.append(int(i))
for i in b1:
b.append(int(i))
for i in range(n-1,-1,-1):
if a[0] == b[i]:
a[0] ^= 1
ans.append(1)
ans.append(i+1)
temp = a[0:i+1]
temp = temp[::-1]
length = len(temp)
for j in range(length):
temp[j] ^= 1
for j in range(i+1):
a[j] = temp[j]
print(len(ans),end=" ")
for i in ans:
print(i,end=" ")
print()
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[100100];
int b[100100];
int c[100100];
int main() {
int n;
cin >> n;
int k = 0;
for (int i = 0; i < n; i++) {
a[i] = i;
}
int j = 1;
j %= n;
for (int i = 0; i < n; i++) {
b[i] = j;
j++;
j %= n;
}
for (int i = 0; i < n; i++) {
c[i] = a[i] + b[i];
c[i] %= n;
}
set<int> st;
for (int i = 0; i < n; i++) {
st.insert(c[i]);
}
if (st.size() != n) {
cout << -1;
return 0;
}
for (int i = 0; i < n; i++) {
printf("%d ", a[i]);
}
printf("\n");
for (int i = 0; i < n; i++) {
printf("%d ", b[i]);
}
printf("\n");
for (int i = 0; i < n; i++) {
printf("%d ", c[i]);
}
printf("\n");
return 0;
}
| 1,300 | CPP |
n=int(input())
v=list(map(int,input().split()))
a=[]
for _v in v:
if _v:
a.append(_v)
v=a
n=len(a)
if n>128:
print(3)
exit(0)
ans=1e10
dis=[[1e10 for _ in range(n)] for __ in range(n)]
dp=[[1e10 for _ in range(n)] for __ in range(n)]
for i in range(n):
for j in range(n):
if i!=j and v[i]&v[j]:
dp[i][j]=dis[i][j]=1
for k in range(n):
for i in range(k):
for j in range(i+1,k):
ans=min(ans,dp[i][j]+dis[i][k]+dis[k][j])
for i in range(n):
for j in range(n):
dp[i][j]=min(dp[i][j],dp[i][k]+dp[k][j])
print([ans,-1][ans==1e10])
| 1,900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_SIZE = 110;
bool space[MAX_SIZE][MAX_SIZE][MAX_SIZE];
int N, M, K;
void read_state() {
for (int i = 0; i < MAX_SIZE; ++i)
for (int j = 0; j < MAX_SIZE; ++j)
for (int k = 0; k < MAX_SIZE; ++k) space[i][j][k] = false;
string states = "";
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j) {
cin >> states;
for (int k = 1; k <= K; ++k) space[i][j][k] = (states[k - 1] == '1');
}
return;
}
bool is_important(int i, int j, int k) {
if ((space[i - 1][j][k] && space[i + 1][j][k]) ||
(space[i][j - 1][k] && space[i][j + 1][k]) ||
(space[i][j][k - 1] && space[i][j][k + 1])) {
return true;
}
if (space[i - 1][j][k]) {
if (space[i][j + 1][k] && !space[i - 1][j + 1][k]) return true;
if (space[i][j][k + 1] && !space[i - 1][j][k + 1]) return true;
}
if (space[i][j - 1][k]) {
if (space[i + 1][j][k] && !space[i + 1][j - 1][k]) return true;
if (space[i][j][k + 1] && !space[i][j - 1][k + 1]) return true;
}
if (space[i][j][k - 1]) {
if (space[i + 1][j][k] && !space[i + 1][j][k - 1]) return true;
if (space[i][j + 1][k] && !space[i][j + 1][k - 1]) return true;
}
return false;
}
void print_state() {
for (int i = 1; i <= N; ++i, cout << endl)
for (int j = 1; j <= M; ++j, cout << endl)
for (int k = 1; k <= K; ++k) {
if (space[i][j][k]) {
if (is_important(i, j, k))
cout << '*';
else
cout << '1';
} else {
cout << '0';
}
}
return;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin >> N >> M >> K;
read_state();
int answer = 0;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j)
for (int k = 1; k <= K; ++k) {
if (space[i][j][k]) answer += is_important(i, j, k);
}
cout << answer << endl;
return 0;
}
| 1,800 | CPP |
cases = int(input())
for _ in range(cases):
n = int(input())
numbers = [int(number) for number in input().split()]
print(n*3)
for i in range(0, n, 2):
for k in range(6):
print("%s %s %s" % (k%2+1, i+1, i+2))
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e6 + 5, mod = 1e9 + 7;
int N, dp[MN], nxt[MN], sum[MN];
char s[MN];
inline int get_val(int x) { return nxt[x] < N ? dp[nxt[x]] : 0; }
int main() {
scanf("%s", s);
N = strlen(s);
for (int i = 0; i < N; ++i)
if (s[i] == '0') sum[i] = (i ? sum[i - 1] : 0) + 1;
for (int i = 0; i <= N; ++i) nxt[0] = N;
for (int i = N - 1; i >= 0; --i) {
dp[i] = ((sum[i] <= sum[N - 1]) + get_val(0) + get_val(sum[i] + 1)) % mod;
nxt[sum[i]] = i;
}
if (nxt[0] < N)
printf("%d\n", 1ll * get_val(0) * (nxt[0] + 1) % mod);
else
printf("%d\n", N);
return 0;
}
| 2,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000;
long long x, y;
string s[30];
int nm[600000][25], n, k, mx, k1[600000], k2[600000], k3[600000], v, tp[500000],
a[300], b[300], c[300];
struct sq {
int l, m, w;
};
sq d[600000];
bool cmp(const sq &i, const sq &j) {
if (i.l < j.l)
return 1;
else if (i.l == j.l && (i.m < j.m))
return 1;
else if (i.l == j.l && i.m == j.m && i.w < j.w)
return 1;
else
return 0;
}
void go(int l, int r, int x, int y, int z, int k) {
if (l > r) {
v++;
d[v].l = x - y;
d[v].m = y - z;
d[v].w = v;
k1[v] = x;
k2[v] = y;
k3[v] = z;
for (int i = 1; i <= k; i++) nm[v][i] = tp[i];
return;
}
k++;
tp[k] = 1;
go(l + 1, r, x + a[l], y + b[l], z, k);
tp[k] = 2;
go(l + 1, r, x + a[l], y, z + c[l], k);
tp[k] = 3;
go(l + 1, r, x, y + b[l], z + c[l], k);
}
void go2(int l, int r, int x, int y, int z, int k) {
if (l > r) {
int ll = lower_bound(d + 1, d + v + 1, (sq){y - x, z - y, 0}, cmp) - d;
if (ll == v + 1) return;
if (x - y + d[ll].l == 0 && y - z + d[ll].m == 0) {
if (k1[d[ll].w] + x > mx)
mx = k1[d[ll].w] + x;
else
return;
for (int i = 1; i <= n / 2; i++) {
int x = d[ll].w;
if (nm[x][i] == 1)
s[i].assign("LM");
else if (nm[x][i] == 2)
s[i].assign("LW");
else if (nm[x][i] == 3)
s[i].assign("MW");
}
for (int i = 1; i <= n - n / 2; i++) {
if (tp[i] == 1)
s[i + n / 2].assign("LM");
else if (tp[i] == 2)
s[i + n / 2].assign("LW");
else if (tp[i] == 3)
s[i + n / 2].assign("MW");
}
return;
}
return;
}
k++;
tp[k] = 1;
go2(l + 1, r, x + a[l], y + b[l], z, k);
tp[k] = 2;
go2(l + 1, r, x + a[l], y, z + c[l], k);
tp[k] = 3;
go2(l + 1, r, x, y + b[l], z + c[l], k);
}
void build(int l, int r) {
k = 0;
go(l, r, 0, 0, 0, 0);
}
void build2(int l, int r) {
k = 0;
sort(d + 1, d + v + 1, cmp);
go2(l, r, 0, 0, 0, 0);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i] >> c[i];
if (n == 1) {
if (a[1] == 0 && b[1] == 0)
cout << "LM\n";
else if (a[1] == 0 && c[1] == 0)
cout << "LW\n";
else if (b[1] == 0 && c[1] == 0)
cout << "MW\n";
return 0;
}
mx = -2e9;
build(1, n / 2);
build2(n / 2 + 1, n);
if (mx != -2e9) {
for (int i = 1; i <= n; i++) cout << s[i] << "\n";
} else
cout << "Impossible\n";
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
const int INF = 0x3f3f3f3f;
struct qry {
int l, r, idx, ans;
};
int n, q, a[N], f[N], last[N];
vector<qry> qs;
pair<int, int> first[4 * N];
void update(int idx, int val, int p = 1, int l = 1, int r = n) {
int mid = (l + r) / 2;
if (l == r) {
first[p] = {val, a[l]};
return;
}
if (idx <= mid)
update(idx, val, 2 * p, l, mid);
else
update(idx, val, 2 * p + 1, mid + 1, r);
first[p] = min(first[2 * p], first[2 * p + 1]);
}
pair<int, int> query(int i, int j, int p = 1, int l = 1, int r = n) {
if (j < l or i > r) return {INF, INF};
if (i <= l and r <= j) return first[p];
return min(query(i, j, 2 * p, l, (l + r) / 2),
query(i, j, 2 * p + 1, (l + r) / 2 + 1, r));
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
cin >> q;
qs.resize(q);
for (int i = 0; i < q; i++)
cin >> qs[i].l >> qs[i].r, qs[i].idx = i, qs[i].ans = 0;
sort(qs.begin(), qs.end(),
[](qry a, qry b) { return a.r == b.r ? a.l < b.l : a.r < b.r; });
for (int i = 0; i < 4 * N; i++) first[i] = {INF, INF};
int ptr = 0;
for (auto &x : qs) {
while (ptr < x.r) {
ptr++;
f[a[ptr]] = last[a[ptr]];
if (last[a[ptr]]) update(last[a[ptr]], INF);
last[a[ptr]] = ptr;
update(ptr, f[a[ptr]]);
}
pair<int, int> ans = query(x.l, x.r);
if (ans.first < x.l) x.ans = ans.second;
}
sort(qs.begin(), qs.end(), [](qry a, qry b) { return a.idx < b.idx; });
for (auto x : qs) cout << x.ans << "\n";
}
| 2,400 | CPP |
x=input()
y=list(x)
k=""
i=0
while(1):
if(i<len(y)):
if(y[i]=="."):
k=k+"0"
i=i+1
else:
if(y[i+1]=="-"):
k=k+"2"
else:
k=k+"1"
i=i+2
else:
break
print(k) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s[2];
long long int n, k, i;
cin >> n >> k;
for (i = 0; i < n; i++) {
s[0] += ".";
s[1] += ".";
}
if (k % 2 == 0) {
for (i = 1; i <= k / 2; i++) s[0][i] = s[1][i] = '#';
} else {
if (k <= n - 2) {
k--;
s[0][n / 2] = '#';
for (i = 1; i <= k / 2; i++) s[0][n / 2 - i] = s[0][n / 2 + i] = '#';
} else {
for (i = 1; i <= n - 2; i++) s[0][i] = '#';
k -= n - 2;
for (i = 1; i <= k / 2; i++) s[1][i] = s[1][n - 1 - i] = '#';
}
}
cout << "YES\n";
for (i = 0; i < n; i++) cout << ".";
cout << "\n";
cout << s[0] << "\n";
cout << s[1] << "\n";
for (i = 0; i < n; i++) cout << ".";
cout << "\n";
return 0;
}
| 1,600 | CPP |
w,h,k = map(int,input().split())
ans = 0
for i in range(k):
minus= i*4
ans += 2*(w - 2*minus + h) - 4
print(ans) | 800 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int n, numa, numb, i, x;
int a[105], b[105], ans[105];
scanf("%d %d %d", &n, &numa, &numb);
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
memset(ans, 0, sizeof(ans));
for (i = 1; i <= numa; i++) {
scanf("%d", &x);
a[x] = 1;
ans[x] = 1;
}
for (i = 1; i <= numb; i++) {
scanf("%d", &x);
b[x] = 1;
if (ans[x] == 0) ans[x] = 2;
}
for (i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
long long Prefix[5007], C[5007][5007];
inline void init() {
memset(C, 0, sizeof(C));
for (int i = 0; i <= 5000; i++) {
C[i][0] = 1LL;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % 998244353;
}
Prefix[0] = 1LL;
for (int i = 1; i <= 5000; i++)
Prefix[i] = (Prefix[i - 1] * (long long)i) % 998244353;
}
int main() {
init();
scanf("%d %d %d", &a, &b, &c);
long long temp1 = 0;
for (int i = 0; i <= min(a, b); i++)
temp1 =
(temp1 + (((C[a][i] * C[b][i]) % 998244353) * Prefix[i]) % 998244353) %
998244353;
long long temp2 = 0;
for (int i = 0; i <= min(a, c); i++)
temp2 =
(temp2 + (((C[a][i] * C[c][i]) % 998244353) * Prefix[i]) % 998244353) %
998244353;
long long temp3 = 0;
for (int i = 0; i <= min(b, c); i++)
temp3 =
(temp3 + (((C[b][i] * C[c][i]) % 998244353) * Prefix[i]) % 998244353) %
998244353;
printf("%lld\n", ((temp1 * temp2) % 998244353 * temp3) % 998244353);
return 0;
}
| 1,800 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e18 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-12;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
int n, a, b;
int f[100005];
int main(void) {
scanf("%d", &n);
for (int(i) = 0; (i) < (n); ++(i)) {
int x;
scanf("%d", &x);
if (x == 1)
++a;
else
++b;
}
f[0] = 1;
f[1] = 1;
for (int i = 2; i <= a; ++i) {
f[i] = (f[i - 1] + 1LL * (i - 1) * f[i - 2]) % mod;
}
int res = f[a];
for (int i = 0, cnt = a + 1; i < b; ++i, ++cnt) {
res = (1LL * res * cnt) % mod;
}
printf("%d\n", res);
return 0;
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000;
const int BN = 17;
vector<int> nbrs[MAX_N];
int ps[MAX_N][BN], ds[MAX_N], cns[MAX_N], ss[MAX_N];
long long ess[MAX_N], pess[MAX_N];
int find_lca(int u, int v) {
if (ds[u] > ds[v]) swap(u, v);
for (int i = BN - 1; i >= 0; i--)
if (((ds[v] - ds[u]) >> i) & 1) v = ps[v][i];
if (u == v) return u;
for (int i = BN - 1; i >= 0; i--)
if (ps[u][i] != ps[v][i]) {
u = ps[u][i];
v = ps[v][i];
}
return ps[u][0];
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
nbrs[a].push_back(b);
nbrs[b].push_back(a);
}
ps[0][0] = -1, ds[0] = 0;
queue<int> q;
q.push(0);
while (!q.empty()) {
int u = q.front();
q.pop();
int up = ps[u][0], vd = ds[u] + 1;
vector<int> &nbru = nbrs[u];
for (vector<int>::iterator vit = nbru.begin(); vit != nbru.end(); vit++) {
int v = *vit;
if (v != up) {
ps[v][0] = u, ds[v] = vd;
cns[u]++;
q.push(v);
}
}
}
for (int u = 0; u < n; u++)
if (cns[u] == 0) q.push(u);
while (!q.empty()) {
int u = q.front();
q.pop();
ss[u]++;
int up = ps[u][0];
if (up >= 0) {
ess[up] += ess[u] + ss[u];
ss[up] += ss[u];
if (--cns[up] == 0) q.push(up);
}
}
for (int k = 0; k < BN - 1; k++)
for (int u = 0; u < n; u++)
ps[u][k + 1] = (ps[u][k] >= 0) ? ps[ps[u][k]][k] : -1;
pess[0] = ess[0];
q.push(0);
while (!q.empty()) {
int u = q.front();
q.pop();
int up = ps[u][0];
vector<int> &nbru = nbrs[u];
for (vector<int>::iterator vit = nbru.begin(); vit != nbru.end(); vit++) {
int v = *vit;
if (v != up) {
pess[v] = pess[u] - ss[v] + (n - ss[v]);
q.push(v);
}
}
}
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
if (ds[u] > ds[v]) swap(u, v);
int w = find_lca(u, v);
double e = 0.0;
if (w == u) {
int cu = v, d = ds[v] - ds[u] - 1;
for (int k = BN - 1; k >= 0; k--)
if ((d >> k) & 1) cu = ps[cu][k];
int spu = n - ss[cu];
long long epu = pess[u] - (ess[cu] + ss[cu]);
long long esum = epu * ss[v] + ess[v] * spu +
(long long)(ds[v] - ds[u] + 1) * spu * ss[v];
e = (double)esum / ((long long)spu * ss[v]);
} else {
long long esum =
ess[u] * ss[v] + ess[v] * ss[u] +
(long long)(ds[u] + ds[v] - ds[w] * 2 + 1) * ss[u] * ss[v];
e = (double)esum / ((long long)ss[u] * ss[v]);
}
printf("%.8lf\n", e);
}
return 0;
}
| 2,300 | CPP |
class Node:
def __init__(self, key = 0, left = None, right = None):
self.key = key
self.left = left
self.right = right
def find(self, x):
if self.key == x:
return self
if self.right and self.key < x:
return self.right.find(x)
if self.left and self.key > x:
return self.left.find(x)
return None
def insert(self, x):
if x < self.key:
if self.left:
self.left.insert(x)
else:
self.left = Node(x)
elif x > self.key:
if self.right:
self.right.insert(x)
else:
self.right = Node(x)
def find_min(self):
cur = self
while cur.left:
cur = cur.left
return cur
def remove(self, x):
if x < self.key:
self.left = self.left.remove(x)
elif x > self.key:
self.right = self.right.remove(x)
else:
if self.left == None:
return self.right
elif root.right == None:
return self.left
temp = self.right.find_min()
self.key = temp.key
self.right = self.right.remove(temp.key)
return self
def size(self):
size_left = 0
size_right = 0
if self.left:
size_left = self.left.size()
if self.right:
size_right = self.right.size()
return size_left + size_right + 1
class Set:
def __init__(self):
self.root = None
def insert(self, x):
if self.root:
self.root.insert(x)
else:
self.root = Node(x)
def remove(self, x):
if self.root:
self.root = self.root.remove(x)
def find(self, x):
if self.root:
return self.root.find(x)
return None
def size(self):
if self.root:
return self.root.size()
return 0
input_line = input().split()
n = int(input_line[0])
x0 = float(input_line[1])
y0 = float(input_line[2])
bonus = 0
s = Set()
for i in range(n):
x, y = map(float, input().split())
if y == y0:
bonus = 1
continue
s.insert((x - x0) / (y - y0))
print(s.size() + bonus) | 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[400];
int check(long long int val, int n) {
long long int vl = sqrt(val);
int ct = 0;
for (int h = 1; h <= vl; h++) {
if (h != vl && val % h == 0) {
ct += 2;
}
if (h == vl && 1LL * vl * vl == val)
ct++;
else if (h == vl && val % vl == 0)
ct += 2;
}
if (ct - 2 == n)
return 1;
else
return 0;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int h = 0; h < n; h++) cin >> a[h];
sort(a, a + n);
long long int val, cal;
int f = 1;
if (n % 2 == 0) {
val = 1LL * a[0] * a[n - 1];
for (int h = 1; h < n / 2; h++) {
cal = 1LL * a[h] * a[n - h - 1];
if (cal != val) {
f = 0;
break;
}
}
} else {
val = 1LL * a[n / 2] * a[n / 2];
for (int h = 0; h < n / 2; h++) {
cal = 1LL * a[h] * a[n - h - 1];
if (cal != val) {
f = 0;
break;
}
}
}
if (f == 0) {
cout << -1 << endl;
} else {
if (check(val, n))
cout << val << endl;
else
cout << -1 << endl;
}
}
}
| 1,600 | CPP |
fast=lambda:stdin.readline().strip()
zzz=lambda:[int(i) for i in fast().split()]
z,zz=input,lambda:list(map(int,z().split()))
szz,graph,mod,szzz=lambda:sorted(zz()),{},10**9+7,lambda:sorted(zzz())
from re import *
from sys import *
from math import *
from heapq import *
from queue import *
from bisect import *
from string import *
from itertools import *
from collections import *
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from collections import Counter as cc
from itertools import accumulate as ac
def lcd(xnum1,xnum2):return (xnum1*xnum2//gcd(xnum1,xnum2))
def output(answer):stdout.write(str(answer))
###########################---Test-Case---#################################
"""
If you Know me , Then you probably don't know me !
"""
###########################---START-CODING---##############################
n=int(z())
arr=zzz()
mx=max(arr)
lst=[mx-arr[i] for i in range(n)]
g=lst[0]
for i in lst[1:]:
g=gcd(g,i)
print(sum(lst)//g,g)
| 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
struct data {
int vl, step;
} tmp;
int main() {
int n, arr[100000 + 7], cnt, tym, ans, i, j, k;
while (scanf("%d", &n) == 1) {
stack<data> stk;
for (i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
}
ans = 0;
tmp.vl = arr[n];
tmp.step = 0;
stk.push(tmp);
for (i = n - 1; i > 0; i--) {
cnt = 1;
while (!stk.empty() and stk.top().vl < arr[i]) {
ans = max(ans, cnt);
cnt = max(cnt, stk.top().step);
stk.pop();
cnt++;
}
tmp.vl = arr[i];
tmp.step = cnt - 1;
stk.push(tmp);
}
printf("%d\n", ans);
}
return 0;
}
| 1,900 | CPP |
def reverse(s):
return 'b' if s == 'a' else 'a'
t = int(input())
for _ in range(t):
n = int(input())
diff = list(map(int, input().split()))
words = ['a'*50]*(len(diff)+1)
print(words[0])
for i in range(1, len(diff)+1):
words[i] = words[i-1][:diff[i-1]]+reverse(words[i-1][diff[i-1]:diff[i-1]+1])+words[i-1][diff[i-1]+1:]
print(words[i]) | 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int oo = 0x3f3f3f3f;
const int Mod = 1e9 + 7;
const int maxn = 1000100;
int fac[maxn + 5];
inline void prepare() {
fac[0] = 1;
for (int i = (0), i_end_ = (maxn); i < i_end_; ++i)
fac[i + 1] = (long long)fac[i] * (i + 1) % Mod;
}
int n;
int a[maxn + 5];
bool notpr[maxn + 5];
int res[maxn + 5];
int ker[maxn + 5];
int bel[maxn + 5], cnt[maxn + 5], val[maxn + 5];
bool vis[maxn + 5];
inline int calc() {
for (int i = (1), i_end_ = (n + 1); i < i_end_; ++i) res[i] = i, ker[i] = 1;
memset(notpr, 0, sizeof notpr);
int ret = 1;
for (int i = 2; i * i <= n; ++i)
if (!notpr[i])
for (int j = i; j <= n; j += i) {
ker[j] *= i;
notpr[j] = 1;
while (!(res[j] % i)) res[j] /= i;
}
for (int i = (1), i_end_ = (n + 1); i < i_end_; ++i)
if (a[i] && ker[i] != ker[a[i]]) return 0;
for (int i = (1), i_end_ = (n + 1); i < i_end_; ++i) ker[i] *= res[i];
for (int i = (1), i_end_ = (n + 1); i < i_end_; ++i) ++cnt[ker[i]];
for (int i = (1), i_end_ = (n + 1); i < i_end_; ++i)
if (a[i]) --cnt[ker[i]];
for (int i = (1), i_end_ = (n + 1); i < i_end_; ++i)
ret = (long long)ret * fac[cnt[i]] % Mod;
memset(cnt, 0, sizeof cnt);
memset(vis, 0, sizeof vis);
bel[1] = 1;
for (int i = (2), i_end_ = (n + 1); i < i_end_; ++i)
if (!notpr[i]) bel[i] = n / i;
for (int i = (1), i_end_ = (n + 1); i < i_end_; ++i)
if (bel[i]) ++cnt[bel[i]];
for (int i = (1), i_end_ = (n + 1); i < i_end_; ++i)
if (a[i]) {
if (bel[res[i]] != bel[res[a[i]]]) return 0;
if (i == 1 || res[i] > 1) {
if (val[res[i]]) {
if (val[res[i]] != res[a[i]]) return 0;
} else {
if (vis[res[a[i]]]) return 0;
val[res[i]] = res[a[i]];
vis[res[a[i]]] = 1;
--cnt[bel[res[i]]];
}
}
}
for (int i = (1), i_end_ = (n + 1); i < i_end_; ++i)
ret = (long long)ret * fac[cnt[i]] % Mod;
return ret;
}
int main() {
prepare();
scanf("%d", &n);
for (int i = (1), i_end_ = (n + 1); i < i_end_; ++i) scanf("%d", a + i);
printf("%d\n", calc());
return 0;
}
| 3,000 | CPP |
#include <bits/stdc++.h>
const uint64_t mod = 2e9 + 11;
const uint64_t pp = 919;
using ll = int64_t;
using namespace std;
ll CalculateAnswer(vector<ll>& a, ll k) {
ll res = k;
for (int i = 0; i + 1 < a.size(); ++i) {
res += min(k, a[i + 1] - a[i]);
}
return res;
}
void solve() {
ll n, h;
cin >> n >> h;
vector<ll> a(n);
for (auto& el : a) {
cin >> el;
}
ll l = 0, r = h;
while (l + 1 < r) {
ll c = l + (r - l) / 2;
if (CalculateAnswer(a, c) < h) {
l = c;
} else {
r = c;
}
}
cout << r << endl;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr), std::cout.tie(nullptr);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct SegmentBeats {
struct node {
long long sum;
int mx1, mx2, cnt, lz;
} seg[N << 2];
SegmentBeats() { build(); }
inline node merge(node a, node b) {
if (a.mx1 < b.mx1) swap(a, b);
a.mx1 > b.mx1 ? a.mx2 = max(a.mx2, b.mx1) : a.cnt += b.cnt;
a.sum += b.sum, a.lz = 0, a.mx2 = max(a.mx2, b.mx2);
return a;
}
inline void change(int id, int x) {
if (seg[id].mx1 > x) {
seg[id].sum += 1LL * seg[id].cnt * (x - seg[id].mx1);
seg[id].mx1 = seg[id].lz = x;
}
}
inline void shift(int id) {
if (seg[id].lz) {
change(id << 1 | 1, seg[id].lz);
change(id << 1, seg[id].lz);
seg[id].lz = 0;
}
}
void build(int id = 1, int st = 0, int en = N) {
seg[id].cnt = en - st;
if (en - st == 1) return;
int mid = st + en >> 1;
build(id << 1, st, mid);
build(id << 1 | 1, mid, en);
}
void set(int p, int x, int id = 1, int st = 0, int en = N) {
if (en - st == 1) {
seg[id] = {x, x, 0, 1, 0};
return;
}
shift(id);
int mid = st + en >> 1;
p < mid ? set(p, x, id << 1, st, mid) : set(p, x, id << 1 | 1, mid, en);
seg[id] = merge(seg[id << 1], seg[id << 1 | 1]);
}
void update(int l, int r, int x, int id = 1, int st = 0, int en = N) {
if (r <= st || en <= l || seg[id].mx1 <= x) return;
if (l <= st && en <= r && seg[id].mx2 < x) return change(id, x);
shift(id);
int mid = st + en >> 1;
update(l, r, x, id << 1, st, mid);
update(l, r, x, id << 1 | 1, mid, en);
seg[id] = merge(seg[id << 1], seg[id << 1 | 1]);
}
long long get(int l, int r, int id = 1, int st = 0, int en = N) {
if (r <= st || en <= l) return 0;
if (l <= st && en <= r) return seg[id].sum;
shift(id);
int mid = st + en >> 1;
return get(l, r, id << 1, st, mid) + get(l, r, id << 1 | 1, mid, en);
}
} A[2];
struct SegmentMin {
int seg[N << 2];
SegmentMin() { memset(seg, 63, sizeof seg); }
void update(int l, int r, int x, int id = 1, int st = 0, int en = N) {
if (r <= st || en <= l) return;
if (l <= st && en <= r) {
seg[id] = min(seg[id], x);
return;
}
int mid = st + en >> 1;
update(l, r, x, id << 1, st, mid);
update(l, r, x, id << 1 | 1, mid, en);
}
int get(int p, int id = 1, int st = 0, int en = N) {
if (en - st == 1) return seg[id];
int mid = st + en >> 1;
return min(seg[id], p < mid ? get(p, id << 1, st, mid)
: get(p, id << 1 | 1, mid, en));
}
} B[2];
set<int> S[3];
int main() {
int q;
scanf("%d", &q);
for (int i = 0; i < N; i++) S[2].insert(i);
while (q--) {
int t, l, r;
scanf("%d%d%d", &t, &l, &r);
if (t & 1) {
int k;
scanf("%d", &k);
auto it = S[2].lower_bound(l);
while (it != S[2].end() && *it < r) {
S[k < 0].insert(*it), S[2].erase(it);
it = S[2].lower_bound(l);
}
it = S[k > 0].lower_bound(l), B[k < 0].update(l, r, abs(k));
while (it != S[k > 0].end() && *it < r) {
A[k < 0].set(*it, B[k < 0].get(*it));
A[k > 0].set(*it, B[k > 0].get(*it));
S[k > 0].erase(it), it = S[k > 0].lower_bound(l);
}
A[k < 0].update(l, r, abs(k));
} else
printf("%lld\n", A[0].get(l, r) + A[1].get(l, r));
}
}
| 3,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
bool win(int a[3][3], int x) {
bool w = 0;
for (int i = 0; i < 3; i++) {
w |= (a[i][0] == x & a[i][1] == x & a[i][2] == x);
w |= (a[0][i] == x & a[1][i] == x & a[2][i] == x);
}
w |= (a[0][0] == x & a[1][1] == x & a[2][2] == x);
w |= (a[0][2] == x & a[1][1] == x & a[2][0] == x);
return w;
}
int main() {
char c;
int a[3][3];
memset(a, 0, sizeof(a));
int nx = 0, no = 0;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) {
cin >> c;
nx += (c == 'X');
no += (c == '0');
a[i][j] += (c == 'X');
a[i][j] += (c == '0') * 2;
}
bool wx = 0, wo = 0;
if (nx - no > 1) {
cout << "illegal" << endl;
return 0;
}
if (nx - no < 0) {
cout << "illegal" << endl;
return 0;
}
wx = win(a, 1);
wo = win(a, 2);
if (wx && wo) {
cout << "illegal" << endl;
return 0;
}
if (wx && (nx == no)) {
cout << "illegal" << endl;
return 0;
}
if (wo && (nx > no)) {
cout << "illegal" << endl;
return 0;
}
if (wx) {
cout << "the first player won" << endl;
return 0;
}
if (wo) {
cout << "the second player won" << endl;
return 0;
}
if (nx + no == 9 && wx + wo == 0) {
cout << "draw" << endl;
return 0;
}
if (nx == no) {
cout << "first" << endl;
return 0;
} else {
cout << "second" << endl;
return 0;
}
return 0;
}
| 1,800 | CPP |
import sys
n=int(input ())
a=list(map(int, input ().split()))
a.sort()
k=sys.maxsize
c=0
for I in range(1,n):
if k>a[I]-a[I-1]:
k=a[I]-a[I-1]
for I in range(1,n):
if k==a[I]-a[I-1]:
c+=1
print(k,c) | 1,100 | PYTHON3 |
s = input()
n = len(s)
MOD = 10**9+7
bckt = []
ct = 0
for i in range(n):
if s[i] == "a":
ct += 1
elif s[i] == "b" and ct:
bckt.append(ct)
ct = 0
if ct:
bckt.append(ct)
prod = 1
for i in bckt:
prod = (prod*(i+1))%MOD
prod = (prod-1)%MOD
print(prod) | 1,500 | PYTHON3 |
#!/usr/bin/python3
import sys
input = lambda: sys.stdin.readline().strip()
for _ in range(int(input())):
k = int(input())
s = input()
a = [*(i for i in range(k) if s[i] == 'A'), k]
print(max((j - i - 1 for i, j in zip(a, a[1:])), default=0)) | 800 | PYTHON3 |
import io
import os
from collections import deque, defaultdict
if 'STDINPUT' not in os.environ:
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
else:
print('Standard input')
def solve():
n = int(input())
a = [abs(int(x)) for x in input().split()]
for i in range(n//2+1):
a[i*2] = -a[i*2]
print(*a)
test_cases = True
if test_cases:
_q = int(input())
for _ in range(_q):
solve()
else:
solve()
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int maxl = 1, curr = 1;
for (int i = 1; i < n; i++) {
if (v[i] == v[i - 1])
curr = 1;
else
curr++;
maxl = max(curr, maxl);
}
cout << maxl << endl;
return 0;
}
| 1,000 | CPP |
for _ in range(int(input())):
a,b,c,d=map(int,input().split())
if b==d or a==c:
print(abs(a-c)+abs(b-d))
else:
print(abs(a-c)+abs(b-d)+2) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, MOD = 1e9 + 7;
const int N = 1e3 + 1000, n_ = 2e3 + 3000;
long long gcd(long long a, long long b) { return (a ? gcd(b % a, a) : b); }
long long power(long long a, long long n) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
}
n >>= 1;
a *= a;
}
return p;
}
long long power(long long a, long long n, long long mod) {
long long p = 1;
while (n > 0) {
if (n % 2) {
p = p * a;
p %= mod;
}
n >>= 1;
a *= a;
a %= mod;
}
return p % mod;
}
int n, m, q, par[n_];
vector<pair<pair<int, int>, pair<int, int> > > e;
void rm() {
for (int i = 0; i < n_; i++) {
par[i] = i;
}
}
int find(int u) { return par[u] = (par[u] == u ? u : find(par[u])); }
int merge(int u, int v) {
int fu = find(u), fv = find(v);
if (fv == fu) return 0;
par[fv] = find(u + N);
par[fu] = find(v + N);
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
int u, v, w;
pair<pair<int, int>, pair<int, int> > tmp;
cin >> u >> v >> w;
u--, v--;
tmp.second.first = u, tmp.second.second = v, tmp.first.first = w,
tmp.first.second = i;
e.push_back(tmp);
}
sort((e).begin(), (e).end());
while (q--) {
int l, r, ans = -1;
cin >> l >> r;
l--;
rm();
for (int i = m - 1; i >= 0; i--) {
if (e[i].first.second >= l && e[i].first.second < r &&
!merge(e[i].second.first, e[i].second.second)) {
ans = e[i].first.first;
break;
}
}
cout << ans << "\n";
}
return 0;
}
| 2,500 | CPP |
import math
h1, h2 = map(int, input().split())
a, b = map(int, input().split())
# if h1 + 8 * a >= h2:
# print(0)
# else:
# if 20*a-12*b<=0:
# print(-1)
# else:
# print(math.ceil((h2-h1)/(20*a-12*b)))
if h1 + 8 * a >= h2:
print(0)
else:
if a <= b:
print(-1)
else:
d = 0
h1 += 8*a-12*b
while True:
d+=1
h1 += 12*a
if h1 >= h2:
break
h1 -= 12*b
print(d) | 1,400 | PYTHON3 |
t=int(input())
for _ in range(t):
a,b=map(int,input().split())
if(abs(b-a)%10):
print(abs(b-a)//10+1)
else:
print(abs(b-a)//10) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
const long long int N = 5e5;
void solve() {
long long int n;
cin >> n;
string A;
cin >> A;
string B;
cin >> B;
long long int ans = 0;
for (long long int i = 0; i < n; ++i) {
if (i + 1 < n && A[i] != B[i] && A[i + 1] != B[i + 1] && A[i] == B[i + 1] &&
A[i + 1] == B[i]) {
ans++;
i++;
} else if (A[i] != B[i]) {
ans++;
}
}
cout << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 1,300 | CPP |
n,a=int(input()),[*map(int,input().split())]
for j in range(1,(n+1)//2):
if n%j==0:
for l in range(j):
t=1
for i in range(l,n,j):
if a[i]==0:t=0;break
if t:exit(print("YES"))
print("NO") | 1,600 | PYTHON3 |
from math import factorial
from collections import Counter
from heapq import heapify, heappop, heappush
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().rstrip("\r\n")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
mod = 1000000007
INF = float('inf')
# ------------------------------
def main():
n, kk = list(RL())
cards = ["S", "E", "T"]
cs = []
res = 0
rec = set()
for i in range(n):
c = input()
cs.append(c)
rec.add(c)
for i in range(len(cs) - 1):
for j in range(i + 1, len(cs)):
new = ""
for k in range(kk):
if cs[i][k] == cs[j][k]:
new += cs[i][k]
else:
for t in cards:
if t != cs[i][k] and t != cs[j][k]: new += t
if new in rec: res += 1
print(res // 3)
if __name__ == "__main__":
main() | 1,500 | PYTHON3 |
tc = int(input())
for tc_idx in range(tc):
n, x = map(int, input().split())
*a, = map(int, input().split())
*b, = map(int, input().split())
a.sort()
b.sort(reverse=True)
res = True
for aa, bb in zip(a, b):
if aa + bb > x:
res = False
break
print("Yes" if res else "No")
if tc_idx != tc - 1:
_ = input()
| 800 | PYTHON3 |
from collections import defaultdict, deque, Counter
from sys import stdin, stdout
from heapq import heappush, heappop
import math
import io
import os
import math
import bisect
#?############################################################
def isPrime(x):
for i in range(2, x):
if i*i > x:
break
if (x % i == 0):
return False
return True
#?############################################################
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den, p - 2, p)) % p
#?############################################################
def primeFactors(n):
l = []
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3, int(math.sqrt(n))+1, 2):
while n % i == 0:
l.append(int(i))
n = n / i
if n > 2:
l.append(n)
return list(set(l))
#?############################################################
def power(x, y, p):
res = 1
x = x % p
if (x == 0):
return 0
while (y > 0):
if ((y & 1) == 1):
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
#?############################################################
def sieve(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
#?############################################################
def digits(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
#?############################################################
def ceil(n, x):
if (n % x == 0):
return n//x
return n//x+1
#?############################################################
def mapin():
return map(float, input().split())
#?############################################################
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
# python3 15.py<in>op
def solve(a,b,size):
msf = -1e9
meh = 0
for i in range(b,size):
meh = meh + a[i]
if (msf < meh):
msf = meh
if meh < 0:
meh = 0
return msf
t = 1
for _ in range(t):
r, x1, x2, x3,x4 = mapin()
dis = (x4-x2)**2
dis2 = (x3-x1)**2
dis+=dis2
dis = math.sqrt(dis)
r+=r
ans = math.ceil(dis/r)
print(ans)
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<bool> isThere;
string t;
vector<string> p;
vector<int> sums;
void tryit(int i, int n);
int sum(int x, int n);
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i <= n; ++i) isThere.push_back(false);
tryit(1, n);
sort(p.begin(), p.end());
int max = 0;
sums.resize(p.size());
for (int i = 0; i < p.size(); ++i) {
sums[i] = sum(i, n);
if (sums[i] > max) max = sums[i];
}
int x = 0;
while (m != 0) {
if (sums[x] == max) --m;
++x;
}
--x;
for (int i = 0; i < p[x].size(); ++i) {
cout << (int)p[x][i] << " ";
}
cout << endl;
return 0;
}
void tryit(int i, int n) {
for (int j = 1; j <= n; ++j) {
if (!isThere[j]) {
t.push_back(j);
isThere[j] = true;
if (t.size() == n) {
p.push_back(t);
} else
tryit(j, n);
t.pop_back();
isThere[j] = false;
}
}
}
int sum(int x, int n) {
int s = 0;
vector<int> t;
for (int i = 0; i < p[x].length(); ++i) t.push_back(int(p[x][i]));
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
int min = 300000;
for (int k = i; k <= j; ++k)
if (t[k] < min) min = t[k];
s += min;
}
}
return s;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
string s;
long long n, i;
long long pal(string aa) {
long long ii;
for (ii = 0; ii < n; ii++)
if (aa[ii] != aa[n - ii - 1]) return 0;
return 1;
}
long long sama(long long aa, long long bb) {
long long ii;
for (ii = aa; ii <= bb; ii++)
if (s[ii] != s[aa]) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> s;
n = s.length();
for (i = 1; i < n; i++) {
string s1 = s.substr(0, i);
string s2 = s.substr(i, n - i);
string s3 = s2 + s1;
if (pal(s3) && s3 != s) {
cout << 1 << "\n";
return 0;
}
}
long long tengah = n / 2;
if (sama(0, tengah - 1))
cout << "Impossible\n";
else
cout << 2 << "\n";
}
| 1,800 | CPP |
x=[]
for i in input():
x += [int(i)]
l=[]
while len(x):
d = 0
for i in range(len(x)):
if x[i] > 0:
d += int(10**(len(x) - i - 1))
x[i] -= 1
l += [d]
while len(x) and x[0] == 0:
x.pop(0)
print(len(l))
print(*l) | 1,400 | PYTHON3 |
import sys
import math
import heapq
import bisect
from collections import Counter
from collections import defaultdict
from io import BytesIO, IOBase
import string
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
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
self.BUFSIZE = 8192
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.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 = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.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:
self.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")
def get_int():
return int(input())
def get_ints():
return list(map(int, input().split(' ')))
def get_int_grid(n):
return [get_ints() for _ in range(n)]
def get_str():
return input().strip()
def get_strs():
return get_str().split(' ')
def flat_list(arr):
return [item for subarr in arr for item in subarr]
def yes_no(b):
if b:
return "YES"
else:
return "NO"
def binary_search(good, left, right, delta=1, right_true=False):
"""
Performs binary search
----------
Parameters
----------
:param good: Function used to perform the binary search
:param left: Starting value of left limit
:param right: Starting value of the right limit
:param delta: Margin of error, defaults value of 1 for integer binary search
:param right_true: Boolean, for whether the right limit is the true invariant
:return: Returns the most extremal value interval [left, right] which is good function evaluates to True,
alternatively returns False if no such value found
"""
limits = [left, right]
while limits[1] - limits[0] > delta:
if delta == 1:
mid = sum(limits) // 2
else:
mid = sum(limits) / 2
if good(mid):
limits[int(right_true)] = mid
else:
limits[int(~right_true)] = mid
if good(limits[int(right_true)]):
return limits[int(right_true)]
else:
return False
def prefix_sums(a):
p = [0]
for x in a:
p.append(p[-1] + x)
return p
def solve_f():
n = get_int()
s = get_str()
t = get_str()
Cs = Counter(s)
Ct = Counter(t)
for k, v in Cs.items():
if k not in Ct or Ct[k] != v:
return False
for k, v in Cs.items():
if v > 1:
return True
inv_s, inv_t = 0, 0
for i in range(n):
for j in range(i):
inv_s += s[j] > s[i]
inv_t += t[j] > t[i]
return (inv_s + inv_t) % 2 == 0
t = get_int()
for _ in range(t):
print(yes_no(solve_f()))
| 2,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
template <class T>
struct RMQ {
const int STEP_P = 5;
const int STEP = 1 << STEP_P;
vector<T> data;
const T INF;
vector<vector<T> > small_powers;
vector<vector<T> > group_powers;
int N;
RMQ(vector<T> data_, T INF_) : data(data_), INF(INF_){};
void init() {
N = int((data).size());
small_powers = vector<vector<T> >(STEP_P + 1, vector<T>(N));
small_powers[0] = data;
for (int p = (0); p < (STEP_P); p++)
for (int n = (0); n < (N); n++) {
small_powers[p + 1][n] =
min(small_powers[p][n], small_powers[p][min(n + (1 << p), N - 1)]);
}
int GN = (N + STEP - 1) / STEP;
int GP = 1;
while (GN > (1 << GP)) ++GP;
group_powers = vector<vector<T> >(GP + 1, vector<T>(GN));
for (int i = (0); i < (GN); i++)
group_powers[0][i] = small_powers[STEP_P][i << STEP_P];
for (int p = (0); p < (GP); p++)
for (int n = (0); n < (GN); n++) {
group_powers[p + 1][n] =
min(group_powers[p][n], group_powers[p][min(n + (1 << p), GN - 1)]);
}
}
int largest_bit(int n) { return 31 - __builtin_clz(max(1, n - 1)); }
T query(int f, int t) {
assert(f >= 0 && t <= N);
if (f >= t) return INF;
int p = min(STEP_P, largest_bit(t - f));
auto res = min(small_powers[p][f], small_powers[p][t - (1 << p)]);
if (t - f > STEP + STEP) {
int g_f = f / STEP + 1, g_t = t / STEP;
p = largest_bit(g_t - g_f);
res =
min(res, min(group_powers[p][g_f], group_powers[p][g_t - (1 << p)]));
}
return res;
}
};
const int MAXN = 5e5;
long long A[MAXN];
vector<int> adj[MAXN];
vector<long long> dp_only[MAXN];
vector<long long> dp_not[MAXN];
long long dp_all[MAXN];
int todo[MAXN];
int xo[MAXN];
long long cost[MAXN];
int etox[MAXN][2];
int edgeval[MAXN][2];
int N, Q;
long long calc_not(int n, int eid) {
int xid = etox[eid][0];
if (int((adj[n]).size()) <= xid || adj[n][xid] != eid) xid = etox[eid][1];
if (dp_not[n][xid] == -1) {
if (dp_all[n] == -1) {
dp_all[n] = A[n];
todo[n] = xid;
for (int i = (0); i < (int((adj[n]).size())); i++)
if (i != xid) {
int neid = adj[n][i];
dp_only[n][i] =
max(0ll, calc_not(xo[neid] ^ n, neid) - cost[neid] * 2ll);
dp_all[n] += dp_only[n][i];
}
dp_not[n][xid] = dp_all[n];
} else if (todo[n] != -1) {
int neid = adj[n][todo[n]];
dp_only[n][todo[n]] =
max(0ll, calc_not(xo[neid] ^ n, neid) - cost[neid] * 2ll);
dp_all[n] += dp_only[n][todo[n]];
assert(dp_only[n][xid] != -1);
dp_not[n][xid] = dp_all[n] - dp_only[n][xid];
todo[n] = -1;
} else {
assert(dp_only[n][xid] != -1);
dp_not[n][xid] = dp_all[n] - dp_only[n][xid];
}
}
return dp_not[n][xid];
}
long long calc_only(int n, int eid) {
int xid = etox[eid][0];
if (adj[n][xid] != eid) xid = etox[eid][1];
assert(adj[n][xid] == eid);
assert(dp_only[n][xid] != -1);
return dp_only[n][xid];
}
int parent_edge[MAXN];
int depth[MAXN];
long long dp_acc[MAXN];
pair<int, int> tmp_rmqdata[MAXN * 2];
int rmqposition[MAXN];
int TMP_RMQDATA;
void calc_accumulate(int n) {
rmqposition[n] = TMP_RMQDATA;
tmp_rmqdata[TMP_RMQDATA++] = make_pair(depth[n], n);
for (auto eid : adj[n])
if (eid != parent_edge[n]) {
int to = xo[eid] ^ n;
dp_acc[to] =
dp_acc[n] - calc_only(n, eid) - cost[eid] + calc_not(to, eid);
depth[to] = depth[n] + 1;
parent_edge[to] = eid;
calc_accumulate(to);
tmp_rmqdata[TMP_RMQDATA++] = make_pair(depth[n], n);
}
}
int main() {
ios::sync_with_stdio(false);
cin >> N >> Q;
for (int i = (1); i < (N + 1); i++) cin >> A[i];
for (int i = (0); i < (N + 1); i++) adj[i].clear();
for (int i = (1); i < (N); i++) {
int a, b;
long long c;
cin >> a >> b >> c;
etox[i][0] = int((adj[a]).size());
etox[i][1] = int((adj[b]).size());
adj[a].push_back(i);
adj[b].push_back(i);
xo[i] = a ^ b;
cost[i] = c;
edgeval[i][0] = a;
edgeval[i][1] = b;
}
for (int i = (1); i < (N + 1); i++)
dp_not[i] = dp_only[i] = vector<long long>(int((adj[i]).size()), -1);
for (int i = (1); i < (N + 1); i++) dp_all[i] = -1;
for (int i = (1); i < (N + 1); i++)
for (auto e : adj[i]) calc_not(i, e);
for (int n = (1); n < (N + 1); n++) {
assert(dp_all[n] != -1);
if (todo[n] != -1) {
int neid = adj[n][todo[n]];
dp_only[n][todo[n]] =
max(0ll, calc_not(xo[neid] ^ n, neid) - cost[neid] * 2ll);
dp_all[n] += dp_only[n][todo[n]];
todo[n] = -1;
}
for (int i = (0); i < (int((adj[i]).size())); i++)
assert(dp_only[n][i] != -1);
for (int i = (0); i < (int((adj[i]).size())); i++)
assert(dp_not[n][i] != -1);
}
parent_edge[1] = -1;
dp_acc[1] = dp_all[1];
depth[1] = 0;
TMP_RMQDATA = 0;
calc_accumulate(1);
vector<pair<int, int> > rmqdata(tmp_rmqdata, tmp_rmqdata + TMP_RMQDATA);
cerr << TMP_RMQDATA << endl;
RMQ<pair<int, int> > rmq(rmqdata, make_pair(N + 1, N + 1));
rmq.init();
for (int q = (0); q < (Q); q++) {
int a, b;
cin >> a >> b;
if (rmqposition[b] < rmqposition[a]) swap(a, b);
int lc = rmq.query(rmqposition[a], rmqposition[b] + 1).second;
assert(lc > 0 && lc <= N);
long long ares = dp_acc[a] + dp_acc[b] - 2 * dp_acc[lc] + dp_all[lc];
cout << ares << endl;
}
return 0;
for (int i = (1); i < (N + 1); i++) {
cout << i << ": all=" << dp_all[i];
for (auto eid : adj[i]) {
cout << " (" << i << "->" << (xo[eid] ^ i) << "):not=" << calc_not(i, eid)
<< " only=" << calc_only(i, eid);
}
cout << endl;
}
for (int i = (1); i < (N + 1); i++) {
cout << i << " dp=" << dp_acc[i] << " depth=" << depth[i];
if (parent_edge[i] != -1) cout << " parent=" << (xo[parent_edge[i]] ^ i);
cout << endl;
}
return 0;
}
| 2,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long s[20][20][20][2], n, len, a0[20];
inline long long Calc(long long x, long long y) {
while (y) x /= 10, y--;
int ma = 0;
while (x) ma = max(ma, int(x % 10)), x /= 10;
return ma;
}
long long Solve(long long x, long long y) {
long long ans = 0;
for (int i = 1; i <= y && x >= a0[i - 1]; i++) {
int ma = Calc(x, i), k = x % a0[i] / a0[i - 1], now = x % 10;
if (x % 10 == 0) {
ans++;
x -= ma;
continue;
}
if ((k == 9 && i != y) || i == 1) continue;
for (; k >= 0; k--)
ans += s[i - 1][max(ma, k)][now][0], x -= s[i - 1][max(ma, k)][now][1],
now = (now - (s[i - 1][max(ma, k)][now][1]) % 10 + 10) % 10;
}
if (x < 0)
return ans - 1;
else if (x < 10)
return ans + 1;
else
return ans + Solve(x, y - 1);
}
int main() {
cin >> n;
if (n < 10) {
puts(!n ? "0" : "1");
return 0;
}
long long p = n;
while (p) p /= 10, len++;
a0[0] = 1;
for (int i = 1; i <= 18; i++) a0[i] = a0[i - 1] * 10;
for (int i = 1; i <= 9; i++)
for (int j = 0; j <= 9; j++)
if (i <= j)
s[1][i][j][1] = i + j, s[1][i][j][0] = 2;
else
s[1][i][j][1] = i, s[1][i][j][0] = 1;
for (int i = 2; i < len; i++)
for (int j = 1; j <= 9; j++)
for (int k = 1; k <= 9; k++) {
long long cnt = 0, tot = 0, now = k;
for (int l = 9; l >= 0; l--)
cnt += s[i - 1][max(j, l)][now][0],
tot += s[i - 1][max(j, l)][now][1],
now = (now - (s[i - 1][max(j, l)][now][1]) % 10 + 10) % 10;
s[i][j][k][0] = cnt;
s[i][j][k][1] = tot;
}
printf("%I64d\n", Solve(n, len));
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long n, m, x, y, k = 2e9;
for (cin >> n >> m; m--;) {
cin >> x >> y;
k = min(k, y - x + 1);
}
cout << k << "\n";
for (long i = long(0); i < long(n); i++) cout << i % k << " ";
}
| 1,700 | CPP |
#import math
#from functools import lru_cache
#import heapq
#from collections import defaultdict
#from collections import Counter
#from collections import deque
#from sys import stdout
#from sys import setrecursionlimit
#setrecursionlimit(10**7)
from sys import stdin
input = stdin.readline
INF = 10**9 + 7
MAX = 10**7 + 7
MOD = 10**9 + 7
for Ti in range(int(input().strip())):
n = int(input().strip())
if(n<31):
print('NO')
else:
print('YES')
if(n-30 in [6, 14, 10]):
m1, m2 = 15, n-31
else:
m1, m2 = 14, n-30
print('6 10', m1, m2)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n = 2 * n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
map<int, pair<int, int>> d;
map<int, int> dd;
map<int, pair<int, int>>::iterator it;
for (int i = 0; i < n; i++) {
it = d.find(a[i]);
if (it == d.end())
d[a[i]].first = i;
else
d[a[i]].second = i;
}
for (int i = 1; i < n / 2; i++) dd[i] = 0;
int ans = 0, x;
for (int i = 0; i < n; i++) {
if (dd[a[i]] == 0) {
ans += d[a[i]].second - d[a[i]].first - 1;
x = d[a[i]].second - d[a[i]].first - 1;
for (int j = 1; j <= n / 2; j++) {
if (d[j].first > i and d[j].first < d[a[i]].second) d[j].first++;
if (d[j].second > i and d[j].second < d[a[i]].second) d[j].second++;
}
d[a[i]].second -= x;
dd[a[i]] = 1;
}
}
cout << ans << endl;
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a = 6, b = 10, c = 14, d = 15;
int n;
cin >> n;
if (n <= 30)
cout << "NO\n";
else {
if (n - a - b - c != a && n - a - b - c != b && n - a - b - c != c) {
cout << "YES\n";
cout << a << ' ' << b << ' ' << c << ' ' << n - a - b - c << '\n';
} else {
if (n <= 31) {
cout << "NO\n";
} else {
cout << "YES\n";
cout << a << ' ' << b << ' ' << d << ' ' << n - a - b - d << '\n';
}
}
}
}
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, t, cn, a[2000 + 5];
int main() {
int T, i, j, k;
while (~scanf("%d %d", &n, &t)) {
for (i = 0; i < n; i++) {
scanf("%d %d", &j, &k);
a[i * 2] = j * 2 + k;
a[i * 2 + 1] = j * 2 - k;
}
sort(a, a + 2 * n);
n *= 2;
t *= 2;
cn = 2;
for (i = 1; i < n; i += 2) {
if (a[i + 1] - a[i] > t)
cn += 2;
else if (a[i + 1] - a[i] == t)
cn++;
}
printf("%d\n", cn);
}
return 0;
}
| 1,200 | CPP |
n=int(input())
a=list(map(int,input().split()))
for i in sorted(a): print(i,end=" ")
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, c;
vector<int> adj[100001];
const int N = 1000000;
vector<int> v1, v2;
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
vector<int> d(n + 1, -1);
for (int i = 1; i <= n; ++i) {
if (d[i] == -1 && adj[i].size() > 0) {
queue<int> q;
q.push(i);
d[i] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
if (!d[v])
v1.push_back(v);
else
v2.push_back(v);
for (int j = 0; j < adj[v].size(); ++j) {
if (d[adj[v][j]] == -1) {
d[adj[v][j]] = !d[v];
q.push(adj[v][j]);
} else if (d[adj[v][j]] == 1) {
if (d[v] == 1) {
cout << -1;
return 0;
}
} else {
if (d[v] == 0) {
cout << -1;
return 0;
}
}
}
}
}
}
cout << v1.size() << "\n";
for (int i = 0; i < v1.size(); ++i) cout << v1[i] << " ";
cout << "\n" << v2.size() << "\n";
for (int i = 0; i < v2.size(); ++i) cout << v2[i] << " ";
}
| 1,500 | CPP |
import sys
input=sys.stdin.readline
import collections
from collections import defaultdict
visited=set()
mem=[]
G=defaultdict(list)
n=int(input())
l=[int(i) for i in input().split()]
l=[i for i in l if i>0]
if len(l)>=121 :
print(3)
elif len(l)<3:
print(-1)
else:
for i in range(1,len(l)):
for j in range(0,i):
if l[i]&l[j]!=0:
G[i].append(j)
G[j].append(i)
#print(G)
min_cycle = n + 1
for key, _ in G.items():
#print(key,_)
qu = collections.deque()
qu.append((key, 0, None))
visited = {}
while len(qu) > 0:
#print(qu,visited)
node = qu.popleft()
visited[node[0]] = node[1]
for child in G[node[0]]:
if child not in visited:
qu.append((child, node[1] + 1, node[0]))
#print(qu)
else:
if node[2] != child:
min_cycle = min(min_cycle, visited[child] + node[1] + 1)
#print(min_cycle,visited[child],node[1])
if min_cycle == n + 1:
print(-1)
else:
print(min_cycle)
| 1,900 | PYTHON3 |
import sys
nm=list(map(int,input().split(' ')))
ms=list(map(int,input().split(' ')))
n=nm[0]
m=nm[1]
counter=[0]*m
diff=[0]*n
times=0
for mi in ms:
diff[mi-1]+=1
counter[diff[mi-1]-1]+=1
if counter[diff[mi-1]-1]%n==0 :
times+=1
sys.stdout.write('1')
else:
sys.stdout.write('0')
| 1,300 | PYTHON3 |
st = input()
a = 0
for c in st:
if c == "a":
a += 1
print(min(len(st), a*2-1)) | 800 | PYTHON3 |
n=int(input())
for i in range(0,n):
n1=int(input())
l=list(map(int,input().split()))
for j in range(n1-1,-1,-1):
print(l[j],end=" ")
print() | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 301;
short sec[maxn][maxn], thr[maxn][maxn][maxn];
int main() {
char LGM[] = "BitLGM", Aryo[] = "BitAryo";
int n, x, y, z;
scanf("%d", &n);
if (n == 1) {
scanf("%d", &x);
x ? puts(LGM) : puts(Aryo);
} else if (n == 2) {
scanf("%d%d", &x, &y);
memset(sec, 0, sizeof sec);
for (int i = 1; i < maxn; ++i) sec[i][0] = 1;
for (int i = 1; i < maxn; ++i) {
sec[i][i] = 1;
for (int j = 1; j < i; ++j)
if (!sec[i][j]) {
for (int ii = 1; i + ii < maxn; ++ii) sec[i + ii][j + ii] = 1;
for (int ii = i + 1; ii < maxn; ++ii) sec[ii][j] = 1;
for (int ii = j + 1; ii < maxn; ++ii) {
if (i >= ii)
sec[i][ii] = 1;
else
sec[ii][i] = 1;
}
}
}
if (x < y) swap(x, y);
sec[x][y] ? puts(LGM) : puts(Aryo);
} else {
scanf("%d%d%d", &x, &y, &z);
for (int i = 0; i < maxn; ++i) {
for (int j = 0; j <= i; ++j) {
for (int k = 0; k <= j; ++k) {
thr[i][j][k] = 0;
}
}
}
for (int i = 1; i < maxn; ++i) thr[i][0][0] = 1;
for (int i = 1; i < maxn; ++i) {
for (int j = 1; j <= i; ++j) {
if (i != j) thr[i][j][0] = 1;
}
}
for (int i = 1; i < maxn; i++) {
for (int j = 1; j <= i; ++j) {
for (int k = 1; k <= j; ++k)
if (!thr[i][j][k]) {
if (i == j || i == k || j == k) {
thr[i][j][k] = 1;
} else {
for (int ii = 1; ii + i < maxn; ++ii)
thr[ii + i][j + ii][k + ii] = 1;
for (int ii = 1; ii + i < maxn; ++ii) {
thr[ii + i][j][k] = 1;
}
for (int ii = 1; ii + j < maxn; ++ii) {
if (i >= ii + j)
thr[i][ii + j][k] = 1;
else
thr[ii + j][i][k] = 1;
}
for (int ii = 1; ii + k < maxn; ++ii) {
if (ii + k > i)
thr[ii + k][i][j] = 1;
else if (ii + k > j)
thr[i][ii + k][j] = 1;
else
thr[i][j][ii + k] = 1;
}
}
}
}
}
if (y > x) swap(x, y);
if (z > x) swap(x, z);
if (z > y) swap(y, z);
thr[x][y][z] ? puts(LGM) : puts(Aryo);
}
return 0;
}
| 2,100 | CPP |
def ans(s):
aaa=0
t=0
for i in s:
if i=="L":
t+=1
else:
aaa=max(aaa,t)
t=0
aaa=max(aaa,t)
return aaa+1
for i in range(int(input())):
s=input()
print(ans(s))
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int to[100010 << 1], nxt[100010 << 1], head[100010], tot;
int f[100010][210], g[210], h[210], k, sz[100010], fac[210], C[210][210];
char *p1, *p2, buf[100000];
int rd() {
int x = 0, f = 1;
char c =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++);
while (c < 48) {
if (c == '-') f = -1;
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++);
}
while (c > 47) {
x = (((x << 2) + x) << 1) + (c ^ 48),
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++);
}
return x * f;
}
inline void add(int x, int y) {
to[++tot] = y;
nxt[tot] = head[x];
head[x] = tot;
}
void dfs(int p, int fa) {
sz[p] = 1;
f[p][0] = 2;
for (int i = head[p]; i; i = nxt[i]) {
if (to[i] != fa) {
dfs(to[i], p);
for (int j = 0; j <= min(sz[p] + sz[to[i]] - 1, k); j++) {
g[j] = 0;
}
for (int j = 0; j < sz[p] && j <= k; j++) {
for (int l = 0; l <= sz[to[i]] && j + l <= k; l++) {
g[j + l] = (g[j + l] + (long long)f[p][j] * f[to[i]][l] % mod) % mod;
}
}
sz[p] += sz[to[i]];
for (int j = 0; j <= min(sz[p] - 1, k); j++) {
f[p][j] = g[j];
}
}
}
if (p == 1) {
for (int i = 0; i <= k; i++) {
h[i] = (h[i] + f[p][i]) % mod;
}
} else {
for (int i = 1; i <= k; i++) {
h[i] = (h[i] - f[p][i - 1]) % mod;
}
h[1] = (h[1] + 1) % mod;
}
for (int i = k; i >= 1; i--) {
f[p][i] = (f[p][i] + f[p][i - 1]) % mod;
}
f[p][1] = (f[p][1] - 1 + mod) % mod;
}
void init() {
fac[0] = 1;
for (int i = 1; i <= k; i++) {
fac[i] = (long long)fac[i - 1] * i % mod;
}
C[0][0] = 1;
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= i; j++) {
C[i][j] = ((long long)C[i - 1][j] * j % mod + C[i - 1][j - 1]) % mod;
}
}
}
int main() {
int n = rd();
k = rd();
init();
for (int i = 1; i < n; i++) {
int x = rd(), y = rd();
add(x, y);
add(y, x);
}
dfs(1, 1);
int ans = 0;
for (int i = 0; i <= k; i++) {
ans = (ans + (long long)C[k][i] * fac[i] % mod * h[i] % mod) % mod;
}
cout << (ans + mod) % mod << endl;
return 0;
}
| 3,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
complex<double> p[1000];
int ans[2000];
int len, N, n;
const double pi = acos(-1.0);
const double sd = cos(36.0 / 180 * pi) * 10 * 2;
const double ag = 2 * asin(5 / sd);
struct pol {
int p[5];
} num[200];
void dfs(int tp, const complex<double>& s) {
if (tp == n) return;
num[tp].p[0] = tp;
p[len] = complex<double>(real(s) + sd, imag(s));
num[tp].p[1] = len;
ans[N++] = len++;
dfs(tp + 1, p[len - 1]);
p[len] = complex<double>(real(p[tp + 1]) - cos(ag) * sd,
imag(p[tp + 1]) - sin(ag) * sd);
num[tp].p[2] = len;
ans[N++] = len++;
p[len] = complex<double>(real(p[len - 1]) + sin(ag / 2) * sd,
imag(p[len - 1]) + cos(ag / 2) * sd);
num[tp].p[3] = len;
ans[N++] = len++;
p[len] = complex<double>(real(p[len - 1]) + sin(ag / 2) * sd,
imag(p[len - 1]) - cos(ag / 2) * sd);
num[tp].p[4] = len;
ans[N++] = len++;
ans[N++] = tp;
}
int main() {
ans[0] = 0;
p[0] = complex<double>(0, 0);
while (cin >> n) {
N = len = 1;
dfs(0, p[0]);
cout << len << endl;
for (int i = 0; i < len; i++)
printf("%.11lf %.11lf\n", real(p[i]), imag(p[i]));
for (int i = 0; i < n; i++) {
int* p = num[i].p;
for (int j = 0; j < 5; j++) num[i].p[j]++;
cout << p[0] << " " << p[3] << " " << p[1] << " " << p[4] << " " << p[2]
<< endl;
}
for (int i = 0; i < N; i++) cout << ans[i] + 1 << " ";
cout << endl;
}
}
| 2,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
long long sumofdigit(long long n) {
long long sum = 0;
while (n) {
sum = sum + n % 10;
n = n / 10;
}
return sum;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
return a * b / gcd<T>(a, b);
}
template <class T>
inline T power(T b, T p) {
long long ans = 1;
while (p--) ans *= b;
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long a, b, c;
cin >> a >> b >> c;
vector<long long> v;
for (long long i = 1; i <= 81; i++) {
long long x = b * pow(i, a) + c;
if (sumofdigit(x) == i && x <= 1000000000 && x >= 0) v.push_back(x);
}
cout << v.size() << endl;
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
}
| 1,500 | CPP |
t = int(input())
for t_ in range(t):
s = input()
t = input()
flag = False
for c in s:
if c in t:
flag = True
break
if flag:
print("YES")
else:
print("NO")
| 1,000 | PYTHON3 |
t = int(input())
def sign(number):
if number>0:
return 1
else:
return -1
for i in range(t):
n = int(input())
a = list(map(int, input().split()))
sum = 0
j=0
while(j<n):
cur = a[j]
k = j
while(k<n and (sign(a[j])==sign(a[k]))):
cur = max(cur, a[k])
k += 1
sum += cur
j = k - 1
j+= 1
print(sum)
| 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10100;
const double eps = 1e-9;
struct node {
int x, y;
node operator+(const node &q) const { return node{x + q.x, y + q.y}; }
node operator-(const node &q) const { return node{x - q.x, y - q.y}; }
bool operator==(const node &q) const { return x == q.x && y == q.y; }
long long len_2() { return x * x + y * y; }
void print() {
printf("%d %d\n", x, y);
return;
}
} a[N], b[N], p[N];
int dj(node x, node y) { return x.x * y.x + x.y * y.y; }
int cj(node x, node y) { return x.x * y.y - x.y * y.x; }
int n, m;
bool cal(node x, node y) {
double l = -1e9, r = 1e9;
for (int i = 1; i <= n; i++) {
node op1 = x - a[i], op2 = y - a[i];
if (cj(op1, op2) == 0) continue;
double op = 1.0 * dj(op1, op2) / cj(op1, op2);
if (cj((a[i] - x), (y - x)) < 0)
l = max(l, op);
else
r = min(r, op);
}
for (int i = 1; i <= m; i++) {
node op1 = x - b[i], op2 = y - b[i];
if (cj(op1, op2) == 0) {
if (b[i].x >= min(x.x, y.x) && b[i].x <= max(x.x, y.x) &&
b[i].y >= min(x.y, y.y) && b[i].y <= max(x.y, y.y))
return 0;
continue;
}
double op = 1.0 * dj(op1, op2) / cj(op1, op2);
if (cj((b[i] - x), (y - x)) > 0)
l = max(l, op);
else
r = min(r, op);
}
return l + eps < r;
}
bool dfs(int l, int r) {
if (l == r - 1) return 0;
int mid;
double op = 1e9;
for (int i = l + 1; i <= r - 1; i++) {
node op1 = p[i] - p[l], op2 = p[i] - p[r];
double x = 1.0 * dj(op1, op2) / cj(op1, op2);
if (x < op) op = x, mid = i;
}
return cal(p[l], p[mid]) || cal(p[r], p[mid]) || dfs(l, mid) || dfs(mid, r);
}
bool cmp1(node x, node y) { return x.x == y.x ? x.y < y.y : x.x < y.x; }
bool cmp2(node x, node y) {
node op1 = x - a[1], op2 = y - a[1];
int op = cj(op1, op2);
return op == 0 ? op1.len_2() < op2.len_2() : op > 0;
}
bool check() {
sort(a + 1, a + n + 1, cmp1);
sort(a + 2, a + n + 1, cmp2);
int top = 0;
p[++top] = a[1], p[++top] = a[2];
for (int i = 3; i <= n; i++) {
while (top >= 2 && cj((a[i] - p[top - 1]), (p[top] - p[top - 1])) >= 0)
top--;
p[++top] = a[i];
}
return cal(p[1], p[top]) || dfs(1, top);
}
int main() {
scanf("%d%d", &n, &m);
if (n == 1 || m == 1) return puts("YES"), 0;
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].x, &a[i].y);
for (int i = 1; i <= m; i++) scanf("%d%d", &b[i].x, &b[i].y);
bool flag = check();
swap(a, b);
swap(n, m);
flag |= check();
if (flag)
puts("YES");
else
puts("NO");
return 0;
}
| 2,700 | CPP |
def f(n):
i = 2
while(i<=n):
if i == n:
return(True)
else:
i = i*2
return(False)
def g(n):
l = int(n**(1/2))+1
c = 0
for i in range(2,l+1):
if n%i == 0:
if i%2 ==1 and (n//i)%2 == 1:
c = c+2
elif i%2 == 1 or (n//i)%2 == 1:
c = c+1
if c>1:
return(True)
return(False)
t = int(input())
while(t>0):
t = t-1
n = int(input())
if n == 1:
print("FastestFinger")
elif n == 2:
print("Ashishgup")
elif f(n) == True:
print("FastestFinger")
elif n%2 == 1:
print("Ashishgup")
elif (n//2)%2 == 0:
print("Ashishgup")
elif (n//2)%2 == 1:
if g(n//2) == True:
print("Ashishgup")
else:
print("FastestFinger") | 1,400 | PYTHON3 |
######################################################################
# Write your code here
#import sys
#import resource
#resource.setrlimit(resource.RLIMIT_STACK, [0x10000000, resource.RLIM_INFINITY])
#sys.setrecursionlimit(0x100000)
# Write your code here
RI = lambda : [int(x) for x in input().strip().split()]
rw = lambda : input().strip().split()
from collections import defaultdict as df
#import heapq
#heapq.heapify(li) heappush(li,4) heappop(li)
#import random
#random.shuffle(list)
#infinite = float('inf')
#######################################################################
n=int(input())
m=RI()#deck
l=RI()#pile
index=df(int)
for i in range(n):
if(l[i]!=0):
index[l[i]]=(i+1)
extra=[0]*(n+1)
for i in range(n):
if(index[i+1]==0):
extra[i+1]=1
else:
extra[i+1]=index[i+1]+1
e=n
s=n-1
while(l[s]!=1):
if(l[s-1]==l[s]-1):
s-=1
continue
else:
break
if(l[s]==1):
for i in range(n-s):
extra[i+1]=-1
#################without zero card
sumo=0
flag=0
for i in range(n):
if(extra[i+1]==-1):
continue
if(extra[i+1]<=sumo+1):
sumo+=1
else:
flag=1
break
#print(sumo)
if(flag==0):
print(sumo)
else:
for i in range(n):
if(index[i+1]==0):
extra[i+1]=1
else:
extra[i+1]=index[i+1]+1
sumo=0
for i in range(n):
if(extra[i+1]<=sumo+1):
sumo+=1
else:
sumo=extra[i+1]
print(sumo)
| 1,800 | PYTHON3 |
import re
s=str(input())
p=re.compile('WUB')
res=p.sub(' ',s)
print (res) | 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
int arr[2][N];
int main() {
int n;
cin >> n;
int q;
cin >> q;
int x, y;
int v = 0, c1 = 0, c2 = 0;
while (q--) {
cin >> x >> y;
x--;
if (arr[x][y] && arr[1 - x][y]) v--;
if (x == 0 && arr[0][y] && arr[1][y + 1]) c1--;
if (x == 1 && arr[1][y] && arr[0][y - 1]) c1--;
if (x == 0 && arr[0][y] && arr[1][y - 1]) c2--;
if (x == 1 && arr[1][y] && arr[0][y + 1]) c2--;
arr[x][y] = 1 - arr[x][y];
if (arr[x][y] && arr[1 - x][y]) v++;
if (x == 0 && arr[0][y] && arr[1][y + 1]) c1++;
if (x == 1 && arr[1][y] && arr[0][y - 1]) c1++;
if (x == 0 && arr[0][y] && arr[1][y - 1]) c2++;
if (x == 1 && arr[1][y] && arr[0][y + 1]) c2++;
if (v || c1 || c2) {
cout << "No" << endl;
} else {
cout << "Yes" << endl;
}
}
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC optimize("no-stack-protector,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
template <class S, class T>
inline S smax(S &l, T r) {
return l = max(l, (S)r);
}
template <class S, class T>
inline S smin(S &l, T r) {
return l = min(l, (S)r);
}
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, m, d;
cin >> n >> m >> d;
vector<long long> dp(n);
vector<long long> pd(n);
long long time = 0;
for (long long i = 0; i < m; ++i) {
long long a, b, t;
cin >> a >> b >> t;
a--;
long long mx = 0;
for (long long j = 0; j < n; ++j)
if (dp[mx] < dp[j]) mx = j;
for (long long j = 0; j < n; ++j) {
if ((j + (t - time) * d) <= mx)
pd[j] = dp[j + (t - time) * d];
else if ((j - (t - time) * d) >= mx)
pd[j] = dp[j - (t - time) * d];
else
pd[j] = dp[mx];
}
for (long long j = 0; j < n; ++j) pd[j] += (b - abs(a - j));
for (long long j = 0; j < n; ++j) dp[j] = pd[j];
time = t;
}
long long ans = (long long)(-1e9);
for (long long i : dp) smax(ans, i);
cout << ans << "\n";
return 0;
}
| 2,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 + 10;
int r, c;
pair<int, int> e, s;
char a[MAXN][MAXN];
int lev[MAXN][MAXN], ans;
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
void bfs() {
queue<pair<int, int>> q;
q.push(e);
lev[e.first][e.second] = 1;
while (!q.empty()) {
pair<int, int> u = q.front();
q.pop();
for (int i = 0; i < 4; i++)
if (lev[u.first + dx[i]][u.second + dy[i]] >
lev[u.first][u.second] + 1 and
a[u.first + dx[i]][u.second + dy[i]] != 'T') {
lev[u.first + dx[i]][u.second + dy[i]] = lev[u.first][u.second] + 1;
q.push({u.first + dx[i], u.second + dy[i]});
}
}
}
int main() {
memset(lev, 5, sizeof(lev));
memset(a, 'T', sizeof(a));
cin >> r >> c;
for (int i = 1; i <= r; i++)
for (int j = 1; j <= c; j++) {
cin >> a[i][j];
if (a[i][j] == 'E') e = {i, j};
if (a[i][j] == 'S') s = {i, j};
}
bfs();
for (int i = 1; i <= r; i++)
for (int j = 1; j <= c; j++)
if (lev[i][j] <= lev[s.first][s.second] and isdigit(a[i][j]))
ans += int(a[i][j] - '0');
cout << ans << endl;
return 0;
}
| 1,500 | CPP |
n=int(input())
if n%2==0 :
print(4,end=' ')
print(n-4)
else :
print(9,end=' ')
print(n-9) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 20;
const int maxb = 20;
vector<int> adj[maxn], x[maxn];
int p[maxn][maxb], st[maxn], ft[maxn], t, from[maxn], to[maxn], w[maxn],
h[maxn];
long long fen_dp[maxn], fen_pd[maxn];
long long dp[maxn], pd[maxn];
long long get_pd(int v) {
v = st[v];
long long res = 0;
for (v++; v > 0; v -= v & (-v)) res += fen_pd[v];
return res;
}
void update_pd(int v, long long val) {
for (v++; v < maxn; v += v & (-v)) fen_pd[v] += val;
}
long long get_dp(int v) {
v = st[v];
long long res = 0;
for (v++; v > 0; v -= v & (-v)) res += fen_dp[v];
return res;
}
void update_dp(int v, long long val) {
for (v++; v < maxn; v += v & (-v)) fen_dp[v] += val;
}
void set_dfs(int v) {
st[v] = ++t;
for (auto u : adj[v]) {
p[u][0] = v;
for (int i = 1; i < maxb; i++) p[u][i] = p[p[u][i - 1]][i - 1];
h[u] = h[v] + 1;
set_dfs(u);
}
ft[v] = t;
}
bool is_par(int v, int u) { return st[v] <= st[u] && st[u] <= ft[v]; }
int lca(int v, int u) {
for (int i = maxb - 1; i >= 0; i--)
if (!is_par(p[v][i], u)) v = p[v][i];
if (is_par(v, u)) return v;
return p[v][0];
}
void dfs(int v) {
for (auto u : adj[v]) dfs(u), pd[v] += dp[u];
update_pd(st[v], pd[v]);
update_pd(ft[v] + 1, -pd[v]);
for (auto e : x[v]) {
long long a = 0, b = 0;
if (from[e] != v) a = get_pd(from[e]) - pd[v] - get_dp(from[e]);
if (to[e] != v) b = get_pd(to[e]) - pd[v] - get_dp(to[e]);
dp[v] = max(dp[v], w[e] + a + b + pd[v]);
}
dp[v] = max(dp[v], pd[v]);
update_dp(st[v], dp[v]);
update_dp(ft[v] + 1, -dp[v]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i < n; i++) {
int p;
cin >> p;
p--;
adj[p].push_back(i);
}
set_dfs(0);
for (int i = 0; i < m; i++) {
cin >> from[i] >> to[i] >> w[i];
from[i]--;
to[i]--;
x[lca(from[i], to[i])].push_back(i);
}
dfs(0);
cout << dp[0] << endl;
}
| 2,400 | CPP |
a=int(input())
if a%2==0 and not(a==2):
print("Yes")
else:
print("No")
| 800 | PYTHON3 |
#include <bits/stdc++.h>
const int INF = 0x7F7F7F7F;
const double EPS = 1e-10;
const long long mod7 = 1e9 + 7;
const long long mod9 = 1e9 + 9;
using namespace std;
inline long long rit() {
long long f = 0, key = 1;
char c;
do {
c = getchar();
if (c == '-') key = -1;
} while (c < '0' || c > '9');
do {
f = f * 10 + c - '0';
c = getchar();
} while (c >= '0' && c <= '9');
return f * key;
}
inline void fprt(double f) { printf("%.08lf", f); }
void init() {}
string sa, sb;
void read() { cin >> sa >> sb; }
void solve() {
if (sa == sb)
cout << -1 << endl;
else
cout << max((int)((sa).size()), (int)((sb).size()));
}
int main() {
int nn = 1;
while (nn--) {
init(), read(), solve();
}
return 0;
}
| 1,000 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 51, MOD = 1e9 + 7;
int n, m;
vector<int> v;
bool left, rightt, up, down;
double a, b, c, xx1, xx2, yy1, yy2;
double man(double a, double a2, double b, double b2) {
return abs(a - b) + abs(a2 - b2);
}
double dist(double a, double a2, double b, double b2) {
return sqrt((a - b) * (a - b) + (a2 - b2) * (a2 - b2));
}
double lineToPoint(double beginx, double beginy, double endx, double endy) {
double res = 0;
double nx = ((-b * endy) - c) / a;
res += dist(beginx, beginy, nx, endy);
res += abs(nx - endx);
double res2 = 0;
double ny = ((-a * endx) - c) / b;
res2 += dist(beginx, beginy, endx, ny);
res2 += abs(ny - endy);
return min(res, res2);
}
int main() {
scanf("%lf%lf%lf", &a, &b, &c);
scanf("%lf%lf%lf%lf", &xx1, &yy1, &xx2, &yy2);
double res = man(xx1, yy1, xx2, yy2);
if (a == 0 || b == 0) {
return printf("%.9lf", res), 0;
}
double distToLine = abs(xx1 - ((-b * yy1) - c) / a);
double lp = lineToPoint(((-b * yy1) - c) / a, yy1, xx2, yy2);
res = min(res, distToLine + lp);
distToLine = abs(yy1 - ((-a * xx1) - c) / b);
lp = lineToPoint(xx1, ((-a * xx1) - c) / b, xx2, yy2);
res = min(res, distToLine + lp);
return printf("%.9lf", res), 0;
return 0;
}
| 1,900 | CPP |
import math
def div(n,k):
return math.ceil(k/(n-1))+k-1
t=int(input())
for i in range(t):
string=input()
I=string.split()
n=int(I[0])
k=int(I[1])
print(div(n,k))
| 1,200 | PYTHON3 |
def main():
n, s = map(int, input().split())
cities = []
for i in range(n):
x, y, p = map(int, input().split())
dist = (x**2 + y**2)**(1/2)
cities.append((x, y, p, dist))
cities.sort(key=lambda city: city[3])
total = s
for city in cities:
total += city[2]
if total >= 10**6:
print((city[0]**2 + city[1]**2)**(1/2))
return
print(-1)
if __name__ == '__main__':
main() | 1,200 | PYTHON3 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
long long a[2 * 100000 + 5];
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
int left[2 * 100000 + 5], right[2 * 100000 + 5];
for (int i = 0; i < n; i++) {
left[i] = i - 1;
right[i] = i + 1;
}
right[n - 1] = -1;
for (int i = 0; i < n; i++) {
int cur = i;
while (left[cur] != -1 && a[left[cur]] == a[cur]) {
int l = left[cur], r = right[cur];
a[l]++;
right[l] = r;
left[r] = l;
cur = l;
}
}
int cnt = 0;
for (int i = 0; i != -1;) {
cnt++;
i = right[i];
}
printf("%d\n", cnt);
for (int i = 0; i != -1;) {
printf("%I64d ", a[i]);
i = right[i];
}
printf("\n");
}
| 1,900 | CPP |
n=int(input())
l=[]
li=[]
for i in range(n):
a,b=map(int,input().split())
if a<0:
l.append(a)
else:
li.append(a)
if len(l)==1 or len(li)==1:
print("YES")
elif len(l)==n or len(li)==n:
print("YES")
else:
print("NO")
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110;
int mp[MAXN][MAXN];
int row[MAXN], col[MAXN];
int ans[MAXN][MAXN];
int main() {
int n, m, i, j, k;
while (scanf("%d%d", &n, &m) == 2) {
memset(row, 0, sizeof(row));
memset(col, 0, sizeof(col));
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) ans[i][j] = 1;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%d", &mp[i][j]);
if (!mp[i][j]) {
for (k = 0; k < n; k++) ans[k][j] = 0;
for (k = 0; k < m; k++) ans[i][k] = 0;
}
}
}
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
row[i] += ans[i][j];
col[j] += ans[i][j];
}
int flag = 1;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (mp[i][j] && !ans[i][j]) {
if (row[i] == 0 && col[j] == 0) {
flag = 0;
break;
}
}
}
}
if (!flag) {
printf("NO\n");
continue;
}
printf("YES\n");
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) printf("%d ", ans[i][j]);
printf("\n");
}
}
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
char r, g, b;
r = 'R';
g = 'G';
b = 'B';
int n;
cin >> n;
string s;
cin >> s;
int cnt = 0;
for (int i = 1; i < n; i++) {
if (s[i] == s[i - 1]) {
cnt++;
if (s[i] == r) {
s[i] = b;
if (s[i + 1] == b || s[i + 1] == r) {
s[i] = g;
} else if (s[i + 1] == g) {
s[i] = b;
}
} else if (s[i] == b) {
s[i] = g;
if (s[i + 1] == g || s[i + 1] == b) {
s[i] = r;
} else if (s[i + 1] == r) {
s[i] = g;
}
} else if (s[i] == g) {
s[i] = r;
if (s[i + 1] == b || s[i + 1] == g) {
s[i] = r;
} else if (s[i + 1] == r) {
s[i] = b;
}
}
}
}
cout << cnt << "\n";
cout << s;
}
| 1,400 | CPP |
"""
Author: Q.E.D
Time: 2020-06-16 09:36:16
"""
T = int(input())
for _ in range(T):
b = input()
a = b[0] + b[1:-1:2] + b[-1]
print(a) | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int solve(const vector<int>& a) {
set<int> todo;
for (auto x : a) {
if (0 == x % 2) todo.insert(x);
}
int res = 0;
while (!todo.empty()) {
int m = *todo.rbegin();
todo.erase(m);
m /= 2;
if (0 == m % 2) {
todo.insert(m);
}
++res;
}
return res;
}
int main() {
cin.sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
cout << solve(a) << endl;
}
return 0;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x7ffffffffffffff;
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
return a > 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b) {
return a < b ? b : a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b) {
return a < b ? a : b;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
(a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
(a > b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
register char ch(getchar());
bool f(false);
while (ch < 48 || ch > 57) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (ch >= 48 && ch <= 57)
x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
if (f) x = -x;
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
register char ch(getchar());
while (ch < 65 || ch > 122 || (ch > 90 && ch < 97)) ch = getchar();
register char *tar = s;
*tar = ch, ch = getchar();
while ((ch >= 65 && ch <= 90) || (ch >= 97 && ch <= 122))
*(++tar) = ch, ch = getchar();
return tar - s + 1;
}
const int N = 100005;
int a[N];
__inline__ __attribute__((always_inline)) bool cmp(const int &a, const int &b) {
return a > b;
}
int main() {
int n, x, y;
read(n);
long long ans = 0;
for (int i = 1; i <= n; ++i) {
read(x, y);
a[i] = x - y;
ans += -x + 1ll * y * n;
}
std::sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; ++i) {
ans += 1ll * a[i] * i;
}
printf("%lld\n", ans);
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, b = 0, be;
cin >> n;
for (int i = 0; i < n; i++) {
int ne;
cin >> ne;
if (ne != be && i > 0) {
b++;
}
be = ne;
}
cout << ++b << endl;
}
| 800 | CPP |
def gns():
return list(map(int,input().split()))
n,m=gns()
a=[]
for i in range(n):
a.append(gns())
b=[[0]*m for i in range(n)]
def one():
ans=[]
for i in range(n-1):
for j in range(m-1):
if a[i][j]==1 and a[i+1][j]==1 and a[i][j+1]==1 and a[i+1][j+1]==1:
ans.append([i,j])
b[i][j]=1
b[i][j+1]=1
b[i+1][j]=1
b[i+1][j+1]=1
# if i==n-1 or j==m-1:
# if a[i][j]!=b[i][j]:
# return False
# continue
# if b[i][j]==1 and a[i][j]==0:
# return False
# if a[i][j]==1 and b[i][j]==0:
# ans.append([i,j])
# b[i][j]=1
# b[i+1][j]=1
# b[i][j+1]=1
# b[i+1][j+1]=1
for i in range(n):
for j in range(m):
if b[i][j]!=a[i][j]:
return False
return ans
ans=one()
if ans==False:
print(-1)
quit()
if len(ans)==0:
print(0)
quit()
print(len(ans))
for x in ans:
print(x[0]+1,x[1]+1)
| 1,200 | PYTHON3 |
t = int(input())
for _ in range(t):
# n = int(input())
a,b,n,s = list(map(int,input().split()))
if a*n==s:
print("YES")
continue
if a*n<s:
if b>=s-a*n:
print("YES")
else:
print("NO")
continue
if b>=s%n:
print("YES")
else:
print("NO")
# if (a>=s//n and b>=s%n):
# print("YES")
# else:
# print("NO")
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long t = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c <= '9' && c >= '0') t = t * 10 + c - 48, c = getchar();
return t * f;
}
struct edge {
int to, next, v;
} e[101000 * 2];
int fl[101000], f[101000], vis[101000], dp[101000][2][2], mo = 1e9 + 7;
int n, tot = 1, m, u, v, del, pdu, pdv, an0, an1, cnt;
void add(int x, int y, int v) {
e[++tot] = (edge){y, f[x], v};
f[x] = tot;
}
void add(int x, int y, int v1, int v2) {
x = abs(x);
y = abs(y);
add(x, y, v1);
add(y, x, v2);
}
void dfs(int x, int pre) {
cnt -= 2;
vis[x] = 1;
for (int i = f[x]; i; i = e[i].next) {
cnt++;
if (e[i].to == x) cnt++;
if (!vis[e[i].to])
dfs(e[i].to, i);
else if (i != (pre ^ 1)) {
u = x;
v = e[i].to;
del = i;
}
}
}
int check(int k1, int k2, int k3) {
if ((k3 & 2) == 0) k1 ^= 1;
if ((k3 & 1) == 0) k2 ^= 1;
return k1 | k2;
}
void treedp(int x, int fa) {
for (int i = f[x]; i; i = e[i].next)
if (e[i].to != fa && (i ^ del) && (i ^ del ^ 1)) treedp(e[i].to, x);
memset(dp[x], 0, sizeof(dp[x]));
for (int w = 0; w <= 1; ++w) {
if (x == u && w != pdu) continue;
if (x == v && w != pdv) continue;
int ans0 = 1, ans1 = 0;
for (int i = f[x]; i; i = e[i].next) {
int to = e[i].to;
if (to == fa || !(i ^ del) || !(i ^ del ^ 1)) continue;
int an0 = ans0, an1 = ans1;
ans0 = 0;
ans1 = 0;
for (int w1 = 0; w1 <= 1; ++w1) {
int A = dp[to][w1][0], B = dp[to][w1][1];
if (check(w, w1, e[i].v)) swap(A, B);
ans0 = (ans0 + 1ll * A * an0 + 1ll * B * an1) % mo;
ans1 = (ans1 + 1ll * A * an1 + 1ll * B * an0) % mo;
}
}
if (fl[x] & (1 << w)) swap(ans0, ans1);
dp[x][w][0] = (dp[x][w][0] + ans0) % mo;
dp[x][w][1] = (dp[x][w][1] + ans1) % mo;
}
}
void solve(int x) {
cnt = 0;
del = -100;
dfs(x, -1);
int ans0 = 0, ans1 = 0;
if (del == -100) {
v = 0;
u = x;
pdu = 0;
pdv = 1;
treedp(x, 0);
ans0 = (ans0 + 1ll * dp[x][0][0] + dp[x][1][0]) % mo;
ans1 = (ans1 + 1ll * dp[x][0][1] + dp[x][1][1]) % mo;
pdu = 1;
treedp(x, 0);
ans0 = (ans0 + 1ll * dp[x][0][0] + dp[x][1][0]) % mo;
ans1 = (ans1 + 1ll * dp[x][0][1] + dp[x][1][1]) % mo;
} else {
for (pdu = 0; pdu < 2; pdu++)
for (pdv = 0; pdv < 2; pdv++) {
treedp(u, 0);
if (check(pdu, pdv, e[del].v))
swap(dp[u][0][0], dp[u][0][1]), swap(dp[u][1][0], dp[u][1][1]);
ans0 = (ans0 + 1ll * dp[u][0][0] + dp[u][1][0]) % mo;
ans1 = (ans1 + 1ll * dp[u][0][1] + dp[u][1][1]) % mo;
}
}
int k0 = an0, k1 = an1;
an0 = ((long long)k0 * ans0 + (long long)k1 * ans1) % mo;
an1 = ((long long)k0 * ans1 + (long long)k1 * ans0) % mo;
}
int T;
int main() {
T = read();
n = read();
while (T--) {
int x, y;
x = read();
if (x == 1) {
y = read();
if (y > 0)
fl[y] |= 2;
else
fl[-y] |= 1;
} else {
x = read();
y = read();
if (x < 0 && y < 0) add(x, y, 0, 0);
if (x < 0 && y > 0) add(x, y, 1, 2);
if (x > 0 && y < 0) add(x, y, 2, 1);
if (x > 0 && y > 0) add(x, y, 3, 3);
}
}
an0 = 1;
an1 = 0;
for (int i = 1; i <= n; ++i)
if (!vis[i]) solve(i);
printf("%d", an1);
}
| 2,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = ((int)1e5) + 5;
long long int dp[maxn][301];
int a[maxn], b[maxn];
int n, m, s, e;
set<int> pos[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> s >> e;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
cin >> b[i];
pos[b[i]].insert(i);
}
long long int ans = 0;
fill(&dp[0][0], &dp[0][0] + maxn * 301, (long long int)1e9);
for (int i = 0; i <= n; i++) {
for (int used = 0; used <= min(i, min(n, (s / e))); used++) {
if (i == 0 || used == 0) {
dp[i][used] = 0;
continue;
}
long long int& res = dp[i][used];
res = min(res, dp[i - 1][used]);
int p = dp[i - 1][used - 1];
int toFind = a[i - 1];
auto it = pos[toFind].lower_bound(p);
if (it != pos[toFind].end()) {
res = min(res, *it + 1ll);
}
int deleted = i + dp[i][used];
int usedEnergy = e * used;
if (deleted + usedEnergy <= s) {
ans = max(ans, used + 0ll);
}
}
}
cout << ans;
return 0;
}
| 2,300 | CPP |
a,b=map(int,input().split())
aw=bw=d=0
for i in range(1,7):
if abs(a-i)<abs(b-i):
aw+=1
elif abs(a-i)==abs(b-i):
bw+=1
else:
d+=1
print(aw,bw,d)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
string s[1000000];
bool cmp(string s1, string s2) {
long long sa = 0, ha = 0, sb = 0, hb = 0;
for (char ch : s1) {
if (ch == 's') {
sa++;
} else {
ha++;
}
}
for (char ch : s2) {
if (ch == 's') {
sb++;
} else {
hb++;
}
}
return sa * hb > sb * ha;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
sort(s, s + n, cmp);
long long ans = 0, c = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < s[i].size(); j++) {
if (s[i][j] == 's') {
c++;
} else {
ans += c;
}
}
}
cout << ans << endl;
return 0;
}
| 1,800 | CPP |
Subsets and Splits