邻接矩阵：Floyd算法 邻接表：Dijkstra算法

邻接表

• 优点：1）省空间，空间复杂度(m)
  ---------2）快速访问以某一点为起点的所有边

• 缺点：不能快速判断两点间关系

• 应用：Floyd算法

  ​ 求多源最短路径，即任意两点间的最短路径。时间复杂的 O(n^3)

#include <iostream>
using namespace std;

int n, m, arr[1000][1000]; //n个点 m条边
void Floyd()
{   //表示从j点到k点的最短路径，其中的i为中间的中转点
    for (int i = 1; i <= n; ++i) //i为中转在最外层
        for (int j = 1; j <= n; ++j)
            for (int k = 1; k <= n; ++k)
                arr[j][k] = min(arr[j][k], arr[j][i] + arr[i][k]);
}

int main()
{
    memset(arr, 0x3F, sizeof(arr)); //0x3F表示就算乘以2不会越界，值等价于0x3F3F3F3F
    return 0;
}

---

邻接矩阵

• 优点：快速直观判断两点间关系

• 缺点：1）不省空间 ，存储无用信息;，空间复杂度(n *n)

  ​ 2）不可以快速访问以某一点为起点的所有边

• 应用：Dijkstra算法
  求单源最短路径，即只能某点开始到其他点的最短路径。
  不能有值为负数的权边(负权边)和一个环的值为负数(负环)

#include <iostream>
#include <queue> //优先队列实现筛选最所确定点的最小值
#include <vector> //实现邻接表
#include <cstring>
using namespace std;

struct node { //记录每个点信息
    int now; //当前所在的点
    int dis; //到now这个点的距离
    bool operator< (const node& b) const {
        //让值小的在最顶
        return this->dis > b.dis;
    }
};

struct edge { //记录每条边信息
    int e; //边的终点
    int v; //边的权值
};

int n; //点的数量
int m; //边的数量
int s; //起点
int ans[100005]; //存储最短路径

int main()
{
    memset(ans, 0x3F, sizeof(ans)); //0x3F表示就算乘以2不会越界，值等价于0x3F3F3F3F
    cin >> n >> m >> s; //怕超时可以改成scanf()
    vector<vector<edge> > edg(n + 1, vector<edge>()); //初始化邻接表
    for (int i = 0; i < m; ++i) {
        int a, b, c; //起点为a,终点为b,权值为c
        cin >> a >> b >> c;
        edg[a].emplace_back((edge) { b, c });
        edg[b].emplace_back((edge) { a, c });
    }

    priority_queue<node> que;
    que.push((node) { s, 0 });
    ans[s] = 0;
    while (!que.empty()) {
        node tmp = que.top();
        que.pop();
        if (tmp.dis > ans[tmp.now]) continue; //筛选掉已确定的点
        //在优先队列下，这一步就是未确定点最小值
        for (int i = 0; i < edg[tmp.now].size(); ++i) { //进行遍历,edg[tmp.now]为当前边
            int e = edg[tmp.now][i].e, v = edg[tmp.now][i].v;
            if (ans[e] > ans[tmp.now] + v) {
                ans[e] = ans[tmp.now] + v;
                que.push((node) { e, ans[e] });
            }
        }
    }

    for (int i = 1; i <= n; ++i)
        if (0x3F3F3F3F == ans[i]) cout << -1 << endl;
        else cout << ans[i] << endl;
    return 0;
}