最短路径——Floyd Dijsktra

Floyd

算法核心：通过比较 已有的路径长度和通过中转点t到达目标点的长度来求出任意两点间最短路径

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

int n , m , k;
int d[210][210];
int x , y , z;

void floyd(){     //通过比较 已有的路径长度和通过中转点t到达目标点的长度来求出最短路径
    for(int t = 1 ; t<=n ; t++)     //将中转点t放在最外层循环，以保证每个d[x][y]都判断过每个中转点 (允许经过t个中转点的最短路径)
        for(int i = 1 ; i<=n ; i++)
            for(int j = 1 ; j<=n ; j++)
                d[i][j] = min(d[i][j] , d[i][t]+d[t][j]);
}


int main(){

    cin>>n>>m>>k;
    
    memset(d , 0x3f , sizeof d); //初始化所有边为无穷大
    
    for(int i = 1 ; i<=n ; i++) d[i][i] = 0; //初始自环为0
    
    while(m--){
        
        cin>>x>>y>>z;
        d[x][y] = min(d[x][y] , z);
    }
        floyd();
        
    while(k--){
        cin>>x>>y;
        if(d[x][y]>1000000) cout<<"impossible"<<endl;
        else cout<<d[x][y]<<endl;
    }
    return 0;
}
    

Dijsktra算法

算法核心：一趟确定一个距离最近的点，再利用该点更新附近的点。以此求得一确定点到另一点的距离。

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;
const int N = 510;
const int INF = 0x3f3f3f3f;

bool flag[N];
int g[N][N];
int d[N];
int n,m;

int Dijkstra(){
        memset(d , 0x3f , sizeof d);
        d[1]=0;     //第一个点的距离当然为零
        
        for(int i = 0 ; i<n ; i++ ){
                 int t = -1;      //t记录当前访问的点 
                                  //因为第一趟t不确定所以设为-1 直到找到第一个不在确定集合中的点
            for(int j = 1 ; j<=n ; j++)
                if(!flag[j]&&(t==-1||d[t]>d[j]))
                   t = j;

                    flag[t]=true;   //列入确定集合
                 
                    for(int j = 1 ; j<=n ; j++)    //更新相邻点距离
                            d[j] = min(d[j] , d[t]+g[t][j]);

        }
                            if(d[n]==INF) return -1;
                           return d[n];
}

int main(){

    cin>>n>>m;
    memset(g,0x3f,sizeof g);
    while(m--){
        int x,y,z;
        cin>>x>>y>>z;
        g[x][y] = min(g[x][y],z);
    }
    int k = Dijkstra();
    cout<<k<<endl;

}