最短路问题

最短路问题是图论中最基础的问题。最短路是给定两个顶点，
在以这两个点为起点和终点的路径中。边的权值和最小的路径。
智力游戏中的求解最少步数问题也能够说是一种最短路问题。

1.单源最短路问题1（Bellman-Ford算法）

//从顶点from指向顶点to的权值为cost的边
struct edge { int from, to, cost; };

edge es[max];  //边

int d[maxn];   //最短距离
int V, E;   //V是顶点数，E是边数

//求解从顶点s出发到全部点的最短距离
void short_path(int s)
{
    for (int i = 0; i < V; i++){
        d[i] = INF;
    }
    d[s] = 0;
    while (true){
        bool update = false;
        for (int i = 0; i < E; i++){
            edge e = es[i];
            if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost){
                d[e.to] = d[e.from] + e,cost;
                update = true;
            }
        }
        if (!update)
            break;
    }
}

假设图中不存在从s可达的负圈，那么最短路不会经过同一个点两次（也就是说，最多通过|V| - 1条边），
while（true）的循环最多运行|V| - 1次。因此，复杂度是O（|V|*|E|）。

反之。假设存在
从s可达的负圈，那么在第|V|次循环中也会更新d的值，因此也能够用这个性质来检查负圈。
假设一開始对全部的顶点i。都把的d[i]初始化为0，那么能够检查出全部的负圈。

//假设返回true则存在负圈
bool find_negative_loop()
{
    memset(d, 0, sizeof(d));

    for (int i = 0; i < V; i++){
        for (int j = 0; j < E; j++){
            edge e = es[j];
            if (d[e.to] > d[e.from] + e.cost){
                d[e.to] = d[e.from] + e.cost;

                //假设第n次仍然更新了，则存在负圈
                if (i == V - 1)
                    return true;
            }
        }
    }
    return false;
}

2.单源最短路问题2(Dijkstra算法)
(1)找到最短距离已经确定的顶点。从他出发更新相邻顶点的最短距离
(2)此后不须要再关心1中的“最短距离已经确定的顶点”。
在（1）（2）中提到的“最短距离已经确定的顶点”要怎么得到是问题的关键。

在最開始，
仅仅有起点的最短距离是确定的。而在尚未使用过的顶点中，距离的d[i]最小的顶点就是最短距离
已经确定的顶点。这是由于由于不存在负边。全部d[i]不会在之后的更新中变小。这个算法
叫做Dijkstra算法。

int cost[maxn][maxn];  //cost[u][v]表示边e=（u。v）的权值（不存在这条边时设为INF）
int d[maxn];   //顶点s出发的最短距离
bool used[maxn];   //已经使用过的图
int V;    //顶点数

//求从起点s出发到各个顶点的最短距离
void dijkstra(int s)
{
    fill(d, d + V, INF);
    fill(used, used + V; false);
    d[s] = 0;

    while (true){
        int v = -1;
        //从尚未使用过的顶点中选择一个距离最小的顶点
        for (int u = 0; u < V; u++){
            if (!used[u] && (v == -1 || d[u] < d[v]))
                v = u;
        }

        if (v == -1)
            break;
        used[v] = true;

        for (int u = 0; u < V; u++){
            d[u] = min(d[u], d[v] + cost[v][u]);
        }
    }
}

使用邻接矩阵实现的Dijkstra算法的复杂度是O(|V|2)。使用邻接表的话，更新最短距离仅仅须要訪问每条边一次
就可以。因此这部分算法的复杂度是O(|E|)。

可是每次要枚举全部的顶点来查找下一个使用的顶点。一次终于
复杂度还是O(|V|2)。

因此使用数据结构进行优化。
以下是使用STL的priority_queue的实现。

struct edge {int to, cost};
typedef pair<int, int> P;   //first是最短距离，second是顶点的编号

int V;
vector<edge> G[maxn];
int d[maxn];

void dijkstra(int s)
{
    //通过指定greater<P>參数，堆依照first从小到大的顺序取出值
    priority_queue<P, vector<P>, greater<P> > que;
    fill(d, d + V; INF);
    d[s] = 0;
    que.push(P(0, s));

    while (!que.empty()){
        P p = que.top();
        que.pop();
        int v = p.second;
        if (d[v] < p.first)
            continue;
        for (int i = 0; i < G[v].size(); i++){
            edge e = G[v][i];
            if (d[e.to] > d[v] + e.cost){
                d[e.to] = d[v] + e.cost;
                que.push(P(d[e.to], e.to));
            }
        }
    }
}

3.随意两点间的最短路问题(Floyd-Warshall算法)
使用DP来求解随意两点间最短路问题。仅仅使用顶点0~k和i,j的情况下，记i到j的最短路长度为
d[k+1][i][j]。

k = -1时。觉得仅仅使用i和j，所以d[0][i][j] = cost[i][j]。接下来让我们把
仅仅使用顶点0~k的问题归约到仅仅使用0~k-1的问题上。
仅仅使用0~k时，我们分i到j的最短路正好经过顶点k一次和全然不经过顶点k两种情况来讨论。
不经过顶点k的情况下。d[k][i][j] = d[k - 1][i][j].通过顶点k的情况下，d[k][i][j] =
d[k - 1][i][k] + d[k - 1][k][j].
合起来，就得到了d[k][i][j] = min(d[k - 1][i][j], d[k - 1][i][k] + d[k - 1][k][j])。
这个DP也能够使用同一个数组，不断进行d[i][j] = min(d[i][j], d[i][k] + d[k][j])的更新来实现。

int d[maxn][maxn];   //d[u][v]表示边e = (u,v)的权值（不存在时设为INF，只是d[i][i] = 0）
int V;   //顶点数

void warshall_floyd()
{
    for (int k = 0; k < V; k++){
        for (int i = 0; i < V; i++){
            for (int j = 0; j < V; j++){
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
            }
        }
    }
}

4.路径还原
在求解最短距离时。满足d[j] = d[k] + cost[k][j]的顶点k，就是最短路上顶点j的前驱结点。
因此通过不断寻找前驱结点就能够恢复出最短路。

时间复杂度是O(|E|).

int prev[maxn];   //最短路上的前驱结点

//求从起点s出发到各个顶点的最短距离
void dijkstra(int s)
{
    fill(d, d + V; INF);
    fill(used, used + V, false);
    fill(prev, prev + V, -1);
    d[s] = 0;
    
    while (true){
        int v = -1;
        for (int u = 0; u < V; u++){
            if (!used[u] && (v == -1 || d[u] < d[v]))
                v = u;
        }
        
        if (v == -1)
            break;
        used[v] = true;
        
        for (int u = 0; u < V; u++){
            if (d[u] > d[v] + cost[v][u]){
                d[u] = d[v] + cost[v][u];
                prev[u] = v;
            }
        }
    }
}

//到顶点t的最短路
vector<int> get_path(int t)
{
    vector<int> path;
    for ( ; t != -1; t = prev[t])
        path.push_back(t);   //不断沿着prev[t]走直到t = s;
    reverse(path.begin(), path.end());
    return path;
}