1.定義
dfs序：每個節點在dfs深度優先遍歷中的進出棧的時間序列
dfs序就是A-B-D-D-E-G-G-E-B-C-F-H-H-F-C-A
2.性質
為了便於理解，我們舉個example
我們都知道它的dfs序A-B-D-D-E-G-G-E-B-C-F-H-H-F-C-A
我們可以發現B的出入棧時間點之間的是B的子樹
因為搜索進下一個點時時間增加，且結束時間逐級傳遞。
所以說我們的點的子節點的時間區間一定包含在這個點的時間區間內。
所以如果一個點的起始時間和終結時間被另一個點包括，這個點肯定是另一個點的子節點。（簡稱括號化定理）
也就是說，子樹的dfs序肯定大於根節點的進棧時間小於根節點的出棧時間，這就成了一個區間問題。所以我們就把一個樹上的問題“拍”到了一個線性的數據結構上面。區間問題就可以用線段樹、樹狀數組、splay...各種優秀的算法解決了
3.時間戳
時間戳記錄第一次開始訪問這個點的時間和和最后結束訪問的時間
void dfs(int node,int parent){
NewIdx[NCnt] = node;
InOut[NCnt] = 1;
InIdx[node] = NCnt++;
for(int next=Vertex[node];next;next=Edge[next].next){
int son = Edge[next].to;
if ( son != parent ) dfs(son,node);
}
NewIdx[NCnt] = node;
InOut[NCnt] = -1;
OutIdx[node] = NCnt++;
}
dfs序求lca
點u,v的LCA還滿足它是其中一個點的最近的一個祖先，滿足u,v都在它的子樹中。
判斷一個點是否在另一個點的子樹中，我們可以用dfs序來判斷。
這是倍增的另一種判斷方法：
void dfs(int p, int fa) {
bz[p][0] = fa, in[p] = ++cnt;
for (int i = 1; i < bzmax; i++)
bz[p][i] = bz[bz[p][i - 1]][i - 1];
for (int i = g.h[p]; ~i; i = g[i].nx) {
int e = g[i].ed;
if (e == fa) continue;
dfs(e, p);
}
out[p] = cnt;
}
int lca(int a, int b) {
if (dep[a] > dep[b]) swap(a, b);
if (in[a] <= in[b] && out[a] >= out[b])
return a;
for (int i = bzmax - 1, nx; ~i; i--) {
nx = bz[a][i];
if (!(in[nx] <= in[b] && out[nx] >= out[b]))
a = nx;
}
return bz[a][0];
簡單的模板題
從前有一棵以1為根的有根樹，
樹的每個節點有一個權值。
現在請你維護如下操作：
1、令節點x的權值增加y
2、詢問以節點x為根的子樹中所有節點的權值和。
一眼題，dfs序把樹上問題轉化為區間問題，然后線段樹單點修改，區間查詢
還是簡單的模板體
樹的每個節點有一個權值。
現在請你維護如下操作：
1、將以節點x為根的子樹中所有節點的權值增加y
2、詢問節點x的權值。
操作變成區間修改，單點查詢
普通的模板體
從前有一棵以1為根的有根樹，
樹的每個節點有一個權值。
現在請你維護如下操作：
1、將從節點x出發到節點y路徑上的所有節點權值增加z。
2、詢問節點x的權值。
一道裸的樹鏈剖分題，還有什么方法可以解決呢？
這個操作等價於
a. 對X到根節點路徑上所有點權加W
b. 對Y到根節點路徑上所有點權加W
c. 對LCA(x, y)到根節點路徑上所有點權值減W
d. 對LCA(x,y)的父節點 father(LCA(x, y))到根節點路徑上所有權值減W
於是要進行四次這樣從一個點到根節點的區間修改
將問題進一步簡化, 進行一個點X到根節點的區間修改, 查詢其他一點Y時
只有X在Y的子樹內, X對Y的值才有貢獻且貢獻值為W
於是只需要更新四個點, 查詢一個點的子樹內所有點權的和即可
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
const int MAXN = 1e5+10;
vector<int> edge[MAXN];
int s[2*MAXN];
int seq[2*MAXN];
int seq1[2*MAXN];
int depth[2*MAXN];
int first[MAXN];
int dp[2*MAXN][25];
int st[MAXN];
int ed[MAXN];
int parent[MAXN];
int cnt, num;
int Lowbit(int x)
{
return x & (-x);
}
void Add(int x, int val, int n)
{
if(x <= 0) return;
for(int i = x; i <= n; i += Lowbit(i)) {
s[i] += val;
}
}
int Sum(int x)
{
int res = 0;
for(int i = x; i > 0; i -= Lowbit(i)) {
res += s[i];
}
return res;
}
void Dfs(int u, int fa, int dep)
{
parent[u] = fa;
seq[++cnt] = u;
seq1[++num] = u;
first[u] = num;
depth[num] = dep;
st[u] = cnt;
int len = edge[u].size();
for(int i = 0; i < len; i++) {
int v = edge[u][i];
if(v != fa) {
Dfs(v, u, dep+1);
seq1[++num] = u;
depth[num] = dep;
}
}
seq[++cnt] = u;
ed[u] = cnt;
}
void RMQ_Init(int n)
{
for(int i = 1; i <= n; i++) {
dp[i][0] = i;
}
for(int j = 1; (1 << j) <= n; j++) {
for(int i = 1; i + (1 << j) - 1 <= n; i++) {
int a = dp[i][j-1], b = dp[i + (1 << (j-1))][j-1];
dp[i][j] = depth[a] < depth[b] ? a : b;
}
}
}
int RMQ_Query(int l, int r)
{
int k = 0;
while((1 << (k + 1)) <= r - l + 1) k++;
int a = dp[l][k], b = dp[r-(1<<k)+1][k];
return depth[a] < depth[b] ? a : b;
}
int LCA(int u, int v)
{
int a = first[u], b = first[v];
if(a > b) a ^= b, b ^= a, a ^= b;
int res = RMQ_Query(a, b);
return seq1[res];
}
void Init(int n)
{
for(int i = 0; i <= n; i++) {
edge[i].clear();
}
memset(s, 0, sizeof(s));
}
int main()
{
int n, op;
int u, v, w;
int cmd;
while(scanf("%d %d", &n, &op) != EOF) {
Init(n);
for(int i = 0; i < n-1; i++) {
scanf("%d %d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
cnt = 0, num = 0;
Dfs(1, -1, 0);
RMQ_Init(num);
while(op--) {
scanf("%d", &cmd);
if(cmd == 0) {
scanf("%d %d %d", &u, &v, &w);
int lca = LCA(u, v);
Add(st[u], w, cnt);
Add(st[v], w, cnt);
Add(lca, -w, cnt);
Add(parent[lca], -w, cnt);
}
else if(cmd == 1) {
scanf("%d", &u);
printf("%d\n", Sum(ed[u]) - Sum(st[u] - 1));
}
}
}
return 0;
}