Çok sayıda alt problemle dinamik programlama

Çok sayıda alt problemle dinamik programlama. Bu yüzden Interview Street'ten bu sorunu çözmeye çalışıyorum:

Izgara Yürüyüş (50 puan Skoru)
Bir yer almaktadır konumunda boyutlu ızgara . Izgaranın boyutları ). Bir adımda, boyutlarından herhangi birinde bir adım önde veya arkada yürüyebilirsiniz . (Yani her zaman olası farklı hamle vardır). Izgarayı hiçbir noktada bırakmayacak şekilde adımlarını kaç şekilde uygulayabilirsiniz? Herhangi bir , veya .$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$

İlk denemem bu memoized özyinelemeli çözüm oldu:

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

Büyük sürpriz: bellek yetersizliği nedeniyle çok sayıda adım ve / veya boyut için başarısız oluyor.

Bir sonraki adım dinamik programlama kullanarak çözümümü geliştirmek. Ama başlamadan önce yaklaşımla ilgili büyük bir sorun görüyorum. Bağımsız değişken starting_pointbir bir -tuple, kadar büyüktür . Yani aslında, fonksiyon olabilir ile .n 10 1 ≤ x i ≤ $n$$n$$10$number_of_ways(steps, x1, x2, x3, ... x10)$1 \leq x_i \leq 100$

Ders kitaplarında gördüğüm dinamik programlama problemlerinin neredeyse hepsinde twp değişkenleri var, böylece sadece iki boyutlu bir matris gerekli. Bu durumda, on boyutlu bir matrise ihtiyaç duyulacaktır. Yani toplamda hücre.$100^{10}$

Dinamik programlamada 2-B matrisler ile, hesaplamalar genellikle sadece önceki satır dolayısıyla uzamsal karmaşıklığını azaltarak, bir sonraki hesaplama için gerekli olan için . Bu durumda nasıl yapacağımı bilmiyorum. Bir tabloyu görselleştirmek mümkün değildir, bu nedenle cevabın doğrudan yukarıdaki yinelemeden gelmesi gerekecektir.$mn$$\min(m,n)$

GÜNCELLEME

Peter Shor'un önerilerini kullanmak ve bazı küçük düzeltmeler yapmak, özellikle işlevindeki konumu takip etmek ve boyutları iki A ve B setine bölmek yerine, bölmeyi yinelemeli olarak, etkili bir şekilde kullanarak kümede yalnızca bir boyutun bulunduğu bir temel duruma ulaşılana kadar böl ve fethetme yöntemi.$W(i, t_i)$

Tüm testleri maksimum yürütme süresinin altında geçen aşağıdaki uygulama ile geldim:

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

Farklı boyutlar bağımsızdır . Ne yapabilirsiniz her boyut için, hesaplamak olduğunu j almak sadece bu boyutta var, kaç farklı yürür adımlarını. O sayıya diyelim . Sorunuzdan, bu sayıları dinamik programlama ile nasıl hesaplayacağınızı zaten biliyorsunuz.W ( j , t $t$$W(j,t)$

Şimdi, boyutunda adımlarını yürüyüş sayısını saymak kolaydır . Sen var böylece boyutta atılan adımlar toplam sayısı boyutlarını interspersing yollarını olan ve bu yöntemin her biri için sahip olduğunuz yürür. Bu fazla miktar almak için Şimdi, bellek kontrol altında, çünkü sadece değerlerini hatırlamanız gerekiyor . Büyük için zaman süperpolinom olarak büyür , ancak çoğu bilgisayarın hafızadan çok daha fazla zamanı vardır. i ($t_i$$i$itiΠN1W(i,ti)∑t1+t2+…+tN=M($N \choose t_1,t_2, \ldots, t_M$$i$$t_i$$\Pi_1^N W(i,t_i)$W(j,t)

Daha da iyisini yapabilirsiniz. Boyutları ve olarak iki alt kümeye yinelemeli olarak bölün ve yalnızca alt kümesindeki boyutları ve sadece boyutları kullanarak kaç yürüyüş olduğunu hesaplayın . Bu numaralara ve . Toplam yürüyüş sayısınıB A B W A ( t ) W B ( t $A$$B$$A$$B$$W_A(t)$$W_B(t)$

için bir formül (iç hücre için, sınır durumlarını yok sayan):$\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}$

İşte bazı fikirler.

• için tüm değerleri hesapladıktan sonra , için tüm hesaplanan değerleri düşürebileceğinizi görüyoruz .$s=k$$s<k$
• Sabit bir , tablo girişlerini sözlükbilimsel sırayla hesaplamanız gerekir (sadece basit olduğu için). Daha sonra, her hücrenin sadece bir "yarıçapı" içinde bu tür hücrelere ihtiyacı olduğunu, yani koordinatın bir hücreden daha uzakta olamayacağını unutmayın. Bu nedenle, yinelemeniz değerine , için tüm değerleri düşürebilirsiniz . Bu yeterli değilse, için aynı şeyi - Sabit için ile, damla değerlerine ve ulaşıldığında - vb.$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$
• "Bu nedenle her zaman olası farklı hareket vardır" ifadesinin yalnızca ızgaranın ortasında olduğunu, yani tüm için ve olduğunu unutmayın . Ama yanıt kolaydır orta olduğunu da araçlarının: bu sadece . Çalışan bir dinamik programlama yinelemeniz varsa, bu tek başına tablonun çoğunu tıraş etmenize izin verecektir ( ).$2N$$x_i - M > 0$$x_i + M < D_i$$i$$(2N)^M$$M\ll N$
• Dikkat edilmesi gereken başka bir şey, tüm tabloyu hesaplamanıza gerek olmadığıdır; çoğu değer yine de ile doldurulur ( ). Kendinizi etrafındaki kenar uzunluğundaki (hiper) küple sınırlandırabilirsiniz ( ızgaradan çıkan yollar nedeniyle eğileceğini unutmayın).$0$$M\ll N$$2M$$x$

Bellek kullanımını oldukça düşük tutmak için bu yeterli olmalıdır.