zoukankan      html  css  js  c++  java
  • 树的直径学习笔记

    树的直径
    给定一棵树,树中每条边都有一个权值,树中两点之间的距离定义为连接两点的路径边权之和。树中最远的两个节点之间的距离被称为树的直径,连接这两点的路径被称为树的最长链。后者通常也可称为直径,即直径是一个
    数值概念,也可代指一条路径
    树的直径通常有两种求法,时间复杂度均为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求树的直径
  • 相关阅读:
    测试杯子
    如何测试网页的登录页面
    功能性测试之边界值测试
    自动化 sample
    软件架构---敏捷和架构的关系
    软件架构---分布式后端架构应该考虑的一些方面
    软件架构---集群与负载均衡
    软件架构---从需求明确架构设计驱动力
    软件架构---质量属性的实现
    软件架构---质量属性(二)
  • 原文地址:https://www.cnblogs.com/ywjblog/p/9254997.html
Copyright © 2011-2022 走看看