Question

我遇到动态编程问题。我已经针对测试用例测试了我的解决方案，这是正确的。但是，它太慢了。这让我相信我可能没有有效地缓解子问题的解决方案。这是问题陈述：

有一个包含N个数字的数组A.给定一个数组，只有当每个子数组中的元素总和为相同值时，玩家才能将数组拆分为两个非空子数组。在进行分割之后，玩家丢弃一个子阵列并且允许继续分裂剩余的子阵列。这种情况一直持续到不再可能分裂为止。给定阵列A上可能的最大分割数是多少？

这是我的（慢）解决方案，它在给定数组上调用topSplit（A）：

def topSplitAux(A, C, i, j):

    if -1 != C[i][j]:
        return C[i][j]

    if i == j:
        return 0

    s = float('-inf')
    for k in range(i + 1, j): 
        if sum(A[i:k]) == sum(A[k:j]):
            p1 = 1 + topSplitAux(A, C, i, k)
            p2 = 1 + topSplitAux(A, C, k, j)
            s = max(s, p1, p2)
            C[i][j] = s 
    if s == float('-inf'):    # we couldn't split, game over 
        C[i][j] = 0
    return C[i][j]

def topSplit(A):

    # initialize a cache to store solutions already solved 
    n = len(A)
    # the subproblem we are interested in will be in C[0][n]
    C = [[-1 for _ in range(n + 1)] for _ in range(n + 1)]

    return topSplitAux(A, C, 0, n)

if __name__ == '__main__':
    T = int(raw_input())
    for t in range(T):
        N = int(raw_input())
        A = map(int, raw_input().split())
        n = len(A)
        print topSplit(A)

这是一个简单的测试用例：

3
3
3 3 3
4
2 2 2 2
7
4 1 0 1 1 0 1

预期结果：

0
2
3

任何有关更快地提供此解决方案的帮助将非常感激。谢谢！

将数组拆分为相等的子数组的解决方案太慢

0 个答案: