solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MX = 2e5 + 7;
long long n;
int main() {
cin >> n;
int flag = 0;
for (int i = 2; (long long)i * i <= n; i++) {
if (n % i == 0) {
flag = i;
break;
}
}
if (!flag) {
puts("1");
return 0;
}
if (n % 2 == 0)
cout << n / 2 << endl;
else {
n -= flag;
cout << n / 2 + 1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline bool equal(double _x, double _y) {
return _x > _y - 1e-9 && _x < _y + 1e-9;
}
int a[25][5005];
int main() {
int n, k, q, x;
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[1][i]);
for (int j = 2; j <= k; j++) a[j][i] = a[1][i] * j;
}
scanf("%d", &q);
while (q--) {
scanf("%d", &x);
int ans = 1e9;
for (int i = 1; i <= k; i++) {
for (int j = 0; j < n; j++) {
for (int l = 0; l + i <= k; l++) {
if (a[l][lower_bound(a[l], a[l] + n, x - a[i][j]) - a[l]] + a[i][j] ==
x)
ans = min(ans, i + l);
}
}
}
if (ans == 1e9)
puts("-1");
else
printf("%d\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
int n;
cin >> n;
int i, j;
int a[n];
std::map<int, int> map;
for (i = 0; i < n; i++) {
cin >> a[i];
map[a[i]]++;
}
int dist = map.size();
std::vector<int> v;
for (auto it = map.begin(); it != map.end(); it++) {
int m;
m = it->second;
v.push_back(m);
}
if (dist >= 2) {
int valance = 0;
int mx = v[0], sz;
sz = v.size();
sort(v.begin(), v.end());
valance = v[sz - 1];
mx = v[sz - 1];
if ((n - mx) >= (mx - 1))
cout << "YES" << endl;
else
cout << "NO" << endl;
} else {
if (v[0] == 1)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
long long n, m, ans = 0;
int main() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) ans += (i + m) / 5 - i / 5;
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int n, m, t[500005], rk[500005];
int vis[500005];
int cmp(int a, int b) { return t[a] < t[b]; }
std::vector<int> E[500005];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
E[u].push_back(v);
E[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &t[i]);
rk[i] = i;
}
for (int u = 1; u <= n; ++u) {
int mex = 1;
for (int i = 1; i <= E[u].size() + 1; ++i) vis[i] = 0;
for (int v : E[u]) {
if (t[v] == t[u]) {
printf("-1");
return 0;
}
vis[t[v]] = 1;
}
while (vis[mex]) mex++;
if (mex != t[u]) {
puts("-1");
return 0;
}
}
std::sort(rk + 1, rk + n + 1, cmp);
for (int i = 1; i <= n; ++i) printf("%d ", rk[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void _R(T &x) {
cin >> x;
}
void _R(int &x) { scanf("%d", &x); }
void _R(int64_t &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template <class T, class... U>
void R(T &head, U &...tail) {
_R(head);
R(tail...);
}
template <class T>
void _W(const T &x) {
cout << x;
}
void _W(const int &x) { printf("%d", x); }
void _W(const int64_t &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template <class T, class U>
void _W(const pair<T, U> &x) {
_W(x.first);
putchar(' ');
_W(x.second);
}
template <class T>
void _W(const vector<T> &x) {
for (auto i = x.begin(); i != x.end(); _W(*i++))
if (i != x.cbegin()) putchar(' ');
}
void W() {}
template <class T, class... U>
void W(const T &head, const U &...tail) {
_W(head);
putchar(sizeof...(tail) ? ' ' : '\n');
W(tail...);
}
template <class T, class... U>
void DEBUG(const T &head, const U &...tail) {}
int MOD = 1e9 + 7;
void ADD(int64_t &x, int64_t v) {
x = (x + v) % MOD;
if (x < 0) x += MOD;
}
const int SIZE = 1e6 + 10;
char s[SIZE];
pair<int, int> dp[SIZE][2], dp2[SIZE][3];
pair<int, int> better(pair<int, int> x, pair<int, int> y) {
if (make_pair(x.first, -x.second) > make_pair(y.first, -y.second)) return x;
return y;
}
pair<int, int> add(pair<int, int> x, pair<int, int> y) {
return make_pair(x.first + y.first, x.second + y.second);
}
int main() {
int n, m;
R(n);
scanf("%s", (s + 1));
R(m);
int an = 0;
if (m == 1) {
for (int i = (1); i <= (n); ++i) {
if (s[i] == '?') an++;
}
W(an);
} else {
for (int i = (1); i <= (n); ++i) {
if (s[i] != 'b') {
dp[i][i & 1] = dp[i - 1][i & 1];
dp[i][i & 1].first++;
dp[i][i & 1].second += (s[i] == '?');
} else {
dp[i][i & 1] = make_pair(0, 0);
}
if (s[i] != 'a') {
dp[i][(i & 1) ^ 1] = dp[i - 1][(i & 1) ^ 1];
dp[i][(i & 1) ^ 1].first++;
dp[i][(i & 1) ^ 1].second += (s[i] == '?');
} else {
dp[i][(i & 1) ^ 1] = make_pair(0, 0);
}
}
dp2[0][0] = dp2[0][1] = make_pair(-MOD, 0);
for (int i = (1); i <= (n); ++i) {
int me = i & 1;
dp2[i][0] = make_pair(-MOD, 0);
dp2[i][1] = make_pair(-MOD, 1);
if (s[i] != 'b' && 1 == m % 2) {
if (dp[i][me].first >= m) {
dp2[i][me] = better(
dp2[i][me],
add(dp2[i - m][2],
make_pair(1, dp[i][me].second - dp[i - m][me].second)));
}
}
me = (i & 1) ^ 1;
if (s[i] != 'a' && 0 == m % 2) {
if (dp[i][me].first >= m) {
dp2[i][me] = better(
dp2[i][me],
add(dp2[i - m][2],
make_pair(1, dp[i][me].second - dp[i - m][me].second)));
}
}
dp2[i][2] = better(better(dp2[i - 1][2], dp2[i][0]), dp2[i][1]);
}
an = dp2[n][2].second;
W(an);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, mod = 1e9 + 7;
int n, t, w, x[N], y[N], a[N], b[N], p[N], f[N], s[N], d[N];
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &x[i], &y[i]), a[++t] = x[i], b[++w] = y[i];
sort(a + 1, a + 1 + t), t = unique(a + 1, a + 1 + n) - a - 1,
sort(b + 1, b + 1 + w),
w = unique(b + 1, b + 1 + n) - b - 1;
p[0] = 1;
for (int i = 1; i <= t + w; i++)
s[i] = 1, f[i] = i, p[i] = p[i - 1] * 2 % mod;
for (int i = 1; i <= n; i++)
x[i] = lower_bound(a + 1, a + 1 + t, x[i]) - a,
y[i] = lower_bound(b + 1, b + 1 + w, y[i]) - b;
for (int i = 1; i <= n; i++) {
int xx = find(x[i]), yy = find(y[i] + t);
if (xx != yy)
f[xx] = yy, s[yy] += s[xx], d[yy] += d[xx] + 1;
else
d[xx]++;
}
long long ans = 1;
for (int i = 1; i <= t + w; i++)
if (find(i) == i)
d[i] + 1 == s[i] ? (ans *= p[s[i]] - 1) %= mod : (ans *= p[s[i]]) %= mod;
return printf("%lld\n", ans), 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, h;
while (cin >> n >> m >> h) {
int i, tot = 0, sh, tem;
for (i = 1; i <= m; i++) {
cin >> tem;
tot += tem;
if (i == h) sh = tem;
}
if (tot - 1 < n - 1) {
printf("-1.0\n");
continue;
}
if (tot - sh < n - 1) {
printf("1.0\n");
continue;
}
double ans = 1.0;
int mult = tot - sh - n + 2;
for (i = tot - n + 1; i <= tot - 1; i++) {
if (mult <= tot - sh) ans *= mult;
ans /= i;
mult++;
}
while (mult <= tot - sh) {
ans *= mult;
mult++;
}
printf("%.12lf\n", 1.0 - ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
long long n = 1, n2, a[200010], sum[200010];
vector<long long> dat[800010];
struct stane {
string val;
bool isneg;
} ans;
void INIT(int k, int lb, int ub) {
if (lb == ub) return;
INIT(k * 2 + 1, lb, (lb + ub) / 2);
INIT(k * 2 + 2, (lb + ub) / 2 + 1, ub);
int i = 0, j = 0;
while (i < dat[k * 2 + 1].size() || j < dat[k * 2 + 2].size()) {
if (i == dat[k * 2 + 1].size())
dat[k].push_back(dat[k * 2 + 2][j++]);
else if (j == dat[k * 2 + 2].size())
dat[k].push_back(dat[k * 2 + 1][i++]);
else if (dat[k * 2 + 1][i] < dat[k * 2 + 2][j])
dat[k].push_back(dat[k * 2 + 1][i++]);
else
dat[k].push_back(dat[k * 2 + 2][j++]);
}
}
long long query(int k, int lb, int ub, int tlb, int tub, long long val) {
if (tlb > tub || ub < tlb || tub < lb) return 0;
if (tlb <= lb && ub <= tub)
return lower_bound(dat[k].begin(), dat[k].end(), val + 1) -
lower_bound(dat[k].begin(), dat[k].end(), val);
return query(k * 2 + 1, lb, (lb + ub) / 2, tlb, tub, val) +
query(k * 2 + 2, (lb + ub) / 2 + 1, ub, tlb, tub, val);
}
stane myitoa(long long x) {
stane ret;
ret.val = "";
ret.isneg = (x < 0 ? true : false);
x = abs(x);
while (x > 0) {
ret.val.push_back(x % 10 + '0');
x /= 10;
}
if (ret.val.size() == 0) ret.val.push_back('0');
return ret;
}
bool larger(string a, string b) {
if (a.size() > b.size()) return true;
if (b.size() > a.size()) return false;
for (int i = a.size() - 1; i >= 0; i--)
if (a[i] != b[i]) return a[i] > b[i];
return false;
}
string realadd(string a, string b) {
string ret = "";
int jw = 0;
while (b.size() < a.size()) b.push_back('0');
for (int i = 0; i < a.size(); i++) {
ret.push_back((a[i] + b[i] - '0' - '0' + jw) % 10 + '0');
jw = (a[i] + b[i] - '0' - '0' + jw) / 10;
}
if (jw > 0) ret.push_back(jw + '0');
return ret;
}
string minu(string a, string b) {
string ret = "";
int tw = 0;
while (b.size() < a.size()) b.push_back('0');
for (int i = 0; i < b.size(); i++) {
if (a[i] + '0' - b[i] - tw < '0') {
ret.push_back(a[i] + 10 - b[i] - tw + '0');
tw = 1;
} else {
ret.push_back(a[i] - b[i] - tw + '0');
tw = 0;
}
}
while (ret[ret.size() - 1] == '0') ret.pop_back();
return ret;
}
stane add(stane a, stane b) {
if (larger(b.val, a.val)) {
swap(a.val, b.val);
swap(a.isneg, b.isneg);
}
stane ret;
if (a.isneg == b.isneg) {
ret.isneg = a.isneg;
ret.val = realadd(a.val, b.val);
} else if (a.isneg) {
ret.isneg = true;
ret.val = minu(a.val, b.val);
} else {
ret.isneg = false;
ret.val = minu(a.val, b.val);
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n2;
while (n < n2) n *= 2;
for (int i = 0; i < n2; i++) {
cin >> a[i];
dat[i + n - 1].push_back(a[i]);
}
INIT(0, 0, n - 1);
for (int i = n2 - 1; i >= 0; i--) sum[i] = sum[i + 1] + a[i];
ans.val = "0";
ans.isneg = false;
for (int i = 0; i < n2 - 1; i++) {
long long numa = query(0, 0, n - 1, i + 1, n2 - 1, a[i] - 1),
numb = query(0, 0, n - 1, i + 1, n2 - 1, a[i]),
numc = query(0, 0, n - 1, i + 1, n2 - 1, a[i] + 1);
ans = add(ans, myitoa(sum[i + 1] - numa * (a[i] - 1) - numb * a[i] -
numc * (a[i] + 1) -
a[i] * (n2 - i - 1 - numa - numb - numc)));
}
reverse(ans.val.begin(), ans.val.end());
if (ans.val.size() == 0) {
ans.val.push_back('0');
ans.isneg = false;
}
cout << (ans.isneg ? "-" : "") << ans.val << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long double PI = acos(-1);
const long long INF = LLONG_MAX;
const long long M = 1e5 + 10;
const long long mod = 1e9 + 7;
const long double eps = 1e-9;
void read(long long t[], long long n) {
for (int i = 1; i <= n; ++i) {
cin >> t[i];
}
return;
}
vector<pair<long long, long long> > G[M];
long long V, E;
bool vis[M] = {false};
bool vis2[M] = {false};
long long dist[M];
long long dist2[M];
void dijkestra(vector<pair<long long, long long> > G[M], long long scr) {
for (int i = 1; i <= V; i++) dist[i] = INF;
dist[scr] = 0;
vis[scr] = true;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
q.push({0, scr});
while (!q.empty()) {
long long a = q.top().second;
vis[a] = 1;
if (dist[a] < q.top().first) {
q.pop();
continue;
}
q.pop();
for (auto b : G[a]) {
if (dist[a] + b.second < dist[b.first] && !vis[b.first]) {
dist[b.first] = dist[a] + b.second;
q.push({dist[b.first], b.first});
}
}
}
}
void dijkestra2(vector<pair<long long, long long> > G[M], long long scr) {
for (int i = 1; i <= V; i++) dist2[i] = INF;
dist2[scr] = 0;
vis2[scr] = true;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
q.push({0, scr});
while (!q.empty()) {
long long a = q.top().second;
vis2[a] = 1;
if (dist2[a] < q.top().first) {
q.pop();
continue;
}
q.pop();
for (auto b : G[a]) {
if (dist2[a] + b.second < dist2[b.first] && !vis2[b.first]) {
dist2[b.first] = dist2[a] + b.second;
q.push({dist2[b.first], b.first});
}
}
}
}
long long ad1[1000 + 10][1000 + 10], ad2[1000 + 10][1000 + 10];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long start, go;
cin >> V >> E >> start >> go;
for (int i = 1; i <= E; ++i) {
long long a1, a2;
cin >> a1 >> a2;
G[a1].push_back(make_pair(a2, 1));
G[a2].push_back(make_pair(a1, 1));
ad1[a1][a2] = 1;
ad1[a2][a1] = 1;
}
dijkestra(G, start);
dijkestra2(G, go);
long long D = dist[go];
long long ans = 0;
for (int i = 1; i <= V; ++i) {
for (int j = i + 1; j <= V; ++j) {
if (ad1[i][j] == 0 &&
!(dist[i] + dist2[j] + 1 < D || dist[j] + dist2[i] + 1 < D))
ans++;
}
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, p[2][N], sgt[2][4 * N], ord[N], sgtAns[4 * N], ans[N];
void build(int sgt[], int tl = 0, int tr = n - 1, int u = 1) {
if (tl == tr) {
sgt[u] = 1;
return;
}
int tm = (tl + tr) / 2;
build(sgt, tl, tm, 2 * u);
build(sgt, tm + 1, tr, 2 * u + 1);
sgt[u] = sgt[2 * u] + sgt[2 * u + 1];
}
void update(int sgt[], int pos, int value, int tl = 0, int tr = n - 1,
int u = 1) {
if (tl == tr) {
sgt[u] = value;
return;
}
int tm = (tl + tr) / 2;
if (pos <= tm)
update(sgt, pos, value, tl, tm, 2 * u);
else
update(sgt, pos, value, tm + 1, tr, 2 * u + 1);
sgt[u] = sgt[2 * u] + sgt[2 * u + 1];
}
int sum(int sgt[], int l, int r, int tl = 0, int tr = n - 1, int u = 1) {
if (l > r) return 0;
if (tl == l && tr == r) return sgt[u];
int tm = (tl + tr) / 2;
return sum(sgt, l, min(tm, r), tl, tm, 2 * u) +
sum(sgt, max(tm + 1, l), r, tm + 1, tr, 2 * u + 1);
}
int pos(int sgt[], int prefixSum, int tl = 0, int tr = n - 1, int u = 1) {
if (tl == tr) {
return tr;
}
int tm = (tl + tr) / 2;
if (prefixSum <= sgt[2 * u])
return pos(sgt, prefixSum, tl, tm, 2 * u);
else
return pos(sgt, prefixSum - sgt[2 * u], tm + 1, tr, 2 * u + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < n; ++j) cin >> p[i][j];
build(sgt[i]);
}
for (int i = 0; i < n; ++i) {
ord[i] = 0;
for (int j = 0; j < 2; ++j) {
ord[i] += sum(sgt[j], 0, p[j][i] - 1);
update(sgt[j], p[j][i], 0);
}
}
int d = 0;
for (int i = n - 2; i >= 0; --i) {
d += ord[i];
ord[i] = d % (n - i);
d /= (n - i);
}
build(sgtAns);
for (int i = 0; i < n; ++i) {
ans[i] = pos(sgtAns, ord[i] + 1);
update(sgtAns, ans[i], 0);
}
for (int i = 0; i < n; ++i) cout << ans[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long a;
cin >> a;
long long b = -1;
string s;
cin >> s;
if (s != "R") {
b = 0;
for (long long i = 0; i < s.length(); i++) {
b *= 10;
b += s[i] - '0';
}
}
cin >> s;
long long num = 0;
for (long long i = 0; i < s.length(); i++) {
num *= a;
if (isalpha(s[i]))
num += s[i] - 'A' + 10;
else
num += s[i] - '0';
}
if (b == -1) {
string r[] = {"M", "CM", "D", "CD", "C", "XC", "L",
"XL", "X", "IX", "V", "IV", "I"};
long long n[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
string ans = "";
while (num > 0) {
for (long long i = 0; i < 13; i++)
if (num >= n[i]) {
num -= n[i];
ans += r[i];
break;
}
}
cout << ans;
} else {
if (num == 0) cout << 0;
string ans = "";
while (num > 0) {
long long q = num % b;
num /= b;
if (q >= 10)
ans += 'A' + q - 10;
else
ans += q + '0';
}
reverse(ans.begin(), ans.end());
cout << ans;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
string s;
int a, b;
int main() {
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'o')
a++;
else
b++;
}
if (a == 0)
cout << "YES" << endl;
else if (b % a == 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, ans[1000005];
char s[1000005];
struct Hash {
int mod = 998244353, h[1000005], pow[1000005];
void build(char s[], int len) {
pow[0] = 1;
for (int i = 1; i <= len; i++) pow[i] = 26ll * pow[i - 1] % mod;
for (int i = 1; i <= len; i++) h[i] = (26ll * h[i - 1] + s[i] - 97) % mod;
}
int get(int l, int len) {
if (len <= 0) return 0;
return 1ll * (h[l + len - 1] - 1ll * h[l - 1] * pow[len] % mod + mod) % mod;
}
} h;
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
h.build(s, n);
ans[(n + 3) >> 1] = -1;
for (int i = (n + 1) >> 1, l = i, r = i + ((n & 1) ^ 1); i; i--, --l, ++r) {
ans[i] = ans[i + 1] + 2;
while (ans[i] >= (r - l + 1) ||
h.get(l, ans[i]) != h.get(r - ans[i] + 1, ans[i]))
ans[i] -= 2;
}
for (int i = 1; i <= ((n + 1) >> 1); i++) printf("%d ", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
ifstream filein("practice.inp");
ofstream fileout("practice.out");
int t, n, a[5001];
void input() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
}
string xl() {
for (int i = 1; i <= n; ++i) {
if (a[a[a[i]]] == i) return "YES";
}
return "NO";
}
int main() {
input();
cout << xl();
filein.close();
fileout.close();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 10e4 + 5;
int main() {
int n;
cin >> n;
string string1 = "";
int maxi = 0;
for (int i = 0; i < n; i++) {
char a;
cin >> a;
if (a == '1') maxi++;
string1 += a;
}
vector<pair<int, int>> v;
for (int i = 0; i < n; i++) {
pair<int, int> p;
cin >> p.first;
cin >> p.second;
v.push_back(p);
}
int count = maxi;
for (int i = 0; i < MAX; i++) {
for (int j = 0; j < n; j++) {
if (i >= v[j].second and (i - v[j].second) % v[j].first == 0) {
if (string1[j] == '0') {
string1[j] = '1';
count++;
} else {
string1[j] = '0';
count--;
}
}
}
maxi = max(maxi, count);
if (maxi == string1.length()) {
break;
}
}
cout << maxi;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long LLINF = 8e18;
const int MOD = 1e9 + 7;
const int INF = 2e9;
const int N = 5000;
int n, m, mx, ans, tmx;
int a[N], b[N], cnt[N], mn1[N], mn2[N];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
fill(mn1, mn1 + n, INF);
fill(mn2, mn2 + n, INF);
while (m--) {
int x, y;
cin >> x >> y;
x--;
y--;
if (y < x) y += n;
if (y < mn1[x]) {
mn2[x] = mn1[x];
mn1[x] = y;
} else if (y < mn2[x]) {
mn2[x] = y;
}
cnt[x]++;
mx = max(mx, cnt[x]);
}
for (int i = 0; i < n; i++) {
ans = (mx - 1) * n;
tmx = 0;
for (int j = 0; j < n; j++) {
if (mn1[j] != INF && cnt[j] == mx) tmx = max(tmx, mn1[j]);
if (mn1[j] != INF && cnt[j] == mx - 1) tmx = max(tmx, mn1[j] - n);
}
ans += tmx - i;
if (mn1[i] != INF) mn1[i] += n;
if (mn2[i] != INF) mn2[i] += n;
cout << ans << ' ';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[102], divisor;
int lcm[102][102], gcd[102][102], res[102];
bool flag, visited[102][102], vis[102];
void findDivisiors(int x) {
for (int i = 1; i <= (int)(ceil(sqrt(x))); i++) {
if (x % i == 0) {
divisor.push_back(i);
if (i != x / i) divisor.push_back(x / i);
}
}
}
int findGCD(int a, int b) {
if (b == 0) return a;
return findGCD(b, a % b);
}
void dfs(int u, int num) {
long long multiple;
int i;
for (i = 0; i < v[u].size(); i++) {
if (flag) break;
if (!visited[u][v[u][i]]) {
visited[u][v[u][i]] = true;
multiple = (long long)gcd[u][v[u][i]] * (long long)lcm[u][v[u][i]];
if (multiple % num != 0 ||
findGCD(num, multiple / num) != gcd[u][v[u][i]]) {
flag = true;
break;
}
dfs(v[u][i], multiple / num);
}
}
res[u] = num;
vis[u] = true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, i, j, x, y, l, g;
cin >> n >> m;
for (i = 0; i < m; i++) {
cin >> x >> y >> g >> l;
v[x].push_back(y);
v[y].push_back(x);
gcd[x][y] = g;
gcd[y][x] = g;
lcm[x][y] = l;
lcm[y][x] = l;
}
memset(res, 0, sizeof(res));
memset(vis, false, sizeof(vis));
for (i = 1; i <= n; i++) {
if (!vis[i] && v[i].size()) {
findDivisiors(lcm[v[i][0]][i]);
for (j = 0; j < divisor.size(); j++) {
flag = false;
memset(visited, false, sizeof(visited));
dfs(i, divisor[j]);
if (!flag) break;
}
if (flag) {
cout << "NO\n";
return 0;
}
divisor.clear();
}
}
cout << "YES\n";
for (i = 1; i <= n; i++) {
if (!res[i])
cout << 1 << " ";
else
cout << res[i] << " ";
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int N, k;
string S;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> S;
for (int i = 0; i < N; i++) {
if (S[i] == 'X') k++;
}
if (k <= N / 2) {
cout << N / 2 - k << '\n';
for (int i = 0; i < N && k < N / 2; i++) {
if (S[i] == 'x') {
S[i] = 'X';
k++;
}
}
cout << S << '\n';
} else {
cout << k - N / 2 << '\n';
for (int i = 0; i < N && k > N / 2; i++) {
if (S[i] == 'X') {
S[i] = 'x';
k--;
}
}
cout << S << '\n';
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long getint() {
long long _x = 0, _tmp = 1;
char _tc = getchar();
while ((_tc < '0' || _tc > '9') && _tc != '-') _tc = getchar();
if (_tc == '-') _tc = getchar(), _tmp = -1;
while (_tc >= '0' && _tc <= '9') _x *= 10, _x += (_tc - '0'), _tc = getchar();
return _x * _tmp;
}
inline long long add(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x + _y;
if (_ >= _mod) _ -= _mod;
return _;
}
inline long long sub(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x - _y;
if (_ < 0) _ += _mod;
return _;
}
inline long long mul(long long _x, long long _y,
long long _mod = 1000000007ll) {
long long _ = _x * _y;
if (_ >= _mod) _ %= _mod;
return _;
}
long long mypow(long long _a, long long _x, long long _mod) {
if (_x == 0) return 1ll;
long long _tmp = mypow(_a, _x / 2, _mod);
_tmp = mul(_tmp, _tmp, _mod);
if (_x & 1) _tmp = mul(_tmp, _a, _mod);
return _tmp;
}
long long mymul(long long _a, long long _x, long long _mod) {
if (_x == 0) return 0ll;
long long _tmp = mymul(_a, _x / 2, _mod);
_tmp = add(_tmp, _tmp, _mod);
if (_x & 1) _tmp = add(_tmp, _a, _mod);
return _tmp;
}
inline bool equal(double _x, double _y) {
return _x > _y - 1e-9 && _x < _y + 1e-9;
}
int __ = 1, _cs;
void build() {}
int n, p[202020][20], dst[202020];
void init() {
n = getint();
for (int i = 0; i < 20; i++) p[1][i] = 1;
for (int i = 2; i <= n; i++) p[i][0] = getint();
}
inline int lca(int a, int b) {
if (dst[a] > dst[b]) swap(a, b);
int dlt = dst[b] - dst[a];
for (int i = 0; i < 20; i++)
if ((dlt >> i) & 1) b = p[b][i];
if (a == b) return a;
for (int i = 20 - 1; i >= 0; i--)
if (p[a][i] != p[b][i]) {
a = p[a][i];
b = p[b][i];
}
return p[a][0];
}
inline int dist(int a, int b) { return dst[a] + dst[b] - 2 * dst[lca(a, b)]; }
void solve() {
int u = 1, v = 1, ans = 0;
for (int i = 2; i <= n; i++) {
dst[i] = dst[p[i][0]] + 1;
for (int j = 1; j < 20; j++) p[i][j] = p[p[i][j - 1]][j - 1];
int tans1 = dist(u, i);
int tans2 = dist(v, i);
if (max(tans1, tans2) > ans) {
if (tans1 < tans2) {
swap(tans1, tans2);
swap(u, v);
}
ans = tans1;
v = i;
}
printf("%d%c", ans, " \n"[i == n]);
}
}
int main() {
build();
while (__--) {
init();
solve();
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
char str[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t, n, k;
cin >> t;
while (t--) {
cin >> n >> k;
cin >> (str + 1);
sort(str + 1, str + 1 + n);
if (k == 1)
cout << (str + 1) << "\n";
else if (str[1] != str[k])
cout << str[k] << "\n";
else if (str[1] == str[k] && str[k + 1] == str[n]) {
cout << str[k];
int l = ceil((double)(n - k) / k);
for (int i = k + 1; i <= k + l; i++) cout << str[i];
cout << "\n";
} else if (str[1] == str[n]) {
int l = ceil((double)(n) / k);
for (int i = 1; i <= l; i++) cout << str[i];
cout << '\n';
} else {
for (int i = k; i <= n; i++) cout << str[i];
cout << '\n';
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int hour[10];
int mini[10];
int main() {
memset(hour, 0, sizeof(hour));
memset(mini, 0, sizeof(mini));
string s;
cin >> s;
string s1 = "";
string s2 = "";
int i = 0;
for (i = 0; i < s.size(); i++) {
if (s[i] != ':') {
s1 += s[i];
} else {
i++;
break;
}
}
for (i = i; i < s.size(); i++) {
s2 += s[i];
}
while (s1.size() < 5) {
string tmps = '0' + s1;
s1 = tmps;
}
while (s2.size() < 5) {
string tmps = '0' + s2;
s2 = tmps;
}
int count = 4;
for (int i = 0; i < s1.size(); i++) {
if (int(s1[i]) >= 48 && int(s1[i]) <= 57) {
hour[count] = int(s1[i]) - 48;
} else
hour[count] = int(s1[i]) - 55;
count--;
}
count = 4;
for (int i = 0; i < s2.size(); i++) {
if (int(s2[i]) >= 48 && int(s2[i]) <= 57) {
mini[count] = int(s2[i]) - 48;
} else
mini[count] = int(s2[i]) - 55;
count--;
}
if (hour[0] < 24 && hour[1] == 0 && hour[2] == 0 && hour[3] == 0 &&
hour[4] == 0 && mini[0] < 60 && mini[1] == 0 && mini[2] == 0 &&
mini[3] == 0 && mini[4] == 0) {
cout << "-1";
return 0;
}
int max = 0;
for (int i = 0; i < 5; i++) {
if (hour[i] > max) max = hour[i];
if (mini[i] > max) max = mini[i];
}
int start = max + 1;
while (1) {
int sum1 = 0;
int sum2 = 0;
for (int i = 0; i < 5; i++) {
sum1 += hour[i] * pow(start, i);
sum2 += mini[i] * pow(start, i);
}
if (sum1 > 23 || sum2 > 59) {
if (start == max + 1) cout << "0";
break;
} else {
cout << start << " ";
start++;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void bad(string mes = "Impossible") {
cout << mes;
exit(0);
}
template <typename... T>
void shit(T&... x) {}
template <typename... T>
void dec(T&... x) {
shit(--x...);
}
template <typename... T>
void inc(T&... x) {
shit(++x...);
}
template <typename T>
string bin(T x, int st = 2) {
string ans = "";
while (x > 0) {
ans += char('0' + x % st);
x /= st;
}
reverse(ans.begin(), ans.end());
return ans.empty() ? "0" : ans;
}
template <typename T>
T dcm(string& second) {
T x = 0;
for (int i = 0; i < second.size(); i++) {
x = (x * 2) + (second[i] == '1');
}
return x;
}
template <typename T>
T input() {
T ans = 0, m = 1;
char c = ' ';
while (c == ' ' || c == '\n') c = getchar();
if (c == '-') m = -1, c = getchar();
while (c >= '0' && c <= '9') {
ans = ans * 10 + int(c - '0'), c = getchar();
}
return ans * m;
}
const int inf = 1e9;
const double eps = 1e-9;
const int maxn = 3e2 + 10, base = 1e9 + 7;
const int sigm = 26;
const long long llinf = 1e18;
template <typename T>
T binpow(T n, T second) {
if (second <= 0) return 1LL;
if (second % 2 == 0) {
T b = binpow(n, second / 2);
return (1LL * b * b) % base;
} else {
return (1LL * binpow(n, second - 1) * n) % base;
}
}
int prs(char c) {
if (c >= '0' && c <= '9') return c - '0';
if (c >= 'A' && c <= 'Z') return c - 'A' + 10;
if (c >= 'a' && c <= 'z') return c - 'a' + 36;
if (c == '-') return 62;
if (c == '_') return 63;
}
int main() {
string notParsedShit;
cin >> notParsedShit;
long long ans = 1;
for (int i = 0; i < notParsedShit.size(); i++) {
int cur = prs(notParsedShit[i]);
for (int j = 0; j < 6; j++) {
if (cur % 2 == 0) ans = (3LL * ans) % base;
cur /= 2;
}
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int X[] = {-1, -1, -1, 0, 1, 1, 1, 0};
int Y[] = {-1, 0, +1, 1, 1, 0, -1, -1};
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
std::vector<pair<int, int> > g[105];
bool visited[105], color[105];
int m, n;
bool dfs(int u) {
visited[u] = 1;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i].first;
int typ = g[u][i].second;
if (!visited[v]) {
if (typ == 0) {
color[v] = !color[u];
} else {
color[v] = color[u];
}
dfs(v);
} else {
if ((typ == 0 and color[u] == color[v]) or
(typ == 1 and color[u] != color[v]))
return false;
}
}
return true;
}
int main() {
(memset(visited, 0, sizeof(visited)));
(memset(color, 0, sizeof(color)));
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v, t;
cin >> u >> v >> t;
g[u].push_back(pair<int, int>(v, t));
g[v].push_back(pair<int, int>(u, t));
}
for (int i = 1; i <= n; i++)
if (!visited[i])
if (!dfs(i)) {
cout << "Impossible" << endl;
return 0;
}
int cnt = 0;
for (int i = 1; i <= n; i++) cnt += color[i];
cout << cnt << endl;
for (int i = 1; i <= n; i++)
if (color[i]) cout << i << " ";
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
const int hashnum = 3;
long long base[] = {233, 23, 97};
long long mod[] = {122420729, 1000000007, 1000000009};
int sum[maxn];
char s[maxn];
long long power[hashnum][maxn];
int n;
struct node {
long long hv[hashnum];
int pref, suf, len;
};
node zer;
inline void init() {
zer.pref = zer.suf = zer.len = 0;
for (int i = (0); i < (hashnum); ++i) zer.hv[i] = 0;
for (int i = (0); i < (hashnum); ++i) {
power[i][0] = 1;
for (int j = (1); j < (maxn); ++j)
power[i][j] = power[i][j - 1] * base[i] % mod[i];
}
}
node merge(node& a, node& b) {
node c = zer;
if (a.len == 0 && b.len == 0)
c.suf = c.pref = a.pref + b.pref;
else if (a.len == 0)
c = b, c.pref += a.pref;
else if (b.len == 0)
c = a, c.suf += b.pref;
else {
c.len = a.len + b.len + (a.suf + b.pref) % 2;
c.pref = a.pref;
c.suf = b.suf;
for (int i = (0); i < (hashnum); ++i) {
if ((a.suf + b.pref) % 2 == 1) {
c.hv[i] = a.hv[i] * power[i][b.len + 1] % mod[i];
(c.hv[i] += 2 * power[i][b.len] % mod[i]) %= mod[i];
(c.hv[i] += b.hv[i]) %= mod[i];
} else {
c.hv[i] = a.hv[i] * power[i][b.len] % mod[i];
(c.hv[i] += b.hv[i]) %= mod[i];
}
}
}
return c;
}
struct segtree {
node t[maxn << 2];
int n, ql, qr;
node ans;
void init(int n) { this->n = n; }
void maintain(int o) { t[o] = merge(t[o << 1], t[o << 1 | 1]); }
void build(int l, int r, int o) {
t[o] = zer;
if (l == r) {
if (s[l] == '0') {
t[o].len++;
for (int i = (0); i < (hashnum); ++i) t[o].hv[i] = 1;
} else
t[o].suf = t[o].pref = 1;
return;
}
int mid = l + r >> 1;
build(l, mid, o << 1), build(mid + 1, r, o << 1 | 1);
maintain(o);
}
void query(int l, int r, int o) {
if (ql <= l && qr >= r)
ans = merge(ans, t[o]);
else {
int mid = l + r >> 1;
if (ql <= mid) query(l, mid, o << 1);
if (qr > mid) query(mid + 1, r, o << 1 | 1);
}
}
node Query(int l, int r) {
ans = zer;
ql = l, qr = r;
query(1, n, 1);
return ans;
}
};
segtree tree;
bool judge(node& a, node& b) {
if (a.suf % 2 != b.suf % 2 || a.pref % 2 != b.pref % 2 || a.len != b.len)
return false;
for (int i = (0); i < (hashnum); ++i)
if (a.hv[i] != b.hv[i]) return false;
return true;
}
int main(void) {
scanf("%d%s", &n, s + 1);
init();
tree.init(n);
tree.build(1, n, 1);
for (int i = (1); i <= (n); ++i) {
sum[i] = sum[i - 1];
if (s[i] == '1') sum[i]++;
}
int q;
scanf("%d", &(q));
for (; q--;) {
int l1, l2, r1, r2, len;
scanf("%d%d%d", &l1, &l2, &len);
r1 = l1 + len - 1;
r2 = l2 + len - 1;
if (sum[r2] - sum[l2 - 1] != sum[r1] - sum[l1 - 1]) {
puts("No");
continue;
}
node x = tree.Query(l1, r1);
node y = tree.Query(l2, r2);
if (judge(x, y))
puts("Yes");
else
puts("No");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
vector<int> dv[N + 2];
void dvv() {
for (int i = 1; i <= N; i++) {
for (int j = i; j <= N; j += i) dv[j].push_back(i);
}
}
int ls[N + 2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
dvv();
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int x, y;
cin >> x >> y;
int cnt = 0;
for (auto d : dv[x]) {
if (ls[d] < i - y) cnt++;
ls[d] = i;
}
cout << cnt << " ";
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
int t;
cin>>t;
while(t--){
string s;
cin>>s;
int flag=1;
int len=s.size();
map<int,int>mp;
for(int i=0;i<len;i++){
mp[s[i]-'a']++;
if(mp[s[i]-'a']>1){
flag=0;
break;
}
if(s[i]-'a'>=len){
flag=0;
break;
}
if(i==0||i==len-1)continue;
if(s[i]>s[i-1]&&s[i]>s[i+1]){
flag=0;
break;
}
}
if(flag)
cout<<"YES"<<endl;
else
cout<<"NO"<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, ans, len1, len2;
vector<int>::iterator it;
int main() {
cin >> n >> m;
len1 = 1;
len2 = 1;
for (int a = 7; a < n; a *= 7) len1 += 1;
for (int b = 7; b < m; b *= 7) len2 += 1;
if (len1 + len2 <= 7)
for (int i = 0; i != n; i++)
for (int j = 0; j != m; j++) {
vector<int> used(7, 0);
for (int a = i, k = 0; k != len1; a /= 7, k++) used[a % 7] += 1;
for (int b = j, k = 0; k != len2; b /= 7, k++) used[b % 7] += 1;
it = max_element(used.begin(), used.end());
if (*it <= 1) ans++;
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long MOD_EXPO(long long b, long long p, long long m) {
if (p == 0) return 1;
long long ret = MOD_EXPO(b, p / 2, m) % m;
ret = (ret * ret) % m;
return ((p & 1) ? (ret * b) % m : ret % m);
}
long long POWER(long long N, long long K) {
long long i, ans = 1;
for (i = 1; i <= K; i++) ans *= N;
return ans;
}
int SET(int N, int pos) { return (N | (1 << pos)); }
int RESET(int N, int pos) { return (N & !(1 << pos)); }
bool CHECK(int N, int pos) { return (N & (1 << pos)); }
int dx4[] = {1, -1, 0, 0};
int dy4[] = {0, 0, 1, -1};
int dx6[] = {0, 0, 1, -1, 0, 0};
int dy6[] = {1, -1, 0, 0, 0, 0};
int dz6[] = {0, 0, 0, 0, 1, -1};
int dx8[] = {1, -1, 0, 0, -1, 1, -1, 1};
int dy8[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dkx8[] = {-1, 1, -1, 1, -2, -2, 2, 2};
int dky8[] = {2, 2, -2, -2, 1, -1, 1, -1};
int tc = 1;
const double eps = 1e-9;
const double pi = acos(-1.0);
const long long int mx = 1e5;
const long long int mod = 1e9 + 7;
int main() {
double w, h, a;
scanf("%lf %lf %lf", &w, &h, &a);
if (fabs(a - 90) < 1e-6) {
printf("%.10lf\n", min(w, h) * min(w, h));
return 0;
}
if (a > 90) a = 180 - a;
if (fabs(a) < 1e-6) {
printf("%.10lf\n", w * h);
return 0;
}
a = a / 180 * pi;
if (w < h) swap(w, h);
double ans = w * h;
double p1x = -w / 2 * cos(a) - h / 2 * sin(a);
double p1y = -w / 2 * sin(a) + h / 2 * cos(a);
double p2x = w / 2 * cos(a) - h / 2 * sin(a);
double p2y = w / 2 * sin(a) + h / 2 * cos(a);
double p3x = -w / 2 * cos(a) + h / 2 * sin(a);
double p3y = -w / 2 * sin(a) - h / 2 * cos(a);
if (a <= atan2(h, w) * 2) {
double xi1 =
((p2y - h / 2) * p1x + (h / 2 - p1y) * p2x) / (p2y - p1y) + w / 2;
double yi1 =
h / 2 - ((p2x - (-w / 2)) * p1y + ((-w / 2) - p1x) * p2y) / (p2x - p1x);
double xi2 =
((p3y - (-h / 2)) * p1x + ((-h / 2) - p1y) * p3x) / (p3y - p1y) + w / 2;
double yi2 =
((p3x - (-w / 2)) * p1y + ((-w / 2) - p1x) * p3y) / (p3x - p1x) -
(-h / 2);
ans -= xi1 * yi1 + xi2 * yi2;
} else {
double xi1 =
((p2y - h / 2) * p1x + (h / 2 - p1y) * p2x) / (p2y - p1y) + w / 2;
double xi2 =
((p2y - (-h / 2)) * p1x + ((-h / 2) - p1y) * p2x) / (p2y - p1y) + w / 2;
ans -= h * (xi1 + xi2);
}
printf("%.10lf\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
int main() {
int t, a, b, i, s;
scanf("%d", &t);
for (i = 1; i <= t; i++) {
scanf("%d%d", &a, &b);
s = ((24 - a) * 60) - b;
printf("%d\n", s);
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a.begin(), a.end());
vector<long long> b(n), s(n);
for (int i = 1; i < n; ++i) {
b[i] = a[i] - a[i - 1];
}
sort(b.begin(), b.end());
for (int i = 1; i < n; ++i) {
s[i] = s[i - 1] + b[i];
}
int nq;
cin >> nq;
for (long long l, r; nq--;) {
cin >> l >> r;
long long d = r - l + 1;
int p = upper_bound(b.begin(), b.end(), d) - b.begin() - 1;
long long ans = s[p] + d * (n - p);
cout << ans << " ";
}
cout << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 0x7FFFFFFF;
const int MIN = 0x80000000;
int main() {
int a, b;
cin >> a >> b;
int h1[1024], h2[1024], v1[1024], v2[1024];
int temp, count_h1 = 0, count_h2 = 0;
for (int i = 1; i < a; i++) {
temp = (int)sqrt(double(a * a - i * i));
if (temp * temp == a * a - i * i) {
h1[count_h1] = i;
v1[count_h1] = temp;
count_h1++;
}
}
for (int i = 1; i < b; i++) {
temp = (int)sqrt(double(b * b - i * i));
if (temp * temp == b * b - i * i) {
h2[count_h2] = i;
v2[count_h2] = temp;
count_h2++;
}
}
int ax, ay, bx, by, cx, cy;
for (int i = 0; i < count_h1; i++)
for (int j = 0; j < count_h2; j++) {
if (a * b == h1[i] * v2[j] + h2[j] * v1[i]) {
ax = 0;
ay = 0;
bx = -h1[i];
by = v1[i];
cx = h2[j];
cy = v2[j];
if (by == cy || bx == cx) continue;
cout << "YES" << endl;
cout << ax << " " << ay << endl;
cout << bx << " " << by << endl;
cout << cx << " " << cy << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int rev[(1 << 21)], mlgn;
double omega[(1 << 21)][2];
double FA[(1 << 21)][2], FB[(1 << 21)][2];
inline void mult(double A[2], double B[2], double C[2]) {
C[0] = A[0] * B[0] - A[1] * B[1];
C[1] = A[0] * B[1] + A[1] * B[0];
}
void calc_rev(int n = (1 << 21)) {
while ((1 << mlgn) < n) mlgn++;
int lvl = 1, mx = (1 << mlgn);
while (lvl < mx) {
int j = 0, sg = 0;
for (int i = 0; i < mx; i++) {
rev[i] = (rev[i] << 1) | sg;
j++;
if (j == lvl) j = 0, sg ^= 1;
}
lvl <<= 1;
}
}
void fft(double X[(1 << 21)][2], int n, bool invert) {
int lgn = 0;
while ((1 << lgn) != n) lgn++;
for (int i = 0; i < (n); i++)
if (i < rev[i << (mlgn - lgn)])
swap(X[i][0], X[rev[i << (mlgn - lgn)]][0]),
swap(X[i][1], X[rev[i << (mlgn - lgn)]][1]);
double ang = (2.0 * M_PI / n) * (invert ? -1.0 : 1.0);
for (int i = 0; i < (n); i++)
omega[i][0] = cos(ang * i), omega[i][1] = sin(ang * i);
for (int len = 2; len <= n; len <<= 1) {
int fact = n / len;
int len2 = len >> 1;
for (int i = 0; i < n; i += len)
for (int j = 0; j < (len2); j++) {
double u[2], v[2];
u[0] = X[i + j][0], u[1] = X[i + j][1];
mult(X[i + j + len2], omega[j * fact], v);
X[i + j][0] = u[0] + v[0], X[i + j][1] = u[1] + v[1];
X[i + j + len2][0] = u[0] - v[0], X[i + j + len2][1] = u[1] - v[1];
}
}
if (invert)
for (int i = 0; i < (n); i++) X[i][0] /= n, X[i][1] /= n;
}
int multiply(int A[(1 << 21)], int B[(1 << 21)], int n1, int n2,
int ret[(1 << 21)]) {
for (int i = 0; i < (n1); i++) FA[i][0] = (double)A[i], FA[i][1] = 0.0;
for (int i = 0; i < (n2); i++) FB[i][0] = (double)B[i], FB[i][1] = 0.0;
int n = 1;
while (n < max(n1, n2)) n <<= 1;
n <<= 1;
for (int i = (n1); i < (n); i++) FA[i][0] = FA[i][1] = 0.0;
for (int i = (n2); i < (n); i++) FB[i][0] = FB[i][1] = 0.0;
fft(FA, n, false);
fft(FB, n, false);
double tmp[2];
for (int i = 0; i < (n); i++) {
mult(FA[i], FB[i], tmp);
FA[i][0] = tmp[0], FA[i][1] = tmp[1];
}
fft(FA, n, true);
int mx = 1;
for (int i = 0; i < (n); i++) {
ret[i] = (int)(FA[i][0] + 0.5);
ret[i] = (ret[i] > 0);
if (ret[i]) mx = i + 1;
}
return mx;
}
int N, K;
int a[(1 << 21)], b[(1 << 21)];
int bigmodFFT(int x[(1 << 21)], int ret[(1 << 21)], int pow, int nx) {
int n = 1;
ret[0] = 1;
while (pow > 0) {
if (pow & 1) n = multiply(ret, x, n, nx, ret);
pow >>= 1;
if (!pow) break;
nx = multiply(x, x, nx, nx, x);
}
return n;
}
int main() {
int n = 0;
scanf("%d%d", &N, &K);
for (int i = 0; i < (N); i++) {
int x;
scanf("%d", &x);
a[x] = 1;
n = max(n, x + 1);
}
calc_rev();
bigmodFFT(a, b, K, n);
bool sp = false;
for (int i = 0; i < ((1 << 21)); i++)
if (b[i]) {
if (sp) printf(" ");
printf("%d", i);
sp = true;
}
return 0;
}
| 8 |
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <vector>
#include <cmath>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <math.h>
#include <string>
#include <cstring>
#include <cassert>
#include <climits>
using namespace std;
const double PI = acos(-1);
const int N=1e5 + 10;
const int M=1000000007;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> ii;
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define all(c) (c).begin(),(c).end()
#define rall(c) (c).rbegin(),(c).rend()
#define oo 1000000001
vi w;
vvi adj;
void solve(){
int n;
cin>>n;
w.clear();
w.resize(n);
adj.clear();
adj.resize(n);
ll sum=0;
for (int i = 0; i < n; ++i)
{
cin>>w[i];
sum+=w[i];
}
int a,b;
for (int i = 0; i < n-1; ++i)
{
cin>>a>>b;
a--;b--;
adj[a].pb(b);
adj[b].pb(a);
}
priority_queue<int> q;
for (int i = 0; i < n; ++i)
{
// printf("node %d has in = %d \n",i+1,(int)adj[i].size() );
for (int j = 0; j < adj[i].size()-1; ++j)
{
q.push(w[i]);
}
}
printf("%lld ",sum );
for (int i = 1; i < n-1; ++i)
{
sum+=q.top();
q.pop();
printf("%lld ",sum );
}
printf("\n");
}
int main(){
int t=1;
scanf("%d",&t);
while(t--)
solve();
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
double a[10000] = {0};
double b[10000] = {0};
double c[10000] = {0};
int main() {
int i, j, k, l, m, n, r = 0;
double x, y, z;
scanf("%i", &n);
for (i = 0; i < n; i++) scanf("%lf", &a[i]);
scanf("%i", &m);
for (i = 0; i < m; i++) scanf("%lf", &b[i]);
scanf("%i", &k);
for (i = 0; i < k; i++) scanf("%lf", &c[i]);
scanf("%lf %lf", &x, &y);
sort(c, c + k);
double t = 0;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
z = sqrt((y * a[i] * a[i] * b[j]) / (b[j] * y + x * c[l]));
if (a[i] > z)
if (z > t) t = z;
}
printf("%.6lf\n", t);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
ifstream from;
const long long nmmin = 1, nmmax = 50, abmin = 1, abmax = 50;
long long n, m, res, rt, i, i0, j, j0, k, t, ax, a, b;
if (0) from.open("test.txt");
cin >> n >> m;
vector<vector<long long> > v(n);
for (i = 0; i < n; i++) v[i].resize(m);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) cin >> v[i][j];
cin >> a >> b;
res = n * m;
if ((a <= n) && (b <= m)) {
for (i0 = 0; i0 <= n - a; i0++) {
rt = 0;
for (i = i0; i < i0 + a; i++)
for (j = 0; j < b; j++) rt += v[i][j];
res = (rt < res) ? rt : res;
for (j0 = 1; j0 <= m - b; j0++) {
for (i = i0; i < i0 + a; i++) rt += (v[i][j0 + b - 1] - v[i][j0 - 1]);
res = (rt < res) ? rt : res;
}
}
}
swap(a, b);
if ((a <= n) && (b <= m)) {
for (i0 = 0; i0 <= n - a; i0++) {
rt = 0;
for (i = i0; i < i0 + a; i++)
for (j = 0; j < b; j++) rt += v[i][j];
res = (rt < res) ? rt : res;
for (j0 = 1; j0 <= m - b; j0++) {
for (i = i0; i < i0 + a; i++) rt += (v[i][j0 + b - 1] - v[i][j0 - 1]);
res = (rt < res) ? rt : res;
}
}
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int x, reverse = 0;
scanf("%d", &x);
while (x) {
if (x % 10 == 0)
x = x / 10;
else
break;
}
int b = x;
while (x) {
int a = x % 10;
reverse = reverse * 10 + a;
x = x / 10;
}
if (reverse == b) {
printf("YES");
} else
printf("NO");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
int a[maxn], b[maxn];
int main() {
long long ans;
long long t, n, k, x, y;
scanf("%lld", &t);
while (t--) {
scanf("%lld %lld", &x, &y);
if (x > y) swap(x, y);
long long z = y / x;
ans = 0;
if (z * x != y) {
ans = -1;
} else {
while (z % 8 == 0 && z) ans++, z /= 8;
while (z % 4 == 0 && z) ans++, z /= 4;
while (z % 2 == 0 && z) ans++, z /= 2;
if (z != 1) ans = -1;
}
printf("%lld\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
int pa[N][22];
int psum[N];
int n;
string s, news;
int get(int x, int lv) {
x = x + n;
for (int i = 0; lv; i++, lv >>= 1)
if (lv & 1) {
x = pa[x][i];
}
return x - n;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> s;
n = s.length();
news.resize(n);
int m = int(log2(n));
for (int j = 0; j <= m; j++)
for (int i = 1; i < n; i++) pa[i][j] = i - (1 << j);
int test;
cin >> test;
while (test--) {
int k, d;
cin >> k >> d;
for (int i = 0; i < d; i++) {
psum[i + 1] = psum[i] + (k + d - i - 1) / d;
}
for (int i = 0; i < k; i++) {
pa[n + i][0] = n + (psum[i % d] + i / d) - 1;
}
for (int j = 1; j <= m; j++)
for (int i = n; i < n + k; i++) pa[i][j] = pa[pa[i][j - 1]][j - 1];
for (int i = 0; i < n; i++) {
int ini_pos = min(i, k - 1);
int turn = n - max(i, k - 1);
int pos = i - ini_pos + get(ini_pos, turn) + turn;
news[pos] = s[i];
}
s = news;
cout << s << '\n';
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
using INT = long long;
using pii = pair<int, int>;
char str[1000010];
int a[111];
int main() {
int n;
cin >> n;
cin >> str + 1;
for (int i = 1; i <= n; i++) {
char ch = str[i];
if (ch == 'L') {
for (int i = 0; i <= 9; i++)
if (a[i] == 0) {
a[i] = 1;
break;
}
}
if (ch == 'R') {
for (int i = 9; i >= 0; i--)
if (a[i] == 0) {
a[i] = 1;
break;
}
} else {
int num = ch - '0';
a[num] = 0;
}
}
for (int i = 0; i <= 9; i++) cout << a[i];
cout << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T& x) {
char c = getchar();
T p = 1, n = 0;
while (c < '0' || c > '9') {
if (c == '-') p = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
n = n * 10 + c - '0';
c = getchar();
}
x = p * n;
}
template <class T, class U>
void read(T& x, U& y) {
read(x), read(y);
}
template <class T, class U, class V>
void read(T& x, U& y, V& z) {
read(x), read(y), read(z);
}
const int maxn = 105;
const long long mod = 1e9 + 7;
bool G[maxn][maxn];
int n, a[maxn][maxn];
int power(int a, int b) {
int r = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) r = 1ll * r * a % mod;
return r;
}
int det() {
int ans = 1;
for (int i = 1; i < n; ++i) {
int j;
for (j = i; j < n; ++j)
if (a[j][i]) break;
ans = 1ll * ans * a[j][i] % mod;
if (j != i) ans = mod - ans;
for (int k = i; k < n; ++k) swap(a[i][k], a[j][k]);
for (int k = i + 1; k < n; ++k) {
int d = 1ll * a[k][i] * power(a[i][i], mod - 2) % mod;
for (int l = i; l < n; ++l)
a[k][l] = (a[k][l] - 1ll * d * a[i][l] % mod + mod) % mod;
}
}
return ans;
}
int go(int x) {
memset(a, 0, sizeof a);
for (int i = 1; i <= n; ++i)
for (int j = 1; j < i; ++j)
if (G[i][j])
a[i][j] = (mod - x) % mod, a[j][i] = (mod - x) % mod,
(a[i][i] += x) %= mod, (a[j][j] += x) %= mod;
else
a[i][j] = mod - 1, a[j][i] = mod - 1, (a[i][i] += 1) %= mod,
(a[j][j] += 1) %= mod;
return det();
}
int f[maxn][maxn], fac[maxn], ifac[maxn], s[maxn][maxn], r[maxn];
int main() {
read(n);
for (int i = 1, u, v; i < n; ++i) read(u, v), G[u][v] = G[v][u] = 1;
for (int i = 0; i < n; ++i) f[0][i] = go(i);
for (int i = 1; i < n; ++i)
for (int j = 0; j < n - i; ++j)
f[i][j] = (f[i - 1][j + 1] - f[i - 1][j] + mod) % mod;
fac[0] = 1;
for (int i = 1; i <= n; ++i) fac[i] = 1ll * fac[i - 1] * i % mod;
ifac[n] = power(fac[n], mod - 2);
for (int i = n - 1; ~i; --i) ifac[i] = 1ll * ifac[i + 1] * (i + 1) % mod;
for (int i = 0; i < n; ++i) r[i] = 1ll * f[i][0] * ifac[i] % mod;
s[0][0] = 1;
for (int i = 1; i < n; ++i)
for (int j = 1; j <= i; ++j)
s[i][j] = (s[i - 1][j - 1] + 1ll * (i - 1) * s[i - 1][j] % mod) % mod;
for (int i = 0; i < n; ++i)
for (int j = i - 1, m1 = mod - 1; ~j; --j, m1 = mod - m1)
(r[j] += 1ll * r[i] * m1 % mod * s[i][j] % mod) %= mod;
for (int i = 0; i < n; ++i) printf("%d ", r[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
const long long N = 6010, mod = 998244353;
bool f[N][N];
long long n, x[N], y[N], ans1, ans2, tot;
long long sum[2][2];
int main() {
n = read();
for (long long i = (long long)(1); i <= (long long)(n); ++i)
x[i] = read() / 2, y[i] = read() / 2;
for (long long i = (long long)(1); i <= (long long)(n); ++i) {
sum[0][0] = sum[0][1] = sum[1][0] = sum[1][1] = 0;
for (long long j = (long long)(1); j <= (long long)(n); ++j)
if (j != i) ++sum[abs(x[j] - x[i]) & 1][abs(y[j] - y[i]) & 1];
ans1 += sum[1][0] * (sum[1][0] - 1) / 2;
ans1 += sum[0][1] * (sum[0][1] - 1) / 2;
ans1 += sum[1][1] * (sum[1][1] - 1) / 2;
ans2 += sum[0][0] * (sum[0][0] - 1) / 2;
}
cout << ans1 + ans2 / 3 << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string s;
char ch;
long long ans;
int find() {
cout << "? 0 1" << endl;
fflush(stdout);
cin >> ch;
if (ch == 'x') {
cout << "! 1" << endl;
fflush(stdout);
return 0;
}
cout << "? 0 2" << endl;
fflush(stdout);
cin >> ch;
if (ch == 'x') {
cout << "! 2" << endl;
fflush(stdout);
return 0;
}
long long x = 2, y = 4;
while (1) {
cout << "? " << x << " " << y << endl;
fflush(stdout);
cin >> ch;
if (ch == 'y')
x <<= 1, y <<= 1;
else if (ch == 'x') {
long long l = x + 1, r = y, mid = (l + r) / 2LL;
while (l < r) {
cout << "? " << x << " " << mid << endl;
fflush(stdout);
cin >> ch;
if (ch == 'e') return 0;
if (ch == 'y')
l = mid + 1;
else
r = mid;
mid = (l + r) / 2;
}
cout << "! " << l << endl;
fflush(stdout);
return 0;
} else
return 0;
}
}
int main() {
while (cin >> s) {
if (s != "start") break;
find();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long ans = 0;
long long n;
cin >> n;
long long it = 0;
while (true) {
if (n - 9 * pow(10, it) < 0) {
it++;
break;
}
n = n - 9 * pow(10, it);
it++;
}
for (int i = 0; i < it - 1; i++) {
ans += (i + 1) * 9 * pow(10, i);
}
ans += it * n;
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
cout << (long long)(n - 2) * (n - 2);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[500001], b[500001], ans, sum, cnt;
inline bool check(long long x) {
sum = cnt = 0;
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
for (register long long i = 1; i <= n; ++i) {
q.push(make_pair(a[i], 0));
if (q.top().first + b[i] + x <= 0) {
sum += q.top().first + b[i] + x;
cnt += q.top().second ^ 1;
q.pop();
q.push(make_pair(-b[i] - x, 1));
}
}
if (cnt >= m) ans = sum;
return cnt >= m;
}
signed main() {
scanf("%lld%lld", &n, &m);
for (register long long i = 1; i <= n; ++i) scanf("%lld", &a[i]);
for (register long long i = 1; i <= n; ++i) scanf("%lld", &b[i]);
long long l = -1e18, r = 1e18, mid;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid)) {
ans = sum - m * mid;
l = mid + 1;
} else
r = mid - 1;
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mn = 2e5 + 10;
char ch[mn];
int deep[mn];
struct TREE {
int dma, dmi, dab, dbc, dabc;
int lazy;
} tr[4 * mn];
void pushup(int id) {
int ls = 2 * id, rs = 2 * id + 1;
tr[id].dma = max(tr[ls].dma, tr[rs].dma);
tr[id].dmi = min(tr[ls].dmi, tr[rs].dmi);
tr[id].dab = max(tr[ls].dab, tr[rs].dab);
tr[id].dab = max(tr[id].dab, tr[ls].dma - 2 * tr[rs].dmi);
tr[id].dbc = max(tr[ls].dbc, tr[rs].dbc);
tr[id].dbc = max(tr[id].dbc, -2 * tr[ls].dmi + tr[rs].dma);
tr[id].dabc = max(tr[ls].dabc, tr[rs].dabc);
tr[id].dabc = max(tr[id].dabc, tr[ls].dab + tr[rs].dma);
tr[id].dabc = max(tr[id].dabc, tr[ls].dma + tr[rs].dbc);
}
void build(int id, int l, int r) {
if (l == r) {
tr[id].dma = tr[id].dmi = deep[l];
tr[id].dab = tr[id].dbc = -deep[l];
tr[id].dabc = 0;
return;
}
int mid = (l + r) >> 1;
build(2 * id, l, mid);
build(2 * id + 1, mid + 1, r);
pushup(id);
}
void change(int id, int val) {
tr[id].dma += val, tr[id].dmi += val;
tr[id].dab -= val, tr[id].dbc -= val;
}
void pushdown(int id) {
if (tr[id].lazy == 0) return;
tr[2 * id].lazy += tr[id].lazy;
tr[2 * id + 1].lazy += tr[id].lazy;
change(2 * id, tr[id].lazy);
change(2 * id + 1, tr[id].lazy);
tr[id].lazy = 0;
}
void update(int id, int l, int r, int L, int R, int val) {
if (L <= l && r <= R) {
change(id, val);
tr[id].lazy += val;
return;
}
int mid = (l + r) >> 1;
pushdown(id);
if (R <= mid)
update(2 * id, l, mid, L, R, val);
else if (mid + 1 <= L)
update(2 * id + 1, mid + 1, r, L, R, val);
else {
update(2 * id, l, mid, L, mid, val);
update(2 * id + 1, mid + 1, r, mid + 1, R, val);
}
pushup(id);
}
int main() {
int n, q;
scanf("%d %d", &n, &q);
scanf("%s", ch + 1);
n = n * 2 - 1;
deep[1] = 0;
for (int i = 2; i <= n; i++)
deep[i] = deep[i - 1] + (ch[i - 1] == '(' ? 1 : -1);
build(1, 1, n);
printf("%d\n", tr[1].dabc);
while (q--) {
int a, b;
scanf("%d %d", &a, &b);
if (ch[a] != ch[b]) {
if (a > b) swap(a, b);
if (ch[a] == '(')
update(1, 1, n, a + 1, b, -2);
else
update(1, 1, n, a + 1, b, 2);
swap(ch[a], ch[b]);
}
printf("%d\n", tr[1].dabc);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
b[i] = a[i];
}
int cnt = 0, j = 0;
bool swapped = false;
for (int i = 1; i < n; i++) {
int temp = a[i];
for (j = i; j > 0 && temp < a[j - 1]; j--) {
a[j] = a[j - 1];
}
a[j] = temp;
}
int s = 0, ans = 0;
for (int i = 0; i < n; i++) {
s += b[i] - a[i];
ans += !s;
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 1e5 + 5;
const long long mod = 1e9 + 7;
long long n;
vector<long long> vc[maxN];
long long cnt;
long long order[maxN];
long long in[maxN];
long long out[maxN];
long long a[maxN];
long long h[maxN];
long long par[maxN];
long long x, y;
long long root;
long long ans = 0;
long long euler[maxN * 2];
long long cntler = 0;
void dfs(long long node, long long pr) {
in[node] = ++cnt;
order[cnt] = node;
par[node] = pr;
h[node] = h[pr] + 1;
euler[++cntler] = node;
for (auto child : vc[node]) {
if (child == pr) continue;
dfs(child, node);
euler[++cntler] = node;
}
out[node] = cnt + 1;
}
long long ftree[maxN];
long long stree[maxN];
void add(long long *tree, long long pos, long long num) {
while (pos <= n) {
tree[pos] += num;
pos = pos + (pos & (-pos));
}
}
void admire(long long left, long long right, long long num) {
add(ftree, left, num);
add(ftree, right + 1, -num);
add(stree, left, num * (left - 1));
add(stree, right + 1, -num * right);
}
long long sum(long long *tree, long long pos) {
long long ans = 0;
while (pos) {
ans += tree[pos];
pos = pos - (pos & (-pos));
}
return ans;
}
long long prefix(long long pos) {
return sum(ftree, pos) * pos - sum(stree, pos);
}
long long area(long long left, long long right) {
return prefix(right) - prefix(left - 1);
}
long long sparse[maxN * 2][20];
long long lg[maxN * 2];
long long minpos[maxN];
long long maxpos[maxN];
long long lcs(long long n1, long long n2) {
long long left = min(minpos[n1], minpos[n2]);
long long right = max(maxpos[n1], maxpos[n2]) + 1ll;
long long lger = lg[right - left];
long long new1 = sparse[left][lger];
long long new2 = sparse[right - (1 << lger)][lger];
if (h[new1] > h[new2])
return new2;
else
return new1;
}
long long parup[maxN][20];
void pullup(long long &node, long long hei) {
long long cur = 18;
while (cur != -1) {
if (h[parup[node][cur]] > hei) node = parup[node][cur];
--cur;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
long long o;
cin >> o;
for (long long i = 0; i <= n + 2; i++) {
ftree[i] = 0;
stree[i] = 0;
}
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 2; i <= n; i++) {
cin >> x >> y;
vc[x].push_back(y);
vc[y].push_back(x);
}
cnt = 0;
root = 1;
par[1] = n + 1;
par[n + 1] = n + 1;
h[0] = mod;
h[n + 1] = -1;
dfs(1, n + 1);
lg[0] = -1;
for (long long i = 1; i <= n; i++) {
admire(i, i, a[order[i]]);
parup[i][0] = par[i];
minpos[i] = mod;
maxpos[i] = -mod;
}
for (long long i = 1; i <= n * 2; i++) {
sparse[i][0] = euler[i];
lg[i] = lg[i / 2] + 1;
minpos[euler[i]] = min(minpos[euler[i]], i);
maxpos[euler[i]] = max(maxpos[euler[i]], i);
}
parup[n + 1][0] = par[n + 1];
for (long long rg = 0; rg < 19; rg++) {
for (long long i = 1; i <= n * 2 + 1 - (1 << (rg + 1)); i++) {
long long n1 = sparse[i][rg];
long long n2 = sparse[i + (1 << rg)][rg];
if (h[n1] > h[n2])
sparse[i][rg + 1] = n2;
else
sparse[i][rg + 1] = n1;
}
for (long long i = 1; i <= n + 1; i++) {
parup[i][rg + 1] = parup[parup[i][rg]][rg];
}
}
while (o--) {
cin >> x >> y;
if (x == 1) {
root = y;
} else if (x == 3) {
long long cope = root;
pullup(cope, h[y]);
if (cope == y)
cout << area(1, n) << "\n";
else if (par[cope] != y)
cout << area(in[y], out[y] - 1) << "\n";
else
cout << area(1, n) - area(in[cope], out[cope] - 1) << "\n";
} else {
long long n1, n2;
cin >> n2 >> n1;
swap(n1, y);
long long cope = root;
long long spec1 = lcs(n1, n2);
long long spec2 = lcs(n1, root);
long long spec3 = lcs(n2, root);
if (h[spec1] < h[spec2]) swap(spec1, spec2);
if (h[spec2] < h[spec3]) swap(spec2, spec3);
if (h[spec1] < h[spec2]) swap(spec1, spec2);
n1 = spec1;
pullup(cope, h[n1]);
if (cope == n1) {
admire(1, n, y);
} else if (par[cope] != n1) {
admire(in[n1], out[n1] - 1, y);
} else {
admire(1, n, y);
admire(in[cope], out[cope] - 1, -y);
}
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long k;
int a[100000];
int main() {
cin >> n;
cin >> k;
long long tmpsum = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
tmpsum += a[i];
}
if (tmpsum < k) {
cout << -1;
return 0;
}
int l = 0, r = 1000000000;
int times = 0;
while (l <= r) {
int mid = (l + r) / 2;
long long cnt = 0LL;
for (int i = 0; i < n; i++) {
cnt += min(mid, a[i]);
}
if (cnt <= k) {
times = max(times, mid);
l = mid + 1;
} else {
r = mid - 1;
}
}
long long cnt = 0LL;
for (int i = 0; i < n; i++) {
cnt += min(times, a[i]);
a[i] = max(0, a[i] - times);
}
int id;
for (id = 0; id < n && cnt < k; id++) {
if (a[id] > 0) {
cnt++;
a[id]--;
}
}
for (int i = id; i < n; i++)
if (a[i] > 0) cout << i + 1 << " ";
for (int i = 0; i < id; i++)
if (a[i] > 0) cout << i + 1 << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long mat[2100][40];
int binaryJordanGauss(int r, int c, int right) {
int b = (c + right + 63) / 64;
int rnk = 0;
for (int _n(c), j(0); j < _n; j++) {
int i = rnk;
for (; i < r; ++i)
if (mat[i][j >> 6] & (1ull << (j % 64))) break;
if (i == r) continue;
if (i != rnk) {
for (int _n(b), k(j >> 6); k < _n; k++) swap(mat[i][k], mat[rnk][k]);
}
for (i = 0; i < r; ++i) {
if (i != rnk) {
if (mat[i][j >> 6] & (1ull << (j % 64))) {
for (int _n(b), k(j >> 6); k < _n; k++) mat[i][k] ^= mat[rnk][k];
}
}
}
rnk++;
}
return rnk;
}
char buff[2222];
int arr[2222];
int in[2020][2020];
int ind[2222];
int main() {
int N;
cin >> N;
for (int _n(N), x(0); x < _n; x++) {
scanf("%s", buff);
int size = (int)strlen(buff);
for (int _n(size), i(0); i < _n; i++) arr[i] = buff[size - 1 - i] - '0';
for (int _n(2000), i(0); i < _n; i++) in[x][i] = 0;
for (int _n(2000), i(0); i < _n; i++) {
in[x][i] = arr[0] % 2;
arr[0] /= 2;
for (int _n(size), j(1); j < _n; j++) {
arr[j - 1] += 5 * (arr[j] % 2);
arr[j] /= 2;
}
if (arr[size - 1] == 0) size--;
if (size == 0) break;
}
}
for (int _n(N), i(0); i < _n; i++)
for (int _n(2000), j(0); j < _n; j++) {
if (in[i][j]) {
mat[j][i / 64] |= 1ull << (i % 64);
}
}
binaryJordanGauss(2000, N, 0);
int k = 0;
for (int _n(N), i(0); i < _n; i++) {
if (mat[k][i / 64] & (1ull << (i % 64))) {
ind[k++] = i;
cout << 0 << endl;
} else {
vector<int> ans;
for (int _n(k), j(0); j < _n; j++)
if (mat[j][i / 64] & (1ull << (i % 64))) ans.push_back(ind[j]);
cout << ans.size();
for (int t : ans) cout << " " << t;
cout << endl;
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
void optimizeIO() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
multiset<int> second[5];
vector<int> vec[5];
int main() {
optimizeIO();
int n;
cin >> n;
int temp = n;
while (temp--) {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
second[1].insert(x1);
second[2].insert(x2);
second[3].insert(y1);
second[4].insert(y2);
vec[1].push_back(x1);
vec[2].push_back(x2);
vec[3].push_back(y1);
vec[4].push_back(y2);
}
for (int i = 0; i < n; i++) {
second[1].erase(second[1].find(vec[1][i]));
second[2].erase(second[2].find(vec[2][i]));
second[3].erase(second[3].find(vec[3][i]));
second[4].erase(second[4].find(vec[4][i]));
int maxsx = *second[1].rbegin();
int minex = *second[2].begin();
int maxsy = *second[3].rbegin();
int miney = *second[4].begin();
if (maxsx <= minex && maxsy <= miney) {
cout << maxsx << " " << maxsy << endl;
return 0;
}
second[1].insert(vec[1][i]);
second[2].insert(vec[2][i]);
second[3].insert(vec[3][i]);
second[4].insert(vec[4][i]);
}
}
| 4 |
#include <bits/stdc++.h>
int main() {
char a[200], b[100];
scanf("%s", a);
int i, j;
for (i = 0; i < strlen(a); i = i + 1) {
if (a[i] == 'W' && a[i + 1] == 'U' && a[i + 2] == 'B') {
a[i] = ' ';
a[i + 1] = '0';
a[i + 2] = '0';
}
}
for (i = 0, j = 0; i < strlen(a); i = i + 1) {
if (a[i] >= 'A' && a[i] <= 'Z' || a[i] == ' ') printf("%c", a[i]);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 10;
const int maxn = 5e3 + 10;
const int maxq = 1e2 + 10;
const int alf = 26;
const long long dlm = 1e9 + 7;
const int del = 1234234;
const int eps = 1e-7;
string O[] = {"YES", "NO", "Yes", "No"};
int a[maxn];
pair<int, int> dp[maxn][maxn];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int most = n / 2 + (n % 2 == 1 ? 1 : 0);
for (int i = 1; i <= n; i++) {
dp[i][0] = {inf, 0};
dp[0][i] = {inf, inf};
}
dp[0][0] = {inf, 0};
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= most; j++) {
dp[i][j] = {inf, inf};
}
}
for (int i = 1; i <= n; i++) {
for (int k = 1; k <= most; k++) {
if (i == 1) {
if (k >= 2) continue;
dp[i][k].first = max(0, a[2] - a[1] + 1);
continue;
}
dp[i][k].first = dp[i - 2][k - 1].second + max(0, a[i - 1] - a[i] + 1) +
max(0, a[i + 1] - a[i] + 1);
int f = min(a[i - 2] - 1, a[i - 1]);
dp[i][k].first =
min(dp[i][k].first, dp[i - 2][k - 1].first + max(0, f - a[i] + 1) +
max(0, a[i + 1] - a[i] + 1));
dp[i][k].second = min(dp[i - 1][k].first, dp[i - 1][k].second);
}
}
for (int i = 1; i <= n; i++) {
for (int k = 1; k <= most; k++) {
}
}
for (int k = 1; k <= most; k++) {
cout << min(dp[n][k].first, dp[n][k].second) << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 111, inf = 1111111111;
int n;
string s;
int main() {
cin >> n >> s;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (s[i] == '*' && s[j] == '*') {
int d = j - i, x = j, f = 0;
for (int k = 0; k < 3; ++k) {
x += d;
if (x >= n || s[x] == '.') {
f = 1;
break;
}
}
if (f == 0) {
cout << "yes" << endl;
return 0;
}
}
}
}
cout << "no" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n1, n2, k1, k2;
scanf("%d%d%d%d", &n1, &n2, &k1, &k2);
if (n2 >= n1)
puts("Second");
else
puts("First");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long infLL = 0x3f3f3f3f3f3f3f3fLL;
const int maxn = 100000 + 5;
const int mod = 1000000007;
int n;
vector<int> ch[maxn];
bool vis[maxn];
int f[maxn][2];
void dp(int u) {
if (vis[u]) return;
vis[u] = true;
f[u][0] = 0;
f[u][1] = 1;
if (ch[u].empty()) return;
int m = ch[u].size(), v;
for (int i = 0; i < (m); ++i) dp(ch[u][i]);
for (int i = 0; i < (m); ++i) {
int v = ch[u][i];
int n0 =
((long long)f[u][0] * f[v][0] + (long long)f[u][1] * f[v][1]) % mod;
int n1 =
((long long)f[u][0] * f[v][1] + (long long)f[u][1] * f[v][0]) % mod;
f[u][0] = (f[u][0] + n0) % mod;
f[u][1] = (f[u][1] + n1) % mod;
}
f[u][0] = f[u][0] * 2 % mod;
f[u][1] = f[u][1] * 2 % mod;
int g[2];
g[0] = 1;
for (int i = 0; i < (m); ++i) {
int v = ch[u][i];
g[0] = (g[0] + (long long)g[0] * f[v][0]) % mod;
}
f[u][1] = (f[u][1] + mod - g[0]) % mod;
g[0] = 1;
g[1] = 0;
for (int i = 0; i < (m); ++i) {
int v = ch[u][i], t = g[0];
g[0] = (g[0] + (long long)g[1] * f[v][1]) % mod;
g[1] = (g[1] + (long long)t * f[v][1]) % mod;
}
f[u][0] = (f[u][0] + mod - g[1]) % mod;
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n - 1); ++i) {
int pa;
scanf("%d", &pa);
--pa;
ch[pa].push_back(i);
}
dp(0);
printf("%d\n", (f[0][0] + f[0][1]) % mod);
return 0;
}
| 9 |
#include<bits/stdc++.h>
using namespace std;
const long long inf=1000000000000000000ll;
int q[2000200],l,r,cnt,n,d,x,hd[2200],la[2200],f[2200],lo[2200];
struct node{int to,next,c,val;}e[2000010];
char s[1100];
bool inq[2200];
long long dis[2200];
vector<int> pa;
void add(int x,int y,int c,int val)
{
e[++cnt]=(node){y,hd[x],c,-val},hd[x]=cnt;
e[++cnt]=(node){x,hd[y],0,val},hd[y]=cnt;
}
bool spfa()
{
dis[1]=0,inq[1]=1,f[1]=1000000000;
for (int i=2; i<=(1<<d+1)+2; i++) dis[i]=inf,inq[i]=0;
q[l=r=1]=1;
while (l<=r)
{
x=q[l++],inq[x]=0;
for (int i=hd[x]; i; i=e[i].next)
if (e[i].c&&dis[e[i].to]>dis[x]+e[i].val)
{
dis[e[i].to]=dis[x]+e[i].val;
la[e[i].to]=i,f[e[i].to]=min(f[x],e[i].c);
if (!inq[e[i].to]) inq[e[i].to]=1,q[++r]=e[i].to;
}
}
return dis[(1<<d+1)+2]!=inf;
}
bool findpath(int x)
{
for (int i=hd[x]; i; i=e[i].next)
if (e[i^1].c&&e[i].to!=(x-(1<<d)))
{
e[i^1].c--,e[i].c++;
if (e[i].to==(1<<d+1)+2) return 1;
if (x!=1) pa.push_back(lo[(x-(1<<d)-2)^(e[i].to-2)]);
x=e[i].to;
for (int j=hd[x]; j; j=e[j].next)
if (e[j].to==x+(1<<d))
{
e[j].c++,e[j^1].c--;
return findpath(e[j].to);
}
}
}
int main()
{
scanf("%d%d",&d,&n),cnt=1;
for (int i=0; i<d; i++) lo[1<<i]=i;
add(1,2,2000,0);
for (int i=0; i<(1<<d)-1; i++)
for (int j=0; j<d; j++) if (!((i>>j)&1)) add(i+2+(1<<d),(i|(1<<j))+2,2000,-1);
for (int i=1; i<=n; i++)
{
scanf("%s",s),x=0;
for (int j=0; j<d; j++) x|=((s[j]-'0')<<j);
add(x+2,x+2+(1<<d),1,1000000000);
}
for (int i=0; i<(1<<d); i++)
{
add(i+2,i+2+(1<<d),2000,0);
add(i+2+(1<<d),(1<<d+1)+2,2000,-1);
}
long long ans=0;
while (spfa())
{
x=(1<<d+1)+2;
int F=f[x]; long long D=dis[x];
if (D>0) break;
while (x!=1) e[la[x]].c-=F,e[la[x]^1].c+=F,x=e[la[x]^1].to;
ans+=D;
}
printf("%lld\n",ans=(((ans-1)%1000000000+1000000000)%1000000000));
while (findpath(1))
{
//cerr<<ans<<endl;
for (int i=0,sz=pa.size(); i<sz; i++) printf("%d ",pa[i]);
ans-=pa.size();
if (ans) printf("R "),ans--; else break;
pa.clear();
}
puts("");
return 0;
} | 9 |
#include <bits/stdc++.h>
using namespace std;
int n, k, ans, y, t;
vector<int> a, v, h, sf;
int main() {
cin >> t;
while (t--) {
cin >> n >> k;
sf.clear();
sf.resize(n + 2, 0);
a.resize(n + 1, 0);
v.resize(n + 1, 0);
h.resize(n + 1, 0);
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) cin >> y;
sort(a.begin() + 1, a.begin() + n + 1);
for (int i = 1; i <= n; ++i) {
int l = lower_bound(a.begin() + 1, a.begin() + n + 1, a[i]) - a.begin(),
hi = upper_bound(a.begin() + 1, a.begin() + n + 1, a[i] + k) -
a.begin();
v[i] = hi - l, h[i] = hi;
}
for (int i = n; i >= 1; --i) sf[i] = max(sf[i + 1], v[i]);
ans = 0;
for (int i = 1; i <= n; ++i) {
int l = v[i], r = sf[h[i]];
ans = max(ans, l + r);
}
cout << ans << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 1e5;
bool vis[2500], check = 0;
long long counter, maxi = 0;
vector<vector<long long>> adj(N);
void dfs(int node, int levels) {
vis[node] = 1;
levels++;
for (long long i = 0; i < adj[node].size(); i++) {
int child = adj[node][i];
if (!vis[child]) {
dfs(child, levels);
}
}
maxi = max((int)maxi, (int)levels);
}
int main() {
int n, u;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> u;
if (u == -1) u = i;
adj[u].push_back(i);
}
for (int i = 1; i <= n; i++) {
memset(vis, 0, sizeof(vis));
dfs(i, 0);
}
cout << maxi;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[200000 + 5];
int a[200000 + 5];
int main() {
int n;
while (~scanf("%d", &n)) {
scanf("%s", s);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int minn = 1000000000, flag = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'R' && s[i + 1] == 'L') {
minn = min(minn, (a[i + 1] - a[i]) / 2);
flag = 1;
}
}
if (flag)
printf("%d\n", minn);
else
printf("-1\n");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long t;
while (a % b) {
t = a % b;
a = b;
b = t;
}
return b;
}
int main() {
long long a, b, l;
cin >> a >> b;
l = (a * b) / gcd(a, b);
a = a;
b = b;
long long fir, sec;
fir = (l - 1) / a;
sec = (l - 1) / b;
if (a > b)
fir++;
else
sec++;
if (fir > sec)
cout << "Dasha";
else if (fir < sec)
cout << "Masha";
else
cout << "Equal";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int x[4];
int y[4];
int ii[4] = {1, -1, 0, 0};
int jj[4] = {0, 0, -1, 1};
int main() {
ios_base::sync_with_stdio(0);
int x1, x2, x3, y1, y2, y3;
for (int i = 1; i <= 3; i++) {
cin >> x[i] >> y[i];
}
set<pair<int, int>> s;
long long xx = 0, yy = 0;
long long d = 1e9;
for (int j = 0; j <= 1000; j++) {
for (int i = 0; i <= 1000; i++) {
if (abs(x[1] - i) + abs(y[1] - j) + abs(x[2] - i) + abs(y[2] - j) +
abs(x[3] - i) + abs(y[3] - j) <
d) {
xx = i;
yy = j;
d = abs(x[1] - i) + abs(y[1] - j) + abs(x[2] - i) + abs(y[2] - j) +
abs(x[3] - i) + abs(y[3] - j);
}
}
}
for (int t = 1; t <= 3; t++) {
int i, j;
i = xx;
j = yy;
s.insert({x[t], y[t]});
while (i != x[t] || j != y[t]) {
s.insert({i, j});
for (int e = 0; e < 4; e++) {
if (abs(i - x[t]) > abs(i + ii[e] - x[t]) ||
abs(j - y[t]) > abs(j + jj[e] - y[t])) {
i += ii[e];
j += jj[e];
break;
}
}
}
}
cout << s.size() << '\n';
for (auto p : s) {
cout << p.first << ' ' << p.second << '\n';
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1.5e5 + 70;
const int INF = 2.1e9;
const int MOD = 1e9 + 7;
const double eps = 1e-7;
const double PI = acos(-1.0);
int n, m, k;
int f[maxn];
vector<int> G[maxn];
void init(int n) {
for (int i = 1; i <= n; i++) {
G[i].clear();
G[i].push_back(i);
f[i] = i;
}
}
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
void Union(int x, int y) {
int u = find(x), v = find(y);
assert(u != v);
if (G[u].size() > G[v].size()) swap(u, v);
f[u] = v;
for (int i = 0; i < G[u].size(); i++) G[v].push_back(G[u][i]);
}
int main() {
while (cin >> n) {
init(n);
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
Union(x, y);
}
int u = find(1);
for (int i = 0; i < G[u].size(); i++) {
if (i) putchar(' ');
printf("%d", G[u][i]);
}
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1e9 + 7;
const double pi = 2 * acos(0.0);
const int N = 3e5 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, t;
cin >> t;
while (t--) {
cin >> n;
int x, z = 0, tot = 0;
for (int i = 0; i < n; i++) {
cin >> x;
if (!x) z++;
tot += x;
}
cout << z + ((tot + z) == 0) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
constexpr int MAXN = 2e5 + 1;
constexpr int MAGIC = 4;
using ll = long long;
using Arr = array<int, MAGIC>;
int N, M, K;
string s;
int x[MAXN], y[MAXN], len[MAXN];
Arr MOD, BASE;
inline int norm(int a, const int& mod) {
while (a >= mod) a -= mod;
while (a < 0) a += mod;
return a;
}
inline int mul(int a, int b, const int& mod) { return int(1LL * a * b % mod); }
inline Arr operator+(const Arr& a, const Arr& b) {
Arr ret;
for (int i = (int)0; i < (int)ret.size(); ++i) {
ret[i] = norm(a[i] + b[i], MOD[i]);
}
return ret;
}
inline Arr operator-(const Arr& a, const Arr& b) {
Arr ret;
for (int i = (int)0; i < (int)ret.size(); ++i) {
ret[i] = norm(a[i] - b[i], MOD[i]);
}
return ret;
}
inline Arr operator*(const Arr& a, const Arr& b) {
Arr ret;
for (int i = (int)0; i < (int)ret.size(); ++i) {
ret[i] = mul(a[i], b[i], MOD[i]);
}
return ret;
}
int CMODS[] = {int(1e9) + 7, int(1e9) + 9, int(1e9) + 21, int(1e9) + 33,
int(1e9) + 87, int(1e9) + 93, int(1e9) + 97, int(1e9) + 103};
int CBASE[] = {1009, 1013, 1019, 1021};
Arr pBase[MAXN];
Arr ph[27][MAXN];
vector<int> ord[MAXN];
void Init() {
mt19937 rnd;
unsigned int seed = N;
for (int i = (int)0; i < (int)N; ++i) {
seed = (seed * 3) + s[i];
}
for (int i = (int)0; i < (int)M; ++i) {
seed = (seed * 3) + x[i];
seed = (seed * 3) + y[i];
seed = (seed * 3) + len[i];
}
rnd.seed(seed);
set<int> mids;
while (mids.size() < MOD.size()) {
mids.emplace(rnd() % 8);
}
vector<int> vmids(mids.begin(), mids.end());
for (int i = (int)0; i < (int)MOD.size(); ++i) {
MOD[i] = CMODS[vmids[i]];
BASE[i] = CBASE[i];
}
pBase[0] = {1, 1, 1, 1};
for (int i = (int)1; i < (int)MAXN; ++i) {
pBase[i] = pBase[i - 1] * BASE;
}
for (int c = (int)0; c < (int)26; ++c) {
ph[c][0] = {0, 0};
for (int i = (int)0; i < (int)N; ++i) {
int val = (s[i] - 'a' == c);
ph[c][i + 1] = ph[c][i] * BASE + Arr{val, val};
}
}
vector<int> cur_ord(26, 0);
iota(cur_ord.begin(), cur_ord.end(), 0);
for (int i = (int)N - 1; i >= (int)0; --i) {
ord[i] = cur_ord;
auto it = find(ord[i].begin(), ord[i].end(), int(s[i] - 'a'));
ord[i].erase(it);
ord[i].emplace(ord[i].begin(), int(s[i] - 'a'));
cur_ord = ord[i];
}
}
Arr GetHash(int id, int l, int r) {
return ph[id][r] - ph[id][l] * pBase[r - l];
}
void Solution() {
Init();
for (int q = (int)0; q < (int)M; ++q) {
int s1 = x[q], s2 = y[q];
bool ok = true;
for (int i = (int)0; i < (int)26; ++i) {
if (GetHash(ord[s1][i], s1, s1 + len[q]) !=
GetHash(ord[s2][i], s2, s2 + len[q])) {
ok = false;
break;
}
}
cout << (ok ? "YES" : "NO") << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
while (cin >> N >> M) {
cin >> s;
for (int i = 0; i < M; ++i) {
cin >> x[i] >> y[i] >> len[i];
--x[i], --y[i];
}
Solution();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[500005];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
int ans = 0;
for (int i = 1; i <= n;) {
int j = i;
while (j + 1 <= n && a[j] != a[j + 1]) ++j;
int len = j - i + 1;
if (a[i] == a[j]) {
for (int k = i + 1; k <= j; ++k) a[k] = a[i];
ans = max(ans, len / 2);
} else {
int k;
for (k = i + 1; k <= (i + j) / 2; ++k) a[k] = a[i];
for (; k < j; ++k) a[k] = a[j];
ans = max(ans, len / 2 - 1);
}
i = j + 1;
}
cout << ans << endl;
for (int i = 1; i <= n; ++i) cout << a[i] << ' ';
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
const int MAXN = 3e5 + 10;
const int LOG = 20;
using namespace std;
struct Seg {
int soma[MAXN * 4];
int mx[MAXN * 4];
int m(int l, int r) { return (l + r) >> 1; }
void upd(int pos, int l, int r, int idx, int k) {
if (l == r) {
soma[pos] += k;
mx[pos] = soma[pos];
return;
}
if (idx <= m(l, r))
upd(pos << 1, l, m(l, r), idx, k);
else
upd(pos << 1 | 1, m(l, r) + 1, r, idx, k);
soma[pos] = soma[pos << 1] + soma[pos << 1 | 1];
mx[pos] = max(mx[pos << 1 | 1], mx[pos << 1] + soma[pos << 1 | 1]);
}
int qry() { return mx[1]; }
};
int N;
int perm[MAXN], bomb[MAXN], resp[MAXN];
Seg seg;
int main() {
scanf("%d", &N);
for (int i = 1; i < N + 1; i++) {
int x;
scanf("%d", &x);
perm[x] = i;
}
for (int i = 1; i < N + 1; i++) scanf("%d", &bomb[i]);
int ptr = N;
for (int i = 1; i < N; i++) {
seg.upd(1, 1, N, bomb[i], -1);
while (seg.qry() <= 0) seg.upd(1, 1, N, perm[ptr--], 1);
resp[i] = ptr + 1;
}
printf("%d ", N);
for (int i = 1; i < N; i++) printf("%d ", resp[i]);
printf("\n");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int T, n, m;
bool check(int k) {
if (n == 1) return 1;
long long num = (long long)m * k, res = 1, C = 1;
for (int i = 1; i <= k; i++) {
if (num < i) return 0;
if ((long long)(k - i + 1) * C >= (long long)n * i)
C = n;
else
C = C * (k - i + 1) / i;
long long temp = min(num / i, C);
res += temp;
if (res >= n) return 1;
num -= temp * i;
}
return 0;
}
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
int l = 0, r = n, mid, ans;
while (l <= r) {
mid = (l + r) / 2;
if (check(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%d\n", ans);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int mark[1000001], dp[1000001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, a, ans = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
mark[a] = 1;
dp[a] = 1;
}
for (int i = 1; i < 1000001; i++)
if (mark[i]) {
ans = max(ans, dp[i]);
for (int j = 2 * i; j < 1000001; j += i) dp[j] = max(dp[j], dp[i] + 1);
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[1000], i, j;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - 1; j++) {
if ((min(a[i], a[i + 1]) < min(a[j], a[j + 1]) &&
min(a[j], a[j + 1]) < max(a[i], a[i + 1]) &&
max(a[i], a[i + 1]) < max(a[j], a[j + 1])) ||
(min(a[j], a[j + 1]) < min(a[i], a[i + 1]) &&
min(a[i], a[i + 1]) < max(a[j], a[j + 1]) &&
max(a[j], a[j + 1]) < max(a[i], a[i + 1]))) {
cout << "yes";
return 0;
}
}
}
cout << "no";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
pair<pair<int, int>, int> p[N];
pair<pair<int, int>, int> v[2 * N];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
p[i] = pair<pair<int, int>, int>(pair<int, int>(a, b), i);
v[2 * i] = pair<pair<int, int>, int>(pair<int, int>(a, b), i);
v[2 * i + 1] = pair<pair<int, int>, int>(pair<int, int>(b, a), i);
}
sort(p, p + n);
sort(v, v + 2 * n);
int pos = 0;
for (int i = 0; i < 2 * n; i++) {
if (v[i].second == p[pos].second) pos++;
if (pos == n) {
cout << v[i].first.first << endl;
return 0;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e8;
const int MAXN = 100000;
void solve() {
vector<string> v(8);
for (int i = 0; i < 8; ++i) cin >> v[i];
int minA = 10;
for (int j = 0; j < 8; ++j) {
int curA = 0;
while (curA < 8 && v[curA][j] == '.') curA++;
if (curA < 8 && v[curA][j] == 'W') minA = min(minA, curA);
}
int minB = 10;
for (int j = 0; j < 8; ++j) {
int curB = 7;
while (curB >= 0 && v[curB][j] == '.') curB--;
if (curB >= 0 && v[curB][j] == 'B') minB = min(minB, 8 - curB - 1);
}
if (minA <= minB)
cout << 'A';
else
cout << 'B';
}
int main() {
cin.sync_with_stdio(false);
cout.sync_with_stdio(false);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int p) {
long long int r = 1;
x = x % p;
while (y) {
if (y & 1) r = r * x % p;
y = y >> 1;
x = x * x % p;
}
return r;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int csrand(int l = 0, int r = 1e9) {
uniform_int_distribution<int> uid(l, r);
return uid(rng);
}
const int N = 2e5 + 99;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t0;
cin >> t0;
while (t0--) {
long long int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> pf(n, 0);
vector<int> zrs(n + 1, 0);
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '1') pf[i]++, cnt++;
if (i) pf[i] += pf[i - 1];
if (s[i] == '0') {
if (k >= pf[i])
zrs[i] = 0, k -= pf[i];
else
zrs[i] = pf[i] - k, k = 0;
}
}
int pr = 0;
std::vector<int> ans;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
int kk = pr;
for (int j = 0; j < zrs[i] - kk; j++) ans.push_back(1), cnt--, pr++;
ans.push_back(0);
}
}
for (int i = 0; i < cnt; i++) ans.push_back(1);
for (auto x : ans) cout << x;
cout << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char str[100007];
int ar[100007];
int ans[100007];
int main(void) {
scanf("%s", str);
int n = strlen(str);
int i, ps, mx = 0;
for (i = n - 1; i >= 0; i--) {
if (str[i] == ')' || str[i] == ']') continue;
if (str[i] == '(' && str[i + 1] == ')') {
ar[i] = 2 + ar[i + 2];
ans[i] = ans[i + 2];
if (ans[i] > mx) {
mx = ans[i];
ps = i;
}
continue;
}
if (str[i] == '[' && str[i + 1] == ']') {
ar[i] = 2 + ar[i + 2];
ans[i] = 1 + ans[i + 2];
if (ans[i] > mx) {
mx = ans[i];
ps = i;
}
continue;
}
if (str[i] == '(') {
if (str[i + ar[i + 1] + 1] == ')') {
ar[i] = 2 + ar[i + 1] + ar[i + ar[i + 1] + 2];
ans[i] = ans[i + 1] + ans[i + ar[i + 1] + 2];
}
}
if (str[i] == '[') {
if (str[i + ar[i + 1] + 1] == ']') {
ar[i] = 2 + ar[i + 1] + ar[i + ar[i + 1] + 2];
ans[i] = 1 + ans[i + 1] + ans[i + ar[i + 1] + 2];
}
}
if (ans[i] > mx) {
mx = ans[i];
ps = i;
}
}
printf("%d\n", mx);
for (i = ps; i - ps < ar[ps]; i++) {
printf("%c", str[i]);
}
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abss(T a) {
return a > 0 ? a : -a;
}
const static double eps = 0.001;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
size_t _q_;
cin >> _q_;
while (_q_--) {
int64_t angle;
cin >> angle;
uint64_t n = 3;
while (angle > (n - 2) * 180.0 / n) {
++n;
}
if (angle == (n - 2) * 180.0 / n)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, m, a[N], b[N];
int sum = 0;
bool check(int x) {
bool vis[N] = {0};
int cur = x - m - sum;
int cnt = 0;
while (x) {
if (cur < 0) return false;
if (a[x] != 0 && !vis[a[x]]) {
cnt++;
vis[a[x]] = true;
cur += b[a[x]];
} else
cur--;
x--;
}
return (cur >= 0 && cnt == m);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= m; i++) {
scanf("%d", b + i);
sum += b[i];
}
int lo = sum, hi = n;
int res = -1;
while (lo <= hi) {
int mid = (lo + hi) >> 1;
if (check(mid)) {
res = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
cout << res << endl;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int T;
scanf("%d", &T);
while (T--) {
double a, b;
scanf("%lf %lf", &a, &b);
double x, y;
if (b >= (a / 4)) {
x = (b + a / 8) * a;
y = a * 2 * b;
} else if (b < (a / 4)) {
x = a * b + (2 * a - 4 * b) * b / 2;
y = a * 2 * b;
}
if (b == 0)
printf("1\n");
else if (a == 0)
printf("0.5\n");
else
printf("%.10lf\n", x / y);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int BIT = (1 << 17), M = 110, N = 25;
int n, m, cnt[BIT], a[M];
long long f[BIT][N], b[N], p[N], year;
void solve(int x) {
memset(f, 0, sizeof(f));
f[0][0] = 1;
int maxb = (1 << n);
for (int i = 0; i < maxb; i++) {
for (int j = 0; j <= n; j++) {
int y = cnt[i] + 1;
if (b[y]) {
if ((a[b[y]] & i) != a[b[y]]) continue;
if ((1 << (b[y] - 1) & i) == (1 << b[y] - 1)) continue;
f[i | (1 << b[y] - 1)][j] += f[i][j];
} else {
for (int k = 1; k <= n; k++) {
if (!(i & (1 << k - 1))) {
if ((a[k] & i) != a[k]) continue;
if (k == x)
f[i | (1 << k - 1)][y] += f[i][j];
else
f[i | (1 << k - 1)][j] += f[i][j];
}
}
}
}
}
}
int main() {
scanf("%d%lld%d", &n, &year, &m);
year -= 2000;
for (int i = 1; i < BIT; i++) cnt[i] = cnt[i ^ (i & (-i))] + 1;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
a[y] |= (1 << x - 1);
}
for (int i = 1; i <= n; i++) {
solve(i);
long long sum = 0;
for (int j = 1; j <= n; j++) {
if (!b[j] && sum + f[(1 << n) - 1][j] >= year) {
b[j] = i;
p[i] = j;
year -= sum;
break;
}
sum += f[(1 << n) - 1][j];
}
if (!p[i]) {
puts("The times have changed");
return 0;
}
}
for (int i = 1; i <= n; i++) printf("%lld ", p[i]);
puts("");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long sum(long long a, long long b) {
return ((b * (b + 1)) - ((a - 1) * a)) / 2;
}
long long ind(long long a, long long val) {
double D = sqrt((2 * a - 1) * (2 * a - 1) + 8 * val);
return (long long)((1 - 2 * a + D) / 2);
}
int main() {
ios_base::sync_with_stdio(0);
int t, i, j;
long long n, m;
cin >> n >> m;
long long arr[n];
for (i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
long long spent = 0;
vector<long long> ans;
if (arr[0] != 1) {
if (sum(1, arr[0] - 1) <= m) {
for (i = 1; i <= arr[0] - 1; i++) ans.push_back(i);
spent += sum(1, arr[0] - 1);
} else {
long long num = ind(1, m);
cout << num << "\n";
for (i = 1; i <= num; i++) cout << i << " ";
return 0;
}
}
for (i = 0; i < n - 1; i++) {
if (arr[i] == arr[i + 1]) continue;
if (sum(arr[i] + 1, arr[i + 1] - 1) + spent <= m) {
for (j = arr[i] + 1; j <= arr[i + 1] - 1; j++) ans.push_back(j);
spent += sum(arr[i] + 1, arr[i + 1] - 1);
} else {
long long num = ind(arr[i] + 1, m - spent);
for (j = 1; j <= num; j++) ans.push_back(arr[i] + j);
break;
}
}
if (i == n - 1) {
long long num = ind(arr[n - 1] + 1, m - spent);
for (j = 1; j <= num; j++) ans.push_back(arr[n - 1] + j);
}
cout << ans.size() << "\n";
for (i = 0; i < ans.size(); i++) cout << ans[i] << " ";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void see(int x) { cout << x; }
void see(long long int x) { cout << x; }
void see(long double x) { cout << x; }
void see(char x) { cout << '\'' << x << '\''; }
void see(string x) { cout << '\"' << x << '\"'; }
template <typename T, typename V>
void see(const pair<T, V> &x) {
cout << '{';
see(x.first);
cout << ',';
see(x.second);
cout << '}';
}
template <typename T>
void see(const T &x) {
int f = 0;
cout << '{';
for (auto &i : x) cout << (f++ ? "," : ""), see(i);
cout << "}";
}
void _print() { cout << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
see(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
long long int gcd(long long int a, long long int b) {
return (!b) ? a : gcd(b, a % b);
}
void solve() {
int n, k;
cin >> n >> k;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
int dp[n + 1][n + 1];
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= i; j++) dp[i][j] = 0;
}
for (int i = 0; i <= n - 1; i++) {
for (int j = 0; j <= i; j++) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] + (a[i + 1] == j + 1));
}
}
for (int i = n; i >= 0; i--) {
if (dp[n][i] >= k) {
cout << n - i << '\n';
return;
}
}
cout << -1 << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
for (int ti = 1; ti <= t; ti++) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
bool a[N];
int ps[N];
int n, k;
int canDo(int x) {
for (int i = 0; i + x <= n; i++)
if (ps[i + x] - ps[i] <= k) return i;
return -1;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) ps[i + 1] = ps[i] + (!a[i]);
int l = 0, r = n + 1;
while (r - l > 1) {
int mid = (r + l) / 2;
if (canDo(mid) != -1)
l = mid;
else
r = mid;
}
cout << l << "\n";
int pos = canDo(l);
for (int i = 0; i < n; i++)
if (i >= pos && i < pos + l)
cout << 1 << " ";
else
cout << a[i] << " ";
cout << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
bool H[9][9][9][9];
char t[4];
int n;
void set() {
int i;
for (i = 0; i < 4; i++) t[i] = t[i] - '0';
}
void look(int i, int j, int k, int l) {
H[j][k][l][i] = H[j][k][l][i] = H[k][l][i][j] = H[l][i][j][k] = false;
}
int main() {
int i, j, k, l, s = 0;
char tm[3];
scanf(" %d", &n);
for (i = 0; i < n; i++) {
if (i) scanf(" %s", tm);
scanf(" %c %c %c %c", &t[0], &t[1], &t[3], &t[2]);
set();
H[t[0]][t[1]][t[2]][t[3]] = true;
}
for (i = 1; i < 7; i++)
for (j = 1; j < 7; j++)
for (k = 1; k < 7; k++)
for (l = 1; l < 7; l++) {
if (H[i][j][k][l]) {
look(i, j, k, l);
s++;
}
}
printf("%d\n", s);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void bug() { cout << " " << endl; }
template <class T>
void bug(T a) {
cout << a << " ";
}
template <class T>
void bug(T* a, int n) {
for (int i = 0; i < (n); i++) bug(a[i]);
}
priority_queue<pair<long long, int> > q;
int n, m;
vector<pair<int, long long> > g[1111111];
long long d[1111111];
int mark[1111111], fa[1111111];
vector<pair<long long, pair<int, int> > > e;
int find(int u) {
if (u == fa[u])
return u;
else
return fa[u] = find(fa[u]);
}
void update(int u, long long dist, int m) {
if (dist < d[u]) {
d[u] = dist;
mark[u] = m;
q.push(make_pair(-dist, u));
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < (m); i++) {
int x, y, w;
cin >> x >> y >> w;
x--;
y--;
g[x].push_back(make_pair(y, w));
g[y].push_back(make_pair(x, w));
}
for (int i = 0; i < (n); i++) d[i] = 1000000000000000000LL;
int k;
cin >> k;
for (int i = 0; i < (k); i++) {
int x;
cin >> x;
mark[x - 1] = x - 1;
update(x - 1, 0, x - 1);
}
while (q.size() > 0) {
pair<long long, int> p = q.top();
q.pop();
long long dist = -p.first;
int u = p.second;
if (d[u] != dist) continue;
for (int i = 0; i < (g[u].size()); i++) {
int v = g[u][i].first;
update(v, g[u][i].second + dist, mark[u]);
}
}
long long ans = d[0];
for (int u = 0; u < (n); u++)
for (int i = 0; i < (g[u].size()); i++) {
int v = g[u][i].first;
if (u < v && mark[u] != mark[v])
e.push_back(make_pair(d[u] + d[v] + g[u][i].second,
make_pair(mark[u], mark[v])));
}
sort(e.begin(), e.end());
for (int i = 0; i < (n); i++) fa[i] = i;
for (int i = 0; i < (e.size()); i++) {
int u = e[i].second.first, v = e[i].second.second;
long long cost = e[i].first;
if (find(u) != find(v)) {
ans += cost;
fa[find(u)] = find(v);
}
}
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e6;
pair<int, int> a[maxn];
long long b[maxn];
int n, m;
long long getLen(int i) {
if (a[i].second == -1) return 1;
return 1ll * a[i].first * a[i].second;
}
int main() {
scanf("%d", &m);
vector<int> v;
for (int i = 0; i < m; ++i) {
int type;
scanf("%d", &type);
if (type == 1) {
int x;
scanf("%d", &x);
a[i] = make_pair(x, -1);
} else if (type == 2) {
int l, cnt;
scanf("%d%d", &l, &cnt);
a[i] = make_pair(l, cnt);
}
}
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%lld", &b[i]);
long long cursize = 0;
for (int j = 0, i = 0; i < n; ++i) {
while (cursize + getLen(j) < b[i]) {
if (a[j].second == -1) {
if (v.size() < maxn) v.push_back(a[j].first);
} else {
for (int c = 0; v.size() < maxn && c < a[j].second; ++c)
for (int l = 0; v.size() < maxn && l < a[j].first; ++l)
v.push_back(v[l]);
}
cursize += getLen(j);
++j;
}
if (a[j].second == -1) {
printf("%d ", a[j].first);
} else {
printf("%d ", v[(b[i] - 1ll - cursize) % a[j].first]);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
};
int n;
cin >> n;
vector<int> v;
int sum = 0;
for (int i = 0; i < 500; i++) {
sum += i;
v.push_back(sum);
}
int ara[27] = {0};
int ch = 0;
if (n == 0) {
cout << 'a';
return 0;
}
while (n) {
int y = lower_bound(v.begin(), v.end(), n) - v.begin();
if (v[y] != n) {
y--;
}
ara[ch] = y + 1;
n -= v[y];
ch++;
}
string second;
for (int i = 0; i < 26; i++) {
for (int j = 0; j < ara[i]; j++) {
second.push_back('a' + i);
}
}
cout << second;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1.0);
const int MAXN = 400003;
int ad[MAXN];
int vl[MAXN];
int x[MAXN];
int lv;
void modify_rmq(int v, int l, int r) {
if (l == r) {
if (x[l] == 0)
vl[v] = ad[v] = -1;
else
vl[v] = ad[v] = 1;
return;
}
int md = (l + r) / 2;
if (lv <= md)
modify_rmq(v * 2 + 1, l, md);
else
modify_rmq(v * 2 + 2, md + 1, r);
ad[v] = ad[v * 2 + 1] + ad[v * 2 + 2];
vl[v] = max(vl[v * 2 + 2], ad[v * 2 + 2] + vl[v * 2 + 1]);
}
int main() {
ios_base::sync_with_stdio(0);
memset(ad, 0, sizeof(ad));
memset(vl, 0, sizeof(vl));
memset(x, 0, sizeof(x));
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int tp;
cin >> lv >> tp;
if (tp == 1) cin >> x[lv];
modify_rmq(0, 1, n);
if (vl[0] <= 0) {
cout << -1 << "\n";
continue;
}
int v = 0, l = 1, r = n, a = 0;
while (l != r) {
int md = (l + r) / 2;
v = (v * 2 + 2);
if (vl[v] + a > 0)
l = md + 1;
else {
r = md;
a += ad[v];
v--;
}
}
cout << x[l] << "\n";
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 3005;
int dp[MAX][2];
int n, a[MAX], b[MAX], c[MAX];
int go(int id, int fed) {
if (id == n - 1) {
if (fed)
return b[id];
else
return a[id];
}
int& ans = dp[id][fed];
if (ans != -1) return ans;
ans = 0;
if (fed) {
ans = max({ans, c[id] + go(id + 1, 0), b[id] + go(id + 1, 1)});
} else {
ans = max({ans, b[id] + go(id + 1, 0), a[id] + go(id + 1, 1)});
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < n; i++) {
cin >> c[i];
}
memset(dp, -1, sizeof dp);
cout << go(0, 0) << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
signed long long t;
cin >> t;
while (t--) {
string s;
cin >> s;
signed long long x;
cin >> x;
int n = s.length();
vector<bool> vis(n, false);
string w(n, '1');
bool ans = true;
for (int i = 0; i < n; i++) {
if (s[i] == '0') {
if (i - x >= 0) {
if (vis[i - x] == true && w[i - x] == '1') {
ans = false;
break;
} else {
vis[i - x] = true;
w[i - x] = '0';
}
}
if (i + x < n) {
if (vis[i + x] == true && w[i + x] == '1') {
ans = false;
break;
} else {
vis[i + x] = true;
w[i + x] = '0';
}
}
} else {
if (i - x >= 0 && w[i - x] == '1')
continue;
else if (i + x < n && w[i + x] == '1') {
vis[i + x] = true;
continue;
} else {
ans = false;
break;
}
}
}
if (ans == false) {
cout << -1 << endl;
} else
cout << w << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s;
char token[10500];
int cnt = 0;
vector<long long> st;
vector<char> op;
int prior[128];
inline int next(int i) {
if (!token[i + 1]) return i + 2;
return i + 1;
}
inline void process(char o) {
long long a = st.back();
st.pop_back();
long long b = st.back();
st.pop_back();
st.push_back((o == '+' ? (a + b) : (a * b)));
}
inline long long calc() {
st.clear();
op.clear();
for (int i = 0; i < cnt; i = next(i)) {
if (token[i] == '(')
op.push_back('(');
else if (token[i] == ')') {
while (op.back() != '(') {
process(op.back());
op.pop_back();
}
op.pop_back();
} else if (token[i] == '+' || token[i] == '*') {
char cur = token[i];
while (!op.empty() && prior[op.back()] >= prior[cur]) {
process(op.back());
op.pop_back();
}
op.push_back(cur);
} else {
st.push_back(token[i] - '0');
}
}
while (!op.empty()) {
process(op.back());
op.pop_back();
}
return st.back();
}
void print() {
int i = 0;
while (i < cnt) {
cout << token[i];
i = next(i);
}
cout << endl;
}
vector<int> pos;
int main() {
prior['+'] = 1;
prior['*'] = 2;
getline(cin, s);
token[0] = '1';
token[2] = '*';
for (int i = 1; i <= (int)s.size(); ++i) token[2 * i + 2] = s[i - 1];
token[2 * s.size() + 4] = '*';
token[2 * s.size() + 6] = '1';
cnt = 2 * s.size() + 7;
for (int i = 0; i < cnt; ++i)
if (token[i] == '*') pos.push_back(i);
long long ans = 0;
for (int i = 0; i < (int)pos.size(); ++i) {
token[pos[i] + 1] = '(';
for (int j = i + 1; j < (int)pos.size(); ++j) {
token[pos[j] - 1] = ')';
ans = max(ans, calc());
token[pos[j] - 1] = 0;
}
token[pos[i] + 1] = 0;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, id[200100], cnt = 1;
struct Suffix_Automaton {
int ch[26], len, fa;
} t[400100];
int Add(int x, int c) {
int xx = ++cnt;
t[xx].len = t[x].len + 1;
for (; x && !t[x].ch[c]; x = t[x].fa) t[x].ch[c] = xx;
if (!x) {
t[xx].fa = 1;
return xx;
}
int y = t[x].ch[c];
if (t[y].len == t[x].len + 1) {
t[xx].fa = y;
return xx;
}
int yy = ++cnt;
t[yy] = t[y], t[yy].len = t[x].len + 1;
t[xx].fa = t[y].fa = yy;
for (; x && t[x].ch[c] == y; x = t[x].fa) t[x].ch[c] = yy;
return xx;
}
char s[200100];
int fa[400100], dfn[400100], sz[400100], son[400100], rev[400100], top[400100],
dep[400100], tot;
vector<int> v[400100];
void dfs1(int x) {
sz[x] = 1;
for (auto y : v[x]) {
fa[y] = x, dep[y] = dep[x] + 1;
dfs1(y);
sz[x] += sz[y];
if (sz[y] > sz[son[x]]) son[x] = y;
}
}
void dfs2(int x) {
dfn[x] = ++tot, rev[tot] = x;
if (!top[x]) top[x] = x;
if (son[x]) top[son[x]] = top[x], dfs2(son[x]);
for (auto y : v[x])
if (y != son[x]) dfs2(y);
}
struct BIT {
long long s[400100];
long long t1[400100], t2[400100];
long long &operator[](const int &x) { return s[x]; }
BIT() {
memset(s, 0, sizeof(s)), memset(t1, 0, sizeof(t1)),
memset(t2, 0, sizeof(t2));
}
void ADD(int x, int y) {
for (int i = x; i <= cnt; i += i & -i)
t1[i] += y, t2[i] += 1ll * s[x - 1] * y;
}
long long SUM(int x) {
long long sum = 0;
for (int i = x; i; i -= i & -i) sum += t1[i];
sum *= s[x];
for (int i = x; i; i -= i & -i) sum -= t2[i];
return sum;
}
void ADD(int l, int r, int val) {
if (l <= r) ADD(l, val), ADD(r + 1, -val);
}
long long SUM(int l, int r) { return SUM(r) - SUM(l - 1); }
} bit;
void chainadd(int x, int val) {
x = id[n - x];
while (x) bit.ADD(dfn[top[x]], dfn[x], val), x = fa[top[x]];
}
long long chainsum(int x) {
x = id[n - x];
long long ret = 0;
while (x) ret += bit.SUM(dfn[top[x]], dfn[x]), x = fa[top[x]];
return ret;
}
int a[200100];
long long res;
int read() {
int x = 0;
char c = getchar();
while (c > '9' || c < '0') c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return x;
}
void print(long long x) {
if (x <= 9)
putchar('0' + x);
else
print(x / 10), putchar('0' + x % 10);
}
int main() {
n = read(), m = read(), scanf("%s", s), reverse(s, s + n);
for (int i = 0, las = 1; i < n; i++) id[i] = las = Add(las, s[i] - 'a');
for (int i = 2; i <= cnt; i++) v[t[i].fa].push_back(i);
dfs1(1), dfs2(1);
for (int i = 1; i <= cnt; i++)
bit[i] = bit[i - 1] + t[rev[i]].len - t[t[rev[i]].fa].len;
for (int i = 1, A, B; i <= m; i++) {
A = read(), B = read(), res = 0;
for (int i = 1; i <= A; i++) chainadd(a[i] = read(), 1);
for (int i = 1; i <= B; i++) res += chainsum(read());
for (int i = 1; i <= A; i++) chainadd(a[i], -1);
print(res), putchar('\n');
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long int n) {
if (n == 1) {
return false;
}
for (long long int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
int power(int x, unsigned int y, int p) {
int res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int findSubarraySum(long long int arr[], long long int n,
long long int sum) {
unordered_map<int, int> prevSum;
long long int res = 0;
long long int currsum = 0;
for (long long int i = 0; i < n; i++) {
currsum += arr[i];
if (currsum == sum) res++;
if (prevSum.find(currsum - sum) != prevSum.end())
res += (prevSum[currsum - sum]);
prevSum[currsum]++;
}
return res;
}
void countConnectedPair(vector<int> *v, vector<int> &visited, int index,
int &count) {
visited[index] = 1;
count++;
for (int i = 0; i < v[index].size(); i++) {
if (!visited[v[index][i]]) {
countConnectedPair(v, visited, v[index][i], count);
}
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, m, prod = 1;
cin >> n >> m;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (n > m)
cout << 0 << "\n";
else {
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
prod = (prod * (abs(a[i] - a[j])) % m) % m;
}
}
cout << prod << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
char a[1005];
scanf("%s", &a);
if (a[0] >= 'a' && a[0] <= 'z') {
a[0] = a[0] - 32;
}
printf("%s\n", a);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, x, y;
vector<int> vec;
bool check(int i) {
int l = i - 1, r = i + 1;
while (l >= 0 && abs(l - i) <= x) {
if (vec[l] < vec[i]) return false;
l--;
}
while (r < n && abs(r - i) <= y) {
if (vec[r] < vec[i]) return false;
r++;
}
return true;
}
int main() {
cin >> n >> x >> y;
for (int i = 0, a; i < n; ++i) {
cin >> a;
vec.push_back(a);
}
for (int i = 0, a; i < n; ++i) {
if (check(i)) {
return cout << i + 1 << '\n', 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
bool nw = 0;
while (t--) {
if (nw) cout << '\n';
nw = 1;
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int& x : a) cin >> x;
string ac;
if (n == 1 && a[0] == k) {
cout << "yes";
continue;
}
bool flg = 0;
for (int i = 0; i < n; i++) {
flg |= (a[i] == k);
ac += (char)('0' + (a[i] >= k));
}
if (flg ^ 1) {
cout << "no";
continue;
}
flg = 0;
for (int i = 0; i < n; i++) {
if (i + 1 < n) {
if (ac[i] == ac[i + 1] && ac[i] == '1') flg = 1;
}
if (i + 2 < n) {
int hw = 0;
hw = (ac[i] - '0') + (ac[i + 2] - '0') + (ac[i + 1] - '0');
flg |= (hw > 1);
}
}
if (flg)
cout << "yes";
else
cout << "no";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 513;
int a[MAX_N], b[MAX_N], last[2 * MAX_N], d[MAX_N][MAX_N];
pair<int, int> pr[MAX_N][MAX_N];
set<int> s;
map<int, int> ma;
vector<int> numbers;
int main() {
int n, m;
scanf("%d", &n);
for (int i = 0; (i) < (n); ++i) scanf("%d", &a[i]), s.insert(a[i]);
scanf("%d", &m);
for (int i = 0; (i) < (m); ++i) scanf("%d", &b[i]), s.insert(b[i]);
int it = 0;
for (auto k : s) ma[k] = it++, numbers.push_back(k);
for (int i = 0; (i) < (n); ++i) a[i] = ma[a[i]];
for (int i = 0; (i) < (m); ++i) b[i] = ma[b[i]];
for (int i = 0; (i) < (n); ++i) {
for (int j = 0; (j) < ((n + m)); ++j) last[j] = -1;
for (int j = 0; (j) < (m); ++j) {
last[b[j]] = j;
if (a[i] != b[j]) continue;
d[i][j] = 1;
pr[i][j] = make_pair(-1, -1);
for (int g = 0; (g) < (i); ++g)
if (a[g] < a[i] && last[a[g]] != -1) {
if (d[i][j] < d[g][last[a[g]]] + 1) {
d[i][j] = d[g][last[a[g]]] + 1;
pr[i][j] = make_pair(g, last[a[g]]);
}
}
}
}
int x = 0, y = 0, maxx = 0;
for (int i = 0; (i) < (n); ++i)
for (int j = 0; (j) < (m); ++j)
if (d[i][j] > maxx) maxx = d[i][j], x = i, y = j;
printf("%d\n", d[x][y]);
if (d[x][y] == 0) return 0;
vector<int> v;
while (x >= 0 && y >= 0) {
v.push_back(a[x]);
int x2 = pr[x][y].first;
y = pr[x][y].second;
x = x2;
}
reverse((v).begin(), (v).end());
for (int k : v) printf("%d ", numbers[k]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005, maxm = 25;
struct node {
int I, Sum[2], Max[2], L[2], R[2], Lmax[2], Lto[2], Rmax[2], Rto[2];
bool boo;
} tree[maxn << 2];
struct data {
int Sum, Max, L, R, Lmax, Lto, Rmax, Rto;
data() {}
data(int A, int B, int C, int D, int E, int F, int G, int H)
: Sum(A), Max(B), L(C), R(D), Lmax(E), Lto(F), Rmax(G), Rto(H) {}
};
int G, n, q, p, ans, val[maxn], reL[maxm], reR[maxm];
void check1(int root, int i, int A, int B, int C) {
if (A <= tree[root].Max[i]) return;
tree[root].Max[i] = A;
tree[root].L[i] = B;
tree[root].R[i] = C;
}
void check2(int root, int i, int A, int B) {
if (A <= tree[root].Lmax[i]) return;
tree[root].Lmax[i] = A;
tree[root].Lto[i] = B;
}
void check3(int root, int i, int A, int B) {
if (A <= tree[root].Rmax[i]) return;
tree[root].Rmax[i] = A;
tree[root].Rto[i] = B;
}
void build(int root, int L, int R) {
if (L == R) {
tree[root].I = 0;
tree[root].boo = false;
tree[root].Sum[0] = val[L];
tree[root].Max[0] = val[L];
tree[root].Lmax[0] = val[L];
tree[root].Rmax[0] = val[L];
tree[root].Sum[1] = -val[L];
tree[root].Max[1] = -val[L];
tree[root].Lmax[1] = -val[L];
tree[root].Rmax[1] = -val[L];
for (int i = 0; i <= 1; i++) {
tree[root].L[i] = L;
tree[root].R[i] = L;
tree[root].Lto[i] = L;
tree[root].Rto[i] = L;
}
return;
}
int mid = (L + R) >> 1, Lson = root << 1, Rson = Lson + 1;
build(Lson, L, mid);
build(Rson, mid + 1, R);
for (int i = 0; i <= 1; i++) {
tree[root].Sum[i] = tree[Lson].Sum[i] + tree[Rson].Sum[i];
tree[root].Max[i] = tree[Lson].Rmax[i] + tree[Rson].Lmax[i];
tree[root].L[i] = tree[Lson].Rto[i];
tree[root].R[i] = tree[Rson].Lto[i];
check1(root, i, tree[Lson].Max[i], tree[Lson].L[i], tree[Lson].R[i]);
check1(root, i, tree[Rson].Max[i], tree[Rson].L[i], tree[Rson].R[i]);
tree[root].Lmax[i] = tree[Lson].Sum[i] + tree[Rson].Lmax[i];
tree[root].Lto[i] = tree[Rson].Lto[i];
check2(root, i, tree[Lson].Lmax[i], tree[Lson].Lto[i]);
tree[root].Rmax[i] = tree[Rson].Sum[i] + tree[Lson].Rmax[i];
tree[root].Rto[i] = tree[Lson].Rto[i];
check3(root, i, tree[Rson].Rmax[i], tree[Rson].Rto[i]);
}
}
void update(int root, int L, int R, int x, int val) {
if (L == R) {
tree[root].I = 0;
tree[root].boo = false;
tree[root].Sum[0] = val;
tree[root].Max[0] = val;
tree[root].Lmax[0] = val;
tree[root].Rmax[0] = val;
tree[root].Sum[1] = -val;
tree[root].Max[1] = -val;
tree[root].Lmax[1] = -val;
tree[root].Rmax[1] = -val;
for (int i = 0; i <= 1; i++) {
tree[root].L[i] = L;
tree[root].R[i] = L;
tree[root].Lto[i] = L;
tree[root].Rto[i] = L;
}
return;
}
int mid = (L + R) >> 1, Lson = root << 1, Rson = Lson + 1;
if (x <= mid)
update(Lson, L, mid, x, val);
else
update(Rson, mid + 1, R, x, val);
for (int i = 0; i <= 1; i++) {
tree[root].Sum[i] = tree[Lson].Sum[i] + tree[Rson].Sum[i];
tree[root].Max[i] = tree[Lson].Rmax[i] + tree[Rson].Lmax[i];
tree[root].L[i] = tree[Lson].Rto[i];
tree[root].R[i] = tree[Rson].Lto[i];
check1(root, i, tree[Lson].Max[i], tree[Lson].L[i], tree[Lson].R[i]);
check1(root, i, tree[Rson].Max[i], tree[Rson].L[i], tree[Rson].R[i]);
tree[root].Lmax[i] = tree[Lson].Sum[i] + tree[Rson].Lmax[i];
tree[root].Lto[i] = tree[Rson].Lto[i];
check2(root, i, tree[Lson].Lmax[i], tree[Lson].Lto[i]);
tree[root].Rmax[i] = tree[Rson].Sum[i] + tree[Lson].Rmax[i];
tree[root].Rto[i] = tree[Lson].Rto[i];
check3(root, i, tree[Rson].Rmax[i], tree[Rson].Rto[i]);
}
}
void down(int root, int Lson, int Rson) {
if (!tree[root].boo) return;
tree[Lson].I ^= 1;
tree[Lson].boo ^= true;
tree[Rson].I ^= 1;
tree[Rson].boo ^= true;
tree[root].boo = false;
}
void flip(int root, int L, int R, int x, int y) {
if (y < L || R < x) return;
if (x <= L && R <= y) {
tree[root].I ^= 1;
tree[root].boo ^= true;
return;
}
int mid = (L + R) >> 1, Lson = root << 1, Rson = Lson + 1;
down(root, Lson, Rson);
flip(Lson, L, mid, x, y);
flip(Rson, mid + 1, R, x, y);
int i = tree[root].I, i1 = tree[Lson].I, i2 = tree[Rson].I;
for (int k = 0; k <= 1; k++) {
tree[root].Sum[i] = tree[Lson].Sum[i1] + tree[Rson].Sum[i2];
tree[root].Max[i] = tree[Lson].Rmax[i1] + tree[Rson].Lmax[i2];
tree[root].L[i] = tree[Lson].Rto[i1];
tree[root].R[i] = tree[Rson].Lto[i2];
check1(root, i, tree[Lson].Max[i1], tree[Lson].L[i1], tree[Lson].R[i1]);
check1(root, i, tree[Rson].Max[i2], tree[Rson].L[i2], tree[Rson].R[i2]);
tree[root].Lmax[i] = tree[Lson].Sum[i1] + tree[Rson].Lmax[i2];
tree[root].Lto[i] = tree[Rson].Lto[i2];
check2(root, i, tree[Lson].Lmax[i1], tree[Lson].Lto[i1]);
tree[root].Rmax[i] = tree[Rson].Sum[i2] + tree[Lson].Rmax[i1];
tree[root].Rto[i] = tree[Lson].Rto[i1];
check3(root, i, tree[Rson].Rmax[i2], tree[Rson].Rto[i2]);
i ^= 1;
i1 ^= 1;
i2 ^= 1;
}
}
data ask(int root, int L, int R, int x, int y) {
if (y < L || R < x) return data(0, 0, 0, 0, 0, 0, 0, 0);
if (x <= L && R <= y) {
int i = tree[root].I;
return data(tree[root].Sum[i], tree[root].Max[i], tree[root].L[i],
tree[root].R[i], tree[root].Lmax[i], tree[root].Lto[i],
tree[root].Rmax[i], tree[root].Rto[i]);
}
int mid = (L + R) >> 1, Lson = root << 1, Rson = Lson + 1;
down(root, Lson, Rson);
data LL = ask(Lson, L, mid, x, y), RR = ask(Rson, mid + 1, R, x, y), res;
if (!LL.L) return RR;
if (!RR.L) return LL;
res.Sum = LL.Sum + RR.Sum;
res.Max = LL.Rmax + RR.Lmax;
res.L = LL.Rto;
res.R = RR.Lto;
if (LL.Max > res.Max) res.Max = LL.Max, res.L = LL.L, res.R = LL.R;
if (RR.Max > res.Max) res.Max = RR.Max, res.L = RR.L, res.R = RR.R;
res.Lmax = LL.Sum + RR.Lmax;
res.Lto = RR.Lto;
if (LL.Lmax > res.Lmax) res.Lmax = LL.Lmax, res.Lto = LL.Lto;
res.Rmax = RR.Sum + LL.Rmax;
res.Rto = LL.Rto;
if (RR.Rmax > res.Rmax) res.Rmax = RR.Rmax, res.Rto = RR.Rto;
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
scanf("%d", &q);
build(1, 1, n);
while (q--) {
int ord, x, y, z;
scanf("%d%d%d", &ord, &x, &y);
if (!ord)
update(1, 1, n, x, y);
else {
p = 0;
ans = 0;
scanf("%d", &z);
while (z--) {
data res = ask(1, 1, n, x, y);
if (res.Max <= 0) break;
ans += res.Max;
p++;
reL[p] = res.L;
reR[p] = res.R;
flip(1, 1, n, reL[p], reR[p]);
}
for (int i = 1; i <= p; i++) flip(1, 1, n, reL[i], reR[i]);
printf("%d\n", ans);
}
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x, n, m;
cin >> n >> m;
vector<pair<int, int> > v;
vector<int> res(n);
for (int i = 0; i < n; i++) {
cin >> x;
v.push_back(make_pair(x, i));
}
sort(v.begin(), v.end());
for (int i = 0; i < n; i++) {
if (i % 2 != 0)
res[v[i].second] = 0;
else
res[v[i].second] = 1;
}
for (int i = 0; i < n; i++) {
cout << res[i];
if (i != n - 1) cout << " ";
}
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int nMax = 100100;
vector<int> e[nMax];
int n;
int s[2][nMax * 3];
int t[2], k[2];
void M(int *a, int x) {
while (x < nMax * 3) {
a[x]++;
x += (x & (-x));
}
}
int S(int *a, int x) {
int res = 0;
while (x) {
res += a[x];
x -= (x & (-x));
}
return res;
}
int main() {
int i, j, m, size, ans, u;
while (scanf("%d", &n) != EOF) {
ans = 0;
for (i = 0; i < n; i++) e[i].clear();
for (i = 0; i < n; i++) {
scanf("%d", &m);
while (m--) {
scanf("%d", &u);
e[i].push_back(u);
}
}
for (i = 0; i < n; i++) {
memset(s, 0, sizeof(s));
for (j = 0, k[0] = (i - 1 + n) % n, size = e[k[0]].size(); j < size; j++)
M(s[0], e[k[0]][j]);
for (j = 0, k[1] = (i + 1) % n, size = e[k[1]].size(); j < size; j++)
M(s[1], e[k[1]][j]);
sort(e[i].begin(), e[i].end());
for (j = 1, size = e[i].size(); j < size; j++) {
t[0] = S(s[0], e[i][j]) - S(s[0], e[i][j - 1]);
t[1] = S(s[1], e[i][j]) - S(s[1], e[i][j - 1]);
if (t[0] != t[1]) ans++;
}
}
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 201000;
int n, x, zz[N], k, pos, ans[N], c[N], m;
vector<pair<int, int>> ret[N];
pair<int, int> p[N];
void modify(int x, int s) {
for (; x <= n; x += x & -x) c[x] += s;
}
int query(int s) {
int z = 0;
for (int j = 19; j >= 0; --j) {
if (z + (1 << j) <= n && c[z + (1 << j)] < s) {
z += (1 << j);
s -= c[z];
}
}
return z;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &x);
p[i] = {-x, i + 1};
zz[i] = x;
}
sort(p, p + n);
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
scanf("%d %d", &k, &pos);
ret[k].push_back({pos, i});
}
for (int i = 0; i < n; ++i) {
modify(p[i].second, 1);
for (auto q : ret[i + 1]) {
ans[q.second] = zz[query(q.first)];
}
}
for (int i = 0; i < m; ++i) {
printf("%d\n", ans[i]);
}
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.