多数の副問題を伴う動的プログラミング

多数の副問題がある動的プログラミング。だから私はインタビューストリートからこの問題を解決しようとしています：

グリッド・ウォーキング（50点のスコア）
あなたはに位置しているの位置に次元グリッド。グリッドの次元は）です。1つのステップで、次元のいずれかを1つ前または後ろに歩くことができます。（したがって、常に可能な異なる動きがあります）。どの時点でもグリッドを離れないように、ステップをいくつ実行できますか？あなたは、任意のためならば、グリッドを離れる、どちらかまたは。（X 1は、xは2、... 、xはN）（D 1、D 2、... 、D N N 2 N M X I 、X I ≤ 0 X I > 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はタプルで、は大きさです。だから、実際には、関数は可能性で 。、N 10 1 ≤ X I ≤ $n$$n$$10$number_of_ways(steps, x1, x2, x3, ... x10)$1 \leq x_i \leq 100$

私が教科書で見た動的プログラミングの問題はほとんどすべてtwp変数を持っているので、2次元のマトリックスだけが必要です。この場合、10次元のマトリックスが必要になります。そう合計細胞。$100^{10}$

動的計画法の2次元行列では、通常、次の計算に必要なのは前の行の計算のみなので、空間の複雑さがから減少します。この場合、同じようにする方法がわかりません。テーブルを視覚化することは現実的ではないため、答えは上記の再帰から直接取得する必要があります。$mn$$\min(m,n)$

更新

Peter Shorの提案を使用し、特に関数で位置を追跡する必要性など、いくつかのマイナーな修正を行い、次元を2つのセットAとBに分割するだけでなく、再帰的に分割を行い、効果的に分割統治法。1つの次元のみがセットに含まれる基本ケースに到達するまで。$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について、その次元にステップを実行するさまざまなウォークがいくつあるかを計算することです。その数をと呼びましょう。あなたの質問から、あなたはすでに動的プログラミングでこれらの数値を計算する方法を知っています。$t$$W(j,t)$

これで、ディメンションステップの歩行数を簡単にカウントます。あなたは持っている 次元で撮影した総ステップ数がそうすることを点在さ寸法の方法をある、およびこれらの方法のそれぞれのためにあなたが持っている歩きます。これらを合計して これで、値を覚えるだけでよいので、メモリが制御されます。大きな場合、時間は超多項的に増加しますが、ほとんどのコンピュータはメモリよりも多くの時間を持っています。$t_i$$i$$N \choose t_1,t_2, \ldots, t_M$$i$$t_i$$\Pi_1^N W(i,t_i)$

あなたはもっと上手にできる。再帰的に2つのサブセット、に寸法を分割と、及び計算は、どのように多くのサブセットにだけ寸法を使用しているが歩く、ちょうどそれらに。これらの番号をおよびとます。合計歩行数を取得します$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$
• 固定場合、テーブルエントリを辞書式順序で計算する必要があります（単純なため）。次に、すべてのセルは「1つの半径」内のセルのみを必要とすることに注意してください。つまり、座標は1よりも遠くにあることはできません。したがって、反復がにすると、すべての値を削除できます。不十分な場合は、についても同じことを行います。固定場合、に達したときにおよび値をドロップします。$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$
• 注意すべきもう1つの点は、テーブル全体を計算する必要がないことです。とにかく、ほとんどの値はで埋められます（場合）。中心としたエッジ長の（ハイパー）キューブに制限できます（グリッドから出るパスのために凹んでいることに注意してください）。$0$$M\ll N$$2M$$x$

これで、メモリ使用量をかなり低く抑えることができます。