樹的直徑

樹的直徑
給定一棵樹，樹中每條邊都有一個權值，樹中兩點之間的距離定義爲鏈接兩點的路徑邊權之和。樹中最遠的兩個節點之間的距離被稱爲樹的直徑，鏈接這兩點的路徑被稱爲樹的最長鏈。後者一般也可稱爲直徑，即直徑是一個
數值概念，也可代指一條路徑
樹的直徑一般有兩種求法，時間複雜度均爲O(n)。咱們假設樹以N個點N-1條邊的無向圖形式給出，並存儲在鄰接表中。

樹形DP求樹的直徑
設1號節點爲根,"N個點N-1條邊的無向圖"就能夠看作「有根樹」
設d[x]表示從節點x出發走向以x爲根的子樹，可以到達的最遠節點的距離。設x的子節點爲y1,y2, y3, ..., yt，edge(x, y)表示邊權，顯然有"
d[x] = max{d[yi] + edge(x, yi)}(1 <= i <= t)
接下來，咱們能夠考慮對每一個節點x求出"通過節點x的最長鏈的長度"f[x]，整棵樹的直徑就是max{f[x]}(1 <= x <= n)
對於x的任意兩個節點yi和yj，"通過節點x的最長鏈長度"能夠經過四個部分構成：從yi到yi子樹中的最遠距離，邊(x, yi)，邊(x, yj)，從yj到yj子樹中的最遠距離。設j < i，所以：
f[x] = max{d[yi] + d[yj] + edge(x, yi) + edge(x, yj)}(1 <= j < i <= t)
可是咱們沒有必要使用兩層循環來枚舉i, j。在計算d[x]的霍城，子節點的循環將要枚舉到i時d[x]剛好就保存了從節點x出發走向「以yj(j < i)爲根的子樹」，可以到達的最遠節點的距離，這個距離就是max{d[yi] +edge(x, yi)}(1
<= j < i)。因此咱們先用d[x] + d[yi] + edge(x, yi)更新f[x]，再用d[yi] + edge(x, yi)更新d[x]便可

 1 void dp(int x) {
 2     v[x] = 1;
 3     for(int i = head[x]; i; i = net[i]) {
 4         int y = ver[i];
 5         if(v[y]) continue;
 6         dp(y);
 7         ans = max(ans, d[x] + d[y] + edge[i]);
 8         d[x] = max(d[x], d[y] + edge[i]);
 9     }
10 }

View Code

 

兩次BFS（DFS）求樹的直徑
經過兩次BFS或者兩次DFS也能夠求樹的直徑，而且更容易計算出直徑上的具體節點
詳細地說，這個作法包含兩步：
1.從任意節點出發，經過BFS和DFS對樹進行一次遍歷，求出與出發點距離最遠的節點記爲p
2.從節點p出發，經過BFS或DFS再進行一次遍歷，求出與p距離最遠的節點，記爲q。
從p到q的路徑就是樹的一條直徑。由於p必定是直徑的一端，不然總能找到一條更長的鏈，與直徑的定義矛盾。顯然地腦洞一下便可。p爲直徑的一端，那麼天然的，與p最遠的q就是直徑的另外一端。
在第2步的遍歷中，能夠記錄下來每一個點第一次被訪問的前驅節點。最後從q遞歸到p，便可獲得直徑的具體方案

 

 1 #include<bits/stdc++.h>
 2 using namespace std;
 3 const int maxn = 100086;
 4 struct picture {
 5     int y, v, net;
 6     int pre;
 7 }e[maxn];
 8 int lin[maxn], len = 0;
 9 int n, m, dis[maxn];
10 bool vis[maxn];
11 int start, end;
12 
13 inline int read() {
14     int x = 0, y = 1;
15     char ch = getchar();
16     while(!isdigit(ch)) {
17         if(ch == '-') y = -1;
18         ch = getchar();
19     } 
20     while(isdigit(ch)) {
21         x = (x << 1) + (x << 3) + ch - '0';
22         ch = getchar();
23     }
24     return x * y;
25 }
26 
27 inline void insert(int xx, int yy, int vv) {
28     e[++len].y = yy;
29     e[len].v = vv;
30     e[len].net = lin[xx];
31     e[len].pre = xx;
32     lin[xx] = len;
33 }
34 
35 void dfs(int st) {
36     vis[st] = 1;
37     for(int i = lin[st]; i; i = e[i].net) {
38         int to = e[i].y;
39         if(!vis[to]) {
40             dis[to] = dis[st] + e[i].v;
41             dfs(to);
42         }
43     }
44 }
45 
46 int main() {
47     memset(vis, 0, sizeof(vis));
48     memset(dis, 0x3f3f3f, sizeof(dis));
49     n = read(), m = read();
50     for(int i = 1; i <= m; ++i) {
51         int x, y, v;
52         x = read(), y = read(), v = read();
53         insert(x, y, v);
54         insert(y, x, v);
55     }
56     dis[1] = 0;
57     dfs(1);
58     int maxx = -1000;
59     for(int i = 1; i <= n; ++i) 
60         if(dis[i] > maxx && dis[i] != 1061109567) {
61             maxx = dis[i];
62             start = i;
63         }
64     cout << maxx << ' ' << start << '\n';
65     memset(vis, 0, sizeof(vis));
66     memset(dis, 0x3f3f3f,sizeof(dis));
67     dis[start] = 0;
68     dfs(start);
69     maxx = -1000;
70     for(int i = 1; i <= n; ++i) 
71         if(dis[i] > maxx && dis[i] != 1061109567) {
72             maxx = dis[i];
73             end = i;
74         }
75     cout << start << ' ' << maxx << ' ' << end << '\n';
76     return 0;
77 }

DFS求樹的直徑

 

 1 #include<bits/stdc++.h>
 2 #define ll long long
 3 using namespace std;
 4 const int maxn = 100086;
 5 const ll inf = 1061109567;
 6 struct picture {
 7     int y, net, v;
 8     int pre;
 9 }e[maxn];
10 int n, m;
11 int lin[maxn], len = 0;
12 int dis[maxn];
13 int q[maxn], head = 0, tail = 0;
14 int start, end;
15 bool vis[maxn];
16 
17 inline int read() {
18     int x = 0, y = 1;
19     char ch = getchar();
20     while(!isdigit(ch)) {
21         if(ch == '-') y = -1;
22         ch = getchar();
23     }
24     while(isdigit(ch)) {
25         x = (x << 1) + (x << 3) + ch - '0';
26         ch = getchar();
27     }
28     return x * y;
29 }
30 
31 inline void insert(int xx, int yy, int vv) {
32     e[++len].pre = xx;
33     e[len].y = yy;
34     e[len].v = vv;
35     e[len].net = lin[xx];
36     lin[xx] = len;
37 }
38 
39 inline void bfs(int st) {
40     head = tail = 0;
41     vis[st] = 1;
42     q[++tail] = st;
43     while(head < tail) {
44         //cout << head << '\n';
45         for(int i = lin[q[++head]]; i; i = e[i].net) {
46             int to = e[i].y;
47             if(!vis[to]) {
48                 dis[to] = dis[q[head]] + e[i].v;
49                 vis[to] = 1;
50                 q[++tail] = to;
51             }
52         }
53     }
54 }
55 
56 int main() {
57     n = read(), m = read();
58     for(int i = 1; i <= m; ++i) {
59         int x, y, v;
60         x = read(), y = read(), v = read();
61         insert(x, y, v);
62         insert(y, x, v);
63     }
64     memset(dis, 0x3f3f3f, sizeof(dis));
65     memset(vis, 0, sizeof(vis));
66     dis[1] = 0;
67     bfs(1);
68     int maxx = -1000;
69     for(int i = 1; i <= n; ++i) 
70         if(dis[i] > maxx && dis[i] != inf) {
71             start = i;
72             maxx = dis[i];
73         }
74     cout << maxx << ' ' << start << '\n';
75     memset(dis, 0x3f3f3f, sizeof(dis));
76     memset(vis, 0, sizeof(vis));
77     dis[start] = 0;    
78     bfs(start);
79     maxx = -1000;
80     for(int i = 1; i <= n; ++i) 
81         if(dis[i] > maxx && dis[i] != inf) {
82             end = i;
83             maxx = dis[i];
84         }
85     cout << start << ' ' << maxx << ' ' << end << '\n';
86     return 0;
87 }
88  

BFS求樹的直徑