solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int L, i, j, k, n, m, s, x, y;
pair<int, int> a[100000];
int p[10000];
double d[10000];
int ansp[10000];
int main() {
cin >> n >> L;
for (i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
}
n++;
double l = 0;
double r = 1000000000;
for (int t = 0; t < 60; t++) {
double x = (l + r) / 2;
if (x < 0.2) {
x = x;
}
for (i = 0; i <= n; i++) {
d[i] = 1000000000;
d[i] *= d[i];
}
d[0] = 0;
for (i = 0; i < n; i++)
for (j = 0; j < i; j++) {
double dis = sqrt(fabs(L - fabs(1.0 * a[j].first - a[i].first)));
if (d[i] > d[j] + dis - x * a[i].second) {
d[i] = d[j] + dis - x * a[i].second;
p[i] = j;
}
}
if (d[n - 1] < 1e-9) {
r = x;
for (i = 0; i < n; i++) ansp[i] = p[i];
} else {
l = x;
}
}
i = n - 1;
vector<int> v;
while (i != 0) {
v.push_back(i);
i = ansp[i];
}
for (i = v.size() - 1; i >= 0; i--) cout << v[i] << " ";
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int MAXN = 1e6 + 100;
void solve() {
int a[2], b[2], u, v, res;
for (int i = 0; i < 2; i++) cin >> a[i];
sort(a, a + 2);
for (int i = 0; i < 2; i++) cin >> b[i];
sort(b, b + 2);
for (int i = 0; i < 2; i++)
if (a[i] != b[i]) {
u = a[i];
v = b[i];
} else
res = a[i];
if (u + v == res)
cout << "yes\n";
else
cout << "no\n";
}
int main() {
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 5;
long long n, m, p;
pair<long long, long long> A[maxn];
pair<long long, long long> B[maxn];
const long long INF = -1e18;
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first == b.first) return a.second > b.second;
return a.first < b.first;
}
pair<long long, pair<long long, long long> > W[maxn];
const long long M = 1e6 + 5;
long long T[4 * M + 500];
long long lz[4 * M + 500];
long long a[M + 5];
long long _t[M + 5];
void build(long long l, long long r, long long x) {
if (l == r) {
T[x] = _t[l];
return;
}
long long mid = (l + r) / 2;
build(l, mid, 2 * x + 1);
build(mid + 1, r, 2 * x + 2);
T[x] = max(T[2 * x + 1], T[2 * x + 2]);
}
void modify(long long l, long long r, long long x, long long L, long long R,
long long v) {
if (l >= L && R >= r) {
T[x] = T[x] + v;
lz[x] += v;
return;
}
long long mid = (l + r) / 2;
T[2 * x + 1] = lz[x] + T[2 * x + 1];
T[2 * x + 2] = lz[x] + T[2 * x + 2];
lz[2 * x + 1] += lz[x];
lz[2 * x + 2] += lz[x];
lz[x] = 0;
if (L <= mid) {
modify(l, mid, 2 * x + 1, L, R, v);
}
if (R > mid) {
modify(mid + 1, r, 2 * x + 2, L, R, v);
}
T[x] = max(T[2 * x + 1], T[2 * x + 2]);
}
signed main() {
scanf("%lld", &(n));
scanf("%lld", &(m));
scanf("%lld", &(p));
fill(a, a + M + 5, INF);
for (long long i = 0; i < n; i++) {
scanf("%lld", &(A[i].first));
scanf("%lld", &(A[i].second));
a[A[i].first] = max(a[A[i].first], -A[i].second);
}
sort(A, A + n, cmp);
fill(T, T + 4 * M + 5, INF);
fill(_t, _t + M + 5, INF);
for (long long i = 0; i < m; i++) {
scanf("%lld", &(B[i].first));
scanf("%lld", &(B[i].second));
_t[B[i].first] = max(_t[B[i].first], -B[i].second);
}
for (long long i = M; i >= 0; i--) {
_t[i] = max(_t[i + 1], _t[i]);
a[i] = max(a[i], a[i + 1]);
}
build(0, M, 0);
for (long long i = 0; i < p; i++) {
scanf("%lld", &(W[i].first));
scanf("%lld", &(W[i].second.first));
scanf("%lld", &(W[i].second.second));
}
sort(W, W + p);
long long j = 0;
long long ans;
ans = a[0] + T[0];
for (long long i = 0; i < p; i++) {
modify(0, M, 0, W[i].second.first + 1, M, W[i].second.second);
ans = max(ans, a[W[i].first + 1] + T[0]);
if (a[W[i].first + 1] == INF) break;
}
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int i, a[3010] = {0};
for (i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a[x] += y;
}
int ct = 0, l = 0;
for (i = 0; i < 3010; i++) {
ct += min(a[i], k);
a[i] -= min(a[i], k);
a[i + 1] += min(a[i], k);
}
cout << ct;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int m = pow(10, 9) + 7;
int fact[100001], rev_fact[100001];
vector<int> divisors[1000001];
int* num_of_dis;
bool* check;
int expmod(int a, int b) {
int result = 1;
while (b > 0) {
if (b % 2 > 0) result = (result * (unsigned long long)a) % m;
a = (a * (unsigned long long)a) % m;
b /= 2;
}
return result;
}
int reverse_mod(int n) { return expmod(n, m - 2); }
void inline prepare_data() {
fact[0] = 1;
rev_fact[0] = 1;
for (int i = 1; i <= 100000; i++) {
for (int j = i; j <= 100000; j += i) {
divisors[j].push_back(i);
}
}
for (int i = 1; i <= 100000; i++) {
fact[i] = (fact[i - 1] * (unsigned long long)(i)) % m;
rev_fact[i] = reverse_mod(fact[i]);
}
}
int C(int n, int k) {
if (k < 0 || k > n)
return 0;
else if (k == 0 || k == n)
return 1;
else {
int result = (fact[n] * (unsigned long long)(rev_fact[k])) % m;
result = (result * (unsigned long long)(rev_fact[n - k])) % m;
return result;
}
}
int num_of_distributions(int n, int f) {
int result;
if (f == n)
result = 1;
else if (f < 1 || f > n)
result = 0;
else {
if (check[n]) return num_of_dis[n];
check[n] = true;
result = C(n - 1, f - 1);
for (int i = 0; i < divisors[n].size() - 1; i++) {
result -= num_of_distributions(divisors[n][i], f);
if (result < 0) result += m;
}
num_of_dis[n] = result;
}
return result;
}
int main() {
int q;
cin >> q;
int n, f;
prepare_data();
for (int i = 0; i < q; i++) {
scanf("%d %d", &n, &f);
num_of_dis = new int[n + 1];
check = new bool[n + 1];
for (int j = 0; j <= n; j++) check[j] = false;
cout << num_of_distributions(n, f) << endl;
delete (num_of_dis);
delete (check);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string a;
int p = 0;
int main() {
cin >> a;
for (int i = 0; i < a.size(); i++) {
if (i == a.size() - 1 && p == 0) {
break;
}
if (a[i] == '0' && p == 0) {
p = 1;
continue;
}
cout << a[i];
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename U, typename V>
inline void smin(U& a, V b) {
if (a > b) a = b;
}
struct node {
int st, ed, L, R, id;
node(int st = 0, int ed = 0, int L = 0, int R = 0, int id = 0)
: st(st), ed(ed), L(L), R(R), id(id) {}
void in() { scanf("%d%d%d%d", &L, &R, &st, &ed); }
void print() {
cout << st << ' ' << ed << ' ' << L << ' ' << R << ' ' << id << endl;
}
};
const int M = 200010;
const int N = 1005;
vector<node> vec[M];
int que[M];
int dp[N][N];
int main() {
int n, m, q;
scanf("%d%d%d", &n, &m, &q);
node s;
for (int i = 1, u, v; i <= m; i++) {
scanf("%d%d", &u, &v);
s = node(u, v);
vec[i].push_back(s);
swap(s.st, s.ed);
vec[i].push_back(s);
}
for (int i = 1; i <= q; i++) {
s.in();
s.id = i;
vec[s.L].push_back(s);
}
memset(dp, 0x3f, sizeof dp);
for (int i = M; --i;) {
for (auto r : vec[i]) {
if (r.id) {
que[r.id] = (dp[r.st][r.ed] <= r.R);
} else {
dp[r.st][r.ed] = i;
for (int j = 1; j <= n; j++) {
smin(dp[r.st][j], dp[r.ed][j]);
}
}
}
}
for (int i = 1; i <= q; i++) {
if (que[i])
puts("Yes");
else
puts("No");
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T &x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T &x, T y) {
x = x > y ? y : x;
}
const long long INF = (1ll << 62) - 1;
template <typename T>
void read(T &x) {
x = 0;
bool f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = 0;
} while (ch > '9' || ch < '0');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
x = f ? x : -x;
}
template <typename T>
void write(T x) {
if (x < 0) x = ~x + 1, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const int N = 500 + 5;
const int M = 6e5 + 7;
struct Node {
int sx, sy, ex, ey, id;
};
vector<Node> v;
bitset<N> empty, f[N][N], g[N][N];
int n, m, q, ans[M];
char s[N][N];
inline void solve(int l, int r, vector<Node> v) {
if (l > r) return;
vector<Node> lq, rq;
int mid = (l + r) >> 1;
for (int i = mid; i >= l; i--) {
for (int j = m; j >= 1; j--) {
f[i][j] = empty;
if (i == mid) f[i][j][j] = 1;
if (i + 1 <= mid && s[i + 1][j] == '.' && s[i][j] == '.')
f[i][j] |= f[i + 1][j];
if (j + 1 <= m && s[i][j + 1] == '.' && s[i][j] == '.')
f[i][j] |= f[i][j + 1];
}
}
for (int i = mid; i <= r; i++) {
for (int j = 1; j <= m; j++) {
g[i][j] = empty;
if (i == mid) g[i][j][j] = 1;
if (i - 1 >= mid && s[i - 1][j] == '.' && s[i][j] == '.')
g[i][j] |= g[i - 1][j];
if (j - 1 >= 1 && s[i][j - 1] == '.' && s[i][j] == '.')
g[i][j] |= g[i][j - 1];
}
}
for (int i = 0, sz = v.size(); i < sz; i++) {
if (v[i].ex < mid)
lq.push_back(v[i]);
else if (v[i].sx > mid)
rq.push_back(v[i]);
else
ans[v[i].id] = (f[v[i].sx][v[i].sy] & g[v[i].ex][v[i].ey]).count();
}
solve(l, mid - 1, lq);
solve(mid + 1, r, rq);
}
int main() {
read(n);
read(m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
read(q);
v.resize(q);
for (int i = 0; i < q; i++) {
read(v[i].sx);
read(v[i].sy);
read(v[i].ex);
read(v[i].ey);
v[i].id = i;
if (v[i].sx > v[i].ex || v[i].sy > v[i].ey) ans[i] = 0;
}
solve(1, n, v);
for (int i = 0; i < q; i++) puts(ans[i] ? "Yes" : "No");
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
inline int gcd(int a, int b) {
int t;
while (b) {
a = a % b;
t = a;
a = b;
b = t;
}
return a;
}
const int maxn = 1e6 + 8;
struct node {
int id, val, t;
friend bool operator<(node a, node b) { return a.val < b.val; }
};
node data[maxn];
bool cmp2(node a, node b) { return a.id < b.id; }
node ans[maxn];
int main() {
int n, k;
priority_queue<node> que;
scanf("%d%d", &n, &k);
int cnt = 1;
node x;
for (int i = 1; i <= n; ++i) {
scanf("%d", &data[i].val);
data[i].id = i;
if (i <= k)
que.push(data[i]);
else {
que.push(data[i]);
x = que.top();
que.pop();
x.t = k + cnt;
ans[cnt] = x;
cnt++;
}
}
while (!que.empty()) {
x = que.top();
que.pop();
x.t = k + cnt;
ans[cnt] = x;
cnt++;
}
sort(ans + 1, ans + n + 1, cmp2);
long long fuck = 0;
for (int i = 1; i <= n; ++i) {
fuck += (long long)ans[i].val * (long long)(ans[i].t - ans[i].id);
}
printf("%lld\n", fuck);
for (int i = 1; i < n; ++i) printf("%d ", ans[i].t);
printf("%d\n", ans[n].t);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<char, long long> mp;
string s;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long mx1 = 0, mx2 = 0, mx3 = 0, n;
cin >> n;
cin >> s;
for (int i = 0; i < s.size(); i++) mx1 = max(mx1, ++mp[s[i]]);
cin >> s;
mp.clear();
for (int i = 0; i < s.size(); i++) mx2 = max(mx2, ++mp[s[i]]);
mp.clear();
cin >> s;
for (int i = 0; i < s.size(); i++) mx3 = max(mx3, ++mp[s[i]]);
long long l = s.size();
if (n == 1) {
if (mx1 == l)
mx1--;
else
mx1++;
if (mx2 == l)
mx2--;
else
mx2++;
if (mx3 == l)
mx3--;
else
mx3++;
if (mx1 > mx2 && mx1 > mx3)
cout << "Kuro\n";
else if (mx2 > mx1 && mx2 > mx3)
cout << "Shiro\n";
else if (mx3 > mx2 && mx3 > mx1)
cout << "Katie\n";
else
cout << "Draw\n";
} else {
mx1 = mx1 + min(l - mx1, n);
mx2 = mx2 + min(l - mx2, n);
mx3 = mx3 + min(l - mx3, n);
if (mx1 > mx2 && mx1 > mx3)
cout << "Kuro\n";
else if (mx2 > mx1 && mx2 > mx3)
cout << "Shiro\n";
else if (mx3 > mx2 && mx3 > mx1)
cout << "Katie\n";
else
cout << "Draw\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
char s[N];
int n, k, arr[N];
long long x;
inline bool check(int val, int o, int t) {
if (val > o + t * 2) return false;
return (o > 0 || (val % 2 == 0));
}
void solve() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &arr[i]);
int ans = 1000000010;
for (int o = 0; o < 2; o++) {
for (int mx, cur, t = 0; t < 3; t++) {
mx = 0;
for (int i = 0; i < n; i++) {
cur = max(0, arr[i] / 3 - 10);
while (cur * 3 < arr[i]) {
if (check(arr[i] - cur * 3, o, t)) break;
cur++;
}
if (cur * 3 > arr[i]) cur = 1000000010;
mx = max(mx, cur);
}
ans = min(ans, mx + o + t);
}
}
printf("%d\n", ans);
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long lp = 998244353;
int n;
long long p, q;
vector<int> val;
long long pow(long long x, long long p) {
if (p == 1) return x;
long long hf = pow(x, p / 2);
if (p % 2) return ((hf * hf) % lp) * x % lp;
return (hf * hf) % lp;
}
long long inv(long long x) { return pow(x, lp - 2); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
val = vector<int>(n + 1);
for (int i = 1; i <= n; i++) cin >> val[i];
val[0] = 0;
sort(val.begin() + 1, val.end(), greater<int>());
for (int i = 1; i <= n; i++) val[i] = (val[i - 1] + val[i]) % lp;
int seg, fin, idx, times;
long long q = inv(n);
for (int i = 1; i <= n; i++) {
seg = min(i, n - i);
idx = i;
p = 0;
times = -1;
while (idx < n) {
times++;
if (idx + seg <= n) {
long long add =
(long long)times * ((val[idx + seg] - val[idx] + lp) % lp) % lp;
p = (p + add) % lp;
idx += seg;
} else {
long long add = (long long)times * ((val[n] - val[idx] + lp) % lp) % lp;
p = (p + add) % lp;
idx = n;
}
}
p = (p + val[n] - val[i] + lp) % lp;
cout << (p * q) % lp << " ";
}
cout << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, k, d, i, sh = 0, mini = 0;
cin >> n >> k >> d;
int a[n];
for (i = 0; i < n; ++i) cin >> a[i];
int dp[k];
for (i = 0; i < k; ++i) dp[i] = 0;
for (i = 0; i < d; ++i) {
if (dp[a[i] - 1] == 0) sh++;
dp[a[i] - 1]++;
}
mini = sh;
for (i = d; i < n; ++i) {
if (dp[a[i] - 1] == 0) sh++;
dp[a[i] - 1]++;
dp[a[i - d] - 1]--;
if (dp[a[i - d] - 1] == 0) sh--;
if (mini > sh) mini = sh;
}
cout << mini << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 1; i <= t; i++) {
string sudoku[100];
for (int i = 1; i <= 9; i++) cin >> sudoku[i];
for (int i = 1; i <= 9; i++) {
for (int j = 0; j < 9; j++) {
if (sudoku[i][j] == '2') sudoku[i][j] = '1';
cout << sudoku[i][j];
}
cout << "\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
struct E {
int y, pre;
} e[N * 2];
struct F {
long long a, b;
} f[N];
int last[N], pre[N], son[N], q[N], m;
long long w[N], a[N];
void add(int x, int y) {
m++;
e[m].y = y;
e[m].pre = last[x];
last[x] = m;
m++;
e[m].y = x;
e[m].pre = last[y];
last[y] = m;
}
void build(int p) {
int x = last[p], y;
while (x > 0) {
y = e[x].y;
if (pre[y] == 0) {
pre[y] = p;
son[p]++;
build(y);
}
x = e[x].pre;
}
}
int main() {
int n, s, i, k, x, y, root, p, l = 1, r = 0, now;
long long sum;
scanf("%d", &n);
for (i = 1; i <= n; i++) cin >> w[i];
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
add(x, y);
}
scanf("%d", &root);
pre[root] = -1;
build(root);
for (i = 1; i <= n; i++)
if (son[i] == 0) {
q[++r] = i;
f[i].a = w[i];
f[i].b = 0;
}
while (l <= r) {
now = q[l];
l++;
s = 0;
sum = 0;
x = last[now];
while (x > 0) {
y = e[x].y;
if (pre[y] == now) {
a[++s] = f[y].b;
sum += f[y].a;
}
x = e[x].pre;
}
sort(a + 1, a + s + 1);
if (now != root) {
w[now]--;
f[now].b++;
}
for (i = s; i >= 1; i--) {
if (w[now] == 0) break;
f[now].b += a[i] + 1;
w[now]--;
}
f[now].b += min(w[now], sum) * 2;
w[now] -= min(w[now], sum);
f[now].a = w[now];
if (now == root) break;
p = pre[now];
son[p]--;
if (son[p] == 0) q[++r] = p;
}
cout << f[root].b << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int p[4][110][110];
int dp[4][110];
int main() {
int t;
scanf("%d", &t);
while (t--) {
memset(p, 0, sizeof p);
int n, m;
scanf("%d%d", &n, &m);
memset(dp, 0, sizeof dp);
for (int i = 0; i < 3; i++) {
getchar();
for (int j = 0; j < n; j++) {
char c;
scanf("%c", &c);
if (c >= 'A' && c <= 'Z') {
int t = 0;
for (int k = j; k >= 0; k -= 2) {
if (k >= 0) {
p[i][k][t] = 1;
t++;
}
}
}
if (c == 's') dp[i][0] = 1;
}
}
for (int j = 0; j < n; j++) {
for (int i = 0; i < 3; i++) {
if (dp[i][j]) {
if (p[i][j + 1][j]) continue;
for (int k = 0; k < 3; k++) {
if (abs(k - i) <= 1 && !p[k][j + 1][j + 1] && !p[k][j + 1][j]) {
dp[k][j + 1] = 1;
}
}
}
}
}
int flag = 0;
for (int i = 0; i < 3; i++) {
if (dp[i][n - 1]) {
flag = 1;
break;
}
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 9223372036854775807LL, SQ_MAX = 40000000000000000LL;
void getmin(long long &a, const long long b) {
if (b < a) a = b;
}
void getmax(long long &a, const long long b) {
if (b > a) a = b;
}
long long Sq(const long long a) { return a * a; }
struct Point {
long long x, y;
Point() {}
Point(const long long _x, const long long _y) : x(_x), y(_y) {}
};
int N;
Point P[100000];
bool SolveTilt(const long long tsq) {
long long ymn = 0, ymx = 0;
int l, r = 0;
for (l = 0; l < N && P[l].x < 0 && Sq(P[l].x) < tsq; l++)
getmax(ymx, P[l].y), getmin(ymn, P[l].y);
for (;;) {
if (l == N || P[l].x >= 0) return false;
for (; r < N && Sq(P[r].x - P[l].x) <= tsq; r++)
;
const long long y2 = sqrt(tsq - Sq(P[l].x));
if (y2 > -P[l].x) return false;
const long long y1 = max(-y2, (long long)(y2 - sqrt(tsq)));
if (r == N && ymn <= y1 && y2 <= ymx) return true;
getmax(ymx, P[l].y), getmin(ymn, P[l].y);
l++;
}
}
bool SolveLine(const long long lsq) {
static long long lymx[100000], lymn[100000], rymx[100000], rymn[100000];
lymx[0] = lymn[0] = P[0].y;
for (int i = 1; i < N; i++)
lymx[i] = max(lymx[i - 1], P[i].y), lymn[i] = min(lymn[i - 1], P[i].y);
rymx[N - 1] = rymn[N - 1] = P[N - 1].y;
for (int i = N - 1; i >= 0; i--)
rymx[i] = max(rymx[i + 1], P[i].y), rymn[i] = min(rymn[i + 1], P[i].y);
for (int r = 0, l = 0; r < N; r++) {
for (; Sq(P[r].x - P[l].x) > lsq; l++)
;
if (l == 0 && r == N - 1) return true;
const long long x1 = P[l].x, x2 = P[r].x,
y1 = min(l > 0 ? lymn[l - 1] : INF,
r + 1 < N ? rymn[r + 1] : INF),
y2 = max(l > 0 ? lymx[l - 1] : -INF,
r + 1 < N ? rymx[r + 1] : -INF);
if (Sq(y2 - y1) <= lsq && max(Sq(y1), Sq(y2)) + max(Sq(x1), Sq(x2)) <= lsq)
return true;
}
return false;
}
bool CmpX(const Point &a, const Point &b) { return a.x < b.x; }
long long TiltMin() {
sort(P, P + N, CmpX);
long long l = 0, r = SQ_MAX;
while (l < r) {
const long long mid = (l + r) / 2;
if (SolveTilt(mid))
r = mid;
else
l = mid + 1LL;
}
return r;
}
long long LineMin() {
sort(P, P + N, CmpX);
long long l = 0, r = SQ_MAX;
while (l < r) {
const long long mid = (l + r) / 2;
if (SolveLine(mid))
r = mid;
else
l = mid + 1LL;
}
return r;
}
void Flip1(bool ish) {
for (int i = 0; i < N; i++) (ish ? P[i].x : P[i].y) *= -1;
}
void Flip2() {
for (int i = 0; i < N; i++) swap(P[i].x, P[i].y);
}
void Flip3() {
Flip2();
Flip1(true), Flip1(false);
}
int main() {
while (scanf("%d", &N) == 1) {
for (int i = 0; i < N; i++) scanf("%lld%lld", &P[i].x, &P[i].y);
long long ans = INF;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 2; j++) getmin(ans, TiltMin()), Flip3();
Flip1(i & 1);
}
for (int i = 0; i < 2; i++) getmin(ans, LineMin()), Flip2();
printf("%lld\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
vector<int> ans(n, 0);
vector<int> visited(n, 0);
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v[i] = a - 1;
ans[i] = i;
}
queue<pair<int, int> > q;
q.push(make_pair(0, 0));
visited[0] = 1;
while (q.size() > 0) {
pair<int, int> p = q.front();
q.pop();
ans[p.first] = p.second;
if (visited[v[p.first]] == 0) {
visited[v[p.first]] = 1;
q.push(make_pair(v[p.first], p.second + 1));
}
if (p.first + 1 < n && visited[p.first + 1] == 0) {
visited[p.first + 1] = 1;
q.push(make_pair(p.first + 1, p.second + 1));
}
if (p.first - 1 >= 0 && visited[p.first - 1] == 0) {
visited[p.first - 1] = 1;
q.push(make_pair(p.first - 1, p.second + 1));
}
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " ";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000 + 100;
struct Node {
int v, sum, max_sum, min_sum;
Node(int _v, int _sum, int _max_sum, int _min_sum)
: v(_v), sum(_sum), max_sum(_max_sum), min_sum(_min_sum) {}
};
int L;
string s;
char t[maxn * 2];
stack<Node> ls, rs;
void push_node(stack<Node> &st, int v) {
auto e = st.top();
st.push(
Node(v, e.sum + v, max(e.max_sum, e.sum + v), min(e.min_sum, e.sum + v)));
}
int main() {
cin >> L;
cin >> s;
int p = 0;
ls.push(Node(0, 0, 0, 0));
rs.push(Node(0, 0, 0, 0));
for (int i = 0; i < L; i++) {
if (s[i] == 'L') {
if (p > 0) {
p--;
if (t[p] == '(') {
ls.pop();
push_node(rs, -1);
} else if (t[p] == ')') {
ls.pop();
push_node(rs, 1);
}
}
} else if (s[i] == 'R') {
if (t[p] == '(') {
rs.pop();
push_node(ls, 1);
} else if (t[p] == ')') {
rs.pop();
push_node(ls, -1);
}
p++;
} else if ('a' <= s[i] && s[i] <= 'z') {
if (t[p] == ')' || t[p] == '(') rs.pop();
t[p] = s[i];
} else if (s[i] == '(') {
if (t[p] == '(') {
} else if (t[p] == ')') {
rs.pop();
push_node(rs, -1);
} else {
push_node(rs, -1);
}
t[p] = s[i];
} else if (s[i] == ')') {
if (t[p] == ')') {
} else if (t[p] == '(') {
rs.pop();
push_node(rs, 1);
} else {
push_node(rs, 1);
}
t[p] = s[i];
}
if (i > 0) cout << " ";
if (ls.top().sum == rs.top().sum && ls.top().min_sum >= 0 &&
rs.top().min_sum >= 0) {
cout << max(ls.top().max_sum, rs.top().max_sum);
} else {
cout << -1;
}
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if ((n - 1) % 2 == 0) {
int m = ((n - 1) / 2) + 1;
cout << m << endl;
for (int i = 1; i <= n; i++) {
if (i <= m)
cout << 1 << " " << i << endl;
else
cout << m << " " << i - (n - m) << endl;
}
} else {
int m = (n / 2) + 1;
cout << m << endl;
for (int i = 1; i <= n; i++) {
if (i <= m)
cout << 1 << " " << i << endl;
else
cout << m << " " << i - (n - m) << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> Avt[1000000];
map<int, vector<int> > ToGo;
map<int, int> Answ;
int t[1000000];
set<int> Seconds;
set<int> place;
int moda = 1000000007;
bool cmp(pair<int, int> x1, pair<int, int> x2) { return x1.second < x2.second; }
int N = 131072;
int get(int l, int r) {
l += N;
r += N;
int answ = 0;
while (r >= l) {
if (l % 2 == 1) {
answ = (answ + t[l]) % moda;
l++;
}
if (r % 2 == 0) {
answ = (answ + t[r]) % moda;
r--;
}
l /= 2;
r /= 2;
}
return answ;
}
void add(int idx, int val) {
idx += N;
int answ = 0;
while (idx >= 1) {
t[idx] = (t[idx] + val) % moda;
idx /= 2;
}
}
map<int, int> LargeToS;
int SmalToL[1000000];
int main() {
int n;
int m;
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &Avt[i].first, &Avt[i].second);
if (Avt[i].first < n && Avt[i].second >= n) {
Avt[i].second = n;
}
ToGo[Avt[i].second].push_back(Avt[i].first);
Seconds.insert(Avt[i].second);
}
int idx = 0;
Seconds.insert(0);
for (set<int>::iterator it = Seconds.begin(); it != Seconds.end(); it++) {
LargeToS[*it] = idx;
SmalToL[idx] = *it;
idx++;
}
sort(Avt, Avt + m, cmp);
;
add(0, 1);
set<int>::iterator it = Seconds.begin();
it++;
int sz = Seconds.size();
for (int i = 0; i < sz - 1; i++) {
int cur = *it;
it++;
for (int j = 0; j < ToGo[cur].size(); j++) {
int from = ToGo[cur][j];
int fromNorm = *Seconds.lower_bound(from);
int answ = 0;
answ = (answ + get(LargeToS[fromNorm], LargeToS[cur] - 1)) % moda;
add(LargeToS[cur], answ);
}
}
if (Seconds.find(n) == Seconds.end()) {
printf("0\n");
} else
printf("%d\n", get(sz - 1, sz - 1));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, s, x, y, nb;
vector<pair<long long, long long> > t, v;
long long dp[102];
bool cmp(pair<long long, long long> a, pair<long long, long long> b) {
return a.first + a.second > b.first + b.second;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> s;
for (long long i = 0; i < n; i++) {
cin >> x >> y;
if (y >= 0) {
t.push_back(make_pair(x, y));
} else {
v.push_back(make_pair(y, x));
}
}
sort(t.begin(), t.end());
for (long long i = 0; i < t.size(); i++) {
if (t[i].first > s) break;
s += t[i].second;
nb++;
}
sort(v.begin(), v.end(), cmp);
n = v.size();
for (long long i = 1; i < n + 1; i++) dp[i] = -1;
dp[0] = s;
for (long long i = 0; i < n; i++) {
for (long long j = i + 1; j > 0; j--) {
if (dp[j - 1] >= v[i].second) dp[j] = max(dp[j], dp[j - 1] + v[i].first);
}
}
long long i;
for (i = n; dp[i] == -1; i--)
;
cout << nb + i << "\n";
return 0;
}
| 6 |
// Copyright: lzt
#include<stdio.h>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<cmath>
#include<iostream>
#include<queue>
#include<string>
#include<ctime>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<long long,long long> pll;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define rep(i,j,k) for(int i=(int)(j);i<=(int)(k);i++)
#define rrep(i,j,k) for(int i=(int)(j);i>=(int)(k);i--)
#define Debug(...) fprintf(stderr, __VA_ARGS__)
ll read(){
ll x=0,f=1;char c=getchar();
while(c<'0' || c>'9'){if(c=='-')f=-1;c=getchar();}
while(c>='0' && c<='9'){x=x*10+c-'0';c=getchar();}
return x*f;
}
int tc, a, b;
void work() {
tc = read();
while (tc--) {
a = read();
b = read();
int ans = 0, res = 1e9;
if (b == 1) ans++, b++;
while (1) {
int tmp = a, cnt = ans;
while (tmp) tmp = tmp / b, cnt++;
res = min(res, cnt);
if (b * b > a && b + 1 <= a) break;
if (b > a) break;
ans++; b++;
}
printf("%d\n", res);
}
}
int main(){
#ifdef LZT
freopen("in","r",stdin);
#endif
work();
#ifdef LZT
Debug("My Time: %.3lfms\n", (double)clock() / CLOCKS_PER_SEC);
#endif
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
const int maxm = 1e3 + 7;
const int mod = 998244353;
int n;
int a[maxn], b[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
cin >> n;
for (int i = (1); i <= (n); ++i) cin >> a[i];
int pre = a[1], tail = 0;
int flag = 1;
for (int i = (1); i <= (n); ++i) {
a[i] -= tail;
if (a[i] < 0) {
flag = 0;
break;
}
pre = min(a[i], pre);
a[i] -= pre;
if (a[i] > 0) tail += a[i];
a[i] = 0;
}
if (flag) {
cout << "YES" << '\n';
} else
cout << "NO" << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int nax = 2e5 + 111;
int n, a, b;
vector<int> v[nax];
int h[nax];
int skok[nax][18];
void dfs(int u, int p) {
h[u] = h[p] + 1;
skok[u][0] = p;
for (int j = 1; j <= 17; ++j) skok[u][j] = skok[skok[u][j - 1]][j - 1];
for (auto it : v[u])
if (it != p) dfs(it, u);
}
int lca(int x, int y) {
if (h[x] < h[y]) swap(x, y);
for (int i = 17; 0 <= i; --i)
if (h[x] - (1 << i) >= h[y]) x = skok[x][i];
if (x == y) return x;
for (int i = 17; 0 <= i; --i)
if (skok[x][i] != skok[y][i]) {
x = skok[x][i];
y = skok[y][i];
}
return skok[x][0];
}
int dis(int a, int b) { return h[a] + h[b] - 2 * h[lca(a, b)]; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; ++i) {
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
}
dfs(1, 0);
int q;
scanf("%d", &q);
while (q--) {
int x, y, k;
scanf("%d%d%d%d%d", &x, &y, &a, &b, &k);
if (dis(a, b) <= k && dis(a, b) % 2 == k % 2) {
printf("YES\n");
continue;
}
int z = dis(a, x) + 1 + dis(y, b);
if (z <= k && z % 2 == k % 2) {
printf("YES\n");
continue;
}
z = dis(a, y) + 1 + dis(x, b);
if (z <= k && z % 2 == k % 2) {
printf("YES\n");
continue;
}
printf("NO\n");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
vector<pair<int, int> > g[200055];
vector<int> res[200055];
void dfs(int id, int par, int pre) {
int cnt = 0;
for (int i = 0; i < (int)g[id].size(); i++) {
int to = g[id][i].first, u = g[id][i].second;
if (to == par) continue;
cnt++;
if (cnt == pre) cnt++;
res[cnt].push_back(u);
dfs(to, id, cnt);
k = max(k, cnt);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
int x, y;
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
g[x].push_back(pair<int, int>(y, i));
g[y].push_back(pair<int, int>(x, i));
}
dfs(1, -1, 0);
cout << k << '\n';
for (int i = 1; i <= k; i++) {
cout << res[i].size();
for (int j = 0; j < (int)res[i].size(); j++) {
cout << " " << res[i][j] + 1;
}
cout << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void _fill_int(int* p, int val, int rep) {
int i;
for (i = 0; i < rep; i++) p[i] = val;
}
signed long long GETi() {
signed long long i;
scanf("%lld", &i);
return i;
}
int N;
map<vector<int>, double> M[64];
int st[64], num[64];
double dodo(int top, vector<int> V) {
int otop, i, x, y, z, ng = 0;
otop = top = st[top];
sort(V.begin(), V.end());
vector<int> VV = V;
if (M[top].find(V) != M[top].end()) return M[top][V];
if (num[top] == 3) V.push_back(top), top = 0, ng = 1;
double ma[4] = {0, 1e15, 1e15, 1e15};
int pre = -1;
for (i = 0; i < V.size() - ng; i++) {
if (pre == V[i]) continue;
pre = V[i];
x = V[i] % 4;
y = V[i] / 4 % 4;
z = V[i] / 16;
vector<int> V2 = V;
V2.erase(V2.begin() + i);
if (x && y && z) {
if (top % 4 == 0) ma[y] = min(ma[y], dodo(top + y * 1, V2));
if (top / 4 % 4 == 0) ma[y] = min(ma[y], dodo(top + y * 4, V2));
if (top / 16 == 0 && top % 4) ma[y] = min(ma[y], dodo(top + y * 16, V2));
}
if (z && y) {
if (x) {
V[i] = 4 + x;
if (top % 4 == 0) ma[z] = min(ma[z], dodo(top + z * 1, V));
if (top / 4 % 4 == 0) ma[z] = min(ma[z], dodo(top + z * 4, V));
if (top / 16 == 0 && top % 4) ma[z] = min(ma[z], dodo(top + z * 16, V));
} else {
if (top % 4 == 0) ma[z] = min(ma[z], dodo(top + z * 1, V2));
if (top / 4 % 4 == 0) ma[z] = min(ma[z], dodo(top + z * 4, V2));
if (top / 16 == 0 && top % 4)
ma[z] = min(ma[z], dodo(top + z * 16, V2));
}
}
if (y && x) {
if (z) {
V[i] = z + 4;
if (top % 4 == 0) ma[x] = min(ma[x], dodo(top + x * 1, V));
if (top / 4 % 4 == 0) ma[x] = min(ma[x], dodo(top + x * 4, V));
if (top / 16 == 0 && top % 4) ma[x] = min(ma[x], dodo(top + x * 16, V));
} else {
if (top % 4 == 0) ma[x] = min(ma[x], dodo(top + x * 1, V2));
if (top / 4 % 4 == 0) ma[x] = min(ma[x], dodo(top + x * 4, V2));
if (top / 16 == 0 && top % 4)
ma[x] = min(ma[x], dodo(top + x * 16, V2));
}
}
V[i] = pre;
}
int sum = 1;
if (ma[1] >= 1e15) ma[1] = 0, sum += 1;
if (ma[2] >= 1e15) ma[2] = 0, sum += 2;
if (ma[3] >= 1e15) ma[3] = 0, sum += 2;
if (sum == 6) return M[otop][VV] = 0;
M[otop][VV] = (1 + ma[1] / 6 + ma[2] / 3 + ma[3] / 3) / (1 - sum / 6.0);
return M[otop][VV] =
(1 + ma[1] / 6 + ma[2] / 3 + ma[3] / 3) / (1 - sum / 6.0);
}
void solve() {
int f, i, j, k, l, x, y, x2, y2, z;
cin >> N;
string S;
for (i = 0; i < 64; i++) {
x = i % 4;
y = i / 4 % 4;
z = i / 16;
st[i] = (z > x) ? (x * 16 + y * 4 + z) : i;
num[i] = (x > 0) + (y > 0) + (z > 0);
}
vector<int> V;
for (i = 0; i < N; i++) {
cin >> S;
x = 0;
for (y = 0; y < 3; y++) {
if (S[y] == 'R') x += 1 << (y * 2);
if (S[y] == 'G') x += 2 << (y * 2);
if (S[y] == 'B') x += 3 << (y * 2);
}
if (i < N - 1) V.push_back(st[x]);
}
(void)printf("%.12lf\n", dodo(st[x], V));
}
int main(int argc, char** argv) {
string s;
if (argc == 1) ios::sync_with_stdio(false);
for (int i = 1; i < argc; i++) s += argv[i], s += '\n';
for (int i = s.size() - 1; i >= 0; i--) ungetc(s[i], stdin);
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1 << 20) | 5;
int n, cnt[N], tr[25];
long long A[N], B[N], T, mod;
long long mul(long long x, long long y) {
x %= mod;
y %= mod;
long long t = x * y - (long long)((long double)x / mod * y) * mod;
return (t % mod + mod) % mod;
}
long long power(long long x, long long y) {
long long s = 1;
for (; y; y /= 2, x = mul(x, x))
if (y & 1) s = mul(s, x);
return s;
}
void DFT(long long *A, int n) {
for (int d = 1; d < n; d <<= 1)
for (int i = 0; i < n; i += d << 1)
for (int j = 0; j < d; j++) {
long long x = A[i + j], y = A[i + j + d];
A[i + j] = (x + y) % mod;
A[i + j + d] = (x + mod - y) % mod;
}
}
int main() {
scanf("%d%lld%lld", &n, &T, &mod);
mod <<= n;
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++) scanf("%lld", &A[i]);
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++)
cnt[i] = cnt[i / 2] + (i & 1);
for (int i = (int)(0); i <= (int)(n); i++) scanf("%d", &tr[i]);
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++) B[i] = tr[cnt[i]];
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++)
A[i] %= mod, B[i] %= mod;
DFT(A, 1 << n);
DFT(B, 1 << n);
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++)
A[i] = mul(A[i], power(B[i], T));
DFT(A, 1 << n);
for (int i = (int)(0); i <= (int)((1 << n) - 1); i++)
printf("%lld\n", A[i] >> n);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct cmp {
bool operator()(const pair<int, int> &a, const pair<int, int> &b) {
int lena = a.second - a.first + 1;
int lenb = b.second - b.first + 1;
if (lena == lenb) return a.first < b.first;
return lena > lenb;
}
};
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
set<pair<int, int>, cmp> segs;
segs.insert({0, n - 1});
vector<int> a(n, 0);
for (int i = 1; i <= n; i++) {
pair<int, int> curr = *segs.begin();
segs.erase(segs.begin());
int id = (curr.first + curr.second) / 2;
a[id] = i;
segs.insert({curr.first, id - 1});
segs.insert({id + 1, curr.second});
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
template <class T, class U>
inline void checkmin(T &x, U y) {
if (y < x) x = y;
}
using namespace std;
vector<int> z_func(string s) {
int n = s.size();
int l = 0, r = 0;
vector<int> z(n);
for (int i = 1; i < n; ++i) {
if (i > r) l = r = i;
z[i] = min(r - i, z[i - l]);
while (i + z[i] < n && s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] > r) r = i + z[i], l = i;
}
return z;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, a, b;
cin >> n >> a >> b;
string s;
cin >> s;
vector<vector<int>> z(n);
for (int i = 0; i < n; ++i) z[i] = z_func(s.substr(i, int(s.size()) - i));
vector<int> dp(n, 1e9 + 10);
dp[0] = a;
for (int i = 1; i < n; ++i) {
checkmin(dp[i], dp[i - 1] + a);
for (int j = 0; j < i; ++j) {
checkmin(dp[i + min(i - j, z[j][i - j]) - 1], dp[i - 1] + b);
}
}
cout << dp.back();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 1e5;
int n, a[105][105], cnt1, cnt2, q[105];
bool flag[105][105], miao[105];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &q[i]);
for (int j = 1; j <= q[i]; j++) {
scanf("%d", &a[i][j]);
flag[i][a[i][j]] = 1;
}
}
for (int i = 1; i <= n; i++) {
cnt2 = 0;
for (int k = 1; k <= n; k++) {
cnt1 = 0;
if (k == i) continue;
for (int j = 1; j <= q[i]; j++) {
if (flag[k][a[i][j]]) cnt1++;
}
if (cnt1 < q[k]) cnt2++;
}
if (cnt2 >= n - 1) miao[i] = 1;
}
for (int i = 1; i <= n; i++) {
if (miao[i])
printf("YES\n");
else
printf("NO\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> Pal;
vector<vector<long long>> DP;
vector<vector<long long>> V;
string s;
long long k;
long long solve(int index, int subsSoFar) {
if (index >= s.size()) {
return 0;
}
if (index == (s.size() - 1)) {
V.at(index).at(subsSoFar) = index;
return 0;
}
if (subsSoFar == k) {
V.at(index).at(subsSoFar) = s.size() - 1;
return Pal.at(index).back();
}
long long &dp = DP.at(index).at(subsSoFar);
if (dp != -1) {
return dp;
}
long long mn = INT32_MAX, curr;
for (int i = index; i < s.size(); i++) {
curr = Pal.at(index).at(i) + solve(i + 1, subsSoFar + 1);
if (curr < mn) {
mn = curr;
V.at(index).at(subsSoFar) = i;
}
}
return (dp = mn);
}
int makePalindrome(int tmpLow, int tmpHigh) {
int ans = 0;
while (tmpLow < tmpHigh) {
if (s.at(tmpLow) != s.at(tmpHigh)) ++ans;
tmpLow++;
tmpHigh--;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> s >> k;
long long l = s.size();
Pal = vector<vector<long long>>(l, vector<long long>(l));
DP = vector<vector<long long>>(l, vector<long long>(k + 1, -1));
V = vector<vector<long long>>(l, vector<long long>(k + 1, -1));
for (long long i = 0; i < l; i++) {
for (long long j = 0; j < l; j++) {
Pal.at(i).at(j) = makePalindrome(i, j);
}
}
cout << solve(0, 1) << endl;
int from = 0, to = V.at(0).at(1), substrings = 1;
vector<pair<int, int>> P;
while (true) {
P.push_back({from, to});
from = to + 1;
if (to >= (l - 1)) break;
++substrings;
to = V.at(from).at(substrings);
}
for (auto [low, high] : P) {
int tmpLow = low, tmpHigh = high;
while (tmpLow < tmpHigh) {
s.at(tmpHigh) = s.at(tmpLow);
tmpLow++;
tmpHigh--;
}
for (int i = low; i <= high; i++) {
cout << s.at(i);
}
if (high != (l - 1)) cout << "+";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void mul(long long int A[5][5], long long int B[5][5]) {
long long int i, j, k, s = 0;
long long int C[5][5];
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) {
for (k = 0; k < 5; k++) {
s = (s + (A[i][k] % 1000000007 * B[k][j] % 1000000007) % 1000000007) %
1000000007;
}
C[i][j] = s;
s = 0;
}
}
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) {
A[i][j] = C[i][j];
}
}
}
void power(long long int x[5][5], long long int n) {
long long int res[5][5] = {{1, 0, 0, 0, 0},
{0, 1, 0, 0, 0},
{0, 0, 1, 0, 0},
{0, 0, 0, 1, 0},
{0, 0, 0, 0, 1}};
while (n) {
if (n % 2 == 0) {
mul(x, x);
n = n / 2;
} else {
mul(res, x);
n--;
}
}
long long int i, j;
for (i = 0; i < 5; i++) {
for (j = 0; j < 5; j++) {
x[i][j] = res[i][j];
}
}
}
long long int a[(1 << 18) + 1];
long long int tree[1 << 20];
long long int level[1 << 20];
void build(long long int node, long long int st, long long int en) {
if (st == en) {
tree[node] = a[st];
level[node] = 1;
return;
}
long long int mid, p, q;
mid = (st + en) / 2;
p = 2 * node;
q = p + 1;
build(p, st, mid);
build(q, mid + 1, en);
level[node] = level[p] + 1;
if (level[node] & 1)
tree[node] = tree[p] ^ tree[q];
else
tree[node] = tree[p] | tree[q];
}
void update(long long int node, long long int st, long long int en,
long long int id, long long int val) {
if (st == en) {
tree[node] = val;
} else {
long long int mid, p, q;
mid = (st + en) / 2;
p = 2 * node;
q = p + 1;
if (st <= id && id <= mid)
update(p, st, mid, id, val);
else
update(q, mid + 1, en, id, val);
if (level[node] & 1)
tree[node] = tree[p] ^ tree[q];
else
tree[node] = tree[p] | tree[q];
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
long long int i, j, x, y;
n = 1 << n;
for (i = 0; i < n; i++) {
cin >> a[i];
}
build(1, 0, n - 1);
for (i = 0; i < m; i++) {
cin >> x >> y;
update(1, 0, n - 1, x - 1, y);
cout << tree[1] << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
deque<int> a, b;
int na;
cin >> na;
while (na--) {
int x;
cin >> x;
a.push_back(x);
}
int nb;
cin >> nb;
while (nb--) {
int x;
cin >> x;
b.push_back(x);
}
map<pair<deque<int>, deque<int>>, int> cek;
int cnt = 0;
while (a.size() && b.size()) {
int ta = a[0];
int tb = b[0];
a.pop_front();
b.pop_front();
if (cek[{a, b}]) {
cout << -1 << '\n';
return 0;
}
cek[{a, b}] = 1;
cnt++;
if (ta > tb) {
a.push_back(tb);
a.push_back(ta);
} else {
b.push_back(ta);
b.push_back(tb);
}
}
cout << cnt << ' ';
cout << (a.size() ? 1 : 2) << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ff first
#define ss second
#define pii pair<int, int>
#define pb emplace_back
#define pf emplace_front
#define mp make_pair
#define ld long double
#define all(x) x.begin(), x.end()
#define uniq(x) sort(all(x)), x.resize(unique(all(x)) - x.begin())
const int maxn = 5e5 + 9;
int p[maxn];
int sz[maxn];
bool kek[maxn];
int n, m;
int mod = 1e9 + 7;
int binpow(int x, int pw) {
if (pw == 0)
return 1;
if (pw == 1)
return x % mod;
int y = binpow(x, pw / 2);
y = (y * y) % mod;
if (pw % 2)
y = (y * x) % mod;
return y;
}
int find_p(int i) {
if (p[i] != i)
p[i] = find_p(p[i]);
return p[i];
}
void merg(int i, int e) {
i = find_p(i);
e = find_p(e);
if (i == e)
return;
if (sz[i] < sz[e])
swap(i, e);
sz[i] += sz[e];
p[e] = i;
kek[i] |= kek[e];
}
signed main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
p[i] = i;
sz[i]= 1;
}
vector<int> ans;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
if (k == 1) {
int x;
cin >> x;
x--;
int v = find_p(x);
if (!kek[v]) {
kek[v] = 1;
ans.pb(i);
}
} else {
int x, y;
cin >> x >> y;
x--, y--;
int px = find_p(x);
int py = find_p(y);
if (px != py && (!kek[px] || !kek[py])) {
merg(x, y);
ans.pb(i);
}
}
}
cout << binpow(2, ans.size()) << " ";
cout << ans.size() << "\n";
for (int i : ans)
cout << i + 1 << " ";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int T = 1 << 19;
bool u[N], w[N];
vector<int> g[N];
int deg[N], deg2[N];
double ta[N];
int t[T], d;
void upd(int i, double x) {
ta[i] = x;
i += d;
for (i >>= 1; i; i >>= 1) {
t[i] = ta[t[i * 2]] < ta[t[i * 2 + 1]] ? t[i * 2] : t[i * 2 + 1];
}
}
int main() {
int n, m, b;
scanf("%d%d%d", &n, &m, &b);
for (int k = 0; k < b; ++k) {
int i;
scanf("%d", &i);
--i;
u[i] = 1;
}
for (int k = 0; k < m; ++k) {
int i, j;
scanf("%d%d", &i, &j);
--i;
--j;
g[i].push_back(j);
g[j].push_back(i);
}
double l = -1, r = 1e5 + 5;
vector<int> ans;
for (d = 2; d < n; d <<= 1)
;
for (int it = 50; it; --it) {
double x = (l + r) / 2.0;
for (int i = 0; i < n; ++i) w[i] = u[i], deg[i] = g[i].size(), deg2[i] = 0;
for (int i = 0; i < n; ++i) t[i + d] = i;
for (int i = n; i < d; ++i) t[i + d] = n;
ta[n] = 1e9;
int cnt = 0;
for (int i = 0; i < n; ++i)
if (!w[i]) {
for (int j : g[i]) {
if (!w[j]) ++deg2[i];
}
ta[i] = 1.0 * deg2[i] / deg[i];
++cnt;
} else
ta[i] = 1e9;
for (int i = d - 1; i; --i)
t[i] = ta[t[i * 2]] < ta[t[i * 2 + 1]] ? t[i * 2] : t[i * 2 + 1];
while (cnt > 0) {
int i = t[1];
if (ta[i] >= x) break;
upd(i, 1e9);
--cnt;
w[i] = 1;
for (int j : g[i])
if (!w[j]) {
deg2[j]--;
upd(j, 1.0 * deg2[j] / deg[j]);
}
}
if (cnt == 0)
r = x;
else {
ans.clear();
for (int i = 0; i < n; ++i)
if (!w[i]) ans.push_back(i);
l = x;
}
}
printf("%d\n", ans.size());
for (int i : ans) printf("%d ", i + 1);
printf("\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int ppow(int a, int b, int mod) {
a %= mod;
int ans = 1 % mod;
while (b) {
if (b & 1) ans = (long long)ans * a % mod;
a = (long long)a * a % mod;
b >>= 1;
}
return ans;
}
int readdd() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c) && c != '-') c = getchar();
if (c == '-') f = -1, c = getchar();
while (isdigit(c)) x = x * 10 + c - '0', c = getchar();
return f * x;
}
void printtt(int x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) printtt(x / 10);
putchar(x % 10 + '0');
}
bool addd(int a, int b) { return a > b; };
const int maxm = 5e5 + 5;
int l[maxm], r[maxm], tot;
vector<int> g[maxm];
int n;
void dfs(int x, int fa) {
int len = g[x].size();
for (int i = len - 1; i >= 0; i--) {
int v = g[x][i];
if (v == fa) continue;
l[v] = ++tot;
}
r[x] = ++tot;
for (int i = 0; i < len; i++) {
int v = g[x][i];
if (v == fa) continue;
dfs(v, x);
}
}
signed main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
l[1] = ++tot;
dfs(1, -1);
for (int i = 1; i <= n; i++) {
printf("%d %d\n", l[i], r[i]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
const long long int mod = 998244353;
const long long int inf = 1e9 + 100;
int n, m, com[N], adj[N];
bool mark[N];
vector<int> in[N], out[N], tp, all[N];
void back_dfs(int u, int k) {
com[u] = k;
all[k].push_back(u);
mark[u] = true;
for (auto x : in[u]) {
if (!mark[x]) back_dfs(x, k);
}
}
void dfs(int u) {
mark[u] = true;
for (auto x : out[u]) {
if (!mark[x]) dfs(x);
}
tp.push_back(u);
}
inline void add_edge(int x, int y) {
out[x].push_back(y);
in[y].push_back(x);
return;
}
inline void cl() {
tp.clear();
for (int i = 0; i < n + 50; i++) {
mark[i] = 0;
com[i] = adj[i] = 0;
in[i].clear();
out[i].clear();
all[i].clear();
}
}
inline void cl_mark() {
for (int i = 0; i < 2 * n; i++) mark[i] = 0;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int q = 1;
cin >> q;
while (q--) {
cl();
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
if (x == y) continue;
add_edge(x, y);
}
for (int i = 0; i < n; i++) {
if (!mark[i]) dfs(i);
}
cl_mark();
reverse(tp.begin(), tp.end());
int cnt = 0;
for (auto u : tp) {
if (!mark[u]) back_dfs(u, cnt++);
}
if (cnt == 1) {
cout << "No" << endl;
continue;
}
cout << "Yes" << endl;
for (int u = 0; u < n; u++) {
for (auto x : out[u]) {
if (com[u] != com[x]) adj[com[u]]++;
}
}
int p = 0;
cl_mark();
for (int i = 0; i < cnt; i++) {
if (adj[i] == 0) {
for (auto x : all[i]) {
mark[x] = 1;
p++;
}
break;
}
}
cout << p << ' ' << n - p << endl;
for (int i = 0; i < n; i++) {
if (mark[i]) cout << i + 1 << ' ';
}
cout << endl;
for (int i = 0; i < n; i++) {
if (!mark[i]) cout << i + 1 << ' ';
}
cout << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[100010], b[2010], n, m;
int pre[100010], nxt[100010];
int dp[100010];
int main() {
int i, j, k, l, r, z;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 0; i < m; i++) scanf("%d", &b[i]);
sort(a + 1, a + n + 1);
sort(b, b + m);
a[0] = -1;
for (i = 1; i <= n; i++)
if (a[i - 1] + 1 == a[i])
pre[i] = pre[i - 1];
else
pre[i] = i;
for (i = n; i >= 1; i--)
if (a[i] + 1 == a[i + 1])
nxt[i] = nxt[i + 1];
else
nxt[i] = i;
for (i = 1; i <= n; i++) {
l = -1;
r = m;
while (l + 1 < r) {
z = (l + r) >> 1;
if (b[z] <= a[i])
l = z;
else
r = z;
}
int t = dp[i - 1];
for (j = l; j >= 0; j--) {
k = i - (a[i] - b[j]);
if (k <= 0) break;
t = max(t, dp[pre[k] - 1] + l - j + 1);
}
dp[i] = max(dp[i], t);
for (j = l + 1; j < m; j++) {
k = i + b[j] - a[i];
if (k > n) break;
dp[nxt[k]] = max(dp[nxt[k]], t + j - l);
}
}
printf("%d\n", dp[n]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1, x2), gn(x3);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = (long long)a * a % m)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
pair<pair<int, int>, int> p[16];
int dp[65536][121], N[2];
int main() {
int n, sum = 0;
gn(n);
for (int i = 0; i < n; i++) {
char c;
scanf(" %c %d %d", &c, &p[i].first.first, &p[i].first.second);
p[i].second = c == 'R';
sum += p[i].first.first;
}
int mx = min(65536, 1 << n), sz = n * (n - 1) / 2 + 1;
for (int i = 0; i < mx; i++) {
for (int j = 0; j < sz; j++) {
dp[i][j] = 0x3f3f3f3f;
}
}
dp[0][0] = 0;
for (int i = 0; i < mx; i++) {
N[0] = N[1] = 0;
for (int j = 0; j < n; j++)
if ((((i) >> (j)) & 1)) {
N[p[j].second]++;
}
for (int j = 0; j < n; j++)
if (!(((i) >> (j)) & 1)) {
int u = i | (1 << j), num = min(p[j].first.first, N[1]),
cnt = max(p[j].first.second - N[0], 0);
for (int k = 0; k < sz; k++)
if (k + num < sz) {
smin(dp[u][k + num], dp[i][k] + cnt);
}
}
}
int ans = 0x3f3f3f3f;
for (int i = 0; i < sz; i++) {
smin(ans, max(sum - i, dp[mx - 1][i]));
}
println(ans + n);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int main() {
long long n;
int k, cnt = 0;
scanf("%lld %d", &n, &k);
for (int i = 0; i < 63; i++) {
if (n >> i & 1) {
mp[i] = 1;
++cnt;
}
}
if (cnt > k) return puts("No"), 0;
puts("Yes");
int st, pre;
for (int i = 62; i >= -62; i--) {
if (mp[i] + cnt <= k) {
pre = i - 1;
mp[i - 1] += 2 * mp[i];
cnt += mp[i];
mp[i] = 0;
} else
break;
}
int x;
for (int i = -62; i < 62; i++) {
if (mp.count(i)) {
x = i;
break;
}
}
vector<int> v;
int res = k - cnt;
if (res > 0) {
--mp[x];
for (int i = 1; i <= res; i++) v.push_back(x - i);
v.push_back(x - res);
}
for (int i = -62; i < 62; i++)
for (int j = 0, y = mp[i]; j < y; j++) v.push_back(i);
sort(v.begin(), v.end(), greater<int>());
for (int i = 0; i < v.size(); i++)
printf("%d%c", v[i], " \n"[i == v.size() - 1]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 2e5 + 10;
long long a[N];
long long fac[N], rev_fac[N];
long long qpow(long long a, long long k) {
long long ret = 1;
while (k) {
if (k % 2) ret = (a * ret) % MOD;
a = (a * a) % MOD;
k /= 2;
}
return ret;
}
void init() {
fac[1] = fac[0] = 1;
for (int i = 2; i <= (int)2e5; i++) fac[i] = (fac[i - 1] * i) % MOD;
for (int i = 0; i <= (int)2e5; i++) rev_fac[i] = qpow(fac[i], MOD - 2);
}
long long C(long long n, long long m) {
return ((fac[n] * rev_fac[m]) % MOD * rev_fac[n - m]) % MOD;
}
int main() {
init();
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
if (n == 1) {
cout << a[1] << endl;
return 0;
}
if (n % 2 == 0) {
long long left = 0, right = 0;
for (int i = 0; i < n / 2; i++) {
left += C(n / 2 - 1, i) * a[i * 2 + 1];
left %= MOD;
right += C(n / 2 - 1, i) * a[(i + 1) * 2];
right %= MOD;
}
if (n % 4 == 2)
cout << (left + right + MOD) % MOD << endl;
else
cout << (left - right + MOD) % MOD << endl;
} else {
long long sum1 = 0, sum2 = 0, sum3 = 0;
for (int i = 0; i <= n / 2 - 1; i++) {
sum1 += C(n / 2 - 1, i) * a[2 * i + 1];
sum1 %= MOD;
sum2 += C(n / 2 - 1, i) * a[(i + 1) * 2];
sum2 %= MOD;
sum3 += C(n / 2 - 1, i) * a[(i + 1) * 2 + 1];
sum3 %= MOD;
}
if (n % 4 == 3)
cout << (sum1 + 2 * sum2 - sum3 + MOD) % MOD << endl;
else
cout << (sum1 + sum3) % MOD << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500 + 10, inf = 100000000;
int n, m, dp[maxn][30][30], ans = inf, x, y, U = 26;
pair<int, int> par[maxn][30][30];
char a[maxn][maxn];
void prt(int row, int A, int B) {
if (row == 0) return;
prt(row - 1, par[row][A][B].first, par[row][A][B].second);
for (int i = 1; i <= m; i++) {
if (i % 2)
cout << char(A + 'a');
else
cout << char(B + 'a');
}
cout << endl;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
for (int j = 0; j < 26; j++)
for (int z = 0; z < 26; z++) dp[i][j][z] = inf;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < U; j++) {
for (int z = 0; z < U; z++) {
if (z == j) continue;
int c = 0;
for (int k = 1; k <= m; k++) {
if (k % 2 && (int(a[i][k]) - 'a') != j) c++;
if (!(k % 2) && (int(a[i][k]) - 'a') != z) c++;
}
for (int p = 0; p < 26; p++) {
if (p == j) continue;
for (int q = 0; q < 26; q++) {
if (q == z || q == p) continue;
if (dp[i][j][z] > dp[i - 1][p][q] + c) {
par[i][j][z].first = p;
par[i][j][z].second = q;
dp[i][j][z] = dp[i - 1][p][q] + c;
}
}
}
}
}
}
for (int i = 0; i < 26; i++)
for (int j = 0; j < 26; j++)
if (ans > dp[n][i][j]) {
ans = dp[n][i][j];
x = i;
y = j;
}
cout << ans << endl;
prt(n, x, y);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int i = 0;
int ans = 0;
while (i < n) {
++ans;
if ((int)s[i] - 48 + 1 == 2)
i++;
else
break;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int N = 15;
int n, m, ans;
char a[N][N], b[N][N];
void print() {
printf("%d\n", ans);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) printf("%c", b[i][j]);
printf("\n");
}
}
void DFS(int d, int x, int y, int w) {
int i, j;
if (y > m) x++, y = 1;
if (x > n) return;
if (d + w / 5 <= ans) return;
if (d > ans) {
ans = d;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) b[i][j] = a[i][j];
}
}
if (a[x][y] == '.') {
a[x][y] = 'A' + d;
if (a[x + 1][y] == '.' && a[x + 2][y] == '.' && a[x + 1][y + 1] == '.' &&
a[x + 1][y + 2] == '.') {
a[x + 1][y] = a[x + 2][y] = a[x + 1][y + 1] = a[x + 1][y + 2] = 'A' + d;
DFS(d + 1, x, y + 1, w - 5);
a[x + 1][y] = a[x + 2][y] = a[x + 1][y + 1] = a[x + 1][y + 2] = '.';
}
if (a[x][y + 1] == '.' && a[x][y + 2] == '.' && a[x + 1][y + 1] == '.' &&
a[x + 2][y + 1] == '.') {
a[x][y + 1] = a[x][y + 2] = a[x + 1][y + 1] = a[x + 2][y + 1] = 'A' + d;
DFS(d + 1, x, y + 1, w - 5);
a[x][y + 1] = a[x][y + 2] = a[x + 1][y + 1] = a[x + 2][y + 1] = '.';
}
if (a[x + 1][y] == '.' && a[x + 2][y] == '.' && a[x + 1][y - 1] == '.' &&
a[x + 1][y - 2] == '.') {
a[x + 1][y] = a[x + 2][y] = a[x + 1][y - 1] = a[x + 1][y - 2] = 'A' + d;
DFS(d + 1, x, y + 1, w - 5);
a[x + 1][y] = a[x + 2][y] = a[x + 1][y - 1] = a[x + 1][y - 2] = '.';
}
if (a[x + 1][y] == '.' && a[x + 2][y] == '.' && a[x + 2][y - 1] == '.' &&
a[x + 2][y + 1] == '.') {
a[x + 1][y] = a[x + 2][y] = a[x + 2][y - 1] = a[x + 2][y + 1] = 'A' + d;
DFS(d + 1, x, y + 1, w - 5);
a[x + 1][y] = a[x + 2][y] = a[x + 2][y - 1] = a[x + 2][y + 1] = '.';
}
a[x][y] = '.';
}
DFS(d, x, y + 1, w - (a[x][y] == '.'));
}
int main() {
int i, j;
scanf("%d%d", &n, &m);
if (n < 3 || m < 3) {
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) b[i][j] = '.';
}
} else {
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) a[i][j] = '.';
}
DFS(0, 1, 1, n * m);
}
print();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int B = 1000000007;
const int N = 1000001;
int d[N + 5];
int pop(int i) {
int64_t a = 0;
for (; i > 0; i -= i & (-i)) a = (a + d[i]) % B;
return a;
}
int push(int i, int64_t a) {
a = (a + B - pop(i) + pop(i - 1)) % B;
for (; i <= N; i += i & (-i)) d[i] = (d[i] + a) % B;
return 0;
}
int n, a, r;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a);
int r = int64_t(a) * (pop(a) + 1LL) % B;
push(a, r);
}
printf("%d", pop(N));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200123;
vector<pair<int, int> > nbs[N];
int deg[N];
int act[N];
int taken[N];
int par[N];
int paredge[N];
int asparent[N];
int h[N];
int n, a, b;
void dfs(int v, int p = -1, int e = -1, int ch = 0) {
par[v] = p;
paredge[v] = e;
h[v] = ch;
for (pair<int, int> w : nbs[v]) {
if (w.first != p) dfs(w.first, v, w.second, ch + 1);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < (int)n - 1; i++) {
cin >> a >> b;
--a;
--b;
nbs[a].push_back({b, i});
nbs[b].push_back({a, i});
act[i] = 1;
}
dfs(0);
priority_queue<pair<int, int> > pq;
int maxdeg = 0;
for (int i = 0; i < (int)n; i++) {
deg[i] = nbs[i].size();
if (deg[i]) pq.push({deg[i], i});
maxdeg = max(maxdeg, deg[i]);
}
cout << maxdeg << endl;
int curdeg;
int nday = 0;
while (pq.size()) {
nday++;
vector<int> day;
vector<pair<int, int> > todo;
curdeg = pq.top().first;
while (pq.size() && curdeg == pq.top().first) {
pair<int, int> c = pq.top();
pq.pop();
int d = c.first, v = c.second;
if (deg[v] != d) continue;
todo.push_back({h[v], v});
}
sort(todo.begin(), todo.end());
for (int i = 0; i < (int)todo.size(); i++) {
int v = todo[i].second;
if (taken[v] == nday) continue;
pair<int, int> w = {-1, -1};
taken[v] = nday;
if (par[v] != -1 && taken[par[v]] < nday && act[paredge[v]]) {
taken[par[v]] = nday;
w = {par[v], paredge[v]};
} else
for (int i = 0; i < (int)nbs[v].size(); i++) {
if (!act[nbs[v][i].second]) {
swap(nbs[v][i], nbs[v].back());
nbs[v].pop_back();
i--;
} else if (taken[nbs[v][i].first] < nday) {
taken[nbs[v][i].first] = nday;
w = nbs[v][i];
break;
}
}
assert(w.first >= 0);
deg[v]--;
deg[w.first]--;
if (deg[v]) pq.push({deg[v], v});
if (deg[w.first]) pq.push({deg[w.first], w.first});
day.push_back(w.second);
assert(act[w.second]);
act[w.second] = 0;
}
cout << day.size() << " ";
for (int e : day) {
cout << e + 1 << " ";
}
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long res = 1ll;
while (b > 0) {
if (b % 2 != 0) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b /= 2;
}
return res % 1000000007;
}
long long ncr(long long n, long long k) {
if (k > n - k) k = n - k;
long long pro = 1;
for (long long i = 0; i < k; i++) {
pro = (pro * (n - i)) % 1000000007;
pro /= (i + 1);
}
return (pro) % 1000000007;
}
void swap(long long *a, long long *b) {
long long temp = *a;
*a = *b;
*b = temp;
}
vector<long long> prime;
void seive() {
vector<bool> isprime(1000001, true);
for (int i = 2; i * i <= 1000000; i++) {
if (isprime[i]) {
for (int j = i * i; j <= 1000000; j += i) {
isprime[j] = false;
}
}
}
for (int i = 2; i <= 1000000; i++) {
if (isprime[i]) prime.push_back(i);
}
}
vector<long long> parent;
long long find(long long p) {
if (parent[p] == p) return parent[p];
return parent[p] = find(parent[p]);
}
void unun(long long a, long long b) {
long long r1 = find(a);
long long r2 = find(b);
if (r1 != r2) parent[r2] = r1;
}
void solve() {
long long n, m;
cin >> n >> m;
vector<long long> arr(n);
set<long long, greater<long long>> s;
long long odd = ceil(m / 2.0), even = (m / 2);
for (int i = 0; i < n; i++) {
cin >> arr[i];
s.insert(arr[i]);
}
long long x = 0, y = 0;
for (auto itr : s) {
if (itr > m) {
if (itr % 2 == 0) {
even++;
} else {
odd++;
}
}
if (itr % 2 == 0)
x++;
else
y++;
}
if (even < (n / 2)) {
cout << "-1";
return;
}
if (odd < (n / 2)) {
cout << "-1";
return;
}
set<long long> eno, ono;
x = 0;
for (auto itr : s) {
if (itr % 2 == 0) {
eno.insert(itr);
x++;
if (x == (n / 2)) break;
}
}
y = 0;
for (auto itr : s) {
if (itr % 2 != 0) {
ono.insert(itr);
y++;
if (y == n / 2) break;
}
}
long long cnt = 0;
for (int i = 2; i < 2e6 && x < (n / 2); i += 2) {
if (s.find(i) == s.end()) {
x++;
eno.insert(i);
cnt++;
}
}
for (int i = 1; i < 2e6 && y < (n / 2); i += 2) {
if (s.find(i) == s.end()) {
y++;
ono.insert(i);
cnt++;
}
}
cout << cnt << "\n";
vector<long long> ans(n, -1);
for (int i = 0; i < n; i++) {
if (arr[i] % 2 == 0) {
if (eno.find(arr[i]) != eno.end()) {
ans[i] = arr[i];
eno.erase(arr[i]);
}
} else {
if (ono.find(arr[i]) != ono.end()) {
ans[i] = arr[i];
ono.erase(arr[i]);
}
}
}
for (int i = 0; i < n; i++) {
if (ans[i] == -1) {
if (!eno.empty()) {
auto itr = eno.begin();
ans[i] = *itr;
eno.erase(itr);
} else if (!ono.empty()) {
auto itr = ono.begin();
ans[i] = *itr;
ono.erase(itr);
}
}
}
for (auto itr : ans) cout << itr << " ";
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
while (t--) {
solve();
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "[";
string sep;
for (const T& i : v) os << sep << i, sep = " ";
os << "]";
return os;
}
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int test;
cin >> test;
while (test--) {
int n, x, y;
cin >> n >> x >> y;
int b[n];
map<int, vector<int>> m;
for (int i = 0; i < n; i++) {
cin >> b[i];
m[b[i]].push_back(i);
}
int unused = 1;
for (auto& i : m) {
if (unused != i.first) break;
unused++;
}
map<int, vector<int>> freq;
int mx = 0;
for (auto& i : m) {
mx = max(mx, (int)i.second.size());
freq[i.second.size()].push_back(i.first);
}
int ans[n];
int count = x;
while (mx && count) {
int color = freq[mx].back();
freq[mx].pop_back();
if (mx - 1) freq[mx - 1].push_back(color);
if (freq[mx].empty()) {
freq.erase(mx);
mx--;
}
int idx = m[color].back();
m[color].pop_back();
ans[idx] = b[idx];
count--;
}
vector<int> order;
for (auto& i : freq) {
for (auto& j : i.second) {
order.insert(order.end(), m[j].begin(), m[j].end());
}
}
int mismatch = n - y;
bool ok = true;
for (int i = 0; i < n - x; i++) {
int idx = (i + (n - x) / 2) % (n - x);
ans[order[idx]] = b[order[i]];
if (ans[order[idx]] == b[order[idx]]) {
if (!mismatch) {
ok = false;
break;
}
mismatch--;
ans[order[idx]] = unused;
}
}
if (!ok) {
cout << "NO" << '\n';
continue;
}
for (int i = 0; i < n - x && mismatch; i++) {
if (ans[order[i]] != unused) {
ans[order[i]] = unused;
mismatch--;
}
}
cout << "YES" << '\n';
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
cout << '\n';
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100;
template <class T>
inline void relax(T &a, const T &b) {
if (b > a) a = b;
}
inline int sgn(const double &a) {
const double Eps = 1e-5;
if (a < -Eps)
return -1;
else if (a > Eps)
return 1;
else
return 0;
}
inline int dblcmp(const double &a, const double &b) { return sgn(a - b); }
struct point {
double x, y;
};
inline double sqr(double x) { return x * x; }
inline double norm(const point &p) { return sqr(p.x) + sqr(p.y); }
inline double dist2(const point &a, const point &b) {
return sqr(a.x - b.x) + sqr(a.y - b.y);
}
inline double dot(const point &a, const point &o, const point &b) {
return (a.x - o.x) * (b.x - o.x) + (a.y - o.y) * (b.y - o.y);
}
inline double cross(const point &a, const point &o, const point &b) {
return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
}
int n;
point po[MaxN];
inline double getR(const int &pa, const int &pb, const int &pc) {
point a = po[pa], b = po[pb], c = po[pc];
if (sgn(dot(a, b, c)) < 0 || sgn(dot(c, a, b)) < 0 || sgn(dot(b, c, a)) < 0)
return 0;
double e[2][3] = {{2 * (a.x - c.x), 2 * (a.y - c.y), norm(a) - norm(c)},
{2 * (b.x - c.x), 2 * (b.y - c.y), norm(b) - norm(c)}};
double det = e[0][0] * e[1][1] - e[0][1] * e[1][0];
if (sgn(det) == 0) return 0;
point o;
o.x = (e[0][2] * e[1][1] - e[0][1] * e[1][2]) / det;
o.y = (e[0][0] * e[1][2] - e[0][2] * e[1][0]) / det;
double r2 = dist2(o, a);
bool ok = true;
point d;
if (sgn(cross(a, o, b)) == 0) {
d = c;
ok = false;
}
if (sgn(cross(b, o, c)) == 0) {
d = a;
ok = false;
}
if (sgn(cross(c, o, a)) == 0) {
d = b;
ok = false;
}
for (int i = 0; i < n; i++)
if (i != pa && i != pb && i != pc) {
switch (dblcmp(dist2(po[i], o), r2)) {
case -1:
return 0;
case 0:
if (!ok && sgn(cross(po[i], o, d)) == 0) ok = true;
break;
case 1:
break;
}
}
if (!ok) return 0;
return sqrt(r2);
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%lf %lf", &po[i].x, &po[i].y);
double res = 0;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
for (int k = j + 1; k < n; k++) relax(res, getR(i, j, k));
if (res == 0)
printf("-1\n");
else
printf("%.10f\n", res);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int m = 6;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
long long mul(long long a, long long b, long long mod) {
a %= mod;
b %= mod;
long long ret = (a * b - (long long)((long double)a * b / mod) * mod) % mod;
if (ret < 0) ret += mod;
return ret;
}
long long qpow(long long a, long long b, long long mod) {
long long ret = 1;
while (b) {
if (b & 1) ret = mul(ret, a, mod);
a = mul(a, a, mod);
b >>= 1;
}
return ret;
}
int T, n;
long long a;
int main() {
cin >> T;
while (T--) {
cin >> a;
n = to_string(a).length();
long long x = a * 1000000ll;
int pw = 1 << (n + m);
if (x % pw) x += ((pw - x) % pw + pw) % pw;
if (x % 5 == 0) x += pw;
x /= pw;
long long d = 0;
for (int i = 0;; i++)
if (qpow(2, i, 5) == x % 5) {
d = i;
break;
}
long long phi = 4, pw5 = 5;
for (int i = 2; i <= n + m; i++) {
pw5 *= 5;
for (int j = 0;; j++)
if (qpow(2, d + phi * j, pw5) == x % pw5) {
d += phi * j;
break;
}
phi *= 5;
}
cout << d + n + m << '\n';
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, k;
int dai, dem, max1, doi, vtm, min1, dau, max2, d1, st;
int a[222222], b[222222], d[222222], onl[222222];
int tt, ban;
struct cs {
int fr, tb;
};
cs msx[150005];
bool sx(int x, int y) { return x > y; }
int check() {
int l, r, m;
l = 0;
r = k - 1;
while (l < r) {
m = (l + r) / 2;
if (d[m] > a[ban - 1])
l = m + 1;
else
r = m;
}
if (d[l] == a[ban - 1]) return 1;
return 0;
}
void sol() {
int i, j;
if (tt == 1) {
if (dem < k) {
d[dem++] = a[ban - 1];
sort(d, d + dem, sx);
} else {
d[k] = max(d[k], a[ban - 1]);
sort(d, d + k + 1, sx);
}
return;
}
if (check() == 1)
printf("YES\n");
else
printf("NO\n");
}
int main() {
int i, j, x, y;
while (scanf("%d %d %d", &n, &k, &q) > 0) {
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
msx[i].fr = i;
msx[i].tb = a[i];
}
dem = 0;
for (i = 0; i < q; i++) {
scanf("%d %d", &tt, &ban);
sol();
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000000007;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int t, n, c;
cin >> t;
long long int pows[32];
for (long long int i = 0; i < 32; i++)
if (!i)
pows[i] = 1;
else
pows[i] = 2 * pows[i - 1];
while (t--) {
cin >> n;
c = 0;
while (n) {
if (n % 2) c++;
n /= 2;
}
cout << pows[c] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int test;
scanf("%d", &test);
while (test-- > 0) {
double R, r, k;
scanf("%lf%lf%lf", &R, &r, &k), R = 1 / (2 * R), r = 1 / (2 * r);
double rr = (r - R) / 2, x = (r + R) / 2, y = 2 * rr * k, d = x * x + y * y;
printf("%.10lf\n", rr / (d - rr * rr));
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
deque<int> Min;
deque<int> Max;
int n, k;
vector<int> Occ;
int arr[123456];
int BS(int L, int R, bool F) {
int ans = (L + R) / 2;
if (R - L <= 1 && F) {
return ans;
}
Occ.clear();
bool flag = 0;
if (ans == 1) flag = 1;
for (int i = 0; i < n; i++) {
int curr = arr[i];
while (!Min.empty() && Min.front() <= i - ans) {
Min.pop_front();
}
while (!Min.empty() && arr[Min.back()] >= curr) {
Min.pop_back();
}
Min.push_back(i);
int lower = arr[Min.front()];
while (!Max.empty() && Max.front() <= i - ans) {
Max.pop_front();
}
while (!Max.empty() && arr[Max.back()] <= curr) {
Max.pop_back();
}
Max.push_back(i);
int upper = arr[Max.front()];
if (ans <= i + 1 && upper - lower <= k) {
flag = 1;
Occ.push_back(i + 2 - ans);
}
}
Max.clear();
Min.clear();
if (flag && F)
return BS(ans, R, F);
else if (F)
return BS(L, ans, F);
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> arr[i];
int ans = BS(1, n + 1, 1);
BS(ans, ans, 0);
cout << ans << " " << Occ.size() << endl;
for (int i = 0; i < Occ.size(); i++) {
cout << Occ[i] << " " << Occ[i] + ans - 1 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[110][27], b[27][27], tedad[110];
bool check[27][27];
int main() {
long long n, x, m = 0;
cin >> n;
string s[n];
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < (int)s[i].size(); j++) {
x = s[i][j] - 96;
a[i][x] = 1;
}
for (int j = 0; j < 27; j++) tedad[i] = tedad[i] + a[i][j];
}
for (int i = 1; i < 27; i++)
for (int j = 1; j < 27; j++) {
if (check[i][j] == true || check[j][i] == true) continue;
check[i][j] = true;
for (int t = 0; t < n; t++) {
if (a[t][i] > 0 && a[t][j] > 0 && i == j && tedad[t] == 1)
b[i][j] = b[i][j] + s[t].size();
else if (a[t][i] > 0 && a[t][j] > 0 && i != j && tedad[t] == 2 ||
(a[t][i] > 0 && a[t][j] == 0 && tedad[t] == 1) ||
(a[t][i] == 0 && a[t][j] > 0 && tedad[t] == 1))
b[i][j] = b[i][j] + s[t].size();
}
}
for (int i = 1; i < 27; i++)
for (int j = 1; j < 27; j++) m = max(b[i][j], m);
cout << m << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do {
x = x * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return x * f;
}
inline pair<long long, int> operator+(const pair<long long, int>& t1,
const pair<long long, int>& t2) {
return make_pair(t1.first + t2.first, t1.second + t2.second);
}
inline pair<long long, int> operator-(const pair<long long, int>& t1,
const pair<long long, int>& t2) {
return make_pair(t1.first - t2.first, t1.second - t2.second);
}
const int N = 1e6 + 10;
struct node {
int l, r;
} q[N];
int n, nq, a[N], lb[N], rb[N], s[N], ls;
long long tans[N];
vector<int> lnum[N], rnum[N], ql[N], qr[N];
pair<long long, int> T[N];
void qadd(int x, pair<long long, int> v) {
while (x <= n) T[x] = T[x] + v, x += ((x) & -(x));
}
pair<long long, int> qsum(int x) {
pair<long long, int> ans = make_pair(0, 0);
while (x) ans = ans + T[x], x -= ((x) & -(x));
return ans;
}
int main() {
scanf("%d%d", &n, &nq);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) {
while (ls && a[s[ls]] < a[i]) rb[s[ls--]] = i - 1;
lb[i] = s[ls] + 1;
s[++ls] = i;
}
while (ls) rb[s[ls--]] = n;
for (int i = 1; i <= nq; ++i) scanf("%d", &q[i].l);
for (int i = 1; i <= nq; ++i) scanf("%d", &q[i].r);
for (int i = 1; i <= nq; ++i) {
ql[q[i].l].push_back(i);
qr[q[i].r].push_back(i);
}
for (int i = 1; i <= n; ++i) {
lnum[lb[i]].push_back(i);
qadd(i, make_pair(lb[i], 0));
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < lnum[i].size(); ++j) qadd(lnum[i][j], make_pair(-i, 1));
for (int j = 0; j < ql[i].size(); ++j) {
int id = ql[i][j], l = q[id].l, r = q[id].r;
pair<long long, int> tmp = qsum(r) - qsum(l - 1);
tans[id] -= tmp.first + 1ll * i * tmp.second;
}
}
memset(T, 0, sizeof(T));
for (int i = 1; i <= n; ++i) {
rnum[rb[i]].push_back(i);
qadd(i, make_pair(rb[i], 0));
}
for (int i = n; i >= 1; --i) {
for (int j = 0; j < rnum[i].size(); ++j) qadd(rnum[i][j], make_pair(-i, 1));
for (int j = 0; j < qr[i].size(); ++j) {
int id = qr[i][j], l = q[id].l, r = q[id].r;
pair<long long, int> tmp = qsum(r) - qsum(l - 1);
tans[id] += tmp.first + 1ll * i * tmp.second;
}
}
for (int i = 1; i <= nq; ++i)
printf("%lld%c", tans[i] + q[i].r - q[i].l + 1ll, i == nq ? '\n' : ' ');
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 2;
const long long mod = 1000000007;
long long n, par[N], s[N], a[N], d[N];
vector<long long> adj[N], dep[N];
void dfs(long long u, long long p) {
for (long long v : adj[u]) {
if (v == p) continue;
d[v] = d[u] + 1;
dep[d[v]].push_back(v);
dfs(v, u);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 2; i <= n; i++) {
cin >> par[i];
adj[i].push_back(par[i]);
adj[par[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
cin >> s[i];
}
a[1] = s[1];
dep[1].push_back(1), d[1] = 1;
dfs(1, 1);
for (long long dd = 2; dd <= n; dd += 2) {
for (long long u : dep[dd]) {
if (adj[u].size() == 1)
a[u] = 0;
else {
long long mn = (1LL << 61);
for (long long v : adj[u]) {
if (v == par[u]) continue;
mn = min(mn, s[v] - s[par[u]]);
}
if (mn < 0) {
cout << -1;
return 0;
}
a[u] = mn;
for (long long v : adj[u]) {
if (v == par[u]) continue;
a[v] = s[v] - s[par[u]] - a[u];
}
}
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += a[i];
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
void solve() {
cin >> s;
long long cnt = 0, minc = 0, ans = 0;
for (int i = 0; i < s.length(); ++i) {
if (s[i] == '+')
cnt++;
else
cnt--;
if (cnt < minc) {
ans += (i + 1) * (minc - cnt);
minc = cnt;
}
}
cout << ans + s.length() << endl;
}
int main() {
int T;
cin >> T;
while (T--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long double EPS = 1e-8;
int n, m;
vector<int> a, b;
pair<long long, long long> count(int p, int q) {
int y = a[p] + b[q];
long long ans1 = 0, ans2 = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i] + b[j] == y) {
ans1 |= (1LL << j);
}
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (b[i] + a[j] == y) {
ans2 |= (1LL << j);
}
}
}
return {ans1, ans2};
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
a.resize(n);
b.resize(m);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
vector<pair<long long, long long>> can;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
can.push_back(count(i, j));
}
}
int ans = 0;
for (int i = 0; i < can.size(); i++) {
for (int j = i; j < can.size(); j++) {
ans = max(ans, __builtin_popcountll(can[i].first | can[j].first) +
__builtin_popcountll(can[i].second | can[j].second));
}
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int i, j, k, l, n, m, c2 = 1;
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) {
if (i % 2 != 0) {
for (j = 1; j <= m; j++) {
printf("#");
}
printf("\n");
continue;
}
if (i % 2 == 0) {
if (c2 % 2 != 0) {
for (k = 1; k < m; k++) {
printf(".");
}
printf("#\n");
c2++;
continue;
}
if (c2 % 2 == 0) {
printf("#");
for (l = 1; l < m; l++) {
printf(".");
}
printf("\n");
c2++;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long dap = 0;
void f(long long p, long long q) {
if (p == 0 || q == 0) return;
if (p >= q) {
dap += p / q;
f(p % q, q);
} else {
dap += q / p;
f(p, q % p);
}
}
int main() {
long long a, b;
scanf("%lld%lld", &a, &b);
f(a, b);
printf("%lld", dap);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, c;
cin >> n >> m >> c;
int a[n], b[m];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
for (int i = 0; i < n - m + 1; i++) {
int k = 0;
for (int j = i; j < i + m; j++) {
a[j] = (a[j] + b[k]) % c;
k++;
}
}
for (int i = 0; i < n; i++) {
cout << a[i] << " ";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long s = 0;
int a[110], c[50], n, m, i, cs, t;
bool b[110];
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= m; i++) {
scanf("%d", &t);
b[t] = true;
cs = cs + 1;
c[cs] = a[t];
}
for (i = 1; i <= n; i++)
if (!b[i]) s += a[i];
sort(c + 1, c + cs + 1);
for (i = cs; i >= 1; i--)
if (c[i] > s)
s += c[i];
else
s *= 2;
printf("%lld\n", s);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool has[10];
int f(int x) {
while (x > 0) {
if (has[x % 10]) {
return 1;
}
x /= 10;
}
return 0;
}
int main() {
int n;
cin >> n;
int tmp = n;
while (tmp > 0) {
has[tmp % 10] = 1;
tmp /= 10;
}
int sol = 0;
for (int d = 1; d * d <= n; ++d) {
if (n % d == 0) {
sol += f(d) + (d * d < n ? f(n / d) : 0);
}
}
cout << sol << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int f[100010], g[100010], h[100010];
int n, p, t1, t2, t3;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &f[i]);
}
p = 0;
for (int i = 1; i <= n; i++) {
t1 = f[i];
t2 = 0;
for (int j = i + 1; j <= n; j++)
if (f[j] < t1) t1 = f[j], t2 = j;
if (t2 != 0) {
p++;
g[p] = i - 1;
h[p] = t2 - 1;
t3 = f[i];
f[i] = t1;
f[t2] = t3;
}
}
printf("%d\n", p);
for (int i = 1; i <= p; i++) printf("%d %d\n", g[i], h[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
if (m == 3 && n > 4) return puts("-1"), 0;
for (int i = 1; i <= m; i++) printf("%d %d\n", i, i * i + 300000);
for (int i = 1; i <= n - m; i++) printf("%d %d\n", i, -i * i - 300000);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
struct sTree {
int pl, pr;
int val, cnt, debt;
} tree[4000009];
int treeSize;
int NewNode(int LL, int RR) {
int cur = ++treeSize;
tree[cur].cnt = RR - LL + 1;
return cur;
}
void CalcDebt(int LL, int RR, int cur);
void Add(int L, int R, int d, int LL, int RR, int cur) {
if (L <= LL && R >= RR) {
tree[cur].debt += d;
tree[cur].val += d;
return;
}
int M = LL + (RR - LL) / 2;
if (!tree[cur].pl) tree[cur].pl = NewNode(LL, M);
if (!tree[cur].pr) tree[cur].pr = NewNode(M + 1, RR);
CalcDebt(LL, RR, cur);
if (L <= M && LL <= R) {
Add(L, R, d, LL, M, tree[cur].pl);
}
if (L <= RR && M + 1 <= R) {
Add(L, R, d, M + 1, RR, tree[cur].pr);
}
if (tree[tree[cur].pl].val < tree[tree[cur].pr].val) {
tree[cur].val = tree[tree[cur].pl].val;
tree[cur].cnt = tree[tree[cur].pl].cnt;
} else if (tree[tree[cur].pl].val > tree[tree[cur].pr].val) {
tree[cur].val = tree[tree[cur].pr].val;
tree[cur].cnt = tree[tree[cur].pr].cnt;
} else {
tree[cur].val = tree[tree[cur].pl].val;
tree[cur].cnt = tree[tree[cur].pl].cnt + tree[tree[cur].pr].cnt;
}
}
int Get(int cur) {
if (tree[cur].val == 0) {
return 2 * inf + 1 - tree[cur].cnt;
}
return 2 * inf + 1;
}
void CalcDebt(int LL, int RR, int cur) {
int M = LL + (RR - LL) / 2;
Add(LL, M, tree[cur].debt, LL, M, tree[cur].pl);
Add(M + 1, RR, tree[cur].debt, M + 1, RR, tree[cur].pr);
tree[cur].debt = 0;
}
int n;
struct event {
char type;
int p, L, R;
} e[200009];
bool operator<(event a, event b) {
if (a.p != b.p) return a.p < b.p;
return a.type < b.type;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1 += inf, y1 += inf, x2 += inf, y2 += inf;
e[2 * i].type = '+';
e[2 * i].p = min(x1, x2) - 1;
e[2 * i].L = min(y1, y2);
e[2 * i].R = max(y1, y2);
e[2 * i + 1].type = '-';
e[2 * i + 1].p = max(x1, x2);
e[2 * i + 1].L = min(y1, y2);
e[2 * i + 1].R = max(y1, y2);
}
sort(e, e + 2 * n);
int root = NewNode(0, 2 * inf);
long long ans = 0;
int prev = -1;
for (int i = 0; i < 2 * n; i++) {
int j = i;
while (j + 1 < 2 * n && e[j + 1].p == e[i].p) j++;
ans += 1LL * Get(root) * (e[i].p - prev);
for (int k = i; k <= j; k++) {
if (e[k].type == '+') {
Add(e[k].L, e[k].R, 1, 0, 2 * inf, root);
} else {
Add(e[k].L, e[k].R, -1, 0, 2 * inf, root);
}
}
i = j;
prev = e[i].p;
}
cout << ans;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 1000010;
const int INF = 2147483600;
int N, M;
long long a[MAXN + 1], sum[MAXN + 1], b[MAXN + 1];
long long S;
int main() {
N = read(), M = read();
for (int i = 1; i <= M; i++)
a[i] = read(), sum[i] = (sum[i - 1] + a[i]) % N, S += a[i];
sum[M] = N;
sort(sum + 1, sum + M + 1);
int X = (int)(ceil(1.0 * S / N));
printf("%d\n", X);
for (int i = 1; i <= M; i++)
b[i] = sum[i] - sum[i - 1], printf("%lld ", b[i]);
printf("\n");
int now = 1;
for (int i = 1; i <= X; i++) {
for (int j = 1; j <= M; j++) {
while (now <= M && !a[now]) ++now;
a[now] -= b[j], printf("%d ", min(now, M));
}
printf("\n");
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 310, foo = INT_MIN;
int n, m;
int c[MAX][MAX];
int f[10][MAX][MAX], curf[MAX][MAX], tmp[MAX][MAX];
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) c[i][j] = foo;
for (int i = (1); i <= (n); ++i) c[i][i] = 0;
for (int i = (1); i <= (m); ++i) {
int a, b;
scanf("%d%d", &a, &b);
scanf("%d%d", &c[a][b], &c[b][a]);
}
int pp = 31;
for (; pp >= 0; pp--)
if ((1 << pp) & n) break;
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) f[0][i][j] = c[i][j];
for (int k = (1); k <= (pp); ++k) {
for (int i = (1); i <= (n); ++i) {
for (int j = (1); j <= (n); ++j) {
auto &ele = f[k][i][j] = foo;
for (int mid = (1); mid <= (n); ++mid) {
int a = f[k - 1][i][mid], b = f[k - 1][mid][j];
if (a != foo && b != foo) ele = max(ele, a + b);
}
}
}
}
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) curf[i][j] = foo;
for (int i = (1); i <= (n); ++i) curf[i][i] = 0;
int step = pp + 1, cur = 0;
while (step) {
int mid = step - 1;
for (int i = (1); i <= (n); ++i) {
for (int j = (1); j <= (n); ++j) {
auto &ele = tmp[i][j] = foo;
for (int h = (1); h <= (n); ++h) {
int a = curf[i][h], b = f[mid][h][j];
if (a != foo && b != foo) {
ele = max(ele, a + b);
}
}
}
}
bool ok = 0;
for (int i = (1); i <= (n); ++i)
if (tmp[i][i] > 0) {
ok = 1;
break;
}
if (!ok) {
for (int i = (1); i <= (n); ++i)
for (int j = (1); j <= (n); ++j) curf[i][j] = tmp[i][j];
cur += 1 << mid;
}
step = mid;
}
int ans = -1;
for (int i = (1); i <= (n); ++i)
if (curf[i][i] > 0) {
ans = cur;
break;
}
if (ans == -1) {
for (int i = (1); i <= (n); ++i) {
for (int j = (1); j <= (n); ++j) {
auto &ele = tmp[i][j] = foo;
for (int h = (1); h <= (n); ++h) {
int a = curf[i][h], b = f[0][h][j];
if (a != foo && b != foo) {
ele = max(ele, a + b);
}
}
}
}
for (int i = (1); i <= (n); ++i)
if (tmp[i][i] > 0) {
ans = cur + 1;
break;
}
}
if (ans == -1)
printf("%d\n", 0);
else
printf("%d\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
struct node {
int u, v;
} Query[N];
int Par[N][18], Mx[N][18], h[N], Time[N], mem[N], Val[N], lab[N], n, m, cnt, sl;
vector<int> a[N];
int get(int u) { return u == lab[u] ? u : lab[u] = get(lab[u]); }
void dfs(int u) {
for (int v : a[u]) {
h[v] = h[u] + 1;
Mx[v][0] = Val[v];
Par[v][0] = u;
for (int i = 1; i <= 17; ++i) {
Par[v][i] = Par[Par[v][i - 1]][i - 1];
Mx[v][i] = max(Mx[Par[v][i - 1]][i - 1], Mx[v][i - 1]);
}
dfs(v);
}
}
int get(int u, int v) {
if (u == v) return 0;
int d = h[v] - h[u];
int ans = Val[v];
for (int i = 17; i >= 0; --i) {
if ((d >> i) & 1) {
ans = max(ans, Mx[v][i]);
v = Par[v][i];
}
}
if (v != u) return m + 1;
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) lab[i] = i;
int type, x, u, v;
for (int i = 1; i <= m; ++i) {
cin >> type;
if (type == 2) {
cin >> x;
++cnt;
mem[cnt] = x;
Time[cnt] = i;
continue;
}
cin >> u >> v;
if (type == 1) {
a[v].push_back(u);
Val[u] = i;
lab[u] = v;
}
if (type == 3) {
Query[++sl] = {u, v};
}
}
for (int i = 1; i <= n; ++i) {
if (!Val[i]) dfs(i);
}
for (int i = 1; i <= sl; ++i) {
u = Query[i].u;
v = mem[Query[i].v];
if (get(u) != get(v) || h[u] > h[v]) {
cout << "NO\n";
continue;
}
if (get(u, v) < Time[Query[i].v]) {
cout << "YES\n";
continue;
}
cout << "NO\n";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
template <typename t1>
t1 gcd(t1 a, t1 b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename t1>
t1 lcm(t1 a, t1 b) {
return a * (b / gcd(a, b));
}
int main() {
int n, d, h;
while (cin >> n >> d >> h) {
if (h == 1 && d == 1 && n > 2)
cout << -1 << endl;
else if (d < h)
cout << -1 << endl;
else if (n <= d || d > 2 * h)
cout << -1 << endl;
else if (h == d) {
{
int l = h;
int now = 1;
while (l--) {
cout << now << " " << now + 1 << endl;
now++;
}
now++;
int nnn = 2;
int tem = d + 1;
while (now <= n) {
cout << nnn << " " << now++ << endl;
}
}
} else {
int l = h;
int now = 1;
while (l--) {
cout << now << " " << now + 1 << endl;
now++;
}
now++;
int rem = d - h;
while (now <= n) {
int flag = 0;
int noww = 1;
int nrem = rem;
while (nrem--) {
if (now > n) {
flag = 1;
break;
}
cout << noww << " " << now << endl;
noww = now;
now++;
}
if (flag) break;
}
}
}
}
| 4 |
#include <iostream>
#include <algorithm>
#include <bits/stdc++.h>
#define fastio ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define rep(i, n) for (int i=0; i<(n); i++)
using namespace std;
vector<long long> a[100000];
bool comp(vector<long long> a, vector<long long> b){
return a[0] < b[0];
}
void solve(){
int n;
cin>>n;
long long b;
long long count = 0;
rep(i, n){
cin>>b;
a[i] = {b, i + 1};
}
sort(a, a + n, comp);
// rep(i, n){
// cout<<a[i][0]<<" "<<a[i][1]<<"\n";
// }
rep(i, n){
rep(j, i){
if(a[j][0]*a[i][0] == a[j][1]+a[i][1] )
count ++;
if(a[j][0]*a[i][0] > 2 * n + 1)
break;
}
}
cout<<count<<"\n";
}
int main(){
fastio;
int t;
cin>>t;
while(t--)
solve();
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
string a[] = {"00:00", "01:10", "02:20", "03:30", "04:40", "05:50",
"10:01", "11:11", "12:21", "13:31", "14:41", "15:51",
"20:02", "21:12", "22:22", "23:32"};
int main() {
ios::sync_with_stdio(false);
set<string> s;
int t = 0;
string d, in;
while (t < 16) {
s.insert(a[t]);
t++;
}
cin >> in;
for (set<string>::iterator it = s.begin(); it != s.end(); ++it) {
if (in < (*it)) {
cout << (*it) << endl;
return 0;
}
}
cout << a[0] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int grid[105][105];
vector<pair<int, int> > ans;
void apb(int aw, int bw) {
ans.push_back(make_pair(aw + 1, bw + 1));
grid[aw][bw] ^= 1;
}
void solve3(int r, int c) {
for (int i = r; i <= r + 1; i++) {
for (int j = c; j <= c + 1; j++) {
if (grid[i][j] == 1) apb(i, j);
}
}
}
void solve2(int r, int c) {
int saw = 0;
for (int i = r; i <= r + 1; i++) {
for (int j = c; j <= c + 1; j++) {
if (grid[i][j] == 0) {
apb(i, j);
} else if (!saw) {
apb(i, j);
saw++;
}
}
}
solve3(r, c);
}
void solve1(int r, int c) {
if (grid[r][c] == 1) {
apb(r, c);
apb(r + 1, c);
apb(r + 1, c + 1);
} else if (grid[r + 1][c] == 1) {
apb(r + 1, c);
apb(r, c);
apb(r, c + 1);
} else if (grid[r][c + 1] == 1) {
apb(r, c + 1);
apb(r, c);
apb(r + 1, c);
} else if (grid[r + 1][c + 1] == 1) {
apb(r + 1, c + 1);
apb(r, c);
apb(r + 1, c);
}
solve2(r, c);
}
void solve4(int r, int c) {
apb(r, c);
apb(r + 1, c);
apb(r, c + 1);
solve1(r, c);
}
void zzero(int r, int c) {
int ct = grid[r][c] + grid[r + 1][c] + grid[r][c + 1] + grid[r + 1][c + 1];
if (ct == 1) solve1(r, c);
if (ct == 2) solve2(r, c);
if (ct == 3) solve3(r, c);
if (ct == 4) solve4(r, c);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
ans.clear();
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char c;
cin >> c;
if (c == '0')
grid[i][j] = 0;
else
grid[i][j] = 1;
}
for (int i = 0; i < n; i += 2) {
for (int j = 0; j < m; j += 2) {
if (i == n - 1) i--;
if (j == m - 1) j--;
zzero(i, j);
}
}
cout << ans.size() / 3 << '\n';
for (int i = 0; i < ans.size(); i += 3) {
cout << ans[i].first << ' ' << ans[i].second << ' ' << ans[i + 1].first
<< ' ' << ans[i + 1].second << ' ' << ans[i + 2].first << ' '
<< ans[i + 2].second << '\n';
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
set<pair<long long, long long> > s;
int a, b, w, h, n;
int A[100100];
bool good(long long w, long long h) {
return (w >= a && h >= b) || (w >= b && h >= a);
}
int main() {
ios::sync_with_stdio(false);
cin >> a >> b >> w >> h >> n;
for (int i = 0; i < (int)(n); ++i) {
cin >> A[i];
}
sort(A, A + n);
s.insert(make_pair(min(w, h), max(w, h)));
for (int i = 0; i < (int)(n + 1); ++i) {
for (auto x : s) {
if (good(x.first, x.second)) {
cout << i << endl;
return 0;
}
}
if (i == n) {
break;
}
long long m = A[n - i - 1];
vector<pair<long long, long long> > nval;
for (auto x : s) {
if (x.first <= 100000) {
nval.push_back(
make_pair(min(x.first * m, x.second), max(x.first * m, x.second)));
}
if (x.second <= 100000) {
nval.push_back(
make_pair(min(x.second * m, x.first), max(x.second * m, x.first)));
}
}
s.clear();
for (auto x : nval) {
s.insert(x);
}
}
cout << -1 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int MAXN = 500 * 2 + 10;
using namespace std;
int n;
int ans = 1e9;
string a, b;
int kol = 0;
int anst;
void check() {
string t1, t2;
t1 = a;
t2 = b;
t1 += a;
t2 += b;
int ans = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) {
for (int k = i; k < i + n; k++)
for (int p = j; p < j + n; p++) {
if (t1[k] == t2[p]) ans++;
}
}
anst = max(anst, ans);
if (anst == ans) {
cout << a << ' ' << ans << endl;
kol++;
}
}
void bt(int i) {
if (i == n) {
check();
return;
}
a[i] = 'A';
bt(i + 1);
a[i] = 'G';
bt(i + 1);
a[i] = 'C';
bt(i + 1);
a[i] = 'T';
bt(i + 1);
}
const int MOD = 1e9 + 7;
long long binpow(long long a, long long n) {
if (n == 0) return 1;
if (n % 2 == 1)
return (binpow(a, n - 1) * a) % MOD;
else {
long long b = (binpow(a, n / 2)) % MOD;
return (b * b) % MOD;
}
}
int K[100];
int main() {
cin >> n;
cin >> a;
b = a;
for (int i = 0; i < n; i++) {
K[a[i] - 'A']++;
}
if (K['A' - 'A'] == n) {
cout << '1';
return 0;
}
if (K['T' - 'A'] == n) {
cout << '1';
return 0;
}
if (K['C' - 'A'] == n) {
cout << '1';
return 0;
}
if (K['G' - 'A'] == n) {
cout << '1';
return 0;
}
int m = K['A' - 'A'];
m = max(m, K['T' - 'A']);
m = max(m, K['G' - 'A']);
m = max(m, K['C' - 'A']);
int cnt = 0;
if (K['A' - 'A'] == m) cnt++;
if (K['T' - 'A'] == m) cnt++;
if (K['C' - 'A'] == m) cnt++;
if (K['G' - 'A'] == m) cnt++;
long long d = 1;
if (cnt != 1) d = binpow((long long)cnt, (long long)n) % MOD;
cout << d;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, s = 0, i, j, k, b[1000], m = 0, temp, l = 0;
char a[1000];
scanf("%d", &n);
getchar();
while (n--) {
gets(a);
k = strlen(a);
b[0] = 0;
for (i = 0; i < k; i++) {
if (a[i] == '1')
s++;
else {
if (s != 0) {
b[l] = s;
l++;
}
s = 0;
}
}
if (a[k - 1] == '1') {
b[l] = s;
l++;
}
for (i = 0; i < l - 1; i++) {
for (j = i + 1; j < l; j++) {
if (b[i] < b[j]) {
temp = b[i];
b[i] = b[j];
b[j] = temp;
}
}
}
for (i = 0; i < l; i += 2) {
m = m + b[i];
}
printf("%d\n", m);
m = 0;
s = 0;
l = 0;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
char s[1010];
int a[1010], num[1010], b[30];
int prime[1010], notprime[1010];
priority_queue<pair<int, char> > pq;
set<pair<int, int> > st;
pair<int, int> c[1010];
int ans[1010];
int cnt;
void init() {
for (int i = 2; i <= 1000; i++) {
if (!notprime[i]) prime[cnt++] = i;
for (int j = 0; j < cnt && i * prime[j] <= 1000; j++) {
notprime[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
}
}
for (int i = 0; i <= 1000; i++) a[i] = i, num[i] = 1;
}
int get(int x) { return a[x] == x ? x : a[x] = get(a[x]); }
void merge(int x, int y) {
int t1 = get(x);
int t2 = get(y);
if (t1 != t2) {
a[max(t1, t2)] = min(t1, t2);
num[min(t1, t2)] += num[max(t1, t2)];
}
}
bool cmp(pair<int, int> x, pair<int, int> y) { return x.first > y.first; }
int main() {
init();
scanf("%s", s);
int l = strlen(s);
for (int i = 0; i < l; i++) b[s[i] - 'a']++;
for (int i = 0; i < 30; i++)
if (b[i]) pq.push({b[i], i + 'a'});
for (int i = 0; i < cnt && prime[i] <= l; i++)
for (int j = 2; j <= l / prime[i]; j++) merge(prime[i], j * prime[i]);
st.insert({1, 1});
for (int i = 0; i < cnt && prime[i] <= l; i++) {
int r = get(prime[i]);
st.insert({num[r], r});
}
int num = 0, j = 0;
for (auto i : st) c[num++] = i;
sort(c, c + num, cmp);
int flag = 0;
while (pq.size() && j < num) {
pair<int, char> t = pq.top();
pq.pop();
if (t.first >= c[j].first)
ans[c[j].second] = t.second - 'a';
else {
flag = 1;
break;
}
if (t.first - c[j].first > 0) pq.push({t.first - c[j].first, t.second});
j++;
}
if (flag)
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i <= l; i++) printf("%c", ans[get(i)] + 'a');
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int inf = pow(10, 9) + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int a, b, k;
cin >> a >> b >> k;
long long int ans = 0;
if (k & 1) {
ans += ((k + 1) / 2) * a;
ans -= (k / 2) * b;
cout << ans << "\n";
} else {
long long int ans = 0;
ans += (k / 2) * a;
ans -= (k / 2) * b;
cout << ans << "\n";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
long long power(long long a, long long b);
long long dp[205][500];
long long a[205];
long long n;
long long solve(long long idx, long long t) {
if (idx == n + 1) return 0;
if (t == 2 * n + 1) return 1e7;
if (dp[idx][t] != -1) return dp[idx][t];
long long ans = solve(idx, t + 1);
ans = min(ans, solve(idx + 1, t + 1) + abs(a[idx] - t));
dp[idx][t] = ans;
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t = 1;
cin >> t;
while (t--) {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
memset(dp, -1, sizeof dp);
sort(a + 1, a + n + 1);
cout << solve(1, 1) << "\n";
}
return 0;
}
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b % 2)
b--, res = res * a;
else
b = b / 2, a *= a;
}
return res;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int n, k, a[N], b[N];
long long l = 0, r = 2e9, ans;
priority_queue<int, vector<int>, greater<int> > q1;
priority_queue<int> q2;
inline int read() {
char c = getchar();
int ans = 0;
while (c < 48 || c > 57) c = getchar();
while (c >= 48 && c <= 57)
ans = (ans << 3) + (ans << 1) + (c ^ 48), c = getchar();
return ans;
}
int main() {
n = read(), k = read();
for (register int i = 1; i <= n; ++i) a[i] = -read();
for (register int i = 1; i <= n; ++i) b[i] = -read();
while (l <= r) {
int cnt = 0;
long long mid = l + r >> 1, s = 0;
while (!q1.empty()) q1.pop();
while (!q2.empty()) q2.pop();
for (register int i = n; i; --i) {
q1.push(a[i]), q2.push(b[i]);
long long s1 = a[i] - q1.top(), s2 = a[i] + q2.top() + mid;
if (s2 >= s1)
s += s2, ++cnt, q2.pop();
else
s += s1, q1.pop();
}
if (cnt <= k)
ans = s - mid * k, l = mid + 1;
else
r = mid - 1;
}
printf("%lld", -ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long int d[1001000];
int main() {
d[1] = 1;
long long int i, j, k, a, b, c, m, div, sum = 0, counter;
cin >> a >> b >> c;
for (i = 1; i <= a; i++) {
for (j = 1; j <= b; j++) {
for (k = 1; k <= c; k++) {
div = i * j * k;
if (d[div] == 0) {
for (m = 2, counter = 2; m * m < div + 1; m++) {
if (div % m == 0) {
counter++;
if (div / m != m) {
counter++;
}
}
}
d[div] = counter;
}
sum += d[div];
sum %= 1073741824;
}
}
}
cout << sum << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
struct easy {
long long int lv, mv, rv;
};
const int N = 3e5 + 5;
easy jt[4 * N];
vector<long long int> diff(N);
vector<long long int> ip(N);
long long int sign(long long int x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }
void merge(long long int l, long long int h, long long int p, long long int m) {
jt[p].mv = max(jt[2 * p + 1].mv, jt[2 * p + 2].mv);
if (!diff[m] || !diff[m + 1] || sign(diff[m]) < sign(diff[m + 1])) {
jt[p].lv = jt[2 * p + 1].lv;
jt[p].rv = jt[2 * p + 2].rv;
} else {
jt[p].mv = max(jt[p].mv, jt[2 * p + 1].rv + jt[2 * p + 2].lv);
if (jt[2 * p + 1].mv == m - l + 1)
jt[p].lv = jt[2 * p + 1].lv + jt[2 * p + 2].lv;
else
jt[p].lv = jt[2 * p + 1].lv;
if (jt[2 * p + 2].mv == h - m)
jt[p].rv = jt[2 * p + 1].rv + jt[2 * p + 2].rv;
else
jt[p].rv = jt[2 * p + 2].rv;
}
return;
}
void cst(long long int l, long long int h, long long int p) {
if (l == h) {
long long int x = !!diff[l];
jt[p] = {x, x, x};
return;
}
long long int m = (l + h) >> 1;
cst(l, m, 2 * p + 1);
cst(m + 1, h, 2 * p + 2);
merge(l, h, p, m);
return;
}
void update(long long int l, long long int h, long long int p, long long int pp,
long long int v) {
if (l == h) {
diff[l] += v;
long long int x = !!diff[l];
jt[p] = {x, x, x};
return;
}
long long int m = (l + h) >> 1;
if (m >= pp)
update(l, m, 2 * p + 1, pp, v);
else
update(m + 1, h, 2 * p + 2, pp, v);
merge(l, h, p, m);
return;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
srand;
long long int n;
cin >> n;
for (long long int i = 0; i < 4 * n; i++) jt[i].lv = jt[i].mv = jt[i].rv = 0;
for (long long int i = 0; i < n; i++) cin >> ip[i];
for (long long int i = 0; i < n - 1; i++) diff[i] = ip[i + 1] - ip[i];
long long int q;
cin >> q;
if (n == 1) {
for (long long int i = 0; i < q; i++) cout << '1' << endl;
return 0;
}
cst(0, n - 2, 0);
while (q--) {
long long int l, h, d;
cin >> l >> h >> d;
if (l != 1) update(0, n - 2, 0, l - 2, d);
if (h != n) update(0, n - 2, 0, h - 1, -d);
cout << jt[0].mv + 1 << endl;
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
const int INF = 1e9;
int atk[N];
int c[N];
int g[2 * N];
int f[2 * N][2 * N];
int s[N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> atk[i];
}
for (int i = 1; i <= n; i++) {
cin >> c[i];
}
for (int i = 1; i <= n + m; i++) {
cin >> g[i];
}
reverse(atk + 1, atk + n + 1);
reverse(c + 1, c + n + 1);
for (int i = 1; i <= n + m; i++) {
for (int j = 1; j <= n + m; j++) f[i][j] = -INF;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
int cnt = 1;
for (int j = n; j >= 1; j--) {
if (f[atk[i]][j - 1] == -INF) continue;
f[atk[i]][j] = max(f[atk[i]][j], f[atk[i]][j - 1] + g[atk[i]] - c[i]);
}
for (int j = atk[i], k = n + m; j < n + m; j++, k >>= 1) {
for (int s = 0; s <= k; s++) {
f[j + 1][s >> 1] = max(f[j + 1][s >> 1], f[j][s] + (s >> 1) * g[j + 1]);
}
}
}
cout << f[n + m][0] << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
int f = 1;
long long res = 0;
char ch;
do {
ch = getchar();
if (ch == '-') f = -f;
} while (ch < '0' || ch > '9');
do {
res = res * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return f == 1 ? res : -res;
}
void fast_io() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int N = 100010;
const int mod = 1000000007;
const long long INF = 1e18;
int n, m, q;
int A[N], B[N];
char str[N];
long long dp[2][310];
int head[N], to[N * 2], nxt[N * 2], tot;
void addEdge(int u, int v) {
tot++;
nxt[tot] = head[u];
to[tot] = v;
head[u] = tot;
}
template <class T>
T mmax(T a, T b) {
return a < b ? b : a;
}
template <class T>
T mmin(T a, T b) {
return a < b ? a : b;
}
int countOne(int set) {
int res = 0;
while (set) {
res++;
set &= set - 1;
}
return res;
}
bool contain(long long set, int i) { return (set & (1LL << i)) > 0; }
long long myPow(long long a, int p) {
if (p == 0) return 1;
long long res = myPow(a, p / 2);
res *= res;
res %= mod;
if (p % 2 == 1) {
res *= a;
res %= mod;
}
return res;
}
void addMode(int &a, long long b) { a = (a + b) % mod; }
long long mul(long long a, long long b) { return a * b % mod; }
template <class T>
void mySwap(T &a, T &b) {
T tmp = a;
a = b;
b = tmp;
}
int father[N][20], level[N];
int pre[N], post[N], id;
int h[N], ord[N];
void dfs(int u, int fa) {
pre[u] = ++id;
father[u][0] = fa;
level[u] = level[fa] + 1;
for (int i = 1; i < 20; i++)
if (father[u][i - 1]) father[u][i] = father[father[u][i - 1]][i - 1];
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v != fa) {
dfs(v, u);
}
}
post[u] = ++id;
}
int lca(int u, int v) {
if (level[u] < level[v]) mySwap(u, v);
for (int i = 19; i >= 0; i--)
if (father[u][i] && level[father[u][i]] >= level[v]) u = father[u][i];
if (u == v) return u;
for (int i = 19; i >= 0; i--)
if (father[u][i] && father[v][i] && father[u][i] != father[v][i]) {
u = father[u][i];
v = father[v][i];
}
return father[u][0];
}
struct BIT {
int a[N * 2], sz;
void init(int n) {
sz = n;
memset(a, 0, sizeof(a));
}
void add(int i, int v) {
for (; i <= sz; i += i & -i) a[i] += v;
}
int getsum(int i) {
int res = 0;
for (; i; i -= i & -i) res += a[i];
return res;
}
} bit;
bool cmp(int a, int b) { return h[a] < h[b]; }
int main() {
fast_io();
cin >> n >> m;
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
addEdge(u, v);
addEdge(v, u);
}
memset(father, 0, sizeof(father));
memset(level, 0, sizeof(level));
id = 0;
dfs(1, 0);
bit.init(n * 2);
for (int i = 0; i < m; i++) {
int k, b, r;
cin >> k >> b >> r;
set<int> nodes;
for (int j = 0; j < k; j++) {
cin >> A[j];
nodes.insert(A[j]);
}
for (int j = 0; j < k; j++) {
bit.add(pre[A[j]], 1);
bit.add(post[A[j]], -1);
}
for (int j = 0; j < k; j++) {
int cf = lca(A[j], r);
h[j] = bit.getsum(pre[A[j]]) + bit.getsum(pre[r]) -
2 * bit.getsum(pre[cf]) + nodes.count(cf) - 1;
ord[j] = j;
}
sort(ord, ord + k, cmp);
for (int j = 0; j <= b; j++) dp[0][j] = 0;
dp[0][1] = 1;
int cur = 0;
for (int j = 1; j < k; j++) {
int ncur = 1 - cur;
for (int d = 0; d <= b; d++) dp[ncur][d] = 0;
int nh = h[ord[j]];
for (int d = nh + 1; d <= b; d++) {
dp[ncur][d] = dp[cur][d] * (d - nh) + dp[cur][d - 1];
dp[ncur][d] %= mod;
}
cur = ncur;
}
int res = 0;
for (int j = 1; j <= b; j++) addMode(res, dp[cur][j]);
cout << res << '\n';
for (int j = 0; j < k; j++) {
bit.add(pre[A[j]], -1);
bit.add(post[A[j]], 1);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int CMXS = 30, MAXS = 200000 * (30 + 3) + 3;
int q, a[2][MAXS], w[MAXS], nxt = 0;
inline void add(bitset<CMXS> b) {
for (int i = CMXS - 1, v = 0; (~i ? true : (w[v]++, false));
(~a[b[i]][v] ? v = a[b[i]][v] : v = a[b[i]][v] = ++nxt), i--)
w[v]++;
}
inline void sub(bitset<CMXS> b) {
for (int i = CMXS - 1, v = 0; (~i ? true : (w[v]--, false));
v = a[b[i]][v], i--)
w[v]--;
}
inline void go(bitset<CMXS> b) {
bitset<CMXS> f;
for (int i = CMXS - 1, v = 0; ~i; i--)
if (~a[1 - b[i]][v] && w[a[1 - b[i]][v]] > 0) {
v = a[1 - b[i]][v];
f[i] = 1;
} else
v = a[b[i]][v];
cout << f.to_ulong() << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
cin >> q;
memset(a, -1, sizeof a);
add(0);
while (q--) {
char c;
int x;
cin >> c >> x;
if (c == '+') add(x);
if (c == '-') sub(x);
if (c == '?') go(x);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> su[1005];
int D[101][1005];
int n, len;
int main() {
scanf("%d %d", &n, &len);
for (int i = 0; i < n; i++) {
scanf("%d %d", &su[i].first, &su[i].second);
su[i].first = len - su[i].first;
}
std::sort(su, su + n);
std::reverse(su, su + n);
memset(D[len], -1, sizeof(D[0]));
D[len][0] = 0;
for (int level = len - 1; level >= 0; level--) {
long long temp = 10000000;
if (level <= 12) temp = 1 << level;
D[level][0] = 0;
for (int j = 1; j <= n; j++) {
if (j * 2 - 1 > n)
D[level][j] = -1;
else
D[level][j] = max(D[level + 1][j * 2], D[level + 1][j * 2 - 1]);
}
for (int i = 0; i < n; i++) {
if (su[i].first == level) {
for (int j = n; j >= 0; j--) {
if (D[level][j] != -1 && D[level][j + 1] < D[level][j] + su[i].second)
D[level][j + 1] = D[level][j] + su[i].second;
}
}
}
for (int j = temp + 1; j <= n; j++) {
D[level][j] = -1;
}
}
printf("%d\n", D[0][1]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, wa = 1e9, v, to;
cin >> n >> m;
vector<vector<int> > g(n);
vector<vector<bool> > u(4000, vector<bool>(4000));
vector<int> p(n);
for (int i = 0; i < m; i++) {
cin >> v >> to;
v--;
to--;
g[v].push_back(to);
g[to].push_back(v);
u[v][to] = u[to][v] = 1;
p[v]++;
p[to]++;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < g[i].size(); j++) {
for (int w = j + 1; w < g[i].size(); w++) {
int x = g[i][j];
int y = g[i][w];
if (u[x][y]) wa = min(wa, p[i] + p[x] + p[y] - 6);
}
}
}
if (wa != 1e9) {
cout << wa;
} else {
cout << -1;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
if (a <= b) {
cout << b << endl;
} else {
if (c <= d) {
cout << -1 << endl;
} else {
long long ans = b + ceil(1.0 * (a - b) / (c - d)) * c;
cout << ans << endl;
}
}
}
signed main() {
long long t;
cin >> t;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
double const eps = 1e-8;
const int nMax = 1e3 + 10;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int a[nMax][nMax];
int ans[nMax][nMax];
char ss[nMax];
int n, m;
int dfs(int x, int y, int countnum) {
if (ans[x][y] != -1) {
return ans[x][y];
}
ans[x][y] = 99999999;
countnum = (countnum + 1) % 4;
int temp = 0;
for (int i = 0; i < 4; i++) {
int c = x + dx[i];
int d = y + dy[i];
if (c >= 1 && c <= n && d >= 1 && d <= m && a[c][d] == countnum) {
temp = (temp > dfs(c, d, countnum) ? temp : dfs(c, d, countnum));
}
}
return ans[x][y] = (temp + 1 < 99999999 ? temp + 1 : 99999999);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", ss);
for (int j = 0; j < m; j++) {
if (ss[j] == 'D')
a[i][j + 1] = 0;
else if (ss[j] == 'I')
a[i][j + 1] = 1;
else if (ss[j] == 'M')
a[i][j + 1] = 2;
else
a[i][j + 1] = 3;
}
}
memset(ans, -1, sizeof(ans));
int ret = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 0 && ans[i][j] == -1) {
ret = (dfs(i, j, 0) > ret ? dfs(i, j, 0) : ret);
}
}
}
if (ret == 99999999)
puts("Poor Inna!");
else if (ret < 4)
puts("Poor Dima!");
else
cout << ret / 4 << endl;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 5e5 + 10;
const int N = 1e5 + 10;
const ll mod = 1e9 + 7;
struct Info {
int l, r, v;
bool operator<(const Info &cur) const {
return r < cur.r;
}
} b[maxn];
int n, a[maxn], num, w[maxn], x[maxn], tr[maxn], f[maxn], res;
unordered_map<int, int> MAP;
int lowbit(int x) {
return x & (-x);
}
void modify(int cur, int val) {
while (cur <= n) {
tr[cur] = max(tr[cur], val);
cur += lowbit(cur);
}
}
int query(int cur) {
int ans = 0;
while (cur) {
ans = max(ans, tr[cur]);
cur -= lowbit(cur);
}
return ans;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("1.txt", "r", stdin);
#endif
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (MAP.find(a[i]) == MAP.end()) {
MAP[a[i]] = ++num;
b[num].l = i;
}
b[MAP[a[i]]].r = i;
++b[MAP[a[i]]].v;
}
sort(b + 1, b + num + 1);
for (int i = 1; i <= num; ++i) {
f[i] = query(b[i].l - 1) + b[i].v;
modify(b[i].r, f[i]);
}
int s = query(n), t = query(1);
// printf("%d %d\n", s, t);
for (int i = n; i >= 1; --i) {
++w[MAP[a[i]]];
x[i] = max(x[i + 1], w[MAP[a[i]]]);
}
res = n;
for (int i = 1; i <= num; ++i) {
res = min(res, n - x[b[i].r + 1] - f[i]);
}
printf("%d\n", res);
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int nm = 0, fh = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') fh = -1;
for (; isdigit(c); c = getchar()) nm = nm * 10 + c - '0';
return nm * fh;
}
int n, sum;
int main() {
n = read();
for (int i = 1; i <= n; i++) sum += read();
if (sum % n)
printf("%d\n", n - 1);
else
printf("%d\n", n);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, a[100010], j;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) {
while (a[i] % 2 == 0) a[i] /= 2;
while (a[i] % 3 == 0) a[i] /= 3;
}
for (j = 1; j < n; j++)
if (a[j] != a[0]) {
printf("No\n");
break;
}
if (j == n) printf("Yes\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
long long n, b[2 * MAXN], a[2 * MAXN], m;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
long long s = 0;
for (int i = 0; i < n; ++i) {
cin >> b[i];
s += b[i];
}
for (int i = 0; i < n; ++i) b[i + n] = b[i];
bool x = 0;
for (int i = 0; i < n; ++i) {
if (b[i] != 0) x = 1;
}
if (x == 0) {
cout << "YES\n";
for (int i = 0; i < n; ++i) cout << 1 << ' ';
cout << endl;
return 0;
}
int ind = -1;
for (int i = 1; i <= n; ++i) {
if (b[i - 1] < b[i]) ind = i;
}
if (ind == -1) {
cout << "NO\n";
return 0;
}
a[ind % n] = b[ind];
m = s + b[ind] * (1LL << 40);
for (int i = ind + 1; i < ind + n; ++i) {
a[i % n] = m;
m -= b[i];
}
cout << "YES\n";
for (int i = 0; i < n; ++i) cout << a[i] << ' ';
cout << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
int b[100005];
map<int, int> m;
int cur = 1;
int st[400005];
int left(int p) { return (p << 1); }
int right(int p) { return (p << 1) + 1; }
void add(int p, int l, int r, int in, int x) {
if (r < in || l > in) return;
if (l == r) {
if (l == in) st[p] = min(st[p], x);
return;
} else {
add(left(p), l, (l + r) / 2, in, x);
add(right(p), ((l + r) / 2) + 1, r, in, x);
st[p] = min(st[left(p)], st[right(p)]);
}
}
int rmq(int p, int l, int r, int i, int j) {
if (l >= i && r <= j) return st[p];
if (r < i || l > j) return 1000000007;
return min(rmq(left(p), l, (l + r) / 2, i, j),
rmq(right(p), ((l + r) / 2) + 1, r, i, j));
}
vector<int> ans;
int main() {
for (int i = 0; i < 400005; i++) st[i] = 1000000007;
scanf("%d", &n);
for (int i = n; i >= 1; i--) {
scanf("%d", &a[i]);
b[i] = a[i];
}
sort(b, b + (n + 1));
m[b[1]] = cur;
for (int i = 2; i <= n; i++)
if (b[i] != b[i - 1]) {
cur++;
m[b[i]] = cur;
}
ans.push_back(-1);
add(1, 1, cur, m[a[1]], 1);
for (int i = 2; i <= n; i++) {
int z = m[a[i]];
if (m[a[i]] == 1) {
ans.push_back(-1);
add(1, 1, cur, z, i);
continue;
}
int x = rmq(1, 1, cur, 1, z - 1);
if (x == 1000000007)
ans.push_back(-1);
else
ans.push_back((i - x) - 1);
add(1, 1, cur, z, i);
}
printf("%d", ans[ans.size() - 1]);
for (int i = ans.size() - 2; i >= 0; i--) printf(" %d", ans[i]);
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
inline int nxt() {
int wow;
scanf("%d", &wow);
return wow;
}
inline long long int lxt() {
long long int wow;
scanf("%lld", &wow);
return wow;
}
inline double dxt() {
double wow;
scanf("%lf", &wow);
return wow;
}
struct child {
long long int v, d, p;
int id, done, scared;
child() { scared = 0; }
};
vector<child> c;
int main() {
int n = nxt(), ans = 0;
child dummy;
c.push_back(dummy);
for (int i = 1; i <= n; i++) {
child temp;
scanf("%I64d %I64d %I64d", &temp.v, &temp.d, &temp.p);
temp.id = i;
c.push_back(temp);
}
for (int i = 1; i <= n; i++) {
if (c[i].scared) continue;
ans++;
long long int val = c[i].v;
for (int j = i + 1; j <= n; j++) {
if (c[j].scared) continue;
c[j].p -= val;
val = max(0LL, val - 1);
}
for (int j = i + 1; j <= n; j++) {
if (c[j].scared == 0 && c[j].p < 0) {
c[j].scared = 1;
for (int k = j + 1; k <= n; k++) c[k].p -= c[j].d;
}
}
}
printf("%d\n", ans);
for (int i = 1; i <= n; i++)
if (c[i].scared == 0) printf("%d ", i);
puts("");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[1000005], flag[1000005];
int n, k;
int main() {
cin >> n >> k;
a[1] = 1;
int l = 2, r = n;
while (l <= r) {
int mid = (l + r) >> 1;
a[2] = mid;
int x = 2, y = mid - 1;
int m = 2;
for (; x < y; ++x, --y) a[++m] = x, a[++m] = y;
if (x == y) a[++m] = x;
for (int i = mid + 1; i <= n; ++i) a[++m] = i;
for (int i = 1; i <= n; ++i) flag[i] = 0;
int tot = 0;
for (int i = 1; i < n; ++i)
if (!flag[abs(a[i] - a[i + 1])]) flag[abs(a[i] - a[i + 1])] = 1, ++tot;
if (k == tot) {
l = mid;
break;
}
if (k < tot)
r = mid - 1;
else
l = mid + 1;
}
for (int i = 1; i < n; ++i) printf("%d ", a[i]);
printf("%d\n", a[n]);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
int n, m, num[2003][2003], hi[2003], rj[2003];
long long x[2003], y[2003], p[2003], sh[2003], f[2003][2003][2],
sum[2003][2003], mx[2003][2003], mi[2003][2003];
int tot, fir[2003], nxt[100005 << 1], to[100005 << 1], val[100005 << 1];
inline void addE(int u, int v, int w) {
nxt[++tot] = fir[u], fir[u] = tot, to[tot] = v, val[tot] = w;
}
void work(long long *now, int &lim) {
for (int i = 1; i <= n; ++i) sh[++lim] = now[i];
sort(sh + 1, sh + lim + 1);
lim = unique(sh + 1, sh + lim + 1) - (sh + 1);
for (int i = 1; i <= n; ++i)
now[i] = lower_bound(sh + 1, sh + lim + 1, now[i]) - sh;
}
void Dijkstra(int s, long long *dis) {
for (int i = 1; i <= n; ++i) dis[i] = INF;
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
q.push(make_pair(dis[s] = 0, s));
while (!q.empty()) {
int u = q.top().second;
q.pop();
for (int i = fir[u], v; i; i = nxt[i]) {
v = to[i];
if (dis[v] <= dis[u] + val[i]) continue;
q.push(make_pair(dis[v] = dis[u] + val[i], v));
}
}
}
inline int getsz(int a, int aa, int b, int bb) {
return num[aa][bb] - num[a][bb] - num[aa][b] + num[a][b];
}
int main() {
int a, b;
cin >> n >> m >> a >> b;
for (int i = 1; i <= n; ++i) scanf("%lld", p + i);
for (int i = 1, u, v, w; i <= m; ++i)
scanf("%d%d%d", &u, &v, &w), addE(u, v, w), addE(v, u, w);
int w = 0, h = 0;
Dijkstra(a, x), work(x, h);
Dijkstra(b, y), work(y, w);
for (int i = 1; i <= n; ++i) sum[x[i]][y[i]] += p[i], ++num[x[i]][y[i]];
for (int i = 1; i <= h + 1; ++i)
for (int j = 1; j <= w + 1; ++j) {
sum[i][j] += sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1];
num[i][j] += num[i - 1][j] + num[i][j - 1] - num[i - 1][j - 1];
}
memset(hi, -1, sizeof hi);
memset(rj, -1, sizeof rj);
for (int i = h; i >= 0; --i)
for (int j = w; j >= 0; --j) {
if (getsz(i, i + 1, j, w)) hi[j] = i + 1;
if (getsz(i, h, j, j + 1)) rj[i] = j + 1;
if (~hi[j]) f[i][j][0] = mx[hi[j]][j] - (sum[i][w] - sum[i][j]);
if (~rj[i]) f[i][j][1] = mi[i][rj[i]];
mx[i][j] = max(hi[j] == -1 ? -INF : mx[hi[j]][j],
f[i][j][1] + (sum[i][w] - sum[i][j]));
mi[i][j] = min(rj[i] == -1 ? INF : mi[i][rj[i]], f[i][j][0]);
}
long long ra = f[0][0][0], rb = sum[h][w] - ra;
if (ra < rb) puts("Cry");
if (ra == rb) puts("Flowers");
if (ra > rb) puts("Break a heart");
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
const int maxn = 1e5 + 50;
int n, a[maxn], K, cnt[maxn], l, r;
long long f[maxn], g[maxn], ret;
void Move(int tl, int tr) {
while (l > tl) ret += cnt[a[--l]]++;
while (l < tl) ret -= --cnt[a[l++]];
while (r < tr) ret += cnt[a[++r]]++;
while (r > tr) ret -= --cnt[a[r--]];
}
void Solve(int l, int r, int bestl, int bestr, long long* x, long long* y) {
if (l > r) return;
int mid = l + r >> 1, s, checkr = min(bestr, mid);
y[mid] = 1ll << 60;
Move(bestl, mid);
for (int i = bestl; i <= checkr; ++i) {
Move(i + 1, mid);
long long c = x[i] + ret;
if (y[mid] > c) y[mid] = c, s = i;
}
Solve(l, mid - 1, bestl, s, x, y);
Solve(mid + 1, r, s, bestr, x, y);
}
int main(int argc, char* argv[]) {
scanf("%d%d", &n, &K);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
f[i] = f[i - 1] + cnt[a[i]]++;
}
memset(cnt, 0, sizeof(cnt));
auto x = f, y = g;
for (int i = 2; i <= K; ++i, swap(x, y)) {
memset(cnt, 0, sizeof(cnt));
ret = 0, l = 1, r = 0;
Solve(1, n, 1, n, x, y);
}
printf("%lld\n", x[n]);
return 0;
}
| 8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.