目录
最短路径问题
1、Floyd算法代码(邻接矩阵)
Floyd 算法复杂度高(结点数n < 200 可以考虑)，低效，但代码很简单，并且能求出任意两点之间的最短距离,还可以处理 有负权边的图。
代码中有一个有趣的地方，就是节点到自己的距离graph[i][i]并没有设初值为 0，graph[i][i]的值得要绕一圈才能求出，这一点可用于判断负圈。
负圈是这样产生的:
如果某些边的权值为负数，那么图中可能有这样的环路，环路上边的权值之和为负数，这样的环路就是负圈。每走一次这个负圈，总权值就会更小，导致陷在这个圈里出不来。
Floyd
用到了动态规划的思想，求两点之间的最短距离，可以分成两种情况考虑，即经过图中的某个点 K 的路径和不经过点 K 的路径，取两者中的最短路径。
代码如下：
#include<bits/stdc++.h>
using namespace std;
const int INF = 1e6;
const int NUM = 105;
int graph[NUM][NUM];
int n, m;
void floyd(){
int s = 1;
// n个中间点，每一个都考虑选与不选
for (int k = 1; k <= n;++k)
for (int i = 1; i <= n;++i)
// 如果 i-->k 不通，那 i-->k-->j 肯定也不通
if(graph[i][k]!=INF)
for (int j = 1; j <= n;++j){
if(graph[i][j]>graph[i][k]+graph[k][j])
graph[i][j] = graph[i][k] + graph[k][j];
}
// 当 k = 2 时，有用到 k = 1 时计算出的graph[i][j] ， k>2 也是如此。
}
int main(){
while(~scanf("%d %d",&n,&m)){
if(n==0&&m==0)
return 0;
for (int i = 1; i <= n;++i)
for (int j = 1; j <= n;++j)
graph[i][j] = INF;
while(m--){
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
graph[a][b] = graph[b][a] = c;
}
floyd();
/*
cout<<graph[i][j]<<endl;
即是 i-->j 的最短路径长度。
*/
}
system("pause");
return 0;
}2、SPFA算法代码(链式前向星)
解决单源点最短路径问题，给定一个起点，求它到图中所有n个结点的最短路径。
Bellman-Ford 算法的特点是只对相邻结点进行计算。
而 SPFA 是利用队列对 Bellman-Ford 进行优化的方法。
代码如下：
#include<bits/stdc++.h>
using namespace std;
const int INF = INT_MAX / 10;
const int NUM = 1e6 + 5;
struct Edge{
int to, next, w;
} edge[NUM];
int n, m, cnt;
int head[NUM];
int dis[NUM]; //记录所有结点到起点的距离
bool inq[NUM]; //inq[i] = true 表示节点 i 在队列中
int Neg[NUM]; //判断负圈
int pre[NUM]; //记录前驱结点
// 打印 s-->t 最短距离路径
void print_path(int s, int t){
if(s==t){
printf("%d ", s);
return;
}
print_path(s, pre[t]);
printf("%d ", t);
}
void init(){
for (int i = 0; i <= NUM;++i){
edge[i].next = -1;
head[i] = -1;
}
cnt = 0;
}
// 前向星存图(很重要！)
// cnt 代表边的数量，一条边相当于2条（无向边）
// 同时，cnt也代表着边的编号 id
// head[u] 表示 u 这个节点的最后一条边的编号
// 可以由u节点的最后一条边找到u节点的所有边
// 如果u节点还没有边,那head[u]就是 -1 了
void addedge(int u, int v, int w){
edge[cnt].to = v;
edge[cnt].w = w;
edge[cnt].next = head[u];
head[u] = cnt++;
}
// s : 起点
int spfa(int s){
memset(Neg, 0, sizeof(Neg));
memset(dis, INF, sizeof(dis));
memset(inq, false, sizeof(inq));
Neg[s] = 1;
dis[s] = 0;
queue<int> Q;
Q.push(s);
inq[s] = true;
while(!Q.empty()){
int u = Q.front();
Q.pop();
inq[u] = false;
// i 表示 边的编号
for (int i = head[u]; i != -1;i = edge[i].next){
int v = edge[i].to;
int w = edge[i].w;
// u 的第i个邻居v，它借道u，到s更进
if(dis[v]>dis[u]+w){
dis[v] = dis[u] + w;
pre[v] = u;
if(!inq[v]){
// 邻居v更新状态了，但是它不在队列中，把它放进队列中
inq[v] = true;
Q.push(v);
Neg[v]++;
// 出现负圈
if(Neg[v]>n){
return 1;
}
}
}
}
}
printf("%d\n", dis[n]); // s-->n 的最短距离
// s-->n 的最短路径
print_path(s, n);
return 0;
}
int main(){
while(~scanf("%d %d", &n, &m)&&(n||m)){
init();
while(m--){
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
addedge(u, v, w);
addedge(v, u, w);
}
spfa(1); // 起点是 1
}
system("pause");
return 0;
}3、Dijkstra算法（邻接表 + 优先队列）
Dijkstra算法应用了贪心法的思想，即“抄近路走，肯定是最短路径”。
所以，怎么找到最近的路是一个问题，而这个问题用STL的优先队列很容易就解决了。
注：当图十分巨大时，需要用到链式前向星存图。
// Dijkstra 算法代码 (邻接表 + 优先队列)
#include<bits/stdc++.h>
using namespace std;
const int INF = 1e6;
// NUM : 结点数
const int NUM = 105;
struct edge{
int from, to, w;
};
vector<edge> e[NUM];
struct node{
int id, dis;
// 三种重载操作符写法
bool operator < (const node& a) const{
return dis > a.dis;
}
// friend bool operator < (const node& a,const node& b){
// return a.dis > b.dis;
// }
};
// bool operator < (const node& a,const node& b){
// return a.dis > b.dis;
// }
int n, m;
int pre[NUM];
void print_path(int s, int t){
if(s == t){
printf("%d ", s);
return;
}
print_path(s, pre[t]);
printf("%d ", t);
}
int dis[NUM];
bool done[NUM];
void dijkstra(){
// 假设起点是 1
int s = 1;
// 初始化
for (int i = 1; i <= n;++i){
dis[i] = INF;
done[i] = false;
}
dis[s] = 0;
priority_queue<node> q;
q.push({s, dis[s]});
while(!q.empty()){
// id 表示加入结点的 编号
int id = q.top().id;
// distance 表示，该编号结点到 起始点的距离
int distance = q.top().dis;
q.pop();
// id编号的结点已经找到了最短的路径
if(done[id]){
continue;
}
done[id] = true;
/*
已加入的结点 都会记录起来，放在一个集合中， 下面简称为 : 集合
每当一个新的结点加入到 集合 中之后 ( 即 done[id] = true )
都要遍历一遍 该结点的边，通过这条边，找到其相邻的结点，
这些相邻的结点都有可能成为下一个加入 集合 的结点
*/
for (int i = 0; i < e[id].size();++i){
edge x = e[id][i];
// x.to是编号，x.to编号结点也已经找到了最短的路径
if(done[x.to]){
continue;
}
if(dis[x.to]>x.w+distance){
dis[x.to] = x.w + distance;
q.push({x.to, dis[x.to]});
pre[x.to] = id;
}
}
}
printf("%d\n", dis[n]);
}
int main(){
while(~scanf("%d %d", &n, &m)&&(n||m)){
for (int i = 1; i <= n;++i){
e[i].clear();
}
while(m--){
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
e[a].push_back({a, b, c});
e[b].push_back({b, a, c});
}
dijkstra();
}
system("pause");
return 0;
}4、Kruskal + 并查集
kruskal算法有两个关键技术:
（1） 对边进行排序。 可以使用STL的sort() 函数。
（2）处理连通性问题。 并查集是kruskal算法的绝配。
// Kruskal + 并查集
#include<bits/stdc++.h>
using namespace std;
int n, m;
const int MAX = 5e3 + 5;
struct edge{
int x, y, val;
}e[MAX];
int root[MAX];
bool cmp(const edge& a, const edge& b){
return a.val < b.val;
}
// Find(int x) 函数功能: 找到 x 的 根
int Find(int x){
if(x!=root[x]){
root[x] = Find(root[x]);
}
return root[x];
}
int kruskal(){
for (int i = 1; i <= m;++i){
scanf("%d %d %d", &e[i].x, &e[i].y, &e[i].val);
}
// kruskal 的时间复杂度花费在对边长长度的排序上
sort(e + 1, e + 1 + m, cmp);
// 初始化各自为根
for (int i = 1; i <= n;++i){
root[i] = i;
}
int ans = 0;
for (int i = 1; i <= m;++i){
int x = e[i].x;
int y = e[i].y;
int val = e[i].val;
int fx = Find(x);
int fy = Find(y);
// 如果两者不是同属一个源，就合并
if (fx != fy) {
root[fx] = fy;
ans += val;
}
}
return ans;
}
int main(){
scanf("%d %d", &n, &m);
int ans = kruskal();
printf("%d\n", ans);
system("pause");
return 0;
}
扫一扫
153
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
