【BZOJ 3083】遥远的国度

这道题很简单的连剖+分类讨论，但是SDOI Round2要来了，不会手动栈怎么办呢？只好用一下这道题练习一下手动栈了，结果调了一天多QwQ

链剖的第一个dfs用bfs水过就行，但是我自以为是地把倍增写错了，坑了好久啊QAQ

这道题因为要询问子树，连剖的第二个dfs就不能再用bfs水过了，只能强行手动栈。

一开始拍小数据拍出了好多错，改过来后拍了无数组极限数据也拍不出来，因为构造的极限数据太弱了(偷懒构造u<v)根本无法暴露倍增的漏洞啊！！！

手残错误毁一生，写代码时不要自以为是。希望SD省选能够给我们一个更好的编程环境和评测环境(NOILinux恐怕是奢望吧)

#include<stack>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 100003;
const int inf = 0x7fffffff;
void read(int &k) {
k = 0; int fh = 1; char c = getchar();
for(; c < '0' || c > '9'; c = getchar())
if (c == '-') fh = -1;
for(; c >= '0' && c <= '9'; c = getchar())
k = (k << 1) + (k << 3) + c - '0';
k = k * fh;
}

struct node {int nxt, to;} E[N << 1];
int n, m, point
, cnt = 0, pos
, wt
, deep
;
int lazy[N * 8], mn[N * 8], top
, sz
, f
[18], root, a
, son
;

void ins(int x, int y) {E[++cnt] = (node) {point[x], y}; point[x] = cnt;}
stack <int> S;
int qu
;
void _() {
int p = 0, q = 1; qu[1] = 1;
while (p != q) {
int u = qu[++p];
for(int tmp = point[u]; tmp; tmp = E[tmp].nxt)
if (E[tmp].to != f[u][0])
f[E[tmp].to][0] = u, deep[E[tmp].to] = deep[u] + 1, qu[++q] = E[tmp].to;
}
for(int i = q; i >= 1; --i) {
int u = qu[i], fa = f[u][0];
++sz[u];
sz[fa] += sz[u];
if (sz[u] > sz[son[fa]]) son[fa] = u;
}
for(int j = 1; j <= 17; ++j)
for(int i = 1; i <= n; ++i)
f[i][j] = f[f[i][j - 1]][j - 1];
}
void __() {
top[1] = 1; cnt = 0;
S.push(1);
while (!S.empty()) {
int u = S.top(); S.pop();
pos[++cnt] = u; wt[u] = cnt;
for(int tmp = point[u]; tmp; tmp = E[tmp].nxt)
if (E[tmp].to != f[u][0] && E[tmp].to != son[u])
top[E[tmp].to] = E[tmp].to, S.push(E[tmp].to);
if (son[u]) {top[son[u]] = top[u]; S.push(son[u]);}
}
}
/* 下面是正确的人工栈模板，完美模拟dfs，但是我学会它不到5小时我就用bfs把它淘汰了
void _() {
S.push(Data(1, point[1]));
sz[1] = 1;
while (!S.empty()) {
int x = S.top().x, y = S.top().y; S.pop();
if (y) {
S.push(Data(x, E[y].nxt));
int v = E[y].to;
if (v != f[x][0]) {
f[v][0] = x;
sz[v] = 1;
deep[v] = deep[x] + 1;
for(int i = 1; i <= 17; ++i) {f[v][i] = f[f[v][i - 1]][i - 1]; if (f[v][i] == 0) break;}
S.push(Data(v, point[v]));
}
} else {
if (!S.empty()) {
sz[S.top().x] += sz[x];
if (sz[x] > sz[son[S.top().x]]) son[S.top().x] = x;
}
}
}
}*/

void pushdown(int rt) {
if (lazy[rt]) {
mn[rt << 1] = mn[rt << 1 | 1] = lazy[rt << 1] = lazy[rt << 1 | 1] = lazy[rt];
lazy[rt] = 0;
}
}
void pushup(int rt) {mn[rt] = min(mn[rt << 1], mn[rt << 1 | 1]);}
void Build(int rt, int l, int r) {
if (l == r) {mn[rt] = a[pos[l]]; mn[rt << 1] = mn[rt << 1 | 1] = inf; return;}
int mid = (l + r) >> 1;
Build(rt << 1, l, mid);
Build(rt << 1 | 1, mid + 1, r);
pushup(rt);
}
void add(int rt, int l, int r, int L, int R, int x) {
if (L <= l && r <= R) {lazy[rt] = x; mn[rt] = x; return;}
int mid = (l + r) >> 1;
pushdown(rt);
if (L <= mid) add(rt << 1, l, mid, L, R, x);
if (R > mid) add(rt << 1 | 1, mid + 1, r, L, R, x);
pushup(rt);
}
void Add(int x, int y, int z) {
for(; top[x] != top[y]; x = f[top[x]][0]) {
if (deep[top[x]] < deep[top[y]]) swap(x, y);
add(1, 1, n, wt[top[x]], wt[x], z);
}
if (deep[x] < deep[y]) swap(x, y);
add(1, 1, n, wt[y], wt[x], z);
}
int QQ(int rt, int l, int r, int L, int R) {
if (L <= l && r <= R) return mn[rt];
int mid = (l + r) >> 1, s = inf;
pushdown(rt);
if (L <= mid) s = min(s, QQ(rt << 1, l, mid, L, R));
if (R > mid) s = min(s, QQ(rt << 1 | 1, mid + 1, r, L, R));
return s;
}
int Q(int L, int R) {
if (L > n || R < 1 || L > R) return inf;
return QQ(1, 1, n, L, R);
}

int lower;
int LCA(int x, int y) {
if (deep[x] < deep[y]) return 1;
for(int i = 16; i >= 0; --i) if (deep[f[x][i]] > deep[y]) x = f[x][i];
lower = x;
return f[x][0] != y;
}

int main() {
read(n); read(m);
int u, v, op, x;
for(int i = 1; i < n; ++i) {
read(u); read(v);
ins(u, v); ins(v, u);
}

_();
__();

for(int i = 1; i <= n; ++i) read(a[i]);

Build(1, 1, n);

read(root);
for(int i = 1; i <= m; ++i) {
read(op);
switch (op) {
case 1:
read(root);
break;
case 2:
read(u); read(v); read(x);
Add(u, v, x);
break;
case 3:
read(u);
if (root == u)
printf("%d\n", Q(1, n));
else
if (LCA(root, u)) {
printf("%d\n", Q(wt[u], wt[u] + sz[u] - 1));
} else {
v = min(Q(1, wt[lower] - 1), Q(wt[lower] + sz[lower], n));
printf("%d\n", v);
}
break;
}
}

return 0;
}

注释掉了能够完美模拟dfs但并没有什么用的手动栈= =