最短路径问题

1.bellman-ford可以用于边权为负的图中，图里有负环也可以，如果有负环，算法会检测出负环。
时间复杂度O（VE）;
2.dijkstra只能用于边权都为正的图中。
时间复杂度O（n2）；
3.spfa是个bellman-ford的优化算法，本质是bellman-ford，所以适用性和bellman-ford一样。（用队列和邻接表优化）。
时间复杂度O（KE）;
4**.floyd可以用于有负权的图中**，即使有负环，算法也可以检测出来,可以求任意点的最短路径，有向图和无向图的最小环和最大环。
时间复杂度O（n3）；

dijkstra算法：Dijkstra算法采用的是一种贪心的策略，声明一个数组dis来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点的集合。初始时，原点 s 的路径权重被赋为 0 （dis[s] = 0）。若对于顶点 s 存在能直接到达的边（s,m），则把dis[m]设为w（s, m）,同时把所有其他（s不能直接到达的）顶点的路径长度设为无穷大。初始时，集合T只有顶点s。
然后，从dis数组选择最小值，则该值就是源点s到该值对应的顶点的最短路径，并且把该点加入到T中，此时完成一个顶点，然后，我们需要看看新加入的顶点是否可以到达其他顶点并且看看通过该顶点到达其他点的路径长度是否比源点直接到达短，如果是，那么就替换这些顶点在dis中的值。然后，又从dis中找出最小值，重复上述动作，直到T中包含了图的所有顶点。
代码：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int inf=0x3f3f3f3f;//设一个很小的值
#define maxn 106

int map[maxn][maxn];
int dis[maxn];//源点到各个顶点的最小距离
int vis[maxn];//已经找到的符合条件的点的集合
int n,m;
void dijkstra()
{
    int i,j;
    for(i=1;i<=n;i++)
    {
        dis[i]=map[1][i];//把从源点到某个点的距离赋值给最短距离集合
    }
    dis[1]=0;
    vis[1]=1;//把源点赋给vis集合
    for(i=0;i<n;i++)
    {
        int flag;
        int minn=inf;
        for(j=1;j<=n;j++)
        {
            if(vis[j]==0&&dis[j]<minn)//寻找下一个最小值点
            {
                minn=dis[j];
                flag=j;
            }
        }
        vis[flag]=1;//将这个点加入集合
        for(j=1;j<=n;j++)
        {
            if(vis[j]==0&&dis[j]>dis[flag]+map[flag][j])
            {
                dis[j]=dis[flag]+map[flag][j];
                //间接到达的距离大于直接到达
            }
        }

    }

    printf("%d\n",dis[n]);
}

int main()
{
    int i;
    while(scanf("%d%d",&n,&m)!=EOF&&n!=0&&m!=0)
    {
        memset(map,inf,sizeof(map));
        memset(vis,0,sizeof(vis));
        for(i=0;i<m;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            if(map[u][v]>w)
            {
              map[u][v]=map[v][u]=w;
            }
        }
        dijkstra();
    }
    return 0;
}

Floyd算法：求有向图的最小环或者最大环（顶点数>=2），求无向图的最小环（顶点数>=3）

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN = 0x3f3f3f3f;
const int p = 1005;
int dist[p][p];
int path[p][p];
int mp[p][p];
int n,m;
int Floyd()
{
    int i,j,k;
    for(i = 0;i < n;++i)
    {
        for(j = 0;j < n;++j)
        {
            dist[i][i]=0;//初始化
            mp[i][i]=0;
        }
    }
    int ans = MAXN;
    for(k = 0;k < n;++k)//顺序k\i\j;
    {
    for(i = 0;i < n;++i)
    {
        for(j = 0;j < n;++j)
        {
            if(dist[i][k] + dist[k][j] < dist[i][j])
            {
                dist[i][j] = dist[i][k] + dist[k][j];
                path[i][j] = k;
            }
        }
    }
    }
    return ans;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        int i,j;
        memset(path,-1,sizeof(path));
        memset(dist,MAXN,sizeof(dist));
        memset(mp,MAXN,sizeof(mp));
        scanf("%d %d",&n,&m);
        for(int i = 0;i < m;++i)
        {
            int x,y,d;
            scanf("%d %d %d",&x,&y,&d);
            dist[x][y]=dist[y][x]=d;
            mp[x][y]=mp[y][x]=d;
        }
        printf("%d\n",Floyd());
        for(i = 0;i < n;++i)
        {
            for(j = 0;j < n;++j)
            {
                printf("%d ",dist[i][j]);
            }
            cout<<endl;
        }
        for(i = 0;i < n;++i)
        {
            for(j = 0;j < n;++j)
            {
                printf("%d ",path[i][j]);
            }
            cout<<endl;
        }
    }
    return 0;
}

Bellman-Ford： 适用范围：1、单源最短路径（从源点到其他所有点v）；2、有向图&无向图；
3、边权可正可负；4、差分约束系统 。
实现过程的三步：
1、初始化所有的点，每一个点保存一个值，表示源点到这个点的距离其他点的值设为无穷大。
2、进行循环，从1到n-1，进行松弛计算。
3、遍历所有边，如果的d[v]大于d[u]+w(u,v)存在，则有从源点可达的权为负的回路。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN = 0x3f3f3f3f;
const int p = 100005;
struct Graph{
   int u,v,cost;
};
//有向图
Graph edge[p];//边表
int pre[p];
int dis[p];
int n,m,v;//点数，边数，源点
bool BellmanFloyd()
{
    int i,j;
    for(i = 1;i <= n;++i)//最多进行n-1次更新
    {
        for(j = 0;j < m;++j)//每次遍历一下边表，至少找出一个点的最短路径
        {
            if(dis[edge[j].v]>dis[edge[j].u]+edge[j].cost)
            {
                dis[edge[j].v]=dis[edge[j].u]+edge[j].cost;
            }
        }
    }
    bool flag = true;
    for(i = 0;i < m;++i)//判断负环
    {
        if(dis[edge[i].v]>dis[edge[i].u]+edge[i].cost)
        {
            flag = false;
            break;
        }
    }
    return flag;
}
int main()
{
    while(~scanf("%d %d",&n,&m))
    {
        int i,j;
        memset(dis,MAXN,sizeof(dis));
        memset(pre,-1,sizeof(pre));
        for(i = 0;i < m;++i)
        {
            scanf("%d %d %d",&edge[i].u,&edge[i].v,&edge[i].cost);
        }
        dis[1] = 0;
        pre[1] = 1;
        BellmanFloyd();
            for(i = 1;i <= n;++i)
            {
                printf("%d ",dis[i]);
            }
            printf("\n");
    }
    return 0;
}

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

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int inf = 0x3f3f3f3f;
const int MAXN = 20005;
const int MINX = 1005;
int u[MAXN];
int v[MAXN];
int w[MAXN];
int first[MINX];
int ne[MAXN];
int d[MINX];
bool vis[MINX];
int p[MINX];
queue<int>que;
void spfa_bfs()
{
    int i,j;
    while(!que.empty())
    {
        int k = que.front();
        que.pop();
        vis[k] = 0;
        for(int x = first[k];x != -1;x = ne[x])
        {
            int y = v[x];
            if(d[y] > d[k] + w[x])
            {
                d[y] = d[k] + w[x];
                p[y] = x;
                if(!vis[y]){
                    vis[y] = 1;
                    que.push(y);
                }
            }
        }
    }
}
int main()
{
    int n,m,s,t;
    while(~scanf("%d %d %d",&n,&m,&s))
    {
        int x,y,z;
        int i,j;
        memset(ne,-1,sizeof(ne));
        memset(first,-1,sizeof(first));
        memset(vis,0,sizeof(vis));
        memset(d,inf,sizeof(d));
        memset(p,-1,sizeof(p));
        d[s] = 0;
        vis[s] = 1;
        p[s] = s;
        que.push(s);
        for(i = 1;i <= m;++i)
        {
            scanf("%d %d %d",&x,&y,&z);
            u[i] = y;
            v[i] = x;
            w[i] = z;
            if(first[y] == -1){
                first[y] = i;
            }
            else
            {
                ne[i] = first[y];
                first[y] = i;
            }
        }
        spfa_bfs();
    scanf("%d",&t);
        int ptr;
        int mx = inf;
        for(j = 0;j < t;++j)
        {
            scanf("%d",&ptr);
            mx = (mx > d[ptr])?d[ptr]:mx;
        }
        if(mx == inf)
            printf("-1\n");
        else
            printf("%d\n",mx);
    }
    return 0;
}