最小生成树

最小生成树

目录

一. kruskal

二. prim

三. 拓朴排序

========================================================

1.连通图：在无向图中，任意两个顶点都有路径相通。
2.强连通图：在有向图中，任意两个顶点有路径相通。
3.连通网：在连通图中，每一条边都对应着一个权值。
4.生成树：一个连通子图，含有图中全部顶点，只有足以构成一棵树的n-1条边。
5.最小生成树：在连通网的所有生成树中，所有边的代价和最小的生成树。

========================================================

一. kruskal（类似查并集）

原理：每一次就选择一条满足条件的最小代价边，加入到最小生成树的边集合里。

步骤：

1.把所有边按代价从小到大排序；
2.把n个顶点看成独立的n个点；
3.按权值从小到大选择边，所选的边连接的两个顶点属于两颗不同的树，作为最小生成树的一条边，并将这两颗树合并作为一颗树。
4.重复步骤3；

代码

//模板一
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#define inf 0x3f3f3f3f
using namespace std;
const int N = 3030;
struct node
{
	int start;
	int end;
	int power;
};
node edge[N];
int pre[N];
int n,m,tot;
int maxx = -1;
void addedge(int s,int e,int p)
{
	edge[tot].start = s;
	edge[tot].end = e;
	edge[tot++].power = p;
}
int find(int x)
{
	if(pre[x]==-1)
		return x;
	else
		return pre[x] = find(pre[x]);
}
bool cmp(node a, node b)
{
	return a.power < b.power;
}
int kruskal(int n)
{
	memset(pre,-1,sizeof(pre));
	sort(edge,edge+tot,cmp);
	int cnt = 0;
	int ans = 0;
	for(int i = 0; i < tot; i++)
	{
		int s = edge[i].start;
		int e = edge[i].end;
		int p = edge[i].power;
		int t1 = find(s);
		int t2 = find(e);
		if(t1!=t2)
		{
			pre[t1] = t2;
			ans += p;
			cnt++;
		}
		if(cnt==n-1)
			break;
	}
	if(cnt<n-1)
		return -1;
	else 
		return ans;
}
int main()
{
	cin >> n >> m;
	for(int i = 1; i <= m; i++)
	{
		int a,b,c;
		cin >> a >> b >> c;
		addedge(a,b,c);
	}
	cout << kruskal(n) << endl;
	return 0;
}
//模板二
#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#define inf 0x3f3f3f3f
using namespace std;
const int N = 3030;
struct node
{
	int start;
	int end;
	int power;
};
node edge[N];
int pre[N];
int n,m,sum;
bool cmp(node a, node b)
{
	return a.power < b.power;
}
int find(int x)
{
	if(x!=pre[x])
		return x;
	return pre[x] = find(pre[x]);
}
void join(int x, int y)
{
	int xx = find(x);
	int yy = find(y);
	if(xx!=yy)
		pre[yy] = xx;
}
void kruskal()
{
	sort(edge+1,edge+m+1,cmp);
	for(int i = 1; i <= m; i++)
	{
		if(find(edge[i].start)==find(edge[i].end))
			continue;
		join(edge[i].start,edge[i].end);
		sum += edge[i].power;
	}
}
int main()
{
	cin >> n >> m;
	for(int i = 1; i <= n; i++)
		pre[i] = i;
	int a,b,c;
	for(int i = 1; i <= m; i++)
	{
		cin >> a >> b >> c;
		edge[i].start = a;
		edge[i].end = b;
		edge[i].power = c;
	}
	kruskal();
	cout << sum << endl;
	return 0;
} 

========================================================

二. prim（类似dijkstra）

原理：每次迭代选择代价最小的边对应的点，加入到最小生成树中。

代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#define inf 0x3f3f3f3f
using namespace std;
const int N = 110;
int dis[N],vis[N];
int map[N][N];
int n;
void prim()
{
	int sum = 0;
	for(int i = 1; i <= n; i++)
		dis[i] = map[1][i];
	vis[1] = 1;
	dis[1] = 0;
	for(int i = 1; i <= n-1; i++)
	{
		int pos;
		int minn = inf;
		for(int j = 1; j <= n; j++)
		{
			if(!vis[j]&&dis[j]<minn)
			{
				pos = j;
				minn = dis[j];
			}
		} 
		vis[pos] = 1;
		sum += minn;
		for(int j = 1; j <= n; j++)
		{
			if(!vis[j]&&dis[j]>map[pos][j])
				dis[j] = map[pos][j];
		}
	}
	cout << sum << endl;
}
int main()
{
	cin >> n;
	for(int i = 1; i <= n; i++)
	{
		for(int j = 1; j <= n; j++)
			cin >> map[i][j];
	}
	prim();
	return 0;
}

========================================================

三.拓扑排序

拓扑排序：对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边<u,v>∈E(G)，则u在线性序列中出现在v之前。通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。

例题 家谱树

代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <queue>
#include <cmath>
#include <map>
#include <algorithm>
#define inf 0x3f3f3f3f
using namespace std;
const int N = 1010;
queue <int> q;
int n,m,cnt;
bool vis[N][N];
int indeg[N],ans[N];
void input()
{
    cin >> n >> m;
    for(int i = 1; i <= m; i++)
    {
        int x,y;
        cin >> x >> y;
        vis[x][y] = 1;
        indeg[y]++;
    }
} 
void topsort()
{
    for(int i = 1; i <= n; i++)
	{
		if(indeg[i]==0)
        	q.push(i);
	} 
    while(!q.empty())
    {
        int u = q.front();
        ans[++cnt] = u;
        q.pop();
        for(int i = 1; i <= n; i++)
        {
        	if(vis[u][i])
         	{
            	indeg[i]--;
            	if(indeg[i]==0)
             		q.push(i); 
         	}
		}
    }
}
void output()
{
    for(int i = 1; i <= n; i++)
     cout << ans[i] << " ";
}
int main()
{
    input();
    topsort();
    output();
    return 0;
}