solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
while (cin >> a >> b >> c) {
int sum = 0;
while (1) {
if (a == 0) break;
if (a * 2 <= b)
if (a * 4 <= c) {
sum = a + (a * 2) + (a * 4);
break;
}
a--;
}
cout << sum << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int num[300];
int main() {
int n, a, minn = 99999, sum = 0, sum2 = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
for (int i = 1; i <= n; i++) sum += abs(num[i]);
printf("%d\n", sum);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
scanf("%d", &T);
while (T--) {
int L, v, l, r;
scanf("%d%d%d%d", &L, &v, &l, &r);
int sum = 0, i;
int S = L / v;
if (l % v == 0)
i = l;
else
i = (l / v + 1) * v;
if (i > r) {
printf("%d\n", S);
continue;
} else if (i == r) {
printf("%d\n", S - 1);
} else {
sum = (r - i) / v + 1;
printf("%d\n", S - sum);
}
}
}
| 1 |
#include <bits/stdc++.h>
int64_t solve(int64_t ts, int64_t tf, int64_t t,
const std::vector<int64_t> &v) {
if (v.empty()) return ts;
int64_t min_wait = std::numeric_limits<int64_t>::max();
int64_t res = -1;
if (v[0] > 0) {
if (ts < v[0]) return ts;
min_wait = std::max<int64_t>(0, ts - v[0] + 1);
res = v[0] - 1;
}
for (int i = 0; i + 1 < (int)v.size();) {
int j = i;
while (j < (int)v.size() && v[j] == v[i]) ++j;
ts = std::max(ts, v[i]);
int64_t d = (j - i) * t;
if (ts + d + t > tf) break;
int64_t c = std::min(ts + d, v[j] - 1);
if (ts + d - c < min_wait) {
min_wait = ts + d - c;
res = c;
}
ts += d;
i = j;
}
return res;
}
int main() {
int64_t ts, tf, t;
int n;
std::cin >> ts >> tf >> t >> n;
std::vector<int64_t> v(n + 1);
for (int i = 0; i < n; ++i) std::cin >> v[i];
v[n] = std::numeric_limits<int64_t>::max();
std::cout << solve(ts, tf, t, v) << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int T = 1;
while (T--) {
long long int hr1, mn1, hr2, mn2;
char c;
cin >> c;
hr1 = (c - '0') * 10;
cin >> c;
hr1 += (c - '0');
cin >> c;
cin >> c;
mn1 = (c - '0') * 10;
cin >> c;
mn1 += (c - '0');
cin >> c;
hr2 = (c - '0') * 10;
cin >> c;
hr2 += (c - '0');
cin >> c;
cin >> c;
mn2 = (c - '0') * 10;
cin >> c;
mn2 += (c - '0');
cin >> c;
long long int difmin = ((hr2 - hr1) * 60 + (mn2 - mn1)) / 2;
hr1 += (difmin) / 60;
mn1 += difmin % 60;
if (mn1 >= 60) {
hr1 += mn1 / 60;
mn1 %= 60;
}
if (hr1 < 10)
cout << 0 << hr1 << ":";
else
cout << hr1 << ":";
if (mn1 < 10)
cout << 0 << mn1;
else
cout << mn1;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct str {
int v, nex;
} edge[2010000];
int fst[2010000], first[2010000], nex[2010000];
int lk[2010000], rk[2010000], size[2010000], dep[201000], fa[201000],
st[101000][22];
int root[2010000];
int e, n, m, q, top, ans[210];
void make_edge(int a, int b) {
edge[++e].nex = fst[a];
fst[a] = e;
edge[e].v = b;
edge[++e].nex = fst[b];
fst[b] = e;
edge[e].v = a;
}
void build(int L, int R, int val, int pas, int u) {
size[u] = size[pas] + 1;
if (L == R) return;
int mid = (L + R) >> 1;
if (val <= mid) {
lk[u] = ++top;
rk[u] = rk[pas];
build(L, mid, val, lk[pas], lk[u]);
} else {
rk[u] = ++top;
lk[u] = lk[pas];
build(mid + 1, R, val, rk[pas], rk[u]);
}
}
void dfs(int u) {
dep[u] = dep[fa[u]] + 1;
int pas = root[fa[u]];
for (int i = first[u]; i; i = nex[i]) {
root[u] = ++top;
build(1, m, i, pas, root[u]);
pas = root[u];
}
root[u] = pas;
for (int i = fst[u]; i; i = edge[i].nex) {
int v = edge[i].v;
if (fa[u] == v) continue;
fa[v] = u;
dfs(v);
}
return;
}
void prepare() {
for (int i = 1; i <= n; i++) st[i][0] = fa[i];
for (int j = 1; j <= 20; j++)
for (int i = 1; i <= n; i++) st[i][j] = st[st[i][j - 1]][j - 1];
}
int lca(int a, int b) {
if (dep[a] < dep[b]) swap(a, b);
int i;
for (i = 19; i >= 0 && !st[a][i]; i--)
;
while (dep[a] != dep[b]) {
for (; dep[st[a][i]] < dep[b] && i > 0; i--)
;
a = st[a][i];
}
for (i = 19; i >= 0 && !st[a][i]; i--)
;
while (a != b) {
for (; i >= 0 && st[a][i] == st[b][i]; i--)
;
if (i < 0)
a = fa[a], b = fa[b];
else
a = st[a][i], b = st[b][i];
}
return a;
}
int ask(int L, int R, int a, int b, int c, int d, int k) {
if (k > size[a] + size[b] - size[c] - size[d]) return 0;
if (L == R) return L;
int js = size[lk[a]] + size[lk[b]] - size[lk[c]] - size[lk[d]];
int mid = (L + R) >> 1;
if (js >= k)
return ask(L, mid, lk[a], lk[b], lk[c], lk[d], k);
else
return ask(mid + 1, R, rk[a], rk[b], rk[c], rk[d], k - js);
}
int query(int a, int b, int k) {
int c = lca(a, b), d = fa[c];
return (ask(1, m, root[a], root[b], root[c], root[d], k));
}
int main() {
scanf("%d %d %d", &n, &m, &q);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
make_edge(a, b);
}
for (int i = 1; i <= m; i++) {
int a;
scanf("%d", &a);
nex[i] = first[a];
first[a] = i;
}
dfs(1);
prepare();
for (; q; q--) {
top = 0;
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
ans[0] = 0;
int k;
while (top < c && ((k = query(a, b, top + 1)) != 0)) ans[++top] = k;
printf("%d ", top);
for (int i = 1; i < top; i++) printf("%d ", ans[i]);
if (top > 0)
printf("%d\n", ans[top]);
else
putchar('\n');
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt, num_1, root;
vector<int> e[(101 * 1000)], ans;
bool a[(101 * 1000)], mark[(101 * 1000)];
void dfs(int x, int par = 0) {
if (a[x]) num_1--;
mark[x] = 1;
ans.push_back(x);
a[x] = !a[x];
cnt++;
for (int i = 0; i < e[x].size(); i++)
if (!mark[e[x][i]]) {
dfs(e[x][i], x);
ans.push_back(x), a[x] = !a[x];
}
if (x == root && a[x]) ans.pop_back(), a[x] = !a[x];
if (a[x])
a[x] = !a[x], a[par] = !a[par], ans.push_back(par), ans.push_back(x);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int v, u;
scanf("%d%d", &v, &u);
e[v].push_back(u);
e[u].push_back(v);
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i]) num_1++;
}
for (int i = 1; i <= n; i++)
if (a[i]) {
root = i;
dfs(i);
break;
}
if (cnt != n && num_1) return cout << -1, 0;
printf("%d\n", (int)ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
template <typename T>
ostream &operator+(ostream &out, const vector<T> &vec) {
for (const auto &x : vec) {
out << x << " ";
}
out << "\n";
return out;
}
template <typename T>
ostream &operator*(ostream &out, const vector<T> &vec) {
for (const auto &x : vec) {
out + x;
}
return out;
}
template <typename T>
istream &operator>>(istream &in, vector<T> &vec) {
for (auto &x : vec) {
in >> x;
}
return in;
}
const int p = 1e9 + 7;
ll modpower(ll base, ll power, ll mod = p) {
ll ans = 1;
base %= mod;
while (power) {
if (power & 1) {
ans *= base;
ans %= mod;
}
base *= base;
base %= mod;
power >>= 1;
}
return ans;
}
vector<ll> fact;
vector<ll> invfact;
void computefactorial(int n) {
++n;
fact.resize(n);
invfact.resize(n);
fact[0] = 1;
for (int i = 1; i < n; i++) {
fact[i] = i * fact[i - 1];
fact[i] %= p;
}
invfact[n - 1] = modpower(fact[n - 1], p - 2);
for (int i = n - 2; i >= 0; i--) {
invfact[i] = (i + 1) * invfact[i + 1];
invfact[i] %= p;
}
}
ll ncr(int n, int r) {
if (n < 0 || r > n) return 0;
return fact[n] * invfact[n - r] % p * invfact[r] % p;
}
struct Snake {
int x, y, b;
Snake(int x, int y, int b) : x(x), y(y), b(b) {}
Snake() {}
};
const int MAXN = 2e3 + 7;
void solve() {
int n, m, r;
cin >> n >> m >> r;
vector<Snake> snakes(n);
for (auto &[x, y, b] : snakes) {
cin >> x >> y >> b;
}
ll ans = 0;
vector<bitset<MAXN>> seq(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
seq[i][j] = (max(abs(snakes[i].x - snakes[j].x),
abs(snakes[i].y - snakes[j].y)) <= r);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (i == j) continue;
int c1 = seq[i].count();
int c2 = seq[j].count();
int cnt = (seq[i] | seq[j]).count();
ll ways = ncr(n, m) - ncr(n - c1, m) - ncr(n - c2, m) + ncr(n - cnt, m);
ways %= p;
ways *= 2 * snakes[i].b;
ways %= p;
ways *= snakes[j].b;
ways %= p;
ans += ways;
ans %= p;
}
int cnt = seq[i].count();
ans += (ncr(n, m) - ncr(n - cnt, m)) * snakes[i].b % p * snakes[i].b % p;
ans %= p;
}
if (ans < 0) ans += p;
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
computefactorial(2e3 + 7);
solve();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int const N = 1e3 + 9;
int com[N][N], comh[N][N];
int n, m;
char arr[N][N];
inline void makeCom() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (arr[i][j] == arr[i][j - 1])
com[i][j] = com[i][j - 1] + 1;
else
com[i][j] = 1;
}
}
}
inline void makeComh() {
for (int j = 1; j <= m; j++) {
for (int i = 1; i <= n; i++) {
if (arr[i][j] == arr[i - 1][j])
comh[i][j] = comh[i - 1][j] + 1;
else
comh[i][j] = 1;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", arr[i] + 1);
}
makeCom();
makeComh();
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int last = comh[i][j];
if (3 * last > i) continue;
int mid = comh[i - last][j];
if (last != mid) continue;
int first = comh[i - mid - last][j];
if (first < mid) continue;
int mn = 1e9;
for (int k = 0; k < 3 * last; k++) {
mn = min(mn, com[i - k][j]);
}
ans += mn;
}
}
printf("%lld", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, a, x, b, y;
cin >> n >> a >> x >> b >> y;
a--, x--, b--, y--;
while (true) {
if (a == b) {
cout << "YES\n";
return 0;
}
if (a == x || b == y) {
break;
}
a = (a + 1) % n;
b = (b - 1 + n) % n;
}
cout << "NO\n";
}
| 0 |
#include <bits/stdc++.h>
const long long Inf = 1e18;
const long double eps = 1e-7;
long long LINF = (long long)2e18;
using namespace std;
long long mod = 1e9 + 7;
long long mod5 = 1e9 + 9;
long long mod3 = 998244353;
long long mod4 = 1000003;
long long mod2 = 1e9 + 123;
const int MAXN = 4000001;
const int INF = 1000000000;
int n, r;
vector<pair<int, int> > xy;
struct Tree {
vector<long long> lazy;
vector<long long> t;
Tree(int n) {
t.resize(4 * n);
lazy.resize(4 * n, 0);
}
void push(int v, int tl, int tr) {
t[v] += lazy[v];
if (tl != tr) {
lazy[2 * v] += lazy[v];
lazy[2 * v + 1] += lazy[v];
}
lazy[v] = 0;
}
void update(int v, int tl, int tr, int l, int r, int x) {
push(v, tl, tr);
if (l == tl && r == tr) {
lazy[v] += x;
push(v, tl, tr);
return;
}
int tm = (tl + tr) / 2;
if (r <= tm) {
update(2 * v, tl, tm, l, r, x);
push(2 * v + 1, tm + 1, tr);
} else if (l > tm) {
update(2 * v + 1, tm + 1, tr, l, r, x);
push(2 * v, tl, tm);
} else {
update(2 * v, tl, tm, l, tm, x);
update(2 * v + 1, tm + 1, tr, tm + 1, r, x);
}
t[v] = max(t[2 * v], t[2 * v + 1]);
}
long long mx(int v, int tl, int tr, int l, int r) {
push(v, tl, tr);
if (l == tl && r == tr) {
return t[v];
}
int tm = (tl + tr) / 2;
if (r <= tm)
return mx(2 * v, tl, tm, l, r);
else if (l > tm)
return mx(2 * v + 1, tm + 1, tr, l, r);
else {
return max(mx(2 * v, tl, tm, l, tm),
mx(2 * v + 1, tm + 1, tr, tm + 1, r));
}
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
cin >> n >> r;
xy.resize(n);
int mn = 1e9;
for (int(i) = 0; (i) < n; (i)++) {
int x, y;
cin >> x >> y;
xy[i].first = x + y;
xy[i].second = x - y;
mn = min(mn, xy[i].second);
}
for (int(i) = 0; (i) < n; (i)++) {
xy[i].second -= mn;
}
sort((xy).begin(), (xy).end());
int itl = 0, itr = 0;
r *= 2;
long long ans = 0;
Tree t(MAXN);
while (itl != n) {
if (itr < n && xy[itr].first - xy[itl].first <= r) {
t.update(1, 0, MAXN - 1, max(0, xy[itr].second - r), xy[itr].second, 1);
ans = max(ans, t.mx(1, 0, MAXN - 1, 0, MAXN - 1));
itr++;
} else {
t.update(1, 0, MAXN - 1, max(0, xy[itl].second - r), xy[itl].second, -1);
itl++;
}
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void Gcd(long long x, long long y, long long mod, long long& kx,
long long& ky) {
if (y == 0) return void(kx = ky = 1);
long long del = x / y;
Gcd(y, x - del * y, mod, ky, kx);
(ky -= del * kx) %= mod;
}
long long Oem(long long x, long long mod) {
long long kx, ky;
Gcd(x, mod, mod, kx, ky);
return kx % mod;
}
long long Solve(long long a1, long long m1, long long a2, long long m2) {
long long koef = ((a2 - a1) * Oem(m1, m2)) % m2;
return (a1 + koef * m1) % (m1 * m2);
}
long long SolveSystem(vector<long long> a, vector<long long> m) {
while (((int)(a).size()) > 1) {
long long a1, a2, m1, m2;
a1 = a[((int)(a).size()) - 1], a2 = a[((int)(a).size()) - 2];
m1 = m[((int)(m).size()) - 1], m2 = m[((int)(m).size()) - 2];
a.pop_back(), a.pop_back();
m.pop_back(), m.pop_back();
a.push_back(Solve(a1, m1, a2, m2));
m.push_back(m1 * m2);
}
return (a[0] + m[0]) % m[0];
}
long long n, p, l, r;
long long mod, prime, deg;
vector<pair<long long, long long>> fact;
long long Comb(long long n, long long k) {
if (k < 0 || k > n) return 0;
auto a = fact[n];
auto b = fact[k];
auto c = fact[n - k];
long long rem = a.second - b.second - c.second;
if (rem >= deg) return 0;
long long res = 1;
while (rem-- > 0) (res *= prime) %= mod;
(res *= a.first) %= mod;
(res *= Oem(b.first, mod)) %= mod;
(res *= Oem(c.first, mod)) %= mod;
return res;
}
void Init(int up) {
fact.resize(up + 1);
fact[0] = make_pair(1, 0);
for (int i = 1; i < ((int)(fact).size()); ++i) {
fact[i] = fact[i - 1];
int j = i;
while (j % prime == 0) j /= prime, ++fact[i].second;
(fact[i].first *= j) %= mod;
}
}
long long Solve(long long _prime, long long _deg) {
prime = _prime;
deg = _deg;
mod = 1;
for (int i = 0; i < deg; ++i) mod *= prime;
Init(n);
long long ans = 0;
for (long long i = 0; i <= n; ++i) {
int cl = max(-i, l);
int cr = min(i, r);
if (cl <= cr) {
int up = (i + cr) / 2;
int low = (i + cl + 1) / 2;
long long val = (Comb(i, low) - Comb(i, up + 1)) % mod;
(ans += val * Comb(n, i)) %= mod;
}
}
return (ans + mod) % mod;
}
vector<pair<long long, int>> Factor(long long w) {
vector<pair<long long, int>> res;
if (!(w & 1)) {
res.push_back(make_pair(2, 0));
while (!(w & 1)) w >>= 1, ++res.back().second;
}
for (long long i = 3; i * i <= w; i += 2)
if (w % i == 0) {
res.push_back(make_pair(i, 0));
while (w % i == 0) w /= i, ++res.back().second;
}
if (w > 1) res.push_back(make_pair(w, 1));
return res;
}
int main() {
cin >> n >> p >> l >> r;
if (p == 1) {
cout << 0 << '\n';
return 0;
}
auto factors = Factor(p);
vector<long long> a, m;
for (const auto& e : factors) {
a.push_back(Solve(e.first, e.second));
m.push_back(mod);
}
cout << SolveSystem(a, m) << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 18 | 7;
int a[N], b[N], o[N];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, s;
cin >> n >> s;
--s;
for (int i = 0; i < n; ++i) cin >> a[i], b[i] = a[i];
for (int i = 0; i < n; ++i)
if (!a[i]) a[i] = n;
if (a[s]) a[s] = 0;
priority_queue<pair<int, int> > Q;
for (int i = 0; i < n; ++i) Q.push({a[i], i}), o[a[i]] = 1;
for (int i = 1; i < Q.top().first; ++i) {
if (o[i]) continue;
auto now = Q.top();
Q.pop();
a[now.second] = i;
now.first = i;
Q.push(now);
}
int ans = 0;
for (int i = 0; i < n; ++i) ans += a[i] != b[i];
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200500;
const long long inf = 0x3f3f3f3f;
long long n, k, x;
long long a[maxn];
long long pr[maxn], ta[maxn];
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> x;
for (long long i = 1; i <= n; i++) cin >> a[i];
a[0] = a[n + 1] = 0;
for (long long i = 1; i <= n; i++) {
pr[i] = a[i] | pr[i - 1];
}
for (long long i = n; i >= 1; i--) {
ta[i] = a[i] | ta[i + 1];
}
long long p = 1;
while (k--) {
p *= x;
}
long long ans = -inf;
for (long long i = 1; i <= n; i++) {
long long t = pr[i - 1] | (a[i] * p) | ta[i + 1];
ans = max(ans, t);
}
cout << ans << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char adj[101][101];
int a[101];
int b[101];
bool invite[101];
int calc(int n) {
for (int i = 0; i < (int)(n); i++) b[i] = 0;
for (int i = 0; i < (int)(n); i++) {
if (invite[i]) {
for (int j = 0; j < (int)(n); j++) b[j] += adj[i][j];
}
}
for (int i = 0; i < (int)(n); i++)
if (a[i] == b[i]) return true;
return false;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (int)(n); i++) scanf("%s", adj[i]);
for (int i = 0; i < (int)(n); i++)
for (int j = 0; j < (int)(n); j++) adj[i][j] -= '0';
for (int i = 0; i < (int)(n); i++) scanf("%d", &a[i]);
for (int i = 0; i < (int)(n); i++) {
invite[i] = true;
}
while (calc(n)) {
for (int j = 0; j < (int)(n); j++)
if (a[j] == b[j]) {
invite[j] = false;
break;
}
}
vector<int> res;
for (int i = 0; i < (int)(n); i++)
if (invite[i]) res.push_back(i);
printf("%u\n", res.size());
for (int i = 0; i < (int)(res.size()); i++) printf("%d ", res[i] + 1);
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
long long rand_seed() {
long long a = rng();
return a;
}
int t;
int n;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t;
for (; t; --t) {
cin >> n;
cin >> s;
bool ok = 0;
for (int i = 0; i + 10 < n; ++i)
if (s[i] == '8') ok = 1;
if (ok)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int Sig(long long a) {
if (a < 0) return -1;
if (a > 0) return 1;
return 0;
}
char str[110];
long long x[100010];
long long y[100010];
bool ok(long long a, long long b, long long c, long long d) {
bool fullp, fullq;
fullp = fullq = false;
long long p, q;
if (a == 0) {
if (b == 0)
fullp = true;
else
return false;
}
if (c == 0) {
if (d == 0)
fullq = true;
else
return false;
}
if (a != 0) {
if (b % a != 0) return false;
p = b / a;
}
if (c != 0) {
if (d % c != 0) return false;
q = d / c;
}
if (fullp && fullq) return true;
if (fullp) return q >= 0;
if (fullq) return p >= 0;
if (p < 0 || q < 0) return false;
return p == q;
}
int main() {
long long a, b;
cin >> a >> b;
scanf("%s", str);
int n = strlen(str);
x[0] = y[0] = 0;
int end = 1;
for (int i = 0; i < n; i++) {
x[end] = x[end - 1];
y[end] = y[end - 1];
if (str[i] == 'U') y[end]++;
if (str[i] == 'D') y[end]--;
if (str[i] == 'R') x[end]++;
if (str[i] == 'L') x[end]--;
end++;
}
long long adda = x[end - 1];
long long addb = y[end - 1];
bool flag = false;
for (int i = 0; i < end; i++) {
long long needa = a - x[i];
long long needb = b - y[i];
if (ok(adda, needa, addb, needb)) flag = true;
}
if (flag)
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 7340033;
long double EPS = 1e-9;
template <class second, class T>
ostream& operator<<(ostream& os, const pair<second, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const unordered_set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class second, class T>
ostream& operator<<(ostream& os, const unordered_map<second, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const multiset<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class second, class T>
ostream& operator<<(ostream& os, const map<second, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
void dbs(string str, T t) {
cerr << str << " : " << t << "\n";
}
template <class T, class... second>
void dbs(string str, T t, second... s) {
int idx = str.find(',');
cerr << str.substr(0, idx) << " : " << t << ",";
dbs(str.substr(idx + 1), s...);
}
template <class T>
void prc(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
long long binpow(long long b, long long p, long long mod) {
long long ans = 1;
for (; p; p >>= 1) {
if (p & 1) ans = ans * b % mod;
b = b * b % mod;
}
return ans;
}
namespace myNTT {
const int MOD = 7340033, PRIMITIVE_ROOT = 5;
const int MAXB = 1 << 20;
long long pow1(long long a, long long b) {
if (b == 0) return 1;
long long ret = pow1(a, b / 2);
ret = (ret * ret) % MOD;
if (b & 1) ret = (a * ret) % MOD;
return ret;
}
int modInv(int a) {
return a <= 1 ? a : (long long)(MOD - MOD / a) * modInv(MOD % a) % MOD;
}
void NTT(int P[], int n, int oper) {
for (int i = 1, j = 0; i < n - 1; i++) {
for (int s = n; j ^= s >>= 1, ~j & s;)
;
if (i < j) swap(P[i], P[j]);
}
for (int d = 0; (1 << d) < n; d++) {
int m = 1 << d, m2 = m * 2;
long long unit_p0 = pow1(PRIMITIVE_ROOT, (MOD - 1) / m2);
if (oper < 0) unit_p0 = modInv(unit_p0);
for (int i = 0; i < n; i += m2) {
long long unit = 1;
for (int j = 0; j < m; j++) {
int &P1 = P[i + j + m], &P2 = P[i + j];
int t = unit * P1 % MOD;
P1 = (P2 - t + MOD) % MOD;
P2 = (P2 + t) % MOD;
unit = unit * unit_p0 % MOD;
}
}
}
}
vector<long long> mul(const vector<long long>& a, const vector<long long>& b) {
vector<long long> ret(max(0, (int)a.size() + (int)b.size() - 1), 0);
static int A[MAXB], B[MAXB], C[MAXB];
int len = 1;
while (len < (int)ret.size()) len <<= 1;
for (int i = 0; i < len; i++) A[i] = i < (int)a.size() ? a[i] : 0;
for (int i = 0; i < len; i++) B[i] = i < (int)b.size() ? b[i] : 0;
NTT(A, len, 1);
NTT(B, len, 1);
for (int i = 0; i < len; i++) C[i] = (long long)A[i] * B[i] % MOD;
NTT(C, len, -1);
for (int i = 0, inv = modInv(len); i < (int)ret.size(); i++)
ret[i] = (long long)C[i] * inv % MOD;
return ret;
}
} // namespace myNTT
vector<long long> gen(int n, int k) {
if (n == 1 || (n & 1) == 0) {
vector<long long> aa(k + 1, 0);
aa[0] = 1;
return aa;
} else {
vector<long long> temp = gen((n - 1) / 2, k);
temp = myNTT::mul(temp, temp);
if (temp.size() > k) temp.resize(k);
temp = myNTT::mul(temp, temp);
if (temp.size() > k) temp.resize(k);
vector<long long> ans(1, 1);
for (auto v : temp) {
ans.emplace_back(v);
}
return ans;
}
}
vector<long long> final[32];
void pre() {
for (long long i = 1; i <= 31; ++i) {
final[i] = gen((1LL << i) - 1, 1000);
}
}
void solve() {
int n, k;
cin >> n >> k;
int x = 1;
while (n > 1 && (n & 1)) {
n >>= 1;
x++;
}
cout << final[x][k] << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
pre();
int t = 1;
cin >> t;
for (int i = 1; i <= t; i++) {
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int dif[10];
int bit[10];
vector<int> vec;
vector<int> fin;
int main() {
int n, x, y;
scanf("%d %d %d", &n, &x, &y);
int l = 0;
while ((1 << (l + 1)) < n) {
l++;
}
for (int i = 0; i <= l; i++) {
int cnt = 0;
for (int j = 0; j < n; j++) {
if (j & (1 << i)) {
cnt++;
vec.push_back(j);
}
}
printf("? %d", cnt);
for (int j = 0; j < vec.size(); j++) {
printf(" %d", vec[j] + 1);
}
printf("\n");
fflush(stdout);
vec.clear();
int k;
scanf("%d", &k);
if (cnt % 2) {
if (k == x) {
dif[i] = 0;
} else {
dif[i] = 1;
}
} else {
if (k == 0) {
dif[i] = 0;
} else {
dif[i] = 1;
}
}
}
int ind = -1;
for (int i = l; i >= 0; i--) {
if (dif[i]) {
ind = i;
break;
}
}
for (int i = 0; i < n; i++) {
if (((1 << ind) & i) == 0) {
vec.push_back(i);
}
}
for (int i = 0; i <= l; i++) {
if (i != ind) {
int cnt = 0;
for (int j = 0; j < vec.size(); j++) {
if (vec[j] & (1 << i)) {
cnt++;
fin.push_back(vec[j]);
}
}
printf("? %d", cnt);
for (int j = 0; j < fin.size(); j++) {
printf(" %d ", fin[j] + 1);
}
printf("\n");
fflush(stdout);
fin.clear();
int k;
scanf("%d", &k);
if (cnt % 2) {
if (k == x) {
bit[i] = 0;
} else {
bit[i] = 1;
}
} else {
if (k == 0) {
bit[i] = 0;
} else {
bit[i] = 1;
}
}
}
}
int lo = 0;
int hi = 0;
for (int i = 0; i <= l; i++) {
int l = bit[i];
int r = l ^ dif[i];
lo += (1 << i) * l;
hi += (1 << i) * r;
}
printf("! %d %d\n", lo + 1, hi + 1);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10, inf = 0x3f3f3f3f3f;
int n, m, s, k, ans[maxn];
vector<int> edge[maxn], color[maxn];
int dis[107][maxn];
void bfs(vector<int> color, int *dis) {
fill(dis + 1, dis + 1 + n, -1);
queue<int> q;
for (auto u : color) {
dis[u] = 0;
q.push(u);
}
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : edge[u])
if (dis[v] == -1) dis[v] = dis[u] + 1, q.push(v);
}
}
int main() {
scanf("%d%d%d%d", &n, &m, &k, &s);
for (int i = 1, tmp; i <= n; i++) scanf("%d", &tmp), color[tmp].push_back(i);
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
for (int i = 1; i <= k; i++) bfs(color[i], dis[i]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) ans[j] = dis[j][i];
sort(ans + 1, ans + 1 + k);
printf("%d", accumulate(ans + 1, ans + 1 + s, 0));
printf("%c", i == n ? '\n' : ' ');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> mark;
string s;
void count(int a, int b, int c, int d, int e, int f) {
string x;
x.resize(6);
sprintf(&x[0], "%c%c%c%c%c%c", s[a], s[b], s[c], s[d], s[e], s[f]);
mark[x] = 1;
}
void cnt(int a, int b, int c, int d, int e, int f) {
count(a, b, c, d, e, f);
count(a, c, d, e, b, f);
count(a, d, e, b, c, f);
count(a, e, b, c, d, f);
}
int main() {
cin >> s;
sort(s.begin(), s.end());
vector<string> a;
int ans = 0;
do {
mark[s] = 0;
} while (next_permutation(s.begin(), s.end()));
sort(s.begin(), s.end());
do {
if (mark[s] == 0) {
ans++;
cnt(0, 1, 2, 3, 4, 5);
cnt(1, 2, 0, 4, 5, 3);
cnt(2, 0, 1, 5, 3, 4);
cnt(3, 0, 2, 5, 4, 1);
cnt(4, 0, 3, 5, 1, 2);
cnt(5, 1, 4, 3, 2, 0);
}
} while (next_permutation(s.begin() + 1, s.end()));
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, i;
long long suma = 1;
int main() {
cin >> n;
for (i = n; i >= n - 4; i--) suma *= i;
suma /= 120;
for (i = n; i >= n - 4; i--) suma *= i;
cout << suma << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct comprator {
bool operator()(const pair<int, int>& p1, const pair<int, int>& p2) {
return p1.first > p2.first;
}
};
void solve() {
set<int> ran;
ran.insert(-500);
int n = 2;
string s;
list<char> ans;
cin >> s;
int arr[26][2];
for (int i = 0; i < 26; ++i) {
arr[i][0] = 0;
arr[i][1] = -500;
}
arr[s[0] - 97][0] = 1;
arr[s[0] - 97][1] = 0;
ans.push_back(s[0]);
ran.insert(0);
for (int i = 1; i < s.length(); ++i) {
if (!arr[s[i] - 97][0]) {
ran.insert(arr[s[i - 1] - 97][1] - 1);
if (n == ran.size()) {
ran.insert(arr[s[i - 1] - 97][1] + 1);
if (n == ran.size()) {
cout << "NO"
<< "\n";
return;
} else {
arr[s[i] - 97][1] = arr[s[i - 1] - 97][1] + 1;
arr[s[i] - 97][0] = 1;
ans.push_back(s[i]);
n++;
}
} else {
arr[s[i] - 97][0] = 1;
arr[s[i] - 97][1] = arr[s[i - 1] - 97][1] - 1;
ans.push_front(s[i]);
n++;
}
} else {
if (abs(arr[s[i] - 97][1] - arr[s[i - 1] - 97][1]) == 1) {
continue;
} else {
cout << "NO"
<< "\n";
return;
}
}
}
for (int i = 0; i < 26; ++i) {
if (!arr[i][0]) {
ans.push_back(char(i + 97));
}
}
cout << "YES"
<< "\n";
for (auto x : ans) cout << x;
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3E5;
int n, m, k;
vector<int> g[N];
bool visited[N];
int par[N];
int deep_chi[N];
int dfs(int x, int p) {
visited[x] = true;
par[x] = p;
int maxd = 0;
for (auto y : g[x]) {
if (y != p && !visited[y]) {
int res = dfs(y, x);
if (res > maxd) {
maxd = res;
deep_chi[x] = y;
}
}
}
return maxd + 1;
}
vector<int> get_cycle(int leaf) {
int a = -1, b = -1;
for (auto x : g[leaf])
if (x != par[leaf]) {
if (a == -1)
a = x;
else if (b == -1)
b = x;
}
int cur = leaf;
vector<int> vb;
while (cur != b) {
assert(cur != 0);
cur = par[cur];
if (cur == a) swap(a, b);
vb.push_back(cur);
}
vector<int> va;
while (cur != a) {
assert(cur != 0);
cur = par[cur];
va.push_back(cur);
}
int VB = vb.size(), VA = va.size();
if (VB + 1 >= 3 && (VB + 1) % 3 != 0) {
vb.insert(vb.begin(), leaf);
return vb;
} else if (VB + VA + 1 >= 3 && (VB + VA + 1) % 3 != 0) {
vb.insert(vb.end(), va.begin(), va.end());
vb.insert(vb.begin(), leaf);
return vb;
} else if (VA + 2 >= 3 && (VA + 2) % 3 != 0) {
va.insert(va.begin(), b);
va.insert(va.begin(), leaf);
return va;
} else {
printf("error no cycle suitable leaf %d\n", leaf + 1);
exit(0);
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
int res_dfs = dfs(0, 0);
int min_len = (n + k - 1) / k;
if (res_dfs >= min_len) {
printf("PATH\n");
printf("%d\n", min_len);
int cur = 0;
for (int i = 0; i < min_len; i++) {
printf("%d ", cur + 1);
cur = deep_chi[cur];
}
printf("\n");
} else {
printf("CYCLES\n");
int to_print = k;
for (int i = 0; i < n; i++) {
if (deep_chi[i] == 0 && to_print) {
to_print--;
vector<int> c = get_cycle(i);
printf("%d\n", c.size());
for (auto x : c) printf("%d ", x + 1);
printf("\n");
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n;
set<long long int> s;
while (n--) {
cin >> t;
s.insert(t);
}
if (s.size() >= 4)
cout << "NO";
else {
if (s.size() == 3) {
auto it1 = s.begin();
auto it2 = it1;
auto it3 = it2;
it2++;
it3++;
it3++;
if (2 * (*it2) == *it1 + *it3)
cout << "YES";
else
cout << "NO";
} else
cout << "YES";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void debug(string s) { cout << s << "\n"; }
vector<long long> prime;
void sieve() {
bool arr[1000008];
memset(arr, 1, sizeof(arr));
arr[0] = arr[1] = 0;
for (int i = 2; i <= sqrt(1000008); i += 1) {
if (arr[i] == 1) {
for (int j = i * i; j <= 1000007; j += i) {
arr[j] = 0;
}
}
}
for (int i = 2; i <= 1000007; i += 1) {
if (arr[i] == 1) {
prime.push_back(i);
}
}
}
long long GCD(long long a, long long b) {
long long c = a % b;
while (c != 0) {
a = b;
b = c;
c = a % b;
}
return b;
}
long long power(long long a, long long b) {
long long ans = 1;
while (b != 0) {
if (b % 2 == 1) {
ans *= a;
}
a *= a;
b = b >> 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n;
cin >> n;
vector<int> v(2 * n);
for (int i = 0; i < (2 * n); i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
int frst[n], scnd[n];
for (int i = 0; i <= n - 1; i += 1) {
frst[i] = v[i];
}
for (int i = n, j = 0; i < (2 * n); i++, j++) {
scnd[j] = v[i];
}
bool say = true;
for (int i = 0; i <= n - 1; i += 1) {
for (int j = 0; j <= n - 1; j += 1) {
if (frst[i] == scnd[j]) {
say = false;
break;
}
}
if (!say) {
break;
}
}
if (say) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
void add(long long int &x, long long int y) { x = (x + y) % mod; }
const int N = 1 << 20;
long long int dp[N];
long long int p2[N];
void init(void) {
p2[0] = 1;
for (int i = (int)(1); i < (int)(N); i++) {
p2[i] = p2[i - 1] * 2 % mod;
}
}
int main(void) {
init();
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = (int)(0); i < (int)(n); i++) {
cin >> a[i];
dp[a[i]]++;
}
for (int i = (int)(0); i < (int)(20); i++) {
for (int bits = (int)(0); bits < (int)(N); bits++) {
if (bits & 1 << i) {
dp[bits ^ 1 << i] += dp[bits];
}
}
}
for (int bits = (int)(0); bits < (int)(N); bits++) {
dp[bits] = p2[dp[bits]];
}
long long int tot = 0;
for (int bits = (int)(0); bits < (int)(N); bits++) {
long long int tmp = dp[bits];
if (__builtin_popcount(bits) % 2 == 1) {
tmp = mod - tmp;
}
add(tot, tmp);
}
cout << tot << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int max(int a, int b) { return (a > b ? a : b); }
int min(int a, int b) { return (a < b ? a : b); }
long long gcd(long long a, long long b) {
if (b == 0) return a;
gcd(b, a % b);
}
bool comp(int a, int b) { return a > b; }
int main() {
int t;
cin >> t;
vector<int> a, b;
while (t--) {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int A;
cin >> A;
a.push_back(A);
}
for (int i = 0; i < n; i++) {
int B;
cin >> B;
b.push_back(B);
}
sort(a.begin(), a.end());
sort(b.begin(), b.end(), comp);
int ans = 0, j = 0;
for (int i = 0; i < n; i++) {
if (k && a[i] < b[j]) {
a[i] = b[j];
k--;
j++;
} else
break;
}
for (int i = 0; i < n; i++) ans += a[i];
cout << ans << endl;
a.clear();
b.clear();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[1050];
map<int, int> mp;
int main() {
int n, t, mx = 1;
cin >> t;
while (t--) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
mx = max(mx, a[i]);
}
sort(a, a + n);
int f = 0, in = 0;
for (int j = 1; j <= 1024; j++) {
mp.clear();
f = 0;
for (int i = 0; i < n; i++) {
int p = a[i] ^ j;
mp[p] = 1;
}
for (int i = 0; i < n; i++) {
if (mp[a[i]] == 0) {
f = 1;
break;
}
}
if (f == 0) {
in = j;
break;
}
}
if (f == 0)
printf("%d\n", in);
else
printf("-1\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int diff(int a, int c) {
if (a == 0 && c == 1) {
return 0;
} else if (a == 1 && c == 0) {
return 0;
} else if (a == 0 && c == 2) {
return 0;
} else if (a == 1 && c == 2) {
return 0;
} else if (a == 2 && c == 0) {
return 0;
} else if (a == 2 && c == 1) {
return 0;
} else if (a == 0 && c == 0) {
return 1;
} else if (a == 1 && c == 1) {
return 1;
} else if (a == 2 && c == 2) {
return 1;
} else
return 3;
}
int valueArr(char a) {
if (a == 'C')
return 0;
else if (a == 'M')
return 1;
else if (a == 'Y')
return 2;
else if (a == '?')
return 3;
}
int main() {
int n;
cin >> n;
int arr[n];
char temp;
cin >> temp;
arr[0] = valueArr(temp);
for (int i = 1; i < n; i++) {
cin >> temp;
arr[i] = valueArr(temp);
if (arr[i] == arr[i - 1] && arr[i] != 3) {
cout << "No" << endl;
return 0;
}
}
int numWays = 1, temp1;
if (arr[0] == 3 || arr[n - 1] == 3)
cout << "Yes" << endl;
else if (n == 1) {
if (arr[0] == 3)
cout << "Yes" << endl;
else
cout << "No" << endl;
} else if (n == 2) {
if (arr[1] == 3)
cout << "Yes" << endl;
else
cout << "No" << endl;
} else {
for (int i = 1; i < n - 1; i++) {
if (arr[i] == 3) {
temp1 = diff(arr[i - 1], arr[i + 1]);
numWays = numWays + temp1;
if (temp1 == 3 || temp1 == 1) {
break;
}
}
}
if (numWays > 1)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, cnt = 0;
cin >> n >> m;
int a[n], b[m];
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < m; i++) {
cin >> b[i];
}
for (i = 0, j = 0; i < n && j < m; i++) {
if (a[i] <= b[j]) {
cnt++;
j++;
} else
continue;
}
cout << cnt << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string second, t;
int n;
void inp() {
cin >> n >> second >> t;
return;
}
class DSU {
private:
vector<int> par, rank;
int n;
public:
void make_set(int x) {
par.resize(x + 1);
rank.resize(x + 1);
for (int i = 0; i < x + 1; i++) par[i] = i, rank[i] = 1;
}
DSU(int x = 0) {
n = x;
make_set(x);
}
vector<int> get_par() { return par; }
vector<int> get_rank() { return rank; }
int get_size() { return n; }
int find(int x) {
if (par[x] != x) par[x] = find(par[x]);
return par[x];
}
void un(int x, int y) {
x = find(x), y = find(y);
if (x == y) return;
if (rank[x] < rank[y]) swap(x, y);
rank[x] += rank[y];
rank[y] = 0;
par[y] = x;
return;
}
};
void solve() {
auto dsu = DSU(256);
for (int i = 0; i < n; i++) dsu.un(second[i], t[i]);
vector<int> a = dsu.get_par();
set<int> p[256];
for (int i = 'a'; i <= 'z'; i++) p[a[i]].insert(i);
set<pair<int, int> > b;
int ans = 0;
for (int i = 'a'; i <= 'z'; i++) {
p[i].insert(i);
if (p[i].size() > 1 || (p[i].size() > 0 && *p[i].begin() != i)) {
vector<int> l;
for (auto j : p[i]) l.push_back(j);
ans += l.size() - 1;
for (int j = 0; j < l.size() - 1; j++) b.insert({l[j], l[j + 1]});
}
}
cout << ans << '\n';
for (auto i : b) cout << char(i.first) << ' ' << char(i.second) << '\n';
return;
}
int main() {
clock_t beg = clock();
inp();
solve();
clock_t end = clock();
fprintf(stderr, "%.3f sec\n", (double)(end - beg) / CLOCKS_PER_SEC);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v, cost;
};
vector<int> G[200005];
vector<edge> H[200005];
int root, n, m, t;
int parent[20][200005], depth[200005], l[200005], r[200005], bit[200005 + 1],
dp[200005], s[200005];
int sum(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, int x) {
while (i < 200005) {
bit[i] += x;
i += i & -i;
}
}
void dfs(int v, int p, int d) {
l[v] = ++t;
parent[0][v] = p;
depth[v] = d;
for (int i = 0; i < G[v].size(); i++)
if (G[v][i] != p) dfs(G[v][i], v, d + 1);
r[v] = t;
}
void init(int V) {
dfs(root, -1, 0);
for (int k = 0; k + 1 < 20; k++) {
for (int v = 0; v < n; v++) {
if (parent[k][v] < 0)
parent[k + 1][v] = -1;
else
parent[k + 1][v] = parent[k][parent[k][v]];
}
}
}
int lca(int u, int v) {
if (depth[u] > depth[v]) swap(u, v);
for (int k = 0; k < 20; k++) {
if ((depth[v] - depth[u]) >> k & 1) v = parent[k][v];
}
if (u == v) return u;
for (int k = 20 - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
void solve(int v) {
for (int i = 0; i < G[v].size(); i++) {
solve(G[v][i]);
s[v] += dp[G[v][i]];
}
dp[v] = s[v];
for (int i = 0; i < H[v].size(); i++) {
edge e = H[v][i];
dp[v] = max(dp[v], sum(l[e.u]) + sum(l[e.v]) + s[v] + e.cost);
}
add(l[v], s[v] - dp[v]);
add(r[v] + 1, dp[v] - s[v]);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i < n; i++) {
int x;
scanf("%d", &x);
G[x - 1].push_back(i);
}
init(n);
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
u--;
v--;
H[lca(u, v)].push_back((edge){u, v, w});
}
memset(bit, 0, sizeof(bit));
memset(dp, 0, sizeof(dp));
memset(s, 0, sizeof(s));
solve(0);
printf("%d\n", dp[0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename T1>
ostream& operator<<(ostream& out, pair<T, T1> obj) {
return out << "(" << obj.first << "," << obj.second << ")";
}
template <typename T, typename T1>
ostream& operator<<(ostream& out, map<T, T1> cont) {
typename map<T, T1>::const_iterator itr = cont.begin();
typename map<T, T1>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
}
template <typename T>
ostream& operator<<(ostream& out, set<T> cont) {
typename set<T>::const_iterator itr = cont.begin();
typename set<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
}
template <typename T,
template <typename ELEM, typename ALLOC = allocator<ELEM>> class CONT>
ostream& operator<<(ostream& out, CONT<T> cont) {
typename CONT<T>::const_iterator itr = cont.begin();
typename CONT<T>::const_iterator ends = cont.end();
for (; itr != ends; ++itr) out << *itr << " ";
out << endl;
}
template <typename T>
T gcd(T a, T b) {
T min_v = min(a, b);
T max_v = max(a, b);
while (min_v) {
T temp = max_v % min_v;
max_v = min_v;
min_v = temp;
}
return max_v;
}
template <typename T>
T lcm(T a, T b) {
return (a * b) / gcd(a, b);
}
int N, M, answer;
int dp_sum[5010][5010];
char board[5010][5010];
vector<int> keep;
string row;
int main() {
scanf("%d%d", &N, &M);
for (auto i = 0 - (0 > N); i != N - (0 > N); i += 1 - 2 * (0 > N)) {
scanf("%s", board[i]);
for (auto j = 0 - (0 > M); j != M - (0 > M); j += 1 - 2 * (0 > M)) {
if (board[i][j] == '0')
dp_sum[i][j] = 0;
else {
if (!j)
dp_sum[i][j] = 1;
else
dp_sum[i][j] = dp_sum[i][j - 1] + 1;
}
}
}
for (auto i = 0 - (0 > M); i != M - (0 > M); i += 1 - 2 * (0 > M)) {
keep.clear();
for (auto j = 0 - (0 > N); j != N - (0 > N); j += 1 - 2 * (0 > N))
keep.push_back(dp_sum[j][i]);
sort(keep.begin(), keep.end(), greater<int>());
for (auto j = 0 - (0 > keep.size()); j != keep.size() - (0 > keep.size());
j += 1 - 2 * (0 > keep.size()))
answer = max(answer, keep[j] * (j + 1));
}
printf("%d\n", answer);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int st = 0;
vector<int> vloo(n);
for (int i = 0; i < n; i++) {
cin >> vloo[i];
if (vloo[i] == 1) {
st++;
}
}
cout << st << endl;
vector<int> answ(st);
int last = 0;
int here = 0;
for (int i = 1; i < n; i++) {
if (vloo[i] == 1) {
answ[here] = i;
if (here != 0) {
answ[here] -= last;
}
last = i;
here++;
}
}
answ[here] = n - last;
for (int i = 0; i < st; i++) {
cout << answ[i] << " ";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-12;
const int MOD = 256;
double dp[300][300][2][2];
double p;
int x, n, q;
int main() {
scanf("%d%d%d", &x, &n, &q);
p = (double)q / 100.;
int y = x >> 8;
x %= MOD;
int z = 0;
q = y & 1;
if (y > 0) {
while ((y & 1) == q) {
z++;
y /= 2;
}
}
dp[x][z][q][0] = 1.;
while (n--) {
for (int mask = 0; mask < MOD; mask++)
for (int k = 0; k < 300; k++)
for (int q = 0; q < 2; q++) {
if (dp[mask][k][q][0] < eps) continue;
int x = mask * 2;
int y = x / MOD;
x %= MOD;
if (y == q)
dp[x][k + 1][q][1] += dp[mask][k][q][0] * p;
else
dp[x][1][y][1] += dp[mask][k][q][0] * p;
if (mask == MOD - 1) {
if (q == 0)
dp[0][1][1][1] += dp[mask][k][q][0] * (1. - p);
else
dp[0][k][0][1] += dp[mask][k][q][0] * (1. - p);
} else {
dp[mask + 1][k][q][1] += dp[mask][k][q][0] * (1. - p);
}
}
for (int mask = 0; mask < MOD; mask++)
for (int k = 0; k < 300; k++)
for (int q = 0; q < 2; q++) {
dp[mask][k][q][0] = dp[mask][k][q][1];
dp[mask][k][q][1] = 0.;
}
}
double ans = 0.;
for (int i = 1; i < 300; i++) ans += (double)i * dp[0][i][0][0];
for (int mask = 0; mask < MOD; mask++) {
int x = 0;
while (x < 8 && (mask & (1 << x)) == 0) x++;
for (int k = 0; k < 300; k++)
for (int q = 0; q < 2; q++) ans += dp[mask][k][q][0] * (double)x;
}
printf("%.10lf\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10005, maxK = 25;
int n, m, K, dis[maxK][maxn], to[maxn], a[maxK], q[maxn], f[1 << 20];
bool b[maxn];
void Bfs(int S, int *Dp) {
int rt, i, s, t, x;
q[s = t = 1] = S;
Dp[S] = 0;
while (s <= t) {
rt = q[s++];
for (i = 0; i < m; i++) {
x = rt + to[i];
if (x <= n + 1 && Dp[x] > Dp[rt] + 1) Dp[x] = Dp[rt] + 1, q[++t] = x;
x = rt - to[i];
if (x > 0 && Dp[x] > Dp[rt] + 1) Dp[x] = Dp[rt] + 1, q[++t] = x;
}
}
}
int main() {
scanf("%d%d%d", &n, &K, &m);
int i, j, v, V;
while (K--) scanf("%d", &v), b[v] = true;
for (i = 0; i < m; i++) scanf("%d", &to[i]);
memset(dis, 0x3f, sizeof(dis));
memset(f, 0x3f, sizeof(f));
f[0] = 0;
for (K = 0, i = 1; i <= n + 1; i++)
if (b[i] ^ b[i - 1]) a[K++] = i, Bfs(i, dis[K - 1]);
for (V = 1 << K, v = 1; v < V; v++) {
int &x = f[v];
for (i = 0; i < K; i++)
if (v >> i & 1)
for (j = i + 1; j < K; j++)
if (v >> j & 1) x = min(x, f[v ^ (1 << i) ^ (1 << j)] + dis[i][a[j]]);
}
printf("%d\n", f[V - 1] < 0x3f3f3f3f ? f[V - 1] : -1);
fclose(stdin);
fclose(stdout);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int maxi = -1, maxiidx;
for (int i = 0; i < n; i++) {
if (s[i] - 'a' < maxi && maxi != -1) {
cout << "YES" << endl;
cout << maxiidx << " " << i + 1;
return 0;
}
if (s[i] - 'a' > maxi) {
maxiidx = i + 1;
maxi = s[i] - 'a';
}
}
cout << "NO";
return 0;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int t, n, a, b, x, y, z, i, j, g, h, count;
scanf("%d", &t);
while (t--) {
g = 0;
h = 0;
i = 0;
j = 0;
scanf("%d", &n);
int ara[n + 1];
int ara1[n + 1];
for (x = 1; x <= n; x++) {
scanf("%d", &a);
ara[x] = a;
if (g == 0 && a == 1) {
i = x;
g = 1;
} else if (h == 0 && ara[x] == -1) {
j = x;
h = 1;
}
}
for (y = 1; y <= n; y++) {
scanf("%d", &b);
ara1[y] = b;
}
if (ara[1] != ara1[1]) {
printf("NO\n");
} else {
for (z = 2, count = 1; z <= n; z++) {
if (ara1[z] == ara[z]) {
count = count + 1;
} else if (ara1[z] > ara[z]) {
if (i != 0 && i < z) {
count = count + 1;
}
} else if (ara1[z] < ara[z]) {
if (j != 0 && j < z) {
count = count + 1;
}
}
}
if (count == n) {
printf("YES\n");
} else {
printf("NO\n");
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int t, n, inf = 1e9 + 3;
int main() {
cin >> t;
while (t--) {
long long int x;
cin >> x;
if (x > 14 && x % 14 <= 6 && x % 14 >= 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
int N, K, X[110000], Y[110000];
double dist(int a, int b) {
double dx = X[a] - X[b], dy = Y[a] - Y[b];
return sqrt(dx * dx + dy * dy);
}
double calc(int a, int b, int from) {
if (a == 0 && b == N - 1) return dist(from, N);
if (a == 0)
return dist(from, N) + min(dist(N, b + 1), dist(N, N - 1)) + X[N - 1] -
X[b + 1];
if (b == N - 1)
return dist(from, N) + min(dist(N, 0), dist(N, a - 1)) + X[a - 1] - X[0];
return dist(from, N) + min(dist(N, 0), dist(N, N - 1)) + X[N - 1] - X[0];
}
int main() {
scanf("%d%d", &N, &K);
K--;
for (int i = (0); i < (N + 1); i++) scanf("%d", &X[i]);
for (int i = (0); i < (N); i++) Y[i] = 0;
scanf("%d", &Y[N]);
int x = X[K];
sort(X, X + N);
if (K < N) {
for (int i = (0); i < (N); i++)
if (X[i] == x) K = i;
}
if (Y[N] == 0) {
int x1 = oo, x2 = -oo;
for (int i = (0); i < (N + 1); i++) {
x1 = min(x1, X[i]);
x2 = max(x2, X[i]);
}
printf("%.8lf\n", double(x2 - x1 + min(X[K] - x1, x2 - X[K])));
return 0;
}
if (K < N) {
double res = DBL_MAX;
for (int i = (0); i < (N); i++) {
int a = min(K, i), b = max(K, i);
res = min(res, abs(X[K] - X[i]) + calc(a, b, i));
res = min(res, X[K] - X[0] + X[i] - X[0] + calc(0, b, i));
res = min(res, X[N - 1] - X[K] + X[N - 1] - X[i] + calc(a, N - 1, i));
res = min(res, abs(X[i] - X[K]) + X[i] - X[0] + calc(0, max(K, i), 0));
res = min(res, abs(X[i] - X[K]) + X[N - 1] - X[i] +
calc(min(K, i), N - 1, N - 1));
}
printf("%.8lf\n", res);
} else {
double d1 = dist(N, 0), d2 = dist(N, N - 1), d = X[N - 1] - X[0];
d += min(d1, d2);
printf("%.8lf\n", d);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
const double MAX_DIST = 15e5;
int x[N], y[N], ans[N];
long long dist(long long x, long long y) { return x * x + y * y; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<pair<long long, int>> vv(n);
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
vv[i] = make_pair(dist(x[i], y[i]), i);
}
sort(vv.begin(), vv.end());
long long xx = 0, yy = 0;
for (int i = 0; i < vv.size(); i++) {
int idx = vv[i].second;
if (dist(xx + x[idx], yy + y[idx]) > dist(xx - x[idx], yy - y[idx])) {
ans[idx] = -1;
} else {
ans[idx] = 1;
}
xx += ans[idx] * x[idx];
yy += ans[idx] * y[idx];
}
if (sqrt(dist(xx, yy)) > MAX_DIST) {
xx = 0, yy = 0;
for (int i = vv.size() - 1; i >= 0; i--) {
int idx = vv[i].second;
if (dist(xx + x[idx], yy + y[idx]) > dist(xx - x[idx], yy - y[idx])) {
ans[idx] = -1;
} else {
ans[idx] = 1;
}
xx += ans[idx] * x[idx];
yy += ans[idx] * y[idx];
}
}
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
register long long ret = 0, c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) ret = ret * 10 + c - '0', c = getchar();
return ret;
}
long long m, n, q[100], w[100], ans = 1, v, u, x, y, bo;
int main() {
n = read(), m = read();
for (int i = 0; i < n; i++) q[i] = read();
for (int i = 1;; i = v + 1) {
bo = 1;
for (int j = 0; j < n; j++) {
w[j] = q[j] / i;
if (w[j]) bo = 0;
}
v = 1e12;
for (int j = 0; j < n; j++)
if (w[j]) v = min(v, (q[j] / w[j]));
u = m;
for (int j = 0; j < n; j++) u = u - ((1 + w[j]) * v - q[j]) % v;
if (u >= 0) ans = v;
y = m;
x = 0;
for (int j = 0; j < n; j++) {
x += 1 + w[j];
y += q[j];
}
y /= x;
if (y >= i && y < v) ans = max(ans, y);
if (bo) break;
}
printf("%lld\n", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
#define fast_io ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define ll long long int
#define f(i,x,n) for(long long int i=x;i<n;i++)
#define fr(i,x,n) for(long long int i=n-1;i>=x;i--)
#define pb push_back
#define mod 1000000007
#define endl '\n'
#define ff first
#define ss second
#define pii pair<int,int>
#define pll pair<ll,ll>
int main(){
fast_io
int t; cin >> t;
while(t--){
ll n,a,b; cin >> n >> a >> b;
if(n == 1 || b == 1){
cout << "YES\n";
continue;
}
if(a == 1){
if((n-1)%b == 0) cout << "YES\n";
else cout << "NO\n";
continue;
}
ll m = 1, f = 0;
while(m <= n){
if((n - m)%b == 0){
f = 1;
break;
}
m *= a;
}
if(f) cout << "YES\n";
else cout << "NO\n";
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(NULL);
cout.tie(NULL);
;
long long tt;
cin >> tt;
while (tt--) {
string s1, s2, s3;
cin >> s1 >> s2 >> s3;
long long n = s1.size(), i = 0, f = 0;
while (i < n) {
if (s1[i] != s3[i] && s2[i] != s3[i]) {
f = 1;
break;
}
i++;
}
if (f == 1)
cout << "NO\n";
else
cout << "YES\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long spf[11];
long long fac[11];
void sieve() {
spf[1] = 1;
for (long long i = 2; i < 11; i++) spf[i] = i;
for (long long i = 4; i < 11; i += 2) spf[i] = 2;
for (long long i = 3; i * i < 11; i++) {
if (spf[i] == i) {
for (long long j = i * i; j < 11; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
map<long long, long long> getfactor(long long a) {
map<long long, long long> m;
while (a > 1) {
m[spf[a]]++;
a /= spf[a];
}
return m;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0 || y < 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long inverse(long long a, long long p) { return power(a, p - 2, p); }
long long ncr(long long n, long long r, long long p) {
if (r > n) return 0;
if (r == 0 || r == n) return 1;
return (fac[n] * inverse(fac[r], p) % p * inverse(fac[n - r], p) % p) % p;
}
vector<long long> v[201];
long long cycle[201], lis[201];
long long maxi1 = 1, maxi2 = 1;
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
set<long long> s;
void dfs(long long cur, long long start) {
s.insert(cur);
for (auto it : v[cur]) {
if (it == start) {
for (auto it : s) cycle[it] = s.size();
maxi1 = lcm(maxi1, s.size());
return;
}
if (cycle[it]) return;
if (s.count(it)) {
return;
}
dfs(it, start);
}
s.erase(cur);
}
void dfs2(long long cur) {
for (auto it : v[cur]) {
if (!cycle[it]) dfs2(it);
cycle[cur] = cycle[it];
lis[cur] = lis[it] + 1;
long long hh = lis[cur] - lis[cur] % maxi1;
if (hh < lis[cur]) hh += maxi1;
if (lis[cur] > maxi1) {
maxi2 = max(hh, maxi2);
}
}
}
void solve() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
v[i].push_back(x);
}
for (long long i = 1; i <= n; i++) {
s.clear();
dfs(i, i);
}
for (long long i = 1; i <= n; i++) {
if (cycle[i] == 0) {
dfs2(i);
}
}
cout << max(maxi1, maxi2) << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long test = 1;
while (test--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, p;
cin >> n >> p;
vector<int> res;
vector<int> num(n);
vector<int> count_num(2001, 0);
vector<int> pref(4005, 0);
for (int i = 0; i < n; ++i) {
cin >> num[i];
++count_num[num[i]];
}
int sum = 0;
for (int i = 0; i < 4005; ++i) {
if (i < 2001) {
sum += count_num[i];
}
pref[i] = sum;
}
for (int i = 0; i <= 4005 - n; ++i) {
bool okay = true;
for (int j = 0; j < n; ++j) {
if (pref[i + j] <= j || (pref[i + j] - j) % p == 0) {
okay = false;
break;
}
}
if (okay) {
res.push_back(i);
}
}
cout << res.size() << "\n";
for (int i = 0; i < res.size(); ++i) {
cout << res[i] << " ";
}
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
;
solve();
}
| 5 |
#include <bits/stdc++.h>
const int mod = 1000000007;
int a[100001], b[100001], c00, c01, c10, c11, n, la, an, bn, ans, C00, C01, C10,
C11, aN, bN, jc[110001], inv[110001];
char s[100001];
int add(int x, int y) { return (x + y >= mod) ? (x + y - mod) : (x + y); }
int C(int x, int y) {
if (x < y) return 0;
return 1ll * jc[x] * inv[y] % mod * inv[x - y] % mod;
}
int query(int l, int r, int x) {
if (l < 0) l = 0;
if (l > r) return 0;
return (C(r + 1, x + 1) - C(l, x + 1) + mod) % mod;
}
int calc() {
if (aN == 0) return 0;
if (c00 + c11 > aN) return 0;
if (c10 == 0) {
if (c11 < aN) return 1;
return (an == 1 ? 1 : 0);
}
if (c00 + c11 < aN)
return 1ll * C(c00 - 1, c10 - 1) * C(c11 - 1, c01 - 1) % mod;
int ans = 0;
for (int i = 1; i <= an; i++)
if (i & 1) {
if (c01 == 1) {
if (c11 > a[i]) return ans;
return add(ans, 1);
}
ans = add(ans, 1ll * query(c11 - a[i], c11 - 2, c01 - 2) *
C(c00 - 1, c10 - 1) % mod);
c11 -= a[i];
c01--;
if (c11 < c01) return ans;
} else {
if (c10 == 1) {
if (c00 < a[i]) return ans;
return add(ans, 1);
}
ans = add(ans, 1ll * query(0, c00 - a[i] - 2, c10 - 2) *
C(c11 - 1, c01 - 1) % mod);
c00 -= a[i];
c10--;
if (c00 < c10) return ans;
}
}
int quickmi(int a, int b) {
int t = 1;
while (b) {
if (b & 1) t = 1ll * t * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return t;
}
int main() {
jc[0] = 1;
for (int i = 1; i <= 110000; i++) jc[i] = 1ll * jc[i - 1] * i % mod;
inv[110000] = quickmi(jc[110000], mod - 2);
for (int i = 110000; i; i--) inv[i - 1] = 1ll * inv[i] * i % mod;
scanf("%s", s);
n = strlen(s);
for (int i = n - 1; i >= 0; i--)
if (s[i] == '1') {
la = i;
break;
}
if (la == 0) {
n--;
for (int i = 0; i < n; i++) s[i] = '1';
} else {
s[la] = '0';
for (int i = la + 1; i < n; i++) s[i] = '1';
}
la = 0;
an = 0;
aN = n;
for (int i = 1; i < n; i++)
if (s[i] != s[i - 1]) a[++an] = i - la, la = i;
a[++an] = n - la;
scanf("%s", s);
n = strlen(s);
la = 0;
bn = 0;
bN = n;
for (int i = 1; i < n; i++)
if (s[i] != s[i - 1]) b[++bn] = i - la, la = i;
b[++bn] = n - la;
scanf("%d%d%d%d", &c00, &c01, &c10, &c11);
c11 += c01 + 1;
c00 += c10;
c01++;
C00 = c00;
C11 = c11;
C01 = c01;
C10 = c10;
if (c10 != c01 && c10 != c01 - 1 || c11 < c01 || c00 < c10) {
printf("0\n");
return 0;
}
ans = calc();
an = bn;
aN = bN;
for (int i = 1; i <= bn; i++) a[i] = b[i];
c00 = C00;
c01 = C01;
c11 = C11;
c10 = C10;
ans = (calc() - ans + mod) % mod;
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char io[3], it[3];
string h, v;
int difo, dift, i;
cin >> io;
cin >> it;
difo = (int)io[0] - (int)it[0];
dift = io[1] - it[1];
if (difo > 0)
h = "L";
else
h = "R";
if (dift > 0)
v = "D";
else
v = "U";
difo = abs(difo);
dift = abs(dift);
if (difo > dift) {
cout << difo << endl;
for (i = 0; i < dift; i++) cout << h << v << endl;
while (i++ < difo) cout << h << endl;
} else {
cout << dift << endl;
for (i = 0; i < difo; i++) cout << h + v << endl;
while (i++ < dift) cout << v << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int i, flag = 0, flag2 = 0;
char x;
if (s.length() == 0) {
cout << 0;
return 0;
}
x = s[0];
for (i = 0; i < s.length(); i++) {
if (s[i] == x) {
flag = 1;
} else {
flag = 0;
break;
}
}
if (flag == 1) {
cout << 0;
return 0;
}
for (i = 0; i < s.length(); i++) {
if (s[i] != s[s.length() - i - 1]) {
flag2 = 1;
break;
}
}
if (flag2 == 1) {
cout << s.length();
} else if (flag2 == 0) {
cout << s.length() - 1;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int m;
pair<pair<int, int>, int> q[N];
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(int a) {
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(int a) {
if (a < 0) {
a = -a;
putchar('-');
}
write(a);
puts("");
}
inline bool cmp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
if (a.first.first == b.first.first) {
if (a.first.first & 1)
return a.first.second < b.first.second;
else
return a.first.second > b.first.second;
} else
return a.first.first < b.first.first;
}
int main() {
scanf("%d", &m);
int len = 1000;
for (int i = 1; i <= m; i++) {
int l = read(), r = read();
q[i] = make_pair(make_pair(l / len, r), i);
}
sort(&q[1], &q[m + 1], cmp);
for (int i = 1; i <= m; i++) {
write(q[i].second);
putchar(' ');
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
set<string> cube;
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 6; j++) {
if (i == j) continue;
for (int k = 0; k < 6; k++) {
if (i == k || j == k) continue;
for (int l = 0; l < 6; l++) {
if (i == l || j == l || k == l) continue;
for (int m = 0; m < 6; m++) {
if (i == m || j == m || k == m || l == m) continue;
for (int n = 0; n < 6; n++) {
if (i == n || j == n || k == n || l == n || m == n) continue;
string a, b, c, d, e, f;
a += s[i];
b += s[j];
c += s[k];
d += s[n];
e += s[l];
f += s[m];
a += s[n];
b += s[l];
c += s[m];
d += s[i];
e += s[j];
f += s[k];
a += s[j];
b += s[k];
c += s[i];
d += s[m];
e += s[n];
f += s[l];
a += s[k];
b += s[i];
c += s[j];
d += s[l];
e += s[m];
f += s[n];
a += s[l];
b += s[m];
c += s[n];
d += s[k];
e += s[i];
f += s[j];
a += s[m];
b += s[n];
c += s[l];
d += s[j];
e += s[k];
f += s[i];
vector<string> rot;
for (int o = 0; o < 4; o++) {
rot.push_back(a);
rot.push_back(b);
rot.push_back(c);
rot.push_back(d);
rot.push_back(e);
rot.push_back(f);
char ba = a[2], bb = b[2], bc = c[2], bd = d[2], be = e[2],
bf = f[2];
for (int p = 2; p < 5; p++) {
a[p] = a[p + 1];
b[p] = b[p + 1];
c[p] = c[p + 1];
d[p] = d[p + 1];
e[p] = e[p + 1];
f[p] = f[p + 1];
}
a[5] = ba;
b[5] = bb;
c[5] = bc;
d[5] = bd;
e[5] = be;
f[5] = bf;
}
cube.insert(*min_element(rot.begin(), rot.end()));
}
}
}
}
}
}
cout << cube.size();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct team {
string team_id;
int points;
int scored_goals;
int missed_goals;
int S_M;
} teams[51];
int referer(int a, int b) {
if (a > b)
return 1;
else if (a < b)
return 2;
else
return 0;
}
string player_1(string str) {
string player;
int i = 0;
while (str[i] != '-') {
player.push_back(str[i]);
i++;
}
return player;
}
string player_2(string str) {
string player;
int i = str.size() - 1;
while (str[i] != '-') {
player.push_back(str[i]);
i--;
}
reverse(player.begin(), player.end());
return player;
}
int player_id(vector<string> tms, string ply) {
for (int i = 0; i < tms.size(); i++)
if (ply == tms[i]) return i;
}
int main() {
int team_no, score_1, score_2, i, j, player_1_id, player_2_id;
char dot;
string score, team_1, team_2;
vector<string> teams_id;
cin >> team_no;
for (i = 0; i < team_no; i++) {
cin >> teams[i].team_id;
teams_id.push_back(teams[i].team_id);
}
int games = team_no * (team_no - 1) / 2;
for (i = 0; i < games; i++) {
cin >> score >> score_1 >> dot >> score_2;
player_1_id = player_id(teams_id, player_1(score));
player_2_id = player_id(teams_id, player_2(score));
switch (referer(score_1, score_2)) {
case 0: {
teams[player_1_id].points += 1;
teams[player_2_id].points += 1;
teams[player_1_id].scored_goals += score_1;
teams[player_1_id].missed_goals += score_2;
teams[player_2_id].scored_goals += score_2;
teams[player_2_id].missed_goals += score_1;
break;
}
case 1: {
teams[player_1_id].points += 3;
teams[player_1_id].scored_goals += score_1;
teams[player_1_id].missed_goals += score_2;
teams[player_2_id].scored_goals += score_2;
teams[player_2_id].missed_goals += score_1;
break;
}
case 2: {
teams[player_2_id].points += 3;
teams[player_1_id].scored_goals += score_1;
teams[player_1_id].missed_goals += score_2;
teams[player_2_id].scored_goals += score_2;
teams[player_2_id].missed_goals += score_1;
break;
}
}
}
for (i = 0; i < team_no; i++)
teams[i].S_M = teams[i].scored_goals - teams[i].missed_goals;
for (i = 0; i < team_no - 1; i++) {
for (j = 0; j < team_no - i - 1; j++) {
if (teams[j].points < teams[j + 1].points)
swap(teams[j], teams[j + 1]);
else {
if (teams[j].points == teams[j + 1].points) {
if (teams[j].S_M < teams[j + 1].S_M)
swap(teams[j], teams[j + 1]);
else {
if (teams[j].S_M == teams[j + 1].S_M) {
if (teams[j].scored_goals < teams[j + 1].scored_goals)
swap(teams[j], teams[j + 1]);
}
}
}
}
}
}
teams_id.clear();
for (i = 0; i < team_no / 2; i++) teams_id.push_back(teams[i].team_id);
sort(teams_id.begin(), teams_id.end());
for (i = 0; i < teams_id.size(); i++) cout << teams_id[i] << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
for (int i = 0; i <= 8; i++) printf("%d??<>%d\n", i, i + 1);
puts("9??>>??0");
puts("??<>1");
for (int i = 0; i < 10; i++) printf("?%d>>%d?\n", i, i);
puts("?>>??");
puts(">>?");
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
map<string, set<string> > have;
bool check(const string &a, const string &b) {
int n = (int)a.size(), m = (int)b.size();
if (n > m) return false;
string cur = b.substr(m - n, n);
if (cur == a)
return true;
else
return false;
}
int main() {
srand(1373737);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, x;
cin >> n;
string s, pn;
for (int i = 0; i < (int)n; i++) {
cin >> s >> x;
for (; x; x--) {
cin >> pn;
have[s].insert(pn);
}
}
map<string, set<string> > ans;
for (auto it = have.begin(); it != have.end(); it++) {
s = it->first;
set<string> ms = it->second;
vector<string> now(ms.begin(), ms.end());
for (int i = 0; i < (int)(int)now.size(); i++) {
bool flag = true;
for (int j = 0; j < (int)(int)now.size(); j++) {
if (i == j) continue;
if (check(now[i], now[j])) {
flag = false;
break;
}
}
if (flag) ans[s].insert(now[i]);
}
}
cout << (int)ans.size() << '\n';
for (auto it = ans.begin(); it != ans.end(); it++) {
cout << it->first << " " << (int)it->second.size() << " ";
for (auto it1 = it->second.begin(); it1 != it->second.end(); it1++)
cout << *it1 << " ";
cout << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
scanf("%I64d", &n);
long long ans;
ans = 1;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
ans *= i;
}
while (n % i == 0) {
n /= i;
}
}
if (n > 1) {
ans *= n;
}
printf("%I64d", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void Nhap(int &n) { cin >> n; }
void Nhapmang(int a[], int n) {
int i;
for (i = 0; i < n; i++) {
cin >> a[i];
}
}
int KQ(int a[], int n) {
int i;
if (n % 2 == 0) {
for (i = 0; i < n - 1; i++) {
if (a[i] % 2 != a[i + 1] % 2) return 0;
}
return 1;
} else {
for (i = 0; i < n; i++) {
if (a[i] % 2 != 0) return 0;
}
return 1;
}
}
int main() {
int t, i, n, j = 0;
cin >> t;
int b[t];
for (i = 1; i <= t; i++) {
Nhap(n);
int a[n];
Nhapmang(a, n);
b[j] = KQ(a, n);
j++;
}
for (i = 0; i < t - 1; i++) {
if (b[i] == 1) {
cout << "NO"
<< "\n";
} else {
cout << "YES"
<< "\n";
}
}
if (b[t - 1] == 1)
cout << "NO";
else
cout << "YES";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
template <typename T1, typename T2>
inline void chmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline void chmax(T1 &a, T2 b) {
if (a < b) a = b;
}
struct FastIO {
FastIO() {
cin.tie(0);
ios::sync_with_stdio(0);
}
} fastio_beet;
signed main() {
string s;
cin >> s;
Int n = s.size();
vector<Int> nx(n, -1);
Int ans = 0;
set<Int> R, L, A, B;
set<int> R1, R2, L1, L2;
auto build = [&]() {
for (Int i = 0; i < n; i++) {
if (s[i] == 'R') {
if (!L2.empty()) {
Int v = *L2.begin();
L2.erase(v);
nx[v] = i;
R1.emplace(i);
} else if (!L1.empty()) {
Int v = *L1.begin();
L1.erase(v);
nx[v] = i;
R2.emplace(i);
} else {
A.emplace(i);
R1.emplace(i);
}
}
if (s[i] == 'L') {
if (!R2.empty()) {
Int v = *R2.begin();
R2.erase(v);
nx[v] = i;
L1.emplace(i);
} else if (!R1.empty()) {
Int v = *R1.begin();
R1.erase(v);
nx[v] = i;
L2.emplace(i);
} else {
B.emplace(i);
L1.emplace(i);
}
}
chmax(ans,
(Int)R1.size() + (Int)R2.size() + (Int)L1.size() + (Int)L2.size());
}
};
build();
for (int r : R1) R.emplace(r);
for (int r : R2) R.emplace(r);
for (int l : L1) L.emplace(l);
for (int l : L2) L.emplace(l);
const int DEBUG = 0;
vector<Int> fr(n, -1), bk(n, -1);
for (Int a : A) {
Int p = a;
if (DEBUG) {
cout << a << ":" << s[a];
while (~nx[p]) p = nx[p], cout << s[p];
cout << ":" << p << endl;
}
p = a;
while (~nx[p]) p = nx[p];
fr[p] = a;
bk[a] = p;
}
for (Int b : B) {
Int p = b;
if (DEBUG) {
cout << b << ":" << s[b];
while (~nx[p]) p = nx[p], cout << s[p];
cout << ":" << p << endl;
}
p = b;
while (~nx[p]) p = nx[p];
fr[p] = b;
bk[b] = p;
}
set<int> A1, A2, B1, B2;
for (int r : R1) A1.emplace(fr[r]);
for (int l : L2) A2.emplace(fr[l]);
for (int l : L1) B1.emplace(fr[l]);
for (int r : R2) B2.emplace(fr[r]);
for (Int a : A) {
assert(~bk[a]);
assert(fr[bk[a]] == a);
}
for (Int b : B) {
assert(~bk[b]);
assert(fr[bk[b]] == b);
}
for (Int r : R) {
assert(~fr[r]);
assert(bk[fr[r]] == r);
}
for (Int l : L) {
assert(~fr[l]);
assert(bk[fr[l]] == l);
}
Int st = 0, en = bk[0];
while (1) {
if (DEBUG) cout << st << " " << en << endl;
if (A1.count(st)) A1.erase(st);
if (B1.count(st)) B1.erase(st);
if (R1.count(en)) R1.erase(en);
if (L1.count(en)) L1.erase(en);
if (A2.count(st)) A2.erase(st);
if (B2.count(st)) B2.erase(st);
if (R2.count(en)) R2.erase(en);
if (L2.count(en)) L2.erase(en);
if (s[st] == 'R' && !L2.empty()) {
Int v = *L2.begin();
L2.erase(v);
nx[v] = st;
st = fr[v];
continue;
}
if (s[st] == 'L' && !R2.empty()) {
Int v = *R2.begin();
R2.erase(v);
nx[v] = st;
st = fr[v];
continue;
}
if (s[en] == 'R' && !B2.empty()) {
Int v = *B2.begin();
B2.erase(v);
nx[en] = v;
en = bk[v];
continue;
}
if (s[en] == 'L' && !A2.empty()) {
Int v = *A2.begin();
A2.erase(v);
nx[en] = v;
en = bk[v];
continue;
}
if (DEBUG) cout << "UKU" << endl;
if (s[st] == 'R' && !L1.empty()) {
Int v = *L1.begin();
L1.erase(v);
nx[v] = st;
st = fr[v];
continue;
}
if (s[st] == 'L' && !R1.empty()) {
Int v = *R1.begin();
R1.erase(v);
nx[v] = st;
st = fr[v];
continue;
}
if (s[en] == 'R' && !B1.empty()) {
Int v = *B1.begin();
B1.erase(v);
nx[en] = v;
en = bk[v];
continue;
}
if (s[en] == 'L' && !A1.empty()) {
Int v = *A1.begin();
A1.erase(v);
nx[en] = v;
en = bk[v];
continue;
}
break;
}
if (DEBUG) return 0;
cout << ans - 1 << endl;
Int pos = st;
Int len = 0;
while (~pos) {
len++;
if (pos != st) cout << " ";
cout << pos + 1;
pos = nx[pos];
}
cout << endl;
assert(len == n);
return 0;
}
| 9 |
// Problem: A. And Then There Were K
// Contest: Codeforces - Codeforces Round #721 (Div. 2)
// URL: https://codeforces.com/contest/1527/problem/A
// Memory Limit: 256 MB
// Time Limit: 1000 ms
//
// Powered by CP Editor (https://cpeditor.org)
/* author: gigawhiz */
#include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
#define endl "\n"
#define sd(val) scanf("%d", &val)
#define ss(val) scanf("%s", &val)
#define sl(val) scanf("%lld", &val)
#define debug(val) printf("check%d\n", val)
#define all(v) v.begin(), v.end()
#define PB push_back
#define MP make_pair
#define FF first
#define SS second
#define ll long long int
#define mod 1000000007
#define mod1 998244353
#define clr(val) memset(val, 0, sizeof(val))
#define what_is(x) cerr << #x << " is " << x << endl;
#define OJ \
freopen("input.txt", "r", stdin); \
freopen("output.txt", "w", stdout);
#define FIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
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);
}
};
// Returns (a * b) % mod
ll prod(ll a, ll b) {
ll res = 0;
a %= mod;
while (b) {
if (b & 1ll) res = (res + a) % mod;
a = (2ll * a) % mod;
b >>= 1ll; // b = b / 2
}
return res;
}
// bool isprime(int x){
// for(int i = 2; i*i <= x; i++){
// if(x%i == 0) return false;
// }
// return true;
// }
//
ll power(ll a, ll b) {
ll res = 1ll;
while (b > 0) {
if (b % 2ll) res = (res * a) % mod;
a = (a * a) % mod;
b /= 2ll;
}
return res;
}
ll binaryExponentiation(ll a, ll b) {
ll result = 1ll;
while (b > 0) {
if (b % 2 == 1) result = (result * a) % mod;
a = (a * a) % mod;
b /= 2ll;
}
return result;
}
ll ModularInverse(ll a) { return binaryExponentiation(a, mod - 2); }
// // Returns factorial of n
// ll fact(ll n)
// {
// ll res = 1;
// for (int i = 2; i <= n; i++){
// res = (res * i)%mod;
// }
// return res%mod;
// }
//
// vector<int> ff;
// int fact(int x){
// if(x == 0) return 1;
// if(ff[x] != -1) return ff[x];
// return ff[x] = (x*fact(x-1))%mod;
// }
//
// ll nCr(ll n, ll r)
// {
// return (fact(n) * ModularInverse((fact(r) * fact(n - r))% mod)) % mod;
// }
///////////////////////////////////////////////////////////////////////////////
void solve() {
// Code here
ll n;
cin >> n;
cout << power(2,log2(n)) - 1 << endl;
}
signed main() {
FIO;
// int t = 1;
ll t;
cin >> t;
while (t--) {
solve();
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int dx[2] = {5, 11};
int dy[4] = {3, 5, 9, 11};
int main() {
int n, m;
cin >> n >> m;
if (m == 1 or (m == 2 and n > 3) or (m == 3 and n > 5)) {
cout << "-1\n";
return 0;
}
if (n == 1) {
cout << "1\n";
return 0;
}
if (m == 2) {
cout << dx[n - 2] << "\n";
return 0;
}
if (m == 3) {
cout << dy[n - 2] << "\n";
return 0;
}
if (m % 2 == 0 or n + 3 <= m) {
cout << 2 * ((n - 2) / ((m - 2) / 2)) + 1 << "\n";
return 0;
}
if (n + 1 == m) {
cout << "3\n";
return 0;
}
if (n + 4 <= 2 * m) {
cout << 2 * ((n - 3) / ((m - 2) / 2)) + 1 << "\n";
return 0;
}
if (n + 3 == 2 * m) {
cout << "7\n";
return 0;
}
cout << 2 * ((n - 4) / ((m - 2) / 2)) + 1 << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long ans = -(1LL << 60);
vector<int> best;
void solve(vector<int> v, vector<int> m) {
if (v.size() == 1) {
if (v[0] > ans) {
ans = v[0];
best = m;
}
return;
}
for (int i = (0); i < int((int)v.size() - 1); i++) {
int t = -(v[i] + v[i + 1]);
vector<int> v1 = v;
v1.erase(v1.begin() + i);
v1[i] = t;
m.push_back(i + 1);
solve(v1, m);
m.pop_back();
}
}
const int MAXN = 200100;
int p[MAXN];
int moze[MAXN];
int main() {
scanf("%d", &n);
for (int i = (0); i < int(n); i++) scanf("%d", &p[i]);
long long sum = 0;
for (int i = (0); i < int(n); i++) sum += p[i];
for (int i = (0); i < int(n + 1); i++)
if ((i + n) % 3 == 1) moze[i] = 1;
multiset<int> m1, m2, m3;
int tmp = 0;
for (int i = 0; i < n; i += 2) {
tmp++;
m1.insert(p[i]);
}
int tmp1 = 0;
for (int i = 1; i < n; i += 2) {
tmp1++;
m2.insert(p[i]);
}
sort(p, p + n);
if ((tmp + n) % 3 == 1) {
m3.clear();
for (int i = (0); i < int(tmp); i++) m3.insert(p[i]);
if (m3 == m1) swap(p[tmp], p[tmp - 1]);
}
if ((tmp1 + n) % 3 == 1) {
m3.clear();
for (int i = (0); i < int(tmp1); i++) m3.insert(p[i]);
if (m3 == m2) swap(p[tmp1], p[tmp1 - 1]);
}
long long sol = 0;
for (int i = (0); i < int(n); i++) {
sol += p[i];
if (moze[i + 1]) {
ans = max(ans, -sol + (sum - sol));
}
}
if (n % 3 == 1) ans = max(ans, sum);
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1005;
const int MOD = 998244353;
int n, k;
long long d[MAXN][2 * MAXN][6];
long long ans, tot;
int main() {
scanf("%d%d", &n, &k);
d[1][1][0] = 1;
d[1][2][1] = 1;
d[1][2][2] = 1;
d[1][1][3] = 1;
for (int i = 2; i <= n; i++) {
for (int j = 1; j <= (i << 1); j++) {
tot =
d[i - 1][j][0] + d[i - 1][j][1] + d[i - 1][j][2] + d[i - 1][j - 1][3];
d[i][j][0] = tot % MOD;
tot = d[i - 1][j - 1][0] + d[i - 1][j][1] + d[i - 1][j - 2][2] +
d[i - 1][j - 1][3];
d[i][j][1] = tot % MOD;
tot = d[i - 1][j - 1][0] + d[i - 1][j - 2][1] + d[i - 1][j][2] +
d[i - 1][j - 1][3];
d[i][j][2] = tot % MOD;
tot =
d[i - 1][j - 1][0] + d[i - 1][j][1] + d[i - 1][j][2] + d[i - 1][j][3];
d[i][j][3] = tot % MOD;
}
}
ans = (d[n][k][0] + d[n][k][1] + d[n][k][2] + d[n][k][3]) % MOD;
printf("%I64d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s[105];
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
sort(s, s + n);
if (s[n / 2] == s[0])
cout << "Bob";
else
cout << "Alice";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4100;
int n, a[maxn], b[maxn];
int main() {
while (scanf("%d", &n) != EOF) {
int cnta = 0, cntb = 0, sum = 0;
for (int i = 0; i < 2 * n; i++) {
scanf("%d.%d", &a[i], &b[i]);
if (b[i]) {
sum += b[i];
cntb++;
} else
cnta++;
}
int ans = 1 << 29;
for (int i = 0; i <= min(n, cntb); i++) {
if (i + cnta < n) continue;
ans = min(ans, abs(i * 1000 - sum));
}
printf("%.3f\n", fabs(ans * 1.0 / 1000));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<long long> a(n);
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
int k = -1, z = 0;
long long mx = -1, mn = 0x3f3f3f3f3f3f3f3f;
for (int i = 0; i < n; i++) {
if (a[i] > 0) z = 1;
if (a[i] > mx && a[i] > a[(i - 1 + n) % n]) {
k = i;
mx = a[i];
}
mn = min(mn, a[i]);
}
if (z == 0) {
puts("YES");
for (int i = 0; i < n; i++) printf("1 ");
return 0;
}
if (k == -1 || mn == mx) {
puts("NO");
return 0;
}
vector<long long> b(n);
b[k] = a[k];
k = (k - 1 + n) % n;
b[k] = b[(k + 1) % n] * 10000000 + a[k];
for (int i = 1; i < n - 1; i++) {
int j = (k - i + n) % n;
b[j] = a[j] + b[(j + 1) % n];
}
puts("YES");
for (int i = 0; i < n; i++) printf("%I64d ", b[i]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
long long k, a, b;
long long f(long long x) { return x / k; }
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> k >> a >> b;
long long ans = 0;
if (0 >= a && 0 <= b) ans++;
if (b > 0)
ans += f(b);
else if (b < 0)
ans -= f(abs(b) - 1);
if (a > 0)
ans -= f(a - 1);
else if (a < 0)
ans += f(abs(a));
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int oo = (int)1e9;
const double PI = 2 * acos(0.0);
const double eps = 1e-9;
const long long MOD = 1000000007;
long long pw(long long n, long long p) {
if (p == 0) return 1;
long long ret = pw(n, p / 2);
if (p % 2 == 1)
return ((ret * ret) % MOD * n) % MOD;
else
return (ret * ret) % MOD;
}
int main() {
ios_base::sync_with_stdio(false);
string ans = "", t;
bool isprevamplifying = true, iscurramplifying;
while (getline(cin, t)) {
iscurramplifying = false;
for (int i = 0; i < (int)(((int)t.size())); i++)
if (t[i] == '#')
iscurramplifying = true;
else if (t[i] != ' ')
break;
if (iscurramplifying) {
if (isprevamplifying)
ans += t + '\n';
else
ans += '\n' + t + '\n';
} else {
for (int i = 0; i < (int)(((int)t.size())); i++)
if (t[i] != ' ') ans += t[i];
}
isprevamplifying = iscurramplifying;
}
if (!isprevamplifying) ans += '\n';
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<string> lx, ly;
vector<int> my[1 << 20];
char str[1 << 20] = {0};
int id = 0;
int get(int i, string &s, int &t) {
s = "";
int j = 0;
if (str[i] == '<') {
if (str[i + 1] == '/') {
t = 2;
for (j = i + 2;; j++) {
if (str[j] == '>') {
break;
}
s += str[j];
}
return j + 1;
} else {
for (j = i + 1;; j++) {
if (str[j] == '/' || str[j] == '>') {
break;
}
s += str[j];
}
if (str[j] == '/') {
t = 3;
return j + 2;
} else {
t = 1;
return j + 1;
}
}
} else {
t = 2;
return i + 1;
}
}
int tt(int p, int i) {
string s;
int t = 0, j = 0;
while (true) {
j = get(i, s, t);
if (t == 3) {
lx.push_back(s);
my[p].push_back(id);
my[id].clear();
id++;
} else if (t == 1) {
lx.push_back(s);
my[p].push_back(id);
my[id].clear();
id++;
j = tt(id - 1, j);
} else {
return j;
}
i = j;
}
}
int f(int x, int ax) {
int ans = 0, i = 0;
if (ax + 1 < ly.size() && lx[x] == ly[ax + 1]) {
ax++;
}
if (ax == ly.size() - 1 && lx[x] == ly[ly.size() - 1]) {
ans++;
}
for (i = 0; i < my[x].size(); i++) {
ans += f(my[x][i], ax);
}
return ans;
}
int main() {
int i = 0, Q = 0;
string s;
while (scanf("%s", str) == 1) {
lx.clear();
lx.push_back("");
my[0].clear();
id = 1;
tt(0, 0);
scanf("%d", &Q);
gets(str);
while (Q--) {
ly.clear();
gets(str);
s = "";
for (i = 0; str[i]; i++) {
if (str[i] != ' ') {
s += str[i];
} else if (s.size()) {
ly.push_back(s);
s = "";
}
}
if (s.size()) {
ly.push_back(s);
s = "";
}
printf("%d\n", f(0, -1));
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
inline long long getint() {
long long _x = 0, _tmp = 1;
char _tc = getchar();
while ((_tc < '0' || _tc > '9') && _tc != '-') _tc = getchar();
if (_tc == '-') _tc = getchar(), _tmp = -1;
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x * _tmp;
}
inline long long add(long long _x, long long _y,
long long _mod = 1000000007LL) {
_x += _y;
return _x >= _mod ? _x - _mod : _x;
}
inline long long sub(long long _x, long long _y,
long long _mod = 1000000007LL) {
_x -= _y;
return _x < 0 ? _x + _mod : _x;
}
inline long long mul(long long _x, long long _y,
long long _mod = 1000000007LL) {
_x *= _y;
return _x >= _mod ? _x % _mod : _x;
}
long long mypow(long long _a, long long _x, long long _mod) {
if (_x == 0) return 1LL;
long long _ret = mypow(mul(_a, _a, _mod), _x >> 1, _mod);
if (_x & 1) _ret = mul(_ret, _a, _mod);
return _ret;
}
long long mymul(long long _a, long long _x, long long _mod) {
if (_x == 0) return 0LL;
long long _ret = mymul(add(_a, _a, _mod), _x >> 1, _mod);
if (_x & 1) _ret = add(_ret, _a, _mod);
return _ret;
}
inline bool equal(double _x, double _y) {
return _x > _y - 1e-9 && _x < _y + 1e-9;
}
int __ = 1, _cs;
struct Permu {
int a[10];
Permu() {
for (int i = 0; i < 10; i++) a[i] = i;
}
Permu operator*(const Permu& he) const {
Permu ret;
for (int i = 0; i < 10; i++) ret.a[i] = he.a[a[i]];
return ret;
}
};
struct SegT {
long long st[131072 << 1][10];
Permu p[131072 << 1];
void build_st(int no, int l, int r) {
for (int i = 0; i < 10; i++) st[no][i] = 0;
p[no] = Permu();
if (l == r) return;
build_st((no << 1), l, ((l + r) >> 1));
build_st((1 + (no << 1)), ((l + r) >> 1) + 1, r);
}
void add(int no, int l, int r, int pos, int vv, long long dlt) {
st[no][vv] += dlt;
if (l == r) return;
if (pos <= ((l + r) >> 1))
add((no << 1), l, ((l + r) >> 1), pos, vv, dlt);
else
add((1 + (no << 1)), ((l + r) >> 1) + 1, r, pos, vv, dlt);
}
void push(int no, int l, int r) {
bool dif = false;
for (int i = 0; i < 10; i++)
if (p[no].a[i] != i) {
dif = true;
break;
}
if (not dif) return;
long long tmp[10];
for (int id : {(no << 1), (1 + (no << 1))}) {
for (int i = 0; i < 10; i++) tmp[i] = 0;
for (int i = 0; i < 10; i++) tmp[p[no].a[i]] += st[id][i];
for (int i = 0; i < 10; i++) st[id][i] = tmp[i];
p[id] = p[id] * p[no];
}
p[no] = Permu();
}
void modify(int no, int l, int r, int ql, int qr, int fr, int to) {
if (qr < l or ql > r) return;
if (ql <= l and r <= qr) {
Permu tp;
tp.a[fr] = to;
p[no] = p[no] * tp;
st[no][to] += st[no][fr];
st[no][fr] = 0;
return;
}
push(no, l, r);
modify((no << 1), l, ((l + r) >> 1), ql, qr, fr, to);
modify((1 + (no << 1)), ((l + r) >> 1) + 1, r, ql, qr, fr, to);
for (int i = 0; i < 10; i++)
st[no][i] = st[(no << 1)][i] + st[(1 + (no << 1))][i];
}
long long query(int no, int l, int r, int ql, int qr) {
if (qr < l or ql > r) return 0;
if (ql <= l and r <= qr) {
long long ret = 0;
for (int i = 1; i < 10; i++) ret += i * st[no][i];
return ret;
}
push(no, l, r);
return query((no << 1), l, ((l + r) >> 1), ql, qr) +
query((1 + (no << 1)), ((l + r) >> 1) + 1, r, ql, qr);
}
} st;
long long bs[10];
void build() {
bs[0] = 1;
for (int i = 1; i < 10; i++) bs[i] = bs[i - 1] * 10;
}
int n, q;
void init() {
n = getint();
q = getint();
st.build_st(1, 1, n);
for (int i = 1; i <= n; i++) {
int ai = getint();
for (int j = 0; j < 9; j++) {
if (ai == 0) break;
st.add(1, 1, n, i, ai % 10, bs[j]);
ai /= 10;
}
}
}
void solve() {
while (q--) {
int cmd = getint();
if (cmd == 1) {
int l = getint();
int r = getint();
int x = getint();
int y = getint();
if (x == y) continue;
for (int i = 0; i < 9; i++) st.modify(1, 1, n, l, r, x, y);
} else {
int l = getint();
int r = getint();
printf("%lld\n", st.query(1, 1, n, l, r));
}
}
}
int main() {
build();
while (__--) {
init();
solve();
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp, vis;
vector<long double> vv;
vector<pair<long long, long long> > vp;
string s, q;
char c;
int main() {
long double t = 0, n, m, l, r, mn = 0, mx = 0, ans = 0, nm = 0, cnt = 0, x, y,
z, d, v, g;
cin >> l >> d >> v >> g >> r;
l -= d;
t += d / v;
long long p = (long long)t / (long long)(g + r);
x = t - (p * (g + r));
if (x >= g) t += r - (x - g);
t += l / v;
cout << setprecision(10) << fixed << t;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> smPrime(1000000 + 2);
vector<long long> primeAr;
void prAr(vector<long long> a) {
auto print = [](const long long &n) { cout << n << " "; };
for_each(a.begin(), a.end(), print);
cout << endl;
}
void prAr(vector<vector<long long> > a) {
auto print = [](const vector<long long> &n) { prAr(n); };
for_each(a.begin(), a.end(), print);
cout << endl;
}
void seiveAtulAg() {
long long i, j, k;
for (i = 0; i < 1000000; i++) smPrime[i] = i;
smPrime[0] = smPrime[1] = -1;
for (i = 2; i <= 1000000; i += 2) smPrime[i] = 2;
for (i = 3; i * i < 1000000; i += 2) {
if (smPrime[i] == i) {
for (j = i * i; j < 1000000; j += i) {
smPrime[j] = i;
}
}
}
for (i = 2; i <= 1000000; i++) {
if (smPrime[i] == i) {
primeAr.push_back(i);
}
}
}
void pfact(long long &n, vector<pair<long long, long long> > &factAr) {
factAr.clear();
long long i, loop = primeAr.size(), cnt;
for (i = 0; i < loop && n > 1; i++) {
cnt = 0;
while (n > 1 && n % primeAr[i] == 0) {
n /= primeAr[i];
cnt++;
}
if (cnt != 0) factAr.push_back({primeAr[i], cnt});
}
}
int main() {
long long t, m, i, j, k, fpr, fcnt, lcm = 1, dm;
seiveAtulAg();
vector<bool> hs(1000010, false);
vector<long long> ans;
cin >> m;
vector<long long> ar(m, 0);
for (i = 0; i < m; i++) {
cin >> ar[i];
hs[ar[i]] = true;
}
bool pos = true;
for (i = 1; i < m && pos; i++) {
if (ar[i] % ar[0]) {
pos = false;
}
}
if (pos) {
cout << (2 * ar.size() - 1) << endl;
cout << ar[0] << " ";
for (i = 1; i < m; i++) {
cout << ar[i] << " " << ar[0] << " ";
}
} else {
cout << "-1";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
scanf("%d", &N);
int P;
scanf("%d", &P);
vector<int> As, Bs;
long long SA = 0, SB = 0;
for (decltype(N) _i = 0, _n = (N); _i < _n; _i++) {
int A;
scanf("%d", &A);
int B;
scanf("%d", &B);
As.push_back(A);
Bs.push_back(B);
SA += A;
SB += B;
}
auto check = [&](double t) {
double tmp = 0.0;
for (decltype(N) i = 0, _n = (N); i < _n; i++) {
tmp += max(As[i] * t - Bs[i], 0.0) / P;
}
return tmp <= t;
};
if (SA <= P) {
printf("-1\n");
} else {
double l = 0.0, r = SB * 2.0;
int cnt = 0;
while (1e-10 < (r - l) and cnt < 1000) {
cnt++;
double c = (l + r) / 2;
if (check(c)) {
l = c;
} else {
r = c;
}
}
printf("%f", l);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s[6];
int l[6], i, k;
void draw(vector<string> &w, int i, int j, int di, int dj, string s) {
for (k = 0; k < s.size(); k++, i += di, j += dj) w[i][j] = s[k];
}
int main() {
for (i = 0; i < 6; i++) cin >> s[i];
sort(s, s + 6);
vector<string> res;
res.clear();
do {
if (s[0].size() + s[2].size() == s[1].size() + 1 &&
s[3].size() + s[5].size() == s[4].size() + 1) {
for (i = 0; i < 6; i++) l[i] = s[i].size() - 1;
if (s[0][0] == s[3][0] && s[0][l[0]] == s[4][0] &&
s[1][0] == s[3][l[3]] && s[1][l[0]] == s[4][l[3]] &&
s[1][l[1]] == s[5][0] && s[2][0] == s[4][l[4]] &&
s[2][l[2]] == s[5][l[5]]) {
int n = l[1] + 1, m = l[4] + 1;
vector<string> w(n, string(m, '.'));
draw(w, 0, 0, 1, 0, s[0]);
draw(w, 0, l[3], 1, 0, s[1]);
draw(w, l[0], m - 1, 1, 0, s[2]);
draw(w, 0, 0, 0, 1, s[3]);
draw(w, l[0], 0, 0, 1, s[4]);
draw(w, n - 1, l[3], 0, 1, s[5]);
if (res.size() == 0 || res > w) res = w;
}
}
} while (next_permutation(s, s + 6));
if (!res.size())
cout << "Impossible";
else
for (i = 0; i < res.size(); i++) cout << res[i] << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double n, a;
int main() {
cin >> n >> a;
double c = (180 * (n - 2) / n);
double d = (180 - c) / 2;
if (a <= d)
cout << 2 << " " << 1 << " " << 3 << endl;
else if (a >= c)
cout << 2 << " " << 1 << " " << n << endl;
else {
int t = a / d;
double a1 = t * d, a2 = t * d + d;
if ((a - a1) >= (a2 - a))
cout << 2 << " " << 1 << " " << t + 3 << endl;
else
cout << 2 << " " << 1 << " " << t + 2 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> va(100001);
vector<long long> v1, v2;
bool zer = false;
long long ans = 1e18;
long long proc(string a) {
long long i, sum = 0, pre;
if (a == "0") return 0;
long long j = 0, k = 0;
for (i = 0; i < a.size(); i++) {
if (a[i] != '0') {
if (k != 0) {
if (j % 3 == 1)
v1.push_back(k - 1);
else if (j % 3 == 2)
v2.push_back(k - 1);
va[pre] = k - 1;
}
pre = i;
j = a[i] - '0';
sum += j;
k = 1;
} else {
k++;
zer = true;
}
}
k--;
if (j % 3 == 1)
v1.push_back(k);
else if (j % 3 == 2)
v2.push_back(k);
va[pre] = k;
return sum;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, i, j, m, l, t, x, k;
double sg, fg, s, tt;
string a, b, c, d;
vector<vector<long long> > v(10);
cin >> a;
long long sum = proc(a);
if (sum % 3 == 0) {
cout << a << endl;
return 0;
} else {
ans = -1;
bool rem = false;
if (sum % 3 == 1) {
b = c = "", d;
x = 1;
if (v1.size() > 0)
for (i = a.size() - 1; i > -1; i--) {
if ((a[i] - '0') % 3 == 1 && x == 1)
x--;
else
b += a[i];
}
reverse(b.begin(), b.end());
d = b;
b = "";
rem = false;
for (i = 0; i < d.size(); i++) {
if (d[i] != '0') rem = true;
if (rem) b += d[i];
}
x = 2;
if (v2.size() >= 2)
for (i = a.size() - 1; i > -1; i--) {
if ((a[i] - '0') % 3 == 2 && x != 0)
x--;
else
c += a[i];
}
reverse(c.begin(), c.end());
d = c;
c = "";
for (i = 0; i < d.size(); i++) {
if (d[i] != '0') rem = true;
if (rem) c += d[i];
}
l = max(b.size(), c.size());
if (l == 0)
ans = 1e18;
else if (b.size() == l)
a = b;
else if (c.size() == l)
a = c;
}
if (sum % 3 == 2) {
b = c = "", d;
x = 1;
if (v2.size() > 0)
for (i = a.size() - 1; i > -1; i--) {
if ((a[i] - '0') % 3 == 2 && x == 1) {
x--;
} else
b += a[i];
}
reverse(b.begin(), b.end());
d = b;
b = "";
rem = false;
for (i = 0; i < d.size(); i++) {
if (d[i] != '0') rem = true;
if (rem) b += d[i];
}
x = 2;
if (v1.size() >= 2)
for (i = a.size() - 1; i > -1; i--) {
if ((a[i] - '0') % 3 == 1 && x != 0)
x--;
else
c += a[i];
}
reverse(c.begin(), c.end());
d = c;
c = "";
for (i = 0; i < d.size(); i++) {
if (d[i] != '0') rem = true;
if (rem) c += d[i];
}
l = max(b.size(), c.size());
if (l == 0)
ans = 1e18;
else if (b.size() == l)
a = b;
else if (c.size() == l)
a = c;
}
}
if (ans == 1e18)
(zer == true) ? cout << "0" << endl : cout << "-1" << endl;
else
cout << a << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast", "inline")
using namespace std;
const int maxn = 5e5 + 5;
int n, m;
vector<int> e[maxn];
vector<int> d[maxn];
int w[maxn];
long long vis[maxn];
int ans[maxn];
int tot;
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d %d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
scanf("%d", w + i);
d[w[i]].push_back(i);
}
for (int i = 1; i <= n; ++i) {
for (auto j : d[i]) {
if (vis[j] != (i - 1) * 1ll * i / 2) {
printf("-1\n");
return 0;
}
ans[++tot] = j;
for (auto k : e[j]) {
if (vis[k] != (i + 1) * 1ll * i / 2) {
vis[k] += i;
}
}
}
}
for (int i = 1; i <= tot; ++i) {
printf("%d ", ans[i]);
}
printf("\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vec[200010];
int main() {
int n, x, m;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
vec[x].push_back(i + 1);
}
int persons = 0;
vector<int> ans;
m = n;
while (m-- > 0) {
while (persons >= 0 && vec[persons].empty()) persons -= 3;
if (persons < 0) {
printf("Impossible\n");
return 0;
}
ans.push_back(vec[persons].back());
vec[persons].pop_back();
persons++;
}
printf("Possible\n");
for (int i = 0; i < n; i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, n;
cin >> q;
for (int i = 0; i < q; i++) {
cin >> n;
vector<int> perms(n);
for (int j = 0; j < n; ++j) {
cin >> perms[j];
}
int pos = 0;
while (pos < n) {
int next = distance(perms.begin(),
min_element(perms.begin() + pos, perms.end()));
int el = perms[next];
perms.erase(perms.begin() + next);
perms.insert(perms.begin() + pos, el);
if (pos == next)
pos = next + 1;
else
pos = next;
}
for (auto it : perms) cout << it << " ";
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, m;
while (scanf("%d %d", &n, &m) == 2) {
i = 1;
while (m >= i) {
m -= i;
if (i == n)
i = 1;
else
++i;
}
printf("%d\n", m);
}
return 0;
}
| 0 |
#include "bits/stdc++.h"
using namespace std;
#define all(x) begin(x),end(x)
template<typename A, typename B> ostream& operator<<(ostream &os, const pair<A, B> &p) { return os << '(' << p.first << ", " << p.second << ')'; }
template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> ostream& operator<<(ostream &os, const T_container &v) { string sep; for (const T &x : v) os << sep << x, sep = " "; return os; }
#define debug(a) cerr << "(" << #a << ": " << a << ")\n";
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pi;
const int mxN = 1e5+1, oo = 1e9;
int main() {
int t; cin >> t;
while(t--) {
int n; cin >> n;
vi a(n);
ll total = 0, ans=0;
for(int& i : a) {
cin >> i;
total+=i;
}
if(n<=2) {
if(n==1) ans = 1;
else {
if(a[0] == a[1]) {
ans=1;
} else {
ans=2;
}
}
cout << ans << '\n';
continue;
}
vector<ll> pref(n+1);
for(int i=1;i<=n;++i) {
pref[i] = a[i-1];
if(i>=2) pref[i]+=pref[i-2];
}
auto range = [&](int l, int r) {
return pref[r+1]-pref[max(l-1,0)];
};
auto solve = [&](int aa, int bb, ll got, bool nope=false) {
for(int j=bb;j>=aa-1;--j) {
int l=0, r = 1 + (j-aa+1)/2;
if(nope and j==bb) r = min(r,1);
int hi = r;
while(l<r) {
int mid = (l+r)/2;
ll extra = range(j-mid*2+1,j-1);
if((got+extra)*2<=total) {
l=mid+1;
} else {
r = mid;
}
}
ans+=hi - r;
got+=a[j];
}
};
solve(1,n-2,0,true);
solve(2,n-2, a[0],true);
solve(2,n-2, a[0]+a.back());
solve(1,n-2, a.back());
ll cur=a[0];
for(int i=1;i<n;++i) {
cur+=a[i];
if(cur*2>total) ans++;
}
cout << ans%998244353 << '\n';
}
} | 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
#pragma GCC optimize("O500")
using namespace std;
const bool db = false;
long long t[4 * 300100], a[300100];
void build(int v, int L, int R) {
if (L == R)
t[v] = max(0LL, a[L]);
else {
int md = (L + R) >> 1;
build(v << 1, L, md);
build((v << 1) + 1, md + 1, R);
t[v] = t[v << 1] + t[(v << 1) + 1];
}
}
long long get(int v, int L, int R, int l, int r) {
if (L == l && r == R)
return t[v];
else {
int md = (L + R) >> 1;
if (r <= md)
return get(v << 1, L, md, l, r);
else if (md < l)
return get((v << 1) + 1, md + 1, R, l, r);
else
return (get(v << 1, L, md, l, md) +
get((v << 1) + 1, md + 1, R, md + 1, r));
}
}
map<int, int> L, R;
int main() {
int n;
scanf("%d\n", &n);
for (int i = 1; i <= n; i++) scanf("%lld ", &a[i]);
build(1, 1, n);
for (int i = 1; i <= n; i++) {
if (!L.count(a[i])) L[a[i]] = i;
R[a[i]] = i;
}
long long mx = LLONG_MIN, temp;
int ans_l, ans_r;
ans_l = ans_r = 1;
for (auto i : L) {
if (R[i.first] != i.second) {
temp = 2 * i.first;
if (L[i.first] + 1 < R[i.first])
temp += get(1, 1, n, L[i.first] + 1, R[i.first] - 1);
if (mx < temp) mx = temp, ans_l = L[i.first], ans_r = R[i.first];
}
}
vector<int> ans;
for (int i = 1; i < ans_l; i++) ans.push_back(i);
for (int i = ans_l + 1; i <= ans_r - 1; i++)
if (a[i] < 0) ans.push_back(i);
for (int i = ans_r + 1; i <= n; i++) ans.push_back(i);
printf("%lld %d\n", mx, ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> s(n);
for (int i = 0; i < n; ++i) cin >> s[i];
if (n == 1 && s[0] == 0) {
cout << "0" << endl;
return 0;
}
sort(s.begin(), s.end());
vector<int> min;
vector<int> max;
int ct = 1;
for (int i = 0; i < n; ++i) {
if (s[i] < 0) min.push_back(s[i]);
if (s[i] > 0) max.push_back(s[i]);
if (s[i] == 0) ct = 0;
}
int count = 0;
reverse(max.begin(), max.end());
if (min.size() == 0 && max.size() == 0 && ct == 0) {
cout << "0" << endl;
return 0;
}
if (min.size() == 1 && ct == 0 && max.size() == 0) cout << ct << endl;
if (min.size() == 1 && max.size() == 0 && ct != 0) cout << min[0] << endl;
if (min.size() > 1 && min.size() % 2 == 0) {
for (int i = 0; i < min.size(); ++i) cout << min[i] << " ";
}
if (min.size() > 1 && min.size() % 2 == 1) {
min.pop_back();
for (int i = 0; i < min.size(); ++i) cout << min[i] << " ";
}
for (int i = 0; i < max.size(); ++i) cout << max[i] << " ";
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
long long int n, h, k;
scanf("%lld%lld%lld", &n, &h, &k);
long long int a[n], i, count = 0, x;
for (i = 0; i < n; i++) scanf("%lld", &a[i]);
i = 0;
while (i < n) {
count = count + a[i] / k;
a[i] = a[i] % k;
x = a[i];
if (a[i] == 0) {
if (i == n - 1) break;
}
while (1) {
if (i < n)
i++;
else
break;
if (a[i] + x <= h) {
a[i] = a[i] + x;
x = a[i];
} else {
i--;
if (x < k) {
count++;
if (i < n) i++;
}
break;
}
}
}
printf("%lld\n", count);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int n, m;
char a[1000][1000];
int stm = inf;
int stlm = inf;
int stma = -inf;
int stlma = -inf;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] == 'X') {
stlm = min(stlm, i);
stlma = max(stlma, i);
stm = min(stm, j);
stma = max(stma, j);
}
}
for (int i = stlm; i <= stlma; i++)
for (int j = stm; j <= stma; j++)
if (a[i][j] != 'X') {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> g(n, 0);
unordered_set<int> conn;
unordered_set<int> vals;
unordered_multimap<int, int> arestes;
long long n_volt = 0;
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
if (x != y) {
arestes.insert(pair<int, int>(x, y));
if (conn.size() == 0) {
conn.insert(x);
conn.insert(y);
} else if (conn.find(x) != conn.end())
conn.insert(y);
else if (conn.find(y) != conn.end())
conn.insert(x);
++g[x];
++g[y];
} else {
++n_volt;
vals.insert(x);
}
}
m -= n_volt;
bool endavant = true;
for (int i = 0; i < n; ++i) {
if ((conn.find(i) == conn.end() and
(g[i] != 0 or (g[i] == 0 and vals.find(i) != vals.end()))) or
(m == 0))
endavant = false;
}
if (endavant) {
long long ret = 0;
for (auto it = arestes.begin(); it != arestes.end(); ++it) {
long long adjacents = (g[it->first] - 1);
adjacents += g[it->second];
ret += m - adjacents;
}
cout << m * n_volt + (n_volt * (n_volt - 1) / 2) +
((long long)m * (m - 1) / (long long)2 - ret / 2)
<< endl;
} else {
cout << 0 << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int K = 3;
const int N = 1e5 + 10;
const int mod = 1e9 + 7;
const double alpha = 0.75;
long long qpow(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int now;
struct Point {
int num[K], val, id;
Point(){};
Point(int xx, int yy, int vall) { num[0] = xx, num[1] = yy, val = vall; }
friend bool operator<(Point a, Point b) { return a.num[now] < b.num[now]; }
} p[N];
struct tree {
int l, r, siz, minn[K], maxx[K], tf, fa;
long long sum;
Point p;
};
struct KDT {
tree t[N];
int id[N];
int tot, root;
int cnt, rubbish[N];
int cnt1;
long long ans = 0;
priority_queue<long long, vector<long long>, greater<long long> > q;
int newnode() {
if (cnt) return rubbish[cnt--];
return ++tot;
}
void up(int u) {
for (int i = 0; i < K; i++) {
t[u].minn[i] = t[u].maxx[i] = t[u].p.num[i];
if (t[u].l) {
t[u].minn[i] = min(t[u].minn[i], t[t[u].l].minn[i]);
t[u].maxx[i] = max(t[u].maxx[i], t[t[u].l].maxx[i]);
}
if (t[u].r) {
t[u].minn[i] = min(t[u].minn[i], t[t[u].r].minn[i]);
t[u].maxx[i] = max(t[u].maxx[i], t[t[u].r].maxx[i]);
}
}
if (t[u].l) t[t[u].l].fa = u;
if (t[u].r) t[t[u].r].fa = u;
t[u].sum = t[t[u].l].sum + t[t[u].r].sum + t[u].p.val;
t[u].siz = t[t[u].l].siz + t[t[u].r].siz + 1;
}
void slap(int u) {
if (!u) return;
p[++cnt1] = t[u].p;
rubbish[++cnt] = u;
slap(t[u].l);
slap(t[u].r);
}
int rebuild(int l, int r, int d) {
now = d;
if (l > r) return 0;
int mid = (l + r) >> 1, u = newnode();
nth_element(p + l, p + mid, p + r + 1);
t[u].p = p[mid];
id[p[mid].id] = u;
t[u].l = rebuild(l, mid - 1, (d + 1) % K);
t[u].r = rebuild(mid + 1, r, (d + 1) % K);
up(u);
return u;
}
void check(int &u, int d) {
if (t[t[u].l].siz > alpha * t[u].siz || t[t[u].r].siz > alpha * t[u].siz) {
cnt1 = 0;
slap(u);
u = rebuild(1, t[u].siz, d);
}
}
void insert(int &u, Point now, int d) {
if (!u) {
u = newnode();
t[u].l = t[u].r = 0, t[u].p = now;
up(u);
return;
}
if (now.num[d] <= t[u].p.num[d])
insert(t[u].l, now, (d + 1) % K);
else
insert(t[u].r, now, (d + 1) % K);
up(u);
check(u, d);
}
int build(int l, int r, int d) {
if (l > r) return 0;
now = d;
int mid = (l + r) >> 1;
int u = newnode();
nth_element(p + l, p + mid, p + r + 1);
t[u].p = p[mid];
id[p[mid].id] = u;
t[u].l = build(l, mid - 1, (d + 1) % K);
t[u].r = build(mid + 1, r, (d + 1) % K);
up(u);
return u;
}
void change(int x, int v) {
for (t[x = id[x]].p.val += v; x; x = t[x].fa) t[x].sum += v;
}
int out(int u, int x1, int x2, int y1, int y2, int z1, int z2) {
if (t[u].minn[0] > x2 || t[u].maxx[0] < x1 || t[u].minn[1] > y2 ||
t[u].maxx[1] < y1 || t[u].minn[2] > z2 || t[u].maxx[2] < z1) {
return 1;
}
return 0;
}
int in(int u, int x1, int x2, int y1, int y2, int z1, int z2) {
if (t[u].minn[0] >= x1 && t[u].maxx[0] <= x2 && t[u].minn[1] >= y1 &&
t[u].maxx[1] <= y2 && t[u].minn[2] >= z1 && t[u].maxx[2] <= z2) {
return 1;
}
return 0;
}
int query(int u, int x1, int x2, int y1, int y2, int z1, int z2) {
if (!u) return 0;
if (out(u, x1, x2, y1, y2, z1, z2)) return 0;
if (in(u, x1, x2, y1, y2, z1, z2)) return 1;
if (t[u].p.num[0] >= x1 && t[u].p.num[0] <= x2 && t[u].p.num[1] >= y1 &&
t[u].p.num[1] <= y2 && t[u].p.num[2] >= z1 && t[u].p.num[2] <= z2) {
return 1;
}
if (query(t[u].l, x1, x2, y1, y2, z1, z2)) return 1;
if (query(t[u].r, x1, x2, y1, y2, z1, z2)) return 1;
return 0;
}
} T1;
int main() {
int X, Y, Z, n, m, k;
scanf("%d%d%d%d%d%d", &X, &Y, &Z, &n, &m, &k);
int mn1 = X, mx1 = 1, mn2 = Y, mx2 = 1, mn3 = Z, mx3 = 1;
for (int i = 1; i <= n; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
mn1 = min(mn1, x), mx1 = max(mx1, x);
mn2 = min(mn2, y), mx2 = max(mx2, y);
mn3 = min(mn3, z), mx3 = max(mx3, z);
}
for (int i = 1; i <= m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
if (x >= mn1 && x <= mx1 && y >= mn2 && y <= mx2 && z >= mn3 && z <= mx3) {
printf("INCORRECT\n");
return 0;
}
p[i].num[0] = x, p[i].num[1] = y, p[i].num[2] = z;
}
printf("CORRECT\n");
T1.root = T1.build(1, m, 0);
for (int i = 1; i <= k; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
if (x >= mn1 && x <= mx1 && y >= mn2 && y <= mx2 && z >= mn3 && z <= mx3) {
printf("OPEN\n");
continue;
} else {
int MX1 = mx1, MN1 = mn1, MX2 = mx2, MN2 = mn2, MX3 = mx3, MN3 = mn3;
MX1 = max(MX1, x), MN1 = min(MN1, x);
MX2 = max(MX2, y), MN2 = min(MN2, y);
MX3 = max(MX3, z), MN3 = min(MN3, z);
if (T1.query(T1.root, MN1, MX1, MN2, MX2, MN3, MX3)) {
printf("CLOSED\n");
} else {
printf("UNKNOWN\n");
}
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const int mod = 1e9 + 7;
long long n;
int v, vis[maxn], lop[maxn], cnt, vs, fa[maxn];
struct edge {
int u, v, next;
} edges[maxn << 1];
int tot, head[maxn];
void init() {
memset(head, -1, sizeof(head));
tot = 0;
}
void add_edges(int u, int v) {
edges[tot].u = u;
edges[tot].v = v;
edges[tot].next = head[u];
head[u] = tot++;
edges[tot].u = v;
edges[tot].v = u;
edges[tot].next = head[v];
head[v] = tot++;
}
void get_lop(int u) {
vis[u] = ++vs;
for (int i = head[u]; ~i; i = edges[i].next) {
int v = edges[i].v;
if (v == fa[u]) continue;
if (vis[v]) {
if (vis[v] < vis[u]) continue;
++cnt;
for (; v != u; v = fa[v]) {
++cnt;
}
} else {
fa[v] = u;
get_lop(v);
}
}
}
long long qpow(long long a, long long b) {
long long ans = 1;
a %= mod;
for (long long i = b; i; i >>= 1, a = a * a % mod)
if (i & 1) ans = ans * a % mod;
return ans;
}
int main() {
scanf("%lld", &n);
init();
for (int i = 1; i <= n; i++) {
scanf("%d", &v);
add_edges(i, v);
}
long long ans = 1, num = 0;
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
vs = 0;
cnt = 0;
get_lop(i);
num += cnt;
ans = (ans * ((qpow(2ll, cnt) - 2 + mod) % mod)) % mod;
}
}
ans = (ans * (qpow(2ll, n - num)) % mod) % mod;
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
int a[200010];
int low[200010], high[200010];
int ans[200010];
bool check(void) {
int i, j;
if (K <= 0) return false;
for ((i) = 0; (i) < (int)(N); (i)++)
if (a[i] >= K) return false;
for ((i) = 0; (i) < (int)(K + 1); (i)++) low[i] = 0;
for ((i) = 0; (i) < (int)(K + 1); (i)++) high[i] = N;
high[0] = 0;
low[K] = N;
for ((i) = 0; (i) < (int)(N); (i)++)
if (a[i] != -1) {
high[a[i]] = min(high[a[i]], i);
low[a[i] + 1] = max(low[a[i] + 1], i + 1);
}
for ((i) = 0; (i) < (int)(K); (i)++) low[i + 1] = max(low[i + 1], low[i] + 2);
for (i = K; i >= 1; i--) low[i - 1] = max(low[i - 1], low[i] - 5);
for ((i) = 0; (i) < (int)(K + 1); (i)++)
if (low[i] > high[i]) return false;
for ((i) = 0; (i) < (int)(K); (i)++)
for (j = low[i]; j < low[i + 1]; j++) ans[j] = i + 1;
}
void print(void) {
int i;
cout << K << endl;
for ((i) = 0; (i) < (int)(N); (i)++) {
printf("%d", ans[i]);
if (i == N - 1)
printf("\n");
else
printf(" ");
}
}
int main(void) {
int i;
cin >> N;
for ((i) = 0; (i) < (int)(N); (i)++) scanf("%d", &a[i]);
for ((i) = 0; (i) < (int)(N); (i)++) a[i]--;
for (i = N - 1; i >= 0; i--)
if (a[i] != -1) break;
int used = ((i == -1) ? 0 : (a[i] + 1));
int K2 = used + (N - i) / 2;
for (i = 3; i >= -3; i--) {
K = K2 + i;
if (check()) {
print();
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
const int M = 1e9 + 7;
template <class T>
struct lazy_seg {
public:
vector<T> st, lazy;
lazy_seg(int n) { st.resize(4 * n + 1, 0), lazy.resize(4 * n + 1, 0); }
lazy_seg() = default;
T propagate(T a, T b, int l, int r) {
return (a + 1ll * b * (r - l + 1)) % M;
}
T combineTree(T a, T b) { return (a + b) % M; }
void combinelazy(T& a, T b) { a = (a + b) % M; }
void push(int l, int r, int curr) {
if (lazy[curr] != 0) {
st[curr] = propagate(st[curr], lazy[curr], l, r);
if (l != r) {
combinelazy(lazy[2 * curr], lazy[curr]);
combinelazy(lazy[2 * curr + 1], lazy[curr]);
}
lazy[curr] = 0;
}
}
void pull(int l, int r, int curr) {
push(l, r, curr);
int mid = (l + r) / 2;
if (l != r) push(l, mid, 2 * curr), push(mid + 1, r, 2 * curr + 1);
st[curr] = combineTree(st[2 * curr], st[2 * curr + 1]);
}
void upd(int x, int y, T v, int l, int r, int curr) {
int mid = (l + r) / 2;
push(l, r, curr);
if (l == x && r == y) {
lazy[curr] += v;
push(l, r, curr);
return;
}
if (y <= mid)
upd(x, y, v, l, mid, 2 * curr);
else if (x > mid)
upd(x, y, v, mid + 1, r, 2 * curr + 1);
else
upd(x, mid, v, l, mid, 2 * curr),
upd(mid + 1, y, v, mid + 1, r, 2 * curr + 1);
pull(l, r, curr);
}
T qry(int x, int y, int l, int r, int curr) {
int mid = (l + r) / 2;
push(l, r, curr);
if (l == x && r == y) return st[curr];
if (y <= mid)
return qry(x, y, l, mid, 2 * curr);
else if (x > mid)
return qry(x, y, mid + 1, r, 2 * curr + 1);
return combineTree(qry(x, mid, l, mid, 2 * curr),
qry(mid + 1, y, mid + 1, r, 2 * curr + 1));
}
void build(int l, int r, int curr) {
lazy[curr] = 0;
int mid = (l + r) / 2;
if (l == r) {
st[curr] = 0;
return;
}
build(l, mid, 2 * curr);
build(mid + 1, r, 2 * curr + 1);
st[curr] = combineTree(st[2 * curr], st[2 * curr + 1]);
}
};
template <class T>
class HLD {
public:
lazy_seg<T> seg;
HLD(int n)
: Sz(n + 1),
Hd(n + 1),
p(n + 1, -1),
g(n + 1),
out(n + 1),
in(n + 1),
H(n + 1),
n(n) {
seg = lazy_seg<T>(n);
seg.build(0, n - 1, 1);
}
void add_edge(int x, int y) {
g[x].push_back(y);
g[y].push_back(x);
edges++;
assert(edges < n);
}
void dfs_sz(int x, int par = -1) {
Sz[x] = 1;
for (auto& w : g[x]) {
if (w == par) continue;
H[w] = H[x] + 1;
dfs_sz(w, x);
Sz[x] += Sz[w];
if (Sz[w] > Sz[g[x][0]] || g[x][0] == par) swap(w, g[x][0]);
}
}
void dfs_dec(int x, int par = -1) {
in[x] = tin++;
for (auto w : g[x]) {
if (w == par) continue;
p[w] = x;
Hd[w] = ((w == g[x][0]) ? Hd[x] : w);
dfs_dec(w, x);
}
out[x] = tin;
}
int lca(int x, int y) {
while (Hd[x] != Hd[y]) {
if (in[Hd[x]] > in[Hd[y]]) swap(x, y);
y = p[Hd[y]];
}
return in[x] < in[y] ? x : y;
}
void update_path(int x, int y, T v, bool c = 1) {
int u = lca(x, y);
for (; Hd[x] != Hd[y]; y = p[Hd[y]]) {
if (in[Hd[x]] > in[Hd[y]]) swap(x, y);
seg.upd(in[Hd[y]], in[y], v, 0, n - 1, 1);
}
if (in[x] > in[y]) swap(x, y);
if (in[u] + 1 - (c ? 1 : 0) <= in[y])
seg.upd(in[u] + 1 - (c ? 1 : 0), in[y], v, 0, n - 1, 1);
return;
}
T query_path(int x, int y, bool c = 1) {
int u = lca(x, y);
T ans = 0;
for (; Hd[x] != Hd[y]; y = p[Hd[y]]) {
if (in[Hd[x]] > in[Hd[y]]) swap(x, y);
ans = (ans + seg.qry(in[Hd[y]], in[y], 0, n - 1, 1)) % M;
}
if (in[x] > in[y]) swap(x, y);
if (in[u] + 1 - (c ? 1 : 0) <= in[y])
ans = (ans + seg.qry(in[u] + 1 - (c ? 1 : 0), in[y], 0, n - 1, 1)) % M;
return ans;
}
void decompose(int root) {
H[root] = 1;
Hd[root] = root;
dfs_sz(root);
dfs_dec(root);
}
T getH(int x) { return H[x]; }
private:
vector<vector<int> > g;
vector<int> Sz, Hd, in, out, p, H;
int n, edges = 0, tin = 0;
};
const int N = 100100;
int l[N], r[N];
long long ini[N];
int t[N];
long long invt[N];
vector<int> add[N], rem[N];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
cin >> n;
HLD<long long> hld(n);
long long P = 1;
int mx = 0;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
mx = max(mx, r[i]);
t[i] = r[i] - l[i] + 1;
P = P * (r[i] - l[i] + 1) % M;
invt[i] = exp(t[i], M - 2, M);
add[l[i]].push_back(i);
rem[r[i] + 1].push_back(i);
}
for (int i = 0; i < (n - 1); ++i) {
int a, b;
cin >> a >> b;
hld.add_edge(a, b);
}
hld.decompose(1);
long long res = 0;
for (int i = 1; i <= n; i++) {
ini[i] = hld.query_path(1, i, 1);
res -= (t[i] * P % M * invt[i] % M * invt[i] % M * hld.getH(i) % M);
res = mod(res, M);
}
long long lca = 0;
long long acu1 = 0, acu2 = 0;
long long acu = 0;
for (int c = 1; c <= mx; c++) {
for (auto i : rem[c]) {
hld.update_path(1, i, -invt[i]);
acu = mod(acu - hld.query_path(1, i) * invt[i], M);
acu1 = mod(acu1 - hld.getH(i) * invt[i], M);
acu2 = mod(acu2 - invt[i], M);
}
for (auto i : add[c]) {
acu = (acu + hld.query_path(1, i) * invt[i]) % M;
hld.update_path(1, i, invt[i]);
acu1 = mod(acu1 + hld.getH(i) * invt[i], M);
acu2 = mod(acu2 + invt[i], M);
}
res = mod(res + P * acu1 % M * acu2, M);
lca = mod(lca + acu, M);
}
lca %= M;
res = mod(res - mod(2ll * P * lca, M), M);
cout << res << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int primero = 1 << 17;
const int tope = 1 << 18;
int n;
int tiempo[tope][60];
void inserta(int pos, int val) {
pos += primero;
for (int i = 0; i < 60; i++) {
if (i % val == 0)
tiempo[pos][i] = 2;
else
tiempo[pos][i] = 1;
}
while (pos > 1) {
pos /= 2;
for (int i = 0; i < 60; i++)
tiempo[pos][i] = tiempo[2 * pos][i] +
tiempo[2 * pos + 1][(i + tiempo[2 * pos][i]) % 60];
}
}
int tiempori[60];
int nexttiempori[60];
int tiempoentre(int pos0, int pos1) {
pos0 += primero;
pos1 += primero;
for (int i = 0; i < 60; i++) tiempori[i] = 0;
int t = 2;
while (pos0 + 1 < pos1) {
if (pos0 % 2 == 0) {
t += tiempo[pos0 + 1][t % 60];
}
pos0 /= 2;
if (pos1 % 2 == 1) {
for (int i = 0; i < 60; i++)
nexttiempori[i] =
tiempo[pos1 - 1][i] + tiempori[(i + tiempo[pos1 - 1][i]) % 60];
for (int i = 0; i < 60; i++) tiempori[i] = nexttiempori[i];
}
pos1 /= 2;
}
return t + tiempori[t % 60];
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
inserta(i, a);
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
char tipo;
int x, y;
cin >> tipo >> x >> y;
if (tipo == 'A') {
cout << tiempoentre(x, y) << endl;
} else {
inserta(x, y);
}
}
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int counter = 0;
while (1) {
if (n >= 1 && n <= 9) {
counter += 9;
break;
}
n = n + 1;
while (1) {
if (n % 10 == 0) {
n = n / 10;
} else {
break;
}
}
counter++;
}
printf("%d\n", counter);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum;
cin >> n;
vector<int> v(100);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int max = v[0];
int max_index = 0;
int min_index = 0;
int min = v[0];
for (int i = 1; i < n; i++) {
if (v[i] > max) {
max = v[i];
max_index = i;
}
if (v[i] <= min) {
min = v[i];
min_index = i;
}
}
if (max_index > min_index) {
sum = max_index + (n - 1 - min_index - 1);
}
if (min_index > max_index && min != max) {
sum = max_index + n - 1 - min_index;
}
if (min_index > max_index && min == max) {
sum = 0;
}
cout << sum;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int arr[n];
memset(arr, 0, sizeof(arr));
priority_queue<pair<int, pair<int, int>>> pq;
pq.push({n, {0, n - 1}});
int t = 0;
while (!pq.empty()) {
int l = -1 * pq.top().second.first;
int r = pq.top().second.second;
int len = pq.top().first;
pq.pop();
if (l > r) {
continue;
} else {
int mid = (l + r) / 2;
t += 1;
arr[mid] = t;
pq.push({(len - 1) / 2, {-1 * l, mid - 1}});
pq.push({len / 2, {-1 * (mid + 1), r}});
}
}
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[300];
int main() {
int i, n, k;
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) scanf("%d", a + i);
sort(a, a + n);
printf("%d", a[n - k]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct T {
double x, v;
int id;
} a[100005];
long long sum[100005] = {};
int n;
double w;
inline int lowbit(int x) { return x & (-x); }
long long query(int x) {
long long ret = 0;
for (; x; x ^= lowbit(x)) ret += sum[x];
return ret;
}
void add(int x) {
for (; x <= n; x += lowbit(x)) sum[x]++;
}
bool cmp(const T &t, const T &t1) {
return abs(t.x * (t1.v - w)) < abs(t1.x * (t.v - w));
}
bool cmp1(const T &t, const T &t1) {
return abs(t.x * (t1.v + w)) < abs(t1.x * (t.v + w));
}
int main() {
cin >> n >> w;
w += 1e-9;
for (int i = 1; i <= n; i++) scanf("%lf%lf", &a[i].x, &a[i].v);
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; i++) a[i].id = i;
sort(a + 1, a + n + 1, cmp1);
long long ans = 0;
for (int i = 1; i <= n; i++) ans += i - 1 - query(a[i].id), add(a[i].id);
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long const max1 = 1e5 + 5;
long long const mod = 1e9 + 7;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
while (t--) {
long long n;
cin >> n;
map<char, char> in, out;
vector<char> v;
set<char> all;
long long f = 1;
map<char, long long> vis;
for (long long i = 0; i < n; i++) {
string s;
cin >> s;
if (s.size() == 1) {
v.push_back(s[0]);
continue;
}
f = 1;
for (long long j = 0; j < s.size() - 1; j++) {
out[s[j]] = s[j + 1];
in[s[j + 1]] = s[j];
all.insert(s[j]);
all.insert(s[j + 1]);
vis[s[j]] = 0;
vis[s[j + 1]] = 0;
}
}
if (f == 1) {
for (auto x : all) {
if (!vis[x]) {
char temp = x;
while (in.find(temp) != in.end()) {
temp = in[temp];
}
vis[temp] = 1;
while (out.find(temp) != out.end()) {
cout << temp;
temp = out[temp];
vis[temp] = 1;
}
cout << temp;
}
}
}
for (auto x : v) {
if (!vis[x]) {
cout << x;
vis[x] = 1;
}
}
}
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
#pragma GCC target("avx2")
using namespace std;
int32_t main() {
long long int n, m;
cin >> n >> m;
string s1;
set<long long int> s;
for (long long int j = 1; j <= n; j++) {
cin >> s1;
long long int h = 0, p = 1;
for (long long int i = 0; i <= (long long int)s1.size() - 1; i++) {
h = (h + (s1[i] - 'a' + 1) * p) % 1110111110111;
p = (p * 11) % 1110111110111;
}
s.insert(h);
}
for (long long int j = 1; j <= m; j++) {
cin >> s1;
long long int h = 0, p = 1, flag = 0;
for (long long int i = 0; i <= (long long int)s1.size() - 1; i++) {
h = (h + (s1[i] - 'a' + 1) * p) % 1110111110111;
p = (p * 11) % 1110111110111;
}
p = 1;
for (long long int i = 0; i <= (long long int)s1.size() - 1; i++) {
long long int t = ((s1[i] - 'a' + 1) * p) % 1110111110111;
h = (h + 1110111110111 - t) % 1110111110111;
long long int a = (h + p) % 1110111110111,
b = (h + 2 * p) % 1110111110111,
c = (h + 3 * p) % 1110111110111;
if (t == (p % 1110111110111)) {
if (s.find(b) != s.end() || s.find(c) != s.end()) {
flag = 1;
}
}
if (t == ((2 * p) % 1110111110111)) {
if (s.find(a) != s.end() || s.find(c) != s.end()) {
flag = 1;
}
}
if (t == ((3 * p) % 1110111110111)) {
if (s.find(a) != s.end() || s.find(b) != s.end()) {
flag = 1;
}
}
h = (h + t) % 1110111110111;
p = (p * 11) % 1110111110111;
}
if (flag)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 222222;
int n, a[N];
vector<int> v, s;
void solver(int x, int y) {
while (y - x >= 3) {
s.push_back(y - 2);
s.push_back(y - 1);
y -= 2;
}
s.push_back(x);
}
void solvel(int x, int y) {
while (y - x >= 3) {
s.push_back(x);
s.push_back(x - 1);
x += 2;
}
s.push_back(y - 2);
}
void solvem(int x, int y) {
int i;
for (i = x; i < y; i += 2) s.push_back(i);
for (i = y - 4; i >= x; i -= 2) s.push_back(i);
}
int main() {
int T, i, x;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
x = 0;
s.clear();
v.clear();
for (i = 1; i <= n; i++) {
scanf("%d", a + i);
x ^= a[i];
if (a[i]) v.push_back(i);
}
if (x) {
printf("NO\n");
continue;
}
if (!a[n]) {
for (i = v.size() - 1; i >= 0; i -= 2) solver(v[i - 1], v[i]);
printf("YES\n");
printf("%d\n", s.size());
for (i = 0; i < s.size(); i++) printf("%d ", s[i]);
printf("\n");
continue;
}
if (!a[1]) {
for (i = 0; i < v.size(); i += 2) solvel(v[i], v[i + 1]);
printf("YES\n");
printf("%d\n", s.size());
for (i = 0; i < s.size(); i++) printf("%d ", s[i]);
printf("\n");
continue;
}
x = -1;
for (i = 1; i < v.size() - 1; i += 2)
if (v[i] < v[i + 1] - 1) x = i;
if (x >= 0) {
for (i = x; i >= 0; i -= 2) solver(v[i - 1], v[i]);
for (i = x + 1; i < v.size(); i += 2) solvel(v[i], v[i + 1]);
printf("YES\n");
printf("%d\n", s.size());
for (i = 0; i < s.size(); i++) printf("%d ", s[i]);
printf("\n");
continue;
}
x = -1;
for (i = 0; i < v.size() - 1; i++)
if (v[i] % 2 == v[i + 1] % 2) x = i;
if (x >= 0) {
solvem(v[x], v[x + 1]);
for (i = x - 1; i >= 0; i -= 2) solver(v[i - 1], v[i]);
for (i = x + 2; i < v.size(); i += 2) solvel(v[i], v[i + 1]);
printf("YES\n");
printf("%d\n", s.size());
for (i = 0; i < s.size(); i++) printf("%d ", s[i]);
printf("\n");
continue;
}
printf("NO\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const long long BIG = 1446803456761533460;
const int Big = 336860180;
stringstream sss;
const long long int maxn = 100010;
long long int n;
long long int ar[maxn];
long long int num[maxn];
long long int cnt[maxn];
bool vis[maxn];
long long int c1 = 0, c2 = 0, odd = 0, ans = 0;
inline long long int R(long long int i) { return n - 1 - i; }
void MAIN() {
cin >> n;
for (long long int i = (0); i < (n); ++i) cin >> ar[i];
for (long long int i = (0); i < (n); ++i) ++num[ar[i]];
for (long long int i = (0); i < (n); ++i) odd += num[i + 1] % 2;
if (odd > 1) {
cout << "0\n";
return;
}
for (long long int i = (0); i < (n / 2); ++i) {
c2 += ar[i] != ar[R(i)];
}
long long int j = 0;
for (long long int i = (0); i < (n); ++i) {
while (j == i || j < n && (c1 > 0 || c2 > 0)) {
if (j == R(j)) {
c1 -= (++cnt[ar[j]] == 0);
} else if (vis[R(j)]) {
c1 -= (++cnt[ar[j]] == 0);
c1 -= (++cnt[ar[j]] == 0);
} else {
c2 -= ar[j] != ar[R(j)];
c1 += (cnt[ar[R(j)]]-- == 0);
c1 -= (++cnt[ar[j]] == 0);
}
vis[j++] = true;
}
ans += n - j + (c1 <= 0 && c2 <= 0);
if (i == R(i)) {
c1 += (cnt[ar[i]]-- == 0);
} else if (vis[R(i)]) {
c1 += (cnt[ar[i]]-- == 0);
c1 += (cnt[ar[i]]-- == 0);
} else {
c2 += ar[i] != ar[R(i)];
c1 -= (++cnt[ar[R(i)]] == 0);
c1 += (cnt[ar[i]]-- == 0);
}
vis[i] = false;
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(10);
sss << R"(
6
3 6 5 3 3 5
5
5 5 2 5 2
)";
MAIN();
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("inline", 2)
using namespace std;
const long long N = 5005;
const long long inf = 1e18;
long long n, hd[N], nxt[N << 1], to[N << 1], w[N << 1], tot = 1;
long long sz[N << 1];
long long aa[N << 1], eg[N << 1];
void add(long long a, long long b, long long c) {
nxt[++tot] = hd[a], to[tot] = b, w[tot] = c;
hd[a] = tot;
}
long long dfs1(long long u, long long fe, long long d) {
long long re = d;
for (long long i = hd[u]; i; i = nxt[i])
if (i != fe) re += dfs1(to[i], i ^ 1, d + w[i]);
return eg[fe] = re;
}
long long dfs2(long long u, long long fe) {
long long re = 1;
for (long long i = hd[u]; i; i = nxt[i])
if (i != fe) re += dfs2(to[i], i ^ 1);
sz[fe ^ 1] = n - re;
return sz[fe] = re;
}
void solve(long long rt) {
memset(eg, 0, sizeof eg);
long long sum = dfs1(rt, 0, 0);
for (long long i = 2; i <= tot; ++i) aa[i] = min(aa[i], sum - eg[i]);
}
long long zz[N];
long long wi[N], wo[N], bb[N << 1];
void dfs3(long long u, long long fe) {
zz[u] = 1;
wi[u] = 0, wo[u] = 0;
for (long long i = hd[u]; i; i = nxt[i])
if (i != fe) {
dfs3(to[i], i ^ 1);
zz[u] += zz[to[i]];
wi[u] += wi[to[i]];
wo[u] += wo[to[i]] + zz[to[i]] * w[i];
wi[u] -= (wo[to[i]] + zz[to[i]] * w[i]) * zz[to[i]];
}
wi[u] += wo[u] * zz[u];
bb[fe] = wi[u];
}
signed main() {
memset(aa, 0x3f, sizeof aa);
cin >> n;
for (long long i = 1; i <= n - 1; ++i) {
long long x, y, z;
cin >> x >> y >> z;
add(x, y, z);
add(y, x, z);
}
for (long long i = 1; i <= n; ++i) dfs3(i, 0);
for (long long i = 1; i <= n; ++i) solve(i);
dfs2(1, 0);
long long ans = 1e18;
for (long long i = 1; i <= n - 1; ++i) {
long long r = i << 1, s = i << 1 | 1;
ans = min(ans, 1LL * w[r] * sz[r] * sz[s] + aa[r] * sz[r] + aa[s] * sz[s] +
bb[r] + bb[s]);
}
cout << ans << endl;
}
| 7 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.