Programação dinâmica com grande número de subproblemas

Programação dinâmica com grande número de subproblemas. Então, eu estou tentando resolver esse problema da Interview Street:

Grid Walking (Score 50 points)
Você está situado em uma grade $N$ dimensional na posição $(x_1,x_2,\dots,x_N)$ . As dimensões da grade são $(D_1,D_2,\dots,D_N$ ). Em uma etapa, você pode dar um passo à frente ou atrás em qualquer uma das $N$ dimensões. (Portanto, sempre existem $2N$ movimentos diferentes possíveis). De quantas maneiras você pode tomar $M$etapas de modo que você não saia da grade em nenhum momento? Você sai da grade se, para qualquer $x_i$ , $x_i \leq 0$ ou $x_i > D_i$ .

Minha primeira tentativa foi esta solução recursiva memorizada:

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 surpresa: falha em um grande número de etapas e / ou dimensões devido à falta de memória.

Portanto, o próximo passo é melhorar minha solução usando programação dinâmica. Mas antes de começar, estou vendo um grande problema com a abordagem. O argumento starting_pointé um $n$ duplo, onde $n$ é tão grande quanto $10$ . Portanto, de fato, a função poderia estar number_of_ways(steps, x1, x2, x3, ... x10)com $1 \leq x_i \leq 100$ .

Os problemas de programação dinâmica que eu já vi nos livros didáticos quase todos têm variáveis ​​twp, de modo que apenas uma matriz bidimensional é necessária. Nesse caso, seria necessária uma matriz de dez dimensões. Então, células no total.$100^{10}$

$mn$$\min(m,n)$

ATUALIZAR

Usando as sugestões de Peter Shor e fazendo algumas correções menores, notavelmente a necessidade de acompanhar a posição na função e, em vez de apenas dividir as dimensões em dois conjuntos A e B, fazendo a divisão recursivamente, efetivamente usando um método de dividir e conquistar, até que um caso base seja alcançado, onde apenas uma dimensão está no conjunto.$W(i, t_i)$

Eu vim com a seguinte implementação, que passou em todos os testes abaixo do tempo máximo de execução:

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

As diferentes dimensões são independentes . O que você pode fazer é calcular, para cada dimensão j , quantas caminhadas diferentes existem naquela dimensão que executa etapas. Vamos chamar esse número de W ( j , t ) . Com a sua pergunta, você já sabe como calcular esses números com programação dinâmica.$t$$W(j,t)$

Agora, é fácil de contar o número de passeios que levam passos na dimensão i . Você tem maneiras de intercalar dimensões, de modo que o número total de etapas executadas na dimensão seja e, para cada uma dessas maneiras, você ande. Soma-os para obter Agora, a memória está sob controle, pois você só precisa se lembrar dos valores . O tempo cresce superpolinomialmente para grande , mas a maioria dos computadores tem muito mais tempo que memória.$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)

Você pode fazer ainda melhor. Recursivamente dividir as dimensões em dois subgrupos, e , e calcular o número de passeios não são usando apenas as dimensões em subconjunto , e apenas aqueles em . Ligue para esses números e , respectivamente. Você obtém o número total de caminhadas porB A B W A ( t ) W B ( t $A$$B$$A$$B$$W_A(t)$$W_B(t)$

Vamos extrair uma fórmula para do seu código (para uma célula interna, que está ignorando casos de borda):$\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}$

Aqui estão algumas idéias.

• Vemos que, depois de calcular todos os valores para , você pode eliminar todos os valores calculados para .$s=k$$s<k$
• Para um fixo , você deve calcular as entradas da tabela em ordem lexicográfica (apenas porque é simples). Observe que todas as células precisam apenas dessas células dentro de um "raio de uma", ou seja, nenhuma coordenada pode estar mais distante que uma. Portanto, quando sua iteração atingir , você poderá eliminar todos os valores de . Se isso não for suficiente, faz o mesmo para - para fixa , valores de queda com e quando é atingido - e assim por diante.$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$
• Observe que "para que sempre haja possíveis movimentos diferentes" é válido apenas no meio da grade, ou seja, se e para todos os . Mas isso também significa que a resposta é fácil no meio: é apenas . Se você tivesse uma recorrência de programação dinâmica em funcionamento, isso por si só permitiria raspar a maior parte da tabela (se ).$2N$$x_i - M > 0$$x_i + M < D_i$$i$$(2N)^M$$M\ll N$
• Outra coisa a se notar é que você não precisa calcular a tabela inteira; a maioria dos valores será preenchida com qualquer maneira (se ). Você pode restringir-se ao (hiper) cubo de comprimento da borda em torno de (observe que ele será amassado devido a caminhos que saem da grade).$0$$M\ll N$$2M$$x$

Isso deve ser suficiente para manter o uso de memória bastante baixo.