L2-001 紧急救援(分数 25) 两种思想

 

L2-001 紧急救援(分数 25)

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

输入格式:

输入第一行给出4个正整数N、M、S、D,其中N(2N500)是城市的个数,顺便假设城市的编号为0 ~ (N1);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
 
代码长度限制
16 KB
时间限制
200 ms
内存限制
64 MB
 
题目分析:
在该题中有边权和点权两种,先求最短路径(即边权总和最小),再考虑救援人数(即点权总和最小),题目还需要求最佳路径(在路径最短的情况下救援队人数最多)
首先先建图,题目说编号从0-n,最简单的方式就是矩阵了
 
思路一:
暴力法
利用深搜+回溯,这种解法能得到正确答案,但是通常只用于点数较少的情况,只能得到部分分数,在本题中暴力dfs只能拿21分
其实这种解法也挺无脑的,因为只要把模板掌握好了很多题目都能用这种方法来求,模板都是在dfs的基础上改改修修,实在不懂甚至可以去背一套模板
题目要求什么就先把变量设好。然后dfs,直到到达终点,然后判断路径长度,记录最短的,然后长度相同则最短路径条数加一。
 
#include<bits/stdc++>
using namespace std;

namespace n1
{

    vector<vector<int>> G(502, vector<int>(502, -1)); //
    vector<int> w(502, 0);                            //点权
    vector<int> vis(502, 0);
    int n, m, s, d;
    int num = 0;       //最短路径条数
    int len = INT_MAX; //长度
    int maxper;        //人数最多
    vector<int> res;   //最短路径
    vector<int> temp;  //中间路径

    void dfs(int to, int l, int per)
    {
        if (l > len)
            return;
        //到达终点
        if (to == d)
        {
            if (l < len)
            {
                len = l;
                maxper = per;
                res = temp;
                num = 1;
            }
            else if (l == len)
            {
                num++;
                if (maxper < per)
                {
                    maxper = per;
                    res = temp;
                }
            }
            else
                return;
        }
        for (int i = 0; i < n; i++)
        {
            if (G[to][i] != -1 && vis[i] == 0)
            {
                temp.push_back(i);
                vis[i] = 1;
                dfs(i, l + G[to][i], per + w[i]);
                temp.pop_back();  //回溯
                vis[i] = 0;
            }
        }
    }

    void test()
    {
        cin >> n >> m >> s >> d;
        for (int i = 0; i < n; i++)
            cin >> w[i];
        for (int i = 0; i < m; i++)
        {
            int u, v, w;
            cin >> u >> v >> w;
            G[u][v] = G[v][u] = w;
        }
        temp.push_back(s);
        vis[s] = 1;
        dfs(s, 0, w[s]);
        cout << num << ' ' << maxper << endl;
        for (int i = 0; i < res.size(); i++)
        {
            if (i == 0)
                cout << res[i];
            else
                cout << ' ' << res[i];
        }
    }

}

int main()
{
    n1::test();
    return 0;
}

 

思路二:
主要介绍思路二,这也是求最短路的一种常规解法,在迪杰斯特拉算法的基础上增加相应的变量来记录结果就行
主要增加的记录有,记录最短长度dist数组,记录最多救援队人数value数组,记录每点最短路径条数num数组 ,记录最近的父节点用于求路径fa数组
 
#include<bits/stdc++.h>
using namespace std;

//紧急救援-迪杰斯特拉算法
namespace n2
{
    const int INF = 1e9;
    int n, m, s, d;                                    //点数 边数 起点 终点
    vector<vector<int>> G(502, vector<int>(502, INF)); //
    vector<int> w;                                     //每个点的救援队人数
    vector<int> num(502, 0);                           //最短路径的条数,起始点为1,其他都为0
    vector<int> value(502, 0);                         //各个点的救援数量,起始点为该点的救援人数,其他点为0
    vector<int> fa(502, -1);                           //每一点的最近父亲节点,回退找到最短路径
    vector<int> dist(502, INF);                        //最短距离
    vector<int> vis(502, 0);                           //是否已访问

    void Dijkstra(int s)
    {

        num[s] = 1;      //通路条数
        value[s] = w[s]; //从起点到该点所拥有的最大救援数量
        dist[s] = 0;     //最短距离
                         // vis[s] = 1;
        for (int i = 0; i < n; i++)
        {
            int to, max = INT_MAX;
            for (int j = 0; j < n; j++)
            {
                if (vis[j] == 0 && dist[j] < max)
                {
                    max = dist[j];
                    to = j;
                }
            }
            vis[to] = 1;
            for (int j = 0; j < n; j++)
            {
                if (vis[j] == 0 && dist[j] > dist[to] + G[to][j])
                {
                    dist[j] = dist[to] + G[to][j];
                    num[j] = num[to];
                    value[j] = value[to] + w[j];
                    fa[j] = to;
                }
                else if (vis[j] == 0 && dist[j] == dist[to] + G[to][j])
                {
                    num[j] += num[to];
                    if (value[j] < value[to] + w[j])
                    {
                        value[j] = value[to] + w[j];
                        fa[j] = to;
                    }
                }
            }
        }
    }

    void test()
    {
        cin >> n >> m >> s >> d;
        for (int i = 0; i < n; i++)
        {
            int t;
            cin >> t;
            w.push_back(t);
        }
        for (int i = 0; i < m; i++)
        {
            int u, v, w;
            cin >> u >> v >> w;
            G[u][v] = G[v][u] = w;
        }
        Dijkstra(s);
        cout << num[d] << ' ' << value[d] << endl;
        vector<int> res;
        for (int i = d; i != -1; i = fa[i])
            res.push_back(i);
        for (int i = 0; i < res.size(); i++)
            if (i == 0)
                cout << res[i];
            else
                cout << ' ' << res[i];
    }

}

int main()
{
    n2::test();
    return 0;
}

 

posted @ 2022-06-15 01:14  深情的山鸡  阅读(94)  评论(0编辑  收藏  举报