1547. 切棍子的最小成本

Problem: 1547. 切棍子的最小成本

思路

本题的目标是在给定长度为 n 的棍子上，根据预设的切割点 cuts 进行切割，使得总的切割成本最小。每次切割的成本等于切割后两段棍子的长度之和。由于切割点可以任意选择，但切割成本由切割后两端的长度决定，因此这是一个典型的动态规划问题。关键在于如何定义状态以及转移方程。状态定义为在给定两个端点的情况下，计算最优切割成本。为了简化问题，我们首先对切割点进行排序，并将棍子的起点和终点也视为切割点加入到列表中。然后使用一个二维数组 dp 来存储从一个切割点到另一个切割点之间的最小成本，其中 dp[i][j] 表示从第 i 个切割点到第 j 个切割点（包含这两个点）的最小成本。

解题方法

首先，将所有切割点按位置从小到大排序，并将棍子的起点和终点添加进切割点列表。初始化 dp 数组，其中 dp[i][i] 被设置为切割当前点的成本，即下一个点与前一个点的距离。使用两层循环遍历所有可能的切割点组合，从短的区间向长的区间推进，以确保在计算较长区间的最小成本时已经计算了所有较短区间的成本。
对于每个区间，尝试在该区间内所有的切割点上切割，选取成本最低的方案。

复杂度

时间复杂度:

$O(m3)$，其中 m 是切割点的数量（包括棍子的起点和终点）。这是因为我们需要遍历所有可能的区间，并在每个区间内尝试所有可能的切割点。

空间复杂度:

$O(m2)$，这是由于我们使用了一个二维数组 dp 来存储所有区间内的最小成本。

Code

class Solution {
    public int minCost1(int n, int[] cuts) {
        int m = cuts.length;
        Arrays.sort(cuts);
        int[] arr = new int[m + 2];
        for(int i = 1; i <= m; i++) {
            arr[i] = cuts[i - 1];
        }
        arr[m + 1] = n;
        int[][] dp = new int[m + 2][m + 2];
        for(int i = 0; i <= m + 1; i++) {
            for(int j = 0; j <= m + 1; j++) {
                dp[i][j] = -1;
            }
        }
      return f(arr, 1, m, dp);
    }

    public int f(int[] arr, int l, int r, int[][] dp) {
        if (l > r) {
            return 0;
        }
        if (l == r) {
            return arr[r + 1] - arr[l - 1];
        }
        if (dp[l][r] != -1) {
            return dp[l][r];
        }
        int ans = Integer.MAX_VALUE;
        for (int k = l; k <= r; k++) {
            ans = Math.min(ans, f(arr, l, k - 1, dp) + f(arr, k + 1, r, dp));
        }
        ans += arr[r + 1] - arr[l - 1];
        dp[l][r] = ans;
        return ans;
    }
    
    public int minCost(int n, int[] cuts) {
        int m = cuts.length;
        Arrays.sort(cuts);
        int[] arr = new int[m + 2];
        for(int i = 1; i <= m; i++) {
            arr[i] = cuts[i - 1];
        }
        arr[m + 1] = n;
        int[][] dp = new int[m + 2][m + 2];
        for(int i = 1; i <= m; i++) {
            dp[i][i] = arr[i + 1] -arr[i - 1];
        }
        for(int l = m - 1,next; l >= 1; l--) {
            for(int r = l + 1; r <= m; r++) {
                next = Integer.MAX_VALUE;
                for(int k = l; k <= r; k++) {
                    next = Math.min(next, dp[l][k - 1] + dp[k + 1][r]);
                }
                dp[l][r] = arr[r + 1] - arr[l - 1] + next;
            }
            
        }
        return dp[1][m];
    }
}