给定大小为A x B的纸张。任务是将纸张切成任意大小的正方形。找到可以从纸上切出的最小平方数。
例子：
Input : 36 x 30
Output : 5
Explanation :
3 (squares of size 12x12) +
2 (squares of size 18x18)
Input : 4 x 5
Output : 5
Explanation :
1 (squares of size 4x4) +
4 (squares of size 1x1)
询问：谷歌
在上一篇文章中，我们已经讨论了贪婪方法来解决此问题。但是以前的方法并不总是有效。例如，对于上述第一个测试用例，它失败。因此，在本文中，我们将使用Dynamic Programming解决此问题。
我们知道，如果要从纸上裁切最小的正方形，则必须首先从纸上裁切最大的正方形，并且最大的裁切面与纸的较小面相同。例如，如果纸张尺寸为13 x 29，则最大正方形将在面13处。因此，我们可以裁切2个尺寸为13 x 13的正方形(29/13 = 2)。现在剩余的纸张将具有3 x 13的尺寸。类似地，我们可以通过使用4个3 x 3的正方形和3个1 x 1的正方形来裁切剩余的纸张。因此，可以从13 x 29的Paper中裁切最少9个正方形。
说明：
minimumSquare是一个试图在某个位置分割矩形的函数。递归调用这两个部分的函数。尝试所有可能的分割，并以最小的结果进行分割。基本情况是当两边相等时，即输入已经是一个正方形，在这种情况下，结果是我们试图找到最靠近中心的切割，这将导致我们得到最小的结果。
假设我们有一个矩形，宽度为N，高度为M。
- 如果(N == M)，则它是一个正方形，不需要执行任何操作。
- 否则，我们可以将矩形划分为另外两个较小的矩形(N – x，M)和(x，M)，以便可以递归求解。
- 同样，我们也可以将其分为(N，M – x)和(N，x)
同样，我们需要注意这里的边沿情况是N = 11和M = 13，反之亦然。对于给定的测试用例，以下将是最好的答案：
在这种情况下，我们的方法将返回8，但是如您所见，我们可以将纸张切成最小的6个正方形。发生这种情况是因为在最佳解决方案中没有垂直线或水平线穿过整个正方形。
以下是使用动态编程实现上述想法的方法。
C++
// C++ program to find minimum number of squares
// to cut a paper using Dynamic Programming
#include
using namespace std;
const int MAX = 300;
int dp[MAX][MAX];
// Returns min number of squares needed
int minimumSquare(int m, int n)
{
// Initializing max values to vertical_min
// and horizontal_min
int vertical_min = INT_MAX;
int horizontal_min = INT_MAX;
// N=11 & M=13 is a special case
if(n==13 && m==11) return 6;
if(m==13 && n==11) return 6;
// If the given rectangle is already a square
if (m == n)
return 1;
// If the answer for the given rectangle is
// previously calculated return that answer
if (dp[m][n])
return dp[m][n];
/* The rectangle is cut horizontally and
vertically into two parts and the cut
with minimum value is found for every
recursive call.
*/
for (int i = 1;i<= m/2;i++)
{
// Calculating the minimum answer for the
// rectangles with width equal to n and length
// less than m for finding the cut point for
// the minimum answer
horizontal_min = min(minimumSquare(i, n) +
minimumSquare(m-i, n), horizontal_min);
}
for (int j = 1;j<= n/2;j++)
{
// Calculating the minimum answer for the
// rectangles with width less than n and
// length equal to m for finding the cut
// point for the minimum answer
vertical_min = min(minimumSquare(m, j) +
minimumSquare(m, n-j), vertical_min);
}
// Minimum of the vertical cut or horizontal
// cut to form a square is the answer
dp[m][n] = min(vertical_min, horizontal_min);
return dp[m][n];
}
// Driver code
int main()
{
int m = 30, n = 35;
// Function call
cout << minimumSquare(m, n);
return 0;
}
// This code is contributed by Utkarsh Gupta Java
// Java program to find minimum number of
// squares to cut a paper using Dynamic
// Programming
import java.io.*;
class GFG {
static int dp[][] = new int[300][300];
// Returns min number of squares needed
static int minimumSquare(int m, int n)
{
// Initializing max values to
// vertical_min and horizontal_min
int vertical_min = Integer.MAX_VALUE;
int horizontal_min = Integer.MAX_VALUE;
// N=11 & M=13 is a special case
if(n==13 && m==11) return 6;
if(m==13 && n==11) return 6;
// If the given rectangle is
// already a square
if (m == n)
return 1;
// If the answer for the given
// rectangle is previously
// calculated return that answer
if (dp[m][n] != 0)
return dp[m][n];
/* The rectangle is cut horizontally
and vertically into two parts and
the cut with minimum value is found
for every recursive call.
*/
for (int i = 1; i <= m / 2; i++)
{
// Calculating the minimum answer
// for the rectangles with width
// equal to n and length less than
// m for finding the cut point for
// the minimum answer
horizontal_min
= Math.min(minimumSquare(i, n)
+ minimumSquare(m - i, n),
horizontal_min);
}
for (int j = 1; j <= n / 2; j++) {
// Calculating the minimum answer
// for the rectangles with width
// less than n and length equal to
// m for finding the cut point for
// the minimum answer
vertical_min
= Math.min(minimumSquare(m, j)
+ minimumSquare(m, n - j),
vertical_min);
}
// Minimum of the vertical cut or
// horizontal cut to form a square
// is the answer
dp[m][n] = Math.min(vertical_min, horizontal_min);
return dp[m][n];
}
// Driver code
public static void main(String[] args)
{
int m = 30, n = 35;
// Function call
System.out.println(minimumSquare(m, n));
}
}
// This code is contributed by Prerna SainiPython3
# Python3 program to find minimum
# number of squares
# to cut a paper using Dynamic Programming
MAX = 300
dp = [[0 for i in range(MAX)] for i in range(MAX)]
# Returns min number of squares needed
def minimumSquare(m, n):
# Initializing max values to
# vertical_min
# and horizontal_min
vertical_min = 10000000000
horizontal_min = 10000000000
# N=11 & M=13 is a special case
if n == 13 and m == 11:
return 6
if m == 13 and n == 11:
return 6
# If the given rectangle is
# already a square
if m == n:
return 1
# If the answer for the given rectangle is
# previously calculated return that answer
if dp[m][n] != 0:
return dp[m][n]
# The rectangle is cut horizontally and
# vertically into two parts and the cut
# with minimum value is found for every
# recursive call.
for i in range(1, m//2+1):
# Calculating the minimum answer for the
# rectangles with width equal to n and length
# less than m for finding the cut point for
# the minimum answer
horizontal_min = min(minimumSquare(i, n) +
minimumSquare(m-i, n), horizontal_min)
for j in range(1, n//2+1):
# Calculating the minimum answer for the
# rectangles with width equal to n and length
# less than m for finding the cut point for
# the minimum answer
vertical_min = min(minimumSquare(m, j) +
minimumSquare(m, n-j), vertical_min)
# Minimum of the vertical cut or horizontal
# cut to form a square is the answer
dp[m][n] = min(vertical_min, horizontal_min)
return dp[m][n]
# Driver code
if __name__ == '__main__':
m = 30
n = 35
# Function call
print(minimumSquare(m, n))
# This code is contributed by sahilshelangiaC#
// C# program to find minimum number of
// squares to cut a paper using Dynamic
// Programming
using System;
class GFG {
static int[, ] dp = new int[300, 300];
// Returns min number of squares needed
static int minimumSquare(int m, int n)
{
// Initializing max values to
// vertical_min and horizontal_min
int vertical_min = int.MaxValue;
int horizontal_min = int.MaxValue;
// N=11 & M=13 is a special case
if(n==13 && m==11) return 6;
if(m==13 && n==11) return 6;
// If the given rectangle is
// already a square
if (m == n)
return 1;
// If the answer for the given
// rectangle is previously
// calculated return that answer
if (dp[m, n] != 0)
return dp[m, n];
/* The rectangle is cut horizontally
and vertically into two parts and
the cut with minimum value is found
for every recursive call.
*/
for (int i = 1; i <= m / 2; i++)
{
// Calculating the minimum answer
// for the rectangles with width
// equal to n and length less than
// m for finding the cut point for
// the minimum answer
horizontal_min
= Math.Min(minimumSquare(i, n)
+ minimumSquare(m - i, n),
horizontal_min);
}
for (int j = 1; j <= n / 2; j++)
{
// Calculating the minimum answer
// for the rectangles with width
// less than n and length equal to
// m for finding the cut point for
// the minimum answer
vertical_min
= Math.Min(minimumSquare(m, j)
+ minimumSquare(m, n - j),
vertical_min);
}
// Minimum of the vertical cut or
// horizontal cut to form a square
// is the answer
dp[m, n] = Math.Min(vertical_min, horizontal_min);
return dp[m, n];
}
// Driver code
public static void Main()
{
int m = 30, n = 35;
// Function call
Console.WriteLine(minimumSquare(m, n));
}
}
// This code is contributed by anuj_67.输出
5