많은 수의 하위 문제가있는 동적 프로그래밍

많은 수의 하위 문제가있는 동적 프로그래밍. 그래서 인터뷰 거리 에서이 문제를 해결하려고합니다.

그리드 워킹 (50 점 점수)
당신은에 위치하고 있습니다 $N$ 위치에 차원 그리드 $(x_1,x_2,\dots,x_N)$ . 격자의 치수는 $(D_1,D_2,\dots,D_N$ )입니다. 한 단계에서 $N$ 차원 중 하나에서 한 단계 앞뒤로 걸을 수 있습니다 . (그래서 항상 거기에 $2N$ 가능한 다른 이동). 얼마나 많은 방법으로 M 을 취할 수 있습니까$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$ 튜플이며, 여기서 $n$ 은 $10$ 입니다. 그래서 사실, 기능 수 number_of_ways(steps, x1, x2, x3, ... x10)와 .$1 \leq x_i \leq 100$

교과서에서 본 동적 프로그래밍 문제에는 거의 모두 twp 변수가 있으므로 2 차원 행렬 만 필요합니다. 이 경우 10 차원 매트릭스가 필요합니다. 그래서 총 세포.$100^{10}$

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

최신 정보

Peter Shor의 제안을 사용하고, 약간의 수정, 특히 함수 에서 위치를 추적 하고 치수를 두 세트 A와 B로만 분할하는 것이 아니라 재귀 적으로 효과적으로 분할을 수행 해야 할 필요성 한 세트의 차원 만있는 기본 사례에 도달 할 때까지 분할 및 정복 방법.$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 에 대해 단계를 거치는 차원에 몇 개의 다른 보행이 있는지 계산 하는 것 입니다. 그 번호를 라고합시다 . 귀하의 질문에서, 당신은 이미 동적 프로그래밍으로 이러한 숫자를 계산하는 방법을 알고 있습니다.W ( J , t $t$$W(j,t)$

이제 차원 에서 단계를 수행 하는 보행 수를 쉽게 계산할 수 있습니다 . 당신은 너무 차원에서 촬영 단계의 총 수 있다는 차원을 산재하는 방법 입니다 , 이러한 각각의 방법에 대해, 당신은 산책을. 이것을 합산하여 이제 값만 기억하면되므로 메모리가 제어됩니다 . 큰 의 경우 시간이 엄청나게 커지지 만 대부분의 컴퓨터는 메모리보다 많은 시간이 있습니다. 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)

더 잘할 수 있습니다. 재귀 개의 서브 세트들로 나누는 차원 및 , 및 계산이 얼마나 많은 서브 세트에 바로 사용 치수가 걸어 , 단지 이들에 . 이 숫자들을 각각 및 . 당신은 총 산책 횟수를 얻습니다.$A$A B W A ( t ) W B ( t $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보다 더 멀리있을 수는 없습니다. 따라서 반복이 하면 대한 모든 값을 삭제할 수 있습니다 . 충분하지 않으면 대해 동일한 작업을 수행하십시오 -고정 경우 에 도달 하면 및 값을 삭제하십시오 .x 1 = i x 1 ≤ i − 2 x 2 x 1 = i x 1 = i x 2 ≤ j − 2 x 2 = $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$
• "가장 가능한 다른 이동 이 항상 있습니다"는 그리드의 중간에만 유지됩니다 . , 모든 대해 및 입니다 . 그러나 그것은 또한 중간에 대답이 쉽다는 것을 의미합니다 : 그것은 단지 입니다. 작동하는 동적 프로그래밍 반복이있는 경우이 테이블만으로도 대부분의 테이블을 면도 할 수 있습니다 ( ).X I - M > 0 X I + M < D I I ( 2 N ) M M « $2N$$x_i - M > 0$$x_i + M < D_i$$i$$(2N)^M$$M\ll N$
• 주목해야 할 또 다른 사항은 전체 테이블을 계산할 필요가 없다는 것입니다. 어쨌든 대부분의 값은 으로 채워집니다 ( ). 주위 의 가장자리 길이 의 (하이퍼) 큐브로 자신을 제한 할 수 있습니다 (그리드를 떠나는 경로 때문에 찌그러짐에 유의하십시오).M ≪ N 2 M $0$$M\ll N$$2M$$x$

메모리 사용량을 매우 낮게 유지하기에 충분해야합니다.