638. 大礼包

在LeetCode商店中，有许多在售的物品。

然而，也有一些大礼包，每个大礼包以优惠的价格捆绑销售一组物品。

现给定每个物品的价格，每个大礼包包含物品的清单，以及待购物品清单。请输出确切完成待购清单的最低花费。

每个大礼包的由一个数组中的一组数据描述，最后一个数字代表大礼包的价格，其他数字分别表示内含的其他种类物品的数量。

任意大礼包可无限次购买。

示例 1:

输入: [2,5], [[3,0,5],[1,2,10]], [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:

输入: [2,3,4], [[1,1,0,4],[2,2,1,9]], [1,2,1]
输出: 11
解释: 
A，B，C的价格分别为¥2，¥3，¥4.
你可以用¥4购买1A和2B，也可以用¥9购买2A，2B和1C。
你需要买1A，2B和1C，所以你付了¥4买了1A和1B（大礼包1），以及¥3购买1B， ¥4购买1C。
你不可以购买超出待购清单的物品，尽管购买大礼包2更加便宜。

说明:

最多6种物品， 100种大礼包。
每种物品，你最多只需要购买6个。
你不可以购买超出待购清单的物品，即使更便宜。

=====================================================================

解题思路: 递归,DFS,DP

6种商品,最多购买6个,我们需要的备忘录结构可以为简化为 map<int><int>

假设needs=[3,2,5], map的key为325,value为买[3,2,5]花的最少的金额

每当我们购买一个大礼包,减去needs对应数量值,再进行递归

代码很好理解可以看一下

class Solution {
    private Map<Integer,Integer> dp =null;
    {
        dp=new HashMap<>();
        dp.put(0,0);
    }
    public int shoppingOffers(List<Integer> price, List<List<Integer>> special, List<Integer> needs) {
        int need =0;
        int maxPrice =0;
        for (int i = 0; i < needs.size(); i++) {
            need+=Math.pow(10, needs.size()-i-1)*needs.get(i);
            maxPrice+=price.get(i)*needs.get(i);
        }
        if (dp.get(need)!=null){
            return dp.get(need);
        }
        int lbsize  = special.size();
        int jgsize  = price.size();
        //遍历所有礼包
        flag:for (int i = 0; i < lbsize; i++) {
            //判断是否超买
            List<Integer> temp = new ArrayList<>();
            for (int j = 0; j < jgsize; j++) {
                temp.add(j,needs.get(j)-special.get(i).get(j));
                if (needs.get(j)-special.get(i).get(j)<0){
                    continue flag;
                }
            }
            //可以买
            maxPrice = Math.min(maxPrice,special.get(i).get(jgsize)+shoppingOffers(price,special,temp));
        }
        dp.put(need,maxPrice);
        return maxPrice;
    }
}

虽然这个53个测试用例用了17ms但是,还是有些大佬代码太牛批

今天没时间看了,明天看看,贴一下他7ms的代码

public class Solution {
    int res;
    public int shoppingOffers(List<Integer> price, List<List<Integer>> special, List<Integer> needs) {
        for(int i=0;i<needs.size();i++){
            this.res+=price.get(i)*needs.get(i);
        }
            dig(price,special,needs,0,0);
        return this.res;
    }
    public void dig(List<Integer> price,List<List<Integer>> special,List<Integer> needs,int index,int total){
        if(index<=special.size()-1){
            List<Integer> offer=special.get(index);
            boolean valid=true;
            List<Integer> newNeed=new ArrayList<Integer>();
            for(int j=0;j<needs.size();j++){
                if(offer.get(j)>needs.get(j)){
                    valid=false;
                    break;
                }
                else{
                    newNeed.add(needs.get(j)-offer.get(j));
                }
            }
            if(valid){
                int temp=offer.get(offer.size()-1);
                if(total+temp<this.res){
                   dig(price,special,newNeed,index,total+temp); 
                }
            }
            dig(price,special,needs,index+1,total);
            
        }
        else{
            int temp=0;
            for(int i=0;i<needs.size();i++){
                temp+=needs.get(i)*price.get(i);
            }
            temp=temp+total;
            this.res=temp<this.res?temp:this.res;
        }
         
    }
}

猜你喜欢