Programmazione dinamica con un gran numero di sottoproblemi

Programmazione dinamica con un gran numero di sottoproblemi. Quindi sto cercando di risolvere questo problema da Interview Street:

Grid Walking (segna 50 punti)
Ti trovi in ​​una griglia dimensionale in posizione . Le dimensioni della griglia sono ). In un passo, puoi camminare un passo avanti o indietro in una qualsiasi delle dimensioni. (Quindi ci sono sempre possibili mosse diverse). In quanti modi puoi fare passi in modo tale da non lasciare la griglia in nessun punto? Si lascia la griglia se per qualsiasi , o o .$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$

Il mio primo tentativo è stato questa soluzione ricorsiva memorizzata:

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

Grande sorpresa: fallisce per un gran numero di passaggi e / o dimensioni a causa della mancanza di memoria.

Quindi il prossimo passo è migliorare la mia soluzione usando la programmazione dinamica. Ma prima di iniziare, sto riscontrando un grave problema con l'approccio. L'argomento starting_pointè una -tupla, dove è grande quanto . Quindi, in effetti, la funzione potrebbe essere con .n 10 1 ≤ x i ≤ $n$$n$$10$number_of_ways(steps, x1, x2, x3, ... x10)$1 \leq x_i \leq 100$

I problemi di programmazione dinamica che ho visto nei libri di testo hanno quasi tutti variabili twp, quindi è necessaria solo una matrice bidimensionale. In questo caso, sarebbe necessaria una matrice tridimensionale. Quindi celle in totale.$100^{10}$

Con le matrici 2D nella programmazione dinamica, di solito è necessaria solo la riga precedente di calcoli per il calcolo successivo, riducendo quindi la complessità spaziale da a . Non sono sicuro di come farei lo stesso in questo caso. Visualizzare una tabella non è fattibile, quindi la risposta dovrebbe provenire direttamente dalla ricorsione sopra.$mn$$\min(m,n)$

AGGIORNARE

Utilizzando i suggerimenti di Peter Shor e apportando alcune correzioni minori, in particolare la necessità di tenere traccia della posizione nella funzione e piuttosto di dividere solo le dimensioni in due insiemi A e B, facendo la scissione ricorsivamente, efficacemente usando un metodo divide-and-conquer, fino a quando non viene raggiunto un caso base in cui solo una dimensione è nell'insieme.$W(i, t_i)$

Mi è venuta in mente la seguente implementazione, che ha superato tutti i test al di sotto del tempo massimo di esecuzione:

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

Le diverse dimensioni sono indipendenti . Quello che puoi fare è calcolare, per ogni dimensione j , quante diverse camminate ci sono proprio in quella dimensione che fa passi. Chiamiamo quel numero . Dalla tua domanda, sai già come calcolare questi numeri con la programmazione dinamica.$t$$W(j,t)$

Ora è facile contare il numero di camminate che compiono passi nella dimensione . Hai modi di intervallare le dimensioni in modo tale che il numero totale di passi fatti nella dimensione sia , e per ognuno di questi modi hai . Sommati su questi per ottenere Ora, la memoria è sotto controllo, poiché devi solo ricordare i valori . Il tempo aumenta in modo superpolinomiale per grandi dimensioni , ma la maggior parte dei computer ha molto più tempo della memoria.$t_i$$i$$N \choose t_1,t_2, \ldots, t_M$$i$$t_i$$\Pi_1^N W(i,t_i)$

Puoi fare ancora meglio. Ricorsivamente dividere le dimensioni in due sottoinsiemi, e , e calcolare quante passeggiate ci sono utilizzando solo le dimensioni in sottoinsieme , e solo quelli in . Chiama questi numeri e , rispettivamente. Ottieni il numero totale di passeggiate$A$$B$$A$$B$$W_A(t)$$W_B(t)$

Estraiamo una formula per dal tuo codice (per una cella interna, che ignora i casi limite):$\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}$

Ecco alcune idee.

• Vediamo che una volta calcolati tutti i valori per , è possibile eliminare tutti i valori calcolati per .$s=k$$s<k$
• Per una fissa , è necessario calcolare le voci della tabella in ordine lessicografico (solo perché è semplice). Quindi, nota che ogni cella ha bisogno solo di tali celle all'interno di un "raggio di una", cioè nessuna coordinata può essere più lontana di una. Pertanto, una volta che l'iterazione raggiunge , è possibile eliminare tutti i valori per . Se questo non è sufficiente, fare lo stesso per - per fisso , valori di perdita con e quando è raggiunto - e così via.$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$
• Nota che "quindi ci sono sempre possibili mosse diverse" vale solo nel mezzo della griglia, cioè se e per tutti . Ma questo significa anche che la risposta è facile in mezzo: è solo . Se avessi una recidiva di programmazione dinamica funzionante, questo da solo ti permetterebbe di radere via la maggior parte della tabella (se ).$2N$$x_i - M > 0$$x_i + M < D_i$$i$$(2N)^M$$M\ll N$
• Un'altra cosa da notare è che non è necessario calcolare l'intera tabella; la maggior parte dei valori verrà comunque riempita con (se ). Puoi limitarti al cubo (iper) di lunghezza del bordo intorno a (nota che verrà ammaccato a causa dei percorsi che escono dalla griglia).$0$$M\ll N$$2M$$x$

Ciò dovrebbe essere sufficiente per mantenere l'utilizzo della memoria piuttosto basso.