POJ2387---Til the Cows Come Home （最短路模板）

题目来源：https://vjudge.net/problem/POJ-2387
【题意】
从点n到点1需要的最短路径。
单源最短路径问题。
【思路】
用已知的边去更新未知的边，不断进行松弛操作，直到不能再松弛。
那什么是松弛操作呢？
假设一题为单源路径问题，那么假设点1为起点，且用d数组来存下点1与其他点的的直接距离，然后依次更新，用w[][]二维数组表示点与点之间的关系。例如：d[2]=20,w[2][3]=10,且d[3]=40。这里表示的意思便是从点1到点2的距离是20，从点1到点3的距离是40，但是呢，2到3的距离是10，那么从1到3，我应该选择哪一个路径？所以会比较：
d[3]>d[2]+w[2][3]]，若成立，便是更新最短路径。对了，以上便是松弛操作。和最小生成树里的prim算法有着异曲同工之妙。
【代码1】

//利用邻接矩阵的普通djs
//时间复杂度较高
//32ms
#include<cstdio>
#include<cstring>
#include<iostream>
#include<string>
#include<algorithm>
#include<cmath>
using namespace std;
const int INF=1e9;
int n,m;
int w[1004][1004];
int d[1005];
bool vis[1004];
void init()
{
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=n; j++)
        {
            w[i][j]=i==j?0:INF;
        }
    }
    memset(vis,0,sizeof(vis));
}
void djs()
{
    d[n]=0;
    for(int i=1; i<=n-1; i++)
    {
        d[i]=w[n][i];
    }//d数组进行初始化
    for(int i=n; i>=1; i--)//每一个点都要遍历一遍
    {
        int m=INF,x=-1;
        for(int j=n-1; j>=1; j--)//选定一个离1最近的且尚未标记的点
        {
            if(!vis[j]&&d[j]<m)
            {
                m=d[x=j];
            }
        }
        if(x!=-1)
        {
            vis[x]=1;//标记
            for(int j=n; j>=1; j--)//利用选定的点（就是思路里的点2）进行松弛操作
            {
                if(!vis[j]&&d[j]>d[x]+w[x][j])
                {
//                    printf("d[%d]=%d d[%d]+d[%d][%d]=%d\n",j,d[j],x,x,j,d[x]+w[x][j]);
                    d[j]=d[x]+w[x][j];
//                    printf("***********\n");
                }
            }
        }
    }
//    for(int i=1; i<=n; i++)
//        printf("%d ",d[i]);
//    printf("\n");
    printf("%d\n",d[1]);
}
int main()
{
    while(~scanf("%d%d",&m,&n))
    {
        init();
        while(m--)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            if(w[x][y]>z) w[x][y]=w[y][x]=z;
        }
        djs();
    }
}

【代码2】

//普通的spfa算法
//47ms
//利用STF+LLL进行优化，由于spfa算法不稳定，
//故一般使用迪杰斯特拉算法。
/*（SPFA算法有两个优化策略SLF和LLL——SLF：Small Label First 策略，设要加入的节点是j，队首元素为i，若dist(j)<dist(i)，则将j插入队首，否则插入队尾； LLL：Large Label Last 策略，设队首元素为i，队列中所有dist值的平均值为x，若dist(i)>x则将i插入到队尾，查找下一元素，直到找到某一i使得dist(i)<=x，则将i出队进行松弛操作。 SLF 可使速度提高 15 ~ 20%；SLF + LLL 可提高约 50%。）*/
#include<cstdio>
#include<cstring>
#include<iostream>
#include<string>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
const int INF=0x3f3f3f3f;
int n,m;
int w[1004][1004];
int d[1005];
bool vis[1004];
void init()
{
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=n; j++)
        {
            w[i][j]=i==j?0:INF;
        }
    }
    memset(vis,0,sizeof(vis));
}
void spfa()
{
    memset(d,INF,sizeof(d));
    d[1]=0;
    deque<int> que;//实现队首队尾的插入需要用到双向队列deque
    que.push_back(1);
    vis[1]=1;
    while(!que.empty())//源点入队
    {
        int x=que.front();
        que.pop_front();
        vis[x]=0;
        for(int i=1;i<=n;i++)
        {
            if(d[i]>d[x]+w[x][i])
            {
                d[i]=d[x]+w[x][i];
                if(!vis[i]&&!que.empty()&&d[i]<d[que.front()])//STF
                    que.push_front(i);
                else que.push_back(i);

                vis[i]=1;
            }
        }
    }
    printf("%d\n",d[n]);
}
int main()
{
    while(~scanf("%d%d",&m,&n))
    {
        init();
        while(m--)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            if(w[x][y]>z) w[x][y]=w[y][x]=z;
        }
        spfa();
    }
}

【代码3】

//不含任何优化的spfa
//63ms
#include<cstdio>
#include<cstring>
#include<iostream>
#include<string>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
const int INF=0x3f3f3f3f;
int n,m;
int w[1004][1004];
int d[1005];
bool vis[1004];
void init()
{
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=n; j++)
        {
            w[i][j]=i==j?0:INF;
        }
    }
    memset(vis,0,sizeof(vis));
}
void spfa()
{
    memset(d,INF,sizeof(d));
    d[1]=0;
   queue<int> que;
    que.push(1);
    vis[1]=1;
    while(!que.empty())
    {
        int x=que.front();
        que.pop();
        vis[x]=0;
        for(int i=1;i<=n;i++)
        {
            if(d[i]>d[x]+w[x][i])
            {
                d[i]=d[x]+w[x][i];
                que.push(i);
                vis[i]=1;
            }
        }
    }
    printf("%d\n",d[n]);
}
int main()
{
    while(~scanf("%d%d",&m,&n))
    {
        init();
        while(m--)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            if(w[x][y]>z) w[x][y]=w[y][x]=z;
        }
        spfa();
    }
}

【代码4】

//利用优先队列的spfa算法
//[优先队列详解](http://www.cnblogs.com/heqinghui/archive/2013/07/30/3225407.html)
//47ms
#include<cstdio>
#include<cstring>
#include<iostream>
#include<string>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
const int INF=0x3f3f3f3f;
int n,m;
int w[1004][1004];
int d[1005];
bool vis[1004];
struct cmp//定义一个用于比较的结构体
{
    bool operator ()(int &a,int &b)
    {
        return a>b;
    }
};
void init()
{
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=n; j++)
        {
            w[i][j]=i==j?0:INF;
        }
    }
    memset(vis,0,sizeof(vis));
}

void spfa()
{
    memset(d,INF,sizeof(d));
    d[1]=0;
//    priority_queue<int,vector<int>,greater<int> >que;
priority_queue<int,vector<int>,cmp>que;//创建一个优先队列
    que.push(1);
    vis[1]=1;
    while(!que.empty())
    {
        int x=que.top();
        que.pop();
        vis[x]=0;
        for(int i=1; i<=n; i++)
        {
            if(d[i]>d[x]+w[x][i])
            {
                d[i]=d[x]+w[x][i];
                que.push(i);
                vis[i]=1;
            }
        }
    }
    printf("%d\n",d[n]);
}
int main()
{
    while(~scanf("%d%d",&m,&n))
    {
        init();
        while(m--)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            if(w[x][y]>z) w[x][y]=w[y][x]=z;
        }
        spfa();
    }
}