PAT 甲级 1003 Emergency 七种方法

最新推荐文章于 2024-11-05 21:58:11 发布
最新推荐文章于 2024-11-05 21:58:11 发布
阅读量143 收藏
点赞数 1
文章标签： dfs dijkstra spfa 算法 最短路径
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011917745/article/details/119682621
版权
本文介绍了多种解决最短路径问题的算法，包括Dijkstra、Bellman-Ford和SPFA等，并提供了相应的C++实现。这些算法在解决含有负权边和可能有多个最短路径的问题中各有优势，适用于不同的场景。此外，还探讨了如何通过DFS进一步优化这些算法以获取更优解。
摘要由CSDN通过智能技术生成

注意：题目中没有零权边，不然就可能会有无数条最短路。

目录

方法一：Dijkstra+堆优化

#include <bits/stdc++.h>
using namespace std;

const int MAXN=510;
const int INF=0x3f3f3f3f;

unordered_map<int,int> graph[MAXN];
int v_w[MAXN]; // 点权
int dis[MAXN],done[MAXN];
int path_num[MAXN],team_num[MAXN]; // 最短路条数和最大营救队数目 

int n,m,c1,c2;

struct QNode{
    int v,c;
    bool operator< (const QNode &r) const {return c>r.c;}
    QNode(int _v=-1,int _c=INF):v(_v),c(_c){}
};
void Dijkstra(int s)
{
    memset(dis,INF,sizeof(dis));
    memset(done,false,sizeof(done));
    memset(path_num,0,sizeof(path_num));
    memset(team_num,0,sizeof(team_num));
    
    dis[s]=0;path_num[s]=1,team_num[s]=v_w[s];
    priority_queue<QNode> q;
    q.push(QNode(s,0));
    while(!q.empty()){
        int now=q.top().v;q.pop();
        if(done[now]) continue;
        done[now]=true;
        for(auto edge:graph[now]){
            int to=edge.first,cost=edge.second;
            if(!done[to]&&dis[to]>dis[now]+cost){
                dis[to]=dis[now]+cost;
                q.push(QNode(to,dis[to]));
                path_num[to]=path_num[now];
                team_num[to]=team_num[now]+v_w[to];
            }else if(!done[to]&&dis[to]==dis[now]+cost){
                path_num[to]+=path_num[now];
                if(team_num[to]<team_num[now]+v_w[to])
                    team_num[to]=team_num[now]+v_w[to];
            }
        }
    }
}

int main() {
    cin>>n>>m>>c1>>c2;
    for(int i=0;i<n;++i) cin>>v_w[i];
    int x,y,z;
    for(int i=0;i<m;++i){
        cin>>x>>y>>z;
        graph[x][y]=graph[y][x]=z;
    }
    Dijkstra(c1);
    
    cout<<path_num[c2]<<" "<<team_num[c2];
}

方法二：Dijkstra+堆优化+DFS

适用于标尺特别多的情况，先把最短路径前驱树（根据距离标尺）记录下来。对这棵树进行 DFS 的时，再根据其他标尺进行判断。
int path_num[MAXN] 和 team_num[MAXN] 就不再需要了。

#include <bits/stdc++.h>
using namespace std;

const int MAXN=510;
const int INF=0x3f3f3f3f;

unordered_map<int,int> graph[MAXN];
int v_w[MAXN]; // 点权
int dis[MAXN],done[MAXN];
set<int> pre[MAXN]; // 最短路前驱树

int n,m,c1,c2;

struct QNode{
    int v,c;
    bool operator< (const QNode &r) const {return c>r.c;}
    QNode(int _v=-1,int _c=INF):v(_v),c(_c){}
};
void Dijkstra(int s)
{
    memset(dis,INF,sizeof(dis));
    memset(done,false,sizeof(done));
    dis[s]=0;
    priority_queue<QNode> q;
    q.push(QNode(s,0));
    while(!q.empty()){
        int now=q.top().v;q.pop();
        if(done[now]) continue;
        done[now]=true;
        for(auto edge:graph[now]){
            int to=edge.first,cost=edge.second;
            if(!done[to]&&dis[to]>=dis[now]+cost){
                if(dis[to]!=dis[now]+cost)
                    pre[to].clear();
                pre[to].insert(now);
                dis[to]=dis[now]+cost;
                q.push(QNode(to,dis[to]));
            }
        }
    }
}

int max_team=0,roads=0;
void DFS(int s,int team)
{
    team+=v_w[s];
    if(pre[s].empty()){
        roads++;
        if(team>max_team) max_team=team;
    }else{
        for(auto i:pre[s]){
            DFS(i,team);
        }
    }
}

int main() {
    cin>>n>>m>>c1>>c2;
    for(int i=0;i<n;++i) cin>>v_w[i];
    int x,y,z;
    for(int i=0;i<m;++i){
        cin>>x>>y>>z;
        graph[x][y]=graph[y][x]=z;
    }
    Dijkstra(c1);
    DFS(c2,0);
    
    cout<<roads<<" "<<max_team;
}

方法三：BellmanFord

#include <bits/stdc++.h>
using namespace std;

const int MAXN=510;
const int INF=0x3f3f3f3f;
int n,m,c1,c2;
struct Edge{
    int u,v,c;
    Edge(int _u=-1,int _v=-1,int _c=INF):u(_u),v(_v),c(_c){}
};
int v_w[MAXN];
vector<Edge> edges;
int dis[MAXN];
set<int> pre[MAXN];
int path_num[MAXN],team_num[MAXN];
void BellmanFord(int s)
{
    memset(dis,INF,sizeof(dis));
    memset(path_num,0,sizeof(path_num));
    memset(team_num,0,sizeof(team_num));
    dis[s]=0;path_num[s]=1,team_num[s]=v_w[s];
    for(int i=0;i<n-1;++i){
        for(auto e:edges){
            if(dis[e.v]>dis[e.u]+e.c){
                dis[e.v]=dis[e.u]+e.c;
                pre[e.v].clear();pre[e.v].insert(e.u);
                path_num[e.v]=path_num[e.u];
                team_num[e.v]=team_num[e.u]+v_w[e.v];
            }else if(dis[e.v]==dis[e.u]+e.c){
                // 不同于 Dijkstra，由于有重复的松弛操作，
                // 所以这里要重新统计最短路径。
                pre[e.v].insert(e.u);
                path_num[e.v]=0;
                for(auto i:pre[e.v])
                    path_num[e.v]+=path_num[i];
                if(team_num[e.v]<team_num[e.u]+v_w[e.v])
                    team_num[e.v]=team_num[e.u]+v_w[e.v];
            }
        }
    }
}

int main() {
    cin>>n>>m>>c1>>c2;
    int x,y,z;
    for(int i=0;i<n;++i) cin>>v_w[i];
    for(int i=0;i<m;++i){
        cin>>x>>y>>z;
        edges.emplace_back(x,y,z);
        edges.emplace_back(y,x,z);
    }
    BellmanFord(c1);
    cout<<path_num[c2]<<" "<<team_num[c2];
}

方法四：BellmanFord+DFS

方法三里面前驱子图都求出来了，那么对于其他标尺的DFS就按照方法二写一个函数就完事儿 ， 就不给代码啦 ~

int path_num[MAXN] 和 team_num[MAXN] 也不再需要了，函数内部简化不少。

#include <bits/stdc++.h>
using namespace std;

const int MAXN=510;
const int INF=0x3f3f3f3f;
int n,m,c1,c2;

struct Edge{
    int u,v,c;
    Edge(int _u=-1,int _v=-1,int _c=INF):u(_u),v(_v),c(_c){}
};
vector<Edge> edges;
int v_w[MAXN];

int dis[MAXN];
set<int> pre[MAXN];
void BellmanFord(int s)
{
    memset(dis,INF,sizeof(dis));
    dis[s]=0;
    
    for(int i=0;i<n-1;++i){
        for(auto e:edges){
            if(dis[e.v]>=dis[e.u]+e.c){
                if(dis[e.v]!=dis[e.u]+e.c)
                    pre[e.v].clear();
                dis[e.v]=dis[e.u]+e.c;
                pre[e.v].insert(e.u);
            }
        }
    }
}

int max_team=0,roads=0;
void DFS(int s,int team)
{
    team+=v_w[s];
    if(pre[s].empty()){
        roads++;
        if(team>max_team) max_team=team;
    }else{
        for(auto i:pre[s]){
            DFS(i,team);
        }
    }
}

int main() {
    cin>>n>>m>>c1>>c2;
    int x,y,z;
    for(int i=0;i<n;++i) cin>>v_w[i];
    for(int i=0;i<m;++i){
        cin>>x>>y>>z;
        edges.emplace_back(x,y,z);
        edges.emplace_back(y,x,z);
    }
    BellmanFord(c1);
    DFS(c2,0);
    
    cout<<roads<<" "<<max_team;
}

方法五：SPFA

#include <bits/stdc++.h>
using namespace std;

const int MAXN=510;
const int INF=0x3f3f3f3f;
int n,m,c1,c2;
unordered_map<int,int> graph[MAXN];
int v_w[MAXN];
int dis[MAXN],in_q[MAXN];
set<int> pre[MAXN];
int path_num[MAXN],team_num[MAXN];

void SPFA(int s)
{
    memset(dis,INF,sizeof(dis));
    memset(in_q,false,sizeof(in_q));
    memset(path_num,0,sizeof(path_num));
    memset(team_num,0,sizeof(team_num));
    dis[s]=0;path_num[s]=1,team_num[s]=v_w[s];
    
    queue<int> q;
    q.push(s),in_q[s]=true;
    while(!q.empty()){
        int now=q.front();q.pop(),in_q[now]=false;
        for(auto edge:graph[now]){
            int to=edge.first,cost=edge.second;
            if(dis[to]>dis[now]+cost){
                dis[to]=dis[now]+cost;
                if(!in_q[to]) q.push(to),in_q[to]=true;
                pre[to].clear();pre[to].insert(now);
                path_num[to]=path_num[now];
                team_num[to]=team_num[now]+v_w[to];
            }else if(dis[to]==dis[now]+cost){
                pre[to].insert(now);path_num[to]=0;
                for(auto i:pre[to])
                    path_num[to]+=path_num[i];
                // 注意 这里更新了 num 之后要把 to 入队。 
                if(!in_q[to]) q.push(to),in_q[to]=true;
                if(team_num[to]<team_num[now]+v_w[to])
                    team_num[to]=team_num[now]+v_w[to];
            }
        }
    }
}

int main() {
    cin>>n>>m>>c1>>c2;
    for(int i=0;i<n;++i) cin>>v_w[i];
    int x,y,z;
    for(int i=0;i<m;++i){
        cin>>x>>y>>z;
        graph[x][y]=graph[y][x]=z;
    }
    SPFA(c1);

    cout<<path_num[c2]<<" "<<team_num[c2];
}

方法六：SPFA+DFS

方法五里面前驱子图 pre 也顺带求出来啦，剩下的就同方法四了~

int path_num[MAXN] 和 team_num[MAXN] 也不再需要了。

#include <bits/stdc++.h>
using namespace std;

const int MAXN=510;
const int INF=0x3f3f3f3f;
int n,m,c1,c2;

unordered_map<int,int> graph[MAXN];
int v_w[MAXN];

int dis[MAXN],in_q[MAXN];
set<int> pre[MAXN];
void SPFA(int s)
{
    memset(dis,INF,sizeof(dis));
    memset(in_q,false,sizeof(in_q));
    dis[s]=0;
    
    queue<int> q;
    q.push(s),in_q[s]=true;
    while(!q.empty()){
        int now=q.front();
        q.pop(),in_q[now]=false;
        for(auto edge:graph[now]){
            int to=edge.first,cost=edge.second;
            if(dis[to]>=dis[now]+cost){
                if(dis[to]!=dis[now]+cost)
                    pre[to].clear();
                pre[to].insert(now);
                dis[to]=dis[now]+cost;
                if(!in_q[to]) q.push(to),in_q[to]=true;
            }
        }
    }
}

int max_team=0,roads=0;
void DFS(int s,int team)
{
    team+=v_w[s];
    if(pre[s].empty()){
        roads++;
        if(team>max_team) max_team=team;
    }else{
        for(auto i:pre[s]){
            DFS(i,team);
        }
    }
}

int main() {
    cin>>n>>m>>c1>>c2;
    for(int i=0;i<n;++i) cin>>v_w[i];
    int x,y,z;
    for(int i=0;i<m;++i){
        cin>>x>>y>>z;
        graph[x][y]=graph[y][x]=z;
    }
    SPFA(c1);
    DFS(c2,0);
    
    cout<<roads<<" "<<max_team;
}

方法七：DFS直接搜索

没错，这道题规模很小，直接搜索也是可以的。

#include <bits/stdc++.h>
using namespace std;

const int MAXN=510;
const int INF=0x3f3f3f3f;
int n,m,c1,c2;
unordered_map<int,int> graph[MAXN];
int v_w[MAXN];

int min_dis=INF,path_num=0,team_num=0,vis[MAXN];
void DFS(int now,int dis_now,int team_now)
{
    if(dis_now>min_dis) return;
    if(now==c2){
        if(dis_now<min_dis){
            min_dis=dis_now;
            path_num=1;
            team_num=team_now;
        }else if(dis_now==min_dis){
            path_num++;
            if(team_num<team_now)
                team_num=team_now;
        }
        return;
    }
    for(auto edge:graph[now]){
        int to=edge.first,cost=edge.second;
        if(!vis[to]&&dis_now+cost<=min_dis){
            vis[to]=true;
            DFS(to,dis_now+cost,team_now+v_w[to]);
            vis[to]=false;
        }
    }
}

int main() {
    cin>>n>>m>>c1>>c2;
    for(int i=0;i<n;++i) cin>>v_w[i];
    int x,y,z;
    for(int i=0;i<m;++i){
        cin>>x>>y>>z;
        graph[x][y]=graph[y][x]=z;
    }

    memset(vis,false,sizeof(vis));
    vis[c1]=true;
    DFS(c1,0,v_w[c1]);

    cout<<path_num<<" "<<team_num;
}
桂圆儿呀
关注
PAT甲级 1003 Emergency (25分）题目理解以及测试点的易错点
weixin_39719872的博客
03-01 1496
PAT甲级 1003 Emergency (25分）题目以及测试点的坑题目介绍：题目以及测试点的坑 题目介绍： As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue teams in each city and the
PTA-1003 Emergency(使用堆优化的dijkstra算法)
qq_45929428的博客
05-25 160
#include<bits/stdc++.h> using namespace std; #define INF 0x3f3f3f3f const int maxx=505; struct edge { int to,dis,cost; edge(int _to,int _dis,int _cost){to=_to,dis=_dis,cost=_cost;} }; vector<edge> a[maxx]; typedef pair<int ,int> P; int
PAT1003 Emergency(裸Djs,优先队列优化两种方法）
chengsilin666的博客
08-24 277
1003 Emergency (25)（25 分） As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue t...
1003 Emergency——dijkstra
m0_46700796的博客
11-21 578
题目描述 As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue teams in each city and the length of each road between any pair of cities are m
杭电多校七 1003-Counting Stickmen（组合数学）
AC__dream的博客
08-10 221
上面标红的部分是一个人，也只有上面这种形状的才算是人，问给定的一棵树中有多少个类似上图的人。
PAT甲级 1003 Emergency 单源Dijkstra最短路
化身孤岛的鲸o的博客
07-13 402
Solution： 这道题的意思是给定起点和终点，求最短路。但还有一个要求，就是每个城市有救援队，我们要在求得最短路的情况下集结沿途尽可能多的救援队人数。 代码如下： #include<iostream> #define INF 0x3f3f3f3f using namespace std; int visit[505]; int mp[505][505]; int num[50...
[PAT甲级]1003 Emergency超详细题解+AC代码
zzylalalala的博客
11-06 224
以下所述均为个人理解，如有错误，还望指正。
PAT 甲级 1003  Emergency
漫浸天空的雨色的备忘录~
01-16 1448
1003 Emergency （25 point(s)） As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescu...
PAT甲级 1003 Emergency
qq_29762941的博客
07-03 345
参考链接:点击打开链接 As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue teams in each c...
PAT甲级1003：Emergency(25）
博客简介
04-13 357
题目 As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue teams in each city and the length of each road between any pair of cities are mar
PAT甲级1003 Emergency (C++)
小海同学的博客
02-25 468
本题翻译： 题目给出四个数字，分别是N（多少城市）、M（有几条路）、C1（初始城市）、C2（救援城市） 第二行是给出五个城市分别有多少救援人员。 接下来的N行是城市x，城市y，两个城市的距离。 最后求到该城市的最短距离有几条路，在最短距离的情况下最多的救援人员是多少？ 本题思路： 利用深度搜索进行图的遍历，寻找最短路径，顺带把救援人员进行统计。 详细代码样例： #include <bits/stdc++.h> using namespace std; int N,M,C1,C2; int num
【PAT甲级】1003 Emergency 紧急情况
wo的博客
11-17 200
1003 紧急情况
PAT甲级题库 1003 Emergency (25 分)
weixin_42445051的博客
01-23 443
1003 Emergency (25 分) As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue teams in each city and the length of each road between any pai
pat甲级1003 c和python实现
weixin_43459445的博客
10-11 250
Emergency (25) As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue teams in eac...
算法基础-链表
August的专栏
11-05 133
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
深⼊理解指针2
ElePower9527的博客
11-01 656
指针访问数组内容时，有如下代码这⾥我们使⽤ &arr[0] 的⽅式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，⽽且 是数组⾸元素的地址，我们来做个测试。输出结果我们发现数组名和数组⾸元素的地址打印出的结果⼀模⼀样，数组名就是数组⾸元素(第⼀个元素)的地址。注意有两个例外• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩， 单位是字节。
【二分查找】【三种写法】——在排序数组中查找元素的第一个和最后一个位置#力扣hot100
weixin_47868976的博客
10-31 1111
给你一个按照非递减顺序排列的整数数组nums，和一个目标值target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值target，返回[-1, -1]。必须设计并实现时间复杂度为O(log n)的算法解决此问题。
【LeetCode】【算法】160.相交链表
最新发布
passer__jw767的博客
11-05 118
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 1242
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
PAT甲级编程题目分类与精华摘要
- **1003 Emergency**：使用Dijkstra算法求最短路径，考虑边的权重和资源限制。 - **1142 Maximal Clique**：判定图中的最大团，涉及到图的子结构分析。 - **1021 Deepest Root**：判断图中是否存在环并找到最...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值