向量分区是将向量分割为一系列向量，以使它们的和为原始向量。这是几个分区：

[3, 1, 2] = [3, 1, 2]
[3, 1, 2] = [0, 0, 1] + [0, 0, 1] + [0, 1, 0] + [1, 0, 0] + [2, 0, 0]
[3, 1, 2] = [1, 1, 2] + [2, 0, 0]

在这里，矢量加法是逐个元素地完成的。有效分区不包含任何带有负整数的矢量或全零矢量。

现在的挑战是编写一个程序或函数，以给定目标向量生成所有可能的向量分区。这听起来相对容易...

...但是有一个转折。如果输入向量的大小为L，并且它生成的最大分区具有M个元素，则使用的内存不得超过O（L * M）。

您可以假定整数使用O（1）内存。这意味着您必须在生成分区时输出分区。最重要的是，每个分区只能输出一次。例如，这些是相同的分区：

[3, 1, 2] = [3, 0, 2] + [0, 1, 0]
[3, 1, 2] = [0, 1, 0] + [3, 0, 2]

如果您都输出，则您的答案均无效。

的所有分区[3, 2]：

[3, 2]
[0, 1] + [3, 1]
[0, 1] + [0, 1] + [3, 0]
[0, 1] + [0, 1] + [1, 0] + [2, 0]
[0, 1] + [0, 1] + [1, 0] + [1, 0] + [1, 0]
[0, 1] + [1, 0] + [2, 1]
[0, 1] + [1, 0] + [1, 0] + [1, 1]
[0, 1] + [1, 1] + [2, 0]
[0, 2] + [3, 0]
[0, 2] + [1, 0] + [2, 0]
[0, 2] + [1, 0] + [1, 0] + [1, 0]
[1, 0] + [2, 2]
[1, 0] + [1, 0] + [1, 2]
[1, 0] + [1, 1] + [1, 1]
[1, 1] + [2, 1]
[1, 2] + [2, 0]

要测试您的答案，请在上运行它[3, 2, 5, 2]。它应该生成17939个分区，所有分区的总和为[3, 2, 5, 2]，并且都是唯一的（您可以通过按字典顺序对每个分区进行排序来测试唯一性）。

以字节为单位的最短代码获胜。

Python 2，289字节

简单的蛮力算法。将整个列表视为以max(input)+1（b）为基的数字，并检查范围内的每个“数字” [0, b**(L*M))以查看是否：

1. 汇总到正确的数量
2. 按字母顺序排列（确保唯一性）

如果列表符合这些条件，则程序将其输出并去除所有全零向量。

内存使用情况

我在此程序中使用的最大数据结构是双嵌套列表，列表长度M包含L要提供O(L*M)内存的liss长度。

对于其他数据结构，我有3个全局整数O(3)，1个列表长度L（O(L)），1个数组长度M（O(M)）和输出（O(L*M)）时最大数组的副本。

总的来说，这使我的内存使用量O(2*L*M + L + M + 3)简化为O(L*M)，从而满足了标准。

时间复杂度

作为蛮力算法，该算法非常慢。要退出while循环，数组中的最后一个int必须为b-1。循环需要运行b**(L*M)时间才能发生。

此外，每次运行列表时，都需要检查两个条件，并在最坏的情况下使用L*M+L+M迭代来打印列表。这简化了总体规划O(L*M * b**(L*M))。我尝试在上测试程序[3, 2, 5, 2]，但在45分钟后放弃了。

打高尔夫球的程序

v=input()
L=len(v)
M=sum(v)
b=max(v)
R=range
t=[L*[0]for i in R(M)]
def A(l,i):
 if i<L*M-1and~-b<l[i/L][i%L]:A(l,i+1)
 l[i/L][i%L]=-~l[i/L][i%L]%-~b
while t[-1][-1]<b:
 if v==[sum(q[i]for q in t)for i in R(L)]and all(`t[i]`>=`t[i+1]`for i in R(M-1)):print[x for x in t if[0]*L!=x]
 A(t,0)

我也许可以打更多的高尔夫球，尤其是增量部分。空缺的代码来了。