solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
char a[n + 1];
cin >> a;
int small[26] = {0}, capi[26] = {0}, digit[10] = {0};
for (int i = 0; i < n; i++) {
if (a[i] >= '0' && a[i] <= '9') {
digit[a[i] - '0']++;
} else if (a[i] >= 'a' && a[i] <= 'z') {
small[a[i] - 'a']++;
} else {
capi[a[i] - 'A']++;
}
}
vector<char> ele;
int count = 0, len = 0;
for (int i = 0; i < 10; i++) {
if (digit[i] % 2 == 1) {
ele.push_back('0' + i);
count++;
digit[i]--;
}
len += digit[i];
}
for (int i = 0; i < 26; i++) {
if (small[i] % 2 == 1) {
small[i]--;
ele.push_back('a' + i);
count++;
}
len += small[i];
if (capi[i] % 2 == 1) {
capi[i]--;
ele.push_back('A' + i);
count++;
}
len += capi[i];
}
if (count == 0) {
cout << 1 << endl;
char arr[len + 1];
arr[len] = '\0';
int k = 0;
for (int i = 0; i < 10; i++) {
while (digit[i] > 0) {
digit[i] -= 2;
arr[k] = arr[len - k - 1] = i + '0';
k++;
}
}
for (int i = 0; i < 26; i++) {
while (small[i] > 0) {
small[i] -= 2;
arr[k] = arr[len - k - 1] = i + 'a';
k++;
}
}
for (int i = 0; i < 26; i++) {
while (capi[i] > 0) {
capi[i] -= 2;
arr[k] = arr[len - k - 1] = i + 'A';
k++;
}
}
cout << arr;
return 0;
} else {
int extra = 0;
while (19) {
if (len <= 0) {
break;
}
if (len % count == 0 && (len / count) % 2 == 0) {
break;
}
len -= 2;
extra += 2;
count += 2;
}
if (len == 0) {
cout << n << endl;
for (int i = 0; i < n; i++) cout << a[i] << " ";
return 0;
} else {
for (int i = 0; extra > 0 && i < 10; i++) {
while (extra > 0 && digit[i] > 0) {
digit[i]--;
extra--;
ele.push_back('0' + i);
}
}
for (int i = 0; i < 26 && count > 0; i++) {
while (extra > 0 && small[i] > 0) {
small[i]--;
extra--;
ele.push_back('a' + i);
}
}
for (int i = 0; i < 26 && count > 0; i++) {
while (extra > 0 && capi[i] > 0) {
capi[i]--;
extra--;
ele.push_back('A' + i);
}
}
}
}
cout << count << endl;
char ch;
int i, j, d = 0, s = 0, c = 0;
len /= count;
char arr[len + 2];
while (count != 0 && !ele.empty()) {
count--;
char ch = ele[ele.size() - 1];
ele.pop_back();
arr[len / 2] = ch;
i = 0;
while (i < len / 2 && d < 10) {
while (d < 10 && digit[d] == 0) d++;
while (d < 10 && i < len / 2 && digit[d] > 0) {
arr[i] = arr[len - i] = d + '0';
digit[d] -= 2;
i++;
}
}
while (i < len / 2 && s < 26) {
while (s < 26 && small[s] == 0) s++;
while (s < 26 && i < len / 2 && small[s] > 0) {
arr[i] = arr[len - i] = s + 'a';
small[s] -= 2;
i++;
}
}
while (i < len / 2 && c < 26) {
while (c < 26 && capi[c] == 0) c++;
while (c < 26 && i < len / 2 && capi[c] > 0) {
arr[i] = arr[len - i] = c + 'A';
capi[c] -= 2;
i++;
}
}
arr[len + 1] = '\0';
printf("%s ", arr);
}
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
long long binpow(long long a, long long b) {
if (b == 0) {
return 1;
}
long long res = binpow(a, b / 2);
res *= res;
if (b % 2) {
return res * a;
}
return res;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
string to_upper(string a) {
for (int i = 0; i < (int)a.size(); ++i)
if (a[i] >= 'a' && a[i] <= 'z') a[i] -= 'a' - 'A';
return a;
}
string to_lower(string a) {
for (int i = 0; i < (int)a.size(); ++i)
if (a[i] >= 'A' && a[i] <= 'Z') a[i] += 'a' - 'A';
return a;
}
void solve() {
int n;
long long a = 0, b = 0, cur = 2;
cin >> n;
for (int i = 1; i < n / 2; ++i) {
a += cur;
cur *= 2;
}
for (int i = 0; i < n / 2; ++i) {
b += cur;
cur *= 2;
}
cout << cur + a - b << "\n";
;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
while (n--) solve();
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)16;
const int MOD = (int)1e9 + 7;
const int infint = (int)1e8 + 3;
const long long inf = (long long)1e18;
long long dp[MAXN][2], L, R, open, close;
int bits[MAXN][4];
int bt(int x, int i) { return (x >> i) & 1; }
string dec(string s) {
int idx = -1;
for (int i = s.size() - 1; i >= 0; i--)
if (s[i] != '0') {
idx = i;
break;
}
for (int i = idx + 1; i < s.size(); i++) s[i] = 'f';
s[idx] = (char)(s[idx] - 1);
return s;
}
long long took(string s) {
long long ans = 0;
for (int i = 0; i < s.size(); i++)
if ('0' <= s[i] && s[i] <= '9')
ans = ans * 16 + (s[i] - '0');
else
ans = ans * 16 + (s[i] - 'a' + 10);
return ans;
}
string conv2(long long ans) {
string s = "";
for (int i = 0; i < 60; i++) {
if (ans % 2)
s += '1';
else
s += '0';
ans /= 2;
}
reverse(s.begin(), s.end());
return s;
}
int val(string bin, int block) {
int ans = 0;
for (int i = (block + 1) * 4 - 1; i >= 4 * block; i--)
ans = ans * 2 + (bin[59 - i] - '0');
return ans;
}
long long get(string bin, int bound, int digit) {
int group = digit / 4;
for (int block = 14; block >= 0; block--) {
int cur = val(bin, block);
if (block != group) {
if (cur <= bound)
dp[block][0] = 1 & ((block == 14) | dp[block + 1][0]);
else
dp[block][0] = 0;
if (block == 14)
dp[block][1] = min(cur, bound + 1);
else
dp[block][1] = (bound + 1) * dp[block + 1][1] +
min(cur, bound + 1) * dp[block + 1][0];
} else {
int mod = digit % 4;
if (cur <= bound && bt(cur, mod))
dp[block][0] = 1 & ((block == 14) | dp[block + 1][0]);
else
dp[block][0] = 0;
if (block == 14)
dp[block][1] = bits[max(0, min(cur - 1, bound))][mod];
else
dp[block][1] =
bits[bound][mod] * dp[block + 1][1] +
bits[max(0, min(bound, cur - 1))][mod] * dp[block + 1][0];
}
}
return dp[0][0] + dp[0][1];
}
long long f(long long x) {
long long ans = 0;
string s = conv2(x);
for (int i = 0; i < 16; i++) {
ans += get(s, i, i);
if (i) ans -= get(s, i - 1, i);
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < 16; i++)
for (int j = 0; j < 4; j++) {
bits[i][j] = bt(i, j);
if (i) bits[i][j] += bits[i - 1][j];
}
int T;
cin >> T;
while (T--) {
string l, r;
cin >> l >> r;
R = took(r), L = took(l);
close = f(R);
open = 0;
if (L) open = f(L - 1);
cout << close - open << "\n";
}
}
| 21
|
#include <bits/stdc++.h>
int main() {
int y, b, r;
scanf("%d %d %d", &y, &b, &r);
while (b < y + 1 || r < y + 2) {
y--;
}
printf("%d\n", 3 * y + 3);
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
multiset<int> s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, ch, x, bad = 0, ans = 0, last = 0;
cin >> n >> ch;
ch--;
for (int i = 0; i < n; i++) {
cin >> x;
if (x && i != ch) s.insert(x);
if (i == ch) ans += bool(x);
if (ch != i) bad += (!bool(x));
}
ans += bad;
while (!s.empty()) {
if ((*s.begin() - 2) < last)
last = *s.begin(), s.erase(s.find(*s.begin()));
else if (bad > 0)
bad--, last++;
else {
s.erase(s.find(*s.rbegin()));
last++;
ans++;
}
}
cout << ans << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 6000000;
int cnt, tot;
int head[MAXN], nxt[MAXN], to[MAXN];
int dfn[MAXN], low[MAXN], sta[MAXN], top, vis[MAXN];
inline void ins(int u, int v) {
nxt[++cnt] = head[u];
head[u] = cnt;
to[cnt] = v;
}
int y;
int sum;
void tarjan(int u) {
dfn[u] = low[u] = ++tot;
vis[u] = 1;
sta[++top] = u;
for (int i = head[u], v = to[i]; i; i = nxt[i], v = to[i])
if (!dfn[v])
tarjan(v), low[u] = min(low[u], low[v]);
else if (vis[v])
low[u] = min(low[u], dfn[v]);
if (dfn[u] == low[u] && ++sum) do
y = sta[top--], vis[y] = 0;
while (y != u);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
int x;
scanf("%d", &x);
if (x) ins(i, j);
}
for (int i = 1; i <= n; ++i)
if (!dfn[i]) tarjan(i);
printf((sum == 1 ? "YES" : "NO"));
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000007;
const long long linf = 1000000000000000000LL;
const double eps = 0.000001;
const double pi = 3.14159265358979323846;
template <class T>
T abs(T k) {
return k >= 0 ? k : -k;
}
template <class T>
T sqr(T n) {
return n * n;
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T mod(T a, T b) {
return (a % b + b) % b;
}
template <class T>
T addmod(T a, T b, T c) {
return (T)mod((long long)a + b, (long long)c);
}
template <class T>
T mulmod(T a, T b, T c) {
return (T)mod((long long)a * b, (long long)c);
}
template <class T>
T powmod(T a, T b, T c) {
return (T)(b ? mulmod(mod((T)sqr((long long)powmod(a, b >> 1, c)), c),
b & 1 ? a : 1, c)
: 1);
}
template <class T>
void maxe(T &a, T b) {
a = max(a, b);
}
template <class T>
void mine(T &a, T b) {
a = min(a, b);
}
template <class T>
void mode(T &a, T b) {
a = mod(a, b);
}
template <class T>
void addmode(T &a, T b, T c) {
a = addmod(a, b, c);
}
template <class T>
void mulmode(T &a, T b, T c) {
a = mulmod(a, b, c);
}
template <class T>
void powmode(T &a, T b, T c) {
a = powmod(a, b, c);
}
void fileio_in_out() {
freopen(".in", "r", stdin);
freopen(".out", "w", stdout);
}
void fileio_txt() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
const int N = 1111111;
int test;
long long n, m, k, ans;
long long dfs(long long x, long long y) {
if (x >= k || y >= k) return 0;
if (x < y) swap(x, y);
long long ret = 0;
if (y >= 0) {
ret = 1;
y += x;
} else {
ret = (-y) / x;
y += ret * x;
if (y < 0) {
ret++;
y += x;
}
}
return ret + dfs(x, y);
}
long long getans() {
if (n >= k || m >= k) return 0;
if (n <= 0 && m <= 0) return -1;
return dfs(n, m);
}
int main() {
scanf("%I64d%I64d%I64d", &n, &m, &k);
printf("%I64d\n", getans());
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2000 + 3;
int n;
string a[N], b[N];
string s;
vector<int> adj[4 * N], rev_adj[4 * N];
bool ans[2 * N];
vector<int> order;
bool used[4 * N];
int timer, comp[4 * N];
void create_component(int u) {
used[u] = true;
comp[u] = timer;
for (int to : rev_adj[u]) {
if (used[to]) continue;
create_component(to);
}
}
void top_sort(int u) {
used[u] = true;
for (int to : adj[u]) {
if (used[to]) continue;
top_sort(to);
}
order.push_back(u);
}
bool do_2sat() {
for (int i = 0; i < 4 * n; ++i)
for (int to : adj[i]) rev_adj[to].push_back(i);
for (int i = 0; i < 4 * n; ++i)
if (!used[i]) top_sort(i);
for (int i = 0; i < 4 * n; ++i) used[i] = false;
timer = 0;
for (int i = 4 * n - 1; i >= 0; --i) {
int u = order[i];
if (!used[u]) {
timer++;
create_component(u);
}
}
for (int i = 0; i < 4 * n; i += 2)
if (comp[i] == comp[i + 1]) return false;
for (int i = 0; i < 2 * n; ++i) used[i] = false;
for (int u : order) {
if (used[u / 2]) continue;
used[u / 2] = true;
ans[u / 2] = (u & 1);
}
return true;
}
void create_graph() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
int diff = (a[i][j] - '0') ^ (b[i][j] - '0');
int r = (s[j] - '0'), c = (s[i] - '0');
if (!r && !c) {
if (diff) {
cout << "-1\n";
exit(0);
}
} else if (r && !c) {
if (diff)
adj[2 * i].push_back(2 * i + 1);
else
adj[2 * i + 1].push_back(2 * i);
} else if (!r && c) {
if (diff)
adj[2 * j + 2 * n].push_back(2 * j + 1 + 2 * n);
else
adj[2 * j + 2 * n + 1].push_back(2 * j + 2 * n);
} else if (r && c) {
if (diff) {
adj[2 * j + 2 * n].push_back(2 * i + 1);
adj[2 * i + 1].push_back(2 * j + 2 * n);
adj[2 * j + 1 + 2 * n].push_back(2 * i);
adj[2 * i].push_back(2 * j + 1 + 2 * n);
} else {
adj[2 * j + 2 * n].push_back(2 * i);
adj[2 * i].push_back(2 * j + 2 * n);
adj[2 * j + 1 + 2 * n].push_back(2 * i + 1);
adj[2 * i + 1].push_back(2 * j + 1 + 2 * n);
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
cin >> s;
create_graph();
if (!do_2sat()) {
cout << "-1\n";
return 0;
}
vector<pair<string, int>> output;
for (int i = 0; i < n; ++i)
if (ans[i]) output.push_back({"row", i});
for (int i = 0; i < n; ++i)
if (ans[i + n]) output.push_back({"col", i});
cout << output.size() << "\n";
for (auto [str, i] : output) cout << str << " " << i << "\n";
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int color[1000000];
int f[1000000];
vector<pair<int, int> > go[1000000];
int main() {
int n, m;
cin >> n >> m;
while (m--) {
int x, y, c;
cin >> x >> y >> c;
go[y].push_back({x, c});
}
fill(color, color + n + 1, -1);
fill(f, f + n + 1, 0x7fffffff);
deque<int> d;
f[n] = 0;
d.push_back(n);
while (!d.empty()) {
int o = d.front();
d.pop_front();
for (auto i : go[o]) {
int t = i.first;
int c = i.second;
if (color[t] == -1)
color[t] = 1 - c;
else if (color[t] == c && f[t] > f[o] + 1) {
f[t] = f[o] + 1;
d.push_back(t);
}
}
}
if (f[1] == 0x7fffffff)
cout << -1 << endl;
else
cout << f[1] << endl;
for (int i = 1; i <= n; ++i)
if (color[i] == -1)
cout << 0;
else
cout << color[i];
cout << endl;
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
x = 0;
char c = getchar();
int f = 1;
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) x = x * 10 - '0' + c, c = getchar();
x *= f;
}
const int M = 510;
const int B = 500;
struct item {
int p;
long long v;
item(int p = 0, long long v = 0) : p(p), v(v) {}
friend bool operator<(item A, item B) {
if (A.p == -1) return B.p != -1;
if (B.p == -1) return 0;
return A.v < B.v;
}
};
long long __a[M];
bool cmp(int x, int y) { return __a[x] < __a[y]; }
struct BLOCK {
long long a[M], b[M], tg, l;
int pos[M], m, hd, tl;
int vis[M], que[M];
int s;
long double slope(int x, int y) {
return (b[y] - b[x]) / (long double)(a[x] - a[y]);
}
int dcmp(long double x) { return x < -1e-12 ? -1 : (x > 1e-12); }
void rebuild() {
hd = 1, tl = 0;
for (int u = 0; u < m; ++u) {
int i = pos[u];
if (vis[i]) continue;
if (hd <= tl && a[i] == a[que[tl]]) {
if (b[i] > b[que[tl]]) {
tl--;
while (hd < tl &&
dcmp(slope(que[tl - 1], que[tl]) - slope(que[tl], i)) >= 0)
tl--;
que[++tl] = i;
}
continue;
}
while (hd < tl &&
dcmp(slope(que[tl - 1], que[tl]) - slope(que[tl], i)) >= 0)
tl--;
que[++tl] = i;
}
}
void build(int _m, int _s) {
m = _m, s = _s;
for (int i = 0; i < m; ++i) b[i] = a[i] = __a[i], pos[i] = i;
sort(pos, pos + m, cmp);
l = tg = 0;
rebuild();
}
void add(int t) { tg += t; }
void mul() { l++; }
void push_down() {
if (l || tg) {
for (int i = 0; i < m; ++i) b[i] += a[i] * l + tg;
l = tg = 0;
}
}
void del(int x) {
push_down();
for (int i = 0; i < x; ++i) b[i] += a[x];
for (int i = x + 1; i < m; ++i) b[i] += a[i];
vis[x] = 1;
rebuild();
}
item query() {
while (hd < tl && dcmp(l - slope(que[hd], que[hd + 1])) >= 0) hd++;
if (hd <= tl) return item(s + que[hd], a[que[hd]] * l + b[que[hd]] + tg);
return item(-1, -1);
}
} T[210];
const int N = 1e5 + 10;
int a[N], n, tot;
int bl[N];
void D(int x) {
for (int i = 0; i < bl[x]; ++i) T[i].add(a[x]);
T[bl[x]].del(x - bl[x] * B);
for (int i = bl[x] + 1; i < tot; ++i) T[i].mul();
}
item Q() {
item ans = item(-1, -1);
for (int i = 0; i < tot; ++i) ans = max(ans, T[i].query());
return ans;
}
int main() {
rd(n);
for (int i = 0; i < n; ++i) rd(a[i]);
for (int i = 0; i < n; ++i) bl[i] = i / B;
tot = (n - 1) / B + 1;
for (int i = 0; i < n; i += B) {
for (int j = 0; j < min(B, n - i); ++j) __a[j] = a[i + j];
T[bl[i]].build(min(B, n - i), i);
}
item tmp, lim = item(0, 0);
long long ans = 0;
while (!((tmp = Q()) < lim)) ans += tmp.v, D(tmp.p);
printf("%lld", ans);
return 0;
}
| 24
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, s[20005], a;
int dp[55][105];
int dp1[55][105];
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a);
s[i] = (s[i - 1] + a) % m;
}
int sol = INT_MIN;
for (int i = 0; i < 55; ++i)
for (int j = 0; j < 105; ++j) dp[i][j] = INT_MIN;
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 55; ++j)
for (int k1 = 0; k1 < 105; ++k1) dp1[j][k1] = INT_MIN;
for (int j = 0; j < k; ++j)
for (int x = 0; x < m; ++x) {
dp1[j + 1][s[i]] = max(dp1[j + 1][s[i]], dp[j][x] + (m + s[i] - x) % m);
if (j == k - 1 && i == n) sol = max(sol, dp1[j + 1][s[i]]);
}
for (int j = 0; j < 55; ++j) {
for (int k1 = 0; k1 < 105; ++k1) {
dp[j][k1] = max(dp[j][k1], dp1[j][k1]);
}
}
}
printf("%d\n", sol);
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
struct sol {
int x, y, z, a, b, t;
};
vector<pair<int, int> > stations;
vector<sol> sols;
int e, s, n, m;
sol driveback(sol car, int si, int fin) {
int dist = stations[si].first - fin;
int i;
i = max(min(car.z, min(s - car.t, dist - car.t)), 0);
car.z -= i;
car.t += i;
i = max(min(car.y, min(s - car.t, dist - car.t)), 0);
car.y -= i;
car.t += i;
car.b += i;
i = max(min(car.x, min(s - car.t, dist - car.t)), 0);
car.x -= i;
car.t += i;
car.a += i;
if (dist > car.t) {
car.a = car.b = -1;
car.x = car.y = car.z = 0;
car.t = 0;
return car;
}
i = s - car.t;
car.z = min(i, car.z);
i -= car.z;
car.y = min(i, car.y);
i -= car.y;
car.x = min(i, car.x);
car.t -= dist;
return car;
}
int main() {
cin >> e >> s >> n >> m;
int i, j;
for (int c = 0; c < n; c++) {
cin >> i >> j;
if (j <= e) stations.push_back(pair<int, int>(j, i));
}
n = stations.size();
stations.push_back(pair<int, int>(pair<int, int>(e, 3)));
sort(stations.begin(), stations.end());
sols.resize(n + 1);
sol car;
car.x = car.y = car.z = car.a = car.b = 0;
car.t = s;
sols[n] = car;
for (int c = n - 1; c >= 0; c--) {
car = driveback(car, c + 1, stations[c].first);
if (car.a != -1) {
int t = stations[c].second;
switch (t) {
case 1:
car.x = s;
break;
case 2:
car.y = s;
break;
case 3:
car.z = s;
break;
}
}
sols[c] = car;
}
for (int c = 0; c < m; c++) {
cin >> i;
vector<pair<int, int> >::iterator it =
upper_bound(stations.begin(), stations.end(), pair<int, int>(i, 3));
car = driveback(sols[it - stations.begin()], it - stations.begin(), i);
cout << car.a << ' ' << car.b << endl;
}
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t = 0;
long long ans = 0;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
while (1 + (1 << t) <= n) t++;
t--;
for (int i = 0; i < n - 1; i++) {
ans += a[i];
a[i + (1 << t)] += a[i];
a[i] = 0;
cout << ans << endl;
if ((i + (1 << t) + 1) >= n) t--;
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
char k, w[2][26];
int g, e, m[30], l = 0;
int main() {
string a;
cin >> a;
for (int i = 0; i < a.size(); i++)
if (m[a[i] - 'A'] != 0) {
k = a[i];
e = m[a[i] - 'A'] - 1;
g = i;
} else
m[a[i] - 'A'] = i + 1;
if (g - e == 1) {
cout << "Impossible" << endl;
return 0;
}
for (int i = (g + e - 1) / 2; i >= (g + e + 1) / 2 - 13; i--)
if (i != g) cout << a[(i + 54) % 27];
cout << endl;
for (int i = (g + e - 1) / 2 + 1; i <= (g + e + 1) / 2 + 13; i++)
if (i != g) cout << a[i % 27];
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int R = 1001;
int h[R][R], l[R][R];
int road[100001][2];
int alp[30][2];
string str[R];
int n, m, w;
void Input1() {
memset(alp, 0, sizeof(alp));
memset(h, 0, sizeof(h));
memset(l, 0, sizeof(l));
for (int i = 0; i < n; i++) {
cin >> str[i];
for (int j = 0; j < str[i].size(); j++) {
if (isalpha(str[i][j])) {
alp[str[i][j] - 'A' + 1][0] = i + 1;
alp[str[i][j] - 'A' + 1][1] = j + 1;
}
if (str[i][j] == '#') {
l[j + 1][i + 1] = l[j + 1][i] + 1;
h[i + 1][j + 1] = h[i + 1][j] + 1;
} else {
l[j + 1][i + 1] = l[j + 1][i];
h[i + 1][j + 1] = h[i + 1][j];
}
}
}
}
void Input2() {
char u;
int v;
cin >> w;
for (int i = 1; i <= w; i++) {
cin >> u >> v;
if (u == 'N')
road[i][0] = -v, road[i][1] = 0;
else if (u == 'S')
road[i][0] = v, road[i][1] = 0;
else if (u == 'E')
road[i][0] = 0, road[i][1] = v;
else
road[i][0] = 0, road[i][1] = -v;
}
}
bool find(int p, int q) {
int p1, q1;
for (int i = 1; i <= w; i++) {
p1 = p + road[i][0];
q1 = q + road[i][1];
if (p1 < 1 || q1 < 1 || p1 > n || q1 > m) return false;
if (p == p1 && h[p][max(q, q1)] - h[p][min(q, q1) - 1]) return false;
if (q == q1 && l[q][max(p, p1)] - l[q][min(p, p1) - 1]) return false;
p = p1, q = q1;
}
return true;
}
void Solve() {
bool flag = true;
for (int i = 1; i <= 26; i++) {
if (!alp[i][0]) continue;
if (find(alp[i][0], alp[i][1])) {
flag = false;
cout << (char)('A' + i - 1);
}
}
if (flag) cout << "no solution";
cout << endl;
}
int main() {
while (cin >> n >> m) {
Input1();
Input2();
Solve();
}
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const long long INF = 1e9;
inline long long pwr(long long base, long long n, long long m) {
long long ans = 1;
while (n > 0) {
if (n & 1) ans = (ans * base) % m;
base = (base * base) % m;
n >>= 1;
}
return ans;
}
int n, x;
char c;
set<int> s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < 10; i++) s.insert(i);
for (int i = 0; i < n; i++) {
cin >> c;
if (c >= '0' && c <= '9') {
s.insert(c - '0');
} else if (c == 'L') {
s.erase(s.begin());
} else {
s.erase(--(s.end()));
}
}
for (int i = 0; i < 10; i++) {
if (s.find(i) != s.end())
cout << 0;
else
cout << 1;
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 500000000;
template <class T>
void debug(T a, T b) {
for (; a != b; ++a) cerr << *a << ' ';
cerr << endl;
}
long long int fib[200005], fib01[200005], fib10[200005];
long long int fibs[200005], fib01s[200005], fib10s[200005];
int n, m;
int ar[105];
const long long int mod = 1000000000;
struct segtree {
struct node {
long long int val, val01, val10;
int all;
int cnt;
node() { val = val01 = val10 = all = cnt = 0; }
};
void fix(node& a) {
a.val %= mod;
a.val01 %= mod;
a.val10 %= mod;
a.all %= mod;
}
void merge(node& res, node& L, node& R) {
res.val =
L.val + R.val10 * fib[L.cnt] % mod + R.val01 * fib[L.cnt + 1] % mod;
res.val01 = L.val01 + R.val10 * fib01[L.cnt] % mod +
R.val01 * fib01[L.cnt + 1] % mod;
res.val10 = L.val10 + R.val10 * fib10[L.cnt] % mod +
R.val01 * fib10[L.cnt + 1] % mod;
res.cnt = L.cnt + R.cnt;
res.all = 0;
fix(res);
}
node val[800005];
int n;
void init(int n_) {
n = 1;
while (n < n_) n <<= 1;
memset(val, 0, sizeof(val));
for (int i = 0; i < n_; ++i) val[i + n - 1].cnt = 1;
for (int i = n - 2; i >= 0; --i)
merge(val[i], val[i * 2 + 1], val[i * 2 + 2]);
}
void add_(node& a, int len, long long int w) {
a.all += w;
a.val += w * fibs[len];
a.val10 += w * fib10s[len];
a.val01 += w * fib01s[len];
fix(a);
}
void push(int i, int l, int r) {
int md = (l + r) >> 1;
if (val[i].all) {
long long int w = val[i].all;
add_(val[i * 2 + 1], md - l, w);
add_(val[i * 2 + 2], md - l, w);
val[i].all = 0;
}
}
void set(int k, int i, int l, int r, int v) {
if (l == k && r - l == 1) {
val[i].val = val[i].val10 = v;
val[i].val01 = 0;
return;
}
if (k + 1 <= l || r <= k) return;
int md = (l + r) >> 1;
push(i, l, r);
set(k, i * 2 + 1, l, md, v);
set(k, i * 2 + 2, md, r, v);
merge(val[i], val[i * 2 + 1], val[i * 2 + 2]);
}
void add(int a, int b, int i, int l, int r, int v) {
if (a <= l && r <= b) {
add_(val[i], r - l, v);
return;
}
if (b <= l || r <= a) return;
int md = (l + r) >> 1;
push(i, l, r);
add(a, b, i * 2 + 1, l, md, v);
add(a, b, i * 2 + 2, md, r, v);
merge(val[i], val[i * 2 + 1], val[i * 2 + 2]);
}
node query(int a, int b, int i, int l, int r) {
if (a <= l && r <= b) {
return val[i];
}
if (b <= l || r <= a) return node();
push(i, l, r);
int md = (l + r) >> 1;
node L = query(a, b, i * 2 + 1, l, md), R = query(a, b, i * 2 + 2, md, r);
node res;
merge(res, L, R);
return res;
}
};
segtree seg;
int main() {
fib[0] = 1;
fib[1] = 1;
fib01[0] = 0;
fib01[1] = 1;
fib10[0] = 1;
fib10[1] = 0;
fibs[1] = 1;
fibs[2] = 2;
fib01s[1] = 0;
fib01s[2] = 1;
fib10s[1] = 1;
fib10s[2] = 1;
for (int i = 2; i < 200005; ++i) {
fib[i] = (fib[i - 1] + fib[i - 2]) % mod;
fib01[i] = (fib01[i - 1] + fib01[i - 2]) % mod;
fib10[i] = (fib10[i - 1] + fib10[i - 2]) % mod;
fibs[i + 1] = fibs[i] + fib[i];
fib01s[i + 1] = fib01s[i] + fib01[i];
fib10s[i + 1] = fib10s[i] + fib10[i];
}
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> ar[i];
seg.init(n);
for (int i = 0; i < n; ++i) {
seg.set(i, 0, 0, seg.n, ar[i]);
}
for (int i = 0; i < m; ++i) {
int t;
scanf("%d", &t);
if (t == 1) {
int x, v;
scanf("%d%d", &x, &v);
--x;
seg.set(x, 0, 0, seg.n, v);
} else if (t == 2) {
int l, r;
scanf("%d%d", &l, &r);
--l;
long long int res = seg.query(l, r, 0, 0, seg.n).val;
cout << res << endl;
} else {
int l, r, d;
scanf("%d%d%d", &l, &r, &d);
--l;
seg.add(l, r, 0, 0, seg.n, d);
}
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500 * 1000 + 10;
int n, m, cnt;
set<int> sv;
vector<int> adj[N], ans[N], tmp;
queue<int> q;
int main() {
ios::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
cin >> n >> m;
for (int i = 0, u, v; i < m; i++)
cin >> u >> v, adj[u].push_back(v), adj[v].push_back(u);
for (int i = 1; i <= n; i++) sv.insert(i), sort(adj[i].begin(), adj[i].end());
while (!sv.empty()) {
if (q.empty())
q.push(*sv.begin()), ans[++cnt].push_back(q.front()),
sv.erase(sv.begin());
int v = q.front(), bs;
q.pop();
for (int u : sv) {
if (adj[v].empty())
bs = -1;
else
bs = upper_bound(adj[v].begin(), adj[v].end(), u) - adj[v].begin() - 1;
if ((bs ^ -1 ? adj[v][bs] : -1) ^ u) tmp.push_back(u);
}
for (int u : tmp) q.push(u), ans[cnt].push_back(u), sv.erase(u);
tmp.clear();
}
cout << cnt << '\n';
for (int i = 1; i <= cnt; i++, cout << '\n') {
cout << ans[i].size() << ' ';
for (int u : ans[i]) cout << u << ' ';
}
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300, maxc = 1e5;
int n, l[maxn + 5], c[maxn + 5];
map<int, bool> vis;
map<int, long long> f;
priority_queue<pair<long long, int> > q;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
inline int dread() {
int x = 0;
bool f = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar()) f ^= (ch == '-');
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = (x << 1) + (x << 3) + (ch ^ 48);
return f ? -x : x;
}
inline void Kaslana() {
n = dread();
for (int i = 1; i <= n; ++i) l[i] = dread();
for (int i = 1; i <= n; ++i) c[i] = dread();
}
inline void Raiden() {
for (int i = 1; i <= n; ++i) q.push(make_pair(f[0] = 0, 0));
for (int x; !q.empty();) {
x = q.top().second, q.pop();
if (vis.find(x) == vis.end())
vis[x] = 1;
else
continue;
if (x == 1) return;
for (int i = 1; i <= n; ++i) {
int y = gcd(l[i], x);
if (f.find(y) == f.end() || f[y] > f[x] + c[i]) {
f[y] = f[x] + c[i];
q.push(make_pair(-f[y], y));
}
}
}
}
inline void Zaychik() {
if (vis.find(1) == vis.end())
puts("-1");
else
printf("%lld\n", f[1]);
}
signed main() {
Kaslana(), Raiden(), Zaychik();
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, c, d, x, y, l, k;
int main() {
cin >> a >> b >> c >> d;
x = (3 * a) / 10;
l = a - a / 250 * c;
y = (3 * b) / 10;
k = b - b / 250 * d;
if (max(x, l) > max(y, k)) {
cout << "Misha";
return 0;
}
if (max(x, l) < max(y, k)) {
cout << "Vasya";
return 0;
}
cout << "Tie";
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200001;
int n, m;
vector<pair<int, long long> > G[N];
int u[N], v[N];
long long x[N];
int parent[N], height[N];
long long d[N];
void dfs(int v, int p) {
for (int i = 0; i < G[v].size(); ++i) {
int to = G[v][i].first;
if (to != p) {
d[to] = G[v][i].second;
parent[to] = v;
height[to] = height[v] + 1;
dfs(to, v);
}
}
}
int Find(int u) {
if (d[u] == 1)
return parent[u] = Find(parent[u]);
else
return u;
}
long long solve(int u, int v, long long x) {
vector<long long> vu, vv;
while (v != u) {
if (vu.size() + vv.size() > 70) return 0;
pair<int, long long> tmp;
if (height[v] < height[u]) {
if (d[u] == 1) {
u = Find(u);
continue;
} else {
vu.push_back(d[u]);
u = parent[u];
}
} else {
if (d[v] == 1) {
v = Find(v);
continue;
} else {
vv.push_back(d[v]);
v = parent[v];
}
}
}
for (int i = 0; i < vu.size(); ++i) {
if (vu[i] != 0) x /= vu[i];
}
for (int i = (int)vv.size() - 1; i >= 0; --i) {
if (vv[i] != 0) x /= vv[i];
}
return x;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n - 1; ++i) {
scanf("%d%d%I64d", &u[i], &v[i], &x[i]);
G[u[i]].push_back(make_pair(v[i], x[i]));
G[v[i]].push_back(make_pair(u[i], x[i]));
}
G[0].push_back(make_pair(1, 0));
parent[0] = -1;
height[0] = 0;
dfs(0, -1);
for (int i = 0; i < m; ++i) {
int type;
scanf("%d", &type);
if (type == 1) {
int a, b;
long long y;
scanf("%d%d%I64d", &a, &b, &y);
printf("%I64d\n", solve(a, b, y));
} else {
int p;
long long c;
scanf("%d%I64d", &p, &c);
p--;
if (parent[u[p]] == v[p])
d[u[p]] = c;
else
d[v[p]] = c;
}
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, i, mcost = 0;
cin >> n >> k;
vector<long long> v(n), sc(n);
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
less<pair<long long, long long> > >
pq;
for (i = 0; i < n; i++) {
cin >> v[i];
if (i <= k) pq.push(make_pair(v[i], i));
}
i = k + 1;
for (long long j = 0; !pq.empty(); j++) {
pair<long long, long long> p = pq.top();
mcost += p.first * (k + j - p.second);
sc[p.second] = j + k + 1;
pq.pop();
if (i < n) {
pq.push(make_pair(v[i], i));
i++;
}
}
cout << mcost << endl;
for (i = 0; i < n; i++) {
cout << sc[i] << " ";
}
cout << endl;
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
char s[1000010];
int nxt[1000010];
int a[1000010];
long long mod = 1000000007;
long long pow(long long a, long long b) {
long long s = 1;
while (b) {
if (b & 1) s = s * a % mod;
a = a * a % mod;
b >>= 1;
}
return s;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
int len;
scanf("%s", s + 1);
len = strlen(s + 1);
int k, p, i, j;
nxt[1] = len;
for (i = 2, j = -1; i <= n; i++, j--)
if (j < 0 || i + nxt[i - k + 1] >= p) {
if (j < 0) {
j = 0;
p = i - 1;
}
while (p < n && s[p + 1] == s[j + 1]) {
p++;
j++;
}
nxt[i] = j;
k = i;
} else
nxt[i] = nxt[i - k + 1];
long long ans = 0;
for (i = 1; i <= m; i++) scanf("%d", &a[i]);
for (i = 2; i <= m; i++)
if (a[i] - a[i - 1] + 1 <= len &&
nxt[a[i] - a[i - 1] + 1] <= len - a[i] + a[i - 1] - 1) {
printf("0\n");
return 0;
}
if (!m)
ans = n;
else {
ans = a[1] - 1;
for (i = 2; i <= m; i++)
if (a[i] - a[i - 1] + 1 > len) ans += a[i] - a[i - 1] + 1 - len - 1;
ans += n - a[m] - len + 1;
}
printf("%I64d\n", pow(26, ans));
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long a, b;
cin >> a >> b;
long long x, y;
cin >> x >> y;
cout << max(max(x, a - 1 - x) * b, max(y, b - 1 - y) * a) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const double eps = 1e-8;
int n, sqrt3, sqrt2;
pair<long long, int> p[N];
long long v, ans, ansa, ansb, ansc;
void dfsb(int k, int a, long long b) {
if (b > sqrt2) return;
if (k == n + 1) {
long long c = v / a / b, s = 2ll * a * b + 2ll * a * c + 2ll * b * c;
if (s < ans) {
ans = s;
ansa = a;
ansb = b;
ansc = c;
}
} else
for (int i = 0; i <= p[k].second; i++, b *= p[k].first) {
p[k].second -= i;
dfsb(k + 1, a, b);
p[k].second += i;
}
}
void dfsa(int k, long long a) {
if (a > sqrt3) return;
if (k == n + 1) {
double x = sqrt(v / a) + eps;
if (4 * a * x + 2 * x * x < ans) {
sqrt2 = x;
dfsb(1, a, 1);
}
} else
for (int i = 0; i <= p[k].second; i++, a *= p[k].first) {
p[k].second -= i;
dfsa(k + 1, a);
p[k].second += i;
}
}
struct ans_t {
long long ans, ansa, ansb, ansc;
ans_t() {}
ans_t(long long ans, long long ansa, long long ansb, long long ansc)
: ans(ans), ansa(ansa), ansb(ansb), ansc(ansc) {}
};
int main() {
int t;
cin >> t;
map<long long, ans_t> m;
while (t--) {
cin >> n;
v = 1;
for (int i = 1; i <= n; i++) {
cin >> p[i].first >> p[i].second;
for (int j = 1; j <= p[i].second; j++) v *= p[i].first;
}
if (m.find(v) == m.end()) {
ans = 4 * v + 3;
sqrt3 = pow(v, 1.0 / 3.0) + eps;
dfsa(1, 1);
cout << ans << ' ' << ansa << ' ' << ansb << ' ' << ansc << endl;
m[v] = ans_t(ans, ansa, ansb, ansc);
} else
cout << m[v].ans << ' ' << m[v].ansa << ' ' << m[v].ansb << ' '
<< m[v].ansc << endl;
}
return 0;
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
vector<pair<long long, long long>> ans;
vector<long long> v;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
ans.push_back(make_pair(x, i));
}
sort(ans.begin(), ans.end());
long long sum = 0;
for (int i = 0; i < n; ++i) {
if (sum + ans[i].first > k) {
break;
} else {
sum += ans[i].first;
v.push_back(ans[i].second + 1);
}
}
cout << v.size() << "\n";
for (int i = 0; i < v.size(); ++i) cout << v[i] << " ";
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
const int inf = 1000000000;
struct Edge {
int to, next, c, f;
} edge[2000100];
int head[100010], num = -1, e[N][2];
void add_edge(int a, int b, int c, int f) {
edge[++num] = (Edge){b, head[a], c, f}, head[a] = num;
edge[++num] = (Edge){a, head[b], -c, 0}, head[b] = num;
}
int S, T, d0[N], id[N][N][2], cnt;
int q[1000100], dis[100010];
bool vis[100010], vv[100010];
bool spfa() {
for (int i = 1; i <= T; i++) dis[i] = inf;
int he = 0, ta = 0;
q[++ta] = S, dis[S] = 0;
while (he != ta) {
int x = q[++he];
for (int i = head[x]; i != -1; i = edge[i].next)
if (edge[i].f && dis[edge[i].to] > dis[x] + edge[i].c) {
dis[edge[i].to] = dis[x] + edge[i].c;
if (!vis[edge[i].to]) vis[edge[i].to] = true, q[++ta] = edge[i].to;
}
vis[x] = false;
}
return dis[T] != inf;
}
int sum;
int dfs(int x, int fl) {
if (x == T) {
sum += dis[T] * fl;
return fl;
}
if (vv[x]) return 0;
vv[x] = true;
int ret = 0, tmp;
for (int i = head[x]; i != -1; i = edge[i].next)
if (fl && edge[i].f && dis[edge[i].to] == dis[x] + edge[i].c &&
(tmp = dfs(edge[i].to, min(edge[i].f, fl))))
fl -= tmp, ret += tmp, edge[i].f -= tmp, edge[i ^ 1].f += tmp;
return ret;
}
int costflow() {
while (spfa()) {
memset(vv, false, sizeof(vv));
while (dfs(S, inf))
;
}
return sum;
}
int main() {
int tt = 100;
int n, m, k, c, d;
scanf("%d%d%d%d%d", &n, &m, &k, &c, &d);
cnt = n;
memset(head, -1, sizeof(head));
for (int i = 1; i <= tt; i++)
for (int j = 1; j <= m * 2; j++) {
id[i][j][0] = ++cnt, id[i][j][1] = ++cnt;
for (int k = 1; k <= n; k++)
add_edge(id[i][j][0], id[i][j][1], (k * k - (k - 1) * (k - 1)) * d, 1);
}
S = cnt + 1, T = S + 1;
for (int i = 1; i <= k; i++) {
int a;
scanf("%d", &a);
d0[a]++;
}
for (int i = 1; i <= n; i++) add_edge(S, i, 0, d0[i]);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &e[i][0], &e[i][1]);
e[i + m][0] = e[i][1], e[i + m][1] = e[i][0];
}
for (int i = 1; i <= m * 2; i++)
for (int j = 1; j <= m * 2; j++)
if (e[i][1] == e[j][0])
for (int k = 1; k <= tt - 1; k++)
add_edge(id[k][i][1], id[k + 1][j][0], 0, inf);
for (int i = 1; i <= m * 2; i++)
for (int j = 1; j <= tt - 1; j++)
add_edge(id[j][i][1], id[j + 1][i][1], 0, inf);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m * 2; j++)
if (e[j][1] == i)
for (int k = 1; k <= tt; k++) add_edge(i, id[k][j][1], 0, inf);
for (int i = 1; i <= m * 2; i++)
if (e[i][1] == 1)
for (int j = 1; j <= tt; j++) add_edge(id[j][i][1], T, (j - 1) * c, inf);
printf("%d\n", costflow());
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int mini(int a, int b, int c, int d, int e) {
return min(a, min(b, min(c, min(d, e))));
}
int maxi(int a, int b, int c, int d, int e) {
return max(a, max(b, max(c, max(d, e))));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, l, r;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
string b;
cin >> b;
l = 1e9 * (-1);
if (b[4] == '1') {
l = maxi(a[0], a[1], a[2], a[3], a[4]) + 1;
}
r = 1e9;
for (int i = 5; i < n; i++) {
if (b[i] != b[i - 1]) {
if (b[i - 1] == '0' && b[i - 2] == '0' && b[i - 3] == '0' &&
b[i - 4] == '0') {
l = max(l, maxi(a[i], a[i - 1], a[i - 2], a[i - 3], a[i - 4]) + 1);
} else if (b[i - 1] == '1' && b[i - 2] == '1' && b[i - 3] == '1' &&
b[i - 4] == '1') {
r = min(r, mini(a[i], a[i - 1], a[i - 2], a[i - 3], a[i - 4]) - 1);
}
}
}
cout << l << " " << r;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
int fu = 1;
char c = getchar();
while (c > 57 || c < 48) {
if (c == 45) fu = -1;
c = getchar();
}
while (c <= 57 && c >= 48) {
x = (x << 3) + (x << 1) + c - 48;
c = getchar();
}
x *= fu;
}
template <typename T>
inline void fprint(T x) {
if (x < 0) putchar(45), x = -x;
if (x > 9) fprint(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void fprint(T x, char ch) {
fprint(x);
putchar(ch);
}
int n, ans1, ans2;
vector<int> vec;
int main() {
read(n);
while (n--) {
int k;
read(k);
for (register int i = 1; i <= k; i++) {
int x;
read(x);
if (i <= (k >> 1))
ans1 += x;
else if ((k & 1) && i == ((k + 1) >> 1))
vec.push_back(x);
else
ans2 += x;
}
}
sort(vec.begin(), vec.end());
int it = 1;
while (!vec.empty()) {
if (it)
ans1 += vec.back();
else
ans2 += vec.back();
vec.pop_back();
it ^= 1;
}
fprint(ans1, 32);
fprint(ans2, 10);
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
bool SortGrtScnd(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second > b.second);
}
int gcd(int a, int b) {
if (!b)
return a;
else
return (gcd(b, a % b));
}
unsigned long long powFn(int num, int power) {
unsigned long long serd = 1;
for (int i = 0; i < power; i++) serd *= (unsigned long long)num;
return serd;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int tx, ty;
bool x = true, y = true, csp = false;
for (int i = 0; i < n; i++) {
cin >> tx >> ty;
if (tx & 1) {
if (x)
x = false;
else
x = true;
}
if (ty & 1) {
if (y)
y = false;
else
y = true;
}
if (((ty & 1) && !(tx & 1)) || (!(ty & 1) && (tx & 1))) csp = true;
}
if (x && y)
cout << 0;
else if (!x && !y && csp)
cout << 1;
else
cout << -1;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, m, s;
int a[N], ans[N];
struct Student {
int b, c, id;
bool operator<(Student b) const { return c > b.c; }
} stu[N];
struct Bug {
int a, id;
bool operator<(Bug b) const { return a < b.a; }
} bug[N];
int cmp(Student a, Student b) { return a.b > b.b; }
void solve(int time) {
int limit = s, cnt = 0;
priority_queue<Student> Q;
for (int i = m - 1; i >= 0; i -= time) {
while (stu[cnt].b >= bug[i].a && cnt != n) Q.push(stu[cnt++]);
Student t = Q.top();
Q.pop();
limit -= t.c;
int e = i - time + 1;
if (e < 0) e = 0;
for (int j = i; j >= e; j--) ans[bug[j].id] = t.id;
}
}
bool OK(int time) {
int limit = s, cnt = 0;
priority_queue<Student> Q;
for (int i = m - 1; i >= 0; i -= time) {
while (stu[cnt].b >= bug[i].a && cnt != n) Q.push(stu[cnt++]);
if (Q.empty()) return false;
Student t = Q.top();
Q.pop();
if (limit < t.c) return false;
limit -= t.c;
}
return true;
}
void Deal() {
if (OK(m) == false) {
printf("NO\n");
return;
}
int low = 0, high = m;
while (low < high) {
int mid = (low + high) >> 1;
if (OK(mid))
high = mid;
else
low = mid + 1;
}
solve(high);
printf("YES\n");
for (int i = 0; i < m - 1; i++) printf("%d ", ans[i] + 1);
printf("%d\n", ans[m - 1] + 1);
}
int main() {
int i;
scanf("%d%d%d", &n, &m, &s);
for (i = 0; i < m; i++) {
scanf("%d", &bug[i].a);
bug[i].id = i;
}
for (i = 0; i < n; i++) {
scanf("%d", &stu[i].b);
stu[i].id = i;
}
for (i = 0; i < n; i++) scanf("%d", &stu[i].c);
sort(bug, bug + m);
sort(stu, stu + n, cmp);
Deal();
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
class pii {
public:
int first, second;
pii() { first = second = 0; }
pii(int _first, int _second) {
first = _first;
second = _second;
}
bool operator<(const pii &a) const {
if (first != a.first) {
return first < a.first;
}
return second < a.second;
}
};
int main() {
char s[101010];
int n;
scanf("%s", s);
n = strlen(s);
pii a[101010];
a[n - 1] = pii(s[n - 1], n - 1);
int i;
for (i = n - 2; i >= 0; i--) {
a[i] = pii(s[i], i);
a[i] = min(a[i], a[i + 1]);
}
pii cur = a[0];
char buf[101010];
int buf_size = 0;
char u[101010];
int l = 0;
bool d[101010] = {false};
i = 0;
while (cur.first != -1) {
for (; i < cur.second; i++) {
if (!d[i]) {
d[i] = true;
buf[buf_size++] = s[i];
}
}
u[l++] = cur.first;
d[cur.second] = true;
if (cur.second != n - 1) {
pii nxt = a[cur.second + 1];
while (buf_size && buf[buf_size - 1] <= nxt.first) {
u[l++] = buf[--buf_size];
}
cur = nxt;
} else {
cur.first = -1;
}
}
while (buf_size) {
u[l++] = buf[--buf_size];
}
u[n] = '\0';
printf("%s\n", u);
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1010101010;
int N;
int A[3030];
int B[3030];
int D[3030][3030];
int E[3030][3030];
int nxt[3030][3030];
int main() {
int tc; scanf("%d", &tc);
while(tc--) {
scanf("%d", &N);
for(int i = 1; i <= N; i++) scanf("%d", &A[i]);
for(int i = 1; i <= N; i++) for(int j = 0; j <= N; j++) D[i][j] = E[i][j] = INF;
for(int i = N - 1; i >= 1; i--) {
if(!A[i]) continue;
if(i + A[i] == N) continue;
bool ok = false;
for(int j = 1; j <= A[i]; j++) {
if(A[i + j]) ok = true;
}
if(!ok) A[i] = 0;
}
for(int i = 1; i <= N; i++) B[i] = A[i];
for(int i = 1; i <= N; i++) for(int j = 0; j <= N; j++) nxt[i][j] = 0;
for(int i = 2; i <= N; i++) {
if(i != N && !A[i]) continue;
for(int j = 1; j <= i; j++) B[j] = A[j];
int p = i - 1;
for(int j = 0; j <= N; j++) {
while(p >= 1) {
if(!B[p]) { p--; continue; }
if(B[p] + p < i) { p--; continue; }
else break;
}
if(p < 1) break;
nxt[i][j] = p;
B[p] = 0; p--;
}
}
// for(int i = 1; i <= N; i++) {
// for(int j = 0; j <= N; j++) {
// printf("%d ", nxt[i][j]);
// }
// puts("");
// }
for(int i = 1; i < N; i++) {
if(!A[i]) continue;
for(int j = 0; j <= N; j++) {
if(!nxt[i][j]) break;
int k = nxt[i][j];
E[i][A[k] + k] = min(E[i][A[k] + k], D[k][i] + j);
}
E[i][0] = INF;
E[1][0] = 0;
for(int j = 1; j <= N; j++) {
E[i][j] = min(E[i][j], E[i][j - 1]);
}
for(int j = i + 1; j <= i + A[i]; j++) {
if(j != N && !A[j]) continue;
D[i][j] = E[i][j - 1];
}
}
int ans = INF;
for(int i = 0; i <= N; i++) {
if(!nxt[N][i]) break;
int j = nxt[N][i];
ans = min(ans, D[j][N] + i);
}
printf("%d\n", ans);
}
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
char a[55][55];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
int x = 0, y = n, u = 0, v = m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == '*') {
if (i >= x) x = i;
if (i <= y) y = i;
if (j >= u) u = j;
if (j <= v) v = j;
}
}
}
for (int i = y; i <= x; i++) {
for (int j = v; j <= u; j++) {
cout << a[i][j];
}
cout << endl;
}
}
| 0
|
#include <bits/stdc++.h>
namespace IO {
char ch = '\n';
template <class T>
inline T ReadInt() {
T x(0);
bool f(1);
while (ch < '0' || '9' < ch) {
if (ch == '-') {
f = 0;
}
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return f ? x : -x;
}
template <class T>
inline T ReadUInt() {
T x(0);
while (ch < '0' || '9' < ch) {
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x;
}
inline double ReadDouble() {
long long int_num = ReadInt<long long>();
if (ch == '.') {
double pow10 = 1, result = int_num;
ch = getchar();
while ('0' <= ch && ch <= '9') {
pow10 /= 10.0;
result += pow10 * (ch ^ 48);
ch = getchar();
}
return result;
} else {
return (double)int_num;
}
}
inline void ReadT(int &x) { x = ReadInt<int>(); }
inline void ReadT(long long &x) { x = ReadInt<long long>(); }
inline void ReadT(bool &x) { x = ReadUInt<bool>(); }
inline void ReadT(unsigned int &x) { x = ReadUInt<unsigned int>(); }
inline void ReadT(unsigned long long &x) { x = ReadUInt<unsigned long long>(); }
inline void ReadT(double &x) { x = ReadDouble(); }
inline void ReadT(char &s) {
for (; isspace(ch) && (~ch); ch = getchar())
;
s = ch;
ch = '\n';
}
inline void ReadT(char *s) {
int len(0);
for (; isspace(ch) && (~ch); ch = getchar())
;
for (; !isspace(ch) && (~ch); ch = getchar()) {
s[len++] = ch;
}
s[len] = '\0';
ch = '\n';
}
template <typename T>
inline void Read(T &t) {
ReadT(t);
}
template <typename T, typename... Args>
void Read(T &t, Args &...args) {
ReadT(t);
Read(args...);
}
template <typename T>
void WriteInt(T x) {
if (x < 0) {
printf("-");
x = -x;
}
if (9 < x) {
WriteInt(x / 10);
}
putchar(x % 10 + '0');
}
template <typename T>
void WriteUInt(T x) {
if (9 < x) {
WriteInt(x / 10);
}
putchar(x % 10 + '0');
}
void WriteDouble(long double x, int len) {
WriteInt((long long)x);
if (len) {
x -= (int)x;
putchar('.');
if (!x) {
while (len--) {
putchar(48);
}
return;
}
while (len--) {
x *= 10;
}
WriteInt((long long)round(x));
}
}
template <typename T>
inline void WriteT(T x);
template <>
inline void WriteT<int>(int x) {
WriteInt<int>(x);
}
template <>
inline void WriteT<long long>(long long x) {
WriteInt<long long>(x);
}
template <>
inline void WriteT<bool>(bool x) {
WriteUInt<bool>(x);
}
template <>
inline void WriteT<unsigned int>(unsigned int x) {
WriteUInt<unsigned int>(x);
}
template <>
inline void WriteT<unsigned long long>(unsigned long long x) {
WriteUInt<unsigned long long>(x);
}
template <>
inline void WriteT<double>(double x) {
WriteDouble(x, 6);
}
template <>
inline void WriteT<char *>(char *s) {
int len(strlen(s));
while (len--) {
putchar(*s++);
}
}
template <>
inline void WriteT<const char *>(const char *s) {
while (*s) {
putchar(*s++);
}
}
template <>
inline void WriteT<char>(char x) {
putchar(x);
}
template <typename T>
inline void Write(T t) {
WriteT(t);
}
template <typename T, typename... Args>
void Write(T t, Args... args) {
WriteT(t);
Write(args...);
}
template <typename T>
inline void Writeln(T t) {
WriteT(t);
puts("");
}
template <typename T, typename... Args>
inline void Writeln(T t, Args... args) {
WriteT(t);
Write(args...);
puts("");
}
inline void Writeln() { puts(""); }
const char NUMBER[36] = {'0', '1', '2', '3', '4', '5', '6', '7', '8',
'9', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q',
'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
template <typename T>
void WriteK(T x, int p) {
if (x < 0) {
printf("-");
x = -x;
}
if (p <= x) {
WriteK(x / p, p);
}
putchar(NUMBER[x % p]);
}
} // namespace IO
using namespace IO;
using namespace std;
const int MAXN = 1e5 + 5;
const int MAXM = MAXN << 1;
int n, m;
struct Edge {
int to, next;
} edge[MAXM];
int edge_head[MAXN];
int edge_cnt = 0;
inline void AddEdge(int from, int to) {
edge[++edge_cnt].to = to;
edge[edge_cnt].next = edge_head[from];
edge_head[from] = edge_cnt;
}
int a, b, da, db;
int deep[MAXN];
void DFS(int now, int father = 0) {
if (!father) {
deep[now] = 0;
}
for (int edge_i = edge_head[now]; edge_i; edge_i = edge[edge_i].next) {
if (edge[edge_i].to ^ father) {
deep[edge[edge_i].to] = deep[now] + 1;
DFS(edge[edge_i].to, now);
}
}
}
void Work() {
for (int i = 1; i <= n; ++i) {
edge_head[i] = 0;
}
edge_cnt = 0;
Read(n, a, b, da, db);
int f, t;
for (int i = 1; i <= n - 1; ++i) {
Read(f, t);
AddEdge(f, t);
AddEdge(t, f);
}
if (db <= da * 2) {
Writeln("Alice");
return;
}
DFS(a);
if (deep[b] <= da) {
Writeln("Alice");
return;
}
int root = 1;
for (int i = 2; i <= n; ++i) {
if (deep[root] < deep[i]) {
root = i;
}
}
DFS(root);
root = 1;
for (int i = 2; i <= n; ++i) {
if (deep[root] < deep[i]) {
root = i;
}
}
if (deep[root] <= da * 2) {
Writeln("Alice");
} else {
Writeln("Bob");
}
}
int main() {
int t;
Read(t);
for (int i = 1; i <= t; ++i) {
Work();
}
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, sum = 0;
cin >> n;
vector<long long int> vec(n);
map<long long int, long long int> cnt;
vector<long long int> dp(100005);
for (long long int i = 0; i < n; i++) {
cin >> vec[i];
cnt[vec[i]]++;
}
dp[1] = cnt[1];
dp[0] = 0;
for (long long int i = 2; i <= 100006; i++) {
dp[i] = max(dp[i - 1], dp[i - 2] + cnt[i] * i);
}
cout << dp[100005];
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int pre[4005];
void init() {
for (int i = 1; i <= 4000; i++) pre[i] = i;
}
int find(int x) {
if (pre[x] != x) {
pre[x] = find(pre[x]);
}
return pre[x];
}
void Union(int x, int y) {
int fx = find(x);
int fy = find(y);
pre[fx] = fy;
}
struct event {
int x, y;
int t;
event() {}
event(int xx, int yy, int tt) {
x = xx;
y = yy;
t = tt;
}
bool operator<(const event a) const {
if (x == a.x) {
if (y == a.y) return t > a.t;
return y < a.y;
}
return x < a.x;
}
};
event e[4000000 + 5];
int n, m;
struct point {
int x, y;
};
point r[2005], b[2005];
int cal(point a, point b) {
int t1 = (int)ceil(fabs(b.y + b.x - a.y - a.x) / 2.0);
int t2 = (int)ceil(fabs(a.y - a.x - b.y + b.x) / 2.0);
return max(t1, t2);
}
bool cmp(event a, event b) { return a.t < b.t; }
int main() {
init();
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d%d", &b[i].x, &b[i].y);
for (int i = 0; i < m; i++) scanf("%d%d", &r[i].x, &r[i].y);
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
if (b[i].x - b[j].x == b[j].y - b[i].y) {
Union(i, j);
}
}
for (int i = 0; i < m; i++)
for (int j = i + 1; j < m; j++) {
if (r[i].x - r[j].x == r[i].y - r[j].y) {
Union(n + i, n + j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
e[i * m + j] = event(find(i), find(n + j), cal(b[i], r[j]));
}
}
sort(e, e + n * m);
vector<event> vec;
event now = e[0];
for (int i = 1; i <= n * m; i++) {
if (i == n * m) {
vec.push_back(now);
break;
} else {
if (e[i].x == now.x && e[i].y == now.y) {
now = e[i];
} else {
vec.push_back(now);
now = e[i];
}
}
}
sort(vec.begin(), vec.end(), cmp);
for (int i = 0; i < vec.size(); i++) {
if (find(vec[i].x) == find(vec[i].y)) {
printf("%d\n", vec[i].t);
return 0;
} else {
Union(vec[i].x, vec[i].y);
}
}
printf("Poor Sereja!\n");
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 5;
const long long INF64 = 1e18;
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(bool b) { return b ? "true" : "false"; }
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename T>
string to_string(const vector<T> &v) {
string ret = "<";
for (auto it : v) ret += to_string(it) + ", ";
ret.pop_back();
ret.pop_back();
ret += ">";
return ret;
}
void debug_print() { cerr << endl; }
template <typename T, typename... U>
void debug_print(T t, U... u) {
cerr << " " << to_string(t);
debug_print(u...);
}
const int N = 1e5 + 5;
string s;
int n;
long long powmod(long long a, long long b) {
long long ret = 1ll;
while (b) {
if (b & 1) ret = ret * a % MOD;
b = b / 2;
a = (a * a) % MOD;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int a = 0, c = 0, g = 0, t = 0;
int mx = -1;
int cnt = 0;
cin >> n >> s;
for (auto it : s) {
if (it == 'A') {
a++;
if (a > mx) {
mx = a;
cnt = 1;
} else if (a == mx)
cnt++;
}
if (it == 'C') {
c++;
if (c > mx) {
mx = c;
cnt = 1;
} else if (c == mx)
cnt++;
}
if (it == 'G') {
g++;
if (g > mx) {
mx = g;
cnt = 1;
} else if (g == mx)
cnt++;
}
if (it == 'T') {
t++;
if (t > mx) {
mx = t;
cnt = 1;
} else if (t == mx)
cnt++;
}
}
cout << powmod(cnt, n) << '\n';
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
int fa[maxn], col[maxn][2], dis[maxn];
int find(int x) {
if (x != fa[x]) {
int root = find(fa[x]);
dis[x] ^= dis[fa[x]];
fa[x] = root;
}
return fa[x];
}
int main() {
int t;
cin >> t;
while (t--) {
bool f = false;
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
fa[i] = i;
dis[i] = 0;
col[i][0] = 1;
col[i][1] = 0;
}
for (int i = 1; i <= m; i++) {
int x, y;
string s;
cin >> x >> y >> s;
int val = s[0] == 'i' ? 1 : 0;
int px = find(x), py = find(y);
if (px == py) {
if ((dis[x] ^ dis[y]) != val) {
f = true;
}
} else {
fa[py] = px;
dis[py] = dis[x] ^ dis[y] ^ val;
col[px][1] += col[py][dis[py] ^ 1];
col[px][0] += col[py][dis[py]];
}
}
if (f) {
puts("-1");
continue;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
if (fa[i] == i) {
ans += max(col[i][0], col[i][1]);
}
}
cout << ans << endl;
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
long long int modu(long long int a, long long int b) {
long long int ans = 1;
while (b > 0) {
if (b & 1) ans = (ans * a) % 1000000007;
b /= 2;
a = (a * a) % 1000000007;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int tt;
cin >> tt;
while (tt--) {
long long int n;
cin >> n;
long long int arr[n + 1];
for (long long int i = 1; i <= n; i++) {
cin >> arr[i];
arr[i] = arr[i] % 3;
}
long long int ans = 0;
long long int cn1 = 0;
long long int cn2 = 0;
for (long long int i = 1; i <= n; i++) {
if (arr[i] == 0)
ans++;
else if (arr[i] == 1)
cn1++;
else
cn2++;
}
cout << ans + min(cn1, cn2) + abs(cn1 - cn2) / 3 << endl;
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
int n, q, c, l, r, tg, ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> q;
long long a[n], h = 0, m, t;
for (int i = 0; i < n; ++i) {
cin >> c;
h += c;
a[i] = h;
}
t = h;
while (q--) {
cin >> m;
if (m >= h) {
h = t;
cout << n << '\n';
} else {
l = 0, r = n - 1, ans = 0;
while (l <= r) {
tg = (l + r) / 2;
if (a[tg] - t + h == m) {
ans = tg + 1;
break;
} else if (a[tg] - t + h > m)
r = tg - 1;
else
l = tg + 1;
}
if (!ans) ans = l;
cout << n - ans << '\n';
h -= m;
}
}
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5;
const long long inf = 1e18;
long long n, m, k;
long long A[maxn];
int main() {
long long q, w, e, a, b, f;
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> k;
for (a = 0; a < k; a++) {
set<long long> S;
cin >> n;
for (q = 0; q < n; q++) {
cin >> A[q];
S.insert(A[q]);
}
vector<long long> V;
for (auto i : S) {
V.push_back(i);
}
reverse(V.begin(), V.end());
long long ans = V[0];
for (q = 0; q < V.size(); q++) {
if (q < V.size() - 2) {
if (V[q] + V[q + 1] + V[q + 2] <= ans) {
break;
}
}
for (w = q + 1; w < V.size(); w++) {
if (V[q] % V[w] == 0) {
continue;
}
ans = max(ans, V[q] + V[w]);
if (w + 1 != V.size()) {
if (V[q] + V[w] + V[w + 1] <= ans) {
break;
}
}
for (e = w + 1; e < V.size(); e++) {
long long dans = V[q] + V[w] + V[e];
if (V[q] % V[e] != 0 && V[w] % V[e] != 0) {
ans = max(ans, dans);
}
if (dans <= ans) {
break;
}
}
}
}
cout << ans << '\n';
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
using namespace std;
const int MAXN = 120000;
int n;
int a[MAXN];
vector<tuple<int, int, int>> ans;
void out() {
cout << "YES\n";
cout << ans.size() << "\n";
for (auto t : ans) {
int x, y, z;
tie(x, y, z) = t;
cout << x + 1 << " " << y + 1 << " " << z + 1 << "\n";
}
exit(0);
}
void no() {
cout << "NO\n";
exit(0);
}
void add(int x, int y, int z) {
vector<int> tmp = {x, y, z};
sort((tmp).begin(), (tmp).end());
x = tmp[0], y = tmp[1], z = tmp[2];
ans.emplace_back(x, y, z);
a[x] ^= 1;
a[y] ^= 1;
a[z] ^= 1;
}
void add(int x, int y) {
assert(x > y);
int d = x - y;
add(y - d, y, x);
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
int tmpn = n;
while (n >= 12) {
if (!a[n - 1]) {
n -= 1;
continue;
}
if (a[n - 2]) {
if (a[n - 3]) {
add(n - 3, n - 2, n - 1);
n -= 3;
} else {
vector<int> ps;
for (int i = n - 4; i >= n - 6; --i)
if (a[i]) ps.push_back(i);
if (ps.size() == 0) {
add(n - 1, n - 6);
add(n - 2, n - 6);
} else if (ps.size() == 1) {
add(n - 2, n - 7);
add(n - 1, ps[0]);
} else if (ps.size() == 2) {
add(n - 1, ps[0]);
add(n - 2, ps[1]);
} else {
add(n - 2, n - 4);
add(n - 1, n - 5);
}
n -= 6;
}
} else {
if (a[n - 3]) {
add(n - 5, n - 3, n - 1);
n -= 3;
} else {
add(n - 7, n - 4, n - 1);
n -= 3;
}
}
}
for (int i = n - 1; i - 2 >= 0; --i)
if (a[i]) add(i - 2, i - 1, i);
if (a[1]) {
if (tmpn <= 7) no();
add(1, 4, 7);
add(4, 5, 6);
add(5, 6, 7);
}
if (a[0]) {
if (tmpn <= 7) no();
add(0, 3, 6);
add(3, 4, 5);
add(4, 5, 6);
}
out();
for (int i = 0; i < tmpn; ++i) assert(a[i] == 0);
assert(ans.size() <= tmpn / 3 + 12);
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, c;
cin >> a;
cin >> b;
cin >> c;
cout << (long long int)(ceil(a / c) * ceil(b / c));
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
class SegmentTree {
public:
void build(int node, int l, int r);
int getLeft(int i) { return 2 * i; }
int getRight(int i) { return 2 * i + 1; }
void refresh(int node, int l, int r) {
if (!lazy[node]) return;
lazy[node] = false;
sum[node] = (r - l + 1) - sum[node];
if (l == r) return;
lazy[getLeft(node)] = !lazy[getLeft(node)];
lazy[getRight(node)] = !lazy[getRight(node)];
}
void update(int node, int l, int r, int i, int j) {
refresh(node, l, r);
if (j < l || r < i) return;
if (i <= l && r <= j) {
lazy[node] = true;
refresh(node, l, r);
return;
}
int m = (l + r) / 2;
update(getLeft(node), l, m, i, j);
update(getRight(node), m + 1, r, i, j);
sum[node] = sum[getLeft(node)] + sum[getRight(node)];
}
int query(int node, int l, int r, int i, int j) {
refresh(node, l, r);
if (j < l || r < i) return 0;
if (i <= l && r <= j) return sum[node];
int m = (l + r) / 2;
int sumLeft = query(getLeft(node), l, m, i, j);
int sumRight = query(getRight(node), m + 1, r, i, j);
return sumLeft + sumRight;
}
private:
int sum[4 * 200010];
bool lazy[4 * 200010];
};
int n, q;
int n1;
int curTime;
int v[200010];
int inTime[200010];
int indNode[200010];
int outTime[200010];
char a[5];
vector<int> grafo[200010];
SegmentTree SEG;
void SegmentTree::build(int node, int l, int r) {
lazy[node] = false;
if (l == r) return void(sum[node] = v[indNode[l]]);
int m = (l + r) / 2;
build(getLeft(node), l, m);
build(getRight(node), m + 1, r);
sum[node] = sum[getLeft(node)] + sum[getRight(node)];
}
void DFS(int cur) {
inTime[cur] = ++curTime;
indNode[inTime[cur]] = cur;
for (int i = 0; i < grafo[cur].size(); i++) {
int prox = grafo[cur][i];
DFS(prox);
}
outTime[cur] = curTime;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
scanf("%d", &n1);
grafo[n1].push_back(i);
}
for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
DFS(1);
SEG.build(1, 1, n);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf(" %s %d", a, &n1);
if (a[0] == 'p')
SEG.update(1, 1, n, inTime[n1], outTime[n1]);
else
printf("%d\n", SEG.query(1, 1, n, inTime[n1], outTime[n1]));
}
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)(1e9 + 1337);
const long long LINF = (long long)(1e18);
const double EPS = 1e-11;
const int MOD = 1000000007;
const int HBASE = 1003;
inline int add(int a, int b) {
a += b;
if (a >= MOD) {
a -= MOD;
}
return a;
}
inline int sub(int a, int b) {
a -= b;
if (a < 0) {
a += MOD;
}
return a;
}
inline int mul(int a, int b) { return (long long)a * b % MOD; }
inline int bin_pow(int a, int b) {
int res = 1;
while (b) {
if (b & 1) {
res = mul(res, a);
}
b >>= 1;
a = mul(a, a);
}
return res;
}
const int MAXN = 256;
int n;
double p[MAXN][MAXN];
double dp[MAXN][MAXN], pp[MAXN][MAXN];
void init() {
scanf("%d", &n);
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < (1 << n); j++) {
int q;
scanf("%d", &q);
p[i][j] = (double)q / 100.0;
}
}
}
void solve() {
init();
for (int i = 0; i < (1 << n); i++) {
pp[0][i] = 1.0;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << n); j += (1 << i)) {
double mx1 = 0.0, mx2 = 0.0;
for (int p1 = j; p1 < j + (1 << (i - 1)); p1++) {
mx1 = max(mx1, dp[i - 1][p1]);
}
for (int p2 = j + (1 << (i - 1)); p2 < j + (1 << i); p2++) {
mx2 = max(mx2, dp[i - 1][p2]);
}
for (int p1 = j; p1 < j + (1 << (i - 1)); p1++) {
dp[i][p1] = mx2 + dp[i - 1][p1];
}
for (int p2 = j + (1 << (i - 1)); p2 < j + (1 << i); p2++) {
dp[i][p2] = mx1 + dp[i - 1][p2];
}
for (int p1 = j; p1 < j + (1 << (i - 1)); p1++) {
for (int p2 = j + (1 << (i - 1)); p2 < j + (1 << i); p2++) {
dp[i][p1] +=
p[p1][p2] * (1 << (i - 1)) * pp[i - 1][p1] * pp[i - 1][p2];
pp[i][p1] += pp[i - 1][p1] * pp[i - 1][p2] * p[p1][p2];
dp[i][p2] +=
p[p2][p1] * (1 << (i - 1)) * pp[i - 1][p1] * pp[i - 1][p2];
pp[i][p2] += pp[i - 1][p1] * pp[i - 1][p2] * p[p2][p1];
}
}
}
}
double ans = 0.0;
for (int i = 0; i < (1 << n); i++) {
ans = max(ans, dp[n][i]);
}
printf("%.10lf\n", ans);
}
int main() {
srand(333);
double st = clock();
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, i, j;
long long curr;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
curr = 2;
for (i = 1; i <= n; i++) {
if (i == 1)
cout << 2 << '\n';
else {
cout << i * (i + 1) * (i + 1) - (i - 1) << '\n';
}
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = (int)(1e6);
vector<int> graph[MAX_N];
int N, M;
unsigned long long xors[MAX_N];
unsigned long long hs[MAX_N];
void init() {
scanf("%d%d", &N, &M);
for (int i = 0; i < N; i++) {
hs[i] = (unsigned long long)rand() * (unsigned long long)rand() *
(unsigned long long)rand() +
(unsigned long long)rand();
}
for (int i = 0; i < M; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--;
y--;
xors[x] = xors[x] ^ hs[y];
xors[y] = xors[y] ^ hs[x];
graph[x].push_back(y);
graph[y].push_back(x);
}
}
long long solve() {
long long ans = 0;
unordered_map<unsigned long long, int> appear;
for (int i = 0; i < N; i++) {
appear[xors[i]]++;
}
for (int i = 0; i < N; i++) {
ans += appear[xors[i]] - 1;
for (int j = 0; j < (int)graph[i].size(); j++) {
const int x = graph[i][j];
if (xors[i] == xors[x]) {
ans--;
} else if ((xors[i] ^ hs[x]) == (xors[x] ^ hs[i])) {
ans++;
}
}
}
return ans / 2;
}
int main() {
init();
cout << solve() << endl;
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 5;
int a, b, c;
int n;
int x[N];
int main() {
int m = 100000 * 100000;
scanf("%d%d%d", &a, &b, &c);
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", x + i);
sort(x + 1, x + 1 + n);
int ans = lower_bound(x + 1, x + 1 + n, c) - upper_bound(x + 1, x + 1 + n, b);
printf("%d\n", max(ans, 0));
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int a[105];
int b[105];
int find(int x) {
int i, sma = 1000000, s;
for (i = 1; i < x; i++) {
if (a[i] < sma && b[i] == 0) {
sma = a[i];
s = i;
}
}
b[s] = 1;
return sma;
}
bool fun(int x, int y) {
int i, sum = a[x];
for (i = 1; i < x; i++) {
sum += find(x);
if (sum > y) return false;
}
return true;
}
int main() {
int i, m, n, j, s;
while (scanf("%d %d", &n, &m) == 2 && m && n) {
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) {
memset(b, 0, sizeof(b));
if (fun(i, m))
printf("0 ");
else {
s = i;
for (j = 1; j < i; j++) s -= b[j];
printf("%d ", s);
}
}
printf("\n");
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x, mx = 0, arr[100009] = {};
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
arr[x]++;
mx = max(mx, x);
}
for (int i = mx; i >= 1; i--) {
arr[i] = arr[i] * i + max(arr[i + 2], arr[i + 3]);
}
cout << max(arr[1], arr[2]) << endl;
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, n, m;
long long int a[11] = {2, 7, 2, 3, 3, 4, 2, 5, 1, 2};
while (cin >> n) {
i = n % 10;
n /= 10;
j = n;
cout << a[i] * a[j] << endl;
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
using pr = pair<int, int>;
int N, M, Q, A[200005], par[200005];
pr E[300005], QS[500005];
bool chk[300005];
set<int> s[200005];
stack<pr> st;
int f(int x) { return par[x] = (par[x] == x ? x : f(par[x])); }
void uni(int x, int y) {
x = f(x), y = f(y);
if (x == y) return;
if (s[x].size() > s[y].size()) swap(x, y);
st.push(pr(x, y));
for (auto it : s[x]) s[y].insert(it);
par[x] = y;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> N >> M >> Q;
iota(par, par + N + 1, 0);
for (int i = 1; i <= N; i++) cin >> A[i], s[i].insert(A[i]);
for (int i = 1, x, y; i <= M; i++) {
cin >> x >> y;
E[i] = pr(x, y);
}
for (int i = 1, x, y; i <= Q; i++) {
cin >> x >> y;
QS[i] = pr(x, y);
if (x == 2) chk[y] = 1;
}
for (int i = 1; i <= M; i++)
if (!chk[i]) uni(E[i].first, E[i].second);
for (int i = Q; i; i--) {
if (QS[i].first == 1)
QS[i].second = f(QS[i].second);
else {
int x = E[QS[i].second].first, y = E[QS[i].second].second;
if (f(x) == f(y))
QS[i].first = 0;
else
uni(x, y);
}
}
for (int i = 1; i <= Q; i++) {
if (QS[i].first == 1) {
int p = QS[i].second;
int ans = 0;
if (s[p].size() > 0) {
ans = *s[p].rbegin();
s[p].erase(ans);
}
cout << ans << "\n";
} else if (QS[i].first == 2) {
int x = st.top().first, y = st.top().second;
st.pop();
set<int> tmp;
for (auto it : s[x])
if (s[y].find(it) != s[y].end()) {
tmp.insert(it);
s[y].erase(it);
}
s[x] = tmp;
}
}
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
const int size = 1000000;
string s;
int i, n, a[size];
long long ans, tp;
int main() {
cin >> s;
n = s.size();
for (i = 0; i < n - 1; i++)
if (s[i] - '0' + s[i + 1] - '0' == 9)
a[i] = 1;
else
a[i] = 0;
a[n - 1] = 0;
tp = 0;
ans = 1;
for (i = 0; i < n; i++)
if (a[i])
tp++;
else {
if (tp % 2 == 0) ans *= (tp / 2 + 1);
tp = 0;
}
cout << ans << endl;
cin >> n;
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int id;
long long cost;
node(int x, long long y) {
id = x;
cost = y;
}
};
int main() {
std::ios::sync_with_stdio(false);
int n, m, k;
cin >> n >> m >> k;
vector<vector<node> > edges(n + 1);
vector<bool> isSto(n + 1, 0);
vector<int> storages;
while (m--) {
int u, v, k;
cin >> u >> v >> k;
edges[u].push_back(node(v, k));
edges[v].push_back(node(u, k));
}
long long ans = 9999999999999;
while (k--) {
int u;
cin >> u;
storages.push_back(u);
isSto[u] = 1;
}
for (int u = 0; u < storages.size(); u++) {
int z = storages[u];
for (int j = 0; j < edges[z].size(); j++) {
if (isSto[edges[z][j].id]) continue;
ans = min(ans, edges[z][j].cost);
}
}
if (ans == 9999999999999)
cout << -1;
else
cout << ans;
cout << endl;
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int A[n];
map<int, int> mp;
map<int, int>::iterator itr;
for (int i = 0; i < n; i++) cin >> A[i];
for (int i = 0; i < n; i++) {
int y = 0;
while (A[i] % 2 == 0) {
A[i] /= 2;
y++;
}
if (mp.count(A[i]))
mp[A[i]] = max(mp[A[i]], y);
else
mp.insert(make_pair(A[i], y));
}
int u = 0;
for (itr = mp.begin(); itr != mp.end(); itr++) u += itr->second;
cout << u << "\n";
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
bool win(long long s, long long e) {
if (e & 1) return !(s & 1);
if (s * 2 > e) return s & 1;
if (s * 4 > e) return 1;
return win(s, e / 4);
}
bool lose(long long s, long long e) {
if (s * 2 > e) return 1;
return win(s, e / 2);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
int fi = 1, se = 0;
int ok = 0;
long long s, e;
for (int i = 1; i <= t; ++i) {
cin >> s >> e;
if (ok) continue;
if (fi && se) ok = 1;
if (!fi && !se) ok = 2;
if (fi) {
fi = lose(s, e);
se = win(s, e);
} else {
fi = !lose(s, e);
se = !win(s, e);
}
}
if (ok == 1)
cout << "1 1\n";
else if (ok == 2)
cout << "0 0\n";
else
cout << se << ' ' << fi << '\n';
return 0;
}
| 19
|
#include <bits/stdc++.h>
int a, i, cnt = 0;
int main() {
scanf("%d", &a);
if (a <= 6) {
for (i = 0; i < a; i++) printf("0 %d\n", i);
return 0;
}
printf("0 0\n1 1\n1 -1\n2 2\n2 0\n2 -2\n");
cnt = 6;
for (i = 3; 1; i++) {
printf("%d %d\n", i, i);
cnt++;
if (cnt == a) break;
printf("%d %d\n", i, i - 2);
cnt++;
if (cnt == a) break;
printf("%d %d\n", i, -i + 2);
cnt++;
if (cnt == a) break;
printf("%d %d\n", i, -i);
cnt++;
if (cnt == a) break;
}
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0;
cin >> n;
int a[1005];
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
int m, l[1005], r[1005];
cin >> m;
for (int i = 0; i < m; i++) cin >> l[i] >> r[i];
for (int i = 0; i < m; i++) {
if (sum >= l[i] && sum <= r[i]) {
cout << sum << "\n";
return 0;
} else if (sum < l[i]) {
cout << l[i] << "\n";
return 0;
}
}
cout << "-1\n";
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int mat[5005][5005];
int desno[5005][5005];
int niz[10000];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cerr.tie(0), cout.tie(0);
cout.precision(0);
cout << fixed;
int n, m;
cin >> n >> m;
string str;
for (int i = 1; i <= n; i++) {
cin >> str;
for (int j = 1; j <= m; j++) {
mat[i][j] = str[j - 1] - '0';
}
}
for (int i = 1; i <= n; i++) {
for (int j = m; j >= 1; j--) {
if (mat[i][j] == 0)
desno[i][j] = 0;
else
desno[i][j] = desno[i][j + 1] + 1;
}
}
int maxres = 0;
for (int x = 1; x <= m; x++) {
for (int j = 1; j <= n; j++) {
niz[j] = desno[j][x];
}
sort(niz + 1, niz + 1 + n);
reverse(niz + 1, niz + 1 + n);
for (int i = 1; i <= n; i++) {
maxres = max(maxres, niz[i] * i);
}
}
cout << maxres;
return 0;
}
| 8
|
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using ll = long long;
using namespace std;
const long double PI = acos(-1);
const long long M = 1000000007;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline long long mod(long long n, long long m = M) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long exp(long long n, long long k, long long m = M) {
if (k == 0) return 1;
if (k == 1) return n;
long long ax = exp(n, k / 2, m);
ax = mod(ax * ax, m);
if (k % 2) ax = mod(ax * n, m);
return ax;
}
long long gcd(long long a, long long b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
vector<vector<long long> > arr;
vector<long long> sum;
long long n, k;
long long ans = -1e18;
void solve(long long l, long long r, vector<long long> dp) {
if (l == r) {
long long acc = 0;
ans = max(ans, dp[k]);
for (long long i = 1; i <= k && i <= arr[l].size(); i++) {
acc += arr[l][i - 1];
ans = max(ans, acc + dp[k - i]);
}
} else {
long long m = (l + r) >> 1;
vector<long long> dpl(dp);
for (long long i = l; i <= m; i++) {
long long len = arr[i].size();
for (long long j = k; j >= len; j--) {
dpl[j] = max(dpl[j], dpl[j - len] + sum[i]);
ans = max(ans, dpl[j]);
}
}
solve(m + 1, r, dpl);
vector<long long> dpr(dp);
for (long long i = m + 1; i <= r; i++) {
long long len = arr[i].size();
for (long long j = k; j >= len; j--) {
dpr[j] = max(dpr[j], dpr[j - len] + sum[i]);
ans = max(ans, dpr[j]);
}
}
solve(l, m, dpr);
}
}
void solution() {
cin >> n >> k;
for (long long i = 0; i < n; i++) {
long long s;
cin >> s;
arr.push_back(vector<long long>(s, 0));
sum.push_back(0);
for (long long &x : arr.back()) cin >> x, sum.back() += x;
}
vector<long long> dp(k + 1, -1e18);
dp[0] = 0;
solve(0, n - 1, dp);
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solution();
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
long long t[100010], cnt;
long long n;
int main() {
cin >> n;
long long nex = sqrt(n);
for (long long i = 1; i <= nex; i++)
if (n % i == 0) {
t[++cnt] = (n + 2 - i) * n / (2 * i);
t[++cnt] = (n + 2 - (n / i)) * n / (2 * (n / i));
}
sort(t + 1, t + cnt + 1);
for (int i = 1; i <= cnt; i++)
if (t[i] != t[i - 1]) printf("%lld ", t[i]);
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
for (__typeof((v).begin()) i = (v).begin(); i != (v).end(); ++i) {
if (i != v.begin()) os << ", ";
os << *i;
}
os << "]";
return os;
}
int main() {
int n;
scanf("%d", &n);
vector<vector<int> > A(n, vector<int>(n));
vector<long long> SP(2 * n - 1, 0), SN(2 * n - 1, 0);
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(n); ++j) {
scanf("%d", &A[i][j]);
SP[i + j] += A[i][j];
SN[i - j + n - 1] += A[i][j];
}
long long best[2] = {-1, -1};
int res_i[2];
int res_j[2];
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(n); ++j) {
int p = (i + j) % 2;
long long x = SP[i + j] + SN[i - j + n - 1] - A[i][j];
if (best[p] < x) {
best[p] = x;
res_i[p] = i;
res_j[p] = j;
}
}
cout << best[0] + best[1] << endl;
cout << res_i[0] + 1 << " " << res_j[0] + 1 << " " << res_i[1] + 1 << " "
<< res_j[1] + 1 << endl;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, i = 2, p;
cin >> n >> m;
p = m;
while (n >= p) {
n++;
p = i * m;
i++;
}
cout << n;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e2 + 4;
const int MAXP = 5e4;
const int MAXV = MAXN + 4;
const int inf = 1e9;
bool isp[MAXP];
int a[MAXN];
int n;
int c[MAXV][MAXV];
int f[MAXV][MAXV];
int d[MAXV];
int q[MAXV];
int ptr[MAXV];
int qh, qt;
const long long flow_inf = 1e18;
struct Dinic {
struct FlowEdge {
int v, u;
long long cap, flow = 0;
FlowEdge(int _v, int _u, long long _cap) : v(_v), u(_u), cap(_cap) {}
};
vector<FlowEdge> edges;
vector<vector<int> > adj;
int n, m = 0;
int s, t;
vector<int> level, ptr;
vector<int> q;
int qh, qt;
void resize(int _n) {
n = _n;
q.resize(n);
adj.resize(n);
level.resize(n);
ptr.resize(n);
}
Dinic() {}
Dinic(int _n, int _s, int _t) {
resize(_n);
s = _s;
t = _t;
}
void add_edge(int v, int u, long long cap) {
edges.push_back(FlowEdge(v, u, cap));
edges.push_back(FlowEdge(u, v, 0));
adj[v].push_back(m);
adj[u].push_back(m + 1);
m += 2;
}
bool bfs() {
while (qh < qt) {
int v = q[qh++];
for (int id : adj[v]) {
if (edges[id].cap - edges[id].flow < 1) continue;
if (level[edges[id].u] != -1) continue;
level[edges[id].u] = level[v] + 1;
q[qt++] = edges[id].u;
}
}
return level[t] != -1;
}
long long dfs(int v, long long pushed = flow_inf) {
if (pushed == 0) return 0;
if (v == t) return pushed;
for (int& cid = ptr[v]; cid < (int)adj[v].size(); cid++) {
int id = adj[v][cid];
int u = edges[id].u;
if (level[v] + 1 != level[u] || edges[id].cap - edges[id].flow < 1)
continue;
long long tr = dfs(u, min(pushed, edges[id].cap - edges[id].flow));
if (tr == 0) continue;
edges[id].flow += tr;
edges[id ^ 1].flow -= tr;
return tr;
}
return 0;
}
long long flow() {
long long f = 0;
while (true) {
ptr.assign(n, 0);
level.assign(n, -1);
level[s] = 0;
qh = 0, qt = 1;
q[0] = s;
if (!bfs()) break;
while (long long pushed = dfs(s)) {
f += pushed;
}
}
return f;
}
};
bool used[MAXN];
int lst[MAXN];
int sz = 0;
int ancnt = 0;
void mark(int v) {
used[v] = true;
lst[sz++] = v + 1;
for (auto i = 0; i != n; i++) {
int w = (a[i] & 1) ? f[i][v] : f[v][i];
if (w > 0 && !used[i]) mark(i);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
Dinic solver(MAXV, 0, 1);
memset(c, 0, sizeof(c));
memset(f, 0, sizeof(f));
memset(isp, 0, sizeof(isp));
isp[2] = false;
for (auto i = 2; i != MAXP; i++) {
if (isp[i]) continue;
for (long long j = i * 1ll * i; j < MAXP; j += i) isp[j] = true;
}
scanf("%d", &n);
for (auto i = 0; i != n; i++) scanf("%d", &a[i]);
for (auto i = 0; i != n; i++)
for (auto j = i + 1; j != n; j++) {
if (isp[a[i] + a[j]]) continue;
if (a[i] & 1)
solver.add_edge(i + 2, j + 2, 1);
else
solver.add_edge(j + 2, i + 2, 1);
}
for (auto i = 0; i != n; i++) {
if (a[i] & 1)
solver.add_edge(0, i + 2, 2);
else
solver.add_edge(i + 2, 1, 2);
}
int flow = solver.flow();
if (flow != n) {
printf("Impossible");
return 0;
}
for (auto e : solver.edges) {
int v = e.v - 2, u = e.u - 2;
if (v < 0) v += n + 2;
if (u < 0) v += n + 2;
f[v][u] = e.flow;
}
memset(used, 0, sizeof(used));
for (auto i = 0; i != n; i++)
if (!used[i]) {
ancnt++;
sz = 0;
mark(i);
}
memset(used, 0, sizeof(used));
printf("%d", ancnt);
for (auto i = 0; i != n; i++)
if (!used[i]) {
printf("\n");
sz = 0;
mark(i);
printf("%d ", sz);
for (auto j = 0; j != sz; j++) printf("%d ", lst[j]);
}
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
long long xres[200005], a[200005], n;
vector<long long> d[200005];
bool was[2][200005];
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
if (i - a[i] >= 1) d[i - a[i]].push_back(i);
if (i + a[i] <= n) d[i + a[i]].push_back(i);
xres[i] = 101111111111111;
}
queue<pair<long long, long long> > q;
for (long long i = 1; i <= n; i++)
if (a[i] & 1) {
was[0][i] = 1;
q.push({i, 0});
}
while (!q.empty()) {
pair<long long, long long> nn = q.front();
long long v = nn.first, l = nn.second;
q.pop();
if ((~a[v]) & 1) {
xres[v] = l;
}
for (auto i : d[v])
if (!was[0][i]) {
q.push({i, l + 1});
was[0][i] = 1;
}
}
for (long long i = 1; i <= n; i++)
if ((~a[i]) & 1) {
was[1][i] = 1;
q.push({i, 0});
}
while (!q.empty()) {
pair<long long, long long> nn = q.front();
long long v = nn.first, l = nn.second;
q.pop();
if (a[v] & 1) {
xres[v] = l;
}
for (auto i : d[v])
if (!was[1][i]) {
q.push({i, l + 1});
was[1][i] = 1;
}
}
for (long long i = 1; i <= n; i++)
cout << (xres[i] == 101111111111111 ? -1 : xres[i]) << " ";
cout << '\n';
}
| 11
|
#include <cstdio>
#include <iostream>
#include <map>
using namespace std;
struct info {
int cnt = 0;
int id = 0;
};
int go(){
int n;
cin >> n;
map<int, info> mp;
for (int i = 1; i <= n; i++){
int x;
cin >> x;
mp[x].cnt++, mp[x].id = i;
}
for(auto &p : mp){
if(p.second.cnt == 1){
return p.second.id;
}
}
return -1;
}
int main() {
int T;
cin >> T;
for (int cases = 0; cases < T; cases++){
cout << go() << endl;
}
}
| 0
|
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
std::vector<int> getBorder(const std::string &str) {
int n = str.size();
std::vector<int> border(n, -1);
for (int i = 1, j = -1; i < n; i++) {
while (j >= 0 && str[i] != str[j + 1]) {
j = border[j];
}
if (str[i] == str[j + 1]) {
j++;
}
border[i] = j;
}
return border;
}
int matchPattern(std::string txt, const std::string &pat,
const std::vector<int> &border) {
int freq = 0;
for (int i = 0, j = -1; i < (int)txt.size(); i++) {
while (j >= 0 && txt[i] != pat[j + 1]) {
j = border[j];
}
if (pat[j + 1] == txt[i]) {
j++;
}
if (j + 1 == (int)pat.size()) {
freq++;
j = border[j];
}
}
return freq;
}
std::string cut(std::string s, int p, bool pref = true) {
if (!pref) {
std::reverse(s.begin(), s.end());
}
while ((int)s.size() >= p) {
s.pop_back();
}
if (!pref) {
std::reverse(s.begin(), s.end());
}
return s;
}
const int ms = 210;
std::string pref[ms], suf[ms];
long long trans[ms];
int bk = 0;
long long getFreq(int n, std::string pat, long long k) {
std::vector<long long> f(n + 1, 0);
if (pat == "0") {
f[0]++;
}
if (pat == "1") {
f[1]++;
}
auto border = getBorder(pat);
for (int i = 2; i <= n; i++) {
long long cur = trans[i - 2];
if (i < bk + 4) {
std::string curString = cut(suf[i - 2], (int)pat.size(), false) +
cut(pref[i - 1], (int)pat.size(), true);
cur = matchPattern(curString, pat, border);
}
f[i] = f[i - 1] + f[i - 2] + cur;
if (f[i] > k) {
return k + 1;
}
trans[i] = cur;
}
return std::min(f[n], k + 1);
}
int main() {
pref[0] = suf[0] = "0";
pref[1] = suf[1] = "1";
for (int i = 2; i < ms; i++) {
pref[i] = cut(pref[i - 2] + pref[i - 1], ms, true);
suf[i] = cut(suf[i - 2] + suf[i - 1], ms, false);
if (pref[i] == pref[i - 2] && suf[i] == suf[i - 1] && bk == 0) {
bk = i;
}
}
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n, m;
long long k;
std::cin >> n >> k >> m;
if (n == 0) {
std::cout << "0\n";
return 0;
} else if (n == 1) {
std::cout << "1\n";
return 0;
}
std::string ans;
k--;
while (k >= 0 && (int)ans.size() < m) {
if (ans.size() > 0 &&
suf[n].substr(suf[n].size() - ans.size(), ans.size()) == ans) {
k--;
}
if (k < 0) {
break;
}
ans += '0';
long long got = getFreq(n, ans, k);
if (got <= k) {
ans.back() = '1';
k -= got;
}
}
std::cout << ans << std::endl;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m;
cin >> n >> m;
if (n + m < 5)
cout << 0 << endl;
else if (n == 1 || m == 1) {
long long val = n == 1 ? m : n;
long long md = val % 6;
val = 6 * (val / 6);
if (md == 4) val += 2;
if (md == 5) val += 4;
cout << val << endl;
} else if (m == 2 || n == 2) {
long long val = n == 2 ? m : n;
long long ans = m * n;
if (val == 3 || val == 7) ans -= 2;
cout << ans << endl;
} else {
long long ans = (m * n);
ans -= (ans % 2ll);
cout << ans << endl;
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
struct Edge {
Edge(int a, int b) {
to = a;
cap = b;
}
int to, cap;
};
class Dinic {
public:
Dinic(int n) {
edges.resize(n);
this->n = n;
}
int maxFlow(int src, int sink) {
int ans = 0;
while (bfs(src, sink)) {
int flow;
pt.assign(n, 0);
while (flow = dfs(src, sink)) ans += flow;
}
return ans;
}
void addEdge(int from, int to, int cap) {
edges[from].push_back(list.size());
list.push_back(Edge(to, cap));
edges[to].push_back(list.size());
list.push_back(Edge(from, 0));
}
std::vector<int> getEdges() {
std::vector<int> ans;
for (int i = 0; i < list.size(); i += 2) {
if (list[i].cap == 0) ans.push_back(i / 2);
}
return ans;
}
private:
int n;
std::vector<std::vector<int> > edges;
std::vector<Edge> list;
std::vector<int> h, pt;
int dfs(int on, int sink, int flow = 1e9) {
if (flow == 0) return 0;
if (on == sink) return flow;
for (; pt[on] < edges[on].size(); pt[on]++) {
int cur = edges[on][pt[on]];
if (h[on] + 1 != h[list[cur].to]) continue;
int got = dfs(list[cur].to, sink, std::min(flow, list[cur].cap));
if (got) {
list[cur].cap -= got;
list[cur ^ 1].cap += got;
return got;
}
}
return 0;
}
bool bfs(int src, int sink) {
h.assign(n, n + 10);
h[src] = 0;
std::queue<int> q;
q.push(src);
while (!q.empty()) {
int on = q.front();
q.pop();
for (auto a : edges[on]) {
if (list[a].cap == 0) continue;
int to = list[a].to;
if (h[to] > h[on] + 1) {
h[to] = h[on] + 1;
q.push(to);
}
}
}
return h[sink] <= n;
}
};
bool can(int n, int m, Dinic graph, int x) {
for (int i = 0; i < n; i++) graph.addEdge(i, n + m + 1, x);
return graph.maxFlow(n + m, n + m + 1) == m;
}
int main() {
int n, m;
std::cin >> n >> m;
int src = n + m;
int sink = src + 1;
Dinic graph(n + m + 2);
std::vector<std::pair<int, int> > hmm;
for (int i = 0; i < m; i++) {
int u, v;
std::cin >> u >> v;
hmm.emplace_back(u, v);
u--;
v--;
graph.addEdge(src, n + i, 1);
graph.addEdge(n + i, u, 1);
graph.addEdge(n + i, v, 1);
}
int l = 0, r = m;
while (l != r) {
int mid = (l + r) / 2;
if (can(n, m, graph, mid))
r = mid;
else
l = mid + 1;
}
for (int i = 0; i < n; i++) graph.addEdge(i, sink, l);
graph.maxFlow(src, sink);
std::vector<int> edges = graph.getEdges();
std::cout << l << '\n';
for (auto a : edges) {
if (a < 3 * m) {
if (a % 3 == 1)
std::cout << hmm[a / 3].first << ' ' << hmm[a / 3].second << '\n';
else if (a % 3 == 2)
std::cout << hmm[a / 3].second << ' ' << hmm[a / 3].first << '\n';
}
}
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
string s;
struct node {
bool winner, loser;
node* ch[26];
void add(int ind) {
if (ind == s.size()) return;
if (ch[s[ind] - 'a'] == NULL) ch[s[ind] - 'a'] = new node;
ch[s[ind] - 'a']->add(ind + 1);
}
void solve() {
bool C = false, N = false;
for (int i = 0; i < 26; i++)
if (ch[i] != NULL) {
N = true;
ch[i]->solve();
if (!(ch[i]->winner)) winner = true;
if (!(ch[i]->loser)) C = true;
}
if (!C and N) loser = false;
}
node() {
winner = false;
loser = true;
for (int i = 0; i < 26; i++) ch[i] = NULL;
}
};
int n, k;
node root;
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> s;
root.add(0);
}
root.solve();
bool Winner = root.winner;
bool Loser = root.loser;
if (Winner and Loser)
cout << "First" << endl;
else if (!Winner)
cout << "Second" << endl;
else if (k & 1)
cout << "First" << endl;
else
cout << "Second" << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
template <class free>
inline void Min(free&, free);
template <class free>
inline void Max(free&, free);
struct inter {
int l, r, id, id1;
inline void operator^=(const inter x) { Max(l, x.l), Min(r, x.r); }
inline inter operator^(const inter x) { return {max(l, x.l), min(r, x.r)}; }
inline bool operator<(const inter& x) const { return l < x.l; }
} I[200050], I1[200050][2], I2[200050];
struct point {
int next, to;
} ar[200050];
multiset<int> S;
bool ans[200050], is[200050];
int head[200050], art, a[200050], at, b1, b2, b3, b4, I2t, t, T, n, m;
inline bool dfs(int, int);
inline void read(int&), link(int, int), deal(inter, inter), deal1(inter, inter),
deal2(inter, inter), deal3(int, int);
int main() {
read(t), read(T), read(n), read(m);
for (int i(1); i <= n; ++i)
read(I[i].l), read(I[i].r), I1[i][0] = {0, 0x3f3f3f3f, i, 0},
I1[i][1] = {0, 0x3f3f3f3f, i, 1};
for (int i(1), u, v; i <= m; ++i) read(u), read(v), link(u, v);
memset(a, -1, sizeof(a));
for (int i(1); i <= n; ++i)
if (!~a[i] && dfs((++at, i), 0)) return puts("IMPOSSIBLE"), 0;
for (int i(1), j; i <= at; ++i)
for (j = 0; j < 2; ++j) {
if (!b1 || I1[i][j].l > I1[b1][b2].l) b1 = i, b2 = j;
if (!b3 || I1[i][j].r < I1[b3][b4].r) b3 = i, b4 = j;
}
if (b1 ^ b3) {
ans[b1] = b2, ans[b3] = b4;
deal(I1[b1][b2] ^ I1[b3][b4], I1[b1][b2 ^ 1] ^ I1[b3][b4 ^ 1]);
ans[b3] ^= 1;
deal2(I1[b1][b2] ^ I1[b3][b4 ^ 1], I1[b1][b2 ^ 1] ^ I1[b3][b4]);
} else {
if (b2 ^ b4)
ans[b1] = b2, deal2(I1[b1][b2], I1[b3][b4]);
else
ans[b1] = b2, deal(I1[b1][b2], I1[b1][b2 ^ 1]);
}
return puts("IMPOSSIBLE"), 0;
}
inline void deal3(int x, int y) {
printf("POSSIBLE\n%d %d\n", x, y);
for (int i(1); i <= n; ++i) putchar(ans[I[i].id] ^ a[i] ? 50 : 49);
exit(0);
}
inline void deal2(inter a, inter b) {
I2t = 0, S.clear(), memset(is, 0, sizeof(is)), S.insert({0x3f3f3f3f});
for (int i(1), j; i <= at; ++i)
if (i ^ b1 && i ^ b3) {
for (j = 0; j < 2; ++j) I2[++I2t] = I1[i][j];
if (I1[i][0].r > I1[i][1].r)
ans[i] = 0, S.insert(I1[i][0].r);
else
ans[i] = 1, S.insert({I1[i][1].r});
}
if (!I2t) deal1(a, b);
sort(I2 + 1, I2 + I2t + 1);
for (int i(I2t), j, k; i; i = j) {
for (j = i; j && I2[j].l == I2[i].l; --j)
;
bool pd(false);
for (k = i; k > j; --k)
if (is[I2[k].id])
pd = 1, deal1(a, b);
else {
inter b1(I1[I2[k].id][I2[k].id1 ^ 1]);
bool temp(ans[b1.id]);
pd |= I2[k].l == b1.l;
S.erase(S.find(max(I2[k].r, b1.r))), ans[b1.id] = b1.id1;
deal1(a ^ (inter){0, *S.begin()} ^ b1, b ^ I2[k]);
S.insert(max(I2[k].r, b1.r)), ans[b1.id] = temp;
}
if (pd) return;
for (k = i; k > j; --k)
if (!is[I2[k].id]) {
inter b1(I1[I2[k].id][I2[k].id1 ^ 1]);
S.erase(S.find(max(I2[k].r, b1.r)));
ans[b1.id] = I2[k].id1, a ^= I2[k], b ^= b1;
is[b1.id] = 1;
}
}
}
inline void deal1(inter a, inter b) {
if (a.l > a.r || b.l > b.r) return;
if (t - a.l <= b.l && b.l <= T - a.l) deal3(a.l, b.l);
if (t - a.l <= b.r && b.r <= T - a.l) deal3(a.l, b.r);
if (t - a.r <= b.l && b.l <= T - a.r) deal3(a.r, b.l);
if (t - a.r <= b.r && b.r <= T - a.r) deal3(a.r, b.r);
int x(a.l), y(t - x);
if (b.l <= y && y <= b.r) deal3(x, y);
x = a.r, y = t - x;
if (b.l <= y && y <= b.r) deal3(x, y);
y = b.l, x = t - y;
if (a.l <= x && x <= a.r) deal3(x, y);
y = b.r, x = t - y;
if (a.l <= x && x <= a.r) deal3(x, y);
}
inline void deal(inter a, inter b) {
I2t = 0, S.clear(), memset(is, 0, sizeof(is)), S.insert(0x3f3f3f3f);
for (int i(1), j; i <= at; ++i)
if (i ^ b1 && i ^ b3) {
for (j = 0; j < 2; ++j) I2[++I2t] = I1[i][j];
if (I1[i][0].r > I1[i][1].r)
S.insert(I1[i][0].r), ans[i] = 1;
else
S.insert(I1[i][1].r), ans[i] = 0;
}
if (!I2t) deal1(a, b);
sort(I2 + 1, I2 + I2t + 1);
for (int i(I2t), j, k; i; i = j) {
for (j = i; j && I2[j].l == I2[i].l; --j)
;
bool pd(false);
for (k = i; k > j; --k)
if (is[I2[k].id])
pd = 1, deal1(a, b ^ (inter){0, *S.begin()});
else {
bool temp(ans[I2[k].id]);
inter& b1(I1[I2[k].id][I2[k].id1 ^ 1]);
pd |= b1.r == I2[k].r;
ans[I2[k].id] = b1.id1, S.erase(S.find(max(I2[k].r, b1.r)));
deal1(a, b ^ (inter){0, *S.begin()} ^ I2[k]);
ans[I2[k].id] = temp, S.insert(max(I2[k].r, b1.r));
}
if (pd) return;
for (k = i; k > j; --k)
if (!is[I2[k].id]) {
inter& b1(I1[I2[k].id][I2[k].id1 ^ 1]);
b ^= b1;
is[I2[k].id] = 1, S.erase(S.find(max(I2[k].r, b1.r)));
}
}
}
template <class free>
inline void Min(free& x, free y) {
x = x < y ? x : y;
}
template <class free>
inline void Max(free& x, free y) {
x = x > y ? x : y;
}
inline bool dfs(int x, int c) {
I1[I[x].id = at][a[x] = c] ^= I[x];
for (int i(head[x]), i1; i; i = ar[i].next)
if (!~a[i1 = ar[i].to] && dfs(i1, c ^ 1))
return true;
else if (a[i1] == c)
return true;
return false;
}
inline void link(int u, int v) {
ar[++art] = {head[u], v}, head[u] = art;
ar[++art] = {head[v], u}, head[v] = art;
}
inline void read(int& x) {
x ^= x;
register char c;
while (c = getchar(), c < '0' || c > '9')
;
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
}
| 24
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1.0);
template <typename T>
inline T sq(T a) {
return a * a;
}
template <typename T1, typename T2>
inline pair<T1, T2> mp(T1 a, T2 b) {
return make_pair(a, b);
}
template <typename T1, typename T2>
inline T1 safeMod(T1 a, T2 m) {
return (a % m + m) % m;
}
template <typename T1, typename T2>
inline bool isEq(T1 a, T2 b) {
return abs(a - b) < EPS;
}
template <typename T1, typename T2, typename T3>
inline bool isEq(T1 a, T2 b, T3 eps) {
return abs(a - b) < eps;
}
template <typename T>
inline bool isKthBitOn(T n, int k) {
assert(n <= numeric_limits<T>::max());
assert(k <= numeric_limits<T>::digits);
T ONE = 1;
return bool((n & (ONE << k)));
}
template <typename T>
inline void setKthBit(T& n, int k) {
assert(n <= numeric_limits<T>::max());
assert(k <= numeric_limits<T>::digits);
T ONE = 1;
n = (n | (ONE << k));
}
const int oo = 0x3f3f3f3f;
const int MAX = 200010;
const int MOD = 1000000007;
const int precision = 10;
void solve(int kas) {
int n;
cin >> n;
vector<string> grid(n);
for (int i = 0; i < n; i++) {
cin >> grid[i];
}
vector<pair<int, int> > ans;
if (grid[0][1] == grid[1][0]) {
char other = (grid[0][1] == '1') ? '0' : '1';
if (other != grid[n - 1][n - 2]) ans.push_back({n - 1, n - 2});
if (other != grid[n - 2][n - 1]) ans.push_back({n - 2, n - 1});
} else {
if (grid[n - 1][n - 2] == grid[n - 2][n - 1]) {
char other = (grid[n - 1][n - 2] == '1') ? '0' : '1';
if (other != grid[0][1]) ans.push_back({0, 1});
if (other != grid[1][0]) ans.push_back({1, 0});
} else {
grid[0][1] = grid[1][0];
ans.push_back({0, 1});
char other = (grid[0][1] == '1') ? '0' : '1';
if (other != grid[n - 1][n - 2]) ans.push_back({n - 1, n - 2});
if (other != grid[n - 2][n - 1]) ans.push_back({n - 2, n - 1});
}
}
cout << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++)
cout << ans[i].first + 1 << " " << ans[i].second + 1 << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int tc = 1;
cin >> tc;
for (int _ = 1; _ <= tc; _++) {
solve(_);
}
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n;
int a[maxn];
int main() {
int sum = 0, u;
int ans = 0x3f3f3f3f;
cin >> n;
cin >> a[1];
sum = a[1];
for (int i = 2; i <= n; i++) {
cin >> a[i];
sum += a[i];
a[i] += a[i - 1];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
ans = min(ans, abs(sum - 2 * (a[i] - a[j - 1])));
}
}
ans = min(ans, sum);
cout << ans << endl;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "{" << p.first << "," << p.second << "}";
return os;
}
const int N = 3e5 + 5;
const int oo = 1e9 + 7;
int to[N][26];
vector<int> a[N];
const int ROOT = 0;
int sz = 1;
void add(string s, int x) {
int now = ROOT;
for (char c : s) {
c -= 'a';
if (to[now][c] == -1) to[now][c] = sz++;
now = to[now][c];
}
a[now].push_back(x);
}
void dfs(int now) {
for (int i = 0; i < 26; i++) {
if (to[now][i] != -1) dfs(to[now][i]);
}
sort(a[now].begin(), a[now].end());
reverse(a[now].begin(), a[now].end());
}
int getnode(string s) {
int now = ROOT;
for (char c : s) {
c -= 'a';
if (to[now][c] == -1) return ROOT;
now = to[now][c];
}
return now;
}
long long cnt(int x, int y) {
long long ret = 0, now = 0, ii = min(a[x].size(), a[y].size());
for (int i = 0; i < ii; i++) {
now += a[x][i] + a[y][i];
ret = max(ret, now);
}
return ret;
}
pair<long long, long long> comb(pair<long long, long long> a,
pair<long long, long long> b) {
return {a.first + b.first, max(a.second + b.first, a.first + b.second)};
}
pair<long long, long long> dfs2(int now, string &s) {
pair<long long, long long> ret = {0, 0};
for (int i = 0; i < 26; i++) {
if (to[now][i] != -1) {
s += ((char)('a' + i));
ret = comb(dfs2(to[now][i], s), ret);
s.pop_back();
}
}
if (!a[now].empty()) {
reverse(s.begin(), s.end());
int re = getnode(s);
reverse(s.begin(), s.end());
pair<long long, long long> x = {0, 0};
if (re == now) {
long long sum = 0;
for (int i = 0; i < a[now].size(); i++) {
sum += a[now][i];
if (i % 2) {
x.first = max(x.first, sum);
} else {
x.second = max(x.second, sum);
}
}
x.first *= 2;
x.second *= 2;
ret = comb(ret, x);
} else if (!a[re].empty()) {
x.first += cnt(now, re);
ret = comb(ret, x);
}
}
return ret;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
memset(to, -1, sizeof to);
int n, k;
cin >> n >> k;
while (n--) {
string s;
int x;
cin >> s >> x;
add(s, x);
}
dfs(ROOT);
string s = "";
pair<long long, long long> ans = dfs2(ROOT, s);
cout << max(ans.first, ans.second) / 2 << "\n";
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn];
int b, k;
int main() {
scanf("%d%d", &b, &k);
int o = 0;
for (int i_ = 0; i_ < k; i_++) {
scanf("%d", &a[i_]);
if (a[i_] & 1) o++;
}
if (b & 1) {
if (o & 1)
printf("odd\n");
else
printf("even\n");
} else {
if (a[k - 1] & 1)
printf("odd\n");
else
printf("even\n");
}
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
void solve() {
int n;
cin >> n;
vector<pair<long long, vector<long long>>> emp;
long long total_max = 0;
for (int i = 0; i < n; i++) {
int m;
cin >> m;
vector<long long> s(m);
long long cur_max = 0;
for (int j = 0; j < m; j++) {
cin >> s[j];
cur_max = max(cur_max, s[j]);
}
total_max = max(cur_max, total_max);
emp.push_back({cur_max, s});
}
long long sum = 0;
for (int i = 0; i < n; i++) {
sum += (total_max - emp[i].first) * emp[i].second.size();
}
cout << sum << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int N = int(3e4);
int n, x, y;
string second[N];
bool a[33][33], u[33];
char b[33];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> second[i];
}
bool ok;
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++) {
int m = min(second[i].size(), second[j].size());
ok = 1;
for (int t = 0; t < m; t++) {
if (second[i][t] != second[j][t]) {
x = second[i][t] - 'a';
y = second[j][t] - 'a';
a[x][y] = 1;
if (a[y][x] == 1) {
puts("Impossible");
return 0;
}
ok = 0;
break;
}
}
if (ok) {
if (second[i].size() > second[j].size()) {
puts("Impossible");
return 0;
}
}
}
}
int bn = 0;
for (int t = 0; t < 100; t++) {
for (int i = 0; i < 26; i++)
if (!u[i]) {
ok = 1;
for (int j = 0; j < 26; j++)
if (!u[j]) {
if (a[j][i]) ok = 0;
}
if (ok) {
b[bn++] = char(i + 'a');
u[i] = 1;
}
}
}
if (bn < 26) {
cout << "Impossible";
return 0;
}
for (int i = 0; i < 26; i++) {
cout << b[i];
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
cout << n + m - 1 - min(n, m) << " " << min(n, m);
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 101;
int l, MOD = 1000000007ll;
struct Mat {
long long v[SIZE][SIZE];
Mat() { memset(v, 0, sizeof(v)); }
void init(long long _v) {
for (int i = (0); i <= (SIZE); i++) v[i][i] = _v;
}
};
Mat operator*(Mat a, Mat b) {
Mat c;
for (int i = (0); i <= (SIZE - 1); i++) {
for (int j = (0); j <= (SIZE - 1); j++) {
c.v[i][j] = 0;
for (int k = (0); k <= (SIZE - 1); k++) {
c.v[i][j] += (a.v[i][k] * b.v[k][j]) % MOD;
c.v[i][j] %= MOD;
}
}
}
return c;
}
Mat operator^(Mat a, long long k) {
Mat c;
c.init(1);
while (k) {
if (k & 1) c = a * c;
a = a * a;
k >>= 1;
}
return c;
}
int main() {
int n, k, b1, x;
int digit[10];
scanf("%d%d%d%d", &n, &b1, &k, &x);
memset(digit, 0, sizeof(digit));
Mat a, b, c;
int temp;
for (int i = 0; i < n; i++) {
scanf("%d", &temp);
digit[temp]++;
a.v[temp % x][0]++;
}
int i, j;
for (i = 0; i < x; i++) {
for (j = 1; j <= 9; j++) {
b.v[(i * 10 + j) % x][i] += digit[j];
}
}
c = b ^ (b1 - 1);
c = c * a;
printf("%I64d\n", c.v[k][0] % MOD);
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int t[15], x;
char s[15];
int main() {
scanf("%s", s);
int n = strlen(s);
for (int i = 0; i < n; i++) {
if (s[i] == '4') {
t[i] = 1;
} else {
t[i] = 2;
}
}
for (int i = n - 1; i >= 0; i--) {
x = x + (1 << (n - i - 1)) * t[i];
}
printf("%d", x);
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
long long l, r, mid, ans;
int n, c, a[220000], b[220000], i;
long long check(long long mid) {
long long res = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] != 0 && mid / b[i] > c / a[i]) return 1e10;
res += mid * a[i] / b[i];
}
return res;
}
int main() {
scanf("%d%d", &n, &c);
c -= n;
for (i = 1; i <= n; ++i) scanf("%d%d", &a[i], &b[i]);
l = 1;
r = 1e18;
while (l <= r) {
mid = l + r >> 1;
if (check(mid) >= c)
r = mid - 1;
else
l = mid + 1;
}
ans = -(r + 1);
l = 1;
r = 1e18;
while (l <= r) {
mid = l + r >> 1;
if (check(mid) <= c)
l = mid + 1;
else
r = mid - 1;
}
ans += (l - 1);
printf("%I64d\n", ans >= (long long)1e18 - 1 ? -1 : ans + 1);
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
long long int n, a;
char c;
cin >> n >> a;
vector<char> v(n);
for (long long int i = (0); i < (long long int)(n); ++i) {
cin >> v[i];
}
bool changed = false;
for (long long int i = (0); i < (long long int)(n - a); ++i) {
if (v[i] == v[i + a] && v[i] != '.' && v[i + a] != '.') {
continue;
}
changed = true;
if (v[i] == '.' && v[i + a] == '.') {
v[i] = '0';
v[i + a] = '1';
break;
}
if (v[i] == '.') {
v[i] = v[i + a] == '0' ? '1' : '0';
break;
}
if (v[i + a] == '.') {
v[i + a] = v[i] == '0' ? '1' : '0';
break;
}
}
for (int i = 0; i < n; ++i) {
if (v[i] == '.') v[i] = '0';
}
if (!changed) {
cout << "No" << endl;
return 0;
}
for (long long int i = (0); i < (long long int)(n); ++i) {
cout << v[i];
}
cout << endl;
return 0;
}
| 4
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
int main() {
string s;
cin >> s;
int c1, c2, c3;
c1 = c2 = c3 = 0;
n = ((int)(s).size());
for (int i = 0; i < (n); i++) {
if (s[i] == '?') c3++;
if (s[i] == '0') c1++;
if (s[i] == '1') c2++;
}
int h1 = (n + 1) / 2 - 1;
int h2 = n / 2 - 1;
vector<string> v;
if (h1 >= c2) v.push_back("00");
if (h2 >= c1) v.push_back("11");
if (h1 < c2 + c3 && h2 < c1 + c3) {
if (s[n - 1] == '1' || s[n - 1] == '?' && h2 < c1 + c3 - 1)
v.push_back("01");
if (s[n - 1] == '0' || s[n - 1] == '?' && h1 < c2 + c3 - 1)
v.push_back("10");
}
sort((v).begin(), (v).end());
for (int i = 0; i < (((int)(v).size())); i++) cout << v[i] << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
long long ans[100009] = {0};
bool set_col[100009];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long arr[3];
long long setp = -1;
for (long long j = 0; j < 3; j++) {
cin >> arr[j];
if (set_col[arr[j]] == true) setp = j;
}
if (setp == -1) ans[arr[0]] = 0, setp = 0, set_col[arr[0]] = true;
for (long long i1 = 0; i1 < 2; i1++) {
ans[arr[(setp + i1 + 1) % 3]] = (ans[arr[(setp + i1) % 3]] + 1) % 3;
set_col[arr[(setp + i1 + 1) % 3]] = true;
}
}
for (long long i = 0; i < n; i++) {
cout << ans[i + 1] + 1 << " ";
}
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
const int N = 4111;
int eqk[N][N];
int ck[N][N];
int NumContr(int n) {
eqk[1][1] = 1;
for (int i = 2; i <= n; ++i) {
eqk[i][1] = 1;
eqk[i][i] = 1;
for (int k = 2; k < i; ++k) {
eqk[i][k] = (eqk[i - 1][k - 1] + k * (long long)eqk[i - 1][k]) % M;
}
}
ck[1][0] = 1;
for (int i = 2; i <= n; ++i) {
ck[i][0] = 1;
ck[i][i - 1] = i;
for (int k = 1; k < i - 1; ++k) {
ck[i][k] = ((long long)eqk[i - 1][k] + (long long)ck[i - 1][k] +
ck[i - 1][k - 1] + k * (long long)ck[i - 1][k]) %
M;
}
}
long long ans = 0;
for (int k = 0; k <= n - 1; ++k) {
ans += ck[n][k];
}
ans %= M;
return ans;
}
int main() {
int n;
cin >> n;
cout << NumContr(n) << endl;
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int n, g[100100][5], d[100100], v[100100];
bool in[100100];
bool dfs(int a, int b, int k = 1) {
v[k - 1] = a, v[k] = b;
if (k < n) {
in[b] = 1;
for (int i = 0; i < 4; ++i) {
int c = g[b][i];
if (in[c]) continue;
if ((g[a][0] == c || g[a][1] == c || g[a][2] == c || g[a][3] == c) &&
dfs(b, c, k + 1))
return 1;
}
in[b] = 0;
return 0;
} else
return 1 == b;
}
int main() {
scanf("%d", &n);
for (int i = 1, a, b; i <= 2 * n; ++i) {
scanf("%d%d", &a, &b);
g[a][d[a]++] = b, g[b][d[b]++] = a;
if (d[a] > 4 || d[b] > 4) return 0 * puts("-1");
}
for (int i = 0; i < 4; ++i) {
if (dfs(1, g[1][i])) {
for (int j = 0; j < n; ++j) printf("%d ", v[j]);
return 0;
}
}
return 0 * puts("-1");
}
| 12
|
#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 = 3.1415926535897932384626433832795;
const string task = "";
template <class T>
T sqr(T x) {
return x * x;
}
const int nmax = 300300;
int n;
long double l, v1, v2;
long double res[nmax], a[nmax];
int main() {
cin >> n >> l >> v1 >> v2;
for (int i = 0; i < (int)(n); i++) {
int x;
scanf("%d", &x);
a[i] = x;
a[n + i] = x + 2. * l;
}
a[2 * n] = 1e10;
long double len = 1.0 * v2 * l / (v1 + v2);
vector<long double> st;
for (int i = 0; i < (int)(n * 2); i++) {
st.push_back(a[i]);
st.push_back(a[i] + len);
st.push_back(a[i] - len);
}
st.push_back(0);
st.push_back(len);
st.push_back(2 * l - len);
for (int i = 0; i < (int)(st.size()); i++) {
while (st[i] < 0) st[i] += 2 * l;
while (st[i] >= 2 * l) st[i] -= 2 * l;
}
sort(st.begin(), st.end());
int m = 1;
for (int i = 1; i < st.size(); i++)
if (st[i] - st[m - 1] > 1e-10) {
st[m] = st[i];
m++;
}
st.resize(m);
st.push_back(2. * l);
int p1, p2;
p1 = 0;
p2 = -1;
for (int i = 0; i < (int)(st.size() - 1); i++) {
long double mid = (st[i] + st[i + 1]) / 2.;
while (a[p1] < mid) p1++;
p2 = max(p2, p1 - 1);
while (a[p2 + 1] - mid < len) p2++;
res[p2 - p1 + 1] += st[i + 1] - st[i];
}
for (int i = 0; i < (int)(n + 1); i++)
printf("%0.15lf\n", (double)(res[i] / (2. * l)));
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
bool vis[1000005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int a[n];
long long int i;
for (i = 0; i <= n - 1; i++) {
cin >> a[i];
a[i] -= 1;
}
long long int count1 = 0;
for (i = 0; i <= n - 1; i++) {
if (vis[i] == false) {
count1 += 1;
long long int x = i;
while (vis[x] == false) {
vis[x] = true;
x = a[x];
}
}
}
long long int x = n - count1;
if (x % 2 == (3 * n) % 2) {
cout << "Petr";
} else {
cout << "Um_nik";
}
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void _DBG(const char *s, _T x) {
cerr << s << " = " << x << "\n";
}
template <typename _T, typename... args>
void _DBG(const char *s, _T x, args... a) {
while (*s != ',') cerr << *s++;
cerr << " = " << x << ',';
_DBG(s + 1, a...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int nr, ng, nb;
cin >> nr >> ng >> nb;
vector<long long> red(nr);
vector<long long> green(ng);
vector<long long> blue(nb);
for (auto &w : red) {
cin >> w;
}
for (auto &w : green) {
cin >> w;
}
for (auto &w : blue) {
cin >> w;
}
sort((red).begin(), (red).end());
sort((green).begin(), (green).end());
sort((blue).begin(), (blue).end());
vector<long long> all_vals((red).begin(), (red).end());
all_vals.insert(all_vals.end(), (green).begin(), (green).end());
all_vals.insert(all_vals.end(), (blue).begin(), (blue).end());
sort((all_vals).begin(), (all_vals).end());
long long res = LLONG_MAX - 1;
for (auto v : all_vals) {
auto it_r = upper_bound((red).begin(), (red).end(), v);
auto it_g = upper_bound((green).begin(), (green).end(), v);
auto it_b = upper_bound((blue).begin(), (blue).end(), v);
long long r = 2e18;
long long g = 2e18;
long long b = 2e18;
if (it_r != red.end() && abs(v - r) > abs(*it_r - v)) {
r = *it_r;
}
it_r--;
if (it_r >= red.begin() && abs(v - r) > abs(*it_r - v)) {
r = *it_r;
}
if (it_b != blue.end() && abs(v - b) > abs(*it_b - v)) {
b = *it_b;
}
it_b--;
if (it_b >= blue.begin() && abs(v - b) > abs(*it_b - v)) {
b = *it_b;
}
if (it_g != green.end() && abs(v - g) > abs(*it_g - v)) {
g = *it_g;
}
it_g--;
if (it_g >= green.begin() && abs(v - g) > abs(*it_g - v)) {
g = *it_g;
}
if (r != 2e18 && b != 2e18 && g != 2e18) {
res =
min(res, (r - g) * (r - g) + (g - b) * (g - b) + (b - r) * (b - r));
}
}
cout << res << "\n";
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops", \
"omit-frame-pointer", "inline")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx,avx2,fma,tune=native")
#pragma GCC option("arch=native", "no-zero-upper")
using namespace std;
const long long mod = (1e9 + 7);
const long double eps = (1e-9);
const long long oo = (long long)(2e18 + 5);
set<int> g[(long long)(1e5 + 5)];
bool ady[(long long)(1e5 + 5) / 30 + 5][(long long)(1e5 + 5) / 30 + 5];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) g[i].clear();
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].insert(v);
g[v].insert(u);
}
if (k > 70) {
vector<int> oks;
for (int i = 0; i < n; i++)
if (g[i].size() >= k - 1) oks.push_back(i);
vector<int> pos(n);
for (int i = 0; i < oks.size(); i++) {
pos[oks[i]] = i + 1;
for (int j = 0; j < oks.size(); j++) ady[i][j] = 0;
}
vector<int> cant(n);
for (auto u : oks)
for (auto v : g[u])
if (pos[v]) {
cant[u]++;
ady[pos[u] - 1][pos[v] - 1] = 1;
ady[pos[v] - 1][pos[u] - 1] = 1;
}
queue<int> q;
vector<bool> mk(n);
for (int i = 0; i < n; i++)
if (cant[i] < k) {
mk[i] = 1;
q.push(i);
}
bool clique = 0;
vector<int> ans;
while (!q.empty()) {
int u = q.front();
q.pop();
if (cant[u] < k - 1) {
for (int i = 0; i < oks.size(); i++)
if (ady[i][pos[u] - 1]) {
ady[i][pos[u] - 1] = 0;
ady[pos[u] - 1][i] = 0;
cant[oks[i]]--;
if (cant[oks[i]] < k && !mk[oks[i]]) {
mk[oks[i]] = 1;
q.push(oks[i]);
}
}
} else {
vector<int> ads;
for (int i = 0; i < oks.size(); i++)
if (ady[i][pos[u] - 1]) ads.push_back(i);
clique = 1;
for (auto u : ads) {
for (auto v : ads)
if (u != v) clique &= ady[u][v];
if (!clique) break;
}
if (clique) {
ans = ads;
ans.push_back(pos[u] - 1);
break;
}
for (int i = 0; i < oks.size(); i++)
if (ady[i][pos[u] - 1]) {
ady[i][pos[u] - 1] = 0;
ady[pos[u] - 1][i] = 0;
cant[oks[i]]--;
if (cant[oks[i]] < k && !mk[oks[i]]) {
mk[oks[i]] = 1;
q.push(oks[i]);
}
}
}
}
if (clique) {
cout << 2 << '\n';
for (int i = 0; i < ans.size(); i++) {
ans[i] = oks[ans[i]];
cout << ans[i] + 1 << ' ';
}
cout << '\n';
continue;
}
ans.clear();
for (int i = 0; i < n; i++)
if (!mk[i]) ans.push_back(i);
if (ans.size() > k) {
cout << 1 << ' ' << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) cout << ans[i] + 1 << ' ';
cout << '\n';
continue;
} else
cout << (-1) << '\n';
} else {
queue<int> q;
vector<bool> mk(n);
for (int i = 0; i < n; i++)
if (g[i].size() < k) {
mk[i] = 1;
q.push(i);
}
bool clique = 0;
vector<int> ans;
while (!q.empty()) {
int u = q.front();
q.pop();
if (g[u].size() < k - 1) {
for (auto v : g[u]) {
g[v].erase(u);
if (g[v].size() < k && !mk[v]) {
mk[v] = 1;
q.push(v);
}
}
} else {
ans.clear();
ans.push_back(u);
for (auto v : g[u]) ans.push_back(v);
clique = 1;
for (auto u : ans)
for (auto v : ans)
if (u != v) clique &= g[u].count(v);
if (clique) break;
for (auto v : g[u]) {
g[v].erase(u);
if (g[v].size() < k && !mk[v]) {
mk[v] = 1;
q.push(v);
}
}
}
}
if (clique) {
cout << 2 << '\n';
for (int i = 0; i < ans.size(); i++) cout << ans[i] + 1 << ' ';
cout << '\n';
continue;
}
ans.clear();
for (int i = 0; i < n; i++)
if (!mk[i]) ans.push_back(i);
if (ans.size() > k) {
cout << 1 << ' ' << ans.size() << '\n';
for (int i = 0; i < ans.size(); i++) cout << ans[i] + 1 << ' ';
cout << '\n';
continue;
} else
cout << (-1) << '\n';
}
}
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
double start_moment = 0;
double get_runtime() { return 1.0 * clock() / CLOCKS_PER_SEC; }
void reset_timer() { start_moment = get_runtime(); }
double timer_time() { return get_runtime() - start_moment; }
void runtime() { cout << fixed << setprecision(5) << get_runtime() << '\n'; }
template <class T>
void read(vector<T> &a, long long n) {
T x;
a.clear();
for (long long i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
}
template <class T>
void write(vector<T> &a) {
for (T x : a) cout << x << ' ';
cout << '\n';
}
const long long INF = 1LL * 1001 * 1001 * 1001 * 1001 * 1001 * 1001;
const long long mod = 998244353;
const int N = 200005;
long long bpow(long long a, long long x) {
if (!x) return 1;
if (x & 1) return a * bpow(a, x - 1) % mod;
long long b = bpow(a, x / 2);
return b * b % mod;
}
int n, m;
vector<int> g[2][N];
long long dp[N][20];
pair<long long, long long> dist[N][2];
int main() {
ios_base::sync_with_stdio(0);
for (int i = 0; i < N; i++) {
for (int j = 0; j < 20; j++) {
dp[i][j] = INF;
}
for (int j = 0; j < 2; j++) {
dist[i][j] = {INF, INF};
}
}
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g[0][a].push_back(b);
g[1][b].push_back(a);
}
dp[1][0] = 0;
priority_queue<vector<long long> > q;
q.push({-dp[1][0], 1, 0});
while (!q.empty()) {
vector<long long> v = q.top();
q.pop();
long long len = -v[0];
int u = (int)v[1];
int step = (int)v[2];
if (step == 19 || dp[u][step] < len) {
continue;
}
for (int i = 0; i < g[step % 2][u].size(); i++) {
int to = g[step % 2][u][i];
if (dp[to][step] > dp[u][step] + 1) {
dp[to][step] = dp[u][step] + 1;
q.push({-dp[to][step], to, step});
}
}
for (int i = 0; i < g[(step + 1) % 2][u].size(); i++) {
int to = g[(step + 1) % 2][u][i];
if (dp[to][step + 1] > dp[u][step] + 1 + (1 << step)) {
dp[to][step + 1] = dp[u][step] + 1 + (1 << step);
q.push({-dp[to][step + 1], to, step + 1});
}
}
}
long long ans = INF;
for (int j = 0; j < 20; j++) {
ans = min(ans, dp[n][j]);
}
if (ans != INF) {
cout << ans << '\n';
return 0;
}
priority_queue<pair<pair<long long, long long>, pair<long long, long long> > >
qq;
dist[1][0] = {0, 0};
qq.push(make_pair(dist[1][0], make_pair(1, 0)));
while (qq.size()) {
pair<pair<long long, long long>, pair<long long, long long> > p = qq.top();
qq.pop();
int u = (int)p.second.first;
int rev = (int)p.second.second;
for (int i = 0; i < g[rev][u].size(); i++) {
int to = g[rev][u][i];
if (dist[to][rev] >
make_pair(dist[u][rev].first, dist[u][rev].second + 1)) {
dist[to][rev] = make_pair(dist[u][rev].first, dist[u][rev].second + 1);
qq.push(
make_pair(make_pair(-dist[to][rev].first, -dist[to][rev].second),
make_pair(to, rev)));
}
}
if (dist[u][rev ^ 1] >
make_pair(dist[u][rev].first + 1, dist[u][rev].second)) {
dist[u][rev ^ 1] = make_pair(dist[u][rev].first + 1, dist[u][rev].second);
qq.push(make_pair(
make_pair(-dist[u][rev ^ 1].first, -dist[u][rev ^ 1].second),
make_pair(u, rev ^ 1)));
}
}
pair<long long, long long> p = min(dist[n][0], dist[n][1]);
cout << (p.second + bpow(2, p.first) - 1 + mod) % mod << endl;
}
| 16
|
#include <bits/stdc++.h>
long long gcd(long long x, long long y) { return !y ? x : gcd(y, x % y); }
inline long long max(long long x, long long y) { return x > y ? x : y; }
inline long long min(long long x, long long y) { return x > y ? y : x; }
const int maxn = 2e5 + 5;
long long seq[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%lld", &seq[i]);
long long mx = 0;
for (int i = 1; i <= n; ++i) mx = mx > seq[i] ? mx : seq[i];
long long sum = 0;
long long per = 0;
for (int i = 1; i <= n; ++i) {
sum += seq[i];
per = gcd(per, mx - seq[i]);
}
sum = mx * n - sum;
assert(sum % per == 0);
sum /= per;
std::cout << sum << " " << per << std::endl;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
namespace Elaina {
template <class T>
inline T fab(T x) {
return x < 0 ? -x : x;
}
template <class T>
inline void getmin(T& x, const T rhs) {
x = min(x, rhs);
}
template <class T>
inline void getmax(T& x, const T rhs) {
x = max(x, rhs);
}
template <class T>
inline T readin(T x) {
x = 0;
long long f = 0;
char c;
while ((c = getchar()) < '0' || '9' < c)
if (c == '-') f = 1;
for (x = (c ^ 48); '0' <= (c = getchar()) && c <= '9';
x = (x << 1) + (x << 3) + (c ^ 48))
;
return f ? -x : x;
}
template <class T>
inline void writc(T x, char s = '\n') {
static long long fwri_sta[1005], fwri_ed = 0;
if (x < 0) putchar('-'), x = -x;
do fwri_sta[++fwri_ed] = x % 10, x /= 10;
while (x);
while (putchar(fwri_sta[fwri_ed--] ^ 48), fwri_ed)
;
putchar(s);
}
} // namespace Elaina
using namespace Elaina;
const long long maxn = 3e5;
pair<long long, long long> seg[maxn + 5];
long long n;
long long K;
vector<pair<long long, long long> > cmd[maxn + 5];
set<pair<pair<long long, long long>, long long> > s;
inline void add(pair<pair<long long, long long>, long long> x) {
set<pair<pair<long long, long long>, long long> >::iterator it =
s.lower_bound(make_pair(make_pair(x.first.first, 0), 0));
pair<pair<long long, long long>, long long> tmp;
if (it != s.begin()) {
--it;
if (x.first.first < it->first.second) {
tmp = *it;
s.erase(it);
s.insert(
make_pair(make_pair(tmp.first.first, x.first.first), tmp.second));
s.insert(
make_pair(make_pair(x.first.first, tmp.first.second), tmp.second));
}
}
it = s.lower_bound(make_pair(make_pair(x.first.second, 0), 0));
if (it != s.begin()) {
--it;
if (x.first.second < it->first.second) {
tmp = *it;
s.erase(it);
s.insert(
make_pair(make_pair(tmp.first.first, x.first.second), tmp.second));
s.insert(
make_pair(make_pair(x.first.second, tmp.first.second), tmp.second));
}
}
set<pair<pair<long long, long long>, long long> >::iterator
op = s.lower_bound(make_pair(make_pair(x.first.first, 0), 0)),
ed = op;
long long pre = x.first.first;
if (op != s.end() && op->first.second <= x.first.second) {
do {
long long L = ed->first.first, R = ed->first.second;
if (pre < L) cmd[x.second].push_back(make_pair(1, L - pre));
cmd[x.second].push_back(make_pair(ed->second + 1, R - L));
pre = R, ++ed;
} while (ed != s.end() && ed->first.second <= x.first.second);
if (pre < x.first.second)
cmd[x.second].push_back(make_pair(1, x.first.second - pre));
s.erase(op, ed);
} else
cmd[x.second].push_back(make_pair(1, x.first.second - x.first.first));
s.insert(x);
}
inline void input() {
n = readin(1), K = readin(1);
for (long long i = (1), i_end_ = (n); i <= i_end_; ++i) {
seg[i].first = readin(1), seg[i].second = readin(1);
add(make_pair(seg[i], i));
}
}
long long f[maxn + 5];
inline long long counter(long long x) {
for (long long i = (0), i_end_ = (n); i <= i_end_; ++i) f[i] = 0;
long long l = 0;
long long ret = 0;
for (long long i = (1), i_end_ = (n); i <= i_end_; ++i) {
for (pair<long long, long long> modi : cmd[i]) {
long long p = modi.first, delta = modi.second;
p = max(p, l);
f[p] += delta, f[i + 1] -= delta;
}
while (l + 1 <= n && f[l + 1] + f[l] >= x) {
f[l + 1] += f[l];
++l;
}
ret += l;
}
return ret;
}
inline long long getans(long long x) {
for (long long i = (0), i_end_ = (n); i <= i_end_; ++i) f[i] = 0;
long long l = 0;
long long ret = 0, cur = 0;
for (long long i = (1), i_end_ = (n); i <= i_end_; ++i) {
for (pair<long long, long long> modi : cmd[i]) {
long long p = modi.first, delta = modi.second;
if (p <= l) cur += 1ll * delta * (l - p + 1);
p = max(p, l);
f[p] += delta, f[i + 1] -= delta;
}
while (l + 1 <= n && f[l + 1] + f[l] >= x) {
f[l + 1] += f[l];
cur += f[l + 1];
++l;
}
ret += cur;
}
return ret;
}
inline long long bisearch() {
long long l = 1, r = 1e9, mid, ret, ans = -1;
while (l <= r) {
mid = (l + r) >> 1;
ret = counter(mid);
if (ret < K)
r = mid - 1;
else
ans = mid, l = mid + 1;
}
return ans;
}
signed main() {
input();
long long ret = bisearch();
writc(getans(ret + 1) - 1ll * ret * (counter(ret + 1) - K));
return 0;
}
| 27
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 5;
int n, m, k, a, ans, flag;
int f[N], l[N][N], v[N];
inline int Gf(int x) { return f[x] == x ? x : Gf(f[x]); }
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++)
for (scanf("%d", &k); k--;) {
scanf("%d", &a);
flag = 1;
l[i][a] = 1;
}
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i != j)
for (int k = 1; k <= m; k++)
if (l[i][k] & l[j][k]) {
int fa = Gf(i), fb = Gf(j);
if (fa != fb) f[fa] = fb;
}
for (int i = 1; i <= n; i++)
if (!v[Gf(i)]) ans++, v[Gf(i)] = 1;
printf("%d\n", ans - flag);
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > adj[1005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a, b;
scanf("%d %d", &a, &b);
int k = a / 1000;
adj[k].push_back(make_pair(b, i));
}
int cnt = 0;
bool cek = true;
for (int i = 0; i <= 1000; i++) {
if (adj[i].size() == 0) continue;
cnt++;
sort(adj[i].begin(), adj[i].end());
if (cnt % 2 == 0) {
for (int j = 0; j < (int)adj[i].size(); j++) {
printf(" %d", adj[i][j].second);
}
} else {
for (int j = (int)adj[i].size() - 1; j >= 0; j--) {
if (cek)
cek = false;
else
printf(" ");
printf("%d", adj[i][j].second);
}
}
}
printf("\n");
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int mx = 0;
const int maxn = 5100;
int q[maxn][maxn * 2];
int s[maxn * 2];
int f[maxn];
int g[maxn];
int ta[maxn];
int tb[maxn];
int n;
bool cmp(int a[], int b[], int t) {
ta[0] = t;
for (int i = 0; i <= mx; i++) {
if (a[i] == -1 && b[i] != -1) return false;
if (a[i] == -1) continue;
tb[a[i]] = i ^ t;
}
for (int i = 0; i < n; i++) ta[i] = g[i] ^ tb[i];
if (ta[0] != t) return false;
for (int i = 0; i < n; i++)
if (ta[tb[i]] != i) return false;
sort(tb, tb + n);
for (int i = 1; i < n; i++)
if (tb[i] == tb[i - 1]) return false;
return true;
}
int main() {
scanf("%d", &n);
memset(s, -1, sizeof(s));
memset(q, -1, sizeof(q));
for (int i = 0; i < n; i++) {
printf("? %d %d\n", 0, i);
fflush(stdout);
scanf("%d", &f[i]);
s[f[i]] = i;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
mx = max(mx, i ^ j);
q[i][i ^ j] = j;
}
}
for (int i = 0; i < n; i++) {
printf("? %d %d\n", i, i);
fflush(stdout);
scanf("%d", &g[i]);
}
int res = 0, t = -1;
for (int i = 0; i < n; i++) {
if (cmp(s, q[i], i)) {
res++;
t = i;
}
}
cmp(s, q[t], t);
printf("!\n%d\n", res);
for (int i = 0; i < n; i++) {
printf("%d", ta[i]);
if (i == n - 1)
printf("\n");
else
printf(" ");
}
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (ll i = a; i < b; i++)
#define yes cout << "YES\n";
#define no cout << "NO\n";
typedef long long int ll;
#define revfr(i, s, e) for (ll i = s - 1; i >= e; i--)
const ll mod = 1e9 + 7;
typedef vector<ll> vll;
#define all(x) x.begin(), x.end()
#define present(c, key) (find(all(c), key) != c.end())
#define tr(c, it) for (auto it : c)
#define getv(v, n) for (ll i = 0; i < n; i++) cin >> v[i];
ll power(int x, int y)
{
if (y == 0)
return 1;
else if (y % 2 == 0)
return power(x, y / 2) * power(x, y / 2);
else
return x * power(x, y / 2) * power(x, y / 2);
}
void solv()
{
ll n, a, b, zero, one;
cin >> n >> a >> b;
string s;
cin >> s;
zero = one = 0;
if(s[0]=='0')
zero++;
else one++;
rep(i,1,n)
{
if(s[i]==s[i-1]) continue;
if(s[i]=='0') zero++; else one++;
}
ll ans = 0;
if (b > 0)
ans = (a + b) * n;
else
{
ll mini=min(zero,one);
ans=(mini+1)*b + a*n;
}
cout << ans << "\n";
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--)
{
solv();
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
void solve() {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long int g = 0;
for (long long int i = 1; i < n; i++) g = gcd(g, a[i] - a[i - 1]);
long long int ans = 0;
for (long long int i = 1; i < n; i++) {
long long int d = a[i] - a[i - 1];
ans += d / g - 1;
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
int N;
int query_count = 0;
map<tuple<int, int, int>, int> memo_c;
map<tuple<int, int, int>, lint> memo_a;
int clockwise(int i, int j, int k) {
if (memo_c.find(tuple<int, int, int>(i, j, k)) != memo_c.end()) {
return memo_c[tuple<int, int, int>(i, j, k)];
}
query_count++;
int res, t = 2;
cout << t << " " << i << " " << j << " " << k << endl;
cin >> res;
memo_c[tuple<int, int, int>(i, j, k)] = res;
memo_c[tuple<int, int, int>(j, k, i)] = res;
memo_c[tuple<int, int, int>(k, i, j)] = res;
memo_c[tuple<int, int, int>(k, j, i)] = -res;
memo_c[tuple<int, int, int>(j, i, k)] = -res;
memo_c[tuple<int, int, int>(i, k, j)] = -res;
return res;
}
lint area(int i, int j, int k) {
if (memo_a.find(tuple<int, int, int>(i, j, k)) != memo_a.end()) {
return memo_a[tuple<int, int, int>(i, j, k)];
}
query_count++;
lint res, t = 1;
cout << t << " " << i << " " << j << " " << k << endl;
cin >> res;
memo_a[tuple<int, int, int>(i, j, k)] = res;
memo_a[tuple<int, int, int>(j, k, i)] = res;
memo_a[tuple<int, int, int>(k, i, j)] = res;
memo_a[tuple<int, int, int>(k, j, i)] = res;
memo_a[tuple<int, int, int>(j, i, k)] = res;
memo_a[tuple<int, int, int>(i, k, j)] = res;
return res;
}
vector<int> solve(int d1, int d2, vector<int> A) {
deque<int> res;
if (A.empty()) {
return vector<int>(1, d2);
}
int top = A.front();
vector<int> vis(N + 1, 0);
for (auto i : A) {
if (area(d1, d2, i) > area(d1, d2, top)) {
top = i;
}
}
vis[top] = 1;
res.emplace_back(top);
while (res.size() < A.size()) {
int id = -1;
for (auto i : A) {
if (vis[i]) continue;
if (id == -1) id = i;
if (area(d1, d2, i) > area(d1, d2, id)) {
id = i;
}
}
vis[id] = 1;
if (clockwise(d2, top, id) == 1) {
res.emplace_back(id);
} else {
res.emplace_front(id);
}
}
res.emplace_front(d2);
return vector<int>(res.begin(), res.end());
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N;
vector<int> L, R;
for (int i = 3; i <= N; i++) {
if (clockwise(1, 2, i) == 1) {
L.emplace_back(i);
} else {
R.emplace_back(i);
}
}
vector<int> ans, ansL, ansR;
ansL = solve(1, 2, L);
ansR = solve(2, 1, R);
for (auto i : ansR) {
ans.emplace_back(i);
}
for (auto i : ansL) {
ans.emplace_back(i);
}
cout << 0;
for (auto i : ans) {
cout << " " << i;
}
cout << "\n";
return 0;
}
| 15
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.