903 昂贵的聘礼（单源最短路径-建图）

最新推荐文章于 2024-09-12 19:02:20 发布

yuzhang_zy

最新推荐文章于 2024-09-12 19:02:20 发布

阅读量123

点赞数

分类专栏： acwing-提高文章标签：算法

本文链接：https://blog.csdn.net/qq_39445165/article/details/120774159

版权

acwing-提高专栏收录该内容

456 篇文章 15 订阅

订阅专栏

1. 问题描述：

年轻的探险家来到了一个印第安部落里。在那里他和酋长的女儿相爱了，于是便向酋长去求亲。酋长要他用 10000 个金币作为聘礼才答应把女儿嫁给他。探险家拿不出这么多金币，便请求酋长降低要求。酋长说：”嗯，如果你能够替我弄到大祭司的皮袄，我可以只要 8000 金币。如果你能够弄来他的水晶球，那么只要 5000 金币就行了。”探险家就跑到大祭司那里，向他要求皮袄或水晶球，大祭司要他用金币来换，或者替他弄来其他的东西，他可以降低价格。探险家于是又跑到其他地方，其他人也提出了类似的要求，或者直接用金币换，或者找到其他东西就可以降低价格。不过探险家没必要用多样东西去换一样东西，因为不会得到更低的价格。探险家现在很需要你的帮忙，让他用最少的金币娶到自己的心上人。另外他要告诉你的是，在这个部落里，等级观念十分森严。地位差距超过一定限制的两个人之间不会进行任何形式的直接接触，包括交易。他是一个外来人，所以可以不受这些限制。但是如果他和某个地位较低的人进行了交易，地位较高的的人不会再和他交易，他们认为这样等于是间接接触，反过来也一样。因此你需要在考虑所有的情况以后给他提供一个最好的方案。为了方便起见，我们把所有的物品从 1 开始进行编号，酋长的允诺也看作一个物品，并且编号总是 1。每个物品都有对应的价格 P，主人的地位等级 L，以及一系列的替代品Ti和该替代品所对应的”优惠” Vi。如果两人地位等级差距超过了 M，就不能”间接交易”。你必须根据这些数据来计算出探险家最少需要多少金币才能娶到酋长的女儿。

输入格式

输入第一行是两个整数 M，N，依次表示地位等级差距限制和物品的总数。接下来按照编号从小到大依次给出了 N 个物品的描述。每个物品的描述开头是三个非负整数 P、L、X，依次表示该物品的价格、主人的地位等级和替代品总数。接下来 X 行每行包括两个整数 T 和 V，分别表示替代品的编号和”优惠价格”。

输出格式

输出最少需要的金币数。

数据范围

1 ≤ N ≤ 100，
1 ≤ P ≤ 10000，
1 ≤ L，M ≤ N，
0 ≤ X < N

输入格式

1 4
10000 3 2
2 8000
3 5000
1000 2 1
4 200
3000 2 1
4 200
50 2 0

输出格式

5250
来源：https://www.acwing.com/problem/content/description/905/

2. 思路分析：

分析题目可以知道这道题目的背景还是挺复杂的，所以我们首先需要弄清楚题目的意思，捋清楚其中的逻辑关系，弄清楚要求的是什么，对于这种比较复杂的题目，我们可以先在纸上画一下其中节点与节点之间的联系，看是否可以将其抽象为一个图论的模型，我们可以从简单一点的问题搞起，暂时先不考虑等级的限制，等到我们已经捋清楚了题目的逻辑关系再考虑等级的限制，以题目中的测试用例为例画出物品与物品之间的关系如下图所示，这样我们就将题目中的关系转换为了图论的简单模型，所以离建图又进了一步：

因为求解花费最少的金币，所以属于最短路径问题，我们可以考虑一下起点和终点，终点其实很好确定，为题目中的1号点，关键是起点，因为题目肯定是有解的（最终可以使用金币来买物品），所以起点肯定是买一个物品，最终通过中间的若干个点转移到1号点，所以我们其实可以建一个虚拟源点(虚拟源点是核心)，虚拟源点到其余点表示直接买当前的物品需要花费的金币数目，因为题目中的节点编号是从1~N的，所以0号点可以设置为虚拟源点，虚拟源点到其余点的边表示买这个商品需要花费的金币数目，其余的点与点之间的边表示通过得到某个商品外加对应的金币那么就可以得到另外的的物品，在图中可以表示为向另外一个点连一条边，最终我们就将原问题转换为了最短路径问题，我们只需要求解从虚拟源点0出发到编号为1的终点的最短路径即可。可以发现题目的难点是如何将问题抽象为图论中的模型。捋清楚题目的逻辑关系之后，还有一个等级限制的问题，其实我们枚举所有合法的区间，题目规定了最小等级与最大等级的差值要小于等于M，所以每一次我们需要以1号点的等级为标准，枚举一个区间，判断对应的节点是否在这个区间之内，如果在这个区间说明可以更新最短路径，求解最短路径的时候使用任何一种最短路径的算法即可，下面使用的是dijkstra朴素版本的解法。

3. 代码如下：

邻接矩阵：

from typing import List


class Solution:
    # n表示图中点的个数, down表示区间等级的最小值, up表示区间等级的最大值, w表示有向图
    def dijkstra(self, n: int, down: int, up: int, level: List[int], w: List[List[int]]):
        INF = 10 ** 9
        dis = [INF] * (n + 1)
        dis[0] = 0
        vis = [0] * (n + 1)
        for i in range(n):
            k = -1
            for j in range(n + 1):
                if vis[j] == 0 and (k == -1 or dis[k] > dis[j]):
                    k = j
            vis[k] = 1
            for j in range(1, n + 1):
                # 判断节点是否在等级区间内
                if down <= level[j] <= up:
                    dis[j] = min(dis[j], dis[k] + w[k][j])
        return dis[1]

    def process(self):
        m, n = map(int, input().split())
        INF = 10 ** 9
        # 使用邻接矩阵存储
        w = [[INF] * (n + 1) for i in range(n + 1)]
        level = [0] * (n + 1)
        for i in range(1, n + 1):
            t = list(map(int, input().split()))
            # 0向第i个点连一条边(源点向其他点连一条边)
            w[0][i] = t[0]
            level[i] = t[1]
            count = t[2]
            for j in range(count):
                idx, price = map(int, input().split())
                # 其余点向第i个点连一条边(根据图确定哪一个在前哪一个在后)
                w[idx][i] = min(w[idx][i], price)
        res = INF
        # 枚举等级区间, 注意题目的意思是最高等级与最低等级的差要小于等于M
        for i in range(level[1] - m, level[1] + 1):
            res = min(res, self.dijkstra(n, i, i + m, level, w))
        return res


if __name__ == "__main__":
    print(Solution().process())

邻接表：

from typing import List

class Solution:
     def dijkstra(self, n: int, down: int, up: int, level: List[int], g: List[dict]):
          INF = 10 ** 9
          dis = [INF] * (n + 1)
          dis[0] = 0
          vis = [0] * (n + 1)
          for i in range(n):
               k = -1
               # 注意循环的时候是从0开始的                    
               for j in range(n + 1):
                    if vis[j] == 0 and (k == -1 or dis[k] > dis[j]):
                         k = j
               vis[k] = 1
               for next in g[k].items():
                    if down <= level[next[0]] <= up:
                         dis[next[0]] = min(dis[next[0]], dis[k] + next[1])
          return dis[1]
          
     
     def process(self):
          # m为等级限制
          m, n = map(int, input().split())
          # 每一个g[i]是一个字典就相当于是一个邻接表
          g = [dict() for i in range(n + 1)]
          level = [0] * (n + 1)
          for i in range(1, n + 1):
               p, l, count= map(int, input().split())
               g[0][i] = p
               level[i] = l
               for j in range(count):
                    idx, price = map(int, input().split())
                    if i in g[idx]:
                         g[idx][i] = min(g[idx][i], price)
                    else: g[idx][i] = price
          INF = 10 ** 9
          res = INF
          for i in range(level[1] - m, level[1] + 1):
               res = min(res, self.dijkstra(n, i, i + m, level, g))
          return res                
          
if __name__ == "__main__":
     print(Solution().process())