text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, l, s, n, m, tot, root, last[100005], to[200005], Next[200005],
dis[100005], q[100005], fa[100005], st[100005], en[100005], id[100005];
int a[100005], x, y, ans;
struct node {
int x, y;
};
vector<node> GT[100005 * 4];
inline bool cmp(const int &x, const int &y) { return dis[x] < dis[y]; }
inline void add(int x, int y) {
Next[++tot] = last[x];
last[x] = tot;
to[tot] = y;
}
inline void build(int x) {
int l = 0, r = 1;
q[1] = x;
dis[x] = 1;
while (l < r) {
int k = q[++l];
for (int i = last[k]; i; i = Next[i])
if (fa[k] != to[i]) fa[q[++r] = to[i]] = k, dis[to[i]] = dis[k] + 1;
}
}
inline void dfs(int x) {
st[x] = ++tot;
for (int i = last[x]; i; i = Next[i])
if (to[i] != fa[x]) dfs(to[i]);
en[x] = tot;
}
inline void change(int o, int l, int r, int ll, int x, int p) {
if (!GT[o].size())
GT[o].push_back(node{x, p});
else
GT[o].push_back(node{x, min(p, GT[o][GT[o].size() - 1].y)});
if (l == ll && r == ll) return;
int mid = (l + r) >> 1;
if (ll <= mid)
change(o * 2, l, mid, ll, x, p);
else
change(o * 2 + 1, mid + 1, r, ll, x, p);
}
inline int ask(int o, int l, int r, int ll, int rr, int p) {
if (l == ll && r == rr) {
int L = 0, R = GT[o].size() - 1;
s = 1000000001;
while (L <= R) {
int mid = (L + R) >> 1;
if (GT[o][mid].x > p)
R = mid - 1;
else
L = mid + 1, s = GT[o][mid].y;
}
return s;
}
int mid = (l + r) >> 1;
if (rr <= mid)
return ask(o * 2, l, mid, ll, rr, p);
else if (ll > mid)
return ask(o * 2 + 1, mid + 1, r, ll, rr, p);
else
return min(ask(o * 2, l, mid, ll, mid, p),
ask(o * 2 + 1, mid + 1, r, mid + 1, rr, p));
}
int main() {
scanf("%d%d", &n, &root);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i < n; i++) scanf("%d%d", &x, &y), add(x, y), add(y, x);
build(root);
tot = 0;
dfs(root);
tot = 0;
for (i = 1; i <= n; i++) id[i] = i;
sort(id + 1, id + 1 + n, cmp);
for (i = 1; i <= n; i++) change(1, 1, n, st[id[i]], dis[id[i]], a[id[i]]);
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d%d", &x, &y);
x = (x + ans) % n + 1;
y = (y + ans) % n;
printf("%d\n", ans = ask(1, 1, n, st[x], en[x], dis[x] + y));
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, Q, x, y, r, p, q, kk, cnt, lastans, a[500005], d[500005 * 16],
ls[500005 * 16], rs[500005 * 16], rt[500005], dep[500005], head[500005];
struct Tree {
int nxt, to;
} e[500005];
inline void link(int x, int y) {
e[++kk].nxt = head[x];
e[kk].to = y;
head[x] = kk;
}
int merge(int x, int y) {
if (!x || !y) return x + y;
int ret = ++cnt;
d[ret] = 1e9;
ls[ret] = merge(ls[x], ls[y]);
rs[ret] = merge(rs[x], rs[y]);
d[ret] = min(d[x], d[y]);
return ret;
}
void insert(int &k, int l, int r, int x, int y) {
if (!k) k = ++cnt;
if (l == r) {
d[k] = y;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
insert(ls[k], l, mid, x, y);
else
insert(rs[k], mid + 1, r, x, y);
d[k] = min(d[ls[k]], d[rs[k]]);
}
int query(int k, int l, int r, int x, int y) {
if (!k) return 1e9;
if (x <= l && y >= r) return d[k];
int mid = (l + r) >> 1;
if (y <= mid)
return query(ls[k], l, mid, x, y);
else if (x > mid)
return query(rs[k], mid + 1, r, x, y);
else
return min(query(ls[k], l, mid, x, mid),
query(rs[k], mid + 1, r, mid + 1, y));
}
void dfs1(int u, int fa, int de) {
dep[u] = de;
insert(rt[u], 1, n, de, a[u]);
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa) continue;
dfs1(v, u, de + 1);
rt[u] = merge(rt[u], rt[v]);
}
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
link(x, y);
link(y, x);
}
d[0] = 1e9;
scanf("%d", &Q);
dfs1(r, -1, 1);
while (Q--) {
scanf("%d%d", &p, &q);
int x = (p + lastans) % n + 1;
int k = (q + lastans) % n;
printf("%d\n", lastans = query(rt[x], 1, n, dep[x], min(n, dep[x] + k)));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int res = 0, c;
while (c = getchar(), c < '0' || c > '9')
;
do {
res = (res << 3) + (res << 1) + (c ^ 48);
} while (c = getchar(), c >= '0' && c <= '9');
return res;
}
const int inf = 0x3f3f3f3f;
const int maxn = 100010;
const int maxd = 8000010;
int T[maxd], s[maxn], lson[maxd], rson[maxd], val[maxd], tot;
int l[maxn], r[maxn], d[maxn];
vector<int> edge[maxn], lay[maxn];
int N, R, last, dep, dfn;
void dfs(int x, int dep) {
l[x] = ++dfn;
d[x] = dep;
::dep = max(dep, ::dep);
lay[dep].push_back(x);
for (auto i : edge[x])
if (!l[i]) {
dfs(i, dep + 1);
}
r[x] = dfn;
}
void update(int to, int L, int R, int& rt) {
if (L == R) {
val[rt = ++tot] = s[to];
return;
}
int mid = L + R >> 1;
lson[++tot] = lson[rt];
rson[tot] = rson[rt];
rt = tot;
if (l[to] <= mid)
update(to, L, mid, lson[rt]);
else
update(to, mid + 1, R, rson[rt]);
val[rt] = min(val[lson[rt]], val[rson[rt]]);
}
int query(int l, int r, int L, int R, int rt) {
if (L >= l && R <= r) {
return val[rt];
}
int mid = L + R >> 1, res = inf;
if (mid >= l) res = query(l, r, L, mid, lson[rt]);
if (mid < r) res = min(res, query(l, r, mid + 1, R, rson[rt]));
return res;
}
int main() {
N = read(), R = read();
for (int i = 1; i <= N; i++) s[i] = read();
for (int i = 1; i < N; i++) {
int x = read(), y = read();
edge[x].push_back(y);
edge[y].push_back(x);
}
dfs(R, 1);
T[0] = lson[0] = rson[0] = 0;
val[0] = inf;
for (int d = 1; d <= dep; d++) {
T[d] = ++tot;
lson[tot] = lson[T[d - 1]];
rson[tot] = rson[T[d - 1]];
for (auto i : lay[d]) update(i, 1, N, T[d]);
}
int Q = read();
while (Q--) {
int X = (last + read()) % N + 1, K = (read() + last) % N;
printf("%d\n", last = query(l[X], r[X], 1, N, T[min(dep, d[X] + K)]));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, sz = 320;
int n, r, a[N], in[N], out[N], d[N];
vector<int> g[N];
vector<pair<int, int> > v, tree[4 * N];
void dfs(int node, int parent = -1, int depth = 0) {
d[node] = depth;
in[node] = v.size();
v.push_back({depth, a[node]});
for (auto child : g[node]) {
if (child == parent) continue;
dfs(child, node, depth + 1);
}
out[node] = v.size() - 1;
}
void build(int node, int l, int r) {
if (l == r) {
tree[node].push_back(v[l]);
return;
}
int md = (l + r) >> 1;
build(node << 1, l, md);
build(node << 1 | 1, md + 1, r);
merge(tree[node << 1].begin(), tree[node << 1].end(),
tree[node << 1 | 1].begin(), tree[node << 1 | 1].end(),
back_inserter(tree[node]));
int mn = 2e9;
for (auto &it : tree[node]) mn = min(mn, it.second), it.second = mn;
}
int query(int node, int l, int r, int i, int j, int val) {
if (i > r || j < l || i > j) return 2e9;
if (l >= i && r <= j) {
auto it = upper_bound(tree[node].begin(), tree[node].end(),
make_pair(val, (int)2e9));
if (it == tree[node].begin()) return 2e9;
it--;
return it->second;
}
int md = (l + r) >> 1;
return min(query(node << 1, l, md, i, j, val),
query(node << 1 | 1, md + 1, r, i, j, val));
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> r;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(r);
build(1, 0, v.size() - 1);
int q;
cin >> q;
int last = 0;
while (q--) {
int p, q;
cin >> p >> q;
int x = (p + last) % n + 1;
int k = (q + last) % n;
last = query(1, 0, v.size() - 1, in[x], out[x], k + d[x]);
cout << last << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 10;
const int INF = 0x3f3f3f3f;
int a[MAXN];
vector<int> G[MAXN];
int tot;
int dep[MAXN];
int rt[MAXN];
int val[MAXN << 6], ls[MAXN << 6], rs[MAXN << 6];
void push_up(int n) { val[n] = min(val[ls[n]], val[rs[n]]); }
void update(int p, int v, int l, int r, int &n) {
n = ++tot;
if (l == r) {
val[n] = v;
return;
}
int m = (l + r) / 2;
if (p <= m) {
update(p, v, l, m, ls[n]);
} else {
update(p, v, m + 1, r, rs[n]);
}
push_up(n);
}
int merging(int u, int v) {
if (!u) return v;
if (!v) return u;
int t = ++tot;
ls[t] = merging(ls[u], ls[v]);
rs[t] = merging(rs[u], rs[v]);
if (ls[t] || rs[t])
push_up(t);
else
val[t] = min(val[u], val[v]);
return t;
}
int query(int ql, int qr, int l, int r, int n) {
if (!n) return INF;
if (ql == l && qr == r) return val[n];
int m = (l + r) / 2;
if (qr <= m) return query(ql, qr, l, m, ls[n]);
if (ql > m) return query(ql, qr, m + 1, r, rs[n]);
return min(query(ql, m, l, m, ls[n]), query(m + 1, qr, m + 1, r, rs[n]));
}
void dfs(int u, int p) {
update(dep[u], a[u], 1, MAXN - 1, rt[u]);
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == p) continue;
dep[v] = dep[u] + 1;
dfs(v, u);
rt[u] = merging(rt[u], rt[v]);
}
}
int main() {
val[0] = INF;
int n, r;
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dep[r] = 1;
dfs(r, 0);
int m;
scanf("%d", &m);
int lst = 0;
while (m--) {
int x, y;
scanf("%d%d", &x, &y);
x = (x + lst) % n + 1;
y = (y + lst) % n;
printf("%d\n",
lst = query(dep[x], min(MAXN - 1, dep[x] + y), 1, MAXN - 1, rt[x]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int readi() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int MAXN = 1e5 + 5;
int n, r, m;
int a[MAXN], dep[MAXN];
vector<int> adj[MAXN];
int tl[MAXN], tr[MAXN], inv[MAXN], Tm;
void dfs(int cur, int p = -1) {
if (p != -1) dep[cur] = dep[p] + 1;
tl[cur] = ++Tm;
inv[Tm] = cur;
for (int v : adj[cur])
if (v != p) {
dfs(v, cur);
}
tr[cur] = Tm;
}
vector<pair<int, int> > t[4 * MAXN];
vector<int> pre[4 * MAXN];
void pull(int x) {
merge(t[x << 1].begin(), t[x << 1].end(), t[x << 1 | 1].begin(),
t[x << 1 | 1].end(), back_inserter(t[x]));
pre[x].push_back(t[x][0].second);
for (int i = 1; i < ((int)(t[x]).size()); i++) {
pre[x].push_back(min(pre[x].back(), t[x][i].second));
}
}
void build(int x, int l, int r) {
if (l == r) {
t[x].push_back({dep[inv[l]], a[inv[l]]});
pre[x].push_back(t[x][0].second);
} else {
int mid = l + r >> 1;
build(x << 1, l, mid);
build(x << 1 | 1, mid + 1, r);
pull(x);
}
}
int get(int x, int d) {
int id = lower_bound(t[x].begin(), t[x].end(), make_pair(d + 1, 0)) -
t[x].begin() - 1;
if (id == -1) return 2000000000;
return pre[x][lower_bound(t[x].begin(), t[x].end(), make_pair(d + 1, 0)) -
t[x].begin() - 1];
}
int query(int x, int l, int r, int ql, int qr, int d) {
if (r < ql || l > qr || l > r) return 2000000000;
if (l >= ql && r <= qr) return get(x, d);
int mid = l + r >> 1;
return min(query(x << 1, l, mid, ql, qr, d),
query(x << 1 | 1, mid + 1, r, ql, qr, d));
}
int main() {
n = readi(), r = readi();
for (int i = 1; i <= n; i++) a[i] = readi();
for (int i = 1; i < n; i++) {
int x = readi(), y = readi();
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(r);
build(1, 1, n);
m = readi();
int last = 0;
while (m--) {
int x = (readi() + last) % n + 1;
int k = (readi() + last) % n;
last = query(1, 1, n, tl[x], tr[x], dep[x] + k);
printf("%d\n", last);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005, INF = 0x3f3f3f3f;
struct Segment_tree {
struct Node {
vector<pair<int, int> > value;
vector<int> minv;
} seg[MAXN << 2];
void modify(int pos, pair<int, int> value, int left, int right, int x) {
seg[x].value.push_back(value);
if (left == right) return;
int mid = (left + right) / 2;
if (pos <= mid)
modify(pos, value, left, mid, x << 1);
else
modify(pos, value, mid + 1, right, x << 1 | 1);
}
void build(int left, int right, int x) {
sort(seg[x].value.begin(), seg[x].value.end());
seg[x].minv.push_back(seg[x].value[0].second);
for (int i = 1; i < seg[x].value.size(); i++)
seg[x].minv.push_back(min(seg[x].minv[i - 1], seg[x].value[i].second));
if (left == right) return;
int mid = (left + right) / 2;
build(left, mid, x << 1);
build(mid + 1, right, x << 1 | 1);
}
int query(int depth, int x) {
if (seg[x].value[0].first > depth) return INF;
int left = 0, right = seg[x].value.size();
while (right - left > 1) {
int mid = (left + right) / 2;
if (seg[x].value[mid].first > depth)
right = mid;
else
left = mid;
}
return seg[x].minv[left];
}
int query(int depth, int l, int r, int left, int right, int x) {
if (l == left && r == right) return query(depth, x);
int mid = (left + right) / 2;
if (r <= mid)
return query(depth, l, r, left, mid, x << 1);
else if (l > mid)
return query(depth, l, r, mid + 1, right, x << 1 | 1);
else
return min(query(depth, l, mid, left, mid, x << 1),
query(depth, mid + 1, r, mid + 1, right, x << 1 | 1));
}
} tree;
vector<int> edges[MAXN];
int n, m, root, t;
int value[MAXN], depth[MAXN], start[MAXN], over[MAXN];
void dfs(int x, int y, int d) {
depth[x] = d;
start[x] = ++t;
for (auto i : edges[x])
if (i != y) dfs(i, x, d + 1);
over[x] = t;
}
int main() {
scanf("%d%d", &n, &root);
for (int i = 1; i <= n; i++) scanf("%d", value + i);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
edges[u].push_back(v);
edges[v].push_back(u);
}
dfs(root, 0, 1);
for (int i = 1; i <= n; i++)
tree.modify(start[i], make_pair(depth[i], value[i]), 1, n, 1);
tree.build(1, n, 1);
scanf("%d", &m);
int ans = 0;
while (m--) {
int x, k;
scanf("%d%d", &x, &k);
x = (x + ans) % n + 1;
k = (k + ans) % n;
ans = tree.query(depth[x] + k, start[x], over[x], 1, n, 1);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void debug() { cout << endl; }
template <typename T, typename... R>
void debug(T f, R... r) {
cout << "[" << f << "]";
debug(r...);
}
int a[100005], deep[100005], root[100005], id, n, r;
vector<int> e[100005];
struct Node {
int l, r, minn;
} t[100005 * 49];
void build(int &p, int l, int r, int pos, int num) {
if (!p) p = ++id;
t[p].minn = num;
if (l == r) return;
int mid = l + r >> 1;
if (pos <= mid)
build(t[p].l, l, mid, pos, num);
else
build(t[p].r, mid + 1, r, pos, num);
}
int mer(int x, int y) {
if (!x || !y) return x | y;
int tmp = ++id;
t[tmp].l = mer(t[x].l, t[y].l);
t[tmp].r = mer(t[x].r, t[y].r);
t[tmp].minn = min(t[x].minn, t[y].minn);
return tmp;
}
void dfs(int u, int fa) {
deep[u] = deep[fa] + 1;
build(root[u], 1, n, deep[u], a[u]);
for (auto v : e[u]) {
if (v == fa) continue;
dfs(v, u);
root[u] = mer(root[u], root[v]);
}
}
int query(int p, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return t[p].minn;
int mid = l + r >> 1;
if (qr <= mid) return query(t[p].l, l, mid, ql, qr);
if (ql > mid) return query(t[p].r, mid + 1, r, ql, qr);
return min(query(t[p].l, l, mid, ql, qr), query(t[p].r, mid + 1, r, ql, qr));
}
int main() {
t[0].minn = 2e9;
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 2; i <= n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
dfs(r, 0);
int m, last = 0, p, q;
for (scanf("%d", &m); m; --m) {
scanf("%d%d", &p, &q);
p = (p + last) % n + 1;
q = (q + last) % n;
last = query(root[p], 1, n, deep[p], min(deep[p] + q, n));
printf("%d\n", last);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 100 * 1000;
const int MOD = 1e9 + 7;
const int INF = (1 << 30);
vector<pair<int, int> > aint[4 * NMAX + 2];
vector<int> G[NMAX + 2];
int v[NMAX + 2], lev[NMAX + 2], e[NMAX + 2], st[NMAX + 2], dr[NMAX + 2];
bool viz[NMAX + 2];
int N, Q, R, e_ind = 0;
void DFS(int nod) {
viz[nod] = 1;
st[nod] = ++e_ind;
e[e_ind] = nod;
for (int x : G[nod]) {
if (viz[x]) continue;
lev[x] = lev[nod] + 1;
DFS(x);
}
dr[nod] = e_ind;
}
void build(int nod, int st, int dr) {
if (st == dr) {
aint[nod].push_back({lev[e[st]], v[e[st]]});
return;
}
int mid = (st + dr) / 2;
build(2 * nod, st, mid);
build(2 * nod + 1, mid + 1, dr);
int ind = 0;
for (int i = 0; i < aint[2 * nod].size(); ++i) {
while (ind < aint[2 * nod + 1].size() &&
aint[2 * nod + 1][ind] < aint[2 * nod][i]) {
aint[nod].push_back(aint[2 * nod + 1][ind]);
++ind;
}
aint[nod].push_back(aint[2 * nod][i]);
}
while (ind < aint[2 * nod + 1].size())
aint[nod].push_back(aint[2 * nod + 1][ind++]);
for (int i = 1; i < aint[nod].size(); ++i)
aint[nod][i].second = min(aint[nod][i].second, aint[nod][i - 1].second);
}
int Query(int nod, int st, int dr, int x, int y, int maxl) {
if (dr < x || st > y) return INF;
if (x <= st && dr <= y) {
auto it =
upper_bound(aint[nod].begin(), aint[nod].end(), make_pair(maxl, INF));
if (it == aint[nod].begin()) return INF;
--it;
return (*it).second;
}
int mid = (st + dr) / 2;
int a = Query(2 * nod, st, mid, x, y, maxl);
int b = Query(2 * nod + 1, mid + 1, dr, x, y, maxl);
return min(a, b);
}
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
cin >> N >> R;
for (int i = 1; i <= N; ++i) cin >> v[i];
for (int i = 1; i < N; ++i) {
int x, y;
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
DFS(R);
build(1, 1, N);
cin >> Q;
int last = 0;
while (Q--) {
int nod, level;
cin >> nod >> level;
nod = (nod + last) % N + 1;
level = (level + last) % N;
cout << (last = Query(1, 1, N, st[nod], dr[nod], lev[nod] + level)) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, Q, x, y, r, p, q, kk, cnt, lastans, a[500005], d[500005 * 16],
ls[500005 * 16], rs[500005 * 16], rt[500005], dep[500005], head[500005];
struct Tree {
int nxt, to;
} e[500005];
inline void link(int x, int y) {
e[++kk].nxt = head[x];
e[kk].to = y;
head[x] = kk;
}
int merge(int x, int y) {
if (!x || !y) return x + y;
int ret = ++cnt;
d[ret] = 1e9;
ls[ret] = merge(ls[x], ls[y]);
rs[ret] = merge(rs[x], rs[y]);
d[ret] = min(d[x], d[y]);
return ret;
}
void insert(int &k, int l, int r, int x, int y) {
if (!k) k = ++cnt;
if (l == r) {
d[k] = y;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
insert(ls[k], l, mid, x, y);
else
insert(rs[k], mid + 1, r, x, y);
d[k] = min(d[ls[k]], d[rs[k]]);
}
int query(int k, int l, int r, int x, int y) {
if (!k) return 1e9;
if (x <= l && y >= r) return d[k];
int mid = (l + r) >> 1;
if (y <= mid)
return query(ls[k], l, mid, x, y);
else if (x > mid)
return query(rs[k], mid + 1, r, x, y);
else
return min(query(ls[k], l, mid, x, mid),
query(rs[k], mid + 1, r, mid + 1, y));
}
void dfs1(int u, int fa, int de) {
dep[u] = de;
insert(rt[u], 1, n, de, a[u]);
for (int i = head[u]; i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa) continue;
dfs1(v, u, de + 1);
rt[u] = merge(rt[u], rt[v]);
}
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
link(x, y);
link(y, x);
}
d[0] = 1e9;
scanf("%d", &Q);
dfs1(r, -1, 1);
while (Q--) {
scanf("%d%d", &p, &q);
int x = (p + lastans) % n + 1;
int k = (q + lastans) % n;
printf("%d\n", lastans = query(rt[x], 1, n, dep[x], min(n, dep[x] + k)));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T>
int sz(const T &a) {
return int(a.size());
}
const int MAXN = 1e5 + 1;
int arr[MAXN], depth[MAXN], st[MAXN], en[MAXN];
vector<int> matrix[MAXN];
vector<int> et;
void dfs(int loc, int parent, int dep) {
depth[loc] = dep;
st[loc] = sz(et);
et.push_back(loc);
for (auto x : matrix[loc]) {
if (x != parent) {
dfs(x, loc, dep + 1);
et.push_back(loc);
}
}
en[loc] = sz(et) - 1;
}
struct seg {
struct node {
vector<int> mi;
int stdep;
node() { mi = {}, stdep = 0; }
} t[4 * MAXN];
void mt(int ind, int le, int ri) {
if (le == ri) {
t[ind].mi = {arr[et[le]]}, t[ind].stdep = depth[et[le]];
return;
}
int mid = (le + ri) / 2;
int left = ind + 1, right = ind + (mid - le + 1) * 2;
mt(left, le, mid), mt(right, mid + 1, ri);
int curmi = INT_MAX;
int maval = max(t[left].stdep + sz(t[left].mi) - 1,
t[right].stdep + sz(t[right].mi) - 1),
mival = min(t[left].stdep, t[right].stdep);
t[ind].mi.resize(maval - mival + 1);
t[ind].stdep = mival;
for (int i = mival; i <= maval; i++)
t[ind].mi[i - mival] = curmi = min(
{curmi,
((i - t[left].stdep >= 0 && i - t[left].stdep < sz(t[left].mi))
? t[left].mi[i - t[left].stdep]
: INT_MAX),
((i - t[right].stdep >= 0 && i - t[right].stdep < sz(t[right].mi))
? t[right].mi[i - t[right].stdep]
: INT_MAX)});
}
int query(int ind, int le, int ri, int l, int r, int dep) {
if (r < le || l > ri) return INT_MAX;
if (le >= l && ri <= r)
return (dep >= t[ind].stdep
? t[ind].mi[min(sz(t[ind].mi) - 1, dep - t[ind].stdep)]
: INT_MAX);
int mid = (le + ri) / 2;
int left = ind + 1, right = ind + (mid - le + 1) * 2;
return min(query(left, le, mid, l, r, dep),
query(right, mid + 1, ri, l, r, dep));
}
} tree;
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n, r;
cin >> n >> r;
for (int i = 1; i <= n; i++) cin >> arr[i];
int a, b;
for (int i = 1; i < n; i++) {
cin >> a >> b;
matrix[a].push_back(b);
matrix[b].push_back(a);
}
dfs(r, 0, 1);
tree.mt(0, 0, sz(et) - 1);
int m;
cin >> m;
int last = 0;
int x, k;
while (m--) {
cin >> x >> k;
x = ((x + last) % n) + 1, k = (k + last) % n;
printf("%d\n",
last = tree.query(0, 0, sz(et) - 1, st[x], en[x], depth[x] + k));
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
void gi(int &x) {
static char r[(1 << 24) + 16], *s = r, *l = r + (1 << 24);
x = 0;
if (!*s) memset(r, 0, (1 << 24)), cin.read(r, (1 << 24)), s = r;
while (*s && (*s < 48 || *s > 57)) ++s;
while (*s >= 48 && *s <= 57) {
x = x * 10 + *s - 48, ++s;
if (s == l) memset(r, 0, (1 << 24)), cin.read(r, (1 << 24)), s = r;
}
++s;
}
char QQ[(1 << 24) + 16], *OP = QQ, *LP = QQ + (1 << 24);
void pn(int x) {
char *B = OP, c, *E;
int t;
if (!x) t = x / 10, c = x - 10 * t + 48, *OP++ = c, x = t;
while (x) t = x / 10, c = x - 10 * t + 48, *OP++ = c, x = t;
E = OP - 1;
while (B < E) swap(*B, *E), ++B, --E;
if (OP > LP) cout.write(QQ, OP - QQ), OP = QQ;
}
void pc(char c) { *OP++ = c; }
void ga(int N, int *A) {
for (int i(0); i < N; i++) gi(A[i]);
}
struct UF {
int v;
UF(long long a = int(1e9 + 1)) { v = a; }
UF mg(UF r) { return UF(min(v, r.v)); }
};
struct sX {
UF P[((100005) * 60)];
int N, t, T[(100005) * 4], L[((100005) * 60)], R[((100005) * 60)], l;
void ini(int n) {
N = 1 << (int(log2(n) - (1e-10)) + 1), *T = t = 1, l = (N << 1) + 2;
for (int i(0); i < N << 1; i++)
P[i] = UF(), L[i] = i << 1, R[i] = i << 1 | 1;
}
int st(int b, UF v) { return T[t] = st(b, v, T[t - 1], 0, N - 1), t++; }
int st(int b, UF v, int u, int B, int E) {
if (B > b || E < b) return u;
int I = u;
u = l++, L[u] = L[I], R[u] = R[I], P[u] = P[I];
if (B == E) return P[u] = v, u;
L[u] = st(b, v, L[u], B, (B + E) >> 1),
R[u] = st(b, v, R[u], (B + E) / 2 + 1, E);
P[u] = P[L[u]].mg(P[R[u]]);
return u;
}
UF gt(int b, int e, int t) { return gt(b, e, T[t], 0, N - 1); }
UF gt(int b, int e, int u, int B, int E) {
if (b <= B && e >= E) return P[u];
if (b > (B + E) >> 1) return gt(b, e, R[u], (B + E) / 2 + 1, E);
if (e <= (B + E) >> 1) return gt(b, e, L[u], B, (B + E) >> 1);
return gt(b, e, L[u], B, (B + E) >> 1)
.mg(gt(b, e, R[u], (B + E) / 2 + 1, E));
}
} G;
vector<int> g[(100005)];
int N, Q, A[(100005)], D[(100005)], B[(100005)], E[(100005)], R, l, a, b,
H[(100005)], T[(100005) * 2], L;
void dfs(int u, int p, int d) {
D[u] = d++, B[u] = l++;
for (auto &h : g[u])
if (h ^ p) dfs(h, u, d);
E[u] = l - 1;
}
bool cp(int a, int b) { return D[a] < D[b]; }
int main(void) {
ios_base::sync_with_stdio(0);
gi(N), gi(R), --R, ga(N, A), iota(H, H + N, 0), G.ini(N),
fill(T, T + (100005) * 2, N);
for (int i(0); i < N - 1; i++)
gi(a), gi(b), g[--a].push_back(--b), g[b].push_back(a);
dfs(R, R, 0), sort(H, H + N, cp);
for (int i(0); i < N; i++) T[D[H[i]]] = G.st(B[H[i]], {A[H[i]]});
int _ = 0;
gi(_);
for (int i(0); i < _; i++)
gi(a), gi(b), a = (a + L) % N, b = (b + L) % N,
pn(L = G.gt(B[a], E[a], T[b + D[a]]).v), pc(10);
cout.write(QQ, OP - QQ);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, R, M, x, y, c, p, q, k, ans;
int a[270100];
vector<int> conn[270100];
vector<int> level2[270100];
int parent[21][270100];
int rect[21][270100];
int level[270100], id[270100], lvlcounter[270100];
vector<int> tree[21][270100];
int v[270100], u[270100];
void dfs(int node, int par, int lvl) {
parent[0][node] = par;
level[node] = lvl;
rect[0][node] = a[node];
lvlcounter[lvl]++;
level2[lvl].push_back(node);
id[node] = lvlcounter[level[node]];
if ((par == 0 && conn[node].size() == 0) ||
(par != 0 && conn[node].size() == 1)) {
++c;
v[node] = u[node] = c;
}
for (int i = 0; i < conn[node].size(); i++) {
if (conn[node][i] != par) {
dfs(conn[node][i], node, lvl + 1);
v[node] = min(v[node], v[conn[node][i]]);
u[node] = max(u[node], u[conn[node][i]]);
}
}
}
void update(int cx, int cy, int node, int l, int r, int q) {
if (l == id[q] && r == id[q]) {
tree[cx][cy][node] = min(tree[cx][cy][node], rect[cx][q]);
return;
} else if (l > id[q] || r < id[q]) {
return;
} else {
update(cx, cy, 2 * node, l, (l + r) / 2, q);
update(cx, cy, 2 * node + 1, (l + r) / 2 + 1, r, q);
tree[cx][cy][node] =
min(tree[cx][cy][2 * node], tree[cx][cy][2 * node + 1]);
}
}
int query(int cx, int cy, int node, int l, int r, int ql, int qr) {
if (l > qr || r < ql) {
return 1000000007;
} else if (ql <= l && r <= qr) {
return tree[cx][cy][node];
} else {
return min(query(cx, cy, 2 * node, l, (l + r) / 2, ql, qr),
query(cx, cy, 2 * node + 1, (l + r) / 2 + 1, r, ql, qr));
}
}
int solve(int s, int t) {
for (int i = 0; i < 21; i++) {
if (((1 << i + 1)) >= t) {
int c = rect[i][s];
int g = level[s] + t - (1 << i);
int e = lvlcounter[g] + 1;
int f = 0;
int lbound = 1;
int hbound = lvlcounter[g];
int avg;
if (lvlcounter[g] > 0) {
do {
avg = (lbound + hbound) / 2;
if (v[level2[g][avg - 1]] >= v[s]) {
e = hbound = avg;
} else {
lbound = avg + 1;
}
} while (lbound < hbound);
while (e > 1 && v[level2[g][e - 2]] >= v[s]) {
--e;
}
lbound = 1;
hbound = lvlcounter[g];
do {
avg = (lbound + hbound) / 2;
if (u[level2[g][avg - 1]] > u[s]) {
hbound = avg;
} else {
f = avg;
lbound = avg + 1;
}
} while (lbound < hbound);
while (f < level2[g].size() && u[level2[g][f]] <= u[s]) {
++f;
}
c = min(c, query(i, g, 1, 1, lvlcounter[g], e, f));
}
return c;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N >> R;
for (int i = 1; i <= N; i++) {
cin >> a[i];
v[i] = 1000000007;
}
for (int i = 0; i < N - 1; i++) {
cin >> x >> y;
conn[x].push_back(y);
conn[y].push_back(x);
}
dfs(R, 0, 1);
for (int i = 1; i < 21; i++) {
for (int j = 1; j <= N; j++) {
parent[i][j] = parent[i - 1][parent[i - 1][j]];
rect[i][j] = 1000000007;
}
}
for (int i = 1; i < 21; i++) {
for (int j = 1; j <= N; j++) {
rect[i][j] = min(rect[i][j], rect[i - 1][j]);
rect[i][parent[i - 1][j]] =
min(rect[i][parent[i - 1][j]], rect[i - 1][j]);
}
}
for (int i = 0; i < 21; i++) {
for (int j = 1; j <= N; j++) {
for (int k = 0; k < 4; k++) {
tree[i][level[j]].push_back(1000000007);
}
}
}
for (int i = 0; i < 21; i++) {
for (int j = 1; j <= N; j++) {
update(i, level[j], 1, 1, lvlcounter[level[j]], j);
}
}
cin >> M;
for (int i = 0; i < M; i++) {
cin >> p >> q;
x = (p + ans) % N + 1;
k = (q + ans) % N;
ans = solve(x, k + 1);
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int M = 30 * N;
struct E {
int to, next;
} mem[N << 1];
int n, num, x, y, root, tot, k, ans, inf, T;
int rt[N], in[N], ot[N], head[N], a[N], dep[N], cnt[M], mn[M], ls[M], rs[M];
vector<int> lev[N];
void add(int x, int y) {
num++;
mem[num].to = y;
mem[num].next = head[x];
head[x] = num;
}
void dfs(int k, int pre) {
int u, j;
in[k] = ++tot;
for (j = head[k]; j; j = mem[j].next) {
u = mem[j].to;
if (u == pre) continue;
dep[u] = dep[k] + 1;
dfs(u, k);
}
ot[k] = tot;
}
int insert(int last, int l, int r, int p, int w) {
int now = ++tot;
if (l == r) {
mn[now] = w;
cnt[now] = cnt[last] + 1;
return now;
}
int mid = (l + r) >> 1;
ls[now] = ls[last];
rs[now] = rs[last];
if (p <= mid)
ls[now] = insert(ls[last], l, mid, p, w);
else
rs[now] = insert(rs[last], mid + 1, r, p, w);
mn[now] = min(mn[ls[now]], mn[rs[now]]);
cnt[now] = cnt[ls[now]] + cnt[rs[now]];
return now;
}
int query(int x, int y, int l, int r, int L, int R) {
if (!(cnt[y] - cnt[x])) return inf;
if (L <= l && r <= R) return mn[y];
int mid = (l + r) >> 1;
if (R <= mid)
return query(ls[x], ls[y], l, mid, L, R);
else if (L > mid)
return query(rs[x], rs[y], mid + 1, r, L, R);
else
return min(query(ls[x], ls[y], l, mid, L, R),
query(rs[x], rs[y], mid + 1, r, L, R));
}
int main() {
int i, j;
memset(mn, 0x3f, sizeof(mn));
inf = mn[0];
scanf("%d%d", &n, &root);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
dep[root] = 1;
dfs(root, 0);
tot = 0;
for (i = 1; i <= n; i++) lev[dep[i]].push_back(i);
for (i = 1; i <= n; i++) {
rt[i] = rt[i - 1];
for (j = 0; j < lev[i].size(); j++) {
x = lev[i][j];
rt[i] = insert(rt[i], 1, n, in[x], a[x]);
}
}
scanf("%d", &T);
while (T--) {
scanf("%d%d", &x, &k);
x = (x + ans) % n + 1;
k = (k + ans) % n;
ans = query(rt[dep[x] - 1], rt[min(dep[x] + k, n)], 1, n, in[x], ot[x]);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
inline int read() {
int x(0), w(1);
char c = getchar();
while (c ^ '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') w = -1, c = getchar();
while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0', c = getchar();
return x * w;
}
int n, M, las, x, y, cnt, R, a[N], rt[N], dep[N], ls[N << 6], rs[N << 6],
v[N << 6];
int head[N], nxt[N << 1], to[N << 1], cnte;
inline void add(int u, int v) {
to[++cnte] = v;
nxt[cnte] = head[u];
head[u] = cnte;
}
void debug(int u) {
if (!u) return;
printf("u=%d v=%d ls=%d rs=%d\n", u, v[u], ls[u], rs[u]);
debug(ls[u]);
debug(rs[u]);
}
inline void pushup(int u) { v[u] = min(v[ls[u]], v[rs[u]]); }
int merge(int a, int b, int l, int r) {
if (!a || !b) return a | b;
int u = ++cnt;
if (l == r) {
v[u] = min(v[a], v[b]);
return u;
}
int mid = (l + r) >> 1;
ls[u] = merge(ls[a], ls[b], l, mid);
rs[u] = merge(rs[a], rs[b], mid + 1, r);
pushup(u);
return u;
}
int modify(int u, int l, int r, int x, int k) {
if (!u) u = ++cnt;
if (l == r) {
v[u] = k;
return u;
}
int mid = (l + r) >> 1;
if (x <= mid)
ls[u] = modify(ls[u], l, mid, x, k);
else
rs[u] = modify(rs[u], mid + 1, r, x, k);
pushup(u);
return u;
}
int query(int u, int l, int r, int x, int y) {
if (l > y || r < x) return 0x3f3f3f3f;
if (x <= l && r <= y) return v[u];
int mid = (l + r) >> 1;
return min(query(ls[u], l, mid, x, y), query(rs[u], mid + 1, r, x, y));
}
void dfs(int u, int Fa) {
rt[u] = modify(rt[u], 1, n, dep[u], a[u]);
for (int i = head[u]; i; i = nxt[i]) {
if (to[i] == Fa) continue;
dep[to[i]] = dep[u] + 1;
dfs(to[i], u);
rt[u] = merge(rt[u], rt[to[i]], 1, n);
}
}
int main() {
memset(v, 0x3f3f3f3f, sizeof(v));
n = read(), R = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i < n; ++i) {
x = read(), y = read();
add(x, y);
add(y, x);
}
for (int i = 1; i <= n; ++i) rt[i] = ++cnt;
dep[R] = 1;
dfs(R, -1);
M = read();
while (M--) {
x = read(), y = read();
x = (x + las) % n + 1;
y = (y + las) % n;
las = query(rt[x], 1, n, dep[x], dep[x] + y);
printf("%d\n", las);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int cnt = 0, f = 1;
char ch = 0;
while (!isdigit(ch)) {
ch = getchar();
if (ch == '-') f = -1;
}
while (isdigit(ch))
cnt = (cnt << 3) + (cnt << 1) + (ch - '0'), ch = getchar();
return cnt * f;
}
const int inf = 0x3fffffff;
vector<int> v[200050];
int mx;
int first[200050], nxt[200050], to[200050], tot;
void add(int x, int y) { nxt[++tot] = first[x], first[x] = tot, to[tot] = y; }
int n, root, m, a[200050], rt[200050], cnt, lastans;
int dep[200050], st[200050], ed[200050], sign;
struct Node {
int ls, rs, val;
} t[200050 * 30];
void Build(int &x, int l, int r) {
x = ++cnt;
t[x].val = inf;
if (l == r) return;
int mid = (l + r) >> 1;
Build(t[x].ls, l, mid);
Build(t[x].rs, mid + 1, r);
}
void Insert(int &x, int last, int l, int r, int pos, int val) {
x = ++cnt;
t[x] = t[last];
t[x].val = min(t[x].val, val);
if (l == r) return;
int mid = (l + r) >> 1;
if (pos <= mid)
Insert(t[x].ls, t[last].ls, l, mid, pos, val);
else
Insert(t[x].rs, t[last].rs, mid + 1, r, pos, val);
}
int Quary(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) return t[x].val;
int mid = (l + r) >> 1, ans = inf;
if (L <= mid) ans = min(ans, Quary(t[x].ls, l, mid, L, R));
if (R > mid) ans = min(ans, Quary(t[x].rs, mid + 1, r, L, R));
return ans;
}
void dfs(int u, int fa) {
st[u] = ++sign;
v[dep[u]].push_back(u);
mx = max(mx, dep[u]);
for (int i = first[u]; i; i = nxt[i]) {
int t = to[i];
if (t == fa) continue;
dep[t] = dep[u] + 1;
dfs(t, u);
}
ed[u] = sign;
}
int main() {
n = read(), root = read();
Build(rt[0], 1, n);
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i < n; i++) {
int x = read(), y = read();
add(x, y);
add(y, x);
}
dep[root] = 1;
dfs(root, 0);
for (int i = 1; i <= mx; i++) {
rt[i] = rt[i - 1];
for (int j = 0; j < v[i].size(); j++) {
Insert(rt[i], rt[i], 1, n, st[v[i][j]], a[v[i][j]]);
}
}
m = read();
while (m--) {
int u = (read() + lastans) % n + 1, k = (read() + lastans) % n;
lastans = Quary(rt[min(mx, dep[u] + k)], 1, n, st[u], ed[u]);
printf("%d\n", lastans);
}
return 0;
}
|
#include <bits/stdc++.h>
int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
using namespace std;
class pa3 {
public:
int x;
int y, z;
pa3(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
int x;
int y, z, w;
pa4(int x = 0, int y = 0, int z = 0, int w = 0) : x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
int x, y;
pa2(int x = 0, int y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(x * a, y * a); }
Point operator/(double a) { return Point(x / a, y / a); }
double absv() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p) const {
return fabs(x - p.x) < (1e-10) && fabs(y - p.y) < (1e-10);
}
};
struct Segment {
Point p1, p2;
};
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
bool parareru(Point a, Point b, Point c, Point d) {
return abs(cross(a - b, d - c)) < (1e-10);
}
double distance_ls_p(Point a, Point b, Point c) {
if (dot(b - a, c - a) < (1e-10)) return (c - a).absv();
if (dot(a - b, c - b) < (1e-10)) return (c - b).absv();
return abs(cross(b - a, c - a)) / (b - a).absv();
}
bool is_intersected_ls(Segment a, Segment b) {
if (a.p1 == b.p1 || a.p2 == b.p1 || a.p1 == b.p2 || a.p2 == b.p2)
return false;
if (parareru((a.p2), (a.p1), (a.p1), (b.p2)) &&
parareru((a.p2), (a.p1), (a.p1), (b.p1))) {
if (dot(a.p1 - b.p1, a.p1 - b.p2) < (1e-10)) return true;
if (dot(a.p2 - b.p1, a.p2 - b.p2) < (1e-10)) return true;
if (dot(a.p1 - b.p1, a.p2 - b.p1) < (1e-10)) return true;
if (dot(a.p1 - b.p2, a.p2 - b.p2) < (1e-10)) return true;
return false;
} else
return (cross(a.p2 - a.p1, b.p1 - a.p1) * cross(a.p2 - a.p1, b.p2 - a.p1) <
(1e-10)) &&
(cross(b.p2 - b.p1, a.p1 - b.p1) * cross(b.p2 - b.p1, a.p2 - b.p1) <
(1e-10));
}
double segment_dis(Segment a, Segment b) {
if (is_intersected_ls(a, b)) return 0;
double r = distance_ls_p(a.p1, a.p2, b.p1);
r = min(r, distance_ls_p(a.p1, a.p2, b.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p1));
return r;
}
Point intersection_ls(Segment a, Segment b) {
Point ba = b.p2 - b.p1;
double d1 = abs(cross(ba, a.p1 - b.p1));
double d2 = abs(cross(ba, a.p2 - b.p1));
double t = d1 / (d1 + d2);
return a.p1 + (a.p2 - a.p1) * t;
}
string itos(int i) {
ostringstream s;
s << i;
return s.str();
}
int gcd(int v, int b) {
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
double distans(double x1, double y1, double x2, double y2) {
double rr = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
return sqrt(rr);
}
int mod;
int extgcd(int a, int b, int &x, int &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
int d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
pair<int, int> operator+(const pair<int, int> &l, const pair<int, int> &r) {
return {l.first + r.first, l.second + r.second};
}
int pr[1200010];
int inv[1200010];
int beki(int wa, int rr, int warukazu) {
if (rr == 0) return 1 % warukazu;
if (rr == 1) return wa % warukazu;
wa %= warukazu;
if (rr % 2 == 1)
return ((long long)beki(wa, rr - 1, warukazu) * (long long)wa) % warukazu;
long long zx = beki(wa, rr / 2, warukazu);
return (zx * zx) % warukazu;
}
double bekid(double w, int r) {
if (r == 0) return 1.0;
if (r == 1) return w;
if (r % 2) return bekid(w, r - 1) * w;
double f = bekid(w, r / 2);
return f * f;
}
int comb(int nn, int rr) {
int r = pr[nn] * inv[rr];
r %= mod;
r *= inv[nn - rr];
r %= mod;
return r;
}
void gya(int ert) {
pr[0] = 1;
for (int i = 1; i <= ert; i++) {
pr[i] = (pr[i - 1] * i) % mod;
}
for (int i = 0; i <= ert; i++) inv[i] = beki(pr[i], mod - 2, mod);
}
int MAX = 1000000007 * 2;
struct segmin {
private:
public:
int cor;
vector<int> vec;
void shoki1(int siz) {
cor = 1;
while (cor <= siz) cor *= 2;
vec.resize(2 * cor + 3, MAX);
}
void shoki2() {
for (int i = cor - 1; i > 0; i--) {
vec[i] = min(vec[2 * i], vec[2 * i + 1]);
}
}
void updadd(int x, int w) {
x += cor;
vec[x] += w;
while (1) {
x /= 2;
if (x == 0) break;
vec[x] = min(vec[2 * x], vec[2 * x + 1]);
}
}
void updchan(int x, int w) {
x += cor;
vec[x] = w;
while (1) {
x /= 2;
if (x == 0) break;
vec[x] = min(vec[2 * x], vec[2 * x + 1]);
}
}
int rangemin(int a, int b, int k = 1, int l = 0, int r = -10) {
if (r < 0) r = cor;
if (a <= l && r <= b) {
return vec[k];
}
if (r <= a || b <= l) {
return MAX;
}
int v1 = rangemin(a, b, k * 2, l, (l + r) / 2),
v2 = rangemin(a, b, k * 2 + 1, (l + r) / 2, r);
return min(v1, v2);
}
};
struct segmin2D {
private:
public:
int corx = 1;
int cory = 1;
vector<segmin> seg;
vector<vector<int>> index;
void shoki1(int sizx, int sizy) {
while (sizx >= corx) corx *= 2;
while (sizy >= cory) cory *= 2;
seg.resize(2 * corx + 3);
index.resize(2 * corx + 3);
}
void pre(int x, int y, int k = 1, int l = 0, int r = -1) {
if (r < 0) r = corx;
index[k].push_back(y);
if (r - l == 1) return;
int med = (l + r) / 2;
if (x < med)
pre(x, y, 2 * k, l, med);
else
pre(x, y, 2 * k + 1, med, r);
}
void precomp(int x, int y) { pre(x, y); }
void shoki2() {
for (int i = 1; i < 2 * corx; i++) {
sort(index[i].begin(), index[i].end());
index[i].erase(unique(index[i].begin(), index[i].end()), index[i].end());
seg[i].shoki1((int)index[i].size());
}
}
void pre2(int x, int y, int val, int k = 1, int l = 0, int r = -1) {
if (r < 0) r = corx;
int it =
lower_bound(index[k].begin(), index[k].end(), y) - index[k].begin();
seg[k].vec[it + seg[k].cor] = min(val, seg[k].vec[it + seg[k].cor]);
if (r - l == 1) return;
int med = (l + r) / 2;
if (x < med)
pre2(x, y, val, 2 * k, l, med);
else
pre2(x, y, val, 2 * k + 1, med, r);
}
void precomp2(int x, int y, int val) { pre2(x, y, val); }
void shoki3() {
for (int i = 1; i < corx; i++) {
seg[i].shoki2();
}
}
int rangemin(int x1, int x2, int y1, int y2, int k = 1, int l = 0,
int r = -1) {
if (r < 0) r = corx;
if (x1 <= l && r <= x2) {
int id1 =
lower_bound(index[k].begin(), index[k].end(), y1) - index[k].begin();
int id2 =
lower_bound(index[k].begin(), index[k].end(), y2) - index[k].begin();
return seg[k].rangemin(id1, id2);
}
if (r <= x1 || x2 <= l) {
return MAX;
}
int v1 = rangemin(x1, x2, y1, y2, 2 * k, l, (l + r) / 2);
int v2 = rangemin(x1, x2, y1, y2, 2 * k + 1, (l + r) / 2, r);
return min(v1, v2);
}
};
segmin2D ss;
struct query {
int type;
int x1;
int x2;
int y1;
int y2;
int val;
};
vector<int> G[100020], G2[100020];
int a[100020];
int dep[100020];
void dfs1(int r, int p, int d = 0) {
dep[r] = d;
for (auto v : G[r])
if (v != p) {
G2[r].push_back(v);
dfs1(v, r, d + 1);
}
}
vector<int> oi;
int kukan[100020][2];
void dfs2(int r) {
kukan[r][0] = oi.size();
oi.push_back(r);
for (auto v : G2[r]) dfs2(v);
kukan[r][1] = oi.size();
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, r;
cin >> n >> r;
ss.shoki1(100020, 100020);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
int y, yy;
cin >> y >> yy;
G[y].push_back(yy);
G[yy].push_back(y);
}
dfs1(r, r);
dfs2(r);
for (int i = 1; i <= n; i++) {
ss.precomp(kukan[i][0], dep[i]);
}
ss.shoki2();
for (int i = 1; i <= n; i++) {
ss.precomp2(kukan[i][0], dep[i], a[i]);
}
ss.shoki3();
int qu;
cin >> qu;
int las = 0;
for (int i = 1; i <= qu; i++) {
int p, q;
cin >> p >> q;
int x = (p + las) % n + 1;
int k = (q + las) % n;
int ans = ss.rangemin(kukan[x][0], kukan[x][1], dep[x], dep[x] + k + 1);
cout << ans << "\n";
las = ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void proc_status() {
ifstream t("/proc/self/status");
cerr << string(istreambuf_iterator<char>(t), istreambuf_iterator<char>())
<< endl;
}
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline T read() {
register T sum(0), fg(1);
register char ch(getchar());
for (; !isdigit(ch); ch = getchar())
if (ch == '-') fg = -1;
for (; isdigit(ch); ch = getchar()) sum = sum * 10 - '0' + ch;
return sum * fg;
}
const int MAXN = (int)1e5;
int n, r;
int A[MAXN + 5];
vector<int> adj[MAXN + 5];
inline void input() {
n = read<int>(), r = read<int>();
for (int i = 1; i <= n; ++i) A[i] = read<int>();
for (int i = 1; i < n; ++i) {
int u = read<int>(), v = read<int>();
adj[u].push_back(v);
adj[v].push_back(u);
}
}
int dfn[MAXN + 5], ed[MAXN + 5], dfn_cur = 0, dep[MAXN + 5];
vector<int> dep_set[MAXN + 5];
inline void dfs(int u, int fa) {
dep_set[dep[u] = dep[fa] + 1].push_back(u);
dfn[u] = ++dfn_cur;
for (auto v : adj[u])
if (v != fa) dfs(v, u);
ed[u] = dfn_cur;
}
namespace SEGT {
const int MAX_NODE = 30 * MAXN;
int lc[MAX_NODE + 5], rc[MAX_NODE + 5], cnt = 0;
int mn[MAX_NODE + 5];
inline int update(int u, int l, int r, int pos, int val) {
int v = ++cnt;
mn[v] = u ? min(mn[u], val) : val;
lc[v] = lc[u], rc[v] = rc[u];
if (l == r) return v;
int mid = (l + r) >> 1;
if (pos <= mid)
lc[v] = update(lc[u], l, mid, pos, val);
else
rc[v] = update(rc[u], mid + 1, r, pos, val);
return v;
}
inline int query(int u, int l, int r, int ql, int qr) {
if (!u) return INT_MAX;
if (ql <= l && r <= qr) return mn[u];
int mid = (l + r) >> 1, res = INT_MAX;
if (ql <= mid) chkmin(res, query(lc[u], l, mid, ql, qr));
if (mid < qr) chkmin(res, query(rc[u], mid + 1, r, ql, qr));
return res;
}
} // namespace SEGT
inline void solve() {
dfs(r, 0);
static int pos[MAXN + 5], cnt = 0;
static int root[MAXN + 5];
for (int i = 1; i <= n; ++i) {
for (auto u : dep_set[i])
++cnt, root[cnt] = SEGT::update(root[cnt - 1], 1, n, dfn[u], A[u]);
pos[i] = cnt;
}
for (int m = read<int>(), lastans = 0; m--;) {
int u = (read<int>() + lastans) % n + 1;
int k = (read<int>() + lastans) % n;
printf("%d\n", lastans = SEGT::query(root[pos[min(dep[u] + k, n)]], 1, n,
dfn[u], ed[u]));
}
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int value[N];
vector<int> g[N];
int lvl[N];
vector<pair<int, int>> nodes;
int L[N], R[N];
void dfs(int node, int par) {
lvl[node] = lvl[par] + 1;
L[node] = nodes.size();
nodes.emplace_back(lvl[node], value[node]);
for (auto u : g[node])
if (u != par) dfs(u, node);
R[node] = nodes.size() - 1;
}
vector<pair<int, int>> tree[N << 2];
void build(int i, int l, int r) {
if (l == r) return void(tree[i].emplace_back(nodes[l]));
int mid = l + r >> 1;
build(i << 1, l, mid);
build(i << 1 | 1, mid + 1, r);
merge(tree[i << 1].begin(), tree[i << 1].end(), tree[i << 1 | 1].begin(),
tree[i << 1 | 1].end(), back_inserter(tree[i]));
for (int j = 1; j < tree[i].size(); j++)
tree[i][j].second = min(tree[i][j].second, tree[i][j - 1].second);
}
int get(int i, int l, int r, int a, int b, int max_depth) {
if (l > b || r < a) return 2e9;
if (l >= a && r <= b) {
auto it = upper_bound(tree[i].begin(), tree[i].end(),
make_pair(max_depth, (int)2e9));
if (it == tree[i].begin()) return 2e9;
--it;
return it->second;
}
int mid = l + r >> 1;
return min(get(i << 1, l, mid, a, b, max_depth),
get(i << 1 | 1, mid + 1, r, a, b, max_depth));
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, root;
cin >> n >> root;
for (int i = 1; i <= n; i++) cin >> value[i];
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(root, root);
build(1, 0, n - 1);
int m;
cin >> m;
int last = 0;
while (m--) {
int p, q;
cin >> p >> q;
int x, k;
x = (p + last) % n + 1;
k = (q + last) % n;
cout << (last = get(1, 0, n - 1, L[x], R[x], lvl[x] + k)) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct pst {
struct node {
int v;
node *l, *r;
node() : node(0x3f3f3f3f) {}
node(int v) : v(v), l(nullptr), r(nullptr) {}
};
int n;
vector<node *> root;
deque<node> buffer;
pst(int n) : n(n) { root.push_back(build(0, n - 1)); }
node *build(int l, int r) {
node *cur = new_node();
if (l != r) {
int m = (l + r) / 2;
cur->l = build(l, m);
cur->r = build(m + 1, r);
}
return cur;
}
void copy(int pt, int t) {
if ((int)(root.size()) <= t) {
root.resize(t + 1);
}
root[t] = new_node(*root[pt]);
}
void upd(int pt, int t, int x, int v) {
if ((int)(root.size()) <= t) {
root.resize(t + 1);
}
root[t] = upd(root[pt], x, v, 0, n - 1);
}
node *upd(node *p, int x, int v, int l, int r) {
node *cur = new_node(*p);
if (l == r) {
cur->v = v;
} else {
int m = (l + r) / 2;
if (x <= m) {
cur->l = upd(cur->l, x, v, l, m);
} else {
cur->r = upd(cur->r, x, v, m + 1, r);
}
cur->v = min(cur->l->v, cur->r->v);
}
return cur;
}
int qry(int t, int x, int y) { return qry(root[t], x, y, 0, n - 1); }
int qry(node *p, int x, int y, int l, int r) {
if (y < l || x > r) {
return 0x3f3f3f3f;
} else if (x <= l && r <= y) {
return p->v;
} else {
int m = (l + r) / 2;
return min(qry(p->l, x, y, l, m), qry(p->r, x, y, m + 1, r));
}
}
template <typename... Args>
node *new_node(Args... args) {
buffer.emplace_back(args...);
return &buffer.back();
}
};
int n, r, m;
int nums[100010];
vector<int> adj[100010];
int p[1000010];
int q[1000010];
int depth[100010];
vector<int> at_depth[100010];
int t = -1;
int in[100010];
int out[100010];
void dfs(int v, int p, int d) {
in[v] = ++t;
depth[v] = d;
at_depth[d].push_back(v);
for (int e : adj[v]) {
if (e != p) {
dfs(e, v, d + 1);
}
}
out[v] = t;
}
int main() {
cin.tie(0)->sync_with_stdio(0);
int n, r;
cin >> n >> r;
r--;
for (int i = 0; i < n; i++) {
cin >> nums[i];
}
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
adj[a].push_back(b);
adj[b].push_back(a);
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> p[i] >> q[i];
}
pst st(n);
dfs(r, -1, 1);
for (int i = 1; i <= n; i++) {
st.copy(i - 1, i);
for (int v : at_depth[i]) {
st.upd(i, i, in[v], nums[v]);
}
}
int last = 0;
for (int i = 0; i < m; i++) {
int v = (last + p[i]) % n;
int k = (last + q[i]) % n;
int lowest = min(depth[v] + k, n);
last = st.qry(lowest, in[v], out[v]);
cout << last << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int w = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
w = (w << 3) + (w << 1) + ch - 48;
ch = getchar();
}
return w * f;
}
int n, m, tot, root[500010], r, a[500010], maxx;
bool debug;
struct DSU_ON_TREE {
struct Node {
int ch[2], val;
} st[100000 * 64];
inline void pushup(int x) {
st[x].val = min(st[st[x].ch[0]].val, st[st[x].ch[1]].val);
}
inline int change(int p, int l, int r, int pos, int val) {
if (!p) p = ++tot;
st[p].val = 0x3f3f3f3f;
if (l == r) {
st[p].val = min(st[p].val, val);
return p;
}
int mid = (l + r) >> 1;
if (pos <= mid)
st[p].ch[0] = change(st[p].ch[0], l, mid, pos, val);
else
st[p].ch[1] = change(st[p].ch[1], mid + 1, r, pos, val);
pushup(p);
return p;
}
inline int merge(int x, int y, int l, int r) {
if (!x || !y) return x | y;
int p = ++tot;
int mid = (l + r) >> 1;
if (l == r) {
st[p].val = min(st[x].val, st[y].val);
return p;
}
st[p].ch[0] = merge(st[x].ch[0], st[y].ch[0], l, mid);
st[p].ch[1] = merge(st[x].ch[1], st[y].ch[1], mid + 1, r);
pushup(p);
return p;
}
inline int query(int p, int L, int R, int l, int r) {
if (!p) return 0x3f3f3f3f;
if (L <= l && R >= r) {
return st[p].val;
}
int mid = (l + r) >> 1;
int now = 0x3f3f3f3f;
if (L <= mid) now = min(now, query(st[p].ch[0], L, R, l, mid));
if (R > mid) now = min(now, query(st[p].ch[1], L, R, mid + 1, r));
return now;
}
} DSU;
int cnt, head[500010];
struct Edge {
int from, to, next;
} edge[500010];
inline void addedge(int u, int v) {
cnt++;
edge[cnt].from = u;
edge[cnt].to = v;
edge[cnt].next = head[u];
head[u] = cnt;
}
int now[500010], b[500010];
int depth[500010], size[500010];
inline void dfs(int u, int fa) {
depth[u] = depth[fa] + 1;
root[u] = DSU.change(root[u], 1, maxx, depth[u], now[u]);
for (int i = head[u]; i; i = edge[i].next) {
int v = edge[i].to;
if (v == fa) continue;
dfs(v, u);
root[u] = DSU.merge(root[u], root[v], 1, maxx);
}
}
int main() {
DSU.st[0].val = 0x3f3f3f3f;
n = read();
r = read();
maxx = n;
for (int i = 1; i <= n; i++) {
now[i] = read();
}
for (int i = 1; i < n; i++) {
int x = read();
int y = read();
addedge(x, y);
addedge(y, x);
}
dfs(r, 0);
m = read();
int lst = 0;
while (m--) {
int p = read();
int q = read();
p = (p + lst) % n + 1;
q = (q + lst) % n;
int ans = DSU.query(root[p], depth[p], depth[p] + q, 1, maxx);
printf("%d\n", ans);
lst = ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int blSize;
int n, ans, t, ordIdx, m;
vector<vector<int> > gr;
int root, postOrder[100010], a[100010], inTime[100010], outTime[100010],
pos[100010], depth[100010];
int minBlock[100010][350];
void dfs(int x, int par) {
inTime[x] = t;
++t;
for (auto i : gr[x]) {
if (i == par) {
continue;
}
depth[i] = depth[x] + 1;
dfs(i, x);
}
pos[x] = ordIdx;
postOrder[ordIdx] = x;
++ordIdx;
outTime[x] = t;
++t;
}
bool isDescendant(int x, int d) {
return inTime[x] <= inTime[d] and outTime[x] >= outTime[d];
}
void buildMin() {
for (int i = 0; i * blSize < n; ++i) {
int l = i * blSize;
int r = min(l + blSize, n);
for (int j = 0; j < n; ++j) {
minBlock[j][i] = 2e9;
}
for (int j = l; j < r; ++j) {
minBlock[depth[postOrder[j]]][i] =
min(minBlock[depth[postOrder[j]]][i], a[postOrder[j]]);
}
for (int j = 1; j < n; ++j) {
minBlock[j][i] = min(minBlock[j][i], minBlock[j - 1][i]);
}
}
}
void getAns(int l, int r, int lowestPoint) {
ans = 2e9;
lowestPoint = min(n - 1, lowestPoint);
for (; l <= r and l % blSize; ++l) {
if (depth[postOrder[l]] > lowestPoint) {
continue;
}
ans = min(ans, a[postOrder[l]]);
}
for (; l / blSize < r / blSize; l += blSize) {
ans = min(ans, minBlock[lowestPoint][l / blSize]);
}
for (; l <= r; ++l) {
if (depth[postOrder[l]] > lowestPoint) {
continue;
}
ans = min(ans, a[postOrder[l]]);
}
}
int beforeDescendant(int x) {
int l = 0, r = pos[x];
int res = r;
while (l <= r) {
int mid = (l + r) / 2;
if (isDescendant(x, postOrder[mid])) {
res = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cout.tie(0);
cin.tie(0);
cin >> n >> root;
gr.resize(n, vector<int>());
blSize = sqrt(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
--x;
--y;
gr[x].push_back(y);
gr[y].push_back(x);
}
dfs(root - 1, -1);
buildMin();
cin >> m;
for (int i = 0; i < m; ++i) {
int x, y;
cin >> x >> y;
x = (x + ans) % n + 1;
y = (y + ans) % n;
--x;
if (x < 0) {
return 0;
}
getAns(beforeDescendant(x), pos[x], y + depth[x]);
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
int n, root, p[100010], val[100010];
struct edge {
int to;
edge *next;
} e[200010], *et = e, *last[100010];
void add(int u, int v) {
*++et = (edge){v, last[u]}, last[u] = et;
*++et = (edge){u, last[v]}, last[v] = et;
}
int dfn[100010], ck, dep[100010], end[100010];
void dfs(int u, int fa) {
dfn[u] = ++ck;
dep[u] = dep[fa] + 1;
for (edge *it = last[u]; it; it = it->next)
if (fa != it->to) {
dfs(it->to, u);
}
end[u] = ck;
}
bool comp(const int &i, const int &j) {
return dep[i] < dep[j] || (dep[i] == dep[j] && dfn[i] < dfn[j]);
}
struct node {
int min;
node *ls, *rs;
} t[5000010], *tt = t, *rt[100010];
void build(node *&rt, int l, int r) {
rt = ++tt;
if (l == r) {
rt->min = 1e9;
return;
}
int mid = l + r >> 1;
build(rt->ls, l, mid);
build(rt->rs, mid + 1, r);
rt->min = std::min(rt->ls->min, rt->rs->min);
}
void modify(node *la, node *&rt, int l, int r, int pos, int x) {
rt = ++tt;
*rt = *la;
if (r < pos || pos < l) return;
if (l == r) {
rt->min = x;
return;
}
int mid = l + r >> 1;
modify(la->ls, rt->ls, l, mid, pos, x);
modify(la->rs, rt->rs, mid + 1, r, pos, x);
rt->min = std::min(rt->ls->min, rt->rs->min);
}
int query(node *rt, int l, int r, int L, int R) {
if (L <= l && r <= R) return rt->min;
if (r < L || R < l) return 1e9;
int mid = l + r >> 1;
return std::min(query(rt->ls, l, mid, L, R), query(rt->rs, mid + 1, r, L, R));
}
int fin[100010];
int main() {
scanf("%d%d", &n, &root);
for (int i = 1; i <= n; i++) scanf("%d", val + i), p[i] = i;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
}
dfs(root, 0);
std::sort(p + 1, p + n + 1, comp);
int m;
build(rt[0], 1, n);
int maxd = 0;
for (int i = 1; i <= n; i++) {
fin[dep[p[i]]] = i;
maxd = dep[p[i]];
modify(rt[i - 1], rt[i], 1, n, dfn[p[i]], val[p[i]]);
}
scanf("%d", &m);
int ans = 0;
while (m--) {
int x, k;
scanf("%d%d", &x, &k);
x = (x + ans) % n + 1;
k = (k + ans) % n;
int d = std::min(k + dep[x], maxd);
ans = query(rt[fin[d]], 1, n, dfn[x], end[x]);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3fLL;
const int maxn = 1e5 + 10;
const int maxm = 6.4e6 + 10;
const int mod = 1e9 + 7;
struct edge {
int to, n;
} e[maxn << 1];
int head[maxn], tot;
inline void add(int x, int y) {
e[++tot].to = y;
e[tot].n = head[x];
head[x] = tot;
}
int a[maxn], L[maxm], R[maxm], f[maxm], id[maxn], cnt, dep[maxn], ed[maxn];
int n;
inline void ins(int &i, int o, int l, int r, int k, int num) {
i = ++cnt;
f[i] = min(f[o], num);
if (l == r) return;
int m = (l + r) >> 1;
if (k <= m)
R[i] = R[o], ins(L[i], L[o], l, m, k, num);
else
L[i] = L[o], ins(R[i], R[o], m + 1, r, k, num);
}
inline int merg(int x, int y, int l, int r) {
if (!x || !y) return x + y;
int id = ++cnt;
f[id] = min(f[x], f[y]);
int m = (l + r) >> 1;
if (l < r) {
L[id] = merg(L[x], L[y], l, m);
R[id] = merg(R[x], R[y], m + 1, r);
}
return id;
}
inline void dfs(int u, int fa) {
ed[u] = dep[u] = dep[fa] + 1;
for (int i = head[u]; i; i = e[i].n) {
int v = e[i].to;
if (v == fa) continue;
dfs(v, u);
ed[u] = max(ed[u], ed[v]);
if (!id[u])
ins(id[u], id[v], 1, n, dep[u], a[u]);
else
id[u] = merg(id[u], id[v], 1, n);
}
if (!id[u]) ins(id[u], id[0], 1, n, dep[u], a[u]);
}
inline int query(int i, int l, int r, int s, int e) {
if (s <= l && r <= e) {
return f[i];
}
int m = (l + r) >> 1;
int ans = inf;
if (s <= m) ans = query(L[i], l, m, s, e);
if (e > m) ans = min(ans, query(R[i], m + 1, r, s, e));
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int m, k, x, y, ans = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
cin >> x >> y;
add(x, y);
add(y, x);
}
f[0] = inf;
dfs(m, 0);
cin >> m;
for (; m--;) {
cin >> x >> k;
x = (x + ans) % n + 1;
k = (k + ans) % n;
ans = query(id[x], 1, n, dep[x], min(dep[x] + k, ed[x]));
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rd(time(0));
vector<long long> v(100010), val(100010), con[100010], st(100010, 0),
en(100010, 0), d(100010, 0);
pair<long long, long long> t[20][100010];
long long cur = 0;
void dfs(long long node, long long par, long long dep) {
st[node] = ++cur;
d[st[node]] = dep;
for (auto i : con[node]) {
if (i != par) dfs(i, node, dep + 1);
}
en[node] = cur;
}
void build(long long c, long long l, long long r) {
if (l == r)
t[c][l] = {d[l], val[l]};
else {
long long mid = (l + r) / 2;
build(c + 1, l, mid);
build(c + 1, mid + 1, r);
long long i = l, j = mid + 1, k = l;
while (i <= mid && j <= r) {
if (t[c + 1][i].first < t[c + 1][j].first)
t[c][k++] = t[c + 1][i++];
else
t[c][k++] = t[c + 1][j++];
}
while (i <= mid) t[c][k++] = t[c + 1][i++];
while (j <= r) t[c][k++] = t[c + 1][j++];
for (i = l + 1; i <= r; i++)
t[c][i].second = min(t[c][i].second, t[c][i - 1].second);
}
}
long long query(long long c, long long l, long long r, long long l1,
long long r1, long long k) {
if (r1 < l || l1 > r) return 1000000007;
if (l >= l1 && r <= r1) {
pair<long long, long long> temp = {k, 1000000007};
long long w = upper_bound(t[c] + l, t[c] + r + 1, temp) - (t[c]);
if (w == l) return 1000000007;
return t[c][w - 1].second;
} else {
long long mid = (l + r) / 2;
return min(query(c + 1, l, mid, l1, r1, k),
query(c + 1, mid + 1, r, l1, r1, k));
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, r, m, l, x, k;
cin >> n >> r;
for (long long i = 1; i < n + 1; i++) cin >> v[i];
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
con[u].push_back(v);
con[v].push_back(u);
}
dfs(r, -1, 0);
for (long long i = 1; i <= n; i++) val[st[i]] = v[i];
build(1, 1, cur);
cin >> m;
l = 0;
while (m--) {
cin >> x >> k;
x = (x + l) % n + 1;
k = (k + l) % n;
l = query(1, 1, cur, st[x], en[x], k + d[st[x]]);
cout << l << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int arr = 2e5 + 10;
const int ar = 2e3 + 10;
const long double pi = acos(-1);
const long double eps = 1e-10;
const long long md = 1e9 + 7;
void assertion(bool ok) {
if (!ok) {
exit(!(cout << -1 << "\n"));
}
}
vector<vector<vector<vector<int>>>> table;
vector<int> posons[(int)(2e5 + 10)];
int tin[(int)(2e5 + 10)];
int tout[(int)(2e5 + 10)];
int timer;
int a[(int)(2e5 + 10)];
int max_deep;
vector<int> reb[(int)(2e5 + 10)];
int lg[(int)(2e5 + 10)];
int deep_global[(int)(2e5 + 10)];
void dfs(int now, int pred, int deep) {
deep_global[now] = deep;
max_deep = max(max_deep, deep);
tin[now] = ++timer;
posons[deep].push_back(now);
for (auto wh : reb[now]) {
if (wh != pred) {
dfs(wh, now, deep + 1);
}
}
tout[now] = timer;
}
int get_lol(int deep, int poson, int deep_want_to_know) {
if (deep > max_deep) {
return 2e9;
}
if (tin[posons[deep].front()] > tout[poson]) {
return 2e9;
}
if (tout[posons[deep].back()] < tin[poson]) {
return 2e9;
}
int l, r;
l = 0;
r = (int)(posons[deep].size()) - 1;
while (r - l > 0) {
int m = (l + r) / 2;
if (tout[posons[deep][m]] < tin[poson]) {
l = m + 1;
} else {
r = m;
}
}
int res1 = l;
l = 0;
r = (int)(posons[deep].size()) - 1;
while (r - l > 0) {
int m = (l + r + 1) / 2;
if (tin[posons[deep][m]] > tout[poson]) {
r = m - 1;
} else {
l = m;
}
}
int res2 = l;
if (res1 > res2) {
return 2e9;
}
int log2_ = lg[res2 - res1 + 1];
return min(table[deep][deep_want_to_know][res1][log2_],
table[deep][deep_want_to_know][res2 - (1ll << log2_) + 1][log2_]);
}
void build() {
table.resize(max_deep + 1);
for (int i = 0; i < (int)(table.size()); i++) {
table[i].resize(18);
for (int j = 0; j < (int)(table[i].size()); j++) {
table[i][j].resize((int)(posons[i].size()));
for (int k = 0; k < (int)(table[i][j].size()); k++) {
table[i][j][k].push_back(0);
while (k + (1ll << ((int)(table[i][j][k].size()) - 1)) - 1 <
(int)(table[i][j].size()) - 1) {
table[i][j][k].push_back(0);
}
}
}
}
for (int i = max_deep; i >= 0; i--) {
for (int k = 0; k < (int)(table[i][0].size()); k++) {
table[i][0][k][0] = a[posons[i][k]];
}
for (int j = 1; j < 18; j++) {
for (int k = 0; k < (int)(table[i][j].size()); k++) {
table[i][j][k][0] =
min(table[i][j - 1][k][0],
get_lol(i + (1ll << (j - 1)), posons[i][k], j - 1));
}
}
for (int j = 0; j < 18; j++) {
for (int l = 1; 0 + (1ll << l) - 1 < (int)(table[i][j].size()); l++) {
for (int k = 0; k + (1ll << l) - 1 < (int)(table[i][j].size()); k++) {
table[i][j][k][l] = min(table[i][j][k][l - 1],
table[i][j][k + (1ll << (l - 1))][l - 1]);
}
}
}
}
}
int get_lalka(int deep, int poson, int k) {
if (k <= 0) {
return 2e9;
}
if (deep > max_deep) {
return 2e9;
}
if (tin[posons[deep].front()] > tout[poson]) {
return 2e9;
}
if (tout[posons[deep].back()] < tin[poson]) {
return 2e9;
}
int l, r;
l = 0;
r = (int)(posons[deep].size()) - 1;
while (r - l > 0) {
int m = (l + r) / 2;
if (tout[posons[deep][m]] < tin[poson]) {
l = m + 1;
} else {
r = m;
}
}
int res1 = l;
l = 0;
r = (int)(posons[deep].size()) - 1;
while (r - l > 0) {
int m = (l + r + 1) / 2;
if (tin[posons[deep][m]] > tout[poson]) {
r = m - 1;
} else {
l = m;
}
}
int res2 = l;
if (res1 > res2) {
return 2e9;
}
int loog2_ = lg[k];
int log2_ = lg[res2 - res1 + 1];
return min({table[deep][loog2_][res1][log2_],
table[deep][loog2_][res2 - (1ll << log2_) + 1][log2_],
get_lalka(deep + (1ll << loog2_), poson, k - (1ll << loog2_))});
}
int get(int x, int k) {
k++;
return get_lalka(deep_global[x], x, k);
}
int main() {
for (int i = 2; i < (int)(2e5 + 10); i++) {
lg[i] = lg[i / 2] + 1;
}
int n, r;
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
reb[u].push_back(v);
reb[v].push_back(u);
}
dfs(r, -1, 0);
build();
int m;
scanf("%d", &m);
int last = 0;
int number_of_request = 0;
while (m--) {
number_of_request++;
int p, q;
scanf("%d%d", &p, &q);
int x = (p + last) % n + 1;
int k = (q + last) % n;
cout << (last = get(x, k)) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rd(time(0));
vector<long long> v(100010), val(100010), con[100010], st(100010, 0),
en(100010, 0), d(100010, 0);
pair<long long, long long> t[20][100010];
long long cur = 0;
void dfs(long long node, long long par, long long l) {
long long i;
st[node] = ++cur;
d[st[node]] = l;
for (i = 0; i < con[node].size(); ++i)
if (con[node][i] != par) dfs(con[node][i], node, l + 1);
en[node] = cur;
}
void build(long long c, long long l, long long r) {
if (l == r)
t[c][l] = {d[l], val[l]};
else {
long long mid = (l + r) / 2;
build(c + 1, l, mid);
build(c + 1, mid + 1, r);
long long i = l, j = mid + 1, k = l;
while (i <= mid && j <= r) {
if (t[c + 1][i].first < t[c + 1][j].first)
t[c][k++] = t[c + 1][i++];
else
t[c][k++] = t[c + 1][j++];
}
while (i <= mid) t[c][k++] = t[c + 1][i++];
while (j <= r) t[c][k++] = t[c + 1][j++];
for (i = l + 1; i <= r; ++i)
t[c][i].second = min(t[c][i].second, t[c][i - 1].second);
}
}
long long query(long long c, long long l, long long r, long long l1,
long long r1, long long k) {
if (r1 < l || l1 > r) return 1000000007;
if (l >= l1 && r <= r1) {
pair<long long, long long> temp = {k, 1000000007};
long long w = upper_bound(t[c] + l, t[c] + r + 1, temp) - t[c];
if (w == l) return 1000000007;
return t[c][w - 1].second;
} else {
long long mid = (l + r) / 2;
return min(query(c + 1, l, mid, l1, r1, k),
query(c + 1, mid + 1, r, l1, r1, k));
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, r, m, l, x, k;
cin >> n >> r;
for (long long i = 1; i < n + 1; i++) cin >> v[i];
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
con[u].push_back(v);
con[v].push_back(u);
}
dfs(r, -1, 0);
for (long long i = 1; i <= n; i++) val[st[i]] = v[i];
build(1, 1, cur);
cin >> m;
l = 0;
while (m--) {
cin >> x >> k;
x = (x + l) % n + 1;
k = (k + l) % n;
l = query(1, 1, cur, st[x], en[x], k + d[st[x]]);
cout << l << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 1e5;
const int INF = 0x3f3f3f3f;
using namespace std;
int rt[MAXN + 5];
struct SegmentTree {
struct Node {
int ls, rs, mn;
} s[MAXN * 50 + 5];
int tot;
SegmentTree() {}
void upd(int p) {
int lm = s[p].ls ? s[s[p].ls].mn : INF, rm = s[p].rs ? s[s[p].rs].mn : INF;
s[p].mn = min(lm, rm);
}
void insert(int &p, int l, int r, int u, int val) {
if (!p) p = ++tot;
if (l == r) {
s[p].mn = val;
return;
}
int mid = (l + r) >> 1;
if (u <= mid) {
insert(s[p].ls, l, mid, u, val);
} else {
insert(s[p].rs, mid + 1, r, u, val);
}
upd(p);
}
int query(int p, int l, int r, int x, int y) {
if (!p) return INF;
if (x <= l && y >= r) return s[p].mn;
int mid = (l + r) >> 1, ret = INF;
if (x <= mid) ret = query(s[p].ls, l, mid, x, y);
if (y > mid) ret = min(ret, query(s[p].rs, mid + 1, r, x, y));
return ret;
}
int merge(int x, int y) {
if (!x || !y) return x + y;
int p = ++tot;
s[p].mn = min(s[x].mn, s[y].mn);
s[p].ls = merge(s[x].ls, s[y].ls);
s[p].rs = merge(s[x].rs, s[y].rs);
return p;
}
} Sgt;
int n, a[MAXN + 5], depth[MAXN + 5], tree_rt;
namespace tree {
vector<int> adj[MAXN + 5];
void addEdge(int u, int v) { adj[u].push_back(v), adj[v].push_back(u); }
void dfs(int u, int fa) {
Sgt.insert(rt[u], 1, n, depth[u], a[u]);
for (int v : adj[u]) {
if (v == fa) continue;
depth[v] = depth[u] + 1, dfs(v, u);
rt[u] = Sgt.merge(rt[u], rt[v]);
}
}
} // namespace tree
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> tree_rt;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
tree::addEdge(u, v);
}
depth[tree_rt] = 1, tree::dfs(tree_rt, 0);
}
int last_ans, m;
int main() {
init();
cin >> m;
while (m--) {
int u, k;
cin >> u >> k;
u = (u + last_ans) % n + 1, k = (k + last_ans) % n;
last_ans = Sgt.query(rt[u], 1, n, depth[u], min(depth[u] + k, n));
cout << last_ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, y = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') y = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return y ? -x : x;
}
template <typename T>
inline T read() {
T x = 0;
int y = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') y = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return y ? -x : x;
}
inline int ran() {
static int seed = 703;
return seed = int(seed * 48271LL % 2147483647);
}
int root[100005], fa[100005], h[100005], line[100005], pos[100005], id[100005],
lo[100005], did[100005], dep[100005], max_dep, head, tail, num, all, gen, n,
len;
struct edge {
int pre, to;
} e[100005 << 1];
inline void add(int from, int to) {
e[++num].pre = h[from], h[from] = num, e[num].to = to;
}
struct Chairman_Tree {
int ls[100005 << 5], rs[100005 << 5], mi[100005 << 5], cnt;
void build(int poi, int l, int r, int &node, int ol, int d) {
node = ++cnt;
mi[node] = min(mi[ol], d);
if (l == r) return;
int mid = l + r >> 1;
if (poi <= mid)
rs[node] = rs[ol], build(poi, l, mid, ls[node], ls[ol], d);
else
ls[node] = ls[ol], build(poi, mid + 1, r, rs[node], rs[ol], d);
}
int ask(int L, int R, int l, int r, int node) {
if (!node) return 0x3f3f3f3f;
if (L <= l && R >= r) return mi[node];
int mid = l + r >> 1, ans = 0x3f3f3f3f;
if (L <= mid) ans = ask(L, R, l, mid, ls[node]);
if (R > mid) ans = min(ans, ask(L, R, mid + 1, r, rs[node]));
return ans;
}
Chairman_Tree() { mi[0] = 0x3f3f3f3f; }
} ct;
struct point {
int deep, seg, low, dat;
} p[100005];
void dfs(int node = gen) {
id[node] = p[node].seg = ++all;
for (register int i = h[node]; i; i = e[i].pre) {
int x = e[i].to;
if (!p[x].seg) fa[x] = node, dfs(x);
}
lo[node] = p[node].low = all;
}
void bfs() {
line[1] = gen, dep[gen] = p[gen].deep = tail = 1;
while (head < tail) {
int node = line[++head];
for (register int i = h[node]; i; i = e[i].pre) {
int x = e[i].to;
if (x != fa[node]) {
line[++tail] = x;
dep[x] = p[x].deep = p[node].deep + 1;
}
}
}
max_dep = p[line[tail]].deep;
}
inline bool cmp(point x, point y) { return x.deep < y.deep; }
signed main() {
n = read(), gen = read();
for (register int i = 1; i <= n; ++i) p[i].dat = read();
for (register int i = 1; i < n; ++i) {
int x = read(), y = read();
add(x, y), add(y, x);
}
dfs(), bfs();
sort(p + 1, p + 1 + n, cmp);
for (register int i = 1; i <= n; ++i) {
ct.build(p[i].seg, 1, n, root[i], root[i - 1], p[i].dat);
if (p[i].deep != p[i - 1].deep) did[p[i - 1].deep] = i - 1;
}
did[p[n].deep] = n;
int m = read(), ans = 0;
while (m--) {
int x = (read() + ans) % n + 1, k = (read() + ans) % n;
printf("%d\n", ans = ct.ask(id[x], lo[x], 1, n,
root[did[min(dep[x] + k, max_dep)]]));
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
constexpr int MAXN = 100005;
constexpr int INF = 1e9 + 7;
int n, r;
vector<int> tree[MAXN];
int val[MAXN];
int depth[MAXN];
int tin[MAXN], rtin[MAXN], tout[MAXN];
int timer = 0;
void dfs(int u, int par = -1) {
tin[u] = timer++;
rtin[tin[u]] = u;
for (int v : tree[u]) {
if (v == par) continue;
depth[v] = depth[u] + 1;
dfs(v, u);
}
tout[u] = timer;
}
vector<int> seg[4 * MAXN];
pair<int, int> range[4 * MAXN];
bool cmp(const int& a, const int& b) {
return depth[a] < depth[b] or (depth[a] == depth[b] and val[a] < val[b]);
}
void build(int node, int l, int r) {
if (l == r) {
seg[node].push_back(rtin[l]);
} else {
int mid = (l + r) >> 1;
build(2 * node, l, mid);
build(2 * node + 1, mid + 1, r);
merge(begin(seg[2 * node]), end(seg[2 * node]), begin(seg[2 * node + 1]),
end(seg[2 * node + 1]), back_inserter(seg[node]), cmp);
}
}
int query(const vector<int>& f_tree, int ind) {
int res = INF;
for (int x = ind + 1; x; x -= (x & -x)) {
res = min(res, f_tree[x]);
}
return res;
}
void update(vector<int>& f_tree, int ind, int vvv) {
for (int x = ind + 1; x < f_tree.size(); x += (x & -x)) {
f_tree[x] = min(f_tree[x], vvv);
}
}
void process(int node) {
if (seg[node].size() > 1) {
process(2 * node);
process(2 * node + 1);
}
range[node] = {depth[seg[node][0]], depth[seg[node].back()]};
vector<int> f_tree(range[node].second - range[node].first + 2, INF);
for (int u : seg[node]) {
update(f_tree, depth[u] - range[node].first, val[u]);
}
seg[node] = f_tree;
}
int query(int node, int l, int r, int ql, int qr, int k) {
if (l == ql and r == qr) {
if (k < range[node].first) return INF;
if (k - range[node].first + 1 >= seg[node].size())
return query(seg[node], seg[node].size() - 2);
return query(seg[node], k - range[node].first);
}
int res = INF;
int mid = (l + r) >> 1;
if (ql <= mid) {
res = min(res, query(2 * node, l, mid, ql, min(mid, qr), k));
}
if (mid + 1 <= qr) {
res = min(res, query(2 * node + 1, mid + 1, r, max(mid + 1, ql), qr, k));
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
scanf("%d %d", &n, &r);
for (int i = 1; i <= n; ++i) {
scanf("%d", val + i);
}
int u, v;
for (int i = 1; i < n; ++i) {
scanf("%d %d", &u, &v);
tree[u].push_back(v);
tree[v].push_back(u);
}
depth[r] = 0;
dfs(r);
build(1, 0, n - 1);
process(1);
int m;
scanf("%d", &m);
int last = 0;
int p, q;
while (m-- > 0) {
scanf("%d %d", &p, &q);
int x = ((p + last) % n) + 1;
int k = (q + last) % n;
last = query(1, 0, n - 1, tin[x], tout[x] - 1, depth[x] + k);
printf("%d\n", last);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
vector<int> g[100010];
int n, r;
int a[100010], b[100010];
int in[100010], out[100010], dep[100010], dfs_clock = 0;
vector<pair<int, int> > seg[100010 << 2];
vector<int> pp[100010 << 2];
void dfs(int u, int fa, int d) {
in[u] = ++dfs_clock;
b[dfs_clock] = u;
dep[u] = d;
for (int v : g[u])
if (v != fa) dfs(v, u, d + 1);
out[u] = dfs_clock;
}
void build(int l, int r, int o) {
if (l == r) {
pp[o].push_back(INF);
pp[o].push_back(a[b[l]]);
seg[o].push_back(pair<int, int>(dep[b[l]], a[b[l]]));
return;
}
int m = (l + r) >> 1;
build(l, m, o << 1), build(m + 1, r, o << 1 | 1);
for (auto s : seg[o << 1]) seg[o].push_back(s);
for (auto s : seg[o << 1 | 1]) seg[o].push_back(s);
sort(seg[o].begin(), seg[o].end());
pp[o].push_back(INF);
for (auto s : seg[o]) pp[o].push_back(min(s.second, pp[o].back()));
}
int query(int l, int r, int o, int ql, int qr, int v) {
if (ql <= l && r <= qr) {
int k = upper_bound(seg[o].begin(), seg[o].end(), pair<int, int>(v, INF)) -
seg[o].begin();
return pp[o][k];
}
int ret = INF;
int m = (l + r) >> 1;
if (ql <= m) ret = min(ret, query(l, m, o << 1, ql, qr, v));
if (qr > m) ret = min(ret, query(m + 1, r, o << 1 | 1, ql, qr, v));
return ret;
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y), g[y].push_back(x);
}
dfs(r, 0, 0);
build(1, n, 1);
int q;
scanf("%d", &q);
int ans = 0;
while (q--) {
int p, q;
scanf("%d%d", &p, &q);
int x = (ans + p) % n + 1, k = (ans + q) % n;
ans = query(1, n, 1, in[x], out[x], k + dep[x]);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> F[100010];
int n, ROOT, q, len = 0;
struct node {
int x, y, next;
} a[200010];
int last[200010], val[100010], dep[100010], size[100010], id[100010],
root[100010], ls[2000010], rs[2000010], Val[2000010];
void ins(int x, int y) {
a[++len] = (node){x, y, last[x]};
last[x] = len;
}
int cnt = 0;
void dfs(int x, int fa) {
id[x] = ++cnt;
size[x] = 1;
for (int i = last[x]; i; i = a[i].next) {
int y = a[i].y;
if (y == fa) continue;
dep[y] = dep[x] + 1;
F[dep[y]].push_back(y);
dfs(y, x);
size[x] += size[y];
}
}
int Len = 0;
void build(int &now, int l, int r) {
now = ++Len;
Val[now] = (int)(1e9);
if (l == r) return;
int mid = (l + r) >> 1;
build(ls[now], l, mid), build(rs[now], mid + 1, r);
}
void change(int last, int &now, int l, int r, int x, int d) {
now = ++Len;
if (l == r) {
Val[now] = d;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
rs[now] = rs[last], change(ls[last], ls[now], l, mid, x, d);
else
ls[now] = ls[last], change(rs[last], rs[now], mid + 1, r, x, d);
Val[now] = min(Val[ls[now]], Val[rs[now]]);
}
int solve(int now, int l, int r, int ll, int rr) {
if (ll <= l && r <= rr) return Val[now];
int mid = (l + r) >> 1;
if (rr <= mid)
return solve(ls[now], l, mid, ll, rr);
else if (ll > mid)
return solve(rs[now], mid + 1, r, ll, rr);
else
return min(solve(ls[now], l, mid, ll, rr),
solve(rs[now], mid + 1, r, ll, rr));
}
int main() {
int x, y, maxdep = 0, lastans = 0;
scanf("%d %d", &n, &ROOT);
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
for (int i = 1; i < n; i++) {
scanf("%d %d", &x, &y);
ins(x, y), ins(y, x);
}
dep[ROOT] = 1;
F[1].push_back(ROOT);
dfs(ROOT, 0);
build(root[0], 1, n);
for (int i = 1; i <= n; i++) {
if (!F[i].size()) break;
maxdep = i;
root[i] = root[i - 1];
for (int j = 0; j < F[i].size(); j++)
change(root[i], root[i], 1, n, id[F[i][j]], val[F[i][j]]);
}
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d %d", &x, &y);
x = (x + lastans) % n + 1, y = (y + lastans) % n;
printf("%d\n", lastans = solve(root[min(dep[x] + y, maxdep)], 1, n, id[x],
id[x] + size[x] - 1));
}
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int inf = numeric_limits<int>::max() >> 1;
constexpr int N = 100001;
constexpr int mod = 1000000007;
int h[N], tin[N], tout[N], ap[N], n, root, a[N], T;
int mx[N * 4], mn[N * 4], ml[N * 4];
vector<int> g[N];
void dfs(int u, int p) {
tin[u] = ++T;
ap[T] = u;
h[u] = h[p] + 1;
for (int v : g[u])
if (v != p) dfs(v, u);
tout[u] = T;
}
void build(int id, int l, int r) {
if (l == r) {
mx[id] = h[ap[l]];
mn[id] = a[ap[l]];
ml[id] = h[ap[l]];
return;
}
build((id << 1), l, (l + r) / 2);
build(((id << 1) + 1), (l + r) / 2 + 1, r);
mx[id] = max(mx[(id << 1)], mx[((id << 1) + 1)]);
mn[id] = min(mn[(id << 1)], mn[((id << 1) + 1)]);
ml[id] = min(ml[(id << 1)], ml[((id << 1) + 1)]);
return;
}
int query(int id, int l, int r, int L, int R, int dep) {
if (R < l || r < L) return inf;
if (ml[id] > dep) return inf;
if (L <= l && r <= R && mx[id] <= dep) return mn[id];
return min(query((id << 1), l, (l + r) / 2, L, R, dep),
query(((id << 1) + 1), (l + r) / 2 + 1, r, L, R, dep));
}
void solution() {
cin >> n >> root;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(root, 0);
build(1, 1, n);
int m;
cin >> m;
int last = 0;
while (m--) {
int p, q;
cin >> p >> q;
p = 1 + ((p + last) % n);
q = (q + last) % n;
last = query(1, 1, n, tin[p], tout[p], h[p] + q);
cout << last << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int tc = 1;
while (tc--) {
solution();
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxm = 2e5 + 5;
vector<int> g[maxm];
int a[maxm];
int n, rt;
int ans;
int d[maxm];
int lc[maxm * 40], rc[maxm * 40], mi[maxm * 40];
int r[maxm], tot;
void pushup(int k) { mi[k] = min(mi[lc[k]], mi[rc[k]]); }
void update(int x, int val, int l, int r, int &k) {
if (!k) k = ++tot;
if (l == r) {
mi[k] = val;
return;
}
int mid = (l + r) / 2;
if (x <= mid)
update(x, val, l, mid, lc[k]);
else
update(x, val, mid + 1, r, rc[k]);
pushup(k);
}
int merged(int x, int y) {
if (!x || !y) return x + y;
int k = ++tot;
lc[k] = merged(lc[x], lc[y]);
rc[k] = merged(rc[x], rc[y]);
mi[k] = min(mi[x], mi[y]);
return k;
}
int ask(int st, int ed, int l, int r, int k) {
if (st <= l && ed >= r) return mi[k];
int mid = (l + r) / 2;
int ans = 2e9;
if (st <= mid) ans = min(ans, ask(st, ed, l, mid, lc[k]));
if (ed > mid) ans = min(ans, ask(st, ed, mid + 1, r, rc[k]));
return ans;
}
void dfs(int x, int fa) {
update(d[x], a[x], 1, n, r[x]);
for (int v : g[x]) {
if (v == fa) continue;
d[v] = d[x] + 1;
dfs(v, x);
r[x] = merged(r[x], r[v]);
}
}
signed main() {
mi[0] = 2e9;
scanf("%d%d", &n, &rt);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
d[rt] = 1;
dfs(rt, rt);
int m;
scanf("%d", &m);
while (m--) {
int p, q;
scanf("%d%d", &p, &q);
int x = ((p + ans) % n) + 1, k = (q + ans) % n;
ans = ask(d[x], min(n, d[x] + k), 1, n, r[x]);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100005];
vector<int> dep[100005];
int a[100005];
int n, r;
int dfs_time;
int In[100005];
int Out[100005];
int pos[100005];
int dis[100005];
int Max;
struct node {
int l, r;
int Min;
} T[100005 << 6];
int ver[100005];
int tot;
void PushUp(int rt) { T[rt].Min = min(T[T[rt].l].Min, T[T[rt].r].Min); }
int BuildTree(int l, int r) {
int rt = (++tot);
T[rt].Min = 0x7f7f7f7f;
if (l == r) return rt;
int m = (l + r) >> 1;
T[rt].l = BuildTree(l, m);
T[rt].r = BuildTree(m + 1, r);
return rt;
}
int Update(int pre, int l, int r, int x) {
int rt = (++tot);
T[rt] = T[pre];
if (l == r) {
T[rt].Min = a[pos[x]];
return rt;
}
int m = (l + r) >> 1;
if (x <= m)
T[rt].l = Update(T[pre].l, l, m, x);
else
T[rt].r = Update(T[pre].r, m + 1, r, x);
PushUp(rt);
return rt;
}
void debug(int rt, int l, int r) {
cout << l << " " << r << endl;
cout << T[rt].Min << endl;
if (l == r) return;
int m = (l + r) >> 1;
debug(T[rt].l, l, m);
debug(T[rt].r, m + 1, r);
}
int Query(int rt, int L, int R, int l, int r) {
if (L <= l && R >= r) return T[rt].Min;
int ans = 0x7f7f7f7f;
int m = (l + r) >> 1;
if (L <= m) ans = min(ans, Query(T[rt].l, L, R, l, m));
if (R > m) ans = min(ans, Query(T[rt].r, L, R, m + 1, r));
return ans;
}
void DFS(int u, int fa, int depth) {
Max = max(Max, depth);
dis[u] = depth;
dep[depth].push_back(u);
pos[dfs_time] = u;
In[u] = dfs_time++;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == fa) continue;
DFS(v, u, depth + 1);
}
Out[u] = dfs_time - 1;
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs_time = 1;
DFS(r, -1, 1);
ver[0] = BuildTree(1, n);
for (int i = 1; i <= Max; i++) {
ver[i] = ver[i - 1];
for (int j = 0; j < dep[i].size(); j++) {
int u = dep[i][j];
ver[i] = Update(ver[i], 1, n, In[u]);
}
}
int m;
scanf("%d", &m);
int las = 0;
while (m--) {
int p, q;
scanf("%d%d", &p, &q);
int x = ((p + las) % n) + 1;
int k = (q + las) % n;
int tag = min(Max, dis[x] + k);
int ans = Query(ver[tag], In[x], Out[x], 1, n);
printf("%d\n", ans);
las = ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 2 * acos(0.0);
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
const int dx8[] = {-1, 0, 1, 0, 1, 1, -1, -1};
const int dy8[] = {0, -1, 0, 1, 1, -1, 1, -1};
long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
template <class S, S (*op)(S, S), S (*e)()>
struct segtree {
private:
int s, _n;
vector<S> st;
void construct(int pos, int l, int r, vector<S> &ind) {
if (l == r) {
st[pos] = ind[l];
return;
}
int mid = (l + r) / 2;
construct(pos * 2 + 1, l, mid, ind);
construct(pos * 2 + 2, mid + 1, r, ind);
st[pos] = op(st[pos * 2 + 1], st[pos * 2 + 2]);
}
void update(int i, int j, int l, int r, S val, int pos) {
if (l > r || l > j || r < i) return;
if (l == r) {
st[pos] = val;
return;
}
int mid = (l + r) / 2;
update(i, j, l, mid, val, 2 * pos + 1);
update(i, j, mid + 1, r, val, 2 * pos + 2);
st[pos] = op(st[pos * 2 + 1], st[pos * 2 + 2]);
}
void query(int i, int j, int l, int r, int pos, int k, int &ans) {
if (l > r || l > j || r < i) {
return;
}
if (i <= l && j >= r) {
auto &vec = st[pos].arr;
int left = 0, right = int(vec.size()) - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (vec[mid].first <= k) {
left = mid + 1;
ans = min(ans, vec[mid].second);
} else {
right = mid - 1;
}
}
return;
}
int mid = (l + r) / 2;
query(i, j, l, mid, pos * 2 + 1, k, ans);
query(i, j, mid + 1, r, pos * 2 + 2, k, ans);
}
void bs(int i, int j, int l, int r, int pos, bool (*fun)(S), int &ans) {
assert(l >= 0 && l < _n);
assert(r >= 0 && r < _n);
assert(r >= l);
if (l > r || l > j || r < i) return;
if (l == r) {
if (fun(st[pos]) == false) ans = min(ans, r);
return;
}
if (i <= l && j >= r) {
if (fun(st[pos]) == false) {
ans = min(ans, r);
int mid = (l + r) / 2;
if (fun(st[pos * 2 + 1]) == false)
bs(i, j, l, mid, 2 * pos + 1, fun, ans);
else if (fun(st[pos * 2 + 2]) == false)
bs(i, j, mid + 1, r, 2 * pos + 2, fun, ans);
}
return;
}
int mid = (l + r) / 2;
bs(i, j, l, mid, 2 * pos + 1, fun, ans);
bs(i, j, mid + 1, r, 2 * pos + 2, fun, ans);
return;
}
void rbs(int i, int j, int l, int r, int pos, bool (*fun)(S), int &ans) {
assert(l >= 0 && l < _n);
assert(r >= 0 && r < _n);
assert(r >= l);
if (l > r || l > j || r < i) return;
if (l == r) {
if (fun(st[pos]) == false) ans = max(ans, l);
return;
}
if (i <= l && j >= r) {
if (fun(st[pos]) == false) {
ans = max(ans, l);
int mid = (l + r) / 2;
if (fun(st[pos * 2 + 2]) == false)
rbs(i, j, l, mid, 2 * pos + 2, fun, ans);
else if (fun(st[pos * 2 + 1]) == false)
rbs(i, j, mid + 1, r, 2 * pos + 1, fun, ans);
}
return;
}
int mid = (l + r) / 2;
rbs(i, j, mid + 1, r, 2 * pos + 2, fun, ans);
rbs(i, j, l, mid, 2 * pos + 1, fun, ans);
return;
}
public:
segtree() : segtree(0) {}
segtree(int n) : segtree(vector<S>(n, e())) {}
segtree(vector<S> &v) : _n(int(v.size())) {
assert(_n > 0);
int s = ceil(log2(_n));
s = pow(2, s + 1) - 1;
st.clear();
st.resize(s, e());
construct(0, 0, _n - 1, v);
}
void set(int i, S val) {
assert(i >= 0 && i < _n);
update(i, i, 0, _n - 1, val, 0);
}
S query(int i) {
assert(i >= 0 && i < _n);
return query(i, i, 0, _n - 1, 0);
}
int query(int i, int j, int k) {
assert(i >= 0 && i < _n);
assert(i <= j && j >= 0 && j < _n);
int ans = INT_MAX;
query(i, j, 0, _n - 1, 0, k, ans);
return ans;
}
template <bool (*fun)(S)>
int bs(int l, int r) {
assert(l >= 0 && l < _n);
assert(r >= l && r >= 0 && r < _n);
assert(fun(e()) == true);
int ans = r + 1;
bs(l, r, 0, _n - 1, 0, fun, ans);
return ans;
}
template <bool (*fun)(S)>
int rbs(int l, int r) {
assert(l >= 0 && l < _n);
assert(r >= l && r >= 0 && r < _n);
assert(fun(e()) == true);
int ans = l - 1;
rbs(l, r, 0, _n - 1, 0, fun, ans);
return ans;
}
};
struct S {
vector<pair<int, int>> arr;
};
S op(S a, S b) {
auto &arr1 = a.arr;
auto &arr2 = b.arr;
vector<pair<int, int>> temp;
int i = 0, j = 0;
while (i < int(arr1.size()) or j < int(arr2.size())) {
if (i == int(arr1.size())) {
while (j < int(arr2.size())) {
temp.push_back(arr2[j++]);
}
break;
}
if (j == int(arr2.size())) {
while (i < int(arr1.size())) {
temp.push_back(arr1[i++]);
}
break;
}
if (arr1[i].first < arr2[j].first)
temp.push_back(arr1[i++]);
else
temp.push_back(arr2[j++]);
}
for (int i = 1; i < int(temp.size()); i++)
temp[i].second = min(temp[i].second, temp[i - 1].second);
return S{temp};
}
S e() { return S{{}}; }
vector<vector<int>> g;
vector<int> in_time, out_time;
vector<S> nodes;
vector<int> h;
vector<int> cost;
void dfs(int r, int p, int &t) {
in_time[r] = t++;
for (auto c : g[r]) {
if (c == p) continue;
h[c] = h[r] + 1;
dfs(c, r, t);
}
nodes[in_time[r]] = S{vector<pair<int, int>>(1, {h[r], cost[r]})};
out_time[r] = t - 1;
}
void solve() {
int n, r;
cin >> n >> r;
r--;
g.clear();
g.resize(n);
cost.clear();
cost.resize(n);
for (auto &a : cost) cin >> a;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--, y--;
g[x].push_back(y);
g[y].push_back(x);
}
in_time = vector<int>(n);
out_time = vector<int>(n);
nodes = vector<S>(n);
h = vector<int>(n);
int t = 0;
dfs(r, -1, t);
segtree<S, op, e> seg(nodes);
int q;
cin >> q;
int last = 0;
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
int x, k;
x = (a + last) % n;
k = (b + last) % n;
int l = in_time[x];
int r = out_time[x];
int deapth = h[x] + k;
last = seg.query(l, r, deapth);
cout << last << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
int add(int a, int b) {
if ((a += b) >= P) a -= P;
return a;
}
int sub(int a, int b) {
if ((a -= b) < 0) a += P;
return a;
}
int mul(int a, int b) { return 1ll * a * b % P; }
int kpow(int a, int b) {
int r = 1;
for (; b; b >>= 1, a = mul(a, a)) {
if (b & 1) r = mul(r, a);
}
return r;
}
const int N = 1e5 + 7;
const int M = 50;
int root[N], dep[N], tr[N * M], ls[N * M], rs[N * M], tid, n, m, T, a[N], u, v,
p, q, Root;
vector<int> g[N];
bool vis[N];
int merge(int x, int y, int l, int r) {
int mid = (l + r) >> 1;
tr[++tid] = min(tr[x], tr[y]);
int now = tid;
if (l == r) return now;
if (ls[x] && ls[y]) {
ls[now] = merge(ls[x], ls[y], l, mid);
} else if (ls[y])
ls[now] = ls[y];
else if (ls[x])
ls[now] = ls[x];
if (rs[x] && rs[y]) {
rs[now] = merge(rs[x], rs[y], mid + 1, r);
} else if (rs[y])
rs[now] = rs[y];
else if (rs[x])
rs[now] = rs[x];
return now;
}
int ne(int x, int l, int r) {
tr[++tid] = a[x];
int now = tid;
if (l == r && l == dep[x]) return now;
int mid = l + r >> 1;
if (dep[x] <= mid)
ls[now] = ne(x, l, mid);
else
rs[now] = ne(x, mid + 1, r);
return now;
}
int qry(int L, int R, int l, int r, int now) {
if (L <= l && r <= R) {
return tr[now];
}
int res = (1ll << (30)), mid = (l + r) >> 1;
if (ls[now] && L <= mid) res = min(res, qry(L, R, l, mid, ls[now]));
if (rs[now] && R > mid) res = min(res, qry(L, R, mid + 1, r, rs[now]));
return res;
}
void dfs(int u) {
vis[u] = 1;
root[u] = ne(u, 1, n);
tr[root[u]] = a[u];
for (auto v : g[u])
if (!vis[v]) {
dep[v] = dep[u] + 1;
dfs(v);
root[u] = merge(root[u], root[v], 1, n);
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> n >> Root;
for (int i = (1); i < (n + 1); i++) cin >> a[i];
for (int i = (1); i < (n); i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dep[Root] = 1;
dfs(Root);
cin >> T;
int pre = 0;
for (int cas = (0); cas < (T); cas++) {
cin >> p >> q;
p = (p + pre) % n + 1;
q = (q + pre) % n;
pre = qry(1, min(dep[p] + q, n), 1, n, root[p]);
cout << pre << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int n, totn;
int fa[N], L[N], R[N], d[N], tott;
int ch[7000010][2], minv[7000010], root[N];
vector<int> g[N], vd[N];
int a[N];
int add(int o, int l, int r, int qx, int qv) {
int x = ++totn;
ch[x][0] = ch[o][0], ch[x][1] = ch[o][1];
minv[x] = min(minv[o], qv);
if (l == r) return x;
int mid = (l + r) >> 1;
if (qx <= mid)
ch[x][0] = add(ch[o][0], l, mid, qx, qv);
else
ch[x][1] = add(ch[o][1], mid + 1, r, qx, qv);
return x;
}
int ask(int x, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return minv[x];
int mid = (l + r) >> 1, ans = 0x7fffffff;
if (ql <= mid) ans = min(ans, ask(ch[x][0], l, mid, ql, qr));
if (mid < qr) ans = min(ans, ask(ch[x][1], mid + 1, r, ql, qr));
return ans;
}
void dfs(int x) {
L[x] = ++tott;
for (auto p : g[x])
if (p != fa[x]) {
fa[p] = x;
d[p] = d[x] + 1;
dfs(p);
}
R[x] = tott;
}
int main() {
int r, m, x, y;
cin >> n >> r;
for (int i = (1); i <= (n); i++) scanf("%d", &a[i]);
for (int i = (2); i <= (n); i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
cin >> m;
d[r] = 1;
dfs(r);
for (int i = (1); i <= (n); i++) vd[d[i]].push_back(i);
minv[0] = 0x7fffffff;
for (int i = (1); i <= (n); i++) {
root[i] = root[i - 1];
for (auto x : vd[i]) {
root[i] = add(root[i], 1, n, L[x], a[x]);
}
}
int lastans = 0;
while (m--) {
scanf("%d%d", &x, &y);
x = (x + lastans) % n + 1;
y = (y + lastans) % n;
printf("%d\n", lastans = ask(root[min(n, d[x] + y)], 1, n, L[x], R[x]));
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16000000")
using namespace std;
const int Maxn = 100005;
const int Maxm = 524288;
const int Inf = 1000000007;
int n, r;
int a[Maxn];
vector<int> neigh[Maxn];
int cur, lef[Maxn], rig[Maxn];
int realval[Maxn];
int L[Maxn];
vector<pair<int, int> > st[Maxm];
int m;
void Traverse(int v, int p) {
cur++;
lef[v] = cur;
realval[cur] = v;
for (int i = 0; i < neigh[v].size(); i++) {
int u = neigh[v][i];
if (u == p) continue;
L[u] = L[v] + 1;
Traverse(u, v);
}
rig[v] = cur;
}
void Create(int v, int l, int r) {
if (l == r)
st[v].push_back(pair<int, int>(L[realval[l]], a[realval[l]]));
else {
int m = l + r >> 1;
int lc = 2 * v, rc = 2 * v + 1;
Create(lc, l, m);
Create(rc, m + 1, r);
int i = 0, j = 0;
int mn = Inf;
while (i < st[lc].size() || j < st[rc].size())
if (i < st[lc].size() &&
(j >= st[rc].size() || st[lc][i].first < st[rc][j].first)) {
mn = min(mn, st[lc][i].second);
st[v].push_back(pair<int, int>(st[lc][i].first, mn));
i++;
} else if (j < st[rc].size() &&
(i >= st[lc].size() || st[rc][j].first < st[lc][i].first)) {
mn = min(mn, st[rc][j].second);
st[v].push_back(pair<int, int>(st[rc][j].first, mn));
j++;
} else {
mn = min(mn, min(st[lc][i].second, st[rc][j].second));
st[v].push_back(pair<int, int>(st[lc][i].first, mn));
i++;
j++;
}
}
}
int Get(int v, int l, int r, int a, int b, int al) {
if (l == a && r == b) {
int ind =
lower_bound(st[v].begin(), st[v].end(), pair<int, int>(al + 1, 0)) -
st[v].begin() - 1;
return ind >= 0 ? st[v][ind].second : Inf;
} else {
int m = l + r >> 1;
if (b <= m) return Get(2 * v, l, m, a, b, al);
if (m + 1 <= a) return Get(2 * v + 1, m + 1, r, a, b, al);
return min(Get(2 * v, l, m, a, m, al),
Get(2 * v + 1, m + 1, r, m + 1, b, al));
}
}
int main() {
scanf("%d %d", &n, &r);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d", &a, &b);
neigh[a].push_back(b);
neigh[b].push_back(a);
}
Traverse(r, 0);
Create(1, 1, n);
int lst = 0;
scanf("%d", &m);
while (m--) {
int x, y;
scanf("%d %d", &x, &y);
x = (x + lst) % n + 1, y = (y + lst) % n;
lst = Get(1, 1, n, lef[x], rig[x], L[x] + y);
printf("%d\n", lst);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int INF = 1e9 + 10;
int n;
struct node {
int l, r;
node *ls, *rs;
int mini;
node *rt;
inline void build(int ll, int rr) {
l = ll;
r = rr;
rt = ls = rs = NULL;
mini = INF;
if (ll == rr) return;
ls = new node;
rs = new node;
ls->build(ll, (ll + rr) >> 1);
rs->build(((ll + rr) >> 1) + 1, rr);
return;
}
inline void init(int ll, int rr) {
l = ll;
r = rr;
rt = ls = rs = NULL;
mini = INF;
return;
}
inline void update2(int depth, int idx) {
mini = min(mini, idx);
if (l == r) return;
int mid = (l + r) >> 1;
if (depth <= mid) {
if (ls == NULL) {
ls = new node;
ls->init(l, mid);
}
ls->update2(depth, idx);
} else {
if (rs == NULL) {
rs = new node;
rs->init(mid + 1, r);
}
rs->update2(depth, idx);
}
return;
}
inline void update1(int pos, int depth, int idx) {
if (rt == NULL) {
rt = new node;
rt->init(1, n);
}
rt->update2(depth, idx);
if (l == r) return;
int mid = (l + r) >> 1;
if (pos <= mid)
ls->update1(pos, depth, idx);
else
rs->update1(pos, depth, idx);
return;
}
inline int getmin2(int ll, int rr) {
if (ll <= l && r <= rr) return mini;
if (rr < l || r < ll)
return INF;
else {
int ans = INF;
if (ls != NULL) ans = min(ans, ls->getmin2(ll, rr));
if (rs != NULL) ans = min(ans, rs->getmin2(ll, rr));
return ans;
}
}
inline int getmin1(int ll, int rr, int lb, int rb) {
if (ll <= l && r <= rr) {
if (rt == NULL)
return INF;
else
return rt->getmin2(lb, rb);
} else if (rr < l || r < ll)
return INF;
else
return min(ls->getmin1(ll, rr, lb, rb), rs->getmin1(ll, rr, lb, rb));
}
} * root;
int r, ans;
vector<int> path[maxn];
int u, v;
int depth[maxn], st[maxn], ed[maxn];
int seq[maxn];
int q, tot, x, k;
int a[maxn];
inline void build(int p, int fa) {
depth[p] = depth[fa] + 1;
seq[++tot] = p;
st[p] = tot;
for (int i = 0; i < path[p].size(); i++) {
if (path[p][i] == fa) continue;
build(path[p][i], p);
}
ed[p] = tot;
return;
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
path[u].push_back(v);
path[v].push_back(u);
}
build(r, r);
root = new node;
root->build(1, n);
for (int i = 1; i <= n; i++) root->update1(st[i], depth[i], a[i]);
ans = 0;
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d%d", &x, &k);
x = (x + ans) % n + 1;
k = (k + ans) % n;
ans = root->getmin1(st[x], ed[x], depth[x], depth[x] + k);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
char ch = getchar();
int f = 0, x = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') x = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
f = (f << 1) + (f << 3) + ch - '0';
ch = getchar();
}
return f * x;
}
int n, m, rt, last;
struct node {
int from;
int to;
int next;
int w;
} edge[200005];
int tot, head[500005], r, fa[500005], tar, npos[500005], cnt, sz, pos[500005];
int root[500005], ch[10000005][2], w[10000005], dep[500005], size[500005],
a[500005];
void add(int u, int v) {
edge[tot].from = u;
edge[tot].to = v;
edge[tot].next = head[u];
head[u] = tot++;
}
void dfs(int x) {
pos[x] = ++tar;
npos[tar] = x;
size[x] = 1;
for (int i = head[x]; i != -1; i = edge[i].next) {
if (edge[i].to != fa[x]) {
fa[edge[i].to] = x;
dep[edge[i].to] = dep[x] + 1;
dfs(edge[i].to);
size[x] += size[edge[i].to];
}
}
}
void insert(int &k, int x, int num, int l, int r) {
if (!k) {
k = ++sz;
w[k] = num;
} else
w[k] = min(w[k], num);
if (l == r) return;
int mid = l + r >> 1;
if (x <= mid)
insert(ch[k][0], x, num, l, mid);
else
insert(ch[k][1], x, num, mid + 1, r);
}
void build(int p, int l, int r, int x, int y, int num) {
insert(root[p], y, num, 1, n);
if (l == r) return;
int mid = l + r >> 1;
if (x <= mid)
build(p << 1, l, mid, x, y, num);
else
build(p << 1 | 1, mid + 1, r, x, y, num);
}
int query(int p, int l, int r, int x, int y) {
if (!p) return 2000000000;
if (l == x && r == y) {
return w[p];
}
int mid = l + r >> 1;
if (y <= mid)
return query(ch[p][0], l, mid, x, y);
else if (x > mid)
return query(ch[p][1], mid + 1, r, x, y);
else {
return min(query(ch[p][0], l, mid, x, mid),
query(ch[p][1], mid + 1, r, mid + 1, y));
}
}
void query(int p, int l, int r, int x, int y, int z, int k) {
int mid = l + r >> 1;
if (l == x && r == y) {
last = min(last, query(root[p], 1, n, z, k));
return;
}
if (y <= mid)
query(p << 1, l, mid, x, y, z, k);
else if (x > mid)
query(p << 1 | 1, mid + 1, r, x, y, z, k);
else {
query(p << 1, l, mid, x, mid, z, k);
query(p << 1 | 1, mid + 1, r, mid + 1, y, z, k);
}
}
int main() {
memset(head, -1, sizeof(head));
n = read();
rt = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i < n; i++) {
int u = read(), v = read();
add(u, v);
add(v, u);
}
dep[rt] = 1;
dfs(rt);
for (int i = 1; i <= n; i++) {
build(1, 1, n, i, dep[npos[i]], a[npos[i]]);
}
last = 0;
m = read();
for (int i = 1; i <= m; i++) {
int x = (read() + last) % n + 1, y = (read() + last) % n;
last = 2000000000;
query(1, 1, n, pos[x], pos[x] + size[x] - 1, dep[x], min(y + dep[x], n));
printf("%d\n", last);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct dor {
vector<pair<int, int> > v;
vector<int> ve;
dor *l, *r;
dor() {
l = r = NULL;
v.clear();
ve.clear();
}
void pump() {
v.clear();
ve.clear();
int dl = 0, dr = 0, n = (int)((l->v).size()), m = (int)((r->v).size());
while (dl < n || dr < m) {
if (dl == n) {
v.push_back((r->v)[dr++]);
} else if (dr == m) {
v.push_back((l->v)[dl++]);
} else {
if ((l->v)[dl].first == (r->v)[dr].first) {
if ((l->v)[dl].second < (r->v)[dr].second) {
v.push_back((l->v)[dl++]);
} else {
v.push_back((r->v)[dr++]);
}
} else if ((l->v)[dl].first < (r->v)[dr].first) {
v.push_back((l->v)[dl++]);
} else {
v.push_back((r->v)[dr++]);
}
}
}
dl = 1e9;
for (int i = 0; i < v.size(); ++i) {
if (i) dl = ve[i - 1];
ve.push_back(min(dl, v[i].second));
}
}
int tsh(int k) {
int bl = 0, br = (int)(v.size()), bm = 0, bp = -1;
--br;
while (bl <= br) {
bm = (bl + br) / 2;
if (v[bm].first <= k) {
bp = bm;
bl = bm + 1;
} else {
br = bm - 1;
}
}
if (bp != -1) return ve[bp];
return 1e9;
}
};
int n, rt, m, a[100005], x, y, p, q, tp, k, io[100005][2], rg, ddt[100005];
pair<int, int> b[100005];
vector<int> v[100005];
dor *rtt;
void dfs(int dg, int dt, int up) {
ddt[dg] = dt;
io[dg][0] = ++rg;
b[rg] = {dt, a[dg]};
for (int i = 0; i < v[dg].size(); ++i) {
if (v[dg][i] != up) {
dfs(v[dg][i], dt + 1, dg);
}
}
io[dg][1] = rg;
}
void bgbn(int l, int r, dor *&t) {
if (t == NULL) t = new dor();
if (l == r) {
(t->v).push_back(b[l]);
(t->ve).push_back(b[l].second);
return;
}
bgbn(l, (l + r) / 2, t->l);
bgbn((l + r) / 2 + 1, r, t->r);
t->pump();
}
int poi(int l, int r, int sl, int sr, dor *&t) {
if (l > sr || r < sl) {
return 1e9;
}
if (l >= sl && r <= sr) {
return t->tsh(k);
}
return min(poi(l, (l + r) / 2, sl, sr, t->l),
poi((l + r) / 2 + 1, r, sl, sr, t->r));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> rt;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
}
for (int i = 1; i < n; ++i) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(rt, 0, 0);
bgbn(1, n, rtt);
cin >> m;
for (int i = 0; i < m; ++i) {
cin >> p >> q;
x = (p + tp) % n + 1;
k = (q + tp) % n + ddt[x];
tp = poi(1, n, io[x][0], io[x][1], rtt);
cout << tp << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
using ll = long long;
const ll mod = 1e9 + 7;
const int maxn = 1e6 + 5;
const int inf = 2e9;
int n, r;
vector<int> g[maxn];
int a[maxn];
int siz[maxn];
int cloc = 1;
int tin[maxn];
int dep[maxn];
vector<pair<int, int>> nodes;
void dfs(int at, int p) {
tin[at] = cloc++;
siz[at] = 1;
nodes.push_back({dep[at], a[at]});
for (int to : g[at]) {
if (to != p) {
dep[to] = 1 + dep[at];
dfs(to, at);
siz[at] += siz[to];
}
}
}
vector<pair<int, int>> t[4 * maxn];
void build(int v, int tl, int tr) {
if (tl == tr) {
t[v].push_back(nodes[tl]);
} else {
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
std::merge(t[2 * v].begin(), t[2 * v].end(), t[2 * v + 1].begin(),
t[2 * v + 1].end(), std::back_inserter(t[v]));
for (int i = 1; i < (int)t[v].size(); i++) {
t[v][i].second = min(t[v][i].second, t[v][i - 1].second);
}
}
}
int qry(int v, int tl, int tr, int l, int r, int d) {
if (l > tr || r < tl) return inf;
if (l <= tl && tr <= r) {
int i = std::upper_bound(t[v].begin(), t[v].end(), make_pair(d, inf)) -
t[v].begin();
return i ? t[v][i - 1].second : inf;
} else {
int tm = (tl + tr) / 2;
return min(qry(2 * v, tl, tm, l, r, d),
qry(2 * v + 1, tm + 1, tr, l, r, d));
}
}
int solve(int at, int k) {
return qry(1, 1, n, tin[at], tin[at] + siz[at] - 1, dep[at] + k);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> r;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
nodes.emplace_back();
dfs(r, -1);
build(1, 1, n);
int last = 0;
int q;
cin >> q;
while (q--) {
int p, q;
cin >> p >> q;
int x = ((p + last) % n + 1);
int k = (q + last) % n;
last = solve(x, k);
cout << last << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000100, INF = 1e9 + 7;
int a[MAXN];
struct Vertex {
Vertex *l, *r;
int sum;
Vertex(int val) : l(nullptr), r(nullptr), sum(val) {}
Vertex(Vertex* l, Vertex* r) : l(l), r(r), sum(INF) {
if (l) sum = min(l->sum, sum);
if (r) sum = min(r->sum, sum);
}
};
Vertex* build(int tl, int tr) {
if (tl == tr) return new Vertex(a[tl]);
int tm = (tl + tr) / 2;
return new Vertex(build(tl, tm), build(tm + 1, tr));
}
int get_sum(Vertex* v, int tl, int tr, int l, int r) {
if (l > r) return INF;
if (l == tl && tr == r) return v->sum;
int tm = (tl + tr) / 2;
return min(get_sum(v->l, tl, tm, l, min(r, tm)),
get_sum(v->r, tm + 1, tr, max(l, tm + 1), r));
}
Vertex* update(Vertex* v, int tl, int tr, int pos, int new_val) {
if (tl == tr) return new Vertex(new_val);
int tm = (tl + tr) / 2;
if (pos <= tm)
return new Vertex(update(v->l, tl, tm, pos, new_val), v->r);
else
return new Vertex(v->l, update(v->r, tm + 1, tr, pos, new_val));
}
Vertex* T[MAXN];
int root, n, timer = -1, tin[MAXN], tout[MAXN], dep[MAXN];
vector<int> adj[MAXN], deps[MAXN];
int val[MAXN], MAXD;
void dfs(int s, int p) {
tin[s] = ++timer;
deps[dep[s]].push_back(s);
MAXD = max(dep[s], MAXD);
for (auto t : adj[s]) {
if (t != p) {
dep[t] = dep[s] + 1;
dfs(t, s);
}
}
tout[s] = timer;
}
int main() {
scanf("%d%d", &n, &root);
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
a[i] = INF;
}
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(root, 0);
a[tin[root]] = val[root];
T[0] = build(0, n - 1);
for (int i = 1; i <= MAXD; i++) {
T[i] = T[i - 1];
for (auto t : deps[i]) {
T[i] = update(T[i], 0, n - 1, tin[t], val[t]);
}
}
int Q;
int last = 0;
scanf("%d", &Q);
while (Q--) {
int x, k;
scanf("%d%d", &x, &k);
x = (x + last) % n + 1;
k = (k + last) % n;
last = get_sum(T[min(dep[x] + k, MAXD)], 0, n - 1, tin[x], tout[x]);
cout << last << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, r, m, t = 0;
int a[100001];
vector<int> v[100001];
bool vs[100001];
int in[100001];
int out[100001];
int lv[100001];
vector<int> bd[100001];
int nc = 0, vc = 0, ver[100001];
int root[100001], mn[6000006];
int lc[6000006], rc[6000006];
void dfs(int x, int l) {
in[x] = ++t;
vs[x] = true;
lv[x] = l;
bd[l].push_back(x);
for (int u : v[x]) {
if (!vs[u]) {
dfs(u, l + 1);
}
}
out[x] = ++t;
}
int build(int l, int r) {
int id = ++nc;
mn[id] = 2e9;
if (l == r) {
return id;
}
int mid = (l + r) / 2;
lc[id] = build(l, mid);
rc[id] = build(mid + 1, r);
return id;
}
int update(int oid, int l, int r, int upos, int uval) {
int id = ++nc;
if (l == r) {
mn[id] = uval;
return id;
}
int mid = (l + r) / 2;
if (upos <= mid) {
rc[id] = rc[oid];
lc[id] = update(lc[oid], l, mid, upos, uval);
} else {
lc[id] = lc[oid];
rc[id] = update(rc[oid], mid + 1, r, upos, uval);
}
mn[id] = min(mn[lc[id]], mn[rc[id]]);
return id;
}
int query(int id, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
return mn[id];
}
if (r < ql || qr < l) {
return 2e9;
}
int mid = (l + r) / 2;
return min(query(lc[id], l, mid, ql, qr), query(rc[id], mid + 1, r, ql, qr));
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
dfs(r, 0);
root[0] = build(1, 2 * n);
for (int i = 0; i <= n; i++) {
for (int u : bd[i]) {
root[vc + 1] = update(root[vc], 1, 2 * n, in[u], a[u]);
vc++;
}
ver[i] = root[vc];
}
int last = 0;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int p, q;
scanf("%d%d", &p, &q);
int x = (p + last) % n + 1;
int k = (q + last) % n;
last = query(ver[min(lv[x] + k, n)], 1, 2 * n, in[x], out[x]);
printf("%d\n", last);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3")
using namespace std;
void read(int &x) {
x = 0;
int c = getchar();
while (c <= 32) c = getchar();
while (c > 32) {
x = (x << 3) + (x << 1) + (c & 15);
c = getchar();
}
}
void write(int x) {
if (x >= 10) write(x / 10);
putchar(x % 10 + 48);
}
const int Siz = 1e7;
int lson[Siz], rson[Siz], mn[Siz], r[Siz], cnt;
int min(int a, int b) { return a < b ? a : b; }
int clone(int x) {
int i = ++cnt;
mn[i] = mn[x];
lson[i] = lson[x];
rson[i] = rson[x];
return i;
}
void ins(int &i, int a, int b, int x, int v) {
if (!i)
i = ++cnt;
else
i = clone(i);
if (a + 1 == b) {
mn[i] = v;
return;
}
int m = (a + b) >> 1;
if (x < m)
ins(lson[i], a, m, x, v);
else
ins(rson[i], m, b, x, v);
mn[i] = 1e9;
if (lson[i]) mn[i] = min(mn[i], mn[lson[i]]);
if (rson[i]) mn[i] = min(mn[i], mn[rson[i]]);
}
int qry(int i, int a, int b, int l, int r) {
if (!i) return 1e9;
if (l <= a && b <= r) {
return mn[i];
}
int ans = 1e9;
int m = (a + b) >> 1;
if (l < m) ans = min(ans, qry(lson[i], a, m, l, r));
if (r > m) ans = min(ans, qry(rson[i], m, b, l, r));
return ans;
}
const int N = 1e5 + 5;
int n, rt;
int c[N];
int head[N], nex[N << 1], to[N << 1], tot;
void add_edge(int u, int v) {
to[tot] = v;
nex[tot] = head[u];
head[u] = tot++;
}
int dep[N], dfn[N], siz[N], tme;
void dfs(int u, int p) {
if (~p) dep[u] = dep[p] + 1;
siz[u] = 1;
dfn[u] = tme++;
for (int e = head[u]; ~e; e = nex[e]) {
int v = to[e];
if (v != p) {
dfs(v, u);
siz[u] += siz[v];
}
}
}
int id[N], lst[N];
bool comp(int a, int b) { return dep[a] < dep[b]; }
int main() {
read(n);
read(rt);
--rt;
for (int i = 0; i < n; ++i) read(c[i]);
for (int i = 0; i < n; ++i) head[i] = -1;
for (int i = 1; i < n; ++i) {
int u, v;
read(u);
read(v);
--u;
--v;
add_edge(u, v);
add_edge(v, u);
}
dfs(rt, -1);
for (int i = 0; i < n; ++i) id[i] = i;
std ::sort(id, id + n, comp);
int mxdep = 0;
for (int i = 0; i < n; ++i) {
if (i) r[i] = r[i - 1];
ins(r[i], 0, tme, dfn[id[i]], c[id[i]]);
lst[dep[id[i]]] = i;
mxdep = dep[id[i]];
}
int q, lstans = 0;
read(q);
while (q--) {
int p, q;
read(p);
read(q);
(p += lstans) %= n;
(q += lstans) %= n;
int lim = min(dep[p] + q, mxdep);
write(lstans = qry(r[lst[lim]], 0, tme, dfn[p], dfn[p] + siz[p]));
putchar(10);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int P = 1e9 + 7;
int add(int a, int b) {
if ((a += b) >= P) a -= P;
return a;
}
int sub(int a, int b) {
if ((a -= b) < P) a += P;
return a;
}
int mul(int a, int b) { return 1ll * a * b % P; }
int kpow(int a, int b) {
int r = 1;
for (; b; b >>= 1, a = mul(a, a)) {
if (b & 1) r = mul(r, a);
}
return r;
}
const int N = 101010;
int n, r, L;
int a[N], ls[N * 44], rs[N * 44], mi[N * 44], rt[N], dep[N];
vector<int> g[N];
void upd(int p, int c, int &rt, int l, int r) {
if (!rt) rt = ++L;
mi[rt] = min(mi[rt], c);
if (l == r) return;
int mid = l + r >> 1;
if (p <= mid)
upd(p, c, ls[rt], l, mid);
else
upd(p, c, rs[rt], mid + 1, r);
}
int merge(int a, int b) {
if (a && b) {
int c = ++L;
mi[c] = min(mi[a], mi[b]);
ls[c] = merge(ls[a], ls[b]);
rs[c] = merge(rs[a], rs[b]);
return c;
} else {
return a + b;
}
}
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
upd(dep[u], a[u], rt[u], 1, n);
for (int i = (0); i < ((int)g[u].size()); i++)
if (g[u][i] != fa) {
int v = g[u][i];
dfs(v, u);
rt[u] = merge(rt[u], rt[v]);
}
}
int qry(int L, int R, int rt, int l, int r) {
if (!rt) return mi[N * 44 - 1];
if (L <= l && r <= R) return mi[rt];
int mid = l + r >> 1, ans = mi[N * 44 - 1];
if (L <= mid) ans = min(ans, qry(L, R, ls[rt], l, mid));
if (R > mid) ans = min(ans, qry(L, R, rs[rt], mid + 1, r));
return ans;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
memset(mi, 0x3f, sizeof(mi));
cin >> n >> r;
for (int i = (1); i < (n + 1); i++) cin >> a[i];
for (int i = (1); i < (n); i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(r, 0);
int p = 0, q;
cin >> q;
while (q--) {
int x, k;
cin >> x >> k;
x = (x + p) % n + 1;
k = (k + p) % n;
p = qry(dep[x], dep[x] + k, rt[x], 1, n);
cout << p << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
const int MN = 1e5 + 4, INF = 0x3f3f3f3f;
int N, R, M, ans, D, A[MN], depth[MN], ord[MN], ecnt, ein[MN], eout[MN], st[MN];
std::vector<int> adj[MN];
struct nd {
int l, r, val;
nd *ch[2];
nd() : l(0), r(0), val(INF), ch{0} {}
} * sgt[MN];
void dfs(int src, int p, int d) {
depth[src] = d;
ein[src] = ++ecnt;
for (int i : adj[src]) {
if (i == p) continue;
dfs(i, src, d + 1);
}
eout[src] = ecnt;
}
inline void upd(nd *n) { n->val = std::min(n->ch[0]->val, n->ch[1]->val); }
void build(nd *&n, int l, int r) {
n = new nd();
n->l = l, n->r = r;
if (l == r) return;
int mid = l + r >> 1;
build(n->ch[0], l, mid);
build(n->ch[1], mid + 1, r);
}
void mod(nd *&n, nd *o, int p, int v) {
n = new nd();
n->l = o->l, n->r = o->r;
if (n->l == n->r) {
n->val = v;
return;
}
int mid = n->l + n->r >> 1;
bool b = p > mid;
n->ch[!b] = o->ch[!b];
mod(n->ch[b], o->ch[b], p, v);
upd(n);
}
int qry(nd *n, int l, int r) {
if (l > n->r || r < n->l) return INF;
if (l <= n->l && n->r <= r) return n->val;
return std::min(qry(n->ch[0], l, r), qry(n->ch[1], l, r));
}
int main() {
scanf("%d%d", &N, &R);
for (int i = 1; i <= N; scanf("%d", A + i++))
;
for (int i = 1, a, b; i < N; ++i) {
scanf("%d%d", &a, &b);
adj[a].emplace_back(b);
adj[b].emplace_back(a);
}
dfs(R, -1, 1);
for (int i = 0; i < N; ++i) ord[i] = i + 1;
std::stable_sort(ord, ord + N, [=](const int &a, const int &b) {
return depth[a] < depth[b];
});
build(sgt[0], 1, N);
for (int i = 0; i < N; ++i) {
if (depth[ord[i]] != D) st[D++] = i;
mod(sgt[i + 1], sgt[i], ein[ord[i]], A[ord[i]]);
}
st[D] = N;
scanf("%d", &M);
for (int i = 0, a, b; i < M; ++i) {
scanf("%d%d", &a, &b);
a = ((a + ans) % N) + 1, b = (b + ans) % N;
printf("%d\n",
ans = qry(sgt[st[std::min(depth[a] + b, D)]], ein[a], eout[a]));
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int h[1000005], arr[1000005], ind[1000005], size[1000005];
vector<pair<long long int, long long int> > tree[4 * 1000005];
vector<long long int> o;
vector<long long int> v[1000005];
void dfs(long long int cur, long long int par) {
if (par != -1) h[cur] = h[par] + 1;
size[cur] = 1;
o.push_back(cur);
for (long long int i = 0; i < v[cur].size(); i++) {
long long int x = v[cur][i];
if (x == par) continue;
dfs(x, cur);
size[cur] += size[x];
}
}
void build(long long int node, long long int a, long long int b) {
if (a == b) {
tree[node].resize(1);
tree[node][0] = make_pair(h[o[a]], arr[o[a]]);
return;
}
long long int mid = (a + b) / 2;
build(2 * node, a, mid);
build(2 * node + 1, mid + 1, b);
tree[node].resize(tree[2 * node].size() + tree[2 * node + 1].size());
merge(tree[2 * node].begin(), tree[2 * node].end(),
tree[2 * node + 1].begin(), tree[2 * node + 1].end(),
tree[node].begin());
for (long long int i = 1; i < tree[node].size(); i++)
tree[node][i].second = min(tree[node][i].second, tree[node][i - 1].second);
return;
}
long long int query(long long int node, long long int a, long long int b,
long long int l, long long int r, long long int val) {
if (a > b || a > r || b < l) return 1000000000000;
if (a >= l && b <= r) {
if (tree[node][0].first > val) return 1000000000000;
long long int lo = 0;
long long int hi = tree[node].size();
while (hi - lo > 1) {
long long int mid = (lo + hi) / 2;
if (tree[node][mid].first <= val)
lo = mid;
else
hi = mid;
}
return tree[node][lo].second;
}
long long int mid = (a + b) / 2;
return min(query(2 * node, a, mid, l, r, val),
query(2 * node + 1, mid + 1, b, l, r, val));
}
int main() {
ios::sync_with_stdio(false);
;
cin.tie(0);
;
long long int i, j, n, x, y, root, ans, q, l, r, k, node;
cin >> n >> root;
for (i = 1; i <= n; i++) cin >> arr[i];
for (i = 1; i <= n - 1; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
o.push_back(-1);
dfs(root, -1);
for (i = 1; i <= n; i++) ind[o[i]] = i;
build(1, 1, n);
cin >> q;
ans = 0;
while (q--) {
cin >> x >> y;
node = ((x + ans) % n) + 1;
k = (y + ans) % n;
l = ind[node];
r = ind[node] + size[node] - 1;
ans = query(1, 1, n, l, r, h[node] + k);
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int number[200001];
vector<int> g[200001];
int timer;
int Pos[200001];
int Hsh[200001];
int Sz[200001];
int Ds[200001];
void dfs(int node, int pa, int dist) {
Pos[node] = ++timer;
Hsh[timer] = node;
Sz[node] = 1;
Ds[node] = dist;
for (int i = 0; i < (int)g[node].size(); ++i) {
int to = g[node][i];
if (to == pa) continue;
dfs(to, node, dist + 1);
Sz[node] += Sz[to];
}
}
vector<pair<int, int> > seg[400010];
int query(int node, int l, int r, int s, int e, int dist) {
if (s > r || l > e) return 2000000007;
if (l >= s && r <= e) {
int B = 0;
int E = (int)seg[node].size() - 1;
int idx = -1;
while (B <= E) {
int mi = (B + E) / 2;
if (seg[node][mi].first <= dist) {
idx = mi;
B = mi + 1;
} else
E = mi - 1;
}
if (idx == -1) {
return 2000000007;
}
return seg[node][idx].second;
}
int p = query(2 * node, l, (l + r) / 2, s, e, dist);
int q = query(2 * node + 1, (l + r) / 2 + 1, r, s, e, dist);
return min(p, q);
}
void Merge(int node) {
int l = 2 * node;
int r = l + 1;
int n = (int)seg[l].size();
int m = (int)seg[r].size();
int i = 0;
int j = 0;
while (i < n && j < m) {
if (seg[l][i].first <= seg[r][j].first) {
seg[node].push_back(seg[l][i]);
++i;
} else {
seg[node].push_back(seg[r][j]);
++j;
}
}
while (i < n) {
seg[node].push_back(seg[l][i]);
++i;
}
while (j < m) {
seg[node].push_back(seg[r][j]);
++j;
}
}
void build(int node, int l, int r) {
if (l == r) {
seg[node].push_back({Ds[Hsh[l]], number[Hsh[l]]});
return;
}
build(2 * node, l, (l + r) / 2);
build(2 * node + 1, (l + r) / 2 + 1, r);
Merge(node);
}
int main() {
int n, r;
scanf("%d %d", &n, &r);
for (int i = 1; i <= n; ++i) scanf("%d", number + i);
int e = n - 1;
while (e--) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(r, -1, 0);
build(1, 1, n);
for (int i = 0; i <= 4 * n; ++i) {
int s = (int)seg[i].size();
for (int j = 1; j < s; ++j)
seg[i][j].second = min(seg[i][j].second, seg[i][j - 1].second);
}
int q;
int last = 0;
scanf("%d", &q);
while (q--) {
int pi, qi;
scanf("%d %d", &pi, &qi);
int xi = (pi + last) % n + 1;
int ki = (qi + last) % n;
last = query(1, 1, n, Pos[xi], Pos[xi] + Sz[xi] - 1, ki + Ds[xi]);
printf("%d\n", last);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long mx = 1e5 + 7;
const long long inf = 1e18;
vector<long long> adj[mx];
long long n, r, val[mx], tin[mx], tout[mx], timer = 0, node_dep[mx],
val_tin[mx];
pair<long long, long long> tree[22][mx];
long long expo_pow(long long x, long long y) {
y = y % (mod - 1);
if (y == 0) y = mod - 1;
long long res = 1;
while (y) {
if (y & 1) res = (res * x) % mod;
x = (x * x) % mod;
y >>= 1;
}
return res;
}
void dfs(long long cur, long long bap, long long level = 0) {
timer++;
tin[cur] = timer;
node_dep[tin[cur]] = level;
val_tin[tin[cur]] = val[cur];
for (auto u : adj[cur]) {
if (u != bap) dfs(u, cur, level + 1);
}
tout[cur] = timer;
}
void build(long long c, long long l, long long r) {
if (l == r)
tree[c][l] = {node_dep[l], val_tin[l]};
else {
long long mid = (l + r) / 2;
build(c + 1, l, mid);
build(c + 1, mid + 1, r);
long long i = l, j = mid + 1, k = l;
while (i <= mid && j <= r) {
if (tree[c + 1][i].first < tree[c + 1][j].first)
tree[c][k++] = tree[c + 1][i++];
else
tree[c][k++] = tree[c + 1][j++];
}
while (i <= mid) tree[c][k++] = tree[c + 1][i++];
while (j <= r) tree[c][k++] = tree[c + 1][j++];
for (i = l + 1; i <= r; ++i)
tree[c][i].second = min(tree[c][i].second, tree[c][i - 1].second);
}
}
long long query(long long c, long long l, long long r, long long l1,
long long r1, long long k) {
if (r1 < l || l1 > r) return inf;
if (l >= l1 && r <= r1) {
pair<long long, long long> temp = {k, inf};
long long w = upper_bound(tree[c] + l, tree[c] + r + 1, temp) - tree[c];
if (w == l) return inf;
return tree[c][w - 1].second;
} else {
long long mid = (l + r) / 2;
return min(query(c + 1, l, mid, l1, r1, k),
query(c + 1, mid + 1, r, l1, r1, k));
}
}
void solve() {
cin >> n >> r;
for (long long i = 0; i < n; i++) {
cin >> val[i + 1];
}
for (long long i = 0; i < n - 1; i++) {
long long p, q;
cin >> p >> q;
adj[p].push_back(q);
adj[q].push_back(p);
}
dfs(r, -1);
build(1, 1, timer);
long long q;
cin >> q;
long long last = 0;
while (q--) {
long long l, r;
cin >> l >> r;
l = (l + last) % n + 1;
r = (r + last) % n;
last = query(1, 1, timer, tin[l], tout[l], r + node_dep[tin[l]]);
cout << last << "\n";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long test = 1;
long long i = 1;
while (test--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const int INF = 0x3f3f3f3f;
int maxd;
int n, m, r, a[MAX], ls[MAX << 6], rs[MAX << 6], val[MAX << 6], d[MAX], rt[MAX],
cnt;
struct P {
int to, nxt;
} e[MAX << 1];
int head[MAX], tot;
void init() {
memset(head, -1, sizeof(head));
memset(val, 0, sizeof(val));
memset(rt, 0, sizeof(rt));
memset(ls, 0, sizeof(ls));
memset(rs, 0, sizeof(rs));
tot = 0;
cnt = 0;
val[0] = INF;
}
void adde(int u, int v) {
e[tot].to = v;
e[tot].nxt = head[u];
head[u] = tot++;
}
void update(int &x, int l, int r, int p, int v) {
if (!x) x = ++cnt;
if (l == r) {
val[x] = v;
return;
}
int mid = (l + r) >> 1;
if (p <= mid)
update(ls[x], l, mid, p, v);
else
update(rs[x], mid + 1, r, p, v);
val[x] = min(val[ls[x]], val[rs[x]]);
}
int merge_(int u, int v) {
if (!u) return v;
if (!v) return u;
int x = ++cnt;
ls[x] = merge_(ls[u], ls[v]);
rs[x] = merge_(rs[u], rs[v]);
if (ls[x] || rs[x])
val[x] = min(val[ls[x]], val[rs[x]]);
else
val[x] = min(val[u], val[v]);
return x;
}
int query(int x, int l, int r, int L, int R) {
if (!x) return INF;
if (l == L && r == R) return val[x];
int mid = (l + r) >> 1;
if (R <= mid) return query(ls[x], l, mid, L, R);
if (L > mid) return query(rs[x], mid + 1, r, L, R);
return min(query(ls[x], l, mid, L, mid),
query(rs[x], mid + 1, r, mid + 1, R));
}
void dfs(int u, int fa) {
update(rt[u], 1, maxd, d[u], a[u]);
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].to;
if (v == fa) continue;
dfs(v, u);
rt[u] = merge_(rt[u], rt[v]);
}
}
void dfs1(int x, int f, int deep) {
d[x] = deep;
maxd = max(maxd, d[x]);
for (int i = head[x]; ~i; i = e[i].nxt) {
int y = e[i].to;
if (y == f) continue;
dfs1(y, x, deep + 1);
}
}
int main() {
int x, y;
while (~scanf("%d%d", &n, &r)) {
init();
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i < n; ++i) {
scanf("%d%d", &x, &y);
adde(x, y);
adde(y, x);
}
dfs1(r, r, 1);
d[r] = 1;
dfs(r, 0);
scanf("%d", &m);
int last = 0;
while (m--) {
scanf("%d%d", &x, &y);
x = (x + last) % n + 1;
y = (y + last) % n;
printf("%d\n", last = query(rt[x], 1, maxd, d[x], min(maxd, d[x] + y)));
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long N = 1e5 + 5;
vector<pair<int, int>> flat;
vector<vector<int>> edges(N);
vector<pair<int, int>> seg[N << 2];
int root, n, m, k, p, last, a[N], l[N], r[N], d[N];
void build(int s, int e, int idx) {
if (s == e) {
seg[idx].push_back(flat[s]);
return;
}
int mid = (s + e) / 2;
build(s, mid, 2 * idx + 1);
build(mid + 1, e, 2 * idx + 2);
merge(seg[2 * idx + 1].begin(), seg[2 * idx + 1].end(),
seg[2 * idx + 2].begin(), seg[2 * idx + 2].end(),
back_inserter(seg[idx]));
for (int i = 1; i < seg[idx].size(); i++)
seg[idx][i].second = min(seg[idx][i].second, seg[idx][i - 1].second);
}
int get_ans(int l, int r, int s, int e, int idx, int lvl) {
if (l > e || s > r) return 2e9;
if (s >= l && e <= r) {
auto it =
upper_bound(seg[idx].begin(), seg[idx].end(), make_pair(lvl, (int)2e9));
if (it == seg[idx].begin()) return 2e9;
it--;
return it->second;
}
int mid = (s + e) / 2;
return min(get_ans(l, r, s, mid, 2 * idx + 1, lvl),
get_ans(l, r, mid + 1, e, 2 * idx + 2, lvl));
}
void dfs(int node, int par) {
d[node] = d[par] + 1;
l[node] = flat.size();
flat.push_back({d[node], a[node]});
for (auto i : edges[node])
if (i != par) dfs(i, node);
r[node] = flat.size() - 1;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> root;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
cin >> p >> k;
edges[p].push_back(k);
edges[k].push_back(p);
}
dfs(root, 0);
build(0, n - 1, 0);
cin >> m;
while (m--) {
cin >> p >> k;
p = (p + last) % n + 1;
k = (k + last) % n;
cout << (last = get_ans(l[p], r[p], 0, n - 1, 0, d[p] + k)) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
using Node = vector<P>;
vector<vector<int>> adj;
vector<int> starttime, size, depth;
vector<P> ps;
vector<int> C;
int t = 0;
class SegmentTree {
public:
SegmentTree(int count) {
n = count;
data.resize(2 * n);
}
SegmentTree(std::vector<P> const &ps) {
n = ps.size();
data.resize(2 * n);
for (int i = 0; i < n; i++) {
data[i + n].push_back(ps[i]);
}
for (int idx = n - 1; idx > 0; idx--) {
std::merge(data[idx << 1].begin(), data[idx << 1].end(),
data[idx << 1 | 1].begin(), data[idx << 1 | 1].end(),
std::back_inserter(data[idx]));
int best = std::numeric_limits<int>::max();
for (auto &p : data[idx]) {
best = min(best, p.second);
p.second = best;
}
}
}
int minimum(int left, int right, int D) {
int ret = std::numeric_limits<int>::max();
left += n;
right += n;
auto p = make_pair(D, std::numeric_limits<int>::max());
while (left < right) {
if (left & 1) {
auto i = upper_bound(data[left].begin(), data[left].end(), p) -
data[left].begin();
if (i) {
ret = min(ret, data[left][i - 1].second);
}
left++;
}
if (right & 1) {
right--;
auto i = upper_bound(data[right].begin(), data[right].end(), p) -
data[right].begin();
if (i) {
ret = min(ret, data[right][i - 1].second);
}
}
left >>= 1;
right >>= 1;
}
return ret;
}
private:
int n;
std::vector<Node> data;
};
void dfs(int v, int p = -1, int d = 0) {
starttime[v] = t;
size[v] = 1;
depth[v] = d;
t++;
ps.push_back({d, C[v]});
for (auto u : adj[v]) {
if (u == p) continue;
dfs(u, v, d + 1);
size[v] += size[u];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int root;
cin >> root;
root--;
C.resize(n);
for (int i = 0; i < n; i++) {
cin >> C[i];
}
adj.resize(n);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
starttime.resize(n);
size.resize(n);
depth.resize(n);
dfs(root);
SegmentTree segtree(ps);
int q;
cin >> q;
int last = 0;
while (q-- > 0) {
int a, b;
cin >> a >> b;
int x = (a + last) % n;
int y = (b + last) % n;
last = segtree.minimum(starttime[x], starttime[x] + size[x], depth[x] + y);
cout << last << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> g[100005], gg[100005], v[100005], down[100005][17];
long long n, root, cnt, q, ans;
long long cc[100005], c[100005], ne[100005], depth[100005], childdepth[100005];
long long up[100005][17], val[100005][17], lefty[100005][17],
righty[100005][17];
long long segtree[17][400005], ltree[17][400005], rtree[17][400005];
void label(long long u, long long p, long long d) {
v[d].push_back(u);
for (auto vv : gg[u])
if (vv != p) label(vv, u, d + 1);
}
void dfs(long long u, long long p) {
depth[u] = depth[p] + 1;
childdepth[u] = depth[u];
up[u][0] = p;
down[p][0].push_back(u);
val[p][0] = min(val[p][0], c[u]);
lefty[p][0] = min(lefty[p][0], u);
righty[p][0] = max(righty[p][0], u);
for (long long i = 1; i <= 16; i++) {
up[u][i] = up[up[u][i - 1]][i - 1];
lefty[up[u][i]][i] = min(lefty[up[u][i]][i], u);
righty[up[u][i]][i] = max(righty[up[u][i]][i], u);
down[up[u][i]][i].push_back(u);
}
for (auto v : g[u])
if (v != p) {
dfs(v, u);
childdepth[u] = max(childdepth[u], childdepth[v]);
}
}
void build(long long id, long long l, long long r) {
if (l == r) {
for (long long i = 0; i <= 16; i++) {
segtree[i][id] = val[l][i];
ltree[i][id] = lefty[l][i];
rtree[i][id] = righty[l][i];
}
return;
}
long long m = (l + r) / 2;
build(id * 2, l, m);
build(id * 2 + 1, m + 1, r);
for (long long i = 0; i <= 16; i++) {
segtree[i][id] = min(segtree[i][id * 2], segtree[i][id * 2 + 1]);
ltree[i][id] = min(ltree[i][id * 2], ltree[i][id * 2 + 1]);
rtree[i][id] = max(rtree[i][id * 2], rtree[i][id * 2 + 1]);
}
}
long long get_min(long long id, long long l, long long r, long long tl,
long long tr, long long bit) {
if (l > tr || r < tl) return 1000000000000000000;
if (l >= tl && r <= tr) return segtree[bit][id];
long long m = (l + r) / 2;
return min(get_min(id * 2, l, m, tl, tr, bit),
get_min(id * 2 + 1, m + 1, r, tl, tr, bit));
}
long long get_l(long long id, long long l, long long r, long long tl,
long long tr, long long bit) {
if (l > tr || r < tl) return 1000000000000000000;
if (l >= tl && r <= tr) return ltree[bit][id];
long long m = (l + r) / 2;
return min(get_l(id * 2, l, m, tl, tr, bit),
get_l(id * 2 + 1, m + 1, r, tl, tr, bit));
}
long long get_r(long long id, long long l, long long r, long long tl,
long long tr, long long bit) {
if (l > tr || r < tl) return 0;
if (l >= tl && r <= tr) return rtree[bit][id];
long long m = (l + r) / 2;
return max(get_r(id * 2, l, m, tl, tr, bit),
get_r(id * 2 + 1, m + 1, r, tl, tr, bit));
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> root;
for (long long i = 1; i <= n; i++) cin >> cc[i];
for (long long i = 1; i <= n - 1; i++) {
long long a, b;
cin >> a >> b;
gg[a].push_back(b);
gg[b].push_back(a);
}
label(root, 0, 1);
for (long long i = 1; i <= 100000; i++) {
for (auto j : v[i]) ne[j] = ++cnt;
}
for (long long i = 1; i <= n; i++) c[ne[i]] = cc[i];
for (long long i = 1; i <= n; i++) {
for (auto &j : gg[i]) j = ne[j];
}
for (long long i = 1; i <= n; i++) g[ne[i]] = gg[i];
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j <= 16; j++) {
val[i][j] = 1000000000000000000;
lefty[i][j] = 1000000000000000000;
}
}
dfs(1, 0);
for (long long j = 1; j <= 16; j++) {
for (long long i = n; i >= 1; i--) {
long long r = 1000000000000000000;
for (auto v : down[i][j - 1]) r = min(r, val[v][j - 1]);
val[i][j] = min(r, val[i][j - 1]);
}
}
build(1, 1, n);
cin >> q;
while (q--) {
long long x, k;
cin >> x >> k;
x = (x + ans) % n + 1;
k = (k + ans) % n;
x = ne[x];
k = min(k, childdepth[x] - depth[x]);
ans = c[x];
long long curl = x, curr = x;
for (long long i = 16; i >= 0; i--)
if ((1 << i) <= k) {
k -= (1 << i);
ans = min(ans, get_min(1, 1, n, curl, curr, i));
long long tl = get_l(1, 1, n, curl, curr, i);
long long tr = get_r(1, 1, n, curl, curr, i);
curl = tl;
curr = tr;
}
cout << ans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
const int INF = 2e9 + 10;
int a[N], sz;
int rot[N * 50], dep[N];
struct node {
int l, r, val;
void init() {
l = r = 0;
val = INF;
}
} nd[N * 50];
vector<int> G[N];
void update(int p, int val, int l, int r, int &rt) {
nd[rt = ++sz].init();
nd[rt].val = val;
if (l != r) {
int m = l + r >> 1;
if (p <= m)
update(p, val, l, m, nd[rt].l);
else
update(p, val, m + 1, r, nd[rt].r);
nd[rt].val = min(nd[nd[rt].l].val, nd[nd[rt].r].val);
}
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return nd[rt].val;
int m = l + r >> 1;
int res = INF;
if (L <= m) res = min(query(L, R, l, m, nd[rt].l), res);
if (R > m) res = min(query(L, R, m + 1, r, nd[rt].r), res);
return res;
}
int merge_up(int u, int v) {
if (!u) return v;
if (!v) return u;
int t = ++sz;
nd[t].l = merge_up(nd[u].l, nd[v].l);
nd[t].r = merge_up(nd[u].r, nd[v].r);
nd[t].val = min(nd[u].val, nd[v].val);
return t;
}
void dfs(int u, int fa) {
dep[u] = dep[fa] + 1;
update(dep[u], a[u], 1, N, rot[u]);
for (int v : G[u]) {
if (v != fa) {
dfs(v, u);
rot[u] = merge_up(rot[u], rot[v]);
}
}
}
int main() {
nd[0].init();
sz = 0;
int n, r;
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
dfs(r, 0);
int q, last = 0;
scanf("%d", &q);
while (q--) {
int pp, qq;
scanf("%d%d", &pp, &qq);
pp = ((pp + last) % n) + 1;
qq = (qq + last) % n;
last = query(dep[pp], min(dep[pp] + qq, N), 1, N, rot[pp]);
printf("%d\n", last);
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long long N = 1e5 + 5;
bool vis[N];
vector<pair<int, int>> flat;
vector<vector<int>> edges(N);
vector<pair<int, int>> seg[N << 2];
long long root, n, m, k, p, last, a[N], l[N], r[N], d[N];
void build(int s, int e, int idx) {
if (s == e) {
seg[idx].push_back(flat[s]);
return;
}
int mid = (s + e) / 2;
build(s, mid, 2 * idx + 1);
build(mid + 1, e, 2 * idx + 2);
merge(seg[2 * idx + 1].begin(), seg[2 * idx + 1].end(),
seg[2 * idx + 2].begin(), seg[2 * idx + 2].end(),
back_inserter(seg[idx]));
for (int i = 1; i < seg[idx].size(); i++)
seg[idx][i].second = min(seg[idx][i].second, seg[idx][i - 1].second);
}
int get_ans(int l, int r, int s, int e, int idx, int lvl) {
if (l > e || s > r) return 2e9;
if (s >= l && e <= r) {
auto it =
upper_bound(seg[idx].begin(), seg[idx].end(), make_pair(lvl, (int)2e9));
if (it == seg[idx].begin()) return 2e9;
it--;
return it->second;
}
int mid = (s + e) / 2;
return min(get_ans(l, r, s, mid, 2 * idx + 1, lvl),
get_ans(l, r, mid + 1, e, 2 * idx + 2, lvl));
}
void dfs(int node, int lvl) {
vis[node] = 1;
d[node] = lvl;
l[node] = flat.size();
flat.push_back({lvl, a[node]});
for (auto i : edges[node])
if (!vis[i]) dfs(i, lvl + 1);
r[node] = flat.size() - 1;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> root;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
cin >> p >> k;
edges[p].push_back(k);
edges[k].push_back(p);
}
dfs(root, 0);
build(0, n - 1, 0);
cin >> m;
while (m--) {
cin >> p >> k;
p = (p + last) % n + 1;
k = (k + last) % n;
last = get_ans(l[p], r[p], 0, n - 1, 0, d[p] + k);
cout << last << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rd(time(0));
vector<long long> v(100010), val(100010), con[100010], st(100010, 0),
en(100010, 0), d(100010, 0);
pair<long long, long long> t[20][100010];
long long cur = 0;
void build(long long c, long long l, long long r) {
if (l == r)
t[c][l] = {d[l], val[l]};
else {
long long mid = (l + r) / 2;
build(c + 1, l, mid);
build(c + 1, mid + 1, r);
long long i = l, j = mid + 1, k = l;
while (i <= mid && j <= r) {
if (t[c + 1][i].first < t[c + 1][j].first)
t[c][k++] = t[c + 1][i++];
else
t[c][k++] = t[c + 1][j++];
}
while (i <= mid) t[c][k++] = t[c + 1][i++];
while (j <= r) t[c][k++] = t[c + 1][j++];
for (i = l + 1; i <= r; ++i)
t[c][i].second = min(t[c][i].second, t[c][i - 1].second);
}
}
long long query(long long c, long long l, long long r, long long l1,
long long r1, long long k) {
if (r1 < l || l1 > r) return 1000000007;
if (l >= l1 && r <= r1) {
pair<long long, long long> temp = {k, 1000000007};
long long w = upper_bound(t[c] + l, t[c] + r + 1, temp) - t[c];
if (w == l) return 1000000007;
return t[c][w - 1].second;
} else {
long long mid = (l + r) / 2;
return min(query(c + 1, l, mid, l1, r1, k),
query(c + 1, mid + 1, r, l1, r1, k));
}
}
void dfs(long long node, long long par, long long dep) {
st[node] = ++cur;
d[st[node]] = dep;
for (auto i : con[node]) {
if (i != par) dfs(i, node, dep + 1);
}
en[node] = cur;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, r, m, l, x, k;
cin >> n >> r;
for (long long i = 1; i < n + 1; i++) cin >> v[i];
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
con[u].push_back(v);
con[v].push_back(u);
}
dfs(r, -1, 0);
for (long long i = 1; i <= n; i++) val[st[i]] = v[i];
build(1, 1, cur);
cin >> m;
l = 0;
while (m--) {
cin >> x >> k;
x = (x + l) % n + 1;
k = (k + l) % n;
l = query(1, 1, cur, st[x], en[x], k + d[st[x]]);
cout << l << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[100022], st[100022], en[100022], lev[100022], curr = 0;
vector<int> v[100022];
vector<pair<int, int> > Arr;
vector<pair<int, int> > tree[400002];
void dfs(int node, int par, int le) {
lev[node] = le;
st[node] = curr;
Arr[curr++] = make_pair(le, arr[node]);
for (int i = 0; i < v[node].size(); i++) {
int u = v[node][i];
if (u == par) continue;
dfs(u, node, le + 1);
}
en[node] = curr;
}
void build(int node, int l, int r) {
if (l == r) {
tree[node].push_back(Arr[l]);
return;
}
int mid = (l + r) / 2;
build(2 * node, l, mid);
build(2 * node + 1, mid + 1, r);
tree[node].resize(tree[2 * node].size() + tree[2 * node + 1].size());
merge(tree[2 * node].begin(), tree[2 * node].end(),
tree[2 * node + 1].begin(), tree[2 * node + 1].end(),
tree[node].begin());
for (int i = 1; i < tree[node].size(); i++)
tree[node][i].second = min(tree[node][i - 1].second, tree[node][i].second);
}
int query(int node, int l, int r, int qs, int qe, int le) {
if (qe < l || qs > r) return INT_MAX;
if (qs <= l && qe >= r) {
int in = lower_bound(tree[node].begin(), tree[node].end(),
make_pair(le + 1, INT_MIN)) -
tree[node].begin();
if (in == 0) return INT_MAX;
return tree[node][in - 1].second;
}
int mid = (l + r) / 2;
return min(query(2 * node, l, mid, qs, qe, le),
query(2 * node + 1, mid + 1, r, qs, qe, le));
}
int main() {
int r, n, i;
scanf("%d%d", &n, &r);
for (i = 1; i <= n; i++) scanf("%d", &arr[i]);
for (i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
Arr.resize(n + 2);
dfs(r, -1, 0);
build(1, 0, curr - 1);
int q, last = 0;
cin >> q;
while (q--) {
int a, b;
scanf("%d%d", &a, &b);
int x = (a + last) % n + 1;
int k = (b + last) % n;
last = query(1, 0, curr - 1, st[x], en[x] - 1, lev[x] + k);
printf("%d\n", last);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, r, a[N], d[N], x, y, m, tin[N], tout[N], timer, k;
vector<int> g[N], q[N], c[4 * N];
void dfs(int v, int pr = -1, int depth = 1) {
tin[v] = ++timer;
d[v] = depth;
k = max(k, depth);
q[depth].push_back(v);
for (auto to : g[v]) {
if (to != pr) {
dfs(to, v, depth + 1);
}
}
tout[v] = timer;
}
struct item {
item *l, *r;
int mn;
item() {
l = r = nullptr;
mn = 2e9;
}
};
typedef item *pitem;
pitem t[4 * N];
inline int mn(pitem v) { return v ? v->mn : 2e9; }
void update(pitem v, int l, int r, int pos, int val) {
if (l == r) {
v->mn = val;
return;
}
int mid = (r + l) >> 1;
if (pos <= mid) {
if (!v->l) {
v->l = new item();
}
update(v->l, l, mid, pos, val);
} else {
if (!v->r) {
v->r = new item();
}
update(v->r, mid + 1, r, pos, val);
}
v->mn = min(mn(v->l), mn(v->r));
}
void build(int v, int l, int r) {
t[v] = new item();
if (l == r) {
for (auto it : q[l]) {
update(t[v], 1, n, tin[it], a[it]);
c[v].push_back(it);
}
return;
}
int mid = (r + l) >> 1;
build(v + v, l, mid);
build(v + v + 1, mid + 1, r);
for (auto it : c[v + v]) {
c[v].push_back(it);
}
for (auto it : c[v + v + 1]) {
c[v].push_back(it);
}
for (auto it : c[v]) {
update(t[v], 1, n, tin[it], a[it]);
}
}
int gett(pitem v, int l, int r, int tl, int tr) {
if (!v || l > r || l > tr || tl > r) {
return 2e9;
}
if (tl <= l && r <= tr) {
return v->mn;
}
int mid = (r + l) >> 1;
return min(gett(v->l, l, mid, tl, tr), gett(v->r, mid + 1, r, tl, tr));
}
int get(int v, int l, int r, int tl, int tr, int x, int y) {
if (l > r || l > tr || tl > r) {
return 2e9;
}
if (tl <= l && r <= tr) {
return gett(t[v], 1, n, x, y);
}
int mid = (r + l) >> 1;
return min(get(v + v, l, mid, tl, tr, x, y),
get(v + v + 1, mid + 1, r, tl, tr, x, y));
}
void dfs1(int v, int l, int r) {
cout << l << " " << r << " : ";
for (auto it : c[v]) {
cout << it << " ";
}
cout << "\n";
if (l == r) {
return;
}
int mid = (r + l) >> 1;
dfs1(v + v, l, mid);
dfs1(v + v + 1, mid + 1, r);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> r;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(r);
build(1, 1, k);
cin >> m;
int last = 0;
for (int i = 1; i <= m; i++) {
cin >> x >> y;
x = (last + x) % n + 1, y = (last + y) % n + 1;
cout << (last = get(1, 1, k, d[x], min(k, d[x] + y - 1), tin[x], tout[x]))
<< "\n";
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int n, m, root, a[100005];
int l[100005], r[100005];
int lvl[100005];
vector<vector<int>> tree;
vector<vector<pair<int, int>>> seg(400005);
vector<pair<int, int>> v;
void dfs(int node, int par) {
lvl[node] = lvl[par] + 1;
l[node] = v.size();
v.push_back({lvl[node], a[node]});
for (auto &i : tree[node])
if (i != par) dfs(i, node);
r[node] = v.size() - 1;
}
void build(int node, int s, int e) {
if (s == e) {
seg[node].push_back(v[s]);
return;
}
int mid = s + e >> 1;
build(node << 1, s, mid);
build(node << 1 | 1, mid + 1, e);
merge(seg[node << 1].begin(), seg[node << 1].end(),
seg[node << 1 | 1].begin(), seg[node << 1 | 1].end(),
back_inserter(seg[node]));
for (int i = 1; i < seg[node].size(); i++)
seg[node][i].second = min(seg[node][i].second, seg[node][i - 1].second);
}
int get(int node, int s, int e, int a, int b, int k) {
if (s > b || e < a) return 2e9;
if (a <= s && e <= b) {
auto it =
upper_bound(seg[node].begin(), seg[node].end(), make_pair(k, (int)2e9));
if (it == seg[node].begin()) return 2e9;
return (--it)->second;
}
int mid = s + e >> 1;
return min(get(node << 1, s, mid, a, b, k),
get(node << 1 | 1, mid + 1, e, a, b, k));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> root;
for (int i = 1; i <= n; i++) cin >> a[i];
tree.resize(n + 5);
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
tree[a].push_back(b);
tree[b].push_back(a);
}
dfs(root, root);
build(1, 0, n - 1);
cin >> m;
int lst = 0;
while (m--) {
int x, k;
cin >> x >> k;
x = (x + lst) % n + 1;
k = (k + lst) % n;
cout << (lst = get(1, 0, n - 1, l[x], r[x], lvl[x] + k)) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100, mod = 1e9 + 7, sz = 400, inf = 1e9;
vector<int> t[4 * N], mn[4 * N];
int b[N], a[N], p[N], h[N], left228[N], right228[N];
bool cmp(int i, int j) { return h[i] < h[j]; }
void build(int v, int l, int r) {
if (l == r - 1) {
t[v].push_back(l);
mn[v].push_back(a[l]);
} else {
int m = (l + r) / 2;
build(2 * v, l, m);
build(2 * v + 1, m, r);
merge((t[2 * v]).begin(), (t[2 * v]).end(), (t[2 * v + 1]).begin(),
(t[2 * v + 1]).end(), back_inserter(t[v]), cmp);
for (auto u : t[v]) {
if (mn[v].empty())
mn[v].push_back(a[u]);
else
mn[v].push_back(min(a[u], mn[v].back()));
}
}
}
int res(int v, int k) {
if (h[t[v][0]] > k) return inf;
int l = 0, r = t[v].size(), m;
while (r - l > 1) {
m = (l + r) / 2;
if (h[t[v][m]] > k)
r = m;
else
l = m;
}
return mn[v][l];
}
int get(int v, int l, int r, int vl, int vr, int k) {
if (l >= vr || vl >= r) return inf;
if (vl <= l && r <= vr) {
return res(v, k);
}
int m = (l + r) / 2;
return min(get(2 * v, l, m, vl, vr, k), get(2 * v + 1, m, r, vl, vr, k));
}
vector<int> v[N], o;
void dfs(int x, int pr) {
p[x] = o.size();
a[p[x]] = b[x];
left228[p[x]] = o.size();
if (pr != -1) {
h[p[x]] = h[p[pr]] + 1;
}
o.push_back(x);
for (auto u : v[x]) {
if (u != pr) dfs(u, x);
}
right228[p[x]] = o.size() - 1;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, r;
cin >> n >> r;
r--;
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < n - 1; i++) {
int f, t;
cin >> f >> t;
f--, t--;
v[f].push_back(t);
v[t].push_back(f);
}
dfs(r, -1);
build(1, 0, n);
int m, last = 0;
cin >> m;
while (m--) {
int p1, q1;
cin >> p1 >> q1;
int x = p[(p1 + last) % n], k = (q1 + last) % n;
last = get(1, 0, n, left228[x], right228[x] + 1, h[x] + k);
cout << last << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 4;
vector<pair<int, int>> v, st[4 * N];
int in[N], out[N], val[N], dep[N];
vector<int> adj[N];
void dfs(int u, int p, int d) {
dep[u] = d;
in[u] = v.size();
v.emplace_back(dep[u], val[u]);
for (int c : adj[u]) {
if (c == p) continue;
dfs(c, u, d + 1);
}
out[u] = v.size() - 1;
}
void build(int p, int l, int r) {
if (l == r) {
st[p] = {v[l]};
} else {
int mid = (l + r) / 2;
build(p * 2, l, mid);
build(p * 2 + 1, mid + 1, r);
merge(st[p * 2].begin(), st[p * 2].end(), st[p * 2 + 1].begin(),
st[p * 2 + 1].end(), back_inserter(st[p]));
for (int i = 1; i < st[p].size(); ++i)
st[p][i].second = min(st[p][i].second, st[p][i - 1].second);
}
}
int query(int p, int l, int r, int i, int j, int mxDep) {
if (r < i || l > j || i > j) return 2e9;
if (l >= i && r <= j) {
auto it =
upper_bound((st[p]).begin(), (st[p]).end(), make_pair(mxDep, (int)2e9));
if (it == st[p].begin()) return 2e9;
return (--it)->second;
}
int mid = (l + r) / 2;
int p1 = query(p * 2, l, mid, i, j, mxDep);
int p2 = query(p * 2 + 1, mid + 1, r, i, j, mxDep);
return min(p1, p2);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n, r;
cin >> n >> r;
for (int i = 1; i <= n; ++i) cin >> val[i];
for (int i = 1; i < n; ++i) {
int u, c;
cin >> u >> c;
adj[u].push_back(c);
adj[c].push_back(u);
}
dfs(r, -1, 0);
build(1, 0, n - 1);
int q, last = 0;
cin >> q;
while (q--) {
int x, k;
cin >> x >> k;
x = (x + last) % n + 1;
k = (k + last) % n;
last = query(1, 0, n - 1, in[x], out[x], dep[x] + k);
cout << last << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, root, m;
int a[100100];
int h[100100];
vector<int> g[100100];
int arr[200100];
int N, tin[100100], tout[100100];
vector<pair<int, int> > t[200100 * 4];
void dfs(int v, int par = -1, int len = 0) {
h[v] = len;
tin[v] = ++N;
arr[N] = v;
for (int to : g[v]) {
if (to != par) {
dfs(to, v, len + 1);
}
}
tout[v] = ++N;
arr[N] = v;
}
void build(int v, int l, int r) {
if (l == r) {
int node = arr[l];
t[v].push_back(make_pair(h[node], a[node]));
return;
}
int mid = (l + r) >> 1;
build(v + v, l, mid), build(v + v + 1, mid + 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]));
for (int i = 1; i < ((int)(t[v]).size()); ++i) {
t[v][i].second = min(t[v][i - 1].second, t[v][i].second);
}
}
int get(int v, int l, int r, int L, int R, int k) {
if (r < L || R < l) return 2e9;
if (L <= l && r <= R) {
int lf = 0, rg = ((int)(t[v]).size()) - 1, i = -1;
while (lf <= rg) {
int avg = (lf + rg) >> 1;
if (t[v][avg].first <= k)
i = avg, lf = avg + 1;
else
rg = avg - 1;
}
return i == -1 ? 2e9 : t[v][i].second;
}
int mid = (l + r) >> 1;
return min(get(v + v, l, mid, L, R, k), get(v + v + 1, mid + 1, r, L, R, k));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n >> root;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(root);
build(1, 1, N);
cin >> m;
int ans = 0;
for (int i = 1; i <= m; ++i) {
int p, q;
cin >> p >> q;
int x = (p + ans) % n + 1;
int k = (q + ans) % n;
ans = get(1, 1, N, tin[x], tout[x], h[x] + k);
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int Pow(int a, int b, int md, int ans = 1) {
for (; b; b >>= 1, a = a * a % md)
if (b & 1) ans = ans * a % md;
return ans % md;
}
const int MAXN = 1e5 + 10;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
vector<int> adj[MAXN], mn[MAXN << 2];
vector<pair<int, int> > seg[MAXN << 2];
int A[MAXN], V[MAXN], L[MAXN], R[MAXN], H[MAXN], rt, n, timer = 1, q;
void DFS(int v, int p = -1) {
L[v] = timer++;
V[L[v]] = v;
for (int u : adj[v]) {
if (u == p) continue;
H[u] = H[v] + 1;
DFS(u, v);
}
R[v] = timer;
}
void build(int id = 1, int l = 0, int r = MAXN) {
if (r - l == 1) {
seg[id].push_back({H[V[l]], V[l]});
mn[id].push_back(A[V[l]]);
return;
}
int mid = (l + r) >> 1;
build(id << 1, l, mid);
build(id << 1 | 1, mid, r);
merge((seg[id << 1]).begin(), (seg[id << 1]).end(),
(seg[id << 1 | 1]).begin(), (seg[id << 1 | 1]).end(),
back_inserter(seg[id]));
for (int i = 0; i < (int)seg[id].size(); i++) {
if ((int)mn[id].size())
mn[id].push_back(min(mn[id].back(), A[seg[id][i].second]));
else
mn[id].push_back(A[seg[id][i].second]);
}
}
int query(int ql, int qr, int val, int id = 1, int l = 0, int r = MAXN) {
if (qr <= l || r <= ql) return INF;
if (ql <= l && r <= qr) {
auto it = upper_bound((seg[id]).begin(), (seg[id]).end(),
pair<int, int>(val, INF));
if (it == seg[id].begin()) return INF;
it--;
return mn[id][it - seg[id].begin()];
}
int mid = (l + r) >> 1;
return min(query(ql, qr, val, id << 1, l, mid),
query(ql, qr, val, id << 1 | 1, mid, r));
}
int main() {
scanf("%d%d", &n, &rt);
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
}
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
DFS(rt);
scanf("%d", &q);
build();
int last = 0;
while (q--) {
int v, k;
scanf("%d%d", &v, &k);
v = (v + last) % n + 1;
k = (k + last) % n;
printf("%d\n", last = query(L[v], R[v], H[v] + k));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 7;
vector<int> sortedH;
vector<int> g[MAXN];
int n, root, a[MAXN], l[MAXN], r[MAXN], h[MAXN];
vector<int> t[4 * MAXN];
inline bool isller(int a, int b, int c, int d) {
return (a <= c && c <= b) || (a <= d && d <= b) || (c <= a && a <= d);
}
inline bool AinB(int a, int b, int c, int d) { return (c <= a && b <= d); }
struct PMin {
vector<int> t;
inline void build(vector<int> &vert) {
for (int i = 0; i < vert.size(); ++i)
if (i)
t[i] = min(a[vert[i]], t[i - 1]);
else
t[i] = a[vert[i]];
}
inline int get(int r) {
if (r >= 0)
return t[r];
else
return (int)2e9;
}
};
PMin getmin[4 * MAXN];
bool cmp(int a, int b) { return h[a] < h[b]; }
void build(int v, int tl, int tr) {
vector<int> vert;
for (int i = tl; i <= tr; ++i) vert.push_back(sortedH[i]);
sort(vert.begin(), vert.end(), cmp);
getmin[v].t.resize(tr - tl + 2);
getmin[v].build(vert);
for (int u : vert) t[v].push_back(h[u]);
if (tl != tr) {
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
}
}
inline int cnt(int v, int tl, int tr, int l, int r, int rx) {
if (!isller(tl, tr, l, r))
return (int)2e9;
else if (AinB(tl, tr, l, r))
return getmin[v].get(
(int)(upper_bound(t[v].begin(), t[v].end(), rx) - t[v].begin()) - 1);
else {
int tm = (tl + tr) / 2;
return min(cnt(2 * v, tl, tm, l, r, rx),
cnt(2 * v + 1, tm + 1, tr, l, r, rx));
}
}
void dfs(int v, int p) {
h[v] = (p == -1 ? 0 : h[p] + 1);
l[v] = sortedH.size();
sortedH.push_back(v);
for (int u : g[v])
if (u != p) dfs(u, v);
r[v] = sortedH.size();
--r[v];
}
void solve() {
cin >> n >> root;
--root;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
int m;
cin >> m;
int last = 0;
dfs(root, -1);
build(1, 0, sortedH.size() - 1);
for (int i = 0; i < m; ++i) {
int p, q;
cin >> p >> q;
int x = (p + last) % n, k = (q + last) % n;
last = cnt(1, 0, sortedH.size() - 1, l[x], r[x], h[x] + k);
cout << last << "\n";
}
return;
}
signed main() {
ios_base::sync_with_stdio(false);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 101;
int dfn[N], a[N];
int head[N], wd[N];
int id, e, n, m, deep[N];
int rt, siz[N];
struct Edge {
int to, nex;
} edge[N * 2];
void add(int from, int to) {
edge[++e].nex = head[from];
edge[e].to = to;
head[from] = e;
}
void dfs(int now, int fath) {
deep[now] = deep[fath] + 1;
dfn[now] = ++id;
wd[id] = now;
siz[now] = 1;
for (int i = head[now]; i; i = edge[i].nex) {
int v = edge[i].to;
if (v == fath) continue;
dfs(v, now);
siz[now] += siz[v];
}
}
int tot;
struct node {
int lch, rch, val, val2, key, val3;
node() {
lch = rch = key = 0;
val = val2 = val3 = 2e9;
}
} t[N * 100];
struct Treap {
int root;
Treap() { root = 0; }
int New(int val, int val2) {
t[++tot].val = val;
t[tot].val2 = t[tot].val3 = val2;
t[tot].key = rand();
t[tot].lch = t[tot].rch = 0;
return tot;
}
void update(int now) {
t[now].val3 = t[now].val2;
t[now].val3 = min(t[now].val3, t[t[now].lch].val3);
t[now].val3 = min(t[now].val3, t[t[now].rch].val3);
}
void split(int now, int &a, int &b, int val) {
if (now == 0) {
a = b = 0;
return;
}
if (t[now].val <= val)
a = now, split(t[now].rch, t[a].rch, b, val);
else
b = now, split(t[now].lch, a, t[b].lch, val);
update(now);
}
void merge(int &now, int a, int b) {
if (a == 0 || b == 0) {
now = a + b;
return;
}
if (t[a].key <= t[b].key)
now = a, merge(t[now].rch, t[a].rch, b);
else
now = b, merge(t[now].lch, a, t[b].lch);
update(now);
}
void insert(int val, int val2) {
int x, y, z = New(val, val2);
split(root, x, y, val - 1);
merge(x, x, z);
merge(root, x, y);
}
int query(int l, int r) {
int x, y, z, res;
split(root, x, y, r);
split(x, x, z, l - 1);
res = t[z].val3;
merge(x, x, z);
merge(root, x, y);
return res;
}
} c[N << 2];
void build(int p, int l, int r) {
for (int i = l; i <= r; i++) c[p].insert(deep[wd[i]], a[wd[i]]);
if (l == r) return;
int mid = (l + r) >> 1;
build(p << 1, l, mid);
build(p << 1 | 1, mid + 1, r);
}
int query(int p, int l, int r, int nl, int nr, int ql, int qr) {
int res = 1e9;
if (nl <= l && r <= nr) return c[p].query(ql, qr);
int mid = (l + r) >> 1;
if (nl <= mid) res = min(res, query(p << 1, l, mid, nl, nr, ql, qr));
if (nr > mid) res = min(res, query(p << 1 | 1, mid + 1, r, nl, nr, ql, qr));
return res;
}
signed main() {
int las = 0;
scanf("%d%d", &n, &rt);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
dfs(rt, 0);
build(1, 1, n);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int x, k;
scanf("%d%d", &x, &k);
x = (x + las) % n + 1;
k = (k + las) % n;
las = query(1, 1, n, dfn[x], dfn[x] + siz[x] - 1, deep[x], deep[x] + k);
printf("%d\n", las);
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MXN = 100005;
vector<int> adj[MXN];
map<int, int> tree[2 * MXN];
int a[MXN], d[MXN], tin[MXN], tout[MXN], timer;
void dfs(int x, int p) {
tin[x] = timer++;
for (int y : adj[x]) {
if (y == p) continue;
d[y] = d[x] + 1;
dfs(y, x);
}
tout[x] = timer;
}
int get(map<int, int>& mp, int d) {
auto it = mp.upper_bound(d);
if (it == mp.begin()) return 1e9;
return prev(it)->second;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n, r;
cin >> n >> r;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 2; i <= n; ++i) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(r, 0);
for (int i = 1; i <= n; ++i) {
tree[tin[i] + n][d[i]] = a[i];
}
for (int i = n - 1; i; --i) {
tree[i] = tree[2 * i + 1];
for (auto& [d, v] : tree[2 * i]) {
int& ref = tree[i][d];
if (ref) {
ref = min(ref, v);
} else {
ref = v;
}
}
int mn = 1e9;
for (auto& [d, v] : tree[i]) {
mn = min(mn, v);
v = mn;
}
}
int last = 0;
int m;
cin >> m;
for (int i = 0; i < m; ++i) {
int x, k;
cin >> x >> k;
x = (x + last) % n + 1;
k = (k + last) % n;
last = 1e9;
for (int l = tin[x] + n, r = tout[x] + n; l < r; l /= 2, r /= 2) {
if (l % 2) last = min(last, get(tree[l++], d[x] + k));
if (r % 2) last = min(last, get(tree[--r], d[x] + k));
}
cout << last << '\n';
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,sse3,sse4,popcnt,abm,mmx")
const int N = (int)1e5 + 7, inf = (int)1e9 + 7, mod = (int)1e9 + 7;
const long long linf = (long long)1e18 + 7;
const int dx[] = {-1, 0, 1, 0, 1, -1, -1, 1},
dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
using namespace std;
int get_int() {
char x = getchar();
while (!isdigit(x)) x = getchar();
int res = 0;
while (isdigit(x)) res = res * 10 + x - '0', x = getchar();
return res;
}
int n, St;
int a[N];
vector<int> g[N];
int tin[N], tout[N];
int lvl[N], id[N];
int tmr;
void dfs(int v = St, int p = 0) {
tin[v] = ++tmr;
id[tmr] = v;
for (auto to : g[v]) {
if (to != p) {
lvl[to] = lvl[v] + 1;
dfs(to, v);
}
}
tout[v] = tmr;
}
struct tree {
vector<pair<int, int> > t[N << 2];
vector<int> mn[N << 2];
void build(int v = 1, int tl = 1, int tr = n) {
if (tl == tr) {
t[v].push_back({lvl[id[tl]], a[id[tl]]});
mn[v].push_back(a[id[tl]]);
return;
}
int tm = tl + tr >> 1;
build((v << 1), tl, tm);
build((v << 1 | 1), tm + 1, tr);
t[v].resize(tr - tl + 1);
mn[v].resize(tr - tl + 1);
merge(t[(v << 1)].begin(), t[(v << 1)].end(), t[(v << 1 | 1)].begin(),
t[(v << 1 | 1)].end(), t[v].begin());
for (int i = 0; i < (int)t[v].size(); i++) {
mn[v][i] = i ? min(t[v][i].second, mn[v][i - 1]) : t[v][i].second;
}
}
int get(int l, int r, int x, int v = 1, int tl = 1, int tr = n) {
if (l <= tl && tr <= r) {
int p = upper_bound(t[v].begin(), t[v].end(), make_pair(x, inf)) -
t[v].begin();
if (p == 0) return inf;
return mn[v][p - 1];
}
int tm = tl + tr >> 1;
if (tm < l) return get(l, r, x, (v << 1 | 1), tm + 1, tr);
if (r <= tm) return get(l, r, x, (v << 1), tl, tm);
return min(get(l, r, x, (v << 1), tl, tm),
get(l, r, x, (v << 1 | 1), tm + 1, tr));
}
} t;
int main() {
n = get_int(), St = get_int();
for (int i = 1; i <= n; i++) {
a[i] = get_int();
}
for (int i = 1; i < n; i++) {
int v = get_int(), u = get_int();
g[v].push_back(u);
g[u].push_back(v);
}
dfs();
t.build();
int last = 0, m = get_int();
for (int i = 1; i <= m; i++) {
int p = get_int(), q = get_int();
p = ((p + last) % n) + 1;
q = (q + last) % n;
last = t.get(tin[p], tout[p], lvl[p] + q);
printf("%d\n", last);
}
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const int LOG = 20;
const int INF = 1e9;
int N, R, M, timer = 0, IDX = 0;
int A[MAX], level[MAX], in[MAX], sub[MAX], b[MAX];
int table[20 * MAX][LOG + 1], D[MAX];
vector<int> v[MAX], idx[20 * MAX];
vector<pair<int, int> > s[4 * MAX];
pair<int, int> back[20 * MAX];
void dfs(int cur, int parent) {
level[cur] = level[parent] + 1;
in[cur] = ++timer;
b[timer] = cur;
sub[cur] = 1;
for (auto it : v[cur]) {
if (it != parent) {
dfs(it, cur);
sub[cur] = sub[cur] + sub[it];
}
}
}
void build(int l, int r, int node) {
assert(node < 4 * MAX);
if (l == r) {
s[node].push_back({level[b[l]], A[b[l]]});
idx[node].push_back(++IDX);
back[IDX] = {node, 0};
table[IDX][0] = A[b[l]];
return;
}
int mid = (l + r) >> 1;
build(l, mid, node << 1);
build(mid + 1, r, 1 | node << 1);
int X = 0, Y = 0, lc = node << 1, rc = 1 | (node << 1);
while (true) {
if (X == s[lc].size() and Y == s[rc].size())
break;
else if (X == s[lc].size())
s[node].push_back(s[rc][Y++]);
else if (Y == s[rc].size())
s[node].push_back(s[lc][X++]);
else if (s[lc][X].first <= s[rc][Y].first)
s[node].push_back(s[lc][X++]);
else
s[node].push_back(s[rc][Y++]);
}
for (int i = 0; i < s[node].size(); ++i) {
idx[node].push_back(++IDX);
back[IDX] = {node, i};
table[IDX][0] = s[node][i].second;
}
}
int solve(int node, int L, int R) {
if (s[node][0].first > R) return INF;
if (s[node][s[node].size() - 1].first < L) return INF;
int X = 0, Y = 0;
X = lower_bound(s[node].begin(), s[node].end(), make_pair(L, 0)) -
s[node].begin();
if (s[node][s[node].size() - 1].first <= R)
Y = s[node].size() - 1;
else
Y = lower_bound(s[node].begin(), s[node].end(), make_pair(R + 1, 0)) -
s[node].begin() - 1;
assert(X < s[node].size() and X >= 0);
assert(Y < s[node].size() and Y >= 0);
assert(Y >= X);
int tableIdx = idx[node][X], c = D[Y - X + 1];
int ans = table[tableIdx][c];
assert(Y - X + 1 <= N);
if (X + (1 << c) - 1 == Y) return ans;
X = Y - (1 << c) + 1;
assert(X < s[node].size() and X >= 0);
assert(Y < s[node].size() and Y >= 0);
assert(Y >= X);
tableIdx = idx[node][X], c = D[Y - X + 1];
assert(Y - X + 1 <= N);
ans = min(ans, table[tableIdx][c]);
return ans;
}
int query(int l, int r, int node, int ql, int qr, int L, int R) {
if (l > qr or r < ql) return INF;
if (l >= ql and r <= qr) return solve(node, L, R);
int mid = (l + r) >> 1;
return min(query(l, mid, node << 1, ql, qr, L, R),
query(mid + 1, r, 1 | node << 1, ql, qr, L, R));
}
signed main() {
ios_base::sync_with_stdio(false);
cin >> N >> R;
D[1] = 0;
for (int i = 2; i <= N; ++i) {
D[i] = D[i - 1];
if (((i - 1) & i) == 0) ++D[i];
}
for (int i = 1; i <= N; ++i) cin >> A[i];
for (int i = 1; i < N; ++i) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(R, 0);
build(1, N, 1);
assert(IDX < 20 * MAX);
for (int i = 1; i < LOG; ++i) {
for (int j = 1; j <= IDX; ++j) {
table[j][i] = INF;
}
}
for (int i = 1; i < LOG; ++i) {
for (int j = 1; j <= IDX; ++j) {
auto X = back[j];
int nxt = X.second + (1 << (i - 1));
if (nxt >= s[X.first].size()) continue;
nxt = idx[X.first][nxt];
table[j][i] = min(table[j][i - 1], table[nxt][i - 1]);
}
}
cin >> M;
int last = 0;
for (int i = 1; i <= M; ++i) {
int x, k;
cin >> x >> k;
x = (x + last) % N + 1;
k = (k + last) % N;
last = query(1, N, 1, in[x], in[x] + sub[x] - 1, level[x], level[x] + k);
cout << last << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dep[100005];
int id[100005];
int val[100005];
vector<int> s[100005];
vector<int> level[100005];
vector<int> inid[100005];
vector<int> tree[100005][20];
int dfs_id;
int dp[100005][20];
int bi[20];
int SZ[100005];
int MAX;
int dfs(int u, int fa, int add) {
int sum = 1;
id[u] = ++dfs_id;
dep[u] = add;
dp[u][0] = val[u];
level[add].push_back(u);
inid[add].push_back(dfs_id);
MAX = max(MAX, add);
for (auto v : s[u]) {
if (v == fa) continue;
sum += dfs(v, u, add + 1);
}
return SZ[u] = sum;
}
void build(vector<int>& T, int L, int V, int root, int l, int r) {
if (l == r) {
T[root] = dp[level[L][l]][V];
return;
}
int m = (l + r) / 2;
build(T, L, V, root * 2, l, m);
build(T, L, V, root * 2 + 1, m + 1, r);
T[root] = min(T[root * 2], T[root * 2 + 1]);
}
int query(vector<int>& T, int root, int l, int r, int L, int R) {
if (r < L || l > R) return 2000000000;
if (L <= l && r <= R) return T[root];
int m = (l + r) / 2;
int first = query(T, root * 2, l, m, L, R);
int second = query(T, root * 2 + 1, m + 1, r, L, R);
return min(first, second);
}
int main() {
bi[0] = 1;
for (int i = 1; i < 20; i++) bi[i] = bi[i - 1] * 2;
vector<int> arr;
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
}
for (int i = 1; i < n; i++) {
int first, second;
scanf("%d%d", &first, &second);
s[first].push_back(second);
s[second].push_back(first);
}
dfs(m, 0, 1);
for (int i = 1; i <= MAX; i++) {
for (int j = 0; j <= 18; j++) tree[i][j].resize(level[i].size() * 4);
build(tree[i][0], i, 0, 1, 0, level[i].size() - 1);
}
for (int j = 1; j <= 18; j++) {
for (int i = 1; i <= n; i++) {
int mi = dp[i][j - 1];
int nxt = dep[i] + bi[j - 1];
if (nxt <= MAX) {
int ID = id[i];
int lll = lower_bound(inid[nxt].begin(), inid[nxt].end(), ID) -
inid[nxt].begin();
int rrr = lower_bound(inid[nxt].begin(), inid[nxt].end(), ID + SZ[i]) -
inid[nxt].begin() - 1;
if (rrr >= lll) {
int tmp =
query(tree[nxt][j - 1], 1, 0, level[nxt].size() - 1, lll, rrr);
mi = min(mi, tmp);
}
}
dp[i][j] = mi;
}
for (int i = 1; i <= MAX; i++)
build(tree[i][j], i, j, 1, 0, level[i].size() - 1);
}
int t;
scanf("%d", &t);
int last = 0;
while (t--) {
int first, second;
scanf("%d%d", &first, &second);
int X = (first + last) % n + 1;
int Y = (second + last) % n + 1;
int ID = id[X];
int nxt = dep[X];
int ans = 2000000000;
for (int d = 0; d <= 18; d++) {
if (nxt > MAX) break;
if ((1 << d) & Y) {
int lll = lower_bound(inid[nxt].begin(), inid[nxt].end(), ID) -
inid[nxt].begin();
int rrr = lower_bound(inid[nxt].begin(), inid[nxt].end(), ID + SZ[X]) -
inid[nxt].begin() - 1;
if (rrr >= lll) {
int tmp = query(tree[nxt][d], 1, 0, level[nxt].size() - 1, lll, rrr);
ans = min(ans, tmp);
}
nxt += bi[d];
}
}
printf("%d\n", ans);
last = ans;
}
}
|
#include <bits/stdc++.h>
int a[100005], n, la, dfn[100005], sz[100005], m, r, rt[100005], ct,
cnt[100005], dep[100005], maxdep, cur;
std::queue<int> q;
namespace segtree {
int lc[3200005], rc[3200005], tot, mn[3200005];
inline void pushup(int x) { mn[x] = std::min(mn[lc[x]], mn[rc[x]]); }
void build(int& p, int l, int r) {
p = ++tot;
if (l == r) return;
int mid = l + r >> 1;
build(lc[p], l, mid);
build(rc[p], mid + 1, r);
pushup(p);
}
void ins(int& p, int pre, int pos, int l, int r, int val) {
p = ++tot;
if (l == r) {
mn[p] = val;
return;
}
int mid = l + r >> 1;
if (pos <= mid)
rc[p] = rc[pre], mn[rc[p]] = mn[rc[pre]],
ins(lc[p], lc[pre], pos, l, mid, val);
else
lc[p] = lc[pre], mn[lc[p]] = mn[lc[pre]],
ins(rc[p], rc[pre], pos, mid + 1, r, val);
pushup(p);
}
int query(int node, int l, int r, int cl, int cr) {
if (l <= cl && cr <= r) return mn[node];
int mid = cl + cr >> 1, ans = 0x7fffffff;
if (l <= mid) ans = std::min(ans, query(lc[node], l, r, cl, mid));
if (r > mid) ans = std::min(ans, query(rc[node], l, r, mid + 1, cr));
return ans;
}
} // namespace segtree
std::vector<int> g[100005];
void dfs(int x, int fx) {
dfn[x] = ++ct;
sz[x] = 1;
dep[x] = dep[fx] + 1;
maxdep = std::max(maxdep, dep[x]);
for (int i = 0; i < (int)g[x].size(); ++i)
if (g[x][i] != fx) dfs(g[x][i], x), sz[x] += sz[g[x][i]];
}
bool vis[100005];
inline void BFS_BUILD(int r) {
q.push(r);
vis[r] = true;
for (int k; (int)q.size(); q.pop()) {
k = q.front();
for (int i = 0; i < (int)g[k].size(); ++i)
if (!vis[g[k][i]]) vis[g[k][i]] = true, q.push(g[k][i]);
segtree::ins(rt[++cur], rt[cur], dfn[k], 1, n, a[k]);
}
}
int main() {
std::memset(segtree::mn, 0x6f, sizeof(segtree::mn));
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y), g[y].push_back(x);
}
dfs(r, r);
for (int i = 1; i <= n; ++i) ++cnt[dep[i]];
for (int i = 1; i <= maxdep; ++i) cnt[i] += cnt[i - 1];
segtree::build(rt[0], 1, n);
BFS_BUILD(r);
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
int x, k;
scanf("%d%d", &x, &k);
x = (x + la) % n + 1, k = (k + la) % n;
printf("%d\n", la = segtree::query(rt[cnt[std::min(maxdep, dep[x] + k)]],
dfn[x], dfn[x] + sz[x] - 1, 1, n));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, INF = 1e9 + 10;
int n, rt, tot;
int fir[N], root[N], v[N], dep[N];
struct edge {
int to;
int nxt;
} e[2 * N];
inline void add(int x, int y) {
e[++tot].to = y;
e[tot].nxt = fir[x];
fir[x] = tot;
e[++tot].to = x;
e[tot].nxt = fir[y];
fir[y] = tot;
}
struct tree {
int cnt;
int son[40 * N][2], val[40 * N];
tree() {
cnt = 0;
memset(val, 0x3f, sizeof(val));
}
inline int merge(int p, int q, int l, int r) {
if (p == 0) return q;
if (q == 0) return p;
int np = ++cnt;
if (l == r) {
val[np] = min(val[p], val[q]);
return np;
}
int mid = (l + r) / 2;
son[np][0] = merge(son[p][0], son[q][0], l, mid);
son[np][1] = merge(son[p][1], son[q][1], mid + 1, r);
val[np] = min(val[son[np][0]], val[son[np][1]]);
return np;
}
inline void change(int &p, int l, int r, int pos, int c) {
if (p == 0) p = ++cnt;
if (l == r) {
val[p] = c;
return;
}
int mid = (l + r) / 2;
if (pos <= mid)
change(son[p][0], l, mid, pos, c);
else
change(son[p][1], mid + 1, r, pos, c);
val[p] = min(val[son[p][0]], val[son[p][1]]);
}
inline int query(int p, int l, int r, int x, int y) {
if (p == 0) return INF;
if (x <= l && y >= r) return val[p];
int mid = (l + r) / 2, ans = INF;
if (x <= mid) ans = min(ans, query(son[p][0], l, mid, x, y));
if (y > mid) ans = min(ans, query(son[p][1], mid + 1, r, x, y));
return ans;
}
} t;
inline void dfs(int p, int fa) {
root[p] = ++t.cnt;
t.change(root[p], 1, n, dep[p], v[p]);
for (int i = fir[p]; i; i = e[i].nxt) {
int q = e[i].to;
if (q == fa) continue;
dep[q] = dep[p] + 1;
dfs(q, p);
root[p] = t.merge(root[p], root[q], 1, n);
}
}
int main() {
int m, a, b, last = 0;
scanf("%d%d", &n, &rt);
for (int i = 1; i <= n; i++) scanf("%d", &v[i]);
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
add(a, b);
}
dep[rt] = 1, dfs(rt, 0);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a, &b);
a = (a + last) % n + 1, b = (b + last) % n;
last = t.query(root[a], 1, n, dep[a], min(dep[a] + b, n));
printf("%d\n", last);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long po(long long a, long long b) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2) {
x = x * y;
x %= 1000000007;
}
y = y * y;
y %= 1000000007;
b /= 2;
}
return x;
}
static int a[200005];
static int st[200005], en[200005];
vector<pair<int, int> > order;
vector<int> adj[200005];
static int mohib[200005];
void dfs0(int cur, int pr, int lvl) {
mohib[cur] = lvl;
order.push_back(make_pair(lvl, a[cur]));
st[cur] = order.size() - 1;
for (int i = 0; i < adj[cur].size(); i++) {
if (adj[cur][i] == pr) {
continue;
}
dfs0(adj[cur][i], cur, lvl + 1);
}
en[cur] = order.size() - 1;
}
vector<pair<int, int> > seg[400005];
void build(int s, int e, int ind) {
if (s == e) {
seg[ind].push_back(order[s]);
return;
}
int mi = (s + e) >> 1;
build(s, mi, 2 * ind + 1);
build(mi + 1, e, 2 * ind + 2);
for (int i = s; i <= e; i++) {
seg[ind].push_back(order[i]);
}
sort(seg[ind].begin(), seg[ind].end());
for (int i = 1; i < seg[ind].size(); i++) {
seg[ind][i].second = min(seg[ind][i].second, seg[ind][i - 1].second);
}
return;
}
int query(int s, int e, int ind, int qs, int qe, int val) {
if (s > qe || e < qs) {
return INT_MAX;
}
if (qs <= s && e <= qe) {
int now = 1e9 + 2;
int lo = 0, high = seg[ind].size() - 1;
while (lo <= high) {
int mi = (lo + high) >> 1;
if (seg[ind][mi].first <= val) {
now = seg[ind][mi].second;
lo = mi + 1;
} else {
high = mi - 1;
}
}
return now;
}
int mi = (s + e) >> 1;
return min(query(s, mi, 2 * ind + 1, qs, qe, val),
query(mi + 1, e, 2 * ind + 2, qs, qe, val));
}
int main() {
if (0) {
freopen("C:/Users/gold/Desktop/sublime IO/input.txt", "r", stdin);
freopen("C:/Users/gold/Desktop/sublime IO/output.txt", "w", stdout);
}
int T = 1;
while (T--) {
int n, r;
scanf("%d %d", &n, &r);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs0(r, -1, 0);
build(0, n - 1, 0);
int last = 0;
int m;
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int p, q;
scanf("%d %d", &p, &q);
p = (last + p) % n + 1;
q = (last + q) % n;
printf("%d\n", last = query(0, n - 1, 0, st[p], en[p], mohib[p] + q));
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MEM = 2000000;
const int INF = 2147483647;
struct Node {
int val, lc, rc;
} tree[MEM];
int mem;
int N, R, Q, val[MAXN];
int step, st[MAXN], ed[MAXN], arr[MAXN], dep[MAXN];
int last;
int mxdep;
int root[MAXN];
vector<int> child[MAXN], vec[MAXN];
int get_node() {
tree[mem] = Node();
return mem++;
}
int init_tree(int l, int r) {
int id = get_node();
if (l == r) {
tree[id].val = INF;
return id;
}
int m = (l + r) / 2;
tree[id].lc = init_tree(l, m);
tree[id].rc = init_tree(m + 1, r);
int lc = tree[id].lc;
int rc = tree[id].rc;
tree[id].val = min(tree[lc].val, tree[rc].val);
return id;
}
int update_tree(int l, int r, int x, int v, int id) {
int id2 = get_node();
tree[id2] = tree[id];
if (l == r) {
tree[id2].val = v;
return id2;
}
int m = (l + r) / 2;
if (x <= m) {
tree[id2].lc = update_tree(l, m, x, v, tree[id].lc);
} else {
tree[id2].rc = update_tree(m + 1, r, x, v, tree[id].rc);
}
int lc = tree[id2].lc;
int rc = tree[id2].rc;
tree[id2].val = min(tree[lc].val, tree[rc].val);
return id2;
}
int query_tree(int l, int r, int fl, int fr, int id) {
if (r < fl) return INF;
if (fr < l) return INF;
if (fl <= l and r <= fr) return tree[id].val;
int lc = tree[id].lc;
int rc = tree[id].rc;
int m = (l + r) / 2;
return min(query_tree(l, m, fl, fr, lc), query_tree(m + 1, r, fl, fr, rc));
}
void DFS(int u, int d) {
st[u] = ++step;
arr[step] = u;
dep[u] = d;
vec[d].push_back(u);
for (auto v : child[u]) {
child[v].erase(find(begin(child[v]), end(child[v]), u));
DFS(v, d + 1);
}
ed[u] = step;
}
void build() {
step = 0;
DFS(R, 0);
root[0] = init_tree(1, N);
for (int i = 0; i < (MAXN); i++) {
if (vec[i].empty()) break;
mxdep = i;
if (i != 0) root[i] = root[i - 1];
for (auto it : vec[i]) {
root[i] = update_tree(1, N, st[it], val[it], root[i]);
}
}
}
int query(int x, int k) {
int d = dep[x] + k;
if (d > mxdep) d = mxdep;
return query_tree(1, N, st[x], ed[x], root[d]);
int res = INF;
for (int i = (1); i <= (N); i++) {
if (st[x] <= st[i] and st[i] <= ed[x] and dep[x] + k >= dep[i]) {
res = min(res, val[i]);
}
}
assert(res == query_tree(1, N, st[x], ed[x], root[d]));
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> N >> R;
for (int i = (1); i <= (N); i++) cin >> val[i];
for (int _ = 0; _ < (N - 1); _++) {
int u, v;
cin >> u >> v;
child[u].push_back(v);
child[v].push_back(u);
}
build();
cin >> Q;
last = 0;
for (int _ = 0; _ < (Q); _++) {
int x, k;
cin >> x >> k;
x = (x + last) % N + 1;
k = (k + last) % N;
long long res = query(x, k);
cout << res << "\n";
last = res;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
struct PST {
struct node {
int lb, rb;
T val;
node *l, *r;
inline T comb(T a, T b) { return min(a, b); }
inline void app(T &v, T x) { v = x; }
node(int lb, int rb, vector<T> &a) : lb(lb), rb(rb) {
if (lb == rb) {
l = r = NULL;
val = a[lb];
return;
}
int m = lb + rb >> 1;
l = new node(lb, m, a);
r = new node(m + 1, rb, a);
val = comb(l->val, r->val);
}
node(int lb, int rb, T x) : lb(lb), rb(rb), val(x) {
if (lb == rb) {
l = r = NULL;
return;
}
int m = lb + rb >> 1;
l = new node(lb, m, x);
r = new node(m + 1, rb, x);
}
node(node *o) {
lb = o->lb;
rb = o->rb;
val = o->val;
l = o->l;
r = o->r;
}
void upd(int i, T x) {
if (lb == rb) {
app(val, x);
return;
}
int m = lb + rb >> 1;
if (i <= m) {
l = new node(l);
l->upd(i, x);
} else {
r = new node(r);
r->upd(i, x);
}
val = comb(l->val, r->val);
}
T query(int lq, int rq, T ID) {
if (rb < lq || lb > rq) return ID;
if (lb >= lq && rb <= rq) return val;
return comb(l->query(lq, rq, ID), r->query(lq, rq, ID));
}
};
const T ID = INT_MAX;
vector<node *> t;
PST(vector<T> &a) { t.push_back(new node(0, a.size() - 1, a)); }
PST(int SZ) { t.push_back(new node(0, SZ - 1, ID)); }
T query(int lq, int rq, int v = -1) {
int ind = (~v ? v : t.size() - 1);
return (t[ind]->query(lq, rq, ID));
}
void upd(int i, T x, int v = -1) {
int ind = (~v ? v : t.size() - 1);
t[ind]->upd(i, x);
}
void cpy(int v = -1) {
int ind = (~v ? v : t.size() - 1);
t.push_back(new node(t[ind]));
}
};
const int mxN = 1e5 + 1;
int n, r, t, q, lst, mxD, a[mxN], in[mxN], out[mxN], dep[mxN];
vector<int> adj[mxN], qu[mxN];
void dfs(int v = r, int p = 0, int d = 1) {
in[v] = t++;
dep[v] = d;
mxD = max(mxD, d);
qu[d].push_back(v);
for (int u : adj[v])
if (u ^ p) dfs(u, v, d + 1);
out[v] = t++;
}
int main() {
cin.tie(0)->sync_with_stdio(0);
cin >> n >> r;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs();
PST<int> pst(n * 2 + 1);
for (int i = 1; i <= mxD; ++i) {
pst.cpy();
for (int v : qu[i]) pst.upd(in[v], a[v]);
}
cin >> q;
while (q--) {
int p, q, x, k;
cin >> p >> q;
x = (p + lst) % n + 1, k = (q + lst) % n;
cout << (lst = pst.query(in[x], out[x], min(mxD, dep[x] + k))) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxx = 1e5 + 6;
struct node {
int l, r;
int w;
node() { w = INF; }
} tree[maxx * 40];
int cnt, tot, maxdeep;
int root[maxx];
int deepth[maxx], ver[maxx * 2], Next[maxx * 2], head[maxx];
int a[maxx];
int n, r;
void add(int x, int y) {
ver[++tot] = y;
Next[tot] = head[x];
head[x] = tot;
ver[++tot] = x;
Next[tot] = head[y];
head[y] = tot;
}
void inserts(int &rt, int l, int r, int pos, int w) {
rt = ++cnt;
tree[rt].w = min(tree[rt].w, w);
if (l == r) {
return;
}
int mid = (l + r) >> 1;
if (pos <= mid)
inserts(tree[rt].l, l, mid, pos, w);
else
inserts(tree[rt].r, mid + 1, r, pos, w);
}
int merge(int x, int y) {
if (!x || !y) {
return x + y;
}
int tmp = ++cnt;
tree[tmp].l = merge(tree[x].l, tree[y].l);
tree[tmp].r = merge(tree[x].r, tree[y].r);
tree[tmp].w = min(tree[x].w, tree[y].w);
return tmp;
}
int query(int rt, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
return tree[rt].w;
}
int mid = (l + r) >> 1;
if (qr <= mid) {
return query(tree[rt].l, l, mid, ql, qr);
} else if (ql > mid) {
return query(tree[rt].r, mid + 1, r, ql, qr);
} else {
return min(query(tree[rt].l, l, mid, ql, qr),
query(tree[rt].r, mid + 1, r, ql, qr));
}
}
void dfs(int u, int fa) {
deepth[u] = deepth[fa] + 1;
maxdeep = max(maxdeep, deepth[u]);
inserts(root[u], 1, n, deepth[u], a[u]);
for (int i = head[u]; i; i = Next[i]) {
int v = ver[i];
if (v == fa) continue;
dfs(v, u);
root[u] = merge(root[u], root[v]);
}
}
int main() {
int uu, vv;
while (~scanf("%d%d", &n, &r)) {
maxdeep = 0;
cnt = 0;
tot = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; i++) {
scanf("%d%d", &uu, &vv);
add(uu, vv);
}
int op;
scanf("%d", &op);
dfs(r, 0);
int ans = 0;
int p, q;
while (op--) {
scanf("%d%d", &p, &q);
p = (p + ans) % n + 1, q = (q + ans) % n;
ans = query(root[p], 1, n, deepth[p], min(deepth[p] + q, n));
printf("%d\n", ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long infl = 0x3f3f3f3f3f3f3f3fLL;
template <typename T>
inline void umax(T& a, T b) {
a = max(a, b);
}
template <typename T>
inline void umin(T& a, T b) {
a = min(a, b);
}
template <typename T>
inline T randIntv(const T& a, const T& b) {
return (T)rand() % (b - a + 1) + a;
}
void debug() { cout << endl; }
template <typename T, typename... R>
void debug(T f, R... r) {
cout << "[" << f << "]";
debug(r...);
}
const int MAXN = 100005;
int n, m, r;
long long a[MAXN];
struct Edge {
int v, next;
} edge[MAXN << 1];
int head[MAXN], etot, dep[MAXN], null;
void ini(int n) {
etot = 0;
for (int i = 0; i <= n; ++i) head[i] = -1;
}
void ins(int u, int v) {
edge[etot] = Edge{v, head[u]};
head[u] = etot++;
}
struct TNode {
long long val;
int ch[2];
void ini() {
ch[0] = ch[1] = 0;
val = infl;
}
} nd[MAXN * 50];
int root[MAXN], rsz;
void pushUp(int rt) {
nd[rt].val = min(nd[nd[rt].ch[0]].val, nd[nd[rt].ch[1]].val);
}
void update(int p, long long v, int l, int r, int& rt) {
nd[rt = ++rsz].ini();
if (l == r) {
nd[rt].val = v;
return;
}
int md = (l + r) >> 1;
if (p <= md)
update(p, v, l, md, nd[rt].ch[0]);
else
update(p, v, md + 1, r, nd[rt].ch[1]);
pushUp(rt);
}
int merge(int u, int v) {
if (!v) return u;
if (!u) return v;
int ret = ++rsz;
nd[ret].ini();
nd[ret].ch[0] = merge(nd[u].ch[0], nd[v].ch[0]);
nd[ret].ch[1] = merge(nd[u].ch[1], nd[v].ch[1]);
nd[ret].val = min(nd[u].val, nd[v].val);
return ret;
}
void dfs(int u, int fa, int d) {
dep[u] = d;
update(dep[u], a[u], 1, n, root[u]);
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (v == fa) continue;
dfs(v, u, d + 1);
root[u] = merge(root[u], root[v]);
}
}
long long query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return nd[rt].val;
int md = (l + r) >> 1;
long long ret = infl;
if (L <= md) umin(ret, query(L, R, l, md, nd[rt].ch[0]));
if (R > md) umin(ret, query(L, R, md + 1, r, nd[rt].ch[1]));
return ret;
}
int main() {
int u, v, p, q, x, k;
long long last = 0;
scanf("%d %d", &n, &r);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
ini(n);
for (int i = 2; i <= n; ++i) {
scanf("%d %d", &u, &v);
ins(u, v), ins(v, u);
;
}
rsz = 0;
nd[null = 0].ini();
dfs(r, r, 1);
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &p, &q);
x = (p + last) % n + 1, k = (q + last) % n;
last = query(dep[x], dep[x] + k, 1, n, root[x]);
printf("%lld\n", last);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 100010;
const long long M = 1000010;
long long n, m, tot, tim, cnt, rt, head[N], dfn[N], low[N], d[N], root[N],
siz[N], id[N];
struct Edge {
long long suiv, ver;
} e[M << 1];
struct SegmentTree {
long long l, r, mini;
;
SegmentTree() { mini = 1000000010; }
} t[N * 50];
struct Node {
long long val, id, dep;
inline bool operator<(const Node& that) const { return dep < that.dep; }
} a[N];
inline bool cmp(long long x, long long y) { return d[x] < d[y]; }
inline void lnk(long long x, long long y) {
e[++tot].ver = y;
e[tot].suiv = head[x];
head[x] = tot;
}
inline void dfs(long long x, long long fa) {
d[x] = a[x].dep = d[fa] + 1;
dfn[x] = ++tim;
for (long long i = head[x]; i; i = e[i].suiv) {
long long y = e[i].ver;
if (y == fa) continue;
dfs(y, x);
}
low[x] = tim;
}
inline void insert(long long p, long long& q, long long l, long long r,
long long d, long long val) {
q = ++cnt;
if (l == r) return t[q].mini = min(t[p].mini, val), void();
long long mid = l + r >> 1;
if (d <= mid) insert(t[p].l, t[q].l, l, mid, d, val), t[q].r = t[p].r;
if (d > mid) insert(t[p].r, t[q].r, mid + 1, r, d, val), t[q].l = t[p].l;
t[q].mini = min(t[t[q].l].mini, t[t[q].r].mini);
}
inline long long query(long long p, long long l, long long r, long long L,
long long R) {
if (L <= l && r <= R) return t[p].mini;
long long mid = l + r >> 1, res = 1ll << 60;
if (L <= mid) res = min(res, query(t[p].l, l, mid, L, R));
if (R > mid) res = min(res, query(t[p].r, mid + 1, r, L, R));
return res;
}
signed main() {
scanf("%lld%lld", &n, &rt);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i].val), a[i].id = i;
for (long long i = 1, x, y; i < n; i++)
scanf("%lld%lld", &x, &y), lnk(x, y), lnk(y, x);
dfs(rt, 0);
sort(a + 1, a + 1 + n);
for (long long i = 1; i <= n; i++)
insert(root[a[i - 1].dep], root[a[i].dep], 1, n, dfn[a[i].id], a[i].val);
scanf("%lld", &m);
long long x, y, ans = 0;
while (m--) {
scanf("%lld%lld", &x, &y);
x = (x + ans) % n + 1, y = (y + ans) % n;
printf("%lld\n",
ans = query(root[min(d[x] + y, a[n].dep)], 1, n, dfn[x], low[x]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const int INF = 1e9 + 7;
int a[maxn], n, r;
struct Edge {
int v, nxt;
} e[maxn << 1];
int head[maxn], tot = 0;
void init() {
memset(head, -1, sizeof head);
tot = 0;
}
void addedge(int u, int v) {
e[tot].nxt = head[u];
e[tot].v = v;
head[u] = tot++;
}
int root[maxn], cnt = 0;
int dep[maxn];
struct node {
int l, r;
int val;
} tree[maxn << 6];
void pushup(int rt) {
tree[rt].val = min(tree[tree[rt].l].val, tree[tree[rt].r].val);
}
void insert(int &rt, int l, int r, int k, int val) {
rt = ++cnt;
if (l == r) {
tree[rt].val = val;
return;
}
int mid = (l + r) / 2;
if (mid >= k)
insert(tree[rt].l, l, mid, k, val);
else
insert(tree[rt].r, mid + 1, r, k, val);
pushup(rt);
}
int merge(int x, int y) {
if (!x || !y) return x | y;
int t = ++cnt;
tree[t].l = merge(tree[x].l, tree[y].l);
tree[t].r = merge(tree[x].r, tree[y].r);
if (tree[t].l || tree[t].r)
pushup(t);
else
tree[t].val = min(tree[x].val, tree[y].val);
return t;
}
void dfs(int u, int p, int d = 1) {
insert(root[u], 1, n, d, a[u]);
dep[u] = d;
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].v;
if (v == p) continue;
dfs(v, u, d + 1);
root[u] = merge(root[u], root[v]);
}
}
int query(int rt, int ql, int qr, int l, int r) {
if (!rt) return INF;
if (ql <= l && r <= qr) return tree[rt].val;
int mid = (l + r) / 2;
int ans = INF, ans2 = INF;
if (ql <= mid) ans = query(tree[rt].l, ql, qr, l, mid);
if (mid < qr) ans2 = query(tree[rt].r, ql, qr, mid + 1, r);
return min(ans, ans2);
}
int main() {
init();
tree[0].val = INF;
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
addedge(x, y);
addedge(y, x);
}
dfs(r, -1);
int q;
scanf("%d", &q);
int last = 0, ans = 0;
while (q-- > 0) {
int p, k;
scanf("%d%d", &p, &k);
p = (p + last) % n + 1;
k = (k + last) % n;
ans = query(root[p], dep[p], min(dep[p] + k, n), 1, n);
last = ans;
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
bool f = 0;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = 1;
for (; ch >= '0' && ch <= '9'; ch = getchar())
x = (x << 3) + (x << 1) + (ch ^ 48);
return f ? -x : x;
}
const int inf = 0x3fffffff;
int n, r, val[100010], p[100010], dep[100010], dl[100010], dr[100010], tim;
int rt[100010];
vector<int> adj[100010];
inline void add(int x, int y) {
adj[x].push_back(y);
adj[y].push_back(x);
}
void dfs(int u, int pre) {
dep[u] = dep[pre] + 1;
dl[u] = ++tim;
for (auto v : adj[u])
if (v ^ pre) dfs(v, u);
dr[u] = tim;
}
int ls[100010 * 120], rs[100010 * 120], mi[100010 * 120], cnt;
void ins(int &u, int v, int l, int r, int p, int x) {
u = ++cnt;
ls[u] = ls[v];
rs[u] = rs[v];
if (l == r) return (void)(mi[u] = x);
int mid = l + r >> 1;
if (p <= mid)
ins(ls[u], ls[v], l, mid, p, x);
else
ins(rs[u], rs[v], mid + 1, r, p, x);
mi[u] = min(mi[ls[u]], mi[rs[u]]);
}
int query(int u, int l, int r, int L, int R) {
if (!u || (L <= l && r <= R)) return mi[u];
int mid = l + r >> 1, ans = inf;
if (L <= mid) ans = min(ans, query(ls[u], l, mid, L, R));
if (mid < R) ans = min(ans, query(rs[u], mid + 1, r, L, R));
return ans;
}
int main() {
n = read();
r = read();
mi[0] = inf;
for (int i = (1); i <= (n); i++) val[i] = read(), p[i] = i;
for (int i = (2); i <= (n); i++) add(read(), read());
dfs(r, 0);
sort(p + 1, p + n + 1, [&](int x, int y) { return dep[x] < dep[y]; });
int j = 0;
for (int i = 1, x, k; i <= n; i++) {
x = p[i];
k = j;
if (dep[x] != j) j++;
ins(rt[j], rt[k], 1, n, dl[x], val[x]);
}
for (int _ = read(), ans = 0, x, k; _--;) {
x = (read() + ans) % n + 1;
k = (read() + ans) % n;
printf("%d\n", ans = query(rt[min(dep[x] + k, j)], 1, n, dl[x], dr[x]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int a[100005];
int interval[100005][2];
vector<int> graph[100005];
int invertorder[100005];
int height[100005];
int val = 0;
void dfs(int v, int par) {
invertorder[v] = val;
interval[v][0] = val;
val++;
for (int w : graph[v]) {
if (w != par) {
height[w] = height[v] + 1;
dfs(w, v);
}
}
interval[v][1] = val - 1;
}
struct node {
int val = 0;
node* c[2];
int query(int low, int high, int L, int R) {
if (low <= L && R <= high) return val;
if (R < low || high < L) return MOD;
int M = (L + R) / 2;
return min(c[0]->query(low, high, L, M), c[1]->query(low, high, M + 1, R));
}
void upd(int ind, int v, int L, int R) {
if (L == ind && R == ind) {
val = v;
return;
}
if (R < ind || ind < L) return;
int M = (L + R) / 2;
c[0] = new node(*c[0]), c[1] = new node(*c[1]);
c[0]->upd(ind, v, L, M);
c[1]->upd(ind, v, M + 1, R);
val = min(c[0]->val, c[1]->val);
}
void build(vector<int>& arr, int L, int R) {
if (L == R) {
if (L < (int)arr.size())
val = arr[L];
else
val = 0;
return;
}
int M = (L + R) / 2;
c[0] = new node();
c[0]->build(arr, L, M);
c[1] = new node();
c[1]->build(arr, M + 1, R);
val = min(c[0]->val, c[1]->val);
}
};
template <int SZ>
struct pers {
node* loc[SZ + 1];
int nex = 1;
pers() { loc[0] = new node(); }
void upd(int ind, int val) {
loc[nex] = new node(*loc[nex - 1]);
loc[nex]->upd(ind, val, 0, SZ - 1);
nex++;
}
void build(vector<int>& arr) { loc[0]->build(arr, 0, SZ - 1); }
int query(int ti, int low, int high) {
return loc[ti]->query(low, high, 0, SZ - 1);
}
};
pers<100005> p;
vector<int> lheight[100005];
vector<int> versions;
int main() {
vector<int> arr;
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, r;
cin >> n >> r;
r--;
for (int i = 0; i < n; i++) {
cin >> a[i];
arr.push_back(MOD);
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
graph[u].push_back(v);
graph[v].push_back(u);
}
height[r] = 0;
dfs(r, -1);
for (int i = 0; i < n; i++) {
lheight[height[i]].push_back(i);
}
p.build(arr);
for (int i = 0; i < n; i++) {
for (int v : lheight[i]) {
p.upd(invertorder[v], a[v]);
}
versions.push_back(p.nex - 1);
}
int last = 0;
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int pro, q;
cin >> pro >> q;
int v = (pro + last) % n;
int h = (q + last) % n;
int H = h + height[v];
last = p.query(versions[min(H, n - 1)], interval[v][0], interval[v][1]);
cout << last << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[100005];
vector<int> dep[100005];
int a[100005];
int n, r;
int dfs_time;
int In[100005];
int Out[100005];
int pos[100005];
int dis[100005];
int Max;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline void write(int x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
struct node {
int l, r;
int Min;
} T[100005 << 6];
int ver[100005];
int tot;
void PushUp(int rt) { T[rt].Min = min(T[T[rt].l].Min, T[T[rt].r].Min); }
int BuildTree(int l, int r) {
int rt = (++tot);
T[rt].Min = 0x7f7f7f7f;
if (l == r) return rt;
int m = (l + r) >> 1;
T[rt].l = BuildTree(l, m);
T[rt].r = BuildTree(m + 1, r);
return rt;
}
int Update(int pre, int l, int r, int x) {
int rt = (++tot);
T[rt] = T[pre];
if (l == r) {
T[rt].Min = a[pos[x]];
return rt;
}
int m = (l + r) >> 1;
if (x <= m)
T[rt].l = Update(T[pre].l, l, m, x);
else
T[rt].r = Update(T[pre].r, m + 1, r, x);
PushUp(rt);
return rt;
}
void debug(int rt, int l, int r) {
cout << l << " " << r << endl;
cout << T[rt].Min << endl;
if (l == r) return;
int m = (l + r) >> 1;
debug(T[rt].l, l, m);
debug(T[rt].r, m + 1, r);
}
int Query(int rt, int L, int R, int l, int r) {
if (L <= l && R >= r) return T[rt].Min;
int ans = 0x7f7f7f7f;
int m = (l + r) >> 1;
if (L <= m) ans = min(ans, Query(T[rt].l, L, R, l, m));
if (R > m) ans = min(ans, Query(T[rt].r, L, R, m + 1, r));
return ans;
}
void DFS(int u, int fa, int depth) {
Max = max(Max, depth);
dis[u] = depth;
dep[depth].push_back(u);
pos[dfs_time] = u;
In[u] = dfs_time++;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == fa) continue;
DFS(v, u, depth + 1);
}
Out[u] = dfs_time - 1;
}
int main() {
n = read();
r = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
}
for (int i = 1; i < n; i++) {
int u, v;
u = read();
v = read();
g[u].push_back(v);
g[v].push_back(u);
}
dfs_time = 1;
DFS(r, -1, 1);
ver[0] = BuildTree(1, n);
for (int i = 1; i <= Max; i++) {
ver[i] = ver[i - 1];
for (int j = 0; j < dep[i].size(); j++) {
int u = dep[i][j];
ver[i] = Update(ver[i], 1, n, In[u]);
}
}
int m;
m = read();
int las = 0;
while (m--) {
int p, q;
p = read();
q = read();
int x = ((p + las) % n) + 1;
int k = (q + las) % n;
int tag = min(Max, dis[x] + k);
int ans = Query(ver[tag], In[x], Out[x], 1, n);
write(ans);
putchar('\n');
las = ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int MAXN = 1e5 + 10;
int cnt, head[MAXN], tot;
int n, tim, a[MAXN], root[MAXN];
struct Poi {
int w, dfn, dep, col;
} poi[MAXN];
bool cmp(int a, int b) { return poi[a].dep < poi[b].dep; }
struct Edge {
int v, nex;
} edge[MAXN * 2];
struct Node {
int l, r, m;
} node[MAXN * 20];
void add(int u, int v) {
edge[cnt] = {v, head[u]};
head[u] = cnt++;
}
void dfs(int u, int fa) {
poi[u].dep = poi[fa].dep + 1;
poi[u].dfn = ++tim;
for (int i = head[u]; ~i; i = edge[i].nex) {
int v = edge[i].v;
if (v == fa) continue;
dfs(v, u);
}
poi[u].col = tim;
}
void up(int rt) { node[rt].m = min(node[node[rt].l].m, node[node[rt].r].m); }
void update(int &rt, int l, int r, int k, int x) {
node[++tot] = node[rt];
rt = tot;
if (l == r) {
node[rt].m = x;
return;
}
int mid = ((l + r) >> 1);
if (k <= mid)
update(node[rt].l, l, mid, k, x);
else
update(node[rt].r, mid + 1, r, k, x);
up(rt);
}
int bin(int x) {
int l = 1, r = n;
while (l <= r) {
int mid = ((l + r) >> 1);
if (poi[a[mid]].dep <= x)
l = mid + 1;
else
r = mid - 1;
}
return r;
}
int query(int rt, int l, int r, int L, int R) {
if (l == L && r == R) return node[rt].m;
int mid = ((l + r) >> 1);
if (R <= mid)
return query(node[rt].l, l, mid, L, R);
else if (L > mid)
return query(node[rt].r, mid + 1, r, L, R);
else {
int a = query(node[rt].l, l, mid, L, mid);
int b = query(node[rt].r, mid + 1, r, mid + 1, R);
return min(a, b);
}
}
inline int read() {
int k = 0;
char f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) k = k * 10 + c - '0';
return k * f;
}
int main() {
int s;
memset(head, -1, sizeof head);
cin >> n >> s;
for (int i = 1; i <= n; i++) poi[i].w = read(), a[i] = i;
for (int i = 1; i < n; i++) {
int u, v;
u = read(), v = read();
add(u, v);
add(v, u);
}
dfs(s, 0);
sort(a + 1, a + 1 + n, cmp);
node[0].m = INF;
for (int i = 1; i <= n; i++) {
root[i] = root[i - 1];
int idx = a[i];
int p = poi[idx].dfn;
int w = poi[idx].w;
update(root[i], 1, n, p, w);
}
int m;
cin >> m;
int ans = 0;
while (m--) {
int x, k;
x = read(), k = read();
x = (x + ans) % n + 1;
k = (k + ans) % n;
int dep = poi[x].dep + k;
int l = poi[x].dfn, r = poi[x].col;
int p = bin(dep);
ans = query(root[p], 1, n, l, r);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
const int inf = (1 << 30) - 1;
const int N = (int)1e5 + 5;
int n, m, root, in[N], out[N], T, a[N];
int h[N], c[N], b[N];
vector<int> g[N], ls[4 * N], rs[4 * N], d[4 * N];
vector<pair<int, int> > t[4 * N];
void _merge(int a, int b, int c) {
t[c].resize(((int)(t[a]).size()) + ((int)(t[b]).size()));
ls[c].resize(((int)(t[a]).size()) + ((int)(t[b]).size()));
rs[c].resize(((int)(t[a]).size()) + ((int)(t[b]).size()));
d[c].resize(((int)(t[a]).size()) + ((int)(t[b]).size()));
int i = 0, j = 0, k = 0;
while (i != ((int)(t[a]).size()) || j != ((int)(t[b]).size())) {
if (i == ((int)(t[a]).size()))
t[c][k] = t[b][j++];
else if (j == ((int)(t[b]).size()))
t[c][k] = t[a][i++];
else if (t[a][i] <= t[b][j])
t[c][k] = t[a][i++];
else
t[c][k] = t[b][j++];
ls[c][k] = i - 1;
rs[c][k] = j - 1;
k++;
}
for (int i = 0; i < ((int)(d[c]).size()); i++) {
if (i == 0)
d[c][i] = t[c][i].second;
else
d[c][i] = min(d[c][i - 1], t[c][i].second);
}
}
void build(int v, int l, int r) {
if (l == r) {
t[v].push_back(make_pair(b[l], c[l]));
d[v].push_back(c[l]);
} else {
build(v + v, l, ((l + r) >> 1));
build(v + v + 1, ((l + r) >> 1) + 1, r);
_merge(v + v, v + v + 1, v);
}
}
int get(int v, int l, int r, int L, int R, int i) {
if (r < L || R < l || i == -1) return inf;
if (L <= l && r <= R) return d[v][i];
return min(get(v + v, l, ((l + r) >> 1), L, R, ls[v][i]),
get(v + v + 1, ((l + r) >> 1) + 1, r, L, R, rs[v][i]));
}
void dfs(int v, int pr = 0) {
h[v] = h[pr] + 1;
in[v] = ++T;
b[in[v]] = h[v];
c[in[v]] = a[v];
for (int u : g[v]) {
if (pr != u) dfs(u, v);
}
out[v] = T;
}
int main() {
scanf("%d %d", &n, &root);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1, x, y; i < n; i++) {
scanf("%d %d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
dfs(root);
build(1, 1, n);
scanf("%d", &m);
int last = 0;
for (int i = 1; i <= m; i++) {
int x, k;
scanf("%d %d", &x, &k);
x = (x + last) % n + 1;
k = (k + last) % n;
k += h[x];
int index = (upper_bound((t[1]).begin(), (t[1]).end(), make_pair(k, inf)) -
t[1].begin()) -
1;
last = get(1, 1, n, in[x], out[x], index);
printf("%d\n", last);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 100, mod = 1e9 + 7, sz = 400, inf = 2e9;
vector<long long> t[4 * N], mn[4 * N];
long long b[N], a[N], p[N], h[N], left228[N], right228[N];
bool cmp(long long i, long long j) { return h[i] < h[j]; }
void build(long long v, long long l, long long r) {
if (l == r - 1) {
t[v].push_back(l);
mn[v].push_back(a[l]);
} else {
long long m = (l + r) / 2;
build(2 * v, l, m);
build(2 * v + 1, m, r);
merge((t[2 * v]).begin(), (t[2 * v]).end(), (t[2 * v + 1]).begin(),
(t[2 * v + 1]).end(), back_inserter(t[v]), cmp);
for (auto u : t[v]) {
if (mn[v].empty())
mn[v].push_back(a[u]);
else
mn[v].push_back(min(a[u], mn[v].back()));
}
}
}
long long res(long long v, long long k) {
if (h[t[v][0]] > k) return inf;
long long l = 0, r = t[v].size(), m;
while (r - l > 1) {
m = (l + r) / 2;
if (h[t[v][m]] > k)
r = m;
else
l = m;
}
return mn[v][l];
}
long long get(long long v, long long l, long long r, long long vl, long long vr,
long long k) {
if (l >= vr || vl >= r) return inf;
if (vl <= l && r <= vr) {
return res(v, k);
}
long long m = (l + r) / 2;
return min(get(2 * v, l, m, vl, vr, k), get(2 * v + 1, m, r, vl, vr, k));
}
vector<long long> v[N], o;
void dfs(long long x, long long pr) {
p[x] = o.size();
a[p[x]] = b[x];
left228[p[x]] = o.size();
if (pr != -1) {
h[p[x]] = h[p[pr]] + 1;
}
o.push_back(x);
for (auto u : v[x]) {
if (u != pr) dfs(u, x);
}
right228[p[x]] = o.size() - 1;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, r;
cin >> n >> r;
r--;
for (long long i = 0; i < n; i++) cin >> b[i];
for (long long i = 0; i < n - 1; i++) {
long long f, t;
cin >> f >> t;
f--, t--;
v[f].push_back(t);
v[t].push_back(f);
}
dfs(r, -1);
build(1, 0, n);
long long m;
long long last = 0;
cin >> m;
while (m--) {
long long p1, q1;
cin >> p1 >> q1;
long long x = p[(p1 + last) % n], k = (q1 + last) % n;
last = get(1, 0, n, left228[x], right228[x] + 1, h[x] + k);
cout << last << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T>
int sz(const T &a) {
return int(a.size());
}
const int MAXN = 1e5 + 1;
int arr[MAXN], depth[MAXN], st[MAXN], en[MAXN];
vector<int> matrix[MAXN];
vector<int> et;
void dfs(int loc, int parent, int dep) {
depth[loc] = dep;
st[loc] = sz(et);
et.push_back(loc);
bool done = false;
for (auto x : matrix[loc]) {
if (x != parent) {
done = true;
dfs(x, loc, dep + 1);
et.push_back(loc);
}
}
if (!done) et.push_back(loc);
en[loc] = sz(et) - 1;
}
struct seg {
struct node {
vector<int> mi;
int stdep;
node() { mi = {}, stdep = 0; }
} t[6 * MAXN];
void mt(int ind, int le, int ri) {
if (le == ri) {
t[ind].mi = {arr[et[le]]}, t[ind].stdep = depth[et[le]];
return;
}
int mid = (le + ri) / 2;
int left = ind + 1, right = ind + (mid - le + 1) * 2;
mt(left, le, mid), mt(right, mid + 1, ri);
int curmi = INT_MAX;
int maval = max(t[left].stdep + sz(t[left].mi) - 1,
t[right].stdep + sz(t[right].mi) - 1),
mival = min(t[left].stdep, t[right].stdep);
t[ind].mi.resize(maval - mival + 1);
t[ind].stdep = mival;
for (int i = mival; i <= maval; i++)
t[ind].mi[i - mival] = curmi = min(
{curmi,
((i - t[left].stdep >= 0 && i - t[left].stdep < sz(t[left].mi))
? t[left].mi[i - t[left].stdep]
: INT_MAX),
((i - t[right].stdep >= 0 && i - t[right].stdep < sz(t[right].mi))
? t[right].mi[i - t[right].stdep]
: INT_MAX)});
}
int query(int ind, int le, int ri, int l, int r, int dep) {
if (r < le || l > ri) return INT_MAX;
if (le >= l && ri <= r)
return (dep >= t[ind].stdep
? t[ind].mi[min(sz(t[ind].mi) - 1, dep - t[ind].stdep)]
: INT_MAX);
int mid = (le + ri) / 2;
int left = ind + 1, right = ind + (mid - le + 1) * 2;
return min(query(left, le, mid, l, r, dep),
query(right, mid + 1, ri, l, r, dep));
}
} tree;
int main() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int n, r;
cin >> n >> r;
for (int i = 1; i <= n; i++) cin >> arr[i];
int a, b;
for (int i = 1; i < n; i++) {
cin >> a >> b;
matrix[a].push_back(b);
matrix[b].push_back(a);
}
dfs(r, 0, 1);
tree.mt(0, 0, sz(et) - 1);
int m;
cin >> m;
int last = 0;
int x, k;
while (m--) {
cin >> x >> k;
x = ((x + last) % n) + 1, k = (k + last) % n;
printf("%d\n",
last = tree.query(0, 0, sz(et) - 1, st[x], en[x], depth[x] + k));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[150005], w[150005];
vector<int>::iterator it;
void chkmin(int &a, int b) {
if (a > b) a = b;
}
int n, rt, a[150005], st[150005], fs[150005], G, dp[150005];
int rg[150005][18], lg[150005][18], b[150005];
int mn[150005][18][18];
const int inf = 0x3f3f3f3f;
void dfs(int k, int pa = 0) {
dp[k] = dp[pa] + 1;
st[k] = ++G;
w[dp[k]].push_back(k);
for (auto x : v[k]) {
if (x == pa) continue;
dfs(x, k);
}
fs[k] = ++G;
return;
}
bool cmp1(int x, int y) { return st[x] < st[y]; }
bool cmp2(int x, int y) { return fs[x] < fs[y]; }
int find_min(int l, int r, int k) {
if (!l || !r) return inf;
int ll = b[l], rr = b[r];
if (ll > rr) return inf;
int m = 31 - __builtin_clz(rr - ll + 1);
r = w[dp[l]][rr - (1 << m) + 1];
return min(mn[l][k][m], mn[r][k][m]);
}
void build() {
for (int i = n; i; i--) {
if (w[i].empty()) continue;
int sz = w[i].size();
for (auto x : w[i]) mn[x][0][0] = a[x];
for (int j = 1; j < 18; j++) {
if (sz < (1 << j)) break;
for (auto x : w[i]) {
if (b[x] + (1 << j) > sz) break;
mn[x][0][j] =
min(mn[x][0][j - 1], mn[w[i][b[x] + (1 << j - 1)]][0][j - 1]);
}
}
for (auto x : w[i]) {
for (int j = 1; j < 18; j++) {
for (int jj = 0; jj < 18; jj++) {
if (b[x] + (1 << jj) > sz) break;
mn[x][j][jj] = mn[x][j - 1][jj];
chkmin(mn[x][j][jj],
find_min(lg[x][j], rg[w[i][b[x] + (1 << jj) - 1]][j], j - 1));
}
}
}
}
return;
}
int query(int x, int y) {
y++;
int res = inf, l = x, r = x;
for (int i = 18 - 1; i >= 0; i--) {
if (y >= (1 << i)) {
chkmin(res, find_min(l, r, i));
l = lg[l][i + 1], r = rg[r][i + 1];
if (!l || !r) return res;
y -= (1 << i);
}
}
return res;
}
int main() {
scanf("%d %d", &n, &rt);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int x, y;
for (int i = 1; i < n; i++) {
scanf("%d %d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
memset(mn, 0x3f, sizeof mn);
dfs(rt, 0);
st[0] = n + 1;
for (int i = 0; i <= n; i++) {
lg[i][0] = i;
rg[i][0] = i;
for (int j = 1; j < 18; j++) {
x = dp[i] + (1 << j - 1);
if (w[x].empty()) break;
it = lower_bound(w[x].begin(), w[x].end(), i, cmp1);
if (it != w[x].end()) lg[i][j] = *it;
it = lower_bound(w[x].begin(), w[x].end(), i, cmp2);
if (it != w[x].begin()) --it, rg[i][j] = *it;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < w[i].size(); j++) {
b[w[i][j]] = j;
}
}
build();
int q, lst = 0;
for (scanf("%d", &q); q--;) {
scanf("%d %d", &x, &y);
x = (x + lst) % n + 1;
y = (y + lst) % n;
lst = query(x, y);
printf("%d\n", lst);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char buff[(int)2e6 + 17];
const long long inf = (long long)1e9 + 7ll;
const int maxn = (int)1e6 + 17;
struct segtree {
int n;
vector<int> T;
segtree() {}
segtree(int n) : n(n) { T.resize(4 * n, inf); }
void update(int i, int x, int v, int l, int r) {
if (l == r)
T[v] = x;
else {
int m = (l + r) / 2;
if (i <= m)
update(i, x, 2 * v, l, m);
else
update(i, x, 2 * v + 1, m + 1, r);
T[v] = min(T[2 * v], T[2 * v + 1]);
}
}
int get(int lq, int rq, int v, int l, int r) {
if (r < lq || l > rq) return inf;
if (lq <= l && r <= rq) return T[v];
int m = (l + r) / 2;
return min(get(lq, rq, 2 * v, l, m), get(lq, rq, 2 * v + 1, m + 1, r));
}
void update(int i, int x) { update(i, x, 1, 0, n - 1); }
int get(int lq, int rq) { return get(lq, rq, 1, 0, n - 1); }
};
int a[maxn], vert[maxn], tin[maxn], tout[maxn], H[maxn];
vector<int> lvl[maxn], g[maxn];
struct segtree2 {
int n;
vector<segtree> T;
vector<vector<int> > vec;
segtree2() {}
segtree2(int n) : n(n) { T.resize(4 * n), vec.resize(4 * n); }
void build(int v, int l, int r) {
if (l == r) {
vec[v] = lvl[l];
T[v] = segtree(static_cast<int>(vec[v].size()));
for (int i = 0; i < static_cast<int>(vec[v].size()); ++i)
T[v].update(i, a[vert[lvl[l][i]]]);
return;
}
int m = (l + r) / 2;
build(2 * v, l, m);
build(2 * v + 1, m + 1, r);
vec[v] = vec[2 * v];
vec[v].insert(vec[v].end(), vec[2 * v + 1].begin(), vec[2 * v + 1].end());
sort(vec[v].begin(), vec[v].end());
T[v] = segtree(static_cast<int>(vec[v].size()));
for (int i = 0; i < static_cast<int>(vec[v].size()); ++i)
T[v].update(i, a[vert[vec[v][i]]]);
}
int get(int lx, int rx, int ly, int ry, int v, int l, int r) {
if (r < lx || l > rx) return inf;
if (lx <= l && r <= rx) {
int res = inf;
int lq = lower_bound(vec[v].begin(), vec[v].end(), ly) - vec[v].begin();
int rq =
upper_bound(vec[v].begin(), vec[v].end(), ry) - vec[v].begin() - 1;
if (lq <= rq) res = T[v].get(lq, rq);
return res;
}
int m = (l + r) / 2;
return min(get(lx, rx, ly, ry, 2 * v, l, m),
get(lx, rx, ly, ry, 2 * v + 1, m + 1, r));
}
int get(int lx, int rx, int ly, int ry) {
return get(lx, rx, ly, ry, 1, 0, n - 1);
}
};
int n, r, q, tt;
bool read() {
if (scanf("%d %d", &n, &r) != 2) return false;
--r;
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < n - 1; ++i) {
int u, v;
scanf("%d %d", &u, &v);
g[u - 1].push_back(v - 1);
g[v - 1].push_back(u - 1);
}
scanf("%d", &q);
return true;
}
void dfs(int v, int h = 0, int pr = -1) {
tin[v] = tt++;
vert[tin[v]] = v;
H[v] = h;
lvl[h].push_back(tin[v]);
for (auto to : g[v])
if (to != pr) dfs(to, h + 1, v);
tout[v] = tt - 1;
}
void solve() {
dfs(r);
segtree2 T = segtree2(n);
T.build(1, 0, n - 1);
int last = 0;
for (int i = 0; i < q; ++i) {
int P, Q;
scanf("%d %d", &P, &Q);
int v = (P + last) % n;
int k = (Q + last) % n;
printf("%d\n", last = T.get(H[v], min(n - 1, H[v] + k), tin[v], tout[v]));
}
}
int main() {
while (read()) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
#pragma warning(disable : 4996)
vector<int> ls(1e5 + 1), rs(1e5 + 1);
vector<int> ds(1e5 + 1, -1);
using Value = int;
const Value ini = 1e9;
struct segtree {
int N;
vector<Value> dat;
segtree() {}
segtree(int n) : dat(2 * (1 << 18)) {
N = 1;
while (N < n) N *= 2;
for (int i = 0; i < 2 * N - 1; i++) {
dat[i] = ini;
}
}
Value connect(const Value &l, const Value &r) { return min(l, r); }
void update(int k, Value a) {
k += N - 1;
dat[k] = a;
while (k > 0) {
k = (k - 1) / 2;
const Value al(dat[k * 2 + 1]);
const Value ar(dat[k * 2 + 2]);
dat[k] = connect(al, ar);
}
}
Value query(int a, int b) { return query(a, b, 0, 0, N); }
Value query(int a, int b, int k, int l, int r) {
if (r <= a or b <= l) return ini;
if (a <= l and r <= b) return dat[k];
const int m = (l + r) / 2;
const Value al(query(a, b, k * 2 + 1, l, m));
const Value ar(query(a, b, k * 2 + 2, m, r));
return connect(al, ar);
}
};
void dfs(const vector<vector<int>> &edges, const int depth, const int now,
const int from, int &id) {
ls[now] = id;
ds[now] = depth;
id++;
for (auto e : edges[now]) {
if (e == from)
continue;
else {
dfs(edges, depth + 1, e, now, id);
}
}
rs[now] = id;
}
vector<int> ch(vector<int> &froms, vector<int> &tos) {
vector<int> nextfroms(froms.size());
for (int i = 0; i < froms.size(); ++i) {
nextfroms[tos[i]] = froms[i];
}
return nextfroms;
}
vector<vector<int>> ch(vector<vector<int>> &froms, vector<int> &tos) {
vector<vector<int>> nextfroms(froms.size());
for (int i = 0; i < froms.size(); ++i) {
for (int j = 0; j < froms[i].size(); ++j) {
nextfroms[tos[i]].push_back(tos[froms[i][j]]);
}
}
return nextfroms;
}
class Tree {
public:
Tree(int V, int root) : V(V), root(root), cnum(V), place(V), id(V) {
T.resize(V);
for (int i = 0; i < MAXLOGV; i++) {
parent[i].resize(V);
}
depth.resize(V);
}
void unite(int u, int v) {
T[u].push_back(v);
T[v].push_back(u);
}
void unite(vector<vector<int>> &e) { T = e; }
void init() {
dfs(root, 0, 0);
int id = 0;
getid(root, 0, id);
}
int lca(int u, int v) const {
if (depth[u] > depth[v]) swap(u, v);
for (int k = 0; k < MAXLOGV; k++) {
if ((depth[v] - depth[u]) >> k & 1) {
v = parent[k][v];
}
}
if (u == v) return u;
for (int k = MAXLOGV - 1; k >= 0; k--) {
if (parent[k][u] != parent[k][v]) {
u = parent[k][u];
v = parent[k][v];
}
}
return parent[0][u];
}
int dist(int u, int v) const {
int p = lca(u, v);
return (depth[u] - depth[p]) + (depth[v] - depth[p]);
}
int dfs(int v, int p, int d) {
parent[0][v] = p;
depth[v] = d;
cnum[v] = 0;
for (int i = 1; i < MAXLOGV; i++) {
parent[i][v] = parent[i - 1][parent[i - 1][v]];
}
for (int next : T[v]) {
if (next != p) cnum[v] += dfs(next, v, d + 1);
}
return cnum[v] + 1;
}
void getid(const int v, const int p, int &nplace) {
place[v] = nplace;
id[nplace] = v;
nplace++;
for (int next : T[v]) {
if (next != p) getid(next, v, nplace);
}
}
static const int MAXLOGV = 25;
vector<vector<int>> T;
int V;
int root;
vector<int> parent[MAXLOGV];
vector<int> depth;
vector<int> cnum;
vector<int> place;
vector<int> id;
};
int main() {
int N, root;
cin >> N >> root;
ds = vector<int>(N, -1);
root--;
vector<int> nums(N);
for (int i = 0; i < N; ++i) {
cin >> nums[i];
}
vector<vector<int>> edges(N);
for (int i = 0; i < N - 1; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
edges[a].push_back(b);
edges[b].push_back(a);
}
vector<int> tos(1e5 + 1);
{
queue<int> que;
que.push(root);
ds[root] = 0;
int nid = 0;
while (!que.empty()) {
const int now(que.front());
que.pop();
tos[now] = nid++;
if (now == root) {
ds[now] = 0;
}
for (auto e : edges[now]) {
if (ds[e] != -1) {
ds[now] = ds[e] + 1;
} else {
que.push(e);
}
}
}
}
{
nums = ch(nums, tos);
root = tos[root];
edges = ch(edges, tos);
}
int id = 0;
dfs(edges, 0, 0, -1, id);
vector<vector<int>> doubles(N, vector<int>(19, 1e9));
vector<segtree> segs(19, N);
{
Tree t(N, 0);
t.unite(edges);
t.init();
auto p = t.parent;
for (int i = N - 1; i >= 0; --i) {
doubles[i][0] = nums[i];
for (int j = 1; j < 18; ++j) {
doubles[i][j] = min(doubles[i][j], doubles[i][j - 1]);
}
for (int j = 0; j < 18; ++j) {
doubles[p[j][i]][j + 1] = min(doubles[p[j][i]][j + 1], doubles[i][j]);
}
}
for (int i = 0; i < N; ++i) {
for (int j = 0; j < 18; ++j) {
segs[j].update(i, doubles[i][j]);
}
}
}
int pre = 0;
int Q;
cin >> Q;
bool flag = false;
if (Q > 10000) flag = true;
while (Q--) {
int x, k;
scanf("%d %d", &x, &k);
x = (x + pre) % N;
x = tos[x];
k = (k + pre) % N + 1;
const int xd = ds[x];
int num = 1;
for (int i = 0; i < 17; ++i) num *= 2;
int ans = 1e9;
int nplus = 0;
for (int i = 17; i >= 0; --i) {
if (k & num) {
auto at = lower_bound(ds.begin(), ds.end(), xd + nplus);
auto bt = upper_bound(at, ds.end(), xd + nplus);
auto lt = lower_bound(ls.begin() + (at - ds.begin()),
ls.begin() + (bt - ds.begin()), ls[x]);
auto rt = lower_bound(lt, ls.begin() + (bt - ds.begin()), rs[x]);
if (lt != rt) {
ans = min(ans, segs[i].query(lt - ls.begin(), rt - ls.begin()));
}
nplus += num;
}
num /= 2;
}
pre = ans;
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int buf_size = 1e5 + 5;
char buf[buf_size], *S, *T;
inline char gc() {
if (S == T) T = (S = buf) + fread(buf, 1, buf_size, stdin);
return S != T ? *(S++) : EOF;
}
inline int in() {
int x = 0, f = 1;
char c = gc();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = gc();
}
while (c >= '0' && c <= '9') x = x * 10 + c - 48, c = gc();
return x * f;
}
const int N = 1e5 + 5, inf = 1e9;
int n, m, r, q, tot, ans;
int a[N], dep[N], dfn[N], out[N], root[N], rt[N];
vector<int> v[N];
int val[N << 5], ls[N << 5], rs[N << 5];
pair<int, int> h[N];
void dfs(int x, int fa) {
dep[x] = dep[fa] + 1;
dfn[x] = ++tot;
for (int i = 0; i < v[x].size(); i++) {
int y = v[x][i];
if (y == fa) continue;
dfs(y, x);
}
out[x] = tot;
}
int add(int pre, int l, int r, int x, int y) {
int p = ++tot;
val[p] = min(val[pre], y), ls[p] = ls[pre], rs[p] = rs[pre];
if (l == r) return p;
int mid = l + r >> 1;
if (x <= mid)
ls[p] = add(ls[pre], l, mid, x, y);
else
rs[p] = add(rs[pre], mid + 1, r, x, y);
return p;
}
int query(int p, int l, int r, int ql, int qr) {
if (!p) return inf;
if (ql <= l && r <= qr) return val[p];
int mid = l + r >> 1;
int minn = inf;
if (ql <= mid) minn = min(minn, query(ls[p], l, mid, ql, qr));
if (qr > mid) minn = min(minn, query(rs[p], mid + 1, r, ql, qr));
return minn;
}
int main() {
n = in(), r = in();
for (int i = 1; i <= n; i++) a[i] = in();
val[0] = inf;
for (int i = 1; i < n; i++) {
int x = in(), y = in();
v[x].push_back(y);
v[y].push_back(x);
}
dfs(r, 0);
for (int i = 1; i <= n; i++) h[i] = make_pair(dep[i], i);
sort(h + 1, h + n + 1);
for (int i = 1; i <= n; i++) {
int x = h[i].second;
root[i] = add(root[i - 1], 1, n, dfn[x], a[x]);
rt[h[i].first] = root[i];
}
m = h[n].first;
q = in();
while (q--) {
int x = in(), k = in();
x = (x + ans) % n + 1, k = (k + ans) % n;
ans = query(rt[min(dep[x] + k, m)], 1, n, dfn[x], out[x]);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int ts, kk = 1;
int n, m, root;
int a[100005];
vector<int> al[100005];
map<int, int> tr[100005 * 4];
int st[100005], ft[100005], dfstm;
int ver[100005];
int ds[100005];
void dfs(int u, int par, int d) {
int i;
ver[dfstm] = u;
st[u] = dfstm++;
ds[u] = d;
for (i = 0; i < al[u].size(); i++) {
int v = al[u][i];
if (v == par) continue;
dfs(v, u, d + 1);
}
ft[u] = dfstm;
}
void bld(int i, int s, int e) {
if (s == e) {
tr[i][ds[ver[s]]] = a[ver[s]];
return;
}
bld(((i << 1) + 1), s, ((s + e) >> 1));
bld((((i << 1) + 1) + 1), ((s + e) >> 1) + 1, e);
auto lt = tr[((i << 1) + 1)].begin();
auto rt = tr[(((i << 1) + 1) + 1)].begin();
int mx = min(lt->first, rt->first);
int qs = 1000000007LL;
for (; lt != tr[((i << 1) + 1)].end() && rt != tr[(((i << 1) + 1) + 1)].end();
mx++) {
if (lt->first == mx) qs = min(qs, lt->second), lt++;
if (rt->first == mx) qs = min(qs, rt->second), rt++;
tr[i][mx] = qs;
}
for (; lt != tr[((i << 1) + 1)].end(); mx++) {
if (lt->first == mx) qs = min(qs, lt->second), lt++;
tr[i][mx] = qs;
}
for (; rt != tr[(((i << 1) + 1) + 1)].end(); mx++) {
if (rt->first == mx) qs = min(qs, rt->second), rt++;
tr[i][mx] = qs;
}
}
int qry(int i, int s, int e, int st, int ed, int k) {
if (k < tr[i].begin()->first) return 1000000007LL;
if (st <= s && e <= ed) {
auto x = tr[i].lower_bound(k);
if (x == tr[i].end()) return tr[i].rbegin()->second;
return x->second;
}
if (ed <= ((s + e) >> 1))
return qry(((i << 1) + 1), s, ((s + e) >> 1), st, ed, k);
if (((s + e) >> 1) < st)
return qry((((i << 1) + 1) + 1), ((s + e) >> 1) + 1, e, st, ed, k);
return min(qry(((i << 1) + 1), s, ((s + e) >> 1), st, ed, k),
qry((((i << 1) + 1) + 1), ((s + e) >> 1) + 1, e, st, ed, k));
}
int main() {
int t, i, j, k;
scanf("%d%d", &n, &root);
for (i = 1; i < n + 1; i++) scanf("%d", &a[i]);
for (i = 1; i < n; i++) {
scanf("%d%d", &j, &k);
al[j].push_back(k);
al[k].push_back(j);
}
dfs(root, -1, 0);
assert(dfstm == n);
bld(0, 0, dfstm - 1);
scanf("%d", &ts);
int ans = 0;
while (ts--) {
scanf("%d%d", &j, &k);
j = (j + ans) % n + 1;
k = (k + ans) % n;
ans = qry(0, 0, dfstm - 1, st[j], ft[j] - 1, ds[j] + k);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 4, sz = 320;
int n, r, a[N], in[N], out[N], d[N];
vector<int> g[N];
vector<pair<int, int> > v, tree[4 * N];
void dfs(int node, int parent = -1, int depth = 0) {
d[node] = depth;
in[node] = v.size();
v.push_back({depth, a[node]});
for (auto child : g[node]) {
if (child == parent) continue;
dfs(child, node, depth + 1);
}
out[node] = v.size() - 1;
}
void build(int node, int l, int r) {
if (l == r) {
tree[node].push_back(v[l]);
return;
}
int md = (l + r) >> 1;
build(node << 1, l, md);
build(node << 1 | 1, md + 1, r);
merge(tree[node << 1].begin(), tree[node << 1].end(),
tree[node << 1 | 1].begin(), tree[node << 1 | 1].end(),
back_inserter(tree[node]));
int mn = 2e9;
for (auto &it : tree[node]) mn = min(mn, it.second), it.second = mn;
}
int query(int node, int l, int r, int i, int j, int val) {
if (i > r || j < l || i > j) return 2e9;
if (l >= i && r <= j) {
auto it = upper_bound(tree[node].begin(), tree[node].end(),
make_pair(val, (int)2e9));
if (it == tree[node].begin()) return 2e9;
it--;
return it->second;
}
int md = (l + r) >> 1;
return min(query(node << 1, l, md, i, j, val),
query(node << 1 | 1, md + 1, r, i, j, val));
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> r;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(r);
build(1, 0, v.size() - 1);
int q;
cin >> q;
int last = 0;
while (q--) {
int p, q;
cin >> p >> q;
int x = (p + last) % n + 1;
int k = (q + last) % n;
last = query(1, 0, v.size() - 1, in[x], out[x], k + d[x]);
cout << last << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long Set(long long n, long long pos) { return n = n | (1 << pos); }
long long reset(long long n, long long pos) { return n = n & ~(1 << pos); }
bool check(long long n, long long pos) { return (bool)(n & (1 << pos)); }
long long n, root;
long long a[100005];
vector<long long> graph[100005];
long long st[100005];
long long en[100005];
long long timerr;
long long tm[2 * 100005];
long long diss[100005];
void dfs(long long src, long long par, long long dis) {
st[src] = timerr++;
diss[src] = dis;
tm[timerr - 1] = src;
for (long long i = 0; i < graph[src].size(); i++) {
long long adj = graph[src][i];
if (adj != par) {
dfs(adj, src, dis + 1);
}
}
en[src] = timerr++;
}
vector<long long> tree[4 * 2 * 100005];
vector<long long> mn[4 * 200005];
void build(long long n, long long b, long long e) {
if (b == e) {
if (tm[b]) {
tree[n].push_back(diss[tm[b]]);
mn[n].push_back(a[tm[b]]);
return;
}
return;
}
long long mid = (b + e) / 2;
build(n * 2, b, mid);
build(n * 2 + 1, mid + 1, e);
long long i = 0;
long long j = 0;
long long k;
while (1) {
if (i >= tree[n * 2].size()) {
while (j < tree[n * 2 + 1].size()) {
tree[n].push_back(tree[n * 2 + 1][j]);
mn[n].push_back(mn[n * 2 + 1][j]);
k = mn[n].size();
k--;
if (k > 0) {
mn[n][k] = min(mn[n][k - 1], mn[n][k]);
}
j++;
}
break;
}
if (j >= tree[n * 2 + 1].size()) {
while (i < tree[n * 2].size()) {
tree[n].push_back(tree[n * 2][i]);
mn[n].push_back(mn[n * 2][i]);
k = mn[n].size();
k--;
if (k > 0) {
mn[n][k] = min(mn[n][k - 1], mn[n][k]);
}
i++;
}
break;
}
if (tree[n * 2][i] < tree[n * 2 + 1][j]) {
tree[n].push_back(tree[n * 2][i]);
mn[n].push_back(mn[n * 2][i]);
k = mn[n].size();
k--;
if (k > 0) {
mn[n][k] = min(mn[n][k - 1], mn[n][k]);
}
i++;
} else {
tree[n].push_back(tree[n * 2 + 1][j]);
mn[n].push_back(mn[n * 2 + 1][j]);
k = mn[n].size();
k--;
if (k > 0) {
mn[n][k] = min(mn[n][k - 1], mn[n][k]);
}
j++;
}
}
}
long long query(long long n, long long b, long long e, long long i, long long j,
long long d, long long root) {
if (j < b || e < i) return (1LL << 62);
if (i <= b && e <= j) {
if (!tree[n].size()) return (1LL << 62);
long long k = upper_bound(tree[n].begin(), tree[n].end(), d + diss[root]) -
tree[n].begin();
k--;
if (k >= 0) {
return mn[n][k];
}
return (1LL << 62);
}
long long mid = (b + e) / 2;
long long x = query(n * 2, b, mid, i, j, d, root);
long long y = query(n * 2 + 1, mid + 1, e, i, j, d, root);
return min(x, y);
}
int main() {
long long q, x, d, u, v;
scanf("%lld", &n);
scanf("%lld", &root);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
timerr = 1;
for (long long i = 1; i <= n - 1; i++) {
scanf("%lld", &u);
scanf("%lld", &v);
graph[u].push_back(v);
graph[v].push_back(u);
}
dfs(root, -1, 0);
timerr--;
build(1, 1, timerr);
scanf("%lld", &q);
long long ans = 0;
for (long long i = 1; i <= q; i++) {
scanf("%lld", &x);
scanf("%lld", &d);
x = (x + ans) % n + 1;
d = (d + ans) % n;
ans = query(1, 1, timerr, st[x], en[x], d, x);
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
const int MAXM = 200010;
const int INF = 0x3fffffff;
int n, tot, sz;
int a[MAXN], to[MAXM], _next[MAXM], head[MAXN], root[MAXN], depth[MAXN];
struct node {
int mn, lc, rc;
node() { mn = INF, lc = 0, rc = 0; }
} f[MAXN * 50];
void Add_Edge(int u, int v) {
to[++tot] = v, _next[tot] = head[u], head[u] = tot;
}
void Modify(int &rt, int l, int r, int x, int y) {
rt = ++sz;
if (l == r) {
f[rt].mn = y;
return;
}
int mid = (l + r) / 2;
if (x <= mid)
Modify(f[rt].lc, l, mid, x, y);
else
Modify(f[rt].rc, mid + 1, r, x, y);
f[rt].mn = y;
}
int Query(int rt, int l, int r, int s, int t) {
if (s <= l && t >= r) return f[rt].mn;
int mid = (l + r) / 2, ans = INF;
if (s <= mid) ans = Query(f[rt].lc, l, mid, s, t);
if (t > mid) ans = min(ans, Query(f[rt].rc, mid + 1, r, s, t));
return ans;
}
int Merge(int u, int v) {
if (!u) return v;
if (!v) return u;
int now = ++sz;
f[now].lc = Merge(f[u].lc, f[v].lc);
f[now].rc = Merge(f[u].rc, f[v].rc);
f[now].mn = min(f[u].mn, f[v].mn);
return now;
}
void dfs(int u, int d) {
depth[u] = d;
Modify(root[u], 1, n, depth[u], a[u]);
for (int i = head[u]; i; i = _next[i]) {
int v = to[i];
if (depth[v]) continue;
dfs(v, d + 1);
root[u] = Merge(root[u], root[v]);
}
}
void Print(int u, int l, int r) {
if (u == 0) return;
printf("%d %d %d\n", l, r, f[u].mn);
int mid = (l + r) / 2;
Print(f[u].lc, l, mid);
Print(f[u].rc, mid + 1, r);
}
int main() {
int r;
scanf("%d%d", &n, &r);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int u, v;
for (int i = 1; i < n; i++) {
scanf("%d%d", &u, &v);
Add_Edge(u, v), Add_Edge(v, u);
}
dfs(r, 1);
int q;
scanf("%d", &q);
int last = 0, x, k;
for (int i = 1; i <= q; i++) {
scanf("%d%d", &x, &k);
x = (x + last) % n + 1, k = (k + last) % n;
printf("%d\n", last = Query(root[x], 1, n, depth[x], depth[x] + k));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, sz = 320;
int n, r, a[N], in[N], out[N], d[N], ind[N];
vector<int> g[N];
vector<pair<int, int> > v, tree[4 * N];
void dfs(int node, int parent = -1, int depth = 0) {
d[node] = depth;
in[node] = v.size();
v.push_back({depth, a[node]});
for (auto child : g[node]) {
if (child == parent) continue;
dfs(child, node, depth + 1);
}
out[node] = v.size() - 1;
}
void build(int node, int l, int r) {
if (l == r) {
tree[node].push_back(v[l]);
return;
}
int md = (l + r) >> 1;
build(node << 1, l, md);
build(node << 1 | 1, md + 1, r);
merge(tree[node << 1].begin(), tree[node << 1].end(),
tree[node << 1 | 1].begin(), tree[node << 1 | 1].end(),
back_inserter(tree[node]));
int mn = 2e9;
for (auto &it : tree[node]) mn = min(mn, it.second), it.second = mn;
}
int query(int node, int l, int r, int i, int j, int val) {
if (i > r || j < l || i > j) return 2e9;
if (l >= i && r <= j) {
auto it = upper_bound(tree[node].begin(), tree[node].end(),
make_pair(val, (int)2e9));
if (it == tree[node].begin()) return 2e9;
it--;
return it->second;
}
int md = (l + r) >> 1;
return min(query(node << 1, l, md, i, j, val),
query(node << 1 | 1, md + 1, r, i, j, val));
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> r;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
ind[y]++;
}
int root = 1;
for (int i = 1; i <= n; i++)
if (ind[i] == 0) root = i;
dfs(r);
build(1, 0, v.size() - 1);
int q;
cin >> q;
int last = 0;
while (q--) {
int p, q;
cin >> p >> q;
int x = (p + last) % n + 1;
int k = (q + last) % n;
last = query(1, 0, v.size() - 1, in[x], out[x], k + d[x]);
cout << last << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
const int N = 2e5 + 10;
const int lg = 20;
const int Nlg = N * lg;
const long long mod = 1e9 + 7;
const double PI = acos(-1);
inline long long mm(long long x, long long p) {
return x >= p ? x -= p : ((x < 0) ? x += p : x);
}
inline long long ab(long long x) { return x < 0 ? -x : x; }
vector<int> son[N];
int v[N], l[N], r[N], cnt, deep[N];
int node[Nlg], net[Nlg][2], tot, root[N];
pair<int, int> line[N];
void init() {
tot = 0;
node[0] = INF;
net[0][0] = net[0][1] = 0;
}
int copynode(int o) {
tot++;
node[tot] = node[o];
net[tot][0] = net[o][0];
net[tot][1] = net[o][1];
return tot;
}
void update(int x, int y, int l, int r, int o) {
node[o] = min(node[o], y);
if (l == r) return;
int mid = l + r >> 1;
if (x <= mid) {
net[o][0] = copynode(net[o][0]);
update(x, y, l, mid, net[o][0]);
} else {
net[o][1] = copynode(net[o][1]);
update(x, y, mid + 1, r, net[o][1]);
}
}
int query(int ll, int rr, int l, int r, int o) {
if (ll <= l && r <= rr) return node[o];
int mid = l + r >> 1, res = INF;
if (ll <= mid) res = min(res, query(ll, rr, l, mid, net[o][0]));
if (rr > mid) res = min(res, query(ll, rr, mid + 1, r, net[o][1]));
return res;
}
void dfs(int o, int fa) {
deep[o] = deep[fa] + 1;
l[o] = ++cnt;
for (auto it : son[o]) {
if (it == fa) continue;
dfs(it, o);
}
r[o] = cnt;
}
int main() {
int n, rt;
scanf("%d%d", &n, &rt);
for (int i = 1; i <= n; ++i) scanf("%d", &v[i]);
for (int i = 1, u, v; i < n; ++i) {
scanf("%d%d", &u, &v);
son[u].push_back(v);
son[v].push_back(u);
}
dfs(rt, 0);
for (int i = 1; i <= n; ++i) line[i] = {deep[i], i};
sort(line + 1, line + n + 1);
init();
for (int i = 1, pre = 0, x, y, id; i <= n; ++i) {
pre = copynode(pre);
root[line[i].first] = pre;
id = line[i].second;
x = l[id], y = v[id];
update(x, y, 1, n, pre);
}
int q, x, y, ans = 0, mx = line[n].first;
scanf("%d", &q);
while (q--) {
scanf("%d%d", &x, &y);
x += ans, y += ans;
x %= n, y %= n;
x++;
y = min(deep[x] + y, mx);
ans = query(l[x], r[x], 1, n, root[y]);
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
int cmpfunc(const void *a, const void *b) { return (*(int *)a) - (*(int *)b); }
int main() {
long long int a, b;
int arr1[20], arr2[20], flag[20] = {0}, i = 0, n1, n2, j, final[20], t,
tatti = 0, ind[20], x = 0;
scanf("%lld %lld", &a, &b);
while (a > 0) {
arr1[i] = a % 10;
a = a / 10;
i++;
}
n1 = i;
i = 0;
while (b > 0) {
arr2[i] = b % 10;
b = b / 10;
i++;
}
n2 = i;
i--;
t = 0;
qsort(arr1, n1, sizeof(int), cmpfunc);
if (n1 < n2) {
for (i = n1 - 1; i >= 0; i--) printf("%d", arr1[i]);
} else {
while (t < n1) {
for (j = n1 - 1; j >= 0; j--) {
if (flag[j] == 0 && arr1[j] <= arr2[i]) {
if (arr1[j] < arr2[i]) tatti = 1;
final[t] = arr1[j];
flag[j] = 1;
t++;
i--;
ind[x] = j;
x++;
break;
}
}
while (j == -1) {
i++;
t--;
x--;
flag[ind[x]] = 0;
for (j = n1 - 1; j >= 0; j--) {
if (flag[j] == 0 && arr1[j] < arr2[i]) {
tatti = 1;
final[t] = arr1[j];
flag[j] = 1;
t++;
i--;
break;
}
}
}
if (tatti == 1) {
for (j = n1 - 1; j >= 0; j--) {
if (flag[j] == 0) {
final[t] = arr1[j];
t++;
}
}
}
}
for (i = 0; i < n1; i++) printf("%d", final[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int A[20], B[20], cnt[20];
multiset<int> se;
vector<int> ans;
bool dfs(int pos, bool limt) {
if (pos == -1) {
for (int i = 0; i < ans.size(); ++i) cout << ans[i];
puts("");
return 1;
}
for (int i = 9; i >= 0; --i) {
if (cnt[i] == 0) continue;
if (limt && i > B[pos]) continue;
cnt[i]--;
ans.push_back(i);
if (dfs(pos - 1, limt && i == B[pos])) return 1;
cnt[i]++;
ans.pop_back();
}
return 0;
}
void solve(long long a, long long b) {
memset(cnt, 0, sizeof cnt);
ans.clear();
int k1 = 0;
while (a) {
A[k1++] = a % 10;
a /= 10;
}
int k2 = 0;
while (b) {
B[k2++] = b % 10;
b /= 10;
}
if (k2 > k1) {
sort(A, A + k1, greater<int>());
for (int i = 0; i < k1; ++i) cout << A[i];
puts("");
return;
}
for (int i = 0; i < k1; ++i) cnt[A[i]]++;
dfs(k1 - 1, 1);
}
int main() {
long long a, b;
while (cin >> a >> b) solve(a, b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int K;
string a, b;
char s[20];
int fr[10];
void rec(int p, int ok) {
if (p >= a.size()) {
cout << s;
K = 1;
return;
}
if (ok == 1) {
for (int j = 9; j >= 0; j--)
if (fr[j]) {
s[p] = (char)(j + '0');
fr[j]--;
rec(p + 1, ok);
}
return;
}
for (int j = 9; j >= 0; j--)
if (fr[j] && j <= b[p] - '0') {
if (j <= b[p] - '0') {
s[p] = (char)(j + '0');
fr[j]--;
}
if (j < b[p] - '0')
rec(p + 1, 1);
else
rec(p + 1, ok);
if (K == 1) return;
fr[j]++;
}
}
int main() {
cin >> a >> b;
int ok = 0;
for (int i = 0; i < a.size(); i++) fr[a[i] - '0']++;
if (b.size() > a.size()) ok = 1;
rec(0, ok);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.