(邻接矩阵)最短路径算法

 

Floyd算法:

思路 ：遍历计算 i 点 经过 k 点 到 j 点 的最小路径值 (动态规划思路)

缺点：时间复杂度高，不能解决负边情况

输入样例：

4 8
1 2 2
1 3 6
1 4 4
2 3 3
3 1 7
3 4 1
4 1 5
4 3 12

输出样例：

1-->2:2
1-->3:5
1-->4:4
2-->1:9
2-->3:3
2-->4:4
3-->1:6
3-->2:8
3-->4:1
4-->1:5
4-->2:7
4-->3:10

#include <cstdio>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <math.h>
#include <queue>
using namespace std;
const int inf=0x7fffff;
const long long mod=1e9+7;
const double PI=acos(-1);

int n,m,start,end;
int ans=9999999;
bool vis[105];
int e[105][105];

void init(){                           //初始化邻接矩阵 
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(i==j) e[i][j]=0;
            else e[i][j]=inf;
        }
    }
} 

void Floyd(){                                       //思路：依此判断 i 通过 k 到 j 的最短路 
    for(int k=1;k<=n;k++){                          // k 经转的节点 
        for(int i=1;i<=n;i++){                      // i 每次的起点 
            for(int j=1;j<=n;j++){                  // j 每次的终点 
                if(k==i&&k==j) continue;
                if(e[i][j]>e[i][k]+e[k][j]){
                    e[i][j]=e[i][k]+e[k][j];
                }
            }
        }
    }
}

int main()
{
    int x,y,value;
    cin>>n>>m;
    init();
    for(int i=0;i<m;i++){
        cin>>x>>y>>value;
        e[x][y]=value;
    }
    Floyd();
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(i==j) continue;
            cout<<i<<"-->"<<j<<":"<<e[i][j]<<endl;
        }
    } 
    return 0;
}

 Dijkstra算法：

思路：依此找起点可达的点的最小值点。通过最小值点再访问其他点。不断更新最小距离。

测试数据：

6 9 1         (6个点9条边 1为起点)
1 2 1
1 3 12
2 3 9
2 4 3
3 5 5
4 3 4
4 5 13
4 6 15
5 6 4

输出数据：

1-->1:0
1-->2:1
1-->3:8
1-->4:4
1-->5:13
1-->6:17

#include <cstdio>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <math.h>
#include <queue>
using namespace std;
const int inf=0x7fffff;
const long long mod=1e9+7;
const double PI=acos(-1);

int n,m,start,end;
int ans=9999999;
bool vis[105];
int e[105][105];
void init(){                                //初始化邻接矩阵 
    for(int i=1;i<=n;i++){
        for(int j=1;j<=n;j++){
            if(i==j) e[i][j]=0;
            else e[i][j]=inf;              //设 inf 为 ∞ 表示两点不通 
        }
    }
} 
void Dijkstra(int s){                        //Dijkstra算法为单源最短路径算法 s 为起点 
    int dis[n+1];                           // dis 用来 记录每次操作时 s 到每个点的最短路径 
    int minp;                              // 记录目前操作的最小距离点 
    int min=inf;                     
    
    for(int i=1;i<=n;i++){                 //初始化最短距离数组 dis 
        dis[i]=e[s][i];
    }
    vis[s]=1;                              
    for(int i=1;i<=n;i++){              
        min=inf;
        for(int j=1;j<=n;j++){              //每次找dis数组里面最小未访问过的值  
            if(min>dis[j]&&!vis[j]){
                min=dis[j];                  //min 表示此时未访问过的最小距离
                minp=j;                      //minj表示未访问过的最小距离那个点 
            } 
        }
        vis[minp]=1;                     //设置访问 
        for(int v=1;v<=n;v++){           //每次访问 此时与最小值点相连的点v 
            if(e[minp][v]<inf){          //该点可达 
                if(dis[v]>dis[minp]+e[minp][v]){   //s直接到 v 的距离大于 s通过 最小值点到 v 的距离，则更新 
                    dis[v]=dis[minp]+e[minp][v];   
                }
            }
        }
    }
    for(int i=1;i<=n;i++){
        cout<<s<<"-->"<<i<<":"<<dis[i]<<endl;   //遍历 s 到 每个点的最小距离 
    }
}
int main()
{
    int x,y,value,s;
    cin>>n>>m>>s;
    init();
    for(int i=0;i<m;i++){
        cin>>x>>y>>value;
        e[x][y]=value;
    }
    Dijkstra(s);               //s 为起点 
    return 0;
}

 Bellman_Floyd算法:

思路：经过n-1次迭代，判断每次迭代判断能不能用u[i]-->v[i]

　　   使源点到v[i]的最短路径变短。

优点：可以解决带负边的问题。

输入样例：

5 5 1 （5个点 5条边 起点1）
2 3 2
1 2 -3
1 5 5
4 5 2
3 4 3

输出样例：

0 -3 -1 2 4 （起点到各个点的最短路径）

#include <cstdio>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <math.h>
#include <vector>
using namespace std;
const int inf=999999;//0x7fffff
const long long mod=1e9+7;
const double PI=acos(-1);

int n,m;
int ans=9999999;
bool vis[105];
int dis[105],u[105],v[105],w[105];
void Bellman_Floyd(int s){
    memset(dis,inf,sizeof(dis));                          //初始 dis最短路径数组 为无穷 
    dis[s]=0;
    for(int k=1;k<=n-1;k++){                              //迭代 n-1次 更新最短路径表dis 
        for(int j=1;j<=m;j++){
            dis[v[j]]=min(dis[v[j]],dis[u[j]]+w[j]);      //每次计算能不能由 u[i]到 v[i] 能不能使结果变小并更新 
        }
    }
//    bool ok=0;
//    for(int k=1;k<=m;k++){
//        if(dis[v[k]]>dis[u[k]]+w[k]) ok=1;               //检测负权回路 
//    }
}
int main()
{
    int x,y,s;
    cin>>n>>m>>s;
    for(int i=1;i<=m;i++){
        cin>>u[i]>>v[i]>>w[i];                           //u[i]边起使点 v[i]边指向点 w[i] 权值 
    }
    Bellman_Floyd(s);
    for(int i=1;i<=n;i++){
        cout<<dis[i]<<" ";
    }
    return 0;
}