text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
int n, lst;
int ID[MAXN], rt[MAXN];
int Read() {
int x = 0, f = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x * 10) + (c ^ 48);
c = getchar();
}
return x * f;
}
void Put1(int x) {
if (x > 9) Put1(x / 10);
putchar(x % 10 ^ 48);
}
void Put(int x, char c = -1) {
if (x < 0) putchar('-'), x = -x;
Put1(x);
if (c >= 0) putchar(c);
}
template <typename T>
T Max(T x, T y) {
return x > y ? x : y;
}
template <typename T>
T Min(T x, T y) {
return x < y ? x : y;
}
template <typename T>
T Abs(T x) {
return x < 0 ? -x : x;
}
struct Chairman_Tree {
int tot;
struct node {
int l, r, val;
} t[MAXN * 24];
void Add(int lrt, int &rt, int ID, int l, int r) {
rt = ++tot;
t[rt] = t[lrt];
t[rt].val++;
if (l == r) return;
int mid = (l + r) >> 1;
if (ID <= mid)
Add(t[lrt].l, t[rt].l, ID, l, mid);
else
Add(t[lrt].r, t[rt].r, ID, mid + 1, r);
}
int Query(int x, int l, int r, int ql, int qr) {
if (!x) return 0;
if (ql <= l && r <= qr) return t[x].val;
int mid = (l + r) >> 1, ret = 0;
if (ql <= mid) ret += Query(t[x].l, l, mid, ql, qr);
if (mid + 1 <= qr) ret += Query(t[x].r, mid + 1, r, ql, qr);
return ret;
}
} ct;
int f(int z) { return (z - 1 + lst) % n + 1; }
int main() {
n = Read();
for (int i = 1; i <= n; ++i) ID[Read()] = i;
for (int i = 1; i <= n; ++i) ct.Add(rt[i - 1], rt[i], ID[Read()], 1, n);
for (int Q = Read(); Q; --Q) {
int a = Read(), b = Read(), c = Read(), d = Read();
int l1 = Min(f(a), f(b)), r1 = Max(f(a), f(b)), l2 = Min(f(c), f(d)),
r2 = Max(f(c), f(d));
Put(lst = (ct.Query(rt[r2], 1, n, l1, r1) -
ct.Query(rt[l2 - 1], 1, n, l1, r1)),
'\n');
lst++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INPUT_MAXCHARS = 1 << 16;
char buffer[INPUT_MAXCHARS];
struct FastReader {
char *p;
FastReader() : p(buffer) { fread(buffer, 1, sizeof buffer, stdin); }
int next_int() {
int remchars = INPUT_MAXCHARS - (p - buffer);
if (remchars < 25) {
memcpy(buffer, p, remchars);
size_t cnt = fread(buffer + remchars, 1, sizeof buffer - remchars, stdin);
if (remchars + cnt < sizeof buffer) {
buffer[remchars + cnt] = 0;
}
p = buffer;
}
while (*p < '0') {
p++;
}
int val = 0;
while (*p >= '0') {
val = val * 10 + (*p - '0');
++p;
}
return val;
}
};
const int MAXPOW = 1 << 20;
vector<int> T[2 * MAXPOW];
const int MAXN = 1000000;
int revP[MAXN], revQ[MAXN];
int query(int x, int a, int b, int l1, int r1, int l2, int r2) {
if (a >= r1 || b <= l1) return 0;
if (l1 <= a && b <= r1) {
return lower_bound(T[x].begin(), T[x].end(), r2) -
lower_bound(T[x].begin(), T[x].end(), l2);
} else {
return query(2 * x, a, (a + b) / 2, l1, r1, l2, r2) +
query(2 * x + 1, (a + b) / 2, b, l1, r1, l2, r2);
}
}
int main() {
FastReader reader;
int n = reader.next_int();
for (int i = 0; i < n; ++i) {
int x = reader.next_int();
revP[x - 1] = i;
}
for (int i = 0; i < n; ++i) {
int x = reader.next_int();
revQ[x - 1] = i;
}
int sz = 1;
while (sz < n) {
sz *= 2;
}
for (int i = 0; i < n; ++i) {
T[sz + revP[i]].push_back(revQ[i]);
}
for (int i = sz - 1; i > 0; --i) {
int left = 2 * i;
int right = left + 1;
merge(T[left].begin(), T[left].end(), T[right].begin(), T[right].end(),
back_inserter(T[i]));
}
int Q = reader.next_int();
int x = 0;
while (Q--) {
int a = reader.next_int();
int b = reader.next_int();
int c = reader.next_int();
int d = reader.next_int();
int l1 = min((a - 1 + x) % n, (b - 1 + x) % n);
int r1 = max((a - 1 + x) % n, (b - 1 + x) % n);
int l2 = min((c - 1 + x) % n, (d - 1 + x) % n);
int r2 = max((c - 1 + x) % n, (d - 1 + x) % n);
x = query(1, 0, sz, l1, r1 + 1, l2, r2 + 1);
cout << x << '\n';
++x;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int M = N * 22;
int tsz, root[N], ls[M], rs[M], sum[M];
void Set(int p, int &c, int ss, int se, int qi) {
c = ++tsz;
ls[c] = ls[p];
rs[c] = rs[p];
sum[c] = sum[p] + 1;
if (ss == se) return;
int mid = ss + se >> 1;
if (qi <= mid)
Set(ls[p], ls[c], ss, mid, qi);
else
Set(rs[p], rs[c], mid + 1, se, qi);
}
int Get(int c, int ss, int se, int qs, int qe) {
if (qs > qe || qs > se || ss > qe) return 0;
if (qs <= ss && qe >= se) return sum[c];
int mid = ss + se >> 1;
return Get(ls[c], ss, mid, qs, qe) + Get(rs[c], mid + 1, se, qs, qe);
}
int x[N], y[N], p[N], q[N];
int main() {
int n, qu;
scanf("%i", &n);
for (int i = 1; i <= n; i++) scanf("%i", &p[i]), x[p[i]] = i;
for (int i = 1; i <= n; i++) scanf("%i", &q[i]), y[q[i]] = i;
for (int i = 1; i <= n; i++) Set(root[i - 1], root[i], 1, n, y[p[i]]);
int ans = 0;
auto f = [&](int x) { return (x - 1 + ans) % n + 1; };
scanf("%i", &qu);
while (qu--) {
int a, b, c, d;
scanf("%i %i %i %i", &a, &b, &c, &d);
a = f(a);
b = f(b);
c = f(c);
d = f(d);
if (a > b) swap(a, b);
if (c > d) swap(c, d);
ans = Get(root[b], 1, n, c, d) - Get(root[a - 1], 1, n, c, d);
printf("%i\n", ans);
ans++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 2;
int n, adr[N], q[N], x;
vector<int> t[4 * N];
void build(int n, int b, int e) {
if (b == e) {
t[n].push_back(adr[q[b]]);
return;
}
int l = n << 1, r = l | 1, m = b + e >> 1;
build(l, b, m);
build(r, m + 1, e);
int p1 = 0, p2 = 0;
while (p1 < t[l].size() && p2 < t[r].size())
if (t[l][p1] < t[r][p2])
t[n].push_back(t[l][p1++]);
else
t[n].push_back(t[r][p2++]);
while (p1 < t[l].size()) t[n].push_back(t[l][p1++]);
while (p2 < t[r].size()) t[n].push_back(t[r][p2++]);
}
int query(int n, int b, int e, int u, int v, int x, int y) {
if (e < u || v < b) return 0;
if (u <= b && e <= v)
return upper_bound(t[n].begin(), t[n].end(), y) -
lower_bound(t[n].begin(), t[n].end(), x);
int l = n << 1, r = l | 1, m = b + e >> 1;
return query(l, b, m, u, v, x, y) + query(r, m + 1, e, u, v, x, y);
}
inline int f(int z) { return (z + x) % n; }
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0, t; i < n; i++) cin >> t, adr[--t] = i;
for (int i = 0; i < n; i++) cin >> q[i], q[i]--;
build(1, 0, n - 1);
int m;
cin >> m;
for (int i = 0; i < m; i++, x++) {
int b, e, l, r;
cin >> b >> e >> l >> r;
b = f(--b), e = f(--e), l = f(--l), r = f(--r);
cout << (x = query(1, 0, n - 1, min(l, r), max(l, r), min(b, e), max(b, e)))
<< '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
int ch[MAXN], arr[MAXN], x, a, b, c, d, l1, l2, r1, r2, n, m;
vector<int> tree[4 * MAXN];
void build(int v, int b, int e) {
if (b == e)
tree[v].push_back(arr[b]);
else {
int m = (b + e) / 2;
build(v + v, b, m);
build(v + v + 1, m + 1, e);
vector<int> &l = tree[v + v], &r = tree[v + v + 1];
merge(l.begin(), l.end(), r.begin(), r.end(), back_inserter(tree[v]));
}
}
int query(int v, int b, int e, int l, int r, int f, int s) {
if (e < l || b > r) return 0;
if (l <= b && e <= r) {
return upper_bound(tree[v].begin(), tree[v].end(), s) -
lower_bound(tree[v].begin(), tree[v].end(), f);
}
int m = (b + e) / 2;
return query(v + v, b, m, l, r, f, s) +
query(v + v + 1, m + 1, e, l, r, f, s);
}
int f(int z) { return ((z - 1 + x) % n) + 1; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a;
ch[a] = i + 1;
}
for (int i = 1; i <= n; ++i) {
cin >> a;
arr[i] = ch[a];
}
build(1, 1, n);
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> a >> b >> c >> d;
l1 = min(f(a), f(b)), r1 = max(f(a), f(b));
l2 = min(f(c), f(d)), r2 = max(f(c), f(d));
x = query(1, 1, n, l2, r2, l1, r1) + 1;
cout << x - 1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
static inline unsigned long long rdtsc() {
unsigned long long d;
__asm__ __volatile__("rdtsc" : "=A"(d));
return d;
}
using namespace std;
const int inf = (int)1e9;
const double eps = 1e-9;
const int maxV = (int)23e6 + 10;
const int maxn = (int)1e6 + 10;
int t[maxV];
int l[maxV], r[maxV];
int root[maxn];
int Last = 0;
inline int init(int L, int R) {
int v = Last++;
if (L + 1 < R) {
int M = (L + R) >> 1;
l[v] = init(L, M);
r[v] = init(M, R);
}
return v;
}
inline int NEW(int x) {
assert(Last < maxV);
t[Last] = t[x];
l[Last] = l[x];
r[Last] = r[x];
return Last++;
}
int modify(int x, int L, int R, int d) {
if (d >= R || L > d) return x;
x = NEW(x);
if (L + 1 == R) {
t[x] = 1;
return x;
}
int M = (L + R) >> 1;
l[x] = modify(l[x], L, M, d);
r[x] = modify(r[x], M, R, d);
t[x] = t[l[x]] + t[r[x]];
return x;
}
int n;
int p[maxn], q[maxn];
int q1[maxn];
void precalc() {
for (int i = 0; (i) < (n); ++i) p[i] -= 1;
for (int i = 0; (i) < (n); ++i) q[i] -= 1;
for (int i = 0; (i) < (n); ++i) q1[q[i]] = i;
root[0] = init(0, n);
for (int i = 0; (i) < (n); ++i) {
root[i + 1] = modify(root[i], 0, n, q1[p[i]]);
}
}
inline int gget(int x, int L, int R, int lq, int rq) {
if (lq <= L && R <= rq) return t[x];
if (lq >= R || L >= rq) return 0;
int M = (L + R) >> 1;
return gget(l[x], L, M, lq, rq) + gget(r[x], M, R, lq, rq);
}
inline int get(int r1, int l2, int r2) {
return gget(root[r1 + 1], 0, n, l2, r2 + 1);
}
inline int GET(int l1, int r1, int l2, int r2) {
l1 -= 1;
return get(r1, l2, r2) - get(l1, l2, r2);
}
int main() {
scanf("%d", &n);
for (int i = 0; (i) < (n); ++i) scanf("%d", &p[i]);
for (int i = 0; (i) < (n); ++i) scanf("%d", &q[i]);
precalc();
int m;
scanf("%d", &m);
int x = 0;
for (int i = 0; (i) < (m); ++i) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
int fa = ((a - 1 + x) % n);
int fb = ((b - 1 + x) % n);
int fc = ((c - 1 + x) % n);
int fd = ((d - 1 + x) % n);
int l1 = min(fa, fb);
int r1 = max(fa, fb);
int l2 = min(fc, fd);
int r2 = max(fc, fd);
int res = GET(l1, r1, l2, r2);
printf("%d\n", res);
x = res + 1;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 500000000;
template <class T>
void debug(T a, T b) {
for (; a != b; ++a) cerr << *a << ' ';
cerr << endl;
}
struct segtree {
vector<int> val[2200000];
int n;
void init(int n_, int *ar) {
n = 1;
while (n < n_) n <<= 1;
for (int i = 0; i < n_; ++i) {
val[i + n - 1].push_back(ar[i]);
}
for (int i = n - 2; i >= 0; --i) {
val[i].resize(val[i * 2 + 1].size() + val[i * 2 + 2].size());
merge((val[i * 2 + 1]).begin(), (val[i * 2 + 1]).end(),
(val[i * 2 + 2]).begin(), (val[i * 2 + 2]).end(), val[i].begin());
}
}
int query(int a, int b, int i, int l, int r, int ub, int lb) {
if (a <= l && r <= b) {
return lower_bound((val[i]).begin(), (val[i]).end(), ub) -
lower_bound((val[i]).begin(), (val[i]).end(), lb);
}
if (b <= l || r <= a) return 0;
int md = (l + r) >> 1;
return query(a, b, i * 2 + 1, l, md, ub, lb) +
query(a, b, i * 2 + 2, md, r, ub, lb);
}
};
segtree seg;
int n;
int perm[1000005], perm2[1000005];
int pos2[1000005], crsp[1000005];
int x = 0;
int f(int a) { return (a - 1 + x) % n; }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &perm[i]);
--perm[i];
}
for (int i = 0; i < n; ++i) {
scanf("%d", &perm2[i]);
--perm2[i];
pos2[perm2[i]] = i;
}
for (int i = 0; i < n; ++i) crsp[i] = pos2[perm[i]];
seg.init(n, crsp);
int m;
scanf("%d", &m);
for (int hoge = 0; hoge < m; ++hoge) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
int A = f(a), B = f(b), C = f(c), D = f(d);
int l1 = min(A, B), r1 = max(A, B), l2 = min(C, D), r2 = max(C, D);
++r1;
++r2;
int res = seg.query(l1, r1, 0, 0, seg.n, r2, l2);
x = res + 1;
printf("%d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int n, m, tot, x, a[N], b[N], pos[N], rt[N], ls[N * 21], rs[N * 21], sz[N * 21];
int f(int z) { return (z - 1 + x) % n + 1; }
void upd(int &x, int y, int l, int r, int p) {
x = ++tot, ls[x] = ls[y], rs[x] = rs[y], sz[x] = sz[y] + 1;
if (l < r) {
int mid = l + r >> 1;
if (p <= mid)
upd(ls[x], ls[y], l, mid, p);
else
upd(rs[x], rs[y], mid + 1, r, p);
}
}
int qry(int x, int l, int r, int ql, int qr) {
if (!x) return 0;
if (l >= ql && r <= qr) return sz[x];
int mid = l + r >> 1, ans = 0;
if (ql <= mid) ans += qry(ls[x], l, mid, ql, qr);
if (qr > mid) ans += qry(rs[x], mid + 1, r, ql, qr);
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) scanf("%d", b + i), pos[b[i]] = i;
for (int i = 1; i <= n; i++) upd(rt[i], rt[i - 1], 1, n, pos[a[i]]);
scanf("%d", &m);
for (int a, b, c, d; m--;) {
scanf("%d%d%d%d", &a, &b, &c, &d);
a = f(a), b = f(b), c = f(c), d = f(d);
if (a > b) swap(a, b);
if (c > d) swap(c, d);
printf("%d\n", x = qry(rt[b], 1, n, c, d) - qry(rt[a - 1], 1, n, c, d));
x++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
const int maxn = 1e6 + 10;
int n;
int x = 0;
pair<int, int> where[maxn];
inline int f(int z) { return (z - 1 + x) % n; }
int stree[21][maxn];
inline void build(int p = 0, int l = 0, int r = n - 1, int h = 0) {
if (l == r) {
stree[h][l] = where[l].second;
return;
}
int mid = (l + r) >> 1;
build(2 * p + 1, l, mid, h + 1), build(2 * p + 2, mid + 1, r, h + 1);
merge(stree[h + 1] + l, stree[h + 1] + mid + 1, stree[h + 1] + mid + 1,
stree[h + 1] + r + 1, stree[h] + l);
}
inline int get(int ql, int qr, int ql2, int qr2, int p = 0, int l = 0,
int r = n - 1, int h = 0) {
if (l > qr || r < ql || ql > qr) return 0;
if (l >= ql && r <= qr) {
return upper_bound(stree[h] + l, stree[h] + r + 1, qr2) -
lower_bound(stree[h] + l, stree[h] + r + 1, ql2);
}
int mid = (l + r) >> 1;
return get(ql, qr, ql2, qr2, 2 * p + 1, l, mid, h + 1) +
get(ql, qr, ql2, qr2, 2 * p + 2, mid + 1, r, h + 1);
}
int32_t main() {
n = in();
for (int i = 0; i < n; i++) {
int foo = in() - 1;
where[foo].first = i;
}
for (int i = 0; i < n; i++) {
int foo = in() - 1;
where[foo].second = i;
}
sort(where, where + n);
build();
int q = in();
while (q--) {
int a = in(), b = in(), c = in(), d = in();
int l1 = min(f(a), f(b)), r1 = max(f(a), f(b)), l2 = min(f(c), f(d)),
r2 = max(f(c), f(d));
int ret = get(l1, r1, l2, r2);
cout << ret << "\n";
x = ret + 1;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005, M = 22000005;
int n, m, tot, ans;
int a[N], posb[N], rt[N], cnt[M], lc[M], rc[M];
void pushup(int u) { cnt[u] = cnt[lc[u]] + cnt[rc[u]]; }
void upd(int &u, int v, int l, int r, int x) {
u = ++tot;
if (l == r) {
cnt[u] = cnt[v] + 1;
return;
}
int mid = (l + r) >> 1;
if (mid >= x)
rc[u] = rc[v], upd(lc[u], lc[v], l, mid, x);
else
lc[u] = lc[v], upd(rc[u], rc[v], mid + 1, r, x);
pushup(u);
}
int qsum(int u, int v, int l, int r, int ql, int qr) {
if (l >= ql && r <= qr) return cnt[v] - cnt[u];
int mid = (l + r) >> 1, res = 0;
if (lc[v] && mid >= ql) res += qsum(lc[u], lc[v], l, mid, ql, qr);
if (rc[v] && mid < qr) res += qsum(rc[u], rc[v], mid + 1, r, ql, qr);
return res;
}
inline int f(int x) { return (x + ans) % n + 1; }
inline int input() {
int x = 0, F = 1;
char c = getchar();
while (c > '9' || c < '0') {
if (c == '-') F = -1;
c = getchar();
}
while (c <= '9' && c >= '0') {
x = x * 10 + c - '0';
c = getchar();
}
return x * F;
}
int main() {
int A, B, C, D;
n = input();
for (int i = 1; i <= n; i++) a[i] = input();
for (int i = 1; i <= n; i++) A = input(), posb[A] = i;
for (int i = 1; i <= n; i++) upd(rt[i], rt[i - 1], 1, n, posb[a[i]]);
m = input();
ans = -1;
for (int i = 1; i <= m; i++) {
A = input();
B = input();
C = input();
D = input();
A = f(A);
B = f(B);
C = f(C);
D = f(D);
if (A > B) swap(A, B);
if (C > D) swap(C, D);
printf("%d\n", ans = qsum(rt[A - 1], rt[B], 1, n, C, D));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int sz = 1 << 15;
char inbuf[sz], outbuf[sz];
char *pinbuf = inbuf + sz;
char *poutbuf = outbuf;
inline char _getchar() {
if (pinbuf == inbuf + sz) fread(inbuf, 1, sz, stdin), pinbuf = inbuf;
return *(pinbuf++);
}
inline void _putchar(char x) {
if (poutbuf == outbuf + sz) fwrite(outbuf, 1, sz, stdout), poutbuf = outbuf;
*(poutbuf++) = x;
}
inline void flush() {
if (poutbuf != outbuf)
fwrite(outbuf, 1, poutbuf - outbuf, stdout), poutbuf = outbuf;
}
} // namespace IO
inline int read() {
int v = 0, f = 1;
char c = IO::_getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = IO::_getchar();
}
while (c >= '0' && c <= '9') {
v = v * 10 + c - '0';
c = IO::_getchar();
}
return v * f;
}
const int Maxn = 1000005;
int n, p[Maxn], q[Maxn], P[Maxn], Q[Maxn], ord[Maxn];
vector<int> T[Maxn * 4];
void modify(int p, int l, int r, int x, int y) {
T[p].push_back(y);
if (l == r) return;
int mid = l + r >> 1;
if (x <= mid) {
modify(p * 2, l, mid, x, y);
} else {
modify(p * 2 + 1, mid + 1, r, x, y);
}
}
int a, b, c, d;
int query(int p, int l, int r) {
if (a <= l && r <= b) {
int pc = lower_bound(T[p].begin(), T[p].end(), c) - T[p].begin();
int pd = upper_bound(T[p].begin(), T[p].end(), d) - T[p].begin();
return pd - pc;
}
int mid = l + r >> 1;
int ans = 0;
if (a <= mid) {
ans += query(p * 2, l, mid);
}
if (b > mid) {
ans += query(p * 2 + 1, mid + 1, r);
}
return ans;
}
bool cmp(int x, int y) { return Q[x] < Q[y]; }
int main() {
n = read();
for (int i = 1; i <= n; i++) {
p[i] = read();
}
for (int i = 1; i <= n; i++) {
P[p[i]] = i;
}
for (int i = 1; i <= n; i++) {
q[i] = read();
}
for (int i = 1; i <= n; i++) {
Q[q[i]] = i;
ord[i] = i;
}
vector<pair<int, int> > V;
sort(ord + 1, ord + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
modify(1, 1, n, P[ord[i]], Q[ord[i]]);
}
int m = read();
int lastans = 0;
while (m--) {
a = read();
b = read();
c = read();
d = read();
a = (a - 1 + lastans) % n + 1;
b = (b - 1 + lastans) % n + 1;
c = (c - 1 + lastans) % n + 1;
d = (d - 1 + lastans) % n + 1;
int A = min(a, b), B = max(a, b), C = min(c, d), D = max(c, d);
a = A;
b = B;
c = C;
d = D;
int rs = query(1, 1, n);
lastans = rs + 1;
printf("%d\n", rs);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = ((1 << 30) - 1);
const long long linf = ((1ll << 62) - 1);
const int cmax = 1e6;
int n;
int a[cmax], b[cmax], res[cmax];
vector<int> rmq[cmax * 4], _left[cmax * 4], _right[cmax * 4];
inline void buildBound(vector<int> &a, vector<int> &b, vector<int> &res) {
int it = 0, size1 = ((int)(a).size()), size2 = ((int)(b).size());
for (int i = 0; i < size1; i++) {
while (it < size2 && b[it] < a[i]) ++it;
res[i] = it;
}
res[size1] = size1;
}
void make_rmq(int i, int l, int r) {
if (l == r) {
rmq[i].resize(1);
rmq[i][0] = a[l];
return;
}
make_rmq(i * 2, l, (l + r) / 2);
make_rmq(i * 2 + 1, (l + r) / 2 + 1, r);
int size = r - l + 1;
rmq[i].resize(size);
merge((rmq[i * 2]).begin(), (rmq[i * 2]).end(), (rmq[i * 2 + 1]).begin(),
(rmq[i * 2 + 1]).end(), rmq[i].begin());
_left[i].resize(size + 1), _right[i].resize(size + 1);
buildBound(rmq[i], rmq[i * 2], _left[i]);
buildBound(rmq[i], rmq[i * 2 + 1], _right[i]);
}
inline int getValue(int i, int ll, int rr, int l, int r, int b, int t) {
int size = rr - ll + 1;
if (t >= size) t = size;
if (b >= size) b = size;
if (ll > r || rr < l) return 0;
if (l <= ll && rr <= r) return max(0, t - b);
return getValue(i * 2, ll, (ll + rr) / 2, l, r, _left[i][b], _left[i][t]) +
getValue(i * 2 + 1, (ll + rr) / 2 + 1, rr, l, r, _right[i][b],
_right[i][t]);
}
int x = 0;
int f(int z) { return ((z - 1 + x) % n) + 1; }
int main() {
assert(scanf("%d", &n));
for (int i = 0; i < n; i++) {
assert(scanf("%d", &a[i])), --a[i];
}
for (int i = 0; i < n; i++) {
int t;
assert(scanf("%d", &t)), --t;
b[t] = i;
}
for (int i = 0; i < n; i++) res[i] = b[a[i]];
memcpy(a, res, sizeof(int) * n);
make_rmq(1, 0, n - 1);
int m;
assert(scanf("%d", &m));
for (int i = 0; i < m; i++) {
int a, b, c, d;
assert(scanf("%d%d%d%d", &a, &b, &c, &d));
int l1 = min(f(a), f(b)) - 1, r1 = max(f(a), f(b)) - 1;
int l2 = min(f(c), f(d)) - 1, r2 = max(f(c), f(d)) - 1;
printf("%d\n",
x = getValue(1, 0, n - 1, l1, r1,
lower_bound((rmq[1]).begin(), (rmq[1]).end(), l2) -
rmq[1].begin(),
upper_bound((rmq[1]).begin(), (rmq[1]).end(), r2) -
rmq[1].begin())),
x++;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000,1000000000")
using namespace std;
const long long inf = 1e18 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
long long n, m, ans = 0;
long long a[1000005], b[1000005];
vector<long long> t[4000005];
inline long long f(long long x) {
long long res = x + ans - 1;
while (res < 0) res += n;
while (res >= n) res -= n;
return res;
}
inline void build(long long v, long long l, long long r) {
if (l == r) {
t[v].push_back(a[l]);
return;
}
long long m = (l + r) >> 1LL;
if (l <= m) build(v + v, l, m);
if (r > m) build(v + v + 1, m + 1, r);
merge(t[v + v].begin(), t[v + v].end(), t[v + v + 1].begin(),
t[v + v + 1].end(), back_inserter(t[v]));
}
inline long long get(long long v, long long tl, long long tr, long long a,
long long b, long long c, long long d) {
if (a <= tl && b >= tr) {
return upper_bound((t[v]).begin(), (t[v]).end(), d) -
lower_bound((t[v]).begin(), (t[v]).end(), c);
}
long long tm = (tl + tr) >> 1LL;
long long res = 0;
if (a <= tm) res += get(v + v, tl, tm, a, b, c, d);
if (b > tm) res += get(v + v + 1, tm + 1, tr, a, b, c, d);
return res;
}
int main(void) {
cin >> n;
for (long long(i) = 0; (i) < (long long)(n); (i)++) {
int x;
scanf("%d", &x);
b[x - 1] = i;
}
for (long long(i) = 0; (i) < (long long)(n); (i)++) {
int x;
scanf("%d", &x);
a[i] = b[x - 1];
}
build(1, 0, n - 1);
cin >> m;
for (long long(i) = 0; (i) < (long long)(m); (i)++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
a = f(a);
b = f(b);
c = f(c);
d = f(d);
if (a > b) swap(a, b);
if (c > d) swap(c, d);
ans = get(1, 0, n - 1, c, d, a, b);
printf("%d\n", (int)ans);
ans++;
}
return 0;
}
|
#include <bits/stdc++.h>
std::vector<int32_t>* segtree;
int32_t* data;
void build(int32_t node, int32_t left, int32_t right) {
if (right - left == 1) {
segtree[node] = {data[left]};
return;
}
int32_t m = (left + right) / 2;
build(node * 2 + 1, left, m);
build(node * 2 + 2, m, right);
segtree[node].resize(right - left);
std::merge(segtree[node * 2 + 1].begin(), segtree[node * 2 + 1].end(),
segtree[node * 2 + 2].begin(), segtree[node * 2 + 2].end(),
segtree[node].begin());
}
int32_t query(int32_t node, int32_t left, int32_t right, int32_t query_left,
int32_t query_right, int32_t param) {
if (left >= query_right || right <= query_left) return 0;
if (left >= query_left && right <= query_right)
return std::lower_bound(segtree[node].begin(), segtree[node].end(), param) -
segtree[node].begin();
int32_t m = (left + right) / 2;
return query(node * 2 + 1, left, m, query_left, query_right, param) +
query(node * 2 + 2, m, right, query_left, query_right, param);
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
int32_t n;
std::cin >> n;
int32_t* arr1 = new int32_t[n];
int32_t* arr2 = new int32_t[n];
for (int32_t i = 0; i < n; i++) {
std::cin >> arr1[i];
arr1[i]--;
}
for (int32_t i = 0; i < n; i++) {
std::cin >> arr2[i];
arr2[i]--;
}
int32_t* positions_in_1 = new int32_t[n];
int32_t* positions = new int32_t[n];
for (int32_t i = 0; i < n; i++) positions_in_1[arr1[i]] = i;
for (int32_t i = 0; i < n; i++) positions[positions_in_1[arr2[i]]] = i;
segtree = new std::vector<int32_t>[4 * n];
data = positions;
build(0, 0, n);
int32_t num_queries;
std::cin >> num_queries;
int32_t x = 0;
for (int32_t i = 0; i < num_queries; i++) {
int32_t a, b, c, d;
std::cin >> a >> b >> c >> d;
int32_t fa = (a - 1 + x) % n;
int32_t fb = (b - 1 + x) % n;
int32_t fc = (d - 1 + x) % n;
int32_t fd = (c - 1 + x) % n;
int32_t left1 = std::min(fa, fb), right1 = std::max(fa, fb);
int32_t left2 = std::min(fc, fd), right2 = std::max(fc, fd);
int32_t answer = query(0, 0, n, left1, right1 + 1, right2 + 1) -
query(0, 0, n, left1, right1 + 1, left2);
std::cout << answer << "\n";
x = answer + 1;
}
return 0;
};
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 4400000;
int x, n;
int f(int z) { return ((z - 1 + x) % n); }
int a[NMAX], b[NMAX], b1[NMAX], l1, r1, l2, r2;
vector<int> md[NMAX];
void build(int idx, int l, int r) {
int len = r - l + 1;
md[idx].resize(len);
if (l == r) {
md[idx][0] = a[l];
return;
}
int mid = (l + r) >> 1;
build(idx << 1, l, mid);
build(idx << 1 | 1, mid + 1, r);
merge(md[idx << 1].begin(), md[idx << 1].end(), md[idx << 1 | 1].begin(),
md[idx << 1 | 1].end(), md[idx].begin());
}
int query(int idx, int l, int r) {
if (r < l1 || r1 < l) return 0;
if (l1 <= l && r <= r1) {
if (r2 < md[idx][0] || md[idx].back() < l2) return 0;
return int(upper_bound(md[idx].begin(), md[idx].end(), r2) -
lower_bound(md[idx].begin(), md[idx].end(), l2));
}
int mid = (l + r) >> 1;
return query(idx << 1, l, mid) + query(idx << 1 | 1, mid + 1, r);
}
int main() {
cin >> n;
for (int i = 0; i < (int)(n); i++) {
scanf("%d", &a[i]);
a[i]--;
}
for (int i = 0; i < (int)(n); i++) {
scanf("%d", &b[i]);
b[i]--;
}
for (int i = 0; i < (int)(n); i++) b1[b[i]] = i;
for (int i = 0; i < (int)(n); i++) a[i] = b1[a[i]];
build(1, 0, n - 1);
int m;
scanf("%d", &m);
for (int i = 0; i < (int)(m); i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
l1 = min(f(a), f(b));
r1 = max(f(a), f(b));
l2 = min(f(c), f(d));
r2 = max(f(c), f(d));
x = query(1, 0, n - 1);
printf("%d\n", x);
x++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1008611;
struct ST {
int i, j, l, r, mid;
vector<int> vv;
} st[maxn * 4];
int p1[maxn];
int p2[maxn];
int xx[maxn];
void bd(int d, int x, int y) {
st[d].i = x, st[d].j = y;
st[d].mid = (x + y) >> 1;
st[d].vv.clear();
for (int i = x; i <= y; i++) st[d].vv.push_back(xx[i]);
sort(st[d].vv.begin(), st[d].vv.end());
if (x < y) {
st[d].l = d << 1;
st[d].r = d << 1 | 1;
bd(st[d].l, x, st[d].mid);
bd(st[d].r, st[d].mid + 1, y);
}
}
int query(int d, int x, int y, int l2, int r2) {
if (x <= st[d].i && y >= st[d].j) {
int ll =
lower_bound(st[d].vv.begin(), st[d].vv.end(), l2) - st[d].vv.begin();
int rr =
upper_bound(st[d].vv.begin(), st[d].vv.end(), r2) - st[d].vv.begin();
return rr - ll;
} else {
int temp = 0;
if (x <= st[d].mid) temp += query(st[d].l, x, y, l2, r2);
if (y > st[d].mid) temp += query(st[d].r, x, y, l2, r2);
return temp;
}
}
int n;
int rr = 0;
int f(int z) { return ((z - 1 + rr) % n) + 1; }
int tmp[maxn];
int main() {
while (cin >> n) {
for (int i = 1; i <= n; i++) scanf("%d", &p1[i]);
for (int i = 1; i <= n; i++) scanf("%d", &p2[i]);
for (int i = 1; i <= n; i++) tmp[p2[i]] = i;
for (int i = 1; i <= n; i++) xx[i] = tmp[p1[i]];
int m;
bd(1, 1, n);
cin >> m;
rr = 0;
int a, b, c, d;
while (m--) {
scanf("%d%d%d%d", &a, &b, &c, &d);
int l1, r1, l2, r2;
l1 = min(f(a), f(b));
r1 = max(f(a), f(b));
l2 = min(f(c), f(d));
r2 = max(f(c), f(d));
rr = query(1, l1, r1, l2, r2);
printf("%d\n", rr);
rr++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, M = 21 * N;
int n, pos[N], a[N], b[N], rt[N], m, l, r, x, y, ans;
struct zxs {
int tot, ls[M], rs[M], sum[M];
inline void pushup(int u) { sum[u] = sum[ls[u]] + sum[rs[u]]; }
inline void update(int &u, int pre, int l, int r, int x) {
u = ++tot;
if (l == r) {
sum[u]++;
return;
} else {
int mid = (l + r) >> 1;
ls[u] = ls[pre], rs[u] = rs[pre];
if (x <= mid) {
update(ls[u], ls[pre], l, mid, x);
} else {
update(rs[u], rs[pre], mid + 1, r, x);
}
pushup(u);
}
}
inline int query(int u, int l, int r, int x, int y) {
if (x <= l && y >= r)
return sum[u];
else {
int val = 0;
int mid = (l + r) >> 1;
if (x <= mid) val += query(ls[u], l, mid, x, y);
if (y > mid) val += query(rs[u], mid + 1, r, x, y);
return val;
}
}
} tree;
inline int read() {
int x;
scanf("%d", &x);
return (x - 1 + ans) % n + 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int temp;
scanf("%d", &temp);
a[temp] = i;
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &b[i]);
pos[i] = a[b[i]];
}
for (int i = 1; i <= n; ++i) {
tree.update(rt[i], rt[i - 1], 1, n, pos[i]);
}
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
l = read(), r = read(), x = read(), y = read();
if (l > r) swap(l, r);
if (x > y) swap(x, y);
ans = tree.query(rt[y], 1, n, l, r);
ans -= tree.query(rt[x - 1], 1, n, l, r);
printf("%d\n", ans);
ans++;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000,1000000000")
using namespace std;
const long long inf = 1e18 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-9;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
long long n, m, ans = 0;
long long a[1000005], b[1000005];
vector<long long> t[4000005];
inline long long f(long long x) {
long long res = ((x + ans - 1) % n + n) % n;
return res;
}
inline void build(long long v, long long l, long long r) {
if (l == r) {
t[v].push_back(a[l]);
return;
}
long long m = (l + r) >> 1LL;
if (l <= m) build(v + v, l, m);
if (r > m) build(v + v + 1, m + 1, r);
merge(t[v + v].begin(), t[v + v].end(), t[v + v + 1].begin(),
t[v + v + 1].end(), back_inserter(t[v]));
}
inline long long get(long long v, long long tl, long long tr, long long a,
long long b, long long c, long long d) {
if (a <= tl && b >= tr) {
return upper_bound((t[v]).begin(), (t[v]).end(), d) -
lower_bound((t[v]).begin(), (t[v]).end(), c);
}
long long tm = (tl + tr) >> 1LL;
long long res = 0;
if (a <= tm) res += get(v + v, tl, tm, a, b, c, d);
if (b > tm) res += get(v + v + 1, tm + 1, tr, a, b, c, d);
return res;
}
int main(void) {
cin >> n;
for (long long(i) = 0; (i) < (long long)(n); (i)++) {
int x;
scanf("%d", &x);
b[x - 1] = i;
}
for (long long(i) = 0; (i) < (long long)(n); (i)++) {
int x;
scanf("%d", &x);
a[i] = b[x - 1];
}
build(1, 0, n - 1);
cin >> m;
for (long long(i) = 0; (i) < (long long)(m); (i)++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
a = f(a);
b = f(b);
c = f(c);
d = f(d);
if (a > b) swap(a, b);
if (c > d) swap(c, d);
ans = get(1, 0, n - 1, c, d, a, b);
printf("%d\n", (int)ans);
ans++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, P[1111111], Q[1111111], z[4], x;
int l1, r1, l2, r2;
vector<int> Num[1111111];
void updata(int n, int x) {
while (n <= N) {
Num[n].push_back(x);
n += n & (-n);
}
}
int cnt(int n, int x) {
int ret = 0;
while (n >= 1) {
ret += upper_bound(Num[n].begin(), Num[n].end(), x) - Num[n].begin();
n -= n & (-n);
}
return ret;
}
int main() {
scanf("%d", &N);
for (int n = 1; n <= N; ++n) {
scanf("%d", &x);
P[x] = n;
}
for (int n = 1; n <= N; ++n) {
scanf("%d", &x);
Q[x] = n;
}
for (int n = 1; n <= N; ++n) updata(P[n], Q[n]);
for (int n = 1; n <= N; ++n) sort(Num[n].begin(), Num[n].end());
scanf("%d", &M);
x = 0;
while (M--) {
for (int d = 0; d < 4; ++d) {
scanf("%d", z + d);
z[d] = (z[d] - 1 + x) % N + 1;
}
l1 = min(z[0], z[1]);
r1 = max(z[0], z[1]);
l2 = min(z[2], z[3]);
r2 = max(z[2], z[3]);
x = cnt(r1, r2) - cnt(r1, l2 - 1) - cnt(l1 - 1, r2) + cnt(l1 - 1, l2 - 1);
printf("%d\n", x++);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
int n, i, x, m, a, b, c, d, l, r, l2, r2, lastans;
int H[N], A[N];
vector<int> first[4 * N];
int f(int x) { return (x - 1 + lastans) % n + 1; }
int query(int root, int bas, int son, int x, int y, int x2, int y2) {
if (bas > y or son < x) return 0;
if (x <= bas and son <= y)
return upper_bound(first[root].begin(), first[root].end(), y2) -
lower_bound(first[root].begin(), first[root].end(), x2);
return query((root + root), bas, ((bas + son) / 2), x, y, x2, y2) +
query((root + root + 1), ((bas + son) / 2) + 1, son, x, y, x2, y2);
}
void init(int root, int bas, int son) {
if (bas == son) {
first[root].push_back(A[bas]);
return;
}
init((root + root), bas, ((bas + son) / 2));
init((root + root + 1), ((bas + son) / 2) + 1, son);
first[root].resize(first[(root + root)].size() +
first[(root + root + 1)].size());
merge(first[(root + root)].begin(), first[(root + root)].end(),
first[(root + root + 1)].begin(), first[(root + root + 1)].end(),
first[root].begin());
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", A + i);
for (i = 1; i <= n; i++) {
scanf("%d", &x);
H[x] = i;
}
for (i = 1; i <= n; i++) A[i] = H[A[i]];
init(1, 1, n);
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d %d %d %d", &a, &b, &c, &d);
l = min(f(a), f(b));
r = max(f(a), f(b));
l2 = min(f(c), f(d));
r2 = max(f(c), f(d));
lastans = query(1, 1, n, l, r, l2, r2) + 1;
printf("%d\n", lastans - 1);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int BS_2 = 108;
const int BS = 216;
const int N = 1010101;
int n, m, a, b, c, d, a2, b2, c2, d2, p[N], q[N], p2[N], q2[N], f[4700][4700];
int ans;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", p + i);
p2[--p[i]] = i;
}
for (int i = 0; i < n; i++) {
scanf("%d", q + i);
q2[--q[i]] = i;
}
ans = n - 1;
memset(f, 0, sizeof(f));
for (int i = 0; i < n; i++) f[(i / BS) + 1][((p[i] = q2[p[i]]) / BS) + 1]++;
for (int i = 1; i <= (n / BS) + 2; i++)
for (int j = 1; j <= (n / BS) + 2; j++)
f[i][j] += f[i][j - 1] + f[i - 1][j] - f[i - 1][j - 1];
for (int i = 0; i < n; i++) q[p[i]] = i;
for (int i = n; i <= n + 333; i++) p[i] = q[i] = -1;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
a = (a + ans) % n;
b = (b + ans) % n;
c = (c + ans) % n;
d = (d + ans) % n;
if (a > b) swap(a, b);
if (c > d) swap(c, d);
a2 = (a + BS_2) / BS;
b2 = (b + BS_2) / BS;
c2 = (c + BS_2) / BS;
d2 = (d + BS_2) / BS;
ans = f[b2][d2] - f[b2][c2] - f[a2][d2] + f[a2][c2];
a2 *= BS;
b2 *= BS;
c2 *= BS;
d2 *= BS;
if (a2 < a) {
for (int j = a2; j < a; j++)
if (p[j] >= c && p[j] <= d) ans--;
} else {
for (int j = a; j < a2; j++)
if (p[j] >= c && p[j] <= d) ans++;
}
if (b < b2) {
for (int j = b + 1; j < b2; j++)
if (p[j] >= c && p[j] <= d) ans--;
} else {
for (int j = b2; j <= b; j++)
if (p[j] >= c && p[j] <= d) ans++;
}
if (c2 < c) {
for (int j = c2; j < c; j++)
if (q[j] >= a2 && q[j] < b2) ans--;
} else {
for (int j = c; j < c2; j++)
if (q[j] >= a2 && q[j] < b2) ans++;
}
if (d < d2) {
for (int j = d + 1; j < d2; j++)
if (q[j] >= a2 && q[j] < b2) ans--;
} else {
for (int j = d2; j <= d; j++)
if (q[j] >= a2 && q[j] < b2) ans++;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int DIM = 1e6 + 5;
vector<int> sgt[DIM << 2];
int prm1[DIM], prm2[DIM], pos[DIM];
void build(int n, int l, int r) {
if (l == r) {
sgt[n].push_back(pos[prm1[l]]);
return;
}
int m = (l + r) >> 1;
build(n << 1, l, m);
build(n << 1 | 1, m + 1, r);
merge(sgt[n << 1].begin(), sgt[n << 1].end(), sgt[n << 1 | 1].begin(),
sgt[n << 1 | 1].end(), back_inserter(sgt[n]));
return;
}
int query(int n, int l, int r, int _l, int _r, int __l, int __r) {
if (_r < l or r < _l) return 0;
if (_l <= l and r <= _r)
return (int)(upper_bound(sgt[n].begin(), sgt[n].end(), __r) -
lower_bound(sgt[n].begin(), sgt[n].end(), __l));
int m = (l + r) >> 1;
return query(n << 1, l, m, _l, _r, __l, __r) +
query(n << 1 | 1, m + 1, r, _l, _r, __l, __r);
}
inline int f(int z, int x, int n) { return (z - 1 + x) % n + 1; }
int main(void) {
int n, x = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &prm1[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &prm2[i]), pos[prm2[i]] = i;
int q;
scanf("%d", &q);
build(1, 1, n);
while (q--) {
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
int l1 = f(a, x, n), r1 = f(b, x, n), l2 = f(c, x, n), r2 = f(d, x, n);
x = query(1, 1, n, min(l1, r1), max(l1, r1), min(l2, r2), max(l2, r2));
printf("%d\n", x++);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using ll = long long;
using pi = pair<int, int>;
using vi = vc<int>;
using vvi = vvc<int>;
int topbit(int t) {
assert(t > 0);
return 31 - __builtin_clz(t);
}
struct X {
int s;
vvi buf;
X(vi first) {
s = 1;
while (s < int((first).size())) s *= 2;
buf.resize(2 * s);
for (int i = int(1); i < int(2 * s); i++) buf[i] = vi(s >> topbit(i));
for (int i = int(0); i < int(int((first).size())); i++)
buf[s + i][0] = first[i];
for (int i = int(s) - 1; i >= int(1); i--)
merge((buf[2 * i]).begin(), (buf[2 * i]).end(), (buf[2 * i + 1]).begin(),
(buf[2 * i + 1]).end(), buf[i].begin());
}
int in(int i, int second, int e) {
if (e < buf[i].front() || buf[i].back() < second)
return 0;
else
return distance(lower_bound((buf[i]).begin(), (buf[i]).end(), second),
lower_bound((buf[i]).begin(), (buf[i]).end(), e));
}
int get(int second, int e, int b1, int e1) {
int i = second + s;
int j = e + s;
int res = 0;
while (i < j) {
if (i & 1) res += in(i++, b1, e1);
if (j & 1) res += in(--j, b1, e1);
i /= 2;
j /= 2;
}
return res;
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vi p(n);
for (int i = int(0); i < int(n); i++) {
cin >> p[i];
p[i]--;
}
vi q(n);
for (int i = int(0); i < int(n); i++) {
cin >> q[i];
q[i]--;
}
vi iq(n);
for (int i = int(0); i < int(n); i++) iq[q[i]] = i;
vi v(n);
for (int i = int(0); i < int(n); i++) v[i] = iq[p[i]];
X x(v);
int m;
cin >> m;
int last = 0;
auto f = [&](int z) -> int { return (z + last - 1) % n + 1; };
for (int _ = int(0); _ < int(m); _++) {
int first, second, c, d;
cin >> first >> second >> c >> d;
int l1 = min(f(first), f(second)) - 1;
int r1 = max(f(first), f(second));
int l2 = min(f(c), f(d)) - 1;
int r2 = max(f(c), f(d));
last = x.get(l1, r1, l2, r2);
cout << last << '\n';
last++;
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int Maxn = 1000010, Maxm = 100005, Mo = 1000000007,
sp[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const long long oo = INT_MAX >> 2;
struct Tree {
int l, r, cnt;
};
struct edge {
int u, v, len;
};
typedef int IArr[Maxn];
typedef long long LArr[Maxn];
typedef double DArr[Maxn];
IArr x, y, sx, sy;
int n, i, j, ans;
vector<int> vt[Maxn];
void ins(int pos, int key) {
while (pos <= n) {
vt[pos].push_back((key));
pos += pos & -pos;
}
}
int ask(int pos, int key) {
int ans = 0;
while (pos) {
ans += upper_bound(vt[pos].begin(), vt[pos].end(), key) - vt[pos].begin();
pos ^= pos & -pos;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (i = 1; i <= n; i++) {
int a;
cin >> a;
x[a] = i;
}
for (i = 1; i <= n; i++) {
int a;
cin >> a;
y[a] = i;
}
for (i = 1; i <= n; i++) ins(x[i], y[i]);
for (i = 1; i <= n; i++) sort(vt[i].begin(), vt[i].end());
int ct = 0, q, a, b, c, d;
cin >> q;
while (q--) {
cin >> a >> b >> c >> d;
a = (a - 1 + ct) % n + 1;
b = (b - 1 + ct) % n + 1;
c = (c - 1 + ct) % n + 1;
d = (d - 1 + ct) % n + 1;
int a1 = min(a, b), b1 = max(a, b), c1 = min(c, d), d1 = max(c, d);
ct = ask(b1, d1) - ask(b1, c1 - 1) - ask(a1 - 1, d1) + ask(a1 - 1, c1 - 1);
cout << ct++ << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX_N = (1e6) + 3;
int cord[MX_N][2];
vector<int> tv[MX_N];
int n;
void insert(int x, int y) {
for (; x <= n; x += (x & (-x))) tv[x].push_back(y);
}
void init() {
for (int i = 1; i <= n; ++i) sort(tv[i].begin(), tv[i].end());
}
int query(int x, int y) {
int res = 0;
for (; x > 0; x -= (x & (-x)))
res += upper_bound(tv[x].begin(), tv[x].end(), y) - tv[x].begin();
return res;
}
int main() {
scanf("%d", &n);
for (int j = 0; j < 2; ++j)
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
cord[x][j] = i;
}
for (int i = 1; i <= n; ++i) insert(cord[i][0], cord[i][1]);
init();
int m;
scanf("%d", &m);
for (int x = 0; m > 0; --m, ++x) {
int a[4];
for (int i = 0; i < 4; ++i) {
scanf("%d", a + i);
a[i] = (a[i] - 1 + x) % n + 1;
}
int l1 = min(a[0], a[1]);
int r1 = max(a[0], a[1]);
int l2 = min(a[2], a[3]);
int r2 = max(a[2], a[3]);
x = query(r1, r2) - query(l1 - 1, r2) - query(r1, l2 - 1) +
query(l1 - 1, l2 - 1);
printf("%d\n", x);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1000005;
const int Maxm = 4194304;
int n;
int seqa[Maxn], inb[Maxn];
int in[Maxn];
vector<int> st[Maxm];
int m;
int a, b, c, d;
int x;
void Create(int v, int l, int r) {
if (l == r)
st[v].push_back(in[l]);
else {
int m = l + r >> 1;
Create(2 * v, l, m);
Create(2 * v + 1, m + 1, r);
int i = 0, j = 0;
while (i < st[2 * v].size() || j < st[2 * v + 1].size())
if (i < st[2 * v].size() &&
(j == st[2 * v + 1].size() || st[2 * v][i] <= st[2 * v + 1][j]))
st[v].push_back(st[2 * v][i++]);
else
st[v].push_back(st[2 * v + 1][j++]);
}
}
int Get(int v, int l, int r, int a1, int a2, int b1, int b2) {
int res = 0;
if (l == a1 && r == a2)
res = upper_bound(st[v].begin(), st[v].end(), b2) -
lower_bound(st[v].begin(), st[v].end(), b1);
else {
int m = l + r >> 1;
if (a1 <= m) res += Get(2 * v, l, m, a1, min(m, a2), b1, b2);
if (m + 1 <= a2)
res += Get(2 * v + 1, m + 1, r, max(m + 1, a1), a2, b1, b2);
}
return res;
}
int f(int z) { return (z - 1 + x + n) % n + 1; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &seqa[i]);
for (int i = 1; i <= n; i++) {
int b;
scanf("%d", &b);
inb[b] = i;
}
for (int i = 1; i <= n; i++) in[i] = inb[seqa[i]];
Create(1, 1, n);
scanf("%d", &m);
while (m--) {
scanf("%d %d %d %d", &a, &b, &c, &d);
int l1 = min(f(a), f(b)), r1 = max(f(a), f(b)), l2 = min(f(c), f(d)),
r2 = max(f(c), f(d));
x = Get(1, 1, n, l1, r1, l2, r2);
printf("%d\n", x);
x++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> t[1000010 << 2];
int a[1000010], b[1000010];
void ins(int p, int l, int r) {
if (l == r) {
t[p].resize(1);
t[p][0] = b[a[l]];
return;
}
int m = (l + r) >> 1;
ins(p << 1, l, m);
ins(p << 1 | 1, m + 1, r);
t[p].resize(t[p << 1].size() + t[p << 1 | 1].size());
merge(t[p << 1].begin(), t[p << 1].end(), t[p << 1 | 1].begin(),
t[p << 1 | 1].end(), t[p].begin());
}
int get(int p, int l, int r, int first, int second, int a, int b) {
if (second < l || first > r) return 0;
if (l >= first && r <= second) {
return upper_bound(t[p].begin(), t[p].end(), b) -
lower_bound(t[p].begin(), t[p].end(), a);
}
int m = (l + r) >> 1;
return get(p << 1, l, m, first, second, a, b) +
get(p << 1 | 1, m + 1, r, first, second, a, b);
}
int main() {
int i, j, n, m;
while (~scanf("%d", &n)) {
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &j), b[j] = i;
ins(1, 1, n);
scanf("%d", &m);
int first = 0;
while (m--) {
int c, d, e, f;
scanf("%d%d%d%d", &c, &d, &e, &f);
c = (c - 1 + first) % n + 1;
d = (d - 1 + first) % n + 1;
e = (e - 1 + first) % n + 1;
f = (f - 1 + first) % n + 1;
int l1 = min(c, d), r1 = max(c, d);
int l2 = min(e, f), r2 = max(e, f);
first = get(1, 1, n, l1, r1, l2, r2);
printf("%d\n", first);
first++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 10;
int n, a[N], pos[N];
struct SegTree {
vector<int> S[N * 5];
void Build(int k, int l, int r) {
if (l == r) {
S[k].push_back(a[l]);
return;
}
Build(k << 1 | 0, l, ((l + r) >> 1));
Build(k << 1 | 1, ((l + r) >> 1) + 1, r);
S[k].assign(r - l + 1, 0);
merge(S[k << 1 | 0].begin(), S[k << 1 | 0].end(), S[k << 1 | 1].begin(),
S[k << 1 | 1].end(), S[k].begin());
}
int Count(int k, int l, int r) {
vector<int>::iterator i1 = lower_bound(S[k].begin(), S[k].end(), l);
vector<int>::iterator i2 = upper_bound(S[k].begin(), S[k].end(), r);
return i2 - i1;
}
int Query(int k, int l, int r, int i, int j, int x, int y) {
if (l > j || r < i) return 0;
if (i <= l && r <= j) return Count(k, x, y);
return Query(k << 1 | 0, l, ((l + r) >> 1), i, j, x, y) +
Query(k << 1 | 1, ((l + r) >> 1) + 1, r, i, j, x, y);
}
} ST;
int f(int z, int x) { return (z - 1 + x) % n + 1; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
pos[x] = i;
}
for (int i = 1; i <= n; ++i) a[i] = pos[a[i]];
ST.Build(1, 1, n);
int q;
scanf("%d", &q);
int lastAns = -1;
while (q--) {
lastAns++;
int a, b, l1, r1;
scanf("%d%d", &a, &b);
int c, d, l2, r2;
scanf("%d%d", &c, &d);
int x, y;
x = f(a, lastAns);
y = f(b, lastAns);
l1 = min(x, y);
r1 = max(x, y);
x = f(c, lastAns);
y = f(d, lastAns);
l2 = min(x, y);
r2 = max(x, y);
printf("%d\n", lastAns = ST.Query(1, 1, n, l1, r1, l2, r2));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int X, N;
int func(int a) {
a += X;
a--;
a %= N;
if (a < 0) a += N;
return a + 1;
}
int first_ar[1000000 + 9];
int second_ar[1000000 + 9];
int POS[1000000 + 9];
int KEEP[1000000 + 9];
vector<int> seg_tree[1000000 * 4 + 9];
void init_tree(int node, int beg, int end) {
if (beg == end) {
seg_tree[node].push_back(KEEP[beg]);
return;
}
int mid = (beg + end) >> 1;
init_tree((node << 1), beg, mid);
init_tree((node << 1) | 1, mid + 1, end);
for (int i = 0; i < seg_tree[(node << 1)].size(); i++)
seg_tree[node].push_back(seg_tree[(node << 1)][i]);
for (int i = 0; i < seg_tree[(node << 1) | 1].size(); i++)
seg_tree[node].push_back(seg_tree[(node << 1) | 1][i]);
sort(seg_tree[node].begin(), seg_tree[node].end());
;
}
int query(int node, int beg, int end, int i, int j, int a, int b) {
if (i > end || j < beg) return 0;
if (beg >= i && end <= j) {
int ub = upper_bound(seg_tree[node].begin(), seg_tree[node].end(), b) -
seg_tree[node].begin();
int lb = lower_bound(seg_tree[node].begin(), seg_tree[node].end(), a) -
seg_tree[node].begin();
return ub - lb;
}
int mid = (beg + end) >> 1;
int leftnode = query((node << 1), beg, mid, i, j, a, b);
int rightnode = query(((node << 1) | 1), mid + 1, end, i, j, a, b);
return (leftnode + rightnode);
}
int main() {
int i, j, k, l, n, m, tot, temp, curr, val, prev, a, b, c, t, ans, cnt, x, y,
siz, ii, jj, xx, yy, root, ind, len, q, xxx, yyy, d, r, no_per_blk;
int l1, l2, r1, r2;
cin >> n;
N = n;
for (i = 1; i <= n; i++) scanf("%d", &first_ar[i]);
for (i = 1; i <= n; i++) POS[first_ar[i]] = i;
for (i = 1; i <= n; i++) scanf("%d", &second_ar[i]);
for (i = 1; i <= n; i++) KEEP[i] = POS[second_ar[i]];
init_tree(1, 1, n);
cin >> m;
while (m--) {
scanf("%d%d%d%d", &a, &b, &c, &d);
l1 = min(func(a), func(b));
r1 = max(func(a), func(b));
l2 = min(func(c), func(d));
r2 = max(func(c), func(d));
ans = query(1, 1, n, l2, r2, l1, r1);
printf("%d\n", ans);
X = ans + 1;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 5;
int ch[MAXN], arr[MAXN], x, a, b, c, d, l1, l2, r1, r2, n, m;
vector<int> tree[4 * MAXN];
void build(int v, int b, int e) {
if (b == e)
tree[v].push_back(arr[b]);
else {
int m = (b + e) / 2;
build(v + v, b, m);
build(v + v + 1, m + 1, e);
vector<int> &l = tree[v + v], &r = tree[v + v + 1];
tree[v].reserve(l.size() + r.size());
merge(l.begin(), l.end(), r.begin(), r.end(), back_inserter(tree[v]));
}
}
int query(int v, int b, int e, int l, int r, int f, int s) {
if (e < l || b > r) return 0;
if (l <= b && e <= r) {
return upper_bound(tree[v].begin(), tree[v].end(), s) -
lower_bound(tree[v].begin(), tree[v].end(), f);
}
int m = (b + e) / 2;
return query(v + v, b, m, l, r, f, s) +
query(v + v + 1, m + 1, e, l, r, f, s);
}
int f(int z) { return ((z - 1 + x) % n) + 1; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a;
ch[a] = i + 1;
}
for (int i = 1; i <= n; ++i) {
cin >> a;
arr[i] = ch[a];
}
build(1, 1, n);
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> a >> b >> c >> d;
l1 = min(f(a), f(b)), r1 = max(f(a), f(b));
l2 = min(f(c), f(d)), r2 = max(f(c), f(d));
x = query(1, 1, n, l2, r2, l1, r1) + 1;
cout << x - 1 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1000000;
using namespace std;
int n, m, las, a[maxn], b[maxn], c[maxn];
vector<int> tr[maxn * 4];
void build(int p, int l, int r) {
if (l == r) {
tr[p].push_back(a[l]);
return;
}
int mid = (l + r) / 2;
build(p * 2, l, mid), build(p * 2 + 1, mid + 1, r);
int ltop = 0, rtop = 0, llim = mid - l, rlim = r - mid - 1;
for (int i = l; i <= r; ++i)
if (rtop > rlim || (rtop <= rlim && ltop <= llim &&
tr[p * 2][ltop] <= tr[p * 2 + 1][rtop]))
tr[p].push_back(tr[p * 2][ltop++]);
else
tr[p].push_back(tr[p * 2 + 1][rtop++]);
}
int f(int ave) { return ((ave - 1 + las) % n) + 1; }
int query(int p, int l, int r, int lx, int rx, int lans, int rans) {
if (l == lx && r == rx) {
int L = 0, R = r - l, ans = -1, ret = r - l + 1;
while (L <= R) {
int mid = (L + R) / 2;
if (tr[p][mid] < lans)
ans = mid, L = mid + 1;
else
R = mid - 1;
}
ret -= ans + 1;
L = 0, R = r - l, ans = r - l + 1;
while (L <= R) {
int mid = (L + R) / 2;
if (tr[p][mid] > rans)
ans = mid, R = mid - 1;
else
L = mid + 1;
}
ret -= (r - l) - ans + 1;
return ret;
}
int mid = (l + r) / 2;
if (rx <= mid) return query(p * 2, l, mid, lx, rx, lans, rans);
if (lx > mid) return query(p * 2 + 1, mid + 1, r, lx, rx, lans, rans);
return query(p * 2, l, mid, lx, mid, lans, rans) +
query(p * 2 + 1, mid + 1, r, mid + 1, rx, lans, rans);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) scanf("%d", &b[i]), c[b[i]] = i;
for (int i = 1; i <= n; ++i) a[i] = c[a[i]];
build(1, 1, n);
scanf("%d", &m);
las = 0;
int A, B, C, D;
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d%d", &A, &B, &C, &D);
int l = min(f(A), f(B)), r = max(f(A), f(B)), lx = min(f(C), f(D)),
rx = max(f(C), f(D));
las = query(1, 1, n, l, r, lx, rx) + 1;
printf("%d\n", las - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1 << 20;
const int N = 1e6 + 100;
int n, X;
vector<int> stree[M * 2];
int p[N], q[N];
int qu(int l1, int r1, int l2, int r2, int small = 0, int big = M - 1,
int index = 1) {
l1 = max(l1, small);
r1 = min(r1, big);
if (l1 > r1) return 0;
if (small == l1 and big == r1)
return upper_bound((stree[index]).begin(), (stree[index]).end(), r2) -
lower_bound((stree[index]).begin(), (stree[index]).end(), l2);
return qu(l1, r1, l2, r2, small, (small + big) / 2, 2 * index) +
qu(l1, r1, l2, r2, (small + big) / 2 + 1, big, index * 2 + 1);
}
int main() {
ios_base::sync_with_stdio(0);
int tmp;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> tmp;
p[tmp] = i;
}
for (int i = 1; i <= n; ++i) {
cin >> tmp;
q[tmp] = i;
}
for (int i = 1; i <= n; ++i) stree[p[i] + M].push_back(q[i]);
for (int i = M - 1; i >= 0; --i)
merge((stree[i * 2]).begin(), (stree[i * 2]).end(),
(stree[i * 2 + 1]).begin(), (stree[i * 2 + 1]).end(),
back_inserter(stree[i]));
int m, a, b, c, d;
cin >> m;
while (m--) {
cin >> a >> b >> c >> d;
int l1 = min(((((a)-1 + X) % n) + 1), ((((b)-1 + X) % n) + 1)),
r1 = max(((((a)-1 + X) % n) + 1), ((((b)-1 + X) % n) + 1)),
l2 = min(((((c)-1 + X) % n) + 1), ((((d)-1 + X) % n) + 1)),
r2 = max(((((c)-1 + X) % n) + 1), ((((d)-1 + X) % n) + 1));
X = qu(l1, r1, l2, r2);
cout << X++ << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 20);
int a[MAXN], x;
int posB[MAXN], N;
int it[22][MAXN], LOW, UP;
void scan() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%d", &x);
posB[x] = i + 1;
}
for (int i = 1; i <= N; ++i) {
scanf("%d", a + i);
a[i] = posB[a[i]];
}
}
void go(int l, int r, int lvl) {
if (l == r) {
it[lvl][l] = a[l];
return;
}
int mid = (l + r) / 2;
go(l, mid, lvl + 1);
go(mid + 1, r, lvl + 1);
merge(it[lvl + 1] + l, it[lvl + 1] + mid + 1, it[lvl + 1] + mid + 1,
it[lvl + 1] + r + 1, it[lvl] + l);
}
void makeTree() { go(1, N, 0); }
int query(int l, int r, int lvl, int L, int R) {
if (r < L || R < l) return 0;
if (L <= l && r <= R) {
int* lw = lower_bound(it[lvl] + l, it[lvl] + r + 1, LOW);
int* up = upper_bound(it[lvl] + l, it[lvl] + r + 1, UP);
return up - lw;
}
int mid = (l + r) / 2;
return query(l, mid, lvl + 1, L, R) + query(mid + 1, r, lvl + 1, L, R);
}
int query(int l1, int r1, int l2, int r2) {
LOW = l1;
UP = r1;
return query(1, N, 0, l2, r2);
}
void solve() {
makeTree();
int M;
scanf("%d", &M);
x = 0;
while (M--) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
a = (a - 1 + x) % N + 1;
b = (b - 1 + x) % N + 1;
if (a > b) swap(a, b);
c = (c - 1 + x) % N + 1;
d = (d - 1 + x) % N + 1;
if (c > d) swap(d, c);
printf("%d\n", x = query(a, b, c, d));
++x;
}
}
int main() {
scan();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1 << 20;
int n, X, tmp, m, a, b, c, d;
vector<int> stree[M * 2];
int p[M], q[M];
int qu(int l1, int r1, int l2, int r2, int small = 0, int big = M - 1,
int index = 1) {
l1 = max(l1, small);
r1 = min(r1, big);
if (l1 > r1) return 0;
if (small == l1 and big == r1)
return upper_bound((stree[index]).begin(), (stree[index]).end(), r2) -
lower_bound((stree[index]).begin(), (stree[index]).end(), l2);
return qu(l1, r1, l2, r2, small, (small + big) / 2, 2 * index) +
qu(l1, r1, l2, r2, (small + big) / 2 + 1, big, index * 2 + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> tmp;
p[tmp] = i;
}
for (int i = 1; i <= n; ++i) {
cin >> tmp;
q[tmp] = i;
}
for (int i = 1; i <= n; ++i) stree[p[i] + M].push_back(q[i]);
for (int i = M - 1; i >= 0; --i)
merge((stree[i * 2]).begin(), (stree[i * 2]).end(),
(stree[i * 2 + 1]).begin(), (stree[i * 2 + 1]).end(),
back_inserter(stree[i]));
cin >> m;
while (m--) {
cin >> a >> b >> c >> d;
int l1 = min(((((a)-1 + X) % n) + 1), ((((b)-1 + X) % n) + 1)),
r1 = max(((((a)-1 + X) % n) + 1), ((((b)-1 + X) % n) + 1)),
l2 = min(((((c)-1 + X) % n) + 1), ((((d)-1 + X) % n) + 1)),
r2 = max(((((c)-1 + X) % n) + 1), ((((d)-1 + X) % n) + 1));
X = qu(l1, r1, l2, r2);
cout << X++ << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename TH>
void _dbg(const char* sdbg, TH h) {
cerr << sdbg << " = " << h << "\n";
}
template <typename TH, typename... TA>
void _dbg(const char* sdbg, TH h, TA... t) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << " = " << h << ",";
_dbg(sdbg + 1, t...);
}
const int N = 1e6 + 6;
int n, a[N], b[N], q;
vector<int> st[4 * N];
void Build(int id, int l, int r) {
if (l == r) {
st[id].push_back(a[l]);
return;
}
Build(id * 2, l, (l + r) / 2);
Build(id * 2 + 1, (l + r) / 2 + 1, r);
merge(begin(st[id * 2]), end(st[id * 2]), begin(st[id * 2 + 1]),
end(st[id * 2 + 1]), back_inserter(st[id]));
}
int Count(int id, int l, int r, int i, int j, int x, int y) {
if (r < i || l > j) {
return 0;
}
if (i <= l && r <= j) {
int pos1 = upper_bound(begin(st[id]), end(st[id]), y) - begin(st[id]) - 1;
int pos2 = lower_bound(begin(st[id]), end(st[id]), x) - begin(st[id]);
if (pos1 >= pos2) {
return pos1 - pos2 + 1;
}
return 0;
}
return Count(id * 2, l, (l + r) / 2, i, j, x, y) +
Count(id * 2 + 1, (l + r) / 2 + 1, r, i, j, x, y);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i <= n; ++i) {
int x;
cin >> x;
b[x] = i;
}
for (int i = 1; i <= n; ++i) {
a[i] = b[a[i]];
}
Build(1, 1, n);
int x = 0;
auto F = [&x](int z) { return ((z - 1 + x) % n) + 1; };
cin >> q;
while (q--) {
int A, B, C, D;
cin >> A >> B >> C >> D;
int l1 = min(F(A), F(B)), r1 = max(F(A), F(B)), l2 = min(F(C), F(D)),
r2 = max(F(C), F(D));
x = Count(1, 1, n, l1, r1, l2, r2);
cout << x << '\n';
x++;
}
return 0;
}
|
#include <bits/stdc++.h>
char In[1 << 22], *p1 = In, *p2 = In, Ch, Out[1 << 21], *Outp = Out, St[20],
*Tp = St;
inline int Getint(int x = 0) {
while (!isdigit(
Ch =
(p1 == p2 && (p2 = (p1 = In) + fread(In, 1, 1 << 22, stdin), p1 == p2)
? EOF
: *p1++)))
;
for (; isdigit(Ch);
Ch = (p1 == p2 &&
(p2 = (p1 = In) + fread(In, 1, 1 << 22, stdin), p1 == p2)
? EOF
: *p1++))
x = x * 10 + (Ch ^ 48);
return x;
}
inline void Putint(int x) {
do *Tp++ = x % 10 ^ 48;
while (x /= 10);
do *Outp++ = *--Tp;
while (Tp != St);
*Outp++ = '\n';
}
const int N = 1000005, M = 22;
int n, m, A[N], B[N];
int Root[N], Sum[N * M], Lc[N * M], Rc[N * M], Tn;
int o, L, R;
void Insert(int &p, int ps, int l, int r) {
if (p = ++Tn, l == r) {
Sum[p] = Sum[ps] + 1;
return;
}
const int Mid = (l + r) >> 1;
if (o <= Mid)
Insert(Lc[p], Lc[ps], l, Mid), Rc[p] = Rc[ps];
else
Insert(Rc[p], Rc[ps], Mid + 1, r), Lc[p] = Lc[ps];
Sum[p] = Sum[Lc[p]] + Sum[Rc[p]];
}
int Query(int p, int l, int r) {
if (L <= l && r <= R) return Sum[p];
int Mid = (l + r) >> 1, Res = 0;
if (L <= Mid) Res = Query(Lc[p], l, Mid);
if (R > Mid) Res += Query(Rc[p], Mid + 1, r);
return Res;
}
int main() {
n = Getint();
for (register int i = 1; i <= n; ++i) A[Getint()] = i;
for (register int i = 1; i <= n; ++i)
o = B[i] = A[Getint()], Insert(Root[i], Root[i - 1], 1, n);
m = Getint();
for (register int a, b, c, d, x = -1; m--;) {
a = (((Getint()) + x) % n + 1), b = (((Getint()) + x) % n + 1),
c = (((Getint()) + x) % n + 1), d = (((Getint()) + x) % n + 1);
if (a > b) std::swap(a, b);
if (c > d) std::swap(c, d);
L = a, R = b, Putint(x = Query(Root[d], 1, n) - Query(Root[c - 1], 1, n));
}
return fwrite(Out, 1, Outp - Out, stdout), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void READ(int &x) {
char c;
x = 0;
do c = getchar();
while (c < '0' || c > '9');
do x = x * 10 + c - 48, c = getchar();
while (c >= '0' && c <= '9');
}
struct NODE {
int v;
NODE *l, *r;
NODE() : v(0), l(0), r(0) {}
};
const int maxn = 1000005;
int N, M, pos[maxn];
NODE *root[maxn];
void Ins(const NODE *old, NODE *&x, int l, int r, int q) {
x = new NODE();
if (l == r) {
x->v++;
return;
}
int mid((l + r) >> 1);
if (q <= mid)
Ins(old ? old->l : 0, x->l, l, mid, q), x->r = (old ? old->r : 0);
else
Ins(old ? old->r : 0, x->r, mid + 1, r, q), x->l = (old ? old->l : 0);
x->v = (x->l ? x->l->v : 0) + (x->r ? x->r->v : 0);
}
int Find(const NODE *x, int l, int r, int ql, int qr) {
if (!x) return 0;
if (l == ql && r == qr) return x->v;
int mid((l + r) >> 1);
if (qr <= mid) return Find(x->l, l, mid, ql, qr);
if (ql > mid) return Find(x->r, mid + 1, r, ql, qr);
return Find(x->l, l, mid, ql, mid) + Find(x->r, mid + 1, r, mid + 1, qr);
}
int main() {
READ(N);
for (int i = 1; i <= N; i++) {
int x;
READ(x);
pos[x] = i;
}
for (int i = 1; i <= N; i++) {
int x;
READ(x);
Ins(root[i - 1], root[i], 1, N, pos[x]);
}
READ(M);
int ans = -1;
for (int i = 1; i <= M; i++) {
int a, b, c, d, l1, r1, l2, r2;
READ(a), READ(b), READ(c), READ(d);
l1 = min((((a + ans) % N) + 1), (((b + ans) % N) + 1)),
r1 = max((((a + ans) % N) + 1), (((b + ans) % N) + 1)),
l2 = min((((c + ans) % N) + 1), (((d + ans) % N) + 1)),
r2 = max((((c + ans) % N) + 1), (((d + ans) % N) + 1));
ans = Find(root[r2], 1, N, l1, r1) - Find(root[l2 - 1], 1, N, l1, r1);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000;
char buffer[maxn], *S, *T;
inline char Get_Char() {
if (S == T) {
T = (S = buffer) + fread(buffer, 1, maxn, stdin);
if (S == T) return EOF;
}
return *S++;
}
int read() {
char c;
int re = 0, f = 0;
for (c = Get_Char(); c < '0' || c > '9'; c = Get_Char()) {
if (c == '-') f = 1;
}
while (c >= '0' && c <= '9') re = re * 10 + (c & 15), c = Get_Char();
if (f) return -re;
return re;
}
int n, p[1111111], q[1111111], pos[1111111], m, lans, a, b, c, d, l1, r1, l2,
r2;
struct hjt {
int tree[22222222], ls[22222222], rs[22222222], rt[1111111], sz;
void update(int x, int l, int r, int pre, int &nw) {
nw = ++sz;
tree[nw] = tree[pre] + 1;
ls[nw] = ls[pre];
rs[nw] = rs[pre];
if (l == r) return;
int mid = (l + r) >> 1;
if (x > mid)
update(x, mid + 1, r, rs[pre], rs[nw]);
else
update(x, l, mid, ls[pre], ls[nw]);
}
int query(int beg, int en, int l, int r, int pre, int nw) {
if (l > en || r < beg) return 0;
if (l >= beg && r <= en) return tree[nw] - tree[pre];
int mid = (l + r) >> 1;
return query(beg, en, l, mid, ls[pre], ls[nw]) +
query(beg, en, mid + 1, r, rs[pre], rs[nw]);
}
} ht;
int main() {
n = read();
for (int i = 1; i <= n; i++) p[i] = read();
for (int i = 1; i <= n; i++) q[i] = read();
for (int i = 1; i <= n; i++) pos[q[i]] = i;
for (int i = 1; i <= n; i++) {
ht.update(pos[p[i]], 1, n, ht.rt[i - 1], ht.rt[i]);
}
m = read();
for (int i = 1; i <= m; i++) {
a = read();
b = read();
c = read();
d = read();
a = (a - 1 + lans) % n + 1;
b = (b - 1 + lans) % n + 1;
c = (c - 1 + lans) % n + 1;
d = (d - 1 + lans) % n + 1;
l1 = min(a, b);
r1 = max(a, b);
l2 = min(c, d);
r2 = max(c, d);
lans = ht.query(l2, r2, 1, n, ht.rt[l1 - 1], ht.rt[r1]);
printf("%d\n", lans);
lans++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace IO {
const int sz = 1 << 15;
char inbuf[sz], outbuf[sz];
char *pinbuf = inbuf + sz;
char *poutbuf = outbuf;
inline char _getchar() {
if (pinbuf == inbuf + sz) fread(inbuf, 1, sz, stdin), pinbuf = inbuf;
return *(pinbuf++);
}
inline void _putchar(char x) {
if (poutbuf == outbuf + sz) fwrite(outbuf, 1, sz, stdout), poutbuf = outbuf;
*(poutbuf++) = x;
}
inline void flush() {
if (poutbuf != outbuf)
fwrite(outbuf, 1, poutbuf - outbuf, stdout), poutbuf = outbuf;
}
} // namespace IO
inline int read() {
int v = 0, f = 1;
char c = IO::_getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = IO::_getchar();
}
while (c >= '0' && c <= '9') {
v = v * 10 + c - '0';
c = IO::_getchar();
}
return v * f;
}
const int Maxn = 1000005;
int n, p[Maxn], q[Maxn], P[Maxn], Q[Maxn], ord[Maxn];
vector<int> T[Maxn * 4];
void modify(int p, int l, int r, int x, int y) {
T[p].push_back(y);
if (l == r) return;
int mid = l + r >> 1;
if (x <= mid) {
modify(p * 2, l, mid, x, y);
} else {
modify(p * 2 + 1, mid + 1, r, x, y);
}
}
int query(int p, int l, int r, int a, int b, int c, int d) {
if (a <= l && r <= b) {
int pc = lower_bound(T[p].begin(), T[p].end(), c) - T[p].begin();
int pd = upper_bound(T[p].begin(), T[p].end(), d) - T[p].begin();
return pd - pc;
}
int mid = l + r >> 1;
int ans = 0;
if (a <= mid) {
ans += query(p * 2, l, mid, a, b, c, d);
}
if (b > mid) {
ans += query(p * 2 + 1, mid + 1, r, a, b, c, d);
}
return ans;
}
bool cmp(int x, int y) { return Q[x] < Q[y]; }
int main() {
n = read();
for (int i = 1; i <= n; i++) {
p[i] = read();
}
for (int i = 1; i <= n; i++) {
P[p[i]] = i;
}
for (int i = 1; i <= n; i++) {
q[i] = read();
}
for (int i = 1; i <= n; i++) {
Q[q[i]] = i;
ord[i] = i;
}
vector<pair<int, int> > V;
sort(ord + 1, ord + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
modify(1, 1, n, P[ord[i]], Q[ord[i]]);
}
int m = read();
int lastans = 0;
while (m--) {
int a, b, c, d;
a = read();
b = read();
c = read();
d = read();
a = (a - 1 + lastans) % n + 1;
b = (b - 1 + lastans) % n + 1;
c = (c - 1 + lastans) % n + 1;
d = (d - 1 + lastans) % n + 1;
int A = min(a, b), B = max(a, b), C = min(c, d), D = max(c, d);
int rs = query(1, 1, n, A, B, C, D);
lastans = rs + 1;
printf("%d\n", rs);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <class T>
inline T gcd(T a, T b) {
return __gcd(a, b);
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
const int inf = 1e9 + 143;
const long long longinf = 1e18 + 143;
inline int read() {
int x;
scanf(" %d", &x);
return x;
}
const int N = 1010100;
int n;
int p[N], loca[N], locb[N];
vector<int> tree[N * 5];
void init(int x, int l, int r) {
if (l == r) {
tree[x].push_back(p[l]);
} else {
int m = (l + r) >> 1;
init(x + x, l, m);
init(x + x + 1, m + 1, r);
tree[x].resize(tree[x + x].size() + tree[x + x + 1].size());
merge((tree[x + x]).begin(), (tree[x + x]).end(), (tree[x + x + 1]).begin(),
(tree[x + x + 1]).end(), tree[x].begin());
}
}
int get(int x, int l, int r, int x1, int x2, int y1, int y2) {
if (l > x2 || r < x1) return 0;
if (l >= x1 && r <= x2)
return upper_bound((tree[x]).begin(), (tree[x]).end(), y2) -
lower_bound((tree[x]).begin(), (tree[x]).end(), y1);
int m = (l + r) >> 1;
return get(x + x, l, m, x1, x2, y1, y2) +
get(x + x + 1, m + 1, r, x1, x2, y1, y2);
}
inline int f(int z, int x) { return (z + x - 1 + n) % n + 1; }
int main() {
n = read();
for (int i = 1; i <= n; i++) {
int x = read();
loca[x] = i;
}
for (int i = 1; i <= n; i++) {
int x = read();
locb[x] = i;
}
for (int i = 1; i <= n; i++) {
p[loca[i]] = locb[i];
}
init(1, 1, n);
int q = read();
int x = 0;
while (q--) {
int a = read(), b = read(), c = read(), d = read();
int l1 = min(f(a, x), f(b, x));
int r1 = max(f(a, x), f(b, x));
int l2 = min(f(c, x), f(d, x));
int r2 = max(f(c, x), f(d, x));
0;
x = get(1, 1, n, l1, r1, l2, r2);
printf("%d\n", x);
++x;
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 1001000;
const int maxtreetop = 2100000;
struct Ttree {
int start, stop, len;
int *a;
} tree[maxtreetop + 1];
int n;
int l1, r1, l2, r2, result;
int wz[maxn + 1];
int x = 0;
void init_tree(int p, int l, int r) {
tree[p].start = l;
tree[p].stop = r;
tree[p].len = r - l + 1;
tree[p].a = new int[tree[p].len];
if (l < r) {
int mid = (l + r) / 2;
init_tree(p * 2, l, mid);
init_tree(p * 2 + 1, mid + 1, r);
}
}
void sort_tree(int p) {
if (tree[p].len == 1) return;
sort_tree(p * 2);
sort_tree(p * 2 + 1);
int q, q1, q2, len1, len2;
int *a1, *a2;
q1 = q2 = 0;
len1 = tree[p * 2].len;
len2 = tree[p * 2 + 1].len;
a1 = tree[p * 2].a;
a2 = tree[p * 2 + 1].a;
q = 0;
while ((q1 < len1) || (q2 < len2)) {
if ((q1 < len1) && ((q2 >= len2) || (a1[q1] < a2[q2]))) {
tree[p].a[q++] = a1[q1];
++q1;
} else {
tree[p].a[q++] = a2[q2];
++q2;
}
}
}
void ins_tree(int x, int val) {
int p = 1, mid;
while (tree[p].len > 1) {
mid = (tree[p].start + tree[p].stop) / 2;
if (x <= mid)
p = p * 2;
else
p = p * 2 + 1;
}
tree[p].a[0] = val;
}
void init() {
int i, j, q;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", &q);
wz[q] = i;
}
init_tree(1, 1, n);
for (i = 1; i <= n; ++i) {
scanf("%d", &q);
ins_tree(i, wz[q]);
}
sort_tree(1);
}
int f(int z) { return ((z - 1 + x) % n) + 1; }
int xiao(int a, int b) {
if (a < b)
return a;
else
return b;
}
int da(int a, int b) {
if (a > b)
return a;
else
return b;
}
void ask_tree(int p, int l, int r) {
int i, j;
if (tree[p].a[tree[p].len - 1] < l1) return;
if (tree[p].a[0] > r1) return;
if ((l <= tree[p].start) && (r >= tree[p].stop)) {
int *a = tree[p].a;
int start, stop, mid;
if (false) {
int i, j;
i = 0;
j = tree[p].len - 1;
while (a[i] < l1) ++i;
while (a[j] > r1) --j;
result += (j - i + 1);
} else {
start = 0;
stop = tree[p].len - 1;
while (start <= stop) {
mid = (start + stop) / 2;
if (a[mid] >= l1) {
i = mid;
stop = mid - 1;
} else
start = mid + 1;
}
start = 0;
stop = tree[p].len - 1;
while (start <= stop) {
mid = (start + stop) / 2;
if (a[mid] <= r1) {
j = mid;
start = mid + 1;
} else
stop = mid - 1;
}
result += (j - i + 1);
}
return;
}
int mid = (tree[p].start + tree[p].stop) / 2;
if (l <= mid) ask_tree(p * 2, l, r);
if (r > mid) ask_tree(p * 2 + 1, l, r);
}
void work() {
int i, m, a, b, c, d;
scanf("%d", &m);
x = 0;
for (i = 1; i <= m; ++i) {
scanf("%d%d%d%d", &a, &b, &c, &d);
l1 = xiao(f(a), f(b));
r1 = da(f(a), f(b));
l2 = xiao(f(c), f(d));
r2 = da(f(c), f(d));
result = 0;
ask_tree(1, l2, r2);
printf("%d\n", result);
x = result + 1;
}
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
vector<int> seg[N * 4];
int n, m;
int pinf[N];
int a[N];
void fil(int p, int val, int v = 1, int s = 1, int e = n + 1) {
seg[v].push_back(val);
if (e - s == 1) return;
if (p < ((s + e) / 2))
fil(p, val, v * 2, s, ((s + e) / 2));
else
fil(p, val, v * 2 + 1, ((s + e) / 2), e);
}
int get(int l, int r, int lw, int hg, int v = 1, int s = 1, int e = n + 1) {
if (r <= s || e <= l) return 0;
if (l <= s && e <= r)
return upper_bound(seg[v].begin(), seg[v].end(), hg) -
lower_bound(seg[v].begin(), seg[v].end(), lw);
return get(l, r, lw, hg, v * 2, s, ((s + e) / 2)) +
get(l, r, lw, hg, v * 2 + 1, ((s + e) / 2), e);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
pinf[t] = i;
}
for (int i = 1; i <= n; i++) {
int t;
scanf("%d", &t);
a[i] = pinf[t];
fil(i, a[i]);
}
for (int i = 1; i < 4 * N; i++) sort(seg[i].begin(), seg[i].end());
scanf("%d", &m);
int lstans = -1;
while (m--) {
lstans++;
int l, r, s, e;
scanf("%d%d%d%d", &l, &r, &s, &e);
l = ((l - 1 + lstans) % n) + 1;
r = ((r - 1 + lstans) % n) + 1;
s = ((s - 1 + lstans) % n) + 1;
e = ((e - 1 + lstans) % n) + 1;
if (r < l) swap(l, r);
if (e < s) swap(s, e);
lstans = get(s, e + 1, l, r);
printf("%d\n", lstans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct ii {
int x, y;
ii(int x = 0, int y = 0) : x(x), y(y) {}
bool operator<(const ii &a) const {
if (x != a.x) return x < a.x;
return y < a.y;
}
bool operator==(const ii &a) const { return x == a.x && y == a.y; }
ii friend operator+(ii a, ii b) { return ii(a.x + b.x, a.y + b.y); }
ii friend operator-(ii a, ii b) { return ii(a.x - b.x, a.y - b.y); }
};
template <class T>
void sc(T &x) {
x = 0;
char c;
int f = 1;
while (c = getchar(), c < 48)
if (c == '-') f = -1;
do x = x * 10 + (c ^ 48);
while (c = getchar(), c > 47);
x *= f;
}
template <class T>
void nt(T x) {
if (!x) return;
nt(x / 10);
putchar(x % 10 + '0');
}
template <class T>
void pt(T x) {
if (x < 0) putchar('-'), x = -x;
if (!x)
putchar('0');
else
nt(x);
}
template <class T>
void pts(T x) {
pt(x);
putchar(' ');
}
template <class T>
void ptn(T x) {
pt(x);
putchar('\n');
}
template <class v>
void pp(v x, int y) {
static char ch[] = {" \n"};
pt(x);
putchar(ch[y]);
}
template <class T>
void PP(T *x, int y) {
for (int i = 0, i_ = (y)-1; i <= i_; ++i) pp(x[i], i == y - 1);
}
template <class T>
void Max(T &x, T y) {
if (x < y) x = y;
}
template <class T>
void Min(T &x, T y) {
if (x > y) x = y;
}
const int maxn = 1000005;
const int maxV = 24000005;
int n, m, tot, lc[maxV], rc[maxV], v[maxV], last, P[maxn], T[maxn];
int f(int z) { return (z + last - 1) % n + 1; }
int insert(int x, int l, int r, int p) {
int k = ++tot;
v[k] = v[x] + 1;
lc[k] = lc[x];
rc[k] = rc[x];
if (l < r) {
int mid = (l + r) >> 1;
if (p <= mid)
lc[k] = insert(lc[x], l, mid, p);
else
rc[k] = insert(rc[x], mid + 1, r, p);
}
return k;
}
int query(int x, int y, int l, int r, int L, int R) {
if (!y) return 0;
if (L <= l && r <= R) return v[y] - v[x];
int mid = (l + r) >> 1, ans = 0;
if (L <= mid) ans += query(lc[x], lc[y], l, mid, L, R);
if (R > mid) ans += query(rc[x], rc[y], mid + 1, r, L, R);
return ans;
}
int end;
int main() {
sc(n);
int u;
for (int i = 1, i_ = (n + 1) - 1; i <= i_; ++i) sc(u), T[u] = i;
for (int i = 1, i_ = (n + 1) - 1; i <= i_; ++i) sc(u), P[T[u]] = i;
for (int i = 1, i_ = (n + 1) - 1; i <= i_; ++i)
T[i] = insert(T[i - 1], 1, n, P[i]);
sc(m);
while (m--) {
int l, r, a, b;
sc(l);
sc(r);
sc(a);
sc(b);
l = f(l);
r = f(r);
a = f(a);
b = f(b);
if (l > r) swap(l, r);
if (a > b) swap(a, b);
last = query(T[l - 1], T[r], 1, n, a, b);
ptn(last);
last++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int Get_Int() {
int Num = 0, Flag = 1;
char ch;
do {
ch = getchar();
if (ch == '-') Flag = -Flag;
} while (ch < '0' || ch > '9');
do {
Num = Num * 10 + ch - '0';
ch = getchar();
} while (ch >= '0' && ch <= '9');
return Num * Flag;
}
int N, Q, LastAns = -1;
int A[1000005], B[1000005], Position[1000005];
namespace Segment_Tree {
vector<int> Nodes[1000005 * 4];
void Build(int x, int Left, int Right) {
if (Left == Right) {
Nodes[x].push_back(Position[A[Left]]);
return;
}
int Mid = Left + Right >> 1;
Build(x << 1, (0 ? Mid + 1 : Left), (0 ? Right : Mid));
Build(x << 1 | 1, (1 ? Mid + 1 : Left), (1 ? Right : Mid));
vector<int>::iterator it1 = Nodes[x << 1].begin(),
it2 = Nodes[x << 1 | 1].begin();
while (it1 != Nodes[x << 1].end() || it2 != Nodes[x << 1 | 1].end()) {
if (it1 == Nodes[x << 1].end())
Nodes[x].push_back(*it2++);
else if (it2 == Nodes[x << 1 | 1].end())
Nodes[x].push_back(*it1++);
else if (*it1 < *it2)
Nodes[x].push_back(*it1++);
else
Nodes[x].push_back(*it2++);
}
}
int Query(int x, int left, int right, int l, int r, int Left, int Right) {
if (left == Left && right == Right)
return upper_bound(Nodes[x].begin(), Nodes[x].end(), r) -
lower_bound(Nodes[x].begin(), Nodes[x].end(), l);
int Mid = Left + Right >> 1;
if (left > Mid || right <= Mid) {
int i = left > Mid;
return Query(x << 1 | i, left, right, l, r, (i ? Mid + 1 : Left),
(i ? Right : Mid));
}
return Query(x << 1, left, Mid, l, r, (0 ? Mid + 1 : Left),
(0 ? Right : Mid)) +
Query(x << 1 | 1, Mid + 1, right, l, r, (1 ? Mid + 1 : Left),
(1 ? Right : Mid));
}
} // namespace Segment_Tree
inline int F(int x) { return (x + LastAns) % N + 1; }
int main() {
cin >> N;
for (int i = 1; i <= N; ++i) A[i] = Get_Int();
for (int i = 1; i <= N; ++i) {
B[i] = Get_Int();
Position[B[i]] = i;
}
Segment_Tree::Build(1, 1, N);
cin >> Q;
while (Q--) {
int a = Get_Int(), b = Get_Int(), c = Get_Int(), d = Get_Int();
int L1 = min(F(a), F(b)), R1 = max(F(a), F(b)), L2 = min(F(c), F(d)),
R2 = max(F(c), F(d));
printf("%d\n", LastAns = Segment_Tree::Query(1, L1, R1, L2, R2, 1, N));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int N = 1e6 + 5;
int n, x = 0;
int a[N], b[N], arr[N], pos[N];
struct {
vector<int> v;
} t[4 * N];
int fun(int id) { return (id - 1 + x) % n + 1; }
void construct(int node, int start, int end) {
if (start == end)
t[node].v.push_back(pos[start]);
else {
int mid = (start + end) >> 1;
construct(2 * node, start, mid);
construct(2 * node + 1, mid + 1, end);
int i = 0, j = 0, n1 = t[2 * node].v.size(), n2 = t[2 * node + 1].v.size();
while (i < n1 && j < n2) {
if (t[2 * node].v[i] < t[2 * node + 1].v[j]) {
t[node].v.push_back(t[2 * node].v[i]);
i++;
} else {
t[node].v.push_back(t[2 * node + 1].v[j]);
j++;
}
}
while (i < n1) {
t[node].v.push_back(t[2 * node].v[i]);
i++;
}
while (j < n2) {
t[node].v.push_back(t[2 * node + 1].v[j]);
j++;
}
}
}
int query(int node, int start, int end, int l, int r, int x, int y) {
if (start > end || start > r || end < l) return 0;
if (start >= l && end <= r) {
int id1, id2;
id1 =
lower_bound(t[node].v.begin(), t[node].v.end(), x) - t[node].v.begin();
id2 = upper_bound(t[node].v.begin(), t[node].v.end(), y) -
t[node].v.begin() - 1;
if (id1 <= id2) return id2 - id1 + 1;
return 0;
}
int mid = (start + end) >> 1;
int q1 = query(2 * node, start, mid, l, r, x, y);
int q2 = query(2 * node + 1, mid + 1, end, l, r, x, y);
return q1 + q2;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
cin >> n;
int i;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
cin >> b[i];
arr[b[i]] = i;
}
for (i = 1; i <= n; i++) pos[i] = arr[a[i]];
construct(1, 1, n);
int m;
cin >> m;
while (m--) {
int p, q, r, s;
cin >> p >> q >> r >> s;
int l1 = fun(p), r1 = fun(q), l2 = fun(r), r2 = fun(s);
if (l1 > r1) swap(l1, r1);
if (l2 > r2) swap(l2, r2);
x = query(1, 1, n, l1, r1, l2, r2);
printf("%d\n", x);
x++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class sort_map {
public:
int num;
int val;
};
bool myfunc(int a, int b) { return a > b; }
int main() {
long long n;
cin >> n;
vector<long long> input;
long long mmax = 0, sum = 0;
for (int i = 0; i < n; i++) {
long long temp;
cin >> temp;
input.push_back(temp);
sum += temp;
if (temp > mmax) mmax = temp;
}
int e = ceil(sum / (n - 1.0));
if (e < mmax) e = mmax;
cout << e;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long sum = 0, ma = 0, x;
for (int i = 0; i < n; i++) {
cin >> x;
sum += x;
ma = max(ma, x);
}
long long b = sum % (n - 1);
sum -= b;
sum /= (n - 1);
if (b) sum++;
cout << max(ma, sum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x[100000];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < (int)(n); i++) cin >> x[i];
long long sum = 0;
for (int i = 0; i < (int)(n); i++) sum += x[i];
long long ret = *max_element(x, x + n);
ret = max(ret, (sum + n - 2) / (n - 1));
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
long long sum = 0;
long long maxVal = 0LL;
for (long long i = 0; i < (n); ++i) {
long long temp;
cin >> temp;
maxVal = max(maxVal, temp);
sum += temp;
}
long long ans = sum / (n - 1);
if (sum % (n - 1)) ++ans;
ans = max(ans, maxVal);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long n;
vector<long long int> a;
long long check(long long x) {
long long t = 0;
for (long long int i = 0; i < n; i++) {
if (a[i] > x) return 0;
t += (x - a[i]);
}
return t >= x;
}
int solve() {
cin >> n;
for (long long int i = 0; i < n; i++) {
long long x;
cin >> x;
a.push_back(x);
}
long long low = 0, high = 2e9 + 5;
while (low < high) {
long long mid = low + (high - low) / 2;
if (check(mid))
high = mid;
else
low = mid + 1;
}
cout << low << "\n";
return 0;
}
int main() {
auto start = chrono::high_resolution_clock::now();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long test_cases = 1;
while (test_cases--) solve();
auto stop = chrono::high_resolution_clock::now();
auto duration = chrono::duration_cast<chrono::milliseconds>(stop - start);
}
|
#include <bits/stdc++.h>
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
struct comp {
bool operator()(pair<pair<long long, long long>, long long> a,
pair<pair<long long, long long>, long long> b) {
if (a.second == b.second) return a.first.first < b.first.first;
return a.second > b.second;
}
};
long long fb(long long n) {
if (n == 0) return 0;
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n = n + 1;
return (n >> 1);
}
bool perfectSquare(long double x) {
long double sr = sqrt(x);
return ((sr - floor(sr)) == 0);
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
long long sum(long long x) {
long long res = 0;
while (x) {
res += x % 10;
x /= 10;
}
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
auto StArT = chrono::high_resolution_clock::now();
{
long long n;
cin >> n;
vector<long long> arr(n);
long long mx = 0, sum = 0;
for (long long i = (0); i < (n); i++) {
cin >> arr[i];
sum += arr[i], mx = max(mx, arr[i]);
}
long long u = sum / (n - 1);
if (sum % (n - 1)) u++;
long long ans = max(mx, u);
cout << ans << "\n";
}
auto eNd = chrono::high_resolution_clock::now();
double time__taken =
chrono::duration_cast<chrono::nanoseconds>(eNd - StArT).count();
time__taken *= 1e-9;
cerr << "Time taken by program is : " << fixed << time__taken
<< setprecision(9);
cerr << " sec" << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167177216")
using namespace std;
int n;
long long a[100010];
inline bool read() {
if (!(cin >> n)) return false;
for (int i = 0; i < int(n); ++i) cin >> a[i];
return true;
}
inline void solve() {
long long sum = 0;
long long maxval = 0;
for (int i = 0; i < int(n); ++i) sum += a[i], maxval = max(maxval, a[i]);
cout << max((sum + n - 2) / (n - 1), maxval) << endl;
}
int main() {
while (read()) solve();
return 0;
}
|
#include <bits/stdc++.h>
using std::cerr;
using std::make_tuple;
using std::pair;
using std::vector;
vector<long long> arr;
int main() {
int n;
scanf("%d", &n);
long long m = 0;
for (int i = 0; i < n; i++) {
long long a;
scanf("%lld", &a);
arr.push_back(a);
m = std::max(a, m);
}
long long left = m;
long long right = 0x7ffffffffffffLL;
long long ans = 0x7ffffffffffffLL;
while (left <= right) {
long long mid = (left + right) / 2;
long long sum = 0;
for (long long i : arr) {
sum += (mid - i);
if (sum >= mid) {
break;
}
}
if (sum >= mid) {
ans = std::min(ans, mid);
right = mid - 1;
} else {
left = mid + 1;
}
}
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[100005], maxx;
bool issOK(long long x) {
long long cnt = 0;
for (int i = 1; i <= n; i++) {
if (x > a[i]) cnt += x - a[i];
if (cnt >= x) return 1;
}
if (cnt >= x)
return 1;
else
return 0;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
maxx = max(maxx, a[i]);
}
long long l = maxx, r = (long long)1e16;
while (r - l > 3) {
long long mid = (l + r) / 2;
if (issOK(mid))
r = mid;
else
l = mid;
}
for (long long i = l; i <= r; i++) {
if (issOK(i)) {
cout << i;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, mx = 0, som = 0, i;
scanf("%I64d", &n);
long long x;
for (i = 0; i < n; i++) {
scanf("%I64d", &x);
mx = max(mx, x);
som += x;
}
cout << max(mx, (som / (n - 1)) + ((som % (n - 1)) != 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool prime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i += 6) {
if (n % i == 0 || n % (i + 2) == 0) return false;
}
return true;
}
long long modexp(long long a, long long b, long long m) {
long long r = 1;
a = a % m;
while (b > 0) {
if (b & 1) r = (r * a) % m;
b = b >> 1;
a = (a * a) % m;
}
return r % m;
}
long long addmod(long long a, long long b) { return (a + b) % 998244353; }
long long mulmod(long long a, long long b) {
a %= 998244353;
b %= 998244353;
return (a * b) % 998244353;
}
long long submod(long long a, long long b) {
long long x = a - b;
if (x < 0) x += 998244353;
x %= 998244353;
return x;
}
bool comp(pair<pair<long long, long long>, long long> a,
pair<pair<long long, long long>, long long> b) {
if (a.first.first == b.first.first) return a.first.second < b.first.second;
return a.first.first < b.first.first;
}
long long n;
vector<long long> arr;
bool check(long long k) {
long long sum = accumulate((arr).begin(), (arr).end(), 0LL);
if (k * n - sum < k) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
arr = vector<long long>(n);
for (int i = 0; i < n; i++) cin >> arr[i];
sort((arr).begin(), (arr).end());
long long ans = 1e18;
long long l = 1, r = 1e10;
while (l <= r) {
long long mid = l + (r - l) / 2;
if (check(mid)) {
r = mid - 1;
ans = mid;
} else
l = mid + 1;
}
cout << max(arr[n - 1], ans) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string num_to_str(int n) {
string res = "";
if (!n) return "0";
while (n) {
res += ((n % 10) + '0');
n /= 10;
}
reverse(res.begin(), res.end());
return res;
}
int str_to_num(string s) {
int res = 0, p = 1;
for (int i = s.size() - 1; i >= 0; i--) res += ((s[i] - '0') * p), p *= 10;
return res;
}
int n;
long long a[100001], Max;
bool ok(unsigned long long mid) {
long long c = mid - a[0];
for (int i = 1; i < n; i++) {
if (a[i] > mid) return 0;
c += (mid - a[i]);
}
return c >= mid;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i], Max = max(a[i], Max);
sort(a, a + n);
unsigned long long l = Max, h = 1e18, mid = 0, res = 0;
while (l <= h) {
mid = (l + h) / 2;
if (ok(mid))
res = mid, h = mid - 1;
else
l = mid + 1;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, sum, mx;
int main() {
scanf("%I64d", &n);
for (long long i = 0, x; i < n; i++) {
scanf("%I64d", &x);
sum += x;
mx = max(mx, x);
}
if (sum % (n - 1))
printf("%I64d\n", max(mx, sum / (n - 1) + 1));
else
printf("%I64d\n", max(mx, sum / (n - 1)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int MOD = 998244353;
int a[N];
int n;
long long acc;
long long mmax;
long long mmin;
int main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", a + i);
mmin = *min_element(a, a + n);
mmax = *max_element(a, a + n);
for (int i = 0; i < n; i++) acc += a[i];
long long l = mmax, r = 1e14;
long long ans = 0;
while (l <= r) {
long long mid = l + r >> 1;
long long x = (long long)mid * (n - 1);
if (x >= acc) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
int n;
long long a[maxn], sum, mx;
bool ok(long long val) {
bool ret = (sum <= (n - 1) * val);
return ret;
}
void solve() {
long long l = mx, r = 2e10;
long long ans;
while (l <= r) {
long long mid = (l + r) / 2;
if (ok(mid))
ans = mid, r = mid - 1;
else
l = mid + 1;
}
cout << ans << endl;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sum += a[i];
mx = max(a[i], mx);
}
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n], mn = 0, sum = 0;
for (long long i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
if (mn < a[i]) {
mn = a[i];
}
}
long long r = sum / (n - 1);
if (sum % (n - 1) > 0) r++;
if (r < mn) r = mn;
cout << r << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, n, res = 0, s = 0;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> a;
s += a;
if (a > res) {
res = a;
}
}
while (res * (n - 1) < s) {
res++;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5;
long long int a[N];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long int lo = 1, hi = 1e10, ans;
while (lo <= hi) {
long long int mid = (lo + hi) / 2, temp = 0, flag = 1;
for (int i = 0; i < n; i++) {
if (mid < a[i]) flag = 0;
temp += mid - a[i];
}
if (flag && temp >= mid) {
ans = mid;
hi = mid - 1;
} else
lo = mid + 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100009;
long long a[N];
int main() {
int n, m, t, i, j, k = 1;
while (~scanf("%d", &n)) {
long long sum = 0;
for (i = 0; i < n; ++i) {
scanf("%I64d", &a[i]);
sum += a[i];
}
long long L = *max_element(a, a + n), R = sum, mid, ans;
while (L <= R) {
mid = (L + R) >> 1;
if (mid * n - sum >= mid) {
ans = mid;
R = mid - 1;
} else {
L = mid + 1;
}
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void input() {
int i, n, x, xmax = 0;
long long tt = 0;
scanf("%d", &n);
for ((i) = 0; (i) < (n); (i)++)
scanf("%d", &x), tt += x, xmax = ((xmax) > (x) ? (xmax) : (x));
long long dau = 0, cuoi = tt, giua;
while (dau <= cuoi) {
giua = (dau + cuoi) >> 1;
if (giua * (n - 1) >= tt && giua >= xmax)
cuoi = giua - 1;
else
dau = giua + 1;
}
printf("%I64d", dau);
}
int main() {
input();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int x[100005];
int main() {
int n;
long long mn, mx, md, re, ans;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%I64d", &x[i]);
sort(x, x + n);
mn = x[n - 1];
mx = x[0] + x[n - 1];
while (mn <= mx) {
re = 0;
md = (mx + mn) / 2;
for (int i = 0; i < n; i++) re += (md - x[i]);
if (re >= md) {
ans = md;
mx = md - 1;
} else
mn = md + 1;
}
printf("%I64d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, n, sum = 0, maxi = 0;
;
cin >> n;
for (i = 0; i < n; i++) {
cin >> k;
maxi = max(maxi, k);
sum += k;
}
double l = (sum * 1.0) / (n - 1);
j = int(ceil(l));
if (j > maxi)
cout << j;
else
cout << maxi;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int i;
long long A[100010];
long long sum = 0;
long long ma = -1;
for (i = 0; i < n; i++) {
cin >> A[i];
sum += A[i];
ma = max(A[i], ma);
}
long long t = ((sum + n - 2) / (n - 1));
long long r = t;
r = max(r, ma);
cout << r << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)1e6;
const int inf = (int)1e9;
const int mod = (int)1e9 + 7;
const long long INF = (long long)1e18;
const double eps = 1e-9;
int an[200005];
int bn[200005];
int cmp(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &an[i]);
sort(an, an + n);
long long sum = 0;
for (int i = 0; i < n; i++) {
sum += an[i];
}
int ans = sum / (n - 1);
if (sum % (n - 1) != 0) ans++;
if (an[n - 1] > ans) ans = an[n - 1];
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
clock_t _start_clock = clock();
inline void _time() {}
inline int log(const char* format, ...) { return 0; }
const double EPS = 10e-8;
const int MAX = 100005;
const int INF = 1 << 30;
int P[MAX];
int n;
bool is_solution(long long steps) {
int i;
long long dec = steps;
for (i = 0; i < n; i++) {
int diff = steps - P[i];
if (diff > 0) {
if (dec < diff) diff = dec;
dec -= diff;
if (P[i] + diff - steps > 0) return false;
} else if (P[i] - steps > 0) {
return false;
}
}
return dec == 0;
}
int main(int argc, char** argv) {
ios_base::sync_with_stdio(false);
int i;
cin >> n;
for (i = 0; i < n; i++) cin >> P[i];
long long low = 1;
long long high = 1;
while (!is_solution(high)) {
low = high;
high *= 2;
}
long long mid;
while (low <= high) {
mid = (low + high) / 2;
bool sol0 = is_solution(mid);
bool sol1 = is_solution(mid + 1);
if (!sol0 && sol1)
break;
else if (!sol0 && !sol1)
low = mid + 1;
else if (sol0 && sol1)
high = mid - 1;
}
cout << mid + 1 << endl;
return EXIT_SUCCESS;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, ave, maxa;
long long a[100005];
long long sum;
int main() {
scanf("%I64d", &n);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
sum += a[i];
if (a[i] > maxa) maxa = a[i];
}
if (sum % (n - 1))
ave = sum / (n - 1) + 1;
else
ave = sum / (n - 1);
printf("%I64d", max(maxa, ave));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int s = 0, a, m = 0, n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a;
s += a;
m = max(m, a);
}
cout << max(m, ((s - 1) / (n - 1)) + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, maxi = 0;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
maxi = max(maxi, a[i]);
}
long long ki = maxi, ka = 1e13, res;
while (ki <= ka) {
long long mid = (ki + ka) / 2, ret = 0;
for (long long i = 1; i <= n; i++) ret += (mid - a[i]);
if (ret >= mid) {
res = mid;
ka = mid - 1;
} else
ki = mid + 1;
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
int main() {
long long int n, i, temp, sum = 0, max = -1, ans;
scanf("%I64d", &n);
for (i = 0; i < n; i++) {
scanf("%I64d", &temp);
sum = sum + temp;
if (temp > max) max = temp;
}
if (sum % (n - 1) == 0)
ans = sum / (n - 1);
else
ans = sum / (n - 1) + 1;
if (ans < max) ans = max;
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
long long a, sum, amax, x, y;
while (~scanf("%d", &n)) {
for (i = 0, sum = 0, amax = 0; i < n; i++) {
scanf("%I64d", &a);
sum += a;
amax = amax > a ? amax : a;
}
x = sum / (n - 1);
y = sum % (n - 1);
if (y > 0) x += 1;
if (x > amax)
printf("%I64d\n", x);
else
printf("%I64d\n", amax);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int sum = 0;
long long int ma = 0;
for (long long int i = 0; i < n; i++) {
long long int temp;
cin >> temp;
ma = max(ma, temp);
sum += temp;
}
long long int ans = sum / (n - 1);
if (sum % (n - 1)) {
ans++;
}
cout << max(ma, ans) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
long long sum = 0, mx = 0;
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
sum += x;
mx = max(mx, x * 1ll);
}
printf("%d\n", (int)max(mx, (sum + n - 2) / (n - 1)));
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
int main() {
long long n, sum = 0, cnt, b = LLONG_MIN;
scanf("%I64d", &n);
for (int(i) = (0); (i) < (n); (i++)) {
scanf("%I64d", &a[i]);
sum += a[i];
b = max(b, a[i]);
}
n--;
double d = sum;
double e = n;
cnt = (long long)ceil(d / e);
cout << max(cnt, b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const ll inf = 1e18;
const ll mod = 998244353;
const ll MOD = 998244353;
const ll MAX = 2e5 + 1;
inline ll add(ll a, ll b) { return ((a % mod) + (b % mod)) % mod; }
inline ll sub(ll a, ll b) { return ((a % mod) - (b % mod) + mod) % mod; }
inline ll mul(ll a, ll b) { return ((a % mod) * (b % mod)) % mod; }
ll pwr(ll x, ll n) {
if (!n) return 1;
if (n & 1)
return mul(x, pwr(mul(x, x), (n - 1) / 2));
else
return pwr(mul(x, x), n / 2);
}
ll modinv(ll n) { return pwr(n, mod - 2); }
void speed_solve() {
ll n, tot = 0, mx = 0;
cin >> n;
for (ll i = 0; i < n; i++) {
ll x;
cin >> x;
tot += x;
mx = max(mx, x);
}
cout << max(mx, (ll)ceil((ld)tot / (n - 1)));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
ll test_cases = 1;
for (ll i = 0; i < test_cases; i++) {
speed_solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int)3e5 + 10;
int data[maxn], n;
bool check(long long x) {
long long sum = 0;
int ok = 1;
for (int i = 1; i <= n; ++i) {
if (x < data[i])
ok = 0;
else
sum += x - data[i];
}
if (sum < x) ok = 0;
return ok;
}
int main() {
while (scanf("%d", &n) != EOF) {
int mx = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &data[i]);
mx = max(mx, data[i]);
}
long long l = 0, r = (long long)mx * n;
long long ans;
while (l <= r) {
long long mid = (l + r) >> 1;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long arr[100000];
int main() {
long long maxi = 0;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
maxi = max(maxi, arr[i]);
}
long long left = maxi;
long long right = 10000000000LL;
while (left < right) {
long long midd = (left + right) / 2;
long long all = 0;
for (int i = 0; i < n; i++) {
all += midd - arr[i];
}
if (all >= midd) {
right = midd;
} else {
left = midd + 1;
}
}
cout << left << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, a[100001], sum, ans, mx;
int main() {
cin >> N;
for (int i = 0; i < N; i++) {
long long x;
cin >> x;
sum += x;
mx = max(x, mx);
}
ans = sum / (N - 1);
if (sum % (N - 1)) ans++;
cout << max(ans, mx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, sum = 0, k, maxi = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> k;
if (maxi < k) maxi = k;
sum += k;
}
if (sum % (n - 1) != 0)
sum = sum / (n - 1) + 1;
else
sum = sum / (n - 1);
if (maxi < sum)
cout << sum;
else
cout << maxi;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int bs(int n, int x, vector<int> v) {
int start = 0, end = n;
int mid;
while (start <= end) {
mid = (start + end) / 2;
if (v[mid] >= x && v[mid - 1] < x)
break;
else if (v[mid] > x)
end = mid - 1;
else
start = mid + 1;
}
return v[mid];
}
int main() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long sum = 0;
for (long long i = 0; i < n - 1; i++) sum += a[i];
long long start = a[n - 1], end = 10000000000;
long long mid;
while (start <= end) {
mid = (start + end) / 2;
long long k = (n - 1) * mid - sum;
long long q = (n - 1) * (mid - 1) - sum;
if (k >= a[n - 1] && q < a[n - 1])
break;
else if (k > a[n - 1])
end = mid - 1;
else if (k < a[n - 1])
start = mid + 1;
}
cout << mid;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n;
cin >> n;
long long int a[n];
long long int sum = 0;
for (long long int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + n);
long long int req = ceil(sum / (long double)(n - 1));
cout << max(req, a[n - 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, j, s = 0, ans;
cin >> n;
long long int a[n];
for (i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (i = 0; i < n; i++) s = s + (a[n - 1] - a[i]);
s = a[n - 1] - s;
if (s <= 0)
cout << a[n - 1] << endl;
else {
ans = s / (n - 1);
if (s % (n - 1)) ans++;
cout << a[n - 1] + ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fast();
long long int ar[200005];
long long int n, a, b, c, d, m, k, q, mod;
vector<long long int> v;
long long int sum = 0;
long long int mini = INT_MAX;
long long int maxi = INT_MIN;
bool find(long long int mid) {
if (mid < maxi) return false;
if (mid * (n - 1) >= sum) return true;
return false;
long long int complete = 0;
long long int partial = 0;
for (long long int i = 0; i < n; i++) {
long long int temp = ar[i];
complete += temp / mid;
partial += temp % mid;
complete += partial / mid;
partial %= mid;
}
if (complete < n - 1) return true;
if (complete == n - 1 && partial == 0)
return true;
else
return false;
}
int32_t main() {
fast();
long long int t = 1;
while (t--) {
cin >> n;
for (long long int i = 0; i < n; i++) cin >> ar[i];
;
for (long long int i = 0; i < n; i++) {
mini = min(mini, ar[i]);
sum += ar[i];
maxi = max(maxi, ar[i]);
}
long long int pp;
long long int s = mini;
long long int e = sum;
while (s <= e) {
long long int mid = (s + e) / 2;
bool ans = find(mid);
if (ans) {
pp = mid;
e = mid - 1;
} else
s = mid + 1;
}
cout << pp;
}
return 0;
}
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
long long int a[n];
cin >> a[0];
long long int m = a[0];
long long int ans = a[0];
for (long long int i = 1; i < n; i++) {
cin >> a[i];
m += a[i];
ans = max(ans, a[i]);
}
cout << max(ans, (long long int)ceil((double)m / (n - 1))) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[100007];
long long sum = 0;
bool check(long long sm) {
long long ss = 0;
for (long long i = 0; i < n; i++)
if (sm < a[i]) return false;
for (long long i = 0; i < n; i++) ss += sm - a[i];
return ss >= sm;
}
int main() {
scanf("%I64d", &n);
for (long long i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
}
long long lch = 0, rch = (1e14 + 50), mch;
while (rch - lch > 1) {
mch = (lch + rch) / 2;
if (check(mch))
rch = mch;
else
lch = mch;
}
printf("%I64d", rch);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool check(long long x, long long sum, long long a) {
if (x * a - sum >= x) return true;
return false;
}
long long a, l, r, b, c, mid, nu[100010], x, y, cnt;
int main() {
cin >> a;
for (int i = 0; i < a; ++i) {
cin >> nu[i];
cnt += nu[i];
l = max(l, nu[i]);
}
l--;
r = l * 10 + 2;
while (r - l > 1) {
mid = (l + r) / 2;
if (check(mid, cnt, a))
r = mid;
else
l = mid;
}
cout << r;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, sum = 0, maxi = -1e+9;
cin >> n;
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
sum += x;
maxi = max(maxi, x);
}
cout << max(maxi, (long long)ceil((double)sum / (n - 1)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, tmp = 0, sm = 0, mx = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> tmp;
mx = max(mx, tmp);
sm += tmp;
}
cout << max((long long)ceil(sm / ((n - 1) * 1.0)), mx);
}
|
#include <bits/stdc++.h>
long long int mod = (long long int)1000000007;
using namespace std;
void solve() {
long long i, j, k, n;
std::cout.precision(10);
int yes = 0;
cin >> n;
long long a[n];
long long ans = 0;
long long maxi = -1;
for (i = 0; i < n; i++) {
cin >> a[i];
maxi = max(maxi, a[i]);
ans += a[i];
}
ans = max(maxi, (ans - 1) / (n - 1) + 1);
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int i, j, k;
int t;
std::cout.precision(10);
t = 1;
while (t--) {
solve();
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, x, sum = 0, z = LONG_MIN, k;
int main() {
cin >> n;
k = n;
while (n--) cin >> x, sum += x, (x > z) ? z = x : x = 0;
return cout << max(z, ((sum + (k - 2)) / (k - 1))), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
long long sum = 0;
int max1 = -1;
for (int i = 0; i < n; i++) {
cin >> arr[i];
sum += arr[i];
max1 = max(max1, arr[i]);
}
long long x = ceil(sum / (n - 1));
if (x < max1) {
cout << max1;
return 0;
}
if (x * (n - 1) != sum) {
cout << x + 1;
return 0;
}
cout << x;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(int x, int y) { return (x > y); }
int n;
long long Sum = 0, Max = 0;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
Max = max(Max, (long long)x);
Sum += x;
}
cout << max(Max, (long long)ceil(Sum / (n - 1 + 0.0)));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool wayToSort(long long i, long long j) { return i > j; }
bool sortinrev(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first > b.first);
}
bool sortbysecdesc(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.second > b.second;
}
int main() {
long long n;
cin >> n;
long long sum = 0;
long long maxm = 0;
for (long long i = 0; i < (n); i++) {
long long temp;
cin >> temp;
maxm = max(maxm, temp);
sum += temp;
}
cout << max((long long)(ceil((double)sum / (double)(n - 1))), maxm) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, sum = 0, m = 0;
cin >> n;
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
sum += a;
m = max(m, a);
}
cout << max(m, (sum - 1) / (n - 1) + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long res = 0;
long long gcd(long long a, long long b) {
if (max(a, b) == 1 && min(a, b) == 1)
return a;
else {
long long maxx = max(a, b);
long long minx = min(a, b);
res += maxx / minx;
return gcd(minx, (maxx - 1) % minx + 1);
}
}
long long cnk(long long n, long long k, long long mod) {
if (k > n) return 0;
double result = 1;
long long lal = 0;
for (long long lol = n; lol > n - k; lol--) {
result *= lol;
result /= (n - lol + 1);
}
return (long long)result;
}
vector<long long> graph[100000];
vector<long long> vec;
vector<long long> vecis;
vector<pair<pair<int, int>, int> > vec3;
long long log4(long long val) {
long long lol = 1;
long long ii = 0;
if (val == 1) {
return 1;
}
while (lol < val) {
ii++;
lol *= 4;
}
return ii;
}
bool comp(pair<pair<int, int>, int> a, pair<pair<int, int>, int> b) {
return a.first.first > b.first.first;
}
string tostr(long long a) {
ostringstream out;
out << a;
return out.str();
}
long long power(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) {
return power(a, b / 2) * power(a, b / 2);
} else
return a * power(a, b - 1);
}
long long tobig(string str) {
long long res = 0;
for (long long lol = 0; lol < str.size(); lol++) {
res += (str[lol] - 48) * power(10, str.size() - 1 - lol);
}
return res;
}
int t[1000000][26];
int h;
void update(int v, int tl, int tr, int newval, int pos, int sym) {
if (tl == tr) {
t[v][sym] = newval;
return;
} else {
int tm = (tl + tr) >> 1;
if (pos <= tm) {
update(v * 2, tl, tm, newval, pos, sym);
} else {
update(v * 2 + 1, tm + 1, tr, newval, pos, sym);
}
}
t[v][sym] = t[v * 2][sym] + t[v * 2 + 1][sym];
}
int sum(long long v, int tl, int tr, int l, int r, int sym) {
cout << v << "\n";
if (l > r) return 0;
if (l == tl && r == tr) return t[v][sym];
int tm = (tl + tr) / 2;
return sum(v * 2, tl, tm, l, min(r, tm), sym) +
sum(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, sym);
}
long long su[100];
vector<bool> prime(200005, true);
vector<int> razn(100005);
long long cel(long long a, long long b) {
long long res = a / b;
if (a % b != 0) res++;
return res;
}
long long mas[10000];
long long mas1[50], mas2[50];
long long a, b, c;
bool check(long long m) {
long long res = 0;
for (int lol = 0; lol < a; lol++) {
if (vec[lol] > m) return true;
res += m - vec[lol];
}
return res < m;
}
int main() {
cin >> a;
for (int lol = 0; lol < a; lol++) {
cin >> b;
vec.push_back(b);
}
long long l = 0, r = 1e10;
long long x = 0;
while (l <= r) {
long long m = (l + r) >> 1;
if (check(m)) {
x = m;
l = m + 1;
} else {
r = m - 1;
}
}
cout << x + 1;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
long long sum = 0;
int mx = -1;
int a[100005];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
mx = max(mx, a[i]);
}
int theory;
if (!(sum % (n - 1)))
theory = sum / (n - 1);
else
theory = sum / (n - 1) + 1;
cout << max(theory, mx);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.