每日一题，切棍子的最小成本-CSDN博客

本文链接：https://blog.csdn.net/liyuxiaomeng/article/details/143696870

有一根长度为 n 个单位的木棍，棍上从 0 到 n 标记了若干位置。例如，长度为 6 的棍子可以标记如下：

给你一个整数数组 cuts ，其中 cuts[i] 表示你需要将棍子切开的位置。

你可以按顺序完成切割，也可以根据需要更改切割的顺序。

每次切割的成本都是当前要切割的棍子的长度，切棍子的总成本是历次切割成本的总和。对棍子进行切割将会把一根木棍分成两根较小的木棍（这两根木棍的长度和就是切割前木棍的长度）。请参阅第一个示例以获得更直观的解释。

返回切棍子的 最小总成本 。

示例 1：

输入：n = 7, cuts = [1,3,4,5]
输出：16
解释：按 [1, 3, 4, 5] 的顺序切割的情况如下所示：

第一次切割长度为 7 的棍子，成本为 7 。第二次切割长度为 6 的棍子（即第一次切割得到的第二根棍子），第三次切割为长度 4 的棍子，最后切割长度为 3 的棍子。总成本为 7 + 6 + 4 + 3 = 20 。
而将切割顺序重新排列为 [3, 5, 1, 4] 后，总成本 = 16（如示例图中 7 + 4 + 3 + 2 = 16）。

示例 2：

输入：n = 9, cuts = [5,6,1,4,2]
输出：22
解释：如果按给定的顺序切割，则总成本为 25 。总成本 <= 25 的切割顺序很多，例如，[4, 6, 5, 2, 1] 的总成本 = 22，是所有可能方案中成本最小的。

提示：

2 <= n <= 10^6
1 <= cuts.length <= min(n - 1, 100)
1 <= cuts[i] <= n - 1
cuts 数组中的所有整数都 互不相同

解法

我们可以使用动态规划来解决这个问题。具体来说，我们可以定义一个二维数组 dp，其中 dp[i][j] 表示从位置 i 到位置 j 的最小切割成本。

步骤详解

初始化：

将 cuts 数组扩展，包含棍子的起点 0 和终点 n。
对 cuts 数组进行排序，以便于后续处理。

动态规划状态定义：

dp[i][j] 表示从位置 cuts[i] 到位置 cuts[j] 的最小切割成本。

状态转移方程：

对于每个区间 [cuts[i], cuts[j]]，我们需要考虑所有的切割点 k，其中 i < k < j。
如果我们在 cuts[k] 处进行切割，那么切割成本为 cuts[j] - cuts[i]，加上左右两个子区间的最小成本 dp[i][k] + dp[k][j]。
因此，状态转移方程为：
dp[i][j]=min⁡i<k<j((cuts[j]−cuts[i])+dp[i][k]+dp[k][j])dp[i][j]=i<k<jmin((cuts[j]−cuts[i])+dp[i][k]+dp[k][j])

边界条件：

当 i == j 时，没有切割点，成本为 0。

最终结果：

dp[0][m-1] 即为从起点到终点的最小切割成本，其中 m 是扩展后的 cuts 数组的长度。

代码实现

function minCost(n, cuts) {
  // 扩展 cuts 数组，包含起点和终点
  cuts.push(0);
  cuts.push(n);
  // 对 cuts 数组进行排序
  cuts.sort((a, b) => a - b);

  const m = cuts.length;
  const dp = Array.from({ length: m }, () => Array(m).fill(0));

  // 动态规划计算最小成本
  for (let len = 2; len < m; len++) {
    for (let i = 0; i + len < m; i++) {
      const j = i + len;
      dp[i][j] = Infinity;
      for (let k = i + 1; k < j; k++) {
        dp[i][j] = Math.min(dp[i][j], cuts[j] - cuts[i] + dp[i][k] + dp[k][j]);
      }
    }
  }

  return dp[0][m - 1];
}

// 测试用例
console.log(minCost(7, [1, 3, 4, 5])); // 输出: 16
console.log(minCost(9, [5, 6, 1, 4, 2])); // 输出: 22

解释

初始化：

cuts 数组扩展为 [0, 1, 3, 4, 5, 7]。
对 cuts 数组进行排序。

动态规划：

使用二维数组 dp 存储每个区间的最小切割成本。
通过三层循环计算每个区间的最小成本：
外层循环控制区间长度 len。
中层循环控制区间的起点 i。
内层循环控制切割点 k。

结果：

dp[0][m-1] 即为从起点到终点的最小切割成本。

这个算法的时间复杂度是 O(m3)O(m3)，其中 mm 是扩展后的 cuts 数组的长度。空间复杂度是 O(m2)O(m2)。这种方法能够在合理的时间内解决给定的问题。