关于最短路的几个算法

关于最短路的几个算法有Dijkstra，Bellman-Ford，Floyd

Dijkstra：

Dijkstra适用于边权为正的情况，从单个源点出发，到其他所有结点的最短路

算法的核心是用已经知道的结点 i 的距离 d[i] 去更新和这个结点相连的其他结点的距离

 

struct node

{

    int d,u; //d是距离,u是另一个结点的编号

    bool operator<(const node A) const

    {

        return d>A.d;

    }

};

struct Dijkstra

{

    int n,m;  //点数和边数

    vector<Edge> edges;  //边列表

    vector<int> G[MAXN];  //每个结点出发的边编号（从0开始编号）

    int vis[MAXN];  //判断点是否被访问

    int d[MAXN];  //s到各个点的距离

    int p[MAXN];  //最短路上的一条边



    void init(int n)

    {

        this->=n;

        for(int i=0;i<n;i++) G[i].clear();  //清空邻接表

        edges.clear();  //清空边表

    }



    void  AddEdge(int from,int to,int dist)  //如果是无向边需调用两次AddEdge

    {

        edges.push_back((Edge){from,to,dist});

        m=edges.size();

        G[from].push_back(m-1);

    }

};

void dijkstra(int s)  //求s到所有点的距离

{

    priority_queue<node> Q;

    memset(vis,0,sizeof(vis));

    for(int i=1;i<=n;i++)

        d[i]=INF;

    d[s]=0;

    node start;

    start.d=0,start.u=s;

    Q.push(start);

    while(!Q.empty())

    {

        node x=Q.top;Q.pop();

        int u=x.u;

        if(vis[u]) continue;

        vis[u]=1;

        for(itn i=0;i<G[u].size();i++)

        {

            Edge& e=edges[G[u][i]];

            if(d[e.to]>d[u]+e.dis)

            {

                node next;

                d[e.to]=d[u]+e.dis;

                p[e.to]=G[u][i];

                next.d=d[e.to];

                next.u=e.to;

                Q.push(next);

            }

        }

    }

}

 

其核心思想还是没有变，依旧是用已经知道的点去更新起点s到其他点的距离，用优先队列，优先级最大的是距离最小的点，然后用这个点去更新其他点

最坏的情况下仍然会循环n-1次，但是从整体上看，每条边恰好被检查过一次，所以松弛操作的执行次数恰好是m次，这样只用找未被访问的d的最小值即可

可以说即使是稠密图，用了priority_queue还是会比用邻接矩阵的Dijstra算法快，因为不满足d[e.to]>d[u]+e.dis是不能入队的，所有push操作会很少

 

Bellman-Ford:

Bellman-Ford也是一个求最短路的算法，这个算法用于算最短路的时候，如果最短路存在，那么一定是一个不含环的最短路，那么这个算法还有一个用处就是判环，

如果存在负环的话，那么便不会存在最短路（因为会不断松弛下去）

如果不含环的话，那么最多便通过n-1个结点（不包含起点），通过n-1“轮”松弛操作便可以计算出最短路

算法核心就是通过循环n-1次，每次对所有的边进行松弛操作边去更新结点距离

for(int i=1;i<=n;i++)

    d[i]=INF;

d[0]=0;

for(int i=0;i<n-1;i++)  //迭代n-1次

{

    for(int j=0;j<m;j++)  //检查每一条边

    {

        int x=u[i],y=v[i];

        if(d[x]<INF)

        {

            d[y]=min(d[y],d[x]+w[i]);  //松弛操作

        }

    }

}

这个代码很明显没有进行负环的判定，复杂度是O(nm)

可以用FIFO队列进行优化，可以进行循环检查

struct Edge

{

    int from,to,dis;

    Edge(int u,int v,int d):from(u),to(v),dis(d) {}

};

vector<Edge> edges;

vector<int> G[MAXN];

int vis[MAXN];  //判断结点是否被访问

int p[MAXN];  //最短路上的一条弧

int d[MAXN]; //起点s到各点的距离



bool Bellman-Ford(int s)

{

    queue<int> Q;

    memset(inq,0,sizeof(inq));

    memset(cnt,0,sizeof(cnt));

    for(int i=0;i<n;i++)

        d[i]=INF;

    d[s]=0;

    inq[s]=true;

    Q.push(s);



    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[u]<INF && d[e.to]>d[u]+e.dis) //松弛

            {

                d[e.to]=d[u]+e.dis;

                p[e.to]=G[u][i];

                if(!inq[e.to])

                {

                    Q.push(e.to);

                    inq[e.to]=true;

                    if(++cnt[e.to]>n) return false;  //如果一个点入队大于n次，那么一定存在负环

                }

            }

        }

        return true;

    }

}

 

用队列优化的Bellman-Ford也叫SPFA（Shortest Path Faster Algorithm）

下面讨论下SPFA

 先转载这两篇，觉得写的不错，以后慢慢填坑

http://blog.csdn.net/hqd_acm/article/details/5442872

http://blog.csdn.net/hqd_acm/article/details/5804345