此问题与KenKen拉丁方谜题的某些部分有关，这些部分要求您查找具有值x的ncell数的所有可能组合，使得1 <= x <= maxval和x（1）+
… + x（ncells）= targetum。测试了一些更有希望的答案后，我将把答案奖授予Lennart Regebro，因为：

1. 他的作息速度和我的一样快（+ -5％），并且

2. 他指出，我原来的例程在某个地方有一个错误，这使我看到了它真正在试图做什么。谢谢，Lennart。

chrispy贡献了一种算法，该算法似乎与Lennart的算法相同，但是5个小时后，如此糟糕，首先要得到它。

备注：Alex
Martelli的裸机递归算法是一个示例，它进行每种可能的组合，并将所有组合放到一个筛子上，然后看哪一个通过孔。这种方法比Lennart或我的方法花费20倍以上的时间。（将输入的值设置为max_val
= 100，n_cells = 5，target_sum = 250，在我的盒子上是18秒vs. 8分钟以上。）道德：不生成所有可能的组合都是好的。

另一句话：Lennart和我的例程 以相同的顺序 生成 相同的答案 。从不同的角度看，它们实际上是同一算法吗？我不知道。

我出事了。如果您对答案进行排序，则以（8,8,2,1,1）开始，以（4,4,4,4,4）结尾（以max_val = 8，n_cells =
5，target_sum得到的结果） =
20），则该系列形成“最慢下降”的形式，其中第一个下降为“热”，最后一个下降为“冷”，其间可能出现的最大阶段数。这和“信息熵”有关吗？什么是合适的衡量标准？是否有一种算法以热的降序（或升序）生成组合？（据我所见，这是没有的，尽管它在很短的时间内就关闭了，并查看了标准化的标准开发人员。）

这是Python例程：

#!/usr/bin/env python
#filename: makeAddCombos.07.py -- stripped for StackOverflow

def initialize_combo( max_val, n_cells, target_sum):
    """returns combo
    Starting from left, fills combo to max_val or an intermediate value from 1 up.  
    E.g.:  Given max_val = 5, n_cells=4, target_sum = 11, creates [5,4,1,1].
    """
    combo = []
    #Put 1 in each cell.
    combo += [1] * n_cells
    need = target_sum - sum(combo)
    #Fill as many cells as possible to max_val.
    n_full_cells = need //(max_val - 1)
    top_up = max_val - 1
    for i in range( n_full_cells): combo[i] += top_up
    need = target_sum - sum(combo)
    # Then add the rest to next item.
    if need > 0:
        combo[n_full_cells] += need
    return combo
#def initialize_combo()

def scrunch_left( combo):
    """returns (new_combo,done)
    done   Boolean; if True, ignore new_combo, all done;
            if Falso, new_combo is valid.

    Starts a new combo list.  Scanning from right to left, looks for first
    element at least 2 greater than right-end element.  
    If one is found, decrements it, then scrunches all available counts on its
    right up against its right-hand side.  Returns the modified combo.
    If none found, (that is, either no step or single step of 1), process
    done.
    """
    new_combo = []
    right_end = combo[-1]
    length = len(combo)
    c_range = range(length-1, -1, -1)
    found_step_gt_1 = False
    for index in c_range:
        value = combo[index]
        if (value - right_end) > 1:
            found_step_gt_1 = True
            break
    if not found_step_gt_1:
        return ( new_combo,True)

    if index > 0:
        new_combo += combo[:index]
    ceil = combo[index] - 1
    new_combo += [ceil]
    new_combo += [1] * ((length - 1) - index)
    need = sum(combo[index:]) - sum(new_combo[index:])
    fill_height = ceil - 1
    ndivf = need // fill_height
    nmodf = need % fill_height
    if ndivf > 0:
        for j in range(index + 1, index + ndivf + 1):
            new_combo[j] += fill_height
    if nmodf > 0:
        new_combo[index + ndivf + 1] += nmodf
    return (new_combo, False)
#def scrunch_left()

def make_combos_n_cells_ge_two( combos, max_val, n_cells, target_sum):
    """
    Build combos, list of tuples of 2 or more addends.
    """
    combo = initialize_combo( max_val, n_cells, target_sum)
    combos.append( tuple( combo))
    while True:
        (combo, done) = scrunch_left( combo)
        if done:
            break
        else:
            combos.append( tuple( combo))
    return combos
#def make_combos_n_cells_ge_two()

if __name__ == '__main__':

    combos = []
    max_val     = 8
    n_cells     = 5
    target_sum  = 20
    if n_cells == 1: combos.append( (target_sum,))
    else:
        combos = make_combos_n_cells_ge_two( combos, max_val, n_cells, target_sum)
    import pprint
    pprint.pprint( combos)