solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx2")
using namespace std;
const long long INF = 1e18;
signed main() {
cin.tie(0);
cout.tie(0);
long long q;
cin >> q;
while (q--) {
long long n;
cin >> n;
vector<long long> a(n);
deque<long long> smth;
long long sum = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
if (i > 0) smth.push_back(a[i]);
}
n--;
vector<long long> pref(n + 1, 0);
for (long long i = 1; i <= n; i++) {
pref[i] = pref[i - 1] + smth[i - 1];
}
long long mi = pref[0], i_best = 0, ma = -INF, j_best = 1, ans_l = 0,
ans_r = 0;
for (long long j = 1; j <= n; j++) {
if (pref[j] - mi > ma) {
ma = pref[j] - mi;
ans_l = i_best;
ans_r = j;
}
if (pref[j] < mi) {
mi = pref[j];
i_best = j;
}
}
long long res = ma;
smth.pop_back();
smth.push_front(a[0]);
pref.resize(n + 1, 0);
for (long long i = 1; i <= n; i++) {
pref[i] = pref[i - 1] + smth[i - 1];
}
mi = pref[0], i_best = 0, ma = -INF, j_best = 1, ans_l = 0, ans_r = 0;
for (long long j = 1; j <= n; j++) {
if (pref[j] - mi > ma) {
ma = pref[j] - mi;
ans_l = i_best;
ans_r = j;
}
if (pref[j] < mi) {
mi = pref[j];
i_best = j;
}
}
res = max(res, ma);
if (res >= sum) {
cout << "NO\n";
} else {
cout << "YES\n";
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = (int)1e9 + 7;
template <class T>
int bins(const vector<T>& vec, T v) {
int low = 0;
int high = vec.size();
while (low != high) {
int mid = (low + high) >> 1;
if (vec[mid] < v)
low = mid + 1;
else
high = mid;
}
return low;
}
int nxt(int x, int dir, const vector<int>& xs) {
int j = bins(xs, x + 1);
if (dir == 1) {
if (j == xs.size())
return xs.size();
else
return j;
} else {
if (j == 0)
return -1;
else
return j - 1;
}
}
vector<int> build(int n, int max_abs, int i, int t, int dir,
const vector<int>& xs, const vector<int>& ys) {
vector<int> res(2 * max_abs + 1, -INF);
res[max_abs] = 0;
int sx = xs[i];
if (dir == 1) {
int x = xs[i];
int j = nxt(x, 1, ys);
int cur = max_abs;
while (0 <= cur && cur <= 2 * max_abs) {
res[cur] = x - sx;
if (i > t && j == ys.size()) {
x = n - 1;
break;
} else {
bool move_x = 0;
if (i <= t && j < ys.size()) {
if (xs[i] < ys[j]) move_x = 1;
} else if (i <= t) {
move_x = 1;
}
if (move_x) {
--cur;
x = xs[i];
++i;
} else {
x = ys[j] - 1;
res[cur] = x - sx;
++cur;
++x;
++j;
}
}
}
if (0 <= cur && cur <= 2 * max_abs) res[cur] = x - sx;
} else {
int x = xs[i];
int j = nxt(x, -1, ys);
int cur = max_abs;
while (0 <= cur && cur <= 2 * max_abs) {
res[cur] = sx - x;
if (i < t && j == -1) {
x = 0;
break;
} else {
bool move_x = 0;
if (i >= t && j >= 0) {
if (xs[i] > ys[j]) move_x = 1;
} else if (i >= t) {
move_x = 1;
}
if (move_x) {
--cur;
x = xs[i];
--i;
} else {
x = ys[j] + 1;
res[cur] = sx - x;
++cur;
--x;
--j;
}
}
}
if (0 <= cur && cur <= 2 * max_abs) res[cur] = sx - x;
}
for (int i = 1; i <= 2 * max_abs; ++i) res[i] = max(res[i - 1], res[i]);
return res;
}
int solve(int n, int ia, int ib, const vector<int>& xs, const vector<int>& ys) {
if (ia > ib) return 0;
int cou = ib - ia + 1;
int mid = (ia + ib) >> 1;
auto le = build(n, cou, mid, ia, -1, xs, ys);
auto ri = build(n, cou, mid, ib, 1, xs, ys);
int res = 0;
for (int j = 0; j <= 2 * cou - 1; ++j) {
res = max(res, le[j] + ri[(2 * cou - 1) - j] + 1);
}
res = max(res, solve(n, ia, mid - 1, xs, ys));
res = max(res, solve(n, mid + 1, ib, xs, ys));
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> vals(n);
for (int& v : vals) cin >> v;
vector<int> comp = vals;
sort(comp.begin(), comp.end());
comp.erase(unique(comp.begin(), comp.end()), comp.end());
int m = comp.size();
vector<vector<int>> xs(m);
for (int i = 0; i < n; ++i) {
vals[i] = bins(comp, vals[i]);
xs[vals[i]].push_back(i);
}
int j = 0;
bool uniq = 1;
for (int i = 1; i < m; ++i) {
if (xs[i].size() > xs[j].size()) {
j = i;
uniq = 1;
} else if (xs[i].size() == xs[j].size()) {
uniq = 0;
}
}
if (!uniq) {
cout << n << '\n';
} else {
vector<int> ys = xs[j];
swap(xs[j], xs[m - 1]);
int res = 0;
for (int i = 0; i < m - 1; ++i)
res = max(res, solve(n, 0, (int)xs[i].size() - 1, xs[i], ys));
cout << res << '\n';
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
char getc() {
char c = getchar();
while (c != '<' && c != '>') c = getchar();
return c;
}
int gcd(int n, int m) { return m == 0 ? n : gcd(m, n % m); }
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * f;
}
int n, m, h, p[55 * 55], d[55 * 55], cur[55 * 55], q[55 * 55], id[55][55], cnt,
t = -1, ans;
struct data {
int to, nxt, cap, flow;
} edge[55 * 55 << 2];
void addedge(int x, int y, int z) {
t++;
edge[t].to = y, edge[t].nxt = p[x], edge[t].cap = z, edge[t].flow = 0,
p[x] = t;
t++;
edge[t].to = x, edge[t].nxt = p[y], edge[t].cap = 0, edge[t].flow = 0,
p[y] = t;
}
bool bfs() {
memset(d, 255, sizeof(d));
d[0] = 0;
int head = 0, tail = 1;
q[1] = 0;
do {
int x = q[++head];
for (int i = p[x]; ~i; i = edge[i].nxt)
if (d[edge[i].to] == -1 && edge[i].flow < edge[i].cap) {
d[edge[i].to] = d[x] + 1;
q[++tail] = edge[i].to;
}
} while (head < tail);
return ~d[3000];
}
int work(int k, int f) {
if (k == 3000) return f;
int used = 0;
for (int i = cur[k]; ~i; i = edge[i].nxt)
if (d[k] + 1 == d[edge[i].to]) {
int w = work(edge[i].to, min(f - used, edge[i].cap - edge[i].flow));
edge[i].flow += w, edge[i ^ 1].flow -= w;
if (edge[i].flow < edge[i].cap) cur[k] = i;
used += w;
if (used == f) return f;
}
if (used == 0) d[k] = -1;
return used;
}
void dinic() {
while (bfs()) {
memcpy(cur, p, sizeof(p));
ans += work(0, 55 * 55 * 55);
}
}
signed main() {
n = read(), h = read(), m = read();
memset(p, 255, sizeof(p));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= h; j++) id[i][j] = ++cnt;
for (int i = 1; i <= n; i++) {
addedge(0, id[i][1], h * h);
for (int j = 1; j < h; j++) addedge(id[i][j], id[i][j + 1], h * h - j * j);
}
for (int i = 1; i <= m; i++) {
int l = read(), r = read(), x = read(), c = read();
if (x < h) {
cnt++;
for (int j = l; j <= r; j++) addedge(id[j][x + 1], cnt, 55 * 55 * 55);
addedge(cnt, 3000, c);
}
}
dinic();
cout << n * h * h - ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000001;
int F[MAX], G[MAX], T[10][2 * MAX + 1];
void calculate_F() {
for (int i = 1; i < 10; i++) F[i] = i;
for (int i = 10; i < MAX; i++) {
int last_digit = i % 10;
F[i] = F[i / 10];
if (last_digit != 0) F[i] *= last_digit;
}
}
void calculate_G() {
for (int i = 1; i < 10; i++) G[i] = i;
for (int i = 10; i < MAX; i++) G[i] = G[F[i]];
}
void insert(int k, int x) {
int v = MAX + x;
T[k][v]++;
while (v != 1) {
v /= 2;
T[k][v]++;
}
}
int query(int k, int a, int b) {
int v_a = MAX + a;
int v_b = MAX + b;
int result = T[k][v_a];
if (v_a != v_b) result += T[k][v_b];
while (v_a / 2 != v_b / 2) {
if (v_a % 2 == 0) result += T[k][v_a + 1];
if (v_b % 2 == 1) result += T[k][v_b - 1];
v_a /= 2;
v_b /= 2;
}
return result;
}
void create_segment_trees() {
for (int i = 1; i < MAX; i++) insert(G[i], i);
}
int main() {
int Q;
calculate_F();
calculate_G();
create_segment_trees();
cin >> Q;
for (int i = 0; i < Q; i++) {
int l, r, k;
cin >> l >> r >> k;
cout << query(k, l, r) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int max_num_prime = 100000;
const int maxn = 1000001;
const int log_maxn = 20;
const int mod = 1000000007;
bool isprime[maxn + 1], is_fixed[maxn + 1];
int remain[maxn + 1];
int num_prime, prime[max_num_prime + 1];
int root[maxn + 1], last_prime[maxn + 1];
int P[maxn + 1];
int n, A[maxn + 1];
inline int mul(int x, int y) { return x * (long long)y % mod; }
void preprocess(int n) {
P[0] = P[1] = 1;
root[1] = 1;
num_prime = 0;
for (int i = 2; i <= n; ++i) {
isprime[i] = true;
remain[i] = 0;
P[i] = mul(P[i - 1], i);
}
int x;
for (int i = 2; i <= n; ++i) {
if (isprime[i]) {
prime[num_prime++] = i;
root[i] = i;
remain[i] = 1;
last_prime[i] = i;
}
for (int j = 0; j < num_prime && i * prime[j] <= n; ++j) {
x = i * prime[j];
isprime[x] = false;
if (i % prime[j] == 0) {
root[x] = root[i];
remain[root[x]]++;
break;
} else {
root[x] = root[i] * prime[j];
last_prime[x] = prime[j];
remain[root[x]]++;
}
}
}
}
int num_index_factor, num_actual_factor;
int solve() {
fill(is_fixed, is_fixed + n + 1, false);
if (A[1] != 0) {
if (A[1] != 1 && (!isprime[A[1]] || n / A[1] > 1)) {
return 0;
}
is_fixed[A[1]] = true;
}
int index_max_prime, actual_max_prime;
for (int i = 2; i <= n; ++i) {
if (A[i] == 0) {
continue;
}
--remain[root[A[i]]];
is_fixed[root[A[i]]] = true;
if (isprime[i]) {
if (A[i] == 1) {
is_fixed[1] = true;
if (n / i > 1) {
return 0;
}
} else if (!isprime[root[A[i]]] || (n / root[A[i]] != n / i)) {
return 0;
}
} else {
num_index_factor = 0;
for (int j = root[i]; j > 1; j /= last_prime[j]) {
num_index_factor++;
index_max_prime = last_prime[j];
}
num_actual_factor = 0;
for (int j = root[A[i]]; j > 1; j /= last_prime[j]) {
num_actual_factor++;
actual_max_prime = last_prime[j];
}
if (num_actual_factor != num_index_factor ||
n / index_max_prime != n / actual_max_prime) {
return 0;
}
if (n / actual_max_prime < actual_max_prime) {
is_fixed[actual_max_prime] = true;
if (A[index_max_prime] == 0) {
--remain[root[actual_max_prime]];
A[index_max_prime] = actual_max_prime;
} else if (root[A[index_max_prime]] != actual_max_prime) {
return 0;
}
}
}
}
int ans = 1;
int num_equiv_prime = 0;
int level = 1;
for (int i = n; i >= 2; --i) {
if (root[i] != i) {
continue;
}
ans = mul(ans, P[remain[i]]);
if (isprime[i]) {
if (n / i != level) {
ans = mul(ans, P[num_equiv_prime + (level == 1 && !is_fixed[1])]);
num_equiv_prime = 0;
level = n / i;
}
if (!is_fixed[i]) {
num_equiv_prime++;
}
}
}
if (num_equiv_prime > 0) {
ans = mul(ans, P[num_equiv_prime + (level == 1 && !is_fixed[1])]);
}
return ans;
}
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> A[i];
}
preprocess(n);
cout << solve() << endl;
}
| 11 |
#include <bits/stdc++.h>
const int INF = 0x7F7F7F7F;
const double EPS = 1e-10;
const long long mod7 = 1e9 + 7;
const long long mod9 = 1e9 + 9;
using namespace std;
inline long long rit() {
long long f = 0, key = 1;
char c;
do {
c = getchar();
if (c == '-') key = -1;
} while (c < '0' || c > '9');
do {
f = f * 10 + c - '0';
c = getchar();
} while (c >= '0' && c <= '9');
return f * key;
}
inline void fprt(double f) { printf("%.08lf", f); }
void init() {}
const int Z = 100005;
int n, m;
vector<pair<int, int> > v[Z];
int mk[Z], mk2[Z], ttt;
vector<int> sv[2], dv[2];
int dfs(int p, int key, int col) {
mk2[p] = ttt;
if (mk[p] == ttt) sv[key].push_back(p);
for (auto f : v[p]) {
if (mk2[f.first] != ttt) {
if (((mk[p] == ttt ? 1 : 0) ^ f.second) == col) {
if (dfs(f.first, key, col) == -1) return -1;
} else {
mk[f.first] = ttt;
if (dfs(f.first, key, col) == -1) return -1;
}
} else if (((mk[f.first] == ttt ? 1 : 0) ^ (mk[p] == ttt ? 1 : 0) ^
f.second) != col) {
return -1;
}
}
return 1;
}
int ask(int key) {
int kk, kk2;
memset((mk), 0, sizeof((mk)));
for (int i = 1; i <= n; i++) {
if (mk[i] == 0) {
sv[0].clear();
sv[1].clear();
ttt++;
kk = dfs(i, 0, key);
ttt++;
mk[i] = ttt;
kk2 = dfs(i, 1, key);
if (kk == -1 && kk2 != -1) {
for (auto f : sv[1]) dv[key].push_back(f);
} else if (kk2 == -1 && kk != -1) {
for (auto f : sv[0]) dv[key].push_back(f);
} else if (kk != -1 && kk2 != -1) {
if ((int)((sv[0]).size()) < (int)((sv[1]).size())) {
for (auto f : sv[0]) dv[key].push_back(f);
} else
for (auto f : sv[1]) dv[key].push_back(f);
} else
return -1;
}
}
return (int)((dv[key]).size());
}
void read() {
int a, b;
char c;
n = rit(), m = rit();
for (int i = 0; i < m; i++) {
a = rit(), b = rit();
scanf(" %c", &c);
v[a].push_back(make_pair(b, (c == 'B' ? 0 : 1)));
v[b].push_back(make_pair(a, (c == 'B' ? 0 : 1)));
}
}
void solve() {
int ans0, ans1;
ans0 = ask(0);
ans1 = ask(1);
if (ans0 != -1 && ans1 == -1) {
printf("%d\n", ans0);
for (auto f : dv[0]) printf("%d ", f);
printf("\n");
} else if (ans0 == -1 && ans1 != -1) {
printf("%d\n", ans1);
for (auto f : dv[1]) printf("%d ", f);
printf("\n");
} else if (ans0 != -1 && ans1 != -1) {
if (ans0 <= ans1) {
printf("%d\n", ans0);
for (auto f : dv[0]) printf("%d ", f);
printf("\n");
} else {
printf("%d\n", ans1);
for (auto f : dv[1]) printf("%d ", f);
printf("\n");
}
} else {
cout << -1 << endl;
}
}
int main() {
int nn = 1;
while (nn--) {
init(), read(), solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y;
vector<int> A;
vector<int> B;
vector<pair<int, int> > sol;
int main() {
int t1;
scanf("%d%d%d%d", &n, &m, &x, &y);
for (int i = 0; i < n; i++) {
scanf("%d", &t1);
A.push_back(t1);
}
for (int i = 0; i < m; i++) {
scanf("%d", &t1);
B.push_back(t1);
}
for (int i = 0, j = 0; i < n && j < m;) {
if (A[i] - x <= B[j] && B[j] <= A[i] + y) {
i++;
j++;
sol.push_back(make_pair(i, j));
} else if (A[i] - x > B[j]) {
j++;
} else {
i++;
}
}
int sz = sol.size();
printf("%d\n", sz);
for (int i = 0; i < sz; i++) {
printf("%d %d\n", sol[i].first, sol[i].second);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int const N = 505;
bool dp[2][N][N];
int a[N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < (n); ++i) scanf("%d", &a[i]);
sort(a, a + n);
int pre = 0, nxt = 1;
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (m + 1); ++j)
for (int k = 0; k < (m + 1); ++k) dp[nxt][j][k] = 0;
dp[pre][0][0] = 1;
for (int j = 0; j < (m + 1); ++j)
for (int k = 0; k < (m + 1); ++k)
if (dp[pre][j][k]) {
dp[nxt][j][k] = 1;
if (j + a[i] <= m) {
dp[nxt][j + a[i]][k] = 1;
dp[nxt][j + a[i]][k + a[i]] = 1;
}
}
swap(pre, nxt);
}
vector<int> ans;
for (int i = 0; i < (m + 1); ++i)
if (dp[pre][m][i]) ans.push_back(i);
printf("%d\n", (int)ans.size());
for (int i = 0; i < (ans.size()); ++i) printf("%d ", ans[i]);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[200010], b[200010];
void solve() {
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long ans = 11111111111;
char tes[] = {'0', 'R', 'G', 'B'};
for (long long i = 1; i <= n; i++) {
if (s[i - 1] == tes[i % 3 + 1])
a[i] = 0;
else
a[i] = 1;
b[i] = b[i - 1] + a[i];
}
for (long long i = k; i <= n; i++) {
ans = min(ans, b[i] - b[i - k]);
}
char tes2[] = {'0', 'G', 'B', 'R'};
for (long long i = 1; i <= n; i++) {
if (s[i - 1] == tes2[i % 3 + 1])
a[i] = 0;
else
a[i] = 1;
b[i] = b[i - 1] + a[i];
}
for (long long i = k; i <= n; i++) {
ans = min(ans, b[i] - b[i - k]);
}
char tes3[] = {'0', 'B', 'R', 'G'};
for (long long i = 1; i <= n; i++) {
if (s[i - 1] == tes3[i % 3 + 1])
a[i] = 0;
else
a[i] = 1;
b[i] = b[i - 1] + a[i];
}
for (long long i = k; i <= n; i++) {
ans = min(ans, b[i] - b[i - k]);
}
cout << ans << endl;
}
signed main() {
long long t;
cin >> t;
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200100;
struct WORK {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
long long a[5], b[311111], u[311111];
vector<long long> g[111111];
set<long long> s;
long long n;
int main() {
long long t;
cin >> t;
while (t--) {
cin >> n;
long long k = 1;
while (k * 4 <= n) {
k *= 4;
}
a[1] = 0;
a[2] = 2;
a[3] = 3;
a[4] = 1;
b[1] = (n - k) / 3 + k;
long long bg = k * 2;
long long ans = 0;
long long x = k / 4;
while (1) {
if (x == 0) break;
if (x == 1) {
ans += a[b[1] - k + 1];
break;
}
long long block = 1;
while (k + x <= b[1]) {
k += x;
block++;
}
ans += a[block] * x;
x /= 4;
if (x == 0) break;
}
b[2] = bg + ans;
b[3] = b[1] ^ b[2];
if (n % 3 == 0) {
cout << b[3];
} else {
cout << b[n % 3];
}
cout << "\n";
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int a[maxn];
int cnt[maxn];
int main(void) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = 2; i <= n - 1; i++) {
if (a[i] == 0 && a[i - 1] == 1 && a[i + 1] == 1) {
if (cnt[i - 1] == 1) continue;
cnt[i - 1]++;
cnt[i + 1]++;
ans++;
}
}
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e6 + 6;
const long long MOD = 1e9 + 7;
bool comparator(long long i, long long j) { return (i < j); }
struct setCompare {
bool operator()(const int64_t& lhs, const int64_t& rhs) const {}
};
long long power(long long x, long long i) {
long long ans = 1;
while (i > 0) {
if (i & 1) ans = (ans * x) % MOD;
i >>= 1;
x = (x * x) % MOD;
}
return ans;
}
long long power(long long x, long long i, long long mod) {
long long ans = 1;
while (i > 0) {
if (i & 1) ans = (ans * x) % mod;
i >>= 1;
x = (x * x) % mod;
}
return ans;
}
long long modInverse(long long x, long long mod) {
return power(x, mod - 2, mod);
}
bool isPalindrome(string s) {
long long limit = s.length() / 2;
for (long long i = 0; i < limit; i++)
if (s[i] != s[s.length() - i - 1]) return false;
return true;
}
long long gcd(long long x, long long y) {
long long t;
while (y != 0) t = x % y, x = y, y = t;
return x;
}
bool isVowel(char ch) {
if (ch == 'a' || ch == 'i' || ch == 'e' || ch == 'u' || ch == 'o' ||
ch == 'y') {
return true;
}
return false;
}
bool isPrime(long long n) {
long long root = sqrt(n);
for (long long i = 2; i <= root; i++)
if (n % i == 0) return 0;
return 1;
}
long double getDisSquare(long double asdfg, long double qwert,
long double gfdsa, long double trewq) {
return ((asdfg - gfdsa) * (asdfg - gfdsa) +
(qwert - trewq) * (qwert - trewq));
}
bool isSquareHelper(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3, long long x4,
long long y4) {
long double d1, d2, d3, d4, d5, d6;
d1 = getDisSquare(asdfg, qwert, gfdsa, trewq);
d2 = getDisSquare(gfdsa, trewq, x3, y3);
d3 = getDisSquare(x3, y3, x4, y4);
d4 = getDisSquare(x4, y4, asdfg, qwert);
if (d1 == d2 && d1 == d3 && d1 == d4) {
d5 = getDisSquare(asdfg, qwert, x3, y3);
d6 = getDisSquare(gfdsa, trewq, x4, y4);
if (d5 == d6) {
return 1;
}
}
return 0;
}
bool isSquare(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3, long long x4,
long long y4) {
if (isSquareHelper(asdfg, qwert, gfdsa, trewq, x3, y3, x4, y4) ||
isSquareHelper(asdfg, qwert, gfdsa, trewq, x4, y4, x3, y3) ||
isSquareHelper(asdfg, qwert, x3, y3, gfdsa, trewq, x4, y4))
return 1;
else
return 0;
}
bool isEqualateralTriangle(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3) {
long long d1 = getDisSquare(asdfg, qwert, gfdsa, trewq);
long long d2 = getDisSquare(gfdsa, trewq, x3, y3);
long long d3 = getDisSquare(x3, y3, asdfg, qwert);
if (d1 == d2 && d1 == d3) {
return 1;
} else
return 0;
}
bool isRightAngleTriangleHelper(long long asdfg, long long qwert,
long long gfdsa, long long trewq, long long x3,
long long y3) {
long long d1 = getDisSquare(asdfg, qwert, gfdsa, trewq);
long long d2 = getDisSquare(gfdsa, trewq, x3, y3);
long long d3 = getDisSquare(x3, y3, asdfg, qwert);
if (d2 == (d1 + d3)) {
return 1;
}
return 0;
}
bool isRightAngleTriangle(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3) {
if (isRightAngleTriangleHelper(asdfg, qwert, gfdsa, trewq, x3, y3) ||
isRightAngleTriangleHelper(gfdsa, trewq, x3, y3, asdfg, qwert) ||
isRightAngleTriangleHelper(x3, y3, asdfg, qwert, gfdsa, trewq))
return 1;
return 0;
}
bool areCollinear(long long asdfg, long long qwert, long long gfdsa,
long long trewq, long long x3, long long y3) {
return ((x3 - asdfg) * (trewq - qwert) == (y3 - qwert) * (gfdsa - asdfg));
}
long long n, m;
map<long long, long long> mp;
void getInput() {
cin >> n;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
mp[x] = y;
}
cin >> m;
for (long long i = 0; i < m; i++) {
long long x, y;
cin >> x >> y;
mp[x] = max(y, mp[x]);
}
}
void getAnswer() {}
void solve() {
long long ans = 0;
for (auto i : mp) {
ans += i.second;
}
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) getInput(), solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
int max(int a, int b) {
if (a > b) {
return a;
}
return b;
}
int min(int a, int b) {
if (a < b) {
return a;
}
return b;
}
int zt(int a, int b) { return max(a, b) - min(a, b); }
int round(int a, int b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
int ceil(int a, int b) {
if (a % b == 0) {
return a / b;
}
return (a / b) + 1;
}
int gcd(int a, int b) {
int c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
int lcm(int a, int b) {
int c = gcd(a, b);
a /= c;
return a * b;
}
int nCr(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
}
int nHr(int a, int b) { return nCr(a + b - 1, b); }
int fact(int a) {
int i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
}
int pow(int a, int b) {
int i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
}
int dsum(int x) {
int r = 0;
while (x) {
r += (x % 10);
x /= 10;
}
return r;
}
int dsumb(int x, int b) {
int r = 0;
while (x) {
r += (x % b);
x /= b;
}
return r;
}
int sankaku(int x) { return ((1 + x) * x) / 2; }
void swap(int *a, int *b) {
int c;
c = (*a);
(*a) = (*b);
(*b) = c;
}
long long llmax(long long a, long long b) {
if (a > b) {
return a;
}
return b;
}
long long llmin(long long a, long long b) {
if (a < b) {
return a;
}
return b;
}
long long llzt(long long a, long long b) { return llmax(a, b) - llmin(a, b); }
long long llround(long long a, long long b) {
if ((a % b) * 2 >= b) {
return (a / b) + 1;
}
return a / b;
}
long long llceil(long long a, long long b) {
if (a % b == 0) {
return a / b;
}
return (a / b) + 1;
}
long long llgcd(long long a, long long b) {
long long c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
long long lllcm(long long a, long long b) {
long long c = llgcd(a, b);
a /= c;
return a * b;
}
long long llnCr(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
}
long long llnHr(long long a, long long b) { return llnCr(a + b - 1, b); }
long long llfact(long long a) {
long long i, r = 1;
for (i = 1; i <= a; i++) {
r *= i;
}
return r;
}
long long llpow(long long a, long long b) {
long long i, r = 1;
for (i = 1; i <= b; i++) {
r *= a;
}
return r;
}
long long lldsum(long long x) {
long long r = 0;
while (x) {
r += (x % 10);
x /= 10;
}
return r;
}
long long lldsumb(long long x, long long b) {
long long r = 0;
while (x) {
r += (x % b);
x /= b;
}
return r;
}
long long llsankaku(long long x) { return ((1 + x) * x) / 2; }
void llswap(long long *a, long long *b) {
long long c;
c = (*a);
(*a) = (*b);
(*b) = c;
}
double dbmax(double a, double b) {
if (a > b) {
return a;
}
return b;
}
double dbmin(double a, double b) {
if (a < b) {
return a;
}
return b;
}
double dbzt(double a, double b) { return dbmax(a, b) - dbmin(a, b); }
void dbswap(double *a, double *b) {
double c;
c = (*a);
(*a) = (*b);
(*b) = c;
}
void chswap(char *a, char *b) {
char c;
c = (*a);
(*a) = (*b);
(*b) = c;
}
int sortfncsj(const void *a, const void *b) {
if (*(int *)a > *(int *)b) {
return 1;
}
if (*(int *)a == *(int *)b) {
return 0;
}
return -1;
}
int sortfnckj(const void *a, const void *b) {
if (*(int *)a < *(int *)b) {
return 1;
}
if (*(int *)a == *(int *)b) {
return 0;
}
return -1;
}
int llsortfncsj(const void *a, const void *b) {
if (*(long long *)a > *(long long *)b) {
return 1;
}
if (*(long long *)a == *(long long *)b) {
return 0;
}
return -1;
}
int llsortfnckj(const void *a, const void *b) {
if (*(long long *)a < *(long long *)b) {
return 1;
}
if (*(long long *)a == *(long long *)b) {
return 0;
}
return -1;
}
int dbsortfncsj(const void *a, const void *b) {
if (*(double *)a > *(double *)b) {
return 1;
}
if (*(double *)a == *(double *)b) {
return 0;
}
return -1;
}
int dbsortfnckj(const void *a, const void *b) {
if (*(double *)a < *(double *)b) {
return 1;
}
if (*(double *)a == *(double *)b) {
return 0;
}
return -1;
}
int strsortfncsj(const void *a, const void *b) {
return strcmp((char *)a, (char *)b);
}
int strsortfnckj(const void *a, const void *b) {
return strcmp((char *)b, (char *)a);
}
int chsortfncsj(const void *a, const void *b) {
if (*(char *)a > *(char *)b) {
return 1;
}
if (*(char *)a == *(char *)b) {
return 0;
}
return -1;
}
int chsortfnckj(const void *a, const void *b) {
if (*(char *)a < *(char *)b) {
return 1;
}
if (*(char *)a == *(char *)b) {
return 0;
}
return -1;
}
void shuffledget(int x[], int n) {
int i, b[524288], p, c;
for (i = 0; i < n; i++) {
b[i] = i;
}
for (i = n; i >= 1; i--) {
p = rand() % i;
c = b[i - 1];
b[i - 1] = b[p];
b[p] = c;
}
for (i = 0; i < n; i++) {
scanf("%d", &x[b[i]]);
}
}
int dx4[4] = {1, -1, 0, 0};
int dy4[4] = {0, 0, 1, -1};
int dx8[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
int dy8[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
int search(int x, int a[], int n) {
int st = 0, fi = n - 1, te;
while (st <= fi) {
te = (st + fi) / 2;
if (a[te] < x) {
st = te + 1;
} else {
fi = te - 1;
}
}
return st;
}
void prarr(int arr[], int n) {
int i;
for (i = 0; i < n; i++) {
if (i) {
printf(" ");
}
printf("%d", arr[i]);
}
printf("\n");
return;
}
void getperm(int a[], int n) {
int i, p;
for (i = 0; i < n; i++) {
a[i] = i;
}
for (i = n - 1; i >= 1; i--) {
p = rand() % (i + 1);
swap(&a[p], &a[i]);
}
}
typedef struct {
int val;
int node;
} sd;
int sdsortfnc(const void *a, const void *b) {
if (((sd *)a)->val < ((sd *)b)->val) {
return -1;
}
if (((sd *)a)->val > ((sd *)b)->val) {
return 1;
}
return 0;
}
void coordinate_comp(int a[], int n) {
int i, c = 0;
sd dat[524288];
for (i = 0; i < n; i++) {
dat[i].val = a[i];
dat[i].node = i;
}
qsort(dat, n, sizeof(dat[0]), sdsortfnc);
a[dat[0].node] = c;
for (i = 1; i < n; i++) {
if (dat[i - 1].val != dat[i].val) {
c++;
}
a[dat[i].node] = c;
}
}
int main(void) {
int i, j, n, m, k, a[524288], h, w, r = 0, l, t;
int g, s, b;
scanf("%d", &t);
while (t > 0) {
t--;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
a[n] = -1;
g = 0;
s = 0;
b = 0;
for (i = 0; i < n; i++) {
if (a[i] == a[i + 1]) {
continue;
}
g = i + 1;
break;
}
for (i = g; i < n; i++) {
if (a[i] == a[i + 1]) {
continue;
}
if (g >= i - (g - 1)) {
continue;
}
s = i - (g - 1);
break;
}
for (i = g + s; i < n; i++) {
if (a[i] == a[i + 1]) {
continue;
}
if (g >= i - (g + s - 1)) {
continue;
}
if (g + s + (i - (g + s - 1)) > n / 2) {
continue;
}
b = i - (g + s - 1);
}
if (b == 0) {
printf("%d %d %d\n", 0, 0, 0);
} else {
printf("%d %d %d\n", g, s, b);
}
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define lli long long int
void laaft() {
int n;
cin >> n;
vector<int> vvv(n);
for (int i = 0; i < n; i++) cin >> vvv[i];
map<int, int> m;
for (int i = 0; i < n; i++) {
m[vvv[i]]++;
}
int mx = 1;
for (auto x : m) {
if (x.second > mx) mx = x.second;
}
if (mx <= (n + 1) / 2 and n % 2 == 0) cout << 0 << endl;
else if (mx <= (n + 1) / 2 and n % 2 == 1) cout << 1 << endl;
else {
cout << n - 2 * (n - mx) << endl;
}
}
int32_t main() {
int t = 1;
cin >> t;
while (t--) laaft();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const long long MOD = 1e9 + 7;
int par[MAXN + MAXN], sz[MAXN + MAXN], kind[MAXN + MAXN];
int N;
int u_find(int node) {
return (par[node] == node) ? node : par[node] = u_find(par[node]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
for (int i = 0; i <= 2 * N; i++) par[i] = i, sz[i] = 1;
int u, v;
for (int i = 0; i < N; i++) {
cin >> u >> v;
if (u == v) {
u = u_find(u);
kind[u] |= 2;
continue;
}
u = u_find(u);
v = u_find(v);
if (u != v) {
par[u] = v;
sz[v] += sz[u];
kind[v] |= kind[u];
} else
kind[u] |= 1;
}
long long ans = 1;
for (int i = 1; i <= 2 * N; i++)
if (u_find(i) == i) {
if (kind[i] == 1)
ans = (ans * 2) % MOD;
else if (kind[i] == 0)
ans = (ans * sz[i]) % MOD;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
if (s.find("AB") == string ::npos || s.find("BA") == string ::npos)
cout << "NO" << endl;
else {
int idx = s.find("AB");
if (s.find("BA", idx + 2) != string ::npos) {
cout << "YES" << endl;
return 0;
}
idx = s.find("BA");
if (s.find("AB", idx + 2) != string ::npos) {
cout << "YES" << endl;
return 0;
}
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
const long double pi = acos(-1.0);
const long double inf = 1000 * 1000 * 1000;
#pragma comment(linker, "/STACK:36777216")
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
long long xabs(long long a) { return a > 0 ? a : -a; }
int dp[700][302][302];
int sm[4][2] = {{0, 0}, {0, -1}, {-1, 0}, {-1, -1}};
int main() {
for (int i = 0; i < 700; ++i)
for (int j = 0; j < 302; ++j)
for (int k = 0; k < 302; ++k) dp[i][j][k] = -inf;
int n;
cin >> n;
vector<vector<int> > g(n, vector<int>(n));
int m = n;
for (int i = 0; i < n; i++)
for (int k = 0; k < n; k++) cin >> g[i][k];
dp[0][0][0] = g[0][0];
for (int t = 1; t <= n + m - 2; t++) {
for (int x1 = 0; x1 < n; x1++) {
for (int x2 = 0; x2 < n; x2++) {
for (int i = 0; i < 4; i++) {
int nx1 = x1 + sm[i][0];
int nx2 = x2 + sm[i][1];
if (nx1 < n && nx2 < n && nx1 >= 0 && nx2 >= 0 && t - x1 >= 0 &&
t - x2 >= 0 && t - x1 < n && t - x2 < n) {
int tmp = dp[t - 1][nx1][nx2] + g[x1][t - x1] + g[x2][t - x2];
if (x1 == x2) tmp -= g[x1][t - x1];
dp[t][x1][x2] = max(dp[t][x1][x2], tmp);
}
}
}
}
}
int result = dp[n + m - 2][n - 1][n - 1];
cout << result << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double eps = 1e-7;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 2000010;
int n, m, k, q, x, y, t, a, b, comp;
int C[MAXN], V[MAXN];
int par[MAXN], A[MAXN];
int ans[MAXN], P[MAXN];
int id[305][305], N;
pair<int, int> id2[MAXN];
int bad[MAXN], tof[MAXN], koj[MAXN];
int get(int x) {
if (par[x] == x) return x;
return par[x] = get(par[x]);
}
int join(int x, int y) {
x = get(x);
y = get(y);
par[x] = y;
return x != y;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) id2[id[i][j] = N++] = {i, j};
for (int i = 1; i <= q; i++) {
cin >> x >> y >> C[i];
V[i] = id[x][y];
if (A[V[i]] == C[i])
P[i] = i - 1;
else
A[V[i]] = C[i];
}
memset(A, 0, sizeof(A));
for (int c = 1; c <= C[q]; c++) {
int ql = lower_bound(C + 1, C + q + 1, c) - C,
qr = upper_bound(C + 1, C + q + 1, c) - C;
if (qr - ql <= 0) continue;
for (int i = ql; i < qr; i++) bad[V[i]] = c;
iota(par, par + N, 0);
comp = n * m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (bad[id[i][j]] != c) {
if (i - 1 && A[id[i - 1][j]] == A[id[i][j]] && bad[id[i - 1][j]] != c)
comp -= join(id[i - 1][j], id[i][j]);
if (j - 1 && A[id[i][j - 1]] == A[id[i][j]] && bad[id[i][j - 1]] != c)
comp -= join(id[i][j - 1], id[i][j]);
}
for (int i = 0; i < N; i++) tof[i] = par[i];
int compp = comp;
for (int i = ql; i < qr; i++)
if (!P[i]) koj[V[i]] = i;
for (int i = qr - 1; i >= ql; i--)
if (!P[i]) {
ans[i] = comp;
int x = id2[V[i]].first, y = id2[V[i]].second, v = V[i];
if (x - 1 && A[id[x - 1][y]] == A[v] &&
(bad[id[x - 1][y]] != c || koj[id[x - 1][y]] >= i))
comp -= join(id[x - 1][y], v);
if (y - 1 && A[id[x][y - 1]] == A[v] &&
(bad[id[x][y - 1]] != c || koj[id[x][y - 1]] >= i))
comp -= join(id[x][y - 1], v);
if (x + 1 <= n && A[id[x + 1][y]] == A[v] &&
(bad[id[x + 1][y]] != c || koj[id[x + 1][y]] >= i))
comp -= join(id[x + 1][y], v);
if (y + 1 <= m && A[id[x][y + 1]] == A[v] &&
(bad[id[x][y + 1]] != c || koj[id[x][y + 1]] >= i))
comp -= join(id[x][y + 1], v);
}
for (int i = 0; i < N; i++) par[i] = tof[i];
comp = 0;
for (int i = ql; i < qr; i++) {
int x = id2[V[i]].first, y = id2[V[i]].second, v = V[i];
A[v] = c;
if (x - 1 && A[id[x - 1][y]] == A[id[x][y]])
comp -= join(id[x - 1][y], id[x][y]);
if (y - 1 && A[id[x][y - 1]] == A[id[x][y]])
comp -= join(id[x][y - 1], id[x][y]);
if (x + 1 <= n && A[id[x + 1][y]] == A[id[x][y]])
comp -= join(id[x + 1][y], id[x][y]);
if (y + 1 <= m && A[id[x][y + 1]] == A[id[x][y]])
comp -= join(id[x][y + 1], id[x][y]);
ans[i] += comp;
}
}
for (int i = 1; i <= q; i++) {
if (P[i]) ans[i] = ans[P[i]];
cout << ans[i] << '\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int tmp[100010 * 4], age[100010 * 4], c[100010 * 4], n, k,
tt = 0, tot = 0, T, val[100010], ans[100010], mx[100010 * 20];
struct Person {
int sup, ag, id;
} p[100010];
struct Query {
int a, b, al, ar, msp, id;
void init(int _id) {
scanf("%d%d", &a, &b);
msp = max(p[a].sup, p[b].sup);
al = max(p[a].ag - k, p[b].ag - k);
ar = min(p[a].ag + k, p[b].ag + k);
id = _id;
}
} q[100010];
bool cmp1(Person _, Person __) { return _.sup < __.sup; }
bool cmp2(Query _, Query __) { return _.msp < __.msp; }
void add(int x) {
while (x <= tot) c[x]++, x += ((x) & (-x));
}
int sum(int x) {
int res = 0;
while (x > 0) res += c[x], x -= ((x) & (-x));
return res;
}
int get(int tg) {
int l = 1, r = tot;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (age[mid] <= tg)
l = mid;
else
r = mid - 1;
}
return l;
}
void update(int t, int x, int nl, int nr, int v) {
if (nl == nr) {
mx[x] = max(mx[x], v);
return;
}
int mid = (nl + nr) >> 1;
if (t <= mid)
update(t, x << 1, nl, mid, v);
else
update(t, x << 1 | 1, mid + 1, nr, v);
mx[x] = max(mx[x << 1], mx[x << 1 | 1]);
}
int query(int ml, int mr, int x, int nl, int nr) {
int res = 0;
if (ml <= nl && nr <= mr) return mx[x];
int mid = (nl + nr) >> 1;
if (ml <= mid) res = max(res, query(ml, mr, x << 1, nl, mid));
if (mr > mid) res = max(res, query(ml, mr, x << 1 | 1, mid + 1, nr));
return res;
}
void pre() {
int rec = -1;
for (int i = 0; i <= tt; i++) {
if (tmp[i] > rec) {
rec = tmp[i];
age[++tot] = tmp[i];
}
}
for (int i = 1; i <= n; i++) {
int tx = get(p[i].ag), tl = get(p[i].ag - k), tr = get(p[i].ag + k);
add(tx);
val[p[i].id] = sum(tr) - sum(tl - 1);
}
}
void work() {
int now = n;
for (int i = T; i >= 1; i--) {
while (p[now].sup >= q[i].msp && now > 0) {
update(get(p[now].ag), 1, 1, tot, val[p[now].id]);
now--;
}
if (q[i].al > q[i].ar) {
ans[q[i].id] = -1;
continue;
}
int tl = get(q[i].al), tr = get(q[i].ar);
int tp = query(tl, tr, 1, 1, tot);
ans[q[i].id] = (tp == 0) ? -1 : tp;
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &p[i].sup);
for (int i = 1; i <= n; i++) {
int ta;
scanf("%d", &ta);
tmp[++tt] = ta;
tmp[++tt] = ta - k;
tmp[++tt] = ta + k;
p[i].ag = ta, p[i].id = i;
}
scanf("%d", &T);
for (int i = 1; i <= T; i++) q[i].init(i);
sort(tmp + 1, tmp + tt + 1);
sort(p + 1, p + n + 1, cmp1);
sort(q + 1, q + T + 1, cmp2);
pre();
work();
for (int i = 1; i <= T; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, f[502], b[502], siz[502], js, d[502], ans;
int lg[8400000], m;
int dp[8400000], ff[8400000];
char ch[102][102];
int getroot(int t) {
if (f[t] == -1) return t;
return f[t] = getroot(f[t]);
}
inline void fwt(int x[], int tle, int mde) {
for (int i = 2; i <= tle; i <<= 1)
for (int j = 0, stp = i >> 1; j < tle; j += i)
for (int k = j; k < j + stp; k++) x[k + stp] += mde * x[k];
}
int main() {
memset(f, -1, sizeof(f));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", ch[i] + 1);
for (int j = 1; j < i; j++) {
if (ch[i][j] == 'A') {
int x = getroot(i), y = getroot(j);
if (x ^ y) f[x] = y;
}
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j < i; j++)
if (ch[i][j] == 'X' && getroot(i) == getroot(j)) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++) siz[getroot(i)]++;
for (int i = 1; i <= n; i++) {
if (siz[i] > 1) b[i] = ++js;
}
if (!js) {
printf("%d\n", n - 1);
return 0;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j < i; j++)
if (ch[i][j] == 'X') {
int x = getroot(i), y = getroot(j);
if (siz[x] > 1 && siz[y] > 1)
d[b[x]] |= 1 << (b[y] - 1), d[b[y]] |= 1 << (b[x] - 1);
}
lg[0] = -1;
m = 1 << js;
dp[0] = 1;
for (register int i = 1; i < m; i++) {
lg[i] = lg[i >> 1] + 1;
int nw = (i & (-i)), la = i ^ nw;
nw = lg[nw] + 1;
if (!(la & d[nw])) dp[i] = dp[la];
}
for (int i = 0; i < m; i++) ff[i] = dp[i];
if (dp[m - 1]) {
printf("%d\n", n);
return 0;
}
ans = n;
fwt(ff, m, 1);
while (1) {
ans++;
fwt(dp, m, 1);
for (int i = 0; i < m; i++) dp[i] = dp[i] * ff[i];
fwt(dp, m, -1);
for (int i = 0; i < m; i++)
if (dp[i]) dp[i] = 1;
if (dp[m - 1]) {
printf("%d\n", ans);
return 0;
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void chkmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chkmax(T1 &a, T2 b) {
if (a < b) a = b;
}
using ll = long long;
using ld = long double;
const string FILENAME = "input";
const int MAXN = 200228;
int n, m, k;
vector<pair<int, int> > g[MAXN];
vector<pair<int, int> > in[MAXN];
ll hsh[MAXN];
mt19937 as;
ll add[10][10];
ll sum = 0;
ll need = 0;
ll ans = 0;
void get(int i) {
if (i == k + 1) {
if (sum == need) {
ans++;
}
return;
}
for (int j = 1; j <= i; j++) {
sum += add[i][j];
get(i + 1);
sum -= add[i][j];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
g[a].push_back(make_pair(c, b));
}
for (int i = 1; i <= n; i++) {
sort((g[i]).begin(), (g[i]).end());
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (int)(g[i]).size(); j++) {
in[g[i][j].second].push_back(make_pair((int)(g[i]).size(), j + 1));
}
hsh[i] = ((ll)as() << 30) + as();
need += hsh[i];
}
for (int i = 1; i <= n; i++) {
for (auto x : in[i]) {
add[x.first][x.second] += hsh[i];
}
}
get(1);
cout << ans << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long unsigned int n_pile;
long long unsigned int n_student;
bool yee(long long unsigned int pile[], long long unsigned int time) {
long long unsigned int need_student = 0;
long long unsigned int more_act = 0;
for (int i = n_pile - 1; i >= 0; i--) {
if (more_act >= pile[i]) {
more_act -= pile[i];
continue;
}
long long unsigned int temp = pile[i] - more_act;
more_act = 0;
if (temp > time - i - 1) {
need_student += temp / (time - i - 1);
temp %= (time - i - 1);
}
if (temp != 0) {
need_student++;
more_act = time - i - 1 - temp;
}
if (need_student > n_student) return false;
}
return true;
}
int main() {
cin >> n_pile >> n_student;
long long unsigned int pile[n_pile + 1];
long long unsigned int n_box = 0;
for (int i = 0; i < n_pile; i++) {
cin >> pile[i];
n_box += pile[i];
}
for (int i = n_pile - 1; i > 0 && pile[i] == 0; i--) n_pile--;
long long unsigned int start = n_pile + 1;
long long unsigned int end = n_pile + n_box;
while (start != end)
if (yee(pile, (start + end) / 2))
end = (start + end) / 2;
else
start = (start + end) / 2 + 1;
cout << start;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
typedef struct node* pnode;
struct node {
pnode l, r;
int pr, c;
int v, add;
node(int v_) {
l = 0;
r = 0;
c = 1;
pr = rand();
v = v_;
add = 0;
}
};
int cnt(pnode t) {
if (t) return t->c;
return 0;
}
void upd(pnode t) {
if (t) t->c = cnt(t->l) + cnt(t->r) + 1;
}
void addv(pnode t, int v) {
if (t) {
t->v += v;
t->add += v;
}
}
void push(pnode t) {
if (t) {
if (t->add != 0) {
addv(t->l, t->add);
addv(t->r, t->add);
t->add = 0;
}
}
}
void merg(pnode& t, pnode l, pnode r) {
push(l);
push(r);
if (!l)
t = r;
else if (!r)
t = l;
else {
if (l->pr > r->pr) {
merg(l->r, l->r, r);
t = l;
} else {
merg(r->l, l, r->l);
t = r;
}
}
upd(t);
}
void split(pnode t, pnode& l, pnode& r, int k) {
if (!t) {
l = 0;
r = 0;
return;
} else {
push(t);
if (cnt(t->l) >= k) {
split(t->l, l, t->l, k);
r = t;
} else {
split(t->r, t->r, r, k - cnt(t->l) - 1);
l = t;
}
}
upd(t);
}
int bs(pnode t, int v) {
if (t == 0) return 0;
push(t);
if (t->v >= v) {
return bs(t->l, v) + 1 + cnt(t->r);
} else {
return bs(t->r, v);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
pnode tree = 0;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int l, r;
cin >> l >> r;
int c2 = bs(tree, r);
if (c2 != 0) {
pnode t1, t2, t3;
split(tree, t1, t2, cnt(tree) - c2);
split(t2, t2, t3, 1);
merg(tree, t1, t3);
}
int c1 = bs(tree, l);
if (c1 != 0) {
pnode t1, t2, t3;
split(tree, t1, t2, cnt(tree) - c1);
int c4 = bs(t2, r);
split(t2, t2, t3, cnt(t2) - c4);
addv(t2, 1);
merg(tree, t1, t2);
merg(tree, tree, t3);
}
int c3 = bs(tree, l);
pnode t1, t2;
split(tree, t1, t2, cnt(tree) - c3);
pnode nn = new node(l);
merg(tree, t1, nn);
merg(tree, tree, t2);
}
cout << cnt(tree) << endl;
}
| 10 |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int n;
std::cin >> n;
std::vector<std::bitset<155>> a(n + 1);
a[0][0] = 1;
a[1][1] = 1;
for (int i = 2; i <= n; i++) {
a[i] = a[i - 2] ^ (a[i - 1] << 1);
}
std::cout << n << '\n';
for (int i = 0; i <= n; i++) {
std::cout << (a[n][i] ? 1 : 0) << (i == n ? '\n' : ' ');
}
std::cout << n - 1 << '\n';
for (int i = 0; i < n; i++) {
std::cout << (a[n - 1][i] ? 1 : 0) << (i == n - 1 ? '\n' : ' ');
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long INF = 1 << 28;
const double pi = acos(-1.0);
int fx[] = {1, -1, 0, 0};
int fy[] = {0, 0, 1, -1};
int dir[4][2] = {1, 0, -1, 0, 0, -1, 0, 1};
int knight[8][2] = {1, 2, 1, -2, 2, 1, 2, -1, -1, 2, -1, -2, -2, 1, -2, -1};
const long double EPS = 1e-7;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
bool cmp(int a, int b) { return a < b; }
int on(int mask, int st) { return mask | (1 << st); }
int off(int mask, int st) { return mask & (~(1 << st)); }
bool check(int mask, int st) { return mask & (1 << st); }
long long inf = 1e18;
long long mod = 1e9 + 7;
int arr[1000], n;
long long dp[200][20000];
long long fun(int pos, int m) {
if (m <= 0) return 0;
if (pos == n) return INT_MAX;
long long &ret = dp[pos][m];
if (ret != -1) return ret;
int k = 0;
int sum = arr[pos];
long long ans;
ans = fun(pos + 1, m - sum) + 1;
for (int i = pos + 1; i < n; i++) {
k++;
int sumk = k * (k + 1);
sumk /= 2;
ans = min(ans, fun(i + 1, m - sum - arr[i] + sumk) + 1);
sum += arr[i];
}
return dp[pos][m] = ans;
}
int main(void) {
int m;
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
sort(arr, arr + n, greater<int>());
memset(dp, -1, sizeof(dp));
long long ans = fun(0, m);
if (ans >= INT_MAX) ans = -1;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 105;
const int mod = 998244353;
const double Pi = acos(-1.0);
const long long INF = 1e18 + 1;
const int G = 3, Gi = 332748118;
long long qpow(long long a, long long b) {
long long res = 1;
while (b & 1) {
if (b) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int n, m, T;
char s[N][N];
struct node {
int sx, sy, ex, ey;
} sol[50];
vector<node> res;
int cnum[50];
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for (int i = 0; i <= 25; ++i) {
sol[i].sx = 0;
cnum[i] = 0;
}
res.clear();
for (int i = 1; i <= n; ++i) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= m; ++j) {
if (s[i][j] == '.') continue;
int tp = s[i][j] - 'a';
cnum[tp]++;
if (!sol[tp].sx) {
sol[tp] = (node){i, j, i, j};
}
}
}
int flag = 0, num = 0;
for (int z = 0; z <= 25; ++z) {
int tp = (char)('a' + z);
int x = sol[z].sx, y = sol[z].sy;
if (!x) {
num++;
continue;
}
node e = (node){x, y, x, y};
int tx = x, ty = y;
int flag1 = 0, tnum = 0;
while (tx <= n) {
if (s[tx][y] == tp) {
tnum++;
if (flag1) {
flag = 1;
break;
}
e.ex = tx;
} else if (s[tx][y] == '.' || s[tx][y] < tp)
flag1 = 1;
tx++;
}
if (flag) break;
flag1 = 0;
while (ty <= m) {
if (s[x][ty] == tp) {
tnum++;
if (flag1) {
flag = 1;
break;
}
e.ey = ty;
} else if (s[x][ty] == '.' || s[x][ty] < tp)
flag1 = 1;
ty++;
}
if (e.ex != x && e.ey != y)
flag = 1;
else if (tnum - 1 != cnum[z])
flag = 1;
if (flag) break;
while (num) {
res.push_back(e);
num--;
}
res.push_back(e);
}
if (flag)
printf("NO\n");
else {
printf("YES\n");
int tt = res.size();
printf("%d\n", tt);
for (int i = 0; i < tt; ++i) {
printf("%d %d %d %d\n", res[i].sx, res[i].sy, res[i].ex, res[i].ey);
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
if (n % 2 == 1 && k % 2 == 0) {
cout << "NO" << endl;
} else {
if (n == k) {
cout << "YES" << endl;
for (int i = 0; i < n; i++) cout << 1 << " ";
cout << endl;
} else if (k == 1) {
cout << "YES" << endl;
cout << n << endl;
} else if (k > n || k == n - 1) {
cout << "NO" << endl;
} else {
if (n % 2 == k % 2) {
cout << "YES" << endl;
for (int i = 0; i < k - 1; i++) cout << 1 << " ";
cout << n - k + 1 << endl;
} else if (n % 2 == 0) {
if (k > n / 2) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
for (int j = 0; j < k - 1; j++) {
cout << 2 << " ";
}
cout << n - 2 * k + 2 << endl;
}
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 200005;
long long l[N], r[N], S[3 * N], dp[3 * N];
void solve() {
long long n;
map<long long, long long> m;
cin >> n;
for (__typeof((n)) i = (1); i <= (n); i++) {
cin >> l[i];
cin >> r[i];
m[l[i]] = 1;
m[r[i]] = 1;
m[r[i] + 1] = 1;
}
long long c = 1;
for (auto &it : m) {
it.second = c++;
}
for (__typeof((n)) i = (1); i <= (n); i++) {
l[i] = m[l[i]];
r[i] = m[r[i]];
S[l[i]]++;
S[r[i] + 1]--;
}
for (__typeof((c - 1)) i = (1); i <= (c - 1); i++) {
S[i] += S[i - 1];
dp[i] = dp[i - 1] + (S[i] == 1);
}
for (__typeof((n)) i = (1); i <= (n); i++) {
if (dp[r[i]] == dp[l[i] - 1]) {
cout << i << '\n';
return;
}
}
cout << -1 << '\n';
return;
}
signed main() {
long long t;
ios_base::sync_with_stdio(false);
t = 1;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100004;
char s[N], t[N], str[N];
int main() {
int n, tr;
scanf("%d %d", &n, &tr);
scanf("%s", s + 1);
scanf("%s", t + 1);
int cnt = 0;
for (int i = 1; i <= n; i++)
if (s[i] != t[i]) cnt++;
if (tr < cnt) {
int val = cnt / 2 + cnt % 2;
if (tr < val)
printf("-1\n");
else {
val = cnt - tr;
val = val * 2;
cnt = 1;
for (int i = 1; i <= n; i++) {
if (s[i] == t[i])
str[i] = s[i];
else {
if (cnt <= val) {
if (cnt % 2 == 1)
str[i] = t[i];
else
str[i] = s[i];
cnt++;
} else {
for (int j = 0; j < 26; j++) {
if (((s[i] - 'a') != j) && ((t[i] - 'a') != j)) {
str[i] = j + 'a';
break;
}
}
}
}
}
printf("%s\n", str + 1);
}
} else {
int val = tr - cnt;
for (int i = 1; i <= n; i++) {
if (s[i] == t[i]) {
if (val > 0) {
str[i] = ((s[i] - 'a') + 1) % 26 + 'a';
val--;
} else
str[i] = s[i];
} else {
for (int j = 0; j < 26; j++) {
if ((j != s[i] - 'a') && (j != t[i] - 'a')) {
str[i] = j + 'a';
break;
}
}
}
}
printf("%s\n", str + 1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int b[m];
for (int j = 0; j < m; j++) cin >> b[j];
for (int j = 0; j < n; j++) {
for (int i = 0; i < m; i++) {
if (a[j] == b[i]) cout << a[j] << " ";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char fi[10][10];
int dx[] = {1, -1, 0, 0, 1, -1, -1, 1};
int dy[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dfs(int x, int y, int i) {
int nx = x + dx[i];
int ny = y + dy[i];
if (0 <= nx && nx < 10 && 0 <= ny && ny < 10 && fi[nx][ny] == 'X') {
return dfs(nx, ny, i) + 1;
}
return 0;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
string s, t;
cin >> s >> t;
map<int, long long> ss, tt;
map<int, int> add;
long long can_use = 0;
for (char c : s) {
if (c == '?') {
can_use++;
} else {
ss[c - 'a']++;
}
}
for (char c : t) {
tt[c - 'a']++;
}
long long left = 0, right = 1e6 + 1;
while (right - left > 1) {
long long mid = (left + right) / 2;
bool ok = 1;
long long no = can_use;
for (int i = 0; i < 26; i++) {
if (ss[i] + no >= tt[i] * mid) {
if (ss[i] >= tt[i] * mid) continue;
no -= tt[i] * mid - ss[i];
} else {
ok = 0;
break;
}
}
if (ok) {
left = mid;
} else {
right = mid;
}
}
for (int i = 0; i < 26; i++) {
if (ss[i] >= tt[i] * left)
continue;
else
add[i] = tt[i] * left - ss[i];
}
add[25] += 1e6;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '?') {
for (int j = 0; j < 26; j++) {
if (add[j] <= 0) continue;
s[i] = (char)(j + 'a');
add[j]--;
break;
}
}
}
cout << s << endl;
}
| 3 |
#include <bits/stdc++.h>
const int N = 3e5 + 5;
int n, v[N];
long long s[N];
int main() {
scanf("%d", &n);
long long sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d%lld", &v[i], &s[i]);
sum += v[i];
}
if (sum < 0) {
for (int i = 1; i <= n; i++) v[i] *= -1;
}
long long ans = 0;
for (int k = 0; k < 62; k++) {
long long sum = 0;
for (int i = 1; i <= n; i++) {
if ((1LL << k) <= s[i] && s[i] < (1LL << (k + 1))) {
sum += ((__builtin_popcountll(ans & s[i]) & 1) ? v[i] : -v[i]);
}
}
if (sum < 0) ans |= (1LL << k);
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long a[200005];
int main() {
long long n, A;
long long tot = 0;
cin >> n >> A;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
tot += a[i];
}
for (int i = 0; i < n; i++) {
long long up = min(A - (n - 1), a[i]);
long long down = max(1ll, A - (tot - a[i]));
printf("%d ", a[i] - (up - down) - 1);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int hh, mm;
while (~scanf("%d:%d", &hh, &mm)) {
hh %= 12;
double t = (double)mm / 60;
cout << (hh * 30 + t * 30);
cout << " " << mm * 6 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int N = 210;
int f[N], pass[N], incycle[N];
int n;
long long k = 1ll, mx = 1ll;
long long gcd(long long a, long long b) { return (a % b ? gcd(b, a % b) : b); }
int dfs(int u, int step) {
if (incycle[u]) {
return -1;
}
if (pass[u]) {
long long cycle = step - pass[u];
k = k * cycle / gcd(k, cycle);
return u;
}
pass[u] = step;
int r = dfs(f[u], step + 1);
if (r != -1) {
incycle[u] = 1;
}
pass[u] = 0;
return (r == u ? -1 : r);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &f[i]);
}
for (int i = 1; i <= n; i++) {
if (pass[i] == 0) {
dfs(i, 1);
}
}
for (int i = 1; i <= n; i++) {
int cnt = 0;
for (int u = i; !incycle[u]; u = f[u]) {
cnt++;
}
if (cnt > mx) {
mx = cnt;
}
}
long long ans = ((mx + k - 1) / k) * k;
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 2, lg = 20, inf = 1e9 + 7;
int a[maxn], Rmin[maxn][lg], Rmax[maxn][lg], Rman[maxn][lg];
int dp[maxn], pd[maxn];
int MQ(int idx, int d) {
int x = idx + d;
d = log2(d);
return min(Rman[idx][d], Rman[x - (1 << d)][d]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, s, l;
cin >> n >> s >> l;
for (int i = 0; i < n; i++) {
cin >> a[i];
Rmin[i][0] = a[i];
Rmax[i][0] = a[i];
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 1; j < lg && i + (1 << j) - 1 < n; j++) {
Rmin[i][j] = min(Rmin[i][j - 1], Rmin[i + (1 << (j - 1))][j - 1]);
Rmax[i][j] = max(Rmax[i][j - 1], Rmax[i + (1 << (j - 1))][j - 1]);
}
}
for (int i = 0; i < n; i++) {
int mx = -inf, mn = inf;
int idx = i;
for (int j = lg - 1; j >= 0; j--) {
if (idx + (1 << j) > n) continue;
if (max(mx, Rmax[idx][j]) - min(mn, Rmin[idx][j]) <= s) {
mx = max(mx, Rmax[idx][j]);
mn = min(mn, Rmin[idx][j]);
idx += 1 << j;
}
}
dp[i] = idx - 1;
}
for (int i = n - 1; i >= 0; i--) {
if (n - i < l)
pd[i] = inf;
else if (dp[i] - i + 1 < l) {
pd[i] = inf;
} else {
pd[i] = min(inf, 1 + MQ(i + l, dp[i] + 1 - i - l + 1));
}
Rman[i][0] = pd[i];
for (int j = 1; j < lg && i + (1 << j) - 1 <= n; j++) {
Rman[i][j] = min(Rman[i][j - 1], Rman[i + (1 << (j - 1))][j - 1]);
}
}
if (pd[0] == inf)
cout << -1;
else
cout << pd[0];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, K;
long long dp[1005][1005][2], sum[2][1005];
long long a[1005], ub[100005], lb[100005];
bool used[100005];
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> K;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) used[a[i]] = true;
for (int i = 0; i < 100005; i++) {
if (!used[i]) {
ub[i] = lb[i] = ub[i - 1];
if (i == 0) ub[i] = lb[i] = 0;
continue;
}
ub[i] = upper_bound(a + 1, a + n + 1, i) - a - 1;
lb[i] = lower_bound(a + 1, a + n + 1, i) - a - 1;
}
long long m = 100000 / (K - 1), ans = 0;
for (int d = 1; d <= m; d++) {
for (int i = 1; i <= K; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k < 2; k++) {
dp[i][j][k] = 0;
}
}
}
for (int j = 1; j <= n; j++) dp[1][j][0] = 1;
for (int i = 2; i <= K; i++) {
for (int j = 1; j <= n; j++) {
sum[0][j] = (sum[0][j - 1] + dp[i - 1][j][0]) % 998244353;
sum[1][j] = (sum[1][j - 1] + dp[i - 1][j][1]) % 998244353;
}
for (int j = 1; j <= n; j++) {
long long just = a[j] - d;
if (just >= 0)
dp[i][j][0] += sum[0][lb[just]], dp[i][j][0] %= 998244353;
if (just >= 0) {
dp[i][j][1] += sum[1][ub[just]], dp[i][j][1] %= 998244353;
dp[i][j][1] += sum[0][ub[just]] - sum[0][lb[just]] + 998244353,
dp[i][j][1] %= 998244353;
}
}
}
for (int j = 1; j <= n; j++)
ans += d * dp[K][j][1] % 998244353, ans %= 998244353;
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int val = (n + m) / 3;
int ans;
if (n <= m)
ans = min(val, n);
else
ans = min(val, m);
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
std::pair<int, int> advance(std::pair<int, int> pos, int dir) {
switch (dir) {
case 0:
return {pos.first + 1, pos.second};
case 1:
return {pos.first + 1, pos.second + 1};
case 2:
return {pos.first, pos.second + 1};
case 3:
return {pos.first - 1, pos.second + 1};
case 4:
return {pos.first - 1, pos.second};
case 5:
return {pos.first - 1, pos.second - 1};
case 6:
return {pos.first, pos.second - 1};
case 7:
return {pos.first + 1, pos.second - 1};
}
}
std::pair<int, int> get_next(int dir) {
switch (dir) {
case 0:
return {7, 1};
case 1:
return {0, 2};
case 2:
return {1, 3};
case 3:
return {2, 4};
case 4:
return {5, 3};
case 5:
return {6, 4};
case 6:
return {5, 7};
case 7:
return {6, 0};
}
}
int n;
int t[30];
std::map<std::pair<int, int>, bool> cells;
std::map<std::pair<std::pair<int, int>, std::pair<int, int> >, bool> q;
void firework(std::pair<int, int> pos, int rec, int dir) {
if (q[{pos, {rec, dir}}]) return;
q[{pos, {rec, dir}}] = true;
if (rec == n) return;
for (int i = 0; i < t[rec]; i++) {
pos = advance(pos, dir);
cells[pos] = true;
}
std::pair<int, int> next = get_next(dir);
firework(pos, rec + 1, next.first);
firework(pos, rec + 1, next.second);
}
int main() {
std::cin >> n;
for (int i = 0; i < n; i++) std::cin >> t[i];
firework({-1, 0}, 0, 0);
std::cout << cells.size() << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 711111;
long long n, big = -99999, ans = 0, a[maxn], dp[maxn], cnt[maxn];
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
cnt[a[i]]++;
big = max(big, a[i]);
}
dp[0] = 0;
dp[1] = cnt[1];
for (long long i = 2; i <= max(big, n) + 11111; i++) {
dp[i] = max(dp[i - 1], dp[i - 2] + i * cnt[i]);
ans = max(ans, dp[i]);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, k;
int a[200010];
int cnt = 0;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] & 1) cnt++;
}
if (cnt < k) {
printf("NO\n");
continue;
} else if ((cnt - k + 1) % 2 == 0) {
printf("NO\n");
continue;
} else {
int num = 0;
printf("YES\n");
if (k == 1) {
printf("%d\n", n);
continue;
} else {
for (int i = 0; i < n; i++) {
if (num == k - 1) break;
if (a[i] & 1) {
num++;
printf("%d ", i + 1);
}
}
printf("%d\n", n);
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long a, b, c;
cin >> a >> b >> c;
long long d = 0;
d = max(a, max(b, c));
cout << d << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
char matrix[400][400];
char tmp[6][400][400];
int main(){
int t;
scanf("%d", &t);
while(t--){
int n;
scanf("%d", &n);
for (int i=0;i<n;i++) scanf("%s", matrix[i]);
for (int z=0;z<6;z++){
for (int i=0;i<400;i++){
for (int j=0;j<400;j++) tmp[z][i][j]=0;
}
}
int c=0;
for (int i=0;i<n;i++){
for (int j=0;j<n;j++) {
if (matrix[i][j]!='.') c++;
}
}
//printf("%d\n", c);
int ansnum=-100, tmp1=0;
for (int z=0;z<3;z++){
for (int i=0;i<n;i++){
for (int j=0;j<n;j++){
if (matrix[i][j]=='.'){
tmp[z][i][j]='.';
continue;
}
if ((i+j)%3==z){
if (matrix[i][j]=='O'){
tmp[z][i][j]='O';
continue;
}
else{
//printf("%d %d\n", i, j);
tmp1++;
tmp[z][i][j]='O';
continue;
}
}
else{
if (matrix[i][j]=='X'){
tmp[z][i][j]='X';
continue;
}
else{
//printf("%d %d\n", i, j);
tmp1++;
tmp[z][i][j]='X';
continue;
}
}
}
}
if (tmp1<=(c/3)){
ansnum=z;
break;
}
tmp1=0;
}
//printf("%d %d\n", ansnum, tmp1);
for (int z=3;z<6;z++){
if (ansnum!=-100) break;
for (int i=0;i<n;i++){
for (int j=0;j<n;j++){
if (matrix[i][j]=='.'){
tmp[z][i][j]='.';
continue;
}
if ((i+j)%3==(z%3)){
if (matrix[i][j]=='X'){
tmp[z][i][j]='X';
continue;
}
else{
tmp1++;
tmp[z][i][j]='X';
continue;
}
}
else{
if (matrix[i][j]=='O'){
tmp[z][i][j]='O';
continue;
}
else{
tmp1++;
tmp[z][i][j]='O';
continue;
}
}
}
}
if (tmp1<=(c/3)){
ansnum=z;
break;
}
tmp1=0;
}
//printf("%d %d\n", ansnum, tmp1);
//if (ansnum==-100) continue;
for (int i=0;i<n;i++){
printf("%s\n", tmp[ansnum][i]);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int cnt[1000000];
char str[22], ch;
char scan() {
char c;
do {
c = getchar();
} while (c == '\n');
return c;
}
int fn(long long num) {
long long dg;
int i = 0;
do {
dg = num % 10;
num = num / 10;
if (dg % 2 == 0)
i = 2 * i + 1;
else
i = 2 * i + 2;
} while (num != 0);
return i;
}
int main() {
int t, n, i, j, k;
long long int num;
scanf("%d", &t);
while (t--) {
ch = scan();
if (ch == '+') {
scanf("%I64d", &num);
cnt[fn(num)]++;
} else if (ch == '-') {
scanf("%I64d", &num);
cnt[fn(num)]--;
} else if (ch == '?') {
int sum = 0;
scanf("%c", &ch);
scanf("%s", str + 1);
reverse(str + 1, str + strlen(str + 1) + 1);
n = strlen(str + 1);
j = 0;
k = 0;
for (i = 1; i <= n; i++)
if (str[i] == '1') j = i;
for (i = 1; i <= j; i++)
if (str[i] == '0')
k = k * 2 + 1;
else
k = 2 * k + 2;
sum = cnt[k];
for (; i <= 18; i++) k = 2 * k + 1, sum += cnt[k];
printf("%d\n", sum);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void init() {
long long n, m, k;
cin >> n >> m;
if (m == 0) {
cout << "YES" << endl;
return;
}
vector<long long> a(m);
for (long long i = 0; i < m; i++) cin >> a[i];
sort(a.begin(), a.end());
bool ok = true;
if (a[0] == 1 or a[m - 1] == n) ok = false;
for (long long i = 0; i < m - 2; i++) {
if (a[i] + 1 == a[i + 1] and a[i] + 2 == a[i + 2]) {
ok = false;
break;
}
}
if (ok == true)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
int32_t main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
init();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[2005][15][15];
int d[2005][2005];
int N, M, n, w;
int calc(int u, int v) {
int res(0);
for (int i = 0; i < M; i++)
for (int j = 0; j < N; j++) {
if (s[u][i][j] != s[v][i][j]) res++;
}
return res * w;
}
int chk[2005], val[2005];
int par[2005];
int main() {
cin >> M >> N >> n >> w;
for (int i = 0; i < n; i++) {
for (int j = 0; j < M; j++) scanf("%s", s[i][j]);
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) d[i][j] = d[j][i] = calc(i, j);
int id, mx;
int rlt(0);
int x[2005];
int xn(0);
memset(par, -1, sizeof(par));
for (int i = 0; i < n; i++) val[i] = M * N;
while (1) {
id = -1;
for (int i = 0; i < n; i++)
if (!chk[i]) {
if (id == -1 || val[i] < mx) {
id = i;
mx = val[i];
}
}
if (id == -1) break;
x[xn++] = id;
rlt += val[id];
chk[id] = 1;
for (int i = 0; i < n; i++) {
if (chk[i]) continue;
if (val[i] <= d[id][i]) continue;
val[i] = d[id][i];
par[i] = id;
}
}
cout << rlt << endl;
for (int i = 0; i < n; i++) {
cout << x[i] + 1 << ' ' << par[x[i]] + 1 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long int n;
cin >> n;
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
ans += (1ll << i);
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 333;
const long long linf = 1e18 + inf;
const int LEN = 6e5 + 555;
int n, m, q, len;
char str[LEN], s[LEN];
int a[LEN], st[LEN], nd[LEN], suf[LEN], ord[LEN], lcp[LEN], w[LEN], root[LEN],
L[LEN], R[LEN];
pair<pair<int, int>, int> C[LEN];
long long cnt[LEN];
void add(int x, char str[]) {
int m = strlen(str);
s[++len] = '#';
st[x] = len + 1;
for (int i = 0; i < m; i++) s[++len] = str[i];
nd[x] = len;
}
int f(int x) {
if (x == root[x]) return x;
return root[x] = f(root[x]);
}
void merge(int x, int y) {
x = f(x);
y = f(y);
if (x == y) return;
root[y] = x;
cnt[x] += cnt[y];
L[x] = min(L[x], L[y]);
R[x] = max(R[x], R[y]);
}
int help[LEN];
pair<pair<int, int>, int> T[LEN];
void fastSort() {
memset(help, 0, sizeof(help));
for (int i = 1; i <= len; i++) {
help[C[i].first.second]++;
}
for (int i = 1; i <= len; i++) {
help[i] += help[i - 1];
}
for (int i = len; i >= 1; i--) {
T[help[C[i].first.second]--] = C[i];
}
memset(help, 0, sizeof(help));
for (int i = 1; i <= len; i++) {
help[T[i].first.first]++;
}
for (int i = 1; i <= len; i++) {
help[i] += help[i - 1];
}
for (int i = len; i >= 1; i--) {
C[help[T[i].first.first]--] = T[i];
}
}
int main() {
for (int it = 0; it < 500; it++) {
s[++len] = '#';
}
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", str);
add(i, str);
}
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= len; i++) suf[i] = s[i];
for (int it = 1; it < len; it *= 2) {
for (int j = 1; j <= len; j++) {
C[j] = make_pair(pair<int, int>(suf[j], suf[min(j + it, len + 1)]), j);
}
fastSort();
for (int j = 1; j <= len; j++) {
suf[C[j].second] = suf[C[j - 1].second] + (C[j].first != C[j - 1].first);
}
}
for (int i = 1; i <= len; i++) ord[suf[i]] = i;
for (int i = 1; i <= len; i++) {
}
int j = 0;
for (int i = 1; i <= len; i++) {
if (suf[i] == 1) continue;
while (i + j <= len and ord[suf[i] - 1] + j <= len and
s[i + j] == s[ord[suf[i] - 1] + j] and s[i + j] != '#')
j++;
lcp[suf[i]] = j;
if (j) j--;
}
for (int i = 1; i <= len; i++) {
assert(s[ord[i] + lcp[i]] != s[ord[i - 1] + lcp[i]] or
s[ord[i] + lcp[i]] == '#');
}
for (int i = 1; i <= len; i++) {
}
memset(w, -1, sizeof(w));
for (int i = 1; i <= n; i++) {
for (int j = st[i]; j <= nd[i]; j++) {
w[suf[j]] = i;
}
}
for (int i = 1; i <= len; i++) {
if (w[i] != -1) cnt[i] = a[w[i]];
L[i] = R[i] = root[i] = i;
}
vector<pair<int, int> > vs;
for (int i = 1; i <= len; i++) {
vs.push_back(pair<int, int>(lcp[i], i));
}
sort(vs.begin(), vs.end());
long long ans = 0;
for (int i = 1; i <= n; i++) {
int x = suf[st[i]];
if (nd[i] - st[i] + 1 > lcp[x] and nd[i] - st[i] + 1 > lcp[x + 1]) {
ans = max(ans, (long long)a[i] * (nd[i] - st[i] + 1));
}
}
for (int it = len - 1; it >= 0; it--) {
int l = vs[it].first, x = vs[it].second;
merge(x, x - 1);
x = f(x);
if (lcp[L[x]] < l and lcp[R[x] + 1] < l) ans = max(ans, cnt[f(x)] * l);
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
long long int temp;
while (b) {
temp = a;
a = b;
b = temp % b;
}
return a;
}
int main() {
ios_base::sync_with_stdio(0);
long long int t, w, b, m, l, ans;
cin >> t >> w >> b;
m = min(w, b);
l = w * (b / gcd(w, b));
if (l > 0 && l % w == 0 && l % b == 0) {
ans = (t / l) * m + min((t % l), m - 1);
cout << ans / gcd(ans, t) << "/" << t / gcd(ans, t) << "\n";
} else {
ans = min(t, m - 1);
cout << ans / gcd(ans, t) << "/" << t / gcd(ans, t) << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int prime[5000000 + 100];
void eratos() {
for (int i = 0; i < 5000000; i++) prime[i] = 1;
prime[0] = prime[1] = 0;
for (int i = 2; i * i <= 5000000; i++)
if (prime[i]) {
for (int j = i * 2; j <= 5000000; j += i) prime[j] = 0;
}
return;
}
bool isprime(int x) {
if (x <= 5000000) return prime[x];
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return true;
}
int n;
int main() {
eratos();
scanf("%d", &n);
if (n == 3 || n == 5) {
printf("1\n%d\n", n);
return 0;
}
n -= 3;
vector<int> v;
for (int i = 2; i <= 5000000; i++)
if (prime[i]) v.push_back(i);
bool flag = true;
for (int i = 0; i < v.size(); i++) {
if (v[i] >= n) break;
if (isprime(n - v[i])) {
flag = false;
printf("3\n3 %d %d\n", v[i], n - v[i]);
break;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " = " << arg1 << '\n';
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " = " << arg1 << " || ";
__f(comma + 1, args...);
}
template <class Ch, class Tr, class Container>
basic_ostream<Ch, Tr>& operator<<(basic_ostream<Ch, Tr>& os,
Container const& x) {
os << "{ ";
for (auto& y : x) os << y << " ; ";
return os << "}";
}
template <class X, class Y>
ostream& operator<<(ostream& os, pair<X, Y> const& p) {
return os << "[ " << p.first << ", " << p.second << "]";
}
long double power(long double x, long long y) {
long double res = 1;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(10);
long long m, n;
cin >> m >> n;
long double num = m * 1.0;
for (long long i = 1; i <= m - 1; i++) {
long double temp = 1.0 * i / m;
temp = 1.0 * power(temp, n);
num -= temp;
}
cout << num << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s[200000];
int main(void) {
int n;
cin >> n;
set<string> joy;
set<string>::iterator it;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
for (int i = n; i >= 0; i--) {
if (joy.count(s[i]) == 0) cout << s[i] << endl;
joy.insert(s[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<char, int> mp;
mp.insert(make_pair('q', 9));
mp.insert(make_pair('r', 5));
mp.insert(make_pair('b', 3));
mp.insert(make_pair('n', 3));
mp.insert(make_pair('p', 1));
int scoreW = 0, scoreB = 0;
string s;
for (int i = 0; i < 8; ++i) {
cin >> s;
for (char c : s) {
if (c != 'k' && c != 'K' && c != '.') {
if (isupper(c))
scoreW += mp[tolower(c)];
else
scoreB += mp[c];
}
}
}
if (scoreW < scoreB)
cout << "Black" << endl;
else if (scoreW == scoreB)
cout << "Draw" << endl;
else
cout << "White" << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5;
int n, val[N + 5], cnt[N + 5], x, sum[N + 5], las[2 * N + 5], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]), cnt[val[i]]++;
for (int i = 1; i <= n; i++)
if (cnt[i] > cnt[x]) x = i;
int lim = sqrt(n) + 1;
for (int i = 1; i <= n; i++)
if (cnt[i] >= lim && i != x) {
int y = i;
for (int j = 1; j <= n; j++)
if (val[j] == x)
sum[j] = 1;
else if (val[j] == y)
sum[j] = -1;
else
sum[j] = 0;
for (int j = 0; j <= 2 * n; j++) las[j] = -1;
las[n] = 0;
sum[0] = n;
for (int j = 1; j <= n; j++) {
sum[j] += sum[j - 1];
if (las[sum[j]] != -1)
ans = max(ans, j - las[sum[j]]);
else
las[sum[j]] = j;
}
}
for (int i = 1; i < lim; i++) {
for (int j = 1; j <= n; j++) sum[j] = 0;
int l = 1, num = 0;
for (int j = 1; j <= n; j++) {
sum[val[j]]++;
if (sum[val[j]] == i)
num++;
else
while (sum[val[j]] > i) {
if (sum[val[l]] == i) num--;
sum[val[l]]--;
l++;
}
if (num >= 2) ans = max(ans, j - l + 1);
}
}
printf("%d", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
template <class T>
T read(T &a) {
a = 0;
char x = getchar();
bool f = 0;
for (; x < '0' || x > '9'; x = getchar()) f |= x == '-';
for (; x >= '0' && x <= '9'; x = getchar()) a = (a << 3) + (a << 1) + x - '0';
if (f) a = -a;
return a;
}
using namespace std;
const int N = 105;
int d[N], n, k;
int main() {
int T;
read(T);
d[0] = -0x3f3f3f3f;
while (T--) {
read(n), read(k);
int cnt = 0;
for (int i = 1; i <= n; ++i) {
read(d[i]);
cnt += d[i] != d[i - 1];
}
if (cnt > 1 && k == 1) {
puts("-1");
continue;
}
int ans = 1;
cnt -= k;
k--;
while (cnt > 0) {
ans++;
cnt -= k;
}
cout << ans << endl;
}
return 0;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct viet {
long long x, w;
};
viet a[N];
bool cmp(viet x, viet y) { return (x.x - x.w) < (y.x - y.w); }
long long dp[N];
set<pair<long long, long long>> s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].x >> a[i].w;
}
sort(a + 1, a + n + 1, cmp);
dp[n + 1] = 0;
s.insert({1000000000000, n + 1});
for (int i = n; i >= 1; i--) {
dp[i] = max(dp[i], dp[i + 1]);
auto it = s.lower_bound({a[i].w + a[i].x, -1e18});
dp[i] = max(dp[i], dp[(*it).second] + 1);
s.insert({a[i].x - a[i].w, i});
}
cout << dp[1];
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
cin >> n;
vector<long long> ni(n);
for (int i = 0; i < n; i++) {
cin >> ni[i];
}
cin >> m;
vector<int> mi(m);
for (int i = 0; i < m; i++) {
cin >> mi[i];
}
sort(ni.rbegin(), ni.rend());
long long sum = 0;
for (int j = 0; j < n; j++) {
sum += ni[j];
}
for (int i = 0; i < m; i++) {
cout << sum - ni[mi[i] - 1] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long const MAXN = 2e5 + 10, MAXM = 2e6 + 10;
long long n, m, T, a[MAXN];
long long e[MAXN], ne[MAXM], h[MAXN], idx, vis[MAXN];
void add(long long a, long long b) { e[idx] = b, ne[idx] = h[a], h[a] = idx++; }
long long tmp = 0;
void dfs(long long u, long long fa) {
for (long long i = h[u]; ~i; i = ne[i]) {
long long j = e[i];
if (j == fa) continue;
if (vis[j] == 1) {
tmp++;
continue;
}
vis[j] = 1;
dfs(j, u);
}
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
memset(h, -1, sizeof h);
cin >> n >> m;
for (long long i = 1; i <= m; ++i) {
long long a, b;
cin >> a >> b;
add(a, b), add(b, a);
}
vis[1] = 1;
dfs(1, -1);
long long flg = 1;
if (tmp / 2 != 1) flg = 0;
for (long long i = 1; i <= n; ++i) {
if (vis[i] == 0) flg = 0;
}
if (!flg)
cout << "NO";
else
cout << "FHTAGN!";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct __timestamper {};
const int MAXK = 150;
const int INF = (int)1.1e9;
vector<int> dp[MAXK];
int a[MAXK];
int main() {
int n, k, s;
scanf("%d%d%d", &n, &k, &s);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
{
vector<int> ord(n);
for (int i = 0; i < n; i++) ord[i] = i;
sort(ord.begin(), ord.end(), [](int x, int y) { return a[x] < a[y]; });
sort(ord.begin(), ord.begin() + k);
int need = 0;
for (int i = 0; i < k; i++) {
need += ord[i] - i;
}
if (need <= s) {
;
int ans = 0;
for (int i = 0; i < k; i++) ans += a[ord[i]];
printf("%d\n", ans);
return 0;
}
}
for (int i = 0; i <= k; i++) {
dp[i] = vector<int>(s + 1, INF);
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = min(i, k - 1); j >= 0; j--) {
for (int c = 0; c + i - j <= s; c++) {
dp[j + 1][c + i - j] = min(dp[j + 1][c + i - j], dp[j][c] + a[i]);
}
}
}
int ans = INF;
for (int i = 0; i <= s; i++) ans = min(ans, dp[k][i]);
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
char string_in_buffer[(int)260];
void fast_scan(int &first) { scanf("%d", &first); }
void fast_scan(long long &first) { scanf("%lld", &first); }
void fast_scan(unsigned long long &first) { scanf("%llu", &first); }
void fast_scan(double &first) { scanf("%lf", &first); }
void fast_scan(long double &first) { scanf("%Lf", &first); }
void fast_scan(char &first) {
scanf("%c", &first);
if (first == '\n') {
fast_scan(first);
}
}
void fast_scan(string &first) {
scanf("%s", string_in_buffer);
first = string(string_in_buffer);
}
template <class TFirst, class TSecond>
void fast_scan(pair<TFirst, TSecond> &p) {
fast_scan(p.first);
fast_scan(p.second);
}
template <class T>
void fast_scan(vector<T> &v) {
for (auto &first : v) fast_scan(first);
}
void fast_print(const int &first) { printf("%d", first); }
void fast_print(const long long &first) { printf("%lld", first); }
void fast_print(const unsigned long long &first) { printf("%llu", first); }
void fast_print(const double &first) { printf("%.15lf", first); }
void fast_print(const long double &first) { printf("%.15Lf", first); }
void fast_print(const char &first) { printf("%c", first); };
void fast_print(const string &first) { printf("%s", first.c_str()); }
void fast_print(const char v[]) { fast_print((string)v); }
template <class TFirst, class TSecond>
void fast_print(const pair<TFirst, TSecond> &p) {
fast_print(p.first);
fast_print(' ');
fast_print(p.second);
}
template <class T>
void fast_print(const vector<T> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print(' ');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const vector<vector<T>> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print('\n');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const T &v) {
for (const auto &first : v) {
fast_print(first);
fast_print(' ');
}
}
using namespace std;
namespace smart_io {
string print_start = "";
string sep = " ";
bool first_print = false;
void precall_print() {
fast_print(print_start);
print_start = "\n";
first_print = true;
}
void _print(deque<string>) {}
template <class T, class... Args>
void _print(deque<string> names, T kek, Args... args) {
if (!first_print) {
fast_print("\n");
} else {
first_print = false;
}
fast_print(names.front());
fast_print(" = ");
fast_print(kek);
names.pop_front();
_print(names, args...);
}
} // namespace smart_io
template <class T>
ostream &operator,(ostream &os, const T &object) {
if (!smart_io::first_print) {
fast_print(smart_io::sep);
} else {
smart_io::first_print = false;
}
fast_print(object);
return os;
}
template <class T>
istream &operator,(istream &is, T &object) {
fast_scan(object);
return is;
}
namespace typedefs {}
namespace numbers_operation {
template <class T>
T floor_mod(T a, T b) {
if (a % b == 0) return 0;
if (a >= 0 && b >= 0) return a % b;
if (a <= 0 && b <= 0) return a % b;
return abs(b) - (abs(a) % abs(b));
}
} // namespace numbers_operation
using namespace numbers_operation;
using namespace typedefs;
long long n;
vector<pair<long long, long long>> v;
vector<long double> a;
vector<vector<vector<long double>>> mem;
inline long double dp(long long i, long long pref, long long cur) {
if (mem[i][pref][cur] != -1e18) return mem[i][pref][cur];
if (i == n) {
return 0;
}
long double rez = 1e18;
{
long long sub_pref = pref;
long long sub_cur = cur + 1;
if (i < n - 1 && v[i].first > v[i + 1].first) {
sub_pref += sub_cur;
sub_cur = 0;
}
rez = min(rez, dp(i + 1, sub_pref, sub_cur) + a[i]);
}
if (pref) {
long long sub_pref = pref - 1;
long long sub_cur = cur;
if (i < n - 1 && v[i].first > v[i + 1].first) {
sub_pref += sub_cur;
sub_cur = 0;
}
rez = min(rez, dp(i + 1, sub_pref, sub_cur));
}
return mem[i][pref][cur] = rez;
}
signed main(signed argc, char *argv[]) {
{
cin, n;
v.resize(n);
for (long long i = 0; i < (n); i++) {
cin, v[i].first;
}
for (long long i = 0; i < (n); i++) {
cin, v[i].second;
}
}
{
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
}
{} {} {
long double left = 0;
long double right = 1e18;
for (long long t = 0; t < (200); t++) {
long double mid = (left + right) / 2;
long double all = 0;
a.clear();
for (long long i = 0; i < (n); i++) {
a.push_back(v[i].first - mid * v[i].second);
}
mem = vector<vector<vector<long double>>>(
60, vector<vector<long double>>(60, vector<long double>(60, -1e18)));
all = dp(0, 0, 0);
if (all > 0) {
left = mid;
} else {
right = mid;
}
}
right *= 1000;
long long first = right;
if (right - 0.000000000000001 <= first) {
smart_io::precall_print();
cout, first;
} else {
smart_io::precall_print();
cout, first + 1;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int md[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int d, m, y;
int tf(int d1, int m1, int y1) {
if (m1 < 1 || m1 > 12 || d1 < 1 || d1 > md[m1] + int(m1 == 2 && y1 % 4 == 0))
return 0;
return (y1 + 18 < y || y1 + 18 == y && m1 < m ||
y1 + 18 == y && m1 == m && d1 <= d);
}
int main() {
int d1, m1, y1;
scanf("%d. %d. %d", &d, &m, &y);
scanf("%d. %d. %d", &d1, &m1, &y1);
if (tf(d1, m1, y1) || tf(d1, y1, m1) || tf(m1, d1, y1) || tf(m1, y1, d1) ||
tf(y1, d1, m1) || tf(y1, m1, d1))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 4 |
#include<iostream>
#include<cmath>
using namespace std;
int a[200010];
int qz[200010];
const int mod=1e9+7;
int main()
{
qz[0]=1;
for(int i=1;i<=200000;i++) qz[i]=1LL*qz[i-1]*i%mod;
int t;
cin>>t;
while(t--)
{
int n,sum=pow(2,31)-1,cnt=0;
bool flag=0;
cin>>n;
for(int i=1;i<=n;i++) scanf("%d",a+i);
for(int i=1;i<=n;i++) sum&=a[i];
for(int i=1;i<=n;i++) if(sum==a[i]) cnt++;
if(cnt<2)
{
cout<<0<<endl;
continue;
}
int base=1LL*cnt*(cnt-1)%mod;
cout<<1LL*base*qz[n-2]%mod<<endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, x;
cin >> n;
int a[n + 5];
for (i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
a[1] = 1;
for (i = 2; i <= n; i++) {
x = a[i];
if (a[i] > a[i - 1] + 1) {
a[i] = a[i - 1] + 1;
}
if (a[i] > x) {
a[i] = x;
}
}
cout << a[n] + 1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char board[501][501];
int ccidx[501][501];
int ccsize[250001];
int timestamp[250001];
const int dy[4] = {-1, 0, 0, 1};
const int dx[4] = {0, -1, 1, 0};
const char EMPTY = '.';
int n, k;
bool inRange(int y, int x) { return 0 <= y && y < n && 0 <= x && x < n; }
void add(int y, int x, int &answer, int cur_time) {
if (inRange(y, x) && board[y][x] == EMPTY) {
int idx = ccidx[y][x];
if (timestamp[idx] != cur_time) {
timestamp[idx] = cur_time;
answer += ccsize[idx];
}
}
}
int dfs(int y, int x, int num) {
int ret = 1;
if (ccidx[y][x] == 0) {
ccidx[y][x] = num;
for (int dir = 0; dir < 4; dir++) {
int ny, nx;
ny = y + dy[dir];
nx = x + dx[dir];
if (inRange(ny, nx) && ccidx[ny][nx] == 0 && board[ny][nx] == EMPTY)
ret += dfs(ny, nx, num);
}
}
return ret;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf(" %s", board[i]);
}
int connected_num = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (ccidx[i][j] == 0 && board[i][j] == EMPTY) {
ccsize[connected_num] = dfs(i, j, connected_num);
connected_num++;
}
}
}
int tt = 1;
int result = 0;
for (int i = 0; i <= n - k; i++) {
for (int y = i; y < i + k; y++) {
for (int x = 0; x < k; x++) {
--ccsize[ccidx[y][x]];
}
}
for (int j = 0; j <= n - k; j++) {
int answer = k * k;
for (int y = i; y < i + k; y++) {
add(y, j - 1, answer, tt);
add(y, j + k, answer, tt);
}
for (int x = j; x < j + k; x++) {
add(i - 1, x, answer, tt);
add(i + k, x, answer, tt);
}
++tt;
result = max(answer, result);
if (j + k != n) {
for (int y = i; y < i + k; y++) {
ccsize[ccidx[y][j]]++;
ccsize[ccidx[y][j + k]]--;
}
}
}
for (int y = i; y < i + k; ++y) {
for (int x = n - k; x < n; ++x) ++ccsize[ccidx[y][x]];
}
}
printf("%d\n", result);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int main() {
cin >> n >> k;
cout << 3 * n + min(n - k, k - 1);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int arr[500];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
string s = "";
for (int i = 0; i < n; i++) {
while (arr[i]) {
s += 'P';
arr[i]--;
if (!arr[i]) break;
if (i)
s += "LR";
else {
if (arr[i + 1]) {
s += "RPL";
arr[i + 1]--;
} else
s += "RL";
}
}
if (i != n - 1) s += 'R';
}
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1050, maxv = 2e6 + 50;
int n, x, y, z, N, cnt, tot, a[maxn], b[maxn];
unordered_map<int, int> mp[30];
int read() {
int x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + (c ^ 48), c = getchar();
return x;
}
void dfs(int x, int p) {
if (x == N + 1) {
int s = 0;
for (int i = 1; i <= cnt; i++) s += b[i];
if (mp[cnt].count(s)) {
int q = mp[cnt][s];
int t = p & q;
p ^= t, q ^= t;
int r = 0, c[30], d[30];
for (int i = 1; i <= 26; i++)
if (p >> (i - 1) & 1) c[++r] = a[i];
r = 0;
for (int i = 1; i <= 26; i++)
if (q >> (i - 1) & 1) d[++r] = a[i];
printf("YES\n");
int x = 0;
printf("0 ");
for (int i = 1; i <= r; i++) {
x = c[i] - x;
printf("%d ", x);
x = d[i] - x;
if (i != r) printf("%d ", x);
}
for (int i = 1; i <= n; i++) {
bool flag = 1;
for (int j = 1; j <= r; j++) {
if (c[j] == a[i] || d[j] == a[i]) {
flag = 0;
break;
}
}
if (flag) printf("%d ", a[i]);
}
exit(0);
}
mp[cnt][s] = p;
return;
}
if ((cnt + 1) * 2 <= N) {
b[++cnt] = a[x];
dfs(x + 1, p | (1 << (x - 1)));
cnt--;
}
dfs(x + 1, p);
}
int main() {
cin >> n;
if (n == 2) {
cin >> x >> y;
if (x == y) {
cout << "YES" << endl;
cout << 0 << " " << x << endl;
} else
cout << "NO" << endl;
return 0;
} else if (n == 3) {
cin >> x >> y >> z;
if (x == y) {
cout << "YES" << endl;
cout << 0 << " " << y << " " << z << endl;
return 0;
}
if (x == z) {
cout << "YES" << endl;
cout << 0 << " " << x << " " << y << endl;
return 0;
}
if (y == z) {
cout << "YES" << endl;
cout << 0 << " " << x << " " << z << endl;
return 0;
}
if (!((x + y + z) & 1)) {
int t = (x + y + z) >> 1;
x = t - x;
y = t - y;
z = t - z;
cout << "YES" << endl;
cout << x << " " << y << " " << z << endl;
return 0;
}
cout << "NO" << endl;
return 0;
}
int t = 0;
for (int i = 1; i <= n; i++) {
a[i] = read();
if ((a[i] & 1) ^ 1) t = i;
}
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) {
if (a[i] == a[j]) {
printf("YES\n");
printf("0 ");
for (int k = 1; k <= n; k++)
if (k != i) printf("%d ", a[k]);
return 0;
}
}
if (t) {
int e1 = 0, e2 = 0, o1 = 0, o2 = 0;
for (int i = 1; i <= n; i++) {
if (i == t) continue;
if (a[i] & 1) {
if (!o1)
o1 = i;
else if (!o2)
o2 = i;
} else {
if (!e1)
e1 = i;
else if (!e2)
e2 = i;
}
}
if (e1 && e2) {
int tmp = (a[e1] + a[e2] - a[t]) / 2;
printf("YES\n");
printf("%d ", tmp);
for (int i = 1; i <= n; i++)
if (i != t) printf("%d ", a[i] - tmp);
} else {
int tmp = (a[o1] + a[o2] - a[t]) / 2;
printf("YES\n");
printf("%d ", tmp);
for (int i = 1; i <= n; i++)
if (i != t) printf("%d ", a[i] - tmp);
}
return 0;
}
N = min(n, 26);
dfs(1, 0);
printf("NO\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxi = 1e6 + 2;
long long a[maxi], w[maxi];
int n, q;
long long mo = 1e9 + 7;
long long bit[maxi];
long long bit1[maxi];
long long bit2[maxi];
void update(long long *bit, int x, long long val) {
for (int i = x; i < maxi; i += i & (-i)) bit[i] += val;
return;
}
long long get(long long *bit, int x) {
long long ans = 0;
for (int i = x; i > 0; i -= i & (-i)) ans += bit[i];
return ans;
}
void update2(long long *bit2, int x, long long val) {
for (int i = x; i < maxi; i += i & (-i)) {
bit2[i] = (bit2[i] + val) % mo;
if (bit2[i] < 0) bit2[i] += mo;
}
return;
}
long long get2(long long *bit2, int x) {
long long ans = 0;
for (int i = x; i > 0; i -= i & (-i)) {
ans += bit2[i];
ans %= mo;
}
return ans;
}
int main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &w[i]);
for (int i = 1; i <= n; i++) update2(bit2, i, w[i] * a[i]);
for (int i = 1; i <= n; i++) update(bit, i, w[i]);
for (int i = 1; i <= n; i++) update2(bit1, i, 1ll * i * w[i]);
while (q--) {
int tip;
int idx, l;
scanf("%d", &tip);
if (tip < 0) {
idx = -tip;
tip = 1;
} else {
l = tip;
tip = 2;
}
if (tip == 1) {
long long val;
scanf("%lld", &val);
update(bit, idx, -w[idx]);
update2(bit1, idx, -1ll * idx * w[idx]);
update2(bit2, idx, -1ll * a[idx] * w[idx]);
w[idx] = val;
update(bit, idx, w[idx]);
update2(bit1, idx, 1ll * idx * w[idx]);
update2(bit2, idx, 1ll * a[idx] * w[idx]);
} else {
int r;
scanf("%d", &r);
if (l == r)
printf("0\n");
else {
int li = -1;
int ri = r - l + 1;
long long sum = get(bit, r) - get(bit, l - 1);
long long pola = (sum + 1) / 2;
while (li < ri - 1) {
int mid = li + ri >> 1;
long long val = get(bit, l + mid) - get(bit, l - 1);
if (val >= pola)
ri = mid;
else
li = mid;
}
int poz = l + ri;
long long ans = 0;
if (poz - 1 >= l) {
long long x = a[poz] - poz;
long long sumWi = get(bit, poz - 1) - get(bit, l - 1);
sumWi %= mo;
ans += sumWi * x;
ans %= mo;
ans += get2(bit1, poz - 1) - get2(bit1, l - 1);
ans %= mo;
if (ans < 0) ans += mo;
ans -= (get2(bit2, poz - 1) - get2(bit2, l - 1));
ans %= mo;
if (ans < 0) ans += mo;
}
if (poz + 1 <= r) {
long long x = a[poz] - poz;
ans += get2(bit2, r) - get2(bit2, poz);
ans %= mo;
if (ans < 0) ans += mo;
ans -= get2(bit1, r) - get2(bit1, poz);
ans %= mo;
if (ans < 0) ans += mo;
long long sumWi = get(bit, r) - get(bit, poz);
sumWi %= mo;
ans -= sumWi * x;
ans %= mo;
if (ans < 0) ans += mo;
}
printf("%lld\n", ans);
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
long long p, q, b;
int n;
scanf("%d", &n);
while (n--) {
scanf("%lld%lld%lld", &p, &q, &b);
long long tmp = gcd(p, q);
q /= tmp;
long long f = gcd(b, q);
while (1) {
if (f == 1) break;
while (q % f == 0) q /= f;
f = gcd(b, q);
}
if (q == 1)
printf("Finite\n");
else
printf("Infinite\n");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> type(2 * 100005);
vector<int> type2(2 * 100005);
int first = 0;
int counter1 = 0;
int counter2 = 0;
int f2 = 0;
int counter12 = 0;
int counter22 = 0;
void dfs(int x, vector<pair<int, int> > adj[]) {
if (type[x] == 1)
counter1++;
else
counter2++;
for (auto &i : adj[x]) {
if (type[x] == 1) {
if (type[i.first] == 0) {
if (i.second == 1)
type[i.first] = 1;
else
type[i.first] = 2;
dfs(i.first, adj);
} else if (type[i.first] != i.second)
first = 1;
} else {
if (type[i.first] == 0) {
if (i.second == 1)
type[i.first] = 2;
else
type[i.first] = 1;
dfs(i.first, adj);
} else if (type[i.first] == i.second)
first = 1;
}
}
}
void dfs2(int x, vector<pair<int, int> > adj[]) {
if (type2[x] == 1)
counter12++;
else
counter22++;
for (auto &i : adj[x]) {
if (type2[x] == 1) {
if (type2[i.first] == 0) {
if (i.second == 1)
type2[i.first] = 1;
else
type2[i.first] = 2;
dfs2(i.first, adj);
} else if (type2[i.first] != i.second)
f2 = 1;
} else {
if (type2[i.first] == 0) {
if (i.second == 1)
type2[i.first] = 2;
else
type2[i.first] = 1;
dfs2(i.first, adj);
} else if (type2[i.first] == i.second)
f2 = 1;
}
}
}
void solve() {
int n, m;
cin >> n >> m;
type.assign(n, 0);
type2.assign(n, 0);
vector<pair<int, int> > adj[n];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a -= 1;
b -= 1;
string t;
cin >> t;
int temp = 1;
if (t == "imposter") temp = 2;
adj[a].push_back({b, temp});
adj[b].push_back({a, temp});
}
int flag = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
if (type[i] == 0) {
int temp = 0;
type[i] = 2;
first = 0;
counter1 = 0;
counter2 = 0;
dfs(i, adj);
f2 = 0;
type2[i] = 1;
counter12 = 0;
counter22 = 0;
dfs2(i, adj);
if (first == 1 && f2 == 1) flag = 1;
if (first != 1) temp = counter2;
if (f2 != 1) temp = max(temp, counter22);
ans += temp;
}
}
if (flag == 1)
cout << -1 << endl;
else {
cout << ans << endl;
}
}
int main() {
std::ios::sync_with_stdio(false);
int T = 1;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
const int M = 1e6;
struct node {
int x, y, d;
} ans[N];
int n, a[N], b[N], pos[N], sta[N], ind, cnt;
long long s[N];
bool cmp(int i, int j) { return a[i] < a[j]; }
int main() {
scanf("%d", &(n));
for (int i = (1); i <= (n); i++) scanf("%d", &(a[i])), pos[i] = i;
for (int i = (1); i <= (n); i++) scanf("%d", &(b[i]));
sort(pos + 1, pos + 1 + n, cmp);
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + n);
for (int i = (1); i <= (n); i++) a[i] = b[i] - a[i];
for (int i = (1); i <= (n); i++) {
s[i] = s[i - 1] + a[i];
if (s[i] < 0) return puts("NO"), 0;
}
for (int i = (1); i <= (n); i++)
if (s[i] < 0) return puts("NO"), 0;
if (s[n]) return puts("NO"), 0;
for (int i = (1); i <= (n); i++) {
if (a[i] > 0) {
sta[++ind] = i;
} else if (a[i] < 0) {
int d = -a[i];
while (ind && a[sta[ind]] < d) {
ans[++cnt] = node{sta[ind], i, a[sta[ind]]};
d -= a[sta[ind]];
ind--;
}
if (d) ans[++cnt] = node{sta[ind], i, d}, a[sta[ind]] -= d;
}
}
puts("YES");
cout << cnt << endl;
for (int i = (1); i <= (cnt); i++)
printf("%d %d %d\n", pos[ans[i].x], pos[ans[i].y], ans[i].d);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 7;
int n;
vector<int> vnode[N], child[N];
int par[N], c[N], root, val[N];
bool mungkin = 1;
void sol(int node) {
if (!mungkin) return;
vector<int> temp;
for (auto dest : child[node]) {
sol(dest);
for (auto x : vnode[dest]) {
temp.push_back(x);
}
}
int len = temp.size();
if (len < c[node]) {
mungkin = 0;
return;
}
for (int i = 0; i < len; i++) {
if (i == c[node]) {
vnode[node].push_back(node);
}
vnode[node].push_back(temp[i]);
}
if (c[node] == len) {
vnode[node].push_back(node);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> par[i] >> c[i];
if (par[i] == 0) {
root = i;
continue;
}
child[par[i]].push_back(i);
}
sol(root);
if (!mungkin) {
cout << "NO" << '\n';
return 0;
}
cout << "YES" << '\n';
for (int i = 0; i < n; i++) {
val[vnode[root][i]] = i + 1;
}
for (int i = 1; i <= n; i++) {
cout << val[i] << " ";
}
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double prob[100010];
struct segmentS {
int l;
int r;
double L;
double R;
segmentS *sl, *sr;
};
segmentS* createSegment(int l, int r) {
segmentS* toRet = new segmentS();
toRet->l = l;
toRet->r = r;
if (l == r) {
toRet->L = toRet->R = prob[l];
return toRet;
}
int mid = (l + r) / 2;
toRet->sl = createSegment(l, mid);
toRet->sr = createSegment(mid + 1, r);
double l1, l2, r1, r2;
l1 = toRet->sl->L;
l2 = toRet->sr->L;
r1 = toRet->sl->R;
r2 = toRet->sr->R;
toRet->L = l1 * l2 / (1 - (1 - l2) * r1);
toRet->R = r2 + ((1 - r2) * l2 * r1 / (1 - (r1 * (1 - l2))));
return toRet;
}
pair<double, double> query(segmentS* s, int l, int r) {
if (s->l > r || s->r < l) return pair<double, double>(1, 1);
if (l <= s->l && s->r <= r) {
return pair<double, double>(s->L, s->R);
} else if (s->sl->r < l) {
return query(s->sr, l, r);
} else if (s->sr->l > r) {
return query(s->sl, l, r);
} else {
pair<double, double> left = query(s->sl, l, r);
pair<double, double> right = query(s->sr, l, r);
pair<double, double> toRet;
double l1, l2, r1, r2;
l1 = left.first;
l2 = right.first;
r1 = left.second;
r2 = right.second;
toRet.first = l1 * l2 / (1 - (1 - l2) * r1);
toRet.second = r2 + ((1 - r2) * l2 * r1 / (1 - (r1 * (1 - l2))));
return toRet;
}
}
void update(segmentS* s, int x) {
if (s->l == x && s->r == x) {
s->L = s->R = prob[x];
return;
} else {
if (s->sl->r < x) {
update(s->sr, x);
} else {
update(s->sl, x);
}
double l1, l2, r1, r2;
l1 = s->sl->L;
l2 = s->sr->L;
r1 = s->sl->R;
r2 = s->sr->R;
s->L = l1 * l2 / (1 - (1 - l2) * r1);
s->R = r2 + ((1 - r2) * l2 * r1 / (1 - (r1 * (1 - l2))));
}
}
int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
prob[i] = double(a) / b;
}
segmentS* segmentRoot = createSegment(0, n - 1);
for (int i = 0; i < q; i++) {
int a;
scanf("%d", &a);
if (a == 2) {
int x, y;
scanf("%d %d", &x, &y);
x--;
y--;
printf("%.10lf\n", query(segmentRoot, x, y).first);
} else {
int i, x, y;
scanf("%d %d %d", &i, &x, &y);
i--;
prob[i] = double(x) / y;
update(segmentRoot, i);
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
double A[maxn], B[maxn], p, q;
int n;
double check(double x) {
double y = 1e20;
for (int i = 0; i < n; i++) {
y = min(y, (1 - A[i] * x) / B[i]);
}
return p * x + y * q;
}
int main() {
while (~scanf("%d%lf%lf", &n, &p, &q)) {
for (int i = 0; i < n; i++) {
scanf("%lf%lf", A + i, B + i);
}
double l = 0, r = 1.0 / (*max_element(A, A + n));
for (int i = 0; i < 250; i++) {
double ml = (l + l + r) / 3;
double mr = (r + r + l) / 3;
if (check(ml) > check(mr)) {
r = mr;
} else {
l = ml;
}
}
printf("%.20f\n", check((l + l) / 2));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
const int N = 2e5 + 5;
int a[N], b[N];
int r[N], t[N];
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int top = 0;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &t[i], &r[i]);
while (top && r[i] > r[top]) top--;
top++;
t[top] = t[i];
r[top] = r[i];
}
for (int i = r[1] + 1; i <= n; i++) b[i] = a[i];
sort(a + 1, a + r[1] + 1);
int L = 1, R = r[1];
for (int i = 1; i < top; i++) {
for (int j = r[i]; j > r[i + 1]; j--) {
if (t[i] == 1)
b[j] = a[R--];
else
b[j] = a[L++];
}
}
for (int i = r[top]; i >= 1; i--) {
if (t[top] == 1)
b[i] = a[R--];
else
b[i] = a[L++];
}
for (int i = 1; i <= n; i++) printf("%d%c", b[i], (i == n) ? '\n' : ' ');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int N = 3e5 + 10;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
using namespace std;
int n;
std::vector<int> vec[N];
int ans = 0;
bool vis[N];
int cnt[N];
void dfs(int u, int fa) {
for (int i = 0; i < vec[u].size(); i++) {
int v = vec[u][i];
if (v == fa) continue;
dfs(v, u);
if (vis[u]) continue;
if (cnt[v] == 1) cnt[u] = 2;
if (cnt[v] == 2) cnt[u] = max(3, cnt[u]);
if (cnt[v] == 3) cnt[u] = max(1, cnt[u]);
if (cnt[u] == 2 && !vis[u] && fa != 1 && u != 1) {
ans++;
vis[u] = 1;
}
}
if (vec[u].size() == 1) {
cnt[u] = 1;
}
}
int main() {
int n;
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
memset(cnt, -1, sizeof(cnt));
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
vec[u].push_back(v);
vec[v].push_back(u);
}
dfs(1, 0);
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1005;
int n, a[MX], b[MX], c[MX], d[MX];
map<int, vector<int> > hor, ver;
vector<int> ch, cv;
bool go(int x1, int y1, int x2, int y2, int cn) {
if (cn < 2) return 1;
int l = 0, r = cn, mx = 0;
auto it = hor.lower_bound(x1);
while (it != hor.end() && it->first < x2) {
if (l && r && mx <= it->first) {
return go(x1, y1, it->first, y2, l) && go(it->first, y1, x2, y2, r);
}
for (int i : it->second)
if (x1 <= a[i] && c[i] <= x2 && y1 <= b[i] && d[i] <= y2) {
mx = max(mx, c[i]);
l++, r--;
}
it++;
}
l = 0, r = cn, mx = 0;
it = ver.lower_bound(y1);
while (it != ver.end() && it->first < y2) {
if (l && r && mx <= it->first) {
return go(x1, y1, x2, it->first, l) && go(x1, it->first, x2, y2, r);
}
for (int i : it->second)
if (x1 <= a[i] && c[i] <= x2 && y1 <= b[i] && d[i] <= y2) {
mx = max(mx, d[i]);
l++, r--;
}
it++;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i] >> d[i];
hor[a[i]].emplace_back(i);
ver[b[i]].emplace_back(i);
}
if (go(0, 0, 1e9, 1e9, n))
cout << "YES" << '\n';
else
cout << "NO" << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string name[1050];
map<string, int> p;
int n, m;
char s[1050];
string ans[1050];
int r[1050];
bool cx[105][105];
int cnt;
int us[105];
int main() {
int t;
scanf("%d", &t);
while (t--) {
memset(r, -1, sizeof(r));
scanf("%d", &n);
p.clear();
string tm = "";
for (int i = 1; i <= n; i++) {
scanf("%s", s);
int len = strlen(s);
tm = "";
for (int j = 0; j < len; j++) tm += s[j];
p[tm] = i;
name[i] = tm;
}
scanf("%d", &m);
getchar();
bool ok = true;
memset(cx, false, sizeof(cx));
for (int i = 1; i <= m; i++) {
gets(s);
int len = strlen(s);
ans[i] = "";
if (s[0] == '?') {
r[i] = -1;
for (int j = 2; j < len; j++) {
tm = "";
while (j < len && s[j] != '.' && s[j] != ',' && s[j] != '!' &&
s[j] != '?' && s[j] != ' ') {
tm += s[j];
j++;
}
if (tm != "") {
int z = p[tm];
if (z != 0) {
cx[i][z] = true;
}
}
}
for (int j = 1; j < len; j++) ans[i] += s[j];
} else {
tm = "";
int j;
for (j = 0; s[j] != ':'; j++) {
tm += s[j];
}
r[i] = p[tm];
j++;
for (int k = 0; k < len; k++) ans[i] += s[k];
for (; j < len; j++) {
tm = "";
while (j < len && s[j] != '.' && s[j] != ',' && s[j] != '!' &&
s[j] != '?' && s[j] != ' ') {
tm += s[j];
j++;
}
if (tm != "") {
int z = p[tm];
if (z != 0) {
cx[i][z] = true;
}
}
}
}
}
if (ok == false) {
printf("Impossible\n");
continue;
}
r[0] = r[m + 1] = -1;
bool dp[105][105];
int pre[105][105];
memset(dp, false, sizeof(dp));
for (int i = 1; i <= n; i++) dp[0][i] = true;
for (int i = 1; i <= m; i++) {
if (r[i] != -1) {
if (i == 1) {
dp[i][r[i]] = true;
continue;
}
for (int j = 1; j <= n; j++) {
if (j != r[i] && dp[i - 1][j] == true) {
dp[i][r[i]] = true;
pre[i][r[i]] = j;
}
}
continue;
}
for (int j = 1; j <= n; j++) {
if (cx[i][j] == true) continue;
if (j == r[i + 1]) continue;
if (j == r[i - 1]) continue;
for (int k = 1; k <= n; k++) {
if (j == k && i != 1) continue;
if (dp[i - 1][k] == true) {
dp[i][j] = true;
pre[i][j] = k;
}
}
}
}
cnt = m;
bool fin = false;
for (int i = 1; i <= n; i++) {
if (dp[m][i] == true) {
us[cnt] = i;
int w = i;
while (cnt >= 2) {
int k = pre[cnt][w];
cnt--;
us[cnt] = k;
w = k;
}
fin = true;
break;
}
}
if (fin == false) {
printf("Impossible\n");
continue;
}
for (int i = 1; i <= m; i++) {
if (r[i] != -1) {
cout << ans[i] << endl;
} else {
cout << name[us[i]] << ans[i] << endl;
}
}
}
}
| 7 |
#include <bits/stdc++.h>
int main() {
int i, cnt1 = 0, l, diff, a, c, fck;
scanf("%d%d", &a, &c);
l = a;
diff = 0;
while (l > 0) {
if (l % 3) diff += (3 - (l % 3)) * pow(3, cnt1);
l /= 3;
cnt1++;
}
cnt1 = 0;
l = 0;
while (c || diff) {
fck = c + diff;
l += fck % 3 * pow(3, cnt1);
cnt1++;
c /= 3;
diff /= 3;
}
printf("%d", l);
}
| 1 |
#include <bits/stdc++.h>
const int MAXN = 1e4 + 10;
using namespace std;
vector<int> vec[MAXN << 2];
int vul, n, q;
void update(int rt, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
vec[rt].push_back(vul);
return;
}
int mid = (l + r) >> 1;
if (ql <= mid) update(rt << 1, l, mid, ql, qr);
if (qr > mid) update(rt << 1 | 1, mid + 1, r, ql, qr);
}
bitset<MAXN> ans;
bitset<MAXN> sum;
void querty(int rt, int l, int r, bitset<MAXN> num) {
for (int i = 0; i < vec[rt].size(); i++) num |= (num << vec[rt][i]);
if (l == r) {
ans |= num;
return;
}
int mid = (l + r) >> 1;
querty(rt << 1, l, mid, num);
querty(rt << 1 | 1, mid + 1, r, num);
}
int main() {
n, q;
scanf("%d%d", &n, &q);
int l, r;
for (int i = 1; i <= q; i++) {
scanf("%d%d%d", &l, &r, &vul);
update(1, 1, n, l, r);
}
sum[0] = 1;
querty(1, 1, n, sum);
int cnt = 0;
for (int i = 1; i <= n; i++)
if (ans[i]) cnt++;
printf("%d\n", cnt);
for (int i = 1; i <= n; i++) {
if (ans[i]) printf("%d ", i);
}
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct point {
point() : x(0), y(0) {}
point(int x, int y) : x(x), y(y) {}
int x, y;
bool operator<(const point &rhs) const {
return make_pair(-x, -y) < make_pair(-rhs.x, -rhs.y);
}
};
long long ccw(const point &a, const point &b, const point &c) {
long long x1 = b.x - a.x, y1 = b.y - a.y;
long long x2 = c.x - a.x, y2 = c.y - a.y;
return c.x * b.y * x1 * y2 - b.x * c.y * x2 * y1;
}
int main() {
scanf("%d", &n);
vector<point> dat;
set<point> un;
int maxy = 0;
for (int i = 0; i < n; i++) {
point p;
int x, y;
scanf("%d%d", &x, &y);
p.x = x;
p.y = y;
un.insert(p);
dat.push_back(p);
maxy = max(maxy, y);
}
vector<point> cv;
for (auto val : un) {
while (cv.size() >= 2 &&
ccw(cv[cv.size() - 2], cv[cv.size() - 1], val) < 0) {
cv.pop_back();
}
cv.push_back(val);
}
vector<int> ans;
set<pair<int, int>> possible;
for (int i = 0; i < cv.size(); i++) {
possible.insert(make_pair(cv[i].x, cv[i].y));
if (cv[i].y == maxy) break;
}
for (int i = 0; i < n; i++) {
if (possible.count(make_pair(dat[i].x, dat[i].y))) {
ans.push_back(i);
}
}
for (int i = 0; i < ans.size(); i++) {
printf("%d%c", ans[i] + 1, " \n"[i + 1 == ans.size()]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e18;
int main() {
long long n, k;
cin >> n >> k;
long long arr[n + 1], b[n + 1];
memset(b, -1, sizeof(b));
for (int i = 0; i <= n; i++) cin >> arr[i];
long long z = 0;
int i, count = 0;
for (i = 0; i <= n; i++) {
z += arr[i];
b[i] = z;
if (abs(z) % 2 != 0) break;
count++;
z = z / 2;
}
int p = count;
long long val = 0, res = 0;
for (i = n; i >= 0; i--) {
if (i <= p) {
long long temp = val * 2 + b[i];
z = temp - arr[i];
if ((z <= k && z >= -k) && (i != n || z != 0)) {
res++;
}
}
val = val * 2 + arr[i];
if (val < -inf || val > inf) break;
}
cout << res;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
char ch[6];
int main() {
int i, k;
long long w, h;
scanf("%d", &n);
w = h = 1;
for (i = 1; i <= n; ++i) {
scanf("%s", ch);
k = strlen(ch);
if (k == 4)
++w, ++h;
else {
if (ch[0] == 'D') {
if (ch[1] == 'L')
++w;
else
++h;
} else {
if (ch[1] == 'R')
++w;
else
++h;
}
}
}
w *= h;
cout << w << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
double ans = 1;
for (int i = 0; i <= k; i++) ans *= (m - i) / (n + 1.0 + i);
printf("%.12lf\n", max(1 - ans, 0.0));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
struct Node {
int mi[10], mx[10], sz;
bool operator<(const Node &b) const {
for (int i = 0; i < k; i++) {
if (mx[i] > b.mi[i]) return false;
}
return true;
}
};
set<Node> S;
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
Node a;
for (int j = 0; j < k; j++) {
scanf("%d", &a.mx[j]);
a.mi[j] = a.mx[j];
a.sz = 1;
}
set<Node>::iterator x = S.lower_bound(a);
set<Node>::iterator y = S.upper_bound(a);
while (x != y) {
a.sz += x->sz;
for (int j = 0; j < k; j++) {
a.mi[j] = min(a.mi[j], x->mi[j]);
a.mx[j] = max(a.mx[j], x->mx[j]);
}
x = S.erase(x);
}
S.insert(a);
cout << S.rbegin()->sz << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long int a[] = {
1, 2, 4, 8, 16, 32,
64, 128, 256, 512, 1024, 2048,
4096, 8092, 16184, 32368, 64736, 129472,
258944, 517888, 1035776, 2071552, 4143104, 8286208,
16572416, 33144832, 66289664, 132579328, 265158656, 530317312,
1060634624, 2121269248, 4242538496, 8485076992, 16970153984, 33940307968};
int n, i;
cin >> n;
for (i = 0; i <= 35; i++) {
if (n == i) {
cout << a[i];
break;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[200001];
vector<int> b[200001];
int main() {
int n;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a[i];
b[a[i]].push_back(i);
}
vector<int> banned;
int first = 0;
for (int i = n - 1; i > 0; i--) {
if (a[i] != -1) {
for (int j = 0; j < b[a[i]].size(); j++) {
banned.push_back(a[i]);
a[b[a[i]][j]] = -1;
}
}
}
for (int i = 0; i < n; i++) {
if (a[i] != -1) {
cout << a[i];
return 0;
}
}
cout << banned[banned.size() - 1];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, tot, cnt, ans;
int ver[200010], nxt[200010], head[1010], bel[1010], col[1010], vis[1010],
as[1010], dis[1010], q[1010], e[1010], pt[1010][1010];
int read() {
int r = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c <= '9' && c >= '0') r = (r << 1) + (r << 3) + c - '0', c = getchar();
return r * f;
}
void put(int x) {
if (x < 0) {
putchar('-');
x = ~x + 1;
}
if (x > 9) put(x / 10);
putchar(x % 10 + '0');
}
void add(int x, int y) {
ver[++tot] = y;
nxt[tot] = head[x];
head[x] = tot;
}
void dfs(int x, int s) {
bel[x] = s, pt[s][++e[s]] = x;
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (!col[y])
col[y] = 1 - col[x], dfs(y, s);
else if (!(col[x] ^ col[y])) {
puts("-1");
exit(0);
}
}
}
void bfs(int s) {
int hd = 0, tl = 1;
q[1] = s, dis[s] = 1;
while (hd ^ tl) {
++hd;
int x = q[hd];
for (int i = head[x]; i; i = nxt[i]) {
int y = ver[i];
if (!dis[y]) {
dis[y] = dis[x] + 1;
q[++tl] = y;
}
}
}
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
add(u, v), add(v, u);
}
for (int i = 1; i <= n; i++)
if (!bel[i]) dfs(i, ++cnt);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= e[bel[i]]; j++) dis[pt[bel[i]][j]] = 0;
bfs(i);
for (int j = 1; j <= e[bel[i]]; j++)
as[bel[i]] = max(as[bel[i]], dis[pt[bel[i]][j]] - 1);
}
for (int i = 1; i <= cnt; i++) ans += as[i];
put(ans);
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
long long int n, m, k, a[3000005], b[300005] = {0}, dp[2000005] = {0}, t;
set<long long int> st, st1, st2;
string s1 = "", s[200005];
vector<long long int> v, vnode[200005];
vector<pair<long long int, long long int> > vv;
vector<pair<pair<long long int, long long int>, long long int> > vvv3;
vector<pair<long long int, pair<long long int, long long int> > > vvv;
priority_queue<long long int> pq;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int i, j, x = 0, y = 0, z = 0, h, res = 0, ans = 0, mx = 0, nb = 0,
nbs = 0, sms = 0, mm = 5e8, idx = 0, ok = 0, l, r;
set<long long int>::iterator it = st.begin(), it1, it2;
char c = 'R';
cin >> n;
ans = 0;
for (i = 1; i <= n; i++) cin >> a[i], a[i]++;
memset(dp, 0, sizeof(dp));
for (i = 1; i <= n; i++) {
if (a[i] > ans) {
ans = a[i];
}
dp[i] = ans;
}
ans = dp[n];
for (i = n; i >= 1; i--) {
if (dp[i] < ans) {
dp[i] = max(dp[i], dp[i + 1] - 1);
ans = dp[i];
}
}
for (i = 1; i <= n; i++) {
res += dp[i];
res -= a[i];
}
cout << res << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long N, L, W;
vector<long long> neg, pos;
long long INF32 = 0x7fffffff;
inline long long div_floor(long long a, long long b) {
return (long long)floor(1.0 * a / b);
}
int main() {
cin >> N >> L >> W;
for (int i = 0; i < N; ++i) {
long long x, d;
cin >> x >> d;
(d == 1 ? pos : neg).push_back(d == 1 ? x : x + L);
}
sort(pos.begin(), pos.end());
sort(neg.begin(), neg.end());
long long ans = 0;
for (auto x : pos) {
long long lval = max(-x - 1, x);
if (W == 1) {
if (x < 0) {
} else {
lval = INF32;
}
} else {
lval = max(lval, div_floor(((W + 1) * x), (W - 1)));
}
auto l = upper_bound(neg.begin(), neg.end(), lval);
ans += int(neg.end() - l);
lval = max(x, div_floor((W - 1) * x, (W + 1)));
long long rval = -x;
l = upper_bound(neg.begin(), neg.end(), lval);
auto r = lower_bound(neg.begin(), neg.end(), rval);
ans += max(0, int(r - l));
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, Next[600010][26], tot;
int dis[600010], Size[600010], cnt[600010], len;
int dfs1(int st) {
Size[st] = 1;
for (int i = 0; i < (26); i++) {
int v = Next[st][i];
if (v == 0) continue;
dis[v] = dis[st] + 1;
Size[st] += dfs1(v);
}
cnt[dis[st]] += Size[st];
return Size[st];
}
int Merge(int x, int y) {
if (!x || !y) return x + y;
int rt = ++tot;
Size[rt] = 1;
for (int i = 0; i < (26); i++) {
Next[rt][i] = Merge(Next[x][i], Next[y][i]);
Size[rt] += Size[Next[rt][i]];
}
return rt;
}
void dfs2(int st) {
int rt = 0;
for (int i = 0; i < (26); i++) {
if (Next[st][i]) dfs2(Next[st][i]);
}
for (int i = 0; i < (26); i++) rt = Merge(rt, Next[st][i]);
cnt[dis[st]] -= max(1, Size[rt]);
}
int main() {
scanf("%d", &n);
tot = n;
for (int i = 1; i < (n); i++) {
int u, v;
char ch;
scanf("%d %d %c", &u, &v, &ch);
Next[u][ch - 'a'] = v;
}
dfs1(1);
for (int i = 1; i < (n + 1); i++) len = max(len, dis[i]);
dfs2(1);
int pos = 0;
for (int i = 1; i < (len + 1); i++)
if (cnt[i] > cnt[pos]) pos = i;
printf("%d\n%d\n", n - cnt[pos], pos + 1);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char m[20];
scanf("%s", m);
int n;
scanf("%d", &n);
char s[300][20];
int i, j, p = 0;
int a[300];
memset(a, 0, sizeof(a));
for (i = 0; i < n; i++) {
char c1[20], c2[20], c3[20], c4[50], cc;
scanf("%s%s", c1, c2);
if (strcmp(c2, "likes") != 0) scanf("%s", c3);
scanf("%c", &cc);
gets(c4);
for (j = 0;; j++) {
if (c4[j] == '\'') {
c4[j] = '\0';
break;
}
}
if ((strcmp(c1, m) != 0) && (strcmp(c4, m) != 0)) {
int _flag = 0;
for (j = 0; j < p; j++) {
if (strcmp(s[j], c4) == 0) {
_flag = 1;
}
}
if (_flag == 0) {
strcpy(s[p++], c4);
}
_flag = 0;
for (j = 0; j < p; j++) {
if (strcmp(s[j], c1) == 0) {
_flag = 1;
}
}
if (_flag == 0) {
strcpy(s[p++], c1);
}
} else if (strcmp(c1, m) != 0) {
int _flag = 0;
for (j = 0; j < p; j++) {
if (strcmp(s[j], c1) == 0) {
_flag = 1;
if (strcmp(c2, "posted") == 0) a[j] += 15;
if (strcmp(c2, "commented") == 0) a[j] += 10;
if (strcmp(c2, "likes") == 0) a[j] += 5;
}
}
if (_flag == 0) {
strcpy(s[p], c1);
if (strcmp(c2, "posted") == 0) a[p] += 15;
if (strcmp(c2, "commented") == 0) a[p] += 10;
if (strcmp(c2, "likes") == 0) a[p] += 5;
p++;
}
} else if (strcmp(c4, m) != 0) {
int _flag = 0;
for (j = 0; j < p; j++) {
if (strcmp(s[j], c4) == 0) {
_flag = 1;
if (strcmp(c2, "posted") == 0) a[j] += 15;
if (strcmp(c2, "commented") == 0) a[j] += 10;
if (strcmp(c2, "likes") == 0) a[j] += 5;
}
}
if (_flag == 0) {
strcpy(s[p], c4);
if (strcmp(c2, "posted") == 0) a[j] += 15;
if (strcmp(c2, "commented") == 0) a[j] += 10;
if (strcmp(c2, "likes") == 0) a[j] += 5;
p++;
}
}
}
int vis[300];
memset(vis, 0, sizeof(vis));
for (i = 0; i < p; i++) {
int mx = -1;
int q = 0;
for (j = 0; j < p; j++) {
if (!vis[j]) {
if (mx < a[j]) {
mx = a[j];
q = j;
} else if (mx == a[j]) {
if (strcmp(s[q], s[j]) > 0) {
mx = a[j];
q = j;
}
}
}
}
vis[q] = 1;
printf("%s\n", s[q]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<vector<pair<int, int> > > v(100005);
vector<int> set1;
vector<int> set2;
vector<int> ans1;
vector<int> ans2;
int s1, s2;
int visited[100005];
void input() {
int i, j, a, b;
string s;
scanf("%d %d", &n, &m);
for (i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
cin >> s;
s[0] == 'B' ? v[a].push_back(pair<int, int>(b, 0))
: v[a].push_back(pair<int, int>(b, 1));
s[0] == 'B' ? v[b].push_back(pair<int, int>(a, 0))
: v[b].push_back(pair<int, int>(a, 1));
}
}
bool dfs(int start) {
visited[start] == 0 ? set1.push_back(start) : set2.push_back(start);
int i, next, edge;
for (i = 0; i < v[start].size(); i++) {
next = v[start][i].first;
edge = v[start][i].second;
if (visited[next] == -1) {
visited[next] = (visited[start] ^ edge);
if (!dfs(next)) return false;
} else if (visited[next] != (visited[start] ^ edge)) {
return false;
}
}
return true;
}
void flip() {
int i, j;
for (i = 1; i <= n; i++) {
for (j = 0; j < v[i].size(); j++) v[i][j].second = 1 - v[i][j].second;
}
}
int main() {
int i, j;
input();
memset(visited, -1, sizeof(visited));
for (i = 1; i <= n; i++) {
if (visited[i] == -1) {
visited[i] = 0;
set1.clear();
set2.clear();
if (!dfs(i)) {
s1 = -1;
break;
}
if (set1.size() < set2.size()) {
for (j = 0; j < set1.size(); j++) ans1.push_back(set1[j]);
} else {
for (j = 0; j < set2.size(); j++) ans1.push_back(set2[j]);
}
}
}
flip();
memset(visited, -1, sizeof(visited));
for (i = 1; i <= n; i++) {
if (visited[i] == -1) {
visited[i] = 0;
set1.clear();
set2.clear();
if (!dfs(i)) {
s2 = -1;
break;
}
if (set1.size() < set2.size()) {
for (j = 0; j < set1.size(); j++) ans2.push_back(set1[j]);
} else {
for (j = 0; j < set2.size(); j++) ans2.push_back(set2[j]);
}
}
}
if (s1 == -1 && s2 == -1) {
printf("%d\n", -1);
} else if (s1 == -1) {
cout << ans2.size() << endl;
for (i = 0; i < ans2.size(); i++) cout << ans2[i] << " ";
cout << endl;
} else if (s2 == -1) {
cout << ans1.size() << endl;
for (i = 0; i < ans1.size(); i++) cout << ans1[i] << " ";
cout << endl;
} else if (ans2.size() < ans1.size()) {
cout << ans2.size() << endl;
for (i = 0; i < ans2.size(); i++) cout << ans2[i] << " ";
cout << endl;
} else {
cout << ans1.size() << endl;
for (i = 0; i < ans1.size(); i++) cout << ans1[i] << " ";
cout << endl;
}
return 0;
}
| 7 |
//Original Code:
//#include <self/utility>
//#include <self/debug>
//using namespace std;
//int n;
//char c[100005];
//int b[100005];
//int a[100005];
//
//int push(int len,int k,vector<int> &v)
//{
// if(k==0) return (len==1);
// if(k==1)
// {
// if(len%2==0) return false;
// for(int i=1;i<len;i+=2) v.push_back(1);
// return true;
// }
// if(k>=2)
// {
// if(len==2) return false;
// if(len%2==0)
// {
// len-=3;
// v.push_back(2);
// }
// for(int i=1;i<len;i+=2) v.push_back(1);
// return true;
// }
// assert(false);return false;
//}
//
//void test(int k)
//{
// if(k>n) return;
// for(int i=0;i<k;i++)
// {
// if(c[n-1-i]=='#') return;
// }
// memset(b,0,sizeof(b));
// memset(a,0,sizeof(a));
// int st=-1;
// for(int i=0;i<n;i++)
// {
// if(c[i]=='#' && st==-1)
// {
// st=i;
// }
// if(c[i]=='_' && st!=-1)
// {
// if(st-k-1>=0) a[st-k-1]++;
// if(st-k<0) return;
// for(int j=st-k;j<i;j++)
// {
// b[j]++;
// }
// st=-1;
// }
// }
// if(st!=-1)
// {
// if(st-k-1>=0) a[st-k-1]++;
// if(st-k<0) return;
// for(int j=st-k;j<n;j++)
// {
// b[j]++;
// }
// st=-1;
// }
// for(int i=0;i<n;i++)
// {
// if(b[i]+a[i]>1) return;
// }
// // for(int i=0;i<n;i++)
// // {
// // cout<<b[i]<<' ';
// // }
// // cout<<endl;
// vector<pii> v;
// for(int i=0;i<n;)
// {
// int j=i;
// int now=b[i];
// while(i<n && b[i]==now) i++;
// v.push_back(mp(i-j,now));
// }
// assert(v.back().first>=k);
// if(v.back().second==0) v.back().first-=k-1;
// if(v.front().second==0) v.front().first++;
// vector<int> res;
// for(int i=0;i<(int)v.size();i++)
// {
// int len=v[i].first,c=v[i].second;
// if(c==1)
// {
// res.push_back(len);
// continue;
// }
// else
// {
// if(!push(len,k,res)) return;
// }
// }
// // debug(k);
// cout<<res.size()<<endl;
// for(auto x:res)
// {
// cout<<x<<' ';
// }
// cout<<endl;
// exit(0);
//}
//
//int main()
//{
// // freopen("input.txt","r",stdin);
// scanf("%s",c);
// n=strlen(c);
// if(none_of(c,c+n,[](const char &c){return c=='#';})) over(0);
// test(0);
// test(1);
// test(2);
// test(3);
// puts("-1");
// return 0;
//}
//substituted with C++ Inliner
#ifndef _SELF_UTILITY
#define _SELF_UTILITY 1
#include <numeric>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <string.h>
#include <stack>
#include <assert.h>
#include <bitset>
#include <time.h>
#define Endl endl
#define mp make_pair
#define mt make_tuple
#define ll long long
#define ull unsigned long long
#define pii pair<int,int>
#define over(A) {cout<<A<<endl;exit(0);}
#define all(A) A.begin(),A.end()
#define quickcin ios_base::sync_with_stdio(false);
#ifdef __TAKE_MOD
int mod;
#else
#ifdef __TAKE_CONST_MOD
const int mod=__TAKE_CONST_MOD;
#else
const int mod=1000000007;
#endif
#endif
const int gmod=3;
const int inf=1039074182;
const double eps=1e-9;
const ll llinf=2LL*inf*inf;
template <typename T1,typename T2> inline void chmin(T1 &x,T2 b) {if(b<x) x=b;}
template <typename T1,typename T2> inline void chmax(T1 &x,T2 b) {if(b>x) x=b;}
inline void chadd(int &x,int b) {x+=b-mod;x+=(x>>31 & mod);}
template <typename T1,typename T2> inline void chadd(T1 &x,T2 b) {x+=b;if(x>=mod) x-=mod;}
template <typename T1,typename T2> inline void chmul(T1 &x,T2 b) {x=1LL*x*b%mod;}
template <typename T1,typename T2> inline void chmod(T1 &x,T2 b) {x%=b,x+=b;if(x>=b) x-=b;}
template <typename T> inline T mabs(T x) {return (x<0?-x:x);}
using namespace std;
#endif
#ifndef _SELF_DEBUG
#define _SELF_DEBUG 1
#ifndef _SELF_OPERATOR
#define _SELF_OPERATOR 1
using namespace std;
template <typename T>
ostream &operator<<(ostream &cout, vector<T> vec)
{
cout << "{";
for (int i = 0; i < (int)vec.size(); i++)
{
cout << vec[i];
if (i != (int)vec.size() - 1)
cout << ',';
}
cout << "}";
return cout;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &cout, pair<T1, T2> p)
{
cout << "(" << p.first << ',' << p.second << ")";
return cout;
}
template <typename T, typename T2>
ostream &operator<<(ostream &cout, set<T, T2> s)
{
vector<T> t;
for (auto x : s)
t.push_back(x);
cout << t;
return cout;
}
template <typename T, typename T2>
ostream &operator<<(ostream &cout, multiset<T, T2> s)
{
vector<T> t;
for (auto x : s)
t.push_back(x);
cout << t;
return cout;
}
template <typename T>
ostream &operator<<(ostream &cout, queue<T> q)
{
vector<T> t;
while (q.size())
{
t.push_back(q.front());
q.pop();
}
cout << t;
return cout;
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &cout, map<T1, T2, T3> m)
{
for (auto &x : m)
{
cout << "Key: " << x.first << ' ' << "Value: " << x.second << endl;
}
return cout;
}
template <typename T1, typename T2>
void operator+=(pair<T1, T2> &x,const pair<T1, T2> y)
{
x.first += y.first;
x.second += y.second;
}
template <typename T1,typename T2>
pair<T1,T2> operator + (const pair<T1,T2> &x,const pair<T1,T2> &y)
{
return make_pair(x.first+y.first,x.second+y.second);
}
template <typename T1,typename T2>
pair<T1,T2> operator - (const pair<T1,T2> &x,const pair<T1,T2> &y)
{
return mp(x.first-y.first,x.second-y.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(pair<T1, T2> x)
{
return make_pair(-x.first, -x.second);
}
template <typename T>
vector<vector<T>> operator~(vector<vector<T>> vec)
{
vector<vector<T>> v;
int n = vec.size(), m = vec[0].size();
v.resize(m);
for (int i = 0; i < m; i++)
{
v[i].resize(n);
}
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
v[i][j] = vec[j][i];
}
}
return v;
}
#endif
#include <sstream>
void print0x(int x)
{
std::vector <int> vec;
while(x)
{
vec.push_back(x&1);
x>>=1;
}
std::reverse(vec.begin(),vec.end());
for(int i=0;i<(int)vec.size();i++)
{
std::cout<<vec[i];
}
std::cout<<' ';
}
template <typename T>
void print0x(T x,int len)
{
std::vector <int> vec;
while(x)
{
vec.push_back(x&1);
x>>=1;
}
reverse(vec.begin(),vec.end());
for(int i=(int)vec.size();i<len;i++)
{
putchar('0');
}
for(size_t i=0;i<vec.size();i++)
{
std::cout<<vec[i];
}
std::cout<<' ';
}
vector<string> vec_splitter(string s) {
s += ',';
vector<string> res;
while(!s.empty()) {
res.push_back(s.substr(0, s.find(',')));
s = s.substr(s.find(',') + 1);
}
return res;
}
void debug_out(
vector<string> __attribute__ ((unused)) args,
__attribute__ ((unused)) int idx,
__attribute__ ((unused)) int LINE_NUM) { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(vector<string> args, int idx, int LINE_NUM, Head H, Tail... T) {
if(idx > 0) cerr << ", "; else cerr << "Line(" << LINE_NUM << ") ";
stringstream ss; ss << H;
cerr << args[idx] << " = " << ss.str();
debug_out(args, idx + 1, LINE_NUM, T...);
}
#define debug(...) debug_out(vec_splitter(#__VA_ARGS__), 0, __LINE__, __VA_ARGS__)
#endif
using namespace std;
int n;
char c[100005];
int b[100005];
int a[100005];
int push(int len,int k,vector<int> &v)
{
if(k==0) return (len==1);
if(k==1)
{
if(len%2==0) return false;
for(int i=1;i<len;i+=2) v.push_back(1);
return true;
}
if(k>=2)
{
if(len==2) return false;
if(len%2==0)
{
len-=3;
v.push_back(2);
}
for(int i=1;i<len;i+=2) v.push_back(1);
return true;
}
assert(false);return false;
}
void test(int k)
{
if(k>n) return;
for(int i=0;i<k;i++)
{
if(c[n-1-i]=='#') return;
}
memset(b,0,sizeof(b));
memset(a,0,sizeof(a));
int st=-1;
for(int i=0;i<n;i++)
{
if(c[i]=='#' && st==-1)
{
st=i;
}
if(c[i]=='_' && st!=-1)
{
if(st-k-1>=0) a[st-k-1]++;
if(st-k<0) return;
for(int j=st-k;j<i;j++)
{
b[j]++;
}
st=-1;
}
}
if(st!=-1)
{
if(st-k-1>=0) a[st-k-1]++;
if(st-k<0) return;
for(int j=st-k;j<n;j++)
{
b[j]++;
}
st=-1;
}
for(int i=0;i<n;i++)
{
if(b[i]+a[i]>1) return;
}
// for(int i=0;i<n;i++)
// {
// cout<<b[i]<<' ';
// }
// cout<<endl;
vector<pii> v;
for(int i=0;i<n;)
{
int j=i;
int now=b[i];
while(i<n && b[i]==now) i++;
v.push_back(mp(i-j,now));
}
assert(v.back().first>=k);
if(v.back().second==0) v.back().first-=k-1;
if(v.front().second==0) v.front().first++;
vector<int> res;
for(int i=0;i<(int)v.size();i++)
{
int len=v[i].first,c=v[i].second;
if(c==1)
{
res.push_back(len);
continue;
}
else
{
if(!push(len,k,res)) return;
}
}
// debug(k);
cout<<res.size()<<endl;
for(auto x:res)
{
cout<<x<<' ';
}
cout<<endl;
exit(0);
}
int main()
{
// // freopen("input.txt","r",stdin);
scanf("%s",c);
n=strlen(c);
if(none_of(c,c+n,[](const char &c){return c=='#';})) over(0);
test(0);
test(1);
test(2);
test(3);
puts("-1");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
struct FAIL {
FAIL() {
cout << "CHANGE!!!"
<< "\n";
}
};
bool next(vector<int> &v, int m) {
int j = v.size() - 1;
++v[j];
while (j > 0 && v[j] == m) {
v[j] = 0;
--j;
++v[j];
}
if (v[j] == m) {
return false;
}
return true;
}
int go(const vector<int> &v, int m) {
vector<int> used(m);
for (int i = (0); i < (v.size()); ++i) {
int place = v[i] / 2;
int dir = v[i] % 2;
int ok = 0;
if (dir == 0) {
for (int i = (place); i < (m); ++i) {
if (!used[i]) {
used[i] = 1;
ok = 1;
break;
}
}
} else {
for (int i = (place); i > (-1); --i) {
if (!used[i]) {
used[i] = 1;
ok = 1;
break;
}
}
}
if (!ok) {
return 0;
}
}
return 1;
}
int main() {
int n, m;
cin >> n >> m;
swap(n, m);
long long d = m - n;
long long res = 2 * (d + 1);
for (int i = (0); i < (n - 1); ++i) {
res *= 2;
res %= MOD;
}
for (int i = (0); i < (n - 1); ++i) {
res *= (n + d + 1);
res %= MOD;
}
cout << res;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,sse4,popcnt,abm,mmx")
using namespace std;
const int N = 3e5 + 111, inf = 1e9, mod = 1e9 + 7;
const long long linf = 1e18;
int a[N], n, le, re, odd, even, lo, ro;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
a[0] = max(a[0], a[i]);
}
if (n == 1) {
printf("%d", a[1]);
return 0;
}
if (n % 2 == 1) {
even = a[n / 2 + 1];
lo = n / 2 + 1, ro = n / 2 + 1;
le = n / 2 + 1, re = n / 2 + 1;
} else {
odd = min(a[n / 2], a[n / 2 + 1]);
le = n / 2 + 1, re = n / 2;
lo = n / 2, ro = n / 2 + 1;
}
for (int i = 1; i <= n - 2; ++i) {
if ((n - i) % 2 == 0) {
lo--, ++ro;
odd = max(odd, max(min(a[lo], a[lo + 1]), min(a[ro], a[ro - 1])));
printf("%d ", odd);
} else {
le--, ++re;
even = max(even, max(a[le], a[re]));
printf("%d ", even);
}
}
printf("%d %d", a[0], a[0]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, t, a, b, c, sum, x, y, tik;
int fa[200005];
struct edge {
int u, v, w;
} e[200005];
int cmp(edge a, edge b) { return a.w < b.w; }
int findset(int x) {
int r = x;
while (r != fa[r]) r = fa[r];
int i, j;
i = x;
while (i != r) {
j = fa[i];
fa[i] = r;
i = j;
}
return r;
}
int main() {
scanf("%d%d", &n, &m);
sum = 0;
for (int i = 1; i <= m; i++) scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
for (int i = 1; i <= n; i++) fa[i] = i;
sort(e + 1, e + m + 1, cmp);
tik = 0;
for (int i = 1, j = 1; i <= m; i = j) {
while (j <= m && e[j].w == e[i].w) ++j;
int cnt = j - i;
for (int k = i; k < j; k++) {
int x = findset(e[k].u);
int y = findset(e[k].v);
if (x == y) cnt--;
}
for (int k = i; k < j; k++) {
int x = findset(e[k].u);
int y = findset(e[k].v);
if (x == y) continue;
cnt--;
fa[x] = y;
}
sum += cnt;
}
printf("%d\n", sum);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
long long ans = 0;
long long num, k = 10;
scanf("%I64d", &num);
for (int i = 1; i <= 9; i++, k = k * 10) {
if (num >= k)
ans += (k - (k / 10)) * i;
else {
ans += (num - (k / 10) + 1) * i;
break;
}
}
if (num == 1e9) ans += 10;
printf("%I64d", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long p[40];
long long C(long long n, long long m) { return p[n] / p[n - m] / p[m]; }
long long n, b[40], a[40], cnt[40];
long long calc() {
memset(cnt, 0, sizeof(cnt));
for (long long i = 1; i < n; i++) cnt[b[i]]++;
long long ans = 1;
for (long long i = n - 1; i; i--) {
if (b[i] == 0) continue;
if (i == n - 1 || b[i] != b[i + 1]) {
if (i - b[i] + 1 < cnt[b[i]]) return 0;
ans *= C(i - b[i] + 1, cnt[b[i]]);
}
}
return ans;
}
void sol(long long x) {
n = 0;
while (x) {
n++;
a[n] = x % (n + 1);
x /= n + 1;
}
long long ans = 0;
sort(a + 1, a + n + 1);
for (long long i = 1; i <= n; i++) {
if (a[i] && a[i] != a[i - 1]) {
b[n] = a[i];
for (long long j = 1, cc = 0; j <= n; j++) {
if (i == j) continue;
b[++cc] = a[j];
}
sort(b + 1, b + n);
ans += calc();
}
}
printf("%lld\n", ans - 1);
}
signed main() {
p[0] = 1;
for (long long i = 1; i <= 20; i++) p[i] = p[i - 1] * i;
long long T;
scanf("%lld", &T);
while (T--) {
long long x;
scanf("%lld", &x);
sol(x);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string str[3];
bool flag;
int b[100010];
void KMPBuild(string pattern) {
int i = 0, j = -1, m = pattern.length();
b[0] = -1;
while (i < m) {
while (j >= 0 && pattern[j] != pattern[i]) j = b[j];
i++;
j++;
b[i] = j;
}
}
int KMP(string pattern, string source, int n) {
int i = 0, j = 0;
int m = source.length();
while (i < m) {
while (j >= 0 && source[i] != pattern[j]) j = b[j];
i++;
j++;
if (j == pattern.length()) {
if (i == m) flag = true;
if (n) return j;
j = b[j];
}
}
return j;
}
int main() {
getline(cin, str[0]);
getline(cin, str[1]);
getline(cin, str[2]);
int maxx = 400000;
flag = false;
int aux = str[0].length();
KMPBuild(str[1]);
int aux2 = KMP(str[1], str[0], 1);
KMPBuild(str[2]);
int aux3;
if (aux2 == str[1].length() && !flag) {
aux3 = KMP(str[2], str[0], 1);
} else
aux3 = KMP(str[2], str[1], 1);
int aux4 = aux + str[1].size() - aux2 + str[2].size() - aux3;
maxx = min(maxx, aux4);
flag = false;
aux = str[0].length();
aux2 = KMP(str[2], str[0], 1);
KMPBuild(str[1]);
if (aux2 == str[2].length() && !flag) {
aux3 = KMP(str[1], str[0], 1);
} else
aux3 = KMP(str[1], str[2], 1);
aux4 = aux + str[2].length() - aux2 + str[1].length() - aux3;
maxx = min(maxx, aux4);
flag = false;
aux = str[1].length();
KMPBuild(str[0]);
aux2 = KMP(str[0], str[1], 1);
KMPBuild(str[2]);
if (aux2 == str[0].length() && !flag) {
aux3 = KMP(str[2], str[1], 1);
} else
aux3 = KMP(str[2], str[0], 1);
aux4 = aux + str[0].length() - aux2 + str[2].length() - aux3;
maxx = min(maxx, aux4);
flag = false;
aux = str[1].length();
aux2 = KMP(str[2], str[1], 1);
KMPBuild(str[0]);
if (aux2 == str[2].length() && !flag) {
aux3 = KMP(str[0], str[1], 1);
} else
aux3 = KMP(str[0], str[2], 1);
aux4 = aux + str[2].length() - aux2 + str[0].length() - aux3;
maxx = min(maxx, aux4);
flag = false;
aux = str[2].length();
KMPBuild(str[0]);
aux2 = KMP(str[0], str[2], 1);
KMPBuild(str[1]);
if (aux2 == str[0].length() && !flag) {
aux3 = KMP(str[1], str[2], 1);
} else
aux3 = KMP(str[1], str[0], 1);
aux4 = aux + str[0].length() - aux2 + str[1].length() - aux3;
maxx = min(maxx, aux4);
flag = false;
aux = str[2].length();
aux2 = KMP(str[1], str[2], 1);
KMPBuild(str[0]);
if (aux2 == str[1].length() && !flag) {
aux3 = KMP(str[0], str[2], 1);
} else
aux3 = KMP(str[0], str[1], 1);
aux4 = aux + str[1].length() - aux2 + str[0].length() - aux3;
maxx = min(maxx, aux4);
cout << maxx << endl;
return 0;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.