solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt = 0, a[1005];
int aw[55] = {25, 18, 15, 12, 10, 8, 6, 4, 2, 1};
map<string, vector<int> > ww;
map<string, int> ps;
struct id {
string n;
id(string n) : n(n) {}
};
bool rule1(const id& l, const id& r) {
if (ps[l.n] != ps[r.n])
return ps[l.n] > ps[r.n];
else
return ww[l.n] > ww[r.n];
}
bool rule2(const id& l, const id& r) {
if (ww[l.n][0] != ww[r.n][0])
return ww[l.n][0] > ww[r.n][0];
else if (ps[l.n] != ps[r.n])
return ps[l.n] > ps[r.n];
return ww[l.n] > ww[r.n];
}
int main() {
int t;
cin >> t;
vector<id> dris;
for (int i = 0; i < t; i++) {
int n;
cin >> n;
for (int j = 0; j < n; j++) {
string s;
cin >> s;
if (ps.find(s) == ps.end()) {
ps[s] = 0;
ww[s] = vector<int>(100, 0);
dris.push_back(id(s));
}
ww[s][j]++;
ps[s] += aw[j];
}
}
sort(dris.begin(), dris.end(), rule1);
cout << dris[0].n << endl;
sort(dris.begin(), dris.end(), rule2);
cout << dris[0].n << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long inv[300010], mod = 1e9 + 7, n, a[300010], maxn;
long long bm[300010], dp[300010], cnt[300010];
long long ksm(long long a, long long b) {
long long tot = a, tmp = 1;
while (b) {
if (b & 1) tmp = tmp * tot % mod;
tot = tot * tot % mod;
b >>= 1;
}
return tmp;
}
void getInv(long long x) {
bm[0] = 1;
for (long long i = 1; i <= x; i++) bm[i] = bm[i - 1] * i % mod;
inv[x] = ksm(bm[x], mod - 2);
for (long long i = x - 1; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
}
int main() {
scanf("%d", &n);
getInv(n);
for (long long i = 1; i <= n; i++) {
scanf("%d", &a[i]);
cnt[a[i]]++;
maxn = maxn > a[i] ? maxn : a[i];
}
for (long long i = 1; i <= maxn; i++)
for (long long j = 2; i * j <= maxn; j++) cnt[i] += cnt[i * j];
for (long long i = 1; i <= 7; i++) {
for (long long j = 1; j <= maxn; j++) dp[j] = 0;
for (long long j = maxn; j >= 1; j--) {
if (cnt[j] < i) continue;
dp[j] = bm[cnt[j]] * inv[cnt[j] - i] % mod;
dp[j] = dp[j] * inv[i] % mod;
for (long long k = 2; k * j <= maxn; k++) {
dp[j] = (dp[j] - dp[j * k] + mod) % mod;
}
}
if (dp[1]) {
printf("%d", i);
goto brown;
}
}
printf("-1");
brown:
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt;
cin >> tt;
while (tt--) {
int n, ans = INT_MAX;
cin >> n;
vector<int> a(n);
for (int &i : a) cin >> i, i %= 2;
for (int f = 0; f < 2; f++) {
vector<int> pos, x;
for (int i = f; i < n; i += 2) pos.push_back(i);
for (int i = 0; i < n; i++)
if (a[i]) x.push_back(i);
if (pos.size() == x.size()) {
int cur_ans = 0;
for (int i = 0; i < pos.size(); i++) cur_ans += abs(pos[i] - x[i]);
ans = min(ans, cur_ans);
}
}
if (ans == INT_MAX) ans = -1;
cout << ans << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200008;
vector<int> a[N];
int n, m, ns[N];
long long ans, b[N], c[N][6];
int dfs(int x, int pre) {
int i, j, k, son;
ns[x] = 1;
b[x] = 0;
c[x][0] = 1;
for (i = 0; i < (int)a[x].size(); i++)
if ((son = a[x][i]) != pre) {
dfs(son, x);
ns[x] += ns[son];
b[x] += ns[son] + b[son];
}
for (i = 0; i < (int)a[x].size(); i++)
if ((son = a[x][i]) != pre) {
ans += (ns[x] - ns[son]) * (ns[son] + b[son]);
for (j = 0; j < m; j++)
for (k = 0; k < m; k++)
if ((j + k + 1) % m)
ans += (m - (j + k + 1) % m) * c[x][k] * c[son][j];
for (j = 0; j < m; j++) c[x][(j + 1) % m] += c[son][j];
}
return 0;
}
int main(void) {
int i, p1, p2;
scanf("%d%d", &n, &m);
for (i = 1; i < n; i++) {
scanf("%d%d", &p1, &p2);
a[p1].push_back(p2);
a[p2].push_back(p1);
}
dfs(1, 0);
cout << ans / m;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, l;
cin >> n >> l;
long long a[n][2];
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
a[i][0] = x;
a[i][1] = y;
}
long long ans[n];
memset(ans, 0, sizeof(ans));
long long i = 0, x, y;
x = a[i][0];
y = a[i][1];
long long t = 0;
queue<long long> q;
while (i < n) {
if (t <= x) {
if (q.empty()) {
ans[i] = x + y;
t = x + y;
i++;
x = a[i][0];
y = a[i][1];
} else {
int j = q.front();
q.pop();
t += a[j][1];
ans[j] = t;
l++;
}
} else if (l > 0) {
q.push(i);
i++;
x = a[i][0];
y = a[i][1];
l--;
} else {
ans[i] = -1;
i++;
x = a[i][0];
y = a[i][1];
}
}
while (!q.empty()) {
long long j = q.front();
q.pop();
t += a[j][1];
ans[j] = t;
}
for (i = 0; i < n; i++) {
cout << ans[i] << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
cout << a[n - k];
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int x, y;
cin >> x >> y;
int sum = abs(x) + abs(y);
if (x <= 0 && y <= 0) {
cout << 0 - sum << " " << 0 << " ";
cout << 0 << " " << 0 - sum;
return 0;
}
if (x <= 0 && y >= 0) {
cout << 0 - sum << " " << 0 << " ";
cout << 0 << " " << sum;
return 0;
}
if (x >= 0 && y <= 0) {
cout << 0 << " " << -sum;
cout << " " << sum << " " << 0;
return 0;
}
if (x >= 0 && y >= 0) {
cout << 0 << " " << sum;
cout << " " << sum << " " << 0;
return 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mm;
int main() {
int amm;
scanf("%d", &amm);
int k;
bool flag = 1;
int ans = 0;
for (int i = 0; i < amm; i++) {
scanf("%d", &k);
if (k == 0) continue;
if (!mm.count(k)) {
mm[k] = 1;
} else {
mm[k]++;
if (mm[k] == 2) ans++;
if (mm[k] == 3) flag = 0;
}
}
if (flag == 0)
printf("-1\n");
else
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<vector<int> > ans;
while (n >= 5) {
int sz = n - 2;
for (int i = 0; i + 1 < sz; i++) {
vector<int> nd;
nd.push_back(i);
nd.push_back(n - 2);
nd.push_back(i + 1);
nd.push_back(n - 1);
ans.push_back(nd);
}
vector<int> nd;
nd.push_back(0);
nd.push_back(n - 1);
nd.push_back(n - 2);
ans.push_back(nd);
nd.clear();
nd.push_back(sz - 1);
nd.push_back(n - 1);
nd.push_back(n - 2);
ans.push_back(nd);
n -= 2;
}
if (n == 3) {
vector<int> nd;
nd.push_back(0);
nd.push_back(1);
nd.push_back(2);
ans.push_back(nd);
ans.push_back(nd);
} else {
vector<int> nd;
nd.push_back(0);
nd.push_back(1);
nd.push_back(2);
ans.push_back(nd);
nd.clear();
nd.push_back(0);
nd.push_back(1);
nd.push_back(3);
ans.push_back(nd);
nd.clear();
nd.push_back(1);
nd.push_back(2);
nd.push_back(3);
ans.push_back(nd);
nd.clear();
nd.push_back(2);
nd.push_back(0);
nd.push_back(3);
ans.push_back(nd);
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
vector<int> nd = ans[i];
printf("%d", nd.size());
for (int j = 0; j < nd.size(); j++) printf(" %d", nd[j] + 1);
puts("");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = (1 << 22) + 5;
int n, m, a[MAX];
bool mk[MAX][2], in[MAX];
int neg(int x) {
int pw = (1 << n) - 1;
return x ^ pw;
}
void dfs(int u, int t) {
if (mk[u][t]) return;
mk[u][t] = 1;
if (t == 1) {
dfs(u, 2);
return;
}
if (in[neg(u)]) dfs(neg(u), 1);
for (int k = 0; k < n; k++) {
if ((u & (1 << k)) == 0) {
int v = u | (1 << k);
dfs(v, 2);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d", &a[i]);
in[a[i]] = 1;
}
int ans = 0;
for (int i = 1; i <= m; i++) {
if (!mk[a[i]][1]) {
ans++;
dfs(a[i], 1);
}
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300100;
vector<int> g[maxn];
bool cycle;
int n, m;
string code;
bool visited[maxn];
int dp[maxn][30], state[maxn];
void dfscycle(int node) {
if (state[node] == 0) {
state[node] = 1;
for (int i : g[node]) {
dfscycle(i);
}
state[node] = 2;
} else if (state[node] == 1)
cycle = true;
}
void dfsdag(int node) {
if (visited[node]) return;
visited[node] = true;
for (int i : g[node]) {
if (!visited[i]) {
dfsdag(i);
}
for (int c = 0; c < 26; c++) {
dp[node][c] = max(dp[node][c], dp[i][c]);
}
}
dp[node][int(code[node] - 'a')]++;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
cin >> code;
int x, y;
for (int i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
}
for (int i = 0; i < n; i++) {
if (state[i] == 0) dfscycle(i);
}
if (cycle) {
cout << "-1\n";
return 0;
}
for (int i = 0; i < n; i++) {
if (!visited[i]) dfsdag(i);
}
int result = 0;
for (int i = 0; i < n; i++) {
for (int c = 0; c < 26; c++) {
result = max(result, dp[i][c]);
}
}
cout << result << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, s, r = 0;
cin >> k >> n;
s = k;
while (s < n) {
s *= k;
r++;
}
if (s == n)
cout << "YES" << endl << r;
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int ms = 4e5 + 5, inf = 0x3f3f3f3f;
map<int, int> tipo;
map<int, int> pos;
int inicioIdx[ms], sz[ms];
int seg[2 * ms], lazy[2 * ms];
int ciclo[ms], posicaoNoCiclo[ms];
int n;
int h;
int *t, *d;
void calc(int p, int k) {
if (d[p] == -1)
t[p] = max(t[p << 1], t[p << 1 | 1]);
else
t[p] = d[p];
}
void apply(int p, int value, int k) {
t[p] = value;
if (p < n) d[p] = value;
}
void build(int l, int r) {
int k = 2;
for (l += n, r += n - 1; l > 1; k <<= 1) {
l >>= 1, r >>= 1;
for (int i = r; i >= l; --i) calc(i, k);
}
}
void push(int l, int r) {
int s = h, k = 1 << (h - 1);
for (l += n, r += n - 1; s > 0; --s, k >>= 1)
for (int i = l >> s; i <= r >> s; ++i)
if (d[i] != -1) {
apply(i << 1, d[i], k);
apply(i << 1 | 1, d[i], k);
d[i] = -1;
}
}
void modify(int l, int r, int value) {
if (value == -1) return;
r++;
push(l, l + 1);
push(r - 1, r);
int l0 = l, r0 = r, k = 1;
for (l += n, r += n; l < r; l >>= 1, r >>= 1, k <<= 1) {
if (l & 1) apply(l++, value, k);
if (r & 1) apply(--r, value, k);
}
build(l0, l0 + 1);
build(r0 - 1, r0);
}
int query(int l) {
int r = l + 1;
push(l, l + 1);
push(r - 1, r);
int res = 0;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = max(res, t[l++]);
if (r & 1) res = max(res, t[--r]);
}
return res;
}
void updateGlobal(int i) {
d = lazy + inicioIdx[i];
t = seg + inicioIdx[i];
n = sz[i];
h = sizeof(int) * 8 - __builtin_clz(n);
}
int buscaBinaria(int t, int p) {
int n = sz[t];
updateGlobal(t);
int l = p + 1, r = p + n;
while (r - l > 1) {
int m = (l + r) / 2;
int check = query(m % n);
if (check == p)
r = m;
else
l = m;
}
int check = query(l % n);
if (check == p) {
return l % n;
} else {
return r % n;
}
}
int main() {
cin.tie(0);
cin.sync_with_stdio(false);
int h, m, n, ans = 0;
cin >> h >> m >> n;
memset(lazy, -1, sizeof lazy);
int zzz = 0;
int ciclosAteAgora = 0;
int cnt = 0;
for (int i = 0; i < h; i++) {
int pos = i;
if (!ciclo[pos]) ++ciclosAteAgora;
for (int j = 0; ciclo[pos] == 0; j++) {
ciclo[pos] = ciclosAteAgora;
posicaoNoCiclo[pos] = j;
sz[ciclosAteAgora]++;
cnt++;
pos = (pos + m) % h;
}
}
for (int i = 1; i <= ciclosAteAgora; i++) {
int qnt = sz[i];
inicioIdx[i] = zzz;
updateGlobal(i);
for (int j = 0; j < qnt; j++) modify(j, j, j);
zzz += 2 * qnt;
}
for (int i = 0; i < n; i++) {
string s;
cin >> s;
if (s == "+") {
int hash, id;
cin >> id >> hash;
int t = ciclo[hash], p = posicaoNoCiclo[hash];
updateGlobal(t);
int posicaoInserir = query(p);
pos[id] = posicaoInserir;
tipo[id] = t;
ans += (posicaoInserir + sz[t] - p) % sz[t];
int apos = query((posicaoInserir + 1) % sz[t]);
if (apos == posicaoInserir) {
modify(0, sz[t] - 1, inf);
continue;
}
int inicioUpdate = buscaBinaria(t, posicaoInserir);
if (inicioUpdate > posicaoInserir) {
modify(inicioUpdate, sz[t] - 1, apos);
modify(0, posicaoInserir, apos);
} else {
modify(inicioUpdate, posicaoInserir, apos);
}
} else {
int id;
cin >> id;
int t = tipo[id], p = pos[id];
updateGlobal(t);
int posicaoApos = query(p);
if (posicaoApos == inf) {
modify(0, sz[t] - 1, p);
continue;
}
int inicioUpdate = buscaBinaria(t, posicaoApos);
if (inicioUpdate > p) {
modify(inicioUpdate, sz[t] - 1, p);
modify(0, p, p);
} else {
modify(inicioUpdate, p, p);
}
}
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 7;
int Stack[N], vis[N], flag[N], ans[N], n, f[N], to[N], top = 0, dep[N];
vector<pair<long long, int> > g[N];
vector<int> p[N];
void dfs(int x) {
vis[x] = 1;
Stack[++top] = x;
if (vis[to[x]] == 1) {
for (int i = top; Stack[i] != to[x]; i--) flag[Stack[i]] = true;
flag[Stack[to[x]]] = true;
} else if (!vis[to[x]])
dfs(to[x]);
vis[x] = 2;
}
void dfs(int x, map<int, int> &m, int r) {
dep[x] = r;
for (int v : p[x])
if (!flag[v]) {
map<int, int> mm;
dfs(v, mm, r + 1);
if (mm.size() > m.size()) swap(mm, m);
for (auto u : mm) m[u.first] += u.second;
}
m[dep[x]]++;
if (flag[x]) return;
for (auto v : g[x]) {
if (v.first <= N) {
ans[v.second] = m[v.first + dep[x]];
} else
ans[v.second] = 0;
}
}
int lowbit(int x) { return x & -x; }
void add(int x, int r, int y, int len) {
if (r < len) f[r] += y, r += len;
for (int i = r / len; i * len + r % len <= n * 3; i += lowbit(i)) {
f[i * len + r % len] += y;
}
for (int v : p[x])
if (!flag[v]) add(v, r + 1, y, len);
}
int get(int r, int len) {
int y = f[r % len];
for (int i = r / len; i > 0; i -= lowbit(i)) y += f[i * len + r % len];
return y;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &to[i]);
p[to[i]].push_back(i);
}
int q;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int u;
long long len;
scanf("%lld%d", &len, &u);
g[u].push_back({len, i});
}
for (int i = 1; i <= n; i++)
if (!vis[i]) dfs(i);
for (int i = 1; i <= n; i++)
if (flag[i]) {
map<int, int> m;
dfs(i, m, 1);
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++)
if (!vis[i] && flag[i]) {
int len = 1, base = n;
for (int j = to[i]; j != i; j = to[j], len++)
;
add(i, 0 + base, 1, len);
vis[i] = true;
for (int j = to[i], k = 1; j != i; j = to[j], k++)
add(j, len - k + base, 1, len);
for (auto v : g[i]) {
int tmp;
if (v.first > n)
tmp = (v.first - n) % len + n;
else
tmp = v.first;
ans[v.second] = get(tmp + base, len);
}
for (int j = to[i], k = 1; j != i; j = to[j], k++) {
add(j, len - k + base, -1, len);
add(j, -k + base, 1, len);
vis[j] = true;
for (auto v : g[j]) {
int tmp;
if (v.first > n)
tmp = (v.first - n) % len + n;
else
tmp = v.first;
ans[v.second] = get(tmp - k + base, len);
}
}
add(i, 0 + base, -1, len);
for (int j = to[i], k = 1; j != i; j = to[j], k++)
add(j, -k + base, -1, len);
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void out(T A[], int n) {
cout << "{";
for (int i = 0; i < n; i++) {
cout << A[i];
if (i == n - 1)
cout << "}";
else
cout << ",";
}
cout << endl;
}
template <class T>
void out(T A[], int n, int m) {
for (int i = 0; i < n; ++i) out(A[i], m);
cout << endl;
}
template <class T>
void out(vector<T> A, int n = -1) {
if (n < 0 || n > ((int)A.size())) n = ((int)A.size());
cout << "{";
for (int i = 0; i < n; i++) {
cout << A[i];
if (i == n - 1)
cout << "}";
else
cout << ",";
}
cout << endl;
}
const int MAXN = 100000;
struct team {
string name;
int point;
int diff;
int goals;
} _team;
map<string, team> mp;
int N;
char s[100];
bool comp(const team& a, const team& b) {
if (a.point != b.point) return a.point > b.point;
if (a.diff != b.diff) return a.diff > b.diff;
return a.goals > b.goals;
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%s", s);
_team.point = _team.diff = _team.goals = 0;
_team.name = s;
mp[s] = _team;
}
char buf1[100], buf2[100];
for (int i = 0; i < N * (N - 1) / 2; ++i) {
scanf("%s %s", buf1, buf2);
string b1 = buf1, b2 = buf2;
string s1, s2, ps1, ps2;
int p1, p2;
for (int i = 0; i < b1.length(); ++i)
if (b1[i] == '-') {
s1 = b1.substr(0, i);
s2 = b1.substr(i + 1);
break;
}
for (int i = 0; i < b2.length(); ++i)
if (b2[i] == ':') {
ps1 = b2.substr(0, i);
ps2 = b2.substr(i + 1);
break;
}
sscanf(ps1.c_str(), "%d", &p1);
sscanf(ps2.c_str(), "%d", &p2);
mp[s1].diff += p1 - p2;
mp[s1].goals += p1;
mp[s2].diff += p2 - p1;
mp[s2].goals += p2;
if (p1 > p2)
mp[s1].point += 3;
else if (p1 == p2) {
mp[s1].point++;
mp[s2].point++;
} else
mp[s2].point += 3;
}
vector<team> vt;
for (map<string, team>::iterator it = mp.begin(); it != mp.end(); ++it)
vt.push_back(it->second);
sort(vt.begin(), vt.end(), comp);
vector<string> ans;
for (int i = 0; i < N / 2; ++i) ans.push_back(vt[i].name);
sort(ans.begin(), ans.end());
for (int i = 0; i < ans.size(); ++i) printf("%s\n", ans[i].c_str());
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 17, oo = (int)1e9;
int N, M, K;
int s, t;
bool vol[MAXN];
vector<int> G[MAXN];
int dist[MAXN];
bool ok(int maxDist) {
if (maxDist == 0) return (s == t);
set<pair<int, int> > S;
for (int i = 0; i < (int)(N); ++i) dist[i] = oo;
dist[s] = 0;
S.insert(pair<int, int>(dist[s], s));
while (!S.empty()) {
pair<int, int> top = *S.begin();
S.erase(S.begin());
int u = top.second;
for (int i = 0; i < (int)(((int)(G[u]).size())); ++i) {
int v = G[u][i];
int nw = dist[u] + 1;
if (nw > maxDist || nw >= dist[v]) continue;
if (v == t) return true;
if (vol[v]) nw = 0;
if (dist[v] != oo) S.erase(pair<int, int>(dist[v], v));
dist[v] = nw;
S.insert(pair<int, int>(dist[v], v));
}
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> N >> M >> K;
for (int i = 0; i < (int)(K); ++i) {
int x;
cin >> x;
--x;
vol[x] = true;
}
for (int i = 0; i < (int)(M); ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 0; i < (int)(N); ++i)
random_shuffle((G[i]).begin(), (G[i]).end());
cin >> s >> t;
--s;
--t;
int lo = 0, hi = N - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (ok(mid))
hi = mid - 1;
else
lo = mid + 1;
}
if (lo >= N)
cout << -1 << endl;
else
cout << lo << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long a[12][12];
long double dp[12][12];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
for (long long i = 1; i <= 10; i++)
for (long long j = 1; j <= 10; j++) cin >> a[i][j];
for (long long i = 2; i <= 10; i++) {
long long xx = (6 - i + 1);
xx = max(xx, 0LL);
dp[1][i] = 0.0;
for (long long j = 1; j <= 6; j++) {
if (i - j <= 0) break;
long double p = 6.0 / ((6.0 - 1.0 * xx) * (6.0 - 1.0 * xx));
dp[1][i] += p + (1.0 / (6.0 - 1.0 * xx)) * dp[1][i - j];
}
}
for (long long i = 2; i <= 10; i++) {
if (i % 2 == 1) {
long double p = (1.0 / 6.0);
for (long long j = 1; j <= 10; j++) {
for (long long x = 1; x <= 6; x++) {
long long ii = i;
long long jj = j;
jj -= x;
if (jj < 1) {
ii--;
jj = (x - (j - 1));
}
dp[i][j] += p * (1.0 + min(dp[ii][jj], dp[ii - a[ii][jj]][jj]));
}
}
} else {
long double p = (1.0 / 6.0);
for (long long j = 10; j >= 1; j--) {
for (long long x = 1; x <= 6; x++) {
long long ii = i;
long long jj = j;
jj += x;
if (jj > 10) {
ii--;
jj = 10 - (x - (10 - j)) + 1;
}
dp[i][j] += p * (1.0 + min(dp[ii][jj], dp[ii - a[ii][jj]][jj]));
}
}
}
}
long double bruh = 0.0;
cout << setprecision(12) << fixed << dp[10][1] + bruh << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n > 36) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < (n / 2); i++) {
cout << 8;
}
if (n % 2 == 1) {
cout << 6;
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class disjointsets {
int *r, n;
public:
int *parent;
disjointsets(int n) {
parent = new int[n];
r = new int[n];
this->n = n;
makeset();
}
void makeset() {
for (int i = 0; i < n; i++) {
parent[i] = i;
r[i] = 0;
}
}
int findset(int x) {
if (parent[x] == x)
return x;
else {
parent[x] = findset(parent[x]);
return parent[x];
}
}
void unionbyrank(int x, int y) {
int xrep = findset(x);
int yrep = findset(y);
if (xrep == yrep) return;
int xrank = r[x];
int yrank = r[y];
if (xrank < yrank)
parent[xrep] = yrep;
else if (yrank < xrank)
parent[yrep] = xrep;
else {
parent[yrep] = xrep;
r[xrep]++;
}
return;
}
};
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
vector<int> p;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
p.push_back(x - 1);
}
int *time = (int *)calloc(n, sizeof(int));
int *visited = (int *)calloc(n, sizeof(int));
disjointsets obj(n);
for (int i = 0; i < n; i++) {
if (!visited[i]) {
visited[i] = 1;
if (i == p[i])
time[i]++;
else {
obj.unionbyrank(i, p[i]);
int r = obj.findset(i);
time[r]++;
int j = p[i];
while (j != r) {
visited[j] = 1;
obj.unionbyrank(j, p[j]);
time[obj.findset(j)]++;
j = p[j];
}
}
}
}
for (int i = 0; i < n; i++) cout << time[obj.findset(i)] << " ";
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000;
const int MAXM = 200;
const int B = 31;
char mat[MAXM + 1][MAXN + 1];
string str;
unsigned long long hsh2[MAXM + 1][MAXN + 1];
unsigned long long hsh1[MAXN + 1];
map<unsigned long long, int> mp;
int main() {
int i, j, n, m;
ios::sync_with_stdio(false);
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> str;
unsigned long long val = 0;
for (auto it : str) {
val = val * B + it - 'a' + 1;
}
hsh1[i] = val;
}
for (i = 1; i <= m; i++) {
cin >> (mat[i] + 1);
}
unsigned long long pw = 1;
for (i = 1; i < m; i++) {
pw *= B;
}
for (i = 1; i <= m; i++) {
unsigned long long val = 0;
for (j = 1; j <= n; j++) {
val = val * B + mat[i][j] - 'a' + 1;
if (j >= m) {
hsh2[i][j] = val;
val -= pw * (mat[i][j - m + 1] - 'a' + 1);
}
}
}
for (i = 1; i + m <= n + 1; i++) {
unsigned long long val = 0;
for (j = i; j < i + m; j++) {
val = val * pw + hsh1[j];
}
mp[val] = i;
}
for (i = 1; i + m <= n + 1; i++) {
unsigned long long val = 0;
for (j = 1; j <= m; j++) {
val = val * pw + hsh2[j][i + m - 1];
}
if (mp[val] > 0) {
cout << mp[val] << " " << i;
return 0;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long pwr(long long a, long long b) {
if (b == 0) {
return 1;
}
long long c = pwr(a, (b >> 1));
c *= c;
if (b & 1) {
c *= a;
}
return c;
}
long long gcd(long long a, long long b) {
while (b) {
if (a < b) {
swap(a, b);
}
long long c = b;
b = a % b;
a = c;
}
return a;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, l, r;
cin >> n >> l >> r;
if (n > 30) {
cout << 0 << "\n";
return 0;
}
if (n == 1) {
cout << r - l + 1 << "\n";
return 0;
}
if (n == 2) {
cout << (r - l + 1) * (r - l) << "\n";
return 0;
}
long long maxi = 0;
vector<long long> v;
while (pwr(maxi + 1, n - 1) <= r) {
maxi++;
v.push_back(pwr(maxi, n - 1));
}
long long ans = 0;
for (int x = 0; x < v.size(); x++) {
for (int y = x + 1; y < v.size(); y++) {
if (gcd(v[x], v[y]) == 1) {
ans += max(0ll, r / v[y] - (l - 1) / v[x]);
}
}
}
cout << ans * 2 << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
set<int> s[26];
char a[100005];
int main() {
scanf("%s", a);
int n = strlen(a);
for (int i = 0; i < n; i++) {
s[a[i] - 'a'].insert(i);
}
int T;
scanf("%d", &T);
while (T--) {
char c;
int op, L, R;
scanf("%d%d ", &op, &L);
L -= 1;
if (op == 1) {
scanf("%c", &c);
s[a[L] - 'a'].erase(L);
a[L] = c;
s[a[L] - 'a'].insert(L);
} else {
scanf("%d", &R);
int ans = 0;
for (int i = 0; i < 26; i++) {
auto it = s[i].lower_bound(L);
if (it != s[i].end() && *it < R) ans++;
}
printf("%d\n", ans);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
const long long MX = 4e4 + 5;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const long double PI = acos((long double)-1);
const long long xd[4] = {1, 0, -1, 0}, yd[4] = {0, 1, 0, -1};
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
constexpr long long pct(long long x) { return __builtin_popcount(x); }
constexpr long long bits(long long x) { return 31 - __builtin_clz(x); }
template <class T>
T cdiv(T a, T b) {
return a / b + !(a < 0 || a % b == 0);
}
long long fstTrue(function<bool(long long)> first, long long lo, long long hi) {
hi++;
assert(lo <= hi);
while (lo < hi) {
long long mid = (lo + hi) / 2;
first(mid) ? hi = mid : lo = mid + 1;
}
return lo;
}
template <class T>
void remDup(vector<T>& v) {
sort(begin(v), end(v));
v.erase(unique(begin(v), end(v)), end(v));
}
void DBG() { cerr << "]" << endl; }
template <class H, class... T>
void DBG(H h, T... t) {
cerr << h;
if (sizeof...(t)) cerr << ", ";
DBG(t...);
}
void setIn(string S) { freopen(S.c_str(), "r", stdin); }
void setOut(string S) { freopen(S.c_str(), "w", stdout); }
void setIO(string S = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
if ((long long)(S).size()) {
setIn(S + ".in"), setOut(S + ".out");
}
}
template <long long SZ>
struct Dinic {
long long N, second, t;
typedef long long F;
struct Edge {
long long to, rev;
F flo, cap;
};
vector<Edge> adj[SZ];
void reset() {
for (long long i = (0); i < (N); ++i)
for (auto& e : adj[i]) e.flo = 0;
}
void clean() {
for (long long i = (0); i < (N); ++i) adj[i].clear();
}
void ae(long long u, long long v, F cap, F rcap = 0) {
assert(min(cap, rcap) >= 0);
Edge a{v, (long long)(adj[v]).size(), 0, cap},
b{u, (long long)(adj[u]).size(), 0, rcap};
adj[u].push_back(a), adj[v].push_back(b);
}
long long lev[SZ];
typename vector<Edge>::iterator cur[SZ];
bool bfs() {
for (long long i = (0); i < (N); ++i) lev[i] = -1, cur[i] = begin(adj[i]);
queue<long long> q({second});
lev[second] = 0;
while ((long long)(q).size()) {
long long u = q.front();
q.pop();
for (auto& e : adj[u])
if (lev[e.to] < 0 && e.flo < e.cap)
q.push(e.to), lev[e.to] = lev[u] + 1;
}
return lev[t] >= 0;
}
F dfs(long long v, F flo) {
if (v == t) return flo;
for (; cur[v] != end(adj[v]); cur[v]++) {
Edge& e = *cur[v];
if (lev[e.to] != lev[v] + 1 || e.flo == e.cap) continue;
F df = dfs(e.to, min(flo, e.cap - e.flo));
if (df) {
e.flo += df;
adj[e.to][e.rev].flo -= df;
return df;
}
}
return 0;
}
F maxFlow(long long _N, long long _s, long long _t) {
N = _N, second = _s, t = _t;
assert(second != t);
F tot = 0;
while (bfs())
while (F df = dfs(second, numeric_limits<F>::max())) tot += df;
return tot;
}
};
vector<pair<long long, pair<long long, long long>>> ed;
Dinic<MX> BP;
int32_t main() {
setIO();
long long N, M;
cin >> N >> M;
long long nodes = N * 2 + 3;
for (long long i = (1); i < (N + 1); ++i)
BP.ae(0, i, 1), BP.ae(i + N, nodes - 1, 1);
map<long long, long long> comp;
for (long long i = (0); i < (M); ++i) {
long long u, v, d;
cin >> u >> v >> d;
v += N;
comp[d];
ed.push_back({d, {u, v}});
BP.ae(u, v, 1);
}
sort(begin(ed), end(ed));
if (BP.maxFlow(nodes, 0, nodes - 1) != N) {
cout << -1 << "\n";
return 0;
}
auto can = [&](long long k) {
Dinic<MX> B;
for (long long i = (1); i < (N + 1); ++i)
B.ae(0, i, 1), B.ae(i + N, nodes - 1, 1);
for (long long i = (0); i < (k); ++i) {
B.ae(ed[i].second.first, ed[i].second.second, 1);
}
long long flo = B.maxFlow(nodes, 0, nodes - 1);
return flo == N;
};
long long lo = 0, hi = M - 1, res = -1;
while (lo <= hi) {
long long mid = (lo + hi) / 2;
if (can(mid)) {
res = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
cout << ed[res - 1].first << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[1002];
char out[1002];
cin >> s;
int l = 0;
for (int i = 0; s[i] != 0; i++) {
l++;
}
out[l] = 0;
if (l <= 3) {
cout << "YES\n" << s;
return 0;
}
bool* P = new bool[l + 1];
for (int i = 0; i <= l; i++) P[i] = true;
for (int i = 2; i <= l; i++)
if (P[i])
for (int j = 2; j * i <= l; j++) P[i * j] = false;
int W[1002];
W[0] = 1;
int C = 1;
for (int i = l; 2 * i > l; i--)
if (P[i]) {
W[C] = i;
C++;
}
int q;
for (char c = 'a'; c <= 'z'; c++) {
q = 0;
for (int i = 0; i <= l - 1; i++)
if (s[i] == c) q++;
if (q >= l - C) {
for (int i = 0; i < l; i++) out[i] = c;
int e = 0;
for (int i = 0; i < l; i++)
if (s[i] != c) {
out[W[e] - 1] = s[i];
e++;
}
cout << "YES\n" << out;
return 0;
}
}
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
long long b[32] = {0};
bool f(int x) {
if (x <= 0) {
return false;
}
while (x) {
if (x % 10 != 4 && x % 10 != 7) {
return false;
}
x /= 10;
}
return true;
}
int get(int x) {
int w = 0, s = 0, t = 0, i = 0, xx = 0, ans = 0;
long long now = 0;
xx = x;
while (xx) {
t++;
xx /= 10;
}
for (w = 1; w <= t; w++) {
for (s = 0; s < (1 << w); s++) {
now = 0;
for (i = 0; i < w; i++) {
if (s & (1 << i)) {
now = now * 10 + 4;
} else {
now = now * 10 + 7;
}
}
if (now <= x) {
ans++;
}
}
}
return ans;
}
void tt(int m, int k, int a[]) {
int i = 0, j = 0;
bool u[32] = {0};
for (i = 0; i < m; i++) {
for (j = 0; j < m; j++) {
if (!u[j]) {
if (k > b[m - i - 1]) {
k -= b[m - i - 1];
} else {
a[i] = j;
u[j] = true;
break;
}
}
}
}
}
void init() {
b[0] = 1;
int i = 0;
for (i = 1; i <= 20; i++) {
b[i] = b[i - 1] * i;
}
}
int main() {
int n = 0, k = 0, m = 0, i = 0, ans = 0, a[32];
init();
while (scanf("%d%d", &n, &k) == 2) {
for (m = 1;; m++) {
if (b[m] >= k) {
break;
}
}
if (n < m) {
printf("-1\n");
continue;
}
ans = get(n - m);
tt(m, k, a);
for (i = 0; i < m; i++) {
if (f(a[i] + n - m + 1) && f(i + n - m + 1)) {
ans++;
}
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> AdjList[1005];
int T, N, Ka, Kb, X, Y, v1, v2, v3, ans;
vector<int> A, B;
int marked1[1005], marked2[1005], track[1005];
void res() {
A.clear();
B.clear();
for (int i = 1; i <= 1000; ++i) {
AdjList[i].clear();
marked1[i] = marked2[i] = 0;
}
}
void dfs(int x, int p, int v) {
track[x] = v;
for (auto it : AdjList[x]) {
if (it == p) continue;
if (marked1[x])
dfs(it, x, x);
else
dfs(it, x, v);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> T;
for (int t = 1; t <= T; ++t) {
cin >> N;
res();
for (int i = 1; i < N; ++i) {
cin >> X >> Y;
AdjList[X].push_back(Y);
AdjList[Y].push_back(X);
}
cin >> Ka;
for (int i = 1; i <= Ka; ++i) {
cin >> X;
A.push_back(X);
marked1[X] = 1;
}
cin >> Kb;
for (int i = 1; i <= Kb; ++i) {
cin >> X;
B.push_back(X);
marked2[X] = 1;
}
dfs(A[0], -1, A[0]);
cout << "B " << B[0] << '\n' << flush;
cin >> v1;
if (marked1[v1]) {
cout << "C " << v1 << '\n' << flush;
continue;
}
v2 = track[v1];
cout << "A " << v2 << '\n' << flush;
cin >> v3;
if (!marked2[v3]) {
cout << "C " << -1 << '\n' << flush;
} else {
cout << "C " << v2 << '\n' << flush;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int N = 1e6 + 5;
int n;
int a[N];
int fi[N];
bool ans;
int w[N];
int lst[N], nxt[N];
int pre[N], suf[N];
int pos[N], k;
bool used[N];
int sta[N], top;
int Nxt[N], hd[N];
void getans(int l, int r) {
if (l == r) return;
if (a[pos[l]]) {
int v = pre[l];
int lst = l;
for (; hd[v] && hd[v] <= r; hd[v] = Nxt[hd[v]]) {
if (hd[v] > l && !a[pos[hd[v]]]) {
a[pos[hd[v]]] = a[pos[l]];
getans(lst + 1, hd[v] - 1);
lst = hd[v];
}
}
return;
}
if (a[pos[r]]) {
int lst = 0;
int v = pre[l];
for (; hd[v] && hd[v] <= r; hd[v] = Nxt[hd[v]]) {
if (hd[v] >= l && !a[pos[hd[v]]]) {
a[pos[hd[v]]] = a[pos[r]];
if (lst) getans(lst + 1, hd[v] - 1);
lst = hd[v];
}
}
getans(lst + 1, r - 1);
return;
}
int v = pre[r];
for (; hd[v] && hd[v] < l; hd[v] = Nxt[hd[v]])
;
getans(l, hd[v]);
getans(hd[v], r);
}
bool solve(int l, int r, int tp) {
if (l == r) {
if (!a[l]) a[l] = sta[top--];
return 1;
}
for (int x = l; x <= r;) {
if (nxt[x]) {
if (!solve(x + 1, nxt[x] - 1, a[x])) return 0;
x = nxt[x];
} else
x++;
}
k = 0;
for (int x = l; x <= r;) {
if (nxt[x])
x = nxt[x];
else
pos[++k] = x++;
}
int known = 0;
for (int i = 1; i <= k; i++)
if (a[pos[i]]) known++;
if (k % 2 == 0 || known > k / 2 + 1) return 0;
known = k / 2 + 1 - known;
if (!a[pos[1]]) {
for (int i = k; i >= 1; i--)
if (!a[pos[i]] && known) {
known--;
a[pos[i]] = sta[top--];
}
} else {
for (int i = 1; i <= k; i++)
if (!a[pos[i]] && known) {
known--;
a[pos[i]] = sta[top--];
}
}
pre[0] = n;
for (int i = 1; i <= k; i++)
if (a[pos[i]])
pre[i] = pre[i - 1] + 1;
else
pre[i] = pre[i - 1] - 1;
int t = k / 2 + 1;
for (int i = n - t; i <= n + t; i++) hd[i] = 0;
for (int i = k; i >= 1; i--) {
Nxt[i] = hd[pre[i]];
hd[pre[i]] = i;
}
if (k == 1) return 1;
if (tp) {
int lst = 0;
for (int i = 1; i <= k; i++)
if (!a[pos[i]] && pre[i] == pre[0]) {
a[pos[i]] = tp;
getans(lst + 1, i - 1);
lst = i;
}
getans(lst + 1, k);
} else {
if (a[pos[1]] && a[pos[k]]) return 0;
getans(1, k);
}
return 1;
}
int main() {
n = get();
for (int i = 1; i <= n * 2 - 1; i++) a[i] = get();
ans = 1;
for (int i = 1; i <= n * 2 - 1; i++)
if (a[i]) {
used[a[i]] = 1;
if (!fi[a[i]])
fi[a[i]] = i;
else {
if (fi[a[i]] % 2 != i % 2) ans = 0;
}
}
for (int i = 1; i <= n; i++)
if (!used[i]) sta[++top] = i;
if (!ans) return printf("no\n"), 0;
for (int i = 1; i <= n * 2 - 1; i++)
if (a[i]) {
lst[i] = w[a[i]];
w[a[i]] = i;
}
for (int i = 1; i <= n; i++) w[i] = 0;
for (int i = n * 2 - 1; i >= 1; i--)
if (a[i]) {
nxt[i] = w[a[i]];
w[a[i]] = i;
}
if (ans) {
for (int i = 1; i <= n; i++)
if (lst[i]) {
for (int x = i - 1; x > lst[i];) {
if (nxt[x] > i) {
ans = 0;
break;
}
if (lst[x])
x = lst[x];
else
x--;
}
if (!ans) break;
}
}
if (!ans) return printf("no\n"), 0;
if (n > 1 && a[1] && a[n * 2 - 1] && a[1] != a[n * 2 - 1])
return printf("no\n"), 0;
for (int i = 1; i <= n * 2 - 1; i++) pre[i] = suf[i] = 0;
ans = solve(1, n * 2 - 1, 0);
if (!ans)
printf("no\n");
else {
printf("yes\n");
for (int i = 1; i <= n * 2 - 1; i++)
printf("%d%c", a[i], i == n * 2 - 1 ? '\n' : ' ');
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3050;
const long long Mod = 152076289;
int p[MAXN];
int cnt;
int temp[MAXN];
void Merge(int low, int mid, int high) {
int i = low;
int j = mid + 1;
int x = low;
while (i <= mid && j <= high) {
if (p[i] > p[j]) {
cnt += mid - i + 1;
temp[x++] = p[j++];
} else {
temp[x++] = p[i++];
}
}
while (i <= mid) temp[x++] = p[i++];
while (j <= high) temp[x++] = p[j++];
for (int k = low; k <= high; k++) p[k] = temp[k];
}
void mergesort(int low, int high) {
if (low < high) {
int mid = (low + high) >> 1;
mergesort(low, mid);
mergesort(mid + 1, high);
Merge(low, mid, high);
}
}
int main(void) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", p + i);
}
mergesort(0, n - 1);
double ans;
if (cnt & 1)
ans = cnt * 2 - 1;
else
ans = cnt * 2;
printf("%.6f\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> expand(long long n, long long k) {
vector<long long> res(1 + log2(n));
vector<long long> result;
long long i = 0;
while (n) res[i] = (n & 1) ? pow(2, i) : 0, i++, n >>= 1;
for (long long j : res)
if (j > 0) result.push_back(j);
i = 0;
while (result.size() != k) {
if (result[i] > 1)
result[i] /= 2, result.push_back(result[i]);
else
i++;
}
return result;
}
int32_t main() {
long long n, k;
cin >> n >> k;
long long m = n, count = 0;
while (m) {
count += m & 1;
m >>= 1;
}
if (count > k || k > n) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
vector<long long> v = expand(n, k);
for (long long i = 0; i < v.size(); i++) cout << v[i] << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bitset<5005> ans;
int n;
vector<int> E[5005];
int sz[5005];
inline void dfs(int u, int fa) {
if (sz[u]) return;
sz[u] = 1;
bitset<5005> tmp;
tmp = 1;
for (int i = 0; i < E[u].size(); ++i) {
int v = E[u][i];
dfs(v, u);
if (v != fa) sz[u] += sz[v], tmp |= tmp << sz[v];
}
tmp |= tmp << (n - sz[u]);
ans |= tmp;
return;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int ref = 0; ref < n - 1; ++ref) {
int x, y;
cin >> x >> y;
E[x].push_back(y);
E[y].push_back(x);
}
dfs(1, 0);
int cnt = 0;
for (int i = 1; i <= n - 2; ++i) {
if (ans[i]) ++cnt;
}
cout << cnt << endl;
for (int i = 1; i <= n - 2; ++i) {
if (ans[i]) cout << i << " " << n - i - 1 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n & (n - 1))
cout << "NO" << endl;
else
cout << "YES" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : -x;
}
const int N = 1e5 + 4;
int tot = 1, ch[N * 28][2], t[N * 28];
inline void insert(int x, int fl) {
int p = 1, c;
t[p] += fl;
for (int i = 26; i >= 0; i--) {
c = (x >> i) & 1;
if (!ch[p][c]) ch[p][c] = ++tot;
p = ch[p][c];
t[p] += fl;
}
}
inline int query(int v, int k) {
int p = 1, cv, ck, ret = 0;
for (int i = 26; i >= 0; i--) {
cv = (v >> i) & 1;
ck = (k >> i) & 1;
if (ck) ret += t[ch[p][cv]];
p = ch[p][cv ^ ck];
}
return ret;
}
int main() {
int Q = read(), op, x;
while (Q--) {
op = read();
x = read();
if (op == 1)
insert(x, 1);
else if (op == 2)
insert(x, -1);
else
cout << query(x, read()) << "\n";
}
return (0 - 0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, i;
cin >> n >> t;
if (t == 10 && n == 1)
cout << -1;
else if (t == 10 && n != 1)
for (i = 1; i <= n; i++) {
if (i == n)
cout << 0;
else
cout << 1;
}
else {
for (i = 1; i <= n; i++) cout << t;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') {
f = -1;
}
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int Hash[26];
int pos[100005];
int main() {
ios::sync_with_stdio(false);
string a, s;
cin >> a >> s;
if (a == s)
cout << -1 << endl;
else {
cout << max(a.length(), s.length()) << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ii = pair<int, int>;
using i64 = long long int;
using ii64 = pair<long long int, long long int>;
vector<i64> costs;
i64 solve(i64 n, i64 l) {
i64 maxIdx = 0;
i64 res = 0;
for (int i = 0; i < n; i++) {
if (costs[maxIdx] * (1ll << i) > costs[i] * (1ll << maxIdx)) maxIdx = i;
}
i64 k = ((l + (1ll << maxIdx) - 1) / (1ll << maxIdx));
res = k * costs[maxIdx];
if (maxIdx == 0) return res;
return min(res, (k - 1) * costs[maxIdx] +
solve(maxIdx, l - (k - 1) * (1ll << maxIdx)));
}
int main() {
i64 n, l;
scanf("%lld %lld", &n, &l);
costs.resize(n);
for (int i = 0; i < n; i++) scanf("%lld", &costs[i]);
printf("%lld", solve(n, l));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mp[(int)1e6 + 6];
int main() {
long long a, b, c;
cin >> a >> b >> c;
long long ans = 0, mod = 1073741824;
for (int i = 1; i <= a; i++) {
for (int j = 1; j <= b; j++) {
for (int k = 1; k <= c; k++) {
long long temp = i * j * k;
if (!mp[temp]) {
long long cnt = 0;
for (int l = 1; l * l <= temp; l++) {
if (temp % l == 0) {
cnt++;
if (temp / l != l) cnt++;
}
}
mp[temp] = cnt;
}
ans += (mp[temp]) % mod;
}
}
}
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > e[200005];
bitset<200005> s[10][10];
int D[200005];
int pd[10][10][10][10];
int ans = 0, p[10], k;
inline void dfs(int x) {
if (x == k + 1) {
++ans;
return;
}
for (int i = 1; i <= x; i++) {
int flag = 1;
if (s[x][i][200001]) continue;
for (int j = 1; j < x; j++) {
if (!pd[x][i][j][p[j]]) {
flag = 0;
break;
}
}
if (flag) p[x] = i, dfs(x + 1);
}
}
int main(int argc, char** argv) {
int n, m;
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
int u, v, w;
cin >> u >> v >> w;
e[u].push_back({w, v});
++D[u];
}
for (int i = 1; i <= n; i++) {
sort(e[i].begin(), e[i].end());
for (int j = 0; j < e[i].size(); j++) {
if (s[D[i]][j + 1][e[i][j].second] && !s[D[i]][j + 1][200001])
s[D[i]][j + 1][200001] = 1;
s[D[i]][j + 1][e[i][j].second] = 1;
}
}
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= i; j++) {
for (int x = 1; x < i; x++) {
for (int y = 1; y <= x; y++) {
if ((s[i][j] & s[x][y]).none()) {
pd[i][j][x][y] = 1;
}
}
}
}
}
dfs(1);
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string s;
int n, m, mm, ans;
int main() {
cin >> s;
n = s.size();
for (int i = 0; i < n; i++) {
if (s[i] == '(') m = 1;
if (s[i] == ')') continue;
if (s[i] == '?') m = 1;
mm = 0;
for (int j = i + 1; j < n; j++) {
if (s[j] == '(') m++;
if (s[j] == ')') m--;
if (s[j] == '?') {
m--;
mm++;
}
if (m < 0)
if (mm > 0) {
m += 2;
mm--;
}
if (m == 0) ans++;
if (m < 0 && mm == 0) break;
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void myfunction(vector<int> &v1, vector<int> &v2, vector<pair<int, int> > &diff,
int &addonn, long long int &sum) {
int index = (diff.end() - addonn)->second;
v1[index] = v2[index];
sum = sum - (diff.end() - addonn)->first;
addonn++;
return;
}
int main() {
int size, limit;
cin >> size >> limit;
vector<int> v1(size);
vector<int> v2(size);
vector<pair<int, int> > diff;
for (int i = 0; i < size; i++) {
cin >> v1[i] >> v2[i];
diff.push_back(make_pair(v1[i] - v2[i], i));
}
if (accumulate(v2.begin(), v2.end(), (long long)0) > limit) {
cout << "-1";
return 0;
}
sort(diff.begin(), diff.end());
int turns = 0;
int addonn = 1;
long long int sum = accumulate(v1.begin(), v1.end(), (long long)0);
while (sum > limit && turns < size) {
myfunction(v1, v2, diff, addonn, sum);
turns++;
}
cout << turns;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int const N = 2e5 + 5;
long long a[N];
int main() {
int t;
cin >> t;
while (t--) {
long long h;
int n;
cin >> h >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int ans = 0;
a[n] = 0;
for (int i = 1; i < n; i++) {
if (h <= 2) break;
if (h - a[i] == 1) {
if (h - a[i + 1] == 2) {
h = a[i + 1];
} else {
ans++;
h = a[i + 1] + 1;
}
} else if (h - a[i] > 1) {
h = a[i] + 1;
i--;
}
}
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<set<string> > N, F;
vector<pair<string, string> > ans;
set<string> p;
for (int i = 0; i < 26; ++i) {
N.push_back(p);
F.push_back(p);
}
int n, k, c;
cin >> n;
c = (int)'A';
string s;
for (int i = 0; i < n; ++i) {
cin >> s;
k = (int)s[0];
N[k - c].insert(s);
}
for (int i = 0; i < n; ++i) {
cin >> s;
k = (int)s[0];
F[k - c].insert(s);
}
queue<string> qN, qF;
set<string>::iterator el, el1;
for (int i = 0; i < 26; ++i) {
if (N[i].size() <= F[i].size()) {
while (N[i].size() < F[i].size() && !qN.empty()) {
el = F[i].begin();
ans.push_back(make_pair(qN.front(), *el));
F[i].erase(el);
qN.pop();
}
while (N[i].size()) {
el = F[i].begin();
el1 = N[i].begin();
ans.push_back(make_pair(*el1, *el));
F[i].erase(el);
N[i].erase(el1);
}
while (F[i].size()) {
el = F[i].begin();
qF.push(*el);
F[i].erase(el);
}
} else {
while (F[i].size() < N[i].size() && !qF.empty()) {
el = N[i].begin();
ans.push_back(make_pair(*el, qF.front()));
N[i].erase(el);
qF.pop();
}
while (F[i].size()) {
el = F[i].begin();
el1 = N[i].begin();
ans.push_back(make_pair(*el1, *el));
F[i].erase(el);
N[i].erase(el1);
}
while (N[i].size()) {
el = N[i].begin();
qN.push(*el);
N[i].erase(el);
}
}
}
sort(ans.begin(), ans.end());
int i;
for (i = 0; i < ans.size() - 1; ++i)
cout << ans[i].first << " " << ans[i].second << ", ";
cout << ans[i].first << " " << ans[i].second;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = 5;
const int MXM = 20;
const int MXA = 11;
int n, m, mask_11 = 0, pw[MXN + 2];
int rw[MXN + 2], cl[MXM + 2];
bool dp[MXM + 2][1 << MXN][MXA * MXA * MXA * MXA * MXA * 2];
vector<int> li[MXM + 2];
char ans[MXN + 2][MXM + 2];
bool f(int id, int msk2, int msk11) {
if (id == m && msk11 == mask_11) return 1;
if (dp[id][msk2][msk11]) return 0;
dp[id][msk2][msk11] = 1;
for (int nx2 : li[id]) {
int nx11 = msk11;
for (int i = 0; i < n; i++)
if ((nx2 >> i & 1) && !(msk2 >> i & 1)) nx11 += pw[n - i - 1];
if (f(id + 1, nx2, nx11)) {
for (int i = 0; i < n; i++)
if (nx2 >> i & 1)
ans[i][id] = '*';
else
ans[i][id] = '.';
return 1;
}
}
return 0;
}
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> rw[i];
for (int j = 0; j < m; j++) cin >> cl[j];
pw[0] = 1;
for (int i = 0; i < n; i++) {
pw[i + 1] = pw[i] * MXA;
mask_11 = MXA * mask_11 + rw[i];
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < (1 << n); j++) {
j <<= 1;
int cnt = 0;
for (int k = 0; k < n; k++)
if ((j >> k) % 4 == 2) cnt++;
j >>= 1;
if (cnt == cl[i]) li[i].push_back(j);
}
}
f(0, 0, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << ans[i][j];
cout << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int b[20010];
char s[20010];
struct edge {
int to, capacity, cost, rev;
edge() {}
edge(int to, int _capacity, int _cost, int _rev)
: to(to), capacity(_capacity), cost(_cost), rev(_rev) {}
};
const int inf = 0x3f3f3f3f;
struct Min_Cost_Max_Flow {
int V, H[20010 + 5], dis[20010 + 5], PreV[20010 + 5], PreE[20010 + 5];
vector<edge> G[20010 + 5];
void Init(int n) {
V = n;
for (int i = 0; i <= V; ++i) G[i].clear();
}
void add_edge(int from, int to, int cap, int cost) {
G[from].push_back(edge(to, cap, cost, G[to].size()));
G[to].push_back(edge(from, 0, -cost, G[from].size() - 1));
}
int minCost(int s, int t, int f) {
int flow = 0;
int res = 0;
fill(H, H + 1 + V, 0);
while (f) {
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
q;
fill(dis, dis + 1 + V, inf);
dis[s] = 0;
q.push(pair<int, int>(0, s));
while (!q.empty()) {
pair<int, int> now = q.top();
q.pop();
int v = now.second;
if (dis[v] < now.first) continue;
for (int i = 0; i < G[v].size(); ++i) {
edge& e = G[v][i];
if (e.capacity > 0 && dis[e.to] > dis[v] + e.cost + H[v] - H[e.to]) {
dis[e.to] = dis[v] + e.cost + H[v] - H[e.to];
PreV[e.to] = v;
PreE[e.to] = i;
q.push(pair<int, int>(dis[e.to], e.to));
}
}
}
if (dis[t] == inf) break;
for (int i = 0; i <= V; ++i) H[i] += dis[i];
int d = f;
for (int v = t; v != s; v = PreV[v])
d = min(d, G[PreV[v]][PreE[v]].capacity);
f -= d;
flow += d;
res += d * H[t];
for (int v = t; v != s; v = PreV[v]) {
edge& e = G[PreV[v]][PreE[v]];
e.capacity -= d;
G[v][e.rev].capacity += d;
}
}
return res;
}
} mcmf;
int cnt[20010];
int main() {
int n;
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) cnt[s[i] - 'a' + 1]++;
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
int sr = 0, tar = 26 + n * 13 + n + 1;
mcmf.Init(tar + 10);
for (int i = 1; i <= 26; i++) mcmf.add_edge(sr, i, cnt[i], 0);
int m = n * 13 + 26;
for (int i = 1; i <= n / 2; i++) {
int t = 26 * i;
for (int j = 1; j <= 26; j++) {
mcmf.add_edge(j, t + j, 1, 0);
mcmf.add_edge(t + j, m + i, 1, -b[i] * (s[i - 1] - 'a' + 1 == j));
mcmf.add_edge(t + j, m + n + 1 - i, 1,
-b[n + 1 - i] * (s[n - i] - 'a' + 1 == j));
}
}
for (int i = m + 1; i <= m + n; i++) mcmf.add_edge(i, tar, 1, 0);
int ans = -mcmf.minCost(sr, tar, n);
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 5;
const long long linf = 1e18 + 5;
const int N = 300 + 5;
int n, h[N];
string s[N];
vector<int> v[N], finished;
int f(int x) {
h[x] = 1;
for (__typeof(v[x].begin()) it = v[x].begin(); it != v[x].end(); it++) {
if (h[*it] == 1) {
cout << "Impossible" << '\n';
exit(0);
}
if (h[*it] != 2) f(*it);
}
finished.push_back(x);
h[x] = 2;
}
int main() {
ios ::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> s[i];
for (int i = 1; i <= n - 1; i++) {
int st = 0;
while (st < s[i].size() and st < s[i + 1].size() and
s[i][st] == s[i + 1][st])
st++;
if (st == s[i].size() or st == s[i + 1].size()) {
if (s[i].size() > s[i + 1].size()) return cout << "Impossible" << '\n', 0;
continue;
}
v[s[i][st]].push_back(s[i + 1][st]);
}
for (int i = 'a'; i <= 'z'; i++)
if (!h[i]) f(i);
reverse(finished.begin(), finished.end());
for (__typeof(finished.begin()) it = finished.begin(); it != finished.end();
it++)
cout << (char)*it;
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, w, one = 0, two = 0;
scanf("%d", &n);
while (n--) {
scanf("%d", &w);
(w == 100 ? one : two)++;
}
if (!(one & 1) && (!(two & 1) || (two & 1 && one)))
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
int r, l;
cin >> t;
while (t--) {
cin >> l;
cin >> r;
cout << l << " " << 2 * l << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const int dx[4] = {0, -1, 0, 1};
const int dy[4] = {-1, 0, 1, 0};
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-5;
const int maxn = 2e3 + 10;
int p[maxn];
vector<int> v;
int main() {
int t;
t = read();
while (t--) {
int n;
n = read();
int x;
for (int i = 1; i <= 2 * n; ++i) {
x = read();
if (!p[x]) v.push_back(x);
p[x] = 1;
}
for (int i = 0; i <= v.size() - 1; ++i) printf("%d ", v[i]);
v.clear();
memset(p, 0, sizeof(p));
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int MAXN = 2e5 + 10;
int n, a[MAXN], ans[MAXN];
int head[MAXN], to[MAXN * 2], nxt[MAXN * 2], tot = 0;
queue<int> que;
void add(int u, int v) {
to[++tot] = v;
nxt[tot] = head[u];
head[u] = tot;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(ans, 0x3f, sizeof(ans));
for (int i = 1; i <= n; i++) {
if (i - a[i] >= 1 && a[i - a[i]] % 2 == a[i] % 2) add(i - a[i], i);
if (i + a[i] <= n && a[i + a[i]] % 2 == a[i] % 2) add(i + a[i], i);
}
for (int i = 1; i <= n; i++)
if (i - a[i] >= 1 && a[i - a[i]] % 2 != a[i] % 2 ||
i + a[i] <= n && a[i + a[i]] % 2 != a[i] % 2)
ans[i] = 1, que.push(i);
while (!que.empty()) {
int u = que.front();
que.pop();
for (int i = head[u]; i; i = nxt[i])
if (ans[to[i]] > ans[u] + 1) {
ans[to[i]] = ans[u] + 1;
que.push(to[i]);
}
}
for (int i = 1; i <= n; i++) printf("%d ", ans[i] == inf ? -1 : ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, m, group;
scanf("%d %d", &n, &m);
if (m == 0) {
printf("1");
} else {
group = m;
if (n - m > group) {
printf("%d", group);
} else {
printf("%d", n - m);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int CeilIndex(std::vector<long long int>& v, int l, int r, long long int key) {
while (r - l > 1) {
int m = l + (r - l) / 2;
if (v[m] >= key)
r = m;
else
l = m;
}
return r;
}
int LongestIncreasingSubsequenceLength(std::vector<long long int>& v) {
if (v.size() == 0) return 0;
std::vector<long long int> tail(v.size(), 0);
int length = 1;
tail[0] = v[0];
for (size_t i = 1; i < v.size(); i++) {
if (v[i] < tail[0])
tail[0] = v[i];
else if (v[i] > tail[length - 1])
tail[length++] = v[i];
else
tail[CeilIndex(tail, -1, length - 1, v[i])] = v[i];
}
return length;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int i, t, n, x;
cin >> t;
while (t--) {
cin >> n;
unordered_set<long long int> s;
for (i = 0; i < n; i++) {
cin >> x;
s.insert(x);
}
cout << s.size() << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
template <typename T, typename U>
static void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
struct Sum {
int size;
int negativePrefix, positiveSuffix;
int hillPrefix, hillSuffix;
int maxHill;
Sum()
: size(0),
negativePrefix(0),
positiveSuffix(0),
hillPrefix(0),
hillSuffix(0),
maxHill(0) {}
explicit Sum(long long val)
: size(1),
negativePrefix(val < 0),
positiveSuffix(val > 0),
hillPrefix(val != 0),
hillSuffix(val != 0),
maxHill(val != 0) {}
Sum &operator+=(const Sum &that) { return *this = *this + that; }
bool isNegative() const { return negativePrefix == size; }
bool isPositive() const { return positiveSuffix == size; }
bool isHill() const { return hillPrefix == size; }
Sum operator+(const Sum &that) const {
Sum res;
res.size = size + that.size;
res.negativePrefix =
isNegative() ? size + that.negativePrefix : negativePrefix;
res.positiveSuffix =
that.isPositive() ? positiveSuffix + that.size : that.positiveSuffix;
res.hillPrefix =
isHill() ? size + (isPositive() ? that.hillPrefix : that.negativePrefix)
: hillPrefix;
res.hillSuffix =
that.isHill()
? (that.isNegative() ? hillSuffix : positiveSuffix) + that.size
: that.hillSuffix;
res.maxHill = max(maxHill, that.maxHill);
amax(res.maxHill, positiveSuffix + that.hillPrefix);
amax(res.maxHill, hillSuffix + that.negativePrefix);
return res;
}
};
struct GetRangeSegmentTree {
static Sum combineVal(const Sum &x, const Sum &y) { return x + y; }
static void assignCombineVal(Sum &x, const Sum &y) { x += y; }
static Sum identityVal() { return Sum(); }
vector<Sum> nodes;
int n;
void init(int n_, const Sum &v = Sum()) { init(vector<Sum>(n_, v)); }
void init(const vector<Sum> &u) {
n = 1;
while (n < (int)u.size()) n *= 2;
nodes.resize(n, identityVal());
nodes.insert(nodes.end(), u.begin(), u.end());
nodes.resize(n * 2, identityVal());
for (int i = n - 1; i > 0; --i)
nodes[i] = combineVal(nodes[i * 2], nodes[i * 2 + 1]);
}
Sum get(int i) { return nodes[i + n]; }
Sum getWhole() const { return nodes[1]; }
Sum getRange(int l, int r) const {
Sum m = identityVal();
int indices[64];
int k = 0;
for (; l && l + (l & -l) <= r; l += l & -l)
assignCombineVal(m, nodes[(n + l) / (l & -l)]);
for (; l < r; r -= r & -r) indices[k++] = (n + r) / (r & -r) - 1;
while (--k >= 0) assignCombineVal(m, nodes[indices[k]]);
return m;
}
void set(int i, const Sum &x) {
i += n;
nodes[i] = x;
for (i >>= 1; i > 0; i >>= 1)
nodes[i] = combineVal(nodes[i * 2], nodes[i * 2 + 1]);
}
};
int main() {
int n;
while (~scanf("%d", &n)) {
vector<int> a(n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
vector<long long> diffs(n - 1);
for (int(i) = 0; (i) < (int)(n - 1); ++(i)) diffs[i] = a[i + 1] - a[i];
GetRangeSegmentTree segt;
segt.init(vector<Sum>(diffs.begin(), diffs.end()));
int m;
scanf("%d", &m);
for (int(ii) = 0; (ii) < (int)(m); ++(ii)) {
int l;
int r;
int d;
scanf("%d%d%d", &l, &r, &d), --l;
if (l > 0) {
diffs[l - 1] += d;
segt.set(l - 1, Sum(diffs[l - 1]));
}
if (r < n) {
diffs[r - 1] -= d;
segt.set(r - 1, Sum(diffs[r - 1]));
}
Sum sum = segt.getWhole();
int ans = sum.maxHill + 1;
printf("%d\n", ans);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
int a[59];
int main() {
int n, d;
cin >> n >> d;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int b = n, m = n;
for (int i = 0; i < m && d--; i++) {
cout << 1 + n - b << " ";
for (int j = b; j < n; j++) cout << a[j] << " ";
cout << a[i] << endl;
if (i == m - 1) m--, i = -1, b--;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 10005;
int vs[mx];
int main() {
int n;
scanf("%d", &n);
int a, b;
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
vs[a]++;
vs[b]++;
}
int ans = 0;
for (int i = 1; i <= n; i++) ans += vs[i] * (vs[i] - 1) / 2;
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long a[n];
long long i;
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long ans = 0;
long long j = 1;
for (i = 0; i < n; i++) {
if (a[i] >= j) {
ans++;
j++;
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
long long ppow(long long a, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans *= a;
a *= a;
n >>= 1;
}
return ans;
}
vector<long long> B;
int main() {
long long A = 0;
cin >> A;
long long ans = 0;
B.push_back(4), B.push_back(7);
int cnt = 2;
for (long long i = 1; i < 10; i++) {
long long a = ppow(10, i) * 4;
long long aa = ppow(10, i) * 7;
long long n = B.size();
int tmp = 0;
for (long long i = n - 1; i > n - 1 - cnt; i--) {
long long c = B[i];
long long d = c + a;
long long dd = c + aa;
B.push_back(d);
B.push_back(dd);
tmp += 2;
}
cnt = tmp;
}
sort(B.begin(), B.end());
for (long long i = 0; i < B.size(); i++) {
if (B[i] == A) {
cout << i + 1 << endl;
return 0;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long vis[1005];
long long vis1[1005];
long long dis[1005];
long long sub[1005];
vector<long long> adj[1005];
long long dia[1005];
long long ans = 0;
long long tot = 0;
void dfs(long long x, long long p) {
vis[x] = vis1[x] = 1;
for (auto it : adj[x]) {
if (!vis1[it]) {
dis[it] = dis[x] + 1;
dfs(it, x);
}
}
}
signed main() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
long long diameter = 0;
long long cc = 0;
long long z = 0;
vector<pair<long long, long long> > center;
for (long long i = 1; i <= n; i++) {
if (!vis[i]) {
cc++;
for (long long i = 1; i <= n; i++) dis[i] = vis1[i] = 0;
dfs(i, -1);
long long node = -1;
long long ma = 0;
for (long long j = 1; j < n + 1; j++) {
if (dis[j] > ma) {
ma = dis[j];
node = j;
}
}
for (long long i = 1; i <= n; i++) dis[i] = vis1[i] = 0;
dfs(node, -1);
ma = 0;
long long node1 = -1;
for (long long j = 1; j < n + 1; j++) {
if (dis[j] > ma) {
ma = dis[j];
node1 = j;
}
}
if (ma == 1) {
node = i;
center.push_back(make_pair(1, i));
continue;
}
if (adj[i].size() == 0) {
center.push_back(make_pair(0, i));
continue;
}
z = max(z, ma);
for (long long i = 1; i <= n; i++) dis[i] = vis1[i] = 0;
set<long long> t;
dfs(node, -1);
for (long long i = 1; i <= n; i++)
if (dis[i] == ma / 2) t.insert(i);
for (long long i = 1; i <= n; i++) dis[i] = vis1[i] = 0;
dfs(node1, -1);
long long centre = -1;
for (long long i = 1; i <= n; i++) {
if (dis[i] == (ma - ma / 2) && t.find(i) != t.end()) {
centre = i;
}
}
z = max(z, ma);
for (long long i = 1; i <= n; i++) dis[i] = 0;
center.push_back(make_pair(ceil(ma / 2.0), centre));
}
}
sort(center.begin(), center.end());
if (center.size() > 2) {
diameter =
center[center.size() - 2].first + center[center.size() - 3].first + 2;
diameter = max(diameter, center[center.size() - 2].first +
center[center.size() - 1].first + 1);
diameter = max(diameter, center[center.size() - 3].first +
center[center.size() - 1].first + 1);
} else if (center.size() == 2) {
diameter = center[0].first + center[1].first + 1;
}
cout << max(z, diameter) << endl;
for (long long i = 0; i < center.size() - 1; i++)
cout << center[center.size() - 1].second << " " << center[i].second << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100;
const int maxpow = 1 << 17;
const int inf = 1e9 + 7;
long long h[maxn];
int par[maxn];
struct node {
pair<int, int> a;
node(pair<int, int> _a) : a(_a) {}
node() : a(0, -1) {}
void merge(node x, node y) { a = max(x.a, y.a); }
};
node tree[maxpow * 2];
node query(int i, int ns, int ne, int qs, int qe) {
if (qe <= ns || qs >= ne) {
return node();
}
if (ns >= qs && ne <= qe) {
return tree[i];
}
int mid = (ns + ne) / 2;
node res1 = query(2 * i, ns, mid, qs, qe);
node res2 = query(2 * i + 1, mid, ne, qs, qe);
node res;
res.merge(res1, res2);
return res;
}
void update(int i, int ns, int ne, int qs, pair<int, int> v) {
if (qs + 1 <= ns || qs >= ne) {
return;
}
if (ns + 1 == ne) {
tree[i] = node(v);
return;
}
int mid = (ns + ne) / 2;
update(2 * i, ns, mid, qs, v);
update(2 * i + 1, mid, ne, qs, v);
tree[i].merge(tree[2 * i], tree[2 * i + 1]);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, d;
cin >> n >> d;
vector<long long> a;
for (long long i = 0; i < n; i++) {
cin >> h[i];
a.push_back(h[i]);
}
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
pair<int, int> mx(-1, -1);
for (int i = 0; i < n; i++) {
int left = lower_bound(a.begin(), a.end(), h[i] - d + 1) - a.begin();
int right = lower_bound(a.begin(), a.end(), h[i] + d) - a.begin();
int cur = lower_bound(a.begin(), a.end(), h[i]) - a.begin();
node ans1 = query(1, 0, maxpow, 0, left);
node ans2 = query(1, 0, maxpow, right, n);
pair<int, int> ans = max(ans1.a, ans2.a);
ans.first += 1;
par[i] = ans.second;
ans.second = i;
mx = max(mx, ans);
update(1, 0, maxpow, cur, ans);
}
cout << mx.first << endl;
int ind = mx.second;
vector<int> res;
while (ind != -1) {
res.push_back(ind);
ind = par[ind];
}
reverse(res.begin(), res.end());
for (int i = 0; i < res.size(); i++) {
cout << res[i] + 1 << " ";
}
cout << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s[50];
bool u[26];
int solve() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < s[i].size(); j++) u[s[i][j] - 'a'] = 1;
}
for (int i = 0; i < 26; i++)
if (!u[i]) {
cout << char('a' + i);
return 0;
}
string ans = "aa";
bool flag;
do {
flag = 0;
for (int i = 0; !flag && i < n; i++) {
for (int j = 0; j < s[i].size() - 1; j++) {
if (s[i][j] == ans[0] && s[i][j + 1] == ans[1]) {
flag = 1;
break;
}
}
}
if (!flag) {
cout << ans;
return 0;
}
if (ans[1] == 'z') {
ans[0]++;
ans[1] = 'a';
} else
ans[1]++;
} while (ans != "zz");
return 0;
}
int main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int Z[400010];
int main() {
int n, m;
while (cin >> n >> m) {
vector<pair<long long, char> > t(n), s(m);
for (int i = 0; i < n; i++) {
scanf("%I64d-%c", &t[i].first, &t[i].second);
if (i && t[i].second == t[i - 1].second) {
t[i - 1].first += t[i].first;
i--;
n--;
}
}
for (int i = 0; i < m; i++) {
scanf("%I64d-%c", &s[i].first, &s[i].second);
if (i && s[i].second == s[i - 1].second) {
s[i - 1].first += s[i].first;
i--;
m--;
}
}
t.resize(n);
s.resize(m);
if (m == 1) {
long long res = 0;
for (int i = 0; i < n; i++) {
if (t[i].second == s[0].second)
res += max(0LL, t[i].first - s[0].first + 1);
}
cout << res << endl;
continue;
}
if (m == 2) {
long long res = 0;
for (int i = 0; i + 1 < n; i++) {
if (t[i].second == s[0].second && t[i].first >= s[0].first &&
t[i + 1].second == s[1].second && t[i + 1].first >= s[1].first)
res++;
}
cout << res << endl;
continue;
}
vector<pair<long long, char> > a(n + m - 1);
for (int i = 1; i + 1 < m; i++) a[i - 1] = s[i];
a[m - 2] = {-1, '$'};
for (int i = 0; i < n; i++) a[i + m - 1] = t[i];
memset(Z, 0, sizeof Z);
int l = 0, r = 0;
for (int i = 1; i < a.size(); i++) {
if (i > r) {
l = r = i;
while (r < a.size() && a[r - l] == a[r]) r++;
Z[i] = r - l;
r--;
} else {
int tmp = i - l;
if (Z[tmp] < r - i + 1)
Z[i] = Z[tmp];
else {
l = i;
while (r < a.size() && a[r - l] == a[r]) r++;
Z[i] = r - l;
r--;
}
}
}
long long res = 0;
for (int i = 0; i < a.size(); i++) {
if (Z[i] == m - 2 && i - m + 1 > 0 && t[i - m].second == s[0].second &&
t[i - m].first >= s[0].first && i - 1 < n &&
t[i - 1].second == s[m - 1].second &&
t[i - 1].first >= s[m - 1].first)
res++;
}
cout << res << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
struct Frog {
int pos, id, cnt;
long long len;
Frog() { cnt = 0; }
Frog(int pos, long long len, int id) : pos(pos), id(id), len(len) {}
void read() { scanf("%d%lld", &pos, &len); }
bool operator<(const Frog& x) const { return pos < x.pos; }
};
bool cmp(Frog A, Frog B) { return A.id < B.id; }
int n, m;
Frog a[maxn];
long long C[maxn];
int lowbit(int x) { return x & (-x); }
void update(int x, long long val) {
while (x <= n) {
C[x] = max(C[x], val);
x += lowbit(x);
}
}
long long query(int x) {
long long ans = 0;
while (x) {
ans = max(ans, C[x]);
x -= lowbit(x);
}
return ans;
}
bool eat(int p, int val) {
Frog tmp(p, 0, 0);
int L = 1;
int R = upper_bound(a + 1, a + n + 1, tmp) - a;
int limit = R;
while (L < R) {
int mid = (L + R) / 2;
if (query(mid) >= p)
R = mid;
else
L = mid + 1;
}
if (L == limit) return false;
a[L].len += val;
a[L].cnt++;
update(L, a[L].len + a[L].pos);
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
a[i].read();
a[i].id = i;
}
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) update(i, a[i].len + a[i].pos);
multiset<pair<int, int> > MS;
while (m--) {
int p, v;
scanf("%d%d", &p, &v);
pair<int, int> x(p, v);
MS.insert(x);
vector<pair<int, int> > eaten;
auto it = MS.lower_bound(x);
while (it != MS.end()) {
if (eat(it->first, it->second)) {
eaten.push_back(*it);
it++;
} else
break;
}
for (auto it : eaten) MS.erase(MS.find(it));
}
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; i++) printf("%d %lld\n", a[i].cnt, a[i].len);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<long long> pre(n);
for (int i = 0; i < n; i++) {
if (i == 0) {
pre[i] = a[i];
continue;
}
pre[i] = pre[i - 1] + a[i];
}
auto high = [&](long long n) -> int {
int ans = 0;
while (n > 0) {
ans++;
n >>= 1;
}
return ans - 1;
};
set<pair<int, int> > ans;
auto solve = [&](bool invert) {
for (int l = 0; l < n; l++) {
int h = high(a[l]);
for (int r = l + 2; r < n; r++) {
long long sum =
invert ? pre[n - l - 2] - pre[n - 1 - r] : pre[r - 1] - pre[l];
if (sum >= (1LL << (h + 1))) break;
if ((a[r] ^ a[l]) == sum) {
ans.insert(invert ? make_pair(n - 1 - r, n - 1 - l)
: make_pair(l, r));
}
}
}
};
solve(0);
reverse(a.begin(), a.end());
solve(1);
cout << ans.size() << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 5;
vector<int> pr[M];
int dp[M], a[M];
bool mark[M];
void pre() {
for (int i = 2; i < M; i++)
if (!mark[i])
for (int j = 2 * i; j < M; j += i) pr[j].push_back(i), mark[j] = 1;
}
int32_t main() {
pre();
int n, ans = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
if (n == 1 && a[0] == 1) return cout << 1 << endl, 0;
for (int i = 0; i < n; i++) {
for (auto p : pr[a[i]]) ((dp[a[i]]) = max((dp[a[i]]), (dp[p])));
dp[a[i]]++;
for (auto p : pr[a[i]]) ((dp[p]) = max((dp[p]), (dp[a[i]])));
((ans) = max((ans), (dp[a[i]])));
}
return cout << ans << endl, 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int rd() {
int x = 0;
char c = getchar();
bool f = 0;
while (c < '0' && c != '-') c = getchar();
if (c == '-') f = 1, c = getchar();
while (c >= '0') x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return f ? -x : x;
}
long long n;
long long tmp[1000];
void _main() {
int Case;
scanf("%d", &Case);
while (Case--) {
scanf("%lld", &n);
int len = 0;
long long L = 1, R = n - 1, res = n;
;
while (L <= R) {
long long mid = (L + R) >> 1;
tmp[++len] = mid;
L = mid + 1;
}
long long pos = 1;
int now = 0;
for (register int i = len, _n = 1; i >= _n; --i) {
if (now == 0)
pos += tmp[i];
else
pos -= tmp[i];
now ^= 1;
}
L = 1, R = n - 1;
printf("? %lld", pos);
std::cout << std::endl;
int ins = rd();
while (L <= R) {
long long mid = (L + R) >> 1;
if (now == 0)
pos += mid;
else
pos -= mid;
now ^= 1;
printf("? %lld", pos);
std::cout << std::endl;
int ins = rd();
if (ins == 1)
res = mid, R = mid - 1;
else
L = mid + 1;
}
printf("= %lld", res);
std::cout << std::endl;
}
}
int main() {
_main();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 250005;
int n, k, P, ans, f[30][N], fac[N], ifac[N], inv[N];
inline int ksm(register int x, register int L) {
register int ans = 1;
while (L)
L& 1 ? ans = (0ll + ans) * x % P, 0 : 0, x = (0ll + x) * x % P, L >>= 1;
return ans;
}
inline int dfs(const int x, const int s) {
if (x > k) return 0;
if (~f[x][s]) return f[x][s];
if (!s) return f[x][s] = (0ll + fac[n]) * fac[k] % P * ifac[k - x] % P;
f[x][s] = 0;
const int ss = s - (s & -s);
for (register int i = ss; i; i = (i - 1) & ss)
f[x][s] = (f[x][s] + (0ll + dfs(x + 1, i)) * ifac[s - i]) % P;
f[x][s] = (f[x][s] + (0ll + dfs(x + 1, 0)) * ifac[s]) % P;
return f[x][s];
}
int main() {
scanf("%d%d%d", &n, &k, &P), ans = ksm(k, n);
if (n & 1) return printf("%d", ans), 0;
for (register int i =
(fac[0] = fac[1] = ifac[0] = ifac[1] = inv[0] = inv[1] = 1) + 1;
i <= n; ++i)
fac[i] = (0ll + fac[i - 1]) * i % P,
inv[i] = (0ll + inv[P % i]) * (P - P / i) % P,
ifac[i] = (0ll + ifac[i - 1]) * inv[i] % P;
memset(f, -1, sizeof(f)), ans -= dfs(0, n),
printf("%d", ans < 0 ? ans + P : ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, bb;
while (~scanf("%d%d%d", &a, &b, &c)) {
bb = (b + c - a) / 2;
b -= bb, c -= bb;
if (bb >= 0 && b >= 0 && c >= 0 && b + c == a)
printf("%d %d %d\n", b, bb, c);
else
puts("Impossible");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long inf64 = 1e18;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
int c0 = 0, c1 = 0;
for (int i = 1; i < n; i++) {
if (s[i] == s[i - 1]) {
if (s[i] == '1')
c1++;
else
c0++;
}
}
cout << max(c0, c1) << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 5;
struct node {
int size, mx1l, mx1r, mx2l, mx2r, mx;
long long vl, vr, tag;
} tr[N * 4];
int n, a[N], q, l, r;
long long val;
void pushdown(int p) {
if (tr[p].tag) {
tr[p + p].vl += tr[p].tag;
tr[p + p + 1].vl += tr[p].tag;
tr[p + p].vr += tr[p].tag;
tr[p + p + 1].vr += tr[p].tag;
tr[p + p].tag += tr[p].tag;
tr[p + p + 1].tag += tr[p].tag;
tr[p].tag = 0;
}
}
void pushup(int p) {
tr[p].vl = tr[p + p].vl;
tr[p].vr = tr[p + p + 1].vr;
int v = 0;
tr[p].mx = max(tr[p + p].mx, tr[p + p + 1].mx);
tr[p].mx1l = tr[p + p].mx1l;
if (tr[p + p].mx1l == tr[p + p].size && tr[p + p].vr > tr[p + p + 1].vl)
tr[p].mx1l += tr[p + p + 1].mx1l;
tr[p].mx = max(tr[p].mx, tr[p].mx1l);
tr[p].mx1r = tr[p + p + 1].mx1r;
if (tr[p + p + 1].mx1r == tr[p + p + 1].size &&
tr[p + p].vr < tr[p + p + 1].vl)
tr[p].mx1r += tr[p + p].mx1r;
tr[p].mx = max(tr[p].mx, tr[p].mx1r);
tr[p].mx2l = tr[p + p].mx2l;
if (tr[p + p].mx2l == tr[p + p].size && tr[p + p].vr > tr[p + p + 1].vl)
tr[p].mx2l += tr[p + p + 1].mx1l;
tr[p].mx = max(tr[p].mx, tr[p].mx2l);
if (tr[p + p].mx1r == tr[p + p].size && tr[p + p].vr < tr[p + p + 1].vl)
v = tr[p + p].mx1r + tr[p + p + 1].mx2l;
tr[p].mx2l = max(tr[p].mx2l, v);
v = 0;
tr[p].mx2r = tr[p + p + 1].mx2r;
if (tr[p + p + 1].mx2r == tr[p + p + 1].size &&
tr[p + p + 1].vl > tr[p + p].vr)
tr[p].mx2r += tr[p + p].mx1r;
tr[p].mx = max(tr[p].mx, tr[p].mx2r);
if (tr[p + p + 1].mx1l == tr[p + p + 1].size &&
tr[p + p + 1].vl < tr[p + p].vr)
v = tr[p + p + 1].mx1l + tr[p + p].mx2r;
tr[p].mx2r = max(tr[p].mx2r, v);
tr[p].mx = max(tr[p].mx, max(tr[p].mx2l, tr[p].mx2r));
if (tr[p + p + 1].vl > tr[p + p].vr)
tr[p].mx = max(tr[p].mx, tr[p + p].mx1r + tr[p + p + 1].mx2l);
if (tr[p + p + 1].vl < tr[p + p].vr)
tr[p].mx = max(tr[p].mx, tr[p + p].mx2r + tr[p + p + 1].mx1l);
}
void update(int p, int l, int r, int x, int y, int val) {
if (x <= l && r <= y) {
tr[p].vl += val;
tr[p].vr += val;
tr[p].tag += val;
return;
}
pushdown(p);
int mid = l + r >> 1;
if (x <= mid) update(p + p, l, mid, x, y, val);
if (y > mid) update(p + p + 1, mid + 1, r, x, y, val);
pushup(p);
}
void build(int p, int l, int r) {
tr[p].size = r - l + 1;
if (l == r) {
tr[p].vl = tr[p].vr = a[l];
tr[p].mx1l = tr[p].mx1r = tr[p].mx2l = tr[p].mx2r = tr[p].mx = 1;
return;
}
int mid = l + r >> 1;
build(p + p, l, mid);
build(p + p + 1, mid + 1, r);
pushup(p);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, 1, n);
scanf("%d", &q);
while (q--) {
scanf("%d%d%lld", &l, &r, &val);
update(1, 1, n, l, r, val);
printf("%d\n", tr[1].mx);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 100;
const int M = 40 + 5;
const int P = 229;
const int P2 = 229;
const long long MOD = 1e9 + 13;
const long long MOD2 = 1e9 + 7;
const int rx[4] = {1, -1, 0, 0};
const int ry[4] = {0, 0, 1, -1};
vector<int> h;
vector<int> h2;
long long p[N];
long long p2[N];
long long kol[N];
void Hash(string s) {
h[0] = int(s[0] - 'a') + 1;
for (int i = 1; i < (int)s.size(); i++) {
h[i] = (h[i - 1] * (1ll) * P) % MOD;
h[i] = (h[i] + (int(s[i] - 'a') + 1)) % MOD;
}
h2[0] = int(s[0] - 'a') + 1;
for (int i = 1; i < (int)s.size(); i++) {
h2[i] = (h2[i - 1] * (1ll) * P2) % MOD2;
h2[i] = (h2[i] + (int(s[i] - 'a') + 1)) % MOD2;
}
}
long long get(int l, int r) {
int len = r - l + 1;
int res = h[r];
if (l > 0) {
res -= ((h[l - 1] * p[len]) % MOD);
}
res += MOD;
res %= MOD;
return res;
}
long long get2(int l, int r) {
int len = r - l + 1;
int res = h2[r];
if (l > 0) {
res -= ((h2[l - 1] * p2[len]) % MOD2);
}
res += MOD2;
res %= MOD2;
return res;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(0));
string s;
cin >> s;
string god;
cin >> god;
h.resize(s.size());
h2.resize(s.size());
int k;
cin >> k;
p[0] = 1;
p2[0] = 1;
int n = s.size();
for (int i = 1; i <= n; i++) {
p[i] = (p[i - 1] * P) % MOD;
p2[i] = (p2[i - 1] * P2) % MOD2;
}
for (int i = 0; i < n; i++) {
int now = int(s[i] - 'a');
if (i > 0) kol[i] = kol[i - 1];
if (god[now] == '0') {
kol[i]++;
}
}
Hash(s);
set<pair<int, int> > st;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
int ans1 = get(i, j);
int ans2 = get2(i, j);
int bad = kol[j];
if (i > 0) bad -= kol[i - 1];
if (bad > k) continue;
st.insert({ans1, ans2});
}
}
cout << st.size();
return 0;
}
| 5 |
#include <bits/stdc++.h>
int take() {
int n;
scanf("%d", &n);
return n;
}
double ttake() {
double n;
scanf("%lf", &n);
return n;
}
long long takes() {
long long n;
scanf("%lld", &n);
return n;
}
int cas;
using namespace std;
bool approximatelyEqual(float a, float b, float epsilon) {
return fabs(a - b) <= ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}
bool essentiallyEqual(float a, float b, float epsilon) {
return fabs(a - b) <= ((fabs(a) > fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}
bool definitelyGreaterThan(float a, float b, float epsilon) {
return (a - b) > ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}
bool definitelyLessThan(float a, float b, float epsilon) {
return (b - a) > ((fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);
}
struct info {
int cnt;
info* next[2];
info() {
cnt = 0;
next[0] = next[1] = NULL;
}
} * root;
string bit(int u) {
string s = "";
int ind = 31;
while (ind--) {
s += ((u % 2) + 48);
u /= 2;
}
reverse(s.begin(), s.end());
return s;
}
void ins(string s) {
info* ptr = root;
for (int i = 0; i <= s.size() - 1; i += 1) {
int ind = s[i] - 48;
if (ptr->next[ind] == NULL) {
ptr->next[ind] = new info();
}
ptr = ptr->next[ind];
ptr->cnt++;
}
}
long long query(string s) {
info* ptr = root;
long long ans = 0;
int len = s.size() - 1;
for (int i = 0; i <= (int)(s.size() - 1); i += 1) {
int ind = s[i] - 48;
if (ptr->next[ind] == NULL || ptr->next[ind]->cnt == 0) ind ^= 1;
if (ptr->next[ind] == NULL || ptr->next[ind]->cnt == 0) return ans;
if (ind) ans += pow(2, len - i);
ptr = ptr->next[ind];
}
return ans;
}
void del(info* ptr, string s) {
for (int i = 0; i <= s.size() - 1; i += 1) {
int ind = s[i] - 48;
ptr = ptr->next[ind];
ptr->cnt--;
}
}
int main() {
root = new info();
int n = take(), arr[n + 1];
for (int i = 1; i <= n; i += 1) {
int u = take();
arr[i] = u;
}
for (int i = 1; i <= n; i += 1) {
int u = take();
ins(bit(u));
}
for (int i = 1; i <= n; i += 1) {
long long ans = query(bit(arr[i]));
printf("%lld ", ans ^ arr[i]);
del(root, bit(ans));
}
{ return 0; };
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, n, x, y, h, w, m = 1, p = 0, flag = 0, k, l, maxperimeter = 0;
cin >> n >> m;
char a[n][m];
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) cin >> a[i][j];
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
p = m - j;
w = 0;
for (k = i; k < n; k++) {
w = k - i + 1;
h = 0;
for (l = j; l < j + p; l++) {
if (a[k][l] == '0')
h++;
else
break;
}
p = h;
if (h > 0 && w > 0) maxperimeter = max(maxperimeter, 2 * (w + h));
}
}
cout << maxperimeter;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
template <typename T>
void write(T a) {
if (a < 0) {
putchar('-');
write(-a);
return;
}
if (a < 10) {
putchar('0' + a);
return;
}
write(a / 10);
putchar((char)('0' + (a % 10)));
}
void read(long long& x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) f = ch == '-' ? -f : f, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
}
void docfile() {
if (ifstream("FORM.inp")) {
freopen("FORM.inp", "r", stdin);
freopen("FORM.out", "w", stdout);
} else if (ifstream("STR4"
".inp")) {
freopen(
"STR4"
".inp",
"r", stdin);
freopen(
"STR4"
".out",
"w", stdout);
}
}
int main() {
docfile();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, q, l, r;
cin >> n;
int a[n + 1], f[n + 1];
for (int i = 1; i <= n; i++) cin >> a[i], f[i] = f[i - 1] + a[i];
cin >> q;
while (q--) {
cin >> l >> r;
cout << (f[r] - f[l - 1]) / 10 << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005, maxm = 100005;
int n, tot, last, e[maxn][26], st[maxm], v[maxm], Parent[maxn], Max[maxn],
data[maxn], degree[maxn];
long long ans, f[maxn];
char c, s[maxn];
void add(char c) {
int np = ++tot, p = last, q, nq;
Max[np] = Max[p] + 1;
for (; p >= 0 && !e[p][c - 'a']; p = Parent[p]) e[p][c - 'a'] = np;
if (p < 0)
Parent[np] = 0;
else {
q = e[p][c - 'a'];
if (Max[q] == Max[p] + 1)
Parent[np] = q;
else {
nq = ++tot;
memcpy(e[nq], e[q], sizeof(e[q]));
Parent[nq] = Parent[q];
Max[nq] = Max[p] + 1;
Parent[np] = Parent[q] = nq;
for (; p >= 0 && e[p][c - 'a'] == q; p = Parent[p]) e[p][c - 'a'] = nq;
}
}
last = np;
}
int main() {
scanf("%d", &n);
Parent[0] = -1;
for (int i = 0; i < n; i++) {
for (c = getchar(); c < 'a' || c > 'z'; c = getchar())
;
st[i] = tot;
for (; c >= 'a' && c <= 'z'; c = getchar()) s[tot++] = c;
}
st[n] = tot;
tot = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
last = 0;
for (int j = st[i]; j < st[i + 1]; j++) add(s[j]);
}
for (int i = 0; i < n; i++) {
int x = 0;
for (int j = st[i]; j < st[i + 1]; j++) {
x = e[x][s[j] - 'a'];
f[x] += v[i];
}
}
for (int i = 1; i <= tot; i++) degree[Parent[i]]++;
n = tot;
tot = 0;
for (int i = 1; i <= n; i++)
if (!degree[i]) data[++tot] = i;
for (int i = 1; i <= tot; i++) {
int x = data[i];
ans = max(ans, f[x] * Max[x]);
if (!x) break;
f[Parent[x]] += f[x];
degree[Parent[x]]--;
if (!degree[Parent[x]]) data[++tot] = Parent[x];
}
printf("%I64d\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int kInf = 0x3f3f3f3f, kMod = 1e9 + 7;
const long long kInf64 = 0x3f3f3f3f3f3f3f3f;
template <typename T>
inline void UMin(T& x, const T& y) {
if (x > y) x = y;
}
template <typename T>
inline void UMax(T& x, const T& y) {
if (x < y) x = y;
}
inline int Add(int a, int b) { return (a += b) >= kMod ? a - kMod : a; }
inline int Sub(int a, int b) { return (a -= b) < 0 ? a + kMod : a; }
inline int Mul(int a, int b) { return 1ll * a * b % kMod; }
int FPow(int bs, int ex = kMod - 2) {
int res = 1;
for (; ex; bs = Mul(bs, bs), ex >>= 1)
if (ex & 1) res = Mul(res, bs);
return res;
}
void Solve();
int main() {
int q;
scanf("%d", &q);
while (q--) Solve();
return 0;
}
const int kMaxn = 5e5 + 5;
int n, k;
long long DP[kMaxn][2];
std::vector<std::pair<int, int> > G[kMaxn];
void Dfs(int u, int fa) {
for (auto& p : G[u]) {
if (p.first == fa) continue;
Dfs(p.first, u);
}
std::vector<std::pair<long long, int> > buf;
long long sum = 0;
for (auto& p : G[u]) {
if (p.first == fa) continue;
sum += DP[p.first][0];
buf.push_back({DP[p.first][0] - DP[p.first][1] - p.second, p.first});
}
std::sort(buf.begin(), buf.end());
for (int i = 0; i + 1 < k && i < (int)buf.size(); ++i) {
if (buf[i].first >= 0) break;
sum -= buf[i].first;
}
DP[u][1] = sum;
if (k - 1 < (int)buf.size() && buf[k - 1].first < 0) sum -= buf[k - 1].first;
DP[u][0] = sum;
}
void Solve() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) G[i].clear();
for (int i = 1, u, v, c; i < n; ++i) {
scanf("%d%d%d", &u, &v, &c);
G[u].push_back({v, c});
G[v].push_back({u, c});
}
Dfs(1, 0);
printf("%lld\n", std::max(DP[1][0], DP[1][1]));
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
namespace patch {
template <typename T>
std::string to_string(const T& n) {
std::ostringstream stm;
stm << n;
return stm.str();
}
} // namespace patch
const long double PI = 3.14159265358979323846;
long long mdf = 4294967296;
const long long INF = 3e18 + 1337;
int A = 105;
struct Matrix {
vector<vector<long long>> mx =
vector<vector<long long>>(A, vector<long long>(A, INF));
Matrix operator*(const Matrix& other) {
Matrix temp;
for (int i = 0; i < A; i++)
for (int j = 0; j < A; j++)
for (int k = 0; k < A; k++)
temp.mx[i][j] = min(mx[i][k] + other.mx[k][j], temp.mx[i][j]);
return temp;
};
};
Matrix exp_matrix(Matrix a, int k) {
Matrix temp;
for (int i = 0; i < A; i++) temp.mx[i][i] = 0;
while (k) {
if (k % 2) temp = temp * a;
a = a * a;
k /= 2;
}
return temp;
}
long long gcd(long long a, long long b) { return a == 0 ? b : gcd(b % a, a); }
bool isAPrime(long long m) {
for (long long p = 2; p * p <= m; p++) {
if (m % p == 0) {
return false;
}
}
return true;
}
long long binpow(long long a, long long n) {
if (n == 0) return 1;
if (n % 2 == 1)
return (binpow(a, n - 1) * a) % mdf;
else {
long long b = binpow(a, n / 2) % mdf;
return (b * b) % mdf;
}
}
int count_setbits(int N) {
int cnt = 0;
while (N > 0) {
cnt += (N & 1);
N = N >> 1;
}
return cnt;
}
long long phi(long long n) {
long long result = n;
for (long long i = 2; i * i <= n; ++i)
if (n % i == 0) {
while (n % i == 0) n /= i;
result -= result / i;
}
if (n > 1) result -= result / n;
return result;
}
bool compare(pair<int, long long> a, pair<int, long long> b) {
return a.second < b.second;
}
int mergethem(vector<int>& a, int l, int m, int r) {
int Inv = 0;
vector<int> buff(r - l + 1);
int pos1 = l, pos2 = m + 1, posB = 0;
while (pos1 <= m && pos2 <= r) {
if (a[pos1] < a[pos2]) {
buff[posB++] = a[pos1++];
} else {
Inv += m - pos1 + 1;
buff[posB++] = a[pos2++];
}
}
while (pos1 <= m) buff[posB++] = a[pos1++];
while (pos2 <= r) buff[posB++] = a[pos2++];
copy(buff.begin(), buff.end(), a.begin() + l);
return Inv;
}
int mergesort(vector<int>& a, int l, int r) {
int curInv = 0;
if (l == r) return curInv;
int m = (l + r) / 2;
curInv += mergesort(a, l, m);
curInv += mergesort(a, m + 1, r);
curInv += mergethem(a, l, m, r);
return curInv;
}
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
return a.first > b.first;
}
vector<int> g[100005];
int av[100005];
int sv[100005];
bool good = true;
void gogogo(int u, int cur) {
if (!good) return;
if (sv[u] == -1) {
int mn = 2e9;
for (int v : g[u]) mn = min(mn, sv[v]);
if (mn == 2e9)
av[u] = 0;
else {
if (mn < cur) good = false;
av[u] = mn - cur;
for (int v : g[u]) gogogo(v, mn);
}
} else {
if (cur > sv[u]) good = false;
av[u] = sv[u] - cur;
for (int v : g[u]) gogogo(v, sv[u]);
}
}
void solve() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int j;
cin >> j;
j--;
g[j].push_back(i);
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
sv[i] = x;
}
av[0] = sv[0];
for (int v : g[0]) {
gogogo(v, av[0]);
}
if (good) {
long long s = 0;
for (int i = 0; i < n; i++) s += av[i];
cout << s;
} else
cout << -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q = 1;
while (q--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010, M = 1000010, P = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const int INF = 0xcfcfcfcf;
const double eps = 1e-9, pi = asin(1) * 2;
inline long long read();
inline int ADD(int a, int b) { return a + b >= P ? a + b - P : a + b; }
inline int MINUS(int a, int b) { return a - b < 0 ? a - b + P : a - b; }
int n;
char s[N][N];
int rk[N];
struct aa {
int a, id;
} a[N];
inline bool operator<(const aa &a, const aa &b) { return a.a > b.a; }
inline long long read() {
long long s = 0;
bool flag = false;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') flag = true;
for (; '0' <= ch && ch <= '9'; ch = getchar())
s = (s << 3) + (s << 1) + (ch ^ '0');
if (flag) return -s;
return s;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i].a = read(), a[i].id = i;
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) rk[a[i].id] = i;
for (int i = 1; i <= n + 1; i++)
for (int j = 1; j <= n; j++) s[i][j] = '0';
for (int j = 1; j <= n; j++)
for (int i = j, cnt = 1; cnt <= a[j].a; cnt++, i = i % (n + 1) + 1)
s[i][j] = '1';
printf("%d\n", n + 1);
for (int i = 1; i <= n + 1; i++) {
for (int j = 1; j <= n; j++) putchar(s[i][rk[j]]);
putchar('\n');
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
std::cin >> t;
while (t--) {
int n;
cin >> n;
int ct3 = 0, ct5 = 0, ct7 = 0;
while (n % 3 != 0) {
if (n % 3 == 1) {
n = n - 7;
ct7++;
} else if (n % 3 == 2) {
n = n - 5;
ct5++;
}
}
if (n < 0)
std::cout << "-1" << std::endl;
else
std::cout << (n / 3) << " " << ct5 << " " << ct7 << std::endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long proc[1000005], comp[1000005], in[1000005];
int main() {
long long n, k, it, nractiv, nrc, j, act, ans = 0;
cin >> n >> k;
for (it = 1; it <= k; it++) {
cin >> proc[it];
}
nractiv = k;
nrc = 0;
while (nractiv != 0) {
long double act;
act = nrc * 100;
act /= n;
act += 0.5;
act = (long long)act;
for (j = 1; j <= k; j++) comp[j]++;
for (j = 1; j <= k; j++) {
if (comp[j] == act && in[j] == 0 && comp[j] != 0) {
in[j] = 1;
ans++;
}
}
for (j = 1; j <= k; j++) {
if (in[j] != -1 && comp[j] >= proc[j]) {
if (nrc + k < n) {
cin >> proc[j];
in[j] = 0;
comp[j] = 0;
} else
nractiv--, in[j] = -1;
nrc++;
}
}
}
cout << ans << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, N = 1010, P = 1e9 + 7;
template <class T>
inline bool chkmin(T &A, T B) {
return B < A ? A = B, 1 : 0;
}
template <class T>
inline bool chkmax(T &A, T B) {
return A < B ? A = B, 1 : 0;
}
template <class T, class _>
inline void Add(T &first, _ second) {
first += second;
if (first >= P) first -= P;
if (first < 0) first += P;
}
int n, K;
long long C[N][N], Fac[N], dp[N][N];
int main() {
int cas;
Fac[0] = 1;
for (int i = (1), i_end = (N - 10); i <= i_end; ++i)
Fac[i] = Fac[i - 1] * i % P;
for (int i = (0), i_end = (N - 10); i <= i_end; ++i) {
C[i][0] = 1;
for (int j = (1), j_end = (i); j <= j_end; ++j)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % P;
}
dp[0][0] = 1;
for (int i = (1), i_end = (N - 10); i <= i_end; ++i)
for (int j = (1), j_end = (i); j <= j_end; ++j)
dp[i][j] = (dp[i - j][j] + dp[i - j][j - 1]) % P;
scanf("%d", &cas);
while (cas--) {
long long ans = 0;
scanf("%d%d", &n, &K);
for (int i = (K * (K + 1) / 2), i_end = (n); i <= i_end; ++i)
Add(ans, dp[i][K] * C[n - i + K][K] % P);
printf("%lld\n", ans * Fac[K] % P);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using INT = long long;
const int NN = 310100;
vector<int> adj[NN], rev[NN];
int n, m, src;
int SolveWin() {
vector<vector<int> > st(n + 10, vector<int>(2, 0)),
prev(n + 10, vector<int>(2, 0));
queue<int> q;
for (int i = 1; i <= n; i++) {
if (adj[i].empty()) {
q.push(i);
q.push(0);
st[i][0] = 1;
}
}
while (!q.empty()) {
int u = q.front();
q.pop();
int s = q.front();
q.pop();
for (int v : rev[u]) {
if (st[v][s ^ 1] == 0) {
prev[v][s ^ 1] = u;
q.push(v);
q.push(s ^ 1);
st[v][s ^ 1] = 1;
}
}
}
if (st[src][1] == 1) {
puts("Win");
int u = src, s = 1;
printf("%d ", u);
while (adj[u].size() > 0) {
u = prev[u][s];
s ^= 1;
printf("%d ", u);
}
exit(0);
}
}
int bel[NN], vst[NN], low[NN];
int head[NN], nxt[NN], to[NN], E;
int st[NN], ins[NN], nc, nt, cnt;
void _dfs(int u) {
ins[u] = 1, vst[st[++nt] = u] = low[u] = ++nc;
for (int v : adj[u]) {
if (!vst[v]) {
_dfs(v);
if (low[v] < low[u]) low[u] = low[v];
} else if (ins[v] && vst[v] < low[u])
low[u] = vst[v];
}
if (vst[u] == low[u]) {
cnt++;
while (bel[st[nt]] = cnt, ins[st[nt]] = 0, st[nt--] ^ u)
;
}
}
int SolveDraw() {
for (int i = 1; i <= n; i++)
if (vst[i] == 0) {
_dfs(i);
}
vector<int> vst(n + 2, 0), cnt(n + 2, 0);
for (int i = 1; i <= n; i++) cnt[bel[i]]++;
queue<int> q;
q.push(src);
vst[src] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
if (cnt[bel[u]] > 1) {
puts("Draw");
exit(0);
}
for (int v : adj[u]) {
if (vst[v]) continue;
vst[v] = 1;
q.push(v);
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int s;
scanf("%d", &s);
while (s--) {
int u;
scanf("%d", &u);
adj[i].push_back(u);
rev[u].push_back(i);
}
}
cin >> src;
SolveWin();
SolveDraw();
puts("Lose");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
namespace stuff {
void solve(int test_num) {
int R, C;
cin >> R >> C;
vector<string> grid(R);
for (int r = 0; r < R; r++) cin >> grid[r];
vector<vector<int> > cnt(R, vector<int>(C, 0));
for (int r = 0; r < R; r++) {
for (int c = 0; c < C; c++) {
const int X = grid[r][c] == 'W' ? 1 : -1;
cnt[r][c] += X;
if (r > 0) cnt[r - 1][c] -= X;
if (c > 0) cnt[r][c - 1] -= X;
if (r > 0 && c > 0) cnt[r - 1][c - 1] += X;
}
}
int res = 0;
for (int r = 0; r < R; r++)
for (int c = 0; c < C; c++)
if (cnt[r][c] != 0) res++;
cout << res << endl;
}
void solve() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
for (int t = 1; t <= T; t++) solve(t);
}
} // namespace stuff
int main() {
stuff::solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string st, s;
cin >> st >> s;
bool flag = st.length() == s.length();
for (int i = 0; i < st.length(); i++)
flag = (st[i] == s[st.length() - i - 1]) && flag;
cout << (flag ? "YES" : "NO");
}
| 0 |
#include <bits/stdc++.h>
long long i, j;
using namespace std;
void solve() {
string s, t1 = "", t2 = "";
cin >> s;
long long p = 0;
long long ans1 = 0, ans2 = 0;
for (i = 0; i < s.size(); i++) {
if (s[i] == '^')
p = 1;
else if (p == 0)
t1 += s[i];
else
t2 += s[i];
}
int k = 1;
for (i = t1.size() - 1; i >= 0; i--) {
if (t1[i] == '=') {
k++;
continue;
} else {
ans1 += (t1[i] - '0') * (k);
k++;
}
}
for (i = 0; i < t2.size(); i++) {
if (t2[i] == '=')
continue;
else {
ans2 += (t2[i] - '0') * (i + 1);
}
}
if (ans1 == ans2)
cout << "balance";
else if (ans1 > ans2)
cout << "left";
else
cout << "right";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
{
solve();
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
double l, p, r, k, m, temp;
cin >> l >> p >> r >> k >> m;
temp = m;
l = ceil(l / r);
p = ceil(p / k);
l ? temp -= l : temp--;
p ? temp -= p : temp--;
temp >= 0 ? cout << l << ' ' << m - l << endl : cout << -1 << endl;
}
int main() {
int t;
for (cin >> t; t--;) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
const double pi = 3.1415926535897932384626433832795, eps = 1e-10;
int N, M, i, j;
double Ax, Ay, Az, Vx, Vy, Vz, Ox, Oy, Oz, Bx, By, Bz, px, py, pz, R, r, Sin,
Sin1, Theta, Theta1, Theta2, l1, l2, mid1, mid2, h, s, Len, Ans, d, D, Cos;
double len(double x, double y, double z) { return sqrt(x * x + y * y + z * z); }
double Abs(double x) {
if (x < 0) return -x;
return x;
}
double Get(double x) {
double Px, Py, Pz, l1, l2;
Px = Ox + px / Len * x, Py = Oy + py / Len * x, Pz = Oz + pz / Len * x, r = 0;
if (Abs(Px - Ax) < eps && Abs(Py - Ay) < eps && Abs(Pz - Az) < eps)
return 0;
else {
Bx = Px - Ax, By = Py - Ay, Bz = Pz - Az;
l1 = len(Vx, Vy, Vz), l2 = len(Bx, By, Bz);
Cos = (Vx * Bx + Vy * By + Vz * Bz) / l1 / l2;
if (Cos < 0)
return len(Ax - Px, Ay - Py, Az - Pz);
else {
Sin = sqrt(1 - Cos * Cos);
return l2 * Sin;
}
}
}
int main() {
scanf("%lf%lf%lf%lf%lf%lf%lf", &Ax, &Ay, &Az, &Vx, &Vy, &Vz, &R);
scanf("%d", &N);
Ans = 1e63;
for (i = 1; i <= N; ++i) {
scanf("%lf%lf%lf%lf%d", &Ox, &Oy, &Oz, &r, &M);
if (Abs(Ox - Ax) < eps && Abs(Oy - Ay) < eps && Abs(Oz - Az) < eps)
d = D = 0;
else {
Bx = Ox - Ax, By = Oy - Ay, Bz = Oz - Az;
l1 = len(Vx, Vy, Vz), l2 = len(Bx, By, Bz);
Cos = (Vx * Bx + Vy * By + Vz * Bz) / l1 / l2;
if (Cos < 0)
d = len(Ax - Ox, Ay - Oy, Az - Oz), D = 0;
else {
Sin = sqrt(1 - Cos * Cos), d = l2 * Sin;
if (Sin > 1) Sin = 1;
if (Sin < eps)
D = l2 - R - r;
else {
if (d - eps < R + r) {
Sin1 = Sin * l2 / (R + r);
if (Sin1 > 1) Sin1 = 1;
Theta = asin(Sin);
Theta1 = pi - asin(Sin1);
Theta2 = pi - Theta - Theta1;
D = sin(Theta2) * (R + r) / Sin;
} else
D = 1e63;
}
}
}
if (d - eps < R + r)
if (D < Ans) Ans = D;
for (j = 1; j <= M; ++j) {
scanf("%lf%lf%lf", &px, &py, &pz);
Len = len(px, py, pz);
for (h = 0, s = Len; h + eps < s;) {
mid1 = h + (s - h) / 3, mid2 = h + (s - h) / 3 * 2;
l1 = Get(mid1), l2 = Get(mid2);
if (l1 < l2)
s = mid2;
else
h = mid1;
}
px = Ox + px / Len * h, py = Oy + py / Len * h, pz = Oz + pz / Len * h,
r = 0;
if (Abs(px - Ax) < eps && Abs(py - Ay) < eps && Abs(pz - Az) < eps)
d = D = 0;
else {
Bx = px - Ax, By = py - Ay, Bz = pz - Az;
l1 = len(Vx, Vy, Vz), l2 = len(Bx, By, Bz);
Cos = (Vx * Bx + Vy * By + Vz * Bz) / l1 / l2;
if (Cos < 0)
d = len(Ax - px, Ay - py, Az - pz), D = 0;
else {
Sin = sqrt(1 - Cos * Cos), d = l2 * Sin;
if (Sin > 1) Sin = 1;
if (Sin < eps)
D = l2 - R - r;
else if (d - eps < R + r) {
Sin1 = Sin * l2 / (R + r);
if (Sin1 > 1) Sin1 = 1;
Theta = asin(Sin);
Theta1 = pi - asin(Sin1);
Theta2 = pi - Theta - Theta1;
D = sin(Theta2) * (R + r) / Sin;
} else
D = 1e63;
}
}
if (d - eps < R + r)
if (D < Ans) Ans = D;
}
}
if (Ans > 1e62)
printf("-1\n");
else
printf("%.9lf\n", Ans / len(Vx, Vy, Vz));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> graph[100005];
bool vis[100005];
bool invis[100005];
vector<int> tree[100005];
vector<int> upedge[100005];
int upcnt[100005];
int psum[100005];
bool good[100005];
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
int bad_edges = 0;
void dfs(int node) {
vis[node] = true;
invis[node] = true;
for (int i = 0; i < graph[node].size(); i++) {
int nxt = graph[node][i];
if (!vis[nxt]) {
tree[node].push_back(nxt);
dfs(nxt);
} else if (invis[nxt]) {
upedge[node].push_back(nxt);
upcnt[nxt]++;
psum[node]++;
psum[nxt]--;
} else {
bad_edges++;
}
}
invis[node] = false;
}
int upnode[100005];
long long dfs2(int node) {
long long val = 0;
for (int i = 0; i < tree[node].size(); i++) {
val += dfs2(tree[node][i]);
psum[node] += psum[tree[node][i]];
}
val -= (long long)node * (long long)upcnt[node];
for (int i = 0; i < upedge[node].size(); i++) {
val += (long long)upedge[node][i];
}
if (psum[node] == 1) upnode[node] = val;
return val;
}
void dfs3(int node, bool root) {
good[node] = root || (psum[node] == 1 && good[upnode[node]]);
for (int i = 0; i < tree[node].size(); i++) {
dfs3(tree[node][i], false);
}
}
bool solve(int root) {
dfs(root);
if (bad_edges) return false;
dfs2(root);
dfs3(root, true);
vector<int> ans;
for (int i = 1; i <= n; i++) {
if (good[i]) ans.push_back(i);
}
if (ans.size() * 5 < n) {
printf("-1\n");
} else {
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i]);
}
printf("\n");
}
return true;
}
void work(void) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
graph[u].push_back(v);
}
bool found = false;
for (int at = 1; at <= 120; at++) {
for (int i = 1; i <= n; i++) vis[i] = false;
for (int i = 1; i <= n; i++) good[i] = false;
for (int i = 1; i <= n; i++) tree[i].clear();
for (int i = 1; i <= n; i++) upedge[i].clear();
for (int i = 1; i <= n; i++) upcnt[i] = 0;
for (int i = 1; i <= n; i++) psum[i] = 0;
bad_edges = 0;
if (solve((rng() % n) + 1)) {
found = true;
break;
}
}
if (!found) {
printf("-1\n");
}
for (int i = 1; i <= n; i++) graph[i].clear();
}
int main() {
int T;
scanf("%d", &T);
for (int i = 1; i <= T; i++) work();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
const int maxm = 10010;
int n, m, en, s[maxm], e[maxm], use[maxn][2], dist[maxn];
struct edge {
int e, id;
edge *next;
} * v[maxn], ed[maxm];
void add_edge(int s, int e, int id) {
en++;
ed[en].next = v[s];
v[s] = ed + en;
v[s]->e = e;
v[s]->id = id;
}
void dfs(int now, int idv) {
use[now][idv] = true;
for (edge *e = v[now]; e; e = e->next)
if (e->id == idv && !use[e->e][idv]) dfs(e->e, idv);
}
int main() {
scanf("%d%d", &n, &m);
for (int a = 1; a <= m; a++) {
scanf("%d%d", &s[a], &e[a]);
add_edge(s[a], e[a], 0);
add_edge(e[a], s[a], 1);
}
dfs(1, 0);
dfs(n, 1);
memset(dist, 0x3f, sizeof(dist));
dist[1] = 0;
for (int a = 1; a <= n; a++)
for (int b = 1; b <= m; b++)
if (use[s[b]][0] && use[e[b]][1]) {
dist[s[b]] = min(dist[s[b]], dist[e[b]] - 1);
dist[e[b]] = min(dist[e[b]], dist[s[b]] + 2);
}
for (int a = 1; a <= m; a++)
if (use[s[a]][0] && use[e[a]][1] && dist[e[a]] - dist[s[a]] != 1 &&
dist[e[a]] - dist[s[a]] != 2) {
printf("No\n");
return 0;
}
printf("Yes\n");
for (int a = 1; a <= m; a++)
if (use[s[a]][0] && use[e[a]][1])
printf("%d\n", dist[e[a]] - dist[s[a]]);
else
printf("1\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, s, cnt;
char mat[501][501], mat2[501][501];
int di[4] = {1, 0, -1, 0};
int dj[4] = {0, 1, 0, -1};
void lee(int i, int j) {
if (s - cnt <= k) return;
if (mat[i][j] == '.') {
cnt++;
mat[i][j] = ',';
mat2[i][j] = '.';
} else
return;
for (int d = 0; d < 4; d++) lee(i + di[d], j + dj[d]);
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> mat[i][j];
if (mat[i][j] == '.')
mat2[i][j] = 'X', s++;
else
mat2[i][j] = '#';
}
bool ok = true;
for (int i = 1; i <= n && ok; i++)
for (int j = 1; j <= m && ok; j++)
if (mat[i][j] == '.') {
ok = false;
lee(i, j);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << mat2[i][j];
cout << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = atan(1.0) * 4;
const int64_t INF = 3e18;
const int32_t LOG = 21;
const long long int MOD = 1e9 + 7;
vector<pair<long long int, pair<long long int, long long int>>> v[2005];
long long int vis[2005];
bool g = false;
long long int n, m;
long long int sol = 0;
void dfs(long long int i, pair<long long int, long long int> range) {
vis[i] = true;
if (i == n) g = true;
for (auto it : v[i]) {
if (!vis[it.first] && it.second.first <= range.first &&
it.second.second >= range.second)
dfs(it.first, range);
}
}
void solve(long long int bound) {
long long int l = 1, r = bound;
long long int ans = bound + 1;
while (l <= r) {
long long int mid = (l + r) >> 1;
g = false;
fill(vis, vis + n + 1, false);
dfs(1, {mid, bound});
if (g) {
ans = min(ans, mid);
r = mid - 1;
} else
l = mid + 1;
}
sol = max(sol, bound + 1 - ans);
}
vector<pair<long long int, long long int>> edges;
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int tests = 1;
for (long long int ii = 0; ii < tests; ii++) {
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
long long int x, y, l, r;
cin >> x >> y >> l >> r;
if (x == y) continue;
v[x].push_back({y, {l, r}});
v[y].push_back({x, {l, r}});
edges.push_back({l, r});
}
for (auto it : edges) solve(it.second);
string second = "Nice work, Dima!";
if (sol > 0)
cout << sol << '\n';
else
cout << second << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int b, long long int m) {
long long int ans = 1;
while (b > 0) {
if (b & 1) {
ans = (ans * a) % m;
}
a = (a * a) % m;
b = b / 2;
}
return ans;
}
bool compare(pair<long long int, long long int>& a,
pair<long long int, long long int>& b) {
if (a.second == b.second)
return a.first <= b.first;
else
return a.second < b.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
for (int i = 0; i < t; i++) {
long long int mod = 998244353;
long long int n, m, k, a;
cin >> n >> m >> k;
vector<pair<long long int, long long int> > arr(k);
set<long long int> myset1, myset2;
for (int i = 0; i < n; i++) {
cin >> a;
myset1.insert(a);
}
myset1.insert(1000000);
for (int i = 0; i < m; i++) {
cin >> a;
myset2.insert(a);
}
myset2.insert(1000000);
for (int i = 0; i < k; i++) {
cin >> arr[i].first >> arr[i].second;
}
sort(arr.begin(), arr.end());
long long int ans = 0, cur = 0;
for (auto val : myset1) {
map<long long int, long long int> mymap;
while (cur < k && arr[cur].first < val) {
mymap[arr[cur].second]++;
cur++;
}
while (cur < k && arr[cur].first == val) {
cur++;
}
long long int sum = 0, temp = 0;
for (auto l : mymap) {
sum += l.second;
temp += (l.second * (l.second - 1)) / 2;
}
ans += ((sum * (sum - 1)) / 2 - temp);
}
cur = 0;
sort(arr.begin(), arr.end(), compare);
for (auto val : myset2) {
map<long long int, long long int> mymap;
while (cur < k && arr[cur].second < val) {
mymap[arr[cur].first]++;
cur++;
}
while (cur < k && arr[cur].second == val) {
cur++;
}
long long int sum = 0, temp = 0;
for (auto l : mymap) {
sum += l.second;
temp += (l.second * (l.second - 1)) / 2;
}
ans += ((sum * (sum - 1)) / 2 - temp);
}
cout << ans << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
string s;
cin >> s;
deque<char> l, r;
bool plus = true;
for (int i = 0; s[i]; ++i) {
if (s[i] == '.') {
plus = false;
} else {
if (plus) {
l.push_back(s[i]);
} else {
r.push_back(s[i]);
}
}
}
l.push_front('0');
while (l.size() > 1 && l[0] == '0') {
l.pop_front();
}
while (r.size() > 0 && r[r.size() - 1] == '0') {
r.pop_back();
}
if (l.size() == 1) {
if (l[0] == '0') {
int k = 0;
for (int i = 0; i < r.size(); ++i) {
k++;
if (r[i] != '0') {
break;
}
}
cout << r[k - 1];
string t;
for (int i = k; i < r.size(); ++i) {
t += r[i];
}
while (t.size() > 0 && t[t.size() - 1] == '0') {
t.erase(t.size() - 1, 1);
}
if (t.size() > 0) {
cout << "." + t;
}
cout << 'E' << -k << endl;
} else {
for (int i = 0; i < l.size(); ++i) {
cout << l[i];
}
if (r.size() > 0) {
cout << ".";
for (int i = 0; i < r.size(); ++i) {
cout << r[i];
}
cout << endl;
}
}
} else {
cout << l[0];
string t;
for (int i = 1; i < l.size(); ++i) {
t += l[i];
}
for (int i = 0; i < r.size(); ++i) {
t += r[i];
}
while (t.size() > 0 && t[t.size() - 1] == '0') {
t.erase(t.size() - 1, 1);
}
if (t.size() > 0) {
cout << "." + t;
}
cout << "E" << l.size() - 1 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int a, b, ans = 0;
cin >> a >> b;
long long int nn = 9;
while (nn <= b) {
ans++;
nn = (nn * 10) + 9;
}
ans *= a;
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class UnionFind {
private:
std::vector<int> disj;
std::vector<int> rank;
public:
UnionFind(int n) : disj(n), rank(n) {
for (int i = 0; i < n; ++i) {
disj[i] = i;
rank[i] = 0;
}
}
int root(int x) {
if (disj[x] == x) {
return x;
}
return disj[x] = root(disj[x]);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) {
return;
}
if (rank[x] < rank[y]) {
disj[x] = y;
} else {
disj[y] = x;
if (rank[x] == rank[y]) {
++rank[x];
}
}
}
bool is_same_set(int x, int y) { return root(x) == root(y); }
};
const int N = 500100;
vector<int> g[N];
const int B = 19;
int bin[B][N];
bool vis[N];
long long int dat[B][N];
map<pair<int, int>, long long int> determ;
const long long int inf = 1e18;
int dep[N];
void dfs(int v, int par, int d = 0) {
vis[v] = true;
bin[0][v] = par == -1 ? v : par;
dep[v] = d;
if (determ.count(pair<int, int>(v, par))) {
dat[0][v] = determ[pair<int, int>(v, par)];
}
for (int w : g[v]) {
if (w == par) continue;
dfs(w, v, d + 1);
}
}
int lca(int x, int y) {
if (dep[x] > dep[y]) swap(x, y);
for (int b = B - 1; b >= 0; --b) {
if (dep[y] - dep[x] >= 1 << b) {
y = bin[b][y];
}
}
assert(dep[x] == dep[y]);
if (x == y) return x;
for (int b = B - 1; b >= 0; --b) {
if (bin[b][x] != bin[b][y]) {
x = bin[b][x];
y = bin[b][y];
}
}
assert(bin[0][x] == bin[0][y] && x != y);
return bin[0][x];
}
void upd(int des, int anc, long long int x) {
int d = dep[des] - dep[anc];
for (int b = B - 1; b >= 0; --b) {
if (d >= 1 << b) {
dat[b][des] = min(dat[b][des], x);
d -= 1 << b;
des = bin[b][des];
}
}
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, m;
cin >> n >> k >> m;
UnionFind uf(n);
for (int i = (int)(0); i < (int)(k); i++) {
int ga, gb;
cin >> ga >> gb;
ga--, gb--;
g[ga].push_back(gb);
g[gb].push_back(ga);
uf.unite(ga, gb);
}
vector<pair<long long int, pair<int, int> > > es;
for (int i = (int)(0); i < (int)(m); i++) {
int a, b;
long long int w;
cin >> a >> b >> w;
a--, b--;
es.push_back(pair<long long int, pair<int, int> >(w, pair<int, int>(a, b)));
}
sort(es.begin(), es.end());
vector<pair<long long int, pair<int, int> > > es_nxt;
for (pair<long long int, pair<int, int> > e : es) {
long long int w = e.first;
int a = e.second.first, b = e.second.second;
if (uf.is_same_set(a, b)) {
es_nxt.push_back(e);
continue;
}
uf.unite(a, b);
determ[pair<int, int>(a, b)] = w;
determ[pair<int, int>(b, a)] = w;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = (int)(0); i < (int)(n); i++) {
for (int j = (int)(0); j < (int)(B); j++) {
bin[j][i] = i;
dat[j][i] = inf;
}
}
dfs(0, -1);
for (int b = (int)(1); b < (int)(B); b++) {
for (int i = (int)(0); i < (int)(n); i++) {
bin[b][i] = bin[b - 1][bin[b - 1][i]];
}
}
long long int tot = 0;
for (pair<long long int, pair<int, int> > e : es_nxt) {
long long int w = e.first;
int a = e.second.first, b = e.second.second;
int l = lca(a, b);
upd(a, l, w);
upd(b, l, w);
}
for (int b = B - 1; b >= 1; --b) {
for (int i = (int)(0); i < (int)(n); i++) {
dat[b - 1][i] = min(dat[b - 1][i], dat[b][i]);
int u = bin[b - 1][i];
dat[b - 1][u] = min(dat[b - 1][u], dat[b][i]);
}
}
for (int i = (int)(0); i < (int)(n); i++) {
if (bin[0][i] == i) continue;
if (determ.count(pair<int, int>(i, bin[0][i]))) continue;
if (dat[0][i] >= inf) {
cout << -1 << "\n";
return 0;
}
tot += dat[0][i];
}
cout << tot << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int arr[500001];
int last[500002];
long long int cnt = 0;
long long int ans = 0;
int main() {
int n;
while (cin >> n) {
for (int i = 1; i <= n; i++) {
char t;
cin >> t;
arr[i] = int(t) - 48;
}
for (int i = 0; i <= n; i++) {
last[i] = 0;
}
cnt = 0;
ans = 0;
for (int i = 1; i <= n; i++) {
if (arr[i] == 0) {
ans = ans + cnt;
} else {
int l = i;
int r = i;
while (r < n && arr[r + 1] == 1) {
r++;
}
for (int j = 1; j <= (r - l + 1); j++) {
cnt = cnt + l + j - 1 - last[j];
last[j] = r - j + 1;
ans = ans + cnt;
}
i = r;
}
}
cout << ans << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n;
int m;
int h;
int k;
int all = 0;
int my;
int i;
double rez = 1.0;
scanf("%d%d%d", &n, &m, &h);
for (i = 1; i <= m; i++) {
scanf("%d", &k);
all += k;
if (i == h) my = k;
}
if (all < n)
printf("-1.0\n");
else {
if (all - my + 1 <= n - 1)
printf("1.0\n");
else {
for (i = 0; i < n - 1; i++) {
rez = rez * (all - my - i) / (all - 1 - i);
}
rez = 1 - rez;
printf("%lf\n", rez);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) {
if ((value += other.value) >= mod()) value -= mod();
return *this;
}
Modular& operator-=(const Modular& other) {
if ((value -= other.value) < 0) value += mod();
return *this;
}
template <typename U>
Modular& operator+=(const U& other) {
return *this += Modular(other);
}
template <typename U>
Modular& operator-=(const U& other) {
return *this -= Modular(other);
}
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(int) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
Modular>::type&
operator*=(const Modular& rhs) {
int64_t q = static_cast<int64_t>(static_cast<long double>(value) *
rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type&
operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) {
return *this *= Modular(inverse(other.value, mod()));
}
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend std::istream& operator>>(std::istream& stream, Modular<U>& number);
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T>& lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T>& lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T>& rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T>& lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T>& rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
template <typename T>
std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
return stream << number();
}
template <typename T>
std::istream& operator>>(std::istream& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
constexpr int md = (int)1e9 + 7;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
int n, k;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
vector<Mint> p(n + 1);
p[0] = 1;
for (int i = 1; i < n + 1; i++) p[i] = p[i - 1] * 2;
int N = k + 1;
vector<Mint> fact(N);
fact[0] = 1;
for (int i = 1; i < N; i++) fact[i] = fact[i - 1] * i;
vector<Mint> inv_fact(N);
for (int i = 0; i < N; i++) inv_fact[i] = 1 / fact[i];
vector<vector<int>> g(n);
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);
}
vector<vector<Mint>> res(n);
vector<int> sub(n, 1);
function<void(int, int)> dfs = [&](int v, int par) {
for (int i : g[v]) {
if (i == par) continue;
dfs(i, v);
sub[v] += sub[i];
}
};
dfs(0, -1);
for (int i = 0; i < n; i++)
sort(g[i].begin(), g[i].end(),
[&](int x, int y) { return sub[x] < sub[y]; });
function<void(int, int)> dfs2 = [&](int v, int par) {
for (int i : g[v]) {
if (i == par) continue;
dfs2(i, v);
}
res[v].push_back(2);
for (int i : g[v]) {
if (i == par) continue;
vector<Mint> a = res[i];
if (a.size() < k + 1) a.resize(a.size() + 1);
for (int j = a.size() - 1; j > 0; j--) a[j] += a[j - 1];
a[1]--;
int sz = min(k + 1, (int)(a.size() + res[v].size() - 1));
vector<Mint> new_res(sz);
for (int i = 0; i < (int)a.size(); i++) {
for (int j = 0; j < min(sz - i, (int)res[v].size()); j++) {
new_res[i + j] += a[i] * res[v][j];
}
}
swap(res[v], new_res);
}
};
dfs2(0, -1);
for (int i = 0; i < n; i++) res[i].resize(k + 1);
Mint ans = 0;
vector<Mint> dp(k + 1);
for (int i = 1; i < k + 1; i++) {
dp[i] = power(Mint(i), k);
for (int j = 1; j < i; j++)
dp[i] -= dp[j] * fact[i] * inv_fact[j] * inv_fact[i - j];
}
vector<vector<Mint>> to(n, vector<Mint>(k + 1));
function<void(int, int)> dfs3 = [&](int v, int par) {
to[v] = res[v];
for (int i : g[v]) {
if (i == par) continue;
dfs3(i, v);
for (int j = 1; j < k + 1; j++) {
to[v][j] -= res[i][j] * p[sub[v] - sub[i]];
if (j == 1)
to[v][j] -= (p[sub[i]] - 1) * p[sub[v] - sub[i]];
else if (j > 1)
to[v][j] -= res[i][j - 1] * p[sub[v] - sub[i]];
}
to[v][0] = 0;
}
assert(to[v][1] == 0);
};
dfs3(0, -1);
for (int i = 0; i < n; i++) {
if (i > 0) {
ans += (p[sub[i]] - 1) * (p[n - sub[i]] - 1);
for (int j = 1; j < k; j++) {
ans += res[i][j] * (p[n - sub[i]] - 1) * dp[j + 1];
}
}
for (int j = 1; j < k + 1; j++) {
ans += to[i][j] * p[n - sub[i]] * dp[j];
}
}
cout << ans;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
void print_width(long long x) {
std::cout << std::fixed;
std::cout << std::setprecision(x);
}
bool sortinrev(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first > b.first);
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return ((a * b) / gcd(a, b)); }
long long isPrime(long long n) {
if (n < 2) return 0;
if (n < 4) return 1;
if (n % 2 == 0 or n % 3 == 0) return 0;
for (long long i = 5; i * i <= n; i += 6)
if (n % i == 0 or n % (i + 2) == 0) return 0;
return 1;
}
long long nCr(long long n, long long r) {
if (r > n - r) r = n - r;
long long ans = 1;
long long i;
for (i = 1; i <= r; i++) {
ans *= n - r + i;
ans /= i;
}
return ans;
}
long long modexpo(long long x, long long p) {
long long res = 1;
x = x % mod;
while (p) {
if (p % 2) res = res * x;
p >>= 1;
x = x * x % mod;
res %= mod;
}
return res;
}
long long sti(string s) {
long long ans = 0;
long long p = 1;
for (long long i = s.size() - 1; i >= 0; i--) {
ans = (ans + ((long long)(s[i] - '0') * p) % mod) % mod;
p = (p * 10) % mod;
}
return ans;
}
void time() {}
const long long N = 1e6 + 5;
const long long despacito = 1e9 + 7;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long testcases;
cin >> testcases;
while (testcases--) {
long long n;
cin >> n;
set<long long> a;
for (long long i = 0; i < n; i++) {
long long elem;
cin >> elem;
a.insert(elem);
}
long long result = 0;
while (!a.empty()) {
long long m = *a.rbegin();
a.erase(m);
if (m % 2 == 0) {
result++;
a.insert(m / 2);
}
}
cout << result << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, a, b, k;
cin >> n >> h >> a >> b >> k;
for (int i = 0; i < k; i++) {
int ta, tb, fa, fb;
cin >> ta >> fa >> tb >> fb;
int ans;
int elevatorDistance, towerDistance, floorDistance, currentFloor;
bool skip = false;
if (ta == tb) {
cout << abs(fa - fb) << '\n';
skip = true;
}
if (!skip) {
if (fa <= b and fa >= a) {
elevatorDistance = 0;
currentFloor = fa;
} else {
elevatorDistance = min(abs(fa - a), abs(fa - b));
if (abs(fa - a) < abs(fa - b))
currentFloor = a;
else
currentFloor = b;
}
towerDistance = abs(ta - tb);
floorDistance = abs(currentFloor - fb);
ans = elevatorDistance + towerDistance + floorDistance;
cout << ans << '\n';
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char a[100001], b[100001], c[100001];
scanf("%s%s%s", a, b, c);
int i, j, al = strlen(a), bl = strlen(b), cl = strlen(c), flag = 1, fr = 0,
bck = 0;
while (flag) {
for (i = 0; i < al; i++) {
if (a[i] == b[0]) {
for (j = i; j < (i + bl); j++) {
if (a[j] != b[j - i]) break;
}
if (j == (i + bl)) {
i = j;
break;
}
}
}
if (i != al) {
for (; i < al; i++) {
if (a[i] == c[0]) {
for (j = i; j < (i + cl); j++) {
if (a[j] != c[j - i]) break;
}
if (j == (i + cl)) break;
}
}
}
if (i != al) {
if (flag % 2 == 1)
++fr;
else
++bck;
}
if (flag % 2 == 1) {
flag++;
reverse(a, a + al);
} else
flag = 0;
}
if ((fr == 1) && (bck == 1))
printf("both");
else if (fr == 1)
printf("forward");
else if (bck == 1)
printf("backward");
else
printf("fantasy");
return 0;
}
| 2 |
#include <bits/stdc++.h>
#include <typeinfo>
#include <stdlib.h>
#include <cxxabi.h>
using ll = long long;
using namespace std;
const int mod = 1e9 + 7;
const int N = 211;
int g[N][N], n;
ll p[N][N], ans = 0;
ll qpow(ll a, ll b) {
ll ans = 1;
while (b) {
if (b & 1)
ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
void solve() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (i != j)
g[i][j] = n << 1;
}
}
for (int i = 0, u, v; i < n - 1; ++i) {
scanf("%d%d", &u, &v);
g[u][v] = g[v][u] = 1;
}
ll inv2 = qpow(2, mod - 2);
ll invn = qpow(n, mod - 2);
//cerr << inv2 << " " << invn << "\n";
//cerr << "here" << endl;
for (int k = 1; k <= n; ++k) {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j)
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
}
for (int i = 1; i <= n; ++i)
p[i][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
p[i][j] = inv2 * (p[i - 1][j] + p[i][j - 1]) % mod;
}
}
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
for (int k = 1; k <= n; ++k) {
int x= (g[i][j] + g[i][k] - g[j][k]) >> 1;
ans = (ans + p[x][g[i][j] - x]) % mod;
}
}
}
ans = ans * invn % mod;
printf("%lld\n", ans);
}
int main() {
solve();
return 0;
}
//~ int main() {
//~ int a = 10, b = 11;
//~ long long c = 9982443533;
//~ __int128 k = 666;
//~ cout<<typeid(a).name()<<" => "<<abi::__cxa_demangle(typeid(a).name(), NULL, NULL, NULL)<<endl;
//~ cout<<typeid(ll(a + b)).name()<<" => "<<abi::__cxa_demangle(typeid(ll(a + b)).name(), NULL, NULL, NULL)<<endl;
//~ cout<<typeid(c).name()<<" => "<<abi::__cxa_demangle(typeid(c).name(), NULL, NULL, NULL)<<endl;
//~ cout<<typeid(k).name()<<" => "<<abi::__cxa_demangle(typeid(k).name(), NULL, NULL, NULL)<<endl;
//~ cout << typeid(k).name() << endl;
//~ return 0;
//~ }
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 51123987;
static const int LEN = 2e6 + 10;
int len[LEN], fail[LEN], num[LEN];
vector<unsigned int> nxt[LEN];
namespace fastIO {
bool IOerror = 0;
inline char nc() {
static char buf[10000], *p1 = buf + 10000, *pend = buf + 10000;
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, 10000, stdin);
if (pend == p1) {
IOerror = 1;
return -1;
}
}
return *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
inline void read(int &x) {
char ch;
int f = 1;
while (blank(ch = nc()))
;
while (ch == '-') f = -f, ch = nc();
if (IOerror) return;
for (x = ch - '0'; (ch = nc()) >= '0' && ch <= '9'; x = x * 10 + ch - '0')
;
x *= f;
}
inline void read(char *s) {
char ch;
while (blank(ch = nc()))
;
if (IOerror) return;
int i = 0;
for (; !blank(ch); s[i++] = ch, ch = nc())
;
s[i] = '\0';
}
} // namespace fastIO
using namespace fastIO;
int last, p, n;
char s[LEN];
int newnode() {
nxt[p].clear();
num[p] = 0;
fail[p] = 0;
return p++;
}
void init() {
p = 0;
len[0] = 0;
len[1] = -1;
newnode();
newnode();
fail[0] = 1;
n = 0;
s[n] = -1;
last = 1;
}
int getfail(int x) {
while (s[n - len[x] - 1] != s[n]) x = fail[x];
return x;
}
int get_nxt(int x, int y) {
for (int i = 0; i < nxt[x].size(); i++) {
if (nxt[x][i] / 100000000 == y) return nxt[x][i] % 100000000;
}
return 0;
}
void set_nxt(int x, int y, int z) {
for (int i = 0; i < nxt[x].size(); i++) {
if (nxt[x][i] / 100000000 == y) {
nxt[x][i] = y * 100000000 + z;
return;
}
}
nxt[x].push_back(y * 100000000 + z);
}
void add(char c) {
int x = c - 'a';
s[++n] = x;
last = getfail(last);
int cur = last;
int to = get_nxt(cur, x);
if (!to) {
int now = newnode();
len[now] = len[cur] + 2;
fail[now] = get_nxt(getfail(fail[cur]), x);
set_nxt(cur, x, now);
to = now;
num[now] = num[fail[now]] + 1;
}
last = to;
}
char ss[2000010];
int ans[2000010];
int main(int argc, char const *argv[]) {
init();
int m;
read(m);
read(ss + 1);
for (int i = 1; i <= m; i++) {
add(ss[i]);
ans[i] = num[last];
ans[i] = (ans[i - 1] + ans[i]) % mod;
}
init();
int tot = 0;
for (int i = m; i >= 1; i--) {
add(ss[i]);
tot = (1ll * ans[i - 1] * num[last] % mod + tot) % mod;
}
int nw = ans[m];
printf("%d\n", ((1ll * nw * (nw - 1) / 2 % mod - tot) % mod + mod) % mod);
return 0;
}
| 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.