Dijstra算法

最新推荐文章于 2024-09-29 14:13:39 发布

饕餮梼杌之徒

最新推荐文章于 2024-09-29 14:13:39 发布

阅读量664

点赞数

分类专栏：图论文章标签： dijstra算法

本文链接：https://blog.csdn.net/qq_43646600/article/details/88085788

版权

图论专栏收录该内容

2 篇文章 0 订阅

订阅专栏

本文深入解析Dijkstra算法的工作原理及其在解决特定问题中的应用。通过实例详细介绍了如何使用Dijkstra算法找到两点间的最短路径，并在此过程中最大化资源收集。文章提供了完整的代码实现和解释，适合对算法有兴趣的学习者。

摘要由CSDN通过智能技术生成

Dijstra算法的板子
例题：
L2-001 紧急救援（25 分）
作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。

输入格式：

输入第一行给出4个正整数N、M、S、D，其中N（2<=N<=500）是城市的个数，顺便假设城市的编号为0~(N-1)；M是快速道路的条数；S是出发地的城市编号；D是目的地的城市编号。第二行给出N个正整数，其中第i个数是第i个城市的救援队的数目，数字间以空格分隔。随后的M行中，每行给出一条快速道路的信息，分别是：城市1、城市2、快速道路的长度，中间用空格分开，数字均为整数且不超过500。输入保证救援可行且最优解唯一。

输出格式：

第一行输出不同的最短路径的条数和能够召集的最多的救援队数量。第二行输出从S到D的路径中经过的城市编号。数字间以空格分隔，输出首尾不能有多余空格。

输入样例：

4 5 0 3
20 30 40 10
0 1 1
1 3 2
0 3 3
0 2 2
2 3 2
输出样例：

2 60
0 1 3
函数接口
1.G[][]用来存储两点之间的权值，城市1、城市2、快速道路的长度
eg:0 1 1 G[0][1]=1;
2.num[]用来存储最优路径，最后输出num[ed] ed:是目的地的城市编号
3.void Dijstra(int s) s:S是出发地的城市编号
4.w[]用来存储权值最高的结果，最后输入w[ed]
5.weight[]用来存第i个城市的救援队的数目
6.visit[]该城市是否被访问

const int maxv = 510;
const int inf = 0x3fffffff;
int n,m,st,ed,G[maxv][maxv],weight[maxv];
int d[maxv],w[maxv],num[maxv],pre[510];
bool vis[maxv]={false}；

void printpath(int v){
    if(v==st){
        printf("%d",v);
        return;
    }
    printpath(pre[v]);
    printf(" %d",v);
}

void Dijstra(int s){
    fill(d,d+maxv,inf);
    memset(num,0,sizeof(num));
    memset(w,0,sizeof(w));
    d[s]=0;
    w[s]=weight[s];
    num[s]=1;
    for(int i=0;i<n;i++){
        int u=-1,minm=inf;
        for(int j=0;j<n;j++){
            if(vis[j]==false&&d[j]<minm){
                u=j;
                minm=d[j];
            }
        }
        if(u==-1){
            return ;
        }
        vis[u]=true;
        for(int v=0;v<n;v++){
            if(vis[v]==false&&G[u][v]!=inf){
                if(d[u]+G[u][v]<d[v]){
                    d[v]=d[u]+G[u][v];
                    w[v]=w[u]+weight[v];
                    num[v]=num[u];
                    pre[v]=u;
                }else if(d[u]+G[u][v]==d[v]){
                if(w[u]+weight[v]>w[v]){
                    w[v]=w[u]+weight[v];
                    pre[v]=u;
                }
                num[v]+=num[u];
                }
            }
        }
    }
}

此处对full,memset的解释是转载
原文：https://blog.csdn.net/xs18952904/article/details/75195412
fill()函数
说明
在头文件里。
按照数组的始末位置以一个数组元素为单位赋值，将区间内的每一个元素都赋值为val。
用法
fill(vector.begin(), vector.end(), val);
实例

#include <algorithm>
using namespace std;
int main() {
    int n[10];
    fill(n, n + 10, 2);//2 2 2 2 2 2 2 2 2 2 
    return 0
}

memset()函数
说明
在头文件里。

将已开辟的内存空间arr的前cnt个字节的值设为值val。

理论上，因为memset()是按照字节去赋值的，所以int数组只能被赋值为0（在二进制层面全为0）或者是-1（在二进制层面全为1）。

理论上只能初始化为0和-1，但是！

偶然发现memset()函数还能将int型数组初始化为INF(0x3f3f3f3f)，不是太懂是为什么，以后再想原因吧。

用法
memset(arr, val, cnt);

#include <cstring>
// 宏定义
#define memset(a,b) memset(a,b,sizeof(a))
using namespace std;
int main(){
    int a[20];
    memset(a,0); // 初始化为0
    memset(a,-1); // 初始化为-1
    cosnt int INF = 0x3f3f3f3f; // 定义INF常量
    memset(a,INF); // 初始化为INF
    return 0;
}

fill()_n函数
说明
在头文件里。

从当前起始点开始，将之后的cnt个元素赋值为val。

注意：不能在没有元素的空容器上调用fill_n()函数

用法
fill(vector.begin(), cnt, val);

#include <algorithm>
#include <vector>
using namespace std;
int main () {
  vector<int> myvector (4,10); // myvector: 10 10 10 10
  fill_n (myvector.begin(),2,20); // myvector: 20 20 10 10
  return 0;
}

INF的解释
0x3f3f3f3f的十进制是1061109567，是10^{9级别的（和0x7fffffff一个数量级），而一般场合下的数据都是小于10}9的，所以它可以作为无穷大使用而不致出现数据大于无穷大的情形。另一方面，由于一般的数据都不会大于10^9，所以当我们把无穷大加上一个数据时，它并不会溢出（这就满足了“无穷大加一个有穷的数依然是无穷大”），事实上0x3f3f3f3f+0x3f3f3f3f=2122219134，这非常大但却没有超过32-bit int的表示范围，所以0x3f3f3f3f还满足了我们“无穷大加无穷大还是无穷大”的需求。
所以要把一段内存全部置为无穷大，我们只需要memset(a,0x3f,sizeof(a))。
INF=0x3f3f3f3f
例题完整解析

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxv = 510;
const int inf = 0x3fffffff;
int n,m,st,ed,G[maxv][maxv],weight[maxv];
int d[maxv],w[maxv],num[maxv],pre[510];
bool vis[maxv]={false};
void printpath(int v){
    if(v==st){
        printf("%d",v);
        return;
    }
    printpath(pre[v]);
    printf(" %d",v);
}
void Dijstra(int s){
    fill(d,d+maxv,inf);
    memset(num,0,sizeof(num));
    memset(w,0,sizeof(w));
    d[s]=0;
    w[s]=weight[s];
    num[s]=1;
    for(int i=0;i<n;i++){
        int u=-1,minm=inf;
        for(int j=0;j<n;j++){
            if(vis[j]==false&&d[j]<minm){
                u=j;
                minm=d[j];
            }
        }
        if(u==-1){
            return ;
        }
        vis[u]=true;
        for(int v=0;v<n;v++){
            if(vis[v]==false&&G[u][v]!=inf){
                if(d[u]+G[u][v]<d[v]){
                    d[v]=d[u]+G[u][v];
                    w[v]=w[u]+weight[v];
                    num[v]=num[u];
                    pre[v]=u;
                }else if(d[u]+G[u][v]==d[v]){
                if(w[u]+weight[v]>w[v]){
                    w[v]=w[u]+weight[v];
                    pre[v]=u;
                }
                num[v]+=num[u];
                }
            }
        }
    }
}
int main()
{
    scanf("%d%d%d%d",&n,&m,&st,&ed);
    for(int i=0;i<n;i++){
        scanf("%d",&weight[i]);
    }
    int u,v;
    fill(G[0],G[0]+maxv*maxv,inf);
    for(int i=0;i<m;i++){
        scanf("%d%d",&u,&v);
        scanf("%d",&G[u][v]);
        G[v][u]=G[u][v];
    }
    Dijstra(st);
    printf("%d %d\n",num[ed],w[ed]);
    printpath(ed);
    return 0;
}