Question

我有一个矩形大小W x H和一个更大的矩形，其边长是W和H的GCD的倍数。

我正在尝试确定我可以放入较大矩形的较小矩形的最大数量。较小的矩形可以旋转。我也不在乎右上角的空隙。

到目前为止，我已提出：

// +-------------+ We have 3 potential sections to fill with rects. The
// |      C      | inital calculation is for section A. If A doesn't
// +-------+-----+ consume the entire area then we then try and fill the
// |       |     | other areas with the alternate rotation.
// |   A   |  B  |
// |       |     |
// +-------+-----+
//
int numWidthA = (int)Math.floor(width / rect[0]);
int numLengthA = (int)Math.floor(length / rect[1]);
int numWidthB = 0;
int numLengthB = 0;
int numWidthC = 0;
int numLengthC = 0;

double remainingWidth = width - (numWidthA * rect[0]);
double remainingLength = length - (numLengthA * rect[1]);

if(remainingWidth != 0) {
    double usedLength = numLengthA * rect[1];

    numWidthB = (int)Math.floor(remainingWidth / rect[1]);
    numLengthB = (int)Math.floor(usedLength / rect[0]);
}

if(remainingLength != 0) {
    numWidthC = (int)Math.floor(width / rect[1]);
    numLengthC = (int)Math.floor(remainingLength / rect[0]);
}

System.out.printf("Rotation: %.1f x %.1f%n", rect[0], rect[1]);
System.out.printf("A: %d x %d%n", numWidthA, numLengthA);
System.out.printf("B: %d x %d%n", numWidthB, numLengthB);
System.out.printf("C: %d x %d%n", numWidthC, numLengthC);

return (numWidthA * numLengthA) + (numWidthB * numLengthB) +
       (numWidthC * numLengthC);

如果初始部分A部分过于贪婪，则会失败。它不断消耗太多空间，以至于在另一部分中没有足够的空间进行交替旋转。即它为H / 2而不是H留下了空间。如果它使用了所有可用的房间，没问题，那就是它几乎占用了整个房间。

我试图以递归方式删除一个矩形，直到有足够的空间容纳多个备用旋转但由于双精度错误而遇到麻烦。所以我希望有另一种解决方案吗？

我也不喜欢这个解决方案，因为它将算法从O（1）带到O（n）

另一个问题是确定矩形的初始旋转，此时我看到哪个旋转占用了最多的区域，并将该旋转用于A部分。

将相同大小的矩形布局成更大的矩形的算法

0 个答案: