leetcode 638. Shopping Offers（购物优惠）

In LeetCode Store, there are some kinds of items to sell. Each item has a price.

However, there are some special offers, and a special offer consists of one or more different kinds of items with a sale price.

You are given the each item’s price, a set of special offers, and the number we need to buy for each item. The job is to output the lowest price you have to pay for exactly certain items as given, where you could make optimal use of the special offers.

Each special offer is represented in the form of an array, the last number represents the price you need to pay for this special offer, other numbers represents how many specific items you could get if you buy this offer.

You could use any of special offers as many times as you want.

Example 1:
Input: [2,5], [[3,0,5],[1,2,10]], [3,2]
Output: 14
Explanation:
There are two kinds of items, A and B. Their prices are $2 and $5 respectively.
In special offer 1, you can pay $5 for 3A and 0B
In special offer 2, you can pay $10 for 1A and 2B.
You need to buy 3A and 2B, so you may pay $10 for 1A and 2B (special offer #2), and $4 for 2A.
Example 2:
Input: [2,3,4], [[1,1,0,4],[2,2,1,9]], [1,2,1]
Output: 11
Explanation:
The price of A is $2, and $3 for B, $4 for C.
You may pay $4 for 1A and 1B, and $9 for 2A ,2B and 1C.
You need to buy 1A ,2B and 1C, so you may pay $4 for 1A and 1B (special offer #1), and $3 for 1B, $4 for 1C.
You cannot add more items, though only $9 for 2A ,2B and 1C.
Note:
There are at most 6 kinds of items, 100 special offers.
For each item, you need to buy at most 6 of them.
You are not allowed to buy more items than you want, even if that would lower the overall price.

题目很长，大概意思是input有3部分，第一部分是price数组，里面有每个物品的价格，第2部分是2维数组special，里面每个一维数组是price中对应的每个物品的数量，最后一个是买前面那些物品的总价格，会比直接买那些要便宜。第3部分的数组是我们的任务，要每个物品买几个。
不能多买，special部分的优惠可以重复利用。

思路：
DFS
先算直接原价买需要的物品要多少钱，然后再一个个试那些special的优惠，看是不是比直接买便宜。如果special中的物品超过了我们要买的量，那就不能用了。
每次用special时要从needs中减掉special的部分，出了DFS后再把那些needs还原回去。

//30ms
    public int shoppingOffers(List<Integer> price, List<List<Integer>> special, List<Integer> needs) {
        if(price == null || special == null || needs == null) {
            return 0;
        }
        
        int result = 0;        
        
        for(int i = 0; i < needs.size(); i ++) {
            result += price.get(i) * needs.get(i);
        }
        
        for(int i = 0; i < special.size(); i++) {
            boolean bValid = true;
            for(int j = 0; j < needs.size(); j++) {
                if(needs.get(j) < special.get(i).get(j)) {
                    bValid = false;
                }
                needs.set(j, needs.get(j) - special.get(i).get(j));
            }
            if(bValid) {
                result = Math.min(result, shoppingOffers(price, special, needs) 
                                  + special.get(i).get(special.get(i).size()-1));
            }
            for(int j = 0; j < needs.size(); j++) {
                needs.set(j, needs.get(j) + special.get(i).get(j));
            }
        }
        
        return result;
    }

上面的方法有可以优化的地方，比如needs全是0的时候就不需要再计算了，直接返回现有的价格。
还有当needs中有的物品达不到special中的时候，这个special就可以跳过，不需要再做从needs中去掉special物品然后再还原这一步。
注意这里的result是在原有的价格上增加的部分，所以传入下一步迭代时不需要把现有的cur加进去。
这样可提高到1ms

//1ms
    public int shoppingOffers(List<Integer> price, List<List<Integer>> special, List<Integer> needs) {
        if(price == null || special == null || needs == null) {
            return 0;
        }
        
        return helper(price, special, needs, 0, 0);
    }
    
    int helper(List<Integer> price, List<List<Integer>> special, List<Integer> needs, int cur
        , int index) {
        
        boolean zeroNeeds = true;
        int size = needs.size();
        int result = 0;
        
        for(int i = 0; i < needs.size(); i++) {
            if(needs.get(i) > 0) {
                zeroNeeds = false;
                result += price.get(i) * needs.get(i);
            }
        }
        if(zeroNeeds) {
            return cur;
        }
        
        for(int i = index; i < special.size(); i++) {
            boolean valid = true;
            for(int j = 0; j < needs.size(); j++) {
                if(needs.get(j) < special.get(i).get(j)) {
                    valid = false;
                    break;
                }
            }
            if(valid) {
                for(int j = 0; j < needs.size(); j++) {
                    needs.set(j, needs.get(j) - special.get(i).get(j));
                }
                
                result = Math.min(result, helper(price, special, needs, 
                                                 special.get(i).get(size), i));
                
                for(int j = 0; j < needs.size(); j++) {
                    needs.set(j, needs.get(j) + special.get(i).get(j));
                }
            }           
        }
        
        return cur+result;
    }