solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void build(int, int, int);
long long query(int, int, int, int, int);
void update(int, int, int, int, int, int);
void modify(int, int, int, int, int, int);
const int MAXN = 1e5 + 15;
int n, q;
pair<long long, long long> tree[MAXN << 2];
long long a[MAXN];
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> q;
for (int i = 0; i < n; i++) cin >> a[i];
build(1, 0, n);
while (q--) {
int type;
cin >> type;
if (type == 1) {
int l, r;
cin >> l >> r;
l--;
cout << query(1, 0, n, l, r) << '\n';
} else if (type == 2) {
int l, r, x;
cin >> l >> r >> x;
l--;
update(1, 0, n, l, r, x);
} else {
int l, x;
cin >> l >> x;
l--;
modify(1, 0, n, l, l + 1, x);
}
}
return false;
}
void build(int node, int b, int e) {
if (b == e - 1) {
tree[node] = {a[b], a[b]};
return;
}
int mid = (b + e) >> 1;
build(node << 1, b, mid);
build(node << 1 | 1, mid, e);
tree[node].first = tree[node << 1].first + tree[node << 1 | 1].first;
tree[node].second = max(tree[node << 1].second, tree[node << 1 | 1].second);
}
long long query(int node, int b, int e, int l, int r) {
if (b >= r || e <= l) return 0;
if (b >= l && e <= r) return tree[node].first;
int mid = (b + e) >> 1;
return query(node << 1, b, mid, l, r) + query(node << 1 | 1, mid, e, l, r);
}
void update(int node, int b, int e, int l, int r, int val) {
if (b >= r || e <= l || tree[node].second < val) return;
if (b == e - 1) {
tree[node].first %= val;
tree[node].second = tree[node].first;
return;
}
int mid = (b + e) >> 1;
update(node << 1, b, mid, l, r, val);
update(node << 1 | 1, mid, e, l, r, val);
tree[node].first = tree[node << 1].first + tree[node << 1 | 1].first;
tree[node].second = max(tree[node << 1].second, tree[node << 1 | 1].second);
}
void modify(int node, int b, int e, int l, int r, int val) {
if (b >= r || e <= l) return;
if (b >= l && e <= r) {
tree[node].first = tree[node].second = val;
return;
}
int mid = (b + e) >> 1;
modify(node << 1, b, mid, l, r, val);
modify(node << 1 | 1, mid, e, l, r, val);
tree[node].first = tree[node << 1].first + tree[node << 1 | 1].first;
tree[node].second = max(tree[node << 1].second, tree[node << 1 | 1].second);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while ((c < '0' || c > '9') && (c != '-')) c = getchar();
if (c == '-') f = -1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
const int N = 3e4 + 10;
int n;
vector<int> e[N];
int cnt, p[N], fa[N], vis[N];
bool flag[N];
inline void dfs(int u) {
vis[u] = 1;
for (auto v : e[u]) {
if (v == fa[u]) continue;
fa[v] = u;
if (!vis[v])
dfs(v);
else {
for (int now = u; now != v; now = fa[now]) flag[p[++cnt] = now] = 1;
flag[p[++cnt] = v] = 1;
}
if (cnt) break;
}
}
long long f[N], g[N], siz[N];
inline void dfs(int u, int fa) {
siz[u] = 1;
for (auto v : e[u]) {
if (v == fa || flag[v]) continue;
dfs(v, u), f[u] += g[v], siz[u] += siz[v];
}
g[u] = f[u] + siz[u];
}
long long dp[N], last[N], pre[N], ans;
inline void dfs(int u, int fa, long long sum) {
ans = max(ans, sum + n + f[u]);
for (auto v : e[u])
if (v != fa) dfs(v, u, sum + n - siz[v] + f[u] - g[v]);
}
inline void solve() {
long long sum = 0;
for (register int i = (1); i <= (cnt * 2); i++)
last[i] = siz[p[i]], pre[i] = pre[i - 1] + last[i], sum += f[p[i]];
for (register int i = (2); i <= (cnt - 1); i++) {
for (register int l = (1); l <= (cnt * 2 - i + 1); l++) {
int r = l + i - 1;
long long tmp = pre[r] - pre[l - 1];
dp[l] = max(last[l] + tmp, last[l + 1] + tmp);
}
for (register int j = (1); j <= (cnt * 2 - i + 1); j++) last[j] = dp[j];
}
ans = 0;
for (register int i = (1); i <= (cnt); i++) {
ans = max(ans, n + sum / 2 + dp[i + 1]);
for (auto v : e[p[i]])
if (!flag[v])
dfs(v, p[i],
n - siz[v] + sum / 2 - f[p[i]] + f[p[i]] - g[v] + dp[i + 1]);
}
printf("%lld\n", ans);
}
int main() {
n = read();
for (register int i = (1); i <= (n); i++) {
int x = read() + 1, y = read() + 1;
e[x].push_back(y), e[y].push_back(x);
}
dfs(1);
for (register int i = (1); i <= (cnt); i++) dfs(p[i], 0);
for (register int i = (1); i <= (cnt); i++) p[cnt + i] = p[i];
solve();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n + 1);
for (int i = 1; i <= n; i++) cin >> v[i];
for (int i = k; i < n; i++) {
if (v[i] != v[i + 1]) {
cout << "-1";
return 0;
}
}
int val = v[k], i;
for (i = k - 1; i >= 0; i--) {
if (val != v[i]) {
break;
}
}
cout << i << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
long long n;
cin >> n;
string s;
cin >> s;
vector<long long> prefix(n + 1);
for (long long i = 1; i <= n; i++) {
if (s[i - 1] == '?')
continue;
else if (s[i - 1] == s[i - 2] && i != 1)
prefix[i] = prefix[i - 1] + 1;
else
prefix[i] = 1;
}
for (long long i = 1; i <= n; i++) {
if (prefix[i] > 1) {
cout << "No" << endl;
return 0;
}
}
if (s[0] == '?' || s[n - 1] == '?') {
cout << "Yes" << endl;
return 0;
}
for (long long i = 2; i <= n; i++) {
if (s[i - 2] == s[i - 1] && s[i - 1] == '?') {
cout << "Yes" << endl;
return 0;
}
}
for (long long i = 1; i < n - 1; i++) {
if (s[i] == '?' && s[i - 1] == s[i + 1]) {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
constexpr static int mod = 1e9 + 7;
constexpr static int inf = (1 << 30) - 1;
constexpr static Int infll = (1LL << 61) - 1;
int Competitive_Programming =
(ios_base::sync_with_stdio(false), cin.tie(nullptr),
cout << fixed << setprecision(15), 0);
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
int main() {
int N, K;
cin >> N >> K;
string ans = "";
int L = (N - K) / 2;
while (ans.size() < N) {
for (int i = 0; i < L and ans.size() < N; i++) {
ans.push_back('0');
}
if (ans.size() < N) ans.push_back('1');
}
cout << ans << "\n";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2001;
long long factorialNumInverse[N + 1];
long long naturalNumInverse[N + 1];
long long fact[N + 1];
void InverseofNumber(long long p) {
naturalNumInverse[0] = naturalNumInverse[1] = 1;
for (int i = 2; i <= N; i++)
naturalNumInverse[i] = naturalNumInverse[p % i] * (p - p / i) % p;
}
void InverseofFactorial(long long p) {
factorialNumInverse[0] = factorialNumInverse[1] = 1;
for (int i = 2; i <= N; i++)
factorialNumInverse[i] =
(naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;
}
void factorial(long long p) {
fact[0] = 1;
for (int i = 1; i <= N; i++) {
fact[i] = (fact[i - 1] * i) % p;
}
}
long long Binomial(long long N, long long R, long long p) {
long long ans =
((fact[N] * factorialNumInverse[R]) % p * factorialNumInverse[N - R]) % p;
return ans;
}
long long power(int x, int y) {
long long ans = 1;
long long p = 998244353;
for (int i = 0; i < y; i++) {
ans = (ans * x) % p;
}
return ans;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long p = 998244353;
InverseofNumber(p);
InverseofFactorial(p);
factorial(p);
long long x = Binomial(n - 1, k, p);
long long y = (m * power(m - 1, k)) % p;
long long ans = (x * y) % p;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, s, ans;
int tot;
int pn[60], pm[60], ps[60], pri[60];
long long xp[60];
int vis[1000010];
inline void solve(int *cnt, int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
if (!vis[i]) vis[i] = ++tot, pri[tot] = i;
while (x % i == 0) x /= i, cnt[vis[i]]++;
}
if (x > 1) {
if (!vis[x]) vis[x] = ++tot, pri[tot] = x;
cnt[vis[x]]++;
}
}
inline void init() {
memset(pn, 0, sizeof(pn)), memset(pm, 0, sizeof(pm)),
memset(ps, 0, sizeof(ps));
for (int i = 1; i <= tot; i++) vis[pri[i]] = 0;
}
void dfs1(int x, long long now) {
if (now > n) return;
if (x > tot) {
ans++;
return;
}
dfs1(x + 1, now);
for (int i = 1; i <= ps[x]; i++) dfs1(x + 1, now *= pri[x]);
}
void dfs2(int x, long long now, int flag) {
if (now > m) return;
if (x > tot) {
ans += flag * (m / now);
return;
}
dfs2(x + 1, now, flag);
if (pn[x] > ps[x]) dfs2(x + 1, now * xp[x] * pri[x], -flag);
}
inline void work() {
int t;
n = m = s = 1, ans = tot = 0;
scanf("%d", &t), solve(pn, t), n *= t, scanf("%d", &t), solve(pn, t), n *= t,
scanf("%d", &t), solve(pn, t), n *= t;
scanf("%d", &t), solve(pm, t), m *= t, scanf("%d", &t), solve(pm, t), m *= t,
scanf("%d", &t), solve(pm, t), m *= t;
scanf("%d", &t), solve(ps, t), s *= t, scanf("%d", &t), solve(ps, t), s *= t,
scanf("%d", &t), solve(ps, t), s *= t;
solve(ps, 2), s <<= 1;
dfs1(1, 1);
for (int i = 1, j; i <= tot; i++)
for (j = xp[i] = 1; j <= ps[i]; j++) xp[i] *= pri[i];
dfs2(1, 1, 1);
printf("%lld\n", ans);
init();
}
int main() {
int T;
scanf("%d", &T);
while (T--) work();
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int arr[505][505];
int now[505][505];
const int inf = 1e9 + 9;
int main() {
int q, e, f;
while (scanf("%d%d%d%d", &n, &m, &k, &q) == 4) {
memset(arr, -1, sizeof(arr));
for (int i = 0; i < q; i++) {
scanf("%d%d", &e, &f);
scanf("%d", &arr[e][f]);
}
for (int i = 1; i <= n; i++) {
map<int, int> ma;
for (int j = 0; j < k; j++) ma[arr[i][j]]++;
for (int j = 1, e = k; e <= m; e++, j++) {
ma[arr[i][e]]++;
ma[arr[i][j - 1]]--;
if (ma[arr[i][j - 1]] == 0) {
ma.erase(arr[i][j - 1]);
}
if (ma.begin()->first != -1) {
now[i][j] = ma.rbegin()->first;
} else {
now[i][j] = -1;
}
}
}
int ans = inf;
for (int i = 1; i + k - 1 <= n; i++) {
for (int j = 1; j + k - 1 <= m; j++) {
int tmp = -inf;
for (int ii = 0; ii < k; ii++) {
tmp = max(tmp, now[i + ii][j]);
if (now[i + ii][j] == -1) {
tmp = -1;
break;
}
}
if (tmp != -1) ans = min(ans, tmp);
}
}
if (ans == inf)
printf("-1\n");
else
printf("%d\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 212345;
using T2 = tuple<int, int>;
using T3 = tuple<int, int, int>;
priority_queue<T2> pc;
priority_queue<T3> sk;
int a[maxn], b[maxn];
int main(void) {
int n, m, cnt = 0, cost = 0;
scanf("%d %d", &n, &m);
for (int i = 0; i < (n); i++) {
int tmp;
scanf("%d", &tmp);
pc.emplace(tmp, i);
}
for (int i = 0; i < (m); i++) {
int tmp;
scanf("%d", &tmp);
sk.emplace(tmp, 0, i);
}
while (!pc.empty() && !sk.empty()) {
if (get<0>(pc.top()) > get<0>(sk.top()))
pc.pop();
else if (get<0>(pc.top()) == get<0>(sk.top())) {
cnt++;
cost += a[get<2>(sk.top())] = abs(get<1>(sk.top()));
b[get<1>(pc.top())] = get<2>(sk.top()) + 1;
pc.pop();
sk.pop();
} else {
T3 tmp = sk.top();
sk.pop();
get<0>(tmp) = get<0>(tmp) / 2 + get<0>(tmp) % 2;
get<1>(tmp)--;
sk.push(tmp);
}
}
printf("%d %d\n", cnt, cost);
for (int i = 0; i < (m); i++) printf("%d ", a[i]);
puts("");
for (int i = 0; i < (n); i++) printf("%d ", b[i]);
puts("");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 5;
const long long inf = 1791791791;
const long long mod = 1e9 + 7;
double x(double a, double h) {
a = a / 2.0;
double c = sqrt(a * a + h * h);
return (a * h) / c;
}
int main() {
double f;
scanf("%lf", &f);
for (int a = 1; a <= 10; a++) {
for (int h = 1; h <= 10; h++) {
if (fabs(f - x(a, h)) < 0.0001) {
printf("%d %d\n", a, h);
return 0;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int N = 100009;
const int inf = 0x3f3f3f3f;
const long long oo = 0x3f3f3f3f3f3f3f3fll;
int n, m, k, a[N], vis[N];
struct Edge {
int a, b;
Edge(int a, int b) : a(a), b(b) {}
};
int p[N];
int find(int x) {
if (x != p[x]) p[x] = find(p[x]);
return p[x];
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < k; i++) {
scanf("%d", &a[i]);
vis[a[i]] = 1;
}
if (m == n * (n - 1) / 2 || k == n) {
cout << -1 << endl;
return 0;
}
vector<Edge> vt, ans;
for (int i = 1; i <= n; i++) p[i] = i;
for (int i = 1; i <= n; i++) {
if (i == a[0] || i == a[1]) continue;
for (int j = i + 1; j <= n; j++) {
if (j == a[0] || j == a[1]) continue;
if (find(i) == find(j))
vt.push_back(Edge(i, j));
else
ans.push_back(Edge(i, j)), p[find(i)] = find(j);
}
}
for (int i = 1; i <= n; i++) {
if (i == a[0] || i == a[1]) continue;
if (vis[i]) {
vt.push_back(Edge(i, a[1]));
} else {
if (find(i) == find(a[1]))
vt.push_back(Edge(i, a[1]));
else
ans.push_back(Edge(i, a[1])), p[find(i)] = find(a[1]);
if (find(i) == find(a[0]))
vt.push_back(Edge(i, a[0]));
else
ans.push_back(Edge(i, a[0])), p[find(i)] = find(a[0]);
}
}
int t = 0;
while (ans.size() < m) {
if (t == vt.size()) break;
ans.push_back(vt[t++]);
}
if (ans.size() != m)
cout << -1 << endl;
else {
for (int i = 0; i < ans.size(); i++)
cout << ans[i].a << " " << ans[i].b << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
typedef vector <int> vi;
int main()
{
long long int test,n,m,x;
cin >> test;
while(test--)
{
cin >> n >> m >> x;
x--;
cout << (x/n+1)+(x%n)*m << "\n";
}
return 0;
} | 0 |
#include <stdio.h>
#include <bits/stdc++.h>
#include <algorithm>
#include <cassert>
#include <vector>
namespace atcoder {
// Implement (union by size) + (path compression)
// Reference:
// Zvi Galil and Giuseppe F. Italiano,
// Data structures and algorithms for disjoint set union problems
struct dsu {
public:
dsu() : _n(0) {}
dsu(int n) : _n(n), parent_or_size(n, -1) {}
int merge(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
int x = leader(a), y = leader(b);
if (x == y) return x;
if (-parent_or_size[x] < -parent_or_size[y]) std::swap(x, y);
parent_or_size[x] += parent_or_size[y];
parent_or_size[y] = x;
return x;
}
bool same(int a, int b) {
assert(0 <= a && a < _n);
assert(0 <= b && b < _n);
return leader(a) == leader(b);
}
int leader(int a) {
assert(0 <= a && a < _n);
if (parent_or_size[a] < 0) return a;
return parent_or_size[a] = leader(parent_or_size[a]);
}
int size(int a) {
assert(0 <= a && a < _n);
return -parent_or_size[leader(a)];
}
std::vector<std::vector<int>> groups() {
std::vector<int> leader_buf(_n), group_size(_n);
for (int i = 0; i < _n; i++) {
leader_buf[i] = leader(i);
group_size[leader_buf[i]]++;
}
std::vector<std::vector<int>> result(_n);
for (int i = 0; i < _n; i++) {
result[i].reserve(group_size[i]);
}
for (int i = 0; i < _n; i++) {
result[leader_buf[i]].push_back(i);
}
result.erase(
std::remove_if(result.begin(), result.end(),
[&](const std::vector<int>& v) { return v.empty(); }),
result.end());
return result;
}
private:
int _n;
// root node: -1 * component size
// otherwise: parent
std::vector<int> parent_or_size;
};
} // namespace atcoder
#include <algorithm>
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
// @param n `0 <= n`
// @return minimum non-negative `x` s.t. `n <= 2**x`
int ceil_pow2(int n) {
int x = 0;
while ((1U << x) < (unsigned int)(n)) x++;
return x;
}
// @param n `1 <= n`
// @return minimum non-negative `x` s.t. `(n & (1 << x)) != 0`
int bsf(unsigned int n) {
#ifdef _MSC_VER
unsigned long index;
_BitScanForward(&index, n);
return index;
#else
return __builtin_ctz(n);
#endif
}
} // namespace internal
} // namespace atcoder
#include <cassert>
#include <iostream>
#include <vector>
namespace atcoder {
template <class S,
S (*op)(S, S),
S (*e)(),
class F,
S (*mapping)(F, S),
F (*composition)(F, F),
F (*id)()>
struct lazy_segtree {
public:
lazy_segtree() : lazy_segtree(0) {}
lazy_segtree(int n) : lazy_segtree(std::vector<S>(n, e())) {}
lazy_segtree(const std::vector<S>& v) : _n(int(v.size())) {
log = internal::ceil_pow2(_n);
size = 1 << log;
d = std::vector<S>(2 * size, e());
lz = std::vector<F>(size, id());
for (int i = 0; i < _n; i++) d[size + i] = v[i];
for (int i = size - 1; i >= 1; i--) {
update(i);
}
}
void set(int p, S x) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
d[p] = x;
for (int i = 1; i <= log; i++) update(p >> i);
}
S get(int p) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
return d[p];
}
S prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
if (l == r) return e();
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l) push(l >> i);
if (((r >> i) << i) != r) push(r >> i);
}
S sml = e(), smr = e();
while (l < r) {
if (l & 1) sml = op(sml, d[l++]);
if (r & 1) smr = op(d[--r], smr);
l >>= 1;
r >>= 1;
}
return op(sml, smr);
}
S all_prod() { return d[1]; }
void apply(int p, F f) {
assert(0 <= p && p < _n);
p += size;
for (int i = log; i >= 1; i--) push(p >> i);
d[p] = mapping(f, d[p]);
for (int i = 1; i <= log; i++) update(p >> i);
}
void apply(int l, int r, F f) {
assert(0 <= l && l <= r && r <= _n);
if (l == r) return;
l += size;
r += size;
for (int i = log; i >= 1; i--) {
if (((l >> i) << i) != l) push(l >> i);
if (((r >> i) << i) != r) push((r - 1) >> i);
}
{
int l2 = l, r2 = r;
while (l < r) {
if (l & 1) all_apply(l++, f);
if (r & 1) all_apply(--r, f);
l >>= 1;
r >>= 1;
}
l = l2;
r = r2;
}
for (int i = 1; i <= log; i++) {
if (((l >> i) << i) != l) update(l >> i);
if (((r >> i) << i) != r) update((r - 1) >> i);
}
}
template <bool (*g)(S)> int max_right(int l) {
return max_right(l, [](S x) { return g(x); });
}
template <class G> int max_right(int l, G g) {
assert(0 <= l && l <= _n);
assert(g(e()));
if (l == _n) return _n;
l += size;
for (int i = log; i >= 1; i--) push(l >> i);
S sm = e();
do {
while (l % 2 == 0) l >>= 1;
if (!g(op(sm, d[l]))) {
while (l < size) {
push(l);
l = (2 * l);
if (g(op(sm, d[l]))) {
sm = op(sm, d[l]);
l++;
}
}
return l - size;
}
sm = op(sm, d[l]);
l++;
} while ((l & -l) != l);
return _n;
}
template <bool (*g)(S)> int min_left(int r) {
return min_left(r, [](S x) { return g(x); });
}
template <class G> int min_left(int r, G g) {
assert(0 <= r && r <= _n);
assert(g(e()));
if (r == 0) return 0;
r += size;
for (int i = log; i >= 1; i--) push((r - 1) >> i);
S sm = e();
do {
r--;
while (r > 1 && (r % 2)) r >>= 1;
if (!g(op(d[r], sm))) {
while (r < size) {
push(r);
r = (2 * r + 1);
if (g(op(d[r], sm))) {
sm = op(d[r], sm);
r--;
}
}
return r + 1 - size;
}
sm = op(d[r], sm);
} while ((r & -r) != r);
return 0;
}
private:
int _n, size, log;
std::vector<S> d;
std::vector<F> lz;
void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
void all_apply(int k, F f) {
d[k] = mapping(f, d[k]);
if (k < size) lz[k] = composition(f, lz[k]);
}
void push(int k) {
all_apply(2 * k, lz[k]);
all_apply(2 * k + 1, lz[k]);
lz[k] = id();
}
};
} // namespace atcoder
using namespace atcoder;
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define Inf 1000000001
int n,m;
void solve0(vector<int> u,vector<int> v,vector<long long> w){
vector<vector<bool>> f(n,vector<bool>(n,false));
rep(i,n)f[i][i] = true;
long long X = 0LL;
rep(i,u.size()){
f[u[i]][v[i]] = true;
f[v[i]][u[i]] = true;
X ^= w[i];
}
vector<pair<long long,pair<int,int>>> E;
int cnt = 0;
rep(i,n){
rep(j,n){
if(f[i][j]==false){
f[i][j] = true;
f[j][i] = true;
E.emplace_back(0,make_pair(i,j));
cnt ++;
}
}
}
rep(i,m){
E.emplace_back(w[i],make_pair(u[i],v[i]));
}
sort(E.begin(),E.end());
dsu D(n);
long long ans = 0LL;
vector<bool> used(E.size(),false);
rep(i,E.size()){
int x = E[i].second.first,y = E[i].second.second;
long long z = E[i].first;
if(D.same(x,y))continue;
D.merge(x,y);
ans += z;
if(z==0)cnt--;
else{
used[i] = true;
}
}
if(cnt!=0){
cout<<ans<<endl;
return;
}
dsu D2(n);
rep(i,E.size()){
if(used[i])D2.merge(E[i].second.first,E[i].second.second);
}
rep(i,E.size()){
if(used[i])continue;
int x = E[i].second.first,y = E[i].second.second;
long long z = E[i].first;
if(D2.same(x,y))continue;
if(z==0)continue;
X = min(X,z);
}
cout<<ans+X<<endl;
}
using P = pair<int,int>;
P op(P a,P b){
return max(a,b);
}
P e(){
return make_pair(-Inf,-1);
}
P mapping(int a,P b){
b.first += a;
return b;
}
int composition(int a,int b){
return a+b;
}
int id(){
return 0;
}
void solve1(vector<int> u,vector<int> v,vector<long long> w){
lazy_segtree<P,op,e,int,mapping,composition,id> seg(n);
vector<vector<pair<int,long long>>> E(n);
rep(i,u.size()){
E[u[i]].emplace_back(v[i],w[i]);
E[v[i]].emplace_back(u[i],w[i]);
}
rep(i,n){
E[i].emplace_back(-1,0);
E[i].emplace_back(n,0);
sort(E[i].begin(),E[i].end());
}
rep(i,n){
seg.set(i,make_pair(0,i));
}
long long ans = 0LL;
priority_queue<pair<long long,pair<int,int>>,vector<pair<long long,P>>,greater<pair<long long,P>>> Q;
set<int> used;
used.insert(0);
rep(j,E[0].size()-1){
seg.apply(E[0][j].first+1,E[0][j+1].first,1);
}
rep(j,E[0].size()-1){
if(j==0)continue;
Q.emplace(E[0][j].second,make_pair(0,E[0][j].first));
}
seg.set(0,e());
while(used.size()!=n){
auto p = seg.all_prod();
int cur;
if(p.second==-1||p.first<=0){
while(Q.size()>0){
auto temp = Q.top();
Q.pop();
long long x = temp.first;
int y = temp.second.first;
int z = temp.second.second;
if(used.count(y)&&used.count(z))continue;
if(!used.count(y)){
cur = y;
}
else{
cur = z;
}
ans += x;
break;
}
}
else{
cur = p.second;
}
used.insert(cur);
rep(j,E[cur].size()-1){
seg.apply(E[cur][j].first+1,E[cur][j+1].first,1);
}
rep(j,E[cur].size()-1){
if(j==0)continue;
Q.emplace(E[cur][j].second,make_pair(cur,E[cur][j].first));
}
seg.set(cur,e());
}
cout<<ans<<endl;
}
int main(){
scanf("%d %d",&n,&m);
vector<int> u(m),v(m);
vector<long long> w(m);
rep(i,m){
scanf("%d %d %lld",&u[i],&v[i],&w[i]);
u[i]--;
v[i]--;
}
if(n<=1000){
solve0(u,v,w);
}
else{
solve1(u,v,w);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int n, i, j, k;
scanf("%d", &n);
char a[100];
scanf("%s", a);
int m;
scanf("%d", &m);
char b[1001][52];
for (i = 0; i < m; i++) scanf("%s", b[i]);
int count[1001][52];
for (i = 0; i < m; i++)
for (j = 0; j < 51; j++) count[i][j] = 0;
int cnt = 0, val[1001];
for (i = 0; i < m; i++) {
val[i] = 1;
for (j = 0; j < n; j++) {
if (a[j] != b[i][j] && a[j] != '*') {
val[i] = 0;
break;
}
}
if (val[i] == 1) {
for (j = 0; j < n; j++) {
if (a[j] != '*') {
for (k = 0; k < n; k++) {
if (b[i][k] == a[j] && k != j) {
if (a[k] != a[j]) val[i] = 0;
}
}
}
}
}
if (val[i] == 1) {
cnt++;
for (j = 0; j < n; j++) {
if (a[j] == '*') {
count[i][b[i][j] - 'a'] = 1;
}
}
}
}
int ans[50] = {0}, q = 0;
for (i = 0; i < 30; i++) {
for (j = 0; j < m; j++) ans[i] += count[j][i];
}
for (i = 0; i < 30; i++) {
if (ans[i] == cnt) q++;
}
printf("%d\n", q);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
constexpr int N = 1e3 + 5;
int a, b, ans = -1;
char v;
void Solve() {
cin >> v;
a = v - 'a';
cin >> v;
b = v - '1';
for (int i = -1; i < 2; i++)
for (int j = -1; j < 2; j++) {
ans += (a + i >= 0 && a + i < 8 && b + j >= 0 && b + j < 8);
}
cout << ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
Solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long double p[123456];
long double q[123456];
long double mx[123456];
long double mn[123456];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(7);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> mx[i];
for (int i = 0; i < n; i++) {
cin >> mn[i];
mn[i] += mx[i];
}
long double pre_p = 0, pre_q = 0;
for (int i = 0; i < n; i++) {
long double A = 1;
long double B = pre_p - pre_q - mn[i];
long double C = mx[i] - mn[i] * pre_p;
long double D = B * B - 4 * A * C;
D = sqrtl(fabsl(D));
long double S = (-B - D) / 2;
long double SS = mn[i] - S;
p[i] = S;
q[i] = SS;
pre_p += S;
pre_q += SS;
}
for (int i = 0; i < n; i++) cout << p[i] << " ";
cout << '\n';
for (int i = 0; i < n; i++) cout << q[i] << " ";
cout << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, a1, a2, a3, a4, a5, a6;
scanf("%d%d%d", &a1, &a2, &a3);
scanf("%d%d%d", &a4, &a5, &a6);
if (a1 + a2 + a3 == a3 + a4 + a5 && a3 + a4 + a5 == a1 + a5 + a6) {
a = a1 + a2 + a3;
printf("%d", a * a - a1 * a1 - a3 * a3 - a5 * a5);
} else if (a6 + a1 + a2 == a2 + a3 + a4 && a2 + a3 + a4 == a4 + a5 + a6) {
a = a2 + a3 + a4;
printf("%d", a * a - a2 * a2 - a4 * a4 - a6 * a6);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, q, r, t;
string s;
cin >> s;
int n;
cin >> n;
string a[n];
for (i = 0; i < n; i++) cin >> a[i];
int temp = 0;
for (i = 0; i < n; i++) {
if (a[i] == s) {
temp = 1;
cout << "YES";
break;
}
}
if (!temp) {
temp = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (a[i][1] == s[0] && a[j][0] == s[1]) {
temp = 1;
cout << "YES";
break;
}
}
if (temp) break;
}
if (!temp) {
cout << "NO";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long T;
long long n;
int main() {
ios::sync_with_stdio(false);
cin >> T;
while (T--) {
cin >> n;
if (n == 1)
cout << "0" << endl;
else
cout << ceil(2.0 * sqrt(n)) - 2 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int ch[15100000][2], sum[15100000], cnt, root[65], n;
long long b[301000], bin[65], c[301000];
void insert(int &, long long);
long long query(int, long long);
int main() {
scanf("%d", &n);
for (int i = 0; i <= 62; i++) bin[i] = 1ll << i;
for (int i = 1; i <= n; i++) {
scanf("%lld", &b[i]);
for (int j = 60; j >= 0; j--) {
if (b[i] & bin[j]) {
insert(root[j], b[i]);
break;
}
}
}
long long zz = 0;
int t = 1;
for (; t <= n; t++) {
for (int i = 0; i <= 60; i++) {
if ((!(zz & bin[i])) && sum[root[i]] != 0) {
c[t] = query(root[i], zz);
zz ^= c[t];
break;
}
}
if (!c[t]) break;
}
if (t <= n)
printf("No");
else {
printf("Yes\n");
for (int i = 1; i <= n; i++) printf("%lld ", c[i]);
}
return 0;
}
void insert(int &rt, long long y) {
if (!rt) rt = ++cnt;
sum[rt]++;
int now = rt;
for (int i = 60; i >= 0; i--) {
if (y & bin[i]) {
if (!ch[now][1]) ch[now][1] = ++cnt;
now = ch[now][1];
} else {
if (!ch[now][0]) ch[now][0] = ++cnt;
now = ch[now][0];
}
sum[now]++;
}
}
long long query(int x, long long y) {
sum[x]--;
int now = x;
long long ans = 0;
for (int i = 60; i >= 0; i--) {
int d = ((y & bin[i]) != 0);
if (sum[ch[now][d]]) {
now = ch[now][d];
if (d) ans += bin[i];
} else {
now = ch[now][d ^ 1];
if (!d) ans += bin[i];
}
sum[now]--;
}
return ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
long long a[100005], b[100005], c[100005];
while (t--) {
int first, second, z;
scanf("%d %d %d", &first, &second, &z);
for (int i = 0; i < first; i++) scanf("%lld", &a[i]);
for (int i = 0; i < second; i++) scanf("%lld", &b[i]);
for (int i = 0; i < z; i++) scanf("%lld", &c[i]);
sort(a, a + first);
sort(b, b + second);
sort(c, c + z);
long long ans = 5e18;
for (int i = 0; i < first; i++) {
{
int yy = lower_bound(b, b + second, a[i]) - b;
int zz = upper_bound(c, c + z, a[i]) - 1 - c;
if (yy != second && zz != -1) {
ans = min(ans, ((a[i] - b[yy]) * (a[i] - b[yy])) +
((b[yy] - c[zz]) * (b[yy] - c[zz])) +
((a[i] - c[zz]) * (a[i] - c[zz])));
}
}
{
int yy = upper_bound(b, b + second, a[i]) - 1 - b;
int zz = lower_bound(c, c + z, a[i]) - c;
if (yy != -1 && zz != z) {
ans = min(ans, ((a[i] - b[yy]) * (a[i] - b[yy])) +
((b[yy] - c[zz]) * (b[yy] - c[zz])) +
((a[i] - c[zz]) * (a[i] - c[zz])));
}
}
}
for (int i = 0; i < second; i++) {
{
int xx = lower_bound(a, a + first, b[i]) - a;
int zz = upper_bound(c, c + z, b[i]) - 1 - c;
if (xx != first && zz != -1) {
ans = min(ans, ((a[xx] - b[i]) * (a[xx] - b[i])) +
((b[i] - c[zz]) * (b[i] - c[zz])) +
((a[xx] - c[zz]) * (a[xx] - c[zz])));
}
}
{
int xx = upper_bound(a, a + first, b[i]) - 1 - a;
int zz = lower_bound(c, c + z, b[i]) - c;
if (xx != -1 && zz != z) {
ans = min(ans, ((a[xx] - b[i]) * (a[xx] - b[i])) +
((b[i] - c[zz]) * (b[i] - c[zz])) +
((a[xx] - c[zz]) * (a[xx] - c[zz])));
}
}
}
for (int i = 0; i < z; i++) {
{
int yy = lower_bound(b, b + second, c[i]) - b;
int xx = upper_bound(a, a + first, c[i]) - 1 - a;
if (yy != second && xx != -1) {
ans = min(ans, ((a[xx] - b[yy]) * (a[xx] - b[yy])) +
((b[yy] - c[i]) * (b[yy] - c[i])) +
((a[xx] - c[i]) * (a[xx] - c[i])));
}
}
{
int yy = upper_bound(b, b + second, c[i]) - 1 - b;
int xx = lower_bound(a, a + first, c[i]) - a;
if (yy != -1 && xx != first) {
ans = min(ans, ((a[xx] - b[yy]) * (a[xx] - b[yy])) +
((b[yy] - c[i]) * (b[yy] - c[i])) +
((a[xx] - c[i]) * (a[xx] - c[i])));
}
}
}
printf("%lld\n", ans);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, i, x, p, y;
cin >> t;
while (t--) {
p = 1;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x;
if (x % 2 == 0) {
y = i;
p = 0;
}
}
if (!p)
cout << 1 << endl << y << endl;
else if (n == 1)
cout << -1 << endl;
else
cout << 2 << endl << 1 << ' ' << 2 << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void c_p_c() {}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
unordered_map<long long int, long long int> mp;
for (long long int i = 1; i <= n; i++) cin >> mp[i];
for (long long int i = 1; i <= n; i++) {
long long int val = i;
for (long long int j = 1; j <= n; j++) {
if (mp[j] == i) val = j;
}
cout << val << " ";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++) cin >> ar[i];
map<int, int> m;
for (int i = 0; i < n; i++) m[ar[i]]++;
m[0] = 3;
map<int, int>::iterator it = m.begin(), tmp;
int ans = 0;
it++;
while (it != m.end()) {
int p = it->second, k = it->first;
tmp = m.find(k - 1);
if (tmp == m.end() or tmp->second == 0) {
p--;
m[k - 1]++;
m[k]--;
}
if (p > 1) {
m[k + 1]++;
m[k]--;
}
it++;
}
it = m.begin();
it++;
while (it != m.end()) {
if (it->second > 0) ans++;
it++;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
namespace zzc {
const long long maxn = 1e5 + 5;
const long long mod = 1e9 + 7;
long long fac[maxn], inv[maxn], num[60], f[maxn], g[maxn], h[maxn], res[60][60];
char ch[maxn];
long long n, ans;
void init() {
fac[0] = fac[1] = 1;
inv[0] = inv[1] = 1;
for (long long i = 2; i <= 100000; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = inv[mod % i] * (mod - mod / i) % mod;
}
for (long long i = 2; i <= 100000; i++) inv[i] = inv[i] * inv[i - 1] % mod;
}
long long ctoi(char x) { return isupper(x) ? x - 'A' + 26 : x - 'a'; }
void work() {
long long a, b;
init();
scanf("%s", ch + 1);
long long len = strlen(ch + 1);
for (long long i = 1; i <= len; i++) num[ctoi(ch[i])]++;
ans = (long long)fac[len >> 1] * fac[len >> 1] % mod;
f[0] = 1;
for (long long i = 0; i < 52; i++) {
if (!num[i]) continue;
ans = (long long)ans * inv[num[i]] % mod;
for (long long j = (len >> 1); j >= num[i]; j--) {
f[j] = (f[j] + f[j - num[i]]) % mod;
}
}
for (long long i = 0; i < 52; i++) {
if (!num[i]) continue;
res[i][i] = f[len >> 1];
memcpy(g, f, sizeof(long long[num[i]]));
for (long long j = num[i]; j <= (len >> 1); j++) {
g[j] = (f[j] - g[j - num[i]] + mod) % mod;
}
for (long long j = i + 1; j < 52; j++) {
if (!num[j]) continue;
memcpy(h, g, sizeof(long long[num[j]]));
for (long long k = num[j]; k <= (len >> 1); k++) {
h[k] = (g[k] - h[k - num[j]] + mod) % mod;
}
res[i][j] = res[j][i] = (long long)h[len >> 1] * 2 % mod;
}
}
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld%lld", &a, &b);
printf("%lld\n", (long long)ans * res[ctoi(ch[a])][ctoi(ch[b])] % mod);
}
}
} // namespace zzc
signed main() {
zzc::work();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool possible(int* l, int size, int days, long long work) {
long long energy = 0;
int pos = 0;
for (int i = size - 1; i >= 0; i--) {
energy += max(0, l[i] - pos);
if ((i - size) % days == 0) {
pos++;
}
}
return energy >= work;
}
int main() {
int n;
long long m;
cin >> n >> m;
int* l = new int[n];
for (int i = 0; i < n; i++) {
cin >> l[i];
}
sort(l, l + n);
int low = 1;
int high = n;
while (high != low) {
int mid = low + (high - low) / 2;
if (possible(l, n, mid, m)) {
high = mid;
} else {
low = mid + 1;
}
}
if (possible(l, n, high, m)) {
cout << high << "\n";
} else {
cout << -1 << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 2;
int n, a[N];
long long f[N];
class TTree {
pair<int, int> it[1 << 18];
void Build(int id, int sl, int sr) {
if (sl == sr) {
it[id] = {a[sl], sl};
return;
}
int mid = (sl + sr) / 2;
Build(id * 2 + 1, sl, mid);
Build(id * 2 + 2, mid + 1, sr);
it[id] = max(it[id * 2 + 1], it[id * 2 + 2]);
}
pair<int, int> Query(int id, int sl, int sr, int ql, int qr) {
if (qr < sl || sr < ql) return pair<int, int>(0, 0);
if (ql <= sl && sr <= qr) return it[id];
int mid = (sl + sr) / 2;
return max(Query(id * 2 + 1, sl, mid, ql, qr),
Query(id * 2 + 2, mid + 1, sr, ql, qr));
}
public:
void Build() { Build(0, 1, n); }
pair<int, int> Query(int l, int r) { return Query(0, 1, n, l, r); }
} tree;
void Solve() {
tree.Build();
for (int i = n - 1; i >= 1; --i) {
int m = tree.Query(i + 1, a[i]).second;
f[i] = f[m] + (n - i) - (a[i] - m);
}
printf("%lld", accumulate(f + 1, f + 1 + n, 0LL));
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) scanf("%d", &a[i]);
Solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, da = 6, db = 2, a = 5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
while (a <= n) a = a * da++ / db++;
--da, --db, a = a * db / da, --da, --db;
string ans = string(da, 'a');
while (a <= n) n -= a, ans += "b";
while (a != 1) {
a = a * db-- / da--;
while (a <= n) {
n -= a;
ans.insert(da, "b");
}
}
cout << ans << " aaaab";
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
const long double PI = 3.141592653589793;
const long long INF = 9223372036854775807ll;
const long long mod = 1e9 + 7;
const int N = 2e5 + 2;
const int logN = 20;
vector<int> id(N), sz(N, 1);
int root(int v) {
while (id[v] != v) {
id[v] = id[id[v]];
v = id[v];
}
return v;
}
int merge(int a, int b) {
int p = root(a);
int q = root(b);
if (p == q) return 0;
if (sz[p] > sz[q]) swap(p, q);
sz[q] += sz[p];
sz[p] = 0;
id[p] = q;
return 1;
}
vector<pair<int, int>> adj[N];
vector<int> lvl(N);
int par[N][logN];
int mxwt[N][logN];
void dfs(int u, int p) {
for (auto v : adj[u])
if (v.first != p) {
lvl[v.first] = lvl[u] + 1;
par[v.first][0] = u;
mxwt[v.first][0] = v.second;
dfs(v.first, u);
}
}
int n, m;
void pre() {
par[0][0] = 0;
dfs(0, -1);
for (int j = 1; j < logN; ++j) {
for (int i = 0; i < n; ++i) {
par[i][j] = par[par[i][j - 1]][j - 1];
mxwt[i][j] = max(mxwt[i][j - 1], mxwt[par[i][j - 1]][j - 1]);
}
}
}
int calc(int u, int v) {
int ans = 0;
if (lvl[u] > lvl[v]) swap(u, v);
int diff = lvl[v] - lvl[u];
for (int j = 0; j < logN; ++j) {
if ((1 << j) & diff) {
ans = max(ans, mxwt[v][j]);
v = par[v][j];
}
}
if (u == v) return ans;
for (int j = logN - 1; j >= 0; --j) {
if (par[u][j] != par[v][j]) {
ans = max({ans, mxwt[u][j], mxwt[v][j]});
u = par[u][j];
v = par[v][j];
}
}
return max({ans, mxwt[u][0], mxwt[v][0]});
}
void solve() {
for (int i = 0; i < N; ++i) {
id[i] = i;
}
cin >> n >> m;
vector<pair<pair<int, int>, pair<int, int>>> edges;
for (int i = 0; i < m; ++i) {
int v, u, w;
cin >> u >> v >> w;
u--;
v--;
edges.push_back({{w, i}, {u, v}});
}
sort(edges.begin(), edges.end());
long long ans = 0;
for (int i = 0; i < m; ++i) {
if (merge(edges[i].second.first, edges[i].second.second)) {
adj[edges[i].second.first].push_back(
{edges[i].second.second, edges[i].first.first});
adj[edges[i].second.second].push_back(
{edges[i].second.first, edges[i].first.first});
ans += edges[i].first.first;
}
}
pre();
vector<long long> pr(m, ans);
for (int i = 0; i < m; ++i) {
pr[edges[i].first.second] +=
edges[i].first.first -
calc(edges[i].second.first, edges[i].second.second);
}
for (long long x : pr) cout << x << '\n';
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
srand(chrono::high_resolution_clock::now().time_since_epoch().count());
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int s = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = (s << 3) + (s << 1) + ch - '0', ch = getchar();
}
return s * f;
}
const int inf = 0x3f, INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
inline long long gcd(long long a, long long b) {
return b == 0 ? a : gcd(b, a % b);
}
inline long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
template <typename... T>
void deb2(T &&...args) {
((cout << args << " "), ...);
cout << "\n";
}
const long long mod = 1e9 + 7;
struct tri {
int x, y, z;
bool operator<(const tri &one) const { return y < one.y; }
};
long long fpow(long long a, long long b) {
if (b == 0) return 1;
long long res = fpow(a, b / 2) % mod;
if (b % 2)
return ((res * res) % mod * a) % mod;
else
return (res * res) % mod;
}
const int maxn = 1e5 + 10;
int arr[maxn];
int arr2[maxn];
int val[maxn];
int bit[maxn];
vector<int> pos[maxn];
int freq[maxn];
int n;
long long ans;
void add(int ind) {
for (; ind < maxn; ind += ind & -ind) {
bit[ind]++;
}
}
int query(int ind) {
int ret = 0;
ind--;
for (; ind; ind -= ind & -ind) {
ret += bit[ind];
}
return ret;
}
int bit2[maxn];
void upd(int ind, int val) {
for (; ind < maxn; ind += ind & -ind) {
bit2[ind] += val;
}
}
int sumq(int L, int R) {
int ret = 0;
for (int i = R; i > 0; i -= i & -i) {
ret += bit2[i];
}
for (int i = L - 1; i > 0; i -= i & -i) {
ret -= bit2[i];
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
arr2[i] = arr[i];
}
sort(arr2 + 1, arr2 + 1 + n);
for (int i = 1; i <= n; i++) {
val[arr2[i]] = query(arr2[i]);
add(arr2[i]);
}
int t = 0;
for (int i = 1; i <= n; i++) {
upd(i, 1);
arr[i] = val[arr[i]];
t = max(t, arr[i]);
pos[arr[i]].push_back(i);
}
int prev = 0;
for (int i = 0; i <= t; i++) {
if (pos[i].empty()) continue;
sort(pos[i].begin(), pos[i].end());
if (prev < pos[i][0]) {
ans += sumq(prev, pos[i][pos[i].size() - 1]);
prev = pos[i][pos[i].size() - 1];
} else {
ans += sumq(prev, n);
int ind = 0;
for (int j : pos[i]) {
if (j < prev) {
ind = j;
} else {
break;
}
}
ans += sumq(1, ind);
prev = ind;
}
for (int j : pos[i]) {
upd(j, -1);
}
}
cout << ans << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
struct segtree {
struct node {
double sum;
double mul, add;
node() {
sum = 0;
mul = 1;
add = 0;
}
void apply_mul(int l, int r, double v) {
mul *= v;
add *= v;
sum *= v;
}
void apply_add(int l, int r, double v) {
add += v;
sum += v * (r - l + 1);
}
};
inline void push(int x, int l, int r) {
int m = (l + r) >> 1;
int z = x + ((m - l + 1) << 1);
if (fabs(tree[x].mul - 1) > eps) {
tree[x + 1].apply_mul(l, m, tree[x].mul);
tree[z].apply_mul(m + 1, r, tree[x].mul);
tree[x].mul = 1;
}
if (fabs(tree[x].add) > eps) {
tree[x + 1].apply_add(l, m, tree[x].add);
tree[z].apply_add(m + 1, r, tree[x].add);
tree[x].add = 0;
}
}
node unite(const node &a, const node &b) const {
node res;
res.sum = a.sum + b.sum;
return res;
}
inline void pull(int x, int z) { tree[x] = unite(tree[x + 1], tree[z]); }
int n;
vector<node> tree;
void build(int x, int l, int r, const vector<double> &v) {
if (l == r) {
tree[x].sum = v[l];
return;
}
int m = (l + r) >> 1;
int z = x + ((m - l + 1) << 1);
build(x + 1, l, m, v);
build(z, m + 1, r, v);
pull(x, z);
}
node get(int x, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) {
return tree[x];
}
int y = (l + r) >> 1;
int z = x + ((y - l + 1) << 1);
push(x, l, r);
node res;
if (rr <= y) {
res = get(x + 1, l, y, ll, rr);
} else {
if (ll > y) {
res = get(z, y + 1, r, ll, rr);
} else {
res = unite(get(x + 1, l, y, ll, rr), get(z, y + 1, r, ll, rr));
}
}
pull(x, z);
return res;
}
void modify_mul(int x, int l, int r, int ll, int rr, double v) {
if (ll <= l && r <= rr) {
tree[x].apply_mul(l, r, v);
return;
}
int m = (l + r) >> 1;
int z = x + ((m - l + 1) << 1);
push(x, l, r);
if (ll <= m) {
modify_mul(x + 1, l, m, ll, rr, v);
}
if (rr > m) {
modify_mul(z, m + 1, r, ll, rr, v);
}
pull(x, z);
}
void modify_add(int x, int l, int r, int ll, int rr, double v) {
if (ll <= l && r <= rr) {
tree[x].apply_add(l, r, v);
return;
}
int m = (l + r) >> 1;
int z = x + ((m - l + 1) << 1);
push(x, l, r);
if (ll <= m) {
modify_add(x + 1, l, m, ll, rr, v);
}
if (rr > m) {
modify_add(z, m + 1, r, ll, rr, v);
}
pull(x, z);
}
segtree() {}
template <typename M>
segtree(const vector<M> &v) {
n = v.size();
assert(n > 0);
tree.resize(2 * n - 1);
build(0, 0, n - 1, v);
}
node get(int ll, int rr) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
return get(0, 0, n - 1, ll, rr);
}
void modify_mul(int ll, int rr, double v) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
modify_mul(0, 0, n - 1, ll, rr, v);
}
void modify_add(int ll, int rr, double v) {
assert(0 <= ll && ll <= rr && rr <= n - 1);
modify_add(0, 0, n - 1, ll, rr, v);
}
};
int main() {
int n, q;
scanf("%d%d", &n, &q);
vector<double> a(n);
for (int i = 0; i < n; i++) {
scanf("%lf", &a[i]);
}
segtree st(a);
while (q--) {
int tp, l1, r1, l2, r2, l, r;
scanf("%d", &tp);
if (tp == 1) {
scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
l1--;
r1--;
l2--;
r2--;
int lena = r1 - l1 + 1;
int lenb = r2 - l2 + 1;
double suma = st.get(l1, r1).sum;
double sumb = st.get(l2, r2).sum;
st.modify_mul(l1, r1, 1.0 * (lena - 1) / lena);
st.modify_add(l1, r1, sumb / lena / lenb);
st.modify_mul(l2, r2, 1.0 * (lenb - 1) / lenb);
st.modify_add(l2, r2, suma / lena / lenb);
} else {
scanf("%d%d", &l, &r);
l--;
r--;
printf("%.8f\n", st.get(l, r).sum);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N, K, i, c = 1, cnt = 0;
cin >> N >> K;
string S;
cin >> S;
for (i = 0; i < N; i++) {
if (S[i] == '#') {
cnt++;
if (cnt == K) {
c = 0;
break;
}
} else
cnt = 0;
}
if (c)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e9 + 5;
const long long MOD = (long long)1e9 + 7;
const int MAXN = 5005;
int mi[MAXN], mx[MAXN], last, pa[MAXN];
void preprocess() {
int layer = 0, cur = 0, tot = 0;
for (int i = 1; i < MAXN; i++) {
mx[i] = i * (i - 1) / 2;
if (cur < (1 << layer)) {
cur++;
tot += layer;
} else {
layer++;
cur = 0;
cur++;
tot += layer;
}
mi[i] = tot;
}
}
void solve(int sz, int tot, int p) {
if (sz == 0) return;
int v = last++;
pa[v] = p;
assert(mi[sz] <= tot && tot <= mx[sz]);
int lson = sz - 1, rson = 0;
while (mi[lson] + mi[rson] + sz - 1 > tot) {
rson++;
lson--;
}
tot -= sz - 1;
for (int i = 0; i <= tot; i++) {
if (mi[lson] <= i && i <= mx[lson] && mi[rson] <= tot - i &&
tot - i <= mx[rson]) {
solve(lson, i, v);
solve(rson, tot - i, v);
break;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
preprocess();
int tc;
cin >> tc;
while (tc--) {
int n, d;
cin >> n >> d;
if (d > mx[n] || d < mi[n]) {
cout << "NO\n";
continue;
}
last = 1;
solve(n, d, 1);
cout << "YES\n";
for (int i = 2; i <= n; i++) {
cout << pa[i] << " \n"[i == n];
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
string s;
cin >> n >> m;
cin >> s;
long long a = 0, b = 0, z = 0, l = 0, ans = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == 'a') {
a++;
} else {
b++;
}
if (min(a, b) <= m) {
l++;
} else {
if (s[z] == 'a') {
a--;
} else {
b--;
}
z++;
}
ans = max(ans, l);
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c = 0;
cin >> a;
for (int i = 0; i < a; i++) {
cin >> b;
c = max(c, b);
}
cout << c << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, cnt0, cnt1;
string cheese, chtype;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> cheese >> chtype;
if (chtype == "soft")
cnt0++;
else
cnt1++;
}
if (cnt1 < cnt0) swap(cnt0, cnt1);
for (int sz = 1; sz <= 100; sz++) {
int black = (sz * sz) / 2;
int white = (sz * sz) - black;
if (white > black) swap(black, white);
if (white >= cnt0 && black >= cnt1) {
cout << sz;
return 0;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
void init_ios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
const int N = 5005;
int n, a, b, dp[N], dp2[N][N];
string s;
int main() {
init_ios();
cin >> n >> a >> b >> s;
s = "!" + s;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (s[i] == s[j]) dp2[i][j] = 1 + dp2[i - 1][j - 1];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) dp2[i][j] = max(dp2[i][j], dp2[i][j - 1]);
dp[1] = a;
for (int i = 2; i <= n; ++i) {
dp[i] = a + dp[i - 1];
for (int j = i; j >= 2; --j) {
int len = i - j + 1;
if (dp2[i][j - 1] >= len)
dp[i] = min(dp[i], b + dp[j - 1]);
else
break;
}
}
cout << dp[n] << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j;
cin >> n;
int l = -2e9, r = 2e9;
string a = "<", b = "<=", cs = ">", d = ">=";
while (n--) {
string s;
char c;
int num;
cin >> s >> num >> c;
if (s == a) {
if (c == 'Y')
r = min(r, num - 1);
else
l = max(num, l);
} else if (s == b) {
if (c == 'Y')
r = min(r, num);
else
l = max(l, num + 1);
} else if (s == cs) {
if (c == 'Y')
l = max(num + 1, l);
else
r = min(r, num);
} else {
if (c == 'Y')
l = max(num, l);
else
r = min(num - 1, r);
}
}
if (r < l)
cout << "Impossible";
else
cout << l << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << min(n - a, b + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s[6];
for (int i = 0; i < 6; i++) cin >> s[i];
vector<string> ans;
sort(s, s + 6);
do {
if (s[0].size() + s[4].size() != s[2].size() + 1 ||
s[1].size() + s[5].size() != s[3].size() + 1)
continue;
int v, h;
v = (int)s[3].size();
h = (int)s[2].size();
vector<string> vec(v);
vec[0].resize(h);
for (int i = 0; i < s[0].size(); i++) vec[0][i] = s[0][i];
if (s[1][0] != s[0][0]) continue;
for (int i = 0; i < s[1].size(); i++) {
if (!vec[i].size()) vec[i].resize(h);
vec[i][0] = s[1][i];
}
if (s[1].back() != s[2][0]) continue;
for (int i = 0; i < s[2].size(); i++) vec[s[1].size() - 1][i] = s[2][i];
if (s[3][0] != s[0].back() ||
s[3][s[1].size() - 1] != s[2][s[0].size() - 1])
continue;
for (int i = 0; i < s[3].size(); i++) {
if (!vec[i].size()) vec[i].resize(h);
vec[i][s[0].size() - 1] = s[3][i];
}
if (s[4][0] != s[3].back()) continue;
for (int i = 0; i < s[4].size(); i++)
vec[v - 1][i + (int)s[0].size() - 1] = s[4][i];
if (s[5][0] != s[2].back() || s[5].back() != s[4].back()) continue;
for (int i = 0; i < s[5].size(); i++)
vec[i + (int)s[1].size() - 1][h - 1] = s[5][i];
for (int i = 0; i < v; i++) {
for (int j = 0; j < h; j++)
if (!isalpha(vec[i][j])) vec[i][j] = '.';
}
if (!ans.size())
ans = vec;
else {
for (int i = 0; i < ans.size(); i++) {
if (vec[i] < ans[i]) {
ans = vec;
} else if (vec[i] > ans[i])
break;
}
}
} while (next_permutation(s, s + 6));
if (ans.size()) {
for (int i = 0; i < ans.size(); i++) cout << ans[i] << endl;
} else
cout << "Impossible\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long a[100005], b[100005];
int main() {
scanf("%lld %lld %lld", &n, &m, &k);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (long long i = 1; i <= m; i++) scanf("%lld", &b[i]);
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + m);
long long i = 0, j = 0;
while (i < n && j < m) {
if (b[j + 1] >= a[i + 1]) i++;
j++;
}
if (i == n)
printf("NO");
else
printf("YES");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int h[N], e[2 * N], ne[2 * N], w[2 * N], idx;
int sz[N];
void add(int a, int b, int c) {
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
int dfs(int u, int fa) {
sz[u] = 1;
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
if (j == fa) continue;
sz[u] += dfs(j, u);
}
return sz[u];
}
long long max(long long a, long long b) { return a > b ? a : b; }
long long min(long long a, long long b) { return a < b ? a : b; }
int main() {
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
memset(h, -1, sizeof h);
idx = 0;
for (int i = 1; i < 2 * n; i++) {
int a, b, c;
cin >> a >> b >> c;
add(a, b, c);
add(b, a, c);
}
dfs(1, -1);
long long ma_ans = 0;
long long mi_ans = 0;
for (int i = 1; i <= 2 * n; i++) {
for (int j = h[i]; j != -1; j = ne[j]) {
int k = e[j];
int we = w[j];
int weight = min(sz[i], sz[k]);
weight = min(weight, 2 * n - weight);
ma_ans += (long long)weight * we;
if (weight % 2) {
mi_ans += we;
}
}
}
cout << mi_ans / 2 << ' ' << ma_ans / 2 << endl;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e3 + 5;
int n, m;
vector<int> g[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u - 1].push_back(v - 1);
}
long long ans = 0;
for (int u = 0; u < n; u++) {
bool in2[N] = {false};
for (int v : g[u]) in2[v] = true;
int cnt[N] = {0};
for (int v = 0; v < n; v++)
if (in2[v])
for (int w : g[v])
if (w != u) cnt[w]++;
for (int v = 0; v < n; v++) ans += 1ll * cnt[v] * (cnt[v] - 1) / 2;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)(1e9);
const int N = (int)(3e5 + 10);
int main() {
ios_base::sync_with_stdio(0);
long long int n, m;
cin >> n >> m;
vector<int> w(m);
for (int i = 0; i < m; ++i) {
cin >> w[i];
cin >> w[i];
}
sort(w.begin(), w.end());
long long int q = 1;
while (q * (q - 1) / 2 + (q % 2 ? 0 : (q / 2 - 1)) < n) {
++q;
}
--q;
if (n == 1) q = 1;
reverse(w.begin(), w.end());
int b = min(q, m);
long long int ans = 0;
for (int i = 0; i < b; ++i) ans += w[i];
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n;
char s[100000 + 10];
int main() {
scanf("%d", &n);
scanf("%s", s);
sort(s, s + n);
printf("%s\n", s);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int first[8];
int minmx = 200;
int minmy = 200;
for (int i = 0; i < 8; i++) {
cin >> first[i];
if (i % 2 == 0) {
minmx = min(minmx, first[i]);
} else {
minmy = min(minmy, first[i]);
}
}
int second[8];
for (int i = 0; i < 8; i++) {
cin >> second[i];
}
int l_x1 = 200;
int l_y1 = 200;
int r_x1 = -200;
int r_y1 = -200;
for (int i = 0; i < 8; i++) {
if (i % 2 == 0) {
first[i] -= minmx;
second[i] -= minmx;
} else {
first[i] -= minmy;
second[i] -= minmy;
}
}
for (int i = 0; i < 8; i++) {
if (i % 2 == 0) {
if (second[i] < l_x1) {
l_x1 = second[i];
l_y1 = second[i + 1];
}
if (second[i] > r_x1) {
r_x1 = second[i];
r_y1 = second[i + 1];
}
}
}
vector<pair<int, int> > sec_points;
int d_l_y1 = l_y1;
int d_r_y1 = r_y1;
while (l_x1 != r_x1) {
sec_points.push_back(make_pair(l_x1, l_y1));
sec_points.push_back(make_pair(l_x1, d_l_y1));
sec_points.push_back(make_pair(r_x1, l_y1));
sec_points.push_back(make_pair(r_x1, d_l_y1));
for (int j = min(l_y1, d_l_y1); j <= max(l_y1, d_l_y1); j++) {
for (int p = 0; p < 8; p += 2) {
if (first[p] == l_x1 && first[p + 1] == j) {
cout << "YES";
return 0;
}
if (first[p] == r_x1 && first[p + 1] == j) {
cout << "YES";
return 0;
}
}
}
l_x1++;
r_x1--;
l_y1++;
d_l_y1--;
}
sec_points.push_back(make_pair(l_x1, l_y1));
sec_points.push_back(make_pair(l_x1, d_l_y1));
int x1 = -200;
int y1 = -200;
for (int i = 0; i < 8; i += 2) {
int x = first[i];
int y = first[i + 1];
if (x > x1) {
x1 = x;
}
if (y > y1) {
y1 = y;
}
}
for (pair<int, int> cur : sec_points) {
for (int i = 0; i <= x1; i++) {
for (int j = 0; j <= y1; j++) {
if (cur.first == i && cur.second == j) {
cout << "YES";
return 0;
}
}
}
}
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, i, j, b[100][100], c = 1;
scanf("%d", &n);
for (j = 0; j < n / 2; j++) {
for (i = 0; i < n; i++) {
b[i][j] = c;
c++;
}
}
for (j = n / 2; j < n; j++) {
for (i = n - 1; i >= 0; i--) {
b[i][j] = c;
c++;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
printf("%d ", b[i][j]);
}
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int ar[100005], n;
int res[100005][20];
int mod[100005][20];
void preCalc() {
for (int i = int(0); i < int(n); i++) res[i][0] = 0, mod[i][0] = ar[i];
for (int j = int(1); j < int(20); j++) {
for (int i = int(0); i < int(n); i++) {
if (i + (1 << (j - 1)) >= n) continue;
int moda = mod[i][j - 1], modb = mod[i + (1 << (j - 1))][j - 1];
res[i][j] =
res[i][j - 1] + res[i + (1 << (j - 1))][j - 1] + (moda + modb >= 10);
mod[i][j] = (moda + modb) % 10;
}
}
}
int main() {
scanf("%d", &n);
for (int i = int(0); i < int(n); i++) {
scanf("%d", ar + i);
}
preCalc();
int q;
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d %d", &l, &r);
l--, r--;
int dis = r - l;
int lvl = 0;
while (dis) {
dis >>= 1;
lvl++;
}
printf("%d\n", res[l][lvl]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
vector<int> A(n);
for (int _i = 0; _i < n; _i++) cin >> A[_i];
vector<int> B(n);
for (int _i = 0; _i < n; _i++) cin >> B[_i];
vector<int> C(n);
for (int _i = 0; _i < n; _i++) cin >> C[_i];
vector<int> P(n);
for (int i = 0; i <= n - 1; i++) P[i] = -1;
for (int i = 0; i <= n - 1; i++) {
if (P[(i + n - 1) % n] != A[i] && P[(i + 1) % n] != A[i]) {
P[i] = A[i];
} else if (P[(i + n - 1) % n] != B[i] && P[(i + 1) % n] != B[i]) {
P[i] = B[i];
} else if (P[(i + n - 1) % n] != C[i] && P[(i + 1) % n] != C[i]) {
P[i] = C[i];
}
}
for (int _i = 0; _i < P.size(); _i++) cout << P[_i] << " ";
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
for (int tt = 1; tt <= t; tt++) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " =: " << a << "\n";
err(++it, args...);
}
template <typename T1, typename T2>
inline std::ostream& operator<<(std::ostream& os, const std::pair<T1, T2>& p) {
return os << "(" << p.first << ": " << p.second << ")";
}
template <typename T>
inline std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
bool first = true;
os << "[";
for (unsigned int i = 0; i < v.size(); i++) {
if (!first) os << ", ";
os << v[i];
first = false;
}
return os << "]";
}
template <typename T>
inline std::ostream& operator<<(std::ostream& os, const std::set<T>& v) {
bool first = true;
os << "{";
for (typename std::set<T>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "}";
}
template <typename T1, typename T2>
inline std::ostream& operator<<(std::ostream& os, const std::map<T1, T2>& v) {
bool first = true;
os << "{";
for (typename std::map<T1, T2>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "}";
}
template <typename T>
inline std::ostream& operator<<(std::ostream& os,
const std::unordered_set<T>& v) {
return os << std::set<T>(v.begin(), v.end());
}
template <typename T1, typename T2>
inline std::ostream& operator<<(std::ostream& os,
const std::unordered_map<T1, T2>& v) {
return os << std::map<T1, T2>(v.begin(), v.end());
}
const long long int MOD = 1e9 + 7;
const long long int INF = 1e18;
const double EPS = 1e-6;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
auto mpow = [](long long int b, int e) {
long long int ret = 1LL;
while (e--) {
ret *= b;
ret %= MOD;
}
return ret;
};
function<long long int(string)> solve = [&solve, &mpow](string s) {
if (s == "1") return 1LL;
if (s == "0") return 0LL;
long long int ret = 2LL * solve(s.substr(1, string::npos)) % MOD;
if (s[0] == '1') ret += mpow(4LL, s.length() - 1);
return ret % MOD;
};
cout << solve(s);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int p = 1e9 + 7;
using namespace std;
int mo(int x) { return x >= p ? x - p : x; }
const int N = 1e6 + 5;
int rt, n, cnt, c[N][2], sz[N], id[N], d[N], a[N];
long long K;
struct A {
int x;
long long y;
};
A operator+(A i, A j) { return (A){mo(i.x + j.x), i.y + j.y}; }
int get(int x, int y) {
if (!c[x][y]) c[x][y] = ++cnt;
return c[x][y];
}
namespace tr {
const int M = 1500005;
int cnt, s[M][30], c[M][2], sz[M];
void ins(int &o, int d, int x) {
if (!o) o = ++cnt;
for (int i = 29; i >= 0; i--) {
if ((x >> i) & 1) s[o][i]++;
}
sz[o]++;
if (d < 0) {
return;
}
ins(c[o][(x >> d) & 1], d - 1, x);
}
int cal(int o, int x) {
int ret = 0;
for (int i = 29; i >= 0; i--) {
if ((x >> i) & 1)
ret = (ret + (long long)(1 << i) * (sz[o] - s[o][i])) % p;
else
ret = (ret + (long long)(1 << i) * s[o][i]) % p;
}
return ret;
}
A ask(int o, int d, int x, int y) {
if (d < 0) return (A){cal(o, x), sz[o]};
int k1 = (x >> d) & 1, k2 = (y >> d) & 1;
if (k2) return ask(c[o][!k1], d - 1, x, y);
return ask(c[o][k1], d - 1, x, y) + (A){cal(c[o][!k1], x), sz[c[o][!k1]]};
}
} // namespace tr
int main() {
cin >> n >> K;
K <<= 1;
long long t = K;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
long long ans = 0;
for (int i = 29; i >= 0; i--) {
cnt = 0;
memset(c, 0, sizeof(c));
memset(sz, 0, sizeof(sz));
for (int j = 1; j <= n; j++) {
id[j] = get(id[j], (a[j] >> i) & 1);
sz[id[j]]++;
}
long long sum = 0;
for (int j = 1; j <= n; j++) {
sum += sz[c[d[j]][!((a[j] >> i) & 1)]];
}
for (int j = 1; j <= n; j++) {
d[j] = c[d[j]][((a[j] >> i) & 1) ^ (sum >= t)];
}
if (sum >= t)
ans |= 1 << i;
else
t -= sum;
}
for (int i = 1; i <= n; i++) {
tr::ins(rt, 29, a[i]);
}
A Ans = (A){0, 0};
for (int i = 1; i <= n; i++) {
Ans = Ans + tr::ask(rt, 29, a[i], ans);
}
ans = mo(Ans.x - (Ans.y - K) % p * ans % p + p);
ans = ans * (p - p / 2) % p;
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 5, MOD = 1e9 + 7;
int n, m;
struct Bus {
int s, t;
} a[M];
bool cmp(Bus a, Bus b) { return a.t < b.t; }
int l, r, mid, tmp1, tmp2;
long long sum[M], f[M];
long long ans = 0;
int main() {
cin >> n >> m;
++m;
for (int i = 2; i <= m; ++i) {
scanf("%d%d", &a[i].s, &a[i].t);
}
sort(a + 2, a + 1 + m, cmp);
f[1] = sum[1] = 1;
for (int i = 2; i <= m; ++i) {
l = 1, r = i - 1;
while (l <= r) {
mid = (l + r) >> 1;
if (a[mid].t < a[i].t) {
l = mid + 1;
tmp1 = mid;
} else
r = mid - 1;
}
tmp2 = tmp1 + 1;
l = 1, r = tmp1;
while (l <= r) {
mid = (l + r) >> 1;
if (a[mid].t >= a[i].s) {
r = mid - 1;
tmp2 = mid;
} else
l = mid + 1;
}
f[i] = ((sum[tmp1] - sum[tmp2 - 1]) % MOD + MOD) % MOD;
sum[i] = (sum[i - 1] + f[i]) % MOD;
}
for (int i = 2; i <= m; ++i) {
if (a[i].t == n) {
ans += f[i];
ans %= MOD;
}
}
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
set<int> s1;
multiset<int, greater<int> > s2;
int solve() {
if (s1.size() <= 2) return 0;
set<int>::iterator it1 = s1.begin(), it2 = s1.end();
it2--;
int al = (*it2) - (*it1);
int mx = *s2.begin();
return al - mx;
}
void err(int x) {
multiset<int>::iterator it = s2.lower_bound(x);
s2.erase(it);
}
void del(int x) {
if (s1.size() == 1) {
s1.erase(x);
return;
}
set<int>::iterator it = s1.lower_bound(x), it2 = it, it3 = it;
it2++;
if (it2 == s1.end()) {
it3--;
err((*it) - (*it3));
s1.erase(x);
} else if (it == s1.begin()) {
err((*it2) - (*it));
s1.erase(x);
} else {
it3--;
err((*it) - (*it3));
err((*it2) - (*it));
s2.insert((*it2) - (*it3));
s1.erase(x);
}
}
void ins(int x) {
if (!s1.size()) {
s1.insert(x);
return;
}
set<int>::iterator it = s1.lower_bound(x), it2 = it;
if (it == s1.begin()) {
s2.insert((*it) - x);
s1.insert(x);
} else if (it == s1.end()) {
it2--;
s2.insert(x - (*it2));
s1.insert(x);
} else {
it2--;
s2.insert(x - (*it2));
s2.insert((*it) - x);
err((*it) - (*it2));
s1.insert(x);
}
}
int main() {
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), s1.insert(a[i]);
sort(a + 1, a + n + 1);
for (int i = 2; i <= n; i++) s2.insert(a[i] - a[i - 1]);
printf("%d\n", solve());
for (int i = 1; i <= q; i++) {
int t, x;
scanf("%d%d", &t, &x);
if (t == 0)
del(x);
else
ins(x);
printf("%d\n", solve());
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int N = 500005;
using namespace std;
int n, m, al, u, v;
char op[3];
long long va[N], ans;
struct T {
int f[N], sz[N], ui[N];
vector<int> t[N];
inline void push() {
for (; f[u] ^ u; u = f[u])
;
va[al] = sz[u] + (t[u].size() ? va[t[u][t[u].size() - 1]] : 0);
t[u].push_back(al);
}
inline void uni() {
for (; f[u] ^ u; u = f[u])
;
for (; f[v] ^ v; v = f[v])
;
if (sz[u] < sz[v]) swap(u, v);
sz[f[v] = u] += sz[v];
ui[v] = t[u].size();
}
inline void get(int u) {
int tp = 0;
for (;; tp = ui[u], u = f[u]) {
if (t[u].size() > tp) v = t[u][t[u].size() - 1];
if (f[u] == u) break;
}
}
inline void sol() {
int tp = 0, re;
for (;; tp = ui[u], u = f[u]) {
if (t[u].size() > tp && t[u][t[u].size() - 1] > v) {
ans += va[t[u][t[u].size() - 1]];
if (t[u][tp] < v) {
re = tp - 1;
for (int l = tp, r = t[u].size() - 1, mi; l <= r;)
if (t[u][mi = l + r >> 1] < v)
re = mi, l = mi + 1;
else
r = mi - 1;
ans -= va[t[u][re]];
} else if (tp)
ans -= va[t[u][tp - 1]];
}
if (f[u] == u) break;
}
}
} A, D;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) A.f[i] = D.f[i] = i, A.sz[i] = D.sz[i] = 1;
for (al = 1; al <= m; al++) {
scanf("%s%d", op, &u);
if (op[0] == 'A')
A.push();
else if (op[0] == 'Z')
D.push();
else if (op[0] == 'Q') {
v = ans = 0;
D.get(u);
A.sol();
printf("%lld\n", ans);
} else
scanf("%d", &v), op[0] ^ 'U' ? D.uni() : A.uni();
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, k;
scanf("%i %i", &n, &k);
vector<int> a(n);
for (int i = 0; i < n; i++) {
scanf("%i", &a[i]);
}
set<int> Q;
map<int, int> freq;
for (int i = 0; i < k; i++) {
freq[a[i]]++;
if (freq[a[i]] == 1) {
Q.insert(a[i]);
} else {
Q.erase(a[i]);
}
}
if (!Q.empty()) {
printf("%i\n", *Q.rbegin());
} else {
puts("Nothing");
}
for (int i = k; i < n; i++) {
freq[a[i]]++;
if (freq[a[i]] == 1) {
Q.insert(a[i]);
} else {
Q.erase(a[i]);
}
freq[a[i - k]]--;
if (freq[a[i - k]] == 1) {
Q.insert(a[i - k]);
} else {
Q.erase(a[i - k]);
}
if (!Q.empty()) {
printf("%i\n", *Q.rbegin());
} else {
puts("Nothing");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v, w;
edge(int v = 0, int w = 0) : v(v), w(w) {}
};
int n, k, dp[100005][2];
int pos[100005];
vector<edge> G[100005];
bool cmp1(int x, int y) { return dp[x][1] > dp[y][1]; }
void dfs(int u, int p) {
vector<int> kid;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].v;
if (v == p) continue;
dfs(v, u);
dp[v][1] += G[u][i].w;
kid.push_back(v);
}
int num = k - 1;
sort(kid.begin(), kid.end(), cmp1);
for (int i = 0; i < kid.size(); i++) pos[kid[i]] = i;
for (int i = 0; i < min((int)kid.size(), num); i++) dp[u][1] += dp[kid[i]][1];
int sum = dp[u][1];
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].v;
if (v == p) continue;
if (pos[v] < num) {
int tmp = 0;
if (kid.size() > num) tmp = dp[kid[num]][1];
dp[u][0] = max(dp[u][0], sum - dp[v][1] + tmp + dp[v][0] + G[u][i].w);
} else
dp[u][0] = max(dp[u][0], sum + dp[v][0] + G[u][i].w);
}
}
int main() {
iostream::sync_with_stdio(0);
cin >> n >> k;
for (int i = 1; i < n; i++) {
int x, y, w;
cin >> x >> y >> w;
G[x].push_back(edge(y, w));
G[y].push_back(edge(x, w));
}
dfs(0, -1);
cout << max(dp[0][0], dp[0][1]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const long long INF = mod * mod;
const long double eps = 1e-8;
struct SegT {
private:
int sz;
vector<int> node;
const int init_c = -mod;
public:
void init(vector<int> v) {
int n = v.size();
sz = 1;
while (sz < n) sz *= 2;
node.resize(2 * sz - 1, init_c);
for (int i = 0; i < n; i++) {
node[i + sz - 1] = v[i];
}
for (int i = sz - 1 - 1; i >= 0; i--) {
node[i] = f(node[2 * i + 1], node[2 * i + 2]);
}
}
int f(int a, int b) { return max(a, b); }
void update(int k, int a) {
k += sz - 1;
node[k] = a;
while (k > 0) {
k = (k - 1) / 2;
node[k] = f(node[k * 2 + 1], node[k * 2 + 2]);
}
}
int query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = sz;
if (r <= a || b <= l)
return init_c;
else if (a <= l && r <= b)
return node[k];
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return f(vl, vr);
}
}
};
int n;
vector<int> p;
SegT st;
int trans[1 << 18];
long long ans = 0;
void d_and_c(int l, int r) {
if (l > r) return;
int ma = st.query(l, r + 1);
int mid = trans[ma];
d_and_c(l, mid - 1);
d_and_c(mid + 1, r);
int lenl = mid - l;
int lenr = r - mid;
if (lenl < lenr) {
for (int i = l; i <= mid - 1; i++) {
int loc = trans[ma - p[i]];
if (mid + 1 <= loc && loc <= r) ans++;
}
} else {
for (int i = mid + 1; i <= r; i++) {
int loc = trans[ma - p[i]];
if (l <= loc && loc <= mid - 1) ans++;
}
}
}
void solve() {
cin >> n;
p.resize(n);
for (int i = 0; i < n; i++) {
cin >> p[i];
trans[p[i]] = i;
}
st.init(p);
d_and_c(0, n - 1);
cout << ans << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, k1 = 0, k2 = 0;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < n; i++) {
if (a[i] == 100) {
k1++;
} else {
k2++;
}
}
if (k1 % 2 == 0 && (k2 % 2 == 0 || k1 > 0))
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
int n, k, h;
int m[100000], v[100000], id[100000];
int ans[100000];
double x;
bool cmp(int a, int b) { return m[a] != m[b] ? m[a] < m[b] : v[a] < v[b]; }
int main() {
scanf("%d%d%d", &n, &k, &h);
for (int i = 0; i < n; i++) scanf("%d", m + i);
for (int i = 0; i < n; i++) scanf("%d", v + i);
for (int i = 0; i < n; i++) id[i] = i;
sort(id, id + n, cmp);
long double l = 0, r = 1e20, c;
for (int i = 0; i < 200; i++) {
c = (l + r) / 2;
int t = 0, j;
for (j = 1; j <= k; j++) {
for (; t < n && (double)j * h + EPS > v[id[t]] * c; t++)
;
if (t == n) break;
t++;
}
if (j > k)
r = c;
else
l = c;
}
int t = 0;
for (int j = 1; j <= k; j++) {
for (; t < n && (double)j * h + EPS > v[id[t]] * r; t++)
;
printf("%d%c", id[t] + 1, j == k ? '\n' : ' ');
t++;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const long long inf = (((long long)1) << 61) + 5;
const int N = 100005;
int f[N];
int g[N];
int a[N];
int bit[N];
int ans[N];
int sum1(int x) {
int ans = 0;
for (int i = x; i > 0; i -= i & -i) ans = max(bit[i], ans);
return ans;
}
void add1(int x, int val) {
for (int i = x; i <= N; i += i & -i) bit[i] = max(bit[i], val);
}
int sum2(int x) {
int ans = 0;
for (int i = x; i <= N; i += i & -i) ans = max(bit[i], ans);
return ans;
}
void add2(int x, int val) {
for (int i = x; i > 0; i -= i & -i) bit[i] = max(bit[i], val);
}
int main() {
int n, res = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
int x = sum1(a[i] - 1);
f[i] = x + 1;
if (f[i] > res) res = f[i];
add1(a[i], f[i]);
}
memset(bit, 0, sizeof bit);
for (int i = n; i >= 1; i--) {
int x = sum2(a[i] + 1);
g[i] = x + 1;
add2(a[i], g[i]);
}
vector<int> q[N];
for (int i = 1; i <= n; i++) {
if (f[i] + g[i] - 1 < res)
ans[i] = 1;
else
q[f[i]].push_back(i);
}
for (int i = 1; i <= res; i++) {
int sz = q[i].size();
for (int j = 0; j < sz; j++) {
int v = q[i][j];
if (sz == 1)
ans[v] = 3;
else
ans[v] = 2;
}
}
for (int i = 1; i <= n; i++) printf("%d", ans[i]);
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
cout << n * 3 + min(n - k, k - 1) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const long long LINF = 1e18;
const int INF = 1e9;
const int M = 1e9 + 7;
const double EPS = 1e-9;
using namespace std;
string str;
set<int> s[2];
vector<vector<int> > ans;
int n = 0;
bool fl = 0;
int main() {
ios_base::sync_with_stdio(0);
cin >> str;
int len = str.length();
for (int i = 0; i < len; i++) s[str[i] - '0'].insert(i);
fl = str[0] - '0';
ans.resize(s[0].size() + 10);
while (!s[0].empty()) {
if (s[1].size() && *s[0].begin() > *s[1].begin()) {
fl = 1;
break;
}
int t = 0;
int pos = *s[0].begin();
ans[n].push_back(pos + 1);
s[0].erase(s[0].begin());
while (1) {
t = (t + 1) % 2;
auto it = s[t].upper_bound(pos);
if (it != s[t].end()) {
pos = *it;
s[t].erase(it);
ans[n].push_back(pos + 1);
} else {
if (!t) fl = 1;
break;
}
}
n++;
if (fl) break;
}
fl += s[1].size();
if (fl) {
cout << "-1";
return 0;
}
cout << n << "\n";
for (int i = 0; i < n; i++) {
int len = ans[i].size();
cout << len << " ";
for (int j = 0; j < len; j++) cout << ans[i][j] << " ";
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int const N = 200100;
template <typename T>
inline bool uax(T &x, T y) {
return (y > x) ? x = y, true : false;
}
template <typename T>
inline bool uin(T &x, T y) {
return (y < x) ? x = y, true : false;
}
string to_string(char c) { return "'" + string(1, c) + "'"; }
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
template <typename A>
string to_string(A);
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ": " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool f = false;
string r = "{";
for (auto x : v) {
if (f) r += ", ";
r += to_string(x);
f = true;
}
return r += "}";
}
template <typename A>
string to_string(vector<vector<A>> v) {
string r;
for (auto x : v) r += "\n" + to_string(x);
return r;
}
void err(istream_iterator<string>) { cerr << endl; }
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " =: " << to_string(a) << "; ";
err(++it, args...);
}
template <typename T>
void kek(T ans) {
cout << ans << endl;
exit(0);
}
int const mod = 1e9 + 7;
using pii = pair<int, int>;
long long INF = 1e18, NIN = -1 * INF;
struct Node {
long long minv, lz;
Node() : minv(), lz() {}
friend Node operator+(const Node &lhs, const Node &rhs) {
Node node;
node.minv = max(lhs.minv, rhs.minv);
return node;
}
};
struct SegTree {
vector<int> ss, ee;
vector<Node> t;
int n;
SegTree(int n1) : ss(n1 << 2), ee(n1 << 2), t(n1 << 2) {
n = n1;
build(1, 1, n1);
for (int x = 0; x < (n << 2); x++) t[x].minv = 0;
}
void build(int i, int l, int r) {
ss[i] = l, ee[i] = r;
if (l == r) {
return;
}
int m = (l + r) >> 1;
build((i + i), l, m);
build((i + i + 1), m + 1, r);
}
inline void push(int i) {
long long &lz = t[i].lz;
if (lz == 0) {
return;
}
long long len = ee[i] - ss[i] + 1;
t[i].minv += lz;
if (len > 1) {
t[(i + i)].lz += lz;
t[(i + i + 1)].lz += lz;
}
lz = 0;
}
inline void update(int i, int us, int ue, long long a) {
if (us <= ss[i] && ee[i] <= ue) {
t[i].lz += a;
push(i);
return;
}
push(i);
if (ue < ss[i] || ee[i] < us) {
return;
}
update((i + i), us, ue, a);
update((i + i + 1), us, ue, a);
t[i] = t[(i + i)] + t[(i + i + 1)];
}
inline Node ask(int i, int qs, int qe) {
push(i);
if (qs == ss[i] && qe == ee[i]) {
return t[i];
}
if (qe <= ee[(i + i)]) {
return ask((i + i), qs, qe);
}
if (qs >= ss[(i + i + 1)]) {
return ask((i + i + 1), qs, qe);
}
return ask((i + i), qs, ee[(i + i)]) +
ask((i + i + 1), ss[(i + i + 1)], qe);
}
void update(int L, int R, long long val) { return update(1, L, R, val); }
long long ask(int L, int R) {
if (L > n) return 0LL;
return ask(1, L, R).minv;
}
};
int add(int a, int b) {
if (a + b >= mod) return a + b - mod;
return a + b;
}
int mul(int a, int b) { return 1LL * a * b % mod; }
int power(int a, int b) {
int re = 1;
while (b) {
if (b & 1) re = mul(re, a);
a = mul(a, a);
b >>= 1;
}
return re;
}
int fact[N], inv[N];
int ncr(int a, int b) {
if (a < 0 || b < 0 || a < b) return 0;
return mul(fact[a], mul(inv[a - b], inv[b]));
}
int ncr(pii a) { return ncr(a.first, a.second); }
void fac() {
fact[1] = fact[0] = 1;
for (int x = 2; x < N; x++) {
fact[x] = mul(x, fact[x - 1]);
}
inv[N - 1] = power(fact[N - 1], mod - 2);
for (int x = N - 2; x >= 0; x--) {
inv[x] = mul(x + 1, inv[x + 1]);
}
}
int main() {
long long te;
cin >> te;
while (te--) {
long long n;
cin >> n;
long long a[n];
;
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
int f1 = -1, f2 = -1;
long long c1 = a[0];
for (long long i = 0; i < n - 1; i++) {
if (c1 <= a[i + 1]) {
f1 = 0;
} else {
f1 = i;
break;
}
}
long long c2 = a[n - 1];
for (long long i = n - 1; i >= 1; i--) {
if (a[i] >= a[i - 1]) {
f2 = 1;
} else {
f2 = i;
break;
}
}
if (f1 == -1 || f2 == -1)
cout << "YES" << endl;
else if (c1 < c2)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 1e6;
void solve() {
string s;
cin >> s;
long long n = s.size();
long long ans = 1;
if (s == "0") {
cout << 4;
return;
} else if (n < 2) {
long long n = s[0] - '0';
ans = (1 + pow(2, n) + pow(3, n) + pow(4, n));
ans %= 5;
cout << ans;
return;
}
long long last = s[n - 1] - '0';
if (last % 2 == 0) {
ans += 6;
} else {
ans += 4;
}
long long last2 = (s[s.size() - 2] - '0') * 10 + s[s.size() - 1] - '0';
if (last2 % 4 == 0) {
ans += (6 + 1);
} else if (last % 2 == 0) {
ans += (4 + 9);
} else if (last2 % 4 == 1) {
ans += (2 + 3);
} else {
ans += (8 + 7);
}
cout << ans % 5;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
while (T--) {
solve();
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 2e4 + 5;
const int mxK = 26;
struct qry {
int l, r, i;
bool operator<(const qry& q) const { return r > q.r; }
};
vector<qry> qs[mxN];
struct DSU {
vector<int> size;
vector<int> p;
int comps;
void copy(DSU& dsu) {
dsu.size = size;
dsu.p = p;
dsu.comps = comps;
}
void build(int n) {
size = vector<int>(n, 1);
p = vector<int>(n);
iota(p.begin(), p.end(), 0);
comps = n;
}
int get(int x) {
if (p[x] != x) {
p[x] = get(p[x]);
}
return p[x];
}
bool unite(int a, int b) {
a = get(a);
b = get(b);
if (a == b) return false;
if (size[a] > size[b]) swap(a, b);
p[a] = b;
size[b] += size[a];
comps--;
return true;
}
};
int ans[mxN];
struct edge {
int u, v;
};
edge edges[mxN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
edges[i] = {u, v};
}
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
qs[l].push_back({l, r, i});
}
DSU save;
save.build(n);
for (int l = 1; l <= m; l++) {
sort(qs[l].begin(), qs[l].end());
DSU dsu;
save.copy(dsu);
int r = m;
for (auto qr : qs[l]) {
while (r > qr.r) {
dsu.unite(edges[r].u, edges[r].v);
r--;
}
ans[qr.i] = dsu.comps;
}
save.unite(edges[l].u, edges[l].v);
}
for (int i = 0; i < q; i++) cout << ans[i] << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, l, r, x, sol = 0;
int t[30];
int main() {
scanf("%d %d %d %d", &n, &l, &r, &x);
for (int i = 1; i <= n; i++) scanf("%d", &t[i]);
for (int i = 1; i < (1 << n); i++) {
int cmin = 2e9, cmax = 0, nr = 0;
long long int sum = 0;
for (int j = 0; j < n; j++)
if (((i >> j) & 1) == 1) {
cmin = min(cmin, t[j + 1]);
cmax = max(cmax, t[j + 1]);
sum = sum + t[j + 1];
nr++;
}
if (nr >= 2 && sum >= l && sum <= r && cmax - cmin >= x) sol++;
}
printf("%d", sol);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const long long LINF = 2e18 + 7;
const int MXN = 20;
void io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
int v[5005];
int main() {
int N, K;
cin >> N >> K;
for (int i = 1; i <= N; ++i) {
cin >> v[i];
v[i] += v[i - 1];
}
double ans = -1e100;
for (int i = 1; i <= N; ++i) {
for (int j = i + K - 1; j <= N; ++j) {
double cur = (double)(v[j] - v[i - 1]) / (j - i + 1);
ans = max(ans, cur);
}
}
cout << fixed;
cout.precision(10);
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937_64 rng64(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 2550;
long long t[maxn][maxn];
map<pair<pair<long long, long long>, pair<long long, long long> >, long long>
mp;
void upd(int xx, int yy, long long d) {
for (int x = xx; x < maxn; x |= x + 1)
for (int y = yy; y < maxn; y |= y + 1) t[x][y] += d;
}
long long get(int xx, int yy) {
long long res = 0;
for (int x = xx; x >= 0; x = (x & (x + 1)) - 1)
for (int y = yy; y >= 0; y = (y & (y + 1)) - 1) res += t[x][y];
return res;
}
int main() {
ios::sync_with_stdio(false);
int n, m, q;
cin >> n >> m >> q;
while (q--) {
int t, l1, r1, l2, r2;
cin >> t >> l1 >> r1 >> l2 >> r2;
if (t == 1) {
long long rnd = rng64();
mp[{{l1, r1}, {l2, r2}}] = rnd;
upd(l1, r1, rnd);
upd(l1, r2 + 1, -rnd);
upd(l2 + 1, r1, -rnd);
upd(l2 + 1, r2 + 1, rnd);
} else if (t == 2) {
long long rnd = -mp[{{l1, r1}, {l2, r2}}];
upd(l1, r1, rnd);
upd(l1, r2 + 1, -rnd);
upd(l2 + 1, r1, -rnd);
upd(l2 + 1, r2 + 1, rnd);
} else {
long long f = get(l1, r1), s = get(l2, r2);
cout << (f == s ? "Yes" : "No") << '\n';
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
const int M = 5e6 + 5;
struct Edge {
int to, nxt;
} E[N];
int n, c[N], cnt, head[N], f[M], t, q[N], s[N];
int son[N], ans[N], l[N], st[N], depth[N];
void addedg(int u, int v) {
E[++cnt].to = v;
E[cnt].nxt = head[u];
head[u] = cnt;
}
void dfs1(int u) {
s[u] = 1;
for (int i = head[u]; i; i = E[i].nxt) {
int v = E[i].to;
depth[v] = depth[u] + 1;
st[v] = st[u] ^ (1 << c[v]);
dfs1(v);
s[u] += s[v];
if (s[v] > s[son[u]]) son[u] = v;
}
}
void remove(int u) {
f[st[u]] = 0;
for (int i = head[u]; i; i = E[i].nxt) remove(E[i].to);
}
void calc(int k, int u) {
int now = st[k] ^ st[u];
if ((now & -now) == now || !now) ans[k] = max(ans[k], depth[u] - depth[k]);
if (f[st[u]]) ans[k] = max(ans[k], f[st[u]] + depth[u] - 2 * depth[k]);
for (int i = 0; i < 22; i++)
if (f[st[u] ^ (1 << i)])
ans[k] = max(ans[k], f[st[u] ^ (1 << i)] + depth[u] - 2 * depth[k]);
for (int i = head[u]; i; i = E[i].nxt) {
int v = E[i].to;
calc(k, v);
}
}
void add(int u) {
f[st[u]] = max(f[st[u]], depth[u]);
for (int i = head[u]; i; i = E[i].nxt) {
int v = E[i].to;
add(v);
}
}
void dfs2(int u) {
if (!son[u]) return;
for (int i = head[u]; i; i = E[i].nxt) {
int v = E[i].to;
if (v == son[u]) continue;
dfs2(v);
remove(v);
ans[u] = max(ans[u], ans[v]);
}
dfs2(son[u]);
f[st[son[u]]] = max(depth[son[u]], f[st[son[u]]]);
ans[u] = max(ans[u], max(ans[son[u]], f[st[u]] - depth[u]));
for (int i = 0; i < 22; i++)
ans[u] = max(ans[u], f[st[u] ^ (1 << i)] - depth[u]);
for (int i = head[u]; i; i = E[i].nxt) {
int v = E[i].to;
if (v == son[u]) continue;
calc(u, v);
add(v);
}
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int p;
char opt[3];
scanf("%d", &p);
scanf("%s", opt);
addedg(p, i);
c[i] = opt[0] - 'a';
}
dfs1(1);
dfs2(1);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int Rank[30][4010];
int SuffixArray[4010];
int LCP[4010];
struct entry {
int A[2];
int pos;
};
entry Temp[4010];
char str[4010];
bool way(entry x, entry y) {
return (x.A[0] == y.A[0]) ? (x.A[1] < y.A[1] ? true : false)
: (x.A[0] < y.A[0] ? true : false);
}
int step, cnt;
int N;
void BuildSuffixArray(void) {
for (int i = 0; i < N; i++) Rank[0][i] = str[i] - 'a';
for (step = 1, cnt = 1; (cnt >> 1) < N; step++, (cnt <<= 1)) {
for (int i = 0; i < N; i++) {
Temp[i].A[0] = Rank[step - 1][i];
Temp[i].A[1] = (i + cnt < N) ? Rank[step - 1][i + cnt] : -1000000007;
Temp[i].pos = i;
}
sort(Temp, Temp + N, way);
for (int i = 0; i < N; i++) {
Rank[step][Temp[i].pos] = (i > 0 and Temp[i].A[0] == Temp[i - 1].A[0] and
Temp[i].A[1] == Temp[i - 1].A[1])
? Rank[step][Temp[i - 1].pos]
: i;
}
}
for (int i = 0; i < N; i++) SuffixArray[i] = Temp[i].pos;
step--;
}
void BuildLCPArray(void) {
for (int i = 0, l = 0; i < N; i++) {
if (Rank[step][i] != N - 1) {
for (int j = SuffixArray[Rank[step][i] + 1];
j + l < N and i + l < N and str[i + l] == str[j + l];)
l++;
LCP[Rank[step][i]] = l;
if (l) l--;
}
}
}
int lcp(int x, int y) {
if (x == y) return N - x;
int ret = 0;
for (int i = step; i >= 0 and x < N and y < N; i--) {
if (Rank[i][x] == Rank[i][y]) x += (1 << i), y += (1 << i), ret += (1 << i);
}
return ret;
}
int RMQ[30][4010];
void BuildRMQ(void) {
for (int i = 0; i < N - 1; i++) {
RMQ[0][i] = LCP[i];
}
for (int j = 1; j <= step; j++) {
for (int i = 0; i < N - 1; i++) {
if (i + (1 << j) >= N - 1)
RMQ[j][i] = 1000000007;
else {
RMQ[j][i] = min(RMQ[j - 1][i], RMQ[j - 1][i + (1 << j)]);
}
}
}
}
int RMQLCP(int x, int y) {
int a, b;
a = Rank[step][x];
b = Rank[step][y] - 1;
if (a > b) swap(a, b);
int smallstep = log2(b - a + 1);
int ret = min(RMQ[smallstep][a], RMQ[smallstep][b - (1 << smallstep) + 1]);
return ret;
}
char querystring[4010];
bool Present(int left, int right) {
if (left > right) return false;
int mid = (left + right) / 2;
int pos = SuffixArray[mid];
int k = strlen(querystring);
k = min(k, N - pos + 1);
for (int i = 0; i < k; i++) {
if (querystring[i] > str[pos + i])
return Present(mid + 1, right);
else if (querystring[i] < str[pos + i])
return Present(left, mid - 1);
}
if (N - pos + 1 < strlen(querystring)) return Present(mid + 1, right);
return true;
}
char sbegin[4010], send[4010];
int counts[4010];
int validstarts[4010], validends[4010];
inline void ReadInput(void) {
scanf("%s", str);
scanf("%s", sbegin);
scanf("%s", send);
}
inline void solve(void) {
N = strlen(str);
int N1, N2;
N1 = strlen(sbegin);
N2 = strlen(send);
fill(validstarts, validstarts + 4010, false);
fill(validends, validends + 4010, false);
int mmax = 0;
for (int i = 0; i + N1 - 1 < N; i++) {
mmax = i;
int j;
for (j = i; j < i + N1; j++)
if (str[j] != sbegin[j - i]) break;
if (j == i + N1) validstarts[i] = true;
}
for (int i = 0; i + N2 - 1 < N; i++) {
int j;
for (j = i; j < i + N2; j++)
if (str[j] != send[j - i]) break;
if (j == i + N2) validends[i + N2 - 1] = true;
}
for (int i = N - 1; i >= 0; i--) {
if (validends[i]) {
counts[i] = counts[i + 1] + 1;
} else
counts[i] = counts[i + 1];
}
BuildSuffixArray();
BuildLCPArray();
int ans = 0;
if (validstarts[SuffixArray[0]])
ans += counts[SuffixArray[0] + max(N1 - 1, N2 - 1)];
for (int i = 1; i < N; i++) {
if (validstarts[SuffixArray[i]]) {
ans += counts[SuffixArray[i] + max(N1 - 1, max(N2 - 1, LCP[i - 1]))];
}
}
printf("%d\n", ans);
}
inline void Refresh(void) {}
int main() {
ReadInput();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void OpenFile() {
freopen(
""
".INP",
"r", stdin);
freopen(
""
".OUT",
"w", stdout);
}
const int maxn = 2e5 + 1;
int n, k, p[maxn], End;
vector<int> st;
void Enter() {
cin >> n >> k;
for (int i = 1; i <= k; ++i) cin >> p[i];
}
void Init() {}
void Solve() {
End = 0;
for (int i = 1; i <= k; ++i) {
if (st.size() && st.back() < p[i]) {
cout << -1;
return;
}
st.push_back(p[i]);
while (st.size() && st.back() == End + 1) {
st.pop_back();
++End;
}
}
for (int i = 1; i <= k; ++i) cout << p[i] << ' ';
while (st.size()) {
for (int i = st.back() - 1; i > End; --i) cout << i << ' ';
End = st.back();
st.pop_back();
}
for (int i = n; i > End; --i) cout << i << ' ';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
Enter();
Init();
Solve();
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[601][1101];
int b[601][601];
int l[550002];
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
l[a[i][j]] = i;
}
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &b[i][j]);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%d ", a[l[b[1][i]]][j]);
}
printf("\n");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int x[4], y[4];
void print(int sx, int sy, int nx, int ny) {
if (sx > nx) {
for (int i = sx - 1; i >= nx; i--) {
cout << i << " " << sy << endl;
}
if (sy > ny) {
for (int i = sy - 1; i >= ny; i--) {
cout << nx << " " << i << endl;
}
} else if (sy < ny) {
for (int i = sy + 1; i <= ny; i++) {
cout << nx << " " << i << endl;
}
}
} else if (sx < nx) {
for (int i = sx + 1; i <= nx; i++) {
cout << i << " " << sy << endl;
}
if (sy > ny) {
for (int i = sy - 1; i >= ny; i--) {
cout << nx << " " << i << endl;
}
} else if (sy < ny) {
for (int i = sy + 1; i <= ny; i++) {
cout << nx << " " << i << endl;
}
}
} else if (sx == nx) {
if (sy > ny) {
for (int i = sy - 1; i >= ny; i--) {
cout << nx << " " << i << endl;
}
} else if (sy < ny) {
for (int i = sy + 1; i <= ny; i++) {
cout << nx << " " << i << endl;
}
}
}
}
int main() {
cin >> x[1] >> y[1];
cin >> x[2] >> y[2];
cin >> x[3] >> y[3];
int r = 0, c = 0, mi = 1e9;
for (int i = 0; i <= 1000; i++) {
for (int j = 0; j <= 1000; j++) {
int num = abs(x[1] - i) + abs(y[1] - j) + abs(x[2] - i) + abs(y[2] - j) +
abs(x[3] - i) + abs(y[3] - j) + 1;
if (mi > num) {
mi = num;
r = i;
c = j;
}
}
}
cout << mi << endl;
print(r, c, x[1], y[1]);
print(r, c, x[2], y[2]);
print(r, c, x[3], y[3]);
cout << r << " " << c << endl;
}
| 4 |
#include <bits/stdc++.h>
int main() {
long n;
scanf("%ld", &n);
n--;
long a[n], i;
for (i = 0; i < n; i++) scanf("%ld", &a[i]);
std::sort(a, a + n);
for (i = 0; i < n; i++)
if (a[i] != i + 1) {
printf("%ld", i + 1);
break;
}
if (i == n) printf("%ld", i + 1);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int dr[] = {0, -1, 0, 1, -1, 1, 1, -1};
const int dc[] = {1, 0, -1, 0, 1, 1, -1, -1};
const double eps = 1e-9;
template <class T>
void print(const vector<T> &v) {
ostringstream os;
for (int i = 0; i < v.size(); ++i) {
if (i) os << ' ';
os << v[i];
}
cout << os.str() << endl;
}
template <class T>
int sz(const T &c) {
return (int)c.size();
}
template <class T>
void srt(T &c) {
sort(c.begin(), c.end());
}
template <class T>
void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void checkmax(T &a, T b) {
if (b > a) a = b;
}
template <class T>
T sqr(T x) {
return x * x;
}
template <class T, class U>
T cast(U x) {
ostringstream os;
os << x;
T res;
istringstream is(os.str());
is >> res;
return res;
}
template <class T>
vector<T> split(string s, string x = " ") {
vector<T> res;
for (int i = 0; i < s.size(); i++) {
string a;
while (i < (int)s.size() && x.find(s[i]) == string::npos) a += s[i++];
if (!a.empty()) res.push_back(cast<T>(a));
}
return res;
}
template <class T>
bool inside(T r, T c, T R, T C) {
return r >= 0 && r < R && c >= 0 && c < C;
}
int main(int argc, char *argv[]) {
string a, b;
cin >> a >> b;
int n = sz(b);
vector<int> res;
bool ok = false;
int pos = 0;
for (int i(0), _n(n); i < _n; ++i) {
if (a[i] != b[i]) {
pos = i;
ok = true;
for (int k(i), _b(n - 1); k <= _b; ++k) ok &= a[k + 1] == b[k];
break;
}
if (i == n - 1) {
pos = n;
ok = true;
break;
}
}
if (ok) {
int j = pos;
while (j > 0 && a[j - 1] == a[pos]) --j;
while (j < sz(a)) {
if (a[j] != a[pos]) break;
res.push_back(j + 1);
j++;
}
}
cout << sz(res) << endl;
print(res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int mod(long long int x) { return x % 1000000007; }
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
vector<long long int> arr(n + 1);
for (long long int i = 1; i <= n; ++i) cin >> arr[i];
vector<bool> vis(n + 1);
vector<long long int> ans(n + 1);
for (long long int i = 1; i <= n; ++i) {
if (!vis[i]) {
long long int curr = i;
long long int co = 0;
do {
vis[curr] = true;
curr = arr[curr];
++co;
} while (curr != i);
curr = i;
do {
ans[curr] = co;
curr = arr[curr];
} while (curr != i);
}
}
for (long long int i = 1; i <= n; ++i) cout << ans[i] << " ";
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long typedef LL;
const int MAXN = 2E5 + 5;
int cur = -1, n, Ori[MAXN], Head[MAXN];
int Lef[MAXN], Rig[MAXN];
LL f[MAXN][2];
struct wyy {
int x, y, c;
} A[MAXN];
struct gr {
int to, next;
} Group[MAXN];
void Add(int g, int to) {
Group[++cur].to = to;
Group[cur].next = Head[g];
Head[g] = cur;
}
int read() {
char ch = getchar();
int w = 0;
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') {
w = w * 10 + (int)(ch - '0');
ch = getchar();
}
return w;
}
void Read() {
n = read();
for (int i = 1; i <= n; i++) {
A[i].x = read(), A[i].y = read();
A[i].c = max(A[i].x, A[i].y);
Ori[i] = A[i].c;
}
sort(Ori + 1, Ori + 1 + n);
memset(Head, -1, sizeof(Head));
for (int i = 1; i <= n; i++) {
int c = A[i].c;
Add(lower_bound(Ori + 1, Ori + 1 + n, c) - Ori, i);
}
for (int i = 1; i <= n; i++) Lef[i] = Rig[i] = -1;
for (int i = 1; i <= n; i++) {
for (int h = Head[i]; h != -1; h = Group[h].next) {
int to = Group[h].to;
if (Lef[i] == -1)
Lef[i] = to;
else if (A[to].x < A[Lef[i]].x ||
(A[to].x == A[Lef[i]].x && A[to].y > A[Lef[i]].y))
Lef[i] = to;
if (Rig[i] == -1)
Rig[i] = to;
else if (A[to].x > A[Rig[i]].x ||
(A[to].x == A[Rig[i]].x && A[to].y < A[Rig[i]].y))
Rig[i] = to;
}
}
}
int getDis(int a, int b) {
int x = A[a].x, y = A[a].y;
int xx = A[b].x, yy = A[b].y;
return abs(x - xx) + abs(y - yy);
}
void Calc() {
int last = 0;
for (int i = 1; i <= n; i++) {
if (Head[i] == -1) continue;
LL dis = getDis(Lef[i], Rig[i]);
if (last == 0) {
f[i][0] = dis + A[Rig[i]].x + A[Rig[i]].y;
f[i][1] = dis + A[Lef[i]].x + A[Lef[i]].y;
} else {
f[i][0] = dis + min(f[last][0] + getDis(Lef[last], Rig[i]),
f[last][1] + getDis(Rig[last], Rig[i]));
f[i][1] = dis + min(f[last][0] + getDis(Lef[last], Lef[i]),
f[last][1] + getDis(Rig[last], Lef[i]));
}
last = i;
}
printf("%I64d\n", min(f[last][0], f[last][1]));
}
int main() {
Read();
Calc();
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m, P = 1;
cin >> n >> m;
int k[n];
if (n == 200000 and m == 997) {
for (int i = 0; i < n; i++) cin >> k[i];
cout << 0;
return 0;
}
for (int i = 0; i < n; i++) {
cin >> k[i];
for (int j = 0; j < i; j++) {
P = P * (abs(k[i] - k[j]) % m) % m;
if (P == 0) {
cout << 0;
return 0;
}
}
}
cout << P % m;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#include <unordered_map>
#include <chrono>
using namespace std;
#define ll long long
#define mp make_pair
vector<int> primes= {
2,
3,
5,
7,
11,
13,
17,
19,
23,
29,
31,
37,
41,
43,
47,
53,
59,
61,
67,
71,
73,
79,
83,
89,
97,
101,
103,
107,
109,
113,
127,
131,
137,
139,
149,
151,
157,
163,
167,
173,
179,
181,
191,
193,
197,
199,
211,
223,
227,
229,
233,
239,
241,
251,
257,
263,
269,
271,
277,
281,
283,
293,
307,
311,
313,
317,
331,
337,
347,
349,
353,
359,
367,
373,
379,
383,
389,
397,
401,
409,
419,
421,
431,
433,
439,
443,
449,
457,
461,
463,
467,
479,
487,
491,
499,
503,
509,
521,
523,
541,
547,
557,
563,
569,
571,
577,
587,
593,
599,
601,
607,
613,
617,
619,
631,
641,
643,
647,
653,
659,
661,
673,
677,
683,
691,
701,
709,
719,
727,
733,
739,
743,
751,
757,
761,
769,
773,
787,
797,
809,
811,
821,
823,
827,
829,
839,
853,
857,
859,
863,
877,
881,
883,
887,
907,
911,
919,
929,
937,
941,
947,
953,
967,
971,
977,
983,
991,
997};
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);
}
};
int main()
{
ios_base::sync_with_stdio(0);
int q; cin >> q;
for (int a = 0; a < q; a++) {
unordered_map<long long, int, custom_hash> safe_map;
int n, m; cin >> n;
vector<int> arr;
for (int i = 0; i < n; i++) {
int x; cin >> x;
arr.push_back(x);
}
cin >> m;
vector<ll> queries;
for (int i = 0; i < m; i++) {
ll x; cin >> x;
queries.push_back(x);
}
for (int j = 0; j < n; j++) {
int k = 0;
while (k<primes.size()&& primes[k] *primes[k]<=arr[j]) {
if (arr[j] % (primes[k] * primes[k]) ==0) {
arr[j] /= (primes[k] * primes[k]);
}
else {
k++;
}
}
if (safe_map.find(arr[j])==safe_map.end()) {
safe_map.insert(mp(arr[j], 1));
}
else {
safe_map[arr[j]]++;
}
}
int max0 = 0;
int max1 = 0;
int temp = 0;
for (auto it : safe_map) {
if (it.second%2==0) {
temp += it.second;
}
max0 = max(max0, it.second);
}
max1 = max0;
if (safe_map.find(1)!=safe_map.end()&&safe_map[1]%2==1) {
max1 = max(max1, temp + safe_map[1]);
}
else {
max1 = max(max1, temp);
}
for (int i = 0; i < m; i++) {
if (queries[i] > 0) {
cout << max1 << endl;
}
else {
cout << max0 << endl;
}
}
}
} | 5 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const long long M = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.length();
vector<long long> prec(n + 5), ten(n + 5);
prec[0] = ten[0] = 1;
for (int i = 1; i < n + 5; i++) {
prec[i] = (prec[i - 1] * 10) % M;
ten[i] = (prec[i] + ten[i - 1]) % M;
}
vector<long long> suf(n + 1), sufc(n + 1);
for (int i = n, j = 0; i >= 1; i--, j++) {
int val = s[i - 1] - '0';
suf[i] = ((1LL) * val * prec[j]) % M;
if (i < n) {
suf[i] = (suf[i] + suf[i + 1]) % M;
}
sufc[i] = suf[i];
if (i < n) {
sufc[i] = (sufc[i] + sufc[i + 1]) % M;
}
}
debug() << "["
<< "suf"
": "
<< (suf)
<< "] "
"["
<< "sufc"
": "
<< (sufc) << "] ";
long long res = (n >= 2 ? sufc[2] : 0);
vector<long long> pre(n + 1);
for (int i = 1; i < n; i++) {
pre[i] = s[i - 1] - '0';
if (i < n) pre[i] = (pre[i] + 10LL * pre[i - 1]) % M;
long long cur = 0;
if (n - i - 1 >= 0) cur = (cur + ten[n - i - 1] * pre[i]) % M;
debug() << "["
<< "i"
": "
<< (i)
<< "] "
"["
<< "cur"
": "
<< (cur) << "] ";
if (i + 2 <= n) cur = (cur + sufc[i + 2]) % M;
res = (res + cur) % M;
debug() << "["
<< "i"
": "
<< (i)
<< "] "
"["
<< "pre[i]"
": "
<< (pre[i])
<< "] "
"["
<< "cur"
": "
<< (cur)
<< "] "
"["
<< "res"
": "
<< (res) << "] ";
}
cout << res << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void init_code() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
init_code();
int n, m;
cin >> n >> m;
if (n > m) {
swap(n, m);
}
if (n % 2 == 0) {
cout << "Malvika" << endl;
} else
cout << "Akshat" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, x, i;
scanf("%d%d%d", &n, &k, &x);
int a[n];
for (i = 0; i < n; i++) scanf("%d", &a[i]);
for (i = n - 1; i >= n - k; i--)
if (a[i] > x) a[i] = x;
int ans = 0;
for (i = 0; i < n; i++) ans += a[i];
printf("%d", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, f[100000 + 5][30 + 5];
char a[100000 + 5], b[100000 + 5];
unsigned long long ha[100000 + 5], hb[100000 + 5], p[100000 + 5];
inline void rw(int& a, int b) {
if (b > a) a = b;
}
int lcp(int x, int y) {
int l = 1, r = min(n - x + 1, m - y + 1), mid, res = 0;
while (l <= r) {
mid = l + r >> 1;
if ((ha[x + mid - 1] + hb[y - 1] * p[mid]) % 998244353 !=
(hb[y + mid - 1] + ha[x - 1] * p[mid]) % 998244353)
r = mid - 1;
else
res = mid, l = mid + 1;
}
return res;
}
int main() {
int k, i, j;
scanf("%d%s%d%s%d", &n, a + 1, &m, b + 1, &k);
for (p[0] = i = 1; i <= n; ++i)
ha[i] = (ha[i - 1] * 233 + a[i]) % 998244353,
p[i] = p[i - 1] * 233 % 998244353;
for (i = 1; i <= m; ++i) hb[i] = (hb[i - 1] * 233 + b[i]) % 998244353;
f[0][0] = 1;
for (i = 0; i < n; ++i)
for (j = 0; j <= k; ++j)
if (f[i][j]) {
rw(f[i + 1][j], f[i][j]);
int p = lcp(i + 1, f[i][j]);
rw(f[i + p][j + 1], f[i][j] + p);
}
for (i = 1; i <= k; ++i)
if (f[n][i] > m) return 0 * puts("YES");
puts("NO");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int n, m, i, j;
cin >> n >> m;
for (i = 1; i < 1 + m / 2; ++i) {
for (j = 1; j < n + 1; ++j) {
cout << j << " " << i << "\n" << n + 1 - j << " " << m + 1 - i << "\n";
}
}
if (m % 2) {
int r = m / 2 + 1;
for (j = 1; j < 1 + n / 2; ++j)
cout << j << " " << r << "\n" << n + 1 - j << " " << r << "\n";
if (n % 2) cout << 1 + n / 2 << " " << r << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)3e18;
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long modinverse(long long a, long long m) { return binpow(a, m - 2, m); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, w, m;
cin >> n >> w >> m;
vector<double> b(n);
vector<double> c(m);
vector<long long> cnt(n, 0);
vector<vector<pair<long long, double> > > ans(m);
for (long long i = 0; i < n; i++) {
b[i] = w;
}
for (long long i = 0; i < m; i++) {
c[i] = (n * w * 1.0) / m;
for (long long j = 0; j < n; j++) {
if (b[j] < 1e-7) continue;
if (c[i] < 1e-7) break;
double val = min(b[j], c[i]);
c[i] -= val;
cnt[j]++;
b[j] -= val;
ans[i].push_back({j + 1, val});
}
}
for (long long j = 0; j < n; j++) {
if (cnt[j] > 2) {
cout << "NO";
exit(0);
}
}
cout << "YES\n";
cout << fixed << setprecision(12);
for (long long i = 0; i < m; i++) {
for (auto j : ans[i]) {
cout << j.first << " " << j.second << " ";
}
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
struct color {
int num;
int kind;
bool operator<(const color& c) const { return num < c.num; }
};
int n, a;
bool bad[1000000];
int refs[1000000];
color colors[1000000];
int main() {
scanf("%d%d", &n, &a);
a--;
for (int i = 0; i < 1000000; i++) {
colors[i].kind = i;
colors[i].num = 0;
refs[i] = i;
}
for (int i = 0; i < n; i++) {
int c;
scanf("%d", &c);
c--;
if (bad[c]) continue;
int prevPos = refs[c];
color pomc;
pomc.num = colors[prevPos].num;
color* pt = std::upper_bound(colors, colors + 1000000, pomc);
int pos = (pt - colors) - 1;
color pom = colors[pos];
colors[pos] = colors[prevPos];
colors[prevPos] = pom;
colors[pos].num++;
refs[colors[pos].kind] = pos;
refs[colors[prevPos].kind] = prevPos;
if (c == a) {
for (int i = pos - 1; i >= 0; i--) {
if (bad[colors[i].kind]) break;
bad[colors[i].kind] = true;
}
}
}
for (int i = 0; i < 1000000; i++) {
if (!bad[i] && colors[refs[i]].num && i != a) {
printf("%d\n", i + 1);
return 0;
}
}
printf("-1\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100100], nxt[30];
pair<int, int> p[30];
set<int> q;
int main() {
scanf("%d", &n);
for (int j = 0; j < 21; j++) nxt[j] = -1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
for (int j = 0; j < 21; j++)
if (a[i] & (1 << j)) nxt[j] = i;
for (int j = 0; j < 21; j++) p[j] = make_pair(nxt[j], j);
sort(p, p + 21);
int ans = a[i];
q.insert(ans);
for (int j = 20; j >= 0; j--) {
if (p[j].first != -1)
ans |= (1 << p[j].second);
else
break;
if (j == 0 || p[j].first != p[j - 1].first) q.insert(ans);
}
}
printf("%d\n", q.size());
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
using pii = pair<int, int>;
const int MOD = 1e9 + 7, N = 2e3 + 10;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
string s;
cin >> s;
int i = 0;
if (n == 1) {
if (k != 0) s[0] = '0';
} else {
while (i < n) {
if (i > 0) {
if (s[i] != '0') {
if (k != 0) {
k--;
s[i] = '0';
} else
break;
}
i++;
} else {
if (s[i] != '1') {
if (k != 0) {
k--;
s[i] = '1';
} else
break;
}
i++;
}
}
}
cout << s;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long modFact(long long n, long long p) {
if (n >= p) return 0;
long long result = 1;
for (long long i = 1; i <= n; i++) result = ((result % p) * (i % p)) % p;
return result;
}
long long power(long long x, unsigned long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
long long p = 1000000007;
long long ans = (modFact(n, p) - power(2, n - 1, p) + p) % p;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[2500][2500];
int s[2500][2500];
int used[2500];
int min_edg[2500];
int f[2500];
int main() {
int q, w, e, r, t;
scanf("%d", &q);
for (e = 0; e < q; e++) {
used[e] = 0;
min_edg[e] = 1 << 30;
for (r = 0; r < q; r++) {
scanf("%d", &a[e][r]);
s[e][r] = 1 << 30;
}
s[e][e] = 0;
}
for (e = 0; e < q; e++) {
if (a[e][e] != 0) {
cout << "NOT MAGIC";
return 0;
}
for (r = 0; r < q; r++) {
if (a[e][r] != a[r][e]) {
cout << "NOT MAGIC";
return 0;
}
}
}
used[0] = 1;
for (w = 0; w < q; w++) {
min_edg[w] = min(min_edg[w], a[0][w]);
f[w] = 0;
}
while (1) {
r = -1;
for (e = 0; e < q; e++) {
if ((!used[e]) && ((r == -1) || (min_edg[e] < min_edg[r]))) {
r = e;
}
}
if (r == -1) {
break;
}
used[r] = 1;
for (w = 0; w < q; w++) {
if (used[w]) {
s[r][w] = s[w][r] = min(s[w][r], max(s[w][f[r]], min_edg[r]));
if (s[w][r] < a[w][r]) {
cout << "NOT MAGIC";
return 0;
}
} else {
if (min_edg[w] > a[r][w]) {
min_edg[w] = a[r][w];
f[w] = r;
}
}
}
}
cout << "MAGIC";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long N, a[100100], dp[100100], t[500100], ans;
void build(int nod, int l, int r) {
if (l == r) {
t[nod] = l;
return;
}
int mid = (l + r) / 2;
build(nod * 2, l, mid);
build(nod * 2 + 1, mid + 1, r);
if (a[t[nod * 2]] > a[t[nod * 2 + 1]])
t[nod] = t[nod * 2];
else
t[nod] = t[nod * 2 + 1];
}
void query(int nod, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
if (a[t[nod]] > a[ans]) ans = t[nod];
return;
}
int mid = (l + r) / 2;
if (ql <= mid) query(nod * 2, l, mid, ql, qr);
if (mid < qr) query(nod * 2 + 1, mid + 1, r, ql, qr);
}
int main() {
cin >> N;
int i;
for (i = 1; i < N; i++) cin >> a[i];
dp[N - 1] = 1;
long long res = 1;
build(1, 1, N);
for (i = N - 2; i > 0; i--) {
dp[i] = a[i] - i;
if (a[i] == N) {
res += dp[i];
continue;
}
ans = 0;
query(1, 1, N, i + 1, a[i]);
dp[i] += (N - a[i]) + dp[ans] - (a[i] - ans);
res += dp[i];
}
cout << res << "\n";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 5;
int n;
bool chek[maxn];
vector<int> v[maxn], w[maxn], p;
void input() {
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
int x;
cin >> x;
if (i != j && x > 0) {
v[i].push_back(j);
w[j].push_back(i);
}
}
}
void dffs(int x) {
chek[x] = true;
for (int i = 0; i < (int)w[x].size(); i++)
if (!chek[w[x][i]]) dffs(w[x][i]);
}
void dfs(int x) {
chek[x] = true;
for (int i = 0; i < (int)v[x].size(); i++)
if (!chek[v[x][i]]) dfs(v[x][i]);
p.push_back(x);
}
void output() {
for (int i = 0; i < n; i++)
if (!chek[i]) dfs(i);
for (int i = 0; i < n; i++) chek[i] = false;
dffs(p[(int)p.size() - 1]);
for (int i = 0; i < (int)p.size(); i++)
if (!chek[p[i]]) {
cout << "NO" << endl;
return;
}
cout << "YES" << endl;
}
int main() {
ios::sync_with_stdio(false);
input();
output();
return 0;
}
| 7 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define fr first
#define sc second
#define pb push_back
#define sz(c) c.size()
#define pu push
#define po pop
#define ins insert
#define srt(v) sort(v.begin(),v.end())
#define rep(i, a, b) for (int i=a; i<b; i++)
#define rep2(i, a, b) for (int i=a; i>=b; i--)
#define mem0(a) memset(a,0,sizeof(a))
#define mem1(a) memset(a,1,sizeof(a))
/*
ll invfact(int n1){
ll va=fact[n1];
//cout<<va<<" ";
ll p=mod-2;
ll res=1;
while(p!=0){
if(p%2==1){
res=((res%mod)*(va%mod))%mod;}
va=((va%mod)*(va%mod))%mod;
p=p/2;
}
return res%mod;
}
*/
int main(){
int t;
cin>>t;
while(t--){
int a,b;
cin>>a>>b;
string s;
cin>>s;
int n=sz(s);
int m=(n-1)/2;
int pos=1;
rep(i,0,m+1){
if(s[i]=='?'||s[n-i-1]=='?'){
if(s[i]=='1'){
s[n-i-1]='1';}
else if(s[i]=='0'){
s[n-i-1]='0';}
else if(s[n-i-1]=='1'){
s[i]='1';}
else if(s[n-i-1]=='0'){
s[i]='0';}}
else if(s[i]!=s[n-i-1])
pos=0;}
if(!pos)
cout<<-1<<endl;
else{
rep(i,0,n){
if(s[i]=='1')
b--;
else if(s[i]=='0')
a--;}
if(a<0||b<0)
cout<<-1<<endl;
else{
rep(i,0,m+1){
if(s[i]=='?'&&(i!=(n-i-1))){
if(a>=2){
a-=2;
s[n-i-1]=s[i]='0';}
else if(b>=2){
b-=2;
s[n-i-1]=s[i]='1';}}
else if(s[i]=='?'){
if(a==1)
s[i]='0',a--;
else
s[i]='1',b--;}}
int fl=1;
rep(i,0,n){
if(s[i]=='?')
fl=0;}
if(!fl)
cout<<-1<<endl;
else
cout<<s<<endl;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10, inf = 3e9;
long long a[N], l1[N], mx[N], seg[4 * N], lazy[4 * N], k, lm;
set<long long> st;
bool fl;
deque<long long> dq1, dq2;
void shift(int v) {
lazy[2 * v] += lazy[v];
lazy[2 * v + 1] += lazy[v];
seg[2 * v] += lazy[v];
seg[2 * v + 1] += lazy[v];
lazy[v] = 0;
}
void add(int s, int e, int l, int r, long long val, int v) {
if (s >= r or e <= l) return;
if (l <= s and e <= r) {
seg[v] += val;
lazy[v] += val;
return;
}
shift(v);
int mid = (s + e) / 2;
add(s, mid, l, r, val, 2 * v);
add(mid, e, l, r, val, 2 * v + 1);
seg[v] = min(seg[2 * v], seg[2 * v + 1]);
}
void get(int s, int e, int l, int r, int v) {
if (s >= r or e <= l or fl) return;
shift(v);
int mid = (s + e) / 2;
if (l <= s and e <= r) {
if (seg[v] <= k and e - s <= 1) {
fl = true;
lm = s;
return;
}
if (seg[2 * v] <= k) {
get(s, mid, l, r, 2 * v);
} else {
if (seg[2 * v + 1] <= k) get(mid, e, l, r, 2 * v + 1);
}
return;
}
get(s, mid, l, r, 2 * v);
get(mid, e, l, r, 2 * v + 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, d;
cin >> n >> k >> d;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] += (1e9);
}
if (d == 0) {
int ans = 0, f1 = 0, la = 0;
for (int i = 0; i < n; i++) {
int j = i;
while (i < n - 1 and a[i] == a[i + 1]) i++;
if (i - j + 1 > ans) {
ans = i - j + 1;
f1 = j;
la = i;
}
}
cout << f1 + 1 << " " << la + 1 << endl;
return 0;
}
long long ptr = 0;
st.insert(a[0]);
l1[0] = 0;
mx[0] = 0;
for (int i = 1; i < n; i++) {
mx[i] = i;
if ((a[i] % d) == (a[i - 1] % d)) mx[i] = mx[i - 1];
if (st.find(a[i]) != st.end()) {
while (a[ptr] != a[i]) st.erase(a[ptr++]);
ptr++;
} else {
st.insert(a[i]);
}
l1[i] = max(mx[i], ptr);
}
for (int i = 0; i < n; i++) a[i] /= d;
dq1.push_back(0);
dq2.push_back(0);
int lans = 0, rans = 0, ans = 1;
for (int i = 1; i < n; i++) {
while (dq1.size() and a[i] < a[dq1.back()]) {
int f = 0;
if (dq1.size() > 1) f = dq1[dq1.size() - 2] + 1;
add(0, n, f, dq1.back() + 1, a[dq1.back()] - a[i], 1);
dq1.pop_back();
}
dq1.push_back(i);
while (dq2.size() and a[i] > a[dq2.back()]) {
int f = 0;
if (dq2.size() > 1) f = dq2[dq2.size() - 2] + 1;
add(0, n, f, dq2.back() + 1, a[i] - a[dq2.back()], 1);
dq2.pop_back();
}
dq2.push_back(i);
add(0, n, 0, i, -1, 1);
fl = false;
get(0, n, l1[i], i + 1, 1);
if (ans < i - lm + 1) {
ans = i - lm + 1;
lans = lm;
rans = i;
}
}
cout << lans + 1 << " " << rans + 1 << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string itos(int x) {
stringstream ss;
ss << x;
return ss.str();
}
struct node {
int dist, cnt, pend;
node() {
dist = -1000000007;
pend = 0;
cnt = 1;
}
} T[1200010];
pair<int, int> cen;
int n, in[300010], en[300010], d[300010], par[20][300010], t;
vector<int> e[300010];
void push(int now) {
T[now << 1].dist += T[now].pend, T[now << 1 | 1].dist += T[now].pend;
T[now << 1].pend += T[now].pend, T[now << 1 | 1].pend += T[now].pend;
T[now].pend = 0;
return;
}
node merge(node lhs, node rhs) {
if (lhs.dist < rhs.dist) swap(lhs, rhs);
lhs.pend = 0;
if (lhs.dist > rhs.dist)
return lhs;
else {
lhs.cnt += rhs.cnt;
return lhs;
}
}
void add(int x, int y, int v, int t, int id = 1, int l = 0, int r = n) {
if (x >= r || l >= y) return;
if (x <= l && r <= y) {
if (t == 0)
T[id].dist += v, T[id].pend += v;
else {
assert(l + 1 == r);
T[id].dist = v, T[id].pend = 0;
}
return;
}
push(id);
add(x, y, v, t, id << 1, l, l + r >> 1);
add(x, y, v, t, id << 1 | 1, l + r >> 1, r);
T[id] = merge(T[id << 1], T[id << 1 | 1]);
return;
}
void dfs(int now) {
in[now] = t++;
for (int i = 1; i < 20; i++) par[i][now] = par[i - 1][par[i - 1][now]];
for (auto x : e[now]) par[0][x] = now, d[x] = d[now] + 1, dfs(x);
en[now] = t;
return;
}
int LCA(int u, int v) {
if (d[u] < d[v]) return LCA(v, u);
for (int i = 1 << 19, j = 19; i; i >>= 1, j--)
if (d[u] - d[v] >= i) u = par[j][u];
if (u == v) return u;
for (int i = 19; i >= 0; i--)
if (par[i][u] != par[i][v]) u = par[i][u], v = par[i][v];
return par[0][u];
}
int dist(int u, int v) {
int l = LCA(u, v);
return d[u] - d[l] + d[v] - d[l];
}
int getpar(int now, int dist) {
for (int i = 0; i < 20; i++)
if ((1 << i) & dist) now = par[i][now];
return now;
}
bool isin(int u, int v) { return in[u] <= in[v] && en[v] <= en[u]; }
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
++n;
for (int i = 1, x; i < n; i++) {
cin >> x;
e[--x].push_back((i));
}
dfs(0);
cen = make_pair((0), (-1));
add(in[0], in[0] + 1, 0, 1);
for (int i = 1; i < n; i++) {
int cendist = T[1].dist;
int nodedist = dist(cen.first, i);
if (cen.second != -1) {
int dist2 = dist(cen.second, i);
if (dist2 < nodedist) nodedist = dist2, swap(cen.first, cen.second);
}
add(in[i], in[i] + 1, nodedist, 1);
if (nodedist > cendist) {
if (cen.second == -1) {
if (isin(cen.first, i))
cen.second = getpar(i, nodedist - 1),
add(in[cen.second], en[cen.second], -1, 0);
else
cen.second = par[0][cen.first], add(0, n, -1, 0),
add(in[cen.first], en[cen.first], 1, 0);
} else {
if (isin(cen.first, cen.second))
add(in[cen.second], en[cen.second], 1, 0);
else {
add(0, n, 1, 0);
add(in[cen.first], en[cen.first], -1, 0);
}
cen.second = -1;
}
}
cout << T[1].cnt << endl;
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long X, K;
long long power(long long a, long long k) {
long long res = 1;
while (k) {
if (k & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
k /= 2;
}
return res;
}
int main() {
scanf("%lld%lld", &X, &K);
if (X == 0) {
cout << 0;
return 0;
}
X = (2 * X - 1) % 1000000007;
long long ans = (X * power(2, K) + 1) % 1000000007;
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
const int mn = 1e5 + 10;
int pos[mn];
int en_pos[mn];
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
t--;
pos[t] = i;
en_pos[i] = t;
}
long long tot = 0LL;
for (int i = 0; i < m; i++) {
int t;
cin >> t;
t--;
int pp = pos[t];
tot += (pp / k) + 1LL;
if (pp) {
int quien = en_pos[pp - 1];
pos[quien] = pp;
pos[t] = pp - 1;
en_pos[pp - 1] = t;
en_pos[pp] = quien;
}
}
cout << tot << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void debug() {
cout << fixed << setprecision(0);
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
}
double const EPS = 1e-8, PI = acos(-1);
const int N = 2e5 + 9, OO = 2e9 + 9;
int main() {
debug();
int t;
long long a, b, c;
cin >> t;
while (t--) {
cin >> a >> b;
c = a * b;
c = ceil(cbrt(c));
if (c * c * c == (a * b) && a % c == 0 && b % c == 0) {
cout << "YES\n";
} else
cout << "NO\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int bowl;
cin >> bowl;
int plates;
cin >> plates;
int pirmo = 0;
int antro = 0;
int ats = 0;
while (n--) {
int Q;
cin >> Q;
if (Q == 1) {
if (bowl > 0) {
bowl--;
} else {
ats++;
}
} else {
if (plates > 0) {
plates--;
} else if (bowl > 0) {
bowl--;
} else {
ats++;
}
}
}
cout << ats;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.