HDU2544---最短路(dijkstra&&floyd&&spfa)

Dijkstra

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define inf 0x3f3f3f3;
int map[110][110],dist[110],vis[110],n,m;
void Dijkstra(int u)
{
    for(int i=1;i<=n;i++)
    {
        dist[i]=map[u][i];
        vis[i]=0;
    }
    dist[u]=0;
    vis[u]=1;
    for(int i=2;i<=n;i++)
    {
        int pos=0,min=inf;
        for(int j=1;j<=n;j++)
            if(!vis[j]&&dist[j]<min)
            {
                pos=j;
                min=dist[j];
            }
        vis[pos]=1;
        for(int j=1;j<=n;j++)
        {
            if(!vis[j]&&dist[j]>dist[pos]+map[pos][j])
                dist[j]=dist[pos]+map[pos][j];
        }
    }

}
int main()
{

    while(scanf("%d%d",&n,&m)!=EOF)
    {

        if(m==0&&n==0) break;
        for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            map[i][j]=inf;

        int a,b,c;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            map[a][b]=map[b][a]=c;
        }
        Dijkstra(1);
        printf("%d\n",dist[n]);
    }
}

Dijkstra's (权值非负)
1 Dijkstra's算法解决的是图中单个源点到其它顶点的最短路径。只能解决权值非负
2 Dijkstral只能求出任意点到达源点的最短距离（不能求出任意两点之间的最短距离），同时适用于有向图和无向图，复杂度为O(n^2).
3算法的过程：
1设置顶点集合S并不断的作贪心选择来选择扩充这个集合。一个顶点属于集合S当且仅当从源点到该点的最短路径长度已知
2 初始时，S中仅含有源。设U是G的某一个顶点，把从源到U且中间只经过S中的顶点的路称为从源到U的特殊路径，并用dis数组距离当前每一个顶点所对应的最短特殊路径
3Dijkstra算法每一次从V-S中取出具有最短特殊长度的顶点u，将u添加到S中，同时对dis数组进行修改。一旦S包含了所有的V中的顶点，dis数组就记录了从源点到其它顶点的最短路径长度。
4 模板:
没有优化，时间复杂度o(n^2)

 

 

Folyd

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define inf 0xffff
int map[110][110],dist[110],vis[110],n,m;
void floyd()
{
    for(int k=1;k<=n;k++)
            for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            if(map[i][k]+map[k][j]<map[i][j])
                map[i][j]=map[i][k]+map[k][j];
}
int main()
{
    while(scanf("%d%d",&n,&m)&&n&&m)
    {
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
            if(i==j) map[i][j]=0;
            else    map[i][j]=inf;
        int a,b,c;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(map[a][b]>c)
                map[a][b]=map[b][a]=c;
        }
        floyd();
        printf("%d\n",map[1][n]);

    }
}

 

Floyd算法是一个经典的动态规划算法。用通俗的语言来描述的话，首先我们的目标是寻找从点i到点j的最短路径。从动态规划的角度看问题，我们需要为这个目标重新做一个诠释（这个诠释正是动态规划最富创造力的精华所在）

      从任意节点i到任意节点j的最短路径不外乎2种可能，1是直接从i到j，2是从i经过若干个节点k到j。所以，我们假设Dis(i,j)为节点u到节点v的最短路径的距离，对于每一个节点k，我们检查Dis(i,k) + Dis(k,j) < Dis(i,j)是否成立，如果成立，证明从i到k再到j的路径比i直接到j的路径短，我们便设置Dis(i,j) = Dis(i,k) + Dis(k,j)，这样一来，当我们遍历完所有节点k，Dis(i,j)中记录的便是i到j的最短路径的距离。

 

SPFA

 

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
#define inf 0x3f3f3f3;
int map[1100][1100],dis[1100],used[1100],t,s,d,n,m;

int SPFA()
{
    for(int i=1;i<=n;i++)
        dis[i]=inf;
    queue<int> q;
    q.push(1);
    used[1]=1;
    dis[1]=0;
    while(!q.empty())
    {
        int now=q.front();
        q.pop();
        used[now]=0;
        for(int i=1;i<=n;i++)
        {
            if(dis[i]>dis[now]+map[now][i])
            {
                dis[i]=dis[now]+map[now][i];
                if(!used[i])
                {
                    q.push(i);
                    used[i]=1;
                }
            }

        }
    }
    int MIN=inf;
    MIN=min(MIN,dis[n]);
    return MIN;
}
int main()
{

    while(scanf("%d%d",&n,&m)&&n&&m)
    {

        for(int i=0;i<=n;i++)
        for(int j=0;j<=n;j++)
            map[i][j]=inf;
        int min=9999;
        int a,b,c;
        for(int i=1;i<=m;i++)
        {
            scanf("%d%d%d",&a,&b,&c);
            if(map[a][b]>c)
                map[a][b]=map[b][a]=c;
        }
        int k=SPFA();
        printf("%d\n",k);
    }
}

 SPFA算法，Shortest Path Faster Algorithm，是由西南交通大学段凡丁于1994年发表的。正如上述所说，Dijkstra 算法无法用于负权回路，很多时候，如果给定的图存在负权边，这时类似Dijkstra等算法便没有了用武之地，而Bellman-Ford算法的复杂度又 过高，SPFA算法便派上用场了。 
　　
    简洁起见，我们约定有向加权图G不存在负权回路，即最短路径一定存在。当然，我们可以在执行该算法前做一次拓扑排序，以判断是否存在负权回路。

    我们用数组d记录每个结点的最短路径估计值，而且用邻接表来存储图G。
    我们采取的方法是动态逼近法：设立一个先进先出的队列用来保存待优化的结点，优化时每次取出队首结点u，并且用u点当前的最短路径估计值对离开u点所指向的结点v进行松弛操作，如果v点的最短路径估计值有所调整，且v点不在当前的队列中，就将v点放入队尾。
    这样不断从队列中取出结点来进行松弛操作，直至队列空为止。

    定理: 只要最短路径存在，上述SPFA算法必定能求出最小值。