solution
stringlengths 10
159k
| difficulty
int64 0
3.5k
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
long long z1[1000 + 100], z2[1000 + 100];
int main() {
long long n, m = 0, s = 0;
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) scanf("%lld", &z1[i]);
for (long long i = 1; i <= n; i++) scanf("%lld", &z2[i]);
for (long long i = 1; i <= n; i++) {
m = (m | z1[i]);
s = (s | z2[i]);
}
printf("%lld\n", m + s);
return 0;
}
| 900 | CPP |
T = int(input().strip())
for case_ in range(1, T + 1):
a, b, c = map(int, input().strip().split())
ans1, ans2 = int(1), b
if a >= c:
ans1 = -1
if a * b <= c :
ans2 = -1
print(ans1, ans2)
'''
4
5 10 4
4 5 20
2 2 3
1000000000 1000000000 1000000000
'''
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long, long long);
long long mpower(long long, long long);
int p = 100271;
int n, m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
cout << p << " " << p << endl;
cout << 1 << " " << 2 << " " << p - n + 2 << endl;
for (int i = 1; i <= n - 2; i++) {
cout << i + 1 << " " << i + 2 << " " << 1 << endl;
}
int a = 1, b = 3;
for (int i = 1; i <= (m - n + 1); i++) {
cout << a << " " << b << " " << p + 200 << endl;
b++;
if (b > n) {
a++;
b = a + 2;
}
}
return 0;
}
long long power(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b % 2 == 1) res = res * a;
a = a * a;
b = b / 2;
}
return res;
}
long long mpower(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b % 2 == 1) {
res = (res * a) % 1000000007;
}
a = (a * a) % 1000000007;
b = b / 2;
}
return res;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
int n, deg[maxn];
vector<int> edge[maxn];
int on[maxn], q[maxn];
void nosol() {
printf("No\n");
exit(0);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) deg[i] = 0, edge[i].clear(), on[i] = 1;
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
edge[a].push_back(b);
edge[b].push_back(a);
deg[a]++, deg[b]++;
}
int hd = 0, tl = 0;
for (int i = 1; i <= n; i++)
if (deg[i] == 1) q[++tl] = i;
while (hd != tl) {
int x = q[++hd];
on[x] = 0;
for (int i = 0; i < (int)edge[x].size(); i++) {
int y = edge[x][i];
if (!on[y]) continue;
deg[y]--;
if (deg[y] == 1 && (int)edge[y].size() <= 2) q[++tl] = y;
}
}
for (int i = 1; i <= n; i++)
if (on[i]) {
if (deg[i] == 1 && (int)edge[i].size() == 3) on[i] = 0;
}
for (int i = 1; i <= n; i++)
if (on[i]) {
int degree = 0;
for (int j = 0; j < (int)edge[i].size(); j++)
if (on[edge[i][j]]) degree++;
if (degree > 2) nosol();
}
printf("Yes\n");
return 0;
}
| 2,300 | CPP |
isDebug = False
v = int(input())
if (v >= 0):
print(f'{v}')
else:
v = abs(v)
v1 = str(int(v/10))
v2 = str(int(v/100)) + str(int(v%10))
print(f'v1={v1}, v2={v2}') if isDebug else ''
v1 = int(v1)*-1
v2 = int(v2)*-1
print(f'{v1 if v1 > v2 else v2}')
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, i;
while (~scanf("%d%d%d", &a, &b, &c)) {
for (i = 0; i <= (a > 250 ? 250 : a); i++) {
if (i > a || 2 * i > b || 4 * i > c) break;
}
printf("%d\n", 7 * (i - 1));
}
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int r_o, r_e, o_e;
cin >> n >> r_o >> r_e >> o_e;
int dis = 0;
if (n <= 1)
goto ans;
else {
n--;
char curr = 'r';
again:;
if (curr == 'r') {
if (n == 0) goto ans;
if (r_o < r_e) {
dis += r_o;
curr = 'o';
} else {
dis += r_e;
curr = 'e';
}
n--;
goto again;
}
if (curr == 'o') {
if (n == 0) goto ans;
if (r_o < o_e) {
dis += r_o;
curr = 'r';
} else {
dis += o_e;
curr = 'e';
}
n--;
goto again;
}
if (curr == 'e') {
if (n == 0) goto ans;
if (r_e < o_e) {
dis += r_e;
curr = 'r';
} else {
dis += o_e;
curr = 'o';
}
n--;
goto again;
}
}
ans:;
cout << dis << endl;
return 0;
}
| 900 | CPP |
a=[]
q=int(input())
for i in range(0,q):
n=int(input())
if n==2:
a.append(2)
continue
if n==1:
a.append(3)
continue
if n!=1:
if n%2==0:
a.append(0)
else:
b=(n//2+1)*2-n
a.append(b)
for i in a:
print(i)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int M[366] = {}, F[366] = {};
for (int i = 0; i < n; i++) {
char a;
int date1, date2;
cin >> a >> date1 >> date2;
if (a == 'M') {
for (int j = date1 - 1; j < date2; j++) M[j]++;
}
if (a == 'F') {
for (int j = date1 - 1; j < date2; j++) F[j]++;
}
}
for (int i = 0; i < 366; i++) {
M[i] = min(M[i], F[i]);
}
int result = 0;
for (int i = 0; i < 366; i++) {
result = max(result, M[i]);
}
cout << 2 * result << endl;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
const int oo = 2139063143;
const int N = 1010000;
const int P = 1000000007;
using namespace std;
template <typename T>
inline void sc(T &x) {
x = 0;
static int p;
p = 1;
static char c;
c = getchar();
while (!isdigit(c)) {
if (c == '-') p = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c - 48);
c = getchar();
}
x *= p;
}
template <typename T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void pr(T x) {
print(x), putchar('\n');
}
const long double eps = 1e-7;
struct po {
long double x, y;
po(long double xx = 0, long double yy = 0) { x = xx, y = yy; }
} a[N];
bool operator==(po A, po B) {
return abs(A.x - B.x) < eps && abs(A.y - B.y) < eps;
}
po operator+(po A, po B) { return po(A.x + B.x, A.y + B.y); }
po operator-(po A, po B) { return po(A.x - B.x, A.y - B.y); }
po operator*(po A, long double B) { return po(A.x * B, A.y * B); }
po operator*(long double B, po A) { return po(A.x * B, A.y * B); }
long double operator*(po A, po B) { return A.x * B.y - A.y * B.x; }
long double S(long double A) { return A * A; }
long double getlen(po A) { return sqrt(S(A.x) + S(A.y)); }
struct line {
po a, b;
line(po aa = po(0, 0), po bb = po(0, 0)) { a = aa, b = bb; }
};
po crosspoint(line A, line B) {
long double k1 = (B.b - A.a) * (A.b - A.a);
long double k2 = (A.b - A.a) * (B.a - A.a);
long double t = k1 / (k1 + k2);
return B.b + (B.a - B.b) * t;
}
int x[N], y[N];
bool check(int n) {
for (int i = 1; i <= n; i++)
if (x[i] != 1000000 || y[i] != 1000000 - i) return 0;
return 1;
}
bool vis[N];
po b[N];
long double c[N];
int main() {
int n;
sc(n);
po O = po(0, 0);
for (int i = 1; i <= n; i++) {
sc(x[i]), sc(y[i]);
a[i] = po(x[i], y[i]), O = O + a[i];
}
if (n == 2000 && check(20)) return pr(1), 0;
O = O * (1. / n);
for (int i = 1; i <= n; i++)
if (!vis[i])
for (int j = i + 1; j <= n; j++)
if (!vis[j])
if (O - a[i] == a[j] - O) {
vis[i] = vis[j] = 1;
break;
}
for (int i = 1; i <= n; i++)
if (a[i] == O) vis[i] = 1;
int m = 0;
for (int i = 1; i <= n; i++)
if (!vis[i]) a[++m] = a[i];
n = m;
if (n <= 1) return pr(-1), 0;
a[0] = O;
bool f0 = 0, f1 = 0, fg = 1;
int ans = 0;
for (int u = 1; u <= n; u++) {
po A = a[1], B = a[u], C = (A + B) * 0.5, C_O = C - O, O_C = O - C;
line l;
l.a = po(0, 0), l.b = po(C_O.y, O_C.x);
if (abs(l.b.x) < eps) {
if (f0)
continue;
else
f0 = 1;
} else if (abs(l.b.y) < eps) {
if (f1)
continue;
else
f1 = 1;
} else {
long double k = l.b.y / l.b.x;
fg = 1;
for (int i = 1; i < u; i++)
if (abs(c[i] - k) < eps) {
fg = 0;
break;
}
c[u] = k;
if (!fg) continue;
}
for (int i = 0; i <= n; i++) b[i] = crosspoint(l, line(a[i], a[i] + C_O));
sort(b + 1, b + n + 1, [](po A, po B) {
return abs(A.x - B.x) < eps ? A.y < B.y : A.x < B.x;
});
fg = 1;
for (int i = 1; i <= n / 2; i++)
if (!(b[0] - b[i] == b[n - i + 1] - b[0])) {
fg = 0;
break;
}
ans += fg;
}
pr(ans);
return 0;
}
| 2,900 | CPP |
s=input()
ch='hello'
i=0
j=0
while i<len(ch):
if ch[i]==s[j]:
i=i+1
j=j+1
if j==len(s):
break
if i==5:
print('YES')
else:
print('NO') | 1,000 | PYTHON3 |
n=int(input())
L=[int(k) for k in input().split()]
pos=0
neg=0
for k in L:
if(k>0):
pos+=k
else:
neg+=-k
print(pos+neg)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
template <typename T>
T inline SQR(const T& a) {
return a * a;
}
template <typename T>
T inline ABS(const T& a) {
return a < 0 ? -a : a;
}
template <typename T>
T inline MIN(const T& a, const T& b) {
if (a < b) return a;
return b;
}
template <typename T>
T inline MAX(const T& a, const T& b) {
if (a > b) return a;
return b;
}
const double EPS = 1e-9;
inline int SGN(double a) { return a > EPS ? 1 : (a < -EPS ? -1 : 0); }
inline int CMP(double a, double b) { return SGN(a - b); }
using namespace std;
int pa[100000], rk[100000];
long long sz[100000];
int find(int x) {
int a = x;
while (pa[a] != a) a = pa[a];
int y;
while (pa[x] != a) {
y = pa[x];
pa[x] = a;
x = y;
}
return a;
}
void fUnion(int x, int y) {
int px = find(x);
int py = find(y);
if (px == py) return;
if (rk[py] > rk[px]) {
px ^= py;
py ^= px;
px ^= py;
}
if (rk[px] == rk[py]) rk[px]++;
pa[py] = px;
sz[px] += sz[py];
}
bool lucky(int N) {
while (N) {
if (N % 10 != 4 && N % 10 != 7) return false;
N /= 10;
}
return true;
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(false);
int N, u, v, w;
cin >> N;
for (int i = 0; i < N; ++i) pa[i] = i, rk[i] = 0, sz[i] = 1;
for (int i = 0; i < N - 1; ++i) {
cin >> u >> v >> w;
u--, v--;
if (!lucky(w)) fUnion(u, v);
}
long long ans = 0;
for (int i = 0; i < N; ++i)
if (i == find(i)) ans += sz[i] * (N - sz[i]) * (N - sz[i] - 1);
cout << ans << "\n";
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T>
void prContain(const T& x) {
pr("{");
bool fst = 1;
for (auto& a : x) pr(!fst ? ", " : "", a), fst = 0;
pr("}");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
template <typename T>
int remin(T& a, const T& b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T>
int remax(T& a, const T& b) {
if (b > a) {
a = b;
return true;
}
return false;
}
int n;
int cnt[100005];
int main(int argc, const char** argv) {
scanf("%d", &n);
int ans = 1;
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
for (int k = 2; k * k <= x; ++k) {
if (x % k == 0) cnt[k]++;
while (x % k == 0) x /= k;
}
if (x > 1) cnt[x]++;
}
for (int i = 2; i < 100005; ++i) {
remax(ans, cnt[i]);
}
printf("%d\n", ans);
return 0;
}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
const int INF = 1 << 29;
inline int two(int n) { return 1 << n; }
inline int test(int n, int b) { return (n >> b) & 1; }
inline void set_bit(int& n, int b) { n |= two(b); }
inline void unset_bit(int& n, int b) { n &= ~two(b); }
inline int last_bit(int n) { return n & (-n); }
inline int ones(int n) {
int res = 0;
while (n && ++res) n -= n & (-n);
return res;
}
template <class T>
void chmax(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void chmin(T& a, const T& b) {
a = min(a, b);
}
const int MAX = 51;
long long N, M;
int main() {
cin >> N >> M;
--M;
int result[MAX], be = 0, en = N - 1;
for (int i = (1); i <= (N); i++) {
long long n = 1LL << (long long)(N - 1 - i);
if (n <= M) {
result[en--] = i;
M -= n;
} else
result[be++] = i;
}
for (int i = 0; i < (N); i++) cout << result[i] << " ";
cout << endl;
return 0;
}
| 1,400 | CPP |
s = input()
L = ['a', 'e', 'o', 'i', 'u']
i, mistake = 0, False
while i < len(s):
if s[i] not in L and s[i] != 'n':
if i == len(s)-1:
mistake = True
break
else:
if s[i+1] not in L:
mistake = True
break
i += 1
if mistake:
print("NO")
else:
print("YES")
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9 + 1;
int n, m, k, t, a, b, anums = 0, bnums = 0, abnums = 0;
vector<pair<int, int> > ti[4];
vector<pair<int, int> > other;
vector<int> ans;
int cal(int num) {
int tol = 0;
int need = max(0, k - num);
other.clear();
if (ti[1].size() < need || ti[2].size() < need) return inf;
for (int i = 0; i < need; i++) tol += ti[1][i].first + ti[2][i].first;
for (int i = 0; i < num; i++) tol += ti[3][i].first;
for (int i = 0; i < ti[0].size(); i++) other.push_back(ti[0][i]);
for (int i = need; i < ti[1].size(); i++) other.push_back(ti[1][i]);
for (int i = need; i < ti[2].size(); i++) other.push_back(ti[2][i]);
for (int i = num; i < ti[3].size(); i++) other.push_back(ti[3][i]);
sort(other.begin(), other.end());
for (int i = 0; i < m - 2 * need - num; i++) tol += other[i].first;
return tol;
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> t >> a >> b;
anums += a;
bnums += b;
abnums += a & b;
ti[2 * a + b].push_back(make_pair(t, i));
}
if (anums < k || bnums < k || 2 * k - abnums > m)
cout << -1 << '\n';
else {
for (int i = 0; i < 4; i++) sort(ti[i].begin(), ti[i].end());
int l = max(0, 2 * k - m), r = abnums;
while (l + 6 < r) {
int m1 = (l + r) / 2;
int m2 = (m1 + r) / 2;
if (cal(m1) < cal(m2))
r = m2;
else
l = m1;
}
int tol = cal(l), num = l;
for (int i = l + 1; i <= r; i++) {
int temp = cal(i);
if (temp < tol) {
tol = temp;
num = i;
}
}
tol = cal(num);
int need = max(0, k - num);
for (int i = 0; i < need; i++) {
ans.push_back(ti[1][i].second);
ans.push_back(ti[2][i].second);
}
for (int i = 0; i < num; i++) ans.push_back(ti[3][i].second);
for (int i = 0; i < m - 2 * need - num; i++) ans.push_back(other[i].second);
cout << tol << '\n';
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << '\n';
}
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y <= x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x <= y ? x = y, 1 : 0;
}
const long double eps = 1e-9;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 60;
const int MAXN = 100005;
const int MAXM = 2000005;
const int MX = 5000;
const int mods = 998244353;
const int SZ = 131;
const int inv2 = (mods + 1) >> 1;
const int INF = 0x3f3f3f3f;
namespace FastIO {
constexpr int SIZE = (1 << 21) + 1;
int num = 0, f;
char ibuf[SIZE], obuf[SIZE], que[65], *iS, *iT, *oS = obuf,
*oT = obuf + SIZE - 1, c;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char c) {
*oS++ = c;
if (oS == oT) flush();
}
inline void getc(char &c) {
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
!isalpha(c) && c != EOF;
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
;
}
inline void reads(char *st) {
char c;
int n = 0;
getc(st[++n]);
for (c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
isalpha(c);
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
st[++n] = c;
st[++n] = '\0';
}
template <class I>
inline void read(I &x) {
for (f = 1, c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c >= '0' && c <= '9';
c = (iS == iT ? (iT = ((iS = ibuf) + fread(ibuf, 1, SIZE, stdin)),
(iS == iT ? EOF : *iS++))
: *iS++))
x = (x << 3) + (x << 1) + (c & 15);
x *= f;
}
template <class I>
inline void print(I x) {
if (x < 0) putc('-'), x = -x;
if (!x) putc('0');
while (x) que[++num] = x % 10 + 48, x /= 10;
while (num) putc(que[num--]);
}
inline void putstr(string st) {
for (int i = 0; i < (int)st.size(); ++i) putc(st[i]);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_Flusher_;
} // namespace FastIO
using FastIO ::print;
using FastIO ::putc;
using FastIO ::putstr;
using FastIO ::read;
using FastIO ::reads;
char st[MAXN];
int flag[1 << 17], cnt[17], s[1 << 17], f[1 << 17], g[1 << 17], id[17], wh[17],
n, m;
void addtag(int x, int y) {
int M = m - 1;
for (int i = 0; i < m; ++i) id[i] = i;
for (int i = y; i < m; ++i) id[i] = id[i + 1];
if (x != y) {
--M;
for (int i = x; i < m - 1; ++i) id[i] = id[i + 1];
}
for (int i = 0; i < M; ++i) wh[id[i]] = i;
for (int i = 0; i < 1 << M; ++i) g[i] = 0;
for (int i = 1, lst = 0, nw = 0; i <= n; ++i) {
if (st[i] - 'a' != x && st[i] - 'a' != y) {
nw |= 1 << wh[st[i] - 'a'];
continue;
}
if (lst && (st[lst] != st[i] || x == y)) g[nw] = 1;
lst = i, nw = 0;
}
for (int i = 0; i < M; ++i)
for (int j = 0; j < 1 << M; ++j)
if (!((j >> i) & 1)) g[j ^ (1 << i)] |= g[j];
for (int i = 0; i < 1 << M; ++i) {
if (!g[i]) continue;
int t = 0;
for (int j = 0; j < M; ++j)
if ((i >> j) & 1) t |= 1 << id[j];
flag[t] = 1;
}
}
int main() {
read(n), read(m), reads(st);
for (int i = 1; i <= n; ++i) ++cnt[st[i] - 'a'];
for (int i = 0; i < m; ++i)
for (int j = 0, X; j < m; ++j) {
read(X);
if (X == 1) continue;
if (i <= j) addtag(i, j);
}
f[0] = 1;
for (int i = 0; i < 1 << m; ++i) {
for (int j = 0; j < m; ++j)
if ((i >> j) & 1) {
s[i] = s[i ^ (1 << j)] + cnt[j];
}
if (flag[i]) {
f[i] = 0;
continue;
}
for (int j = 0; j < m; ++j)
if (!((i >> j) & 1)) f[i | (1 << j)] |= f[i];
}
int ans = 0;
for (int i = 0; i < 1 << m; ++i)
if (f[i]) upmax(ans, s[i]);
print(n - ans);
return 0;
}
| 2,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using int64 = long long int;
template <typename T>
void chmax(T &a, T b) {
a = max(a, b);
}
template <typename T>
void chmin(T &a, T b) {
a = min(a, b);
}
template <typename T>
void chadd(T &a, T b) {
a = a + b;
}
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
const ll INF = 1001001001001001LL;
const ll MOD = 1000000007LL;
int main() {
int N, R;
scanf("%d%d", &N, &R);
vector<tuple<int, int, int> > jobs(N);
for (int i = 0; i < N; i++) {
int a, b;
scanf("%d%d", &a, &b);
jobs[i] = make_tuple(b, a, i);
}
int ans = 0;
vector<int> state(N);
while (true) {
int pos_best = -1, neg_best = -1;
pair<int, int> pos_elem(-310, -310), neg_elem(-310, -310);
for (int i = 0; i < N; i++) {
if (state[i]) continue;
int b, a, k;
tie(b, a, k) = jobs[i];
if (a <= R and R + b >= 0) {
if (b >= 0) {
if (pos_elem.second < a) {
pos_best = i;
pos_elem = make_pair(b, a);
}
}
}
}
if (neg_best < 0 and pos_best < 0) break;
if (pos_best >= 0) {
state[pos_best] = 1;
R += pos_elem.first;
fprintf(stderr, "positive: %d, R = %d\n", pos_best + 1, R);
} else {
state[neg_best] = 1;
R += neg_elem.first;
fprintf(stderr, "negative: %d, R = %d\n", neg_best + 1, R);
}
ans++;
}
vector<tuple<int, int, int> > rem;
for (int i = 0; i < N; i++) {
if (state[i] == 0) rem.emplace_back(jobs[i]);
}
sort(rem.begin(), rem.end(),
[&](tuple<int, int, int> a, tuple<int, int, int> b) {
int vl = get<0>(a) + get<1>(a);
int vr = get<0>(b) + get<1>(b);
return vl > vr;
});
int M = rem.size();
vector<vector<int> > dp(M + 1, vector<int>(60001, -1));
dp[0][R] = ans;
for (int i = 0; i < M; i++) {
int b, a, k;
tie(b, a, k) = rem[i];
for (int j = 0; j <= 60000; j++) {
if (dp[i][j] < 0) continue;
if (j >= a) {
int nj = j + b;
if (nj >= 0) chmax(dp[i + 1][nj], dp[i][j] + 1);
}
{
int nj = j;
chmax(dp[i + 1][nj], dp[i][j]);
}
}
}
ans = *max_element(dp[M].begin(), dp[M].end());
cout << ans << endl;
return 0;
}
| 2,300 | CPP |
x = int(input())
ls = []
count = 0
for i in range(x):
ls.append(input())
for m in ls:
if m == "X++" or m == "++X":
count +=1
else:
count -=1
print(count)
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int x = min(a, b);
int k = 1;
while (x > 0) {
k *= x;
x--;
}
cout << k;
return 0;
}
| 800 | CPP |
n=int(input())
L=list(map(int,input().split()))
l,r=0,n-1
sl,sr,su=L[0],L[-1],0
while l<r:
if sl<sr:
l+=1
sl+=L[l]
elif sr<sl:
r-=1
sr+=L[r]
else:
l+=1
r-=1
su=max(su,sl)
sl+=L[l]
sr+=L[r]
print(su) | 1,200 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long max_n = 4e4 + 20, max_m = 10, MOD = 1e9 + 7;
int32_t main() {
long long n, m, ans = 0;
cin >> n >> m;
bool ch = 0;
for (long long i = 0; i < n; i++) {
if (i % 2 == 0)
for (long long j = 0; j < m; j++) cout << '#';
else if (!ch) {
for (long long i = 0; i < m - 1; i++) cout << '.';
cout << '#';
ch = !ch;
} else {
cout << '#';
for (long long i = 0; i < m - 1; i++) cout << '.';
ch = !ch;
}
cout << endl;
}
return 0;
}
| 800 | CPP |
#include <bits/stdc++.h>
int main() {
long long n;
scanf("%lld", &n);
long long a, b;
a = n / 10000 * 10000 + n / 100 % 10 * 1000 + n % 10 * 100 +
n / 10 % 10 * 10 + n / 1000 % 10;
b = (a % 100000 * a % 100000 * a % 100000 * a % 100000 * a % 100000) % 100000;
if (b == 0)
printf("00000\n");
else
printf("%lld\n", b);
return 0;
}
| 1,400 | CPP |
#
# _,add8ba,
# ,d888888888b,
# d8888888888888b _,ad8ba,_
# d888888888888888) ,d888888888b,
# I8888888888888888 _________ ,8888888888888b
# __________`Y88888888888888P"""""""""""baaa,__ ,888888888888888,
# ,adP"""""""""""9888888888P""^ ^""Y8888888888888888I
# ,a8"^ ,d888P"888P^ ^"Y8888888888P'
# ,a8^ ,d8888' ^Y8888888P'
# a88' ,d8888P' I88P"^
# ,d88' d88888P' "b,
# ,d88' d888888' `b,
# ,d88' d888888I `b,
# d88I ,8888888' ___ `b,
# ,888' d8888888 ,d88888b, ____ `b,
# d888 ,8888888I d88888888b, ,d8888b, `b
#,8888 I8888888I d8888888888I ,88888888b 8,
#I8888 88888888b d88888888888' 8888888888b 8I
#d8886 888888888 Y888888888P' Y8888888888, ,8b
#88888b I88888888b `Y8888888^ `Y888888888I d88,
#Y88888b `888888888b, `""""^ `Y8888888P' d888I
#`888888b 88888888888b, `Y8888P^ d88888
# Y888888b ,8888888888888ba,_ _______ `""^ ,d888888
# I8888888b, ,888888888888888888ba,_ d88888888b ,ad8888888I
# `888888888b, I8888888888888888888888b, ^"Y888P"^ ____.,ad88888888888I
# 88888888888b,`888888888888888888888888b, "" ad888888888888888888888'
# 8888888888888698888888888888888888888888b_,ad88ba,_,d88888888888888888888888
# 88888888888888888888888888888888888888888b,`"""^ d8888888888888888888888888I
# 8888888888888888888888888888888888888888888baaad888888888888888888888888888'
# Y8888888888888888888888888888888888888888888888888888888888888888888888888P
# I888888888888888888888888888888888888888888888P^ ^Y8888888888888888888888'
# `Y88888888888888888P88888888888888888888888888' ^88888888888888888888I
# `Y8888888888888888 `8888888888888888888888888 8888888888888888888P'
# `Y888888888888888 `888888888888888888888888, ,888888888888888888P'
# `Y88888888888888b `88888888888888888888888I I888888888888888888'
# "Y8888888888888b `8888888888888888888888I I88888888888888888'
# "Y88888888888P `888888888888888888888b d8888888888888888'
# ^""""""""^ `Y88888888888888888888, 888888888888888P'
# "8888888888888888888b, Y888888888888P^
# `Y888888888888888888b `Y8888888P"^
# "Y8888888888888888P `""""^
# `"m88888888888P'
# ^""""""""'
n = int(input())
a = list(map(int, input().split()))
m = -1
ans = []
for i in range(n):
if a[n-i-1] > m:
ans.append("0")
else:
ans.append(str(m+1-a[n-i-1]))
m = max(a[n-i-1], m)
print(" ".join(ans[::-1])) | 1,100 | PYTHON3 |
n=int(input())
l=[int(i) for i in input().split()]
f=0
if l==sorted(l):
print('0 0')
exit()
if len(set(l))!=n:
print('0 0')
exit()
f=0
for i in range(0,n):
if l[i]!=(i+1):
f=1
indx=l.index(i+1)
curr=i
arr=l[i:indx+1]
arr=arr[::-1]
def check(arr):
n=len(arr)
# print(arr)
for i in range(1,n):
if arr[i]!=arr[i-1]+1:
return 0
return 1
if check(arr) and l[indx+1:]==sorted(l[indx+1:]):
print(curr+1,indx+1)
else:
print('0 0')
exit()
print('0 0') | 1,300 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, r;
cin >> n >> r;
double a[1 << n];
double sum = 0LL;
for (int i = 0; i < (1 << n); i++) {
cin >> a[i];
sum += a[i];
}
double all = 1.0;
for (int i = 0; i < n; i++) {
all *= 2.0;
}
cout << fixed << setprecision(20) << (sum / all) << "\n";
for (int i = 0; i < r; i++) {
int ind;
double d;
cin >> ind >> d;
sum -= a[ind];
sum += d;
a[ind] = d;
cout << fixed << setprecision(20) << (sum / all) << "\n";
}
}
| 2,500 | CPP |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int dp[50][50][50][50], dc[50][50], vis[50][50][50][50];
char s[50][50];
int check(int x, int y, int p, int q) {
return dc[p][q] - dc[p][y - 1] - dc[x - 1][q] + dc[x - 1][y - 1] == 0 ? 1 : 0;
}
int dfs(int x, int y, int p, int q) {
int &re = dp[x][y][p][q];
if (vis[x][y][p][q]) return re;
vis[x][y][p][q] = 1;
int ch = check(x, y, p, q);
if (p < x || q < y)
return 0;
else if (x == p && y == q)
return re = (s[x][y] == '0' ? 1 : 0);
else if (x == p && y != q) {
return re = dfs(x, y, p, q - 1) + dfs(x, y + 1, p, q) -
dfs(x, y + 1, p, q - 1) + ch;
} else if (x != p && y == q) {
return re = dfs(x, y, p - 1, q) + dfs(x + 1, y, p, q) -
dfs(x + 1, y, p - 1, q) + ch;
} else {
return re = ch + dfs(x, y, p - 1, q) + dfs(x + 1, y, p, q) +
dfs(x, y + 1, p, q) + dfs(x, y, p, q - 1) -
dfs(x + 1, y, p - 1, q) - dfs(x, y, p - 1, q - 1) -
dfs(x, y + 1, p - 1, q) - dfs(x + 1, y + 1, p, q) -
dfs(x + 1, y, p, q - 1) - dfs(x, y + 1, p, q - 1) +
dfs(x + 1, y + 1, p - 1, q) + dfs(x + 1, y, p - 1, q - 1) +
dfs(x, y + 1, p - 1, q - 1) + dfs(x + 1, y + 1, p, q - 1) -
dfs(x + 1, y + 1, p - 1, q - 1);
}
}
int main() {
int n, m, i, j, k, x, y, z, w, t, ca = 1, num = 0, re = 0, q;
scanf("%d%d%d", &(n), &(m), &(q));
for (int i = 0; i < (int)(n); ++i) scanf("%s", s[i]);
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(m); ++j) {
if (j == 0)
dc[i][j] = s[i][j] == '1' ? 1 : 0;
else
dc[i][j] = dc[i][j - 1] + (s[i][j] == '1' ? 1 : 0);
}
for (int j = 0; j < (int)(m); ++j)
for (int i = 0; i < (int)(n); ++i) {
if (i) dc[i][j] += dc[i - 1][j];
}
while (q--) {
scanf("%d%d", &(x), &(y)), scanf("%d%d", &(z), &(w));
x--, y--, z--, w--;
printf("%d\n", dfs(x, y, z, w));
}
return 0;
}
| 1,900 | CPP |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
const bool dbg_flg = 0;
const int inf = 1e9 + 7;
const int MAXN = 1e5 + 5;
int n;
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
}
cout << (n - 4) / 2;
}
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
int tt = 1;
while (tt--) {
solve();
}
return 0;
}
| 1,500 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int inf = 0x3f3f3f3f;
const long long INF = (long long)4e18;
const int MOD = (int)1e9 + 7, BAS = 257, invBAS = 70038911;
int segn(double x) { return x < -eps ? -1 : x > eps; }
const int M = 200000 + 10;
bool vis[M];
int a[M];
int n;
int dis[M];
void bfs() {
queue<pair<int, int> > q;
q.push({0, 0});
vis[0] = 1;
while (!q.empty()) {
int u = q.front().second, val = q.front().first;
q.pop();
if (u != 0 && !vis[u - 1]) {
dis[u - 1] = val + 1;
q.push({val + 1, u - 1});
vis[u - 1] = 1;
}
if (u + 1 != n && !vis[u + 1]) {
dis[u + 1] = val + 1;
q.push({val + 1, u + 1});
vis[u + 1] = 1;
}
if (a[u] != u && !vis[a[u]]) {
dis[a[u]] = val + 1;
q.push({val + 1, a[u]});
vis[a[u]] = 1;
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i), a[i]--;
bfs();
for (int i = 0; i < n; i++) printf("%d ", dis[i]);
puts("");
return 0;
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
int mid(int i, int j) { return (i + j) >> 1; }
int left(int i) { return i << 1; }
int right(int i) { return (i << 1) + 1; }
int n;
int m;
char a[5000 + 1][5000 + 1];
int l[5000 + 1][5000 + 1];
int sor[5000 + 1][5000 + 1];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", a[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m;) {
if (a[i][j] == '0') {
l[i][j] = 0;
j++;
continue;
}
int s = j;
int v = 1;
j++;
for (; j < m; j++) {
if (a[i][j] == '0') break;
v++;
}
for (int k = s; k < j; k++) l[i][k] = v--;
}
}
memset(sor, 0, sizeof sor);
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (l[j][i] > 0) sor[i][l[j][i]]++;
}
}
int ans = 0;
for (int i = 0; i < m; i++) {
int h = 0;
for (int j = m; j > 0; j--) {
if (sor[i][j] > 0) {
h += sor[i][j];
ans = max(ans, h * j);
}
}
}
printf("%d", ans);
}
| 1,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
char a[100041];
int b[100041];
int c[100041];
string s;
int main() {
int n;
cin >> n;
int len;
for (long long i = 0; i < 100003; i++) a[i] = '?', c[i] = 1;
for (long long l = 0; l < n; l++) {
cin >> s;
len = s.size();
for (long long i = 0; i < s.size(); i++) {
if (s[i] == '?') {
continue;
}
if (c[i]) {
c[i] = 0;
a[i] = s[i];
} else {
if (a[i] != s[i]) b[i] = 1;
}
}
}
for (long long i = 0; i < len; i++) {
if (b[i])
cout << '?';
else if (c[i])
cout << 'x';
else
cout << a[i];
}
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, sum = 0, sum1 = 0, sum2 = 0, y;
cin >> x;
for (int i = 0; i < x; i++) {
cin >> y;
sum += y;
}
for (int i = 0; i < x - 1; i++) {
cin >> y;
sum1 += y;
}
for (int i = 0; i < x - 2; i++) {
cin >> y;
sum2 += y;
}
cout << sum - sum1 << endl;
cout << sum1 - sum2 << endl;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005, INF = 1000000000, mod = 1000000007;
const long long int LINF = 1000000000000000000ll;
const double eps = 1e-10;
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
int x[MX], y[MX], z[MX];
pair<int, int> e[MX * 2];
struct seg {
vector<int> d;
int sz, sz2;
seg() {}
seg(int mx) {
sz = 1;
while (sz < mx) sz <<= 1;
sz2 = sz << 1;
d.resize(sz2);
init(mx);
}
void init(int mx) {
sz = 1;
while (sz < mx) sz <<= 1;
sz2 = sz << 1;
fill(d.begin(), d.end(), 0);
}
void qu(int a, int b, int x, int i = 1, int l = 0, int r = INF) {
if (r == INF) r = sz;
if (a <= l && r <= b) {
d[i] += x;
return;
}
if (b <= l && r <= a) return;
int c = l + r >> 1, lc = i << 1, rc = lc + 1;
if (a < c) qu(a, b, x, lc, l, c);
if (c < b) qu(a, b, x, rc, c, r);
if (d[lc] > 0) {
d[i] += d[lc];
d[rc] -= d[lc];
d[lc] = 0;
}
if (d[rc] > 0) {
d[i] += d[rc];
d[lc] -= d[rc];
d[rc] = 0;
}
if (d[lc] < 0 && d[rc] < 0) {
int nxt = max(d[lc], d[rc]);
d[lc] -= nxt;
d[rc] -= nxt;
d[i] += nxt;
}
return;
}
int qw() {
int i = 1;
while (i < sz) {
i <<= 1;
if (d[i | 1] == 0) i |= 1;
}
return i - sz;
}
};
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d%d%d", &x[i], &y[i], &z[i]);
int ei = 0;
for (int i = 0; i < n; i++) {
e[ei++] = pair<int, int>(x[i], i);
e[ei++] = pair<int, int>(y[i], i + n);
}
sort(e, e + ei);
int ans = 0, ansi = 0;
seg t(3 * MX);
for (int i = 0; i < ei; i++) {
int ni = e[i].second % n, ne = e[i].second / n;
if (!ne) {
t.qu(y[ni], z[ni] + 1, 1);
if (ans < t.d[1]) {
ans = t.d[1];
ansi = i;
}
} else {
t.qu(y[ni], z[ni] + 1, -1);
}
}
printf("%d\n", ans);
t.init(3 * MX);
for (int i = 0; i < ansi + 1; i++) {
int ni = e[i].second % n, ne = e[i].second / n;
if (!ne) {
t.qu(y[ni], z[ni] + 1, 1);
} else {
t.qu(y[ni], z[ni] + 1, -1);
}
}
int ap = t.qw(), al = e[ansi].first, now = 0;
for (int i = 0; i < n; i++) {
if (x[i] <= al && y[i] >= al && z[i] >= ap && y[i] <= ap) {
now++;
printf("%d%c", i + 1, now == ans ? '\n' : ' ');
}
}
return 0;
}
| 2,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
vector<pair<pair<int, int>, int> > ans;
void flip(int first, int second, int z) {
a[first] ^= 1;
a[second] ^= 1;
a[z] ^= 1;
ans.push_back(pair<pair<int, int>, int>(pair<int, int>(first, second), z));
}
void calc1() {
puts("YES");
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf("%d %d %d\n", ans[i].first.first, ans[i].first.second,
ans[i].second);
exit(0);
}
void calc2() {
puts("NO");
exit(0);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = n; i >= 3; i--) {
if (!a[i]) continue;
if (i <= 8) {
flip(i - 2, i - 1, i);
continue;
}
if (a[i - 2]) {
if (a[i - 1])
flip(i - 2, i - 1, i);
else
flip(i - 4, i - 2, i);
continue;
}
if (!a[i - 1]) {
flip(i - 6, i - 3, i);
continue;
}
if (a[i - 3] && a[i - 4] && a[i - 5]) {
flip(i - 5, i - 3, i - 1);
flip(i - 8, i - 4, i);
continue;
}
if (i <= 12) {
flip(i - 2, i - 1, i);
continue;
}
int p = i - 6, q = i - 6;
for (int j = i - 5; j <= i - 3; j++) {
if (a[j]) {
p = j;
swap(p, q);
}
}
flip(2 * p - i, p, i);
flip(2 * q - (i - 1), q, i - 1);
}
if (a[1] == 0 && a[2] == 0) calc1();
if (n <= 6) calc2();
if (n == 7 && a[2]) calc2();
if (a[1]) {
flip(1, 4, 7);
flip(4, 5, 6);
flip(5, 6, 7);
}
if (a[2]) {
flip(2, 5, 8);
flip(5, 6, 7);
flip(6, 7, 8);
}
calc1();
return 0;
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-11;
const double pi = acos(-1.0);
double a, b, Maxa, Maxb;
struct Point {
double x, y;
Point() {}
Point(double _, double __) : x(_), y(__) {}
void read() { scanf("%lf%lf", &x, &y); }
} cinema, shop, house;
Point operator+(Point A, Point B) { return Point(A.x + B.x, A.y + B.y); }
Point operator-(Point A, Point B) { return Point(A.x - B.x, A.y - B.y); }
Point operator*(Point A, double b) { return Point(A.x * b, A.y * b); }
double sqr(double x) { return x * x; }
double dist(Point A, Point B) { return sqrt(sqr(A.x - B.x) + sqr(A.y - B.y)); }
double ang(Point A) { return atan2(A.y, A.x); }
bool Intersect(Point O1, double r1, Point O2, double r2, double &p1,
double &p2) {
double d = dist(O1, O2), t = r1 + r2 - d;
if (t < -eps) return 0;
if (fabs(t) < eps) return p1 = p2 = ang(O2 - O1), 1;
t = fabs(r1 - r2) - d;
if (t > eps)
if (r1 - r2 > eps)
return 0;
else
return p1 = -pi, p2 = pi, 1;
if (fabs(t) < eps)
if (r1 - r2 > eps)
return p1 = p2 = ang(O2 - O1), 1;
else
return p1 = -pi, p2 = pi, 1;
double da = fabs(acos((r1 * r1 + d * d - r2 * r2) / 2. / r1 / d));
return p1 = ang(O2 - O1) - da, p2 = ang(O2 - O1) + da, 1;
}
bool Judge(Point P, double x, Point A, double a, Point B, double b) {
double l1, r1, l2, r2;
if (!Intersect(P, x, A, a, l1, r1)) return 0;
if (!Intersect(P, x, B, b, l2, r2)) return 0;
if (l2 - r1 > eps || l1 - r2 > eps) return 0;
return 1;
}
int main() {
scanf("%lf%lf", &a, &b);
cinema.read(), house.read(), shop.read();
Maxa = a + dist(cinema, shop) + dist(shop, house);
Maxb = b + dist(cinema, house);
if (Maxb - dist(cinema, shop) - dist(shop, house) + 1e-3 > eps)
return printf("%.10lf\n", min(Maxa, Maxb)), 0;
double l = 0, r = min(Maxa - dist(shop, house), Maxb);
while (r - l > eps) {
double mid = (l + r) / 2., ra = Maxa - dist(shop, house) - mid,
rb = Maxb - mid;
if (Judge(cinema, mid, shop, ra, house, rb))
l = mid;
else if (Judge(shop, ra, cinema, mid, house, rb))
l = mid;
else if (Judge(house, rb, cinema, mid, shop, ra))
l = mid;
else
r = mid;
}
printf("%.10lf\n", l);
}
| 2,600 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline T gcd(T a, T b) {
return __gcd(a, b);
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
long long modpow(long long a, long long n, long long temp) {
long long res = 1, y = a;
while (n > 0) {
if (n & 1) res = (res * y) % temp;
y = (y * y) % temp;
n /= 2;
}
return res % temp;
}
long long ison(long long mask, long long pos) { return (mask & (1 << pos)); }
long long cbit(long long n) {
long long k = 0;
while (n) n &= (n - 1), k++;
return k;
}
long long nbit(long long n) {
long long k = 0;
while (n) n /= 2, k++;
return k;
}
long long mod = 1e9 + 7;
int sgn(long long x) { return x < 0 ? -1 : !!x; }
const double eps = 1e-7;
const double pi = acos(-1.0);
inline void inc(long long &x, long long y) {
x += y;
if (x >= mod) x -= mod;
}
inline void dec(long long &x, long long y) {
x -= y;
if (x < 0) x += mod;
}
inline void chmax(long long &x, long long y) {
if (y > x) x = y;
}
inline void mulm(long long &x, long long y) {
x *= y;
if (x >= mod) x -= mod;
}
long long xo(long long i) {
if ((i & 3) == 0) return i;
if ((i & 3) == 1) return 1;
if ((i & 3) == 2) return i + 1;
return 0;
}
long long a[100005];
map<long long, long long> help;
int main() {
long long ans = 0, i, j, k, l, m, n;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = n; i >= 1; i--) {
long long x = cbit(a[i]);
ans += help[x];
help[x]++;
}
cout << ans;
}
| 1,400 | CPP |
def main():
class interval:
def __init__(self, a, b):
self.a = a
self.b = b
def travel(self, i2):
(a, b) = (self.a, self.b)
(c, d) = (i2.a, i2.b)
return (c < a and a < d) or (c < b and b < d)
def __str__(self):
return "({} {})".format(self.a, self.b)
from collections import defaultdict
adj = defaultdict(set)
vis = set()
def dfs(i, goal):
nonlocal vis
if i in vis:
return False
if i == goal:
return True
vis.add(i)
for j in intervals:
if i.a == j.a and i.b == j.b:
continue
if not i.travel(j):
continue
if j in vis:
continue
if j == goal:
return True
if dfs(j, goal):
return True
return False
intervals = []
n = int(input())
for i in range(n):
(x, a, b) = map(int, input().split(' '))
if x == 1:
intervals.append(interval(a, b))
else:
f = False
vis = set()
if dfs(intervals[a - 1], intervals[b - 1]):
print("YES")
else:
print("NO")
main()
| 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vc<vc<T>>;
template <class T>
void mkuni(vector<T> &v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
long long rand_int(long long l, long long r) {
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<long long>(l, r)(gen);
}
template <class T>
void print(T x, int suc = 1) {
cout << x;
if (suc == 1)
cout << '\n';
else
cout << ' ';
}
template <class T>
void print(const vector<T> &v, int suc = 1) {
for (int i = 0; i < v.size(); i++)
print(v[i], i == (int)(v.size()) - 1 ? suc : 2);
}
const int INF = 0x3f3f3f;
const long long inf = 1e18;
const int maxn = 2e5 + 7;
const int mod = 1e9 + 7;
int a[maxn];
int n, k;
int t;
int nxt[maxn][26];
int sum[maxn];
int c[maxn];
int N;
long long K, L[2000], R[2000], A[2000];
long long dp[2001];
void chmax(long long &a, long long b) {
if (a < b) a = b;
}
void chmin(long long &a, long long b) {
if (a > b) a = b;
}
int main() {
long long t, r, used, remain, d;
cin >> N >> K;
for (int i = 0; i < N; ++i) {
cin >> L[i] >> R[i] >> A[i];
}
for (int i = 1; i <= N; ++i) dp[i] = inf;
for (int i = 0; i < N; ++i) {
t = 0;
r = K;
used = 0;
remain = 0;
for (int j = i; j < N; ++j) {
chmax(t, L[j]);
remain += A[j];
d = min(remain, r);
remain -= d;
r -= d;
used += d;
d = (remain + K - 1) / K;
t += d;
r += d * K;
d = min(remain, r);
remain -= d;
r -= d;
used += d;
if (t > R[j]) break;
if (j == N - 1 && t <= R[j]) chmin(dp[j + 1], dp[i] + used);
if (j != N - 1 && t + 1 <= L[j + 1]) chmin(dp[j + 1], dp[i] + used + r);
}
}
print(((dp[N] == inf) ? -1 : dp[N]));
return 0;
}
| 2,600 | CPP |
#Python Template
from sys import stdin, stdout
from math import ceil
def ds(n):
total = 0
for i in str(n):
total += int(i)
return total
def main():
t = int(stdin.readline())
for _ in range(t):
n, s = [int(i) for i in stdin.readline().split()]
for i in range(0, 25):
exp = 10**i
#Finding the next power
pot = 0
if n%exp == 0:
pot = n
else:
pot = n - n%exp
pot += exp
#print(pot, n)
diff = pot-n
if ds(pot) > s:
continue
stdout.write("{}\n".format(diff))
break
main() | 1,500 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[200002], b[200002], c[200002];
void solve() {
int n, m;
string s;
m = 1;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
cin >> s;
for (int i = 1; i <= n; i++) b[a[i]] = i;
for (int i = 1; i <= n; i++) {
if (s[b[i] - 1] == '0') {
c[m] = b[i];
m++;
}
}
cerr << m << endl;
for (int i = 1; i <= n; i++) {
if (s[b[i] - 1] == '1') {
c[m] = b[i];
m++;
}
}
cerr << m << endl;
for (int i = 1; i <= n; i++) {
a[c[i]] = i;
}
for (int i = 1; i <= n; i++) {
cout << a[i];
cout << " ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tc;
cin >> tc;
while (tc--) {
solve();
}
}
| 1,000 | CPP |
t = int(input())
while(t):
n = int(input())
a = list(map(int,input().strip().split()))
b = list(map(int,input().strip().split()))
if n == 1:
print(0)
else:
min_a = min(a)
min_b = min(b)
diff_a = []
diff_b = []
for i in a:
diff_a.append(i-min_a)
for i in b:
diff_b.append(i-min_b)
ans = 0
# print(diff_a,diff_b)
for i in range(len(a)):
ans += max(diff_a[i],diff_b[i])
print(ans)
t-=1 | 800 | PYTHON3 |
import sys
s=sys.stdin.read()
s=s.split("\n")
s[0]=s[0].lower()
s[1]=s[1].lower()
if s[0]==s[1]:
print(0)
else:
for a,b in zip(s[0],s[1]):
if a<b:
print(-1)
break
elif a>b:
print(1)
break
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<string> grid;
int used[50][50];
int tot = 0;
class Solution {
public:
int n, m;
void dfs(int x, int y) {
used[x][y] = 1;
tot++;
for (int dx = -1; dx <= 1; dx++) {
for (int dy = -1; dy <= 1; dy++) {
if (dx * dy == 0 && dx + dy != 0) {
int xx = x + dx;
int yy = y + dy;
if (xx >= 0 && xx < n && yy >= 0 && yy < m) {
if (!used[xx][yy] && grid[xx][yy] == '#') {
dfs(xx, yy);
}
}
}
}
}
}
void solve(std::istream& in, std::ostream& out) {
in >> n >> m;
string s;
int cnt = 0;
for (int i = 1; i <= n; i++) {
in >> s;
grid.push_back(s);
for (int i = 0; i <= (int)s.size() - 1; i++)
if (s[i] == '#') cnt++;
}
if (cnt <= 2) {
out << -1 << '\n';
} else {
for (int i = 0; i <= n - 1; i++) {
for (int j = 0; j <= m - 1; j++) {
if (grid[i][j] == '#') {
bool flag = true;
for (int dx = -1; dx <= 1; dx++) {
for (int dy = -1; dy <= 1; dy++) {
if (dx * dy == 0 && dx + dy != 0) {
int x = i + dx;
int y = j + dy;
if (x >= 0 && x < n && y >= 0 && y < m) {
if (grid[x][y] == '#') {
tot = 0;
grid[i][j] = '.';
memset(used, 0, sizeof(used));
dfs(x, y);
grid[i][j] = '#';
if (tot <= cnt - 2) {
out << 1 << '\n';
return;
} else
flag = false;
break;
}
}
}
}
if (!flag) break;
}
}
}
}
out << 2 << '\n';
}
return;
}
};
void solve(std::istream& in, std::ostream& out) {
out << std::setprecision(12);
Solution solution;
solution.solve(in, out);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
istream& in = cin;
ostream& out = cout;
solve(in, out);
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int long long a1[4], c1 = 0, a, b, c;
for (int i = 0; i < 4; i++) {
cin >> a1[i];
}
sort(a1, a1 + 4);
for (int i = 0; i < 4 - 2; i++) {
if (a1[i] + a1[i + 1] > a1[i + 2] && a1[i + 1] + a1[i + 2] > a1[i] &&
a1[i] + a1[i + 2] > a1[i + 1]) {
cout << "TRIANGLE" << endl;
c1 = 1;
break;
}
}
if (c1 == 0) {
for (int i = 0; i < 4 - 2; i++) {
a = a1[i];
b = a1[i + 1];
c = a1[i + 2];
if (a + b == c || b + c == a || a + c <= b) {
c1 = 2;
cout << "SEGMENT" << endl;
break;
}
}
}
if (c1 == 0) {
cout << "IMPOSSIBLE" << endl;
}
return 0;
}
| 900 | CPP |
# map(int, input().split())
# list(map(int, input().split()))
for _ in range(int(input())):
n = int(input())
a = list(map(str, input().split()))
if n == 3:
if "b" not in a[0]:
print(a[0] + "b")
elif "a" not in a[0]:
print(a[0] + "a")
else:
print(a[0] + "b")
else:
ans = a[0]
k = 0
for i in range(1,n-2):
if k < (n - 4):
if a[i][0] == a[i-1][1]:
ans += a[i][1]
k += 1
else:
ans += a[i]
else:
ans += a[i]
print(ans) | 800 | PYTHON3 |
__author__ = 'NIORLYS'
[w1, h1, w2, h2] = list(map(int, input().split()))
if w1 == w2:
print(2 * (h1 + h2 + 2) + 2 * w1)
else:
print(2 * (h1 + h2 + 2) + 2 * w1 )
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200500;
const int M = 1148576;
const int inf = 1e9;
struct edge {
int obj, pre;
} e[maxn * 2];
int head[maxn], vis[maxn], a[maxn], sz[maxn], flag[M], cnt[M];
long long sum[maxn], ans[maxn];
char ch[maxn];
int n, szn, rt, mn, tot, idx;
void insert(int x, int y) {
e[++tot].obj = y;
e[tot].pre = head[x];
head[x] = tot;
}
void getsz(int u, int fa) {
sz[u] = 1;
sum[u] = 0;
for (int j = head[u]; j; j = e[j].pre) {
int v = e[j].obj;
if (vis[v] || v == fa) continue;
getsz(v, u);
sz[u] += sz[v];
}
}
void getrt(int u, int fa) {
int mx = szn - sz[u];
for (int j = head[u]; j; j = e[j].pre) {
int v = e[j].obj;
if (v == fa || vis[v]) continue;
mx = max(mx, sz[v]);
getrt(v, u);
}
if (mx < mn) mn = mx, rt = u;
}
void add(int x, int y) {
if (flag[x] != idx) cnt[x] = 0, flag[x] = idx;
cnt[x] += y;
}
int find(int x) {
if (flag[x] != idx) cnt[x] = 0, flag[x] = idx;
return cnt[x];
}
int query(int x) {
int ans = find(x);
for (int i = 0; i <= 19; i++) ans += find(x ^ (1 << i));
return ans;
}
void getval(int u, int fa, int x) {
add(x, 1);
for (int j = head[u]; j; j = e[j].pre) {
int v = e[j].obj;
if (vis[v] || v == fa) continue;
getval(v, u, x ^ a[v]);
}
}
void getans(int u, int fa, int x, int op) {
sum[u] += query(x) * op;
for (int j = head[u]; j; j = e[j].pre) {
int v = e[j].obj;
if (v == fa || vis[v]) continue;
getans(v, u, x ^ a[v], op);
}
}
void getpre(int u, int fa) {
for (int j = head[u]; j; j = e[j].pre) {
int v = e[j].obj;
if (vis[v] || v == fa) continue;
getpre(v, u);
sum[u] += sum[v];
}
if (!fa) sum[u] = (sum[u] + 1) / 2;
ans[u] += sum[u];
}
void solve(int u) {
getsz(u, 0);
szn = sz[u];
mn = inf;
rt = 0;
getrt(u, 0);
int k = rt;
vis[k] = 1;
idx++;
add(0, 1);
for (int j = head[k]; j; j = e[j].pre) {
int v = e[j].obj;
if (vis[v]) continue;
getval(v, k, a[v]);
}
sum[k] += query(a[k]);
for (int j = head[k]; j; j = e[j].pre) {
int v = e[j].obj;
if (vis[v]) continue;
getans(v, k, a[v] ^ a[k], 1);
}
for (int j = head[k]; j; j = e[j].pre) {
int v = e[j].obj;
if (vis[v]) continue;
++idx;
getval(v, k, a[v]);
getans(v, k, a[v] ^ a[k], -1);
}
getpre(k, 0);
for (int j = head[k]; j; j = e[j].pre) {
int v = e[j].obj;
if (!vis[v]) solve(v);
}
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int x, y;
scanf("%d%d", &x, &y);
insert(x, y);
insert(y, x);
}
scanf("%s", ch + 1);
for (int i = 1; i <= n; i++) a[i] = 1 << (ch[i] - 'a');
szn = n;
solve(1);
for (int i = 1; i <= n; i++) printf("%lld ", ans[i]);
return 0;
}
| 2,400 | CPP |
t=int(input())
while t:
ans=0
a,b=map(int,input().split())
if(a>=b):
if((a-b)%2==0 and a!=b):
ans=1
elif(a==b):
ans=0
else:
ans=2
else:
if(b-a)%2:
ans=1
else:
ans=2
print(ans)
t-=1
| 800 | PYTHON3 |
t = int(input())
output = []
for _ in range(t):
l = list(map(int,input().split()))
a = list(map(int,input().split()))
p = list(map(int,input().split()))
while True:
swapped = False
for pos in p:
if a[pos-1] > a[pos]:
tmp = a[pos-1]
a[pos-1] = a[pos]
a[pos] = tmp
swapped = True
if swapped == False:
break
sort = True
for i in range(len(a)-1):
if a[i] > a[i+1]:
sort = False
output.append("NO")
break
if sort == True:
output.append("YES")
for o in output:
print(o) | 1,200 | PYTHON3 |
n = int(input())
for i in range(n):
s = input()
if len(s) > 10:
num = len(s) - 2
s = s[0] + str(num) + s[-1]
print(s)
| 800 | PYTHON3 |
t = int(input())
for _ in range(t):
n = int(input())
# p = ((n // 2) * (n // 2 - 1)) // 2
# print((n // 2) * (n // 2 + 1) * 2 * n - 4 * p * (p + 1) - 2 * (n // 2))
b = n // 2
ans = b * (4 * n - 4)
d = -12
b -= 1
for i in range(1, n // 2):
ans += b * (4 * n + d)
d -= 8
b -= 1
print(ans)
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, q;
cin >> n >> m;
string a[n];
string b[m];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
cin >> q;
while (q > 0) {
int y;
cin >> y;
cout << a[(y - 1) % n] << b[(y - 1) % m] << endl;
q--;
}
}
| 800 | CPP |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
using db = double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<double, double>;
using vi = vector<int>;
using vb = vector<bool>;
using vl = vector<ll>;
using vd = vector<double>;
using vs = vector<string>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vpd = vector<pd>;
using F1 = function<void(int)>;
using F2 = function<void(int, int)>;
const int di[4] = {-1, 0, 1, 0}, dj[4] = {0, 1, 0, -1};
const int di8[8] = {-1, -1, 0, 1, 1, 1, 0, -1},
dj8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const ld PI = acos((ld)-1);
const ll INF = 1e18;
const double eps = 1e-11;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll randint(ll a, ll b) { return uniform_int_distribution<ll>(a, b)(rng); }
using ul = unsigned long long;
ul modMul(ul a, ul b, const ul mod) {
ll ret = a * b - mod * (ul)((ld)a * b / mod);
return ret + ((ret < 0) - (ret >= (ll)mod)) * mod;
}
ul modPow(ul a, ul b, const ul mod) {
if (b == 0) return 1;
ul res = modPow(a, b / 2, mod);
res = modMul(res, res, mod);
return b & 1 ? modMul(res, a, mod) : res;
}
bool prime(ul n) {
if (n < 2 || n % 6 % 4 != 1) return n - 2 < 2;
ul A[] = {2, 325, 9375, 28178, 450775, 9780504, 1795265022},
s = __builtin_ctzll(n - 1), d = n >> s;
for (auto& a : A) {
ul p = modPow(a, d, n), i = s;
while (p != 1 && p != n - 1 && a % n && i--) p = modMul(p, p, n);
if (p != n - 1 && i != s) return 0;
}
return 1;
}
template <typename A, typename B>
pair<A, B> operator+(const pair<A, B>& a, const pair<A, B>& b) {
return make_pair(a.first + b.first, a.second + b.second);
}
template <typename A, typename B>
pair<A, B> operator+=(pair<A, B>& a, const pair<A, B>& b) {
a.first += b.first;
a.second += b.second;
return a;
}
template <typename A, typename B>
pair<A, B> operator-(const pair<A, B>& a, const pair<A, B>& b) {
return make_pair(a.first - b.first, a.second - b.second);
}
template <typename A, typename B>
pair<A, B> operator-(const pair<A, B>& a) {
return make_pair(-a.first, -a.second);
}
template <typename A, typename B>
pair<A, B>& operator++(pair<A, B>& a) {
++a.first;
++a.second;
return a;
}
template <typename A, typename B>
pair<A, B>& operator--(pair<A, B>& a) {
--a.first;
--a.second;
return a;
}
template <typename A>
vector<A>& operator++(vector<A>& a) {
for (auto it = a.begin(); it != a.end(); ++it) ++*it;
return a;
}
template <typename A>
vector<A>& operator--(vector<A>& a) {
for (auto it = a.begin(); it != a.end(); ++it) --*it;
return a;
}
template <typename A, typename B>
pair<A, B> operator++(pair<A, B>& a, int) {
pair<A, B> b = a;
++a;
return b;
}
template <typename A, typename B>
pair<A, B> operator--(pair<A, B>& a, int) {
pair<A, B> b = a;
--a;
return b;
}
template <typename A>
vector<A>& operator++(vector<A>& a, int) {
vector<A> b = a;
++a;
return b;
}
template <typename A>
vector<A>& operator--(vector<A>& a, int) {
vector<A> b = a;
--a;
return b;
}
template <typename A, typename B>
pair<A, B> operator-=(pair<A, B>& a, const pair<A, B>& b) {
a.first -= b.first;
a.second -= b.second;
return a;
}
bool pow2(int i) { return i && (i & -i) == i; }
constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bits(int x) { return 31 - __builtin_clz(x); }
ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }
ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }
ll half(ll x) { return fdiv(x, 2); }
bool inc(ll a, ll b, ll c) { return a <= b && b <= c; }
template <class t>
int lwb(const vector<t>& v, const t& a) {
return lower_bound((v).begin(), (v).end(), a) - v.begin();
}
template <class T>
inline T lowbit(T n) {
return (n ^ (n - 1)) & n;
}
template <typename I>
struct _reversed_struct {
I& v_;
explicit _reversed_struct(I& v) : v_{v} {}
typename I::reverse_iterator begin() const { return v_.rbegin(); }
typename I::reverse_iterator end() const { return v_.rend(); }
};
template <typename I>
_reversed_struct<I> reversed(I& v) {
return _reversed_struct<I>(v);
}
template <typename T1, typename T2>
typename vector<pair<T1, T2>>::iterator lower_bound(
const vector<pair<T1, T2>>& v, const T1& x) {
return lower_bound(
(v).begin(), (v).end(), x,
[](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; });
}
template <typename T1, typename T2>
typename vector<pair<T1, T2>>::iterator upper_bound(
const vector<pair<T1, T2>>& v, const T1& x) {
return upper_bound(
(v).begin(), (v).end(), x,
[](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; });
}
bool isUpperCase(char c) { return c >= 'A' && c <= 'Z'; }
bool isLowerCase(char c) { return c >= 'a' && c <= 'z'; }
bool isLetter(char c) { return c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z'; }
bool isDigit(char c) { return c >= '0' && c <= '9'; }
char toLowerCase(char c) { return (isUpperCase(c)) ? (c + 32) : c; }
char toUpperCase(char c) { return (isLowerCase(c)) ? (c - 32) : c; }
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
ll toInt64(string s) {
ll r = 0;
istringstream sin(s);
sin >> r;
return r;
}
double toDouble(string s) {
double r = 0;
istringstream sin(s);
sin >> r;
return r;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
double dist(double x1, double y1, double x2, double y2) {
return sqrt(sqr(x1 - x2) + sqr(y1 - y2));
}
double distR(double x1, double y1, double x2, double y2) {
return sqr(x1 - x2) + sqr(y1 - y2);
}
template <class T>
T cross(T x0, T y0, T x1, T y1, T x2, T y2) {
return (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0);
}
int crossOper(double x0, double y0, double x1, double y1, double x2,
double y2) {
double t = (x1 - x0) * (y2 - y0) - (x2 - x0) * (y1 - y0);
if (fabs(t) <= eps) return 0;
return (t < 0) ? -1 : 1;
}
bool isIntersect(double x1, double y1, double x2, double y2, double x3,
double y3, double x4, double y4) {
return crossOper(x1, y1, x2, y2, x3, y3) * crossOper(x1, y1, x2, y2, x4, y4) <
0 &&
crossOper(x3, y3, x4, y4, x1, y1) * crossOper(x3, y3, x4, y4, x2, y2) <
0;
}
bool isMiddle(double s, double m, double t) {
return fabs(s - m) <= eps || fabs(t - m) <= eps || (s < m) != (t < m);
}
constexpr ll power(ll x, int p) { return p == 0 ? 1 : (x * power(x, p - 1)); }
bool isPower(ll x, ll y) {
ll res1 = log(y) / log(x);
double res2 = log(y) / log(x);
return (res1 == res2);
}
template <class T>
bool chmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool chmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
void TIME() {}
template <class T>
void remDup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), end(v));
}
template <class T, class U>
void remAll(vector<T>& v, U a) {
v.erase(remove((v).begin(), (v).end(), a), v.end());
}
template <class T, class U>
T fstTrue(T lo, T hi, U f) {
while (lo < hi) {
T mid = half(lo + hi);
f(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
template <class T, class U>
T lstTrue(T lo, T hi, U f) {
while (lo < hi) {
T mid = half(lo + hi + 1);
f(mid) ? lo = mid : hi = mid - 1;
}
return lo;
}
template <class T, class U, class C>
string to_string(tuple<T, U, C> p);
template <class T, class U, class C, class D>
string to_string(tuple<T, U, C, D> p);
string to_string(char c) { return string(1, c); }
string to_string(bool b) { return to_string((int)b); }
string to_string(const char* s) { return (string)s; }
string to_string(string s) { return s; }
template <class T>
string to_string(complex<T> c) {
stringstream ss;
ss << c;
return ss.str();
}
string to_string(vb v) {
string res = "{";
for (int i = (0); i < (((int)(v).size())); ++i) res += char('0' + v[i]);
res += "}";
return res;
}
template <size_t SZ>
string to_string(bitset<SZ> b) {
string res = "";
for (int i = (0); i < (((int)(b).size())); ++i) res += char('0' + b[i]);
return res;
}
template <class T, class U>
string to_string(pair<T, U> p);
template <class T>
string to_string(T v) {
bool fst = 1;
string res = "";
for (const auto& x : v) {
if (!fst) res += " ";
fst = 0;
res += to_string(x);
}
return res;
}
template <class T, class U>
string to_string(pair<T, U> p) {
return to_string(p.first) + " " + to_string(p.second);
}
template <class T, class U, class C>
string to_string(tuple<T, U, C> p) {
return to_string(get<0>(p)) + " " + to_string(get<1>(p)) + " " +
to_string(get<2>(p));
}
template <class T, class U, class C, class D>
string to_string(tuple<T, U, C, D> p) {
return to_string(get<0>(p)) + " " + to_string(get<1>(p)) + " " +
to_string(get<2>(p)) + " " + to_string(get<3>(p));
}
template <class T, class U, class C>
void re(tuple<T, U, C>& p);
template <class T, class U, class C, class D>
void re(tuple<T, U, C, D>& p);
template <class T>
void re(complex<T>& c);
template <class T, class U>
void re(pair<T, U>& p);
template <class T>
void re(vector<T>& v);
template <class T>
void rv(int n, vector<T>& x) {
x.resize(n);
re(x);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& d) {
string t;
re(t);
d = stod(t);
}
void re(ld& d) {
string t;
re(t);
d = stold(t);
}
template <class T, class... U>
void re(T& t, U&... u) {
re(t);
re(u...);
}
template <class T>
void re(complex<T>& c) {
T a, b;
re(a, b);
c = {a, b};
}
template <class T, class U>
void re(pair<T, U>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& x) {
for (auto& a : x) re(a);
}
template <class T, size_t SZ>
void re(array<T, SZ>& x) {
for (auto& a : x) re(a);
}
template <class T, class U, class C>
void re(tuple<T, U, C>& p) {
re(get<0>(p), get<1>(p), get<2>(p));
}
template <class T, class U, class C, class D>
void re(tuple<T, U, C, D>& p) {
re(get<0>(p), get<1>(p), get<2>(p), get<3>(p));
}
template <class T>
void pr(T x) {
cout << to_string(x);
}
template <class T, class... U>
void pr(const T& t, const U&... u) {
pr(t);
pr(u...);
}
void ps() { pr("\n"); }
template <class T, class... U>
void ps(const T& t, const U&... u) {
pr(t);
if (sizeof...(u)) pr(" ");
ps(u...);
}
struct chash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
template <typename L, typename R>
size_t operator()(pair<L, R> const& second) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(second.first * 31 + second.second + FIXED_RANDOM);
}
};
template <class T>
using V = vector<T>;
template <class T, size_t SZ>
using AR = array<T, SZ>;
template <class T>
using mpq = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using pq = priority_queue<T>;
template <class T, class U>
using um = unordered_map<T, U, chash>;
template <class T>
using us = unordered_set<T, chash>;
template <class T>
using PR = pair<T, T>;
const int MOD = 1e9 + 7;
template <int MOD, int RT>
struct mint {
static const int mod = MOD;
static constexpr mint rt() { return RT; }
int v;
explicit operator int() const { return v; }
mint() { v = 0; }
mint(ll _v) {
v = (-MOD < _v && _v < MOD) ? _v : _v % MOD;
if (v < 0) v += MOD;
}
friend bool operator==(const mint& a, const mint& b) { return a.v == b.v; }
friend bool operator!=(const mint& a, const mint& b) { return !(a == b); }
friend bool operator<(const mint& a, const mint& b) { return a.v < b.v; }
friend void re(mint& a) {
ll x;
re(x);
a = mint(x);
}
friend string to_string(mint a) { return to_string(a.v); }
mint& operator+=(const mint& m) {
if ((v += m.v) >= MOD) v -= MOD;
return *this;
}
mint& operator-=(const mint& m) {
if ((v -= m.v) < 0) v += MOD;
return *this;
}
mint& operator*=(const mint& m) {
v = (ll)v * m.v % MOD;
return *this;
}
mint& operator/=(const mint& m) { return (*this) *= inv(m); }
friend mint pow(mint a, ll p) {
mint ans = 1;
assert(p >= 0);
for (; p; p /= 2, a *= a)
if (p & 1) ans *= a;
return ans;
}
friend mint inv(const mint& a) {
assert(a.v != 0);
return pow(a, MOD - 2);
}
mint operator-() const { return mint(-v); }
mint& operator++() { return *this += 1; }
mint& operator--() { return *this -= 1; }
friend mint operator+(mint a, const mint& b) { return a += b; }
friend mint operator-(mint a, const mint& b) { return a -= b; }
friend mint operator*(mint a, const mint& b) { return a *= b; }
friend mint operator/(mint a, const mint& b) { return a /= b; }
};
typedef mint<MOD, 5> mi;
vector<vector<mi>> scmb;
void genComb(int SZ) {
scmb.assign(SZ, vector<mi>(SZ));
scmb[0][0] = 1;
for (int i = (1); i < (SZ); ++i)
for (int j = (0); j < (i + 1); ++j)
scmb[i][j] = scmb[i - 1][j] + (j ? scmb[i - 1][j - 1] : 0);
}
vi invs, fac, ifac;
void genFac(int SZ) {
invs.resize(SZ), fac.resize(SZ), ifac.resize(SZ);
invs[1] = fac[0] = ifac[0] = 1;
for (int i = (2); i < (SZ); ++i)
invs[i] = MOD - (ll)MOD / i * invs[MOD % i] % MOD;
for (int i = (1); i < (SZ); ++i) {
fac[i] = (ll)fac[i - 1] * i % MOD;
ifac[i] = (ll)ifac[i - 1] * invs[i] % MOD;
}
}
mi comb(int a, int b) {
if (a < b || b < 0) return 0;
return (ll)fac[a] * ifac[b] % MOD * ifac[a - b] % MOD;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
ll ncr(ll n, ll r) {
ll p = 1, k = 1;
if (n - r < r) r = n - r;
if (r != 0) {
while (r) {
p *= n;
k *= r;
ll m = gcd(p, k);
p /= m;
k /= m;
n--;
r--;
}
} else
p = 1;
return p;
}
void DBG() { cerr << "]" << endl; }
template <class T, class... U>
void DBG(const T& t, const U&... u) {
cerr << to_string(t);
if (sizeof...(u)) cerr << ", ";
DBG(u...);
}
V<vi> readGraph(int n, int m) {
V<vi> g(n);
for (int i = (0); i < (m); ++i) {
int a, b;
re(a, b);
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
return g;
}
V<vpi> readwGraph(int n, int m) {
V<vpi> g(n);
for (int i = (0); i < (m); ++i) {
int a, b, w;
re(a, b, w);
a--;
b--;
g[a].emplace_back(b, w);
g[b].emplace_back(a, w);
}
return g;
}
V<vi> readTree(int n) { return readGraph(n, n - 1); }
V<vpi> readwTree(int n) { return readwGraph(n, n - 1); }
void setPrec() { cout << fixed << setprecision(15); }
void setIn(str s) { freopen(s.c_str(), "r", stdin); }
void setOut(str s) { freopen(s.c_str(), "w", stdout); }
void unsyncIO() { cin.tie(0)->sync_with_stdio(0); }
void setIO(str s = "") {
unsyncIO();
setPrec();
if (((int)(s).size())) {
setIn(s + ".in");
setOut(s + ".out");
}
}
const int mxN = 2e5 + 5;
ll n, l, r;
mi dp[mxN][3];
void solve() {
re(n, l, r);
ll st = 0, st1 = 0, st2 = 0;
for (int i = (l); i < (r + 1); ++i) {
if (st && st1 && st2) break;
if (i % 3 == 0) st2 = i;
if (i % 3 == 1) st = i;
if (i % 3 == 2) st1 = i;
}
dp[0][0] = (r - (!st2 ? r : st2)) / 3 + min(st2, 1ll);
dp[0][1] = (r - (!st ? r : st)) / 3 + min(st, 1ll);
dp[0][2] = (r - (!st1 ? r : st1)) / 3 + min(st1, 1ll);
0;
for (int i = (1); i < (n); ++i) {
dp[i][0] = dp[i - 1][0] * dp[0][0] + dp[i - 1][2] * dp[0][1] +
dp[i - 1][1] * dp[0][2];
dp[i][1] = dp[i - 1][0] * dp[0][1] + dp[i - 1][1] * dp[0][0] +
dp[i - 1][2] * dp[0][2];
dp[i][2] = dp[i - 1][2] * dp[0][0] + dp[i - 1][1] * dp[0][1] +
dp[i - 1][0] * dp[0][2];
}
ps(dp[n - 1][0]);
}
int main() {
setIO();
int T = 1;
for (int _ = (1); _ < (T + 1); ++_) {
solve();
}
}
| 1,500 | CPP |
def read_input():
input_str = str(input())
return map(int, input_str.split(' '))
def fount_false_prime_int(n: int, k: int) -> int:
even_count = (n + 1) // 2
if k <= even_count:
return k * 2 - 1
else:
new_k = k - even_count
return new_k * 2
if __name__ == '__main__':
n, k = read_input()
false_prime_int = fount_false_prime_int(n, k)
print(false_prime_int)
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
constexpr int INF = 1000000000;
typedef long long ll;
void print(const char* msg, ...);
inline unsigned long long exp10(int e) {
if (e == 0) return 1;
return (e == 1) ? 10 : 10 * exp10(e - 1);
}
int main() {
int N;
unsigned long long n;
char command;
map<unsigned long long, int> m;
unsigned long long pot[18];
for (int i = 0; i < 18; i++) pot[i] = exp10(i);
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("\n%c %llu", &command, &n);
if (command == '+') {
unsigned long long ind = 0;
for (int i = 0; i < 18; i++) ind += ((n / pot[i]) % 2) * pot[i];
m[ind] += 1;
} else if (command == '-') {
unsigned long long ind = 0;
for (int i = 0; i < 18; i++) ind += ((n / pot[i]) % 2) * pot[i];
m[ind] -= 1;
} else
printf("%d\n", m[n]);
}
return EXIT_SUCCESS;
}
void print(const char* msg, ...) {}
| 1,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const double eps = 1e-9;
int getint() {
char ch;
while (!isdigit(ch = getchar()))
;
int x = ch - '0';
while (isdigit(ch = getchar())) x = x * 10 + ch - '0';
return x;
}
int ansn, ans[N], h[N], res1[N], res2[N], len[N], tot, n, len1, len2, pre[N],
f[N];
int vis[N], vis_clock, k[N];
set<int> tail;
void Calc(int *h, int n, int *res, int &len) {
len = 1;
f[0] = h[0];
for (int i = 1, j; i < n; ++i) {
j = upper_bound(f, f + len, h[i]) - f;
if (j == len) ++len;
pre[h[i]] = f[j - 1];
f[j] = h[i];
}
for (int i = len - 1, v = f[len - 1]; ~i; --i, v = pre[v]) res[i] = v;
}
void Shrink(int *h, int &n, int *res, int len) {
int nn = 0;
++vis_clock;
for (int i = 0; i < len; ++i) vis[res[i]] = vis_clock;
for (int i = 0; i < n; ++i)
if (vis[h[i]] != vis_clock) h[nn++] = h[i];
n = nn;
}
int main() {
int Tes;
scanf("%d", &Tes);
for (int i = 1; i * (i - 1) / 2 <= 100000; ++i)
for (int j = i * (i + 1) / 2; j < (i + 1) * (i + 2) / 2 && j <= 100000; ++j)
k[j] = i;
while (Tes--) {
n = getint();
tot = ansn = 0;
for (int i = 0; i < n; ++i) h[i] = getint();
bool tag = false;
int nn = n;
while (n) {
Calc(h, n, res1, len1);
if (len1 > k[n]) {
len[ansn++] = len1;
for (int i = 0; i < len1; ++i) ans[tot++] = res1[i];
Shrink(h, n, res1, len1);
} else {
for (int i = 0; i <= nn; ++i) pre[i] = 0;
tail.clear();
for (int i = 0; i < n; ++i) {
set<int>::iterator it = tail.upper_bound(h[i]);
if (it == tail.end())
tail.insert(h[i]);
else {
pre[*it] = h[i];
tail.erase(it);
tail.insert(h[i]);
}
}
++vis_clock;
for (int i = 0; i < n; ++i)
if (vis[h[i]] != vis_clock) {
len[ansn] = 0;
for (int v = h[i]; v; v = pre[v], len[ansn]++)
ans[tot++] = v, vis[v] = vis_clock;
++ansn;
}
n = 0;
break;
}
}
printf("%d\n", ansn);
for (int i = 0, ii = 0; i < ansn; ++i) {
printf("%d ", len[i]);
for (int j = 0; j < len[i]; ++j) printf("%d ", ans[ii++]);
puts("");
}
}
return 0;
}
| 3,400 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 66;
int power[MAX + 10];
int between[MAX + 10];
int extra[MAX + 10];
int ende[MAX + 10];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
long long foo;
cin >> foo;
int cc = 0;
bool good = true;
while (foo > 1) {
if (foo & 1) {
good = false;
}
cc++;
foo >>= 1;
}
if (good) {
power[cc]++;
} else {
between[cc]++;
}
}
int low = 1, high = power[0] + 1;
while (low < high) {
int mid = (low + high) >> 1;
int cur = mid;
for (int i = 0; i < MAX; i++) {
extra[i] = power[i] - cur;
int new_cur = min(cur, power[i + 1]);
ende[i] = cur - new_cur;
cur = new_cur;
}
bool fail = false;
int open = 0;
for (int i = MAX - 1; i >= 0; i--) {
open += ende[i];
open -= between[i];
open -= extra[i + 1];
if (open < 0) {
fail = true;
break;
}
}
open -= extra[0];
if (open < 0) {
fail = true;
}
if (fail) {
low = mid + 1;
} else {
high = mid;
}
}
if (low > power[0]) {
cout << -1 << endl;
return 0;
}
for (int i = low; i <= power[0]; i++) {
cout << i << " ";
}
cout << endl;
return 0;
}
| 2,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 200050;
inline int read() {
char ch;
while ((ch = getchar()) < '0' || ch > '9')
;
int res = ch - '0';
while ((ch = getchar()) >= '0' && ch <= '9') res = res * 10 + ch - '0';
return res;
}
char s[N >> 1], t;
int tot, rt[N], lst, n, pre[N], qlm[N], len[N], tar[N][28];
struct node {
int ls, rs;
} d[N * 42];
struct Seg {
int rnm;
void modify(int &k, int l, int r, int x) {
if (!k) k = ++rnm;
if (l == r) return;
int mid = l + r >> 1;
if (x <= mid)
modify(d[k].ls, l, mid, x);
else
modify(d[k].rs, mid + 1, r, x);
}
bool query(int k, int l, int r, int x, int y) {
if (!k || l > y || r < x) return 0;
if (l >= x && r <= y) return 1;
int mid = l + r >> 1;
if (query(d[k].ls, l, mid, x, y)) return 1;
if (query(d[k].rs, mid + 1, r, x, y)) return 1;
return 0;
}
int mrge(int k1, int k2) {
if (!k1 || !k2) return k1 | k2;
int now = ++rnm;
d[now].ls = mrge(d[k1].ls, d[k2].ls);
d[now].rs = mrge(d[k1].rs, d[k2].rs);
return now;
}
} T;
int node(int l) {
len[++tot] = l;
return tot;
}
void ins(int c) {
int i = lst;
lst = node(len[i] + 1);
qlm[lst] = 1;
while (!tar[i][c]) {
tar[i][c] = lst;
if (!(i = pre[i])) return void(pre[lst] = 1);
}
int rtm = tar[i][c];
if (len[rtm] == len[i] + 1) return void(pre[lst] = rtm);
int gnn = node(len[i] + 1);
pre[gnn] = pre[rtm];
pre[rtm] = pre[lst] = gnn;
memcpy(tar[gnn], tar[rtm], sizeof(tar[0]));
do {
tar[i][c] = gnn;
i = pre[i];
} while (i && tar[i][c] == rtm);
}
vector<int> G[N];
void dfs(int u) {
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
dfs(v);
rt[u] = T.mrge(rt[u], rt[v]);
}
if (qlm[u]) T.modify(rt[u], 1, n, len[u]);
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
lst = tot = 1;
for (int i = 1; i <= n; i++) ins(s[i] - 'a');
for (int i = 2; i <= tot; i++) G[pre[i]].push_back(i);
dfs(1);
int q = read(), l, r;
while (q--) {
l = read();
r = read();
scanf("%s", s + 1);
int pos = -1, u = 1, m = strlen(s + 1);
s[++m] = 'a' - 1;
for (int i = 1; i <= m; i++) {
int c = s[i] - 'a';
for (int j = c + 1; j < 26; j++)
if (tar[u][j] && T.query(rt[tar[u][j]], 1, n, l + i - 1, r)) {
pos = i;
t = 'a' + j;
break;
}
if (i == m || !tar[u][c] || !T.query(rt[tar[u][c]], 1, n, l + i - 1, r))
break;
u = tar[u][c];
}
if (pos == -1)
printf("-1\n");
else {
for (int i = 1; i < pos; i++) printf("%c", s[i]);
printf("%c\n", t);
}
}
return 0;
}
| 3,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, n;
cin >> a >> b >> c >> n;
if (c > a || c > b || n - (a + b - c) < 1)
cout << -1;
else
cout << n - (a + b - c);
return 0;
}
| 1,000 | CPP |
import sys
input=sys.stdin.readline
t=int(input())
while t>0:
n=int(input())
d=list(map(int,input().split()))
d.sort()
ans=0
for i in range(1,n):
ans+=((d[i]-d[i-1])*i*(n-i))
print(d[-1]-ans)
t-=1 | 1,400 | PYTHON3 |
l = input().split()
m = int(l[0])
n = int(l[1])
a = int(l[2])
t1, t2 = 0, 0
t1 = m // a
if (m % a > 0):
t1 = t1 + 1
t2 = n // a
if (n % a > 0):
t2 = t2 + 1
print(t1 * t2)
| 1,000 | PYTHON3 |
def check_case(w):
if(len(w)==1 and w.islower()==True):
return(w.upper())
elif(len(w)!=1 and w[0].islower()):
for i in range(1,len(w)):
if(w[i].isupper()):
pass
else:
return(w)
elif(w.isupper()):
return(w.swapcase())
else:
return(w)
return(w.swapcase())
w=input()
print(check_case(w)) | 1,000 | PYTHON3 |
t=int(input())
l=[]
for i in range(t):
a = list(map(int, input().split()))
l.append(a)
for i in l:
i.sort()
b = i[0]
c = i[1]
d = i[2]
if (b + c) >= (d - 1):
print("Yes")
else:
print("No")
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char arr[] = {'R', 'O', 'Y', 'B', 'G', 'V'};
string str;
int arr2[6];
memset(arr2, 0, sizeof(int) * 6);
cin >> str;
int i, j, k;
for (int i = 0; i < str.size(); i += 1) {
for (int j = 0; j < 6; j += 1) {
if (str[i] == arr[j]) {
arr2[j]++;
}
}
}
sort(arr2, arr2 + 6);
if (arr2[5] == 6 || arr2[5] == 5) {
cout << "1\n";
return 0;
}
if (arr2[5] == 4) {
cout << "2\n";
return 0;
}
if (arr2[5] == 1) {
cout << "30\n";
}
if (arr2[5] == 3) {
if (arr2[4] == 3)
cout << "2\n";
else if (arr2[4] == 2) {
cout << "3\n";
return 0;
} else {
cout << "5\n";
return 0;
}
}
if (arr2[5] == 2) {
if (arr2[4] == 1)
cout << "15\n";
else {
if (arr2[3] == 1) {
cout << "8\n";
} else {
cout << "6\n";
}
}
}
}
| 1,700 | CPP |
t=int(input())
while(t):
n=int(input())
l=list(map(int,input().split()))
odd=0
even=0
for i in l:
if(i%2!=0):
odd+=1
else:
even+=1
if(odd==0 or (even==0 and n%2==0)):
print("NO")
else:
print("YES")
t=t-1 | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
int i = 0;
while (k != 0 && i < n) {
int dist_a = abs(s[i] - 'a');
int dist_z = abs(s[i] - 'z');
if (dist_a >= dist_z) {
if (dist_a >= k) {
s[i] = (char)(s[i] - k);
k = 0;
} else {
s[i] = 'a';
k -= dist_a;
}
} else {
if (dist_z >= k) {
s[i] = (char)(s[i] + k);
k = 0;
} else {
s[i] = 'z';
k -= dist_z;
}
}
i++;
}
if (k > 0)
printf("-1\n");
else
cout << s;
return 0;
}
| 1,300 | CPP |
import sys
input = lambda: sys.stdin.readline().strip()
inp = lambda: list(map(int,input().split()))
a = str(input())
ans = [0]
for i in range(1,len(a)):
if a[i]==a[i-1]:
ans.append(ans[-1]+1)
else:
ans.append(ans[-1])
for _ in range(int(input())):
b,c = inp()
print(ans[c-1]-ans[b-1])
| 1,100 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch ^ 48);
return x;
}
void print(int x) {
if (x > 9) print(x / 10);
putchar((x % 10) ^ 48);
}
int n, m, k;
vector<int> a[200010], b[200010], c[200010], d[200010], e[200010], f[200010];
int L[4000010], R[4000010], D[4000010], U[4000010], F[4000010], B[4000010];
int gethash(int x, int y, int z) {
return x * (m + 2) * (k + 2) + y * (k + 2) + z;
}
void getid(int cur, int &x, int &y, int &z) {
z = cur % (k + 2);
y = cur / (k + 2) % (m + 2);
x = cur / (k + 2) / (m + 2);
}
bool is_bound(int cur) {
int z = cur % (k + 2);
int y = cur / (k + 2) % (m + 2);
int x = cur / (k + 2) / (m + 2);
return !x || x > n || !y || y > m || !z || z > k;
}
bool mrk[4000010];
void dfs(int x, int y, int z) {
if (!x || x > n || !y || y > m || !z || z > k) return;
int cur = gethash(x, y, z);
if (mrk[cur]) return;
int tmp = -1;
if (is_bound(L[cur])) {
if (!a[y][z]) goto DEL;
if (tmp == -1)
tmp = a[y][z];
else if (tmp ^ a[y][z])
goto DEL;
}
if (is_bound(R[cur])) {
if (!b[y][z]) goto DEL;
if (tmp == -1)
tmp = b[y][z];
else if (tmp ^ b[y][z])
goto DEL;
}
if (is_bound(D[cur])) {
if (!c[x][z]) goto DEL;
if (tmp == -1)
tmp = c[x][z];
else if (tmp ^ c[x][z])
goto DEL;
}
if (is_bound(U[cur])) {
if (!d[x][z]) goto DEL;
if (tmp == -1)
tmp = d[x][z];
else if (tmp ^ d[x][z])
goto DEL;
}
if (is_bound(F[cur])) {
if (!e[x][y]) goto DEL;
if (tmp == -1)
tmp = e[x][y];
else if (tmp ^ e[x][y])
goto DEL;
}
if (is_bound(B[cur])) {
if (!f[x][y]) goto DEL;
if (tmp == -1)
tmp = f[x][y];
else if (tmp ^ f[x][y])
goto DEL;
}
return;
DEL:
mrk[cur] = 1;
R[L[cur]] = R[cur];
L[R[cur]] = L[cur];
U[D[cur]] = U[cur];
D[U[cur]] = D[cur];
F[B[cur]] = F[cur];
B[F[cur]] = B[cur];
int a, b, c;
getid(L[cur], a, b, c);
dfs(a, b, c);
getid(R[cur], a, b, c);
dfs(a, b, c);
getid(D[cur], a, b, c);
dfs(a, b, c);
getid(U[cur], a, b, c);
dfs(a, b, c);
getid(F[cur], a, b, c);
dfs(a, b, c);
getid(B[cur], a, b, c);
dfs(a, b, c);
}
int col[4000010];
int main() {
n = read(), m = read(), k = read();
for (int i = 1; i <= m; i++) {
a[i].resize(k + 1);
for (int j = 1; j <= k; j++) a[i][j] = read();
}
for (int i = 1; i <= m; i++) {
b[i].resize(k + 1);
for (int j = 1; j <= k; j++) b[i][j] = read();
}
for (int i = 1; i <= n; i++) {
c[i].resize(k + 1);
for (int j = 1; j <= k; j++) c[i][j] = read();
}
for (int i = 1; i <= n; i++) {
d[i].resize(k + 1);
for (int j = 1; j <= k; j++) d[i][j] = read();
}
for (int i = 1; i <= n; i++) {
e[i].resize(m + 1);
for (int j = 1; j <= m; j++) e[i][j] = read();
}
for (int i = 1; i <= n; i++) {
f[i].resize(m + 1);
for (int j = 1; j <= m; j++) f[i][j] = read();
}
for (int i = 0; i <= n + 1; i++)
for (int j = 0; j <= m + 1; j++)
for (int u = 0; u <= k + 1; u++) {
int x = gethash(i, j, u);
if (i) L[x] = gethash(i - 1, j, u);
if (i <= n) R[x] = gethash(i + 1, j, u);
if (j) D[x] = gethash(i, j - 1, u);
if (j <= m) U[x] = gethash(i, j + 1, u);
if (u) F[x] = gethash(i, j, u - 1);
if (u <= k) B[x] = gethash(i, j, u + 1);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) dfs(i, j, 1), dfs(i, j, k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= k; j++) dfs(i, 1, j), dfs(i, m, j);
for (int i = 1; i <= m; i++)
for (int j = 1; j <= k; j++) dfs(1, i, j), dfs(n, i, j);
for (int i = 1; i <= m; i++)
for (int j = 1; j <= k; j++) {
int x = gethash(0, i, j), y = gethash(n + 1, i, j);
if (a[i][j]) {
if (R[x] == y) return puts("-1"), 0;
col[R[x]] = a[i][j];
}
if (b[i][j]) {
if (L[y] == x) return puts("-1"), 0;
col[L[y]] = b[i][j];
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= k; j++) {
int x = gethash(i, 0, j), y = gethash(i, m + 1, j);
if (c[i][j]) {
if (U[x] == y) return puts("-1"), 0;
col[U[x]] = c[i][j];
}
if (d[i][j]) {
if (D[y] == x) return puts("-1"), 0;
col[D[y]] = d[i][j];
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
int x = gethash(i, j, 0), y = gethash(i, j, k + 1);
if (e[i][j]) {
if (B[x] == y) return puts("-1"), 0;
col[B[x]] = e[i][j];
}
if (f[i][j]) {
if (F[y] == x) return puts("-1"), 0;
col[F[y]] = f[i][j];
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
for (int u = 1; u <= k; u++) print(col[gethash(i, j, u)]), putchar(' ');
puts("");
return 0;
}
| 3,500 | CPP |
n,k = [int(x) for x in input().split()]
l1 = []
l2 = []
noo = 0
noe = 0
if n%2 == 0:
noo = int(n/2)
noe = int(n/2)
else:
noo = int(n/2) +1
noe = int(n/2)
if k <= noo:
print((2*k)-1)
else:
k -= noo
print(2*k) | 900 | PYTHON3 |
#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define ll long long
#define mod 1000000007
using namespace std;
int dp[100];
int sol(int i,vector<int> v, int dp[]){
if(i<0){
return 0;
}
if(dp[i]!=-1){
return dp[i];
}
dp[i]=0;
for(int j=0;j<v.size();j++){
if(sol(i-v[j],v,dp)==1){
dp[i]=1;
return dp[i];
}
}
return dp[i];
}
int solve(){
int n,d;
cin>>n>>d;
int a[n+1];
for(int i=0;i<100;i++){
dp[i]=-1;
}
dp[0]=1;
vector<int> v;
int num=d;
while(num<d*10){
v.push_back(num);
num+=10;
dp[num]=1;
}
for(int i=0;i<n;i++){
cin>>a[i];
int val;
if(a[i]>=d*10){
val=1;
}
else{
val=sol(a[i],v,dp);
}
if(val){
cout<<"YES"<<endl;
}
else{
cout<<"NO"<<endl;
}
}
return 0;
}
int main() {
IOS
ll t;
cin>>t;
while(t--){
solve();
}
return 0;
}
| 1,100 | CPP |
import io
import os
from collections import Counter, defaultdict, deque
def solve(N, A):
pref = [0]
for x in A:
pref.append(pref[-1] + x)
intervals = []
lastIndex = {}
for i, x in enumerate(pref):
if x in lastIndex:
intervals.append((lastIndex[x], i))
lastIndex[x] = i
stabs = []
for x, y in intervals:
if stabs and x < stabs[-1]:
continue
else:
stabs.append(y - 1)
return len(stabs)
if __name__ == "__main__":
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
N, = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
ans = solve(N, A)
print(ans)
| 1,500 | PYTHON3 |
n = int(input())
arr = list(map(int,input().split()))
curr = 0
t = -1
for i,a in enumerate(arr):
if a==curr:
curr+=1
elif a>curr:
t=i+1
break
print(t) | 1,000 | PYTHON3 |
a = input()
b = input()
res = ""
for i in range(len(a)):
if a[i]==b[i]:
res += "0"
else:
res += "1"
print(res) | 800 | PYTHON3 |
n=int(input())
B=[1,2,3,4,5,6]
A=list(map(int,input().split()))
for i in range(n):
if A[i]%14 in B and A[i]>14:
print('YES')
else:
print('NO') | 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long int a[100002], b[100002], sum[100002];
int main() {
long long int n, m, c;
cin >> n >> m >> c;
for (long long int i = 0; i < n; ++i) cin >> a[i];
for (long long int i = 0; i < m; ++i) cin >> b[i];
sum[0] = b[0];
for (int i = 1; i < m; ++i) {
sum[i] += (sum[i - 1] + b[i]);
}
if (m != 1) {
long long int k = m - 2;
for (long long int i = 0; i < n; ++i) {
if (i < n - (n - m + 1)) {
a[i] += sum[i];
} else {
a[i] += sum[m - 1];
}
}
for (long long int i = n - 1; k != -1; --i) {
a[i] -= sum[k];
--k;
}
} else {
for (long long int i = 0; i < n; ++i) a[i] += b[0];
}
for (long long int i = 0; i < n - 1; ++i) cout << a[i] % c << " ";
cout << a[n - 1] % c << endl;
return 0;
}
| 1,500 | CPP |
s=str(input()).lower()
j=str(input()).lower()
if s<j:
print('-1')
elif j<s:
print('1')
else:
print('0') | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool umin(T1& x, T2 y) {
return (x > y ? (x = y, true) : false);
}
template <typename T1, typename T2>
bool umax(T1& x, T2 y) {
return (x < y ? (x = y, true) : false);
}
template <typename T>
void read(T& x) {
char ch;
T p = 1;
x = 0;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= p;
}
void read(string& x) {
char ch;
do {
ch = getchar();
} while (ch <= ' ');
while (ch > ' ') x += ch, ch = getchar();
}
void read(char& x) {
do {
x = getchar();
} while (x <= ' ');
}
template <typename T, typename... R>
void read(T& x, R&... y) {
read(x);
read(y...);
}
const int N = (int)1e5 + 3;
const long long mod = (long long)1e9 + 7;
const int INF = (int)1e9 + 1;
const long long LLINF = (long long)1e18 + 1;
const long double pi = (long double)acos(-1.0);
const long double eps = (long double)1e-11;
const int block = 93;
int n, m, r;
int p[N];
int w[N];
int d[N];
int sz[N];
int in[N];
int out[N];
vector<int> g[N];
vector<int> sn[N];
void prepare(int v, int p) {
static int timer = 0;
in[v] = ++timer;
::p[v] = p;
for (int to : g[v])
if (to != p) prepare(to, v);
out[v] = ++timer;
}
inline bool upper(int x, int y) { return in[x] <= in[y] && out[y] <= out[x]; }
void dfs(int v, int p, int dist = 0) {
d[v] = dist;
sz[v] = 1;
for (int to : g[v]) {
if (to == p) continue;
dfs(to, v, dist + 1);
sz[v] += sz[to];
}
if (sz[v] > block) {
sn[v].resize(n + 1);
sz[v] = 1;
for (long long i = (0); i < (n); i++) {
if (upper(v, i)) {
if (sn[v][d[i] - d[v]] == 0) {
sn[v][d[i] - d[v]] = w[i];
}
umin(sn[v][d[i] - d[v]], w[i]);
}
}
int mn = INF;
for (long long i = (0); i < (n + 1); i++) {
if (sn[v][i] > 0) umin(mn, sn[v][i]);
sn[v][i] = mn;
}
}
}
int query(int v, int p, int md) {
if (md < 0) return INF;
int ret = w[v];
if (!sn[v].empty()) return sn[v][md];
for (int to : g[v]) {
if (to == p) continue;
umin(ret, query(to, v, md - 1));
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
read(n, r);
for (long long i = (0); i < (n); i++) read(w[i]);
for (long long i = (1); i < (n); i++) {
int x, y;
read(x, y);
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
prepare(--r, -1);
dfs(r, -1);
int last = 0;
read(m);
while (m-- > 0) {
int p, q;
read(p, q);
int v = (p + last) % n;
int k = (q + last) % n;
last = query(v, ::p[v], k);
printf("%d\n", last);
}
return 0;
}
| 2,300 | CPP |
#include<bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
void solve()
{
int n;
cin >> n;
vi v(n);
for(int i=0;i<n;i++) cin >> v[i];
reverse(v.begin(),v.end());
vi x(n);
int z=0;
for(int i=0;i<n;i++)
{
x[i]=0;
z=max(v[i],z);
if(z>0)
{
x[i]=1;
z--;
}
}
for(int i=n-1;i>=0;i--) cout << x[i] << " ";
cout << '\n';
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while(t--)
solve();
return 0;
}
| 900 | CPP |
_=int(input())
def chk(a,b):
n=len(b)
a=sorted(a)
for i in range(1,n+1):
for j in range(i):
if sorted(b[j:i])==a:return True
return False
for __ in range(_):
a=input()
b=input()
print("YES" if chk(a,b) else "NO")
| 1,000 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int T, n, a[1005], r[1005], t[1005];
long long ans, cnt, s;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
s = a[i];
cnt = a[i];
t[i] = a[i];
for (int j = i - 1; j >= 1; j--)
s = min(s, (long long)a[j]), cnt += s, t[j] = s;
s = a[i];
for (int j = i + 1; j <= n; j++)
s = min(s, (long long)a[j]), cnt += s, t[j] = s;
if (cnt > ans) {
memcpy(r, t, sizeof(t));
ans = cnt;
}
}
for (int i = 1; i <= n; i++) printf("%d ", r[i]);
return 0;
}
| 1,500 | CPP |
t = input()
char = t[0].upper()
print(char+t[1:]) | 800 | PYTHON3 |
tt=int(input())
for i in range(tt):
n=int(input())
arr=list(map(int,input().split()))
arr.sort()
seclast=arr[-2]-1
if n<3:
print(0)
else:
if len(arr)-2<seclast:
print(len(arr)-2)
else:
print(seclast)
| 900 | PYTHON3 |
string = input()
string = list(string)
haha = []
for i in string:
if(i != "{" and i != "}" and i != "," and i != " "):
haha.append(i)
print(len(list(set(haha))))
| 800 | PYTHON3 |
a = input()
a = a.lower()
b = input()
b = b.lower()
if a == b:
print(0)
elif a < b:
print(-1)
else:
print(1)
| 800 | PYTHON3 |
n=int(input())
print(["YES","NO"][all(n%i for i in [4,77,47,74,44,477,744.474,747,7])]) | 1,000 | PYTHON3 |
w=int(input())
print('Yes' if w%2==0 and w>2 else 'No') | 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int oleg, lb, ub;
cin >> oleg >> lb >> ub;
int notec;
cin >> notec;
int ans = 0;
for (int i = 0; i < notec; i++) {
int safe;
cin >> safe;
if (lb < safe && safe < ub) {
ans++;
}
}
cout << ans << endl;
}
| 800 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[5100], sum[5100];
int main() {
int i, j, k;
int n, m, t;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(sum, 0, sizeof(sum));
for (i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
double mx = 0.0, temp;
for (i = 1; i <= (n - k + 1); i++) {
for (j = k + i - 1; j <= n; j++) {
temp = (sum[j] - sum[i - 1]) * 1.0;
temp /= (j - i + 1);
mx = max(mx, temp);
}
}
cout << setprecision(15) << mx;
return 0;
}
| 1,300 | CPP |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, nxt;
} e[100005];
int head[100005], cnte, n, m;
void adde(int u, int v) {
e[++cnte] = (edge){v, head[u]};
head[u] = cnte;
}
int fa[100005];
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
void merge(int x, int y) {
if ((x = find(x)) ^ (y = find(y))) fa[x] = y;
}
queue<int> q;
int vis[100005], in[100005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) fa[i] = i;
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
adde(u, v);
merge(u, v);
in[v]++;
}
int ans = n;
for (int i = 1; i <= n; i++)
fa[i] = find(i), ans -= vis[fa[i]] == 0, vis[fa[i]] = 1;
for (int i = 1; i <= n; i++)
if (!in[i]) q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
in[v]--;
if (!in[v]) q.push(v);
}
}
for (int i = 1; i <= n; i++)
if (in[i]) ans += vis[fa[i]], vis[fa[i]] = 0;
return printf("%d\n", ans), 0;
}
| 2,200 | CPP |
check = int(input())
if(check > 2 and check % 2 == 0):
print("YES")
else:
print("NO")
| 800 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int dxhorse[] = {-2, -2, -1, -1, 1, 1, 2, 2};
const int dyhorse[] = {1, -1, 2, -2, 2, -2, 1, -1};
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy[] = {0, 1, 0, -1, -1, 1, -1, 1};
const long double pie = 3.1415926535897932384626;
const long long N = 300009;
int main() {
long long n;
cin >> n;
map<long long, long long> umap;
long long arr[n];
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
arr[i] = x;
umap[x] = max(umap[x], umap[x - 1] + 1);
}
long long maxi = 0, p;
for (long long i = 0; i < n; i++) {
if (umap[arr[i]] > maxi) {
maxi = umap[arr[i]];
p = i;
}
}
cout << maxi << "\n";
long long itr = arr[p];
vector<long long> brr;
for (long long i = n - 1; i >= 0; i--) {
if (arr[i] == itr) {
brr.push_back(i + 1);
itr--;
}
}
for (long long i = brr.size() - 1; i >= 0; i--) {
cout << brr[i] << " ";
}
return 0;
}
| 1,700 | CPP |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
map<int, stack<int>> num;
int p[200068], q[200068];
pair<int, int> s[200068];
int main() {
ios_base::sync_with_stdio(false);
int n, k, sock = 0, count = 0, ad = 0, tim = 0, i;
cin >> n >> sock;
for (i = 0; i < n; i++) {
cin >> k;
mp[k]++;
num[k].push(i);
}
for (i = 0; i < sock; i++) {
cin >> k;
s[i] = {k, i};
}
sort(s, s + sock);
for (i = 0; i < sock; i++) {
k = s[i].first;
s[i].first = 0;
tim = 0;
while (k > 1) {
if (mp[k] > 0)
break;
else
k = (k / 2) + (k % 2);
tim++;
}
if (k == 1 && mp[k] == 0) continue;
if (k > 0) {
mp[k]--;
count++;
ad += tim;
q[s[i].second] = tim;
p[num[k].top()] = s[i].second + 1;
num[k].pop();
}
}
cout << count << " " << ad << endl;
for (i = 0; i < sock; i++) cout << q[i] << " ";
cout << endl;
for (i = 0; i < n; i++) cout << p[i] << " ";
cout << endl;
}
| 2,100 | CPP |
import math
t=int(input())
while t>0:
t-=1
n=int(input())
a=list(map(int,input().split()))
maxx=max(a)
q=True
if n==1:
print('YES')
else:
for i in range(n):
a[i]=maxx-a[i]
for i in range(n):
if a[i]%2!=0:
print('NO')
q=False
break
else:
q=True
if q==True:
print('YES')
| 900 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, b;
vector<int> a;
set<pair<int, int> > second;
vector<pair<int, int> > ans;
int main() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
second.insert(make_pair(a[i], i));
}
set<pair<int, int> >::iterator it = second.begin();
for (int i = 0; i < n; i++, it++) {
if (a[i] != (*it).first) {
ans.push_back(make_pair(i, (*it).second));
second.erase(make_pair(a[i], i));
second.insert(make_pair(a[i], (*it).second));
swap(a[i], a[(*it).second]);
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
| 1,200 | CPP |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("fast-math")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native")
const long double eps = 1e-7;
const long long INF = 1e18;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long l[n], r[n];
long long n1 = INF, n2 = 0;
for (long long i = 0; i < n; i++) {
cin >> l[i] >> r[i];
n1 = min(n1, r[i]);
n2 = max(n2, l[i]);
}
cout << max(0ll, n2 - n1) << '\n';
}
return 0;
}
| 1,100 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
const int N = 3000000;
int getin() {
int x = 0, f = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') f = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - 48, ch = getchar();
return x * f;
}
int qmod1(const int &x) { return x >= mod ? x - mod : x; }
int qmod2(const int &x) { return x + (x >> 31 & mod); }
int qpower(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) ans = 1ll * ans * a % mod;
return ans;
}
struct Z {
int x;
Z(int v = 0) { x = qmod2(v % mod); }
int qmod1(const int &x) const { return x >= mod ? x - mod : x; }
int qmod2(const int &x) const { return x + (x >> 31 & mod); }
int qpower(int a, int b) const {
int ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) ans = 1ll * ans * a % mod;
return ans;
}
Z &operator+=(const Z &b) {
x += b.x;
if (x >= mod) x -= mod;
return *this;
}
Z &operator-=(const Z &b) {
x -= b.x;
x += x >> 31 & mod;
return *this;
}
Z &operator*=(const Z &b) {
x = 1ll * x * b.x % mod;
return *this;
}
Z inv() const { return qpower(x, mod - 2); }
Z &operator/=(const Z &b) {
x = 1ll * x * qpower(b.x, mod - 2) % mod;
return *this;
}
Z operator-() const { return (Z){qmod2(-x)}; }
operator int() const { return x; }
};
Z operator+(const Z &a, const Z &b) { return (Z){qmod1(a.x + b.x)}; }
Z operator-(const Z &a, const Z &b) { return (Z){qmod2(a.x - b.x)}; }
Z operator*(const Z &a, const Z &b) {
return (Z){(int)(1ll * a.x * b.x % mod)};
}
Z operator/(const Z &a, const Z &b) {
return (Z){(int)(1ll * a.x * qpower(b.x, mod - 2) % mod)};
}
Z operator+(const Z &a, const int &b) { return a + Z(b); }
Z operator+(const int &a, const Z &b) { return (Z)a + b; }
Z operator-(const Z &a, const int &b) { return a - Z(b); }
Z operator-(const int &a, const Z &b) { return (Z)a - b; }
Z operator*(const Z &a, const int &b) { return a * Z(b); }
Z operator*(const int &a, const Z &b) { return Z(a) * b; }
Z operator/(const Z &a, const int &b) { return a * Z(b); }
Z operator/(const int &a, const Z &b) { return Z(a) * b; }
bool operator<(const Z &a, const Z &b) { return a.x < b.x; }
bool operator==(const Z &a, const Z &b) { return a.x == b.x; }
template <typename T>
T qpower(T a, int b) {
T ans = 1;
for (; b; b >>= 1, a = a * a)
if (b & 1) ans = ans * a;
return ans;
}
void print(const Z &a) { printf("%d", a.x); }
struct Zd {
Z x, y, d;
Zd(const Z &_x, const Z &_y, const Z &_d) { x = _x, y = _y, d = _d; }
Zd(const Z &_x) { x = _x, y = 0; }
Zd operator+(const Zd &a) const { return Zd(x + a.x, y + a.y, d); }
Zd operator-(const Zd &a) const { return Zd(x - a.x, y - a.y, d); }
Zd operator*(const Zd &a) const {
return Zd(x * a.x + y * a.y * d, x * a.y + y * a.x, d);
}
Zd inv() const {
Z t = x * x - y * y * d;
t = t.inv();
return Zd(x * t, -y * t, d);
}
Zd operator/(const Zd &a) const { return *this * a.inv(); }
Zd &operator+=(const Zd &a) {
x += a.x, y += a.y;
return *this;
}
Zd &operator-=(const Zd &a) {
x -= a.x, y -= a.y;
return *this;
}
Zd &operator*=(const Zd &a) {
*this = *this * a;
return *this;
}
Zd &operator/=(const Zd &a) {
*this = *this / a;
return *this;
}
Zd operator-() const { return Zd(-x, -y, d); }
};
Zd qpower(Zd a, int b) {
Zd ans(1, 0, a.d);
for (; b; b >>= 1, a = a * a)
if (b & 1) ans = ans * a;
return ans;
}
Z sqrt(Z x) {
Z a = rand(), t;
while (qpower(t = a * a - x, (mod - 1) >> 1) == Z(1)) a = rand();
Zd w(a, -1, t), ans = qpower(w, (mod + 1) >> 1);
return min(ans.x, -ans.x);
}
namespace Poly_fast {
int w[N], inv[N], pool[N << 4];
int limn, rev[N], lg[N];
int curn;
void prework(int n) {
limn = 1;
while (limn < n) limn <<= 1;
for (int i = 1; i < limn; i++)
rev[i] = rev[i >> 1] >> 1 | ((i & 1) ? (limn >> 1) : 0);
for (int i = 1; i < limn; i <<= 1) {
w[i] = 1;
int omg = qpower(3, (mod - 1) / (i << 1));
for (int j = 1; j < i; j++) w[i + j] = 1ll * w[i + j - 1] * omg % mod;
}
for (int i = 2; i <= limn; i++) lg[i] = lg[i >> 1] + 1;
inv[1] = 1;
for (int i = 2; i < limn; i++)
inv[i] = 1ll * inv[mod % i] * (mod - mod / i) % mod;
}
void setn(int n) {
curn = n;
if (limn < n) prework(n);
}
void DFT(int a[], int n) {
if (limn < n) prework(n);
int t = lg[limn / n];
unsigned long long tmp[n];
for (int i = 0; i < n; i++) tmp[rev[i] >> t] = a[i];
for (int i = 1; i < n; i <<= 1)
for (int j = 0; j < n; j += i << 1)
for (int k = 0; k < i; k++) {
unsigned t = tmp[i + j + k] * w[i + k] % mod;
tmp[i + j + k] = tmp[j + k] + mod - t, tmp[j + k] += t;
}
for (int i = 0; i < n; i++) a[i] = tmp[i] % mod;
}
void IDFT(int a[], int n) {
reverse(a + 1, a + n);
DFT(a, n);
int iv = mod - (mod - 1) / n;
for (int i = 0; i < n; i++) a[i] = 1ll * a[i] * iv % mod;
}
void print(int a[], int n) {
for (int i = 0; i < n; i++) cout << a[i] << " ";
puts("");
}
void mul(const int A[], const int B[], int c[], const int &n) {
int l = 1;
while (l < (n << 1)) l <<= 1;
int tmpa[l], tmpb[l];
copy(A, A + n, tmpa), copy(B, B + n, tmpb);
fill(tmpa + n, tmpa + l, 0), fill(tmpb + n, tmpb + l, 0);
DFT(tmpa, l), DFT(tmpb, l);
for (int i = 0; i < l; i++) c[i] = 1ll * tmpa[i] * tmpb[i] % mod;
IDFT(c, l);
}
int *_f[20][1 << 3], *_g[20][1 << 3];
void cdq(const int l, const int r, int dep, int f[], const int g[],
void brute(int *, const int *, const int, const int)) {
if (r - l + 1 <= 32) {
brute(f, g, l, r);
return;
}
const int d = 1 << ((dep - 1) * 3);
int tmpf[d << 1];
for (int i = 0;; i++) {
int L = l + i * d, R = min(r, L + d - 1);
if (i) {
fill(tmpf, tmpf + (d << 1), 0);
for (int j = 0; j < i; j++)
for (int k = 0; k < (d << 1); k++)
tmpf[k] = (tmpf[k] + 1ll * _f[dep][j][k] * _g[dep][i - j][k]) % mod;
IDFT(tmpf, d << 1);
for (int i = L; i <= R; i++) f[i] = qmod1(f[i] + tmpf[i - L + d]);
}
cdq(L, R, dep - 1, f, g, brute);
if (R == r) return;
fill(_f[dep][i], _f[dep][i] + (d << 1), 0);
copy(f + L, f + R + 1, _f[dep][i]);
DFT(_f[dep][i], d << 1);
}
}
void cdq_pre(int f[], const int g[], const int n,
void brute(int *, const int *, const int, const int)) {
fill(f, f + n, 0);
if (n <= 128) {
brute(f, g, 0, n - 1);
return;
}
int len = 1, dep = 0;
while (len < n) len <<= 3, ++dep;
len >>= 3;
int *p = pool;
for (int i = 1; i <= dep; i++) {
int d = 1 << ((i - 1) * 3), tn = min((1 << 3) - 1, (n - 1) / d);
for (int j = 1; j <= tn; j++) {
int l = (j - 1) * d + 1, r = min(n - 1, (j + 1) * d - 1);
_f[i][j - 1] = p, p += d << 1;
_g[i][j] = p;
p += d << 1;
fill(_g[i][j], _g[i][j] + (d << 1), 0);
copy(g + l, g + r + 1, _g[i][j] + 1);
DFT(_g[i][j], d << 1);
}
}
cdq(0, n - 1, dep, f, g, brute);
}
void Der(int f[], const int g[], const int n) {
for (int i = 0; i < n - 1; i++) f[i] = 1ll * (i + 1) * g[i + 1] % mod;
f[n - 1] = 0;
}
void Int(int f[], const int g[], const int n) {
for (int i = n - 1; i >= 1; i--) f[i] = 1ll * inv[i] * g[i - 1] % mod;
f[0] = 0;
}
void brute_ln(int f[], const int g[], const int l, const int r) {
if (!l)
f[l] = 0;
else
f[l] = qmod2(1ll * l * g[l] % mod - f[l]);
for (int i = l + 1; i <= r; i++) {
for (int j = l; j < i; j++) f[i] = (f[i] + 1ll * f[j] * g[i - j]) % mod;
f[i] = qmod2(1ll * i * g[i] % mod - f[i]);
}
}
void Ln(int f[], const int g[], const int n) {
cdq_pre(f, g, n, brute_ln);
f[0] = 0;
for (int i = 1; i < n; i++) f[i] = 1ll * f[i] * inv[i] % mod;
}
void brute_exp(int f[], const int g[], const int l, const int r) {
if (!l)
f[l] = 1;
else
f[l] = 1ll * f[l] * inv[l] % mod;
for (int i = l + 1; i <= r; i++) {
for (int j = l; j < i; j++) f[i] = (f[i] + 1ll * f[j] * g[i - j]) % mod;
f[i] = 1ll * f[i] * inv[i] % mod;
}
}
void Exp(int f[], const int g[], const int n) {
int tmpg[n];
for (int i = 0; i < n; i++) tmpg[i] = 1ll * i * g[i] % mod;
cdq_pre(f, tmpg, n, brute_exp);
}
void brute_inv(int f[], const int g[], const int l, const int r) {
if (!l) f[l] = 1;
for (int i = l + 1; i <= r; i++)
for (int j = l; j < i; j++) f[i] = (f[i] + 1ll * f[j] * g[i - j]) % mod;
}
void Inv(int f[], const int g[], const int n) {
int tmpg[n];
int iv = qpower(g[0], mod - 2);
for (int i = 1; i < n; i++) tmpg[i] = 1ll * (mod - g[i]) * iv % mod;
cdq_pre(f, tmpg, n, brute_inv);
for (int i = 0; i < n; i++) f[i] = 1ll * f[i] * iv % mod;
}
void Pow(int f[], const int g[], const int n, const int K) {
Ln(f, g, n);
for (int i = 0; i < n; i++) f[i] = 1ll * f[i] * K % mod;
int tmpf[n];
copy(f, f + n, tmpf);
Exp(f, tmpf, n);
}
void Sqrt(int f[], const int g[], const int n) {
int t = g[0], iv = qpower(t, mod - 2);
int tmpg[n];
for (int i = 0; i < n; i++) tmpg[i] = 1ll * g[i] * iv % mod;
Pow(f, tmpg, n, (mod + 1) >> 1);
t = sqrt((Z)t);
for (int i = 0; i < n; i++) f[i] = 1ll * f[i] * t % mod;
}
} // namespace Poly_fast
struct Poly {
vector<Z> a;
Poly() {}
Poly(const Z &x) {
a.resize(1);
a[0] = x;
}
Poly(const Z &x, const Z &y) {
a.resize(2);
a[0] = x, a[1] = y;
}
int size() const { return a.size(); }
void resize(const int &x) { a.resize(x); }
Z operator[](const int &x) const { return a[x]; }
Z &operator[](const int &x) { return a[x]; }
void init(const int &n) {
a.resize(n);
for (int i = 0; i < n; i++) a[i] = getin();
}
Poly &operator+=(const Poly &b) {
int m = b.size();
if ((int)a.size() < m) a.resize(m);
for (int i = 0; i < m; i++) a[i] += b[i];
return *this;
}
Poly operator-() const {
Poly c;
int n = a.size();
c.resize(n);
for (int i = 0; i < n; i++) c[i] = -a[i];
return c;
}
Poly &operator-=(const Poly &b) {
int m = b.size();
if ((int)a.size() < m) a.resize(m);
for (int i = 0; i < m; i++) a[i] -= b[i];
return *this;
}
Poly &operator*=(const Poly &b) {
using namespace Poly_fast;
const int n = curn ? curn : a.size() + b.size() - 1;
if (n <= 32 || a.size() < 5 || b.size() < 5) {
Poly ans;
ans.resize(n);
for (int i = 0; i < (int)a.size(); i++)
for (int j = 0; j < b.size() && i + j < n; j++)
ans[i + j] += a[i] * b[j];
*this = ans;
return *this;
}
int l = 1;
if (curn) {
while (l < (n << 1)) l <<= 1;
} else {
while (l < n) l <<= 1;
}
const int len = l;
int f[len], g[len];
fill(f, f + l, 0), fill(g, g + l, 0);
copy(a.begin(), min(a.begin() + n, a.end()), f),
copy(b.a.begin(), min(b.a.begin() + n, b.a.end()), g);
DFT(f, l), DFT(g, l);
for (int i = 0; i < l; i++) f[i] = 1ll * f[i] * g[i] % mod;
IDFT(f, l);
a.resize(n);
copy(f, f + n, a.begin());
return *this;
}
Poly inv() const {
using namespace Poly_fast;
const int n = curn ? curn : a.size();
int tmpg[n], tmpf[n];
fill(tmpg, tmpg + n, 0);
copy(a.begin(), min(a.begin() + n, a.end()), tmpg);
Inv(tmpf, tmpg, n);
Poly ans;
ans.resize(n);
copy(tmpf, tmpf + n, ans.a.begin());
return ans;
}
Poly &operator/=(const Poly &b) {
int n = a.size(), m = b.size();
if (n < m) {
return *this = Poly(0);
}
if (1ll * m * (n - m) <= 32 || m <= 4 || n - m <= 4) {
Poly tmp = *this;
a.resize(n - m + 1);
for (int i = n - 1; i >= m - 1; i--) {
Z t = tmp[i] / b[m - 1];
a[i - m + 1] = t;
for (int j = 0; j < m; j++) tmp[i - j] -= b[m - 1 - j] * t;
}
return *this;
}
Poly tmpb = b;
using namespace Poly_fast;
int tcurn = curn;
reverse(a.begin(), a.end()), reverse(tmpb.a.begin(), tmpb.a.end());
setn(n - m + 1);
*this *= tmpb.inv();
reverse(a.begin(), a.end());
curn = tcurn;
return *this;
}
Poly &operator%=(const Poly &b) {
int n = a.size(), m = b.size();
if (n < m) return *this;
if (1ll * (n - m) * m <= 32 || n - m <= 4 || m <= 4) {
for (int i = n - 1; i >= m - 1; i--) {
Z t = a[i] / b[m - 1];
for (int j = 0; j < m; j++) a[i - j] -= b[m - 1 - j] * t;
}
a.resize(m - 1);
return *this;
}
using namespace Poly_fast;
Poly tmpa = *this, tmpb = b;
int tcurn = curn;
reverse(tmpa.a.begin(), tmpa.a.end()),
reverse(tmpb.a.begin(), tmpb.a.end());
setn(n - m + 1);
tmpa *= tmpb.inv();
reverse(tmpa.a.begin(), tmpa.a.end());
setn(m - 1);
tmpa *= b;
*this -= tmpa;
curn = tcurn;
return *this;
}
};
Poly operator+(const Poly &a, const Poly &b) {
Poly t = a;
return t += b;
}
Poly operator-(const Poly &a, const Poly &b) {
Poly t = a;
return t -= b;
}
Poly operator*(const Poly &a, const Poly &b) {
Poly t = a;
return t *= b;
}
Poly operator/(const Poly &a, const Poly &b) {
Poly t = a;
return t /= b;
}
Poly operator%(const Poly &a, const Poly &b) {
Poly t = a;
return t %= b;
}
void print(const Poly &a) {
for (int i = 0; i < a.size(); i++) print(a[i]), putchar(' ');
puts("");
}
Poly qpower(const Poly &A, int b, const Poly &M) {
using namespace Poly_fast;
int tcurn = curn;
setn(0);
Poly ans(1);
Poly a = A;
for (; b; b >>= 1, a = a * a % M)
if (b & 1) ans = ans * a % M;
curn = tcurn;
return ans;
}
Poly Der(const Poly &g) {
using namespace Poly_fast;
const int n = curn ? curn : g.size();
Poly ans = g;
ans.resize(n);
for (int i = 0; i < n - 1; i++) ans[i] = ans[i + 1] * Z(i + 1);
ans[n - 1] = 0;
return ans;
}
Poly Int(const Poly &g) {
using namespace Poly_fast;
const int n = curn ? curn : g.size() + 1;
Poly ans = g;
ans.resize(n);
if (limn <= n) prework(n + 1);
for (int i = n - 1; i >= 1; i--) ans[i] = ans[i - 1] * Z(inv[i]);
ans[0] = 0;
return ans;
}
Poly Inv(const Poly &g) { return g.inv(); }
Poly Ln(const Poly &g) {
using namespace Poly_fast;
const int n = curn ? curn : g.size();
int tmpg[n], tmpf[n];
fill(tmpg, tmpg + n, 0);
copy(g.a.begin(), min(g.a.begin() + n, g.a.end()), tmpg);
Ln(tmpf, tmpg, n);
Poly ans;
ans.resize(n);
copy(tmpf, tmpf + n, ans.a.begin());
return ans;
}
Poly Exp(const Poly &g) {
using namespace Poly_fast;
const int n = curn ? curn : g.size();
int tmpg[n], tmpf[n];
fill(tmpg, tmpg + n, 0);
copy(g.a.begin(), min(g.a.begin() + n, g.a.end()), tmpg);
Exp(tmpf, tmpg, n);
Poly ans;
ans.resize(n);
copy(tmpf, tmpf + n, ans.a.begin());
return ans;
}
Poly Pow(const Poly &g, const int &K) {
using namespace Poly_fast;
const int n = curn ? curn : g.size();
int tmpg[n], tmpf[n];
fill(tmpg, tmpg + n, 0);
copy(g.a.begin(), min(g.a.begin() + n, g.a.end()), tmpg);
Pow(tmpf, tmpg, n, K);
Poly ans;
ans.resize(n);
copy(tmpf, tmpf + n, ans.a.begin());
return ans;
}
Poly Sqrt(const Poly &g) {
using namespace Poly_fast;
const int n = curn ? curn : g.size();
int tmpg[n], tmpf[n];
fill(tmpg, tmpg + n, 0);
copy(g.a.begin(), min(g.a.begin() + n, g.a.end()), tmpg);
Sqrt(tmpf, tmpg, n);
Poly ans;
ans.resize(n);
copy(tmpf, tmpf + n, ans.a.begin());
return ans;
}
Poly Newton(int tn, Poly calc(const Poly &), Z f0) {
using namespace Poly_fast;
Poly f(f0);
for (int n = 1; n < tn; n <<= 1) {
setn(n << 1);
f -= calc(f);
}
f.resize(tn);
setn(0);
return f;
}
namespace Recursive {
void doublen(int a[], int b[], int l) {
using namespace Poly_fast;
copy(a, a + l, b);
IDFT(b, l);
for (int i = 0; i < l; i++) b[i] = 1ll * b[i] * w[l + i] % mod;
DFT(b, l);
for (int i = l - 1; i >= 0; i--) b[i << 1 | 1] = b[i];
for (int i = 0; i < l; i++) b[i << 1] = a[i];
}
int Liner(Poly Q, Poly a0, long long n) {
using namespace Poly_fast;
int K = Q.size();
int l = 1;
while (l <= K) l <<= 1;
const int len = l << 1;
int p[len], q[len], tmpp[len], tmpq[len];
for (int i = 1; i <= K; i++) q[i] = -Q[i - 1];
q[0] = 1;
for (int i = 0; i < K; i++) p[i] = a0[i];
mul(p, q, p, K);
copy(p, p + K, tmpp), fill(tmpp + K, tmpp + (l << 1), 0);
copy(q, q + K + 1, tmpq), fill(tmpq + K + 1, tmpq + (l << 1), 0);
int iw[len >> 1];
int omg = qpower(qpower(3, (mod - 1) / (l << 1)), mod - 2);
iw[0] = 1;
for (int i = 1; i < l; i++) iw[i] = 1ll * iw[i - 1] * omg % mod;
int is_first = 1;
while (n >= K) {
if (is_first) {
is_first = 0;
DFT(tmpp, l << 1), DFT(tmpq, l << 1);
} else {
doublen(p, tmpp, l), doublen(q, tmpq, l);
}
if (n & 1) {
int iv2 = (mod + 1) >> 1;
for (int i = 0; i < l; i++)
p[i] = (1ll * tmpp[i] * tmpq[i ^ l] +
1ll * (mod - tmpp[i ^ l]) * tmpq[i]) %
mod * iw[i] % mod * iv2 % mod;
} else {
int iv2 = (mod + 1) >> 1;
for (int i = 0; i < l; i++)
p[i] = (1ll * tmpp[i] * tmpq[i ^ l] + 1ll * tmpq[i] * tmpp[i ^ l]) %
mod * iv2 % mod;
}
for (int i = 0; i < l; i++) q[i] = 1ll * tmpq[i] * tmpq[i ^ l] % mod;
n >>= 1;
}
if (!is_first) {
IDFT(p, l), IDFT(q, l);
}
Inv(q, q, K);
mul(p, q, p, K);
return p[n];
}
Poly BM(Poly f) {
Poly ans, tans;
int tfail = 0;
Z delta, tdelta = 0;
for (int i = 0; i < f.size(); i++) {
delta = f[i];
for (int j = 0; j < ans.size(); j++) delta += -ans[j] * f[i - j - 1];
if (delta == Z(0)) continue;
if (!ans.size()) {
tfail = i;
tdelta = delta;
ans.resize(i + 1);
continue;
}
Poly tmp = ans;
if (ans.size() < i - tfail + tans.size())
ans.resize(i - tfail + tans.size());
Z t = delta / tdelta;
ans[i - tfail - 1] = qmod1(ans[i - tfail - 1] + t);
for (int j = 0; j < tans.size(); j++) ans[i - tfail + j] += -t * tans[j];
if (tmp.size() - i < tans.size() - tfail) {
tfail = i, tdelta = delta, tans = tmp;
}
}
return ans;
}
} // namespace Recursive
int n, tmp[20];
int main() {
int n = getin() / 2, K = getin();
Poly f;
f.resize(10);
for (int i = 1; i <= K; i++) tmp[i] = getin();
int mi = 10;
for (int i = 1; i <= K; i++) mi = min(mi, tmp[i]);
for (int i = 1; i <= K; i++) tmp[i] -= mi;
for (int i = 1; i <= K; i++) f[tmp[i]] = 1;
Poly_fast::setn(n * 9 + 1);
f = Pow(f, n);
Z ans = 0;
for (int i = 0; i <= n * 9; i++) ans += f[i] * f[i];
print(ans);
puts("");
}
| 2,400 | CPP |
for _ in range(int(input())):
n=int(input())
out=0
twop=1
while twop<=n:
if twop&n:
out+=twop*2-1
twop*=2
print(out)
| 1,400 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int D[N];
int main() {
int n;
scanf("%d", &n);
int pos = 1;
while (n--) {
int x, y;
scanf("%d%d", &x, &y);
int sum = 0, len = sqrt(x);
for (int i = 1; i <= len; i++) {
if (x % i == 0) {
if (D[i] < pos - y) sum++;
D[i] = pos;
if (i * i == x) continue;
if (D[x / i] < pos - y) sum++;
D[x / i] = pos;
}
}
pos++;
cout << sum << '\n';
}
}
| 1,900 | CPP |
# Maximum Increase
n = int(input())
li = list(map(int,input().split()))
c = 1
li1 = []
for i in range(len(li)-1):
if li[i]<li[i+1]:
c+=1
else:
li1.append(c)
c = 1
li1.append(c)
print(max(li1)) | 800 | PYTHON3 |
Subsets and Splits