1444. 切披萨的方案数

题目描述：

给你一个 rows x cols 大小的矩形披萨和一个整数 k ，矩形包含两种字符： 'A' （表示苹果）和 '.' （表示空白格子）。你需要切披萨 k-1 次，得到 k 块披萨并送给别人。

切披萨的每一刀，先要选择是向垂直还是水平方向切，再在矩形的边界上选一个切的位置，将披萨一分为二。如果垂直地切披萨，那么需要把左边的部分送给一个人，如果水平地切，那么需要把上面的部分送给一个人。在切完最后一刀后，需要把剩下来的一块送给最后一个人。

请你返回确保每一块披萨包含至少一个苹果的切披萨方案数。由于答案可能是个很大的数字，请你返回它对 10^9 + 7 取余的结果。

示例 1：

输入：pizza = ["A..","AAA","..."], k = 3
输出：3 
解释：上图展示了三种切披萨的方案。注意每一块披萨都至少包含一个苹果。

示例 2：

输入：pizza = ["A..","AA.","..."], k = 3
输出：1

示例 3：

输入：pizza = ["A..","A..","..."], k = 1
输出：1

提示：

1 <= rows, cols <= 50
rows == pizza.length
cols == pizza[i].length
1 <= k <= 10
pizza 只包含字符 'A' 和 '.' 。

实现代码与解析：

二维后缀和 + 动态规划

class Solution {
public:
    int ways(vector<string>& pizza, int k) {

        int m = pizza.size(), n = pizza[0].size(), mod = 1e9 + 7;
        vector<vector<vector<int>>> f(k, vector<vector<int>>(m, vector<int>(n)));

        vector<vector<int>> apples(m + 1, vector<int>(n + 1)); // 后缀和

        // 后缀和 与 初始化dp数组
        for (int i = m - 1; i >= 0; i--)
        {
            for (int j = n - 1; j >= 0; j--)
            {
                apples[i][j] = apples[i + 1][j] + apples[i][j + 1] - apples[i + 1][j + 1] + (pizza[i][j] == 'A');
                f[0][i][j] = apples[i][j] > 0;
            }
        } 

        for (int kk = 1; kk < k; kk++)
        {
            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    // 选择此刀的切割位置

                    // 水平切, 遍历切的位置
                    for (int a = i + 1; a < m; a++)
                    {
                        // 上面的一块中至少要有一个苹果
                        if (apples[i][j] > apples[a][j])
                        {
                            f[kk][i][j] = (f[kk][i][j] + f[kk - 1][a][j]) % mod;
                        }
                    }
                
                    // 垂直切
                    for (int b = j + 1; b < n; b++)
                    {
                        // 左侧块中至少有一个苹果
                        if (apples[i][j] > apples[i][b])
                        {
                            f[kk][i][j] = (f[kk][i][j] + f[kk - 1][i][b]) % mod;
                        }
                    }
                }
            }
        }
        
        return f[k - 1][0][0];
    }
};