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 0xffffint 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算法必定能求出最小值。