scau 数据结构实验七（最小生成树，最短路径，拓扑排序，关键路径）

这里不讲算法思路，如果你能从代码中知道算法思想的当我没说ahh
这里附上一张oj的图咳咳

最小生成树

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <stack>
#include<algorithm>
#include <string.h>
#include<string>
#include<queue>
using namespace std;
typedef long long ll;
//最小生成树
//普利姆算法的实现：
ll power[2005], a[2005][2005], vert[2005], v[2005];
//权值			邻接矩阵		边			标记数组
//注：power数组是以当前节点为观测点，与它相邻的顶点（即下标）的权值
int n, m;//顶点，边数
ll getmin()//找权值最小边的顶点下标
{
	ll minv = 1e18;
	int x;
	for (int j = 1; j <= n; j++) {
		if (v[j] == 0 && power[j] < minv) {
			minv = power[j];
			x = j;
		}
	}
	return x;
}

ll prim()
{
	memset(power, 42, sizeof(power));//将power数组的值全置为无穷大（为什么是42自己去了解memset函数）
	power[1] = 0;//从1开始
	ll sum = 0;
	for (int i = 1; i <= n; i++) {
		int t = getmin();
		sum += power[t];
		v[t] = 1;
		//更新与t有关的所有权值，以便于下次循环的查找
		for (int j = 1; j <= n; j++) {
			if (v[j] == 0 && a[t][j] < power[j]) {
				power[j] = a[t][j];
				vert[j] = t;//记录最小二叉树的边
			}
		}
	}
	return sum;
}

//克鲁斯卡尔算法实现：
//用到并查集的内容(计算智能有教过)
struct node {
	ll x, y, w;
	bool operator<(node t) {//运算符重载
		return w < t.w;
	}
}ed[2005];
ll pre[2005];
ll findr(ll x) {
	return x == pre[x] ? x : pre[x] = findr(pre[x]);
}

ll kruskal()
{
	ll sum = 0;
	for (int i = 1; i <= m; i++)pre[i] = i;//并查集初始化
	for (int i = 1; i <= m; i++) {
		//找边所对应俩顶点是否有关连（有则是x==y，表明俩顶点已经在同一集合，不能再连了）
		ll x = findr(ed[i].x);
		ll y = findr(ed[i].y);
		if (x != y) {
			pre[x] = y;
			sum += ed[i].w;
		}
	}
	return sum;
}
int main()
{
	cin >> n >> m;
	//处理邻接矩阵
	memset(a, 42, sizeof(a));
	//prim:
	//for (int i = 1; i <= m; i++) {
	//	cin >> x >> y >> w;
	//	if (x == y)continue;//自环
	//	a[x][y] =a[y][x]=min( w,a[x][y]);//重边
	//}
	//cout << prim() << endl;
	//kruskal:
	for (int i = 1; i <= m; i++) {
		cin >> ed[i].x >> ed[i].y >> ed[i].w;
	}
	sort(ed + 1, ed + 1 + m);
	cout << kruskal() << endl;
}

最短路径

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
typedef long long ll;
#define maxint 10086
int n, m;
ll G[105][105];//邻接矩阵
bool S[105];
int Path[105];//记录前驱顶点，下标为本节点，值为前驱节点
ll D[105];//记录当前最短路径
//迪杰斯特拉算法
ll DIJ()
{
	//初始化
	for (int i = 1; i <= n; i++) {
		S[i] = false;
		D[i] = G[1][i];
		if (D[i] < maxint)Path[i] = 1;
		else Path[i] = -1;
	}
	S[1] = true;
	D[1] = 0;

	int v = 0;
	for (int i = 1; i < n; i++) {
		ll min = maxint;
		for (int j = 1; j <= n; j++) {
			if (S[j] == false && D[j] < min) {
				v = j;
				min = D[j];
			}
		}
		S[v] = true;
		for (int k = 1; k <= n; k++) {
			if (S[k] == false && (D[v] + G[v][k] < D[k])) {
				D[k] = D[v] + G[v][k];
				Path[k] = v;
			}
		}
	}
	return D[n];
}

int main()
{
	ll x, y, w;
	cin >> n >> m;
	//初始化邻接矩阵
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			G[i][j] = maxint;
		}
	}
	for (int i = 1; i <= m; i++) {
		cin >> x >> y >> w;
		G[x][y] = G[y][x] = min(w, G[x][y]);
	}
	ll r = DIJ();
	if (r < maxint)cout << r << endl;
	else cout << -1 << endl;
}
//弗洛伊德算法：
int a[105][105];
int main()
{
	int x, y, z, i, n, m, j, k;
	ios::sync_with_stdio(false);
	memset(a, 127 / 3, sizeof(a));//初始化距离为无穷大 
	cin >> n >> m;
	for (i = 1; i <= n; i++)//自身到自身的距离为0 
		a[i][i] = 0;
	for (i = 1; i <= m; i++)
	{
		cin >> x >> y >> z;
		a[x][y] = a[y][x] = z;//此题为无向网 
	}
	for (k = 1; k <= n; k++)//弗洛伊德算法核心 
		for (i = 1; i <= n; i++)
			for (j = 1; j <= n; j++)
				if (a[i][k] + a[k][j] < a[i][j])
					a[i][j] = a[i][k] + a[k][j];
	if (a[1][n] > 999999)
		cout << -1;
	else
		cout << a[1][n];
	return 0;
}

拓扑排序

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <stack>
#include<algorithm>
#include <string.h>
#include<string>
#include<set>
using namespace std;
typedef long long ll;

//运用set解决为确保输出唯一性，同等条件下，编号小的在排在前面的问题。
//set是一个内部自动有序且不含重复元素的容器。
int d[35], a[35][35];
//入度数   邻接矩阵
int main()
{
	int n, m;
	cin >> n >> m;
	int x, y;
	for (int i = 1; i <= m; i++) {
		cin >> x >> y;
		a[x][y] = 1;
		d[y]++;//记录每个节点度数
	}
	set<int>s;
	//将度数为0的插入
	for (int i = 1; i <= n; i++) {
		if (d[i] == 0) {
			s.insert(i);
		}
	}
	for (int i = 1; i <= n; i++) {
		int t = *s.begin();
		s.erase(t);
		cout << t << " ";
		for (int j = 1; j <= n; j++) {
			if (a[t][j] == 1) {//与t邻接的顶点
				d[j]--;
				if (d[j] == 0) {
					s.insert(j);
				}
			}
		}
	}
}

关键路径

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <stack>
#include<algorithm>
#include <string.h>
#include<string>
#include<set>
using namespace std;
typedef long long ll;
//运用动态规划在拓扑排序的基础上进行修改
int d[35], a[35][35], dp[35];
//入度数 邻接矩阵
int main()
{
	int n, m;
	cin >> n >> m;
	int x, y, w;
	for (int i = 1; i <= m; i++) {
		cin >> x >> y >> w;
		a[x][y] = w;
		d[y]++;//记录每个节点度数
	}
	set<int>s;
	//将度数为0的插入
	for (int i = 1; i <= n; i++) {
		if (d[i] == 0) {
			s.insert(i);
		}
	}
	for (int i = 1; i <= n; i++) {
		int t = *s.begin();
		s.erase(t);
		//cout << t << " ";
		for (int j = 1; j <= n; j++) {
			if (a[t][j]) {//与t邻接的顶点
				dp[j] = max(dp[j], dp[t] + a[t][j]);
				d[j]--;
				if (d[j] == 0) {
					s.insert(j);
				}
			}
		}
	}
	cout << dp[n] << endl;
	return 0;
}