力扣每日一题 1547. 切棍子的最小成本

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

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

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

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

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

这个题目我一眼哈夫曼树，然后就开始错误的一发不可收拾。。。

这个题目的正解应该是动态规划，区间dp。但这个题的数据范围太水了，直接dfs递归暴力求解就可以过，完全够不上困难。

dfs的方法就是以整段为递归入口，枚举每个可切割点尝试切割，递归求解。长度为1时是递归出口。只不过记得记忆化一下，不然会超时。

class Solution {
public:
    int minCost(int n, vector<int>& cuts) {
        cuts.push_back(n);cuts.push_back(0);
        sort(cuts.begin(), cuts.end());
        block = cuts;
        int len=cuts.size();
        vector<vector<int> > ma(len, vector<int>(len));

        return dfs(0, len-1, ma);
    }
    int dfs(int x, int y, vector<vector<int> > &ma)
    {
        if (x+1 ==y) return 0;
        int ans=ma[x][y];
        if (ans) return ans;
        ans = INT_MAX;
        for (int z=x+1; z<y; ++z)
        {
            ans = min(ans, dfs(x,z,ma)+dfs(z,y,ma));
        }
        ans += block[y]-block[x];
        ma[x][y] = ans;
        return ans;
    }
    vector<int> block;
};

因为记忆化了，所以时间复杂度应该是O(m^3)，m是cuts的长度。空间复杂度O(m*m)?

也可以把递归改成递推，就变成了dp了。这里贴官方题解的代码。

class Solution {
public:
    int minCost(int n, vector<int>& cuts) {
        int m = cuts.size();
        sort(cuts.begin(), cuts.end());
        cuts.insert(cuts.begin(), 0);
        cuts.push_back(n);
        vector<vector<int>> f(m + 2, vector<int>(m + 2));
        for (int i = m; i >= 1; --i) {
            for (int j = i; j <= m; ++j) {
                f[i][j] = (i == j ? 0 : INT_MAX);
                for (int k = i; k <= j; ++k) {
                    f[i][j] = min(f[i][j], f[i][k - 1] + f[k + 1][j]);
                }
                f[i][j] += cuts[j + 1] - cuts[i - 1];
            }
        }
        return f[1][m];
    }
};

至于我的贪心思想，就是参考哈夫曼树，每次选择花费最小的两块合并，其实就是切分的逆过程。当然，肯定错了。我给个错误的例子

n=36
cuts=[13,17,15,18,3,22,27,6,35,7,11,28,26,20,4,5,21,10,8]

贪心解法是165，dp的答案是150