算法笔记：Codeup_最短路径_问题 C: 最短路径

题目描述

N个城市，标号从0到N-1，M条道路，第K条道路（K从0开始）的长度为2^K，求编号为0的城市到其他城市的最短距离。

输入

第一行两个正整数N（2<=N<=100）M(M<=500),表示有N个城市，M条道路，
接下来M行两个整数，表示相连的两个城市的编号。

输出

N-1行，表示0号城市到其他城市的最短路，如果无法到达，输出-1，数值太大的以MOD 100000 的结果输出。

思路：难点在于最多会有500条道路，用int储存变量最多也就表示到2的31次方也就是第31条道路，而如果在建图算路径时每次都取模的话会导致一些k值更大更长的路径取模后小于k值更小的路径，不能算出正确的最短路径。因此，在建图时，邻接矩阵中只保存k值，不保存由k值计算出的实际路径长度。但如果用这种保存方法，传统的Dijkstra无法正确得出正确的最短路径，因此我将传统Dijkstra：

for(int j = 0;j < n;j++){
    if(!vis[j] && G[u][j] != INF){
        if(G[u][j] + d[u] < d[j]){//传统的Dijsktra判断是否更新d[j]
            d[j] = G[u][j] + d[u];
        }
    }   
}

改为了：

for(int j = 1;j < n;j++){
            if(!vis[j] && G[u][j] != INF){
                if(G[u][j] < d[j]){//这里改了更新d[j]条件
                    d[j] = G[u][j];
                    pre[j] = u;
                    //由于d[j]不再记录最短路径的和，因此用pre记录最短路径上的上一个结点
                    //后续只需对pre数组进行递归，计算各点的最短路径
                }
            }
        }

利用的性质是：2^0 + 2^1 + 2^2 + ... + 2^(k-1) = 2^k - 1.(等比数列求和)

即2^0 + 2^1 + 2^2 + ... + 2^(k-1) < 2^k.

 举个例子：对于下图这种情况，想求从0到4的最短路径，如果用传统Dijkstra会得到k=4的这条边是0到4的最短路径，而实际上：

Distance(0->4) = 2^4 = 16;

Distance(0->1->2->3->4) = 2^0 + 2^1 + 2^2 + 2^3 = 15;

最短路径应该是0->1->2->3->4;

 

在这种情况里，一个k=4就打破了前面四条路（0->1->2->3->4）所积累的所有长度，因此我们没必要在dijkstra算法中更新d[j]时再求前面所有的加和，反正只要一个最大的k就可以打破其他所有的路径的加和，因此，我们的d数组，d[i]表示从0到i点一路走来，经历过最大的k值，更新条件为：当我们遇到更小的k值，我们便可以更新d[i]为更小的k值（更小的k值代表更短的路径）。

水平不高，代码比较冗长，大家看Dijkstra部分就好。

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxN = 110;
const int INF = 0x3fffffff;
const int mod = 100000;
int G[maxN][maxN];
bool vis[maxN];
int d[maxN];
int ans[maxN];
int pre[maxN];
int n,m;
int fake_pow(int num){
    int t = 1;
    for(int i = 0;i < num;i++){
        t = (t*2) % mod;
    }
    return t;
}
void Dijkstra(int s){
    fill(d , d+maxN , INF);
    d[s] = 0;
    for(int i = 0;i < n;i++){
        int u = -1 , MIN = INF;
        for(int j = 0;j < n;j++){
            if(!vis[j] && d[j] < MIN){
                u = j;
                MIN = d[j];
            }
        }
        if(u == -1) return;
        vis[u] = true;
        for(int j = 1;j < n;j++){
            if(!vis[j] && G[u][j] != INF){
                if(G[u][j] < d[j]){
                    d[j] = G[u][j];
                    pre[j] = u;
                }
            }
        }
    }
}
bool get_a[maxN];
bool get_ans(int s){
    if(pre[s] == 0){
        ans[s] = fake_pow(G[s][pre[s]]-1);
        get_a[s] = true;
        return true;
    }else if(pre[s] == -1){
        ans[s] = -1;
        return false;
    }
    if(get_ans(pre[s])) {
        ans[s] = ans[pre[s]] + fake_pow(G[s][pre[s]]-1);
        get_a[s] = true;
    }else{
        ans[s] = -1;
        return false;
    }
    return true;
}
void final_ans(){
    memset(get_a , false , sizeof(bool) *maxN);
    for(int i = 1;i < n;i++){
        if(!get_a[i]){
            get_ans(i);
        }
    }
}
int main(){
    while(scanf("%d%d",&n,&m) != EOF){
        fill(vis , vis +maxN , false);
        fill(ans , ans +maxN , -1);
        fill(G[0],G[0] + maxN*maxN , INF);
        fill(pre,pre+maxN , -1);
        int c1 , c2;
        for(int i = 1;i <= m;i++){
            scanf("%d%d",&c1 , &c2);
            G[c1][c2] = i;
            G[c2][c1] = i;
        }
        Dijkstra(0);
        final_ans();
        for(int i = 1;i < n;i++){
            printf("%d\n",ans[i]%mod);
        }
    }
    return 0;
}