solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, m;
scanf("%d%d\n", &n, &m);
vector<set<int> > a(m);
for (int i = 0; i < n; i++) {
string s;
getline(cin, s);
for (int j = 0; j < m; j++) a[j].insert(s[j] - 'A');
}
long long e = 1;
for (int i = 0; i < m; i++) {
e *= 1LL * a[i].size();
e = e % 1000000007LL;
}
printf("%I64d\n", e);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int p[5007][5007];
int pre[5007];
int a, b, c;
int solve(int x, int y) {
int res = 0;
for (int k = 0; k <= x && k <= y; k++) {
int del = pre[k];
del = (1LL * del * p[x][k]) % 998244353;
del = (1LL * del * p[y][k]) % 998244353;
res = (res + del) % 998244353;
}
return res;
}
int main() {
scanf("%d%d%d", &a, &b, &c);
memset(p, 0, sizeof(p));
p[0][0] = 1;
for (int i = 1; i <= 5000; i++) {
p[i][0] = 1;
for (int j = 1; j <= i; j++)
p[i][j] = (p[i - 1][j - 1] + p[i - 1][j]) % 998244353;
}
memset(pre, 0, sizeof(pre));
pre[0] = 1;
for (int i = 1; i <= 5000; i++) pre[i] = (1LL * pre[i - 1] * i) % 998244353;
int ans = 1;
ans = (1LL * ans * solve(a, b)) % 998244353;
ans = (1LL * ans * solve(b, c)) % 998244353;
ans = (1LL * ans * solve(a, c)) % 998244353;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using ll = long long;
int const nmax = 100;
int const lgmax = 60;
int const modulo = 998244353;
struct Interval {
ll start;
int p;
bool operator<(Interval const &oth) const {
if (start != oth.start)
return start < oth.start;
else
return oth.p < p;
}
bool operator==(Interval const &oth) const {
return (start == oth.start && p == oth.p);
}
};
std::vector<Interval> transform(std::pair<ll, ll> aux) {
std::vector<Interval> sol;
ll x = aux.first;
ll y = aux.second;
for (int h = 0; h <= lgmax; h++)
if ((0 < (x & (1LL << h))) && (x + (1LL << h) <= y)) {
sol.push_back({x, h});
x += (1LL << h);
}
for (int h = lgmax; 0 <= h; h--)
if ((x + (1LL << h) - 1) <= y) {
sol.push_back({x, h});
x += (1LL << h);
}
return sol;
}
Interval combine(Interval a, Interval b) {
int pmax = std::max(a.p, b.p);
ll result = ((a.start >> pmax) ^ (b.start >> pmax)) << pmax;
return {result, pmax};
}
int main() {
int n, m;
std::cin >> n;
std::vector<std::pair<ll, ll>> v1, v2;
for (int i = 1; i <= n; i++) {
ll x, y;
std::cin >> x >> y;
v1.push_back({x, y});
std::vector<Interval> spart = transform({x, y});
}
std::cin >> m;
for (int i = 1; i <= m; i++) {
ll x, y;
std::cin >> x >> y;
v2.push_back({x, y});
std::vector<Interval> spart = transform({x, y});
}
std::vector<Interval> sol;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
std::vector<Interval> s1, s2;
s1 = transform(v1[i]);
s2 = transform(v2[j]);
std::vector<Interval> small;
for (int h = 0; h < s1.size(); h++) {
Interval base = s1[h];
int p = base.p;
ll bit = (1LL << p);
ll x = (v2[j].first >> p) << p;
ll y = (v2[j].second >> p) << p;
sol.push_back(combine(base, {x, 0}));
sol.push_back(combine(base, {y, 0}));
if (x + bit <= y) {
sol.push_back(combine(base, {x + bit, 0}));
sol.push_back(combine(base, {y - bit, 0}));
}
}
for (int h = 0; h < s2.size(); h++) {
Interval base = s2[h];
int p = base.p;
ll bit = (1LL << p);
ll x = (v1[i].first >> p) << p;
ll y = (v1[i].second >> p) << p;
sol.push_back(combine(base, {x, 0}));
sol.push_back(combine(base, {y, 0}));
if (x + bit <= y) {
sol.push_back(combine(base, {x + bit, 0}));
sol.push_back(combine(base, {y - bit, 0}));
}
}
}
std::sort(sol.begin(), sol.end());
ll last = 0;
ll result = 0;
for (int i = 0; i < sol.size(); i++) {
if (last <= sol[i].start) {
ll _count = (1LL << (sol[i].p));
result =
(result + 1LL * sol[i].start % modulo * (_count % modulo) % modulo +
((_count - 1) % modulo) * ((_count / 2) % modulo)) %
modulo;
last = sol[i].start + (1LL << sol[i].p);
}
}
std::cout << result;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int dp[200005], pind[200005], sdp[2000005];
int n;
int t[2 * 200005];
void modify(int p, int value) {
for (t[p += n] = value; p > 1; p >>= 1) t[p >> 1] = min(t[p], t[p ^ 1]);
}
int query(int l, int r) {
int res = 1e9 + 4;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res = min(res, t[l++]);
if (r & 1) res = min(res, t[--r]);
}
return res;
}
void test_case() {
cin >> n;
vector<pair<int, int>> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
n++;
a.push_back({1e9 + 5, 1e9 + 4});
sort(a.begin(), a.end());
vector<int> h(n);
for (int i = 0; i < n; i++) {
h[i] = a[i].first;
}
pind[0] = 0;
for (int i = 1; i < n; i++) {
int it = upper_bound(h.begin(), h.end(), a[i].second) - h.begin();
pind[i] = max(it, pind[i - 1]);
pind[i] = min(pind[i], i);
}
fill(dp, dp + n, 1e9 + 4);
for (int i = 0; i < n; i++) {
dp[i] = a[i].second;
int it = upper_bound(h.begin(), h.end(), a[i].second) - h.begin();
it--;
it = min(it, i - 1);
if (it >= 0) {
dp[i] = a[i].second + query(pind[it], it + 1);
}
modify(i, dp[i] - a[i].first);
}
map<int, vector<int>> mp, mps;
for (int i = 0; i < n; i++) {
int it = upper_bound(h.begin(), h.end(), a[i].second) - h.begin();
it--;
it = min(it, i - 1);
if (it >= 0) {
int req = dp[i] - a[i].second;
auto &vi = mp[req], &vs = mps[req];
int l = pind[it], r = it;
auto li = lower_bound(vi.begin(), vi.end(), l) - vi.begin();
auto ri = upper_bound(vi.begin(), vi.end(), r) - vi.begin();
sdp[i] = ((ri ? vs[ri - 1] : 0) - (li ? vs[li - 1] : 0) + mod) % mod;
} else {
sdp[i] = 1;
}
int la = 0;
if (mps[dp[i] - a[i].first].size()) {
la = mps[dp[i] - a[i].first].back();
}
mp[dp[i] - a[i].first].push_back(i);
mps[dp[i] - a[i].first].push_back((sdp[i] + la) % mod);
}
int ans = 0, ac = dp[n - 2];
for (int i = pind[n - 2]; i <= n - 2; i++) {
ac = min(ac, dp[i]);
}
for (int i = pind[n - 2]; i <= n - 2; i++) {
if (dp[i] == ac) {
ans = (ans + sdp[i]) % mod;
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
t = 1;
while (t--) {
test_case();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int m, n = 3, p[4], a[4];
int main() {
scanf("%d", &m);
for (int i = 0; i < n; i++) scanf("%d %d", &p[i], &a[i]);
int prvi = min(m - p[1] - p[2], a[0]);
m -= prvi;
int drugi = min(m - p[2], a[1]);
m -= drugi;
printf("%d %d %d\n", prvi, drugi, m);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int gi() {
char cc = getchar();
int cn = 0, flus = 1;
while (cc < '0' || cc > '9') {
if (cc == '-') flus = -flus;
cc = getchar();
}
while (cc >= '0' && cc <= '9') cn = cn * 10 + cc - '0', cc = getchar();
return cn * flus;
}
const int N = 2e5 + 5;
int n, q, idx, Id[N], w[N], dfn[N], dep[N], fa[N], top[N], sz[N], son[N];
vector<int> G[N];
struct node {
int u, v, f;
node(int _u = 0, int _v = 0, int _f = 0) { u = _u, v = _v, f = _f; }
void init() { u = 0, v = 0, f = 0; }
} tr[N << 2], fs;
void dfs1(int x) {
sz[x] = 1, dep[x] = dep[fa[x]] + 1;
for (int v : G[x]) {
dfs1(v), sz[x] += sz[v];
if (sz[v] >= sz[son[x]]) son[x] = v;
}
}
void dfs2(int x, int high) {
top[x] = high, dfn[x] = ++idx;
if (son[x]) dfs2(son[x], high);
for (int v : G[x])
if (v ^ son[x]) dfs2(v, v);
}
int LCA(int x, int y) {
while (top[x] != top[y]) {
if (dep[top[x]] < dep[top[y]]) swap(x, y);
x = fa[top[x]];
}
return (dep[x] > dep[y]) ? y : x;
}
int dis(int x, int y) { return dep[x] + dep[y] - 2 * dep[LCA(x, y)]; }
int a[10];
node merge(node x, node y) {
if (x.f || y.f) return node(-1, -1, 1);
a[0] = x.u, a[1] = x.v, a[2] = y.u, a[3] = y.v;
sort(a, a + 4);
do {
int d = dis(a[0], a[3]);
for (int i = 1; i < 4; ++i) d -= dis(a[i], a[i - 1]);
if (d == 0) return node(a[0], a[3], 0);
} while (next_permutation(a, a + 4));
return node(-1, -1, 1);
}
void build(int x, int l, int r) {
if (l == r) return tr[x] = node(Id[l], Id[l], 0), void();
int mid = (l + r) >> 1;
build((x << 1), l, mid), build((x << 1 | 1), mid + 1, r);
tr[x] = merge(tr[(x << 1)], tr[(x << 1 | 1)]);
}
void update(int x, int l, int r, int k, node u) {
if (l == r) return tr[x] = u, void();
int mid = (l + r) >> 1;
if (k <= mid)
update((x << 1), l, mid, k, u);
else
update((x << 1 | 1), mid + 1, r, k, u);
tr[x] = merge(tr[(x << 1)], tr[(x << 1 | 1)]);
}
bool check(node x) {
if (x.f) return 0;
if (fs.u == 0) {
fs = x;
return 1;
}
node t = merge(x, fs);
if (t.f) return 0;
fs = t;
return 1;
}
int query(int x, int l, int r) {
if (l == r) return (check(tr[x])) ? l : 0;
int mid = (l + r) >> 1;
if (check(tr[(x << 1)]))
return max(mid, query((x << 1 | 1), mid + 1, r));
else
return query((x << 1), l, mid);
}
void Change(int x, int y) {
update(1, 0, n - 1, w[x], node(y, y, 0)),
update(1, 0, n - 1, w[y], node(x, x, 0)), swap(w[x], w[y]);
}
signed main() {
n = gi();
int opt, x, y;
for (register int i = (1); i <= (n); ++i) x = gi(), Id[x] = i, w[i] = x;
for (register int i = (2); i <= (n); ++i) fa[i] = gi(), G[fa[i]].push_back(i);
dfs1(1), dfs2(1, 1), build(1, 0, n - 1);
q = gi();
while (q--) {
opt = gi();
if (opt == 1)
x = gi(), y = gi(), Change(x, y);
else
fs.init(), printf("%d\n", query(1, 0, n - 1) + 1);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> v(n);
for (auto &i : v) {
cin >> i;
}
sort(v.begin(), v.end());
string s;
cin >> s;
int changes = 0;
for (int i = 0; i + 1 < s.size(); ++i) {
changes += s[i] != s[i + 1];
}
int l = n - 1 - changes, r = n - 1 - changes;
char lstleft = s[0];
char lstright = s[0];
vector<pair<int, char> > ans;
ans.emplace_back(v[l], s[0]);
for (int j = 1; j < n; j++) {
if (s[j] != s[j - 1]) {
r++;
lstright = char('L' + 'R' - lstright);
ans.emplace_back(v[r], lstright);
} else {
l--;
lstleft = char('L' + 'R' - lstleft);
ans.emplace_back(v[l], lstleft);
}
}
for (auto i : ans) {
cout << i.first << " " << i.second << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
int t = 1;
while (t--) solve();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const int MOD = 1000000007;
const int inf = (1 << 30) - 1;
const ll INF = (1LL << 60) - 1;
template <typename T>
bool chmax(T &x, const T &y) {
return (x < y) ? (x = y, true) : false;
};
template <typename T>
bool chmin(T &x, const T &y) {
return (x > y) ? (x = y, true) : false;
};
struct io_setup {
io_setup() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
}
} io_setup;
template <typename T>
struct Node {
int l, r;
vector<T> v, s;
T base;
Node(int l, int r, const vector<T> &v) : l(l), r(r), v(v), base(-INF) {
s.resize(r - l + 1);
recalc();
}
void recalc() {
s[r - l] = 0;
for (int i = r - l - 1; i >= 0; i--) s[i] = s[i + 1] + v[i];
}
T get(int i) { return base == -INF ? v[i] : base; }
void update() {
for (int i = 0; i < r - l; i++) v[i] = get(i);
base = -INF;
}
void rmq(int R, const T &x) {
if (R <= l) return;
R -= l, chmin(R, r - l);
if (get(R - 1) >= x) return;
if (R == r - l) {
if (x >= get(0)) {
base = x;
return;
}
update();
for (int i = 0; i < R; i++) chmax(v[i], x);
recalc();
return;
}
update();
for (int i = 0; i < R; i++) chmax(v[i], x);
recalc();
}
T rsq(int L) {
if (L >= r) return 0;
L -= l, chmax(L, 0);
return base == -INF ? s[L] : base * (r - l - L);
}
};
template <typename T>
struct Data {
int n, m;
vector<Node<T>> nodes;
vector<T> s;
Data(int n, const vector<T> &v) : n(n) {
m = 0;
while (m * m < n) m++;
for (int i = 0; i < m; i++) {
int l = min(n, m * i), r = min(n, m * (i + 1));
nodes.emplace_back(l, r, vector<T>(begin(v) + l, begin(v) + r));
}
s.resize(m + 1), rmq(n, 0);
}
void rmq(int R, const T &x) {
for (auto &e : nodes) e.rmq(R, x);
s[m] = 0;
for (int i = m - 1; i >= 0; i--) s[i] = s[i + 1] + nodes[i].rsq(0);
}
T rsq(int L) {
int k = L / m + 1;
return s[k] + nodes[k - 1].rsq(L);
}
T get(int i) { return nodes[i / m].get(i % m); }
};
int main() {
int N, Q;
cin >> N >> Q;
vector<ll> a(N);
for (int i = 0; i < N; i++) cin >> a[i];
Data<ll> D(N, a);
while (Q--) {
int q, x;
ll y;
cin >> q >> x >> y;
if (q == 1) {
D.rmq(x, y);
} else {
x--;
int ans = 0;
while (x < N) {
int l = x - 1, r = N;
while (r - l > 1) {
int m = (l + r) / 2;
(D.get(m) <= y ? r : l) = m;
}
if (r == N) break;
x = r;
ll S = D.rsq(x);
l = x + 1, r = N + 1;
while (r - l > 1) {
int m = (l + r) / 2;
(D.rsq(m) >= S - y ? l : r) = m;
}
ans += l - x, x = l, y -= S - D.rsq(l);
}
cout << ans << '\n';
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct DSU {
DSU() = default;
DSU(int n) {
v.resize(n);
for (int i = 0; i < (int)n; i++) {
v[i] = make_pair(i, 1);
}
}
int getLeader(int a) {
while (v[a].first != a) {
a = v[a].first;
}
return a;
}
void merge(int a, int b) {
int A = getLeader(a);
int B = getLeader(b);
if (A == B) return;
int cntA = v[A].second;
int cntB = v[B].second;
if (cntA > cntB) {
v[B].first = A;
v[A].second += v[B].second;
} else {
v[A].first = B;
v[B].second += v[A].second;
}
}
bool isConnected() {
int commonLeader = getLeader(0);
for (int i = 1; i < (int)v.size(); i++) {
if (getLeader(i) != commonLeader) return false;
}
return true;
}
vector<pair<int, int>> v;
};
int main() {
int n, m;
cin >> n >> m;
DSU dsu(n);
int u, v;
for (int i = 0; i < (int)m; i++) {
cin >> u >> v;
u--;
v--;
dsu.merge(u, v);
}
string ans = (n == m && dsu.isConnected()) ? "FHTAGN!" : "NO";
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, min1, ras = INT_MAX;
cin >> n;
int a[n];
queue<int> v;
cin >> a[0];
min1 = a[0];
v.push(0);
for (int i = 1; i < n; i++) {
cin >> a[i];
if (min1 > a[i]) {
while (!v.empty()) {
v.pop();
}
v.push(i);
min1 = a[i];
} else {
if (min1 == a[i] && v.size() == 2) {
int kek = v.front();
v.pop();
ras = min(ras, v.front() - kek);
v.push(i);
}
if (min1 == a[i] && v.size() == 1) {
ras = i - v.front();
v.push(i);
}
}
}
int kol = v.front();
v.pop();
ras = min(v.front() - kol, ras);
cout << ras;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, done[1010000], st[1010000], mark[1010000];
int top, res, ans[101000], A[101000], T;
int main() {
for (scanf("%d", &T); T; T--) {
scanf("%d", &n);
memset(done, 0, sizeof(done));
memset(mark, 0, sizeof(mark));
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) mark[abs(A[i] - A[j])] = 1;
top = 0;
res = n;
for (int i = 1; i <= 1000000; i++)
if (mark[i]) st[++top] = i;
for (int i = 1; i <= 1000000 && res; i++) {
if (done[i]) continue;
ans[res--] = i;
for (int j = 1; j <= top && i + st[j] <= 1000000; j++)
done[i + st[j]] = 1;
}
printf("YES\n");
for (int i = n; i >= 1; i--) printf("%d ", ans[i]);
putchar('\n');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200009;
int n;
int x[222], y[222];
int N;
vector<int> belongline[222];
vector<int> linepointcnt2[222 * 222];
double tmp[222];
double M[222][222], MM[222][222];
double init[222 * 222][222];
double deg[15][222][222];
int net[222][222];
double caocao[222];
void init1() {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) deg[0][i][j] = M[i][j];
for (int i = 1; i < 15; i++) {
for (int j = 0; j < n; j++)
for (int jj = 0; jj < n; jj++)
for (int jjj = 0; jjj < n; jjj++)
deg[i][j][jj] += deg[i - 1][j][jjj] * deg[i - 1][jjj][jj];
}
for (int i = 0; i < N; i++) {
for (auto &j : linepointcnt2[i]) init[i][j] = 1.0 / linepointcnt2[i].size();
}
}
void Mul(int p) {
for (int i = 0; i < 15; i++) {
if (p & (1 << i)) {
for (int f = 0; f < n; f++) {
tmp[f] = 0;
for (int ff = 0; ff < n; ff++) tmp[f] += deg[i][f][ff] * caocao[ff];
}
for (int f = 0; f < n; f++) caocao[f] = tmp[f];
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%d%d", &x[i], &y[i]);
memset(net, -1, sizeof net);
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (net[i][j] != -1) continue;
linepointcnt2[N].push_back(i);
linepointcnt2[N].push_back(j);
for (int k = j + 1; k < n; k++) {
if ((y[i] - y[j]) * (x[j] - x[k]) == (y[j] - y[k]) * (x[i] - x[j]))
linepointcnt2[N].push_back(k);
}
for (int ii = 0; ii < (int)linepointcnt2[N].size(); ii++)
for (int jj = 0; jj < (int)linepointcnt2[N].size(); jj++)
net[linepointcnt2[N][ii]][linepointcnt2[N][jj]] =
net[linepointcnt2[N][jj]][linepointcnt2[N][ii]] = N;
for (int ii = 0; ii < (int)linepointcnt2[N].size(); ii++)
belongline[linepointcnt2[N][ii]].push_back(N);
N++;
}
}
for (int i = 0; i < n; i++) {
for (auto &j : belongline[i]) M[i][i] += 1.0 / linepointcnt2[j].size();
M[i][i] /= 1.0 * belongline[i].size();
for (int j = i + 1; j < n; j++) {
M[i][j] = 1.0 / belongline[i].size() / linepointcnt2[net[i][j]].size();
M[j][i] = 1.0 / belongline[j].size() / linepointcnt2[net[i][j]].size();
}
}
init1();
int q;
cin >> q;
while (q--) {
int t, m;
scanf("%d%d", &t, &m);
t--;
m--;
double Mx = 0.0;
memset(caocao, 0, sizeof caocao);
caocao[t] = 1;
Mul(m);
for (int i = 0; i < N; i++) {
double oo = 0.0;
for (int j = 0; j < n; j++) oo += init[i][j] * caocao[j];
if (oo > Mx) Mx = oo;
}
printf("%.12f\n", Mx);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
inline void Max(T &a, U b) {
if (a < b) a = b;
}
template <class T, class U>
inline void Min(T &a, U b) {
if (a > b) a = b;
}
inline void add(int &a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
vector<int> g[1005];
int d[1005], f[1005], cnt[1005], U[100005], V[100005], co[100005];
pair<int, int> c[2005][1005];
void dfs(int u, int first, int v, int second, int k) {
int i = c[v][second].first, from = c[v][second].second;
if (c[from][first].first == 0) {
c[from][first] = make_pair(i, v), c[v][first] = make_pair(i, from);
co[i] = first;
c[from][second] = make_pair(0, 0), c[v][second] = make_pair(0, 0);
c[u][second] = make_pair(k, v), c[v][second] = make_pair(k, u),
co[k] = second;
return;
}
dfs(v, second, from, first, i);
c[u][second] = make_pair(k, v), c[v][second] = make_pair(k, u),
co[k] = second;
}
int main() {
int T, i, j, k, m, n;
int a, b;
scanf("%d%d%d", &a, &b, &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &j, &k);
j--, k--;
d[j]++, f[k]++;
U[i] = j, V[i] = k + a;
}
int ans = 0;
for (i = 0; i < a; i++) Max(ans, d[i]);
for (i = 0; i < b; i++) Max(ans, f[i]);
printf("%d\n", ans);
for (i = 1; i <= m; i++) {
int u = U[i], v = V[i], ok = 0;
for (j = 1; j <= ans; j++) {
cnt[j] = 0;
if (c[u][j].first == 0 && c[v][j].first == 0) {
co[i] = j;
ok = 1;
c[u][j] = make_pair(i, v), c[v][j] = make_pair(i, u);
break;
}
}
if (ok) continue;
for (j = 1; j <= ans; j++) {
if (c[u][j].first) cnt[j] |= 1;
if (c[v][j].first) cnt[j] |= 2;
}
for (j = 1; j <= ans; j++)
if (cnt[j] != 3 && cnt[j]) break;
int first = j, second = -1;
for (j++; j <= ans; j++)
if (cnt[j] == 3 - cnt[first]) {
second = j;
break;
}
assert(second > 0);
if (cnt[first] == 1)
dfs(u, first, v, second, i);
else
dfs(u, second, v, first, i);
}
for (i = 1; i <= m; i++) printf("%d ", co[i]);
puts("");
return 0;
}
| 10 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int n, k;
int b[1010], done[1010], a[1010];
vector<pair<int, int> > od, ev;
unordered_map<int, int> rec[14];
const int max_siz = 13;
int mask1, mask2;
bool found;
int mask, sum, siz;
void dfs(int x) {
if (siz > max_siz) return;
if (found) return;
if (x == k) {
if (!siz) return;
if (rec[siz].count(sum)) {
mask1 = rec[siz][sum];
mask2 = mask;
found = 1;
return;
} else
rec[siz][sum] = mask;
return;
}
mask += (1 << x);
sum += b[x];
siz++;
dfs(x + 1);
mask -= (1 << x);
sum -= b[x];
siz--;
dfs(x + 1);
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < int(n); i++) cin >> b[i];
srand(7122);
random_shuffle(b, b + n);
for (int i = 0; i < int(n); i++) {
if (b[i] & 1)
od.push_back(make_pair(b[i], i));
else
ev.push_back(make_pair(b[i], i));
}
if (n == 2) {
if (b[0] == b[1]) {
cout << "YES" << '\n';
cout << 0 << " " << b[0] << '\n';
} else
cout << "NO" << '\n';
return 0;
}
if (n == 3) {
if (b[0] == b[1]) {
cout << "YES" << '\n';
cout << 0 << " " << b[0] << " " << b[2] - b[0] << '\n';
} else if (b[1] == b[2]) {
cout << "YES" << '\n';
cout << 0 << " " << b[1] << " " << b[0] - b[1] << '\n';
} else if (b[0] == b[2]) {
cout << "YES" << '\n';
cout << 0 << " " << b[0] << " " << b[1] - b[0] << '\n';
} else if ((b[0] + b[1] + b[2]) % 2 == 0) {
cout << "YES" << '\n';
cout << (-b[0] + b[1] + b[2]) / 2 << " " << (b[0] - b[1] + b[2]) / 2
<< " " << (b[0] + b[1] - b[2]) / 2 << '\n';
} else
cout << "NO" << '\n';
return 0;
}
if (ev.size() >= 3) {
cout << "YES" << '\n';
a[0] = (-ev[0].first + ev[1].first + ev[2].first) / 2;
a[1] = (ev[0].first - ev[1].first + ev[2].first) / 2;
a[2] = (ev[0].first + ev[1].first - ev[2].first) / 2;
done[ev[0].second] = 1;
done[ev[1].second] = 1;
done[ev[2].second] = 1;
int cur = 3;
for (int i = 0; i < int(n); i++) {
if (!done[i]) {
a[cur++] = b[i] - a[0];
}
}
for (int i = 0; i < int(n); i++) cout << a[i] << " ";
cout << '\n';
return 0;
}
if (ev.size() >= 1 && od.size() >= 2) {
cout << "YES" << '\n';
a[0] = (-od[0].first + od[1].first + ev[0].first) / 2;
a[1] = (od[0].first - od[1].first + ev[0].first) / 2;
a[2] = (od[0].first + od[1].first - ev[0].first) / 2;
done[od[0].second] = 1;
done[od[1].second] = 1;
done[ev[0].second] = 1;
int cur = 3;
for (int i = 0; i < int(n); i++) {
if (!done[i]) a[cur++] = b[i] - a[0];
}
for (int i = 0; i < int(n); i++) cout << a[i] << " ";
cout << '\n';
return 0;
}
k = min(n, 27);
dfs(0);
if (!found) {
cout << "NO" << '\n';
return 0;
}
for (int i = 0; i < int(k); i++) {
if ((mask1 & (1 << i)) == (1 << i) && (mask2 & (1 << i)) == (1 << i)) {
mask1 -= (1 << i);
mask2 -= (1 << i);
}
}
vector<int> v1, v2, v;
for (int i = 0; i < int(k); i++) {
if ((mask1 & (1 << i)) == (1 << i)) {
mask1 -= (1 << i);
v1.push_back(i);
done[i] = 1;
}
if ((mask2 & (1 << i)) == (1 << i)) {
mask2 -= (1 << i);
v2.push_back(i);
done[i] = 1;
}
}
for (int i = 0; i < int(v1.size()); i++) {
v.push_back(v1[i]);
if (i != v1.size() - 1) v.push_back(v2[i]);
}
cout << "YES" << '\n';
a[0] = 0;
for (int i = 0; i < int(v.size()); i++) a[i + 1] = b[v[i]] - a[i];
int cur = v.size() + 1;
for (int i = 0; i < int(n); i++) {
if (!done[i]) a[cur++] = b[i] - a[0];
}
for (int i = 0; i < int(n); i++) cout << a[i] << " ";
cout << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
void min_self(long long &a, long long b) { a = min(a, b); }
void max_self(long long &a, long long b) { a = max(a, b); }
long long add(long long x, long long y) { return (x + y) % MOD; }
long long sub(long long x, long long y) { return add(x, MOD - y); }
long long mul(long long x, long long y) { return (x * 1ll * y) % MOD; }
long long binpow(long long x, long long y) {
long long z = 1;
while (y > 0) {
if (y % 2 == 1) z = mul(z, x);
x = mul(x, x);
y /= 2;
}
return z;
}
long long inv(long long x) { return binpow(x, MOD - 2); }
const int MXN = 1e6 + 10;
long long fact[MXN];
void fac_pre() {
fact[0] = 1;
for (long long i = 1; i < MXN; i++) {
fact[i] = mul(fact[i - 1], i);
}
}
long long C(long long n, long long k) {
return mul(fact[n], inv(mul(fact[k], fact[n - k])));
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
const int MAXN = 2 * 1e5 + 10;
vector<int> bit(MAXN, 0);
int sump(int idx) {
int ret = 0;
for (++idx; idx > 0; idx -= idx & -idx) ret += bit[idx];
return ret;
}
int sum(int l, int r) { return sump(r) - sump(l - 1); }
void upd(int idx, int delta) {
for (++idx; idx < MAXN; idx += idx & -idx) bit[idx] += delta;
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
long long genRand(long long B) { return (unsigned long long)rng() % B; }
void solve() {
int n, k;
cin >> n >> k;
string second;
cin >> second;
int INF = 1e7;
vector<int> nxt(n);
nxt[n - 1] = INF;
for (int i = n - 2; i >= 0; i--) {
if (second[i + 1] == '1')
nxt[i] = i + 1;
else
nxt[i] = nxt[i + 1];
}
int prev = -INF;
int ans = 0;
for (int i = 0; i < n; i++) {
if (second[i] == '1') {
prev = i;
}
if (second[i] == '0') {
if (prev < i - k && nxt[i] > i + k) {
second[i] = '1';
ans++;
prev = i;
}
}
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int prev = -1;
int64_t ans = 0;
for (int i = 0; i < s.size(); ++i) {
for (int k = 1; k < s.size(); ++k) {
if (i - k < 0 || i - 2 * k < 0) break;
if (s[i - k] == s[i - 2 * k] && s[i - k] == s[i]) {
prev = max(i - 2 * k, prev);
break;
}
}
ans += prev + 1;
}
cout << ans << endl;
return 0;
}
| 5 |
// i_m_arin
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef vector<long long> vll;
typedef vector<string> vs;
typedef priority_queue<ll> pqll;
typedef pair<ll,ll> pll;
typedef vector<pll> vpll;
typedef map<ll,ll> mpll;
typedef set<ll> stll;
#define f(i, a, n) for(ll i=a; i<(ll)n; i++)
#define f2(i, a, b) for(ll i=a; i<=(ll)b; i++)
#define pb push_back
#define ff first
#define ss second
#define pf push_front
#define mp make_pair
#define all(a) (a).begin(),(a).end()
#define decimal(x) fixed<<setprecision(x)
#define fsort(a) sort(all(a))
#define rsort(a) sort(all(a),greater<>())
#define fast_io ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,-1,sizeof(a))
#define lcm(a,b) (a*b)/__gcd(a,b)
#define ub(v,x) upper_bound(all(v),x)-v.begin()
#define lb(v,x) lower_bound(all(v),x)-v.begin()
const ld PI = acos(-1);
const ll MOD = 1e9+7;
const ll INF = LLONG_MAX;
const ll SIZE= 100000;
void solve(){
ll n,k;
cin>>n>>k;
if(n%2==0){
ll ans=k%n;
if(ans==0) ans=n;
cout<<ans<<endl;
}
else{
ll div=n/2;
ll check=0;
k=k%(div*n);
if(k==0){
k=div*n;
}
ll cnt=0;
if(k>= n/2 +1){
cnt++;
}
ll some=k- (n/2 +1);
if(some>0)
cnt+=some/div;
ll ans=(k+cnt)%n;
if(ans==0) ans=n;
cout<<ans<<endl;
}
}
int main(){
fast_io;
int t=1;
cin>>t;
while(t--){
solve();
}
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int lcp(const string& s1, const string& s2) {
int pos = 0;
while (pos < min(s1.size(), s2.size()) && s1[pos] == s2[pos]) pos++;
return pos;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<string> vs(n + 1), vs2(n + 2);
for (int i = 1; i <= n; i++) cin >> vs[i];
set<pair<string, int>> sp;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
sp.insert({s, i});
vs2[i] = s;
}
vector<bool> used(n + 1);
priority_queue<vector<int>> pq;
for (int i = 1; i <= n; i++) {
auto it = sp.lower_bound({vs[i], 0});
int pos = -1, val = -1;
if (it != sp.end()) {
val = lcp(vs[i], it->first);
pos = it->second;
}
if (it != sp.begin()) {
it--;
int valt = lcp(vs[i], it->first);
if (valt > val) {
val = valt;
pos = it->second;
}
}
pq.push({val, i, pos});
}
int ans = 0;
vector<pair<int, int>> vans;
while (pq.size()) {
auto cur = pq.top();
pq.pop();
if (!used[cur[2]]) {
vans.push_back({cur[1], cur[2]});
ans += cur[0];
used[cur[2]] = 1;
sp.erase({vs2[cur[2]], cur[2]});
} else {
auto it = sp.lower_bound({vs[cur[1]], 0});
int pos = -1, val = -1;
if (it != sp.end()) {
val = lcp(vs[cur[1]], it->first);
pos = it->second;
}
if (it != sp.begin()) {
it--;
int valt = lcp(vs[cur[1]], it->first);
if (valt > val) {
val = valt;
pos = it->second;
}
}
pq.push({val, cur[1], pos});
}
}
cout << ans << '\n';
for (auto p : vans) {
cout << p.first << ' ' << p.second << '\n';
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum1 = 0, sum2 = 0;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
sum1 += a[i];
}
for (int i = 0; i < n; i++) {
sum2 += a[i];
if (sum2 * 2 >= sum1) {
cout << i + 1;
return 0;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, p, c, h, t, head[100005], Next[200005], adjc[200005], adjh[200005], q, a,
b, f[4005], k, i;
int qhead[100005], qNext[200005], qadj[200005], num[200005], ans[100005];
void Push(int u, int c, int h) {
Next[++k] = head[u];
head[u] = k;
adjc[k] = c;
adjh[k] = h;
}
void qPush(int u, int v, int w) {
qNext[++k] = qhead[u];
qhead[u] = k;
qadj[k] = v;
num[k] = w;
}
void modify(int i, int l, int r, int ll, int rr, int c, int h) {
if (l >= ll && r <= rr) {
Push(i, c, h);
return;
}
int mid = l + r >> 1;
if (mid >= ll) modify(i << 1, l, mid, ll, rr, c, h);
if (mid < rr) modify(i << 1 | 1, mid + 1, r, ll, rr, c, h);
}
void Query(int i, int l, int r) {
int j, k;
for (j = head[i]; j != 0; j = Next[j])
for (k = 4000; k >= adjc[j]; k--)
f[k] = max(f[k], f[k - adjc[j]] + adjh[j]);
if (l == r) {
for (j = qhead[l]; j != 0; j = qNext[j]) ans[num[j]] = f[qadj[j]];
return;
}
int tmp[4005];
memcpy(tmp, f, sizeof(tmp));
int mid = l + r >> 1;
Query(i << 1, l, mid);
memcpy(f, tmp, sizeof(f));
Query(i << 1 | 1, mid + 1, r);
}
int main() {
scanf("%d %d", &n, &p);
for (i = 1; i <= n; i++) {
scanf("%d %d %d", &c, &h, &t);
modify(1, 1, 20000, t, t + p - 1, c, h);
}
scanf("%d", &q);
k = 0;
for (i = 1; i <= q; i++) {
scanf("%d %d", &a, &b);
qPush(a, b, i);
}
Query(1, 1, 20000);
for (i = 1; i <= q; i++) printf("%d\n", ans[i]);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll a, b;
scanf("%lld%lld", &a, &b);
ll sum = a + b;
vector<ll> ans;
ll total = 0;
ll i;
for (i = 1; total <= sum; ++i) {
total += i;
if (total > sum) break;
ans.push_back(i);
}
total -= i;
vector<ll> p, q;
sum = 0;
for (int i = ans.size() - 1; i >= 0; --i) {
if (sum + ans[i] <= b) {
sum += ans[i];
q.push_back(ans[i]);
ans[i] = -1;
if (sum == b) break;
}
}
for (ll xx : ans) {
if (xx == -1) continue;
p.push_back(xx);
}
cout << p.size() << "\n";
for (ll x : p) {
cout << x << " ";
}
cout << "\n";
cout << q.size() << "\n";
for (ll x : q) {
cout << x << " ";
}
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
struct Node {
int p;
int dis;
};
vector<pair<int, int> > tree[maxn];
int n, m, u, v, len, cen, du[maxn], dv[maxn], vis[maxn];
int flp(int s) {
memset(vis, 0, sizeof(vis));
int max_dis = 0, lp = -1;
queue<Node> q;
q.push(Node{s, 0});
vis[s] = 1;
while (!q.empty()) {
Node f = q.front();
q.pop();
if (s == u) du[f.p] = f.dis;
if (s == v) dv[f.p] = f.dis;
if (f.dis > max_dis) {
max_dis = f.dis;
lp = f.p;
}
for (int i = 0; i < tree[f.p].size(); i++) {
int next = tree[f.p][i].first;
int d = tree[f.p][i].second;
if (vis[next]) continue;
vis[next] = 1;
q.push(Node{next, f.dis + d});
}
}
return lp;
}
bool dfs(int w, int fa, int dep) {
int siz = tree[w].size();
for (int i = 0; i < siz; i++) {
pair<int, int> v = tree[w][i];
if (v.first == fa) continue;
if (dfs(v.first, w, dep + 1) == false) return false;
}
if (cen == w)
return (siz >= 3);
else if (dep < m)
return (siz >= 4);
else
return (siz == 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int a, b;
cin >> n >> m;
for (int i = 1; i < n; i++) {
cin >> a >> b;
tree[a].push_back(make_pair(b, 1));
tree[b].push_back(make_pair(a, 1));
}
u = flp(1);
v = flp(u);
flp(v);
len = du[v];
cen = -1;
for (int i = 1; i <= n; i++)
if (dv[i] == du[i] && (dv[i] + du[i]) == len) {
cen = i;
break;
}
if (cen == -1) {
cout << "No" << endl;
return 0;
}
if (dfs(cen, -1, 0) == true) {
cout << "Yes" << endl;
} else
cout << "No" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
deque<int> a;
int main() {
int n, k = -1;
cin >> n;
int i = 1, j = n;
if (n == 1) {
cout << "1\n1";
} else if (n == 2) {
cout << "1\n1";
} else if (n == 3) {
cout << "2\n1 3";
} else {
cout << n << "\n";
for (; j - i > 1; ++i, --j) {
a.push_back(j);
a.push_back(i);
}
if (j == i)
a.push_front(j);
else {
a.push_back(j);
a.push_front(i);
}
}
for (i = 0; i < a.size(); ++i) cout << a[i] << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
template <class C>
inline void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
inline void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
int n, v, e;
int a[307], b[307];
vector<int> GG[307], G[307];
bool del[307], vis[307];
int xx[1000007], yy[1000007], dd[1000007], moves;
long long int go(int x) {
long long int res = a[x] - b[x];
vis[x] = true;
for (__typeof((GG[x]).begin()) i = (GG[x]).begin(); i != (GG[x]).end(); ++i)
if (!vis[*i]) {
G[x].push_back(*i);
G[*i].push_back(x);
res += go(*i);
}
return res;
}
void push(int x, int o, int lim, bool down) {
for (__typeof((G[x]).begin()) i = (G[x]).begin(); i != (G[x]).end(); ++i)
if (*i != o && !del[*i]) {
push(*i, x, INF, down);
int can = lim;
int l = x, r = *i;
if (!down) swap(l, r);
mini(can, a[l]);
mini(can, v - a[r]);
lim -= can;
if (can > 0) {
a[l] -= can;
a[r] += can;
xx[moves] = l;
yy[moves] = r;
dd[moves] = can;
moves++;
}
}
}
int main() {
std::ios_base::sync_with_stdio(0);
cout << setprecision(15) << fixed;
cin >> n >> v >> e;
for (int i = (1); i <= (n); i++) cin >> a[i];
for (int i = (1); i <= (n); i++) cin >> b[i];
while (e--) {
int x, y;
cin >> x >> y;
GG[x].push_back(y);
GG[y].push_back(x);
}
for (int i = (1); i <= (n); i++)
if (!vis[i])
if (go(i) != 0) {
cout << "NO" << endl;
return 0;
}
bool ok;
do {
ok = false;
for (int i = (1); i <= (n); i++)
if (!del[i]) {
int deg = 0;
for (__typeof((G[i]).begin()) j = (G[i]).begin(); j != (G[i]).end();
++j)
deg += !del[*j];
if (deg != 1) continue;
if (a[i] != b[i]) push(i, i, abs(a[i] - b[i]), a[i] > b[i]);
del[i] = true;
ok = true;
break;
}
} while (ok);
cout << moves << endl;
for (int i = 0; i < (moves); i++)
cout << xx[i] << " " << yy[i] << " " << dd[i] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2000000000;
int main() {
long long t1, t2, x1, x2, t0, y1, y2, l, r, ans_1 = -1, ans_2 = -1,
max_time = -inf, cycle;
double t, eps = inf * 1.0;
cin >> t1 >> t2 >> x1 >> x2 >> t0;
if (t1 == t2) {
cout << x1 << " " << x2;
return 0;
} else if (t1 == t0) {
cout << x1 << " " << 0;
return 0;
} else if (t2 == t0) {
cout << 0 << " " << x2;
return 0;
}
for (y1 = 0; y1 <= x1; y1++) {
l = 0;
r = x2;
while (l <= r) {
y2 = (l + r) / 2;
t = double(t1 * y1 + t2 * y2) / double(y1 + y2);
if (t >= t0) {
r = y2 - 1;
if (t - t0 < eps || (t - t0 == eps && y1 + y2 > max_time)) {
max_time = y1 + y2;
eps = t - t0;
ans_1 = y1;
ans_2 = y2;
}
} else {
l = y2 + 1;
}
}
}
if (ans_1 == 0 && ans_2 != 0)
ans_2 = x2;
else if (ans_1 != 0 && ans_2 == 0)
ans_1 = x1;
cout << ans_1 << " " << ans_2;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 10;
const int inf = 1e9;
const int mo = 998244353;
int a[N], b[N];
void trans(int i) {
swap(a[i], a[i + 2]);
swap(a[i + 1], a[i + 2]);
}
int main() {
int t;
cin >> t;
while (t--) {
vector<int> ans;
int n;
cin >> n;
for (auto i = (1); i <= (n); ++i) cin >> a[i];
for (auto i = (1); i <= (n); ++i) b[i] = a[i];
sort(b + 1, b + 1 + n);
int mepos = -1;
for (auto i = (2); i <= (n); ++i) {
if (b[i] == b[i - 1]) mepos = i;
}
bool ok = 1;
for (auto i = (1); i <= (n); ++i) {
int now = b[i];
for (auto j = (i); j <= (n); ++j) {
if (a[j] == now) {
for (int k = j - 2; k >= i; k -= 2) {
ans.push_back(k);
trans(k);
}
}
}
if (a[i] != now) {
if (i + 2 <= n) {
ans.push_back(i);
trans(i);
ans.push_back(i);
trans(i);
} else
ok = 0;
}
if (i == mepos) {
int inv = 0;
for (auto j = (i + 2); j <= (n); ++j) {
for (auto k = (i + 1); k <= (j - 1); ++k) {
if (a[k] > a[j]) inv++;
}
}
if (inv & 1) {
trans(i - 1);
trans(i - 1);
trans(i);
trans(i);
ans.push_back(i - 1);
ans.push_back(i - 1);
ans.push_back(i);
ans.push_back(i);
}
}
}
if (!ok && a[n - 2] == a[n]) {
ans.push_back(n - 2);
trans(n - 2);
ok = 1;
}
if (!ok) {
cout << "-1\n";
} else {
cout << ans.size() << endl;
for (auto x : ans) cout << x << " ";
cout << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inv = numeric_limits<int>::max();
const int minv = numeric_limits<int>::min();
const int lim = 310;
int n;
int p1, p2, p3;
bool Lij[lim + 1][lim + 1] = {0};
bool Ljk[lim + 1][lim + 1] = {0};
bool Lik[lim + 1][lim + 1] = {0};
bool Lijk[2 * lim + 1][2 * lim + 1] = {0};
bool Mi[lim + 1] = {0};
bool Mj[lim + 1] = {0};
bool Mij[2 * lim + 1] = {0};
int main() {
scanf("%d", &n);
if (n == 1) {
scanf("%d", &p1);
if (p1 > 0)
printf("BitLGM\n");
else
printf("BitAryo\n");
} else if (n == 2) {
scanf("%d", &p1);
scanf("%d", &p2);
for (int i = 0; i < p1 + 1; ++i) {
for (int j = 0; j < p2 + 1; ++j) {
if (Mi[i] or Mj[j] or Mij[j - i + lim]) {
if (i == p1 and j == p2) {
printf("BitLGM\n");
return 0;
}
} else {
if (i == p1 and j == p2) {
printf("BitAryo\n");
return 0;
}
Mi[i] = true;
Mj[j] = true;
Mij[j - i + lim] = true;
}
}
}
} else {
scanf("%d", &p1);
scanf("%d", &p2);
scanf("%d", &p3);
for (int i = 0; i < p1 + 1; ++i) {
for (int j = 0; j < p2 + 1; ++j) {
for (int k = 0; k < p3 + 1; ++k) {
if (Lij[i][j] or Ljk[j][k] or Lik[i][k] or
Lijk[j - i + lim][k - i + lim]) {
if (i == p1 and j == p2 and k == p3) {
printf("BitLGM\n");
return 0;
}
} else {
if (i == p1 and j == p2 and k == p3) {
printf("BitAryo\n");
return 0;
}
Lij[i][j] = true;
Ljk[j][k] = true;
Lik[i][k] = true;
Lijk[j - i + lim][k - i + lim] = true;
}
}
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, q, c, C[100010], V[100010], L, H;
long long F[100010], va, vb, a, b, s;
int main() {
cin >> n >> q;
for (int i = 0; i < n; ++i) cin >> V[i];
for (int i = 0; i < n; ++i) cin >> C[i];
for (int j = 0; j < q; ++j) {
for (int i = 0; i < 100010; ++i) F[i] = -1ll << 50;
cin >> a >> b, L = H = F[0] = 0;
for (int i = 0; i < n; ++i) {
c = C[i], va = V[i] * a, vb = V[i] * b, s = -1ll << 50;
if (H != c)
s = max(s, F[H] + vb);
else if (L != c)
s = max(s, F[L] + vb);
if (F[c] != -1ll << 50) s = max(s, F[c] + va);
s = max(s, vb);
if (s > F[c]) {
F[c] = s;
if (c == L || c == H) {
if (F[L] > F[H]) L ^= H ^= L ^= H;
} else {
if (F[c] > F[H])
L = H, H = c;
else if (F[c] > F[L])
L = c;
}
}
}
cout << F[H] << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10005;
long long A[MAXN], nodes[MAXN], F[MAXN], val[MAXN], ans[MAXN];
long long G[MAXN], val2[MAXN];
const long long MOD = 1000000007;
int main() {
long long inv2 = (MOD + 1) / 2;
int n;
scanf("%d", &n);
nodes[1] = 1;
for (int i = 1; i < n; ++i) {
scanf("%lld", &A[i]);
nodes[i + 1] = nodes[i] * A[i] % MOD;
}
F[0] = 1;
for (int d = n - 1; d >= 1; --d) {
swap(F, G);
swap(val, val2);
memset(F, 0, sizeof(F));
memset(val, 0, sizeof(val));
F[0] = 1;
for (int l = 1; l < n; ++l) F[l] = (G[l - 1] * A[d]) % MOD;
for (int l = 2; l <= 2 * n - 2; ++l) {
val[l] = val2[l - 2] * A[d + 1] % MOD * A[d + 1] % MOD;
val[l] += G[0] * G[l - 2];
if (l > 2) val[l] += G[l - 2] * G[0];
val[l] %= MOD;
}
for (int l = 0; l <= 2 * n - 2; ++l) {
long long v = val[l] * A[d] % MOD * (A[d] - 1) % MOD * inv2 % MOD;
(ans[l] += (F[l] + v) * nodes[d]) %= MOD;
}
}
for (int l = 1; l <= 2 * n - 2; ++l) printf("%lld ", ans[l]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int nbtc;
cin >> nbtc;
while (nbtc--) {
int k;
cin >> k;
vector<bool> days(7);
for (int i = 0; i < 7; i++) {
int tmp;
cin >> tmp;
days[i] = tmp;
}
int wd = accumulate(days.begin(), days.end(), 0);
int nw = (k + wd - 1) / wd - 1;
int mk = k - wd * nw;
int b = 7;
for (int i = 0; i < 7; i++) {
int mkc = mk;
int pos = i;
int c = 0;
while (mkc > 0) {
if (days[pos]) mkc--;
++c;
pos = (pos + 1) % 7;
}
b = min(c, b);
}
int c = 7 * nw + b;
cout << c << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[500];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
set<int>::iterator it;
int n;
int f = 1;
cin >> n;
for (int i = 1; i <= 4 * n; i++) {
cin >> a[i];
}
sort(a + 1, a + 4 * n + 1);
int v = a[1] * a[4 * n];
for (int i = 1; i <= 2 * n; i += 2)
if (a[i] * a[4 * n - i + 1] != v || a[4 * n - i] != a[4 * n - i + 1] ||
a[i] != a[i + 1]) {
printf("NO\n");
f = 0;
break;
}
if (f) puts("YES");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char name1[128], name2[128];
map<string, int> m1;
map<int, string> m2;
bool adj[32][32];
bool visited[32];
vector<int> res;
vector<int> resg;
bool cmp(int a, int b) { return m2[a] < m2[b]; }
int run(int u) {
if (u == n) {
if (res.size() > resg.size()) resg = res;
return 0;
}
int op1 = run(u + 1);
bool fail = false;
for (int i = 0; i < (int)res.size(); i++)
if (adj[res[i]][u]) fail = true;
int op2 = 0;
if (!fail) {
res.push_back(u);
op2 = 1 + run(u + 1);
res.pop_back();
}
return max(op1, op2);
}
int main() {
m1.clear();
m2.clear();
memset(adj, false, sizeof(adj));
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", name1);
string n1 = name1;
m1[n1] = i;
m2[i] = n1;
}
for (int i = 0; i < m; i++) {
scanf("%s %s", name1, name2);
string n1 = name1;
string n2 = name2;
adj[m1[n1]][m1[n2]] = true;
adj[m1[n2]][m1[n1]] = true;
}
memset(visited, false, sizeof(visited));
res.clear();
printf("%d\n", run(0));
sort(resg.begin(), resg.end(), cmp);
for (int i = 0; i < (int)resg.size(); i++)
printf("%s\n", m2[resg[i]].c_str());
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e18;
const string nl = "\n";
vector<char> a;
long long ans;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
a.resize(6);
for (auto& i : a) {
cin >> i;
i -= '0';
}
long long hld = a[0] + a[1] + a[2] - a[3] - a[4] - a[5];
if (hld < 0) {
reverse(a.begin(), a.end());
hld *= -1;
}
a[3] = 9 - a[3];
a[4] = 9 - a[4];
a[5] = 9 - a[5];
sort(a.begin(), a.end());
while (hld > 0) {
++ans;
hld -= a[6 - ans];
}
cout << ans << nl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void setmin(int &x, int y) {
if (y < x) x = y;
}
inline void setmax(int &x, int y) {
if (y > x) x = y;
}
inline void setmin(long long &x, long long y) {
if (y < x) x = y;
}
inline void setmax(long long &x, long long y) {
if (y > x) x = y;
}
const int N = 501;
const int inf = (int)1e9 + 1;
const long long big = (long long)1e18 + 1;
const int P = 239;
const int MOD = (int)1e9 + 7;
const int MOD1 = (int)1e9 + 9;
const double eps = 1e-9;
const double pi = atan2(0, -1);
const int ABC = 26;
int cnt[N][N];
int dp[N][N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
cout << fixed;
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
vector<int> p;
for (int j = 0; j < m; j++)
if (s[j] == '1') p.push_back(j);
for (int miss = 0; miss < k + 1; miss++) {
if (miss >= (int)p.size())
cnt[i][miss] = 0;
else {
cnt[i][miss] = inf;
for (int j = 0; j < miss + 1; j++)
setmin(cnt[i][miss], p[(int)p.size() - 1 - (miss - j)] - p[j] + 1);
}
}
}
for (int i = 0; i < n + 1; i++)
for (int j = 0; j < k + 1; j++) dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < k + 1; j++)
for (int miss = 0; miss < j + 1; miss++)
setmin(dp[i + 1][j], dp[i][j - miss] + cnt[i][miss]);
int ans = inf;
for (int j = 0; j < k + 1; j++) setmin(ans, dp[n][j]);
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
int u;
while (q--) {
int n;
cin >> n;
u = n;
int res[u + 1];
int p[n + 1];
for (int i = 1; i <= n; i++) cin >> p[i];
int day = 1;
for (int i = 1; i <= n; i++) {
bool found = true;
int countt = 0;
int j = i;
while (found) {
if (p[j] == i) {
countt++;
found = false;
} else {
j = p[j];
countt++;
}
}
res[i] = countt;
}
for (int i = 1; i <= u; i++) cout << res[i] << " ";
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, c;
vector<long long> a;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> c;
a.push_back(c);
}
sort(a.begin(), a.end());
c = n;
stack<long long> b;
for (int i = 0; i < n - 1; i++) {
if (a[i] + k >= a[i + 1] && a[i] != a[i + 1]) {
c--;
while (!b.empty()) {
if (b.top() + k >= a[i + 1]) {
c--;
b.pop();
} else
break;
}
} else {
if (a[i] == a[i + 1]) {
b.push(a[i]);
}
}
}
cout << c;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
int num1[N], num2[N];
map<pair<int, int>, int> vis;
int main() {
int t;
cin >> t;
while (t--) {
vis.clear();
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> num1[i];
for (int i = 1; i <= n; i++) cin >> num2[i];
for (int i = 1; i <= n / 2; i++) {
int a = num1[i], b = num1[n - i + 1];
if (a > b) swap(a, b);
vis[make_pair(a, b)]++;
}
if (n & 1) {
if (num1[n / 2 + 1] != num2[n / 2 + 1]) {
cout << "no" << endl;
continue;
}
}
bool f = 1;
for (int i = 1; i <= n / 2; i++) {
int a = num2[i], b = num2[n - i + 1];
if (a > b) swap(a, b);
if (vis[make_pair(a, b)] == 0) {
cout << "no" << endl;
f = 0;
break;
}
vis[make_pair(a, b)]--;
}
if (f) cout << "yes" << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) {
if (x == 0) return y;
return gcd(y % x, x);
}
long long powmod(long long x, long long y, long long m) {
if (y == 0) return 1;
long long p = powmod(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
long long modif(long long x, long long m) { return (powmod(x, m - 2, m)); }
bool fa(vector<long long> &x, vector<long long> &y) { return x[0] < y[0]; }
bool fa1(vector<long long> &x, vector<long long> &y) { return x[1] < y[1]; }
bool f1(pair<long long, long long> &x, pair<long long, long long> &y) {
return x.second > y.second;
}
bool f2(pair<long long, long long> &x, pair<long long, long long> &y) {
return x.first < y.first;
}
bool f3(long long &x, long long &y) { return abs(x) > abs(y); }
long long mxn = 1e6;
vector<long long> b;
vector<long long> ch(mxn, 0ll);
long long tr;
long long m, n, k;
bool meow(long long x, vector<array<long long, 3> > &c) {
if (x == 0) return true;
long long yo = 0;
for (int i = 0; i < mxn; i++) ch[i] = 0;
long long y = b[b.size() - x];
for (int i = 0; i < k; i++) {
if (c[i][2] > y) {
ch[c[i][0]]++;
ch[c[i][1] + 1]--;
}
}
long long l = 0;
for (int i = 0; i < n + 1; i++) {
l += ch[i];
yo += 1;
if (l > 0) yo += 2;
}
return yo <= tr;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> m >> n >> k >> tr;
for (int i = 0; i < m; i++) {
long long x;
cin >> x;
b.push_back(x);
}
sort(b.begin(), b.end());
vector<array<long long, 3> > c(k);
for (int i = 0; i < k; i++) {
cin >> c[i][0] >> c[i][1] >> c[i][2];
}
long long l = 0, r = m;
long long it = 0;
while (l < r) {
if (it > 100) {
cout << "meow";
break;
}
long long mid = (l + r + 1) / 2;
if (meow(mid, c))
l = mid;
else
r = mid - 1;
}
cout << l;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n;
int l[30], m[30], w[30];
map<pair<int, int>, pair<int, int> > fst, scnd;
void solve(int low, int up, int a, int b, int c, int path,
map<pair<int, int>, pair<int, int> > &hs) {
if (low == up) {
if (hs.find(make_pair(a - b, b - c)) == hs.end()) {
hs[make_pair(a - b, b - c)] = make_pair(a, path);
} else {
hs[make_pair(a - b, b - c)] =
max(hs[make_pair(a - b, b - c)], make_pair(a, path));
}
} else {
solve(low + 1, up, a + l[low], b + m[low], c, path * 3 + 2, hs);
solve(low + 1, up, a + l[low], b, c + w[low], path * 3 + 1, hs);
solve(low + 1, up, a, b + m[low], c + w[low], path * 3 + 0, hs);
}
}
map<char, int> vl;
int addup = 0;
void output(int res, int num) {
vector<int> vout;
while (num) {
vout.push_back(res % 3);
res /= 3;
num--;
}
reverse(vout.begin(), vout.end());
for (int i = 0; i < vout.size(); ++i) {
int x = vout[i];
if (x == 0) {
cout << "MW" << endl;
vl['M'] += m[i + addup];
vl['W'] += w[i + addup];
}
if (x == 1) {
cout << "LW" << endl;
vl['L'] += l[i + addup];
vl['W'] += w[i + addup];
}
if (x == 2) {
cout << "LM" << endl;
vl['M'] += m[i + addup];
vl['L'] += l[i + addup];
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> l[i] >> m[i] >> w[i];
}
solve(0, n / 2, 0, 0, 0, 0, fst);
solve(n / 2, n, 0, 0, 0, 0, scnd);
int MAX = -1000 * 1000 * 1000 - 7, res[2];
for (map<pair<int, int>, pair<int, int> >::iterator i = fst.begin();
i != fst.end(); ++i) {
pair<pair<int, int>, pair<int, int> > el = *i;
pair<int, int> le = make_pair(-el.first.first, -el.first.second);
if (scnd.find(le) != scnd.end()) {
if (MAX < el.second.first + scnd[le].first) {
res[0] = el.second.second;
res[1] = scnd[le].second;
MAX = el.second.first + scnd[le].first;
}
}
}
if (MAX == -1000 * 1000 * 1000 - 7) {
cout << "Impossible" << endl;
return 0;
}
addup = 0;
output(res[0], n / 2);
addup = n / 2;
output(res[1], n - n / 2);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using ll = long long;
const int INF = (int)1e9 + 7, mod = (int)1e9 + 9, pw = 31, N = (int)1e5 + 123,
M = (int)1e6 + 123;
const double eps = 1e-11;
const long long inf = 1e18;
ll a, b, n;
bool ok(ll x) {
bool ok = 1;
while (x) {
if (x % 10 != a && x % 10 != b) ok = 0;
x /= 10;
}
return ok;
}
long long binpow(long long a, ll b) {
long long rec = 1;
while (b) {
if (b % 2) {
rec = rec * a % INF;
}
a = a * a % INF;
b /= 2;
}
return rec;
}
long long factorial[M] = {1};
long long fact(ll x) {
for (static int i = 1; i <= x; i++) factorial[i] = factorial[i - 1] * i % INF;
return factorial[x];
}
ll ans = 0;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> a >> b >> n;
for (int j = 0; j <= n; j++) {
if (ok(a * j + b * (n - j))) {
ans += fact(n) * binpow(fact(j) * fact(n - j) % INF, INF - 2) % INF;
ans %= INF;
}
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
const int mod = 1e9 + 7;
int a[205];
int main() {
int T, n;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
int id = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] == 1) id = i;
}
int cnt = 1;
bool f = 1, h = 1;
for (int i = id; i < id + n; i++) {
if (a[i % n] == cnt) {
cnt++;
} else {
f = 0;
break;
}
}
cnt = 1;
for (int i = id;; i--) {
if (i < 0) i += n;
if (a[i] == cnt) {
cnt++;
} else {
h = 0;
break;
}
if (cnt == n + 1) break;
}
if (f || h)
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50;
int n;
struct side {
int y, next;
} e[N * 2 + 9];
int lin[N + 9], cs;
void Ins(int x, int y) {
e[++cs].y = y;
e[cs].next = lin[x];
lin[x] = cs;
}
void Ins2(int x, int y) {
Ins(x, y);
Ins(y, x);
}
void into() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
Ins2(x, y);
}
}
int siz[N + 9];
long double dp[N + 9][N + 9], tmp[N + 9];
void Dfs_dp(int k, int fa) {
siz[k] = 1;
for (int i = 0; i <= n; ++i) dp[k][i] = 0;
dp[k][0] = 1;
for (int i = lin[k]; i; i = e[i].next) {
int y = e[i].y;
if (y == fa) continue;
Dfs_dp(y, k);
for (int i = 0; i < siz[k]; ++i)
for (int j = 0; j < siz[y]; ++j) {
tmp[i + j] += dp[k][i] * dp[y][j] * (0.5 / (siz[y] - j) - 1);
tmp[i + j + 1] += dp[k][i] * dp[y][j];
}
siz[k] += siz[y];
for (int i = 0; i < siz[k]; ++i) dp[k][i] = tmp[i], tmp[i] = 0;
}
}
long double ans[N + 9];
void Get_ans() {
for (int i = 1; i <= n; ++i) {
Dfs_dp(i, 0);
ans[i] = 1;
for (int j = lin[i]; j; j = e[j].next) {
int y = e[j].y;
long double sum = 0;
for (int k = 0; k < siz[y]; ++k) sum += dp[y][k] * 0.5 / (siz[y] - k);
ans[i] *= sum;
}
}
}
void work() { Get_ans(); }
void outo() {
for (int i = 1; i <= n; ++i) {
double t = ans[i];
printf("%.10lf\n", t);
}
}
int main() {
into();
work();
outo();
return 0;
}
| 10 |
#include <bits/stdc++.h>
int arr[100001], order[100001], a[100001];
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n * 2; i++) {
cin >> arr[i];
order[arr[i]] = i;
}
for (int i = 1; i <= 2 * n; i++) a[i] = 0;
int val = 2 * n, pos = 2 * n - 1;
if (order[val] == 0)
cout << "NO\n";
else {
while (order[val] != 0) {
if (order[val] <= pos) {
int tmp = pos - order[val] + 1;
for (int i = n; i > 0; i--)
if (a[i] != 0) a[tmp + i] = 1;
a[tmp] = 1;
pos = order[val] - 1;
}
val--;
}
for (int i = n; i > 0; i--)
if (a[i] != 0) a[pos + i + 1] = 1;
a[pos + 1] = 1;
if (a[n] == 1)
cout << "YES\n";
else
cout << "NO\n";
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void oka() {
long long n, i, j, l = -1, r = -1, f = 0;
cin >> n;
long long a[n];
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n - 1; i++) {
if (a[i] > a[i + 1]) {
l = i;
break;
}
}
for (i = n - 1; i > 0; i--) {
if (a[i] < a[i - 1]) {
r = i;
break;
}
}
if (r == -1 || l == -1) {
cout << 0 << " " << 0 << endl;
return;
}
for (i = l, j = r; i < j; i++, j--) {
swap(a[i], a[j]);
}
for (i = 0; i < n - 1; i++) {
if (a[i] > a[i + 1]) {
f = 1;
break;
}
}
if (f)
cout << 0 << " " << 0 << endl;
else
cout << l + 1 << " " << r + 1 << endl;
}
int main() { oka(); }
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 1100;
const long long LLinf = 1000000000000000000LL;
int A[SIZE][SIZE];
long long AN[SIZE], AM[SIZE];
int main() {
int N, M;
cin >> N >> M;
for (int i = 0; i != N; i++)
for (int j = 0; j != M; j++)
scanf("%d", &A[i][j]), AN[i] += A[i][j], AM[j] += A[i][j];
long long rN = LLinf, iN = 0, r;
for (int i = 0; i != N + 1; i++) {
r = 0;
for (int j = 0; j != N; j++)
if (j >= i)
r += AN[j] * (2LL + 4 * (j - i)) * (2LL + 4 * (j - i));
else
r += AN[j] * (-2LL + 4 * (i - j)) * (-2LL + 4 * (i - j));
if (rN > r) rN = r, iN = i;
}
long long rM = LLinf, iM = 0;
for (int i = 0; i != M + 1; i++) {
r = 0;
for (int j = 0; j != M; j++)
if (j >= i)
r += AM[j] * (2LL + 4 * (j - i)) * (2LL + 4 * (j - i));
else
r += AM[j] * (-2LL + 4 * (i - j)) * (-2LL + 4 * (i - j));
if (rM > r) rM = r, iM = i;
}
cout << rN + rM << endl << iN << ' ' << iM;
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int N = 150007;
int read() {
int x = 0, c = getchar();
while (isspace(c)) c = getchar();
while (isdigit(c)) (x *= 10) += c & 15, c = getchar();
return x;
}
int n, m, p;
struct node {
int n, a[5], b[5];
void out() {
printf("%d ", n);
for (int i = 0; i < n; ++i) printf("%d ", a[i]);
puts("");
}
} t[N << 2];
node operator+(node a, node b) {
node c = b;
for (int i = 0, f, j, k, t; i < a.n; ++i) {
for (f = j = 0; j < c.n; ++j)
if (c.a[j] == a.a[i]) {
c.b[j] += a.b[i];
f = 1;
break;
}
if (f) continue;
if (c.n < p) {
c.a[c.n] = a.a[i], c.b[c.n] = a.b[i], ++c.n;
continue;
}
for (k = 0, j = 1; j < p; ++j)
if (c.b[j] < c.b[k]) k = j;
if (a.b[i] < c.b[k])
for (j = 0; j < p; ++j) c.b[j] -= a.b[i];
else
for (t = c.b[k], c.a[k] = a.a[i], c.b[k] = a.b[i], j = 0; j < p; ++j)
c.b[j] -= t;
}
return c;
}
int tag[N << 2], len[N << 2];
void pushup(int p) { t[p] = t[p << 1] + t[p << 1 | 1]; }
void modify(int p, int x) {
tag[p] = x, t[p].n = 1, t[p].a[0] = x, t[p].b[0] = len[p];
}
void pushdown(int p) {
if (tag[p]) modify(p << 1, tag[p]), modify(p << 1 | 1, tag[p]), tag[p] = 0;
}
void build(int p, int l, int r) {
if (l == r)
return len[p] = t[p].n = t[p].b[0] = 1, t[p].a[0] = read(), void();
build(p << 1, l, ((l + r) >> 1)), build(p << 1 | 1, ((l + r) >> 1) + 1, r),
pushup(p), len[p] = len[p << 1] + len[p << 1 | 1];
}
void update(int p, int l, int r, int L, int R, int x) {
if (L > r || l > R) return;
if (L <= l && r <= R) return modify(p, x);
pushdown(p), update(p << 1, l, ((l + r) >> 1), L, R, x),
update(p << 1 | 1, ((l + r) >> 1) + 1, r, L, R, x), pushup(p);
}
node query(int p, int l, int r, int L, int R) {
if (L <= l && r <= R) return t[p];
pushdown(p);
if (R <= ((l + r) >> 1)) return query(p << 1, l, ((l + r) >> 1), L, R);
if (L > ((l + r) >> 1)) return query(p << 1 | 1, ((l + r) >> 1) + 1, r, L, R);
return query(p << 1, l, ((l + r) >> 1), L, R) +
query(p << 1 | 1, ((l + r) >> 1) + 1, r, L, R);
}
int main() {
n = read(), m = read(), p = 100 / read(), build(1, 1, n);
for (int l, r; m; --m)
read() == 1 ? (l = read(), r = read(), update(1, 1, n, l, r, read()))
: (l = read(), r = read(), query(1, 1, n, l, r).out());
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
template <typename T>
using V = vector<T>;
template <typename T, typename S>
using P = pair<T, S>;
template <class T>
using min_heap = priority_queue<T, std::vector<T>, std::greater<T>>;
using LD = long double;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << "=" << h << "\n";
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') {
cerr << *sdbg++;
}
cerr << "=" << h << ",";
_dbg(sdbg + 1, a...);
}
vector<pair<int, int>> a, b;
int possibleNumber(pair<int, int> a, pair<int, int> b) {
map<int, int> m;
for (int i : {a.first, a.second, b.first, b.second}) m[i]++;
if (m.size() != 3) return -1;
for (auto &i : m) {
if (i.second == 2) return i.first;
}
return -1;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (0) cout.tie(NULL);
int n, m;
cin >> n >> m;
a.resize(n);
b.resize(m);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
if (a[i].first > a[i].second) swap(a[i].first, a[i].second);
}
for (int i = 0; i < m; i++) {
cin >> b[i].first >> b[i].second;
if (b[i].first > b[i].second) swap(b[i].first, b[i].second);
}
set<int> possible;
for (int i = 0; i < n; i++) {
map<int, int> M;
for (int j = 0; j < m; j++) {
auto &x = a[i];
auto &y = b[j];
auto ans = possibleNumber(x, y);
if (ans != -1) {
M[ans]++;
}
}
if (!M.empty() && M.size() == 2) {
cout << -1 << '\n';
return 0;
} else {
(M.size());
if (!M.empty()) possible.insert((M.begin())->first);
}
}
for (int i = 0; i < m; i++) {
map<int, int> M;
for (int j = 0; j < n; j++) {
auto &x = a[j];
auto &y = b[i];
auto ans = possibleNumber(x, y);
if (ans != -1) {
M[ans]++;
}
}
if (!M.empty() && M.size() == 2) {
cout << -1 << '\n';
return 0;
} else {
(M.size());
if (!M.empty()) possible.insert((M.begin())->first);
}
}
if (possible.size() == 1) {
cout << *(possible.begin()) << '\n';
return 0;
}
if (possible.empty()) {
cout << -1 << '\n';
} else {
cout << 0 << '\n';
}
if (0)
cout << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms"
<< '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MM = 1e9 + 7;
const double eps = 1e-8;
const int MAXN = 2e6 + 10;
int n, m;
string ans[256] = {"!x&x",
"x&y&z",
"!z&x&y",
"x&y",
"!y&x&z",
"x&z",
"!y&x&z|!z&x&y",
"(y|z)&x",
"!y&!z&x",
"!y&!z&x|x&y&z",
"!z&x",
"!z&x|x&y",
"!y&x",
"!y&x|x&z",
"!(y&z)&x",
"x",
"!x&y&z",
"y&z",
"!x&y&z|!z&x&y",
"(x|z)&y",
"!x&y&z|!y&x&z",
"(x|y)&z",
"!x&y&z|!y&x&z|!z&x&y",
"(x|y)&z|x&y",
"!x&y&z|!y&!z&x",
"!y&!z&x|y&z",
"!x&y&z|!z&x",
"!z&x|y&z",
"!x&y&z|!y&x",
"!y&x|y&z",
"!(y&z)&x|!x&y&z",
"x|y&z",
"!x&!z&y",
"!x&!z&y|x&y&z",
"!z&y",
"!z&y|x&y",
"!x&!z&y|!y&x&z",
"!x&!z&y|x&z",
"!y&x&z|!z&y",
"!z&y|x&z",
"!(!x&!y|x&y|z)",
"!(!x&!y|x&y|z)|x&y&z",
"!z&(x|y)",
"!z&(x|y)|x&y",
"!x&!z&y|!y&x",
"!x&!z&y|!y&x|x&z",
"!y&x|!z&y",
"!z&y|x",
"!x&y",
"!x&y|y&z",
"!(x&z)&y",
"y",
"!x&y|!y&x&z",
"!x&y|x&z",
"!(x&z)&y|!y&x&z",
"x&z|y",
"!x&y|!y&!z&x",
"!x&y|!y&!z&x|y&z",
"!x&y|!z&x",
"!z&x|y",
"!x&y|!y&x",
"!x&y|!y&x|x&z",
"!(x&z)&y|!y&x",
"x|y",
"!x&!y&z",
"!x&!y&z|x&y&z",
"!x&!y&z|!z&x&y",
"!x&!y&z|x&y",
"!y&z",
"!y&z|x&z",
"!y&z|!z&x&y",
"!y&z|x&y",
"!(!x&!z|x&z|y)",
"!(!x&!z|x&z|y)|x&y&z",
"!x&!y&z|!z&x",
"!x&!y&z|!z&x|x&y",
"!y&(x|z)",
"!y&(x|z)|x&z",
"!y&z|!z&x",
"!y&z|x",
"!x&z",
"!x&z|y&z",
"!x&z|!z&x&y",
"!x&z|x&y",
"!(x&y)&z",
"z",
"!(x&y)&z|!z&x&y",
"x&y|z",
"!x&z|!y&!z&x",
"!x&z|!y&!z&x|y&z",
"!x&z|!z&x",
"!x&z|!z&x|x&y",
"!x&z|!y&x",
"!y&x|z",
"!(x&y)&z|!z&x",
"x|z",
"!(!y&!z|x|y&z)",
"!(!y&!z|x|y&z)|x&y&z",
"!x&!y&z|!z&y",
"!x&!y&z|!z&y|x&y",
"!x&!z&y|!y&z",
"!x&!z&y|!y&z|x&z",
"!y&z|!z&y",
"!y&z|!z&y|x&y",
"!(!x&!y|x&y|z)|!x&!y&z",
"!(!x&!y|x&y|z)|!x&!y&z|x&y&z",
"!x&!y&z|!z&(x|y)",
"!x&!y&z|!z&(x|y)|x&y",
"!x&!z&y|!y&(x|z)",
"!x&!z&y|!y&(x|z)|x&z",
"!y&(x|z)|!z&y",
"!y&z|!z&y|x",
"!x&(y|z)",
"!x&(y|z)|y&z",
"!x&z|!z&y",
"!x&z|y",
"!x&y|!y&z",
"!x&y|z",
"!(x&y)&z|!z&y",
"y|z",
"!x&(y|z)|!y&!z&x",
"!x&(y|z)|!y&!z&x|y&z",
"!x&(y|z)|!z&x",
"!x&z|!z&x|y",
"!x&(y|z)|!y&x",
"!x&y|!y&x|z",
"!x&y|!y&z|!z&x",
"x|y|z",
"!(x|y|z)",
"!(x|y|z)|x&y&z",
"!(!x&y|!y&x|z)",
"!(x|y|z)|x&y",
"!(!x&z|!z&x|y)",
"!(x|y|z)|x&z",
"!(!x&y|!y&x|z)|!y&x&z",
"!(x|y|z)|(y|z)&x",
"!y&!z",
"!y&!z|x&y&z",
"!(!x&y|z)",
"!y&!z|x&y",
"!(!x&z|y)",
"!y&!z|x&z",
"!(!x&y|z)|!y&x",
"!y&!z|x",
"!(!y&z|!z&y|x)",
"!(x|y|z)|y&z",
"!(!x&y|!y&x|z)|!x&y&z",
"!(x|y|z)|(x|z)&y",
"!(!x&z|!z&x|y)|!x&y&z",
"!(x|y|z)|(x|y)&z",
"!(!x&y|!y&x|z)|!x&y&z|!y&x&z",
"!(x|y|z)|(x|y)&z|x&y",
"!x&y&z|!y&!z",
"!y&!z|y&z",
"!(!x&y|z)|!x&y&z",
"!(!x&y|z)|y&z",
"!(!x&z|y)|!x&y&z",
"!(!x&z|y)|y&z",
"!(!x&y|z)|!x&y&z|!y&x",
"!y&!z|x|y&z",
"!x&!z",
"!x&!z|x&y&z",
"!(!y&x|z)",
"!x&!z|x&y",
"!x&!z|!y&x&z",
"!x&!z|x&z",
"!(!y&x|z)|!y&x&z",
"!(!y&x|z)|x&z",
"!(x&y|z)",
"!(x&y|z)|x&y&z",
"!z",
"!z|x&y",
"!x&!z|!y&x",
"!(x&y|z)|x&z",
"!y&x|!z",
"!z|x",
"!(!y&z|x)",
"!x&!z|y&z",
"!(!y&x|z)|!x&y",
"!x&!z|y",
"!(!y&z|x)|!y&x&z",
"!(!y&z|x)|x&z",
"!(!y&x|z)|!x&y|!y&x&z",
"!x&!z|x&z|y",
"!x&y|!y&!z",
"!(x&y|z)|y&z",
"!x&y|!z",
"!z|y",
"!(!x&!y&z|x&y)",
"!x&!z|!y&x|y&z",
"!x&y|!y&x|!z",
"!z|x|y",
"!x&!y",
"!x&!y|x&y&z",
"!x&!y|!z&x&y",
"!x&!y|x&y",
"!(!z&x|y)",
"!x&!y|x&z",
"!(!z&x|y)|!z&x&y",
"!(!z&x|y)|x&y",
"!(x&z|y)",
"!(x&z|y)|x&y&z",
"!x&!y|!z&x",
"!(x&z|y)|x&y",
"!y",
"!y|x&z",
"!y|!z&x",
"!y|x",
"!(!z&y|x)",
"!x&!y|y&z",
"!(!z&y|x)|!z&x&y",
"!(!z&y|x)|x&y",
"!(!z&x|y)|!x&z",
"!x&!y|z",
"!(!z&x|y)|!x&z|!z&x&y",
"!x&!y|x&y|z",
"!x&z|!y&!z",
"!(x&z|y)|y&z",
"!(!x&!z&y|x&z)",
"!x&!y|!z&x|y&z",
"!x&z|!y",
"!y|z",
"!x&z|!y|!z&x",
"!y|x|z",
"!(x|y&z)",
"!(x|y&z)|x&y&z",
"!x&!y|!z&y",
"!(x|y&z)|x&y",
"!x&!z|!y&z",
"!(x|y&z)|x&z",
"!(!y&!z&x|y&z)",
"!x&!y|!z&y|x&z",
"!((x|y)&z|x&y)",
"!((x|y)&z|x&y)|x&y&z",
"!x&!y|!z",
"!x&!y|!z|x&y",
"!x&!z|!y",
"!x&!z|!y|x&z",
"!y|!z",
"!y|!z|x",
"!x",
"!x|y&z",
"!x|!z&y",
"!x|y",
"!x|!y&z",
"!x|z",
"!x|!y&z|!z&y",
"!x|y|z",
"!x|!y&!z",
"!x|!y&!z|y&z",
"!x|!z",
"!x|!z|y",
"!x|!y",
"!x|!y|z",
"!(x&y&z)",
"!x|x"};
int main() {
int T;
scanf("%d", &T);
while (T--) {
char s[8];
scanf("%s", s);
int x = 0;
for (int i = 0; i < 8; i++) x = x * 2 + (s[i] - '0');
puts(ans[x].c_str());
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 5e4 + 5;
int T, n, m;
int cntr[MAXN], cntc[MAXN];
vector<vector<int> > v;
char s[MAXN];
int main() {
scanf("%d", &T);
while (T--) {
v.clear();
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s);
vector<int> vec;
for (int j = 0; j < m; j++) {
if (s[j] == '.')
vec.push_back(0);
else {
vec.push_back(1);
cntr[i]++;
cntc[j]++;
}
}
v.push_back(vec);
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (v[i][j])
ans = max(ans, cntr[i] + cntc[j] - 1);
else
ans = max(ans, (cntr[i] + cntc[j]));
}
}
printf("%d\n", n + m - 1 - ans);
for (int i = 0; i <= n; i++) cntr[i] = 0;
for (int j = 0; j <= m; j++) cntc[j] = 0;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int a, b, c;
cin >> a >> b >> c;
int ans = 0;
if (c >= 2 * b) {
ans += b * 3;
b = 0;
} else {
ans += c / 2 * 3;
b -= c / 2;
}
if (b >= 2 * a)
ans += a * 3;
else
ans += b / 2 * 3;
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> pri;
vector<int> phi(n + 5);
unordered_map<int, bool> mp;
vector<int> pre(n + 5);
vector<int> mark(n + 5);
int tot;
auto Phi = [&](int k) {
phi[1] = 1;
for (int i = 2; i <= k; ++i) {
if (!phi[i]) {
phi[i] = i - 1;
pri.emplace_back(i);
mp[i] = 1;
mark[i] = (int)pri.size();
}
int pos = 0;
for (auto x : pri) {
pos++;
if (i * x > n) break;
mark[i * x] = pos;
if (i % x == 0) {
phi[i * x] = phi[i] * x;
break;
} else {
phi[i * x] = phi[i] * phi[x];
}
}
}
tot = (int)pri.size();
if (tot) {
for (int i = 2; i <= k; ++i) {
pre[mark[i]]++;
}
while (pri[tot - 1] > n / 2) tot--;
for (int i = tot - 1; i >= 1; --i) {
pre[i] += pre[i + 1];
}
}
};
Phi(n);
long long ans = 0, res = 0;
int cnt = 0;
for (int i = 2; i <= n; ++i) {
ans += i - 1 - phi[i];
if (i <= n / 2 || !mp[i])
res += phi[i] - 1 - cnt;
else
cnt++;
}
ans += 2 * res;
res = 0;
int max_lim = sqrt(n), cnr = tot, sum = 0;
for (int i = 1; i <= tot; ++i) {
if (pri[i - 1] <= max_lim) continue;
while (1ll * pri[cnr - 2] * pri[i - 1] > n) cnr--;
res += pre[cnr];
sum++;
}
res -= 1ll * sum * (sum + 1) / 2;
ans += res;
cout << ans << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
template <class T>
inline int len(const T &a) {
return a.size();
}
const double EPS = 1e-9;
const double PI = 3.14159265358979323846264338328;
const long long LINF = (long long)1e16 + 5;
template <class T>
inline int toInt(const T &t) {
int n;
stringstream ss;
ss << t;
ss >> n;
return n;
}
template <class T>
inline string toStr(const T &t) {
stringstream ss;
ss << t;
return ss.str();
}
template <class T>
inline long long toInt64(const T &t) {
long long n;
stringstream ss;
ss << t;
ss >> n;
return n;
}
template <typename T>
int sgn(T val) {
return (T(0) < val) - (val < T(0));
}
template <class T>
T gcd(T a, T b) {
T r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <typename T1, typename T2>
inline std::ostream &operator<<(std::ostream &os, const std::pair<T1, T2> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
inline std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
bool first = true;
os << "[";
for (unsigned int i = 0; i < v.size(); i++) {
if (!first) os << ", ";
os << v[i];
first = false;
}
return os << "]";
}
template <typename T>
inline std::ostream &operator<<(std::ostream &os, const std::set<T> &S) {
bool first = true;
os << "set([";
for (typename std::set<T>::const_iterator it = S.begin(); it != S.end();
++it) {
if (!first) os << ", ";
os << *it;
first = false;
}
return os << "])";
}
template <typename T1, typename T2>
inline std::ostream &operator<<(std::ostream &os, const std::map<T1, T2> &d) {
bool first = true;
os << "{";
for (auto kv : d) {
if (!first) os << ", ";
os << kv.first << ": " << kv.second;
first = false;
}
return os << "}";
}
template <typename T1, typename T2>
inline std::ostream &operator<<(std::ostream &os,
const std::unordered_map<T1, T2> &d) {
bool first = true;
os << "{";
for (auto kv : d) {
if (!first) os << ", ";
os << kv.first << ": " << kv.second;
first = false;
}
return os << "}";
}
struct debugger {
template <typename T>
debugger &operator,(const T v) {
cerr << v << " ";
return *this;
}
} dbg;
set<string> blacklist;
string s;
int N;
int memo[1000 * 100 + 5][27];
char buf[1000 * 100 + 5];
int solve(int idx, int c) {
if (idx >= N) return 0;
if (memo[idx][c] != -1) return memo[idx][c];
int ret = 1 + solve(idx + 1, c);
string x = "**";
x[0] = s[idx];
x[1] = 'a' + c - 1;
if (!blacklist.count(x)) ret = min(ret, solve(idx + 1, s[idx] - 'a' + 1));
return memo[idx][c] = ret;
}
int main() {
scanf("%s", buf);
s = string(buf);
N = len(s);
int t;
scanf("%d", &t);
memset(memo, -1, sizeof(memo));
for (int i = 0; i < t; i++) {
string u;
cin >> u;
blacklist.insert(u);
reverse(u.begin(), u.end());
blacklist.insert(u);
}
printf("%d\n", solve(0, 0));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long i = 1, j = 1, n, k, c = 0;
cin >> n >> k;
cout << i << " " << i + k << " ";
if (n == 1) {
cout << 1;
return 0;
}
while (1) {
if (i + j < i + k - j)
cout << i + j << " " << i + k - j << " ";
else if (i + j == i + k - j) {
cout << i + j << " ";
break;
} else
break;
c++;
j++;
}
j = 2;
while (k + j <= n && c < n) {
cout << k + j << " ";
j++;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
const long long M = 998244353;
long long n, fact[N], prod[N];
int main() {
ios::sync_with_stdio(false);
cin >> n;
fact[0] = 1;
fact[1] = 1;
for (int i = 2; i < N; i++) fact[i] = fact[i - 1] * i % M;
prod[n] = n;
for (int i = n - 1; i >= 1; i--) prod[i] = prod[i + 1] * i % M;
long long ans = fact[n];
for (int i = n; i >= 1; i--) {
ans += (fact[n] - prod[i] + M);
ans %= M;
}
cout << ans;
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int A[500005] = {};
int main() {
int a;
while (cin >> a) {
memset((A), (0), sizeof(A));
for (int k = 0; k < a; k++) {
cin >> A[k];
}
int i = 0;
int ans = 0;
while (i < a) {
int j = i;
while (j < a - 1 && A[j] != A[j + 1]) {
j++;
}
int l = j - i + 1;
if (l % 2 == 0) {
for (int L = i; L < (i) + l / 2; L++) A[L] = A[i];
for (int R = (i) + l / 2; R < i + l; R++) A[R] = A[i + l - 1];
ans = max(ans, l / 2 - 1);
} else {
for (int L = i; L < i + l; L++) A[L] = A[i];
ans = max(l / 2, ans);
}
i = j + 1;
}
cout << ans << '\n';
for (int i = 0; i < a; i++) cout << A[i] << " ";
cout << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[5000];
int t[5000] = {0};
int color[200001] = {0}, ind[200001] = {0};
set<int> st[200001];
vector<int> v[200001];
map<int, int> mp;
int main() {
int h, n, m;
scanf("%d%d%d", &h, &m, &n);
long long cnt = 0;
int ccnt = 0;
for (int i = 0; i < n; i++) {
if (color[i] == 0) {
++ccnt;
int num = i, index = 0;
while (color[num] == 0) {
color[num] = ccnt;
ind[num] = index;
st[ccnt].insert(index);
v[ccnt].push_back(num);
index++;
num = (num + m) % h;
}
}
}
for (int i = 0; i < n; i++) {
string p;
char pp[3];
int id, hash;
scanf("%s", pp);
if (pp[0] == '+') {
scanf("%d %d", &id, &hash);
int col = color[hash], index = ind[hash];
int pos;
long long temp = 0;
set<int>::iterator iter = st[col].lower_bound(index);
if (iter == st[col].end()) {
iter = st[col].begin();
temp += v[col].size() - index;
}
pos = *iter;
if (pos < index)
temp += pos;
else
temp += pos - index;
cnt += temp;
st[col].erase(iter);
mp[id] = v[col][pos];
} else {
scanf("%d", &id);
int hash = mp[id];
int col = color[hash];
int index = ind[hash];
st[col].insert(index);
mp.erase(id);
}
}
cout << cnt;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int col[200001];
char s[200001];
int main() {
int n, i, j, index, temp, sign, level;
cin >> n;
memset(col, 0, sizeof(int));
for (i = 0; i < n; i++) {
cin >> s[i];
}
sign = n;
col[0] = 1;
index = 0;
level = 0;
while (sign > 0) {
level++;
col[index] = level;
sign--;
for (i = index + 1; i < n; i++) {
if (col[i] == 0) {
if (s[i] >= s[index]) {
index = i;
col[i] = level;
sign--;
}
}
}
index = 0;
while (col[index] != 0 && index < n) {
index++;
}
if (index > n) break;
}
cout << level << endl;
for (i = 0; i < n; i++) {
cout << col[i] << " ";
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
string str1, str2;
int s1[200100][30], s2[200100][30];
bool comp(int a1, int a2, int b1, int b2) {
bool fail = 0;
for (long long i = 0; i < (int)30; i++)
if (s1[a2 + 1][i] - s1[a1][i] != s2[b2 + 1][i] - s2[b1][i]) fail = 1;
if (fail) return 0;
for (long long i = 0; i < (int)a2 - a1 + 1; i++)
if (str1[a1 + i] != str2[b1 + i]) fail = 1;
if (!fail) return 1;
if ((a2 - a1 + 1) % 2) return 0;
bool aa1 = comp(a1, (a2 + a1) / 2, b1, (b2 + b1) / 2);
if (aa1) {
bool aa2 = comp((a1 + a2) / 2 + 1, a2, (b1 + b2) / 2 + 1, b2);
if (aa2) return 1;
}
aa1 = comp(a1, (a1 + a2) / 2, (b1 + b2) / 2 + 1, b2);
if (aa1) {
bool aa2 = comp((a1 + a2) / 2 + 1, a2, b1, (b1 + b2) / 2);
if (aa2) return 1;
}
return 0;
}
int main() {
getline(cin, str1);
getline(cin, str2);
for (long long i = 0; i < (int)30; i++) {
s1[0][i] = 0;
s2[0][i] = 0;
}
for (long long i = 0; i < (int)str1.size(); i++) {
for (long long j = 0; j < (int)30; j++) {
if (str1[i] - 'a' == j)
s1[i + 1][j] = s1[i][j] + 1;
else
s1[i + 1][j] = s1[i][j];
if (str2[i] - 'a' == j)
s2[i + 1][j] = s2[i][j] + 1;
else
s2[i + 1][j] = s2[i][j];
}
}
if (comp(0, str1.size() - 1, 0, str2.size() - 1))
cout << "YES";
else
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void readi(int &x) {
int v = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readll(long long &x) {
long long v = 0ll, f = 1ll;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-')
f = -1;
else
v = v * 10 + c - '0';
while (isdigit(c = getchar())) v = v * 10 + c - '0';
x = v * f;
}
void readc(char &x) {
char c;
while ((c = getchar()) == ' ')
;
x = c;
}
void writes(string s) { puts(s.c_str()); }
void writeln() { writes(""); }
void writei(int x) {
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
void writell(long long x) {
if (!x) putchar('0');
char a[25];
int top = 0;
while (x) {
a[++top] = (x % 10) + '0';
x /= 10;
}
while (top) {
putchar(a[top]);
top--;
}
}
inline long long inc(int &x) { return ++x; }
inline long long inc(long long &x) { return ++x; }
inline long long inc(int &x, long long y) { return x += y; }
inline long long inc(long long &x, long long y) { return x += y; }
inline double inc(double &x, double y) { return x += y; }
inline long long dec(int &x) { return --x; }
inline long long dec(long long &x) { return --x; }
inline long long dec(int &x, long long y) { return x -= y; }
inline long long dec(long long &x, long long y) { return x -= y; }
inline double dec(double &x, double y) { return x -= y; }
inline long long mul(int &x) { return x = ((long long)x) * x; }
inline long long mul(long long &x) { return x = x * x; }
inline long long mul(int &x, long long y) { return x *= y; }
inline long long mul(long long &x, long long y) { return x *= y; }
inline double mul(double &x, double y) { return x *= y; }
inline long long divi(const int &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(const long long &x) {
long long ans, l, r, mid;
ans = 0;
l = 0;
r = 0x3fffffff;
while (l < r) {
mid = (l + r) / 2;
if (mid * mid <= x) {
ans = mid;
l = mid + 1;
} else
r = mid;
}
return ans;
}
inline long long divi(int &x, long long y) { return x /= y; }
inline long long divi(long long &x, long long y) { return x /= y; }
inline double divi(double &x, double y) { return x /= y; }
inline long long mod(int &x, long long y) { return x %= y; }
inline long long mod(long long &x, long long y) { return x %= y; }
long long n, m, i, j, x, y, z, seq[100005];
struct seg {
struct nd {
int l, r, sum, ad;
} tr[400005];
void pushup(int x) {
tr[x].sum = max(tr[((x) << 1)].sum, tr[(((x) << 1) | 1)].sum);
}
void pushdo(int x) {
if (!tr[x].ad) return;
tr[((x) << 1)].sum += tr[x].ad;
tr[((x) << 1)].ad += tr[x].ad;
tr[(((x) << 1) | 1)].sum += tr[x].ad;
tr[(((x) << 1) | 1)].ad += tr[x].ad;
tr[x].ad = 0;
}
void build(int x, int l, int r) {
tr[x].l = l;
tr[x].r = r;
tr[x].sum = tr[x].ad = 0;
if (l == r) return;
build(x * 2, l, (l + r) / 2);
build(x * 2 + 1, (l + r) / 2 + 1, r);
pushup(x);
}
void update(int x, int l, int r, int c) {
if (tr[x].r < l || tr[x].l > r) return;
if (l <= tr[x].l && tr[x].r <= r) {
tr[x].sum += c;
tr[x].ad += c;
return;
}
pushdo(x);
update(((x) << 1), l, r, c);
update((((x) << 1) | 1), l, r, c);
pushup(x);
}
int query(int x, int l, int r) {
if (tr[x].r < l || tr[x].l > r) return 0;
if (tr[x].sum <= 0) return 0;
if (tr[x].l == tr[x].r) {
if (tr[x].sum > 0) return tr[x].r;
return 0;
}
pushdo(x);
if (tr[(((x) << 1) | 1)].sum > 0) return query((((x) << 1) | 1), l, r);
return query(((x) << 1), l, r);
}
} tr;
int main() {
scanf("%d", &n);
tr.build(1, 1, n);
seq[0] = -1;
if ((1) <= ((n)))
for (((i)) = (1); ((i)) <= ((n)); ((i))++) {
scanf("%d%d", &x, &y);
if (y == 1) {
scanf("%d", &z);
seq[x] = z;
tr.update(1, 1, x, 1);
} else {
tr.update(1, 1, x, -1);
}
printf("%d\n", seq[tr.query(1, 1, n)]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using vpdd = vector<pdd>;
template <typename T>
void ckmin(T& a, const T& b) {
a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
cin >> x;
}
void re(double& x) {
string t;
re(t);
x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
for (int i = 0; i < (SZ); i++) re(a[i]);
}
} // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
pr(first);
pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
if (pretty) pr("{");
bool fst = 1;
for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
prContain<T, false>(x);
pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
prContain(x);
}
template <class T>
void pr(const set<T>& x) {
prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
pr(first);
ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
pr(first, " ");
ps(rest...);
}
} // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::const_iterator find(const vector<T>& v, const T& x) {
auto it = lower_bound((v).begin(), (v).end(), x);
return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(const vector<T>& v, const T& x) {
auto it = find(v, x);
assert(it != v.end() && *it == x);
return it - v.begin();
}
template <typename T1, typename T2>
typename vector<pair<T1, T2>>::iterator lower_bound(
const vector<pair<T1, T2>>& v, const T1& x) {
return lower_bound(
(v).begin(), (v).end(), x,
[](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; });
}
template <typename T1, typename T2>
typename vector<pair<T1, T2>>::iterator upper_bound(
const vector<pair<T1, T2>>& v, const T1& x) {
return upper_bound(
(v).begin(), (v).end(), x,
[](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; });
}
} // namespace __algorithm
using namespace __algorithm;
struct __monostate {
friend istream& operator>>(istream& is,
const __attribute__((unused)) __monostate& ms) {
return is;
}
friend ostream& operator<<(ostream& os,
const __attribute__((unused)) __monostate& ms) {
return os;
}
} ms;
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << setprecision(15);
if (int((second).size())) {
setIn(second + ".in"), setOut(second + ".out");
}
}
} // namespace __io
using namespace __io;
int ceil(int a, int b) { return (a + b - 1) / b; }
vb state;
void light(vi lamps) {
pr(int((lamps).size()));
for (auto& e : lamps) {
state[e] = 1;
pr(" ", e + 1);
}
ps();
cout << flush;
int x;
re(x);
--x;
for (int i = 0; i < (int((lamps).size())); i++) {
state[(x + i) % int((state).size())] = 0;
}
}
int main() {
setIO();
int N;
re(N);
pii bestK = {N / 2 - 1, 2};
for (int K = (3); K < (N + 1); K++) {
int blocks = ceil(N, K);
int fill = N - blocks;
int get = fill - (K - 1);
ckmax(bestK, {get, K});
}
state.resize(N);
int K = bestK.second;
while (1) {
vi lamps;
for (int i = 0; i < (N); i++)
if ((i % K != 0) && !state[i]) lamps.push_back(i);
if (int((lamps).size()) < K) break;
lamps.resize(K);
light(lamps);
}
cout << 0 << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T>
void read(T &x) {
x = 0;
int c = getchar();
int flag = 0;
while (c < '0' || c > '9') flag |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (flag) x = -x;
}
template <class T>
T _max(T a, T b) {
return b < a ? a : b;
}
template <class T>
T _min(T a, T b) {
return a < b ? a : b;
}
template <class T>
bool checkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
bool checkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
const double eps = 1e-8;
int n;
set<pair<int, int> > S;
int x[105], y[105];
int sqr(int x) { return x * x; }
struct Point {
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
} a[105];
Point operator+(Point a, Point b) { return Point(a.x + b.x, a.y + b.y); }
Point operator-(Point a, Point b) { return Point(a.x - b.x, a.y - b.y); }
Point operator*(Point a, double b) { return Point(a.x * b, a.y * b); }
Point operator/(Point a, double b) { return Point(a.x / b, a.y / b); }
double operator*(Point a, Point b) { return a.x * b.y - b.x * a.y; }
double operator^(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double norm(Point a) { return a ^ a; }
double dist(Point a, Point b) { return sqrt(norm(a - b)); }
Point rot90(Point a) { return Point(-a.y, a.x); }
Point LI(Point p1, Point v1, Point p2, Point v2) {
double t = ((p2 - p1) * v2) / (v1 * v2);
return p1 + v1 * t;
}
struct Circle {
double x, y, r;
Circle(double x = 0, double y = 0, double z = 0) : x(x), y(y), r(z) {}
};
vector<Circle> ans;
void run(Point X, Point Y, Point Z) {
Point p = LI((X + Y) / 2.0, rot90(Y - X), (Y + Z) / 2.0, rot90(Z - Y));
ans.push_back(Circle(p.x, p.y, dist(p, X)));
}
void init() {
read(n);
for (int i = 1; i <= n; ++i) {
read(x[i]);
read(y[i]);
S.insert(make_pair(x[i], y[i]));
a[i].x = x[i], a[i].y = y[i];
}
}
void solve() {
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
for (int k = 1; k <= n; ++k) {
if (i == j || i == k || j == k) continue;
int A = sqr(x[i] - x[j]) + sqr(y[i] - y[j]);
int B = sqr(x[i] - x[k]) + sqr(y[i] - y[k]);
int C = sqr(x[j] - x[k]) + sqr(y[j] - y[k]);
if (A + B == C) {
int X = x[j] + x[k] - x[i], Y = y[j] + y[k] - y[i];
if (S.count(make_pair(X, Y))) {
ans.push_back(Circle((x[j] + x[k]) * 0.5, (y[j] + y[k]) * 0.5,
sqrt(C) * 0.5));
}
}
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = i + 1; j <= n; ++j) {
for (int k = j + 1; k <= n; ++k) {
int A = sqr(x[i] - x[j]) + sqr(y[i] - y[j]);
int B = sqr(x[i] - x[k]) + sqr(y[i] - y[k]);
int C = sqr(x[j] - x[k]) + sqr(y[j] - y[k]);
if (A + B > C && B + C > A && C + A > B) {
run(a[i], a[j], a[k]);
}
}
}
}
double tim = -1;
for (int i = 0; i < (int)ans.size(); ++i) {
Point O(ans[i].x, ans[i].y);
int error = 0;
for (int j = 1; j <= n; ++j) {
if (sqrt(norm(a[j] - O)) + eps < ans[i].r) {
error = 1;
}
}
if (!error) checkmax(tim, ans[i].r);
}
if (tim < 0)
printf("-1\n");
else
printf("%.12lf\n", tim);
}
int main() {
init();
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a = k / n;
if (a > 2)
cout << 0 << endl;
else
cout << max(0, n - k % n) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct c {
int w;
};
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
int k, i, l = s.size();
struct c a[26];
cin >> k;
long long int m = -1;
for (i = 0; i < 26; i++) {
cin >> a[i].w;
if (a[i].w > m) m = a[i].w;
}
long long int val = 0;
int j = 0;
int kk = k;
for (i = 0; i < l + kk; i++) {
if (a[s[j] - 'a'].w <= m && j < l) {
val += (i + 1) * (a[s[j] - 'a'].w);
++j;
} else if (k) {
val += (i + 1) * m;
--k;
}
}
cout << val << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 350;
int c[2 * N][2 * N], dp[N][N], b[N];
int f[N];
map<int, int> bucket;
int min(int a, int b) { return a > b ? b : a; }
int main() {
int n, i, j, a;
scanf("%i", &n);
f[0] = 1;
for (i = 1; i <= n; i++) {
scanf("%i", &a);
for (j = 2; j * j <= a; j++)
while (a % (j * j) == 0) a /= j * j;
bucket[a]++;
f[i] = ((long long)f[i - 1] * i) % mod;
}
for (i = 0; i < 2 * n; i++) {
c[i][0] = 1;
for (j = 1; j <= i; j++) {
c[i][j] = ((long long)c[i - 1][j - 1] + c[i - 1][j]) % mod;
}
}
int m = 0, k, l, s = 0;
long long sol = 1;
map<int, int>::iterator it;
for (it = bucket.begin(); it != bucket.end(); it++) b[++m] = it->second;
dp[0][0] = 1;
for (i = 0; i < m; i++) {
for (j = 0; j <= n; j++) {
if (dp[i][j] > 0) {
for (k = 1; k <= b[i + 1]; k++) {
for (l = 0; l <= min(j, k); l++) {
long long tmp = ((long long)dp[i][j] * c[j][l]) % mod;
tmp = (tmp * c[s + 1 - j][k - l]) % mod;
tmp = (tmp * c[b[i + 1] - 1][k - 1]) % mod;
dp[i + 1][j + b[i + 1] - k - l] =
((long long)dp[i + 1][j + b[i + 1] - k - l] + tmp) % mod;
}
}
}
}
s += b[i + 1];
sol = ((long long)sol * f[b[i + 1]]) % mod;
}
printf("%lld\n", (sol * dp[m][0]) % mod);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_BUF_SIZE = 16384;
char BUFOR[MAX_BUF_SIZE];
int BUF_SIZE, BUF_POS;
char ZZZ;
int _MINUS;
const int MXN = 2000010;
const int C = 262144;
const int INF = 1000000001;
int pi[20] = {0, 2, 3, 5, 7, 11, 13, 17, 19, 23};
int n;
void test() {
scanf("%d", &n);
int N = 2 * n * n;
bool dec = 0;
vector<int> res;
for (int ILE = (1); ILE <= (9); ILE++) {
set<int> gen;
for (int j = (1); j <= (ILE); j++) gen.insert(pi[j]);
vector<int> vec;
while ((int)(gen).size() > 0) {
int p = *gen.begin();
vec.push_back(p);
gen.erase(gen.begin());
for (int j = (1); j <= (ILE); j++)
if (pi[j] * p <= N) gen.insert(pi[j] * p);
}
if ((int)(vec).size() >= n) {
for (int i = ((int)(vec).size() - 1); i >= (0); i--) {
res.push_back(vec[i]);
if ((int)(res).size() == n) break;
}
dec = 1;
break;
}
}
if (dec) {
sort((res).begin(), (res).end());
for (__typeof((res).begin()) it = ((res).begin()); it != (res).end(); ++it)
printf("%d ", *it);
printf("\n");
} else
printf("PIEPRZU\n");
}
int main() {
int te = 1;
while (te--) test();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long dp[5005][5], p[5005][5];
long long a[5005], sum[5005];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
for (int i = 1; i <= n; ++i) {
dp[i][1] = sum[i];
p[i][1] = 0;
}
for (int z = 2; z <= 4; ++z) {
for (int i = 1; i <= n; ++i) {
dp[i][z] = z % 2 == 0 ? 9e18 : -9e18;
for (int j = 0; j <= i; ++j) {
long long cur = sum[i] - sum[j] - dp[j][z - 1];
if (z % 2 == 0 && cur < dp[i][z] || z % 2 != 0 && cur > dp[i][z]) {
dp[i][z] = cur;
p[i][z] = j;
}
}
}
}
int cur = n, curz = 4;
vector<int> ans;
while (curz > 1) {
ans.push_back(p[cur][curz]);
cur = p[cur][curz--];
}
cout << ans[2] << " " << ans[1] << " " << ans[0] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
const int N = 200005;
template <class T>
bool read(T& x) {
char c;
while (!isdigit(c = getchar()) && c != '-' && c != EOF)
;
if (c == EOF) return false;
T flag = 1;
if (c == '-') {
flag = -1;
x = 0;
} else
x = c - '0';
while (isdigit(c = getchar())) x = x * 10 + c - '0';
x *= flag;
return true;
}
template <class T, class... R>
bool read(T& a, R&... b) {
if (!read(a)) return false;
return read(b...);
}
mt19937 gen(steady_clock::now().time_since_epoch().count());
struct data {
int l, r, t, type, id;
} dat[N];
int val[N << 2], id[N], ans[N];
void update(int o, int l, int r, int x, int y, int k) {
if (l == r) {
val[o] = y;
id[l] = k;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
update((o << 1), l, mid, x, y, k);
else
update(((o << 1) | 1), mid + 1, r, x, y, k);
val[o] = max(val[(o << 1)], val[((o << 1) | 1)]);
}
int query(int o, int l, int r, int x, int y, int k) {
if (val[o] < k) return 0;
int mid = (l + r) >> 1;
if (x <= l && y >= r) {
if (l == r) {
return val[o] >= k ? id[l] : 0;
}
int ans = query((o << 1), l, mid, x, y, k);
if (!ans) return query(((o << 1) | 1), mid + 1, r, x, y, k);
return ans;
}
if (y <= mid)
return query((o << 1), l, mid, x, y, k);
else if (x > mid)
return query(((o << 1) | 1), mid + 1, r, x, y, k);
else {
int ans = query((o << 1), l, mid, x, y, k);
if (!ans) return query(((o << 1) | 1), mid + 1, r, x, y, k);
return ans;
}
}
int main() {
time_point<steady_clock> start = steady_clock::now();
int n, m, c = 0;
read(n, m);
vector<int> v;
for (int i = 1; i <= n; i++) {
read(dat[c].l, dat[c].r, dat[c].t);
v.push_back(dat[c].t);
dat[c].type = 0;
dat[c].id = i;
c++;
}
for (int i = 1; i <= m; i++) {
read(dat[c].l, dat[c].r, dat[c].t);
v.push_back(dat[c].t);
dat[c].type = 1;
dat[c].id = i;
c++;
}
sort(dat, dat + c, [](const data& x, const data& y) {
if (x.l == y.l) return x.type < y.type;
return x.l < y.l;
});
sort((v).begin(), (v).end());
(v).erase(unique((v).begin(), (v).end()), (v).end());
for (int i = 0; i < c; i++) {
dat[i].t =
(lower_bound((v).begin(), (v).end(), (dat[i].t)) - (v).begin() + 1);
if (dat[i].type == 0) {
update(1, 1, v.size(), dat[i].t, dat[i].r, dat[i].id);
} else {
ans[dat[i].id] = query(1, 1, v.size(), dat[i].t, v.size(), dat[i].r);
}
}
for (int i = 1; i <= m; i++)
printf("%d%c", ans[i] ? ans[i] : -1, i == m ? '\n' : ' ');
cerr << endl
<< "------------------------------" << endl
<< "Time: "
<< duration<double, milli>(steady_clock::now() - start).count() << " ms."
<< endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
bool op(pair<int, int> a, pair<int, int> b) {
if (a.first != b.first) return a.first > b.first;
return a.second < b.second;
}
int x, y, n, res[MAXN];
pair<int, int> t[MAXN];
int main() {
cin >> n >> x >> y;
for (int i = 1; i <= n; i++) {
cin >> t[i].first;
t[i].second = i;
}
if (y > x) {
sort(t + 1, t + 1 + n, op);
} else if (x > y) {
sort(t + 1, t + 1 + n);
} else {
for (int i = 1; i <= x; i++) cout << "1 ";
for (int i = 1; i <= y; i++) cout << "2 ";
return 0;
}
for (int i = 1; i <= x; i++) res[t[i].second] = 1;
for (int i = x + 1; i <= n; i++) res[t[i].second] = 2;
for (int i = 1; i <= n; i++) cout << res[i] << " ";
cout << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1000005;
const long long mo = 998244353;
long long n, a, dp[N], ans;
signed main() {
cin >> n;
dp[0] = dp[1] = 1;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
if (x == 1) a++;
}
for (long long i = 2; i <= a; i++)
dp[i] = (dp[i - 2] * (i - 1) % mo + dp[i - 1]) % mo;
ans = dp[a];
for (long long i = a + 1; i <= n; i++) ans = ans * i % mo;
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
int main() {
int t, n, count = 0;
char shape[13];
scanf("%d", &t);
while (t--) {
scanf("%s", shape);
n = strlen(shape);
if (n == 4)
count += 6;
else if (n == 11) {
if (shape[0] == 'T')
count += 4;
else if (shape[0] == 'I')
count += 20;
} else if (n == 12)
count += 12;
else if (n == 10)
count += 8;
}
printf("%d", count);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, h, m = 1;
cin >> a;
int b[a];
for (int g = 0; g < a; g++) {
cin >> b[g];
}
h = b[0];
for (int c = 0; c < a; c++) {
if (h < b[c]) {
h = b[c];
m = c + 1;
}
}
sort(b, b + a);
h = b[a - 2];
cout << m << " " << h;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int c;
while (a != 0) {
c = a;
a = b % a;
b = c;
}
return b;
}
long long int powmod(long long int a, int b, int n) {
long long int rm = 1;
while (b) {
if (b % 2) {
rm = (rm * a) % n;
}
a = (a * a) % n;
b /= 2;
}
return rm;
}
char s[100100];
int main() {
int m, n, p, d = 2 * 3 * 5 * 7, rem, f1;
cin >> n;
if (n < 4) {
m = 1;
for (int i = 1; i < n; ++i) m *= 10;
f1 = m - m % d + d;
m *= 10;
if (f1 >= m)
cout << -1 << endl;
else
cout << f1 << endl;
} else {
rem = 1;
s[0] = '1';
for (int i = 1; i < n; ++i) {
rem = rem * 10;
rem = rem % d;
s[i] = '0';
}
d = d - rem;
p = n - 1;
while (d) {
s[p] = d % 10 + 48;
d /= 10;
--p;
}
s[n] = '\0';
cout << s << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[10], b[10];
int main() {
while (cin >> n) {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
int q, w, e;
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &q, &w, &e);
if (q == 1)
a[0] += w, a[1] += e;
else if (q == 2)
b[0] += w, b[1] += e;
}
if (a[0] * 2 >= a[1] + a[0])
cout << "LIVE" << endl;
else
cout << "DEAD" << endl;
if (b[0] * 2 >= b[1] + b[0])
cout << "LIVE" << endl;
else
cout << "DEAD" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 100005, INF = 1000000000, mod = 314000000;
const long long int LINF = 1000000000000000000ll;
const double eps = 1e-9;
const int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, -1, 0, 1};
int n, m;
int a[MX], c[MX], d[MX], e[MX];
vector<int> t[MX], u[MX], b[MX];
bool can[MX], ok[MX], used[MX];
int mn[MX], mx[MX];
int main() {
int x, y, z;
scanf("%d%d", &m, &n);
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
t[--x].push_back(i);
for (int j = 0; j < y; j++) {
scanf("%d", &z);
if (z == -1)
c[i]++;
else {
b[i].push_back(--z);
u[z].push_back(i);
}
}
d[i] = b[i].size();
e[i] = x;
}
queue<int> q;
for (int i = 0; i < n; i++) {
bool bl = false;
for (int j = 0; j < t[i].size(); j++)
if (!d[t[i][j]]) bl = true;
if (bl) q.push(i);
}
while (!q.empty()) {
x = q.front();
q.pop();
if (can[x]) continue;
can[x] = true;
for (int i = 0; i < u[x].size(); i++) {
d[u[x][i]]--;
if (!d[u[x][i]]) q.push(e[u[x][i]]);
}
}
for (int i = 0; i < m; i++) {
x = e[i];
d[i] = b[i].size();
if (!can[x]) continue;
bool bl = true;
for (int j = 0; j < b[i].size(); j++) {
if (!can[b[i][j]]) bl = false;
}
if (bl) ok[i] = true;
}
for (int i = 0; i < n; i++) {
if (!can[i]) continue;
bool bl = true;
mn[i] = mod;
mx[i] = 0;
a[i] = 0;
for (int j = 0; j < t[i].size(); j++) {
x = t[i][j];
if (ok[x] && b[x].size()) {
bl = false;
a[i]++;
}
}
if (bl) q.push(i);
}
while (!q.empty()) {
x = q.front();
q.pop();
if (used[x]) continue;
used[x] = true;
if (!can[x]) continue;
int dw = mod, up = 0;
int dwx, upx;
for (int i = 0; i < t[x].size(); i++) {
y = t[x][i];
if (!ok[y]) continue;
dwx = upx = c[y];
for (int j = 0; j < b[y].size(); j++) {
dwx += mn[b[y][j]];
upx += mx[b[y][j]];
dwx = min(dwx, mod);
upx = min(upx, mod);
}
dw = min(dw, dwx);
up = max(up, upx);
}
mn[x] = dw;
mx[x] = min(mod, up);
for (int i = 0; i < u[x].size(); i++) {
if (!ok[u[x][i]]) continue;
d[u[x][i]]--;
if (!d[u[x][i]]) {
y = e[u[x][i]];
a[y]--;
if (!a[y]) q.push(y);
}
}
}
priority_queue<pair<int, int>, vector<pair<int, int> >,
greater<pair<int, int> > >
pq;
for (int i = 0; i < n; i++) {
if (!can[i] || used[i]) continue;
mx[i] = -2;
for (int j = 0; j < t[i].size(); j++) {
x = t[i][j];
if (ok[x] && !d[x]) {
z = c[x];
for (int k = 0; k < b[x].size(); k++) {
z += mn[b[x][k]];
z = min(z, mod);
}
mn[i] = min(mn[i], z);
}
}
pq.push(pair<int, int>(mn[i], i));
}
while (!pq.empty()) {
x = pq.top().second;
pq.pop();
if (used[x]) continue;
used[x] = true;
if (!can[x]) continue;
for (int i = 0; i < u[x].size(); i++) {
z = u[x][i];
if (!ok[z]) continue;
d[z]--;
if (!d[z]) {
y = e[z];
int cnt = c[z];
for (int j = 0; j < b[z].size(); j++) {
cnt += mn[b[z][j]];
cnt = min(cnt, mod);
}
if (cnt < mn[y]) {
mn[y] = cnt;
pq.push(pair<int, int>(cnt, y));
}
}
}
}
for (int i = 0; i < n; i++) {
if (can[i]) {
printf("%d %d\n", mn[i], mx[i]);
} else {
printf("-1 -1\n");
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int res = 0;
int neg;
while (true) {
char ch = getchar();
if (ch >= '0' && ch <= '9' || ch == '-') {
if (ch == '-')
neg = -1;
else
neg = 1, res = ch - '0';
break;
}
}
while (true) {
char ch = getchar();
if (ch >= '0' && ch <= '9')
res *= 10, res += ch - '0';
else
break;
}
return res * neg;
}
const int maxn = 100020;
const int maxm = 1000020;
const int MOd = 1e9 + 7;
const int K = 350;
int dad[maxn], a, k, b;
int gec[maxn];
int num, ans[maxn];
vector<int> g;
int find(int n) {
if (n == dad[n]) return n;
return dad[n] = find(dad[n]);
}
void merge(int j, int k) {
j = find(j);
k = find(k);
if (j != k) dad[j] = k, num--;
}
vector<int> nex[maxn], pre[maxn];
bool comp(const pair<pair<int, int>, int> &a,
const pair<pair<int, int>, int> &b) {
if ((a.first.first / K) == (b.first.first / K))
return a.first.second < b.first.second;
return (a.first.first / K) < (b.first.first / K);
}
int main() {
int a, kk, b;
scanf("%d %d %d", &a, &kk, &b);
for (int i = 1, j, k; i <= b; i++) {
scanf("%d %d", &j, &k);
if (j > k) swap(j, k);
nex[j].push_back(k);
pre[k].push_back(j);
}
int q;
scanf("%d", &q);
vector<pair<pair<int, int>, int> > v;
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d %d", &l, &r);
v.push_back(pair<pair<int, int>, int>(pair<int, int>(l, r), i));
}
sort(v.begin(), v.end(), comp);
int last = -1, R = 0, L = 0;
for (int i = 0; i < v.size(); i++) {
if ((v[i].first.first / K) != last) {
last = v[i].first.first / K;
for (int j = 1; j <= a; j++) dad[j] = j;
L = (last + 1) * K;
R = L - 1;
num = 0;
}
int l = v[i].first.first;
int r = v[i].first.second;
while (R < r) {
++R;
num++;
for (int j = 0; j < pre[R].size(); j++)
if (pre[R][j] >= L) merge(pre[R][j], R);
}
g.clear();
int oldnum = num;
for (int j = min(L - 1, r); j >= l; j--) {
dad[j] = j;
num++;
for (int k = 0; k < nex[j].size(); k++) {
int h = nex[j][k];
if (h <= r) {
h = find(h);
if (gec[h]) h = find(gec[h]);
if (h != j) {
num--;
if (h < L)
dad[h] = j;
else
gec[h] = j, g.push_back(h);
}
}
}
}
ans[v[i].second] = num;
num = oldnum;
for (int j = 0; j < g.size(); j++) gec[g[j]] = 0;
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
multiset<int> s[200005];
multiset<int>::iterator it;
vector<int> e[200005], G[200005];
stack<int> st;
int n, m, q, dfn[200005], low[200005], tim, cnt, w[200005], bel[200005];
bool vis[200005];
void tarjan(int u, int fa) {
dfn[u] = low[u] = ++tim;
st.push(u);
vis[u] = 1;
for (int i = 0; i < e[u].size(); ++i) {
int v = e[u][i];
if (v == fa) continue;
if (!dfn[v]) {
tarjan(v, u);
low[u] = min(low[u], low[v]);
if (low[v] >= dfn[u]) {
++cnt;
int tmp;
G[u].push_back(cnt);
do {
tmp = st.top();
st.pop();
G[cnt].push_back(tmp);
s[cnt].insert(w[tmp]);
bel[tmp] = cnt;
} while (tmp != v);
w[cnt] = *(s[cnt].begin());
}
} else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
}
int siz[200005], f[200005], dep[200005], son[200005], top[200005], id[200005],
wt[200005];
void dfs1(int u) {
siz[u] = 1;
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
dep[v] = dep[u] + 1;
f[v] = u;
dfs1(v);
siz[u] += siz[v];
if (siz[v] > siz[son[u]]) son[u] = v;
}
}
void dfs2(int u, int topf) {
top[u] = topf;
wt[id[u] = ++tim] = u;
if (son[u]) dfs2(son[u], topf);
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
if (v == son[u]) continue;
dfs2(v, v);
}
}
int sum[200005 << 2];
void build(int o, int l, int r) {
if (l == r) {
sum[o] = w[wt[l]];
return;
}
int mid = l + r >> 1;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
sum[o] = min(sum[o << 1], sum[o << 1 | 1]);
}
void updata(int o, int l, int r, int u, int val) {
if (l == r) {
sum[o] = val;
return;
}
int mid = l + r >> 1;
if (u <= mid)
updata(o << 1, l, mid, u, val);
else
updata(o << 1 | 1, mid + 1, r, u, val);
sum[o] = min(sum[o << 1], sum[o << 1 | 1]);
}
int check(int o, int l, int r, int u, int v) {
if (u <= l && r <= v) {
return sum[o];
}
int res = 1e9 + 7, mid = l + r >> 1;
if (u <= mid) res = min(res, check(o << 1, l, mid, u, v));
if (v > mid) res = min(res, check(o << 1 | 1, mid + 1, r, u, v));
return res;
}
void modify(int u, int val) {
if (bel[u]) {
it = s[bel[u]].find(w[u]);
s[bel[u]].erase(it);
}
w[u] = val;
updata(1, 1, cnt, id[u], val);
if (bel[u]) {
s[bel[u]].insert(w[u]);
w[bel[u]] = *(s[bel[u]].begin());
updata(1, 1, cnt, id[bel[u]], w[bel[u]]);
}
}
int query(int u, int v) {
int res = 1e9 + 7;
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
res = min(res, check(1, 1, cnt, id[top[u]], id[u]));
u = f[top[u]];
}
if (dep[u] > dep[v]) swap(u, v);
res = min(res, check(1, 1, cnt, id[u], id[v]));
if (u > n && f[u]) res = min(res, w[f[u]]);
return res;
}
int main() {
scanf("%d %d %d", &n, &m, &q);
cnt = n;
for (int i = 1; i <= n; ++i) scanf("%d", &w[i]);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
tarjan(1, 0);
dfs1(1);
tim = 0;
dfs2(1, 0);
build(1, 1, cnt);
while (q--) {
char opt[1];
int x, y;
scanf("%s %d %d", opt, &x, &y);
if (opt[0] == 'C')
modify(x, y);
else
printf("%d\n", query(x, y));
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
char st[123456];
char now[123456];
int good[300];
int l1, l2;
int dfs(int i, int j) {
if (i == l1 && j == l2) return 1;
if (i >= l1) return 0;
if (st[i] != '*' && j >= l2) return 0;
if (st[i] == '*') {
if (i && st[i - 1] == '*')
if (dfs(i + 1, j)) return 1;
{
if (dfs(i + 1, j)) return 1;
while (j < l2 && !good[now[j]]) {
if (dfs(i + 1, j + 1)) return 1;
j++;
}
}
} else if (st[i] == '?') {
if (good[now[j]]) {
if (dfs(i + 1, j + 1)) return 1;
}
} else if (st[i] == now[j])
if (dfs(i + 1, j + 1)) return 1;
return 0;
}
int main() {
scanf("%s", st);
int l = strlen(st);
for (int i = 0; i < l; i++) {
good[st[i]] = 1;
}
scanf("%s", st);
l1 = strlen(st);
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", now);
l2 = strlen(now);
if (dfs(0, 0))
printf("YES\n");
else
printf("NO\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 100032;
const int MOD = 1000000009;
int N;
int M;
vector<int> edges[N_MAX];
int markers[N_MAX];
vector<int> components[N_MAX];
void init();
void fuse(int a, int b) {
if (components[a].size() > components[b].size()) {
fuse(b, a);
return;
}
for (int i = 0; i < components[a].size(); i++) {
markers[components[a][i]] = b;
components[b].push_back(components[a][i]);
}
}
int main() {
init();
int count = 1;
for (int i = 0; i < M; i++) {
int start, end;
cin >> start >> end;
start--;
end--;
if (markers[start] == markers[end]) {
count *= 2;
count %= MOD;
} else {
fuse(markers[start], markers[end]);
}
cout << count - 1 << '\n';
}
return 0;
}
void init() {
cin >> N >> M;
for (int i = 0; i < N; i++) {
markers[i] = i;
components[i].push_back(i);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename item>
item abs(item i) {
if (i < 0) i = -i;
return i;
}
template <class type>
type POW(type b, type p) {
type res = 1;
while (p) {
if (p & 1) res *= b;
b *= b;
b %= 1000000007LL;
res %= 1000000007LL;
p /= 2;
}
return res;
}
int tc = 0;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
map<int, int> mp;
vector<int> v;
int cnt = 0, tot = 0;
for (int i = 1; i <= n; i++) {
int r;
cin >> r;
if (r > 0) {
if (mp[r]) {
cout << -1;
return 0;
} else {
mp[r]++;
cnt++;
}
} else {
if (mp[-r] != 1) {
cout << -1;
return 0;
} else {
mp[-r]++;
cnt--;
}
}
tot++;
if (!cnt) {
v.push_back(tot);
;
tot = 0;
mp.clear();
}
}
if (cnt) {
cout << -1;
return 0;
}
cout << v.size() << "\n";
for (auto &x : v) cout << x << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int solve(string s, int x, int y) {
int rep = 0;
for (char c : s) {
if (c - '0' == x) {
rep++;
swap(x, y);
}
}
if (rep & 1 && x != y) rep--;
return rep;
}
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int ans = 0, x, y, rep;
for (x = 0; x < 10; x++) {
for (y = 0; y < 10; y++) {
ans = max(ans, solve(s, x, y));
}
}
cout << s.size() - ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
long long mu[20], f[40][20][20];
long next[40][20][20];
char xau[40], kq[40];
int main() {
long i, j, k, l;
scanf("%ld\n", &l);
gets(xau + 1);
mu[1] = 1;
for (i = 2; i <= l; i++) mu[i] = mu[i - 1] * 10;
for (i = 0; i <= 2 * l; i++)
for (j = 0; j <= l; j++)
for (k = 0; k <= l; k++) f[i][j][k] = -9000000;
f[2 * l + 1][0][0] = 0;
for (i = 2 * l; i >= 1; i--)
for (j = 0; j <= l; j++)
for (k = 0; k <= l; k++) {
if (j > 0) {
f[i][j][k] = f[i + 1][j - 1][k] + mu[j] * (xau[i] - 48);
next[i][j][k] = 0;
}
if (k > 0 && f[i + 1][j][k - 1] + mu[k] * (xau[i] - 48) > f[i][j][k]) {
f[i][j][k] = f[i + 1][j][k - 1] + mu[k] * (xau[i] - 48);
next[i][j][k] = 1;
}
}
j = k = l;
for (i = 1; i <= 2 * l; i++)
if (next[i][j][k]) {
printf("H");
k--;
} else {
printf("M");
j--;
}
printf("\n");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = numeric_limits<int>::max();
template <class T>
struct RMQ {
vector<vector<T>> jmp;
RMQ(const vector<T>& V) {
int N = (int)(V).size(), on = 1, depth = 1;
while (on < (int)(V).size()) on *= 2, depth++;
jmp.assign(depth, V);
for (int i = 0; i < (depth - 1); ++i)
for (int j = 0; j < (N); ++j)
jmp[i + 1][j] = min(jmp[i][j], jmp[i][min(N - 1, j + (1 << i))]);
}
T query(int a, int b) {
if (b <= a) return inf;
int dep = 31 - __builtin_clz(b - a);
return min(jmp[dep][a], jmp[dep][b - (1 << dep)]);
}
};
struct Tree {
const long long LOW = 1e18;
long long f(long long a, long long b) { return min(a, b); }
int n;
vector<long long> s;
Tree() {}
Tree(int m, long long def = 0) { init(m, def); }
void init(int m, long long def) {
n = 1;
while (n < m) n *= 2;
s.assign(n + m, def);
s.resize(2 * n, LOW);
for (int i = n; i-- > 1;) s[i] = f(s[i * 2], s[i * 2 + 1]);
}
void update(int pos, long long val) {
pos += n;
s[pos] = val;
for (pos /= 2; pos >= 1; pos /= 2) s[pos] = f(s[pos * 2], s[pos * 2 + 1]);
}
long long query(int l, int r) { return que(1, l, r, 0, n); }
long long que(int pos, int l, int r, int lo, int hi) {
if (r <= lo || hi <= l) return LOW;
if (l <= lo && hi <= r) return s[pos];
int m = (lo + hi) / 2;
return f(que(2 * pos, l, r, lo, m), que(2 * pos + 1, l, r, m, hi));
}
};
int main() {
int n, c;
scanf("%d %d", &n, &c);
vector<int> a(n);
long long sum = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
RMQ<int> rmq(a);
Tree tree(n);
tree.update(c - 1, -rmq.query(0, c));
for (int i = c; i < n; i++) {
tree.update(
i, min(tree.query(i - c + 1, i),
tree.query(i - c, i - c + 1) - rmq.query(i - c + 1, i + 1)));
}
cout << sum + tree.query(n - 1, n) << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
static long long mi[824290][20];
long long qry(int l, int r) {
int t = r - l + 1;
return min(mi[l][31 - __builtin_clz(t)],
mi[r - (1 << (31 - __builtin_clz(t)))][31 - __builtin_clz(t)]);
}
int main() {
long long n, a, b, c, d, start, len;
scanf("%lld %lld %lld %lld %lld %lld %lld", &n, &a, &b, &c, &d, &start, &len);
vector<pair<long long, long long> > v;
for (long long i = 0; i < n; i++) {
long long x, y;
scanf("%lld %lld", &x, &y);
v.push_back(make_pair(y, x));
}
static long long psum[300005];
if (v[0].first == 0)
psum[0] = -d;
else
psum[0] = c;
for (int i = 1; i < n; i++) {
if (v[i].first)
psum[i] = psum[i - 1] + c;
else
psum[i] = psum[i - 1] - d;
}
for (int i = 0; i < n; i++) mi[i][0] = psum[i];
for (int j = 1; j < 20; j++) {
for (int i = 0; i < n; i++) {
mi[i][j] = min(mi[i][j - 1], mi[i + (1 << (j - 1))][j - 1]);
}
}
vector<long long> t;
t.push_back(0);
for (int i = 0; i < n; i++) {
t.push_back(v[i].second + 1);
if (v[i].second - len + 1 >= 0) t.push_back(v[i].second - len + 1);
}
sort(t.begin(), t.end());
int l = 0, r = 0;
long long at = start;
for (int i = 0; i < t.size(); i++) {
while (l < v.size() && v[l].second < t[i]) {
if (v[l].first)
at += a;
else
at -= b;
if (at < 0) {
printf("-1\n");
return 0;
}
l++;
}
while (r < v.size() && v[r].second < t[i] + len) r++;
long long low = qry(l, r) - (l > 0 ? psum[l - 1] : 0) + at;
if (low >= 0) {
printf("%lld\n", t[i]);
return 0;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
if (m == 0) return cout << 1, 0;
cout << min(n - m, m);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return a * (b / gcd(a, b));
}
int main() {
int t;
cin >> t;
for (int x = 0; x < t; x++) {
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++) {
int p;
cin >> p;
v.push_back(p);
}
int l = 0, r = n - 1;
int sum1 = 0, sum2 = 0;
int moves = 0, ans1 = 0, ans2 = 0;
while (l <= r) {
if (moves % 2 == 0) {
int nsum1 = 0;
while (l <= r && nsum1 <= sum2) nsum1 += v[l++];
sum1 = nsum1;
ans1 += nsum1;
}
if (moves % 2 == 1) {
int nsum2 = 0;
while (l <= r && nsum2 <= sum1) nsum2 += v[r--];
ans2 += nsum2;
sum2 = nsum2;
}
moves++;
}
cout << moves << " " << ans1 << " " << ans2 << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
set<long long> s;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
if (a != 0) s.insert(a);
}
cout << s.size();
}
int32_t main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
std::cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
void change(map<long long, long long> &m, long long n) {
long long i;
for (long long i = 1; i < n + 1; i++) {
if (m[i] == 1)
m.erase(i);
else
m[i]--;
}
return;
}
void solve() {
long long n, i, l, t;
cin >> n >> t;
string ans = "";
map<long long, long long> m;
for (long long i = 0; i < t; i++) {
cin >> l;
m[l]++;
if ((long long)m.size() == n) {
ans += "1";
change(m, n);
} else {
ans += "0";
}
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int ar[a];
for (int i = 0; i < a; i++) cin >> ar[i];
for (int i = 0; i < a - 1; i++)
for (int j = i + 1; j < a; j++)
if (ar[j] > ar[i]) swap(ar[i], ar[j]);
int bag = 0;
int count = 0;
for (int i = 0; i < a; i++) {
if (bag >= b)
break;
else {
bag = bag + ar[i];
count++;
}
}
cout << count << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
namespace IO {
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void setIO(string s = "") {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin.exceptions(cin.failbit);
if (s.size()) {
setIn(s + ".inp");
setOut(s + ".out");
} else {
}
}
} // namespace IO
using namespace IO;
namespace Function {
template <typename T1, typename T2>
void amax(T1 &a, T2 b) {
if (typeid(a).name() == typeid(int).name() &&
typeid(b).name() == typeid(long long).name()) {
cout << "Error on amax";
exit(0);
}
if (a < b) a = b;
}
template <typename T1, typename T2>
void amin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T>
void compress(vector<T> &a) {
sort(a.begin(), a.end());
a.resize(unique(a.begin(), a.end()) - a.begin());
}
template <typename T>
int get_it(vector<T> a, T b) {
return lower_bound(a.begin(), a.end(), b) - a.begin();
}
template <typename T1, typename T2>
long long gcd(T1 a, T2 b) {
return (b == 0 ? a : gcd(b, a % b));
}
template <typename T1, typename T2>
long long lcm(T1 a, T2 b) {
return 1LL * a / gcd(a, b) * b;
}
} // namespace Function
using namespace Function;
namespace Output {
void print(int x) { cout << x << "\n"; }
void print(unsigned int x) { cout << x << "\n"; }
void print(long unsigned int x) { cout << x << "\n"; }
void print(long long x) { cout << x << "\n"; }
void print(unsigned long long x) { cout << x << "\n"; }
void print(float x) { cout << x << "\n"; }
void print(double x) { cout << x << "\n"; }
void print(long double x) { cout << x << "\n"; }
void print(char x) { cout << x << "\n"; }
void print(const char *x) { cout << x << "\n"; }
void print(string x) { cout << x << "\n"; }
void print(bool x) { cout << (x ? "True" : "False") << "\n"; }
template <typename T1, typename T2>
void print(pair<T1, T2> a) {
cout << a.first << " " << a.second << "\n";
}
template <typename T>
void print(T a) {
for (auto it : a) {
print(it);
}
}
template <class T, class... Ts>
void print(T t, Ts... ts) {
cout << t << " ";
print(ts...);
}
template <typename T>
void prine(T x) {
print(x);
exit(0);
}
template <class T, class... Ts>
void prine(T t, Ts... ts) {
print(t, ts...);
exit(0);
}
} // namespace Output
using namespace Output;
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
const int INF = 1e9;
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
int lab[N], n, m, c[N];
int Get(int u) {
while (lab[u] > 0) u = lab[u];
return u;
}
void Union(int u, int v) {
if (lab[u] > lab[v]) swap(u, v);
lab[u] += lab[v];
lab[v] = u;
}
struct Data {
int u, v, w;
};
bool comp(Data A, Data B) { return A.w > B.w; }
vector<Data> E;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
E.push_back({u, v, min(c[u], c[v])});
}
sort(E.begin(), E.end(), comp);
long long sum = 0;
for (int i = 1; i <= n; i++) lab[i] = -1;
for (Data X : E) {
int u = X.u;
int v = X.v;
int w = X.w;
int x = Get(u);
int y = Get(v);
if (x == y) continue;
sum += 1ll * w * lab[x] * lab[y];
Union(x, y);
}
sum *= 2;
cout << fixed << setprecision(5) << 1.00 * sum / (1ll * n * (n - 1));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, p;
cin >> n;
p = n - (n / 2 + n / 3 + n / 5 + n / 7) +
(n / 14 + n / 6 + n / 15 + n / 35 + n / 10 + n / 21) -
(n / 42 + n / 30 + n / 105 + n / 70) + (n / 210);
cout << p;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int N = 2550;
int grid[N][N];
int minimo[N][N];
vector<pair<int, int> > matrix[N];
bool flagI[N];
bool flagJ[N];
int main(void) {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
scanf("%d", &grid[i][j]);
matrix[i].push_back(make_pair(grid[i][j], -j));
}
sort(matrix[i].begin(), matrix[i].end());
}
for (int i = 0; i < n; i++) {
if (grid[i][i]) {
cout << "NOT MAGIC" << endl;
return 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] != grid[j][i]) {
cout << "NOT MAGIC" << endl;
return 0;
}
}
}
for (int i = 0; i < n; i++) {
minimo[i][i] = grid[i][0];
for (int j = 1; j < n; j++) {
minimo[i][i] = min(minimo[i][i], grid[i][j]);
}
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
memset(flagI, false, sizeof flagI);
memset(flagJ, false, sizeof flagJ);
for (int k = 0; k < n; k++) {
int I = -matrix[i][k].second, J = -matrix[j][k].second;
if (I == J) {
minimo[i][j] = max(matrix[i][k].first, matrix[j][k].first);
break;
} else if (flagJ[I] and flagI[J]) {
minimo[i][j] = max(matrix[i][k].first, matrix[j][k].first);
break;
} else if (flagJ[I]) {
minimo[i][j] = max(matrix[i][k].first, grid[j][J]);
break;
} else if (flagI[J]) {
minimo[i][j] = max(matrix[j][k].first, grid[i][I]);
break;
}
flagI[I] = flagJ[J] = true;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (grid[i][j] > (j > i ? minimo[i][j] : minimo[j][i])) {
cout << "NOT MAGIC" << endl;
return 0;
}
}
}
cout << "MAGIC" << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int countO = 0, countI = 0;
int a[n + 1];
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 0)
countO++;
else
countI++;
}
int countOO = 0, countII = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 0)
countOO++;
else
countII++;
if (countOO == countO) {
cout << i + 1;
break;
}
if (countII == countI) {
cout << i + 1;
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct item {
int key, prior, cnt, sum;
item *l, *r;
item() {}
item(int key, int prior) : key(key), prior(prior), l(NULL), r(NULL) {}
};
typedef item* pitem;
int cnt(pitem t) { return t ? t->cnt : 0; }
int sm(pitem t) { return t ? t->sum : 0; }
void upd(pitem t) {
if (t) {
t->cnt = 1 + cnt(t->l) + cnt(t->r);
t->sum = t->key + sm(t->l) + sm(t->r);
}
}
void split(pitem t, int key, pitem& l, pitem& r) {
if (!t)
l = r = NULL;
else if (key < t->key)
split(t->l, key, l, t->l), r = t;
else
split(t->r, key, t->r, r), l = t;
upd(t);
}
void insert(pitem& t, pitem it) {
if (!t)
t = it;
else if (it->prior > t->prior)
split(t, it->key, it->l, it->r), t = it;
else
insert(it->key < t->key ? t->l : t->r, it);
upd(t);
}
void merge(pitem& t, pitem l, pitem r) {
if (!l || !r)
t = l ? l : r;
else if (l->prior > r->prior)
merge(l->r, l->r, r), t = l;
else
merge(r->l, l, r->l), t = r;
upd(t);
}
void erase(pitem& t, int key) {
if (t->key == key)
merge(t, t->l, t->r);
else
erase(key < t->key ? t->l : t->r, key);
upd(t);
}
int get(pitem t, int count) {
if (!t || count <= 0)
return 0;
else {
if (t->cnt == count)
return t->sum;
else {
int j = min(count, cnt(t->l));
return get(t->l, j) + (count > j ? t->key : 0) + get(t->r, count - 1 - j);
}
}
}
pitem root = NULL;
int main() {
srand(time(NULL));
int n;
cin >> n;
vector<int> l(n), d(n);
for (int i = 0; i < n; ++i) {
cin >> l[i];
}
for (int i = 0; i < n; ++i) {
cin >> d[i];
}
vector<pair<int, int> > p(n);
int base_e = 0;
for (int i = 0; i < n; ++i) {
p[i] = make_pair(l[i], d[i]);
base_e += d[i];
}
sort(p.begin(), p.end());
int start = 0, finish = 0;
int min_e = 1000 * 1000 * 1000;
while (start < n) {
finish++;
if (finish == n || p[finish].first != p[start].first) {
int count = finish - start;
int x = max(0, n - 2 * count + 1 - (n - finish));
int e = 0;
for (int i = start; i < finish; ++i) {
base_e -= p[i].second;
}
e += get(root, x);
for (int i = start; i < finish; ++i) {
insert(root, new item(p[i].second, rand()));
}
e += base_e;
min_e = min(e, min_e);
start = finish;
}
}
cout << min_e;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long int ans = 0;
for (int i = 1; i <= n; i++) {
int k1, k2, x1, x2;
cin >> x1 >> k1 >> x2 >> k2;
ans += abs((abs(k1 - k2) + 1) * (abs(x1 - x2) + 1));
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
const int MOD = 10000000000000000007;
template <class T>
inline T sqr(const T x) {
return x * x;
}
template <class T1, class T2>
inline T1 POW(const T1 x, const T2 y) {
if (!y)
return 1;
else if ((y & 1) == 0) {
return sqr(POW(x, y >> 1));
} else
return POW(x, y ^ 1) * x;
}
template <class T>
inline T GCD(const T x, const T y) {
if (x < 0) return GCD(-x, y);
if (y < 0) return GCD(x, -y);
return (!y) ? x : GCD(y, x % y);
}
template <class T>
inline T LCM(const T x, const T y) {
if (x < 0) return LCM(-x, y);
if (y < 0) return LCM(x, -y);
return x * (y / GCD(x, y));
}
template <class T>
inline T EEA(const T a, const T b, T &x, T &y) {
if (a < 0) {
T d = EEA(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = EEA(a, -b, x, y);
y = -y;
return d;
}
if (!b) {
x = 1;
y = 0;
return a;
} else {
T d = EEA(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline vector<pair<T, int> > FACTORIZE(T x) {
vector<pair<T, int> > ret;
if (x < 0) x = -x;
for (T i = 2; x > 1;) {
if (x % i == 0) {
int count = 0;
for (; x % i == 0; x /= i) count++;
ret.push_back(MP(i, count));
}
i++;
if (i > x / i) i = x;
}
return ret;
}
template <class T>
inline int ISPRIME(const T x) {
if (x <= 1) return 0;
for (T i = 2; sqr(i) <= x; i++)
if (x % i == 0) return 0;
return 1;
}
template <class T>
inline T EULARFUNCTION(T x) {
vector<pair<T, int> > f = FACTORIZE(x);
for (typename vector<pair<T, int> >::iterator it = f.begin(); it != f.end();
it++) {
x = x / it->first * (it->first - 1);
}
return x;
}
template <class T>
inline T INVERSEE(const T a, const T b) {
T x, y;
EEA(a, b, x, y);
return x ? x : 1;
}
template <class T>
inline T MOD_STD(const T x, const T m) {
return (x % m + m) % m;
}
template <class T>
inline T MOD_STD(const T x) {
return (x % MOD + MOD) % MOD;
}
template <class T>
inline T MOD_ADD(const T x, const T y, const T m) {
return (x + y) % m;
}
template <class T>
inline T MOD_ADD(const T x, const T y) {
return (x + y) % MOD;
}
template <class T>
inline void MOD_ADD(T *x, const T y, const T m) {
*x = (*x + y) % m;
}
template <class T>
inline void MOD_ADD(T *x, const T y) {
*x = (*x + y) % MOD;
}
template <class T>
inline T MOD_MUL(const T x, const T y, const T m) {
return (T)((1LL * x * y) % m);
}
template <class T>
inline T MOD_MUL(const T x, const T y) {
return (T)((1LL * x * y) % MOD);
}
template <class T>
inline void MOD_MUL(T *x, const T y, const T m) {
*x = (T)((1LL * (*x) * y) % m);
}
template <class T>
inline void MOD_MUL(T *x, const T y) {
*x = (T)((1LL * (*x) * y) % MOD);
}
template <class T1, class T2>
inline T1 MOD_POW(const T1 x, const T2 y, const T1 m) {
if (y == 0)
return 1 % m;
else if ((y & 1) == 0) {
T1 z = MOD_POW(x, y >> 1, m);
return MOD_MUL(z, z, m);
} else
return MOD_MUL(MOD_POW(x, y ^ 1, m), x, m);
}
template <class T1, class T2>
inline T1 MOD_POW(const T1 x, const T2 y) {
if (y == 0)
return 1 % MOD;
else if ((y & 1) == 0) {
T1 z = MOD_POW(x, y >> 1);
return MOD_MUL(z, z);
} else
return MOD_MUL(MOD_POW(x, y ^ 1), x);
}
const int N_MAX = 400000;
const int SUP_I = (int)1e+9;
const unsigned long long int SUP_LL = (unsigned long long int)1e+16;
const double EPS = 1e-6;
const double pi = 3.14159265358979323846;
const double E = 2.7182818284590452354;
double DEG(double x) { return (180.0 * x) / (pi); }
double RAD(double x) { return (x * (double)pi) / (180.0); }
template <typename T>
T DIS(T x1, T y1, T x2, T y2) {
return sqrt((double)((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)));
}
template <typename T>
T ANGLE(T x1, T y1, T x2, T y2) {
return atan(double(y1 - y2) / double(x1 - x2));
}
template <typename T>
long long isLeft(T a, T b, T c) {
return (c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y);
}
char buffer[N_MAX];
class Comparator {
public:
bool operator()(char *a, char *b) { return (strcmp(a, b) < 0); }
};
string s;
int length, query;
int f() {
int result = 0;
int countDot = 0;
int s_length = s.length();
for (int i = 0; i < s_length; i++) {
if (s[i] != '.') {
if (countDot > 1) {
result += (countDot - 1);
}
countDot = 0;
continue;
}
if (s[i] == '.') countDot++;
}
if (countDot > 1) {
result += (countDot - 1);
}
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> length >> query;
cin >> s;
s = "a" + s + "a";
int position;
char value;
int lastCount = f();
for (int i = 0; i < query; i++) {
cin >> position >> value;
;
if (value == '.') {
if (s[position] == value) {
cout << lastCount << '\n';
continue;
} else {
s[position] = value;
if (s[position - 1] != '.' && s[position + 1] != '.') {
cout << lastCount << '\n';
continue;
} else if (s[position - 1] == '.' && s[position + 1] == '.') {
lastCount += 2;
cout << lastCount << '\n';
continue;
} else {
lastCount += 1;
cout << lastCount << '\n';
continue;
}
}
} else {
if (s[position] != '.') {
cout << lastCount << '\n';
continue;
} else {
s[position] = value;
if (s[position - 1] != '.' && s[position + 1] != '.') {
cout << lastCount << '\n';
continue;
} else if (s[position - 1] == '.' && s[position + 1] == '.') {
lastCount -= 2;
cout << lastCount << '\n';
continue;
} else {
lastCount -= 1;
cout << lastCount << '\n';
continue;
}
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long a, gap[300000], gain[300000];
vector<pair<long long, long long>> l_seqs, r_seqs;
long long build(int l, int r) {
if (l == r) return gain[l] > 0 ? gain[l] : 0;
int i, j, k;
int mid = (l + r) / 2;
long long mx, l_mx, r_mx;
long long cur_gap, cur_sum, cur_l, cur_r;
l_mx = build(l, mid);
r_mx = build(mid + 1, r);
mx = 0;
mx = l_mx > mx ? l_mx : mx;
mx = r_mx > mx ? r_mx : mx;
l_seqs.clear();
r_seqs.clear();
cur_gap = gap[mid];
l_seqs.push_back({cur_gap, cur_sum = gain[mid]});
for (i = mid - 1; i >= l; i--) {
cur_sum += gain[i];
if (gap[i] > cur_gap) {
cur_gap = gap[i];
l_seqs.push_back({cur_gap, cur_sum});
} else if (cur_sum > l_seqs.back().second)
l_seqs.back().second = cur_sum;
}
cur_gap = gap[mid];
r_seqs.push_back({cur_gap, cur_sum = gain[mid + 1]});
for (i = mid + 2; i <= r; i++) {
cur_sum += gain[i];
if (gap[i - 1] > cur_gap) {
cur_gap = gap[i - 1];
r_seqs.push_back({cur_gap, cur_sum});
} else if (cur_sum > r_seqs.back().second)
r_seqs.back().second = cur_sum;
}
cur_gap = gap[mid];
auto l_it = l_seqs.begin();
auto r_it = r_seqs.begin();
cur_l = l_it->second;
cur_r = r_it->second;
cur_sum = cur_l + cur_r - cur_gap;
if (cur_sum > mx) mx = cur_sum;
while (l_it != l_seqs.end() && r_it != r_seqs.end()) {
if (l_it->first <= r_it->first) {
cur_gap = l_it->first;
if (l_it->second > cur_l) cur_l = l_it->second;
l_it++;
} else {
cur_gap = r_it->first;
if (r_it->second > cur_r) cur_r = r_it->second;
r_it++;
}
cur_sum = cur_l + cur_r - cur_gap;
if (cur_sum > mx) mx = cur_sum;
}
while (l_it != l_seqs.end()) {
cur_gap = l_it->first;
if (l_it->second > cur_l) cur_l = l_it->second;
l_it++;
cur_sum = cur_l + cur_r - cur_gap;
if (cur_sum > mx) mx = cur_sum;
}
while (r_it != r_seqs.end()) {
cur_gap = r_it->first;
if (r_it->second > cur_r) cur_r = r_it->second;
r_it++;
cur_sum = cur_l + cur_r - cur_gap;
if (cur_sum > mx) mx = cur_sum;
}
return mx;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int i, j, k;
cin >> n >> a;
for (i = 0; i < n; i++) {
cin >> gap[i] >> gain[i];
gain[i] = a - gain[i];
if (i) gap[i - 1] = (gap[i] - gap[i - 1]) * (gap[i] - gap[i - 1]);
}
cout << build(0, n - 1) << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200005];
vector<int> g[200005];
int f[18][200005];
long long s[18][200005];
int r[200005];
int w[200005];
void dfs(int x) {
r[x] = w[x];
for (int i = 0, to = g[x].size(); i < to; ++i) {
int y = g[x][i];
dfs(y);
r[x] += r[y];
}
}
int main() {
scanf("%d", &n);
for (int i = 0, to = n; i < to; ++i) scanf("%d", a + i);
memset(f, -1, sizeof(f));
memset(s, 0, sizeof(s));
for (int i = 1, to = n; i < to; ++i) {
scanf("%d%lld", &f[0][i], &s[0][i]);
f[0][i]--;
g[f[0][i]].push_back(i);
}
for (int k = 1, to = 18; k < to; ++k) {
for (int i = 0, to = n; i < to; ++i) {
if (f[k - 1][i] < 0) {
f[k][i] = -1;
s[k][i] = s[k - 1][i];
} else {
f[k][i] = f[k - 1][f[k - 1][i]];
s[k][i] = s[k - 1][i] + s[k - 1][f[k - 1][i]];
}
}
}
for (int x = 0, to = n; x < to; ++x) {
int y = x;
long long d = 0;
for (int k = 17; k >= 0; --k) {
if (f[k][y] >= 0 && d + s[k][y] <= a[x]) {
d += s[k][y];
y = f[k][y];
}
}
w[x]++;
w[y]--;
}
dfs(0);
for (int i = 0, to = n; i < to; ++i) {
if (i) putchar(' ');
printf("%d", r[i] - w[i]);
}
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct rw_t {
int e;
int i;
rw_t() {
this->i = 0;
this->e = 0;
}
rw_t(int i, int e) {
this->i = i;
this->e = e;
}
};
struct nd_t {
bool c;
std::vector<rw_t> nb;
};
int n = 0;
int k = 0;
int d = 0;
const int nums_max(300010);
std::vector<nd_t> grs(nums_max);
std::vector<int> rs(nums_max);
long long res = 0;
void dfs(int index) {}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(false);
cin >> n >> k >> d;
for (int i = 1; i <= n; ++i) {
grs[i].c = false;
}
std::deque<int> nxt;
int v;
for (int i = 1; i <= k; ++i) {
cin >> v;
nxt.push_back(v);
grs[v].c = true;
}
int r1, r2;
for (int i = 1; i < n; ++i) {
cin >> r1;
cin >> r2;
grs[r1].nb.push_back(rw_t(i, r2));
grs[r2].nb.push_back(rw_t(i, r1));
}
while (!nxt.empty()) {
nd_t& nd = grs[nxt.front()];
nxt.pop_front();
for (int i = 0; i < nd.nb.size(); ++i) {
int ni = nd.nb[i].e;
nd_t& nb = grs[ni];
if (nb.c) continue;
nb.c = true;
rs[nd.nb[i].i]++;
nxt.push_back(ni);
}
}
for (int i = 1; i < n; ++i) {
if (rs[i] == 0) res++;
}
cout << res << "\n";
for (int i = 1; i < n; ++i) {
if (rs[i] == 0) cout << i << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int u, int v) { return (v != 0) ? gcd(v, u % v) : u; }
long long dp[51][51][5001];
map<long long, int> h;
vector<pair<int, pair<int, pair<long long, long long> > > > vec;
int N, M;
long long ans, K;
vector<pair<int, long long> > res;
int temp;
long long solve(int ind, int counter, long long prevEX) {
long long &ret = dp[ind][counter][h[prevEX]];
if (counter == N) return ret = 0;
if (ind == M) return ret = -(int)5 * 1e18;
if (ret != -1) return ret;
long long Max = -(int)5 * 1e18;
for (int i = ind + 1; i < M; i++) {
if (vec[i].first > vec[ind].first) {
if (prevEX + K >= vec[i].second.second.first &&
prevEX + K <= vec[i].second.second.second) {
if (!h.count(prevEX + K)) h[prevEX + K] = temp++;
Max = max(Max, solve(i, counter + 1, prevEX + K) + prevEX + K);
}
if (prevEX * K >= vec[i].second.second.first &&
prevEX * K <= vec[i].second.second.second) {
if (!h.count(prevEX * K)) h[prevEX * K] = temp++;
Max = max(Max, solve(i, counter + 1, prevEX * K) + prevEX * K);
}
}
}
return ret = Max;
}
bool print(int ind, int counter, long long prevEX, long long total) {
if (counter == N) return 1;
if (ind == M) return 0;
for (int i = ind + 1; i < M; i++) {
if (vec[i].first > vec[ind].first) {
if (prevEX + K >= vec[i].second.second.first &&
prevEX + K <= vec[i].second.second.second) {
if (!h.count(prevEX + K)) h[prevEX + K] = temp++;
if (dp[i][counter + 1][h[prevEX + K]] + prevEX + K + total == ans) {
res.push_back(make_pair(vec[i].second.first, prevEX + K));
if (print(i, counter + 1, prevEX + K, total + prevEX + K)) return 1;
res.pop_back();
}
}
if (prevEX * K >= vec[i].second.second.first &&
prevEX * K <= vec[i].second.second.second) {
if (!h.count(prevEX * K)) h[prevEX * K] = temp++;
if (dp[i][counter + 1][h[prevEX * K]] + prevEX * K + total == ans) {
res.push_back(make_pair(vec[i].second.first, prevEX * K));
if (print(i, counter + 1, prevEX * K, total + prevEX * K)) return 1;
res.pop_back();
}
}
}
}
return 0;
}
int main() {
temp = 0;
ios_base::sync_with_stdio(false);
cin >> N >> M >> K;
long long a, b;
int c;
temp = 0;
memset(dp, -1, sizeof dp);
for (long long i = 0; i < M; i++) {
cin >> a >> b >> c;
vec.push_back(make_pair(c, make_pair(i + 1, make_pair(a, b))));
}
sort(vec.begin(), vec.end());
ans = -(int)5 * 1e18;
for (long long i = 0; i < M; i++) {
for (long long x = vec[i].second.second.first;
x <= vec[i].second.second.second; x++) {
if (!h.count(x)) h[x] = temp++;
ans = max(ans, solve(i, 1, x) + x);
}
}
if (ans < 0) {
cout << "NO" << endl;
return 0;
}
bool found = 0;
for (long long i = 0; i < M; i++) {
for (long long x = vec[i].second.second.first;
x <= vec[i].second.second.second; x++) {
if (!h.count(x)) h[x] = temp++;
if (dp[i][1][h[x]] != ans - x) continue;
res.clear();
res.push_back(make_pair(vec[i].second.first, x));
if (print(i, 1, x, x)) {
found = 1;
break;
}
}
if (found) break;
}
cout << "YES" << endl;
for (long long i = 0; i < res.size(); i++)
cout << res[i].first << " " << res[i].second << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int x, y, k, n, divi, put;
bool gasit = false;
int main() {
cin >> y >> k >> n;
divi = k;
put = 1;
while (divi <= n) {
x = divi - y;
if (x > 0) {
cout << x << " ";
gasit = true;
}
divi += k;
}
if (!gasit) cout << -1;
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.