图论 - 生成树 - 最小生成树

最新推荐文章于 2024-03-29 10:26:03 发布

长剑凌清秋

最新推荐文章于 2024-03-29 10:26:03 发布

阅读量238

点赞数 1

分类专栏：图论 - 生成树 - 最小生成树

本文链接：https://blog.csdn.net/weixin_44584560/article/details/99610386

版权

图论 - 生成树 - 最小生成树专栏收录该内容

0 篇文章 0 订阅

订阅专栏

文章目录

两大算法模板
练习题

两大算法模板

$K r u s k a l$ 贪边， $p r i m$ 贪点
$p r i m$ 有没有跟 $d i j k s t r a$ 很像？？~~（有）~~
一些特殊运用，右转瓶颈生成树与最小瓶颈路

Kruskal

#include<bits/stdc++.h>

using namespace std;

const int maxn = 2e5 + 5;
const int maxm = 5e5 + 5;

int n,m,cnt,size;
long long ans;
int father[maxn];

struct Edge{
	int u,v,w;
	bool operator < (const Edge &a) const {
		return w < a.w;//sort里面默认就是从小到大
	}
}edge[maxm];

template<class T>inline void read(T &x){
	x = 0;bool flag = 0;char ch = getchar();
	while(!isdigit(ch)) flag |=ch == '-',ch = getchar(); 
	while(isdigit(ch)) x = (x<< 1) + (x << 3) + (ch ^48),ch = getchar(); 
	if(flag) x = -x;
}

int find(int x){
	return father[x] == x ? x : father[x] = find(father[x]);
}

void merge(int x,int y){
	father[find(x)] = find(y);
}

void eadd(int u,int v,int w){
	edge[++size].v = v;
	edge[size].u = u;
	edge[size].w = w;
}

/*
bool cmp(const Edge &a,const Edge &b){
	return a.w < b.w;
}
*/

int main(){
	read(n);read(m);
	for(int i =1;i <= n; ++ i) father[i] = i;
	for(int i = 1;i <= m;++i){
		int u,v,w;
		read(u);read(v);read(w);
		eadd(u,v,w);
	}
	sort(edge + 1,edge + m  + 1);
	for(int i  =1;i <= m; ++ i){
		int u = edge[i].u;
		int v = edge[i].v;
		int w = edge[i].w;
		
		if(find(u) != find(v)){
			merge(u,v);
			++cnt;
			ans += (long long)w;
		}
		if(cnt == n - 1) break; 
	}
	printf("%lld",ans);
	return 0;
 }

prim（ $n^2$ ）

#include<bits/stdc++.h>
using namespace std;

int n,m,d[5005],p,t,s,h[5005];
struct ee
{
	int u,v,w,nt;
}e[400005];

void eadd(int x,int y,int z)
{
	e[++s].u=x;
	e[s].v=y;
	e[s].w=z;
	e[s].nt=h[x];
	h[x]=s;
}

void init()
{
	freopen("1.txt","r",stdin);
}

void readdata()
{
	scanf("%d%d",&n,&m);
	
	for(int i=1;i<=m;i++)
	{
		int x,y,z;
		scanf("%d%d%d",&x,&y,&z);
		eadd(x,y,z);
		eadd(y,x,z);
	}
}

void work()
{
	memset(d,0x3f,sizeof(d));
	d[1]=0;
	for(int i=h[1];i;i=e[i].nt) 
	{
		if(e[i].w<d[e[i].v])//重边 
		d[e[i].v]=e[i].w;
	}
	for(int i=1;i<n;i++)
	{
		p=2000000000;
		int x;
		for(int j=2;j<=n;j++)
		{
			if(d[j]&&d[j]<p)
			{
				p=d[j];
				x=j;
			}
		}
		t+=p;
		d[x]=0;
		for(int j=h[x];j;j=e[j].nt) if(d[e[j].v]>e[j].w) d[e[j].v]=e[j].w;
	}
	printf("%d",t);
}

int main()
{
//	init();
	readdata();
	work();
	return 0;
}

prim（堆优化）

#include<bits/stdc++.h>

using namespace std;

const int maxn = 2e5 + 5;
const int maxm = 5e5 + 5;
const int inf = 2e9 + 5;

int n,m,size,cnt;
int first[maxn];
int dis[maxn];
bool vis[maxn];
long long ans = 0;

struct Edge{
	int v,w,nt;
}edge[maxm << 1];

struct Node{
	int v,w;
	Node(){v = w = 0;}
	Node(int _v,int _w):v(_v),w(_w){}
	
	bool operator < (const Node &a) const{
		return w > a.w;
	}
};

/*
//也可以用二元组
typedef pair<int,int>pir;
priority_queue<pir,vector<pir>,greater<pir> >q;
//使用：
q.push(make_pair(dis[v],v));
pir e = q.top;
int u = e.second;
int w = e.first; 
*/

char *TT, *mo, but[(1 << 15) + 2];
#define getchar() ((TT == mo && (mo = ((TT = but) + fread(but, 1, 1 << 15, stdin)), TT == mo)) ? -1 : *TT++)
template<class T>inline void read(T &x){
	x = 0;bool flag = 0;char ch = getchar();
	while(!isdigit(ch)) flag |= ch == '-',ch = getchar();
	while(isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48),ch = getchar();
	if(flag) x = -x;
}

void eadd(int u,int v,int w){
	edge[++ size].v = v;
	edge[size].w = w;
	edge[size].nt = first[u];
	first[u] = size;
}

void readdata(){
	read(n);read(m);
	for(int i = 1;i <= m; ++ i){
		int u,v,w;
		read(u);read(v);read(w);
		eadd(u,v,w);eadd(v,u,w);
	}
}

void work(){
	memset(dis,0x3f3f3f3f,sizeof(dis));
	
	dis[1] = 0;
	
	priority_queue<Node>q;
	q.push(Node(1,0));
	
	while(!q.empty()){
		Node e = q.top();
		q.pop();
		int u = e.v,w = e.w;
		
		if(vis[u]) continue;
		
		vis[u] = 1;
		++cnt;
		ans += (long long)w;
		if(cnt == n) break;//点数判n
		
		for(int i = first[u];i;i = edge[i].nt){
			int v = edge[i].v;
			int w = edge[i].w;
			if((!vis[v]) && w < dis[v]){
				dis[v] = w;
				q.push(Node(v,w));
			}
			
		}
	}
	
	printf("%lld",ans);
}

int main(){
	readdata();
	work();
	return 0;
}

练习题

Kruskal

luogu2916 Cheering up the Cow

传送门：luogu2916

题目描述
Farmer John has grown so lazy that he no longer wants to continue maintaining the cow paths that currently provide a way to visit each of his N (5 <= N <= 10,000) pastures (conveniently numbered 1…N). Each and every pasture is home to one cow. FJ plans to remove as many of the P (N-1 <= P <= 100,000) paths as possible while keeping the pastures connected. You must determine which N-1 paths to keep.

Bidirectional path j connects pastures S_j and E_j (1 <= S_j <= N; 1 <= E_j <= N; S_j != E_j) and requires L_j (0 <= L_j <= 1,000) time to traverse. No pair of pastures is directly connected by more than one path.

The cows are sad that their transportation system is being reduced. You must visit each cow at least once every day to cheer her up. Every time you visit pasture i (even if you’re just traveling

through), you must talk to the cow for time C_i (1 <= C_i <= 1,000).

You will spend each night in the same pasture (which you will choose) until the cows have recovered from their sadness. You will end up talking to the cow in the sleeping pasture at least in the morning when you wake up and in the evening after you have returned to sleep.

Assuming that Farmer John follows your suggestions of which paths to keep and you pick the optimal pasture to sleep in, determine the minimal amount of time it will take you to visit each cow at least once in a day.

For your first 10 submissions, you will be provided with the results of running your program on a part of the actual test data.

POINTS: 300

约翰有N个牧场，编号依次为1到N。每个牧场里住着一头奶牛。连接这些牧场的有P条道路，每条道路都是双向的。第j条道路连接的是牧场Sj和Ej，通行需要Lj的时间。两牧场之间最多只有一条道路。约翰打算在保持各牧场连通的情况下去掉尽量多的道路。

约翰知道，在道路被强拆后，奶牛会非常伤心，所以他计划拆除道路之后就去忽悠她们。约翰可以选择从任意一个牧场出发开始他维稳工作。当他走访完所有的奶牛之后，还要回到他的出发地。每次路过牧场i的时候，他必须花Ci的时间和奶牛交谈，即使之前已经做过工作了，也要留下来再谈一次。注意约翰在出发和回去的时候，都要和出发地的奶牛谈一次话。请你计算一下，约翰要拆除哪些道路，才能让忽悠奶牛的时间变得最少？

输入格式

Line 1: Two space-separated integers: N and P
Lines 2…N+1: Line i+1 contains a single integer: C_i
Lines N+2…N+P+1: Line N+j+1 contains three space-separated

integers: S_j, E_j, and L_j

输出格式

Line 1: A single integer, the total time it takes to visit all the cows (including the two visits to the cow in your

sleeping-pasture)

输入输出样例
输入 #1 复制
5 7
10
10
20
6
30
1 2 5
2 3 5
2 4 12
3 4 17
2 5 15
3 5 6
4 5 12
输出 #1 复制
176
在这里插入图片描述
Wake up in pasture 4 and visit pastures in the order 4, 5, 4, 2, 3, 2, 1, 2, 4 yielding a total time of 176 before going back to sleep.

分析：
每条道路会走两遍，每个点（除了出发点）都会经历他相连的边数次

出发点多经历一次，所以取权值最小的一个

代码：

/**************************
User:Mandy.H.Y
Language:c++
Problem:luogu2916 Cheering up the Cow
Algorithm:kruskal
**************************/

#include<bits/stdc++.h>

using namespace std;

const int maxn = 1e4 + 5;
const int maxm = 1e5 + 5;

int n,m,size,minc = 1e9;
int father[maxn];
int c[maxn];

struct Edge{
	int u,v,w;
}edge[maxm]; 

template<class T>inline void read(T &x){
	x = 0;bool flag = 0;char ch = getchar();
	while(!isdigit(ch)) flag |= ch == '-',ch = getchar();
	while(isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48),ch = getchar();
	if(flag) x = -x;
}

template<class T>void putch(const T x){
	if(x > 9) putch(x / 10);
	putchar(x % 10 | 48);
}

template<class T>void put(const T x){
	if(x < 0) putchar('-'),putch(-x);
	else putch(x);
}


int find(int x){
	return father[x] == x ? x : father[x] = find(father[x]);
}

void merge(int x,int y){
	father[find(x)] = find(y);
}

void eadd(int u,int v,int w){
	edge[++ size].v = v;
	edge[size].u = u;
	edge[size].w = (w << 1) + (c[u] + c[v]);
	//每条道路会走两遍，每个点（除了出发点）都会经历他相连的边数次 
	//出发点多经历一次 
}

bool cmp(const Edge &a,const Edge &b){
	return a.w < b.w;
}

int main(){
	read(n);read(m);
	for(int i = 1;i <=n; ++ i){
		read(c[i]);
		minc = min(minc,c[i]);
	} 
	for(int i = 1;i <= m ;++ i){
		int u,v,w;
		read(u);read(v);read(w);
		eadd(u,v,w);
	}
	
	sort(edge + 1,edge + 1 + m,cmp);
	
	for(int i = 1;i <= n; ++ i ) father[i] = i;
	
	int ans = 0,cnt = 0;
	
	for(int i = 1;i <= m; ++ i){
		int u = edge[i].u;
		int v = edge[i].v;
		int w = edge[i].w;
		
		if(find(u) != find(v)){
			merge(u,v);
			++cnt;
			ans += w;
		}
		if(cnt == n - 1) break;
	}
	
	put(ans + minc);//加上出发地的权值 
	return 0;
}

codevs1403 新三国争霸

题目传送门:codevs1403
题目
描述 Description
PP 特别喜欢玩即时战略类游戏，但他觉得那些游戏都有美中不足的地方。灾害总不降临道路，而只降临城市，而且道路不能被占领，没有保护粮草的真实性。于是他就研发了《新三国争霸》。
在这款游戏中，加入灾害对道路的影响（也就是一旦道路W[i，j]受到了灾害的影响，那么在一定时间内，这条路将不能通过）和道路的占领权（对于一条道路W[i，j]，至少需要K[i，j]个士兵才能守住）。
PP可真是高手，不一会，就攻下了N-1座城市，加上原来的就有N座城市了，但他忽略了一点……那就是防守同样重要，不过现在还来的及。因为才打完仗所以很多城市都需要建设，PP估算了一下，大概需要T天。他现在无暇分身进攻了，只好在这T天内好好的搞建设了。所以他要派士兵占领一些道路，以确保任何两个城市之间都有路（不然敌人就要分而攻之了，是很危险的）。士兵可不是白干活的，每个士兵每天都要吃掉V的军粮。因为有灾害，所以方案可能有变化（每改变一次就需要K的军粮，初始方案也需要K的军粮）。
因为游戏是PP编的，所以他知道什么时候有灾害。PP可是一个很节约的人，他希望这T天在道路的防守上花最少的军粮。
输入格式 InputFormat
第一行有5个整数N，M，T，V，K。N表示有城市数，M表示道路数，T表示需要修养的天数，V表示每个士兵每天吃掉的军粮数，K表示修改一次花掉的军粮数。
以下M行，每行3个数A，B，C。表示A与B有一条路（路是双向的）需要C个士兵才能守住。
第M+2行是一个数P，表示有P个灾害。
以下P行，每行4个数，X，Y，T1，T2。表示X到Y的这条路，在T1到T2这几天都会受灾害。
输出格式 OutputFormat
T天在道路的防守上花费最少的军粮。
样例输入 SampleInput
3 3 5 10 30
1 2 1
2 3 2
1 3 4
1
1 3 2 5
样例输出 SampleOutput
180
数据范围和注释 Hint
对于所有数据：N<=300，M<=5000 ，T<=50，P<=8000

分析:
最小生成树 + DP；
用 $d p [i]$ 表示到第 $i$ 天总共的最少费用
方程：（ans是第j~i天的共有的最小生成树最低费用）
$d p [i] = m i n (d p [i], d p [j - 1] + (i - j + 1) * a n s + K$
有木有很像[ZJOI2006]物流运输？~~（有诶>_<）~~
那个专题传送门：综合题 - 图论与动规

代码:

/*************************
User:Mandy.H.Y
Language:c++
Problem:three
Algorithm: 
*************************/

#include<bits/stdc++.h>
#define Max(x,y) ((x) > (y) ? (x) : (y))
#define Min(x,y) ((x) < (y) ? (x) : (y))

using namespace std;

const int maxn = 305;
const int maxm = 5005;

int T,N,M,size,V,K,P,now,pre,ans;
int father[maxn]; 
int dp[55];
bool vis[maxn][maxn];
//因为是按边禁，就标记边而不是点 qwq 

struct Val{
	int u,v,w;
}val[maxm];

struct Dis{
	int x,y,l,r;
}dis[8005];

template<class T>inline void read(T &x){
	x = 0;bool flag = 0;char ch = getchar();
	while(!isdigit(ch)) flag |= ch == '-',ch = getchar();
	while(isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48),ch = getchar();
	if(flag) x = -x;
}

template<class T>void putch(const T x){
	if(x > 9) putch(x / 10);
	putchar(x % 10 | 48);
} 

template<class T>void put(const T x){
	if(x < 0) putchar('-'),putch(-x);
	else putch(x);
}

void file(){
	freopen("three.in","r",stdin);
//	freopen("three.out","w",stdout);
}

void add(int u,int v,int w){
	val[++size].v = v;
	val[size].u = u;
	val[size].w = w;
}

bool cmp(const Val &a,const Val &b){
	return a.w < b.w;
}

bool cmp1(const Dis &a,const Dis &b){
	if(a.l != b.l) return a.l < b.l;
	else return a.r < b.r;
}

void readdata(){
	read(N);read(M);read(T);read(V);read(K);
	for(int i = 1;i <= M; ++ i){
		int u,v,w;
		read(u);read(v);read(w);
		add(u,v,w);
	}
	
	sort(val + 1,val + 1 + M,cmp);
	
	read(P);
	
	for(int i = 1;i <= P; ++ i){
		read(dis[i].x);	read(dis[i].y);	read(dis[i].l);	read(dis[i].r);
	}

	sort(dis + 1,dis + 1 + P,cmp1);
}

int find(int x){
	return father[x] == x ? x : father[x] = find(father[x]);
}

void merge(int x,int y){
	father[find(x)] = find(y);
}

int kruskal(int x,int y){
	for(int i = 1;i <= N; ++ i) father[i] = i;
	memset(vis,0,sizeof(vis));

	for(int i = 1;i <= P; ++ i){
		if(dis[i].l > y) break;
		if(dis[i].l <= y && x <= dis[i].r){
			vis[dis[i].x][dis[i].y] = 1;
			vis[dis[i].y][dis[i].x] = 1;
		}
	}
	
	int cnt = 0,cost = 0;
	
	for(int i = 1;i <= M; ++ i){
		int v = val[i].v;
		int u = val[i].u;
		int w = val[i].w;
		
		if(vis[u][v]) continue;
		if(find(u) != find(v)){
			merge(u,v);
			cost += w * V;
			++cnt;
		}
		if(cnt == N - 1) return cost;
	}
	return -1;
}

void work(){
	memset(dp,0x3f3f3f3f,sizeof(dp));
	dp[0] = 0;
	for(int i = 1;i <= T; ++ i){
		
		for(int j = i;j >= 1; -- j){
			int ans = kruskal(j,i);
			if(ans == -1) continue;
			dp[i] = min(dp[i],dp[j - 1] + (i - j + 1) * ans + K);
		}
		
	}
	put(dp[T]);
}

int main(){
//	file();
	readdata();
	work();
	return 0;
}

prim

luogu1265 公路修建

传送门：

题目：
题目描述
某国有n个城市，它们互相之间没有公路相通，因此交通十分不便。为解决这一“行路难”的问题，政府决定修建公路。修建公路的任务由各城市共同完成。

修建工程分若干轮完成。在每一轮中，每个城市选择一个与它最近的城市，申请修建通往该城市的公路。政府负责审批这些申请以决定是否同意修建。

政府审批的规则如下：

（1）如果两个或以上城市申请修建同一条公路，则让它们共同修建；

（2）如果三个或以上的城市申请修建的公路成环。如下图，A申请修建公路AB，B申请修建公路BC，C申请修建公路CA。则政府将否决其中最短的一条公路的修建申请；

在这里插入图片描述

（3）其他情况的申请一律同意。

一轮修建结束后，可能会有若干城市可以通过公路直接或间接相连。这些可以互相：连通的城市即组成“城市联盟”。在下一轮修建中，每个“城市联盟”将被看作一个城市，发挥一个城市的作用。

当所有城市被组合成一个“城市联盟”时，修建工程也就完成了。

你的任务是根据城市的分布和前面讲到的规则，计算出将要修建的公路总长度。

输入格式
第一行一个整数n，表示城市的数量。(n≤5000)

以下n行，每行两个整数x和y，表示一个城市的坐标。(-1000000≤x，y≤1000000)

输出格式
一个实数，四舍五入保留两位小数，表示公路总长。（保证有惟一解）

输入输出样例
输入 #1 复制
4
0 0
1 2
-1 2
0 4
输出 #1 复制
6.47
说明/提示
修建的公路如图所示：
在这里插入图片描述
分析

看题，prim既视感(>_<)
貌似不可能成环，只有可能是各边相等，但是各边相等去掉任意一边都等价
想明白之后，这道题的过程就是prim的过程

代码：

/***************************
User:Mandy.H.Y
Language:c++
Problem:luogu 
***************************/

//看题，prim既视感~(>_<)~
//貌似不可能成环 ，只有可能是各边相等，但是各边相等去掉任意一边都等价
//想明白之后，这道题的过程就是prim的过程 

#include<bits/stdc++.h>

using namespace std;

const int maxn = 5005;
const double inf = 10000000000000.0;

int n,cnt;

bool vis[maxn];

double d[maxn];

struct Node{
	int x,y;
}node[maxn];

struct Edge{
	int v;
	double w;
	Edge(){v = 0,w = 0;}
	Edge(int _v,double _w):v(_v),w(_w){}
	bool operator <(const Edge &a)const {
		return w > a.w ;
	}
};

template<class T>inline void read(T &x){
	x = 0;bool flag = 0;char ch = getchar();
	while(!isdigit(ch)) flag |= ch == '-',ch = getchar();
	while(isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48),ch = getchar();
	if(flag) x = -x;
}

template<class T>void putch(const T x){
	if(x > 9) putch(x / 10);
	putchar(x % 10 | 48);
}

template<class T>void put(const T x){
	if(x < 0) putchar('-'),putch(-x);
	else putch(x);
}

void file(){
	freopen("road.in","r",stdin);
	freopen("road.out","w",stdout);
}

void readdata(){
	read(n);
	for(int i = 1;i <= n; ++ i){
		d[i] = inf;
		read(node[i].x);read(node[i].y);
	}
}

double dist(int i,int j){
	return ((double)node[i].x - node[j].x) * (node[i].x - node[j].x) + 
		   ((double)node[i].y - node[j].y) * (node[i].y - node[j].y);
}

void work(){
	priority_queue<Edge>q;
	q.push(Edge(1,(double)0));
	double ans = 0;
	while(!q.empty()){
		Edge e = q.top();q.pop();
		int u = e.v;
		double w = e.w;
		if(vis[u]) continue;
		vis[u] = 1;ans += sqrt(w);
		++cnt;
		if(cnt == n) break;
		for(int i = 1;i <= n; ++ i){
			if(vis[i]) continue;
			double dis = dist(u,i);
			if(dis < d[i]){
				q.push(Edge(i,dis));
				d[i] = dis;
			}
		}
	} 
	printf("%.2lf",ans);
}

int main(){
//	file();
	readdata();
	work();
	return 0; 
}

长剑凌清秋

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
图论 - 生成树 - 最小生成树

文章目录两大算法模板Kruskalprim练习题Kruskalluogu2916 Cheering up the Cowcodevs1403 新三国争霸primluogu1265 公路修建两大算法模板KruskalKruskalKruskal贪边，primprimprim贪点primprimprim有没有跟dijkstradijkstradijkstra很像？？（有）一些特殊运用，右转瓶颈...
复制链接

扫一扫