最短路----求满足两个条件的情况

7-3 打怪升级
分数 25
作者 陈越
单位 浙江大学
dgsj.JPG

很多游戏都有打怪升级的环节，玩家需要打败一系列怪兽去赢取成就和徽章。这里我们考虑一种简单的打怪升级游戏，游戏规则是，给定有 N 个堡垒的地图，堡垒之间有道路相连，每条道路上有一只怪兽把守。怪兽本身有能量，手里的武器有价值。打败怪兽需要的能量等于怪兽本身的能量，而怪兽一旦被打败，武器就归玩家所有 —— 当然缴获的武器价值越高，玩家就越开心。

你的任务有两件：

帮助玩家确定一个最合算的空降位置，即空降到地图中的某个堡垒，使得玩家从这个空降点出发，到攻下最难攻克（即耗费能量最多）的那个堡垒所需要的能量最小；
从这个空降点出发，帮助玩家找到攻克任意一个其想要攻克的堡垒的最省能量的路径。如果这种路径不唯一，则选择沿途缴获武器总价值最高的解，题目保证这种解是唯一的。
输入格式:
输入第一行给出两个正整数 N (≤1000) 和 M，其中 N 是堡垒总数，M 是怪兽总数。为简单起见，我们将堡垒从 1 到 N 编号。随后 M 行，第 i 行给出了第 i 只怪兽的信息，格式如下：

B1 B2 怪兽能量 武器价值
其中 B1 和 B2 是怪兽把守的道路两端的堡垒编号。题目保证每对堡垒之间只有一只怪兽把守，并且 怪兽能量 和 武器价值 都是不超过 100 的正整数。

再后面是一个正整数 K（≤N）和玩家想要攻克的 K 个目标堡垒的编号。

输出格式:
首先在一行中输出玩家空降的堡垒编号 B0。如果有多种可能，则输出编号最小的那个。

随后依次为玩家想要攻克的每个堡垒 B 推荐最省能量的攻克路径，并列出需要耗费的能量值和沿途缴获武器的总价值。注意如果最省力的路径不唯一，则选择沿途缴获武器总价值最高的解。格式为：

B0->途经堡垒1->...->B
总耗费能量 武器总价值
输入样例:
6 12
1 2 10 5
2 3 16 20
3 1 4 2
2 4 20 22
4 5 2 2
5 3 12 6
4 6 8 5
6 5 10 5
6 1 20 25
1 5 8 5
2 5 2 1
2 6 8 5
4
2 3 6 5
输出样例:
5
5->2
2 1
5->1->3
12 7
5->4->6
10 7
5
0 0
代码长度限制

这道题的难点：

从这个空降点出发，帮助玩家找到攻克任意一个其想要攻克的堡垒的最省能量的路径。如果这种路径不唯一，则选择沿途缴获武器总价值最高的解，题目保证这种解是唯一的。
接下来是我认为我至今写的最好的Dijkstra算法，建议以后以这个为模板：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <stack>
using namespace std;
const int N = 1010, INF = 0x3f3f3f3f;
struct node
{
    int power = INF, value = 0;
} g[N][N];        // Dijkstra要
int gg[N][N], B0; // floyd要
int n, m;
int dist[N], getvalue[N], fnode[N];
bool st[N];
int floyd()
{
    for (int k = 1; k <= n; k++)
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= n; j++)
                gg[i][j] = min(gg[i][j], gg[i][k] + gg[k][j]);
    int B0, mind = INF, d[N];
    for (int i = 1; i <= n; i++)
    {
        d[i] = -1;
        for (int j = 1; j <= n; j++)
            if (gg[i][j] < INF)
                d[i] = max(d[i], gg[i][j]);
    }
    for (int i = 1; i <= n; i++)
    {
        if (mind > d[i])
        {
            mind = d[i];
            B0 = i;
        }
    }
    return B0;
}
void Dijkstra()
{
    memset(dist, 0x3f, sizeof(dist));
    dist[B0] = 0;
    getvalue[B0] = 0;
    for (int i = 1; i <= n; i++)
    {
        int mind = INF, maxv = 0, t = -1;//强烈建议用这种写法：y 总的总是会出一些问题：
        for (int j = 1; j <= n; j++)
        {
            if (!st[j])
            {
                if (mind > dist[j] || (mind == dist[j] && maxv < getvalue[j]))//维护在能量消耗一样时，选择最大的价值点
                {
                    t = j;
                    mind = dist[j];
                    maxv = getvalue[j];//记得保证更新当前选择的最大价值点
                }
            }
        }
        st[t] = true;
        for (int j = 1; j <= n; j++) //是谁更新到这个点的，是在这里；
        {
            if (!st[j] && g[t][j].power != INF)//注意这里这样写更好
            {
                if (dist[j] > dist[t] + g[t][j].power)
                {
                    dist[j] = dist[t] + g[t][j].power;
                    getvalue[j] = getvalue[t] + g[t][j].value;
                    fnode[j] = t;
                }
                else if (dist[j] == dist[t] + g[t][j].power && getvalue[j] < getvalue[t] + g[t][j].value)
                {
                    getvalue[j] = getvalue[t] + g[t][j].value;
                    fnode[j] = t;
                }
            }
        }
    }
}
int main()
{
    memset(gg, 0x3f, sizeof(gg));
    scanf("%d%d", &n, &m);
    int a, b, p, v;
    for (int i = 1; i <= m; i++)
    {
        scanf("%d%d%d%d", &a, &b, &p, &v);
        g[a][b].power = g[b][a].power = p;
        g[a][b].value = g[b][a].value = v;
        gg[a][b] = gg[b][a] = p;
    }
    B0 = floyd();
    int k, target[N];
    scanf("%d", &k);
    for (int i = 1; i <= k; i++)
        scanf("%d", &target[i]);
    Dijkstra();
    stack<int> s;
    printf("%d\n", B0);
    for (int i=1;i<=k;i++)
    {
        for (int j=target[i];j!=0;j=fnode[j])
        {
            s.push(j);
        }
        while (!s.empty())
        {
            printf ("%d",s.top());
            s.pop();
            if (s.size()>=1) printf ("->");
        }
        printf ("\n%d %d",dist[target[i]],getvalue[target[i]]);
        printf ("\n");
    }
    return 0;
}

 

 这里还有道好题目：讲到了核心：

Heavy Transportation
描述：
Background
Hugo Heavy is happy. After the breakdown of the Cargolifter project he can now expand business. But he needs a clever man who tells him whether there really is a way from the place his customer has build his giant steel crane to the place where it is needed on which all streets can carry the weight.
Fortunately he already has a plan of the city with all streets and bridges and all the allowed weights.Unfortunately he has no idea how to find the the maximum weight capacity in order to tell his customer how heavy the crane may become. But you surely know.

Problem
You are given the plan of the city, described by the streets (with weight limits) between the crossings, which are numbered from 1 to n. Your task is to find the maximum weight that can be transported from crossing 1 (Hugo's place) to crossing n (the customer's place). You may assume that there is at least one path. All streets can be travelled in both directions.
输入：
The first line contains the number of scenarios (city plans). For each city the number n of street crossings (1 <= n <= 1000) and number m of streets are given on the first line. The following m lines contain triples of integers specifying start and end crossing of the street and the maximum allowed weight, which is positive and not larger than 1000000. There will be at most one street between each pair of crossings.
输出：
The output for every scenario begins with a line containing "Scenario #i:", where i is the number of the scenario starting at 1. Then print a single line containing the maximum allowed weight that Hugo can transport to the customer. Terminate the output for the scenario with a blank line.
样例输入：
1
3 3
1 2 3
1 3 4
2 3 5
复制
样例输出：
Scenario #1:
4

好博客：https://blog.csdn.net/Ratina/article/details/87933057?spm=1001.2101.3001.6650.2&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-2-87933057-blog-82708228.pc_relevant_default&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromBaidu%7Edefault-2-87933057-blog-82708228.pc_relevant_default&utm_relevant_index=5

https://blog.csdn.net/STILLxjy/article/details/78169093?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_title~default-1-78169093-blog-89299741.pc_relevant_baidufeatures_v7&spm=1001.2101.3001.4242.2&utm_relevant_index=4