树的问题小结(最小生成树、次小生成树、最小树形图、LCA、最小支配集、最小点覆盖、最大独立集)

树的定义:连通无回路的无向图是一棵树。

有关树的问题:

1、最小生成树。

2、次小生成树。

3、有向图的最小树形图。

4、LCA(树上两点的最近公共祖先)。

5、树的最小支配集、最小点覆盖、最大独立集。

一、最小生成树

解决的问题是:求无向图中边权值之和最小的生成树。

算法有Kruskal和Prim。

Kruskal使用前向星和并查集实现,可以存储重边(平行边),时间复杂度是O(m log m  +  m),m是边的数量。

Prim使用邻接矩阵建图,不可以存储重边(平行边),如果出现重边,存储的是权值最小的那一条,时间复杂度为O(n*n), n是顶点的数量。使用邻接表建图可能会提高效率。

一般情况下,题目都是比较裸的。难度为易。

模版:建好图以后,直接调用,输出。

prim

 1 const int maxn=101,INF=0x3f3f3f3f;
 2 int dist[maxn],Map[maxn][maxn],pre[maxn];
 3 //向外延伸的最短边长,记录图信息,记录连接信息
 4 bool p[maxn];//1表示点已经在树的,0表示点在树外
 5 bool f[maxn][maxn];
 6 int Prim(int n)
 7 {
 8     int i,j,k,Min,ans=0;
 9     for(i=2;i<=n;i++)
10     {
11         p[i]=0;
12         dist[i]=Map[1][i];
13         pre[i]=1;
14     }
15     dist[1]=0;
16     p[1]=1;
17     for(i=1;i<n;i++)
18     {
19         Min=INF;
20         k=0;
21         for(j=1;j<=n;j++)
22         {
23             if(!p[j]&&dist[j]<Min)
24             {
25                 Min=dist[j];
26                 k=j;
27             }
28         }
29         if(k==0) return -1;//G不连通
30         ans+=Min;
31         p[k]=1;
32         for(j=1;j<=n;j++)
33         {
34             if(!p[j]&&Map[k][j]!=INF&&dist[j]>Map[k][j])
35             {
36                 dist[j]=Map[k][j];
37                 pre[j]=k;
38             }
39         }
40     }
41     return ans;
42 }

Kruskal

 1 const int N=1010,M=100010;
 2 int f[N],r[N];
 3 struct node
 4 {
 5     int x, y, len;
 6 }e[M];
 7 int cmp(const node &a,const node &b)
 8 {
 9     return a.len<b.len;
10 }
11 void Make_Set(int n)
12 {
13     for(int i=0;i<=n;i++)
14     {
15         f[i]=i;
16         r[i]=1;
17     }
18 }
19 void Link(int a, int b)
20 {
21     if (r[a] > r[b]) {f[b] = a; r[a]+=r[b];}
22     else {f[a] = b; r[b]+=r[a];}
23 }
24 int Find_Set(int a)
25 {
26     if (a == f[a]) return a;
27     else return  f[a] = Find_Set(f[a]);
28 }
29 int Kruskal(int n,int m)
30 {
31     int i, j, k, s=0,cn=0;
32     Make_Set(n);
33     sort(e,e+m,cmp);
34     for(i=0;i<m;i++)
35     {
36         j=Find_Set(e[i].x);
37         k=Find_Set(e[i].y);
38         if(j!=k) {
39             Link(j,k);
40             s+=e[i].len;
41             cn++;
42         }
43         if(cn==n-1) break;
44     }
45     if(cn<n-1) return -1;
46     return s;
47 }

二、次小生成树

1、最朴素的办法就是暴力枚举。求一遍最小生成树以后,依次删除最小生成树上的边,求此时的最小生成树,值最小的就是我们所求的。总共要运行 n次最小生成树算法,时间复杂度为n倍最小生成树算法的复杂度。有些题目能AC。暴力枚举在没有好方法时,也是一种非常好的方法。

2、我们知道,添加任意一条不在最小生成树上的边以后一定会形成一个环。找到环上除了(u,v)以外的权值最大的边,把它删掉,那么此时生成树就可能是次小生成树。基于这种思想:首先求出原图最小生成树,权值之和为MST。在执行最小最小生成树算法的时候,记录任意两点(u,v)路径之间的最大权值,maxe[u][v]。注意,不是记录以u与v为起点和终点的边的最大值,是两点之间的路径,可能有多个点在它们之间。然后枚举每一条边,如果该边不是原本最小生成树上的边,就用MST - maxe[u][v] + Map[u][v],统计结果最小的。

需要知道的是次小生成树的权值和可以与最小生成树的权值和相等。

模版:

prim(直接贴poj1679的代码了)

 1 #include<iostream>
 2 #include<cstring>
 3 #include<cstdio>
 4 #include<algorithm>
 5 using namespace std;
 6
 7 const int maxn=1100,INF=0x3f3f3f3f;
 8 int dist[maxn],Map[maxn][maxn],pre[maxn],maxe[maxn][maxn];
 9 //向外延伸的最短边长,记录图信息,记录连接信息,最长边
10 bool vis[maxn];//1表示点已经在树的,0表示点在树外
11 bool f[maxn][maxn];//存在边为1,用过为0
12 int n,m;//顶点数目
13 int Prim()
14 {
15     int i,j,k,Min,ans=0;
16     memset(vis,0,sizeof(vis));
17     memset(f,0,sizeof(f));
18     memset(maxe,0,sizeof(maxe));
19     for(i=2;i<=n;i++)
20     {
21         dist[i]=Map[1][i];
22         pre[i]=1;
23     }
24     dist[1]=0;
25     vis[1]=1;
26     pre[1]=0;
27     for(i=1;i<n;i++)
28     {
29         Min=INF;
30         k=0;
31         for(j=1;j<=n;j++)
32         {
33             if(!vis[j]&&dist[j]<Min)
34             {
35                 Min=dist[j];
36                 k=j;
37             }
38         }
39         if(Min==INF) return -1;//G不连通
40         vis[k]=1;
41         ans+=Min;
42         f[pre[k]][k] = f[k][pre[k]]=1;
43         for(j=1;j<=n;j++)
44         {
45             if(vis[j]) maxe[k][j]=maxe[j][k]=max(maxe[j][pre[k]],dist[k]);
46             if(!vis[j]&&dist[j]>Map[k][j])
47             {
48                 dist[j]=Map[k][j];
49                 pre[j]=k;
50             }
51         }
52     }
53     return ans;
54 }
55 void init()
56 {
57     for(int i=0;i<=n;i++)
58         for(int j=0;j<=n;j++)
59         {
60             if(i==j)Map[i][j]=0;
61             else Map[i][j]=INF;
62         }
63 }
64 int main()
65 {
66     //freopen("test.txt","r",stdin);
67     int i,j,k,a,b,c,ca;
68     scanf("%d",&ca);
69     while(ca--)
70     {
71         scanf("%d%d",&n,&m);
72         init();
73         for(i=0;i<m;i++)
74         {
75             scanf("%d%d%d",&a,&b,&c);
76             Map[a][b]=Map[b][a]=c;
77         }
78         int ans=Prim();
79         if(ans==-1) {printf("Not Unique!\n");continue;}
80         int res=INF;
81         for(i=1;i<=n;i++)
82         {
83             for(j=i+1;j<=n;j++)
84             {
85                 if(!f[i][j]&&Map[i][j]!=INF)
86                 {
87                     res=(res,ans+Map[i][j]-maxe[i][j]);
88                 }
89             }
90         }
91         if(res==ans) printf("Not Unique!\n");
92         else printf("%d\n",ans);
93     }
94     return 0;
95 }

kruskal

 1 //O(mlogm+n^2)
 2 const int N=1010,M=100010,INF=0x3f3f3f3f;
 3 int f[N],r[N];
 4 int Find(int x)
 5 {
 6     if(x==f[x]) return x;
 7     return f[x]=Find(f[x]);
 8 }
 9 void Link(int x,int y)
10 {
11     int a=Find(x), b=Find(y);
12     if(a!=b)
13     {
14         f[b]=a;
15         r[a]+=r[b];
16     }
17 }
18 struct node
19 {
20     int u,v,w;
21     bool select;
22 }edge[M];
23 bool cmp(const node &a, const node &b)
24 {
25     if(a.w!=b.w) return a.w<b.w;
26     if(a.u!=b.u) return a.u<b.u;
27     return a.v<b.v;
28 }
29 struct node1
30 {
31     int to,next;
32 }e[N];
33 int cnt,tot,head[N],en[N],maxe[N][N];
34 //e的边数、头结点、尾结点、两点在mst中的最大边
35 void Kruskal(int n,int m)
36 {
37     int k=0, i,j,t;
38     for(cnt=0;cnt<n;cnt++)
39     {
40         e[cnt].to=cnt+1;
41         e[cnt].next=head[cnt+1];
42         en[cnt+1]=cnt;
43         head[cnt+1]=cnt;
44     }
45     sort(edge,edge+m,cmp);
46     for(i=0;i<m;i++)
47     {
48         if(k==n-1) break;
49         if(edge[i].w<0) continue;
50         int a=Find(edge[i].u), b=Find(edge[i].v);
51         if(a!=b)
52         {
53             for(j=head[a];j!=-1;j=e[j].next){
54                 for(t=head[b];t!=-1;t=e[t].next){
55                     int u=e[j].to, v=e[t].to;
56                     maxe[u][v]=maxe[v][u]=edge[i].w;
57                 }
58             }
59             e[en[b]].next=head[a];
60             en[b]=en[a];
61             Link(a,b);
62             k++;
63             edge[i].select=1;
64         }
65     }
66 }
67 void addedge(int u,int v,int w)
68 {
69     edge[tot].u=u;edge[tot].v=v;edge[tot].w=w;tot++;
70 }
71 void init()
72 {
73     tot=0;
74     memset(head,-1,sizeof(head));
75     memset(en,-1,sizeof(en));
76     for(int i=0;i<N;i++){
77         edge[i].select=0;
78         f[i]=i;
79         r[i]=1;
80     }
81 }
82 int main()
83 {
84     //freopen("test.txt","r",stdin);
85     int mst,secmst;
86     Kruskal(n,m);
87     mst=0;
88     for(i=0;i<m;i++){
89         if(edge[i].select) mst+=edge[i].w;
90     }
91     secmst=INF;
92     for(i=0;i<m;i++){
93         if(!edge[i].select)
94             secmst=min(secmst,mst+edge[i].w-maxe[edge[i].u][edge[i].u]]);
95     }
96
97     return 0;
98 }

算法的不同,当然也继承了该算法的特点。Prim不能存重边。这是需要注意的。

题目:Hdu2489  poj1679

三、有向图的最小树形图

解决的问题:一水源给菜地供水,水只能从高处向低处流,修水渠需要一定的花费,问怎样才能使得花费最低。

边是有方向的,与最小生成树不同,这可以理解为有向图的最小生成树。

算法是朱刘算法,难得的以国人名字命名的算法。

邻接矩阵建图,时间复杂度为O( n*n*n )。 hdu4009用这种方法超时了。

前向星建图,时间复杂度为O( n*m )。

朱刘算法的两种实现可以看我的博客 http://www.cnblogs.com/Potato-lover/p/3942321.html

题目:hdu4009 、 hdu2121

四、LCA(树上两点的最近公共祖先)

解决的问题:求树上的任意两个点之间的最短距离。

用最短路的方法是行不通的,复杂度太高。所以才有解决LCA的专门的算法。

我只会离线的Tarjan(图拉)算法。 时间复杂度为O(m+q),m是边数,q是问题的个数。

我的博客里已经有相关的介绍了。http://www.cnblogs.com/Potato-lover/category/613545.html

题目:poj1330 (hdu2586)

五、树的最小支配集、最小点覆盖、最大独立集

注意:是树上的,图中一定不能有圈。

都是基于深度优先搜索。

最小支配集:对于图G=(V,E),从V取尽量少的点组成一个集合,使得V中剩余的点都与取出来的点有边相连。

最小点覆盖:对于图G=(V,E),从V取尽量少的点组成一个集合,使得E中所有的边都与取出来的点相连。

最大独立集:对于图G=(V,E),从V取尽量多的点组成一个集合,使得这些点之间没有边相连。

时间复杂度都是O(n)。

这方面的题目似乎不曾出现,但是作为图论的学习者,有必须会。

实现的算法很相似。

顶点下标从1开始的。

  1 /*newpos[i]表示深度优先遍历序列的第i个点是哪个点,
  2 now表示当前深度优先遍历序列已经有多少个点了。select[]用于
  3 深度优先遍历的判重,p[i]表示点i的父节点的编号。对于greedy(),
  4 s[i]为1表示第i个点被覆盖。se[i]表示点i属于要求的点集*/
  5
  6 const int N = 1010;
  7 struct node
  8 {
  9     int to, w, next;
 10 }e[N*N];
 11 int head[N],tot,now;
 12 int p[N], newpos[N] ;
 13 bool select[N];
 14 bool s[N],se[N];
 15 //深度优先遍历,得到深度优先遍历序列
 16 void dfs(int x)
 17 {
 18     newpos[now++] = x;
 19     int k;
 20     for(k=head[x]; k!=-1; k=e[k].next)
 21     {
 22         if(!select[e[k].to])
 23         {
 24             select[e[k].to]= 1;
 25             p[e[k].to]=x;
 26             dfs(e[k].to);
 27         }
 28     }
 29 }
 30 //最小支配集
 31 int greedy1()
 32 {
 33     memset(s,0,sizeof(s));
 34     memset(se,0,sizeof(se));
 35     int ans=0;
 36     int i;
 37     for(i=now-1; i>=0; i--)
 38     {
 39         int t=newpos[i];
 40         if(!s[t])
 41         {
 42             if(!se[p[t]])
 43             {
 44                 se[p[t]]=1;
 45                 ans++;
 46             }
 47             s[t] = 1;
 48             s[p[t]] = 1;
 49             s[p[p[t]]] = 1;
 50         }
 51     }
 52     return ans;
 53 }
 54 //最小点覆盖
 55 int greedy2()
 56 {
 57     memset(s,0,sizeof(s));
 58     memset(se,0,sizeof(se));
 59     int ans=0;
 60     int i;
 61     for(i=now-1; i>=1; i--)
 62     {
 63         int t=newpos[i];
 64         if(!s[t]&&!s[p[t]])
 65         {
 66             se[p[t]]=1;
 67             ans++;
 68             s[t] = 1;
 69             s[p[t]] = 1;
 70         }
 71     }
 72     return ans;
 73 }
 74 //最大独立集
 75 int greedy3()
 76 {
 77     memset(s,0,sizeof(s));
 78     memset(se,0,sizeof(se));
 79     int ans=0;
 80     int i;
 81     for(i=now-1; i>=0; i--)
 82     {
 83         int t=newpos[i];
 84         if(!s[t])
 85         {
 86             se[t]=1;
 87             ans++;
 88             s[t] = 1;
 89             s[p[t]] = 1;
 90         }
 91     }
 92     return ans;
 93 }
 94 void addedge(int i,int j)
 95 {
 96     e[tot].to=j;e[tot].next=head[i];head[i]=tot++;
 97 }
 98 void init()
 99 {
100     tot=now=0;
101     memset(head,-1,sizeof(head));
102     memset(select, 0, sizeof(select));
103 }
104 int main()
105 {
106     /* 读入图*/
107     select[1]=1;
108     p[1]=1;
109     dfs(1);
110     printf("%d\n",greedy());
111     return 0;
112 }

时间: 2024-10-12 03:19:29

树的问题小结(最小生成树、次小生成树、最小树形图、LCA、最小支配集、最小点覆盖、最大独立集)的相关文章

HDU 4081 Qin Shi Huang&#39;s National Road System(最小生成树/次小生成树)

题目链接:传送门 题意: 有n坐城市,知道每坐城市的坐标和人口.现在要在所有城市之间修路,保证每个城市都能相连,并且保证A/B 最大,所有路径的花费和最小,A是某条路i两端城市人口的和,B表示除路i以外所有路的花费的和(路径i的花费为0). 分析: 先求一棵最小生成树,然后枚举每一条最小生成树上的边,删掉后变成两个生成树,然后找两个集合中点权最大的两 个连接起来.这两个点中必然有权值最大的那个点,所以直接从权值最大的点开始dfs. 为了使A/B的值最大,则A尽可能大,B尽可能小.所以B中的边一定

最小生成树 次小生成树 hdu4081

A - Qin Shi Huang's National Road System Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Submit Status Description During the Warring States Period of ancient China(476 BC to 221 BC), there were seven kingdoms in China --

hdu 4081 Qin Shi Huang&#39;s National Road System 树的基本性质 or 次小生成树

During the Warring States Period of ancient China(476 BC to 221 BC), there were seven kingdoms in China ---- they were Qi, Chu, Yan, Han, Zhao, Wei and Qin. Ying Zheng was the king of the kingdom Qin. Through 9 years of wars, he finally conquered all

贪心法求树的最小支配集,最小点覆盖,最大独立集

定义: 最小支配集:对于图G = (V, E) 来说,最小支配集指的是从 V 中取尽量少的点组成一个集合, 使得 V 中剩余的点都与取出来的点有边相连.也就是说,设 V' 是图的一个支配集,则对于图中的任意一个顶点 u ,要么属于集合 V', 要么与 V' 中的顶点相邻. 在 V' 中除去任何元素后 V' 不再是支配集, 则支配集 V' 是极小支配集.称G 的所有支配集中顶点个数最少的支配集为最小支配集,最小支配集中的顶点个数称为支配数. 最小点覆盖:对于图G = (V, E) 来说,最小点覆盖

POJ 1679 The Unique MST 【最小生成树/次小生成树】

The Unique MST Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 22668   Accepted: 8038 Description Given a connected undirected graph, tell if its minimum spanning tree is unique. Definition 1 (Spanning Tree): Consider a connected, undire

树的最小支配集 最小点覆盖 与 最大独立集 (图论)

做 战略游戏 这道题的时候看到了这个东西,于是就来这里写了一下. 首先看一下三者的定义: 定义1 对于图G=(V,E)来说,最小支配集指的是从V中取尽量少的点组成一个集合,使得对于V中剩余的点都与取出来的点有边相连.也就是说,设V‘是图G的一个支配集,则对于图中的任意一个顶点u,要么属于集合V’,要么与V‘中的顶点相邻.在V’中出去任何元素后V‘不再是支配集,则支配集是极小支配集.称G的所有支配集中顶点个数最少的支配集为最小支配集,最小支配集中顶点的个数称为支配数. 定义2 对于图G=(V,E)

洛谷.4180.[模板]次小生成树Tree(Kruskal LCA 倍增)

构建完MST后,枚举非树边(u,v,w),在树上u->v的路径中找一条权值最大的边(权为maxn),替换掉它这样在 w=maxn 时显然不能满足严格次小.但是这个w可以替换掉树上严格小于maxn的次大边用倍增维护MST上路径的最大值.次大值,每条非树边的查询复杂度就为O(logn) ps:1.倍增更新次大值时,未必是从最大值转移,要先赋值较大的次大值,再与较小的那个最大值比较.2.maxn!=w时,是可以从maxn更新的(不能更新就是上面情况啊)倍增处理部分我还是在dfs里写吧 md改了一晚上

洛谷P4180 [Beijing2010组队]次小生成树Tree(最小生成树,LCT,主席树,倍增LCA,倍增,树链剖分)

洛谷题目传送门 %%%天平巨佬和山楠巨佬%%% 他们的题解 思路分析 具体思路都在两位巨佬的题解中.这题做法挺多的,我就不对每个都详细讲了,泛泛而谈吧. 首先kruskal把最小生成树弄出来,因为要求次小生成树.至于为什么次小一定只在最小的基础上改变了一条边,我也不会证......打表找规律大法好 剩下的可以有一堆数据结构来维护最大值和次大值(原理两位巨佬都讲清楚了,这里只分析一下算法的优劣) 倍增+LCA 山楠巨佬的做法,我也写了这一种.复杂度\(O(MlogM(kruscal)+MlogN(

poj1679The Unique MST判断最小生成树是否唯一以及求次小生成树边权和的讲解

Time Limit: 1000MS   Memory Limit: 10000K Total Submissions: 22346   Accepted: 7924 Description Given a connected undirected graph, tell if its minimum spanning tree is unique. Definition 1 (Spanning Tree): Consider a connected, undirected graph G =