solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, k;
bool checkSurvive(char f[], char s[], int pos, int flooded) {
if (pos < 0) {
return false;
}
if (flooded >= pos) {
return false;
}
if (pos > n - 1) {
return true;
}
if (f[pos] != '-') {
return false;
}
f[pos] = 'a';
bool jump = checkSurvive(s, f, pos + k, flooded + 1);
if (jump) {
return true;
}
bool next = checkSurvive(f, s, pos + 1, flooded + 1);
if (next) {
return true;
}
bool prev = checkSurvive(f, s, pos - 1, flooded + 1);
if (prev) {
return true;
}
return false;
}
int main() {
cin >> n >> k;
char first[n + 5];
char second[n + 5];
cin >> first;
cin >> second;
bool f = checkSurvive(first, second, 0, -1);
if (f) {
cout << "YES" << '\n';
} else {
cout << "NO" << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, mod, m;
scanf("%d%d%d", &a, &b, &mod);
for (int i = 0; i <= a && i < mod; i++) {
m = (1000000000LL * i) % mod;
if ((m > 0) && (m + b < mod)) {
printf("1 %09d\n", i);
return 0;
}
}
cout << 2 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int GC(long long int a, long long int b) {
if (b == 0)
return a;
else
return GC(b, a % b);
}
long long int inv_gc(long long int a, long long int b) {
return a / GC(a, b) * b;
}
long long int Ceil(long long int a, long long int b) {
return a / b + (a % b != 0);
}
long long int fastModExp(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b = b >> 1;
}
return res;
}
map<int, int> par, rk;
void make_set(int n) {
for (int i = 1; i <= n; i++) {
par[i] = i;
rk[i] = 1;
}
}
int find(int x) {
if (x == par[x]) return x;
int p = find(par[x]);
par[x] = p;
return p;
}
int uni(int x, int y) {
int p1 = find(x);
int p2 = find(y);
if (p1 == p2) return 0;
if (rk[p1] > rk[p2]) {
par[p2] = p1;
rk[p1] += rk[p2];
} else {
par[p1] = p2;
rk[p2] += rk[p1];
}
return 1;
}
bool sortinrev(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first > b.first);
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, x, l, r;
cin >> n;
int v[n + 1], sum[n + 1];
sum[0] = 0;
for (int i = 1; i <= n; i++) {
cin >> v[i];
sum[i] = sum[i - 1] + v[i];
}
int ans[n + 1];
ans[1] = 0;
for (int i = 2; i <= n; i++) {
ans[i] = sum[i] / 10;
}
int t;
cin >> t;
while (t--) {
cin >> l >> r;
cout << (sum[r] - sum[l - 1]) / 10 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct A {
int i, j;
int x;
A() {}
A(int x, int i, int j) : x(x), i(i), j(j) {}
const bool operator<(const A &tmp) const { return this->x < tmp.x; }
const bool operator!=(const A &tmp) const { return this->x != tmp.x; }
} a[1010];
int mp[1010][1010];
int smaller[1010][1010][2], bigger[1010][1010][2];
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> mp[i][j];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) a[j] = A(mp[i][j], i, j);
sort(a + 1, a + 1 + m);
int t = 1;
smaller[a[1].i][a[1].j][0] = 1;
for (int j = 2; j <= m; j++) {
if (a[j] != a[j - 1]) t++;
smaller[a[j].i][a[j].j][0] = t;
}
for (int j = 1; j <= m; j++)
bigger[a[j].i][a[j].j][0] = t - smaller[a[j].i][a[j].j][0];
}
for (int j = 1; j <= m; j++) {
for (int i = 1; i <= n; i++) a[i] = A(mp[i][j], i, j);
sort(a + 1, a + 1 + n);
int t = 1;
smaller[a[1].i][a[1].j][1] = 1;
for (int i = 2; i <= n; i++) {
if (a[i] != a[i - 1]) t++;
smaller[a[i].i][a[i].j][1] = t;
}
for (int i = 1; i <= n; i++)
bigger[a[i].i][a[i].j][1] = t - smaller[a[i].i][a[i].j][1];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int ans = max(smaller[i][j][0] + bigger[i][j][1],
smaller[i][j][1] + bigger[i][j][0]);
ans = max(ans, smaller[i][j][0] + bigger[i][j][0]);
ans = max(ans, smaller[i][j][1] + bigger[i][j][1]);
cout << ans << " ";
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
bool op = false;
char c = getchar();
while (!isdigit(c)) op |= (c == '-'), c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return op ? -x : x;
}
const long long N = 1e3 + 10;
long long n, al;
double pr;
signed main() {
n = read();
scanf("%lf", &pr);
al = n * (n - 1) * (n - 2) / 6;
for (long long i = 0; i <= n; i++) {
double p1 = 1.0 * i / al * ((n - i) * (n - i - 1) / 2);
double p2 = 1.0 * (i * (i - 1) / 2) / al * (n - i);
double p3 = 1.0 * i * (i - 1) * (i - 2) / 6 / al;
double res = p1 / 2 + p2 + p3;
if (res >= pr) {
printf("%lld", i);
return 0;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> A, RES;
map<long long int, set<long long int>> EDGES;
vector<long long int> E, P;
long long int SUM = 0;
long long int AA;
vector<long long int> STACK;
vector<long long int> SUMSTACK;
vector<long long int> STACKIDX;
vector<long long int> RETURN;
vector<long long int> RESULT;
bool cmpStack(long long int x) { return SUM - SUMSTACK[x] <= AA; }
long long int search(long long int low, long long int high,
bool (*cmp)(long long int)) {
long long int mid;
while (low < high) {
mid = (low + high) / 2;
if (cmp(mid))
high = mid;
else
low = mid + 1;
}
return low;
}
void solve(long long int n) {
SUM += E[n];
STACK.push_back(E[n]);
SUMSTACK.push_back(E[n] + (SUMSTACK.size() ? SUMSTACK.back() : 0));
STACKIDX.push_back(n);
AA = A[n];
long long int p = search(0, STACK.size(), cmpStack);
long long int pidx = STACKIDX[p];
RETURN[pidx] -= 1;
RETURN[n] += 1;
for (auto x : EDGES[n]) {
solve(x);
RESULT[n] += RETURN[x];
RETURN[n] += RETURN[x];
}
SUM -= E[n];
STACK.pop_back();
SUMSTACK.pop_back();
STACKIDX.pop_back();
}
int main() {
ios::sync_with_stdio(false);
long long int N;
cin >> N;
A = vector<long long int>(N);
for (long long int i = (0); i < (long long int)(N); ++i) {
cin >> A[i];
}
E = P = RETURN = RESULT = vector<long long int>(N);
P[0] = 0;
E[0] = 0;
for (long long int i = (0); i < (long long int)(N - 1); ++i) {
long long int p, w;
cin >> p >> w;
--p;
P[i + 1] = p;
E[i + 1] = w;
EDGES[p].insert(i + 1);
}
SUM = 0;
solve(0);
for (long long int i = (0); i < (long long int)(N); ++i) {
cout << RESULT[i] << " ";
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
int arr[2 * 100000], l, r, n;
int main() {
cin >> n;
for (int i = (0), _b = (n - 1); i <= _b; i++) {
cin >> arr[i];
arr[n + i] = arr[i];
}
for (int i = (1), _b = (2 * n - 1); i <= _b; i++) {
if (arr[i] >= arr[i - 1])
r++;
else
l = r = i;
if (r - l + 1 == n) {
cout << (l == 0 ? 0 : n - l) << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[30][30];
char st[110][110];
int in[30];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%s", st[i]);
memset(a, 0, sizeof(a));
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) {
int l1 = strlen(st[i]);
int l2 = strlen(st[j]);
int flag = 0;
for (int k = 0; k < min(l1, l2); ++k)
if (st[i][k] != st[j][k]) {
a[st[i][k] - 'a'][st[j][k] - 'a'] = 1;
flag = 1;
break;
}
if (!flag) {
if (l1 > l2) {
printf("Impossible\n");
return 0;
}
}
}
memset(in, 0, sizeof(in));
for (int i = 0; i < 26; ++i)
for (int j = 0; j < 26; ++j)
if (a[i][j]) ++in[j];
int ans[26];
for (int i = 0; i < 26; ++i) {
int flag = 0;
for (int j = 0; j < 26; ++j)
if (in[j] == 0) {
ans[i] = j;
flag = 1;
break;
}
if (!flag) {
printf("Impossible\n");
return 0;
}
in[ans[i]] = -1;
for (int j = 0; j < 26; ++j)
if (a[ans[i]][j]) --in[j];
}
for (int i = 0; i < 26; ++i) {
char ch = 'a' + ans[i];
printf("%c", ch);
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 262222, M = 19;
int n, K, mo, T, Fac[N], Inv[N], FInv[N], ans, a[M][N], c[M][N], cnt[N];
unsigned long long b[M][N];
int quick(int x, int y) {
int s = 1;
for (int i = 1; i <= y; i <<= 1, x = (long long)x * x % mo)
if (i & y) s = (long long)s * x % mo;
return s;
}
void fwt(int *f) {
for (int l = 2; l <= T; l <<= 1) {
int half = l >> 1;
for (int i = 0; i < T; i += l) {
for (int j = 0; j < half; j++) {
int p = f[i + j], q = f[i + j + half];
f[i + j] = (p + q >= mo) ? p + q - mo : p + q;
f[i + j + half] = (p < q) ? p - q + mo : p - q;
}
}
}
}
void ifwt(int *f) {
for (int l = 2; l <= T; l <<= 1) {
int half = l >> 1;
for (int i = 0; i < T; i += l) {
for (int j = 0; j < half; j++) {
int p = f[i + j], q = f[i + j + half];
f[i + j] = (long long)(p + q) * Inv[2] % mo;
f[i + j + half] = (long long)(p - q + mo) * Inv[2] % mo;
}
}
}
}
void quick(int N) {
if (!N) return;
quick(N >> 1);
memset(b, 0, sizeof(b));
for (int i = 0; i <= cnt[n]; i++) {
for (int j = 0; i + j <= cnt[n]; j++) {
for (int k = 0; k < T; k++) b[i + j][k] += (long long)a[i][k] * a[j][k];
}
}
for (int i = 0; i <= cnt[n]; i++)
for (int j = 0; j < T; j++) a[i][j] = b[i][j] % mo;
if (N % 2 == 0) return;
memset(b, 0, sizeof(b));
for (int i = 0; i <= cnt[n]; i++) {
for (int j = 0; i + j <= cnt[n]; j++) {
for (int k = 0; k < T; k++) b[i + j][k] += (long long)a[i][k] * c[j][k];
}
}
for (int i = 0; i <= cnt[n]; i++)
for (int j = 0; j < T; j++) a[i][j] = b[i][j] % mo;
}
int main() {
scanf("%d%d%d", &n, &K, &mo);
if (n & 1) {
printf("%d\n", quick(K, n));
return 0;
}
Inv[1] = 1;
for (int i = 2; i <= n; i++)
Inv[i] = (long long)Inv[mo % i] * (mo - mo / i) % mo;
Fac[0] = FInv[0] = 1;
for (int i = 1; i <= n; i++)
Fac[i] = (long long)Fac[i - 1] * i % mo,
FInv[i] = (long long)FInv[i - 1] * Inv[i] % mo;
for (T = 1; T <= n; T <<= 1)
;
for (int i = 0; i <= n; i++) {
if (i) cnt[i] = cnt[i ^ (i & -i)] + 1;
c[cnt[i]][i] = FInv[i];
}
for (int i = 0; i <= cnt[n]; i++) fwt(c[i]);
for (int i = 0; i < T; i++) a[0][i] = 1;
quick(K);
ifwt(a[cnt[n]]);
ans = (long long)a[cnt[n]][n] * Fac[n] % mo;
ans = (quick(K, n) - ans + mo) % mo;
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, k;
int a[100003];
int sum[100003];
int sum2[100003];
int res = 0;
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
res += a[i];
}
int cur = 0;
for (i = 1; i <= n; i++) {
cur -= a[i];
sum[i] = max(cur, sum[i - 1] + a[i]);
}
cur = 0;
for (i = n; i >= 1; i--) {
cur -= a[i];
sum2[i] = max(cur, sum2[i + 1] + a[i]);
}
for (i = 0; i <= n + 1; i++) res = max(res, sum[i] + sum2[i + 1]);
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
bool tab[910];
int res[40];
int main() {
int n, k;
int v;
cin >> n >> k;
for (int(i) = 0; (i) < (k); ++(i)) {
cin >> v;
tab[v] = 1;
res[i] = v;
}
int curr = 1;
for (int(i) = 0; (i) < (k); ++(i)) {
cout << res[i] << " ";
for (int(j) = 0; (j) < (n - 1); ++(j)) {
while (tab[curr]) curr++;
cout << curr << " ";
curr++;
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int i, j, k, t, n, m, it, siz[5050], cur, res, it2;
char s0[5050];
string sb[5050];
struct trie {
int mp[30];
int f1, f2, len, fa;
} s[10050];
void build(int id, int dep, int l, int r) {
if (l == r) {
s[id].len += (siz[l] - dep + 2);
return;
}
int x[30], i, y[30], j, k = 0;
memset(x, 1, sizeof(x));
memset(y, 0, sizeof(y));
s[id].len++;
memset(s[id].mp, 0, sizeof(s[id].mp));
for (j = l; j <= r; j++) {
if (siz[j] >= dep) {
x[sb[j][dep] - 'a' + 1] = min(x[sb[j][dep] - 'a' + 1], j);
y[sb[j][dep] - 'a' + 1] = max(y[sb[j][dep] - 'a' + 1], j);
}
}
for (i = 1; i <= 26; i++) {
k += (y[i] > 0);
}
if ((dep == 1) || k > 1) {
for (i = 1; i <= 26; i++) {
if (y[i]) {
s[id].mp[i] = ++it;
s[it].fa = id;
build(it, dep + 1, x[i], y[i]);
}
}
return;
}
if (k == 1) {
for (i = 1; i <= 26; i++) {
if (y[i]) {
build(id, dep + 1, x[i], y[i]);
return;
}
}
}
}
void dfs(int cur, int dep, int ans) {
int i, j, k, f = s[cur].fa, nmsl = dep + s[cur].len;
for (i = 1; i < s0[dep]; i++) {
if (s[f].mp[i]) {
ans = max(ans, s[s[f].mp[i]].f2);
}
}
ans += min(s[cur].len, n - dep + 1);
ans = max(ans, s[cur].f1);
s[cur].f1 = ans;
s[cur].f2 = max(s[cur].f2, ans);
if (nmsl <= n) {
dfs(s[cur].mp[s0[nmsl]], nmsl, ans);
s[cur].f2 = max(s[cur].f2, s[s[cur].mp[s0[nmsl]]].f2);
}
res = max(res, ans);
}
int main() {
ios::sync_with_stdio(0);
cin >> t;
while (t--) {
it = 0;
s[0].f1 = s[0].f2 = 0;
res = 0;
cin >> n >> s0 + 1;
if (n == 1) {
cout << 1 << '\n';
continue;
}
for (i = 1; i <= n; i++) {
sb[i].clear();
sb[i] += "0";
for (j = i; j <= n; j++) {
sb[i] += s0[j];
}
}
sort(sb + 1, sb + n + 1);
for (i = 1; i <= n; i++) {
siz[i] = sb[i].size() - 1;
}
build(0, 1, 1, n);
for (i = 1; i <= n; i++) {
s0[i] -= 'a' - 1;
}
for (i = 1; i <= n; i++) {
it2 = i;
dfs(s[0].mp[s0[i]], i, 0);
}
cout << res << '\n';
memset(s, 0, sizeof(s[0]) * it + 500);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int data;
int idx;
bool operator<(const node &n) const { return n.data > data; }
};
const int MAX = 310000;
struct node A[MAX];
priority_queue<struct node> pq;
int main(void) {
int n, k;
while (~scanf("%d %d", &n, &k)) {
for (int i = 1; i <= n; i++) {
A[i].idx = i;
scanf("%d", &A[i].data);
if (i <= k + 1) pq.push(A[i]);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
struct node tmp = pq.top();
pq.pop();
ans += 1LL * (i + k - tmp.idx) * tmp.data;
A[tmp.idx].idx = i + k;
if (k + 1 + i <= n) pq.push(A[k + 1 + i]);
}
printf("%lld\n", ans);
for (int i = 1; i <= n; i++) printf("%d%c", A[i].idx, i == n ? '\n' : ' ');
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e9 + 1;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int tests, ind1, ind2;
cin >> tests;
string s, t, sorted;
char mn;
while (tests--) {
cin >> s >> t;
sorted = s;
sort(sorted.begin(), sorted.end());
ind1 = -1;
for (int i = 0; i < int(s.size()); i++)
if (sorted[i] != s[i]) {
ind1 = i;
mn = sorted[i];
break;
}
if (ind1 == -1) goto fin;
for (int i = ind1 + 1; i < int(s.size()); i++)
if (s[i] == mn) ind2 = i;
swap(s[ind1], s[ind2]);
fin:
if (s >= t) {
cout << "---"
<< "\n";
continue;
}
cout << s << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 105;
const int MAX_E = MAX_N * MAX_N * 2;
const int INF = 1 << 30;
int n, k, flow;
int e, head[MAX_N], from[MAX_E], to[MAX_E], c[MAX_E], w[MAX_E];
void add_edge(int u, int v, int cap, int cost) {
from[e] = head[u];
head[u] = e;
to[e] = v;
c[e] = cap;
w[e++] = cost;
from[e] = head[v];
head[v] = e;
to[e] = u;
c[e] = 0;
w[e++] = -cost;
}
bool seen[MAX_N];
int Q[MAX_N], d[MAX_N], p[MAX_N];
void mcmf() {
int s = 0, t = n - 1;
while (true) {
fill(d, d + n, INF);
d[s] = 0;
int l = 0, r = 0;
Q[r++] = s;
while (l < r) {
int u = Q[l++];
seen[u] = 0;
for (int i = head[u]; ~i; i = from[i]) {
int v = to[i];
if (c[i] && d[u] + w[i] < d[v]) {
d[v] = d[u] + w[i];
p[v] = i;
if (!seen[v]) {
Q[r++] = v;
seen[v] = 1;
}
}
}
}
if (d[t] == INF) break;
int f = INF;
for (int i = t; i != s; i = to[p[i] ^ 1]) f = min(f, c[p[i]]);
for (int i = t; i != s; i = to[p[i] ^ 1]) c[p[i]] -= f, c[p[i] ^ 1] += f;
if (1ll * f * d[t] <= k)
k -= f * d[t], flow += f;
else {
flow += k / d[t];
break;
}
}
}
int main() {
scanf("%d %d", &n, &k);
memset(head, -1, sizeof head);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
int x;
scanf("%d", &x);
if (!x) continue;
add_edge(i, j, x, 0);
add_edge(i, j, INF, 1);
}
}
mcmf();
printf("%d\n", flow);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<long long, long long> > a;
int main() {
scanf("%d", &n);
long long x, y;
for (int i = 0; i < n; i++) {
scanf("%I64d %I64d", &x, &y);
a.push_back(pair<long long, long long>(x, y));
}
sort(a.begin(), a.end());
for (int i = 0; i < n - 1; i++) {
while (a[i].second > 1 && a[i].first < a[i + 1].first) {
a[i].second = (a[i].second / 4) + (a[i].second % 4 != 0);
a[i].first++;
}
if (a[i].first == a[i + 1].first)
a[i + 1].second = max(a[i + 1].second, a[i].second);
}
if (a[n - 1].second == 1) {
printf("%I64d", a[n - 1].first + 1);
return 0;
}
while (a[n - 1].second > 1) {
a[n - 1].second = (a[n - 1].second / 4) + (a[n - 1].second % 4 != 0);
a[n - 1].first++;
}
printf("%I64d", a[n - 1].first);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10, mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
struct node {
int ch, l, r, sz, lb, rb, v;
bool operator<(const node& b) const {
if (sz == b.sz) return lb > b.lb;
return sz < b.sz;
}
};
node a[maxn];
priority_queue<node> q;
bool vis[maxn];
void check(node u) { printf("lb == %d rb == %d sz == %d\n", u.lb, u.rb, u.sz); }
void solve() {
int ans = 0;
while (!q.empty()) {
node u = q.top();
q.pop();
if (vis[u.lb]) continue;
ans++;
int pos = u.lb;
while (pos <= u.rb) vis[pos] = 1, pos = a[pos].r;
node &le = a[a[u.lb].l], &ri = a[a[u.rb].r];
le.r = a[u.rb].r;
ri.l = a[u.lb].l;
if (le.ch == ri.ch) {
a[le.lb].rb = ri.rb;
a[ri.rb].lb = le.lb;
a[le.lb].sz = a[ri.rb].sz = a[ri.rb].sz + a[le.lb].sz;
q.push(a[le.lb]);
}
}
printf("%d\n", ans);
}
int main() {
int n;
scanf("%d", &n);
a[0].ch = -INF;
a[n + 1].ch = INF;
for (int i = 0; i <= n + 1; i++) {
if (i >= 1 && i <= n) scanf("%d", &a[i].ch);
a[i].v = a[i].lb = a[i].rb = i;
a[i].l = i - 1, a[i].r = i + 1;
a[i].sz = 1;
}
for (int i = 2; i <= n; i++)
if (a[i - 1].ch == a[i].ch) {
a[a[i - 1].lb].rb = i;
a[i].sz = ++a[a[i - 1].lb].sz;
a[i].lb = a[i - 1].lb;
}
int temp = 1;
while (temp <= n) {
q.push(a[temp]);
temp = a[temp].rb + 1;
}
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Obj {
int money, size, id;
Obj(int m = 0, int s = 0, int i = 0) : money(m), size(s), id(i) {}
};
bool cmpSize(Obj a, Obj b) { return a.size < b.size; }
bool cmpMoney(Obj a, Obj b) { return a.money > b.money; }
vector<int> e[(100000 + 10)];
int _link[(100000 + 10)];
char tmpuse[(100000 + 10)];
bool can(int t) {
if (tmpuse[t]) return false;
tmpuse[t] = true;
for (int i(0), _n(e[t].size()); i < _n; ++i) {
int j = e[t][i];
if (_link[j] == -1 || can(_link[j])) {
_link[j] = t;
return true;
}
}
return false;
}
Obj sh[(100000 + 10)], bu[(100000 + 10)];
int n, m;
void solve() {
memset((_link), -1, sizeof(_link));
long long ans = 0LL;
int cnt = 0;
for (int i(0), _n(n); i < _n; ++i) {
memset((tmpuse), false, sizeof(tmpuse));
if (can(sh[i].id)) ans += sh[i].money, ++cnt;
}
printf("%I64d\n", ans);
printf("%d\n", (cnt));
for (int j(0), _n(m); j < _n; ++j) {
if (_link[j] != -1) {
printf("%d %d\n", j + 1, _link[j] + 1);
}
}
}
int main() {
scanf("%d", &(n));
for (int i(0), _n(n); i < _n; ++i)
scanf("%d", &(sh[i].money)), scanf("%d", &(sh[i].size)), sh[i].id = i;
scanf("%d", &(m));
for (int j(0), _n(m); j < _n; ++j)
scanf("%d", &(bu[j].money)), scanf("%d", &(bu[j].size)), bu[j].id = j;
sort(sh, sh + n, cmpSize);
for (int j(0), _n(m); j < _n; ++j) {
int p = (int)(lower_bound(sh, sh + n, Obj(0, bu[j].size, 0), cmpSize) - sh);
while (p < n &&
(sh[p].size == bu[j].size || sh[p].size == bu[j].size + 1)) {
if (sh[p].money <= bu[j].money) e[sh[p].id].push_back(bu[j].id);
++p;
}
}
sort(sh, sh + n, cmpMoney);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<string> v;
map<vector<string>, int> m;
bool result;
int n;
void dfs(vector<string> v) {
if (m[v]) return;
m[v] = 1;
int x = v.size();
if (x == 1) result = true;
if (x > 1 && (v[x - 1][0] == v[x - 2][0] || v[x - 1][1] == v[x - 2][1])) {
vector<string> u = v;
u[x - 2] = u[x - 1];
u.erase(u.end() - 1);
dfs(u);
}
if (x > 3 && (v[x - 1][0] == v[x - 4][0] || v[x - 1][1] == v[x - 4][1])) {
vector<string> u = v;
u[x - 4] = u[x - 1];
u.erase(u.end() - 1);
dfs(u);
}
return;
}
int main() {
int i, j;
string s;
while (cin >> n) {
for (v.clear(), m.clear(), i = 0; i < n; ++i) {
cin >> s;
v.push_back(s);
}
result = false;
dfs(v);
if (result)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7, N = 1e5 + 5;
long long n, m, a[N], b[N];
int main() {
scanf("%lld%lld", &n, &m);
if (n > m) swap(n, m);
a[1] = 2, a[2] = 4;
for (int i = 3; i <= n; i++) a[i] = (a[i - 1] + a[i - 2]) % Mod;
b[1] = a[n], b[2] = (b[1] + 2) % Mod;
for (int i = 3; i <= m; i++)
b[i] = ((b[i - 1] + b[i - 2] - b[1] + 2) % Mod + Mod) % Mod;
printf("%lld\n", b[m]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
long long a[n][m];
long long ck = 1;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> a[i][j];
if ((i == 0 && (j == 0 || j == m - 1)) ||
(i == n - 1 && (j == 0 || j == m - 1))) {
if (a[i][j] > 2) ck = 0;
a[i][j] = 2;
} else if (i == 0 || i == n - 1 || j == 0 || j == m - 1) {
if (a[i][j] > 3) ck = 0;
a[i][j] = 3;
} else {
if (a[i][j] > 4) ck = 0;
a[i][j] = 4;
}
}
}
if (ck == 1) {
cout << "YES" << endl;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cout << a[i][j] << " ";
cout << endl;
}
} else
cout << "NO" << endl;
}
int main() {
long long t;
cin >> t;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 998244353;
int power(int a, int p) {
if (p == 0) return 1;
int ans = power(a, p / 2);
ans = (1LL * ans * ans) % M;
if (p % 2) ans = (1LL * a * ans) % M;
return ans;
}
const int N = 3e5 + 7;
int a[N], dp[N], ex[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, s = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s += a[i];
}
int invs = power(s, M - 2);
int invnminus1 = power(n - 1, M - 2);
for (int i = 0; i < s; i++) {
int pkombe = (1LL * i * invs) % M;
int pbarbe = (1LL * (s - i) * invs) % M;
pbarbe = (1LL * pbarbe * invnminus1) % M;
dp[i] = 1;
if (i > 0) dp[i] = (dp[i] + 1LL * pkombe * dp[i - 1]) % M;
dp[i] = (1LL * dp[i] * power(pbarbe, M - 2)) % M;
}
for (int i = s - 1; i >= 0; i--) ex[i] = (dp[i] + ex[i + 1]) % M;
int C = ex[0];
int ans = (1LL * (M - C) * (n - 1)) % M;
for (int i = 1; i <= n; i++) {
ans = (ans + ex[a[i]]) % M;
}
ans = (1LL * ans * power(n, M - 2)) % M;
cout << ans << endl;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int N;
char S[23][400005];
vector<int> zhi[23];
int vvv[23];
int dp[(1 << 20) + 3];
inline int countOne(const vector<int>& zhi, int x) {
auto iter1 = lower_bound(zhi.begin(), zhi.end(), x);
auto iter2 = upper_bound(zhi.begin(), zhi.end(), x);
int ret = iter2 - iter1;
if (x == 0) --ret;
return ret;
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%s", S[i]);
int val = 0;
zhi[i].push_back(-val);
for (int j = 0; S[i][j]; ++j) {
if (S[i][j] == '(')
++val;
else
--val;
if (val <= -*zhi[i].rbegin()) zhi[i].push_back(-val);
}
vvv[i] = val;
}
int ans = 0;
memset(dp, -1, sizeof(dp));
dp[0] = 0;
for (int f = 1; f < (1 << N); ++f) {
int s = 0;
for (int i = 0; i < N; ++i)
if (f & (1 << i)) s += vvv[i];
for (int i = 0; i < N; ++i)
if ((f & (1 << i)) && dp[f ^ (1 << i)] != -1) {
int tmp = dp[f ^ (1 << i)];
int now = tmp + countOne(zhi[i], s - vvv[i]);
if (-*zhi[i].rbegin() + s - vvv[i] < 0) {
ans = max(ans, now);
continue;
}
dp[f] = max(dp[f], now);
}
}
ans = max(ans, dp[(1 << N) - 1]);
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int NMax = 55;
int N, P;
int C[NMax];
int DP[NMax][NMax][NMax][NMax];
int Power[NMax], ans;
const int MOD = 1000000007;
void Add(int& x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
void Read() {
cin >> N >> P;
for (int i = 1; i <= N; i++) {
cin >> C[i];
}
}
void initPower() {
Power[0] = 1;
for (int i = 1; i <= N; i++) {
Power[i] = (Power[i - 1] * 2) % MOD;
}
}
void initialize() { DP[0][0][0][0] = 1; }
void solveDPForWhiteNode(int currNode) {
for (int ew = 0; ew <= currNode; ew++) {
for (int ow = 0; ow + ew <= currNode; ow++) {
for (int ed = 0; ed + ow + ew <= currNode; ed++) {
int od = currNode - ew - ow - ed;
if (ew + ow == 0) continue;
int powerFactor = Power[ew + ow + ed - 1];
int ewFactor = (od > 0) ? (Power[od - 1]) : 0;
int owFactor = (od > 0) ? (Power[od - 1]) : 1;
int term =
(ew > 0)
? ((1LL * ewFactor * DP[currNode - 1][ew - 1][ow][ed]) % MOD)
: 0;
Add(term,
(ow > 0)
? ((1LL * owFactor * DP[currNode - 1][ew][ow - 1][ed]) % MOD)
: 0);
Add(DP[currNode][ew][ow][ed], (1LL * powerFactor * term) % MOD);
}
}
}
}
void solveDPForBlackNode(int currNode) {
for (int ew = 0; ew <= currNode; ew++) {
for (int ow = 0; ow + ew <= currNode; ow++) {
for (int ed = 0; ed + ow + ew <= currNode; ed++) {
int od = currNode - ew - ow - ed;
if (ed + od == 0) continue;
int powerFactor = Power[ew + od + ed - 1];
int edFactor = (ow > 0) ? Power[ow - 1] : 0;
int odFactor = (ow > 0) ? Power[ow - 1] : 1;
int term =
((ed > 0)
? ((1LL * edFactor * DP[currNode - 1][ew][ow][ed - 1]) % MOD)
: 0);
Add(term,
((od > 0) ? ((1LL * odFactor * DP[currNode - 1][ew][ow][ed]) % MOD)
: 0));
Add(DP[currNode][ew][ow][ed], (1LL * powerFactor * term) % MOD);
}
}
}
}
void computeAns() {
initialize();
for (int i = 1; i <= N; i++) {
if (C[i] != 0) solveDPForWhiteNode(i);
if (C[i] != 1) solveDPForBlackNode(i);
}
for (int ew = 0; ew <= N; ew++) {
for (int ow = 0; ow + ew <= N; ow++) {
for (int ed = 0; ed + ow + ew <= N; ed++) {
int od = N - ew - ow - ed;
if ((ow + od) % 2 == P) Add(ans, DP[N][ew][ow][ed]);
}
}
}
cout << ans << "\n";
}
int main() {
Read();
initPower();
computeAns();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct Seg_tree {
int maxv, ori, lazy;
} tree[800005];
int dep[200005], nnum[200005], onum[200005], ttop[200005], f[200005],
siz[200005], son[200005];
struct Ques {
int p, t, num;
friend bool operator<(Ques a, Ques b) {
return dep[a.p] + a.t == dep[b.p] + b.t ? a.p < b.p
: dep[a.p] + a.t < dep[b.p] + b.t;
}
} q[200005];
vector<int> v[200005];
int ret[200005];
int n, m, tot;
void dfs(int x, int fx) {
siz[x] = 1, dep[x] = dep[fx] + 1, f[x] = fx;
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i];
if (to == fx) continue;
dfs(to, x);
siz[x] += siz[to], son[x] = (siz[to] > siz[son[x]]) ? to : son[x];
}
}
void redfs(int x, int fx, int topx) {
ttop[x] = topx, nnum[x] = ++tot, onum[tot] = x;
if (son[x]) redfs(son[x], x, topx);
for (int i = 0; i < v[x].size(); i++) {
int to = v[x][i];
if (to == fx || to == son[x]) continue;
redfs(to, x, to);
}
}
void buildtree(int rt, int l, int r) {
tree[rt].maxv = tree[rt].lazy = -0x3f3f3f3f;
if (l == r) {
tree[rt].ori = dep[onum[l]] << 1;
return;
}
int mid = (l + r) >> 1;
buildtree(rt << 1, l, mid), buildtree((rt << 1) | 1, mid + 1, r);
tree[rt].ori = max(tree[rt << 1].ori, tree[(rt << 1) | 1].ori);
}
void pushdown(int rt) {
tree[rt << 1].lazy = max(tree[rt << 1].lazy, tree[rt].lazy);
tree[(rt << 1) | 1].lazy = max(tree[(rt << 1) | 1].lazy, tree[rt].lazy);
tree[rt << 1].maxv =
max(tree[rt << 1].maxv, tree[rt << 1].ori + tree[rt].lazy);
tree[(rt << 1) | 1].maxv =
max(tree[(rt << 1) | 1].maxv, tree[(rt << 1) | 1].ori + tree[rt].lazy);
tree[rt].lazy = -0x3f3f3f3f;
}
void update(int rt, int l, int r, int lq, int rq, int v) {
if (l >= lq && r <= rq) {
tree[rt].lazy = max(tree[rt].lazy, v);
tree[rt].maxv = max(tree[rt].maxv, tree[rt].ori + v);
return;
}
if (tree[rt].lazy != -0x3f3f3f3f) pushdown(rt);
int mid = (l + r) >> 1;
if (lq <= mid) update(rt << 1, l, mid, lq, rq, v);
if (rq > mid) update((rt << 1) | 1, mid + 1, r, lq, rq, v);
tree[rt].maxv = max(tree[rt << 1].maxv, tree[(rt << 1) | 1].maxv);
}
int query(int rt, int l, int r, int lq, int rq) {
if (l >= lq && r <= rq) return tree[rt].maxv;
if (tree[rt].lazy != -0x3f3f3f3f) pushdown(rt);
int mid = (l + r) >> 1;
int s = -0x3f3f3f3f;
if (lq <= mid) s = max(s, query(rt << 1, l, mid, lq, rq));
if (rq > mid) s = max(s, query((rt << 1) | 1, mid + 1, r, lq, rq));
return s;
}
int solve(int p, int tim) {
int u = p;
while (u) {
int t = ttop[u];
if (query(1, 1, n, nnum[t], nnum[u]) <= dep[p] + tim) {
u = f[ttop[u]];
continue;
}
int l = nnum[t], r = nnum[u], ans = r;
while (l <= r) {
int mid = (l + r) >> 1;
if (query(1, 1, n, mid, r) > dep[p] + tim)
ans = mid, l = mid + 1;
else
r = mid - 1;
}
u = onum[ans];
break;
}
if (!u) u = 1;
int re = 2 * (dep[p] - dep[u]) + tim;
int tp = p;
while (ttop[tp] != ttop[u])
update(1, 1, n, nnum[ttop[tp]], nnum[tp], re - dep[p]), tp = f[ttop[tp]];
update(1, 1, n, nnum[u] + 1, nnum[tp], re - dep[p]);
return re;
}
inline int read() {
int f = 1, x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int main() {
n = read() + 1, m = read();
for (int i = 2; i <= n; i++) f[i] = read() + 1, v[f[i]].push_back(i);
dfs(1, 0), redfs(1, 0, 1), buildtree(1, 1, n);
for (int i = 1; i <= m; i++)
q[i].p = read() + 1, q[i].t = read(), q[i].num = i;
sort(q + 1, q + m + 1);
for (int i = 1; i <= m; i++) ret[q[i].num] = solve(q[i].p, q[i].t);
for (int i = 1; i <= m; i++) printf("%d\n", ret[i]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int n;
cin >> n;
vector<int> planks(n);
for (int j = 0; j < n; j++) {
int size;
cin >> size;
planks[j] = size;
}
sort(planks.begin(), planks.end());
int maxK = n - 2;
int k = min(planks[n - 2] - 1, n - 2);
cout << k << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using std::array;
using std::bitset;
using std::cin;
using std::cout;
using std::deque;
using std::endl;
using std::function;
using std::ios_base;
using std::list;
using std::map;
using std::max;
using std::min;
using std::multiset;
using std::next_permutation;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::stack;
using std::string;
using std::swap;
using std::unordered_map;
using std::unordered_set;
using std::vector;
string front(string s) {
string t;
t += s[3], t += s[0], t += s[1], t += s[2], t += s[4], t += s[5];
return t;
}
string left(string s) {
string t;
t += s[0], t += s[5], t += s[2], t += s[4], t += s[1], t += s[3];
return t;
}
string getmin(string s) {
string mn = s;
for (int i = 0; i < 8; i++) {
for (int m = 0; m < (1 << i); m++) {
string t = s;
for (int b = 0; b < i; b++) {
if (1 << b & m) {
t = front(t);
} else {
t = left(t);
}
}
mn = min(mn, t);
}
}
return mn;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
string s;
cin >> s;
sort(s.begin(), s.end());
set<string> a;
do {
a.insert(getmin(s));
} while (next_permutation(s.begin(), s.end()));
cout << a.size();
exit(EXIT_SUCCESS);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, s;
cin >> n;
s = (n + 1) / 2;
cout << s % 2 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int B = 317;
const int N = 4e3 + 7;
const long long mod = 998244353;
const int inf = 1e9 + 100;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int> > v(n);
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
v[i] = {x + y, x - y};
}
sort(v.begin(), v.end());
int last = -1e9;
int ans = 0;
for (int i = 0; i < n; i++) {
if (v[i].second >= last) {
last = v[i].first;
ans++;
}
}
cout << ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, nn, mm, x, y, r, a1, a2, p[1000000], q[1000000];
char s[1000000], t[1000000], ch;
int main() {
scanf("%s", s + 1);
scanf("%s", t + 1);
ch = 'a';
for (int i = (1); i <= (500000); i++) {
if (s[i] != ch) {
n++;
p[n] = x;
x = 0;
ch = 'a' + 'b' - ch;
}
x++;
if (!s[i]) break;
}
ch = 'b';
x = 0;
for (int i = (1); i <= (500000); i++) {
if (t[i] != ch) {
m++;
q[m] = x;
x = 0;
ch = 'a' + 'b' - ch;
}
x++;
if (!t[i]) break;
}
if ((!p[1]) && (!q[1])) {
n--;
for (int i = (1); i <= (n); i++) p[i] = p[i + 1];
m--;
for (int i = (1); i <= (m); i++) q[i] = q[i + 1];
}
nn = n;
mm = m;
if (m - n > 2) {
r = (m - n + 1) / 4 * 2;
mm -= r + 1;
nn += r - 1;
if (nn == r) nn++;
} else if (n - m > 2) {
r = (n - m + 1) / 4 * 2;
nn -= r + 1;
mm += r - 1;
if (mm == r) mm++;
}
if (((nn - mm) < 0 ? -(nn - mm) : (nn - mm)) > 1) {
if (!p[1]) {
n--;
for (int i = (1); i <= (n); i++) p[i] = p[i + 1];
m++;
for (int i = (m + 1); i >= (2); i--) q[i] = q[i - 1];
q[1] = 0;
} else if (!q[1]) {
m--;
for (int i = (1); i <= (m); i++) q[i] = q[i + 1];
n++;
for (int i = (n + 1); i >= (2); i--) p[i] = p[i - 1];
p[1] = 0;
}
}
r = 0;
if (m - n > 2) {
r = (m - n + 1) / 4 * 2;
x = 0;
for (int i = (1); i <= (r + 1); i++) x += q[i];
a1 = p[1];
a2 = x;
x = p[1];
y = q[r + 1];
for (int i = (n + r - 1); i >= (r + 1); i--) p[i] = p[i - r + 1];
for (int i = (1); i <= (r); i++) p[i] = q[i];
for (int i = (1); i <= (m - r - 1); i++) q[i] = q[i + r + 1];
p[r + 1] += y;
q[1] += x;
m -= r + 1;
n += r - 1;
if (n == r) n++;
} else if (n - m > 2) {
r = (n - m + 1) / 4 * 2;
x = 0;
for (int i = (1); i <= (r + 1); i++) x += p[i];
a1 = x;
a2 = q[1];
x = q[1];
y = p[r + 1];
for (int i = (m + r - 1); i >= (r + 1); i--) q[i] = q[i - r + 1];
for (int i = (1); i <= (r); i++) q[i] = p[i];
for (int i = (1); i <= (n - r - 1); i++) p[i] = p[i + r + 1];
q[r + 1] += y;
p[1] += x;
n -= r + 1;
m += r - 1;
if (m == r) m++;
}
x = y = 0;
printf("%d\n", (r > 0) + ((n) > (m) ? (n) : (m)) - 1);
if (r) printf("%d %d\n", a1, a2);
p[n + 1] = p[n + 2] = q[m + 1] = q[m + 2] = 0;
for (int i = (1); i <= (((n) > (m) ? (n) : (m)) - 1); i++) {
x += p[i];
y += q[i];
printf("%d %d\n", x, y);
x ^= y;
y ^= x;
x ^= y;
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 321;
const int MOD = 1000 * 1000 * 1000 + 7;
int lps[MAXN], N, M, dp[MAXN], ps[MAXN], sp[MAXN];
bool good[MAXN];
char txt[MAXN], pat[MAXN];
void computeLPSArray();
void KMPSearch() {
M = strlen(pat);
N = strlen(txt);
computeLPSArray();
int i = 0;
int j = 0;
while (i < N) {
if (pat[j] == txt[i]) {
j++;
i++;
}
if (j == M) {
good[i - j + M - 1] = true;
j = lps[j - 1];
} else if (i < N && pat[j] != txt[i]) {
if (j != 0)
j = lps[j - 1];
else
i = i + 1;
}
}
}
void computeLPSArray() {
int len = 0;
lps[0] = 0;
int i = 1;
while (i < M) {
if (pat[i] == pat[len]) {
len++;
lps[i] = len;
i++;
} else {
if (len != 0) {
len = lps[len - 1];
} else {
lps[i] = 0;
i++;
}
}
}
}
void DP() {
int lst = -1, n = N, fst = -1;
for (int i = 0; i < n; i++) {
if (good[i]) {
lst = i - M + 1;
if (fst == -1) fst = i - M + 1;
}
if (~lst) dp[i] = (sp[lst] + lst + 1) % MOD;
ps[i + 1] = (ps[i] + dp[i]) % MOD;
sp[i + 1] = (sp[i] + ps[i + 1]) % MOD;
}
cout << ps[n];
}
int main() {
cin >> txt >> pat;
KMPSearch();
DP();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename P, typename Q>
ostream& operator<<(ostream& os, const pair<P, Q>& p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename K, typename V>
ostream& operator<<(ostream& os, const map<K, V>& v) {
os << '[';
for (const auto& it : v) (os << it) << ", ";
return os << ']';
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << '[';
for (const auto& it : v) (os << it) << ", ";
return os << ']';
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << '[';
for (const auto& it : v) os << it << ", ";
return os << ']';
}
int n;
ll vals[111];
vector<int> indx[4][4];
vector<pair<int, int> > graph[4];
int ptr[4];
bool vis[111];
ll dfval;
vector<int> tour;
void dfs(int u) {
for (; ptr[u] < graph[u].size();) {
pair<int, int> edge = graph[u][ptr[u]];
ptr[u]++;
if (vis[edge.second]) continue;
vis[edge.second] = true;
dfval += vals[edge.second];
dfs(edge.first);
}
tour.emplace_back(u);
}
bool df0(int root) {
fill(ptr, ptr + 4, 0);
fill(vis, vis + 1 + n, false);
dfval = 0;
tour.clear();
dfs(root);
int cnt[4][4];
memset(cnt, 0, sizeof cnt);
for (int i = 1; i < tour.size(); i++) {
if (tour[i - 1] == tour[i]) {
if (cnt[tour[i]][tour[i]] == indx[tour[i]][tour[i]].size()) {
return false;
}
cnt[tour[i]][tour[i]]++;
} else {
if (cnt[tour[i - 1]][tour[i]] == indx[tour[i - 1]][tour[i]].size()) {
return false;
}
cnt[tour[i - 1]][tour[i]]++;
cnt[tour[i]][tour[i - 1]]++;
}
}
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
cin >> n;
for (int i = 1; i <= n; i++) {
int u, v;
cin >> u >> vals[i] >> v;
u--;
v--;
indx[u][v].emplace_back(i);
if (u != v) indx[v][u].emplace_back(i);
}
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) {
sort((indx[i][j]).begin(), (indx[i][j]).end(),
[&](const int& p, const int& q) { return vals[p] > vals[q]; });
}
int pos[4][4];
for (int i = 0, k = 0; i < 4; i++)
for (int j = 0; j < 4; j++) pos[i][j] = k++;
ll answer = 0;
for (int mask = 0; mask < (1 << 16); mask++) {
for (int v = 0; v < 4; v++) graph[v].clear();
for (int i = 0; i < 4; i++) {
for (int j = 0; j < i; j++) {
if (mask & (1 << pos[j][i])) {
for (int id = 0; id + 1 < indx[j][i].size(); id++) {
graph[j].emplace_back(i, indx[j][i][id]);
graph[i].emplace_back(j, indx[j][i][id]);
}
} else {
for (int id = 0; id < indx[j][i].size(); id++) {
graph[j].emplace_back(i, indx[j][i][id]);
graph[i].emplace_back(j, indx[j][i][id]);
}
}
}
}
for (int i = 0; i < 4; i++)
for (auto& id : indx[i][i]) graph[i].emplace_back(i, id);
for (int root = 0; root < 4; root++) {
if (df0(root)) answer = max(answer, dfval);
}
}
cout << answer << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 405;
int n, m, g[N][N], tag1, tag2, vis1[N], vis2[N];
vector<int> G[N], d[N], po, Le;
double Ans, P[N], Maxp[N];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) g[i][j] = g[j][i] = N;
for (int i = 1, u, v; i <= m; i++)
scanf("%d%d", &u, &v), g[u][v] = g[v][u] = 1, G[u].push_back(v),
G[v].push_back(u);
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
for (int i = 1; i <= n; i++) {
double p = 0;
for (int l = 0; l < n; l++) d[l].clear();
for (int j = 1; j <= n; j++) d[g[i][j]].push_back(j);
for (int l = 0; l < n; l++)
if (d[l].size()) {
if (d[l].size() == 1) {
p += 1. / n;
continue;
}
double Max = 0;
tag1++;
po.clear();
for (int u = 0; u < d[l].size(); u++) {
int v = d[l][u];
double _p = 1. / d[l].size() / G[v].size();
for (int k = 0; k < G[v].size(); k++) {
int pos = G[v][k];
if (vis1[pos] != tag1)
vis1[pos] = tag1, po.push_back(pos), P[pos] = 0;
P[pos] += _p;
}
}
for (int j = 1; j <= n; j++) {
double q = 0;
tag2++;
Le.clear();
for (int u = 0; u < po.size(); u++) {
int v = po[u];
if (vis2[g[v][j]] != tag2)
vis2[g[v][j]] = tag2, Le.push_back(g[v][j]), Maxp[g[v][j]] = 0;
Maxp[g[v][j]] = max(Maxp[g[v][j]], P[v]);
}
for (int u = 0; u < Le.size(); u++) q += Maxp[Le[u]];
Max = max(Max, q);
}
p += max(1. / n, Max * d[l].size() / n);
}
Ans = max(Ans, p);
}
printf("%.10lf", Ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx")
using namespace std;
const long long maxn = 2e5 + 20;
const long long inf = (long long)2e9;
const long double pi = asin(1) * 2;
const long double eps = 1e-8;
const long long mod = (long long)1e9 + 7;
const long long ns = 97;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
void solve() {
long long n, m;
cin >> n >> m;
long long ans = n / 2 * m + (n % 2) * (m + 1) / 2;
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long q = 1;
cin >> q;
while (q--) solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, out, rev;
getline(cin, s);
int i = 0;
int j = s.length() - 1;
while (j - i >= 3) {
if (s[i] == s[j]) {
out.push_back(s[i]);
i++;
j--;
} else if (s[i] == s[j - 1]) {
out.push_back(s[i]);
i++;
j -= 2;
} else {
out.push_back(s[i + 1]);
if (s[i + 1] == s[j]) {
j--;
} else {
j -= 2;
}
i += 2;
}
}
rev = out;
reverse(rev.begin(), rev.end());
out.push_back(s[i]);
cout << out << rev << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
set<long long> ss;
int main() {
int n;
cin >> n;
int k = 0;
long long x, y, a;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
x = n / i, y = x + x * (x - 1) / 2 * i;
ss.insert(y);
a = n / i, x = n / a;
y = x + x * (x - 1) / 2 * a;
ss.insert(y);
}
}
set<long long>::iterator iter = ss.begin();
while (iter != ss.end()) {
cout << *iter << ' ';
iter++;
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int s1[N], m1[N], r1[N];
struct Line {
int t;
long long a;
long long b;
bool operator<(const Line& x) const { return t < x.t; }
};
struct Node {
vector<Line> vec;
void init(int l, int r) {
vec.push_back({0, 0, 0});
for (int i = l; i < r; i++) {
vec.push_back({
r1[i] ? m1[i] / r1[i] + 1 : INT_MAX,
-r1[i],
+m1[i],
});
vec[0].a += r1[i];
}
sort(vec.begin(), vec.end());
for (int i = 1; i < (int)vec.size(); i++) {
vec[i].b += vec[i - 1].b;
vec[i].a += vec[i - 1].a;
}
}
long long query(int x) {
const auto i = upper_bound(vec.begin(), vec.end(), (Line){x, 0, 0}) - 1;
return i->a * x + i->b;
}
};
struct Tree {
int l;
int r;
Tree* L;
Tree* R;
Node node;
int val;
void maintain() { val = L->val == R->val ? L->val : 0; }
Tree(int t, int v) {
l = t;
r = v;
val = 0;
node = Node();
if (l == r - 1) {
scanf("%d%d%d", s1 + l, m1 + l, r1 + l);
} else {
int m = (l + r) >> 1;
L = new Tree(l, m);
R = new Tree(m, r);
maintain();
}
node.init(l, r);
}
void update(int x) { val = x; }
void pushdown() {
if (val) {
L->update(val);
R->update(val);
}
}
void modify(int t, int v, int x) {
if (v <= l || r <= t) return;
if (t <= l && r <= v && val) {
update(x);
return;
}
if (l == r - 1) {
update(x);
return;
}
pushdown();
L->modify(t, v, x);
R->modify(t, v, x);
maintain();
}
long long query(int t, int v, int x) {
if (v <= l || r <= t) return 0;
if (t <= l && r <= v && val) {
return node.query(x - val);
}
if (l == r - 1) {
return min((long long)m1[l], s1[l] + (long long)r1[l] * x);
}
pushdown();
const auto a = L->query(t, v, x);
const auto b = R->query(t, v, x);
return a + b;
}
};
int main() {
int n;
cin >> n;
Tree root(1, n + 1);
int m;
cin >> m;
while (m--) {
int x, l, r;
scanf("%d%d%d", &x, &l, &r);
const auto ans = root.query(l, r + 1, x);
root.modify(l, r + 1, x);
printf("%lld\n", ans);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
class dinic_flow {
public:
struct edge {
int to, rev, cap;
edge(int to = 0, int rev = 0, int cap = 0) : to(to), rev(rev), cap(cap) {}
};
vector<vector<edge> > g;
vector<vector<edge>::iterator> nowi;
vector<int> dist;
int nodes, src, dst;
queue<int> q;
void init(int _nodes) {
nodes = _nodes;
g.resize(_nodes);
nowi.resize(_nodes);
for (int i = 0; i < _nodes; i++) g[i].clear();
dist.resize(_nodes);
}
void add_Edge(int _from, int _to, int _cap) {
g[_from].push_back(edge(_to, g[_to].size(), _cap));
g[_to].push_back(edge(_from, g[_from].size() - 1, 0));
}
bool dinic_bfs() {
fill(dist.begin(), dist.end(), -1);
dist[src] = 0;
q.push(src);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < g[u].size(); i++) {
edge e = g[u][i];
if (e.cap) {
int v = e.to;
if (dist[v] < 0) dist[v] = dist[u] + 1, q.push(v);
}
}
}
return dist[dst] >= 0;
}
int dinic_dfs(int u, int f) {
if (u == dst) return f;
int ret = 0;
for (vector<edge>::iterator &it = nowi[u]; it != g[u].end(); it++)
if (it->cap) {
int v = it->to;
if (dist[v] == dist[u] + 1) {
int tmp = dinic_dfs(v, min(f, it->cap));
it->cap -= tmp, f -= tmp, ret += tmp, g[v][it->rev].cap += tmp;
if (!f) return ret;
}
}
return ret;
}
int maxFlow(int _src, int _dst) {
src = _src, dst = _dst;
int flow = 0;
while (dinic_bfs()) {
for (int i = 0; i < nodes; i++) nowi[i] = g[i].begin();
flow += dinic_dfs(_src, 1e9);
}
return flow;
}
} D;
int d[666], c[666];
vector<int> v[666];
int main() {
int t, n, m, k;
scanf("%d", &t);
while (t--) {
scanf("%d%d%d", &n, &m, &k);
memset(d, 0, sizeof d);
D.init(n + m + 10);
int S = 0, T = n + m + 1;
for (int i = 1, x, y; i <= m; i++) {
scanf("%d%d", &x, &y);
d[x]++;
d[y]++;
D.add_Edge(x, n + i, 1);
D.add_Edge(y, n + i, 1);
D.add_Edge(n + i, T, 1);
}
int tot = 0;
for (int i = 1; i <= n; i++) {
int flw = 2 * max(0, d[i] - k);
tot += flw;
D.add_Edge(S, i, flw);
}
int mxflw = D.maxFlow(S, T);
if (mxflw != tot) {
for (int i = 1; i <= m; i++) printf("%d ", 0);
puts("");
continue;
}
for (int i = 1; i <= n; i++) v[i].clear();
for (int i = 1; i <= n; i++) {
for (int j = 0; j < D.g[i].size(); j++) {
int e = D.g[i][j].to, c = D.g[i][j].cap;
if (e != S && c == 0) v[i].push_back(e - n);
}
}
int cnt = 0;
memset(c, 0, sizeof c);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < v[i].size(); j += 2) {
++cnt;
c[v[i][j]] = cnt;
c[v[i][j + 1]] = cnt;
}
}
for (int i = 1; i <= m; i++) {
if (!c[i])
printf("%d ", ++cnt);
else
printf("%d ", c[i]);
}
puts("");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, r, k;
cin >> n >> r >> k;
long long int a = n * k;
vector<pair<long long int, long long int>> ar(n);
for (int i = 0; i < n; i++) {
cin >> ar[i].second >> ar[i].first;
a -= ar[i].second;
}
sort(ar.begin(), ar.end());
if (a <= 0) {
cout << "0\n";
return 0;
}
long long int ans = 0;
for (int i = 0; i < n; i++) {
if (a <= 0) break;
long long int dif = min(a, r - ar[i].second);
ans += (ar[i].first * dif);
a -= dif;
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> x, v;
int idX(int val) { return (lower_bound(x.begin(), x.end(), val) - x.begin()); }
int idV(int val) { return (lower_bound(v.begin(), v.end(), val) - v.begin()); }
struct FenwickTree {
vector<long long> bit;
int n;
FenwickTree(int n) {
this->n = n;
bit.assign(n, 0);
}
long long sum(int r) {
long long ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[r];
return ret;
}
long long sum(int l, int r) { return sum(r) - sum(l - 1); }
void upd(int idx, int delta) {
for (; idx < n; idx = idx | (idx + 1)) bit[idx] += delta;
}
};
void nikal_pehli_fursat_mai() {
int n;
cin >> n;
vector<array<long long, 2>> arr(n);
long long ans = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i][0];
x.push_back(arr[i][0]);
}
for (int i = 0; i < n; i++) {
cin >> arr[i][1];
v.push_back(abs(arr[i][1]));
}
sort(v.begin(), v.end());
sort(x.begin(), x.end());
sort(arr.begin(), arr.end());
FenwickTree pos(n), neg(n), zero(n), cntp(n), cntn(n), cntz(n);
for (int i = 0; i < n; i++) {
int id = idV(abs(arr[i][1]));
if (arr[i][1] > 0) {
cntp.upd(id, 1);
pos.upd(id, arr[i][0]);
} else if (arr[i][1] < 0) {
cntn.upd(id, 1);
neg.upd(id, arr[i][0]);
} else {
cntz.upd(id, 1);
zero.upd(id, arr[i][0]);
}
}
for (int i = 0; i < n; i++) {
int id = idV(abs(arr[i][1]));
if (arr[i][1] > 0) {
ans += pos.sum(id, n - 1) - cntp.sum(id, n - 1) * arr[i][0];
cntp.upd(id, -1);
pos.upd(id, -arr[i][0]);
} else if (arr[i][1] < 0) {
ans += pos.sum(0, n - 1) - cntp.sum(0, n - 1) * arr[i][0];
ans += zero.sum(0, n - 1) - cntz.sum(0, n - 1) * arr[i][0];
ans += neg.sum(0, id) - cntn.sum(0, id) * arr[i][0];
cntn.upd(id, -1);
neg.upd(id, -arr[i][0]);
} else {
ans += pos.sum(id, n - 1) - cntp.sum(id, n - 1) * arr[i][0];
ans += zero.sum(0, n - 1) - cntz.sum(0, n - 1) * arr[i][0];
cntz.upd(id, -1);
zero.upd(id, -arr[i][0]);
}
}
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int tc = 1;
while (tc--) {
nikal_pehli_fursat_mai();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void debugv(vector<vector<T>> v) {
for (auto x : v) {
for (auto y : x) {
cout << y << " ";
}
cout << "\n";
}
}
template <typename T>
T myMax(T x, T y) {
return (x > y) ? x : y;
}
long long maximum = numeric_limits<int>::max();
long long minimum = numeric_limits<int>::min();
string gg = "abcdefghijklmnopqrstuvwxyz";
int max3(int a, int b, int c) { return max(a, max(b, c)); }
int mint(int x, int y, int z) {
if (x < y)
return (x < z) ? x : z;
else
return (y < z) ? y : z;
}
vector<pair<long long int, long long int>> v;
bool sortbysec(const pair<long long int, long long int>& a,
const pair<long long int, long long int>& b) {
if (a.second == b.second) {
return (a.first > b.first);
}
return a.second > b.second;
}
bool cmp(pair<long long int, long long int>& a,
pair<long long int, long long int>& b) {
return a.second < b.second;
}
template <typename T1, typename T2>
struct less_second {
bool operator()(pair<T1, T2> const& a, pair<T1, T2> const& b) const {
return a.second < b.second;
}
};
long long int baselog(long long int base, long long int x) {
return (long long int)(log(x) / log(base));
}
vector<int> visted(101, 0);
void dfs(vector<vector<int>> v, int ind) {
if (visted[ind]) return;
visted[ind] = 1;
for (long long int i = 0; i < v.size(); i++) {
if (!visted[i] and (v[i][0] == v[ind][0] or v[i][1] == v[ind][1])) {
dfs(v, i);
}
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
vector<long long int> s(n);
vector<long long int> c(n);
for (long long int i = 0; i < n; i++) cin >> s[i];
for (long long int i = 0; i < n; i++) cin >> c[i];
long long int ans = maximum;
for (long long int j = 0; j < n; j++) {
long long int temp1 = c[j];
long long int temp2 = maximum;
long long int temp3 = maximum;
long long int mini = maximum;
for (long long int i = 0; i < j + 1; i++) {
if (s[i] < s[j] and c[i] < mini) {
temp2 = c[i];
mini = c[i];
}
}
mini = maximum;
for (long long int i = j; i < n; i++) {
if (s[i] > s[j] and c[i] < mini) {
temp3 = c[i];
mini = c[i];
}
}
mini = temp1 + temp2 + temp3;
ans = min(ans, mini);
}
if (ans == maximum) {
cout << -1 << endl;
} else {
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int inf = 1 << 30;
int cnt[510][510], n, m;
struct Vector {
long long x, y;
Vector(long long _x = 0, long long _y = 0) {
x = _x;
y = _y;
}
inline friend Vector operator-(const Vector &u, const Vector &v) {
return Vector(u.x - v.x, u.y - v.y);
}
inline friend long long operator^(const Vector &u, const Vector &v) {
return u.x * v.y - u.y * v.x;
}
} A[510], B[510];
signed main() {
scanf("%d%d", &n, &m);
for (int i = 1, x, y; i <= n; i++) scanf("%d%d", &x, &y), A[i] = Vector(x, y);
for (int i = 1, x, y; i <= m; i++) scanf("%d%d", &x, &y), B[i] = Vector(x, y);
Vector p = Vector(-inf, -inf);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (((A[i] - p) ^ (A[j] - p)) > 0) {
for (int k = 1; k <= m; k++)
cnt[i][j] += (((A[i] - p) ^ (B[k] - p)) > 0) &
(((A[j] - A[i]) ^ (B[k] - A[i])) > 0) &
(((p - A[j]) ^ (B[k] - A[j])) > 0);
cnt[j][i] = -cnt[i][j];
}
int ans = 0;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
for (int k = j + 1; k <= n; k++)
ans += (cnt[i][j] + cnt[j][k] + cnt[k][i]) == 0;
return !printf("%d", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool check(char arr[200][200], int i, int j) {
bool d = 1;
if (arr[i][j] == '#' && arr[i - 1][j] == '#' && arr[i + 1][j] == '#' &&
arr[i][j + 1] == '#' && arr[i][j - 1] == '#') {
d = 0;
}
return d;
}
int main() {
char arr[200][200];
int x;
cin >> x;
for (int i = 1; i <= x; i++) {
for (int j = 1; j <= x; j++) {
cin >> arr[i][j];
}
}
bool da = 1;
for (int i = 1; i <= x; i++) {
for (int j = 1; j <= x; j++) {
if (arr[i][j] == '#' && arr[i - 1][j] == '#' && arr[i + 1][j] == '#' &&
arr[i][j + 1] == '#' && arr[i][j - 1] == '#') {
arr[i][j] = '.';
arr[i - 1][j] = '.';
arr[i + 1][j] = '.';
arr[i][j + 1] = '.';
arr[i][j - 1] = '.';
}
}
}
for (int i = 1; i <= x; i++) {
for (int j = 1; j <= x; j++) {
if (arr[i][j] != '.') {
da = 0;
break;
}
}
if (da == 0) break;
}
if (da)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, m, num;
long long g, r, p;
long long w[maxn], f[maxn];
struct SegmentTree {
int sum, ls, rs;
} empty;
vector<SegmentTree> tree;
int query(int k, long long l, long long r, long long x, long long y) {
if (x <= l && r <= y) return tree[k].sum;
int res = n + 1;
long long mid = (l + r) >> 1;
if (x <= mid && tree[k].ls) res = min(res, query(tree[k].ls, l, mid, x, y));
if (y > mid && tree[k].rs)
res = min(res, query(tree[k].rs, mid + 1, r, x, y));
return res;
}
void change(int k, long long l, long long r, long long x, long long v) {
if (l == r) {
tree[k].sum = v;
return;
}
if (!tree[k].ls) {
tree[k].ls = ++num;
tree.push_back(empty);
tree[num].sum = n + 1;
}
if (!tree[k].rs) {
tree[k].rs = ++num;
tree.push_back(empty);
tree[num].sum = n + 1;
}
int mid = (l + r) >> 1;
if (x <= mid)
change(tree[k].ls, l, mid, x, v);
else
change(tree[k].rs, mid + 1, r, x, v);
tree[k].sum = min(tree[tree[k].ls].sum, tree[tree[k].rs].sum);
}
int main() {
scanf("%d%lld%lld", &n, &g, &r);
p = g + r;
tree.push_back(empty);
tree[0].sum = n + 1;
for (int i = 1; i <= n + 1; ++i) {
scanf("%lld", &w[i]);
w[i] += w[i - 1];
}
for (int i = n, j; i; --i) {
long long t = (p - w[i] % p) % p;
j = query(0, 0, p - 1, max(0ll, g - t), p - 1ll - t);
if (g - t < 0) j = min(j, query(0, 0, p - 1, p + g - t, p - 1));
if (j > n)
f[i] = w[n + 1] - w[i];
else
f[i] = f[j] + w[j] - w[i] + (p - (w[j] - w[i]) % p);
change(0, 0, p - 1, w[i] % p, i);
}
scanf("%d", &m);
while (m--) {
int y;
long long x, t;
scanf("%lld", &x);
t = x % p;
y = query(0, 0, p - 1, max(0ll, g - t), p - 1 - t);
if (g - t < 0) y = min(y, query(0, 0, p - 1, p + g - t, p - 1));
if (y > n)
printf("%lld\n", w[n + 1] + x);
else
printf("%lld\n", w[y] + x + f[y] + (p - (t + w[y]) % p));
}
return 0;
}
| 10 |
//#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
#include <bits/stdc++.h>
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define all(x) (x).begin(),(x).end()
using namespace std;
typedef long long LL;
typedef pair<int,int> PII;
typedef vector < int > VI;
typedef double D;
const int MN = 100005, MX = 5005, inf = 1000000005, mod = 1000000007;
const LL INF = 1000000000000000005LL;
vector < PII > wek, wek2;
int ans[MX][MX];
int dx[] = {0, 0, 1, 1};
int dy[] = {0, 1, 0, 1};
int wez(bool keep = false)
{
if(!wek2.size())
return 0;
while(wek2.back().fi == 0)
wek2.pop_back();
if(!wek2.size())
return 0;
int ret = wek2.back().se;
if(!keep)
wek2.back().fi--;
return ret;
}
bool check(int N, bool write = false)
{
wek2.clear();
for(auto w : wek)
wek2.pb(w);
vector < PII > gdzie;
for(int i = 2; i <= N; i += 2)
{
for(int j = 1; j <= N; j += 2)
{
int cur = wez();
if(!cur)
break;
ans[i][j] = cur;
gdzie.pb({i, j});
}
if(!wez(true))
break;
}
for(int i = 1; i <= N; i += 2)
{
for(int j = 1; j <= N; j += 2)
{
int cur = wez();
if(!cur)
break;
ans[i][j] = cur;
gdzie.pb({i, j});
}
if(!wez(true))
break;
}
for(int i = 1; i <= N; i += 2)
{
for(int j = 2; j <= N; j += 2)
{
int cur = wez();
if(!cur)
break;
ans[i][j] = cur;
gdzie.pb({i, j});
}
if(!wez(true))
break;
}
bool ret = true;
if(wez(true))
ret = false;
for(auto g : gdzie)
for(int i = 0; i < 4; ++i)
{
PII to_check = {g.fi + dx[i], g.se + dy[i]};
if(min(to_check.fi, to_check.se) > 1 && max(to_check.fi, to_check.se) <= N)
{
bool ok = ((ans[to_check.fi - 1][to_check.se - 1] == 0 || ans[to_check.fi - 1][to_check.se - 1] != ans[to_check.fi][to_check.se]) && (ans[to_check.fi - 1][to_check.se] == 0 || ans[to_check.fi - 1][to_check.se] != ans[to_check.fi][to_check.se - 1]));
//printf("%d %d %d\n", to_check.fi, to_check.se, (int)ok);
if(!ok)
ret = false;
}
}
if(!write)
for(auto g : gdzie)
ans[g.fi][g.se] = 0;
return ret;
}
int bs()
{
int zd = 1, zg = MX - 3;
while(zd != zg)
{
int mid = (zd + zg) >> 1;
if(check(mid))
zg = mid;
else
zd = mid + 1;
}
return zd;
}
void solve()
{
int m, k;
scanf("%d%d", &m, &k);
for(int i = 1; i <= k; ++i)
{
int ile;
scanf("%d", &ile);
wek.pb({ile, i});
}
sort(all(wek));
int n = bs();
check(n, true);
printf("%d\n", n);
for(int i = 1; i <= n; ++i)
{
for(int j = 1; j <= n; ++j)
{
printf("%d ", ans[i][j]);
ans[i][j] = 0;
}
printf("\n");
}
wek.clear();
}
int main()
{
int t;
scanf("%d", &t);
while(t--)
solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return x * f;
}
int main() {
int T = read();
while (T--) {
int N = read(), S = read(), T = read();
printf("%d\n", max(N - S, N - T) + 1);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
struct Point {
int id;
int c;
double x, y;
Point(double x = 0, double y = 0, int c = 0, int id = 0)
: x(x), y(y), c(c), id(id) {}
};
const double EPS = 1e-8;
Point operator+(Point A, Point B) { return Point(A.x + B.x, A.y + B.y); }
Point operator-(Point A, Point B) { return Point(A.x - B.x, A.y - B.y); }
Point operator*(Point A, double p) { return Point(A.x * p, A.y * p); }
Point operator/(Point A, double p) { return Point(A.x / p, A.y / p); }
bool operator<(const Point& a, const Point& b) {
return a.x < b.x || (a.x == b.x && a.y < b.y);
}
int Sgn(long double x) {
if (fabs(x) < EPS)
return 0;
else
return x < 0 ? -1 : 1;
}
bool operator==(const Point& a, const Point& b) {
return Sgn(a.x - b.x) == 0 && Sgn(a.y - b.y) == 0;
}
long double Cross(Point A, Point B) {
return (long double)A.x * B.y - A.y * B.x;
}
vector<int> v[N];
int ConvexHull(Point* p, int n, Point* ch) {
sort(p, p + n);
int m = 0;
for (int i = 0; i < n; i++) {
p[m++] = p[i];
if (Sgn(p[i + 1].x - p[i].x) == 0) {
int j = i + 1;
for (j = i + 1; j < n; j++) {
if (Sgn(p[j].x - p[i].x) != 0) {
i = j - 1;
break;
} else if (Sgn(p[j].y - p[i].y) == 0) {
v[p[i].id].push_back(p[j].id);
}
}
if (j == n) i = n;
}
}
m = 0;
for (int i = 0; i < n; i++) {
while (m > 1 && (Cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2])) < 0) m--;
ch[m++] = p[i];
}
return m;
}
int n, ans[N];
Point p[N], ch[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0, x, y; i < n; i++) {
cin >> x >> y;
p[i].id = i + 1;
p[i].x = 1.0 / x;
p[i].y = 1.0 / y;
}
n = ConvexHull(p, n, ch);
for (int i = 0; i < n; i++) p[i] = ch[i];
int i;
ans[p[0].id] = 1;
for (int id : v[p[0].id]) ans[id] = 1;
for (i = 1; i < n; i++) {
if (Sgn((p[i].y - p[i - 1].y) / (p[i].x - p[i - 1].x)) < 0) {
ans[p[i].id] = 1;
for (int id : v[p[i].id]) ans[id] = 1;
} else
break;
}
for (int i = 1; i < N; i++) {
if (ans[i]) cout << i << " ";
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
double const PI = 4 * atan(1.0);
using namespace std;
int n, run;
vector<vector<int> > V;
int main() {
scanf("%d", &n);
for (run = 1;; run++)
if (run * (run + 1) / 2 > n) break;
V.resize(run + 2);
int m = run * (run - 1) / 2;
int chay = 0;
for (int i = 0; i < run; i++) {
for (int j = V[i].size(); j < run - 1; j++) {
V[i].push_back(++chay);
}
for (int j = i + 1; j < run; j++) V[j].push_back(V[i][j - 1]);
}
printf("%d\n", run);
for (int i = 0; i < run; i++) {
printf("%d", V[i][0]);
for (int j = 1; j < run - 1; j++) printf(" %d", V[i][j]);
printf("\n");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5, MOD = 1e9 + 7;
set<int> lower, upper, unknown;
int get_min(set<int> &s) { return s.empty() ? INF : *s.begin(); }
int get_max(set<int> &s) { return s.empty() ? -INF : *(--s.end()); }
void add(int price) {
if (price <= get_max(lower)) {
assert(lower.insert(price).second);
} else if (price >= get_min(upper)) {
assert(upper.insert(price).second);
} else {
assert(unknown.insert(price).second);
}
}
int accept(int price) {
if (price < get_max(lower) || price > get_min(upper)) return 0;
int status;
if (price == get_max(lower)) {
assert(lower.erase(price));
status = 1;
} else if (price == get_min(upper)) {
assert(upper.erase(price));
status = 1;
} else {
assert(unknown.erase(price));
status = 2;
}
for (int p : unknown)
if (p < price)
lower.insert(p);
else if (p > price)
upper.insert(p);
else
assert(false);
unknown.clear();
return status;
}
int main() {
int N;
scanf("%d", &N);
char operation[100];
long long answer = 1;
for (int i = 0; i < N; i++) {
int price;
scanf("%s %d", operation, &price);
if (strcmp(operation, "ADD") == 0) {
add(price);
} else if (strcmp(operation, "ACCEPT") == 0) {
int status = accept(price);
if (status == 0) {
cout << 0 << '\n';
return 0;
}
answer = answer * status % MOD;
} else {
assert(false);
}
}
answer = answer * (unknown.size() + 1) % MOD;
cout << answer << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int MAXN = 110000;
const int INF = 1E9 + 233;
struct Node {
int c[2], fa;
int siz;
long long val, sum, ret;
Node() {}
Node(int k) {
c[0] = c[1] = fa = 0;
siz = 1;
sum = val = k;
ret = 0;
}
} tr[MAXN];
struct Splay {
int root;
void pushup(int x) {
tr[x].siz = tr[tr[x].c[0]].siz + tr[tr[x].c[1]].siz + 1;
tr[x].sum = tr[tr[x].c[0]].sum + tr[tr[x].c[1]].sum + tr[x].val;
tr[x].ret = tr[tr[x].c[0]].ret + tr[tr[x].c[1]].ret +
(tr[tr[x].c[1]].sum + tr[x].val) * (tr[tr[x].c[0]].siz + 1) -
(tr[tr[x].c[0]].sum + tr[x].val) * (tr[tr[x].c[1]].siz + 1);
}
bool getlr(int x) { return tr[tr[x].fa].c[1] == x; }
void rotate(int x) {
int y = tr[x].fa, z = tr[y].fa;
bool k = getlr(x);
int w = tr[x].c[k ^ 1];
if (z) tr[z].c[getlr(y)] = x;
tr[x].fa = z;
tr[y].c[k] = w;
if (w) tr[w].fa = y;
tr[x].c[k ^ 1] = y;
tr[y].fa = x;
pushup(y);
}
void splay(int x, int y) {
while (tr[x].fa != y) {
if (tr[tr[x].fa].fa != y)
rotate(getlr(x) ^ getlr(tr[x].fa) ? x : tr[x].fa);
rotate(x);
}
pushup(x);
if (!y) root = x;
}
int find(int k) {
int x = root, y = 0;
while (x)
if (tr[x].val >= k)
y = x, x = tr[x].c[0];
else
x = tr[x].c[1];
return y;
}
void insert(int y) {
if (!root) {
root = y;
return;
}
int x = find(tr[y].val);
if (!x) {
x = root;
while (tr[x].c[1]) x = tr[x].c[1];
tr[x].c[1] = y;
tr[tr[x].c[1]].fa = x;
splay(tr[x].c[1], 0);
return;
}
splay(x, 0);
if (!tr[x].c[0])
tr[x].c[0] = y, tr[tr[x].c[0]].fa = x, pushup(x);
else {
x = tr[x].c[0];
while (tr[x].c[1]) x = tr[x].c[1];
tr[x].c[1] = y;
tr[tr[x].c[1]].fa = x;
splay(tr[x].c[1], 0);
}
}
void erase(int x) {
splay(x, 0);
if (!tr[x].c[0])
tr[tr[x].c[1]].fa = 0, root = tr[x].c[1];
else {
int y = tr[x].c[0];
while (tr[y].c[1]) y = tr[y].c[1];
splay(y, x);
tr[y].c[1] = tr[x].c[1];
tr[tr[x].c[1]].fa = y;
tr[y].fa = 0;
root = y;
pushup(y);
}
}
int pre(int x) {
splay(x, 0);
if (!x) {
x = root;
while (tr[x].c[1]) x = tr[x].c[1];
splay(x, 0);
return tr[x].val;
}
x = tr[x].c[0];
while (tr[x].c[1]) x = tr[x].c[1];
return x;
}
long long query(int l, int r) {
int x = find(l), y = find(r + 1);
if (!x) return 0;
x = pre(x);
if (x) {
splay(x, 0);
if (y) {
splay(y, x);
return tr[tr[y].c[0]].ret;
} else
return tr[tr[x].c[1]].ret;
} else if (y) {
splay(y, 0);
return tr[tr[y].c[0]].ret;
} else
return tr[root].ret;
}
} splay;
int main() {
int n, m;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
tr[i] = Node(x);
splay.insert(i);
}
scanf("%d", &m);
while (m--) {
int opt, x, y;
scanf("%d%d%d", &opt, &x, &y);
if (opt == 1) {
splay.erase(x);
tr[x] = Node(tr[x].val + y);
splay.insert(x);
} else
printf("%lld\n", splay.query(x, y));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> mat(n, vector<int>(m, 0));
vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < m + 1; j++) {
cin >> mat[i - 1][j - 1];
dp[i][j] =
dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + mat[i - 1][j - 1];
}
int cont = 0;
for (int i = 1; i < n + 1; i++)
for (int j = 1; j < m + 1; j++) {
if (mat[i - 1][j - 1] == 0) {
if (dp[i][j] - dp[i - 1][j] - dp[i][1 - 1] + dp[i - 1][1 - 1] >= 1) {
cont++;
}
if (dp[i][j] - dp[1 - 1][j] - dp[i][j - 1] + dp[1 - 1][j - 1] >= 1) {
cont++;
}
if (dp[i][m] - dp[i - 1][m] - dp[i][j - 1] + dp[i - 1][j - 1] >= 1) {
cont++;
}
if (dp[n][j] - dp[i - 1][j] - dp[n][j - 1] + dp[i - 1][j - 1] >= 1) {
cont++;
}
}
}
cout << cont;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
long long cost[N][10], step[N][10], n;
int getMax(int x) {
int ret = 0;
while (x) {
ret = max(ret, int(x % 10));
x /= 10;
}
return ret;
}
void init() {
for (int i = 0; i < N; i++) {
int c = getMax(i);
for (int j = 0; j < 10; j++) {
int v = max(j, c);
if (i < v) {
step[i][j] = 1;
cost[i][j] = v;
} else {
step[i][j] = step[i - v][j] + 1;
cost[i][j] = cost[i - v][j] + v;
}
}
}
}
int main() {
init();
scanf("%lld", &n);
long long ans = 0;
while (n >= N) {
int j = getMax(n / N);
ans += step[n % N][j];
n -= cost[n % N][j];
}
while (n > 0) {
int j = getMax(n);
ans += 1;
n -= j;
}
printf("%lld\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 51123987LL;
const int ROWS = 2;
int pnext[1001][3];
int dp[ROWS][150][51][51];
int main() {
int n;
scanf("%d", &n);
char str[1001];
scanf("%s", str);
for (int c = 0; c < 3; ++c) pnext[n][c] = n;
for (int i = n - 1; i >= 0; --i) {
for (int c = 0; c < 3; ++c) pnext[i][c] = pnext[i + 1][c];
pnext[i][str[i] - 'a'] = i;
}
const int nlow = n / 3, nhigh = (n + 2) / 3;
memset(dp[n % ROWS], 0, sizeof(dp[n % ROWS]));
for (int da = 0; da < 2; ++da)
for (int db = 0; db < 2; ++db)
for (int dc = 0; dc < 2; ++dc)
if (nlow * 3 + da + db + dc == n) {
for (int p = 0; p < n; ++p) dp[n % ROWS][p][nlow + da][nlow + db] = 1;
}
for (int i = n - 1; i >= 0; --i) {
const int me = i % ROWS, old = (i + 1) % ROWS, nnlow = nlow - (n - i);
memset(dp[me], 0, sizeof(dp[me]));
for (int p = 0; p < n; ++p)
for (int na = max(0, nnlow); na <= min(i, nhigh); ++na)
for (int nb = max(0, nnlow); nb <= min(i, nhigh); ++nb) {
const int nc = i - na - nb;
if (max(0, nnlow) <= nc && nc <= min(i, nhigh)) {
int& count = dp[me][p][na][nb];
if (pnext[p][0] < n && na < nhigh && nb > nnlow && nc > nnlow)
count += dp[old][pnext[p][0]][na + 1][nb];
if (pnext[p][1] < n && nb < nhigh && na > nnlow && nc > nnlow)
count += dp[old][pnext[p][1]][na][nb + 1];
if (pnext[p][2] < n && nc < nhigh && na > nnlow && nb > nnlow)
count += dp[old][pnext[p][2]][na][nb];
count %= MOD;
}
}
}
printf("%d\n", dp[0][0][0][0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 25, M = 300005;
int n, a[N][N];
long long f[M], g[N][M], d[N][M], dp[N][M];
map<long long, long long> mp;
string st;
inline int bp(int x) { return __builtin_popcount(x); }
void dfs(int p, int s, int x, long long m) {
if (s == n) {
long long w = 0;
for (int i = 0; i < (1 << n); i++) {
if ((n + bp(i)) & 1)
w -= d[x][i];
else
w += d[x][i];
}
mp[m] = w;
return;
}
if (s + p > n) return;
for (int i = 0; i < (1 << n); i++) d[x + 1][i] = d[x][i] * g[p][i];
dfs(p, s + p, x + 1, m * 10 + p);
dfs(p + 1, s, x, m);
}
long long ch(int x) {
vector<int> v;
int s = 0;
for (int i = 0; i < n; i++) {
if (x >> i & 1)
s++;
else {
v.push_back(s + 1);
s = 0;
}
}
sort(v.begin(), v.end());
long long y = 0;
for (auto i : v) y = y * 10 + i;
return y;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> st;
for (int j = 0; j < n; j++) a[i][j] = (st[j] == '1');
}
for (int i = 0; i < n; i++) dp[i][1 << i] = 1;
for (int i = 1; i < (1 << n); i++) {
for (int j = 0; j < n; j++) {
if (dp[j][i]) {
g[bp(i)][i] += dp[j][i];
for (int k = 0; k < n; k++)
if (!(i >> k & 1) && a[j][k]) dp[k][i | (1 << k)] += dp[j][i];
}
}
}
for (int i = 1; i <= n; i++)
for (int j = 0; j < n; j++)
for (int s = 0; s < (1 << n); s++)
if (s >> j & 1) g[i][s] += g[i][s ^ (1 << j)];
for (int i = 0; i < (1 << n); i++) d[0][i] = 1;
dfs(1, 0, 0, 0);
for (int i = 0; i < (1 << (n - 1)); i++) f[i] = mp[ch(i)];
for (int i = 0; i < n - 1; i++)
for (int j = 0; j < (1 << (n - 1)); j++)
if (!(j >> i & 1)) f[j] -= f[j ^ (1 << i)];
for (int i = 0; i < (1 << (n - 1)); i++) printf("%lld ", f[i]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
long long mpow(long long a, long long b) {
long long c = 1;
while (b) {
if (b & 1) c = c * a % 998244353;
a = a * a % 998244353;
b /= 2;
}
return c;
}
long long minv(long long a) { return mpow(a, 998244353 - 2); }
int n;
long long ans;
vector<int> g[500010];
long long f(int u, int p) {
long long prob = 1;
for (int v : g[u])
if (v != p) {
prob *= 1 - f(v, u) * ((998244353 + 1) / 2) % 998244353;
prob %= 998244353;
}
ans += 1 - prob;
ans %= 998244353;
return prob;
}
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i < n; i++) {
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
f(1, 0);
printf("%I64d\n", (ans + 998244353) * mpow(2, n) % 998244353);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[110], b[110], sco[10];
scanf("%d", &n);
memset(sco, 0, sizeof(sco));
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
sco[a[i]]++;
}
for (int i = 0; i < n; i++) {
scanf("%d", b + i);
sco[b[i]]--;
}
int sum1 = 0, sum2 = 0;
;
for (int i = 1; i <= 5; i++) {
if (sco[i] % 2 != 0) {
puts("-1");
return 0;
} else if (sco[i] > 0) {
sum1 += sco[i] >> 1;
} else if (sco[i] < 0) {
sum2 -= sco[i] >> 1;
}
}
printf("%d\n", max(sum1, sum2));
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long x[100005], y[100005];
int par[100005][30], lvl[100005];
long long cross(long long x1, long long y1, long long x2, long long y2,
long long x3, long long y3) {
long long x4 = x1 - x2;
long long x5 = x3 - x2;
long long y4 = y1 - y2;
long long y5 = y3 - y2;
return x4 * y5 - y4 * x5;
}
int check(int x, int y) {
if (x == y) return x;
if (lvl[x] < lvl[y]) swap(x, y);
if (lvl[x] > lvl[y]) {
int i = 0;
while (par[x][i + 1] != -1 && lvl[par[x][i + 1]] > lvl[y]) i++;
return check(par[x][i], y);
}
if (par[x][0] == par[y][0]) return par[x][0];
int i = 0;
while (par[x][i + 1] != -1 && par[x][i + 1] != par[y][i + 1]) i++;
return check(par[x][i], par[y][i]);
}
int main() {
int n, m, a, b;
memset(par, -1, sizeof(par));
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld %lld", &x[i], &y[i]);
}
lvl[n - 1] = 0;
par[n - 2][0] = n - 1;
lvl[n - 2] = 1;
for (int i = n - 2; i > 0; i--) {
int q = i;
long long a =
cross(x[par[i][0]], y[par[i][0]], x[i], y[i], x[i - 1], y[i - 1]);
while (par[q][0] != n - 1 && a > 0) {
q = par[q][0];
a = cross(x[par[q][0]], y[par[q][0]], x[q], y[q], x[i - 1], y[i - 1]);
}
if (a > 0) {
par[i - 1][0] = par[q][0];
} else
par[i - 1][0] = q;
for (int j = 1; j < 20; j++) {
if (par[i - 1][j - 1] == -1) break;
par[i - 1][j] = par[par[i - 1][j - 1]][j - 1];
}
lvl[i - 1] = lvl[par[i - 1][0]] + 1;
}
scanf("%d", &m);
while (m--) {
scanf("%d %d", &a, &b);
a--, b--;
printf("%d ", check(a, b) + 1);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
long long int dp[MAXN][4];
long long int comb(int n, int k) {
if (k == n || k == 0) return 1;
if (k > n) return 0;
if (dp[n][k] > 0) return dp[n][k];
long long int ans = comb(n - 1, k - 1) + comb(n - 1, k);
return dp[n][k] = ans;
}
long long int func(int a, int b, int c, int l) {
long long int ans = 0;
for (int l1 = 0; l1 <= l; l1++) {
int k = min(l - l1, a + l1 - b - c);
ans += comb(k + 2, 2);
}
for (int l1 = 0; l1 <= l; l1++) {
int k = min(l - l1, b + l1 - a - c);
ans += comb(k + 2, 2);
}
for (int l1 = 0; l1 <= l; l1++) {
int k = min(l - l1, c + l1 - b - a);
ans += comb(k + 2, 2);
}
return ans;
}
void init() {
for (int i = 0; i < 3e5 + 5; i++)
for (int j = 0; j < 5; j++) dp[i][j] = -1;
}
int main() {
int a, b, c, l;
scanf("%d %d %d %d", &a, &b, &c, &l);
init();
long long int total = comb(l + 3, 3);
long long int ans = func(a, b, c, l);
printf("%lld\n", total - ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int b[500005], ans[500005];
struct Base {
int a[23], pos[23];
Base() {
for (int i = 0; i < 23; i++) a[i] = 0;
}
void up(int &a, int b) {
if (b > a) a = b;
}
void ins(int x, int r) {
for (int i = 22; ~i; i--)
if (x >> i & 1) {
if (a[i]) {
if (pos[i] < r) {
swap(pos[i], r);
swap(a[i], x);
}
x ^= a[i];
} else {
a[i] = x;
pos[i] = r;
break;
}
}
}
int ask(int r) {
int t = 0;
for (int i = 22; ~i; i--)
if (pos[i] >= r) up(t, t ^ a[i]);
return t;
}
} f;
struct node {
int l, r, idx;
bool operator<(const node &a) const {
if (r == a.r) return l < a.l;
return r < a.r;
}
} e[500005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &e[i].l, &e[i].r);
e[i].idx = i;
}
sort(e + 1, e + 1 + q);
int r = 0;
for (int i = 1; i <= q; i++) {
while (r < n && r < e[i].r) {
r++;
f.ins(b[r], r);
}
ans[e[i].idx] = f.ask(e[i].l);
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long double ZERO = 1e-15;
const long double EPS = 1e-10;
const long long MAXN = 100500;
const long long INF9 = 2 * 1e9;
const long long INF = 4 * 1e18;
const long long L0 = 0;
const long double PI = acos(-1);
const long double sq2 = sqrt(2.0);
long long req(long long a, long long b) {
cout << "? " << a + 1 << ' ' << b + 1 << endl;
fflush(stdout);
char c;
cin >> c;
return (c == '=' ? 0 : c == '>' ? 1 : -1);
}
void ans(long long a, long long b) {
cout << "! " << a + 1 << ' ' << b + 1 << endl;
fflush(stdout);
}
int main() {
{
ios::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
}
long long q;
cin >> q;
while (q--) {
long long n;
cin >> n;
if (n == 1) {
cout << "! 1 1" << endl;
continue;
}
long long mi = 0, ma = 1;
if (req(mi, ma) > 0) swap(mi, ma);
long long done = 2;
while (true) {
if (done >= n) break;
long long tmi = done, tma = tmi + 1;
if (tma == n) {
tma = tmi;
done++;
} else {
done += 2;
if (req(tmi, tma) > 0) swap(tmi, tma);
}
if (req(tma, ma) > 0) ma = tma;
if (req(tmi, mi) < 0) mi = tmi;
}
ans(mi, ma);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a = "", aux;
for (int i = 1; i <= 1001; i++) {
stringstream ss;
ss << i;
ss >> aux;
a += aux;
}
int n;
cin >> n;
n--;
cout << a[n] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, K, v[1000050], c[1000050], ans[1000050];
double Ans, ret;
int main() {
scanf("%d%d", &n, &K);
for (int i = 1; i <= n; ++i) {
scanf("%d", &v[i]);
v[i] *= 100;
}
for (int i = 1; i <= n; ++i) scanf("%d", &c[i]);
for (int i = n; i; --i) ans[i] = min(max(v[i], ans[i + 1]), c[i]);
sort(ans + 1, ans + n + 1);
ret = 1.0 * K / n;
Ans = 0;
for (int i = 1; i <= n - K + 1; ++i) {
Ans += ans[i] * ret;
ret = ret * (n - K - i + 1) / (n - i);
}
printf("%.9lf\n", Ans);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, A[105];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
sort(A, A + n);
for (int i = 0; i < n; i++) {
cout << A[i] << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300001;
const int mod = 998244353;
int main() {
ios_base::sync_with_stdio(false);
long long int fact[N];
vector<pair<int, int> > seq;
map<int, long long int> freqA;
map<int, long long int> freqB;
map<pair<int, int>, long long int> freqSeq;
seq.clear();
freqA.clear();
freqB.clear();
freqSeq.clear();
fact[0] = fact[1] = 1;
for (int i = 2; i < N; i++) {
fact[i] = (i * fact[i - 1]) % mod;
}
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int ai;
int bi;
cin >> ai >> bi;
freqA[ai]++;
freqB[bi]++;
seq.push_back(make_pair(ai, bi));
freqSeq[make_pair(ai, bi)]++;
}
sort(seq.begin(), seq.end());
bool unsorted = false;
for (int i = 1; i < n; i++) {
if (seq[i - 1].second > seq[i].second) {
unsorted = true;
break;
}
}
long long int res = fact[n];
long long int res1 = 1;
for (map<int, long long int>::iterator it = freqA.begin(); it != freqA.end();
it++) {
res1 = (res1 * fact[(it->second)]) % mod;
}
long long int res2 = 1;
for (map<int, long long int>::iterator it = freqB.begin(); it != freqB.end();
it++) {
res2 = (res2 * fact[(it->second)]) % mod;
}
long long int res3 = 1;
if (!unsorted) {
for (map<pair<int, int>, long long int>::iterator it = freqSeq.begin();
it != freqSeq.end(); it++) {
res3 = (res3 * fact[(it->second)]) % mod;
}
}
res = (res - res1 - res2 + mod + mod) % mod;
if (!unsorted) {
res = (res + res3) % mod;
}
cout << res % mod << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXNN = 1E4 + 10;
int n, b, q;
pair<int, int> a[MAXNN];
int c[MAXNN][5];
const int MAXN = 22000, MAXM = 440000;
struct Dinic {
struct edge {
int x, y;
int c;
int f;
edge *next, *back;
edge(int x, int y, int c, edge* next)
: x(x), y(y), c(c), f(0), next(next), back(0) {}
void* operator new(size_t, void* p) { return p; }
} * E[MAXN], *data;
char storage[2 * MAXM * sizeof(edge)];
int S, T;
int Q[MAXN];
int D[MAXN];
void DFS() {
memset(D, -1, sizeof(D));
int head = 0, tail = 0;
Q[tail++] = S;
D[S] = 0;
for (;;) {
int i = Q[head++];
for (edge* e = E[i]; e; e = e->next) {
if (e->c == 0) continue;
int j = e->y;
if (D[j] == -1) {
D[j] = D[i] + 1;
Q[tail++] = j;
if (j == T) return;
}
}
if (head == tail) break;
}
}
edge* cur[MAXN];
edge* path[MAXN];
int flow() {
int res = 0;
int path_n;
for (;;) {
DFS();
if (D[T] == -1) break;
memcpy(cur, E, sizeof(E));
path_n = 0;
int i = S;
for (;;) {
if (i == T) {
int mink = 0;
int delta = INT_MAX;
for (int k = 0; k < path_n; ++k) {
if (path[k]->c < delta) {
delta = path[k]->c;
mink = k;
}
}
for (int k = 0; k < path_n; ++k) {
path[k]->c -= delta;
path[k]->back->c += delta;
}
path_n = mink;
i = path[path_n]->x;
res += delta;
}
edge* e;
for (e = cur[i]; e; e = e->next) {
if (e->c == 0) continue;
int j = e->y;
if (D[i] + 1 == D[j]) break;
}
cur[i] = e;
if (e) {
path[path_n++] = e;
i = e->y;
} else {
D[i] = -1;
if (path_n == 0) break;
path_n--;
i = path[path_n]->x;
}
}
}
return res;
}
int cut(int* s) {
int rst = 0;
for (int i = 0; i < MAXN; ++i)
if (D[i] == -1 && E[i]) s[rst++] = i;
return rst;
}
void init(int _S, int _T) {
S = _S, T = _T;
data = (edge*)storage;
memset(E, 0, sizeof(E));
}
void add_edge(int x, int y, int w) {
E[x] = new ((void*)data++) edge(x, y, w, E[x]);
E[y] = new ((void*)data++) edge(y, x, 0, E[y]);
E[x]->back = E[y];
E[y]->back = E[x];
}
};
Dinic dinic;
int main() {
scanf("%d%d%d", &n, &b, &q);
for (int i = 0; i < q; ++i) scanf("%d%d", &a[i].first, &a[i].second);
a[q].first = 0;
a[q].second = 0;
a[q + 1].first = b;
a[q + 1].second = n;
q += 2;
sort(a, a + q);
q = unique(a, a + q) - a;
for (int i = 1; i < q; ++i)
if (a[i].first == a[i - 1].first) {
puts("unfair");
return 0;
}
for (int i = q - 1; i > 0; --i)
if ((a[i].second -= a[i - 1].second) < 0) {
puts("unfair");
return 0;
}
int S = 0, T = 5 + q;
dinic.init(S, T);
for (int i = 0; i < 5; ++i) dinic.add_edge(S, i + 1, n / 5);
for (int i = q - 1; i > 0; --i)
for (int j = 0; j < 5; ++j) c[i][j] = (a[i].first + 4 - j) / 5;
for (int i = q - 1; i > 0; --i) {
for (int j = 0; j < 5; ++j) {
dinic.add_edge(j + 1, i + 5, c[i][j] - c[i - 1][j]);
}
dinic.add_edge(5 + i, T, a[i].second);
}
puts(dinic.flow() == n ? "fair" : "unfair");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
bool v = false, h = false;
for (auto &x : s) {
if (x == '0') {
if (v) {
cout << "3 4" << endl;
} else {
cout << "1 4" << endl;
}
v = !v;
} else {
if (h) {
cout << "4 3" << endl;
} else {
cout << "4 1" << endl;
}
h = !h;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long pow(long long a, long long b) {
long long ans = 1;
a %= mod;
while (b) {
if (b % 2) {
ans *= a;
ans %= mod;
}
b /= 2;
a *= a;
a %= mod;
}
return ans;
}
long long inv(long long a) { return pow(a, mod - 2); }
long long mul(long long a, long long b) {
return ((a % mod) * (b % mod)) % mod;
}
struct cmp {
bool operator()(pair<long long, long long> a,
pair<long long, long long> b) const {
long long x = a.first;
long long y = b.first;
return x >= y;
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(15);
;
long long t;
cin >> t;
while (t--) {
long long a, b, c;
cin >> a >> b >> c;
if (a) {
for (long long i = 0; i < a + 1; i++) cout << "0";
}
if (!b && c) c++;
if (b) {
if (!a) cout << "0";
cout << "1";
b--;
for (long long i = 0; i < b / 2; i++) cout << "01";
b %= 2;
}
for (long long i = 0; i < c; i++) cout << "1";
if (b) cout << "0";
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[1 << 21], ops[1 << 20];
int h, g;
int qq[24], qn;
int f(int id) {
int tmp = a[id];
a[id] = 0;
qn = 0;
qq[qn++] = id;
while (id * 2 < (1 << h) && a[id] < max(a[id << 1], a[(id << 1) | 1])) {
if (a[id << 1] > a[(id << 1) | 1]) {
swap(a[id << 1], a[id]);
id <<= 1;
} else {
swap(a[(id << 1) | 1], a[id]);
id = (id << 1) | 1;
}
qq[qn++] = id;
}
if (id < (1 << g)) {
for (int i = qn - 1; i > 0; i--) {
a[qq[i]] = a[qq[i - 1]];
}
a[qq[0]] = tmp;
return 0;
}
return tmp;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
scanf("%d %d", &h, &g);
long long ans = 0;
for (int i = 1; i < (1 << h); ++i) {
scanf("%d", &a[i]);
ans += a[i];
}
int ptr = 0;
for (int i = 1; i < (1 << g); ++i) {
while (1) {
int v = f(i);
if (v) {
ans -= v;
ops[ptr++] = i;
} else
break;
}
}
cout << ans << endl;
for (int i = 0; i < ptr; ++i) {
cout << ops[i] << ' ';
}
cout << endl;
}
}
| 8 |
#include <bits/stdc++.h>
long long XX, XY, YX, YY;
int bits[100005];
int n;
int readbit() {
char ch = getchar();
while (ch != '0' && ch != '1') ch = getchar();
return ch - '0';
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) bits[i] = readbit();
for (int i = 0; i < n; ++i) {
int x = readbit();
if (x == 0 && bits[i] == 0)
++YY;
else if (x == 1 && bits[i] == 0)
++YX;
else if (x == 1 && bits[i] == 1)
++XX;
else
++XY;
}
printf("%lld", XX * YY + XY * YX + XY * YY);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, g[20][20], r, c, k, ans = 0, x, y;
bool chk(int a, int b, int c, int d) {
int cnt = 0;
for (int i = a; i <= a + c; i++) {
for (int j = b; j <= b + d; j++) {
cnt += g[i][j];
if (cnt >= k) return 1;
}
}
return 0;
}
int main() {
scanf("%d%d%d%d", &r, &c, &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
g[x][y] = 1;
}
for (int i = 1; i <= r; i++) {
for (int j = 1; j <= c; j++) {
for (int e = 0; e + i <= r; e++) {
for (int f = 0; f + j <= c; f++) {
ans += chk(i, j, e, f);
}
}
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2,unroll-loops")
using namespace std;
const int inf = 1000000010;
const long long INF = 1000000000000001000LL;
const int mod = 1000000007;
const int MAXN = 300010, LOG = 20;
int n, m, k, u, v, x, y, t, a, b, ans;
int A[MAXN], B[30];
void Main() {
memset(B, 0, sizeof(B));
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> A[i];
for (int j = 0; j < 30; j++)
if (A[i] & (1 << j)) B[j]++;
}
for (int i = 1; i <= n; i++) {
int ok = 1;
for (int j = 0; j < 30; j++)
if (B[j] % i) ok = 0;
if (ok) cout << i << " ";
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
cin >> T;
while (T--) Main();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7, N = 202, M = 1e9 + 7;
int nxt[N][2], dp[N][N][N][2];
int n;
string s;
int max_prifix(string t) {
for (int i = t.size(); i >= 1; i--)
if (s.substr(0, i) == t.substr(t.size() - i)) return i;
return 0;
}
void add(int &a, int b) {
a += b;
if (a >= M) a -= M;
}
signed main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
;
cin >> n >> s;
for (int i = 0; i <= s.size(); i++) {
string cur = s.substr(0, i);
cur.push_back('(');
nxt[i][0] = max_prifix(cur);
cur.pop_back();
cur.push_back(')');
nxt[i][1] = max_prifix(cur);
cur.pop_back();
}
dp[0][0][0][0] = 1;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= i; j++) {
for (int k = 0; k <= s.size(); k++) {
for (int l = 0; l < 2; l++) {
add(dp[i + 1][j][nxt[k][0]][l | (nxt[k][0] == s.size())],
dp[i][j][k][l]);
add(dp[i][j + 1][nxt[k][1]][l | (nxt[k][1] == s.size())],
dp[i][j][k][l]);
}
}
}
}
int ans = 0;
for (int k = 0; k <= s.size(); k++) add(ans, dp[n][n][k][1]);
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
long n, k;
cin >> n >> k;
vector<long> v;
long i, x;
for (i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
long long count = 0;
sort(v.begin(), v.end(), greater<long>());
for (i = 0; i < n; i++) {
if ((v[i] - v[n - 1]) % k == 0) {
count = count + ((v[i] - v[n - 1]) / k);
} else {
cout << "-1";
return 0;
}
}
cout << count;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 1, INF = 1e9 + 1;
int arr[MAXN], tree[4 * MAXN];
void build(int v, int a, int b) {
if (b - a == 1) {
tree[v] = arr[a];
return;
}
build(v * 2, a, (a + b) / 2);
build(v * 2 + 1, (a + b) / 2, b);
tree[v] = min(tree[v * 2], tree[v * 2 + 1]);
}
int get_min(int v, int a, int b, int l, int r) {
if (a >= r || b <= l) return INF;
if (a >= l && b <= r) return tree[v];
return min(get_min(v * 2, a, (a + b) / 2, l, r),
get_min(v * 2 + 1, (a + b) / 2, b, l, r));
}
int main() {
int n;
cin >> n;
vector<int> h(n);
vector<int> pref(n);
for (int i = 0; i < n; i++) {
cin >> h[i];
arr[i] = h[i];
}
build(1, 0, n);
int curmx = 0, ans = 0;
for (int i = 0; i < n; i++) {
curmx = max(curmx, h[i]);
if (i == n - 1) {
ans++;
break;
}
if (get_min(1, 0, n, i + 1, n) >= curmx) {
curmx = 0;
ans++;
}
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5;
const long long INF = 1e12;
vector<long long> vec;
string X;
long long N, res, mx, ind, arr[MAX], beg[MAX], value[MAX], mark[MAX];
int main() {
ios_base::sync_with_stdio(false);
mx = -INF;
cin >> N;
for (int A = 1; A <= N; A++) {
cin >> X;
for (int B = X.size() - 1; B >= 0; B--)
value[X[B]] += pow(10, X.size() - 1 - B);
beg[X[0]] = 1;
}
for (int A = 'a'; A <= 'j'; A++) {
if (beg[A]) continue;
if (value[A] > mx) mx = value[A], ind = A;
}
for (int A = 'a'; A <= 'j'; A++) {
if (A == ind) continue;
vec.push_back(value[A]);
}
sort(vec.begin(), vec.end());
for (int A = vec.size() - 1; A >= 0; A--) res += vec[A] * (vec.size() - A);
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long T, a, n, p, h;
long long f(long long a, long long n, long long p) {
long long tmp = a * n / p;
if (!tmp) return max(a, p - a * n);
if (a * n % p < a * (p / a - 1)) --tmp;
return f(min(a - p % a, p % a), tmp, a);
}
int main() {
cin >> T;
while (T--) {
cin >> a >> n >> p >> h;
a %= p;
if (a * n < p)
cout << (a > h ? "NO" : "YES") << endl;
else
cout << (f(a, n, p) > h ? "NO" : "YES") << endl;
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <class TT>
void read(register TT &x) {
x = 0;
register char ch = getchar();
register bool f = 0;
while (ch < 48 || 57 < ch) f |= ch == '-', ch = getchar();
while (47 < ch && ch < 58)
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
if (f) x = -x;
}
int n, q;
int a[5010];
int f[5010][5010];
bool vis[5010][5010];
int maxf[5010][5010];
void work(int l, int r) {
vis[l][r] = 1;
if (l == r) {
maxf[l][r] = f[l][r] = a[l];
return;
}
if (!vis[l][r - 1]) work(l, r - 1);
if (!vis[l + 1][r]) work(l + 1, r);
maxf[l][r] = f[l][r] = f[l][r - 1] ^ f[l + 1][r];
(maxf[l][r] < (((maxf[l][r - 1]) < (maxf[l + 1][r]) ? (maxf[l + 1][r])
: (maxf[l][r - 1])))
? maxf[l][r] = (((maxf[l][r - 1]) < (maxf[l + 1][r]) ? (maxf[l + 1][r])
: (maxf[l][r - 1])))
: 0);
}
int main() {
read(n);
for (register int i = 1; i <= n; ++i) read(a[i]);
read(q);
work(1, n);
for (register int i = 1, l, r; i <= q; ++i) {
read(l);
read(r);
printf("%d\n", maxf[l][r]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200 * 1000 + 9;
const long long inf = 1e18;
const long long mod = 998244353;
void solve() {
long long n;
cin >> n;
long long x = sqrt(n);
long long mv = x - 1;
n = n - x;
long long y;
n % x == 0 ? y = n / x : y = (n / x) + 1;
mv = mv + y;
cout << mv << '\n';
return;
}
signed main() {
long long ___T;
scanf("%lld", &___T);
for (long long cs = 1; cs <= ___T; cs++) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e8;
struct ppp {
int k, l, r, v;
void mk(int _k, int _l, int _r, int _v) {
k = _k;
l = _l;
r = _r;
v = _v;
}
} a[1200000];
struct seg {
int ans, sign;
seg *lch, *rch;
seg() {
ans = sign = 0;
lch = 0;
rch = 0;
}
void updata(int l, int r, int x, int y, int k) {
int mid = (l + r) / 2;
if (x <= l && y >= r) {
ans = max(ans, k);
sign = max(sign, k);
return;
}
if (!lch) lch = new seg(), rch = new seg();
if (x <= mid) lch->updata(l, mid, x, y, k);
if (y > mid) rch->updata(mid + 1, r, x, y, k);
ans = max(sign, min(lch->ans, rch->ans));
}
int calc(int l, int r, int x, int y) {
int mid = (l + r) / 2, res = 1e9;
if (x <= l && y >= r) return ans;
if (!lch) return sign;
if (x <= mid) res = min(res, lch->calc(l, mid, x, y));
if (y > mid) res = min(res, rch->calc(mid + 1, r, x, y));
return max(res, sign);
}
} * tree;
int vx, vy, tot, i, j, n, x;
long long ans;
bool cmp(const ppp& a, const ppp& b) { return a.k < b.k; }
void add(int i, int j, int v) {
int x, y, k = 1e9, l = 1e9, r = -1e9, d;
for (x = i - 1; x <= i; ++x)
for (y = j - 1; y <= j; ++y) {
k = min(k, y * vy + vx * x);
d = vy * x - vx * y;
l = min(l, d);
r = max(r, d);
}
a[++tot].mk(k, l + inf + 1, r + inf, v);
}
int main() {
scanf("%d%d%d", &n, &vx, &vy);
for (i = 1; i <= n; ++i)
for (j = 1; j <= n; ++j) {
scanf("%d", &x);
add(i, j, x);
}
sort(a + 1, a + tot + 1, cmp);
tree = new seg();
for (i = 1; i <= tot; ++i) {
int tmp = tree->calc(0, inf + inf, a[i].l, a[i].r);
ans += max(0, a[i].v - tmp);
tree->updata(0, inf + inf, a[i].l, a[i].r, a[i].v);
}
printf("%I64d\n", ans);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
void file() {}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
int mod = 1e9 + 7;
long long fpow(long long x, long long p) {
if (!p) return 1;
long long sq = fpow(x, p / 2);
sq *= sq;
sq %= mod;
if (p & 1) sq *= x;
return sq % mod;
}
const int N = 2e3 + 9;
int mem[N];
vector<int> adjL[N];
int n, m, k;
int solve(int idx) {
if (idx >= n) return 1;
if (mem[idx] == 2) return 0;
if (mem[idx]) return 1;
mem[idx] = 1;
int ch = 1;
for (auto& it : adjL[idx]) ch = min(ch, solve(it));
return ch;
}
int main() {
file();
fast();
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
if (i + k - 1 >= n) break;
for (int j = 0; j < k / 2; j++)
adjL[j + i].push_back(k - j - 1 + i),
adjL[k - j - 1 + i].push_back(j + i);
}
long long ans = 1;
for (int i = 0; i < n; i++) {
ans *= max(1, solve(i) * m);
ans %= mod;
for (int j = 0; j < n; j++) mem[j] = (mem[j] ? 2 : 0);
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[2005][2005];
int main() {
int n, k;
cin >> n >> k;
long long int s = 0;
dp[0][1] = 1;
for (int i = 0; i < k; i++) {
for (int j = 1; j <= n; j++) {
for (int p = j; p <= n; p += j) {
(dp[i + 1][p] += dp[i][j]) %= 1000000007;
}
}
}
for (int i = 1; i <= n; ++i) (s += dp[k][i]) %= 1000000007;
cout << s;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define R(i,a,b) for(int i=a;i<=b;i++)
#define ll long long
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
int A[n];
if(n%2)
{
for(int i=1;i<=n-3;i=i+2)
{
cout<<i+1<<" "<<i<<" ";
}
cout<<n-1<<" "<<n<<" "<<n-2;
}
else
{
for(int i=1;i<=n;i=i+2)
cout<<i+1<<" "<<i<<" ";
}
cout<<"\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long p, d;
unsigned long long num[20] = {0};
unsigned long long ten[20];
ten[0] = 1;
int i;
for (int w = 1; w <= 19; w++) {
num[w] = num[w - 1] * 10 + 9;
ten[w] = ten[w - 1] * 10;
}
while (cin >> p >> d) {
int a[20];
unsigned long long temp = d, len;
for (i = 19; i >= 0; i--) {
if (num[i] <= p) {
len = (p - num[i]) % ten[i];
if (len <= d) {
p -= len;
break;
}
}
}
cout << p << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9, PI = acos(-1);
int n, k;
vector<int> a;
void solve() {
cin >> n >> k;
a.resize(n);
for (int i = 0; i < n; i++) cin >> a[i];
int to = 1, ans = 0;
for (int i = 1; i < n; i++) {
if (a[i] != a[i - 1])
to++;
else
ans = max(ans, to), to = 1;
}
ans = max(ans, to);
cout << ans;
}
int main() { solve(); }
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3010;
int px[N], py[N];
vector<int> d[N], h[N];
int r, c, n, k;
int prv[N], nxt[N], f[N], la;
void push(int x) {
prv[x] = la;
nxt[la] = x;
la = x;
}
void delt(int x) {
prv[nxt[x]] = prv[x];
nxt[prv[x]] = nxt[x];
}
long long ans;
long long calc(int x) {
return 1 <= x && x <= n ? (py[x] - py[prv[x]]) * (c - (py[f[x]]) + 1) : 0;
}
void del(int x, long long &sum) {
sum -= calc(x) + calc(nxt[x]);
delt(x);
int y = prv[x];
for (int i = 1; i <= k; i++, y = prv[y]) {
sum -= calc(y);
f[y] = nxt[f[y]];
sum += calc(y);
}
sum += calc(nxt[x]);
}
int main() {
cin >> r >> c >> n >> k;
k--;
for (int i = 1; i <= n; i++)
scanf("%d%d", &px[i], &py[i]), d[py[i]].push_back(i), h[px[i]].push_back(i);
for (int i = 1; i <= r; i++) {
memset(prv, 0, sizeof prv);
memset(nxt, 0, sizeof nxt);
memset(f, 0, sizeof f);
la = 0;
for (int j = 1; j <= c; j++)
for (auto x : d[j])
if (px[x] >= i) push(x);
push(n + 1);
nxt[n + 1] = n + 1;
py[n + 1] = c + 1;
long long sum = 0;
for (int x = nxt[0]; x <= n; x = nxt[x]) {
f[x] = x;
for (int y = x, z = 1; z <= k; z++, f[x] = y = nxt[y])
;
sum += calc(x);
}
for (int j = r; j >= i; j--) {
ans += sum;
for (auto x : h[j]) del(x, sum);
}
}
cout << ans << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, ans;
pair<int, int> p[2000];
map<pair<int, int>, int> cnt;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf(" %d%d", &p[i].first, &p[i].second);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
int X = p[i].first + p[j].first;
int Y = p[i].second + p[j].second;
ans += cnt[{X, Y}];
cnt[{X, Y}]++;
}
printf("%d", ans);
}
| 5 |
#include <bits/stdc++.h>
long long int max(long long int a, long long int b) {
long long int m;
if (a < b) {
m = b;
} else
m = a;
return m;
}
int main() {
long long int x1, x2, y1, y2, i, j, k, m = 0;
scanf("%lld %lld", &x1, &y1);
scanf("%lld %lld", &x2, &y2);
i = abs(x2 - x1);
j = abs(y2 - y1);
k = max(i, j);
printf("%lld\n", k);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[102][102], mod = 1000000007, k;
long long int find(int n, int k) {
if (dp[n][k] != -1) return dp[n][k];
if (n == 0) return 1;
long long int sum = 0;
for (long long int i = 1; i < k + 1; i++) {
if (n - i >= 0) {
sum = (sum + find(n - i, k)) % mod;
} else
break;
}
return dp[n][k] = sum % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
{
long long int n, m, x, y, q, ans = 0, f = 1, a, b, d;
cin >> n >> k >> d;
memset(dp, -1, sizeof(dp));
cout << ((find(n, k) - find(n, d - 1)) % mod + mod) % mod;
cout << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1700;
int g[N][N], n, m, ng[N][N], bg[N][N];
int c[4][2] = {1, 0, 0, 1, -1, 0, 0, -1},
cc[8][2] = {1, 0, 0, 1, -1, 0, 0, -1, 1, 1, -1, -1, 1, -1, -1, 1};
void xiao() {
int i, j, k;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (!g[i][j])
ng[i][j] = 0;
else {
ng[i][j] = 1;
for (k = 0; k < 4; k++) {
int x = i + c[k][0], y = j + c[k][1];
if (x > 0 && x <= n && y > 0 && y <= m) {
if (!g[x][y]) ng[i][j] = 0;
}
}
}
}
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) g[i][j] = ng[i][j];
}
int k;
void dfs(int x, int y) {
bg[x][y] = k;
for (int i = 0; i < 4; i++) {
int a = x + c[i][0], b = y + c[i][1];
if (a > 0 && a <= n && b > 0 && b <= m && g[a][b] && !bg[a][b]) {
dfs(a, b);
}
}
}
bool u[N][N], vis[N][N];
void kuo() {
int i, j, k;
memset(ng, 0, sizeof(ng));
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++)
if (g[i][j]) {
ng[i][j] = 1;
for (k = 0; k < 4; k++) {
int x = i + c[k][0], y = j + c[k][1];
if (x > 0 && x <= n && y > 0 && y <= m && bg[x][y] == bg[i][j]) {
ng[x][y] = 1;
}
}
}
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) g[i][j] = ng[i][j];
}
int cnt[N * N];
void ddfs(int x, int y) {
vis[x][y] = true;
for (int i = 0; i < 8; i++) {
int a = x + cc[i][0], b = y + cc[i][1];
if (a > 0 && a <= n && b > 0 && b <= m && bg[a][b] == bg[x][y] &&
!u[a][b] && !vis[a][b]) {
ddfs(a, b);
}
}
}
int main() {
int i, j;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
scanf("%d", &g[i][j]);
}
}
xiao();
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++)
if (g[i][j] && !bg[i][j]) {
k++;
dfs(i, j);
}
}
xiao();
xiao();
kuo();
kuo();
kuo();
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (g[i][j]) u[i][j] = true;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++)
if (bg[i][j] && !u[i][j] && !vis[i][j]) {
cnt[bg[i][j]]++;
ddfs(i, j);
}
}
printf("%d\n", k);
sort(cnt + 1, cnt + k + 1);
for (i = 1; i <= k; i++) printf("%d ", cnt[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long cost[100005][5], jaw[100005];
vector<int> hub[100005];
int ke[100005];
void dfs(int now, int par) {
for (int i = 0; i < hub[now].size(); i++) {
int cur = hub[now][i];
if (cur == par) continue;
ke[now] = cur;
dfs(cur, now);
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> cost[i][0];
}
for (int i = 1; i <= n; i++) {
cin >> cost[i][1];
}
for (int i = 1; i <= n; i++) {
cin >> cost[i][2];
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
hub[u].push_back(v);
hub[v].push_back(u);
}
int nyak = 0;
int mulai;
for (int i = 1; i <= n; i++) {
if (hub[i].size() == 1) {
nyak++;
mulai = i;
}
}
memset(ke, -1, sizeof(ke));
dfs(mulai, -1);
if (nyak != 2) {
cout << "-1\n";
return 0;
} else {
long long ans = 1e18;
long long kiri = -1, kanan = -1;
for (int i = 0; i <= 2; i++) {
for (int j = 0; j <= 2; j++) {
if (i == j) continue;
long long now = cost[mulai][i] + cost[ke[mulai]][j];
int a = i, b = j;
int node = ke[ke[mulai]];
while (node != -1) {
int cur = 3 - a - b;
now = now + cost[node][cur];
a = b;
b = cur;
node = ke[node];
}
if (now < ans) {
kiri = i;
kanan = j;
ans = now;
}
}
}
jaw[mulai] = kiri;
jaw[ke[mulai]] = kanan;
int a = kiri;
int b = kanan;
int node = ke[ke[mulai]];
while (node != -1) {
int cur = 3 - a - b;
a = b;
b = cur;
jaw[node] = cur;
node = ke[node];
}
cout << ans << "\n";
for (int i = 1; i <= n; i++) {
if (i != 1) cout << " ";
cout << jaw[i] + 1;
}
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int i = 1; i <= q; i++) {
int n;
cin >> n;
int a[205];
for (int j = 1; j <= n; j++) cin >> a[j];
for (int j = 1; j <= n; j++) {
int t = a[j], total = 1;
while (t != j) {
total++;
t = a[t];
}
cout << total << ' ';
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string vow = "aeiou";
const int dxhorse[] = {-2, -2, -1, -1, 1, 1, 2, 2};
const int dyhorse[] = {1, -1, 2, -2, 2, -2, 1, -1};
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
const long double pie = 3.14159265358979;
const long long mod = 1e9 + 7;
void solve(int test_case) {
int n;
cin >> n;
string s, t;
cin >> s >> t;
int h[26] = {};
for (auto i : s) h[i - 'a']++;
for (auto i : t) h[i - 'a']++;
int i = 0;
for (; i < 26 && h[i] % 2 == 0; i++)
;
if (i < 26) {
cout << "No";
cout << "\n";
;
return;
}
cout << "Yes\n";
vector<pair<int, int> > v;
while (s != t) {
int i = 0;
for (; i < n && s[i] == t[i]; i++)
;
int j = i + 1;
for (; j < n && s[j] != s[i]; j++)
;
if (j < n) {
v.push_back(make_pair(j, i));
swap(s[j], t[i]);
continue;
;
}
j = i + 1;
for (; j < n && t[j] != t[i]; j++)
;
if (j < n) {
v.push_back(make_pair(i, j));
swap(s[i], t[j]);
continue;
;
}
j = i + 1;
for (; j < n && t[j] != s[i]; j++)
;
v.push_back(make_pair(i + 1, j));
swap(s[i + 1], t[j]);
v.push_back(make_pair(i + 1, i));
swap(s[i + 1], t[i]);
}
cout << v.size();
cout << "\n";
for (auto i : v) cout << i.first + 1 << " " << i.second + 1, cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
for (int i = 0; i < t; i++) solve(i);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 5;
const int L = 20 + 5;
const int S = 2097152 + 5;
const int oo = 1000000000;
int n, p;
int f[N], g[N], v[S];
int z[N][L];
char s[N][L];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%s", s[i] + 1);
p = strlen(s[1] + 1);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= p; ++j) z[i][j] = s[i][j] - '0';
for (int i = 0; i <= 1 << (p + 1); ++i) v[i] = -oo;
int tmp = 0, now = 0;
for (int i = 1; i <= n; ++i) {
int ha1 = 1, ha2 = 0, da = 1, suf = 0;
for (int j = 1; j <= p; ++j) {
ha1 = ha1 * 2 + z[i][j];
ha2 = ha2 + z[i - 1][p - j + 1] * da;
if (ha1 == da * 2 + ha2) suf = j;
da *= 2;
}
if (i == 1)
now = 0;
else
now += suf;
if (i == n) break;
int hash = 1;
f[i] = max(f[i], now);
f[i] = max(f[i], v[2 + (z[i + 1][1] ^ 1)] + now);
for (int j = 1; j <= p; ++j) {
hash = hash * 2 + z[i + 1][j];
f[i] = max(f[i], v[hash] + j + now);
}
ha1 = 1, ha2 = 0, da = 1, suf = 0;
for (int j = 1; j <= p; ++j) {
ha1 = ha1 * 2 + z[i + 1][j];
ha2 = ha2 + z[i][p - j + 1] * da;
if (ha1 == da * 2 + ha2) suf = j;
da *= 2;
}
g[i] = f[i] - (now + suf);
tmp = max(tmp, g[i]);
int t = 0;
da = 1;
for (int j = p; j >= 1; --j) {
t = t + z[i][j] * da;
v[t + da * 2] = max(v[t + da * 2], g[i]);
da *= 2;
}
}
printf("%d\n", n * p - tmp - now);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e6 + 5;
char s[MAXN];
char Ma[MAXN * 2];
int Mp[MAXN * 2];
int dp[MAXN];
int len;
void Manacher(char s[]) {
int l = 0;
Ma[l++] = '$';
Ma[l++] = '#';
for (int i = 0; i < len; i++) {
Ma[l++] = s[i];
Ma[l++] = '#';
}
Ma[l] = 0;
int mx = 0, id = 0;
for (int i = 0; i < l; i++) {
Mp[i] = mx > i ? min(Mp[2 * id - i], mx - i) : 1;
while (Ma[i + Mp[i]] == Ma[i - Mp[i]]) Mp[i]++;
if (i + Mp[i] > mx) {
mx = i + Mp[i];
id = i;
}
}
}
int main() {
scanf("%s", s);
len = strlen(s);
Manacher(s);
long long ans = 0;
for (int i = 1; i <= len; i++) {
if (Mp[i + 1] >= i + 1) {
dp[i] = dp[i >> 1] + 1;
}
ans += dp[i];
}
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int c[n];
for (int i = 0; i < n; ++i) {
cin >> c[i];
}
for (int i = 0; i < n - 1; ++i) {
if (c[i] > 8) {
c[i + 1] += c[i] - 8;
c[i] = 8;
}
}
if (c[n - 1] > 8) {
c[n - 1] = 8;
}
int res = -1;
int sum = 0;
for (int i = 0; i < n; ++i) {
sum += c[i];
if (sum >= k) {
int r = i + 1;
if (res > r || res == -1) {
res = r;
}
}
}
cout << res << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int _kReadBufferSize = 1 << 15;
char _readBuffer[_kReadBufferSize];
int _readPos;
int _readLength;
bool _ended = false;
inline void _loadBuffer() {
_readLength = static_cast<int>(
fread(_readBuffer, sizeof(char), _kReadBufferSize, stdin));
_readPos = 0;
}
inline char readChar(bool advance = true) {
if (_ended) {
return 0;
}
if (_readPos >= _readLength) {
_loadBuffer();
if (_readLength == 0) {
_ended = true;
return 0;
}
}
return _readBuffer[advance ? _readPos++ : _readPos];
}
template <typename T>
inline bool readInt(T& res) {
char ch;
while (true) {
ch = readChar(false);
if (!ch) {
return false;
}
if (!isspace(ch)) {
break;
}
++_readPos;
}
ch = readChar(false);
bool negative = ch == '-';
if (negative) {
++_readPos;
}
res = 0;
while (true) {
ch = readChar(false);
if (!isdigit(ch)) {
break;
}
res = (res << 3) + (res << 1) + (ch & 15);
++_readPos;
}
if (negative) {
res = -res;
}
return true;
}
const int _kWriteBufferSize = 1 << 15;
int _writePos = 0;
char _writeBuffer[_kWriteBufferSize];
inline void writeChar(char x) {
if (_writePos == _kWriteBufferSize) {
fwrite(_writeBuffer, 1, _kWriteBufferSize, stdout);
_writePos = 0;
}
_writeBuffer[_writePos++] = x;
}
struct _Flusher {
inline void flush() {
if (_writePos) {
fwrite(_writeBuffer, 1, _writePos, stdout);
_writePos = 0;
}
fflush(stdout);
}
inline ~_Flusher() { flush(); }
} _flusher;
template <class T>
inline void writeInt(T x, int padding = 0) {
static char s[32];
if (x < 0) {
writeChar('-');
x = -x;
}
int n = 0;
for (; x || !n; x /= 10) {
s[n++] = '0' + x % 10;
}
for (int i = n; i < padding; ++i) {
writeChar('0');
}
for (; n > 0; writeChar(s[--n])) {
}
}
} // namespace io
namespace math {
inline uint32_t nextPow2_32(uint32_t v) {
if (!v) {
return 1;
}
uint32_t res = 1U << (31 - __builtin_clz(v));
return res == v ? res : res << 1;
}
template <typename V, typename V_SQR, V MOD>
struct ModInt {
template <typename T>
inline static T slightFix(T v) {
if (v < 0) {
v += MOD;
} else if (v >= MOD) {
v -= MOD;
}
return v;
}
template <typename T>
inline static V fix(T v) {
if (v < 0 || v >= MOD) {
v = slightFix(v);
}
if (v < 0 || v >= MOD) {
v %= MOD;
}
if (v < 0 || v >= MOD) {
v = slightFix(v);
}
return v;
}
inline ModInt(V v = 0) { _v = fix(v); }
inline void operator=(V v) { _v = fix(v); }
inline void operator+=(const ModInt& o) { _v = slightFix(_v + o._v); }
inline void operator*=(const ModInt& o) {
_v = fix(static_cast<V_SQR>(_v) * o._v);
}
inline void initMul(const ModInt& x, const ModInt& y) {
_v = fix(static_cast<V_SQR>(x._v) * y._v);
}
inline void initSub(const ModInt& x, const ModInt& y) {
_v = slightFix(x._v - y._v);
}
inline ModInt inv() const {
V g = MOD, r = _v, x = 0, y = 1;
while (r != 0) {
V q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return ModInt(x < 0 ? x + MOD : x);
}
template <typename E>
inline ModInt pow(E e) const {
if (e < 0) {
return inv().pow(-e);
}
ModInt res = 1, mul = *this;
while (e) {
if (e & 1) {
res *= mul;
}
e >>= 1;
if (e) {
mul *= mul;
}
}
return res;
}
inline void flip() {
if (MOD > 1) {
_v = MOD - _v;
}
}
int _v;
};
template <typename V, typename V_SQR, V MOD, V ROOT>
struct NTTUtilsFixMod {
using _ModInt = ModInt<V, V_SQR, MOD>;
inline NTTUtilsFixMod(int capacity = -1) { init(capacity); }
inline void init(int capacity = -1) {
_root = _ModInt(ROOT);
_invRoot = _root.inv();
_rootPow = 1 << __builtin_ctz(MOD - 1);
if (capacity > 0) {
capacity = nextPow2_32(capacity);
}
capacity = max(capacity, 2);
_revs.reserve(capacity);
_revs.clear();
_revs.push_back(0);
_revs.push_back(1);
_roots.reserve(capacity | 1);
_roots.clear();
_roots.emplace_back(0);
_roots.emplace_back(1);
_roots.emplace_back(1);
_initCapacity(capacity);
_xs.reserve(capacity);
_ys.reserve(capacity);
}
inline const vector<_ModInt>& mul(const vector<V>& x, const vector<V>& y) {
int pow2 = nextPow2_32(max(static_cast<int>(x.size() + y.size()) - 1, 1));
_xs.resize(pow2);
for (size_t i = 0; i < pow2; ++i) {
_xs[i] = i < x.size() ? x[i] : 0;
}
ntt(_xs, false, pow2);
_ys.resize(pow2);
for (size_t i = 0; i < pow2; ++i) {
_ys[i] = i < y.size() ? y[i] : 0;
}
ntt(_ys, false, pow2);
for (int i = 0; i < pow2; ++i) {
_xs[i] *= _ys[i];
}
ntt(_xs, true, pow2);
_shrink(_xs);
return _xs;
}
inline void _shrink(vector<_ModInt>& vs) {
for (; vs.size() > 1 && !vs.back()._v; vs.pop_back()) {
}
}
inline void ntt(vector<_ModInt>& vs, bool invert, int n = -1) {
int pow2 = nextPow2_32(n < 0 ? vs.size() : n);
_initCapacity(pow2);
_expand(pow2, vs);
int shift = __builtin_ctz(_revs.size()) - __builtin_ctz(pow2);
for (int i = 0; i < pow2; ++i) {
int j = _revs[i] >> shift;
if (i < j) {
swap(vs[i], vs[j]);
}
}
for (int l = 1; l < pow2; l <<= 1) {
for (int i = 0, l2 = l << 1; i < pow2; i += l2) {
int step = invert ? -1 : 1;
for (int j = 0, k = invert ? l2 : l; j < l; ++j, k += step) {
_v.initMul(vs[i + j + l], _roots[k]);
if (invert && j) {
_v.flip();
}
vs[i + j + l].initSub(vs[i + j], _v);
vs[i + j] += _v;
}
}
}
if (invert) {
_v = _ModInt(pow2).inv();
for (int i = 0; i < pow2; ++i) {
vs[i] *= _v;
}
}
}
inline void _initCapacity(int pow2) {
if (_revs.size() >= pow2) {
return;
}
int oldPow2 = _revs.size(), lgN = __builtin_ctz(pow2);
_revs.resize(pow2);
for (int i = 0; i < pow2; ++i) {
_revs[i] = (_revs[i >> 1] >> 1) + ((i & 1) << (lgN - 1));
}
_roots.resize(pow2 | 1);
for (int i = oldPow2; i < pow2; i <<= 1) {
_v = _root.pow((_rootPow / i) >> 1);
for (int j = i; j < i << 1; j += 2) {
_roots[j] = _roots[j >> 1];
_roots[j | 1].initMul(_roots[j], _v);
}
}
_roots[pow2] = _roots[pow2 >> 1];
}
inline void _expand(int pow2, vector<_ModInt>& vs) {
for (size_t i = vs.size(); i < pow2; ++i) {
vs.emplace_back(0);
}
}
vector<int> _revs;
vector<_ModInt> _roots;
_ModInt _root, _invRoot, _v;
int _rootPow;
vector<_ModInt> _xs, _ys;
};
} // namespace math
const int MAXN = 200000 + 2;
const int MAXM = (1000000 + 2) >> 1;
int n, x, y, x1;
vector<int> xs, revXs;
math::NTTUtilsFixMod<int, int64_t, 998244353, 31> ntt(MAXN << 1);
int answers[MAXM];
int main() {
io::readInt(n);
io::readInt(x);
io::readInt(y);
x1 = x + 1;
xs.resize(x1);
revXs.resize(x1);
for (int i = 0; i <= n; ++i) {
int v;
io::readInt(v);
xs[v] = 1;
revXs[x - v] = 1;
}
const auto& delta = ntt.mul(xs, revXs);
memset(answers, 0xFF, sizeof(answers));
for (int i = x + 1, j = y + 1; i <= (x << 1) && j < MAXM; ++i, ++j) {
if (i < delta.size() && delta[i]._v && j < MAXM) {
for (int k = j; k < MAXM; k += j) {
answers[k] = j << 1;
}
}
}
int q;
io::readInt(q);
for (int i = 0; i < q; ++i) {
int x;
io::readInt(x);
io::writeInt(answers[x >> 1]);
io::writeChar(i + 1 == q ? '\n' : ' ');
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e5 + 5;
double dp[Maxn];
int First[Maxn], Next[Maxn * 2], to[Maxn * 2], cnt, WE[Maxn * 2], size[Maxn],
nmsl[Maxn];
inline void add(int z, int y, int w) {
Next[++cnt] = First[z];
First[z] = cnt;
to[cnt] = y;
WE[cnt] = w;
}
inline int R() {
char c;
int res, sign = 1;
while ((c = getchar()) > '9' || c < '0')
if (c == '-') sign = -1;
res = c - '0';
while ((c = getchar()) >= '0' && c <= '9') res = res * 10 + c - '0';
return res * sign;
}
int n, m, O;
void dfs(int pos, int father) {
priority_queue<pair<double, int>, vector<pair<double, int> >,
greater<pair<double, int> > >
q;
double res = 0, S = 0, z = 0;
for (int k = First[pos]; k; k = Next[k]) {
if (to[k] == father) continue;
dfs(to[k], pos);
q.push(make_pair((nmsl[to[k]] + WE[k]) * (double)(size[pos]) / size[to[k]],
k));
}
double rs = 1.0;
if (pos != 1) rs = (double)(size[pos] - 1) / size[pos];
while (!q.empty()) {
int x = q.top().second;
q.pop();
res += (dp[to[x]] + WE[x] + S) * (double)size[to[x]] / (size[pos]);
S += (nmsl[to[x]] + WE[x]) * 2;
}
dp[pos] = res;
}
void deal(int pos, int father) {
size[pos] = 1;
for (int k = First[pos]; k; k = Next[k]) {
if (to[k] == father) continue;
deal(to[k], pos);
nmsl[pos] += WE[k] + nmsl[to[k]];
size[pos] += size[to[k]];
}
}
int main() {
n = R();
int x, y, w;
for (int i = 1; i < n; i++) {
x = R();
y = R();
w = R();
add(x, y, w);
add(y, x, w);
}
deal(1, 0);
size[1]--;
dfs(1, 0);
printf("%.9lf\n", dp[1]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long base, long long exponent, long long modulus) {
if (base == 0 && exponent == 0) return 0;
long long result = 1;
while (exponent > 0) {
if (exponent % 2 == 1) result = (result * base) % modulus;
exponent = exponent >> 1;
base = (base * base) % modulus;
}
return result;
}
int N, x, y;
vector<vector<int> > Adj(6004);
int val[6004];
bool visit[6004];
int LIS[6004];
int ans = 0;
int Max_City = 0;
void dfs(int node) {
int flag = 0;
visit[node] = true;
int p = lower_bound(LIS, LIS + ans, val[node]) - LIS;
if (p == ans) {
ans++;
flag = 1;
}
Max_City = ((Max_City) > (ans) ? Max_City : ans);
int rev = LIS[p];
LIS[p] = val[node];
for (int i = (0); i < (Adj[node].size()); i++) {
if (!visit[Adj[node][i]]) {
dfs(Adj[node][i]);
}
}
if (flag) {
ans--;
} else
LIS[p] = rev;
return;
}
inline void ReadInput(void) {
cin >> N;
for (int i = (1); i < (N + 1); i++) cin >> val[i];
for (int i = (0); i < (N - 1); i++) {
cin >> x >> y;
Adj[x].push_back(y);
Adj[y].push_back(x);
}
}
inline void solve(void) {
for (int i = (1); i < (N + 1); i++) {
ans = 0;
for (int i = (1); i < (N + 2); i++) {
visit[i] = false;
LIS[i] = 0;
}
dfs(i);
}
cout << Max_City << endl;
}
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
ReadInput();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e9 + 1;
const double pi = 3.1415926535897932384626433832;
const long long M = 2e18 + 7;
long long bis(long long a[], long long l, long long r, long long x) {
while (l <= r) {
long long m = l + (r - l) / 2;
if (a[m] == x) return m;
if (a[m] < x)
l = m + 1;
else
r = m - 1;
}
return -1;
}
void addEdge(vector<long long> adj[], long long u, long long v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
void DFSUtil(long long u, vector<long long> adj[], vector<bool> &visited) {
visited[u] = true;
for (long long i = 0; i < adj[u].size(); i++)
if (visited[adj[u][i]] == false) DFSUtil(adj[u][i], adj, visited);
}
void DFS(vector<long long> adj[], long long V) {
vector<bool> visited(V, false);
for (long long u = 0; u < V; u++)
if (visited[u] == false) DFSUtil(u, adj, visited);
}
void addEdge(vector<pair<long long, long long> > adj[], long long u,
long long v, long long wt) {
adj[u].push_back(make_pair(v, wt));
adj[v].push_back(make_pair(u, wt));
}
long long gcd(long long x, long long y) {
if (x == 0)
return y;
else
return gcd(y % x, x);
}
long long lcm(long long x, long long y) { return (x * y) / gcd(x, y); }
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6) {
if (n % i == 0 || n % (i + 2) == 0) {
return false;
}
}
return true;
}
bool pdrome(string s) {
long long n = s.length();
for (long long i = 0; i < n / 2; i++) {
if (s[i] != s[n - i - 1]) {
return false;
}
}
return true;
}
long long mindig(long long x) {
long long ans = 9;
long long t = x;
while (x) {
ans = min(ans, x % 10);
x /= 10;
}
x = t;
return ans;
}
long long maxdig(long long x) {
long long ans = 0;
long long t = x;
while (x) {
ans = max(ans, x % 10);
x /= 10;
}
x = t;
return ans;
}
long long modpow(long long x, long long n, long long M) {
if (n == 0) return 1 % M;
long long u = modpow(x, n / 2, M);
u = (u * u) % M;
if (n % 2 == 1) u = (u * x) % M;
return u;
}
long long sum(long long a) {
long long result = 0;
while (a > 0) {
result += a % 10;
a /= 10;
}
return result;
}
long long digits(long long n) { return floor(log10(n) + 1); }
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, k, i, p1 = 0, p2 = 0;
string s;
cin >> n >> k >> s;
if (k == 2) {
for (i = 0; i < n; i++) {
if (s[i] - 'A' != i % 2)
p1++;
else
p2++;
}
cout << min(p1, p2) << endl;
if (p1 < p2)
for (i = 0; i < n; i++) cout << char('A' + i % 2);
else
for (i = 0; i < n; i++) cout << char('A' + 1 - (i % 2));
} else {
for (i = 1; i < n; i++) {
if (s[i] == s[i - 1]) {
p1++;
s[i] = 'A';
while (s[i] == s[i - 1] || s[i] == s[i + 1]) s[i]++;
}
}
cout << p1 << endl << s;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18 + 5;
const int N = 1e5 + 10;
const long long mod = 1e9 + 7;
const int Mx = 1e7;
const string t = "RGB";
void solve() {
int n;
cin >> n;
int tmp = n;
if (n % 4 == 0) {
cout << 0 << endl;
cout << n / 2 << " ";
for (int i = 1; i <= n / 4; i++) {
cout << i << " " << (n + 1) - i << " ";
}
} else if (n % 4 == 1) {
cout << 1 << endl;
cout << (n + 1) / 2 << " ";
cout << 1 << " ";
int ans = 2;
for (int i = 0; i < (n - 1) / 4; i++) {
cout << ans << " " << tmp << " ";
ans++;
tmp--;
}
} else if (n % 4 == 2) {
cout << 1 << endl;
cout << n / 2 << " ";
cout << 1 << " ";
int ans = 3;
for (int i = 0; i < (n - 2) / 4; i++) {
cout << ans << " " << tmp << " ";
ans++;
tmp--;
}
} else {
cout << 0 << endl;
cout << (n - 3) / 2 + 2 << " ";
cout << 1 << " " << 2 << " ";
int ans = 4;
for (int i = 0; i < (n - 3) / 4; i++) {
cout << ans << " " << tmp << " ";
ans++;
tmp--;
}
}
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.