Question

两周前，我在这里发布了关于动态编程的THIS问题。用户Andrea Corbellini正好回答了我想要的内容，但我想更进一步地解决这个问题。

这是我的功能

def Opt(n):
    if len(n) == 1:
        return 0
    else:
        return sum(n) + min(Opt(n[:i]) + Opt(n[i:])
                            for i in range(1, len(n)))

假设你打电话给

Opt( [ 1,2,3,4,5 ] )

前一个问题解决了计算最优值的问题。现在，而不是计算上述例子的最佳值33，我想打印我们获得最佳解决方案的方式（最佳解决方案的路径）。因此，我想打印列表被剪切/分割的索引，以便以列表的形式获得最佳解决方案。所以，上面例子的答案是：

[ 3,2,1,4 ]（在第三个标记/索引处切割极点/列表，然后在第二个索引之后，然后在第一个索引之后，最后在第四个索引处）。答案应该是列表的形式。列表的第一个元素将是列表的第一个剪切/除法应该在最佳路径中发生的索引。第二个元素将是列表的第二个剪切/分割，依此类推。

还可以有不同的解决方案：

[ 3,4,2,1 ]

它们都会引导您输出正确的输出。所以，你打印哪一个并不重要。但是，我不知道如何跟踪和打印动态编程解决方案所采用的最佳路径。顺便说一句，我找到了一个非递归的解决方案，解决了我之前提出的问题。但是，我仍然无法弄清楚打印最佳解决方案的路径。这是前一个问题的非递归代码，它可能有助于解决当前问题。

def Opt(numbers):
prefix = [0]
for i in range(1,len(numbers)+1):
    prefix.append(prefix[i-1]+numbers[i-1])
results = [[]]
for i in range(0,len(numbers)):
    results[0].append(0)
for i in range(1,len(numbers)):
    results.append([])
    for j in range(0,len(numbers)):
        results[i].append([])
for i in range(2,len(numbers)+1): # for all lenghts (of by 1)
    for j in range(0,len(numbers)-i+1): # for all beginning
        results[i-1][j] = results[0][j]+results[i-2][j+1]+prefix[j+i]-prefix[j]
        for k in range(1,i-1): # for all splits
            if results[k][j]+results[i-2-k][j+k+1]+prefix[j+i]-prefix[j] < results[i-1][j]:
                results[i-1][j] = results[k][j]+results[i-2-k][j+k+1]+prefix[j+i]-prefix[j]
return results[len(numbers)-1][0]

Answer 1

以下是打印所选内容的一种方法：

我在前一个问题中使用了@Andrea Corbellini提供的memoization的递归解决方案。如下所示：

cache = {}

def Opt(n):
    # tuple objects are hashable and can be put in the cache.
    n = tuple(n)

    if n in cache:
        return cache[n]

    if len(n) == 1:
        result = 0
    else:
        result = sum(n) + min(Opt(n[:i]) + Opt(n[i:])
                              for i in range(1, len(n)))

    cache[n] = result
    return result

现在，我们有所有元组的缓存值，包括选定的元组。

使用它，我们可以打印选定的元组，如下所示：

selectedList = []
def printSelected (n, low):

    if len(n) == 1:
        # No need to print because it's 
        # already printed at previous recursion level.
        return

    minVal = math.Inf
    minTupleLeft = ()
    minTupleRight = ()
    splitI = 0

    for i in range(1, len(n)):
        tuple1ToI = tuple (n[:i])
        tupleiToN = tuple (n[i:])

        if (cache[tuple1ToI] + cache[tupleiToN]) < minVal:
            minVal = cache[tuple1ToI] + cache[tupleiToN]
            minTupleLeft = tuple1ToI
            minTupleRight = tupleiToN
            splitI = low + i


    print minTupleLeft, minTupleRight, minVal
    print splitI   # OP just wants the split index 'i'.
    selectedList.append(splitI) # or add to the list as requested by OP

    printSelected (list(minTupleLeft), low)
    printSelected (list(minTupleRight), splitI)

您调用上述方法如下所示：

printSelected (n, 0)

更多关于动态编程

1 个答案: