在 LeetCode 商店中， 有 n 件在售的物品。每件物品都有对应的价格。然而，也有一些大礼包，每个大礼包以优惠的价格捆绑销售一组物品。
给你一个整数数组 price 表示物品价格，其中 price[i] 是第 i 件物品的价格。另有一个整数数组 needs 表示购物清单，其中 needs[i] 是需要购买第 i 件物品的数量。
还有一个数组 special 表示大礼包，special[i] 的长度为 n + 1 ，其中 special[i][j] 表示第 i 个大礼包中内含第 j 件物品的数量，且 special[i][n] （也就是数组中的最后一个整数）为第 i 个大礼包的价格。
返回 确切 满足购物清单所需花费的最低价格，你可以充分利用大礼包的优惠活动。你不能购买超出购物清单指定数量的物品，即使那样会降低整体价格。任意大礼包可无限次购买。
示例 1：
输入：price = [2,5], special = [[3,0,5],[1,2,10]], needs = [3,2] 输出：14 解释：有 A 和 B 两种物品，价格分别为 ¥2 和 ¥5 。 大礼包 1 ，你可以以 ¥5 的价格购买 3A 和 0B 。 大礼包 2 ，你可以以 ¥10 的价格购买 1A 和 2B 。 需要购买 3 个 A 和 2 个 B ， 所以付 ¥10 购买 1A 和 2B（大礼包 2），以及 ¥4 购买 2A 。
示例 2：
输入：price = [2,3,4], special = [[1,1,0,4],[2,2,1,9]], needs = [1,2,1] 输出：11 解释：A ，B ，C 的价格分别为 ¥2 ，¥3 ，¥4 。 可以用 ¥4 购买 1A 和 1B ，也可以用 ¥9 购买 2A ，2B 和 1C 。 需要买 1A ，2B 和 1C ，所以付 ¥4 买 1A 和 1B（大礼包 1），以及 ¥3 购买 1B ， ¥4 购买 1C 。 不可以购买超出待购清单的物品，尽管购买大礼包 2 更加便宜。
思路
动态规划，这里只有 special 数组是需要考虑的特殊变量，可以把 大礼包 也看成是产品，price 数组最后额外加钱就可以了。
- dp数组，dp[i][n] 表示买 i 个第 n 号商品的最小价格
- 初始条件和状态转移这里卡住了
问了问 gpt ，提供了一个反向思考的思路：
- 用一个
dp数组，其中dp[i]表示为了满足需要needs的当前状态i的最小花费。 - 对于每一种物品组合状态
i（例如needs的当前状态），首先计算直接购买所有物品的价格：
cost = sum(price[j] * needs[j] for j in range(n))
dp[i] = min(dp[i], cost)
- 然后遍历所有大礼包，检查当前状态能否使用大礼包。如果可以，则更新最小花费：
for sp in special:
new_needs = needs[:]
for j in range(n):
new_needs[j] -= sp[j]
if all(x >= 0 for x in new_needs): # 检查新需求是否有效
dp[i] = min(dp[i], sp[n] + dp[tuple(new_needs)])
结果发现这似乎不是一道 dp 的问题，而是用深搜来解决，深搜使用大礼包来寻找最优解。同样的先计算按照原价购买所有商品的价格，然后再用深搜判断使用大礼包是否能够减少价格。但是其实和 dp 的想法一致，只不过用 memo 字典代表 dp，字典 key 用一个 list 表示，这个 list 为一个需求状态。用 dp 来解释就是 dp[i] 代表了 i 装填的 min_cost，而 i 是一个 list 表示一个 needs 情况。
代码（Python）
class Solution(object):
def shoppingOffers(self, price, special, needs):
"""
:type price: List[int]
:type special: List[List[int]]
:type needs: List[int]
:rtype: int
"""
n = len(price)
memo = {} # 手动构建缓存
def dfs(needs):
# 将需求状态转化为元组，以便作为字典的键
needs_tuple = tuple(needs)
# 如果已经计算过该需求组合的最小花费，则直接返回
if needs_tuple in memo:
return memo[needs_tuple]
# 如果直接购买所有物品的价格
min_cost = sum(needs[i] * price[i] for i in range(n))
# 尝试使用每个大礼包
for sp in special:
new_needs = []
for i in range(n):
if needs[i] < sp[i]: # 如果大礼包内物品数量超过需求，跳过该大礼包
break
new_needs.append(needs[i] - sp[i])
else: # 如果所有需求都满足，则计算使用该大礼包后的最小花费
min_cost = min(min_cost, sp[-1] + dfs(new_needs))
# 将当前需求组合的最小花费存入缓存
memo[needs_tuple] = min_cost
return min_cost
# 从初始需求开始递归计算最小花费
return dfs(needs)
sp[-1] 表示大礼包 sp 的最后一个元素，即该大礼包的价格。在 special 数组中，每个大礼包的信息格式是 [商品1的数量, 商品2的数量, ..., 大礼包价格]，所以 sp[-1] 取的是大礼包的价格部分。
至于是否考虑了大礼包可以无限次购买的情况，答案是是的。在代码中，通过递归调用 dfs(new_needs) 来反复尝试使用同一个大礼包。如果当前需求 needs 满足使用某个大礼包的条件，那么会更新需求并继续递归地尝试购买，直到需求不足以使用该大礼包为止。所以，这种递归结构自然允许大礼包的多次使用，直到需求被满足或无效为止。
在这个代码片段中：
for sp in special:
new_needs = []
for i in range(n):
if needs[i] < sp[i]: # 如果大礼包内物品数量超过需求，跳过该大礼包
break
new_needs.append(needs[i] - sp[i])
else: # 如果所有需求都满足，则计算使用该大礼包后的最小花费
min_cost = min(min_cost, sp[-1] + dfs(new_needs))
这个 else 是与内层的 for 循环配对的，而不是 if 语句。Python 的 for-else 结构在此处的作用是：
- 当内层的
for循环遍历完range(n)的所有元素时，才会执行else中的代码块。 - 如果内层
for循环因为break语句提前退出（即发现大礼包的物品数量超过需求），则else部分不会执行。
代码（C++）
#include<unordered_map>
#include<vector>
class Solution {
private:
// 定义自定义哈希函数
struct VectorHash {
size_t operator()(const vector<int>& vec) const {
size_t hash = 0;
for (int num : vec) {
hash ^= hash * 31 + std::hash<int>{}(num);
}
return hash;
}
};
public:
unordered_map<vector<int>, int, VectorHash> memo;
int dfs(const vector<int>& price, const vector<vector<int>>& special, vector<int> needs) {
if (memo.find(needs) != memo.end()) {
return memo[needs];
}
int n = price.size();
int min_cost = 0;
for (int i = 0; i < n; ++i) {
min_cost += price[i] * needs[i];
}
for (const auto& sp : special) {
vector<int> new_needs = needs;
bool valid = true;
for (int i = 0; i < n; ++i) {
if (new_needs[i] < sp[i]) {
valid = false;
break;
}
new_needs[i] -= sp[i];
}
if (valid) {
min_cost = std::min(min_cost, sp.back() + dfs(price, special, new_needs));
}
}
memo[needs] = min_cost;
return min_cost;
}
int shoppingOffers(vector<int>& price, vector<vector<int>>& special, vector<int>& needs) {
memo.clear();
int minn_cost = dfs(price, special, needs);
return minn_cost;
}
};C++ 中无法直接在哈希表中用列表作为键，需要自定义哈希函数。
// 定义自定义哈希函数
struct VectorHash {
size_t operator()(const vector<int>& vec) const {
size_t hash = 0;
for (int num : vec) {
hash ^= hash * 31 + std::hash<int>{}(num);
}
return hash;
}
};- VectorHash: 这是一个自定义的哈希函数，专门为
vector<int>类型设计。它遍历vector中的每个元素，并生成一个组合哈希值。 - unordered_map<vector<int>, int, VectorHash>: 将
VectorHash作为哈希函数传递给unordered_map，从而使vector<int>可以作为键来存储和查找。
通过这个改动，编译器就可以正确地为 Solution 类生成默认构造函数，因为 unordered_map 可以正常工作，不再依赖于 std::hash<vector<int>>。
VectorHash 结构体 - 能够将 vector 转换成 size_t 类型的哈希值键
VectorHash 结构体定义了一个自定义哈希函数，用于 std::vector<int> 类型。这是因为 std::unordered_map 需要可哈希的键，但 std::vector<int> 并没有内置的哈希函数。以下是对该函数的总结：
-
目的：
VectorHash提供了一种计算std::vector<int>哈希值的方法，使其能够用作std::unordered_map的键。 -
operator()：该结构体重载了函数调用运算符，使其可以像函数一样使用。它接受一个const vector<int>&参数，并返回一个size_t类型的哈希值。 -
哈希计算：
- 初始化一个
size_t类型的变量hash为零。 - 遍历向量中的每个整数
num，使用公式hash ^= hash * 31 + std::hash<int>{}(num)更新哈希值。std::hash<int>{}(num)计算num的哈希值。hash * 31用于分散哈希值，减少冲突。- 使用
^=（按位异或赋值）将当前哈希值与新计算的值结合。
- 初始化一个
-
返回值：处理完所有元素后，返回最终的哈希值，表示整个向量的哈希。
使用示例
通过定义 VectorHash，可以将 std::vector<int> 作为 unordered_map 的键。例如：
std::unordered_map<std::vector<int>, int, VectorHash> memo;
std::vector<int> vec = {1, 2, 3};
memo[vec] = 42; // 可以使用 VectorHash
这样，unordered_map 就能够根据向量的内容正确存储和检索值。没有 VectorHash，编译将会失败，因为 unordered_map 不知道如何哈希 std::vector<int>。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
