# Solution For Number Of Ways Of Cutting A Pizza

The problem “Number Of Ways Of Cutting A Pizza” on LeetCode asks us to find the number of ways to cut a pizza into pieces with at least one apple or tomato on each piece. The pizza is represented as a 2D array of size n x m, where the cell (i,j) contains either ‘A’ or ‘T’ or ‘.’ representing an apple, tomato, or empty cell, respectively. A cut is defined as a straight line that divides the pizza into two pieces and goes through the center of any cell. We are also given the number of pieces we want to divide the pizza into.

One possible approach to solve this problem is to use dynamic programming. We can define a 3D dp array dp[i][j][k], where dp[i][j][k] represents the number of ways to cut the sub-pizza from cell (i,j) to the lower-right corner of the pizza into k pieces, such that each piece contains at least one apple or tomato.

We can observe that to compute dp[i][j][k], we need to consider all possible cuts that pass through cell (i,j) and divide the sub-pizza into two pieces. For each such cut, we can count the number of ways to cut the left piece into k-1 pieces and the right piece into 1 piece, such that each piece contains at least one apple or tomato. Then we can sum up all these counts to get the total number of ways to cut the sub-pizza from cell (i,j) into k pieces.

To speed up this computation, we can precompute two auxiliary arrays countA and countT, where countA[i][j] and countT[i][j] represent the number of apples and tomatoes, respectively, in the sub-pizza from cell (i,j) to the lower-right corner of the pizza. These arrays can be computed in O(nm) time using a simple dynamic programming approach.

Using these auxiliary arrays, we can check whether a cut passes through a cell containing an apple or tomato or not, and if not, we can skip that cut and move to the next one. This reduces the time complexity of our algorithm from O(np^3) to O(np^2), where p is the maximum number of cuts we need to consider.

The final answer is given by dp[0][0][k], which represents the number of ways to cut the entire pizza into k pieces, such that each piece contains at least one apple or tomato.

Here is the Python code for this approach:

“`
class Solution:
def ways(self, pizza: List[str], k: int) -> int:
n, m = len(pizza), len(pizza[0])
MOD = 10**9 + 7

``````    # Precompute auxiliary arrays countA and countT
countA = [[0] * m for _ in range(n)]
countT = [[0] * m for _ in range(n)]
countA[-1][-1] = 1 if pizza[-1][-1] == 'A' else 0
countT[-1][-1] = 1 if pizza[-1][-1] == 'T' else 0
for i in range(n-2, -1, -1):
countA[i][-1] = countA[i+1][-1] + (pizza[i][-1] == 'A')
countT[i][-1] = countT[i+1][-1] + (pizza[i][-1] == 'T')
for j in range(m-2, -1, -1):
countA[-1][j] = countA[-1][j+1] + (pizza[-1][j] == 'A')
countT[-1][j] = countT[-1][j+1] + (pizza[-1][j] == 'T')
for i in range(n-2, -1, -1):
for j in range(m-2, -1, -1):
countA[i][j] = countA[i+1][j] + countA[i][j+1] - countA[i+1][j+1] + (pizza[i][j] == 'A')
countT[i][j] = countT[i+1][j] + countT[i][j+1] - countT[i+1][j+1] + (pizza[i][j] == 'T')

# Initialize the DP array dp
dp = [[[0] * k for _ in range(m)] for _ in range(n)]
dp[-1][-1][0] = 1 if pizza[-1][-1] != '.' else 0
for i in range(n-2, -1, -1):
dp[i][-1][0] = dp[i+1][-1][0] + (pizza[i][-1] != '.')
for j in range(m-2, -1, -1):
dp[-1][j][0] = dp[-1][j+1][0] + (pizza[-1][j] != '.')

# Compute the DP array dp
for i in range(n-2, -1, -1):
for j in range(m-2, -1, -1):
for t in range(1, k):
for x in range(i, n-1):
if countA[i][j] - countA[x+1][j] == 0:
dp[i][j][t] += dp[x+1][j][t-1]
dp[i][j][t] %= MOD
for y in range(j, m-1):
if countA[i][j] - countA[i][y+1] == 0:
dp[i][j][t] += dp[i][y+1][t-1]
dp[i][j][t] %= MOD
dp[i][j][t] %= MOD

return dp[0][0][k-1]
``````

“`

The time complexity of this solution is O(nmp^2), where p is the maximum number of cuts we need to consider. The space complexity is also O(nmp).

## Step by Step Implementation For Number Of Ways Of Cutting A Pizza

```There are many ways to solve this problem, but one approach is to use dynamic programming.

We can define a 2D array dp, where dp[i][j] represents the number of ways to cut a pizza with i slices and j toppings. Then, we can fill in this array using the following recurrence:

dp[i][j] = dp[i-1][j] + dp[i][j-1]

This recurrence says that the number of ways to cut a pizza with i slices and j toppings is equal to the number of ways to cut a pizza with i-1 slices and j toppings (i.e., one fewer slice) plus the number of ways to cut a pizza with i slices and j-1 toppings (i.e., one fewer topping).

We can initialize the array as follows:

dp[0][0] = 1

This says that there is only one way to cut a pizza with 0 slices and 0 toppings (i.e., don't cut it at all).

Then, we can simply compute the number of ways to cut a pizza with m slices and n toppings by looking up dp[m][n].```
```Given a rectangular pizza represented as a rows x cols matrix containing the following characters: 'A' (an apple) and '.' (empty cell) return the number of ways you can cut the pizza represented by the matrix into 1 x 1 pieces.

For example, given a pizza with 2 rows and 3 columns, it can be divided into 4 1 x 1 pieces as follows:

[['A', 'A', '.'], ['A', '.', '.']]

-> 4

1) [ ['A', 'A', '.'],  ['A', '.', '.'] ]
-> 4
2) [ ['A', 'A', 'A'],  ['A', '.', '.'] ]
-> 6
3) [ ['A', 'A', 'A'],  ['A', 'A', '.'] ]
-> 9
4) [ ['A', 'A', 'A'],  ['A', 'A', 'A'] ]
-> 12```
`There are many ways to cut a pizza, so the number of ways to cut a pizza is infinite.`
```There are many ways to solve this problem, but one way to think about it is as follows:

1. Consider all of the possible ways to cut the pizza into slices.
2. For each way, calculate the number of possible ways to arrange the slices.
3. Return the sum of all the possibilities.

Here is some sample code to get you started:

#include
#include

using namespace std;

// This function calculates the number of ways to arrange n items
// in r groups. For example, if n = 6 and r = 3, then there are
// 120 ways to arrange the 6 items into 3 groups.
int numWays(int n, int r) {
if (r == 1) return 1;
if (n == r) return 1;
return numWays(n-1, r) + numWays(n-1, r-1);
}

int main() {
int N, M;
cin >> N >> M;

// Calculate the number of ways to cut the pizza
int ways = 0;
for (int i = 1; i <= M-1; i++) {
ways += numWays(N-1, i);
}

cout << ways << endl;

return 0;
}```
`There are many ways to cut a pizza, so the number of ways to cut a pizza is infinite.`

Scroll to Top
[gravityforms id="5" description="false" titla="false" ajax="true"]