最短路径问题Dijkstra&Floyd

图的表示方法

邻接矩阵：节点数为N，构造N*N的二维矩阵，表示节点到节点间的距离。(稠密图)

vector<vector<int>> graph(N, vector<int>(N, INT_MAX));
for(auto& edge:edges){
    graph[edge[0]][edge[1]] = edge[2];
}

邻接表：节点数为N，构造长度N的一维向量，每个数组元素存放一个链表（或pair<int,int>向量），串联所有与该节点相连的边的指向以及权重。（稀疏图）

vector<vector<pair<int, int>>> graph(N);//N个节点
for(auto& edge:edges）{
    graph[edge[0]].push_back({edge[1], edge[2]});
}

无权图（或同权）的最短路径

可以用队列+BFS思想实现，每次步进一步，类似二叉树的层序遍历。

具体：把起点放入队列，然后步数+1，向队列中加入当前步数可以访问到的节点，循环往复直到队列为空。

有权图的最短路径

Dijikstra

解决：单点到多点的最短路径，leetcode743.

思想：维护起点到各个点的距离（一维数组）dist，以及节点标记（一维数组）path有没有遍历过。

过程：取出dist中没有被path标记的最短距离的节点（可以用优先级队列），添加该点的所有边，更新dist数组，循环往复，直到所有点都被标记（即循环N次）。

//用队列的话可以不需要标记 
struct cmp{
    bool operator()(pair<int, int>& a, pair<int, int>& b) {
        return a.second > b.second;
    }
};
void dijkstra(int start, int N){
    vector<int> dist(N+1, INT_MAX);
    dist[start] = 0;
    priority_queue<pair<int,int>, vector<pair<int,int>>, cmp> q;//小顶堆
    q.push({start, 0});//队列中加入起始点
    while(!q.empty()){
        //取出dist中最小的
        int cur = q.top().first;
        int curdist = q.top().second;
        q.pop();
        if(curdist > dist[cur]) continue;//如果cur已经确定过了，dist[cur]就是最小的
        //遍历所有边
        for(int i = 1; i <= N; ++i){
            if(graph[cur][i] == INT_MAX) continue;
            if(dist[i] > graph[cur][i] + curdist){//需要更新
                dist[i] = graph[cur][i] + curdist;
                q.push({i, dist[i]});
                /*这里可以做很多扩展操作：
                    如：记录前置节点。
                */
            }
        }
    }
    //dist数组就是与start的最短距离。
}

//不用队列，需要标记遍历过的点
void dijkstra(int start, int N){
    vector<int> dist(n+1, INT_MAX);
    vector<bool> path(n+1, false);

    dist[k] = 0;
    for(int i = 0; i < N; ++i){
        //找到dist里的最小点
        int cur = 0;//0是没用的点，如果是起点就会出错，因为不会有更近的
        for(int j = 1; j <= n; ++j){
            if(dist[j] < dist[cur] && !path[j]) //找到未标记里最小的
                cur = j;
        }
        for(int j = 1; j <= N; ++j){
            if(graph[cur][j] == INT_MAX) continue;
            if(graph[cur][j] + dist[cur] < dist[j]) 
                dist[j] = graph[cur][j] + dist[cur];
        }
        path[cur] = true;//标记
    }
}

Floyd

解决：多点到多点的最短路径，如果只求一个点就用Dijkstra，O(n^2)。

思想：贪心暴力。两点间增加一个松弛点，遍历所有可能的中间点，刷新所有两点间的距离。

过程：外循环遍历中间点，内两层循环遍历所有点。O(n^3)

void floyd(int n){
    vector<vector<int>> graph(n+1, vector<int>(n+1, INT_MAX/2));
    for(auto& edge:edges){
        graph[edge[0]][edge[1]] = edge[2];
    }
    for(int i = 1; i <= n; ++i){
        graph[i][i] = 0;
    }
    for(int m = 1; m <= n; ++m){
        //经过的中间点
        for(int i = 1; i <= n; ++i){
            for(int j = 1; j <= n; ++j){
                graph[i][j] = min(graph[i][j], graph[i][m] + graph[m][j]);
            }
        }
    }    
}