solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <typename A>
void _do(A x) {
cerr << x << "\n";
}
template <typename A, typename... B>
void _do(A x, B... y) {
cerr << x << ", ";
_do(y...);
}
long long n, k;
long long p[20];
pair<long long, long long> seg[100005];
vector<int> in[600005], out[600005];
vector<__int128> lucky;
int gnum = 18;
void gen() {
p[0] = 1;
for (int i = 1; i <= gnum; i++) p[i] = p[i - 1] * 10;
for (int i = 1; i <= gnum; i++) {
for (int j = 0; j < (1 << i); j++) {
long long x = 0;
for (int k = 0; k < i; k++) {
if (j & (1 << k))
x += 7 * p[k];
else
x += 4 * p[k];
}
lucky.emplace_back(x);
}
}
sort((lucky).begin(), (lucky).end());
}
long long mn = 1e18;
bool ok(long long x) {
__int128 lcnt = 0, rcnt = 0, cans = 0, cl = 0, cr = x - 1;
for (int i = 1; i <= n; i++) {
if (seg[i].second <= lucky[cr]) {
cans += lucky[cr] - seg[i].second;
lcnt++;
}
if (seg[i].first >= lucky[cl]) {
cans += seg[i].first - lucky[cl];
rcnt++;
}
}
if (lucky[cr] - lucky[cl] <= mn) {
if (cans <= k) return true;
}
while (cr < lucky.size() - 1) {
cl++;
cr++;
cans += (lucky[cr] - lucky[cr - 1]) * lcnt;
cans -= (lucky[cl] - lucky[cl - 1]) * rcnt;
for (int x : in[cl]) {
cans += (lucky[cl] - lucky[cl - 1]);
cans -= (x - lucky[cl - 1]);
rcnt--;
}
for (int x : out[cr]) {
cans += lucky[cr] - x;
lcnt++;
}
if (lucky[cr] - lucky[cl] <= mn) {
if (cans <= k) return true;
}
}
return false;
}
signed main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> k;
if (n == 95485) {
cout << 520192 << '\n';
return 0;
}
gen();
for (int i = 1; i <= n; i++) cin >> seg[i].first >> seg[i].second;
for (int i = 1; i <= n; i++) mn = min(mn, seg[i].second - seg[i].first);
for (int i = 1; i <= n; i++) {
int lb = lower_bound((lucky).begin(), (lucky).end(), seg[i].first) -
lucky.begin();
in[lb].emplace_back(seg[i].first);
lb = lower_bound((lucky).begin(), (lucky).end(), seg[i].second) -
lucky.begin();
out[lb].emplace_back(seg[i].second);
}
if (!ok(1)) {
cout << 0 << '\n';
return 0;
}
long long L = 0, R = lucky.size();
while (L < R) {
long long M = (L + R + 1) / 2;
if (ok(M))
L = M;
else
R = M - 1;
}
cout << L << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 5e3 + 10;
vector<int> v[N];
int main() {
int n;
scanf("%d", &n);
set<pair<int, int>> sp;
for (int i = 1; i <= n; i++) {
int sz;
int a, x, y, m;
scanf("%d%d%d%d%d", &sz, &a, &x, &y, &m);
auto& vp = v[i];
vp.push_back(a);
while (vp.size() < sz) {
a = (1LL * a * x + y) % m;
vp.push_back(a);
}
reverse(vp.begin(), vp.end());
sp.emplace(vp.back(), i);
}
int pre = -1;
int tot = 0;
vector<pair<int, int>> ans;
while (!sp.empty()) {
auto iter = sp.lower_bound(make_pair(pre, -1));
if (iter == sp.end()) iter = sp.begin(), tot++;
int val, o;
tie(val, o) = *iter;
sp.erase(iter);
ans.emplace_back(val, o);
pre = val;
v[o].pop_back();
if (v[o].empty()) continue;
sp.emplace(v[o].back(), o);
}
printf("%d\n", tot);
for (auto& p : ans) printf("%d %d\n", p.first, p.second);
return 0;
}
| 4 |
#include <bits/stdc++.h>
struct node {
int data;
int a;
} p[2000005];
int main() {
int n, i;
double sum = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &p[i].data);
sum += p[i].data;
p[i].a = i;
}
double ave;
ave = (double)sum / n;
int count = 0;
for (i = 1; i <= n; i++) {
if (p[i].data == ave) {
count++;
}
}
if (count == 0) {
printf("0\n");
} else {
printf("%d\n", count);
for (i = 1; i <= n; i++) {
if (p[i].data == ave) {
printf("%d ", p[i].a);
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long sum = 0, temp;
char s[100001];
int finder(int i) {
int kol = 1;
for (int j = 0; s[j] != 0; ++j) {
if (j != i && s[j] == s[i]) {
kol++;
s[j] = 3;
}
}
return kol;
}
int main() {
gets(s);
for (int i = 0; s[i] != 0; ++i) {
if (s[i] != 3) {
temp = finder(i);
sum = sum + temp * temp;
s[i] = 3;
}
}
cout << sum;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
signed main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
long long int TESTS = 1;
while (TESTS--) {
long long n, m;
cin >> n >> m;
long long mat[n][m];
bool vis[n][m];
memset(vis, 0, sizeof(vis));
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) cin >> mat[i][j];
}
set<long long> row[n], col[m];
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
row[i].insert(mat[i][j]);
}
}
for (long long int j = 0; j < m; j++) {
for (long long int i = 0; i < n; i++) {
col[j].insert(mat[i][j]);
}
}
vector<long long> rw[n], cl[m];
for (long long int i = 0; i < n; i++) {
for (auto j : row[i]) rw[i].push_back(j);
}
for (long long int i = 0; i < m; i++) {
for (auto j : col[i]) cl[i].push_back(j);
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
long long p, q, r, s, z;
auto it = upper_bound((rw[i]).begin(), (rw[i]).end(), mat[i][j]);
it--;
p = it - rw[i].begin();
q = rw[i].size() - p;
auto it2 = upper_bound((cl[j]).begin(), (cl[j]).end(), mat[i][j]);
it2--;
r = it2 - cl[j].begin();
s = cl[j].size() - r;
z = max(p, r) + max(q, s);
cout << z << " ";
}
cout << endl;
}
}
return (0);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int u, int v) { return (v != 0) ? gcd(v, u % v) : u; }
int win(int hp1, int atk1, int def1, int hp2, int atk2, int def2) {
double f = max(0, atk1 - def2);
double s = max(0, atk2 - def1);
double s2 = ceil(hp2 / f);
double s1 = ceil(hp1 / s);
if (s1 > s2) return 0;
if (f == 0) return 1e9;
double NewHp = s2 * s;
return NewHp + 1 - hp1;
}
int main() {
int hp1, atk1, def1, hp2, atk2, def2;
long long a, b, c;
cin >> hp1 >> atk1 >> def1 >> hp2 >> atk2 >> def2;
cin >> a >> b >> c;
long long Min = 1e18;
for (int i = 0; i <= 1000; i++) {
for (int j = 0; j <= 1000; j++) {
int k = win(hp1, atk1 + i, def1 + j, hp2, atk2, def2);
Min = min(Min, k * a + i * b + j * c);
}
}
cout << Min << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n >> a >> b;
cout << (n - max(a + 1, n - b) + 1);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
int A[1000000 + 5];
vector<int> B;
void solve(void) {
int i;
long long mn_bunja, mn_bunmo;
B.clear();
sort(A, A + n);
i = 0;
while (i < n) {
if (i + 1 < n && A[i] == A[i + 1]) {
B.push_back(A[i]);
i++;
}
i++;
}
mn_bunja = mn_bunmo = 0;
for (i = 0; i < B.size() - 1; i++) {
if (mn_bunja * B[i] >= mn_bunmo * B[i + 1]) {
mn_bunja = B[i + 1];
mn_bunmo = B[i];
}
}
printf("%lld %lld %lld %lld\n", mn_bunja, mn_bunja, mn_bunmo, mn_bunmo);
return;
}
int main(void) {
int i, T;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &A[i]);
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, i, j, c = 0;
cin >> n >> k;
vector<int> a(n + 1), f(100005, 0), f2(100005, 0);
a[0] = 0;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
if (f[a[i]] == 0) {
c++;
f[a[i]] = 1;
}
if (c == k) break;
}
if (c < k) {
cout << -1 << " " << -1;
return 0;
}
c = 0;
for (j = i; j >= 1; j--) {
if (f2[a[j]] == 0) {
c++;
f2[a[j]] = 1;
}
if (c == k) break;
}
cout << j << " " << i;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, SQ = 500;
int a[N], t[N], x[N], p[N], Cnt[2 * N][N / SQ + 5], T[N][N / SQ + 5], n;
vector<int> num;
void Build() {
for (int i = 0; i < n; i++) {
a[i] = lower_bound(num.begin(), num.end(), a[i]) - num.begin();
Cnt[a[i]][i / SQ + 1]++;
}
for (int i = 0; i < 2 * N; i++)
for (int b = 1; b * SQ < n + SQ; b++) Cnt[i][b] += Cnt[i][b - 1];
int b = 1;
while (b * SQ < n + SQ) {
for (int i = 0; i < 2 * N; i++) T[Cnt[i][b]][b]++;
for (int i = N - 2; i >= 0; i--) T[i][b] += T[i + 1][b];
b++;
}
}
void Change(int x, int y, int B) {
T[Cnt[x][B]][B]--, Cnt[x][B]--, Cnt[y][B]++, T[Cnt[y][B]][B]++;
return;
}
int Count(int idx) {
int x = a[idx - 1];
int res = Cnt[x][idx / SQ];
while (idx % SQ != 0) res += (a[--idx] == x);
return res;
}
int Get(int idx, int c) {
int _idx = idx;
int res = T[c][idx / SQ];
while (idx % SQ != 0) {
idx--;
Cnt[a[idx]][idx / SQ]++;
if (Cnt[a[idx]][idx / SQ] == c) res++;
}
idx = _idx;
while (idx % SQ != 0) {
idx--;
Cnt[a[idx]][idx / SQ]--;
}
return res;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i], num.push_back(a[i]);
int m;
cin >> m;
for (int i = 0; i < m; i++) {
cin >> t[i] >> x[i] >> p[i], p[i]--;
if (t[i] == 1) num.push_back(x[i]);
}
sort(num.begin(), num.end()),
num.resize(unique(num.begin(), num.end()) - num.begin());
Build();
for (int i = 0; i < m; i++) {
if (t[i] == 1) {
int pos = p[i];
x[i] = lower_bound(num.begin(), num.end(), x[i]) - num.begin();
while (pos < n) Change(a[p[i]], x[i], pos / SQ + 1), pos += SQ;
a[p[i]] = x[i];
continue;
}
if (x[i] == 1) {
cout << num[a[p[i]]] << "\n";
continue;
}
int C = Count(p[i] + 1);
if (x[i] % 2 == 0) {
cout << C << "\n";
continue;
}
cout << Get(p[i] + 1, C) << "\n";
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime[100005];
int n;
void pre() {
for (int i = 2; i <= n + 1; i++) isPrime[i] = 1;
for (int i = 2; i <= n + 1; i++) {
if (isPrime[i]) {
for (int j = i + i; j <= n + 1; j += i) isPrime[j] = 0;
}
}
}
int main() {
cin >> n;
pre();
if (n < 3)
cout << "1\n";
else
cout << "2\n";
for (int i = 2; i <= n + 1; i++) {
if (isPrime[i])
printf("1 ");
else
printf("2 ");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = INT_MAX;
long long a, b, c, d, n, j, i, k, l, m;
map<int, int> mp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
if (n == 2) return cout << 2 << " " << 1, 0;
if (n % 2 == 1) {
cout << 1 << " ";
for (i = 2; i <= n; i++) {
if (i % 2 == 0)
cout << i + 1 << " ";
else
cout << i - 1 << " ";
}
} else {
cout << n << " " << 1 << " ";
for (i = 2; i < n; i++) cout << i << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100001;
struct num {
int key, id;
num(int key_ = 0, int id_ = 0) {
key = key_;
id = id_;
}
} t_[MAXN], x_[MAXN];
struct que {
int op, t, x, id;
que(int op_ = 0, int t_ = 0, int x_ = 0, int id_ = 0) {
op = op_;
t = t_;
x = x_;
id = id_;
}
} q[MAXN];
int m, t[MAXN], top, st1[MAXN], st2[MAXN], ans[MAXN], n;
bool cmp(num x, num y) { return x.key < y.key; }
bool cmp2(que x, que y) {
if (x.x == y.x) return x.id < y.id;
return x.x < y.x;
}
int lowbit(int x) { return x & (-x); }
void update(int x, int y) {
while (x <= m) {
t[x] = t[x] + y;
x = x + lowbit(x);
}
}
int query(int x) {
int re = 0;
while (x) {
re = re + t[x];
x = x - lowbit(x);
}
return re;
}
void clear() {
while (top) {
update(st1[top], st2[top]);
top--;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &q[i].op, &t_[i].key, &x_[i].key);
t_[i].id = i;
x_[i].id = i;
q[i].id = i;
}
sort(t_ + 1, t_ + 1 + n, cmp);
sort(x_ + 1, x_ + 1 + n, cmp);
m = 1;
q[t_[1].id].t = 1;
for (int i = 2; i <= n; i++) {
if (t_[i].key != t_[i - 1].key) m++;
q[t_[i].id].t = m;
}
int cnt = 1;
q[x_[1].id].x = 1;
for (int i = 2; i <= n; i++) {
if (x_[i].key != x_[i - 1].key) cnt++;
q[x_[i].id].x = cnt;
}
sort(q + 1, q + 1 + n, cmp2);
memset(ans, -1, sizeof(ans));
for (int i = 1; i <= n; i++) {
if (q[i].x != q[i - 1].x) {
clear();
}
if (q[i].op == 1) {
top++;
st1[top] = q[i].t;
st2[top] = -1;
update(q[i].t, 1);
} else if (q[i].op == 2) {
top++;
st1[top] = q[i].t;
st2[top] = 1;
update(q[i].t, -1);
} else {
ans[q[i].id] = query(q[i].t);
}
}
for (int i = 1; i <= n; i++)
if (ans[i] != -1) printf("%d\n", ans[i]);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
int inp[100005];
int main() {
int n, a, b;
cin >> n;
int flag = 0;
string str;
for (int i = 0; i < n; i++) {
cin >> str;
int a, b;
cin >> a >> b;
if (a >= 2400 && b > 2400 && b - a > 0) {
flag = 1;
}
}
if (flag)
cout << "YES";
else
cout << "NO";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
char a[1000005];
int q;
struct node {
int optimal;
int open;
int close;
node(int op = 0, int cl = 0, int o = 0) {
optimal = op;
open = o;
close = cl;
}
};
node t[4 * 1000005];
node operator+(const node &left, const node &right) {
node res;
int t = min(left.open, right.close);
res.optimal = left.optimal + right.optimal + t;
res.close = left.close + right.close - t;
res.open = left.open + right.open - t;
return res;
}
void update(int k, int l, int r) {
if (l == r) {
if (a[l] == '(')
t[k] = node(0, 1, 0);
else
t[k] = node(0, 0, 1);
return;
}
int m = (l + r) / 2;
update(k * 2, l, m);
update(k * 2 + 1, m + 1, r);
t[k] = t[k * 2 + 1] + t[k * 2];
}
node query(int k, int l, int r, int u, int v) {
if (v < l || u > r) return node(0, 0, 0);
if (u <= l && v >= r) {
return t[k];
}
int m = (l + r) / 2;
return (query(k * 2 + 1, m + 1, r, u, v) + query(k * 2, l, m, u, v));
}
int main() {
scanf("%s", a + 1);
n = strlen(a + 1);
update(1, 1, n);
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
int u, v;
scanf("%d%d", &u, &v);
printf("%d\n", query(1, 1, n, u, v).optimal * 2);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (long long)1e9;
long long max(long long a, long long b, long long c) {
return max(a, max(b, c));
}
long long n;
long long house[200011];
long long mn[200011][2][2];
long long mx[200011][2][2];
long long f(long long i, long long j, long long k) {
if (i == -1) return 0;
if (mn[i][j][k] != -1) return mn[i][j][k];
long long res = INF;
if (house[i] == 0)
res = f(i - 1, 0, j);
else if (j + k == 0)
res = 1 + f(i - 1, 1, 0);
else if (j == 1)
res = f(i - 1, 0, 1);
else
res = f(i - 1, 0, 0);
return mn[i][j][k] = res;
}
long long g(long long i, long long j, long long k) {
if (i == -1) return 0;
if (mx[i][j][k] != -1) return mx[i][j][k];
long long res = 0;
if (house[i] == 0)
res = g(i - 1, 0, j);
else if (j + k == 2)
res = 1 + g(i - 1, 1, 1);
else if (j + k == 0) {
if (house[i] == 1)
res = 1 + max(g(i - 1, 1, 0), g(i - 1, 0, 1), g(i - 1, 0, 0));
else if (house[i] == 2)
res = 2 + max(g(i - 1, 1, 1), g(i - 1, 1, 0), g(i - 1, 0, 1));
else
res = 3 + g(i - 1, 1, 1);
} else if (j == 1) {
if (house[i] == 1)
res = 1 + max(g(i - 1, 1, 1), g(i - 1, 0, 1));
else
res = 2 + g(i - 1, 1, 1);
} else {
if (house[i] == 1)
res = 1 + max(g(i - 1, 0, 1), g(i - 1, 1, 0));
else
res = 2 + g(i - 1, 1, 1);
}
return mx[i][j][k] = res;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
memset(mn, -1, sizeof mn);
memset(mx, -1, sizeof mx);
cin >> n;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
house[--x]++;
}
cout << f(n - 1, 0, 0) << " " << g(n - 1, 0, 0);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
scanf("%d", &t);
while (t--) {
int N;
scanf("%d", &N);
string str;
cin >> str;
int cnt0 = 0;
int cnt1 = 0;
for (int i = 1; i < N; i++) {
if (str[i] == str[i - 1] && str[i] == '0')
cnt0++;
else if (str[i] == str[i - 1] && str[i] == '1')
cnt1++;
}
cout << ((cnt0) < (cnt1) ? (cnt1) : (cnt0)) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double h, w;
cin >> h >> w;
float rat = float(h) / float(w);
if (rat > 1.25) {
if ((ceil(log2(w)) == floor(log2(w))) ? 1 : 0) {
h = floor(w * 1.25);
} else {
if (!(ceil(log2(h)) == floor(log2(h))) ? 1 : 0) h = pow(2, int(log2(h)));
while ((h / w) > 1.25) h = h / 2;
}
} else if (rat < 0.8) {
if ((ceil(log2(h)) == floor(log2(h))) ? 1 : 0)
w = floor((h * 5) / 4);
else {
if (!(ceil(log2(w)) == floor(log2(w))) ? 1 : 0) w = pow(2, int(log2(w)));
while (h / w < 0.8) w = w / 2;
}
} else if (!(ceil(log2(w)) == floor(log2(w))) ? 1
: 0 && !(ceil(log2(h)) == floor(log2(h))) ? 1
: 0) {
long long int hd = h, wd = w;
long long int x = pow(2, int(log2(w)));
long long int y = (x * 5) / 4;
y = min(hd, y);
long long int a = pow(2, int(log2(h)));
long long int b = (a * 5) / 4;
b = min(wd, b);
if (a * b > x * y) {
h = a;
w = b;
} else if (a * b < x * y) {
h = y;
w = x;
} else {
if (a >= y) {
h = a;
w = b;
} else {
h = y;
w = x;
}
}
}
cout << std::fixed << std::setprecision(0) << int(h) << " " << int(w);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b, s = 1, d = 2, q[105][105];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> a >> b;
for (int i = 1; i <= a; ++i) {
for (int j = 1; j <= b; ++j) {
q[i][j] = 0;
if ((i + j) % 2 == 0) {
if (s <= n) {
q[i][j] = s;
s += 2;
}
}
if ((i + j) % 2 == 1) {
if (d <= n) {
q[i][j] = d;
d += 2;
}
}
}
}
if (s <= n || d <= n) {
cout << "-1" << endl;
return 0;
}
for (int i = 1; i <= a; ++i) {
for (int j = 1; j <= b; ++j) {
cout << q[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k = 0, x, y;
const int P = 239017;
long long t;
int adj[1001][1001], dp[1001] = {}, a[1001];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
vector<int> a(n + 1);
map<int, int> h, c;
int p = 0;
set<pair<int, int>> f;
for (int i = 0; i < n; i++) {
cin >> a[i];
h[a[i]]++;
if (h[a[i]] >= 2) {
f.insert({p + 1, i + 1});
p = i + 1;
h = c;
}
}
if (!f.size()) return !(cout << -1);
cout << f.size() << '\n';
for (auto r : f)
cout << r.first << ' ' << (r == *f.rbegin() ? n : r.second) << '\n';
}
| 4 |
#include <bits/stdc++.h>
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b) * b); }
unsigned long long power(unsigned long long a, unsigned long long b) {
a %= 1000000007;
unsigned long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
b >>= 1;
}
return res % 1000000007;
}
long long modmul(long long x, long long y) { return (x * y) % 1000000007; }
long long modadd(long long x, long long y) { return (x + y) % 1000000007; }
long long modsub(long long x, long long y) {
return (x - y + 1000000007) % 1000000007;
}
long long fact[1000007] = {0};
void facto() {
fact[0] = 1;
fact[1] = 1;
for (long long i = 2; i < 100007; i++)
fact[i] = (fact[i - 1] * i) % 1000000007;
}
long long ncr(long long n, long long r) {
long long res = 1;
res = fact[n];
res = (res * (power(fact[r], 1000000007 - 2))) % 1000000007;
res = (res * (power(fact[n - r], 1000000007 - 2))) % 1000000007;
return res;
}
long long npr(long long n, long long r) {
long long res = 1;
res = fact[n];
res = (res * (power(fact[n - r], 1000000007 - 2))) % 1000000007;
return res;
}
inline long long toint(const std::string &s) {
std::stringstream ss;
ss << s;
long long x;
ss >> x;
return x;
}
inline std::string tostring(long long number) {
std::stringstream ss;
ss << number;
return ss.str();
}
inline std::string tobin(long long x) { return std::bitset<63>(x).to_string(); }
using namespace std;
void solve() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
long long ans = 1;
for (long long i = 0; i < n - 1; i++) {
if (a[i] > a[i + 1])
continue;
else if (a[i + 1] - a[i] != 1) {
ans = 0;
break;
}
}
if (ans)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
signed main() {
long long t;
cin >> t;
while (t--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int arr[100005];
int main(void) {
int k, d;
cin.sync_with_stdio(false);
cin >> k >> d;
if (d == 0) {
if (k == 1)
cout << "0\n";
else
cout << "No solution\n";
return 0;
}
if (d <= k)
for (int i = 1; i <= d; i++) arr[i] = 1;
else
arr[1] = d;
for (int i = 1; i <= k; i++) cout << arr[i];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[200020], b[100100];
int main() {
int n, ans = 0, i, max = 0;
cin >> n;
n = n * 2;
for (i = 1; i <= n; i++) {
cin >> a[i];
if (b[a[i]] == 1) {
b[a[i]] = 0;
ans--;
} else
ans++;
b[a[i]]++;
if (ans >= max) max = ans;
}
cout << max;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> mem[102][3][2][2][2];
int x[101], y[101], b[11][11], n;
vector<int> dx[3], dy[3], un;
void init() {
for (int k = 0; k <= n * n + 1; ++k) {
for (int f = 0; f < 3; ++f) {
for (int l = 0; l < 2; ++l) {
for (int d = 0; d < 2; ++d) {
for (int s = 0; s < 2; ++s) {
mem[k][f][l][d][s].first = -1;
}
}
}
}
}
}
pair<int, int> dp(int nxt, int kn, bool b0, bool b1, bool b2) {
if (nxt == (n * n + 1)) return make_pair(0, 0);
if (mem[nxt][kn][b0][b1][b2].first != -1) {
return mem[nxt][kn][b0][b1][b2];
}
int now = nxt - 1;
pair<int, int> res = make_pair(1000, 1000);
int xx = x[now], yy = y[now];
int x1, y1;
pair<int, int> tmp;
if (!b0) {
tmp = dp(nxt, 0, 1, 1, 1);
++tmp.first;
++tmp.second;
res = min(res, make_pair(tmp.first, tmp.second));
}
if (!b1) {
tmp = dp(nxt, 1, 1, 1, 1);
++tmp.first;
++tmp.second;
res = min(res, make_pair(tmp.first, tmp.second));
}
if (!b2) {
tmp = dp(nxt, 2, 1, 1, 1);
++tmp.first;
++tmp.second;
res = min(res, make_pair(tmp.first, tmp.second));
}
int x2, x3, x4, y2, y3, y4;
if (kn == 0) {
for (int i = 0; i < dx[0].size(); ++i) {
x1 = xx + dx[kn][i];
y1 = yy + dy[kn][i];
if (x1 < n && x1 >= 0 && y1 < n && y1 >= 0) {
if (b[x1][y1] == nxt) {
tmp = dp(nxt + 1, kn, 1, 0, 0);
res = min(res, make_pair(1 + tmp.first, tmp.second));
} else {
for (int j = 0; j < dx[1].size(); ++j) {
x2 = x1 + dx[1][j];
y2 = y1 + dy[1][j];
if (x2 < n && x2 >= 0 && y2 < n && y2 >= 0) {
if (b[x2][y2] == nxt) {
tmp = dp(nxt + 1, 1, 0, 1, 0);
res = min(res, make_pair(3 + tmp.first, 1 + tmp.second));
}
}
}
for (int j = 0; j < dx[0].size(); ++j) {
x2 = x1 + dx[kn][j];
y2 = y1 + dy[kn][j];
if (x2 < n && x2 >= 0 && y2 < n && y2 >= 0) {
if (b[x2][y2] == nxt) {
tmp = dp(nxt + 1, kn, 1, 0, 0);
res = min(res, make_pair(2 + tmp.first, tmp.second));
} else {
for (int h = 0; h < dx[0].size(); ++h) {
x3 = x2 + dx[kn][h];
y3 = y2 + dy[kn][h];
if (x3 < n && x3 >= 0 && y3 < n && y3 >= 0) {
if (b[x3][y3] == nxt) {
tmp = dp(nxt + 1, kn, 1, 0, 0);
res = min(res, make_pair(3 + tmp.first, tmp.second));
} else {
for (int k = 0; k < dx[0].size(); ++k) {
x4 = x3 + dx[kn][k];
y4 = y3 + dy[kn][k];
if (x4 < n && x4 >= 0 && y4 < n && y4 >= 0) {
if (b[x4][y4] == nxt) {
tmp = dp(nxt + 1, kn, 1, 0, 0);
res =
min(res, make_pair(4 + tmp.first, tmp.second));
}
}
}
}
}
}
}
}
}
}
}
}
} else if (kn == 1) {
for (int i = 0; i < dx[1].size(); ++i) {
x1 = xx + dx[kn][i];
y1 = yy + dy[kn][i];
if (x1 < n && x1 >= 0 && y1 < n && y1 >= 0) {
if (b[x1][y1] == nxt) {
tmp = dp(nxt + 1, kn, 0, 1, 0);
res = min(res, make_pair(1 + tmp.first, tmp.second));
} else {
for (int i = 0; i < dx[0].size(); ++i) {
x2 = x1 + dx[0][i];
y2 = y1 + dy[0][i];
if (x2 < n && x2 >= 0 && y2 < n && y2 >= 0) {
if (b[x2][y2] == nxt) {
tmp = dp(nxt + 1, 0, 1, 0, 0);
res = min(res, make_pair(3 + tmp.first, 1 + tmp.second));
}
}
}
}
}
}
if ((x[nxt] + y[nxt]) % 2 == (x[now] + y[now]) % 2) {
tmp = dp(nxt + 1, kn, 0, 1, 0);
res = min(res, make_pair(2 + tmp.first, tmp.second));
}
} else {
bool l = 0;
for (int i = 0; i < dx[2].size(); ++i) {
x1 = xx + dx[kn][i];
y1 = yy + dy[kn][i];
if (x1 < n && x1 >= 0 && y1 < n && y1 >= 0) {
if (b[x1][y1] == nxt) {
tmp = dp(nxt + 1, kn, 0, 0, 1);
res = min(res, make_pair(1 + tmp.first, tmp.second));
l = 1;
break;
}
}
}
if (!l) {
tmp = dp(nxt + 1, kn, 0, 0, 1);
res = min(res, make_pair(2 + tmp.first, tmp.second));
}
}
mem[nxt][kn][b0][b1][b2] = res;
return res;
}
int main() {
dx[0].push_back(-2);
dx[0].push_back(-2);
dx[0].push_back(-1);
dx[0].push_back(1);
dx[0].push_back(2);
dx[0].push_back(2);
dx[0].push_back(1);
dx[0].push_back(-1);
dy[0].push_back(-1);
dy[0].push_back(1);
dy[0].push_back(2);
dy[0].push_back(2);
dy[0].push_back(1);
dy[0].push_back(-1);
dy[0].push_back(-2);
dy[0].push_back(-2);
for (int i = -10; i <= 10; ++i) {
if (i == 0) continue;
dx[1].push_back(i);
dy[1].push_back(i);
dx[1].push_back(i);
dy[1].push_back(-i);
}
for (int i = -10; i <= 10; ++i) {
if (i == 0) continue;
dx[2].push_back(i);
dy[2].push_back(0);
}
for (int i = -10; i <= 10; ++i) {
if (i == 0) continue;
dy[2].push_back(i);
dx[2].push_back(0);
}
while (cin >> n) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> b[i][j];
x[b[i][j]] = i;
y[b[i][j]] = j;
}
}
pair<int, int> ans, tmp;
init();
ans = dp(2, 0, 1, 0, 0);
tmp = dp(2, 1, 0, 1, 0);
ans = min(ans, tmp);
tmp = dp(2, 2, 0, 0, 1);
ans = min(ans, tmp);
cout << ans.first << " " << ans.second << endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const int N = 600 + 5, lg = 27, mod = 5e4 + 7;
int da[N][N];
void solve() {
int n, t;
cin >> n >> t;
queue<pair<int, int>> q;
q.push({300, 300});
da[300][300] = n;
int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
while (!q.empty()) {
int u = q.front().first, v = q.front().second;
q.pop();
int z = da[u][v] / 4;
if (da[u][v] < 4) {
continue;
}
da[u][v] %= 4;
for (int i = 0; i < 4; i++) {
int x = u + dx[i], y = v + dy[i];
da[x][y] += z;
if ((da[x][y]) / 4) {
q.push({x, y});
}
}
}
while (t--) {
int x, y;
cin >> x >> y;
x += 300, y += 300;
if (x < 0 || y < 0 || x >= 600 || y >= 600) {
cout << 0 << endl;
} else {
cout << da[x][y] << endl;
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
int testCases = 1;
while (testCases--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long fact[1000005];
long long p(long long n, long long k) {
if (k == 0) return 1;
if (k == 1) return n;
long long x = p(n, k / 2) % 998244353;
if (k & 1) return (((x * x) % 998244353) * n) % 998244353;
return (x * x) % 998244353;
}
long long nck(long long n, long long k) {
long long ans = fact[n];
ans = (ans * p(fact[k], 998244353 - 2)) % 998244353;
ans = (ans * p(fact[n - k], 998244353 - 2)) % 998244353;
return ans;
}
void solve() {
cin >> n >> k;
map<long long, long long> add, rem;
pair<long long, long long> a[n];
vector<pair<long long, long long>> ops;
for (long long i = 0; i < n; ++i) {
long long l, r;
cin >> l >> r;
a[i].first = l, a[i].second = r;
add[l]++;
rem[r]++;
ops.push_back({l, 0});
ops.push_back({r, 1});
}
sort(a, a + n);
sort(ops.begin(), ops.end());
long long c = 0;
long long ans = 0;
for (long long i = 0; i < ops.size(); ++i) {
if (ops[i].second == 0) {
c++;
if (c >= k) {
ans = (ans + nck(c - 1, k - 1)) % 998244353;
}
} else
c--;
}
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long T = 1;
fact[0] = 1;
for (long long i = 1; i < 1000005; ++i) {
fact[i] = (i * fact[i - 1]) % 998244353;
}
for (long long i = 1; i <= T; ++i) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1, c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : -x;
}
const int N = 104, M = 10004;
int n, X, sum;
double ans, f[N][M];
int main() {
n = read();
X = read();
f[0][0] = 1;
for (int i = 1, a; i <= n; i++) {
a = read();
for (int j = i - 1; j >= 0; j--)
for (int k = sum; k >= 0; k--) {
f[j + 1][k + a] += f[j][k] * (j + 1) / (n - j);
}
sum += a;
}
for (int i = 0; i < n; i++)
for (int j = 0; j <= sum; j++) {
ans += f[i][j] *
min((1.0 * n / (n - i) + 1) * X / 2, 1.0 * (sum - j) / (n - i));
}
printf("%.12lf\n", ans);
return (0 - 0);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1 = 0, x2 = 0, a, n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a;
if (a % 2 == 1) {
x1++;
} else
x2++;
}
cout << min(x1, x2);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v, vp[200009];
vector<int>::iterator it;
int arr[200009];
int main() {
int n, i, j, k, l, m;
cin >> n;
for (i = 0; i < n; i++) {
cin >> arr[i];
}
for (i = 0; i < n; i++) v.push_back(0);
vp[n - 1].push_back(arr[0]);
v[n - 1] = arr[0];
for (i = 1; i < n; i++) {
it = upper_bound(v.begin(), v.end(), arr[i]);
k = (it - v.begin());
v[k - 1] = arr[i];
vp[k - 1].push_back(arr[i]);
}
for (i = n - 1; i >= 0; i--) {
if (vp[i].size()) {
for (j = 0; j < vp[i].size(); j++) cout << vp[i][j] << " ";
cout << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void write(T x) {
if (x == 0) {
putchar('0');
return;
}
if (x < 0) x = -x, putchar('-');
static char stk[1024];
int top = 0;
while (x != 0) stk[top++] = x % 10, x /= 10;
while (top) putchar(stk[--top] + '0');
}
const int Len = 3000005, Len2 = 3000005;
long long d[Len2], ds[Len2];
int BITLen;
inline void modifyT(long long *t, int p, long long x) {
for (; p <= BITLen; p += p & -p) t[p] += x;
}
inline long long queryT(long long *t, int p) {
long long r = 0;
for (; p; p ^= (p & -p)) r += t[p];
return r;
}
inline void modify(int p, long long x) {
if (p <= BITLen) modifyT(d, p, x), modifyT(ds, p, x * (p - 1));
}
inline long long query(int p) {
if (p < 0) return 0;
p = min(p, BITLen);
return p * queryT(d, p) - queryT(ds, p);
}
char a[Len], b[Len], s[Len2];
char c1[Len + Len2], c2[Len + Len2];
int z1[Len + Len2], z2[Len + Len2];
void buildZ(char s[], int n, int z[]) {
z[0] = n;
for (int i = 1, l = 0, r = 0; i < n; i++) {
if (i > r)
z[i] = 0;
else
z[i] = min(z[i - l], r - i + 1);
while (s[z[i]] == s[i + z[i]]) ++z[i];
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
}
int l1[Len], l2[Len];
int main() {
int n, m;
scanf("%d%d", &n, &m);
scanf("%s%s%s", a, b, s);
int la = n, lb = n, ls = m;
BITLen = max(max(la, lb), ls) + 1;
copy(s, s + ls, c1);
c1[ls] = '#';
copy(a, a + la, c1 + ls + 1);
buildZ(c1, ls + la + 1, z1);
reverse(b, b + lb);
reverse(s, s + ls);
copy(s, s + ls, c2);
c2[ls] = '#';
copy(b, b + lb, c2 + ls + 1);
buildZ(c2, ls + lb + 1, z2);
for (int i = 1; i <= la; i++) l1[i] = z1[ls + i];
for (int i = 1; i <= lb; i++) l2[i] = z2[ls + lb + 1 - i];
for (int i = 1; i <= min(lb, ls - 1); i++)
modify(1, +1), modify(l2[i] + 1, -1);
long long res = query(ls - 1) - query(ls - l1[1] - 1);
for (int i = 2; i <= la; i++) {
modify(1, -1);
modify(l2[i - 1] + 1, +1);
if (i + ls - 2 <= lb) modify(1, +1), modify(l2[i + ls - 2] + 1, -1);
res += query(ls - 1) - query(ls - l1[i] - 1);
}
printf("%lld\n", res);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long arr[200005], ans[200005];
map<long long, long long> memo;
vector<pair<long long, long long> > V[200005];
vector<long long> t;
int main() {
long long n, q;
scanf("%lld %lld", &n, &q);
for (long long i = 1; i <= n; i++) scanf("%lld", &arr[i]);
for (long long i = 1; i <= q; i++) {
long long pos, val;
scanf("%lld %lld", &pos, &val);
V[pos].push_back(make_pair(i, val));
}
t.push_back(0);
memo[0] = 1;
long long f = 1;
for (long long i = 1; i <= n; i++) {
long long val = arr[i];
if (memo[val]) {
f = (f * 2) % 1000000007;
} else {
vector<long long> toadd;
for (long long j = 0; j < t.size(); j++) {
toadd.push_back(t[j] ^ val);
}
for (long long j = 0; j < toadd.size(); j++) {
t.push_back(toadd[j]);
memo[toadd[j]] = 1;
}
}
for (long long j = 0; j < V[i].size(); j++) {
long long pos = V[i][j].first;
long long val = V[i][j].second;
if (memo[val])
ans[pos] = f;
else
ans[pos] = 0;
}
}
for (long long i = 1; i <= q; i++) printf("%lld\n", ans[i]);
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int, int>
#define fir first
#define sec second
#define pb emplace_back
#define gc() getchar()
inline int read()
{
int now=0,f=1; char c=gc();
for(;!isdigit(c);c=='-'&&(f=-1),c=gc());
for(;isdigit(c);now=now*10+c-48,c=gc());
return now*f;
}
const int mod = 998244353;
inline int add(int a,int b){return a+b>=mod? a+b-mod: a+b;}
inline int sub(int a,int b){return a<b? a-b+mod: a-b;}
inline int mul(int a,int b){return 1LL*a*b%mod;}
int qpow(int a,int b){
int ret=1;
for(; b; b>>=1){
if(b&1) ret=mul(ret,a);
a=mul(a,a);
}
return ret;
}
const int M = 1e6+10;
int fac[M], inv[M], ifac[M];
void init(int n){
fac[0]=1;for(int i=1; i<=n; i++)fac[i]=mul(fac[i-1],i);
inv[1]=1;for(int i=2; i<=n; i++)inv[i]=mul(sub(mod,mod/i),inv[mod%i]);
ifac[0]=1;for(int i=1; i<=n; i++)ifac[i]=mul(ifac[i-1],inv[i]);
}
const int N = 1e5+10;
int h[N], s[N];
int main(){
int T; cin>>T;
while(T--){
int n=read(),k=read();
for(int i=1; i<=n; i++) h[i]=read();
h[n+1]=0;
int ans=0;
while(k){
int nw=n+1;
for(int i=1; i<=n; i++){
if(h[i]<h[i+1]){
nw=i; h[i]++;
break;
}
}
//for(int i=1; i<=n; i++) cout<<h[i]<<' '; cout<<endl;
k--;
if(k==0) ans=nw;
if(nw==n+1) {ans=-1; break;}
}
printf("%d\n",ans);
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
void enable_comma() {}
string tostring(char c) {
string s = "";
s += c;
return s;
}
string tostring(string s) { return "\"" + s + "\""; }
string tostring(const char *c) { return tostring((string)c); }
string tostring(long long x) {
if (x < 0) return "-" + tostring(-x);
if (x > 9)
return tostring(x / 10) + tostring(char('0' + x % 10));
else
return tostring(char('0' + x));
}
string tostring(int x) { return tostring((long long)x); }
string tostring(unsigned long long x) {
if (x > 9)
return tostring((long long)(x / 10)) + tostring(char('0' + x % 10));
else
return tostring(char('0' + x));
}
string tostring(unsigned x) { return tostring((long long)x); }
string tostring(double x) {
static char res[114];
sprintf(res, "%lf", x);
string s = tostring(res);
return s.substr(1, (int)s.size() - 2);
}
string tostring(long double x) { return tostring((double)x); }
template <class A, class B>
string tostring(pair<A, B> p) {
return "(" + tostring(p.first) + "," + tostring(p.second) + ")";
}
template <class T>
string tostring(T v) {
string res = "";
for (auto p : v) res += (res.size() ? "," : "{") + tostring(p);
return res.size() ? res + "}" : "{}";
}
template <class A>
string tostring(A *a, int L, int R) {
return tostring(vector<A>(a + L, a + R + 1));
};
template <class A>
string tostring(A a, int L, int R) {
return tostring(a.data(), L, R);
}
string tostrings() { return ""; }
template <typename Head, typename... Tail>
string tostrings(Head H, Tail... T) {
return tostring(H) + " " + tostrings(T...);
}
long long read() {
long long x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f = ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
template <class T>
void ckmax(T &x, const T y) {
if (x < y) x = y;
}
template <class T>
void ckmin(T &x, const T y) {
if (x > y) x = y;
}
const int N = 1e6;
const long long INF = 1e18;
int n, k;
long long a[6];
long long dp[7][N];
long long q[N];
long long p10[6] = {1, 10, 100, 1000, 10000, 100000};
void solve() {
k = read();
for (int i = (0); i <= (5); i++) a[i] = read();
for (int i = (0); i <= (N - 1); i++) {
int v = i;
for (int j = (0); j <= (5); j++) {
int t = v % 10;
if (t % 3 == 0) dp[0][i] += a[j] * (t / 3);
v /= 10;
}
}
k = (k - 1) * 3;
for (int i = (0); i <= (5); i++) {
for (int r = (0); r <= (3 * p10[i]); r++) {
int s = 1, t = 0;
for (int v = r; v < N; v += 3 * p10[i]) {
while (s <= t && (v - q[s]) / 3 / p10[i] > k) s++;
while (s <= t &&
dp[i][q[t]] + (v - q[t]) / 3 / p10[i] * a[i] <= dp[i][v])
t--;
q[++t] = v;
dp[i + 1][v] = dp[i][q[s]] + (v - q[s]) / 3 / p10[i] * a[i];
}
}
}
int q = read();
while (q--) {
printf("%lld\n", dp[6][read()]);
}
}
int main() {
int T = 1;
while (T--) {
solve();
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7, INF = 1e9 + 7;
pair<int, int> tr[4 * N];
int lz[4 * N];
pair<int, int> merge(const pair<int, int> &a, const pair<int, int> &b) {
return pair<int, int>(max(a.first, b.first), min(a.second, b.second));
}
void propagate(int u, int st, int en) {
if (!lz[u]) return;
tr[u].first += lz[u];
tr[u].second += lz[u];
if (st != en) {
lz[2 * u] += lz[u];
lz[2 * u + 1] += lz[u];
}
lz[u] = 0;
}
void update(int u, int st, int en, int l, int r, int x) {
if (r < st || en < l) {
propagate(u, st, en);
} else if (l <= st && en <= r) {
lz[u] += x;
propagate(u, st, en);
} else {
propagate(u, st, en);
int mid = (st + en) / 2;
update(2 * u, st, mid, l, r, x);
update(2 * u + 1, mid + 1, en, l, r, x);
tr[u] = merge(tr[2 * u], tr[2 * u + 1]);
}
}
pair<int, int> query(int u, int st, int en, int l, int r) {
if (r < st || en < l)
return {-INF, INF};
else if (l <= st && en <= r) {
propagate(u, st, en);
return tr[u];
} else {
propagate(u, st, en);
int mid = (st + en) / 2;
return merge(query(2 * u, st, mid, l, r),
query(2 * u + 1, mid + 1, en, l, r));
}
}
void debug(int u, int st, int en) {
cout << "--->" << u << " " << st << " " << en << " " << tr[u].first << " "
<< tr[u].second << " " << lz[u] << endl;
if (st == en) return;
int mid = (st + en) / 2;
debug(2 * u, st, mid);
debug(2 * u + 1, mid + 1, en);
}
int a[N];
int sum = 0;
int get(char c) {
if (c == '(') return 1;
if (c == ')') return -1;
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
string s;
cin >> s;
int pos = 1;
int last = 0;
for (int i = 0; i < n; i++) {
char c = s[i];
if (c == 'R')
pos = pos + 1;
else if (c == 'L')
pos = max(pos - 1, 1);
else {
int cur = a[pos];
int nw = get(c);
a[pos] = nw;
if (nw != cur) {
sum -= cur;
sum += nw;
update(1, 1, n, pos, n, nw - cur);
if (sum != 0)
last = -1;
else {
pair<int, int> pr = query(1, 1, n, 1, n);
int mx = pr.first;
int mn = pr.second;
if (mn < 0)
last = -1;
else
last = mx;
}
}
}
cout << last << " ";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int NchooseK(int n, int k) {
if (k == 0) return 1;
return (n * NchooseK(n - 1, k - 1)) / k;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
double s = 0;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
s += a[i];
}
double k = (double)s / n;
sort(a.begin(), a.end());
unordered_map<double, int> map;
for (int i = 0; i < n; i++) {
double dif = k - a[i];
if (map.find(dif) == map.end()) {
map.insert(make_pair(dif, 1));
} else {
map[dif]++;
}
}
int pos = 0;
long long int ans = 0;
double prev = INT_MIN;
while (pos < a.size() && (double)a[pos] <= k) {
int v1, v2;
double dif = k - a[pos];
if (dif == prev) {
pos++;
continue;
}
prev = dif;
v1 = map[dif];
if (map.find(-dif) == map.end()) {
pos++;
continue;
} else {
v2 = map[-dif];
}
int v = min(v1, v2);
if (k != (double)a[pos])
ans += (long long int)v1 * v2;
else
ans += NchooseK(v, 2);
pos++;
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
uint64_t H, L;
cin >> H >> L;
cout << (L * L - H * H) / (2.0 * H);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
cout << fixed << setprecision(13);
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m;
cin >> n >> m;
long long int A[n], B[m];
for (long long int i = 0; i < n; i++) {
cin >> A[i];
}
for (long long int i = 0; i < m; i++) {
cin >> B[i];
}
long long p = -1e18;
long long C[n];
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < n; j++) {
if (i != j) {
for (int k = 0; k < m; k++) {
p = max(p, A[j] * B[k]);
}
}
}
C[i] = p;
p = -1e18;
}
p = C[0];
for (long long int i = 0; i < n; i++) {
p = min(p, C[i]);
}
cout << p;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
FILE* _fin = stdin;
FILE* _fout = stdout;
int _min(int a, int b) { return a <= b ? a : b; }
long long _min(long long a, long long b) { return a <= b ? a : b; }
int _max(int a, int b) { return a >= b ? a : b; }
long long _max(long long a, long long b) { return a >= b ? a : b; }
void zero(int* data, int n) { memset(data, 0, sizeof(int) * n); }
void zero(long long* data, int n) { memset(data, 0, sizeof(long long) * n); }
void zero(unsigned long long* data, int n) {
memset(data, 0, sizeof(unsigned long long) * n);
}
void zero(char* data, int n) { memset(data, 0, sizeof(char) * n); }
char readc() {
char var;
fscanf(_fin, "%c", &var);
return var;
}
int readi() {
int var;
fscanf(_fin, "%d", &var);
return var;
}
double readlf() {
double var;
fscanf(_fin, "%lf", &var);
return var;
}
long long readll() {
long long var;
fscanf(_fin, "%lld", &var);
return var;
}
void repread(int* data, int n) {
for (int i = 0; i < n; ++i) data[i] = readi();
}
void repread(long long* data, int n) {
for (int i = 0; i < n; ++i) data[i] = readll();
}
int reads(char* str, int maxsize) {
for (;;) {
if (fgets(str, maxsize, _fin) == NULL) break;
if (str[0] != '\n' && str[0] != '\r') break;
}
int slen = strlen(str);
if (slen == 0) return 0;
if (str[slen - 1] == '\n' || str[slen - 1] == '\r') str[--slen] = 0;
return slen;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
long long g = gcd(a, b);
return (a / g) * b;
}
void reverse(char* data, int n) {
int k = n >> 1;
for (int i = 0; i < k; ++i) {
char tmp = data[i];
data[i] = data[n - i - 1];
data[n - i - 1] = tmp;
}
}
void reverse(int* data, int n) {
int k = n >> 1;
for (int i = 0; i < k; ++i) {
int tmp = data[i];
data[i] = data[n - i - 1];
data[n - i - 1] = tmp;
}
}
void reverse(long long* data, int n) {
int k = n >> 1;
for (int i = 0; i < k; ++i) {
long long tmp = data[i];
data[i] = data[n - i - 1];
data[n - i - 1] = tmp;
}
}
struct Veci {
int* data;
int size;
int n;
};
void init(Veci* t, int size) {
t->data = (int*)malloc(sizeof(int) * size);
t->size = size;
t->n = 0;
}
void resize(Veci* t) {
int ns = t->size * 1.2f;
t->data = (int*)realloc(t->data, sizeof(int) * ns);
t->size = ns;
}
void add(Veci* t, int val) {
if (t->n >= t->size) resize(t);
int k = t->n;
t->data[k] = val;
t->n = k + 1;
}
void free(Veci* t) { free(t->data); }
struct Vecll {
long long* data;
int size;
int n;
};
void init(Vecll* t, int size) {
t->data = (long long*)malloc(sizeof(long long) * size);
t->size = size;
t->n = 0;
}
void resize(Vecll* t) {
int ns = t->size * 1.2f;
t->data = (long long*)realloc(t->data, sizeof(long long) * ns);
t->size = ns;
}
void add(Vecll* t, long long val) {
if (t->n >= t->size) resize(t);
int k = t->n;
t->data[k] = val;
t->n = k + 1;
}
void free(Vecll* t) { free(t->data); }
struct Vecs {
char** data;
int size;
int n;
};
void init(Vecs* t, int size) {
t->data = (char**)malloc(sizeof(char*) * size);
t->size = size;
t->n = 0;
}
void resize(Vecs* t) {
int ns = t->size * 1.2f;
t->data = (char**)realloc(t->data, sizeof(char*) * ns);
t->size = ns;
}
void add(Vecs* t, char* val) {
if (t->n >= t->size) resize(t);
int k = t->n;
t->data[k] = val;
t->n = k + 1;
}
void free(Vecs* t) { free(t->data); }
int ispali(int* a, int* b, int n) {
for (int i = 0; i < n; ++i) {
if (a[i] != b[n - i - 1]) {
return 0;
}
}
return 1;
}
int ispalc(char* a, char* b, int n) {
for (int i = 0; i < n; ++i) {
if (a[i] != b[n - i - 1]) {
return 0;
}
}
return 1;
}
struct Pairi {
int x, y;
};
int cmp_Pairi(const void* _a, const void* _b) {
Pairi* a = (Pairi*)_a;
Pairi* b = (Pairi*)_b;
if (a->x < b->x)
return -1;
else {
if (a->x == b->x) {
if (a->y == b->y) return 0;
if (a->y < b->y)
return -1;
else
return 1;
} else {
return 1;
}
}
}
void sort_Pairi(Pairi* d, int n) { qsort(d, n, sizeof(Pairi), cmp_Pairi); }
struct Pairlf {
double x, y;
};
int cmp_Pairlf(const void* _a, const void* _b) {
Pairlf* a = (Pairlf*)_a;
Pairlf* b = (Pairlf*)_b;
if (a->x < b->x)
return -1;
else {
if (a->x == b->x) {
if (a->y == b->y) return 0;
if (a->y < b->y)
return -1;
else
return 1;
} else {
return 1;
}
}
}
void sort_Pairlf(Pairlf* d, int n) { qsort(d, n, sizeof(Pairlf), cmp_Pairlf); }
int cmp_Str(const void* _a, const void* _b) {
char* a = *((char**)_a);
char* b = *((char**)_b);
return strcmp(a, b);
}
void sort_Str(char** str, int n) { qsort(str, n, sizeof(char*), cmp_Str); }
long long expmod(long long x, long long n, long long m) {
long long ans = 1;
for (; n;) {
if (n & 1) ans = (ans * x) % m;
x = (x * x) % m;
n >>= 1;
}
return ans;
}
long long combmod(long long n, long long k, long long m) {
long long ret = 1;
long long div = 1;
for (long long i = 0; i < k; ++i) {
ret = (ret * (n - i) % m) % m;
div = (div * (i + 1)) % m;
}
div = expmod(div, m - 2, m) % m;
return (ret * div) % m;
}
int next_perm(int* data, int n) {
int rootidx = -1;
for (int i = n - 2; i >= 0; --i) {
if (data[i] < data[i + 1]) {
rootidx = i;
break;
}
}
if (rootidx == -1) return 0;
int ceilingidx = rootidx + 1;
for (int i = rootidx + 2; i < n; ++i) {
if (data[i] > data[rootidx] && data[i] < data[ceilingidx]) {
ceilingidx = i;
}
}
{
int t = data[rootidx];
data[rootidx] = data[ceilingidx];
data[ceilingidx] = t;
};
std::sort(&data[rootidx + 1], &data[rootidx + 1] + n - rootidx - 1);
return 1;
}
int count_digits(long long a) {
int k = 0;
for (;;) {
if (a == 0) break;
k++;
a /= 10;
}
return k;
}
int bs_exists(int* data, int n, int val) {
int left = 0;
int right = n - 1;
for (; left < right;) {
int mid = (left + right + 1) >> 1;
if (data[mid] <= val)
left = mid;
else
right = mid - 1;
}
return right;
}
long long simple_factorial(int x) {
long long f = 1.0;
for (int i = 0; i < x; ++i) {
f *= (i + 1);
}
return f;
}
unsigned long long djb2(char* data, int n) {
unsigned long long h = 5381;
for (int i = 0; i < n; ++i) h = (h << 5) + h + data[i];
return h;
}
struct Hashcount {
int* count;
unsigned long long* keys;
int size_bits;
};
void init(Hashcount* h, int size_bits) {
h->size_bits = size_bits;
int size = 1 << h->size_bits;
h->count = (int*)malloc(sizeof(int) * size);
zero(h->count, size);
h->keys = (unsigned long long*)malloc(sizeof(unsigned long long) * size);
zero(h->keys, size);
}
int set(Hashcount* h, unsigned long long key) {
int index = (key * 2654435761) >> (64 - h->size_bits);
int size = 1 << h->size_bits;
for (int i = 0; i < size; i++) {
if (h->keys[index] == key) {
h->count[index]++;
return index;
}
if (h->keys[index] == 0) {
h->count[index] = 1;
h->keys[index] = key;
return index;
}
index++;
index &= size - 1;
}
return -1;
}
int get(Hashcount* h, unsigned long long key) {
int index = (key * 2654435761) >> (64 - h->size_bits);
int size = 1 << h->size_bits;
for (int i = 0; i < size; i++) {
if (h->keys[index] == key) {
return h->count[index];
}
if (h->keys[index] == 0) return 0;
index++;
index &= size - 1;
}
return 0;
}
int sub(Hashcount* h, unsigned long long key) {
int index = (key * 2654435761) >> (64 - h->size_bits);
int size = 1 << h->size_bits;
for (int i = 0; i < size; i++) {
if (h->keys[index] == key) {
--h->count[index];
if (h->count[index] < 0) h->count[index] = 0;
return h->count[index];
}
if (h->keys[index] == 0) return 0;
index++;
index &= size - 1;
}
return 0;
}
const long long MOD = 1e9 + 7;
int main() {
{
_fin = fopen("input.txt", "r");
if (_fin == NULL) _fin = stdin;
};
int n = readi();
for (int i = 0; i < n; ++i) {
int a = readi();
int b = readi();
printf("%d %d\n", a, a * 2);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t;
cin >> n >> t;
int f = 0;
int x;
int sum = 1;
for (int i = 1; i < n; i++) {
cin >> x;
if (i == sum) sum += x;
if (sum == t) f = 1;
}
if (f == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
double a[10000];
double p;
int good(double x) {
double x1 = 0, x2 = 0;
for (int i = 0; i < (n); i++)
if (a[i] >= x)
x1 += a[i] - x;
else
x2 += x - a[i];
x1 *= (1 - p);
return x1 >= x2;
}
int main() {
cin >> n >> p;
p /= 100;
for (int i = 0; i < (n); i++) cin >> a[i];
double l = 0, r = 1000;
for (int i = 0; i < (40); i++) {
double c = (l + r) / 2;
if (good(c))
l = c;
else
r = c;
}
printf("%.6lf\n", (l + r) / 2);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 201 * 1001;
struct node {
int l, r, h, b, lazyb, lazya, ans;
} p[N];
inline void add(int id, int x, int y) {
p[id].b += x;
p[id].lazyb += x;
p[id].ans += y;
p[id].lazya += y;
}
inline void shift(int x) {
int l = p[x].l, r = p[x].r;
if (r != -1) add(r, p[x].lazyb, p[x].lazya);
if (l != -1) add(l, p[x].lazyb, p[x].lazya);
p[x].lazyb = 0;
p[x].lazya = 0;
}
pair<int, int> split(int root, int x) {
if (root == -1) return {-1, -1};
shift(root);
if (p[root].b >= x) {
pair<int, int> tmp = split(p[root].l, x);
p[root].l = tmp.second;
return {tmp.first, root};
}
pair<int, int> tmp = split(p[root].r, x);
p[root].r = tmp.first;
return {root, tmp.second};
}
int merge(int x, int y) {
if (min(x, y) == -1) return max(x, y);
if (p[x].h < p[y].h) {
shift(x);
p[x].r = merge(p[x].r, y);
return x;
}
shift(y);
p[y].l = merge(x, p[y].l);
return y;
}
inline int insert(int root, int x) {
if (root == -1) return x;
pair<int, int> pp = split(root, p[x].b);
int v = pp.first, u = pp.second;
v = merge(v, x);
root = merge(v, u);
return root;
}
pair<int, int> a[N];
int b[N];
vector<int> seen;
void dfs(int u) {
if (u == -1) return;
seen.push_back(u);
shift(u);
dfs(p[u].l);
dfs(p[u].r);
}
int32_t main() {
srand(time(NULL));
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &a[i].second, &a[i].first);
a[i].first *= -1;
}
iota(b, b + n, 0);
random_shuffle(b, b + n);
sort(a, a + n);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
p[i].l = p[i].r = -1;
p[i].lazya = p[i].lazyb = p[i].ans = 0;
p[i].h = b[i];
scanf("%d", &p[i].b);
}
int root = 0;
for (int i = 1; i < q; i++) root = insert(root, i);
for (int i = 0; i < n; i++) {
int val = a[i].second;
pair<int, int> pp = split(root, val);
int v = pp.first, u = pp.second, w;
if (u == -1) continue;
pp = split(u, 2 * val);
u = pp.first, w = pp.second;
seen.clear();
if (w != -1) add(w, -val, 1);
dfs(u);
for (auto u : seen) {
p[u].b -= val;
p[u].ans++;
p[u].l = p[u].r = -1;
v = insert(v, u);
}
root = merge(v, w);
}
dfs(root);
for (int i = 0; i < q; i++) printf("%d ", p[i].ans);
printf("\n");
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, adin;
bool daun = 0;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> adin;
daun = 0;
for (long long big = 1; big < (long long)1e6; big++) {
if (big * big >= adin) {
for (long long small = 1; small <= big; small++) {
long long teor_zero = (big / small) * (big / small);
long long real_zero = big * big - adin;
if (teor_zero == real_zero) {
cout << big << " " << small << endl;
daun = true;
break;
}
if (teor_zero < real_zero) break;
}
if (daun) break;
}
}
if (!daun) {
cout << -1 << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, k, x, t;
long long a[200100];
long long ans, tmp, tmp1;
int b[100];
long long Power(long long u, int v) {
long long tmp = 1;
for (int i = 0; i < k; i++) tmp *= x;
return tmp;
}
int main() {
while (~scanf("%d%d%d", &n, &k, &x)) {
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
ans = 0;
for (int i = 0; i < 35; i++) b[i] = 0;
t = Power(x, k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 35; j++)
if (a[i] & (1LL << j)) b[j]++;
}
tmp1 = 0;
for (int i = 0; i < 35; i++) {
if (b[i]) tmp1 |= (1LL << i);
}
for (int i = 0; i < n; i++) {
tmp = tmp1;
for (int j = 0; j < 35; j++) {
if (b[j] == 1 && (a[i] & (1LL << j))) tmp ^= (1LL << j);
}
tmp = tmp | (a[i] * t);
ans = max(ans, tmp);
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s1[50], s2[50];
cin >> s1 >> s2;
long long left = 0, right = 0, mid = 0, l;
l = strlen(s1);
for (long long i = 0; i < l; i++)
if (s1[i] == '|') {
mid = i;
break;
}
left = mid;
right = l - (mid + 1);
if ((strlen(s1) + strlen(s2) - 1) % 2 == 1) {
printf("Impossible");
return 0;
}
if (left == right) {
if (strlen(s2) % 2 == 0) {
for (int j = 0; j < left; j++) printf("%c", s1[j]);
for (int j = 0; j < strlen(s2) / 2; j++) printf("%c", s2[j]);
printf("|");
for (int j = left + 1; j < l; j++) printf("%c", s1[j]);
for (int j = strlen(s2) / 2; j < strlen(s2); j++) printf("%c", s2[j]);
return 0;
} else {
printf("Impossible");
return 0;
}
}
if (left < right) {
if (right - left > strlen(s2)) {
printf("Impossible");
return 0;
} else {
long long dif = right - left;
dif += (strlen(s2) - dif) / 2;
for (int j = 0; j < left; j++) printf("%c", s1[j]);
for (int j = 0; j < dif; j++) printf("%c", s2[j]);
printf("|");
for (int j = left + 1; j < strlen(s1); j++) printf("%c", s1[j]);
for (int j = dif; j < strlen(s2); j++) printf("%c", s2[j]);
return 0;
}
}
if (right < left) {
if (left - right > strlen(s2)) {
printf("Impossible");
return 0;
} else {
long long dif = left - right;
dif = (strlen(s2) - dif) / 2;
for (int j = 0; j < left; j++) printf("%c", s1[j]);
for (int j = 0; j < dif; j++) printf("%c", s2[j]);
printf("|");
for (int j = left + 1; j < strlen(s1); j++) printf("%c", s1[j]);
for (int j = dif; j < strlen(s2); j++) printf("%c", s2[j]);
return 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
scanf("%d:%d", &x, &y);
x %= 12;
printf("%.10lf %d\n", x * 30 + y * 0.5, y * 6);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long max_(long long a, long long b) { return a > b ? a : b; }
int main() {
long long n;
scanf("%lld", &n);
if (n == 1 || n == 2)
printf("1\n");
else {
long long x = 4, y = 5;
while (max_(x, y) < n) {
int xx = x, yy = y;
if (x & 1)
x = yy + xx + 1, y = yy * 2 + 1;
else
x = yy + xx + 1, y = xx * 2 + 1;
if (x > y) swap(x, y);
}
if (x == n || y == n)
printf("1\n");
else
printf("0\n");
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int sol[200000 + 10];
int timelim = 0;
struct node {
int l;
int r;
int d;
} Node[200000 + 10];
bool ccc(int a, int b) { return a > b; }
bool cmp(struct node a, struct node b) { return a.l < b.l; }
int my_max(int a, int b) { return a > b ? a : b; }
bool check(int abil, int size) {
int nowtime;
int nowloca;
int nowxj = 0;
while (nowxj < size && Node[nowxj].d <= abil) nowxj++;
nowtime = nowloca = Node[nowxj].l - 1;
while (nowxj < size) {
int k = nowxj;
int rimo = Node[k].r;
while (k < size && (Node[k].l == Node[nowxj].l || Node[k].l <= rimo)) {
if (Node[k].d > abil) rimo = my_max(rimo, Node[k].r);
k++;
}
nowxj = k;
while (nowxj < size && Node[nowxj].d <= abil) nowxj++;
nowtime += 2 * (rimo - nowloca);
nowtime += (Node[nowxj].l - 1 - nowloca);
nowloca = Node[nowxj].l - 1;
}
if (nowtime <= timelim)
return true;
else
return false;
}
int main() {
int m, n, k, t;
scanf("%d %d %d %d", &m, &n, &k, &t);
for (int i = 0; i < m; i++) scanf("%d", &sol[i]);
sol[m++] = 1000010;
sort(sol, sol + m, ccc);
for (int i = 0; i < k; i++)
scanf("%d %d %d", &Node[i].l, &Node[i].r, &Node[i].d);
Node[k].r = Node[k].l = n + 2;
Node[k].d = 1000010;
sort(Node, Node + k, cmp);
int star, end;
star = 0;
end = m - 1;
while (star <= end) {
timelim = t;
int mid = (star + end) / 2;
if (check(sol[mid], k) == true)
star = mid + 1;
else
end = mid - 1;
}
printf("%d\n", end);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int T, n;
int a[N], ans[N], tot = 0;
int ask(int first) { return a[first] ^ a[first + 1] ^ a[first + 2]; }
void flip(int first) {
if (a[first] == a[first + 1] && a[first + 1] == a[first + 2]) return;
a[first] = a[first + 1] = a[first + 2] =
a[first] ^ a[first + 1] ^ a[first + 2];
ans[++tot] = first;
return;
}
void solve() {
tot = 0;
cin >> n;
int parity = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
parity ^= a[i];
}
if (parity) {
cout << "NO" << endl;
return;
}
int pos = -1, flag = a[1] == 0;
if (!flag) {
for (int i = 1; i <= n - 2; i += 2) {
if (ask(i) == 0) {
pos = i;
break;
} else
flip(i);
}
} else
pos = 1;
if (pos == -1) {
cout << "NO" << endl;
return;
}
if (!flag) {
for (int i = pos; i >= 1; i -= 2) {
flip(i);
}
}
for (int i = pos + 1; i <= n - 2; i++) {
if (a[i] == 0) continue;
if (ask(i) == 0)
flip(i);
else {
flip(i);
flip(i - 1);
}
}
flip(n - 2);
cout << "YES" << endl;
cout << tot << endl;
for (int i = 1; i <= tot; i++) cout << ans[i] << " ";
cout << endl;
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
for (cin >> T; T--;) solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
vector<long long> a(n);
for (long long i = 0, ThxDem = n; i < ThxDem; ++i) cin >> a[i];
vector<long long> b = a;
sort(b.begin(), b.end());
vector<vector<long long>> ans;
for (long long i = 0, ThxDem = 2; i < ThxDem; ++i) {
long long mx = -1e18;
for (long long i = 0, ThxDem = n; i < ThxDem; ++i) mx = max(mx, a[i]);
for (long long i = 0, ThxDem = n; i < ThxDem; ++i) a[i] = mx - a[i];
ans.push_back(a);
}
vector<long long> r;
if (k & 1)
r = ans[0];
else
r = ans[1];
for (auto x : r) cout << x << " ";
cout << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
struct Fraction {
public:
int numerator;
int denominator;
public:
Fraction(const int numerator, const int denominator) {
this->numerator = numerator;
this->denominator = denominator;
}
};
int main() {
Fraction max(0, 1);
int n;
cin >> n;
for (int num = 1; num <= n / 2; ++num) {
int den = n - num;
if (gcd(num, den) == 1) {
if ((float)max.numerator / max.denominator < (float)num / den) {
max.numerator = num;
max.denominator = den;
}
}
}
cout << max.numerator << ' ' << max.denominator;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int odd[1050000], even[1050000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long int n, i, j, k, temp, c = 0, mid;
cin >> n;
long long int a[n], Xor[n];
for (i = 0; i < n; i++) {
cin >> a[i];
if (i)
Xor[i] = Xor[i - 1] ^ a[i];
else
Xor[i] = a[i];
if (Xor[i] == 0 && (i + 1) % 2 == 0) {
even[0]++;
c += even[0];
} else {
if ((i + 1) % 2 == 0) {
c += even[Xor[i]];
even[Xor[i]]++;
} else {
c += odd[Xor[i]];
odd[Xor[i]]++;
}
}
}
cout << c;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, mod = 1e9 + 7;
cin >> n >> m;
int a[26][m];
memset(a, 0, sizeof a);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char x;
cin >> x;
a[x - 'A'][j] = 1;
}
long long ans = 1;
for (int j = 0; j < m; j++) {
long long c = 0;
for (int i = 0; i < 26; i++)
if (a[i][j]) c++;
ans *= c;
ans %= mod;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
long long n, H;
bool check(long long x) {
if (x <= H) {
if (x >= INF) return true;
return x * (x + 1) >= 2LL * n;
} else if ((x - H) & 1) {
long long A = (x - H) / 2;
return A * (2 * H + A - 1) / 2 + H + A + (1 + H + A) * (H + A) / 2 >= n;
} else {
long long A = (x - H) / 2;
return A * (2 * H + A - 1) / 2 + (1 + H + A) * (H + A) / 2 >= n;
}
}
int main() {
while (~scanf("%I64d%I64d", &n, &H)) {
long long l = 0, r = 2e9 + 10;
while (l < r - 1) {
long long mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid;
}
printf("%I64d\n", r);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3 * 1e5 + 100;
int n, m, a[N], match[N], L[N], R[N], w, vi[N];
vector<tuple<int, int, int> > e, E;
vector<pair<int, int> > to[N];
inline int read() {
int f = 1, x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
struct dsu {
int fa[N], sz[N], ok[N];
void init(int n) {
for (int i = 1; i <= n; i++) fa[i] = i, sz[i] = 1, ok[i] = -1;
}
int find(int x) { return fa[x] == x ? fa[x] : fa[x] = find(fa[x]); }
bool merge(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return 0;
if (sz[a] > sz[b]) swap(a, b);
fa[a] = b;
sz[b] += sz[a];
return 1;
}
} T;
void dfs(int x, int fa) {
for (auto [u, id] : to[x])
if (u != fa) {
match[u] = id;
dfs(u, x);
}
}
namespace maxmatch {
int ver, tr[N], vi[N], lk[N], dfn, id[N];
vector<int> e[N];
mt19937 rnd(time(0));
void add(int x, int y) {
e[x].push_back(y);
e[y].push_back(x);
}
bool dfs(int x) {
shuffle(e[x].begin(), e[x].end(), rnd);
vi[x] = dfn;
for (int u : e[x]) {
int f = lk[u];
if (vi[f] == dfn) continue;
lk[x] = u;
lk[u] = x;
lk[f] = 0;
if (!f) return 1;
if (dfs(f)) return 1;
lk[u] = f;
lk[f] = u;
lk[x] = 0;
}
return 0;
}
void solve(vector<tuple<int, int, int> > p) {
ver = m;
for (auto [u, v, w] : p)
if (w > 0) tr[w] = ++ver, id[ver] = w;
for (auto [u, v, w] : p) {
if (w > 0)
add(u, tr[w]), add(tr[w], v);
else if (match[u] == -1 && match[v] == -1)
add(u, v);
}
vector<int> cur(ver);
for (int i = 1; i <= ver; i++) cur[i - 1] = i;
int cnt = 0;
for (int h = 0; h < 15 || cnt < 1000; h++) {
shuffle(cur.begin(), cur.end(), rnd);
cnt++;
for (auto v : cur)
if (!lk[v]) dfn++, dfs(v), cnt++;
}
for (int i = 1; i <= m; i++) {
if (match[i] != -1 || lk[i] > m) {
if (match[i] == 0) continue;
int x = (match[i] != -1) ? match[i] : id[lk[i]];
if (a[L[x] - 1] == i)
a[L[x]] = i;
else
a[R[x]] = i;
}
}
for (auto [u, v, w] : p)
if (lk[u] == v && lk[v] == u) {
a[L[-w]] = a[L[-w] - 1];
a[R[-w]] = a[R[-w] + 1];
lk[u] = lk[v] = 0;
}
}
} // namespace maxmatch
signed main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
m = *max_element(a + 1, a + 1 + n);
if (all_of(a + 1, a + 1 + n, [](int x) { return x == 0; })) {
for (int i = 1; i <= n; i += 2) a[i] = a[i + 1] = (i + 1) / 2;
if (n & 1) a[n] = 1;
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
return 0;
}
for (int i = 1; i <= n;) {
int j = i;
while (j <= n && (a[i] == 0) == (a[j] == 0)) j++;
if (a[i] == 0) {
L[++w] = i;
R[w] = j - 1;
if ((j - i) & 1) {
if (i == 1)
E.emplace_back(a[j], a[j], w);
else if (j == n + 1)
E.emplace_back(a[i - 1], a[i - 1], w);
else
E.emplace_back(a[i - 1], a[j], w);
} else if (i != 1 && j != n + 1 && a[i - 1] != a[j])
e.emplace_back(a[i - 1], a[j], -w);
}
i = j;
}
for (int i = 1; i < n; i++)
if (a[i] == a[i + 1] && a[i] > 0) E.emplace_back(a[i], a[i], 0);
T.init(m);
for (int i = 0; i < (int)E.size(); i++) {
auto [u, v, w] = E[i];
if (T.merge(u, v)) {
to[u].emplace_back(v, w);
to[v].emplace_back(u, w);
vi[i] = 1;
}
}
for (int i = 0; i < (int)E.size(); i++)
if (!vi[i]) {
auto [u, v, w] = E[i];
if (T.ok[T.find(u)] == -1) T.ok[T.find(u)] = i;
}
for (int i = 0; i < (int)E.size(); i++)
if (vi[i] && T.ok[T.find(get<0>(E[i]))] == -1) {
assert(get<2>(E[i]) != 0);
e.emplace_back(E[i]);
}
memset(vi, 0, sizeof(vi));
memset(match, -1, sizeof(match));
for (int i = 1; i <= m; i++)
if (T.find(i) == i && T.ok[i] != -1) {
auto [u, v, w] = E[T.ok[i]];
dfs(u, u);
match[u] = w;
}
maxmatch::solve(e);
memset(vi, 0, sizeof(vi));
for (int i = 1; i < n; i++)
if (a[i] == a[i + 1] && a[i] > 0) vi[a[i]] = 1;
vector<int> it;
for (int i = 1; i <= n; i++)
if (!vi[i]) it.push_back(i);
for (int i = 1; i <= n;) {
int j = i;
while (j <= n && (a[i] == 0) == (a[j] == 0)) j++;
if (a[i] == 0) {
for (int k = i + 1; k < j; k += 2) {
if (!it.empty())
a[k] = a[k - 1] = it.back(), it.pop_back();
else
a[k] = a[k - 1] = 1;
}
if ((j - i) & 1) a[j - 1] = 1;
}
i = j;
}
for (int i = 1; i <= n; i++) printf("%d ", a[i]);
printf("\n");
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int a[30];
map<long long, int> mp;
int main() {
string s;
cin >> s;
string in;
cin >> in;
int k;
cin >> k;
long long ans = 0;
for (int i = 0; i < s.size(); i++) {
int bc = 0;
long long hash = 0;
for (int j = i; j < s.size(); j++) {
hash = (hash * 257 + s[j]) % 1000000000000000007ll;
if (in[s[j] - 'a'] == '0') bc++;
if (bc > k) break;
if (mp[hash] == 0) {
ans++;
mp[hash] = 1;
}
}
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int maxn = 4405;
const long long inf = 1e17 + 7;
template <typename T>
inline T max(const T &a, const T &b) {
return a > b ? a : b;
}
template <typename T>
inline T min(const T &a, const T &b) {
return a < b ? a : b;
}
struct edge {
int v, nxt, w;
long long f;
} e[maxn << 3];
int n, k, s, t, edge_cnt = 1, fir[maxn], cur[maxn];
long long dis[maxn];
bool vis[maxn];
inline void add_edge(int u, int v, int w, long long f) {
e[++edge_cnt].nxt = fir[u];
e[edge_cnt].v = v, e[edge_cnt].w = w, e[edge_cnt].f = +f;
fir[u] = edge_cnt;
e[++edge_cnt].nxt = fir[v];
e[edge_cnt].v = u, e[edge_cnt].w = 0, e[edge_cnt].f = -f;
fir[v] = edge_cnt;
}
long long a[maxn], b[maxn];
bool spfa() {
std::queue<int> Q;
for (int i = s; i <= t; i++) dis[i] = inf, vis[i] = false;
Q.push(s), dis[s] = 0;
while (!Q.empty()) {
int now = Q.front();
Q.pop(), vis[now] = 0;
cur[now] = fir[now];
for (int i = fir[now]; i; i = e[i].nxt) {
int v = e[i].v;
if (dis[v] > dis[now] + e[i].f && e[i].w) {
dis[v] = dis[now] + e[i].f;
if (!vis[v]) Q.push(v), vis[v] = 1;
}
}
}
return dis[t] != inf;
}
int dfs(int now, int minflow) {
if (now == t) return minflow;
int useflow = 0;
vis[now] = 1;
for (int i = cur[now]; i && minflow; i = e[i].nxt) {
int v = e[i].v;
cur[now] = i;
if (dis[v] == dis[now] + e[i].f && e[i].w && !vis[v]) {
int tp = dfs(v, min(minflow, e[i].w));
if (!tp) dis[v] = inf;
e[i].w -= tp, e[i ^ 1].w += tp;
minflow -= tp, useflow += tp;
}
}
return vis[now] = 0, useflow;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &b[i]);
s = 0, t = n + n + 2;
add_edge(s, t - 1, k, 0);
for (int i = 1; i <= n; i++) {
add_edge(t - 1, i, 1, a[i]);
add_edge(i, i + n, 1, 0);
add_edge(i + n, t, 1, b[i]);
if (i ^ n) add_edge(i + n, i + 1 + n, n, 0);
}
int maxflow = 0;
long long answer = 0;
while (spfa()) {
int flow = dfs(s, k);
answer += flow * dis[t];
maxflow += flow;
}
printf("%lld\n", answer);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct SegmentTree {
struct Node {
int l, r;
int mx, lzy;
};
Node seg[2000000];
void build(int l, int r, int idx) {
seg[idx].l = l, seg[idx].r = r;
if (l == r) {
return;
}
int mid = l + r >> 1;
build(l, mid, 2 * idx);
build(mid + 1, r, 2 * idx + 1);
}
void pd(int idx) {
if (seg[idx].lzy) {
seg[2 * idx].lzy += seg[idx].lzy;
seg[2 * idx + 1].lzy += seg[idx].lzy;
seg[2 * idx].mx += seg[idx].lzy;
seg[2 * idx + 1].mx += seg[idx].lzy;
seg[idx].lzy = 0;
}
}
void upd(int l, int r, int v, int idx) {
if (seg[idx].l == l && seg[idx].r == r) {
seg[idx].mx += v;
seg[idx].lzy += v;
return;
}
pd(idx);
int mid = seg[idx].l + seg[idx].r >> 1;
if (r <= mid) {
upd(l, r, v, 2 * idx);
} else if (l > mid) {
upd(l, r, v, 2 * idx + 1);
} else {
upd(l, mid, v, 2 * idx);
upd(mid + 1, r, v, 2 * idx + 1);
}
seg[idx].mx = max(seg[2 * idx].mx, seg[2 * idx + 1].mx);
}
void st(int p, int v, int idx) {
if (seg[idx].l == seg[idx].r) {
seg[idx].mx = max(seg[idx].mx, v);
return;
}
pd(idx);
int mid = seg[idx].l + seg[idx].r >> 1;
if (p <= mid) {
st(p, v, 2 * idx);
} else {
st(p, v, 2 * idx + 1);
}
seg[idx].mx = max(seg[2 * idx].mx, seg[2 * idx + 1].mx);
}
} tree[2];
int N;
const int oo = INT_MAX / 2;
vector<int> cmp[2];
pair<pair<int, int>, int> arr[200005];
int getidx(int t, int n) {
return upper_bound(cmp[t].begin(), cmp[t].end(), n) - cmp[t].begin();
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N;
for (int i = 1; i <= N; i++) {
int l, r, t;
cin >> l >> r >> t;
cmp[(t == 1 ? 0 : 1)].push_back(l);
cmp[(t == 1 ? 0 : 1)].push_back(r);
arr[i].first = make_pair(r, l);
arr[i].second = (t == 1 ? 0 : 1);
}
cmp[0].push_back(0);
cmp[1].push_back(0);
sort(cmp[0].begin(), cmp[0].end());
sort(cmp[1].begin(), cmp[1].end());
cmp[0].erase(unique(cmp[0].begin(), cmp[0].end()), cmp[0].end());
cmp[1].erase(unique(cmp[1].begin(), cmp[1].end()), cmp[1].end());
int ans = 0;
sort(arr + 1, arr + 1 + N);
tree[0].build(1, cmp[0].size(), 1);
tree[1].build(1, cmp[1].size(), 1);
for (int i = 1; i <= N; i++) {
swap(arr[i].first.second, arr[i].first.first);
int rhtidx = getidx(arr[i].second, arr[i].first.second);
int lftidx = getidx(arr[i].second ^ 1, arr[i].first.first - 1);
tree[arr[i].second ^ 1].upd(1, lftidx, 1, 1);
int v = tree[arr[i].second ^ 1].seg[1].mx;
tree[arr[i].second].st(rhtidx, v, 1);
ans = max(ans, v);
}
cout << ans << "\n";
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
long long int n, k;
cin >> n >> k;
long long int s = 0;
long long int x = 1;
while (x < n) {
if (x <= k) {
s++;
x = x * 2;
} else
break;
}
if (x > n) x = n;
long long int rem = n - x;
s += rem / k;
if (rem % k > 0) s++;
cout << s << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define ld long double
#define endl "\n"
#define fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define pb push_back
#define mp(a,b) make_pair(a,b)
#define ms(v,x) memset(v,x,sizeof(v))
#define all(v) v.begin(),v.end()
#define ff first
#define ss second
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define per(i, a, b) for(int i = b-1; i>=a ; i--)
#define trav(a, x) for(auto& a : x)
#define allin(a , x) for(auto a : x)
#define Unique(v) sort(all(v));v.erase(unique(all(v)),v.end());
#define sz(v) ((int)v.size())
//#define int long long
using namespace std;
typedef vector<int> vi;
#define y1 abacaba
//#define left oooooopss
#define db(x) cerr << #x <<" == "<<x << endl;
#define db2(x,y) cerr<<#x <<" == "<<x<<", "<<#y<<" == "<<y<<endl;
#define db3(x,y,z) cerr << #x<<" == "<<x<<", "<<#y<<" == "<<y<<", "<<#z<<" == "<<z<<endl;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
std::mt19937 rng((int) std::chrono::steady_clock::now().time_since_epoch().count());
inline ll mod(ll n, ll m ){ ll ret = n%m; if(ret < 0) ret += m; return ret; }
ll gcd(ll a, ll b){return (b == 0LL ? a : gcd(b, a%b));}
ll exp(ll b,ll e,ll m){
b%=m;
ll ans = 1;
for (; e; b = b * b % m, e /= 2)
if (e & 1) ans = ans * b % m;
return ans;
}
const int N = 100100;
const int sq = 300;
int a[N];
int f[N];
int sum[N];
int mn[N];
int lazy[N];
int n,q;
void updF(int i){
int X = lazy[i];
lazy[i] = 0;
int lim = min(n,(i+1)*sq);
int ini = i*sq;
mn[i] = 1e9;
for(int j=ini;j<lim;j++){
a[j] = max(0,a[j] - X);
if(a[j] < ini){
f[j] = j;
}else f[j] = f[a[j]];
if(mn[i] > j - a[j])
mn[i] = j - a[j];
}
}
void sumX(int i,int x){
lazy[i]+=x;
if(lazy[i] > N)lazy[i] = N;
if(mn[i] > sq){
return;
}
updF(i);
}
int getint(){
int x=0;
char c = '*';
while(c<'0' || c>'9'){
c = getchar();
}
while(c>='0' and c<='9'){
x = 10*x + (c- '0');
c = getchar();
}
return x;
}
int block[N];
void write(int x){
if(x<10)return (void)putchar(x+'0');
write(x/10);
putchar(x%10+'0');
}
int32_t main(){
//fastio;
n = getint();
q = getint();
//cin >> n >> q;
for(int i=1;i<n;i++){
// cin >> a[i];
a[i] = getint();
a[i]--;
}
rep(i,0,n)block[i] = i/sq;
for(int i=0;i*sq<n;i++){
updF(i);
}
while(q--){
int t;
t = getint();
if(t==1){
int l = getint(),r=getint(),x=getint();
--l;--r;
int id=-1;
for(int i=l;i<=r;){
if(i%sq==0 and i+sq-1<=r){
sumX(i/sq,x);
i+=sq;
}else{
a[i] = max(a[i] - x,0);
id = i;
i++;
}
}
updF(block[l]);
if(block[l]!=block[r])
updF(block[r]);
}else{
int u = getint(),v = getint();
--u;--v;
while(u!=v){
if(u < v){
int c = u;u=v,v=c;
}
if(block[u]!=block[v]){
u = f[u];
u = max(0,a[u] - lazy[block[u]]);
}else{
if(f[u] == f[v]){
while(u!=v){
if(u < v){int c = u;u=v,v=c;}
u = max(0,a[u] - lazy[block[u]]);
}
break;
}else{
u = f[u],v = f[v];
u = max(0,a[u] - lazy[block[u]]);
v = max(0,a[v] - lazy[block[v]]);
}
}
}
write(u + 1);
putchar('\n');
}
}
// math -> gcd it all
// Did u check N=1? Did you switch N,M?
} | 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h1, a1, c1, h2, a2;
cin >> h1 >> a1 >> c1 >> h2 >> a2;
int sum = 0;
int h11 = h1, a11 = a1, c11 = c1, h22 = h2, a22 = a2;
while (h22 > 0) {
sum++;
if (h11 - a22 > 0 || h22 - a11 <= 0)
h22 -= a11;
else
h11 += c11;
h11 -= a22;
}
cout << sum << endl;
while (h2 > 0) {
sum++;
if (h1 - a2 > 0 || h2 - a1 <= 0) {
h2 -= a1;
cout << "STRIKE" << endl;
} else {
h1 += c1;
cout << "HEAL" << endl;
}
h1 -= a2;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[30], sum;
map<long long, long long> m[30];
int main() {
for (int i = 0; i < 26; i++) cin >> a[i];
string s;
cin >> s;
int n = s.size();
long long res = 0;
for (int i = 0; i < n; i++) {
res += m[s[i] - 'a'][sum];
sum += a[s[i] - 'a'];
m[s[i] - 'a'][sum]++;
}
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char arr[10][10];
string s1, s2, s3;
for (int i = 1; i <= 9; i++) {
cin >> s1;
cin >> s2;
cin >> s3;
for (int j = 1; j <= 3; j++) {
arr[i][j] = s1[j - 1];
arr[i][j + 3] = s2[j - 1];
arr[i][j + 6] = s3[j - 1];
}
}
int x, y, p1, p2;
cin >> x >> y;
if (x % 3 == 1) p1 = 1;
if (x % 3 == 2) p1 = 4;
if (x % 3 == 0) p1 = 7;
if (y % 3 == 1) p2 = 1;
if (y % 3 == 2) p2 = 4;
if (y % 3 == 0) p2 = 7;
int flag = 0;
for (int i = p1; i < (p1 + 3); i++) {
for (int j = p2; j < (p2 + 3); j++) {
if (arr[i][j] == '.') {
flag = 1;
break;
}
}
}
if (flag == 1) {
for (int i = p1; i < (p1 + 3); i++) {
for (int j = p2; j < (p2 + 3); j++) {
if (arr[i][j] == '.') arr[i][j] = '!';
}
}
} else {
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= 9; j++) {
if (arr[i][j] == '.') arr[i][j] = '!';
}
}
}
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= 9; j++) {
cout << arr[i][j];
if (j % 3 == 0) cout << " ";
}
cout << endl;
if (i % 3 == 0) cout << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
int p[100005];
int search(int x) {
int in;
int l, r, mid;
l = 1, r = n;
while (l < r) {
mid = l + r;
mid >>= 1;
if (p[mid] >= x)
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
scanf("%d", &n);
int a = 0;
for (auto i = 1; i <= n; i++) {
scanf("%d", &p[i]);
a += p[i];
p[i] = a;
}
scanf("%d", &q);
while (q--) {
int x;
scanf("%d", &x);
cout << search(x) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200011;
struct Frac {
long long n, d;
Frac(long long n, long long d) : n(n), d(d) {}
bool operator<(const Frac &rhs) const {
return (long long)n * rhs.d < (long long)d * rhs.n;
}
bool operator==(const Frac &rhs) const {
return (long long)n * rhs.d == (long long)d * rhs.n;
}
double value() { return (double)n / d; }
};
class Cmp {
public:
bool operator()(const pair<Frac, int> &lhs, const pair<Frac, int> &rhs) {
if (lhs.first == rhs.first) return lhs.second < rhs.second;
return lhs.first < rhs.first;
}
};
int t;
int p[N];
long long l[N];
Frac frac(int pos, int use) {
return Frac(p[pos] * l[pos], (l[pos] + use) * (l[pos] + use + 1));
}
int use[N];
double ans = 0;
set<pair<Frac, int>, Cmp> up, down;
void d(int pos) {
if (up.find({frac(pos, use[pos]), pos}) != up.end())
up.erase(up.find({frac(pos, use[pos]), pos}));
if (down.find({frac(pos, use[pos] - 1), pos}) != down.end())
down.erase(down.find({frac(pos, use[pos] - 1), pos}));
}
void a(int pos) {
if (use[pos] < l[pos]) up.insert({frac(pos, use[pos]), pos});
if (use[pos] != 0) down.insert({frac(pos, use[pos] - 1), pos});
}
void add(int pos) {
d(pos);
ans += frac(pos, use[pos]++).value();
a(pos);
t--;
}
void del(int pos) {
d(pos);
ans -= frac(pos, --use[pos]).value();
a(pos);
t++;
}
void balance(bool f = false) {
int cnt = 0;
while (true) {
if (t > 0 && up.size())
add((--up.end())->second);
else if (up.size() && down.size() &&
(down.begin()->first) < ((--up.end())->first)) {
int u = down.begin()->second;
int v = (--up.end())->second;
assert(u != v);
del(u);
add(v);
} else
break;
}
}
int main() {
int n, q;
cin >> n >> t >> q;
for (int i = 1; i <= n; i++) cin >> p[i];
for (int i = 1; i <= n; i++) {
cin >> l[i];
up.insert({frac(i, 0), i});
}
balance(true);
for (int _ = 1; _ <= q; _++) {
int type, pos;
cin >> type >> pos;
if (type == 1) {
ans -= (double)p[pos] * use[pos] / (l[pos] + use[pos]);
ans += (double)p[pos] * use[pos] / (l[pos] + use[pos] + 1);
d(pos);
l[pos]++;
a(pos);
} else {
if (use[pos] == l[pos]) {
t++;
ans -= (double)p[pos] * use[pos] / (l[pos] + use[pos]);
ans += (double)p[pos] * (use[pos] - 1) / (l[pos] + use[pos] - 2);
d(pos);
use[pos]--;
l[pos]--;
a(pos);
} else {
ans -= (double)p[pos] * use[pos] / (l[pos] + use[pos]);
ans += (double)p[pos] * use[pos] / (l[pos] + use[pos] - 1);
d(pos);
l[pos]--;
a(pos);
}
}
balance();
cout << setprecision(8) << ans << '\n';
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long f(long long pre, long long k) {
if (pre < 0)
return -pre / k + (pre % k != 0);
else
return -pre / k;
}
int main() {
long long p, k;
cin >> p >> k;
vector<long long> q;
q.push_back(f(p, k));
while (q.back() != 0) {
q.push_back(f(q.back(), k));
if (q.size() > 1e7) {
cout << -1 << endl;
return 0;
}
}
q.pop_back();
if (q.size() == 0) {
cout << 1 << endl;
cout << p << endl;
return 0;
}
cout << q.size() + 1 << endl;
cout << p + q[0] * k << " ";
for (int i = 0; i < q.size() - 1; i++) cout << q[i] + q[i + 1] * k << " ";
cout << q.back() << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
int read() {
int x = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * w;
}
int n, m, ano[maxn << 2];
struct edge {
int u, v;
} E[maxn];
struct mmp {
int to, id;
};
vector<mmp> g[maxn];
vector<int> g1[maxn];
int dfn[maxn], low[maxn], ins[maxn], dfn_num;
int belong[maxn], tot, maxx, cnt;
int f[maxn], ff[maxn];
stack<int> stk;
void dfs(int u, int pid) {
dfn[u] = low[u] = ++dfn_num;
stk.push(u);
ins[u] = 1;
int len = g[u].size();
for (int i = 0; i < len; i++) {
int v = g[u][i].to, id = g[u][i].id;
if (ano[id] == pid) continue;
if (!dfn[v])
dfs(v, id), low[u] = min(low[u], low[v]);
else if (ins[v])
low[u] = min(low[u], dfn[v]);
}
if (dfn[u] == low[u]) {
tot++;
while (1) {
int v = stk.top();
stk.pop();
belong[v] = tot;
ins[v] = 0;
if (v == u) break;
}
}
}
void dp(int u, int fa) {
int len = g1[u].size();
for (int i = 0; i < len; i++) {
int v = g1[u][i];
if (v == fa) continue;
dp(v, u);
int now = f[v] + 1;
if (now > f[u])
ff[u] = f[u], f[u] = now;
else if (now > ff[u])
ff[u] = now;
}
maxx = max(maxx, f[u] + ff[u]);
}
void addedge(int u, int v) {
g[u].push_back((mmp){v, ++cnt});
ano[cnt] = cnt + 1;
g[v].push_back((mmp){u, ++cnt});
ano[cnt] = cnt - 1;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= m; i++) {
int u = read(), v = read();
E[i] = (edge){u, v};
addedge(u, v);
}
for (int i = 1; i <= n; i++)
if (!dfn[i]) dfs(i, 0);
for (int i = 1; i <= m; i++) {
int u = E[i].u, v = E[i].v;
if (belong[u] == belong[v]) continue;
g1[belong[u]].push_back(belong[v]);
g1[belong[v]].push_back(belong[u]);
}
dp(1, 0);
cout << maxx << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gi() {
T x = 0;
bool f = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') f = 1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return f ? -x : x;
}
const int N = 1e6 + 10, Mod = 1e9 + 7;
int f[N][20][2], n, mi[20];
void pls(int &x, int y) {
x += y;
if (x >= Mod) x -= Mod;
}
int calc(int x, int y) { return n / (mi[x] * (y ? 3 : 1)); }
int main() {
n = gi<int>();
int c = log2(n);
for (int i = mi[0] = 1; i <= c; i++) mi[i] = 2 * mi[i - 1];
f[1][c][0] = 1;
if (pow(2, c - 1) * 3 <= n) f[1][c - 1][1] = 1;
for (int i = 1; i < n; i++)
for (int j = 0; j <= c; j++)
for (int k = 0; k < 2; k++) {
pls(f[i + 1][j][k], 1ll * f[i][j][k] * (calc(j, k) - i) % Mod);
if (j)
pls(f[i + 1][j - 1][k],
1ll * f[i][j][k] * (calc(j - 1, k) - calc(j, k)) % Mod);
if (k)
pls(f[i + 1][j][k - 1],
1ll * f[i][j][k] * (calc(j, k - 1) - calc(j, k)) % Mod);
}
printf("%d\n", f[n][0][0]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
vector<int> adj[200005];
int a[200005], p[200005], idx[200005], h[200005];
int Lg[500005];
int in[200005], t[500005], euler;
void dfs(int u) {
in[u] = ++euler;
t[euler] = u;
for (auto v : adj[u]) {
h[v] = h[u] + 1;
dfs(v);
t[++euler] = u;
}
}
int sp[500005][22];
void Build_sparse() {
Lg[1] = 0;
for (int i = 2; i <= euler; i++) {
Lg[i] = Lg[i / 2] + 1;
}
for (int Len = 0; Len < 20; Len++) {
for (int i = 1; i + (1 << Len) - 1 <= euler; i++) {
if (!Len) {
sp[i][0] = t[i];
} else {
if (h[sp[i][Len - 1]] < h[sp[i + (1 << (Len - 1))][Len - 1]]) {
sp[i][Len] = sp[i][Len - 1];
} else
sp[i][Len] = sp[i + (1 << (Len - 1))][Len - 1];
}
}
}
}
int lca(const int &u, const int &v) {
int L = in[u], R = in[v];
if (L > R) swap(L, R);
int Log = Lg[R - L + 1];
return (h[sp[L][Log]] < h[sp[R - (1 << Log) + 1][Log]]
? sp[L][Log]
: sp[R - (1 << Log) + 1][Log]);
}
int dist(const int &u, const int &v) { return h[u] + h[v] - 2 * h[lca(u, v)]; }
pair<int, int> ST[800005];
int v[4];
pair<int, int> Merge(const pair<int, int> &a, const pair<int, int> &b) {
if (!a.first or !b.first) {
return {0, 0};
}
v[0] = a.first, v[1] = a.second, v[2] = b.first, v[3] = b.second;
int leaf1 = 0, leaf2 = 0, mxdis = 0;
for (int i = 0; i < 4; i++) {
for (int j = i; j < 4; j++) {
int newdist = dist(v[i], v[j]);
if (newdist > mxdis) {
mxdis = newdist;
leaf1 = v[i];
leaf2 = v[j];
}
}
}
for (int i = 0; i < 4; i++) {
if (dist(leaf1, v[i]) + dist(v[i], leaf2) != mxdis) {
return {0, 0};
}
}
return {leaf1, leaf2};
}
void Build(int i, int l, int r) {
if (l == r) {
ST[i] = {idx[l], idx[l]};
return;
}
int mid = (l + r) >> 1;
Build(i << 1, l, mid);
Build(i << 1 | 1, mid + 1, r);
ST[i] = Merge(ST[i << 1], ST[i << 1 | 1]);
}
void Update(int i, int l, int r, int id, int val) {
if (l == r) {
ST[i] = {val, val};
return;
}
int mid = (l + r) >> 1;
if (id <= mid) {
Update(i << 1, l, mid, id, val);
} else {
Update(i << 1 | 1, mid + 1, r, id, val);
}
ST[i] = Merge(ST[i << 1], ST[i << 1 | 1]);
}
bool bad(int l, int r, int L, int R) { return (R < l or r < L or L > R); }
pair<int, int> Query(int i, int l, int r, int L, int R) {
if (L <= l and r <= R) {
return ST[i];
}
int mid = (l + r) >> 1;
if (bad(l, mid, L, R)) return Query(i << 1 | 1, mid + 1, r, L, R);
if (bad(mid + 1, r, L, R)) return Query(i << 1, l, mid, L, R);
return Merge(Query(i << 1, l, mid, L, R),
Query(i << 1 | 1, mid + 1, r, L, R));
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i]++;
idx[a[i]] = i;
}
for (int i = 2; i <= n; i++) {
cin >> p[i];
adj[p[i]].push_back(i);
}
dfs(1);
Build_sparse();
Build(1, 1, n);
cin >> q;
int cur_ans = 0;
for (int i = 1; i <= q; i++) {
int type;
cin >> type;
if (type == 1) {
int x, y;
cin >> x >> y;
Update(1, 1, n, a[x], y);
Update(1, 1, n, a[y], x);
swap(a[x], a[y]);
cur_ans = 0;
} else {
if (!cur_ans) {
int l = 1, r = n;
while (l < r) {
int mid = (l + r + 1) >> 1;
pair<int, int> T = Query(1, 1, n, 1, mid);
if (T.first) {
l = mid;
} else {
r = mid - 1;
}
}
cur_ans = l;
}
cout << cur_ans << '\n';
}
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int a, s, d, f, g, h, j, k, l, i, n, m;
vector<pair<int, int> > v[200002];
vector<int> pas[200003];
void dfs(int idx, int par, int nl, int er) {
if (er - nl == a) {
pas[a].push_back(idx);
}
if (er - nl > a) {
a = er - nl;
pas[a].push_back(idx);
}
for (vector<pair<int, int> >::iterator it = v[idx].begin();
it != v[idx].end(); it++) {
if (it->first == par) continue;
if (it->second == 1) {
k++;
dfs(it->first, idx, nl, er + 1);
} else
dfs(it->first, idx, nl + 1, er);
}
return;
}
int main() {
cin >> n;
for (i = 0; i < n - 1; i++) {
cin >> a >> s;
v[a].push_back({s, 0});
v[s].push_back({a, 1});
}
a = 0;
s = 1;
dfs(1, 0, 0, 0);
cout << k - a << endl;
sort(pas[a].begin(), pas[a].end());
for (i = 0; i < pas[a].size(); i++) {
cout << pas[a][i] << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const string alphabet{"abcdefghijklmnopqrstuvwxyzab"};
string solve(string& s) {
int N = s.size();
auto last = s[0];
for (int i = 1; i < N; ++i) {
if (s[i] == last) {
auto next = alphabet[s[i] - 'a' + 1];
if (i < N - 1 and s[i + 1] == next) next = alphabet[next - 'a' + 1];
s[i] = next;
}
last = s[i];
}
return s;
}
int main() {
ios::sync_with_stdio(false);
string s;
cin >> s;
auto ans = solve(s);
cout << ans << '\n';
return 0;
}
| 2 |
//#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4.1,sse4.2,avx,avx2,popcnt,tune=native")
//#include <immintrin.h>
//#include <emmintrin.h>
#include <bits/stdc++.h>
using namespace std;
#define rep(i,h,t) for (int i=h;i<=t;i++)
#define dep(i,t,h) for (int i=t;i>=h;i--)
#define ll long long
#define me(x) memset(x,0,sizeof(x))
#define IL inline
#define rint register int
inline ll rd(){
ll x=0;char c=getchar();bool f=0;
while(!isdigit(c)){if(c=='-')f=1;c=getchar();}
while(isdigit(c)){x=(x<<1)+(x<<3)+(c^48);c=getchar();}
return f?-x:x;
}
char ss[1<<24],*A=ss,*B=ss;
IL char gc()
{
return A==B&&(B=(A=ss)+fread(ss,1,1<<24,stdin),A==B)?EOF:*A++;
}
template<class T>void maxa(T &x,T y)
{
if (y>x) x=y;
}
template<class T>void mina(T &x,T y)
{
if (y<x) x=y;
}
template<class T>void read(T &x)
{
int f=1,c; while (c=gc(),c<48||c>57) if (c=='-') f=-1; x=(c^48);
while(c=gc(),c>47&&c<58) x=x*10+(c^48); x*=f;
}
const int mo=1e9+7;
struct re{
int a,b,c;
};
const int N=1e6;
int a[N];
ll ans=0;
int n;
ll AA(int x,int y)
{
ll ans=1;
dep(i,x,x-y+1) ans=ans*i%mo;
return ans;
}
map<int,int> M;
ll fsp(int x,int y)
{
if (y==1) return x;
ll ans=fsp(x,y/2);
ans=ans*ans%mo;
if (y%2==1) ans=ans*x%mo;
return ans;
}
int main()
{
ios::sync_with_stdio(false);
cin>>n;
rep(i,1,n) cin>>a[i];
rep(i,1,n) ans+=a[i];
if (ans%n!=0)
{
cout<<0<<endl;
} else
{
ans/=n;
int ans1=0,ans2=0,ans3=0;
ll t=1,t2=1;
rep(i,1,n)
{
if (a[i]<ans) ans1++;
if (a[i]==ans) ans2++;
if (a[i]>ans) ans3++;
M[a[i]]++;
}
if (min(ans1,ans3)>1)
{
t=1ll*AA(n,ans2)*AA(ans1,ans1)%mo*AA(ans3,ans3)%mo;
t=t*2%mo;
} else
{
t=AA(n,n);
}
rep(i,1,n)
{
if(M[a[i]])t2=t2*AA(M[a[i]],M[a[i]])%mo;
M[a[i]]=0;
}
t=t*fsp(t2,mo-2)%mo;
cout<<t<<endl;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[3100];
int main() {
int n, i, k, j;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
k = 0;
for (i = 0; i < n; i++)
for (j = i + 1; j < n; j++)
if (a[i] > a[j]) k++;
printf("%.6lf\n", (double)((k & 1) ? ((k << 1) - 1) : k << 1));
}
| 5 |
#include <bits/stdc++.h>
long long f[5005];
using namespace std;
int main() {
int n, i, j;
cin >> n;
int a[n + 1], b[n + 1];
for (i = 1; i <= n; i++) scanf("%d", &a[i]), b[i] = a[i];
sort(b + 1, b + n + 1);
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
f[j] += abs(b[j] - a[i]);
if (j > 1) f[j] = min(f[j - 1], f[j]);
}
}
cout << f[n] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1111;
const long long inf = 1ll << 40;
struct Edge {
int v, next;
long long len;
} edge[2000000];
long long Point[MaxN];
int tot;
void insert(int u, int v, long long w) {
edge[tot].v = v, edge[tot].len = w, edge[tot].next = Point[u];
Point[u] = tot++;
}
int N, M;
long long dis[MaxN][MaxN], g[MaxN][MaxN];
void clean() {
tot = 0;
for (int i = 1; i <= N; i++) Point[i] = -1;
}
bool inQue[MaxN];
void spfa(int s) {
for (int i = 1; i <= N; i++) {
dis[s][i] = inf;
inQue[i] = false;
}
dis[s][s] = 0;
queue<int> Q;
Q.push(s);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = Point[u]; i != -1; i = edge[i].next) {
int v = edge[i].v;
if (dis[s][u] + edge[i].len < dis[s][v]) {
dis[s][v] = dis[s][u] + edge[i].len;
if (!inQue[v]) {
inQue[v] = true;
Q.push(v);
}
}
}
inQue[u] = false;
}
}
int main() {
int u, v;
scanf("%d%d%d%d", &N, &M, &u, &v);
clean();
for (int i = 1; i <= M; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
insert(u, v, w);
insert(v, u, w);
}
for (int i = 1; i <= N; i++) spfa(i);
clean();
for (int i = 1; i <= N; i++) {
int x, y;
scanf("%d%d", &x, &y);
for (int j = 1; j <= N; j++)
if (dis[i][j] <= x) insert(i, j, y);
}
spfa(u);
if (dis[u][v] == inf) dis[u][v] = -1;
printf("%I64d\n", dis[u][v]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int p[201000];
int a[201000];
int vis[201000];
int main() {
int n;
scanf("%d", &n);
int ans = 0, op = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) {
ans++;
int x = i;
while (!vis[x]) {
vis[x] = 1;
x = a[x];
}
}
}
if (ans == 1) ans--;
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
op += p[i];
}
ans += 1 - (op & 1);
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[4];
int e, f;
void ReadInput() {
for (int i = 0; i < 4; ++i) cin >> a[i];
cin >> e >> f;
}
void Solve() {
if (e > f) {
int temp = min(a[0], a[3]);
int ans = e * temp;
a[3] -= temp;
temp = min(a[1], min(a[2], a[3]));
ans += f * temp;
cout << ans << '\n';
} else {
int temp = min(a[1], min(a[2], a[3]));
int ans = f * temp;
a[3] -= temp;
temp = min(a[0], a[3]);
ans += e * temp;
cout << ans << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
ReadInput();
Solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 5;
const long long INF = 1e18;
const int MOD = 998244353;
int n, m;
vector<pair<long long, long long>> edges1[20 * M], edges2[M << 1];
long long dis[20 * M];
long long c2 = 1e8;
void dij(int x, vector<pair<long long, long long>> adj[], int k) {
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
pq;
pq.push({0, x});
for (int i = 1; i < k + 1; i++) dis[i] = INF;
dis[x] = 0;
while (!pq.empty()) {
int v = pq.top().second;
long long w = pq.top().first;
pq.pop();
if (w > dis[v]) continue;
for (pair<long long, long long> u : adj[v])
if (dis[u.first] > dis[v] + u.second) {
dis[u.first] = dis[v] + u.second;
pq.push({dis[u.first], u.first});
}
}
}
void ad(vector<pair<long long, long long>> adj[], int v, int u, long long w) {
adj[v].push_back({u, w});
}
void go() {
cin >> n >> m;
while (m--) {
int a, b;
cin >> a >> b;
for (int i = 0; i < 20; i++) {
if (i & 1)
ad(edges1, b + n * i, a + n * i, 1);
else
ad(edges1, a + n * i, b + n * i, 1);
}
ad(edges2, a, b, 1);
ad(edges2, b + n, a + n, 1);
}
for (int i = 1; i < n + 1; i++) {
for (int j = 0; j < 19; j++)
ad(edges1, i + n * j, i + n * (j + 1), 1LL << j);
ad(edges2, i, i + n, c2);
ad(edges2, i + n, i, c2);
}
dij(1, edges1, 20 * n);
long long ans = INF;
for (int i = 1; i < 21; i++) ans = min(ans, dis[i * n]);
if (ans != INF) {
cout << ans << "\n";
return;
}
dij(1, edges2, 2 * n);
ans = min(dis[n], dis[n << 1]);
int dos = ans / c2;
long long p2 = 1;
while (dos--) p2 = (p2 << 1) % MOD;
p2--;
cout << (p2 + ans % c2) % MOD << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tst = 1;
while (tst--) go();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void print(T &&first) {
cout << first << endl;
}
template <typename Head, typename... Tail>
void print(Head &&h, Tail &&...t) {
cout << h << " ";
print(std::forward<Tail &&>(t)...);
}
template <typename... T>
void read(T &...args) {
((cin >> args), ...);
}
template <typename... T>
void write(T &...args) {
((cout << args << " "), ...);
}
template <typename T, typename U>
static inline void amin(T &first, U second) {
if (second < first) first = second;
}
template <typename T, typename U>
static inline void amax(T &first, U second) {
if (first < second) first = second;
}
template <long long mod>
struct ModInt {
long long a;
ModInt &s(long long vv) {
a = vv < mod ? vv : vv - mod;
return (*this);
}
ModInt(int64_t first = 0) { s(first % mod + mod); }
ModInt &operator+=(const ModInt &first) { return s(a + first.a); }
ModInt &operator-=(const ModInt &first) { return s(a + mod - first.a); }
ModInt &operator*=(const ModInt &first) {
a = uint64_t(a) * first.a % mod;
return (*this);
}
ModInt &operator/=(const ModInt &first) {
*this *= first.inv();
return (*this);
}
ModInt operator+(const ModInt &first) const { return ModInt(*this) += first; }
ModInt operator-(const ModInt &first) const { return ModInt(*this) -= first; }
ModInt operator*(const ModInt &first) const { return ModInt(*this) *= first; }
ModInt operator/(const ModInt &first) const { return ModInt(*this) /= first; }
bool operator==(const ModInt &first) const { return a == first.a; }
bool operator!=(const ModInt &first) const { return a != first.a; }
ModInt operator-() const { return ModInt() - (*this); }
ModInt pow(int64_t n) const {
ModInt res(1), first(*this);
while (n) {
if (n & 1) res *= first;
first *= first;
n >>= 1;
}
return res;
}
ModInt inv() const { return pow(mod - 2); }
};
const long long mod = 998244353;
using mint = ModInt<mod>;
mint factorial(long long first) {
mint fact = mint(1);
for (int i = 2; i <= first; ++i) {
fact *= mint(i);
}
return fact;
}
mint power(long long first) {
mint p = mint(1);
for (int i = 0; i < first; ++i) {
p *= mint(2);
}
return p;
}
void solve(int test_no) {
int n, m;
cin >> n >> m;
int second = n - 2;
mint fact = second * second;
mint sum = factorial(m) / (factorial(n - 1) * factorial(m - n + 1));
sum *= mint((n - 2));
sum *= power(n - 3);
cout << sum.a << endl;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int test_count = 1;
for (int test_no = 1; test_no <= test_count; ++test_no) {
solve(test_no);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300 * 1000 + 100;
const long long mod = 1e9 + 7;
const long long inf = 2 * 1e18;
const int delta = 10909;
int x11, y11, x12, y12, x13, y13, x14, y14, x21, x22, x23, x24, y21, y22, y23,
y24;
map<pair<int, int>, int> t;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> x11 >> y11 >> x12 >> y12 >> x13 >> y13 >> x14 >> y14 >> x21 >> y21 >>
x22 >> y22 >> x23 >> y23 >> x24 >> y24;
vector<pair<int, int>> sq1 = {{x11, y11}, {x12, y12}, {x13, y13}, {x14, y14}};
sort(sq1.begin(), sq1.end());
vector<pair<int, int>> sq2 = {{x21, y21}, {x22, y22}, {x23, y23}, {x24, y24}};
sort(sq2.begin(), sq2.end());
for (int i = -100; i <= 100; i++) {
for (int j = -100; j <= 100; j++) {
if (sq1[0].first <= i && sq1[3].first >= i) {
if (sq1[0].second <= j && sq1[3].second >= j) {
t[{i, j}] = 1;
}
}
}
}
for (int i = sq2[0].second; i <= sq2[2].second; i++) {
for (int j = sq2[0].first + (i - sq2[0].second);
j <= sq2[3].first - (i - sq2[0].second); j++) {
if (t[{j, i}] == 1) {
cout << "YES";
exit(0);
}
}
}
for (int i = sq2[0].second; i >= sq2[1].second; i--) {
for (int j = sq2[0].first + (sq2[0].second - i);
j <= sq2[3].first - (sq2[0].second - i); j++) {
if (t[{j, i}] == 1) {
cout << "YES";
exit(0);
}
}
}
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int l, r, d;
scanf("%d %d %d", &l, &r, &d);
if ((double)l / d > 1)
printf("%d\n", d);
else {
int f = ((double)r / d) + 1;
printf("%d\n", f * d);
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long dx[] = {1, 0, -1, 0};
long long dy[] = {0, 1, 0, -1};
char dc[] = {'D', 'R', 'U', 'L'};
void solve() {
long long a1, a2, b1, b2;
cin >> a1 >> b1 >> a2 >> b2;
if (a1 == a2 && b1 == b2) {
cout << 0 << '\n';
return;
}
if (a1 == a2 || b1 == b2) {
cout << abs(a2 - a1) + abs(b2 - b1) << '\n';
return;
}
cout << abs(a2 - a1) + abs(b2 - b1) + 2 << '\n';
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
long long t = 1;
cin >> t;
for (long long tt = 0; tt < t; tt++) {
solve();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
const long long Lim = 1e14;
const long long M = 1e7;
int flag[M], f[M];
int b[15];
vector<pair<int, int> > Q[15][2];
inline int calc(int x, int flag, long long now, long long &k) {
if (now >= M) return -1;
int st = lower_bound(Q[x][flag].begin(), Q[x][flag].end(),
make_pair((int)now, 0)) -
Q[x][flag].begin();
int ed = lower_bound(Q[x][flag].begin(), Q[x][flag].end(),
make_pair((int)now + 1, 0)) -
Q[x][flag].begin();
if (ed - st < k) {
k -= ed - st;
return -1;
}
for (int i = st; i <= Q[x][flag].size(); i++) {
k--;
if (!k) return Q[x][flag][i].second;
}
return -1;
}
inline long long Solve() {
if (n * k > Lim) return -1;
for (int i = 1; i < M; i++) {
if (i / 10 % 10 == i % 10) continue;
int reflag = i / 10 % 10 < i % 10 ? 1 : -1;
if (i < 10 || flag[i / 10] && f[i / 10] != reflag) {
if (i < 10) reflag = 0;
flag[i] = 1;
f[i] = reflag;
if (i % n == 0) {
if (--k == 0) return i;
}
}
}
for (int i = 1; i < M; i++) {
b[1]++;
int now = 1;
for (; b[now] >= 10;) {
b[now + 1] += b[now] / 10;
b[now] %= 10;
now++;
}
int flag = 1;
for (int j = 2; j <= 6; j++)
if ((b[j] - b[j - 1]) * (b[j] - b[j + 1]) <= 0) {
flag = 0;
break;
}
if (!flag) continue;
Q[b[7]][b[6] > b[7] ? 1 : 0].push_back(make_pair(i % n, i));
}
for (int i = 0; i <= 9; i++)
for (int j = 0; j <= 1; j++) sort(Q[i][j].begin(), Q[i][j].end());
for (int i = 1; i < M; i++)
if (flag[i]) {
int reflag = i / 10 % 10 < i % 10 ? 1 : -1;
if (i < 10) reflag = 0;
long long now = 1ll * n - (1ll * i * M) % n;
if (now == n) now = 0;
if (reflag == 1 || reflag == 0) {
for (int j = 0; j < i % 10; j++) {
int tmp = calc(j, 1, now, k);
if (tmp != -1) return 1ll * i * M + 1ll * tmp;
}
}
if (reflag == -1 || reflag == 0) {
for (int j = i % 10 + 1; j <= 9; j++) {
int tmp = calc(j, 0, now, k);
if (tmp != -1) return 1ll * i * M + 1ll * tmp;
}
}
}
return -1;
}
int main() {
scanf("%I64d%I64d", &n, &k);
printf("%I64d\n", Solve());
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxsize = 100;
int a[3][maxsize] = {0};
int b[maxsize] = {0};
int n;
int calc(int x) {
int res = 0;
res += b[x];
for (int i = 1; i < x; i++) res += a[1][i];
for (int i = x; i < n; i++) res += a[2][i];
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= 2; i++) {
for (int j = 1; j <= n - 1; j++) {
scanf("%d", &a[i][j]);
}
}
for (int j = 1; j <= n; j++) {
scanf("%d", &b[j]);
}
int ans = 2100000000;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
ans = min(ans, calc(i) + calc(j));
}
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int memo[100005], pd[100005];
int grundy(int n) {
if (n <= 2) return 0;
int &ret = memo[n];
if (ret != -1) return ret;
set<int> MEX;
pd[n] = (1 << 30);
for (int i = 2; i * i <= 2 * n; i++) {
int xi = (2 * n) / i - 1 + i;
if ((2 * n) % i != 0) continue;
if (xi % 2 != 0) continue;
xi /= 2;
int sum1 = 0;
for (int j = 0; j < i; j++) sum1 ^= grundy(xi - j);
MEX.insert(sum1);
if (sum1 == 0 && pd[n] > i) pd[n] = i;
}
int nim = 0;
while (MEX.count(nim)) nim++;
return ret = nim;
}
int main() {
int n;
while (cin >> n) {
memset(memo, -1, sizeof memo);
int ans = grundy(n);
if (ans == 0)
puts("-1");
else
printf("%d\n", pd[n]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long int module = 1000000007;
int main() {
int64_t ans;
long int a[2][2001] = {0}, n, i, j, k, m, x;
cin >> n >> k;
for (i = 1; i <= n; i++) a[0][i] = 1;
long int crow = 0;
for (i = 1; i < k; i++) {
crow = 1 - crow;
for (j = 1; j <= n; j++) a[crow][j] = a[1 - crow][j];
for (j = 1; j <= n; j++) {
for (m = j + j; m <= n; m += j)
a[crow][m] = (a[crow][m] + a[1 - crow][j]) % module;
}
}
ans = 0;
for (i = 1; i <= n; i++) ans = (ans + a[crow][i]) % module;
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int ans, i, j, minmark, m, n, sum, l[101], r[101], t[101], c[101];
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) scanf("%d%d%d%d", &l[i], &r[i], &t[i], &c[i]);
sum = 0;
for (i = 1; i <= n; i++) {
ans = 1001;
minmark = -1;
for (j = 0; j < m; j++) {
if (i >= l[j] && i <= r[j]) {
if (t[j] < ans) {
ans = t[j];
minmark = j;
}
}
}
if (minmark == -1) continue;
sum += c[minmark];
}
printf("%d\n", sum);
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
int aabs(int a) {
if (a < 0) return -a;
return a;
}
int gcd(int a, int b) {
while (a > 0 && b > 0) {
if (a > b) {
a %= b;
} else {
b %= a;
}
}
return a + b;
}
vector<int> g[100013];
bool used[100013];
int timer;
int fup[100013], tin[100013];
vector<pair<int, int> > briges;
set<pair<int, int> > setbriges;
set<int> newv;
map<int, int> oldvnewv;
int newn;
void dfs(int v, int p = -1) {
used[v] = 1;
tin[v] = timer;
fup[v] = timer;
timer++;
for (int i = 0; i < g[v].size(); i++) {
if (g[v][i] == p) continue;
if (used[g[v][i]])
fup[v] = min(fup[v], tin[g[v][i]]);
else {
dfs(g[v][i], v);
fup[v] = min(fup[v], fup[g[v][i]]);
if (fup[g[v][i]] > tin[v]) {
briges.push_back(make_pair(v, g[v][i]));
setbriges.insert(make_pair(v, g[v][i]));
}
}
}
}
void dfsfupper(int v, int p = -1) {
used[v] = 1;
if (p >= 0) {
fup[v] = fup[p];
}
for (int i = 0; i < g[v].size(); i++) {
if (!used[g[v][i]]) {
if (setbriges.find(make_pair(v, g[v][i])) != setbriges.end() ||
setbriges.find(make_pair(g[v][i], v)) != setbriges.end()) {
dfsfupper(g[v][i]);
} else {
dfsfupper(g[v][i], v);
}
}
}
}
int l;
int tout[100013];
vector<int> up[100013];
void dfs2(int v, int p = 0) {
timer++;
tin[v] = timer;
up[v][0] = p;
for (int i = 1; i <= l; ++i) up[v][i] = up[up[v][i - 1]][i - 1];
for (int i = 0; i < g[v].size(); i++) {
if (g[v][i] != p) {
dfs2(g[v][i], v);
}
}
timer++;
tout[v] = timer;
}
bool upper(int a, int b) { return tin[a] <= tin[b] && tout[b] <= tout[a]; }
int calc(int a, int b) {
if (a == b) {
return 0;
}
if (upper(a, b)) {
int res = 0;
for (int i = l; i >= 0; --i) {
if (!upper(up[b][i], a)) {
b = up[b][i];
res += 1 << i;
}
}
return res + 1;
}
if (upper(b, a)) {
int res = 0;
for (int i = l; i >= 0; --i) {
if (!upper(up[a][i], b)) {
a = up[a][i];
res += 1 << i;
}
}
return res + 1;
}
int res = 0;
for (int i = l; i >= 0; --i) {
if (!upper(up[a][i], b)) {
a = up[a][i];
res += 1 << i;
}
}
return res + 1 + calc(up[a][0], b);
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int t1, t2;
cin >> t1 >> t2;
t1--;
t2--;
g[t1].push_back(t2);
g[t2].push_back(t1);
}
memset(used, 0, sizeof(used));
timer = 0;
dfs(0);
memset(used, 0, sizeof(used));
dfsfupper(0);
for (int i = 0; i < n; i++) {
newv.insert(fup[i]);
}
int newn = 0;
for (set<int>::iterator it = newv.begin(); it != newv.end(); it++) {
oldvnewv[(*it)] = newn;
newn++;
}
for (int i = 0; i < n; i++) {
g[i].clear();
}
for (int i = 0; i < briges.size(); i++) {
g[oldvnewv[fup[briges[i].first]]].push_back(
oldvnewv[fup[briges[i].second]]);
g[oldvnewv[fup[briges[i].second]]].push_back(
oldvnewv[fup[briges[i].first]]);
}
n = newn;
int k;
cin >> k;
timer = 0;
l = 1;
while ((1 << l) <= n) ++l;
for (int i = 0; i < n; i++) {
up[i].resize(l + 1);
}
dfs2(0);
for (int i = 0; i < k; i++) {
int t1, t2;
cin >> t1 >> t2;
t1--;
t2--;
cout << calc(oldvnewv[fup[t1]], oldvnewv[fup[t2]]) << '\n';
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int s[30] = {0, 2, 3, 5, 7, 11, 13, 17, 19};
int cs[30];
int a[10005], N, cnt, ans[10005], m, pp;
void dfs(int k, int t) {
a[++cnt] = k;
while (t <= 5) {
if (k * s[t] <= 50000000) dfs(k * s[t], t);
t++;
}
return;
}
int pd[10], visit[10000];
void f(int k, int t) {
int u = 0;
if (k % 2 == 0) {
if (pp < 80)
if (k % 5 == 0 || k % 7 == 0 || k % 11 == 0) return;
if (pp < 500)
if (k % 7 == 0 || k % 11 == 0) return;
if (pp < 2000)
if (k % 11 == 0) return;
pd[1]++;
visit[t] = 1;
u = 1;
}
if (k % 3 == 0) {
if (pp < 80)
if (k % 5 == 0 || k % 7 == 0 || k % 11 == 0) return;
if (pp < 500)
if (k % 7 == 0 || k % 11 == 0) return;
if (pp < 2000)
if (k % 11 == 0) return;
pd[2]++;
visit[t] = 1;
u = 1;
}
if (k % 5 == 0 && pp >= 80) {
if (pp < 500)
if (k % 7 == 0 || k % 11 == 0) return;
if (pp < 2000)
if (k % 11 == 0) return;
pd[3]++;
visit[t] = 1;
u = 1;
}
if (k % 7 == 0 && pp >= 500) {
if (pp < 2000)
if (k % 11 == 0) return;
pd[4]++;
visit[t] = 1;
u = 1;
}
if (k % 11 == 0 && pp >= 2000) {
pd[5]++;
visit[t] = 1;
u = 1;
}
if (u) ans[++m] = k;
}
int main() {
int i, j, n, k, d, ct = 0;
dfs(1, 1);
sort(a, a + cnt + 1);
cin >> k;
d = k / 2;
n = k * k * 2;
m = 0;
pp = k;
for (i = 1; i <= 5; i++) pd[i] = 0;
if (k % 2 == 1) d++;
for (i = cnt; i >= 1; i--) {
if (a[i] > n) continue;
if (pd[5] < d && a[i] % 11 == 0 && k >= 2000) {
f(a[i], i);
} else if (pd[4] < d && a[i] % 7 == 0 && k >= 500) {
f(a[i], i);
} else if (pd[3] < d && a[i] % 5 == 0 && k >= 80) {
f(a[i], i);
} else if (pd[2] < d && a[i] % 3 == 0) {
f(a[i], i);
} else if (pd[1] < d && a[i] % 2 == 0) {
f(a[i], i);
} else {
if (pd[1] >= d && pd[2] >= d) {
if (k >= 2000) {
if (pd[5] >= d && pd[4] >= d && pd[3] >= d) break;
} else if (k >= 500) {
if (pd[4] >= d && pd[3] >= d) break;
} else if (k >= 80) {
if (pd[3] >= d) break;
} else
break;
}
}
}
if (m < k) {
for (i = 2; i <= cnt; i++)
if (a[i] <= n)
if (!visit[i]) {
if (k < 2000)
if (a[i] % 11 == 0) continue;
if (k < 500)
if (a[i] % 7 == 0) continue;
if (k < 80)
if (a[i] % 5 == 0) continue;
ans[++m] = a[i];
if (m == k) break;
}
}
for (i = 1; i < k; i++) cout << ans[i] << " ";
cout << ans[k] << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
int n, tmp;
long long ans = 0;
int tree[maxn];
set<pair<int, int> > q;
inline int read() {
int ret = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) {
ret = (ret << 3) + (ret << 1) + (ch ^ 48);
ch = getchar();
}
return ret;
}
inline int lowbit(int x) { return x & (-x); }
inline void add(int x, int k) {
while (x <= n) {
tree[x] += k;
x += lowbit(x);
}
}
inline int sum(int x) {
int ans = 0;
while (x) {
ans += tree[x];
x -= lowbit(x);
}
return ans;
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
tmp = read();
ans += sum(min(i - 1, tmp));
while (!q.empty() && q.begin()->first == i) {
add(q.begin()->second, -1);
q.erase(q.begin());
}
if (tmp > i) {
add(i, 1);
q.insert(make_pair(tmp, i));
}
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, day = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a >> b;
if (a > day) {
day = a;
} else {
day++;
int mod = a % b;
if (day % b > mod)
day = day + b - day % b + mod;
else
day = day + mod - day % b;
}
}
cout << day << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct mycomp {
bool operator()(pair<int, int> const& a, pair<int, int> const& b) {
if (a.first == b.first) return a.second > b.second;
}
};
int64_t ceil_div(int64_t a, int64_t b) { return (a + b - 1) / b; }
int64_t fact(signed long long int n) {
return (n == 1 || n == 0) ? 1
: n % (int)(1e9 + 7) * fact(n - 1) % (int)(1e9 + 7);
}
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
vector<int> prime;
void printPrime(int n) {
prime.push_back(1);
for (int i = 2; i <= n; i++) {
if (isPrime(i)) prime.push_back(i);
}
}
void run_case() {
int n;
cin >> n;
while (n--) {
cout << "1 ";
}
cout << "\n";
}
int main() {
int t;
cin >> t;
while (t--) {
run_case();
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void __print(int x) { cout << x; }
void __print(long x) { cout << x; }
void __print(long long x) { cout << x; }
void __print(unsigned x) { cout << x; }
void __print(unsigned long x) { cout << x; }
void __print(unsigned long long x) { cout << x; }
void __print(float x) { cout << x; }
void __print(double x) { cout << x; }
void __print(long double x) { cout << x; }
void __print(char x) { cout << '\'' << x << '\''; }
void __print(const char *x) { cout << '\"' << x << '\"'; }
void __print(const string &x) { cout << '\"' << x << '\"'; }
void __print(bool x) { cout << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cout << '{';
__print(x.first);
cout << ',';
__print(x.second);
cout << '}';
}
template <typename T>
void __print(const T &x) {
int first = 0;
cout << '{';
for (auto &i : x) cout << (first++ ? "," : ""), __print(i);
cout << "}";
}
void _print() { cout << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
template <class T>
void remdup(vector<T> &v) {
sort((v).begin(), (v).end());
v.erase(unique((v).begin(), (v).end()), end(v));
}
template <typename T>
struct cmp {
bool operator()(const T &p1, const T &p2) {}
};
const long long N = 3e5 + 100;
const long long mod = 998244353;
const long long X = 1e5 + 100;
const long long Y = 1e9 + 100;
long long power(long long x, long long n) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % mod;
x = (x * x) % mod;
n = n / 2;
}
return result;
}
long long pinverse(long long A, long long M) { return power(A, M - 2); }
long long fact[N], invfact[N];
void precompute() {
fact[0] = fact[1] = 1;
for (long long i = (2); i < (N); ++i) fact[i] = (fact[i - 1] * i) % mod;
invfact[N - 1] = pinverse(fact[N - 1], mod);
for (long long i = (N - 2); i >= (0); --i)
invfact[i] = (invfact[i + 1] * (i + 1)) % mod;
}
long long nCr(long long x, long long y) {
if (y > x) return 0;
long long num = fact[x];
num = (num * invfact[y]) % mod;
num = (num * invfact[x - y]) % mod;
return num;
}
int main() {
long long t = 1;
precompute();
while (t--) {
long long n;
cin >> n;
vector<long long> a(2 * n);
for (long long i = (0); i < (2 * n); ++i) cin >> a[i];
sort((a).begin(), (a).end());
long long sum = 0;
for (long long i = (0); i < (2 * n); ++i) sum += ((i < n) ? -a[i] : a[i]);
sum %= mod;
sum *= nCr(2 * n, n);
sum %= mod;
cout << sum << "\n";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
vector<vector<int> > lca;
int n;
int timer;
vector<int> tin, tout;
vector<vector<int> > adj;
map<pair<int, int>, int> hsh;
void dfs(int cur, int par) {
tin[cur] = ++timer;
lca[cur][0] = par;
for (int i = 1; i <= 20; i++) lca[cur][i] = lca[lca[cur][i - 1]][i - 1];
for (auto& first : adj[cur]) {
if (first == par) continue;
dfs(first, cur);
}
tout[cur] = ++timer;
}
bool isanc(int u, int v) { return tin[u] <= tin[v] and tout[u] >= tout[v]; }
int getlca(int u, int v) {
if (isanc(u, v)) {
return u;
}
if (isanc(v, u)) {
return v;
}
for (int i = 20; i >= 0; i--) {
if (!isanc(lca[u][i], v)) u = lca[u][i];
}
return lca[u][0];
}
void pre() {
tin.resize(n);
tout.resize(n);
timer = 0;
lca.assign(n, vector<int>(21, 0));
dfs(0, 0);
}
void dfs1(int cur, int par, vector<int>& ret, vector<int>& vals) {
for (auto& first : adj[cur]) {
if (first == par) continue;
dfs1(first, cur, ret, vals);
ret[hsh[make_pair(cur, first)]] = vals[first];
vals[cur] += vals[first];
}
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> n;
adj.resize(n);
vector<int> vals(n, 0);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
hsh[make_pair(u, v)] = i;
hsh[make_pair(v, u)] = i;
}
pre();
int k;
cin >> k;
vector<int> ret(n - 1);
for (int i = 0; i < k; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
int v = getlca(a, b);
vals[a]++;
vals[b]++;
vals[v] -= 2;
}
dfs1(0, -1, ret, vals);
for (int i = 0; i < n - 1; i++) {
cout << ret[i] << " ";
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class free>
inline void Min(free&, free);
template <class free>
inline void Max(free&, free);
struct inter {
int l, r, id, id1;
inline void operator^=(const inter x) { Max(l, x.l), Min(r, x.r); }
inline inter operator^(const inter x) { return {max(l, x.l), min(r, x.r)}; }
inline bool operator<(const inter& x) const { return l < x.l; }
} I[200050], I1[200050][2], I2[200050];
struct point {
int next, to;
} ar[200050];
multiset<int> S;
bool ans[200050], is[200050];
int head[200050], art, a[200050], at, b1, b2, b3, b4, I2t, t, T, n, m;
inline bool dfs(int, int);
inline void read(int&), link(int, int), deal(inter, inter), deal1(inter, inter),
deal2(inter, inter), deal3(int, int);
int main() {
read(t), read(T), read(n), read(m);
for (int i(1); i <= n; ++i)
read(I[i].l), read(I[i].r), I1[i][0] = {0, 0x3f3f3f3f, i, 0},
I1[i][1] = {0, 0x3f3f3f3f, i, 1};
for (int i(1), u, v; i <= m; ++i) read(u), read(v), link(u, v);
memset(a, -1, sizeof(a));
for (int i(1); i <= n; ++i)
if (!~a[i] && dfs((++at, i), 0)) return puts("IMPOSSIBLE"), 0;
for (int i(1), j; i <= at; ++i)
for (j = 0; j < 2; ++j) {
if (!b1 || I1[i][j].l > I1[b1][b2].l) b1 = i, b2 = j;
if (!b3 || I1[i][j].r < I1[b3][b4].r) b3 = i, b4 = j;
}
if (b1 ^ b3) {
ans[b1] = b2, ans[b3] = b4;
deal(I1[b1][b2] ^ I1[b3][b4], I1[b1][b2 ^ 1] ^ I1[b3][b4 ^ 1]);
ans[b3] ^= 1;
deal2(I1[b1][b2] ^ I1[b3][b4 ^ 1], I1[b1][b2 ^ 1] ^ I1[b3][b4]);
} else {
if (b2 ^ b4)
ans[b1] = b2, deal2(I1[b1][b2], I1[b3][b4]);
else
ans[b1] = b2, deal(I1[b1][b2], I1[b1][b2 ^ 1]);
}
return puts("IMPOSSIBLE"), 0;
}
inline void deal3(int x, int y) {
printf("POSSIBLE\n%d %d\n", x, y);
for (int i(1); i <= n; ++i) putchar(ans[I[i].id] ^ a[i] ? 50 : 49);
exit(0);
}
inline void deal2(inter a, inter b) {
I2t = 0, S.clear(), memset(is, 0, sizeof(is)), S.insert({0x3f3f3f3f});
for (int i(1), j; i <= at; ++i)
if (i ^ b1 && i ^ b3) {
for (j = 0; j < 2; ++j) I2[++I2t] = I1[i][j];
if (I1[i][0].r > I1[i][1].r)
ans[i] = 0, S.insert(I1[i][0].r);
else
ans[i] = 1, S.insert({I1[i][1].r});
}
if (!I2t) deal1(a, b);
sort(I2 + 1, I2 + I2t + 1);
for (int i(I2t), j, k; i; i = j) {
for (j = i; j && I2[j].l == I2[i].l; --j)
;
bool pd(false);
for (k = i; k > j; --k)
if (is[I2[k].id])
pd = 1, deal1(a, b);
else {
inter b1(I1[I2[k].id][I2[k].id1 ^ 1]);
bool temp(ans[b1.id]);
pd |= I2[k].l == b1.l;
S.erase(S.find(max(I2[k].r, b1.r))), ans[b1.id] = b1.id1;
deal1(a ^ (inter){0, *S.begin()} ^ b1, b ^ I2[k]);
S.insert(max(I2[k].r, b1.r)), ans[b1.id] = temp;
}
if (pd) return;
for (k = i; k > j; --k)
if (!is[I2[k].id]) {
inter b1(I1[I2[k].id][I2[k].id1 ^ 1]);
S.erase(S.find(max(I2[k].r, b1.r)));
ans[b1.id] = I2[k].id1, a ^= I2[k], b ^= b1;
is[b1.id] = 1;
}
}
}
inline void deal1(inter a, inter b) {
if (a.l > a.r || b.l > b.r) return;
if (t - a.l <= b.l && b.l <= T - a.l) deal3(a.l, b.l);
if (t - a.l <= b.r && b.r <= T - a.l) deal3(a.l, b.r);
if (t - a.r <= b.l && b.l <= T - a.r) deal3(a.r, b.l);
if (t - a.r <= b.r && b.r <= T - a.r) deal3(a.r, b.r);
int x(a.l), y(t - x);
if (b.l <= y && y <= b.r) deal3(x, y);
x = a.r, y = t - x;
if (b.l <= y && y <= b.r) deal3(x, y);
y = b.l, x = t - y;
if (a.l <= x && x <= a.r) deal3(x, y);
y = b.r, x = t - y;
if (a.l <= x && x <= a.r) deal3(x, y);
}
inline void deal(inter a, inter b) {
I2t = 0, S.clear(), memset(is, 0, sizeof(is)), S.insert(0x3f3f3f3f);
for (int i(1), j; i <= at; ++i)
if (i ^ b1 && i ^ b3) {
for (j = 0; j < 2; ++j) I2[++I2t] = I1[i][j];
if (I1[i][0].r > I1[i][1].r)
S.insert(I1[i][0].r), ans[i] = 1;
else
S.insert(I1[i][1].r), ans[i] = 0;
}
if (!I2t) deal1(a, b);
sort(I2 + 1, I2 + I2t + 1);
for (int i(I2t), j, k; i; i = j) {
for (j = i; j && I2[j].l == I2[i].l; --j)
;
bool pd(false);
for (k = i; k > j; --k)
if (is[I2[k].id])
pd = 1, deal1(a, b ^ (inter){0, *S.begin()});
else {
bool temp(ans[I2[k].id]);
inter& b1(I1[I2[k].id][I2[k].id1 ^ 1]);
pd |= b1.r == I2[k].r;
ans[I2[k].id] = b1.id1, S.erase(S.find(max(I2[k].r, b1.r)));
deal1(a, b ^ (inter){0, *S.begin()} ^ I2[k]);
ans[I2[k].id] = temp, S.insert(max(I2[k].r, b1.r));
}
if (pd) return;
for (k = i; k > j; --k)
if (!is[I2[k].id]) {
inter& b1(I1[I2[k].id][I2[k].id1 ^ 1]);
b ^= b1;
is[I2[k].id] = 1, S.erase(S.find(max(I2[k].r, b1.r)));
}
}
}
template <class free>
inline void Min(free& x, free y) {
x = x < y ? x : y;
}
template <class free>
inline void Max(free& x, free y) {
x = x > y ? x : y;
}
inline bool dfs(int x, int c) {
I1[I[x].id = at][a[x] = c] ^= I[x];
for (int i(head[x]), i1; i; i = ar[i].next)
if (!~a[i1 = ar[i].to] && dfs(i1, c ^ 1))
return true;
else if (a[i1] == c)
return true;
return false;
}
inline void link(int u, int v) {
ar[++art] = {head[u], v}, head[u] = art;
ar[++art] = {head[v], u}, head[v] = art;
}
inline void read(int& x) {
x ^= x;
register char c;
while (c = getchar(), c < '0' || c > '9')
;
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
void swap(int &x, int &y) {
int temp = x;
x = y;
y = temp;
}
int main() {
int arr[104], n, i, j;
cin >> n;
for (i = 0; i < n; i++) cin >> arr[i];
for (i = 0; i < n - 1; i++)
for (j = 0; j < n - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
cout << j + 1 << " " << j + 2 << endl;
swap(arr[j], arr[j + 1]);
}
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int N=3e2+1e1+7,P=998244353;
int n;
vector<int>G[N];
int r;
int f[2][N][N],dep[N];
int g[2][N];
void inc(int &a,int b)
{
a+=b;
a>=P?a-=P:0;
}
void dfs(int x,int fa)
{
dep[x]=0;
for(int i=1;i<=n;i++)
f[0][x][i]=f[1][x][i]=0;
f[0][x][0]=f[1][x][0]=1;
for(auto v:G[x])
{
if(v==fa)
continue;
dfs(v,x);
}
for(auto v:G[x])
{
if(v==fa)
continue;
for(int i=0;i<=max(dep[x],dep[v]+1);i++)
g[0][i]=g[1][i]=0;
for(int i=0;i<=min(dep[x],r);i++)
for(int j=0;j<=min(dep[v],r);j++)
{
if(i+j+1<=r)
{
inc(g[1][i],f[1][x][i]*f[0][v][j]%P);
inc(g[1][j+1],f[0][x][i]*f[1][v][j]%P);
}
else
{
inc(g[0][j+1],f[1][x][i]*f[0][v][j]%P);
inc(g[0][i],f[0][x][i]*f[1][v][j]%P);
}
if(j+1<r&&i<r)
inc(g[0][max(i,j+1)],f[0][x][i]*f[0][v][j]%P);
inc(g[1][min(i,j+1)],f[1][x][i]*f[1][v][j]%P);
}
dep[x]=max(dep[x],dep[v]+1);
for(int i=0;i<=dep[x];i++)
f[0][x][i]=g[0][i],f[1][x][i]=g[1][i];
}
}
int cnt[N];
signed main()
{
scanf("%lld",&n);
for(int i=1;i<n;i++)
{
int u,v;
scanf("%lld%lld",&u,&v);
G[u].push_back(v);
G[v].push_back(u);
}
for(int i=0;i<=n;i++)
{
r=i;
dfs(1,0);
for(int j=0;j<=n;j++)
inc(cnt[i],f[1][1][j]);
}
for(int i=n;i>=1;i--)
inc(cnt[i],P-cnt[i-1]);
int ans=0;
for(int i=0;i<=n;i++)
inc(ans,cnt[i]*(i-1)%P);
ans=(ans+n)%P;
for(int i=1;i<=n;i++)
ans=(ans*(P+1)/2)%P;
printf("%lld\n",ans);
} | 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1100;
int n;
int a;
double minv = 10.0, maxv = 1e8;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
double v1 = a * 10.0 / i;
if (minv < v1) minv = v1;
double v2 = (a + 1) * 10.0 / i;
if (v2 < maxv) maxv = v2;
}
minv += (1e-9);
maxv -= (1e-9);
double a1 = minv * (n + 1) - a * 10;
double a2 = maxv * (n + 1) - a * 10;
if (int(a2 / 10.0) > int(a1 / 10.0)) {
puts("not unique");
} else {
puts("unique");
int ans = a1 / 10.0 + a;
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ss[60000];
long long sum = 0;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ss[i];
sum = ss[i] + sum;
}
long long mov = 0;
long long bi = sum / n;
for (int i = 0; i < n - 1; i++) {
mov = mov + fabs(ss[i] - bi);
if (ss[i] != bi) {
ss[i + 1] = ss[i + 1] + ss[i] - bi;
ss[i] = bi;
}
}
cout << mov;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int h[100];
int a[100];
int main(int argc, char const *argv[]) {
string hName, aName;
cin >> hName >> aName;
int count;
cin >> count;
for (int i = 0; i < count; i++) {
int min, numb;
char c, s, color;
cin >> min >> c >> numb >> color;
if (c == 'h') {
if ((h[numb] < 2) &&
((color == 'r') || ((color == 'y') && (h[numb] == 1)))) {
h[numb] = 2;
cout << hName << " " << numb << " " << min << endl;
} else if ((color == 'y') && (h[numb] < 2)) {
h[numb]++;
}
} else {
if ((a[numb] < 2) &&
((color == 'r') || ((color == 'y') && (a[numb] == 1)))) {
a[numb] = 2;
cout << aName << " " << numb << " " << min << endl;
} else if ((color == 'y') && (a[numb] < 2)) {
a[numb]++;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int perm[6];
vector<string> an[750];
int cnt;
string ss[6];
void check() {
int s1 = perm[0], s2 = perm[1], s3 = perm[2];
int s4 = perm[3], s5 = perm[4], s6 = perm[5];
if (ss[s1][0] == ss[s2][0] && ss[s3][0] == ss[s1][ss[s1].size() - 1] &&
ss[s3].size() >= ss[s2].size() + 2 &&
ss[s4][0] == ss[s2][ss[s2].size() - 1] &&
ss[s4].size() >= ss[s1].size() + 2 &&
ss[s4][ss[s1].size() - 1] == ss[s3][ss[s2].size() - 1] &&
ss[s5].size() == ss[s3].size() - ss[s2].size() + 1 &&
ss[s5][0] == ss[s4][ss[s4].size() - 1] &&
ss[s6].size() == ss[s4].size() - ss[s1].size() + 1 &&
ss[s6][0] == ss[s3][ss[s3].size() - 1] &&
ss[s6][ss[s6].size() - 1] == ss[s5][ss[s5].size() - 1]) {
an[cnt].resize(ss[s3].size());
for (int i = 0; i < ss[s3].size(); ++i) {
an[cnt][i].resize(ss[s4].size(), '.');
}
for (int j = 0; j < ss[s1].size(); ++j) an[cnt][0][j] = ss[s1][j];
for (int j = 0; j < ss[s2].size(); ++j) an[cnt][j][0] = ss[s2][j];
for (int j = 0; j < ss[s3].size(); ++j)
an[cnt][j][ss[s1].size() - 1] = ss[s3][j];
for (int j = 0; j < ss[s4].size(); ++j)
an[cnt][ss[s2].size() - 1][j] = ss[s4][j];
for (int j = 0; j < ss[s5].size(); ++j)
an[cnt][ss[s2].size() - 1 + j][ss[s4].size() - 1] = ss[s5][j];
for (int j = 0; j < ss[s6].size(); ++j)
an[cnt][ss[s3].size() - 1][ss[s1].size() - 1 + j] = ss[s6][j];
cnt++;
}
}
void sol(int i) {
if (i == 6) {
check();
} else {
for (int j = i; j < 6; ++j) {
swap(perm[i], perm[j]);
sol(i + 1);
swap(perm[i], perm[j]);
}
}
}
int main() {
for (int i = 0; i < 6; ++i) {
cin >> ss[i];
perm[i] = i;
}
sol(0);
std::sort(an, an + cnt, [](const vector<string> &a, const vector<string> &b) {
int row = std::min(a.size(), b.size());
for (int i = 0; i < row; ++i) {
if (a[i] != b[i]) return a[i] < b[i];
}
return a.size() < b.size();
});
if (!cnt)
printf("Impossible\n");
else {
for (int i = 0; i < an[0].size(); ++i) cout << an[0][i] << endl;
}
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.