solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int b = 0;
for (int i = 0; i < n; i++) {
if (a[i + 1] == a[i]) b++;
}
cout << b;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, i;
scanf("%d", &n);
for (i = 1; i <= n * 2 / 3; i++) printf("0 %d\n", i);
for (i = 1; i <= n - n * 2 / 3; i++) printf("3 %d\n", i * 2);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[610000];
int n;
int solve(int x, int y) {
if (x == y) return 0;
for (int i = x; i + 1 <= y; i++) {
if (a[i] == a[i + 1]) return max(solve(x, i), solve(i + 1, y));
}
int len = (y - x + 1);
if (a[x] != a[y]) {
int first = len / 2;
for (int i = x; i < x + first; i++) a[i] = a[x];
for (int i = x + first; i <= y; i++) a[i] = a[y];
} else {
for (int i = x; i <= y; i++) a[i] = a[x];
}
return (len - 1) / 2;
}
int main() {
scanf("%d", &n);
for (int(i) = 0; (i) < (int)(n); (i)++) scanf("%d", &a[i]);
printf("%d\n", solve(0, n - 1));
for (int(i) = 0; (i) < (int)(n); (i)++) printf("%d ", a[i]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 5;
const int K = 20 + 5;
const int MOD = 1000000007;
const int INF = 1 << 30;
vector<int> G[N];
int64_t dp[N][K][K << 1], tmp[K][K << 1];
void dfs(int, int, int);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--, v--;
G[u].push_back(v);
G[v].push_back(u);
}
dfs(0, 0, k);
int64_t ans = 0;
for (int i = -1; i <= 2 * k; i++) ans = (ans + dp[0][0][i + 1]) % MOD;
cout << ans << '\n';
return 0;
}
void dfs(int u, int f, int k) {
dp[u][0][1] = 1;
dp[u][1][0] = 1;
for (auto v : G[u]) {
if (v == f) continue;
dfs(v, u, k);
memset(tmp, 0, sizeof(tmp));
for (int w1 = -1; w1 <= k; w1++)
for (int b1 = -1; b1 <= 2 * k; b1++) {
for (int w = -1; w <= k; w++)
for (int b = -1; b <= 2 * k; b++) {
int w2 = w < 0 ? -1 : w + 1, b2 = b < 0 ? INF : b + 1;
int nw = max(w1, w2), nb = min(b1 < 0 ? INF : b1, b2);
int64_t cur = (dp[u][w1 + 1][b1 + 1] * dp[v][w + 1][b + 1]) % MOD;
if (nb == INF)
tmp[nw + 1][0] = (tmp[nw + 1][0] + cur) % MOD;
else if (nw + nb <= k)
tmp[0][nb + 1] = (tmp[0][nb + 1] + cur) % MOD;
else
tmp[nw + 1][nb + 1] = (tmp[nw + 1][nb + 1] + cur) % MOD;
}
}
for (int a = 0; a <= k + 2; a++)
for (int b = 0; b <= 2 * k + 2; b++) {
dp[u][a][b] = tmp[a][b];
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int primes[3] = {2, 3, 5};
int a[2], b[2], cnt[2][3] = {};
cin >> a[0] >> a[1];
b[0] = a[0];
b[1] = a[1];
for (int i = 0, _i = (2); i < _i; ++i) {
for (int j = 0, _j = (3); j < _j; ++j) {
while (!(b[i] % primes[j])) {
b[i] /= primes[j];
cnt[i][j]++;
}
}
}
int ans = -1;
if (b[1] == b[0]) {
ans = 0;
for (int j = (3), _j = (0); --j >= _j;) {
for (int i = 0, _i = (2); i < _i; ++i)
if (cnt[i][j] > cnt[1 - i][j]) {
ans += cnt[i][j] - cnt[1 - i][j];
}
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 1e5 + 10;
int n;
double p[mxN], ans = 0.0, cur = 0.0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i];
cur = (cur + 1) * p[i];
ans += cur * 2 - p[i];
}
cout << fixed << setprecision(12) << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 5;
const int M = 200 + 5;
vector<int> adj[N];
int state[N], cur[N], taken[N];
int main() {
int n, m, a, b, k;
cin >> n >> m;
k = n;
vector<int> sol;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--, b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int i = 0; i < n; i++) cin >> state[i];
queue<int> q;
for (int i = 0; i < n; i++)
if (cur[i] == state[i]) q.push(i);
while (!q.empty() && k > 0) {
int i = q.front();
q.pop();
if (state[i] != cur[i] || taken[i]) continue;
taken[i] = 1;
sol.push_back(i);
k--;
cur[i]++;
for (int j = 0; j < adj[i].size(); j++) cur[adj[i][j]]++;
for (int j = 0; j < adj[i].size(); j++) {
if (taken[adj[i][j]]) continue;
int node = adj[i][j];
if (cur[node] == state[node]) q.push(node);
}
}
for (int i = 0; i < n; i++) {
if (state[i] == cur[i]) {
cout << -1;
return 0;
}
}
cout << sol.size() << endl;
for (int i = 0; i < sol.size(); i++) cout << sol[i] + 1 << ' ';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
struct node {
int x, y, c;
double f;
} q[400009];
bool cmp(node a, node b) { return a.f < b.f; }
int n, c, d, tot, k1[400009], k2[400009], g0, g1;
int main() {
n = read(), c = read(), d = read();
for (int i = 1; i <= n; i++) {
int x = read() - c, y = read() - d;
if (y != 0)
q[++tot] = (node){x, y, y > 0 ? 1 : 0, 1.0 * x / y};
else if (x > 0)
g1++;
else
g0++;
}
sort(q + 1, q + 1 + tot, cmp);
int now = 0, a = 0, b = 0;
for (int i = 1; i <= tot; i++) {
while (now < i - 1 &&
1LL * q[i].x * q[now + 1].y != 1LL * q[now + 1].x * q[i].y) {
now++;
if (q[now].c == 1)
a++;
else
b++;
}
if (q[i].c == 1)
k1[i] = b;
else
k1[i] = a;
}
now = tot + 1, a = 0, b = 0;
for (int i = tot; i >= 1; i--) {
while (i + 1 < now &&
1LL * q[i].x * q[now - 1].y != 1LL * q[now - 1].x * q[i].y) {
now--;
if (q[now].c == 1)
a++;
else
b++;
}
if (q[i].c == 1)
k2[i] = b;
else
k2[i] = a;
}
long long ans = 0;
for (int i = 1; i <= tot; i++) ans += 1LL * k1[i] * k2[i];
for (int i = 1; i <= tot; i++)
if (q[i].c == 0) ans += 1LL * k1[i] * g1;
for (int i = 1; i <= tot; i++)
if (q[i].c == 1) ans += 1LL * k1[i] * g0;
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
char letters[1000001];
char answers[1000][1001];
int count[26];
char getMinChar() {
static int index = 0;
while (index < 26) {
if (count[index]) {
--count[index];
return index + 'a';
} else
++index;
}
return '-';
}
int main() {
int n, l, k;
scanf("%d%d%d%s", &n, &l, &k, letters);
int length = strlen(letters);
for (int i = 0; i < length; ++i) ++count[letters[i] - 'a'];
int ansStart = 0;
for (int i = 0; i < l; ++i) {
for (int j = ansStart; j < k; ++j) answers[j][i] = getMinChar();
int prevAnsStart = ansStart;
for (int j = k - 1; j >= prevAnsStart; --j) {
if (answers[j][i] == answers[k - 1][i])
ansStart = j;
else
break;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < l; ++j)
if (answers[i][j] == 0) answers[i][j] = getMinChar();
printf("%s\n", answers[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t a[6], b, i, c, x, h, y, n;
cin >> x >> y;
cin >> n;
h = 1000000007;
a[0] = (x + h) % h;
a[1] = (y + h) % h;
a[2] = (y - x + 2 * h) % h;
a[3] = (-x + h) % h;
a[4] = (-y + h) % h;
a[5] = (-y + x + 2 * h) % h;
cout << a[(n - 1) % 6];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
const int mod = 1e9 + 7;
const int N = 2e5 + 10;
const int M = 202;
int power(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) {
res = 1LL * res * a % mod;
}
a = 1LL * a * a % mod;
b >>= 1;
}
return res;
}
int main() {
int n, k, curr = 1, nxt = 2, tot[N] = {0};
scanf("%d %d", &n, &k);
if (n > 1LL * k * (k - 1)) {
printf("NO\n");
return 0;
}
printf("YES\n");
int b = 0;
for (int i = 1; i <= n; i++) {
if (b == 0) {
printf("%d %d\n", curr, nxt);
} else {
printf("%d %d\n", nxt, curr);
nxt++;
}
if (nxt > k) {
curr++;
nxt = curr + 1;
}
b ^= 1;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int mas[101] = {0};
int n, a;
cin >> n;
int ans = 0;
vector<int> v;
for (int i = 0; i < n; i++) {
cin >> a;
v.push_back(a);
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
if (mas[v[i]] == 0) {
for (int j = v[i]; j <= 100; j += v[i]) mas[j] = 1;
ans++;
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[10000];
vector<string> ans;
int main() {
cin >> s;
n = strlen(s);
if (s[0] == '@' || s[n - 1] == '@') {
cout << "No solution" << endl;
return 0;
}
bool w = false;
for (int i = 0; i < n; i++)
if (s[i] == '@') w = true;
if (!w) {
cout << "No solution" << endl;
return 0;
}
ans.clear();
for (int i = 0; i < n; i++) {
if (i == 0 || (i > 1 && s[i - 2] == '@')) ans.push_back("");
ans[ans.size() - 1] += s[i];
}
w = false;
for (int i = 0; i < ans[ans.size() - 1].size(); i++)
if (ans[ans.size() - 1][i] == '@') w = true;
if (ans.size() > 1 && !w) {
ans[ans.size() - 2] += ans[ans.size() - 1];
ans.pop_back();
}
for (int i = 0; i < ans.size(); i++) {
int cnt = 0;
for (int j = 0; j < ans[i].size(); j++)
if (ans[i][j] == '@') cnt++;
if (cnt != 1) {
cout << "No solution" << endl;
return 0;
}
if (ans[i][0] == '@' || ans[i][ans[i].size() - 1] == '@') {
cout << "No solution" << endl;
return 0;
}
}
for (int i = 0; i < ans.size(); i++) {
if (i) cout << ',';
cout << ans[i];
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 22, INF = 1e10 + 7;
long long n, k, s, t, x, dis[MAXN], high, low, mid;
pair<long long, long long> car[MAXN];
bool check(long long ans) {
if (ans < x) return false;
long long u, e = 0;
for (int i = 1; i <= k + 1; i++) {
u = ans - dis[i] + dis[i - 1];
if (u <= dis[i] - dis[i - 1])
e += u + (2 * (dis[i] - dis[i - 1]) - ans) * 2;
else
e += dis[i] - dis[i - 1];
}
if (e <= t)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) cin >> car[i].first >> car[i].second;
dis[k + 1] = s;
for (int i = 1; i <= k; i++) cin >> dis[i];
sort(dis + 1, dis + 1 + k);
sort(car + 1, car + 1 + n);
for (int i = 1; i <= k + 1; i++) x = max(x, dis[i] - dis[i - 1]);
low = 0, high = INF;
while (high >= low) {
mid = (low + high) / 2;
if (check(mid))
high = mid - 1;
else
low = mid + 1;
}
for (int i = 1; i <= n; i++) {
if (car[i].second >= low) {
cout << car[i].first;
return 0;
}
}
cout << -1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, num, test, kase = 0;
long long int n;
while (cin >> n) {
int sev, four;
sev = four = 0;
k = n / 4;
bool yes = false;
for (i = k; i >= 0; i--) {
j = n - (4 * i);
if (j % 7 == 0) {
yes = true;
four = i;
sev = j / 7;
}
}
if (yes) {
for (i = 1; i <= four; i++) cout << 4;
for (i = 1; i <= sev; i++) cout << 7;
} else
cout << -1;
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> sc, goal, missed, ch;
int main(void) {
string a, b, c;
for (int i = 0; i < 5; i++) {
cin >> a >> b >> c;
int s, t;
sscanf(c.c_str(), "%d:%d", &s, &t);
if (s > t) sc[a] += 3;
if (s < t) sc[b] += 3;
if (s == t) sc[a]++, sc[b]++;
goal[a] += s;
missed[a] += t;
goal[b] += t;
missed[b] += s;
ch[a]++;
ch[b]++;
}
string me = "BERLAND", other;
for (map<string, int>::iterator it = ch.begin(); it != ch.end(); it++)
if (it->second == 2 && it->first != "BERLAND") other = it->first;
for (int DIF = 1; DIF <= 40; DIF++) {
for (int Y = 0; Y <= 40; Y++) {
int X = Y + DIF;
sc[me] += 3;
goal[me] += X;
missed[me] += Y;
goal[other] += Y;
missed[other] += X;
int cnt = 0;
for (map<string, int>::iterator it = ch.begin(); it != ch.end(); it++) {
if (it->first == me) continue;
if (sc[it->first] > sc[me]) {
++cnt;
continue;
}
if (sc[it->first] < sc[me]) continue;
int v = (goal[it->first] - missed[it->first]);
int vm = goal[me] - missed[me];
if (v > vm) {
++cnt;
continue;
}
if (v < vm) continue;
v = goal[it->first];
vm = goal[me];
if (v > vm) {
++cnt;
continue;
}
if (v < vm) continue;
if (it->first < me) {
++cnt;
continue;
}
}
if (cnt <= 1) {
printf("%d:%d\n", X, Y);
return 0;
}
goal[me] -= X;
missed[me] -= Y;
goal[other] -= Y;
missed[other] -= X;
sc[me] -= 3;
}
}
puts("IMPOSSIBLE");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-6;
const long long MOD = 1000000009;
const int maxn = 1 << 20;
long long two[maxn];
int main() {
int n;
cin >> n;
two[0] = 1;
for (int i = 1; i < maxn; i++) two[i] = (two[i - 1] << 1) % MOD;
long long x = 2;
for (int i = (n - 2) / 2; i >= 2; i--) {
x = (x + 2) % MOD;
x = (2 + 3 * x + 2 * x * (two[i] - 3));
}
if (n >= 4) {
x = (x + 4) % MOD;
}
long long res = (2 * (1 + x * x)) % MOD;
cout << res << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string k, p;
long long a, b = 0, c, d = 0, e = 0, f = 1, g, h, i, j, l, m, n, o, q, r, s,
t, u, v, w, x, y, z;
cin >> a >> k;
for (i = 1; i < a; i++) {
if (k[i] != k[i - 1]) {
i++;
b++;
}
}
cout << a - b;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
clock_t time_p = clock();
void ktj() {
time_p = clock() - time_p;
cerr << "Time elapsed : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
int n, k;
const int N = 1000 + 1;
vector<int> g[N];
int dp[N];
bool vis[N];
int len = 0;
void dfs(int v) {
if (vis[v]) return;
vis[v] = 1;
dp[v] = 1;
for (auto x : g[v]) {
if (!vis[x]) dfs(x);
dp[v] = max(dp[v], dp[x] + 1);
}
len = max(len, dp[v]);
}
int main() {
int i, j, l;
cin >> n >> k;
vector<vector<int> > perm(k, vector<int>(n));
vector<vector<int> > idx(k, vector<int>(n));
for (i = 0; i < k; i++) {
for (j = 0; j < n; j++) {
cin >> perm[i][j];
perm[i][j]--;
idx[i][perm[i][j]] = j;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i == j) continue;
bool ok = 1;
for (l = 0; l < k; l++) {
if (idx[l][i] > idx[l][j]) {
ok = 0;
break;
}
}
if (ok) {
g[i].push_back(j);
}
}
}
for (i = 0; i < n; i++) {
if (!vis[i]) {
dfs(i);
}
}
cout << len << '\n';
ktj();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void chef(int n) {
int x = 0;
while (n--) {
string a;
cin >> a;
if (a[1] == '+')
x = x + 1;
else
x = x - 1;
}
cout << x;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
chef(n);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int nums[n];
int maxi = 0;
for (int i = 0; i < n; i++) {
cin >> nums[i];
if (nums[i] > maxi) {
maxi = nums[i];
}
}
int diffs[maxi + 1];
int mo[maxi + 1];
for (int i = 0; i <= maxi; i++) {
diffs[i] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
diffs[abs(nums[i] - nums[j])]++;
}
}
for (int i = 0; i <= maxi; i++) {
mo[i] = 0;
}
int cnt;
int ans;
int cnt2;
for (int i = 1; i <= maxi; i++) {
cnt = 0;
for (int j = i; j <= maxi; j = j + i) {
cnt = cnt + diffs[j];
}
if (cnt > k * (k + 1) / 2) {
continue;
}
cnt2 = 0;
for (int j = 0; j < n; j++) {
if (mo[nums[j] % i] == i) cnt2++;
mo[nums[j] % i] = i;
}
if (cnt2 <= k) {
cout << i;
return 0;
}
}
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, i = 1;
long long int a, s = 0;
scanf("%d", &n);
while (n--) {
scanf("%I64d", &a);
s = s + (a - 1) * i + 1;
i++;
}
printf("%I64d\n", s);
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:200000000")
using namespace std;
int r, g, b;
int main() {
scanf("%d %d %d", &r, &g, &b);
int i, c = 0;
for (i = 1; (g + r + b); i++) {
c += 1;
c %= 3;
(!c) ? c = 3 : 1;
if (c == 1)
(r >= 2) ? r -= 2 : r = 0;
else if (c == 2)
(g >= 2) ? g -= 2 : g = 0;
else if (c == 3)
(b >= 2) ? b -= 2 : b = 0;
}
printf("%d", (i - 2) + 30);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[300];
int colone[300];
int coltwo[300];
int grid[300][300];
char readin[2000];
int calcColumnTwo(int j, int i) {
if (dp[i] != -1) return dp[i];
int ret = 0;
if (!(grid[i][j] / 10 == 1 || grid[i][j + 1] / 10 == 1))
ret += calcColumnTwo(j, i + 1);
if (!(grid[i][j] > 20 || grid[i][j + 1] > 20 || grid[i + 1][j] > 20 ||
grid[i + 1][j + 1] > 20))
ret += calcColumnTwo(j, i + 2);
ret %= 1000000007;
return dp[i] = ret;
}
int calc(int col) {
if (dp[col] != -1) return dp[col];
long long ret = 0;
ret += 1LL * colone[col] * calc(col + 1);
ret += 1LL * coltwo[col + 1] * calc(col + 2);
ret %= 1000000007;
return dp[col] = ret;
}
int main() {
int n, m;
int i, j;
int code[513];
scanf("%d %d", &n, &m);
code[0] = 0;
code[16] = 1;
code[257] = 22;
code[68] = 12;
code[84] = 13;
code[273] = 23;
code[325] = 4;
code[341] = 5;
code[455] = 26;
code[365] = 16;
memset(grid, 0, sizeof(grid));
for (i = 0; i < n; i++) {
scanf("%s", readin);
scanf("%s", readin);
for (j = 0; j < m; j++) {
if (readin[j * 4 + 1] == 'O') grid[i][j] |= 256;
if (readin[j * 4 + 2] == 'O') grid[i][j] |= 128;
if (readin[j * 4 + 3] == 'O') grid[i][j] |= 64;
}
scanf("%s", readin);
for (j = 0; j < m; j++) {
if (readin[j * 4 + 1] == 'O') grid[i][j] |= 32;
if (readin[j * 4 + 2] == 'O') grid[i][j] |= 16;
if (readin[j * 4 + 3] == 'O') grid[i][j] |= 8;
}
scanf("%s", readin);
for (j = 0; j < m; j++) {
if (readin[j * 4 + 1] == 'O') grid[i][j] |= 4;
if (readin[j * 4 + 2] == 'O') grid[i][j] |= 2;
if (readin[j * 4 + 3] == 'O') grid[i][j] |= 1;
}
for (j = 0; j < m; j++) grid[i][j] = code[grid[i][j]];
}
memset(colone, 0, sizeof(colone));
for (j = 0; j < m; j++) {
for (i = 0; i < n; i += 2)
if (grid[i][j] > 20 || grid[i + 1][j] > 20) break;
if (i == n) colone[j] = 1;
}
memset(coltwo, 0, sizeof(coltwo));
for (j = 1; j < m; j++) {
memset(dp, -1, sizeof(dp));
dp[n] = 1;
dp[n + 1] = 0;
coltwo[j] = calcColumnTwo(j - 1, 0);
if (colone[j - 1] && colone[j]) {
coltwo[j]--;
if (coltwo[j] < 0) coltwo[j] += 1000000007;
}
}
memset(dp, -1, sizeof(dp));
dp[m] = 1;
dp[m + 1] = 0;
cout << calc(0) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<int> ys;
map<int, int> idxy, idxx;
vector<vector<int>> yx;
vector<int> sum, bit;
void update(int x, int val) {
while (x < N) {
sum[x] += val;
x += (x & -x);
}
}
long long query(int r) {
long long ans = 0;
while (r > 0) {
ans += sum[r];
r -= (r & -r);
}
return ans;
}
int main() {
int n;
cin >> n;
sum = vector<int>(N, 0);
bit = vector<int>(N, 0);
yx = vector<vector<int>>(N);
set<int> xset;
int tot = 0;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
xset.insert(x);
if (!idxy.count(y)) {
idxy[y] = ++tot;
ys.push_back(y);
}
yx[idxy[y]].push_back(x);
}
tot = 0;
for (auto x : xset) {
idxx[x] = ++tot;
}
xset.clear();
sort(ys.begin(), ys.end(), greater<int>());
long long ans = 0, cnt = 0;
for (auto y : ys) {
sort(yx[idxy[y]].begin(), yx[idxy[y]].end());
xset.insert(yx[idxy[y]].begin(), yx[idxy[y]].end());
cnt = xset.size();
;
ans += (cnt * (cnt + 1) / 2);
int pre = 0;
for (auto x : yx[idxy[y]]) {
long long ret = query(idxx[x] - 1) - query(pre);
ans -= (ret * (ret + 1) / 2);
pre = idxx[x];
if (bit[idxx[x]] == 0) {
bit[idxx[x]] = 1;
update(idxx[x], 1);
}
}
long long ret = query(tot) - query(pre);
ans -= (ret * (ret + 1) / 2);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400005;
int tree[N], lazy[N];
void updateRange(long long node, long long start, long long end, long long l,
long long r, long long val) {
if (lazy[node] != 0) {
tree[node] += (end - start + 1) * lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start > end or start > r or end < l) return;
if (start >= l and end <= r) {
tree[node] += (end - start + 1) * val;
if (start != end) {
lazy[node * 2] += val;
lazy[node * 2 + 1] += val;
}
return;
}
long long mid = (start + end) / 2;
updateRange(node * 2, start, mid, l, r, val);
updateRange(node * 2 + 1, mid + 1, end, l, r, val);
tree[node] = tree[node * 2] + tree[node * 2 + 1];
}
long long queryRange(long long node, long long start, long long end,
long long l, long long r) {
if (start > end or start > r or end < l) return 0;
if (lazy[node] != 0) {
tree[node] += (end - start + 1) * lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start >= l and end <= r) return tree[node];
long long mid = (start + end) / 2;
long long p1 = queryRange(node * 2, start, mid, l, r);
long long p2 = queryRange(node * 2 + 1, mid + 1, end, l, r);
return (p1 + p2);
}
long long n;
long long V[100005], T[100005], S[100005];
long long answer[100005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> V[i];
for (long long i = 1; i <= n; i++) cin >> T[i], S[i] = S[i - 1] + T[i];
for (long long i = 1; i <= n; i++) {
long long lo = i, hi = n, ans = i - 1, mid;
while (lo <= hi) {
mid = (lo + hi) / 2;
long long melted = S[mid] - S[i - 1];
if (melted <= V[i]) {
ans = mid;
lo = mid + 1;
} else {
hi = mid - 1;
}
}
updateRange(1, 1, n, i, ans, 1);
long long melted = S[ans] - S[i - 1];
long long remain = V[i] - melted;
answer[ans + 1] += remain;
}
for (int i = 1; i <= n; i++) {
long long bing = queryRange(1, 1, n, i, i);
answer[i] += bing * T[i];
cout << answer[i] << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int t;
cin >> t;
while (t--) {
int n;
string s;
cin >> n >> s;
int l = n, r = 0;
bool flag = false;
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
flag = true;
l = i;
break;
}
}
if (!flag) {
cout << n << endl;
continue;
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '1') {
r = i;
break;
}
}
int m = min(l, n - 1 - r);
cout << 2 * (n - m) << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, q;
int a[100001];
int b[100001];
int kth[100001];
int cou[100001];
vector<int> t[4 * 100001];
void build(int v, int tl, int tr) {
if (tl == tr)
t[v].push_back(b[tl]);
else {
int tm = (tl + tr) / 2;
build(v * 2, tl, tm);
build(v * 2 + 1, tm + 1, tr);
t[v] = t[v * 2];
t[v].insert(t[v].end(), t[v * 2 + 1].begin(), t[v * 2 + 1].end());
sort(t[v].begin(), t[v].end());
}
}
int query(int v, int tl, int tr, int l, int r, int perm_l) {
if (l > r) return 0;
if (l == tl && r == tr) {
int mid = 0;
int ttl = 0;
int ttr = t[v].size() - 1;
while (ttl < ttr || mid != ttl) {
mid = (ttl + ttr + 1) / 2;
if (t[v][mid] >= perm_l)
ttr = mid - 1;
else
ttl = mid;
}
if (mid == 0 && t[v][0] >= perm_l) return 0;
return mid + 1;
}
int tm = (tl + tr) / 2;
return query(v * 2, tl, tm, l, min(r, tm), perm_l) +
query(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, perm_l);
}
int main(void) {
ios::sync_with_stdio(0);
cin >> n >> k;
memset(kth, -1, sizeof(kth));
for (int i = 0; i < n; i++) {
cin >> a[i];
cou[a[i]]++;
if (cou[a[i]] > k) {
while (a[++kth[a[i]]] != a[i])
;
b[i] = kth[a[i]];
} else
b[i] = -1;
}
build(1, 0, n - 1);
cin >> q;
int last = 0;
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
l = (l + last) % n;
r = (r + last) % n;
if (l > r) swap(l, r);
last = query(1, 0, n - 1, l, r, l);
cout << last << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 5, MAXM = 8e2;
int n, Q, a[MAXN];
long long sum[MAXM][MAXM];
int main() {
n = 500000;
scanf("%d", &Q);
int B = sqrt(n * 1.0);
for (int i = 1; i <= Q; i++) {
char opt[5];
scanf("%s", opt);
if (opt[0] == '1') {
int k;
long long x;
scanf("%d %lld", &k, &x);
a[k] += x;
for (int i = 1; i <= B; i++) sum[i][k % i] += x;
} else {
int k, b;
scanf("%d %d", &k, &b);
if (k > B) {
long long ans = 0;
for (int i = b; i <= n; i += k) ans += a[i];
printf("%lld\n", ans);
} else {
printf("%lld\n", sum[k][b]);
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, y, num = 0, fact = 1;
cin >> n >> m;
list<int> q, p, ans;
while (n > 0) {
q.push_front(n % 3);
n /= 3;
}
while (m > 0) {
p.push_front(m % 3);
m /= 3;
}
while (q.size() < p.size()) q.push_front(0);
while (p.size() < q.size()) p.push_front(0);
while (!q.empty()) {
x = q.back(), y = p.back();
ans.push_front((y - x + 3) % 3);
q.pop_back(), p.pop_back();
}
while (!ans.empty()) {
x = ans.back();
num += (fact * x);
ans.pop_back(), fact *= 3;
}
cout << num;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
using namespace std;
struct node {
int next, to;
} w[2000010];
int n, m, cnt = 1, ans[1000005], h[1000005], top, ln, op, c[1000005],
dfn[1000005], timer, bj[1000005], v[1000005], id[2000005];
const int MAX_SIZE = 1 << 21;
char *l, *r, buf[MAX_SIZE];
inline int gc() {
if (l == r)
if (l == (r = (l = buf) + fread(buf, 1, MAX_SIZE, stdin))) return -1;
return *l++;
}
inline void read(int &x) {
register char c = gc();
for (; c < 48 || c > 57; c = gc())
;
for (x = 0; c > 47 && c < 58; c = gc()) x = (x << 3) + (x << 1) + (c ^ 48);
}
inline void write(int x) {
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
void add(int x, int y, int z) {
cnt++;
w[cnt].to = y;
w[cnt].next = h[x];
id[cnt] = z;
h[x] = cnt;
}
inline void DFS1(int u, int co, int tag) {
register int i;
c[u] = co;
dfn[u] = ++timer;
for (i = h[u]; i; i = w[i].next) {
if (i == (tag ^ 1)) {
continue;
}
int e = w[i].to;
if (c[e] == 0) {
DFS1(e, 3 - co, i);
} else {
if (dfn[u] < dfn[e]) {
continue;
}
if (c[u] == c[e]) {
op++;
ln = i;
bj[u]++;
bj[e]--;
} else {
bj[u]--;
bj[e]++;
}
}
}
}
inline void DFS2(int u, int tag) {
register int i;
v[u] = 1;
for (i = h[u]; i; i = w[i].next) {
if (i == (tag ^ 1)) continue;
int e = w[i].to;
if (v[e] == 0) {
DFS2(e, i);
bj[u] += bj[e];
}
}
if (bj[u] == op) {
top++;
ans[top] = tag;
}
}
int main() {
register int i, x, y;
read(n);
read(m);
for (i = 1; i <= m; i++) {
read(x);
read(y);
if (x == y) {
op++;
add(0, 0, i);
ln = cnt;
continue;
}
add(x, y, i);
add(y, x, i);
}
for (i = 1; i <= n; i++) {
if (c[i] == 0) {
DFS1(i, 1, 0);
}
}
for (i = 1; i <= n; i++) {
if (v[i] == 0) {
DFS2(i, 0);
}
}
if (op == 0) {
write(m);
putchar('\n');
for (i = 1; i <= m; i++) {
write(i);
putchar(' ');
}
} else {
if (op == 1) {
top++;
ans[top] = ln;
}
write(top);
putchar('\n');
sort(ans + 1, ans + 1 + top);
for (i = 1; i <= top; i++) {
write(id[ans[i]]);
putchar(' ');
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long memo[2010][2010], c[2010], t[2010];
long long Min(long long a, long long b) { return a < b ? a : b; }
long long sum_c = 0;
long long kns(int id, int time) {
if (time >= n) return 0;
if (id == n) return 1e18;
if (memo[id][time] != -1) return memo[id][time];
return memo[id][time] = Min(kns(id + 1, time),
c[id] + kns(id + 1, Min(2000, t[id] + time)));
}
int main() {
scanf("%d", &n);
memset(memo, -1, sizeof memo);
for (int i = 0; i < n; i++) {
scanf("%d%I64d", &t[i], &c[i]);
t[i]++;
}
printf("%I64d\n", kns(0, 0));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const int N = 1e5 + 7;
int n, m, k, s, arr[N], res[N][150];
struct emp {
int x, y, c;
};
vector<vector<int> > vt;
queue<emp> Q;
int main(void) {
scanf("%d %d %d %d", &n, &m, &k, &s);
vt.resize(n + 1);
for (int i = 1; i <= n; i++) {
int T;
scanf("%d", &T);
Q.push({i, 0, T});
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) res[i][j] = INF;
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
vt[x].push_back(y);
vt[y].push_back(x);
}
while (!Q.empty()) {
emp fr = Q.front();
Q.pop();
if (res[fr.x][fr.c] <= fr.y) continue;
res[fr.x][fr.c] = fr.y;
for (auto next : vt[fr.x]) Q.push({next, fr.y + 1, fr.c});
}
for (int i = 1; i <= n; i++) {
sort(res[i] + 1, res[i] + k + 1);
int ans = 0;
for (int j = 1; j <= s; j++) ans += res[i][j];
printf("%d ", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897923846;
const long long int MOD = 1000000007;
const long long int N = 998244353;
long long int power(long long int x, long long int n) {
long long int res = 1;
while (n > 0) {
if (n & 1) res = res * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return res;
}
long long int modinverse(long long int a) { return power(a, MOD - 2); }
int cot[3001][3001];
long long int n, m;
vector<vector<int>> adj;
void dfs(long long int node, long long int parent) {
if (parent == -1) {
for (auto x : adj[node])
if (x != node) dfs(x, node);
} else {
for (auto x : adj[node]) {
if (x != node && x != parent) cot[parent][x]++;
}
}
}
void solve() {
cin >> n >> m;
for (long long int i = 0; i < n; i++)
for (long long int j = 0; j < n; j++) cot[i][j] = 0;
adj.resize(n);
for (long long int i = 0; i < m; i++) {
long long int u, v;
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
}
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
dfs(i, -1);
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < n; j++) {
long long int cc = cot[i][j];
ans += (cc * (cc - 1)) / 2;
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int test = 1;
while (test--) {
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
const long long N = 2e6 + 10;
vector<long long> p;
long long mark[N];
long long small[N];
void crivo() {
for (long long i = 1; i < N; i++) small[i] = i;
for (long long i = 2; i < N; i++) {
if (!mark[i]) {
p.push_back(i);
for (long long j = 2 * i; j < N; j += i) {
mark[j] = 1;
if (small[j] == j) small[j] = i;
}
}
}
}
long long Q[23];
vector<long long> inter[23];
void precalc() {
long long id = 0;
for (long long i = 1; i <= 22; i++) {
long long prod = p[id];
inter[i].push_back(p[id]);
id++;
while (prod < 1e18 / p[id]) {
prod *= p[id];
inter[i].push_back(p[id]);
id++;
}
Q[i] = prod;
}
}
long long ask(long long x) {
cout << "? " << x << "\n";
cout.flush();
long long g;
cin >> g;
return g;
}
long long cnt(long long pp) {
long long P = pp;
while (P < 1e18 / pp) {
P *= pp;
}
long long g = ask(P);
long long k = 0;
while (g % pp == 0) {
k++;
g /= pp;
}
return k;
}
void solve() {
long long ans = 1;
long long foi = 0;
long long i = 1;
while (foi < 22) {
long long g = ask(Q[i]);
foi++;
i++;
vector<long long> primes;
for (long long P : inter[i - 1]) {
if (g % P == 0) primes.push_back(P);
}
long long id = 0;
while (foi < 22 and id < primes.size()) {
foi++;
long long x = cnt(primes[id]);
ans = 1LL * ans * (x + 1);
id++;
}
while (id < primes.size()) {
ans *= 2LL;
id++;
}
}
ans = max(ans * 2LL, ans + 7);
cout << "! " << ans << "\n";
cout.flush();
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
crivo();
precalc();
long long t;
cin >> t;
while (t--) {
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 5050;
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x;
}
int n, money, num_edge;
int num[SIZE], low[SIZE], son[SIZE], head[SIZE], siz[SIZE];
int dp[SIZE][SIZE][2];
struct node {
int to, nxt;
};
node edge[SIZE];
inline void add(int u, int v) {
edge[++num_edge].to = v;
edge[num_edge].nxt = head[u];
head[u] = num_edge;
}
void dfs(int u) {
siz[u] = 1;
dp[u][0][0] = 0;
dp[u][1][0] = num[u];
dp[u][1][1] = num[u] - low[u];
for (int i = head[u]; i; i = edge[i].nxt) {
int v = edge[i].to;
dfs(v);
for (int j = siz[u]; j >= 0; --j) {
for (int k = 0; k <= siz[v]; ++k) {
dp[u][j + k][0] = min(dp[u][j + k][0], dp[u][j][0] + dp[v][k][0]);
dp[u][j + k][1] = min(dp[u][j + k][1], dp[u][j][1] + dp[v][k][1]);
dp[u][j + k][1] = min(dp[u][j + k][1], dp[u][j][1] + dp[v][k][0]);
}
}
siz[u] += siz[v];
}
}
int main() {
n = read();
money = read();
num[1] = read();
low[1] = read();
for (int i = 2; i <= n; ++i) {
num[i] = read();
low[i] = read();
son[i] = read();
add(son[i], i);
}
memset(dp, 0x3f, sizeof(dp));
dp[1][1][1] = num[1] - low[1];
dfs(1);
for (int i = n; i >= 1; --i) {
if (dp[1][i][1] <= money || dp[1][i][0] <= money) {
printf("%d\n", i);
return 0;
}
}
printf("0\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
string s;
cin >> s;
int sol = 0;
for (char x : s) {
bool gornji = '@' < x && '[' > x;
bool donji = '`' < x && '{' > x;
int p1 = (int)gornji * (int)(x - 'A' + 1);
int p2 = (int)donji * (int)(x - 'a' + 1);
sol += p1 - p2;
}
cout << sol;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int x, n, m;
cin >> x >> n >> m;
if (m * 10 >= x) {
cout << "YES"
<< "\n";
} else {
int flag = 0;
while (n > 0) {
x = x / 2;
x += 10;
if (m * 10 >= x) {
flag = 1;
break;
}
n--;
}
if (flag == 1)
cout << "YES"
<< "\n";
else {
cout << "NO"
<< "\n";
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int nmax = 5012;
int n, c[nmax], dp[nmax][nmax];
int DP(int l, int r) {
if (dp[l][r]) return dp[l][r];
int l2 = l, r2 = r;
while (l2 < r2 && c[l2] == c[l2 + 1]) ++l2;
while (l2 < r2 && c[r2] == c[r2 - 1]) --r2;
if (l2 == r2)
return dp[l][r] = 0;
else {
if (c[l2] == c[r2])
dp[l2][r2] = DP(l2 + 1, r2 - 1) + 1;
else
dp[l2][r2] = min(DP(l2 + 1, r2), DP(l2, r2 - 1)) + 1;
return dp[l][r] = dp[l2][r2];
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &c[i]);
}
DP(1, n);
printf("%d", dp[1][n]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005;
struct node {
int num;
int a, b;
int op;
int x;
} q[maxn];
bool cmp(node x, node y) { return x.a < y.a; }
int sum[maxn];
char s[maxn];
int main() {
int i, j, k;
int n, m;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d %d", &q[i].a, &q[i].b);
q[i].num = i;
}
sum[0] = 0;
sort(q, q + n, cmp);
for (i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + q[i - 1].a;
}
int g = -1;
int res = 0;
int t;
for (i = 0; i <= n; i++) {
t = sum[i] - ((n - i) * 1000 - (sum[n] - sum[i]));
if (t >= -500 && t <= 500) {
g = i;
break;
}
if (t > 500) break;
}
if (g == -1) {
printf("-1\n");
} else {
for (i = 0; i < g; i++) s[q[i].num] = 'A';
for (; i < n; i++) s[q[i].num] = 'G';
s[n] = '\0';
printf("%s\n", s);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long n, t;
cin >> n;
t = n / 10 * 10;
if (n - t <= t + 10 - n)
cout << t << endl;
else
cout << t + 10 << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 112345;
const int mod = 1e9 + 7;
int read() {
int x;
scanf("%d", &x);
return x;
}
vector<int> v[N];
vector<int> t[N];
vector<int> ans[N];
bool used[N];
bool use[N];
int main() {
int n, m, i, j, x, y;
cin >> n;
m = (n - 1) * n / 2;
for (i = 1; i <= m; i++) {
x = read();
while (x--) {
y = read();
t[y].push_back(i);
v[i].push_back(y);
}
}
if (m == 1) {
cout << 1 << " ";
cout << v[1][0] << endl;
cout << v[1].size() - 1 << " ";
for (i = 1; i < v[1].size(); i++) cout << v[1][i] << " ";
return 0;
}
int id = 0;
for (i = 1; i <= 200; i++) {
if (!used[i] && t[i].size() != 0) {
int id1 = t[i][0];
int id2 = t[i][1];
for (j = 1; j <= 200; j++) use[j] = 0;
for (j = 0; j < v[id1].size(); j++) {
use[v[id1][j]] = 1;
}
id++;
for (j = 0; j < v[id2].size(); j++) {
int to = v[id2][j];
if (use[to]) {
ans[id].push_back(to);
}
}
for (j = 0; j < ans[id].size(); j++) {
used[ans[id][j]] = 1;
}
}
}
for (i = 1; i <= n; i++) {
cout << ans[i].size() << " ";
for (j = 0; j < ans[i].size(); j++) {
cout << ans[i][j] << " ";
}
cout << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T read() {
register T sum = 0;
register char cc = getchar();
int sym = 1;
while (cc != '-' && (cc > '9' || cc < '0')) cc = getchar();
if (cc == '-') sym = -1, cc = getchar();
sum = sum * 10 + cc - '0';
cc = getchar();
while (cc >= '0' && cc <= '9') sum = sum * 10 + cc - '0', cc = getchar();
return sym * sum;
}
template <typename T>
inline T read(T& a) {
a = read<T>();
return a;
}
template <typename T, typename... Others>
inline void read(T& a, Others&... b) {
a = read(a);
read(b...);
}
int n, t, lim;
vector<int> G[100010];
vector<pair<int, int>> ans;
void dfs(int v, int back = 0, int fa = 0) {
ans.push_back({v, t});
int cnt = (int)G[v].size() - (fa != 0);
for (int to : G[v]) {
if (to == fa) continue;
if (t == lim) {
t = back - 1 - cnt;
ans.push_back({v, t});
}
t += 1;
dfs(to, t, v);
ans.push_back({v, t});
cnt -= 1;
}
if (fa && t >= back) {
t = back - 1;
ans.push_back({v, t});
}
t += 1;
}
int main() {
read(n);
for (int i = 1; i < n; i++) {
int x, y;
read(x, y);
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = 1; i <= n; i++) lim = max(lim, (int)G[i].size());
dfs(1);
printf("%d\n", ans.size());
for (auto i : ans) printf("%d %d\n", i.first, i.second);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
class FT {
private:
int size;
int ft[200013];
int lim;
int cur[200013];
int sumto(int x) { return x > 0 ? ft[x] + sumto(x - (x & -x)) : 0; }
public:
FT(int s = 0, int l = 0) {
size = s;
fill(ft, ft + size + 1, 0);
lim = l;
fill(cur, cur + size + 1, 0);
}
void update(int x, int v) {
v = min(v, lim - cur[x]);
cur[x] += v;
while (x <= size) ft[x] += v, x += x & -x;
}
int query(int a, int b) { return sumto(b) - sumto(a - 1); }
};
int n, k, a, b, q;
FT high, low;
int main() {
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
low = FT(n, b);
high = FT(n, a);
for (int Q = 0; Q < q; Q++) {
int type;
scanf("%d", &type);
if (type == 1) {
int d, a;
scanf("%d%d", &d, &a);
high.update(d, a);
low.update(d, a);
} else {
int p;
scanf("%d", &p);
int res = 0;
res += low.query(1, p - 1);
res += high.query(p + k, n);
printf("%d\n", res);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int N = 2000007, P = 1000000007;
int a[N], low[N], mx[N], num[N], vis[N];
int mul(int a, int b) { return 1ll * a * b % P; }
int pow(int a, int k) {
int r = 1;
for (; k; k >>= 1, a = mul(a, a))
if (k & 1) r = mul(a, r);
return r;
}
int read() {
int x = 0, c = getchar();
while (isspace(c)) c = getchar();
while (isdigit(c)) (x *= 10) += c & 15, c = getchar();
return x;
}
void update(int p, int x) {
if (x > mx[p])
mx[p] = x, num[p] = 1;
else
num[p] += mx[p] == x;
}
int check(int x) {
for (int p, c; x ^ 1;) {
for (p = low[x], c = 0; !(x % p); x /= p, ++c)
;
if (c == mx[p] && num[p] == 1) return 0;
}
return 1;
}
int main() {
int n = read(), s = 1, t = 0;
for (int i = 1; i <= n; ++i) a[i] = read();
std::sort(a + 1, a + n + 1);
for (int i = 2; i <= a[n]; ++i)
if (!low[i])
for (int j = i; j <= a[n]; j += i)
if (!low[j]) low[j] = i;
for (int i = n, v, x, p, c; i; --i)
if (mx[v = a[i]])
for (vis[i] = 1, x = v - 1; x ^ 1;
s = mul(s, pow(p, std::max(0, c - mx[p]))), update(p, c))
for (p = low[x], c = 0; !(x % p); x /= p, ++c)
;
else
update(v, 1), s = mul(s, v);
for (int i = 1; i <= n; ++i)
if ((vis[i] && check(a[i] - 1)) || (!vis[i] && check(a[i]))) t = 1;
printf("%d", (s + t) % P);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n;
char s[2000005], t[2000005];
int sa[2000005], rnk[2000005], lcp[2000005], cnt[2000005];
void build(char *s) {
int n = strlen(s) + 1, m = 256;
int *x = rnk, *y = lcp, *z;
for (int i = 0; i < m; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[x[i] = s[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cnt[x[i]]] = i;
for (int j = 1, p = 1; p < n; j <<= 1, m = p) {
p = 0;
for (int i = n - j; i < n; i++) y[p++] = i;
for (int i = 0; i < n; i++)
if (sa[i] >= j) y[p++] = sa[i] - j;
for (int i = 0; i < m; i++) cnt[i] = 0;
for (int i = 0; i < n; i++) cnt[x[i]]++;
for (int i = 1; i < m; i++) cnt[i] += cnt[i - 1];
for (int i = n - 1; i >= 0; i--) sa[--cnt[x[y[i]]]] = y[i];
z = x, x = y, y = z;
x[sa[0]] = 0, p = 1;
for (int i = 1; i < n; i++) {
x[sa[i]] = (y[sa[i]] == y[sa[i - 1]] && y[sa[i] + j] == y[sa[i - 1] + j])
? p - 1
: p++;
}
}
for (int i = 0; i < n; i++) rnk[sa[i]] = i;
for (int i = 0, k = 0; i < n - 1; lcp[rnk[i++]] = k) {
if (k) k--;
for (int j = sa[rnk[i] - 1]; s[i + k] == s[j + k]; k++)
;
}
}
int sum[2000005], emn[2000005], smn[2000005];
int ans, rot, ff, ss, g1, g2;
void update(int len, int r, int f, int s) {
if (ans > len) {
ans = len;
rot = r;
ff = f, ss = s;
}
return;
}
const int inf = 1e9;
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
strcpy(t, s + 1);
strcpy(t + n, s + 1);
build(t);
for (int i = 1; i <= n; i++) {
int d = s[i] == '(' ? 1 : -1;
if (s[i] == '(')
g1++;
else
g2++;
sum[i] = sum[i - 1] + d;
}
for (int i = 1; i <= n; i++) {
smn[i] = sum[i];
if (i > 1) smn[i] = min(smn[i], smn[i - 1]);
}
for (int i = n; i >= 1; i--) {
emn[i] = sum[i];
if (i < n) emn[i] = min(emn[i], emn[i + 1]);
}
ans = inf;
for (int ii = 0; ii <= 2 * n; ii++) {
int i = sa[ii];
if (i > n) continue;
i++;
int d = sum[n] - sum[i - 1];
int mn = min(d + smn[i - 1], emn[i] - sum[i - 1]);
int inc = 0;
if (mn < 0) inc = -mn;
assert(inc + g1 >= g2);
update((inc + g1) * 2, i, inc, inc + g1 - g2);
}
for (int i = 0; i < ff; i++) putchar('(');
for (int i = rot; i <= n; i++) putchar(s[i]);
for (int i = 1; i < rot; i++) putchar(s[i]);
for (int i = 0; i < ss; i++) putchar(')');
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[600 * 600];
map<int, int> s;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int n, b[250010];
cin >> n;
for (int i = 1; i <= n * n; i++) {
cin >> a[i];
s[a[i]]++;
}
sort(a + 1, a + n * n + 1);
int len = 0;
for (int i = n * n; i > 0; i--) {
if (!s[a[i]]) continue;
s[a[i]]--;
for (int j = 0; j < len; j++) {
int l = gcd(b[j], a[i]);
s[l] -= 2;
}
b[len++] = a[i];
}
for (int i = 0; i < n; i++) printf("%d ", b[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 10, maxg = 1010, mod = 1e9 + 7, inf = 1e9 + 10;
int a[maxn];
int dp[maxn][maxg];
bool mark[maxn][maxg];
deque<pair<int, int> > D;
void better(int pos, int rm, int x, bool is) {
if (mark[pos][rm]) return;
mark[pos][rm] = 1;
dp[pos][rm] = x;
if (is)
D.push_front({pos, rm});
else
D.push_back({pos, rm});
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie();
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a[i];
}
int g, r;
cin >> g >> r;
sort(a, a + m);
m = unique(a, a + m) - a;
for (int i = 0; i < m; i++) {
for (int j = 0; j <= g; j++) {
dp[i][j] = inf;
}
}
dp[0][g] = 0;
D.push_back({0, g});
mark[0][g] = 1;
while (int((D).size())) {
int pos = D.back().first, rm = D.back().second;
D.pop_back();
if (rm == 0) better(pos, g, dp[pos][rm] + 1, 1);
if (pos != 0 && a[pos] - a[pos - 1] <= rm)
better(pos - 1, rm - (a[pos] - a[pos - 1]), dp[pos][rm], 0);
if (pos != m - 1 && a[pos + 1] - a[pos] <= rm)
better(pos + 1, rm - (a[pos + 1] - a[pos]), dp[pos][rm], 0);
}
int ans = inf;
for (int i = 0; i <= g; i++) {
if (dp[m - 1][i] != inf) ans = min(ans, dp[m - 1][i] * (r + g) + (g - i));
}
if (ans == inf)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int ha(char ch) {
if (ch == '>') {
return 4;
} else if (ch == 'v') {
return 1;
} else if (ch == '<') {
return 2;
} else if (ch == '^') {
return 3;
} else
return 0;
}
int main() {
char ch1, ch2;
int a1, a2, n;
cin >> ch1 >> ch2 >> n;
n %= 4;
a1 = ha(ch1);
a2 = ha(ch2);
int temp = (a2 - a1 + 4) % 4;
if (temp == 2 || temp == 0) {
cout << "undefined";
} else if (temp == n) {
cout << "cw";
} else if (temp = 4 - n) {
cout << "ccw";
} else
cout << "undefined";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long modex(long long a, long long b, long long m) {
if (b == 0) return 1;
long long ans = a;
long long save = 1;
while (b != 1) {
if (b % 2 == 1) {
save *= ans;
save %= m;
}
ans *= ans;
ans %= m;
b /= 2;
}
return (ans * save) % m;
}
long long mx, my;
void solve(long long a, long long b) {
if (b == 0) {
mx = 1;
my = 0;
return;
}
solve(b, a % b);
long long x1 = mx;
long long y1 = my;
mx = y1;
my = x1 - (a / b) * y1;
}
long long mi(long long x, long long m) {
solve(x, m);
return (mx + m) % m;
}
vector<long long> p;
vector<bool> prime;
void seive(int n) {
prime.resize(n + 1);
for (int i = 2; i < prime.size(); i++) prime[i] = 1;
for (int i = 2; i * i <= n; i++) {
if (!prime[i]) continue;
int j = i + i;
while (j <= n) {
prime[j] = 0;
j += i;
}
}
for (int i = 2; i <= n; i++)
if (prime[i]) p.push_back(i);
}
vector<long long> lpd;
void lpdgen(int n) {
prime.resize(n + 1);
lpd.resize(n + 1, 0);
for (int i = 2; i <= n; i++) prime[i] = 1;
for (int i = 2; i * i <= n; i++) {
if (!prime[i]) continue;
int j = i + i;
while (j <= n) {
prime[j] = 0;
if (lpd[j] == 0) lpd[j] = i;
j += i;
}
}
for (int i = 2; i <= n; i++)
if (prime[i]) lpd[i] = i;
}
template <typename T>
vector<T> compfactor(T x) {
vector<T> ret;
while (x != 1) {
ret.push_back(lpd[x]);
x /= lpd[x];
}
return ret;
}
template <typename T>
vector<T> pfactor(T x) {
vector<T> ret;
while (x != 1) {
if (ret.size() == 0 || ret[ret.size() - 1] != lpd[x]) ret.push_back(lpd[x]);
x /= lpd[x];
}
return ret;
}
vector<long long> fact;
void factgen(long long n, long long m) {
fact.resize(n + 1);
fact[0] = 1;
for (long long i = 1; i <= n; i++) {
fact[i] = i * fact[i - 1];
fact[i] %= m;
}
}
template <typename T>
vector<T> factor(T x) {
vector<T> ret;
for (long long i = 1; i * i <= x; i++) {
if (i * i == x) {
ret.push_back(i);
break;
}
if (x % i == 0) {
ret.push_back(i);
ret.push_back(x / i);
}
}
return ret;
}
template <typename T>
void init(vector<T>& x, T n) {
for (int i = 0; i < x.size(); i++) x[i] = n;
}
template <typename T>
void init2(vector<vector<T> >& x, T n) {
for (int i = 0; i < x.size(); i++)
for (int j = 0; j < x[i].size(); j++) x[i][j] = n;
}
template <typename T>
void init3(vector<vector<vector<T> > >& x, T n) {
for (int i = 0; i < x.size(); i++)
for (int j = 0; j < x[i].size(); j++)
for (int k = 0; k < x[i][j].size(); k++) x[i][j][k] = n;
}
template <typename T>
void inits2(vector<vector<T> >& x, int a, int b) {
x.resize(a);
for (int i = 0; i < x.size(); i++) x[i].resize(b);
}
template <typename T>
void inits3(vector<vector<T> >& x, int a, int b, int c) {
x.resize(a);
for (int i = 0; i < x.size(); i++) {
x[i].resize(b);
for (int j = 0; j < x[i].size(); j++) x[i][j].resize(c);
}
}
template <typename T>
T minarr(T* arr, int n) {
T x = arr[0];
for (int i = 0; i < n; i++) x = min(x, arr[i]);
return x;
}
template <typename T>
T maxarr(T* arr, int n) {
T x = arr[0];
for (int i = 0; i < n; i++) x = max(x, arr[i]);
return x;
}
template <typename T>
T minarr(vector<T>& arr) {
T x = arr[0];
for (int i = 0; i < arr.size(); i++) x = min(x, arr[i]);
return x;
}
template <typename T>
T maxarr(vector<T>& arr) {
T x = arr[0];
for (int i = 0; i < arr.size(); i++) x = max(x, arr[i]);
return x;
}
template <typename T>
void prt(vector<T>& x, int n) {
for (int i = 0; i < n; i++) cout << x[i] << " ";
}
template <typename T>
void prt(T* x, int n) {
for (int i = 0; i < n; i++) cout << x[i] << " ";
}
template <typename T>
void prtl(vector<T>& x, int n) {
for (int i = 0; i < n; i++) cout << x[i] << endl;
}
template <typename T>
void prtl(T* x, int n) {
for (int i = 0; i < n; i++) cout << x[i] << endl;
}
template <typename T>
void scan(T* arr, int n) {
for (int i = 0; i < n; i++) cin >> arr[i];
}
template <typename T>
void scan(vector<T>& ret, int n) {
for (int i = 0; i < n; i++) cin >> ret[i];
}
vector<int> failure(string& s) {
vector<int> f(s.size(), 0);
int ex = 0;
for (int i = 1; i < s.size(); i++) {
while (ex != 0 && s[ex] != s[i]) ex = f[ex - 1];
if (ex == 0) {
if (s[ex] != s[i]) {
f[i] = 0;
ex = 0;
continue;
}
}
f[i] = ex + 1;
ex++;
}
return f;
}
long long ans = 0;
vector<vector<int> > q;
int n;
void dfs(int* s, int i, int tot) {
ans += (s[i] - tot);
for (int j = 0; j < q[i].size(); j++) dfs(s, q[i][j], s[i]);
}
int main() {
cin >> n;
int p[n + 1];
q.resize(n + 1);
for (int i = 2; i <= n; i++) cin >> p[i];
for (int i = 2; i <= n; i++) q[p[i]].push_back(i);
int s[n + 1];
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i <= n; i++) {
if (s[i] != -1) continue;
int xx = INT_MAX;
for (int j = 0; j < q[i].size(); j++) {
xx = min(s[q[i][j]], xx);
}
if (xx == INT_MAX)
s[i] = s[p[i]];
else
s[i] = xx;
if (s[i] < s[p[i]]) {
cout << -1 << endl;
return 0;
}
}
dfs(s, 1, 0);
cout << ans << endl;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define loi long long
#define lod long double
#define doubel double
#define pb push_back
#define run ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define mod 1000000007
#define lim 5000000000000000000
#define in(ar, n) for(loi i = 0; i < n; i++) cin >> ar[i];
#define out(ar, n) for (loi i = 0; i < n; i++) cout << ar[i] << " "; cout << "\n";
#define rep(i, n) for(loi i = 0; i < n; i++)
#define rep1(i, n) for(loi i = 1; i <= n; i++)
#define rev(i, n) for(loi i = n - 1; ~i; i--)
#define rep3(i, l, r) for(loi i = l; i <= r; i++)
#define rev3(i, r, l) for(loi i = r; i >= l; i--)
#define rep4(i, r, l) for(loi i = r; i >= l; i--)
#define all(x) x.begin(), x.end ()
#define mkp make_pair
#define vii vector<loi>
#define mii map<loi, loi>
#define sii set<loi>
#define pii pair<loi, loi>
#define mxdepth 23 // FOR LCA till N = 1e6
#define mxn 2000001
#define MAXN 20000005
int main()
{
loi t;
cin >> t;
while(t--)
{
loi n;
cin >> n;
loi ar[n];
in(ar, n);
loi br[n];
in(br, n);
vector<pii> res;
vii less, gre;
rep(i, n)
{
if(ar[i] < br[i])
less.pb(i);
else if(ar[i] > br[i])
gre.pb(i);
}
if(less.size() and !gre.size())
cout << "-1\n";
else if(gre.size() and !less.size())
cout << "-1\n";
else if(less.size() and gre.size())
{
loi cnt = 0;
rep(i, n)
{
cnt += abs(ar[i] - br[i]);
}
if(cnt & 1)
{
cout << "-1\n";
continue;
}
loi x = 0, y = 0;
while(x < less.size() and y < gre.size())
{
loi lindx = less[x], gindx = gre[y];
while(ar[lindx] < br[lindx] and ar[gindx] > br[gindx])
{
res.pb({gindx + 1, lindx + 1});
ar[lindx]++, ar[gindx]--;
}
if(ar[lindx] == br[lindx]) x++;
if(ar[gindx] == br[gindx]) y++;
}
if((x != less.size() and y == gre.size()) or (x == less.size() and y != gre.size()))
{
cout << "-1\n";
continue;
}
cout << res.size() << "\n";
for(pii p: res)
cout << p.first << " " << p.second << "\n";
}
else cout << "0\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int mod = (int)1e9 + 7;
int n, m, k;
int d[1111111], dd[1111111];
vector<int> e[1111111];
void In() {
scanf("%d%d%d", &n, &m, &k);
;
for (int i = (1); i <= (n); i++) d[i] = -n;
for (int i = 0; i < (m); i++) {
int x;
scanf("%d", &x);
;
d[x] = 0;
dd[x] = 1;
}
for (int i = 0; i < (n - 1); i++) {
int x, y;
scanf("%d%d", &x, &y);
;
e[x].push_back(y);
e[y].push_back(x);
}
}
void dfs(int u, int F) {
for (__typeof((e[u]).begin()) y = (e[u]).begin(); y != (e[u]).end(); y++)
if (*y != F) {
dfs(*y, u);
d[u] = max(d[u], d[*y] + 1);
}
}
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
return a.first > b.first;
}
vector<pair<int, int> > a[1111111];
void get(int u, int F) {
if (dd[u]) a[u].push_back(make_pair(0, u));
if (F)
for (__typeof((a[F]).begin()) it = (a[F]).begin(); it != (a[F]).end(); it++)
if (it->second != u) {
a[u].push_back(make_pair(it->first + 1, F));
}
for (__typeof((e[u]).begin()) y = (e[u]).begin(); y != (e[u]).end(); y++)
if (*y != F) {
if (d[*y] >= 0) a[u].push_back(make_pair(d[*y] + 1, *y));
}
sort((a[u]).begin(), (a[u]).end(), cmp);
while (a[u].size() > 2) a[u].pop_back();
for (__typeof((e[u]).begin()) y = (e[u]).begin(); y != (e[u]).end(); y++)
if (*y != F) {
get(*y, u);
}
}
int main() {
In();
dfs(1, 0);
get(1, 0);
int ans = 0;
for (int i = (1); i <= (n); i++)
if (a[i].empty() || a[i][0].first <= k) ans++;
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> edges[200005];
int visited[200005], s[200005];
int cycle = 0, nxt = 0, flag = 1;
void dfs(int x) {
visited[x] = 1;
if (s[x] != 2) flag = 0;
for (int i = 0; i < edges[x].size(); i++) {
if (visited[edges[x][i]] == 0) dfs(edges[x][i]);
}
}
int main() {
int n, m, a, b;
scanf("%d%d", &n, &m);
memset(s, 0, sizeof s);
for (int i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
s[a]++;
s[b]++;
edges[a].push_back(b);
edges[b].push_back(a);
}
memset(visited, 0, sizeof visited);
int total = 0;
for (int i = 1; i <= n; i++) {
if (visited[i] == 0) {
nxt = i;
cycle = 0;
flag = 1;
dfs(i);
total += flag;
}
}
cout << total;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N, M, ans = 0;
cin >> N >> M;
for (int i = 1; i <= min(N, M); i++) {
for (int j = 1; j <= min(N, M); j++) {
if ((i * i + j * j) % M == 0) {
long long vi = (N - i) / M - (M - i) / M + 1;
long long vj = (N - j) / M - (M - j) / M + 1;
ans += vi * vj;
}
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int const INF = (1 << 30);
int const MAXN = (int)1e5 + 100;
double a, b, m, vx, vy, vz;
double x, y, z;
int main() {
cin >> a >> b >> m;
cin >> vx >> vy >> vz;
double t = (-1 * m) / vy;
x = a / 2;
x += vx * t;
z += vz * t;
while (x < 0 || x > a) {
if (x < 0) x = (-1) * x;
if (x > a) x = a - (x - a);
}
while (z < 0 || z > b) {
if (z < 0) z = (-1) * z;
if (z > b) z = b - (z - b);
}
printf("%.10f %.10f", x, z);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define co(n) cout<<n<<endl;
const int x=720720;
int n,m,k;
int main(int argc, char const *argv[]) {
scanf("%d %d", &n, &m);
for (int i=1;i<=n;++i) {
for (int j=1;j<=m;++j) {
scanf("%d", &k);
if ((i+j)&1) printf("%d ", x);
else printf("%d ", x - k*k*k*k);
}
printf("\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, m2, aux, a;
vector<long long> res;
cin >> n;
aux = n;
m2 = 1;
while (2 * m2 < n) m2 = 2 * m2;
aux = m2;
for (i = 0; i < n; i++) {
res.push_back(1000000007);
}
while (aux > 0) {
j = 0;
vector<long long> v1, v2;
while (j < n) {
for (i = 0; j + i < n && i < aux; i++) {
v1.push_back(i + j + 1);
}
j += 2 * aux;
}
cout << v1.size() << endl;
for (i = 0; i < v1.size(); i++) {
cout << v1[i] << " ";
}
cout << endl;
fflush(stdout);
j = 0;
for (i = 0; i < n; i++) {
cin >> a;
if (j < v1.size()) {
while (j < v1.size() && i + 1 > v1[j]) j++;
if (i + 1 == v1[j]) continue;
}
if (a < res[i]) res[i] = a;
}
j = aux;
while (j < n) {
for (i = 0; j + i < n && i < aux; i++) {
v2.push_back(i + j + 1);
}
j += 2 * aux;
}
cout << v2.size() << endl;
for (i = 0; i < v2.size(); i++) {
cout << v2[i] << " ";
}
cout << endl;
fflush(stdout);
j = 0;
for (i = 0; i < n; i++) {
cin >> a;
if (j < v2.size()) {
while (j < v2.size() && i + 1 > v2[j]) j++;
if (i + 1 == v2[j]) continue;
}
if (a < res[i]) res[i] = a;
}
aux /= 2;
}
cout << -1 << endl;
for (i = 0; i < n; i++) {
cout << res[i] << " ";
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using pii = std::pair<int, int>;
using pll = std::pair<long long, long long>;
const int maxk = 203;
std::vector<int> prefix[maxk];
std::vector<int> at[maxk];
void solve() {
int n;
std::cin >> n;
for (int i = 0; i < maxk; i++) {
prefix[i].resize(n + 1);
prefix[i][0] = 0;
at[i].clear();
}
for (int i = 1; i <= n; i++) {
int x;
std::cin >> x;
for (int j = 0; j < maxk; j++) {
prefix[j][i] = prefix[j][i - 1];
}
prefix[x][i]++;
at[x].push_back(i);
}
int ans = 0;
for (int a = 1; a < maxk; a++) {
ans = std::max(ans, (int)at[a].size());
int l = 0;
int r = at[a].size() - 1;
while (l < r) {
int lt = at[a][l];
int rt = at[a][r];
++l, --r;
int need = l;
ans = std::max(ans, 2 * need);
for (int b = 1; b < maxk; b++) {
int has = prefix[b][rt - 1] - prefix[b][lt];
ans = std::max(ans, 2 * need + has);
}
}
}
std::cout << ans << "\n";
}
int main() {
std::ios::sync_with_stdio(false);
int t;
std::cin >> t;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
int q;
cin >> q;
while (q--) {
string s;
cin >> s;
sort(begin(s), end(s));
int l = 0, r = 0, u = 0, d = 0;
for (auto& c : s) {
if (c == 'L') ++l;
if (c == 'R') ++r;
if (c == 'U') ++u;
if (c == 'D') ++d;
}
int dx = r - l;
int dy = u - d;
if (dx < 0) l -= -dx;
if (dx > 0) r -= dx;
if (dy < 0) d -= -dy;
if (dy > 0) u -= dy;
if (u == 0 or d == 0) {
if (l == 0 or r == 0) {
cout << 0 << endl;
} else {
cout << 2 << endl;
cout << "LR" << endl;
}
} else if (l == 0 or r == 0) {
if (u == 0 or d == 0) {
cout << 0 << endl;
} else {
cout << 2 << endl;
cout << "UD" << endl;
}
} else {
string out;
for (int i = (0); i < (l); ++i) out.push_back('L');
for (int i = (0); i < (u); ++i) out.push_back('U');
for (int i = (0); i < (r); ++i) out.push_back('R');
for (int i = (0); i < (d); ++i) out.push_back('D');
cout << (int)(out).size() << endl;
cout << out << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool sortbyval(const pair<string, int> &a, const pair<string, int> &b) {
return (a.second > b.second);
}
void solve() {
string s;
cin >> s;
string ans = "";
int flag = 0;
if (s[0] == '-') {
ans += "($";
s.erase(s.begin());
flag = 1;
} else {
ans += "$";
}
int n = s.length();
string s2 = "";
auto it = s.find('.');
string s3 = "";
if (it != string::npos) {
s2 += s.substr(0, it);
int rem = n - it - 1;
if (rem >= 2)
s3 += s.substr(it + 1, 2);
else {
string t(2 - rem, '0');
s3 += s.substr(it + 1, rem) + t;
}
} else {
s2 += s;
string t(2, '0');
s3 += t;
}
int ct = 0;
for (int i = s2.length() - 3; i > 0; i = i - 3 - ct) {
s2.insert(i, ",");
}
ans = ans + s2 + '.' + s3;
if (flag == 1) ans += ')';
cout << ans << "\n";
}
signed main() {
int t = 1;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
bool black[maxn];
vector<int> tree[maxn];
bool old_black[maxn];
const int MAX_BLOCK_SIZE = 600;
int t[maxn], v[maxn];
bool in_mini[maxn];
vector<pair<pair<int, int>, int>> minitree[maxn];
int push[maxn];
bool clear[maxn];
void dfs1(int pos, int prev = -1, int white = 0, int dist = 0) {
if (in_mini[pos]) {
if (prev != -1) minitree[prev].push_back({{pos, white}, dist});
for (int a : tree[pos]) dfs1(a, pos, 0, 0);
} else {
if (!black[pos]) white++;
for (int a : tree[pos]) dfs1(a, prev, white, dist + 1);
}
}
void make1(int pos) {
if (!black[pos]) {
black[pos] = true;
return;
}
push[pos]++;
for (auto a : minitree[pos])
if (a.first.second + 1 <= push[pos]) make1(a.first.first);
}
void make2(int pos) {
black[pos] = false;
push[pos] = 0;
clear[pos] = true;
for (auto &a : minitree[pos]) {
a.first.second = a.second;
make2(a.first.first);
}
}
void dfs2(int pos, int p = 0, bool cl = false) {
if (in_mini[pos]) {
p = push[pos];
cl |= clear[pos];
} else {
black[pos] = old_black[pos];
if (cl) black[pos] = false;
if (!black[pos] && p) black[pos] = true, p--;
}
for (int a : tree[pos]) dfs2(a, p, cl);
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 2; i <= n; i++) {
int tmp;
cin >> tmp;
tree[tmp].push_back(i);
}
for (int i = 1; i <= q; i++) cin >> t[i] >> v[i];
int root = 1;
for (int i = 1; i <= q; i += MAX_BLOCK_SIZE) {
for (int j = 1; j <= n; j++) {
in_mini[j] = false;
minitree[j].clear();
old_black[j] = black[j];
push[j] = 0;
clear[j] = false;
}
for (int j = 0; j < MAX_BLOCK_SIZE && i + j <= q; j++)
in_mini[v[i + j]] = true;
dfs1(root);
for (int j = 0; j < MAX_BLOCK_SIZE && i + j <= q; j++) {
int t = ::t[i + j];
int v = ::v[i + j];
if (t == 1)
make1(v);
else if (t == 2)
make2(v);
else
cout << (black[v] ? "black" : "white") << endl;
}
dfs2(root);
}
}
| 12 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,fast-math,unroll-loops")
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<ll, ll>;
template <class T>
istream &operator>>(istream &in, vector<T> &a) {
for (auto &i : a) in >> i;
return in;
}
template <class T>
ostream &operator<<(ostream &out, vector<T> a) {
for (auto &i : a) out << i << ' ';
return out;
}
template <class T, class U>
istream &operator>>(istream &in, pair<T, U> &p) {
in >> p.first >> p.second;
return in;
}
template <class T, class U>
ostream &operator<<(ostream &out, pair<T, U> p) {
out << p.first << " " << p.second << " ";
return out;
}
inline void Start() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
const ll P = 998244353;
ll add(ll a, ll b) { return (a + b) % P; }
ll mul(ll a, ll b) { return (a * b) % P; }
ll bpow(ll a, ll n) {
ll res = 1;
while (n) {
if (n & 1) res = mul(res, a);
a = mul(a, a);
n >>= 1;
}
return res;
}
ll rev(ll x) { return bpow(x, P - 2); }
ll divi(ll a, ll b) { return mul(a, rev(b)); }
pii comb(pii a, pii b) {
return make_pair(add(mul(a.first, b.second), a.first),
mul(a.second, b.second));
}
struct node {
ll vl, vr;
pii val;
node *l = 0, *r = 0;
node() {}
node(ll tl, ll tr, vector<ll> &p) {
vl = tl, vr = tr;
if (vr - vl == 1) {
val = {p[vl], p[vl]};
return;
}
l = new node(vl, (vl + vr) >> 1, p), r = new node((vl + vr) >> 1, vr, p);
val = comb(l->val, r->val);
}
pii get(ll ql, ll qr) {
if (ql >= qr) return make_pair(0ll, 1ll);
if (vl == ql && vr == qr) return val;
ll vm = (vl + vr) >> 1;
if (qr <= vm) return l->get(ql, qr);
if (ql >= vm) return r->get(ql, qr);
return comb(l->get(ql, vm), r->get(vm, qr));
}
};
struct snode {
ll vl, vr;
ll val = 0;
snode *l = 0, *r = 0;
snode() {}
snode(ll tl, ll tr) {
vl = tl, vr = tr;
if (vr - vl == 1) {
val = 0;
return;
}
l = new snode(vl, (vl + vr) >> 1), r = new snode((vl + vr) >> 1, vr);
val = 0;
}
ll get(ll ql, ll qr) {
if (ql >= qr) return 0;
if (vl == ql && vr == qr) return val;
ll vm = (vl + vr) >> 1;
if (qr <= vm) return l->get(ql, qr);
if (ql >= vm) return r->get(ql, qr);
return l->get(ql, vm) + r->get(vm, qr);
}
void change(ll pos, ll x) {
if (vr - vl == 1) {
val = x;
return;
}
ll vm = (vl + vr) >> 1;
if (pos < vm)
l->change(pos, x);
else
r->change(pos, x);
val = l->val + r->val;
}
};
signed main() {
Start();
ll n, q;
cin >> n >> q;
vector<ll> p(n);
cin >> p;
for (ll i = 0; i < n; ++i) p[i] = divi(100, p[i]);
vector<ll> sufp(n), revs(n), sumsufmp(n);
for (ll i = n - 1; i >= 0; --i) {
sufp[i] = mul((i + 1 < n ? sufp[i + 1] : 1), p[i]);
revs[i] = rev(sufp[i]);
sumsufmp[i] = add((i + 1 < n ? sumsufmp[i + 1] : 0), sufp[i]);
}
auto get = [&](ll l, ll r) -> ll {
return mul(add(sumsufmp[l], P - (r < n ? sumsufmp[r] : 0)),
(r < n ? revs[r] : 1));
};
node *t = new node(0, n, p);
snode *tsum = new snode(0, n);
tsum->change(0, get(0, n));
ll cur = get(0, n);
set<ll> st;
st.emplace(0);
st.emplace(n);
for (ll i = 0; i < q; ++i) {
ll x;
cin >> x, --x;
if (st.count(x)) {
auto it = st.lower_bound(x);
auto dit = it;
auto uit = it;
--dit, ++uit;
ll d = *dit, u = *uit;
cur -= get(d, x);
cur -= get(x, u);
cur += get(d, u);
cur += 5 * P;
cur %= P;
st.erase(x);
cout << cur << '\n';
} else {
st.emplace(x);
auto it = st.lower_bound(x);
auto dit = it;
auto uit = it;
--dit, ++uit;
ll d = *dit, u = *uit;
cur -= get(d, u);
cur += get(d, x);
cur += get(x, u);
cur += 5 * P;
cur %= P;
cout << cur << '\n';
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 121;
long long n, m;
map<string, long long> mp;
long long sl, a[N], num[N];
void Input() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
}
void Solve() {
sl = 0;
for (long long i = 1; i <= m; i++) {
string s;
cin >> s;
if (mp[s] == 0) {
sl++;
mp[s] = sl;
num[sl]++;
} else
num[mp[s]]++;
}
sort(num + 1, num + sl + 1, greater<long long>());
long long maxx = 0, minx = 0;
for (long long i = 1; i <= sl; i++) {
minx += num[i] * a[i];
maxx += num[i] * a[n - i + 1];
}
cout << minx << ' ' << maxx;
}
int main() {
if (fopen("trash.inp", "r")) freopen("trash.inp", "r", stdin);
Input();
Solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1111;
int num[maxn];
int tot;
int head[maxn];
int vis[maxn];
int sum;
int dp[maxn][maxn];
int tt;
int pos;
int tot2;
int head2[maxn];
void init() {
tot = 0;
memset(head, -1, sizeof(head));
tot2 = 0;
memset(head2, -1, sizeof(head2));
memset(vis, 0, sizeof(vis));
tt = 0;
}
struct {
int v, next;
} edge[maxn * maxn], edge2[maxn * maxn];
void add(int u, int v) {
edge[tot].v = v;
edge[tot].next = head[u];
head[u] = tot++;
}
void dfs(int u) {
vis[u] = 1;
sum++;
int i, v;
for (i = head[u]; i != -1; i = edge[i].next) {
v = edge[i].v;
if (!vis[v]) dfs(v);
}
}
void add2(int u, int v) {
edge2[tot2].v = v;
edge2[tot2].next = head2[u];
head2[u] = tot2++;
}
void dfs2(int u) {
sum++;
int i, v;
for (i = head2[u]; i != -1; i = edge2[i].next) {
v = edge2[i].v;
dfs2(v);
}
}
int main() {
int i, j, n, m;
int a;
while (scanf("%d%d", &n, &m) != EOF) {
init();
tt = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &a);
if (a) {
add(i, a);
add(a, i);
add2(i, a);
}
}
sum = 0;
dfs(m);
sum = 0;
dfs2(m);
pos = sum;
for (i = 1; i <= n; i++) {
sum = 0;
if (!vis[i]) {
dfs(i);
num[++tt] = sum;
}
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
for (i = 1; i <= n; i++) {
for (j = 0; j <= n; j++) {
dp[i][j] = dp[i - 1][j];
if (!dp[i][j] && j - num[i] >= 0) {
dp[i][j] = dp[i - 1][j - num[i]];
}
}
}
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) {
if (dp[j][i] == 1) {
printf("%d\n", i + pos);
break;
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000000000000LL;
const double EPS = 1e-9;
const long long mod = 1000000007ll;
const int maxn = 500500;
struct point {
double x, y, z;
point() {}
point(double _x, double _y, double _z) : x(_x), y(_y), z(_z) {}
void read() { scanf("%lf%lf%lf", &x, &y, &z); }
point operator-(const point& p) { return point(x - p.x, y - p.y, z - p.z); }
point operator+(const point& p) { return point(x + p.x, y + p.y, z + p.z); }
point operator*(double d) { return point(x * d, y * d, z * d); }
double abs() { return sqrt(x * x + y * y + z * z); }
};
point polyline[maxn];
double vp, vs;
int n;
point where(double ti) {
for (int i = 0; i < n; i++) {
double segTime = (polyline[i + 1] - polyline[i]).abs() / vs;
if (segTime >= ti) {
point dir = (polyline[i + 1] - polyline[i]);
return polyline[i] + dir * (ti / segTime);
}
ti -= segTime;
}
return polyline[n];
}
bool can(double ti) { return (polyline[n + 1] - where(ti)).abs() / vp <= ti; }
int main() {
scanf("%d", &n);
for (int i = 0; i < (int)(n + 1); ++i) polyline[i].read();
scanf("%lf%lf", &vp, &vs);
polyline[n + 1].read();
double ti = 0;
for (int i = 0; i < n; i++) ti += (polyline[i + 1] - polyline[i]).abs() / vs;
if ((polyline[n] - polyline[n + 1]).abs() / vp > ti + EPS) {
puts("NO");
return 0;
}
double l = 0, r = 1e10;
for (int st = 0; st < 100; st++) {
double mid = (l + r) / 2.;
if (can(mid))
r = mid;
else
l = mid;
}
point loc = where(l);
puts("YES");
printf("%lf\n%lf %lf %lf", (loc - polyline[n + 1]).abs() / vp, loc.x, loc.y,
loc.z);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int wart[maxn];
int n;
int kmr[21][2 * maxn];
int sufiks[maxn];
int RANK[maxn];
int ileWspolne[maxn];
int lewo[maxn];
int prawo[maxn], sumZly[maxn];
bool zly[maxn];
string s, bin;
void buildKMR() {
for (int i = 1; i <= 20; i++) {
vector<pair<pair<int, int>, int> > sorted;
int dl = (1 << (i - 1));
if (dl > n) return;
for (int j = 1; j <= n; j++)
sorted.push_back({{kmr[i - 1][j], kmr[i - 1][j + dl]}, j});
sort(sorted.begin(), sorted.end());
int nr = 1;
kmr[i][sorted[0].second] = 1;
for (int j = 1; j < (int)sorted.size(); j++) {
int id = sorted[j].second;
int act1 = sorted[j].first.first;
int act2 = sorted[j].first.second;
int prev1, prev2;
prev1 = sorted[j - 1].first.first;
prev2 = sorted[j - 1].first.second;
if (act1 != prev1 || act2 != prev2) nr++;
kmr[i][id] = nr;
}
if (2 * dl > n) {
for (int j = 0; j < (int)sorted.size(); j++) {
int id = sorted[j].second;
sufiks[j + 1] = id;
RANK[id] = j + 1;
}
}
}
}
void zbudujIleWsp() {
int maxiWsp = 0;
for (int i = 1; i <= n; i++) {
maxiWsp = max(maxiWsp - 1, 0);
int posAct = i + maxiWsp;
int posPrev = sufiks[RANK[i] - 1] + maxiWsp;
if (0)
cerr << "i , fWsp posAct, prev: " << i << ' ' << posAct << ' ' << posPrev
<< '\n';
while (max(posAct, posPrev) <= n && s[posAct] == s[posPrev]) {
maxiWsp++;
posAct++;
posPrev++;
}
ileWspolne[RANK[i]] = maxiWsp;
}
ileWspolne[1] = -1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
string tmpS, tmpBin;
cin >> tmpS >> tmpBin;
s = tmpS, bin = tmpBin;
for (int i = n - 1; i >= 0; i--) {
s[(n - 1) - i] = tmpS[i];
bin[(n - 1) - i] = tmpBin[i];
}
s = ' ' + s;
bin = ' ' + bin;
for (int i = 1; i <= n; i++) kmr[0][i] = (int)s[i] - 96;
buildKMR();
zbudujIleWsp();
for (int i = 1; i <= n; i++)
if (0) cerr << "sortedSuf " << i << " ity: " << sufiks[i] << '\n';
for (int i = 1; i <= n; i++)
if (0) cerr << "RANK[" << i << "] : " << RANK[i] << '\n';
for (int i = 1; i <= n; i++)
if (bin[i] == '1') zly[RANK[i]] = 1;
for (int i = 1; i <= n; i++) sumZly[i] = sumZly[i - 1] + zly[i];
ileWspolne[0] = -1;
lewo[1] = 1;
for (int i = 2; i <= n; i++) {
int val = ileWspolne[i];
int id = i - 1;
while (id > 1 && ileWspolne[id] >= val) {
id = lewo[id];
}
lewo[i] = id;
}
prawo[n + 1] = 0;
ileWspolne[n + 1] = 1e9;
for (int i = n; i >= 1; i--) {
int val = ileWspolne[i];
int id = i + 1;
while (id <= n && ileWspolne[id] >= val) {
id = prawo[id];
}
prawo[i] = id;
}
for (int i = 0; i <= n + 1; i++)
if (0) cerr << "lewo[" << i << "] : " << lewo[i] << '\n';
for (int i = 1; i <= n + 1; i++)
if (0) cerr << "prawo[" << i << "] : " << prawo[i] << '\n';
for (int i = 1; i <= n; i++)
if (0) cerr << "ileWsp[" << i << "]: " << ileWspolne[i] << '\n';
for (int i = 1; i <= n; i++)
if (0) cerr << "zly[" << i << "]: " << zly[i] << '\n';
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long l = lewo[i];
long long p = prawo[i];
p = max((long long)i, p - 1LL);
if (0) cerr << "i l p : " << i << ' ' << l << ' ' << p << '\n';
if (l <= 0) exit(0);
long long fa = (p - l + 1) - (sumZly[p] - sumZly[l - 1]);
long long a = ileWspolne[i];
if (0) cerr << "a fa : " << a << ' ' << fa << '\n';
long long kand = fa * a;
if (0) cerr << "kand : " << kand << '\n';
ans = max(ans, kand);
if (zly[i] == 0) {
ans = max(ans, (long long)n - sufiks[i] + 1LL);
if (0) cerr << " n - sufiks[i] + 1 : " << n - sufiks[i] + 1 << '\n';
}
}
cout << ans << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug &operator<<(const c &) {
return *this;
}
};
long long __pow(long long x, long long y, long long M) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % M;
y >>= 1;
x = (x * x) % M;
}
return res % M;
}
long long __pow(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y >>= 1;
x = (x * x);
}
return res;
}
long long mi(long long x, long long M) { return __pow(x, M - 2, M); }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long add(long long a, long long b, long long M) { return (a + b) % M; }
long long mul(long long a, long long b, long long M) { return (a * b) % M; }
long long sub(long long a, long long b, long long M) { return (a - b + M) % M; }
long long div(long long a, long long b, long long M) {
return (a * mi(b, M)) % M;
}
void umax(long long &a, long long b) { a = max(a, b); }
void umin(long long &a, long long b) { a = min(a, b); }
const long long N = 3e5 + 2, inf = 1e18, M = 998244353;
long long Test, n, m, k, query;
bool ok = 1;
void test_case() {
cin >> n;
long long L = 0, R = 0, ans = 0;
vector<long long> a(n);
for (long long &x : a) cin >> x;
sort((a).begin(), (a).end());
vector<pair<long long, long long>> b;
for (long long i = 0; i < n; i++) {
long long cnt = 0;
for (; i < n - 1 && a[i] == a[i + 1]; i++) cnt++;
b.push_back({a[i], cnt + 1});
if (b.back().second > ans)
L = b.size() - 1, R = b.size() - 1, ans = b.back().second;
}
n = b.size();
vector<long long> pref(n), pref1(n);
pref[0] = (b[0].second == 1);
pref1[0] = b[0].second;
for (long long i = 1; i < n; i++)
pref[i] = pref[i - 1] + (b[i].second == 1),
pref1[i] = pref1[i - 1] + b[i].second;
debug() << " ["
<< "b"
": "
<< (b)
<< "] "
" ["
<< "pref"
": "
<< (pref)
<< "] "
" ["
<< "pref1"
": "
<< (pref1) << "] ";
for (long long i = 0; i < n - 1; i++) {
long long lx = i + 1, rx = n - 1, r = 0;
while (rx >= lx) {
long long md = (lx + rx) / 2;
if (b[md].first == b[i].first + md - i && pref[md - 1] == pref[i])
r = md, lx = md + 1;
else
rx = md - 1;
}
if (pref1[r] - (i ? pref1[i - 1] : 0) > ans)
L = i, R = r, ans = pref1[r] - (i ? pref1[i - 1] : 0);
}
cout << ans << endl;
for (long long i = R - 1; i > L; i--) cout << b[i].first << " ";
for (long long i = 0; i < b[L].second; i++) cout << b[L].first << " ";
for (long long i = L + 1; i <= R; i++)
for (long long j = (i != R); j < b[i].second; j++)
cout << b[i].first << " ";
cout << endl;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
Test = 1;
while (Test--) test_case();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x20202020;
const long long mod = 1000000007;
const double eps = 1e-9;
const double pi = 3.1415926535897932384626;
const int DX[] = {1, 0, -1, 0}, DY[] = {0, 1, 0, -1};
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
const int N = 110;
int n, d, a[N], x[N], y[N], f[N][N];
int main() {
scanf("%d%d", &n, &d);
for (int i = 1; i < (int)n - 1; i++) scanf("%d", a + i);
for (int i = 0; i < (int)n; i++) scanf("%d%d", x + i, y + i);
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)n; j++)
if (i == j)
f[i][j] = 0;
else
f[i][j] = d * (abs(x[i] - x[j]) + abs(y[i] - y[j])) - a[j];
for (int k = 0; k < (int)n; k++)
for (int i = 0; i < (int)n; i++)
for (int j = 0; j < (int)n; j++)
if (i != j && i != k && j != k)
f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
printf("%d\n", f[0][n - 1]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
ans = max(ans, k);
}
ans = max(ans - 25, 0);
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010, mod = 1e9 + 7;
int n, m, a[maxn], cnt, head[maxn], to[maxn], nxt[maxn];
long long dp[maxn];
int d;
inline void add(int x, int y) {
nxt[++cnt] = head[x];
head[x] = cnt;
to[cnt] = y;
}
void dfs(int u, int p, int x) {
dp[u] = 1;
for (int i = head[u]; i; i = nxt[i]) {
if (to[i] == p) continue;
if (a[to[i]] > a[x]) continue;
if (a[to[i]] < max(0, a[x] - d)) continue;
if (a[to[i]] == a[x] && to[i] < x) continue;
dfs(to[i], u, x);
dp[u] *= dp[to[i]] + 1LL;
dp[u] %= mod;
}
}
int main() {
cin >> d >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1, x, y; i < n; ++i) {
cin >> x >> y;
add(x, y);
add(y, x);
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
dfs(i, -1, i);
ans += dp[i];
ans %= mod;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int mat[1005][1005];
int main() {
int n;
scanf("%d", &n);
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (n); j++) {
scanf("%d", &mat[i][j]);
}
}
int akt = 0;
for (int i = (0); i < (n); i++) akt = (akt + mat[i][i]) % 2;
int q;
scanf("%d", &q);
for (int i = (0); i < (q); i++) {
int nr;
scanf("%d", &nr);
if (nr == 1 || nr == 2) {
akt = 1 - akt;
int x;
scanf("%d", &x);
} else
printf("%d", akt);
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tests;
cin >> tests;
for (int idk = 0; idk < tests; idk++) {
long long n;
cin >> n;
long long a[n], one = 0, md1 = 0, md2 = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) one = 1;
if (a[i] % 3 == 1) md1 = 1;
if (a[i] % 3 == 2) md2 = 1;
}
std::sort(a, a + n);
int dif1 = 0;
for (int i = 0; i < n; i++)
if (a[n - 1] - a[i] == 1) dif1 = 1;
long long ans[4];
ans[1] = 0;
ans[2] = 0;
if (md1) ans[1] = 1;
if (md2) ans[2] = 1;
if ((md1) && (md2) && (one == 0) && (a[n - 1] % 3 == 1) && (dif1 == 0)) {
ans[1] = 0;
ans[2] = 2;
}
long long dif = ans[1] + ans[2] * 2;
ans[3] = 0;
for (int i = 0; i < n; i++) {
ans[3] = max(ans[3], (a[i] + 2 - dif) / 3);
}
cout << ans[1] + ans[2] + ans[3] << endl;
}
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void *wmem;
char memarr[96000000];
template <class S, class T>
inline S min_L(S a, T b) {
return a <= b ? a : b;
}
template <class T>
inline void walloc1d(T **arr, int x, void **mem = &wmem) {
static int skip[16] = {0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
(*mem) = (void *)(((char *)(*mem)) + skip[((unsigned long long)(*mem)) & 15]);
(*arr) = (T *)(*mem);
(*mem) = ((*arr) + x);
}
template <class T1, class T2>
void sortA_L(int N, T1 a[], T2 b[], void *mem = wmem) {
int i;
pair<T1, T2> *arr;
walloc1d(&arr, N, &mem);
for (i = (0); i < (N); i++) {
arr[i].first = a[i];
arr[i].second = b[i];
}
sort(arr, arr + N);
for (i = (0); i < (N); i++) {
a[i] = arr[i].first;
b[i] = arr[i].second;
}
}
template <class T1, class T2, class T3>
void sortA_L(int N, T1 a[], T2 b[], T3 c[], void *mem = wmem) {
int i;
pair<T1, pair<T2, T3> > *arr;
walloc1d(&arr, N, &mem);
for (i = (0); i < (N); i++) {
arr[i].first = a[i];
arr[i].second.first = b[i];
arr[i].second.second = c[i];
}
sort(arr, arr + N);
for (i = (0); i < (N); i++) {
a[i] = arr[i].first;
b[i] = arr[i].second.first;
c[i] = arr[i].second.second;
}
}
inline int my_getchar() {
static char buf[1048576];
static int s = 1048576;
static int e = 1048576;
if (s == e && e == 1048576) {
e = fread(buf, 1, 1048576, stdin);
s = 0;
}
if (s == e) {
return EOF;
}
return buf[s++];
}
inline void rd(int &x) {
int k;
int m = 0;
x = 0;
for (;;) {
k = my_getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
x = k - '0';
break;
}
}
for (;;) {
k = my_getchar();
if (k < '0' || k > '9') {
break;
}
x = x * 10 + k - '0';
}
if (m) {
x = -x;
}
}
inline void rd(char &c) {
int i;
for (;;) {
i = my_getchar();
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF) {
break;
}
}
c = i;
}
inline int rd(char c[]) {
int i;
int sz = 0;
for (;;) {
i = my_getchar();
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF) {
break;
}
}
c[sz++] = i;
for (;;) {
i = my_getchar();
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) {
break;
}
c[sz++] = i;
}
c[sz] = '\0';
return sz;
}
struct MY_WRITER {
char buf[1048576];
int s;
int e;
MY_WRITER() {
s = 0;
e = 1048576;
}
~MY_WRITER() {
if (s) {
fwrite(buf, 1, s, stdout);
}
}
};
MY_WRITER MY_WRITER_VAR;
void my_putchar(int a) {
if (MY_WRITER_VAR.s == MY_WRITER_VAR.e) {
fwrite(MY_WRITER_VAR.buf, 1, MY_WRITER_VAR.s, stdout);
MY_WRITER_VAR.s = 0;
}
MY_WRITER_VAR.buf[MY_WRITER_VAR.s++] = a;
}
inline void wt_L(char a) { my_putchar(a); }
inline void wt_L(int x) {
int s = 0;
int m = 0;
char f[10];
if (x < 0) {
m = 1;
x = -x;
}
while (x) {
f[s++] = x % 10;
x /= 10;
}
if (!s) {
f[s++] = 0;
}
if (m) {
my_putchar('-');
}
while (s--) {
my_putchar(f[s] + '0');
}
}
inline void wt_L(const char c[]) {
int i = 0;
for (i = 0; c[i] != '\0'; i++) {
my_putchar(c[i]);
}
}
template <class T>
struct LHeap {
int *hp;
int *place;
int size;
T *val;
void malloc(int N) {
hp = (int *)std::malloc(N * sizeof(int));
place = (int *)std::malloc(N * sizeof(int));
val = (T *)std::malloc(N * sizeof(T));
}
void walloc(int N, void **mem = &wmem) {
walloc1d(&hp, N, mem);
walloc1d(&place, N, mem);
walloc1d(&val, N, mem);
}
void free() {
std::free(hp);
std::free(place);
std::free(val);
}
void init(int N) {
int i;
size = 0;
for (i = (0); i < (N); i++) {
place[i] = -1;
}
}
void up(int n) {
int m;
while (n) {
m = (n - 1) / 2;
if (val[hp[m]] <= val[hp[n]]) {
break;
}
swap(hp[m], hp[n]);
swap(place[hp[m]], place[hp[n]]);
n = m;
}
}
void down(int n) {
int m;
for (;;) {
m = 2 * n + 1;
if (m >= size) {
break;
}
if (m + 1 < size && val[hp[m]] > val[hp[m + 1]]) {
m++;
}
if (val[hp[m]] >= val[hp[n]]) {
break;
}
swap(hp[m], hp[n]);
swap(place[hp[m]], place[hp[n]]);
n = m;
}
}
void change(int n, T v) {
T f = val[n];
val[n] = v;
if (place[n] == -1) {
place[n] = size;
hp[size++] = n;
up(place[n]);
} else {
if (f < v) {
down(place[n]);
} else if (f > v) {
up(place[n]);
}
}
}
int pop(void) {
int res = hp[0];
place[res] = -1;
size--;
if (size) {
hp[0] = hp[size];
place[hp[0]] = 0;
down(0);
}
return res;
}
};
template <class T>
struct segtree_Point_Minval {
int N;
int logN;
T *mn;
void malloc(int maxN, int once = 0) {
int i;
for (i = 1; i < maxN; i *= 2) {
;
}
mn = new T[2 * i];
if (once) {
setN(maxN);
}
}
void walloc(int maxN, int once = 0, void **mem = &wmem) {
int i;
for (i = 1; i < maxN; i *= 2) {
;
}
walloc1d(&mn, 2 * i, mem);
if (once) {
setN(maxN);
}
}
void free(void) { delete[] mn; }
T &operator[](int i) { return mn[N + i]; }
void setN(int n, int zerofill = 1, int dobuild = 1) {
int i;
for (i = 1, logN = 0; i < n; i *= 2, logN++) {
;
}
N = i;
if (zerofill) {
for (i = (0); i < (N); i++) {
mn[N + i] = 0;
}
}
if (dobuild) {
build();
}
}
void build(void) {
int i;
for (i = N - 1; i; i--) {
mn[i] = min_L(mn[2 * i], mn[2 * i + 1]);
}
}
inline void build(int a) {
while (a > 1) {
a /= 2;
mn[a] = min_L(mn[2 * a], mn[2 * a + 1]);
}
}
inline void change(int a, T val) {
mn[a + N] = val;
build(a + N);
}
inline void add(int a, T val) {
mn[a + N] += val;
build(a + N);
}
inline T getMinVal(int a, int b) {
T res;
T tmp;
int fga = 0;
int fgb = 0;
a += N;
b += N;
while (a < b) {
if (a % 2) {
if (fga) {
res = min_L(res, mn[a]);
} else {
res = mn[a];
fga = 1;
}
a++;
}
if (b % 2) {
b--;
if (fgb) {
tmp = min_L(mn[b], tmp);
} else {
tmp = mn[b];
fgb = 1;
}
}
a /= 2;
b /= 2;
}
if (fga == 1 && fgb == 0) {
return res;
}
if (fga == 0 && fgb == 1) {
return tmp;
}
if (fga == 1 && fgb == 1) {
res = min_L(res, tmp);
return res;
}
return res;
}
};
int N;
char E[200000];
int A[200000];
int lf[100000];
int rg[100000];
int id[100000];
int sz;
int res[100000];
segtree_Point_Minval<int> t;
LHeap<int> hp;
int main() {
wmem = memarr;
int i;
int j;
int k;
rd(N);
for (i = (0); i < (2 * N); i++) {
rd(E[i]);
if (E[i] == '-') {
rd(A[i]);
A[i] += (-1);
}
}
t.walloc(N, 1);
for (i = (0); i < (2 * N); i++) {
if (E[i] == '-') {
t.change(A[i], -i);
if (A[i] == N - 1) {
j = 0;
} else {
j = -t.getMinVal(A[i] + 1, N);
}
lf[A[i]] = j;
rg[A[i]] = i;
id[A[i]] = A[i];
}
}
hp.walloc(N);
hp.init(N);
sortA_L(N, lf, rg, id);
k = 0;
for (i = (0); i < (2 * N); i++) {
while (k < N && lf[k] == i) {
hp.change(k, rg[k]);
k++;
}
if (E[i] == '-') {
continue;
}
if (hp.size == 0) {
wt_L("NO");
wt_L('\n');
return 0;
}
j = hp.pop();
if (rg[j] < i) {
wt_L("NO");
wt_L('\n');
return 0;
}
res[sz++] = id[j];
}
wt_L("YES");
wt_L('\n');
{
int WYIGIcGE;
if (N == 0) {
wt_L('\n');
} else {
for (WYIGIcGE = (0); WYIGIcGE < (N - 1); WYIGIcGE++) {
wt_L(res[WYIGIcGE] + 1);
wt_L(' ');
}
wt_L(res[WYIGIcGE] + 1);
wt_L('\n');
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int cond = 1;
struct Edge {
int a, b, cost;
};
bool operator<(Edge a, Edge b) { return a.cost < b.cost; }
const int N = 100005;
int pr[N][20];
int mx[N][20];
int n, m, q;
Edge ed[2 * N];
int p[N];
int gp(int x) {
if (p[x] != x) p[x] = gp(p[x]);
return p[x];
}
vector<pair<int, int> > e[N];
bool visited[N];
int in[N], out[N];
bool ancestor(int a, int b) { return in[a] <= in[b] && in[b] <= out[a]; }
int tim;
void dfs(int x) {
in[x] = ++tim;
visited[x] = true;
for (int i = 1; i < 20; ++i) {
pr[x][i] = pr[pr[x][i - 1]][i - 1];
mx[x][i] = max(mx[x][i - 1], mx[pr[x][i - 1]][i - 1]);
}
for (__typeof((e[x]).begin()) it = ((e[x]).begin()); it != (e[x]).end();
++it) {
if (!visited[it->first]) {
pr[it->first][0] = x;
mx[it->first][0] = it->second;
dfs(it->first);
}
}
out[x] = ++tim;
}
int firstAncestor(int a, int b) {
int x = 0;
while (!ancestor(a, b)) {
int j = 0;
while (pr[a][j] && !ancestor(pr[a][j], b)) ++j;
if (j > 0) --j;
x = max(x, mx[a][j]);
a = pr[a][j];
}
return x;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= m; ++i) cin >> ed[i].a >> ed[i].b >> ed[i].cost;
sort(ed + 1, ed + m + 1);
for (__typeof(1) i = (1); i <= (n); ++i) p[i] = i;
long long res = 0;
int cnt = n;
for (int i = 1; i <= m; ++i) {
if (gp(ed[i].a) != gp(ed[i].b)) {
--cnt;
res += ed[i].cost;
e[ed[i].a].push_back(make_pair(ed[i].b, ed[i].cost));
e[ed[i].b].push_back(make_pair(ed[i].a, ed[i].cost));
p[gp(ed[i].a)] = gp(ed[i].b);
}
}
dfs(1);
cin >> q;
for (int i = 1; i <= q; ++i) {
int a, b;
cin >> a >> b;
if (cnt > 2) {
printf("-1\n");
} else if (cnt > 1) {
if (gp(a) != gp(b))
cout << res << "\n";
else
cout << "-1\n";
} else {
cout << res - max(firstAncestor(a, b), firstAncestor(b, a)) << "\n";
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int const N = 29;
long long m, n, k, a[N][N], res;
map<long long, long long> tmp[N][N];
void cal1(int i, int j, long long s) {
s ^= a[i][j];
if (i + j == n + 1) {
tmp[i][j][s]++;
return;
}
if (i + 1 <= m) cal1(i + 1, j, s);
if (j + 1 <= n) cal1(i, j + 1, s);
}
void cal2(int i, int j, long long s) {
if (i + j == n + 1) {
long long x = s ^ k;
res += tmp[i][j][x];
return;
}
s ^= a[i][j];
if (i - 1 > 0) cal2(i - 1, j, s);
if (j - 1 > 0) cal2(i, j - 1, s);
}
int main() {
scanf("%lld%lld%lld", &m, &n, &k);
for (int i = 1; i <= m; i++)
for (int j = 1; j <= n; j++) scanf("%lld", &a[i][j]);
cal1(1, 1, 0);
cal2(m, n, 0);
cout << res;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
if (n % 4 == 0) {
cout << 0 << "\n";
cout << n / 2 << " ";
for (long long i = 1; i < n / 2; i += 2) {
cout << i << " " << (n - i + 1) << " ";
}
cout << "\n";
return 0;
}
if (n % 4 == 1) {
cout << 1 << "\n";
cout << n / 2 << " ";
for (long long i = 2; i <= n / 2; i += 2) {
cout << i << " " << (n - i + 2) << " ";
}
cout << "\n";
return 0;
}
if (n % 4 == 2) {
cout << 1 << '\n';
cout << n / 2 << " ";
for (long long i = 1; i < n / 2; i += 2) {
cout << i << " " << (n - i + 1) << " ";
}
cout << n / 2 << "\n";
return 0;
}
if (n % 4 == 3) {
cout << 0 << "\n";
cout << n / 2 << " ";
for (long long i = 2; i < n / 2; i += 2) {
cout << i << " " << (n - i + 2) << " ";
}
cout << n / 2 + 2 << "\n";
return 0;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int d[3] = {a, b, c};
sort(d, d + 3);
int t = 0, g = 0;
for (int i = 0; i <= n / d[2]; i++) {
for (int j = 0; j <= n / d[1]; j++) {
for (int k = 0; k <= n / d[0]; k++) {
if (k * d[0] + j * d[1] + i * d[2] == n) {
g = k + j + i;
t = 1;
break;
}
}
if (t == 1) break;
}
if (t == 1) break;
}
t = 0;
int f = 0;
for (int i = 0; i <= n / d[1]; i++) {
for (int j = 0; j <= n / d[2]; j++) {
for (int k = 0; k <= n / d[0]; k++) {
if (k * d[0] + j * d[2] + i * d[1] == n) {
f = k + j + i;
t = 1;
break;
}
}
if (t == 1) break;
}
if (t == 1) break;
}
cout << max(f, g);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ori[300][300], mat[300][300], mr[300], mc[300], vis[100000],
l[100000], r[100000];
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", &ori[i][j]);
for (int i = 1; i <= n; i++) mr[i] = 0;
for (int i = 1; i <= m; i++) mc[i] = 0;
for (int i = 1; i < 1000; i++) vis[i] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
mr[i] = max(mr[i], ori[i][j]);
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
mc[i] = max(mc[i], ori[j][i]);
}
}
for (int i = 1; i <= n; i++) vis[mr[i]] = 1;
for (int i = 1; i <= m; i++) {
if (!vis[mc[i]])
vis[mc[i]] = 2;
else
vis[mc[i]] = 3;
}
int x = 0, y = 0;
for (int k = n * m; k >= 1; k--) {
if (vis[k] == 3) {
mat[++x][++y] = k;
l[x] = r[x] = y;
} else if (vis[k] == 2) {
mat[x][++y] = k;
l[x] = r[x] = y;
} else if (vis[k] == 1) {
mat[++x][y] = k;
l[x] = r[x] = y;
} else {
for (int i = 1; i <= x; i++) {
int flag = 0;
for (int j = l[i] - 1; j >= 1; j--) {
if (!mat[i][j] && mat[i - 1][j]) {
flag = 1;
mat[i][j] = k;
l[i] = j;
break;
}
}
if (flag) break;
for (int j = r[i] + 1; j <= y; j++) {
if (!mat[i][j] && mat[i + 1][j]) {
flag = 1;
mat[i][j] = k;
r[i] = j;
break;
}
}
if (flag) break;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%d ", mat[i][j]);
printf("\n");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
struct chd {
int v, d, p;
} aaa[55];
int arr[55];
int a[55], b[55], aa[55];
int main() {
int n;
while (~scanf("%d", &n)) {
int len = 0, ll = 0, min = (1 << 30), mm;
int ans;
a[0] = aa[0] = a[n] = aa[n] = 0;
for (int i = 1; i < n; i++) {
scanf("%d", &a[i]);
len += a[i];
}
for (int i = 1; i < n; i++) {
scanf("%d", &aa[i]);
ll += aa[i];
}
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
for (int i = n - 1; i >= 0; i--) {
if (len + b[i] <= min) {
mm = i;
min = len + b[i];
}
len += aa[i] - a[i];
}
ans = min;
min = (1 << 30);
b[mm] = (1 << 30);
for (int i = 0; i < n; i++) {
if (ll + b[i] <= min) min = ll + b[i];
ll += a[i + 1] - aa[i + 1];
}
ans += min;
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005], L[100005], R[100005];
int main() {
int n, q, l, r;
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 2; i <= n; i++) b[i] = abs(a[i] - a[i - 1]), L[i] = R[i] = i;
b[1] = b[n + 1] = 1000000009;
for (int i = 2; i <= n; i++)
while (b[i] >= b[L[i] - 1]) L[i] = L[L[i] - 1];
for (int i = n; i > 1; i--)
while (b[i] > b[R[i] + 1]) R[i] = R[R[i] + 1];
while (q--) {
cin >> l >> r;
long long ans = 0;
if (r == l) {
cout << "0\n";
continue;
}
l++;
for (int i = l; i <= r; i++)
ans += 1LL * (i - max(l, L[i]) + 1) * (min(r, R[i]) - i + 1) * b[i];
cout << ans << "\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, j, t, m, k, l, sum, v1, r, q, f, x, kol, y, p, z;
string s;
cin >> p;
cin >> s;
char a, b;
k = 0;
for (j = 25; j > 0; j--) {
for (i = p - 1; i > -1; i--) {
if (s[i] == 97 + j) {
a = s[i];
b = s[i - 1];
if (a == b + 1) {
s.erase(s.begin() + i);
k = k + 1;
p = p - 1;
if (i != p) {
i++;
}
} else {
if (i != p - 1) {
b = s[i + 1];
if (a == b + 1) {
s.erase(s.begin() + i);
k = k + 1;
p = p - 1;
if (i != p) {
i++;
}
}
}
}
}
}
}
cout << k << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000 * 1000 * 1000 + 7;
const int INF = 1000 * 1000 * 1000;
const long long LINF = (long long)INF * INF;
struct QR {
int op, t, a, ind;
};
int fen[100100];
void add(int i, int x) {
for (i++; i < 100100; i += i & -i) {
fen[i] += x;
}
}
int psum(int i) {
int res = 0;
for (i++; i > 0; i -= i & -i) {
res += fen[i];
}
return res;
}
int rsum(int l, int r) { return psum(r) - psum(l - 1); }
vector<int> tcor, acor;
vector<int> pos;
int n;
vector<QR> qr[100100];
QR fqr[100100];
int ans[100100];
int32_t main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = (0); i < (n); i++) {
int op, t, a;
cin >> op >> t >> a;
tcor.push_back(t);
acor.push_back(a);
fqr[i] = {op, t, a, i};
}
sort((acor).begin(), (acor).end());
sort((tcor).begin(), (tcor).end());
acor.resize(unique((acor).begin(), (acor).end()) - acor.begin());
tcor.resize(unique((tcor).begin(), (tcor).end()) - tcor.begin());
for (int i = (0); i < (n); i++) {
fqr[i].t =
lower_bound((tcor).begin(), (tcor).end(), fqr[i].t) - tcor.begin();
fqr[i].a =
lower_bound((acor).begin(), (acor).end(), fqr[i].a) - acor.begin();
qr[fqr[i].a].push_back(fqr[i]);
}
for (int i = (0); i < ((int)acor.size()); i++) {
;
;
for (auto q : qr[i]) {
;
;
;
;
;
;
if (q.op == 1) {
add(q.t, 1);
pos.push_back(q.t);
} else if (q.op == 2) {
add(q.t, -1);
pos.push_back(q.t);
} else {
ans[q.ind] = psum(q.t);
}
}
for (int u : pos) {
add(u, -rsum(u, u));
}
pos.clear();
}
for (int i = (0); i < (n); i++) {
if (fqr[i].op == 3) {
cout << ans[i] << '\n';
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = (s << 1) + (s << 3) + (ch ^ 48);
ch = getchar();
}
return s * w;
}
long long t, n, prime[20005], tot, ans, cnt, minn;
bool isprime[20005], flag;
void pre() {
for (register long long i = 2; i <= 20000; i++) {
if (!isprime[i]) prime[++tot] = i;
for (register long long j = 1; j <= tot && i * prime[j] <= 20000; j++) {
isprime[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
}
}
}
int main() {
t = read();
pre();
while (t--) {
n = read(), flag = 1, ans = 0, minn = 0x3fffffff;
for (register long long i = 1; i <= n; i++) {
long long x = read();
if (x % 2 && x < minn) minn = x, cnt = i;
ans += x;
}
for (register long long i = 1; i <= tot && flag; i++)
if (prime[i] == ans) flag = 0;
if (flag) {
printf("%lld\n", n);
for (register long long i = 1; i <= n; i++) printf("%lld ", i);
} else {
printf("%lld\n", n - 1);
for (register long long i = 1; i <= n; i++)
if (i != cnt) printf("%lld ", i);
}
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400010;
class TWO_SAT {
vector<int> A[N], T[N];
int tag[N];
int noot[N];
vector<int> topo;
bool vis1[N];
void dfs1(int u) {
vis1[u] = true;
for (auto v : A[u])
if (!vis1[v]) dfs1(v);
topo.push_back(u);
}
bool vis2[N];
void dfs2(int u, int k) {
vis2[u] = true;
tag[u] = k;
for (auto v : T[u])
if (!vis2[v]) dfs2(v, k);
}
int dagN;
void makeDag(int n) {
memset(tag, -1, sizeof(tag));
memset(vis1, 0, sizeof(vis1));
memset(vis2, 0, sizeof(vis2));
for (int i = 0; i < n; ++i)
if (!vis1[i]) dfs1(i);
dagN = 0;
reverse(topo.begin(), topo.end());
for (auto u : topo) {
if (!vis2[u]) dfs2(u, dagN++);
}
}
bool did[N];
bool ans[N];
bool solve() {
for (int so : topo) {
if (did[tag[so]]) continue;
int si = noot[so];
if (tag[si] == tag[so]) return false;
ans[tag[si]] = 1;
ans[tag[so]] = 0;
did[tag[si]] = true;
did[tag[so]] = true;
}
return true;
}
int satn = 0;
int mapp[N];
bool exist = false;
public:
TWO_SAT() { memset(mapp, -1, sizeof(mapp)); }
bool Exist() { return exist; }
bool Solve() {
makeDag(satn);
exist = solve();
return exist;
}
void addClaw(int x1, int x2, bool b1, bool b2) {
if (mapp[x1] == -1) {
mapp[x1] = satn++;
noot[mapp[x1]] = satn++;
noot[noot[mapp[x1]]] = mapp[x1];
}
if (mapp[x2] == -1) {
mapp[x2] = satn++;
noot[mapp[x2]] = satn++;
noot[noot[mapp[x2]]] = mapp[x2];
}
x1 = mapp[x1];
if (b1) x1 = noot[x1];
x2 = mapp[x2];
if (b2) x2 = noot[x2];
A[noot[x1]].push_back(x2);
A[noot[x2]].push_back(x1);
T[x1].push_back(noot[x2]);
T[x2].push_back(noot[x1]);
}
bool Ans(int x) { return ans[tag[mapp[x]]]; }
} sat;
const int M = 2020;
char stati[M][M];
char statf[M][M];
char bar[M];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
for (int i = 0; i < n; ++i) cin >> stati[i];
for (int i = 0; i < n; ++i) cin >> statf[i];
cin >> bar;
bool ans = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
stati[i][j] -= '0';
statf[i][j] -= '0';
if (bar[i] - '0' && bar[j] - '0') {
sat.addClaw(2 * i, 2 * j + 1, stati[i][j], 1 ^ statf[i][j]);
sat.addClaw(2 * i, 2 * j + 1, 1 ^ stati[i][j], statf[i][j]);
} else if (bar[j] - '0') {
sat.addClaw(2 * i, 2 * i, 1 ^ stati[i][j] ^ statf[i][j],
1 ^ stati[i][j] ^ statf[i][j]);
} else if (bar[i] - '0') {
sat.addClaw(2 * j + 1, 2 * j + 1, 1 ^ stati[i][j] ^ statf[i][j],
1 ^ stati[i][j] ^ statf[i][j]);
} else if (stati[i][j] ^ statf[i][j]) {
ans = 0;
}
}
}
if (!ans || !sat.Solve()) {
cout << -1 << '\n';
return 0;
};
int cnt = 0;
for (int i = 0; i < 2 * n; i++) cnt += sat.Ans(i);
cout << cnt << '\n';
for (int i = 0; i < 2 * n; i += 2)
if (sat.Ans(i)) cout << "row " << i / 2 << '\n';
for (int i = 1; i < 2 * n; i += 2)
if (sat.Ans(i)) cout << "col " << i / 2 << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
inline int read() {
register int ch = getchar();
while ((ch ^ '-') && !isdigit(ch)) ch = getchar();
register int rtn = 0, f = 1;
if (ch == '-') f = -1, ch = getchar();
while (isdigit(ch)) rtn = rtn * 10 + ch - '0', ch = getchar();
return f * rtn;
}
struct t1 {
int to, nxt;
} edge[1000006];
int cnt_edge = 0;
int fst[1000006];
inline void addedge(int x, int y) {
edge[++cnt_edge].to = y;
edge[cnt_edge].nxt = fst[x];
fst[x] = cnt_edge;
}
int fth[1000006], val[1000006];
int sum_all, ave;
int sum[1000006];
int root;
int ans[1000006], cnt_ans = 0;
void dfs(int now) {
sum[now] = val[now];
for (int tmp = fst[now]; tmp; tmp = edge[tmp].nxt) {
int aim = edge[tmp].to;
dfs(aim);
sum[now] += sum[aim];
}
if (sum[now] == ave && (now ^ root)) ans[++cnt_ans] = now, sum[now] = 0;
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
fth[i] = read();
val[i] = read(), sum_all += val[i];
if (!fth[i])
root = i;
else
addedge(fth[i], i);
}
if (sum_all % 3) return puts("-1"), 0;
ave = sum_all / 3;
dfs(root);
if (cnt_ans >= 2)
printf("%d %d", ans[1], ans[2]);
else
puts("-1");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
long long from, to, w;
edge(int from, int to, long long w) : from(from), to(to), w(w) {}
bool operator<(const edge& e) const { return ((w > e.w)); }
};
void O_o() {
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
}
bool valid(long long i, long long j, long long n, long long m) {
return (i >= 0 && i < n && j >= 0 && j < m);
}
long long n, k, a, b;
vector<long long> vec;
bool ok(long long x) {
long long cnt = 999999999;
multimap<int, pair<int, int> > mm;
for (int i = x; i < n + 1; i++) {
cnt = x - vec[i] + vec[i - x];
if (cnt <= k) {
b = i, a = i - x + 1;
return 1;
}
}
return 0;
}
int main() {
O_o();
cin >> n >> k;
int arr[n + 5];
vec.push_back(0);
for (int i = 1; i <= int(n); i++) {
cin >> arr[i];
vec.push_back(arr[i] + vec.back());
}
long long second = 0, e = 1e9, ans = 2e9 + 7, x = 0, y = 0, i = 65;
while (second < e) {
long long mid = (second + e) >> 1;
if (ok(mid)) {
second = mid + 1;
} else
e = mid - 1;
}
second -= 3;
while (ok(second)) ++second;
second--;
ok(second);
cout << second << endl;
for (int i = 1; i <= int(n); i++) {
if (i >= a && i <= b)
cout << "1 ";
else
cout << arr[i] << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
const int Mod = 1e9 + 7;
int n, m;
long long rockr[N][N], rockc[N][N];
long long dpr[N][N], dpc[N][N];
long long sumr[N][N], sumc[N][N];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
long long x = (c == 'R');
rockr[i][j] = rockr[i][j - 1] + x;
rockc[i][j] = rockc[i - 1][j] + x;
}
if (n == 1 && m == 1) {
cout << 1 << endl;
return 0;
}
dpr[1][1] = dpc[1][1] = sumr[1][1] = sumc[1][1] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
if (i == 1 && j == 1) continue;
int l = 1, r = j;
while (l < r) {
int mid = (l + r) >> 1;
if (rockr[i][m] - rockr[i][mid] <= m - j)
r = mid;
else
l = mid + 1;
}
dpr[i][j] = (sumr[i][j - 1] - sumr[i][l - 1] + Mod) % Mod;
int u = 1, d = i;
while (u < d) {
int mid = (u + d) >> 1;
if (rockc[n][j] - rockc[mid][j] <= n - i)
d = mid;
else
u = mid + 1;
}
dpc[i][j] = (sumc[i - 1][j] - sumc[u - 1][j] + Mod) % Mod;
sumr[i][j] = (sumr[i][j - 1] + dpc[i][j]) % Mod;
sumc[i][j] = (sumc[i - 1][j] + dpr[i][j]) % Mod;
}
cout << (dpc[n][m] + dpr[n][m]) % Mod << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 998244353;
struct Edge {
int v, next;
} edge[300010 * 2];
int e, ft[300010];
int n;
long long dp[300010][3];
bool flag[300010];
void init_graph() {
e = 0;
memset(ft, -1, sizeof(ft));
}
void add_edge(int u, int v) {
edge[e].v = v;
edge[e].next = ft[u];
ft[u] = e++;
}
void dfs(int u) {
flag[u] = true;
dp[u][0] = 1;
dp[u][1] = 0;
dp[u][2] = 0;
long long c[3];
for (int i = ft[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
if (flag[v]) continue;
dfs(v);
c[0] = c[1] = c[2] = 0;
for (int j = 0; j < 3; j++) {
for (int k = 0; k < 3; k++) {
if (k != 1) c[j] += dp[u][j] * dp[v][k] % mod;
if ((j != 2 && k != 2) || (j == 2 && k == 2)) {
c[2] += dp[u][j] * dp[v][k] % mod;
} else if ((j == 0 || j == 1) && k == 2) {
c[1] += dp[u][j] * dp[v][k] % mod;
}
}
}
dp[u][0] = c[0] % mod;
dp[u][1] = c[1] % mod;
dp[u][2] = c[2] % mod;
}
}
void solve() {
memset(flag, false, sizeof(flag));
dfs(1);
long long ans = (dp[1][0] + dp[1][2]) % mod;
cout << ans << endl;
}
int main() {
while (cin >> n) {
int u, v;
init_graph();
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
add_edge(u, v);
add_edge(v, u);
}
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k, m;
cin >> n >> k >> m;
vector<long long> a(k);
for (long long& v : a) cin >> v;
sort(a.begin(), a.end());
a.push_back(0);
k++;
a.insert(a.begin(), 0);
for (int i = 1; i <= k; i++) a[i] += a[i - 1];
vector<long long> dp((k + 1) * n, 1e18);
dp[0] = 0;
for (int i = 0; i < n; i++) {
auto ndp = dp;
for (int j = 0; j <= k; j++) {
for (int l = dp.size() - 1 - j; l >= 0; l--)
ndp[l + j] = min(ndp[l + j], dp[l] + a[j]);
}
dp = ndp;
}
cout << upper_bound(dp.begin(), dp.end(), m) - dp.begin() - 1 << endl;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
void qread(int &x) {
int neg = 1;
x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') neg = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = 10 * x + c - '0', c = getchar();
x *= neg;
}
const int maxn = 405;
int test, n, mod;
int dp[maxn][maxn * 2], fac[maxn];
int quickpow(int x, int pow) {
int res = 1;
for (; pow; pow >>= 1) {
if (pow & 1) res = 1LL * res * x % mod;
x = 1LL * x * x % mod;
}
return res;
}
void work() {
for (int(i) = 1; (i) <= 400; i++) dp[i][i + 400] = 1;
for (int(i) = 1; (i) <= 400; i++) {
int inv = quickpow(dp[i][i], mod - 2);
for (int j = i + 1; j <= 2 * 400; j++)
dp[i][j] = 1LL * dp[i][j] * inv % mod;
dp[i][i] = 1;
for (int j = i + 1; j <= 400; j++) {
for (int k = i + 1; k <= 2 * 400; k++)
dp[j][k] = (dp[j][k] - 1LL * dp[j][i] * dp[i][k] % mod + mod) % mod;
dp[j][i] = 0;
}
}
}
int main() {
scanf("%d%d", &test, &mod);
fac[0] = 1;
for (int(i) = 1; (i) <= 400; i++) fac[i] = 1LL * fac[i - 1] * i % mod;
for (int(i) = 1; (i) <= 400; i++) {
dp[i][1] = fac[i];
for (int k = 2; k <= i; k++) {
for (int m = 0; m <= i - k; m++)
dp[i][k] =
(dp[i][k] + 1LL * fac[m + 1] * dp[i - m - 1][k - 1] % mod) % mod;
}
}
work();
while (test--) {
scanf("%d", &n);
if (n == 2) {
puts("2");
continue;
}
int ans = ((mod - dp[n][401]) % mod + ((n & 1) ? 2 : -2) + mod) % mod;
printf("%d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100005;
int n, sol[MaxN];
struct nesto {
int val, idx;
} a[MaxN];
bool cmp(nesto a, nesto b) {
return a.val < b.val || (a.val == b.val && a.idx < b.idx);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].val);
a[i].idx = i;
}
sort(a + 1, a + n + 1, cmp);
int m = 0;
for (int i = 1; i <= n;) {
int j = i;
while (a[j].val == a[j + 1].val && j < n) {
if (m > a[j].idx)
sol[a[j].idx] = m - a[j].idx;
else
sol[a[j].idx] = 0;
j++;
}
if (m > a[j].idx)
sol[a[j].idx] = m - a[j].idx;
else
sol[a[j].idx] = 0;
for (int k = i; k <= j; k++) m = max(m, a[k].idx);
i = j + 1;
}
for (int i = 1; i <= n; i++) printf("%d ", sol[i] - 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, i, j, c, t, a, b, d[100005], l[100005], len[100005],
g[100005][11], pos[50][50], p[50], res, ans, mod = 998244353;
string s;
vector<int> v;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> d[i];
for (j = d[i], t = 0; j > 0; t++, j /= 10) {
g[i][t] = j % 10;
}
l[i] = t;
len[t]++;
}
p[0] = 1;
for (int i = 1; i <= 22; i++) p[i] = (p[i - 1] * 10) % mod;
for (int i = 0; i < n; i++) {
for (int j = 0; j < l[i]; j++) {
for (int t = 0; t <= 10; t++) {
if (t <= j) {
pos[g[i][j]][t + j] += len[t];
pos[g[i][j]][t + j] += len[t];
} else {
pos[g[i][j]][2 * j + 1] += len[t];
pos[g[i][j]][2 * j] += len[t];
}
}
}
}
for (int i = 1; i <= 10; i++) {
for (int j = 0; j < 25; j++) {
if (pos[i][j] == 0) continue;
res = (res + (i * ((pos[i][j] * p[j]) % mod)) % mod) % mod;
}
}
cout << res;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N, K, G;
vector<string> str;
char text[2000100], x[2000100];
vector<vector<int> > child;
vector<vector<int> > childChar;
vector<int> fail;
vector<int> isEnding;
int n;
int addNode() {
++n;
child.push_back(vector<int>(26, -1));
childChar.push_back(vector<int>());
fail.push_back(0);
isEnding.push_back(-1);
return n - 1;
}
void init() {
child.clear();
childChar.clear();
fail.clear();
isEnding.clear();
n = 0;
addNode();
}
void buildTrie() {
for (int i = 0; i < G; ++i) {
int cur = 0;
for (int j = 0; j < str[i].size(); ++j) {
char c = str[i][j] - 'a';
if (child[cur][c] == -1) {
child[cur][c] = addNode();
childChar[cur].push_back(c);
}
cur = child[cur][c];
}
isEnding[cur] = i;
}
}
void buildFail() {
queue<int> q;
for (int i = 0; i < childChar[0].size(); ++i)
q.push(child[0][childChar[0][i]]);
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int i = 0; i < childChar[cur].size(); ++i) {
char c = childChar[cur][i];
int to = child[cur][c], tmp = cur;
q.push(to);
while (1) {
if (~child[fail[tmp]][c]) {
fail[to] = child[fail[tmp]][c];
break;
}
if (tmp == 0) break;
tmp = fail[tmp];
}
}
}
}
int nxt(int cur, char c) {
while (child[cur][c] == -1 && cur) cur = fail[cur];
if (~child[cur][c]) return child[cur][c];
return cur;
}
int id[2000100];
int main() {
scanf("%d", &N), scanf("%d", &K);
scanf(" %s", text);
for (int i = 0; i < N * K; i++) text[i + N * K] = text[i];
text[2 * N * K] = 0;
scanf("%d", &G);
for (int i = 0; i < G; ++i) scanf(" %s", x), str.push_back(string(x));
init();
buildTrie();
buildFail();
int cur = 0;
memset(id, -1, sizeof id);
for (int i = 0; i < 2 * N * K; i++) {
cur = nxt(cur, text[i] - 'a');
if (~isEnding[cur]) id[i - K + 1] = isEnding[cur];
}
for (int s = 0; s < K; s++) {
vector<int> vec, out;
for (int i = s, j = 0; j < N; j++, i += K) {
vec.push_back(id[i]);
out.push_back(id[i]);
}
sort(vec.begin(), vec.end());
if (vec[0] == -1) continue;
bool ok = 1;
for (int i = 0; i < N - 1; ++i)
if (vec[i] == vec[i + 1]) ok = 0;
if (ok) {
puts("YES");
for (int i = 0; i < N; ++i) printf("%d ", out[i] + 1);
return 0;
}
}
puts("NO");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<long long> pr;
int sost[21000];
bool isPrime(long long x) {
bool prime = true;
for (long long i = 2; i * i <= x; ++i) {
if (x % i) continue;
prime = false;
break;
}
if (x < 2) prime = false;
return prime;
}
int main() {
ios::sync_with_stdio(0);
sost[1] = 1;
for (int i = 2; i < 21000; ++i) {
if (sost[i]) continue;
pr.push_back(i);
for (int j = i + i; j < 21000; j += i) sost[j] = 1;
}
cin >> n;
if (isPrime(n))
cout << 1 << "\n" << n << "\n";
else if (isPrime(n - 2))
cout << 2 << "\n" << 2 << " " << n - 2 << "\n";
else {
for (int i = 0; i < pr.size(); ++i) {
long long m = n - pr[i];
if (m % 2) continue;
m /= 2;
if (isPrime(m)) {
cout << 3 << "\n" << pr[i] << " " << m << " " << m << "\n";
break;
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1, x2), gn(x3);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = (long long)a * a % m)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
long long first[100010], second[100010];
long long arr[100010 << 2];
int nn;
pair<int, pair<int, int> > p[100010];
long long sum[(100010 << 4)], ans[(100010 << 4)];
int num[(100010 << 4)];
void push_up(int u) {
num[u] = num[(u << 1)] + num[((u << 1) | 1)];
sum[u] = sum[(u << 1)] + sum[((u << 1) | 1)];
ans[u] = ans[(u << 1)] + ans[((u << 1) | 1)];
ans[u] +=
num[(u << 1)] * sum[((u << 1) | 1)] - num[((u << 1) | 1)] * sum[(u << 1)];
}
void update(int u, int L, int R, int l, int r, long long first, int k) {
smax(l, L);
smin(r, R);
if (l >= r) return;
if (l == L && r == R) {
ans[u] = 0;
sum[u] = first;
num[u] = k;
return;
}
update((u << 1), L, (L + R >> 1), l, r, first, k);
update(((u << 1) | 1), (L + R >> 1), R, l, r, first, k);
push_up(u);
}
int cnt;
long long s, sz;
void calc(int u, int L, int R, int l, int r) {
smax(l, L);
smin(r, R);
if (l >= r) return;
if (l == L && r == R) {
s += ans[u] + cnt * sum[u] - num[u] * sz;
sz += sum[u];
cnt += num[u];
return;
}
calc((u << 1), L, (L + R >> 1), l, r);
calc(((u << 1) | 1), (L + R >> 1), R, l, r);
}
int main() {
int n, m;
gn(n);
for (int i = 1; i <= n; i++) {
gn(first[i]);
second[i] = first[i];
arr[nn++] = first[i];
}
gn(m);
for (int i = 0; i < m; i++) {
gn(p[i].first, p[i].second.first, p[i].second.second);
int a = p[i].second.first, b = p[i].second.second;
if (p[i].first == 1) {
second[a] += b;
arr[nn++] = second[a];
} else {
arr[nn++] = a;
arr[nn++] = b;
}
}
sort(arr, arr + nn);
nn = unique(arr, arr + nn) - arr;
for (int i = 1; i <= n; i++) {
int id = lower_bound(arr, arr + nn, first[i]) - arr;
update(1, 0, nn, id, id + 1, first[i], 1);
}
for (int i = 0; i < m; i++) {
int a = p[i].second.first, b = p[i].second.second;
if (p[i].first == 1) {
int id = lower_bound(arr, arr + nn, first[a]) - arr;
update(1, 0, nn, id, id + 1, 0, 0);
first[a] += b;
id = lower_bound(arr, arr + nn, first[a]) - arr;
update(1, 0, nn, id, id + 1, first[a], 1);
} else {
int l = lower_bound(arr, arr + nn, a) - arr;
int r = upper_bound(arr, arr + nn, b) - arr;
s = sz = cnt = 0;
calc(1, 0, nn, l, r);
println(s);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct Dinic {
using F = int;
const static F INF = 0x3f3f3f3f;
struct Edge {
int v, bro;
F cap;
Edge() {}
Edge(int _v, int _bro, F _cap) : v(_v), bro(_bro), cap(_cap) {}
};
vector<Edge> e;
vector<int> pos, cur;
int n, s, t, m;
Dinic(int _n, int _s, int _t) : n(_n), s(_s), t(_t), m(0) {
pos.assign(n, -1);
cur.resize(n);
d.resize(n);
e.reserve(4e5);
}
void add(int u, int v, F c = INF) {
assert(u < n && v < n);
e.emplace_back(v, pos[u], c);
pos[u] = m++;
e.emplace_back(u, pos[v], 0);
pos[v] = m++;
}
vector<int> d;
bool bfs() {
fill(d.begin(), d.end(), -1);
d[s] = 0;
queue<int> q;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = cur[u] = pos[u]; i != -1; i = e[i].bro) {
int v = e[i].v;
if (d[v] == -1 && e[i].cap != 0) {
d[v] = d[u] + 1;
q.push(v);
}
}
}
return d[t] != -1;
}
F dfs(int u, F lim) {
if (u == t) return lim;
F tot = 0;
for (int& i = cur[u]; i != -1; i = e[i].bro) {
int v = e[i].v;
if (e[i].cap != 0 && d[v] == d[u] + 1) {
F flow = dfs(v, min(e[i].cap, lim - tot));
tot += flow;
e[i].cap -= flow;
e[i ^ 1].cap += flow;
if (tot == lim) return lim;
}
}
return tot;
}
F flow() {
F res = 0;
while (bfs()) {
res += dfs(s, INF);
}
return res;
}
};
struct ProjectSelection {
int n;
int s, t;
Dinic mc;
using F = Dinic::F;
F positive;
ProjectSelection(int _n)
: n(_n), s(n), t(n + 1), mc(n + 2, s, t), positive(0) {}
void add_proj(int i, F profit) {
if (profit >= 0) {
mc.add(s, i, profit);
positive += profit;
} else {
mc.add(i, t, -profit);
}
}
void add_dep(int u, int v) { mc.add(u, v); }
F profit() { return positive - mc.flow(); }
};
const int N = 55;
int a[N][N];
int v = 0;
void solve() {
int n, h, m;
cin >> n >> h >> m;
ProjectSelection ps(n * h + m);
for (int i = 0; i < n; i++) {
for (int j = 1; j <= h; j++) {
a[i][j] = v++;
ps.add_proj(a[i][j], 2 * j - 1);
if (j > 1) {
ps.add_dep(a[i][j], a[i][j - 1]);
}
}
}
for (int _ = 0; _ < m; _++) {
int l, r, x, c;
cin >> l >> r >> x >> c;
l--;
x++;
if (x <= h) {
ps.add_proj(v, -c);
for (int i = l; i < r; i++) {
ps.add_dep(a[i][x], v);
}
v++;
}
}
cout << ps.profit();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
cout << endl;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long BIG = 1446803456761533460LL;
const int Big = 336860180;
const int INF = INT_MAX;
const int adj4[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const int adj8[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{-1, -1}, {1, -1}, {-1, 1}, {1, 1}};
int clk_ar[10];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int powMod(int a, int b) {
int n = 1;
int p = a;
while (b > 0) {
if (b % 2 == 1) {
n *= p;
n %= MOD;
}
p *= p;
p %= MOD;
b /= 2;
}
return n;
}
int modularInverse(int a) { return powMod(a, MOD - 2); }
stringstream sss;
const int maxn = 5010;
int ent[maxn][maxn];
int dp[maxn][maxn];
int lst[maxn];
int sum[maxn];
string s;
void MAIN() {
for (int i = 0; i < (maxn); ++i) {
ent[0][i] = 1;
}
for (int i = (1); i < (maxn); ++i) {
for (int j = (1); j < (maxn); ++j) {
ent[i][j] = (ent[i - 1][j - 1] + ent[i][j - 1]) % MOD;
}
}
int n;
cin >> n;
cin >> s;
for (int i = 0; i < (26); ++i) {
lst[i] = maxn - 5;
}
for (int i = 0; i < (n); ++i) {
int chr = s[i] - 'a';
for (int j = (n + 1) - 1; j >= (2); --j) {
dp[i][j] = (sum[j - 1] - dp[lst[chr]][j - 1] + MOD) % MOD;
sum[j] = ((sum[j] - dp[lst[chr]][j] + MOD) % MOD + dp[i][j]) % MOD;
}
dp[i][1] = 1;
if (lst[chr] == maxn - 5) ++sum[1];
lst[chr] = i;
}
int res = 0;
for (int i = (1); i < (n + 1); ++i) {
res = (res + (long long)sum[i] * ent[i - 1][n - 1] % MOD) % MOD;
}
cout << (res) << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
sss << R"(
7
abacaba
)";
MAIN();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> dp;
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int n;
int l[108000];
int c[108000];
int main() {
cin >> n;
dp[0] = 0;
for (int i = 0; i < n; i++) cin >> l[i];
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < n; i++) {
for (auto it = dp.begin(); it != dp.end(); it++) {
int g = gcd(it->first, l[i]);
if (g == it->first) continue;
if (dp.count(g) == 0)
dp[g] = it->second + c[i];
else
dp[g] = min(dp[g], it->second + c[i]);
}
}
if (dp.count(1) == 0)
cout << -1 << endl;
else
cout << dp[1] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const long long INF_LL = 1000000000000000000LL;
const int h = 100011, T = 20;
int n, m, k;
vector<int> r[h];
int t[h], mn[h], c[h];
int tt;
bool us[h];
void dfs(int v, int pr) {
us[v] = true;
t[v] = mn[v] = tt++;
c[v] = v;
for (int i(0), _b(int((r[v]).size())); i < _b; ++i) {
int u = r[v][i];
if (!us[u]) dfs(u, v);
if (u != pr && mn[u] < mn[v]) {
mn[v] = mn[u];
c[v] = c[u];
}
}
}
vector<int> g[h];
int l[h], p[h][T];
void dfsp(int v, int pr) {
l[v] = pr == -1 ? 0 : l[pr] + 1;
p[v][0] = pr;
for (int i(0), _b(T - 1); i < _b; ++i) {
if (p[v][i] == -1) break;
p[v][i + 1] = p[p[v][i]][i];
}
for (int i(0), _b(int((g[v]).size())); i < _b; ++i)
if (g[v][i] != pr) dfsp(g[v][i], v);
}
int main() {
scanf("%d%d", &n, &m);
int a, b;
for (int i(0), _b(m); i < _b; ++i) {
scanf("%d%d", &a, &b);
--a;
--b;
r[a].push_back(b);
r[b].push_back(a);
}
memset(us, 0, sizeof us);
tt = 0;
dfs(0, -1);
for (int v(0), _b(n); v < _b; ++v) {
int u = v;
vector<int> l;
while (c[u] != u) {
l.push_back(u);
u = c[u];
}
for (int i(0), _b(int((l).size())); i < _b; ++i) c[l[i]] = u;
}
for (int v(0), _b(n); v < _b; ++v)
for (int i(0), _b(int((r[v]).size())); i < _b; ++i) {
int u = r[v][i];
if (c[u] != c[v]) g[c[v]].push_back(c[u]);
}
for (int v(0), _b(n); v < _b; ++v) {
sort((g[v]).begin(), (g[v]).end());
g[v].resize(unique((g[v]).begin(), (g[v]).end()) - g[v].begin());
}
memset(p, -1, sizeof p);
dfsp(0, -1);
scanf("%d", &k);
for (int kk(0), _b(k); kk < _b; ++kk) {
scanf("%d%d", &a, &b);
a = c[a - 1];
b = c[b - 1];
int res = 0;
if (l[a] < l[b]) swap(a, b);
for (int i(T - 1), _b(0); i >= _b; --i)
if (l[a] - (1 << i) >= l[b]) {
a = p[a][i];
res += 1 << i;
}
for (int i(T - 1), _b(0); i >= _b; --i) {
if (p[a][i] != p[b][i]) {
a = p[a][i];
b = p[b][i];
res += 1 << (i + 1);
}
}
if (a != b) res += 2;
printf("%d\n", res);
}
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.