最短路小结--模板

最新推荐文章于 2021-06-19 22:55:14 发布

bupt_xycr

最新推荐文章于 2021-06-19 22:55:14 发布

阅读量238

点赞数

分类专栏：最短路

本文链接：https://blog.csdn.net/u013077144/article/details/51211892

版权

最短路专栏收录该内容

18 篇文章 0 订阅

订阅专栏

以hdu2544为例

（1）dijkstra主要是从第一个点开始枚举，每次枚举出当当前最小的路径，然后再以那最小的路径点为起点，求出它到其它未标记点的最短距离。（没优化O(n2)）

（2） Floyd 算法又称为，插点法，是一种用于寻找给定的加权图中多源点之间最短路径的算法。感觉和dijkstra算法差不多。只不过是枚举k的值来找最小的路径。 O(n3)

（3）bellman-ford 算法则是假设有向网中有n 个顶点、且不存在负权值回路，从顶点v1 和到顶点v2 如果存在最短路径，则此路径最多有n-1 条边。这是因为如果路径上的边数超过了n-1 条时，必然会重复经过一个顶点，形成回路；而如果这个回路的权值总和为非负时，完全可以去掉这个回路，使得v1到v2的最短路径长度缩短。

下面将以此为依据，计算从源点v0 到其他每个顶点u 的最短路径长度dist [u]。

Bellman-Ford 算法构造一个最短路径长度数组序列：dist 1 [u]，dist 2 [u]，dist 3 [u]，…，distn-1 [u]。

其中：

dist 1 [u]为从源点v0 到终点u 的只经过一条边的最短路径长度，并有dist 1 [u] = Edge[v0][u]；

dist 2 [u]为从源点v0 出发最多经过不构成负权值回路的两条边到达终点u 的最短路径长度；

dist 3 [u]为从源点v0 出发最多经过不构成负权值回路的三条边到达终点u 的最短路径长度；

……

dist n-1 [u]为从源点v0 出发最多经过不构成负权值回路的n-1 条边到达终点u 的最短路径长

度；

补充:

考虑：为什么要循环V-1次？

答：因为最短路径肯定是个简单路径，不可能包含回路的，

如果包含回路，且回路的权值和为正的，那么去掉这个回路，可以得到更短的路径

如果回路的权值是负的，那么肯定没有解了

图有n个点，又不能有回路

所以最短路径最多n-1边

又因为每次循环，至少relax一边

所以最多n-1次就行了

bellman-ford未优化AC代码（主要为了理解概念）:
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define INF 10000000
#define N  200000
int u[N],v[N],w[N];
int d[N];
int n,m;
void Bellman_ford()
{
    for(int i=1;i<=n;i++)d[i]=INF;
    d[1]=0;
    for(int k=0;k<n;k++)
        for(int i=1;i<=2*m;i++)//从dist(1)[u]递推出dist(2)[u], …,dist(n-1)[u] ,因为这是无向图，所以
多检查了一些边
        {
            int x,y;
            x=u[i];
            y=v[i];
	    if(d[y]>d[x]+w[i])
		d[y]=d[x]+w[i];
        }
}
int main()
{
    int i,j;
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        if(n==0&&m==0)break;
        for(i=1;i<=2*m;i++){
            scanf("%d %d %d",&u[i],&v[i],&w[i]);
            int tempu = u[i];
            int tempv = v[i];
            int tempw = w[i];
            u[++i] = tempv;
            v[i] = tempu;
            w[i] = tempw;
        }
        Bellman_ford();
        printf("%d\n",d[n]);
    }
    return 0;
}

优化后代码：
#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<algorithm>
#include<vector>
using namespace std;
#define maxn 105
const int INF = 0x3fffffff;
struct Edge
{
    int from,to,dist;
};
struct BellmanFord
{
    int n,m;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool inq[maxn];
    int d[maxn];
    int p[maxn];
    int cnt[maxn];
    Edge e;
    void init(int n)
    {
        this->n=n;
        for(int i=0;i<n;i++)
            G[i].clear();
        edges.clear();
    }
    void AddEdge(int from,int to,int dist)
    {
        //printf("%d %d %d\n",from,to,dist);
        edges.push_back((Edge){from,to,dist});
        m=edges.size();
        G[from].push_back(m-1);
    }
    bool negativeCycle()
    {
        queue<int >Q;
        memset(inq,0,sizeof(inq));
        memset(cnt,0,sizeof(cnt));
        for(int i=0;i<n;i++)
        {
            d[i]=INF;
            inq[0]=true;
            Q.push(i);
        }
        d[0] = 0;
        while(!Q.empty())
        {
            int u=Q.front();
            Q.pop();
            inq[u]=false;

            for(int i=0;i<G[u].size();i++)   //只检查存在的边
            {
                Edge& e=edges[G[u][i]];
                if(d[e.to]>d[u]+e.dist)
                {
                    d[e.to]=d[u]+e.dist;
                    p[e.to]=G[u][i];
                    if(!inq[e.to])
                    {
                        Q.push(e.to);
                        inq[e.to]=true;
                        if(++cnt[e.to]>n)
                            return true;
                    }
                }
            }

        }
        return false;
    }
    void To(){
            printf("%d\n",d[n-1]);
    }
};
int main()
{
     int a,b,c,i,node,m;
     bool j;
     while(scanf("%d %d",&node,&m)!=EOF)
     {
            if(node==0&&m==0)break;
            BellmanFord tu;
            tu.init(node);
            for(i=0;i<m;i++)
            {
                scanf("%d %d %d",&a,&b,&c);
                a--;b--;
                tu.AddEdge(a,b,c);
                tu.AddEdge(b,a,c);
            }

            j=tu.negativeCycle();
            tu.To();
     }
     return 0;
}

Dijkstra


#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdlib>
#include<vector>
#include<cmath>
#include<stdlib.h>
#include<iomanip>
#include<list>
#include<deque>
#include<map>
#include <stdio.h>
#include <queue>

#define maxn 10000+5
#define ull unsigned long long
#define ll long long
#define reP(i,n) for(i=1;i<=n;i++)
#define rep(i,n) for(i=0;i<n;i++)
#define cle(a) memset(a,0,sizeof(a))
#define mod 90001
#define PI 3.141592657

const ull inf = 1LL << 61;
const double eps=1e-5;
const int INF=1<<30;
using namespace std;

bool cmp(int a,int b){
    return a>b;
}
int edge[110][110];
int lowcost[110];
int vis[110];
int n,m;
void Dj(int cur)
{
    cle(vis);
    vis[cur]=1;
    for(int i=1;i<=n;i++)
        lowcost[i]=edge[cur][i];
    int k,Min;
    while(1)
    {
        Min=INF;
        for(int j=1;j<=n;j++)
            if(!vis[j]&&Min>lowcost[j])
        {
            Min=lowcost[j];k=j;
        }
        if(Min==INF)break;
        vis[k]=1;
        for(int j=1;j<=n;j++)
        {
            if(!vis[j]&&lowcost[j]>lowcost[k]+edge[k][j])
                lowcost[j]=lowcost[k]+edge[k][j];
        }
    }
    cout<<lowcost[n]<<endl;
}
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);

    int a,b,c;
    while(cin>>n>>m)
    {
        if(n==0&&m==0)break;
        for(int i=1;i<=n;i++)
           for(int j=1;j<=n;j++)
              { if(i==j){edge[i][j]=0;edge[j][i]=0;}
                  else {edge[i][j]=INF;edge[j][i]=INF;}
              }
        for(int i=1;i<=m;i++)
        {
            cin>>a>>b>>c;
            if(c<INF)
            {   edge[a][b]=c;
                edge[b][a]=c;
            }
        }
       // cout<<INF<<endl;
        Dj(1);
    }
    return 0;
}

SPFA

#include<iostream>  
#include<cstdio>  
#include<cstring>  
#include<algorithm>  
#include<queue>  
using namespace std;  
#define N 110  
#define inf 0x3fffffff  
int f[N][N],n,m;  
void spfa(){  
    int d[N],v[N]={0},k;  
    for(int i=1;i<=n;i++)d[i]=inf;  
    d[1]=0;  
    queue<int>p;  
    p.push(1);  
    while(!p.empty()){  
        k=p.front();p.pop();  
        v[k]=0;  
        for(int i=2;i<=n;i++){  
            int t=d[k]+f[k][i];  
            if(d[i]>t){  
                d[i]=t;  
                if(v[i]==0){p.push(i);v[i]=1;}  
            }  
        }  
    }  
    printf("%d\n",d[n]);  
}  
int main(){  
    int i,j,k;  
    while(scanf("%d%d",&n,&m)){  
        if(n==0&&m==0)break;  
        for(i=0;i<=n;i++){  
            f[i][i]=0;  
            for(j=i+1;j<=n;j++)  
                f[i][j]=f[j][i]=inf;  
        }  
        while(m--){  
            scanf("%d%d%d",&i,&j,&k);  
            f[i][j]=f[j][i]=k;  
        }  
        spfa();  
    }  
return 0;  
}

bupt_xycr

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
最短路小结--模板

以hdu2544为例（1）dijkstra主要是从第一个点开始枚举，每次枚举出当当前最小的路径，然后再以那最小的路径点为起点，求出它到其它未标记点的最短距离。（没优化O(n2)）（2）Floyd算法又称为，插点法，是一种用于寻找给定的加权图中多源点之间最短路径的算法。感觉和dijkstra算法差不多。只不过是枚举k的值来找最小的路径。 O(n3)（3）bellman-ford 算法则是假设有向
复制链接

扫一扫

专栏目录