半径为 R 的圆中的矩形数

给定一个半径为 R 的圆形片，任务是找到可以从圆形片上切割出的具有整数长度和宽度的矩形的总数，一次一个。
例子：

Input: R = 2 
Output: 8 
8 rectangles can be cut from a circular sheet of radius 2. 
These are: 1×1, 1×2, 2×1, 2×2, 1×3, 3×1, 2×3, 3×2.
Input: R = 1 
Output: 1 
Only one rectangle with dimensions 1 X 1 is possible. 
 

方法
考虑下图，

很容易看出，ABCD 是半径为R和中心为 O 的给定圆中可以形成的最大矩形，尺寸为a X b
放下一个垂直的 AO，使得∠AOD = ∠AOB = 90°
考虑下图进行进一步分析，

Consider triangles AOD and AOB,
In these triangles,
AO = AO (Common Side)
∠AOD = ∠AOB = 90° 
OD = OB = R
Thus, by SAS congruence ▵AOD ≅ ▵AOB
∴ AD = AB by CPCT(i.e Corresponding Parts on Congruent Triangles)
or, a = b
=> The rectangle ABCD is a square 

直径 BD 是矩形可以从圆形板材切割的最大对角线。
因此，可以检查 a 和 b 的所有组合以形成所有可能的矩形，并且如果任何此类矩形的对角线小于或等于所形成的最大矩形的对角线长度（即 2 * R，其中 R是圆的半径，如上所述）
现在，a 和 b 的最大长度将始终严格小于圆的直径，因此 a 和 b 的所有可能值都将位于闭区间 [1, (2 * R – 1)] 中。
下面是上述方法的实现：

C++

// C++ program to find the number of rectangles
// that can be cut from a circle of Radius R
#include 
using namespace std;
 
// Function to return the total possible
// rectangles that can be cut from the circle
int countRectangles(int radius)
{
 
    int rectangles = 0;
 
    // Diameter = 2 * Radius
    int diameter = 2 * radius;
 
    // Square of diameter which is the square
    // of the maximum length diagonal
    int diameterSquare = diameter * diameter;
 
    // generate all combinations of a and b
    // in the range (1, (2 * Radius - 1))(Both inclusive)
    for (int a = 1; a < 2 * radius; a++) {
        for (int b = 1; b < 2 * radius; b++) {
 
            // Calculate the Diagonal length of
            // this rectangle
            int diagonalLengthSquare = (a * a + b * b);
 
            // If this rectangle's Diagonal Length
            // is less than the Diameter, it is a
            // valid rectangle, thus increment counter
            if (diagonalLengthSquare <= diameterSquare) {
                rectangles++;
            }
        }
    }
 
    return rectangles;
}
 
// Driver Code
int main()
{
 
    // Radius of the circle
    int radius = 2;
 
    int totalRectangles;
    totalRectangles = countRectangles(radius);
    cout << totalRectangles << " rectangles can be"
         << "cut from a circle of Radius " << radius;
    return 0;
}

Java

// Java program to find the
// number of rectangles that
// can be cut from a circle
// of Radius R
import java.io.*;
 
class GFG
{
     
// Function to return
// the total possible
// rectangles that can
// be cut from the circle
static int countRectangles(int radius)
{
    int rectangles = 0;
 
    // Diameter = 2 * Radius
    int diameter = 2 * radius;
 
    // Square of diameter
    // which is the square
    // of the maximum length
    // diagonal
    int diameterSquare = diameter *
                         diameter;
 
    // generate all combinations
    // of a and b in the range
    // (1, (2 * Radius - 1))
    // (Both inclusive)
    for (int a = 1;
             a < 2 * radius; a++)
    {
        for (int b = 1;
                 b < 2 * radius; b++)
        {
 
            // Calculate the
            // Diagonal length of
            // this rectangle
            int diagonalLengthSquare = (a * a +
                                       b * b);
 
            // If this rectangle's Diagonal
            // Length is less than the Diameter,
            // it is a valid rectangle, thus
            // increment counter
            if (diagonalLengthSquare <= diameterSquare)
            {
                rectangles++;
            }
        }
    }
 
    return rectangles;
}
 
// Driver Code
public static void main (String[] args)
{
     
// Radius of the circle
int radius = 2;
 
int totalRectangles;
totalRectangles = countRectangles(radius);
System.out.println(totalRectangles +
             " rectangles can be " +
            "cut from a circle of" +
               " Radius " + radius);
}
}
 
// This code is contributed
// by anuj_67.

Python3

# Python3 program to find
# the number of rectangles
# that can be cut from a
# circle of Radius R Function
# to return the total possible
# rectangles that can be cut
# from the circle
def countRectangles(radius):
     
    rectangles = 0
     
    # Diameter = 2 * Radius
    diameter = 2 * radius
     
    # Square of diameter which
    # is the square of the
    # maximum length diagonal
    diameterSquare = diameter * diameter
     
    # generate all combinations
    # of a and b in the range
    # (1, (2 * Radius - 1))(Both inclusive)
    for a in range(1, 2 * radius):
        for b in range(1, 2 * radius):
             
            # Calculate the Diagonal
            # length of this rectangle
            diagonalLengthSquare = (a * a +
                                   b * b)
             
            # If this rectangle's Diagonal
            # Length is less than the
            # Diameter, it is a valid
            # rectangle, thus increment counter
            if (diagonalLengthSquare <= diameterSquare) :
                rectangles += 1
     
    return rectangles
 
# Driver Code
 
# Radius of the circle
radius = 2
totalRectangles = countRectangles(radius)
print(totalRectangles , "rectangles can be" ,
      "cut from a circle of Radius" , radius)
 
# This code is contributed by Smita

C#

// C# program to find the
// number of rectangles that
// can be cut from a circle
// of Radius R
using System;
 
class GFG
{
     
// Function to return
// the total possible
// rectangles that can
// be cut from the circle
static int countRectangles(int radius)
{
    int rectangles = 0;
 
    // Diameter = 2 * Radius
    int diameter = 2 * radius;
 
    // Square of diameter
    // which is the square
    // of the maximum length
    // diagonal
    int diameterSquare = diameter *
                         diameter;
 
    // generate all combinations
    // of a and b in the range
    // (1, (2 * Radius - 1))
    // (Both inclusive)
    for (int a = 1;
             a < 2 * radius; a++)
    {
        for (int b = 1;
                 b < 2 * radius; b++)
        {
 
            // Calculate the
            // Diagonal length of
            // this rectangle
            int diagonalLengthSquare = (a * a +
                                        b * b);
 
            // If this rectangle's
            // Diagonal Length is
            // less than the Diameter,
            // it is a valid rectangle,
            // thus increment counter
            if (diagonalLengthSquare <=
                             diameterSquare)
            {
                rectangles++;
            }
        }
    }
 
    return rectangles;
}
 
// Driver Code
public static void Main ()
{
     
// Radius of the circle
int radius = 2;
 
int totalRectangles;
totalRectangles = countRectangles(radius);
Console.WriteLine(totalRectangles +
            " rectangles can be " +
           "cut from a circle of" +
              " Radius " + radius);
}
}
 
// This code is contributed
// by anuj_67.

Javascript

// java script  program to find the
// number of rectangles that
// can be cut from a circle
// of Radius R
 
// Function to return the
// total possible rectangles
// that can be cut from the circle
function countRectangles(radius)
{
 
    let rectangles = 0;
 
    // Diameter = 2 * $Radius
    let diameter = 2 * radius;
 
    // Square of diameter which
    // is the square of the
    // maximum length diagonal
    let diameterSquare = diameter *
                    diameter;
 
    // generate all combinations
    // of a and b in the range
    // (1, (2 * Radius - 1))(Both inclusive)
    for (let a = 1;a < 2 * radius; a++)
    {
        for (let b = 1;
            b < 2 * radius; b++)
        {
 
            // Calculate the Diagonal
            // length of this rectangle
            let diagonalLengthSquare = (a * a +
                                    b * b);
 
            // If this rectangle's Diagonal
            // Length is less than the
            // Diameter, it is a valid
            // rectangle, thus increment counter
            if (diagonalLengthSquare <= diameterSquare)
            {
                rectangles++;
            }
        }
    }
 
    return rectangles;
}
 
// Driver Code
 
// Radius of the circle
let radius = 2;
 
let totalRectangles;
totalRectangles = countRectangles(radius);
document.write( totalRectangles + " rectangles can be cut from a circle of Radius " +radius);
 
// This code is contributed by sravan kumar

输出：

8 rectangles can be cut from a circle of Radius 2

时间复杂度： O(R ² )，其中 R 是圆的半径

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。