Lập trình động với số lượng lớn các bài toán con

Lập trình động với số lượng lớn các bài toán con. Vì vậy, tôi đang cố gắng giải quyết vấn đề này từ Interview Street:

Đi bộ theo lưới (Điểm 50 điểm)
Bạn đang ở trong lưới chiều hai chiều tại vị trí . Kích thước của lưới là ). Trong một bước, bạn có thể đi trước một bước hoặc phía sau trong bất kỳ kích thước nào. (Vì vậy, luôn luôn có có thể di chuyển khác nhau). Trong bao nhiêu cách bạn có thể thực hiện các bước sao cho bạn không rời khỏi lưới tại bất kỳ điểm nào? Bạn rời khỏi lưới nếu với bất kỳ nào , hoặc .$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$

Thử đầu tiên của tôi là giải pháp đệ quy ghi nhớ này:

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ất ngờ lớn: nó thất bại đối với một số lượng lớn các bước và / hoặc kích thước do thiếu bộ nhớ.

Vì vậy, bước tiếp theo là cải thiện giải pháp của tôi bằng cách sử dụng lập trình động. Nhưng trước khi bắt đầu, tôi đang thấy một vấn đề lớn với cách tiếp cận. Đối số starting_pointlà một -tuple, trong đó lớn bằng . Vì vậy, trên thực tế, chức năng có thể là với .n 10 1 ≤ x i ≤ $n$$n$$10$number_of_ways(steps, x1, x2, x3, ... x10)$1 \leq x_i \leq 100$

Các vấn đề lập trình động mà tôi đã thấy trong sách giáo khoa hầu hết đều có biến twp, do đó chỉ cần một ma trận hai chiều. Trong trường hợp này, sẽ cần một ma trận mười chiều. Vậy tổng cộng ô.$100^{10}$

Với ma trận 2 chiều trong lập trình động, thường chỉ cần hàng tính toán trước đó cho phép tính tiếp theo, do đó giảm độ phức tạp không gian từ xuống . Tôi không chắc làm thế nào tôi sẽ làm như vậy trong trường hợp này. Hình dung một bảng không khả thi, vì vậy câu trả lời sẽ phải đến trực tiếp từ phép đệ quy ở trên.$mn$$\min(m,n)$

CẬP NHẬT

Sử dụng các đề xuất của Peter Shor và thực hiện một số chỉnh sửa nhỏ, đáng chú ý là cần theo dõi vị trí trong hàm và thay vì chỉ chia kích thước thành hai bộ A và B, thực hiện phân tách một cách đệ quy, sử dụng hiệu quả phương pháp chia và chinh phục, cho đến khi đạt được trường hợp cơ sở trong đó chỉ có một thứ nguyên trong tập hợp.$W(i, t_i)$

Tôi đã đưa ra cách thực hiện sau, vượt qua tất cả các thử nghiệm dưới thời gian thực hiện tối đa:

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

Các kích thước khác nhau là độc lập . Những gì bạn có thể làm là tính toán, với mỗi chiều j , có bao nhiêu bước đi khác nhau chỉ trong chiều đó có các bước . Hãy để chúng tôi gọi số đó . Từ câu hỏi của bạn, bạn đã biết cách tính những con số này bằng lập trình động.$t$$W(j,t)$

Bây giờ, thật dễ dàng để đếm số lần đi bộ thực hiện các bước theo chiều thứ . Bạn có cách xen kẽ các kích thước sao cho tổng số bước được thực hiện trong thứ nguyên là và với mỗi cách bạn có đi bộ. Tổng hợp các khoản này để nhận Bây giờ, bộ nhớ đã được kiểm soát, vì bạn chỉ cần nhớ các giá trị . Thời gian tăng trưởng đa chiều đối với lớn , nhưng hầu hết các máy tính có nhiều thời gian hơn bộ nhớ.$t_i$$i$$N \choose t_1,t_2, \ldots, t_M$$i$$t_i$$\Pi_1^N W(i,t_i)$

Bạn có thể làm tốt hơn nữa. Đệ quy chia kích thước thành hai tập con, và , và tính toán bao nhiêu đi có đang sử dụng chỉ là kích thước trong nhóm , và chỉ những người trong . Gọi các số này và . Bạn có tổng số lần đi bộ$A$$B$$A$$B$$W_A(t)$$W_B(t)$

Hãy trích xuất một công thức cho từ mã của bạn (đối với một ô bên trong, đó là bỏ qua các trường hợp viền):$\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}$

Đây là một số ý tưởng.

• Chúng tôi thấy rằng một khi bạn đã tính toán tất cả các giá trị cho , bạn có thể loại bỏ tất cả các giá trị được tính cho .$s=k$$s<k$
• Đối với một cố định , bạn nên tính toán các mục trong bảng theo thứ tự từ điển (chỉ vì nó đơn giản). Sau đó, lưu ý rằng mọi ô chỉ cần các ô như vậy trong "bán kính một", không có tọa độ nào có thể ở xa hơn một ô. Do đó, khi lần lặp của bạn đạt , bạn có thể bỏ tất cả các giá trị cho . Nếu điều đó là không đủ, hãy thực hiện tương tự cho - đối với cố định , bỏ các giá trị với và khi đạt đến - v.v.$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$
• Lưu ý rằng "vì vậy luôn có khả năng di chuyển khác nhau" chỉ giữ ở giữa lưới, đó là nếu và cho tất cả . Nhưng điều đó cũng có nghĩa rằng câu trả lời là dễ dàng ở giữa: nó chỉ . Nếu bạn đã tái phát lập trình động làm việc, một mình điều đó sẽ cho phép bạn cạo đi phần lớn bảng (nếu ).$2N$$x_i - M > 0$$x_i + M < D_i$$i$$(2N)^M$$M\ll N$
• Một điều cần lưu ý là bạn không phải tính toán toàn bộ bảng; hầu hết các giá trị sẽ được điền bằng (nếu ). Bạn có thể giới hạn mình trong khối (siêu) có độ dài cạnh quanh (lưu ý rằng nó sẽ bị lõm xuống do các đường dẫn rời khỏi lưới).$0$$M\ll N$$2M$$x$

Điều đó là đủ để giữ cho việc sử dụng bộ nhớ khá thấp.