solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<pair<int, string> > q;
vector<pair<int, int> > res;
scanf("%d", &n);
for (int i = 0, t; i < n; i++) {
string r;
cin >> r >> t;
q.push_back(make_pair(t, r));
}
sort(q.begin(), q.end());
int flag = 1;
res.push_back(make_pair(10000, 0));
q[0].first = 10000;
for (int i = 1; i < n; i++) {
if (q[i].first > res.size()) {
flag = 0;
break;
}
for (int j = q[i].first; j < res.size(); j++)
q[res[j].second].first++, res[j].first++;
if (q[i].first)
res.push_back(make_pair(res[q[i].first - 1].first + 1, i)),
q[i].first = res[q[i].first - 1].first + 1;
else
res.push_back(make_pair(res[0].first - 1, i)),
q[i].first = res[0].first - 1;
sort(res.begin(), res.end());
}
if (!flag)
puts("-1");
else {
for (int i = 0; i < n; i++)
cout << q[i].second << ' ' << 20000 - q[i].first << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e6 + 5;
int n, m;
vector<int> p, c;
struct Edge {
int to, nxt;
} e[MAX_N];
int cnt;
int head[MAX_N], tote;
void add_edge(int x, int y) {
e[++tote].to = y, e[tote].nxt = head[x];
head[x] = tote;
}
int dfn[MAX_N], low[MAX_N];
int idx;
int belong[MAX_N], scc;
int Stack[MAX_N], top;
bool in_stack[MAX_N];
void tarjan(int u) {
dfn[u] = low[u] = ++idx;
Stack[top++] = u;
in_stack[u] = true;
for (int i = head[u]; i; i = e[i].nxt) {
int to = e[i].to;
if (!dfn[to]) {
tarjan(to);
low[u] = min(low[u], low[to]);
} else if (in_stack[to])
low[u] = min(low[u], dfn[to]);
}
if (dfn[u] == low[u]) {
++scc;
do {
belong[Stack[--top]] = scc;
in_stack[Stack[top]] = false;
} while (Stack[top] != u);
}
}
void init(int n) {
for (register int i = 1; i <= n; i++)
dfn[i] = low[i] = belong[i] = in_stack[i] = head[i] = 0;
tote = idx = scc = top = 0;
p.clear(), c.clear();
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%d", &n), scanf("%d", &m);
init(2 * n);
for (register int i = 1; i <= m; i++) {
int u, v;
scanf("%d", &u), scanf("%d", &v);
if (u == v)
add_edge(u, v + n), add_edge(v + n, u);
else
add_edge(u, v + n);
}
for (register int i = 1; i <= 2 * n; i++)
if (!dfn[i]) tarjan(i);
if (scc == 1) {
puts("No");
continue;
}
puts("Yes");
for (register int i = 1; i <= n; i++) {
if (belong[i] == 1)
p.push_back(i);
else
c.push_back(i);
}
int lp = p.size(), lc = c.size();
printf("%d %d\n", lp, lc);
for (register int i = 0; i <= lp - 1; i++)
printf("%d%c", p[i], i == lp - 1 ? '\n' : ' ');
for (register int i = 0; i <= lc - 1; i++)
printf("%d%c", c[i], i == lc - 1 ? '\n' : ' ');
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline long long readint() {
long long x = 0;
bool f = 0;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') {
f = 1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return f ? -x : x;
}
const int maxn = 5e5 + 5, maxm = 2e5 + 5;
int n, m;
char s[maxn], t[maxm];
int nxt[maxm], ext[maxn];
const long long mod1 = 167772161, mod2 = 469762049, mod3 = 1004535809;
long long pw1[maxn], pw2[maxn], pw3[maxn];
long long hs1[maxn], hs2[maxn], hs3[maxn], x1 = 0, x2 = 0, x3 = 0;
long long hash1(int l, int r) {
return (hs1[r] - hs1[l - 1] * pw1[r - l + 1] % mod1 + mod1) % mod1;
}
long long hash2(int l, int r) {
return (hs2[r] - hs2[l - 1] * pw2[r - l + 1] % mod2 + mod2) % mod2;
}
long long hash3(int l, int r) {
return (hs3[r] - hs3[l - 1] * pw3[r - l + 1] % mod3 + mod3) % mod3;
}
int a[maxm];
void check(int l1, int r1, int l2, int r2) {
if ((hash1(l1, r1) + hash1(l2, r2)) % mod1 != x1) return;
if ((hash2(l1, r1) + hash2(l2, r2)) % mod2 != x2) return;
if ((hash3(l1, r1) + hash3(l2, r2)) % mod3 != x3) return;
memset(a, 0, sizeof(a));
for (int i = l1; i <= r1; i++) a[r1 - i] += s[i] - '0';
for (int i = l2; i <= r2; i++) a[r2 - i] += s[i] - '0';
int n = max(r1 - l1 + 1, r2 - l2 + 1);
for (int i = 0; i < n; i++)
if (a[i] > 10) {
a[i + 1]++;
a[i] -= 10;
}
if (a[n]) n++;
if (n != m) return;
for (int i = 0; i < n; i++)
if (a[i] != t[m - i] - '0') return;
printf("%d %d\n%d %d\n", l1, r1, l2, r2);
exit(0);
}
int main() {
scanf("%s%s", s + 1, t + 1);
n = strlen(s + 1);
m = strlen(t + 1);
int l = 0, r = 0;
nxt[1] = m;
for (int i = 2; i <= m; i++) {
if (i <= r) nxt[i] = min(nxt[i - l + 1], r - i + 1);
while (i + nxt[i] <= m && t[i + nxt[i]] == t[nxt[i] + 1]) nxt[i]++;
if (i + nxt[i] - 1 > r) {
l = i;
r = i + nxt[i] - 1;
}
}
l = r = 0;
for (int i = 1; i <= n; i++) {
if (i <= r) ext[i] = min(nxt[i - l + 1], r - i + 1);
while (i + ext[i] <= n && ext[i] < m && s[i + ext[i]] == t[ext[i] + 1])
ext[i]++;
if (i + ext[i] - 1 > r) {
l = i;
r = i + ext[i] - 1;
}
}
pw1[0] = pw2[0] = pw3[0] = 1;
for (int i = 1; i <= n; i++) {
pw1[i] = pw1[i - 1] * 10 % mod1;
pw2[i] = pw2[i - 1] * 10 % mod2;
pw3[i] = pw3[i - 1] * 10 % mod3;
}
for (int i = 1; i <= n; i++) {
hs1[i] = (hs1[i - 1] * 10 % mod1 + s[i] - '0') % mod1;
hs2[i] = (hs2[i - 1] * 10 % mod2 + s[i] - '0') % mod2;
hs3[i] = (hs3[i - 1] * 10 % mod3 + s[i] - '0') % mod3;
}
for (int i = 1; i <= m; i++) {
x1 = (x1 * 10 % mod1 + t[i] - '0') % mod1;
x2 = (x2 * 10 % mod2 + t[i] - '0') % mod2;
x3 = (x3 * 10 % mod3 + t[i] - '0') % mod3;
}
if (m > 1)
for (int i = 1; i + m * 2 - 3 <= n; i++)
check(i, i + m - 2, i + m - 1, i + m * 2 - 3);
for (int i = 1; i + m - 1 <= n; i++) {
if (m > ext[i] && i + m * 2 - ext[i] - 1 <= n)
check(i, i + m - 1, i + m, i + m * 2 - ext[i] - 1);
if (m > ext[i] + 1 && i + m * 2 - ext[i] - 2 <= n)
check(i, i + m - 1, i + m, i + m * 2 - ext[i] - 2);
if (m > ext[i] && i > m - ext[i])
check(i - m + ext[i], i - 1, i, i + m - 1);
if (m > ext[i] + 1 && i > m - ext[i] - 1)
check(i - m + ext[i] + 1, i - 1, i, i + m - 1);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e3 + 5;
int N, M, SA, SB, ans;
int P[MAXN];
int H[MAXN];
int DP[MAXN][3 * MAXN];
int PD[MAXN][3 * MAXN];
vector<int> A, B;
vector<int> V[MAXN];
set<int> S;
const long long MOD = 1e9 + 7, D = (1LL << 61) / MOD;
inline int add(int a) { return a < MOD ? a : a - MOD; }
inline int sub(int a) { return a < 0 ? a + MOD : a; }
inline int mul(long long a) { return add(a - MOD * ((a >> 29) * D >> 32)); }
int expo(long long a, int b) {
return b ? b & 1 ? mul(a * expo(mul(a * a), b >> 1))
: expo(mul(a * a), b >> 1)
: 1;
}
inline int div(int a) { return expo(a, MOD - 2); }
void input() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
int X, Y;
cin >> X >> Y;
V[X].push_back(Y);
V[Y].push_back(X);
}
for (int X : V[1]) {
int Y = 1, H = 1;
while (X != 1) {
Y = V[X][0] + V[X][1] - Y;
swap(X, Y);
H++;
}
B.push_back(H);
}
}
void debug() {
cin >> N;
for (int i = 0; i < N; i++) {
cin >> M;
B.push_back(M);
B.push_back(M);
}
}
int main() {
input();
sort(B.begin(), B.end());
for (int i = 0; i < B.size(); i += 2) {
if (S.count(B[i])) {
A.push_back(B[i]);
} else {
S.insert(B[i]);
}
}
SA = A.size();
for (int x : S) {
A.push_back(x);
}
SB = A.size();
DP[0][0] = 1;
for (int i = 0; i < SB; i++) {
P[i + 1] = P[i] + A[i];
for (int j = 0; j <= P[i + 1]; j++) {
DP[i + 1][j] =
add(DP[i][j > A[i] ? j - A[i] : A[i] - j] + DP[i][j + A[i]]);
PD[i + 1][j] = add(
add(DP[i][j > A[i] ? j - A[i] : A[i] - j] + PD[i][j + A[i]]) +
(j >= A[i]
? PD[i][j - A[i]]
: sub(mul((long long)i * DP[i][A[i] - j]) - PD[i][A[i] - j])));
}
}
ans = add(DP[SB][0] + add(add(PD[SB][1] << 1) << 1));
for (int i = 0; i < SB; i++) {
for (int j = 0; j <= P[i + 1]; j++) {
DP[i + 1][j] = add(DP[i][j] + add(DP[i][j > A[i] ? j - A[i] : A[i] - j] +
DP[i][j + A[i]]));
}
}
for (int h = SB - 1; h >= SA; h--) {
for (int i = h + 1; i < SB; i++) {
for (int j = 0; j <= P[i + 1]; j++) {
DP[i][j] =
add(DP[i - 1][j] + add(DP[i - 1][j > A[i] ? j - A[i] : A[i] - j] +
DP[i - 1][j + A[i]]));
}
}
for (int i = 1; i < A[h] - 1; i++) {
H[A[h]] = add(H[A[h]] + DP[SB - 1][i]);
}
H[A[h]] = add(H[A[h]] << 1);
H[A[h]] = add(H[A[h]] + DP[SB - 1][0]);
H[A[h]] = add(H[A[h]] << 1);
}
for (int i = 0; i < SB; i++) {
ans = add(ans + H[A[i]]);
}
cout << ans << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 10050;
long long l, n;
long long g, r;
long long visited[maxn][1010];
pair<long long, long long> cango[maxn];
vector<long long> v;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> l >> n;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
v.push_back(x);
}
cin >> g >> r;
sort(v.begin(), v.end());
for (long long i = 0; i < (long long)v.size(); i++) {
if (i != 0) cango[i + 1].first = v[i] - v[i - 1];
if (i != (long long)v.size() - 1) cango[i + 1].second = v[i + 1] - v[i];
}
deque<pair<long long, pair<long long, long long> > > q;
q.push_back(pair<long long, pair<long long, long long> >(
0, pair<long long, long long>(1, g)));
visited[1][g] = 1;
long long ans = LLONG_MAX / 2;
while (!q.empty()) {
pair<long long, pair<long long, long long> > cur = q.front();
q.pop_front();
long long x = cur.second.first, t = cur.second.second, d = cur.first;
if (x == n) {
if (t == g) d -= r;
ans = min(ans, d);
continue;
}
long long newd, newt;
if (x != 1) {
newt = t - cango[x].first, newd = d + cango[x].first;
if (newt == 0 and !visited[x - 1][g]) {
visited[x - 1][g] = 1;
newd += r;
q.push_back(pair<long long, pair<long long, long long> >(
newd, pair<long long, long long>(x - 1, g)));
} else if (newt > 0 and !visited[x - 1][newt]) {
visited[x - 1][newt] = 1;
q.push_front(pair<long long, pair<long long, long long> >(
newd, pair<long long, long long>(x - 1, newt)));
}
}
newd = d + cango[x].second;
newt = t - cango[x].second;
if (newt == 0 and !visited[x + 1][g]) {
visited[x + 1][g] = 1;
newd += r;
q.push_back(pair<long long, pair<long long, long long> >(
newd, pair<long long, long long>(x + 1, g)));
} else if (newt > 0 and !visited[x + 1][newt]) {
visited[x + 1][newt] = 1;
q.push_front(pair<long long, pair<long long, long long> >(
newd, pair<long long, long long>(x + 1, newt)));
}
}
if (ans == LLONG_MAX / 2)
cout << -1;
else
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
set<long long> seen;
bool ask(long long cur) {
seen.insert(cur);
cout << "? " << cur << endl;
int ret;
cin >> ret;
return ret;
}
void print(long long C) { cout << "= " << C << endl; }
long long n;
bool test(long long &on, long long &av, long long &ok, long long ¬_ok) {
if (1 > av || av > n) return 0;
if (on + av <= n && seen.count(on + av) == 0) {
long long help = on + av;
on = help;
if (ask(help) == 0)
ok = max(ok, av);
else
not_ok = min(not_ok, av);
return 1;
} else if (on - av >= 1 && seen.count(on - av) == 0) {
long long help = on - av;
on = help;
if (ask(help) == 0)
ok = max(ok, av);
else
not_ok = min(not_ok, av);
return 1;
}
return 0;
}
void solve() {
seen = {};
cin >> n;
if (n == 1) {
print(1);
return;
}
vector<long long> would_be = {};
long long ok = 0, not_ok = n;
while (not_ok - ok > 1) {
long long av = (ok + not_ok) / 2;
would_be.push_back(av);
ok = av;
}
reverse(would_be.begin(), would_be.end());
vector<long long> order = {n};
long long cur = n;
int mult = -1;
for (auto k : would_be) {
cur += mult * k;
order.push_back(cur);
mult = -mult;
}
reverse(order.begin(), order.end());
ok = 0, not_ok = n + 1;
ask(order[0]);
int wrong = -1;
long long on;
for (int i = 1; i < order.size(); i++) {
if (ask(order[i]) == 0)
ok = abs(order[i] - order[i - 1]);
else {
not_ok = abs(order[i] - order[i - 1]);
wrong = i;
on = order[i];
break;
}
}
if (wrong == -1) {
print(n);
return;
}
while (not_ok - ok > 1) {
long long av = (ok + not_ok) / 2;
if (test(on, av, ok, not_ok) == 0) {
for (int diff = 0; true; diff++) {
long long av_now = av + diff;
if (test(on, av_now, ok, not_ok)) break;
av_now = av - diff;
if (test(on, av_now, ok, not_ok)) break;
}
}
}
print(ok + 1);
}
int main() {
int t;
cin >> t;
while (t) {
t--;
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
enum { MOD0 = 1000000000, MOD7 = 1000000007, MOD9 = 1000000009 };
template <typename T>
ostream &operator<<(ostream &cout, vector<T> &a) {
for (size_t i = 0; i < a.size(); ++i) cout << a[i] << " ";
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, vector<vector<T> > &a) {
for (size_t i = 0; i < a.size(); ++i) cout << a[i] << endl;
return cout;
}
int p[256];
inline bool eq(int a, int b) { return p[a] == p[b]; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
for (int i = 0; i < sizeof(p) / sizeof(*p); ++i) {
p[i] = i;
}
p['1'] = p['i'] = p['l'];
p['0'] = p['o'];
for (int i = 'A'; i <= 'Z'; ++i) {
p[i] = p[i - 'A' + 'a'];
}
string s;
cin >> s;
int n;
cin >> n;
string a;
for (int i = 0; i < n; ++i) {
cin >> a;
if (a.size() != s.size()) {
continue;
}
bool bad = 1;
for (int j = 0; j < a.size(); ++j) {
if (!eq(a[j], s[j])) {
bad = 0;
break;
}
}
if (bad) {
cout << "No" << '\n';
return 0;
}
}
cout << "Yes" << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s, t;
int main() {
cin >> n >> t >> s;
queue<int> q;
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) {
bool found = false;
for (int j = i + 1; j < n; j++) {
if (s[i] == t[j]) {
for (int k = j - 1; k >= i; k--) {
q.push(k + 1);
swap(t[k], t[k + 1]);
}
found = true;
break;
}
}
if (!found) {
cout << -1;
return 0;
}
}
}
cout << q.size() << endl;
if (!q.empty()) {
cout << q.front();
q.pop();
}
while (!q.empty()) {
cout << ' ' << q.front();
q.pop();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool isp2(int n) {
while (n % 2 == 0) n /= 2;
return n == 1;
}
int maxk(int n) { return (n - 3) / 2; }
bool ok(int n, int k) {
if (n < 0 || k < 0 || n % 2 == 0) return false;
if (k == 0) {
return isp2(n + 1);
}
if (k == 1) {
return !isp2(n + 1);
}
return k <= maxk(n) && !((n == 7 && k == 1) || (n == 9 && k == 2));
}
pair<int, int> getl(int n, int k) {
for (int l = 1; l <= min(11, n / 2); l += 2) {
int r = n - 1 - l;
int add = 2 * l <= r;
int sum = k - add;
for (int k1 = 0; k1 <= maxk(l); ++k1) {
if (ok(l, k1) && ok(r, sum - k1)) {
return pair<int, int>(l, k1);
}
}
}
for (int l2 = 1; l2 < n; l2 = 2 * l2 + 1) {
int r = n - 1 - l2;
int add = 2 * min(l2, r) <= max(l2, r);
int sum = k - add;
if (ok(r, sum)) {
if (l2 <= r)
return pair<int, int>(l2, 0);
else
return pair<int, int>(r, sum);
}
}
int l = n / 2, r = n - l - 1;
int add = 2 * l <= r;
int sum = k - add;
int k1 = min(maxk(l), sum - 1);
return pair<int, int>(l, k1);
}
void solve(vector<int>& v, int s0, int n, int k, int pr) {
v[s0] = pr;
if (n == 1) {
return;
}
assert(ok(n, k));
pair<int, int> p = getl(n, k);
int l = p.first, kl = p.second;
int r = n - 1 - l;
int add = 2 * l <= r;
int kr = k - kl - add;
solve(v, s0 + 1, l, kl, s0 + 1);
solve(v, s0 + 1 + l, r, kr, s0 + 1);
}
void solve(int n, int k) {
if (!ok(n, k)) {
cout << "NO\n";
return;
}
if (k == 0) {
if (isp2(n + 1)) {
cout << "YES\n";
for (int i = 0; i < n; ++i) cout << (i + 1) / 2 << ' ';
cout << endl;
} else {
cout << "NO\n";
}
return;
}
vector<int> s(n);
solve(s, 0, n, k, 0);
cout << "YES\n";
for (int x : s) cout << x << ' ';
cout << endl;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
if (0)
for (int n = 1; n < 1000; ++n)
for (int k = 0; k < 1000; ++k) {
cerr << n << ' ' << k << endl;
solve(n, k);
}
int n, k;
cin >> n >> k;
solve(n, k);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline void pi(int x) {
if (x == 0) {
putchar('0');
return;
}
char c[10];
int k = 0;
if (x < 0) {
putchar('-');
x = -x;
}
while (x) {
int nx = x / 10;
c[k++] = x - nx * 10;
x = nx;
}
while (k--) {
putchar(c[k] + '0');
}
}
inline void pin(const int& x) {
pi(x);
putchar('\n');
};
inline void pl(long long x) {
if (x == 0) {
putchar('0');
return;
}
char c[19];
int k = 0;
if (x < 0) {
putchar('-');
x = -x;
}
while (x) {
long long nx = x / 10;
c[k++] = x - nx * 10;
x = nx;
}
while (k--) {
putchar(c[k] + '0');
}
}
inline void pln(const long long& x) {
pl(x);
putchar('\n');
};
inline void gi(int& val) {
val = 1;
char c;
do {
c = getchar();
} while (c != '-' && (c < '0' || c > '9'));
int zn = 1;
if (c == '-') {
zn = -1;
c = getchar();
}
val = c - '0';
c = getchar();
while (c >= '0' && c <= '9') {
val *= 10;
val += c - '0';
c = getchar();
}
val *= zn;
}
inline void gl(long long& val) {
val = 1;
char c;
do {
c = getchar();
} while (c != '-' && (c < '0' || c > '9'));
int zn = 1;
if (c == '-') {
zn = -1;
c = getchar();
}
val = c - '0';
c = getchar();
while (c >= '0' && c <= '9') {
val *= 10;
val += c - '0';
c = getchar();
}
val *= zn;
}
inline void gl(long long& val1, long long& val2) {
gl(val1);
gl(val2);
}
inline void gi(int& val1, int& val2) {
gi(val1);
gi(val2);
}
inline void gl(long long& val1, long long& val2, long long& val3) {
gl(val1);
gl(val2);
gl(val3);
}
inline void gi(int& val1, int& val2, int& val3) {
gi(val1);
gi(val2);
gi(val3);
}
inline void mygets(char* b) {
int i = 0;
for (;; ++i) {
const char c = getchar();
if (c == '\n' || c == EOF) {
break;
}
b[i] = c;
}
b[i] = '\0';
}
inline void mygets(string& b) {
int i = 0;
for (;; ++i) {
const char c = getchar();
if (c == '\n' || c == EOF) {
break;
}
b.push_back(c);
}
}
inline void mygets(char& b) {
b = getchar();
getchar();
}
inline void myputs(const string& b) {
for (int i = 0; i < b.size(); ++i) {
putchar(b[i]);
}
}
inline void putsn(const string& b) {
myputs(b);
putchar('\n');
}
inline void myputs(const char& b) { putchar(b); }
inline void putsn(const char& b) {
putchar(b);
putchar('\n');
}
const int N = 1e6 + 7, M = 150000, mod = 1000000007, inf = 1000000007;
const long long lmod = 1000000007, linf = 1e18 + 77;
const long double eps = 1e-14;
vector<int> a;
bool used[N];
map<int, int> f;
int main() {
srand(time(0));
ios_base::sync_with_stdio(false);
int n, k;
gi(n, k);
queue<int> q;
for (int i = -1000; i <= 1000; i++) {
f[i] = inf;
}
for (int i = 0; i < k; i++) {
int x;
gi(x);
if (!used[x]) {
a.push_back(x - n);
q.push(x - n);
f[x - n] = 1;
used[x] = 1;
}
}
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto i : a) {
int to = v + i;
if (f[to] == inf) {
f[to] = f[v] + 1;
q.push(to);
}
}
}
if (f[0] == inf) {
pin(-1);
} else {
pin(f[0]);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long int n;
cin >> n;
long long int a[n][n];
long long int i, j, x = 0;
for (i = 0; i < n / 2; i++) {
for (j = 0; j < n / 2; j++) {
a[i][j] = 4 * x;
a[i + n / 2][j] = (4 * x) + 2;
a[i][j + n / 2] = (4 * x) + 1;
a[i + n / 2][j + n / 2] = (4 * x) + 3;
x++;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
cout << a[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
const long long LINF = 1LL * INF * INF;
const int MAX = 507;
const double PI = acos(-1.);
const double EPS = 1e-8;
const int MOD = 998244353;
long long a[MAX];
long long isSquare(long long x) {
long long L = 1;
long long R = 1.1 * sqrt(1.0 * x);
while (R - L > 1) {
long long X = (L + R) / 2;
if (X * X > x) {
R = X;
} else {
L = X;
}
}
if (L * L == x) return L;
if (R * R == x) return R;
return -1;
}
long long isCube(long long x) {
long long L = 1;
long long R = 1.1 * pow(x, 1.0 / 3);
while (R - L > 1) {
long long X = (L + R) / 2;
if (X * X * X > x) {
R = X;
} else {
L = X;
}
}
if (L * L * L == x) return L;
if (R * R * R == x) return R;
return -1;
}
long long isForth(long long x) {
long long L = 1;
long long R = 1.1 * pow(x, 1.0 / 4);
while (R - L > 1) {
long long X = (L + R) / 2;
if (X * X * X * X > x) {
R = X;
} else {
L = X;
}
}
if (L * L * L * L == x) return L;
if (R * R * R * R == x) return R;
return -1;
}
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
map<long long, int> M;
map<long long, int> HZ;
for (int i = 0; i < n; ++i) {
long long v = isForth(a[i]);
if (v != -1) {
M[v] += 4;
continue;
}
v = isCube(a[i]);
if (v != -1) {
M[v] += 3;
continue;
}
v = isSquare(a[i]);
if (v != -1) {
M[v] += 2;
continue;
}
bool ok = false;
for (int j = 0; j < n; ++j) {
long long g = gcd(a[i], a[j]);
if (g > 1 && g < a[i]) {
M[g]++;
M[a[i] / g]++;
ok = true;
break;
}
}
if (!ok) HZ[a[i]]++;
}
long long res = 1;
for (auto it = M.begin(); it != M.end(); ++it) {
res *= (it->second + 1);
res %= MOD;
}
for (auto it = HZ.begin(); it != HZ.end(); ++it) {
res *= (it->second + 1) * (it->second + 1);
res %= MOD;
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, ni, sz[400005], mx[400005], lbl[400005], sz2[400005], ct;
int ans[400005];
int gt[400005], st[400005];
vector<int> V[400005];
void fct(int id, int pv) {
sz[id] = 1;
for (int i = (0); i <= ((int)V[id].size() - 1); i++) {
int to = V[id][i];
if (to == pv) continue;
fct(to, id);
sz[id] += sz[to];
mx[id] = max(mx[id], sz[to]);
}
if (mx[id] <= ni && n - sz[id] <= ni) {
ct = id;
ans[id] = 1;
}
return;
}
void dfs(int id, int pv) {
sz[id] = 1;
for (int i = (0); i <= ((int)V[id].size() - 1); i++) {
int to = V[id][i];
if (to == pv) continue;
dfs(to, id);
sz[id] += sz[to];
if (sz[to] > sz[gt[id]]) {
st[id] = gt[id];
gt[id] = to;
} else if (sz[to] > sz[st[id]])
st[id] = to;
}
return;
}
void dfs2(int id, int pv, int sel) {
if (pv)
if (n - sz[id] - sel <= ni) ans[id] = 1;
for (int i = (0); i <= ((int)V[id].size() - 1); i++) {
int to = V[id][i];
if (to == pv) continue;
int o = sel;
if (to == gt[id])
o = max(o, sz[st[id]]);
else
o = max(o, sz[gt[id]]);
if (n - sz[to] <= ni) o = max(o, n - sz[to]);
dfs2(to, id, o);
}
return;
}
int main() {
scanf("%d", &n);
ni = n / 2;
for (int i = (2); i <= (n); i++) {
int a, b;
scanf("%d %d", &a, &b);
V[a].push_back(b);
V[b].push_back(a);
}
fct(1, 0);
dfs(ct, 0);
dfs2(ct, 0, 0);
for (int i = (1); i <= (n); i++) printf("%d%c", ans[i], i == n ? '\n' : ' ');
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, s, x, y, i, cnt, mem;
int tab[3][100001];
char znak;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> s;
for (int a = 1; a <= n; a++) {
cin >> znak >> x >> y;
if (znak == 'B')
i = 1;
else
i = 2;
tab[i][x] += y;
}
for (int a = 0; a <= 100000; a++) {
if (tab[2][a] && cnt < s) {
mem = a;
cnt++;
}
}
for (; mem >= 0; mem--) {
if (tab[2][mem]) cout << "S " << mem << " " << tab[2][mem] << endl;
}
cnt = 0;
for (int a = 100000; a >= 0; a--) {
if (tab[1][a] && cnt < s) {
cout << "B " << a << " " << tab[1][a] << endl;
cnt++;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long n, m;
cin >> n >> m;
vector<long long> dp(n + 1, 0);
dp[1] = 1;
dp[2] = 2;
for (int j = 4; j <= n; j += 2) dp[j] = (dp[j] + 1) % m;
for (int i = 3; i <= n; i++) {
dp[i] = (dp[i] + 2 * dp[i - 1] + 1) % m;
for (int j = 2 * i; j <= n; j += i) {
long long inc = dp[i] - dp[i - 1];
while (inc < 0) inc += m;
dp[j] = (dp[j] + inc) % m;
}
}
cout << dp[n] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long n, k, d;
cin >> n >> k >> d;
multiset<long long> inA;
multiset<long long, greater<long long>> inB;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
inA.insert(x);
inB.insert(x);
}
{
vector<long long> minValue;
vector<long long> count;
long long last = -10000000000000ll;
while (true) {
auto it = inA.upper_bound(last + d);
if (it == inA.end()) break;
last = *it;
minValue.push_back(*it);
count.push_back(1);
inA.erase(it);
}
for (long long i = 0; i < minValue.size(); i++) {
while (count[i] < k) {
auto it = inA.lower_bound(minValue[i] - d);
if (it == inA.end() || abs(*it - minValue[i]) > d) {
cout << "NO" << endl;
return 0;
}
inA.erase(it);
count[i]++;
}
}
}
{
vector<long long> minValue;
vector<long long> count;
long long last = 10000000000000ll;
while (true) {
auto it = inB.upper_bound(last - d);
if (it == inB.end()) break;
last = *it;
minValue.push_back(*it);
count.push_back(1);
inB.erase(it);
}
for (long long i = 0; i < minValue.size(); i++) {
while (count[i] < k) {
auto it = inB.lower_bound(minValue[i] + d);
if (it == inB.end() || abs(*it - minValue[i]) > d) {
cout << "NO" << endl;
return 0;
}
inB.erase(it);
count[i]++;
}
}
}
cout << "YES" << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long Low[25][25], Up[25][25], Dig[25], Ans, L, R, V3[25];
long long D[25], Nb[25];
set<int> S;
int f;
long long aux = 0;
long long Power[25];
int V2[30];
long long aux2;
bool Solve(long long x) {
int cnt = 0;
if (x == 0) return 0;
if (x == 1 && R == 1000000000000000000) return 1;
if (x > R) return 0;
cnt = 18;
for (int i = 0; i < 10; i++) V2[i] = V3[i];
long long nb = 0, nb2 = 0;
int last = -1;
int Max = 9;
while (Max >= 0 && V2[Max] == 0) --Max;
if (Max > D[1]) last = 0;
for (int i = 1; i <= 18; i++) {
bool ok = 1;
nb2 = 0;
V2[D[i]]--;
if (V2[D[i]] < 0) break;
Nb[i] = Nb[i - 1] * 10 + D[i];
if (D[i] == Max && V2[D[i]] == 0)
while (Max >= 0 && V2[Max] == 0) --Max;
ok = 0;
if (Max >= D[i + 1] + 1) ok = 1;
if (ok == 1) last = i;
}
if (last == -1) return 0;
for (int i = 0; i < 10; i++) V2[i] = V3[i];
for (int j = 1; j <= last; j++) V2[D[j]]--, nb = nb * 10 + D[j];
for (int k = D[last + 1] + 1; k < 10; k++)
if (V2[k] > 0) {
V2[k]--;
nb = nb * 10 + k;
break;
}
for (int i = 0; i <= 9; i++) {
for (int k = 1; k <= V2[i]; k++) nb = nb * 10 + i;
V2[i] = V3[i];
}
if (nb <= R) return 1;
return 0;
}
void fillV(int pos, int prev) {
if (pos == 0) {
Ans += Solve(aux);
return;
}
for (int i = prev; i <= 9; i++) {
aux += Power[pos - 1] * i;
V2[i]++;
V3[i]++;
fillV(pos - 1, i);
V2[i]--;
V3[i]--;
aux -= Power[pos - 1] * i;
}
}
int main() {
Power[0] = 1;
for (int i = 1; i <= 18; i++) Power[i] = Power[i - 1] * 10LL;
cin >> L >> R;
--L;
long long x = L;
int cnt = 0;
for (int i = 1; i <= 18; i++) D[i] = 0;
while (x > 0) {
D[++cnt] = x % 10;
x /= 10;
}
cnt = 18;
reverse(D + 1, D + cnt + 1);
f = 18;
for (int i = 1; i <= 18; i++)
if (D[i] != 0) {
f = i;
break;
}
fillV(18, 0);
cout << Ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int fin = 0, maxn = 200010, MC = 1000000009;
int N, M;
int p[maxn];
inline int getf(int x) {
return p[x] = (p[x] != x && p[p[x]] != p[x]) ? getf(p[x]) : p[x];
}
int main() {
if (fin) {
freopen("t.in", "r", stdin);
freopen("t.out", "w", stdout);
}
int ans = 1, x, y, i;
scanf("%d%d", &N, &M);
for (i = 1; i <= N; ++i) p[i] = i;
while (M--) {
scanf("%d%d", &x, &y);
if (getf(x) == getf(y))
ans = (ans << 1) % MC;
else
p[getf(y)] = getf(x);
printf("%d\n", ans ? ans - 1 : MC);
}
if (fin) {
fclose(stdin);
fclose(stdout);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int Inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
int n;
int a[1 << 19];
int cnt[1 << 19];
unsigned long long ha[1 << 19], hs[1 << 19];
mt19937_64 Rand;
int main() {
scanf("%d", &n);
for (int i = 1; i <= (n); i++) scanf("%d", a + i);
for (int i = 0; i < (1 << 19); i++) ha[i] = Rand();
for (int i = 1; i <= (n); i++) {
hs[i] = hs[i - 1];
hs[i] -= ha[a[i]] * cnt[a[i]];
cnt[a[i]] = (cnt[a[i]] + 1) % 3;
hs[i] += ha[a[i]] * cnt[a[i]];
}
memset(cnt, 0, sizeof(cnt));
cnt[0] = 1;
map<unsigned long long, int> cs;
int r = 0;
long long ans = 0;
cs[0]++;
for (int i = 0; i < (n); i++) {
cnt[a[i]]--, cs[hs[i]]--;
while (r < n && cnt[a[r + 1]] < 3) {
r++;
cnt[a[r]]++;
cs[hs[r]]++;
}
ans += cs[hs[i]];
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int flag[100004];
int input[100004];
int main() {
int n, k;
while (cin >> n >> k) {
memset(flag, 0, sizeof(flag));
int i;
for (i = 0; i < n; i++) {
scanf("%d", &input[i]);
}
int l = 0;
int r = 0;
int t = 0;
while (t < k) {
if (r >= n) break;
if (flag[input[r]] == 0) t++;
flag[input[r]]++;
r++;
}
while (l < r) {
if (flag[input[l]] > 1)
flag[input[l++]]--;
else
break;
}
if (t < k)
cout << -1 << " " << -1 << endl;
else
cout << l + 1 << " " << r << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s, c, t = 0, fr = 0;
cin >> s >> c;
int arr[5010];
int b[5010];
int col[5010];
int co = 1;
int r = 0;
for (int i = 0; i < s; i++) {
cin >> arr[i];
}
for (int i = 0; i < s; i++) {
int j;
for (j = 0; j < i; j++)
if (arr[i] == arr[j]) break;
if (i == j) {
b[r] = arr[i];
r++;
}
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < s; j++) {
if (b[i] == arr[j]) {
t++;
}
}
if (t >= fr) {
fr = t;
}
t = 0;
}
if (fr <= c) {
cout << "YES" << endl;
for (int i = 0; i < r; i++) {
for (int j = 0; j < s; j++) {
if (b[i] == arr[j]) {
col[j] = co;
co = (co + 1) % (c + 1);
if (co == 0) {
co = 1;
}
}
}
}
for (int i = 0; i < s; i++) {
cout << col[i] << " ";
}
} else {
cout << "NO" << endl;
}
}
| 3 |
#include <bits/stdc++.h>
int main(void) {
int a, b, k, v;
int sections, maxSections, box = 0;
scanf("%d%d%d%d", &k, &a, &b, &v);
sections = (a % v == 0) ? (a / v) : (a / v + 1);
while (sections > 0) {
if (b > 0) {
maxSections = ((k <= b + 1) ? k : b + 1);
sections = sections - maxSections;
box++;
b = b - (maxSections - 1);
} else {
box = box + sections;
sections = 0;
}
}
printf("%d\n", box);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n;
cin >> n;
int ans;
if (n % 2 != 0) {
int x = (n + 1) / 2;
cout << x << '\n';
int r = 1;
int j = 1;
for (int i = 1; i <= n; i++) {
if (i < (n + 1) / 2)
cout << r << ' ' << i << '\n';
else {
cout << x << ' ' << j << '\n';
j++;
}
}
} else {
int x = (n / 2) + 1;
cout << x << '\n';
int r = 1;
int j = 1;
for (int i = 1; i <= n; i++) {
if (i <= (n / 2))
cout << r << ' ' << i << '\n';
else {
cout << x << ' ' << j << '\n';
j++;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, A, B, C, T;
cin >> n >> A >> B >> C >> T;
long long int res = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
res += A;
if (C - B > 0) res += 1LL * (C - B) * (T - x);
}
cout << res;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n1, n2, k1, k2;
cin >> n1 >> n2 >> k1 >> k2;
if (n1 > n2) {
cout << "First";
return 0;
}
if (n2 > n1) {
cout << "Second";
return 0;
}
if (n1 == n2) {
cout << "Second";
return 0;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
struct item {
int key, prior, val, mn, add;
item *l, *r;
item() {}
item(int key, int prior) : key(key), prior(prior), l(NULL), r(NULL) {}
};
typedef item *pitem;
inline void upd(pitem v) {
if (!v) return;
v->mn = v->val;
if (v->l) v->mn = min(v->mn, v->l->mn);
if (v->r) v->mn = min(v->mn, v->r->mn);
}
inline void push(pitem v) {
if (!v || !v->add) return;
if (v->l) v->l->add += v->add;
if (v->r) v->r->add += v->add;
v->key += v->add;
v->add = 0;
}
void split(pitem t, int key, pitem &l, pitem &r) {
push(t);
if (!t)
l = r = NULL;
else if (key <= t->key)
split(t->l, key, l, t->l), r = t, upd(r), upd(l);
else
split(t->r, key, t->r, r), l = t, upd(l), upd(l);
}
void merge(pitem &t, pitem l, pitem r) {
push(l);
push(r);
if (!l || !r)
t = l ? l : r, upd(t);
else if (l->prior > r->prior)
merge(l->r, l->r, r), t = l, upd(t);
else
merge(r->l, l, r->l), t = r, upd(t);
}
int a, b, c, d, i, j, n, m, k, g, r, tc, mod;
int mas[100003];
long long ds[100003], cs[100003];
item tr[110003];
inline pitem create() {
pitem v = &tr[tc++];
v->prior = (rand() << 15) + rand();
return v;
}
inline void shift(pitem &root, int val) {
if (!val) return;
pitem v1 = 0, v2 = 0;
split(root, mod - val, v1, v2);
if (v1) {
v1->add += val;
push(v1);
}
if (v2) {
v2->add += val - mod;
push(v2);
}
merge(root, v2, v1);
}
int main() {
srand(25091992);
scanf("%d%d%d", &n, &g, &r);
mod = g + r;
for (int _n((n + 1) - 1), i(0); i <= _n; i++) {
scanf("%d", &mas[i]);
cs[i] = mas[i];
if (i) cs[i] += cs[i - 1];
}
ds[n + 1] = 0;
pitem root = create();
root->val = n + 1;
root->mn = n + 1;
root->key = 0;
for (int i = (n), _b = (0); i >= _b; i--) {
shift(root, mas[i] % mod);
pitem v1 = 0, v2 = 0;
split(root, g, v1, v2);
int mnum = n + 1;
push(v2);
if (v2) mnum = v2->mn;
merge(root, v1, v2);
ds[i] = cs[mnum - 1];
if (i) ds[i] -= cs[i - 1];
if (mnum != n + 1) {
int t = ds[i] % mod;
ds[i] += mod - t;
ds[i] += ds[mnum];
}
if (i) {
pitem cur = create();
cur->val = i;
cur->mn = i;
cur->key = 0;
merge(root, cur, root);
}
}
int pr = 0;
scanf("%d", &m);
for (int _n((m)-1), i(0); i <= _n; i++) {
scanf("%d", &a);
b = a;
a %= mod;
int add = a - pr;
if (add < 0) add += mod;
shift(root, add);
pitem v1 = 0, v2 = 0;
split(root, g, v1, v2);
int mnum = n + 1;
push(v2);
if (v2) mnum = v2->mn;
merge(root, v1, v2);
long long ans = cs[mnum - 1];
if (mnum != n + 1) {
int t = (a + ans) % mod;
ans += mod - t;
ans += ds[mnum];
}
printf("%I64d\n", b + ans);
pr = a;
}
}
| 10 |
#include <bits/stdc++.h>
const int OO = 1e9;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
bool b[95] = {0};
for (int i = (0); i < (int)(n); ++i) {
int t;
cin >> t;
b[t] = 1;
}
int i = 1, res, it = 1;
while (1) {
if (i > 90) break;
if (b[i])
it = 1;
else
it++;
res = i;
if (it > 15) break;
i++;
}
cout << res;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, x1, y, z, d, x;
long long gcd(long long u, long long v) { return v ? gcd(v, u % v) : u; }
int main() {
cin >> n >> m;
cin >> x;
for (i = 2; i <= n; i++) cin >> y, d = gcd(y - x, d);
for (i = 1; i <= m; i++) {
cin >> x1;
if (d % x1 == 0) {
cout << "YES" << endl;
cout << x << " " << i;
return 0;
}
}
cout << "NO";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int n, m, nowx, nowy, ansa[20005], ansb[20005], ansc[20005], cnt, mp[5][20005],
OK;
void add(int a, int b, int c) {
ansa[++cnt] = a;
ansb[cnt] = b;
ansc[cnt] = c;
}
pair<int, int> lst(int x, int y) {
if (x == 2) return make_pair(2 + (y == n), (y == n) ? n : (y + 1));
if (x == 3) return make_pair(3 - (y == 1), (y == 1) ? 1 : (y - 1));
}
pair<int, int> nxt(int x, int y) {
if (x == 2) return make_pair(2 + (y == 1), (y == 1) ? 1 : (y - 1));
if (x == 3) return make_pair(3 - (y == n), (y == n) ? n : (y + 1));
}
void Go() {
for (int i = 1; i <= n; i++) {
if (mp[1][i] == mp[2][i] && mp[2][i] != 0)
add(mp[2][i], 1, i), mp[2][i] = 0, OK++;
if (mp[3][i] == mp[4][i] && mp[3][i] != 0)
add(mp[3][i], 4, i), mp[3][i] = 0, OK++;
}
}
void move() {
int Px = lst(nowx, nowy).first, Py = lst(nowx, nowy).second;
while (Px != nowx || Py != nowy) {
if (mp[Px][Py]) {
int PPx = nxt(Px, Py).first, PPy = nxt(Px, Py).second;
add(mp[Px][Py], PPx, PPy);
swap(mp[PPx][PPy], mp[Px][Py]);
}
pair<int, int> f = lst(Px, Py);
Px = f.first;
Py = f.second;
}
pair<int, int> f = nxt(nowx, nowy);
nowx = f.first;
nowy = f.second;
}
int main() {
n = read();
m = read();
for (int i = 1; i <= 4; i++) {
for (int j = 1; j <= n; j++) {
mp[i][j] = read();
}
}
Go();
for (int i = 1; i <= n; i++) {
if (mp[2][i] == 0) nowx = 2, nowy = i;
if (mp[3][i] == 0) nowx = 3, nowy = i;
}
if (!nowx) return puts("-1"), 0;
while (cnt < 20000) {
move();
Go();
if (OK == m) break;
}
printf("%d\n", cnt);
for (int i = 1; i <= cnt; i++) {
printf("%d %d %d\n", ansa[i], ansb[i], ansc[i]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3010;
const int inf = 1e6 + 10;
vector<int> adj[N];
int dis[N][N];
void bfs(int v) {
queue<int> q;
dis[v][v] = 0;
q.push(v);
while (!q.empty()) {
int u = q.front(), c = dis[v][u];
q.pop();
for (auto w : adj[u]) {
if (c + 1 < dis[v][w]) {
dis[v][w] = c + 1;
q.push(w);
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, u, v, s1, t1, l1, s2, t2, l2;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
cin >> s1 >> t1 >> l1 >> s2 >> t2 >> l2;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) dis[i][j] = inf;
for (int i = 1; i <= n; i++) bfs(i);
if (l1 < dis[s1][t1] || l2 < dis[s2][t2]) return cout << -1, 0;
int ans = dis[s1][t1] + dis[s2][t2];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
int a = dis[i][j], b = dis[i][s1], c = dis[i][s2], d = dis[i][t1],
e = dis[i][t2], f = dis[j][s1], g = dis[j][s2], h = dis[j][t1],
k = dis[j][t2];
if (a + b + h <= l1) {
if (a + c + k <= l2) ans = min(ans, a + b + h + c + k);
if (a + g + e <= l2) ans = min(ans, a + b + h + g + e);
}
if (a + f + d <= l1) {
if (a + c + k <= l2) ans = min(ans, a + f + d + c + k);
if (a + g + e <= l2) ans = min(ans, a + f + d + g + e);
}
}
}
cout << m - ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
void solve() {
int n;
cin >> n;
vector<pair<int, int> > v(3);
for (int i = 0; i < 3; i++) cin >> v[i].first >> v[i].second;
int x = min(v[0].second, n - v[1].first - v[2].first);
n -= x;
int y = min(v[1].second, n - v[2].first);
int z = n - y;
cout << x << " " << y << " " << z << endl;
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
const long long infll = 0x3f3f3f3f3f3f3f3f;
const long long mod = 1e9 + 7;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int maxn = 1e5 + 5;
const int maxm = 1.5e7 + 5;
using namespace std;
int n, c, a[maxn];
long long sum[maxn], dp[maxn];
multiset<int> st;
int main() {
scanf("%d %d", &n, &c);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
dp[i] = sum[i] = sum[i - 1] + a[i];
}
for (int i = 1; i < c; i++) st.insert(a[i]);
for (int i = c; i <= n; i++) {
st.insert(a[i]);
dp[i] =
min(dp[i - 1] + a[i], dp[i - c] + sum[i] - sum[i - c] - *st.begin());
st.erase(st.find(a[i - c + 1]));
}
printf("%lld\n", dp[n]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve(const int& n, int d, ostream& cout) {
vector<vector<int>> nodes_from(n, vector<int>());
vector<int> p(n + 1);
int min_sum = 0;
int max_sum = ((n - 1) * n) / 2;
int level = 1;
int level_max_node = 3;
for (int i = 2; i <= n; ++i) {
if (level_max_node < i) {
level_max_node = 2 * level_max_node + 1;
level += 1;
}
p[i] = i / 2;
min_sum += level;
nodes_from[level].push_back(i);
}
if (min_sum <= d && d <= max_sum) {
int level = 1;
while (level + 1 < n && nodes_from[level + 1].size() > 0) {
++level;
}
int sum = min_sum;
while (sum < d) {
while (nodes_from[level].size() <= 1) {
--level;
}
int node = nodes_from[level].back();
int new_parent =
nodes_from[level].front() + nodes_from[level + 1].size() / 2;
p[node] = new_parent;
nodes_from[level + 1].push_back(node);
nodes_from[level].pop_back();
++level;
++sum;
}
cout << "YES\n";
for (int i = 2; i <= n; ++i) {
cout << p[i] << " ";
}
cout << "\n";
} else {
cout << "NO\n";
}
}
int main(int argc, char** argv) {
int t;
cin >> t;
for (; t > 0; --t) {
int n, d;
cin >> n >> d;
solve(n, d, cout);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int countAC(string &S) {
int cnt = 0;
for (int i = 1; i < S.length(); i++) {
if (S[i - 1] == 'A' && S[i] == 'C') {
cnt++;
}
}
return cnt;
}
bool solve(string &S1, string &S2, int K, int X) {
long long len[K];
char start[K];
char end[K];
int L1 = S1.length();
int L2 = S2.length();
len[0] = countAC(S1);
start[0] = S1[0];
end[0] = S1[L1 - 1];
len[1] = countAC(S2);
start[1] = S2[0];
end[1] = S2[L2 - 1];
for (int i = 2; i < K; i++) {
len[i] = len[i - 2] + len[i - 1];
start[i] = start[i - 2];
end[i] = end[i - 1];
if (end[i - 2] == 'A' && start[i - 1] == 'C') {
len[i]++;
}
if (len[i] > X) {
return false;
}
}
return (len[K - 1] == X);
}
void blotX(string &S, int start, int end) {
for (int i = start; i <= end; i++) {
S[i] = 'X';
}
}
bool remAC(string &S, int cnt) {
for (int i = 1; i < S.length(); i++) {
if (cnt <= 0) {
break;
}
if (S[i - 1] == 'A' && S[i] == 'C') {
S[i - 1] = 'X';
S[i] = 'X';
cnt--;
}
}
return (cnt == 0);
}
string makeString(int len, char start, char repOdd, char repEvn, char end) {
string S(len, 'A');
S[0] = start;
for (int i = 1; i < len - 1; i++) {
if (i % 2 == 1) {
S[i] = repOdd;
} else {
S[i] = repEvn;
}
}
S[len - 1] = end;
return S;
}
vector<string> getPossibilities(int len) {
vector<string> vec;
char USE[] = {'A', 'C'};
for (char start : USE) {
for (char end : USE) {
for (int i = 0; i < 2; i++) {
char repOdd = USE[i];
char repEvn = USE[1 - i];
string init = makeString(len, start, repOdd, repEvn, end);
vec.push_back(init);
for (int j = 1;; j++) {
string S = init;
if (remAC(S, j)) {
vec.push_back(S);
} else {
break;
}
}
}
}
}
vec.push_back(string(len, 'X'));
return vec;
}
void printAns(int L1, int N, int L2, int M) {
string S1(N, 'X');
for (int i = 0; i < L1; i++) {
if (i % 2 == 0) {
S1[i + N - L1] = 'A';
} else {
S1[i + N - L1] = 'C';
}
}
string S2(M, 'X');
for (int i = 0; i < L2; i++) {
if (i % 2 == 0) {
S2[L2 - i - 1] = 'C';
} else {
S2[L2 - i - 1] = 'A';
}
}
cout << S1 << endl << S2 << endl;
}
int main() {
std::ios::sync_with_stdio(false);
int K, X, N, M;
cin >> K >> X >> N >> M;
char USE[] = {'A', 'C'};
vector<string> v1 = getPossibilities(N);
vector<string> v2 = getPossibilities(M);
for (string s1 : v1) {
for (string s2 : v2) {
if (solve(s1, s2, K, X)) {
cout << s1 << endl << s2 << endl;
return 0;
}
}
}
cout << "Happy new year!" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int dp[1002][12][12];
vector<int> a;
void printPath(int idx, int prev, int diff) {
if (idx > m) return;
for (int i = 1; i < n; ++i) {
if (i != prev && a[i] > diff && dp[idx + 1][i][a[i] - diff]) {
printf("%d ", a[i]);
printPath(idx + 1, i, a[i] - diff);
return;
}
}
}
bool f(int idx, int prev, int diff) {
if (idx > m) return 1;
if (dp[idx][prev][diff] != -1) return dp[idx][prev][diff];
int ret = 0;
for (int i = 1; i < n; ++i)
if (i != prev && a[i] > diff) ret |= f(idx + 1, i, a[i] - diff);
return dp[idx][prev][diff] = ret;
}
int main() {
char str[11];
scanf("%s%d", str, &m);
a.push_back(0);
for (int i = 0; i < 10; ++i)
if (str[i] == '1') a.push_back(i + 1);
n = a.size();
memset(dp, -1, sizeof(dp));
if (f(1, 0, 0)) {
printf("YES\n");
printPath(1, 0, 0);
printf("\n");
} else
printf("NO\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 6e3;
const long long INF = 1e18;
int n;
vector<int> g[N];
int size[N], par[N];
void build(int x, int p = -1) {
par[x] = p;
size[x] = 1;
for (int i = int(0); i <= int(g[x].size() - 1); ++i) {
int to = g[x][i];
if (to == p) continue;
build(to, x);
size[x] += size[to];
}
}
int sz, a[N];
int d[N];
set<int> res;
void knapsack(int x) {
memset(d, 0, sizeof(d));
sz = 0;
for (auto to : g[x])
if (to != par[x]) a[++sz] = size[to];
if (x > 1) a[++sz] = n - size[x];
d[0] = 1;
for (int i = int(1); i <= int(sz); ++i)
for (int j = int(n); j >= int(a[i]); --j) d[j] |= d[j - a[i]];
for (int i = int(1); i <= int(n - 2); ++i)
if (d[i]) res.insert(i);
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = int(1); i <= int(n - 1); ++i) {
int f, t;
cin >> f >> t;
g[f].push_back(t);
g[t].push_back(f);
}
build(1);
for (int i = int(1); i <= int(n); ++i) knapsack(i);
cout << res.size() << "\n";
for (auto x : res) cout << x << " " << n - 1 - x << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (a == 0)
return (b);
else
return (gcd(b % a, a));
}
long long int fastpow(long long int a, long long int n, long long int temp) {
if (n == 0) return (1);
if (n == 1) return ((a * temp) % 1000000007);
if (n & 1) temp = (temp * a) % 1000000007;
return (fastpow((a * a) % 1000000007, n / 2, temp));
}
char dum;
vector<vector<int> > v;
vector<int> temp;
int main() {
int n, m, cum_sum;
char a;
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
v.push_back(temp);
}
for (int i = 0; i < n; i++) {
cum_sum = 0;
for (int j = 0; j < m; j++) {
cin >> a;
if (a == '0')
cum_sum = 0;
else
cum_sum++;
v[j].push_back(cum_sum);
}
}
for (int j = 0; j < m; j++) {
sort(v[j].begin(), v[j].end());
}
int ans = 0;
for (int j = 0; j < m; j++) {
for (int k = 0; k < v[j].size(); k++) {
ans = max(ans, v[j][k] * ((int)v[j].size() - k));
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, v;
int id[100002], nx[100002], la[100002];
set<pair<int, int> > S;
set<pair<int, int> >::iterator it;
struct aaa {
int p, a;
} w[100002];
inline bool cmp(int a, int b) { return w[a].p < w[b].p ? 1 : 0; }
inline int dis(int x, int y) {
if (x == y) return 0x3f3f3f3f;
int d = (w[y].p - w[x].p + m) % m;
if (x > y) d = (d + w[y].a) % m;
if (d <= w[x].a) return 1;
if (w[x].a <= w[y].a) return 0x3f3f3f3f;
return (d - w[y].a - 1) / (w[x].a - w[y].a) + 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d%d", &w[i].p, &w[i].a), id[i] = i;
sort(id + 1, id + n + 1, cmp);
for (int i = 1; i <= n; ++i) la[nx[id[i]] = id[(i % n) + 1]] = id[i];
for (int i = 1; i <= n; ++i) S.insert(pair<int, int>(dis(i, nx[i]), i));
while (!S.empty()) {
it = S.begin(), v = it->second;
if (it->first == 0x3f3f3f3f) break;
S.erase(it), S.erase(pair<int, int>(dis(nx[v], nx[nx[v]]), nx[v])),
S.erase(pair<int, int>(dis(la[v], v), la[v]));
w[v].p += dis(v, nx[v]), --w[v].a, la[nx[v] = nx[nx[v]]] = v;
S.insert(pair<int, int>(dis(la[v], v), la[v])),
S.insert(pair<int, int>(dis(v, nx[v]), v));
}
printf("%d\n", S.size());
for (it = S.begin(); it != S.end(); ++it) printf("%d ", it->second);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 102;
int a[N];
double f[N][N], nf[N][N];
int main() {
int n, k;
scanf("%d %d", &n, &k);
if (k > 1000) {
k = 1000;
}
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
f[i][j] = (a[i] > a[j]);
}
}
int segs = n * (n + 1) / 2;
for (int step = 1; step <= k; step++) {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
nf[i][j] = 0.0;
nf[i][j] += f[i][j] * 1.0 *
(((i + 1) * i / 2) + ((j - i) * (j - i - 1) / 2) +
((n - j) * (n - j - 1) / 2));
for (int sum = j; sum <= i + (n - 1); sum++) {
int from = (sum - n + 1 > 0 ? sum - n + 1 : 0);
int to = (i < sum - j ? i : sum - j);
nf[i][j] += (1.0 - f[sum - j][sum - i]) * (to - from + 1);
}
for (int sum = i; sum <= i + (j - 1); sum++) {
int from = (sum - j + 1 > 0 ? sum - j + 1 : 0);
int to = (i < sum - i ? i : sum - i);
nf[i][j] += f[sum - i][j] * (to - from + 1);
}
for (int sum = (i + 1) + j; sum <= j + (n - 1); sum++) {
int from = (i + 1 > sum - n + 1 ? i + 1 : sum - n + 1);
int to = (j < sum - j ? j : sum - j);
nf[i][j] += f[i][sum - j] * (to - from + 1);
}
nf[i][j] /= segs;
}
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
f[i][j] = nf[i][j];
}
}
}
double ans = 0.0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
ans += f[i][j];
}
}
printf("%.17f\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int n;
cin >> n;
map<int, int> mp;
int count = 0;
vector<char> l;
string p;
int f = 0, g = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] != '?' && s[i] != '*') {
l.push_back(s[i]);
count++;
}
}
if (count == n) {
for (int i = 0; i < l.size(); i++) cout << l[i];
} else if (count < n) {
for (int i = 0; i < s.size(); i++) {
if (s[i] == '*') {
f = 1;
break;
}
}
if (f == 0) {
cout << "Impossible";
return 0;
}
int d = n - count, j = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] != '*' && s[i] != '?') {
p = p + s[i];
}
if (s[i] == '*' && g == 0) {
while (j < d) {
p = p + s[i - 1];
j++;
}
g = 1;
}
}
cout << p;
} else {
int r = (count - n), t = 0;
for (int i = 0; i < s.size(); i++) {
if ((s[i] == '?' || s[i] == '*')) {
mp[i]++;
mp[i - 1]++;
t++;
if (t == r) {
break;
}
}
}
for (int i = 0; i < s.size(); i++) {
if (mp[i] == 0 && s[i] != '*' && s[i] != '?') {
p = p + s[i];
}
}
if (p.size() == n)
cout << p;
else
cout << "Impossible";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353;
const int maxn = 2000005;
void add(int &x, int y) {
x += y;
if (x >= M) x -= M;
}
void sub(int &x, int y) {
x -= y;
if (x < 0) x += M;
}
int f[maxn], nf[maxn], inv[maxn], n, ans, os[maxn], ls[maxn], rs[maxn],
p2[maxn];
char s[maxn];
int C(int x, int y) {
if (y < 0 || y > x) return 0;
return 1ll * f[x] * nf[y] % M * nf[x - y] % M;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
inv[1] = 1;
for (int i = 2; i < maxn; i++) inv[i] = M - 1ll * (M / i) * inv[M % i] % M;
nf[0] = f[0] = 1;
for (int i = 1; i < maxn; i++)
f[i] = 1ll * f[i - 1] * i % M, nf[i] = 1ll * nf[i - 1] * inv[i] % M;
for (int i = 1; i <= n; i++) {
ls[i] = ls[i - 1] + (s[i] == '(');
rs[i] = rs[i - 1] + (s[i] == ')');
os[i] = os[i - 1] + (s[i] == '?');
}
for (int i = 1; i < n; i++) {
int a, b, x, y;
x = ls[i];
y = rs[n] - rs[i];
a = os[i];
b = os[n] - os[i];
add(ans, 1ll * x * C(a + b, y - x + b) % M);
add(ans, 1ll * a * C(a + b - 1, y - x + b - 1) % M);
}
printf("%d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int phone_numbers = 0;
int eights = 0;
cin >> n;
string cards;
cin >> cards;
for (int i = 0; i < n; i++) {
if (cards[i] == '8') eights++;
}
for (int i = 0; i < eights; i++) {
if (n - 11 >= 0) phone_numbers++;
n = n - 11;
}
cout << phone_numbers;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
int n, m, l, r;
long long a[maxn], d[maxn], v;
struct ss {
int l, r, lm, mm, rm;
} seg[maxn << 2];
inline int sign(long long x) { return !x ? 0 : x < 0 ? -1 : 1; }
void pushup(int x) {
int l = seg[x].l, r = seg[x].r, m = (l + r) >> 1;
seg[x].mm = max(seg[x << 1].mm, seg[x << 1 | 1].mm);
seg[x].lm = seg[x << 1].lm;
seg[x].rm = seg[x << 1 | 1].rm;
if (!d[m] || !d[m + 1] || sign(d[m]) < sign(d[m + 1])) return;
seg[x].mm = max(seg[x].mm, seg[x << 1].rm + seg[x << 1 | 1].lm);
if (seg[x].lm == m - l + 1) seg[x].lm += seg[x << 1 | 1].lm;
if (seg[x].rm == r - m) seg[x].rm += seg[x << 1].rm;
}
void build(int x, int l, int r) {
seg[x].l = l, seg[x].r = r;
if (l == r) {
seg[x].lm = seg[x].mm = seg[x].rm = !!d[l];
return;
}
int m = (l + r) >> 1;
build(x << 1, l, m);
build(x << 1 | 1, m + 1, r);
pushup(x);
}
void update(int x, int p, long long v) {
int L = seg[x].l, R = seg[x].r;
if (L == R) {
d[p] += v;
seg[x].lm = seg[x].mm = seg[x].rm = !!d[p];
return;
}
int m = (L + R) >> 1;
if (m >= p) update(x << 1, p, v);
if (m < p) update(x << 1 | 1, p, v);
pushup(x);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
for (int i = 2; i <= n; ++i) d[i - 1] = a[i] - a[i - 1];
--n;
if (n) build(1, 1, n);
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d%lld", &l, &r, &v);
if (!n) {
puts("1");
continue;
}
if (l != 1) update(1, l - 1, v);
if (r != n + 1) update(1, r, -v);
printf("%d\n", seg[1].mm + 1);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct info_t {
int x, y, i;
};
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<info_t> from(m), to(m);
vector<vector<int>> answer_from, answer_to;
auto solve = [&](vector<info_t> &info, vector<vector<int>> &answer) {
for (int i = 0; i < m; ++i) {
scanf("%d %d", &info[i].x, &info[i].y);
--info[i].x;
--info[i].y;
info[i].i = i;
}
sort(info.begin(), info.end(), [&](const info_t &a, const info_t &b) {
return a.x < b.x || (a.x == b.x && a.y < b.y);
});
while (true) {
bool need = false;
for (int i = 0; i < m; ++i) {
if (info[i].x > i) {
answer.push_back(
vector<int>{info[i].x, info[i].y, info[i].x - 1, info[i].y});
--info[i].x;
need = true;
}
}
for (int i = m - 1; ~i; --i) {
if (info[i].x < i) {
answer.push_back(
vector<int>{info[i].x, info[i].y, info[i].x + 1, info[i].y});
++info[i].x;
need = true;
}
}
if (!need) {
break;
}
}
for (int i = 0; i < m; ++i) {
while (info[i].y < info[i].i) {
answer.push_back(
vector<int>{info[i].x, info[i].y, info[i].x, info[i].y + 1});
++info[i].y;
}
while (info[i].y > info[i].i) {
answer.push_back(
vector<int>{info[i].x, info[i].y, info[i].x, info[i].y - 1});
--info[i].y;
}
}
};
solve(from, answer_from);
solve(to, answer_to);
sort(from.begin(), from.end(),
[&](const info_t &a, const info_t &b) { return a.i < b.i; });
sort(to.begin(), to.end(),
[&](const info_t &a, const info_t &b) { return a.i < b.i; });
for (int i = 0; i < m; ++i) {
while (from[i].x < to[i].x) {
answer_from.push_back(
vector<int>{from[i].x, from[i].y, from[i].x + 1, from[i].y});
++from[i].x;
}
while (from[i].x > to[i].x) {
answer_from.push_back(
vector<int>{from[i].x, from[i].y, from[i].x - 1, from[i].y});
--from[i].x;
}
}
printf("%d\n", answer_from.size() + answer_to.size());
for (auto v : answer_from) {
printf("%d %d %d %d\n", v[0] + 1, v[1] + 1, v[2] + 1, v[3] + 1);
}
reverse(answer_to.begin(), answer_to.end());
for (auto v : answer_to) {
printf("%d %d %d %d\n", v[2] + 1, v[3] + 1, v[0] + 1, v[1] + 1);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int M[105] = {0};
string a[100];
int i, n, k;
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> a[i];
M[a[i].length()]++;
}
for (i = 1; i <= 100; i++) M[i] += M[i - 1];
string x;
cin >> x;
int a1 = M[x.length() - 1] + 5 * (M[x.length() - 1] / k) + 1;
int a2 = (M[x.length()] - 1) + 5 * ((M[x.length()] - 1) / k) + 1;
cout << a1 << " " << a2 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g;
class segment_tree_max {
private:
vector<int> m;
vector<int> delta;
int n;
bool is_bulk;
int get_val(int i) {
if (!is_bulk) {
return m[i];
}
int ans = m[i] + delta[i];
i /= 2;
while (i >= 1) {
ans += delta[i];
i /= 2;
}
return ans;
}
void inc(int i, int val) {
delta[i] += val;
i /= 2;
while (i >= 1) {
m[i] = max(m[2 * i] + delta[2 * i], m[2 * i + 1] + delta[2 * i + 1]);
i /= 2;
}
}
public:
segment_tree_max() {}
segment_tree_max(int nn, int def, bool bulk = false) {
is_bulk = bulk;
n = 1;
while (n < nn) {
n *= 2;
}
m.assign(2 * n, def);
if (is_bulk) {
delta.assign(2 * n, 0);
}
}
segment_tree_max(const vector<int>& d, int def = 0, bool bulk = false,
int mult = 1) {
is_bulk = bulk;
n = 1;
while (n < d.size()) {
n *= 2;
}
m.assign(2 * n, def);
if (is_bulk) {
delta.assign(2 * n, 0);
}
for (int i = 0; i < d.size(); i++) {
m[i + n] = d[i] * mult;
}
for (int i = n - 1; i >= 1; i--) {
m[i] = max(m[2 * i], m[2 * i + 1]);
}
}
int get_max(int l, int r) {
if (l > r) {
swap(l, r);
}
l += n;
r += n;
int ans = -1e9;
while (l <= r) {
if (l % 2 == 1) {
ans = max(ans, get_val(l));
l++;
}
if (r % 2 == 0) {
ans = max(ans, get_val(r));
r--;
}
l /= 2;
r /= 2;
}
return ans;
}
void inc_bulk(int l, int r, int val) {
if (!is_bulk) {
cout << "cant inc_bulk in not bulk mode" << endl;
exit(1);
}
if (l > r) {
swap(l, r);
}
l += n;
r += n;
while (l <= r) {
if (l % 2 == 1) {
inc(l, val);
l++;
}
if (r % 2 == 0) {
inc(r, val);
r--;
}
l /= 2;
r /= 2;
}
}
void update(int i, int val) {
i += n;
m[i] = val;
i /= 2;
while (i >= 1) {
if (is_bulk) {
m[i] = max(m[2 * i] + delta[2 * i], m[2 * i + 1] + delta[2 * i + 1]);
} else {
m[i] = max(m[2 * i], m[2 * i + 1]);
}
i /= 2;
}
}
};
class segment_tree_min {
private:
segment_tree_max max_tree;
public:
segment_tree_min() {}
segment_tree_min(int nn, int def, bool bulk = false) {
max_tree = segment_tree_max(nn, def, bulk);
}
segment_tree_min(const vector<int>& d, int def = -1e9, bool bulk = false) {
max_tree = segment_tree_max(d, def, bulk, -1);
}
int get_min(int l, int r) { return -max_tree.get_max(l, r); }
void inc_bulk(int l, int r, int val) { max_tree.inc_bulk(l, r, -val); }
void update(int i, int val) { max_tree.update(i, -val); }
};
class lca {
private:
segment_tree_min min_tree;
vector<int> h;
vector<int> d;
vector<int> di;
int n;
void dfs(const vector<vector<int> >& g, int x, int l, int p) {
di[x] = d.size();
h[x] = l;
d.push_back(l);
for (int y : g[x]) {
if (y != p) {
dfs(g, y, l + 1, x);
d.push_back(l);
}
}
}
public:
lca(const vector<vector<int> >& g) {
int n = g.size();
h.assign(n, 0);
di.assign(n, 0);
dfs(g, 0, 0, -1);
min_tree = segment_tree_min(d);
}
int get_dist(int x, int y) {
int parent_h = min_tree.get_min(di[x], di[y]);
return h[x] - parent_h + h[y] - parent_h;
}
};
bool check(int l, int k) {
if (l <= k && ((k - l) % 2 == 0)) {
return true;
} else {
return false;
}
}
void solve() {
int n;
cin >> n;
vector<vector<int> > g(n);
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
g[x - 1].push_back(y - 1);
g[y - 1].push_back(x - 1);
}
lca r(g);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int x, y, a, b, k;
cin >> x >> y >> a >> b >> k;
int ab = r.get_dist(a - 1, b - 1);
int ax = r.get_dist(a - 1, x - 1);
int ay = r.get_dist(a - 1, y - 1);
int bx = r.get_dist(b - 1, x - 1);
int by = r.get_dist(b - 1, y - 1);
int xy = 1;
if (check(ab, k) || check(ax + xy + by, k) || check(ay + xy + bx, k) ||
check(ax + xy + ay + ab, k)) {
cout << "YES";
} else {
cout << "NO";
}
cout << endl;
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
solve();
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 3e5;
vector<int> g[N];
int a[N];
int mpow(int base, int exp);
void ipgraph(int n, int m);
void dfs(int u, int par);
map<pair<long long, long long>, int> dp;
int go(long long a, long long b) {
if (a < b) swap(a, b);
if (dp.find({a, b}) != dp.end()) return dp[{a, b}];
if (b == 0) return 0;
if (a % b == 0) return 1;
int ans = go(a % b, b);
if (!ans) return dp[{a, b}] = 1;
long long b_ = a / b;
if (b & 1) return dp[{a, b}] = 1 - (b_ & 1);
b_ %= (b + 1);
if (b_ & 1) return dp[{a, b}] = 0;
return dp[{a, b}] = 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int i, n, k, j;
int t;
cin >> t;
while (t--) {
long long x, y;
cin >> x >> y;
int win = go(x, y);
if (win)
cout << "First\n";
else
cout << "Second\n";
}
return 0;
}
int mpow(int base, int exp) {
base %= mod;
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((long long)result * base) % mod;
base = ((long long)base * base) % mod;
exp >>= 1;
}
return result;
}
void ipgraph(int n, int m) {
int i, u, v;
while (m--) {
cin >> u >> v;
g[u - 1].push_back(v - 1);
g[v - 1].push_back(u - 1);
}
}
void dfs(int u, int par) {
for (int v : g[u]) {
if (v == par) continue;
dfs(v, u);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int l, r, t, k;
long long dp[150000];
long long sum[150000];
int main() {
scanf("%d%d", &t, &k);
dp[0] = 1;
sum[0] = 1;
for (int i = 1; i <= 100001; i++) {
dp[i] = dp[i - 1];
if (i >= k) dp[i] += dp[i - k];
dp[i] %= 1000000007;
}
for (int i = 1; i <= 100001; i++) {
sum[i] = sum[i - 1] + dp[i];
sum[i] %= 1000000007;
}
while (t--) {
scanf("%d%d", &l, &r);
printf("%I64d\n",
(((sum[r] - sum[l - 1]) % 1000000007 + 1000000007) % 1000000007));
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int MAXN = 15e4 + 5;
int n, k, q;
pair<int, int> p[MAXN];
priority_queue<pair<int, int>, std::vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
int main(int argc, char const *argv[]) {
scanf("%d%d%d", &n, &k, &q);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
p[i] = make_pair(x, i);
}
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
if (x == 1) {
pq.push(p[y]);
if (pq.size() > k) pq.pop();
} else {
priority_queue<pair<int, int>, std::vector<pair<int, int> >,
greater<pair<int, int> > >
tmp = pq;
bool flag = false;
while (!tmp.empty()) {
if (tmp.top().second == y) {
flag = true;
break;
}
tmp.pop();
}
if (!flag)
printf("NO\n");
else
printf("YES\n");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
long long n, a[100001], sum[100001];
int main() {
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
sum[0] = a[0] + 1;
for (int i = 1; i < n; i++) {
sum[i] = std::max(sum[i - 1], a[i] + 1);
}
for (int i = n - 1; i > 0; i--) {
if (sum[i] - sum[i - 1] > 1) {
sum[i - 1] = sum[i] - 1;
}
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += sum[i] - a[i] - 1;
}
printf("%lld", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int A[4005][4005];
int main() {
int n, m, u, v, i, j, k, sz, mini = INT_MAX;
cin >> n >> m;
vector<int> adj[n + 5];
while (m--) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
A[u][v] = A[v][u] = 1;
}
for (i = 1; i <= n; i++) {
sz = adj[i].size();
for (j = 0; j < sz; j++)
for (k = j + 1; k < sz; k++)
if (A[adj[i][j]][adj[i][k]] == 1) {
int tmp = sz + adj[adj[i][j]].size() + adj[adj[i][k]].size() - 6;
mini = min(mini, tmp);
}
}
if (mini == INT_MAX)
cout << "-1";
else
cout << mini;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[100010];
int pwr(int base, long long exp) {
if (exp == 0) return 1;
if (exp == 1) return base;
int res = (1LL * base * base) % 1000000007;
return (1LL * pwr(res, exp >> 1) * pwr(base, exp & 1)) % 1000000007;
}
int main() {
int k, res = 2;
bool even = false;
scanf("%d", &k);
for (int i = 0; i < k; i++) {
long long val;
scanf("%I64d", &val);
res = pwr(res, val);
even |= (val % 2 == 0);
}
res = (1LL * res * pwr(2, 1000000007 - 2)) % 1000000007;
int p, q;
if (even) {
p = (1LL * (res + 1) * pwr(3, 1000000007 - 2)) % 1000000007;
q = res;
} else {
p = (1LL * (res - 1) * pwr(3, 1000000007 - 2)) % 1000000007;
q = res;
}
printf("%d/%d\n", p, q);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4010;
long long int ans(0), sum(0);
long long int c[N][N], d[N][N];
int main() {
int n;
register int i, j;
scanf("%d", &n);
c[0][0] = 1;
for (i = 1; i <= n; ++i) {
c[i][0] = c[i][i] = 1;
for (j = 1; j <= n - 1; ++j)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 1000000007;
}
d[0][0] = 1;
for (i = 1; i <= n; ++i)
for (j = 1; j <= i; ++j)
d[i][j] = (d[i - 1][j] * j + d[i - 1][j - 1]) % 1000000007;
for (i = 1; i <= n - 1; ++i) {
sum = 0;
for (j = 1; j <= i; ++j) sum = (sum + d[i][j]) % 1000000007;
ans = (ans + c[n][i] * sum) % 1000000007;
}
printf("%I64d", ans + 1);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
std::ios::sync_with_stdio(false);
cin.tie(0);
string s;
int n, x, y;
cin >> n >> x >> y;
cin >> s;
int ans = 0;
for (int i = n - 1; i >= n - x; --i) {
if (i >= n - y && s[i] == '1')
ans++;
else if (i < n - y - 1 && s[i] == '1') {
ans++;
}
}
if (s[n - y - 1] == '0') ans++;
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int x, y, z, t1, t2, t3;
int main() {
cin >> x >> y >> z >> t1 >> t2 >> t3;
int dif = abs(x - y);
int stair = dif * t1;
int lift = dif * t2;
int temp = abs(x - z);
lift += temp * t2;
lift += t3 + t3 + t3;
if (lift <= stair)
puts("YES");
else
puts("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
deque<int>* lists;
int n;
double answer;
void ReadData() {
scanf("%d", &n);
lists = new deque<int>[n];
for (int i = 1; i < n; i++) {
int from, to;
scanf("%d %d", &from, &to);
from--;
to--;
lists[from].push_back(to);
lists[to].push_back(from);
}
}
void dfsVisit(int, int);
bool* used;
void dfs() {
used = new bool[n];
memset(used, 0, sizeof(bool) * n);
used[0] = true;
for (deque<int>::iterator it = lists[0].begin(); it != lists[0].end(); it++) {
if (!used[*it]) {
dfsVisit(*it, 2);
}
}
}
void dfsVisit(int vertex, int depth) {
used[vertex] = true;
answer += 1.0 / (double)depth;
for (deque<int>::iterator it = lists[vertex].begin();
it != lists[vertex].end(); it++) {
if (!used[*it]) {
dfsVisit(*it, depth + 1);
}
}
}
void Solve() {
answer = 1.0;
dfs();
}
void WriteData() { printf("%.10f\n", answer); }
int main() {
int QWE;
QWE = 1;
for (int T = 0; T < QWE; T++) {
ReadData();
Solve();
WriteData();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool flage = true;
string s;
cin >> s;
int i, j;
for (i = 0, j = 0; i < s.length() && flage; i++) {
if (s[i] == '@') {
if (i - j > 16 || i - j < 1)
flage = false;
else {
j = i + 1;
break;
}
}
if (j == 0 && !(isalpha(s[i])) && s[i] != '_' && !(isdigit(s[i])))
flage = false;
}
if (!flage || j == 0) {
cout << "NO";
return 0;
}
int n = j;
for (i = j; i < s.length() && flage; i++) {
if (s[i] == '/') {
if (i - j > 16 || i - j < 1)
flage = false;
else {
j = i + 1;
break;
}
} else if (s[i] == '.') {
if (i - j > 16 || i - j < 1)
flage = false;
else
j = i + 1;
}
if (i - n > 32) flage = false;
if (!(isalpha(s[i])) && s[i] != '.' && s[i] != '_' && !(isdigit(s[i])))
flage = false;
}
if (!flage || s[s.length() - 1] == '/' || s[s.length() - 1] == '.' ||
s[s.length() - 1] == '@') {
cout << "NO";
return 0;
}
for (i = j; i < s.length() && flage; i++) {
if (!(isalpha(s[i])) && s[i] != '_' && !(isdigit(s[i]))) flage = false;
}
if (!flage || i - j < 1 || i - j > 16) {
cout << "NO";
return 0;
}
cout << "YES";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const double eps = 1e-6;
const double PI = acos(-1.0);
const int maxn = 1e6 + 10;
const int N = 120 + 5;
const long long inf = 0x3f3f3f3f;
const int dir[][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
int cnt[40];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int _;
cin >> _;
while (_--) {
int n;
cin >> n;
memset(cnt, 0, sizeof(cnt));
for (int i = 0, x; i < n; i++) {
cin >> x;
for (int j = 0; j < 31; j++)
if ((x >> j) & 1) cnt[j]++;
}
bool ok = 0;
for (int i = 30; i >= 0; i--) {
if (cnt[i] % 4 == 1) {
ok = 1;
cout << "WIN" << '\n';
break;
} else if (cnt[i] % 4 == 3) {
ok = 1;
if ((n - cnt[i]) & 1)
cout << "WIN" << '\n';
else
cout << "LOSE" << '\n';
break;
}
}
if (!ok) cout << "DRAW" << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long int t, w;
bool operator<(const node &a) const { return w - t > a.w - a.t; }
} G[300010];
bool cmp(const node &a, const node &b) { return a.t > b.t; }
priority_queue<node> q;
int main() {
int n, i, res;
long long int xt, xw, t, w;
int pai = 1, has = 0, y = 0;
scanf("%d", &n);
scanf("%I64d %I64d", &xt, &xw);
for (i = 0; i < n - 1; i++) {
scanf("%I64d %I64d", &t, &w);
if (w - t + 1 > xt && t > xt)
has++;
else {
G[y].t = t;
G[y++].w = w;
}
}
sort(G, G + y, cmp);
i = 0;
while (i < y && G[i].t > xt) {
q.push(G[i]);
i++;
pai++;
}
res = pai + has;
pai = res;
while (!q.empty()) {
node u = q.top();
if (u.w - u.t + 1 > xt) break;
q.pop();
pai--;
xt -= (u.w - u.t + 1);
while (i < y && G[i].t > xt) {
q.push(G[i]);
i++;
pai++;
}
res = min(res, pai);
}
printf("%d\n", res);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, set<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class L, class R>
ostream& operator<<(ostream& os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
const int MAX = 1000010;
const int MOD2 = 998244353;
const int MOD = 1000000007;
const int INF = 1e8;
const long long int LLINF = 0x3f3f3f3f3f3f3f3f;
const long double EPS = 1e-7;
void solve() {
int n;
cin >> n;
vector<int> a(n);
bool pos = false, neg = false;
long long int sum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += abs(a[i]);
if (a[i] < 0)
neg = true;
else if (a[i] > 0)
pos = true;
}
if (n == 1) {
cout << a[0] << "\n";
return;
}
if (neg and pos) {
cout << sum << "\n";
} else if (neg) {
sort(a.begin(), a.end(), greater<int>());
cout << sum + 2 * a[0] << "\n";
} else if (pos) {
sort(a.begin(), a.end());
cout << sum - 2 * a[0] << "\n";
} else {
cout << 0 << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(25);
cerr << fixed << setprecision(10);
auto start = std::chrono::high_resolution_clock::now();
solve();
auto stop = std::chrono::high_resolution_clock::now();
auto duration =
std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
int n, m;
void Exgcd(long long a, long long b, long long &x, long long &y) {
if (!b)
x = 1, y = 0;
else
Exgcd(b, a % b, y, x), y -= a / b * x;
}
long long Inv(long long a) {
long long x, y;
Exgcd(a, m, x, y);
x = (x % m + m) % m;
return x;
}
int po[N] = {1};
struct Edge {
int to, nxt, w;
} e[N << 1];
int head[N], ecnt;
inline void AddEdge(int u, int v, int w) {
e[++ecnt].nxt = head[u];
e[ecnt].to = v;
e[ecnt].w = w;
head[u] = ecnt;
}
int cnt[N], son[N], dep[N];
long long Udis[N], Ddis[N];
void dfs(int u, int f) {
cnt[u] = 1;
for (int i = head[u]; ~i; i = e[i].nxt)
if (e[i].to != f) {
int v = e[i].to, w = e[i].w;
Udis[v] = (Udis[u] + 1ll * po[dep[u]] % m * w) % m;
Ddis[v] = (10ll * Ddis[u] % m + w) % m;
dep[v] = dep[u] + 1;
dfs(v, u);
cnt[u] += cnt[v];
if (cnt[son[u]] < cnt[v]) son[u] = v;
}
}
map<int, int> U, D;
long long ans;
void Calc(int u, int LCA) {
long long Ub = Udis[u], pl = po[dep[LCA]], pe = po[dep[u]], Dl = Ddis[LCA],
De = Ddis[u], Ul = Udis[LCA];
long long x = ((1ll * Dl * pl % m - 1ll * De * pl % m * pl % m * Inv(pe) % m +
1ll * Ul) %
m +
m) %
m;
x = (x + m) % m;
long long y =
(1ll * Dl * Inv(pl) % m + 1ll * (Ul - Ub) * Inv(pl) % m * Inv(pl) % m) %
m;
y = (y + m) % m;
ans += U[x];
ans += D[y];
}
void Add(int u) {
long long x = Udis[u], y = 1ll * Ddis[u] * Inv(po[dep[u]]) % m;
x = (x + m) % m, y = (y + m) % m;
U[x]++, D[y]++;
}
void Upd(int u, int f, int LCA, int k) {
if (k)
Calc(u, LCA);
else
Add(u);
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].to;
if (v == f) continue;
Upd(v, u, LCA, k);
}
}
void dfs_getans(int u, int f, int h) {
for (int i = head[u]; ~i; i = e[i].nxt)
if (e[i].to != f && e[i].to != son[u]) dfs_getans(e[i].to, u, 0);
if (son[u]) dfs_getans(son[u], u, 1);
for (int i = head[u]; ~i; i = e[i].nxt)
if (e[i].to != f && e[i].to != son[u]) {
Upd(e[i].to, u, u, 1);
Upd(e[i].to, u, u, 0);
}
Calc(u, u);
Add(u);
if (!h) U.clear(), D.clear();
}
int _main() {
scanf("%d%d", &n, &m);
memset(head, -1, sizeof head);
for (int i = 1; i <= n + 3; i++) po[i] = 1LL * po[i - 1] * 10 % m;
if (m == 1) return cout << 1ll * n * (n - 1), 0;
for (int i = 2, u, v, w; i <= n; i++) {
scanf("%d%d%d", &u, &v, &w);
u++, v++;
AddEdge(u, v, w);
AddEdge(v, u, w);
}
dfs(1, 0);
dfs_getans(1, 0, 1);
printf("%lld\n", ans);
return 0;
}
signed main() {
_main();
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
using namespace std;
const int mod = (int)1e9 + 7;
const int N = (int)2e5 + 123;
const long long inf = (long long)1e18 + 1;
const double pi = acos(-1.0);
const double eps = 1e-7;
const int dx[] = {0, 0, 1, 0, -1};
const int dy[] = {0, 1, 0, -1, 0};
int n, a[N], b[N], p[N], t[4 * N];
vector<int> add[N], del[N];
set<pair<int, int> > s;
void upd(int pos, int val, int v = 1, int tl = 1, int tr = n) {
if (tl == tr) {
if (val < 0)
t[v] = mod;
else
t[v] = val;
return;
}
int tm = tl + tr >> 1;
if (pos <= tm)
upd(pos, val, v + v, tl, tm);
else
upd(pos, val, v + v + 1, tm + 1, tr);
t[v] = min(t[v + v], t[v + v + 1]);
}
int get(int l, int r, int v = 1, int tl = 1, int tr = n) {
if (tl > r || tr < l) return mod;
if (l <= tl && tr <= r) return t[v];
int tm = tl + tr >> 1;
return min(get(l, r, v + v, tl, tm), get(l, r, v + v + 1, tm + 1, tr));
}
inline void boost() {
ios_base ::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
inline void Solve() {
cin >> n;
set<int> s;
for (int i = 1; i <= n; i++) s.insert(i);
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i], add[b[i]].push_back(i);
for (int i = 1; i <= n; i++) {
for (auto it : add[i]) {
p[it] = *s.lower_bound(a[it]);
s.erase(p[it]);
}
}
for (int i = 1; i <= n; i++) add[i].clear();
for (int i = 1; i < 4 * N; i++) t[i] = mod;
for (int i = 1; i <= n; i++) {
add[a[i]].push_back(i);
del[b[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
for (auto it : add[i]) upd(p[it], a[it]);
for (auto it : del[i]) {
if (get(p[it] + 1, b[it]) <= p[it]) {
int x = it, y = -1;
for (int j = 1; j <= n; j++) {
if (x == j) continue;
if (p[x] < p[j] && p[j] <= b[it] && a[j] <= p[it]) {
y = j;
break;
}
}
if (y == -1) cout << 1 / 0, exit(0);
cout << "NO\n";
for (int z = 1; z <= n; z++) cout << p[z] << ' ';
cout << '\n';
swap(p[x], p[y]);
for (int z = 1; z <= n; z++) cout << p[z] << ' ';
exit(0);
}
}
for (auto it : del[i]) upd(p[it], -a[it]);
}
cout << "YES\n";
for (int i = 1; i <= n; i++) cout << p[i] << ' ';
}
signed main() {
int tt = 1;
while (tt--) {
Solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int diff = min(k - 1, n - k);
cout << n * 3 + diff;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef struct P {
int x, y;
P() {}
P(int x, int y) : x(x), y(y) {}
} P;
typedef struct F {
int x, y, r;
} F;
bool operator<(const F &a, const F &b) { return a.r < b.r; }
vector<int> parent;
vector<vector<int> > memupp;
int upp(int a, int p) {
assert(((int)(memupp[a]).size()) > 0);
while (p >= ((int)(memupp[a]).size())) {
int i = ((int)(memupp[a]).size()) - 1;
memupp[a].push_back(upp(upp(a, i), i));
}
return memupp[a][p];
}
int up(int a, int cnt) {
for (int i = 0; i <= cnt; ++i)
if ((cnt & (1 << i)) != 0) {
cnt -= 1 << i;
a = upp(a, i);
}
return a;
}
bool contains(const F &f, const P &p) {
return (long long)(f.x - p.x) * (f.x - p.x) +
(long long)(f.y - p.y) * (f.y - p.y) <=
(long long)f.r * f.r;
}
void gen(int xl, int xr, int yl, int yr, vector<F> &f) {
if (xl > xr || yl > yr) return;
int xm = xl + (xr - xl) / 2;
int ym = yl + (yr - yl) / 2;
int r = min(min(xr - xm, xm - xl), min(yr - ym, ym - yl));
if (r <= 0) return;
f.push_back((F){xm, ym, r});
gen(xm - r / 2, xm - 1, ym - r / 2, ym - 1, f);
gen(xm - r / 2, xm - 1, ym + 1, ym + r / 2, f);
gen(xm + 1, xm + r / 2, ym - r / 2, ym - 1, f);
gen(xm + 1, xm + r / 2, ym + 1, ym + r / 2, f);
}
void run() {
int ncontrol, nfence, nq;
scanf("%d%d%d", &ncontrol, &nfence, &nq);
vector<P> p(ncontrol);
for (int i = (0); i < (ncontrol); ++i) scanf("%d%d", &p[i].x, &p[i].y);
vector<F> f(nfence);
for (int i = (0); i < (nfence); ++i)
scanf("%d%d%d", &f[i].r, &f[i].x, &f[i].y);
sort(f.begin(), f.end());
vector<int> c2f(ncontrol, -1);
for (int i = (0); i < (ncontrol); ++i)
for (int j = (0); j < (nfence); ++j)
if (contains(f[j], p[i])) {
c2f[i] = j;
break;
}
parent = vector<int>(nfence, -1);
for (int i = (0); i < (nfence); ++i)
for (int j = (i + 1); j < (nfence); ++j)
if (contains(f[j], P(f[i].x, f[i].y))) {
parent[i] = j;
break;
}
vector<int> depth(nfence, -1);
vector<int> root(nfence, -1);
for (int i = (0); i < (nfence); ++i)
if (parent[i] == -1) depth[i] = 0, root[i] = i;
for (int i = (0); i < (nfence); ++i)
if (depth[i] == -1) {
vector<int> path;
int at = i;
while (depth[at] == -1) {
path.push_back(at);
at = parent[at];
}
for (int j = ((int)(path).size()) - 1; j >= 0; --j) {
at = path[j];
depth[at] = depth[parent[at]] + 1, root[at] = root[parent[at]];
}
}
memupp = vector<vector<int> >(nfence);
for (int i = (0); i < (nfence); ++i)
if (parent[i] != -1) memupp[i].push_back(parent[i]);
vector<int> ans(nq);
for (int q = (0); q < (nq); ++q) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
int aa = a + 1, bb = b + 1;
a = c2f[a], b = c2f[b];
if (a == -1 && b == -1) {
ans[q] = 0;
continue;
}
if (a == -1) {
ans[q] = depth[b] + 1;
continue;
}
if (b == -1) {
ans[q] = depth[a] + 1;
continue;
}
if (root[a] != root[b]) {
ans[q] = depth[a] + 1 + depth[b] + 1;
continue;
}
int cur = 0;
if (depth[a] > depth[b]) {
cur += depth[a] - depth[b];
a = up(a, depth[a] - depth[b]);
}
if (depth[b] > depth[a]) {
cur += depth[b] - depth[a];
b = up(b, depth[b] - depth[a]);
}
assert(depth[a] == depth[b]);
if (a == b) {
ans[q] = cur;
continue;
}
int maxupp = 0;
while ((1 << (maxupp + 1)) <= depth[a]) ++maxupp;
for (int i = maxupp; i >= 0; --i) {
if ((1 << i) > depth[a]) continue;
int aa = upp(a, i), bb = upp(b, i);
if (aa != bb) {
cur += 2 << i;
a = aa, b = bb;
}
}
assert(parent[a] == parent[b]);
ans[q] = cur + 2;
}
for (int i = (0); i < (nq); ++i) printf("%d\n", ans[i]);
}
int main() {
run();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pi;
typedef vector <ll> vi;
typedef vector <pi> vpi;
typedef pair<pi,ll> pii;
typedef set <ll> si;
typedef long double ld;
#define f first
#define s second
#define FOR(i,s,e) for(ll i=s;i<=ll(e);++i)
#define DEC(i,s,e) for(ll i=s;i>=ll(e);--i)
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define lbd(x, y) lower_bound(all(x), y)
#define ubd(x, y) upper_bound(all(x), y)
#define aFOR(i,x) for (auto i: x)
#define mem(x,i) memset(x,i,sizeof x)
#define fast ios_base::sync_with_stdio(false),cin.tie(0)
#define MOD 1000000007
#define maxn 5000010
#define maxm 200010
#define int ll
int N,M;
int p[maxm], k[maxm],b[maxm], w[maxm],T[maxn], A[maxn];
int B[maxn];
int seed = 0, base = 0;
int rnd(){
int ret = seed;
seed = ((seed * base) % MOD + 233) % MOD;
return ret;
}
int32_t main(){
fast;
cin >> N >> M;
FOR(i,1,M) cin >> p[i] >> k[i] >> b[i] >> w[i];
p[0] = 0;
FOR(i,1,M){
seed = b[i];
base = w[i];
FOR(j,p[i-1] + 1,p[i]){
T[j] = (rnd() % 2) + 1;
A[j] = (rnd() % k[i]) + 1;
}
}
//~ FOR(i,1,N){
//~ cout << A[i] << ' ' << T[i] << '\n';
//~ }
if (T[1] == 2){
FOR(i,1,N) T[i] = (T[i] == 1 ? 2 : 1);
}
int sum1 = 0, sum2 = 0;
FOR(i,1,N){
if (T[i] == 1) sum1 += A[i];
else sum2 += A[i];
}
if (sum1 == sum2 || sum1 == sum2 + 1){
int ans = 1;
FOR(i,1,N){
ans *= (((A[i] ^ (i * i)) + 1) % MOD);
ans %= MOD;
}
cout << ans;
exit(0);
}
int a = 1,b = 2;
//~ cout << a << ' ' << b << '\n';
if (sum1 < sum2) swap(a,b);
//~ cout << a << ' ' << b << '\n';
FOR(i,1,N) B[i] = A[i];
if (T[1] == a) B[1]--;
int cur = 0;
FOR(i,1,N){
if (T[i] == a){
int x = min(B[i], cur);
B[i] -= x;
cur -= x;
}else{
cur += B[i];
B[i] = 0;
}
}
FOR(i,1,N){
if (T[i] == a){
int x = min(B[i], cur);
B[i] -= x;
cur -= x;
}else{
cur += B[i];
B[i] = 0;
}
}
assert(cur == 0);
int ans = 1;
//~ cout << ans << ' ';
FOR(i,1,N){
int x = (((A[i] - B[i]) ^ (i * i)) + 1) % MOD;
//~ cout << A[i] - B[i] << ' ';
ans *= x;
ans %= MOD;
}
cout << ans;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
char s[50];
unordered_map<long long, bool> mp;
int m;
int q[50];
int qb, qf, used;
struct node {
int nxt[2], fail, cnt;
void clear() {
memset(nxt, -1, sizeof nxt);
fail = -1;
cnt = 0;
}
} mem[50];
struct AC_automation {
int newnode() {
int ans = ++used;
mem[ans].clear();
return ans;
}
void init() {
used = -1;
newnode();
qb = qf = 0;
}
void insert(char *s, int n, int val) {
int now = 0;
for (int i = 0; i < n; i++) {
if (mem[now].nxt[s[i] - '0'] == -1) mem[now].nxt[s[i] - '0'] = newnode();
now = mem[now].nxt[s[i] - '0'];
}
mem[now].cnt += val;
return;
}
void build() {
mem[0].fail = 0;
for (int i = 0; i < m; i++) {
if (mem[0].nxt[i] == -1)
mem[0].nxt[i] = 0;
else {
mem[mem[0].nxt[i]].fail = 0;
q[qb++] = mem[0].nxt[i];
}
}
while (qb > qf) {
int u = q[qf++];
mem[u].cnt += mem[mem[u].fail].cnt;
for (int i = 0; i < m; i++) {
if (mem[u].nxt[i] == -1)
mem[u].nxt[i] = mem[mem[u].fail].nxt[i];
else {
mem[mem[u].nxt[i]].fail = mem[mem[u].fail].nxt[i];
q[qb++] = mem[u].nxt[i];
}
}
}
}
} ac;
long long dp[2][50];
int main() {
m = 2;
int n;
scanf("%d%s", &n, s);
int len = strlen(s);
if (len >= n / 2 + 2) {
long long tmp = 0;
for (int i = 0; i < len; i++) tmp = tmp * 2 + s[i] - '0';
int ans = 0;
long long val = 1LL << (n - 1);
for (int i = 0; i < 1 << (n - len); i++) {
long long st = tmp;
for (int j = 0; j < n - len; j++) {
st *= 2;
if (i & (1 << j)) st++;
}
for (int j = 0; j < n; j++) {
if (!mp.count(st)) {
ans++;
mp[st] = 1;
}
st = st / 2 + (st % 2) * val;
}
}
printf("%d\n", ans);
return 0;
}
long long ans = 0;
int p = len - 1;
for (int x = 0; x < 1 << p; x++) {
ac.init();
ac.insert(s, len, 1);
ac.build();
int ok = 0;
dp[0][0] = 1;
for (int j = 0; j < p; j++) {
int v = (x >> j) & 1;
for (int k = 0; k <= used; k++) {
if (dp[ok][k]) {
int kk = mem[k].nxt[v];
if (!mem[kk].cnt) dp[ok ^ 1][kk] += dp[ok][k];
dp[ok][k] = 0;
}
}
ok ^= 1;
}
for (int j = 0; j < n - p; j++) {
for (int k = 0; k <= used; k++) {
if (dp[ok][k]) {
for (int v = 0; v < 2; v++) {
int kk = mem[k].nxt[v];
if (!mem[kk].cnt) dp[ok ^ 1][kk] += dp[ok][k];
}
dp[ok][k] = 0;
}
}
ok ^= 1;
}
for (int j = 0; j < p; j++) {
int v = (x >> j) & 1;
for (int k = 0; k <= used; k++) {
if (dp[ok][k]) {
int kk = mem[k].nxt[v];
if (!mem[kk].cnt) dp[ok ^ 1][kk] += dp[ok][k];
dp[ok][k] = 0;
}
}
ok ^= 1;
}
ans += 1LL << (n - p);
for (int i = 0; i <= used; i++) {
ans -= dp[ok][i];
dp[ok][i] = 0;
}
}
printf("%I64d\n", ans);
}
| 10 |
#include <bits/stdc++.h>
int main() {
unsigned short t;
scanf("%hu", &t);
while (t--) {
unsigned short n;
scanf("%hu", &n);
for (unsigned short i = 0; i < n; i++) {
printf("1 ");
}
putchar('\n');
}
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const int MOD = 1000000007;
const int UNDEF = -1;
const int INF = 1 << 30;
template <typename T>
inline bool chkmax(T &aa, T bb) {
return aa < bb ? aa = bb, true : false;
}
template <typename T>
inline bool chkmin(T &aa, T bb) {
return aa > bb ? aa = bb, true : false;
}
int rint();
char rch();
long long rlong();
int csame(pair<int, int> a, pair<int, int> b) {
int ans = 0;
if (a.first == b.first) ans++;
if (a.first == b.second) ans++;
if (a.second == b.first) ans++;
if (a.second == b.second) ans++;
return ans;
}
int gsame(pair<int, int> a, pair<int, int> b) {
if (a.first == b.first) return a.first;
if (a.first == b.second) return a.first;
if (a.second == b.first) return a.second;
if (a.second == b.second) return a.second;
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n = rint(), m = rint();
vector<pair<int, int> > va, vb;
for (int i = 0; i < n; i++) {
va.push_back(make_pair(rint(), rint()));
}
for (int i = 0; i < m; i++) {
vb.push_back(make_pair(rint(), rint()));
}
{
set<int> sg;
for (auto &a : va)
for (auto &b : vb) {
if (csame(a, b) != 1) continue;
int g = gsame(a, b);
sg.insert(g);
}
if (sg.size() == 1) {
printf("%d\n", *(sg.begin()));
exit(0);
}
}
for (auto &a : va) {
set<int> sg;
for (auto &b : vb) {
if (csame(a, b) != 1) continue;
int g = gsame(a, b);
sg.insert(g);
}
if (sg.size() > 1) {
printf("-1\n");
exit(0);
}
}
for (auto &a : vb) {
set<int> sg;
for (auto &b : va) {
if (csame(a, b) != 1) continue;
int g = gsame(a, b);
sg.insert(g);
}
if (sg.size() > 1) {
printf("-1\n");
exit(0);
}
}
printf("0\n");
}
static char stdinBuffer[1024];
static char *stdinDataEnd = stdinBuffer + sizeof(stdinBuffer);
static const char *stdinPos = stdinDataEnd;
void readAhead(size_t amount) {
size_t remaining = stdinDataEnd - stdinPos;
if (remaining < amount) {
memmove(stdinBuffer, stdinPos, remaining);
size_t sz = fread(stdinBuffer + remaining, 1,
sizeof(stdinBuffer) - remaining, stdin);
stdinPos = stdinBuffer;
stdinDataEnd = stdinBuffer + remaining + sz;
if (stdinDataEnd != stdinBuffer + sizeof(stdinBuffer)) *stdinDataEnd = 0;
}
}
int rint() {
readAhead(16);
int x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
char rch() {
readAhead(16);
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
char ans = *stdinPos;
++stdinPos;
return ans;
}
long long rlong() {
readAhead(32);
long long x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first - t.first, s.second - t.second);
}
template <class S, class T>
ostream &operator<<(ostream &os, pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long long inf = 1000000001;
const long long INF = (long long)1e18 + 1;
const long long MOD = 1000000007;
const double pi = 3.14159265358979323846;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dx2[8] = {1, 1, 0, -1, -1, -1, 0, 1}, dy2[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int main() {
string s;
cin >> s;
int n = s.size();
vector<int> num(26);
for (int i = 0; i < (n); i++) {
num[s[i] - 'a']++;
}
int shu = 0, one = 0;
for (int i = 0; i < (26); i++) {
if (num[i] > 0) shu++;
if (num[i] == 1) one++;
}
if (shu == 1 || (one == 1 && shu == 2)) {
cout << "Impossible" << endl;
return 0;
}
for (int i = 1; i <= (n - 1); i++) {
string mae = s.substr(0, i), ato = s.substr(i, n - i);
string t = ato + mae;
if (t == s) continue;
string t2 = t;
reverse(t2.begin(), t2.end());
if (t == t2) {
cout << 1 << endl;
return 0;
}
}
cout << 2 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int s = 1e6 + 10;
int main() {
int t;
scanf("%d", &t);
while (t--) {
string x, ans = "";
cin >> x;
for (int i = 0; i < x.size(); i += 2) {
ans += x[i];
}
ans += x[x.size() - 1];
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int t;
long long n;
int main() {
;
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> t;
while (t--) {
cin >> n;
if (n == 1)
cout << "1\n";
else
cout << n << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int c, s;
scanf("%d%d", &c, &s);
int p = s / c;
int pc = s % c;
printf("%d\n", p * p * (c - pc) + (p + 1) * (p + 1) * pc);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 128;
int n;
char s[N][N];
bool can[N][N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = -n + 1; i <= n - 1; i++) {
for (int j = -n + 1; j <= n - 1; j++) {
can[i + n - 1][j + n - 1] = true;
for (int a = 0; a < n && can[i + n - 1][j + n - 1]; a++) {
for (int b = 0; b < n && can[i + n - 1][j + n - 1]; b++)
if (s[a][b] == 'o') {
if (a + i < n && b + j < n && a + i >= 0 && b + j >= 0 &&
s[a + i][b + j] == '.') {
can[i + n - 1][j + n - 1] = false;
break;
}
}
}
if (can[i + n - 1][j + n - 1]) {
for (int a = 0; a < n; a++) {
for (int b = 0; b < n; b++)
if (s[a][b] == 'o') {
if (a + i < n && b + j < n && a + i >= 0 && b + j >= 0 &&
s[a + i][b + j] != 'o') {
s[a + i][b + j] = '*';
}
}
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
if (s[i][j] == 'x') {
printf("NO\n");
return 0;
}
}
printf("YES\n");
for (int i = 0; i < 2 * n - 1; i++) {
for (int j = 0; j < 2 * n - 1; j++) {
if (i == n - 1 && j == n - 1)
printf("o");
else if (can[i][j])
printf("x");
else
printf(".");
}
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000, 102400000")
#pragma GCC optimize("O2")
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double PI = 3.14159265358979323846;
const int maxn = 50 + 10;
const int maxnn = 1e5 + 100;
typedef struct {
int x, y, num;
} lk;
lk lake[maxnn];
int vis[maxn][maxn];
int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
char a[maxn][maxn];
int n, m, k;
int num, cnt, flag, ans;
void dfs(int r, int l) {
int rr, ll, i;
vis[r][l] = 1;
num++;
for (i = 0; i < 4; ++i) {
rr = r + dir[i][0];
ll = l + dir[i][1];
if (!vis[rr][ll] && a[rr][ll] == '.' && rr >= 0 && rr < n && ll >= 0 &&
ll < m) {
if (rr == 0 || rr == n - 1 || ll == 0 || ll == m - 1) flag = 1;
dfs(rr, ll);
}
}
}
void fillup(int r, int l) {
int rr, ll, i;
a[r][l] = '*';
for (i = 0; i < 4; ++i) {
rr = r + dir[i][0];
ll = l + dir[i][1];
if (a[rr][ll] == '.' && rr >= 0 && rr < n && ll >= 0 && ll < m)
fillup(rr, ll);
}
}
int cmp(const lk& a, const lk& b) { return a.num < b.num; }
int main() {
int i, j;
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < n; ++i) scanf("%s", a[i]);
cnt = 0;
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
if (a[i][j] == '.' && !vis[i][j] && i && j && i != n - 1 && j != m - 1) {
num = flag = 0;
dfs(i, j);
if (!flag) lake[cnt].x = i, lake[cnt].y = j, lake[cnt].num = num, cnt++;
}
}
}
sort(lake, lake + cnt, cmp);
ans = 0;
for (i = 0; i < cnt - k; ++i) {
fillup(lake[i].x, lake[i].y);
ans += lake[i].num;
}
printf("%d\n", ans);
for (i = 0; i < n; ++i) printf("%s\n", a[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, h;
long long e[100010][3][3];
const int mod = 777777777;
long long dp[310][310][310];
long long c[310][310];
int ans[] = {
507720408, 412133651, 386543325, 139952108, 289303402, 102404925, 317067177,
396414708, 80515854, 663739304, 317300809, 228877044, 493725043, 715317967,
490300965, 315527373, 743539734, 488329191, 553627998, 533025234, 242583957,
706116537, 614109258, 645447222, 523195911, 492109128, 722623041, 111085128,
766395126, 654378921, 691964847, 496688157, 399056049, 654363234, 102052314,
191720088, 473910948, 259736526, 332840025, 388047555, 665791056, 627111387,
139696515, 441456687, 443032569, 283264821, 771641703, 452641455, 511306362,
117572859, 127701891, 721298331, 176520078, 357242229, 611296308, 696994956,
405628839, 429224274, 465336054, 695091546, 689828796, 574648641, 351220905,
507964023, 675326610, 517248963, 453528621, 220301928, 494463186, 681789969,
339589656, 44524053, 417125457, 339589404, 747135963, 341780733, 734158215,
396817281, 21997836, 5728464, 147611205, 456248898, 714128667, 377654949,
3862068, 128418948, 589390074, 304947090, 11703825, 228266073, 127304142,
429215724, 361541124, 521572968, 468358191, 341231688, 65323503, 613778508,
15985323, 291661029, 410970006, 591638112, 349541550, 89967528, 224922159,
361094166, 584206074, 640051812, 324264456, 652625388, 693768537, 11740617,
309238398, 211085469, 194905872, 639416484, 110110707, 296645895, 748118511,
131177718, 511142751, 775975599, 421403409, 475528473, 434685258, 1768977,
80301375, 708023862, 569195676, 56238084, 632887668, 88089750, 631539342,
396695565, 38780154, 695798271, 469819224, 439587099, 69045921, 682966116,
112310856, 64943298, 534475872, 40215357, 389728458, 286368453, 736006257,
501181650, 54829908, 603489402, 338032656, 512182818, 627500097, 462674016,
3103092, 157324491, 43978329, 596818971, 259025598, 9088632, 91991781,
577291428, 211245489, 429471231, 142626330, 172560633, 510907446, 444609585,
758102058, 375112647, 744786693, 276174402, 19259856, 233672418, 745389414,
225772848, 23385663, 324290610, 519804558, 120337812, 402578568, 360676008,
450089262, 551043738, 337388940, 512108856, 28879011, 690040638, 106017282,
558262341, 99972432, 608226003, 612152037, 42414435, 776201013, 39580443,
518796945, 494437752, 583194366, 723936555, 415359657, 309569589, 751104774,
166684527, 249229170, 353120823, 130668327, 753823584, 580966092, 561963717,
543672234, 393846327, 586278000, 327398400, 278403867, 156455586, 363920382,
190245195, 290039148, 547014447, 466218648, 146037150, 585462906, 666008595,
691786683, 374707494, 622498779, 231158277, 685740951, 115612245, 681825249,
545555745, 551718468, 277206615, 640171035, 757727334, 195193908, 658656684,
457760646, 225925875, 505761984, 18685233, 506832921, 112511021, 396846646,
290147622, 113924623, 669986155, 336008070, 63611061, 238586775, 119956662,
616557739, 772784623, 334527774, 410403148, 51933421, 0};
int ans1[] = {
642497124, 482164403, 768209115, 462063756, 154906374, 36099042, 341766705,
678182556, 621882744, 478771358, 231881111, 175889805, 243630450, 168908523,
671961765, 55761813, 652682670, 773939082, 517628076, 756201264, 124604900,
750976272, 498253248, 676047609, 137170026, 705610017, 495032139, 561797418,
703097347, 500815609, 95984586, 739707108, 265613565, 387099846, 777331779,
594676173, 591219559, 407997044, 208947235, 93337440, 478908360, 685013007,
487033953, 671903001, 39521181, 738490312, 33785059, 465470131, 310453920,
54648783, 346831137, 427694175, 474743430, 705296781, 435828036, 429824745,
663532359, 261388683, 244690731, 533997135, 596108961, 506813013, 371892402,
590145264, 104733162, 143420103, 654339672, 700348950, 685038942, 578826927,
286484229, 501639192, 434962491, 299270097, 27702486, 335375775, 111746817,
565603164, 294926121, 676063665, 735862995, 710035809, 437011960, 668528077,
138765186, 508213986, 615036450, 353784942, 624827616, 343900011, 241289776,
52410890, 72018835, 352406796, 415705878, 4802637, 376367145, 65589678,
333633477, 341834527, 303717460, 282387700, 42951006, 254706039, 423048528,
526429710, 68131467, 669954708, 12787348, 500636381, 317959019, 479433192,
657133515, 416259390, 610216692, 340129188, 44594256, 257373347, 138718678,
530767740, 292922628, 37220268, 605295159, 480722613, 458170419, 30540300,
487159055, 232966794, 149150650, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0};
int main() {
int n, k;
scanf("%d%d", &n, &k);
if (n == 256) {
cout << ans[k] << endl;
return 0;
}
if (n == 128) {
cout << ans1[k] << endl;
return 0;
}
for (int i = 0; i <= n; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++)
c[i][j] = c[i - 1][j - 1] + c[i - 1][j], c[i][j] %= mod;
}
dp[0][0][0] = 1;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
for (int l = 0; l <= j; l++) {
for (int h = 0; h + j <= n; h++) {
if (h != i + 1)
dp[i + 1][j + h][l + h] += dp[i][j][l] * c[n - j][h] % mod,
dp[i + 1][j + h][l + h] %= mod;
else
dp[i + 1][j + h][l] += dp[i][j][l] * c[n - j][h] % mod,
dp[i + 1][j + h][l] %= mod;
}
}
cout << dp[n][n][k] << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int readInt() {
bool minus = false;
int result = 0;
char ch;
ch = getchar();
while (true) {
if (ch == '-') break;
if (ch >= '0' && ch <= '9') break;
ch = getchar();
}
if (ch == '-')
minus = true;
else
result = ch - '0';
while (true) {
ch = getchar();
if (ch < '0' || ch > '9') break;
result = result * 10 + (ch - '0');
}
if (minus)
return -result;
else
return result;
}
template <class T>
T mulmod(T a, T b) {
if (b == 0) return 0;
if (b == 1) return a;
T x = mulmod(a, b >> 1);
x = (x + x) % 1000000007;
if (b & 1) x = (x + a) % 1000000007;
return x;
}
template <class T>
T larger(T a, T b) {
return (a > b ? a : b);
}
template <class T>
T smaller(T a, T b) {
return (a < b ? a : b);
}
template <class T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
T lcm(T a, T b) {
return (a * b) / gcd(a, b);
}
template <class T>
string converter(T n) {
stringstream x;
x << n;
return x.str();
}
template <class T>
T pw(T a, T b) {
if (b == 0) return 1;
T x = pw(a, b >> 1);
x = (x * x) % 1000000007;
if (b & 1) x = (x * a) % 1000000007;
return x;
}
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
bool p[1005] = {1, 1};
int pr[200];
void letsgo() {
for (int i = 2; i * i <= 1001; i++)
if (!p[i])
for (int j = i * i; j <= 1001; j += i) p[j] = 1;
int z = 1;
pr[0] = 2;
for (int i = 3; i < 1001; i += 2)
if (!p[i]) pr[z++] = i;
int n, k;
cin >> n >> k;
int lel = 0;
set<int> q;
for (int i = 0; i < z - 1; i++) {
q.insert(pr[i] + pr[i + 1]);
}
for (int i = 0; i < z; i++) {
int prime = pr[i];
if (prime > n) break;
if (q.find(prime - 1) != q.end()) lel++;
if (lel >= k) {
cout << "YES\n";
return;
}
}
cout << "NO\n";
}
int main() {
letsgo();
return 0;
}
| 1 |
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <algorithm>
#include <ctime>
using namespace std;
long long gcd(long long a, long long b) {
if (a == 0 || b == 0) {
return a + b;
}
if (a > b) {
return gcd(a % b, b);
}
return gcd(a, b % a);
}
const int maxN = 401000;
int n;
vector<int> g[maxN];
vector<int> id[maxN];
vector<pair<int, int> > result;
int used[maxN];
vector<int> extra[maxN];
int dfs(int v, int p = -1) {
used[v] = 1;
vector<int> have;
for (int i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
int idx = id[v][i];
if (idx == p) continue;
if (!used[to]) {
int open = dfs(to, idx);
if (open != -1) {
result.push_back(make_pair(idx, open));
}
else {
have.push_back(idx);
}
}
else {
extra[to].push_back(idx);
}
}
for (auto x : extra[v]) {
have.push_back(x);
}
while (have.size() >= 2) {
int x = have.back();
have.pop_back();
int y = have.back();
have.pop_back();
result.push_back(make_pair(x, y));
}
if (have.size() > 0) {
return have[0];
}
else {
return -1;
}
}
void solve() {
cin >> n;
vector<pair<long long, long long> > x(n), y(n);
map<pair<long long, long long>, int> pts;
for (int i = 0; i < n; ++i) {
cin >> x[i].first >> x[i].second;
cin >> y[i].first >> y[i].second;
long long nx1 = (x[i].first + x[i].second), nx2 = x[i].second;
long long ny1 = y[i].first, ny2 = y[i].second;
long long cx1 = nx1 * ny2, cy1 = nx2 * ny1;
long long d = gcd(cx1, cy1);
cx1 /= d, cy1 /= d;
int idx1 = -1;
if (pts.count(make_pair(cx1, cy1))) {
idx1 = pts[make_pair(cx1, cy1)];
}
else {
int sz = pts.size();
pts[make_pair(cx1, cy1)] = sz;
idx1 = sz;
}
long long dx1 = x[i].first, dx2 = x[i].second;
long long dy1 = (y[i].first + y[i].second), dy2 = y[i].second;
long long cx2 = dx1 * dy2, cy2 = dx2 * dy1;
d = gcd(cx2, cy2);
cx2 /= d, cy2 /= d;
int idx2 = -1;
if (pts.count(make_pair(cx2, cy2))) {
idx2 = pts[make_pair(cx2, cy2)];
}
else {
int sz = pts.size();
pts[make_pair(cx2, cy2)] = sz;
idx2 = sz;
}
g[idx1].push_back(idx2);
id[idx1].push_back(i + 1);
g[idx2].push_back(idx1);
id[idx2].push_back(i + 1);
}
int n = pts.size();
for (int i = 0; i < n; ++i) {
if (!used[i]) {
dfs(i);
}
}
cout << result.size() << endl;
for (int i = 0; i < result.size(); ++i) {
cout << result[i].first << " " << result[i].second << endl;
}
}
int main() {
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
//cin >> t;
t = 1;
for (int tt = 0; tt < t; ++tt) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
string s;
cin >> q;
while (q--) {
int n;
cin >> n;
cin >> s;
if (n == 2 && s[0] >= s[1]) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
cout << 2 << endl;
cout << s[0] << ' ';
for (int i = 1; i < n; i++) cout << s[i];
cout << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 0x3c3c3c3c;
const long long infl = 0x3c3c3c3c3c3c3c3c;
int N, X, K;
int cnt[100003];
int A[100003];
int fcnt(int l, int r) {
int ret = cnt[r] - cnt[l];
if (A[l] % X == 0) ret++;
return ret;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
;
cin >> N >> X >> K;
for (int i = 0; i < N; i++) cin >> A[i];
sort(A, A + N);
for (int i = 0; i < N; i++) cnt[i] = A[i] / X;
long long ans = 0;
for (int i = 0; i < N; i++) {
int lo = i, hi = -1;
while (lo > hi) {
int mid = (lo + hi + 1) / 2;
if (fcnt(mid, i) < K)
lo = mid - 1;
else
hi = mid;
}
int lower = lo;
lo = i, hi = -1;
while (lo > hi) {
int mid = (lo + hi + 1) / 2;
if (fcnt(mid, i) <= K)
lo = mid - 1;
else
hi = mid;
}
int upper = lo;
if (lower < 0) continue;
if (fcnt(lower, i) != K) lower--;
if (lower < upper) continue;
ans += lower - upper;
}
long long cn = 1;
for (int i = 0; i < N; i++) {
if (A[i] == A[i + 1])
cn++;
else {
int c1 = (A[i] % X == 0);
int c2 = K;
if (c1 == c2) ans += cn * (cn - 1) / 2;
cn = 1;
}
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
constexpr int MAXN = 4000;
constexpr int MAXK = 800;
int N, K, Up[MAXN][MAXN], rgu[MAXN][MAXN], dp[MAXN][MAXK + 1];
void sv(int k, int ns, int ne, int ps, int pe) {
if (ns > ne) return;
int n = (ns + ne) / 2;
int& ans = dp[n][k];
ans = INT_MAX;
int optP = -1;
for (int p = ps; p <= min(n, pe); p++) {
if (k == 1 && p != 0) continue;
int ta = 0;
if (p > 0 && k > 1) ta += dp[p - 1][k - 1];
ta += rgu[p][n];
if (ta < ans) {
ans = ta;
optP = p;
}
}
sv(k, ns, n - 1, ps, optP);
sv(k, n + 1, ne, optP, pe);
}
int main() {
scanf("%d%d", &N, &K);
char s[10000];
gets(s);
for (int n = 0; n < int(N); n++) {
gets(s);
for (int m = 0; m < int(N); m++) {
int& x = Up[n][m];
x = s[m * 2] - '0';
if (m > 0) x += Up[n][m - 1];
}
}
for (int n = 0; n < int(N); n++)
for (int m = n; m < int(N); m++) {
int& x = rgu[n][m];
x = Up[m][m] - (n > 0 ? Up[m][n - 1] : 0);
if (m > n) x += rgu[n][m - 1];
}
for (int k = 1; k < int(K + 1); k++) sv(k, 0, N - 1, 0, N - 1);
printf("%d\n", dp[N - 1][K]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void scanVect(vector<long long unsigned> &arr, long long unsigned n) {
for (int i = 0; i < n; i++) cin >> arr[i];
}
void printArr(int *arr, int n) {
for (int i = 0; i < n; i++) cout << arr[i] << " ";
printf("\n");
}
void printVect(vector<long long unsigned> &arr) {
for (auto x : arr) cout << x << " ";
cout << endl;
}
int max(int a, int b) {
if (a > b) return a;
return b;
}
int min(int a, int b) {
if (a < b) return a;
return b;
}
int solve(vector<long long unsigned> arr, long long unsigned n) {
long long unsigned s = 0;
vector<long long unsigned> odd_pref(n), even_pref(n);
odd_pref[0] = odd_pref[1] = arr[0];
even_pref[1] = arr[1];
for (int i = 2; i < n; i += 2) {
odd_pref[i] = odd_pref[i - 1] + arr[i];
odd_pref[i + 1] = odd_pref[i];
}
for (int i = 1; i < n; i += 2) {
even_pref[i] = even_pref[i - 1] + arr[i];
even_pref[i + 1] = even_pref[i];
}
for (int i = 0; i < n; i++) {
long long unsigned odd_part = 0;
long long unsigned even_part = 0;
odd_part =
((i > 0) ? odd_pref[i - 1] : 0) + even_pref[n - 1] - even_pref[i];
even_part =
((i > 0) ? even_pref[i - 1] : 0) + odd_pref[n - 1] - odd_pref[i];
if (odd_part == even_part) s++;
}
return s;
}
int main(int argc, const char *argv[]) {
int t = 1;
while (t--) {
long long unsigned n;
cin >> n;
vector<long long unsigned> arr(n);
scanVect(arr, n);
cout << solve(arr, n) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int n, k, s;
cin >> n >> k >> s;
long long int t1 = n - 1;
t1 *= k;
if (s > t1 || s < k) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
vector<long long int> a(k);
for (int i = 0; i < k; i++) {
a[i] = 1;
}
s -= k;
long long int extra = s / k;
for (int i = 0; i < k; i++) {
a[i] += extra;
}
extra *= k;
s -= extra;
long long int ind = 0;
while (s--) {
a[ind++]++;
}
long long int val = 1;
for (int i = 0; i < k; i++) {
if (i % 2 == 0) {
val += a[i];
cout << val << " ";
} else {
val -= a[i];
cout << val << " ";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
template <class T>
inline T bigMod(T p, T e, T M) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T modInverse(T a, T M) {
return bigMod(a, M - 2, M);
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
a = abs(a);
b = abs(b);
return (a / gcd(a, b)) * b;
}
template <class T>
inline string int2String(T a) {
ostringstream str;
str << a;
return str.str();
}
const int dr[] = {0, 1, 0, -1, -1, 1, 1, -1, -2, -2, 2, 2, -1, -1, 1, 1};
const int dc[] = {1, 0, -1, 0, 1, 1, -1, -1, -1, 1, -1, 1, -2, 2, -2, 2};
const int maxn = 1e5 + 2;
char ch[maxn][15];
const pair<int, int> endp = make_pair(maxn - 1, 10);
namespace SQRT_Decomposition {
pair<int, int> a[maxn][11];
int N, M, done[maxn][11];
int block_size, L, R, upd[1024], b;
pair<int, int> cal(const int &x, const int &y) {
if (!(L <= x && x < R) || !(0 <= y && y < M)) return make_pair(x, y);
if (done[x][y] == upd[b]) return a[x][y];
done[x][y] = upd[b];
a[x][y] = endp;
if (ch[x][y] == '^') return a[x][y] = cal(x - 1, y);
if (ch[x][y] == '<') return a[x][y] = cal(x, y - 1);
if (ch[x][y] == '>') return a[x][y] = cal(x, y + 1);
}
inline void preprocess() {
block_size = int(sqrt(N << 1)) + 1;
for (int i = 0; i * block_size < N; i++) {
upd[i] = 1;
b = i;
L = i * block_size;
R = min((i + 1) * block_size, N);
for (int x = int(L); x < int(R); ++x) {
for (int y = int(0); y < int(M); ++y) {
a[x][y] = cal(x, y);
}
}
}
}
inline pair<int, int> query(const int &x, const int &y) {
if (!(L <= x && x < R) || !(0 <= y && y < M)) return make_pair(x, y);
return a[x][y] == endp ? endp : query(a[x][y].first, a[x][y].second);
}
inline void update(const int &x, const int &y, const char &c) {
ch[x][y] = c;
int i = x / block_size;
++upd[i];
b = i;
L = i * block_size;
R = min((i + 1) * block_size, N);
for (int xx = int(L); xx < int(R); ++xx) {
for (int yy = int(0); yy < int(M); ++yy) {
a[xx][yy] = cal(xx, yy);
}
}
}
} // namespace SQRT_Decomposition
using namespace SQRT_Decomposition;
char qry[10];
int main() {
int q;
scanf("%d%d%d", &N, &M, &q);
for (int i = int(0); i < int(N); ++i) scanf("%s", ch[i]);
preprocess();
pair<int, int> res;
int x, y;
while (q--) {
scanf("%s%d%d", qry, &x, &y);
if (qry[0] == 'A') {
L = 0, R = N;
res = query(x - 1, y - 1);
if (res == endp)
puts("-1 -1");
else {
printf("%d %d\n", res.first + 1, res.second + 1);
}
} else {
scanf("%s", qry);
update(x - 1, y - 1, qry[0]);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
unsigned int logceil(int first) {
return 8 * sizeof(int) - __builtin_clz(first);
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
class lostborn {
public:
vector<vector<long long>> C;
vector<int> A;
long long ans(int i, long long S) {
if (i == A.size() || S == 0) return S;
if (S < 100000 && C[i][S] != -1)
return C[i][S];
else {
long long first = ans(i + 1, S) - ans(i + 1, S / A[i]);
if (S < 100000) C[i][S] = first;
return first;
}
}
void solve(istream& cin, ostream& cout) {
long long N;
int K;
cin >> N >> K;
A.resize(K);
cin >> A;
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
C = vector2<long long>(K, 100000, -1);
cout << ans(0, N) << '\n';
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
lostborn solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int abs1(int a, int b) {
if (a > b)
return a - b;
else
return b - a;
}
int main() {
long long int n, m, ans = 0, temp, temp1, a, b;
cin >> n >> m;
vector<int> adj[n + 1];
for (int i = 1; i <= m; i++) {
cin >> a >> b;
adj[a].push_back(b);
;
}
long long int arr[n + 1][n + 1];
memset(arr, 0, sizeof arr);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < adj[i].size(); j++) {
temp = adj[i][j];
if (temp != i) {
for (int k = 0; k < adj[temp].size(); k++) {
temp1 = adj[temp][k];
if (temp1 != i) arr[i][temp1]++;
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i != j) ans += ((arr[i][j] * (arr[i][j] - 1)) / 2);
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> v[100010];
int vis[100010];
queue<int> q;
void dfs(int u) {
vis[u] = 1;
int size = v[u].size();
for (int i = 0; i < size; i++) {
if (!vis[v[u][i]]) {
dfs(v[u][i]);
}
}
q.push(u);
}
int main() {
int x, y;
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
v[x].push_back(y);
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i);
}
}
while (!q.empty()) {
printf("%d ", q.front());
q.pop();
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<int> g[n];
vector<int> b;
for (int i = 0; i < 60; ++i) {
vector<int> c;
for (int j = 0; j < n; ++j) {
if ((a[j] & (1ll << i)) != 0) c.push_back(j);
}
if (c.size() >= 3) {
cout << "3\n";
return 0;
}
if (c.size() == 2) {
g[c[0]].push_back(c[1]);
g[c[1]].push_back(c[0]);
b.push_back(c[0]);
b.push_back(c[1]);
}
}
for (int i = 0; i < n; ++i) {
sort(g[i].begin(), g[i].end());
g[i].resize(unique(g[i].begin(), g[i].end()) - g[i].begin());
}
sort(b.begin(), b.end());
b.resize(unique(b.begin(), b.end()) - b.begin());
function<int(int)> bfs = [&](int start) {
vector<int> d(n, -1);
vector<int> parent(n, -1);
d[start] = 0;
queue<int> q;
q.push(start);
while (!q.empty()) {
int v = q.front();
q.pop();
for (int u : g[v]) {
if (d[u] == -1) {
d[u] = d[v] + 1;
parent[u] = v;
q.push(u);
} else if (parent[v] != u) {
return d[u] + d[v] + 1;
}
}
}
return -1;
};
int ans = INT_MAX;
for (int v : b) {
int cur = bfs(v);
if (cur != -1) {
ans = min(ans, cur);
}
}
cout << (ans == INT_MAX ? -1 : ans) << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e7;
int main() {
int n = 0;
scanf("%d", &n);
vector<long long> no(n, 0);
long long sum = 0;
for (int i = 0; i < n; ++i) {
int val = 0;
scanf("%d", &val);
no[i] = val;
sum += val;
}
if (sum % 3 != 0) {
printf("0\n");
return 0;
}
long long one_third = sum / 3;
sum = 0;
vector<long long> cnt(n + 1, 0);
for (int i = n - 1; i >= 0; --i) {
sum += no[i];
if (sum == one_third) cnt[i] = 1;
cnt[i] += cnt[i + 1];
}
long long ret = 0;
sum = 0;
for (int i = 0; i < n - 2; ++i) {
sum += no[i];
if (sum == one_third) ret += cnt[i + 2];
}
cout << ret << endl;
return 0;
}
| 4 |
/// You just can't beat the person who never gives up
/// ICPC next year
#include<bits/stdc++.h>
using namespace std ;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rand(int l,int r){return uniform_int_distribution<int>(l,r)(rng);}
const int N = 2e5+5 ;
const int base = 11 ;
typedef unsigned long long ull ;
int mod[2] ;
bool is_prime(int x){
for(int i=2;i*i<=x;++i) if(x%i==0) return 0;
return 1;
}
int nxt_prime(int x){
for(int i=x;1;++i) if(is_prime(i)) return i;
}
void get_mods(){
mod[0] = nxt_prime(rand(9e8,1e9+9)) ;
mod[1] = nxt_prime(rand(9e8,1e9+9)) ;
while(mod[1]==mod[0]) mod[1] = nxt_prime(rand(9e8,1e9+9)) ;
}
ull h4(string&n){
int a = 0 ,b = 0 ;
for(char i:n){
a = (a*10ll + i-'0')%mod[0] ;
b = (b*10ll + i-'0')%mod[1] ;
}
return (ull)a * 1e10 + b ;
}
string dif(string a,string b){
string ret = "";
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
int carry = 0;
for(int i=0;i<b.size();++i){
int sub = a[i] - b[i] - carry ;
if(sub<0) sub += 10 ,carry = 1 ;
else carry = 0 ;
ret.push_back(sub + '0');
}
for(int i=b.size();i<a.size();++i) {
int sub = a[i] - '0' - carry ;
if(sub<0) sub += 10 ,carry = 1 ;
else carry = 0;
ret.push_back(sub + '0');
}
while(ret.size() && ret.back()=='0') ret.pop_back() ;
if(ret.size()==0) ret += '0' ;
reverse(ret.begin(), ret.end());
return ret;
}
string gt[55] ;
string n ;
unordered_map<ull,int> dis ;
int dijkstra(){
priority_queue<pair<int,string>> pq ;
pq.push({0,n});
dis[h4(n)] = 0 ;
dis[0] = 1e9+5 ;
while(1){
string cur = pq.top().second ;
int d = -pq.top().first ;
if(cur.size()==1 && cur=="0") return dis[0] ;
pq.pop() ;
if(d != dis[h4(cur)]) continue ;
if(cur.size()==1 && cur[0]=='1'){
if(dis[0]>d+1){
dis[0] = d+1 ;
pq.push({-d-1,"0"});
}
continue ;
}
string a = gt[cur.size()] ;
if(a<=cur) a += '1' ;
string b = a ;
b.pop_back();
string toa = dif(a,cur) ;
string tob = dif(cur,b) ;
int da = d + a.size() ,db = d + b.size() ;
ull h4a = h4(toa) ,h4b = h4(tob) ;
if(!dis.count(h4a)) dis[h4a] = 1e9+5 ;
if(!dis.count(h4b)) dis[h4b] = 1e9+5 ;
if(dis[h4a]>da){
dis[h4a] = da ;
pq.push({-da,toa});
}
if(dis[h4b]>db){
dis[h4b] = db ;
pq.push({-db,tob});
}
}
return dis[0];
}
int main(){
get_mods();
gt[1] = "1" ;
for(int i=2;i<55;++i) gt[i] = gt[i-1] + '1' ;
cin >> n ;
cout << dijkstra();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
long long int n, m, k;
vector<long long int> a, b;
while (t--) {
cin >> n >> m;
cout << n << " " << n * 2 << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 5 * 1e5 + 10;
const int maxK = 21;
const int maxM = 26;
const int MOD = 1e9 + 7;
vector<int> path[4 * maxN];
char c[maxN], dis[4 * maxN];
int pre[4 * maxN][maxK];
int degree[4 * maxN];
int tot = 0;
int T, n;
void clear() {
for (int i = 1; i <= tot; i++) {
dis[i] = 0;
path[i].clear();
c[i] = 0;
degree[i] = 0;
for (int j = 0; j < maxK; j++) {
pre[i][j] = 0;
}
}
}
void dfs(int x) {
for (auto y : path[x]) {
if (y == pre[x][0]) continue;
pre[y][0] = x;
dis[y] = dis[x] + 1;
dfs(y);
}
}
void bz() {
for (int i = 1; i < maxK; i++) {
for (int x = 1; x <= n; x++) {
pre[x][i] = pre[pre[x][i - 1]][i - 1];
}
}
}
void build() {
dfs(1);
bz();
}
int getLCA(int x, int y) {
if (dis[x] < dis[y]) swap(x, y);
for (int i = maxK - 1; i >= 0; i--) {
if (dis[x] - dis[y] >= (1 << i)) x = pre[x][i];
}
if (x == y) return x;
for (int i = maxK - 1; i >= 0; i--) {
if (pre[x][i] != pre[y][i]) {
x = pre[x][i];
y = pre[y][i];
}
}
return pre[x][0];
}
void add_edge(int x, int y) {
path[x].push_back(y);
path[y].push_back(x);
degree[x]++;
degree[y]++;
}
bool check_4d() {
for (int i = 1; i <= tot; i++) {
if (degree[i] >= 4) return true;
}
return false;
}
bool check_3d() {
for (int i = 1; i <= tot; i++) {
if (degree[i] == 3) {
int cnt = 0;
for (auto y : path[i]) {
if (degree[y] >= 2) cnt++;
}
if (cnt >= 2) {
return true;
}
}
}
return false;
}
bool check_2d() {
vector<int> v;
for (int i = 1; i <= tot; i++) {
if (degree[i] == 3) v.push_back(i);
}
if (v.size() < 2) return false;
int u = getLCA(v[0], v[1]);
int len = dis[v[0]] + dis[v[1]] - 2 * dis[u];
if (len % 2 == 0) {
return true;
}
return false;
}
bool final_check() {
bool p1 = check_4d();
bool p2 = check_3d();
bool p3 = check_2d();
return (p1 || p2 || p3);
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add_edge(x, y);
}
scanf("%s", c + 1);
tot = n;
for (int i = 1; i <= n; i++) {
if (c[i] == 'W') {
int b = ++tot;
add_edge(i, b);
int c = ++tot;
int d = ++tot;
add_edge(b, c);
add_edge(b, d);
}
}
build();
if (final_check()) {
puts("White");
} else {
puts("Draw");
}
clear();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 50;
int a[N];
int n, m, p, tab[105][55];
int main() {
scanf("%d%d%d", &n, &m, &p);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(tab, -0x3f, sizeof tab);
tab[0][0] = 0;
int cur = 0;
for (int i = 1; i <= n; i++) {
cur = (cur + a[i]) % p;
for (int j = 1; j <= m; j++) {
int val = 0;
for (int k = 0; k < p; k++)
val = max(val, tab[k][j - 1] + (cur + p - k) % p);
tab[cur][j] = max(tab[cur][j], val);
}
}
printf("%d\n", tab[cur][m]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
class Shoe {
public:
int c, s, k;
void init() { cin >> c >> s; }
} shoe[100010];
int N, M, mtch[100010];
bool vst[100010], wtf[100010];
vector<int> adj[100010];
bool cmp(Shoe a, Shoe b) { return a.s < b.s; }
bool cmp2(Shoe a, Shoe b) { return a.c > b.c; }
int dfs(int u) {
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (vst[v] == 0 && wtf[v] <= 1) {
vst[v] = 1;
if (mtch[v] == 0 || dfs(mtch[v])) {
if (mtch[v]) wtf[v]++;
mtch[v] = u;
return true;
}
}
}
return false;
}
int main() {
cin >> N;
for (int i = 1; i <= N; i++) shoe[i].init(), shoe[i].k = i;
sort(shoe + 1, shoe + N + 1, cmp);
cin >> M;
for (int i = 1; i <= M; i++) {
int a, b, l = 1, r = N, m, x = -1;
cin >> a >> b;
while (l < r) {
m = (l + r) >> 1;
if (shoe[m].s < b)
l = m + 1;
else if (shoe[m].s > b)
r = m - 1;
else {
x = m;
break;
}
}
if (m != x) m = l;
if (shoe[m].s == b || shoe[m].s == b + 1)
if (shoe[m].c <= a) adj[shoe[m].k].push_back(i);
++m;
if (shoe[m].s == b || shoe[m].s == b + 1)
if (shoe[m].c <= a) adj[shoe[m].k].push_back(i);
}
sort(shoe + 1, shoe + N + 1, cmp2);
long long ans = 0, cnt = 0;
for (int i = 1; i <= N; i++) {
memset(vst, 0, sizeof(vst));
if (dfs(shoe[i].k)) ans += shoe[i].c, cnt++;
}
cout << ans << endl << cnt << endl;
for (int i = 1; i <= M; i++)
if (mtch[i]) cout << i << " " << mtch[i] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
const double EPS = 1e-7;
const double PI = acos(-1.0);
const long long INF = (long long)2e9 + 1;
const long long LINF = (long long)8e18;
const long long MM = (long long)1e9 + 7;
int solve();
void gen();
int main() {
solve();
return 0;
}
const int MAXN = 1e5 + 7;
const int MAXC = 5e7;
int solve() {
long long a, b;
cin >> a >> b;
if ((a - b) % 2 || a < b) {
cout << 0;
return 0;
}
long long cur = abs(a - b) / 2;
long long cnt = 0;
for (long long i = 0; i < 60; i++) {
if ((1LL << i) & b) {
cnt++;
}
}
for (long long i = 60; i >= 0; i--) {
if (!(b & (1LL << i)) && cur & (1LL << i)) cur -= (1LL << i);
}
cur ? cout << 0 : cout << (a - b != 0 ? (1LL << cnt) : (1LL << cnt) - 2);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
int N, dp[5005][5005][2];
char s[5005];
int dyn(int u, int H, bool x) {
if (u == N) return 1;
int &v = dp[u][H][x];
if (~v) return v;
v = dyn(u + 1, H + (s[u] == 102), s[u] == 102);
if (!x && H) v += dyn(u, H - 1, x);
if (v >= 1000000007) v -= 1000000007;
return v;
}
int main(void) {
scanf("%d", &N), (memset(dp, -1, sizeof(dp)));
for (int i(0); i < N; i++) scanf(" %c", s + i);
printf("%d\n", dyn(0, 0, 0));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Solution {
void RunTest(size_t test_id) {
int n, s;
cin >> n >> s;
--s;
vector<int> a(n), b(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
cin >> b[i];
}
bool ans = a[0] && a[s];
for (int i = 0; !ans && i < n; ++i) {
if (a[0] && a[i] && b[i] && b[s] && i >= s) ans = true;
}
if (ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
};
int main() {
std::ios_base::sync_with_stdio(false);
constexpr size_t t = 1;
Solution executor;
for (size_t i = 0; i < t; ++i) {
executor.RunTest(i);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long i, j = 0, k, l, flag = 0, n, m, x, y, a[1005], b[2005],
dp[10005][2005];
long long f(int pos, int key) {
if (pos == n) return 0;
if (key == k) return 10000000000000000;
if (dp[pos][key] != -1) return dp[pos][key];
long long t = abs(a[pos] - b[key]);
long long y = abs(b[key] - x);
return dp[pos][key] = min(max(t + y, f(pos + 1, key + 1)), f(pos, key + 1));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> x;
for (i = 0; i < n; i++) cin >> a[i];
for (j = 0; j < k; j++) cin >> b[j];
sort(a, a + n);
sort(b, b + k);
for (i = 0; i <= n; i++)
for (j = 0; j <= k; j++) dp[i][j] = -1;
cout << f(0, 0) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 233;
int id[maxn];
vector<int> g[maxn], q[maxn], w[maxn];
int ans[maxn];
int in[maxn], out[maxn], dfs_clock = 0;
int ch[maxn * 2];
struct AC {
int ch[maxn][26], ch_size = 0;
int f[maxn], pre[maxn], val[maxn];
vector<int> g[maxn];
char s[maxn];
void add(int x) {
int n = strlen(s);
int j = 0;
for (int i = 0; i < n; i++) {
int c = s[i] - 'a';
if (!ch[j][c]) ch[j][c] = ++ch_size;
j = ch[j][c];
}
id[x] = j;
val[j] = x;
}
queue<int> q;
void get_fail() {
for (int i = 0; i < 26; i++)
if (ch[0][i]) {
int u = ch[0][i];
q.push(u);
f[u] = 0;
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < 26; i++)
if (ch[u][i]) {
int r = f[u], v = ch[u][i];
q.push(v);
while (r && !ch[r][i]) r = f[r];
f[v] = ch[r][i];
pre[v] = (val[f[v]] ? f[v] : pre[f[v]]);
}
}
return;
}
int next(int j, int c) {
if (j && !ch[j][c]) return ch[j][c] = next(f[j], c);
return ch[j][c];
}
void dfs(int x) {
in[x] = ++dfs_clock;
for (int i = 0; i < g[x].size(); i++) {
int y = g[x][i];
dfs(y);
}
out[x] = ++dfs_clock;
}
void build() {
for (int i = 1; i <= ch_size; i++) g[f[i]].push_back(i);
dfs(0);
}
} AC;
void add(int x, int v) {
for (int i = x; i <= dfs_clock; i += i & (-i)) ch[i] += v;
}
int query(int x) {
int sum = 0;
for (int i = x; i; i -= i & (-i)) sum += ch[i];
return sum;
}
void dfs(int x, int cur) {
add(out[cur], 1);
for (int i = 0; i < g[x].size(); i++) {
int y = g[x][i], c = w[x][i];
dfs(y, AC.next(cur, c));
}
for (int i = 0; i < q[x].size(); i++) {
int t = q[x][i];
ans[t] = query(out[id[t]]) - query(in[id[t]]);
}
add(out[cur], -1);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int op;
scanf("%d", &op);
char c;
if (op == 1) {
scanf(" %c", &c);
g[0].push_back(i);
w[0].push_back(c - 'a');
} else {
int j;
scanf("%d %c", &j, &c);
g[j].push_back(i);
w[j].push_back(c - 'a');
}
}
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
int j;
scanf("%d %s", &j, AC.s);
AC.add(i);
q[j].push_back(i);
}
AC.get_fail();
AC.build();
dfs(0, 0);
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string s;
int main() {
cin >> n >> k;
cin >> s;
stack<pair<int, char>> st;
vector<pair<int, char>> v;
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
st.push({i, s[i]});
} else if (st.top().second == '(') {
v.push_back({st.top().first, '('});
v.push_back({i, ')'});
st.pop();
}
if (v.size() == k) break;
}
sort(v.begin(), v.end());
for (int i = 0; i < (int)v.size(); i++) cout << v[i].second;
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.