单源最短路径问题-迪杰斯特拉算法(Dijsktra)

一、问题描述:

给定一个带权有向图 G=(V,E) ,其中每条边的权是一个非负实数。再给定 V 中的一个顶点,称为源,计算源到所有顶点的最短距离。

实例:单源最短路径(弱化版)https://www.luogu.org/problemnew/show/P3371

二、 求取过程:

1. 从起点开始,查找所有与起点直接相连的点,并把连接它们的边权值作为起点到它们的距离(有平行边取最小值)。起点到起点的距离为0,其它不与起点直接相连的点距离为无穷大,存入上图所示的表中。

2. 遍历所有点,查找得到的结果中距离最小的那个点,然后再看所有与该点直接相连的点,计算该点到它们的最短距离(即从起点开始,经由该点到达的点的距离),根据结果更新上图。

3. 不断重复2中过程,直到每一个点都像2中那样计算过一遍。

觉得抽象的话可以看视频:https://www.bilibili.com/video/av2156069

三、合理性:

假设A到C经过B,如果最短路径经过B,那么此时A到B的路径必定最短。

单源最短路径问题-迪杰斯特拉算法(Dijsktra)_第1张图片

对于第一次操作,我们已经确定了从起点直接到所有点的最短距离。

此时取距离的最小值,有两种情况,一种是最小值来自跳过中间点的直接路径,那么我们可知从起点到该点的最短距离一定来自该路径,因为所有中间点的距离已经比其大,标记该点,已经使用过,接下来该点连接的点也可以根据该点的距离来处理了,因为此时A到B的距离已经最短,且中间点也不会对再对该点产生影响。另一种是最小值来自某一中间路径,那么经过该点的操作,完全有可能使第一次操作得到的距离改变,这就是取最小值的意义。若在未确定某一点最短距离的情况下对该点进行处理,由于该点已经标记使用,那么后续即使该点最短距离改变了,也无法改变该点已经确定的点的情况了。

如图所示的情况,第一次操作后我们知道直接与1相连的点有2, 3, 4。

如果此时不取最小值,例如对4进行处理,那么5的距离直接被确定为10000,此时4被标记使用,后续我们即使通过2,3改变了4的最短距离,5的距离也无法进行改变了。

 四、算法实现:

1. 单源最短路径(弱化版)https://www.luogu.org/problemnew/show/P3371

首先要知道怎么建图:

#include

using namespace std;

const int N=1e6+5;
const int MAX=2147483647;

struct node{        //建图(链式向前星,二维矩阵会炸),储存边
    int from;
    int to;
    int value;
    int next;
}edge[200005];
int head[N];        

int dis[N];        //记录每一个顶点的距离
int visited[N];    //记录是否访问过某一个顶点

int main()
{
    int n,m,s;
    int cnt=0;
    scanf("%d%d%d",&n,&m,&s);

    for(int i=1;i<=n;i++) dis[i]=MAX;    //距离初始化为无穷大

    memset(head,0,sizeof(head));         //这两行其实可以不要
    memset(visited,0,sizeof(visited));

    for(int i=1;i<=m;i++)    //建图,储存边
    {
        cnt++;
        scanf("%d%d%d",&edge[cnt].from,&edge[cnt].to,&edge[cnt].value);
        int from=edge[cnt].from;
        int to=edge[cnt].to;
        edge[cnt].next=head[from];
        head[from]=cnt;
    }

    int start=s;            //以s为起点
    dis[start]=0;           //起点到自己的距离为0


    while(visited[start]!=1)    //开始模拟查找过程
    {
        visited[start]=1;    //标记该起点,表示已访问过

        for(int i=head[start];i!=0;i=edge[i].next)    //读取与起点相连的边
        {
            if(dis[edge[i].to]>dis[start]+edge[i].value)    //算法的核心
                dis[edge[i].to]=dis[start]+edge[i].value;
        }

        int minn=MAX;            //每一次都寻找所有点中距离最小的点
        for(int i=1;i<=n;i++)
        {
            if(visited[i]!=1 && minn>dis[i])
            {
                minn=dis[i];
                start=i;        //以距离最小的点为新的起点,开始查找
            }
        }

    }
    for(int i=1;i<=n;i++)
    {
        if(i==n) printf("%d\n",dis[i]);
        else printf("%d ",dis[i]);
    }
}

2. 单源最短路径(标准版):https://www.luogu.org/problemnew/show/P4779

这题数据要比上一题大,所以要进行优化。

上一题的写法每一次都要查找距离最短的点,占用了大量时间,我们用优先队列优化这个过程。

有关优先队列可参考:https://blog.csdn.net/qq_19656301/article/details/82490601

#include 

using namespace std;

const int N=1e5+5;
const int MAX=2147483647;
typedef long long LL;

struct node{        //建图部分还是一样的
    int from;
    int to;
    int value;
    int next;
}edge[2*N];
int head[N];

LL dis[N];
int visited[N];

priority_queue,vector >,greater > >vis;    //优先队列

int main()
{
    int n,m,s;
    int cnt=0;
    cin>>n>>m>>s;
    for(int i=1;i<=n;i++) dis[i]=MAX;
    for(int i=1;i<=m;i++)
    {
        cnt++;
        scanf("%d%d%d",&edge[cnt].from,&edge[cnt].to,&edge[cnt].value);
        edge[cnt].next=head[edge[cnt].from];
        head[edge[cnt].from]=cnt;
    }


    dis[s]=0;
    vis.push(make_pair(0,s));    //储存某点距离和该点
                                 //make_pair是c++自带的二元组定义方式,可以通过first、second访问第一个,第二个元素(小根堆以第一个值排序)

    while(!vis.empty())        //判断所有点是否都查找过一遍
    {
        int start=vis.top().second;    //优先队列队首即最小的元素
        vis.pop();

        if(visited[start]==1) continue;    //如果该点查找过,跳过
        visited[start]=1;

        for(int i=head[start];i!=0;i=edge[i].next)
        {
            if(dis[edge[i].to]>dis[start]+edge[i].value)
            {
                dis[edge[i].to]=dis[start]+edge[i].value;
                vis.push(make_pair(dis[edge[i].to],edge[i].to));     
            }
        }
    }
    for(int i=1;i<=n;i++)
    {
        if(i==n) printf("%d\n",dis[i]);
        else printf("%d ",dis[i]);
    }
}

 

你可能感兴趣的:(算法)