solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long INF = LLONG_MAX;
const long long mod = 1000000007;
const double pi = 3.14159265358979323846;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long divmod(long long a, long long b) {
return a * powmod(b, mod - 2) % mod;
}
const int nax = 2e5 + 10;
long long sum[4 * nax];
long long mn[4 * nax];
long long mx[4 * nax];
long long lazy[4 * nax];
void build(vector<long long>& arr, int id, int tl, int tr) {
if (tr - tl == 1) {
mn[id] = mx[id] = sum[id] = arr[tl];
} else {
int mid = (tr + tl) / 2;
build(arr, id * 2, tl, mid);
build(arr, id * 2 + 1, mid, tr);
mn[id] = min(mn[id * 2], mn[id * 2 + 1]);
mx[id] = max(mx[id * 2], mx[id * 2 + 1]);
sum[id] = sum[id * 2] + sum[id * 2 + 1];
}
}
void add_lazy(int id, long long len, long long val) {
mn[id] = val;
mx[id] = val;
sum[id] = val * len;
lazy[id] = val;
}
void shift(int id, int tl, int tr) {
if (!lazy[id]) return;
int mid = (tl + tr) / 2;
add_lazy(id * 2, mid - tl, lazy[id]);
add_lazy(id * 2 + 1, tr - mid, lazy[id]);
lazy[id] = 0;
}
void update(int id, int tl, int tr, int pos, long long val) {
if (pos <= tl || mn[id] >= val) return;
if (tr <= pos && mx[id] <= val) {
add_lazy(id, tr - tl, val);
return;
}
shift(id, tl, tr);
int mid = (tl + tr) / 2;
update(id * 2, tl, mid, pos, val);
update(id * 2 + 1, mid, tr, pos, val);
mn[id] = min(mn[id * 2], mn[id * 2 + 1]);
mx[id] = max(mx[id * 2], mx[id * 2 + 1]);
sum[id] = sum[id * 2] + sum[id * 2 + 1];
}
long long sumQuery(int id, int tl, int tr, int l, int r) {
if (r <= tl || tr <= l) return 0;
if (l <= tl && tr <= r) {
return sum[id];
}
shift(id, tl, tr);
int mid = (tl + tr) / 2;
return sumQuery(id * 2, tl, mid, l, r) + sumQuery(id * 2 + 1, mid, tr, l, r);
}
long long minQuery(int id, int tl, int tr, int l, int r) {
if (r <= tl || tr <= l) return INT_MAX;
if (l <= tl && tr <= r) {
return mn[id];
}
shift(id, tl, tr);
int mid = (tl + tr) / 2;
return min(minQuery(id * 2, tl, mid, l, r),
minQuery(id * 2 + 1, mid, tr, l, r));
}
int binarySearch1(int x, long long money, int n) {
int l = x;
int r = n + 1;
while (l < r) {
int mid = (l + r) / 2;
if (minQuery(1, 1, n + 1, 1, mid + 1) <= money)
r = mid;
else
l = mid + 1;
}
return l;
}
int binarySearch2(int start, long long money, int n) {
int l = start + 1;
int r = n + 1;
while (l < r) {
int mid = (l + r + 1) / 2;
if (sumQuery(1, 1, n + 1, start, mid) <= money)
l = mid;
else
r = mid - 1;
}
return l;
}
int query2(int id, int tl, int tr, int l, int r, long long& val) {
if (val < mn[id]) return 0;
if (r <= tl || tr <= l) return 0;
if (l <= tl && tr <= r && sum[id] <= val) {
val -= sum[id];
return tr - tl;
}
shift(id, tl, tr);
int mid = (tl + tr) / 2;
return query2(id * 2, tl, mid, l, r, val) +
query2(id * 2 + 1, mid, tr, l, r, val);
}
void solve() {
int n, q;
cin >> n >> q;
vector<long long> a(n + 2);
for (int i = (1); i < (n + 1); ++i) cin >> a[i];
build(a, 1, 1, n + 1);
for (int i = (0); i < (q); ++i) {
int type, x;
long long y;
cin >> type >> x >> y;
if (type == 1) {
update(1, 1, n + 1, x + 1, y);
} else {
cout << query2(1, 1, n + 1, x, n + 1, y) << endl;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1000000;
int vis[maxn];
int n, m;
int sum = 0;
set<int> ns;
vector<int> v[maxn];
void dfs(int x) {
printf("%d ", x);
sum++;
ns.erase(x);
vis[x] = 1;
if (sum == n) return;
int kk = 0;
int qw = v[x].size();
for (int i = 0; i < qw; i++) {
kk = v[x][i];
if (vis[kk] == 0) ns.insert(kk);
}
int ny = *ns.begin();
dfs(ny);
}
int main() {
scanf("%d%d", &n, &m);
ns.insert(1);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n = 2 * n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = 0; i < n - 1; i = i + 2) {
for (int j = i + 1; j < n; j++) {
if (a[i] == a[j]) {
for (int k = j; k >= i + 2; k--) {
swap(a[k], a[k - 1]);
ans++;
}
break;
}
}
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = (long long)1e15;
const long double eps = 1e-12;
const long long N = (int)1e5 + 5;
const long long LOGN = 19;
const long double PI = 3.14159265358979323846;
long long mul(long long a, long long b, long long m = mod) {
return (long long)(a * b) % m;
}
long long add(long long a, long long b, long long m = mod) {
a += b;
if (a >= m) a -= m;
if (a < 0) a += m;
return a;
}
long long power(long long a, long long b, long long m = mod) {
if (b == 0) return 1;
if (b == 1) return (a % m);
long long x = power(a, b / 2, m);
x = mul(x, x, m);
if (b % 2) x = mul(x, a, m);
return x;
}
int n, m, k;
int c[111];
vector<int> a[111];
long long dp[111][111][111];
long long rec(int pos, int groups, int curr) {
if (pos >= n) {
if (groups == k)
return 0;
else
return inf;
}
if (curr != -1 && dp[pos][groups][curr] != -1) return dp[pos][groups][curr];
if (c[pos] != 0) {
if (c[pos] == curr)
return dp[pos][groups][curr] = rec(pos + 1, groups, curr);
else
return dp[pos][groups][curr] = rec(pos + 1, groups + 1, c[pos]);
}
long long to = inf;
for (int i = 1; i <= m; i++) {
if (i == curr) {
to = min(to, rec(pos + 1, groups, curr) + a[pos][i - 1]);
} else
to = min(to, rec(pos + 1, groups + 1, i) + a[pos][i - 1]);
}
return dp[pos][groups][curr] = to;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
if (0) {
freopen("C:\\Users\\Dishant\\Desktop\\Collection-DEV c++\\input.txt", "r",
stdin);
freopen("C:\\Users\\Dishant\\Desktop\\Collection-DEV c++\\output.txt", "w",
stdout);
}
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < n; i++) {
a[i].resize(m);
for (int j = 0; j < m; j++) cin >> a[i][j];
}
for (int i = 0; i < 111; i++) {
for (int j = 0; j < 111; j++) {
for (int k = 0; k < 111; k++) dp[i][j][k] = -1;
}
}
long long ans = inf;
ans = rec(0, 0, -1);
if (ans == inf || ans < 0)
cout << "-1";
else
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string solve(string& input) {
string int_part = "";
string dec_part = "";
string b_part = "";
int st = -1;
for (int i = 0; i < input.size(); i++) {
if (input[i] == '.') {
st = i + 1;
break;
}
int_part += input[i];
}
for (int i = st; i < input.size(); i++) {
if (input[i] == 'e') {
st = i + 1;
break;
}
dec_part += input[i];
}
for (int i = st; i < input.size(); i++) {
b_part += input[i];
}
istringstream iss(b_part);
int num_b;
iss >> num_b;
for (int i = 0; i < min(num_b, (int)dec_part.size()); i++) {
int_part += dec_part[i];
}
if (dec_part.size() == num_b) {
return int_part;
}
if (dec_part.size() < num_b) {
int rem = num_b - dec_part.size();
for (int i = 0; i < rem; i++) {
int_part += "0";
}
return int_part;
}
string rem_dec = "";
for (int i = num_b; i < dec_part.size(); i++) {
rem_dec += dec_part[i];
}
if (rem_dec.size() == 1 && rem_dec[0] == '0') {
return int_part;
}
int_part += '.';
int_part += rem_dec;
return int_part;
}
string process(string input) {
for (int i = 0; i < input.size(); i++) {
if (input[i] != '0') {
return input.substr(i);
}
}
}
int main() {
string input = "";
cin >> input;
string res = solve(input);
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f;
const double eps = 1e-8;
const long long mod = 1000000007;
const double pi = acos(-1);
inline void gn(long long& x) {
long long sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long powmod(long long a, long long x, long long mod) {
long long t = 1ll;
while (x) {
if (x & 1) t = t * a % mod;
a = a * a % mod;
x >>= 1;
}
return t;
}
const long long maxn = 55;
long long n, m, x;
long long v[maxn][maxn];
vector<pair<long long, long long> > E;
struct Edge {
long long from, to, cap, flow;
Edge(long long u, long long v, long long c, long long f)
: from(u), to(v), cap(c), flow(f) {}
};
struct EdmondsKarp {
long long n, m;
vector<Edge> edges;
vector<long long> G[maxn];
long long p[maxn];
long long a[maxn];
void init(long long n) {
for (long long i = 0; i < n; i++) G[i].clear();
edges.clear();
}
void AddEdge(long long from, long long to, long long cap) {
edges.push_back(Edge(from, to, cap, 0));
edges.push_back(Edge(to, from, 0, 0));
m = edges.size();
G[from].push_back(m - 2);
G[to].push_back(m - 1);
}
long long Maxflow(long long s, long long t) {
long long flow = 0;
for (;;) {
memset(a, 0, sizeof(a));
queue<long long> Q;
Q.push(s);
a[s] = inf;
while (!Q.empty()) {
long long x = Q.front();
Q.pop();
for (long long i = 0; i < G[x].size(); i++) {
Edge& e = edges[G[x][i]];
if (!a[e.to] && e.cap > e.flow) {
p[e.to] = G[x][i];
a[e.to] = ((a[x]) < (e.cap - e.flow) ? (a[x]) : (e.cap - e.flow));
Q.push(e.to);
}
}
if (a[t]) break;
}
if (!a[t]) break;
for (long long u = t; u != s; u = edges[p[u]].from) {
edges[p[u]].flow += a[t];
edges[p[u] ^ 1].flow -= a[t];
}
flow += a[t];
}
return flow;
}
} flow;
int main() {
gn(n);
gn(m);
gn(x);
long long tot = 0;
long long a, b, c;
for (long long i = (1); i <= (m); i++) {
gn(a);
gn(b);
gn(c);
tot += c;
E.push_back(make_pair(a, b));
v[a][b] = c;
}
double l = 0, r = tot;
;
for (long long k = (1); k <= (200); k++) {
double mid = (l + r) / 2;
double ech = mid / x;
flow.init(n);
for (long long i = 0; i < E.size(); ++i) {
long long f = (long long)(v[E[i].first][E[i].second] / ech);
flow.AddEdge(E[i].first, E[i].second, f);
}
long long cnt = flow.Maxflow(1, n);
if (cnt >= x)
l = mid;
else
r = mid;
}
printf("%.12lf\n", l);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 400 + 10;
int n, m, adj[Maxn][Maxn], dis[Maxn];
bool mark[Maxn];
queue<int> q;
void bfs(int v, int a) {
q.push(v);
mark[v] = true;
while (!q.empty()) {
int u = q.front();
for (int i = 0; i < n; i++)
if (!mark[i] && adj[u][i] == a) {
q.push(i);
dis[i] = dis[u] + 1;
mark[i] = true;
}
q.pop();
}
}
int main() {
cin >> n >> m;
int u, v;
for (int i = 0; i < m; i++) {
scanf("%d%d", &u, &v);
u--;
v--;
adj[u][v] = adj[v][u] = 1;
}
if (adj[0][n - 1] == 1)
bfs(0, 0);
else
bfs(0, 1);
if (dis[n - 1] == 0)
cout << -1 << endl;
else
cout << dis[n - 1] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool fs(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
int l, n;
vector<long long> v;
bool ara[100009] = {false};
void rec() {
int i, j;
ara[0] = ara[1] = true;
for (i = 2; i * i <= 100000; i++) {
if (!ara[i]) {
for (j = i * 2; j <= 100000; j += i) ara[j] = true;
}
}
for (i = 2; i <= 100000; i++) {
if (ara[i] == false) v.push_back(i);
}
l = v.size();
}
int rec2(int a) {
int i;
for (i = 0; i < l && v[i] * v[i] <= a; i++) {
if (a % v[i] == 0) return 1;
}
return 0;
}
int main() {
rec();
fs(n);
if (n <= 5) {
printf("1\n%d\n", n);
return 0;
}
int a, b;
for (int i = 1; i < l && v[i] < n; i++) {
a = n - v[i];
a /= 2;
b = rec2(a);
if (b == 0) {
printf("3\n");
printf("%d %d %d\n", a, a, v[i]);
break;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &x) {
char c;
bool op = 0;
while (c = getchar(), c < '0' || c > '9')
if (c == '-') op = 1;
x = c - '0';
while (c = getchar(), c >= '0' && c <= '9') x = x * 10 + c - '0';
if (op) x = -x;
}
template <class T>
void write(T x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar('0' + x % 10);
}
const int N = 1000005;
int T, n, deg[4 * N], dis[4 * N];
int ecnt, adj[4 * N], nxt[8 * N], go[8 * N];
char s[N];
void init() {
ecnt = 0;
for (int i = 1; i <= n; i++) dis[i] = deg[i] = adj[i] = 0;
}
void add(int u, int v) {
go[++ecnt] = v;
nxt[ecnt] = adj[u];
adj[u] = ecnt;
deg[v]++;
}
void bi_add(int u, int v) { add(u, v), add(v, u); }
void repl(int u) {
int a = ++n, b = ++n, c = ++n;
bi_add(a, u), bi_add(a, b), bi_add(a, c);
}
void dfs(int u, int pre) {
for (int e = adj[u], v; e; e = nxt[e])
if ((v = go[e]) != pre) {
dis[v] = dis[u] + 1;
dfs(v, u);
}
}
void steal_data() {
for (int i = 1; i < 46; i++) {
read(n);
for (int j = 1, t; j < n; j++) read(t), read(t);
scanf("%s", s + 1);
}
read(n), write(n), putchar('\n');
for (int i = 1, t; i < n; i++)
read(t), write(t), putchar(' '), read(t), write(t), putchar('\n');
scanf("%s", s + 1);
printf("%s\n", s + 1);
}
int main() {
read(T);
while (T--) {
init();
read(n);
for (int i = 1, u, v; i < n; i++) read(u), read(v), bi_add(u, v);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++)
if (s[i] == 'W') repl(i);
int max_deg = 0, tar[3] = {0}, cur = 0;
bool ok = 1;
for (int i = 1; i <= n; i++) {
max_deg = max(max_deg, deg[i]);
if (deg[i] == 3) {
int cnt_deg1 = 0;
for (int e = adj[i]; e; e = nxt[e]) cnt_deg1 += deg[go[e]] == 1;
if (cnt_deg1 <= 1) ok = 0;
if (ok) {
if (cur == 2)
ok = 0;
else
tar[++cur] = i;
}
}
}
if (!ok || max_deg >= 4)
puts("White");
else if (cur <= 1)
puts("Draw");
else {
dfs(tar[1], 0);
if (dis[tar[2]] & 1)
puts("Draw");
else
puts("White");
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
int n, m;
map<int, int> dir;
char s[200][200];
bool ok;
int b[200];
void dfs(int x, int y, int i) {
if (x < 1) return;
if (x > n) return;
if (y < 1) return;
if (y > m) return;
if (s[x][y] == '#') return;
if (s[x][y] == 'E') {
ok = true;
return;
}
if (b[i] == -1) return;
int ii = dir[b[i]];
if (ii == 0) {
dfs(x - 1, y, i + 1);
} else if (ii == 1) {
dfs(x + 1, y, i + 1);
} else if (ii == 2) {
dfs(x, y - 1, i + 1);
} else {
dfs(x, y + 1, i + 1);
}
}
int main() {
cin >> n >> m;
int u, v;
for (int i = 1; i <= n; ++i) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= m; ++j) {
if (s[i][j] == 'S') {
u = i, v = j;
}
}
}
string si;
cin >> si;
for (int i = 0; i < si.size(); ++i) {
b[i] = si[i] - '0';
}
b[si.size()] = -1;
int a[4] = {0, 1, 2, 3};
int res = 0;
do {
for (int i = 0; i < 4; ++i) {
dir[a[i]] = i;
}
ok = false;
dfs(u, v, 0);
if (ok) {
res++;
}
} while (next_permutation(a, a + 4));
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
inline long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
inline long long int lcm(long long int a, long long int b) {
return a * b / gcd(a, b);
}
inline long long int add(long long int a, long long int b) {
return ((a % MOD) + (b % MOD)) % MOD;
}
inline long long int multi(long long int a, long long int b) {
return ((a % MOD) * (b % MOD)) % MOD;
}
inline long long int sub(long long int a, long long int b) {
a %= MOD;
b %= MOD;
a -= b;
if (a < 0) a += MOD;
return a;
}
inline long long int power(long long int a, long long int b) {
a %= MOD;
long long int res = 1;
while (b > 0) {
if (b & 1) {
res = multi(res, a);
}
a = multi(a, a);
b >>= 1;
}
return res;
}
bool isPrime(long long int x) {
if (x <= 4 || x % 2 == 0 || x % 3 == 0) {
return x == 2 || x == 3;
}
for (long long int i = 5; i * i <= x; i += 6) {
if (x % i == 0 || x % (i + 2) == 0) {
return 0;
}
}
return 1;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
if (n <= 1 || n % 2 == 0)
cout << -1;
else {
long long int ans = 0;
long long int arr[n + 1];
for (long long int i = 1; i <= n; i++) cin >> arr[i];
arr[0] = 0;
for (long long int i = n; i >= 3; i--) {
ans += arr[i];
if (i % 2 == 0) {
long long int x = i / 2;
arr[x] = max(0LL, arr[x] - arr[i]);
} else {
long long int x = (i - 1) / 2;
arr[x] = max(0LL, arr[x] - arr[i]);
arr[i - 1] = max(0LL, arr[i - 1] - arr[i]);
}
}
ans += max(arr[1], arr[2]);
cout << ans << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
template <class T>
using max_heap = priority_queue<T, vector<T>, less<T>>;
int solve2(const vector<string> &vec, char c) {
int n = vec.size();
vector<int> val(n);
for (int i = 0; i < n; i++) {
int bal = 0;
for (char ch : vec[i]) {
if (ch == c) {
bal++;
} else {
bal--;
}
}
val[i] = bal;
}
int t = 0, cur = 0;
sort((val).begin(), (val).end(), greater<int>());
for (int i = 0; i < n; i++) {
if (val[i] > 0 || cur + val[i] > 0) {
cur += val[i];
t++;
}
}
return t;
}
void solve() {
int n;
cin >> n;
vector<string> vec(n);
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
int ans = 0;
for (char i = 'a'; i <= 'e'; i++) {
ans = max(ans, solve2(vec, i));
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tc = 1;
cin >> tc;
for (int i = 1; i <= tc; i++) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int t, n;
int a[55];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
if (a[1] == a[n / 2 + 1])
cout << "Bob";
else
cout << "Alice";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int k, d;
int a[100000], b[100000];
int main() {
cin >> k;
for (int i = 0; i < k; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b, b + k);
for (int i = 0; i < k; i++) {
if (a[i] != b[i]) d++;
}
if ((d == 2) || (d == 0)) {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, arr[(int)1e5 + 2], c = 2, mx = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (i > 1 && arr[i] == arr[i - 1] + arr[i - 2])
c++;
else
mx = max(mx, c), c = 2;
}
if (n <= 2) return cout << n, 0;
return cout << max(mx, c), 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
const long long inf = 92233720368547758;
long long T = 1;
vector<vector<long long> > v;
long long n, m, x, y, k;
vector<long long> dp, vis, depth;
string s;
long long ceil_(long long x, long long y) {
if (x % y == 0) return x / y;
return (x / y) + 1;
}
long long floor_(long long x, long long y) { return x / y; }
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long fpow(long long a, long long b) {
return b ? fpow(a * a % mod, b / 2) * (b % 2 ? a : 1) % mod : 1;
}
long long power(float x, int y) {
float temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return temp * temp;
else {
if (y > 0)
return x * temp * temp;
else
return (temp * temp) / x;
}
}
string lower(string s) {
for (int i = 0; i < s.length(); i++) s[i] = tolower(s[i]);
return s;
}
long long inv(long long i) {
if (i == 1) return 1;
return (mod - (mod / i) * inv(mod % i) % mod) % mod;
}
void show_tree() {
for (int i = 1; i <= n; i++) {
for (int j = 0; j < v[i].size(); j++) cout << v[i][j] << " ";
cout << "\n";
}
}
void dfs(int i) {
vis[i] = 1;
for (auto u : v[i]) {
if (!vis[u]) dfs(u);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> T;
while (T--) {
cin >> n;
vector<pair<long long, long long> > v2;
for (int i = 0; i < n; i++) {
cin >> x;
v2.push_back({x, i});
}
sort((v2).begin(), (v2).end());
long long cnt = 1;
long long ans = 0;
for (int i = 1; i < n; i++) {
if (v2[i].second > v2[i - 1].second)
cnt++;
else {
ans = max(ans, cnt);
cnt = 1;
}
}
ans = max(ans, cnt);
cout << n - ans << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long str_to_int, sub_ans, t;
string s, sp;
char str2[6];
cin >> s;
str2[0] = s[0];
str2[1] = s[2];
str2[2] = s[4];
str2[3] = s[3];
str2[4] = s[1];
sp = str2;
stringstream x(sp);
x >> str_to_int;
sub_ans = str_to_int;
for (int i = 2; i <= 5; i++) {
str_to_int = str_to_int * sub_ans % 100000;
}
if (str_to_int == 0)
cout << "00000" << endl;
else
cout << str_to_int << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void oblivious() {
long long int a, b, c, r;
cin >> a >> b >> c >> r;
long long int a1 = min(a, b);
long long int a2 = max(a, b);
a = a1;
b = a2;
if (c >= a && c <= b) {
if (c + r <= b && c - r >= a) {
cout << b - a - 2 * r << endl;
} else if (c + r <= b) {
cout << b - c - r << endl;
} else if (c - r >= a) {
cout << c - r - a << endl;
} else if (2 * r >= abs(b - a)) {
cout << "0" << endl;
}
} else if (c < a) {
if (c + r >= a && c + r <= b) {
cout << b - c - r << endl;
} else if (c + r >= b) {
cout << "0" << endl;
} else if (c + r <= a) {
cout << b - a << endl;
}
} else if (c > b) {
if (c - r <= b && c - r >= a) {
cout << c - r - a << endl;
} else if (c - r <= a) {
cout << "0" << endl;
} else if (c - r >= b) {
cout << b - a << endl;
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t = 1;
cin >> t;
while (t--) {
oblivious();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long double EPS = 1e-14;
int K;
vector<long double> inv;
int nInvers(vector<int> a) {
int sum = 0;
for (int i = 0; i < int(a.size()); i++) {
for (int j = i + 1; j < a.size(); j++) {
if (a[j] < a[i]) {
sum++;
}
}
}
return sum;
}
void rec(vector<int> a, int k) {
if (k == K) {
int num = nInvers(a);
inv[num] += 1;
return;
}
for (int l = 0; l < int(a.size()); l++) {
for (int r = l; r < a.size(); r++) {
vector<int> aa = a;
reverse(aa.begin() + l, aa.begin() + r + 1);
rec(aa, k + 1);
}
}
}
int main() {
int n, k;
cin >> n >> k;
K = k;
vector<int> a(n);
for (int i = 0; i < int(n); i++) {
cin >> a[i];
}
int siz = ((1 + (a.size() - 1)) * (a.size() - 1)) / 2;
inv.resize(siz + 1);
rec(a, 0);
long double sum = 0;
for (int i = 0; i < int(inv.size()); i++) {
sum += inv[i];
}
long double res = 0;
for (int i = 0; i < int(inv.size()); i++) {
res += ((long double)i) * (inv[i] / sum);
}
cout << fixed << setprecision(9) << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 5;
int cnt[27];
int k;
char str[N];
int main(void) {
cin >> str;
scanf("%d", &k);
if (k > strlen(str)) {
printf("impossible\n");
return 0;
}
for (int i = 0; i < strlen(str); ++i) {
++cnt[str[i] - 'a'];
}
int val = 0;
for (int i = 0; i < 26; ++i) {
if (cnt[i]) {
val++;
}
}
int cnt = k - val;
if ((k - val) < 0) {
printf("0\n");
return 0;
} else
printf("%d\n", cnt);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct team {
string nam;
int pnts, sc, mis;
};
int n;
team t[50];
void add(const string &s, int a, int b) {
for (int i = 0; i < n; ++i)
if (t[i].nam == s) {
if (a > b)
t[i].pnts += 3;
else if (a == b)
t[i].pnts += 1;
t[i].sc += a;
t[i].mis += b;
break;
}
}
bool l1(const team &a, const team &b) {
if (a.pnts != b.pnts)
return a.pnts > b.pnts;
else if (a.sc - a.mis != b.sc - b.mis)
return a.sc - a.mis > b.sc - b.mis;
else
return a.sc > b.sc;
}
bool l2(const team &a, const team &b) { return a.nam < b.nam; }
int main() {
string a, b;
int c, d;
cin >> n;
for (int i = 0; i < n; ++i) cin >> t[i].nam;
cin.ignore();
for (int i = 0; i < n * (n - 1) / 2; ++i) {
getline(cin, a, '-');
getline(cin, b, ' ');
scanf("%d:%d", &c, &d);
cin.ignore();
add(a, c, d);
add(b, d, c);
}
sort(t, t + n, l1);
sort(t, t + n / 2, l2);
for (int i = 0; i < n / 2; ++i) cout << t[i].nam << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int num[200005];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", num + i);
}
sort(num, num + n);
n = unique(num, num + n) - num;
int maxs = 0;
for (int i = 0; i < n - 1; i++) {
if (num[i] == 1) continue;
int h = num[n - 1] / num[i];
for (int j = 2; j <= h + 1; j++) {
int k = lower_bound(num + i, num + n, j * num[i]) - num;
maxs = max(maxs, num[k - 1] % num[i]);
if (k == n) break;
}
}
printf("%d\n", maxs);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int INF = 1000000001;
int n, q;
long long segSum[800005], segMult[800005], w[200005], a[200005];
void update(long long seg[], int v, int l, int r, int index, long long x);
long long get(long long seg[], int v, int l, int r, int cl, int cr);
pair<int, long long> find(long long seg[], int v, int l, int r, int cl, int cr,
long long s);
long long norm(long long a) {
a %= mod;
if (a > mod) a -= mod;
if (a < 0) a += mod;
return a;
}
long long mult(long long a, long long b) { return norm(norm(a) * norm(b)); }
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] = norm(a[i] - i);
}
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= n; i++) {
update(segSum, 1, 1, n, i, w[i]);
update(segMult, 1, 1, n, i, mult(w[i], a[i]));
}
while (q--) {
int x, y;
cin >> x >> y;
if (x < 0) {
x *= -1;
w[x] = y;
update(segSum, 1, 1, n, x, w[x]);
update(segMult, 1, 1, n, x, mult(w[x], a[x]));
} else {
long long result = 0;
auto pos = find(segSum, 1, 1, n, x, y, get(segSum, 1, 1, n, x, y) / 2);
assert((pos.first >= x) && (pos.first <= y));
result = norm(mult(a[pos.first], get(segSum, 1, 1, n, x, pos.first)) -
norm(get(segMult, 1, 1, n, x, pos.first)));
result = norm(result + norm(get(segMult, 1, 1, n, pos.first, y)) -
mult(a[pos.first], get(segSum, 1, 1, n, pos.first, y)));
cout << result << "\n";
}
}
cout << "\n"
<< "\n";
return 0;
}
void update(long long seg[], int v, int l, int r, int index, long long x) {
if (l == r) {
seg[v] = x;
return;
}
int mid = (l + r) >> 1;
if (index <= mid)
update(seg, v * 2, l, mid, index, x);
else
update(seg, v * 2 + 1, mid + 1, r, index, x);
seg[v] = seg[v * 2] + seg[v * 2 + 1];
}
long long get(long long seg[], int v, int l, int r, int cl, int cr) {
if ((l == cl) && (r == cr)) return seg[v];
int mid = (l + r) >> 1;
long long result = 0;
if (cl <= mid) result = get(seg, v * 2, l, mid, cl, min(cr, mid));
if (cr > mid) result += get(seg, v * 2 + 1, mid + 1, r, max(cl, mid + 1), cr);
return result;
}
pair<int, long long> find(long long seg[], int v, int l, int r, int cl, int cr,
long long s) {
if ((l == cl) && (r == cr)) {
if (seg[v] <= s) return {INF, seg[v]};
if (l == r) return {l, 0};
}
int mid = (l + r) >> 1;
pair<int, long long> result = {INF, 0};
if (cl <= mid) result = find(seg, v * 2, l, mid, cl, min(mid, cr), s);
if ((cr > mid) && (result.first == INF)) {
auto res = find(seg, v * 2 + 1, mid + 1, r, max(mid + 1, cl), cr,
s - result.second);
result.first = res.first;
result.second += res.second;
}
return result;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
char kkm[maxn];
int cnt[maxn];
int main() {
int n;
scanf("%d", &n);
scanf("%s", kkm + 1);
int x = 0;
for (int i = 1; i <= n; i++) {
if (kkm[i] == '(')
x++;
else
x--;
cnt[i] = x;
}
for (int i = n - 1; i >= 1; i--) cnt[i] = min(cnt[i + 1], cnt[i]);
int ans = 0, b = 0;
for (int i = 1; i <= n; i++) {
if (kkm[i] == '(') {
if (cnt[i] == 2 && x == 2) ans++;
b++;
} else {
if (cnt[i] == -2 && x == -2) ans++;
b--;
}
if (b < 0) break;
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring>
#include <ctime>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <queue>
#include <iomanip>
#define CHECK_IMPL1(cond) \
if (!(cond)) { \
DEBUG("expected cond: " << #cond); \
assert(cond); \
}
#define CHECK_IMPL2(cond, message) \
if (!(cond)) { \
DEBUG("expected cond: " << #cond << " failed with message: " << message); \
assert(cond); \
}
#define CHECK_IMPL(_1, _2, NAME, ...) NAME
#define CHECK(...) CHECK_IMPL(__VA_ARGS__, CHECK_IMPL2, CHECK_IMPL1, CHECK_IMPL0)(__VA_ARGS__)
#ifdef __APPLE__
#define DEBUG(message) std::cerr << message << std::endl;
#else
#define DEBUG(message)
#endif
void solve() {
int n;
std::cin >> n;
std::vector<int> a(n);
std::vector<int> b(n);
for (int i = 0; i < n; ++i) {
std::cin >> a[i] >> b[i];
}
const int kMaxA = 100 * n + 1;
std::vector<std::vector<std::vector<int>>> dp(
2,
std::vector<std::vector<int>>(
n + 1,
std::vector<int>(kMaxA, -1)
)
);
dp[0][0][0] = 0;
for (int k = 0; k <= n; ++k) {
int bit = k % 2;
int next_bit = bit ^ 1;
for (int i = 0; i <= n; ++i) {
for (int A = 0; A < kMaxA; ++A) {
dp[next_bit][i][A] = -1;
}
}
for (int i = 0; i < n; ++i) {
for (int A = 0; A < kMaxA; ++A) {
if (dp[bit][i][A] == -1) {
continue;
}
dp[bit][i + 1][A] = std::max(
dp[bit][i + 1][A],
dp[bit][i][A] + b[i]
);
dp[next_bit][i + 1][A + a[i]] = std::max(
dp[next_bit][i + 1][A + a[i]],
dp[bit][i][A] + 2 * b[i]
);
}
}
if (k > 0) {
int ans = 0;
for (int A = 0; A < kMaxA; ++A) {
ans = std::max(ans, std::min(2 * A, dp[bit][n][A]));
}
std::cout << std::fixed << std::setprecision(10) << ans / 2.0 << ' ';
}
}
std::cout << '\n';
}
int main() {
#ifdef __APPLE__
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
#endif
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int t = 1;
//std::cin >> t;
while (t--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n;
cin >> n;
string num;
cin >> num;
if (n == 1) {
if ((num[0] - '0') % 2 == 0) {
cout << 2 << endl;
return;
}
cout << 1 << endl;
return;
}
int e, o = 0;
if (n % 2 == 0) {
for (int i = 1; i < num.length(); i += 2) {
if ((num[i] - '0') % 2 == 0) {
cout << 2 << endl;
return;
}
}
cout << 1 << endl;
return;
}
for (int i = 0; i < num.length(); i += 2) {
if ((num[i] - '0') % 2 != 0) {
cout << 1 << endl;
return;
}
}
cout << 2 << endl;
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s = "FESTIVAL";
long long dp[1010][10];
int a[1010];
int main(void) {
int i, j, k;
dp[0][0] = 1;
for ((i) = 0; (i) < (int)(1000); (i)++)
for ((j) = 0; (j) < (int)(8); (j)++)
for ((k) = 0; (k) < (int)(8); (k)++)
if (j <= k) dp[i + 1][k] = min(dp[i + 1][k] + dp[i][j], (1ll << 60));
long long K;
cin >> K;
for (i = 25; i >= 1; i--) {
a[i] = K / dp[i][7];
K %= dp[i][7];
}
string s;
for ((i) = 0; (i) < (int)(25); (i)++) {
s += "FESTIVA";
for ((j) = 0; (j) < (int)(a[i + 1]); (j)++) s += 'L';
}
cout << s << ' ' << "FESTIVAL" << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cout << 1 << " ";
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> m;
int n, a, x, maxi;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
m[x] = m[x - 1] + 1;
a = m[x];
maxi = max(a, maxi);
}
printf("%d", n - maxi);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1111][1111], a1[1111][1111], a2[1111][1111], f1[1111][1111],
f2[1111][1111], p1[1111][1111], p2[1111][1111], x = -1, y, xx, yy, as1, bs1,
as2, bs2, s1, s2;
string ans1, ans2;
int main() {
cin >> 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++) {
if (!a[i][j]) {
x = i;
y = j;
continue;
}
while (a[i][j] % 2 == 0) a1[i][j]++, a[i][j] /= 2;
while (a[i][j] % 5 == 0) a2[i][j]++, a[i][j] /= 5;
}
memset(f1, 63, sizeof(f1));
memset(f2, 63, sizeof(f2));
f1[0][0] = a1[0][0];
f2[0][0] = a2[0][0];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
if (j < n - 1) {
if (f1[i][j] + a1[i][j + 1] < f1[i][j + 1])
f1[i][j + 1] = f1[i][j] + a1[i][j + 1], p1[i][j + 1] = 1;
if (f2[i][j] + a2[i][j + 1] < f2[i][j + 1])
f2[i][j + 1] = f2[i][j] + a2[i][j + 1], p2[i][j + 1] = 1;
}
if (i < n - 1) {
if (f1[i][j] + a1[i + 1][j] < f1[i + 1][j])
f1[i + 1][j] = f1[i][j] + a1[i + 1][j], p1[i + 1][j] = 2;
if (f2[i][j] + a2[i + 1][j] < f2[i + 1][j])
f2[i + 1][j] = f2[i][j] + a2[i + 1][j], p2[i + 1][j] = 2;
}
}
xx = yy = n - 1;
as1 = a1[xx][yy];
bs1 = a2[xx][yy];
while (xx || yy) {
if (p1[xx][yy] == 1)
ans1 = "R" + ans1, yy--;
else
ans1 = "D" + ans1, xx--;
as1 += a1[xx][yy];
bs1 += a2[xx][yy];
}
xx = yy = n - 1;
as2 = a1[xx][yy];
bs2 = a2[xx][yy];
while (xx || yy) {
if (p2[xx][yy] == 1)
ans2 = "R" + ans2, yy--;
else
ans2 = "D" + ans2, xx--;
as2 += a1[xx][yy];
bs2 += a2[xx][yy];
}
s1 = min(as1, bs1);
s2 = min(as2, bs2);
if (s1 > 1 && s2 > 1 && x != -1) {
puts("1");
xx = yy = 0;
while (yy != y) putchar('R'), yy++;
while (xx != x) putchar('D'), xx++;
while (yy != n - 1) putchar('R'), yy++;
while (xx != n - 1) putchar('D'), xx++;
return 0;
}
if (s1 < s2)
cout << s1 << endl << ans1 << endl;
else
cout << s2 << endl << ans2 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Z = (int)2e3 + 228;
const int N = (int)4e5 + 600;
const int INF = (int)1e9 + 228;
const int MOD = (int)1e9 + 7;
struct Bor {
Bor *next[26];
Bor() {
for (int i = 0; i < 26; i++) next[i] = nullptr;
}
};
Bor *root = new Bor();
bool good[26];
int ans, k;
void Add(string s) {
int n = s.length();
Bor *v = root;
for (int i = 0; i < n; i++) {
char c = s[i];
if (v->next[c - 'a'] == nullptr) {
v->next[c - 'a'] = new Bor();
}
v = v->next[c - 'a'];
}
}
void Go(Bor *v, int cur) {
ans++;
for (int i = 0; i < 26; i++)
if (v->next[i] != nullptr) {
int c = 1 - good[i];
if (cur + c <= k) Go(v->next[i], cur + c);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
int n = s.length();
for (int i = 0; i < 26; i++) {
char c;
cin >> c;
good[i] = (c - '0');
}
cin >> k;
for (int i = 0; i < n; i++) {
string t = s.substr(i, n - i + 1);
Add(t);
}
Go(root, 0);
cout << ans - 1;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000 + 100;
const int maxm = 300000 + 100;
const long long INF = 100000000000000000LL;
long long dp[maxn][maxn], n, k;
long long a[maxm], sum[maxm], ts;
int main() {
scanf("%lld%lld", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
ts = 0;
sort(a + 1, a + n + 1);
int tn = n / k, tm = n % k;
for (int i = 1; i < tn; ++i) ts += llabs(a[i] - a[i + 1]);
sum[tn] = ts;
for (int i = tn, j = 1; i <= n; ++i, ++j) {
ts += llabs(a[i + 1] - a[i]);
ts -= llabs(a[j] - a[j + 1]);
sum[i + 1] = ts;
}
for (int i = 1; i <= k; ++i) dp[0][i] = INF;
for (int i = 1; i <= k; ++i) {
dp[i][0] = dp[i - 1][0] + sum[i * tn];
for (int j = 1; j <= tm; ++j) {
dp[i][j] = min(dp[i - 1][j] + sum[i * tn + j],
dp[i - 1][j - 1] + sum[i * tn + j - 1] +
llabs(a[i * tn + j - 1] - a[i * tn + j]));
}
}
printf("%lld\n", dp[k][tm]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6;
int p[maxn];
void solve() {
int n;
cin >> n;
int fl = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
if (i > 1 && p[i - 1] >= p[i]) fl = 1;
}
if (n % 2 == 1 && fl == 0)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
int main() {
int __;
cin >> __;
while (__--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<long long int, int> mp;
int re[100022], ad[100022], cou[100022];
long long int arr[100022], val[100022], aa[100022], ansa[100022];
struct node {
int l, r, in;
} q[100222];
int cmp(node a, node b) {
if (a.l / 333 != b.l / 333) return a.l / 333 < b.l / 333;
return a.r < b.r;
}
long long int ans = 0;
void add1(int in) {
if (ad[in] != -1) ans += cou[ad[in]];
cou[aa[in]]++;
}
void add2(int in) {
if (re[in] != -1) ans += cou[re[in]];
cou[aa[in]]++;
}
void rem1(int in) {
cou[aa[in]]--;
if (ad[in] != -1) ans -= cou[ad[in]];
}
void rem2(int in) {
cou[aa[in]]--;
if (re[in] != -1) ans -= cou[re[in]];
}
int main() {
int i, n, k;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) scanf("%lld", &arr[i]);
for (i = 1; i <= n; i++) scanf("%lld", &val[i]);
long long int one = 0, two = 0;
mp[one - two]++;
for (i = 1; i <= n; i++) {
if (arr[i] == 1)
one += val[i];
else
two += val[i];
mp[one - two]++;
aa[i] = one - two;
}
int aay = 0;
for (map<long long int, int>::iterator it = mp.begin(); it != mp.end(); it++)
mp[it->first] = aay++;
for (i = 0; i <= n; i++) {
re[i] = ad[i] = -1;
if (mp.find(aa[i] + k) != mp.end()) re[i] = mp[aa[i] + k];
if (mp.find(aa[i] - k) != mp.end()) ad[i] = mp[aa[i] - k];
aa[i] = mp[aa[i]];
}
int m;
cin >> m;
for (i = 0; i < m; i++) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].in = i;
}
sort(q, q + m, cmp);
int l = 0, r = 0;
for (i = 0; i < m; i++) {
int nl = q[i].l - 1, nr = q[i].r;
while (l > nl) add2(--l);
while (r <= nr) add1(r++);
while (l < nl) rem2(l++);
while (r > nr + 1) rem1(--r);
ansa[q[i].in] = ans;
}
for (i = 0; i < m; i++) printf("%lld\n", ansa[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int pos[maxn];
int main() {
int n, tem;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &tem);
pos[tem] = i;
}
int cou = 0, MAX = -1;
for (int i = 1; i <= n; i++) {
if (i == 1) {
cou++;
MAX = 1;
} else if (pos[i] > pos[i - 1]) {
cou++;
MAX = max(MAX, cou);
} else {
MAX = max(MAX, cou);
cou = 1;
}
}
printf("%d\n", n - MAX);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int p[100005];
bool vis[100005];
bool par = true;
int res1 = -1, res2 = -1;
int pareja;
int k, szz;
int main() {
cin >> n;
for (int i = 1; i < n + 1; i++) cin >> p[i];
for (int i = 1; i < n + 1; i++) {
if (!vis[i]) {
vis[i] = true;
k = p[i];
szz = 1;
while (k != i) {
vis[k] = true;
k = p[k];
szz++;
}
if (szz == 1) res1 = i;
if (szz == 2) {
res2 = i;
pareja = p[i];
}
if (szz % 2 == 1) par = false;
}
}
if (res1 != -1) {
cout << "YES" << endl;
for (int i = 1; i < n + 1; i++)
if (i != res1) cout << res1 << " " << i << endl;
} else if (res2 != -1 && par) {
cout << "YES" << endl;
memset(vis, false, sizeof vis);
cout << res2 << " " << pareja << endl;
;
vis[res2] = true;
vis[pareja] = true;
for (int i = 1; i < n + 1; i++) {
if (!vis[i]) {
vis[i] = true;
szz = 1;
k = p[i];
cout << pareja << " " << i << endl;
while (k != i) {
vis[k] = true;
szz++;
if (szz % 2 == 1)
cout << pareja << " " << k << endl;
else
cout << res2 << " " << k << endl;
k = p[k];
}
}
}
} else
cout << "NO" << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
long long k, temp = 9, t = 1, d = 1, l, m, n;
cin >> k;
while (k - temp * t > 0) {
k -= temp * t;
temp *= 10;
t++;
}
m = (k - 1) % t + 1;
n = (k - 1) / t;
for (int i = 1; i < t; i++) d = d * 10;
d += n;
for (int i = 0; i < t - m; i++) d /= 10;
l = d % 10;
cout << l;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
int n, L, minID;
string s;
void fill(int id, char c) {
L -= (s[id] == 'L');
s[id] = c;
minID = min(minID, id);
}
void query(char cmd, string str) {
cout << cmd << " " << str << '\n';
cout.flush();
if (cmd == '?') {
int k;
cin >> k;
assert(k != -1);
vector<int> a(k);
for (auto& z : a) {
cin >> z;
z--;
for (int i = 0; i < str.size(); i++) {
assert(s[z + i] == 'L' || s[z + i] == str[i]);
fill(z + i, str[i]);
}
}
} else if (cmd == '!') {
int correct;
cin >> correct;
assert(correct);
}
}
void Input() {
cin >> n;
s.clear();
L = n;
minID = n;
s.resize(n, 'L');
}
void Solve() {
query('?', "CH");
query('?', "CO");
query('?', "HC");
query('?', "HO");
if (L == n) {
query('?', "CCC");
if (minID < n) {
for (int x = minID - 1; x >= 0; x--) fill(x, 'O');
} else {
query('?', "HHH");
if (minID < n) {
for (int x = minID - 1; x >= 0; x--) fill(x, 'O');
} else {
query('?', "OOO");
if (minID == n) {
query('?', "OOCC");
if (minID == n) {
fill(0, 'O');
fill(1, 'O');
fill(2, 'H');
fill(3, 'H');
}
}
if (s[n - 1] == 'L') {
string t = s;
t[n - 1] = 'C';
if (t[n - 2] == 'L') t[n - 2] = 'C';
query('?', t);
if (s[n - 1] == 'L') {
fill(n - 1, 'H');
if (s[n - 2] == 'L') fill(n - 2, 'H');
}
}
}
}
} else {
int maxID = minID;
while (maxID < n - 1 && s[maxID + 1] != 'L') maxID++;
for (int i = minID - 1; i >= 0; i--) {
query('?', s.substr(i + 1, 1) + s.substr(minID, maxID - minID + 1));
if (minID != i) {
for (int x = 0; x <= i; x++) fill(x, 'O');
break;
}
}
int nextFilled;
for (int i = maxID + 1; i < n; i++) {
if (s[i] != 'L') continue;
nextFilled = i;
while (nextFilled < n && s[nextFilled] == 'L') nextFilled++;
query('?', s.substr(0, i) + s[i - 1]);
if (s[i] == 'L') {
if (s[i - 1] != 'O')
fill(i, 'O');
else {
if (nextFilled == n) {
query('?', s.substr(0, i) + 'C');
if (s[i] == 'L') fill(i, 'H');
for (int x = i + 1; x < nextFilled; x++) fill(x, s[i]);
} else
for (int x = i; x < nextFilled; x++) fill(x, s[nextFilled]);
i = nextFilled - 1;
}
}
}
}
query('!', s);
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int T;
cin >> T;
while (T--) {
Input();
Solve();
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> cnt;
multiset<long long> have;
vector<long long> used;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
srand(time(NULL));
int n;
cin >> n;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
cnt[a]++;
}
for (map<int, int>::iterator it = cnt.begin(); it != cnt.end(); it++) {
have.insert(it->second);
}
long long ans = 0;
for (int i = 1; i < 300100; i++) {
long long now = i;
long long res = 0;
used.clear();
while (now < 300100) {
multiset<long long>::iterator it = have.lower_bound(now);
if (it == have.end()) break;
used.push_back(*it);
res += now;
have.erase(it);
now *= 2;
}
ans = max(ans, res);
for (int j = 0; j < used.size(); j++) have.insert(used[j]);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int num;
int l, r;
} Mem[10000];
int cnt;
string s[1024];
void init(int root) {
Mem[root].num = 2;
Mem[root].l = -1;
Mem[root].r = -1;
}
string Str;
bool insert(int root, int len) {
if (len == 0) {
Mem[root].num = 0;
return true;
}
if (Mem[root].num == 0) return false;
if (Mem[root].num == 2) {
if (Mem[root].l == -1) {
Mem[root].l = ++cnt;
init(Mem[root].l);
}
Str += '0';
bool res = insert(Mem[root].l, len - 1);
if (Mem[Mem[root].l].num == 0) Mem[root].num--;
return res;
}
if (Mem[root].r == -1) {
Mem[root].r = ++cnt;
init(Mem[root].r);
}
Str += '1';
bool res = insert(Mem[root].r, len - 1);
if (Mem[Mem[root].r].num == 0) Mem[root].num--;
return res;
}
struct Int {
int id, val;
} I[1024];
bool cmp(Int a, Int b) { return a.val < b.val; }
int main() {
cnt = 0;
int root = 0, n;
init(root);
scanf("%d", &n);
bool ok = true;
for (int i = 0; i < n; i++) {
scanf("%d", &I[i].val);
I[i].id = i;
}
sort(I, I + n, cmp);
for (int i = 0; i < n; i++) {
Str = "";
if (!insert(root, I[i].val)) {
puts("NO");
ok = false;
break;
}
s[I[i].id] = Str;
}
if (ok) {
puts("YES");
for (int i = 0; i < n; i++) {
cout << s[i] << endl;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v, rev, cap, flow, cost;
edge(int _v, int _rev, int _cap, int _flow, int _cost) {
v = _v;
rev = _rev;
cap = _cap;
flow = _flow;
cost = _cost;
}
edge() {}
};
vector<pair<int, int> > path;
vector<vector<edge> > AdjList;
int f = 0;
long long total_cost = 0;
void addEdge(int u, int v, int cap, int cost) {
int k = AdjList[v].size(), l = AdjList[u].size();
AdjList[u].push_back(edge(v, k, cap, 0, cost));
AdjList[v].push_back(edge(u, l, 0, 0, -cost));
}
void augment(int s, int v, int min_edge) {
if (v == s) {
f = min_edge;
return;
}
int u = path[v].first, i = path[v].second;
if (u != -1) {
int res = AdjList[u][i].cap - AdjList[u][i].flow;
augment(s, u, min(res, min_edge));
AdjList[u][i].flow += f;
AdjList[v][AdjList[u][i].rev].flow -= f;
total_cost += 1LL * AdjList[u][i].cost * f;
}
}
int minCostMaxFlow(int s, int t, int N) {
int maxflow = 0;
path.resize(N);
while (true) {
f = 0;
vector<long long> dist(N, 1000000000);
vector<bool> IN(N, false);
dist[s] = 0;
path[t] = make_pair(-1, -1);
queue<int> cola;
cola.push(s);
IN[s] = true;
while (!cola.empty()) {
int u = cola.front();
cola.pop();
IN[u] = false;
for (int i = (0); i < ((int)AdjList[u].size()); ++i) {
edge e = AdjList[u][i];
if (e.cap - e.flow > 0 and dist[e.v] > dist[u] + e.cost) {
dist[e.v] = dist[u] + e.cost;
path[e.v] = make_pair(u, i);
if (!IN[e.v]) cola.push(e.v), IN[e.v] = true;
}
}
}
augment(s, t, 1000000000);
if (!f) break;
maxflow += f;
}
return maxflow;
}
int a[255], last[255], var[255];
void dfs(int u, int n, int id) {
if (u == 2 * n + 2) return;
if (u >= 2 and u <= n + 1) var[u - 2] = id;
for (int i = (0); i < ((int)AdjList[u].size()); ++i)
if (AdjList[u][i].flow == 1) dfs(AdjList[u][i].v, n, id);
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = (0); i < (n); ++i) scanf("%d", &a[i]);
AdjList.assign(2 * n + 3, vector<edge>());
addEdge(0, 1, m, 0);
addEdge(1, 2 * n + 2, 1000000000, 0);
for (int i = (0); i < (n); ++i) {
addEdge(1, i + 2, 1, __builtin_popcount(a[i]));
addEdge(i + 2, i + n + 2, 1, -1000000000);
for (int j = (i + 1); j < (n); ++j) {
int cost = a[i] == a[j] ? 0 : __builtin_popcount(a[j]);
addEdge(i + n + 2, j + 2, 1, cost);
}
addEdge(i + n + 2, 2 * n + 2, 1, 0);
}
int maxflow = minCostMaxFlow(0, 2 * n + 2, 2 * n + 3);
int cont = 0;
for (int i = (0); i < ((int)AdjList[1].size()); ++i)
if (AdjList[1][i].flow == 1) dfs(AdjList[1][i].v, n, cont++);
int lineas = 0;
memset(last, -1, sizeof last);
for (int i = (0); i < (n); ++i) {
if (last[var[i]] != a[i]) ++lineas;
++lineas;
last[var[i]] = a[i];
}
printf("%d %I64d\n", lineas, total_cost + 1LL * n * 1000000000);
memset(last, -1, sizeof last);
for (int i = (0); i < (n); ++i) {
if (last[var[i]] != a[i]) printf("%c=%d\n", 'a' + var[i], a[i]);
printf("print(%c)\n", 'a' + var[i]);
last[var[i]] = a[i];
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
void add(int& a, const int& b) {
a += b;
if (a >= mod) a -= mod;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int suf0 = 0;
while (!s.empty() && s.back() == '0') {
s.pop_back();
suf0++;
}
if (s.empty()) {
cout << suf0 << "\n";
return 0;
}
int n = s.size();
vector<int> z(n, 0);
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
if (!i)
z[i] = 1;
else
z[i] = z[i - 1] + 1;
}
}
vector<int> dp(n + 1, 0), nxt(n + 1, n);
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '1') dp[i] = 1;
add(dp[i], dp[nxt[0]]);
add(dp[i], dp[nxt[z[i] + 1]]);
nxt[z[i]] = i;
}
for (int i = 0; i < n; i++) {
if (s[i] == '1') {
cout << (((dp[i] * 1ll * (suf0 + 1)) % mod) * 1ll * (i + 1)) % mod
<< "\n";
return 0;
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300010, maxm = 300010, maxs = 610;
struct Task {
int idx, x, d;
} q[maxn];
long long f[maxn], ans[maxm];
int w[maxn], n, m, S;
inline bool cmp_ask(const Task &u, const Task &v) { return u.d < v.d; }
void init() {
scanf("%d", &n), S = sqrt(n);
for (int i = 1; i <= n; ++i) scanf("%d", w + i);
scanf("%d", &m);
for (int i = 1; i <= m; ++i) scanf("%d%d", &q[i].x, &q[i].d), q[i].idx = i;
sort(q + 1, q + m + 1, cmp_ask), q[0] = (Task){-1, -1, -1};
}
void preset(int d) {
for (int i = 1; i <= d; ++i) f[i] = w[i];
for (int i = d + 1; i <= n; ++i) f[i] = f[i - d] + w[i];
}
void solve() {
for (int i = 1; i <= m; ++i) {
int d = q[i].d, x = q[i].x, k = q[i].idx;
if (d <= S) {
if (d != q[i - 1].d) preset(d);
int y = x + (n - x) / d * d;
ans[k] = f[y];
if (x > d) ans[k] -= f[x - d];
} else {
ans[k] = 0;
for (int i = x; i <= n; i += d) ans[k] += w[i];
}
}
for (int i = 1; i <= m; ++i) printf("%I64d\n", ans[i]);
}
int main() {
init();
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
long long int brr[2 * n + 10];
long long int arr[n + 5];
long long int i;
for (i = 0; i < n; i++) cin >> arr[i];
long long int b = 0;
for (i = 0; i < n; i += 2) {
brr[b++] = arr[i];
}
for (i = 1; i < n; i += 2) brr[b++] = arr[i];
for (i = 0; i < n; i++) {
brr[n + i] = brr[i];
}
long long int gap = (n + 1) / 2;
long long int j = 0;
long long int maxi = 0;
long long int sum = 0;
for (i = 0; i < gap; i++) {
sum += brr[i];
}
maxi = max(sum, maxi);
for (i = gap; i < 2 * n; i++) {
sum -= brr[j++];
sum += brr[i];
maxi = max(sum, maxi);
}
cout << maxi << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k, m, x, y, r, A[100000 + 5], B[100000 + 5], Bh, C[100000 + 5], Ch,
D[100000 + 5], Dh, G[100000 + 5], F[100000 + 5][350 + 5], fr[100000 + 5],
en[100000 + 5], Fs[350 + 5][350 + 5], ToT[100000 + 5], Ans;
const long long Maxn = 2e9;
inline bool cmp(int x, int y) { return A[x] < A[y]; }
int main() {
register int i, j, h;
scanf("%d", &n);
k = sqrt(n);
for (i = 1; i <= n; i++) scanf("%d", &A[i]);
for (i = 0; i <= n / k; i++)
fr[i] = ((1) > (i * k) ? (1) : (i * k)),
en[i] = ((n) < (i * k + k - 1) ? (n) : (i * k + k - 1));
for (i = 0; i <= n / k; i++) {
for (j = fr[i]; j <= en[i]; j++) G[j] = j;
sort(G + fr[i], G + en[i] + 1, cmp);
for (ToT[i] = Maxn, j = fr[i]; j < en[i]; j++)
ToT[i] = ((ToT[i]) < (A[G[j + 1]] - A[G[j]]) ? (ToT[i])
: (A[G[j + 1]] - A[G[j]]));
}
for (i = 0; i <= n / k; i++) {
for (j = fr[i]; j <= en[i]; j++) F[j][i] = Maxn;
for (j = i + 1; j <= n / k; j++) {
for (r = fr[j], h = fr[i]; h <= en[i]; h++) {
F[G[h]][j] = F[G[h]][j - 1];
while (r <= en[j] && A[G[r]] < A[G[h]]) r++;
r ^ fr[j] && (F[G[h]][j] = ((F[G[h]][j]) < (A[G[h]] - A[G[r - 1]])
? (F[G[h]][j])
: (A[G[h]] - A[G[r - 1]])));
r <= en[j] && (F[G[h]][j] = ((F[G[h]][j]) < (A[G[r]] - A[G[h]])
? (F[G[h]][j])
: (A[G[r]] - A[G[h]])));
}
}
for (j = i - 1; ~j; j--) {
for (r = fr[j], h = fr[i]; h <= en[i]; h++) {
F[G[h]][j] = F[G[h]][j + 1];
while (r <= en[j] && A[G[r]] < A[G[h]]) r++;
r ^ fr[j] && (F[G[h]][j] = ((F[G[h]][j]) < (A[G[h]] - A[G[r - 1]])
? (F[G[h]][j])
: (A[G[h]] - A[G[r - 1]])));
r <= en[j] && (F[G[h]][j] = ((F[G[h]][j]) < (A[G[r]] - A[G[h]])
? (F[G[h]][j])
: (A[G[r]] - A[G[h]])));
}
}
}
for (i = 0; i <= n / k; i++) {
i && (Fs[i][i - 1] = Maxn);
for (j = i; j <= n / k; j++) {
Fs[i][j] = ((Fs[i][j - 1]) < (ToT[j]) ? (Fs[i][j - 1]) : (ToT[j]));
for (h = fr[j]; h <= en[j]; h++)
Fs[i][j] = ((Fs[i][j]) < (F[h][i]) ? (Fs[i][j]) : (F[h][i]));
}
}
scanf("%d", &m);
while (m--) {
scanf("%d%d", &x, &y);
if (x / k == y / k) {
Bh = 0;
for (i = fr[x / k]; i <= en[x / k]; i++)
G[i] >= x&& G[i] <= y && (B[++Bh] = G[i]);
Ans = Maxn;
for (i = 1; i < Bh; i++)
Ans =
((Ans) < (A[B[i + 1]] - A[B[i]]) ? (Ans) : (A[B[i + 1]] - A[B[i]]));
printf("%d\n", Ans);
continue;
}
Ans = Fs[x / k + 1][y / k - 1];
for (i = x; i <= en[x / k]; i++)
Ans = ((Ans) < (F[i][y / k - 1]) ? (Ans) : (F[i][y / k - 1]));
for (i = fr[y / k]; i <= y; i++)
Ans = ((Ans) < (F[i][x / k + 1]) ? (Ans) : (F[i][x / k + 1]));
for (Bh = 0, i = fr[x / k]; i <= en[x / k]; i++)
G[i] >= x && (B[++Bh] = G[i]);
for (Ch = 0, i = fr[y / k]; i <= en[y / k]; i++)
G[i] <= y && (C[++Ch] = G[i]);
i = j = 1;
Dh = 0;
while (i <= Bh || j <= Ch)
D[++Dh] = (j > Ch || (i <= Bh && A[B[i]] < A[C[j]])) ? B[i++] : C[j++];
for (i = 1; i < Dh; i++)
Ans = ((Ans) < (A[D[i + 1]] - A[D[i]]) ? (Ans) : (A[D[i + 1]] - A[D[i]]));
printf("%d\n", Ans);
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> v, pl;
vector<pair<int, int>> s;
vector<vector<int>> ans;
vector<int> rec(int ind, vector<int>& t, map<int, bool>& ch) {
if (ch[ind]) return t;
t.push_back(ind + 1);
ch[ind] = 1;
int x = pl[ind];
pl[ind] = -1;
return rec(x, t, ch);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
v.resize(n);
s.resize(n);
pl.resize(n, -1);
for (int i = 0; i < n; i++) cin >> v[i], s[i] = {v[i], i};
sort(s.begin(), s.end());
for (int i = 0; i < n; i++)
if (s[i].second == i)
ans.push_back({i + 1});
else
pl[s[i].second] = i;
for (int i = 0; i < n; i++) {
if (pl[i] == -1) continue;
vector<int> t;
map<int, bool> ch;
ans.push_back(rec(i, t, ch));
}
cout << ans.size() << endl;
for (auto vec : ans) {
cout << vec.size() << " ";
for (int x : vec) cout << x << " ";
cout << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
vector<int> a(n + 1, 0);
int most = 0;
int mostCount = 0;
for (int i = 0; i < int(n); i++) {
int cake;
cin >> cake;
a[cake]++;
if (a[cake] > most) {
most = a[cake];
mostCount = 1;
} else if (a[cake] == most) {
mostCount++;
}
}
int different = 0;
for (int i = 0; i < int(n + 1); i++) {
if (a[i] > 0) different++;
}
int rem = n - most - mostCount + 1;
int mingap = rem / (most - 1);
mingap = min(different - 1, mingap);
cout << mingap << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, c;
int bs[31];
int main() {
cin >> n;
int tx = 0;
for (int i = 0; i < n; i++) {
cin >> c;
tx ^= c;
for (int j = 30; j >= 0; j--) {
if (c & (1 << j)) {
if (bs[j])
c ^= bs[j];
else {
bs[j] = c;
break;
}
}
}
}
if (!tx) {
cout << "-1" << endl;
return 0;
}
int ans = 0;
for (int i = 0; i < 31; i++) {
if (bs[i]) ans++;
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, ans = 0, n;
cin >> n;
string s;
cin >> s;
for (i = 0; i < s.size(); i++) {
if (s[i] == 'R') {
for (j = i + 1; j < s.size(); j++)
if (s[j] == 'L') {
for (k = i; k <= j; k++) s[k] = '0';
if ((j - i) % 2 == 0) ans++;
break;
}
}
}
for (i = 0; i < s.size(); i++) {
if (s[i] == 'R') break;
if (s[i] == 'L') {
for (k = 0; k <= i; k++) s[k] = '0';
break;
}
}
for (i = s.size() - 1; i >= 0; i--) {
if (s[i] == 'L') break;
if (s[i] == 'R') {
for (k = i; k < s.size(); k++) s[k] = '0';
break;
}
}
for (i = 0; i < s.size(); i++)
if (s[i] == '.') ans++;
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, s, v(0);
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++)
if (a[i] > a[i + 1]) s = i, v++;
if (a[n - 1] > a[0]) s = n - 1, v++;
if (v == 0)
cout << 0 << endl;
else if (v > 1)
cout << -1 << endl;
else
cout << n - 1 - s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int x[1005], y[1005], r[1005];
int main() {
int gnrs, c1 = 1, c2 = 1, c3 = 1, c4 = 1, gnr, x1, x2, y1, y2, n, i, j, k,
minx, miny, maxx, maxy, xx, yy;
cin >> x1 >> y1 >> x2 >> y2 >> n;
for (i = 0; i < n; i++) cin >> x[i] >> y[i] >> r[i];
minx = min(x1, x2);
maxx = max(x1, x2);
miny = min(y1, y2);
maxy = max(y1, y2);
gnrs = gnr = (maxx - minx + maxy - miny) * 2;
xx = minx;
yy = miny;
while (gnr--) {
for (i = 0; i < n; i++) {
if (sqrt(((xx) - (x[i])) * ((xx) - (x[i])) +
((yy) - (y[i])) * ((yy) - (y[i]))) <= r[i]) {
gnrs--;
break;
}
}
if (c1 and xx < maxx) {
xx++;
} else if (c2 and yy < maxy) {
yy++;
c1 = 0;
} else if (c3 and xx > minx) {
xx--;
c2 = 0;
} else if (c4 and yy > miny) {
yy--;
c3 = 0;
}
}
cout << gnrs << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 5e5 + 5;
long long int n, m, k, a, b, temp;
string str;
set<long long int> s;
vector<long long int> v;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int i;
cin >> n >> m;
cin >> k;
v.resize(n);
for (i = 0; i < n; i++) cin >> v[i];
vector<long long int> in[m + 1];
for (i = 0; i < n; i++) {
in[v[i]].push_back(i);
}
long long int ans = 0;
long long int l = 0;
long long int mx = 1;
bool vis[100000 + 1] = {0};
for (i = 0; i < n; i++) {
temp = v[i];
if (vis[temp]) continue;
vis[temp] = 1;
long long int r = 0;
long long int sum = 0;
for (l = 0; l < in[temp].size() - 1; l++) {
while (r < in[temp].size() - 1 && sum <= k) {
if (sum + in[temp][r + 1] - in[temp][r] - 1 <= k) {
sum += in[temp][r + 1] - in[temp][r] - 1;
r++;
} else
break;
}
mx = max((long long int)in[temp][r] - in[temp][l] + 1 - sum, mx);
sum -= (in[temp][l + 1] - in[temp][l] - 1);
}
}
cout << mx;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[400005][5];
int c[2] = {-1, 1};
int mx[800005][1 << 5];
int calc(int* x, int s) {
int ret = 0;
for (int i = 0; i < k; i++) {
ret += c[s >> i & 1] * x[i];
}
return ret;
}
void merge(int o) {
for (int i = 0; i < (1 << k); i++) {
mx[o][i] = max(mx[o << 1][i], mx[o << 1 | 1][i]);
}
}
void build(int o, int l, int r) {
if (l == r) {
for (int i = 0; i < (1 << k); i++) {
mx[o][i] = calc(a[l], i);
}
} else {
int mid = (l + r) / 2;
build(o << 1, l, mid);
build(o << 1 | 1, mid + 1, r);
merge(o);
}
}
void cg(int o, int l, int r, int pos, int* x) {
if (l == r) {
for (int i = 0; i < (1 << k); i++) {
mx[o][i] = calc(x, i);
}
} else {
int mid = (l + r) / 2;
if (pos <= mid)
cg(o << 1, l, mid, pos, x);
else
cg(o << 1 | 1, mid + 1, r, pos, x);
merge(o);
}
}
int ask(int o, int l, int r, int L, int R, int k) {
if (l == L && r == R) {
return mx[o][k];
} else {
int mid = (l + r) / 2;
if (R <= mid)
return ask(o << 1, l, mid, L, R, k);
else if (L > mid)
return ask(o << 1 | 1, mid + 1, r, L, R, k);
else
return max(ask(o << 1, l, mid, L, mid, k),
ask(o << 1 | 1, mid + 1, r, mid + 1, R, k));
}
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++)
for (int j = 0; j < k; j++) scanf("%d", &a[i][j]);
int q;
scanf("%d", &q);
build(1, 1, n);
while (q--) {
int t;
scanf("%d", &t);
if (t == 1) {
int x;
int tmp[5];
scanf("%d", &x);
for (int i = 0; i < k; i++) scanf("%d", &tmp[i]);
cg(1, 1, n, x, tmp);
} else {
int l, r;
scanf("%d%d", &l, &r);
int mx = 0;
for (int i = 0; i < (1 << k); i++) {
mx = max(
mx, ask(1, 1, n, l, r, i) + ask(1, 1, n, l, r, i ^ ((1 << k) - 1)));
}
printf("%d\n", mx);
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char a[1100][1100];
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
bool u[10];
void G(const int x, const int y) {
for (int i = 0; i <= 3; ++i) {
int X = x + dx[i], Y = y + dy[i];
if (a[X][Y] <= 'D' && a[X][Y] >= 'A') u[a[X][Y] - 'A'] = 1;
}
}
bool ok() {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (a[i][j] == 'b')
return 0;
else if (a[i][j] == 'w') {
memset(u, 0, sizeof(u));
if (a[i][j + 1] == 'b' && a[i][j + 2] == 'w') {
G(i, j), G(i, j + 1), G(i, j + 2);
for (int k = 0; k <= 4; ++k)
if (!u[k]) {
a[i][j] = a[i][j + 1] = a[i][j + 2] = 'A' + k;
break;
}
} else if (a[i + 1][j] == 'b' && a[i + 2][j] == 'w') {
G(i, j), G(i + 1, j), G(i + 2, j);
for (int k = 0; k <= 4; ++k)
if (!u[k]) {
a[i][j] = a[i + 1][j] = a[i + 2][j] = 'A' + k;
break;
}
} else
return 0;
}
puts("YES");
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j)
if (a[i][j] >= 'A' && a[i][j] <= 'D') a[i][j] = 'a' + a[i][j] - 'A';
puts(a[i] + 1);
}
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%s", a[i] + 1);
if (!ok()) puts("NO");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
int n, m;
cin >> n >> m;
int a[n + 1];
long long minsuma[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
minsuma[i] = 1e18;
}
int b[m + 1];
for (int i = 1; i <= m; i++) cin >> b[i];
long long x;
cin >> x;
for (int i = 1; i <= n; i++) {
long long sum = 0;
for (int j = i; j <= n; j++) {
sum += a[j];
minsuma[j - i + 1] = min(minsuma[j - i + 1], sum);
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long sum = 0;
int k = 1;
for (int j = 1; j <= m; j++) {
while (k <= m && (minsuma[i] * (sum + b[k]) <= x)) {
sum += b[k++];
}
ans = max(ans, (long long)i * (k - j));
sum -= b[j];
}
}
cout << ans << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a1, b1, a2, b2;
scanf("%d%d%d%d", &a1, &b1, &a2, &b2);
int valid = 0;
if (a1 <= b2 + 1 && b2 <= 2 * (a1 + 1)) valid = 1;
if (b1 <= a2 + 1 && a2 <= 2 * (b1 + 1)) valid = 1;
if (valid)
printf("YES");
else
printf("NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
const int maxn = (int)3e5 + 10;
struct vt {
double x, y;
vt() : x(0), y(0) {}
vt(double x, double y) : x(x), y(y) {}
};
vt operator+(vt a, vt b) {
a.x += b.x;
a.y += b.y;
return a;
}
struct mat {
double a[2][2];
mat() { memset(a, 0, sizeof a); }
mat(double b, double c, double d, double f) {
a[0][0] = b;
a[0][1] = c;
a[1][0] = d;
a[1][1] = f;
}
};
mat operator*(mat x, mat y) {
mat ans;
memset(ans.a, 0, sizeof ans.a);
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
ans.a[i][j] += x.a[i][k] * y.a[k][j];
}
}
}
return ans;
}
vt operator*(mat x, vt a) {
return vt(x.a[0][0] * a.x + x.a[0][1] * a.y,
x.a[1][0] * a.x + x.a[1][1] * a.y);
}
vt tr[4 * maxn];
mat st[4 * maxn];
void build(int it, int l, int r) {
if (l == r) {
tr[it] = vt(1, 0);
} else {
int m = (l + r) / 2;
st[it].a[0][0] = 1;
st[it].a[1][1] = 1;
st[it].a[0][1] = 0;
st[it].a[1][0] = 0;
build(2 * it, l, m);
build(2 * it + 1, m + 1, r);
tr[it] = tr[2 * it] + tr[2 * it + 1];
}
}
void sets(int it, mat x) {
st[it] = x * st[it];
tr[it] = x * tr[it];
}
bool operator==(mat x, mat y) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
if (x.a[i][j] != y.a[i][j]) {
return false;
}
}
}
return true;
}
bool operator!=(mat x, mat y) { return !(x == y); }
mat e(1, 0, 0, 1);
void push(int it) {
if (st[it] != e) {
sets(2 * it, st[it]);
sets(2 * it + 1, st[it]);
st[it] = e;
}
}
double dst(vt a) { return hypot(a.x, a.y); }
vt operator/(vt a, double x) {
a.x /= x;
a.y /= x;
return a;
}
vt operator*(vt a, double x) {
a.x *= x;
a.y *= x;
return a;
}
void change(int it, int l, int r, int lm, int rm, mat x) {
if (l == lm && r == rm) {
if (x.a[0][1] != 0) {
sets(it, x);
} else {
double d = dst(tr[it]);
tr[it] = tr[it] / d;
tr[it] = tr[it] * (d + x.a[0][0]);
}
} else {
push(it);
int m = (l + r) / 2;
if (rm <= m) {
change(2 * it, l, m, lm, rm, x);
} else if (lm > m) {
change(2 * it + 1, m + 1, r, lm, rm, x);
} else {
change(2 * it, l, m, lm, m, x);
change(2 * it + 1, m + 1, r, m + 1, rm, x);
}
tr[it] = tr[2 * it] + tr[2 * it + 1];
}
}
const double pi = acos(-1.0);
int main() {
int n, m;
scanf("%d %d", &n, &m);
build(1, 0, n - 1);
for (int i = 0; i < m; i++) {
int tp, pos;
double z;
scanf("%d %d %lf", &tp, &pos, &z);
pos--;
mat x;
if (tp == 1) {
x = mat(z, 0, 0, z);
change(1, 0, n - 1, pos, pos, x);
} else {
z /= 180;
z *= pi;
x = mat(cos(z), sin(z), -sin(z), cos(z));
change(1, 0, n - 1, pos, n - 1, x);
}
printf("%.5lf %.5lf\n", tr[1].x, tr[1].y);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int fa[100010];
int Find(int x) { return fa[x] == x ? x : fa[x] = Find(fa[x]); }
int main() {
int n, k, x, y;
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) fa[i] = i;
int ans = 0;
for (int i = 1; i <= k; i++) {
scanf("%d%d", &x, &y);
int g1 = Find(x), g2 = Find(y);
if (g1 != g2) fa[g1] = g2, ans++;
}
printf("%d\n", k - ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double dp[51][200001];
double A[200001];
double suf[200002];
double cst[200002];
double inv[200002];
const double EPS = 1e-9;
inline double compute(int L, int R) {
return cst[L] - cst[R + 1] - (suf[L] - suf[R + 1]) * (inv[R + 1]);
}
int cost(int n, int qL, int qR, int k) {
qR = min(qR, n - 1);
assert(qL <= qR);
int ret = qR, i;
double cost = 0;
dp[k][n] = 1e22;
for (i = qR; i >= qL; --i) {
cost = compute(i + 1, n);
if (cost + dp[k - 1][i] < dp[k][n] + EPS) {
ret = i;
dp[k][n] = cost + dp[k - 1][i];
}
}
return ret;
}
void divide(int L, int R, int qL, int qR, int K) {
if (L > R) return;
if (L == R) {
cost(L, qL, qR, K);
return;
}
int M = (L + R) / 2;
int idx = cost(M, qL, qR, K);
divide(L, M - 1, qL, idx, K);
divide(M + 1, R, idx, qR, K);
}
int main() {
int N, K, i, j;
cin >> N >> K;
for (i = 1; i <= N; ++i) cin >> A[i];
for (i = N; i >= 1; --i) {
inv[i] = inv[i + 1] + 1.0 / A[i];
cst[i] = cst[i + 1] + inv[i] * A[i];
suf[i] = suf[i + 1] + A[i];
}
dp[0][0] = 0.0;
for (i = 1; i <= N; ++i) dp[0][i] = 1e22;
for (i = 1; i <= K; ++i) divide(1, N, 0, N - 1, i);
cout.precision(11);
cout << fixed << (dp[K][N]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1 << 30) - 1;
const int maxn = 1 << 17;
long long n, pos[maxn];
int vis[maxn];
struct node {
long long id, d, s;
} t[maxn];
int main() {
queue<int> Q;
long long cnt = 0;
scanf("%I64d", &n);
for (long long i = 0; i < n; ++i) {
scanf("%I64d%I64d", &t[i].d, &t[i].s);
cnt += t[i].d;
t[i].id = i;
if (t[i].d == 1) Q.push(i);
}
printf("%I64d\n", cnt / 2);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
if (t[x].d != 1) continue;
long long id = t[x].s;
t[id].s ^= t[x].id;
t[id].d--;
if (t[id].d == 1) Q.push(id);
printf("%I64d %I64d\n", t[x].id, t[id].id);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2000;
long long grafo[MAXN][MAXN];
int main() {
long long sum = 0, cnt = 0;
int n = 0, k = 0, temp = 0;
cin >> n >> k;
for (int i = 0; i < n - 1; ++i) {
grafo[i][i] = -1;
for (int j = i + 1; j < n; ++j) {
scanf("%d", &temp);
grafo[j][i] = grafo[i][j] = temp;
if (temp != -1) sum += temp;
}
}
grafo[n - 1][n - 1] = -1;
if (k == 1 || (k > 2 && n == k + 1)) {
sum = 2 * sum;
cnt = n;
}
if (k == 2) {
sum = 0;
cnt = n * (n - 1) / 2;
vector<int> vect;
for (int i = 0; i < n; ++i) {
vect.clear();
for (int j = 0; j < n; ++j)
if (grafo[i][j] != -1) vect.push_back(j);
for (int j = 0; j < vect.size(); ++j)
for (int z = j + 1; z < vect.size(); ++z)
sum += grafo[i][vect[j]] + grafo[i][vect[z]];
}
}
cout << sum / cnt << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int L[5];
long long c;
long long A[100000], B[100000];
int n;
long long days(long long mid) {
long long act = n;
for (int i = (0); i < (n); i++) {
if (A[i]) act += (mid / B[i]);
if (act > c) return c + 1;
}
act = n;
for (int i = (0); i < (n); i++) {
act += (mid / B[i]) * A[i];
if (act > c) return c + 1;
}
act = n;
for (int i = (0); i < (n); i++) {
act += (mid * A[i]) / B[i];
if (act > c) return c + 1;
}
return act;
}
long long maxC() {
long long lo = 0, hi = (long long)1e18;
while (lo < hi) {
long long mid = (lo + hi + 1) / 2;
if (days(mid) > c)
hi = mid - 1;
else
lo = mid;
}
return hi;
}
long long minC() {
long long lo = 0, hi = (long long)1e18;
while (lo < hi) {
long long mid = (lo + hi) / 2;
if (days(mid) < c)
lo = mid + 1;
else
hi = mid;
}
return lo;
}
int main() {
cin >> n >> c;
for (int i = (0); i < (n); i++) cin >> A[i] >> B[i];
int inf = 1;
for (int i = (0); i < (n); i++) inf = inf && (A[i] == 0);
if (inf)
cout << -1 << endl;
else {
long long m = minC();
long long M = maxC();
if (m == 0) m++;
if (days(m) == c && days(M) == c && M >= m)
cout << M - m + 1;
else
cout << 0 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:20000000")
using namespace std;
int ri() {
int x;
scanf("%d", &x);
return x;
}
long long rll() {
long long x;
scanf("%lld", &x);
return x;
}
long long fact[200500];
long long rev[200500];
long long MOD = 1e9 + 7;
long long bin_s(long long x, long long step) {
long long res = 1;
while (step) {
if (step & 1) res *= x, res %= MOD;
x *= x;
x %= MOD;
step >>= 1;
}
return res;
}
pair<int, int> mas[2050];
int dp[2050];
void add(int &x, int v) {
x += v;
if (x >= MOD) x -= MOD;
}
int getValue(int i, int j) {
int nx = mas[j].first;
int ny = mas[j].second;
int x = mas[i].first;
int y = mas[i].second;
int len = nx - x + ny - y;
long long temp = fact[len];
temp *= rev[nx - x];
temp %= MOD;
temp *= rev[len - (nx - x)];
temp %= MOD;
return (int)temp;
}
void solve() {
int n = ri(), m = ri(), cnt = ri();
fact[0] = rev[0] = 1;
for (int i = (int)(1); i <= (int)(n + m); i++) {
fact[i] = (fact[i - 1] * (long long)i) % MOD;
rev[i] = bin_s(fact[i], MOD - 2);
}
for (int i = (int)(0); i <= (int)(cnt - 1); i++)
mas[i].first = ri(), mas[i].second = ri();
mas[cnt] = make_pair(n, m);
mas[cnt + 1] = make_pair(1, 1);
sort(mas, mas + 1 + cnt);
for (int i = (int)(0); i <= (int)(cnt); i++) {
dp[i] = getValue(cnt + 1, i);
for (int j = (int)(0); j <= (int)(i - 1); j++) {
if (mas[j].second > mas[i].second) continue;
long long a = dp[j];
long long b = getValue(j, i);
long long c = (a * b) % MOD;
dp[i] -= c;
if (dp[i] < 0) dp[i] += MOD;
}
}
cout << dp[cnt] << endl;
}
int main() {
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
const long double error = 2e-6;
const long double PI = acosl(-1);
mt19937 rng((unsigned)chrono::system_clock::now().time_since_epoch().count());
inline long long int MOD(long long int x, long long int m = mod) {
long long int y = x % m;
return (y >= 0) ? y : y + m;
}
const int inf = 1e9;
const long long int infl = LLONG_MAX;
const int nmax = 3000 + 10;
vector<int> adj[nmax];
long long int val[nmax];
int n, m;
pair<int, long long int> memo[nmax][nmax];
int vis[nmax][nmax], clk;
inline void maxself(int a, int b, pair<int, long long int> q) {
if (vis[a][b] != clk) {
vis[a][b] = clk;
memo[a][b] = q;
} else {
memo[a][b] = max(memo[a][b], q);
}
}
int dfs(int root, int par) {
int ret = 0;
memo[root][0] = make_pair(0, 0ll);
for (int x : adj[root]) {
if (x == par) continue;
int tmp = dfs(x, root);
clk++;
for (int i = min(m - 1, ret); i >= 0; i--) {
auto p = memo[root][i];
for (int j = min(m - 1 - i, tmp - 1); j >= 0; j--) {
auto q = memo[x][j];
maxself(root, i + j, make_pair(p.first + q.first, p.second + q.second));
maxself(root, i + j + 1,
make_pair(p.first + q.first + (q.second > 0), p.second));
}
}
ret += tmp;
}
ret++;
for (int i = 0; i <= min(ret - 1, m - 1); i++) {
memo[root][i].second += val[root];
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int tc;
cin >> tc;
for (int cs = 1; cs <= tc; cs++) {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> val[i];
val[i] = -val[i];
}
for (int i = 1; i <= n; i++) {
long long int x;
cin >> x;
val[i] += x;
adj[i].clear();
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, -1);
int ans = memo[1][m - 1].first + (memo[1][m - 1].second > 0);
cout << ans << "\n";
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int t, n, a[1010], s[2];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
s[0] = s[1] = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
s[a[i]]++;
}
if (s[0] >= n / 2) {
printf("%d\n", s[0]);
for (int i = 0; i < s[0]; i++) {
printf("0 ");
}
puts("");
} else {
printf("%d\n", s[1] / 2 * 2);
for (int i = 0; i < s[1] / 2 * 2; i++) {
printf("1 ");
}
puts("");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s1, s2, s3 = "";
cin >> s1 >> s2;
for (int i = 0; i < n; i++) {
s3 += to_string(((s1[i] - '0') + (s2[i] - '0')) % 2);
}
s3 += '0';
int count = 0;
for (int i = 0; i < n; i++) {
if (s3[i] == '1') {
if (s3[i + 1] == '1') {
if (s2[i] == '0' && s2[i + 1] == '0')
count++;
else if (s2[i] == '0' && s2[i + 1] == '1') {
count++;
i++;
} else if (s2[i] == '1' && s2[i + 1] == '0') {
count++;
i++;
} else if (s2[i] == '1' && s2[i + 1] == '1')
count++;
} else {
count++;
}
}
}
cout << count;
}
| 2 |
/*
* CM = March
* M = April
* IM = July
* GM = September
* IGM = December
*/
// region config
#include <bits/stdc++.h>
#define F first
#define S second
#define pb push_back
#define mp make_pair
typedef long long int lli;
#define pll pair<lli, lli>
#define pil pair<int, lli>
#define pli pair<lli, int>
#define pii pair<int, int>
#define pdd pair<double, double>
#define vi vector<int>
#define vl vector<lli>
#define pq priority_queue
#define end end
#define beg begin
#define lb lower_bound
#define ub upper_bound
#define dmx(x, y) x = max(x, y)
#define dmn(x, y) x = min(x, y)
using namespace std;
void setIO(string str, bool dbg) {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
if (!dbg) {
freopen((str + ".in").c_str(), "r", stdin);
freopen((str + ".out").c_str(), "w", stdout);
}
}
// .region
const int MAX = 2e5 + 5;
const int LEN = 5e2 + 0;
const int LVL = 2e1 + 0;
const lli MOD = 1e9 + 7;
const lli INF = 2e9;
int xyz = 1; // test cases
int n, m;
int a, b;
int arr[MAX];
void run() {
cin >> n >> m >> a >> b;
for (int i = 1; i <= m; i++)
cin >> arr[i];
sort(arr + 1, arr + 1 + m);
int time = abs(a - b) - 1;
int bufr = (a > b ? n - a : a - 1);
int cnt = 0;
for (int i = m; i >= 1; i--) {
//cout << i << ": " << arr[i] << ": " << time << " " << bufr << endl;
if (!time || arr[i] > time + bufr)
continue;
time--, cnt++;
}
cout << cnt << "\n";
}
int main() {
setIO("", 1);
cin >> xyz;
while (xyz--) run();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 30010;
struct State {
bitset<MAX> left;
bitset<MAX> right;
long long len = 0, res = 0;
};
int n;
bitset<MAX> all;
State Unite(const State &a, const State &b) {
State c;
c.len = a.len + b.len;
c.res = a.res + b.res;
c.left = a.left;
c.right = b.right;
if (a.len < n - 1) c.left &= (b.left >> a.len) | (all << (n - 1 - a.len));
if (b.len < n - 1) c.right &= (a.right << b.len) | (all >> (n - 1 - b.len));
if (a.len + b.len >= n) {
bitset<MAX> d = a.right & b.left;
if (a.len < n - 1) d &= (all >> (n - 1 - a.len));
if (b.len < n - 1) d &= (all << (n - 1 - b.len));
c.res += d.count();
}
return c;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int d, m;
cin >> d >> m;
vector<int> gen(d);
for (int i = 0; i < d; i++) cin >> gen[i];
cin >> n;
vector<int> b(n);
for (int i = 0; i < n; i++) cin >> b[i];
long long L, R;
cin >> L >> R;
for (int i = 1; i < n; i++) all.set(i);
vector<vector<State>> states(1, vector<State>(m));
for (int i = 0; i < m; i++) {
states[0][i].len = 1;
if (n == 1)
states[0][i].res = b[0] >= i;
else {
for (int j = 1; j < n; j++)
if (b[j] >= i) states[0][i].left.set(j);
for (int j = 1; j < n; j++)
if (b[j - 1] >= i) states[0][i].right.set(j);
}
}
long long z = 1;
while (z <= R / d) {
int sz = (int)states.size();
states.resize(sz + 1);
states[sz].resize(m);
for (int i = 0; i < m; i++) {
State cur = states[sz - 1][i];
for (int j = 1; j < d; j++)
cur = Unite(cur, states[sz - 1][(i + gen[j]) % m]);
states[sz][i] = cur;
}
z *= d;
}
auto calc = [&](long long up) -> long long {
State res;
int shift = 0;
for (int i = (int)states.size() - 1; i >= 0; i--) {
z = 1;
for (int j = 0; j < i; j++) z *= d;
for (int j = 0; j < d; j++)
if (up >= z) {
res = Unite(res, states[i][(shift + gen[j]) % m]);
up -= z;
} else {
shift = (shift + gen[j]) % m;
break;
}
}
return res.res;
};
cout << calc(R) - calc(L + n - 2) << '\n';
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
typedef struct {
int x, y;
} Tlho;
bool bunga(Tlho a, Tlho b) {
if (a.x + a.y != b.x + b.y) return a.x + a.y < b.x + b.y;
return a.x < b.x;
}
vector<Tlho> wew;
int main() {
int N;
scanf("%d", &N);
int y;
for (y = N / 7; y >= 0; y--) {
int sisa = N - 7 * y;
if (sisa % 4 == 0) wew.push_back((Tlho){sisa / 4, y});
}
int zz = min_element(wew.begin(), wew.end(), bunga) - wew.begin();
if (zz < (int)wew.size()) {
for (int i = 0; i < wew[zz].x; i++) printf("4");
for (int i = 0; i < wew[zz].y; i++) printf("7");
} else
puts("-1");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long mod = 1e9 + 7;
int t;
cin >> t;
while (t--) {
long long n, ans = 1;
cin >> n;
for (int i = 3; i <= 2 * n; i++) {
ans = (ans * i) % mod;
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <random>
using namespace std;
const int N = 1005;
const int M = 10005;
const double P = 0.6892;
int n, m;
char s[N];
int wrong[N];
double pr[M];
mt19937 gen(19260817);
void solve()
{
scanf("%s", s);
double sum = 0.0;
int mn = *min_element(wrong, wrong + n);
for (int i = 0; i < n; ++i) sum += pr[wrong[i] - mn];
double rnd = uniform_real_distribution<>(0.0, sum)(gen);
double cur = 0.0;
for (int i = 0; i < n; ++i)
{
cur += pr[wrong[i] - mn];
if (cur < rnd) continue;
putchar(s[i]);
putchar('\n');
fflush(stdout);
break;
}
char ch;
scanf(" %c", &ch);
for (int i = 0; i < n; ++i)
wrong[i] += s[i] != ch;
}
int main()
{
scanf("%d%d", &n, &m);
pr[0] = 1.0;
for (int i = 1; i <= m; ++i)
pr[i] = pr[i - 1] * P;
for (int i = 0; i < m; ++i) solve();
return 0;
} | 9 |
#include <bits/stdc++.h>
int main(void) {
int w, h, k, c, e;
scanf("%d %d %d", &w, &h, &k);
c = 0;
do {
e = (w * h) - ((w - 2) * (h - 2));
w -= 4;
h -= 4;
c += e;
} while (--k);
printf("%d", c);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
static int N;
static int M;
static int Q;
static int w[500000];
static int C[4096];
static int cost[4096];
static int ans[4096][101];
static int read10(void) {
int c;
while ((c = getchar()) < '0') continue;
int n = 0;
do n = 10 * n + c - '0';
while ((c = getchar()) >= '0');
return n;
}
static int read2(void) {
int c;
while ((c = getchar()) < '0') continue;
int n = 0;
do n = 2 * n + c - '0';
while ((c = getchar()) >= '0');
return n;
}
int main(void) {
N = read10();
M = read10();
Q = read10();
for (int i = 0; i < N; i++) w[i] = read10();
for (int i = 0; i < M; i++) C[read2()]++;
for (int i = 0; i < (1 << N); i++) {
for (int j = 0; j < N; j++)
if (i & (1 << j)) cost[i] += w[N - 1 - j];
}
for (int i = 0; i < (1 << N); i++)
for (int j = 0; j < (1 << N); j++)
if (cost[i ^ j] < 101) ans[~i & ((1 << N) - 1)][cost[i ^ j]] += C[j];
for (int i = 0; i < (1 << N); i++)
for (int k = 1; k < 101; k++) ans[i][k] += ans[i][k - 1];
for (int i = 0; i < Q; i++) {
int t = read2();
int k = read10();
printf("%d\n", ans[t][k]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t, n, i, j, k, m, q;
string s;
t = 1;
while (t--) {
cin >> n;
vector<vector<long long>> grid(3, vector<long long>(n, 0));
vector<vector<long long>> dp(
3, vector<long long>(n, numeric_limits<long long>::min()));
for (auto &x : grid) {
for (auto &y : x) cin >> y;
}
dp[0][0] = grid[0][0];
dp[1][0] = grid[1][0] + grid[0][0];
dp[2][0] = grid[2][0] + grid[1][0] + grid[0][0];
for (i = 1; i < n; i++) {
dp[0][i] = max(dp[0][i], dp[0][i - 1] + grid[0][i]);
dp[0][i] = max(dp[0][i], dp[1][i - 1] + grid[1][i] + grid[0][i]);
dp[0][i] =
max(dp[0][i], dp[2][i - 1] + grid[2][i] + grid[1][i] + grid[0][i]);
if (i >= 2)
dp[0][i] = max(dp[0][i], dp[2][i - 2] + grid[2][i - 1] + grid[2][i] +
grid[1][i] + grid[1][i - 1] +
grid[0][i - 1] + grid[0][i]);
else
dp[0][i] =
max(dp[0][i], grid[2][i - 1] + grid[2][i] + grid[1][i] +
grid[1][i - 1] + grid[0][i - 1] + grid[0][i]);
dp[1][i] = max(dp[1][i], dp[1][i - 1] + grid[1][i]);
dp[1][i] = max(dp[1][i], dp[0][i - 1] + grid[0][i] + grid[1][i]);
dp[1][i] = max(dp[1][i], dp[2][i - 1] + grid[2][i] + grid[1][i]);
dp[2][i] = max(dp[2][i], dp[2][i - 1] + grid[2][i]);
dp[2][i] = max(dp[2][i], dp[1][i - 1] + grid[1][i] + grid[2][i]);
dp[2][i] =
max(dp[2][i], dp[0][i - 1] + grid[0][i] + grid[1][i] + grid[2][i]);
if (i >= 2)
dp[2][i] = max(dp[2][i], dp[0][i - 2] + grid[2][i - 1] + grid[2][i] +
grid[1][i] + grid[1][i - 1] +
grid[0][i - 1] + grid[0][i]);
else
dp[2][i] =
max(dp[2][i], grid[2][i - 1] + grid[2][i] + grid[1][i] +
grid[1][i - 1] + grid[0][i - 1] + grid[0][i]);
}
cout << dp[2][n - 1] << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
int arr[n], tot = 0, mx = 0;
for (i = 0; i < n; i++) {
cin >> arr[i];
tot += arr[i];
mx = max(mx, arr[i]);
}
mx--;
int tot2 = 0;
while (tot2 <= tot) {
mx++;
tot2 = 0;
for (i = 0; i < n; i++) {
tot2 += mx - arr[i];
}
}
cout << mx << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, k, t;
struct Stats {
long long int nBefore, nAfter, sLeft, sRight;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
map<int, int> num;
for (int i = 0; i < n; i++) {
cin >> t;
if (num[t]) {
num[t]++;
} else
num[t] = 1;
}
t = num.size();
for (auto a : num) {
if (a.second >= k) {
cout << 0 << '\n';
return 0;
}
}
vector<pair<int, int>> v(num.begin(), num.end());
vector<Stats> s(t);
long long int rsum = v[t - 1].second, lsum = v[0].second, rsteps = 0,
lsteps = 0;
s[0].nBefore = lsum;
s[0].sLeft = 0;
s[t - 1].nAfter = rsum;
s[t - 1].sRight = 0;
for (int i = 1, j = t - 2; i < t; ++i, --j) {
lsteps += (v[i].first - v[i - 1].first) * lsum;
lsum += v[i].second;
rsteps += (v[j + 1].first - v[j].first) * rsum;
rsum += v[j].second;
s[i].nBefore = lsum;
s[i].sLeft = lsteps;
s[j].nAfter = rsum;
s[j].sRight = rsteps;
}
long long int min_moves = LONG_LONG_MAX;
for (auto it = s.begin(); it != s.end(); ++it) {
long long int m;
bool cond1 = it->nBefore >= k, cond2 = it->nAfter >= k;
if (cond1 && cond2) {
m = min(it->sLeft - it->nBefore, it->sRight - it->nAfter) + k;
} else if (cond1) {
m = it->sLeft - it->nBefore + k;
} else if (cond2) {
m = it->sRight - it->nAfter + k;
} else {
m = it->sLeft + it->sRight - n + k;
}
min_moves = min(min_moves, m);
}
cout << min_moves << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
const int mod = 1e9 + 7;
const long long INF = 2e15;
long long qpower(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) ans = ans * a % mod;
b >>= 1;
a = a * a % mod;
}
return ans;
}
long long n, k;
int main(int argc, char const *argv[]) {
std::cin >> n >> k;
if (k == 0) {
std::cout << n << '\n';
return 0;
}
int cnt = 0;
for (int i = 0; i < k; i++) {
if (n % 10 == 0) {
cnt++;
n /= 10;
} else
break;
}
for (int i = cnt; i < k; i++) {
if (n % 5 == 0) n /= 5;
if (n % 2 == 0) n /= 2;
}
for (int i = 1; i <= k; i++) {
n *= 10;
}
std::cout << n << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 5;
int n, A[N], P[N], f[N];
void solve() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &A[i]);
for (int i = 1; i < 2 * n; ++i) P[i] = -1, f[i] = n + 1;
f[0] = f[1] = -n;
for (int i = 1; i < n; ++i)
for (int x = 0; x < 2; ++x)
for (int y = 0; y < 2; ++y) {
int v[2] = {f[i * 2 - 2 + y], A[i - 1] * (2 * y - 1)};
for (int j = 0; j < 2; ++j)
if (v[j] <= A[i] * (2 * x - 1) && v[(j == 0)] < f[i * 2 + x])
f[i * 2 + x] = v[!j], P[i * 2 + x] = i * 2 - 2 + y;
}
if (f[2 * n - 1] <= n) {
puts("YES");
for (int i = n - 1, x = 2 * n - 1; ~i; --i, x = P[x])
if (x % 2 == 0) A[i] *= -1;
for (int i = 0; i < n; ++i) printf("%d ", A[i]);
puts("");
} else {
puts("NO");
}
}
int main() {
int T;
scanf("%d", &T);
while (T--) solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 1e6 + 5;
int n, m, deg[N], fa[N], vis[N], rt;
ll ans, s, k;
int fd(int x) { return fa[x] == x ? x : fa[x] = fd(fa[x]); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1, x, y; i <= m; ++i) {
scanf("%d%d", &x, &y), rt = x, vis[x] = vis[y] = 1;
if (x == y)
++s;
else
++deg[x], ++deg[y], ++k, fa[fd(x)] = fd(y);
}
for (int i = 1; i <= n; ++i)
if (vis[i] && fd(i) != fd(rt)) return puts("0"), 0;
ans = s * (s - 1) / 2 + s * k;
for (int i = 1; i <= n; ++i) ans += 1LL * deg[i] * (deg[i] - 1) / 2;
printf("%lld", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[25];
void rotate(vector<int> t) {
for (int j = 0; j < 2; j++) {
int temp = a[t[0]];
for (int i = 1; i < t.size(); i++) a[t[i - 1]] = a[t[i]];
a[t.back()] = temp;
}
}
void move(int type) {
if (type == 0) rotate({1, 3, 5, 7, 9, 11, 24, 22});
if (type == 1) rotate({2, 4, 6, 8, 10, 12, 23, 21});
if (type == 2) rotate({9, 10, 19, 17, 4, 3, 14, 16});
if (type == 3) rotate({11, 12, 20, 18, 2, 1, 13, 15});
if (type == 4) rotate({13, 14, 5, 6, 17, 18, 21, 22});
if (type == 5) rotate({15, 16, 7, 8, 19, 20, 23, 24});
}
bool ok(vector<int> q) {
int cc = a[q[0]];
for (int to : q)
if (a[to] != cc) return 0;
return 1;
}
bool check() {
return ok({1, 2, 3, 4}) && ok({5, 6, 7, 8}) && ok({9, 10, 11, 12}) &&
ok({13, 14, 15, 16}) && ok({21, 22, 23, 24});
}
int main() {
int t;
for (int i = 1; i <= 24; i++) cin >> a[i];
int i;
for (i = 0; i < 6; i++) {
move(i);
if (check()) {
cout << "Yes" << endl;
break;
}
move(i);
move(i);
if (check()) {
cout << "Yes" << endl;
break;
}
move(i);
}
if (i == 6) cout << "No" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> in(1024, 0);
bool check(int k) {
for (int i = 0; i < 1024; i++) {
if (in[i] && in[i ^ k] == 0) return 0;
}
return 1;
}
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
in[t] = 1;
}
int anw = -1;
for (int i = 1023; i > 0; i--) {
if (check(i)) anw = i;
}
cout << anw << endl;
in.assign(1024, 0);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char str[50009];
int A[50009], B[50009];
struct node {
int id, cost;
node() {}
node(int n1, int n2) : id(n1), cost(n2) {}
};
bool operator<(const node &elem1, const node &elem2) {
return elem1.cost > elem2.cost;
}
int n;
void solve() {
int balance = 0;
long long res = 0;
priority_queue<node> q;
for (int i = 1; i <= n; i++) {
if (str[i] == '(')
balance++;
else if (str[i] == ')')
balance--;
else {
res += B[i];
str[i] = ')';
balance--;
q.push(node(i, A[i] - B[i]));
}
while (balance < 0) {
if (q.empty()) {
printf("-1\n");
return;
}
balance += 2;
res += q.top().cost;
str[q.top().id] = '(';
q.pop();
}
}
if (balance > 0) {
printf("-1\n");
return;
}
for (int i = 1; i <= n; i++) {
if (str[i] == '?')
while (1) printf("1111111111\n");
}
printf("%I64d\n%s\n", res, str + 1);
}
int main() {
for (;;) {
if (scanf("%s", str + 1) == EOF) break;
n = strlen(str + 1);
for (int i = 1; i <= n; i++)
if (str[i] == '?') scanf("%d%d", &A[i], &B[i]);
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<pair<long long, int> > a;
for (int i = 0; i < n; ++i) {
long long x;
cin >> x;
a.push_back(make_pair(x, i + 1));
}
vector<int> m(2 * n + 10, 1);
sort(a.begin(), a.end());
vector<int> ans(n + 1);
long long sum = 0;
long long first = k + 1;
for (int i = a.size() - 1; i >= 0; --i) {
long long x = a[i].first;
long long y = a[i].second;
if (y > k && m[y]) {
m[y] = 0;
ans[y] = y;
} else {
m[first] = 0;
sum += (x * (first - y));
ans[y] = first;
}
while (!m[first]) {
++first;
}
}
cout << sum << endl;
for (int i = 1; i < ans.size(); ++i) {
cout << ans[i] << " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = int(1e9);
const double eps = 0.0000000001, pi = 3.14159265358979323;
const int maxn = int(2e5 + 100);
bool u[maxn];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
string s;
set<int> r, d;
cin >> n >> s;
for (int i = 0; i < n; ++i) {
if (s[i] == 'R')
r.insert(i);
else
d.insert(i);
}
set<int>::iterator it;
while (1) {
for (int i = 0; i < n; ++i) {
if (!u[i] && s[i] == 'R' && !d.empty()) {
it = d.lower_bound(i);
if (it != d.end()) {
u[*it] = 1;
d.erase(it);
} else {
it--;
if (it != d.end()) {
u[*it] = 1;
d.erase(it);
}
}
} else if (!u[i] && !r.empty()) {
it = r.lower_bound(i);
if (it != r.end()) {
u[*it] = 1;
r.erase(it);
} else {
it--;
if (it != r.end()) {
u[*it] = 1;
r.erase(it);
}
}
}
}
if (d.empty()) {
cout << "R";
return 0;
}
if (r.empty()) {
cout << "D";
return 0;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long Factorial[2000003], F_Inv[2000003];
long long Power(long long base, long long times) {
if (base == 0) return 0L;
if (times == 1) return base;
long long ans = 1;
long long base_binary = base;
while (times > 0) {
if (times % 2 == 1)
ans = ((ans % 1000000007) * (base_binary % 1000000007)) % 1000000007;
base_binary =
(base_binary % 1000000007) * (base_binary % 1000000007) % 1000000007;
times /= 2;
}
return ans % 1000000007;
}
long long nCr_mod_m(int n, int r) {
return ((Factorial[n] * (F_Inv[r] % 1000000007)) % 1000000007 *
(F_Inv[n - r] % 1000000007)) %
1000000007;
}
int main(void) {
Factorial[0] = 1L;
F_Inv[0] = 1L;
for (int i = (1); i <= (2000003); i++) {
Factorial[i] = Factorial[i - 1] * i % 1000000007;
F_Inv[i] = Power(Factorial[i], 1000000007 - 2);
}
int n, ans;
scanf("%d", &n);
ans = nCr_mod_m(2 * n + 2, n + 1) - 1;
cout << ans;
cout << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 7340033;
long long dp[31][1001];
void init() {
dp[0][0] = 1;
for (int i = 1; i < 31; i++) {
long long tmp[5][1001];
memset(tmp, 0, sizeof(tmp));
tmp[0][0] = 1;
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 1001; k++) {
for (int l = 0; k + l < 1001; l++) {
tmp[j + 1][k + l] += tmp[j][k] * dp[i - 1][l] % MOD;
tmp[j + 1][k + l] %= MOD;
}
}
}
dp[i][0] = 1;
for (int j = 1; j < 1001; j++) {
dp[i][j] = tmp[4][j - 1];
}
}
}
int main() {
int q;
scanf("%d", &q);
init();
while (q--) {
int n, k;
scanf("%d %d", &n, &k);
int h = 0;
while (n > 1 && n % 2) {
++h;
n >>= 1;
}
printf("%d\n", dp[h][k]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
long long q;
cin >> q;
while (q--) {
string tmp;
cin >> tmp;
string num;
for (long long i = 4; i < (long long)tmp.size(); i++) {
num.push_back(tmp[i]);
}
long long k = (long long)num.size();
cerr << "k " << k << endl;
long long l = 1989;
long long pw = 1;
for (long long i = 0; i < k; i++) {
if (i > 0) {
l += pw;
}
pw *= 10;
}
long long r = l + pw;
cerr << l << ' ' << r << endl;
for (long long i = 0; i <= 3000; i++) {
string uu = to_string(i);
string res = uu + num;
long long res_i = stoll(res);
if (l <= res_i && res_i < r) {
cout << res_i << '\n';
break;
}
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char getc() {
char c = getchar();
while ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && (c < '0' || c > '9'))
c = getchar();
return c;
}
int gcd(int n, int m) { return m == 0 ? n : gcd(m, n % m); }
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * f;
}
int n, k, a[5010], f[5010][5010], ans;
int ksm(int a, int k) {
int s = 1;
for (; k; k >>= 1, a = 1ll * a * a % 1000000007)
if (k & 1) s = 1ll * s * a % 1000000007;
return s;
}
int inv(int a) { return ksm(a, 1000000007 - 2); }
void inc(int &x, int y) {
x += y;
if (x >= 1000000007) x -= 1000000007;
}
signed main() {
const char LL[] = "%lld\n";
n = read(), k = read();
for (int i = 1; i <= n; i++) a[i] = read();
f[0][0] = 1;
for (int i = 1; i <= n; i++) {
f[i][0] = 1ll * f[i - 1][0] * a[i] % 1000000007;
for (int j = 1; j <= i; j++)
f[i][j] = (1ll * f[i - 1][j] * a[i] - f[i - 1][j - 1] + 1000000007) %
1000000007;
}
int s = 1;
for (int i = 0; i <= min(k, n); i++) {
inc(ans, 1ll * ksm(n, k - i) * f[n][i] % 1000000007 * s % 1000000007);
s = 1ll * s * (k - i) % 1000000007;
}
ans = 1ll * ans * inv(ksm(n, k)) % 1000000007;
ans = (f[n][0] - ans + 1000000007) % 1000000007;
cout << ans;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long SIZE = 5e3 + 5;
const long long mod = 1e9 + 7;
bool ok[SIZE];
bool vis[SIZE];
vector<long long> adj[SIZE];
vector<pair<long long, long long> > conn;
long long cap, cnt;
void dfs(long long u) {
if (ok[u]) return;
ok[u] = 1;
long long i, v;
for (i = 0; i < adj[u].size(); i++) {
v = adj[u][i];
dfs(v);
}
}
void dfs1(long long u) {
if (vis[u]) return;
vis[u] = 1;
cnt++;
long long i, v;
for (i = 0; i < adj[u].size(); i++) {
v = adj[u][i];
dfs1(v);
}
}
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
return (a.second > b.second);
}
int main() {
long long t = 0, n, x, y, z, i, j, k, g, p, q, ans = 0, sum = 0, c = 0;
scanf("%lld %lld", &n, &q);
scanf("%lld", &cap);
for (i = 1; i <= q; i++) {
scanf("%lld %lld", &x, &y);
adj[x].push_back(y);
}
dfs(cap);
for (i = 1; i <= n; i++) {
if (!ok[i]) {
cnt = 0;
memset(vis, 0, sizeof vis);
dfs1(i);
conn.push_back(make_pair(i, cnt));
}
}
sort(conn.begin(), conn.end(), cmp);
for (i = 0; i < conn.size(); i++) {
x = conn[i].first;
if (!ok[x]) {
dfs(x);
ans++;
}
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int L(int i) { return i << 1; }
inline int R(int i) { return (i << 1) | 1; }
inline int B(int i) { return 1 << i; }
inline int low_bit(int x) { return x & (-x); }
long long cnt[1010], top;
long long tmp, mul;
bool must_win(long long a, long long b) {
if (a == 0 || b == 0) return 0;
if (a > b) tmp = a, a = b, b = tmp;
if (must_win(b % a, a) == 0) return 1;
tmp = b;
tmp /= a;
tmp %= a + 1;
if (tmp & 1) return 0;
return 1;
}
int main() {
int t;
long long a, b;
cin >> t;
while (t--) {
cin >> a >> b;
if (must_win(a, b))
puts("First");
else
puts("Second");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> &a, pair<int, int> &b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
bool isSquare(int n) {
int s = sqrt(n);
return (s * s == n);
}
bool isFibo(int n) {
return isSquare(5 * n * n + 4) || isSquare(5 * n * n - 4);
}
int main() {
int ans = 0, pre = 0, post = 0;
string s;
cin >> s;
for (int i = 0; i < s.length(); ++i) {
if (s[i] == 'A') {
pre = 0, post = 0;
for (int j = i - 1; j >= 0; --j) {
if (s[j] == 'Q') pre++;
}
for (int j = i + 1; j < s.length(); ++j) {
if (s[j] == 'Q') post++;
}
ans += pre * post;
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int l, r, p, prime[110], rez;
vector<int> V, dp, counted;
bool check(int x) {
for (int i = 2; i < x; ++i)
if (x % i == 0) return 0;
return 1;
}
void rek(int a, int b) {
if (b > p) return;
if (prime[b]) {
if ((long long)a > r / b) return;
rek(a, b + 1);
V.push_back(a * b);
rek(a * b, b);
} else
rek(a, b + 1);
}
int main() {
for (int i = 2; i < 110; ++i) prime[i] = check(i);
scanf("%d%d%d", &l, &r, &p);
V.push_back(1);
rek(1, 2);
sort(V.begin(), V.end());
dp.resize(V.size(), (int)1e9);
dp[0] = 0;
counted.resize(V.size(), 0);
for (int i = 2; i <= p; ++i) {
int idx = 0;
for (int j = 0; j < V.size() && idx < V.size(); ++j) {
while (idx < V.size() && i * V[j] > V[idx]) ++idx;
if (V[j] * i != V[idx]) continue;
dp[idx] = min(dp[idx], dp[j] + 1);
if (!counted[idx] && dp[idx] + i <= p) {
counted[idx] = 1;
if (l <= V[idx] && r >= V[idx]) ++rez;
}
}
}
printf("%d\n", rez);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int viz[N];
vector<int> v[N], vt[N];
bool has, viz1[N], viz2[N];
void check(int x) {
viz[x] = 1;
for (auto it : v[x]) {
if (viz[it] == 1) has = 1;
if (!viz[it]) check(it);
}
viz[x] = 2;
}
void dfs1(int x) {
viz1[x] = 1;
for (auto it : v[x])
if (!viz1[it]) dfs1(it);
}
void dfs2(int x) {
viz2[x] = 1;
for (auto it : vt[x])
if (!viz2[it]) dfs2(it);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
vt[y].push_back(x);
}
for (int i = 1; i <= n; i++)
if (!viz[i]) check(i);
if (has) {
cout << -1;
return 0;
}
int cnt = 0;
string ans;
for (int i = 1; i <= n; i++) {
if (viz1[i] || viz2[i])
ans += 'E';
else {
cnt++;
ans += 'A';
}
if (!viz1[i]) dfs1(i);
if (!viz2[i]) dfs2(i);
}
cout << cnt << "\n" << ans;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n;
pair<int, int> event[N];
int nxt2[N], nxt4[N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &event[i].first);
if (event[i].first == 1 || event[i].first == 3) {
scanf("%d", &event[i].second);
}
}
nxt2[n] = nxt4[n] = 1e9;
for (int i = n - 1; i >= 0; i--) {
if (event[i].first == 2)
nxt2[i] = i;
else
nxt2[i] = nxt2[i + 1];
if (event[i].first == 4)
nxt4[i] = i;
else
nxt4[i] = nxt4[i + 1];
}
bool can = true;
vector<int> limits;
int speed = 0, ans = 0;
for (int i = 0; i < n; i++) {
if (event[i].first == 1)
speed = event[i].second;
else if (event[i].first == 2)
assert(can);
else if (event[i].first == 3)
limits.push_back(event[i].second);
else if (event[i].first == 4)
can = true;
else if (event[i].first == 5)
limits.clear();
else if (event[i].first == 6) {
can = false;
if (nxt2[i] < nxt4[i]) can = true, ans++;
}
while (!limits.empty() && speed > limits.back()) {
limits.pop_back(), ans++;
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void checkmin(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T &a, T b) {
if (b > a) a = b;
}
int N, K;
vector<int> G[50061];
int dp[50061][510];
long long ans;
void dfs(int u, int p) {
for (int i = (0); i < (int)(((int)((G[u]).size()))); i++) {
int v = G[u][i];
if (v == p) continue;
dfs(v, u);
for (int j = (0); j < (int)(K); j++) dp[u][j + 1] += dp[v][j];
}
dp[u][0] = 1;
}
void rec(int u, int p) {
ans += dp[u][K];
if (p != -1) {
ans += dp[p][K - 1];
if (K - 2 >= 0) ans -= dp[u][K - 2];
for (int j = ((K)-1); j >= (int)(0); j--) {
dp[u][j + 1] += dp[p][j];
if (j > 0) dp[u][j + 1] -= dp[u][j - 1];
}
}
for (int i = (0); i < (int)(((int)((G[u]).size()))); i++) {
int v = G[u][i];
if (v == p) continue;
rec(v, u);
}
}
int main() {
scanf("%d%d", &N, &K);
for (int i = (0); i < (int)(N - 1); i++) {
int u, v;
scanf("%d%d", &u, &v);
u--, v--;
G[u].push_back(v), G[v].push_back(u);
}
memset((dp), 0, sizeof(dp));
dfs(0, -1);
ans = 0;
rec(0, -1);
ans /= 2;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
long long node[4 * N], root[4 * N], inds[N], indf[N], h[N], CNT, n, q;
vector<int> adj[N];
void DFS(int v, int par) {
inds[v] = CNT++;
for (int i = 0; i < adj[v].size(); i++)
if (adj[v][i] != par) {
h[adj[v][i]] = h[v] + 1;
DFS(adj[v][i], v);
}
indf[v] = CNT - 1;
}
void modify(int tag, int L, int R, int s, int e, int val) {
if (s >= R || e <= L) return;
if (s <= L && R <= e) {
node[tag] += val;
return;
}
modify(tag * 2, L, (L + R) / 2, s, e, val);
modify(tag * 2 + 1, (L + R) / 2, R, s, e, val);
}
void modify_root(int tag, int L, int R, int s, int e, int val) {
if (s >= R || e <= L) return;
if (s <= L && R <= e) {
root[tag] += val;
return;
}
modify_root(tag * 2, L, (L + R) / 2, s, e, val);
modify_root(tag * 2 + 1, (L + R) / 2, R, s, e, val);
}
int get_vert(int tag, int L, int R, int s, int e) {
if (e <= L || s >= R) return 0;
if (s <= L && R <= e) return node[tag];
return get_vert(tag * 2, L, (L + R) / 2, s, e) +
get_vert(tag * 2 + 1, (L + R) / 2, R, s, e) + node[tag];
}
int get_root(int tag, int L, int R, int s, int e) {
if (e <= L || s >= R) return 0;
if (s <= L && R <= e) return root[tag];
return get_root(tag * 2, L, (L + R) / 2, s, e) +
get_root(tag * 2 + 1, (L + R) / 2, R, s, e) + root[tag];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q;
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
DFS(1, 1);
while (q--) {
int t;
cin >> t;
if (t == 0) {
int v, val, d;
cin >> v >> val >> d;
if (d >= h[v]) {
int s = inds[v] - 2 * h[v] + d + 1, e = min(inds[v] + d, indf[v]);
if (s <= e) modify(1, 0, n, s, e + 1, val);
modify_root(1, 0, n, 0, d - h[v] + 1, val);
} else
modify(1, 0, n, inds[v] - d, min(inds[v] + d, indf[v]) + 1, val);
}
if (t == 1) {
int v;
cin >> v;
cout << get_vert(1, 0, n, inds[v], inds[v] + 1) +
get_root(1, 0, n, h[v], h[v] + 1)
<< endl;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 100100;
const long long INF = 2000000100;
const long long MOD = 998244353;
long long N, S, startS, BC;
long long P[MAXN], maxH;
vector<long long> VH[MAXN];
void output() {
cout << "Yes\n";
for (int i = 2; i <= N; i++) {
cout << P[i] << (i == N ? "\n" : " ");
}
}
void outP() {
for (int i = 1; i <= N; i++) {
cerr << P[i] << " ";
}
cerr << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin >> N >> S;
if (S < 2 * N - 1 || S > ((N + 1) * (N)) / 2) {
cout << "No\n";
return 0;
}
int a = 1, b = N - 1, c;
while (a <= b) {
c = (a + b) / 2;
long long p = 1, l = N, s = 0;
for (int i = 1; l > 0; i++) {
s += min(l, p) * i;
l -= min(l, p);
p *= c;
}
if (s <= S) {
BC = c;
startS = s;
b = c - 1;
} else {
a = c + 1;
}
}
long long p = BC;
long long start = 2;
P[1] = -1;
bool ok = true;
for (int i = 2; ok; i++) {
for (int j = start; j < start + p; j++) {
if (j == N + 1) {
ok = false;
break;
}
maxH = i;
VH[i].push_back(j);
P[j] = start - p / BC + (j - start) / BC;
}
if (!ok) break;
start += p;
p *= BC;
}
S -= startS;
if (S == 0) {
output();
return 0;
}
for (int i = maxH; i >= 1; i--) {
while (VH[i].size() > 1) {
int v = VH[i][(int)VH[i].size() - 1];
VH[i].pop_back();
if (maxH - i + 1 < S) {
S -= maxH - i + 1;
P[v] = VH[maxH][0];
maxH++;
VH[maxH].push_back(v);
} else {
P[v] = VH[i + S - 1][0];
i = 0;
break;
}
}
}
output();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 100500;
const int maxn = 450;
int n, m;
int e[maxn][maxn];
void scan() {
scanf("%d%d", &n, &m);
for (int i = 0; i < (int)(m); ++i) {
int x, y;
scanf("%d%d", &x, &y), --x, --y;
e[x][y] = e[y][x] = 1;
}
}
int d[maxn], q[maxn];
int bfs() {
for (int i = 0; i < (int)(n); ++i) d[i] = maxn;
int lq = 0, rq = 1;
q[0] = d[0] = 0;
while (lq != rq) {
int v = q[lq++];
for (int i = 0; i < (int)(n); ++i)
if (e[v][i] && d[i] == maxn) {
d[i] = d[v] + 1;
q[rq++] = i;
}
}
return d[n - 1];
}
int main() {
scan();
if (e[0][n - 1]) {
for (int i = 0; i < (int)(n); ++i)
for (int j = 0; j < (int)(n); ++j) e[i][j] ^= 1;
}
int res = bfs();
if (res == maxn)
cout << -1;
else
cout << res;
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
const int inf = 1e9 + 7;
int pr[] = {2, 3, 5, 7, 11, 13};
int up;
int tot[105];
int q[50000005], vis[1000005];
int sz;
pair<int, int> srt[1000005];
void dfs(int x, int y) {
if (y == sz) {
q[x] = 1;
return;
}
dfs(x, y + 1);
x *= pr[y];
while (x <= up) {
dfs(x, y + 1);
x *= pr[y];
}
}
int ans[N];
int main() {
int n;
scanf("%d", &n);
up = n * n * 2;
sz = 6;
if (n <= 100)
sz = 4;
else if (n <= 200)
sz = 5;
dfs(1, 0);
int cnt = 0;
for (int i = (1); i <= (up); i++)
if (q[i]) {
cnt++;
srt[cnt].second = i;
for (int j = (0); j <= (sz - 1); j++)
if (i % pr[j] == 0) {
srt[cnt].first ^= (1 << (j - 1));
tot[j]++;
}
}
sort(srt + 1, srt + 1 + cnt);
int cur = cnt;
for (int i = (1); i <= (cnt); i++) {
int flag = 1;
for (int j = (0); j <= (sz - 1); j++)
if (srt[i].second % pr[j] == 0)
if (tot[j] <= (n + 1) / 2) {
flag = 0;
break;
}
if (flag && cur > n) {
cur--;
vis[i] = 1;
for (int j = (0); j <= (sz - 1); j++)
if (srt[i].second % pr[j] == 0) tot[j]--;
}
}
for (int i = (1); i <= (cnt); i++)
if (!vis[i]) printf("%d ", srt[i].second);
puts("");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string a;
int n, k;
int main() {
cin >> a >> k;
n = a.length();
if (n % k != 0) {
cout << "NO";
return 0;
}
int z = n / k;
for (int i = 0; i < k; i++)
for (int j = 0; j < z / 2; j++)
if (a[i * z + j] != a[(i + 1) * z - 1 - j]) {
cout << "NO";
return 0;
}
cout << "YES";
}
| 1 |