具有大量子问题的动态编程

具有大量子问题的动态编程。因此，我正在尝试通过Interview Street解决此问题：

网格漫游（得分50分）
您位于维网格中，位置为。网格的尺寸为）。一步，您可以在维度中的任何一个维度上向前或向后走一步。（因此，总是有可能的不同动作）。您可以采用多少种方法采取步骤，以使您在任何时候都不会离开网格？如果有任何，则离开网格，或。（X 1，X 2，... ，X Ñ）（d 1，d 2，... ，d Ñ Ñ 2 Ñ 中号X 我X 我 ≤ 0 X 我 > d $N$$(x_1,x_2,\dots,x_N)$$(D_1,D_2,\dots,D_N$$N$$2N$$M$$x_i$$x_i \leq 0$$x_i > D_i$

我的第一个尝试是这个记住的递归解决方案：

def number_of_ways(steps, starting_point):
    global n, dimensions, mem
    #print steps, starting_point
    if (steps, tuple(starting_point)) in mem:
        return mem[(steps, tuple(starting_point))]
    val = 0
    if steps == 0:
        val = 1
    else:
        for i in range(0, n):
            tuple_copy = starting_point[:]
            tuple_copy[i] += 1
            if tuple_copy[i] <= dimensions[i]:
                val += number_of_ways(steps - 1, tuple_copy)
            tuple_copy = starting_point[:]
            tuple_copy[i] -= 1
            if tuple_copy[i] > 0:
                val += number_of_ways(steps - 1, tuple_copy)
    mem[(steps, tuple(starting_point))] = val
    return val

大惊喜：由于缺少内存，它在许多步骤和/或尺寸上失败了。

因此，下一步就是使用动态编程来改进我的解决方案。但是在开始之前，我发现该方法存在一个主要问题。参数starting_point是元组，其中等于。因此，实际上，该函数可能具有 。Ñ 10 1 ≤ X 我 ≤ $n$$n$$10$number_of_ways(steps, x1, x2, x3, ... x10)$1 \leq x_i \leq 100$

我在教科书中看到的动态编程问题几乎都包含twp变量，因此只需要一个二维矩阵。在这种情况下，将需要一个十维矩阵。因此总共有单元。$100^{10}$

对于动态编程中的二维矩阵，通常仅需要前一行计算才能进行下一次计算，因此将空间复杂度从降低到。在这种情况下，我不确定该怎么做。可视化表格是不可行的，因此答案必须直接来自上面的递归。$mn$$\min(m,n)$

更新

根据彼得·索尔（Peter Shor）的建议，并进行一些较小的更正，尤其是需要跟踪函数中的位置，而不是仅将维度分为两组A和B，而是使用a进行递归拆分分而治之的方法，直到达到基本情况，即集合中只有一个维。$W(i, t_i)$

我想出了以下实现，通过了所有测试，但未超过最大执行时间：

def ways(di, offset, steps):
    global mem, dimensions
    if steps in mem[di] and offset in mem[di][steps]:
        return mem[di][steps][offset]
    val = 0
    if steps == 0:
        val = 1
    else:
        if offset - 1 >= 1:
            val += ways(di, offset - 1, steps - 1)
        if offset + 1 <= dimensions[di]:
            val += ways(di, offset + 1, steps - 1)
    mem[di][steps][offset] = val
    return val


def set_ways(left, right, steps):
    # must create t1, t2, t3 .. ti for steps
    global mem_set, mem, starting_point
    #print left, right
    #sleep(2)
    if (left, right) in mem_set and steps in mem_set[(left, right)]:
        return mem_set[(left, right)][steps]
    if right - left == 1:
        #print 'getting steps for', left, steps, starting_point[left]
        #print 'got ', mem[left][steps][starting_point[left]], 'steps'
        return mem[left][steps][starting_point[left]]
        #return ways(left, starting_point[left], steps)
    val = 0
    split_point =  left + (right - left) / 2 
    for i in xrange(steps + 1):
        t1 = i
        t2 = steps - i
        mix_factor = fact[steps] / (fact[t1] * fact[t2])
        #print "mix_factor = %d, dimension: %d - %d steps, dimension %d - %d steps" % (mix_factor, left, t1, split_point, t2)
        val += mix_factor * set_ways(left, split_point, t1) * set_ways(split_point, right, t2)
    mem_set[(left, right)][steps] = val
    return val

import sys
from time import sleep, time

fact = {}
fact[0] = 1
start = time()
accum = 1
for k in xrange(1, 300+1):
    accum *= k
    fact[k] = accum
#print 'fact_time', time() - start

data = sys.stdin.readlines()
num_tests = int(data.pop(0))
for ignore in xrange(0, num_tests):
    n_and_steps = data.pop(0)
    n, steps = map(lambda x: int(x), n_and_steps.split())
    starting_point = map(lambda x: int(x), data.pop(0).split())
    dimensions = map(lambda x: int(x), data.pop(0).split())
    mem = {}
    for di in xrange(n):
        mem[di] = {}
        for i in xrange(steps + 1):
            mem[di][i] = {}
            ways(di, starting_point[di], i)
    start = time()
    #print 'mem vector is done'
    mem_set = {}
    for i in xrange(n + 1):
        for j in xrange(n + 1):
            mem_set[(i, j)] = {}
    answer = set_ways(0, n, steps)
    #print answer
    print answer % 1000000007
    #print time() - start

不同的维度是独立的。您可以做的是，针对每个维度j，计算该维度中有多少不同的步行路程，这些步行路程需要步。让我们称该数字为。从您的问题中，您已经知道如何使用动态编程来计算这些数字。W （j ，t $t$$W(j,t)$

现在，很容易计算在维度采取步的步行次数。您有 散布维度，以便维度采取的步骤总数为，并且对于每种方式，您都有步行。对这些求和求 现在，由于您只需要记住值，内存就处于控制之下。对于大的，时间的增长是多项式的，但是大多数计算机的时间要比内存多得多。$t_i$$i$我Ť我ΠÑ1w ^（我，吨我）Σ吨1+吨2+...+吨Ñ=中号（$N \choose t_1,t_2, \ldots, t_M$$i$$t_i$$\Pi_1^N W(i,t_i)$W（j，t）

您可以做得更好。递归划分维度分为两个子集，和，以及计算有多少走有只使用在子维度，只是那些在。分别称这些数字为和。您得到的步行总数B A B W A（t ）W B（t $A$$B$$A$$B$$W_A(t)$$W_B(t)$

让我们从代码中提取的公式（对于内部单元格，它忽略边界情况）：$\newcommand{\now}{\operatorname{now}}\now(s,x_1,\dots,x_n)$

$\qquad \begin{align} \now(s,x_1,\dots,x_n) = \phantom{+} &\sum_{i=0}^n \now(s-1,x_1,\dots,x_{i-1},x_i + 1, x_{i+1},\dots,x_n) \\ + &\sum_{i=0}^n\now(s-1,x_1,\dots,x_{i-1},x_i - 1, x_{i+1},\dots,x_n) \end{align}$

这里有一些想法。

• 我们看到，一旦您计算了所有值，就可以删除所有计算值。$s=k$$s<k$
• 对于固定，您应该按字典顺序计算表条目（仅因为它很简单）。然后，请注意，每个像元只需要在“一个半径”内的此类像元，即没有坐标可以比一个更远。因此，一旦迭代达到，就可以删除所有值。如果这还不够，请对执行相同的操作-对于固定的，在达到时删除和值-依此类推。$s$$x_1=i$$x_1\leq i-2$$x_2$$x_1=i$$x_1 = i$$x_2 \leq j-2$$x_2=j$
• 请注意，“所以总是有可能的不同移动”仅在网格的中间成立，也就是说，对于所有，如果且。但是，这也意味着，答案很简单，中间：这只是。如果您具有有效的动态编程重复性，那么仅此一项就可以使您节省掉大部分表（如果）。$2N$$x_i - M > 0$$x_i + M < D_i$$i$$(2N)^M$$M\ll N$
• 需要注意的另一件事是，您不必计算整个表。无论如何，大多数值都将填充（如果）。您可以将自己限制在左右的边长的（超）立方体中（请注意，由于离开网格的路径，它会凹入）。中号« Ñ 2 中号$0$$M\ll N$$2M$$x$

这应该足以使内存使用率保持在较低水平。