最短路相关

求一个图的最短路径。

一、多源最短路

1.Floyed-Wallsahll算法

借用动态规划的思想，是枚举中转点，其中核心语句的原型是mp[i][k][k-1]+mp[k][j][k-1]<=mp[i][j][k]，只不过因为最后的k,k-1没什么用，就压缩成了二维。

代码：

for(int k=1;k<=n;k++)//k循环一定要在外面 
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(mp[i][j]>mp[i][k]+mp[k][j])
                {
                    mp[i][j]=mp[i][k]+mp[k][j];//核心算法语句 
                }
            }
        }
    }

借助Floyed算法，加入path[][]数组，可以进行路径的保存，最终实现路径输出。代码如下：

#include<iostream>
#include<cstdio>
using namespace std;
const int maxn=1000; 
const int inf=0x3f3f3f3f;
int path[maxn][maxn];
int mp[maxn][maxn];
int n,m;
void Floyed()//Floyed算法核心语句 
{
    int i,j,k;
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=n;j++)
        {
            if(mp[i][j]<inf&&i!=j)
            path[i][j]=j;//记录能到达的路径 
            else
            path[i][j]=-1;
        }
    }
    for(k=1;k<=n;k++)
    {
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
            {
            if(mp[i][j]>mp[i][k]+mp[k][j])
            {
            mp[i][j]=mp[i][k]+mp[k][j];
            path[i][j]=path[i][k];//更新路径 
            }
        }
    }
}
}
void Output(int start,int end)//最短路输出 
{
    int next=start;
    printf("%d",start);
    while(next!=end)
    {
        printf("-->");
        printf("%d",path[next][end]);
        next=path[next][end];
    }
    cout<<endl;
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j)
            mp[i][j]=0;
            else
            mp[i][j]=inf;
        }
    }
    int a,b,c;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        mp[a][b]=c;
        mp[b][a]=c;
    }
    Floyed();
    int Qa,Qb;
    while(cin>>Qa>>Qb)
    {
    cout<<mp[Qa][Qb]<<endl;
    Output(Qa,Qb);
}
    return 0;
}

二、单源最短路

1.Dijkstra算法

借助贪心算法的思想。

主要用来计算一个节点到其他所有点的最短路径。以起点为中心点向外拓展。

该算法的要求：图中不存在负权边。

其中典型的操作松弛。首先用dis[]数组记录源点到其他所有点的距离并标记正无穷，然后从源点开始，比如dis[3]表示1到3的距离，此时比较dis[3]和dis[2]+mp[2][3]，即如果此时1到3的距离通过点2松弛如果更小，那么更新，其他依次操作，直到所有点都更新完成。

代码：

    int book[50],min,u,v,i,j;
    for(i=1;i<=n;i++)//把距离改为源点到所有可直接连通点的距离 
    {
        dis[i]=map[1][i];
    }
    for(i=1;i<=n;i++)//标记 
    {
        book[i]=0;
    }
    book[1]=1;//1已经遍历过 
    for(i=1;i<=n-1;i++)//进行n-1次操作 
    {//操作是寻找距离1号最近的顶点 
        min=din;
        for(j=1;j<=n;j++)//寻找可以更新的点 
        {
            if(book[j]==0&&dis[j]<min)
            {
                min=dis[j];
                u=j;
            }
        }
        book[u]=1;
        for(v=1;v<=n;v++)
        {
            if(map[u][v]<din)
            {
                if(dis[v]>dis[u]+map[u][v])
                {
                    dis[v]=dis[u]+map[u][v];
                }
            }
        }
    }

 2.Bellman_Ford算法

采用“松弛”的策略，从原点到每个点的方案作对比，逐步更新，更新n（顶点）-1次后，一定全部更新完毕，再次判断是否可更新，如果还可更新，则一定存在负权回路。

代码如下：

#include<iostream>
#include<cstdio>
using namespace std;
const int inf=0x3f3f3f3f;
const int maxn=1e5;
struct Edge
{
    int u,v,w;
};
Edge e[maxn];
int dis[maxn],pre[maxn];
int n,m,s;//n为点数，m为通路条数，s为源点 

bool Bellman_Ford()
{
    for(int i=1;i<=n;i++)//初始化源点到其他各个点的距离 
    {
        if(i==s)
        dis[i]=0;
        else
        dis[i]=inf;
    }
    for(int i=1;i<=n-1;i++)//核心代码，“松弛”操作 
    {
        for(int j=1;j<=m;j++)
        {
            if(dis[e[j].v]>dis[e[j].u]+e[j].w)
            {
            dis[e[j].v]=dis[e[j].u]+e[j].w;
            pre[e[j].v]=e[j].u;//前驱路线更新 
            }
        }
    }
    bool flag=true;//判断是否含有负权回路的标志 
    for(int i=1;i<=m;i++)
    {
        if(dis[e[i].v]>dis[e[i].u]+e[i].w)
        {
            flag=false;
            break;
        }
    }
    return flag;
}
void Output_path(int s)//路径输出的函数 
{
    while(s!=pre[s])
    {
        printf("%d",s);
        printf("-->");
        s=pre[s];
    }
    if(s==pre[s])
    cout<<s<<endl;
}
int main()
{
    cin>>n>>m;
    cin>>s;
    for(int i=1;i<=n;i++)
    {
        scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);
    }
    pre[s]=s;
    bool flag;
    flag=Bellman_Ford();
    if(flag)
    {
        for(int i=1;i<=n;i++)
        {
            printf("%d
",dis[i]);
            Output_path(i);
        }
    }
    else
    printf("图中含有负权回路。
");
    return 0;
}