树的直径学习笔记

树的直径
给定一棵树,树中每条边都有一个权值,树中两点之间的距离定义为连接两点的路径边权之和。树中最远的两个节点之间的距离被称为树的直径,连接这两点的路径被称为树的最长链。后者通常也可称为直径,即直径是一个
数值概念,也可代指一条路径
树的直径通常有两种求法,时间复杂度均为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)求树的直径
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求树的直径

 

posted @ 2018-07-02 17:48  YuWenjue  阅读(8104)  评论(1编辑  收藏  举报