dfs序

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爲根的有根樹，

樹的每一個節點有一個權值。

 

如今請你維護以下操做：

 

一、令節點x的權值增長y

 

二、詢問以節點x爲根的子樹中全部節點的權值和。

 

一眼題，dfs序把樹上問題轉化爲區間問題，而後線段樹單點修改，區間查詢

仍是簡單的模板體

 

樹的每一個節點有一個權值。

 

如今請你維護以下操做：

 

一、將以節點x爲根的子樹中全部節點的權值增長y

 

二、詢問節點x的權值。

操做變成區間修改，單點查詢

普通的模板體

從前有一棵以1爲根的有根樹，

樹的每一個節點有一個權值。

如今請你維護以下操做：

一、將從節點x出發到節點y路徑上的全部節點權值增長z。

二、詢問節點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;
}