记录一下图论里面几个比较重要且基础的算法
首先是最小生成树
Description
某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了连接两个城镇需要花费的代价。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。问最少花费多少代价就可以完成工程？
Input
输入包含多组数据，对于每组测试数据
第一行包含两个正整数N和M(0 <=N <=1000,0 < M < 5000)，分别代表现有城镇的数目和已修建的道路的数目。城镇分别以1～N编号。
接下来是M行道路信息。每一行有三个整数A,B,X(0 < A,B <= N ,0 < X < 10000),表示可以在城镇A和城镇B之间建一条花费为X的双向道路。保证数据可以完成工程。
Output
对于每组数据，输出完成工程需要花费的最少代价。
Sample Input
3 3 1 2 3 1 3 1 2 3 2
Sample Output
3
最小生成树有两个主要的算法分别是Prim算法和克鲁斯卡尔算法,分别是基于点和边进行的生成
第一个是prime算法，大致算法就是不断去找已经生成的树与所有相连的边（不包括树内的）的最小值，将这条边纳入生成树，进行n-1轮
建立dis数组，存储还在树外的点到树内任何一点的距离的最小值，具体的操作就是每次找到一个没有被标记过的，同时 dis[] 也是最短的点，纳入生成树，同时利用这个点到其他点的距离去更新其他没有被标记过的点，因为如果 dis[] 变化一定是因为新节点的纳入，所以只需要在每一次纳入新节点时，就去更新与之相关的点就能够保证dis[]存储的永远是到树内节点的最小值
完整代码
#include<stdio.h>
#include<algorithm>
using namespace std;
#define inf 0x3f3f3f3
using namespace std;
int flag[1010][1010];
int n,m;//点数量和路数量
int getMinDis() {
int ans = 0;
int vis[1010];
int dis[1010];//记录当前的最小值
for (int i = 1; i <= n; i++)vis[i] = 0;
vis[1] = 1;//从第一个开始查找
for (int i = 2; i <= n; i++)
dis[i] = flag[1][i];
for (int epco = 1; epco <= n - 1; epco++) {//要查找这么多轮
int k = 1, tmp = inf;
for (int i = 1; i <= n; i++) {
if (!vis[i] && dis[i] < tmp) {//寻找当前的最小值
tmp = dis[i];//要记得这里必须要更新tmp
k = i;
}
}
vis[k] = 1;//标记
ans += dis[k];
//用k点更新距离
for (int i = 1; i <= n; i++) {
if (!vis[i] && dis[i] > flag[i][k])
dis[i] = flag[i][k];
}
}
return ans;
}
int main()
{
while (~scanf("%d%d", &n,&m)) {
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
flag[i][j] = inf;//这里没有给出图那么需要自己初始化
int x, y,l;
for (int i = 1; i <= m; i++){
scanf("%d%d%d", &x , &y,&l);
flag[x][y] =min(l,flag[x][y]);
flag[y][x] =flag[x][y];
}
int ans = getMinDis();//寻找最小生成树
printf("%d\n", ans);
}
return 0;
}
第二个是克鲁斯卡尔算法,不同于前一个，这个算法主要针对于边操作
因为需要最小的生成树，所以用贪心策略来看就是用最小的几条边来组成一棵树，那么从小来开始选，大致就是将所有边排序，从小到大去扫描取边，要想不形成环其实就是要保证这一条边的两个端点落在两个连通块之中，需要用到关于并查集的内容
#include<stdio.h>
#include<algorithm>
using namespace std;
int jz[1010];
struct Bian {
int l, r;
int dis;
}bian[5000];
int cmp(Bian x, Bian y) {
return x.dis < y.dis;//距离升序排列
}
int get_jz(int x) {//得到这个点的代表块
if (jz[x] == x)return x;
return jz[x] = get_jz(jz[x]);//返回的是找到的上级的上级
}
int main()
{
int n, m;
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= m; i++)
scanf("%d%d%d", &bian[i].l, &bian[i].r, &bian[i].dis);
for (int i = 1; i <= n; i++)
jz[i] = i;
sort(bian+1 , bian + m+1, cmp);
//for (int i = 1; i <= m; i++)
// printf("%d %d %d\n", bian[i].l, bian[i].r,bian[i].dis);
int num = 0;//已经选到的边数量
int ans= 0 ;//记录答案
int x, y;
for (int i = 1; i <= m; i++) {
x = bian[i].l;
y = bian[i].r;
if (get_jz(x) != get_jz(y)) {//不是在一个连通块上
ans += bian[i].dis;
jz[get_jz(x)] = get_jz(y);//合并,这里要注意合并的对象一定是代表块
num++;
}
if (num == n - 1)break;//可以退出了
}
printf("%d\n", ans);
}
return 0;
}对比两个算法，一个依赖于点，比较适合稠密图，第二种比较适合稀疏图，因为这时候的边比较少
然后是关于最短路径的问题
Description
某省调查城镇交通状况，得到现有城镇道路统计表，表中列出了连接两个城镇需要花费的代价。省政府“畅通工程”的目标是使全省任何两个城镇间都可以实现交通（但不一定有直接的道路相连，只要互相间接通过道路可达即可）。问最少花费多少代价就可以完成工程？
Input
输入包含多组数据，对于每组测试数据
第一行包含两个正整数N和M(0 <=N <=1000,0 < M < 5000)，分别代表现有城镇的数目和已修建的道路的数目。城镇分别以1～N编号。
接下来是M行道路信息。每一行有三个整数A,B,X(0 < A,B <= N ,0 < X < 10000),表示可以在城镇A和城镇B之间建一条花费为X的双向道路。保证数据可以完成工程。
Output
对于每组数据，输出完成工程需要花费的最少代价。
Sample Input
3 3 1 2 3 1 3 1 2 3 2
Sample Output
3
首先是单源最短路径问题，也就是求一个点到另一个点的最短路，这里说一下Dijkstra算法，这个算法适用于非负边权的最短路
这个算法也是利用了贪心策略，基于每一步的最优实现整体最优。
建立MinDis[]数组存储当前用标记过的点的情况下该点到达目标点的最短路长度
假设当前目标点是i，然后这时候找MinDIs[]数组中一个最短的，同时也没有被标记过的，假设是点j，这时候的 i 到 j 一定已经是最短了。
简单证明一下：假设还有其他点k能使得这两点距离能够缩短，那么也就意味着经过k松弛可以让 i到 j 变得更短，那么 k本身 到i的最短路就一定比 j 到 i 要小，这样再加上k到j的距离才能使得两条路更短，再看上面的条件，这时候 j 到 i 的距离已经是最短了，这时候哪里还有什么 k 可以比 j 到 i 更短？因而不存再这样的k，那么 j 到 i 也就是最短。
找到这样的k之后就需要用找到的k去更新其他的点到目标点的最短路，只要用k这个桥梁能够使得当前这个点到达目标点能够更短，那么就把DisMin[]数组改掉。
#include<stdio.h>
#define inf 0x3f3f3f3f
int dis[1010][1010];
int MinDis[1010];//记录最小值
bool vis[1010];//记录状态
int n, m;
void GetMinDis(int x) {
vis[x] = 1;
for (int i = 0; i <n ; i++)
MinDis[i] = dis[i][x];//初始化
while (1) {
int k = -1,tmp=inf;
for (int i = 0; i < n; i++) {
if (!vis[i] && tmp > MinDis[i]) {
k = i;
tmp = MinDis[i];//这里的更新...不要老是忘记
}
}
if (k == -1)break;
vis[k] = 1;
for (int i = 0; i < n; i++) {
if (MinDis[k] + dis[k][i] < MinDis[i])
MinDis[i] = MinDis[k] + dis[k][i];
}
}
}
int main()
{
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; i++) {
vis[i] = 0;
for (int j = 0; j <= n; j++)
dis[i][j] = (i==j?0:inf);
}
int x, y, l;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &x, &y, &l);
if (l < dis[x][y]) {
dis[x][y] = l;
dis[y][x] = l;
}
}
scanf("%d%d", &x, &y);
GetMinDis(x);//计算x到其他点的最短距离
if (MinDis[y] == inf)
printf("-1\n");
else printf("%d\n", MinDis[y]);
}
return 0;
}
Description
通过给定的邻接矩阵，求出任意两点之间的最短路径。
Input
本题目包含多组数据，请处理到文件结束。
每组数据第一行包含两个正整数N和M(0<N<100,0<M<100)，分别代表点的数目和要要查询点对的个数。接下来N行，每行N个元素表示两点之间的距离
再接下来M行有两个整数S,T(0<=S,T<N)，分别代表起点和终点。
Output
对于每个询问，输出最短需要行走的距离。
Sample Input
3 2 0 1 4 1 0 2 4 2 0 0 1 2 0
Sample Output
1 3
还有多源最短路问题，也就是任意两点之间的最短距离，这里介绍弗洛伊德算法。
这种算法主要是基于动态规划的思想，两点 i , j 之间的最短路主要有以下三种情况，一种是直接相连，那么就是两点距离dis[i][j]，要么就是经过一个点 k 使得两点最短，也就是dis[i][k]+dis[k][j] , 第三种是经过 k1,k2...kn 使得 i ， j 最短，这时候只要保证 i 到 k1 最短 ，k1 到 k2...kn到 j 最短 就可以实现 i 到 j 的最短，那么把 k1 k2...kn 分解看做i j其实还是前面两种情况,确定转移方程 dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]) ,然后运用循环就可以求解.。
需要注意的是k要放在最外面，代表当前的松弛点，也就是 k 节点
#include<stdio.h>
#include<algorithm>
using namespace std;
#define inf 0x3f3f3f3f
int dis[1010][1010];
int main()
{
int n, num;
while (~scanf("%d%d", &n, &num)) {
int x;
for(int i=0;i<n;i++)
for (int j = 0; j < n; j++) {
scanf("%d", &x);
dis[i][j] = x;
}
for (int k = 0; k < n; k++) //k轮松弛
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);//通过k来松弛
int y;
while (num--) {
scanf("%d%d", &x, &y);
printf("%d\n", dis[x][y]);
}
}
return 0;
}
扫一扫
2608
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
