solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int maxn = 110;
int main() {
int n, d;
int a[maxn], x[maxn], y[maxn];
int dist[maxn][maxn], cost[maxn][maxn];
scanf("%d%d", &n, &d);
a[1] = a[n] = 0;
for (int i = 2; i < n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d%d", &x[i], &y[i]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dist[i][j] = dist[j][i] = abs(x[i] - x[j]) + abs(y[i] - y[j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cost[i][j] = d * dist[i][j] - a[j];
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (i == j) continue;
if (i == k) continue;
if (j == k) continue;
if (cost[i][k] + cost[k][j] < cost[i][j])
cost[i][j] = cost[i][k] + cost[k][j];
}
int ans = cost[1][n];
if (ans < 0) ans = 0;
printf("%d\n", ans);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k;
string s, s1;
cin >> s;
cin >> s1;
map<int, int> m;
for (i = 0; i <= 9; i++) m[i] = 0;
for (i = 0; i < s1.size(); i++) m[(int)(s1[i]) - 48]++;
for (i = 0; i < s.size(); i++) {
for (j = 9; j >= 0; j--) {
if (j > ((int)(s[i]) - 48) && m[j] >= 1) {
m[j]--;
s[i] = char(j + 48);
break;
}
}
}
cout << s << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int L = (1 << 22) + 1;
char ibuf[L], *iS, *iT, obuf[L], *oS = obuf, *oT = obuf + L - 1, c, qu[55];
int f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void pc(char x) {
*oS++ = x;
if (oS == oT) flush();
}
template <class I>
inline void gi(I &x) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-') f = -1;
for (x = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, L, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
x = x * 10 + (c & 15);
x *= f;
}
template <class I>
inline void print(I x) {
if (!x) pc('0');
if (x < 0) pc('-'), x = -x;
while (x) qu[++qr] = x % 10 + '0', x /= 10;
while (qr) pc(qu[qr--]);
}
struct IOC {
~IOC() { flush(); }
} _ioc_;
}; // namespace io
using io::gi;
using io::pc;
using io::print;
const int maxn = 200005;
const int maxm = 12;
int n, m, q;
long long seq[maxn];
struct trans_t {
int arr[maxm];
trans_t operator+(const trans_t &rhs) {
trans_t res;
for (int i = 1; i <= m + 1; i++) res.arr[i] = arr[rhs.arr[i]];
return res;
}
} I[2];
struct segtree {
int lft, rgt, d, tag;
trans_t trans[2];
} tree[maxn * 4];
void pushdown(int root) {
if (tree[root].tag)
tree[(root << 1)].d ^= 1, tree[((root << 1) | 1)].d ^= 1,
tree[(root << 1)].tag ^= 1, tree[((root << 1) | 1)].tag ^= 1,
tree[root].tag = 0;
}
void build(int root, int left, int right) {
tree[root].lft = left, tree[root].rgt = right;
if (left == right) {
tree[root].d = seq[left] & 1ll;
tree[root].trans[0] = I[0], tree[root].trans[1] = I[1];
return;
}
int mid(left + right >> 1);
build((root << 1), left, mid);
build(((root << 1) | 1), mid + 1, right);
tree[root].trans[tree[root].d] =
tree[(root << 1)].trans[tree[(root << 1)].d] +
tree[((root << 1) | 1)].trans[tree[((root << 1) | 1)].d];
tree[root].trans[tree[root].d ^ 1] =
tree[(root << 1)].trans[tree[(root << 1)].d ^ 1] +
tree[((root << 1) | 1)].trans[tree[((root << 1) | 1)].d ^ 1];
}
void update(int root, int left, int right) {
if (left <= tree[root].lft && tree[root].rgt <= right) {
tree[root].d ^= 1, tree[root].tag ^= 1;
return;
}
int mid(tree[root].lft + tree[root].rgt >> 1);
pushdown(root);
if (left <= mid) update((root << 1), left, right);
if (right > mid) update(((root << 1) | 1), left, right);
tree[root].trans[tree[root].d] =
tree[(root << 1)].trans[tree[(root << 1)].d] +
tree[((root << 1) | 1)].trans[tree[((root << 1) | 1)].d];
tree[root].trans[tree[root].d ^ 1] =
tree[(root << 1)].trans[tree[(root << 1)].d ^ 1] +
tree[((root << 1) | 1)].trans[tree[((root << 1) | 1)].d ^ 1];
}
trans_t query(int root, int left, int right) {
if (left <= tree[root].lft && tree[root].rgt <= right)
return tree[root].trans[tree[root].d];
int mid(tree[root].lft + tree[root].rgt >> 1);
pushdown(root);
if (right <= mid) return query((root << 1), left, right);
if (left > mid) return query(((root << 1) | 1), left, right);
return query((root << 1), left, right) +
query(((root << 1) | 1), left, right);
}
int main() {
long long d;
gi(n), gi(m), gi(q);
for (int i = 1; i <= n; i++) gi(seq[i]);
for (int i = 1; i <= m; i++) I[0].arr[i] = I[1].arr[i] = i + 1;
I[0].arr[m + 1] = m + 1, I[1].arr[m + 1] = 1;
build(1, 1, n);
for (int o, l, r, i = 1; i <= q; i++) {
gi(o), gi(l), gi(r);
if (o == 1) {
gi(d), d = d & 1ll;
if (d == 1ll) update(1, l, r);
} else {
trans_t res = query(1, l, r);
print(res.arr[m + 1] == 1 ? 2 : 1), pc('\n');
}
}
return 0;
}
| 22 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int b[200005];
long long dp[200005][18][2][2];
int main() {
cin >> n >> k;
memset(b, false, sizeof(b));
for (int i = 1; i <= k; ++i) {
int a;
cin >> a;
b[a] = true;
}
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= (1 << n); j += (1 << i)) {
if (i == 1) {
for (int k1 = 0; k1 < 2; ++k1) {
for (int k2 = 0; k2 < 2; ++k2) {
if (k1 + k2 != b[j] + b[j + 1]) continue;
dp[j][i][k1][k2] = (b[j] || b[j + 1]);
}
}
} else {
for (int x1 = 0; x1 < 2; ++x1) {
for (int y1 = 0; y1 < 2; ++y1) {
for (int x2 = 0; x2 < 2; ++x2) {
for (int y2 = 0; y2 < 2; ++y2) {
int j2 = j + (1 << (i - 1));
if (dp[j][i - 1][x1][y1] < 0 || dp[j2][i - 1][x2][y2] < 0)
continue;
long long tmp = dp[j][i - 1][x1][y1] + dp[j2][i - 1][x2][y2];
if (x1 || x2) tmp++;
if (y1 || y2) tmp++;
long long t1 = (x2 || y1);
dp[j][i][x1][x2] = max(dp[j][i][x1][x2], tmp + t1);
dp[j][i][x1][y1] = max(dp[j][i][x1][y1], tmp + t1);
t1 = (x2 || y2);
dp[j][i][x1][x2] = max(dp[j][i][x1][x2], tmp + t1);
dp[j][i][x1][y2] = max(dp[j][i][x1][y2], tmp + t1);
t1 = (x1 || y2);
dp[j][i][x2][x1] = max(dp[j][i][x2][x1], tmp + t1);
dp[j][i][x2][y2] = max(dp[j][i][x2][y2], tmp + t1);
t1 = (x1 || y1);
dp[j][i][x2][x1] = max(dp[j][i][x2][x1], tmp + t1);
dp[j][i][x2][y1] = max(dp[j][i][x2][y1], tmp + t1);
}
}
}
}
}
}
}
long long ans = 0LL;
for (int k1 = 0; k1 < 2; ++k1) {
for (int k2 = 0; k2 < 2; ++k2) {
ans = max(ans, dp[1][n][k1][k2] + (k1 || k2));
}
}
cout << ans << endl;
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long funtion(long long n) {
if (n < 50) {
return pow(2, n);
} else
return ((funtion(n / 2 + (n % 2)) % 1000000007) *
(funtion(n / 2) % 1000000007)) %
1000000007;
}
int main() {
long long r, c, i, j, k, l;
cin >> r >> c;
long long row[r], colum[c];
for (i = 0; i < r; i++) cin >> row[i];
for (i = 0; i < c; i++) cin >> colum[i];
long long arr[r][c];
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++) {
arr[i][j] = 0;
}
}
for (i = 0; i < r; i++) {
for (j = 0; j < row[i]; j++) {
arr[i][j] = 1;
}
arr[i][row[i]] = -1;
}
for (i = 0; i < c; i++) {
for (j = 0; j < colum[i]; j++) {
if (arr[j][i] != -1)
arr[j][i] = 1;
else {
cout << 0;
exit(0);
}
}
if (arr[colum[i]][i] != 1)
arr[colum[i]][i] = -1;
else {
cout << 0;
exit(0);
}
}
int count = 0;
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++) {
if (arr[i][j] != 1 && arr[i][j] != -1) count++;
}
}
long long ans;
ans = funtion(count);
cout << ans;
}
| 6 |
#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);
}
const int N = 50005;
vector<int> adj[N];
int fa[N], _a[N], _dep[N], a[N], t[N], dep[N], tops[N], siz[N];
int n, q, cnt, ans, dfn;
void dfs0(int u) {
tops[u] = ++dfn;
siz[u] = 1;
for (int i = 0; i < (int)adj[u].size(); i++)
_dep[adj[u][i]] = _dep[u] + 1, dfs0(adj[u][i]), siz[u] += siz[adj[u][i]];
}
int main() {
read(n);
read(q);
for (int i = 1; i <= n; i++) read(_a[i]);
for (int i = 2; i <= n; i++) read(fa[i]), adj[fa[i]].push_back(i);
dfs0(1);
for (int i = 1; i <= n; i++) a[tops[i]] = _a[i], dep[tops[i]] = _dep[i];
for (int T = 1; T <= q; T++) {
int x;
read(x);
ans = cnt = 0;
for (register int i = tops[x]; i <= tops[x] + siz[x] - 1; ++i) {
if (t[i] <= T) {
ans += dep[i];
++cnt;
t[i] = T + a[i];
}
}
print(ans - cnt * _dep[x], ' ');
print(cnt, '\n');
}
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10010;
int n, m, dsu[N];
int find(int x) { return x == dsu[x] ? x : dsu[x] = find(dsu[x]); }
bool Union(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return false;
dsu[u] = v;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; ++i) dsu[i] = i;
for (int i = 0, a, b; i < m; ++i) {
cin >> a >> b;
if (!Union(a, b)) return cout << "no\n", 0;
}
int cmp = find(1);
for (int i = 1; i <= n; ++i)
if (cmp != find(i)) return cout << "no\n", 0;
cout << "yes\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
int m = max(3 * (a / 10), a - ((a / 250) * c));
int v = max(3 * (b / 10), b - ((b / 250) * d));
if (m > v)
cout << "Misha";
else if (m == v)
cout << "Tie";
else
cout << "Vasya";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int t;
cin >> t;
int n, x;
long long sum;
while (t--) {
cin >> n >> x;
sum = 0;
int arr[n + 5], ans = -1;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
sum += arr[i];
ans = sum % x ? max(ans, max(i, n - i)) : ans;
}
cout << ans << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string a;
cin >> a;
map<int, pair<int, int> > m;
map<pair<int, int>, int> m1;
for (int i = -7; i <= 7; i++) {
for (int j = -7; j <= 7; j++) {
m1[{i, j}] = -1;
}
}
m1[{1, 1}] = 1;
m1[{2, 1}] = 2;
m1[{3, 1}] = 3;
m1[{1, 2}] = 4;
m1[{2, 2}] = 5;
m1[{3, 2}] = 6;
m1[{1, 3}] = 7;
m1[{2, 3}] = 8;
m1[{3, 3}] = 9;
m1[{2, 4}] = 0;
m[1] = {1, 1};
m[2] = {2, 1};
m[3] = {3, 1};
m[4] = {1, 2};
m[5] = {2, 2};
m[6] = {3, 2};
m[7] = {1, 3};
m[8] = {2, 3};
m[9] = {3, 3};
m[0] = {2, 4};
int i, j;
for (i = 0; i <= 9; i++) {
if (i == a[0] - '0') continue;
int cur = i;
for (j = 0; j < a.size() - 1; j++) {
int x = m[a[j + 1] - '0'].first - m[a[j] - '0'].first;
int y = m[a[j + 1] - '0'].second - m[a[j] - '0'].second;
if (m1[{(x + m[cur].first), (y + m[cur].second)}] != -1) {
cur = m1[{x + m[cur].first, y + m[cur].second}];
continue;
}
break;
}
if (j == a.size() - 1) {
cout << "NO" << '\n';
return 0;
}
}
cout << "YES" << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> To[100], iTo[100];
bool u[100];
long long dp[1 << 17];
int a[100], order[100];
long long Calc(int mask, int n, int fr) {
int cur = __builtin_popcount(mask);
if (cur == n) return 1;
long long &ans = dp[mask];
if (ans != -1) return ans;
ans = 0;
for (int i = 0; i < n; ++i)
if (!(mask & (1 << i))) {
bool ok = true;
int v = order[cur];
for (int j = 0; ok && j < To[i + fr].size(); ++j) {
int u = To[i + fr][j];
if (fr <= u) {
if (mask & (1 << (u - fr))) ok = false;
} else {
if (a[u] < v) ok = false;
}
}
for (int j = 0; ok && j < iTo[i + fr].size(); ++j) {
int u = iTo[i + fr][j];
if (fr <= u) {
if (!(mask & (1 << (u - fr)))) ok = false;
} else {
if (a[u] > v) ok = false;
}
}
if (ok) ans += Calc(mask | (1 << i), n, fr);
}
return ans;
}
int main() {
int n, m;
long long k;
cin >> n >> k >> m;
k -= 2000;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
u--;
v--;
To[u].push_back(v);
iTo[v].push_back(u);
}
for (int i = 0; i < n; ++i) order[i] = i;
for (int i = 0; i < n; ++i) {
bool found = false;
for (int j = 0; j < n - i; ++j) {
memset(dp, -1, sizeof(dp));
a[i] = order[j];
for (int l = j; l < n - i - 1; ++l) order[l] = order[l + 1];
long long tmp = Calc(0, n - i - 1, i + 1);
if (tmp >= k) {
found = true;
break;
}
order[n - i - 1] = a[i];
sort(order, order + n - i);
k -= tmp;
}
if (!found) {
puts("The times have changed");
return 0;
}
}
if (k > 1) {
puts("The times have changed");
return 0;
}
for (int i = 0; i < n; ++i) printf("%d ", a[i] + 1);
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int s, n, i, j;
cin >> s >> n;
int ara[n][2];
for (i = 0; i < n; i++) {
for (j = 0; j < 2; j++) {
cin >> ara[i][j];
}
}
int c = 0;
for (i = 0; i < n; i++) {
int p = 0;
for (j = 0; j < n; j++) {
if (ara[j][0] < s) {
s += ara[j][1];
ara[j][0] = 100000000;
ara[j][1] = 0;
p = 1;
c++;
}
}
if (c == n) {
break;
}
}
if (c == n) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
int l = a.size(), ll = b.size();
if (l != ll) {
cout << "NO\n";
return 0;
}
int one = 0, zero = 0;
for (int i = 0; i < l; i++) {
if (a[i] == '1') {
one++;
}
if (b[i] == '1') zero++;
}
if (one == 0 && zero > 0 || zero == 0 && one > 0)
cout << "NO\n";
else
cout << "YES\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int read() {
char ch = '!';
int res = 0, f = 0;
while (!isdigit(ch)) {
ch = getchar();
if (ch == '-') f = 1;
}
while (isdigit(ch)) res = res * 10 + ch - '0', ch = getchar();
return f ? -res : res;
}
const int N = 2e5 + 100;
int n, Q, K, R, ty[N], tot, mn, rt, used[N], dep[N], mnd[N], sz[N];
int bel[N], son[N], fa[N], dst[N], dfn[N], ts, siz[N], Mn[N << 2], ans[N][3];
vector<int> np, nq, nxt[N], pot[N];
vector<pair<int, int> > qw[N];
bool cmp(int x, int y) { return dep[x] < dep[y]; }
void mdf(int k, int l, int r, int tar, int val) {
if (l == r) {
Mn[k] = val;
return;
}
int mid = (l + r) >> 1;
tar <= mid ? mdf((k << 1), l, mid, tar, val)
: mdf((k << 1 | 1), mid + 1, r, tar, val);
Mn[k] = min(Mn[(k << 1)], Mn[(k << 1 | 1)]);
}
int qry(int k, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return Mn[k];
int mid = (l + r) >> 1, res = 1e9;
if (ql <= mid) res = min(res, qry((k << 1), l, mid, ql, qr));
if (qr > mid) res = min(res, qry((k << 1 | 1), mid + 1, r, ql, qr));
return res;
}
void dfs1(int u, int lst) {
siz[u] = 1, fa[u] = lst, dst[u] = dst[lst] + 1, dfn[u] = ++ts;
for (auto v : nxt[u])
if (v != lst) {
dfs1(v, u), siz[u] += siz[v];
son[u] = siz[v] > siz[son[u]] ? v : son[u];
}
}
void dfs2(int u, int lst) {
bel[u] = son[lst] == u ? bel[lst] : u;
for (auto v : nxt[u])
if (v != lst) dfs2(v, u);
}
int LCA(int x, int y) {
while (bel[x] != bel[y])
dst[bel[x]] > dst[bel[y]] ? x = fa[bel[x]] : y = fa[bel[y]];
return dst[x] < dst[y] ? x : y;
}
queue<int> q;
int vis[N], pa[N], dis[N];
int getfa(int x) { return x == pa[x] ? x : pa[x] = getfa(pa[x]); }
void bfs() {
for (int i = 1; i <= n; ++i)
if (ty[i]) vis[i] = pa[i] = i, q.push(i);
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto v : nxt[u])
if (!vis[v]) vis[v] = vis[u], dis[v] = dis[u] + 1, q.push(v);
}
for (int i = 1; i <= n; ++i)
for (auto j : nxt[i])
if (vis[i] != vis[j] && dis[i] + dis[j] + 1 <= K) {
int x = getfa(vis[i]), y = getfa(vis[j]);
dst[x] < dst[y] ? pa[y] = x : pa[x] = y;
}
for (int i = 1; i <= n; ++i)
if (ty[i]) pot[mnd[i] = getfa(i)].push_back(i);
}
void getRoot(int u, int lst) {
sz[u] = 1;
int _mx = 0;
for (auto v : nxt[u])
if (v != lst && !used[v]) {
getRoot(v, u);
sz[u] += sz[v];
_mx = max(_mx, sz[v]);
}
_mx = max(_mx, tot - sz[u]);
if (_mx < mn) mn = _mx, rt = u;
}
void getdep(int u, int lst) {
dep[u] = -1;
for (auto v : nxt[u])
if (v != lst && !used[v]) getdep(v, u);
}
void dfs(int u) {
used[u] = 1;
np.clear(), nq.clear();
dep[0] = -1, getdep(u, 0);
q.push(u);
dep[u] = 0;
while (!q.empty()) {
int x = q.front();
q.pop();
(ty[x] ? nq : np).push_back(x);
for (auto y : nxt[x])
if (!~dep[y] && !used[y]) dep[y] = dep[x] + 1, q.push(y);
}
reverse(np.begin(), np.end());
for (int i = 0, j = 0, w = -1; i < np.size(); ++i) {
while (j < nq.size() && dep[nq[j]] + dep[np[i]] <= K)
(!~w || dst[mnd[nq[j]]] < dst[w]) ? w = mnd[nq[j]] : 0, ++j;
if (~w) dst[w] < dst[mnd[np[i]]] ? mnd[np[i]] = w : 0;
}
for (auto v : nxt[u])
if (!used[v]) {
tot = mn = sz[v], rt = 0;
getRoot(v, 0);
dfs(rt);
}
}
int main() {
n = read(), K = read(), R = read();
for (int i = 1; i < n; ++i) {
int x = read(), y = read();
nxt[x].push_back(y), nxt[y].push_back(x);
}
for (int i = 1; i <= R; ++i) ty[read()] = 1;
dfs1(1, 0), dfs2(1, 0);
for (int i = 1; i <= n; ++i) mnd[i] = i;
dst[0] = -1e9;
bfs();
tot = mn = n;
getRoot(1, 0);
dfs(rt);
Q = read();
for (int i = 1; i <= Q; ++i) {
int x = read(), y = read(), z = LCA(x, y);
if (mnd[x] == mnd[y]) continue;
qw[mnd[x]].push_back(pair<int, int>(i, z));
qw[mnd[y]].push_back(pair<int, int>(-i, z));
ans[i][0] = dst[x], ans[i][1] = dst[y], ans[i][2] = dst[z];
}
for (int i = 1; i <= n << 2; ++i) Mn[i] = 1e9;
for (int i = 1; i <= n; ++i)
if (mnd[i] == i) {
for (auto x : pot[i]) mdf(1, 1, n, dfn[x], dst[x]);
for (auto t : qw[i]) {
int id = abs(t.first), o = t.first < 0, x = t.second;
ans[id][o] = min(ans[id][o], qry(1, 1, n, dfn[x], dfn[x] + siz[x] - 1));
}
for (auto x : pot[i]) mdf(1, 1, n, dfn[x], 1e9);
}
for (int i = 1; i <= Q; ++i)
puts(ans[i][0] + ans[i][1] - 2 * ans[i][2] <= K ? "YES" : "NO");
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
int NWD(int a, int b) { return (b == 0) ? (a) : (NWD(b, a % b)); }
char s[100007];
int n;
int k[100007];
vector<int> t[100007];
int m = 1000000007;
char pom[100007];
int w[11];
int l[11];
int main() {
ios_base::sync_with_stdio(0);
cin >> s;
cin >> n;
for (int i = 0; i < (n); ++i) {
cin >> pom;
k[i] = pom[0] - '0';
for (int j = 3; pom[j]; j++) t[i].push_back(pom[j] - '0');
}
for (int i = (0); i <= (9); ++i) l[i] = 10;
for (int i = (0); i <= (9); ++i) w[i] = i;
for (int i = (n - 1); i >= (0); --i) {
long long wyn = 0;
long long len = 1;
for (int j = 0; j < t[i].size(); ++j) {
len *= l[t[i][j]];
len %= m;
wyn *= l[t[i][j]];
wyn += w[t[i][j]];
wyn %= m;
}
w[k[i]] = wyn;
l[k[i]] = len;
}
long long wynik = 0;
for (int i = 0; s[i]; ++i) {
wynik *= l[s[i] - '0'];
wynik += w[s[i] - '0'];
wynik %= m;
}
cout << wynik << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
double m[6], w[6], kol[6], hs, hu, ans;
int i;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
for (i = 1; i <= 5; i++) cin >> m[i];
for (i = 1; i <= 5; i++) cin >> w[i];
cin >> hs >> hu;
kol[1] = 500;
kol[2] = 1000;
kol[3] = 1500;
kol[4] = 2000;
kol[5] = 2500;
for (i = 1; i <= 5; i++)
ans += max(kol[i] * 0.3, (1 - m[i] / 250) * kol[i] - w[i] * 50);
ans += hs * 100;
ans -= hu * 50;
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long int MOD = 1e11 + 7;
void solve() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
unsigned long long int n;
cin >> n;
vector<string> v;
unsigned long long int a = 1, b = 0;
string ans;
for (unsigned long long int i = 0; i < n; i++) {
string s;
cin >> s;
v.push_back(s);
if (i != 0) {
if (v[0] == v[i]) {
a++;
} else {
ans = v[i];
b++;
}
}
}
if (a > b) {
cout << v[0] << "\n";
} else {
cout << ans << "\n";
}
}
signed main() {
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double n, h, f, x[511], y[511], ans;
double calc(double x, double y) {
if (x == 0 || y == 0) return 0;
if (x > y) swap(x, y);
if (x < 0 && y > 0) return x * ((f + h) / (f - h) + 1) * h;
if (x < 0 && y < 0) swap(x, y), x = -x, y = -y;
if (x * (f + h) / (f - h) < y) return x * ((f + h) / (f - h) + 1) * h;
double a = f * (y - x) / (y + x);
double z = x * (f + a) / (f - h);
return ((y + z) * (h - a) + (x + z) * (h + a)) / 2.0;
}
int main() {
scanf("%lf%lf%lf", &n, &h, &f);
for (int i = 1; i <= n; ++i) {
scanf("%lf%lf", &x[i], &y[i]);
if (x[i] < 0 && y[i] > 0) x[i + 1] = 0, y[i + 1] = y[i], y[i] = 0, ++i, ++n;
}
for (int i = 1; i <= n; ++i)
ans += (y[i] - x[i]) * ((f + h) / (f - h) + 1.0) * h * 2.0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if ((x[i] < 0 && x[j] < 0) || (y[i] > 0 && y[j] > 0))
ans -= calc(x[i], x[j]) + calc(y[i], y[j]) - calc(x[i], y[j]) -
calc(x[j], y[i]);
printf("%.10lf\n", ans);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 55;
float n, c, l, p, q;
int main() {
scanf("%f%f%f", &n, &p, &q);
printf("%.10f", n * p / (p + q));
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[2010];
int main() {
int k;
scanf("%d", &k);
a[0] = -1;
int ans = 1;
for (int i = 2; i <= 2000; i++) {
int tmp = (k + i) / (i - 1);
int t1 = k + i - tmp * (i - 1) + tmp;
if (tmp <= int(1e6) && tmp >= 1 && t1 <= int(1e6)) {
ans = i;
break;
}
}
int sum = k + ans;
int t = sum / (ans - 1);
int t1 = sum - t * (ans - 1);
printf("%d\n", ans);
printf("-1 ");
for (int i = 1; i <= ans - 1; i++) {
if (i == ans - 1) {
printf("%d\n", t + t1);
} else {
printf("%d ", t);
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
ll sum = 0;
vector<vector<ll>> dp(n);
vector<ll> v(n);
for (ll i = 0; i < n; ++i) {
cin >> v[i];
sum += v[i] * ((i + 1) % 2);
dp[i].push_back(0);
dp[i].push_back(0);
}
if (n == 1) {
cout << sum << endl;
} else {
dp[1][1] = max(dp[1][1], -v[0] + v[1]);
dp[1][0] = max(dp[0][0], dp[1][1]);
for (int i = 2; i < n; ++i) {
if (i % 2 == 0) {
dp[i][1] = max(dp[i - 2][1] - v[i] + v[i - 1], dp[i][1]);
dp[i][0] = max(dp[i - 1][0], dp[i][1]);
} else {
dp[i][1] = max(dp[i - 2][1] + v[i] - v[i - 1], dp[i][1]);
dp[i][0] = max(dp[i - 1][0], dp[i][1]);
}
}
cout << dp[n - 1][0] + sum << endl;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<string> v;
unordered_map<char, int> p;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
v.push_back(s);
}
for (int i = 0; i < v.size(); i++) {
string s = v[i];
for (int i = 0; i < s.length(); i++) {
p[s[i]] = p[s[i]] + 1;
}
}
int flag = 0;
for (auto i = p.begin(); i != p.end(); i++) {
if (i->second < n || i->second % n != 0) {
flag = 1;
break;
}
}
if (flag == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x, y, a, b, i, j, d[2001][2001];
bool occupied[2001][2001];
bool found(int x, int y, int z) {
int l = max(x - z, 1), r = min(x + z, n), i, t;
for (i = l; i <= r; i++) {
t = z - abs(i - x);
if (y - t > 0 && !occupied[i][y - t]) {
a = i;
b = y - t;
return 1;
}
if (y + t <= m && !occupied[i][y + t]) {
a = i;
b = y + t;
return 1;
}
}
return 0;
}
int main() {
memset(occupied, 0, sizeof(occupied));
memset(d, 0, sizeof(d));
cin >> n >> m >> k;
while (k--) {
cin >> x >> y;
for (i = -2; i < 3; i++) {
for (j = -2; j < 3; j++) {
if (x + i < 1 || x + i > n || y + j < 1 || y + j > m) continue;
d[x][y] = max(d[x][y], d[x + i][y + j] - abs(i) - abs(j));
}
}
while (!found(x, y, d[x][y])) d[x][y]++;
cout << a << " " << b << endl;
occupied[a][b] = 1;
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9+7;
const ll INF = 1e18;
#define rep(i,m,n) for(ll i = (m); i <= (n); i++)
#define zep(i,m,n) for(ll i = (m); i < (n); i++)
#define rrep(i,m,n) for(ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x,m,n) for(int i = (m); i <= n; i++){cout << (x[i]) << " ";} cout<<endl;
ll x[4], y[4];
bool cross(ll a, ll b, ll c, ll d){
return !(b < c || d < a);
}
vector<ll> g(ll a, ll b, ll c, ll d){
ll cx = abs(a - b) + abs(c - d);
ll llb = min(a, b);
ll lrb = max(a, b);
ll rlb = min(c, d);
ll rrb = max(c, d);
ll mnx = cross(llb, lrb, rlb, rrb)? 0 : min(abs(llb - rrb), abs(lrb - rlb));
ll mxx = max(max(lrb - llb, rrb - rlb), max(lrb - rlb, rrb - llb));
return {cx, mnx, mxx};
}
ll f(ll a, ll b, ll c){
auto vx = g(x[0], x[a], x[b], x[c]);
auto vy = g(y[0], y[b], y[a], y[c]);
if(cross(vx[1], vx[2], vy[1], vy[2])){
return vx[0] + vy[0];
}
return vx[0] + vy[0] + 2 * min(abs(vx[1] - vy[2]), abs(vx[2] - vy[1]));
}
int main(){
cin.tie(0); ios::sync_with_stdio(false);
ll t; cin >> t;
while(t--){
zep(i, 0, 4)cin >> x[i] >> y[i];
ll ans = INF;
ans = min(ans, f(1, 2, 3));
ans = min(ans, f(1, 3, 2));
ans = min(ans, f(2, 1, 3));
ans = min(ans, f(2, 3, 1));
ans = min(ans, f(3, 1, 2));
ans = min(ans, f(3, 2, 1));
print(ans)
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int N, D;
int main() {
int i, a, b, res = 0;
scanf("%d%d", &N, &D);
scanf("%d", &a);
for (i = 1; i < N; i++) {
scanf("%d", &b);
if (b <= a) {
int d = (a - b) / D + 1;
b += d * D;
res += d;
}
a = b;
}
printf("%d", res);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n + 1];
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
int sum = 0;
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
sum = min(a[x], a[y]) + sum;
}
cout << sum;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
static inline void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static inline void amax(T &x, U y) {
if (x < y) x = y;
}
const int N = 1e7;
const long long int mod = 1e9 + 7;
void solve() {
long long int n, k, i, ans = 0;
string s;
cin >> n >> k >> s;
long long int cnt[26]{0};
for (i = 0; i < n; i++) cnt[s[i] - 'A']++;
sort(cnt, cnt + 26);
for (i = 25; i >= 0 && k > 0; i--) {
if (cnt[i]) {
if (cnt[i] <= k && k > 0) {
ans += cnt[i] * cnt[i];
k -= cnt[i];
} else {
ans += k * k;
k = 0;
}
}
}
cout << ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char t[] = "qwertyuiopasdfghjkl;zxcvbnm,./";
int n = strlen(t);
char c;
string x;
cin >> c >> x;
for (int i = 0; i < x.size(); ++i) {
for (int j = 0; j < n; ++j) {
if (t[j] == x[i]) {
x[i] = (c == 'L') ? t[j + 1] : t[j - 1];
break;
}
}
}
cout << x << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2010;
int n, m, ans;
string a[MAXN];
bool t[MAXN], ok;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int p = 0; p < m; p++) {
ok = true;
for (int i = 1; i < n; i++)
if (!t[i] && a[i][p] > a[i + 1][p]) ok = false;
if (!ok) {
ans++;
continue;
}
for (int i = 1; i < n; i++)
if (a[i][p] != a[i + 1][p]) t[i] = true;
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 10;
int top, indegree[maxn], n, money[maxn];
struct Edge {
int to;
Edge* next;
} * head[maxn], e[maxn];
void Addedge(int from, int to) {
Edge* p = &e[top++];
p->to = to, p->next = head[from], head[from] = p;
}
void Topsort() {
queue<int> Q;
int k = 1, i;
for (i = 1; i <= n; i++)
if (!indegree[i]) {
Q.push(i);
money[i] = 1;
}
while (!Q.empty()) {
int x = Q.front();
Q.pop();
for (Edge* p = head[x]; p; p = p->next) {
indegree[p->to]--;
if (!indegree[p->to]) {
money[p->to] = money[x] + 1;
Q.push(p->to);
}
}
}
}
int main() {
int i, ans, a;
while (~scanf("%d", &n)) {
ans = top = 0;
memset(head, 0, sizeof(head));
for (i = 1; i <= n; i++) {
scanf("%d", &a);
if (a != -1) Addedge(a, i), indegree[i]++;
}
Topsort();
for (i = 1; i <= n; i++) ans = max(ans, money[i]);
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, dp[505][505][11], s[505][11], tt, k, cnt[505], dep[505];
char ch[505];
int Dp(int u, int d, int lk) {
if (dp[u][d][lk] != -1) return dp[u][d][lk];
int tmp[11], bb[11], tmpx[11];
memset(bb, 0, sizeof(bb));
for (int i = 0; i < 10; i++)
if (s[u][i]) {
for (int j = 0; j <= lk; j++) tmp[j] = Dp(s[u][i], d, j);
memset(tmpx, 0x3f, sizeof(tmpx));
for (int x = 0; x <= lk; x++)
for (int y = 0; x + y <= lk; y++)
tmpx[x + y] = min(tmpx[x + y], tmp[x] + bb[y]);
memcpy(bb, tmpx, sizeof(tmpx));
}
int res = bb[lk] + cnt[u] * (dep[u] - d);
if (lk) res = min(res, Dp(u, dep[u], lk - 1));
return dp[u][d][lk] = res;
}
int main() {
scanf("%d%d", &n, &k);
int opt;
for (int i = 1; i <= n; i++) {
scanf("%s%d", ch + 1, &opt);
int len = strlen(ch + 1), now = 0;
for (int j = 1; j <= len; j++) {
if (!s[now][ch[j] - '0'])
s[now][ch[j] - '0'] = ++tt, dep[tt] = dep[now] + 1;
now = s[now][ch[j] - '0'];
}
cnt[now] += opt;
}
memset(dp, -1, sizeof(dp));
printf("%d\n", Dp(0, 0, k));
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
string brain(char a) {
if (a == '>') return "1000";
if (a == '<') return "1001";
if (a == '+') return "1010";
if (a == '-') return "1011";
if (a == '.') return "1100";
if (a == ',') return "1101";
if (a == '[') return "1110";
return "1111";
}
long long dec(string str) {
long long rez = 0;
long long mn = 1;
for (int i = str.length() - 1; i >= 0; i--) {
if (str[i] == '1') {
rez += mn;
rez %= 1000003;
}
mn *= 2;
mn %= 1000003;
}
return rez;
}
int main() {
string all_bin = "";
long long a = 0;
string str;
cin >> str;
for (int i = 0; i < str.length(); i++) {
string bin = brain(str[i]);
all_bin += bin;
}
long long rez = dec(all_bin);
cout << rez % 1000003;
cin >> str;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100005], b[100005], id[100005];
bool cmp(int &x, int &y) { return a[x] > a[y]; }
int main() {
int n;
vector<int> re;
while (scanf("%d", &n) != EOF) {
re.clear();
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
id[i] = i;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
}
sort(id + 1, id + n + 1, cmp);
re.push_back(id[1]);
for (int i = 2; i < n; i += 2) {
re.push_back(b[id[i]] > b[id[i + 1]] ? id[i] : id[i + 1]);
}
if (!(n & 1)) {
re.push_back(id[n]);
}
printf("%d\n", n / 2 + 1);
for (int i = 0; i < re.size(); i++) {
printf("%d%c", re[i], i == re.size() - 1 ? '\n' : ' ');
}
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6;
const long long mod = 1e9 + 7;
int m, k, n;
char s[maxn + 5];
int pre[26];
long long dp[maxn + 5];
int main() {
cin >> m >> k;
scanf("%s", s + 1);
n = strlen(s + 1);
dp[0] = 1;
for (int i = 1; i <= n; ++i) {
if (pre[s[i] - 'a'] == 0)
dp[i] = 2 * dp[i - 1] % mod;
else
dp[i] = (2 * dp[i - 1] - dp[pre[s[i] - 'a'] - 1]) % mod;
pre[s[i] - 'a'] = i;
}
for (int i = n + 1; i <= n + m; ++i) {
int mi = 0;
for (int j = 1; j < k; ++j)
if (pre[j] < pre[mi]) mi = j;
if (pre[mi] == 0)
dp[i] = 2 * dp[i - 1] % mod;
else
dp[i] = (2 * dp[i - 1] - dp[pre[mi] - 1]) % mod;
pre[mi] = i;
}
if (dp[n + m] < 0) dp[n + m] += mod;
cout << dp[n + m];
return 0;
}
| 14 |
#include <bits/stdc++.h>
int main() {
int t, n, m;
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &m);
if (n == 1)
printf("0\n");
else if (n == 2)
printf("%d\n", m);
else
printf("%d\n", 2 * m);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int T, n, maxb, t, a[100100], f[100100];
int main() {
cin >> T >> n >> maxb >> t;
t = min(t, n);
while (T--) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(f, 0, sizeof(f));
int ans = 0;
for (int i = 1; i <= t; i++)
for (int j = 1; j <= n; j++) {
int t = a[j] + 1;
f[a[j]] = max(f[a[j]], 1);
while (f[t] < f[a[j]] + 1 && t <= maxb) f[t] = f[a[j]] + 1, t++;
ans = max(f[a[j]], ans);
if (f[a[j]] == maxb) break;
}
printf("%d\n", ans);
}
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, i, n;
long long x[100002];
int main() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> x[i];
}
for (i = 0; i < n; i++) {
a = x[i + 1] - x[i];
b = x[i] - x[i - 1];
c = x[i] - x[0];
d = x[n - 1] - x[i];
if (i == 0) {
cout << a << " " << d;
cout << endl;
continue;
}
if (i == n - 1) {
cout << b << " " << c;
cout << endl;
continue;
}
cout << min(a, b) << " " << max(c, d);
cout << endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define int long long int
#define endl "\n"
#define mod 1000000007
#define inf 1e18
using namespace std;
void solve() {
int n;
cin >> n;
string s;
cin >> s;
vector<int> dpl(n + 1, 0), dpr(n + 1, 0);
for(int i = 0; i < n + 1; i++) {
if(i == 0) {
dpl[i] = i;
continue;
}
else if(i == 1) {
if(s[i - 1] == 'L') {
dpl[i] = i - 1;
}
else dpl[i] = i;
}
else {
if(s[i - 1] == 'L' and s[i - 2] == 'R')
dpl[i] = dpl[i - 2];
else if(s[i - 1] == 'L')
dpl[i] = i - 1;
else
dpl[i] = i;
}
}
for(int i = n; i >= 0; i--) {
if(i == n) {
dpr[i] = i;
continue;
}
else if(i == n - 1) {
if(s[i] == 'R') {
dpr[i] = i + 1;
}
else dpr[i] = i;
}
else {
if(s[i] == 'R' and s[i + 1] == 'L')
dpr[i] = dpr[i + 2];
else if(s[i] == 'R')
dpr[i] = i + 1;
else
dpr[i] = i;
}
}
for(int i = 0; i <= n; i++)
cout << i - dpl[i] + dpr[i] - i + 1 << " ";
cout << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int t;
cin >> t;
while(t--){
solve();
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[500011];
vector<int> ret;
int visited[500011];
bool flag = true;
void dfs(int v) {
visited[v] = 1;
for (auto nv : g[v]) {
if (visited[nv] == 1) {
flag = false;
} else if (visited[nv] == 0) {
dfs(nv);
}
}
ret.push_back(v);
visited[v] = 2;
}
int main() {
int n, m, i, j;
scanf("%d%d", &n, &m);
int add = m + 1;
for (i = 1; i <= n; ++i) {
vector<pair<int, int>> vc;
vector<int> disc;
vector<int> index;
for (j = 1; j <= m; ++j) {
int value;
scanf("%d", &value);
if (value != -1) {
vc.emplace_back(value, j);
}
}
sort(vc.begin(), vc.end());
for (auto v : vc) {
if (disc.empty() || v.first != disc.back()) {
disc.push_back(v.first);
index.push_back(add);
add += 2;
}
}
for (auto v : vc) {
int idx = lower_bound(disc.begin(), disc.end(), v.first) - disc.begin();
g[index[idx]].push_back(v.second);
g[v.second].push_back(index[idx] + 1);
}
for (j = 0; j < (int)index.size() - 1; ++j) {
g[index[j] + 1].push_back(index[j + 1]);
}
}
for (i = 1; i <= add; ++i) {
g[0].push_back(i);
}
dfs(0);
if (!flag) {
printf("-1\n");
return 0;
}
reverse(ret.begin(), ret.end());
for (auto r : ret) {
if (r >= 1 && r <= m) {
printf("%d ", r);
}
}
printf("\n");
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &item) {
out << '(' << item.first << ", " << item.second << ')';
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
for (const auto &item : v) out << item << ' ';
return out;
}
const int N = 500010;
const int V = 1000000;
struct Node {
int vmin, nrEl, nrMinEl;
friend ostream &operator<<(ostream &out, const Node &n) {
return out << '(' << n.vmin << ' ' << n.nrEl << ' ' << n.nrMinEl << ')';
}
};
struct ST {
Node st[4 * V];
int lazy[4 * V];
void push(int node) {
st[2 * node].vmin += lazy[node];
lazy[2 * node] += lazy[node];
st[2 * node + 1].vmin += lazy[node];
lazy[2 * node + 1] += lazy[node];
lazy[node] = 0;
}
Node combine(const Node &n1, const Node &n2) {
if (!n1.nrEl) return n2;
if (!n2.nrEl) return n1;
Node res;
res.vmin = min(n1.vmin, n2.vmin);
res.nrEl = n1.nrEl + n2.nrEl;
res.nrMinEl = (res.vmin == n1.vmin ? n1.nrMinEl : 0) +
(res.vmin == n2.vmin ? n2.nrMinEl : 0);
return res;
}
void update(int node, int l, int r, int a, int b, int val) {
if (a <= l && r <= b) {
st[node].vmin += val;
lazy[node] += val;
return;
}
push(node);
int mid = (l + r) / 2;
if (a <= mid) update(2 * node, l, mid, a, b, val);
if (mid + 1 <= b) update(2 * node + 1, mid + 1, r, a, b, val);
st[node] = combine(st[2 * node], st[2 * node + 1]);
}
void toggle(int node, int l, int r, int p) {
if (l == r) {
st[node].nrEl = 1 - st[node].nrEl;
st[node].nrMinEl = 1 - st[node].nrMinEl;
return;
}
push(node);
int mid = (l + r) / 2;
if (p <= mid)
toggle(2 * node, l, mid, p);
else
toggle(2 * node + 1, mid + 1, r, p);
st[node] = combine(st[2 * node], st[2 * node + 1]);
}
};
int a[N];
ST st;
int main() {
ios_base::sync_with_stdio(false);
int n, q, p, x;
cin >> n >> q;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
st.toggle(1, 1, V, a[i]);
}
for (int i = 1; i <= n; ++i) {
st.update(1, 1, V, min(a[i], a[i + 1]) + 1, max(a[i], a[i + 1]), 1);
}
while (q--) {
cin >> p >> x;
if (p > 1)
st.update(1, 1, V, min(a[p - 1], a[p]) + 1, max(a[p - 1], a[p]), -1);
st.update(1, 1, V, min(a[p], a[p + 1]) + 1, max(a[p], a[p + 1]), -1);
st.toggle(1, 1, V, a[p]);
a[p] = x;
st.toggle(1, 1, V, a[p]);
if (p > 1)
st.update(1, 1, V, min(a[p - 1], a[p]) + 1, max(a[p - 1], a[p]), 1);
st.update(1, 1, V, min(a[p], a[p + 1]) + 1, max(a[p], a[p + 1]), 1);
cout << st.st[1].nrMinEl << '\n';
}
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const int inf = (1 << 30) - 1;
const long long inf64 = ((long long)1 << 62) - 1;
const long double pi = acos(-1);
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T abs(T x) {
return x < 0 ? -x : x;
}
string s, t;
int main() {
ios_base::sync_with_stdio(0);
cin >> s >> t;
int n = s.length();
int m = t.length();
int ind1 = -1;
for (int i = 0; i < n; ++i) {
ind1++;
while (ind1 < m && t[ind1] != s[i]) {
ind1++;
}
if (ind1 >= m) break;
}
int ind2 = m;
for (int i = n - 1; i >= 0; --i) {
ind2--;
while (ind2 >= 0 && t[ind2] != s[i]) {
ind2--;
}
if (ind2 <= 0) break;
}
cout << max(0, ind2 - ind1) << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, l[152], h[152];
char s[152][152];
int main(int argc, char **argv) {
for (int i = 0; i <= 151; ++i) l[i] = 500, h[i] = -1;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
for (int j = 0; j < m; ++j)
if (s[i][j] == 'W') l[i] = min(l[i], j), h[i] = max(h[i], j);
}
int last = 0, ans = 0, pos = 0;
for (int i = 0; i < n; ++i) {
if (h[i] == -1) continue;
if (i & 1) {
ans += abs(pos - h[i]) + h[i] - l[i];
pos = l[i];
} else {
ans += abs(pos - l[i]) + h[i] - l[i];
pos = h[i];
}
ans += i - last;
last = i;
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long f(long long x, long long y) {
long long h = 1;
long long g = 1;
for (long long i = x; i > x - y; i--) h *= i;
for (long long i = y; i >= 1; i--) g *= i;
return h / g;
}
signed main() {
long long n, k;
cin >> n >> k;
if (k == 4) {
cout << f(n, 4) * 9 + f(n, 3) * 2 + f(n, 2) + 1;
return 0;
}
if (k == 3) {
cout << f(n, 3) * 2 + f(n, 2) + 1;
return 0;
}
if (k == 2) {
cout << f(n, 2) + 1 << endl;
return 0;
}
cout << 1 << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long a[111][111];
int main() {
long long n, m, k, x, y;
cin >> n >> m >> k >> x >> y;
long long sum = m;
if (n > 1) {
sum += m;
}
if (n > 2) {
sum += m * (n - 2) * 2;
}
long long MAX = 0;
long long MIN = 0;
long long me = 0;
if (n == 1) {
MIN = MAX = k / sum;
if (k % sum) {
MAX++;
}
k %= sum;
if (k >= y) {
me = MAX;
} else {
me = MIN;
}
} else if (n == 2) {
MIN = MAX = k / sum;
if (k % sum) {
MAX++;
}
k %= sum;
if (x > 1) {
y += m;
}
if (k + 1 >= y) {
me = MAX;
} else {
me = MIN;
}
} else {
MIN = MAX = k / sum;
MAX *= 2;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == 0 || i == n - 1) {
a[i][j] = MIN;
} else {
a[i][j] = MAX;
}
}
}
k %= sum;
for (int i = 0; i < n && k > 0; i++) {
for (int j = 0; j < m && k > 0; j++, k--) {
a[i][j]++;
}
}
for (int i = n - 2; i > 0 && k > 0; i--) {
for (int j = 0; j < m && k > 0; j++, k--) {
a[i][j]++;
}
}
MIN = 1e18 + 10;
MAX = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
MAX = max(MAX, a[i][j]);
MIN = min(MIN, a[i][j]);
}
}
me = a[x - 1][y - 1];
}
cout << MAX << " " << MIN << " " << me << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, a[55], cum[55];
set<long long> dp[55][55];
set<long long> maxand(long long i, long long k) {
if (k == 1) {
return {cum[n] - cum[i]};
}
if (dp[i][k].empty() == false) {
return dp[i][k];
}
set<long long> ret, t;
for (int x = i + 1; x <= n - k + 1; x++) {
t = maxand(x, k - 1);
for (auto j = t.begin(); j != t.end(); j++) {
ret.insert(((cum[x] - cum[i]) & (*j)));
}
}
return dp[i][k] = ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
cum[i] = cum[i - 1] + a[i];
}
set<long long> ans = maxand(0, k);
long long mx = 0;
for (auto i = ans.begin(); i != ans.end(); i++) {
mx = max(mx, (*i));
}
cout << mx;
}
| 11 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int mod = 1e9 + 7;
const char nl = '\n';
int n, m, k;
int a[15][15];
int p[15 * 15];
void solve() {
int t;
cin >> t;
while (t--) {
cin >> n >> m;
k = 0;
int sum = 0;
for (int i = 1; i <= (n); ++i) {
for (int j = 1; j <= (m); ++j) {
cin >> a[i][j];
p[++k] = a[i][j];
sum += a[i][j];
}
}
sort(p + 1, p + k + 1);
int ans = sum;
for (int i = 2; i <= k; i += 2) {
sum -= 2 * (p[i] + p[i - 1]);
ans = max(ans, sum);
}
cout << ans << nl;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
const long long q = 20;
using namespace std;
long long n, ans, a[100], x;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> x, a[x + q]++;
for (int i = -10; i < 0; i++) {
x = a[i + q] * a[i + q + 2 * abs(i)];
ans += x;
}
ans += (a[q] * (a[q] - 1)) / 2;
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<int> h(n);
for (int i = 0; i < n; ++i) scanf("%d", &h[i]);
stack<int> up, down;
vector<vector<int>> g(n);
auto addEdge = [&](int u, int v) {
if (u > v) swap(u, v);
g[u].push_back(v);
};
for (int i = 0; i < n; ++i) {
int last = -1;
while (!up.empty() && h[up.top()] <= h[i]) {
addEdge(up.top(), i);
last = h[up.top()];
up.pop();
}
if (!up.empty() && last != h[i]) addEdge(up.top(), i);
up.push(i);
last = -1;
while (!down.empty() && h[down.top()] >= h[i]) {
addEdge(down.top(), i);
last = h[down.top()];
down.pop();
}
if (!down.empty() && last != h[i]) addEdge(down.top(), i);
down.push(i);
}
for (int i = 0; i < n; ++i) {
sort(g[i].begin(), g[i].end());
g[i].erase(unique(g[i].begin(), g[i].end()), g[i].end());
}
queue<int> que;
que.push(0);
vector<int> dist(n, -1);
dist[0] = 0;
while (!que.empty()) {
int v = que.front();
que.pop();
for (int u : g[v]) {
if (dist[u] != -1) continue;
dist[u] = dist[v] + 1;
que.push(u);
}
}
printf("%d\n", dist[n - 1]);
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
int a[4][4];
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++) cin >> a[i][j];
for (int i = 0; i < 4; i++) {
if (min(a[i][0], a[i][1]) + min(a[i][2], a[i][3]) <= n) {
cout << i + 1 << " " << min(a[i][0], a[i][1]) << " "
<< n - min(a[i][0], a[i][1]);
return 0;
}
}
cout << -1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
if (k) {
cout << 2 * i << " " << 2 * i - 1 << " ";
k--;
} else {
cout << 2 * i - 1 << " " << 2 * i << " ";
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1000000000000LL;
long long n;
long long POW(long long x, long long y) {
long long tmp = 1;
if (y == 1) return x;
if (y % 2) tmp = x;
long long ans = POW(x, y / 2);
if (ans >= MAX) return MAX;
return ans * ans * tmp > MAX ? MAX : ans * ans * tmp;
}
int dp[60000][100];
int dfs(int a, int b) {
if (POW(a + 1, b) >= n && POW(a, b + 1) >= n) return 0;
if (b == 1 && a * a >= n) return (n - a + 1) % 2;
if (a < 60000 && b < 100 && dp[a][b] != -1) return dp[a][b];
if (((POW(a + 1, b) < n) && !dfs(a + 1, b)) ||
(POW(a, b + 1) < n && !dfs(a, b + 1)))
return (a < 60000 && b < 100) ? dp[a][b] = 1 : 1;
return (a < 60000 && b < 100) ? dp[a][b] = 0 : 0;
}
int main() {
long long a, b;
while (cin >> a >> b >> n) {
memset(dp, -1, sizeof(dp));
if (a == 1 && POW(2, b) >= n) {
cout << "Missing" << endl;
} else {
if (!dfs(a, b))
cout << "Stas" << endl;
else
cout << "Masha" << endl;
}
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592654;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL), cout.tie(NULL);
int x, t;
cin >> x;
vector<int> v(x);
vector<int> ss;
for (int i = 1; i * i <= x; i++) {
if (x % i == 0) t = i;
}
cout << t << " " << x / t << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int max_vis;
vector<int> vis;
vector<vector<int> > adj;
void dfs(int u, int g) {
vis[u] = g;
max_vis = max(max_vis, u);
for (int v : adj[u]) {
if (vis[v] != -1) continue;
dfs(v, g);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, u, v;
cin >> n >> m;
adj.resize(n + 1);
vis.resize(n + 1, -1);
for (int i = 0; i < m; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
max_vis = -1;
int ans = 0, g = -1;
for (int i = 1; i <= n; i++) {
if (vis[i] == -1) {
if (g == -1) {
g = i;
dfs(i, g);
} else {
ans++;
dfs(i, g);
}
}
if (i == max_vis) {
g = -1;
max_vis = -1;
}
}
cout << ans << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void add(vector<pair<int, int> > &ans, int pos1, int pos2) {
pos1 <<= 2;
pos2 <<= 2;
for (int k = 0; k < 4; k++)
for (int i = 0; i < 4; i++)
ans.push_back(pair<int, int>(pos1 + i, pos2 + (i ^ k)));
}
int dx[] = {0, 0, 1, 0, 1, 2}, dy[] = {1, 2, 3, 3, 2, 3};
void add4(vector<pair<int, int> > &ans, int pos) {
pos <<= 2;
for (int i = 0; i < 6; i++)
ans.push_back(pair<int, int>(pos + dx[i], pos + dy[i]));
}
vector<pair<int, int> > make4(int n) {
vector<pair<int, int> > ans;
for (int i = 0; i < n / 4; i++) add4(ans, i);
for (int i = 0; i < n / 4; i++)
for (int j = 0; j < i; j++) add(ans, j, i);
return ans;
}
int n;
void solve() {
vector<pair<int, int> > ans;
if (n % 4 == 0)
ans = make4(n);
else if (n % 4 == 1) {
vector<pair<int, int> > tmp = make4(n - 1);
for (int i = 0; i < tmp.size(); i++) {
pair<int, int> p = tmp[i];
int x = p.first, y = p.second;
if (x > y) swap(x, y);
if (y == x + 1 && y % 2) {
ans.push_back(pair<int, int>(n - 1, x));
ans.push_back(pair<int, int>(x, y));
ans.push_back(pair<int, int>(n - 1, y));
} else
ans.push_back(p);
}
} else {
puts("NO");
return;
}
puts("YES");
for (int i = 0; i < ans.size(); i++) {
pair<int, int> p = ans[i];
if (p.first > p.second) swap(p.first, p.second);
printf("%d %d\n", p.first + 1, p.second + 1);
}
}
int main() {
while (~scanf("%d", &n)) solve();
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, val;
vector<int> v;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> n;
for (int j = 0; j < n; j++) {
cin >> val;
v.push_back(val);
}
if (v[0] + v[1] > v[n - 1]) {
cout << -1 << endl;
} else {
cout << "1 "
<< "2 " << n << endl;
}
v.clear();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int ans = 0;
struct node {
node *next[26];
int strings;
bool end;
node() {
for (int i = 0; i < 26; i++) {
next[i] = nullptr;
}
strings = 0;
end = false;
}
};
node *root = new node();
void add(const string &s) {
node *cur_v = root;
for (int i = 0; i < s.size(); i++) {
char c = s[i];
if (cur_v->next[c - 'a'] == nullptr) {
cur_v->next[c - 'a'] = new node();
}
cur_v = cur_v->next[c - 'a'];
++cur_v->strings;
}
cur_v->end = true;
}
bool has(const string &s) {
node *cur_v = root;
for (int i = 0; i < s.size(); i++) {
cur_v = cur_v->next[s[i] - 'a'];
if (cur_v == nullptr) {
return false;
}
}
return cur_v->end;
}
void count(const string &s) {
bool used = false;
node *cur_v = root;
for (int i = 0; i < s.size(); ++i) {
++ans;
if (cur_v->next[s[i] - 'a']) {
cur_v = cur_v->next[s[i] - 'a'];
} else {
ans += s.size() - i - 1;
break;
}
if (cur_v->strings == 1 && !cur_v->end && !used) {
node *tmp = cur_v;
bool fl = true;
for (int j = i + 1; j < s.size(); ++j) {
if (cur_v->next[s[j] - 'a']) {
cur_v = cur_v->next[s[j] - 'a'];
} else if (cur_v->end) {
i = j - 1;
++ans;
fl = false;
break;
} else {
cur_v = tmp;
fl = false;
break;
}
}
if (fl && cur_v->end) {
++ans;
break;
}
used = 1;
}
}
if (!has(s)) {
add(s);
}
}
bool separator(char c) {
if (c == '.' || c == ',' || c == '?' || c == '!' || c == '\'' || c == '-' ||
c == ' ') {
return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string buffer;
vector<string> a;
while (getline(cin, buffer)) {
++ans;
a.push_back(buffer);
}
vector<string> words;
for (auto &s : a) {
int l = 0;
for (int r = 0; r < s.size(); ++r) {
if (separator(s[r])) {
string cur = s.substr(l, r - l);
if (cur.size() != 0) {
words.push_back(cur);
}
++ans;
l = r + 1;
}
}
string cur = s.substr(l, s.size() - l);
if (cur.size() != 0) {
words.push_back(cur);
}
}
for (auto s : words) {
count(s);
}
cout << ans << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 300100;
char s[MAXN];
long long n, sol, x;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> s;
n = strlen(s);
for (int i = 0; i < n; i++) s[i] -= '0';
for (int i = 0; i < n; i++) {
if (s[i] % 4 == 0) sol++;
if (i > 0) {
x = s[i - 1] * 10 + s[i];
if (x % 4 == 0) sol += i;
}
}
cout << sol << '\n';
;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
inline void chmin(A &a, B b) {
if (a > b) a = b;
}
template <typename A, typename B>
inline void chmax(A &a, B b) {
if (a < b) a = b;
}
long long N;
vector<long long> G[222222];
bool centroid[222222];
long long subtree_size[222222];
long long compute_subtree_size(long long v, long long p) {
long long c = 1;
for (auto u : G[v]) {
if (u == p || centroid[u]) continue;
c += compute_subtree_size(u, v);
}
subtree_size[v] = c;
return c;
}
pair<long long, long long> search_centroid(long long v, long long p,
long long t) {
pair<long long, long long> res = {INT_MAX, -1};
long long s = 1, m = 0;
for (auto u : G[v]) {
if (u == p || centroid[u]) continue;
res = min(res, search_centroid(u, v, t));
m = max(m, subtree_size[u]);
s += subtree_size[u];
}
m = max(m, t - s);
res = min(res, {m, v});
return res;
}
vector<tuple<long long, long long, long long>> ans;
long long g;
long long s;
long long pre;
void dfs(long long v, long long p, long long d) {
for (auto u : G[v]) {
if (u == p) continue;
dfs(u, v, d + 1);
}
if (d > 1) {
ans.push_back(make_tuple(g, pre, v));
ans.push_back(make_tuple(v, p, s));
pre = v;
}
}
signed main() {
cin >> N;
for (long long i = 0; i < (N - 1); i++) {
long long a, b;
cin >> a >> b;
a--;
b--;
G[a].push_back(b);
G[b].push_back(a);
}
compute_subtree_size(0, -1);
long long x = search_centroid(0, -1, N).second;
compute_subtree_size(x, -1);
long long y = -1;
for (auto u : G[x]) {
if (subtree_size[u] * 2 == N) {
y = u;
}
}
for (auto u : G[x]) {
if (u == y) continue;
g = x;
pre = u;
s = u;
dfs(u, x, 0);
if (pre != u) {
ans.push_back(make_tuple(x, pre, u));
}
}
if (y != -1) {
for (auto u : G[y]) {
if (u == x) continue;
g = y;
pre = u;
s = u;
dfs(u, y, 0);
if (pre != u) {
ans.push_back(make_tuple(y, pre, u));
}
}
}
printf("%lld\n", (long long)ans.size());
for (long long i = 0; i < (ans.size()); i++)
printf("%lld %lld %lld\n", get<0>(ans[i]) + 1, get<1>(ans[i]) + 1,
get<2>(ans[i]) + 1);
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int n, who[N], a[N][N];
bool ban[N][N];
deque<int> pref[N];
void GG() { puts("-1"), exit(0); }
void clip(int k1) {
while (((int)(pref[k1]).size()) && ban[k1][pref[k1].front()])
pref[k1].pop_front();
while (((int)(pref[k1]).size()) && ban[k1][pref[k1].back()])
pref[k1].pop_back();
if (!((int)(pref[k1]).size())) GG();
}
void del(int k1, int k2) { ban[k1][k2] = ban[k2][k1] = 1; }
void add(int k1, int k2) {
who[k2] = k1;
while (1) {
((void)0);
clip(k2);
if (pref[k2].back() != k1)
del(pref[k2].back(), k2);
else
break;
}
}
void work1() {
queue<int> q;
for (int i = (1); i <= (n); ++i) q.push(i);
while (((int)(q).size())) {
int k1 = q.front();
((void)0);
q.pop();
while (1) {
((void)0);
clip(k1);
int k2 = pref[k1].front(), k3 = who[k2];
if (k3 && a[k2][k3] < a[k2][k1]) {
del(k1, k2);
continue;
}
if (k3) {
who[k2] = 0, q.push(k3);
}
add(k1, k2);
break;
}
}
}
int nex(int k1) {
clip(k1);
int k2 = pref[k1].front();
pref[k1].pop_front();
clip(k1);
pref[k1].push_front(k2);
return who[pref[k1][1]];
}
void work2() {
int cur = 1;
while (1) {
((void)0);
for (; cur <= n; ++cur) {
clip(cur);
if (((int)(pref[cur]).size()) > 1) break;
}
if (cur > n) {
for (int i = (1); i <= (n); ++i) printf("%d\n", pref[i].front());
puts("");
exit(0);
}
vector<int> cyc, CYC;
{
int k1 = cur, k2 = cur;
do k1 = nex(k1), k2 = nex(nex(k2));
while (k1 != k2);
do cyc.push_back(k2), k2 = nex(k2);
while (k1 != k2);
}
for (auto k1 : cyc) {
int k2 = pref[k1][0];
CYC.push_back(k2);
who[k2] = 0;
del(k1, k2);
}
for (int i = (0); i <= (((int)(cyc).size()) - 1); ++i) {
add(cyc[i], CYC[(i + 1) % ((int)(CYC).size())]);
}
}
}
int main() {
scanf("%d", &n);
if (n & 1) GG();
for (int i = (1); i <= (n); ++i) {
for (int j = (1); j <= (n); ++j)
if (i != j) scanf("%d", &a[i][j]), pref[i].push_back(j);
sort(pref[i].begin(), pref[i].end(),
[&](int k1, int k2) { return a[i][k1] < a[i][k2]; });
}
work1();
work2();
return 0;
}
| 27 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
vector<vector<pair<int, int>>> tree(n);
for (int i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
tree[x].emplace_back(y, tree[y].size());
tree[y].emplace_back(x, tree[x].size() - 1);
}
queue<pair<int, int>> bfq;
for (int i = 0; i < n; ++i) {
if ((int)tree[i].size() == 1) {
bfq.emplace(1, i);
}
}
vector<int> result(n);
fill(result.begin() + bfq.size() - 1, result.end(), n);
result[0] = 1;
int where = (int)bfq.size() - 2;
while (where > 0) {
int node, steps;
tie(steps, node) = bfq.front();
bfq.pop();
int parent, idx;
tie(parent, idx) = tree[node].front();
swap(tree[parent].back(), tree[parent][idx]);
tree[parent].pop_back();
tree[tree[parent][idx].first][tree[parent][idx].second].second = idx;
if ((int)tree[parent].size() == 1) {
bfq.emplace(steps + 1, parent);
} else {
result[where] = result[where + 1] - steps;
--where;
}
}
for (auto it : result) {
cout << it << ' ';
}
cout << '\n';
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int M = 605;
int read() {
int x = 0, f = 1;
char c;
while ((c = getchar()) < '0' || c > '9') {
if (c == '-') f = -1;
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
int n, b[M], a[M][M], len[M];
signed main() {
n = read();
len[0] = 1;
for (int i = 1; i <= n; i++) {
b[i] = read();
a[i - 1][1]++;
for (int j = 1; j <= len[i - 1]; j++) {
a[i - 1][j + 1] += a[i - 1][j] / 10;
a[i - 1][j] %= 10;
}
for (int j = len[i - 1] + 1; a[i - 1][j]; j++) {
a[i - 1][j + 1] += a[i - 1][j] / 10;
a[i - 1][j] %= 10;
len[i - 1] = j;
}
int tot = b[i], s = 0;
for (int j = 1; j <= len[i - 1]; j++) s += a[i - 1][j];
if (s == tot)
memcpy(a[i], a[i - 1], sizeof a[i - 1]), len[i] = len[i - 1];
else {
for (int j = len[i - 1]; j >= 1; j--)
if (tot > a[i - 1][j]) {
len[i] = max(len[i], j);
a[i][j] = a[i - 1][j];
tot -= a[i - 1][j];
} else {
len[i] = max(len[i], j + 1);
a[i][j + 1]++;
tot--;
break;
}
for (int j = 1; j <= len[i]; j++) {
a[i][j + 1] += a[i][j] / 10;
a[i][j] %= 10;
}
for (int j = len[i] + 1; a[i][j]; j++) {
a[i][j + 1] += a[i][j] / 10;
a[i][j] %= 10;
len[i] = j;
}
tot = b[i];
for (int j = 1; j <= len[i]; j++) tot -= a[i][j];
for (int j = 1; tot; j++) {
if (tot >= 9 - a[i][j])
tot -= (9 - a[i][j]), a[i][j] = 9;
else
a[i][j] += tot, tot = 0;
len[i] = max(len[i], j);
}
}
for (int j = len[i]; j >= 1; j--) printf("%d", a[i][j]);
puts("");
}
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
if (a % 2 == 0 && b % 2 == 0 || a % 2 != 0 && b % 2 != 0) {
int x = abs((b - a) / 2);
int ans = 2 * ((x * (x + 1)) / 2);
cout << ans;
} else {
int x = abs(a - b) / 2;
int ans1 = (x * (x + 1)) / 2;
int ans2 = ((x + 1) * (x + 2)) / 2;
cout << ans1 + ans2;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const int MAXN = 100000 + 7;
const pair<int, int> bad = make_pair(-1, -1);
class RMQ2 {
public:
pair<int, int> t[4 * MAXN];
RMQ2() {
for (int i = (0); i < (MAXN * 4); ++i) t[i] = bad;
}
void push(int v) {
if (t[v] != bad) {
t[v * 2] = t[v * 2 + 1] = t[v];
t[v] = bad;
}
}
void update(int v, int tl, int tr, int l, int r, pair<int, int> val) {
if (l > r) return;
if (l == tl && tr == r)
t[v] = val;
else {
push(v);
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(r, tm), val);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, val);
}
}
pair<int, int> get(int v, int tl, int tr, int pos) {
if (tl == tr) return t[v];
push(v);
int tm = (tl + tr) / 2;
if (pos <= tm)
return get(v * 2, tl, tm, pos);
else
return get(v * 2 + 1, tm + 1, tr, pos);
}
};
int A[MAXN], B[MAXN];
RMQ2 rmq;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = (0); i < (n); ++i) scanf("%d", &A[i]);
for (int i = (0); i < (n); ++i) scanf("%d", &B[i]);
for (int i = (0); i < (m); ++i) {
int tp;
scanf("%d", &tp);
if (tp == 1) {
int x, y, k;
scanf("%d%d%d", &x, &y, &k);
x--;
y--;
rmq.update(1, 0, n - 1, y, y + k - 1, make_pair(x, y));
continue;
}
int pos;
scanf("%d", &pos);
pos--;
pair<int, int> z = rmq.get(1, 0, n - 1, pos);
int res = 0;
if (z == bad) {
res = B[pos];
} else {
int shuffle_x = pos - z.second;
int pos_x = z.first + shuffle_x;
res = A[pos_x];
}
printf("%d\n", res);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
int x = b - a;
if (a == b)
cout << 0 << endl;
else if (x < 0 && (-x) & 1)
cout << 2 << endl;
else if (x < 0 && (-x) % 2 == 0)
cout << 1 << endl;
else if (x > 0 && x & 1)
cout << 1 << endl;
else
cout << 2 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char S[100005], a[100005];
int N, f[100005], g[100005], h[100005], r[100005];
int main() {
scanf("%s", S + 1), N = strlen(S + 1), S[0] = 1;
for (int i = 1; i <= N; i++) a[i] = S[N - i + 1];
for (int i = 1, p = 0, q = 0; i <= N; i++) {
r[i] = q > i ? min(r[2 * p - i], q - i) : 1;
for (; S[i + r[i]] == S[i - r[i]]; r[i]++)
;
if (i + r[i] > q) p = i, q = i + r[i];
}
for (int i = 2, j; i <= N; i++) {
for (j = f[i - 1]; j && a[j + 1] != a[i]; j = f[j])
;
f[i] = j + (a[j + 1] == a[i]);
}
for (int i = 1, j = 0; i <= N; i++) {
for (; j && a[j + 1] != S[i]; j = f[j])
;
if (a[j + 1] == S[i]) j++;
g[i] = j, h[i] = g[h[i - 1]] > j ? h[i - 1] : i;
}
int ans = 0, a1, a2, a3, l1, l2;
for (int i = 1; i <= N; i++) {
int x = min(g[h[i - r[i]]], N - i - r[i] + 1);
if (r[i] * 2 + x * 2 - 1 > ans)
ans = r[i] * 2 + x * 2 - 1, a1 = h[i - r[i]] - x + 1, l1 = x,
a2 = i - r[i] + 1, l2 = 2 * r[i] - 1, a3 = N - x + 1;
}
printf("%d\n", 2 * !!l1 + !!l2);
if (l1) printf("%d %d\n", a1, l1);
if (l2) printf("%d %d\n", a2, l2);
if (l1) printf("%d %d\n", a3, l1);
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[10];
bool vis[10];
int val[10];
int n, m, sum, ans, x, y;
set<pair<int, int>> s;
vector<pair<int, int>> edge;
void dfs(int v) {
vis[v] = true;
for (auto u : g[v]) {
if (vis[u] == false) {
int val1 = min(val[u], val[v]);
int val2 = max(val[u], val[v]);
if (s.find({val1, val2}) == s.end()) {
s.insert({val1, val2});
sum++;
}
dfs(u);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
edge.push_back({x, y});
}
if (n <= 6) {
cout << m;
return 0;
}
for (int i = 1; i <= 7; i++) {
for (int j = 1; j <= 7; j++) {
s.clear();
if (i == j) {
continue;
}
for (int k = 1; k <= 7; k++) {
val[k] = k;
}
val[i] = val[j];
sum = 0;
for (auto it : edge) {
int val1 = min(val[it.first], val[it.second]),
val2 = max(val[it.first], val[it.second]);
if (s.find({val1, val2}) == s.end()) {
sum++;
s.insert({val1, val2});
}
}
ans = max(ans, sum);
}
}
cout << ans;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
long long int ans = 0;
long long int l = 0, r = 2;
if (n == 1) {
cout << "1";
} else if (n == 2) {
cout << "2";
} else {
for (; r < n; ++r) {
if (a[r] == a[r - 1] + a[r - 2]) {
continue;
} else {
ans = max(ans, r - l);
l = r - 1;
}
}
cout << max(ans, r - l);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 0.0000001;
const double PI = acos(-1);
const long long INFLL = 0x7FFFFFFFFFFFFFFF;
const int INF = 0x7FFFFFFF;
template <typename T>
inline void next(T &num) {
char c;
num = 0;
do {
c = getchar_unlocked();
} while (c != EOF && c == ' ' && c == '\n' && c == '\t');
int sign = (c == '-' ? -1 : 1);
if (c != '-') num += (c - '0');
while ((c = getchar_unlocked()) != EOF && c != '\n' && c != '\t' &&
c != ' ') {
num *= 10;
num += (c - '0');
}
num *= sign;
}
inline string getstr() {
string str;
char k;
while ((k = getchar_unlocked()) == ' ' || k == '\n') {
k = getchar_unlocked();
if (k == ' ' || k == '\n')
continue;
else
break;
}
str.push_back(k);
while ((k = getchar_unlocked()) != EOF && k != '\n' && k != '\t' &&
k != '\v' && k != '\0' && k != ' ')
str.push_back(k);
return str;
}
int h[45][45][45][45], x[45][45], n, m, q;
int main() {
cin >> n >> m >> q;
for (int i = int(1), _b = int(n); i <= _b; i++) {
getchar_unlocked();
for (int j = int(1), _b = int(m); j <= _b; j++)
x[i][j] = (getchar_unlocked() - '0') + x[i - 1][j] + x[i][j - 1] -
x[i - 1][j - 1];
}
for (int a = int(1), _b = int(n); a <= _b; a++)
for (int b = int(1), _b = int(m); b <= _b; b++)
for (int c = int(a), _b = int(n); c <= _b; c++)
for (int d = int(b), _b = int(m); d <= _b; d++) {
int sum = x[c][d] + x[a - 1][b - 1] - x[c][b - 1] - x[a - 1][d];
h[a][b][c][d] = (sum == 0);
}
for (int a = int(n), _b = int(1); a >= _b; a--)
for (int b = int(1), _b = int(m); b <= _b; b++)
for (int c = int(a), _b = int(n); c <= _b; c++)
for (int d = int(b), _b = int(m); d <= _b; d++)
h[a][b][c][d] += h[a + 1][b][c][d];
for (int a = int(1), _b = int(n); a <= _b; a++)
for (int b = int(m), _b = int(1); b >= _b; b--)
for (int c = int(a), _b = int(n); c <= _b; c++)
for (int d = int(b), _b = int(m); d <= _b; d++)
h[a][b][c][d] += h[a][b + 1][c][d];
for (int a = int(1), _b = int(n); a <= _b; a++)
for (int b = int(1), _b = int(m); b <= _b; b++)
for (int c = int(a), _b = int(n); c <= _b; c++)
for (int d = int(b), _b = int(m); d <= _b; d++)
h[a][b][c][d] += h[a][b][c - 1][d];
for (int a = int(1), _b = int(n); a <= _b; a++)
for (int b = int(1), _b = int(m); b <= _b; b++)
for (int c = int(a), _b = int(n); c <= _b; c++)
for (int d = int(b), _b = int(m); d <= _b; d++)
h[a][b][c][d] += h[a][b][c][d - 1];
while (q--) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
printf("%d\n", h[a][b][c][d]);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
string str;
string req;
cin >> str;
cin >> req;
int lstr = str.length();
int lreq = req.length();
for (int i = 0; i < lreq; ++i) {
str = "X" + str;
}
for (int i = 0; i < lreq; ++i) {
str += "X";
}
int matches, changes = 1000000000;
for (int i = 0; i < str.length(); ++i) {
matches = 0;
for (int j = 0; j < req.length(); ++j) {
if (str[i + j] == req[j]) {
matches++;
}
changes = min(lreq - matches, changes);
}
}
cout << changes;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, a[N];
char c[N];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> c[i] >> a[i];
}
int x, y, z;
z = 1023, x = y = 0;
for (int i = 0; i < 10; ++i) {
int pos = -1;
bool t = 0;
for (int j = 0; j < n; ++j) {
if (c[j] == '|' && a[j] >> i & 1) pos = j, t = 1;
if (c[j] == '&' && !(a[j] >> i & 1)) pos = j, t = 0;
}
for (int j = pos + 1; j < n; ++j) {
if (c[j] == '^') t ^= (a[j] >> i & 1);
}
if (pos == -1)
x |= t * 1 << i;
else {
if (t)
y |= 1 << i;
else
z ^= 1 << i;
}
}
cout << "3\n";
cout << "^ " << x << '\n';
cout << "| " << y << '\n';
cout << "& " << z << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 10, maxm = 2000 + 10;
struct P {
int x, y, n;
P(int _x, int _y, int _n) : x(_x), y(_y), n(_n) {}
bool operator<(const P &A) const { return n > A.n; }
};
int G[maxn][maxn], n, m, t;
char Ans[maxn][maxn], pos[maxn][maxn];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
priority_queue<P> Q;
int find(int x, int y) {
int sum = 0;
for (int i = 0; i < 4; i++) {
int xx, yy;
xx = x + dx[i], yy = y + dy[i];
if (xx < 0 || yy < 0 || xx >= n || yy >= m)
continue;
else if (G[xx][yy] == 0)
sum++;
}
return sum;
}
void re(int x, int y) {
for (int i = 0; i < 4; i++) {
int xx = x + dx[i], yy = y + dy[i];
if (xx < n && yy < m && xx >= 0 && yy >= 0 && G[xx][yy] == 0 &&
find(xx, yy))
Q.push(P(xx, yy, find(xx, yy)));
}
}
bool check(P a, int i) {
int x = a.x + dx[i], y = a.y + dy[i];
if (x >= 0 && x < n && y >= 0 && y < m) return true;
return false;
}
int main() {
while (scanf("%d %d", &n, &m) == 2) {
char s[m + 2];
memset(G, 0, sizeof(G));
memset(Ans, ' ', sizeof(Ans));
int num = 0;
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++) {
if (s[j] == '*') G[i][j] = 1, num++;
Ans[i][j] = s[j];
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (G[i][j] == 0) Q.push(P(i, j, find(i, j)));
while (!Q.empty()) {
if (Q.top().n >= 2) {
t = 2;
break;
}
P p = Q.top();
Q.pop();
if (G[p.x][p.y] == 1) continue;
if (check(p, 0) && G[p.x + dx[0]][p.y + dy[0]] == 0) {
Ans[p.x][p.y] = '^';
G[p.x][p.y] == 1;
Ans[p.x + dx[0]][p.y + dy[0]] = 'v';
G[p.x + dx[0]][p.y + dy[0]] = 1;
re(p.x + dx[0], p.y + dy[0]);
num += 2;
} else if (check(p, 1) && G[p.x + dx[1]][p.y + dy[1]] == 0) {
Ans[p.x][p.y] = 'v';
G[p.x][p.y] == 1;
Ans[p.x + dx[1]][p.y + dy[1]] = '^';
G[p.x + dx[1]][p.y + dy[1]] = 1;
re(p.x + dx[1], p.y + dy[1]);
num += 2;
} else if (check(p, 2) && G[p.x + dx[2]][p.y + dy[2]] == 0) {
Ans[p.x][p.y] = '<';
G[p.x][p.y] == 1;
Ans[p.x + dx[2]][p.y + dy[2]] = '>';
G[p.x + dx[2]][p.y + dy[2]] = 1;
re(p.x + dx[2], p.y + dy[2]);
num += 2;
} else if (check(p, 3) && G[p.x + dx[3]][p.y + dy[3]] == 0) {
Ans[p.x][p.y] = '>';
G[p.x][p.y] == 1;
Ans[p.x + dx[3]][p.y + dy[3]] = '<';
G[p.x + dx[3]][p.y + dy[3]] = 1;
re(p.x + dx[3], p.y + dy[3]);
num += 2;
}
}
if (num == n * m) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%c", Ans[i][j]);
printf("\n");
}
} else {
printf("Not unique\n");
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "Hungry");
exit(0);
}
void addmod(int &x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et() {
puts("-1");
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) {
long long z = y;
while (x % y != 0) {
z = x % y;
x = y;
y = z;
}
return z;
}
int dp[105][200105];
void fmain(int ID) {
scanf("%d%d", &n, &k);
for (int(i) = 0; (i) < (int)(k + 1); (i)++)
for (int(j) = 0; (j) < (int)(200105); (j)++) dp[i][j] = (1000000000);
dp[0][0] = 0;
int pre = 0;
for (int(i) = 1; (i) <= (int)(k); (i)++) {
int l, r;
scanf("%d%d", &l, &r);
int len = r - l;
int M = l - pre;
int L = 0 - len - M, R = 0 - M;
multiset<int> ms;
for (int(z) = 0; (z) < (int)(R + 1); (z)++) ms.insert(dp[i - 1][0]);
for (int j = 0; j <= r; j++) {
if (!ms.empty()) dp[i][j] = min(dp[i][j], *ms.begin() + 2);
R++;
if (R >= 0 && R <= n + n) ms.insert(dp[i - 1][R]);
if (L >= 0) ms.erase(ms.find(dp[i - 1][L]));
L++;
}
ms.clear();
L = r - r - len - M;
R = r - r - 0 - M;
if (R == 0) ms.insert(dp[i - 1][0]);
for (int j = r; j >= 0; j--) {
if (!ms.empty()) dp[i][j] = min(dp[i][j], *ms.begin() + 1);
R++;
if (R >= 0 && R <= n + n) ms.insert(dp[i - 1][R]);
if (L >= 0) ms.erase(ms.find(dp[i - 1][L]));
L++;
}
for (int j = M + len; j <= r; j++)
dp[i][j] = min(dp[i][j], dp[i - 1][j - len - M]);
pre = r;
}
if (pre < n) {
etp();
}
int ans = dp[k][n - (n + n - pre)];
if (ans >= (1000000000)) etp();
puts("Full");
printf("%d\n", ans);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
sort(a.rbegin(), a.rend());
bool ok = false;
if (a.back() == 0) {
int sum = accumulate(a.begin(), a.end(), 0);
int mod = sum % 3;
if (mod == 0) {
if (sum)
for (int i = 0; i < n; ++i) cout << a[i];
else
cout << 0 << endl;
ok = true;
} else {
int p = -1;
for (int i = 0; i < n; ++i)
if (a[i] % 3 == mod) p = i;
if (p != -1) {
if (sum - a[p]) {
for (int i = 0; i < n; ++i)
if (i != p) cout << a[i];
} else
cout << 0 << endl;
ok = true;
} else {
mod = mod == 2 ? 1 : 2;
int p1 = -1, p2 = -1;
for (int i = 0; i < n; ++i)
if (a[i] % 3 == mod) p1 = i;
for (int i = 0; i < n; ++i)
if (a[i] % 3 == mod && i != p1) p2 = i;
if (p1 != -1 && p2 != -1) {
if (sum - a[p1] - a[p2]) {
for (int i = 0; i < n; ++i)
if (i != p1 && i != p2) cout << a[i];
} else
cout << 0 << endl;
ok = true;
}
}
}
}
if (!ok) cout << -1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[200000];
vector<long long> res;
vector<pair<long long, long long> > inp;
long long deg[200000];
bool visited[200000];
set<long long> s;
set<long long>::iterator it;
map<long long, long long> mp, inv_mp;
void dfs(long long node) {
if (visited[node]) return;
visited[node] = true;
res.push_back(node);
if (deg[node] == 1) return;
for (long long i = 0; i < adj[node].size(); i++) dfs(adj[node][i]);
}
int main() {
long long n, i, x, y;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x >> y;
s.insert(x);
s.insert(y);
inp.push_back(make_pair(x, y));
}
i = 1;
for (it = s.begin(); it != s.end(); it++) {
mp[*it] = i;
inv_mp[i] = *it;
i++;
}
long long maxnode = i - 1;
for (i = 0; i < n; i++) {
x = mp[inp[i].first];
y = mp[inp[i].second];
adj[x].push_back(y);
adj[y].push_back(x);
deg[x]++;
deg[y]++;
}
for (i = 1; i <= maxnode; i++) {
if (deg[i] == 1) {
break;
}
}
res.push_back(i);
visited[i] = true;
dfs(adj[i][0]);
for (i = 0; i < res.size(); i++) cout << inv_mp[res[i]] << " ";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
map<int, int> mp;
int main() {
cin >> n >> m;
while (m--) {
mp.clear();
int k;
cin >> k;
bool can = true;
for (int i = 1; i <= k; ++i) {
int x;
cin >> x;
if (mp[-x]) {
can = false;
}
++mp[x];
}
if (can) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e6 + 7, INF = 1e9;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long tt;
cin >> tt;
while (tt--) {
long long n;
cin >> n;
if (n < 4)
cout << "-1\n";
else {
for (long long i = n - (n % 2 == 0); i > 0; i -= 2) cout << i << ' ';
cout << "4 2 ";
for (long long i = 6; i <= n; i += 2) cout << i << ' ';
cout << '\n';
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x20202020;
const long long linf = (((long long)1) << 60) - 1;
const long long mod = 1000000007;
const double eps = 1e-9;
const double pi = 3.1415926535897932384626;
const int DX[] = {1, 0, -1, 0}, DY[] = {0, 1, 0, -1};
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long inv_mod(long long a, long long mod) {
return powmod(a, mod - 2, mod);
}
vector<long long> A;
vector<pair<long long, long long> > R;
long long dyn[100009], dp[100009];
map<int, bool> vst;
int main() {
int i, j, k, T, cas = 0;
long long n, x, y, init;
cin >> n >> init;
A.push_back(init);
vst[init] = 1;
for (i = 0; i < n; i++) {
cin >> x >> y;
if (!vst.count(x)) {
A.push_back(x);
vst[x] = 1;
}
if (!vst.count(y)) {
A.push_back(y);
vst[y] = 1;
}
R.push_back(make_pair(x, y));
}
sort((A).begin(), (A).end());
int pos = inf;
int lo = 0, hi = ((int)(A).size()) - 1, mid;
while (lo <= hi) {
mid = (lo + hi) / 2;
if (A[mid] == init) {
pos = mid;
break;
} else if (A[mid] > init)
hi = mid - 1;
else
lo = mid + 1;
}
for (i = 0; i < ((int)(A).size()); i++) dyn[i] = linf;
dyn[pos] = 0;
long long cost;
for (int q = 0; q < ((int)(R).size()); q++) {
long long bestval = dyn[0];
dp[0] = dyn[0];
for (pos = 1; pos < ((int)(A).size()); pos++) {
cost = abs(A[pos] - A[pos - 1]);
bestval = min(bestval + cost, dyn[pos]);
dp[pos] = min(dyn[pos], bestval);
}
bestval = dyn[((int)(A).size()) - 1];
for (pos = ((int)(A).size()) - 2; pos >= 0; pos--) {
cost = abs(A[pos] - A[pos + 1]);
bestval = min(bestval + cost, dyn[pos]);
dp[pos] = min(dp[pos], bestval);
cost = 0;
if (A[pos] > R[q].second || A[pos] < R[q].first)
cost = min(abs(A[pos] - R[q].first), abs(A[pos] - R[q].second));
dp[pos] += cost;
dyn[pos] = dp[pos];
}
cost = 0;
pos = ((int)(A).size()) - 1;
if (A[pos] > R[q].second || A[pos] < R[q].first)
cost = min(abs(A[pos] - R[q].first), abs(A[pos] - R[q].second));
dp[pos] += cost;
dyn[pos] = dp[pos];
}
long long ans = linf;
for (i = 0; i < ((int)(A).size()); i++) ans = min(ans, dyn[i]);
cout << ans << endl;
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
constexpr int MAX_N = 200000;
int N, M, S, D;
int X[MAX_N + 10];
int DP[MAX_N + 1] = {0};
stack<string> OPS;
void run(int x) {
if (x == 0) return;
std::ostringstream os;
os << "RUN " << x;
OPS.push(os.str());
}
void jump(int x) {
assert(x > 0);
std::ostringstream os;
os << "JUMP " << x;
OPS.push(os.str());
}
bool dfs(int p) {
assert(p >= 0 && p <= N);
if (DP[p] != 0) {
assert(DP[p] == 2);
return false;
}
if (M < X[p]) {
DP[p] = 2;
return false;
}
if (p == N || M < X[p + 1]) {
run(M - X[p] - 1);
DP[p] = 1;
} else {
DP[p] = 2;
int space = X[p + 1] - X[p] - 2;
if (space < S) {
return false;
}
int i = p + 1;
while (DP[p] != 1 && i <= N && X[i] + 1 <= X[p + 1] - 1 + D) {
if (dfs(i)) {
DP[p] = 1;
jump(X[i] + 1 - X[p + 1] + 1);
run(space);
}
i++;
}
}
return DP[p] == 1;
}
int main() {
cin >> N >> M >> S >> D;
X[0] = -1;
for (int i = 0; i < N; i++) {
cin >> X[i + 1];
}
sort(&X[0], &X[N + 1]);
if (!dfs(0)) {
printf("IMPOSSIBLE\n");
} else {
while (!OPS.empty()) {
cout << OPS.top() << endl;
OPS.pop();
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int Inf = 0x7fffffff;
const int maxn = 1e5 + 5;
const double eps = 1e-10;
int n;
int main() {
while (cin >> n) {
int a, b, c, d;
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c >> d;
cout << 2 * (a & 1) + (b & 1) + 1 << endl;
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
long long r = 1, z = x;
while (y) {
if (y & 1) r *= z;
z *= z;
y = y >> 1;
}
return r;
}
long long powerm(long long x, long long y, long long p) {
long long r = 1;
while (y) {
if (y & 1) r = (r * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return r % p;
}
long long modinv(long long x, long long m) { return powerm(x, m - 2, m); }
long long logarithm(long long a, long long b) {
long long x = 0;
while (a > 1) {
x++;
a /= b;
}
return x;
}
long long max3(long long a, long long b, long long c) {
return max(a, max(b, c));
}
long long min3(long long a, long long b, long long c) {
return min(a, min(b, c));
}
void under_rated() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int32_t main() {
under_rated();
long long n, m;
cin >> n >> m;
vector<long long> v(n);
long long freq[101];
for (long long i = 0; i < 101; ++i) {
freq[i] = 0;
}
for (long long i = 0; i < n; ++i) {
cin >> v[i];
}
long long tot = 0;
long long i = 0;
while (i < n) {
tot += v[i];
if (tot <= m) {
cout << 0 << " ";
freq[v[i]]++;
++i;
continue;
}
long long temp = tot;
long long num = 0;
long long k = 100;
while (k >= 0) {
if (freq[k] == 0) {
--k;
continue;
}
long long x = freq[k];
if ((temp - (x * k)) > m) {
num += x;
temp -= (x * k);
} else {
long long z = temp - m;
if (z % k == 0) {
num += (z / k);
} else {
num += (z / k) + 1;
}
cout << num << " ";
break;
}
--k;
}
freq[v[i]]++;
++i;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, m, cnt[N][26], num[26];
char s[N], ans[N];
map<string, int> mp;
string ss, dat[N];
int main() {
scanf("%d", &n);
m = (n + 1) / 2;
if (m > 1) {
printf("? %d %d\n", 1, m - 1);
cout.flush();
for (int i = 1; i <= m * (m - 1) / 2; i++) {
cin >> ss;
sort(ss.begin(), ss.end());
mp[ss]++;
}
}
printf("? %d %d\n", 1, m);
cout.flush();
for (int i = 1; i <= m * (m + 1) / 2; i++) {
cin >> ss;
sort(ss.begin(), ss.end());
if (!mp[ss])
dat[ss.length()] = ss;
else
mp[ss]--;
}
for (int i = 1; i <= m; i++) {
for (int j = 0; j < i; j++) num[dat[i][j] - 'a']++;
for (int j = m; j > m - i + 1; j--) num[ans[j] - 'a']--;
for (int j = 0; j < 26; j++)
if (num[j]) ans[m - i + 1] = j + 'a', num[j] = 0;
}
printf("? %d %d\n", 1, n);
cout.flush();
for (int i = 1; i <= n * (n + 1) / 2; i++) {
scanf("%s", s + 1);
int l = strlen(s + 1);
for (int j = 1; j <= l; j++) cnt[l][s[j] - 'a']++;
}
for (int i = n / 2 + 1; i <= n; i++) {
for (int j = 0; j < 26; j++) cnt[i][j] -= cnt[i + 1][j];
for (int j = n / 2 + 1; j < i; j++)
for (int k = 0; k < 26; k++) cnt[i][k] -= cnt[j][k];
}
for (int i = n; i > m; i--) {
for (int j = 0; j < 26; j++)
if (cnt[i][j] - (ans[n - i + 1] - 'a' == j)) ans[i] = j + 'a';
}
printf("! %s", ans + 1);
return 0;
}
| 20 |
#include <bits/stdc++.h>
using namespace std;
bool comp(long long int x, long long int y) { return x > y; }
bool is_square(long long int n) {
if (pow((long long int)sqrt(n), 2) == n) return true;
return false;
}
long long int logd(long long int x, long long int y) {
return ceil((long double)log(x) / (long double)log(y));
}
struct mone {
int value = -1;
};
const int N = 2e5 + 5;
void solve() {
long long int n, s;
cin >> n >> s;
cout << s / ((n / 2) + 1) << endl;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[2 * n];
if (n % 2 == 0)
cout << "NO" << endl;
else {
cout << "YES" << endl;
int i = 0;
int od = 1;
while (i < n) {
ar[i] = od;
i += 2;
od += 4;
}
od -= 2 + 4;
while (i < 2 * n) {
ar[i] = od;
i += 2;
od -= 4;
}
int j = n;
od = 2;
while (j < 2 * n) {
ar[j] = od;
j += 2;
od += 4;
}
od -= 2 + 4;
j = 1;
while (j < n) {
ar[j] = od;
j += 2;
od -= 4;
}
for (int i = 0; i < 2 * n; i++) cout << ar[i] << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10, INFTY = 1e10;
long long DD_from1to[105];
long long DD_toNfrom[105];
long long NN_from1to[105];
long long NN_toNfrom[105];
queue<int> Q;
int N;
int M;
bool visited[105];
vector<int> adiac[105];
void bfs(int from, long long *array_NN, long long *array_DD) {
memset(visited, 0, sizeof visited);
array_NN[from] = 1;
Q.push(from);
int node, to;
while (!Q.empty()) {
node = Q.front();
Q.pop();
visited[node] = true;
for (int i = 0; i < (int((adiac[node]).size())); i++) {
to = adiac[node][i];
if (!visited[to]) {
if (array_NN[to] == 0) {
Q.push(to);
array_DD[to] = array_DD[node] + 1;
}
if (array_DD[to] > array_DD[node]) array_NN[to] += array_NN[node];
}
}
}
}
int main() {
scanf("%d%d", &N, &M);
int a, b;
for (int i = 0; i < M; i++) {
scanf("%d %d", &a, &b);
adiac[a].push_back(b);
adiac[b].push_back(a);
}
bfs(1, NN_from1to, DD_from1to);
bfs(N, NN_toNfrom, DD_toNfrom);
long long tot = NN_from1to[N];
long long temp, best = -1;
for (int node = 1; node <= N; node++) {
if (node == 1 || node == N) {
temp = 1 * tot;
} else {
if (DD_from1to[node] + DD_toNfrom[node] == DD_from1to[N]) {
temp = 2 * NN_from1to[node] * NN_toNfrom[node];
}
}
best = max(best, temp);
}
cout << fixed << setprecision(18) << ((long double)best) / tot << "\n";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline void inp(int &n) {
n = 0;
int ch = getchar();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
n = (n << 3) + (n << 1) + ch - '0', ch = getchar();
n = n * sign;
}
long long gcd(long long A, long long B) {
return A > B ? gcd(B, A) : A ? gcd(B % A, A) : B;
}
long long lcm(long long A, long long B) { return A / gcd(A, B) * B; }
long long pow(long long A, long long B, long long P) {
if (!B) return 1 % P;
long long h = pow(A, B / 2, P);
h *= h;
h %= P;
if (B % 2) h *= A;
return h % P;
}
vector<int> z_function(string s) {
int n = (int)s.length();
vector<int> z(n);
for (int i = 1, l = 0, r = 0; i < n; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
return z;
}
int tst;
void get_ready() { tst = 1; }
long long H;
long long solve(long long h, long long n, long long lst) {
if (h == 0) return 0;
long long l = 1;
long long r = (1LL << h);
long long mid = (l + r) / 2LL;
if (lst) {
if (n > mid)
return (1LL << (h)) + solve(h - 1, n - mid, lst);
else
return 1LL + solve(h - 1, n, 1 - lst);
} else {
if (n > mid)
return 1LL + solve(h - 1, n - mid, 1 - lst);
else
return (1LL << (h)) + solve(h - 1, n, lst);
}
}
long long n;
bool READ() {
cin >> H >> n;
cout << solve(H, n, 1) << endl;
return 1;
}
bool SOLVE() { return 1; }
bool PRINT() { return 1; }
bool CLEAR() { return 1; }
int main() {
get_ready();
while (tst--) {
if (!READ()) {
return 0;
}
if (!SOLVE()) {
return 0;
}
if (!PRINT()) {
return 0;
}
if (!CLEAR()) {
return 0;
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace ::std;
template <class T1, class T2>
istream& operator>>(istream& I, pair<T1, T2>& p) {
return I >> p.first >> p.second;
}
template <class T1, class T2>
ostream& operator<<(ostream& O, const pair<T1, T2>& p) {
return O << '(' << p.first << ' ' << p.second << ')';
}
template <class T>
istream& operator>>(istream& I, vector<T>& v) {
for (T& e : v) I >> e;
return I;
}
template <class T>
ostream& operator<<(ostream& O, const vector<T>& v) {
for (const T& e : v) O << e << ' ';
return O;
}
template <class T>
ostream& operator<<(ostream& O, const unordered_set<T>& v) {
for (const T& e : v) O << e << ' ';
return O;
}
template <class T>
ostream& operator<<(ostream& O, const set<T>& v) {
for (const T& e : v) O << e << ' ';
return O;
}
template <class T>
ostream& operator<<(ostream& O, const unordered_multiset<T>& v) {
for (const T& e : v) O << e << ' ';
return O;
}
template <class T>
ostream& operator<<(ostream& O, const multiset<T>& v) {
for (const T& e : v) O << e << ' ';
return O;
}
template <class T1, class T2>
ostream& operator<<(ostream& O, const unordered_map<T1, T2>& v) {
for (const auto& e : v) O << e << ' ';
return O;
}
template <class T1, class T2>
ostream& operator<<(ostream& O, const map<T1, T2>& v) {
for (const auto& e : v) O << e << ' ';
return O;
}
template <class T>
istream& operator>>(istream& I, deque<T>& v) {
for (T& e : v) I >> e;
return I;
}
template <class T>
ostream& operator<<(ostream& O, const deque<T>& v) {
for (const T& e : v) O << e << ' ';
return O;
}
void _main() {
long long n, x;
cin >> n >> x;
string str;
cin >> str;
vector<long long> pre(n + 1);
long long cnt = 0;
for (long long i = 0; i < n; i++) {
if (str[i] == '0')
cnt++;
else
cnt--;
pre[i + 1] = cnt;
}
if (!x && !pre[n]) {
cout << "-1\n";
return;
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
if (!pre[n]) {
if (pre[i] == x) {
cout << "-1\n";
return;
}
} else {
if ((x - pre[i]) % pre[n] == 0 && (x - pre[i]) / pre[n] >= 0) ans++;
}
}
cout << ans << '\n';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long _t = 1;
cin >> _t;
while (_t--) _main();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast", "unroll-loops")
const int MAXN = 1e5 * 2;
int mp[(int)1e6 + 42];
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
int n;
cin >> n;
int t = 0;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
mp[x]++, t = max(t, x);
42;
}
42;
int ans = 0, cur = 0;
for (int i = 0; i <= t + 42; i++) {
42;
mp[i + 1] += mp[i] / 2;
ans += mp[i] % 2;
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int dr[] = {1, 0, -1, 0, 1, 1, -1, -1};
const int dc[] = {0, 1, 0, -1, 1, -1, -1, 1};
const double eps = 1e-9;
const int INF = 0x7FFFFFFF;
const long long INFLL = 0x7FFFFFFFFFFFFFFFLL;
const double pi = acos(-1);
template <class T>
T take(queue<T> &O) {
T tmp = O.front();
O.pop();
return tmp;
}
template <class T>
T take(stack<T> &O) {
T tmp = O.top();
O.pop();
return tmp;
}
template <class T>
T take(priority_queue<T> &O) {
T tmp = O.top();
O.pop();
return tmp;
}
template <class T>
inline void getint(T &num) {
bool neg = 0;
num = 0;
char c;
while ((c = getchar_unlocked()) && (!isdigit(c) && c != '-'))
;
if (c == '-') {
neg = 1;
c = getchar_unlocked();
}
do num = num * 10 + c - '0';
while ((c = getchar_unlocked()) && isdigit(c));
if (neg) num = -num;
}
template <class T>
inline bool inRange(T z, T a, T b) {
return a <= z && z <= b;
}
void OPEN(string in = "input.txt", string out = "output.txt") {
freopen(in.c_str(), "r", stdin);
freopen(out.c_str(), "w", stdout);
return;
}
struct Action {
int x, y, t, dir, ans;
inline void getData(int _t = -1) {
cin >> x >> y;
t = _t;
string s;
cin >> s;
if (s[0] == 'L')
dir = 0;
else
dir = 1;
ans = 0;
return;
}
inline bool operator<(const Action &O) const {
return make_tuple(x, y, t) < make_tuple(O.x, O.y, O.t);
}
inline void calculate(int xkiri, int yatas) {
if (dir == 0)
ans = x - xkiri;
else
ans = y - yatas;
return;
}
};
int rmq[20][200005];
int arr[200005], n, q;
Action action[200005];
inline int query(int l, int r) {
if (r - l + 1 <= 0) return -1;
int loglen = (r - l + 1);
loglen = 31 - __builtin_clz(loglen);
;
return action[arr[rmq[loglen][l]]].t <
action[arr[rmq[loglen][r - (1 << loglen) + 1]]].t
? rmq[loglen][l]
: rmq[loglen][r - (1 << loglen) + 1];
}
int cntt = 0;
void rec(int idx, int l, int r, int xkiri, int yatas) {
action[arr[idx]].calculate(xkiri, yatas);
if (action[arr[idx]].dir == 0) {
if (l <= idx - 1)
rec(query(l, idx - 1), l, idx - 1, xkiri, max(yatas, action[arr[idx]].y));
if (idx + 1 <= r) rec(query(idx + 1, r), idx + 1, r, xkiri, yatas);
} else {
if (l <= idx - 1) rec(query(l, idx - 1), l, idx - 1, xkiri, yatas);
if (idx + 1 <= r)
rec(query(idx + 1, r), idx + 1, r, max(xkiri, action[arr[idx]].x), yatas);
}
return;
}
set<pair<int, int> > uda;
int cntq;
int main(int argc, const char *argv[]) {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> q;
for (int(i) = (0), _t = (q); i < (_t); ++(i)) {
action[i].getData(i);
if (uda.count(make_pair(action[i].x, action[i].y)))
action[i].ans = 0;
else {
uda.insert(make_pair(action[i].x, action[i].y));
arr[cntq] = i;
++cntq;
}
}
sort(arr, arr + cntq,
[](const int &A, const int &B) { return action[A] < action[B]; });
for (int(i) = (0), _t = (cntq); i < (_t); ++(i)) rmq[0][i] = i;
for (int j = 1; (1 << j) <= cntq; ++j)
for (int(i) = (0), _t = (cntq - (1 << j)); i <= (_t); ++(i))
rmq[j][i] = (action[arr[rmq[j - 1][i]]].t <
action[arr[rmq[j - 1][i + (1 << (j - 1))]]].t
? rmq[j - 1][i]
: rmq[j - 1][i + (1 << (j - 1))]);
rec(query(0, cntq - 1), 0, cntq - 1, 0, 0);
for (int(i) = (0), _t = (q); i < (_t); ++(i)) cout << action[i].ans << "\n";
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7, M = 2 * N;
int edge[M], succ[M], ver[N], idx, ID[M];
int d[N], all, have, fa[N], vis[N];
vector<int> ans;
void add(int u, int v, int id) {
edge[idx] = v;
succ[idx] = ver[u];
ID[idx] = id;
ver[u] = idx++;
}
void dfs1(int u) {
vis[u] = 1;
if (d[u] == -1)
have = u;
else if (d[u] == 1)
++all;
for (int i = ver[u]; ~i; i = succ[i]) {
int v = edge[i];
if (vis[v]) continue;
fa[v] = u;
dfs1(v);
}
}
void dfs2(int u) {
for (int i = ver[u]; ~i; i = succ[i]) {
int v = edge[i];
if (fa[v] == u) {
dfs2(v);
if (d[v] == 1) ans.push_back(ID[i]), d[u] ^= 1;
}
}
}
int main() {
memset(ver, -1, sizeof ver);
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &d[i]);
set<pair<int, int> > st;
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
if (u > v) swap(u, v);
if (st.count({u, v})) continue;
st.insert({u, v});
add(u, v, i), add(v, u, i);
}
dfs1(1);
if (all & 1) {
if (!have) return puts("-1"), 0;
d[have] = 1;
}
for (int i = 1; i <= n; ++i)
if (d[i] == -1) d[i] = 0;
dfs2(1);
printf("%d\n", (int)ans.size());
for (auto& v : ans) printf("%d\n", v);
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
using ll = int_fast64_t;
constexpr int mod = 1e9 + 7;
constexpr int inf = (1 << 30) - 1;
constexpr ll infll = (1LL << 61) - 1;
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
int main() {
int t;
cin >> t;
while (t--) {
ll a, b, x, y, n;
cin >> a >> b >> x >> y >> n;
ll k = a - x + b - y;
if (k <= n) {
cout << x * y << "\n";
continue;
}
if (max(x, a - n) > max(y, b - n)) {
swap(a, b);
swap(x, y);
}
ll ans = a * b, l = 0;
if (a - x <= n) {
l = n - a + x;
ans = x * (b - l);
} else {
ans = (a - n) * b;
}
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool maze[305][305] = {0};
char mov[105];
int main() {
scanf("%s", &mov);
bool bug = 0;
int r = 150, c = 150, len = strlen(mov);
maze[r][c] = 1;
for (int i = 0; i < len; ++i) {
int nr = r, nc = c;
switch (mov[i]) {
case 'U':
nr--;
break;
case 'D':
nr++;
break;
case 'L':
nc--;
break;
case 'R':
nc++;
break;
}
int cnt = maze[nr][nc - 1] + maze[nr][nc + 1] + maze[nr - 1][nc] +
maze[nr + 1][nc];
if (maze[nr][nc] || cnt > 1) {
bug = 1;
break;
}
r = nr;
c = nc;
maze[r][c] = 1;
}
printf("%s\n", bug ? "BUG" : "OK");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool prime[1000005];
void sieve(int n) {
for (int i = 0; i < n; i++) prime[i] = true;
prime[0] = false, prime[1] = false;
for (int i = 2; i * i <= n; i++) {
if (prime[i] == true) {
for (int j = i * i; j <= n; j += i) prime[j] = false;
}
}
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int ck = n / 2;
if (!(ck % 2)) {
cout << "YES" << endl;
vector<int> v;
;
int even = 2, evensum = 0;
for (int i = 0; i < n / 2; i++) {
v.push_back(even);
evensum += even;
even += 2;
}
int odd = 1, oddsum = 0;
for (int i = 1; i <= n / 2; i++) {
if (i == n / 2) {
v.push_back(evensum - oddsum);
} else
v.push_back(odd);
oddsum += odd;
odd += 2;
}
for (auto i = 0; i < v.size(); i++) cout << v[i] << " ";
;
cout << endl;
;
v.clear();
} else
cout << "NO" << endl;
}
return 0;
;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void solve(){
map<int,int>ma; //key可能为负，所以不数组
int n; cin>>n;
ll ans = 0;
for(int i=0; i<n; i++){
int x; cin>>x; x-=i;
ans+=ma[x]; ma[x]++; //即使第一次，ma[x]为0
}
cout<<ans<<endl;
}
int main(){
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
int t; cin>>t;
while(t--){
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[1003], min, x, y;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
min = abs(a[0] - a[n - 1]);
x = 1;
y = n;
for (int i = 0; i < n - 1; i++) {
if (abs(a[i] - a[i + 1]) < min) {
min = abs(a[i] - a[i + 1]);
x = i + 1;
y = i + 2;
}
}
cout << x << " " << y;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int arr[2000];
int main() {
int test, m, c = 0, sum1 = 0, i, j, a;
cin >> test >> m;
for (int i = 1; i <= test; i++) {
cin >> a;
arr[a]++;
}
long long sum = 0;
for (i = 1; i <= m; i++)
for (j = i + 1; j <= m; j++) sum += 1LL * arr[i] * arr[j];
cout << sum << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
int n, Q;
int pre[N], nxt[N], lst[N], cnt[N], pi[N], a[N];
struct node {
int l, r, id;
} q[N];
int tr[N], ans[N];
void add(int x, int k) {
while (x <= n + 1) {
tr[x] += k;
x += x & -x;
}
}
int find(int x) {
int ans = 0;
while (x) {
ans += tr[x];
x -= x & -x;
}
return ans;
}
bool cmp(node a, node b) { return a.r < b.r; }
int main() {
scanf("%d%d", &n, &Q);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (a[i] > n) continue;
pre[i] = lst[a[i]];
nxt[lst[a[i]]] = i;
lst[a[i]] = i;
}
for (int i = 1; i <= n; ++i) {
if (a[i] > n) continue;
cnt[a[i]]++;
if (cnt[a[i]] == 1) lst[a[i]] = i;
if (cnt[a[i]] == a[i]) {
pi[i] = lst[a[i]];
} else if (cnt[a[i]] > a[i]) {
pi[i] = nxt[pi[pre[i]]];
}
}
for (int i = 1; i <= Q; ++i) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].id = i;
}
sort(q + 1, q + Q + 1, cmp);
int l = 1;
for (int i = 1; i <= n; ++i) {
if (a[i] <= n) {
if (pi[i]) {
add(pre[pi[i]] + 2, 1);
add(pi[i] + 2, -1);
if (pre[pi[i]]) {
add(pre[pre[pi[i]]] + 2, -1);
add(pre[pi[i]] + 2, 1);
}
}
}
while (q[l].r == i) {
ans[q[l].id] = find(q[l].l + 1);
l++;
}
}
for (int i = 1; i <= Q; ++i) printf("%d\n", ans[i]);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
char pan[10][10];
int main() {
std::ios::sync_with_stdio(false);
long long n, m;
cin >> n >> m;
vector<long long> v(n + 1), pre(n + 1, 0);
for (long long i = 1; i <= n; i++) {
cin >> v[i];
pre[i] = pre[i - 1] + v[i];
}
long long ans = 0;
long long val = 0;
while (m--) {
long long l, r;
cin >> l >> r;
long long sum = pre[r] - pre[l - 1];
if (sum < 0) {
continue;
}
val += sum;
ans = max(ans, val);
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int board[31][31] = {0};
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) cin >> board[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) board[i][0] += board[i][j];
for (int j = 1; j <= n; j++)
for (int i = 1; i <= n; i++) board[0][j] += board[i][j];
int ans = 0;
for (int j = 1; j <= n; j++)
for (int i = 1; i <= n; i++) ans += (board[0][j] > board[i][0]);
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 3e5 + 5;
void solve() {
int n;
cin >> n;
vector<pair<long long int, long long int> > v(2 * n + 5);
vector<long long int> cost(2 * n + 5, 0);
for (int i = 0; i < n; i++) {
cin >> v[i].first >> v[i].second;
v[n + i] = v[i];
}
long long int ans = 1e18;
long long int sum = 0;
for (int i = 0; i < 2 * n; i++) {
if (i == 0)
cost[i] = v[i].first;
else
cost[i] = max(0LL, v[i].first - v[i - 1].second);
}
for (int i = 1; i < n; i++) sum += cost[i];
for (int i = 0; i < n; i++) {
ans = min(ans, sum + v[i].first);
sum -= cost[i + 1];
sum += cost[i + n];
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e5 + 10;
const int inf = 2e9;
const double eps = 1e-7;
const long long INF = (long long)1e18;
int n;
int m;
int a[N];
vector<int> ans;
int main() {
scanf("%d%d", &(n), &(m));
for (int i = 0; i < (n); ++i) scanf("%d", &(a[i]));
sort(a, a + n);
int j = 0, val = 1;
int k = (int)1e9;
while (m > 0 && j < n && val <= k) {
if (val < a[j]) {
if (m >= val) {
ans.push_back(val);
m -= val;
} else
break;
val++;
} else {
val++;
j++;
}
}
while (j == n && val <= k && m > 0) {
if (m >= val) {
ans.push_back(val);
m -= val;
} else
break;
val++;
}
cout << ans.size() << "\n";
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.