LC638. 大礼包_大礼包在商店中, 有 n 件在售的物品。每件物品都有对应的价格。然而,也有一-优快云博客

本文链接：https://blog.youkuaiyun.com/min_coder/article/details/120940042

题目

在 LeetCode 商店中，有 n 件在售的物品。每件物品都有对应的价格。然而，也有一些大礼包，每个大礼包以优惠的价格捆绑销售一组物品。

给你一个整数数组 price 表示物品价格，其中 price[i] 是第 i 件物品的价格。另有一个整数数组 needs 表示购物清单，其中 needs[i] 是需要购买第 i 件物品的数量。

还有一个数组 special 表示大礼包，special[i] 的长度为 n + 1 ，其中 special[i][j] 表示第 i 个大礼包中内含第 j 件物品的数量，且 special[i][n] （也就是数组中的最后一个整数）为第 i 个大礼包的价格。

返回确切满足购物清单所需花费的最低价格，你可以充分利用大礼包的优惠活动。你不能购买超出购物清单指定数量的物品，即使那样会降低整体价格。任意大礼包可无限次购买。

n == price.length
n == needs.length
1 <= n <= 6
0 <= price[i] <= 10
0 <= needs[i] <= 10
1 <= special.length <= 100
special[i].length == n + 1
0 <= special[i][j] <= 50

思路

这种组合题需要对所有有效的礼包进行遍历组合
因此为避免超时，应先采用排除法将所有不符合的礼包排除：

没有原价实惠的礼包
礼包内第i个物品数量超过购买需求量

为实现组合情况，需采用深度优先搜索（dfs）【可以结合树的分支考虑每一次情况】:

对于每一次遍历，为每个有效礼包建立一个分支。即每次都考虑有效礼包的所有选择情况
对于每个礼包，依然需要考虑购买需求量。并且每次向下dfs传递时，需传递这次购买礼包后剩余的购买需求
如果某礼包某产品超出购买力度，不考虑其礼包的向下传递
建立到树叶子，没有礼包可以购买时，回溯依次相加每一次礼包金额，然后判断最小值

在搜索过程中，对于不同分支可能会出现剩余购买力重复的情况，此时可以通过记忆化搜索来降低时间复杂度。具体步骤为：

建立一个哈希映射
对于每次的情况进行记录其运算结果
若发现已经存储的情况，直接返回其结果即可

数据量越大，记忆化搜索带来的效果越好。

代码

class Solution {
public:
    vector<vector<int>> ans;
    int ans_len;
    int n;
    int minn;
    map<vector<int>, int> dp;
    int shoppingOffers(vector<int>& price, vector<vector<int>>& special, vector<int>& needs) {
        n=price.size();
        //直接购买费用
        for(int i=0;i<n;i++) minn+=price[i]*needs[i];
        //排除不符合礼包
        for(int i=0;i<special.size();i++){
            int f=1, count=0;
            for(int j=0;j<n;j++){
                if(special[i][j]>needs[j]) f=0;
                count+=special[i][j]*price[j];
            }
            if(f&&count>special[i][n]) ans.push_back(special[i]);
        }
        ans_len=ans.size();
        //有符合礼包再进行遍历
        if(ans_len) return dfs(price, ans, needs);
        return minn;
    }
    int dfs(vector<int>& price, vector<vector<int>>& ans, vector<int> needs){
    	//
        if (dp.count(needs) != 0)
            return dp[needs];
        int Min=0;
        for(int i=0;i<n;i++){
           Min+=price[i]*needs[i]; 
        }
        for(int i=0;i<ans_len;i++){
            vector<int> need;
            for(int j=0;j<n;j++){
                if(needs[j]<ans[i][j]) break;
                need.push_back(needs[j]-ans[i][j]);
            }
            if(need.size()==n) Min = min(Min, dfs(price, ans, need)+ans[i][n]); 
        }
        return dp[needs] = Min;
    }