solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, a[1005];
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", a + i);
sort(a, a + n);
int ub = k, id = -1, ans = 0;
while (id < n - 1) {
int pid = id;
id = upper_bound(a, a + n, ub * 2) - a - 1;
if (id == pid) {
ub *= 2;
ans++;
} else
ub = max(ub, a[id]);
}
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
int a[1000005], p[1000005], L[1000005], R[1000005], n, m, x, t = 2;
long long c[1000005];
void read(int &x) {
char ch;
x = 0;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; x = x * 10 + ch - 48, ch = getchar())
;
}
void dfs(int l, int r, int x) {
if (l > r) return;
dfs(l, x - 1, L[x]), dfs(x + 1, r, R[x]);
c[1] += a[x], c[x - l + 2] -= a[x], c[r - x + 2] -= a[x],
c[r - l + 3] += a[x];
}
int main() {
read(n);
for (int i = 1; i <= n; i++) {
read(a[i]);
for (; m && a[p[m]] > a[i]; m--)
;
R[p[m++]] = i, L[i] = p[m], p[m] = i, p[m + 1] = 0;
}
read(m), dfs(1, n, R[0]);
while (t--)
for (int i = 1; i <= n; i++) c[i] += c[i - 1];
while (m--) read(x), printf("%.9lf\n", c[x] * 1. / (n - x + 1));
return 0;
}
| 17 |
#include <bits/stdc++.h>
unsigned GetMin(unsigned passangers_count,
const std::vector<unsigned>& airplanes) {
unsigned result = 0;
for (std::vector<unsigned>::const_iterator b = airplanes.begin(),
e = airplanes.end();
(b != e) && passangers_count; ++b) {
unsigned places = std::min(passangers_count, *b);
passangers_count -= places;
result += (*b - places + (*b + 1)) * places / 2;
}
return result;
}
unsigned GetMax(unsigned passangers_count,
std::priority_queue<unsigned>& airplanes) {
unsigned result = 0;
while (passangers_count) {
unsigned price = airplanes.top();
result += price;
airplanes.pop();
airplanes.push(price - 1);
--passangers_count;
}
return result;
}
int main() {
unsigned passangers_count = 0;
unsigned airplanes_count = 0;
scanf("%d %d", &passangers_count, &airplanes_count);
std::vector<unsigned> airplanes;
airplanes.reserve(airplanes_count);
for (unsigned i = 0, airplane_capacity = 0; i < airplanes_count; ++i) {
scanf("%d", &airplane_capacity);
airplanes.push_back(airplane_capacity);
}
std::sort(airplanes.begin(), airplanes.end());
std::priority_queue<unsigned> ordered_airplanes(airplanes.begin(),
airplanes.end());
int min = GetMin(passangers_count, airplanes);
int max = GetMax(passangers_count, ordered_airplanes);
printf("%d %d", max, min);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int m, last;
int nxt[400400][26], link[400400], dp[400400], pos[400400];
void extend(int c) {
if (nxt[last][c] && dp[nxt[last][c]] == dp[last] + 1) {
last = nxt[last][c];
return;
}
int x = last, y = last = ++m;
dp[y] = dp[x] + 1;
while (x && !nxt[x][c]) nxt[x][c] = y, x = link[x];
if (!x)
link[y] = 1;
else {
int z = nxt[x][c];
if (dp[z] == dp[x] + 1)
link[y] = z;
else {
int u = ++m;
memcpy(nxt[u], nxt[z], sizeof nxt[u]);
link[u] = link[z], link[z] = link[y] = u;
dp[u] = dp[x] + 1;
while (x && nxt[x][c] == z) nxt[x][c] = u, x = link[x];
}
}
}
int n, q, ans[1001001];
string s[400400];
vector<int> v[400400];
int T, dt[400400], ft[400400];
vector<int> w[400400];
void dfs(int x) {
dt[x] = ++T;
for (int i = 0; i < v[x].size(); i++) dfs(v[x][i]);
ft[x] = T;
}
struct query {
int l, r, p, id;
query(int l = 0, int r = 0, int p = 0, int id = 0)
: l(l), r(r), p(p), id(id) {}
bool operator<(const query &b) const { return p < b.p; }
} Q[1001001];
int sum[400400];
void add(int x) {
while (x <= m) sum[x]++, x += x & -x;
}
int calc(int x) {
int rlt = 0;
while (x) rlt += sum[x], x -= x & -x;
return rlt;
}
int main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) cin >> s[i];
last = ++m;
for (int i = 1; i <= n; i++) {
last = 1;
for (int j = 0; j < s[i].size(); j++) extend(s[i][j] - 'a');
}
for (int x = 1; x <= m; x++)
if (link[x]) v[link[x]].push_back(x);
dfs(1);
for (int i = 1; i <= n; i++) {
int x = 1;
for (int j = 0; j < s[i].size(); j++)
x = nxt[x][s[i][j] - 'a'], w[i].push_back(dt[x]);
pos[i] = x;
}
for (int i = 1; i <= q; i++) {
int l, r, k;
scanf("%d %d %d", &l, &r, &k);
k = pos[k];
Q[i * 2 - 1] = query(dt[k], ft[k], r, i);
Q[i * 2] = query(dt[k], ft[k], l - 1, -i);
}
sort(Q + 1, Q + 2 * q + 1);
for (int i = 1, j = 1; i <= 2 * q; i++) {
while (j <= Q[i].p) {
for (int k = 0; k < w[j].size(); k++) add(w[j][k]);
j++;
}
int tmp = calc(Q[i].r) - calc(Q[i].l - 1);
if (Q[i].id > 0)
ans[Q[i].id] += tmp;
else
ans[-Q[i].id] -= tmp;
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int N = 50;
int n, m, q;
vector<pair<int, int>> fc;
int fn, s, t;
vector<int> e[N + 7], to, fw, co;
void add(int u, int v, int f, int c) {
e[u].push_back(int((to).size())), to.push_back(v), fw.push_back(f),
co.push_back(+c);
e[v].push_back(int((to).size())), to.push_back(u), fw.push_back(0),
co.push_back(-c);
}
int dep[N + 7], p[N + 7], vis[N + 7];
int Bfs() {
for (int i = 1; i <= fn; i++) dep[i] = inf, vis[i] = 0;
queue<int> q;
q.push(s), vis[s] = 1, dep[s] = 0;
while (int((q).size())) {
int u = q.front();
q.pop(), vis[u] = 0;
for (int& v : e[u])
if (fw[v] && dep[to[v]] > dep[u] + co[v]) {
dep[to[v]] = dep[u] + co[v], p[to[v]] = v;
if (!vis[to[v]]) vis[to[v]] = 1, q.push(to[v]);
}
}
return dep[t] < inf;
}
int flow, cost;
void EK() {
while (Bfs()) {
int f = inf;
for (int i = t; i != s; i = to[p[i] ^ 1]) f = min(f, fw[p[i]]);
flow += f, cost += dep[t] * f;
for (int i = t; i != s; i = to[p[i] ^ 1]) fw[p[i]] -= f, fw[p[i] ^ 1] += f;
fc.push_back(make_pair(flow, cost));
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, u, v, w; i <= m; i++)
scanf("%d%d%d", &u, &v, &w), add(u, v, 1, w);
s = 1, t = fn = n, EK();
scanf("%d", &q);
for (int i = 1, first; i <= q; i++) {
scanf("%d", &first);
double res = inf;
for (auto d : fc) res = min(res, double(d.second + first) / d.first);
printf("%.10lf\n", res);
}
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
double binary_search_max();
bool ok(double);
long long k, n;
double EN, EA;
int arr[100000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
}
cout << std::fixed;
cout << std::setprecision(9);
cout << binary_search_max();
return 0;
}
double binary_search_max() {
double low = 0, high = 1e4, mid = 0;
int cnt = 1e3;
while (low < high && cnt--) {
mid = (low + high) / 2.0;
if (ok(mid)) {
low = mid;
} else {
high = mid;
}
}
return mid;
}
bool ok(double ee) {
EN = 0, EA = 0;
for (int i = 0; i < n; ++i) {
if (arr[i] < ee) {
EN += ee - arr[i];
} else if (arr[i] > ee) {
double x = arr[i] - ee;
EA += (x - (x * k / 100.0));
}
}
if (EA >= EN) {
return true;
} else {
return false;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
const long long LB = 0;
const long long RB = (1LL << 60LL) - 1;
vector<tuple<int, long long, long long>> reduced[2];
vector<pair<long long, long long>> all[2][65];
inline void insert(int id, int depth, long long l, long long r, long long qs,
long long qe) {
if (l > qe || r < qs) {
return;
}
all[id][depth].push_back({l, r});
if (l >= qs && r <= qe) {
reduced[id].push_back(make_tuple(depth, l, r));
return;
}
long long mid = (l + r) / 2;
insert(id, depth - 1, l, mid, qs, qe);
insert(id, depth - 1, mid + 1, r, qs, qe);
}
int main() {
int na;
cin >> na;
for (int i = 0; i < na; i++) {
long long l, r;
cin >> l >> r;
insert(0, 60, LB, RB, l, r);
}
int nb;
cin >> nb;
for (int i = 0; i < nb; i++) {
long long l, r;
cin >> l >> r;
insert(1, 60, LB, RB, l, r);
}
vector<pair<long long, long long>> unnormalized;
for (int cur = 0; cur < 2; cur++) {
for (auto [depth, l1, r1] : reduced[cur]) {
for (auto [l2, r2] : all[1 - cur][depth]) {
long long l_res = (l1 ^ l2) & (RB ^ ((1LL << depth) - 1));
long long r_res = l_res + (1LL << depth) - 1;
unnormalized.push_back({l_res, r_res});
}
}
}
assert(unnormalized.size() <= 100 * 100 * 60 * 8);
sort(unnormalized.begin(), unnormalized.end());
vector<pair<long long, long long>> normalized_intervals;
for (auto [l, r] : unnormalized) {
if (normalized_intervals.empty() ||
normalized_intervals.back().second < l) {
normalized_intervals.push_back({l, r});
} else {
normalized_intervals.back().second =
max(normalized_intervals.back().second, r);
}
}
long long sol = 0;
for (auto [l, r] : normalized_intervals) {
long long reduced_r = r % MOD;
long long reduced_l = l % MOD;
sol += (((reduced_r * (reduced_r + 1)) / 2) % MOD);
sol %= MOD;
sol -= (((reduced_l * (reduced_l - 1)) / 2) % MOD);
sol += MOD;
sol %= MOD;
}
cout << sol << endl;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 212345;
struct Seg {
int l, r, lv, rv;
} T[maxn << 2];
vector<int> G[maxn];
int n, q, clk, st[maxn << 1][19], in[maxn], out[maxn], dep[maxn], w[maxn];
void dfs(int u, int p) {
in[u] = ++clk;
st[clk][0] = u;
for (int v : G[u]) {
if (v == p) continue;
dep[v] = dep[u] + 1;
dfs(v, u);
st[++clk][0] = u;
}
out[u] = clk;
}
void rmq_init() {
for (int(i) = (1); (i) <= (clk); (i)++)
for (int(j) = (1); (j) <= (18); (j)++) {
st[i][j] = st[i][j - 1];
int val = i - (1 << j - 1);
if (val > 0 && dep[st[val][j - 1]] < dep[st[i][j]])
st[i][j] = st[val][j - 1];
}
}
inline int rmq(int l, int r) {
int val = floor(log(r - l + 1) / log(2));
int u = st[l + (1 << val) - 1][val], v = st[r][val];
return dep[u] < dep[v] ? u : v;
}
inline int lca(int u, int v) {
if (in[u] > in[v]) swap(u, v);
return rmq(in[u], in[v]);
}
inline bool between(int e1, int e2, int m) {
int a = lca(e1, e2);
return lca(a, m) == a && (lca(e1, m) == m || lca(e2, m) == m);
}
inline pair<int, int> get(const int *buff) {
if (between(buff[0], buff[1], buff[2]) && between(buff[0], buff[1], buff[3]))
return make_pair(buff[0], buff[1]);
if (between(buff[0], buff[2], buff[1]) && between(buff[0], buff[2], buff[3]))
return make_pair(buff[0], buff[2]);
if (between(buff[0], buff[3], buff[1]) && between(buff[0], buff[3], buff[2]))
return make_pair(buff[0], buff[3]);
if (between(buff[1], buff[2], buff[0]) && between(buff[1], buff[2], buff[3]))
return make_pair(buff[1], buff[2]);
if (between(buff[1], buff[3], buff[0]) && between(buff[1], buff[3], buff[2]))
return make_pair(buff[1], buff[3]);
if (between(buff[2], buff[3], buff[0]) && between(buff[2], buff[3], buff[1]))
return make_pair(buff[2], buff[3]);
return make_pair(-1, -1);
}
void maintain(int o) {
int lson = o << 1, rson = o << 1 | 1;
if (T[lson].lv == -1 || T[rson].lv == -1) {
T[o].lv = T[o].rv = -1;
return;
}
if (T[lson].lv == T[lson].rv) {
T[o].lv = T[lson].lv;
T[o].rv = T[rson].lv;
return;
}
int buff[] = {T[lson].lv, T[lson].rv, T[rson].lv, T[rson].rv};
auto tmp = get(buff);
T[o].lv = tmp.first;
T[o].rv = tmp.second;
}
int solve(int o, int &p1, int &p2) {
if (T[o].lv == -1) {
if (T[o].l == T[o].r) return T[o].l - 1;
int flag = solve(o << 1, p1, p2);
return flag == T[o << 1].r ? solve(o << 1 | 1, p1, p2) : flag;
}
int buff[] = {p1, p2, T[o].lv, T[o].rv};
auto check = get(buff);
if (check.first != -1) {
p1 = check.first, p2 = check.second;
return T[o].r;
}
if (T[o].lv == T[o].rv) return T[o].l - 1;
int flag = solve(o << 1, p1, p2);
return flag == T[o << 1].r ? solve(o << 1 | 1, p1, p2) : flag;
}
int query(int o) {
while (T[o].lv == -1) o <<= 1;
pair<int, int> tmp = make_pair(T[o].lv, T[o].rv);
return solve(o | 1, tmp.first, tmp.second);
}
void update(int o, int pos, int u) {
if (T[o].l == T[o].r) {
T[o].lv = T[o].rv = u;
return;
}
int M = T[o].l + T[o].r >> 1;
pos <= M ? update(o << 1, pos, u) : update(o << 1 | 1, pos, u);
maintain(o);
}
void build(int o, int l, int r) {
T[o].l = l, T[o].r = r;
T[o].lv = T[o].rv = -1;
if (l != r) {
int m = l + r >> 1;
build(o << 1, l, m);
build(o << 1 | 1, m + 1, r);
}
}
int main() {
scanf("%d", &n);
build(1, 1, 1 << 18);
for (int(i) = (1); (i) <= (n); (i)++) {
scanf("%d", w + i);
w[i]++;
}
for (int(i) = (2); (i) <= (n); (i)++) {
int d;
scanf("%d", &d);
G[i].push_back(d);
G[d].push_back(i);
}
dfs(1, 0);
rmq_init();
for (int(i) = (1); (i) <= (n); (i)++) update(1, w[i], i);
scanf("%d", &q);
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int i, j;
scanf("%d%d", &i, &j);
update(1, w[i], j);
update(1, w[j], i);
swap(w[i], w[j]);
} else {
printf("%d\n", query(1));
}
}
}
| 21 |
#include <bits/stdc++.h>
char str[200005];
int main() {
int n;
scanf("%d", &n);
scanf("%s", str);
int sum = 0;
for (int i = 0; i < n; i++) {
if (str[i] == '<') {
sum++;
} else
break;
}
for (int i = n - 1; i >= 0; i--) {
if (str[i] == '>') {
sum++;
} else
break;
}
printf("%d\n", sum);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
set<pair<int, int>> seg[4 * MAXN];
int tx[MAXN], ty[MAXN], x[MAXN], y[MAXN], qt[MAXN];
void ins(int qv, int xl = 0, int xr = MAXN, int id = 0) {
if (tx[qv] >= xr || tx[qv] < xl) return;
seg[id].insert({ty[qv], qv});
if (xr - xl == 1) return;
int mid = (xl + xr) / 2;
ins(qv, xl, mid, 2 * id + 1);
ins(qv, mid, xr, 2 * id + 2);
}
void del(int qv, int xl = 0, int xr = MAXN, int id = 0) {
if (tx[qv] >= xr || tx[qv] < xl) return;
seg[id].erase({ty[qv], qv});
if (xr - xl == 1) return;
int mid = (xl + xr) / 2;
del(qv, xl, mid, 2 * id + 1);
del(qv, mid, xr, 2 * id + 2);
}
vector<int> res, xs;
void get(int qv, int xl = 0, int xr = MAXN, int id = 0) {
if (xl >= qv) return;
if (xr <= qv) {
set<pair<int, int>>::iterator it = seg[id].lower_bound({qv + 1, 0});
for (; it != seg[id].end(); it++) res.push_back(it->second);
return;
}
int mid = (xl + xr) / 2;
get(qv, xl, mid, 2 * id + 1);
get(qv, mid, xr, 2 * id + 2);
}
int p[MAXN];
void merg(int a, int b) {
p[b] += p[a];
p[a] = b;
}
int root(int a) {
if (p[a] < 0) return a;
return p[a] = root(p[a]);
}
int main() {
memset(p, -1, sizeof p);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> qt[i];
cin >> x[i] >> y[i];
if (qt[i] == 1) xs.push_back(x[i]), xs.push_back(y[i]);
}
sort(xs.begin(), xs.end());
xs.resize(unique(xs.begin(), xs.end()) - xs.begin());
int cnt = 1;
for (int i = 0; i < n; i++) {
if (qt[i] == 1) {
tx[cnt] = lower_bound(xs.begin(), xs.end(), x[i]) - xs.begin();
ty[cnt] = lower_bound(xs.begin(), xs.end(), y[i]) - xs.begin();
get(tx[cnt]);
get(ty[cnt]);
sort(res.begin(), res.end());
res.resize(unique(res.begin(), res.end()) - res.begin());
for (auto id : res) {
del(id);
tx[cnt] = min(tx[cnt], tx[id]);
ty[cnt] = max(ty[cnt], ty[id]);
merg(id, cnt);
}
res.clear();
ins(cnt);
cnt++;
} else {
x[i] = root(x[i]);
y[i] = root(y[i]);
if (tx[y[i]] < tx[x[i]] && tx[x[i]] < ty[y[i]])
cout << "YES\n";
else if (tx[y[i]] < ty[x[i]] && ty[x[i]] < ty[y[i]])
cout << "YES\n";
else if (tx[y[i]] == tx[x[i]] && ty[x[i]] == ty[y[i]] &&
p[x[i]] + p[y[i]] < -2)
cout << "YES\n";
else if (y[i] == x[i])
cout << "YES\n";
else
cout << "NO\n";
}
}
}
| 22 |
#include <bits/stdc++.h>
char map[10][10];
struct Q {
int x, y;
} q[100000];
int l, r;
bool mark[10][10];
bool judge(int xx, int yy) {
if (xx < 0 || yy < 0 || xx >= 8 || yy >= 8 || map[xx][yy] == 'S') return 0;
if (mark[xx][yy]) return 0;
xx--;
if (xx < 0 || yy < 0 || xx >= 8 || yy >= 8 || map[xx][yy] == 'S') return 0;
return 1;
}
int main() {
while (scanf("%s", map[7]) != EOF) {
for (int i = 6; i >= 0; i--) scanf("%s", map[i]);
memset(mark, 0, sizeof(mark));
l = 0;
r = 0;
mark[0][0] = 1;
q[r].x = 0, q[r].y = 0;
r++;
while (l < r) {
int x0, y0;
x0 = q[l].x, y0 = q[l].y;
l++;
int x1, y1;
for (int dx = 0; dx <= 2; dx++)
for (int dy = -1; dy <= 1; dy++) {
x1 = x0 + dx, y1 = y0 + dy;
if (judge(x1, y1)) {
q[r].x = x1, q[r].y = y1;
mark[x1][y1] = 1;
r++;
}
}
}
bool ans = 0;
for (int i = 0; i < 8; i++) {
if (mark[7][i] == 1 && map[7][i] != 'S') {
ans = 1;
break;
}
}
if (ans)
printf("WIN\n");
else
printf("LOSE\n");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int dp[501][501];
int main() {
int n, i, j, k;
vector<int> vec;
scanf("%d", &n);
for (i = 0; i < n; i++) {
int x;
scanf("%d", &x);
vec.push_back(x);
}
for (i = 0; i < n; i++) dp[i][i] = 1;
for (j = 1; j < n; j++) {
for (i = 0; i + j < n; i++) {
if (vec[i] == vec[i + j])
dp[i][i + j] = dp[i + 1][i + j - 1] + (j == 1);
else
dp[i][i + j] = 1 + min(dp[i + 1][i + j], dp[i][i + j - 1]);
for (k = i; k < i + j; k++) {
dp[i][i + j] = min(dp[i][i + j], dp[i][k] + dp[k + 1][i + j]);
}
}
}
printf("%d\n", dp[0][n - 1]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
const int N = 1 << 12;
int k, n, a[N], p[N], q[N], r[N];
void do_xor(int x, int y, int z) {
int t = r[p[x] ^ z];
if (t == x) return;
if (t == y) {
std::swap(p[x], p[y]);
r[p[x]] = x, r[p[y]] = y;
return;
}
std::swap(p[x], p[t]);
r[p[x]] = x, r[p[t]] = t;
std::swap(q[y], q[t]);
do_xor(t, y, z ^ q[y] ^ q[t]);
}
int main() {
assert(scanf("%d", &k) == 1);
n = 1 << k;
for (int i = 0; i < n; ++i) assert(scanf("%d", &a[i]) == 1);
for (int i = 0; i < n; ++i) p[i] = q[i] = r[i] = i;
for (int i = n; i--;) {
do_xor(i - 1, i, a[i]);
a[i - 1] ^= a[i];
}
if (a[0] == 0) {
puts("Shi");
for (int i = 0; i < n; ++i) printf("%d%c", p[i], i + 1 == n ? '\n' : ' ');
for (int i = 0; i < n; ++i) printf("%d%c", q[i], i + 1 == n ? '\n' : ' ');
} else {
puts("Fou");
}
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
long long A[300001];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
long long n, k, mx = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> A[i];
mx = max(mx, A[i]);
}
sort(A + 1, A + n + 1);
long long l = mx, h = 10000000000000;
while (l < h) {
long long m = (l + h) / 2, j = 1, c = 0;
for (long long i = n; i >= j;) {
if (i == j) {
c++;
break;
}
if (A[i] + A[j] <= m) {
c++;
i--;
j++;
} else {
c++;
i--;
}
}
if (c <= k)
h = m;
else
l = m + 1;
}
cout << h << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 222;
int n, x, k;
int a[N];
long long dp[N][N];
void Input() {
cin >> n >> k >> x;
for (int i = 1; i <= n; i++) cin >> a[i];
}
void maximize(long long &a, long long b) { a = max(a, b); }
void Output() {
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= x; j++) {
for (int ii = max(0, i - k); ii < i; ii++) {
if (dp[ii][j - 1] != -1) maximize(dp[i][j], dp[ii][j - 1] + 1LL * a[i]);
}
}
}
long long ans = -1;
for (int i = n - k + 1; i <= n; i++) maximize(ans, dp[i][x]);
cout << ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
Input();
Output();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
long double l, r, k;
cin >> l >> r >> k;
bool any = false;
for (long double kk = 1; kk <= r; kk *= k)
if (kk >= l) {
cout << std::fixed << setprecision(0) << kk << " ";
any = true;
}
if (!any) cout << -1;
cout << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
;
string s;
cin >> s;
int a = 0, b = 1;
for (int i = 0; i < int(s.size()); i++)
if (s[i] == '1')
a = min(a, b) + 1;
else
b = min(a, b) + 1;
cout << a;
return 0;
}
| 11 |
#include <bits/stdc++.h>
#include <math.h>
using namespace std;
#define ll long long int
inline double round( double val )
{
if( val < 0 ) return ceil(val - 0.5);
return floor(val + 0.5);
}
ll mod=1e9+7;
ll mul(ll a,ll b)
{
return ((a%mod)*(b%mod))%mod;
}
ll add(ll a,ll b)
{
return ((a%mod)+(b%mod))%mod;
}
ll sub(ll a,ll b)
{
return ((a%mod)-(b%mod)+mod)%mod;
}
ll po(ll a, ll b)
{
if(b==0)
{
return 1;
}
ll t=po(a,b/2);
if(b%2)
{
return mul(t,mul(t,a));
}
else
{
return mul(t,t);
}
}
vector<ll> v;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll o=2;
while(o<100)
{
v.push_back(o);
o*=2;
}
ll t;
cin>>t;
while(t--)
{
ll n;
cin>>n;
ll a[n];
ll out=0;
for(ll i=0;i<n;i++)
{
cin>>a[i];
if(i)
{
ll s=(max(a[i],a[i-1])+min(a[i],a[i-1])-1)/(min(a[i],a[i-1]));
if(s>2)
{
auto it=lower_bound(v.begin(),v.end(),s);
out+=(it-v.begin());
}
}
//cout<<out<<"\n";
}
cout<<out<<"\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 7, maxm = 5e6 + 7;
struct Node {
int h[maxm], e[maxm], ne[maxm], cnt;
void add(int u, int v) {
e[++cnt] = v;
ne[cnt] = h[u];
h[u] = cnt;
}
} G1, G2;
char s[100010][60];
int sk[maxm], dfn[maxm], low[maxm], clock_dfs;
int dp[maxm], sz[maxm], unicom[maxm], vis[maxm], top, scc;
void tarjan(int u) {
vis[u] = 1, sk[++top] = u;
dfn[u] = low[u] = ++clock_dfs;
for (int i = G1.h[u]; i; i = G1.ne[i]) {
int v = G1.e[i];
if (!dfn[v]) {
tarjan(v);
low[u] = min(low[u], low[v]);
} else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
++scc;
int t;
do {
t = sk[top];
vis[t] = 0;
unicom[t] = scc;
top--;
} while (t != u);
}
}
int dfs(int u) {
if (dp[u]) return dp[u];
int ans = 0;
for (int i = G2.h[u]; i; i = G2.ne[i]) {
int v = G2.e[i];
ans = max(ans, dfs(v));
}
dp[u] = sz[u] + ans;
return dp[u];
}
void solve() {
int n, m, d;
scanf("%d%d%d", &n, &m, &d);
int tot = n * d;
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
for (int j = 0; j < d; j++) {
G1.add(((u - 1) * d + j + 1), ((v - 1) * d + (j + 1) % d + 1));
}
}
for (int i = 1; i <= n; i++) scanf("%s", s[i]);
for (int i = 1; i <= tot; i++)
if (!dfn[i]) tarjan(i);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < d; j++) {
int u = ((i - 1) * d + j + 1);
if (s[i][j] == '1' && vis[unicom[u]] != i)
vis[unicom[u]] = i, sz[unicom[u]]++;
for (int k = G1.h[u]; k; k = G1.ne[k]) {
int v = G1.e[k];
if (unicom[u] != unicom[v]) G2.add(unicom[u], unicom[v]);
}
}
}
cout << dfs(unicom[1]) << endl;
return;
}
int main() {
solve();
return 0;
}
| 17 |
#include <bits/stdc++.h>
int main() {
int n1, n2 = 0, n3 = 0;
std::vector<int> v1(101, 0);
for (int i = 0; i < 5; i++) {
std::cin >> n1;
v1[n1]++;
}
for (int i = 0; i < v1.size(); i++) {
if (v1[i] == 2) n2 = std::max(n2, i * 2);
if (v1[i] >= 3) n2 = std::max(n2, i * 3);
}
for (int i = 0; i < v1.size(); i++) n3 += v1[i] * i;
std::cout << n3 - n2;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, p, q, r, s, a, b;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p >> q >> r >> s;
if (s != p)
a = p;
else
a = q;
b = s;
cout << a << ' ' << b << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, m, i, j;
scanf("%d %d", &n, &m);
int ara[m], min = 0, max = 0, t = 0, arr[m];
for (i = 0; i < m; i++) {
scanf("%d", &ara[i]);
}
for (i = 0; i < m; i++) {
arr[i] = ara[i];
}
for (i = 0; i < n; i++) {
t = 0;
for (j = 1; j < m; j++) {
if (ara[t] < ara[j]) t = j;
}
max = max + ara[t];
ara[t]--;
}
t = 1001;
int temp;
for (i = 0; i < n; i++) {
t = 1001;
for (j = 0; j < m; j++) {
if (arr[j] > 0 && arr[j] < t) {
t = arr[j];
temp = j;
}
}
min = min + t;
arr[temp]--;
}
printf("%d %d\n", max, min);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int m;
cin >> m;
if (n == m + 1) {
cout << 0;
for (int i = 0; i < m; ++i) cout << 1 << 0;
} else if ((n + 1) * 2 == m) {
cout << 11;
for (int i = 0; i < n; ++i) cout << 0 << 11;
} else if ((n + 1) * 2 - 1 == m) {
cout << 1;
for (int i = 0; i < n; ++i) cout << 0 << 11;
} else if ((n + 1) * 2 > m && n < m + 1) {
for (int i = 0; i < n; ++i) {
if (m-- > n)
cout << 11 << 0;
else
cout << 1 << 0;
}
} else
cout << -1;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
string s;
cin >> s;
vector<long long int> v;
long long int cnt = 0;
for (int i = 0; i < s.size(); i++) {
if (i != 0 && s[i] != s[i - 1]) {
v.push_back(cnt);
cnt = 1;
} else {
cnt++;
}
}
v.push_back(cnt);
long long int ans = 0;
cnt = 0;
for (int i = 0; i < v.size(); i++) {
if (v[i] == 1) {
cnt++;
} else {
if (v[i] - 1 > cnt) {
ans += cnt;
ans++;
cnt = 0;
} else if (v[i] - 1 == cnt) {
ans += cnt;
cnt = 1;
} else {
ans += v[i] - 1;
cnt -= v[i] - 1;
cnt++;
}
}
}
ans += (cnt + 1) / 2;
cout << ans << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long a, b, c, d;
cin >> a >> b >> c >> d;
long long n = 1005;
if (a == 1 and b == 1 and c == 1 and d == 1) {
cout << endl;
return 0;
}
while (n > 0) {
--n;
if (a == 1 and b == 1 and c == 1 and d == 1) break;
if ((a % 2) == 0 and (b % 2) == 0) {
a /= 2;
b /= 2;
cout << "/";
cout << 1 << endl;
continue;
}
if (b % 2 == 0 and c % 2 == 0) {
b /= 2;
c /= 2;
cout << "/";
cout << 2 << endl;
continue;
}
if (c % 2 == 0 and d % 2 == 0) {
c /= 2;
d /= 2;
cout << "/";
cout << 3 << endl;
continue;
}
if (d % 2 == 0 and a % 2 == 0) {
d /= 2;
a /= 2;
cout << "/";
cout << 4 << endl;
continue;
}
if (a % 2 == 1 and b % 2 == 1 and
((a != 1 and b >= 1) or (a >= 1 and b != 1))) {
a += 1;
b += 1;
cout << "+";
cout << 1 << endl;
continue;
}
if (b % 2 == 1 and c % 2 == 1 and
((b != 1 and c >= 1) or (b >= 1 and c != 1))) {
b += 1;
c += 1;
cout << "+";
cout << 2 << endl;
continue;
}
if (c % 2 == 1 and d % 2 == 1 and
((c != 1 and d >= 1) or (c >= 1 and d != 1))) {
c += 1;
d += 1;
cout << "+";
cout << 3 << endl;
continue;
}
if (d % 2 == 1 and a % 2 == 1 and
((d != 1 and a >= 1) or (d >= 1 and a != 1))) {
d += 1;
a += 1;
cout << "+";
cout << 4 << endl;
continue;
}
if (a % 2 == 0 and b % 2 == 1 or (a % 2 == 1 and b % 2 == 0)) {
a += 1;
b += 1;
cout << "+" << 1 << endl;
continue;
}
if (b % 2 == 0 and c % 2 == 1 or (b % 2 == 1 and c % 2 == 0)) {
b += 1;
c += 1;
cout << "+" << 2 << endl;
continue;
}
if (c % 2 == 0 and d % 2 == 1 or (c % 2 == 1 and d % 2 == 0)) {
c += 1;
d += 1;
cout << "+" << 3 << endl;
continue;
}
if (d % 2 == 0 and a % 2 == 1 or (a % 2 == 1 and d % 2 == 0)) {
d += 1;
a += 1;
cout << "+" << 4 << endl;
continue;
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
long long a[n];
long long sum = 0;
for (long long i = 0, _n = (n); i < _n; i++) {
cin >> a[i];
sum = sum + a[i];
}
sort(a, a + n);
long long ans = sum;
for (long long i = 1; i < n; i++) {
long long sum2 = sum - a[i];
sum2 = sum2 - a[0];
for (long long j = (1), _b = (sqrt(a[i])); j <= _b; j++) {
long long sum3 = sum2;
long long sum4 = sum2;
if (a[i] % j == 0) {
sum3 = sum3 + (a[i] / j) + (a[0] * j);
long long xx = a[i] / j;
sum4 = sum4 + (a[i] / xx) + (a[0] * xx);
ans = min({ans, sum3, sum4});
}
}
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[111111], b[1111], d[111];
long long j, i, n, m = 0, k, t;
int ans = 0;
int main() {
string s, st;
cin >> st >> s;
sort(s.begin(), s.end());
j = s.size() - 1;
for (i = 0; i < st.size(); i++)
if (st[i] < s[j] && j >= 0) st[i] = s[j--];
cout << st;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200050;
int n, head[N], pre[N << 1], to[N << 1], len[N << 1];
int ok, sta[N], cnt, vis[N], huan[N];
vector<int> hp;
long long mv[N], pv[N], ct[N], dis[N], maxv, ans, tmp;
set<pair<long long, int> > pos, neg;
set<pair<long long, int> >::iterator it, ip;
inline void addedge(int u, int v, int w) {
pre[++cnt] = head[u];
head[u] = cnt, to[cnt] = v;
len[cnt] = w;
}
void dfs(int now, int fa) {
if (ok) return;
if (vis[now]) {
ok = 1;
do {
hp.push_back(sta[cnt]);
huan[sta[cnt]] = 1;
} while (sta[cnt--] != now);
}
vis[now] = 1;
sta[++cnt] = now;
for (int i = head[now]; i; i = pre[i]) {
if (to[i] == fa) continue;
dfs(to[i], now);
if (ok) return;
}
vis[now] = 0, cnt--;
return;
}
void fuc(int now, int fa) {
for (int i = head[now]; i; i = pre[i]) {
int nex = to[i], ln = len[i];
if (huan[nex] || nex == fa) continue;
fuc(nex, now);
if (ln + mv[nex] > mv[now])
pv[now] = mv[now], mv[now] = mv[nex] + ln;
else if (ln + mv[nex] > pv[now])
pv[now] = ln + mv[nex];
}
maxv = max(maxv, mv[now] + pv[now]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
ans += w;
addedge(u, v, w);
addedge(v, u, w);
}
cnt = 0;
dfs(1, -1);
for (int i = 0; i < hp.size(); i++) {
int now = hp[i], nex = hp[(i + 1) % hp.size()];
fuc(now, -1);
for (int j = head[now]; j; j = pre[j])
if (to[j] == nex) ct[i] = len[j];
dis[i + 1] = dis[i] + ct[i];
pos.insert(make_pair(dis[i] + mv[now], i));
neg.insert(make_pair(mv[now] - dis[i], i));
}
for (int i = 0; i < hp.size(); i++) {
long long ret = maxv;
int now = hp[i];
it = pos.end(), ip = neg.end();
it--, ip--;
if (ip->second == it->second) {
it--, ret = max(ret, it->first + ip->first);
it++, ip--, ret = max(ret, it->first + ip->first);
} else
ret = max(ret, it->first + ip->first);
ans = min(ans, ret);
tmp += ct[i];
pos.erase(pos.find(make_pair(dis[i] + mv[now], i)));
neg.erase(neg.find(make_pair(mv[now] - dis[i], i)));
long long ins = dis[hp.size()] - ct[i];
neg.insert(make_pair(mv[now] - ins - tmp, i));
pos.insert(make_pair(mv[now] + ins + tmp, i));
}
printf("%lld\n", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c;
double xx, yy, zz;
while (cin >> a >> b >> c) {
xx = (a + b - c) / 2.0;
yy = (b + c - a) / 2.0;
zz = (c + a - b) / 2.0;
if (ceil(xx) == xx and ceil(yy) == yy and ceil(zz) == zz and xx >= 0 and
yy >= 0 and zz >= 0)
cout << xx << " " << yy << " " << zz << endl;
else
cout << "Impossible" << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long int absdiff(long long int a, long long int b) {
return (a > b) ? a - b : b - a;
}
long long int fast_expo(long long int x, long long int p) {
if (p == 0)
return 1;
else if (p % 2 == 0) {
long long int t = fast_expo(x, p / 2) % 1000000007;
return (t * t) % 1000000007;
} else
return (x * (fast_expo(x, p - 1)) % 1000000007) % 1000000007;
}
long long int gcd(long long int a, long long int b) {
if (a == 0 || b == 0)
return a + b;
else
return gcd(b % a, a);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long int t_c;
t_c = 1;
for (long long int t = 0; t < t_c; ++t) {
long long int n, q;
cin >> n >> q;
map<pair<long long int, long long int>, long long int> M, st;
for (long long int i = 0; i < q; ++i) {
long long int x, y;
cin >> x >> y;
if (st.find(make_pair(x, y)) == st.end()) {
if (st.find(make_pair(3 - x, y)) != st.end()) {
M[make_pair(y, y)] = 1;
}
if (st.find(make_pair(3 - x, y - 1)) != st.end()) {
if (x == 1)
M[make_pair(y, y - 1)] = 1;
else
M[make_pair(y - 1, y)] = 1;
}
if (st.find(make_pair(3 - x, y + 1)) != st.end()) {
if (x == 1)
M[make_pair(y, y + 1)] = 1;
else
M[make_pair(y + 1, y)] = 1;
}
st[make_pair(x, y)] = 1;
} else {
if (M.find(make_pair(y, y)) != M.end()) M.erase(make_pair(y, y));
if (x == 1) {
if (M.find(make_pair(y, y - 1)) != M.end())
M.erase(make_pair(y, y - 1));
if (M.find(make_pair(y, y + 1)) != M.end())
M.erase(make_pair(y, y + 1));
} else {
if (M.find(make_pair(y - 1, y)) != M.end())
M.erase(make_pair(y - 1, y));
if (M.find(make_pair(y + 1, y)) != M.end())
M.erase(make_pair(y + 1, y));
}
st.erase(make_pair(x, y));
}
if (M.size() == 0) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (1e9) + 7;
const int INF = 1e9;
const long long INF64 = 1e18;
const double EPS = 1e-12;
const double PI = acos(-1);
const long long MD = 6235164;
const long long T = 23917;
const int N = 400100;
const int M = 2010;
int n, m, k;
string p, s;
string ans, t;
bool f;
int main() {
ios_base::sync_with_stdio(0);
getline(cin, p);
getline(cin, s);
cin >> k;
n = int((s).size());
m = int((p).size());
for (int i = 0; i < int(k); i++) ans += "1";
int qq = m % k;
for (int u = min(k, n); u > 0; u--) {
int q = (n - (u * (m / k)));
t.clear();
for (int i = 0; i < int(k); i++) t += "0";
int sum = 0, ss = 0;
for (int i = k - 1; i >= 0; i--) {
if (sum == u - q && i >= qq) continue;
bool flag = 1;
int s1 = 0;
for (int j = 0; j < int(m / k + 1); j++) {
int z = k * j + i;
if (z >= m) continue;
int w = u * j + u - sum - 1;
if (w >= n) {
flag = 0;
break;
}
if (s[w] != p[z]) {
flag = 0;
break;
}
s1++;
}
if (flag && s1) {
sum++;
t[i] = '1';
ss += s1;
}
if (sum == u) break;
}
if (sum != u || ss != n) continue;
ans = min(ans, t);
f = 1;
}
if (f)
cout << ans;
else
cout << 0;
return 0;
}
| 16 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
signed main(){
int t,n;cin>>t;
while(t--){
cin>>n;
int r[n+1],c[n+1];
r[0]=1;c[0]=1;
for(int i=1;i<=n;i++){cin>>r[i];}
for(int i=1;i<=n;i++){cin>>c[i];}
sort(r,r+n+1);sort(c,c+n+1);
int cost=0,dr,dc;
for(int i=0;i<n;i++){
dr=r[i+1]-r[i];
dc=c[i+1]-c[i];
if((r[i]+c[i])%2){
cost+=(dr-dc+1)/2;
}
else if(dr==dc)cost+=dr;
else cost+=(dr-dc)/2;
}
cout<<cost<<'\n';
}
} | 12 |
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void _DBG(const char *s, _T x) {
cerr << s << " = " << x << "\n";
}
template <typename _T, typename... args>
void _DBG(const char *s, _T x, args... a) {
while (*s != ',') cerr << *s++;
cerr << " = " << x << ',';
_DBG(s + 1, a...);
}
const int N = 5e5 + 7;
int n, m, par[N], pre[N], post[N], cnt;
bool check[N];
pair<int, int> memo[N];
vector<pair<int, int> > G[N], T[N], edges;
long long ans[N], eans[N];
int Find(int x) {
if (par[x] == x) return x;
return par[x] = Find(par[x]);
}
void Union(int a, int b) { par[Find(a)] = Find(b); }
void dfs(int v, int f = 0) {
pre[v] = ++cnt;
for (auto [u, i] : T[v]) {
if (u != f) {
dfs(u, v);
memo[u] = {v, i};
}
}
post[v] = ++cnt;
}
bool anc(int a, int b) { return pre[a] <= pre[b] && post[b] <= post[a]; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
par[i] = i;
ans[i] = 1;
}
edges.push_back({0, 0});
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
G[a].push_back({b, i});
G[b].push_back({a, i});
edges.push_back({a, b});
}
for (int i = m; i >= 1; i--) {
auto [a, b] = edges[i];
if (Find(a) != Find(b)) {
Union(a, b);
T[a].push_back({b, i});
T[b].push_back({a, i});
} else
check[i] = true;
}
dfs(1);
for (int i = m; i >= 1; i--) {
auto [a, b] = edges[i];
if (!check[i]) {
long long x = ans[a] + ans[b];
ans[a] = ans[b] = x;
eans[i] = x;
} else {
long long x = ans[a] + ans[b];
int mx = 0;
vector<pair<int, int> > pa, pb;
int v = a;
while (!anc(v, b)) {
pa.push_back(memo[v]);
mx = max(mx, memo[v].second);
v = memo[v].first;
}
v = b;
while (!anc(v, a)) {
pb.push_back({v, memo[v].second});
mx = max(mx, memo[v].second);
v = memo[v].first;
}
reverse((pb).begin(), (pb).end());
for (auto p : pb) pa.push_back(p);
bool inc1 = true;
int last1 = 0, ver1 = 0;
for (auto p : pa) {
if (last1 > p.second) inc1 = false;
last1 = p.second;
if (p.second == mx) {
ver1 = p.second;
break;
}
}
bool inc2 = true;
int last2 = 0, ver2 = 0;
reverse((pa).begin(), (pa).end());
for (int i = 0; i < (int)(pa).size(); i++) {
auto p = pa[i];
if (last2 > p.second) inc2 = false;
last2 = p.second;
if (p.second == mx) {
ver2 = p.second;
break;
}
}
if (inc1 && inc2) {
long long aux = x - eans[ver2];
ans[b] = x - eans[ver1];
ans[a] = aux;
eans[i] = x - eans[ver1];
} else {
ans[a] = ans[b] = x;
eans[i] = x;
}
}
}
for (int i = 1; i <= n; i++) cout << ans[i] - 1 << " ";
cout << "\n";
return 0;
}
| 26 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
vector<long long> a, b;
int main() {
cin >> n >> k;
for (long long i = 0; i < n; i++) {
long long f;
cin >> f;
a.push_back(f);
b.push_back(f);
}
long long ans = 0;
for (long long i = 1; i <= n - 1; i++) {
long long sum = a[i] + a[i - 1];
if (sum < k) a[i] += k - sum, ans += k - sum;
}
if (n != 1)
cout << ans << endl;
else
cout << 0 << endl;
for (long long i = 0; i < a.size(); i++) {
cout << a[i] << " ";
}
cout << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int maxm = 310;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
const double eps = 1e-6;
int n, m;
int v[maxn], d[maxn], p[maxn];
int vis[maxn];
vector<int> vans;
queue<int> que;
void gao() {
int i, j;
int sum = 0;
for (j = i + 1; j <= n; j++) {
if (p[j] < 0) {
sum++;
continue;
}
if ((v[i] - (j - i - 1 - sum)) <= 0) break;
p[j] -= v[i] - (j - i - 1 - sum);
}
vans.push_back(i);
}
int main() {
int i, j;
while (scanf("%d", &n) != EOF) {
for (i = 1; i <= n; i++) {
scanf("%d%d%d", &v[i], &d[i], &p[i]);
}
vans.clear();
while (!que.empty()) que.pop();
memset(vis, 0, sizeof(vis));
for (i = 1; i <= n; i++) {
if (p[i] >= 0) {
vans.push_back(i);
int sum = 0;
for (j = i + 1; j <= n; j++) {
if (p[j] < 0) {
sum++;
continue;
}
if ((v[i] - (j - i - 1 - sum)) <= 0) break;
p[j] -= v[i] - (j - i - 1 - sum);
if (p[j] < 0) que.push(j);
}
while (!que.empty()) {
int x = que.front();
que.pop();
for (j = x + 1; j <= n; j++) {
if (p[j] < 0) continue;
p[j] -= d[x];
if (p[j] < 0) que.push(j);
}
}
}
}
printf("%d\n", vans.size());
for (i = 0; i < vans.size(); i++) {
printf("%d ", vans[i]);
}
puts("");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mint;
map<int, string> mstr;
set<int> sint;
int a[500], chk = 1;
int main() {
ios::sync_with_stdio(0);
char str[500];
int k = 0, n, l = 0, i, j, x;
a[k++] = 1;
char c;
while (cin >> c && c != '=') {
if (c == '+') {
a[k++]++;
chk++;
} else if (c == '-') {
a[k++]--;
chk--;
}
str[l++] = c;
}
str[l++] = '=';
cin >> n;
for (i = 0; i < k; i++) {
while (chk < n && a[i] < n && a[i] > 0) chk++, a[i]++;
while (chk > n && a[i] < 0 && a[i] > -n) chk--, a[i]--;
}
if (chk != n)
cout << "Impossible\n";
else {
cout << "Possible\n";
for (i = 0, x = 0; i < l; i++) {
if (str[i] == '?') {
if (a[x] < 0) a[x] = -a[x];
cout << a[x] << " ";
x++;
} else {
cout << str[i];
cout << " ";
}
}
cout << n << "\n";
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
typedef set<int, bool (*)(int, int)> sic;
typedef set<pair<int, int>, bool (*)(pair<int, int>, pair<int, int>)> spic;
typedef set<long long int, bool (*)(long long int, long long int)> slc;
typedef set<pair<long long int, long long int>,
bool (*)(pair<long long int, long long int>,
pair<long long int, long long int>)>
splc;
pair<int, int> operator+(const pair<int, int>& x, const pair<int, int>& y) {
return {x.first + y.first, x.second + y.second};
}
pair<long long int, long long int> operator+(
const pair<long long int, long long int>& x,
const pair<long long int, long long int>& y) {
return {x.first + y.first, x.second + y.second};
}
long long int gcd(long long int a, long long int b) {
return a >= b ? b ? gcd(b, a % b) : a : gcd(b, a);
}
long long int lcm(long long int a, long long int b) {
return a / gcd(a, b) * b;
}
long long int exp(long long int a, long long int b) {
long long int r = 1;
while (b)
r = (1000000007LL +
((long long int)(r) * (long long int)(b & 1 ? a : 1)) % 1000000007LL) %
1000000007LL,
a = (1000000007LL +
((long long int)(a) * (long long int)(a)) % 1000000007LL) %
1000000007LL,
b >>= 1;
return r;
}
long long int fac[500000];
long long int ifac[500000];
void mkfac() {
fac[0] = ifac[0] = 1;
for (int i = (int)(!0); i <= (int)(500000 - 1 - 0); i++)
fac[i] =
(1000000007LL +
((long long int)(fac[i - 1]) * (long long int)(i)) % 1000000007LL) %
1000000007LL,
ifac[i] = exp((fac[i]), 1000000007LL - 2);
}
string out;
long long int T;
unordered_set<int> adj[500000];
long long int DP[500000][3];
long long int A[500000];
int N, M, K;
long long int u, v;
string S;
void process() {
cin >> N >> M;
for (int i = (int)(!0); i <= (int)(N - 0); i++) cin >> A[i];
for (int i = (int)(!0); i <= (int)(N - 0); i++) {
DP[i][0] = max(0LL, DP[i - 1][0]) + A[i];
DP[i][1] = max(0LL, max(DP[i - 1][0], DP[i - 1][1])) + M * A[i];
DP[i][2] = max(0LL, max(DP[i - 1][1], DP[i - 1][2])) + A[i];
v = max(v, max(DP[i][0], max(DP[i][1], DP[i][2])));
}
out += to_string(v), out += "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
T = 1;
for (int t = (int)(!0); t <= (int)(T - 0); t++) process();
cout << out;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll mod = 1e9 + 7;
const ld eps = 1e-9;
const ld PI = acos(-1);
void solve(){
ll n,k;
cin >> n >> k;
vector<pair<ll,ll>> a(n);
for(int i=0;i<n;i++){
cin >> a[i].first >> a[i].second;
}
bool isBad = false;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(abs(a[j].first - a[i].first) + abs(a[j].second - a[i].second) > k){
isBad = true;
}
}
if(!isBad){
cout << 1 << "\n";
return;
}
isBad = false;
}
cout << -1 << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
ll t;
cin >> t;
while(t--)solve();
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
int mult(int x, int y) {
long long int ans, x1 = (long long int)x, y1 = (long long int)y;
ans = (x1 * y1) % 1000000007;
return (int)ans;
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
long long int pow1(long long int a, long long int b) {
long long int ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return ans;
}
int mina(int arr[], int n) {
int x = arr[0], i, pos = 0;
for (i = 1; i < n; i++) {
if (arr[i] < x) {
x = arr[i];
pos = i;
}
}
return x;
}
int maxa(int arr[], int n) {
int x = arr[0], i, pos = 0;
for (i = 1; i < n; i++) {
if (arr[i] > x) {
x = arr[i];
pos = i;
}
}
return x;
}
vector<vector<int> > v, indexa, costs;
int base[200005], ptr;
int chainno, chainind[200005], chainhead[200005], posinbase[200005];
int depth[200005], p[22][200005], otherend[200005], child[200005];
pair<int, int> st[200005 * 6];
int revmap[200005];
vector<pair<int, int> > e;
int w[200005], c[200005];
int endpt1[200005], endpt2[200005];
void build(int low, int high, int pos) {
if (low == high) {
st[pos] = make_pair(base[low], revmap[low]);
return;
}
int mid = (low + high) >> 1;
build(low, mid, 2 * pos);
build(mid + 1, high, 2 * pos + 1);
int lft = st[2 * pos].first, rht = st[2 * pos + 1].first;
if (lft >= rht)
st[pos] = st[2 * pos];
else
st[pos] = st[2 * pos + 1];
}
pair<int, int> rmq(int low, int high, int l, int r, int pos) {
if (high < l || low > r) return make_pair(-INT_MAX, -1);
if (l <= low && r >= high) return st[pos];
int mid = (low + high) >> 1;
pair<int, int> lft = rmq(low, mid, l, r, 2 * pos),
rht = rmq(mid + 1, high, l, r, 2 * pos + 1);
if (lft.first >= rht.first)
return lft;
else
return rht;
}
pair<int, int> query_up(int u1, int v1) {
int uchain, vchain = chainind[v1], ind;
pair<int, int> ans = make_pair(-INT_MAX, -1);
while (true) {
uchain = chainind[u1];
if (uchain == vchain) {
if (u1 == v1) break;
pair<int, int> quer =
rmq(1, ptr - 1, posinbase[v1] + 1, posinbase[u1], 1);
ans = max(ans, quer);
break;
}
ans = max(ans,
rmq(1, ptr - 1, posinbase[chainhead[uchain]], posinbase[u1], 1));
u1 = chainhead[uchain];
u1 = p[0][u1];
}
return ans;
}
int lca(int u1, int v1) {
if (depth[u1] < depth[v1]) swap(u1, v1);
int diff = depth[u1] - depth[v1], i, j;
for (i = 0; i < 22; i++)
if ((diff >> i) & 1) u1 = p[i][u1];
if (u1 == v1) return u1;
for (i = 22 - 1; i >= 0; i--)
if (p[i][u1] != p[i][v1]) {
u1 = p[i][u1];
v1 = p[i][v1];
}
return p[0][u1];
}
pair<int, int> query(int u1, int v1) {
int comm = lca(u1, v1);
return max(query_up(u1, comm), query_up(v1, comm));
}
map<pair<int, int>, int> m1;
void hld(int curnode, int cost, int n, int indx) {
if (chainhead[chainno] == -1) chainhead[chainno] = curnode;
chainind[curnode] = chainno;
posinbase[curnode] = ptr;
revmap[ptr] = indx;
base[ptr++] = cost;
int mxchild = -1, ncost = 0, i, j, cnt = 0, pos1;
for (vector<int>::iterator itr = v[curnode].begin(); itr != v[curnode].end();
itr++) {
int v1 = *itr;
if (v1 != p[0][curnode]) {
if (mxchild == -1 || child[mxchild] < child[v1])
mxchild = v1, ncost = costs[curnode][cnt];
}
cnt++;
}
cnt = 0;
if (mxchild != -1) hld(mxchild, ncost, n, m1[make_pair(curnode, mxchild)]);
for (vector<int>::iterator itr = v[curnode].begin(); itr != v[curnode].end();
itr++) {
int v1 = *itr;
if (v1 != p[0][curnode] && v1 != mxchild) {
chainno++;
hld(v1, costs[curnode][cnt], n, m1[make_pair(curnode, v1)]);
}
cnt++;
}
}
void dfs(int u, int par) {
if (u == 1)
depth[u] = 0;
else
depth[u] = depth[par] + 1;
p[0][u] = par;
child[u] = 1;
int cnt = 0;
for (vector<int>::iterator itr = v[u].begin(); itr != v[u].end(); itr++) {
int v1 = *itr;
if (v1 != par) {
otherend[indexa[u][cnt]] = v1;
dfs(v1, u);
child[u] += child[v1];
}
cnt++;
}
}
int arr1[200005], arr2[200005];
bool mark[200005];
int finda(int i) {
if (arr1[i] == i)
return i;
else
return arr1[i] = finda(arr1[i]);
}
void makeunion(int a, int b) {
int a1 = finda(a);
int a2 = finda(b);
if (arr2[a1] < arr2[a2])
arr1[a1] = a2;
else if (arr2[a2] < arr2[a1])
arr1[a2] = a1;
else {
arr2[a1]++;
arr1[a2] = a1;
}
}
int main() {
int x, y, n, m, i, j, k;
long long int tot;
scanf("%d", &n);
scanf("%d", &m);
for (i = 1; i < m + 1; i++) scanf("%d", &w[i]);
for (i = 1; i < m + 1; i++) scanf("%d", &c[i]);
for (i = 1; i < m + 1; i++) {
scanf("%d", &x);
scanf("%d", &y);
endpt1[i] = x;
endpt2[i] = y;
e.push_back(make_pair(w[i], i));
}
scanf("%lld", &tot);
sort(e.begin(), e.end());
for (i = 1; i < n + 1; i++) {
arr1[i] = i;
arr2[i] = 1;
}
long long int cost = 0;
v.resize(n + 2);
costs.resize(n + 2);
indexa.resize(n + 2);
for (i = 0; i < n + 2; i++) {
chainhead[i] = -1;
for (j = 0; j < 22; j++) p[j][i] = -1;
}
int cn = 0;
vector<int> final;
for (i = 0; i < m; i++) {
pair<int, int> front = e[i];
int u1 = endpt1[front.second], v1 = endpt2[front.second];
int a = finda(u1);
int b = finda(v1);
if (a != b) {
final.push_back(front.second);
v[u1].push_back(v1);
v[v1].push_back(u1);
m1[make_pair(u1, v1)] = front.second;
m1[make_pair(v1, u1)] = front.second;
costs[u1].push_back(front.first);
costs[v1].push_back(front.first);
indexa[u1].push_back(cn);
indexa[v1].push_back(cn++);
mark[front.second] = true;
cost += front.first;
makeunion(endpt1[front.second], endpt2[front.second]);
}
}
dfs(1, -1);
ptr = 1;
chainno = 0;
hld(1, -INT_MAX, n, 0);
build(1, ptr - 1, 1);
for (i = 1; i < 22; i++)
for (j = 0; j < n + 1; j++)
if (p[i - 1][j] != -1) p[i][j] = p[i - 1][p[i - 1][j]];
long long int ans = LLONG_MAX;
pair<int, int> indx = make_pair(-INT_MAX, -INT_MAX);
for (i = 1; i < m + 1; i++) {
if (mark[i]) {
if (cost - (tot / (long long int)c[i]) < ans)
indx = make_pair(-INT_MAX, i);
ans = min(ans, cost - (tot / (long long int)c[i]));
continue;
}
int u1 = endpt1[i], v1 = endpt2[i];
pair<int, int> pra = query(u1, v1);
long long int cost1 = (long long int)pra.first;
int ind = pra.second;
if (w[i] - (int)(tot / c[i]) < (int)cost1) {
if (cost - cost1 + (long long int)w[i] - (tot / c[i]) < ans)
indx = make_pair(i, ind);
ans = min(ans, cost - cost1 + (long long int)w[i] - (tot / c[i]));
}
}
printf("%lld\n", ans);
if (indx.first == -INT_MAX) {
for (i = 0; i < final.size(); i++) {
if (final[i] != indx.second)
printf("%d %d\n", final[i], w[final[i]]);
else
printf("%d %d\n", final[i], w[final[i]] - (int)(tot / c[final[i]]));
}
} else {
for (i = 0; i < final.size(); i++) {
if (final[i] != indx.second)
printf("%d %d\n", final[i], w[final[i]]);
else
printf("%d %d\n", indx.first,
w[indx.first] - (int)(tot / c[indx.first]));
}
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx,avx2,sse,sse2")
using namespace std;
long long fastexp(long long a, long long n, long long nod = LLONG_MAX) {
long long ans = 1;
while (n) {
if (n & 1) ans = (ans * a) % nod;
a = (a * a) % nod;
n >>= 1;
}
return ans;
}
struct node {
int w;
int mst;
int index;
};
bool comp(node &A, node &B) {
if (A.w != B.w) return A.w < B.w;
return A.mst > B.mst;
}
void fun() {
int n, m;
cin >> n >> m;
vector<node> v(m);
vector<pair<int, int>> ans(m);
for (int i = 0; i < m; i++) {
cin >> v[i].w >> v[i].mst;
v[i].index = i;
}
sort(v.begin(), v.end(), comp);
int curnode = 1;
int maker = 3, makel = 1;
for (int i = 0; i < m; i++) {
int a, b;
if (!v[i].mst) {
if (maker > curnode) {
cout << "-1\n";
return;
}
a = maker;
b = makel;
makel--;
if (makel == 0) {
maker++;
makel = maker - 2;
}
} else {
a = curnode;
b = curnode + 1;
curnode++;
}
int ind = v[i].index;
ans[ind].first = a;
ans[ind].second = b;
}
for (int i = 0; i < m; i++) {
cout << ans[i].first << " " << ans[i].second << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(20);
cout << fixed;
int t = 1;
while (t--) {
fun();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
return (b ? __gcd(a, b) : a);
}
template <typename T>
T lcm(T a, T b) {
return (a * (b / gcd(a, b)));
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class T>
ostream &operator<<(ostream &os, set<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class L, class R>
ostream &operator<<(ostream &os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
const int N = 101;
int mu[N], pr[N];
unsigned long long powr(unsigned long long n, unsigned long long p) {
unsigned long long ans = 1;
while (p) {
if (p & 1) {
ans = (ans * n);
}
n = (n * n);
p >>= 1;
}
return ans;
}
void pew() {
for (int i = 1; i < (101); ++i) pr[i] = i;
for (int i = 2; i < (11); ++i) {
if (pr[i] == i) {
for (int j = i * i; j <= 100; j += i) {
pr[j] = i;
}
}
}
mu[1] = 1;
for (int i = 2; i < (101); ++i) {
if ((i / pr[i]) % pr[i]) {
mu[i] = -mu[i / pr[i]];
}
}
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
pew();
int tt;
for (cin >> tt; tt--;) {
unsigned long long n;
cin >> n;
unsigned long long ans = n - 1;
for (int i = 2; i < (61); ++i)
if (mu[i]) {
unsigned long long x = floor(pow(n, 1.0L / i));
if (pow(x + 1, i) <= 1e18 and powr(x + 1, i) <= n) ++x;
ans += mu[i] * (x - 1);
}
cout << ans << '\n';
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int maxint = -1u >> 1;
const double pi = 3.14159265358979323;
const double eps = 1e-8;
int x, a, b, n;
bool num[8];
int main() {
cin >> n;
cin >> x;
cin >> a >> b;
bool ans = true;
x = 7 - x;
for (int i = (0); i < (n - 1); i++) {
cin >> a >> b;
memset(num, false, sizeof(num));
num[a] = num[7 - a] = num[b] = num[7 - b] = true;
int t = -1;
for (int i = 1; i <= 6; i++)
if (i != x && !num[i]) {
if (t != -1) ans = false;
t = i;
}
if (t == -1) ans = false;
x = 7 - t;
}
if (ans)
puts("YES");
else
puts("NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
Point(double x = 0, double y = 0) : x(x), y(y) {}
double x, y;
};
Point first;
Point operator-(const Point& p1, const Point& p2) {
return Point(p1.x - p2.x, p1.y - p2.y);
}
double operator^(const Point& p1, const Point& p2) {
return p1.x * p2.y - p1.y * p2.x;
}
double distanceS(const Point& p1, const Point& p2) {
return pow(p1.x - p2.x, 2.0) + pow(p1.y - p2.y, 2.0);
}
struct CmpXY {
bool operator()(const Point& p1, const Point& p2) {
if (p1.y > p2.y)
return false;
else if (p1.y < p2.y)
return true;
return p1.x < p2.x;
}
};
struct CmpAngle {
bool operator()(const Point& p1, const Point& p2) {
if ((p1 - first) ^ (p2 - first)) return ((p1 - first) ^ (p2 - first)) > 0;
return distanceS(first, p1) < distanceS(first, p2);
}
};
void convexHull(vector<Point>& points, vector<Point>& res) {
vector<Point> points2;
int n = (int)points.size();
sort(points.begin(), points.end(), CmpXY());
int i, j;
for (i = j = 0; i < n;) {
points2.push_back(points[i++]);
while (i < n && !distanceS(points[i - 1], points[i])) ++i;
}
n = (int)points2.size();
first = points2[0];
sort(points2.begin() + 1, points2.end(), CmpAngle());
for (i = j = 1; i < n;) {
++i;
while (i < n && ((points2[i - 1] - first) ^ (points2[i] - first)) == 0) ++i;
points2[j++] = points2[i - 1];
}
n = j;
res.push_back(first);
res.push_back(points2[1]);
res.push_back(points2[2]);
for (int i = 3; i < n; ++i) {
while (((points2[i] - res[res.size() - 2] ^
(res.back() - res[res.size() - 2])) >= 0))
res.pop_back();
res.push_back(points2[i]);
}
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
int n;
cin >> n;
vector<Point> points;
for (int i = (0); i < ((n)); ++i) {
int x, y;
cin >> x >> y;
int const DX[] = {0, 1, 1, 1, 0, -1, -1, -1};
int const DY[] = {-1, -1, 0, 1, 1, 1, 0, -1};
for (int k = (0); k < ((8)); ++k)
if (k % 2 == 0) {
points.push_back(Point(x + DX[k], y + DY[k]));
}
}
vector<Point> hull;
convexHull(points, hull);
int res = 0;
for (int i = (0); i < (((int)hull.size())); ++i) {
Point const& p1 = hull[i];
Point const& p2 = hull[(i + 1) % (int)hull.size()];
int const dx = abs(p1.x - p2.x);
int const dy = abs(p1.y - p2.y);
int moves = min(dx + dy, max(dx, dy));
res += moves;
}
cout << res << endl;
return 0;
}
| 12 |
#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...);
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long x, long long y) { return x / gcd(x, y) * y; }
long long INF = 1e18 + 13;
long double eps = 1e-12;
long double PI = 3.14159265;
const long long MAXN = 4 * 1e6 + 13;
const long long MAXH = 100;
const long long MAXM = 1e5 + 13;
long long MOD;
long long dp[MAXN];
long long pref[2 * MAXN + 2];
void solve() {
long long n;
cin >> n >> MOD;
dp[n] = 1;
pref[n] = 1;
long long summ = 1;
for (long long i = n - 1; i >= 1; i--) {
dp[i] += summ;
dp[i] = dp[i] % MOD;
for (long long j = 2; j * i <= n; j++) {
dp[i] += (pref[i * j] - pref[i * j + j]);
dp[i] = dp[i] % MOD;
}
summ += dp[i];
summ = summ % MOD;
pref[i] = pref[i + 1] + dp[i];
pref[i] = pref[i] % MOD;
}
cout << dp[1];
}
int32_t main() {
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
int main() {
long long i, j, n, m, t, p, cas = 1;
while (scanf("%I64d %I64d %I64d", &n, &m, &p) == 3) {
v.push_back(n);
v.push_back(m);
v.push_back(p);
sort(v.begin(), v.end());
if ((v[0] + v[1]) % 2 == 0)
printf("%I64d\n", v[1]);
else
printf("%I64d\n", v[2]);
v.clear();
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int f[3][3][77977 << 2], a[3][3];
inline void add(int &a, int b) {
a += b;
if (a >= 777777777) a -= 777777777;
}
void up(int id) {
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) f[i][j][id] = 0;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
if (a[i][j]) {
for (int ii = 0; ii < 3; ii++)
if (f[ii][i][id << 1]) {
for (int jj = 0; jj < 3; jj++)
add(f[ii][jj][id],
1LL * f[ii][i][id << 1] * f[j][jj][id << 1 | 1] % 777777777);
}
}
}
void build(int L, int R, int id) {
if (L == R) {
for (int i = 0; i < 3; i++) f[i][i][id] = 1;
return;
}
int md = (L + R) >> 1;
build(L, md, id << 1);
build(md + 1, R, id << 1 | 1);
up(id);
}
void update(int L, int R, int id, int x, int v) {
if (L == R) {
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) f[i][j][id] = 0;
if (v)
f[v - 1][v - 1][id] = 1;
else
for (int i = 0; i < 3; i++) f[i][i][id] = 1;
return;
}
int md = (L + R) >> 1;
if (x <= md)
update(L, md, id << 1, x, v);
else
update(md + 1, R, id << 1 | 1, x, v);
up(id);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
scanf("%d", &a[i][j]);
}
}
build(1, n, 1);
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
update(1, n, 1, x, y);
int rt = 0;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) add(rt, f[i][j][1]);
printf("%d\n", rt);
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
long long a[200001], b[200001];
long long l, r, mid, ans;
int n, m, i, j, k;
int tb;
long long dist(int x, int y) {
if (a[x] > b[y])
return a[x] - b[y];
else
return b[y] - a[x];
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
bool work(long long t) {
tb = 1;
for (i = 1; i <= n; ++i) {
if (dist(i, tb) > t) continue;
if (b[tb] < a[i]) {
j = tb;
while (tb <= m && b[tb] <= a[i]) ++tb;
while (tb <= m && (b[tb] - b[j] + min(dist(i, tb), dist(i, j)) <= t))
++tb;
} else {
while (tb <= m && b[tb] - a[i] <= t) ++tb;
}
if (tb > m) return true;
}
return false;
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) scanf("%I64d", &a[i]);
for (i = 1; i <= m; ++i) scanf("%I64d", &b[i]);
l = 0;
r = 100000000000LL;
ans = r;
while (l <= r) {
mid = (l + r) / 2;
if (work(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%I64d\n", ans);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 200005;
inline int read() {
int x = 0, f = 1;
char c = 0;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c && c <= '9') x = 10 * x + c - '0', c = getchar();
return x * f;
}
struct Matrix {
int m[5][5];
inline int *operator[](int id) { return m[id]; }
inline Matrix operator*(Matrix rsh) {
Matrix ret;
memset(ret.m, 0x3f, sizeof(ret.m));
for (register int i = 0; i < 5; i++)
for (register int k = 0; k < 5; k++)
for (register int j = 0; j < 5; j++)
ret[i][j] = min(ret[i][j], m[i][k] + rsh[k][j]);
return ret;
}
} tr[N << 1], mdl[6];
inline void Pushup(int l, int mid, int r) {
tr[(((l) + (r)) | ((l) != (r)))] =
tr[(((mid + 1) + (r)) | ((mid + 1) != (r)))] *
tr[(((l) + (mid)) | ((l) != (mid)))];
}
void Build(int l, int r) {
if (l == r) {
switch (getchar()) {
case '2':
tr[(((l) + (r)) | ((l) != (r)))] = mdl[1];
break;
case '0':
tr[(((l) + (r)) | ((l) != (r)))] = mdl[2];
break;
case '1':
tr[(((l) + (r)) | ((l) != (r)))] = mdl[3];
break;
case '7':
tr[(((l) + (r)) | ((l) != (r)))] = mdl[4];
break;
case '6':
tr[(((l) + (r)) | ((l) != (r)))] = mdl[5];
break;
default:
tr[(((l) + (r)) | ((l) != (r)))] = mdl[0];
break;
}
return;
}
int mid = (l + r) >> 1;
Build(l, mid);
Build(mid + 1, r);
Pushup(l, mid, r);
}
Matrix Query(int l, int r, int L, int R) {
if (L <= l && r <= R) return tr[(((l) + (r)) | ((l) != (r)))];
int mid = (l + r) >> 1;
if (R <= mid) return Query(l, mid, L, R);
if (L > mid) return Query(mid + 1, r, L, R);
return Query(mid + 1, r, L, R) * Query(l, mid, L, R);
}
void Init() {
memset(mdl[0].m, 0x3f, sizeof(mdl[0].m));
for (int i = 0; i < 5; i++) mdl[0][i][i] = 0;
for (int i = 1; i <= 5; i++) mdl[i] = mdl[0];
mdl[1][0][0] = 1, mdl[1][1][0] = 0;
mdl[2][1][1] = 1, mdl[2][2][1] = 0;
mdl[3][2][2] = 1, mdl[3][3][2] = 0;
mdl[4][3][3] = 1, mdl[4][4][3] = 0;
mdl[5][4][4] = 1, mdl[5][3][3] = 1;
}
int n, q;
int x, y;
int main() {
Init();
n = read();
q = read();
Build(1, n);
Matrix tmp;
while (q--) {
x = read(), y = read();
tmp = Query(1, n, x, y);
if (tmp[4][0] > (y - x + 1))
puts("-1");
else
printf("%d\n", tmp[4][0]);
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int NAX = 2e5 + 5, MOD = 1000000007;
void solveCase() {
int n, m;
cin >> n >> m;
vector<vector<int>> a(n, vector<int>(m));
vector<vector<int>> b(n, vector<int>(m));
int cnta = 0, cntb = 0;
for (auto &x : a)
for (auto &y : x) {
cin >> y;
cnta += y;
}
for (auto &x : b)
for (auto &y : x) {
cin >> y;
cntb += y;
}
if (n == 1 || m == 1) {
for (size_t i = 0; i < n; i++) {
for (size_t j = 0; j < m; j++) {
if (a[i][j] != b[i][j]) {
cout << "NO\n";
return;
}
}
}
cout << "YES\n";
return;
};
for (size_t i = 0; i < n; i++) {
int meowa = 0, meowb = 0;
for (size_t j = 0; j < m; j++) {
meowa += a[i][j];
meowb += b[i][j];
}
if ((meowa & 1) != (meowb & 1)) {
cout << "NO\n";
return;
}
}
for (size_t j = 0; j < m; j++) {
int meowa = 0, meowb = 0;
for (size_t i = 0; i < n; i++) {
meowa += a[i][j];
meowb += b[i][j];
}
if ((meowa & 1) != (meowb & 1)) {
cout << "NO\n";
return;
}
}
if ((cnta & 1) == (cntb & 1)) {
cout << "YES\n";
} else
cout << "NO\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
for (int i = 1; i <= t; ++i) solveCase();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int const N = 26;
int main() {
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec[i];
}
string str;
cin >> str;
long long cnt = 0, tmp = 0;
map<long long, long long> m[N];
for (int i = 0; i < (int)str.size(); i++) {
int chr = str[i] - 'a';
cnt += m[chr][tmp];
tmp += vec[chr];
m[chr][tmp]++;
}
cout << cnt << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
const int MOD = 1000000007;
const int MAXN = 300010;
struct State {
ll s00, s01, s10, s11;
State() {}
State(ll a, ll b, ll c, ll d) {
s00 = a;
s01 = b;
s10 = c;
s11 = d;
}
};
int v[MAXN];
int n;
State tree[4 * MAXN];
State solve(int node, int i, int j) {
if (i == j) return tree[node] = State(0, v[i], -v[i], 0);
int mid = (i + j) / 2;
auto l = solve(node * 2, i, mid);
auto r = solve(node * 2 + 1, mid + 1, j);
return tree[node] = State(max(l.s00 + r.s00, l.s01 + r.s10),
max(l.s01 + r.s11, l.s00 + r.s01),
max(l.s10 + r.s00, l.s11 + r.s10),
max(l.s11 + r.s11, l.s10 + r.s01));
}
void update(int node, int i, int j, int idx) {
if (i == j) {
tree[node] = State(0, v[i], -v[i], 0);
return;
}
int mid = (i + j) / 2;
if (idx <= mid)
update(node * 2, i, mid, idx);
else
update(node * 2 + 1, mid + 1, j, idx);
auto l = tree[node * 2], r = tree[node * 2 + 1];
tree[node] = State(
max(l.s00 + r.s00, l.s01 + r.s10), max(l.s01 + r.s11, l.s00 + r.s01),
max(l.s10 + r.s00, l.s11 + r.s10), max(l.s11 + r.s11, l.s10 + r.s01));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tests = 1;
cin >> tests;
while (tests--) {
int q;
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> v[i];
}
auto ans = solve(1, 0, n - 1);
cout << max(ans.s00, ans.s01) << '\n';
while (q--) {
int l, r;
cin >> l >> r;
l--;
r--;
swap(v[l], v[r]);
update(1, 0, n - 1, l);
update(1, 0, n - 1, r);
ans = tree[1];
cout << max(ans.s00, ans.s01) << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const long double eps = 1e-22;
struct point {
long double x, y;
int s, r;
point(long double x = 0, long double y = 0) : x(x), y(y) {}
inline point operator-(const point &p) const {
return point(x - p.x, y - p.y);
}
inline long double operator*(const point &p) const {
return x * p.y - y * p.x;
}
inline bool operator<(const point &p) const {
return s > p.s || (s == p.s && r > p.r);
}
};
inline int convex(int n, point p[], point q[]) {
if (n < 3) {
memcpy(q, p, sizeof(point) * n);
return n;
} else {
int c;
sort(p, p + n);
for (int i = c = 0; i < n; q[c++] = p[i++]) {
for (; c > 1 && (q[c - 1] - q[c - 2]) * (p[i] - q[c - 1]) < 0 - eps; --c)
;
}
for (int i = n - 2, j = c; i >= 0; q[c++] = p[i--]) {
for (; c > j && (q[c - 1] - q[c - 2]) * (p[i] - q[c - 1]) < 0 - eps; --c)
;
}
return c - 1;
}
}
int n, s[N], r[N];
point p[N], q[N];
map<pair<int, int>, vector<int> > mp;
int find(point &x) {
for (int i = 0; i < n; ++i) {
if (x * (q[i + 1] - q[i]) > 0 + eps &&
(q[i] - q[(i + n - 1) % n]) * x > 0 - eps)
return i;
}
}
int find2(point &x) {
for (int i = 0; i < n; ++i) {
if (x * (q[i + 1] - q[i]) > 0 - eps &&
(q[i] - q[(i + n - 1) % n]) * x > 0 + eps)
return i;
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d", s + i, r + i);
mp[make_pair(s[i], r[i])].push_back(i + 1);
}
n = 0;
for (auto &t : mp) {
p[n].x = 1.0 / t.first.first;
p[n].y = 1.0 / t.first.second;
p[n].s = t.first.first;
p[n].r = t.first.second;
n++;
}
n = convex(n, p, q);
point a(0, -1), b(1, 0);
int bg = find(a);
int ed = find2(b);
if (ed < bg) ed += n;
if (n == 1 || n == 2) {
bg = 0, ed = n - 1;
}
vector<int> v;
for (int i = bg; i <= ed; ++i) {
auto t = make_pair(q[i % n].s, q[i % n].r);
for (int j : mp[t]) {
v.push_back(j);
}
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); ++i) {
printf("%d%c", v[i], " \n"[i == (int)v.size() - 1]);
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
struct T {
int x, in, r;
};
int n;
T target[10005];
bool conf(T left, T right) { return left.x < right.x; }
int lb(int val) {
int left, right, pivot;
left = 0;
right = n - 1;
while (left <= right) {
pivot = (left + right) / 2;
if (target[pivot].x == val)
return pivot;
else if (target[pivot].x < val)
left = pivot + 1;
else
right = pivot - 1;
}
return pivot;
}
int main() {
int m, sx, sy, index, cnt, ans[10005], range, res;
scanf("%d", &n);
for (int i = 0; i <= n - 1; i++) {
scanf("%d %d", &target[i].x, &target[i].r);
target[i].in = i;
ans[i] = -1;
}
sort(target, target + n, conf);
scanf("%d", &m);
cnt = 0;
for (int i = 1; i <= m; i++) {
scanf("%d %d", &sx, &sy);
index = lb(sx);
res = ((sx - target[index].x) * (sx - target[index].x)) + (sy * sy);
range = (int)ceil(sqrt(res));
if ((range <= target[index].r) && (ans[target[index].in] == -1)) {
ans[target[index].in] = i;
cnt++;
}
if (index - 1 >= 0) {
res =
((sx - target[index - 1].x) * (sx - target[index - 1].x)) + (sy * sy);
range = (int)ceil(sqrt(res));
if ((range <= target[index - 1].r) && (ans[target[index - 1].in] == -1)) {
ans[target[index - 1].in] = i;
cnt++;
}
}
if (index + 1 <= n - 1) {
res =
((sx - target[index + 1].x) * (sx - target[index + 1].x)) + (sy * sy);
range = (int)ceil(sqrt(res));
if ((range <= target[index + 1].r) && (ans[target[index + 1].in] == -1)) {
ans[target[index + 1].in] = i;
cnt++;
}
}
}
printf("%d\n", cnt);
for (int i = 0; i <= n - 1; i++) printf("%d ", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int dp[2][1010];
int main() {
int i, y;
int tmp;
scanf("%d%d", &n, &m);
memset(dp, 0, sizeof(dp));
for (i = 1; i <= n; i++) {
scanf("%d", &tmp);
tmp = tmp % m;
memset(dp[i & 1], 0, sizeof(dp[1]));
dp[i & 1][tmp] = 1;
for (y = 0; y < m; y++) {
if (dp[(i + 1) & 1][y]) {
dp[i & 1][y] = 1;
dp[i & 1][(y + tmp) % m] = 1;
}
}
if (dp[i & 1][0] == 1) {
printf("YES\n");
return 0;
}
}
printf("NO\n");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, e, f;
const int maxn = 101000;
int bio[maxn];
int bio2[maxn];
int main() {
scanf("%d%d%d", &a, &b, &c);
for (int i = 0; i < a; ++i) {
scanf("%d", &d);
bio[i] = d;
}
for (int i = 0; i < b; ++i) {
scanf("%d", &d);
bio2[i] = d;
}
if (a > b) {
printf("YES\n");
return 0;
}
sort(bio, bio + a);
sort(bio2, bio2 + b);
--a, --b;
while (a >= 0) {
if (bio2[b] < bio[a]) {
printf("YES\n");
return 0;
}
a--;
b--;
}
printf("NO");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h = (1 << 4) - 1;
long long n;
cin >> n;
long long ans = 0;
for (int i = 0; i <= h; i++) {
long long cur = 1;
int c = 0;
if (i & 1) cur *= 2, c++;
if (i & 2) cur *= 3, c++;
if (i & 4) cur *= 5, c++;
if (i & 8) cur *= 7, c++;
if (c & 1) {
ans -= (n / cur);
} else {
ans += (n / cur);
}
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char s[100][100], str[100];
int vis[100], k, cha, b[100], n;
void dfs(int wei) {
int i, j, minx = 99999999, maxx = -99999999, num;
if (wei == k + 1) {
for (i = 1; i <= n; i++) {
num = 0;
for (j = 1; j <= k; j++) {
num = num * 10 + s[i][b[j]] - '0';
}
maxx = max(maxx, num);
minx = min(minx, num);
}
cha = min(cha, maxx - minx);
} else {
for (i = 1; i <= k; i++) {
if (!vis[i]) {
vis[i] = 1;
b[wei] = i;
dfs(wei + 1);
vis[i] = 0;
}
}
}
}
int main() {
int m, i, j, t, num;
char c;
while (scanf("%d%d", &n, &k) != EOF) {
for (i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
}
cha = 99999999;
if (n == 1) {
printf("0\n");
continue;
}
memset(vis, 0, sizeof(vis));
dfs(1);
printf("%d\n", cha);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long double deg[10010], length[10010], nowdeg;
const long double pi = acos(-1.);
int n, q, t1 = 1, t2 = 2;
struct node {
long double x, y;
long double operator*(node a) { return x * a.y - y * a.x; }
node operator+(node a) { return (node){x + a.x, y + a.y}; }
node operator-(node a) { return (node){x - a.x, y - a.y}; }
node operator/(long double tem) { return (node){x / tem, y / tem}; }
node operator*(long double tem) { return (node){x * tem, y * tem}; }
} Pos[10010], center;
long double cross(node a, node b, node c) { return (b - a) * (c - a); }
node getpos(int x) {
long double Deg = deg[x] + nowdeg;
while (Deg >= pi * 2.) Deg -= pi * 2.;
while (Deg <= -pi * 2.) Deg += pi * 2.;
return (node){center.x + length[x] * sin(Deg),
center.y + length[x] * cos(Deg)};
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%Lf%Lf", &Pos[i].x, &Pos[i].y);
long double sum = 0.;
for (int i = 3; i <= n; i++) {
long double area = cross(Pos[1], Pos[i - 1], Pos[i]);
sum += area;
center = center + (Pos[i - 1] + Pos[i] - (Pos[1] * 2.)) / 3. * area;
}
center = (center / sum) + Pos[1];
for (int i = 1; i <= n; i++) {
long double a = Pos[i].x - center.x, b = Pos[i].y - center.y,
c = sqrt(a * a + b * b);
deg[i] = std::acos(fabs(b) / c);
if (a < 0. && b > 0.) deg[i] = -deg[i];
if (a < 0. && b < 0.) deg[i] = deg[i] - pi;
if (a > 0. && b < 0.) deg[i] = -deg[i] - pi;
if (fabs(b) == c && b < 0.) deg[i] = pi;
length[i] = c;
while (deg[i] >= pi * 2.) deg[i] -= pi * 2.;
while (deg[i] <= -pi * 2.) deg[i] += pi * 2.;
}
nowdeg = 0.;
for (int i = 1, opt, f, t; i <= q; i++) {
scanf("%d", &opt);
if (opt == 1) {
scanf("%d%d", &f, &t);
if (t1 == f) t1 ^= t2 ^= t1 ^= t2;
center = getpos(t1);
nowdeg = -deg[t1];
center.y -= length[t1];
t2 = t;
} else {
scanf("%d", &f);
auto x = getpos(f);
std::cout << std::setprecision(11) << x.x << ' ' << x.y << std::endl;
}
}
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long w, h, k;
cin >> w >> h >> k;
long long ans = 0;
for (long long i = 0; i < k; i++) {
ans = ans + 2 * w + 2 * h - 4;
w = w - 4;
h = h - 4;
}
cout << ans;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
int n, a, b;
cin >> n >> a >> b;
string s = "abcdefghijklmnopqrstuvwxyz";
for (int i = 0; i < n; i++) {
cout << s[i % b];
}
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> has;
map<int, vector<int> > lst;
set<int> st;
int main() {
int N;
scanf("%d", &N);
int cnt = 0;
for (int i = 0; i < N; i++) {
int x;
scanf("%d", &x);
set<int>::iterator it = st.lower_bound(x);
if (it == st.begin()) {
cnt++;
has[x] = cnt;
lst[cnt].push_back(x);
st.insert(x);
} else {
it--;
int y = *it;
int c = has[y];
has[x] = c;
lst[c].push_back(x);
st.erase(it);
st.insert(x);
}
}
map<int, vector<int> >::iterator it;
for (it = lst.begin(); it != lst.end(); it++) {
vector<int> res = it->second;
for (int i = 0; i < res.size(); i++) {
printf("%d ", res[i]);
}
printf("\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, t, c;
string arr[1010];
vector<char> ans;
char di;
vector<pair<char, int> > op;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) cin >> arr[i];
scanf("%d", &k);
while (k--) {
scanf(" %c %d", &di, &t);
op.push_back(make_pair(di, t));
}
int num[n][m][4];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < 4; k++) num[i][j][k] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 1; j < m; j++) {
if (arr[i][j] != '#' && arr[i][j - 1] != '#')
num[i][j][0] += (num[i][j - 1][0] + 1);
}
for (int j = m - 2; j >= 0; j--) {
if (arr[i][j] != '#' && arr[i][j + 1] != '#')
num[i][j][1] += (num[i][j + 1][1] + 1);
}
}
for (int j = 0; j < m; j++) {
for (int i = 1; i < n; i++) {
if (arr[i][j] != '#' && arr[i - 1][j] != '#')
num[i][j][2] += (num[i - 1][j][2] + 1);
}
for (int i = n - 2; i >= 0; i--) {
if (arr[i][j] != '#' && arr[i + 1][j] != '#')
num[i][j][3] += (num[i + 1][j][3] + 1);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] != '#' && arr[i][j] != '.') {
bool flag = false;
int x = i, y = j;
for (int k = 0; k < (int)op.size(); k++) {
di = op[k].first;
t = op[k].second;
if (di == 'W' && num[x][y][0] >= t)
y -= t;
else if (di == 'E' && num[x][y][1] >= t)
y += t;
else if (di == 'N' && num[x][y][2] >= t)
x -= t;
else if (di == 'S' && num[x][y][3] >= t)
x += t;
else {
flag = true;
break;
}
}
if (!flag) ans.push_back(arr[i][j]);
}
}
}
if (ans.size() == 0)
printf("no solution\n");
else {
sort(ans.begin(), ans.end());
for (int i = 0; i < (int)ans.size(); i++) cout << ans[i];
cout << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void io() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
long long n, m, t, num;
int k;
map<pair<long long, long long>, int> mp;
struct Point {
long long x, y;
int num;
bool flag = false;
};
Point p[200007], ch[200007], tp[200007];
bool cmp(Point a, Point b) {
if (a.x == b.x)
return a.y < b.y;
else
return a.x < b.x;
}
long long cross(Point a, Point b, Point c) {
return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
}
int andrew(Point p[], Point ch[], long long n) {
sort(p + 1, p + n + 1, cmp);
long long top = 0;
for (int i = 1; i <= n; ++i) {
while ((top > 1) && (cross(ch[top - 1], ch[top], p[i]) <= 0)) --top;
ch[++top] = p[i];
}
long long tmp = top;
for (int i = n - 1; i; --i) {
while ((top > tmp) && (cross(ch[top - 1], ch[top], p[i]) <= 0)) --top;
ch[++top] = p[i];
}
if (n > 1) top--;
return top;
}
void draw(int top, Point ch[], Point p[]) {
for (int i = 2; i <= top; ++i) {
p[mp[make_pair(ch[i].x, ch[i].y)]].num = 1;
++i;
p[mp[make_pair(ch[i].x, ch[i].y)]].num = 2;
}
p[1].num = 0;
}
void preset(int s) {
k = 1;
for (int i = 1; i <= n; ++i) {
if (p[i].num == s) continue;
tp[k++] = p[i];
}
}
bool judge(int top, Point ch[]) {
for (int i = 1; i <= top; ++i)
if (!ch[i].flag) return true;
return false;
}
int main() {
io();
cin >> n;
++n;
p[1].flag = true;
mp[make_pair(0, 0)] = 1;
for (int i = 2; i <= n; ++i) {
cin >> p[i].x >> p[i].y;
if ((p[i].x == 0) && (p[i].y == 0)) {
--i, --n;
continue;
}
if (((p[i].x % 2) == 0) && ((p[i].y % 2) == 0)) p[i].flag = true;
}
int top = andrew(p, ch, n);
for (int i = 1; i <= n; ++i) mp[make_pair(p[i].x, p[i].y)] = i;
draw(top, ch, p);
if (judge(top, ch)) {
puts("Ani");
return 0;
}
preset(1);
top = andrew(tp, ch, k - 1);
if (judge(top, ch)) {
puts("Ani");
return 0;
}
preset(2);
top = andrew(tp, ch, k - 1);
if (judge(top, ch)) {
puts("Ani");
return 0;
}
puts("Borna");
}
| 26 |
#include <bits/stdc++.h>
using namespace std;
multiset<int> se1, se2, se3;
int main() {
int k, n1, n2, n3, t1, t2, t3;
scanf("%d", &k);
scanf("%d%d%d", &n1, &n2, &n3);
scanf("%d%d%d", &t1, &t2, &t3);
for (int i = 1; i <= n1; ++i) se1.insert(0);
for (int i = 1; i <= n2; ++i) se2.insert(0);
for (int i = 1; i <= n3; ++i) se3.insert(0);
int t = 0;
while (k--) {
multiset<int>::iterator x = se1.begin();
multiset<int>::iterator y = se2.upper_bound(*x + t1);
if (y != se2.begin()) --y;
multiset<int>::iterator z = se3.upper_bound(*y + t2);
if (z != se3.begin()) --z;
int X = *x, Y = *y, Z = *z;
se3.erase(z);
se2.erase(y);
se1.erase(x);
X += t1;
Y = max(X + t2, Y + t2);
Z = max(Y + t3, Z + t3);
t = max(t, Z);
se1.insert(X);
se2.insert(Y);
se3.insert(Z);
}
printf("%d\n", t);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n, k, x;
string s;
int main() {
while (getline(cin, s)) {
switch (s[0]) {
case '+': {
n++;
break;
}
case '-': {
n--;
break;
}
default:
x = s.find(':');
k = k + n * (s.size() - x - 1);
}
}
cout << k;
}
| 2 |
#include <bits/stdc++.h>
const int vx[4] = {-1, 0, 0, 1}, vy[4] = {0, -1, 1, 0};
int n, m;
struct Map {
int a[55][55], k, x1[10800], y1[10800], x2[10800], y2[10800];
void read() {
for (int i = 1, x, y; i <= m; i++) scanf("%d%d", &x, &y), a[x][y] = i;
}
void move(int x, int y, int d) {
a[x + vx[d]][y + vy[d]] = a[x][y];
a[x][y] = 0;
x1[k] = x;
y1[k] = y;
x2[k] = x + vx[d];
y2[k++] = y + vy[d];
}
void move_r(int x, int y) {
if (y + 1 <= n && a[x][y + 1]) move_r(x, y + 1);
move(x, y, 2);
}
void play() {
int pos = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (a[i][j]) {
int x = j;
++pos;
while (x < pos) move_r(i, x++);
while (x > pos) move(i, x--, 1);
for (x = i; x > 1; x--) move(x, pos, 0);
}
}
}
void fix(int* b) {
if (n == 2 && a[1][1] != b[1]) {
move(1, 1, 3);
move(2, 1, 2);
move(1, 2, 1);
move(2, 2, 0);
} else if (n > 3) {
for (int i = 1; i <= m; i++) {
int j = 1, x = i;
while (b[j] != a[1][i]) j++;
move(1, i, 3);
while (x < j) move(2, x++, 2);
while (x > j) move(2, x--, 1);
move(2, x, 3);
}
for (int i = 1; i <= m; i++) move(3, i, 0), move(2, i, 0);
}
}
void print(bool r) {
if (r)
for (int i = k; i--;) printf("%d %d %d %d\n", x2[i], y2[i], x1[i], y1[i]);
else
for (int i = 0; i < k; i++)
printf("%d %d %d %d\n", x1[i], y1[i], x2[i], y2[i]);
}
} M1, M2;
int main() {
scanf("%d%d", &n, &m);
M1.read();
M2.read();
M1.play();
M2.play();
M1.fix(M2.a[1]);
printf("%d\n", M1.k + M2.k);
M1.print(0);
M2.print(1);
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll md = 1000000007;
ll exp(ll a, ll b) {
ll r = 1ll;
while (b > 0) {
if (b & 1) {
r = r * (a % md);
r = (r + md) % md;
}
b >>= 1;
a = (a % md) * (a % md);
a = (a + md) % md;
}
return (r + md) % md;
}
ll gcd(ll a, ll b) {
if (b == 0) return a;
return gcd(b, a % b);
}
ll Min(ll a, ll b) {
if (a < b) return a;
return b;
}
ll Max(ll a, ll b) {
if (a > b) return a;
return b;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll n;
cin >> n;
vector<ll> v(n);
vector<pair<ll, ll> > un;
for (ll i = 0; i <= n - 1; ++i) cin >> v[i];
long long start = 0, end = 0;
while (start < n - 1) {
while (start < n - 1 && v[start] == v[start + 1]) ++start;
end = start + 1;
while (end < n - 1 && v[end] != v[end + 1]) ++end;
if (end - start + 1 >= 3) un.push_back({start, end});
start = end + 1;
}
long long ans = 0;
for (auto z : un) {
long long i = z.first, j = z.second, len = j - i + 1;
if (len & 1) {
ans = Max(ans, len / 2);
for (ll k = i + 1; k <= j - 1; ++k) v[k] = v[i];
} else {
ans = Max(ans, (len / 2) - 1);
long long bb = len / 2;
for (ll k = 0; k <= bb - 1; ++k) v[i + k] = v[i];
for (ll k = 0; k <= bb - 1; ++k) v[j - k] = v[j];
}
}
cout << ans << '\n';
for (ll i = 0; i <= n - 1; ++i) cout << v[i] << " ";
cout << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
namespace Rstd {
using namespace std;
template <typename T>
inline bool chkmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
template <typename T>
inline bool chkmin(T &x, T y) {
return x > y ? x = y, 1 : 0;
}
template <typename T>
inline void read(T &x) {
char c = getchar();
x = 0;
bool f = 0;
while (c < '0' || c > '9') f |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0', c = getchar();
x = f ? -x : x;
}
void file() {}
} // namespace Rstd
using namespace Rstd;
long long C[105][105], dp[105][105 * 105], n, m, k;
long long qpow(long long x, long long tim) {
long long res = 1;
while (tim) {
if (tim & 1) res = (res * x) % 1000000007;
x = (x * x) % 1000000007;
tim >>= 1;
}
return res;
}
signed main() {
file();
read(n);
read(m);
read(k);
for (long long i = 1; i <= n; i++) C[i][0] = C[i][i] = 1, C[i][1] = i;
for (long long i = 2; i <= n; i++)
for (long long j = 2; j < i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000007;
long long res = (m % n == 0) ? n : m % n;
long long times = m / n + (m % n != 0);
for (long long i = 0; i <= n; i++) dp[i][0] = 1;
for (long long i = 1; i <= n; i++) {
for (long long j = 0, tmp; j <= min(n, k); j++) {
if (i <= res)
tmp = qpow(C[n][j], times);
else
tmp = qpow(C[n][j], times - 1);
for (long long l = j; l <= k; l++)
if (l) {
dp[i][l] =
(dp[i][l] + dp[i - 1][l - j] * tmp % 1000000007) % 1000000007;
}
}
}
printf("%lld", dp[n][k]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000100;
int n, m, dx, dy, x[maxn], y[maxn], s[maxn];
int main() {
scanf("%d%d%d%d", &n, &m, &dx, &dy);
int xx = 0, yy = 0;
for (int i = 1; i < n; ++i) {
xx = (xx + dx) % n, yy = (yy + dy) % n;
x[xx] = i;
y[i] = yy;
}
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &xx, &yy);
int k = x[xx];
int y0 = (yy - y[k] + n) % n;
s[y0]++;
}
int ans = s[0], temy = 0;
for (int i = 1; i < n; ++i) {
if (ans < s[i]) ans = s[i], temy = i;
}
printf("0 %d\n", temy);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
char ch[2507][2507];
int sum[2507][2507];
int n, m;
int ac(int k) {
memset(sum, 0, sizeof sum);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
sum[i / k][j / k] += ch[i][j] - '0';
}
}
int ret = 0;
for (int i = 0; i <= (n - 1) / k; i++) {
for (int j = 0; j <= (m - 1) / k; j++) {
ret += min(sum[i][j], k * k - sum[i][j]);
}
}
return ret;
}
int main() {
scanf("%d%d", &n, &m);
int ans = n * m;
for (int i = 0; i < n; i++) {
scanf("%s", ch[i]);
}
ans = min(min(ac(5), ac(7)), min(ac(2), ac(3)));
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
namespace IO {
template <class A, class B>
ostream &operator<<(ostream &out, pair<A, B> a) {
out << a.first << " " << a.second;
return out;
}
template <class A, class B>
ostream &operator<<(ostream &out, vector<pair<A, B>> a) {
for (pair<A, B> x : a) out << x.first << " " << x.second << '\n';
return out;
}
template <class A>
ostream &operator<<(ostream &out, vector<A> a) {
for (A x : a) out << x << ' ';
return out;
}
template <class A, class B>
istream &operator>>(istream &in, pair<A, B> &a) {
in >> a.first >> a.second;
return in;
}
template <class A>
istream &operator>>(istream &in, vector<A> &a) {
for (A &x : a) in >> x;
return in;
}
} // namespace IO
using namespace IO;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
vector<vector<long long>> graph;
vector<long long> d;
vector<long long> tin;
vector<long long> tout;
long long timerr = 0;
void dfs(long long v, long long p) {
tin[v] = timerr++;
d[v] = d[p] + 1;
for (long long x : graph[v])
if (x != p) {
dfs(x, v);
}
tout[v] = timerr++;
}
pair<long long, long long> get(vector<long long> c) {
cout << "? " << c.size() << " ";
for (long long i : c) cout << i + 1 << " ";
cout << endl;
pair<long long, long long> res;
cin >> res;
if (res.first == -1) exit(0);
--res.first;
return res;
}
void solve() {
long long n;
cin >> n;
timerr = 0;
d = vector<long long>(n, 0);
tin = vector<long long>(n, 0);
tout = vector<long long>(n, 0);
graph = vector<vector<long long>>(n);
for (long long i = (0); i < (long long)(n - 1); ++i) {
long long a, b;
cin >> a >> b;
--a;
--b;
graph[a].push_back(b);
graph[b].push_back(a);
}
long long root, ans_d;
vector<long long> r(n);
for (long long i = (0); i < (long long)(n); ++i) r[i] = i;
tie(root, ans_d) = get(r);
d[root] = -1;
dfs(root, root);
long long L = 0, R = (*max_element(d.begin(), d.end())) + 1;
long long last_v;
while (R - L > 1) {
long long m = (R + L) / 2;
vector<long long> cur;
for (long long i = (0); i < (long long)(n); ++i)
if (d[i] >= m) cur.push_back(i);
long long e;
tie(last_v, e) = get(cur);
if (e == ans_d) {
L = m;
} else
R = m;
}
pair<long long, long long> res;
vector<long long> cur_q;
for (long long i = (0); i < (long long)(n); ++i)
if (d[i] == L) cur_q.push_back(i);
res.first = get(cur_q).first;
cur_q.clear();
for (long long i = (0); i < (long long)(n); ++i)
if (d[i] == ans_d - L &&
(tin[i] > tin[res.first] || tout[i] < tout[res.first]))
cur_q.push_back(i);
if (cur_q.size())
res.second = get(cur_q).first;
else
res.second = root;
cout << "! " << res.first + 1 << " " << res.second + 1 << endl;
string STUPID;
cin >> STUPID;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(30);
long long q = 1;
cin >> q;
while (q--) solve();
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007, N = 1000010;
long long gcd(long long a, long long b) {
return (a % b == 0) ? b : gcd(b, a % b);
}
int n, f[N], g[N], fa[N];
long long sz[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &sz[i]);
for (int i = 2; i <= n; i++) scanf("%d", &fa[i]);
for (int i = n; i > 1; i--) sz[fa[i]] += sz[i];
for (int i = 1; i <= n; i++) {
long long k = sz[1] / gcd(sz[1], sz[i]);
if (k <= n) g[k]++;
}
for (int i = n; i; i--)
for (int j = i * 2; j <= n; j += i) g[j] += g[i];
for (int i = n; i; i--)
if (g[i] >= i) {
f[i] = 1;
for (int j = i * 2; j <= n; j += i) (f[i] += f[j]) %= mod;
}
printf("%d", f[1]);
return 0;
}
| 19 |
#include <bits/stdc++.h>
int main() {
long long n;
unsigned long long sum;
scanf("%I64d", &n);
sum = (n * (n + 1)) * 3;
printf("%I64u", sum + 1);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 345678;
const int m = 998244353;
int mul(int a, int b) { return (long long)a * b % m; }
vector<int> e[maxn];
int f[2][2][maxn], pa[maxn];
int solve(int r, int eq, int v, int p) {
pa[v] = p;
if (f[r][eq][v] != -1) return f[r][eq][v];
if (e[v].size() == 1 && p) return eq;
if (eq) {
if (!r) {
int pr = 1;
for (int n : e[v]) {
if (n == p) continue;
int vv = 0;
vv += solve(0, 0, n, v);
if (vv >= m) vv -= m;
vv += solve(0, 1, n, v);
if (vv >= m) vv -= m;
pr = mul(pr, vv);
}
return f[r][eq][v] = pr;
} else {
int pr = 1;
for (int n : e[v]) {
if (n == p) continue;
int vv = 0;
vv += mul(2, solve(0, 0, n, v));
if (vv >= m) vv -= m;
vv += solve(0, 1, n, v);
if (vv >= m) vv -= m;
pr = mul(pr, vv);
}
return f[r][eq][v] = pr;
}
} else {
if (r) {
return 0;
} else {
struct wp {
int wl, wr, v;
};
vector<wp> uv;
for (int n : e[v]) {
if (n == p) continue;
uv.push_back({0, 0, n});
}
int pr = 1;
int len = uv.size();
for (int i = 0; i < len; i++) {
wp& ww = uv[i];
ww.wl = pr;
int vv = 0;
vv += mul(2, solve(0, 0, ww.v, v));
if (vv >= m) vv -= m;
vv += solve(0, 1, ww.v, v);
if (vv >= m) vv -= m;
pr = mul(pr, vv);
}
pr = 1;
for (int i = len - 1; i >= 0; i--) {
wp& ww = uv[i];
ww.wr = pr;
int vv = 0;
vv += mul(2, solve(0, 0, ww.v, v));
if (vv >= m) vv -= m;
vv += solve(0, 1, ww.v, v);
if (vv >= m) vv -= m;
pr = mul(pr, vv);
}
int rr = 0;
for (int i = 0; i < len; i++) {
wp ww = uv[i];
int pwr = mul(ww.wl, ww.wr);
pwr = mul(pwr, solve(1, 1, ww.v, v));
rr += pwr;
if (rr >= m) rr -= m;
}
return f[r][eq][v] = rr;
}
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d %d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
memset(f, -1, sizeof(f));
int r = 0;
r += solve(0, 0, 1, 0);
if (r >= m) r -= m;
r += solve(0, 1, 1, 0);
if (r >= m) r -= m;
printf("%d\n", r);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int n, m, t, r, rez;
vector<int> G[100005], GT[100005], C[100005];
vector<int> H[100005];
char viz[100005];
struct nod {
int a, b;
};
nod A[100005];
bool mark[100005], good[100005];
void read() {
scanf("%d%d", &n, &m);
int x, y;
while (m) {
scanf("%d%d", &x, &y);
mark[x] = mark[y] = true;
H[x].push_back(y);
H[y].push_back(x);
G[x].push_back(y);
GT[y].push_back(x);
m--;
}
}
void dfs1(int nod) {
viz[nod] = 1;
t++;
int i;
for (i = 0; i < (int)G[nod].size(); i++)
if (!viz[G[nod][i]]) dfs1(G[nod][i]);
A[++r].a = nod;
A[r].b = ++t;
}
void dfs2(int nod) {
viz[nod] = 1;
int i;
C[rez].push_back(nod);
for (i = 0; i < (int)GT[nod].size(); i++)
if (!viz[GT[nod][i]]) dfs2(GT[nod][i]);
}
void solve() {
int i;
for (i = 1; i <= n; i++)
if (!viz[i]) dfs1(i);
memset(viz, 0, sizeof(viz));
for (i = r; i >= 1; i--)
if (!viz[A[i].a]) {
rez++;
dfs2(A[i].a);
}
}
bool hasCycle;
int compSize;
void dfsComp(int node) {
viz[node] = true;
compSize++;
if (good[node]) hasCycle = true;
int x;
for (int i = 0; i < (int)H[node].size(); i++) {
x = H[node][i];
if (!viz[x]) dfsComp(x);
}
}
void show() {
int i, res = 0;
for (i = 1; i <= rez; i++)
if (C[i].size() > 1)
for (int j = 0; j < (int)C[i].size(); j++) good[C[i][j]] = true;
memset(viz, false, sizeof(viz));
for (int i = 1; i <= n; i++)
if (mark[i] && !viz[i]) {
hasCycle = false;
compSize = 0;
dfsComp(i);
if (hasCycle)
res += compSize;
else
res += compSize - 1;
}
printf("%d\n", res);
}
int main() {
read();
solve();
show();
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e6;
const long long LINF = 8e18;
const int MOD = 1e9 + 7;
const long double EPS = 1e-9;
vector<long long> A[1005][2];
long long mat[502][502][2];
void zigzag(int N, int M, int d) {
for (int i = 0; i < N + M; i++) {
int start_c = max(0, i - N);
int num_c = min(min(N, i), M - start_c);
for (int j = 0; j < num_c; j++)
A[i][d].push_back(mat[min(N, i) - 1 - j][start_c + j][d]);
}
}
bool equal(vector<long long>& a, vector<long long>& b) {
int n = (int)a.size();
for (int i = 0; i < n; i++)
if (a[i] != b[i]) return false;
return true;
}
void sol(int N, int M) {
for (int i = 0; i < N + M; i++)
for (int j = 0; j < 2; j++) sort(A[i][j].begin(), A[i][j].end());
for (int i = 0; i < N + M; i++) {
if (!equal(A[i][0], A[i][1])) {
printf("NO");
return;
}
}
printf("YES");
}
int main() {
int N, M;
scanf("%d", &N);
;
scanf("%d", &M);
;
for (int it = 0; it < 2; it++)
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) scanf("%lld", &mat[i][j][it]);
zigzag(N, M, 0);
zigzag(N, M, 1);
sol(N, M);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 5;
const int MOD = 1e9 + 7;
constexpr int MAX_VAL = 1e7 + 5;
constexpr int LOGMAX = 31 - __builtin_clz(MAX_N) + 5;
bool prime[MAX_VAL];
vector<int> primes, adj[MAX_N];
vector<tuple<int, int, int, int> > ops[MAX_VAL];
int st[MAX_N], en[MAX_N], arr[MAX_N], ans[MAX_N], p[LOGMAX][MAX_N],
level[MAX_N];
int less_bit[MAX_N], val_bit[MAX_N], zero_bit[MAX_N];
int dfs_c = 1, n;
void update(int idx, int val, int bit[MAX_N]) {
while (idx < MAX_N) {
bit[idx] += val;
idx += idx & -idx;
}
}
int query(int idx, int bit[MAX_N]) {
int total = 0;
while (idx) {
total += bit[idx];
idx -= idx & -idx;
}
return total;
}
void dfs(int node, int father) {
st[node] = dfs_c++;
for (auto &each : adj[node]) {
if (each != father) {
p[0][each] = node;
level[each] = level[node] + 1;
dfs(each, node);
}
}
en[node] = dfs_c - 1;
}
inline int add(int a, int b) {
a += b;
if (a >= MOD) {
a -= MOD;
}
return a;
}
inline int mult(int a, int b) { return (1LL * a * b) % MOD; }
int f_exp(int x, int exp) {
if (exp == 0) {
return 1;
} else if (exp & 1) {
return mult(x, f_exp(x, exp - 1));
}
return f_exp(mult(x, x), exp / 2);
}
inline int inv(int x) { return f_exp(x, MOD - 2); }
void sieve() {
memset(prime, true, sizeof prime);
primes.push_back(2);
for (long long i = 3; i < MAX_VAL; i += 2) {
if (prime[i]) {
primes.push_back(i);
for (long long j = i * i; j < MAX_VAL; j += 2 * i) {
prime[j] = false;
}
}
}
}
int lca(int u, int v) {
if (level[u] > level[v]) {
swap(u, v);
}
int lg = 31 - __builtin_clz(level[v]);
for (int i = int(lg); i >= int(0); i--) {
if (level[v] - (1 << i) >= level[u]) {
v = p[i][v];
}
}
if (u == v) {
return u;
}
lg = 31 - __builtin_clz(level[v]);
for (int i = int(lg); i >= int(0); i--) {
if (p[i][u] != p[i][v]) {
u = p[i][u];
v = p[i][v];
}
}
return p[0][u];
}
int main() {
sieve();
scanf("%d", &n);
for (int i = int(0); i < int(n - 1); i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
memset(p, -1, sizeof p);
dfs(1, -1);
for (int i = int(1); i < int(LOGMAX); i++) {
for (int j = int(1); j < int(n + 1); j++) {
if (p[i - 1][j] != -1) {
p[i][j] = p[i - 1][p[i - 1][j]];
}
}
}
for (int i = int(1); i < int(n + 1); i++) {
scanf("%d", arr + i);
int x = arr[i];
for (int j = 0; j < (int)primes.size() && primes[j] * primes[j] <= x; j++) {
int e = 0;
while (x % primes[j] == 0) {
e++;
x /= primes[j];
}
if (e) {
ops[primes[j]].emplace_back(e, 0, i, -1);
}
}
if (x != 1) {
ops[x].emplace_back(1, 0, i, -1);
}
}
int q;
scanf("%d", &q);
for (int i = int(0); i < int(q); i++) {
int u, v, x;
scanf("%d %d %d", &u, &v, &x);
int l = lca(u, v);
for (int j = 0; j < (int)primes.size() && primes[j] * primes[j] <= x; j++) {
int e = 0;
while (x % primes[j] == 0) {
e++;
x /= primes[j];
}
if (e) {
ops[primes[j]].emplace_back(e, 1, u, i);
ops[primes[j]].emplace_back(e, 1, v, i);
ops[primes[j]].emplace_back(-e, 1, l, i);
if (p[0][l] != -1) {
ops[primes[j]].emplace_back(-e, 1, p[0][l], i);
}
}
}
if (x != 1) {
ops[x].emplace_back(1, 1, u, i);
ops[x].emplace_back(1, 1, v, i);
ops[x].emplace_back(-1, 1, l, i);
if (p[0][l] != -1) {
ops[x].emplace_back(-1, 1, p[0][l], i);
}
}
ans[i] = 1;
}
for (auto &each : primes) {
if (ops[each].empty()) {
continue;
}
sort(ops[each].begin(), ops[each].end(),
[](const tuple<int, int, int, int> &lhs,
const tuple<int, int, int, int> &rhs) {
if (abs(get<0>(lhs)) != abs(get<0>(rhs))) {
return abs(get<0>(lhs)) < abs(get<0>(rhs));
}
tuple<int, int, int, int> a = tuple<int, int, int, int>(
0, get<1>(lhs), get<2>(lhs), get<3>(lhs));
tuple<int, int, int, int> b = tuple<int, int, int, int>(
0, get<1>(rhs), get<2>(rhs), get<3>(rhs));
return a < b;
});
for (auto &op : ops[each]) {
int exp, type, node, q_id;
tie(exp, type, node, q_id) = op;
if (type == 0) {
int l = st[node];
int r = en[node];
update(l, 1, zero_bit);
update(r + 1, -1, zero_bit);
}
}
for (auto &op : ops[each]) {
int exp, type, node, q_id;
tie(exp, type, node, q_id) = op;
if (type == 0) {
int l = st[node];
int r = en[node];
update(l, exp, val_bit);
update(r + 1, -exp, val_bit);
update(l, 1, less_bit);
update(r + 1, -1, less_bit);
} else {
int idx = st[node];
int non_zeros = query(idx, zero_bit);
int less = query(idx, less_bit);
int more = non_zeros - less;
int total_exp = query(idx, val_bit) + more * abs(exp);
if (exp < 0) {
total_exp *= -1;
}
ans[q_id] =
mult(ans[q_id], total_exp < 0 ? inv(f_exp(each, abs(total_exp)))
: f_exp(each, total_exp));
}
}
for (auto &op : ops[each]) {
int exp, type, node, q_id;
tie(exp, type, node, q_id) = op;
if (type == 0) {
int l = st[node];
int r = en[node];
update(l, -exp, val_bit);
update(r + 1, exp, val_bit);
update(l, -1, less_bit);
update(r + 1, 1, less_bit);
update(l, -1, zero_bit);
update(r + 1, 1, zero_bit);
}
}
}
for (int i = int(0); i < int(q); i++) {
printf("%d\n", ans[i]);
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int n, x, mx = -1, d;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
mx = mx > x ? mx : x;
d = i == 0 ? x : gcd(d, x);
}
x = mx / d;
x = n - x;
if (x & 1)
puts("Alice");
else
puts("Bob");
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, a, b, c;
fscanf(stdin, "%d%d%d%d", &a, &b, &c, &n);
int ans = 0;
for (int i = 1; i <= n; i++) {
int x;
fscanf(stdin, "%d", &x);
if ((b < x) && (x < c)) ans++;
}
fprintf(stdout, "%d\n", ans);
fclose(stdin);
fclose(stdout);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, u, v, cnt = 0;
vector<int> g[3002];
bool vis[3002];
void dfs(int s) {
cnt++;
vis[s] = true;
for (int i = 0; i < g[s].size(); i++) {
if (!vis[g[s][i]]) dfs(g[s][i]);
}
}
int main() {
scanf("%d%d", &n, &m);
if (n != m) {
cout << "NO" << endl;
return 0;
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
if (cnt != n)
cout << "NO" << endl;
else
cout << "FHTAGN!" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long long a[1000] = {0};
for (long long i = 1; i <= n; i++) cin >> a[i];
a[n + 1] = 1001;
long long ans = 0;
long long curr = 0;
for (long long i = 1; i < n + 1; i++) {
if (a[i] == a[i - 1] + 1 && a[i] == a[i + 1] - 1)
curr++, ans = max(ans, curr);
else
curr = 0;
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
clock_t start, end;
start = clock();
long long tc;
tc = 1;
for (long long i = 1; i <= tc; i++) solve();
end = clock();
double time_taken = double(end - start) / double(CLOCKS_PER_SEC);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int val[60];
int n;
int grid[2][60];
int mask1[25][1200008 + 1], mask2[25][1200008 + 1];
void solve(int l, int r, int mask[][1200008 + 1]) {
memset(mask, -1, sizeof mask);
for (int i = 0; i <= 24; i++)
for (int j = 0; j < 1200008 + 1; j++) mask[i][j] = -1;
for (int i = 0; i < (1 << r - l); i++) {
int s = 0;
for (int j = 0; j < r - l; j++)
if ((1 << j) & i) s += val[j + l];
mask[__builtin_popcount(i)][s] = i;
}
}
signed main() {
scanf("%d", &n);
n = n * 2;
for (int i = 0; i < n; i++) scanf("%d", &val[i]);
sort(val, val + n);
int sum = 0;
int base = val[0] + val[1];
grid[0][0] = val[0], grid[1][n / 2 - 1] = val[1];
n -= 2;
for (int i = 0; i < n; i++) val[i] = val[i + 2], sum += val[i];
solve(0, n / 2, mask1);
solve(n / 2, n, mask2);
int ans = 1e9;
long long ansmask = 0;
for (int a = 0; a <= n / 2; a++) {
int b = n / 2 - a;
int j = 1200008;
while (j >= 0 and mask2[b][j] == -1) j--;
for (int i = 0; j >= 0 and i <= 1200008; i++)
if (mask1[a][i] > -1) {
while (j >= 0 and (j + i) * 2 > sum) j--;
while (j >= 0 and mask2[b][j] == -1) j--;
if (j < 0) break;
if (sum - (i + j) * 2 < ans) {
ans = sum - (i + j) * 2;
ansmask = (1ll * mask2[b][j]) << (n / 2);
ansmask += mask1[a][i];
}
}
}
ans = (sum + ans) / 2;
vector<int> v1, v2;
for (int i = 0; i < n; i++)
if ((1ll << i) & ansmask)
v1.push_back(val[i]);
else
v2.push_back(val[i]);
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
reverse(v2.begin(), v2.end());
n += 2;
for (int i = 1; i < n / 2; i++) grid[0][i] = v1[i - 1];
for (int i = 0; i < n / 2 - 1; i++) grid[1][i] = v2[i];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < n / 2; j++) cout << grid[i][j] << " ";
cout << "\n";
}
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int n, h, w;
const long long MOD = 1e9 + 7;
int L[2], R[2], C[2], D[2];
int ans;
string trace;
bool go(long long d, bool memo) {
char here = trace[d % n];
if (here == 'L')
memo ? C[0] = L[0] - 1 : C[0]--;
else if (here == 'R')
memo ? C[0] = R[0] + 1 : C[0]++;
else if (here == 'D')
memo ? C[1] = R[1] + 1 : C[1]++;
else
memo ? C[1] = L[1] - 1 : C[1]--;
bool ret = false;
for (int i = 0; i < 2; i++) {
if (C[i] < L[i] || C[i] > R[i]) {
ans = (ans + (d + 1) % MOD * D[1 - i]) % MOD;
D[i]--;
ret = true;
}
L[i] = min(L[i], C[i]);
R[i] = max(R[i], C[i]);
}
return ret;
}
inline bool chk() { return D[0] > 0 && D[1] > 0; }
int main() {
cin >> n >> D[1] >> D[0] >> trace;
vector<long long> v;
for (long long i = 0; chk() && i < n; i++) {
go(i, false);
}
if (C[0] == 0 && C[1] == 0 && D[0] > 0 && D[1] > 0) {
cout << -1;
return 0;
}
for (long long i = n; chk() && i < 2 * n; i++)
if (go(i, false)) v.push_back(i % n);
for (long long mult = 2; chk(); mult++) {
for (long long p : v) {
if (chk()) {
go(mult * n + p, true);
}
}
}
cout << ans;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 13;
int kol[MAX];
int m, d;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
kol[1] = 31;
kol[2] = 28;
kol[3] = 31;
kol[4] = 30;
kol[5] = 31;
kol[6] = 30;
kol[7] = 31;
kol[8] = 31;
kol[9] = 30;
kol[10] = 31;
kol[11] = 30;
kol[12] = 31;
cin >> m >> d;
int ans = d - 1 + kol[m];
cout << ans / 7 + (ans % 7 != 0);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int maxn = 1e6 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9;
using namespace std;
int main() {
int n;
cin >> n;
if (n > 36)
cout << "-1" << endl;
else if (n == 1)
cout << "6" << endl;
else {
while (n) {
if (n >= 2) {
cout << "8";
n -= 2;
} else {
cout << "0";
n -= 1;
}
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long int;
using pii = pair<int, int>;
using vi = vector<int>;
using vb = vector<bool>;
using vvi = vector<vector<int>>;
using vlli = vector<long long int>;
using vpii = vector<pair<int, int>>;
int n, q, x, l, r;
char c;
string s;
map<char, set<int>> pos;
vi tree, del;
int query(int i) {
int temp = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) temp += tree[i];
return temp;
}
void update(int i, int val) {
for (; i <= n; i = (i | (i + 1))) tree[i] += val;
}
int get(int x) {
int l = 1, r = n, m, ans = 1, y;
while (l <= r) {
m = (l + r) / 2;
y = m - query(m);
if (y < x)
l = m + 1;
else
r = m - 1, ans = m;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> q >> s;
tree.assign(n + 1, 0);
for (int i = 0; i < n; i++) pos[s[i]].insert(i + 1);
for (int i = 1; i <= q; i++) {
cin >> l >> r >> c;
l = get(l);
r = get(r);
auto &idx = pos[c];
auto it = idx.lower_bound(l);
while (it != idx.end() && (*it) <= r) {
update(*it, 1);
del.push_back(*it);
it = idx.erase(it);
}
}
sort((del).begin(), (del).end());
for (int i = 1, j = 0; i <= n; i++)
if (j < del.size() && del[j] == i)
j++;
else
cout << s[i - 1];
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long tn;
int n, m, a, arr[110], ind, mx;
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
ind = mx = -1;
for (int j = 1; j <= n; j++) {
cin >> a;
if (a > mx) {
mx = a;
ind = j;
}
}
arr[ind]++;
}
ind = mx = -1;
for (int j = 1; j <= n; j++) {
if (arr[j] > mx) {
mx = arr[j];
ind = j;
}
}
cout << ind;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
template <typename T>
struct hash_map_t {
vector<T> v, val, nxt;
vector<int> head;
int mod, tot, lastv;
T lastans;
bool have_ans;
hash_map_t(int md = 0) {
head.clear();
v.clear();
val.clear();
nxt.clear();
tot = 0;
mod = md;
nxt.resize(1);
v.resize(1);
val.resize(1);
head.resize(mod);
have_ans = 0;
}
void clear() { *this = hash_map_t(mod); }
bool count(int x) {
int u = x % mod;
for (register int i = head[u]; i; i = nxt[i]) {
if (v[i] == x) {
have_ans = 1;
lastv = x;
lastans = val[i];
return 1;
}
}
return 0;
}
void ins(int x, int y) {
int u = x % mod;
nxt.push_back(head[u]);
head[u] = ++tot;
v.push_back(x);
val.push_back(y);
}
int qry(int x) {
if (have_ans && lastv == x) return lastans;
count(x);
return lastans;
}
};
const int N = 2005, md = 998244353;
inline int add(int x, int y) {
x += y;
if (x >= md) x -= md;
return x;
}
inline int sub(int x, int y) {
x -= y;
if (x < 0) x += md;
return x;
}
inline int mul(int x, int y) { return 1ll * x * y % md; }
inline int fpow(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = mul(ans, x);
y >>= 1;
x = mul(x, x);
}
return ans;
}
struct fenwick {
int f[N], n;
inline int lowbit(int x) { return x & -x; }
void add(int x, int y) {
for (register int i = x; i <= n; i += lowbit(i)) f[i] += y;
}
int query(int x) {
int ans = 0;
for (register int i = x; i; i ^= lowbit(i)) ans += f[i];
return ans;
}
} tr1, tr2;
int a[N][N], f[N][N], vis1[N], vis2[N];
int n, ans;
int main() {
read(n);
tr1.n = tr2.n = n;
for (register int i = 1; i <= n; i++) {
for (register int j = 1; j <= n; j++) read(a[i][j]);
}
f[0][0] = 1;
for (register int i = 1; i <= n; i++) {
f[i][0] = mul(f[i - 1][1], i - 1);
for (register int j = 1; j <= i; j++)
f[i][j] = add(mul(f[i - 1][j - 1], j), mul(f[i - 1][j], i - j));
}
for (register int i = 2; i <= n; i++) {
memset(vis1, 0, sizeof(vis1));
memset(vis2, 0, sizeof(vis2));
for (register int j = 1; j <= n; j++) tr1.add(j, 1);
int cnt = 0, sum = 0;
for (register int j = 1; j <= n; j++) {
vis1[a[i - 1][j]] = 1;
if (!vis2[a[i - 1][j]]) tr1.add(a[i - 1][j], -1), ++cnt;
sum = add(sum, add(mul(tr1.query(a[i][j] - 1), f[n - j][cnt]),
mul(tr2.query(a[i][j] - 1), f[n - j][cnt - 1])));
if (!vis2[a[i - 1][j]]) tr2.add(a[i - 1][j], 1);
vis2[a[i][j]] = 1;
if (vis1[a[i][j]]) --cnt;
if (vis1[a[i][j]])
tr2.add(a[i][j], -1);
else
tr1.add(a[i][j], -1);
}
ans = add(ans, mul(sum, fpow(f[n][0], n - i)));
}
for (register int i = n, now = fpow(f[n][0], n - 1); i >= 1;
i--, now = mul(now, n - i)) {
ans = add(ans, mul(tr1.query(a[1][i] - 1), now));
tr1.add(a[1][i], 1);
}
print(ans, '\n');
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v, t, i;
edge(int v_, int t_, int i_) {
v = v_;
t = t_;
i = i_;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, q;
cin >> n >> m >> q;
vector<pair<int, int>> inp;
vector<vector<edge>> adj(n + 1);
int cnt = 0;
for (int i = 0; i < m; i++) {
int t, u, v;
cin >> t >> u >> v;
if (t == 1) {
adj[u].push_back(edge(v, t, 0));
} else {
inp.push_back(make_pair(u, v));
adj[u].push_back(edge(v, t, cnt));
adj[v].push_back(edge(u, t, cnt));
cnt++;
}
}
vector<bool> vis(n + 1);
stack<int> s;
s.push(q);
vis[q] = true;
int min_cnt = 1;
while (!s.empty()) {
int u = s.top();
s.pop();
for (auto e : adj[u]) {
if (e.t == 1 and !vis[e.v]) {
s.push(e.v);
vis[e.v] = true;
min_cnt++;
}
}
}
vector<char> min_orient;
for (int i = 0; i < cnt; i++) {
if (vis[inp[i].first] and !vis[inp[i].second])
min_orient.push_back('-');
else
min_orient.push_back('+');
}
vector<char> max_orient;
for (int i = 0; i < cnt; i++) max_orient.push_back('-');
int max_cnt = min_cnt;
for (int i = 0; i <= n; i++) {
if (vis[i]) s.push(i);
}
while (!s.empty()) {
int u = s.top();
s.pop();
for (auto e : adj[u]) {
if (!vis[e.v]) {
s.push(e.v);
vis[e.v] = true;
max_cnt++;
if (e.t == 2) {
if (u == inp[e.i].first) {
max_orient[e.i] = '+';
}
}
}
}
}
cout << max_cnt << endl;
for (int i = 0; i < cnt; i++) cout << max_orient[i];
cout << endl;
cout << min_cnt << endl;
for (int i = 0; i < cnt; i++) cout << min_orient[i];
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long n, x[1005], y[1005], maxx, maxy, minx, miny;
int main() {
cin >> n;
cin >> x[1] >> y[1];
minx = x[1];
maxx = x[1];
miny = y[1];
maxy = y[1];
for (int i = 2; i <= n; i++) {
cin >> x[i] >> y[i];
minx = min(x[i], minx);
maxx = max(maxx, x[i]);
miny = min(y[i], miny);
maxy = max(y[i], maxy);
}
if (abs(maxy - miny) > abs(maxx - minx))
cout << abs(maxy - miny) * abs(maxy - miny);
else
cout << abs(maxx - minx) * abs(maxx - minx);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long s, x;
while (cin >> s >> x) {
long long dp[41][2];
memset(dp, 0, sizeof dp);
dp[0][0] = 1;
for (int i = 0; i < 40; i++) {
if (x & (1LL << i)) {
if (s & (1LL << i)) dp[i + 1][0] += 2 * dp[i][0];
if (!(s & (1LL << i))) dp[i + 1][1] += 2 * dp[i][1];
} else {
if (!(s & (1LL << i)))
dp[i + 1][0] += dp[i][0], dp[i + 1][1] += dp[i][0];
if (s & (1LL << i)) dp[i + 1][0] += dp[i][1], dp[i + 1][1] += dp[i][1];
}
}
cout << dp[40][0] - 2 * (s == x) << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long ans;
const int maxn = 11000;
const int mod = 1000000007;
char s[3][maxn];
long long dp[2][1 << 3];
bool flag[4];
int n;
int x, y;
const int d[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
bool build(int dir) {
int dx = x, dy = y;
for (int i = 1; i <= 2; ++i) {
dx += d[dir][0], dy += d[dir][1];
if (!(dx >= 0 && dx < 3 && dy >= 0 && dy < n) || s[dx][dy] == 'X') return 0;
}
dx = x, dy = y;
for (int i = 0; i <= 2; ++i) {
s[dx][dy] = 'X';
dx += d[dir][0], dy += d[dir][1];
}
return 1;
}
void reset(int dir) {
int dx = x, dy = y;
for (int i = 0; i <= 2; ++i) {
s[dx][dy] = '.';
dx += d[dir][0], dy += d[dir][1];
}
}
int cur;
inline void update(int a, int b) {
if (b & 8) (dp[cur][b ^ 8] += dp[cur ^ 1][a]) %= mod;
}
long long cal() {
cur = 0;
memset(dp, 0, sizeof(dp));
dp[cur][7] = 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < 3; ++j) {
cur ^= 1;
memset(dp[cur], 0, sizeof(dp[cur]));
if (s[j][i] == 'X')
for (int k = 0; k < 8; ++k) {
if (k & 1)
dp[cur][k] = dp[cur ^ 1][(k >> 1) + 4];
else
dp[cur][k] = 0;
}
else
for (int k = 0; k < 8; ++k) {
update(k, k << 1);
if (i && !(k & 4)) update(k, (k << 1) ^ 8 ^ 1);
if (j && !(k & 1)) update(k, (k << 1) ^ 3);
}
}
return dp[cur][7];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < 3; ++i) scanf("%s", s[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < 3; ++j)
if (s[j][i] == 'O') x = j, y = i;
for (int i = 0; i < 4; ++i) flag[i] = 0;
ans = 0;
for (int i = 0; i < 4; ++i) {
if (build(i)) {
flag[i] = 1;
ans = (ans + cal()) % mod;
reset(i);
}
}
for (int i = 0; i < 4; ++i)
for (int j = i + 1; j < 4; ++j) {
if (flag[i] && flag[j]) {
build(i), build(j);
ans = (ans - cal() + mod) % mod;
reset(i), reset(j);
}
}
for (int i = 0; i < 4; ++i)
for (int j = i + 1; j < 4; ++j)
for (int k = j + 1; k < 4; ++k) {
if (flag[i] && flag[j] && flag[k]) {
build(i), build(j), build(k);
ans = (ans + cal()) % mod;
reset(i), reset(j), reset(k);
}
}
cout << ans << endl;
}
| 13 |
/**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <iostream>
#include <fstream>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <unordered_map>
#include <vector>
#define pb push_back
#define sz(v) ((int)(v).size())
#define all(v) (v).begin(),(v).end()
#define mp make_pair
using namespace std;
typedef long long int64;
typedef vector<int> vi;
typedef pair<int, int> ii;
struct Op {
int left;
int right;
int oldValue;
int value;
};
struct Fenwick {
vector<int64> a;
Fenwick(int n) : a(n) {
}
void upd(int at, int64 by) {
while (at < a.size()) {
a[at] += by;
at |= at + 1;
}
}
int64 get(int upto) const {
int64 res = 0;
while (upto >= 0) {
res += a[upto];
upto = (upto & (upto + 1)) - 1;
}
return res;
}
int findLastLess(int64 val) const {
int shift = 1;
int pos = -1;
while (pos + shift * 2 < a.size()) shift *= 2;
while (shift > 0) {
if (pos + shift < a.size() && a[pos + shift] <= val) {
val -= a[pos + shift];
pos += shift;
}
shift /= 2;
}
return pos;
}
};
class EStrannayaPerestanovka {
public:
void solveOne(istream &in, ostream &out) {
int n, c, q;
in >> n >> c >> q;
vector<int> p(n);
for (auto& x : p) {
in >> x;
--x;
}
vector<Op> ops;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n && j <= i + c; ++j) {
Op op;
op.left = i;
op.right = j;
op.oldValue = p[i];
op.value = p[j];
ops.push_back(op);
}
}
Op sentinel;
sentinel.left = n;
sentinel.right = n;
sentinel.oldValue = 1;
sentinel.value = 0;
ops.push_back(sentinel);
sort(all(ops), [](const Op& a, const Op& b) {
int kinda = a.value < a.oldValue ? 0 : 1;
int kindb = b.value < b.oldValue ? 0 : 1;
if (kinda != kindb) return kinda < kindb;
if (kinda == 0) {
if (a.left != b.left) {
return a.left < b.left;
}
return a.value < b.value;
} else {
if (a.left != b.left) {
return a.left > b.left;
}
return a.value < b.value;
}
});
vector<vector<int>> toDelete(n + 2);
for (int i = 0; i < ops.size(); ++i) {
toDelete[ops[i].left].push_back(i);
}
vector<vector<int64>> choices(c + 1, vector<int64>(n + 2));
for (int rem = 0; rem <= c; ++rem) {
choices[rem][n] = choices[rem][n + 1] = 1;
for (int start = n - 1; start >= 0; --start) {
choices[rem][start] = choices[rem][start + 1];
for (int finish = start + 1; finish < n && finish <= start + rem; ++finish) {
choices[rem][start] += choices[rem - (finish - start)][finish + 1];
if (choices[rem][start] >= 4e18) assert(false);
}
}
}
vector<Fenwick> fenwick(c + 1, Fenwick(ops.size()));
for (int i = 0; i < ops.size(); ++i) {
auto op = ops[i];
for (int j = op.right - op.left; j <= c; ++j) {
fenwick[j].upd(i, choices[j - (op.right - op.left)][op.right + 1]);
}
}
vector<int64> need(q);
vector<int> needAt(q);
vector<int> avail(q);
vector<int> answer(q, -1);
for (int i = 0; i < q; ++i) {
in >> needAt[i] >> need[i];
--needAt[i];
--need[i];
answer[i] = p[needAt[i]];
avail[i] = c;
}
vector<vector<int>> queue(n + 2);
for (int i = 0; i < q; ++i) {
queue[0].push_back(i);
}
for (int pos = 0; pos < n; ++pos) {
for (int qi : queue[pos]) {
int at = fenwick[avail[qi]].findLastLess(need[qi]);
need[qi] -= fenwick[avail[qi]].get(at);
assert(need[qi] >= 0);
if (at + 1 >= ops.size()) {
need[qi] = 0;
answer[qi] = -2;
continue;
}
auto op = ops[at + 1];
if (op.left <= needAt[qi] && op.right >= needAt[qi]) {
answer[qi] = p[op.left + op.right - needAt[qi]];
}
avail[qi] -= op.right - op.left;
queue[op.right + 1].push_back(qi);
}
queue[pos].clear();
for (int i : toDelete[pos]) {
auto op = ops[i];
for (int j = op.right - op.left; j <= c; ++j) {
fenwick[j].upd(i, -choices[j - (op.right - op.left)][op.right + 1]);
}
}
}
for (int i = 0; i < q; ++i) {
assert(need[i] == 0);
out << answer[i] + 1 << "\n";
}
}
void solve(std::istream &in, std::ostream &out) {
int nt;
in >> nt;
for (int it = 0; it < nt; ++it) {
solveOne(in, out);
}
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
EStrannayaPerestanovka solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
printf("%d\n", (n - 1) / 2);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxx = 2e5 + 100;
struct edge {
int next;
int to;
} e[maxx << 1];
int head[maxx << 1];
int vis[maxx], fa[maxx], sum[maxx], ans[maxx];
int n, tot = 0;
inline void add(int u, int v) {
e[tot].next = head[u], e[tot].to = v, head[u] = tot++;
}
inline void dfs(int u, int f) {
fa[u] = f;
sum[u] = (vis[u] == 1 ? 1 : -1);
for (int i = head[u]; i != -1; i = e[i].next) {
int to = e[i].to;
if (to == f) continue;
dfs(to, u);
if (sum[to] >= 0) sum[u] += sum[to];
}
}
inline void Dfs(int u, int f) {
if (sum[u] >= 0)
ans[u] = max(sum[u], ans[fa[u]]);
else if (ans[fa[u]] > 0)
ans[u] = sum[u] + ans[fa[u]];
else
ans[u] = sum[u];
for (int i = head[u]; i != -1; i = e[i].next) {
int to = e[i].to;
if (to == f) continue;
Dfs(to, u);
}
}
int main() {
scanf("%d", &n);
memset(head, -1, sizeof(head));
for (int i = 1; i <= n; i++) scanf("%d", &vis[i]);
int x, y;
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
sum[0] = -1 * maxx;
dfs(1, 0);
ans[1] = sum[1];
Dfs(1, 0);
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000 * 1000 * 1000 + 7;
const long long INF = 1ll * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 7;
const long long MOD2 = 998244353;
const long long N = 1000 * 100 + 5;
const long long N2 = 1000 * 1000;
const double PI = 3.14159265;
long long power(long long x, long long y, long long p) {
long long res = 1;
x %= p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
char a[n][n];
int r[n][n], c[n][n], row[n], col[n], prefr[n], prefc[n];
memset(row, 0, sizeof(row));
memset(col, 0, sizeof(col));
memset(prefr, 0, sizeof(prefr));
memset(prefc, 0, sizeof(prefc));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> a[i][j];
if (a[i][j] == 'B') {
row[i]++;
col[j]++;
r[i][j] = c[i][j] = 1;
} else
r[i][j] = c[i][j] = 0;
}
}
for (int i = 0; i < n; ++i) {
if (!row[i]) prefr[i]++;
if (!col[i]) prefc[i]++;
}
for (int i = 1; i < n; ++i) {
prefr[i] += prefr[i - 1];
prefc[i] += prefc[i - 1];
}
int tr = prefr[n - 1];
int tc = prefc[n - 1];
for (int i = 0; i < n; ++i) {
for (int j = 1; j < n; ++j) {
r[i][j] += r[i][j - 1];
}
}
for (int j = 0; j < n; ++j) {
for (int i = 1; i < n; ++i) {
c[i][j] += c[i - 1][j];
}
}
int si = n - k + 1, count = 0;
int calcr[si][si], calcc[si][si];
for (int i = 0; i < si; ++i) {
int count = 0;
for (int j = 0; j < k; ++j) {
int dum;
if (!i)
dum = c[k - 1][j];
else
dum = c[k + i - 1][j] - c[i - 1][j];
if ((col[j] - dum) == 0) count++;
}
calcc[i][0] = count;
for (int j = 1; j < si; ++j) {
int dum1, dum2;
if (i)
dum1 = c[i + k - 1][j - 1] - c[i - 1][j - 1];
else
dum1 = c[k - 1][j - 1];
if (i)
dum2 = c[i + k - 1][j + k - 1] - c[i - 1][j + k - 1];
else
dum2 = c[k - 1][j + k - 1];
if (col[j - 1] == dum1) count--;
if (col[j + k - 1] == dum2) count++;
calcc[i][j] = count;
}
}
for (int i = 0; i < si; ++i) {
int count = 0;
for (int j = 0; j < k; ++j) {
int dum;
if (!i)
dum = r[j][k - 1];
else
dum = r[j][k + i - 1] - r[j][i - 1];
if (row[j] == dum) count++;
}
calcr[0][i] = count;
for (int j = 1; j < si; ++j) {
int dum1, dum2;
if (i)
dum1 = r[j - 1][i + k - 1] - r[j - 1][i - 1];
else
dum1 = r[j - 1][k - 1];
if (i)
dum2 = r[j + k - 1][i + k - 1] - r[j + k - 1][i - 1];
else
dum2 = r[j + k - 1][k - 1];
if (row[j - 1] == dum1) count--;
if (row[j + k - 1] == dum2) count++;
calcr[j][i] = count;
}
}
int ans = 0;
for (int i = 0; i < si; ++i) {
for (int j = 0; j < si; ++j) {
int dum = calcr[i][j] + calcc[i][j];
int dum2, dum3;
if (i)
dum2 = prefr[i + k - 1] - prefr[i - 1];
else
dum2 = prefr[k - 1];
if (j)
dum3 = prefc[j + k - 1] - prefc[j - 1];
else
dum3 = prefc[k - 1];
ans = max(ans, dum + tr + tc - dum2 - dum3);
}
}
cout << ans;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
const int INF = MAXN;
int n, k, p[MAXN], c[MAXN];
multiset<pair<int, int> > s, ovi;
vector<int> ans[MAXN];
void print(multiset<pair<int, int> > &t) {
for (auto &x : t) cerr << "(" << x.first << "," << x.second << ") ";
cerr << endl;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = (0); i < int(n); i++) s.insert({INF, i});
for (int i = (0); i < int(n); i++) scanf("%d", &p[i]);
for (int i = (0); i < int(k); i++) scanf("%d", &c[i + 1]);
sort(p, p + n);
reverse(p, p + n);
for (int i = (0); i < int(k); i++) ovi.insert({c[i + 1], -(i + 1)});
int m = 0;
for (int i = (0); i < int(n); i++) {
auto it = s.lower_bound({p[i], -INF});
int b = it->second;
m = max(m, b + 1);
ans[b].push_back(p[i]);
s.erase(it);
int cnt = (int)ans[b].size();
auto t = ovi.lower_bound({cnt + 1, -INF});
s.insert({-(t->second), b});
}
printf("%d\n", m);
for (int i = (0); i < int(m); i++) {
printf("%d ", (int)ans[i].size());
for (auto &x : ans[i]) printf("%d ", x);
puts("");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long A, B, C, L[4], R[4];
long long a[N][4];
int n, t;
bool check(long long x) {
for (int i = 0; i < 4; i++) L[i] = a[1][i] - x, R[i] = a[1][i] + x;
for (int i = 2; i <= n; i++)
for (int j = 0; j < 4; j++) {
L[j] = max(L[j], a[i][j] - x);
R[j] = min(R[j], a[i][j] + x);
}
for (int i = 0; i < 2; i++) {
long long l0 = L[0] + ((L[0] & 1) == i), r0 = R[0] - ((R[0] & 1) == i);
long long l1 = L[1] + ((L[1] & 1) == i), r1 = R[1] - ((R[1] & 1) == i);
long long l2 = L[2] + ((L[2] & 1) == i), r2 = R[2] - ((R[2] & 1) == i);
long long l3 = L[3] + ((L[3] & 1) == i), r3 = R[3] - ((R[3] & 1) == i);
if (l0 > r0 || l1 > r1 || l2 > r2 || l3 > r3 || l1 + l2 + l3 > r0) continue;
if (l1 + l2 + l3 < l0) l1 = min(r1, l0 - l2 - l3);
if (l1 + l2 + l3 < l0) l2 = min(r2, l0 - l1 - l3);
if (l1 + l2 + l3 < l0) l3 = min(r3, l0 - l1 - l2);
if (l1 + l2 + l3 < l0) continue;
A = (l2 + l3) / 2, B = (l3 + l1) / 2, C = (l1 + l2) / 2;
return true;
}
return false;
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
long long x, y, z;
scanf("%lld%lld%lld", &x, &y, &z);
a[i][0] = x + y + z, a[i][1] = -x + y + z;
a[i][2] = x - y + z, a[i][3] = x + y - z;
}
long long l = 0, r = 4e18;
while (l < r) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = ++mid;
}
printf("%lld %lld %lld\n", A, B, C);
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
template <typename H>
bool chmin(H& v1, const H v2) {
if (v1 > v2) {
v1 = v2;
return true;
}
return false;
}
template <typename H>
bool chmax(H& v1, const H v2) {
if (v1 < v2) {
v1 = v2;
return true;
}
return false;
}
template <typename H>
void read(H& head) {
cin >> head;
}
template <typename H, typename... T>
void read(H& head, T&... tail) {
cin >> head;
read(tail...);
}
template <typename H>
void write(H head) {
cout << head << '\n';
}
template <typename H, typename... T>
void write(H head, T... tail) {
cout << head << " ";
write(tail...);
}
template <typename... T>
void die(T... tok) {
write(tok...);
exit(0);
}
using namespace std;
long long intersect(long long l1, long long r1, long long l2, long long r2) {
return max(0ll, min(r1, r2) - max(l1, l2));
}
void solve() {
int n;
long long k;
read(n, k);
long long l1, r1, l2, r2;
read(l1, r1, l2, r2);
long long g = intersect(l1, r1, l2, r2);
long long ni = max(0ll, max(l1, l2) - min(r1, r2));
long long v = g * n;
long long c1 = max(r1, r2) - min(l1, l2) - g;
long long ans = 0x3f3f3f3f3f3f3f3fll;
if (v >= k) {
write(0);
return;
}
for (int i = 1; i < (n + 1); ++i) {
long long vv = v;
long long cx = min(k - v, c1 * i);
long long cy = k - (vv + cx);
chmin(ans, ni * i + cx * 1 + cy * 2);
}
write(ans);
}
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(cin.failbit);
int t;
read(t);
for (int i = 0; i < (t); ++i) solve();
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, c = 0;
cin >> n >> m;
int a[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++) {
if (a[i][0] == 1 || a[i][m - 1] == 1) {
c++;
}
}
for (int i = 0; i < m; i++) {
if (a[0][i] == 1 || a[n - 1][i] == 1) {
c++;
}
}
if (c > 0) {
cout << 2 << endl;
} else {
cout << 4 << endl;
}
return 0;
}
| 2 |
Subsets and Splits