HDU 2544 最短路（我的dijkstra算法模板、SPAFA算法模板）

思路：这道题是基础的最短路径算法，可以拿来试一下自己对3种方法的理解

dijkstra主要是从第一个点开始枚举，每次枚举出当当前最小的路径，然后再以那最小的路径点为起点，求出它到其它未标记点的最短距离

 

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 的最短路径长
度；

dijkstraAC代码：

 

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define INF 0x3f3f3f3;
int map[110][110],dis[110],visited[110];

void Dijkstra(int n,int x)
{
    int i,p,j,min;
    for (i=1;i<=n;i++)
    {
        dis[i]=map[1][i];
        visited[i]=0;
    }
    visited[x]=1;//顶点v0 加入到顶点集合S
    for (i=1;i<=n;i++)//从顶点v1 确定n 条最短路径
    {
        min=INF;  
        for (j=1;j<=n;j++)//选择当前集合T 中具有最短路径的顶点p
        {
            if(!visited[j] && dis[j]<min)
            {
                p=j;
                min=dis[j];
            }
        }
        visited[p]=1;//将顶点p加入到集合S，表示它的最短路径已求得
        for (j=1;j<=n;j++)//修改T 集合中顶点的dist值
        {
            if(!visited[j] && dis[p]+map[p][j]<dis[j])
            {
                    dis[j]=dis[p]+map[p][j];
            }
        }
    }

}

int main()
{
    int n,m,i,j,a,b,t;
    while(scanf("%d%d",&n,&m)!=EOF,n+m)
    {
        for (i=1;i<=n;i++)
        {
            for (j=1;j<=n;j++)
            {
                map[i][j]=INF;
            }
        }
        for(i=1;i<=m;i++)
        {
            scanf("%d%d%d",&a,&b,&t);
            map[a][b]=map[b][a]=t;
        }
        Dijkstra(n,1);
        printf("%d\n",dis[n]);
    }
    return 0;
}

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[x]<INF)
                d[y]=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;
}