2312.卖木头块（力扣每日一题）

2312.卖木头块

给你两个整数 m 和 n ，分别表示一块矩形木块的高和宽。同时给你一个二维整数数组 prices ，其中 prices[i] = [hi, wi, pricei] 表示你可以以 pricei 元的价格卖一块高为 hi 宽为 wi 的矩形木块。

每一次操作中，你必须按下述方式之一执行切割操作，以得到两块更小的矩形木块：

• 沿垂直方向按高度 完全 切割木块，或
• 沿水平方向按宽度 完全 切割木块

在将一块木块切成若干小木块后，你可以根据 prices 卖木块。你可以卖多块同样尺寸的木块。你不需要将所有小木块都卖出去。你 不能 旋转切好后木块的高和宽。

请你返回切割一块大小为 m x n 的木块后，能得到的 最多 钱数。

注意你可以切割木块任意次。

示例 1：

输入：m = 3, n = 5, prices = [[1,4,2],[2,2,7],[2,1,3]]
输出：19
解释：上图展示了一个可行的方案。包括：
- 2 块 2 x 2 的小木块，售出 2 * 7 = 14 元。
- 1 块 2 x 1 的小木块，售出 1 * 3 = 3 元。
- 1 块 1 x 4 的小木块，售出 1 * 2 = 2 元。
总共售出 14 + 3 + 2 = 19 元。
19 元是最多能得到的钱数。

示例 2：

输入：m = 4, n = 6, prices = [[3,2,10],[1,4,2],[4,1,3]]
输出：32
解释：上图展示了一个可行的方案。包括：
- 3 块 3 x 2 的小木块，售出 3 * 10 = 30 元。
- 1 块 1 x 4 的小木块，售出 1 * 2 = 2 元。
总共售出 30 + 2 = 32 元。
32 元是最多能得到的钱数。
注意我们不能旋转 1 x 4 的木块来得到 4 x 1 的木块。

提示：

• 1 <= m, n <= 200
• 1 <= prices.length <= 2 * 104
• prices[i].length == 3
• 1 <= hi <= m
• 1 <= wi <= n
• 1 <= pricei <= 106
• 所有 (hi, wi) 互不相同 。

题解

显然，对于m * n的可以由（m - 1) * n + 1 * n 两个木块组成，同样的也可以由m * （n - 1） + m * 1 两个木块组成。

假设 f[x][y] 表示对于 x * y 的木块我们所可以得到的最大Value，因此我们可以分别枚举所有横向和纵向切割位置，然后存储所有切割方式中的最大值即可。

具体代码如下：

int d[N][N];//d[i][j]表示i*j的方块的Value值 
long long int dfs(int x, int y)
{
    long long int ans = d[x][y];//存储所有切割方式的最大值
    for(int i = 1; i < x; i ++)//第0个和第x个分割点对方块无影响
    {
        ans = max(ans, dfs(x - i, y) + dfs(i, y));
    }
    for(int i = 1; i < y; i ++)//第0个和第y个分割点对方块无影响
    {
        ans = max(ans, dfs(x, y - i) + dfs(x, i));
    }
    return f[x][y];
}

可以发现，对于m * n 和 （m - 1) * n 两种木块他们存在很多切割方式相同的情况，经分析发现这种重复计算的情况普遍存在，为了避免重复计算，考虑使用记忆化搜索，即存储各种切割方式的Value值，如果已经算过则不必重复计算，因此可以把代码优化为：

int d[N][N];//d[i][j]表示i*j的方块的Value值 
int f[N][N];// f[x][y]表示对于x*y的木块我们所可以得到的最大Value
memset(f, -1, sizeof f);//因为有些切割方式的Value值为0是合法的，为了方便区分该状态是否计算过，把初始值设为-1
long long int dfs(int x, int y)
{
    if(f[x][y] != -1)//已经计算过，直接返回上次计算的值
    {
        return f[x][y];
    }
    long long int ans = d[x][y];//初始值为x*y方块的Value值，尝试能否找到其他切割方式，得到更大的Value值并存储在ans中
    for(int i = 1; i < x; i ++)//第0个和第x个分割点对方块无影响
    {
        ans = max(ans, dfs(x - i, y) + dfs(i, y));
    }
    for(int i = 1; i < y; i ++)//第0个和第y个分割点对方块无影响
    {
        ans = max(ans, dfs(x, y - i) + dfs(x, i));
    }
    f[x][y] = ans;//把算过的答案记录
    return f[x][y];
}

至此核心代码已经介绍完毕，最终AC代码如下（Leetcode C++版本）：

class Solution {
public:
    long long f[210][210];
    int d[210][210];
    long long int dfs(int x, int y)
    {
        if(f[x][y] != -1)//已经计算过，直接返回上次计算的值
        {
            return f[x][y];
        }
        long long int ans = d[x][y];//初始值为x*y方块的Value值，尝试能否找到其他切割方式，得到更大的Value值并存储在ans中
        for(int i = 1; i < x; i ++)//第0个和第x个分割点对方块无影响
        {
            ans = max(ans, dfs(x - i, y) + dfs(i, y));
        }
        for(int i = 1; i < y; i ++)//第0个和第y个分割点对方块无影响
        {
            ans = max(ans, dfs(x, y - i) + dfs(x, i));
        }
        f[x][y] = ans;//把算过的答案记录
        return f[x][y];
    }
long long sellingWood(int m, int n, vector<vector<int>>& prices) {   
        memset(f, -1, sizeof f);
        memset(d, 0, sizeof(d));
        for(auto& i: prices) d[i[0]][i[1]] = i[2];
        return dfs(m, n);
    }
};