leetcode 1774. 最接近目标价格的甜点成本

题目链接–>最接近目标价格的甜点成本

示例 1：

输入：baseCosts = [1,7], toppingCosts = [3,4], target = 10
输出：10
解释：考虑下面的方案组合（所有下标均从 0 开始）：

• 选择 1 号基料：成本 7
• 选择 1 份 0 号配料：成本 1 x 3 = 3
• 选择 0 份 1 号配料：成本 0 x 4 = 0
  总成本：7 + 3 + 0 = 10 。

示例 2：

输入：baseCosts = [2,3], toppingCosts = [4,5,100], target = 18
输出：17
解释：考虑下面的方案组合（所有下标均从 0 开始）：

• 选择 1 号基料：成本 3
• 选择 1 份 0 号配料：成本 1 x 4 = 4
• 选择 2 份 1 号配料：成本 2 x 5 = 10
• 选择 0 份 2 号配料：成本 0 x 100 = 0
  总成本：3 + 4 + 10 + 0 = 17 。不存在总成本为 18 的甜点制作方案。

示例 3：

输入：baseCosts = [3,10], toppingCosts = [2,5], target = 9
输出：8
解释：可以制作总成本为 8 和 10 的甜点。返回 8 ，因为这是成本更低的方案。

方案一：暴力深搜+剪枝
不断地累加并与target比较

代码一：

class Solution {
public:
    int m, n;
    vector<int> used;  //记录toppingCosts索引项的使用次数
    int res = 100000;  //结果
    int dif = 100000;  //与target的差值
    int closestCost(vector<int>& baseCosts, vector<int>& toppingCosts, int target) {
        n = baseCosts.size();
        m = toppingCosts.size();
        used.resize(m, 0);
        for(int i=0; i<n; i++){
            dfs(toppingCosts, baseCosts[i], target);
        }
        return res;
    }
    
    void dfs(vector<int>& toppingCosts, int sum, int target){
        int cur = abs(sum - target);
        if(dif >= cur){
            //差值相等时，取最小结果
            if(dif == cur && sum > res) return;
            res = sum;
            dif = cur;
        }
        //剪枝，如果已经大于target，上述代码已进行比较，没必要再去检查更大的值了
        if(sum > target) return;

        for(int i=0; i<toppingCosts.size(); i++){
            //使用了2次，就不能再使用，跳过
            if(used[i] == 2) continue;
            used[i]++;
            dfs(toppingCosts, sum + toppingCosts[i], target);
            //回溯
            used[i]--;
        } 
    }
};

代码二：

class Solution {
public:
    int res = INT_MAX;
    int closestCost(vector<int>& baseCosts, vector<int>& toppingCosts, int target) {
        for(int base: baseCosts){
            dfs(toppingCosts, 0, base, target);
        }
        return res;
    }
    
    //cur指向toppingCosts的索引位置，代表深搜的层数
    void dfs(vector<int>& toppingCosts, int cur, int cost, int target){
        //更新最小花费
        if(abs(target-cost) < abs(target-res)
          //相等时，取较小者
          ||(abs(target-cost) == abs(target-res) && cost<res)){
            res = cost;
        }
        //剪枝，
        if(cost >= target||cur == toppingCosts.size()){
            return;
        }
        //3种情况，+0倍，+1倍， +2倍
        dfs(toppingCosts, cur+1, cost, target);
        dfs(toppingCosts, cur+1, cost+toppingCosts[cur], target);
        dfs(toppingCosts, cur+1, cost+2*toppingCosts[cur], target);
    }
};

方法二：动态规划 0-1背包
（题解大佬的代码拿来用）
把每一种基料和其余配料累加出所有值，并做标记，然后从这些值中搜索更新

class Solution {
public:
    //将所有可能凑成的数字标记，每一种配料最多出现2次，且<10000, 假如10个数字全为10000，
    //最大值为10*10000*2 = 20000；
    int closestCost(vector<int>& baseCosts, vector<int>& toppingCosts, int target) {
        vector<bool> can(20001);
        for (int base : baseCosts)
            can[base] = true;
        //扩充为2倍，每个元素最多可使用两次
        toppingCosts.insert(toppingCosts.end(), toppingCosts.begin(), toppingCosts.end());
        
        for (int topping : toppingCosts) {
            //从后向前将所有符合的数字标记
            for (int i = 20000; i >= topping; --i)
                can[i] = can[i] || can[i - topping];
        }
        int min_gap = INT_MAX, ans = 0;
        for (int i = 1; i <= 20000; ++i){
            //如果此数可用，比较得到最小值
            if (can[i] && abs(i - target) < min_gap) {
                ans = i;
                min_gap = abs(i - target);
            }
        }
        return ans;
    }
};