ShoppingOffers

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:

1. There are at most 6 kinds of items, 100 special offers.
2. For each item, you need to buy at most 6 of them.
3. You are not allowed to buy more items than you want, even if that would lower the overall price.

import java.util.ArrayList;
    import java.util.List;

    /**
     * Created by qmq
     * 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.
     * 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.*
     *
     * @ 18-10-8
     **/
    class Solution6 {

        boolean checkvalid(List<Integer> needs, List<Integer> special) {
            for (int j = 0; j < needs.size(); ++j) {
                if (needs.get(j) < special.get(j)) {
                    return false;
                }
            }
            return true;
        }

        public int shoppingOffers(List<Integer> price, List<List<Integer>> special, List<Integer> needs) {

            int minPrice = 0;
            for (int i = 0; i < needs.size(); ++i) {
                //不使用折扣方案的价格
                minPrice += needs.get(i) * price.get(i);
            }

            for (int i = 0; i < special.size(); ++i) {
                if (checkvalid(needs, special.get(i))) {
                    //校验是否符合每个需求量大于优惠方案数量，若均不符合则直接使用不折扣方案
                    List<Integer> curNeeds = new ArrayList<>();
                    for (int j = 0; j < needs.size(); ++j) {
                        curNeeds.add(needs.get(j) - special.get(i).get(j));         // 子需求量 = 当前需求量-方案提供量
                    }
                    int tempPrice = shoppingOffers(price, special, curNeeds) + special.get(i).get(needs.size());
                    //子方案递归选择+当前方案金额
                    minPrice = Math.min(minPrice, tempPrice);
                    //获取最低价格，可能不使用折扣方案更便宜
                }
            }
            return minPrice;
        }
    }

需要注意的是可能存在方案数量超出和方案组合并不优惠的情况，所以每次需要加入Math.min(minPrice,tempPrice)的判断和checkValid(needs,special.get(i))，对于选择方案剩余后的继续递归判断，是否能继续使用方案。所以递归的时候需要注意每次执行时的判断条件。

class Solution
{
  public:
    bool checkvalid(vector<int> &needs, const vector<int> &special)
    { //检查当前需求数量若均大于折扣方案数量，则可以使用该折扣方案
        for (int j = 0; j < needs.size(); ++j)
        {
            if (needs[j] < special[j])
            {
                return false;
            }
        }
        return true;
    }
    int shoppingOffers(vector<int> &price, vector<vector<int>> &special, vector<int> &needs)
    {
        int minPrice = 0;
        for (int i = 0; i < needs.size(); ++i)
        { //不使用折扣方案的价格
            minPrice += needs[i] * price[i];
        }
        for (int i = 0; i < special.size(); ++i)
        {
            if (checkvalid(needs, special[i]))
            {
                vector<int> curNeeds;
                for (int j = 0; j < needs.size(); ++j)
                {
                    curNeeds.push_back(needs[j] - special[i][j]);
                }
                int tempPrice = shoppingOffers(price, special, curNeeds) + special[i][needs.size()]; //递归调用剩下的需求数量的最低买价方案
                minPrice = min(minPrice, tempPrice);                                                 //获取最低价格，可能不使用折扣方案更便宜
            }
        }
        return minPrice;
    }
};