Given a rectangular paper of dimensions a x b. The task is to cut the entire paper into the minimum number of square pieces. We can choose square pieces of any size, but they must be cut without overlapping or leaving any extra space.
Output: 5 Explanation: We can cut the paper into 5 squares: 1 square of size 5x5, 1 square of size 3x3, 1 square of size 2x2 and 2 squares of size 1x1.
Output: 6 Explanation: We can cut the paper into 6 squares: 1 square of size 7x7, 1 square of size 6x6, 1 square of size 5x5, 2 squares of size 4x4 and 1 square of size 1x1.
At the first sight, it might seem that the problem can be easily solved by cutting the largest square possible from the paper first, followed by cutting the largest square from the remaining paper and so on till we have cut the entire paper. But, this solution is incorrect.
Why Greedy Approach won't work?
Consider a paper of size 6x7, then if we try to cut the paper greedily we will get 7 squares: 1 square of size 6x6 and 6 squares of size 1x1, whereas the correct solution is: 5. Hence, greedy approach won't work.
[Incorrect Approach 2] Using Dynamic Programming
Dynamic Programming with vertical or horizonal cuts: Another solution which might seem correct is using Dynamic Programming. We can maintain a dp[][] table such that dp[i][j] = minimum number of squares that can be cut from paper of size i x j. Then for paper of size axb,
We can try to cut it along each row: dp[i][j] = min(dp[i][j], 1 + dp[i - k][j] + dp[k][j]), where k can be in the range [1, i - 1].
We can try to cut it along each column: dp[i][j] =min(dp[i][j], 1 + dp[i][j - k] + dp[i][k]), where k can be in the range [1, j - 1].
Finally, minimum of all cuts will be the answer. But, this solution is also incorrect.
Why cutting vertically or horizontally with Dynamic Programming Approach won't work?
This won't work because we are assuming that a vertical or horizontal cut will always divide the rectangle into two parts. Consider a paper of size 13x11, then if we try to cut the paper using DP approach, we will get 8 squares but the correct answer (as shown in Examples) is 6. Hence, Dynamic Programming won't work.
[Correct Approach] Using DFS and Dynamic Programming
The idea is to cut the entire paper using DFS in bottom-up manner. In every step, find the lowest-left corner of the paper and try to cut squares of all possible size from that corner. After cutting a square, again find the lowest-left corner of the remaining paper to cut squares of all possible sizes and so on. But if we try all possible cuts from the lowest-left corner of every possible paper size, then it would be quite inefficient. We can optimize it by using Dynamic Programming to store minimum cuts for each possible paper size.
To uniquely identify any paper size, we can maintain a remSq[] array, such that remSq[i] stores the number of remaining squares of size 1x1 in the ith column of the paper. So, for a paper of size 6x7, remSq[] = {6, 6, 6, 6, 6, 6, 6}. Also to find the lowest-left corner, we will find the first index having the maximum remaining squares. So, we can hash the value of remSq[] array to find a unique key for all the possible values of remSq[] array.
Output
6
Time Complexity: O(a^b), for each of b columns, we can have a squares. Auxiliary Space: O(a^b), due to memoization storing each unique state.
