Programación dinámica con gran cantidad de subproblemas.

Programación dinámica con gran cantidad de subproblemas. Así que estoy tratando de resolver este problema desde Interview Street:

Caminata de cuadrícula (Puntuación 50 puntos)
Está situado en una cuadrícula dimensional en la posición . Las dimensiones de la cuadrícula son ). En un paso, puede caminar un paso adelante o atrás en cualquiera de las dimensiones. (Por lo tanto, siempre hay movimientos diferentes posibles). ¿De cuántas maneras puede dar pasos para no abandonar la cuadrícula en ningún momento? Dejas la cuadrícula si para cualquier , ya sea 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$

Mi primer intento fue esta solución recursiva memorable:

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

Gran sorpresa: falla por una gran cantidad de pasos y / o dimensiones debido a la falta de memoria.

Entonces, el siguiente paso es mejorar mi solución usando programación dinámica. Pero antes de comenzar, veo un problema importante con el enfoque. El argumento starting_pointes una -tupla, donde es tan grande como . De hecho, la función podría ser con .n 10 1 ≤ x i ≤ $n$$n$$10$number_of_ways(steps, x1, x2, x3, ... x10)$1 \leq x_i \leq 100$

Los problemas de programación dinámica que he visto en los libros de texto casi todos tienen variables twp, por lo que solo se necesita una matriz bidimensional. En este caso, se necesitaría una matriz de diez dimensiones. Entonces celdas en total.$100^{10}$

Con las matrices bidimensionales en programación dinámica, generalmente solo se necesita la fila anterior de cálculos para el siguiente cálculo, por lo tanto, se reduce la complejidad espacial de a . No estoy seguro de cómo haría lo mismo en este caso. Visualizar una tabla no es factible, por lo que la respuesta tendría que venir directamente de la recursividad anterior.$mn$$\min(m,n)$

ACTUALIZAR

Usando las sugerencias de Peter Shor, y haciendo algunas correcciones menores, en particular la necesidad de realizar un seguimiento de la posición en la función , y en lugar de solo dividir las dimensiones en dos conjuntos A y B, dividiendo recursivamente, efectivamente usando un método de divide y vencerás, hasta que se alcance un caso base donde solo haya una dimensión en el conjunto.$W(i, t_i)$

Se me ocurrió la siguiente implementación, que pasó todas las pruebas por debajo del tiempo máximo de ejecución:

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

Las diferentes dimensiones son independientes . Lo que puede hacer es calcular, para cada dimensión j , cuántas caminatas diferentes hay en esa dimensión que pasos. Llamemos a ese número . A partir de su pregunta, ya sabe cómo calcular estos números con programación dinámica.$t$$W(j,t)$

Ahora, es fácil contar la cantidad de caminatas que toman pasos en la dimensión . Tiene formas de intercalar dimensiones para que el número total de pasos dados en la dimensión sea , y para cada una de estas formas tenga camina. Suma estos para obtener Ahora, la memoria está bajo control, ya que solo necesita recordar los valores . El tiempo crece súper polinomialmente para grande , pero la mayoría de las computadoras tienen mucho más tiempo que memoria.$t_i$$i$$N \choose t_1,t_2, \ldots, t_M$$i$$t_i$$\Pi_1^N W(i,t_i)$

Puedes hacerlo aún mejor. Recursiva dividir las dimensiones en dos subgrupos, y , y calcular cuántos camina Hay utilizando sólo las dimensiones en subconjunto , y sólo los de . Llame a estos números y , respectivamente. Obtienes el número total de caminatas por$A$$B$$A$$B$$W_A(t)$$W_B(t)$

una fórmula para de su código (para una celda interna, que ignora los casos de borde):$\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}$

Aquí hay algunas ideas.

• Vemos que una vez que ha calculado todos los valores para , puede eliminar todos los valores calculados para .$s=k$$s<k$
• Para una fija , debe calcular las entradas de la tabla en orden lexicográfico (solo porque es simple). Luego, tenga en cuenta que cada celda solo necesita esas celdas dentro de un "radio de uno", es decir, ninguna coordenada puede estar más lejos que una. Por lo tanto, una vez que su iteración llegue a , puede soltar todos los valores para . Si eso no es suficiente, haga lo mismo para : para fijo , elimine los valores con y cuando se alcanza , y así sucesivamente.$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$
• Tenga en cuenta que "por lo que siempre hay movimientos diferentes posibles" se mantiene solo en el centro de la cuadrícula, es decir, si y para todo . Pero eso también significa que la respuesta es fácil en el medio: es sólo . Si tuviera una recurrencia de programación dinámica que funcionara, eso solo le permitiría eliminar la mayor parte de la tabla (si ).$2N$$x_i - M > 0$$x_i + M < D_i$$i$$(2N)^M$$M\ll N$
• Otra cosa a tener en cuenta es que no tiene que calcular toda la tabla; la mayoría de los valores se completarán con todos modos (si ). Puede restringirse al cubo (hiper) de longitud de borde alrededor de (tenga en cuenta que se abollará debido a los caminos que salen de la cuadrícula).$0$$M\ll N$$2M$$x$

Eso debería ser suficiente para mantener el uso de memoria bastante bajo.