L2-001 紧急救援 （25分题！）附上Dijkstra模板

原题链接

直接上ac代码，讲的可能有点乱，本蒟蒻水平有限轻点骂

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int N=510;
int g[N][N];//用邻接矩阵存图
int saveTeam[N],initialTeam[N];//saveTeam存到当前城市所能拉到的最多救援人数
//initialTeam存一开始输入的每个城市的救援队人数
int dist[N];//存当前节点城市到城市0的最短距离
int number[N];//存到当前节点的最短路径数量
bool vis[N];//当前点的最短距离有无确定
int n,m,s,e;
int f[N];//类似并查集的父节点，用来存路径
vector<int> path;//存答案的路径
void dijkstra()
{
    memset(dist,0x3f,sizeof dist);//我们要找最短距离，先把距离都初始化成一个大数
    dist[0]=0;//第一个点0到自己的距离就是0，这个得初始化
    number[0]=1;//同样，0自己到自己先得有一种路径
    for (int i=0;i<n;i++) 
    {
        int t=-1;//t是所有还没确定最终最短距离的点中最小的一个
        //我们需要用t来更新所有的点最短距离（一次更新完后只有t是可以最终确定的
        for (int j=0;j<n;j++) 
        {
            if (!vis[j]&&(t==-1||dist[t]>dist[j])) t=j;
        }
        vis[t]=true;//这时候t可以最终确定，就vis[t]=true
        //if (t==-1) return ;
        for (int j=0;j<n;j++) 
        {
            if (dist[j]>(dist[t]+g[t][j])) {
                dist[j]=dist[t]+g[t][j];
                f[j]=t;
                saveTeam[j]=saveTeam[t]+initialTeam[j];
                number[j]=number[t];//出现了新的最短路径后，就要更新当前最短路径的数量
                //到j的最短路径数量也就是到t的最短路径数量，
                //由于都是从节点0开始过来的，所以这也是为什么要初始化number[0]=1
                
            }
            else if (dist[j]==(dist[t]+g[t][j])) {//这里就是出现多条最短路径
                if (saveTeam[j]<saveTeam[t]+initialTeam[j]) {
                    saveTeam[j]=saveTeam[t]+initialTeam[j];
                    f[j]=t;
                }
                number[j]+=number[t];
                //到j这里的最短路径数量变多了，多出到t的最短路径数量（从t又再到j的路径都是新的最短路径）
            }
            
        }
        
    }
}

int main()
{
    cin.tie(0);
    cin>>n>>m>>s>>e;
    memset(g,0x3f,sizeof g);//比较纳闷，没有初始化g答案就不对了，可是我感觉没啥必要初始化
    for (int i=0;i<n;i++) f[i]=i;
    for (int i=0;i<n;i++) {
        cin>>initialTeam[i];
        saveTeam[i]=initialTeam[i];//初始化队员数量
    }
    while (m--) 
    {
        int a,b,c;
        cin>>a>>b>>c;
        //g[a][b]=min(g[a][b],c);//如果含重边的话就要加上这一句，并且g得初始乘0x3f（某个极大值）
        g[a][b]=c;
        g[b][a]=g[a][b];//无向图，两个方向都存一下
    }
    dijkstra();
    int p=e;//从终点开始回溯，一个父节点一个的push_back进vector里
    while (true)
    {
        if (p==f[p]) {
            path.push_back(p);
            break;
        }
        path.push_back(p);
        p=f[p];
    }
    //输出答案即可
    cout<<number[e]<<" "<<saveTeam[e]<<"\n";
    for (int i=path.size()-1;i>=0;i--) 
    {
        if (i==path.size()-1) cout<<path[i];
        else cout<<" "<<path[i];
    }
    return 0;
}

朴素版Dijkstra模板，适用于点数不超过1000的图，否则会超时，时间复杂O(n²)

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

using namespace std;

const int N=510;

int dist[N];
bool st[N];
int n,m;
int g[N][N];

int dijkstra()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    
    for (int i=1;i<n;i++) 
    {
        int t=-1;
        for (int j=1;j<=n;j++) 
        {
            if (!st[j]&&(t==-1||dist[t]>dist[j])) t=j;
        }
        st[t]=true;
        for (int j=1;j<=n;j++) 
        {
            dist[j]=min(dist[j],dist[t]+g[t][j]);
        }
        
    }
    
    if (dist[n]==0x3f3f3f3f) return -1;
    return dist[n];
    
}

int main()
{
    scanf("%d%d",&n,&m);
    
    memset(g,0x3f,sizeof g);
    
    while (m--)
    {
        int a,b,c;
        scanf("%d%d%d",&a,&b,&c);
        
        g[a][b]=min(g[a][b],c);
        
    }
    
    int t=dijkstra();
    
    printf("%d\n",t);
    return 0;
}


```