【1774.最接近目标价格的甜点成本】-创新互联

来源：力扣（LeetCode）

描述：

你打算做甜点，现在需要购买配料。目前共有 n 种冰激凌基料和 m 种配料可供选购。而制作甜点需要遵循以下几条规则：

• 必须选择 一种 冰激凌基料。
• 可以添加 一种或多种 配料，也可以不添加任何配料。
• 每种类型的配料 最多两份 。

给你以下三个输入：

• baseCosts，一个长度为n的整数数组，其中每个baseCosts[i]表示第i种冰激凌基料的价格。
• toppingCosts，一个长度为m的整数数组，其中每个toppingCosts[i]表示 一份 第i种冰激凌配料的价格。
• target，一个整数，表示你制作甜点的目标价格。

你希望自己做的甜点总成本尽可能接近目标价格target。

返回最接近target的甜点成本。如果有多种方案，返回 成本相对较低 的一种。

示例 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 ，因为这是成本更低的方案。

示例 4：

输入：baseCosts = [10], toppingCosts = [1], target = 1
输出：10
解释：注意，你可以选择不添加任何配料，但你必须选择一种基料。

提示：

• n == baseCosts.length
• m == toppingCosts.length
• 1<= n, m<= 10
• 1<= baseCosts[i], toppingCosts[i]<= 10⁴
• 1<= target<= 10⁴

方法一：回溯

思路与算法

  首先题目给出长度分别为 n 的冰淇淋基料数组 baseCosts 和长度为 m 的配料数组 toppingCosts ，其中 baseCosts[i] 表示第 i 种冰淇淋基料的价格，toppingCosts[j] 表示一份第 j 种冰淇淋配料的价格，以及一个整数 target 表示我们需要制作甜点的目标价格。现在在制作甜品上我们需要遵守以下三条规则：

• 必须选择一种冰淇淋基料；
• 可以添加一种或多种配料，也可以不添加任何配料；
• 每种配料最多两份。

  我们希望做的甜点总成本尽可能接近目标价格 target ，那么我们现在按照规则对于每一种冰淇淋基料用回溯的方式来针对它进行甜品制作。又因为每一种配料都是正整数，所以在回溯的过程中总开销只能只增不减，当回溯过程中当前开销大于目标价格 target 后，继续往下搜索只能使开销与 target 的差值更大，所以如果此时差值已经大于等于我们已有最优方案的差值，我们可以停止继续往下搜索，及时回溯。

代码:

class Solution {public:
    void dfs(const vector& toppingCosts, int p, int curCost, int& res, const int& target) {if (abs(res - target)< curCost - target) {return;
        } else if (abs(res - target) >= abs(curCost - target)) {if (abs(res - target) >abs(curCost - target)) {res = curCost;
            } else {res = min(res, curCost);
            }
        }
        if (p == toppingCosts.size()) {return;
        }
        dfs(toppingCosts, p + 1, curCost + toppingCosts[p] * 2, res, target);
        dfs(toppingCosts, p + 1, curCost + toppingCosts[p], res, target);
        dfs(toppingCosts, p + 1, curCost, res, target);
    }

    int closestCost(vector& baseCosts, vector& toppingCosts, int target) {int res = *min_element(baseCosts.begin(), baseCosts.end());
        for (auto& b : baseCosts) {dfs(toppingCosts, 0, b, res, target);
        }
        return res;
    }
};

复杂度分析
时间复杂度：O(n×3^m)，其中 nnn，mmm 分别为数组 baseCosts，toppingCosts 的长度。
空间复杂度：O(m)，主要为回溯递归的空间开销。

方法二：动态规划

思路与算法

  我们可以将问题转化为对于某一个开销是否存在甜品制作方案问题，然后我们选择与目标价格最接近的合法甜品制作方案即可，那么问题就转化为了「01 背包」问题（关于「01 背包」的概念可见 百度百科）。这样我们就可以把问题求解从指数级别降到多项式级别了。对于「01 背包」的求解我们可以用「动态规划」来解决。

  设最小的基料开销为 x。若 x ≥ target ，则无论我们是否添加配料都不会使甜品制作的开销与目标价格 target 的距离缩小，所以此时直接返回此最小的基料开销即可。当最小的基料开销小于 target 时，我们可以对超过 target 的制作开销方案只保存其最小的一份即可，并可以初始化为 2 × target − x ，因为大于该开销的方案与目标价格 target 的距离一定大于仅选最小基料的情况，所以一定不会是最优解。将背包的容量 MAXC 设置为 target 。然后我们按「01 背包」的方法来依次枚举配料来进行放置。

  我们设 can[i] 表示对于甜品制作开销为 i 是否存在合法方案，如果存在则其等于 true，否则为 false，初始为 false。因为单独选择一种基料的情况是合法的，所以我们对 can 进行初始化：

  然后我们按「01 背包」的方法来依次枚举配料来进行放置，因为每种配料我们最多只能选两份，所以我们可以直接将每种配料变为两个，然后对于两个配料都进行放置即可。因为任意一个合法方案加上一份配料一定也为合法制作方案。所以当要放置的配料开销为 y 时，对于开销为 c, c >y 的转移方程为：

  因为每一个状态的求解只和前面的状态有关，所以我们可以从后往前来更新每一个状态。然后当配料全部放置后，我们可以从目标价格 target 往左搜索找到最接近 target 的合法方案并与大于 target 的方案做比较返回与 target 更接近的方案即可。

代码:

class Solution {public:
    int closestCost(vector& baseCosts, vector& toppingCosts, int target) {int x = *min_element(baseCosts.begin(), baseCosts.end());
        if (x >= target) {return x;
        }
        vectorcan(target + 1, false);
        int res = 2 * target - x;
        for (auto& b : baseCosts) {if (b<= target) {can[b] = true;
            } else {res = min(res, b);
            }
        }
        for (auto& t : toppingCosts) {for (int count = 0; count< 2; ++count) {for (int i = target; i; --i) {if (can[i] && i + t >target) {res = min(res, i + t);
                    }
                    if (i - t >0) {can[i] = can[i] | can[i - t];
                    }
                }
            }
        }
        for (int i = 0; i<= res - target; ++i) {if (can[target - i]) {return target - i;
            }
        }
        return res;
    }
};

复杂度分析
时间复杂度：O(target × m) ，其中 m 为数组 toppingCosts 的长度，target 为目标值。动态规划的时间复杂度是 O(MAXC × m) ，由于 MAXC = target ，因此时间复杂度是 O(target × m) 。
空间复杂度：O(target) ，其中 target 为目标值。需要创建长度为 target + 1 的数组 can。
author：力扣官方题解

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧