用Floyd算法和Dijkstra算法分别求多源最短路径和单源最短路径（第二次作业）

用Floyd算法和Dijkstra算法分别求多源最短路径和单源最短路径。

问题：
用Floyd算法求解下图各个顶点的最短距离。写出Floyd算法的伪代码和给出距离矩阵（顶点之间的最短距离矩阵）。

对于下图使用Dijkstra算法求由顶点a到顶点h的最短路径，按实验报告模板编写算法。

解析：
用Floyd算法求解题一，我们用三重循环进行判断，当然我们可以进行相应的减枝，不用对无效的数据即没有连通的点算最短距离。
用Dijkstra算法求解题二，我们可以用优先队列优化问题，获取最短边的时候可以降低复杂度，因为题目给的点是以字母的形式给出的，我们可以用映射的方法将字母映射为数字。

Floyd：

#include<iostream>
using namespace std;
const int maxn = 1e2 + 10;
const int inf = 0x3f3f3f3f;

int n, m;//点的数量、边的数量
int graph[maxn][maxn];//存图

void initGraph(){//初始化图
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= n; j++)
            graph[i][j] = inf;
    for(int i = 0; i < m; i++){
        int u, v, w;
        scanf("%d %d %d", &u, &v, &w);
        graph[u][v] = w;
    }
}

void Floyd(){//Floyd算法求各点之间的最短路
    for(int k = 1; k <= n; k++){
        for(int i = 1; i <= n; i++){
            if(graph[i][k] == inf)continue;
            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];
            }
        }
    }
}

int main(){
    scanf("%d %d", &n, &m);
    initGraph();
    Floyd();
    for(int i = 1; i <= n; i++){//输出矩阵
        for(int j = 1; j <= n; j++){
            if(i == j)graph[i][j] = 0;
            printf("%d ", graph[i][j]);
        }
        printf("\n");
    }

    system("pause");
    return 0;
}
/*
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
*/

Dijkstra：

#include<iostream>
#include<queue>
using namespace std;

const int maxn = 1e3 + 10;
const int inf = 0x3f3f3f3f;

int n, m;
int st = 0, ed = 7, vis[maxn]  = {0};//起点、终点、该点是否被访问过

struct Edge{//定义边
    int u, v, w;
    Edge(){}
    Edge(int u, int v, int w):u(u), v(v), w(w){}
};
vector<Edge>e[maxn];

struct Node{//定义点
    int id, dist;
    Node(){}
    Node(int id, int dist):id(id), dist(dist){}
    bool operator<(const Node & tmp)const {
        return tmp.dist < dist;
    }
};

int Dijkstra(char st, char ed){//Dijkstra算法求解两点之间的最短路
    int start = st - 97;//对点进行映射
    int end = ed - 97;
    int dis[maxn];//每个点到起点的最短距离
    for(int i = 0; i <= n; i++)dis[i] = inf;//初始化最短距离
    priority_queue<Node>q;//定义优先队列获取最近点
    q.push(Node(start, 0));
    while(!q.empty()){
        Node u = q.top();
        q.pop();
        if(vis[u.id] == 1)continue;
        vis[u.id] = 1;
        for(int i = 0; i < e[u.id].size(); i++){
            int v = e[u.id][i].v;
            if(vis[v] == 1)continue;
            if(dis[v] > u.dist + e[u.id][i].w){ // 进行松弛比较
                dis[v] = u.dist + e[u.id][i].w;
                q.push(Node(v, dis[v]));
            }
        }
    }
    return dis[end];
}

int main(){
    scanf("%d %d",&n ,&m);
    getchar();//读取回车
    for(int i = 0; i < m; i++){ // 读图同时转化
        char u, v;
        int w;
        scanf("%c %c %d", &u, &v, &w);
        getchar();//读取多余字符
        e[u - 97].push_back(Edge(u - 97, v - 97, w));
    }
    printf("%d\n", Dijkstra('a', 'h'));
    system("pause");
    return 0;
}
/*
8 11
a b 1
b d 2
c a 2
d c 1
d f 8
e d 2
e g 2
f e 2
g f 3
g h 3
h f 2
*/

github源码地址：
Floyd
Dijkstra