solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l, r, x = 0, y = 0;
cin >> n >> l >> r;
if (l <= r) {
if (n > r) {
for (int i = 0; i < r; i++) {
x = x + pow(2, i);
}
for (int i = 0; i < n - r; i++) {
x = x + pow(2, r - 1);
}
for (int i = 0; i < l; i++) {
y = y + pow(2, i);
}
for (int i = 0; i < n - l; i++) {
y++;
}
} else {
for (int i = 0; i < n; i++) {
x = x + pow(2, i);
}
for (int i = 0; i < l; i++) {
y = y + pow(2, i);
}
for (int i = 0; i < n - l; i++) {
y++;
}
}
cout << y << " " << x << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long double A[4];
long double find_det() { return A[0] * A[3] - A[1] * A[2]; }
int main(void) {
for (int i = 0; i < 4; i++) {
cin >> A[i];
}
long double maxim = max(
max(fabs(A[0] + A[1] + A[2] + A[3]), fabs(A[0] - A[1] + A[2] - A[3])),
max(fabs(A[0] - A[1] - A[2] + A[3]), fabs(A[0] + A[1] - A[2] - A[3])));
if (maxim == 0)
cout << setprecision(12) << 0 << endl;
else
cout << setprecision(12) << fabs(find_det()) / fabs(maxim) << endl;
;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxT = 32 * 100000;
int n, Q, cnt;
map<int, int> pla;
struct range {
int s, e;
range(int s = -1, int e = -1) : s(s), e(e) {}
};
struct empcmp {
inline bool operator()(const range &a1, const range &a2) const {
return a1.s < a2.s;
}
};
struct sizcmp {
inline bool operator()(const range &a1, const range &a2) const {
return (a1.e - a1.s != a2.e - a2.s) ? (a1.e - a1.s > a2.e - a2.s)
: (a1.s > a2.s);
}
};
set<range, empcmp> emp;
set<range, sizcmp> siz;
struct node {
int s, e, sum;
int l, r;
node(int s = 0, int e = 0, int sum = 0, int l = -1, int r = -1)
: s(s), e(e), sum(sum), l(l), r(r) {}
};
node t[maxT];
inline void INSERT(range a) {
emp.insert(a);
siz.insert(a);
}
inline void ERASE(range a) {
emp.erase(a);
siz.erase(a);
}
inline int newCoat() {
range top = *siz.begin();
ERASE(top);
if (top.s == top.e) return top.s;
if (top.e - top.s == 1) {
INSERT(range(top.s, top.s));
return top.e;
}
int select = (top.s + top.e + 1) / 2;
INSERT(range(top.s, select - 1));
INSERT(range(select + 1, top.e));
return select;
}
inline void pickCoat(int pos) {
if (emp.empty()) {
INSERT(range(pos, pos));
return;
}
set<range>::iterator it = emp.lower_bound(range(pos, pos));
if (it == emp.begin()) {
if (it->s == (pos + 1)) {
range tmp = *it;
ERASE(tmp);
INSERT(range(pos, tmp.e));
} else
INSERT(range(pos, pos));
return;
}
if (it == emp.end()) {
it--;
if (it->e == pos - 1) {
range tmp = *it;
ERASE(tmp);
INSERT(range(tmp.s, pos));
} else
INSERT(range(pos, pos));
return;
}
range next = *it;
range prev = *(--it);
int s = pos, e = pos;
if (prev.e == pos - 1) {
ERASE(prev);
s = prev.s;
}
if (next.s == pos + 1) {
ERASE(next);
e = next.e;
}
INSERT(range(s, e));
}
inline int getSum(int root, int s, int e) {
if (root == -1 || e < t[root].s || t[root].e < s) return 0;
if (s <= t[root].s && t[root].e <= e) return t[root].sum;
return getSum(t[root].l, s, e) + getSum(t[root].r, s, e);
}
inline void add(int root, int pos, int key) {
t[root].sum += key;
if (t[root].s == t[root].e) return;
int mid = (t[root].s + t[root].e) / 2;
if (pos <= mid) {
if (t[root].l == -1) {
t[t[root].l = ++cnt] = node(t[root].s, mid, 0);
}
add(t[root].l, pos, key);
} else {
if (t[root].r == -1) {
t[t[root].r = ++cnt] = node(mid + 1, t[root].e, 0);
}
add(t[root].r, pos, key);
}
}
int main() {
scanf("%d%d", &n, &Q);
INSERT(range(1, n));
vector<range> que;
t[++cnt] = node(1, n, 0);
while (Q) {
int ord;
scanf("%d", &ord);
if (ord == 0) {
int s, e;
scanf("%d%d", &s, &e);
printf("%d\n", getSum(1, s, e));
Q--;
continue;
}
if (pla[ord] == 0)
add(1, pla[ord] = newCoat(), 1);
else {
pickCoat(pla[ord]);
add(1, pla[ord], -1);
pla[ord] = 0;
}
Q--;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = int(1e9);
const long long INFll = 1ll * INF * INF;
const int MOD = 1000000007;
char a[50][50];
int cost[50][50];
int f[1048700];
int cnt[50][50];
int mask[50][50];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> a[i][j];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> cost[i][j];
for (int i = 1; i < (1 << n); ++i) f[i] = INF;
for (int i = 0; i < m; ++i) {
for (int c = 0; c < 26; ++c) {
int tmp = -1;
for (int j = 0; j < n; ++j)
if (a[j][i] - 'a' == c)
mask[i][c] |= (1 << j), cnt[i][c] += cost[j][i],
tmp = max(tmp, cost[j][i]);
cnt[i][c] -= tmp;
}
}
for (int i = 0; i < (1 << n) - 1; ++i) {
int num = -1;
for (int j = 0; j < n; ++j)
if (!(i & (1 << j))) {
num = j;
break;
}
for (int j = 0; j < m; ++j) {
f[i | (1 << num)] = min(f[i | (1 << num)], f[i] + cost[num][j]);
f[i | mask[j][a[num][j] - 'a']] =
min(f[i | mask[j][a[num][j] - 'a']], f[i] + cnt[j][a[num][j] - 'a']);
}
}
cout << f[(1 << n) - 1];
;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int n, m;
pair<int, int> val[1550][1550];
char tab[1550][1550];
bool vist[1550][1550];
int getPi(int i) { return (i % n + n) % n; }
int getPj(int j) { return (j % m + m) % m; }
bool dfs(int i, int j) {
int pi = getPi(i), pj = getPj(j);
if (vist[pi][pj] and val[pi][pj] != make_pair(i, j)) return true;
if (vist[pi][pj] and val[pi][pj] == make_pair(i, j)) return false;
vist[pi][pj] = true;
val[pi][pj] = make_pair(i, j);
bool ans = false;
for (int k = int(0); k < int(4); ++k) {
int x = i + dx[k], y = j + dy[k];
int px = getPi(x), py = getPj(y);
if (tab[px][py] == '#') continue;
ans = ans or dfs(x, y);
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int x, y;
cin >> n >> m;
for (int i = int(0); i < int(n); ++i)
for (int j = int(0); j < int(m); ++j) {
cin >> tab[i][j];
if (tab[i][j] == 'S') x = i, y = j;
}
cout << (dfs(x, y) ? "Yes" : "No") << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 * 1000;
int n;
struct seq {
long long int s, h;
string str;
void initialize() {
s = h = 0;
for (int i = 0; i < str.size(); i++) {
if (str[i] == 's')
s++;
else
h++;
}
}
bool operator<(const seq& t) const { return (t.h * s) > (t.s * h); }
};
seq t[maxn];
void read();
long long int ans(string);
int main() {
read();
sort(t, t + n);
string str = "";
for (int i = 0; i < n; i++) str += t[i].str;
cout << ans(str) << endl;
return 0;
}
void read() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t[i].str;
t[i].initialize();
}
}
long long int ans(string str) {
long long int ans = 0;
int s = 0;
for (int i = 0; i < str.size(); i++) {
if (str[i] == 'h')
ans += s;
else
s++;
}
return ans;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int max(long long int a, long long int b) {
if (a > b) return a;
return b;
}
long long int min(long long int a, long long int b) {
if (a < b) return a;
return b;
}
const long long int MOD = 1e9 + 7, N = 2e5 + 5, INF = 1e18, M = 1e6;
std::vector<int> s, p;
string a;
bool check(int t) {
int ls = -1, tp = 0;
for (int i = 0; i < p.size(); i++) {
tp = upper_bound(s.begin(), s.end(), ls) - s.begin();
if (tp == s.size()) return true;
if (s[tp] < p[i] && abs(s[tp] - p[i]) > t) return false;
if (s[tp] > p[i])
ls = p[i] + t;
else
ls = max(p[i] + max(t - ((p[i] - s[tp]) * 2), 0),
p[i] + (t - p[i] + s[tp]) / 2);
}
if (upper_bound(s.begin(), s.end(), ls) != s.end()) return false;
return true;
}
int main() {
cin.sync_with_stdio(false), cin.tie(NULL);
int n;
cin >> n;
cin >> a;
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] == '*')
s.push_back(i);
else if (a[i] == 'P')
p.push_back(i);
}
int l = 0, r = 2 * n, mid;
while (r - l > 1) {
mid = l + r;
mid /= 2;
if (check(mid))
r = mid;
else
l = mid;
}
if (!check(l)) l = r;
cout << l << "\n";
return 0;
}
long long int bin_p(long long int n, long long int m) {
long long int tp = 1, ans = 0;
while (m > 1) {
if (m & 1) {
m /= 2;
tp *= n;
} else
m /= 2;
n *= n;
}
n *= tp;
return n;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int blame[100001];
int clear[100001];
int cur[100001];
bool susp[100001];
int main() {
int n, m;
cin >> n >> m;
int a;
int allclear = 0;
int allblame = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a);
cur[i] = a;
if (a < 0) {
clear[-a - 1]++;
allclear++;
} else
blame[a - 1]++;
}
int cnt = 0;
for (int i = 0; i < n; i++) {
int m1 = blame[i] + allclear - clear[i];
if (m1 == m) {
susp[i] = true;
cnt++;
}
}
for (int i = 0; i < n; i++) {
if (cur[i] > 0 && susp[cur[i] - 1] && cnt == 1 ||
(cur[i] < 0 && !susp[-cur[i] - 1]))
puts("Truth");
else if ((cur[i] < 0 && susp[-cur[i] - 1] && cnt == 1) ||
(cur[i] > 0 && !susp[cur[i] - 1]))
puts("Lie");
else
puts("Not defined");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 4 * atan((long double)1);
const long long mod = 1e9 + 7;
const long long inf = 922337203685477;
const long long nax = 2e5 + 5;
long long n;
long long tp[nax], seg[4 * nax];
pair<long long, long long> a[nax];
vector<pair<long long, long long>> b;
void upd(long long l, long long r, long long pos, long long fp, long long val) {
if (l == fp && r == fp) {
seg[pos] = val;
} else if (fp > r || fp < l) {
return;
} else {
long long mid = (l + r) / 2;
upd(l, mid, 2 * pos, fp, val);
upd(mid + 1, r, 2 * pos + 1, fp, val);
seg[pos] = max(seg[2 * pos], seg[2 * pos + 1]);
}
}
long long que(long long l, long long r, long long pos, long long fl,
long long fr) {
if (b[r - 1].first <= fl || seg[pos] <= fr) {
return inf;
} else if (l == r) {
return l;
} else {
long long ret;
long long mid = (l + r) / 2;
ret = que(l, mid, 2 * pos, fl, fr);
if (ret == inf) {
ret = que(mid + 1, r, 2 * pos + 1, fl, fr);
}
return ret;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (long long i = 1; i <= n; i++) {
string s;
cin >> s >> a[i].first >> a[i].second;
b.push_back({a[i].first, a[i].second});
if (s == "add") {
tp[i] = 1;
} else if (s == "remove") {
tp[i] = 2;
} else {
tp[i] = 3;
}
}
sort(b.begin(), b.end());
for (long long i = 1; i <= n; i++) {
if (tp[i] == 1) {
long long idx = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
upd(1, n, 1, idx + 1, a[i].second);
} else if (tp[i] == 2) {
long long idx = lower_bound(b.begin(), b.end(), a[i]) - b.begin();
upd(1, n, 1, idx + 1, 0);
} else {
long long idx = que(1, n, 1, a[i].first, a[i].second);
if (idx == inf) {
cout << -1 << '\n';
} else {
cout << b[idx - 1].first << " " << b[idx - 1].second << '\n';
}
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e18;
const int N = 1e5 + 5;
void solve() {
int n;
cin >> n;
set<int> st;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x % 2 == 0) st.insert(x);
}
int ans = 0;
while (!st.empty()) {
int x = *st.rbegin();
st.erase(x);
if (x % 2 == 0) st.insert(x / 2), ans++;
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << showpoint;
cout << setprecision(9);
int test = 1;
cin >> test;
while (test--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int64_t n, k, i;
int main() {
cin >> n >> k;
cout << (n / k % 2 ? "YES" : "NO");
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
inline int read() {
int x = 0;
bool f = 0;
char ch;
do {
ch = getchar();
f |= (ch == '-');
} while (!isdigit(ch));
do {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
} while (isdigit(ch));
return f ? -x : x;
}
inline void write(int x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
inline void writesp(int x) {
write(x);
putchar(' ');
}
inline void writeln(int x) {
write(x);
puts("");
}
int head[maxn], to[maxn << 1], nxt[maxn << 1], tot = 0;
void add(int u, int v) {
nxt[++tot] = head[u];
head[u] = tot;
to[tot] = v;
}
int dep[maxn];
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
for (register int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v == fa) continue;
dfs(v, u);
}
}
bool tag[maxn];
void diam(int u, int fa) {
for (register int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v == fa) continue;
diam(v, u);
if (tag[v]) tag[u] = true;
}
}
int n, k;
int len, f[maxn], g[maxn], col[maxn];
void color2(int u, int fa, int op) {
if (op)
col[u] = col[fa] % k + 1;
else
col[u] = col[fa] - 1 + (col[fa] == 1) * k;
for (register int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v == fa) continue;
color2(v, u, op);
if (f[v] >= f[u])
g[u] = f[u], f[u] = f[v] + 1;
else if (f[v] >= g[u])
g[u] = f[v] + 1;
if (g[v] >= g[u]) g[u] = g[v] + 1;
}
if (f[u] + g[u] + 1 >= k) {
puts("No");
exit(0);
}
}
void color1(int u, int fa) {
col[u] = col[fa] % k + 1;
for (register int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v == fa) continue;
if (tag[v]) {
color1(v, u);
continue;
}
if (dep[u] * 2 - 1 <= len)
color2(v, u, 0);
else
color2(v, u, 1);
if (f[v] >= f[u])
g[u] = f[u], f[u] = f[v] + 1;
else if (f[v] >= g[u])
g[u] = f[v] + 1;
if (g[v] >= g[u]) g[u] = g[v] + 1;
}
if (f[u] + g[u] + 1 >= k) {
puts("No");
exit(0);
}
if (f[u] && f[u] + dep[u] >= k && f[u] + len - dep[u] + 1 >= k) {
puts("No");
exit(0);
}
}
int main() {
n = read(), k = read();
for (register int i = 1; i <= n - 1; ++i) {
int u = read(), v = read();
add(u, v);
add(v, u);
}
dfs(1, 0);
if (k == 2) {
puts("Yes");
for (register int i = 1; i <= n; ++i) {
writesp((dep[i] & 1) ? 1 : 2);
}
return 0;
}
int temp = 0;
for (register int i = 1; i <= n; ++i) {
if (dep[i] > dep[temp]) temp = i;
}
memset(dep, 0, sizeof dep);
dfs(temp, 0);
int s = 0;
for (register int i = 1; i <= n; ++i) {
if (dep[i] > dep[s]) s = i;
}
tag[s] = 1;
diam(temp, 0);
col[0] = k;
len = dep[s];
color1(temp, 0);
puts("Yes");
for (register int i = 1; i <= n; ++i) writesp(col[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
int n;
char s[maxn];
char t[maxn];
int cnt[55];
void scanff() {
scanf("%d", &n);
scanf("%s%s", s + 1, t + 1);
}
void work() {
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= n; i++) {
cnt[s[i] - 'a']++;
cnt[t[i] - 'a']--;
}
for (int i = 0; i <= 25; i++) {
if (cnt[i] != 0) {
printf("-1\n");
return;
}
}
int ans = 999;
for (int i = 1; i <= n; i++) {
int now = i;
for (int j = 1; j <= n && now <= n; j++) {
if (s[j] == t[now]) {
now++;
}
}
ans = min(ans, n - (now - i));
}
printf("%d\n", ans);
}
int main() {
int T;
scanf("%d", &T);
for (; T--;) {
scanff();
work();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int N = 400000 + 10;
inline int toint(char c) { return (c != '$') ? (c - 'a' + 1) : 0; }
int n, k;
std::string a[N];
long long ret[N];
namespace SAM {
struct T {
int par, tr[27], len, size;
T() {
par = len = size = 0;
for (int i = 0; i < 27; i++) tr[i] = 0;
}
} t[N];
int cnt, qs, last;
std::vector<int> son[N];
inline int& tr(int q, int c) { return t[q].tr[c]; }
inline int& len(int q) { return t[q].len; }
inline int& par(int q) { return t[q].par; }
inline int& size(int q) { return t[q].size; }
inline void init() { last = qs = ++cnt; }
inline int newnode(int l) {
++cnt;
len(cnt) = l;
size(cnt) = 1;
return cnt;
}
inline int newnode(int o, int l) {
t[++cnt] = t[o];
len(cnt) = l;
size(cnt) = 0;
return cnt;
}
void append(int c) {
int np = newnode(len(last) + 1), p = last;
last = np;
while (p && tr(p, c) == 0) {
tr(p, c) = np;
p = par(p);
}
if (p == 0) {
par(np) = qs;
return;
}
int q = tr(p, c);
if (len(q) == len(p) + 1)
par(np) = q;
else {
int nq = newnode(q, len(p) + 1);
par(np) = par(q) = nq;
while (p && tr(p, c) == q) {
tr(p, c) = nq;
p = par(p);
}
}
}
std::set<int> col[N];
int cc[N];
void dfs1(int u) {
for (int v : son[u]) {
dfs1(v);
size(u) += size(v);
if (col[u].size() < col[v].size()) std::swap(col[u], col[v]);
for (int x : col[v]) col[u].insert(x);
col[v] = std::set<int>();
}
cc[u] = col[u].size();
}
long long pre[N];
void dfs2(int u, int fa) {
pre[u] = pre[fa] + (cc[u] >= k ? len(u) - len(par(u)) : 0);
for (int v : son[u]) dfs2(v, u);
}
void build() {
int q = qs;
for (int i = 1; i <= n; i++) {
for (char c : a[i]) col[q = tr(q, toint(c))].insert(i);
q = tr(q, toint('$'));
}
for (int i = 1; i <= cnt; i++) son[par(i)].push_back(i);
dfs1(qs);
dfs2(qs, 0);
}
long long solve(const std::string& s) {
long long ans = 0;
int q = qs, tl = 0;
for (char c : s) {
q = tr(q, toint(c));
tl++;
while (tl <= len(par(q))) {
puts("NMSL");
q = par(q);
}
if (cc[q] >= k) {
int L = len(par(q)) + 1, R = len(q);
R = std::min(R, tl);
ans += std::max(0, R - L + 1);
}
ans += pre[par(q)];
}
return ans;
}
} // namespace SAM
int main() {
std::ios::sync_with_stdio(0);
SAM::init();
std::cin >> n >> k;
for (int i = 1; i <= n; i++) {
std::cin >> a[i];
for (char c : a[i]) SAM::append(toint(c));
SAM::append(toint('$'));
}
SAM::build();
for (int i = 1; i <= n; i++) ret[i] = SAM::solve(a[i]);
for (int i = 1; i <= n; i++) std::cout << ret[i] << " ";
std::cout << std::endl;
std::cerr << 1.0 * clock() / CLOCKS_PER_SEC << std::endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using VS = vector<string>;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
using VL = vector<LL>;
using VVL = vector<VL>;
const int INF = 1e9;
const LL LINF = 1e16;
const LL MOD = 1000000007;
const double PI = acos(-1.0);
int DX[8] = {0, 0, 1, -1, 1, 1, -1, -1};
int DY[8] = {1, -1, 0, 0, 1, -1, 1, -1};
LL ans = 0LL;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
LL N, K;
cin >> N >> K;
VL x(N), y(N);
for (int(i) = (0); (i) < (N); (i)++) {
cin >> x[i];
}
for (int(i) = (0); (i) < (N); (i)++) {
cin >> y[i];
}
LL a = 0, b = 0;
for (int(i) = (0); (i) < (N); (i)++) {
a = max(0ll, a + x[i] - y[i] * K);
b = max(0ll, b + y[i] - x[i] * K);
if (a > K || b > K) {
puts("NO");
return 0;
}
}
puts("YES");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
vector<int> nei[maxn];
int sx[maxn], deg[maxn], que[maxn];
bool used[maxn], vis[maxn];
int U, V, frm[maxn];
pair<int, int> maxx[2][maxn];
void add(pair<int, int> &a, pair<int, int> b) {
a.first += b.first;
a.second += b.second;
return;
}
void sub(pair<int, int> &a, pair<int, int> b) {
a.first -= b.first;
a.second -= b.second;
return;
}
void clear(int rt, int f) {
maxx[0][rt] = maxx[1][rt] = make_pair(0, 0);
bool used = false;
for (int i = 0; i < (int)nei[rt].size(); i++) {
int to = nei[rt][i];
if (to == f) continue;
if (((rt == U && to == V) || (rt == V && to == U)) && (used == false)) {
used = true;
continue;
}
clear(to, rt);
}
return;
}
void slv(int rt, int f) {
bool used = false;
for (int i = 0; i < (int)nei[rt].size(); i++) {
int to = nei[rt][i];
if (to == f) continue;
if (((rt == U && to == V) || (rt == V && to == U)) && (used == false)) {
used = true;
continue;
}
slv(to, rt);
add(maxx[0][rt], maxx[1][to]);
}
maxx[1][rt] = maxx[0][rt];
frm[rt] = -1;
used = false;
for (int i = 0; i < (int)nei[rt].size(); i++) {
int to = nei[rt][i];
if (to == f) continue;
if (((rt == U && to == V) || (rt == V && to == U)) && (used == false)) {
used = true;
continue;
}
pair<int, int> cur = maxx[0][rt];
sub(cur, maxx[1][to]);
add(cur, maxx[0][to]);
cur.first++;
cur.second += (sx[rt] != sx[to]);
if (cur > maxx[1][rt]) {
maxx[1][rt] = cur;
frm[rt] = to;
}
}
return;
}
vector<pair<int, int> > out;
void wrk(int rt, int type, int f) {
if (type == 1) {
bool used = false;
for (int i = 0; i < (int)nei[rt].size(); i++) {
int to = nei[rt][i];
if (to == f) continue;
if (((rt == U && to == V) || (rt == V && to == U)) && (used == false)) {
used = true;
continue;
}
if (to == frm[rt])
wrk(to, 0, rt);
else
wrk(to, 1, rt);
}
if (~frm[rt]) out.push_back(make_pair(frm[rt], rt));
} else {
bool used = false;
for (int i = 0; i < (int)nei[rt].size(); i++) {
int to = nei[rt][i];
if (to == f) continue;
if (((rt == U && to == V) || (rt == V && to == U)) && (used == false)) {
used = true;
continue;
}
wrk(to, 1, rt);
}
}
return;
}
void tag(int rt, int f) {
vis[rt] = true;
bool used = false;
for (int i = 0; i < (int)nei[rt].size(); i++) {
int to = nei[rt][i];
if (to == f) continue;
if (((rt == U && to == V) || (rt == V && to == U)) && (used == false)) {
used = true;
continue;
}
tag(to, rt);
}
return;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int f;
scanf("%d%d", &f, &sx[i]);
nei[f].push_back(i);
nei[i].push_back(f);
deg[i]++;
deg[f]++;
}
int head = 0, tail = 0;
for (int i = 1; i <= n; i++) {
if (deg[i] == 1) {
used[i] = true;
que[tail++] = i;
}
}
while (head < tail) {
int cur = que[head++];
for (int i = 0; i < (int)nei[cur].size(); i++) {
int to = nei[cur][i];
if ((--deg[to]) == 1) {
used[to] = true;
que[tail++] = to;
}
}
}
pair<int, int> ans = make_pair(0, 0);
for (int i = 1; i <= n; i++) {
if (used[i] || vis[i]) continue;
int aim1 = -1, aim2 = -1;
for (int j = 0; j < (int)nei[i].size(); j++) {
int to = nei[i][j];
if (used[to]) continue;
if (~aim1)
aim2 = to;
else
aim1 = to;
}
U = i;
V = aim1;
slv(i, 0);
pair<int, int> ans1 = maxx[1][i];
clear(i, 0);
U = i;
V = aim2;
slv(i, 0);
pair<int, int> ans2 = maxx[1][i];
clear(i, 0);
if (ans1 > ans2) {
U = i;
V = aim1;
}
slv(i, 0);
add(ans, maxx[1][i]);
clear(i, 0);
wrk(i, 1, 0);
tag(i, 0);
}
printf("%d %d\n", ans.first, ans.second);
for (int i = 0; i < (int)out.size(); i++)
printf("%d %d\n", out[i].first, out[i].second);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, a[105], f, ans;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
while (n) {
++ans;
for (int i = 0; i < n; ++i) {
if (a[i] >= f) {
++f;
a[i] = 999;
}
}
sort(a, a + n);
n -= f;
f = 0;
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
int add(int a, int b) {
if ((a += b) >= P) a -= P;
return a;
}
int sub(int a, int b) {
if ((a -= b) < 0) a += P;
return a;
}
int mul(int a, int b) { return 1ll * a * b % P; }
int kpow(int a, int b) {
int r = 1;
for (; b; b >>= 1, a = mul(a, a)) {
if (b & 1) r = mul(r, a);
}
return r;
}
const int N = 1e5 + 7;
long long n, d, b, a[N], s[N], pr, pl, ans1, ans2, suml, sumr, usel, user;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> n >> d >> b;
for (int i = (1); i < (n + 1); i++) cin >> a[i], s[i] = s[i - 1] + a[i];
for (int t = (1); t < (n / 2 + 1); t++) {
pr = min(n, t * d + t);
pl = max(1ll, n - t + 1 - t * d);
suml = s[pr] - s[0];
sumr = s[n] - s[pl - 1];
if (suml - usel >= b)
usel += b;
else
ans1++;
if (sumr - user >= b)
user += b;
else
ans2++;
}
cout << max(ans1, ans2);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long ret[70];
long long a, b;
long long ans = 0;
long long qpow(long long a, long long n) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * a;
a = a * a;
n /= 2;
}
return ret;
}
void solve() {
ret[0] = 1;
for (long long i = 1; i < 64; i++) {
ret[i] = ret[i - 1] + qpow(2, i);
}
}
void getans() {
for (long long i = 0; i < 64; i++) {
long long tmp = qpow(2, i);
for (long long j = i + 1; j < 64; j++) {
if (ret[j] - tmp >= a && ret[j] - tmp <= b) ans++;
}
}
}
int main() {
solve();
cin >> a >> b;
getans();
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dp[603][30003];
int mark[30003];
int N, D;
int Z = 299;
int main() {
int u;
scanf("%d %d", &N, &D);
for (int i = 0; i < N; ++i) {
scanf("%d", &u);
mark[u]++;
}
for (int i = 30000; i >= 0; --i) {
for (int k = 0; k <= 600; ++k) {
dp[k][i] = mark[i];
int cur = D + k - Z;
if (cur < 1) continue;
if (i + cur <= 30000) {
dp[k][i] = max(dp[k][i], dp[k][i + cur] + mark[i]);
}
if (i + cur + 1 <= 30000 && k != 600) {
dp[k][i] = max(dp[k][i], dp[k + 1][i + cur + 1] + mark[i]);
}
if (i + cur - 1 <= 30000 && cur != 1) {
dp[k][i] = max(dp[k][i], dp[k - 1][i + cur - 1] + mark[i]);
}
}
}
printf("%d\n", dp[Z][D]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int dem = 0, kq = 0;
;
while (getline(cin, s)) {
if (s[0] == '+')
dem++;
else {
if (s[0] == '-')
dem--;
else {
int i = 0, tam = s.length() - 1;
while (s[i] != ':') i++;
tam = tam - i;
kq += dem * tam;
}
}
}
cout << kq;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int c[5], a[1001], b[1001];
int min(int x, int cc1, int cc2) {
int d = x * cc1, e = cc2, min = 0;
if (d < e)
min = d;
else
min = e;
return min;
}
int main() {
int i, n, m;
long long int suma, sumb;
for (i = 1; i <= 4; i++) scanf("%d", &c[i]);
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) scanf("%d", &b[i]);
suma = 0;
for (i = 1; i <= n; i++) {
suma += min(a[i], c[1], c[2]);
}
sumb = 0;
for (i = 1; i <= m; i++) {
sumb += min(b[i], c[1], c[2]);
}
if (suma > c[3]) suma = c[3];
if (sumb > c[3]) sumb = c[3];
if (suma + sumb > c[4]) {
suma = c[4];
sumb = 0;
}
cout << suma + sumb << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int query(int except) {
cout << '?';
for (int i = 1; i <= k + 1; ++i)
if (i != except) cout << ' ' << i;
cout << endl;
int pos, a;
cin >> pos >> a;
return a;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
int val1 = query(1), cnt1 = 1, val2 = -1, cnt2 = 0;
for (int i = 2; i <= k + 1; ++i) {
int x = query(i);
if (x == val1)
++cnt1;
else {
if (val2 == -1) val2 = x;
if (x == val2)
++cnt2;
else
return 1;
}
}
cout << "! " << (val1 > val2 ? cnt1 : cnt2) << endl;
}
| 5 |
#include <bits/stdc++.h>
const int MAXN = 1e5 + 10;
const int INF = 1e18 + 10;
using namespace std;
int T, N, M;
long long A[MAXN], pot[35];
bool test(int x) {
long long new_A[MAXN];
new_A[N + 1] = INF;
for (int i = N; i > 0; i--) {
new_A[i] = A[i];
for (int j = x - 1; j >= 0; j--)
if (new_A[i] + pot[j] <= new_A[i + 1]) new_A[i] += pot[j];
if (new_A[i] > new_A[i + 1]) return false;
}
return true;
}
int main() {
pot[0] = 1LL;
for (int i = 1; i < 31; i++) pot[i] = pot[i - 1] << 1;
scanf("%d", &T);
while (T--) {
scanf("%d", &N);
for (int i = 1; i < N + 1; i++) scanf("%lld", &A[i]);
bool ok = true;
for (int i = 1; i < N; i++)
if (A[i] > A[i + 1]) {
ok = false;
break;
}
if (ok) {
printf("0\n");
continue;
}
int l = 1, r = 31, mid, best;
while (l <= r) {
mid = (l + r) >> 1;
if (test(mid)) {
best = mid;
r = mid - 1;
} else
l = mid + 1;
}
printf("%d\n", best);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005, M = 22000005;
int n, m, tot, ans;
int a[N], posb[N], rt[N], cnt[M], lc[M], rc[M];
void pushup(int u) { cnt[u] = cnt[lc[u]] + cnt[rc[u]]; }
void upd(int &u, int v, int l, int r, int x) {
u = ++tot;
if (l == r) {
cnt[u] = cnt[v] + 1;
return;
}
int mid = (l + r) >> 1;
if (mid >= x)
rc[u] = rc[v], upd(lc[u], lc[v], l, mid, x);
else
lc[u] = lc[v], upd(rc[u], rc[v], mid + 1, r, x);
pushup(u);
}
int qsum(int u, int v, int l, int r, int ql, int qr) {
if (l >= ql && r <= qr) return cnt[v] - cnt[u];
int mid = (l + r) >> 1, res = 0;
if (lc[v] && mid >= ql) res += qsum(lc[u], lc[v], l, mid, ql, qr);
if (rc[v] && mid < qr) res += qsum(rc[u], rc[v], mid + 1, r, ql, qr);
return res;
}
inline int f(int x) { return (x + ans) % n + 1; }
inline int input() {
int x = 0, F = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') F = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
x = x * 10 + c - '0';
c = getchar();
}
return x * F;
}
int main() {
int A, B, C, D;
n = input();
for (int i = 1; i <= n; i++) a[i] = input();
for (int i = 1; i <= n; i++) A = input(), posb[A] = i;
for (int i = 1; i <= n; i++) upd(rt[i], rt[i - 1], 1, n, posb[a[i]]);
m = input();
ans = -1;
for (int i = 1; i <= m; i++) {
A = input();
B = input();
C = input();
D = input();
A = f(A);
B = f(B);
C = f(C);
D = f(D);
if (A > B) swap(A, B);
if (C > D) swap(C, D);
printf("%d\n", ans = qsum(rt[A - 1], rt[B], 1, n, C, D));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200010, Mod = 1e9 + 9;
inline long long read() {
long long s = 0, w = 1;
register char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
return s * w;
}
long long n, A, B, K, gb, res;
char inp[N];
inline long long ksc(long long x, long long p) {
long long res = 1;
for (; p; p >>= 1, x = x * x % Mod)
if (p & 1) res = res * x % Mod;
return res;
}
signed main() {
n = read(), A = read(), B = read(), K = read();
gb = ksc(B * ksc(A, Mod - 2) % Mod, K) % Mod;
scanf("%s", inp);
for (register long long i = 0; i < K; i++) {
long long up = (inp[i] == '+') ? (1) : (-1);
long long fir = ksc(A, n - i) * ksc(B, i) % Mod;
long long m = (n - i) / K + 1;
if (gb == 1)
res = (res + up * m * fir % Mod + Mod) % Mod;
else
res = (res +
up * fir % Mod * (1 - ksc(gb, m) + Mod) % Mod *
ksc((1 - gb + Mod) % Mod, Mod - 2) % Mod +
Mod) %
Mod;
}
printf("%lld\n", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
while (cin >> n) {
cout << "25" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> tree[100005];
long long arr[100005], n;
bool col[100005];
int red[10000007], blue[10000007];
bool go(int now) {
if (tree[now].size() == 0) {
col[now] = true;
return true;
}
bool flag;
for (int i = 0; i < tree[now].size(); i++) {
flag = go(tree[now][i]);
}
col[now] = !flag;
return !flag;
}
int main() {
int i, j;
scanf("%I64d", &n);
for (i = 1; i <= n; i++) scanf("%I64d", &arr[i]);
for (i = 2; i <= n; i++) {
scanf("%d", &j);
tree[j].push_back(i);
}
go(1);
int b = 0, r = 0;
long long s = 0;
for (i = 1; i <= n; i++) {
if (col[i]) {
s ^= arr[i];
blue[arr[i]]++;
b++;
} else {
red[arr[i]]++;
r++;
}
}
long long ans = 0;
if (s == 0) {
ans = ((long long)b * (b - 1)) / 2 + ((long long)r * (r - 1)) / 2;
}
for (i = 1; i <= n; i++) {
if (col[i]) {
long long t = s ^ arr[i];
if (t > 10000000) continue;
ans += red[t];
}
}
printf("%I64d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n >> m;
while (true) {
if (n == 0 || m == 0)
break;
else if (n >= (2 * m))
n = n % (2 * m);
else if (m >= (2 * n))
m = m % (2 * n);
else
break;
}
cout << n << " " << m << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
template <class T>
void out(map<char, T> &a, string s = "(%3c ->%3d)") {
for (auto(it) = (a).begin(); (it) != (a).end(); ++(it))
printf(s.c_str(), it->first, it->second);
printf("\n");
}
template <class T>
void out(vector<T> &a, string s = "%3d ") {
int i, n = a.size();
for ((i) = 0; (i) < (n); (i)++) printf(s.c_str(), a[i]);
printf("\n");
}
template <class T>
void out(T *a, int n, string s = "%3d ") {
int i;
for ((i) = 0; (i) < (n); (i)++) printf(s.c_str(), a[i]);
printf("\n");
}
long long i, j, N, M, n, m, k, p;
int MainSolve(string args = "") {
cout << args;
long long ii, jj, a, b;
cin >> n >> m >> ii >> jj >> a >> b;
long long ans[4];
int k = 0;
auto do_it = [&](long long ii, long long jj, long long k1, long long k2) {
long long ti = abs(ii - k1), tj = abs(jj - k2);
if ((ti + tj == 0) || (ti % a == 0 && tj % b == 0 &&
((ti / a + tj / b + 1) & 1) && n > a && m > b))
ans[k++] = max(ti / a, tj / b);
else
ans[k++] = n * m + 1;
};
do_it(ii, jj, 1, 1);
do_it(ii, jj, 1, m);
do_it(ii, jj, n, 1);
do_it(ii, jj, n, m);
long long mn = ans[0];
for ((i) = 0; (i) < (4); (i)++) mn = min(ans[i], mn);
if (mn > n * m)
cout << "Poor Inna and pony!" << endl;
else
cout << mn << endl;
return 0;
}
string ReadAllLines(char *fileName) {
string s = "";
const int NMAX = 1000;
char buf[NMAX];
buf[0] = 0;
FILE *f = fopen(fileName, "r");
while (fgets(buf, NMAX, f)) s = s + string(buf);
return string(s.begin(), find_if(s.rbegin(), s.rend(), [](char c) {
return c != '\n' && c != '\r' && c != '\t' &&
c != ' ';
}).base());
}
int main() {
MainSolve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
int ans = a + a + b + b;
ans = min(ans, a + b + c);
ans = min(a + c + c + a, ans);
ans = min(b + c + c + b, ans);
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k, p;
cin >> n >> m >> k >> p;
vector<vector<long long> > array(n, vector<long long>(m, 0));
vector<long long> rowSum(n, 0);
vector<long long> colSum(m, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> array[i][j];
rowSum[i] += array[i][j];
colSum[j] += array[i][j];
}
}
long long arbitIndex = 0;
set<pair<long long, long long> > open;
for (int i = 0; i < n; i++) open.insert(make_pair(-rowSum[i], arbitIndex++));
vector<long long> rowSumTill(k + 1, 0);
vector<long long> colSumTill(k + 1, 0);
int rowIndex = 1;
while (rowIndex <= k) {
long long num = -(open.begin()->first);
open.erase(open.begin());
rowSumTill[rowIndex] = rowSumTill[rowIndex - 1] + num;
rowIndex++;
open.insert(make_pair(-(num - p * m), arbitIndex++));
}
open.clear();
for (int i = 0; i < m; i++) open.insert(make_pair(-colSum[i], arbitIndex++));
int colIndex = 1;
while (colIndex <= k) {
long long num = -(open.begin()->first);
open.erase(open.begin());
colSumTill[colIndex] = colSumTill[colIndex - 1] + num;
colIndex++;
open.insert(make_pair(-(num - p * n), arbitIndex++));
}
long long M = -1e15;
for (int i = 0; i <= k; i++) {
long long total = 0;
total = rowSumTill[i];
total += colSumTill[k - i];
total -= p * i * (k - i);
M = max(M, total);
}
cout << M << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main(void) {
int t, h, m;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &h, &m);
printf("%d\n", (23 - h) * 60 + (60 - m));
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ar[200005], ans[200005], pos[200005];
char ch[200005];
int n, m, ii, k;
vector<pair<int, int>> g[200005];
vector<int> divi[200005];
int Tree[200005 * 4];
void update(int node, int be, int en, int id, int val) {
if (id > en || id < be) return;
if (be == en) {
Tree[node]++;
return;
}
int mid = (be + en) / 2;
update(node * 2, be, mid, id, val);
update(node * 2 + 1, mid + 1, en, id, val);
Tree[node] = Tree[node * 2] + Tree[node * 2 + 1];
}
int query(int node, int be, int en, int i, int j) {
if (i > en || j < be) return 0;
if (i <= be && j >= en) return Tree[node];
int mid = (be + en) / 2;
return query(node * 2, be, mid, i, j) +
query(node * 2 + 1, mid + 1, en, i, j);
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &ar[i]), pos[ar[i]] = i;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[y].push_back({x, i});
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
int x = pos[i], y = pos[j];
divi[max(x, y)].push_back(min(x, y));
}
}
for (int i = 1; i <= n; i++) {
for (int v : divi[i]) {
update(1, 1, n, v, 1);
}
for (auto it : g[i]) {
ans[it.second] = query(1, 1, n, it.first, i);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> G[5010];
int ans[5010];
int dist(int a, int b) {
if (a == b) return 0;
if (a < b) return b - a;
return b - a + n;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d %d", &a, &b);
G[a].push_back(b);
}
for (int i = 1; i <= n; i++) {
sort(G[i].begin(), G[i].end(),
[i](int a, int b) { return dist(i, a) < dist(i, b); });
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (G[j].size()) {
ans[i] = max(
ans[i], dist(i, j) + n * ((int)G[j].size() - 1) + dist(j, G[j][0]));
}
}
}
for (int i = 1; i <= n; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
bool operator<(const node& p) const { return x < p.x; }
};
vector<int> vc[200000], cost[200000];
long long parent[200000], vis[200000], ma = 0, add = 0, ans, mainsum = 0;
void dfs(int v, int par, long long sum) {
parent[v] = par;
if (sum > ma) {
ans = v;
ma = sum;
}
for (int i = 0; i < vc[v].size(); i++) {
int w = vc[v][i];
if (w == par) continue;
dfs(w, v, cost[v][i] + sum);
mainsum += (cost[v][i] * 2);
}
}
int main() {
int i, j, k, l, m, n;
long long sum = 0;
scanf("%d", &n);
for (i = 1; i < n; i++) {
scanf("%d%d%d", &k, &l, &j);
vc[k].push_back(l);
cost[k].push_back(j);
vc[l].push_back(k);
cost[l].push_back(j);
}
dfs(1, -1, 0);
sum += ma;
mainsum -= (ma);
printf("%lld\n", mainsum);
}
| 5 |
#include <bits/stdc++.h>
template <typename T>
bool chkmin(T &a, T b) {
return (b < a) ? a = b, 1 : 0;
}
template <typename T>
bool chkmax(T &a, T b) {
return (b > a) ? a = b, 1 : 0;
}
long long ksm(long long a, long long b) {
if (b == 0) return 1;
long long ns = ksm(a, b >> 1);
ns = ns * ns % 1000000007;
if (b & 1) ns = ns * a % 1000000007;
return ns;
}
using namespace std;
const int maxn = 2005;
char s[maxn][maxn];
int nr[maxn][maxn];
long long ans = 0;
int st[maxn];
int sqr(int a) { return a * a; }
vector<int> calc(vector<int> a) {
auto chk = [&](int i, int j) { return a[i] + 1ll * (j - i) * (j - i); };
auto ins = [&](int i, int j, int k) {
long long cur = 1ll * (j - i) * (a[k] + sqr(k) - a[j] - sqr(j)) -
1ll * (k - j) * (a[j] + sqr(j) - a[i] - sqr(i));
return cur;
};
int fr = 0, ed = 0;
vector<int> res(a.size());
for (int i = 0; i < a.size(); i++) {
while (ed - fr >= 2 && ins(st[ed - 2], st[ed - 1], i) <= 0) ed--;
st[ed++] = i;
while (ed - fr >= 2 && chk(st[fr + 1], i) <= chk(st[fr], i)) fr++;
res[i] = chk(st[fr], i);
}
return res;
}
void upd(vector<int> a) {
vector<int> t = calc(a);
reverse(a.begin(), a.end());
vector<int> s = calc(a);
reverse(s.begin(), s.end());
for (int i = 0; i < t.size(); i++) {
chkmin(t[i], s[i]);
ans += t[i];
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i <= n; i++) {
scanf("%s", s[i]);
for (int j = 0; j <= m; j++) {
if (s[i][j] == '0')
nr[i][j] = maxn * 2;
else
nr[i][j] = 0;
}
}
for (int i = 0; i <= n; i++) {
for (int j = 1; j <= m; j++) chkmin(nr[i][j], nr[i][j - 1] + 1);
for (int j = m - 1; j >= 0; j--) chkmin(nr[i][j], nr[i][j + 1] + 1);
}
for (int j = 0; j <= m; j++) {
vector<int> cur(n + 1);
for (int i = 0; i <= n; i++) cur[i] = 1ll * nr[i][j] * nr[i][j];
upd(cur);
}
cout << ans << endl;
return (0 - 0);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
long long X, Y;
int i;
pt(long long a = 0, long long b = 0, int c = 0) : X(a), Y(b), i(c) {}
bool operator==(const pt& p) const {
return make_pair(X, Y) == make_pair(p.X, p.Y);
}
bool operator<(const pt& p) const {
return make_pair(X, Y) < make_pair(p.X, p.Y);
}
};
pt operator-(const pt& a, const pt& b) { return pt(a.X - b.X, a.Y - b.Y); }
long long operator^(const pt& a, const pt& b) { return a.X * b.Y - b.X * a.Y; }
long long cross(pt o, pt a, pt b) { return (a - o) ^ (b - o); }
vector<pt> convex_hull(vector<pt> v) {
int n = v.size();
if (n <= 2) return v;
vector<pt> st(2 * n);
int tp = 0;
for (int i = 0; i < n; ++i) {
while (tp >= 2 && cross(st[tp - 2], st[tp - 1], v[i]) <= 0) --tp;
st[tp++] = v[i];
}
for (int i = n - 2, t = tp + 1; i >= 0; --i) {
while (tp >= t && cross(st[tp - 2], st[tp - 1], v[i]) <= 0) --tp;
st[tp++] = v[i];
}
st.resize(tp - 1);
return st;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<pt> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i].X >> v[i].Y;
v[i].i = i + 1;
}
string s;
cin >> s;
sort(begin(v), end(v));
vector<pt> ans = {v[0]};
for (char c : s) {
auto hull = convex_hull(v);
pt tdd = ans.back();
rotate(begin(hull), find(begin(hull), end(hull), tdd), end(hull));
if (c == 'L')
ans.push_back(hull[1]);
else
ans.push_back(hull.back());
v.erase(find(begin(v), end(v), tdd));
}
assert(v.size() == 2);
v.erase(find(begin(v), end(v), ans.back()));
ans.push_back(v[0]);
for (auto ilovetdd : ans) cout << ilovetdd.i << ' ';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
int t;
cin >> t;
while (t--) {
cin >> n >> m;
int tong = 0;
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
tong += 1LL * a;
}
if (tong == m)
cout << "YES";
else
cout << "NO";
cout << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n, flag = 0, f = 0;
cin >> n;
vector<long long> v;
for (int j = 0; j < n; j++) {
long long a;
cin >> a;
v.push_back(a);
}
for (int j = 0; j <= n / 2; j++) {
if (v[j] < j) {
flag = 1;
}
}
int c = 0;
for (int j = v.size() - 1; j > n / 2; j--) {
if (v[j] < c) {
flag = 1;
}
c++;
}
for (int j = 0; j < n / 2 - 1; j++) {
if (v[j] < j) {
f = 1;
}
}
c = 0;
for (int j = v.size() - 1; j >= n / 2 - 1; j--) {
if (v[j] < c) {
f = 1;
}
c++;
}
if (flag == 1 && f == 1) {
cout << "No" << endl;
}
if (flag == 0 || f == 0) {
cout << "Yes" << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, mod = 1000000007;
struct _two {
int a, b;
} edge[N * 4];
struct _three {
int a, b, c;
} To[N * 4];
int n, tot;
int st[N + N], indeer[N + N], qu[N * 4];
int f[N * 4], s[N * 4];
void Init() {
scanf("%d", &n);
int x, y;
tot = 1;
n += n;
for (int i = 1; i <= n - 1; i++) {
scanf("%d%d", &x, &y);
indeer[x]++;
indeer[y]++;
edge[++tot] = (_two){y, st[x]};
st[x] = tot;
edge[++tot] = (_two){x, st[y]};
st[y] = tot;
}
}
void Calc_s(int x) {
if (s[x]) return;
s[x] = 1;
for (int i = st[edge[x].a]; i; i = edge[i].b)
if (i != (x ^ 1)) {
Calc_s(i);
s[x] += s[i];
}
}
int Next(int x) {
for (int i = st[edge[x].a]; i; i = edge[i].b)
if ((i ^ 1) != x) return i;
}
void dfs(int x);
int Calc(int p1, int p2) {
_three t1 = To[p1], t2 = To[p2];
int ret = 0;
if (!t1.b && !t2.b && t1.a == t2.a) ret++;
if (!t1.b && t2.a > t1.a) {
int px = qu[To[p2].c + t1.a];
dfs(px);
ret = (ret + f[px]) % mod;
}
if (!t2.b && t1.a > t2.a) {
int px = qu[To[p1].c + t2.a];
dfs(px);
ret = (ret + f[px]) % mod;
}
return ret;
}
void dfs(int x) {
if (f[x] != -1) return;
f[x] = 0;
if (s[x] & 1) return;
if (indeer[edge[x].a] == 2) {
int i = Next(x);
if (!To[i].b) {
f[x] = (f[x] + s[x] / 2) % mod;
} else {
bool flag = 0;
_three t1, t2;
int p1, p2;
for (int j = st[edge[To[i].b].a]; j; j = edge[j].b)
if ((j ^ 1) != To[i].b) {
if (flag) {
t1 = To[j];
p1 = j;
} else {
t2 = To[j];
p2 = j;
flag = 1;
}
}
if (!t1.b) {
if (((To[i].a - t1.a) > 0 ? (To[i].a - t1.a) : -(To[i].a - t1.a)) ==
1) {
dfs(p2);
f[x] = (f[x] + f[p2]) % mod;
}
} else if (t1.a == 1 && indeer[edge[t1.b].a] == 3) {
int pp1, pp2;
bool flag = 0;
for (int j = st[edge[t1.b].a]; j; j = edge[j].b)
if ((j ^ 1) != t1.b)
if (flag)
pp1 = j;
else {
pp2 = j;
flag = 1;
}
if (To[pp1].a == To[i].a && !To[pp1].b)
f[x] = (f[x] + Calc(pp2, p2)) % mod;
if (To[pp2].a == To[i].a && !To[pp2].b)
f[x] = (f[x] + Calc(pp1, p2)) % mod;
}
if (!t2.b) {
if (((To[i].a - t2.a) > 0 ? (To[i].a - t2.a) : -(To[i].a - t2.a)) ==
1) {
dfs(p1);
f[x] = (f[x] + f[p1]) % mod;
}
} else if (t2.a == 1 && indeer[edge[t2.b].a] == 3) {
int pp1, pp2;
bool flag = 0;
for (int j = st[edge[t2.b].a]; j; j = edge[j].b)
if ((j ^ 1) != t2.b)
if (flag)
pp1 = j;
else {
pp2 = j;
flag = 1;
}
if (To[pp1].a == To[i].a && !To[pp1].b)
f[x] = (f[x] + Calc(pp2, p1)) % mod;
if (To[pp2].a == To[i].a && !To[pp2].b)
f[x] = (f[x] + Calc(pp1, p1)) % mod;
}
if (To[i].a > 1) {
int j = Next(i);
dfs(j);
f[x] = (f[x] + f[j]) % mod;
}
}
} else {
bool flag = 0;
int p1, p2;
for (int i = st[edge[x].a]; i; i = edge[i].b)
if ((i ^ 1) != x)
if (flag)
p1 = i;
else {
p2 = i;
flag = 1;
}
if (indeer[edge[p1].a] == 1) {
dfs(p2);
f[x] = (f[x] + f[p2]) % mod;
} else if (indeer[edge[p1].a] == 2)
f[x] = (f[x] + Calc(Next(p1), p2)) % mod;
if (indeer[edge[p2].a] == 1) {
dfs(p1);
f[x] = (f[x] + f[p1]) % mod;
} else if (indeer[edge[p2].a] == 2)
f[x] = (f[x] + Calc(Next(p2), p1)) % mod;
}
}
void Find(int x) {
qu[To[x].c = ++tot] = x;
if (indeer[edge[x].a] == 1) {
To[x].a = 1;
To[x].b = 0;
}
if (indeer[edge[x].a] == 3) {
To[x].a = 1;
To[x].b = x;
}
if (indeer[edge[x].a] == 2) {
int i = Next(x);
Find(i);
To[x].a = To[i].a + 1;
To[x].b = To[i].b;
}
}
void Work() {
for (int i = 1; i <= n; i++)
if (indeer[i] > 3) {
puts("0");
return;
}
tot = 0;
for (int i = 1; i <= n; i++)
if (indeer[i] != 2)
for (int j = st[i]; j; j = edge[j].b) Find(j);
int ans = 0;
memset(f, -1, sizeof(f));
for (int i = 1; i <= n; i++)
if (indeer[i] < 3) {
f[1] = -1;
edge[1].a = i;
s[1] = 0;
indeer[i]++;
Calc_s(1);
dfs(1);
indeer[i]--;
ans = (ans + f[1]) % mod;
}
printf("%d\n", ans);
}
int main() {
Init();
Work();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
const int M = 3e5 + 7;
long long mod = (long long)1e9 + 7;
int T, n, m;
string s, t, p;
int main() {
ios::sync_with_stdio(false);
cin >> T;
while (T--) {
cin >> s >> t >> p;
int id = 0, ls = s.length();
for (int i = 0; i < t.length(); ++i) {
if (id < ls) {
if (t[i] == s[id]) {
++id;
}
}
}
if (id != ls) {
cout << "NO" << endl;
continue;
}
map<char, int> g1;
map<char, int> g2;
for (int i = 0; i < ls; ++i) ++g1[s[i]];
for (int i = 0; i < t.length(); ++i) ++g2[t[i]];
for (int i = 0; i < p.length(); ++i) ++g1[p[i]];
int ok = true;
for (auto iter = g2.begin(); iter != g2.end(); ++iter) {
int sz = iter->second;
char c = iter->first;
if (g1[c] < sz) {
ok = 0;
}
}
cout << (ok ? "YES" : "NO") << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int r, c, k;
string s[501];
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
bool valid(int x, int y) {
if (x < 0 || y < 0 || x >= r || y >= c) return 0;
return 1;
}
void dfs(int x, int y) {
if (k == 0) return;
for (int i = 0; i < 4; i++) {
int X = x + dx[i];
int Y = y + dy[i];
if (!valid(X, Y)) continue;
if (s[X][Y] == '.') {
k--;
s[X][Y] = 'X';
dfs(X, Y);
}
if (k == 0) return;
}
}
int main() {
cin >> r >> c >> k;
int x, y;
int cnt = 0;
for (int i = 0; i < r; i++) {
cin >> s[i];
for (int j = 0; j < c; j++) {
if (s[i][j] == '.') {
x = i, y = j;
cnt++;
}
}
}
k = cnt - k;
k--;
s[x][y] = 'X';
dfs(x, y);
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (s[i][j] == 'X')
s[i][j] = '.';
else if (s[i][j] == '.')
s[i][j] = 'X';
cout << s[i][j];
}
cout << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
void dout() { cerr << endl; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << H << ' ';
dout(T...);
}
vector<int> primes;
const int maxN = 1e4 + 47;
bool is_prime[maxN];
void sieve() {
for (int i = 2; i < maxN; i++) {
is_prime[i] = true;
}
for (int i = 2; i < maxN; i++) {
if (is_prime[i]) {
primes.push_back(i);
for (int j = i + i; j < maxN; j += i) {
is_prime[j] = false;
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
sieve();
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<vector<int>> odd(n);
vector<int> prod(n, 1);
for (int i = 0; i < n; i++) {
int x = a[i];
if (x == 0) {
continue;
}
for (auto p : primes) {
while (x % p == 0) {
if (((int)odd[i].size()) && odd[i].back() == p)
odd[i].pop_back();
else
odd[i].push_back(p);
x /= p;
}
if (abs(x) == 1) break;
}
if (abs(x) != 1) {
odd[i].push_back(abs(x));
}
if (x < 0) odd[i].push_back(-1);
for (auto p : odd[i]) {
prod[i] *= p;
}
}
vector<int> ans(n);
unordered_set<int> used;
used.reserve(4096);
used.max_load_factor(0.25);
for (int l = 0; l < n; l++) {
used.clear();
for (int r = l; r < n; r++) {
if (a[r] != 0) used.insert(prod[r]);
ans[max(0, ((int)used.size()) - 1)]++;
}
}
for (auto x : ans) {
cout << x << " ";
}
cout << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int main() {
int n;
cin >> n;
a.resize(n);
for (int i = 0; i < (n); ++i) a[i] = i + 1;
for (int i = 0; i < (n / 2); ++i) swap(a[n - 1 - 2 * i], a[n - 2 - 2 * i]);
for (int i = 0; i < (n); ++i) cout << a[i] << (i + 1 == n ? '\n' : ' ');
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int p;
string place(int x, int y) {
printf("%d %d\n", x, p = y);
string s;
cin >> s;
return s;
}
bool patrol(int i) {
for (int j = p == 1 ? 2 : 1; j <= 8; j++) {
string s = place(i, j);
if (s == "Done") return 1;
if (s[0] == 'D') return 0;
if (s[0] == 'U') return patrol(i);
}
return 0;
}
void mein() {
for (int i = p = 1; i <= 8; i++)
if (place(i, p) == "Done" || patrol(i)) return;
}
int main() {
int T;
for (scanf("%d", &T); T--;) mein();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
bool check(int x, int y) {
if (y < x - 1 || y > 2 * (x + 1)) return 0;
return 1;
}
int main() {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
if (check(a, d) || check(b, c))
puts("YES");
else
puts("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 1;
int p[N];
set<int> s[N];
int get(int pos) { return p[pos] = p[pos] == pos ? pos : get(p[pos]); }
void merge(int a, int b) {
a = get(a), b = get(b);
if (a == b) return;
if (s[b].size() < s[a].size()) swap(a, b);
p[a] = b;
for (int i : s[a]) s[b].insert(i);
}
void init() {
for (int i = 0; i < N; i++) p[i] = i;
}
int idx, n;
map<pair<int, int>, int> has;
void add() {
int a, b, c;
cin >> a >> b >> c;
s[get(a)].insert(b);
s[get(b)].insert(a);
if (has[{a, c}])
merge(has[{a, c}], b);
else
merge(has[{a, c}] = idx++, b);
if (has[{b, c}])
merge(has[{b, c}], a);
else
merge(has[{b, c}] = idx++, a);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
init();
int m, c, q;
cin >> n >> m >> c >> q;
idx = n + 1;
for (int i = 0; i < m; i++) add();
for (int i = 0; i < q; i++) {
char mode;
cin >> mode;
if (mode == '+')
add();
else {
int a, b;
cin >> a >> b;
if (get(a) == get(b) or s[get(a)].find(b) != s[get(a)].end())
cout << "Yes\n";
else
cout << "No\n";
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10;
const long long mod = 998244353;
const double eps = 1e-7;
long long n, m, k, x;
long long dp[510][510];
long long c[510][510];
long long qsm(long long a, long long b) {
long long ans = 1, temp = a;
while (b) {
if (b & 1) ans = (ans * temp) % mod;
temp = (temp * temp) % mod;
b >>= 1;
}
return ans;
}
long long C(long long n, long long m) { return c[n][m]; }
void solve() {
for (long long i = (1); i <= (x); i++) dp[1][i] = i;
for (long long i = (2); i <= (n); i++) {
for (long long j = (1); j <= (x); j++) {
if (i <= j)
for (long long k = (0); k <= (i - 1); k++)
dp[i][j] +=
dp[i - k][j - i + 1] * qsm(i - 1, k) % mod * C(i, k) % mod,
dp[i][j] %= mod;
}
}
long long ans = (qsm(x, n) - dp[n][x] + mod) % mod;
cout << ans << "\n";
}
signed main() {
ios::sync_with_stdio(false), cin.tie(0);
for (long long i = (0); i <= (500); i++) c[i][0] = 1;
for (long long i = (1); i <= (500); i++) {
for (long long j = (1); j <= (i); j++) {
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
}
}
cin >> n >> x;
solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, x, y, d;
scanf("%d %d %d %d", &n, &x, &y, &d);
int a = abs(x - y);
int ans = INT_MAX;
if (a % d == 0) {
ans = a / d;
} else {
int b = INT_MAX, c = INT_MAX;
if (((y - 1) % d == 0)) {
b = ceil((double)(x - 1) / d) + (y - 1) / d;
}
if ((n - y) % d == 0) {
c = ceil((double)(n - x) / d) + (n - y) / d;
}
ans = min(b, c);
}
if (ans != INT_MAX) {
printf("%d\n", ans);
} else {
printf("-1\n");
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> a;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
a.push_back(x);
}
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
a[i] = x - a[i];
}
sort(a.begin(), a.end());
int beg = 0;
int end = n - 1;
long long result = 0;
while (end > beg) {
if (a[end] + a[beg] < 0) {
result += end - beg;
beg++;
} else {
end--;
}
}
cout << result;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
unsigned int mod = 4294967296;
unsigned int opt[201000];
int top = 0;
int main() {
cin >> n >> s;
if (n & 1) {
printf("0\n");
return 0;
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] != '?') cnt++;
}
opt[top++] = 1;
for (int i = n - 1; top > 0 && i >= 0; --i) {
if (s[i] == '?') {
opt[top++] = 0;
for (int z = top - 1 - ((top & 1) ? 0 : 1); z >= 2; z -= 2) {
opt[z] = opt[z] + opt[z - 2];
}
} else {
--top;
}
}
if (top <= 0) {
cout << 0 << endl;
return 0;
}
int p = (n >> 1) - cnt;
unsigned int ans = opt[top - 1];
for (int i = 0; i < p; i++) {
ans = (ans * 25);
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T min(T &a, T &b) {
return a < b ? a : b;
}
template <class T>
inline T max(T &a, T &b) {
return a > b ? a : b;
}
inline void read(int &x) {
char ch;
while ((ch = getchar()) && !(ch >= '0' && ch <= '9'))
;
x = ch - '0';
while ((ch = getchar()) && (ch >= '0' && ch <= '9')) x = x * 10 + ch - '0';
}
struct point {
int x, y;
point() {}
point(int _x, int _y) : x(_x), y(_y) {}
};
const int Mod = 1000000009;
const int N = 500000;
int n, m, W[N];
pair<int, int> val[N], sum[N];
struct lj {
int l, r, f1, f2, c;
} t[N << 2];
int Chen(int x, int y) {
return int((long long)x * (long long)y % (long long)Mod);
}
int ADD(int x, int y) { return (x + y) % Mod; }
void build(int w, int l, int r) {
t[w].l = l;
t[w].r = r;
if (l == r) {
t[w].c = W[l];
return;
}
int mid = l + r >> 1;
build(w << 1, l, mid);
build(w << 1 | 1, mid + 1, r);
t[w].c = ADD(t[w << 1].c, t[w << 1 | 1].c);
}
void push(int w) {
if (t[w].f1 || t[w].f2) {
int l = w << 1;
t[l].f1 = ADD(t[l].f1, t[w].f1);
t[l].f2 = ADD(t[l].f2, t[w].f2);
pair<int, int> c = sum[t[l].r - t[l].l + 1];
t[l].c = ADD(ADD(Chen(c.first, t[w].f1), Chen(c.second, t[w].f2)), t[l].c);
int mid = t[w].l + t[w].r >> 1;
l |= 1;
int d, e;
d = ADD(Chen(val[mid - t[w].l + 2].first, t[w].f1),
Chen(val[mid - t[w].l + 2].second, t[w].f2));
e = ADD(Chen(val[mid - t[w].l + 3].first, t[w].f1),
Chen(val[mid - t[w].l + 3].second, t[w].f2));
t[l].f1 = ADD(t[l].f1, d);
t[l].f2 = ADD(t[l].f2, e);
c = sum[t[l].r - t[l].l + 1];
t[l].c = ADD(ADD(Chen(c.first, d), Chen(c.second, e)), t[l].c);
t[w].f1 = t[w].f2 = 0;
}
}
void change(int w, int l, int r, int p, int q) {
if (t[w].l == l && t[w].r == r) {
pair<int, int> c = sum[r - l + 1];
t[w].c = ADD(t[w].c, ADD(Chen(c.first, p), Chen(c.second, q)));
t[w].f1 = ADD(t[w].f1, p);
t[w].f2 = ADD(t[w].f2, q);
return;
}
push(w);
int mid = t[w].l + t[w].r >> 1;
if (r <= mid)
change(w << 1, l, r, p, q);
else if (l > mid)
change(w << 1 | 1, l, r, p, q);
else {
change(w << 1, l, mid, p, q);
int d, e;
d = ADD(Chen(val[mid - l + 2].first, p), Chen(val[mid - l + 2].second, q));
e = ADD(Chen(val[mid - l + 3].first, p), Chen(val[mid - l + 3].second, q));
change(w << 1 | 1, mid + 1, r, d, e);
}
t[w].c = ADD(t[w << 1].c, t[w << 1 | 1].c);
}
int ask(int w, int l, int r) {
if (t[w].l == l && t[w].r == r) return t[w].c;
push(w);
int mid = t[w].l + t[w].r >> 1;
if (r <= mid)
return ask(w << 1, l, r);
else if (l > mid)
return ask(w << 1 | 1, l, r);
else
return ADD(ask(w << 1, l, mid), ask(w << 1 | 1, mid + 1, r));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &W[i]);
sum[1] = make_pair(1, 0);
sum[2] = make_pair(1, 1);
val[1] = make_pair(1, 0);
val[2] = make_pair(0, 1);
for (int i = 3; i <= n; i++)
val[i] = make_pair(ADD(val[i - 1].first, val[i - 2].first),
ADD(val[i - 1].second, val[i - 2].second)),
sum[i] = make_pair(ADD(val[i].first, sum[i - 1].first),
ADD(val[i].second, sum[i - 1].second));
build(1, 1, n);
int ty, x, y;
for (int i = 1; i <= m; i++) {
scanf("%d", &ty);
if (ty == 1) {
scanf("%d%d", &x, &y);
change(1, x, y, 1, 1);
}
if (ty == 2) {
scanf("%d%d", &x, &y);
printf("%d\n", ask(1, x, y));
}
}
}
| 8 |
#include <bits/stdc++.h>
using std::deque;
using std::make_pair;
using std::map;
using std::max;
using std::min;
using std::pair;
using std::set;
using std::string;
using std::vector;
constexpr long long magic_mod = 998244353;
long long m_pluss(long long a, long long b) { return (a + b) % magic_mod; }
long long m_mul(long long a, long long b) { return (a * b) % magic_mod; }
int main() {
double pi = 3.14159265358979323846264338;
double n, r;
scanf("%lf%lf", &n, &r);
double a = pi / n;
double r1 = r * std::sin(a) / (1.0 - std::sin(a));
printf("%.10lf\n", r1);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int flag[1003], ans[1003];
int main() {
int n, k, a, b, c, d;
scanf("%d%d%d%d%d%d", &n, &k, &a, &b, &c, &d);
if (k < n + 1 || n == 4) {
printf("-1\n");
return 0;
}
flag[a] = flag[b] = flag[c] = flag[d] = 1;
ans[0] = a;
ans[1] = c;
ans[n - 2] = d;
ans[n - 1] = b;
int res = 2;
for (int i = 1; i <= n; i++) {
if (!flag[i]) {
flag[i] = 1;
ans[res++] = i;
}
}
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
printf("\n");
swap(ans[0], ans[1]);
swap(ans[n - 1], ans[n - 2]);
for (int i = 0; i < n; i++) printf("%d ", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a[100];
cin >> n;
int temp = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i] < a[j]) {
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
}
int flag = 0, secMin = 0;
for (int i = 0; i < n; i++) {
if (i + 1 < n) {
if (a[i] != a[i + 1]) {
flag = 1;
secMin = a[i + 1];
break;
}
}
}
if (flag == 1)
cout << secMin;
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n;
cin >> n;
vector<long double> probs(n);
for (i = 0; i < n; i++) {
cin >> probs[i];
}
sort(probs.begin(), probs.end());
reverse(probs.begin(), probs.end());
long double prob0 = 1;
long double prob1 = 0.;
for (i = 0; i < n; i++) {
long double p = prob1;
p = probs[i] * prob0 + p * (1 - probs[i]);
if (p > prob1) {
prob1 = p;
prob0 = (1 - probs[i]) * prob0;
}
}
printf("%.9lf", double(prob1 + 0.0000000001));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 1;
int y, n, r, f[N];
int main() {
for (scanf("%d", &n); n--;) {
register int x;
scanf("%d%d", &x, &y);
register int* a = std::lower_bound(f + 1, f + r + 1, y);
if (a - f > r) ++r, f[r] = 2e9;
for (register int i = 4000; a-- > f && --i;)
if (*a >= x)
*(a + 1) = *a + 1;
else
break;
if (*a<x&&*(a + 1)> x) *(a + 1) = x;
}
printf("%d", r);
}
| 10 |
#include <iostream>
#include <vector>
#include <set>
#include <math.h>
#include <map>
#include <algorithm>
#include <string>
using namespace std;
void tree(int n) {
int nn = pow(2, int(log2(n) + 2)) - 1;
vector<int> tree(nn);
for (int i = nn - n; i < nn; ++i) {
cin >> tree[i];
}
for (int i = nn / 2 - 1; i >= 0; --i) {
tree[i] = tree[i * 2 + 1] + tree[i * 2 + 2];
}
int cnt = 0;
int step = 2;
for (int i = 0; i < nn; ++i) {
cout << tree[i] << '\t';
++cnt;
if (cnt + 1 == step) {
cout << '\n';
step *= 2;
}
}
}
void solve() {
int n;
cin >> n;
int last_ind = 0;
vector<int> v(n);
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
if (v[i] > v[last_ind]) {
last_ind = i;
}
a[i] = last_ind;
}
int cnt = n - 1;
uint64_t ans = 0;
while (cnt >= 0) {
for (int b = a[cnt]; b <= cnt; ++b) {
cout << v[b] << " ";
}
cnt = a[cnt] - 1;
}
cout << '\n';
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
solve();
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int nMAX = 100000 + 5;
const int NMAX = 2 * nMAX;
int n, m;
string S, T;
int Q;
int N;
string str;
const int MOD[] = {1000000000 + 7, 1000000000 + 9};
struct Hash {
int h[sizeof(MOD) / sizeof(int)];
Hash() {
for (int i = 0; i < sizeof(MOD) / sizeof(int); ++i) h[i] = 0;
}
Hash(int v0, int v1) { h[0] = v0, h[1] = v1; }
Hash operator+(const Hash &hs) const {
Hash res;
for (int i = 0; i < sizeof(MOD) / sizeof(int); ++i) {
res.h[i] = h[i] + hs.h[i];
if (res.h[i] >= MOD[i]) res.h[i] -= MOD[i];
}
return res;
}
Hash operator-(const Hash &hs) const {
Hash res;
for (int i = 0; i < sizeof(MOD) / sizeof(int); ++i) {
res.h[i] = h[i] - hs.h[i];
if (res.h[i] < 0) res.h[i] += MOD[i];
}
return res;
}
Hash operator*(const Hash &hs) const {
Hash res;
for (int i = 0; i < sizeof(MOD) / sizeof(int); ++i)
res.h[i] = (1LL * h[i] * hs.h[i]) % MOD[i];
return res;
}
bool operator==(const Hash &hs) const {
for (int i = 0; i < sizeof(MOD) / sizeof(int); ++i)
if (h[i] != hs.h[i]) return false;
return true;
}
bool operator!=(const Hash &hs) const {
for (int i = 0; i < sizeof(MOD) / sizeof(int); ++i)
if (h[i] != hs.h[i]) return true;
return false;
}
};
const Hash C = {666013, 666017};
Hash powC[NMAX];
Hash sPart[NMAX];
void precomputeHashes() {
powC[0] = Hash(1, 1);
for (int i = 1; i <= N; ++i) powC[i] = powC[i - 1] * C;
for (int i = 1; i <= N; ++i)
sPart[i] = sPart[i - 1] * C + Hash(str[i], str[i]);
}
Hash getHashS(int l, int r) {
Hash hr = sPart[r];
Hash hl = sPart[l - 1];
return hr - hl * powC[r - l + 1];
}
Hash getHashT(int l, int r) {
Hash hr = sPart[r + n + 1];
Hash hl = sPart[l - 1 + n + 1];
return hr - hl * powC[r - l + 1];
}
bool lcp(int l, int r) {
int st = 1;
int dr = min(N - l + 1, N - r + 1);
int ans = 0;
while (st <= dr) {
int mid = (st + dr) >> 1;
if (getHashS(l, l + mid - 1) == getHashS(r, r + mid - 1)) {
ans = mid;
st = mid + 1;
} else
dr = mid - 1;
}
return str[l + ans] < str[r + ans];
}
int lcpSS(int l, int r) { return lcp(l, r); }
int lcpST(int l, int r) { return lcp(l, r + n + 1); }
int lcpTS(int l, int r) { return lcp(l + n + 1, r); }
int lcpTT(int l, int r) { return lcp(l + n + 1, r + n + 1); }
bool cmpPlacement(const int &_a, const int &_b) {
int a = _a + 1, b = _b + 1;
bool rev = false;
if (b < a) {
swap(a, b);
rev = true;
}
if (b <= a + m) {
if (getHashT(1, b - a) != getHashS(a, b - 1))
return lcpTS(1, a) ^ rev;
else if (getHashT(b - a + 1, m) != getHashT(1, a + m - b))
return lcpTT(b - a + 1, 1) ^ rev;
else if (getHashS(a, b - 1) != getHashT(a + m - b + 1, m)) {
return lcpST(a, a + m - b + 1) ^ rev;
}
} else {
if (getHashT(1, m) != getHashS(a, a + m - 1))
return lcpTS(1, a) ^ rev;
else if (getHashS(a, b - m - 1) != getHashS(a + m, b - 1)) {
return lcpSS(a, a + m) ^ rev;
} else if (getHashS(b - m, b - 1) != getHashT(1, m))
return lcpST(b - m, 1) ^ rev;
}
return false;
}
string ins(string a, string b, int pos) {
a.insert(pos, b);
return a;
}
int ord[NMAX];
int inv[NMAX];
int logar2[NMAX];
void precLogar2() {
for (int i = 2; i <= N; ++i) logar2[i] = 1 + logar2[i >> 1];
}
const int RAD = 53;
struct RMQ {
vector<int> v;
int dims;
int **dp;
void destroy() {
v.clear();
for (int i = 0; i <= dims; ++i) delete dp[i];
delete dp;
dims = 0;
}
void computeDp() {
dims = logar2[v.size()];
if ((1 << dims) < v.size()) ++dims;
dp = new int *[dims + 1];
for (int i = 0; i <= dims; ++i) {
dp[i] = new int[v.size()];
}
for (int i = 0; i < v.size(); ++i) dp[0][i] = v[i];
for (int i = 1; i <= dims; ++i)
for (int j = 0; j + (1 << i) - 1 < v.size(); ++j)
if (inv[dp[i - 1][j]] < inv[dp[i - 1][j + (1 << (i - 1))]])
dp[i][j] = dp[i - 1][j];
else
dp[i][j] = dp[i - 1][j + (1 << (i - 1))];
}
int query(int a, int b) {
if (b < a) return n + 1;
int y = logar2[b - a + 1];
if (inv[dp[y][a]] < inv[dp[y][b - (1 << y) + 1]]) return dp[y][a];
return dp[y][b - (1 << y) + 1];
}
} all;
RMQ rmqs[RAD + 5];
struct Query {
int l, r, x, y;
int pos;
};
vector<Query> queries[RAD + 5];
int anss[NMAX];
int main() {
ios_base ::sync_with_stdio(false);
cin >> S >> T >> Q;
n = S.size();
m = T.size();
str = "#" + S + "#" + T;
N = str.size() - 1;
str += "#";
precomputeHashes();
for (int i = 0; i <= n; ++i) ord[i] = i;
stable_sort(ord, ord + n + 1, cmpPlacement);
for (int i = 0; i <= n; ++i) inv[ord[i]] = i;
inv[n + 1] = n + 2;
precLogar2();
all.v.resize(n + 1);
for (int i = 0; i <= n; ++i) {
all.v[i] = i;
}
all.computeDp();
for (int i = 1; i <= Q; ++i) {
int l, r, k, x, y;
cin >> l >> r >> k >> x >> y;
int ans = n + 1;
if (k > RAD) {
if (x <= l % k && l % k <= y) {
ans = all.query(l, min(r, l + y - l % k));
l += y - l % k + 1;
}
l += (k + x - l % k) % k;
while (l <= r) {
int aux = all.query(l, min(r, l + y - x));
if (inv[aux] < inv[ans]) ans = aux;
l += k;
}
if (ans == n + 1)
anss[i] = -1;
else
anss[i] = ans;
} else {
queries[k].push_back({l, r, x, y, i});
}
}
for (int k = 1; k <= RAD; ++k) {
for (int i = 0; i <= n; ++i) rmqs[i % k].v.push_back(i);
for (int res = 0; res < k; ++res) rmqs[res].computeDp();
for (auto it : queries[k]) {
int x = it.x;
int y = it.y;
int l = it.l;
int r = it.r;
int pos = it.pos;
int ans = n + 1;
for (int res = x; res <= y && res <= r; ++res) {
int a, b;
b = (r - res) / k;
if (l - res < 0)
a = 0;
else
a = (l - res + k - 1) / k;
int qu = rmqs[res].query(a, b);
if (inv[qu] < inv[ans]) ans = qu;
}
if (ans == n + 1)
anss[pos] = -1;
else
anss[pos] = ans;
}
for (int res = 0; res < k; ++res) rmqs[res].destroy();
}
for (int i = 1; i <= Q; ++i) cout << anss[i] << " \n"[i == Q];
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long int n, m, i, x;
cin >> n >> m;
vector<string> v1, v2;
string s;
for (i = 0; i < n; i++) {
cin >> s;
v1.push_back(s);
}
for (i = 0; i < m; i++) {
cin >> s;
v2.push_back(s);
}
long long int q;
cin >> q;
while (q--) {
cin >> x;
x--;
long long int p = x % n;
long long int q1 = x % m;
string res = v1[p] + v2[q1];
cout << res << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[300005], i, tree[1000005], tree2[1000005], ans[600005], mx;
void modify(int i, int l, int r, int ll, int rr, int x) {
if (l >= ll && r <= rr) {
tree[i] = max(tree[i], x);
return;
}
int mid = l + r >> 1;
if (mid >= ll) modify(i << 1, l, mid, ll, rr, x);
if (mid < rr) modify(i << 1 | 1, mid + 1, r, ll, rr, x);
}
void modify2(int i, int l, int r, int ll, int rr, int x) {
if (l >= ll && r <= rr) {
tree2[i] = max(tree2[i], x);
return;
}
int mid = l + r >> 1;
if (mid >= ll) modify2(i << 1, l, mid, ll, rr, x);
if (mid < rr) modify2(i << 1 | 1, mid + 1, r, ll, rr, x);
}
void Out1(int i, int l, int r, int s) {
if (l == r) {
if (n - 2 * l >= 0) ans[n - 2 * l] = max(s, tree[i]);
return;
}
int mid = l + r >> 1;
Out1(i << 1 | 1, mid + 1, r, max(s, tree[i]));
Out1(i << 1, l, mid, max(s, tree[i]));
}
void Out2(int i, int l, int r, int s) {
if (l == r) {
if (n - 2 * l - 1 >= 0) ans[n - 2 * l - 1] = max(s, tree2[i]);
return;
}
int mid = l + r >> 1;
Out2(i << 1 | 1, mid + 1, r, max(s, tree2[i]));
Out2(i << 1, l, mid, max(s, tree2[i]));
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
mx = max(mx, a[i]);
modify(1, 1, n, 1, min(i, n - i + 1), a[i]);
}
for (i = 2; i <= n; ++i)
modify2(1, 1, n, 1, min(i - 1, n - i + 1), min(a[i], a[i - 1]));
Out1(1, 1, n, 0);
Out2(1, 1, n, 0);
for (i = 0; i < n - 1; ++i) printf("%d ", ans[i]);
printf("%d", mx);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005], x[1000005], mx = -999999999, mxi, xx[10000005];
set<int> st;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
x[a[i]]++;
if (x[a[i]] > mx) mx = x[a[i]];
}
for (int i = 1; i <= n; i++) {
xx[a[i]]++;
if (xx[a[i]] == mx) {
cout << a[i];
return 0;
}
}
cout << mxi;
}
| 1 |
#include <bits/stdc++.h>
const int MAX = 1e3 + 11;
using namespace std;
int N;
vector<pair<int, int>> A[MAX];
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
int x = 0, y = 0;
scanf("%d %d", &x, &y);
A[x / MAX].push_back({y, i});
}
for (int i = 0; i < MAX; ++i) {
for (int j = i + 1; j < MAX; ++j) {
if (A[i].size() < A[j].size()) {
swap(A[i], A[j]);
}
}
}
int sz = 0;
for (int i = 0; i < MAX; ++i) {
if (!A[i].size()) {
sz = i + 1;
break;
}
}
for (int j = 0; j < sz; ++j) {
if (j & 1) {
sort(A[j].begin(), A[j].end());
} else {
sort(A[j].rbegin(), A[j].rend());
}
}
vector<int> res;
for (int i = 0; i < sz; ++i) {
for (int j = 0; j < A[i].size(); ++j) {
res.push_back(A[i][j].second);
}
}
for (int k = 0; k < res.size(); ++k) {
printf("%d ", res[k] + 1);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
int v[200000], next[200000 + 1];
int main() {
int i, n;
long long con;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &v[i]);
next[v[i] - 1] = i + 1;
}
con = 0;
for (i = 1; i < n; i++) con = con + abs(next[i] - next[i - 1]);
printf("%I64d", con);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int t, l, r, z;
cin >> t;
while (t--) {
cin >> l >> r >> z;
if (z >= (r - l + 1)) {
z = z % (r - l + 1);
}
reverse(str.begin() + l - 1, str.begin() + r);
reverse(str.begin() + l - 1 + z, str.begin() + r);
reverse(str.begin() + l - 1, str.begin() + r - (r - l + 1) + z);
}
cout << str;
}
| 2 |
#include <bits/stdc++.h>
const int mod = 998244353;
using namespace std;
char s[3000];
int dp1[3000][3000], dp2[3000][3000];
void sol() {
memset(dp2, 0, sizeof(dp2));
memset(dp1, 0, sizeof(dp1));
int n = strlen(s + 1);
dp1[0][0] = 1;
dp2[n + 1][0] = 1;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= n; ++j) {
if (s[i] == '(') {
if (j) dp1[i][j] = (dp1[i][j] + dp1[i - 1][j - 1]) % mod;
} else if (s[i] == ')') {
dp1[i][j] = (dp1[i][j] + dp1[i - 1][j]) % mod;
} else {
dp1[i][j] = (dp1[i][j] + dp1[i - 1][j]) % mod;
if (j) {
dp1[i][j] = (dp1[i][j] + dp1[i - 1][j - 1]) % mod;
}
}
}
}
for (int i = n; i >= 0; --i) {
for (int j = 0; j <= n; ++j) {
if (s[i] == ')') {
if (j) dp2[i][j] = (dp2[i][j] + dp2[i + 1][j - 1]) % mod;
} else if (s[i] == '(') {
dp2[i][j] = (dp2[i][j] + dp2[i + 1][j]) % mod;
} else {
dp2[i][j] = (dp2[i][j] + dp2[i + 1][j]) % mod;
if (j) dp2[i][j] = (dp2[i][j] + dp2[i + 1][j - 1]) % mod;
}
}
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
ans = (ans + ((1ll * j * dp1[i][j]) % mod) * dp2[i + 1][j]) % mod;
}
}
cout << ans << endl;
}
int main() {
cin >> s + 1;
sol();
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int dp[10][10][100000];
int k, n;
const long long int mod = 1e9 + 7;
long long int calc(int len, long long int st, long long int a) {
long long int maxv = st;
for (int i = 1; i < len; i++) {
maxv = maxv * 10 + 9, st = st * 10;
}
return (maxv / a - st / a + (st % a == 0)) % mod;
}
int main() {
cin >> n >> k;
long long int a[n / k], b[n / k];
for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
for (int k = 0; k < 100000; k++) {
dp[i][j][k] = -1;
}
}
}
for (int i = 0; i < n / k; i++) cin >> a[i];
for (int i = 0; i < n / k; i++) cin >> b[i];
long long int ans = 1;
for (int i = 0; i < n / k; i++) {
long long int par = 0;
for (int d = 0; d <= 9; d++) {
if (d != b[i]) {
par = (par + calc(k, d, a[i])) % mod;
}
}
ans = ans * par % mod;
}
cout << ans % mod << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const char painted = 'B';
int get_num_strokes(const vector<string>& board) {
bool full = true;
for (int row = 0; row < (int)board.size(); ++row) {
for (int col = 0; col < (int)board[row].size(); ++col) {
full = full && (board[row][col] == painted);
}
}
if (full) return 8;
int n_strokes = 0;
for (int row = 0; row < (int)board.size(); ++row) {
full = true;
for (int col = 0; col < (int)board[row].size(); ++col) {
full = full && (board[row][col] == painted);
}
if (full) ++n_strokes;
full = true;
for (int col = 0; col < (int)board[row].size(); ++col) {
full = full && (board[col][row] == painted);
}
if (full) ++n_strokes;
}
return n_strokes;
}
int main(int argc, char* argv[]) {
vector<string> board(8);
for (string& row : board) getline(cin, row);
cout << get_num_strokes(board) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:67108864")
using namespace std;
int n;
vector<int> vc[222222];
vector<int> cn[222222];
set<int, less<int> > vv[222222];
int dr[222222][2];
bool color[222222];
int mx = 0;
void dfs(int v) {
color[v] = true;
for (size_t i = 0; i < cn[v].size(); i++) {
int j = cn[v][i];
int k = 0;
if (dr[j][0] == v) {
k = dr[j][1];
} else {
k = dr[j][0];
}
if (!color[k]) {
int l = *(vv[v].begin());
vv[v].erase(vv[v].begin());
if (l > mx) mx = l;
set<int, less<int> >::iterator ii = vv[k].find(l);
if (ii != vv[k].end()) vv[k].erase(ii);
vc[l].push_back(j);
dfs(k);
}
}
}
int main() {
scanf("%i", &n);
memset(color, 0, sizeof(color));
for (int i = 0; i < n - 1; i++) {
scanf("%i%i", &dr[i][0], &dr[i][1]);
dr[i][0]--;
dr[i][1]--;
vv[dr[i][0]].insert(vv[dr[i][0]].size());
vv[dr[i][1]].insert(vv[dr[i][1]].size());
cn[dr[i][0]].push_back(i);
cn[dr[i][1]].push_back(i);
}
dfs(0);
printf("%i\n", mx + 1);
for (int i = 0; i <= mx; i++) {
printf("%i ", vc[i].size());
for (int j = 0; j < vc[i].size(); j++) {
printf("%i ", vc[i][j] + 1);
}
printf("\n");
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
void solve() {
long long n, k;
cin >> n >> k;
long long a[n];
for (long long i = 0; i < n; i += 1) cin >> a[i];
long long pre[n], suff[n];
memset(pre, 1, n);
memset(suff, -1, n);
for (long long i = 0; i < n; i += 1) {
pre[i] = i + 1;
}
for (long long i = 0; i < n; i += 1) {
suff[i] = i - 1;
}
priority_queue<pair<long long, long long>> pq;
for (long long i = 0; i < n; i += 1) {
pq.push({a[i], i});
}
string ans;
for (long long i = 0; i < n; i += 1) ans += '0';
long long fl = 0;
while (true) {
if (pq.empty()) break;
while ((!pq.empty()) && ans[pq.top().second] != '0') {
pq.pop();
}
if (pq.empty()) break;
long long x = pq.top().first;
long long i = pq.top().second;
vector<long long> v;
v.push_back(i);
pq.pop();
if (fl == 0)
ans[i] = '1';
else
ans[i] = '2';
long long I = i;
i = suff[i];
long long K = k;
while (K-- && i >= 0) {
v.push_back(i);
if (fl == 0)
ans[i] = '1';
else
ans[i] = '2';
i = suff[i];
}
long long l = i;
i = I;
i = pre[i];
K = k;
while (K-- && i < n) {
v.push_back(i);
if (fl == 0)
ans[i] = '1';
else
ans[i] = '2';
i = pre[i];
}
if (i >= 0 && i < n) suff[i] = l;
if (l >= 0 && l < n) pre[l] = i;
fl ^= 1;
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long tin = 1;
while (tin--) {
solve();
}
return 0;
}
| 5 |
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<cassert>
#include<set>
#include<map>
using namespace std;
#define pb push_back
#define mp make_pair
#define rep(i,n) for(int i=1;i<=n;i++)
typedef long long LL;
const int MOD=(int)1e9+7;
const int N=110;
int f[N][N*N],ssb[N],sc[N],b[N],c[N],n,q,ans[N];
void work(int&ans,int x)
{
memset(f,0,sizeof(f));
rep(i,n)
{
if(i==1)for(int j=max(0,x);j<=c[1];j++)f[1][j]=1;
else
{
rep(j,sc[i])(f[i-1][j]+=f[i-1][j-1])%=MOD;
for(int j=max(0,i*x+ssb[i]);j<=sc[i];j++)f[i][j]=(f[i-1][j]-(j-c[i]-1>=0?f[i-1][j-c[i]-1]:0)+MOD)%MOD;
}
}
ans=0;
for(int i=0;i<=sc[n];i++)(ans+=f[n][i])%=MOD;
}
int main()
{
scanf("%d",&n);
rep(i,n)scanf("%d",&c[i]),sc[i]=sc[i-1]+c[i];
rep(i,n-1)scanf("%d",&b[i+1]),ssb[i+1]=ssb[i]+b[i+1];
rep(i,n)ssb[i]+=ssb[i-1];
int L=(-ssb[n])/n,R=(sc[n]-ssb[n])/n;
rep(i,n-1)L=min(L,(-ssb[i])/i),R=min(R,(sc[i]-ssb[i])/i);
L=max(L,-(int)1e5);R=min(R,(int)1e5);
for(int i=L;i<=R;i++)work(ans[i-L+1],i);
scanf("%d",&q);
int pw2=1;
rep(i,n)pw2=1ll*pw2*(c[i]+1)%MOD;
rep(Q,q)
{
int x;scanf("%d",&x);
if(Q==217)
{
int ans=0;
work(ans,x);
printf("%d\n",ans);
continue;
}
if(x>R)puts("0");
else if(x<L)printf("%d\n",pw2);
else printf("%d\n",ans[x-L+1]);
}
return 0;
} | 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
vector<int> cnt(32, 0);
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
for (int j = 31; j >= 0; --j) {
if (x >> j & 1) {
cnt[j]++;
}
}
}
27;
bool isdraw = true;
for (int i = 31; i >= 0; i--) {
if (cnt[i] % 2 == 0) {
continue;
}
27;
int x = cnt[i] % 4, y = n - cnt[i];
if (x == 1) {
cout << "WIN" << '\n';
isdraw = false;
break;
} else if (x == 3) {
cout << (y % 2 ? "WIN" : "LOSE") << '\n';
isdraw = false;
break;
}
}
if (isdraw) {
cout << "DRAW" << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, ans, a[maxn], cnt[31];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + n + 1);
function<int(int, int, int)> solve = [&](int k, int l, int r) {
if (k < 0) return 0;
if ((a[l] >> k & 1) == (a[r] >> k & 1)) return solve(k - 1, l, r);
int lb = l, rb = r, pos;
while (lb <= rb) {
int mid = (lb + rb) >> 1;
if (!(a[mid] >> k & 1))
lb = (pos = mid) + 1;
else
rb = mid - 1;
}
int v1 = solve(k - 1, l, pos);
int v2 = solve(k - 1, pos + 1, r);
return min(v1 + r - pos - 1, v2 + pos - l);
};
printf("%d\n", solve(30, 1, n));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int CN = 4e5 + 10;
int read() {
int s = 0, ne = 1;
char c = getchar();
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') ne = -1;
for (; c >= '0' && c <= '9'; c = getchar()) s = (s << 1) + (s << 3) + c - '0';
return s * ne;
}
int n, q, val[CN], id[CN], dep[CN];
vector<int> G[CN];
int lg[CN], pos[CN], ar[20][CN], idx = 0;
void dfs(int u, int p) {
dep[u] = dep[p] + 1, pos[u] = ++idx, ar[0][idx] = u;
for (int l = G[u].size(), i = 0; i < l; i++) {
int v = G[u][i];
if (v == p) continue;
dfs(v, u), ar[0][++idx] = u;
}
}
int lca(int l, int r) {
l = pos[l], r = pos[r];
if (l > r) swap(l, r);
int g = lg[r - l + 1], e = 1 << g;
return dep[ar[g][l]] < dep[ar[g][r - e + 1]] ? ar[g][l] : ar[g][r - e + 1];
}
int dist(int u, int v) { return dep[u] + dep[v] - (dep[lca(u, v)] << 1); }
bool isanc(int u, int v) { return u ^ v ? lca(u, v) == u : 1; }
bool onpath(int u, int v, int x) {
if (u == x || v == x) return 1;
int l = lca(u, v);
return isanc(l, x) && (isanc(x, u) || isanc(x, v));
}
class SGT {
public:
int u[CN << 2], v[CN << 2];
void pu(int &cu, int &cv, int a, int b, int c, int d) {
if (!a) return (void)(cu = c, cv = d);
if (a == -1 || c == -1) return (void)(cu = -1);
bool abc = onpath(a, b, c), abd = onpath(a, b, d), cda = onpath(c, d, a),
cdb = onpath(c, d, b);
if (abc && abd) return (void)(cu = a, cv = b);
if (cda && cdb) return (void)(cu = c, cv = d);
int cur = dist(a, c), tmp, tu = a, tv = c;
if ((tmp = dist(a, d)) > cur) tu = a, tv = d, cur = tmp;
if ((tmp = dist(b, c)) > cur) tu = b, tv = c, cur = tmp;
if ((tmp = dist(b, d)) > cur) tu = b, tv = d, cur = tmp;
if ((abc && cda) || (abc && cdb) || (abd && cda) || (abd && cdb))
return (void)(cu = tu, cv = tv);
if (onpath(tu, tv, a) && onpath(tu, tv, b) && onpath(tu, tv, c) &&
onpath(tu, tv, d))
return (void)(cu = tu, cv = tv);
cu = -1;
}
void bd(int l, int r, int k) {
if (l == r) return (void)(u[k] = v[k] = id[l]);
int m = (l + r) >> 1;
bd(l, m, k << 1), bd(m + 1, r, k << 1 | 1);
pu(u[k], v[k], u[k << 1], v[k << 1], u[k << 1 | 1], v[k << 1 | 1]);
}
void upd(int l, int r, int k, int p) {
if (l == r) return (void)(u[k] = v[k] = id[l]);
int m = (l + r) >> 1;
p <= m ? upd(l, m, k << 1, p) : upd(m + 1, r, k << 1 | 1, p);
pu(u[k], v[k], u[k << 1], v[k << 1], u[k << 1 | 1], v[k << 1 | 1]);
}
int qu(int l, int r, int k, int &cu, int &cv) {
if (l == r) {
pu(cu, cv, cu, cv, u[k], v[k]);
return l + !!(cu ^ -1);
}
int m = (l + r) >> 1, tcu = cu, tcv = cv;
pu(cu, cv, cu, cv, u[k << 1], v[k << 1]);
if (cu == -1) return cu = tcu, cv = tcv, qu(l, m, k << 1, cu, cv);
return qu(m + 1, r, k << 1 | 1, cu, cv);
}
} D;
int main() {
n = read();
for (int i = 1; i <= n; i++) val[i] = read(), id[val[i]] = i;
for (int i = 2; i <= n; i++) G[read()].push_back(i);
dfs(1, 0);
for (int i = 2; i <= idx; i++) lg[i] = lg[i >> 1] + 1;
for (int k = 1; k <= lg[idx]; k++)
for (int i = 1; i <= idx; i++) {
int j = i + (1 << (k - 1));
if (j > idx) continue;
if (dep[ar[k - 1][i]] < dep[ar[k - 1][j]])
ar[k][i] = ar[k - 1][i];
else
ar[k][i] = ar[k - 1][j];
}
D.bd(0, n - 1, 1), q = read();
while (q--) {
int tp = read(), x, y;
if (tp == 1) {
x = read(), y = read();
swap(id[val[x]], id[val[y]]), swap(val[x], val[y]);
D.upd(0, n - 1, 1, val[x]), D.upd(0, n - 1, 1, val[y]);
} else {
x = 0, y = 0;
printf("%d\n", D.qu(0, n - 1, 1, x, y));
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int r[110], l[110], val[110][110], num[110][110];
int main() {
int T, t, n, m, i, j, k;
bool flag;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) r[i] = 1;
for (j = 1; j <= m; j++) l[j] = 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf("%d", &num[i][j]);
if (num[i][j] == 0) r[i] = l[j] = 0;
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (r[i] == 1 && l[j] == 1)
val[i][j] = 1;
else
val[i][j] = 0;
for (i = 1; i <= n; i++) {
r[i] = 0;
for (j = 1; j <= m; j++) r[i] += val[i][j];
}
for (i = 1; i <= m; i++) {
l[i] = 0;
for (j = 1; j <= n; j++) l[i] += val[j][i];
}
flag = true;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (num[i][j] == 1 && r[i] + l[j] == 0) flag = false;
if (!flag)
printf("NO\n");
else {
printf("YES\n");
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) printf("%d ", val[i][j]);
printf("\n");
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long egcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
long long c = egcd(b, a % b, x, y);
long long d = x;
x = y;
y = d - a / b * x;
return c;
}
int n, m;
long long mod = 1000000007;
int main() {
long long a, b, sum, now, s1, s2;
int i, j, res;
long long x, y;
while (cin >> a >> b >> n) {
sum = 0;
s1 = 1;
for (i = 0; i <= n;) {
now = a * i + b * (n - i);
while (now) {
if (now % 10 == a || now % 10 == b)
now /= 10;
else
break;
}
if (now == 0) {
sum = (sum + s1) % mod;
}
i++;
egcd(i, mod, x, y);
s1 = s1 * (n - i + 1) % mod * x % mod;
}
res = (sum + mod) % mod;
cout << res << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int way[5005][5005], go[5005][5005];
const int mod = 1000000007;
int main() {
string s, t;
cin >> s >> t;
int n = s.size();
int m = t.size();
for (int i = n - 1; i >= 0; i--) {
way[i][m] = way[n][m] = 0;
for (int j = m - 1; j >= 0; j--) {
way[n][j] = 0;
if (s[i] == t[j])
way[i][j] = (way[i + 1][j + 1] + way[i][j + 1] + 1) % mod;
else
way[i][j] = way[i][j + 1];
}
}
for (int i = n - 1; i >= 0; i--) {
go[i][m] = go[n][m] = 0;
for (int j = m - 1; j >= 0; j--) {
go[n][j] = 0;
go[i][j] = (way[i][j] + go[i + 1][j]) % mod;
}
}
cout << go[0][0] << endl;
cin >> s;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[100086];
vector<int> vec[100086];
vector<int> x;
bool vis[100086];
int main() {
scanf("%d%d", &n, &m);
memset(vis, 0, sizeof(vis));
long long ans = 0;
for (int i = 1; i <= m; ++i) scanf("%d", &a[i]);
for (int i = 2; i <= m; ++i) {
if (a[i] == a[i - 1]) continue;
ans += abs(a[i] - a[i - 1]);
vec[a[i - 1]].push_back(a[i]);
vec[a[i]].push_back(a[i - 1]);
if (!vis[a[i - 1]]) {
x.push_back(a[i - 1]);
vis[a[i - 1]] = 1;
}
if (!vis[a[i]]) {
x.push_back(a[i]);
vis[a[i]] = 1;
}
}
long long t = 0;
for (int i = 0; i < x.size(); ++i) {
long long u = 0;
int w = x[i];
for (int j = 0; j < vec[w].size(); ++j) u += abs(x[i] - vec[w][j]);
long long v = 0;
int sz = vec[w].size();
sort(vec[w].begin(), vec[w].end());
for (int j = 0; j * 2 < vec[w].size(); ++j)
v += vec[w][sz - 1 - j] - vec[w][j];
t = max(t, u - v);
}
cout << ans - t << endl;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int a, b, x, y, ans;
scanf("%d %d", &a, &b);
ans = a;
while (a >= b) {
x = a / b;
ans = ans + x;
y = a % b;
a = x + y;
}
printf("%d", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MSIZE = 1e5;
const int INF = 1e9 + 1;
const int MOD = 1e9 + 1;
const int alpha = 256;
const double EPS = 1e-9;
int dp[2][MSIZE + 1];
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
for (int i = 0; i <= MSIZE; ++i) dp[1][i] = -INF;
for (int i = 0; i < n; ++i) {
dp[0][i + 1] = max(dp[0][i + 1], dp[0][i]);
dp[1][i + 1] = max(dp[1][i + 1], dp[1][i]);
int val0 = dp[0][i] + v[i];
int val1 = dp[1][i] + v[i];
if (val0 % 2 == 0)
dp[0][i + 1] = max(dp[0][i + 1], val0);
else
dp[1][i + 1] = max(dp[1][i + 1], val0);
if (val1 % 2 == 0)
dp[0][i + 1] = max(dp[0][i + 1], val1);
else
dp[1][i + 1] = max(dp[1][i + 1], val1);
}
cout << dp[1][n];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, k;
char s[N];
vector<int> pos[2];
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s);
for (int i = 0; i < n; i++) pos[s[i] - '0'].push_back(i);
for (int t = 0; t < 2; t++) {
vector<int>& v = pos[t];
if (v.empty() || v.back() - v.front() < k)
return cout << "tokitsukaze" << endl, 0;
}
for (int i = 0; i + k <= n; i++) {
for (int t = 0; t < 2; t++) {
vector<int>& v = pos[t];
int first = i, last = i + k - 1;
if (v.front() < first && v.back() > last) {
return cout << "once again" << endl, 0;
} else if (v.front() < first) {
int idx = lower_bound((v).begin(), (v).end(), first) - v.begin() - 1;
if (v[idx] - v.front() >= k) {
return cout << "once again" << endl, 0;
}
} else {
int idx = lower_bound((v).begin(), (v).end(), last + 1) - v.begin();
if (v.back() - v[idx] >= k) {
return cout << "once again" << endl, 0;
}
}
}
}
cout << "quailty" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long f, suma, l = sqrt(n);
suma = 4 * l;
f = n - l * l;
suma += (f / l) * 2;
f -= (f / l) * l;
if (f > 0) {
suma += 2;
}
cout << suma;
return 0;
}
| 1 |
#include <bits/stdc++.h>
std::vector<int> data[100005];
long long count(0);
long long sum[100005];
int dg[100005];
signed main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
int n, m;
std::cin >> n >> m;
for (int i = 0; i < m; i++) {
int f, t;
std::cin >> f >> t;
f--;
t--;
if (f > t) {
std::swap(f, t);
}
data[f].push_back(t);
dg[f]++;
dg[t]++;
}
for (int i = 0; i < n; i++) {
data[i].reserve(dg[i]);
count += sum[i] = data[i].size() * (dg[i] - data[i].size());
}
std::cout << count << '\n';
int q;
std::cin >> q;
for (q; q > 0; q--) {
int v;
std::cin >> v;
v--;
count -= sum[v];
sum[v] = 0;
while (!data[v].empty()) {
int u = data[v].back();
data[v].pop_back();
count -= sum[u];
data[u].push_back(v);
count += sum[u] = data[u].size() * (dg[u] - data[u].size());
}
std::cout << count << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int N;
int dp[(1 << 8) + 10][1000 + 10];
int mx[(1 << 8) + 10][1000 + 10];
int nx[8 + 2][125 + 2][1000 + 10];
int A[1000 + 10];
const int INF = 1e9;
void init() {
memset(nx, -1, sizeof(nx));
for (int u = 1; u <= 8; u++) {
nx[u][0][N + 1] = N + 1;
for (int i = N; i >= 1; i--) {
nx[u][0][i] = i;
for (int b = 1; b <= (N / 8 + 1); b++) {
if (A[i] == u)
nx[u][b][i] = nx[u][b - 1][i + 1];
else
nx[u][b][i] = nx[u][b][i + 1];
}
}
}
}
int sset(int st, int x) { return st | (1 << (x - 1)); }
bool is(int st, int x) { return st & (1 << (x - 1)); }
int solve(int block) {
if (block == 0) {
int res = 0;
for (int x = 1; x <= 8; x++) {
res += count(A + 1, A + N + 1, x) > 0;
}
return res;
}
memset(dp, 0, sizeof(dp));
memset(mx, 0, sizeof(mx));
for (int st = 0; st < (1 << 8) - 1; st++) {
dp[st][N + 1] = -INF;
mx[st][N + 1] = -INF;
}
for (int i = 1; i <= N + 1; i++) {
dp[(1 << 8) - 1][i] = 0;
mx[(1 << 8) - 1][i] = 0;
}
for (int st = (1 << 8) - 2; st >= 0; st--) {
for (int i = N; i >= 1; i--) {
dp[st][i] = -INF;
for (int x = 1; x <= 8; x++) {
if (is(st, x)) continue;
int l = nx[x][block][i];
int r = nx[x][block + 1][i];
if (l != -1 && mx[sset(st, x)][l] != -INF) {
dp[st][i] = max(dp[st][i], block + mx[sset(st, x)][l]);
}
if (r != -1 && mx[sset(st, x)][r] != -INF) {
dp[st][i] = max(dp[st][i], block + 1 + mx[sset(st, x)][r]);
}
mx[st][i] = max(dp[st][i], mx[st][i + 1]);
}
}
}
return dp[0][1];
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d", &A[i]);
}
init();
int mx = 0;
for (int d = 0; d <= N / 8; d++) {
mx = max(mx, solve(d));
}
printf("%d\n", mx);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& x) {
bool fu = 0;
char c;
for (c = getchar(); c <= 32; c = getchar())
;
if (c == '-') fu = 1, c = getchar();
for (x = 0; c > 32; c = getchar()) x = x * 10 + c - '0';
if (fu) x = -x;
};
template <class T>
inline void read(T& x, T& y) {
read(x);
read(y);
}
template <class T>
inline void read(T& x, T& y, T& z) {
read(x);
read(y);
read(z);
}
inline char getc() {
char c;
for (c = getchar(); c <= 32; c = getchar())
;
return c;
}
const int N = 100010;
const int D = N << 1;
int n, i, j, k, l, p, ans;
pair<int, int> res1, res2;
int a[N], q[N], t[N];
bool v[N];
int main() {
read(n);
for (i = 1; i <= n; i++) read(a[i]);
p = -1;
for (i = 1; i <= n; i++) {
if (a[i] >= p) {
p = a[i];
v[i] = 1;
}
}
p = 0;
int ans = 0;
for (i = n; i >= 1; i--) {
if (v[i] == 1)
p = 0;
else {
int cnt = 0;
for (; p > 0 && q[p] < a[i]; p--, cnt++)
;
q[++p] = a[i];
ans = max(ans, p);
}
}
cout << ans << endl;
scanf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool uax(T &x, T y) {
return (y > x) ? x = y, true : false;
}
template <typename T>
inline bool uin(T &x, T y) {
return (y < x) ? x = y, true : false;
}
template <typename T>
void kek(T ans) {
cout << ans << endl;
exit(0);
}
const int MOD = (int)1e9 + 7;
const long long INF = (long long)1e18 + 42;
int a[555][555];
void solve_case() {
int n, m;
cin >> n >> m;
42;
;
auto calc = [&](int i, int j) {
int ans = 0;
ans += i > 0;
ans += i + 1 < n;
ans += j > 0;
ans += j + 1 < m;
return ans;
};
int ok = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
int nei = calc(i, j);
if (a[i][j] > nei) {
ok = 0;
}
a[i][j] = nei;
}
}
if (!ok) {
cout << "NO\n";
return;
}
cout << "YES\n";
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << a[i][j] << ' ';
}
cout << '\n';
}
}
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
int tt;
cin >> tt;
while (tt--) {
solve_case();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long cc = 1e9 + 7;
void Zarr(string s, long long Z[]) {
long long n = s.size();
if (n > 0) Z[0] = 0;
long long L = 0, R = 0;
for (long long i = 1; i < n; i++) {
if (R < i) {
L = i;
R = i;
while (R < n && s[R - L] == s[R]) R++;
Z[i] = R - L;
R--;
} else {
if (Z[i - L] < R - i + 1) {
Z[i] = Z[i - L];
} else {
L = i;
while (R < n && s[R - L] == s[R]) R++;
Z[i] = R - L;
R--;
}
}
}
}
long long KK[100005];
long long KA[100005];
long long KL[100005];
long long Z[1000000];
int main() {
string s, t, S;
cin >> s >> t;
S = t + s;
Zarr(S, Z);
long long nn = s.size();
long long n = t.size();
long long K[nn];
memset(K, 0, sizeof(K));
long long j = 0;
for (long long i = n; i < S.size(); i++) {
if (Z[i] >= n) K[j] = 1;
j++;
}
for (long long i = nn - 1; i >= 0; i--) {
if (K[i] == 0) {
if (i < nn - 1) KK[i] = KK[i + 1];
} else {
KK[i] = (nn - i + 1 - n);
if (i + n < nn) KK[i] = (KK[i] + KL[i + n]) % cc;
}
if (i < nn - 1)
KA[i] = (KA[i + 1] + KK[i]) % cc;
else
KA[i] = KK[i];
if (i < nn - 1)
KL[i] = (KL[i + 1] + KA[i]) % cc;
else
KL[i] = KA[i];
}
cout << KA[0] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> v[k];
int lines[k];
for (int i = 0; i < k; i++) {
cin >> lines[i];
for (int j = 0; j < lines[i]; j++) {
int x;
cin >> x;
v[i].push_back(x);
}
}
int ans = 0;
for (int i = 0; i < k; i++) {
if (v[i][0] != 1)
ans += lines[i] - 1;
else {
for (int j = 1; j < lines[i]; j++) {
if (v[i][j] != v[i][j - 1] + 1) {
ans += lines[i] - j;
break;
}
}
}
}
ans += ans + k - 1;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long t[8000005];
struct node {
int x, y;
} tt[200005];
int ans, i, A, B, C, n, m, Q, cnt, root[200005], L, R, mid;
int cmp(node i, node j) { return i.x > j.x; }
void work(unsigned long long A, int &B, int &C) {
A /= 200001;
C = A % 8000001;
A /= 8000001;
B = A % 8000001;
}
unsigned long long WORK(unsigned long long A, unsigned long long B,
unsigned long long C) {
A *= 8000001;
A *= 200001;
B *= 200001;
return A + B + C;
}
void Update(int &A, int &B, int l, int r, int L, int R) {
if (l == r) {
B = A + 1;
return;
}
if (!B) B = ++cnt;
int mid = (l + r) / 2, llB, rrB, llA, rrA;
work(t[B], llB, rrB);
work(t[A], llA, rrA);
if (l == L && r == R) {
if (!llB) llB = llA;
if (!rrB) rrB = rrA;
int D = t[A] % 200001 - max(mid == l ? llA : t[llA] % 200001,
mid + 1 == r ? rrA : t[rrA] % 200001);
t[B] = WORK(llB, rrB,
max(mid == l ? llB : t[llB] % 200001,
mid + 1 == r ? rrB : t[rrB] % 200001) +
D + 1);
return;
}
int D = t[A] % 200001 - max(mid == l ? llA : t[llA] % 200001,
mid + 1 == r ? rrA : t[rrA] % 200001);
if (L <= mid) Update(llA, llB, l, mid, L, min(mid, R));
if (R > mid) Update(rrA, rrB, mid + 1, r, max(mid + 1, L), R);
if (!llB) llB = llA;
if (!rrB) rrB = rrA;
t[B] = WORK(llB, rrB,
max(mid == l ? llB : t[llB] % 200001,
mid + 1 == r ? rrB : t[rrB] % 200001) +
D);
}
int work2(int A, int l, int r, int L, int R) {
if (l == L && r == R) return l == r ? A : t[A] % 200001;
int mid = (l + r) / 2, llA, rrA, p = 0, q = 0;
work(t[A], llA, rrA);
int D = t[A] % 200001 - max(mid == l ? llA : t[llA] % 200001,
mid + 1 == r ? rrA : t[rrA] % 200001);
if (L <= mid) p = work2(llA, l, mid, L, min(mid, R));
if (R > mid) q = work2(rrA, mid + 1, r, max(mid + 1, L), R);
return max(p, q) + D;
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &tt[i].x);
tt[i].y = i;
}
sort(tt + 1, tt + n + 1, cmp);
for (i = 1; i <= n; i++)
Update(root[i - 1], root[i], 1, n - m + 1, max(1, tt[i].y - m + 1),
min(n - m + 1, tt[i].y));
scanf("%d", &Q);
while (Q--) {
scanf("%d%d%d", &A, &B, &C);
C ^= ans;
L = 1;
R = n;
mid = (L + R) / 2;
while (L <= R) {
if (tt[mid].x < C) {
R = mid - 1;
mid = (L + R) / 2;
} else {
L = mid + 1;
mid = (L + R) / 2;
}
}
if (!R) {
ans = m;
printf("%d\n", ans);
continue;
}
ans = m - work2(root[R], 1, n - m + 1, A, B);
printf("%d\n", ans);
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
unsigned char reverse_bits(unsigned char c) {
unsigned char res = 0;
for (int i = 0; i < 8; i++) {
if (c & (1 << i)) {
res |= (1 << (7 - i));
}
}
return res;
}
int main() {
string s;
getline(cin, s);
for (int i = 0; i < s.size(); i++) {
unsigned char prev = (i > 0) ? s[i - 1] : 0;
prev = reverse_bits(prev);
unsigned char c = s[i];
unsigned char c1 = reverse_bits(c);
unsigned char q = prev - c1;
cout << (int)q << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, size_t N>
struct array {
T val[N];
T& operator[](size_t n) {
if (n >= N) assert(false);
return val[n];
}
T* begin() { return &val[0]; }
T* end() { return &val[0] + N; }
};
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& p) {
return os << '(' << p.first << ", " << p.second << ')';
}
const int inf = 0x3f3f3f3f;
const long long inf64 = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-8;
struct Eva {
enum Poly { PA, PB };
int poly;
pair<long long, long long> from, to;
Eva(int p, const pair<long long, long long>& a,
const pair<long long, long long>& b)
: poly(p), from(a), to(b) {
if (from > to) swap(from, to);
}
bool operator<(const Eva& o) const {
if (from.first != o.from.first) return from.first < o.from.first;
if (poly != o.poly) return poly < o.poly;
return from < o.from;
}
};
bool check(const pair<long long, long long>& from,
const pair<long long, long long>& to, long long x, long long y,
bool under) {
y -= from.second;
long long up = (to.second - from.second) * (x - from.first);
long long down = to.first - from.first;
long long cury = 0;
;
;
if (under) {
return y * down < up;
} else {
return y * down > up;
}
throw 1;
}
int main() {
ios_base::sync_with_stdio(false);
vector<Eva> es;
int n;
cin >> n;
vector<pair<long long, long long> > as(n + 1);
set<long long> ys;
for (int i = 0; i < n; i++) {
cin >> as.at(i).first >> as.at(i).second;
ys.insert(as[i].first);
}
as.back() = as.front();
for (int i = 0; i < n; i++) {
es.push_back(Eva(Eva::PA, as[i], as[i + 1]));
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
es.push_back(Eva(Eva::PB, pair<long long, long long>(x, y),
pair<long long, long long>(inf64, inf64)));
}
sort((es).begin(), (es).end());
Eva up(0, pair<long long, long long>(inf64, inf64),
pair<long long, long long>(inf64, inf64)),
down(0, pair<long long, long long>(inf64, inf64),
pair<long long, long long>(inf64, inf64));
try {
for (const Eva& e : es) {
;
;
;
if (e.poly == Eva::PA) {
if (e.from.first == e.to.first &&
(up.from.first == inf64 || down.from.first == inf64))
continue;
if (up.from.first == inf64) {
up = e;
} else if (down.from.first == inf64) {
down = e;
assert(up.from.first == down.from.first);
if (up.from.second < down.from.second ||
(up.from.second == down.from.second &&
up.to.second < down.to.second))
swap(up, down);
} else {
if (e.from == up.to)
up = e;
else
down = e;
}
} else {
;
;
;
;
if (up.from.first == inf64 || down.from.first == inf64) throw 0;
long long x = e.from.first;
long long y = e.from.second;
if (x > up.to.first || x > down.to.first) throw 0;
if (x <= *ys.begin() || x >= *ys.rbegin()) throw 0;
if (!check(up.from, up.to, x, y, true) ||
!check(down.from, down.to, x, y, false))
throw 0;
}
}
} catch (...) {
puts("NO");
return 0;
}
puts("YES");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100 + 20;
int a[MAX_N];
int P[MAX_N];
int mark[MAX_N];
int n, q;
void dfs(int v, int r) {
mark[v] = 1;
if (v != r && !mark[v + 1] && P[v] < P[v + 1]) dfs(v + 1, r);
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i(0); i < int(n); i++) {
cin >> a[i];
--a[i];
P[a[i]] = i;
}
cin >> q;
while (q--) {
int k, l, r;
cin >> k >> l >> r;
--l, r--;
if (k == 2) {
swap(P[a[l]], P[a[r]]);
swap(a[l], a[r]);
} else {
int Sum = 0;
for (int i(0); i < int(n); i++) mark[i] = 0;
for (int i(l); i < int(r + 1); i++)
if (!mark[i]) {
++Sum;
dfs(i, r);
}
cout << Sum << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
multiset<long long> ms;
int a[500000];
int main() {
int n, v;
cin >> n >> v;
int pos = 1;
int money = min(v, n - 1);
while (pos < n) {
v--;
pos++;
if (n - pos > v) {
money += pos;
v++;
}
}
cout << money;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, l = 0;
int x[201], y[201];
bool flagup = false;
bool flagdown = false;
bool flagright = false;
bool flagleft = false;
bool flag = false;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
}
for (int i = 0; i < n; i++) {
flagup = false;
flagdown = false;
flagright = false;
flagleft = false;
flag = false;
for (int j = 0; j < n; j++) {
if (i == j) continue;
if (x[i] == x[j]) {
if (y[i] > y[j])
flagdown = true;
else
flagup = true;
}
if (y[i] == y[j]) {
if (x[i] > x[j])
flagleft = true;
else
flagright = true;
}
if (flagleft == flagright && flagright == flagup && flagup == flagdown &&
flagdown == true) {
flag = true;
break;
}
}
if (flag == true) l++;
}
cout << l;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
stack<int> st;
queue<int> q;
priority_queue<int> pq;
priority_queue<int, vector<int>, greater<int>> mpq;
int binarySearch(vector<string> arr, int l, int r, string x) {
if (r >= l) {
int mid = l + (r - l) / 2;
if (arr[mid] == x) {
return mid;
}
if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
bool comp(pair<int, int> a, pair<int, int> b) { return (a.first > b.first); }
int visited[1005][1005];
int arr[1005][1005];
vector<int> ans;
int dfs(int x, int y, int n, int m) {
if (x >= n || x < 0 || y < 0 || y >= m) {
return 0;
}
if (visited[x][y]) {
return 0;
}
visited[x][y] = 1;
int size = 1;
if ((arr[x][y] & (4)) == 0 && (arr[x][y + 1] & (1)) == 0) {
size += dfs(x, y + 1, n, m);
}
if ((arr[x][y] & (2)) == 0 && (arr[x + 1][y] & (8)) == 0) {
size += dfs(x + 1, y, n, m);
}
if ((arr[x][y] & (1)) == 0 && (arr[x][y - 1] & (4)) == 0) {
size += dfs(x, y - 1, n, m);
}
if ((arr[x][y] & (8)) == 0 && (arr[x - 1][y] & (2)) == 0) {
size += dfs(x - 1, y, n, m);
}
return size;
}
void solve() {
memset(arr, 0, sizeof arr);
memset(visited, 0, sizeof visited);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> arr[i][j];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (!visited[i][j]) {
ans.push_back(dfs(i, j, n, m));
}
}
}
sort(ans.begin(), ans.end(), greater<int>());
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010;
const int inf = 1 << 30;
long long ans;
int n;
int v[maxn], rm[maxn], rn[maxn], lm[maxn], ln[maxn], s1[maxn << 1],
s2[maxn << 1];
inline int rd() {
int ret = 0, f = 1;
char gc = getchar();
while (gc < '0' || gc > '9') {
if (gc == '-') f = -f;
gc = getchar();
}
while (gc >= '0' && gc <= '9') ret = ret * 10 + (gc ^ '0'), gc = getchar();
return ret * f;
}
void solve(int l, int r) {
if (l == r) return;
int i, j1, j2, mid = (l + r) >> 1;
solve(l, mid), solve(mid + 1, r);
for (lm[mid + 1] = 0, ln[mid + 1] = inf, i = mid; i >= l; i--)
lm[i] = max(lm[i + 1], v[i]), ln[i] = min(ln[i + 1], v[i]);
for (rm[mid] = 0, rn[mid] = inf, i = mid + 1; i <= r; i++)
rm[i] = max(rm[i - 1], v[i]), rn[i] = min(rn[i - 1], v[i]);
for (i = mid, j1 = j2 = mid + 1; i >= l; i--) {
while (j1 <= r && rn[j1] > ln[i] && rm[j1] < lm[i]) s1[rn[j1] + j1]++, j1++;
while (j2 <= r && rm[j2] < lm[i]) s2[rn[j2] + j2]++, j2++;
if (j1 != mid + 1 && j1 - 1 >= i + lm[i] - ln[i]) ans++;
ans += s2[i + lm[i]] - s1[i + lm[i]];
}
for (i = mid + 1; i <= r; i++) s1[rn[i] + i] = s2[rn[i] + i] = 0;
for (i = mid + 1, j1 = j2 = mid; i <= r; i++) {
while (j1 >= l && ln[j1] > rn[i] && lm[j1] < rm[i])
s1[ln[j1] - j1 + n]++, j1--;
while (j2 >= l && lm[j2] < rm[i]) s2[ln[j2] - j2 + n]++, j2--;
if (j1 != mid && j1 + 1 <= i - (rm[i] - rn[i])) ans++;
ans += s2[rm[i] - i + n] - s1[rm[i] - i + n];
}
for (i = mid; i >= l; i--) s1[ln[i] - i + n] = s2[ln[i] - i + n] = 0;
}
int main() {
n = rd();
int i, a;
for (i = 1; i <= n; i++) a = rd(), v[a] = rd();
solve(1, n);
printf("%lld", ans + n);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 1e6 + 10;
int n, k, F[MAXN], rem, tmp = 0, T = 0, tin[MAXN], tout[MAXN];
string s;
vector<int> adj[MAXN];
bool vis[MAXN];
void dfs(int v) {
vis[v] = true;
tin[v] = T++;
for (int u : adj[v]) dfs(u);
tout[v] = T++;
}
inline bool Check(int ind, int sz) {
if (ind == sz - 1) return true;
ind = F[ind];
return vis[ind] && tin[sz] <= tin[ind] && tout[sz] >= tout[ind];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> s;
if (k == 1) {
for (int i = 0; i < n; i++) cout << 1;
cout << '\n';
return 0;
}
cout << 0;
int t = 0;
for (int i = 1; i < n; i++) {
while (t && s[t] != s[i]) t = F[t - 1];
F[i] = (t += s[t] == s[i]);
if (t) adj[t - 1].push_back(i);
}
for (int i = 0; i < n; i++)
if (!vis[i]) dfs(i);
for (int i = 1; i < n; i++) {
if (i % k == k - 1) {
bool flag = true;
int j = i, p = ((i + 1) / k);
while (j >= p) {
flag &= Check(j, p);
j -= p;
}
if (flag) rem = p + 1, tmp = 0;
}
cout << (rem > 0 && Check(i, tmp) ? 1 : 0);
rem--;
tmp++;
}
cout << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> val(100000 + 5);
struct Gaussian {
long long no_of_bits = 20;
vector<long long> v;
long long set, origsize = 0, redsize = 0;
void push(long long val) {
origsize++;
if (val) v.push_back(val);
}
void clear() {
v.clear();
set = 0, redsize = 0;
}
void eliminate() {
set = redsize = 0;
for (long long bit = 0; bit <= no_of_bits; bit++) {
bool check = false;
for (long long i = redsize; i < v.size(); i++) {
if ((v[i] >> bit) & 1) {
swap(v[i], v[redsize]);
check = true;
break;
}
}
if (check) {
for (long long i = redsize + 1; i < v.size(); i++) {
if ((v[i] >> bit) & 1) v[i] ^= v[redsize];
}
redsize++;
}
}
v.resize(redsize);
for (auto it : v) set |= it;
}
Gaussian& operator=(Gaussian& orig) {
v = orig.v;
set = orig.set;
redsize = orig.redsize;
origsize = orig.origsize;
return *this;
}
};
long long modexpo(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b % 2) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b = b / 2;
}
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, q;
cin >> n >> q;
Gaussian arr[n];
val.resize(n);
for (long long i = 0; i < n; i++) cin >> val[i];
arr[0].push(val[0]);
arr[0].eliminate();
for (long long i = 1; i < n; i++) {
arr[i] = arr[i - 1];
arr[i].push(val[i]);
arr[i].eliminate();
}
while (q--) {
long long l, x;
cin >> l >> x;
Gaussian temp = arr[--l];
temp.push(x);
temp.eliminate();
long long ans = 0;
if (temp.redsize == arr[l].redsize)
ans = modexpo(2, arr[l].origsize - arr[l].redsize);
cout << ans << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int fun(int i, int y, int z);
int main() {
int a, b, c, r, s, x;
cin >> a >> b >> c;
r = abs(a - b) + abs(a - c);
s = abs(b - a) + abs(b - c);
x = abs(c - a) + abs(c - b);
cout << fun(r, s, x);
return 0;
}
int fun(int i, int y, int z) {
if (i < y && i < z) return i;
if (y < i && y < z) return y;
if (z < i && z < y) return z;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.