（Dijkstra算法、Floyd算法、SPFA）hdu 1874 畅通工程续

传送门：hdu 1874 畅通工程续

Dijkstra算法（单源最短路算法）

Dijkstra算法的主要思想是通过“边”来松弛源点到其余各个点的路程。

权值必须为非负值，理由如下：
        该算法是一种基于贪心策略的算法。每次新扩展一个路程最短的点，更新与其相邻的点的路程。当所有边权都为正时，由于不会存在一个路程更短的没扩展过的点，所以这个点的路程永远不会再被改变，因而保证了算法的正确性。不过根据这个原理，用本算法求最短路径的图是不能有负权边的，因为扩展到负权边的时候会产生更短的路程，有可能就破坏了已经更新的点路程不会改变的性质。Bellman-Ford解决负权边。

单源最短路径，邻接矩阵形式，复杂度为O（N^2）

和最小生成树的Pime算法差不多，迪杰斯特拉更新的是未加入集合的点经或不经过集合中的点到源点的最短距离，而Prim更新的未加入最小生成树的点到最小生成树的最短距离

#include<iostream>  
using namespace std;  
#define INF 10010  
#define maxn 210  
  
int n,m;  
int maps[maxn][maxn];  
bool visited[maxn];  
int dist[maxn];     //dist[i]表示顶点i到源点的最短路径
  
int dijkstra(int s,int t)  
{  
    for(int i=0;i<n;i++){  
        dist[i]=maps[s][i];  
        visited[i]=false;  
    }  
    dist[s]=0;  
    visited[s]=true;  
  
     int temp,k;  
    for(int i = 0;i < n;i++)  
    {  
        temp = INF;  
        for(int j = 0;j < n;j++)  //找出最小值  
        {  
            if(!visited[j]&& temp > dist[j])  
            {  
                k = j;  
                temp = dist[j];  
            }  
        }  
        if(temp == INF|| k==t)  //找完了  
            break;  
        visited[k] = 1;  
        for(int j = 0;j < n;j++)  
            dist[j]=min(dist[j],dist[k] + maps[k][j]);  
    }  
    if(dist[t] == INF)  
        return -1;  
    else  
        return dist[t];  
  
  
}  
  
int main()  
{  
    while(cin>>n>>m){  
        for(int i=0;i<n;i++){  
            for(int j=0;j<n;j++){  
                maps[i][j]=(i==j?0:INF);  
            }  
        }  
        int a,b,x,ans;  
        while(m--)  
        {  
            cin>>a>>b>>x;  
            if(x<maps[a][b])  
                maps[a][b]=maps[b][a]=x;  
        }  
        int s,t;  
        cin>>s>>t;  
        ans=dijkstra(s,t);  
        cout<<ans<<endl;  
    }  
    return 0;  
}  

Floyd算法（多源最短路算法）

Floyd算法用来找到每对点之间的最短距离，可以是有向图，也可以是无向图，边权可正可负，唯一要求是不能有负环。

Floyd算法的核心是松弛操作，松弛操作的原理就是著名的定理：“三角形两边之和大于第三边”，在信息学中我们叫它三角不等式。所谓对i,j进行松弛，就是判断是否d[j]>d[i]+w[i,j]，如果该式成立，则将d[j]减小到d[i]+w[i,j]，否则不动。

#include<bits/stdc++.h>
using namespace std;

const int maxn =205;
#define INF 1e9
int n,m;
int x,y,z;
int mp[maxn][maxn];

//floyd算法（动态规划思想，可处理负权）
void floyd()
{
    for(int k=0;k<n;k++) //枚举中间点
        for(int i=0;i<n;i++) //枚举起点
            for(int j=0;j<n;j++) //枚举终点
                mp[i][j]=min(mp[i][j],mp[i][k]+mp[k][j]); //松弛操作，经过k+1个点的i到j的最短路径
}

//数据输入处理
void init()
{
    for(int i=0;i<n;i++)
        for(int j=0;j<n;j++)
            mp[i][j]=(i==j?0:INF);

    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&z);
        mp[x][y]=mp[y][x]=min(z,mp[y][x]);
    }
}

int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init();
        int s,t;
        scanf("%d%d",&s,&t);
        floyd();
        if(mp[s][t]==INF) cout<<"-1"<<endl;
            else cout<<mp[s][t]<<endl;
    }
    return 0;
}

SPFA

spfa算法详解

#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
using namespace std;
const int maxn=205;
vector<pair<int,int> >E[maxn];

int n,m;
int d[maxn],inq[maxn];
void init(){
    for(int i=0;i<maxn;i++) E[i].clear();
    for(int i=0;i<maxn;i++) inq[i]=0;
    for(int i=0;i<maxn;i++) d[i]=1e9;
}

int main(){
    while(~scanf("%d%d",&n,&m)){
        init();
        for(int i=0;i<m;i++){
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            E[x].push_back(make_pair(y,z));
            E[y].push_back(make_pair(x,z));
        }
        int s,t;
        scanf("%d%d",&s,&t);

        queue<int> Q;
        Q.push(s);
        d[s]=0;
        inq[s]=1;
        while(!Q.empty()){
            int now=Q.front();
            Q.pop();
            inq[now]=0;
            for(int i=0;i<E[now].size();i++){
                int v=E[now][i].first;
                if(d[v]>d[now]+E[now][i].second){
                    d[v]=d[now]+E[now][i].second;
                    if(inq[v]==1) continue;
                    inq[v]=1;
                    Q.push(v);
                }
            }
        }
        if(d[t]==1e9) printf("-1\n");
        else printf("%d\n",d[t]);
    }


    return 0;
}

参考：《啊哈算法》