solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
bitset<N> b;
int p[N];
int cnt[N];
bool was[N];
int main() {
int n, k;
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", p + i);
p[i]--;
was[i] = false;
}
for (int i = 1; i <= n; i++) {
cnt[i] = 0;
}
int c1 = 0, c2 = 0;
for (int i = 0; i < n; i++) {
if (was[i]) {
continue;
}
int x = i;
int len = 0;
while (!was[x]) {
was[x] = true;
x = p[x];
len++;
}
c1 += len % 2;
c2 += len / 2;
cnt[len]++;
}
b.set(n);
for (int i = 1; i <= n; i++) {
if (cnt[i] == 0) {
continue;
}
for (int j = 0; (1 << j) <= cnt[i]; j++) {
int x = i * (1 << j);
b |= (b >> x);
cnt[i] -= (1 << j);
}
b |= (b >> (i * cnt[i]));
}
int ans_min = k;
if (!b.test(n - k)) {
ans_min++;
}
int ans_max = 0;
ans_max += 2 * min(k, c2);
k -= min(k, c2);
ans_max += min(k, c1);
printf("%d %d\n", ans_min, ans_max);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[9];
int b[9];
int k;
inline bool verify() {
memset(b, 0, sizeof(b));
for (int i = (1); i < (k + 1); i++)
if (!b[i]) {
int j = i;
while (1) {
b[j] = i;
j = a[j];
if (j == 1 || b[j]) break;
}
if (j != 1 && b[j] == i) return false;
}
return true;
}
int rec(int i) {
if (i > k) {
if (verify()) return 1;
return 0;
}
int ret = 0;
for (int j = (1); j < (k + 1); j++) {
if (i == j && i != 1) continue;
a[i] = j;
ret += rec(i + 1);
}
return ret;
}
int main() {
int n;
cin >> n >> k;
memset(a, 0, sizeof(a));
long long prev = rec(1);
for (int i = 0; i < (n - k); i++) prev = (prev * (n - k)) % 1000000007;
cout << prev;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long infinity = 1000000000000000000;
const int inf = 1e9 + 5;
bool do_debug = false;
struct FlowEdge {
int u, v;
long long cap, flow = 0;
FlowEdge(int u, int v, long long cap) : u(u), v(v), cap(cap) {}
};
struct Dinic {
const long long flow_inf = 1e18;
vector<FlowEdge> edges;
vector<vector<int>> adj;
int n, m = 0;
int s, t;
vector<int> level, ptr;
queue<int> q;
Dinic(int n, int s, int t) : n(n), s(s), t(t) {
adj.clear();
adj.resize(n + 5);
level.clear();
level.resize(n + 5);
ptr.clear();
ptr.resize(n + 5);
}
void add_edge(int u, int v, long long cap) {
edges.emplace_back(u, v, cap);
edges.emplace_back(v, u, 0);
adj[u].push_back(m);
adj[v].push_back(m + 1);
m += 2;
}
bool bfs() {
while (!q.empty()) {
int u = q.front();
q.pop();
for (int id : adj[u]) {
if (edges[id].cap - edges[id].flow < 1) continue;
if (level[edges[id].v] != -1) continue;
level[edges[id].v] = level[u] + 1;
q.push(edges[id].v);
}
}
return level[t] != -1;
}
long long dfs(int u, long long pushed) {
if (pushed == 0) return 0;
if (u == t) return pushed;
for (int& cid = ptr[u]; cid < (int)adj[u].size(); cid++) {
int id = adj[u][cid];
int v = edges[id].v;
if (level[u] + 1 != level[v] || edges[id].cap - edges[id].flow < 1)
continue;
long long tr = dfs(v, min(pushed, edges[id].cap - edges[id].flow));
if (tr == 0) continue;
edges[id].flow += tr;
edges[id ^ 1].flow -= tr;
return tr;
}
return 0;
}
long long flow() {
long long f = 0;
while (true) {
fill(level.begin(), level.end(), -1);
level[s] = 0;
q.push(s);
if (!bfs()) break;
fill(ptr.begin(), ptr.end(), 0);
while (long long pushed = dfs(s, flow_inf)) {
f += pushed;
}
}
return f;
}
};
void solve() {
int n, m;
cin >> n >> m;
vector<array<int, 3>> e;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
e.push_back({w, u, v});
}
sort(e.begin(), e.end());
int l = 0, r = m - 1;
int opt = m + 1;
while (l <= r) {
int mid = ((r - l) >> 1) + l;
int src = 0, snk = 2 * n + 1;
Dinic d(2 * n + 5, src, snk);
for (int i = 0; i < mid + 1; i++) {
d.add_edge(e[i][1], n + e[i][2], 1);
}
for (int i = 1; i < n + 1; i++) {
d.add_edge(src, i, 1);
d.add_edge(n + i, snk, 1);
}
int f = d.flow();
if (f == n) {
opt = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
if (opt >= m) {
cout << -1;
} else {
cout << e[opt][0];
}
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q = 1;
while (q-- > 0) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int l = 1, temp = 0;
char s[maxn];
int q[maxn] = {0};
int h[maxn] = {0};
map<string, int> st;
map<string, int> zhao1;
map<string, int> yuan1;
class Student {
private:
string name;
string id;
string school;
string mima;
int grade;
string number;
public:
Student(string _name, string _id, string _school, int _grade, string _number,
string _mima) {
name = _name;
id = _id;
school = _school;
grade = _grade;
number = _number;
mima = _mima;
}
~Student(){};
string showna() { return name; }
string showid() { return id; }
string showsc() { return school; }
int showgr() { return grade; }
string shownu() { return number; }
string showmi() { return mima; }
};
const int MAXN = 2e5 + 10;
int num[MAXN];
int hh, n;
int t;
int id;
void solve() {
cin >> t;
while (t--) {
cin >> hh >> n;
if (l) temp++;
int t = 1;
if (l) temp++;
for (int i = n; i >= 1; --i) {
cin >> num[i];
}
if (l) temp++;
int k = n;
if (l) temp++;
if (hh == num[n]) k = n - 1;
if (l) temp++;
int res = 0;
if (l) temp++;
while (hh != 0) {
id = lower_bound(num + 1, num + 1 + k, hh) - num;
--id;
if (id <= 0) break;
hh = num[id] + 1;
if (num[id] != num[id - 1] + 1) ++res;
hh = num[id] - 1;
}
if (l) temp++;
cout << res << endl;
}
}
void solv() {
if (l) temp++;
int n;
cin >> n;
if (l) temp++;
scanf("%s", s + 1);
if (l) temp++;
long long sum = 0;
if (l) temp++;
for (int i = 1; i <= n; i++) {
q[i] = 1;
h[i] = 1;
}
if (l) temp++;
for (int i = 1; i <= n; i++) {
if (s[i] == s[i - 1]) {
q[i] = q[i - 1] + 1;
}
}
if (l) temp++;
for (int i = n; i >= 1; i--) {
if (s[i] == s[i + 1]) {
h[i] = h[i + 1] + 1;
}
}
if (l) temp++;
for (int i = 1; i <= n - 1; i++) sum = sum + i;
if (l) temp++;
for (int i = 1; i < n; i++) {
if (s[i] != s[i + 1]) {
sum = sum - h[i + 1];
}
}
if (l) temp++;
for (int i = 2; i <= n; i++) {
if (s[i] != s[i - 1]) {
sum = sum - q[i - 1];
}
}
for (int i = 1; i < n; i++) {
if (s[i] != s[i + 1]) {
sum = sum + 1;
}
}
if (l) temp++;
cout << sum << endl;
if (l) temp++;
}
int main() {
if (l) temp++;
solve();
if (l) temp++;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 2139063143;
const int N = 1010000;
const double eps = 1e-7;
template <typename T>
inline void sc(T &x) {
x = 0;
static int p;
p = 1;
static char c;
c = getchar();
while (!isdigit(c)) {
if (c == '-') p = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c - 48);
c = getchar();
}
x *= p;
}
template <typename T>
inline void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) print(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void pr(T x) {
print(x), putchar('\n');
}
template <typename T1, typename T2>
void chkmax(T1 &A, T2 B) {
A = A >= B ? A : B;
}
template <typename T1, typename T2>
void chkmin(T1 &A, T2 B) {
A = A <= B ? A : B;
}
long long k;
int P, n, m, s[N], ss[N];
int del(int x) { return x >= P ? x - P : x; }
void add(int &x, int y) { x = del(x + y); }
struct mat {
int x[2][2];
};
void init(mat &A) { memset(A.x, 0, sizeof(A.x)); }
mat operator*(mat A, mat B) {
mat C;
init(C);
for (int i = 0; i <= 1; i++)
for (int j = 0; j <= 1; j++)
for (int k = 0; k <= 1; k++)
add(C.x[i][j], (long long)A.x[i][k] * B.x[k][j] % P);
return C;
}
mat ksm(mat a, long long b) {
mat ans;
init(ans);
ans.x[0][0] = ans.x[1][1] = 1;
while (b) {
if (b & 1) ans = ans * a;
a = a * a, b >>= 1;
}
return ans;
}
struct TREE {
mat w;
} t[N << 2];
void build(int p, int l, int r) {
if (l == r)
return t[p].w.x[0][0] = 0, t[p].w.x[1][0] = 1,
t[p].w.x[0][1] = l ? s[l - 1] : s[n - 1], t[p].w.x[1][1] = s[l],
void();
int mid = (l + r) >> 1, ls = p << 1, rs = ls | 1;
build(ls, l, mid), build(rs, mid + 1, r);
t[p].w = t[ls].w * t[rs].w;
}
void change(int p, int l, int r, int w) {
if (l == r)
return t[p].w.x[0][0] = 0, t[p].w.x[1][0] = 1,
t[p].w.x[0][1] = l ? s[l - 1] : s[n - 1], t[p].w.x[1][1] = s[l],
void();
int mid = (l + r) >> 1, ls = p << 1, rs = ls | 1;
(w <= mid) ? change(ls, l, mid, w) : change(rs, mid + 1, r, w);
t[p].w = t[ls].w * t[rs].w;
}
mat query(int p, int l, int r, int L, int R) {
if (L <= l && r <= R) return t[p].w;
mat ans;
init(ans);
ans.x[0][0] = ans.x[1][1] = 1;
if (R < L) return ans;
int mid = (l + r) >> 1, ls = p << 1, rs = ls | 1;
if (L <= mid) ans = query(ls, l, mid, L, R);
if (R > mid) ans = ans * query(rs, mid + 1, r, L, R);
return ans;
}
struct LY {
long long id, w;
int x;
bool fg;
} a[N];
long long up(long long x, long long y) { return x / y + (x % y > 0); }
int main() {
sc(k), sc(P);
if (k <= 1) return pr(k % P), 0;
sc(n);
for (int i = 0; i < n; i++) sc(s[i]), ss[i] = (s[i] %= P);
build(1, 0, n - 1);
sc(m);
int mm = m;
m = 0;
for (int i = 1; i <= mm; i++) {
++m;
sc(a[m].w), sc(a[m].x);
a[m].x %= P;
if (a[m].w > k) {
--m;
continue;
}
long long pos = up(a[m].w + 1, n);
a[m].id = pos, a[m].w %= n;
if (a[m].w == n - 1) ++m, a[m] = a[m - 1], a[m].fg = 1, ++a[m].id;
}
sort(a + 1, a + m + 1,
[](LY A, LY B) { return A.id != B.id ? A.id < B.id : A.w < B.w; });
long long las = 1, ID = up(k, n);
mat ans;
init(ans);
ans.x[0][1] = 1;
if (k <= n) return pr((ans * query(1, 0, n - 1, 1, k - 1)).x[0][1]), 0;
ans = ans * query(1, 0, n - 1, 1, n - 1), las = 1;
a[m + 1].id = 1e18;
for (int i = 1; i <= m + 1; i++) {
if (a[i].id > ID)
return pr((ans * ksm(t[1].w, ID - las - 1) *
query(1, 0, n - 1, 0, (k - 1) % n))
.x[0][1]),
0;
ans = ans * ksm(t[1].w, a[i].id - 1 - las);
int nx = i;
while (a[nx].id == a[i].id) {
s[a[nx].w] = a[nx].x;
if (a[nx].w == n - 1) {
if (a[nx].fg)
change(1, 0, n - 1, 0);
else
change(1, 0, n - 1, n - 1);
} else
change(1, 0, n - 1, a[nx].w), change(1, 0, n - 1, (a[nx].w + 1) % n);
++nx;
}
if (a[i].id == ID)
return pr((ans * query(1, 0, n - 1, 0, (k - 1) % n)).x[0][1]), 0;
ans = ans * t[1].w;
nx = i;
while (a[nx].id == a[i].id)
s[a[nx].w] = ss[a[nx].w], change(1, 0, n - 1, a[nx].w),
change(1, 0, n - 1, (a[nx].w + 1) % n), ++nx;
i = nx - 1, las = a[i].id;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 10;
const long long MOD = 1e9 + 9;
inline long long in() {
long long x = 0, flag = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + (ch ^ 48), ch = getchar();
return x * flag;
}
int n, m;
long long a[MAXN], fib[MAXN];
long long F(int n, long long a1, long long a2) {
return n == 1 ? a1 : (a1 * fib[n - 2] % MOD + a2 * fib[n - 1] % MOD) % MOD;
}
long long Sum(int n, long long a1, long long a2) {
return (a1 * fib[n] % MOD + a2 * (fib[n + 1] - 1) % MOD) % MOD;
}
struct Segt {
int l, r;
long long sum, t1, t2;
} t[MAXN << 2];
void build(int now, int l, int r) {
t[now].l = l, t[now].r = r;
if (l == r) return (void)(t[now].sum = a[l]);
int mid = (l + r) >> 1;
build(now << 1, l, mid);
build(now << 1 | 1, mid + 1, r);
t[now].sum = (t[now << 1].sum + t[now << 1 | 1].sum) % MOD;
}
void addtag(int now, long long a1, long long a2) {
(t[now].sum += Sum((t[now].r - t[now].l + 1), a1, a2)) %= MOD;
(t[now].t1 += a1) %= MOD;
(t[now].t2 += a2) %= MOD;
}
void pushdown(int now) {
addtag(now << 1, t[now].t1, t[now].t2);
addtag(now << 1 | 1,
F(t[now << 1 | 1].l - t[now << 1].l + 1, t[now].t1, t[now].t2),
F(t[now << 1 | 1].l - t[now << 1].l + 2, t[now].t1, t[now].t2));
t[now].t1 = t[now].t2 = 0;
}
void update(int now, int l, int r) {
if (t[now].r < l || r < t[now].l) return;
if (l <= t[now].l && t[now].r <= r)
return (void)(addtag(now, fib[t[now].l - l + 1], fib[t[now].l - l + 2]));
pushdown(now);
update(now << 1, l, r);
update(now << 1 | 1, l, r);
t[now].sum = (t[now << 1].sum + t[now << 1 | 1].sum) % MOD;
}
long long query(int now, int l, int r) {
if (t[now].r < l || r < t[now].l) return 0;
if (l <= t[now].l && t[now].r <= r) return t[now].sum;
pushdown(now);
return (query(now << 1, l, r) + query(now << 1 | 1, l, r)) % MOD;
}
void check() {
for (int i = 1; i <= n; i++) printf("%lld ", query(1, i, i));
printf("\n");
}
int main() {
n = in();
m = in();
fib[1] = fib[2] = 1;
for (int i = 3; i <= 300001; i++) fib[i] = (fib[i - 2] + fib[i - 1]) % MOD;
for (int i = 1; i <= n; i++) a[i] = in() % MOD;
build(1, 1, n);
for (int i = 1; i <= m; i++) {
int opt = in(), l = in(), r = in();
if (opt == 1)
update(1, l, r);
else
printf("%lld\n", query(1, l, r));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
using namespace std;
namespace _c {
const double pi = acos(-1.0);
const int MIN_INT8 = -128;
const int MIN_INT16 = -32768;
const int MIN_INT = -2147483647 - 1;
const long long MIN_LL = -9223372036854775807LL - 1;
const int MAX_INT8 = 127;
const int MAX_INT16 = 32767;
const int MAX_INT = 2147483647;
const long long MAX_LL = 9223372036854775807LL;
} // namespace _c
namespace _f {
template <typename T>
inline const T gcd(T m, T n) {
while (n != 0) {
T t = m % n;
m = n;
n = t;
}
return m;
}
template <typename T>
inline const T max(const T &a, const T &b) {
return a > b ? a : b;
}
template <typename T>
inline const T min(const T &a, const T &b) {
return a < b ? a : b;
}
template <typename T>
inline const T abs(const T &a) {
return a > 0 ? a : -a;
}
} // namespace _f
namespace io {
template <typename T>
inline void read(T &t) {
register T res = 0, neg = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) {
if (c == '-') {
neg = -1;
}
}
for (; isdigit(c); c = getchar()) {
res = res * 10 + c - '0';
}
t = res * neg;
}
inline int in() {
register int T;
read(T);
return T;
}
inline long long in_ll() {
register long long T;
read(T);
return T;
}
} // namespace io
int win(long long a, long long b) {
if (!a || !b) {
return 0;
}
if (!win(b % a, a)) {
return 1;
}
if ((b / a % (a + 1)) & 1) {
return 0;
} else {
return 1;
}
}
int main() {
int t = io::in();
while (t--) {
long long a, b;
io::read(a), io::read(b);
if (win(_f::min(a, b), _f::max(a, b))) {
puts("First");
} else {
puts("Second");
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
char let[10];
int ind;
int res[30] = {0};
cin >> s;
for (int i = 0; i < s.size(); ++i) {
if (s[i] != '!') {
if (i % 4 == 0)
ind = 4;
else
ind = i % 4;
let[ind] = s[i];
}
}
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '!') {
if (i % 4 == 0)
ind = 4;
else
ind = i % 4;
res[let[ind] - 'A']++;
}
}
cout << res['R' - 'A'] << " " << res['B' - 'A'] << " " << res['Y' - 'A']
<< " " << res['G' - 'A'] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void f() {
int m = 0;
for (int i = 1; i < 1000; ++i) {
int s = 1;
int a = i;
while (a > 0) {
s *= a % 10;
a /= 10;
}
if (s > m) {
m = s;
cout << i << ' ' << m << '\n';
}
}
}
uint64_t sol(string n) {
uint64_t p = 1;
for (size_t i = 0; i < n.length(); ++i) p *= n[i] - '0';
if (n[0] == '1') {
uint64_t p1 = 1;
for (size_t i = 1; i < n.length(); ++i) p1 *= 9;
if (p1 > p) p = p1;
}
for (size_t i = 0; i < n.length(); ++i) {
if (n[i] == '0') continue;
uint64_t p1 = 1;
for (size_t j = 0; j < i; ++j) p1 *= n[j] - '0';
uint64_t p2 = n[i] - '0' - 1;
uint64_t p3 = 1;
for (size_t j = i + 1; j < n.length(); ++j) p3 *= 9;
if (p1 * p2 * p3 > p) {
p = p1 * p2 * p3;
}
}
return p;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
string n;
cin >> n;
cout << sol(n) << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template <typename T1, typename T2>
inline void chkmin(T1 &x, const T2 &y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void chkmax(T1 &x, const T2 &y) {
if (x < y) x = y;
}
mt19937 rnd(228);
map<pair<int, int>, int> mem;
int Q = 2048 * 2 + 170;
int query(int a, int b) {
if (a > b) swap(a, b);
if (mem.count({a, b})) return mem[{a, b}];
Q--;
assert(Q >= 0);
cout << "? " << a + 1 << " " << b + 1 << endl;
int ans;
cin >> ans;
mem[{a, b}] = ans;
return ans;
}
void outAns(vector<int> ans) {
cout << "! ";
for (auto i : ans) {
cout << i << " ";
}
cout << endl;
exit(0);
}
int getBit(int x) { return __builtin_popcount(x); }
int findZero(int pos, vector<int> have) {
int val = 1e9;
vector<int> nhave = {};
vector<int> check;
for (int i = 0; i < (int)have.size(); i++) {
if (have[i] == pos) continue;
if (getBit(query(have[i], pos)) == 1) {
check.push_back(query(have[i], pos));
}
if (query(have[i], pos) > val) continue;
if (query(have[i], pos) < val) val = query(have[i], pos), nhave = {};
nhave.push_back(have[i]);
}
sort(check.begin(), check.end());
check.resize(unique(check.begin(), check.end()) - check.begin());
if (check.size() > 1) return pos;
if (nhave.size() == 1) return nhave[0];
return findZero(nhave[rnd() % (int)nhave.size()], nhave);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int val = 1e9, posNow = 0;
for (int i = 0; i < Q - 2 * n; i++) {
int a = rnd() % n;
int b = rnd() % n;
if (a == b) {
i--;
continue;
}
if (getBit(query(a, b)) < val) {
val = getBit(query(a, b));
posNow = a;
}
}
vector<int> have(n);
iota(have.begin(), have.end(), 0);
int zero = findZero(posNow, have);
vector<int> ans(n);
for (int i = 0; i < n; i++) {
if (i == zero) continue;
ans[i] = query(i, zero);
}
outAns(ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long v[n], d[n], p[n];
vector<long long> ra;
for (int i = 0; i < n; i++) {
cin >> v[i] >> d[i] >> p[i];
ra.push_back(i + 1);
}
long long i = 0;
vector<long long> ans;
while (ra.size() != 0) {
long long val = ra.front();
ra.erase(ra.begin());
ans.push_back(val);
long long j = 0, k = 0;
long long ini = 0;
while (j < ra.size()) {
if (v[val - 1]) {
p[ra[j] - 1] -= ini + v[val - 1];
v[val - 1] -= 1;
} else {
p[ra[j] - 1] -= ini;
}
if (p[ra[j] - 1] < 0) {
ini += d[ra[j] - 1];
ra.erase(ra.begin() + j);
j--;
}
j++;
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) cout << ans[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long npow(long long n, long long k, long long mod) {
long long res = 1;
while (k) {
if (k & 1) {
res *= n;
res %= mod;
}
n *= n;
n %= mod;
k >>= 1;
}
return res;
}
int main() {
long long n, k;
cin >> n >> k;
long long temp, a, b, c, d;
long long mod = 1000000007;
long long p = 2;
long long x;
int dp[10007][51];
long long res = 1;
long long no = n;
while (1) {
if (n < 2) break;
if (p * p > n) {
p = n;
}
if (n % p == 0) {
x = 0;
while (n % p == 0) {
n /= p;
x++;
}
dp[0][0] = 1;
if (k == 0) {
res *= npow(p, x, mod);
} else {
for (long long i = 0; i <= k; i++) {
for (long long j = 0; j <= x; j++) {
if (i == 0 && j == 0)
dp[i][j] = 1;
else if (i == 0) {
a = dp[i][j - 1];
temp = (a * p) % mod;
dp[i][j] = temp;
} else {
dp[i][j] = 0;
if (j == 0) {
dp[i][j] = 1;
} else {
a = dp[i][j - 1];
b = dp[i - 1][j];
a *= (j);
a %= mod;
temp = a + b;
temp %= mod;
dp[i][j] = temp;
}
temp = dp[i][j];
temp *= npow(j + 1, mod - 2, mod);
temp %= mod;
dp[i][j] = temp;
}
}
}
temp = dp[k][x];
res *= temp;
res %= mod;
}
}
if (p & 1)
p += 2;
else
p++;
}
res %= mod;
cout << res;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename T1>
T amax(T &a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T &a, T1 b) {
if (b < a) a = b;
return a;
}
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
const long long mod = 1e9 + 7;
const long long INF = 1e18;
long long sum(long long a, long long b) {
long long res = (a + b) % mod;
if (res < 0) res += mod;
return res;
}
long long mult(long long a, long long b) {
long long res = a * b % mod;
if (res < 0) res += mod;
return res;
}
void test_case() {
long long n, q;
cin >> n >> q;
const int maxb = 21;
vector<vector<long long> > dp(n, vector<long long>(maxb, n + 2));
vector<long long> v(n);
for (long long i = (0); i <= (n - 1); i++) cin >> v[i];
vector<long long> bit(maxb, n + 2);
for (long long i = (n - 1); i >= (0); i--) {
for (long long j = (0); j <= (maxb - 1); j++) {
if (v[i] & (1 << j)) {
if (bit[j] != n + 2) {
for (long long k = (0); k <= (maxb - 1); k++)
amin(dp[i][k], dp[bit[j]][k]);
}
bit[j] = dp[i][j] = i;
}
}
}
while (q--) {
int x, y;
cin >> x >> y;
x--;
y--;
bool ans = false;
for (long long i = (0); i <= (maxb - 1); i++)
if ((dp[x][i] <= y) && (v[y] & (1ll << i))) {
ans = true;
break;
}
if (ans)
cout << "Shi"
<< "\n";
else
cout << "Fou"
<< "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t = 1;
while (t--) {
test_case();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r, cx, cy, x, y;
cin >> r >> cx >> cy >> x >> y;
long long int ans = pow((cx - x), 2) + pow((cy - y), 2);
long double res = sqrt(ans);
cout << ceil(res / (float)(2 * r)) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long A[100005] = {0};
long long C[1000005] = {0};
int main() {
long long n, x, i, y, ans = 0;
cin >> n >> x;
for (int i = 1; i <= n; i++) {
cin >> A[i];
C[A[i]]++;
}
for (int i = 1; i <= n; i++) {
y = A[i] ^ x;
if (y == A[i]) {
ans += C[y] - 1;
} else
ans += C[y];
}
cout << ans / 2 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 888;
vector<int> G[2][maxn];
int val[2][1111][1111];
int l[maxn], r[maxn];
int siz[maxn];
void dfs(int s, int fa, int id) {
if (s != 1)
siz[s] = 1;
else
siz[s] = 0;
for (int d : G[id][s]) {
if (d == fa) continue;
dfs(d, s, id);
siz[s] += siz[d];
l[s] = min(l[s], l[d]);
r[s] = max(r[s], r[d]);
}
val[id][l[s]][r[s]] = siz[s];
}
int dp[maxn];
void solve() {
int nn;
scanf("%d", &nn);
memset(val, 128, sizeof(val));
int tot = 0;
for (int t = 0; t <= 1; t++) {
int n;
scanf("%d", &n);
tot += n - 1;
for (int i = 2; i <= n; i++) {
int f;
scanf("%d", &f);
G[t][f].push_back(i);
}
memset(l, 0x3f, sizeof(l));
memset(r, 128, sizeof(r));
for (int i = 1; i <= nn; i++) {
int a;
scanf("%d", &a);
l[a] = i;
r[a] = i;
}
dfs(1, 1, t);
}
for (int i = 1; i <= nn; i++) {
for (int cut = 0; cut < i; cut++) {
dp[i] = max(dp[i], dp[cut] + max(val[0][cut + 1][i], val[1][cut + 1][i]));
}
}
cout << dp[nn] << endl;
}
signed main() { solve(); }
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000055;
int n, m;
vector<pair<int, int> > g[N];
int col[N];
bool cyc;
int res[N];
void dfs(int v) {
col[v] = 1;
for (auto p : g[v]) {
int to = p.first, id = p.second;
if (col[to] == 0) {
dfs(to);
res[id] = 1;
} else if (col[to] == 2)
res[id] = 1;
else {
res[id] = 2;
cyc = true;
}
}
col[v] = 2;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
--u, --v;
g[u].push_back(make_pair(v, i));
}
for (int i = 0; i < n; ++i)
if (col[i] == 0) dfs(i);
cout << (cyc ? 2 : 1) << endl;
for (int i = 0; i < m; ++i) cout << res[i] << ' ';
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, m;
int lft[N][N], rgt[N][N];
int dp[N][N];
int f(int l, int r) {
if (l > r) return 0;
if (~dp[l][r]) return dp[l][r];
int ret = 0;
for (int j = l; j <= r; ++j) {
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (lft[i][j] >= l && rgt[i][j] <= r) ++cnt;
}
ret = max(ret, cnt * cnt + f(l, j - 1) + f(j + 1, r));
}
return dp[l][r] = ret;
}
int solve() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; ++i) {
int k;
scanf("%d", &k);
while (k--) {
int l, r;
scanf("%d %d", &l, &r);
--l, --r;
for (int j = l; j <= r; ++j) {
lft[i][j] = l;
rgt[i][j] = r;
}
}
}
memset(dp, -1, sizeof dp);
printf("%d\n", f(0, m - 1));
return 0;
}
int main() {
int t = 1;
for (int tc = 0; tc < t; ++tc) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 5;
const int H = 1e9 + 7;
vector<pair<int, int> > g[M];
unsigned long long goal, a[20][20], Hash[M];
int n, m, k, ans;
void dfs(int u, unsigned long long now) {
if (u == k + 1) {
ans += (now == goal);
return;
}
for (int i = 1; i <= u; i++) dfs(u + 1, now + a[u][i]);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int u, v, w, i = 1; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
g[u].push_back(make_pair(w, v));
}
Hash[0] = 1, goal = 0;
for (int i = 1; i <= n; i++) {
Hash[i] = Hash[i - 1] * H;
goal += Hash[i];
}
for (int i = 1; i <= n; i++) {
sort(g[i].begin(), g[i].end());
int tot = g[i].size();
for (int j = 0; j < tot; j++) a[tot][j + 1] += Hash[g[i][j].second];
}
ans = 0;
dfs(1, 0);
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > adj;
vector<pair<int, int> > Bridges;
int low[10000];
int num[10000];
int idx;
void dfs_Bridges(int u, int p = -1) {
num[u] = low[u] = idx++;
for (int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i];
if (v == p) continue;
if (num[v] == -1) {
dfs_Bridges(v, u);
if (low[v] > num[u]) Bridges.push_back(pair<int, int>(u, v));
low[u] = min(low[u], low[v]);
} else
low[u] = min(low[u], num[v]);
}
}
void buildBridges(int N) {
idx = 0;
Bridges = vector<pair<int, int> >();
memset(num, -1, sizeof(num));
for (int i = 0; i < N; ++i)
if (num[i] == -1) dfs_Bridges(i);
}
set<pair<int, int> > B_SET;
bool isBridge(pair<int, int> p) { return B_SET.count(p) > 0; }
int P[100010], L[100000];
vector<vector<int> > adj2;
vector<vector<int> > list_of_nodes;
bool vis[100010];
void tree_dfs(int u, int idx = 0, int lvl = 0) {
list_of_nodes[idx].push_back(u);
vis[u] = true;
L[idx] = lvl;
for (int i = 0; i < adj[u].size(); ++i) {
int v = adj[u][i];
if (vis[v]) continue;
if (isBridge(pair<int, int>(u, v)) || isBridge(pair<int, int>(v, u))) {
list_of_nodes.push_back(vector<int>());
adj2.push_back(vector<int>());
adj2.back().push_back(idx);
adj2[idx].push_back(adj2.size() - 1);
P[adj2.size() - 1] = idx;
tree_dfs(v, list_of_nodes.size() - 1, lvl + 1);
} else {
tree_dfs(v, idx, lvl);
}
}
}
int G[100010];
int T[100000][20];
void create(int *P, int N) {
memset(T, -1, sizeof(T));
for (int i = 0; i < N; ++i) T[i][0] = P[i];
for (int lvl = 1; (1 << lvl) <= N; lvl++)
for (int i = 0; i < N; ++i)
if (T[i][lvl - 1] != -1) T[i][lvl] = T[T[i][lvl - 1]][lvl - 1];
}
int LCA(int x, int y) {
if (L[x] < L[y]) swap(x, y);
int log = 0;
for (log = 1; (1 << log) <= L[x]; log++)
;
log--;
for (int i = log; L[x] != L[y]; i--)
if (L[x] - (1 << i) >= L[y]) x = T[x][i];
for (int i = log; x != y && i >= 0; i--)
if (T[x][i] != T[y][i]) x = T[x][i], y = T[y][i];
return x == y ? x : T[x][0];
}
int main() {
cin.sync_with_stdio(false);
int N, M, K;
cin >> N >> M;
adj = vector<vector<int> >(N);
for (int i = 0; i < M; ++i) {
int u, v;
cin >> u >> v;
adj[u - 1].push_back(v - 1);
adj[v - 1].push_back(u - 1);
}
buildBridges(N);
for (int i = 0; i < Bridges.size(); ++i) B_SET.insert(Bridges[i]);
list_of_nodes = vector<vector<int> >(1);
adj2 = vector<vector<int> >(1);
memset(vis, 0, sizeof(vis));
memset(P, -1, sizeof(P));
tree_dfs(0);
for (int i = 0; i < list_of_nodes.size(); ++i)
for (int j = 0; j < list_of_nodes[i].size(); ++j)
G[list_of_nodes[i][j]] = i;
create(P, adj2.size());
cin >> K;
for (int i = 0; i < K; ++i) {
int u, v;
cin >> u >> v;
int s = G[u - 1], e = G[v - 1];
int lc = LCA(s, e);
cout << L[s] - L[lc] + L[e] - L[lc] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[333][333];
vector<int> V;
int ABS(int x) { return x < 0 ? -x : x; }
double calc() {
sort(V.begin(), V.end());
int l = V.size();
double s1 = 0, s2 = 0;
for (int i = l / 10; i + l / 10 < V.size(); i++) s1 += V[i], s2 += 1;
return s1 / s2;
}
int main() {
int Q;
cin >> Q;
while (Q--) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) scanf("%d", a[i] + j);
double s1, s2;
V.clear();
for (int j = 1; j <= m; j++)
V.push_back(ABS(a[n / 2][j] - a[n / 2 + 1][j]));
s1 = calc();
V.clear();
for (int j = 1; j <= m; j++) V.push_back(ABS(a[1][j] - a[n][j]));
s2 = calc();
double ss = s1 / s2;
if (ss > 1)
cout << "YES";
else
cout << "NO";
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111111;
const int INF = (1 << 30);
int n, center, size[N], father[N];
long long dist[N];
vector<pair<int, int> > e[N];
int getCenter() {
vector<int> q;
q.push_back(1);
father[1] = 0;
for (int head = 0; head < (int)q.size(); head++) {
int x = q[head];
for (int i = 0; i < (int)e[x].size(); i++) {
int y = e[x][i].first;
if (y == father[x]) {
continue;
}
q.push_back(y);
father[y] = x;
}
}
int cent = -1, minV = INF;
for (int i = n - 1; i >= 0; i--) {
int x = q[i], cur = 0;
size[x] = 1;
for (int j = 0; j < (int)e[x].size(); j++) {
int y = e[x][j].first;
if (y == father[x]) {
continue;
}
cur = max(cur, size[y]);
size[x] += size[y];
}
cur = max(cur, n - size[x]);
if (cur < minV) {
minV = cur;
cent = x;
}
}
assert(minV <= n / 2);
return cent;
}
int tot, OPEN[N];
int closed[N], who[N], match[N], belone[N];
int sl[N], sr[N];
int minID[N << 2], visited[N];
priority_queue<pair<int, int> > values;
void dfs(int x, int fat, long long value) {
father[x] = fat;
dist[x] = value;
OPEN[x] = ++tot;
who[tot] = x;
for (int i = 0; i < (int)e[x].size(); i++) {
int y = e[x][i].first;
if (y == fat) {
continue;
}
dfs(y, x, value + e[x][i].second);
}
closed[x] = tot;
}
void build(int x, int l, int r) {
if (l == r) {
minID[x] = who[l];
} else {
int mid = (l + r) / 2;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
minID[x] = min(minID[x << 1], minID[x << 1 | 1]);
}
}
int ask(int x, int l, int r, int ql, int qr) {
if (qr < l || r < ql) {
return INF;
}
if (ql <= l && r <= qr) {
return minID[x];
}
int mid = (l + r) / 2;
return min(ask(x << 1, l, mid, ql, qr), ask(x << 1 | 1, mid + 1, r, ql, qr));
}
void delet(int x, int l, int r, int pos) {
if (l == r) {
minID[x] = INF;
} else {
int mid = (l + r) >> 1;
if (pos <= mid) {
delet(x << 1, l, mid, pos);
} else {
delet(x << 1 | 1, mid + 1, r, pos);
}
minID[x] = min(minID[x << 1], minID[x << 1 | 1]);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b, w;
scanf("%d %d %d", &a, &b, &w);
e[a].push_back(make_pair(b, w));
e[b].push_back(make_pair(a, w));
}
if (n == 1) {
printf("0\n");
printf("1\n");
return 0;
}
center = getCenter();
dfs(center, 0, 0);
closed[center] = 1;
belone[center] = center;
sl[center] = sr[center] = 1;
values.push(make_pair(sl[center] + sr[center], center));
for (int i = 0; i < (int)e[center].size(); i++) {
int y = e[center][i].first;
for (int j = OPEN[y]; j <= closed[y]; j++) {
int it = who[j];
belone[it] = y;
}
sl[y] = sr[y] = closed[y] - OPEN[y] + 1;
values.push(make_pair(sl[y] + sr[y], y));
}
build(1, 1, n);
for (int x = 1; x <= n; x++) {
while (1) {
int it = values.top().second;
if (sl[it] + sr[it] != values.top().first) {
values.pop();
} else {
break;
}
}
pair<int, int> top = values.top();
assert(top.first <= n - x + 1);
if (top.first == n - x + 1) {
int which = top.second;
if (which == center) {
if (x == n) {
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
match[x] = i;
}
}
} else {
vector<int> ls, rs;
for (; x <= n; x++) {
ls.push_back(x);
}
for (int i = 1; i <= n; i++) {
if (!visited[i]) {
rs.push_back(i);
}
}
sort(rs.begin(), rs.end());
if (ls[0] == rs[0] && ls[0] != center ||
ls[1] == rs[1] && ls[1] != center) {
swap(rs[0], rs[1]);
}
match[ls[0]] = rs[0];
match[ls[1]] = rs[1];
}
break;
}
vector<int> inner, outer;
for (int i = 1; i <= n; i++) {
if (visited[i]) {
continue;
}
if (OPEN[i] >= OPEN[which] && OPEN[i] <= closed[which]) {
inner.push_back(i);
} else {
outer.push_back(i);
}
}
sort(inner.begin(), inner.end());
reverse(inner.begin(), inner.end());
sort(outer.begin(), outer.end());
reverse(outer.begin(), outer.end());
for (; x <= n; x++) {
if (OPEN[which] <= OPEN[x] && OPEN[x] <= closed[which]) {
match[x] = outer.back();
outer.pop_back();
} else {
match[x] = inner.back();
inner.pop_back();
}
visited[match[x]] = 1;
}
break;
} else {
int bel = belone[x];
int y =
min(ask(1, 1, n, 1, OPEN[bel] - 1), ask(1, 1, n, closed[bel] + 1, n));
if (x == center && !visited[center]) {
y = min(y, center);
}
match[x] = y;
sl[bel]--;
values.push(make_pair(sl[bel] + sr[bel], bel));
delet(1, 1, n, OPEN[y]);
bel = belone[y];
sr[bel]--;
values.push(make_pair(sl[bel] + sr[bel], bel));
visited[y] = 1;
}
}
long long answer = 0;
for (int i = 1; i <= n; i++) {
answer += dist[i];
}
cout << 2 * answer << endl;
for (int i = 1; i <= n; i++) {
printf("%d%c", match[i], i < n ? ' ' : '\n');
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) + 7;
int n;
int a[N];
int aib[N];
int on[N];
long long sum[30][2];
void add(int i, int val) {
while (i <= n) {
aib[i] += val;
i += i & (-i);
}
}
int get(int i) {
int sol = 0;
while (i) {
sol += aib[i];
i -= i & (-i);
}
return sol;
}
int get(int l, int r) { return get(r) - get(l - 1); }
void build(int v, int tl, int tr, int lvl) {
if (tl == tr) {
return;
}
int tm = (tl + tr) / 2;
build(2 * v, tl, tm, lvl - 1);
build(2 * v + 1, tm + 1, tr, lvl - 1);
for (int j = tl; j <= tm; j++) add(a[j], +1);
for (int j = tm + 1; j <= tr; j++) {
sum[lvl - 1][0] += get(a[j] + 1, n);
;
sum[lvl - 1][1] += get(1, a[j] - 1);
}
for (int j = tl; j <= tm; j++) add(a[j], -1);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
int k = n;
n = (1 << n);
map<int, int> tr;
for (int i = 1; i <= n; i++) {
cin >> a[i];
tr[a[i]] = 0;
}
int kol = 0;
for (auto &it : tr) it.second = ++kol;
for (int i = 1; i <= n; i++) a[i] = tr[a[i]];
build(1, 1, n, k);
int q;
cin >> q;
while (q--) {
int l;
cin >> l;
l--;
for (int j = l; j >= 0; j--) on[j] ^= 1;
long long sol = 0;
for (int j = 0; j <= k; j++) sol += sum[j][on[j]];
cout << sol << "\n";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char ch = getchar();
long long s = 0, w = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = s * 10 + ch - '0';
ch = getchar();
}
return s * w;
}
long long n, m, tag;
vector<pair<long long, long long> > e[300010];
long long sz[300010], d[300010], s[300010], p[300010], fa[300010], dep[300010],
fv[300010], val[300010];
vector<long long> v;
void dfs(long long x, long long father) {
sz[x] = 1;
d[x] = (x == n);
for (auto tmp : e[x])
if (tmp.first != father) {
long long y = tmp.first;
dfs(y, x);
d[x] |= d[y];
sz[x] += sz[y];
}
}
void dfs2(long long x, long long father, long long w) {
fa[x] = father;
fv[x] = w;
dep[x] = dep[father] + 1;
if (d[x]) {
p[x] = ++m;
s[m] = w;
} else {
v.push_back(x);
}
if (d[x]) {
int s = sz[x];
for (auto tmp : e[x])
if (tmp.first != father && d[tmp.first]) s -= sz[tmp.first];
if (s >= 3) {
tag = 1;
}
}
for (auto tmp : e[x])
if (tmp.first != father) {
long long y = tmp.first, val = tmp.second;
dfs2(y, x, val);
}
}
inline long long cmp(long long x, long long y) { return dep[x] < dep[y]; }
int main() {
n = read();
long long q = read();
for (register long long i = 1; i <= n - 1; i++) {
long long x = read(), y = read(), w = read();
e[x].push_back(make_pair(y, w));
e[y].push_back(make_pair(x, w));
}
dfs(1, 0);
dfs2(1, 0, 0);
for (register long long i = 1; i <= m; i++) s[i] = s[i - 1] + s[i];
if (tag) {
while (q--) printf("%lld\n", s[m]);
return 0;
}
for (long long x : v) val[p[fa[x]]] = fv[x];
long long minn = 1e18, ans = 1e18;
for (register long long i = 1; i <= m; i++) {
if (i == 1) {
continue;
}
ans = min(ans, s[i] - val[i] + minn);
if (val[i] || val[i - 1])
ans = min(s[i] - s[i - 1] - (val[i] + val[i - 1]), ans);
minn = min(minn, val[i - 1] - s[i - 1]);
}
while (q--) {
long long x = read();
printf("%lld\n", s[m] - max(ans - x, 0LL));
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void chmin(int64_t& a, int64_t b) { a = min(a, b); }
int main() {
int N, A[50], B[50];
cin >> N;
for (int i = 0; i < N; i++) cin >> A[i];
for (int i = 0; i < N; i++) cin >> B[i];
map<int, vector<int>> mp;
for (int i = 0; i < N; i++) mp[A[i]].push_back(B[i]);
vector<pair<int, vector<int>>> vs;
for (auto& p : mp) {
sort(p.second.rbegin(), p.second.rend());
vs.push_back(p);
}
reverse(vs.begin(), vs.end());
int sz = vs.size();
const int64_t INF = 1e18;
static int64_t dp[51][51][5001];
for (int i = 0; i <= sz; i++)
for (int j = 0; j <= N; j++)
for (int k = 0; k <= 5000; k++) dp[i][j][k] = INF;
dp[0][0][0] = 0;
int num = 0, sum = 0;
for (int i = 0; i < sz; i++) {
int64_t a = vs[i].first;
auto& bs = vs[i].second;
int kd = 0;
for (int use = 0; use <= bs.size(); use++) {
int need = bs.size() - use;
if (use > 0) kd += bs[use - 1];
for (int j = need; j <= num; j++) {
for (int k = 0; k <= sum; k++)
chmin(dp[i + 1][j - need + use][k + kd], dp[i][j][k] + a * use);
}
}
num += bs.size();
for (int b : bs) sum += b;
}
double ans = INF;
for (int j = 0; j <= N; j++)
for (int k = 1; k <= 5000; k++) {
double res = (double)dp[sz][j][k] / k;
ans = min(ans, res);
}
int64_t Ans = ceil(ans * 1000);
cout << Ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
int cnt = 0;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 1; i < n - 1; i++) {
if (a[i] == 0) {
if (a[i + 1] == 1 && a[i - 1] == 1) {
if (i + 2 < n) {
if (a[i + 2] == 0) {
cnt++;
a[i + 1] = 0;
} else
cnt++;
} else
cnt++;
}
}
}
cout << cnt;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char a[1000];
map<char, string> b;
int ans[10000];
string binary(int n) {
string s;
while (n) {
if (n % 2 == 0)
s += "0";
else
s += "1";
n /= 2;
}
for (int i = s.size(); i < 8; i++) s += "0";
return s;
}
long long bigmod(long long b, long long p, long long m) {
long long x, power;
x = 1;
power = b % m;
for (;;) {
if (p == 0) break;
if (p % 2 == 1) x = (x * power) % m;
power = (power * power) % m;
p = p / 2;
}
return x;
}
long long decimal(string s) {
long long i, j, ans = 0, ansf = 0;
for (i = 0, j = s.size() - 1; i < s.size(); i++, j--) {
if (s[i] == '1') {
ans = bigmod(2, j, 256);
} else
ans = 0;
ansf += ans;
}
return ansf;
}
int main() {
string s;
int i, m, k, z, x;
while (gets(a)) {
int in = 0;
k = 0;
for (i = 0; i < strlen(a); i++) {
s = binary(a[i]);
b[a[i]] = s;
m = decimal(s);
if (in < m) {
z = m - in;
x = 256 - z;
in = m;
} else {
x = (in - m) % 256;
in = m;
}
ans[k++] = x;
}
for (i = 0; i < k; i++) cout << ans[i] << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9, maxn = (int)1e5 + 1;
const double eps = (double)1e-8;
const int mod = (int)1000000007;
long long a[500005], sn, k, n, T, st[100005], en[100005], type, l, r, x,
c[100005];
vector<pair<long long, int> > b[100005];
vector<pair<long long, int> >::iterator it;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> T;
for (int i = (1), _end = (n), _start = (1);
(_start <= _end && i <= _end) || (_start > _end && i >= _end);
i = (i + 1) * (_start <= _end) + (i - 1) * (_start > _end)) {
cin >> a[i];
}
sn = int(sqrt(n));
k = sn;
if (sn * sn != n) k++;
memset((c), 0, sizeof(c));
;
for (int i = 1; i < k; i++) {
for (int j = sn * (i - 1) + 1; j <= sn * i; j++) {
b[i].push_back(make_pair(a[j], j));
}
st[i] = sn * (i - 1) + 1;
en[i] = sn * i;
sort(b[i].begin(), b[i].end());
}
for (int i = sn * (k - 1) + 1; i <= n; i++) {
b[k].push_back(make_pair(a[i], i));
}
st[k] = sn * (k - 1) + 1;
en[k] = n;
sort(b[k].begin(), b[k].end());
while (T--) {
cin >> type;
if (type == 1) {
cin >> l >> r >> x;
for (int i = 1; i <= k; i++) {
if (st[i] >= l && en[i] <= r) {
c[i] += (long long)x;
continue;
}
if (en[i] < l) continue;
if (st[i] > r) break;
for (int j = 0; j < b[i].size(); j++) {
if (b[i][j].second >= l && b[i][j].second <= r)
b[i][j].first += (long long)x;
}
sort(b[i].begin(), b[i].end());
}
} else {
cin >> x;
l = inf;
r = 0;
for (int i = 1; i <= k; i++) {
if (x <= c[i]) continue;
x -= (long long)c[i];
it = lower_bound(b[i].begin(), b[i].end(), make_pair(x, 0));
if (it->first == x) l = min((int)l, (int)it->second);
it = --lower_bound(b[i].begin(), b[i].end(), make_pair(x, inf));
if (it->first == x) r = max((int)r, (int)it->second);
x += (long long)c[i];
}
if (r == 0)
cout << -1 << "\n";
else
cout << r - l << "\n";
}
}
return 0;
}
| 8 |
#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') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const int maxn = 6e5 + 10;
int Q, num, Max;
int fa[maxn], top, cnt1[maxn], cnt2[maxn];
struct node {
int x, c1, c2;
} sta[maxn];
struct Edge {
int from, to;
} e[maxn];
map<pair<int, int>, int> mp;
vector<int> V[maxn];
int get(int x) {
while (fa[x] != x) x = fa[x];
return x;
}
void merge(int x, int y) {
int fx = get(x), fy = get(y);
if (cnt1[fx] + cnt2[fx] > cnt1[fy] + cnt2[fy]) swap(fx, fy);
sta[++top] = (node){fx, cnt1[fx], cnt2[fx]};
fa[fx] = fy;
cnt1[fy] += cnt1[fx], cnt2[fy] += cnt2[fx];
}
struct Seg_Tree {
vector<int> c[maxn << 2];
void insert(int L, int R, int l, int r, int p, int x) {
if (L <= l && R >= r) {
c[p].push_back(x);
return;
}
int mid = (l + r) >> 1;
if (mid >= L) insert(L, R, l, mid, p << 1, x);
if (mid < R) insert(L, R, mid + 1, r, p << 1 | 1, x);
}
void solve(int l, int r, int p, long long Ans) {
int Nowtop = top;
for (int i = 0; i < c[p].size(); ++i) {
int x = e[c[p][i]].from, y = e[c[p][i]].to;
int fx = get(x), fy = get(y);
if (fx != fy) {
Ans -= (long long)cnt1[fx] * cnt2[fx] + (long long)cnt1[fy] * cnt2[fy];
merge(x, y);
Ans += (long long)cnt1[get(y)] * cnt2[get(y)];
}
}
if (l == r)
printf("%lld ", Ans);
else {
int mid = (l + r) >> 1;
solve(l, mid, p << 1, Ans);
solve(mid + 1, r, p << 1 | 1, Ans);
}
while (top > Nowtop) {
cnt1[fa[sta[top].x]] -= sta[top].c1;
cnt2[fa[sta[top].x]] -= sta[top].c2;
fa[sta[top].x] = sta[top].x;
top--;
}
}
} T;
int en[maxn];
int main() {
Q = read();
Max = 3e5;
int tim = 0;
for (int i = 1; i <= Q; ++i) {
int u = read(), v = read();
tim++;
v += Max;
pair<int, int> Now = make_pair(u, v);
if (mp.find(Now) != mp.end())
V[mp[Now]].push_back(tim), en[mp[Now]] = 1, mp.erase(Now);
else {
e[++num] = (Edge){u, v};
V[num].push_back(tim - 1);
mp[Now] = num;
}
}
for (int i = 1; i <= num; ++i) {
if (!en[i]) V[i].push_back(tim + 1);
for (int j = 1; j < V[i].size(); ++j)
if (V[i][j - 1] + 1 <= V[i][j] - 1)
T.insert(V[i][j - 1] + 1, V[i][j] - 1, 1, tim, 1, i);
}
Max *= 2;
for (int i = 1; i <= Max / 2; ++i) fa[i] = i, cnt1[i] = 1;
for (int i = Max / 2 + 1; i <= Max; ++i) fa[i] = i, cnt2[i] = 1;
T.solve(1, tim, 1, 0);
puts("");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch != 45 && (ch > '9' || ch < '0')) ch = getchar();
if (ch == 45) {
f = -1, ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
void cmin(int &a, int b) { a = min(a, b); }
void cmax(int &a, int b) { a = max(a, b); }
const int N = 205;
int i, j, k, n, s, t, m;
int dp[N][N], a[N], suf[N][N], maxn[N];
vector<int> e[N];
void dfs(int u, int fa) {
for (int v : e[u]) {
if (v == fa) continue;
dfs(v, u);
}
for (int v : e[u]) {
if (v == fa) continue;
for (i = 0; i <= n; i++) maxn[i] = dp[u][i];
for (i = 0; i <= n; i++) {
dp[u][i] = maxn[i] + suf[v][max(i - 1, k - i)];
if (i)
dp[u][i] = max(maxn[i] + suf[v][max(i - 1, k - i)],
maxn[max(i, k - i + 1)] + suf[v][i - 1]);
}
}
dp[u][0] += a[u];
for (i = n; i >= 0; i--) {
suf[u][i] = max(suf[u][i + 1], dp[u][i]);
}
}
signed main() {
read(n), read(k);
for (i = 1; i <= n; i++) read(a[i]);
for (i = 1; i < n; i++) {
int x, y;
read(x), read(y);
e[x].push_back(y);
e[y].push_back(x);
}
dfs(1, 0);
cout << suf[1][0];
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long pwr(long long base, long long p, long long mod = (1000000007LL)) {
long long ans = 1;
while (p) {
if (p & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
p /= 2;
}
return ans;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
const int N = 100002;
int n, m, k, x;
long long DP[N][3][12], storage[3][12];
vector<int> adj[N];
void dfs(int v, int par) {
DP[v][0][0] = k - 1;
DP[v][1][1] = 1;
DP[v][2][0] = m - k;
for (auto vv : adj[v]) {
if (vv == par) continue;
dfs(vv, v);
memset(storage, 0, sizeof(storage));
for (int j = 0; j <= x; j++)
for (int k = 0; k <= x; k++) {
if (j + k <= x)
storage[0][j + k] =
(storage[0][j + k] +
DP[v][0][j] * (DP[vv][0][k] + DP[vv][1][k] + DP[vv][2][k])) %
(1000000007LL);
if (j + k <= x)
storage[1][j + k] =
(storage[1][j + k] + DP[v][1][j] * DP[vv][0][k]) % (1000000007LL);
if (j + k <= x)
storage[2][j + k] = (storage[2][j + k] +
DP[v][2][j] * (DP[vv][0][k] + DP[vv][2][k])) %
(1000000007LL);
}
for (int j = 0; j <= x; j++) {
DP[v][0][j] = storage[0][j];
DP[v][1][j] = storage[1][j];
DP[v][2][j] = storage[2][j];
}
}
}
int main() {
scanf("%d%d", &n, &m);
int e = n - 1;
while (e--) {
int a, b;
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
scanf("%d%d", &k, &x);
dfs(1, -1);
long long ans = 0;
for (int j = 0; j <= x; j++) {
ans = (ans + DP[1][0][j]) % (1000000007LL);
ans = (ans + DP[1][1][j]) % (1000000007LL);
ans = (ans + DP[1][2][j]) % (1000000007LL);
}
ans %= (1000000007LL);
ans += (1000000007LL);
ans %= (1000000007LL);
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 1;
while (t--) {
int n;
cin >> n;
int m = n;
for (int i = 1; i <= n; i++)
if ((i - 1) + (i - 1) >= n - 1) {
m = i;
break;
}
cout << m << endl;
int a = 1, b = 1;
for (int i = 0; i < n; i++) {
cout << a << " " << b << endl;
if (b + 1 <= m)
b++;
else
a++;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
int l = 2;
int r = n;
int id = 1;
int res = 0;
bool f = 1;
while (l <= r) {
if (f) {
res += (id + r) % (n + 1);
id = r;
r--;
} else {
res += (id + l) % (n + 1);
id = l;
l++;
}
f ^= 1;
}
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 21;
const int zn = 351;
int n, q, ans, dp[zn][maxn];
deque<int> Q[zn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
a--;
dp[i / zn][a]++;
Q[i / zn].push_back(a);
}
cin >> q;
for (int i = 0; i < q; i++) {
int t, l, r;
cin >> t >> l >> r;
l = (l + ans - 1) % n;
r = (r + ans - 1) % n;
if (l > r) swap(l, r);
int Lzone = l / zn, Rzone = r / zn;
int Lmod = l % zn, Rmod = r % zn;
if (t == 2) {
int k;
cin >> k;
k = (k + ans - 1) % n;
ans = 0;
if (Lzone == Rzone) {
for (int j = Lmod; j <= Rmod; j++)
if (Q[Lzone][j] == k) ans++;
cout << ans << "\n";
continue;
}
for (int j = Lmod; j < zn; j++)
if (Q[Lzone][j] == k) ans++;
Lzone++;
while (Lzone != Rzone) {
ans += dp[Lzone][k];
Lzone++;
}
for (int j = 0; j <= Rmod; j++)
if (Q[Rzone][j] == k) ans++;
cout << ans << "\n";
} else {
int x = Q[Rzone][Rmod];
Q[Rzone].erase(Q[Rzone].begin() + (Rmod));
dp[Rzone][x]--;
Q[Lzone].insert(Q[Lzone].begin() + (Lmod), x);
dp[Lzone][x]++;
while (Lzone != Rzone) {
x = Q[Lzone].back();
Q[Lzone].pop_back();
dp[Lzone][x]--;
Q[Lzone + 1].push_front(x);
dp[Lzone + 1][x]++;
Lzone++;
}
}
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 0) {
cout << 0;
return 0;
}
vector<pair<string, int>> a;
map<pair<string, int>, vector<pair<string, int>>> g;
map<string, pair<int, int>> dl;
map<pair<string, int>, pair<int, int>> con;
map<string, bool> u;
for (int i = 0; i < n; ++i) {
string s;
int f;
cin >> s >> f;
a.push_back(make_pair(s, f));
int m;
cin >> m;
auto x = make_pair(s, f);
for (int j = 0; j < m; ++j) {
string l;
int e;
cin >> l >> e;
g[x].push_back(make_pair(l, e));
}
}
string prime_s;
int prime_i;
prime_s = a[0].first;
prime_i = a[0].second;
auto prime = make_pair(prime_s, prime_i);
dl[prime_s] = make_pair(1, prime_i);
con[prime] = make_pair(1, prime_i);
map<int, vector<pair<string, int>>> r;
int max_lev = 1;
r[1].push_back(prime);
u[prime.first] = 1;
while (r[max_lev].size() != 0) {
for (int i = 0; i < r[max_lev].size(); ++i) {
auto x = r[max_lev][i];
for (int j = 0; j < g[x].size(); ++j) {
if (dl[g[x][j].first].first == 0 ||
(dl[g[x][j].first].first == max_lev + 1 &&
dl[g[x][j].first].second < g[x][j].second)) {
dl[g[x][j].first] = make_pair(max_lev + 1, g[x][j].second);
}
}
}
for (int i = 0; i < r[max_lev].size(); ++i) {
auto x = r[max_lev][i];
for (int j = 0; j < g[x].size(); ++j) {
if ((dl[g[x][j].first] == make_pair(max_lev + 1, g[x][j].second)) &&
u[g[x][j].first] == 0) {
r[max_lev + 1].push_back(g[x][j]);
u[g[x][j].first] = 1;
}
}
}
max_lev++;
}
vector<pair<string, int>> ans;
for (int i = 2; i <= max_lev; ++i) {
for (int j = 0; j < r[i].size(); ++j) {
ans.push_back(r[i][j]);
}
}
sort(ans.begin(), ans.end());
cout << ans.size() << endl;
for (int i = 0; i < (int)ans.size(); ++i) {
cout << ans[i].first << ' ' << ans[i].second << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, cp = 2;
cin >> n;
bool p[1000][1000];
for (int i = n; i > 0;) {
int sq = sqrt(sqrt(i));
if (sq == 0) sq++;
vector<int> nums(4, sq);
int cr = sq * sq * sq * sq;
bool change = true;
while (change) {
change = false;
for (int j = 0; j < 4; j++) {
if ((cr / nums[j]) * (nums[j] + 1) <= i) {
cr = (cr / nums[j]) * (nums[j] + 1);
nums[j]++;
change = true;
}
}
}
for (int j = 0; j < nums[0]; j++) {
p[cp + j][0] = p[0][cp + j] = 1;
}
for (int j = 0; j < 3; j++) {
for (int k = 0; k < nums[j]; k++) {
for (int l = 0; l < nums[j + 1]; l++) {
p[cp + k][cp + nums[j] + l] = 1;
p[cp + nums[j] + l][cp + k] = 1;
}
}
cp += nums[j];
}
for (int j = 0; j < nums[3]; j++) {
p[cp + j][1] = p[1][cp + j] = 1;
}
cp += nums[3];
i -= cr;
}
cout << cp << endl;
for (int i = 0; i < cp; i++) {
for (int j = 0; j < cp; j++) {
if (p[i][j])
cout << "Y";
else
cout << "N";
}
cout << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int input = 0;
int a = 1;
int b = 1;
int difference = 0;
int differencefinal = 10000000;
int record1 = 0;
int record2 = 0;
int top = 0;
cin >> input;
for (int i = 1; i <= input; i++) {
if (i * i >= input) {
top = i;
break;
}
}
for (int i = 1; i <= input; i++) {
for (int j = 1; j <= input / i; j++) {
if (i * j == input) {
difference = abs(i - j);
if (difference < differencefinal) {
differencefinal = difference;
record1 = i;
record2 = j;
}
}
}
}
cout << record1;
cout << endl;
cout << record2;
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long b_search(long long n, long long d, long long m, long long l,
long long pos) {
long long a, b;
long long left = 0, right = 1000000000007;
a = pos * m + l;
if (pos == n - 1)
b = 1000000000007;
else
b = (pos + 1) * m;
while (right - left > 1) {
long long mid = left + (right - left) / 2;
if (a < mid * d)
right = mid;
else
left = mid;
}
if (a < left * d && left * d < b) right = left;
if (right * d < b)
return right * d;
else
return -1;
}
int main() {
long long n, d, m, l;
cin >> n >> d >> m >> l;
long long pos = 0;
for (int i = 0; i < n; ++i) {
pos = b_search(n, d, m, l, i);
if (pos != -1) break;
}
cout << pos;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Z = (int)2e5 + 123;
const int inf = (int)1e9 + 123;
const long long llinf = (long long)1e18 + 123;
long long a[Z], b[Z];
int main() {
int n;
cin >> n;
long long mx = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
mx = max(mx, a[i]);
}
int len = 0;
long long sum = 0;
for (int i = 1; i <= n; i++) {
if (a[i] != mx) {
len++;
b[len] = (mx - a[i]);
sum += b[len];
}
}
bool flag = true;
sort(b + 1, b + 1 + len);
vector<int> del;
for (int q = 1; q * q <= b[1]; q++) {
if (b[1] % q == 0) {
del.push_back(q);
if (q * q == b[1]) break;
del.push_back(b[1] / q);
}
}
sort(del.begin(), del.end());
reverse(del.begin(), del.end());
for (auto i : del) {
flag = true;
for (int j = 1; j <= len; j++) {
if (b[j] % i > 0) {
flag = false;
break;
}
}
if (flag) {
cout << sum / i << ' ' << i;
return 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int r = 0;
int t;
cin >> t;
for (int x = 0; x < t; x++) {
string s;
cin >> s;
if (s.at(1) == '+') {
r++;
} else {
r--;
}
}
cout << r << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int aim, step;
char ans[50], path[50];
int h(int a, int b) {
int s = 0;
if (a < b) swap(a, b);
while (a < aim) b += a, swap(a, b), s++;
return s;
}
bool dfs(int u, int a, int b) {
if (a > aim || b > aim || u + h(a, b) > step) return 0;
if (a == aim) {
for (int i = 0; i < u; i++) ans[i] = path[i];
return 1;
}
path[u] = 'X';
if (dfs(u + 1, a + b, b)) return 1;
path[u] = 'Y';
if (dfs(u + 1, a, a + b)) return 1;
return 0;
}
int main() {
scanf("%d", &aim);
while (!dfs(0, 1, 1)) step++;
printf("%d\n", step);
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
void eras(map<int, int> &m, int x) {
m[x]--;
if (!m[x]) m.erase(x);
}
const int N = (int)3e5 + 100;
const int M = (int)2e6 + 100;
const int inf = (int)1e9 + 100;
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
srand(time(0));
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, i;
cin >> n;
map<int, int> m;
for ((i) = 0; (i) < (n); (i)++) {
int a;
cin >> a;
m[a]++;
}
if (m[1]) {
cout << -1;
} else {
cout << 1;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, sum = 0;
for (int i = 1; i <= 5; i++) {
scanf("%d", &t);
sum += t;
}
if (sum == 0 || sum % 5)
puts("-1");
else
printf("%d\n", sum / 5);
return 0;
}
| 1 |
#include <bits/stdc++.h>
char s[100100];
struct code {
int n, i;
bool operator<(const code &rhs) const { return n < rhs.n; }
};
code cnt[50];
bool flag[50];
int main() {
scanf("%s", s);
int n = strlen(s);
memset(cnt, 0, sizeof cnt);
for (int i = 0; i < n; i++) cnt[s[i] - 'a'].n++;
for (int i = 0; i < 26; i++) cnt[i].i = i;
std::sort(cnt, cnt + 26);
int k;
scanf("%d", &k);
for (int i = 0; i < 26; i++) flag[i] = true;
int now = 0, ans = 0;
while (k >= cnt[now].n && now < 26)
k -= cnt[now].n, flag[cnt[now].i] = false, now++;
for (int i = 0; i < 26; i++)
if (flag[i]) ans++;
printf("%d\n", ans);
for (int i = 0; i < n; i++)
if (flag[s[i] - 'a']) printf("%c", s[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
int b = 500000, e = -1, l = 500000, r = -1, count = 4;
cin >> str;
for (int i = 0; i < str.size(); i++) {
if (str[i] == '[') {
b = i;
break;
}
}
for (int i = str.size() - 1; i >= 0; i--) {
if (str[i] == ']') {
e = i;
break;
}
}
if (b >= e) {
cout << -1 << endl;
return 0;
}
for (int i = b + 1; i < str.size(); i++) {
if (str[i] == ':') {
l = i;
break;
}
}
for (int i = e - 1; i >= 0; i--) {
if (str[i] == ':') {
r = i;
break;
}
}
if (l >= r) {
cout << -1 << endl;
return 0;
}
for (int i = l + 1; i < r; i++) {
if (str[i] == '|') count++;
}
cout << count << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e9 + 7;
long long int possible(string s, int a, int b, int p, int mid) {
char tofind;
long long int cnt = 0;
if (s[mid] == 'A') {
tofind = 'B';
} else
tofind = 'A';
for (int i = mid + 1; i < s.length(); i++) {
if (i == s.length() - 1 && s[i] != tofind && tofind == 'A') {
cnt += b;
}
if (i == s.length() - 1 && s[i] != tofind && tofind == 'B') {
cnt += a;
}
if (tofind == 'A' && s[i] == 'A') {
cnt += b;
tofind = 'B';
}
if (tofind == 'B' && s[i] == 'B') {
cnt += a;
tofind = 'A';
}
}
if (cnt <= p) {
return mid;
} else {
return -1;
}
}
long long int binary(string s, int a, int b, int p) {
int iteration = 1;
int l = 0;
int h = s.length() - 1;
long long int ans = -1e9;
long long int cnt = 0;
long long int mid;
while (l <= h) {
mid = l + (h - l) / 2;
if (possible(s, a, b, p, mid) != -1) {
ans = mid;
h = mid - 1;
} else {
l = mid + 1;
}
}
return ans;
}
void solve() {
long long int a, b, p;
cin >> a >> b >> p;
string s;
cin >> s;
long long int ans = binary(s, a, b, p);
if (ans != -1e9) {
cout << ans + 1;
} else {
cout << s.length();
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t;
cin >> t;
while (t--) {
solve();
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void _DBG(const char *s, _T x) {
cerr << s << " = " << x << "\n";
}
template <typename _T, typename... args>
void _DBG(const char *s, _T x, args... a) {
while (*s != ',') cerr << *s++;
cerr << " = " << x << ',';
_DBG(s + 1, a...);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<pair<int, int> > V;
multiset<int> costs;
for (int i = 0; i < n; i++) {
int m, p;
cin >> m >> p;
V.emplace_back(-m, p);
}
sort((V).begin(), (V).end());
long long res = 0;
int bought = 0;
for (int i = 0; i < n;) {
int last_gr = -V[i].first;
while (i < n && last_gr == -V[i].first) {
costs.emplace(V[i].second);
i++;
}
long long diff = last_gr - (bought + n - i);
while (diff > 0 && !costs.empty()) {
res += *costs.begin();
bought++;
diff--;
costs.erase(costs.begin());
}
}
cout << res << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
typedef long long mx[2][2];
mx a, b, c;
long long d, l, r, k;
void mul(mx x, mx y) {
memset(c, 0, sizeof(c));
for (int i = 0; i < (2); ++i)
for (int j = 0; j < (2); ++j)
for (int k = 0; k < (2); ++k) (c[i][j] += x[i][k] * y[k][j] % d) %= d;
memcpy(x, c, sizeof(mx));
}
void pmx(long long x) {
memset(a, 0, sizeof(a)), memset(b, 0, sizeof(b));
a[0][1] = a[1][0] = a[1][1] = 1;
b[0][0] = b[1][1] = 1;
while (x) {
if (x & 1) mul(b, a);
mul(a, a);
x >>= 1;
}
}
int main() {
cin >> d >> l >> r >> k;
--l;
long long x = 1;
for (long long i = 1; i * i <= r; ++i) {
long long j = r / i;
if (r / (i)-l / (i) >= k) x = max(x, i);
if (r / (j)-l / (j) >= k) x = max(x, j);
}
pmx(x);
cout << b[0][1] % d << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100000 + 10;
struct Tree {
Tree *pl, *pr;
int l, r;
pair<int, int> v;
set<pair<int, int> > st;
Tree(int _l, int _r) : l(_l), r(_r) {
int m = (l + r) >> 1;
if (l + 1 == r) {
pl = pr = 0;
v = make_pair(INT_MAX, INT_MAX);
st.insert(v);
return;
}
pl = new Tree(l, m);
pr = new Tree(m, r);
v = min(pl->v, pr->v);
}
void add(int at, pair<int, int> w) {
if (l + 1 == r) {
st.insert(w);
v = *st.begin();
return;
}
int m = (l + r) >> 1;
if (at < m)
pl->add(at, w);
else
pr->add(at, w);
v = min(pl->v, pr->v);
}
void remove(int at, pair<int, int> w) {
if (l + 1 == r) {
st.erase(w);
v = *st.begin();
return;
}
int m = (l + r) >> 1;
if (at < m)
pl->remove(at, w);
else
pr->remove(at, w);
v = min(pl->v, pr->v);
}
pair<int, int> ask(int L, int R) {
if (L >= r || l >= R) return make_pair(INT_MAX, INT_MAX);
if (L <= l && R >= r) {
return v;
}
return min(pl->ask(L, R), pr->ask(L, R));
}
} * root;
int n, m;
struct Data {
int l, r, t;
int type, id;
void read() { scanf("%d%d%d", &l, &r, &t); }
bool operator<(const Data &o) const {
return t != o.t ? t < o.t : type > o.type;
}
};
template <class T>
struct Index : public vector<T> {
using vector<T>::erase;
using vector<T>::begin;
using vector<T>::end;
void doit() {
sort(begin(), end());
erase(unique(begin(), end()), end());
}
int get(T x) { return lower_bound(begin(), end(), x) - begin(); }
};
Data a[MAX_N * 2];
Index<int> idx;
int ans[MAX_N];
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
a[i].read();
a[i].type = 0;
a[i].id = i;
}
for (int i = n; i < n + m; ++i) {
a[i].read();
a[i].type = 1;
a[i].id = i - n;
}
for (int i = 0; i < n + m; ++i) {
idx.push_back(a[i].l);
idx.push_back(a[i].r);
}
idx.doit();
for (int i = 0; i < n + m; ++i) {
a[i].l = idx.get(a[i].l);
a[i].r = idx.get(a[i].r);
}
sort(a, a + n + m);
Tree *root = new Tree(0, idx.size());
memset(ans, -1, sizeof ans);
for (int i = 0; i < n + m; ++i) {
if (a[i].type == 0) {
for (;;) {
pair<int, int> v = root->ask(a[i].l, a[i].r + 1);
if (v.first <= a[i].r) {
int who = v.second;
ans[a[who].id] = a[i].id + 1;
root->remove(a[who].l, v);
} else
break;
}
} else {
root->add(a[i].l, make_pair(a[i].r, i));
}
}
for (int i = 0; i < m; ++i) {
printf("%d ", ans[i]);
}
puts("");
return 0;
}
| 8 |
#include <bits/stdc++.h>
int a[1000010];
using namespace std;
set<int> s;
int main() {
a[1] = 1;
int n, count = 1, flag = 1;
scanf("%d", &n);
int i, m;
for (i = 1; i <= n; i++) {
scanf("%d", &m);
if (s.count(m)) {
count += 2;
a[count - 1] = i;
a[count] = i + 1;
flag = 0;
s.clear();
} else
s.insert(m);
}
if (flag) {
printf("-1\n");
return 0;
}
count -= 1;
a[count] = n;
printf("%d\n", count / 2);
for (i = 1; i <= count / 2; i++) {
printf("%d %d\n", a[2 * i - 1], a[2 * i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int sum[26];
int main() {
int n, k = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) int a;
if (n == 1) {
printf("YES\n");
return 0;
}
getchar();
for (int i = 1; i <= n; i++) {
char c = getchar();
sum[c - 'a']++;
}
for (int i = 0; i < 26; i++)
if (sum[i] > 1) k++;
if (k)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void Solve();
int main() {
Solve();
return 0;
}
void Solve() {
string str;
cin >> str;
bool bol = true;
for (int i = 0; i < str.length(); i++) {
if (str[i] != '1' && str[i] != '4') {
bol = false;
break;
} else if (str[0] != '1') {
bol = false;
break;
} else if (str.find("444") != -1) {
bol = false;
break;
}
}
if (bol)
cout << "YES\n";
else
cout << "NO\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7, MAX = 155;
long long n, m, dp[MAX][MAX][MAX][2][2], ans;
long long get(int i, int x1, int x2, int y1, int y2, int x, int y) {
return ((dp[i][x1][y1][x][y] - dp[i][x1][y2][x][y] - dp[i][x2][y1][x][y] +
dp[i][x2][y2][x][y]) %
MOD +
MOD) %
MOD;
}
int main() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
for (int l = 1; l <= m; l++)
for (int r = l; r <= m; r++)
dp[i][l][r][0][0] =
((i == 1 ? 1 : 0) + get(i - 1, l - 1, r, l - 1, r, 0, 0)) % MOD,
dp[i][l][r][0][1] = (get(i - 1, l - 1, r, r, m, 0, 0) +
get(i - 1, l - 1, r, r - 1, m, 0, 1)) %
MOD,
dp[i][l][r][1][0] = (get(i - 1, 0, l - 1, l - 1, r, 0, 0) +
get(i - 1, 0, l, l - 1, r, 1, 0)) %
MOD,
dp[i][l][r][1][1] =
(get(i - 1, 0, l - 1, r, m, 0, 0) +
get(i - 1, 0, l - 1, r - 1, m, 0, 1) +
get(i - 1, 0, l, r, m, 1, 0) + get(i - 1, 0, l, r - 1, m, 1, 1)) %
MOD;
for (int l = 1; l <= m; l++)
for (int r = 1; r <= m; r++)
for (int c = 0; c < 2; c++)
for (int d = 0; d < 2; d++)
dp[i][l][r][c][d] =
((dp[i][l - 1][r][c][d] + dp[i][l][r - 1][c][d] -
dp[i][l - 1][r - 1][c][d] + dp[i][l][r][c][d]) %
MOD +
MOD) %
MOD;
for (int x = 0; x < 2; x++)
for (int y = 0; y < 2; y++)
ans = (ans + (n - i + 1) * dp[i][m][m][x][y] % MOD) % MOD;
}
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long cntzero(long long num) {
long long ans = 0;
while (num != 0) {
if (num % 2) ans++;
num /= 2;
}
return ans;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, p;
cin >> n >> p;
for (long long i = 1; clock() < 1.95 * CLOCKS_PER_SEC; i++) {
long long newn = n - p * i;
if (newn < i) continue;
if (cntzero(newn) <= i) {
cout << i;
return 0;
}
}
cout << -1;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
const long long INF = 1e9 + 7;
pair<int, int> a[N];
int d[N];
int main() {
ios_base::sync_with_stdio(0);
int n, ans = INF, t;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
sort(a, a + n);
for (int i = 0; i < n; i++) {
int l = 0, r = i;
while (l < r - 1) {
int m = (l + r) / 2;
if (a[m].first < a[i].first - a[i].second)
l = m;
else
r = m;
}
t = r;
if (a[0].first >= a[i].first - a[i].second) t = 0;
d[i] = d[max(t - 1, 0)] + i - t;
ans = min(ans, d[i] + n - i - 1);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 7;
map<int, int> cnt;
int p[N], a[N], d[N];
int main() {
int n, b;
scanf("%d%d", &n, &b);
int tot = n;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
cnt[a[i]]++;
}
sort(a + 1, a + n + 1);
n = unique(a + 1, a + n + 1) - a - 1;
d[1] = 0;
for (int i = 1; i <= n; ++i) {
p[i] = p[i - 1] + cnt[a[i]];
d[i + 1] = d[i] + ((i & (i - 1)) ? 0 : 1);
}
int ans = N;
int r = 1;
for (int l = 1; l <= n; ++l) {
while (r <= n && 1LL * d[r - l + 1] * tot <= b * 8) ++r;
ans = min(ans, tot - (p[r - 1] - p[l - 1]));
}
printf("%d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:100000000")
int ri() {
int x;
scanf("%d", &x);
return x;
}
int main() {
long long n;
cin >> n;
long long res = 0;
res += n * (n - 1) / 2LL * (n - 2) / 3LL * (n - 3) / 4LL * (n - 4) / 5LL;
res += n * (n - 1) / 2LL * (n - 2) / 3LL * (n - 3) / 4LL * (n - 4) / 5LL *
(n - 5) / 6LL;
res += n * (n - 1) / 2LL * (n - 2) / 3LL * (n - 3) / 4LL * (n - 4) / 5LL *
(n - 5) / 6LL * (n - 6) / 7LL;
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long arr[123456];
for (int i = 0; i < 123456; i++) {
arr[i] = 0;
}
long long x;
for (int i = 0; i < n; i++) {
cin >> x;
arr[x]++;
}
arr[2] = max(arr[2] * 2, arr[1]);
for (long long i = 3; i < 111111; i++) {
arr[i] = max(arr[i - 1], arr[i - 2] + arr[i] * i);
}
cout << arr[100011] << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1001001001;
const long long INFLL = 1001001001001001001LL;
template <typename T>
void pv(T a, T b) {
for (T i = a; i != b; ++i) cout << *i << " ";
cout << endl;
}
template <typename T>
void chmin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
void chmax(T& a, T b) {
if (a < b) a = b;
}
bool exist[100050];
long long pos[100050], val[100050];
long long mv[10050];
set<pair<long long, long long> > calc(long long h, long long n, long long k,
long long ops, long long A[]) {
for (int i = 0; i < k; ++i) {
mv[i] = INFLL;
}
mv[0] = 0;
priority_queue<long long> Q;
Q.push(0);
while (!Q.empty()) {
long long v = -Q.top();
Q.pop();
long long vk = v % k;
if (mv[vk] != v) continue;
for (int i = 0; i < ops; ++i) {
long long vv = v + A[i];
long long vvk = vv % k;
if (mv[vvk] > vv) {
mv[vvk] = vv;
Q.push(-vv);
}
}
}
set<pair<long long, long long> > res;
for (int i = 0; i < n; ++i) {
if (exist[i] && mv[pos[i] % k] <= pos[i]) {
res.insert(make_pair(val[i], -i));
}
}
return res;
}
int main() {
long long h, A[24];
long long n, m, k, ops = 0;
cin >> h >> n >> m >> k;
for (int i = 0; i < n; ++i) {
cin >> pos[i] >> val[i];
exist[i] = true;
--pos[i];
}
set<pair<long long, long long> > ts = calc(h, n, k, ops, A);
for (int i = 0; i < m; ++i) {
int t;
cin >> t;
if (t == 1) {
cin >> A[ops++];
ts = calc(h, n, k, ops, A);
} else if (t == 2) {
long long x, y;
cin >> x >> y;
--x;
bool found = ts.find(make_pair(val[x], -x)) != ts.end();
if (found) ts.erase(make_pair(val[x], -x));
val[x] -= y;
if (found) ts.insert(make_pair(val[x], -x));
} else if (t == 3) {
if (ts.empty()) {
cout << 0 << endl;
} else {
cout << ts.rbegin()->first << endl;
exist[-ts.rbegin()->second] = false;
ts.erase(*ts.rbegin());
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
typedef long long int ll;
#define in(v,n) for(int i = 0 ; i < n ; i++) cin >> v[i];
#define f(i,a,b) for(int i = a ; i < b ; i++)
#define frev(a,b) for(int i = a ; i >= b ; i--)
#define mod 1000000007
using namespace std;
#define pb push_back
#define debugVector(v) for(int i = 0; i < v.size(); i++) cout << v[i] << " "; cout << endl;
#define debugArray(arr, n) for(int i=1; i<n; i++) cout << arr[i] << " "; cout << endl;
#define FIO ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define F first
#define S second
typedef vector<int> vi;
typedef pair<int, int> pi;
#define o1(x) cout<<x<<'\n'
#define o2(x,y) cout<<x<<" "<<y<<"\n";
#define o3(x,y,z) cout<<x<<" "<<y<<" "<<z<<'\n'
#define nl cout <<"\n"
#define s(v) sort(v.begin(), v.end());
#define imax INT_MAX
#define imin INT_MIN
//A....Z 65....90
//a....z 97....122
int main(int argc, char **argv)
{
// Code goes here
FIO;
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int t; cin >> t;
while (t--) {
ll n;
cin >> n;
while (n and n % 2 == 0) {
n /= 2;
}
if (n == 1) {
o1("NO");
} else {
o1("YES");
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int IN() {
int x = 0, ch = getchar(), f = 1;
while (!isdigit(ch) && (ch != '-') && (ch != EOF)) ch = getchar();
if (ch == '-') {
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
inline void Out(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10)
Out(x / 10), putchar(x % 10 + '0');
else
putchar(x + '0');
}
const int M = 200005;
struct Stat {
int x, p;
bool operator<(const Stat& w) const { return x < w.x; }
} a[M];
int d, n, m, sml[M];
int main() {
d = IN(), n = IN(), m = IN();
for (int i = 1; i <= m; i++) a[i].x = IN(), a[i].p = IN();
a[0].x = 0;
a[m + 1].x = d;
a[m + 1].p = 0;
sort(a + 1, a + m + 1);
sml[m] = m + 1;
for (int i = m - 1; i >= 1; i--) {
int now = i + 1;
while (a[now].p > a[i].p) now = sml[now];
sml[i] = now;
}
long long Ans = 0, gas = n;
for (int i = 1; i <= m + 1; i++) {
gas -= a[i].x - a[i - 1].x;
if (gas < 0) return puts("-1"), 0;
int Min = min(n, a[sml[i]].x - a[i].x);
if (gas < Min) {
Ans += 1ll * (Min - gas) * a[i].p;
gas = Min;
}
}
printf("%I64d\n", Ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct aaa {
int x, y;
} a[1010];
;
int n, i, j, x, ans[1010][1010];
bool cmp(aaa a, aaa b) { return a.x > b.x; }
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i].x);
a[i].y = i;
}
sort(a + 1, a + n + 1, cmp);
for (i = 1; i <= a[1].x; i++) {
x = i;
for (j = 1; j <= n; j++)
if (a[j].x >= i) {
ans[x][a[j].y] = 1;
x++;
if (x > n + 1) x = 1;
}
}
printf("%d\n", n + 1);
for (i = 1; i <= n + 1; i++) {
for (j = 1; j <= n; j++) printf("%d", ans[i][j]);
puts("");
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[2000][2000], b[2000][2000];
bool used[2000][2000];
int pi[2000 * 2000], pj[2000 * 2000];
int num;
int circles, squares;
void check() {
if (num < 100) return;
int i0 = (1 << 30), i1 = -(1 << 30), j0 = (1 << 30), j1 = -(1 << 30);
for (int k = 0; k < num; k++) {
int i = pi[k], j = pj[k];
i0 = min(i0, i), i1 = max(i1, i), j0 = min(j0, j), j1 = max(j1, j);
}
double ic = 0.5 * (i0 + i1), jc = 0.5 * (j0 + j1);
double r2 = 0;
for (int k = 0; k < num; k++) {
double di = ic - pi[k], dj = jc - pj[k];
r2 = max(r2, di * di + dj * dj);
}
double ratio = 1.0 * num / r2;
if (ratio > 2.6)
circles++;
else
squares++;
}
void dfs(int i, int j) {
if (used[i][j] || b[i][j] == 0) return;
used[i][j] = true;
pi[num] = i, pj[num] = j, num++;
if (i + 1 < n) dfs(i + 1, j);
if (i > 0) dfs(i - 1, j);
if (j + 1 < n) dfs(i, j + 1);
if (j > 0) dfs(i, j - 1);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf("%d", &a[i][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
b[i][j] = a[i][j];
}
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (!used[i][j] && b[i][j] == 1) {
num = 0;
dfs(i, j);
check();
}
printf("%d %d\n", circles, squares);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int n;
cin >> n;
vector<int> h(n), c(n);
for (int j = 0; j < n; ++j) scanf("%d%d", &h[j], &c[j]);
vector<vector<unsigned long long>> dp(
n, vector<unsigned long long>(3, LLONG_MAX));
dp[0][0] = 0;
dp[0][1] = c[0];
dp[0][2] = c[0] * 2;
for (int j = 1; j < n; ++j) {
for (int k = 0; k < 3; ++k)
for (int s = 0; s < 3; ++s) {
if (h[j - 1] + k != h[j] + s)
dp[j][s] = min(dp[j][s], dp[j - 1][k] + s * c[j]);
}
}
cout << min(dp[n - 1][0], min(dp[n - 1][1], dp[n - 1][2])) << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll p, f, cs, cw, s, w;
void solve() {
cin >> p >> f >> cs >> cw >> s >> w;
if (p > f) swap(p, f);
if (s > w) swap(s, w), swap(cs, cw);
ll answer = 0;
for (ll i = 0; i <= cs; i++) {
if (i * s > p) break;
ll p_baki = p - (i * s);
ll p_w = min(cw, p_baki / w);
ll f_nibe = min(cs - i, f / s);
ll f_baki = f - (f_nibe * s);
ll f_w = min(cw - p_w, f_baki / w);
ll t = f_nibe + f_w;
f_w = min(cw - p_w, f / w);
f_baki = f - (f_w * w);
f_nibe = min(cs - i, f_baki / s);
t = max(t, f_nibe + f_w);
answer = max(answer, i + p_w + t);
}
cout << answer << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
int testcases = 1;
cin >> testcases;
for (int i = 1; i <= testcases; i++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int dy[5] = {-1, 0, 1};
int N;
int ret(int col, int row, vector<string> &A, vector<vector<int>> &mem) {
if (col >= N) return 1;
int &ans = mem[row][col];
if (ans >= 0) return ans;
ans = 0;
auto bad = [&](pair<int, int> X) {
if (X.first < 0 || X.first >= 3) return true;
if (X.second >= N) return false;
if (A[X.first][X.second] != '.') return true;
return false;
};
for (int move = 0; move < 3; ++move) {
bool ok = true;
vector<pair<int, int>> cells;
cells.push_back({row, col + 1});
for (int i = 1; i <= 3; ++i) cells.push_back({row + dy[move], col + i});
for (auto temp : cells)
if (bad(temp)) {
ok = false;
}
if (!ok) continue;
ans |= ret(col + 3, row + dy[move], A, mem);
}
return ans;
}
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
N = n;
vector<string> A(3);
for (int i = 0; i < 3; ++i) cin >> A[i];
int start = 0;
for (int i = 0; i < 3; ++i)
if (A[i][0] == 's') {
start = i;
A[i][0] = '.';
}
vector<vector<int>> mem(3, vector<int>(n + 10, -1));
int ans = ret(0, start, A, mem);
if (ans) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1e5 + 5;
queue<int> q1, q2;
class psy {
public:
int l, r, val, del;
} c[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
c[0].val = 0;
c[n + 1].val = inf;
for (int i = 1; i <= n; i++) {
cin >> c[i].val;
c[i].l = i - 1, c[i].r = i + 1;
}
for (int i = 2; i <= n; i++) {
if (c[i - 1].val > c[i].val) q1.push(i);
}
int ans = 0;
while (!q1.empty()) {
ans++;
while (!q1.empty()) {
int x = q1.front();
q1.pop();
c[x].del = 1;
c[c[x].l].r = c[x].r;
c[c[x].r].l = c[x].l;
q2.push(c[x].r);
}
while (!q2.empty()) {
int x = q2.front();
q2.pop();
if (c[c[x].l].val > c[x].val && !c[x].del) q1.push(x);
}
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
long long int mod = 998244353LL;
long long int factmod[1000100];
unsigned long long powmod(long long z, long long a) {
if (a == 0) return 1;
if (a == 1) return z;
long long x = powmod(z, a / 2);
x = (x * x) % mod;
if (a % 2 == 1) x = (x * z) % mod;
return x;
}
unsigned long long invmod(long long z) { return powmod(z, mod - 2); }
int main() {
long long int n;
scanf("%lld", &n);
factmod[0] = 1;
factmod[1] = 1;
for (int x = 2; x <= n + 10; x += 1) {
factmod[x] = factmod[x - 1] * x % mod;
}
long long int b = 0;
for (long long k = 1; k < n; k++) {
long long int a = (k * k) % mod;
a *= (factmod[n] * invmod(factmod[k + 1]) % mod);
a %= mod;
a *= invmod(factmod[n - k - 1]);
a %= mod;
a *= factmod[n - k - 1];
b += a;
b %= mod;
}
long long int c = factmod[n] * n - n + 1;
long long int ans = c - b + mod;
ans %= mod;
printf("%lld\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool comp(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
if ((abs(a.first) < abs(b.first)) ||
(abs(a.first) == abs(b.first) && abs(a.second) < abs(b.second)))
return true;
return false;
}
string fn(string x) {
if (x == "L") return "R";
if (x == "R") return "L";
if (x == "D") return "U";
if (x == "U") return "D";
}
int main() {
long long int n;
cin >> n;
vector<pair<long long int, long long int>> pts(n);
for (int i = 0; i < n; i++) scanf("%lld%lld", &pts[i].first, &pts[i].second);
sort(pts.begin(), pts.end(), comp);
long long int ans = 0;
vector<vector<pair<int, string>>> answer;
for (int i = 0; i < n; i++) {
vector<pair<int, string>> pth;
if (pts[i].first > 0)
pth.push_back(make_pair(abs(pts[i].first), "R"));
else if (pts[i].first < 0)
pth.push_back(make_pair(abs(pts[i].first), "L"));
if (pts[i].second > 0)
pth.push_back(make_pair(abs(pts[i].second), "U"));
else if (pts[i].second < 0)
pth.push_back(make_pair(abs(pts[i].second), "D"));
pth.push_back(make_pair(2, "N"));
for (int i = pth.size() - 2; i >= 0; i--) {
pth.push_back(make_pair(pth[i].first, fn(pth[i].second)));
}
pth.push_back(make_pair(3, "N"));
answer.push_back(pth);
ans += pth.size();
}
printf("%lld\n", ans);
for (auto it1 : answer) {
for (auto it : it1) {
if (it.second == "N")
printf("%d\n", it.first);
else {
printf("1 %d %s\n", it.first, it.second.c_str());
}
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mpow = 10;
int main() {
int n;
scanf("%i", &n);
int one[mpow];
int zero[mpow];
for (int i = 0; i < mpow; i++) one[i] = 1;
for (int i = 0; i < mpow; i++) zero[i] = 0;
for (int i = 0; i < n; i++) {
char c;
int x;
scanf(" %c %i", &c, &x);
for (int j = 0; j < mpow; j++) {
int tmp = 0;
if (x & (1 << j)) tmp = 1;
if (c == '|') {
one[j] |= tmp;
zero[j] |= tmp;
} else if (c == '^') {
one[j] ^= tmp;
zero[j] ^= tmp;
} else {
one[j] &= tmp;
zero[j] &= tmp;
}
}
}
int or_val = 0;
int and_val = 0;
int xor_val = 0;
for (int i = 0; i < mpow; i++) {
if (one[i] == 1 and zero[i] == 0) {
and_val += 1 << i;
} else if (one[i] == 1 and zero[i] == 1) {
and_val += 1 << i;
or_val += 1 << i;
} else if (one[i] == 0 and zero[i] == 1) {
and_val += 1 << i;
xor_val += 1 << i;
} else if (one[i] == 0 and zero[i] == 0) {
}
}
printf("3 \n");
printf("| %i\n", or_val);
printf("& %i\n", and_val);
printf("^ %i\n", xor_val);
for (int i = 0; i < mpow; i++) {
int tmp1 = 1;
int tmp2 = 0;
int tmp = 0;
if (or_val & (1 << i)) tmp = 1;
tmp1 |= tmp;
tmp2 |= tmp;
tmp = 0;
if (and_val & (1 << i)) tmp = 1;
tmp1 &= tmp;
tmp2 &= tmp;
tmp = 0;
if (xor_val & (1 << i)) tmp = 1;
tmp1 ^= tmp;
tmp2 ^= tmp;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
cout << v[(n - 1) / 2];
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
class MinStr {
public:
string getNewStr(int n, string s) {
char currC, nextC;
bool found = false;
int remInd = -1;
for (int i = 0; i < (n - 1); i++) {
currC = s[i];
nextC = s[i + 1];
if (currC > nextC) {
remInd = i;
found = true;
break;
}
}
string newStr = s.substr(0, n - 1);
if (found) {
if (remInd > 0) {
newStr = s.substr(0, remInd) + s.substr(remInd + 1, n - 1 - remInd);
} else {
newStr = s.substr(1, n - 1);
}
}
return newStr;
}
};
int main(int argc, const char* argv[]) {
MinStr ms;
string nLn, sLn;
getline(cin, nLn);
getline(cin, sLn);
int n = atoi(nLn.c_str());
string newS = ms.getNewStr(n, sLn);
cout << newS << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
class node {
public:
int lo, hi, value;
node *left, *right;
node(const int _lo, const int _hi) {
left = right = NULL;
lo = _lo, hi = _hi, value = 0;
}
void build() {
if (lo == hi) return;
const int mid = (lo + hi) >> 1;
left = new node(lo, mid), left->build();
right = new node(mid + 1, hi), right->build();
}
void update(const int idx) {
if (lo > idx or hi < idx) return;
if (lo == idx and hi == idx) {
++value;
return;
}
left->update(idx);
right->update(idx);
value = left->value + right->value;
}
int query(const int _lo, const int _hi) {
if (lo > _hi or hi < _lo) return 0;
if (lo >= _lo and hi <= _hi) return value;
int a = left->query(_lo, _hi);
int b = right->query(_lo, _hi);
return a + b;
}
int leftmost() {
if (lo == hi) return lo;
if (left->value) return left->leftmost();
return right->leftmost();
}
int rightmost() {
if (value == hi - lo + 1) return lo - 1;
if (lo == hi) return lo;
if (right->value < right->hi - right->lo + 1) return right->rightmost();
return left->rightmost();
}
};
int main() {
printf("1");
int n;
scanf("%d", &n);
node root = node(1, n);
root.build();
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
root.update(x);
printf(" %d", root.query(root.leftmost(), root.rightmost()) + 1);
}
return !printf("\n");
};
| 3 |
#include <bits/stdc++.h>
using namespace std;
int ot, n, k, x, y;
map<pair<int, int>, pair<int, int> > m;
int main() {
cin >> n;
int a, b, c;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
if (a > b) swap(a, b);
if (b > c) swap(b, c);
if (a > b) swap(a, b);
if (a > ot) {
ot = a;
k = 1;
x = i;
}
if (m.find({b, c}) != m.end() && min(m[{b, c}].first + a, min(b, c)) > ot) {
ot = min(m[{b, c}].first + a, min(b, c));
k = 2;
x = m[{b, c}].second;
y = i;
}
m[{b, c}] = max(m[{b, c}], {a, i});
}
cout << k << endl;
if (k == 1)
cout << x + 1;
else
cout << x + 1 << " " << y + 1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n;
while (cin >> n) {
long m = (n * (n - 1)) / 2, i, a, b, fst[55] = {0}, scnd[55] = {0},
tot[55] = {0}, team[55] = {0}, k = 0;
for (i = 1; i < m; i++) {
cin >> a >> b;
fst[a]++;
scnd[b]++;
}
for (i = 1; i <= n; i++) {
tot[i] = fst[i] + scnd[i];
if (tot[i] != n - 1) {
team[k++] = i;
}
}
if (fst[team[0]] > fst[team[1]]) {
cout << team[0] << " " << team[1] << endl;
} else {
cout << team[1] << " " << team[0] << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
for (int i = 0; i < n; i += 2) {
cout << a[i] << " ";
}
int temp;
if (n % 2 == 0) {
temp = n - 1;
} else
temp = n - 2;
for (int i = temp; i >= 0; i -= 2) {
cout << a[i] << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int nimber[] = {0, 1, 2, 1, 4, 3, 2, 1, 5, 6, 2, 1, 8, 7, 5, 9,
8, 7, 3, 4, 7, 4, 2, 1, 10, 9, 3, 6, 11, 12, 14, 13};
int main() {
long long n;
cin >> n;
vector<long long> cnt(32, 0);
cnt[1] = 1;
long long total = 1;
vector<bool> used(100000, false);
for (long long i = 2; i * i <= n; ++i)
if (!used[i]) {
int len = 0;
for (long long j = i; j <= n; j *= i) {
if (j < int(used.size())) used[j] = true;
++len;
++total;
}
++cnt[len];
}
cnt[1] += n - total;
int nim = 0;
for (int i = 0; i < int(cnt.size()); ++i) {
if (cnt[i] % 2 == 1) {
nim ^= nimber[i];
}
}
if (nim == 0)
cout << "Petya" << endl;
else
cout << "Vasya" << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, y = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') y = -y;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * y;
}
namespace qiqi {
const int N = 505, P = 1e9 + 7;
int n, m, f[N];
void main() {
int ans = 0;
n = read();
for (int i = (1); i <= (n); ++i) {
int x = read();
if (x > 0) f[x] = (2LL * f[x] - 1) % P;
if (i != 1) ans = (2LL * ans - 1) % P;
}
ans = -ans;
for (int i = (1); i <= (n); ++i) ans = (ans + f[i]) % P;
printf("%d\n", (ans + P) % P);
}
} // namespace qiqi
int main() {
qiqi::main();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {0, 1, -1, 0};
const int dy[] = {1, 0, 0, -1};
const int N = 1003;
int n, m, k, T = 1;
char a[N][N];
int done[N][N], vis[N][N];
int memo[N][N];
bool valid(int x, int y) { return x >= 0 && y >= 0 && x < n && y < m; }
int dfs(int x, int y) {
done[x][y] = 1;
int cnt = 0;
for (int i = 0; i < 4; ++i) {
int xx = x + dx[i], yy = y + dy[i];
if (!valid(xx, yy) || done[xx][yy]) continue;
if (a[xx][yy] == '.') {
cnt += dfs(xx, yy);
} else {
++cnt;
}
}
return cnt;
}
void dfs2(int x, int y, int cnt) {
vis[x][y] = T;
memo[x][y] = cnt;
for (int i = 0; i < 4; ++i) {
int xx = x + dx[i], yy = y + dy[i];
if (!valid(xx, yy) || vis[xx][yy] == T || a[xx][yy] == '*') continue;
dfs2(xx, yy, cnt);
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; ++i) scanf("%s", a[i]);
while (k--) {
int x, y;
scanf("%d %d", &x, &y);
--x, --y;
if (done[x][y]) {
printf("%d\n", memo[x][y]);
continue;
}
int cnt = dfs(x, y);
printf("%d\n", cnt);
dfs2(x, y, cnt);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 305;
map<string, int> mp;
string s;
int id[N], sum[N];
int n, cnt, ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
cin >> s;
if (!mp.count(s)) mp[s] = ++cnt;
id[i] = mp[s];
sum[i] = sum[i - 1] + s.size();
}
ans = sum[n] + n - 1;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
int len = j - i, cnt = 0;
for (int k = j + 1; k + len <= n; k++) {
bool f = true;
for (int x = 0; x <= len; x++)
if (id[i + x] != id[k + x]) {
f = false;
break;
}
if (f) {
cnt++;
k += len;
}
}
if (cnt)
ans = min(ans, sum[n] - (cnt + 1) * (sum[j] - sum[i - 1]) + cnt + n);
}
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[15][50];
int m;
int c[15];
int numWrong[15];
map<vector<int>, int> M;
long long res = 0;
void Find(int limit, int pos, string cur, bool isCheck) {
int maxNumWrong = 0;
for (int i = 1; i <= m; i++)
if (numWrong[i] > c[i]) return;
if (pos == limit) {
vector<int> cur;
for (int i = 1; i <= m; i++)
if (isCheck)
cur.push_back(c[i] - numWrong[i]);
else
cur.push_back(numWrong[i]);
if (isCheck) {
res += M[cur];
} else {
M[cur]++;
}
return;
}
for (int val = 0; val <= 1; val++) {
for (int i = 1; i <= m; i++) {
if (a[i][pos] == val) numWrong[i]++;
}
Find(limit, pos + 1, cur + (char)(val + '0'), isCheck);
for (int i = 1; i <= m; i++) {
if (a[i][pos] == val) numWrong[i]--;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
string s;
cin >> s;
for (int j = 0; j < s.size(); j++) {
a[i][j] = (int)(s[j] - '0');
}
cin >> c[i];
}
int mid = n / 2;
Find(mid, 0, "", false);
for (int i = 1; i <= m; i++) numWrong[i] = 0;
Find(n, mid, "", true);
cout << res;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string itosm(long long x) {
if (x == 0) return "0";
string res = "";
while (x > 0) {
res += ((x % 10) + '0');
x /= 10;
}
reverse(res.begin(), res.end());
return res;
}
long long stoim(string str) {
long long res = 0;
int p = 0;
if (str[0] == '-') p++;
for (int i = p; i < str.length(); i++) {
res *= 10;
res += (str[i] - '0');
}
return res;
}
const long long infll = 1e18 + 3;
const int inf = 1009000999;
const long double eps = 1e-7;
const int maxn = 1.5e7 + 1146;
const int baseint = 1000200013;
const long long basell = 1e18 + 3;
const long double PI = acos(-1.0);
const long long mod = 998244353;
long long binpow(long long x, long long st) {
if (st == 0) return 1;
if (st & 1) return binpow(x, st - 1) * x % mod;
long long res = binpow(x, st >> 1);
return res * res % mod;
}
map<int, int> m;
int cnt[30];
vector<int> p;
void solve() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string a;
cin >> a;
for (int j = 0; j < 30; j++) cnt[j] = 0;
for (char c : a) cnt[c - 'a']++;
int x = 0;
for (int j = 0; j < 30; j++)
if (cnt[j] & 1) x += (1 << j);
m[x]++;
p.push_back(x);
}
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += (m[p[i]] - 1);
for (int j = 0; j < 30; j++) ans += (m[p[i] ^ (1 << j)]);
}
cout << ans / 2;
}
int main() {
srand(time(0));
ios_base::sync_with_stdio(0);
;
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 100;
const int inf = 0x3f3f3f3f3f;
const int mod = 1e9 + 7;
inline void add(long long &a, long long b) {
a += b;
if (a >= mod) a -= mod;
}
inline void sub(long long &a, long long b) {
a -= b;
if (a < 0) a += mod;
}
inline long long mul1(long long a, long long b) {
return (long long)((unsigned long long)a * b % mod);
}
inline long long mul2(long long a, long long b, long long x) {
long long ans = 0;
while (b) {
if (b & 1) ans = (ans + a) % x;
b >>= 1, a = (a << 1) % x;
}
return ans;
}
inline long long mpow(long long a, long long p) {
long long res = 1;
if (p < 0) return mpow(a, mod + p - 1);
if (p == 0) return 1;
if (p == 1) return a;
while (p) {
if (p & 1) res = res * a % mod;
p >>= 1;
a = a * a % mod;
}
return res;
}
long long fac[maxn], fac_inv[maxn], inv[maxn];
void getinv() {
const long long nn = 1e6;
fac[0] = 1, fac[1] = 1;
for (long long i = 1; i <= nn; i++) fac[i] = fac[i - 1] * i % mod;
fac_inv[nn] = mpow(fac[nn], mod - 2);
for (long long i = nn; i > 0; i--) fac_inv[i - 1] = fac_inv[i] * i % mod;
for (long long i = 1; i <= nn; i++) inv[i] = fac_inv[i] * fac[i - 1] % mod;
}
int main() {
long long n, m, a, b;
cin >> n >> m >> a >> b;
getinv();
long long ans = 0;
for (int i = 1; i <= min(n - 1, m); i++) {
long long ret = fac[n - 2] * fac_inv[n - i - 1] % mod * (i + 1) % mod *
mpow(n, n - i - 2) % mod * fac[m - 1] % mod *
fac_inv[m - i] % mod * fac_inv[i - 1] % mod *
mpow(m, n - i - 1) % mod;
ans += ret;
ans %= mod;
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int bpow(long long int a, long long int b) {
if (b == 0) return 1;
long long int res = bpow(a, b / 2);
if (b % 2)
return res * res * a;
else
return res * res;
}
long long int bpowm(long long int x, long long int y, long long int m) {
long long int res = 1;
x = x % m;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % m;
y = y >> 1;
x = (x * x) % m;
}
return res;
}
long long int solve() {
string s;
cin >> s;
vector<long long int> a;
long long int n = s.size(), count = 0;
for (long long int i = 0; i < n; i++) {
if (s[i] == 'b') {
if (count > 0) a.push_back(count);
count = 0;
} else if (s[i] == 'a') {
count++;
}
}
if (count > 0) a.push_back(count);
long long int ans = 1;
for (auto x : a) {
ans *= (x + 1);
ans %= 1000000007;
}
ans -= 1;
ans %= 1000000007;
cout << ans << "\n";
return 0;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int P = 1000000007;
int solve(int x, int y, int z) {
std::vector<std::pair<int, int>> f(8);
f[7] = std::make_pair(0, 1);
for (int l = 30; l >= 0; --l) {
std::vector<std::pair<int, int>> g(8);
int xl = x >> l & 1, yl = y >> l & 1, zl = z >> l & 1;
for (int S = 0; S < 8; ++S) {
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
int k = i ^ j;
if (S & 1 && i > xl) {
continue;
}
if (S & 2 && j > yl) {
continue;
}
if (S & 4 && k > zl) {
continue;
}
int T = S & ((i == xl) | (j == yl) << 1 | (k == zl) << 2);
g[T].second = (g[T].second + f[S].second) % P;
g[T].first =
(g[T].first + f[S].first + 1ll * (k << l) * f[S].second) % P;
}
}
}
f.swap(g);
}
return (f[0].first + f[0].second) % P;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int T;
std::cin >> T;
while (T--) {
int sx, sy, tx, ty, v;
std::cin >> sx >> sy >> tx >> ty >> v;
--sx, --sy;
int ans = (solve(tx, ty, v) - solve(sx, ty, v) - solve(tx, sy, v) +
solve(sx, sy, v)) %
P;
std::cout << (ans + P) % P << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long x, n, m;
cin >> x >> n >> m;
if (x - m * 10 <= 0) {
cout << "YES" << endl;
continue;
}
while (n--) {
x = floor(x / 2) + 10;
}
x -= (m * 10);
if (x <= 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[2333333];
int main() {
int n, m;
scanf("%d%d", &n, &m);
n = (1 << n);
double sum = 0;
for (int i = 0; i < n; i++) scanf("%d", &a[i]), sum += a[i];
printf("%.6f\n", sum / n);
for (int i = 0; i < m; i++) {
int p, x;
scanf("%d%d", &p, &x);
sum -= a[p];
sum += x;
a[p] = x;
printf("%.6f\n", sum / n);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, n, m, count = 0;
cin >> n >> m;
int a[m];
int k = 0;
for (i = 0; i < m; i++) cin >> a[i];
i = 0;
while (k < m) {
if (a[k] > i) {
count += a[k] - 1 - i;
i = a[k] - 1;
} else {
count += n - i - 1 + a[k];
if (a[k] - 1 == i)
i = n - 1;
else
i = a[k] - 1;
}
k++;
}
cout << count << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 100005;
long long int mod = 998244353;
const long double pi = 3.14159265359;
mt19937_64 rang(
chrono::high_resolution_clock::now().time_since_epoch().count());
int rng(int lim) {
uniform_int_distribution<int> uid(0, lim - 1);
return uid(rang);
}
void fastIO(void);
void decimal(int);
long long int modmulti(long long int, long long int);
long long int modadd(long long int, long long int);
long long int modpower(long long int, long long int);
long long int gcd(long long int, long long int);
long long int modinv(long long int);
long long int a[N], b[N];
long long int n;
long long int solve1(long long int l, long long int r, long long int val) {
if (val > a[r]) return r + 1;
if (val < a[l]) return l - 1;
if (l == r) return l;
long long int m = (l + r) / 2;
if (val <= a[m]) return solve1(l, m, val);
return solve1(m + 1, r, val);
}
long long int solve2(long long int l, long long int r, long long int val) {
if (val > b[r]) return r + 1;
if (val < b[l]) return l - 1;
if (l == r) return l;
long long int m = (l + r) / 2;
if (val <= b[m]) return solve2(l, m, val);
return solve2(m + 1, r, val);
}
long long int query(long long int t) {
long long int s1 = 0, s2 = 0;
long long int ca = 0, cb = 0;
long long int prev = 0;
long long int last = -1;
while (prev != n) {
if (a[n - 1] < ca + t && b[n - 1] < cb + t) return 0;
long long int t1, t2;
t1 = solve1(prev, n - 1, ca + t);
t2 = solve2(prev, n - 1, cb + t);
if (t1 > t2) {
s2++;
last = 2;
} else {
s1++;
last = 1;
}
if (t1 > t2) swap(t1, t2);
prev = t1 + 1;
ca = a[t1];
cb = b[t1];
}
long long int x = abs(s1 - s2);
if (s1 == s2) return 0;
if (s1 > s2 && last == 2) return 0;
if (s2 > s1 && last == 1) return 0;
return max(s1, s2);
}
bool comp(pair<long long int, long long int> p1,
pair<long long int, long long int> p2) {
if (p1.first != p2.first) return p1.first < p2.first;
return p1.second < p2.second;
}
int main() {
fastIO();
cin >> n;
long long int x;
cin >> x;
if (x == 1) {
a[0] = 1;
b[0] = 0;
} else {
a[0] = 0;
b[0] = 1;
}
for (long long int i = 1; i < n; i++) {
cin >> x;
a[i] = a[i - 1];
b[i] = b[i - 1];
if (x == 1)
a[i]++;
else
b[i]++;
}
vector<long long int> t, s;
for (long long int i = 1; i < n + 1; i++) {
x = query(i);
if (x != 0) {
t.push_back(i);
s.push_back(x);
}
}
vector<pair<long long int, long long int> > v;
for (long long int i = 0; i < t.size(); i++) {
v.push_back({s[i], t[i]});
}
sort(v.begin(), v.end(), comp);
cout << t.size() << "\n";
for (long long int i = 0; i < t.size(); i++) {
cout << v[i].first << " " << v[i].second << "\n";
}
}
void fastIO(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
void decimal(int n) {
cout << fixed;
cout << setprecision(n);
}
long long int modmulti(long long int a, long long int b) {
return ((a % mod) * 1ll * (b % mod)) % mod;
}
long long int modadd(long long int a, long long int b) {
long long int asdfgh = ((a % mod) + (b % mod) + mod + mod) % mod;
asdfgh = (asdfgh + mod) % mod;
return asdfgh;
}
long long int modpower(long long int a, long long int n) {
if (n == 0) return 1;
if (n == 1) return a % mod;
long long int b = modpower(a, n / 2);
b = modmulti(b, b);
if (n % 2 == 0) return b;
return modmulti(a, b);
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int modinv(long long int a) { return modpower(a, mod - 2); }
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int min = 1001, a, b, t;
for (int i = 0; i < 4; i++) {
cin >> t;
if (t < min) min = t;
}
cin >> a >> b;
if (min <= a)
cout << 0;
else if (min > b)
cout << b - a + 1;
else
cout << min - a;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i;
string s;
cin >> s;
string ans;
int len = s.size();
for (i = 0; i < len; i++) {
if (i < len - 1 && s[i] == 'a' && s[i + 1] == 't') {
ans.push_back('@');
i++;
} else if (i < len - 2 && s[i] == 'd' && s[i + 1] == 'o' &&
s[i + 2] == 't') {
ans.push_back('.');
i = i + 2;
} else
ans.push_back(s[i]);
}
int flag = 0;
len = ans.size();
for (i = 0; i < len; i++) {
if ((i == 0 || i == len - 1) && ans[i] == '.')
cout << "dot";
else if ((i == 0 || i == len - 1) && ans[i] == '@')
cout << "at";
else if (ans[i] == '@') {
if (flag == 0) {
cout << ans[i];
flag++;
} else
cout << "at";
} else
cout << ans[i];
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline long long mmul(long long a, long long b) { return (a * b) % 1000000007; }
priority_queue<int> buy;
priority_queue<int, vector<int>, greater<int>> sell;
vector<int> middle;
int cnt = 1;
void add(int p) {
if (!buy.empty() && p < buy.top()) {
buy.push(p);
} else if (!sell.empty() && p > sell.top()) {
sell.push(p);
} else {
middle.push_back(p);
}
}
void accept(int p) {
if (!buy.empty() && p < buy.top()) {
cnt = 0;
return;
}
if (!sell.empty() && p > sell.top()) {
cnt = 0;
return;
}
for (int p0 : middle) {
if (p0 < p)
buy.push(p0);
else if (p0 > p)
sell.push(p0);
}
middle.clear();
if (!buy.empty() && p == buy.top())
buy.pop();
else if (!sell.empty() && p == sell.top())
sell.pop();
else
cnt = (int)mmul(cnt, 2);
}
int main() {
int n;
cin >> n;
string action;
int p;
for (int i = 0; i < n; i++) {
cin >> action >> p;
if (action == "ADD")
add(p);
else
accept(p);
}
cnt = (int)mmul(cnt, (int)middle.size() + 1);
cout << cnt << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acosl(-1);
const int maxn = 200010;
const long long mod = 1e9 + 7;
const long long inf = 1e18;
const long double eps = 1e-10;
int n, m, q, u, v, w, a[maxn], b[maxn];
long long f[maxn];
struct {
long long mini, add;
} tree[4 * maxn];
long long bit[maxn];
vector<pair<int, int> > g[maxn];
void add(int l, int r, int L, int R, int cur, long long x) {
if (l >= L && r <= R) {
tree[cur].add += x, tree[cur].mini += x;
return;
}
if (l > R || r < L) return;
int mid = (l + r) / 2;
if (L <= mid) add(l, mid, L, R, 2 * cur, x);
if (mid < R) add(mid + 1, r, L, R, 2 * cur + 1, x);
tree[cur].mini =
tree[cur].add + min(tree[2 * cur].mini, tree[2 * cur + 1].mini);
}
long long query(int l, int r, int L, int R, int cur, long long x) {
if (l >= L && r <= R) {
return tree[cur].mini + x;
}
long long ret = inf;
if (l > R || r < L) return ret;
int mid = (l + r) / 2;
if (L <= mid) ret = min(query(l, mid, L, R, 2 * cur, x + tree[cur].add), ret);
if (mid < R)
ret = min(query(mid + 1, r, L, R, 2 * cur + 1, x + tree[cur].add), ret);
return ret;
}
void init() {
for (int i = 1; i < n; i++) add(0, n, i, i, 1, b[i]);
for (int i = 1; i < n + 1; i++) {
for (pair<int, int> pa : g[i]) add(0, n, 0, pa.first - 1, 1, pa.second);
f[i] = query(0, n, 0, n - 1, 1, 0);
f[i] += a[i];
}
memset(tree, 0, sizeof(tree));
for (int i = 1; i < n + 1; i++) add(1, n, i, i, 1, f[i]);
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i < n; i++) scanf("%d%d", a + i, b + i);
for (int i = 0; i < m; i++)
scanf("%d%d%d", &u, &v, &w), g[u].push_back({v, w});
init();
printf("%lld\n", query(1, n, 1, n, 1, 0));
for (int i = 0; i < q; i++) {
scanf("%d%d", &v, &w);
add(1, n, v, v, 1, w - a[v]);
a[v] = w;
printf("%lld\n", query(1, n, 1, n, 1, 0));
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
string ans;
cin >> s;
int val[10];
for (int i = 0; i < 10; i++) val[i] = 0;
int size = s.length();
for (int i = 0; i < size; i++) {
val[s[i] - '0'] += 1;
}
val[1] -= 1;
val[6] -= 1;
val[8] -= 1;
val[9] -= 1;
for (int i = 1; i < 10; i++) {
for (int j = 0; j < val[i]; j++) {
ans += (i + '0');
}
}
int size2 = ans.length();
int mod = 0;
int fact = 10000 % 7;
for (int i = (size2 - 1); i >= 0; i--) {
mod += (fact * ((int)(ans[i] - '0')));
mod = mod % 7;
fact = (fact * 10) % 7;
}
if (mod) mod = (7 - mod);
string tp[7];
tp[0] = "1869";
tp[1] = "1968";
tp[2] = "1689";
tp[3] = "6198";
tp[4] = "8691";
tp[5] = "1986";
tp[6] = "1896";
ans += tp[mod];
for (int i = 0; i < val[0]; i++) ans += '0';
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, k;
bool feasible() {
if ((n * m) % k == 0) return true;
if (k % 2 == 0 && (n * m) % k == k / 2) return true;
return false;
}
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
cin >> n >> m >> k;
if (feasible()) {
cout << "YES" << endl;
long long int target = (2 * n * m) / k;
long long int tmp = gcd(n, k);
int potential_n = n / tmp;
k /= tmp;
tmp = gcd(m, k);
int potential_m = m / tmp;
k /= tmp;
if (k == 2) {
cout << 0 << ' ' << 0 << endl;
cout << potential_n << ' ' << 0 << endl;
cout << 0 << ' ' << potential_m << endl;
} else {
if (potential_n * 2 <= n)
potential_n *= 2;
else
potential_m *= 2;
cout << 0 << ' ' << 0 << endl;
cout << potential_n << ' ' << 0 << endl;
cout << 0 << ' ' << potential_m << endl;
}
} else
cout << "NO" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2,fma,tune=native")
template <typename T>
void print(T&& x) {
cout << x << "\n";
}
template <typename T, typename... S>
void print(T&& x, S&&... y) {
cout << x << ' ';
print(y...);
}
const long long Mod = 1000000007, Mod2 = 998244353;
const long long MOD = Mod2;
const long long maxn = 300005;
long long n, a[maxn], q;
void orzck() {
cin >> n >> q;
a[0] = n;
for (long long i = (0); i < ((long long)(n)); i++) {
char c;
cin >> c;
a[i + 1] = a[i] + (c == '+' ^ (i & 1) ? 1 : -1);
}
while (q--) {
long long l, r;
cin >> l >> r;
l--;
if (a[l] == a[r])
print(0);
else if ((l ^ r) & 1)
print(1);
else
print(2);
}
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cout << fixed << setprecision(15);
long long t;
cin >> t;
while (t--) orzck();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
int sm, ff, ss, x;
int main() {
cin >> s;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '#') sm++;
if (s[i] == '(') ff++;
if (s[i] == ')') ss++;
if (ss + sm > ff || s[s.size() - 1] == '(') {
cout << -1;
return 0;
}
}
x = sm - 1;
if (ff <= ss) {
cout << -1;
return 0;
}
int sq = 0, Sf = 0, Sj = 0;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '#') sq++;
if (s[i] == '(') Sf++;
if (s[i] == ')') Sj++;
if (sq == sm && s[i] == '#' && Sj + (ff - ss - x) > Sf) {
cout << -1;
return 0;
}
}
while (--sm) cout << 1 << "\n";
cout << ff - ss - x;
exit(0);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const long long MOD = 1e9 + 7;
const double EPS = (1e-8);
const int OO = (int)1e9 + 7;
const long long OOO = (long long)1e15 + 7;
const int mxn = 100009;
char c1, c2, c3, c4;
string s, s1, s2, s3;
int n, m, k, t = 1, q, a, b, c, d, e, x, y, z;
int sol = 0;
vector<int> g[222];
pair<int, int> edg[222];
int leaf(int v, int p) {
queue<pair<int, int> > q;
q.push({v, p});
int ret, node, par;
while (!q.empty()) {
par = q.front().second;
node = q.front().first;
q.pop();
for (auto i : g[node]) {
if (i == par) continue;
q.push({i, node});
}
}
queue<pair<pair<int, int>, int> > q2;
q2.push({{node, 0}, 0});
while (!q2.empty()) {
node = q2.front().first.first;
par = q2.front().first.second;
ret = q2.front().second;
q2.pop();
for (auto i : g[node]) {
if (i == p || i == par) continue;
q2.push({{i, node}, ret + 1});
}
}
return ret;
}
void pre() {}
void solve() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
edg[i] = {a, b};
g[a].push_back(b);
g[b].push_back(a);
}
sol = 0;
for (int i = 0; i < n - 1; i++) {
a = edg[i].first;
b = edg[i].second;
x = leaf(a, b);
y = leaf(b, a);
sol = max(sol, x * y);
}
cout << sol;
}
int main() {
fast();
pre();
while (t--) {
solve();
}
cout << endl << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0;
cin >> n >> m;
string x, z;
cin >> x >> z;
if ((x[0] == '<' && z[0] == '^') || (x[0] == '>' && z[m - 1] == '^') ||
(x[n - 1] == '<' && z[0] == 'v') ||
(x[n - 1] == '>' && z[m - 1] == 'v')) {
cout << "NO";
return 0;
}
cout << "YES";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long mod(long long a, long long b) {
if (a % b < 0) {
return a % b + b;
}
return a % b;
}
long long mod_exp(long long a, long long b, long long c) {
long long res = 1;
a = a % c;
while (b > 0) {
if (b % 2 == 1) {
res = (res * a) % c;
}
b /= 2;
a = (a * a) % c;
}
return res;
}
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
bool prime[3001];
void SieveOfEratosthenes() {
memset(prime, true, sizeof(prime));
prime[1] = false;
for (int p = 2; p * p <= 3000; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= 3000; i += p) prime[i] = false;
}
}
}
long long powe[20];
void power() {
powe[0] = 1;
for (long long i = 1; i < 20; i++) {
powe[i] = (powe[i - 1] * 10) % 1000000007;
if (powe[i] < 0) powe[i] += 1000000007;
}
}
long long func(long long A[], long long n) {
long long lis[n];
lis[0] = 1;
for (long long i = 0; i < n; i++) {
lis[i] = 1;
}
return lis[0];
}
void solve() {
long long a, b, c;
cin >> a >> b >> c;
if ((c >= b && b >= a) || (a >= b && b >= c)) {
if (a >= b && b >= c) {
swap(a, c);
}
while (b > (a + c) / 2) {
b--;
a++;
}
while (b < (a + c) / 2) {
b++;
c--;
}
cout << ((((a > b) ? a : b) > c) ? ((a > b) ? a : b) : c) << "\n";
return;
}
}
int main() {
long long n, a, b, c;
cin >> n;
cout << "\n? 1 2\n";
fflush(stdout);
cin >> a;
cout << "? 2 3\n";
fflush(stdout);
cin >> b;
cout << "? 1 3\n";
fflush(stdout);
cin >> c;
long long A[n];
A[0] = (a + c - b) / 2;
A[1] = a - A[0];
A[2] = c - A[0];
for (long long i = 3; i < n; i++) {
cout << "? 1 " << i + 1 << "\n";
fflush(stdout);
cin >> a;
A[i] = a - A[0];
}
cout << "! ";
for (long long i = 0; i < n; i++) {
cout << A[i] << " ";
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.