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

Raphael Liu Lv10
  2023-09-13 00:47:26 2023-09-13 00:47:26 Created   2023-09-13 16:06:25 2023-09-13 16:06:25 Updated    

你打算做甜点，现在需要购买配料。目前共有 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] <= 104
  • 1 <= target <= 104

方法一：回溯

思路与算法

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

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

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

代码

[sol1-Python3]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Solution:
    def closestCost(self, baseCosts: List[int], toppingCosts: List[int], target: int) -> int:
        ans = min(baseCosts)
        def dfs(p: int, cur_cost: int) -> None:
            nonlocal ans
            if abs(ans - target) < cur_cost - target:
                return
            if abs(ans - target) >= abs(cur_cost - target):
                if abs(ans - target) > abs(cur_cost - target):
                    ans = cur_cost
                else:
                    ans = min(ans, cur_cost)
            if p == len(toppingCosts):
                return
            dfs(p + 1, cur_cost + toppingCosts[p] * 2)
            dfs(p + 1, cur_cost + toppingCosts[p])
            dfs(p + 1, cur_cost)
        for c in baseCosts:
            dfs(0, c)
        return ans
[sol1-C++]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Solution {
public:
    void dfs(const vector<int>& 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<int>& baseCosts, vector<int>& toppingCosts, int target) {
        int res = *min_element(baseCosts.begin(), baseCosts.end());
        for (auto& b : baseCosts) {
            dfs(toppingCosts, 0, b, res, target);
        }
        return res;
    }
};
[sol1-Java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Solution {
    int res;

    public int closestCost(int[] baseCosts, int[] toppingCosts, int target) {
        res = Arrays.stream(baseCosts).min().getAsInt();
        for (int b : baseCosts) {
            dfs(toppingCosts, 0, b, target);
        }
        return res;
    }

    public void dfs(int[] toppingCosts, int p, int curCost, int target) {
        if (Math.abs(res - target) < curCost - target) {
            return;
        } else if (Math.abs(res - target) >= Math.abs(curCost - target)) {
            if (Math.abs(res - target) > Math.abs(curCost - target)) {
                res = curCost;
            } else {
                res = Math.min(res, curCost);
            }
        }
        if (p == toppingCosts.length) {
            return;
        }
        dfs(toppingCosts, p + 1, curCost + toppingCosts[p] * 2, target);
        dfs(toppingCosts, p + 1, curCost + toppingCosts[p], target);
        dfs(toppingCosts, p + 1, curCost, target);
    }
}
[sol1-C#]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class Solution {
    int res;

    public int ClosestCost(int[] baseCosts, int[] toppingCosts, int target) {
        res = baseCosts.Min();
        foreach (int b in baseCosts) {
            DFS(toppingCosts, 0, b, target);
        }
        return res;
    }

    public void DFS(int[] toppingCosts, int p, int curCost, int target) {
        if (Math.Abs(res - target) < curCost - target) {
            return;
        } else if (Math.Abs(res - target) >= Math.Abs(curCost - target)) {
            if (Math.Abs(res - target) > Math.Abs(curCost - target)) {
                res = curCost;
            } else {
                res = Math.Min(res, curCost);
            }
        }
        if (p == toppingCosts.Length) {
            return;
        }
        DFS(toppingCosts, p + 1, curCost + toppingCosts[p] * 2, target);
        DFS(toppingCosts, p + 1, curCost + toppingCosts[p], target);
        DFS(toppingCosts, p + 1, curCost, target);
    }
}
[sol1-C]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#define MIN(a, b) ((a) < (b) ? (a) : (b))

void dfs(const int *toppingCosts, int toppingCostsSize, 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 == toppingCostsSize) {
        return;
    }
    dfs(toppingCosts, toppingCostsSize, p + 1, curCost + toppingCosts[p] * 2, res, target);
    dfs(toppingCosts, toppingCostsSize, p + 1, curCost + toppingCosts[p], res, target);
    dfs(toppingCosts, toppingCostsSize, p + 1, curCost, res, target);
}

int closestCost(int* baseCosts, int baseCostsSize, int* toppingCosts, int toppingCostsSize, int target) {
    int res = INT_MAX;
    for (int i = 0; i < baseCostsSize; i++) {
        res = MIN(res, baseCosts[i]);
    }
    for (int i = 0; i < baseCostsSize; i++) {
        dfs(toppingCosts, toppingCostsSize, 0, baseCosts[i], &res, target);
    }
    return res;
}
[sol1-JavaScript]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
var closestCost = function(baseCosts, toppingCosts, target) {
    let res = _.min(baseCosts);
    const dfs = (toppingCosts, p, curCost, target) => {
        if (Math.abs(res - target) < curCost - target) {
            return;
        } else if (Math.abs(res - target) >= Math.abs(curCost - target)) {
            if (Math.abs(res - target) > Math.abs(curCost - target)) {
                res = curCost;
            } else {
                res = Math.min(res, curCost);
            }
        }
        if (p === toppingCosts.length) {
            return;
        }
        dfs(toppingCosts, p + 1, curCost + toppingCosts[p] * 2, target);
        dfs(toppingCosts, p + 1, curCost + toppingCosts[p], target);
        dfs(toppingCosts, p + 1, curCost, target);
    };
    for (const b of baseCosts) {
        dfs(toppingCosts, 0, b, target);
    }
    return res;
}
[sol1-Golang]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
func closestCost(baseCosts []int, toppingCosts []int, target int) int {
    ans := baseCosts[0]
    for _, c := range baseCosts {
        ans = min(ans, c)
    }
    var dfs func(int, int)
    dfs = func(p, curCost int) {
        if abs(ans-target) < curCost-target {
            return
        } else if abs(ans-target) >= abs(curCost-target) {
            if abs(ans-target) > abs(curCost-target) {
                ans = curCost
            } else {
                ans = min(ans, curCost)
            }
        }
        if p == len(toppingCosts) {
            return
        }
        dfs(p+1, curCost+toppingCosts[p]*2)
        dfs(p+1, curCost+toppingCosts[p])
        dfs(p+1, curCost)
    }
    for _, c := range baseCosts {
        dfs(0, c)
    }
    return ans
}

func abs(x int) int {
    if x < 0 {
        return -x
    }
    return x
}

func min(a, b int) int {
    if a > b {
        return b
    }
    return a
}

复杂度分析

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

方法二：动态规划

思路与算法

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

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

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

can}[x] = \text{true}, \forall x \in \textit{baseCosts} \And x < \textit{MAXC

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

can}[c] = \textit{can}[c - y] | \textit{can}[c], c > y

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

代码

[sol2-Python3]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Solution:
    def closestCost(self, baseCosts: List[int], toppingCosts: List[int], target: int) -> int:
        x = min(baseCosts)
        if x > target:
            return x
        can = [False] * (target + 1)
        ans = 2 * target - x
        for c in baseCosts:
            if c <= target:
                can[c] = True
            else:
                ans = min(ans, c)
        for c in toppingCosts:
            for count in range(2):
                for i in range(target, 0, -1):
                    if can[i] and i + c > target:
                        ans = min(ans, i + c)
                    if i - c > 0 and not can[i]:
                        can[i] = can[i - c]
        for i in range(ans - target + 1):
            if can[target - i]:
                return target - i
        return ans
[sol2-C++]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
class Solution {
public:
    int closestCost(vector<int>& baseCosts, vector<int>& toppingCosts, int target) {
        int x = *min_element(baseCosts.begin(), baseCosts.end());
        if (x >= target) {
            return x;
        }
        vector<bool> can(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;
    }
};
[sol2-Java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class Solution {
    public int closestCost(int[] baseCosts, int[] toppingCosts, int target) {
        int x = Arrays.stream(baseCosts).min().getAsInt();
        if (x >= target) {
            return x;
        }
        boolean[] can = new boolean[target + 1];
        int res = 2 * target - x;
        for (int b : baseCosts) {
            if (b <= target) {
                can[b] = true;
            } else {
                res = Math.min(res, b);
            }
        }
        for (int t : toppingCosts) {
            for (int count = 0; count < 2; ++count) {
                for (int i = target; i > 0; --i) {
                    if (can[i] && i + t > target) {
                        res = Math.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;
    }
}
[sol2-C#]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public class Solution {
    public int ClosestCost(int[] baseCosts, int[] toppingCosts, int target) {
        int x = baseCosts.Min();
        if (x >= target) {
            return x;
        }
        bool[] can = new bool[target + 1];
        int res = 2 * target - x;
        foreach (int b in baseCosts) {
            if (b <= target) {
                can[b] = true;
            } else {
                res = Math.Min(res, b);
            }
        }
        foreach (int t in toppingCosts) {
            for (int count = 0; count < 2; ++count) {
                for (int i = target; i > 0; --i) {
                    if (can[i] && i + t > target) {
                        res = Math.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;
    }
}
[sol2-C]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#define MIN(a, b) ((a) < (b) ? (a) : (b))

int closestCost(int* baseCosts, int baseCostsSize, int* toppingCosts, int toppingCostsSize, int target) {
    int x = INT_MAX;
    for (int i = 0; i < baseCostsSize; i++) {
        x = MIN(x, baseCosts[i]);
    }
    if (x >= target) {
        return x;
    }
    bool can[target + 1];
    memset(can, 0, sizeof(can));
    int res = 2 * target - x;
    for (int i = 0; i < baseCostsSize; i++) {
        if (baseCosts[i] <= target) {
            can[baseCosts[i]] = true;
        } else {
            res = MIN(res, baseCosts[i]);
        }
    }
    for (int j = 0; j < toppingCostsSize; j++) {
        for (int count = 0; count < 2; ++count) {
            for (int i = target; i > 0; --i) {
                if (can[i] && i + toppingCosts[j] > target) {
                    res = MIN(res, i + toppingCosts[j]);
                }
                if (i - toppingCosts[j] > 0) {
                    can[i] = can[i] | can[i - toppingCosts[j]];
                }
            }
        }
    }
    for (int i = 0; i <= res - target; ++i) {
        if (can[target - i]) {
            return target - i;
        }
    }
    return res;
}
[sol2-JavaScript]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
var closestCost = function(baseCosts, toppingCosts, target) {
    const x = _.min(baseCosts);
    if (x >= target) {
        return x;
    }
    const can = new Array(target + 1).fill(0);
    let res = 2 * target - x;
    for (const b of baseCosts) {
        if (b <= target) {
            can[b] = true;
        } else {
            res = Math.min(res, b);
        }
    }
    for (const t of toppingCosts) {
        for (let count = 0; count < 2; ++count) {
            for (let i = target; i > 0; --i) {
                if (can[i] && i + t > target) {
                    res = Math.min(res, i + t);
                }
                if (i - t > 0) {
                    can[i] = can[i] | can[i - t];
                }
            }
        }
    }
    for (let i = 0; i <= res - target; ++i) {
        if (can[target - i]) {
            return target - i;
        }
    }
    return res;
}
[sol2-Golang]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
func closestCost(baseCosts []int, toppingCosts []int, target int) int {
    x := baseCosts[0]
    for _, c := range baseCosts {
        x = min(x, c)
    }
    if x > target {
        return x
    }
    can := make([]bool, target+1)
    ans := 2*target - x
    for _, c := range baseCosts {
        if c <= target {
            can[c] = true
        } else {
            ans = min(ans, c)
        }
    }
    for _, c := range toppingCosts {
        for count := 0; count < 2; count++ {
            for i := target; i > 0; i-- {
                if can[i] && i+c > target {
                    ans = min(ans, i+c)
                }
                if i-c > 0 {
                    can[i] = can[i] || can[i-c]
                }
            }
        }
    }
    for i := 0; i <= ans-target; i++ {
        if can[target-i] {
            return target - i
        }
    }
    return ans
}

func min(a, b int) int {
    if a > b {
        return b
    }
    return a
}

复杂度分析

  • 时间复杂度：O(\textit{target} \times m)，其中 m 为数组 toppingCosts 的长度，target 为目标值。动态规划的时间复杂度是 O(\textit{MAXC} \times m)，由于 MAXC} = \textit{target，因此时间复杂度是 O(\textit{target} \times m)。
  • 空间复杂度：O(\textit{target})，其中 target 为目标值。需要创建长度为 target} + 1 的数组 can。
 Comments
On this page
1774-最接近目标价格的甜点成本