leetcode 1444. Number of Ways of Cutting a Pizza（切披萨的方法数）

一个String数组代表批萨，pizza[i]表示一行，其中A代表苹果，’ . '代表空。
给出整数k, 要把批萨切成 k-1块，每一块都必须有苹果。
可以横着切，也可以竖着切。
如果横着切，那么上面一块直接给人，继续切下面一块。
如果竖着切，那么左边一块直接给人，继续切右边一块。
问有多少种切法。

思路：

首先把切批萨这件事抽象成具体问题。
实际到手的是一个string数组，
需要找到横着切的点，分成上下两部分，判断上面那部分是否有苹果，有的话继续分下面那部分。
同样处理竖着切的情况。

那么就需要一个函数来判断某个区域是不是有苹果。
因为上面和左边都是直接给人的，不需要进一步处理，所以只需要判断右下部分区域是否有苹果。
每次都遍历统计苹果数比较耗时，还记得积分数组，统计左上部分的数字和的，
现在把积分数组应用在统计右下部分数字和。

还需要一个数组统计每个区域切k次有多少种方法，防止重复计算。
那么需要一个dp数组，dp[k][r][c]表示以(r,c)为左上角的右下区域，切k次，有多少种方法。

top-down DP

class Solution {
    final int mod = 1000000007;
    Integer[][][] dp;
    int rows = 0;
    int cols = 0;
    int[][] appleNum;

    public int ways(String[] pizza, int k) {
        rows = pizza.length;
        cols = pizza[0].length();
        dp = new Integer[k][rows][cols];

        //appleNum[r][c]表示(r,c)右下部分的苹果个数，右边加上一列，下面加上一行，方便统计
        appleNum = new int[rows+1][cols+1]; 

        //统计(r,c)右下角区域的苹果个数（积分数组）
        for(int r = rows-1; r >= 0; r--) {
            for(int c = cols-1; c >= 0; c--) {
                appleNum[r][c] = appleNum[r+1][c] + appleNum[r][c+1] 
                - appleNum[r+1][c+1] + (pizza[r].charAt(c)=='A' ? 1 : 0);
            }
        }
        return subSolve(k-1, 0, 0);
    }

    //统计切k次，从(r,c)到右下角的区域有几种方法
    int subSolve(int k, int r, int c) {
        if(appleNum[r][c] == 0) return 0; //没有苹果
        if(k == 0) return 1;  //k-1次已经用完了,完成一种方法
        if(dp[k][r][c] != null) return dp[k][r][c];
        int ways = 0;

        //横着切
        for(int i = r+1; i < rows; i++) {
            if(appleNum[r][c] - appleNum[i][c] > 0) { //upper部分有苹果，给人
                //继续分下半部分的苹果
                ways += subSolve(k-1, i, c) % mod;    
                ways %= mod;            
            }
        }

        //竖着切
        for(int j = c+1; j < cols; j++) {
            if(appleNum[r][c] - appleNum[r][j] > 0) { //左半部分有苹果，给人
                //继续分右半部分的苹果
                ways += subSolve(k-1, r, j) % mod;
                ways %= mod;
            }
        }
        
        return dp[k][r][c] = ways;
    }
}

也可以不用递归，直接用DP,
需要从右下到左上遍历，因为需要先计算右下部分的方法数（左上是直接给人的）。
bottom-up DP

class Solution {
    public int ways(String[] pizza, int k) {
        int rows = pizza.length;
        int cols = pizza[0].length();

        long[][][] dp = new long[k + 1][rows][cols];
        int[][] preSum = new int[rows + 1][cols + 1];

        for (int i = rows - 1; i >= 0; i--) {
            for (int j = cols - 1; j >= 0; j--) {
                preSum[i][j] = preSum[i + 1][j] + preSum[i][j + 1] - preSum[i + 1][j + 1] + (pizza[i].charAt(j) == 'A' ? 1 : 0);
                dp[1][i][j] = (preSum[i][j] > 0 ? 1 : 0);
            }
        }
        
        for (int pieces = 2; pieces <= k; pieces++) {
            for (int row = rows - 1; row >= 0; row--) {
                for (int col = cols - 1; col >= 0; col--) {
                    long ways = 0;

                    for (int nr = row + 1; nr < rows; nr++) {
                        if (preSum[row][col] - preSum[nr][col] > 0) { // there is at least one apple in the top piece 
                            ways += dp[pieces - 1][nr][col];
                        }
                    }

                    for (int nc = col + 1; nc < cols; nc++) {
                        if (preSum[row][col] - preSum[row][nc] > 0) { // there is at least one apple in the left piece 
                            ways += dp[pieces - 1][row][nc];
                        }
                    }

                    dp[pieces][row][col] = ways;
                }
            }
        }
        return (int)(dp[k][0][0] % 1000000007L);
    }
}