solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
int main() {
int n, cur = 0;
vector<int> m;
stack<int> q;
string s, p;
while (cin >> p) s += p;
for (int i = 0; i < (int)s.length() - 3; ++i) {
if (s[i] != '/' && s[i + 2] == 'a') m.push_back(0), q.push(cur++);
if (s[i] != '/' && s[i + 2] == 'd') ++m[q.top()];
if (s[i] == '/' && s[i + 2] == 'a') q.pop();
}
sort(m.begin(), m.end());
for (int i = 0; i < (int)m.size(); ++i) cout << m[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int Read() {
char ch = getchar();
while (!((ch >= '0' && ch <= '9') || ch == '-')) ch = getchar();
int x = 0, p = 1;
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * p;
}
struct cht {
struct Line {
int a;
long long b;
long long val;
double xLeft;
bool type;
Line(long long _a = 0, long long _b = 0) {
a = _a;
b = _b;
xLeft = -2 * (1e18);
type = 0;
val = 0;
}
long long valueAt(int x) const { return 1LL * a * x + b; }
friend bool areParallel(const Line &l1, const Line &l2) {
return l1.a == l2.a;
}
friend double intersectX(const Line &l1, const Line &l2) {
return areParallel(l1, l2) ? 2 * (1e18)
: 1.0 * (l2.b - l1.b) / (l1.a - l2.a);
}
bool operator<(const Line &l2) const {
if (!l2.type) return a < l2.a;
return xLeft > l2.val;
}
};
set<Line> hull;
void init() { hull.clear(); }
bool hasPrev(set<Line>::iterator it) { return it != hull.begin(); }
bool hasNext(set<Line>::iterator it) {
return it != hull.end() && next(it) != hull.end();
}
bool irrelevant(const Line &l1, const Line &l2, const Line &l3) {
return intersectX(l1, l3) <= intersectX(l1, l2);
}
bool irrelevant(set<Line>::iterator it) {
return hasPrev(it) && hasNext(it) &&
(irrelevant(*next(it), *it, *prev(it)));
}
set<Line>::iterator updateLeftBorder(set<Line>::iterator it) {
if (!hasNext(it)) {
return it;
}
double val = intersectX(*it, *next(it));
Line buf(*it);
it = hull.erase(it);
buf.xLeft = val;
it = hull.insert(it, buf);
return it;
}
void addLine(int a, long long b) {
Line l3 = Line(a, b);
auto it = hull.lower_bound(l3);
if (it != hull.end() && areParallel(*it, l3)) {
if (it->b > b) {
it = hull.erase(it);
} else {
return;
}
}
it = hull.insert(it, l3);
if (irrelevant(it)) {
hull.erase(it);
return;
}
while (hasPrev(it) && irrelevant(prev(it))) {
hull.erase(prev(it));
}
while (hasNext(it) && irrelevant(next(it))) {
hull.erase(next(it));
}
it = updateLeftBorder(it);
if (hasPrev(it)) {
updateLeftBorder(prev(it));
}
if (hasNext(it)) {
updateLeftBorder(next(it));
}
}
long long getBest(int x) {
Line q;
q.val = x;
q.type = 1;
auto bestLine = hull.lower_bound(q);
if (bestLine == hull.end()) {
return 2 * (1e18);
}
return bestLine->valueAt(x);
}
} segTree[300005 << 2];
int TYPE[300005];
pair<int, int> ins[300005];
int qury[300005];
int deadline[300005];
void update(int t, int i, int j, const int &ri, const int &rj, const int &idx) {
if (ri <= i && j <= rj) {
segTree[t].addLine(-ins[idx].first, -ins[idx].second);
return;
}
int left = t << 1, right = left | 1, mid = (i + j) >> 1;
if (ri <= mid) update(left, i, mid, ri, rj, idx);
if (rj > mid) update(right, mid + 1, j, ri, rj, idx);
}
long long query(int t, int i, int j, const int &idx, long long ans) {
if (i == j) return max(ans, -segTree[t].getBest(qury[idx]));
int left = t << 1, right = left | 1, mid = (i + j) >> 1;
if (idx <= mid)
return query(left, i, mid, idx, max(ans, -segTree[t].getBest(qury[idx])));
return query(right, mid + 1, j, idx,
max(ans, -segTree[t].getBest(qury[idx])));
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) deadline[i] = n;
for (int i = 1; i <= n; i++) {
int t;
t = Read();
TYPE[i] = t;
if (t == 1) {
int a, b;
a = Read();
b = Read();
ins[i] = make_pair(a, b);
} else if (t == 2) {
int x;
x = Read();
deadline[x] = i;
} else if (t == 3) {
int q;
q = Read();
qury[i] = q;
}
}
for (int i = 1; i <= n; i++) {
if (TYPE[i] == 2) continue;
if (TYPE[i] == 1)
update(1, 1, n, i, deadline[i], i);
else {
long long x = query(1, 1, n, i, -3 * (1e18));
if (x == -2 * (1e18))
printf("EMPTY SET\n");
else
printf("%lld\n", x);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, M, G;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
cin >> n >> G;
M = G;
for (int i = 0, x; i < n - 1; i++) cin >> x, G = gcd(G, x), M = max(M, x);
M = M / G;
cout << (((M - n) % 2) ? "Alice" : "Bob");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, root = 1;
int root_red = -1, root_blue = -1;
vector<vector<int>> adj;
vector<int> color, cnt_red, cnt_blue, par;
vector<bool> used;
void dfs1(int v) {
used[v] = true;
cnt_red[v] = (color[v] == 1 ? 1 : 0);
cnt_blue[v] = (color[v] == 2 ? 1 : 0);
for (auto u : adj[v])
if (!used[u]) {
par[u] = v;
dfs1(u);
cnt_red[v] += cnt_red[u];
cnt_blue[v] += cnt_blue[u];
}
}
void dfs2(int v) {
used[v] = true;
for (auto u : adj[v])
if (!used[u]) dfs2(u);
if (root_red == -1 && cnt_red[v] == cnt_red[root]) root_red = v;
if (root_blue == -1 && cnt_blue[v] == cnt_blue[root]) root_blue = v;
}
int main() {
cin >> n;
color.resize(n + 1);
cnt_red.resize(n + 1);
cnt_blue.resize(n + 1);
par.resize(n + 1);
par[root] = -1;
for (int i = 1; i <= n; i++) cin >> color[i];
adj.resize(n + 1);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
used.assign(n + 1, false);
dfs1(root);
used.assign(n + 1, false);
dfs2(root);
set<int> s;
vector<int> vr = {root_red, root_blue};
for (auto cur : vr) {
while (cur != -1) {
if (cnt_red[cur] == 0 || cnt_blue[cur] == 0)
s.insert(cur);
else
break;
cur = par[cur];
}
}
cout << s.size() << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char a[100010];
char b[100010];
char c[100010];
int main() {
scanf("%s", a);
scanf("%s", b);
scanf("%s", c);
int fa[26] = {0}, fb[26] = {0}, fc[26] = {0};
int la = strlen(a);
int lb = strlen(b);
int lc = strlen(c);
for (int i = 0; i < la; i++) fa[a[i] - 'a']++;
for (int i = 0; i < lb; i++) fb[b[i] - 'a']++;
for (int i = 0; i < lc; i++) fc[c[i] - 'a']++;
int maxb = -1;
for (int i = 0; i < 26; i++) {
if (fb[i] && (maxb == -1 || maxb > fa[i] / fb[i])) maxb = fa[i] / fb[i];
}
int max = -1;
int muchb = 0, muchc = 0;
for (int i = 0; i < maxb + 1; i++) {
int maxc = -1;
for (int j = 0; j < 26; j++) {
if (fc[j] && (maxc == -1 || maxc > (fa[j] - i * fb[j]) / fc[j]))
maxc = (fa[j] - i * fb[j]) / fc[j];
}
if (max == -1 || max < maxc + i) {
max = maxc + i;
muchb = i;
muchc = maxc;
}
}
for (int i = 0; i < muchb; i++) printf("%s", b);
for (int i = 0; i < muchc; i++) printf("%s", c);
for (int i = 0; i < 26; i++) {
int r = fa[i] - muchb * fb[i] - muchc * fc[i];
while (r--) printf("%c", i + 'a');
}
printf("\n");
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 3e5 + 5;
int ans[MX];
vector<int> pos[MX];
int main() {
int i, j, k;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> vt;
for (i = 0; i < n; ++i) {
cin >> k;
if (pos[k].empty()) {
pos[k].push_back(0);
vt.push_back(k);
}
pos[k].push_back(i + 1);
}
sort(vt.begin(), vt.end());
for (i = 0; i < n; ++i) ans[i] = -1;
int last = n - 1;
for (i = 0; i < vt.size(); ++i) {
int mx = 0;
pos[vt[i]].push_back(n + 1);
for (j = 1; j < pos[vt[i]].size(); ++j) {
mx = max(mx, pos[vt[i]][j] - pos[vt[i]][j - 1]);
}
mx--;
for (j = mx; j <= last; ++j) {
ans[j] = vt[i];
}
last = min(last, mx - 1);
}
for (i = 0; i < n; ++i) cout << ans[i] << " ";
cout << endl;
for (auto x : vt) pos[x].clear();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int zeros = 0, fives = 0;
for (int i = 0; i < n; i++) {
int temp;
cin >> temp;
if (temp == 0)
zeros++;
else
fives++;
}
if (zeros == 0)
cout << -1 << endl;
else {
if (fives < 9)
cout << 0 << endl;
else {
for (int i = 0; i < (fives / 9) * 9; i++) cout << 5;
for (int i = 0; i < zeros; i++) cout << 0;
cout << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<long long> a(n), b(m);
for (int i = 0; i < n; i++) cin >> a[i];
for (int j = 0; j < m; j++) cin >> b[j];
vector<long long> ans;
for (int i = 0; i < n; i++) {
long long cmax = -1e18;
for (int ii = 0; ii < n; ii++)
if (i != ii) {
for (int j = 0; j < m; j++) {
cmax = max(cmax, a[ii] * b[j]);
}
}
ans.push_back(cmax);
}
sort((ans).begin(), (ans).end());
cout << ans[0];
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int x, y;
scanf("%d%d", &x, &y);
int sum;
sum = x + y;
int rem;
rem = (x * y) / 2;
printf("%d", (rem));
return 0;
}
| 0 |
#include <bits/stdc++.h>
const long long N = 105000;
const int mod = 1000000007;
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int pintar[2 * N];
vector<pair<int, int>> xd;
int dp[2 * N];
void solve(int m) {
dp[m + 1] = 0;
int n = xd.size();
for (int i = m; i >= 0; i--) {
if (pintar[i])
dp[i] = dp[i + 1];
else {
dp[i] = mod;
for (int j = 0; j < n; j++) {
if (i < xd[j].first)
dp[i] = min(dp[i],
xd[j].first - i + dp[xd[j].second + xd[j].first - i + 1]);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
xd.push_back({a - b, a + b});
for (int j = max(a - b, 0); j < min(m + 1, a + b) + 1; j++) pintar[j] = 1;
}
xd.push_back({m + 1, m + 1});
solve(m);
cout << dp[1] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
const long long INF = 1e18L + 1;
const int IINF = 1e9 + 1;
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, q;
cin >> n >> q;
pair<long long, long long> transf;
for (long long _ = (long long)0; _ < (long long)q; _++) {
long long typ;
cin >> typ;
if (typ == 1) {
long long rot;
cin >> rot;
rot = (n + rot) % n;
transf.first = (transf.first + rot) % n;
transf.second = (transf.second + rot) % n;
} else {
if (transf.first & 1) {
transf.first = (transf.first + n - 1) % n;
transf.second = (transf.second + 1) % n;
} else {
transf.first = (transf.first + 1) % n;
transf.second = (transf.second + n - 1) % n;
}
}
}
for (long long i = (long long)0; i < (long long)n; i++) {
if (((transf.first ^ i) & 1) == 0) {
cout << (n + i - transf.first) % n + 1 << " \n"[i == n - 1];
} else {
cout << (n + i - transf.second) % n + 1 << " \n"[i == n - 1];
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int inf;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T, class T2>
int chkmin(T &a, T2 b) {
return a > b ? a = b, 1 : 0;
}
template <class T, class T2>
int chkmax(T &a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T, class T2>
T mmin(T a, T2 b) {
return a < b ? a : b;
}
template <class T, class T2>
T mmax(T a, T2 b) {
return a > b ? a : b;
}
template <class T>
T aabs(T a) {
return a < 0 ? -a : a;
}
template <class T>
int dcmp(T a, T b) {
return a > b;
}
template <int *a>
int cmp_a(int first, int second) {
return a[first] < a[second];
}
template <class T>
bool sort2(T &a, T &b) {
return a > b ? swap(a, b), 1 : 0;
}
struct __INIT__ {
__INIT__() {
fill((unsigned char *)&inf, (unsigned char *)&inf + sizeof(inf), 0x3f);
}
} __INIT___;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char first) {
*oS++ = first;
if (oS == oT) flush();
}
template <typename A>
inline bool read(A &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(char &first) {
while ((first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == ' ' ||
first == '\n' || first == '\r')
;
return first != EOF;
}
inline bool read(char *first) {
while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*first == ' ' || *first == '\r')
;
if (*first == EOF) return 0;
while (!(*first == '\n' || *first == ' ' || *first == '\r' || *first == EOF))
*(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*first = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &first, B &...second) {
return read(first) && read(second...);
}
template <typename A>
inline bool write(A first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char first) {
putc(first);
return 0;
}
inline bool write(const char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
inline bool write(char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A first, B... second) {
return write(first) || write(second...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
namespace run {
vector<int> to[500005];
char s[500005];
int deg[500005];
bitset<500005> a;
bool main() {
int n;
read(n);
int u, v;
for (int i = 1; i <= n; ++i) to[i].clear();
for (int i = 1; i < n; ++i) {
read(u, v);
to[u].emplace_back(v);
to[v].emplace_back(u);
}
for (int i = 1; i <= n; ++i) deg[i] = to[i].size();
read(s + 1);
if (n <= 2) return write("Draw\n");
int c3 = 0;
for (int i = 1; i <= n; ++i)
if (deg[i] >= 4)
return write("White\n");
else if (deg[i] == 3) {
int cnt = 0;
for (auto j : to[i])
if (deg[j] > 1) ++cnt;
if (cnt > 1) return write("White\n");
++c3;
} else if (deg[i] == 2) {
if (deg[to[i][0]] >= 3 && deg[to[i][1]] >= 3) return write("White\n");
}
if (c3 >= 2 && n & 1) return write("White\n");
for (int i = 1; i <= n; ++i) a[i] = s[i] == 'W';
for (int i = 1; i <= n; ++i) {
int cnt = 0;
for (auto j : to[i]) cnt += a[j];
if ((a[i] + cnt) >= 2) return write("White\n");
}
int s = 0;
for (int i = 1; i <= n; ++i)
if (a[i]) {
if (deg[i] >= 3) return write("White\n");
for (auto j : to[i])
if (deg[j] >= 3) return write("White\n");
if (deg[i] == 2 && (deg[to[i][0]] > 1 || deg[to[i][1]] > 1))
return write("White\n");
++s;
}
if (s == 2 && n & 1) return write("White\n");
if (s == 1 && !(n & 1)) {
for (int i = 1; i <= n; ++i)
if (deg[i] == 3) return write("White\n");
}
return write("Draw\n");
}
} // namespace run
signed main() {
int t;
read(t);
for (; t; --t) run::main();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long long INF64 = 1e18;
const long double EPS = 1e-7;
mt19937 myrand(time(NULL));
const int N = 23;
int n;
int a[N], b[N];
bool read() {
if (scanf("%d", &n) != 1) return 0;
for (int i = 0; i < (n); i++) scanf("%d", &a[i]);
return 1;
}
void solve() {
for (int i = 0; i < (n); i++) b[i] = a[i];
sort(b, b + n);
for (int i = 0; i < (n); i++) {
int pos = lower_bound(b, b + n, a[i]) - b;
printf("%d ", b[(pos + 1) % n]);
}
puts("");
}
int main() {
while (read()) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793238462643383279;
const long double EPS = 1e-6;
const long long INF = 1e18 + 7;
const long long MOD = INF;
const long long maxn = 1e5 + 2;
const long long HASH_MODS[] = {1000000007333, 1000000009367, 1000000075747,
1000000158923, 1000000203119};
long long c[maxn];
long long v[maxn];
long long dp[maxn];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, q;
cin >> n >> q;
for (int i = (1); i < (n + 1); ++i) {
cin >> v[i];
}
for (int i = (1); i < (n + 1); ++i) {
cin >> c[i];
}
while (q--) {
int a, b;
cin >> a >> b;
int cmx1 = 0;
int cmx2 = 0;
long long mx1 = 0;
long long mx2 = 0;
for (int i = 1; i <= n; ++i) dp[i] = -INF;
for (int i = 1; i <= n; ++i) {
dp[c[i]] = max(dp[c[i]], dp[c[i]] + v[i] * a);
if (c[i] != cmx1) dp[c[i]] = max(dp[c[i]], mx1 + v[i] * b);
if (c[i] != cmx2) dp[c[i]] = max(dp[c[i]], mx2 + v[i] * b);
if (dp[c[i]] >= mx1) {
if (cmx1 != c[i]) {
cmx2 = cmx1;
mx2 = mx1;
}
mx1 = dp[c[i]];
cmx1 = c[i];
} else if (dp[c[i]] > mx2) {
if (cmx1 != c[i]) cmx2 = c[i], mx2 = dp[c[i]];
}
}
long long ans = 0;
for (int i = (1); i < (n + 1); ++i) ans = max(ans, dp[i]);
cout << ans << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<long long> a(n);
for (long long &i : a) cin >> i;
cout << *max_element(a.begin(), a.end()) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
istringstream in(s);
out.clear();
copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
static void redirect(int argc, const char **argv) {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (argc > 1) {
static filebuf f;
f.open(argv[1], ios::in);
cin.rdbuf(&f);
if (!cin) {
cerr << "Failed to open '" << argv[1] << "'" << endl;
exit(1);
}
}
if (argc > 2) {
static filebuf f;
f.open(argv[2], ios::out | ios::trunc);
cout.rdbuf(&f);
if (!cout) {
cerr << "Failed to open '" << argv[2] << "'" << endl;
}
}
cin.exceptions(ios::failbit);
}
template <typename T>
static inline T dot(const std::complex<T> &a, const std::complex<T> &b) {
return real(conj(a) * b);
}
template <typename T>
static inline T cross(const std::complex<T> &a, const std::complex<T> &b) {
return imag(conj(a) * b);
}
template <typename T>
static inline T cross(const std::complex<T> &a, const std::complex<T> &b,
const std::complex<T> &c) {
return cross(b - a, c - a);
}
class CompareAngle {
public:
bool operator()(const complex<long long> &a,
const complex<long long> &b) const {
const complex<long long> da = a;
const complex<long long> db = b;
bool fa = da.imag() > 0 || (da.imag() == 0 && da.real() >= 0);
bool fb = db.imag() > 0 || (db.imag() == 0 && db.real() >= 0);
if (fa != fb)
return fa;
else {
auto c = cross(da, db);
if (c != 0)
return c > 0;
else
return dot(da, da) > dot(db, db);
}
}
};
class CompareDamage {
public:
bool operator()(const complex<long long> &a,
const complex<long long> &b) const {
if (a.imag() != b.imag())
return a.imag() > b.imag();
else
return a.real() < b.real();
}
};
static void solve() {
int Q;
long long M;
cin >> Q >> M;
int last_pos = 0;
set<complex<long long>, CompareAngle> hull;
set<complex<long long>, CompareDamage> hull_by_dmg;
hull.insert(complex<long long>(1, 0));
for (int i = 0; i < Q; i++) {
int k;
long long a, b;
cin >> k >> a >> b;
a = (a + last_pos) % 1000000 + 1;
b = (b + last_pos) % 1000000 + 1;
if (k == 1) {
complex<long long> p(b, a);
auto [ptr, added] = hull.insert(p);
if (!added) continue;
hull_by_dmg.insert(p);
if (ptr != hull.begin() && next(ptr) != hull.end() &&
cross(*prev(ptr), p, *next(ptr)) <= 0) {
hull.erase(ptr);
hull_by_dmg.erase(p);
continue;
}
decltype(ptr) x1, x2;
while (ptr != hull.begin() && (x1 = prev(ptr)) != hull.begin() &&
cross(*prev(x1), *x1, p) <= 0) {
hull_by_dmg.erase(*x1);
hull.erase(x1);
}
while ((x1 = next(ptr)) != hull.end() && (x2 = next(x1)) != hull.end() &&
cross(p, *x1, *x2) <= 0) {
hull_by_dmg.erase(*x1);
hull.erase(x1);
}
while (((long long)(hull).size()) >= 2 &&
cross(*prev(hull.end()), *prev(prev(hull.end()))) == 0) {
auto prv = prev(hull.end());
hull_by_dmg.erase(*prv);
hull.erase(prv);
}
} else {
long long t = a;
long long h = b;
long long min_y = (h + t - 1) / t;
complex<long long> p(M, h);
auto ptr = hull.lower_bound(p);
if (ptr != hull.begin() && cross(*prev(ptr), p) == 0) --ptr;
bool good = false;
if (ptr != hull.end()) {
if (ptr->imag() >= min_y)
good = true;
else if (ptr != hull.begin()) {
auto prv = prev(ptr);
long long cr1 = cross(p, *ptr);
long long cr2 = cross(p, *prv);
long long yn = (prv->imag() * cr1 - ptr->imag() * cr2);
long long yd = cr1 - cr2;
assert(yd > 0);
if (__int128(yn) * t >= __int128(h) * yd) good = true;
}
}
if (!good && !hull_by_dmg.empty() &&
hull_by_dmg.begin()->imag() >= min_y &&
cross(p, *hull_by_dmg.begin()) >= 0)
good = true;
if (good) {
cout << "YES\n";
last_pos = i + 1;
} else {
cout << "NO\n";
}
}
}
}
int main(int argc, const char **argv) {
redirect(argc, argv);
solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline long long getnum() {
char c = getchar();
int num, sign = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') sign = -1;
for (num = 0; c >= '0' && c <= '9';) {
c -= '0';
num = num * 10 + c;
c = getchar();
}
return num * sign;
}
char S[100], temp[40];
int val[405], done[100023], there[100023], sorted[100023];
unordered_map<string, int> Map, Gap;
vector<int> V[100023], W[100023], todo;
string All[100003];
queue<pair<int, pair<int, int> > > Q;
void thatsort() {
int ind = Q.front().first, l = Q.front().second.first,
r = Q.front().second.second;
Q.pop();
int pos = 0;
for (int i = l; i <= r; i++) {
if (done[V[sorted[i]][ind]] == 0) todo.push_back(V[sorted[i]][ind]);
done[V[sorted[i]][ind]]++;
}
done[todo[0]] += l - 1;
for (int i = 1; i < todo.size(); i++) done[todo[i]] += done[todo[i - 1]];
for (int i = todo.size() - 1; i > 0; i--)
done[todo[i]] = done[todo[i - 1]] + 1;
done[todo[0]] = l;
int x = l;
for (int i = l; i <= r; i++) {
there[done[V[sorted[i]][ind]]] = sorted[i];
done[V[sorted[i]][ind]]++;
}
for (int i = l; i <= r; i++) sorted[i] = there[i];
for (int i = 0; i < todo.size(); i++) {
if (todo[i] > 0)
Q.push(make_pair(ind + 1, make_pair(x, done[todo[i]] - 1)));
x = done[todo[i]];
done[todo[i]] = 0;
}
todo.clear();
}
int main() {
for (char i = 'a'; i <= 'z'; i++) val[(int)i] = i - 'a' + 1;
val[(int)'.'] = 27;
val[(int)'/'] = 28;
int n = getnum(), ind = 0, wind = 0;
for (int i = 1; i <= n; i++) {
sorted[i] = i;
gets(S + 1);
int j = 8, k;
for (k = 1; S[j] != 0 && S[j] != '/'; j++, k++) temp[k] = S[j];
temp[k] = 0;
string x = string(temp + 1);
if (Map[x] == 0) {
Map[x] = ++ind;
All[ind] = x;
}
int pos = Map[x];
for (k = 1; S[j] != 0; j++, k++) temp[k] = S[j];
temp[k] = 0;
x = string(temp + 1);
if (Gap[x] == 0) Gap[x] = ++wind;
int y = Gap[x];
V[pos].push_back(y);
}
vector<int>::iterator it;
for (int i = 1; i <= ind; i++) {
sort(V[i].begin(), V[i].end());
it = unique(V[i].begin(), V[i].end());
V[i].erase(it, V[i].end());
V[i].push_back(0);
}
Q.push(make_pair(0, make_pair(1, ind)));
while (!Q.empty()) thatsort();
int ans = 0;
wind = 0;
for (int i = 1; i <= ind; i++) {
int l = sorted[i - 1], r = sorted[i];
if (V[l].size() != V[r].size())
wind++;
else {
int flag = 1;
for (int j = 0; j < V[r].size(); j++)
if (V[r][j] != V[l][j]) flag = 0;
if (!flag) wind++;
}
W[wind].push_back(sorted[i]);
if (W[wind].size() == 2) todo.push_back(wind);
}
printf("%d\n", todo.size());
for (int i = 0; i < todo.size(); i++) {
for (int j = 0; j < W[todo[i]].size(); j++) {
printf("http://%s ", All[W[todo[i]][j]].c_str());
}
puts("");
}
}
| 6 |
#include <bits/stdc++.h>
char s[100000 + 20];
int x[100000 + 20], y[100000 + 20], z[100000 + 20];
int abs(int x) { return x > 0 ? x : -x; }
int main() {
scanf("%s", s + 1);
int n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
x[i] = x[i - 1];
y[i] = y[i - 1];
z[i] = z[i - 1];
switch (s[i]) {
case 'x':
x[i]++;
break;
case 'y':
y[i]++;
break;
case 'z':
z[i]++;
break;
}
}
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int l, r;
scanf("%d%d", &l, &r);
int xnum = x[r] - x[l - 1];
int ynum = y[r] - y[l - 1];
int znum = z[r] - z[l - 1];
if (abs(xnum - ynum) < 2 && abs(xnum - znum) < 2 && abs(ynum - znum) < 2 ||
r - l + 1 <= 2) {
printf("YES\n");
} else {
printf("NO\n");
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> pref(const string& s) {
int n = s.size();
vector<int> p(n);
for (int i = 1; i < n; i++) {
int j = p[i - 1];
while (j > 0 && s[i] != s[j]) j = p[j - 1];
if (s[i] == s[j]) p[i] = j + 1;
}
return p;
}
int main() {
string s;
cin >> s;
vector<int> p = pref(s);
int out = p.back();
int n = p.size();
if ((out && find(p.begin(), p.begin() + n - 1, out) != p.begin() + n - 1))
cout << s.substr(0, out) << endl;
else if (out && p[out - 1])
cout << s.substr(0, p[out - 1]) << endl;
else
cout << "Just a legend" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, l, k;
string s;
string ans[1001];
int cnt[30];
int main() {
cin >> n >> l >> k;
cin >> s;
for (int i = 0; i < s.size(); i++) {
cnt[s[i] - 'a']++;
}
int pos = 0;
int posk = 1;
while (posk != k && ans[k].length() < l) {
for (int i = posk; i <= k; i++) {
if (cnt[pos] == 0) {
while (cnt[pos] == 0) pos++;
posk = i;
}
if (cnt[pos] > 0) {
ans[i] += pos + 'a';
cnt[pos]--;
}
}
}
while (ans[k].length() < l) {
while (cnt[pos] == 0) pos++;
if (cnt[pos] > 0) {
ans[k] += pos + 'a';
cnt[pos]--;
}
}
for (int i = 1; i <= n; i++) {
while (ans[i].length() < l) {
while (cnt[pos] == 0) pos++;
if (cnt[pos] > 0) {
ans[i] += pos + 'a';
cnt[pos]--;
}
}
}
for (int i = 1; i <= n; i++) {
cout << ans[i] << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[400];
int l[400], r[400];
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= m; i++) cin >> l[i] >> r[i];
int b[400];
int now[400];
int ans = 0;
vector<int> q;
int num = 0;
int ans1 = 0;
int ans2[400];
for (int i = 1; i <= n; i++) {
num = 0;
q.clear();
memset(b, 0, sizeof(b));
for (int j = 1; j <= m; j++) {
if (l[j] <= i && r[j] >= i) {
b[l[j]]--, b[r[j] + 1]++, num++;
q.push_back(j);
}
}
int tmp = -99999999;
for (int j = 1; j <= n; j++) {
b[j] = b[j] + b[j - 1], now[j] = a[j] + b[j];
tmp = max(tmp, now[j]);
}
if (abs(tmp - now[i]) > ans) {
ans = abs(tmp - now[i]);
ans1 = num;
for (int i = 0; i < ans1; i++) ans2[i] = q[i];
}
}
cout << ans << endl;
cout << ans1 << endl;
for (int i = 0; i < ans1; i++) {
if (i == (ans1 - 1))
cout << ans2[i] << endl;
else
cout << ans2[i] << " ";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - 48;
x *= f;
}
struct ha {
int x, y, xx, yy;
} ans1[400010], ans2[400010];
int an1, an2, n, m;
list<char> c[310][310];
int main() {
read(n);
read(m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
string s;
cin >> s;
if (i == 1 || j == 1) {
if (i != 1 || j != 1)
for (int k = s.size() - 1; k >= 0; --k)
ans1[++an1] = (ha){i, j, 1, 1}, c[1][1].push_front(s[k]);
else
for (int k = 0; k < s.size(); ++k) c[1][1].push_back(s[k]);
} else
for (int k = s.size() - 1; k >= 0; --k)
if (s[k] == '0')
ans1[++an1] = (ha){i, j, 1, j}, c[1][j].push_front(s[k]);
else
ans1[++an1] = (ha){i, j, i, 1}, c[i][1].push_front(s[k]);
}
for (int j = 3; j <= m; ++j)
while (!c[1][j].empty()) c[1][j].pop_back(), ans1[++an1] = (ha){1, j, 1, 2};
for (int i = 3; i <= n; ++i)
while (!c[i][1].empty()) c[i][1].pop_back(), ans1[++an1] = (ha){i, 1, 2, 1};
while (!c[1][1].empty())
if ((*c[1][1].rbegin()) == '0')
ans1[++an1] = (ha){1, 1, 1, 2}, c[1][1].pop_back();
else
ans1[++an1] = (ha){1, 1, 2, 1}, c[1][1].pop_back();
c[1][2].clear();
c[2][1].clear();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
string s;
cin >> s;
if (i == 1 || j == 1) {
if (i != 1 || j != 1)
for (int k = 0; k < s.size(); ++k)
ans2[++an2] = (ha){i, j, 1, 1}, c[1][1].push_back(s[k]);
else
for (int k = 0; k < s.size(); ++k) c[1][1].push_back(s[k]);
} else
for (int k = 0; k < s.size(); ++k)
if (s[k] == '0')
ans2[++an2] = (ha){i, j, 1, j}, c[1][j].push_back(s[k]);
else
ans2[++an2] = (ha){i, j, i, 1}, c[i][1].push_back(s[k]);
}
for (int j = 3; j <= m; ++j)
while (!c[1][j].empty())
c[1][j].pop_front(), ans2[++an2] = (ha){1, j, 1, 2};
for (int i = 3; i <= n; ++i)
while (!c[i][1].empty())
c[i][1].pop_front(), ans2[++an2] = (ha){i, 1, 2, 1};
while (!c[1][1].empty())
if ((*c[1][1].begin()) == '0')
ans2[++an2] = (ha){1, 1, 1, 2}, c[1][1].pop_front();
else
ans2[++an2] = (ha){1, 1, 2, 1}, c[1][1].pop_front();
c[1][2].clear();
c[2][1].clear();
cout << an1 + an2 << endl;
for (int i = 1; i <= an1; ++i)
printf("%d %d %d %d\n", ans1[i].x, ans1[i].y, ans1[i].xx, ans1[i].yy);
for (int i = an2; i >= 1; --i)
printf("%d %d %d %d\n", ans2[i].xx, ans2[i].yy, ans2[i].x, ans2[i].y);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long ans;
pair<int, int> a[37];
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) cin >> a[i].second >> a[i].first;
sort(a, a + m);
for (int i = m - 1; i > -1 && n > 0; i--) {
ans += min(a[i].second, n) * a[i].first;
n -= a[i].second;
}
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
const int maxl = 205;
int c[maxn];
char s[maxl];
inline bool isVow(char c) {
return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y';
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
bool flag = true;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", c + i);
getchar();
for (int k = 0; k < n; ++k) {
gets(s);
int len = strlen(s);
int i = 0, cnt = 0;
while (i < len) {
while (i < len && !isVow(s[i])) {
if (s[i] == ' ') break;
++i;
}
if (i >= len) break;
if (isVow(s[i])) ++cnt;
++i;
}
if (cnt != c[k]) flag = false;
}
puts(flag ? "YES" : "NO");
return 0;
}
| 2 |
//Classic
//g++ -std=c++17 -O2 -Wall a.cpp -o test
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define vl vector<ll>
#define vi vector<int>
#define vb vector<bool>
#define pi pair<int,int>
#define pl pair<ll,ll>
#define vp vector<pi>
#define vpl vector<pl>
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define F first
#define S second
#define For(i,a,b) for(ll i=a;i<b;i++)
#define endl "\n"
#define debug2(x,y) cout<<"This side ----> "<<#x<<" -> "<<x<<" | "<<#y<<" -> "<<y<<endl;
#define debug(x) cout<<"This side ----> "<<#x<<" -> "<<x<<endl
//#define ai(a, n) for (int ele = 0; ele < n; ele++) cin >> a[ele];
//#define ao(a, n) {for (int ele = 0; ele < (n); ele++) {cout << a[ele]<<" "; } cout << '\n';}
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(), x.rend()
#define mint map<int,int>
#define mall map<ll,ll>
#define ciN cin
#define g(a,s) get<a>(s)
#define tin tuple<ll,ll,ll>
#define ter(x,y,z) ((x)?y:z)
bool isGoogles = 0;
const ll maxn = 2e5 + 10;
const ll max_val = 2e5 + 10;
const ll mod = 998244353;
const ll bits = 10;
ll caseNumber = 1;
////////////////////////////////////////////////////////////////
void jabru() {
ll n, k; cin >> n >> k;
int curr = 0;
string s = "";
int done = 0;
while (done < n) {
s += curr + 'a';
done++;
for (int i = curr + 1; i < k; i++) {
if (done == n)break;
if (done == n - 1) {
s += curr + 'a'; done++;
}
else {
s += curr + 'a'; s += i + 'a'; done += 2;
}
}
curr++;
curr %= k;
}
cout << s << endl;
}
bool TestCase = 0;
//////////////////////////////////////////////////////////////////
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
ll t;
t = 1;
if (TestCase) {
cin >> t;
}
while (t--) {
if (isGoogles) {cout << "Case #" << caseNumber << ": ";} caseNumber++;
jabru();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Set {
long long head, tail, size;
Set(int x) {
head = tail = x;
size = 1;
}
Set() { head = tail = size = 0; }
} s[100005];
int a[100005], Next[100005], head[100005];
void MakeSet(int x) {
s[x] = Set(x);
head[x] = x;
Next[x] = -1;
}
int FindSet(int x) { return head[x]; }
void Union(int x, int y) {
if (s[x].size == 0 || s[y].size == 0) return;
if (s[x].size < s[y].size) swap(x, y);
Next[s[x].tail] = s[y].head;
s[x].tail = s[y].tail;
s[x].size += s[y].size;
head[s[y].tail] = s[x].head;
for (int node = s[y].head; node != s[y].tail; node = Next[node])
head[node] = s[x].head;
}
bool mark[100005];
pair<int, int> p[100005];
vector<int> v[100005];
int main() {
long long n, m, x, y, sum = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
MakeSet(i);
cin >> a[i];
p[i] = make_pair(a[i], i);
}
sort(p, p + n);
for (int i = 0; i < m; i++) {
cin >> x >> y;
v[x - 1].push_back(y - 1);
v[y - 1].push_back(x - 1);
}
for (int i = n - 1; i >= 0; i--) {
int x = p[i].second;
mark[x] = true;
for (int j = 0; j < v[x].size(); j++) {
int y = v[x][j];
int yn = FindSet(y), xn = FindSet(x);
if (mark[y] && yn != xn) {
sum += s[yn].size * s[xn].size * p[i].first;
Union(xn, yn);
}
}
}
double ans = sum;
ans /= double(n) * (n - 1) / 2;
printf("%0.6f\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int Rand(int x) { return rand() * rand() % x + 1; }
const int INF = 0x3f3f3f3f, N = 1000005, M = 2000005, MOD = 1e9 + 7;
int a[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
if (n % 2 == 0) return puts("0");
int t = n / 2 + 1;
long long tim = 1ll * m / t * k;
if (m < t) return puts("0");
int minn = INF;
k = 0;
for (int i = 1; i <= n; i += 2) {
if (a[i] < minn) minn = a[i], k = i;
}
cout << min(tim, 1ll * minn) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
constexpr int MAX_N = 200000;
constexpr int LOG_N = 18;
using ll = int64_t;
struct edge {
int u, v, w;
};
bool operator<(const edge& a, const edge& b) { return a.w < b.w; }
vector<edge> edges;
struct edgeEquality {
bool operator()(const edge& a, const edge& b) {
if (a.u == b.u) {
if (a.v == b.v) {
return a.w < b.w;
} else
return a.v < b.v;
} else
return a.u < b.u;
}
};
map<pair<int, int>, int> og_mst_edges;
int parent[MAX_N][LOG_N];
vector<int> depth;
int max_in_path[MAX_N][LOG_N];
void init_uf(int n, vector<int>& parent, vector<int>& subtree_size) {
for (int i = 0; i < n; i++) {
parent[i] = i;
subtree_size[i] = 1;
}
}
int root(int x, vector<int>& parent) {
return parent[x] == x ? x : parent[x] = root(parent[x], parent);
}
void join(int x, int y, vector<int>& parent, vector<int>& subtree_size) {
x = root(x, parent);
y = root(y, parent);
if (x == y) return;
if (subtree_size[x] < subtree_size[y]) {
parent[x] = y;
subtree_size[y] += subtree_size[x];
} else {
parent[y] = x;
subtree_size[x] += subtree_size[y];
}
}
ll mst(int nE, vector<int>& parent, vector<int>& subtree_size) {
ll total_weight = 0;
for (int i = 0; i < nE; i++) {
edge& e = edges[i];
if (root(e.u, parent) != root(e.v, parent)) {
total_weight += e.w;
og_mst_edges.insert({{e.u, e.v}, e.w});
og_mst_edges.insert({{e.v, e.u}, e.w});
join(e.u, e.v, parent, subtree_size);
}
}
return total_weight;
}
void preprocess(int n) {
for (int i = 0; i < n; i++) {
for (int j = 1; (1 << j) < n; j++) {
parent[i][j] = -1;
}
}
for (int j = 1; (1 << j) < n; j++) {
for (int i = 0; i < n; i++) {
if (parent[i][j - 1] != -1) {
parent[i][j] = parent[parent[i][j - 1]][j - 1];
max_in_path[i][j] =
max(max_in_path[i][j - 1], max_in_path[parent[i][j - 1]][j - 1]);
}
}
}
}
int lca(int u, int v) {
int max = -1;
if (depth[u] < depth[v]) swap(u, v);
for (int i = (int)log2(depth[u]); i >= 0; i--) {
if (depth[u] - (1 << i) >= depth[v]) {
if (max_in_path[u][i] > max) max = max_in_path[u][i];
u = parent[u][i];
}
}
if (u == v) return max;
for (int i = (int)log2(depth[u]); i >= 0; i--)
if (parent[u][i] != -1 && parent[u][i] != parent[v][i]) {
if (max_in_path[u][i] > max) max = max_in_path[u][i];
if (max_in_path[v][i] > max) max = max_in_path[v][i];
u = parent[u][i];
v = parent[v][i];
}
max = (max > max_in_path[u][0]) ? max : max_in_path[u][0];
max = (max > max_in_path[v][0]) ? max : max_in_path[v][0];
return max;
}
constexpr ll INF = 1000000001;
void dfs(vector<vector<int>>& graph, int root = 0, int d = 0) {
depth[root] = d;
for (int i = 0; i < graph[root].size(); i++) {
int des = graph[root][i];
if (depth[des] <= -1) {
parent[des][0] = root;
max_in_path[des][0] = og_mst_edges.find({root, des})->second;
dfs(graph, des, d + 1);
}
}
}
int main() {
int nV, nE;
cin >> nV >> nE;
if (nE == 0 || nV == 0) {
return 0;
}
for (int i = 0; i < nE; ++i) {
int u, v;
int w;
cin >> u >> v >> w;
--u, --v;
edges.push_back({u, v, w});
}
vector<edge> edges_in_order = edges;
sort(edges.begin(), edges.end());
ll og_mst_weight;
{
vector<int> og_parent(nE);
vector<int> og_subtree_size(nE);
init_uf(nV, og_parent, og_subtree_size);
og_mst_weight = mst(nE, og_parent, og_subtree_size);
}
depth = vector<int>(nV, -1);
{
vector<vector<int>> graph(nV, vector<int>());
for (const auto& e : og_mst_edges) {
graph[e.first.first].push_back(e.first.second);
}
dfs(graph);
}
preprocess(nV);
for (edge ed : edges_in_order) {
if (og_mst_edges.find({ed.u, ed.v}) != og_mst_edges.end())
cout << og_mst_weight << "\n";
else {
int max = lca(ed.u, ed.v);
cout << og_mst_weight - (ll)max + (ll)ed.w << "\n";
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
int l[100100];
int c[100100];
map<long long, long long> dp[330][2];
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
long long f(int i, bool b, long long g) {
if (i == n) {
if (g == 1) return 0;
return 1e8;
}
if (dp[i][b].count(g)) return dp[i][b][g];
long long r = f(i + 1, 1, gcd(l[i], g)) + c[i];
r = min(r, f(i + 1, b, g));
return dp[i][b][g] = r;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> l[i];
for (int i = 0; i < n; i++) cin >> c[i];
long long r = f(0, 0, 0);
if (r >= 1e8) r = -1;
cout << r << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cl[int(1e3) + 1][int(1e3) + 1], col, sz[int(1e6) + 1], ans;
char c[int(1e3) + 1][int(1e3) + 1];
set<int> st;
bool in(int x, int y) { return ((0 <= x && x < n) && (0 <= y && y < m)); }
void dfs(int x, int y) {
cl[x][y] = col;
sz[col]++;
for (int i = -1; i < 2; i++) {
for (int j = -1; j < 2; j++) {
if (abs(i) + abs(j) == 1 && in(x + i, y + j) && c[x + i][y + j] == '.' &&
cl[x + i][y + j] == 0) {
dfs(x + i, y + j);
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> c[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (c[i][j] == '.' && cl[i][j] == 0) {
col++;
dfs(i, j);
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (c[i][j] == '*') {
for (int x = -1; x < 2; ++x) {
for (int y = -1; y < 2; ++y) {
if (abs(x) + abs(y) == 1 && in(i + x, j + y) &&
c[i + x][j + y] == '.') {
st.insert(cl[i + x][j + y]);
}
}
}
for (auto it : st) {
ans += sz[it];
}
st.clear();
cout << (1 + ans) % 10;
ans = 0;
} else {
cout << ".";
}
}
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1e6 + 5;
long long read() {
long long s = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
s = s * 10 + c - '0';
c = getchar();
}
return s * f;
}
long long K, Ans, dis[N];
int n, t, tot, a[N], b[N], ch[N][2], sum[N];
void Clear() {
for (int i = 0; i <= tot; i++) sum[i] = ch[i][0] = ch[i][1] = 0;
tot = 0;
}
int main() {
n = read();
K = read();
for (int i = 2; i <= n; i++) {
int x = read();
dis[i] = dis[x] ^ read();
}
for (int i = 1; i <= n; i++) a[i] = b[i] = 1;
tot = 1;
for (int j = 62; j >= 0; j--) {
long long Sum = 0, type = 0;
t ^= 1;
Clear();
for (int i = 1; i <= n; i++) {
int x = (dis[i] >> j) & 1;
if (!ch[a[i]][x]) ch[a[i]][x] = ++tot;
sum[ch[a[i]][x]]++;
}
for (int i = 1; i <= n; i++) Sum += sum[ch[b[i]][(dis[i] >> j) & 1]];
if (K > Sum) {
K -= Sum;
Ans |= (1ll << j);
type = 1;
}
for (int i = 1; i <= n; i++) {
a[i] = ch[a[i]][(dis[i] >> j) & 1];
b[i] = ch[b[i]][((dis[i] >> j) & 1) ^ type];
}
}
printf("%lld\n", Ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
struct bb {
string s;
int id;
};
vector<bb> v;
long long data[100005][2];
bool cmp(bb s1, bb s2) {
long long a1, b1, a2, b2;
a1 = data[s1.id][0];
b1 = data[s1.id][1];
a2 = data[s2.id][0];
b2 = data[s2.id][1];
if (a1 * b2 == a2 * b1) return 0;
return a1 * b2 > a2 * b1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
bb baba;
cin >> baba.s;
baba.id = i;
v.push_back(baba);
long long a = 0;
long long b = 0;
for (int j = 0; j < baba.s.length(); j++) {
if (baba.s[j] == 's')
a++;
else
b++;
}
data[i][0] = a;
data[i][1] = b;
}
sort(v.begin(), v.end(), cmp);
long long cnt = 0;
long long scnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < v[i].s.length(); j++) {
if (v[i].s[j] == 's')
scnt++;
else
cnt += scnt;
}
}
cout << cnt << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n;
int arr[maxn];
string ans;
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
while (cin >> n) {
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
}
ans = "";
int l = 1, r = n;
int last = 0;
while (r - l >= 0) {
if ((arr[l] < arr[r] && arr[l] > last) ||
(arr[r] < last && arr[l] > last)) {
ans += "L";
last = arr[l++];
} else if (arr[r] > last) {
ans += "R";
last = arr[r--];
} else {
break;
}
}
cout << ans.size() << endl;
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1005, M = 1e9 + 7;
struct Ask {
long double x, y, d;
} A[N * N];
long double x1, x2, ___y1, y2, x[N], y[N];
long long tot, n;
long long ksm(long long x, long long y) {
long long ans = 1;
for (; y; y >>= 1, x = x * x % M)
if (y & 1) (ans *= x) %= M;
return ans;
}
long long cmp(Ask x, Ask y) {
if (fabs(x.x - y.x) >= 1e-9) return x.x < y.x;
if (fabs(x.y - y.y) >= 1e-9) return x.y < y.y;
return x.d < y.d;
}
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%Lf%Lf%Lf%Lf", &x1, &x2, &___y1, &y2);
x[i] = x1 / x2;
y[i] = ___y1 / y2;
long double len = sqrt(x[i] * x[i] + y[i] * y[i]);
x[i] /= len * len;
y[i] /= len * len;
}
long long ans = 0;
for (long long i = 1; i <= n; i++)
for (long long j = i + 1; j <= n; j++) {
tot++;
A[tot].x = x[i] + x[j];
A[tot].y = y[i] + y[j];
A[tot].d =
fabs(x[i] - x[j]) < 1e-9 ? 1e18 : (y[i] - y[j]) / (x[i] - x[j]);
}
sort(A + 1, A + tot + 1, cmp);
for (long long i = 1, j = 1; i <= tot; i = j) {
while (j <= tot && fabs(A[i].x - A[j].x) < 1e-9 &&
fabs(A[i].y - A[j].y) < 1e-9)
j++;
long long num = 1, cnt = 2;
for (long long k = i + 1; k <= j; k++)
if (k == j || fabs(A[k].d - A[k - 1].d > 1e-9))
(num *= cnt) %= M, cnt = 2;
else
cnt++;
ans = (ans + num + 1ll * M - (j - i + 1)) % M;
}
printf("%lld\n", (ans + M) % M);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int s;
void basic() {
int x, y;
char c;
cin >> x >> c >> y;
s = x * 100 + y;
for (int i = s + 1; i <= 2359; i++) {
if (i % 100 >= 60) continue;
int a[4];
int k = i;
for (int j = 0; j <= 3; j++) {
a[j] = k % 10;
k /= 10;
}
if (a[0] == a[3] && a[1] == a[2]) {
cout << a[3] << a[2] << ":" << a[1] << a[0];
return;
}
}
for (int i = 0; i < s; i++) {
if (i % 100 >= 60) continue;
int a[4];
int k = i;
for (int j = 0; j <= 3; j++) {
a[j] = k % 10;
k /= 10;
}
if (a[0] == a[3] && a[1] == a[2]) {
cout << a[2] << a[2] << ":" << a[1] << a[0];
return;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
basic();
getchar();
getchar();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3;
int main() {
int n;
cin >> n;
vector<int> A;
int resp = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
A.push_back(x);
}
for (int i = 1; i < n; i++) {
if (A[i - 1] == 3 && A[i] == 2) {
cout << "Infinite\n";
return 0;
}
if (A[i - 1] == 2 && A[i] == 3) {
cout << "Infinite\n";
return 0;
}
if (A[i] == 2) {
if (i >= 2 && A[i - 2] == 3 && A[i] == 2)
resp += 2;
else
resp += 3;
} else if (A[i] == 3)
resp += 4;
else if (A[i] == 1)
resp += A[i - 1] + 1;
}
cout << "Finite\n" << resp << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[100000], b[100000];
int main() {
long long n;
cin >> n;
long long nu;
nu = sqrt(n);
if (nu * nu == n) {
cout << 4 * nu;
} else {
if (n - (nu * nu) > nu) {
nu = 4 * nu + 4;
} else {
nu = 4 * nu + 2;
}
cout << nu << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> nums[20];
int n, N;
double p[20][20], dp[1000010];
int main() {
scanf("%d", &n);
N = (1 << n) - 1;
dp[N] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) scanf("%lf", &p[i][j]);
}
for (int i = 1; i <= N; ++i) {
int cur = 0;
for (int j = 0; j < n; ++j) {
if (i & (1 << j)) ++cur;
}
nums[cur].push_back(i);
}
for (int i = n; i >= 2; --i) {
for (int j = 0; j < nums[i].size(); ++j) {
int now = nums[i][j], cur = 0;
for (int a = 0; a < n; ++a) {
for (int b = a + 1; b < n; ++b) {
if ((now & (1 << a)) && (now & (1 << b))) ++cur;
}
}
for (int a = 0; a < n; ++a) {
for (int b = a + 1; b < n; ++b) {
if ((now & (1 << a)) && (now & (1 << b))) {
dp[now ^ (1 << b)] += dp[now] * p[a][b] / cur;
dp[now ^ (1 << a)] += dp[now] * p[b][a] / cur;
}
}
}
}
}
for (int i = 0; i < n; ++i) printf("%.6lf ", dp[1 << i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.size();
cout << 3 << '\n';
cout << "L 2\n";
cout << "R " << 2 << '\n';
cout << "R " << 2 * n - 1 << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
inline char gc() {
static const int L = 23333;
static char sxd[L], *sss = sxd, *ttt = sxd;
if (sss == ttt) {
ttt = (sss = sxd) + fread(sxd, 1, L, stdin);
if (sss == ttt) {
return EOF;
}
}
return *sss++;
}
template <class T>
inline bool read(T& x) {
x = 0;
char c = gc();
bool flg = false;
for (; !isdigit(c); c = gc()) {
if (c == '-') {
flg = true;
} else if (c == EOF) {
return false;
}
}
for (; isdigit(c); c = gc()) {
x = (x * 10) + (c ^ 48);
}
if (flg) {
x = -x;
}
return true;
}
template <class T>
inline void write(T x) {
if (x < 0) {
x = -x;
putchar('-');
}
if (x > 9) {
write(x / 10);
x %= 10;
}
putchar(x | 48);
}
template <class T>
inline void writeln(T x) {
write(x);
puts("");
}
template <class T>
inline void writesp(T x) {
write(x);
putchar(' ');
}
using namespace std;
const int maxn = 100005;
int gcd(int a, int b) {
while (b) {
int t = a % b;
a = b;
b = t;
}
return a;
}
int n;
struct Edge {
int to, nxt;
} e[maxn << 1];
int first[maxn];
int du[maxn];
int dubk[maxn];
int cnt;
void add_edge(int u, int v) {
du[u]++, du[v]++;
e[++cnt].nxt = first[u];
first[u] = cnt;
e[cnt].to = v;
e[++cnt].nxt = first[v];
first[v] = cnt;
e[cnt].to = u;
}
int final_ans[maxn];
void init() {
cnt = 0;
for (int i = 1; i <= n; ++i) {
first[i] = du[i] = final_ans[i] = 0;
}
}
bool np[maxn];
int factor[maxn];
int prime[maxn];
void oula(const int n = 100000) {
np[1] = true;
int cnt = 0;
for (int i = 2; i <= n; ++i) {
if (!np[i]) {
prime[++cnt] = i;
factor[i] = i;
}
for (int j = 1; j <= cnt && (long long)i * prime[j] <= n; ++j) {
np[i * prime[j]] = true;
factor[i * prime[j]] = prime[j];
if (!(i % prime[j])) {
break;
}
}
}
}
bool vis[maxn];
int nn[maxn];
int bfs(int xx) {
for (int i = 1; i <= n; ++i) {
vis[i] = false;
nn[i] = du[i] = dubk[i];
}
queue<int> q;
while (!q.empty()) {
q.pop();
}
for (int i = 1; i <= n; ++i) {
if (du[i] <= 1) {
q.push(i);
vis[i] = true;
}
}
int ans = n - 1;
while (!q.empty()) {
int now = q.front();
q.pop();
bool flg = false;
if (du[now]) {
int tmpans = gcd(ans, nn[now]);
if (tmpans % xx) {
nn[now]--;
ans = gcd(ans, nn[now]);
} else {
ans = tmpans;
flg = true;
}
} else {
ans = gcd(ans, nn[now]);
}
if (ans % xx) {
return 1;
}
for (int i = first[now]; i; i = e[i].nxt) {
int to = e[i].to;
if (!vis[to]) {
du[to]--;
if (flg) {
nn[to]--;
}
if (du[to] <= 1) {
q.push(to);
vis[to] = true;
}
}
}
}
return ans;
}
const int mod = 998244353;
int ksm(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = (long long)a * a % mod) {
if (b & 1) {
ans = (long long)ans * a % mod;
}
}
return ans;
}
void solve() {
read(n);
init();
for (int i = 1; i < n; ++i) {
int u, v;
read(u), read(v);
add_edge(u, v);
}
for (int i = 1; i <= n; ++i) {
dubk[i] = du[i];
}
int tt = n - 1;
int tmpans = 0;
while (tt > 1) {
int pme = factor[tt];
while (!(tt % pme)) {
tt /= pme;
}
int nowans = bfs(pme);
if (nowans > 1 && !final_ans[nowans]) {
final_ans[nowans] = 1;
tmpans++;
}
}
final_ans[1] = ksm(2, n - 1) - tmpans;
if (final_ans[1] < 0) {
final_ans[1] += mod;
}
for (int i = 1; i <= n; ++i) {
writesp(final_ans[i]);
}
puts("");
}
int main() {
oula();
int T;
read(T);
while (T--) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const long long M = 1e9 + 7;
long long n;
long long a[N];
long long fac[N], inv[N];
long long modpow(long long x, long long y, long long p) {
long long ret = 1;
while (y) {
if (y & 1) ret = (ret * x) % p;
y >>= 1;
x = (x * x) % p;
}
return ret;
}
long long C(long long a, long long b) {
if (a < b) return 0LL;
long long ret = (fac[a] * inv[b]) % M;
ret = (ret * inv[a - b]) % M;
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
fac[0] = inv[0] = 1LL;
for (int i = 1; i < N; i++) {
fac[i] = (i * fac[i - 1]) % M;
inv[i] = modpow(fac[i], M - 2, M);
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long rem = n % 4;
long long ans = 0;
if (rem == 0) {
for (int i = 0; i < n; i++) {
if (!(i & 1)) {
ans = (ans + C((n - 2) / 2, i / 2) * a[i]);
} else {
ans = (ans - C((n - 2) / 2, i / 2) * a[i]);
}
ans = (ans % M + M) % M;
}
} else if (rem == 1) {
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
ans = (ans + C((n - 1) / 2, i / 2) * a[i]);
}
ans = (ans % M + M) % M;
}
} else if (rem == 2) {
for (int i = 0; i < n; i++) {
ans = (ans + C((n - 2) / 2, i / 2) * a[i]);
ans = (ans % M + M) % M;
}
} else if (rem == 3) {
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
ans = (ans + C((n - 3) / 2, i / 2) * a[i] -
C((n - 3) / 2, i / 2 - 1) * a[i]);
} else {
ans = (ans + 2LL * C((n - 3) / 2, i / 2) * a[i]);
}
ans = (ans % M + M) % M;
}
}
cout << (ans % M + M) % M << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long n, m, k, p[105], c[105], a;
vector<int> s[105];
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
cin >> p[i];
}
for (int i = 0; i < n; i++) {
cin >> a;
s[a].push_back(p[i]);
}
for (int i = 1; i <= m; i++) {
sort(s[i].rbegin(), s[i].rend());
}
long long ans = 0;
for (int i = 0; i < k; i++) {
cin >> a;
a--;
bool found = false;
for (int j = 1; j <= m; j++) {
if (!s[j].empty() && s[j][0] == p[a]) {
found = true;
break;
}
}
if (!found) ans++;
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int R[100000], S[100000], s, K, r, n, b, d, t;
int A(int k) {
s = 0;
r = 0;
K = 0;
t = 0;
for (int i = 0; i < n; i++) {
S[i] = 0;
}
for (int i = 0; i < n; i++) {
while (i - b * (t + 1) > t) {
t++;
}
if (R[i] + s <= k) {
S[t] += R[i];
s += R[i];
} else {
S[t] += k - s;
i += n;
}
}
for (int i = 0; i <= (n - 1) / 2; i++) {
K += S[i];
if (K < d) {
r++;
} else {
K -= d;
}
}
return r;
}
int B(int k) {
s = 0;
r = 0;
K = 0;
t = n - 1;
for (int i = 0; i < n; i++) {
S[i] = 0;
}
for (int i = n - 1; i >= 0; i--) {
while (i + b * (n - t) < t) {
t--;
}
if (R[i] + s <= k) {
S[t] += R[i];
s += R[i];
} else {
S[t] += k - s;
i = -1;
}
}
for (int i = n - 1; i > (n - 1) / 2; i--) {
K += S[i];
if (K < d) {
r++;
} else {
K -= d;
}
}
return r;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> b >> d;
int C = -1, D = n * d + 1, T, Sk;
for (int i = 0; i < n; i++) {
cin >> R[i];
}
while (D - C > 1) {
T = (C + D) / 2;
Sk = B(n * d - T) - A(T);
if (Sk < 0) {
C = T;
} else {
D = T;
}
}
cout << max(B(D), A(D));
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using base = ll;//complex<double>;
const ll mod = 998244353;
ll mexp(ll x, ll y) {
ll r = 1;
for(;y;x=x*x%mod, y>>=1) if(y & 1) r = r * x % mod;
return r;
}
ll modd(ll x) {
if(x >= mod) x -= mod;
if(x < 0) x += mod;
return x;
}
base roots[1<<20];
void fft(vector<base>& a, bool inv) {
int n = a.size(), j = 0;
for(int i=1;i<n;i++) {
int bit = (n >> 1);
while(j >= bit) {
j -= bit;
bit >>= 1;
}
j += bit;
if(i < j) swap(a[i], a[j]);
}
// In NTT, let prr = primitive root. Then,
int prr = 3;
ll ang = mexp(prr, (mod - 1) / n);
if(inv) ang = mexp(ang, mod - 2);
roots[0] = 1;
for(int i=1; i<n/2; i++){
roots[i] = roots[i-1] * ang % mod;
}
//also, make sure to apply modulus under here
for(int i=2;i<=n;i<<=1) {
int step = n / i;
for(int j=0;j<n;j+=i) {
for(int k=0;k<i/2;k++) {
base u = a[j+k], v = a[j+k+i/2] * roots[step * k] % mod;
a[j+k] = modd(u+v);
a[j+k+i/2] = modd(u-v+mod);
}
}
}
if(inv) for(int i=0;i<n;i++) a[i] = a[i] * mexp(n, mod-2) % mod;
}
void conv(vector<base>& x, vector<base>& y) {
int n = 2; while(n < x.size()+y.size()) n <<= 1;
x.resize(n), y.resize(n);
fft(x, false); fft(y, false);
for(int i=0;i<n;i++) x[i] = x[i] * y[i] % mod;
fft(x, true);
}
const int lim = 222222;
ll f[lim], fi[lim];
vector<base> ans, mul, nans;
int n;
ll binom(int a, int b) {
if(b < 0 || b > a) return 0;
return f[a] * fi[b] % mod * fi[a-b] % mod;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
ans.reserve(1<<16);
mul.reserve(1<<16);
f[0] = 1;
for(int i=1;i<lim;i++)
f[i] = i * f[i-1] % mod;
fi[lim-1] = mexp(f[lim-1], mod-2);
for(int i=lim-2;i>=0;i--)
fi[i] = (i+1) * fi[i+1] % mod;
ans.push_back(1);
for(int i=0;i<n;i++) {
int a, b;
cin >> a >> b;
int m = ans.size();
int m1 = 2 * m + a - b - 1;
for(int j=0;j<m1;j++)
mul.emplace_back(binom(a+b, b+j-(m-1)));
conv(ans, mul);
nans.clear(); nans.resize(m+a-b);
for(int i=0;i<m+a-b;i++) nans[i] = ans[m-1+i];
ans = nans;
mul.clear();
}
cout << accumulate(ans.begin(), ans.end(), 0LL) % mod;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 301;
int main() {
int a, wallet[MAX];
cin >> a;
mylabel:
for (int i = 1; i <= a; i++) {
cin >> wallet[i];
}
for (int i = 1; i < a; i++)
if (wallet[i] != 0) {
cout << 'P' << 'R';
wallet[i]--;
} else
cout << 'R';
for (int i = a; i > 1; i--)
if (wallet[i] != 0) {
cout << 'P' << 'L';
wallet[i]--;
} else
cout << 'L';
for (int i = a; i >= 0; i--)
if (wallet[i] != 0) goto mylabel;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1.01e9;
const long long infll = (long long)1.01e18;
const long double eps = 1e-9;
const long double pi = acos((long double)-1);
mt19937 mrand(chrono::steady_clock::now().time_since_epoch().count());
int rnd(int x) { return mrand() % x; }
void precalc() {}
const int maxn = 1005, maxm = (int)1e5 + 5;
int n[2], m;
vector<int> g[2][maxn], ids[2][maxn];
bool read() {
if (scanf("%d%d%d", &n[0], &n[1], &m) < 3) {
return false;
}
for (int t = 0; t < 2; t++) {
for (int v = 0; v < n[t]; v++) {
g[t][v].clear();
ids[t][v].clear();
}
}
for (int i = 0; i < m; i++) {
int v, u;
scanf("%d%d", &v, &u);
v--;
u--;
g[0][v].push_back(u);
ids[0][v].push_back(i);
g[1][u].push_back(v);
ids[1][u].push_back(i);
}
return true;
}
int c[maxm];
int p[2][maxn], pe[2][maxn];
int used[2][maxn];
int curu;
bool dfs(int t, int v, int d) {
used[t][v] = curu;
for (int i = 0; i < ((int)(g[t][v]).size()); i++) {
int u = g[t][v][i], e = ids[t][v][i];
int w = p[!t][u], ee = pe[!t][u];
if (w == -1) {
p[!t][u] = v;
pe[!t][u] = e;
p[t][v] = u;
pe[t][v] = e;
c[e] = d;
return true;
}
if (((int)(g[t][w]).size()) < d) {
p[t][w] = -1;
pe[t][w] = -1;
c[ee] = -1;
p[!t][u] = v;
pe[!t][u] = e;
p[t][v] = u;
pe[t][v] = e;
c[e] = d;
return true;
}
}
for (int i = 0; i < ((int)(g[t][v]).size()); i++) {
int u = g[t][v][i], e = ids[t][v][i];
int w = p[!t][u], ee = pe[!t][u];
if (used[t][w] != curu && dfs(t, w, d)) {
c[ee] = -1;
p[!t][u] = v;
pe[!t][u] = e;
p[t][v] = u;
pe[t][v] = e;
c[e] = d;
return true;
}
}
return false;
}
void solve() {
for (int i = 0; i < m; i++) {
c[i] = -1;
}
int d = 0;
for (int t = 0; t < 2; t++) {
for (int v = 0; v < n[t]; v++) {
d = max(d, ((int)(g[t][v]).size()));
}
}
for (int dd = d; dd > 0; dd--) {
for (int t = 0; t < 2; t++) {
for (int v = 0; v < n[t]; v++) {
p[t][v] = -1;
pe[t][v] = -1;
int k = 0;
for (int i = 0; i < ((int)(g[t][v]).size()); i++) {
int u = g[t][v][i], e = ids[t][v][i];
if (c[e] == -1) {
g[t][v][k] = u;
ids[t][v][k] = e;
k++;
}
}
g[t][v].resize(k);
ids[t][v].resize(k);
}
}
for (int t = 0; t < 2; t++) {
for (int v = 0; v < n[t]; v++) {
if (p[t][v] == -1 && ((int)(g[t][v]).size()) == dd) {
curu++;
assert(dfs(t, v, dd));
}
}
}
}
printf("%d\n", d);
for (int i = 0; i < m; i++) {
printf("%d ", c[i]);
}
printf("\n");
}
int main() {
precalc();
while (read()) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int nn = 100005;
char a[nn];
int n, q, ql[nn], qr[nn];
int vis[nn], ex[nn], l[nn], r[nn];
int p1[nn], q1[nn], r1[nn];
int p2[nn], q2[nn], r2[nn];
int c[11], pc[nn][11], ans[nn][11];
inline void add1(int x, int y) {
if (p1[x])
r1[q1[x]] = y;
else
p1[x] = y;
q1[x] = y;
}
inline void add2(int x, int y) {
if (p2[x])
r2[q2[x]] = y;
else
p2[x] = y;
q2[x] = y;
}
void init() {
scanf("%d%d%s", &n, &q, a + 1);
for (int i = 1; i <= q; ++i) {
scanf("%d%d", &ql[i], &qr[i]);
add1(ql[i] - 1, i);
add2(qr[i] + 1, i);
}
}
inline void update(int x) {
if (ex[x]) return;
ex[x] = 1;
for (int i = 0; i <= 9; ++i) ans[x][i] = c[i] - pc[ql[x]][i];
}
inline void del(int x) {
if (p2[x]) {
r2[q2[x]] = p2[r[x]];
p2[r[x]] = p2[x];
q2[r[x]] = q2[x];
}
if (p1[x]) {
r1[q1[x]] = p1[l[x]];
p1[l[x]] = p1[x];
q1[l[x]] = q1[x];
}
r[l[x]] = r[x];
l[r[x]] = l[x];
}
int run(int x) {
memset(c, 0, sizeof(c));
int mx = x, mk = 0;
for (int i = x, j = 0;; i = j ? l[i] : r[i]) {
if (!vis[i]) memcpy(pc[i], c, sizeof(c));
vis[i] = 1;
if (j) {
for (int k = p1[i]; k; k = r1[k]) update(k);
p1[i] = q1[i] = 0;
} else {
for (int k = p2[i]; k; k = r2[k]) update(k);
p2[i] = q2[i] = 0;
}
mx = max(mx, i);
if (i < x || i > n) break;
if (a[i] >= '0' && a[i] <= '9') {
++c[a[i] - 48];
mk = 0;
if (a[i] > '0')
--a[i];
else
del(i);
} else {
if (mk) del(j ? r[i] : l[i]);
j = a[i] == '<';
mk = 1;
}
}
return mx;
}
void work() {
for (int i = 1; i <= n; ++i) l[i] = i - 1, r[i] = i + 1;
for (int i = run(1); i <= n; i = run(i + 1))
;
for (int i = 1; i <= q; ++i)
for (int j = 0; j <= 9; ++j) {
printf("%d", ans[i][j]);
if (j < 9)
printf(" ");
else
puts("");
}
}
int main() {
init();
work();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 17;
const int LOG = 17;
int n, m, q, tick;
int id[N], st[N], nd[N], ch[N], dep[N], lca[LOG][N];
vector<int> v[N];
void dfs(int p, int x) {
dep[x] = dep[p] + 1;
lca[0][x] = p;
for (int i = 1; i < LOG; i++) lca[i][x] = lca[i - 1][lca[i - 1][x]];
ch[x] = 1;
for (auto u : v[x]) {
if (u != p) {
dfs(x, u);
ch[x] += ch[u];
}
}
}
int head[N], ww[N];
void dfs2(int p, int x, int h) {
id[x] = ++tick;
st[x] = tick;
ww[tick] = x;
head[x] = h;
int mx = -1;
for (auto u : v[x]) {
if (u != p) {
if (mx == -1 or ch[u] > ch[mx]) mx = u;
}
}
if (mx != -1) dfs2(x, mx, h);
for (auto u : v[x]) {
if (u != p and u != mx) dfs2(x, u, u);
}
nd[x] = tick;
}
int getLca(int x, int y) {
if (!x) return y;
if (!y) return x;
if (dep[x] < dep[y]) swap(x, y);
for (int i = LOG - 1; i >= 0; i--)
if (dep[x] - (1 << i) >= dep[y]) x = lca[i][x];
if (x == y) return x;
for (int i = LOG - 1; i >= 0; i--)
if (lca[i][x] != lca[i][y]) x = lca[i][x], y = lca[i][y];
return lca[0][x];
}
vector<int> jun[N];
namespace tree {
pair<long long, int> t[N << 1];
long long lazy[N << 1];
void Do(int x, long long v) {
t[x].first += v;
lazy[x] += v;
}
void push(int x) {
Do(x + x, lazy[x]);
Do(x + x + 1, lazy[x]);
lazy[x] = 0;
}
void up(int x, int l, int r, int x1, int x2, long long v) {
if (x2 < l or r < x1) return;
if (x1 <= l and r <= x2) {
Do(x, v);
return;
}
push(x);
int m = (l + r) >> 1;
up(x + x, l, m, x1, x2, v);
up(x + x + 1, m + 1, r, x1, x2, v);
t[x] = min(t[x + x], t[x + x + 1]);
}
void update(int x, int l, int r, int x1) {
if (l == r) {
if (jun[ww[l]].size())
t[x] = {jun[ww[l]].back() + lazy[x], ww[l]};
else
t[x] = {1e18, -1};
return;
}
push(x);
int m = (l + r) >> 1;
if (x1 <= m)
update(x + x, l, m, x1);
else
update(x + x + 1, m + 1, r, x1);
t[x] = min(t[x + x], t[x + x + 1]);
}
void init(int x, int l, int r) {
if (l == r) {
if (jun[ww[l]].size())
t[x] = {jun[ww[l]].back(), ww[l]};
else
t[x] = {1e18, -1};
} else {
int m = (l + r) >> 1;
init(x + x, l, m);
init(x + x + 1, m + 1, r);
t[x] = min(t[x + x], t[x + x + 1]);
}
}
pair<long long, int> get(int x, int l, int r, int x1, int x2) {
if (x2 < l or r < x1) return {1e18, -1};
if (x1 <= l and r <= x2) return t[x];
push(x);
int m = (l + r) >> 1;
return min(get(x + x, l, m, x1, x2), get(x + x + 1, m + 1, r, x1, x2));
}
} // namespace tree
pair<long long, int> get(int x, int y) {
pair<long long, int> res = {1e18, -1};
while (dep[x] >= dep[y]) {
int a = head[x];
if (dep[a] < dep[y]) a = y;
res = min(res, tree ::get(1, 1, n, id[a], id[x]));
x = lca[0][a];
}
return res;
}
int w[N];
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
for (int i = 1; i <= m; i++) {
scanf("%d", w + i);
jun[w[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
reverse(jun[i].begin(), jun[i].end());
}
dfs(0, 1);
tick = 0;
dfs2(0, 1, 1);
tree ::init(1, 1, n);
for (int i = 1; i <= q; i++) {
int c;
scanf("%d", &c);
if (c == 1) {
int x, y, k;
scanf("%d %d %d", &x, &y, &k);
int lca = getLca(x, y);
vector<int> v;
for (int it = 0; it < k; it++) {
auto tmp = min(get(x, lca), get(y, lca));
if (tmp.first > 5e17) break;
v.push_back(jun[tmp.second].back());
jun[tmp.second].pop_back();
tree ::update(1, 1, n, st[tmp.second]);
}
printf("%d", v.size());
for (auto x : v) printf(" %d", x);
puts("");
} else {
int x, k;
scanf("%d %d", &x, &k);
tree ::up(1, 1, n, st[x], nd[x], k);
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool uin(T& a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
inline bool uax(T& a, T b) {
return a < b ? (a = b, true) : false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long N, K;
cin >> N >> K;
if (K == 1) {
cout << N << '\n';
return 0;
}
string be, en;
cin >> be >> en;
long long ans = 0, cur = 1;
for (int i = 0; i < N; ++i) {
cur *= 2LL;
if (be[i] == 'b') --cur;
if (en[i] == 'a') --cur;
uin(cur, K);
ans += cur;
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 9;
int n, m, head[N], tot;
struct pp {
int nxt, to;
long long val;
} g[N << 1];
void add(int u, int v, long long w) {
g[++tot].nxt = head[u], g[tot].to = v, g[tot].val = w, head[u] = tot;
}
int rt;
long long dep[N], f[N];
void dfs(int u, int fa) {
for (int i = head[u]; i != -1; i = g[i].nxt) {
int v = g[i].to;
if (v == fa) continue;
dep[v] = dep[u] + g[i].val;
dfs(v, u);
}
if (dep[u] > dep[rt]) rt = u;
f[u] = max(f[u], dep[u]);
}
int ans;
int Fa[N], cnt;
int find(int x) { return Fa[x] == x ? x : (Fa[x] = find(Fa[x])); }
struct node {
int ch[2], dst, siz;
long long val;
} t[N];
void pushup(int x) { t[x].siz = t[t[x].ch[0]].siz + t[t[x].ch[1]].siz + 1; }
int New(int x) {
++cnt;
t[cnt].val = f[x], t[cnt].ch[0] = t[cnt].ch[1] = 0, t[cnt].dst = 1,
t[cnt].siz = 1;
return cnt;
}
int merge(int x, int y) {
if (!x || !y) return x + y;
if (t[x].val < t[y].val) swap(x, y);
t[x].ch[1] = merge(t[x].ch[1], y);
pushup(x);
if (t[t[x].ch[0]].dst < t[t[x].ch[1]].dst) swap(t[x].ch[0], t[x].ch[1]);
t[x].dst = t[t[x].ch[1]].dst + 1;
return x;
}
void del(int x) {
Fa[x] = Fa[t[x].ch[0]] = Fa[t[x].ch[1]] = merge(t[x].ch[0], t[x].ch[1]);
t[x].ch[0] = t[x].ch[1] = t[x].dst = 0, t[x].siz = 0;
return;
}
void dfs2(int u, int fa, long long lim) {
for (int i = head[u]; i != -1; i = g[i].nxt) {
int v = g[i].to;
if (v == fa) continue;
dfs2(v, u, lim);
int fu = find(Fa[u]), fv = find(Fa[v]);
Fa[u] = merge(fu, fv);
}
while (t[find(u)].val - f[u] > lim) {
del(find(u));
}
ans = max(ans, t[find(u)].siz);
}
int main() {
memset(head, -1, sizeof(head));
tot = 0;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
long long w;
scanf("%d%d%lld", &u, &v, &w);
add(u, v, w);
add(v, u, w);
}
dep[1] = 0;
dfs(1, 0);
dep[rt] = 0;
dfs(rt, 0);
dep[rt] = 0;
dfs(rt, 0);
rt = 1;
for (int i = 1; i <= n; i++) {
if (f[rt] > f[i]) rt = i;
}
scanf("%d", &m);
while (m--) {
long long lim;
ans = 0, cnt = 0;
for (int i = 1; i <= n; i++) Fa[i] = New(i);
scanf("%lld", &lim);
dfs2(rt, 0, lim);
printf("%d\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string ss, tt, p, f;
int cnt = 0, flag = -1, temp = -1;
cin >> ss >> tt;
if (ss.size() != tt.size()) return cout << "NO", 0;
for (size_t i = 0; i < ss.size(); i++) {
if (ss[i] != tt[i]) {
cnt++;
if (cnt > 2) return cout << "NO", 0;
if (flag == -1) {
flag = i;
} else {
temp = i;
swap(ss[flag], ss[temp]);
p = ss.substr(0, temp);
f = tt.substr(0, temp);
if (p != f)
return cout << "NO", 0;
else
flag = -1;
}
}
}
if (ss == tt)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long s, x;
scanf("%lld%lld", &s, &x);
long long y = s - x;
if (y & 1) {
printf("0\n");
return 0;
}
y >>= 1;
int cnt = 0;
for (int i = 0; i <= 40; i++) {
if ((x >> i) & 1) {
if ((y >> i) & 1) {
cnt = -1;
break;
} else
cnt++;
}
}
long long ans = cnt == -1 ? 0 : (1LL << cnt);
if (s == x) ans -= 2;
printf("%lld\n", ans);
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define IOS ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define read freopen("in.txt","r",stdin)
#define write freopen("out.txt","w",stdout)
//Default Functions
#define gcd(a,b) __gcd((a),(b))
#define lcm(a,b) ((a)*(b))/(gcd(a,b))
//Data types
#define lli long long int
#define pi pair<int, int>
#define plli pair<long long int, long long int>
//Others
#define mset(a,x) memset(a, x, sizeof(a))
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define pback push_back
#define mx 10000007
int main()
{
IOS
int t;
cin >> t;
while(t--)
{
string s;
cin >> s;
cout << s.size() << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
printf("%d\n", 2001);
for (int i = 1; i <= 1000; i++) {
printf("%d %d %d %d\n", i, 1, i, 2);
}
printf("%d %d %d %d\n", 1, 1, 1, 2);
for (int i = 1; i <= 1000; i++) {
printf("%d %d %d %d\n", i, 1, i, 2);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
while (n--) {
int a[105][30] = {0};
int b[105][30] = {0};
string s, p;
cin >> s >> p;
if (s.size() > p.size()) {
cout << "NO" << endl;
continue;
}
for (int i = 1; i <= s.size(); i++) {
a[i][s[i - 1] - 'a']++;
for (int j = 1; j <= 26; j++) a[i][j] += a[i - 1][j];
}
for (int i = 1; i <= p.size(); i++) {
b[i][p[i - 1] - 'a']++;
for (int j = 1; j <= 26; j++) b[i][j] += b[i - 1][j];
}
int flag = 0;
for (int i = 1; i <= p.size() - s.size() + 1; i++) {
flag = 0;
for (int j = 1; j <= 26; j++) {
if (b[i + s.size() - 1][j] - b[i - 1][j] != a[s.size()][j]) {
flag = 1;
}
}
if (flag == 0) break;
}
if (flag == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double prob[20][20];
double dp[(1 << 19)];
double pmove(int previous_bitmask, int must_die, int &n) {
int total_fishes = __builtin_popcount(previous_bitmask);
long long deno = ((total_fishes) * (total_fishes - 1)) / 2;
double move_prob = 0;
for (int fish = 0; fish < n; fish++) {
if (previous_bitmask & (1 << fish)) {
move_prob += prob[fish + 1][must_die + 1];
}
}
return move_prob / (1.0 * deno);
}
double solve(int bitmask, int n) {
if (__builtin_popcount(bitmask) == n) {
return 1;
}
if (dp[bitmask] > -0.9) {
return dp[bitmask];
}
double answer = 0;
for (int fish = 0; fish < n; fish++) {
bool alive = bitmask & ((1 << fish));
if (!alive) {
int previous_bitmask = bitmask ^ (1 << fish);
double previous_day = solve(previous_bitmask, n);
answer += previous_day * pmove(previous_bitmask, fish, n);
}
}
return dp[bitmask] = answer;
}
int main() {
int n;
cin >> n;
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> prob[i][j];
}
}
for (int i = 0; i < n; i++) {
cout << fixed << setprecision(10) << solve((1 << i), n) << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 5;
int n, k;
string s;
int l[28], r[28];
int main() {
ios::sync_with_stdio(false);
cout.setf(ios::fixed | ios::showpoint);
cout.precision(8);
cin >> n >> k >> s;
for (int i = 0; i < 28; i++) l[i] = r[i] = -1;
int mx = 0;
for (int i = 0; i < n; i++) {
int pos = s[i] - 'A';
if (l[pos] == -1)
l[pos] = r[pos] = i;
else
r[pos] = i;
}
for (int i = 0; i < n; i++) {
int pos = s[i] - 'A';
if (mx > k) return !printf("YES\n");
if (l[pos] == i) mx++;
if (mx > k) return !printf("YES\n");
if (r[pos] == i) mx--;
}
if (mx > k)
cout << "YES\n";
else
cout << "NO\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, start, end;
cin >> n >> m >> start >> end;
start--, end--;
long long r1 = start / m, c1 = start % m;
long long r2 = end / m, c2 = end % m;
if (r1 == r2) {
cout << 1 << endl;
return 0;
};
if (m == 1) {
cout << 1 << endl;
return 0;
};
if (c1 == 0 && c2 == m - 1) {
cout << 1 << endl;
return 0;
};
if (end + 1 == n) {
cout << (c1 == 0 ? 1 : 2) << endl;
return 0;
};
if (r1 + 1 == r2) {
cout << 2 << endl;
return 0;
};
if (c1 == 0) {
cout << 2 << endl;
return 0;
};
if (c2 == m - 1) {
cout << 2 << endl;
return 0;
};
if (c2 == c1 - 1) {
cout << 2 << endl;
return 0;
};
{
cout << 3 << endl;
return 0;
};
return 0;
}
| 4 |
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <utility>
#include <map>
#include <set>
#include <queue>
using namespace std;
vector<int> nei[200000];
int explore(int root, int father, int d) {
if (nei[root].size() == 1 && father == nei[root][0]) {
return 0;
}
int min_leaf = d;
int cnt = 0;
int d2_cnt = 0;
int d1_cnt = 0;
for (int p: nei[root]) {
if (p != father) {
++cnt;
int leaf = explore(p, root, d);
if (leaf <= d - 2) {
++d2_cnt;
} else if (leaf == d - 1) {
++d1_cnt;
} else {
return d + 1;
}
min_leaf = min(leaf, min_leaf);
}
}
if (d2_cnt == cnt) {
return min_leaf + 1;
} else if (d2_cnt == cnt - 1) {
return d;
}
return d + 1;
}
vector<int> order;
int leaf[200000];
bool nr_explore(int d) {
for (int root: order) {
int min_leaf = d + 1;
int d2_cnt = 0;
int cnt = 0;
for (int p: nei[root]) {
if (leaf[p] != -1) {
if (leaf[p] <= d - 2) {
++d2_cnt;
} else if (leaf[p] == d - 1) {
} else {
return false;
}
++cnt;
min_leaf = min(leaf[p], min_leaf);
}
}
if (cnt == 0) {
leaf[root] = 0;
} else if (d2_cnt == cnt) {
leaf[root] = min_leaf + 1;
} else if (d2_cnt == cnt - 1) {
leaf[root] = d;
} else {
return false;
}
}
return leaf[0] <= d;
}
int main() {
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
nei[i].clear();
}
for (int i = 1; i < n; i++) {
int s, t;
scanf("%d %d", &s, &t);
--s, --t;
nei[s].push_back(t);
nei[t].push_back(s);
}
memset(leaf, 0, sizeof(leaf));
order.clear();
order.push_back(0);
int q = 0;
while (q != order.size()) {
int root = order[q];
leaf[root] = 1;
for (int p: nei[root]) {
if (leaf[p] == 0) {
order.push_back(p);
}
}
++q;
}
reverse(order.begin(), order.end());
int l = -1, r = n + 1;
while (l != r - 1) {
int mid = (l + r) >> 1;
if (explore(0, n, mid) <= mid) {
// memset(leaf, -1, sizeof(leaf));
// if (nr_explore(mid)) {
r = mid;
} else {
l = mid;
}
}
cout << r << endl;
}
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
unsigned int f[4][40005], g[4][40005], st[10], n, A, B, C, D;
bool is_prime[100000];
unsigned int p1(unsigned int x) {
unsigned int y = x + 1;
if (x % 2 == 0)
x /= 2;
else
y /= 2;
return x * y;
}
unsigned int p2(unsigned int x) {
unsigned int y = x + 1, z = x * 2 + 1;
if (x % 2 == 0)
x /= 2;
else
y /= 2;
if (x % 3 == 0)
x /= 3;
else if (y % 3 == 0)
y /= 3;
else
z /= 3;
return x * y * z;
}
unsigned int p3(unsigned int x) {
unsigned int y = p1(x);
return y * y;
}
unsigned int PrimeCount(unsigned int n) {
unsigned int i, j, k, m = 0;
for (m = 1; m * m <= n; m++) {
f[0][m] = (n / m - 1);
f[1][m] = (p1(n / m) - 1) * C;
f[2][m] = (p2(n / m) - 1) * B;
f[3][m] = (p3(n / m) - 1) * A;
}
for (i = 1; i <= m; i++) {
g[0][i] = i - 1;
g[1][i] = (p1(i) - 1) * C;
g[2][i] = (p2(i) - 1) * B;
g[3][i] = (p3(i) - 1) * A;
}
for (i = 2; i <= m; i++) {
if (g[0][i] == g[0][i - 1]) continue;
st[0] = 1;
for (k = 1; k < 4; k++) st[k] = st[k - 1] * i;
for (j = 1; j <= min(m - 1, n / i / i); ++j) {
for (k = 0; k < 4; k++) {
if (i * j < m)
f[k][j] -= st[k] * (f[k][i * j] - g[k][i - 1]);
else
f[k][j] -= st[k] * (g[k][n / i / j] - g[k][i - 1]);
}
}
for (j = m; j >= i * i; j--)
for (k = 0; k < 4; k++) g[k][j] -= st[k] * (g[k][j / i] - g[k][i - 1]);
}
for (i = 1; i <= m + 1; i++) f[0][i] *= D, g[0][i] *= D;
unsigned int ans = 0;
for (i = 1; n / i > m; i++)
for (int k = 0; k < 4; k++) ans += f[k][i] - g[k][m];
return ans;
}
int main() {
cin >> n >> A >> B >> C >> D;
unsigned int res = PrimeCount(n);
memset(is_prime, true, sizeof(is_prime));
is_prime[0] = is_prime[1] = false;
for (unsigned int i = 2; (i - 1) * (i - 1) <= n; i++) {
if (is_prime[i]) {
unsigned int cnt = A * i * i * i + B * i * i + C * i + D;
unsigned int rem = n;
while (rem) {
res += cnt * (rem / i);
rem /= i;
}
for (unsigned int j = 2 * i; (j - 1) * (j - 1) <= n; j += i)
is_prime[j] = false;
}
}
cout << res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct SCC {
vector<bool> in_stack;
vector<int> stack;
int top, comp_cnt, time_stamp;
vector<int> delta;
vector<int> eta;
void dfs(vector<int>* G, int v, vector<int>& C) {
stack[top++] = v;
in_stack[v] = 1;
delta[v] = eta[v] = ++time_stamp;
for (int i = (0); i < (((int)(G[v]).size())); i++) {
if (delta[G[v][i]] == 0) {
dfs(G, G[v][i], C);
eta[v] = min(eta[v], eta[G[v][i]]);
} else if (delta[G[v][i]] < delta[v] && in_stack[G[v][i]])
eta[v] = min(eta[v], delta[G[v][i]]);
}
if (delta[v] == eta[v]) {
while (top > 0 && delta[v] <= delta[stack[top - 1]]) {
--top;
in_stack[stack[top]] = 0;
C[stack[top]] = comp_cnt;
}
++comp_cnt;
}
}
int lmSCCTarjanAlgo(vector<int>* G, int n, vector<int>& C) {
in_stack = vector<bool>(n, 0);
C = vector<int>(n, 0);
delta = vector<int>(n, 0);
eta = vector<int>(n, 0);
stack = vector<int>(n, 0);
top = comp_cnt = time_stamp = 0;
for (int i = (0); i < (n); i++)
if (delta[i] == 0) dfs(G, i, C);
return comp_cnt;
}
vector<vector<int> > getDAG(vector<int>* G, int n, vector<int>& C) {
int comp_cnt = lmSCCTarjanAlgo(G, n, C);
vector<vector<int> > result = vector<vector<int> >(comp_cnt);
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (((int)(G[i]).size())); j++) {
int u = G[i][j];
if (C[i] != C[u]) {
result[C[i]].push_back(C[u]);
}
}
}
for (int i = (0); i < (comp_cnt); i++) {
sort(result[i].begin(), result[i].end());
result[i].erase(unique(result[i].begin(), result[i].end()),
result[i].end());
}
return result;
}
};
vector<int> G[1000100];
vector<long long> M[1000100];
vector<int> GC[1000100];
long long getAll(long long m) {
if (m == 0) return 0;
if (m == 1) return 1;
long long left = 1, right = m, idx;
while (left <= right) {
long long mid = (left + right) / 2;
if ((mid) * (mid + 1) / 2 <= m) {
idx = mid;
left = mid + 1;
} else
right = mid - 1;
}
return m * (idx + 1) - idx * (idx + 1) * (idx + 2) / 6;
}
long long CM[1000100];
long long BEST[1000100];
int DEG[1000100];
int LAB[1000100];
long long ADD[1000100];
bool POS[1000100];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = (0); i < (m); i++) {
int a, b;
long long mush;
scanf("%d%d%I64d", &a, &b, &mush);
--a;
--b;
G[a].push_back(b);
M[a].push_back(mush);
}
int start;
scanf("%d", &start);
--start;
SCC scc;
vector<int> comp;
vector<vector<int> > dag = scc.getDAG(G, n, comp);
for (int v = (0); v < (n); v++) {
for (int i = (0); i < (((int)(G[v]).size())); i++) {
int u = G[v][i];
if (comp[u] == comp[v]) CM[comp[v]] += getAll(M[v][i]);
}
}
for (int v = (0); v < (n); v++) GC[comp[v]].push_back(v);
queue<int> q;
for (int i = (0); i < (((int)(dag).size())); i++) {
for (int v : dag[i]) {
++DEG[v];
}
}
for (int i = (0); i < (((int)(dag).size())); i++) {
if (DEG[i] == 0) q.push(i);
}
int label = 1;
long long result = 0;
POS[comp[start]] = true;
while (!q.empty()) {
++label;
int cv = q.front();
q.pop();
if (POS[cv]) BEST[cv] += CM[cv];
result = result > BEST[cv] ? result : BEST[cv];
;
if (POS[cv]) {
for (int v : GC[cv]) {
for (int i = (0); i < (((int)(G[v]).size())); i++) {
int u = G[v][i];
if (comp[u] != comp[v]) {
int cu = comp[u];
if (LAB[cu] != label) {
LAB[cu] = label;
ADD[cu] = 0;
}
ADD[cu] = ADD[cu] > M[v][i] ? ADD[cu] : M[v][i];
;
}
}
}
}
for (int cu : dag[cv]) {
--DEG[cu];
POS[cu] |= POS[cv];
if (DEG[cu] == 0) q.push(cu);
BEST[cu] = BEST[cu] > ADD[cu] + BEST[cv] ? BEST[cu] : ADD[cu] + BEST[cv];
;
}
}
cout << result << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const long long INF = 1e18;
const double eps = 0.0000001;
const long long mod = 1e9 + 7;
long long a[N];
char str[N];
vector<int> p[100005];
vector<int> ans;
int n, m, k, q;
int x, y, z;
int mx;
int judge(int x) {
ans.clear();
int sum = 0;
int need = x - p[0].size();
for (int i = 1; i <= mx; i++) {
for (int j = 0; j < p[i].size(); j++) {
if (p[i].size() - j >= x) {
need--;
sum += p[i][j];
} else {
ans.push_back(p[i][j]);
}
}
}
if (need <= 0) return sum;
int sss = 0;
sort(ans.begin(), ans.end());
while (need--) {
sum += ans[sss++];
}
return sum;
}
int solve(int l, int r) {
while (l + 1 < r) {
int lm = (l + r) >> 1, rm = (lm + r) >> 1;
if (judge(lm) > judge(rm))
l = lm;
else
r = rm;
}
return min(judge(l), judge(r));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
mx = 0;
for (int i = 0; i < n; i++) {
cin >> x >> y;
p[x].push_back(y);
if (mx < x) mx = x;
}
for (int i = 0; i <= mx; i++) {
sort(p[i].begin(), p[i].end());
}
cout << solve(p[0].size(), n);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Matrix {
int data[2][2];
void init() { memset(data, 0, sizeof(data)); }
Matrix operator*(const Matrix &o) {
Matrix ret;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
ret.data[i][j] = 0;
for (int k = 0; k < 2; k++) {
ret.data[i][j] += data[i][k] * o.data[k][j];
}
}
}
return ret;
}
static Matrix power(Matrix o, long long n) {
Matrix ret = o;
n--;
while (n) {
if (n & 1) {
ret = ret * o;
}
o = o * o;
n >>= 1;
}
return ret;
}
};
int n;
long long K;
int a[100005], b[100005];
Matrix meta;
Matrix matrix[100005];
int gao(int p, int num[100005]) {
for (int i = 0; i < n; i++) {
matrix[i].init();
matrix[i].data[0][0] = -1;
matrix[i].data[1][0] = 2 * num[i];
matrix[i].data[1][1] = 1;
if (i) {
matrix[i] = matrix[i - 1] * matrix[i];
}
}
meta.init();
meta.data[0][0] = p;
meta.data[0][1] = 1;
long long div = K / n;
int mod = K % n;
if (div) {
meta = meta * Matrix::power(matrix[n - 1], div);
}
if (mod) {
meta = meta * matrix[mod - 1];
}
return meta.data[0][0];
}
int main() {
while (scanf("%d", &n) != EOF) {
cin >> K;
int mx, my;
scanf("%d %d", &mx, &my);
for (int i = 0; i < n; i++) {
scanf("%d %d", &a[i], &b[i]);
}
int x = gao(mx, a);
int y = gao(my, b);
printf("%d %d\n", x, y);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
unordered_map<int, int> umap;
int m;
cin >> m;
int k;
cin >> k;
for (int i = 0; i < k; i++) {
int a;
cin >> a;
umap[a] = 1;
}
if (umap.find(m) == umap.end()) {
cout << 0;
} else {
int u = m, d = m;
while (d > 0) {
if (umap.find(d) == umap.end()) break;
d--;
}
while (u < n + 1) {
if (umap.find(u) == umap.end()) break;
u++;
}
if (d == 0)
cout << u - m;
else if (u == n + 1)
cout << m - d;
else
cout << min(m - d, u - m);
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool contain(const pair<int, int> &a, const int &b) {
return a.first == b || a.second == b;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
if (n == 3) {
cout << "1 2 3";
return 0;
}
vector<pair<int, int> > v(n);
vector<int> nxt(n, -1);
for (int i = 0; i < n; i++) cin >> v[i].first >> v[i].second;
for (int i = 0; i < n; i++) {
if (contain(v[v[i].second - 1], v[i].first))
nxt[i] = v[i].second - 1;
else
nxt[i] = v[i].first - 1;
}
cout << 1;
int cur = nxt[0];
while (cur != 0) {
cout << " " << cur + 1;
cur = nxt[cur];
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mul(long long a, long long b, long long p = 1000000007) {
return ((a % p) * (b % p)) % p;
}
long long add(long long a, long long b, long long p = 1000000007) {
return (a % p + b % p) % p;
}
void input(long long a[], long long sz) {
for (long long i = 0; i < sz; i++) cin >> a[i];
}
void print(long long a[], long long sz) {
for (long long i = 0; i < sz; i++) {
if (i == sz - 1)
cout << a[i] << "\n";
else
cout << a[i] << " ";
}
}
long long maxr(long long a[], long long sz) {
long long ma;
for (long long i = 0; i < sz; i++) {
if (i == 0)
ma = a[i];
else if (a[i] > ma)
ma = a[i];
}
return ma;
}
long long minr(long long a[], long long sz) {
long long mi;
for (long long i = 0; i < sz; i++) {
if (i == 0)
mi = a[i];
else if (a[i] < mi)
mi = a[i];
}
return mi;
}
long long isprm(long long n) {
if (n <= 1) return 0;
if (n <= 3) return 1;
if (n % 2 == 0 || n % 3 == 0) return 0;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return 0;
return 1;
}
long long power(long long x, long long y, long long p = 1000000007) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long modInverse(long long n, long long p = 1000000007) {
return power(n, p - 2, p);
}
struct comp {
bool operator()(const pair<long long, long long> &a,
const pair<long long, long long> &b) const {
if (a.first == b.first) {
return (a.second > b.second);
}
return (a.first < b.first);
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, m;
cin >> n >> m;
long long b[n + 5], g[m + 5];
input(b, n);
input(g, m);
long long ans = 0;
sort(b, b + n);
sort(g, g + m);
if (g[0] < b[n - 1]) {
cout << "-1\n";
return 0;
}
for (long long i = 0; i < n; i++) {
ans += (b[i] * m);
}
long long s = 0, f = n - 1, g2 = 0;
for (long long i = m - 1; i >= 0; i--) {
if (g[i] > b[n - 1]) {
ans += (g[i] - b[f]);
g2++;
if (g2 == m - 1) {
f--;
g2 = 0;
}
}
}
cout << ans << "\n";
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
const int N = 2e5+10;
int a[N],v[N];
int main()
{
int T;
cin>>T;
while(T--)
{
int n,r,now;
cin>>n;
r=n;
for(int i=1;i<=n;i++)
cin>>a[i],v[a[i]]=i;
for(int i=n;i>=1;i--)
{
if(!v[i])
continue;
now=v[i];
for(int j=v[i];j<=r;j++)
{
printf("%d ",a[j]);
v[a[j]]=0;
}
r=now-1;
}
puts("");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000100;
int dp[N][2];
int a[] = {1, 2};
int solve(int sum, int idx) {
if (sum == 0) return 1;
if (sum < 0 || idx == 2) return 0;
if (dp[sum][idx] != -1) return dp[sum][idx];
return dp[sum][idx] = solve(sum - a[idx], idx) + solve(sum, idx + 1);
}
int main() {
int n;
scanf("%d", &n);
memset(dp, -1, sizeof(dp));
for (int i = 1; i < N; ++i) {
int ans = solve(i, 0);
if (ans == n) {
printf("%d 2\n1 2", i);
break;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char str[200200], pat[200200];
int pre[200200], nxt[200200];
int chr[128];
int main() {
while (~scanf(" %s %s", str, pat)) {
int l1 = strlen(str);
int l2 = strlen(pat);
memset(chr, 0xff, sizeof chr);
int pos = 0;
for (int i = 0; i < l1; ++i) {
if (str[i] == pat[pos] && pos < l2) {
chr[str[i]] = pos++;
}
pre[i] = chr[str[i]];
}
pos = l2 - 1;
memset(chr, 0xff, sizeof chr);
for (int i = l1 - 1; i >= 0; --i) {
if (str[i] == pat[pos] && pos >= 0) {
chr[str[i]] = l2 - pos - 1;
--pos;
}
nxt[i] = chr[str[i]];
}
bool flag = true;
for (int i = 0; i < l1; ++i) {
if (pre[i] + nxt[i] + 2 <= l2) {
flag = false;
break;
}
}
puts(flag ? "Yes" : "No");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> p(n), A(5);
for (int i = 0; i < n; i++) {
cin >> p[i];
}
for (int i = 0; i < 5; i++) {
cin >> A[i];
}
vector<long long> quantity(5, 0);
long long money = 0;
for (int i = 0; i < n; i++) {
money += p[i];
for (int j = 4; j >= 0; j--) {
quantity[j] += money / A[j];
money = money - (money / A[j]) * A[j];
}
}
for (auto i : quantity) {
cout << i << " ";
}
cout << endl;
cout << money << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
vector<vector<long long> > dp;
vector<vector<long long> > tree;
void build(long long v, long long tl, long long tr, long long x) {
if (tl == tr) {
tree[x][v] = dp[tl][x];
return;
}
long long t = (tl + tr) / 2;
build(2 * v, tl, t, x);
build(2 * v + 1, t + 1, tr, x);
tree[x][v] = min(tree[x][2 * v], tree[x][2 * v + 1]);
return;
}
long long get(long long v, long long tl, long long tr, long long l, long long r,
long long x) {
if (l <= tl && tr <= r) return tree[x][v];
long long t = (tl + tr) / 2;
long long one = INF;
long long two = INF;
if ((l <= tl && tl <= r) || (l <= t && t <= r) || (tl <= l && r <= t))
one = get(2 * v, tl, t, l, r, x);
if ((l <= t + 1 && t + 1 <= r) || (l <= tr && tr <= r) ||
(t + 1 <= l && r <= tr))
two = get(2 * v + 1, t + 1, tr, l, r, x);
return min(one, two);
}
void up(long long v, long long tl, long long tr, long long x, long long index) {
if (tl == tr) {
tree[x][v] = dp[index][x];
return;
}
long long t = (tl + tr) / 2;
if (index <= t)
up(2 * v, tl, t, x, index);
else
up(2 * v + 1, t + 1, tr, x, index);
tree[x][v] = min(tree[x][2 * v], tree[x][2 * v + 1]);
return;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, k;
cin >> n >> k;
tree.resize(2, vector<long long>(4 * n));
vector<bool> used(n);
string s;
cin >> s;
dp.resize(n, vector<long long>(2, INF));
for (long long i = 0; i < n; ++i) used[i] = (s[i] - '0');
dp[0][0] = 1;
if (used[0] == 1) dp[0][1] = 1;
build(1, 0, n - 1, 0);
build(1, 0, n - 1, 1);
for (long long i = 1; i < n; ++i) {
if (used[i]) {
dp[i][1] = min(dp[max(0LL, i - k - 1)][0],
get(1, 0, n - 1, max(0LL, i - k), i - 1, 1)) +
(i + 1);
if (i - k - 1 < 0) dp[i][1] = min(dp[i][1], i + 1);
up(1, 0, n - 1, 1, i);
}
dp[i][0] = min(dp[i - 1][0] + (i + 1),
get(1, 0, n - 1, max(0LL, i - k), min(n - 1, i + k), 1));
up(1, 0, n - 1, 0, i);
}
cout << min(dp[n - 1][0], dp[n - 1][1]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 500000, MAX_VAL = 1000000000, MIN_VAL = -1000000000;
int n, x[MAX_N + 1], y[MAX_N + 1], type[3][3], length[3][3];
char c[MAX_N + 1];
void calc(int t, int x0, int y0) {
int i = -1, j = -1, l;
if (x0 == x[0]) {
l = y0 - y[0];
i = 0, j = 1;
if (l < 0) {
i = 2;
l *= -1;
}
}
if (y0 == y[0]) {
l = x0 - x[0];
i = 1, j = 2;
if (l < 0) {
j = 0;
l *= -1;
}
}
if (x0 - y0 == x[0] - y[0]) {
l = x0 - x[0];
i = 0, j = 2;
if (l < 0) {
i = 2, j = 0;
l *= -1;
}
}
if (x0 + y0 == x[0] + y[0]) {
l = x0 - x[0];
i = 2, j = 0;
if (l < 0) {
i = 0, j = 0;
l *= -1;
}
}
if (i != -1 && j != -1 && l < length[i][j]) {
type[i][j] = t;
length[i][j] = l;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
cin >> n;
cin >> x[0] >> y[0];
for (int i = 1; i <= n; i++) {
cin >> c[i] >> x[i] >> y[i];
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
type[i][j] = 0;
length[i][j] = MAX_VAL - MIN_VAL + 1;
}
}
for (int i = 1; i <= n; i++) {
if (c[i] == 'B') {
calc(1, x[i], y[i]);
}
if (c[i] == 'R') {
calc(2, x[i], y[i]);
}
if (c[i] == 'Q') {
calc(3, x[i], y[i]);
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (type[i][j] == 3) {
cout << "YES" << endl;
return 0;
}
}
}
if (type[0][0] == 1 || type[0][2] == 1 || type[2][0] == 1 ||
type[2][2] == 1) {
cout << "YES" << endl;
return 0;
}
if (type[0][1] == 2 || type[1][0] == 2 || type[1][2] == 2 ||
type[2][1] == 2) {
cout << "YES" << endl;
return 0;
}
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int cost[N + 100];
vector<pair<pair<int, int>, pair<int, int> > > seg1, seg2, seg3;
vector<int> ele;
pair<int, int> tree[16 * N + 100];
long long ans = 0;
pair<int, int> taken = make_pair(0, 0);
void update(int v, int tl, int tr, int idx1, int idx2, int val) {
if (tl == tr) {
tree[v] = make_pair(val, idx2);
} else {
int tm = (tl + tr) / 2;
if (idx1 <= tm) {
update(v * 2, tl, tm, idx1, idx2, val);
} else {
update(v * 2 + 1, tm + 1, tr, idx1, idx2, val);
}
tree[v] = max(tree[v * 2], tree[v * 2 + 1]);
}
}
pair<int, int> getMax(int v, int tl, int tr, int l, int r) {
if (l > r) {
return make_pair(0, 0);
}
if (l == tl && r == tr) {
return tree[v];
}
int tm = (tl + tr) / 2;
return max(getMax(v * 2, tl, tm, l, min(r, tm)),
getMax(v * 2 + 1, tm + 1, tr, max(tm + 1, l), r));
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int l, r;
scanf("%d%d", &l, &r);
seg1.push_back(make_pair(make_pair(l, r), make_pair(0, i)));
seg2.push_back(make_pair(make_pair(r, l), make_pair(1, i)));
seg3.push_back(make_pair(make_pair(r, l), make_pair(0, i)));
ele.push_back(l);
ele.push_back(r);
}
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d%d%d", &l, &r, cost + i);
seg1.push_back(make_pair(make_pair(l, r), make_pair(1, i)));
seg2.push_back(make_pair(make_pair(r, l), make_pair(0, i)));
seg3.push_back(make_pair(make_pair(r, l), make_pair(1, i)));
ele.push_back(l);
ele.push_back(r);
}
sort(seg1.begin(), seg1.end());
sort(seg2.begin(), seg2.end());
reverse(seg2.begin(), seg2.end());
sort(seg3.begin(), seg3.end());
set<pair<int, int> > st;
ele.push_back(-1);
sort(ele.begin(), ele.end());
int M = unique(ele.begin(), ele.end()) - ele.begin();
for (auto it : seg1) {
if (it.second.first == 0) {
st.insert(make_pair(it.first.second, it.second.second));
} else if (!st.empty()) {
auto cur = *st.rbegin();
if (cur.first >= it.first.first) {
int l = it.first.first;
int r = min(it.first.second, cur.first);
long long total = 1ll * (r - l) * cost[it.second.second];
if (total > ans) {
ans = total;
taken = make_pair(cur.second, it.second.second);
}
}
}
}
st.clear();
for (auto it : seg2) {
if (it.second.first == 1) {
st.insert(make_pair(it.first.second, it.second.second));
} else {
if (st.empty()) continue;
auto cur = *st.begin();
if (cur.first <= it.first.first) {
int r = it.first.first;
int l = max(it.first.second, cur.first);
long long total = 1ll * (r - l) * cost[it.second.second];
if (total > ans) {
ans = total;
taken = make_pair(cur.second, it.second.second);
}
}
}
}
for (auto it : seg3) {
if (it.second.first == 0) {
int idx1 = lower_bound(ele.begin(), ele.begin() + M, it.first.second) -
ele.begin();
int idx2 = it.second.second;
int val = it.first.first - it.first.second;
update(1, 1, M, idx1, idx2, val);
} else {
int idx1 = lower_bound(ele.begin(), ele.begin() + M, it.first.second) -
ele.begin();
int idx2 = it.second.second;
pair<int, int> ret = getMax(1, 1, M, idx1, M);
if (ret.first != 0) {
long long total = 1ll * cost[idx2] * ret.first;
if (total > ans) {
ans = total;
taken = make_pair(ret.second, idx2);
}
}
}
}
printf("%lld\n", ans);
if (ans > 0) {
printf("%d %d\n", taken.first, taken.second);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
while (cin >> n) {
int a, b, ans, MAX;
MAX = 0;
ans = 0;
for (int i = 0; i < n; i++) {
cin >> a >> b;
ans -= a;
ans += b;
MAX = max(MAX, ans);
}
cout << MAX << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 110;
int n, m, u, v;
char s[2];
int dp[maxn][maxn][30][2];
struct Edge {
int to, nex, dis;
} edge[maxn * maxn];
int head[maxn], ecnt;
void add_edge(int u, int v, int d) {
edge[++ecnt] = {v, head[u], d};
head[u] = ecnt;
}
int go(int x, int y, int num, int who) {
if (~dp[x][y][num][who]) return dp[x][y][num][who];
if (who == 0) {
for (int i = head[x]; i; i = edge[i].nex) {
int to = edge[i].to;
if (edge[i].dis < num) continue;
if (go(to, y, edge[i].dis, who ^ 1) == 0) return dp[x][y][num][who] = 0;
}
return dp[x][y][num][who] = 1;
} else {
for (int i = head[y]; i; i = edge[i].nex) {
int to = edge[i].to;
if (edge[i].dis < num) continue;
if (go(x, to, edge[i].dis, who ^ 1) == 1) return dp[x][y][num][who] = 1;
}
return dp[x][y][num][who] = 0;
}
}
int main() {
scanf("%d %d", &n, &m);
while (m--) {
scanf("%d %d %s", &u, &v, s);
add_edge(u, v, s[0] - 'a' + 1);
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
for (int k = 0; k <= 26; k++) dp[i][j][k][0] = dp[i][j][k][1] = -1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) go(i, j, 0, 0);
for (int i = 1; i <= n; i++, puts(""))
for (int j = 1; j <= n; j++) printf("%c", dp[i][j][0][0] + 'A');
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int MAXN = 1001000;
const long long MOD = 1000003;
long long fac[MAXN], inv[MAXN], invfac[MAXN];
long long n, k;
long long powmod(long long p, long long k) {
long long ret = 1;
for (long long i = 1; i <= k; i <<= 1, p = p * p % MOD)
if (i & k) ret = ret * p % MOD;
return ret;
}
long long sum0(long long k) {
long long ret = 0;
while (k) ret += k /= 2;
return ret;
}
long long sum1(long long n, long long k) {
k = k & -k;
while (k >>= 1) --n;
return n;
}
long long C(long long n, long long k) {
if (n < k) return 0;
return fac[n] * invfac[k] % MOD * invfac[n - k] % MOD;
}
long long P(long long n, long long k) {
if (k >= MOD) return 0;
return C(powmod(2, n), k) * fac[k] % MOD;
}
int main() {
scanf("%I64d%I64d", &n, &k);
if (n <= 63 && (k - 1) >> n) {
puts("1 1");
return 0;
}
invfac[0] = fac[0] = inv[1] = fac[1] = invfac[1] = 1;
for (int i = (2); i <= (MOD - 1); ++i)
inv[i] = (MOD - MOD / i) * inv[MOD % i] % MOD,
fac[i] = fac[i - 1] * i % MOD, invfac[i] = invfac[i - 1] * inv[i] % MOD;
long long p = P(n, k), q = powmod(powmod(2, n), k), _s = sum0(k) + sum1(n, k),
s = powmod(inv[2], _s);
(p *= s) %= MOD;
(q *= s) %= MOD;
p = q - p;
if (p < 0) p += MOD;
printf("%I64d %I64d\n", p, q);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x7fffffff;
inline int reint() {
int d;
scanf("%d", &d);
return d;
}
inline long relong() {
long l;
scanf("%ld", &l);
return l;
}
inline char rechar() {
scanf(" ");
return getchar();
}
inline double redouble() {
double d;
scanf("%lf", &d);
return d;
}
inline string restring() {
string s;
cin >> s;
return s;
}
const int maxn = 1000;
int n;
struct Edge {
int u, v, d;
Edge(int u, int v, int d) : u(u), v(v), d(d) {}
bool operator<(const Edge& rhs) const { return d < rhs.d; }
};
priority_queue<Edge> q;
int vis[maxn];
int p[maxn];
int a;
int main(void) {
cin >> n;
for (int i = (2); i <= (2 * n); i++) {
for (int j = (1); j <= (i - 1); j++) {
cin >> a;
q.push(Edge(i, j, a));
}
}
while (!q.empty()) {
Edge e = q.top();
q.pop();
if (!vis[e.u] && !vis[e.v]) {
vis[e.u] = 1;
vis[e.v] = 1;
p[e.u] = e.v;
p[e.v] = e.u;
}
}
for (int i = (1); i <= (2 * n); i++) {
printf("%d%c", p[i], i == 2 * n ? '\n' : ' ');
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
#define en '\n'
#define endl '\n'
#define ll long long signed
#define pb push_back
#define append push_back
#define all(v) (v).begin(),(v).end()
#define FOR(i,a,b,k) for(int i=a; k>0?i<b:i>b; i+=k)
#define fori(a) for(int i=0; i<a; i++)
#define forj(a) for(int j=0; j<a; j++)
#define fork(a) for(int k=0; k<a; k++)
#define MOD 1000000007
#define MAX 1000010
#define mset(a,s,k) memset(a,k,s*sizeof(a[0]))
#define ff first
#define ss second
#define __ <<" "<<
#define _ <<en
ll pow_(ll a,ll e,ll m=MOD){ll r=1;while(e){if(e&1)r=r*a%m;a=a*a%m;e>>=1;}return r;}
int inv(ll a) {return int(pow_(a,MOD-2,MOD));}int add(ll a, ll b){return (a+b+MOD)%MOD;} int mul(ll a, ll b)
{return (MOD+a*b%MOD)%MOD;}int di(ll a, ll b){return mul(a,inv(b));}ll ceil(ll a,ll b){return a/b+(a%b!=0);}
template<typename T1,typename T2>ostream&operator<<(ostream&O,pair<T1,T2>a){O<<"( ";O<<a.ff<<", "<<a.ss;O<<" )";return O;}
template<typename T>ostream&operator<<(ostream&O,vector<T>V){O<<"[ ";fori(V.size())O<<V[i]<<(i==V.size()-1?"":", ");O<<" ]";return O;}
template<typename T>ostream&operator<<(ostream&O,set<T>S){O<<"{ ";for(T i:S)O<<i<<", ";O<<" }";return O;}
template<typename T1,typename T2>ostream&operator<<(ostream&O,map<T1,T2>S){O<<"{ ";for(auto i:S)O<<i<<", ";O<<" }";return O;}
template<typename T=int>class print{public:vector<T>V;print(vector<T>v){V=v;cout<<" <"<<V<<"> ";}
print(T*x,int n){fori(n)V.push_back(x[i]);cout<<" <"<<V<<"> ";}friend ostream&operator<<(ostream&O,print p){return O;}};
#define vi vector<int>
#define tp pair<int,int>
array<int,4> X,Y,sq;
int arr[MAX]; int N;
void reset();
ll eval(int k){
array<int,4> x,y;
fori(4){
x[i]=X[sq[i]];
y[i]=Y[sq[i]];
}
// abs(x0-x) + abs(x3-x) + abs(x1-k -x) + abs(x2-k -x);
// abs(y3-x) + abs(y2-x) + abs(y0-k -x) + abs(y1-k -x);
array<int,4> ptx={x[0],x[3], x[1]-k, x[2]-k};
array<int,4> pty={y[3],y[2], y[0]-k, y[1]-k};
sort(all(ptx));
sort(all(pty));
ll res=0;
fori(4){
res+=abs(ptx[i]-ptx[1]);
res+=abs(pty[i]-pty[1]);
}
return res;
}
int solve(){
fori(4) cin>>X[i]>>Y[i];
sq={0,1,2,3};
ll res=INT_MAX;
do{
int i=0, j=2*int(1e9)+10;
while(i<=j){
int m=(i+j)/2;
if(eval(m)<eval(m+1)){
j=m-1;
}else{
i=m+1;
}
}
res=min(res, eval(j+1));
}while(next_permutation(all(sq)));
cout<<res<<en;
return 0;
}
void reset(){
// Clear Vectors, maps, sets
// Set default values of arr
}
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t=1;
cin>>t;
while(t--){
solve();
// cout<<solve()<<en;
// cout<<(solve()?"Yes":"No")<<endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 5;
long long a[maxn];
int c[maxn];
int d[maxn];
long long s1[maxn];
long long s2[maxn];
vector<int> vv;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
d[i] = n + 1;
c[i] = 0;
}
stack<int> ss;
for (int i = n; i >= 1; i--) {
while (!ss.empty() && a[ss.top()] >= a[i]) {
int x = ss.top();
ss.pop();
}
if (ss.empty())
d[i] = n + 1;
else
d[i] = ss.top();
ss.push(i);
}
while (!ss.empty()) {
ss.pop();
}
for (int i = 1; i <= n; i++) {
while (!ss.empty() && a[ss.top()] > a[i]) {
int x = ss.top();
ss.pop();
}
if (ss.empty())
c[i] = 0;
else
c[i] = ss.top();
ss.push(i);
}
s1[1] = a[1];
for (int i = 2; i <= n; i++) {
if (a[i] >= a[i - 1]) {
s1[i] = s1[i - 1] + a[i];
} else {
int x = c[i];
s1[i] = s1[x] + (i - x) * a[i];
}
}
s2[n] = a[n];
for (int i = n - 1; i >= 1; i--) {
if (a[i] >= a[i + 1]) {
s2[i] = s2[i + 1] + a[i];
} else {
int x = d[i];
s2[i] = s2[x] + (x - i) * a[i];
}
}
long long ans = 0;
int k = 0;
for (int i = 1; i <= n; i++) {
if (ans < s1[i] + s2[i] - a[i]) {
ans = s1[i] + s2[i] - a[i];
k = i;
}
}
long long temp = a[k];
for (int i = k - 1; i >= 1; i--) {
temp = min(temp, a[i]);
vv.push_back(temp);
}
reverse(vv.begin(), vv.end());
vv.push_back(a[k]);
temp = a[k];
for (int i = k + 1; i <= n; i++) {
temp = min(temp, a[i]);
vv.push_back(temp);
}
for (int i = 0; i < vv.size(); i++) {
printf("%d ", vv[i]);
}
printf("\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, arr[26];
memset(arr, -1, sizeof(arr));
cin >> n;
char a[n], b[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
int setno = 0;
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
if (arr[a[i] - 'a'] == -1 && arr[b[i] - 'a'] == -1) {
arr[a[i] - 'a'] = setno;
arr[b[i] - 'a'] = setno;
setno++;
} else if (arr[b[i] - 'a'] == -1) {
arr[b[i] - 'a'] = arr[a[i] - 'a'];
} else if (arr[a[i] - 'a'] == -1) {
arr[a[i] - 'a'] = arr[b[i] - 'a'];
} else if (arr[a[i] - 'a'] != arr[b[i] - 'a']) {
for (int j = 0; j < 26; j++)
if (arr[j] == arr[b[i] - 'a'] && j != (b[i] - 'a'))
arr[j] = arr[a[i] - 'a'];
arr[b[i] - 'a'] = arr[a[i] - 'a'];
}
}
}
vector<pair<char, char>> ans;
for (int i = 0; i < 26; i++) {
int flag = 0;
char x, y;
for (int j = 0; j < 26; j++) {
if (arr[j] == i && flag == 0) {
x = 'a' + j;
flag = 1;
} else if (arr[j] == i) {
y = 'a' + j;
ans.push_back(make_pair(x, y));
x = y;
}
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > ans;
void _div(int l, int r) {
if (l >= r) return;
if (r - l == 1) {
ans.push_back(pair<int, int>(l, r));
return;
}
int mid = l + r >> 1;
_div(l, mid);
_div(mid + 1, r);
for (int i = l; i <= mid; i++) ans.push_back(pair<int, int>(i, r - (i - l)));
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int k = pow(2, (int)log2(n));
_div(1, k);
_div(n - k + 1, n);
for (int i = 1; i <= n - k; i++) ans.push_back(pair<int, int>(i, i + k));
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first << ' ' << ans[i].second << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int comp(int a, int b) { return a > b; }
int main() {
map<string, int> m1;
int num[105];
int n, m, arr[105];
memset(num, 0, sizeof(num));
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> arr[i];
sort(arr, arr + n);
string tmp;
for (int i = 0; i < m; ++i) {
cin >> tmp;
m1[tmp]++;
}
int j = 0;
for (map<string, int>::iterator it = m1.begin(); it != m1.end(); it++)
num[j++] = it->second;
sort(num, num + m, comp);
int low = 0, high = 0;
for (int i = 0; i < m; ++i) low += num[i] * arr[i];
for (int i = n - 1, j = 0; j < m; ++j, --i) high += num[j] * arr[i];
printf("%d %d\n", low, high);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool a[2000][2000];
int m, n;
bool isEmptyRow(int r, int c1, int c2) {
for (int i = 0; i < m; ++i) {
if (a[r][i] && i != c1 && i != c2) return false;
}
return true;
}
bool isEmptyColumn(int c, int r1, int r2) {
for (int i = 0; i < n; ++i) {
if (a[i][c] && i != r1 && i != r2) return false;
}
return true;
}
int main() {
int xm, xM, ym, yM;
int x1, x2, y1, y2;
char ch;
cin >> n >> m;
for (int i = 0; i <= (n * m - 1); ++i) {
cin >> ch;
if (ch == '.')
a[i / m][i % m] = 0;
else if (ch == 'w')
a[i / m][i % m] = 1;
else
i--;
}
xm = xM = ym = yM = -1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] == 1) {
if (xm == -1 || j < xm) xm = j;
if (j > xM) xM = j;
if (ym == -1 || i < ym) ym = i;
if (i > yM) yM = i;
}
}
}
if (xM - xm == yM - ym) {
x1 = xm;
x2 = xM;
y1 = ym;
y2 = yM;
} else if (xM - xm > yM - ym) {
x1 = xm;
x2 = xM;
y1 = ym;
if (ym + xM - xm < n && (isEmptyRow(yM, xm, xM) || ym == yM))
y2 = ym + xM - xm;
else if (yM - (xM - xm) >= 0 && (isEmptyRow(ym, xm, xM) || ym == yM)) {
y2 = yM;
y1 = yM - (xM - xm);
} else if (xM - xm < n) {
y1 = 0;
y2 = xM - xm;
} else
y2 = -1;
} else {
x1 = xm;
y1 = ym;
y2 = yM;
if (xm + yM - ym < m && (isEmptyColumn(xM, ym, yM) || xm == xM))
x2 = xm + yM - ym;
else if (xM - (yM - ym) >= 0 && (isEmptyColumn(xm, ym, yM) || xm == xM)) {
x2 = xM;
x1 = xM - (yM - ym);
} else if (yM - ym < m) {
x1 = 0;
x2 = yM - ym;
} else
x2 = -1;
}
if (x2 < 0 || y2 < 0) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j] && !(((j == x1 || j == x2) && i <= y2 && i >= y1) ||
((i == y1 || i == y2) && j <= x2 && j >= x1))) {
cout << -1 << endl;
return 0;
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (a[i][j])
cout << 'w';
else if (((j == x1 || j == x2) && i <= y2 && i >= y1) ||
((i == y1 || i == y2) && j <= x2 && j >= x1))
cout << '+';
else
cout << '.';
}
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a[1001], p, q, n, ans;
cin >> p >> q;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
bool ok = true;
for (int i = 0; i < n; i++) {
if (q == 0) {
ok = false;
break;
}
ans = p / q;
if (ans < a[i] || ans > a[i] + 1) {
ok = false;
break;
}
if (ans == a[i])
p = p % q;
else
p = p % q + q;
swap(p, q);
}
if (ok && q == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int a[150004] = {0};
sort(arr, arr + n);
for (int i = 0; i < n; i++) {
if (a[arr[i] - 1] == 0 && (arr[i] - 1) > 0) {
a[arr[i] - 1] = 1;
} else if (a[arr[i]] == 0) {
a[arr[i]] = 1;
} else if (a[arr[i] + 1] == 0 && arr[i] + 1 < 150002) {
a[arr[i] + 1] = 1;
}
}
int count = 0;
for (int i = 0; i < 150002; i++) {
if (a[i] == 1) {
count++;
}
}
cout << count << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, p1[2010], p2[2010], inv1[2010], inv2[2010], sum;
vector<pair<int, int> > swps;
void slv(int posx, int y) {
if (p1[posx] == y) return;
int x = p1[posx], posy = inv1[y], tgtx = inv2[x];
if (tgtx < posx) {
slv(tgtx, x);
slv(posx, y);
return;
} else if (tgtx < posy) {
slv(tgtx, y);
slv(posx, y);
return;
}
p1[posx] = y, p1[posy] = x, inv1[y] = posx, inv1[x] = posy;
swps.push_back(make_pair(posx, posy));
sum += abs(posx - posy);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &p1[i]), inv1[p1[i]] = i;
for (int i = 1; i <= n; ++i) scanf("%d", &p2[i]), inv2[p2[i]] = i;
sum = 0;
for (int i = 1; i <= n; ++i) slv(i, p2[i]);
printf("%d\n%d\n", sum, (int)swps.size());
for (int i = 0; i < swps.size(); ++i)
printf("%d %d\n", swps[i].second, swps[i].first);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 7;
int n;
int main() {
cin >> n;
cout << (n / 2) - 2;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
const int mod=998244353;
#define ll long long
inline int ksm(int x,int y)
{
int ans=1;
for (;y;y/=2,x=(ll)x*x%mod)
if (y&1)
ans=(ll)ans*x%mod;
return ans;
}
int n,m,ans,inv;
int a[22][50005];
int f[100];
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=n;++i)
for (int j=1;j<=m;++j)
scanf("%d",&a[i][j]);
inv=1;
for (int i=1;i<=n;++i)
inv=(ll)inv*i%mod;
inv=ksm(inv,mod-2);
for (int i=1;i<=m;++i)
{
for (int j=1;j<=n;++j)
f[j]=0;
for (int j=1;j<=n;++j)
++f[n-a[j][i]+2];
int tmp=1,sum=1;
for (int j=1;j<=n;++j)
{
tmp+=f[j]-1;
sum=(ll)sum*tmp%mod;
}
(ans+=sum)%=mod;
}
ans=(ll)ans*inv%mod;
ans=(m-ans+mod)%mod;
cout<<ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int L[100010];
int main() {
int N;
cin >> N;
int ma = 0;
int h = 0;
for (int i = 0; i < N; ++i) {
int n;
cin >> n;
while (h > 0 && L[h - 1] <= n) {
ma = max(L[h - 1] ^ n, ma);
h--;
}
if (h > 0) ma = max(L[h - 1] ^ n, ma);
L[h++] = n;
}
cout << ma << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = 1000000000009;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n{};
cin >> n;
vector<long long> v(n);
map<int, int> m;
int ans{};
for (int i = 0, sz = (int)n; i < sz; i++) {
cin >> v[i];
m[v[i]]++;
}
for (int i = 0, sz = (int)n; i < sz; i++) {
int f{};
for (int j = 0, sz = (int)31; j < sz; j++) {
int x = (1 << j) - v[i];
if (m.count(x) && (m[x] > 1 || (m[x] == 1 && x != v[i]))) f = 1;
}
if (!f) ans++;
}
cout << ans << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
using ll = long long;
const int maxn = 1e6 + 5;
ll pw(ll x, ll y, ll mod) {
ll res = 1;
while (y) {
if (y % 2) res = res * x % mod;
x = x * x % mod;
y = y / 2;
}
return ((res % mod) + mod) % mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll n, m, a, Q;
cin >> n >> m >> a >> Q;
ll phi = 1;
{
ll cur = a;
while (cur != 1) {
phi++;
cur = cur * a % Q;
}
}
vector<ll> powers = {1};
ll C = 1;
for (int i = 1; i < n; i++) {
C = C * (m - i + 1) % phi * pw(i, phi - 2, phi) % phi;
powers.push_back(C + powers.back() % phi);
}
reverse(powers.begin(), powers.end());
for (ll p : powers) {
cout << pw(a, p, Q) << " ";
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
int n, dat[500], res = -1;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &dat[i]);
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
int cnt1 = 1, cnt2 = 0, W = dat[i] - 1, t;
for (int k = i + 1; k <= j; k++) cnt1 += (W / dat[k]), W %= dat[k];
t = W = dat[i] - 1 - W + dat[j];
for (int k = 1; k <= n; k++) cnt2 += (W / dat[k]), W %= dat[k];
if (cnt1 < cnt2 && (res == -1 || res > t)) res = t;
}
printf("%d", res);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using ull = unsigned long long;
using ll = long long;
using ld = long double;
using namespace std;
const ll mod = 1e9 + 7;
const int N = 2e5 + 5;
void solve() {
int n, m;
cin >> n >> m;
vector<ll> a(n), b(m);
ll sum = 0;
for (auto& i : a) {
cin >> i;
sum += i;
}
for (auto& i : b) {
cin >> i;
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
if (b.front() < a.back()) {
cout << "-1\n";
return;
}
ll res = 0;
bool flag = 0;
for (int i = 0; i < m; i++) {
if (flag) {
res += b[i];
res += sum - a.back();
continue;
}
if (i == 0) {
if (b[0] == a.back()) {
flag = 1;
res += sum;
continue;
} else {
res += b[i];
res += sum - a.back();
continue;
}
} else {
res += b[i];
res += sum - a[n - 2];
flag = 1;
}
}
cout << res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_T = 31;
const int MAX_H = 201;
long double f[MAX_H][MAX_H][2][MAX_T];
long double s0[MAX_H][MAX_H][2][MAX_T];
long double s1[MAX_H][MAX_H][2][MAX_T];
long double sum0(int h0mn, int h0mx, int h1, int w, int t) {
long double ret = s0[h0mx][h1][w][t];
if (h0mx < 0) return (h0mx - h0mn + 1) * f[0][h1][w][t];
if (h0mn >= 1)
ret -= s0[h0mn - 1][h1][w][t];
else
ret += abs(h0mn) * f[0][h1][w][t];
return ret;
}
long double sum1(int h0, int h1mn, int h1mx, int w, int t) {
long double ret = s1[h0][h1mx][w][t];
if (h1mx < 0) return (h1mx - h1mn + 1) * f[h0][0][w][t];
if (h1mn >= 1)
ret -= s1[h0][h1mn - 1][w][t];
else
ret += abs(h1mn) * f[h0][0][w][t];
return ret;
}
long double g[2][MAX_T];
bool calc[2][MAX_T];
int hp[2], dt[2], lf[2], rg[2], pMiss[2];
long double pShotLD[2];
int nextW[2][MAX_T], nextT[2][MAX_T], prevW[2][MAX_T], prevT[2][MAX_T];
void calcSums(int h0, int h1) {
for (int w = 0; w < 2; w++)
for (int t = w; t < dt[w ^ 1]; t++) {
s0[h0][h1][w][t] = (h0 ? s0[h0 - 1][h1][w][t] : 0) + f[h0][h1][w][t];
s1[h0][h1][w][t] = (h1 ? s1[h0][h1 - 1][w][t] : 0) + f[h0][h1][w][t];
}
}
int main() {
for (int i = 0; i < 2; i++) {
cin >> hp[i] >> dt[i] >> lf[i] >> rg[i] >> pMiss[i];
pShotLD[i] = (100 - pMiss[i]) * 0.01;
}
for (int w = 0; w < 2; w++)
for (int t = w; t < dt[w ^ 1]; t++) {
int next0 = (!t || w == 0) ? dt[0] : t;
int next1 = (!t || w == 1) ? dt[1] : t;
if (next0 <= next1) {
nextW[w][t] = 0;
nextT[w][t] = next1 - next0;
prevW[0][next1 - next0] = w;
prevT[0][next1 - next0] = t;
} else {
nextW[w][t] = 1;
nextT[w][t] = next0 - next1;
prevW[1][next0 - next1] = w;
prevT[1][next0 - next1] = t;
}
}
for (int h0 = 0; h0 <= hp[0]; h0++)
for (int w = 0; w < 2; w++)
for (int t = w; t < dt[w ^ 1]; t++) f[h0][0][w][t] = 1.0;
for (int h1 = 0; h1 <= hp[1]; h1++) calcSums(0, h1);
for (int h0 = 0; h0 <= hp[0]; h0++) calcSums(h0, 0);
for (int h0 = 1; h0 <= hp[0]; h0++)
for (int h1 = 1; h1 <= hp[1]; h1++) {
memset(calc, 0, sizeof(calc));
int w00 = nextW[0][0];
int t00 = nextT[0][0];
long double pBothShoot = 0;
for (int x = lf[0]; x <= rg[0]; x++) {
int h1Next = max(0, h1 - x);
pBothShoot += sum0(h0 - rg[1], h0 - lf[1], h1Next, w00, t00) /
(rg[1] - lf[1] + 1);
}
pBothShoot /= (rg[0] - lf[0] + 1);
long double pZeroShoot =
sum1(h0, h1 - rg[0], h1 - lf[0], w00, t00) / (rg[0] - lf[0] + 1);
long double pOneShoot =
sum0(h0 - rg[1], h0 - lf[1], h1, w00, t00) / (rg[1] - lf[1] + 1);
g[0][0] = pShotLD[0] * pShotLD[1] * pBothShoot +
pShotLD[0] * (1 - pShotLD[1]) * pZeroShoot +
(1 - pShotLD[0]) * pShotLD[1] * pOneShoot;
for (int t = 1; t < dt[1]; t++) {
int w0t = nextW[0][t];
int t0t = nextT[0][t];
g[0][t] = pShotLD[0] * sum1(h0, h1 - rg[0], h1 - lf[0], w0t, t0t) /
(rg[0] - lf[0] + 1);
}
for (int t = 1; t < dt[0]; t++) {
int w1t = nextW[1][t];
int t1t = nextT[1][t];
g[1][t] = pShotLD[1] * sum0(h0 - rg[1], h0 - lf[1], h1, w1t, t1t) /
(rg[1] - lf[1] + 1);
}
for (int w = 0; w < 2; w++)
for (int t = w; t < dt[w ^ 1]; t++) {
int wUnk = w, tUnk = t;
while (!calc[wUnk][tUnk]) {
int wCur = wUnk;
int tCur = tUnk;
long double pCur = 1;
long double sum = 0;
do {
sum += pCur * g[wCur][tCur];
pCur *= tCur ? (1 - pShotLD[wCur])
: (1 - pShotLD[0]) * (1 - pShotLD[1]);
int wTmp = wCur;
int tTmp = tCur;
wCur = nextW[wTmp][tTmp];
tCur = nextT[wTmp][tTmp];
} while ((wCur != wUnk || tCur != tUnk) && !calc[wCur][tCur]);
if (calc[wCur][tCur]) {
sum += pCur * f[h0][h1][wCur][tCur];
} else if (pCur < 1 - 1e-9) {
sum = sum / (1 - pCur);
} else
sum = 0;
f[h0][h1][wUnk][tUnk] = sum;
calc[wUnk][tUnk] = true;
int wTmp = wUnk;
int tTmp = tUnk;
wUnk = prevW[wTmp][tTmp];
tUnk = prevT[wTmp][tTmp];
}
}
calcSums(h0, h1);
}
cout << fixed << setprecision(9) << f[hp[0]][hp[1]][0][0] << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int main() {
int n, x, y;
char num[N];
int step = 0;
cin >> n >> x >> y;
getchar();
gets(num);
if (y == 0 && num[n - 1] == '0') step++;
for (int i = 1; i <= y; i++) {
if (num[n - i] == '1') step++;
if (i == y && num[n - i - 1] == '0') step++;
}
for (int j = y + 2; j <= x; j++) {
if (num[n - j] == '1') step++;
}
cout << step;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, vis[20];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
int tmp = 0;
for (int j = 1; j <= k; ++j) {
int x;
scanf("%d", &x);
tmp += x << (k - j);
}
vis[tmp] = 1;
}
int flag = 0;
for (int i = 0; i < (1 << k); ++i)
for (int j = 0, x; j < (1 << k); ++j)
if (vis[i] && vis[j]) {
for (x = 0; x < k; ++x)
if (((i >> x) & 1) && ((j >> x) & 1)) break;
if (x == k) flag = 1;
}
puts(flag ? "YES" : "NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100001;
double logFact[N];
int main() {
int maxItr = 250;
for (int i = 2; i < N; i++) logFact[i] = logFact[i - 1] + log(i);
int v;
cin >> v;
for (int i = 0; i < v; i++) {
vector<int> vec;
for (int j = 0; j < maxItr; j++) {
int x;
cin >> x;
vec.push_back(x);
}
double maxi = -1E18;
string ans = "";
int P = -1;
for (int k = 1; k <= 1000; k++) {
double lnP = log(k);
double ln2P = log(2 * k + 1);
double poisson = 0;
double uniform = 0;
for (int j = 0; j < maxItr; j++)
if (vec[j] <= k && vec[j] + k >= 0)
uniform -= ln2P;
else
uniform -= 1E18;
for (int j = 0; j < maxItr; j++) {
vec[j] += k;
if (vec[j] >= 0)
poisson += vec[j] * lnP - logFact[vec[j]] - k;
else
poisson -= 1E18;
vec[j] -= k;
}
if (poisson > maxi) {
maxi = poisson;
P = k;
ans = "poisson";
}
if (uniform > maxi) {
maxi = uniform;
P = k;
ans = "uniform";
}
}
cout << ans << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string ans = "";
int z = 0, it1 = n;
for (int i = 0; i < n; i++) {
for (int k = 0; k < 2 * it1; k++) {
if (k < it1) {
ans += "(";
} else {
ans += ")";
}
}
for (int j = 0; j < z; j++) {
ans += "()";
}
z++;
it1--;
if (i != n - 1) {
ans += "\n";
}
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 105;
using namespace std;
int T;
int n;
long long m;
long long a[N], sum;
int main() {
scanf("%d", &T);
while (T--) {
sum = 0;
scanf("%d%lld", &n, &m);
for (register int i = 1; i <= n; i++) scanf("%lld", &a[i]), sum += a[i];
puts(sum == m ? "YES" : "NO");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int k, n;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int pfx[n + 1];
pfx[0] = 0;
double ans = 0;
for (int i = 0; i < n; i++) pfx[i + 1] = pfx[i] + a[i];
for (int len = k; len <= n; len++) {
for (int i = 0; i < n - len + 1; i++) {
int l = i, r = i + len - 1;
int sum = pfx[r + 1] - pfx[l];
ans = max(ans, 1.0 * sum / len);
}
}
cout << fixed << setprecision(7) << ans << endl;
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.