好基友YanBaoC的另一篇巨作，又被我“剽窃”来了。
出处--------------->我叫YanBaoC 我叫YanBaoC。
本文分为以下几个部分 ：
1、 拓扑排序
3、 普利姆算法 & 优先队列优化
4、 克鲁斯卡尔算法
前情提要 ： 本文的存图方式 只有两种 ： 邻接矩阵 or 前向星。
1、 拓扑排序
我们起床穿裤子和鞋子时，相信大部分人的顺序是这样的，先穿上内裤，然后再穿上裤子，再穿上袜子，然后才是鞋子。 那么，我们把这些步骤分解：
(1)穿内裤
(2)穿裤子
(3)穿袜子
(4)穿鞋子
我们把这四个步骤，按照上述的顺序 给排一下，这就是所谓的拓扑排序。
当然这个排序的顺序是唯一的，如果你先进行(2)然后(1)(3)(4)，哦，不，你不是超人，请不要这样做， 又假如你按照(1)(2)(4)(3)， 那显然也是不行的。
拓扑排序 也可以描述一个暑假写作业的过程 ： 语文作业，数学作业，英语作业，生物作业，化学作业，物理作业。
(1) 语文
(2) 数学
(3) 英语
(4) 生物
(5) 化学
(6) 物理
你可以是(1)(2)(3)(4)(5)(6),也可以是(6)(5)(4)(3)(2)(1)，再者英语老师比较凶，那么可以是(3)(1)(2)(4)(5)(6)。等等其他的排序方式。
那么这个排序又是不唯一的。
因此 拓扑排序可能是唯一的又有可能是不唯一的。
就像 3个篮球队进行比赛。 编号分别为 1 ， 2 ， 3。
1打赢了2
2打赢了3
3打赢了1。 问谁是最后的冠军。 各一胜一负你问我谁是冠军 ，这不是扯蛋嘛。 So，这是不能判断谁是冠军的， 因为这个事件存在一个 环，互相牵制，进行排序是不行产生结果的。
如果这样 ：
1打赢了2
3打赢了2
那么最后的冠军可能是不确定的，因为你不知道1和3 谁强。 所以只能是 1,3并列了，你如果喜欢大数在前 那就是3 1 2，反之，就是1 3 2了。
拓扑排序其实就是这个样子。
前面大篇幅的扯犊子，主要是介绍什么是拓扑排序。 那么我们要讨论一下，怎么样进行拓扑排序呢？ 哎，这个问题好！
插播 ：
我们再次的从 1 2 3 这三支队伍的冠军争夺赛说起。
1打赢了2 因为2输了一场比赛，所以要给2做一标记。因此2号的菊花上就出现了一杆长枪。 我们称这个标记为 入度 那么2的入度就是 1了。
3打赢了2 因为2又输了一场比赛，又是一杆长枪啊。为什么受伤的总是2。 那么2的入度 就++了 变成了2。
好了 这就是 什么是 入度 了。 如果你还不是很懂入度是什么。那我告诉你，入度 在这里就是2号被打败了几次。
那我们 就要 进入正题了。
拓扑排序 ：
由AOV网构造拓扑序列的拓扑排序算法主要是循环执行以下两步，直到不存在入度为0的顶点为止。
(1) 选择一个入度为0的顶点并输出之；
(2) 从网中删除此顶点及所有出边。
循环结束后，若输出的顶点数小于网中的顶点数，则输出“有回路”信息，否则输出的顶点序列就是一种拓扑序列。 （摘自 ： 百度百科）
我们继续 以题来进行讲解和理解的加深。
Description
有N个比赛队（1<=N<=500），编号依次为1，2，3，。。。。，N进行比赛，比赛结束后，裁判委员会要将所有参赛队伍从前往后依次排名，但现在裁判委员会不能直接获得每个队的比赛成绩，只知道每场比赛的结果，即P1赢P2，用P1，P2表示，排名时P1在P2之前。现在请你编程序确定排名。
Input
输入有若干组，每组中的第一行为二个数N（1<=N<=500），M；其中N表示队伍的个数，M表示接着有M行的输入数据。接下来的M行数据中，每行也有两个整数P1，P2表示即P1队赢了P2队。
Output
给出一个符合要求的排名。输出时队伍号之间有空格，最后一名后面没有空格。
其他说明：符合条件的排名可能不是唯一的，此时要求输出时编号小的队伍在前；输入数据保证是正确的，即输入数据确保一定能有一个符合要求的排名。
Sample Input
4 3
1 2
2 3
4 3
Sample Output
1 2 4 3
题目在这：http://acm.hdu.edu.cn/showproblem.php?pid=1285
因为数据较小，我们可以使用邻接矩阵进行存储。 这是第一种方法。
题解在这 ：
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#define LL long long
const int INF = 1e9+7;
const int VM = 503;// 点的个数
bool G[VM][VM];//图
int deg[VM];//各个顶点的入度 计数
void toposort(int n) {//拓扑排序
int k = 0;
for (int i = 1; i <= n; i++) {//共进行|G.V|次操作
for (int j = 1; j <= n; j++) {//遍历所有的顶点 找入度为0的
if (deg[j] == 0) {//找到
printf("%d%c", j, i == n ? '\n' : ' ');//输出
deg[j]--;//去掉这个点 让deg[j] = -1;
k = j;//记录这个点
break;//跳出循环
}
}
for (int j = 1; j <= n; j++)//遍历所有的点
if (G[k][j] == true) {//找被此点打败过的点
G[k][j] = false;//标记为找到过
deg[j]--;//让这个点的入度-1
}
}
}
int main() {
int n, m;
while (scanf("%d %d", &n, &m) == 2) {//多组输入， 获取n, m
memset(G, 0, sizeof(G));//初始化
memset(deg, 0, sizeof(deg));//初始化
while (m--) {
int u, v;
scanf("%d %d", &u, &v);//获取 u,v u打败过v
if (G[u][v] == false) {//防止重边 如果被同一个对手打败多次，也太伤v的心了
G[u][v] = true;//标记为真
deg[v]++;//v的入度++ 一杆长枪入洞了。
}
}
toposort(n);//调用函数
}
return 0;
}
主函数 对数据的获取 和存图。
int main() {
int n, m;
while (scanf("%d %d", &n, &m) == 2) {//多组输入， 获取n, m
memset(G, 0, sizeof(G));//初始化
memset(deg, 0, sizeof(deg));//初始化
while (m--) {
int u, v;
scanf("%d %d", &u, &v);//获取 u,v u打败过v
if (G[u][v] == false) {//防止重边 如果被同一个对手打败多次，也太伤v的心了
G[u][v] = true;//标记为真
deg[v]++;//v的入度++ 一杆长枪入洞了。
}
}
toposort(n);//调用函数
}
return 0;
}拓扑排序的函数 :
void toposort(int n) {//拓扑排序
int k = 0;
for (int i = 1; i <= n; i++) {//共进行|G.V|次操作
for (int j = 1; j <= n; j++) {//遍历所有的顶点 找入度为0的
if (deg[j] == 0) {//找到
printf("%d%c", j, i == n ? '\n' : ' ');//输出
deg[j]--;//去掉这个点 让deg[j] = -1;
k = j;//记录这个点
break;//跳出循环
}
}
for (int j = 1; j <= n; j++)//遍历所有的点
if (G[k][j] == true) {//找被此点打败过的点
G[k][j] = false;//标记为找到过
deg[j]--;//让这个点的入度-1
}
}
}此算法的时间复杂度为 O（n * n） 复杂度挺高的呢。
那我们要想办法优化啊。
来了 ， 第二种 时间复杂度为 O（V + E） 在这个算法中 我们用到了 前向星 和 优先队列。
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#define LL long long
using namespace std;
const int INF = 1e9+7;
const int VM = 503;// 点的个数
struct node {//前向星的结构体
int v;//输队编号
int next;
};
node edge[VM * 4];//结构体数组
int head[VM];//头指针数组
int cnt;//下标
int deg[VM];//入度数组
void toposort(int n) {
priority_queue<int, vector<int>, greater<int> > que;//优先队列
for (int i = 1; i <= n; i++)//找所有点
if (deg[i] == 0) {//入度为 0
que.push(i);//加入队列
deg[i]--;//入度 变为 -1
}
int k = 1;
while (que.empty() == false) {//队列不为空
int u = que.top();//取出队首的数
que.pop();//删除
printf("%d%c", u, k++ == n ? '\n' : ' ');//输出
for (int i = head[u]; i != -1; i = edge[i].next) {//与该点相连的
node e = edge[i];//便于书写
deg[e.v]--;//点的入度 -1
if (deg[e.v] == 0)//若此点的 入度为 0
que.push(e.v);//放入队列
}
}
}
int main() {
int n, m;
int i;
while (scanf("%d %d", &n, &m) == 2) {//多组输入 ，获取n,m
memset(head, -1, sizeof(head));//初始化
memset(deg, 0, sizeof(deg));//初始化
cnt = 0;//初始化
while (m--) {
int u, v;
scanf("%d %d", &u, &v);//获取u,v
for (i = head[u]; i != -1; i = edge[i].next)//查找重边
if (edge[i].v == v)//输入重复数据
break;//不再储存
if (i == -1) {//若不是重复数据
deg[v]++;//加边
edge[cnt].v = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
}
toposort(n);//调用函数
}
return 0;
}
所用到的数据结构 ：
priority_queue<int, vector<int>, greater<int> > que;//优先队列
struct node {//前向星的结构体
int v;//输队编号
int next;
};
node edge[VM * 4];//结构体数组
int head[VM];//头指针数组
int cnt;//下标
主函数对数据的获取和 图的存储
int main() {
int n, m;
int i;
while (scanf("%d %d", &n, &m) == 2) {//多组输入 ，获取n,m
memset(head, -1, sizeof(head));//初始化
memset(deg, 0, sizeof(deg));//初始化
cnt = 0;//初始化
while (m--) {
int u, v;
scanf("%d %d", &u, &v);//获取u,v
for (i = head[u]; i != -1; i = edge[i].next)//查找重边
if (edge[i].v == v)//输入重复数据
break;//不再储存
if (i == -1) {//若不是重复数据
deg[v]++;//加边
edge[cnt].v = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
}
toposort(n);//调用函数
}
return 0;
}拓扑排序函数
void toposort(int n) {
priority_queue<int, vector<int>, greater<int> > que;//优先队列
for (int i = 1; i <= n; i++)//找所有点
if (deg[i] == 0) {//入度为 0
que.push(i);//加入队列
deg[i]--;//入度 变为 -1
}
int k = 1;
while (que.empty() == false) {//队列不为空
int u = que.top();//取出队首的数
que.pop();//删除
printf("%d%c", u, k++ == n ? '\n' : ' ');//输出
for (int i = head[u]; i != -1; i = edge[i].next) {//与该点相连的
node e = edge[i];//便于书写
deg[e.v]--;//点的入度 -1
if (deg[e.v] == 0)//若此点的 入度为 0
que.push(e.v);//放入队列
}
}
}
拓扑排序 讲解 完毕。
插播 ：
什么是 生成树？什么 又是 最小生成树？
给定一个无向图，如果它的某个子图中的任意两个顶点都互相联通并且是一棵树，那么这棵树就是 生成树 。
也就是说，在一个图中，有 n 个顶点 ，若有 n - 1 条边，能使得所有的顶点相连 ，就是 生成树了。
如果你给这些边 加上权值 ，那 权值 总和最小的额生成树 就是最小生成树
再插 ：
最小生成树 有两种方法 一种 ： 普利姆算法 另一种 ： 克鲁斯卡尔。
3、 普利姆算法 & 优先队列优化
prim算法和Dijkstra算法十分相似，都是从某个顶点出发，不断加边的算法。
1. 假设有一棵树只包含一个顶点的v的树T。
2.贪心的选取T和其他顶点之间相连的最小权值的边，并将它加入T中。
3.不断重复1,2 知道所有的点相连生成一棵最小生成树。（此算法的正确性，不给予证明）
下面开始练题。
题目 ： 我是题目 请点击
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int INF = 1e9+7;
const int VM = 103;
int G[VM][VM];//存图
void prim(int n) {
int dis[VM];//记录 边的权值
bool vis[VM];//记录为否访问
int ans = 0;//
memset(vis, 0, sizeof(vis));//初始化
for (int i = 1; i <= n; i++)
dis[i] = G[1][i];//初始化
dis[1] = 0;//
vis[1] = true;// 1 点标记为已访问
int i;
for (i = 2; i <= n; i++) {//进行 n - 1 次操作
int u = INF;//初始化
int k;
for (int j = 1; j <= n; j++) {//遍历所有顶点
if (!vis[j] && u > dis[j]) {//在所有的未加入的点中 找一个最小的权值
k = j;//记录下标
u = dis[j];//更新最小值
}
}
if (u == INF)//若图是不连通的
break;//提前退出
vis[k] = true;//标记为已加入
ans += u;//加权值
for (int j = 1; j <= n; j++) {//遍历所有的点
if (!vis[j] && dis[j] > G[k][j])//对未加入的点&&能找到与此点相连且的权值最小的边
dis[j] = G[k][j];//进行更新
}
}
//输出
if (i - 1 == n)
printf("%d\n", ans);
else
printf("?\n");
}
int main() {
int n, m;
while (scanf("%d %d", &n, &m), n) {//对边数 和点数的获取
for (int i = 1; i <= m; i++) {//初始化
for (int j = 1; j <= m; j++) {
G[i][j] = i == j ? 0 : INF;
}
}
while (n--) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);//获取 数据
if (G[u][v] > w)//防止重边&&存两点之间的最短距离
G[u][v] = G[v][u] = w;
}
prim(m);//调用函数
}
return 0;
}
<span style="font: 15.19px/24px 微软雅黑, 宋体, Arial; color: rgb(0, 0, 0); text-transform: none; text-indent: 0px; letter-spacing: normal; word-spacing: 0px; float: none; display: inline !important; white-space: normal; background-color: rgb(255, 255, 255); -webkit-text-stroke-width: 0px;">主函数对数据的获取及图的存储</span><span style="font: 15.19px/24px 微软雅黑, 宋体, Arial; color: rgb(0, 0, 0); text-transform: none; text-indent: 0px; letter-spacing: normal; word-spacing: 0px; float: none; display: inline !important; white-space: normal; background-color: rgb(255, 255, 255); -webkit-text-stroke-width: 0px;"></span><pre class="html" name="code">int main() {
int n, m;
while (scanf("%d %d", &n, &m), n) {//对边数 和点数的获取
for (int i = 1; i <= m; i++) {//初始化
for (int j = 1; j <= m; j++) {
G[i][j] = i == j ? 0 : INF;
}
}
while (n--) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);//获取 数据
if (G[u][v] > w)//防止重边&&存两点之间的最短距离
G[u][v] = G[v][u] = w;
}
prim(m);//调用函数
}
return 0;
}普利姆函数
void prim(int n) {
int dis[VM];//记录 边的权值
bool vis[VM];//记录为否访问
int ans = 0;//
memset(vis, 0, sizeof(vis));//初始化
for (int i = 1; i <= n; i++)
dis[i] = G[1][i];//初始化
dis[1] = 0;//
vis[1] = true;// 1 点标记为已访问
int i;
for (i = 2; i <= n; i++) {//进行 n - 1 次操作
int u = INF;//初始化
int k;
for (int j = 1; j <= n; j++) {//遍历所有顶点
if (!vis[j] && u > dis[j]) {//在所有的未加入的点中 找一个最小的权值
k = j;//记录下标
u = dis[j];//更新最小值
}
}
if (u == INF)//若图是不连通的
break;//提前退出
vis[k] = true;//标记为已加入
ans += u;//加权值
for (int j = 1; j <= n; j++) {//遍历所有的点
if (!vis[j] && dis[j] > G[k][j])//对未加入的点&&能找到与此点相连且的权值最小的边
dis[j] = G[k][j];//进行更新
}
}
//输出
if (i - 1 == n)
printf("%d\n", ans);
else
printf("?\n");
}
上面的算法的时间复杂度为O（V * V），是不是和Dijkstra很相似呢？那么可不可用优化Dijkstra算法的方法来优化这个呢？ 当然可以
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#define LL long long
using namespace std;
const int INF = 1e9+7;
const int VM = 103;
typedef pair<int, int>P;//对组
struct node {//前向星 结构体
int v, w;
int next;
};
node edge[4 * VM];//前向星数组
int head[VM];//头指针数组
int cnt;//计数
void add(int u, int v, int w) {//加边函数
edge[cnt].v = v;//顶点
edge[cnt].w = w;//权值
edge[cnt].next = head[u];//下一个
head[u] = cnt++;//头指针
}
void prim(int n) {//普利姆函数
bool vis[VM];//标记是否访问过
int dis[VM];//记录权值
int ans = 0;//最小生成树的总值
int count = 0;//计数
priority_queue<P, vector<P>, greater<P> >que;//权值从小到大的队列
fill(dis, dis + VM, INF);//初始化
memset(vis, 0, sizeof(vis));//初始化
dis[1] = 0;//初始化
que.push(P(0, 1));//将 1点 和 dis[1] = 0 放入队列
while (que.empty() == false) {//队列不为空时
P p = que.top();//取出队首
que.pop();//删除
int u = p.second;//
if (vis[u] == true)//若此顶点已经加入生成树
continue;//
vis[u] = true;//否则，就标记为加入
ans += dis[u];//
count++;//加入点个数
for (int i = head[u]; i != -1; i = edge[i].next) {//遍历与该点相邻的点
node e = edge[i];
if (dis[e.v] > e.w) {//更新他们的权值
dis[e.v] = e.w;//
que.push(P(dis[e.v], e.v));//放入队列
}
}
}
//输出
if (count == n)
printf("%d\n", ans);
else
printf("?\n");
}
int main() {
int n, m;
while (scanf("%d %d", &n, &m), n) {//边的个数 顶点个数
memset(head, -1, sizeof(head));//初始化
cnt = 0;//初始化
while (n--) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);//获取数据
add(u, v, w);//加边
add(v, u, w);//无向图
}
prim(m);//普利姆算法
}
return 0;
}
主函数对数据的获取 和 图的存储
int main() {
int n, m;
while (scanf("%d %d", &n, &m), n) {//边的个数 顶点个数
memset(head, -1, sizeof(head));//初始化
cnt = 0;//初始化
while (n--) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);//获取数据
add(u, v, w);//加边
add(v, u, w);//无向图
}
prim(m);//普利姆算法
}
return 0;
}
prim函数
void prim(int n) {//普利姆函数
bool vis[VM];//标记是否访问过
int dis[VM];//记录权值
int ans = 0;//最小生成树的总值
int count = 0;//计数
priority_queue<P, vector<P>, greater<P> >que;//权值从小到大的队列
fill(dis, dis + VM, INF);//初始化
memset(vis, 0, sizeof(vis));//初始化
dis[1] = 0;//初始化
que.push(P(0, 1));//将 1点 和 dis[1] = 0 放入队列
while (que.empty() == false) {//队列不为空时
P p = que.top();//取出队首
que.pop();//删除
int u = p.second;//
if (vis[u] == true)//若此顶点已经加入生成树
continue;//
vis[u] = true;//否则，就标记为加入
ans += dis[u];//
count++;//加入点个数
for (int i = head[u]; i != -1; i = edge[i].next) {//遍历与该点相邻的点
node e = edge[i];
if (dis[e.v] > e.w) {//更新他们的权值
dis[e.v] = e.w;//
que.push(P(dis[e.v], e.v));//放入队列
}
}
}
//输出
if (count == n)
printf("%d\n", ans);
else
printf("?\n");
}此算法的时间复杂度为O(E*log(V)); 是不是很棒！
次算法结束。
4、 克鲁斯卡尔算法
克鲁斯卡尔算法就是利用了并查集这一方法，通过对所有边从小到大排序后，判断这两个顶点是否在一个分组中，若在一个分组中，说明这两个点已经加入到生成树之中，若不在一个分组中
就可以直接加上这个边了。
还是以上一题为例
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#define LL long long
using namespace std;
const int INF = 1e9+7;
const int VM = 103;
struct node {//边的结构体
int u, v, w;
};
node edge[VM * 2];
int rank[VM];//分组的高度
int par[VM];//父节点
bool cmp(const node &a, const node &b) {
return a.w < b.w;//按w从小到大排序
}
int find(int x) {
if (par[x] == x)//若根节点为本身
return x;
return par[x] = find(par[x]);//路径压缩
}
bool same(int x, int y) {//判断为否在同一分组中
return find(x) == find(y);
}
void unite(int x, int y) {
x = find(x);//查找根节点
y = find(y);//查找根节点
if (x == y)//若以在同一分组
return ;
if (rank[x] < rank[y])//y所在分组的高度 大于x的
par[x] = y;//将y作x的父节点。
else {
par[y] = x;//将x作为y的父节点
if (rank[x] == rank[y])//若两个分组高度相同
rank[x]++;//x分组所在高度++
}
}
int main() {
int n, m;
while (scanf("%d %d", &n, &m), n) {//获取边的个数 和顶点个数
int cnt = 0;//
for (int i = 1; i <= m; i++)//初始化
par[i] = i;
memset(rank, 0, sizeof(rank));//初始化
while (n--) {
scanf("%d %d %d", &edge[cnt].u, &edge[cnt].v, &edge[cnt].w);//获取数据
cnt++;
}
sort(edge, edge + cnt, cmp);//按权值从小到大排序
int ans = 0;//最小生成树 权值
int count = 0;//计数
for (int i = 0; i < cnt; i++) {//对所有的边
node e = edge[i];
if (!same(e.u, e.v)) {//若两点不属于一个分组
ans += e.w;//权值总和
unite(e.u, e.v);//合并两点
count++;//计数
}
}
//输出
if (count == m - 1)
printf("%d\n", ans);
else
printf("?\n");
}
return 0;
}
声明：本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。