最短路径

最新推荐文章于 2021-02-11 11:36:42 发布

二十七º

最新推荐文章于 2021-02-11 11:36:42 发布

阅读量188

点赞数 1

分类专栏：算法

本文链接：https://blog.csdn.net/ckk727/article/details/97122784

版权

算法专栏收录该内容

12 篇文章 0 订阅

订阅专栏

<前导>

这里回顾四种计算最短路径的算法，分别为：

Floyd算法；
Dijkstra算法；
Bellman-Ford算法；
SPFA算法；

<Floyd算法>

Floyd算法的实现非常简单，直接看代码：

int d[maxn][maxn];//d[i][j]表示顶点i、j之间的最短距离
int inf=99999999;
for(int i=0;i<maxn;i++){
    d[i][i]=0; //初始化
}
void Floyd(){
    for(int k=0;k<n;k++){ //注意Floyd算法先循环中转点k
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(d[i][k]<inf&&d[k][j]<inf&&d[i][k]+d[k][j]<d[i][j])
                    d[i][j]=d[i][k]+d[k][j];
            }
        }
    }
}

<dijkstra算法>

//以邻接矩阵为例
bool book[maxn]={false};
int d[maxn];
int G[maxn][maxn];//注意G也需要初始化，除了输入的边之外，其余不连通的边全部设为inf
int n,inf=99999999;
void Dijkstra(int s){
    for(int i=0;i<maxn;i++){
        d[i]=inf;//初始化
    }
    d[s]=0;
    for(int i=0;i<n;i++){
        int u,mind=inf;
        for(int j=0;j<n;j++){ //该循环可以用堆优化，使复杂度降低至logn；
            if(book[j]==false&&d[j]<mind){
                u=j;
                mind=d[j];
            }
        }
        book[u]=true;
        for(int v=0;v<n;v++){
            if(book[v]==false&&G[u][v]<inf&&d[u]+G[u][v]<d[v])
                d[v]=d[u]+G[u][v];
        }
    }
}

这种写法的复杂度为O(n*(n+n))=O(n^2)，当然用堆优化之后会降至O(n*(logn+n)),如果再用上邻接表，那么复杂度会进一步降至O(n*(logn+m));

当然这是针对于顶点远小于边数的稀疏图来讲，在规定必须使用Dijkstra算法的情况下，对于储存图的方式，如果是顶点远大于边数的稀疏图，用邻接表比较适合，如果是边数大于顶点数的稠密图，用邻接矩阵计较适合；

<Dijkstra的拓展>

1.输出最短路径
核心依旧不变，只需要多开一个pre[maxn]数组记录每次更新d[v]时v的前一个结点即可；

int n,G[maxn][maxn];
int d[maxn],pre[maxn];
bool book[maxn]={false};
void Dijkstra(int s){
    for(int i=0;i<maxn;i++){
        d[i]=inf;
        pre[i]=i;//初始化
    }
    d[s]=0;
    for(int i=0;i<n;i++){
        int u,mind=inf;
        for(int j=0;j<n;j++){
            if(book[j]==false&&d[j]<mind){
                u=j;
                mind=d[j];
            }
        }
        book[u]=true;
        for(int v=0;v<n;v++){
            if(book[v]==false&&G[u][v]<inf&&d[u]+G[u][v]<d[v]){
                d[v]=d[u]+G[u][v];
                pre[v]=u;//记录前驱
            }
        }
    }
}
//如果要输出，则可以用递归实现
void dfs(int s,int v){ //从终点开始递归
    if(v==s){
        cout<<s<<" ";
        return;
    }
    dfs(s,pre[v]);
    cout<<v<<" ";
}

2.除距离之外新增第二标尺，如物资、花费、最短路径不止一条等；
一个例子：

int n,G[maxn][maxn],weight[maxn];//新增点权
int d[maxn],w[maxn],num[maxn];//最短路径不止一条
bool book[maxn]={false};
void Dijkstra(int s){
    for(int i=0;i<maxn;i++){
        d[i]=inf;
        w[i]=0;
        num[i]=0;
    }
    d[s]=0;
    w[s]=weight[s];
    num[s]=1;
    for(int i=0;i<n;i++){
        int u,mind=inf;
        for(int j=0;j<n;j++){
            if(book[j]==false&&d[j]<mind){
                u=j;
                mind=d[j];
            }
        }
        book[u]=true;
        for(int v=0;v<n;v++){
            if(book[v]==false&&G[u][v]<inf){
                if(d[u]+G[u][v]<d[v]){
                    d[v]=d[u]+G[u][v];
                    w[v]=w[u]+weight[v];
                    num[v]=num[u];
                }
                else if(d[u]+G[u][v]==d[v]){
                   if(w[u]+weight[v]>w[v])
                       w[v]=w[u]+weight[v];
                }
                num[v]+=num[u];
            }
        }
    }
}

3.Dijkstra与dfs结合处理复杂问题

vector<int> pre[maxn];
void Dijkstra(int s){
    for(int i=0;i<maxn;i++){
        d[i]=inf;
    }
    d[s]=0;
    for(int i=0;i<n;i++){
        int u,mind=inf;
        for(int j=0;j<n;j++){
            if(book[j]=false&&d[j]<mind){
                u=j;
                mind=d[j];
            }
        }
        book[u]=true;
        for(int v=0;v<n;v++){
            if(book[v]==false&&G[u][v]<inf){
                if(d[u]+G[u][v]<d[v]){
                    d[v]=d[u]+G[u][v];
                    pre[v].clear();
                    pre[v].push_back(u);
                }
                else if(d[u]+G[u][v]==d[v])
                    pre[v].push_back(u);
            }
        }
    }
}
//dfs的书写
vector<int> temppath,path;
void dfs(int v){
    if(v==s){
        temppath.push_back(v);
        int value;
        for(int i=temppath.size()-1;i>0;i--){
            //计算value
        }
        if(value<mincost){ //此处mincost只是借指,即在这里进行第二、甚至第三标尺的比较
            mincost=value;
            path=temppath;//更新path
        }
        temppath.popback();
        return;
    }
    temppath.push_back(v);
    for(int i=0;i<pre[v].size();i++){
        dfs(pre[v][i]);
    }
    temppath.pop_back();
}

<Bellman-Ford算法>

Bellman-Ford算法的核心在于对所有的边进行松弛操纵，一步一步确立最短路径；
需要进行多少次松弛？如果顶点数是n，那么最多需要进行n-1轮，注意是最多，因为bf算法是一步步确定最短路径，因此也有可能不需要n-1次就已经得到了最短路径；
那么为什么是n-1次，因为最多只有n-1条边；

最短路径可能包含回路么？答案是不可能。回路要么正权回路，要么负权回路，正权回路显然不可能为最短路径，负权回路的话，每一次循环该回路都会使最短路径长度更小，那就没有最短路径了；

代码：

struct node{
    int v,dis;
}
int n,d[maxn];
vector<node> Adj[maxn];
bool bf(int s){
    for(int i=0;i<maxn;i++){
        d[i]=inf;
    }
    d[s]=0;
    for(int i=0;i<n-1;i++){
        for(int u=0;u<n;u++){
            for(int j=0;j<Adj[maxn].size();j++){
                int v=Adj[u][j].v;
                int dis=Adj[u][j].dis;
                if(d[u]+dis<d[v])
                    d[v]=d[u]+dis;
            }
        }
    }
    for(int u=0;u<n;u++){ //判断是否有负权回路
        for(int j=0;j<Adj[u].size();j++){
            int v=Adj[u][j].v;
            int dis=Adj[u][j].dis;
            if(d[u]+dis<d[v]) //仍然可以被松弛
                return false;
        }
    }
    return true;
}

该算法的时间复杂度为O(NE)，其中E为边的个数，多数情况下该算法的效率并不能让人满意，于是就有了优化后的Bellman-Ford算法；

<SPFA算法>

int n,d[maxn],num[maxn];//num数组判断是否有负环
vector<bode> Adj[maxn];
bool book[maxn]={false};
bool SPFA(int s){
    for(int i=0;i<maxn;i++){
        d[i]=inf;
        num[i]=0;
    }
    queue<int> q;
    q.push(s);
    d[s]=0;
    num[s]=1;
    book[s]=true;
    while(!q.empty()){
        int u=q.front();
        q.pop();
        book[u]=false;
        for(int j=0;j<Adj[u].size();j++){
            int v=Adj[u][j].v;
            int dis=Adj[u][j].dis;
            if(d[u]+dis<d[v]){
                d[v]=d[u]+dis;
                if(!book[v]){
                    q.push(v);
                    book[v]=true;
                    num[v]++;
                    if(num[v]>=n) 
                        return false;
                }
            }
        }
    }
    return true;
}

SPFA算法的时间复杂度为O(kE)，其中k为常数，且多数情况下不超过2，但如果有从起点可达的负环，那么这个复杂度就会退化为O(NE);

<小结>

Dijkstra与Floyd算法不能解决有负权的情况，且与点关系密切，适用于稀疏图，其中Floyd解决全源最短路径问题，Dijkstra解决单源最短路径问题；

Bellman-Ford与SPFA算法可以解决有负权；

二十七º

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
4
评论
最短路径

<前导>这里回顾四种计算最短路径的算法，分别为：Floyd算法；Dijkstra算法；Bellman-Ford算法；SPFA算法；<Floyd算法>Floyd算法的实现非常简单，直接看代码：int d[maxn][maxn];//d[i][j]表示顶点i、j之间的最短距离int inf=99999999;for(int i=0;i<maxn;i...
复制链接

扫一扫

专栏目录