将一个矩形分割成 n 个大小相等的矩形

Question

我正在寻找一种算法，将一个矩形（比如说 1000x800）分割成 n 个（或更多，但尽可能少的额外矩形）在该矩形内大小相等的矩形，因此所有空间都被使用。小矩形也应尽量接近原始纵横比。

例如：

+---------------+
|               |
|               |
|               |
+---------------+

拆分为 n = 2：

+---------------+
|               |
+---------------+
|               |
+---------------+

拆分为 n = 3

+-------+-------+
|       |       |
+-------+-------+
|       |       |
+---------------+

等等

有这样的算法吗？理想情况下，我希望用 Python 编写它，但实际上任何语言都可以，因为我应该能够翻译它......

编辑：

一些额外的信息：

目标表面将是一个浏览器窗口，因此表面将大致为 4:3 或 16:9 或其他流行尺寸。矩形由像素组成。纵横比不保证为整数。

与纵横比限制相比，较少的多余矩形稍微可取。

Answer 1

（我假设，也许是错误的，你的矩形是无限可分的，而不是由离散的像素组成。）

通过让 m = ceil(sqrt(n)) 并在每边使用 m 个片段，您总是可以在浪费的矩形中以一定的成本获得准确的纵横比。

否则，您正在寻找接近 sqrt(n) 的 p,q 使得 pq >= n 和 p,q 彼此接近。 p,q 的最佳选择当然取决于您在浪费与不准确之间进行权衡的意愿。您似乎不太可能希望将 p,q 与 sqrt(n) 相距甚远，因为这样做会给您的形状带来很大的错误。所以我认为你想要这样的东西：

p = ceiling(sqrt(n))
best_merit_yet = merit_function(p,p,0)
best_configuration_yet = (p,p)
for p from floor(sqrt(n)) downward:
  # we need pq >= n and q as near to p as possible, which means (since p is too small) as small as possible
  q = ceiling(n/p)
  if max(merit_function(n/p,n/q,0), merit_function(n/q,n/p,0)) < best_merit_yet:
    break
  n_wasted = p*q-n
  merit1 = merit_function(n/p,n/q,n_wasted)
  merit2 = merit_function(n/q,n/p,n_wasted)
  if max(merit1,merit2) > best_merit_yet:
    if merit1 > merit2:
      best_configuration_yet = (p,q)
      best_merit_yet = merit1
    else:
      best_configuration_yet = (q,p)
      best_merit_yet = merit2

希望非常错误的形状非常糟糕这一事实意味着您实际上不必进行多次循环迭代。

在这里，merit_function 应该体现您对形状与浪费进行权衡的偏好。

Answer 2

使用此函数获取 2 个数字作为列表：

def divide_equally(n):
    if (n<3):
        return [n, 1]
    result = list()
    for i in range(1, int(n ** 0.5) + 1):
       div, mod = divmod(n, i)
       #ignore 1 and n itself as factors
       if mod == 0 and i != 1 and div != n:
           result.append(div)
           result.append(i)
    if len(result)==0: # if no factors then add 1
        return divide_equally(n+1)
    return result[len(result)-2:]

例如：

print divide_equally(1)
print divide_equally(50)
print divide_equally(99)
print divide_equally(23)
print divide_equally(50)

会给

[1, 1]
[10, 5]
[11, 9]
[6, 4]  # use the next even number (24)
[10, 5] # not [25, 2] use the 2 closest numbers 

Answer 3

编辑：第二个想法：

var countHor = Math.Floor(Math.Sqrt(n));
var countVer = Math.Ceil(n / countHor);
var widthDivided = widthTotal / countVer;
var heightDivided = heightTotal / countHor;

虽然结果取决于您更喜欢矩形比例还是额外的矩形数量（例如，对于 n = 14，应该是 2x7 还是 3x5，对于 n = 7，应该是 3x3 还是 2x4）

第一个想法是错误的，由于一些消耗：

如果你想获得最少数量的相等矩形，你应该使用 sqrt 操作。例如，如果 n = 9，那么它将是 3x3 矩形（垂直 2 行，水平 2 行）。如果 n = 10，它将是 3x4 矩形，如 floor(sqrt(10)) x ceil(sqrt(10)) => 3x4（垂直 2 行，水平 3 行或其他）。

这只是一般的算法思想，根据您的要求，您应该构建正确的算法。

新矩形的大小如下：

var widthDivided = widthTotal / Math.Floor(Math.Sqrt(count));
var heightDivided = heightTotal / Math.Ceil(Math.Sqrt(count));

这是类似的任务，但它不会返回最小值： Algorithm to split rectangle into n smaller rectangles and calculate each center