solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, t, r, w;
cin >> m >> t >> r;
vector<int> v1, v2;
cin >> w;
for (int i = w - r; i < w; i++) v1.push_back(i);
int res = v1.size();
int ip = 0;
int cnt = 0;
for (int i = 0; i < v1.size(); i++) {
if (v1[i] + t >= w) cnt++;
}
if (cnt < r) ip = 1;
for (int i = 1; i < m; i++) {
cin >> w;
int sec = -1;
cnt = 0;
for (int i = 0; i < v1.size(); i++) {
if (v1[i] + t >= w) v2.push_back(v1[i]), sec = v1[i];
}
int diff = v2.size();
diff = r - diff;
for (int i = max(w - diff, sec + 1); i < w; i++) v2.push_back(i), res++;
for (int i = 0; i < v2.size(); i++)
if (v2[i] + t >= w) cnt++;
if (cnt < r) ip = 1;
v1 = v2;
v2.clear();
}
if (ip) {
cout << "-1\n";
return 0;
}
cout << res << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int u = 0; u < t; u++) {
int a[50], n, r;
bool g = false;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
r = abs(a[0] - a[1]);
for (int i = 1; i < n - 1; i++) {
if (r > (a[i + 1] - a[i])) r = a[i + 1] - a[i];
if (r == 0) {
cout << 0 << endl;
g = true;
break;
}
}
if (g == false) cout << r << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int k;
bool debug = false;
int main() {
long long t0, t1, t2, x1, x2, a1, a2;
cin >> t1 >> t2 >> x1 >> x2 >> t0;
if (t1 > t2) {
swap(t1, t2);
swap(x1, x2);
}
if (t0 == t1 && t0 == t2) {
printf("%lld %lld\n", x1, x2);
return 0;
}
if (t0 == t1) {
printf("%lld %lld\n", x1, 0LL);
return 0;
}
vector<pair<long long, long long>> ans;
for (a2 = 0; a2 <= x2; a2++) {
a1 = (t2 - t0) * a2 / (t0 - t1);
if (a1 > x1) a1 = x1;
if (a1 + a2 != 0) ans.push_back({a1, a2});
}
sort(ans.begin(), ans.end(),
[&](pair<long long, long long> x, pair<long long, long long> y) {
if ((t1 * x.first + t2 * x.second) * (y.first + y.second) ==
(t1 * y.first + t2 * y.second) * (x.first + x.second)) {
return x.first + x.second > y.first + y.second;
}
return (t1 * x.first + t2 * x.second) * (y.first + y.second) <
(t1 * y.first + t2 * y.second) * (x.first + x.second);
});
printf("%lld %lld\n", ans[0].first, ans[0].second);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int const INF = (int)1e9 + 1e3;
long long const INFL = (long long)1e18 + 1e6;
mt19937 tw(9450189);
uniform_int_distribution<long long> ll_distr;
long long rnd(long long a, long long b) {
return ll_distr(tw) % (b - a + 1) + a;
}
void solve() {
int n;
cin >> n;
vector<pair<pair<int, int>, pair<int, int>>> inp;
vector<pair<pair<int, int>, pair<int, int>>> pref = {
{{-INF, INF}, {-INF, INF}}};
for (int i = 0; i < n; ++i) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
inp.push_back({{x1, x2}, {y1, y2}});
pref.push_back(
{{max(pref.back().first.first, x1), min(pref.back().first.second, x2)},
{max(pref.back().second.first, y1),
min(pref.back().second.second, y2)}});
}
pair<pair<int, int>, pair<int, int>> suff = {{-INF, INF}, {-INF, INF}};
for (int i = n - 1; i >= 0; --i) {
pair<pair<int, int>, pair<int, int>> cur = {
{max(suff.first.first, pref[i].first.first),
min(suff.first.second, pref[i].first.second)},
{max(suff.second.first, pref[i].second.first),
min(suff.second.second, pref[i].second.second)}};
if (cur.first.first <= cur.first.second &&
cur.second.first <= cur.second.second) {
cout << cur.first.first << " " << cur.second.first << "\n";
return;
}
suff = {{max(suff.first.first, inp[i].first.first),
min(suff.first.second, inp[i].first.second)},
{max(suff.second.first, inp[i].second.first),
min(suff.second.second, inp[i].second.second)}};
}
}
int main() {
cout << setprecision(15) << fixed;
ios::sync_with_stdio(false);
cin.tie(nullptr);
int test_count = 1;
for (int test = 1; test <= test_count; ++test) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long a, long long b) { return b ? GCD(b, a % b) : a; }
long long LCM(long long a, long long b) { return a * b / GCD(a, b); }
const int N = 2e5 + 7;
const int mod = 1e9 + 7;
const long long inf = 1e18 + 7;
long long n, mOd;
long long a[N];
int main() {
cin >> n >> mOd;
for (int i = 1; i <= n; i++) cin >> a[i];
if (n > mOd) {
cout << "0\n";
return 0;
}
long long ans = 1;
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
ans = ans * abs(a[i] - a[j]) % mOd;
if (ans == 0) break;
}
if (ans == 0) break;
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 5;
int t, n, x;
int s[M];
int main() {
cin >> t;
while (t--) {
cin >> n >> x;
memset(s, 0, sizeof(s));
int flag = 0;
int ma = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
if (s[i] == x) flag = 1;
ma = max(ma, s[i]);
}
if (flag) {
cout << 1 << endl;
} else if (ma > x)
cout << 2 << endl;
else {
int w = x / ma;
if (x % ma == 0) {
cout << w << endl;
} else
cout << ++w << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int dis[N], vis[N];
vector<int> base;
vector<pair<int, int>> g[N];
void add(int b) {
for (int i = 0; i < (int)base.size() && b; ++i) {
b = min(b, b ^ base[i]);
}
if (b) {
base.push_back(b);
}
}
void dfs(int u, int d) {
dis[u] = d;
vis[u] = 1;
for (auto v : g[u]) {
if (!vis[v.first]) {
dfs(v.first, d ^ v.second);
} else {
add(dis[u] ^ dis[v.first] ^ v.second);
}
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
g[u].push_back({v, w});
g[v].push_back({u, w});
}
dfs(1, 0);
for (auto b : base) {
dis[n] = min(dis[n], dis[n] ^ b);
}
printf("%d\n", dis[n]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int tot = n, i = 1; tot > 1; tot -= 2, ++i) {
for (int j = 1; j <= m; ++j)
printf("%d %d\n%d %d\n", i, j, n - i + 1, m - j + 1);
}
if (n % 2 == 1) {
for (int j = 1; j <= m / 2; ++j)
printf("%d %d\n%d %d\n", n / 2 + 1, j, n / 2 + 1, m - j + 1);
if (m % 2 == 1) printf("%d %d\n", n / 2 + 1, m / 2 + 1);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10, N = 2000;
long long m, n, shroo, I[maxn], tmm, id[maxn], J[maxn], W[maxn], Su[maxn],
dp1[maxn], dp2[maxn];
vector<pair<long long, long long> > hel1;
vector<int> tmp, in[maxn], out[maxn];
bool amx(int i, int j) { return id[I[i]] > id[I[j]]; }
void dfs_1(int i) {
id[i] = 1;
for (auto A : out[i])
if (!id[A]) dfs_1(A);
tmp.push_back(i);
}
void dfs_2(int i) {
id[i] = tmm;
for (auto A : in[i])
if (!id[A]) dfs_2(A);
}
void scc() {
for (int y = 1; y <= n; y++)
if (!id[y]) dfs_1(y);
memset(id, 0, sizeof id);
reverse(tmp.begin(), tmp.end());
for (auto A : tmp)
if (!id[A]) tmm++, dfs_2(A);
}
long long gett(long long x) {
int st = 0, en = 2e4 + 5, md, i;
while (st <= en) {
md = st + ((en - st) >> 1);
if (2 * x >= md * (md + 1))
st = md + 1, i = md;
else
en = md - 1;
}
return (i + 1) * x - 1LL * i * (i + 1) * (i + 2) / 6;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int y = 1; y <= m; y++) {
cin >> I[y] >> J[y] >> W[y];
in[J[y]].push_back(I[y]);
out[I[y]].push_back(J[y]);
Su[y] = gett(W[y]);
}
scc();
tmp.clear();
cin >> shroo;
for (int y = 1; y <= m; y++)
if (id[I[y]] == id[J[y]]) dp2[id[I[y]]] += Su[y];
for (int y = 1; y <= m; y++)
if (id[I[y]] != id[J[y]]) tmp.push_back(y);
sort(tmp.begin(), tmp.end(), amx);
for (int y = 1; y <= n; y++) dp1[y] = dp2[y];
for (auto A : tmp)
dp1[id[I[A]]] = max(dp1[id[I[A]]], dp2[id[I[A]]] + W[A] + dp1[id[J[A]]]);
cout << dp1[id[shroo]];
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
long long t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
unordered_map<int, vector<pair<long long, long long>>> g;
pair<int, int> p[m];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(make_pair(b, i + 1));
g[b].push_back(make_pair(a, i + 1));
p[i] = make_pair(a, b);
}
unordered_map<int, int> res, pa;
for (auto i : g) {
if (!res.count(i.first)) {
for (auto j : i.second) {
if (!res.count(j.first)) {
if (!pa.count(j.second)) res[i.first]++;
res[j.first]++;
pa[j.second]++;
break;
}
}
}
}
unordered_map<int, int> rem;
for (int i = 1; i <= 3 * n; i++) {
if (!res.count(i)) {
rem[i]++;
}
}
if (rem.size() >= n) {
cout << "IndSet" << endl;
int x = 0;
for (auto i : rem) {
cout << i.first << " ";
x++;
if (x == n) break;
}
cout << endl;
} else {
cout << "Matching" << endl;
int x = 0;
for (auto i : pa) {
cout << i.first << " ";
x++;
if (x == n) break;
}
cout << endl;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
char c[200005];
int main() {
int i;
char t;
t = getchar(), n = 0;
while (t != '\n') c[++n] = t, t = getchar();
for (i = 1; i <= n; i++) c[n + i] = c[i];
int cnt = 1, ans = 1;
for (i = 2; i <= 2 * n; i++) {
if (c[i] != c[i - 1]) {
cnt++;
ans = max(cnt, ans);
ans = min(n, ans);
} else
cnt = 1;
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
int n;
cin >> n;
int a, b;
cin >> a >> b;
int mi = 0;
for (int i = 1; i < n; i++) {
mi = max(mi, min(a / i, b / (n - i)));
}
cout << mi;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char change(char a) { return (a == 'A' ? 'B' : 'A'); }
void solve() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
vector<int> p;
for (int i = 1; i < n; i += 2) p.push_back(a[i] - a[i - 1]);
long long int ans = 0LL, sum = 0LL;
for (int i = 0; i < p.size(); i++) {
sum += p[i];
if (sum < 0) {
sum = 0;
continue;
}
ans = max(ans, sum);
}
p.clear();
for (int i = 1; i < n - 1; i += 2) p.push_back(a[i] - a[i + 1]);
sum = 0LL;
for (int i = 0; i < p.size(); i++) {
sum += p[i];
if (sum < 0) {
sum = 0;
continue;
}
ans = max(ans, sum);
}
long long int esum = 0LL;
for (int i = 0; i < n; i += 2) esum += a[i];
if (ans) esum += ans;
cout << esum << endl;
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5, MOD = 1e9 + 7;
long long n, s, dp[19][19 * 9 + 5][2];
long long solve(long long pos, long long matches, long long sum, string num) {
if (sum < 0) return 0;
if (pos >= num.size()) return sum == 0;
if (dp[pos][sum][matches] != -1) return dp[pos][sum][matches];
long long dig = num[pos] - '0', ret = 0;
for (long long i = 0; i < 10; i++) {
if (!matches && i > dig) break;
ret += solve(pos + 1, matches | (i < dig), sum - i, num);
}
return dp[pos][sum][matches] = ret;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long ans = 0;
cin >> n >> s;
for (long long i = 1; i <= 163; i++) {
if (s + i > n) break;
memset(dp, -1, sizeof(dp));
long long p1 = solve(0, 0, i, to_string(n));
memset(dp, -1, sizeof(dp));
long long p2 = solve(0, 0, i, to_string(s + i - 1));
ans += p1 - p2;
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int ans = -1, n, k;
void call(long long int r, long long int d) {
long long int sk = k * (k + 1) / 2;
if (sk > r)
return;
else if (sk == r)
ans = max(ans, d);
else {
long long int x = r - k * (k - 1) / 2;
ans = max(ans, d);
}
}
int main() {
cin >> n >> k;
if (k > 1000000) {
cout << -1 << '\n';
return 0;
}
long long int d;
for (d = 1; d * d < n; d++) {
if (n % d == 0) {
call(n / d, d);
call(d, n / d);
}
}
if (d * d == n) call(d, d);
if (ans == -1) {
cout << -1 << '\n';
return 0;
}
for (int i = 1; i < k; i++) cout << ans * i << ' ';
cout << (n / ans - k * (k - 1) / 2) * ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5, Mod = 1e9 + 7;
int n, q, a[N], suf[N], pre[N], fa[N], val[N], s[N], pw[N], ans[N];
struct questions {
int l, r, id;
} que[N];
bool cmp(questions a, questions b) { return a.r < b.r; }
int father(int x) { return fa[x] == x ? x : fa[x] = father(fa[x]); }
void merge(int x, int y) {
fa[x] = y, pre[y] = pre[x];
int len = x - pre[x];
if ((len > 30 && s[y] > 0) || 1LL * s[x] + ((1LL * s[y]) << len) > Mod)
s[y] = Mod;
else
s[y] = (1LL * s[x] + ((1LL * s[y]) << len)) % Mod;
}
int calc(int l, int r) {
return ((1LL * suf[l] - 1LL * suf[r + 1] * pw[r - l + 1]) % Mod + Mod) % Mod;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]), s[i] = a[i], pre[i] = i - 1, fa[i] = i;
for (int i = 1; i <= q; ++i)
scanf("%d%d", &que[i].l, &que[i].r), que[i].id = i;
sort(que + 1, que + 1 + q, cmp);
for (int i = n; i; --i) suf[i] = (2LL * suf[i + 1] + a[i]) % Mod;
pw[0] = 1;
for (int i = 1; i <= n; ++i) pw[i] = ((1LL * pw[i - 1]) << 1) % Mod;
for (int i = 1, j = 0; i <= n; ++i) {
for (; pre[i] && s[i] >= 0; merge(pre[i], i))
;
val[i] = (1LL * val[pre[i]] + ((1LL * calc(pre[i] + 1, i)) << 1)) % Mod;
while (i == que[j + 1].r) {
int x = father(que[++j].l);
ans[que[j].id] =
((1LL * val[i] - 1LL * val[x] + 1LL * calc(que[j].l, x)) % Mod +
Mod) %
Mod;
}
}
for (int i = 1; i <= q; ++i) printf("%d\n", ans[i]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
long long a[N], dp[N], s[N];
vector<int> h[N];
int n;
void input() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int u, v;
for (int i = 1; i < n; i++) {
cin >> u >> v;
h[v].push_back(u);
h[u].push_back(v);
}
}
void dfs1(int x = 1, int p = -1, int q = 0) {
s[1] += q * a[x];
for (int i = 0; i < h[x].size(); i++)
if (h[x][i] != p) dfs1(h[x][i], x, q + 1);
}
void getdp(int x = 1, int p = -1) {
dp[x] += a[x];
for (int i = 0; i < h[x].size(); i++)
if (h[x][i] != p) {
getdp(h[x][i], x);
dp[x] += dp[h[x][i]];
}
}
void getans(int x = 1, int p = -1) {
if (x != 1) s[x] = s[p] + dp[1] - (2 * dp[x]);
for (int i = 0; i < h[x].size(); i++)
if (h[x][i] != p) getans(h[x][i], x);
}
int main() {
input();
dfs1();
getdp();
getans();
long long maxn = 0;
for (int i = 1; i <= n; i++) maxn = max(maxn, s[i]);
cout << maxn;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
char s[MAXN];
int ans[MAXN];
bool check(deque<int> &a, deque<int> &b, int n) {
if (a.size() + b.size() < n) return false;
assert(a.size() + b.size() == n);
for (int i = 0; i + 1 < (int)a.size(); i++) {
if (s[a[i]] > s[a[i + 1]]) return false;
}
for (int i = 0; i + 1 < (int)b.size(); i++) {
if (s[b[i]] > s[b[i + 1]]) return false;
}
if (!a.empty() && !b.empty() && s[a.back()] > s[b.front()]) return false;
return true;
}
void output(deque<int> &a, deque<int> &b, int n) {
for (auto &x : a) ans[x] = 1;
for (auto &x : b) ans[x] = 2;
for (int i = 1; i <= n; i++) printf("%d", ans[i]);
printf("\n");
}
void solve_test() {
int n;
scanf("%d", &n);
scanf("%s", s + 1);
bool done = false;
for (char d = '0'; d <= '9'; d++) {
deque<int> sol1, sol2;
int last_small = 0, first_big = n + 1;
for (int i = 1; i <= n; i++) {
if (s[i] < d) {
sol1.push_back(i);
last_small = i;
} else if (s[i] > d) {
sol2.push_back(i);
if (first_big == n + 1) first_big = i;
}
}
for (int i = last_small + 1; i <= n; i++) {
if (s[i] == d) sol1.push_back(i);
}
for (int i = 1; i < min(last_small, first_big); i++) {
if (s[i] == d) sol2.push_front(i);
}
if (check(sol1, sol2, n)) {
output(sol1, sol2, n);
done = true;
break;
}
}
if (!done) puts("-");
}
int main() {
int tests;
scanf("%d", &tests);
while (tests--) {
solve_test();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct P {
int x, y, tp, id;
} a[10005 * 2], c;
bool cmp1(P a, P b) { return a.y != b.y ? a.y < b.y : a.x < b.x; }
bool cmp2(P a, P b) {
return ((a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x)) < 0;
}
int n, ans[10005];
void work(int l, int r) {
if (l > r) return;
int p = min_element(a + l, a + r + 1, cmp1) - a;
swap(a[l], a[p]);
c = a[l];
sort(a + l + 1, a + r + 1, cmp2);
int cnt1 = 0, cnt2 = 0, k = r;
for (; !(c.tp != a[k].tp && cnt1 == cnt2);) {
if (c.tp == a[k].tp)
cnt1++;
else
cnt2++;
k--;
}
if (c.tp)
ans[a[k].id] = c.id;
else
ans[c.id] = a[k].id;
work(l + 1, k - 1);
work(k + 1, r);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= 2 * n; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
a[i].tp = (i > n);
a[i].id = (i > n ? i - n : i);
}
work(1, 2 * n);
for (int i = 1; i <= n; i++) printf("%d\n", ans[i]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T, class U>
inline void print(T first, U second) {
printsp(first);
println(second);
}
template <class T, class U, class V>
inline void print(T first, U second, V z) {
printsp(first);
printsp(second);
println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
vector<int> adj[20020];
vector<char> ch[20020];
vector<pair<int, int> > qu[20020];
int sz[20020], dep[20020];
string s;
int ans[20020], fa[20020];
char fc[20020];
void dfs(int u, int pa = 0) {
sz[u] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (pa == v) continue;
fc[v] = ch[u][i];
fa[v] = u;
dfs(v, u);
sz[u] += sz[v];
}
}
int flag, vst[20020];
int calc(int u, int v) {
++flag;
s.clear();
static int q[20020], qb, d[20020];
qb = 0;
while (u != v) {
s += fc[v];
v = fa[v];
q[qb++] = v;
vst[v] = flag;
}
reverse(s.begin(), s.end());
reverse(q, q + qb);
for (int i = 0; i < qb; i++) d[i] = i;
int res = qb - 1;
for (int i = 0; i < qb; i++) {
int cur = q[i], dep = d[i];
for (int j = 0; j < adj[cur].size(); j++) {
v = adj[cur][j];
if (vst[v] == flag) continue;
if (ch[cur][j] < s[dep]) {
res += sz[v];
}
if (ch[cur][j] == s[dep]) {
if (dep + 1 < s.size()) {
res++;
q[qb] = v;
d[qb++] = dep + 1;
vst[v] = flag;
}
}
}
}
return res;
}
int n;
void solve(int u, int pa = 0) {
for (int i = 0; i < qu[u].size(); i++) {
ans[qu[u][i].second] = calc(u, qu[u][i].first);
}
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == pa) continue;
fa[u] = v;
fa[v] = 0;
fc[u] = ch[u][i];
fc[v] = 0;
sz[u] = n - sz[v];
sz[v] = n;
solve(v, u);
fa[v] = u;
fa[u] = 0;
fc[v] = ch[u][i];
fc[u] = 0;
sz[v] = n - sz[u];
sz[u] = n;
}
}
int main() {
int q;
gn(n, q);
for (int i = 1; i < n; i++) {
int u, v;
char c;
gn(u, v);
c = getchar();
adj[u].push_back(v);
adj[v].push_back(u);
ch[u].push_back(c);
ch[v].push_back(c);
}
dfs(1);
for (int i = 1; i <= q; i++) {
int u, v;
gn(u, v);
qu[u].push_back(pair<int, int>(v, i));
}
solve(1);
for (int i = 1; i <= q; i++) println(ans[i]);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
template <typename first, typename second>
ostream& operator<<(ostream& os, const pair<first, second>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ",";
os << *it;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const multiset<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream& operator<<(ostream& os, const map<first, second>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello&... rest) {
cerr << arg << ' ';
faltu(rest...);
}
string s;
long long func(int l, int r) {
if (l > r) return 0;
string t;
for (int i = l; i <= r; ++i) t += s[i];
for (int i = 0; i < (int)t.size(); ++i) {
if (t[i] == '+') t[i] = ' ';
}
stringstream ss;
ss << t;
long long sum = 0;
while (ss >> t) {
for (int i = 0; i < (int)t.size(); ++i) {
if (t[i] == '*') t[i] = ' ';
}
stringstream tt;
tt << t;
long long x;
long long p = 1;
while (tt >> x) {
p *= x;
}
sum += p;
}
return sum;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> s;
s = "1*" + s;
s += "*1";
long long ans = 0;
for (int i = 0; i < (int)s.size(); ++i) {
for (int j = i + 1; j < (int)s.size(); ++j) {
if (s[i] == '*' && s[j] == '*') {
int le = -1, ri = (int)s.size();
for (int k = i; k >= 0; --k) {
if (s[k] == '+') {
le = k;
break;
}
}
for (int k = j; k < (int)s.size(); ++k) {
if (s[k] == '+') {
ri = k;
break;
}
}
long long a = func(le + 1, i - 1);
long long b = func(i + 1, j - 1);
long long c = func(j + 1, ri - 1);
long long temp = a * b * c;
long long temp1 = func(0, le - 1);
long long temp2 = func(ri + 1, (int)s.size() - 1);
temp += temp1 + temp2;
ans = max(ans, temp);
}
}
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int x = sqrt(n), i, j;
vector<vector<int> > ans;
vector<int> tmp;
for (i = n; i > 0; i -= x) {
for (j = i; j >= i - x + 1 && j > 0; j--) {
tmp.push_back(j);
}
reverse(tmp.begin(), tmp.end());
ans.push_back(tmp);
tmp.clear();
}
for (i = 0; i < ans.size(); i++) {
for (j = 0; j < ans[i].size(); j++) cout << ans[i][j] << " ";
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
#define endl '\n'
#define __ ios_base::sync_with_stdio(0);cin.tie(0);
#define fi first
#define se second
#define pb push_back
typedef long long int lli;
typedef pair<int,int> pii;
const int mod = (int)1e9+7;
const int maxn = (int)1e6+5;
void solve(){
int n;
cin >> n;
n*=2;
vector<int> a(n);
for(int i=0; i < n; i++) cin >> a[i];
sort(a.begin(),a.end());
multiset<int> s;
vector<pii> ans;
for(int i=0; i < n-1; i++){
ans.clear();
s.clear();
for(int x : a) s.insert(x);
int ini = a.back() + a[i];
int obj = a.back();
assert(s.find(a[i]) != s.end() && s.find(a.back()) != s.end());
s.erase(s.find(a[i]));
s.erase(s.find(a.back()));
ans.push_back({a[i],a.back()});
debug(s);
debug(i,a[i],a);
bool puedo = true;
while(!s.empty()){
int mayor = *s.rbegin();
int dif = obj - mayor;
debug(obj,mayor,dif);
debug(s);
s.erase(s.find(mayor));
if(s.find(dif) == s.end()){
puedo = false;
break;
}
ans.push_back({mayor,dif});
s.erase(s.find(dif));
obj = mayor;
}
if(puedo){
cout << "YES\n";
cout << ini << endl;
for(auto e : ans) cout << e.fi << " " << e.se << endl;
return;
}
}
cout << "NO\n";
}
int main(){__
int t;
cin >> t;
while(t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int pos[1000000 + 5];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &pos[i]);
int k = lower_bound(pos, pos + n, 500000) - pos;
if (k == n)
printf("%d\n", pos[n - 1] - 1);
else if (1000000 - pos[k] == 500000)
printf("499999\n");
else
printf("%d\n", max(pos[k - 1] - 1, 1000000 - pos[k]));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 60;
const long long Mod = 1e9 + 7;
long long pw(long long x, int k) {
long long re = 1ll;
for (; k; k >>= 1, x = x * x % Mod)
if (k & 1) (re *= x) %= Mod;
return re;
}
int n, m;
long long inv[maxn];
long long f[maxn][maxn], g[maxn][maxn], h[maxn][maxn];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < maxn; i++) inv[i] = pw(i, Mod - 2);
f[0][1] = 1ll;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
for (int a = 0; a <= i - 1; a++) {
int c = i - 1 - a;
for (int b = j; b <= a + 1; b++) g[i][j] += f[a][b] * f[c][j] % Mod;
for (int d = j + 1; d <= c + 1; d++) g[i][j] += f[a][j] * f[c][d] % Mod;
}
g[i][j] %= Mod;
for (int p = 0; p <= n - i; p++) {
for (int q = 1; q <= p + 1; q++) {
long long tmp = f[p][q];
if (!tmp) continue;
for (int t = 1; p + i * t <= n; t++) {
tmp = tmp * (g[i][j] + t - 1) % Mod * inv[t] % Mod;
h[p + i * t][q + j * t] += tmp;
}
}
}
for (int p = 0; p <= n; p++)
for (int q = 0; q <= p + 1; q++)
(f[p][q] += h[p][q] % Mod) %= Mod, h[p][q] = 0;
}
}
printf("%I64d\n", f[n][m] % Mod);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200005];
bool u[200005];
int q;
int typ[200005];
int qx[200005];
int qp[200005];
int gx;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
cin >> q;
for (int i = 1; i <= q; i++) {
cin >> typ[i];
if (typ[i] == 1) {
cin >> qp[i] >> qx[i];
} else {
cin >> qx[i];
}
}
for (int i = q; i >= 1; i--) {
if (typ[i] == 2) {
gx = max(gx, qx[i]);
} else {
if (!u[qp[i]]) {
u[qp[i]] = true;
a[qp[i]] = max(qx[i], gx);
}
}
}
for (int i = 1; i <= n; i++) {
if (!u[i]) {
a[i] = max(a[i], gx);
}
cout << a[i] << ' ';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
for (; b; a %= b, swap(a, b))
;
return a;
}
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
vector<pair<int, int>> a(n * m);
for (int i = 0; i < n * m; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a.begin(), a.end());
int ans = 0;
vector<vector<pair<int, int>>> v(n, vector<pair<int, int>>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
v[i][j] = a[i * m + j];
for (int k = 0; k < j; k++) {
if (v[i][k].first != v[i][j].first && v[i][k].second < v[i][j].second)
ans++;
}
}
}
cout << ans << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
struct node {
int id;
long long val;
} a[N];
struct cmp1 {
bool operator()(const node &a, const node &b) {
if (a.val == b.val) return a.id > b.id;
return a.val > b.val;
}
};
struct cmp2 {
bool operator()(const node &a, const node &b) { return a.id < b.id; }
};
int n, tot, v[N];
int main() {
scanf("%d", &n);
priority_queue<node, vector<node>, cmp1> que;
for (int i = 1; i <= n; i++) {
node a;
a.id = i;
scanf("%d", &a.val);
que.push(a);
}
while (!que.empty()) {
node p = que.top();
que.pop();
if (que.empty()) {
a[++tot] = p;
break;
}
node q = que.top();
que.pop();
if (p.val == q.val)
q.val *= 2;
else
a[++tot] = p;
que.push(q);
}
sort(a + 1, a + tot + 1, cmp2());
printf("%d\n", tot);
for (int i = 1; i <= tot; i++) {
printf("%I64d ", a[i].val);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct dat {
int lim;
long long d, mx;
dat() {}
dat(int lim, long long d, long long mx) : lim(lim), d(d), mx(mx) {}
inline bool operator<(const dat& a) const { return lim < a.lim; }
};
vector<int> s;
struct seg {
int sz;
vector<int> tm;
vector<vector<dat> > d;
seg() {}
seg(int mx) {
sz = 1;
while (sz <= mx) sz <<= 1;
tm.resize(sz << 1);
d.resize(sz << 1);
}
void init() {
for (int i = (sz << 1) - 1; i >= 1; --i) {
if (i != 1) {
int p = i >> 1;
d[p].insert(d[p].end(), d[i].begin(), d[i].end());
}
d[i].push_back(dat(0, 0, 0));
sort(d[i].begin(), d[i].end());
for (int j = 0; j < (int)d[i].size() - 1; ++j) {
d[i][j + 1].d += d[i][j].d;
d[i][j + 1].mx += d[i][j].mx;
}
}
}
long long sum(int a, int b, int t, int i = 1, int l = 0, int r = -1) {
if (r == -1) r = sz;
long long res = 0;
if (a <= l && r <= b && tm[i]) {
t -= tm[i];
int p = lower_bound(d[i].begin(), d[i].end(), dat(t, -1, -1)) -
d[i].begin() - 1;
res += (d[i].back().d - d[i][p].d) * t;
res += d[i][p].mx;
tm[i] += t;
return res;
}
if (r - l == 1) {
res = min(d[i].back().d * t + s[i - sz], d[i].back().mx);
tm[i] = t;
return res;
}
int c = l + r >> 1;
tm[i << 1] = max(tm[i << 1], tm[i]);
tm[i << 1 | 1] = max(tm[i << 1 | 1], tm[i]);
if (a < c) res += sum(a, b, t, i << 1, l, c);
if (c < b) res += sum(a, b, t, i << 1 | 1, c, r);
if (a <= l && r <= b)
tm[i] = t;
else
tm[i] = 0;
return res;
}
};
int main() {
int n, q;
scanf("%d", &n);
seg d(n);
s.resize(n);
for (int i = 0; i < n; ++i) {
int m, g;
scanf("%d%d%d", &s[i], &m, &g);
d.d[d.sz + i].push_back(dat(g ? m / g : 1 << 30, g, m));
}
d.init();
scanf("%d", &q);
for (int qi = 0; qi < q; ++qi) {
int t, l, r;
scanf("%d%d%d", &t, &l, &r);
--l;
printf("%I64d\n", d.sum(l, r, t));
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int N = 2e5 + 5;
long long qpow(long long a, long long b) {
long long ans = 1;
for (; b; b >>= 1, a = a * a % mod)
if (b & 1) ans = ans * a % mod;
return ans;
}
long long fac[N], inv[N];
long long c(long long n, long long m) {
if (m > n || m < 0) return 0;
if (m == 0 || m == n) return 1;
return fac[n] * inv[m] % mod * inv[n - m] % mod;
}
int a[N];
int main() {
fac[0] = 1;
for (long long i = 1; i < N; i++)
fac[i] = fac[i - 1] * i % mod, inv[i] = qpow(fac[i], mod - 2);
int n, num = 0;
long long k;
scanf("%d%lld", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
a[0] = a[n];
for (int i = 1; i <= n; i++) num += a[i] != a[i - 1];
long long sum = 0;
for (long long i = 0; i <= num / 2; i++)
sum = (sum + c(num, i) * c(num - i, i) % mod * qpow(k - 2, num - 2 * i) %
mod * qpow(k, n - num)) %
mod;
sum = (qpow(k, n) - sum + mod) * qpow(2, mod - 2) % mod;
printf("%lld\n", sum);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
scanf("%lld%lld", &n, &k);
long long ans = 0;
n--;
for (int i = 0; i < k && n > 0; i++) {
ans += 2 * n - 1;
n -= 2;
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
unordered_set<int> s;
vector<int> v;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
v.push_back(x);
s.insert(x);
}
if (s.size() > k) {
cout << -1 << '\n';
return;
}
vector<int> beauty;
for (int x : s) beauty.push_back(x);
while (beauty.size() < k) beauty.push_back(1);
cout << (n * k) << '\n';
for (int i = 0; i < n; i++) {
for (int x : beauty) cout << x << ' ';
}
cout << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << std::fixed;
cout << std::setprecision(10);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
namespace mine {
long long qread() {
long long ans = 0, f = 1;
char c = getchar();
while (c < '0' or c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c and c <= '9') ans = ans * 10 + c - '0', c = getchar();
return ans * f;
}
void write(long long num) {
if (num < 0) putchar('-'), num = -num;
if (num >= 10) write(num / 10);
putchar('0' + num % 10);
}
void write1(long long num) {
write(num);
putchar(' ');
}
void write2(long long num) {
write(num);
putchar('\n');
}
template <typename T>
void chmax(T &x, const T y) {
x = (x > y ? x : y);
}
template <typename T>
void chmin(T &x, const T y) {
x = (x < y ? x : y);
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
bool IN(long long x, long long l, long long r) { return l <= x and x <= r; }
const int INF = 0x3f3f3f3f;
const int MOD = 998244353;
int mm(const int x) { return x >= MOD ? x - MOD : x; }
template <typename T>
void add(T &x, const int &y) {
x = (x + y >= MOD ? x + y - MOD : x + y);
}
long long qpower(long long x, long long e, int mod = MOD) {
long long ans = 1;
while (e) {
if (e & 1) ans = ans * x % mod;
x = x * x % mod;
e >>= 1;
}
return ans;
}
long long invm(long long x) { return qpower(x, MOD - 2); }
const int N = 2e5 + 10;
vector<int> to[N];
int cnt, blg[N];
vector<int> pt[N], backup[N];
int dfn[N], low[N], dfnid;
stack<int> sta;
bool insta[N];
void tarjan(int x) {
dfn[x] = low[x] = ++dfnid;
sta.push(x);
insta[x] = 1;
for (auto y : to[x])
if (!dfn[y])
tarjan(y), chmin(low[x], low[y]);
else if (insta[y])
chmin(low[x], dfn[y]);
if (low[x] == dfn[x]) {
cnt++;
while (1) {
int now = sta.top();
insta[now] = 0;
sta.pop();
blg[now] = cnt;
pt[cnt].push_back(now);
if (now == x) break;
}
backup[cnt] = pt[cnt];
}
}
int indeg[N];
int que[N];
void main() {
int n = qread(), m = qread();
for (int i = (1), I = (m); i <= I; i++) {
int x = qread(), y = qread();
to[x].push_back(y);
}
for (int rt = (1), I = (n); rt <= I; rt++)
if (!dfn[rt]) tarjan(rt);
for (int x = (1), I = (n); x <= I; x++)
for (auto y : to[x])
if (blg[x] != blg[y]) indeg[blg[y]]++;
int tou = 1, wei = 0;
for (int i = (1), I = (cnt); i <= I; i++)
if (!indeg[i]) que[++wei] = i;
int now = pt[que[tou]].back(), fm = que[tou];
tou++;
while (tou <= wei) {
if (((int)(pt[que[tou]]).size()) == 0) {
for (auto x : backup[que[tou]])
for (auto y : to[x]) {
indeg[blg[y]]--;
if (!indeg[blg[y]]) que[++wei] = blg[y];
};
tou++;
continue;
}
int t = pt[que[tou]].back();
printf("? %d %d\n", now, t);
fflush(stdout);
if (qread())
pt[que[tou]].pop_back();
else
pt[fm].pop_back(), swap(fm, que[tou]), now = t;
}
printf("! %d", now);
fflush(stdout);
}
}; // namespace mine
signed main() {
srand(time(0));
mine::main();
}
| 12 |
#include <bits/stdc++.h>
int main() {
int w, h, k, i = 1, sum = 0;
scanf("%d%d%d", &w, &h, &k);
while (i <= k) {
sum = sum + (2 * (w + h) - 4);
w = w - 4;
h = h - 4;
i++;
}
printf("%d", sum);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 5;
struct Tree {
int l, r, sum;
bool tag;
} tr[N * 3];
pair<int, int> f[N], g[N];
int val[N], v[N];
long long tot, ans;
inline void pushdown(int now) {
if (tr[now].tag) {
if (tr[now].l != tr[now].r) {
int mid = (tr[now].l + tr[now].r) >> 1, ch;
ch = now << 1;
tr[ch].tag ^= 1;
tr[ch].sum = mid - tr[now].l + 1 - tr[ch].sum;
++ch;
tr[ch].tag ^= 1;
tr[ch].sum = tr[now].r - mid - tr[ch].sum;
}
tr[now].tag = 0;
}
}
inline void update(int now) {
if (tr[now].l != tr[now].r)
tr[now].sum = tr[now << 1].sum + tr[(now << 1) + 1].sum;
}
inline void build(int now, int le, int ri) {
tr[now].l = le;
tr[now].r = ri;
if (le != ri) {
int mid = (le + ri) >> 1;
build(now << 1, le, mid);
build((now << 1) + 1, mid + 1, ri);
}
}
inline void reverse(int now, int le, int ri) {
if (le > ri) return;
if (tr[now].l == le && tr[now].r == ri) {
tr[now].tag ^= 1;
tr[now].sum = ri - le + 1 - tr[now].sum;
return;
}
pushdown(now);
int mid = (tr[now].l + tr[now].r) >> 1;
if (ri <= mid)
reverse(now << 1, le, ri);
else if (le > mid)
reverse((now << 1) + 1, le, ri);
else
reverse(now << 1, le, mid), reverse((now << 1) + 1, mid + 1, ri);
update(now);
}
inline int getans(void) { return tr[1].sum; }
inline int getans(int now, int pos) {
if (tr[now].l == tr[now].r) return tr[now].sum;
pushdown(now);
int mid = (tr[now].l + tr[now].r) >> 1;
if (pos <= mid)
return getans(now << 1, pos);
else
return getans((now << 1) + 1, pos);
}
int main(int argc, char **argv) {
int n, m, cnt, x, y;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &v[i]), val[i] = v[i];
sort(val + 1, val + n + 1);
cnt = unique(val + 1, val + n + 1) - val - 1;
for (int i = 1; i <= n; ++i)
v[i] = lower_bound(val + 1, val + cnt + 1, v[i]) - val;
sort(v + 1, v + n + 1);
build(1, 1, cnt);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &x, &y);
x = lower_bound(val + 1, val + cnt + 1, x) - val;
y = upper_bound(val + 1, val + cnt + 1, y) - val - 1;
f[i] = make_pair(x, y);
g[i] = make_pair(y, x);
}
sort(f + 1, f + m + 1);
sort(g + 1, g + m + 1);
for (int i = 1, j = 1, k = 1; i <= n; ++i) {
for (; j <= m && f[j].first <= v[i]; ++j)
reverse(1, f[j].first, f[j].second);
for (; k <= m && g[k].first < v[i]; ++k)
reverse(1, g[k].second, g[k].first);
tot = getans() - getans(1, v[i]);
ans += tot * (long long)(tot - 1) >> 1;
reverse(1, v[i], v[i]);
}
ans = n * (long long)(n - 1) * (n - 2) / 6 - ans;
printf("%I64d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
typedef struct point {
int start;
int end;
} point;
bool sort_cmp(const point& lhs, const point& rhs) {
if (lhs.end < rhs.end)
return true;
else
return false;
}
long long dp[1000006];
int main() {
long long i, j, k, l, n, m, a, t, s, x, y;
cin >> n;
for (i = 0; i < 1000006; i++) dp[i] = 100000000;
dp[0] = 0;
for (i = 0; i < 9; i++) dp[i + 1] = 1;
for (i = 10; i <= n; i++) {
x = i;
while (x > 0) {
y = x % 10;
x = x / 10;
dp[i] = min(dp[i], dp[i - y] + 1);
}
}
cout << dp[n] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef priority_queue<int, vector<int>, greater<int>()> heapMi;
const int NMAX = 1e6 + 1;
const int KMAX = 50 + 1;
const int MOD = 1e9 + 7;
const double PI = acos(-1);
const double EPS = 1e-9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int n;
cin >> n;
int a[n + 1], sum = 0, tmp = 0, Count = 0;
for (int i = 1; i <= n; i += 1) cin >> a[i], sum += a[i];
sort(a + 1, a + 1 + n, greater<int>());
for (int i = 1; i <= n; i += 1) {
if (sum >= tmp)
sum -= a[i], tmp += a[i], Count++;
else
break;
}
cout << Count;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, w, e, r, t = 0, y;
cin >> q >> w >> e;
for (r = 0; r < q; r++) {
cin >> y;
if (y == 1) {
if (w)
w--;
else
t++;
} else {
if (e)
e--;
else if (w)
w--;
else
t++;
}
}
cout << t;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
cout.tie(0);
int n, valore, s[100002], m, worm;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> valore;
if (i == 0)
s[1] = valore;
else
s[i + 1] = s[i] + valore;
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> valore;
cout << lower_bound(s, s + n, valore) - s << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++)
;
printf("%d\n", n + m - 1);
for (int i = 1; i <= n; i++) printf("%d %d\n", i, 1);
for (int i = 2; i <= m; ++i) cout << 1 << " " << i << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[200005];
int sum[2][200005];
int mm[4][200005];
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
sum[0][i] = sum[0][i - 1];
sum[1][i] = sum[1][i - 1];
if (s[i] == 'W') {
sum[0][i]++;
} else if (s[i] == 'S') {
sum[0][i]--;
} else if (s[i] == 'A') {
sum[1][i]--;
} else {
sum[1][i]++;
}
}
mm[0][n] = mm[1][n] = sum[0][n];
mm[2][n] = mm[3][n] = sum[1][n];
int xmi = min(0, sum[1][n]), ymi = min(0, sum[0][n]),
xma = max(0, sum[1][n]), yma = max(0, sum[0][n]);
for (int i = n - 1; i >= 0; i--) {
xmi = min(xmi, sum[1][i]);
ymi = min(ymi, sum[0][i]);
xma = max(xma, sum[1][i]);
yma = max(yma, sum[0][i]);
mm[0][i] = min(sum[0][i], mm[0][i + 1]);
mm[1][i] = max(sum[0][i], mm[1][i + 1]);
mm[2][i] = min(sum[1][i], mm[2][i + 1]);
mm[3][i] = max(sum[1][i], mm[3][i + 1]);
}
int w = xma - xmi + 1, h = yma - ymi + 1;
int ans1 = 2000000, ans2 = 2000000;
long long ans = 1e18;
xmi = ymi = xma = yma = 0;
for (int i = 1; i <= n; i++) {
xmi = min(xmi, sum[1][i]);
ymi = min(ymi, sum[0][i]);
xma = max(xma, sum[1][i]);
yma = max(yma, sum[0][i]);
ans1 = 2000000, ans2 = 2000000;
ans2 = min(ans2, max(xma, mm[3][i] - 1) - min(xmi, mm[2][i] - 1) + 1);
ans1 = min(ans1, max(yma, mm[1][i] - 1) - min(ymi, mm[0][i] - 1) + 1);
ans2 = min(ans2, max(xma, mm[3][i] + 1) - min(xmi, mm[2][i] + 1) + 1);
ans1 = min(ans1, max(yma, mm[1][i] + 1) - min(ymi, mm[0][i] + 1) + 1);
ans = min(ans, min((long long)ans1 * w, (long long)ans2 * h));
}
printf("%lld\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int dp[43][(1 << 7)][(1 << 7)];
int main() {
int nn, mm;
cin >> nn >> mm;
if (nn * mm == 1) {
cout << "0" << endl;
return 0;
}
n = min(nn, mm);
m = max(nn, mm);
int coun = 0;
int i, j, mask1, mask2, mask3;
for (i = 0; i < m; i++)
for (mask1 = 0; mask1 < (1 << n); mask1++)
for (mask2 = 0; mask2 < (1 << n); mask2++)
dp[i][mask1][mask2] = 1000000000;
for (mask1 = 0; mask1 < (1 << n); mask1++)
for (mask2 = 0; mask2 < (1 << n); mask2++) {
coun = 0;
for (j = 0; j < n; j++) {
bool ok = false;
ok |= ((mask1 >> j) & 1);
ok |= ((mask2 >> j) & 1);
ok |= ((mask1 >> (j + 1)) & 1);
if (j > 0) ok |= ((mask1 >> (j - 1)) & 1);
if (!ok) break;
coun += ((mask1 >> j) & 1);
coun += ((mask2 >> j) & 1);
}
if (j == n) dp[0][mask1][mask2] = coun;
}
for (i = 1; i < m - 1; i++)
for (mask1 = 0; mask1 < (1 << n); mask1++)
for (mask2 = 0; mask2 < (1 << n); mask2++)
for (mask3 = 0; mask3 < (1 << n); mask3++) {
coun = 0;
for (j = 0; j < n; j++) {
bool test = false;
test |= ((mask1 >> j) & 1);
test |= ((mask2 >> j) & 1);
test |= ((mask3 >> j) & 1);
test |= ((mask2 >> (j + 1)) & 1);
if (j > 0) test |= ((mask2 >> (j - 1)) & 1);
if (!test) break;
coun += ((mask3 >> j) & 1);
}
if (j == n)
dp[i][mask2][mask3] =
min(dp[i][mask2][mask3], dp[i - 1][mask1][mask2] + coun);
}
int rec = 1000000000;
for (mask1 = 0; mask1 < (1 << n); mask1++)
for (mask2 = 0; mask2 < (1 << n); mask2++) {
for (j = 0; j < n; j++) {
bool test = false;
test |= ((mask1 >> j) & 1);
test |= ((mask2 >> j) & 1);
test |= ((mask2 >> (j + 1)) & 1);
if (j > 0) test |= ((mask2 >> (j - 1)) & 1);
if (!test) break;
}
if (j == n) rec = min(rec, dp[m - 2][mask1][mask2]);
}
cout << n * m - rec << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
char m[11], digit[10] = {'0'}, digitcount(0);
scanf("%d%s", &n, &m);
while (n != 0) {
digit[digitcount++] = '0' + n % 10;
n /= 10;
}
sort(digit, digit + digitcount);
if (digit[0] == '0') {
for (int i = 1; i < digitcount; ++i) {
if (digit[i] != '0') {
digit[0] = digit[i];
digit[i] = '0';
break;
}
}
}
if (strcmp(m, digit) == 0)
cout << "OK" << endl;
else
cout << "WRONG_ANSWER" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 10;
long long inf = 1e18;
set<pair<long long, pair<int, int> > > s;
vector<pair<pair<int, int>, long long> > vec;
long long dp[2][maxn][maxn], arr[maxn][maxn];
long long ps[maxn][maxn];
int n, m, a, b;
bool mark[maxn][maxn];
void input() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> m >> a >> b;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> arr[i][j];
}
void cal_ps() {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
ps[i + 1][j + 1] = ps[i][j + 1] + ps[i + 1][j] - ps[i][j] + arr[i][j];
}
void cal_dp() {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) dp[0][i][j] = dp[1][i][j] = inf;
for (int j = 0; j < m; j++) {
deque<int> dq;
for (int i = 0; i < a; i++) {
while (!dq.empty() && arr[dq.back()][j] >= arr[i][j]) dq.pop_back();
dq.push_back(i);
}
dp[0][a - 1][j] = arr[dq.front()][j];
for (int i = a; i < n; i++) {
while (!dq.empty() && arr[dq.back()][j] >= arr[i][j]) dq.pop_back();
dq.push_back(i);
if (dq.front() == i - a) dq.pop_front();
dp[0][i][j] = arr[dq.front()][j];
}
}
for (int i = 0; i < n; i++) {
deque<int> dq;
for (int j = 0; j < b; j++) {
while (!dq.empty() && dp[0][i][dq.back()] >= dp[0][i][j]) dq.pop_back();
dq.push_back(j);
}
dp[1][i][b - 1] = dp[0][i][dq.front()];
for (int j = b; j < m; j++) {
while (!dq.empty() && dp[0][i][dq.back()] >= dp[0][i][j]) dq.pop_back();
dq.push_back(j);
if (dq.front() == j - b) dq.pop_front();
dp[1][i][j] = dp[0][i][dq.front()];
}
}
}
void init() {
for (int i = a - 1; i < n; i++)
for (int j = b - 1; j < m; j++) {
long long sum = ps[i + 1][j + 1] - ps[i + 1][j + 1 - b] -
ps[i + 1 - a][j + 1] + ps[i + 1 - a][j + 1 - b] -
a * b * dp[1][i][j];
s.insert({sum, {i - a + 1, j - b + 1}});
}
}
bool valid(int x, int y) {
if (mark[x][y]) return false;
int xx = max(0, x - a + 1), yy = max(0, y - b + 1);
for (int i = x + a - 1; i >= xx; i--)
for (int j = y + b - 1; j >= yy; j--) mark[i][j] = true;
return true;
}
int main() {
input();
cal_ps();
cal_dp();
init();
while (!s.empty()) {
auto tmp = *s.begin();
int x = tmp.second.first, y = tmp.second.second;
long long p = tmp.first;
if (valid(x, y)) vec.push_back({{x, y}, p});
s.erase(tmp);
}
cout << vec.size() << "\n";
for (auto tmp : vec) {
cout << tmp.first.first + 1 << " " << tmp.first.second + 1 << " "
<< tmp.second << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
#define ld long double
#define ll long long
#define ull unsigned long long
#define pb push_back
#define eb emplace_back
#define endl '\n'
using namespace std;
ll const N = 103;
void task_a() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
int c = 0;
for (int i = 0; i < n - 1; ++i) {
if (min(v[i], v[i + 1]) * 2 < max(v[i], v[i + 1])) {
int x = max(v[i], v[i + 1]);
while (min(v[i], v[i + 1]) * 2 < x) {
if (x % 2 != 0) {
x /= 2;
x++;
} else x /= 2;
c++;
}
}
}
cout << c << endl;
}
void task_b() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
int nm = n / 3;
vector<pair<int, int>> ans;
int c0 = 0, c1 = 0, c2 = 0;
for (int i = 0; i < n; ++i) {
int rem = v[i] % 3;
if (rem == 0)c0++;
else if (rem == 1)c1++;
else if (rem == 2)c2++;
}
ans.eb(c0, 0);
ans.eb(c1, 1);
ans.eb(c2, 2);
sort(ans.begin(), ans.end());
int c = 0;
while (true) {
if (ans.back().first == nm)break;
int dif = 0;
if (ans.back().first > nm) {
dif = ans.back().first - nm;
c += dif;
ans.back().first = nm;
}
for (int j = 0; j < ans.size(); ++j) {
if (ans[j].second == (ans.back().second + 1) % 3) {
ans[j].first += dif;
break;
}
}
sort(ans.begin(), ans.end());
}
cout << c << endl;
}
void task_c() {
int n;
cin >> n;
vector<ll> v(n);
map<ll, ll> mp;
for (int i = 0; i < n; ++i) {
cin >> v[i];
mp[v[i]]++;
}
map<ll, ll> res;
for (auto i : mp) {
res[mp[i.first]]++;
}
vector<pair<ll, ll>> a;
for (auto i : res) {
a.eb(i.first, i.second);
}
sort(a.rbegin(), a.rend());
ll minn = 1e18;
for (int i = 0; i < a.size(); ++i) {
ll cnt = 0;
for (int j = 0; j < i; ++j) {
ll k = a[j].first - a[i].first;
k *= a[j].second;
cnt += k;
}
for (int j = i + 1; j < a.size(); ++j) {
ll k = a[j].first;
k *= a[j].second;
cnt += k;
}
// cout << cnt << endl;
minn = min(minn, cnt);
}
cout << minn << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt;
tt = 1;
cin >> tt;
for (int i = 1; i <= tt; ++i) {
//task_a();
//task_b();
task_c();
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
int n, k;
cin >> n >> k;
long long s;
cin >> s;
long long f[25];
vector<int> v;
long long POWER[30];
POWER[0] = 1;
for (int i = 1; i < 30; i++) POWER[i] = POWER[i - 1] << 1;
f[0] = 1;
long long maxi = 0;
int x[30];
for (long long i = 1;; i++) {
long long temp = s / (1LL * i);
if (f[i - 1] <= temp)
f[i] = f[i - 1] * i, maxi = i;
else
break;
}
for (int i = 0; i < n; i++) cin >> x[i];
vector<long long> v1, v2;
map<long long, long long> cnt1[30], cnt2[30];
cnt1[0][0]++;
cnt2[0][0]++;
int fir = n / 2, sec = n - fir;
for (int i = 1; i < POWER[fir]; i++) {
vector<int> v;
for (int j = 0; j < fir; j++)
if (POWER[j] & i) v.push_back(x[j]);
for (int j = 0; j < POWER[((int)v.size())]; j++) {
long long sum = 0;
bool z = true;
for (int p = 0; z and p < ((int)v.size()); p++) {
if ((POWER[p] & j) and v[p] <= maxi)
sum += f[v[p]];
else if (POWER[p] & j)
z = false;
else
sum += v[p];
}
if (__builtin_popcount(j) > k) z = false;
if (z) cnt1[__builtin_popcount(j)][sum]++;
}
}
for (int i = 1; i < POWER[sec]; i++) {
vector<int> v;
for (int j = 0; j < sec; j++)
if (POWER[j] & i) v.push_back(x[j + fir]);
for (int j = 0; j < POWER[((int)v.size())]; j++) {
long long sum = 0;
bool z = true;
for (int p = 0; z and p < ((int)v.size()); p++) {
if ((POWER[p] & j) and v[p] <= maxi)
sum += f[v[p]];
else if (POWER[p] & j)
z = false;
else
sum += v[p];
}
if (__builtin_popcount(j) > k) z = false;
if (z) cnt2[__builtin_popcount(j)][sum]++;
}
}
long long ans = 0;
for (int i = 0; i <= k; i++) {
for (auto it : cnt1[i]) {
for (int j = k - i; j >= 0; j--) ans += it.second * cnt2[j][s - it.first];
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
long long binom[N][N];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
for (int i = 0; i < N; i++) {
binom[i][0] = binom[i][i] = 1;
for (int j = 1; j < i; j++)
binom[i][j] = binom[i - 1][j] + binom[i - 1][j - 1];
}
int n;
cin >> n;
vector<int> ans;
for (int i = 30; i > 0; i--) {
while (binom[i][8] <= n && n > 0) {
n -= binom[i][8];
ans.push_back(1);
}
ans.push_back(0);
}
reverse(ans.begin(), ans.end());
for (int i : ans) {
if (i == 0)
cout << 'a';
else
cout << 'b';
}
cout << " aaaaaaaab" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long f = 0, ans = 1;
for (int i = 2; i <= n; ++i) {
f += 12;
ans += f;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int k, p;
int f[7] = {1, 10, 100, 1000, 10000, 100000, 1000000};
int main() {
scanf("%d%d", &k, &p);
long long tot = 1, ans = 0;
while (tot <= k) {
long long x = tot, y = 0, m = 0;
while (x) {
m++;
y = y * 10 + x % 10;
x /= 10;
}
ans = (ans + tot * f[m] + y) % p;
tot++;
}
printf("%I64d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200005;
const long long MOD = 1e9 + 7;
void solve() {
long long x, y;
cin >> x >> y;
long long a[3];
a[0] = a[1] = a[2] = y;
long long tm = 0;
while (1) {
a[0] = min(x, a[1] + a[2] - 1);
tm++;
sort(a, a + 3);
if (a[0] == x) {
break;
}
}
cout << tm;
}
int32_t main() {
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, y;
char s[64], ans[64];
for (scanf("%d ", &n); n--;) {
gets(s);
if (sscanf(s, "R%dC%d", &x, &y) == 2) {
int k = 0;
while (y > 0) {
ans[k++] = y % 26 + 'A' - 1;
y /= 26;
if (ans[k - 1] == 'A' - 1) {
y--;
ans[k - 1] = 'Z';
}
}
for (int i = k - 1; i >= 0; i--) putchar(ans[i]);
printf("%d\n", x);
} else {
int i;
x = 0;
for (i = 0; s[i] >= 'A' && s[i] <= 'Z'; i++) x = x * 26 + s[i] - 'A' + 1;
printf("R%sC%d\n", s + i, x);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, num, val, pos;
long long int ans = 0;
vector<pair<int, int> > V;
cin >> n;
int arr[n], left[n], right[n];
for (i = 0; i < n; i++) {
cin >> num;
arr[i] = num;
left[i] = i - 1;
right[i] = i + 1;
V.push_back(make_pair(num, i));
}
sort(V.begin(), V.end());
for (i = 0; i < n; i++) {
val = V[i].first;
pos = V[i].second;
if (pos == 0 || pos == n - 1) continue;
ans += min(arr[left[pos]], arr[right[pos]]);
if (arr[pos] < arr[right[pos]]) {
right[left[pos]] = right[pos];
}
if (arr[pos] < arr[left[pos]]) {
left[right[pos]] = left[pos];
}
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void solve(int total, int alice_ques, int bob_ques, int assignment[]) {
sort(assignment, assignment + total);
int possible_complexities = assignment[bob_ques] - assignment[bob_ques - 1];
cout << possible_complexities << endl;
}
signed main() {
int total, alice_ques, bob_ques;
cin >> total >> alice_ques >> bob_ques;
int assignment[total];
for (int i = 0; i < total; i++) {
cin >> assignment[i];
}
solve(total, alice_ques, bob_ques, assignment);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
int nx[4] = {1, -1, 0, 0}, ny[4] = {0, 0, 1, -1};
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
void solve() {
long long n;
cin >> n;
vector<long long> A;
A.assign(n, 0);
set<long long> s;
bool vis[n];
memset(vis, false, sizeof(vis));
for (int i = 0; i < n; i++) {
s.insert(i + 1);
cin >> A[i];
}
sort((A).begin(), (A).end());
for (int i = 0; i < n; i++) {
if (s.count(A[i]) != 0) {
s.erase(A[i]);
vis[i] = true;
}
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (vis[i]) continue;
long long main = *(s.begin());
if (A[i] != main && A[i] / 2 + (A[i] & 1) <= main) {
cout << -1 << '\n';
return;
} else if (A[i] != main) {
cnt++;
}
s.erase(s.begin());
}
cout << cnt << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tt;
cin >> tt;
while (tt--) solve();
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
int main() {
int n, m, k;
long long a[100013], b[100013], c[100013], d[113];
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
scanf("%I64d", &a[i]);
scanf("%I64d", &b[i]);
scanf("%I64d", &c[i]);
}
long long ans = 0;
for (int i = 0; i < k; i++) {
cin >> d[i];
for (int j = 0; j < m; j++) {
if (a[j] <= d[i] && b[j] >= d[i]) {
ans += c[j] + d[i] - a[j];
}
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
clock_t clk = clock();
long long int i, j;
void solve(void);
long long int dp[100][100][100];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int t = 1;
cin >> t;
memset(dp, -1, sizeof(dp));
while (t--) solve();
return 0;
}
long long int compute(long long int n, long long int m, long long int k) {
if (dp[n][m][k] != -1) return dp[n][m][k];
if (n * m == k || k == 0) return 0;
long long int minh = 1000000000000000, minv = 1000000000000000, q, l;
for (q = 1; q <= k; ++q)
for (l = 1; l <= n - 1; ++l) {
long long int val = compute(l, m, q) + m * m + compute(n - l, m, k - q);
minh = ((minh) < (val) ? (minh) : (val));
}
for (q = 1; q <= k; ++q)
for (l = 1; l <= m - 1; ++l) {
long long int val = compute(n, l, q) + n * n + compute(n, m - l, k - q);
minv = ((minv) < (val) ? (minv) : (val));
}
return dp[n][m][k] = ((minh) < (minv) ? (minh) : (minv));
}
void solve() {
long long int n, m, k;
cin >> n >> m >> k;
cout << compute(n, m, k) << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n, m, rt, ans[N];
struct node {
int c, q;
} a[N];
bool cmp(node x, node y) { return (x.q == y.q) ? (x.c < y.c) : (x.q > y.q); }
struct FHQTreap {
int val[N], cnt[N], lazy[N][2], dat[N], ch[N][2];
void pushdown(int x) {
int lc = ch[x][0], rc = ch[x][1];
if (lazy[x][0]) {
cnt[lc] += lazy[x][0];
lazy[lc][0] += lazy[x][0];
cnt[rc] += lazy[x][0];
lazy[rc][0] += lazy[x][0];
lazy[x][0] = 0;
}
if (lazy[x][1]) {
val[lc] -= lazy[x][1];
lazy[lc][1] += lazy[x][1];
val[rc] -= lazy[x][1];
lazy[rc][1] += lazy[x][1];
lazy[x][1] = 0;
}
}
void split(int x, int k, int &lc, int &rc) {
if (!x) return (void)(lc = rc = 0);
pushdown(x);
if (val[x] <= k)
lc = x, split(ch[x][1], k, ch[x][1], rc);
else
rc = x, split(ch[x][0], k, lc, ch[x][0]);
}
int merge(int x, int y) {
if (!x || !y) return x + y;
pushdown(x);
pushdown(y);
if (dat[x] < dat[y])
return ch[x][1] = merge(ch[x][1], y), x;
else
return ch[y][0] = merge(x, ch[y][0]), y;
}
void ins(int x, int v) {
int y, z;
val[x] = v;
dat[x] = (rand() * 32768 + rand());
split(rt, v, y, z);
rt = merge(merge(y, x), z);
}
void dfs(int x, int &y, int c, bool flag) {
pushdown(x);
if (ch[x][0]) dfs(ch[x][0], y, c, flag);
if (ch[x][1]) dfs(ch[x][1], y, c, flag);
if (flag) {
int z;
val[x] -= c;
cnt[x]++;
ch[x][0] = ch[x][1] = 0;
split(y, val[x], y, z);
y = merge(merge(y, x), z);
}
}
} fhq;
int main() {
srand(1023);
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].c, &a[i].q);
scanf("%d", &m);
for (int i = 1, x; i <= m; i++) {
scanf("%d", &x);
fhq.ins(i, x);
}
sort(a + 1, a + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
int x, y, z, c = a[i].c;
fhq.split(rt, c - 1, x, y);
fhq.split(y, c * 2, y, z);
fhq.cnt[z]++;
fhq.lazy[z][0]++;
fhq.val[z] -= c;
fhq.lazy[z][1] += c;
rt = fhq.merge(x, z);
fhq.dfs(y, rt, c, 1);
}
fhq.dfs(rt, n, 0, 0);
for (int i = 1; i <= m; i++) printf("%d ", fhq.cnt[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
int a[maxn];
int ans[maxn];
int num[maxn];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
memset((ans), (-1), sizeof(ans));
memset((num), (0), sizeof(num));
memset((a), (0), sizeof(a));
scanf("%d", &a[0]);
int flag = 0;
for (int i = 1; i < m; i++) {
scanf("%d", &a[i]);
int temp = a[i] - a[i - 1];
if (temp <= 0) temp += n;
if (ans[a[i - 1]] == -1 || ans[a[i - 1]] == temp) {
ans[a[i - 1]] = temp;
} else {
flag = 1;
}
}
if (flag == 1) {
puts("-1");
continue;
}
for (int i = 1; i <= n; i++) {
if (ans[i] != -1) num[ans[i]]++;
}
for (int i = 1; i <= n; i++) {
if (num[i] > 1) {
flag = 1;
break;
}
if (num[i] == 0 && flag != 1) {
flag = 2;
}
}
if (flag == 1) {
puts("-1");
continue;
}
if (flag == 2) {
for (int i = 1; i <= n; i++) {
if (ans[i] == -1) {
for (int j = 1; j <= n; j++) {
if (num[j] == 0) {
ans[i] = j;
num[j] = 1;
break;
}
}
}
}
}
for (int i = 1; i < n; i++) {
printf("%d ", ans[i]);
}
printf("%d\n", ans[n]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " : " << a << '\n';
err(++it, args...);
}
const double PI = acos(-1.0);
vector<vector<int>> adj(2 * 100005);
bool vis[2 * 100005];
int depth[2 * 100005], subtree[2 * 100005];
long long int ans = 0;
int dfs(int u, int d) {
vis[u] = true;
int st = 0;
for (int x : adj[u]) {
if (!vis[x]) {
st += dfs(x, d + 1);
}
}
depth[u] = d;
subtree[u] = st;
return st + 1;
}
void cp() {
int n, k;
cin >> n >> k;
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(1, 0);
vector<int> v;
for (int i = 0; i < n; i++) v.push_back(i + 1);
sort(v.begin(), v.end(), [&](int a, int b) {
return depth[a] - subtree[a] > depth[b] - subtree[b];
});
for (int i = 0; i < k; i++) {
ans += depth[v[i]] - subtree[v[i]];
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
while (t--) {
cp();
}
return 0;
}
| 4 |
#include <iostream>
#include <ctime>
#include <cmath>
#include <vector>
#include <random>
#include <cstring>
#include <cstdlib>
using namespace std;
const int MAXN = 2e5 + 5;
// mt19937 rng(0);
int dp[MAXN];
char s[MAXN][65];
char ans[MAXN];
int res;
inline int count_bit(int x) {
int res = 0;
for (int i = 0; i < 31; ++i) {
res += !!(x & 1);
x >>= 1;
}
return res;
}
int main() {
srand(time(0));
int n, m, p;
cin >> n >> m >> p;
for (int i = 1; i <= n; ++i)
cin >> s[i];
for (int _ = 1; _ <= 50; ++_) {
// int t = rng() % n + 1;
int t = (rand() << 15 | rand()) % n + 1;
vector<int> bit;
memset(dp, 0, sizeof dp);
for (int i = 0; i < m; ++i)
if (s[t][i] == '1') bit.push_back(i);
p = bit.size();
for (int i = 1; i <= n; ++i) {
int mask = 0;
for (int j = 0; j < p; ++j)
mask |= ((s[i][bit[j]] - '0') << j);
++dp[mask];
}
for (int i = 0; i < p; ++i) {
for (int j = 0; j < (1 << p); ++j)
if (!((1 << i) & j)) {
dp[j] +=dp[(1 << i) | j];
}
}
for (int i = 0; i < (1 << p); ++i) {
if (dp[i] < (n + 1) / 2 || count_bit(i) < res) continue;
for (int j = 0; j < m; ++j) ans[j] = '0';
ans[m] = '\0';
for (int j = 0; j < p; ++j) {
ans[bit[j]] = '0' + ((i >> j) & 1);
}
res = count_bit(i);
}
}
cout << ans << endl;
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
vector<long long> adj[200005];
long long t[200005], ax[200005], ay[200005], n, m;
long long arr[1005][1005], rev[1005], sum[1005];
long long cur;
long long ans[200005];
void dfs(long long i) {
bool one, two, three;
one = two = three = 0;
if (t[i] == 1) {
if (rev[ax[i]] == arr[ax[i]][ay[i]]) {
one = true;
arr[ax[i]][ay[i]] = !arr[ax[i]][ay[i]];
sum[ax[i]]++;
cur++;
}
} else if (t[i] == 2) {
if (rev[ax[i]] ^ arr[ax[i]][ay[i]]) {
two = true;
arr[ax[i]][ay[i]] = !arr[ax[i]][ay[i]];
sum[ax[i]]--;
cur--;
}
} else if (t[i] == 3) {
three = true;
rev[ax[i]] ^= 1;
cur -= sum[ax[i]];
sum[ax[i]] = (m - sum[ax[i]]);
cur += sum[ax[i]];
}
ans[i] = cur;
for (auto &cv : adj[i]) {
dfs(cv);
}
if (one) {
arr[ax[i]][ay[i]] = !arr[ax[i]][ay[i]];
sum[ax[i]]--;
cur--;
} else if (two) {
arr[ax[i]][ay[i]] = !arr[ax[i]][ay[i]];
sum[ax[i]]++;
cur++;
} else if (three) {
rev[ax[i]] ^= 1;
cur -= sum[ax[i]];
sum[ax[i]] = (m - sum[ax[i]]);
cur += sum[ax[i]];
}
}
void solve() {
long long i, j, k, l, r, a, b, c, d, x, y, z;
cin >> n >> m >> k;
for (i = 1; i <= k; i++) {
cin >> t[i];
if (t[i] < 3) {
cin >> ax[i] >> ay[i];
} else {
cin >> ax[i];
}
if (t[i] == 4) {
adj[ax[i]].push_back(i);
} else {
adj[i - 1].push_back(i);
}
}
dfs(0);
for (i = 1; i <= k; i++) cout << ans[i] << endl;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, t = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') t = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * t;
}
const int N = 2e5 + 5;
const int M = 5005;
int n, m, a[N], pre[M], sz[M], g[M];
double Ans, f[M][M];
vector<int> G[M];
struct Node {
int l, r;
double v;
} p[N];
bool cmp(Node A, Node B) { return A.l ^ B.l ? A.l < B.l : A.r > B.r; }
void Get(int l, int r, int &t) {
for (int i = l; i <= r; i++) t = max(t, a[i]);
}
void DFS(int x) {
int l = p[x].l;
for (auto y : G[x]) {
Get(l, p[y].l - 1, g[x]), l = p[y].r + 1;
DFS(y), g[x] = max(g[x], g[y]);
}
Get(l, p[x].r, g[x]);
double tp[M] = {0}, v = p[x].v;
f[x][0] = 1;
for (auto y : G[x]) {
for (int i = 0; i <= sz[x]; i++)
for (int j = 0; j <= sz[y]; j++) {
int k = max(i, g[y] + j - g[x]);
tp[k] += f[x][i] * f[y][j];
}
sz[x] += sz[y];
for (int i = 0; i <= sz[x]; i++) f[x][i] = tp[i], tp[i] = 0;
}
sz[x]++;
for (int i = sz[x]; i >= 0; i--) {
f[x][i] = f[x][i] * (1 - v);
if (i) f[x][i] += f[x][i - 1] * v;
}
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= m; i++) scanf("%d%d%lf", &p[i].l, &p[i].r, &p[i].v);
p[0] = (Node){1, n, 0.0}, sort(p, p + m + 1, cmp);
for (int i = 0; i <= m; i++) {
int l = p[i].l;
for (int j = i + 1; j <= m && p[j].r <= p[i].r; j++)
if (p[j].l >= l) G[i].push_back(j), l = p[j].r + 1;
}
DFS(0);
for (int i = 0; i <= sz[0]; i++) Ans += (g[0] + i) * f[0][i];
printf("%.10lf", Ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 55;
const int MAX_R = MAX_N * 105;
const double eps = 1e-10;
int N, R;
int f[MAX_N], s[MAX_N], p[MAX_N];
double dp[MAX_N][MAX_R];
bool check(double mid) {
for (int i = N - 1; i >= 0; --i) {
for (int j = R + 1; j < MAX_R; ++j) {
dp[i + 1][j] = mid;
}
for (int j = 0; j <= R; ++j) {
double t1 = (dp[i + 1][j + f[i]] + f[i]) * p[i] / 100.0;
double t2 = (dp[i + 1][j + s[i]] + s[i]) * (100 - p[i]) / 100.0;
dp[i][j] = min(mid, t1 + t2);
}
}
return dp[0][0] - mid < -eps;
}
double bs(double l, double r) {
for (int i = 0; i < 100; ++i) {
double mid = (l + r) / 2.0;
if (check(mid))
r = mid;
else
l = mid;
}
return l;
}
void solve() {
double ans = bs(0.0, 5000000000.);
printf("%.10f\n", ans);
}
int main() {
scanf("%d%d", &N, &R);
for (int i = 0; i < N; ++i) {
scanf("%d%d%d", &f[i], &s[i], &p[i]);
}
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int kM = 4e4 + 5;
const int kN = 55;
int M, n, m, k;
long long T[kM << 3], tag[kM << 3], a[kN][kM], pre[kM], s[kM], f[kN][kM];
void Update(int cur) { T[cur] = std::max(T[cur << 1], T[cur << 1 | 1]); }
void PushTag(int cur) {
T[cur << 1] += tag[cur];
T[cur << 1 | 1] += tag[cur];
tag[cur << 1] += tag[cur];
tag[cur << 1 | 1] += tag[cur];
tag[cur] = 0;
}
void Build(int cur, int l, int r) {
if (l < r) {
int mid = (l + r) >> 1;
Build(cur << 1, l, mid);
Build(cur << 1 | 1, mid + 1, r);
Update(cur);
} else
T[cur] = s[l];
}
void Modify(int cur, int l, int r, int ql, int qr, long long v) {
if (l > qr || r < ql) return;
if (ql <= l && r <= qr)
T[cur] += v, tag[cur] += v;
else {
int mid = (l + r) >> 1;
PushTag(cur);
if (ql <= mid) Modify(cur << 1, l, mid, ql, qr, v);
if (qr > mid) Modify(cur << 1 | 1, mid + 1, r, ql, qr, v);
Update(cur);
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) scanf("%d", &a[i][j]);
for (int i = 1; i <= m + k; ++i) pre[i] = pre[i - 1] + a[1][i];
for (int i = 1; i <= m; ++i) f[1][i] = pre[i + k - 1] - pre[i - 1];
for (int i = 2; i <= n; ++i) {
for (int j = 1; j <= m + k; ++j) pre[j] = pre[j - 1] + a[i][j];
for (int j = 1; j <= m; ++j)
s[j] = pre[j + k - 1] - pre[std::max(k, j - 1)] + f[i - 1][j];
memset(tag, 0, sizeof(tag));
Build(1, 1, m);
for (int j = 1; j <= m; ++j) {
f[i][j] = T[1] + pre[j + k - 1] - pre[j - 1];
Modify(1, 1, m, j - k + 1, j, a[i][j]);
Modify(1, 1, m, j + 1, j + k, -a[i][j + k]);
}
}
long long ans = 0;
for (int i = 1; i <= m; ++i) ans = std::max(ans, f[n][i]);
printf("%lld", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 65;
const long long INF64 = 3e18;
int primes[maxn], top, is[maxn], mu[maxn];
long long ans[100005];
int cnt[61];
void seive() {
fill(mu, mu + maxn, 1);
mu[0] = 0;
for (int i = 2; i < maxn; i++) {
if (!is[i]) {
primes[top++] = i;
mu[i] = -1;
}
for (int j = 0; j < top && primes[j] * i < maxn; j++) {
is[primes[j] * i] = 1;
if (i % primes[j] == 0) {
mu[primes[j] * i] = 0;
break;
} else {
mu[primes[j] * i] = -mu[i];
}
}
}
}
long long mypow(long long a, int b) {
long long ret = 1;
long long c = a;
while (b) {
if (b & 1) {
if (ret < INF64 / c)
ret *= c;
else
return INF64;
}
b >>= 1;
if (b) {
if (c < INF64 / c)
c *= c;
else
return INF64;
}
}
return ret;
}
int work1(long long n, int h) {
int left = 1;
int right = 1e6;
if (h == 2) right = 1e9;
while (left < right) {
int mid = (left + right + 1) / 2;
if (mypow(mid, h) <= n)
left = mid;
else
right = mid - 1;
}
return left;
}
int main() {
seive();
int T;
scanf("%d", &T);
vector<pair<long long, int>> v;
for (int i = 1; i <= T; i++) {
long long temp;
cin >> temp;
ans[i] = temp - 1 - work1(temp, 2) - work1(temp, 3) - work1(temp, 5) + 3;
v.push_back({temp, i});
}
sort(v.begin(), v.end(), greater<pair<long long, int>>());
for (int i = 6; i <= 60; i++) cnt[i] = 1000;
int lim = 60;
for (auto p : v) {
for (int i = 6; i <= lim; i++) {
while (mypow(cnt[i], i) > p.first) cnt[i]--;
if (cnt[i] == 1) lim = i - 1;
}
for (int i = 6; i <= lim; i++) ans[p.second] += mu[i] * (cnt[i] - 1);
}
for (int i = 1; i <= T; i++) cout << ans[i] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, x;
cin >> n >> x;
long int arr[n];
for (long int i = 0; i < n; i++) {
cin >> arr[i];
}
sort(arr, arr + n);
long int arr_save[100000];
for (long int i = 0; i < 100000; i++) {
arr_save[i] = 0;
}
long int flag = 1;
for (long int i = 0; i < n; i++) {
arr_save[arr[i] - 1] += 1;
if (arr_save[arr[i] - 1] == 2) {
cout << 0;
flag = 0;
break;
}
}
if (flag == 1) {
long int fl = 0;
long int arr_2[100001];
for (long int i = 0; i < 100001; i++) {
arr_2[i] = 0;
}
for (long int i = 0; i < n; i++) {
long int val;
val = arr[i] & x;
if (val == arr[i]) {
arr_2[val] += 1;
} else {
if (arr_save[val - 1] != 0 && val != 0) {
cout << 1;
fl = 1;
break;
} else {
arr_2[val] += 1;
}
}
}
if (fl == 0) {
long int max1 = 0;
for (long int i = 0; i < 100001; i++) {
if (arr_2[i] > max1) {
max1 = arr_2[i];
}
}
if (max1 == 1) {
cout << -1;
} else {
cout << 2;
}
}
}
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define ya cout<<"YES\n"
#define nah cout<<"NO\n"
#define endl "\n"
#define md 1000000007ll
#define mdd 998244353ll
void solve()
{
int n;
cin>>n;
priority_queue<int,vector<int>,greater<int>> pq;
int d; int sum = 0;
for(int i=0;i<n;i++)
{
cin>>d;
if(d >= 0) {sum+=d; pq.push(d); continue;}
else{
sum += d;
if(sum < 0){
if(pq.size() > 0 && pq.top() < d) {
sum -= pq.top();
pq.pop();
pq.push(d);
}
else sum -=d;
}
else{
pq.push(d);
}
}
}
cout<<pq.size()<<endl;
}
int32_t main()
{
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void Read(T &x) {
x = 0;
int s = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') s = -1;
ch = getchar();
};
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
ch = getchar();
}
x *= s;
}
const int N = 1e6 + 10;
struct node {
int lson, rson, father, yu;
};
char ch[10];
node edge[N << 1];
int n, zhuang[N], tmp[N][2];
bool f[N];
int dfs(int now) {
if (edge[now].lson + edge[now].rson == 0) return zhuang[now];
if (edge[now].yu == 1)
zhuang[now] = (dfs(edge[now].lson) & (dfs(edge[now].rson)));
else if (edge[now].yu == 2)
zhuang[now] = (dfs(edge[now].lson) | (dfs(edge[now].rson)));
else if (edge[now].yu == 3)
zhuang[now] = (dfs(edge[now].lson) ^ (dfs(edge[now].rson)));
else
zhuang[now] = (!dfs(edge[now].lson));
return zhuang[now];
}
int yusuan(int x, int y, int yu) {
if (yu == 1)
return x & y;
else if (yu == 2)
return x | y;
else if (yu == 3)
return x ^ y;
else
return !x;
}
int dfs2(int now, int zh) {
if (now == 1) return zh;
if (tmp[now][zh]) return tmp[now][zh] - 1;
int tmp1;
if (edge[edge[now].father].lson == now)
tmp1 = yusuan(zh, zhuang[edge[edge[now].father].rson],
edge[edge[now].father].yu);
else if (edge[edge[now].father].rson == now)
tmp1 = yusuan(zh, zhuang[edge[edge[now].father].lson],
edge[edge[now].father].yu);
int k = dfs2(edge[now].father, tmp1);
tmp[now][zh] = k + 1;
return k;
}
void init() {
Read(n);
for (int i = 1; i <= n; i++) {
scanf(" %s ", ch);
if (ch[0] == 'I')
Read(zhuang[i]), f[i] = true;
else {
int x = 0, y = 0;
Read(x);
if (ch[0] == 'A')
Read(y), edge[i].yu = 1;
else if (ch[0] == 'O')
Read(y), edge[i].yu = 2;
else if (ch[0] == 'X')
Read(y), edge[i].yu = 3;
else
edge[i].yu = 4;
edge[i].lson = x;
edge[i].rson = y;
edge[x].father = i;
edge[y].father = i;
}
}
dfs(1);
for (int i = 2; i <= n; i++) tmp[i][zhuang[i]] = zhuang[1] + 1;
for (int i = 1; i <= n; i++) {
if (f[i]) {
int k = dfs2(i, !zhuang[i]);
putchar(k + '0');
}
}
}
int main() {
init();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
bool ch = true;
vector<int> v(26);
set<int> st;
for (int j = 0; j < s.length(); ++j) {
if (v[s[j] - 'a'] == 1) {
cout << "No\n";
ch = false;
break;
}
v[s[j] - 'a'] = 1;
st.insert(s[j] - 'a');
}
auto it2 = st.begin();
++it2;
for (auto it = st.begin(); it != st.end(), it2 != st.end(); ++it, ++it2) {
if ((*it) + 1 != (*it2)) {
if (ch) cout << "No\n";
ch = false;
break;
}
}
if (ch) cout << "Yes\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3 + 7;
int n;
int a[maxn], b[maxn];
long long solve() {
long long res = 0;
for (int i = 0; i < int(n); i++) {
long long sa = 0, sb = 0;
for (int j = i; j < int(n); j++) {
sa |= a[j];
sb |= b[j];
res = max(res, sa + sb);
}
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < int(n); i++) scanf("%d", &a[i]);
for (int i = 0; i < int(n); i++) scanf("%d", &b[i]);
printf("%lld\n", solve());
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, MOD = 1e9 + 7;
int ans = MOD;
int a, b, h, w, n;
vector<int> v;
inline void go(int ind, long long x, long long y) {
if (x >= a && y >= b) {
ans = min(ans, ind);
return;
}
if (ind >= v.size()) {
return;
}
if (ind >= ans) return;
int t = 0;
for (int i = ind; i < n && t < 34; i++)
if (v[i] == v[ind])
t++;
else
break;
for (int i = 0; i <= t; i++) {
if (i) x *= v[ind];
if (x >= a) {
if (y >= b) {
ans = min(ans, ind + i);
break;
}
for (int j = 0; j < t - i; j++) {
y *= v[ind];
if (y >= b) {
ans = min(ans, ind + i + j + 1);
break;
}
}
if (y < b) go(ind + t, x, y);
break;
}
long long p = y;
for (int j = 0; j < t - i; j++) {
y *= v[ind];
if (j == t - i - 1) go(ind + t, x, y);
if (y >= b) break;
}
if (i == t) go(ind + t, x, y);
y = p;
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int x;
cin >> a >> b >> h >> w >> n;
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(x);
}
sort(v.rbegin(), v.rend());
go(0, h, w);
swap(a, b);
go(0, h, w);
if (ans == MOD)
cout << -1;
else
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n + 1];
int ans = 1;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int m = 1;
for (int j = i; j < n - 1 and a[j] >= a[j + 1]; j++) m++;
for (int j = i; j > 0 and a[j] >= a[j - 1]; j--) m++;
ans = max(ans, m);
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = 3.1415926535897932384626433832795;
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T abs(T x) {
return x < 0 ? -x : x;
}
const int MAXN = 1200;
long long a[MAXN][MAXN];
long long ind[MAXN * MAXN];
int n, m;
long long stolb[MAXN][MAXN], n_stolb[MAXN];
long long b[MAXN][MAXN];
bool comp(int ind1, int ind2) {
int i1 = ind1 / m;
int j1 = ind1 - i1 * m;
int i2 = ind2 / m;
int j2 = ind2 - i2 * m;
return (a[i1][j1] > a[i2][j2]);
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
ind[i * m + j] = i * m + j;
}
}
sort(ind, ind + n * m, comp);
memset(b, 0, sizeof(long long) * MAXN * MAXN);
for (int i = 0; i < m; ++i) {
n_stolb[i] = 0;
}
long long maxmin = 0;
for (int k = 0; k < n * m; ++k) {
int x = ind[k] / m;
int y = ind[k] - m * x;
bool key = true;
for (int j = 0; j < n_stolb[y]; ++j) {
if (b[x][stolb[y][j]] == 0) {
b[x][stolb[y][j]] = 1;
b[stolb[y][j]][x] = 1;
} else {
maxmin = a[x][y];
key = false;
break;
}
}
if (!key) {
break;
}
stolb[y][n_stolb[y]] = x;
n_stolb[y]++;
}
cout << maxmin << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long siv[500005];
bool ans[500005];
void gen() {
for (long long i = 2; i <= 300005; i++) {
for (long long j = i + i; j <= 300005; j += i) {
siv[j]++;
}
}
}
int main() {
gen();
long long n, k;
cin >> n >> k;
long long cnt = 0;
long long m = -1;
ans[1] = 1;
for (long long i = 2; i <= n; i++) {
cnt += siv[i] + 1;
ans[i] = 1;
if (cnt >= k) {
m = i;
break;
}
}
if (m == -1) {
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
int tot = m;
for (long long i = 2; i <= m; i++) {
if (cnt == k) break;
if (!siv[i]) {
if (cnt - m / i < k) continue;
ans[i] = 0;
cnt -= m / i;
tot--;
}
}
for (long long i = m / 2 + 1; i <= m; i++) {
if (cnt == k) break;
if (!siv[i] && ans[i]) {
ans[i] = 0;
cnt--;
tot--;
}
}
cout << tot << endl;
for (long long i = 1; i <= m; i++) {
if (ans[i]) cout << i << " ";
}
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n, m, a[N];
double dp[N][N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dp[i][j] = (a[i] > a[j]);
for (int i = 1; i <= m; i++) {
int t1, t2;
scanf("%d%d", &t1, &t2);
for (int j = 1; j <= n; j++) {
dp[j][t1] = dp[j][t2] = (dp[j][t1] + dp[j][t2]) / 2;
dp[t1][j] = dp[t2][j] = (dp[t1][j] + dp[t2][j]) / 2;
}
dp[t1][t2] = dp[t2][t1] = 0.5;
}
double ans = 0;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) ans += dp[i][j];
printf("%.8lf", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> graph[100005];
int a[100005], b[100005];
vector<int> ans;
void dfs(int source, int parent, int oddlevel, int evenlevel, int depth) {
if (depth % 2 == 1)
a[source] ^= oddlevel;
else
a[source] ^= evenlevel;
if (a[source] != b[source]) {
a[source] ^= 1;
if (depth % 2 == 1)
oddlevel++;
else
evenlevel++;
oddlevel %= 2, evenlevel %= 2;
ans.push_back(source);
}
for (int i = 0; i < graph[source].size(); i++) {
int child = graph[source][i];
if (child == parent) continue;
dfs(child, source, oddlevel, evenlevel, depth + 1);
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
graph[x].push_back(y);
graph[y].push_back(x);
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i <= n; i++) cin >> b[i];
dfs(1, 0, 0, 0, 0);
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
int m, n, k, t, lt[N], rt[N], w[N], cnt[N], opt[N];
inline bool check(int u) {
memset(opt, 0, sizeof(opt));
for (int i = 1; i <= k; i++) {
if (w[i] <= u) continue;
opt[rt[i] + 1]--, opt[lt[i]]++;
}
int kt = 0;
for (int i = 1; i <= n; i++) {
opt[i] += opt[i - 1];
if (opt[i] > 0) kt++;
}
if (kt <= t) return 1;
return 0;
}
int main() {
cin >> m >> n >> k >> t;
t = (t - n - 1) / 2;
int x, c = 0;
for (int i = 1; i <= m; i++) scanf("%d", &x), cnt[x]++;
for (int i = 2e5; i >= 0; i--) cnt[i] += cnt[i + 1];
int l = 0, r = 2e5;
for (int i = 1; i <= k; i++) {
scanf("%d%d%d", <[i], &rt[i], &w[i]);
}
int pt = 0;
while (l <= r) {
int d = (l + r) >> 1;
if (check(d))
c = d, r = d - 1;
else
l = d + 1;
}
cout << cnt[c] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long startx, starty, endx, endy;
cin >> startx >> starty >> endx >> endy;
int n;
cin >> n;
string str;
cin >> str;
long long x = 0, y = 0, dx = endx - startx, dy = endy - starty;
for (int i = 0; i < str.size(); i++) {
if (str[i] == 'U')
y++;
else if (str[i] == 'D')
y--;
else if (str[i] == 'L')
x--;
else
x++;
}
long long l = 0, r = 1e15;
while (l < r) {
long long mid = l + r >> 1;
long long mod = mid % n;
long long tx = x * (mid / n), ty = y * (mid / n);
for (int i = 0; i < mod; i++) {
if (str[i] == 'U')
ty++;
else if (str[i] == 'D')
ty--;
else if (str[i] == 'L')
tx--;
else
tx++;
}
if (abs(dx - tx) + abs(dy - ty) <= mid)
r = mid;
else
l = mid + 1;
}
if (l == 1e15)
printf("%d", -1);
else
printf("%lld", l);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int tst;
int n, x, y, z;
const int BUBEN = 1000;
int dp[BUBEN][3];
int val[3];
bool ok[5];
int calc() {
memset(dp, 0, sizeof dp);
for (int i = 0; i < BUBEN; i++) {
for (int j = 0; j < 3; j++) {
memset(ok, 0, sizeof ok);
if (i == 0) {
dp[i][j] = 0;
continue;
}
for (int p = 0; p < 3; p++) {
if (j == p && j != 0) continue;
int ni = max(0, i - val[p]);
ok[dp[ni][p]] = true;
}
while (ok[dp[i][j]]) dp[i][j]++;
}
}
for (int per = 1; 2 * per < BUBEN; per++) {
bool ok = true;
for (int i = 100; i + per < BUBEN; i++) {
if (!ok) break;
for (int j = 0; j < 3; j++) {
if (dp[i][j] != dp[i + per][j]) {
ok = false;
break;
}
}
}
if (ok) return per;
}
return -1;
}
const int maxN = 3 * (int)1e5 + 10;
long long a[maxN];
void solve() {
cin >> n >> x >> y >> z;
val[0] = x;
val[1] = y;
val[2] = z;
int xr = 0;
int per = calc();
assert(per != -1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] >= 1000) {
a[i] = a[i] % per + per * ((100 + per - 1) / per);
}
xr ^= dp[a[i]][0];
}
if (xr == 0) {
cout << 0 << '\n';
} else {
int cnt = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
if ((xr ^ dp[a[i]][0]) == dp[max(0LL, a[i] - val[j])][j]) cnt++;
}
}
assert(cnt);
cout << cnt << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> tst;
while (tst--) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n1, n2, k, p, i;
string s1, s2;
int main() {
cin >> s1 >> s2;
n1 = s1.length();
n2 = s2.length();
if (n1 != n2) {
cout << "NO";
return 0;
}
for (i = 0; i <= n1 - 1; i++)
if (s1[i] != s2[n1 - 1 - i]) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 900 + 10;
int n, m, backE[maxN], par[maxN], moal[maxN], x;
vector<int> adj[maxN], adj2[maxN], leaf, mol[maxN];
vector<pair<int, int> > edg;
bool mark[maxN], markEdg[maxN][maxN];
void Dfs2(int v) {
mark[v] = true;
for (int i = 0; i < (int)adj2[v].size(); i++) {
int u = adj2[v][i];
if (!mark[u]) Dfs2(u);
}
if ((int)adj2[v].size() == 1) leaf.push_back(v);
return;
}
void Dfs(int v) {
mark[v] = true;
for (int i = 0; i < (int)adj[v].size(); i++) {
int u = adj[v][i];
if (!mark[u]) {
par[u] = v;
Dfs(u);
backE[v] += backE[u];
} else if (u != par[v] && !markEdg[v][u]) {
markEdg[v][u] = true;
markEdg[u][v] = true;
backE[v]++;
backE[u]--;
}
}
return;
}
void MoalDfs(int v) {
mark[v] = true;
moal[v] = x;
mol[x].push_back(v);
for (int i = 0; i < (int)adj[v].size(); i++) {
int u = adj[v][i];
if (!mark[u] && !markEdg[v][u]) MoalDfs(u);
}
return;
}
void MakeTree() {
Dfs(0);
for (int i = 0; i < n; i++) {
mark[i] = false;
for (int j = 0; j < n; j++) markEdg[i][j] = 0;
}
for (int i = 1; i < n; i++) {
if (backE[i] <= 0) {
edg.push_back({i, par[i]});
markEdg[i][par[i]] = true;
markEdg[par[i]][i] = true;
}
}
for (int i = 0; i < n; i++) {
if (!mark[i]) {
MoalDfs(i);
x++;
}
}
for (int i = 0; i < n; i++) mark[i] = false;
for (int i = 0; i < (int)edg.size(); i++) {
int u = moal[edg[i].first];
int v = moal[edg[i].second];
adj2[v].push_back(u);
adj2[u].push_back(v);
}
return;
}
int main() {
cin >> n >> m;
if (n == 2) {
cout << -1;
return 0;
}
for (int i = 0; i < m; i++) {
int v, u;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
MakeTree();
int s = 0;
for (int i = 0; i < x; i++)
if ((int)adj2[i].size() > 1) s = i;
Dfs2(s);
int ans = (int)leaf.size();
cout << (ans + 1) / 2 << endl;
ans /= 2;
vector<pair<int, int> > Got;
for (int i = 0; i < ans; i++) Got.push_back({leaf[i], leaf[i + ans]});
if ((int)leaf.size() % 2 == 1)
Got.push_back({leaf[ans * 2 - 1], leaf[ans * 2]});
for (int i = 0; i < (int)Got.size(); i++) {
int a = Got[i].first;
int b = Got[i].second;
if ((int)mol[a].size() > (int)mol[b].size()) swap(a, b);
cout << mol[a][0] + 1 << ' ';
int y = 0;
while (markEdg[mol[a][0]][mol[b][y]]) y++;
cout << mol[b][y] + 1 << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long c[65][65], m, k;
long long cal(long long x) {
long long i, j, res = 0, num = 0;
for (i = 62; i >= 0; i--) {
if (x & (1LL << i)) {
if (k - num >= 0)
res += c[i][k - num];
else
break;
num++;
}
}
return res;
}
int main() {
long long i, j, le, ri, mid, cnt, ans;
for (i = 0; i <= 64; i++) c[i][0] = 1;
for (i = 1; i <= 64; i++) {
for (j = 1; j <= i; j++) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
}
}
while (cin >> m >> k) {
le = 1;
ri = 1LL << 62;
while (le <= ri) {
mid = (le + ri) >> 1;
cnt = cal(2 * mid) - cal(mid);
if (m <= cnt) {
ans = mid;
ri = mid - 1;
} else
le = mid + 1;
}
cout << ans << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const long long MOD = 1e9 + 7;
int a[5005], b[5005], last[5005], first[5005], n;
int vals[5005];
int mem[5005];
int solve(int idx) {
if (idx == n) return 0;
int &ret = mem[idx];
if (ret != -1) return ret;
ret = solve(idx + 1);
if (idx == first[a[idx]] && vals[idx] > -1)
ret = max(vals[idx] + solve(last[idx] + 1), ret);
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
memset(first, 6000, sizeof first);
for (int i = 0; i < n; ++i) {
cin >> a[i];
b[a[i]]++;
first[a[i]] = min(first[a[i]], i);
}
map<int, int> mp;
for (int i = 0; i < n; ++i) {
if (i == first[a[i]]) {
mp.clear();
int val = 0, ok = 0, j = i;
while (j < n) {
if (mp[a[j]])
mp[a[j]]++;
else {
mp[a[j]] = 1;
val = val ^ a[j];
}
ok += (mp[a[j]] == b[a[j]]);
if (ok == mp.size()) break;
j++;
}
if (ok == mp.size()) {
vals[i] = val;
last[i] = j;
} else {
vals[i] = -1;
}
}
}
memset(mem, -1, sizeof mem);
cout << solve(0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename C>
ostream& operator<<(ostream& os, const vector<C>& v) {
for (__typeof((v).begin()) __it = (v).begin(); __it != (v).end(); __it++)
os << *(__it) << ' ';
return os;
}
const int inf = 0x3f3f3f3f;
const long long inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-5;
int main() {
string s;
cin >> s;
int res = 0;
reverse((s).begin(), (s).end());
bool fromback = false;
for (int i = 0; i < (int((s).size())) - 1; i++) {
if (s[i] == '0') {
if (fromback) {
res += 2;
} else {
res++;
}
} else {
if (fromback) {
res++;
} else {
res += 2;
fromback = true;
}
}
}
if (fromback) res++;
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
bool check(string &s, pair<string, pair<int, int> > a[], int n) {
for (int i = (0), _b = (n); i < (_b); ++i) {
string t = a[i].first;
int b = a[i].second.first;
int c = a[i].second.second;
int cnt = 0;
for (int j = (0), _b = (4); j < (_b); ++j) {
if (s[j] == t[j]) ++cnt;
}
if (cnt != b) return false;
cnt = 0;
for (int j = (0), _b = (4); j < (_b); ++j) {
for (int k = (0), _b = (4); k < (_b); ++k) {
if (j == k) continue;
if (s[j] == t[k]) ++cnt;
}
}
if (cnt != c) return false;
}
return true;
}
int main() {
int n;
cin >> n;
pair<string, pair<int, int> > a[n];
for (int i = (0), _b = (n); i < (_b); ++i)
cin >> a[i].first >> a[i].second.first >> a[i].second.second;
string ret = "";
int cnt = 0;
for (char c1 = '0'; c1 <= '9'; ++c1) {
for (char c2 = '0'; c2 <= '9'; ++c2) {
if (c1 == c2) continue;
for (char c3 = '0'; c3 <= '9'; ++c3) {
if (c3 == c1 || c3 == c2) continue;
for (char c4 = '0'; c4 <= '9'; ++c4) {
if (c4 == c1 || c4 == c2 || c4 == c3) continue;
string s = "";
s += c1;
s += c2;
s += c3;
s += c4;
if (check(s, a, n)) {
cnt++;
ret = s;
}
}
}
}
}
if (!cnt)
cout << "Incorrect data" << endl;
else if (cnt > 1)
cout << "Need more data" << endl;
else
cout << ret << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char numm[701];
int num[701];
long long dp[701][701][10][2];
int main() {
scanf("%s", numm);
int len = strlen(numm);
for (int i = 1; i <= len; ++i) num[i] = numm[i - 1] - '0';
for (int i = 0; i < 10; ++i) dp[0][0][i][0] = 1;
for (int i = 1; i <= len; ++i)
for (int j = 0; j < i; ++j)
for (int k = 1; k < 10; ++k)
for (int l = 0; l < 2; ++l)
for (int p = 0; p <= (l ? 9 : num[i]); ++p) {
dp[i][j + (p >= k)][k][l || (p < num[i])] += dp[i - 1][j][k][l];
dp[i][j + (p >= k)][k][l || (p < num[i])] %= 1000000007;
}
long long ans = 0;
for (int i = 1; i < 10; ++i)
for (int j = 1, p = 1; j <= len; ++j, p = (10ll * p + 1) % 1000000007) {
ans += p * (dp[len][j][i][0] + dp[len][j][i][1]);
ans %= 1000000007;
}
printf("%lld\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int ma1 = 3e5 + 5;
string no = "NO", yes = "YES";
const unsigned int MAX1 = 1000000007;
void f(int n) {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
int d = n / i;
for (int j = i + 1; j < sqrt(d); j++) {
if (d % j == 0) {
cout << yes << endl;
cout << i << " " << j << " " << d / j << endl;
return;
}
}
}
}
cout << no << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
f(n);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
map<long long int, long long int> mp;
vector<long long int> a(n);
for (auto &ele : a) {
cin >> ele;
if (ele == 0) mp[ele]++;
}
vector<vector<long long int> > latest(32, vector<long long int>(n, -1));
long long int i, j;
for (i = n - 1; i >= 0; i--) {
for (j = 0; j < 32; j++) {
if (a[i] & (1 << j)) {
latest[j][i] = i;
} else {
latest[j][i] = ((i + 1 < n) ? latest[j][i + 1] : -1);
}
}
}
for (i = 0; i < n; i++) {
priority_queue<pair<long long int, long long int>,
vector<pair<long long int, long long int> >,
greater<pair<long long int, long long int> > >
pq;
for (j = 0; j < 32; j++) {
if (latest[j][i] != -1) pq.push({latest[j][i], j});
}
if (pq.empty()) mp[0]++;
long long int val = 0;
while (!pq.empty()) {
long long int in = pq.top().first;
while (!pq.empty() && pq.top().first == in) {
val += (1 << pq.top().second);
pq.pop();
}
mp[val]++;
}
}
cout << mp.size() << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, f = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + (ch ^ '0');
ch = getchar();
}
return f ? x : -x;
}
const int N = 3e2 + 10, mod = 1e9 + 7;
int n, q, t, a[N], to[N], in[N], f[100010];
int main() {
n = read(), q = read(), t = read();
for (int i = (1), ed = (n); i <= ed; ++i) a[i] = read();
for (int i = (1), ed = (q); i <= ed; ++i) {
int u = read(), v = read();
++in[v];
to[u] = v;
}
while (q--) {
int u = 0;
for (int i = 1; i <= n && !u; ++i)
if (!in[i] && to[i]) u = i;
if (!u) {
puts("0");
return 0;
}
--in[to[u]];
a[to[u]] += a[u];
t -= a[u];
to[u] = 0;
if (t < 0) {
puts("0");
return 0;
}
}
f[0] = 1;
for (int i = (1), ed = (n); i <= ed; ++i)
for (int j = (a[i]), ed = (t); j <= ed; ++j)
f[j] = (f[j] + f[j - a[i]]) % mod;
printf("%d\n", f[t]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int powm(int a, long long x) {
if (x == 0) {
return 1;
} else {
if (x & 1LL) {
return (1LL * powm(a, x - 1LL) * a) % 1000000007;
} else {
int b = powm(a, x / 2LL);
return (1LL * b * b) % 1000000007;
}
}
}
long long a[100001];
int main() {
cin >> n;
bool b = 0;
bool b1 = 0;
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
if (a[i] != 1LL) {
b = 1;
}
if (a[i] % 2LL == 0LL) {
b1 = 1;
}
}
if (!b) {
cout << "0/1" << endl;
return 0;
}
if (!b1) {
int ans = 2;
for (int i = 0; i < n; i++) {
ans = powm(ans, a[i]);
}
ans = (1LL * ans * powm(2, 1000000007 - 2)) % 1000000007;
int st = ans;
ans--;
if (ans < 0) {
ans += 1000000007;
}
ans = (1LL * ans * powm(3, 1000000007 - 2)) % 1000000007;
cout << ans << '/' << st << endl;
} else {
int ans = 2;
for (int i = 0; i < n; i++) {
ans = powm(ans, a[i]);
}
ans = (1LL * ans * powm(2, 1000000007 - 2)) % 1000000007;
int st = ans;
ans++;
if (ans >= 1000000007) {
ans -= 1000000007;
}
ans = (1LL * ans * powm(3, 1000000007 - 2)) % 1000000007;
cout << ans << '/' << st << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
string str[40100];
int cal() {
int sum = 0;
int len = str[1].length();
for (int i = 0; i < len; i++) {
for (int j = 1; j < n; j++) {
if (str[j][i] != str[j + 1][i]) {
return sum;
}
}
sum++;
}
return sum;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> str[i];
}
cout << cal() << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int MAXN = 300;
int x[MAXN], y[MAXN];
int main() {
int n;
int i, j, k;
int ax, ay;
int t, min, max, ans;
scanf("%d", &n);
for (i = 0; i < n; ++i) scanf("%d%d", &x[i], &y[i]);
ans = 0;
for (i = 0; i < n; ++i)
for (j = i + 1; j < n; ++j) {
min = max = 0;
ax = x[j] - x[i];
ay = y[j] - y[i];
for (k = 0; k < n; ++k) {
t = ax * (y[k] - y[i]) - ay * (x[k] - x[i]);
if (t < min)
min = t;
else if (t > max)
max = t;
}
if (min < 0 && max > 0 && max - min > ans) ans = max - min;
}
printf("%d", ans >> 1);
if (ans & 1) printf(".5");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int mod = 1000000007;
const int inf = 1034567891;
const long long LL_INF = 1234567890123456789ll;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
template <typename T>
T GCD(T a, T b) {
long long t;
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
}
template <typename T>
string toString(T a) {
return to_string(a);
}
template <typename T>
void toInt(string s, T& x) {
stringstream str(s);
str >> x;
}
inline int add(int x, int y) {
x += y;
if (x >= mod) x -= mod;
return x;
}
inline int sub(int x, int y) {
x -= y;
if (x < 0) x += mod;
return x;
}
inline int mul(int x, int y) { return (x * 1ll * y) % mod; }
inline int powr(int a, long long b) {
int x = 1 % mod;
while (b) {
if (b & 1) x = mul(x, a);
a = mul(a, a);
b >>= 1;
}
return x;
}
inline int inv(int a) { return powr(a, mod - 2); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, h;
cin >> n >> h;
vector<pair<int, int> > vec;
int l, r;
for (int i = 0; i < n; i++) {
cin >> l >> r;
vec.push_back({l, r});
}
vector<long long> dis(n, 0);
for (int i = 1; i < n; i++) {
dis[i] = dis[i - 1];
dis[i] += vec[i].first - vec[i - 1].second;
}
long long ans = h;
for (int i = 0; i < n; i++) {
long long x = dis[i] + h;
int ind = lower_bound(dis.begin(), dis.end(), x) - dis.begin();
if (ind == n) ind--;
if (dis[ind] >= x) {
ind--;
}
long long r = vec[ind].second;
long long cur = r - vec[i].first;
cur += x - dis[ind];
ans = max(ans, cur);
}
cout << ans << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long sum;
int main() {
scanf("%d", &n);
sum += n;
while (n % 2 == 0) {
sum += n / 2;
n = n / 2;
}
k = 3;
for (k = 3; k * k <= n; k += 2) {
while (n % k == 0) {
sum += n / k;
n = n / k;
}
}
if (1 != n) sum += 1;
printf("%I64d\n", sum);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[200005];
int main() {
int n, a, b;
scanf("%d%d%d", &n, &a, &b);
scanf("%s", s + 1);
int l = strlen(s + 1);
s[0] = '.';
int ans = 0;
for (int i = 1; i <= l; i++) {
int mx = max(a, b);
if (s[i] == '*') continue;
if (a == 0 && b == 0) break;
if (a == 0) {
if (s[i - 1] == 'b') continue;
s[i] = 'b';
b--;
ans++;
} else if (b == 0) {
if (s[i - 1] == 'a') continue;
s[i] = 'a';
a--;
ans++;
} else {
if (mx == a) {
if (s[i - 1] == 'a') {
s[i] = 'b';
b--;
} else {
s[i] = 'a';
a--;
}
ans++;
} else if (mx == b) {
if (s[i - 1] == 'b') {
s[i] = 'a';
a--;
} else {
s[i] = 'b';
b--;
}
ans++;
}
}
}
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mn = 1e5, msq = 317, mod = 998244353;
int n, sq, k, a[mn + 3];
int inp[mn + 3], lw[msq + 3], rw[msq + 3];
int num[mn + 3];
int topw[mn + 3], secw[mn + 3];
long long f[mn + 3];
long long Sumf[msq + 3][2 * msq + 3];
int add[msq + 3];
void Add(int l, int r, int ad) {
l--;
r++;
if (inp[l] >= inp[r]) {
register int p = inp[l];
for (register int i = l + 1; i <= r - 1; i++) {
if (ad == 1)
Sumf[p][num[i]] -= f[i - 1];
else
Sumf[p][num[i] - 1] += f[i - 1];
num[i] += ad;
}
return;
}
register int p = inp[l];
for (register int i = l + 1; i <= rw[p]; i++) {
if (ad == 1)
Sumf[p][num[i]] -= f[i - 1];
else
Sumf[p][num[i] - 1] += f[i - 1];
num[i] += ad;
}
for (p = inp[l] + 1; p <= inp[r] - 1; p++) add[p] += ad;
p = inp[r];
for (register int i = lw[p]; i <= r - 1; i++) {
if (ad == 1)
Sumf[p][num[i]] -= f[i - 1];
else
Sumf[p][num[i] - 1] += f[i - 1];
num[i] += ad;
}
}
int main() {
cin >> n >> k;
sq = sqrt(n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
int totp = 0;
for (int i = 1; i <= n; i++) {
if ((i - 1) % sq == 0) lw[++totp] = i;
if (i % sq == 0 || i == n) rw[totp] = i;
inp[i] = totp;
}
inp[n + 1] = ++totp;
lw[totp] = rw[totp] = n + 1;
f[0] = 1;
for (register int i = 1; i <= n; i++) {
for (int nu = 0; nu <= 2 * sq; nu++) Sumf[inp[i]][nu] += f[i - 1];
Add(topw[a[i]] + 1, i, 1);
if (topw[a[i]]) Add(secw[a[i]] + 1, topw[a[i]], -1);
for (register int p = 1; p < inp[i]; p++)
if (add[p] <= k) f[i] += Sumf[p][min(2 * sq, k - add[p])], f[i] %= mod;
register int p = inp[i];
for (register int w = lw[p]; w <= i; w++)
if (num[w] + add[p] <= k) f[i] += f[w - 1], f[i] %= mod;
f[i] = (f[i] + mod) % mod;
secw[a[i]] = topw[a[i]];
topw[a[i]] = i;
}
cout << f[n];
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int kMaxN = 5000;
int dp[kMaxN][kMaxN];
int N;
string S;
int Dp(int i, int j) {
if (i > j) {
return 1;
}
int& r = dp[i][j];
if (r != -1) {
return r;
}
if (S[i] != S[j]) {
r = 0;
return r;
}
r = Dp(i + 2, j - 2);
return r;
}
struct Node {
int present_count;
Node* next[2];
Node() : present_count(0) { next[0] = next[1] = nullptr; }
};
bool Dfs(Node* node, int need_count, int& current_count, string* way) {
if (!node) {
return false;
}
assert(current_count < need_count);
current_count += node->present_count;
if (current_count >= need_count) {
return true;
}
way->push_back('a');
if (Dfs(node->next[0], need_count, current_count, way)) {
return true;
}
way->pop_back();
way->push_back('b');
if (Dfs(node->next[1], need_count, current_count, way)) {
return true;
}
way->pop_back();
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
memset(dp, -1, sizeof(dp));
cin >> S;
N = S.size();
int K;
cin >> K;
for (int len = 1; len <= N; ++len) {
for (int i = 0; i <= N - len; ++i) {
Dp(i, i + len - 1);
}
}
Node* root = new Node();
for (int i = 0; i < N; ++i) {
int idx = i;
Node* node = root;
for (int j = i; j < N; ++j) {
if (Dp(i, j) == 1) {
for (; idx <= j; ++idx) {
Node* next_node = node->next[S[idx] - 'a'];
if (!next_node) {
next_node = new Node();
node->next[S[idx] - 'a'] = next_node;
}
node = next_node;
if (idx == j) {
++node->present_count;
}
}
}
}
}
string result;
int current_count = 0;
Dfs(root, K, current_count, &result);
cout << result << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
string ss[500010];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) cin >> ss[i];
for (int i = n - 1; i >= 1; i--) {
int flag = 0, Size1 = ss[i].length(), Size2 = ss[i + 1].length();
for (int j = 0; j < Size1 && j < Size2; j++) {
if (ss[i][j] < ss[i + 1][j]) {
flag = 1;
break;
} else if (ss[i][j] > ss[i + 1][j]) {
ss[i] = ss[i].substr(0, j);
}
}
if (!flag) {
if (ss[i].length() > ss[i + 1].length()) ss[i] = ss[i].substr(0, Size2);
}
}
for (int i = 1; i <= n; i++) cout << ss[i] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 5;
int a[maxn];
int n, x;
int main() {
scanf("%d%d", &n, &x);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
int number = 0;
int flag = 0;
for (int i = 0; i < n; i++) {
if (a[i] < x) number++;
if (a[i] == x) flag = 1;
}
if (flag) x++;
printf("%d\n", x - number);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a[7][1003], pos[7][1003], ans[1003], k;
int maxi(int a, int b) { return (a > b) ? a : b; }
bool posi(int j, int i) {
for (int x = 1; x <= k; x++)
if (pos[x][j] < pos[x][i])
continue;
else
return 0;
return 1;
}
int main() {
int i, j, l, m, out;
cin >> n >> k;
for (i = 1; i <= k; i++)
for (j = 1; j <= n; j++) {
cin >> a[i][j];
pos[i][a[i][j]] = j;
}
for (i = 1; i <= n; i++) {
ans[a[1][i]] = 1;
for (j = 1; j <= n; j++)
if (posi(j, a[1][i])) ans[a[1][i]] = maxi(ans[a[1][i]], ans[j] + 1);
}
out = ans[1];
for (i = 2; i <= n; i++) out = maxi(out, ans[i]);
cout << out << endl;
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.