最短路径问题

通过搜索算法的学习，可以知道深度优先搜索是一种遍历图并且找到有关信息的有效手段，但是事实上，dfs在好写的同时，会耗费大量的时间，例如对一个100*100的图进行dfs，可能需要耗费2-3s的时间，这对于算法的设计来说，是无法容忍的，于是在这个基础上思考相关的问题，学习以下几种算法。

佛洛伊德算法

算法实现:

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int INF=0x3f3f3f3f;
const int N=100+5;
long long e[N][N],n,m;
int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j)
            {
                e[i][j]=e[j][i]=0;
            }
            else
            {
                e[i][j]=e[j][i]=INF;
            }
        }
    }
    for(int i=1;i<=m;i++)
    {
        long long  x,y,z;
        cin>>x>>y>>z;
        e[x][y]=e[y][x]=min(z,e[x][y]);
    }
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(e[i][j]>e[i][k]+e[k][j])
                {
                    e[i][j]=e[i][k]+e[k][j];
                }
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            cout<<e[i][j]<<" ";
        }
        cout<<"\n";
    }
    return 0;
}

普里姆算法

题目描述

Description
给定结点数为n，边数为m的带权无向连通图G，所有结点编号为1,2,3…n。
求图G的最小生成树的边权和。

输入格式
第一行两个正整数n和m。n,m<=2000
之后的m行，每行三个正整数a,b,w，描述一条连接结点a和b,边权为w的边。1=<a,b<=n,w<=10^18。
注意可能存在重边和自环。

输出格式
一个整数表示图G的最小生成树的边权和（注意用长整型）。

输入样例
7 12
1 2 9
1 5 2
1 6 3
2 3 5
2 6 7
3 4 6
3 7 3
4 5 6
4 7 2
5 6 3
5 7 6
6 7 1

输出样例
16
注意这道题说可能存在重边和自环，所以在建图的时候要特别注意这个问题。

AC代码

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;
typedef long long ll;
const int N=2e3+5;
const ll M=0x3f3f3f3f3f3f;
int n,m;
ll a[N][N],book[N],d[N];

int GetMin()//找最小权值的下标
{
    ll minv=M;int mini;
    for(int i=1;i<=n;i++)
    {
        if(d[i]<minv && book[i]==0)
        {
            minv=d[i];
            mini=i;
        }
    }
    return mini;
}

ll prim()
{
    ll sum=0;
    memset(d,127/3,sizeof(d));
    d[1]=0;
    for(int i=1;i<=n;i++)
    {
        int t=GetMin();
        book[t]=1;
        sum+=d[t];
        for(int j=1;j<=n;j++)/*刷新*/
        {
            if(book[j]==0 && a[t][j]<d[j])
            {
                d[j]=a[t][j];
            }
        }
    }
    return sum;
}

int main()
{
    ios::sync_with_stdio(false);
    memset(a,127/3,sizeof(a));
    cin>>n>>m;
    ll x,y,z;
    for(int i=1;i<=m;i++)
    {
        cin>>x>>y>>z;
        if(x==y)/*处理重边*/
        {
            continue;
        }
        a[x][y]=a[y][x]=min(z,a[x][y]);
    }
    cout<<prim()<<endl;
    return 0;
}

解法2:

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
const int M=2000+5;
const ll INF=0x3f3f3f3f3f3f3f;

ll e[M][M],dis[M],n,m;
int book[M];

int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j)
            {
                e[i][j]=0;
            }
            else
            {
                e[i][j]=e[j][i]=INF;
            }
        }
    }
    for(int i=1;i<=m;i++)
    {
        ll x,y,z;
        cin>>x>>y>>z;
        if(x==y)
        {
            continue;
        }
        e[x][y]=e[y][x]=min(z,e[x][y]);
    }
    for(int i=1;i<=n;i++)
    {
        dis[i]=e[1][i];/*表示1到各顶点的距离*/
    }
    memset(book,0,sizeof(book));
    dis[1]=0;book[1]=1;
    ll sum=0;
    ll Min=INF;
    int u,v;
    for(int i=1;i<=n-1;i++)
    {
        Min=INF;
        for(int j=1;j<=n;j++)
        {
            if(book[j]==0 && dis[j]<Min)
            {
                Min=dis[j];
                u=j;/*GetMin,算是一个剪枝的过程*/
            }
        }
        book[u]=1;/*就是说，已经用了这个点来计算了，这个点所计算出的路径已经是最小的了，不要去搞它*/
        sum+=dis[u];
        for(v=1;v<=n;v++)
        {
            if(book[v]==0 && e[u][v]< dis[v] )
            {
                dis[v]=e[u][v];
            }
        }
    }
    cout<<sum<<endl;
    return 0;
}

其实本题的关键就是从头遍历到尾，通过一个最小权值去刷新还没走完的最小权值，最终的结果都将会是最小权值。

最短路问题

题目描述

现在有n个车站和m条直达公交线路，每条线路都有一个固定票价。
作为一个窮人，你打算从车站1坐车到车站n，请计算下车站1到车站n的最少花费。
如果车站1无法到达车站n，请输出-1。
注意，在车站x和y之间可能存在不止一条线路。

输入格式
第一行两个整数n和m，表示车站数量和线路数量。(1<=n<=100),(1<=m<=1000)
第二行至第m+1行，每行3个整数a,b,x，代表车站a和车站b之间有一条票价为x的公交线路，公交线路是双向的。

输出格式
输出车站1到n的最小花费。

输入样例
4 4
1 2 4
2 3 7
2 4 1
3 4 6

输出样例
5

作者 30002692

采用的是迪杰斯特拉算法,具体解法思路见啊哈算法。
核心思想是通过边来松弛1号顶点到到其余各个顶点的路程。
算法的基本思想是：每次找到距离源点最近的一个顶点（这个点的路径是不确定的，就是还没有标记的），然后以该点为中心进行扩展，最终得到远点到其余所有点的最短路径，基本步骤如下：
①将所有顶点分为两部分，已知最短路径的顶点集合P和未知最短路径的顶点集合Q，已知最短路径的顶点集合P中只有源点一个顶点，这里用一个Book数组来记录哪些点在集合P中。例如对于某个顶点i，如果book[i]为1，则表示这个顶点在集合P中，假如为0，那么也就是说这个顶点在集合Q中。
②设置源点s到直接的最短路径为0，即dis[s]=0。若存在有源点能直接到达的顶点i，则把dis[i]设置为e [s].[i]。同时把所有其他（源点所不能直接到达的）顶点的最短路径设置为无穷大
③在集合Q中的所有顶点中选择一个离源点s最近的顶点u，即dis【u】是最小的加入到集合P，并考察所有以u为起点的边，对每一条边进行松弛操作，例如存在一条从u到v的边，那么可以通过将边u->v添加到尾部来扩展一条从s到v的路径，这条路径的长度就是dis[u]+e[u].[v],如果这个值比目前已经知道的dis[v]要小的话，可以用新值来代替dis[v]中的值。
④重复第三步，知道集合Q为空，没有点可以考察的时候，算法就结束了。
最终dis数组里面存储的就是源点到所有顶点的最短路径。

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
const int M=1000+5;
const ll INF=0x3f3f3f3f3f3f3f;

ll e[M][M],dis[M],n,m;
int book[M];

int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j)
            {
                e[i][j]=0;
            }
            else
            {
                e[i][j]=e[j][i]=INF;
            }
        }
    }
    for(int i=1;i<=m;i++)
    {
        ll x,y,z;
        cin>>x>>y>>z;
        e[x][y]=e[y][x]=min(z,e[x][y]);
    }
    for(int i=1;i<=n;i++)
    {
        dis[i]=e[1][i];/*表示1到各顶点的距离*/
    }
    memset(book,0,sizeof(book));
    dis[1]=0;book[1]=1;
    ll Min=INF;
    int u,v;
    for(int i=1;i<=n-1;i++)
    {
        Min=INF;
        for(int j=1;j<=n;j++)
        {
            if(book[j]==0 && dis[j]<Min)
            {
                Min=dis[j];
                u=j;/*GetMin,算是一个剪枝的过程*/
            }
        }
        book[u]=1;/*就是说，已经用了这个点来计算了，这个点所计算出的路径已经是最小的了，不要去搞它*/
        for(v=1;v<=n;v++)
        {
            if(e[u][v]<INF)/*如果从u点到v点是连通的,那么可以进行一波更新*/
            {
                if(dis[v]>dis[u]+e[u][v])
                {
                    dis[v]=dis[u]+e[u][v];
                }
            }
        }
    }
    ll ans=dis[n];
    if(ans>=INF)
    {
        cout<<-1<<endl;
    }
    else
    {
        cout<<ans<<endl;
    }
    return 0;
}

}