การเขียนโปรแกรมแบบไดนามิกที่มีปัญหาย่อยจำนวนมาก

การเขียนโปรแกรมแบบไดนามิกที่มีปัญหาย่อยจำนวนมาก ดังนั้นฉันพยายามแก้ไขปัญหานี้จาก Interview Street:

ตารางเดิน (คะแนน 50 คะแนน)
คุณกำลังตั้งอยู่ในตารางมิติที่ตำแหน่งX_n) ขนาดของกริดคือ ) ในขั้นตอนเดียวคุณสามารถเดินไปข้างหน้าหรือข้างหลังหนึ่งก้าวในมิติใด ๆ ก็ได้ (ดังนั้นจะมีการเคลื่อนไหวต่าง ๆ ที่เป็นไปได้เสมอ) คุณสามารถทำตามขั้นตอนหลายวิธีเช่นนี้โดยที่คุณไม่ออกจากกริดในทุกจุด คุณออกจากตารางถ้าใด ๆทั้งหรือD_i( x 1 , x 2 , … , x N ) ( D 1 , D 2 , … , D N N 2 N M x ฉันx ฉัน ≤ 0 x i > D $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$

ความพยายามครั้งแรกของฉันคือโซลูชันแบบเรียกซ้ำที่บันทึกไว้:

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เป็น -tuple ที่คือขนาดใหญ่เป็น10ดังนั้นในความเป็นจริงการทำงานอาจจะมี 100n 10 1 ≤ x ฉัน ≤ $n$$n$$10$number_of_ways(steps, x1, x2, x3, ... x10)$1 \leq x_i \leq 100$

ปัญหาการเขียนโปรแกรมแบบไดนามิกที่ฉันเคยเห็นในตำราเกือบทั้งหมดมีตัวแปร twp ดังนั้นจำเป็นต้องใช้เมทริกซ์สองมิติเท่านั้น ในกรณีนี้จำเป็นต้องใช้เมทริกซ์สิบมิติ ดังนั้นทั้งหมดเซลล์โดยรวม$100^{10}$

มี 2-D matrixes ในการเขียนโปรแกรมแบบไดนามิกมักจะมีเพียงแถวก่อนหน้าของการคำนวณเป็นสิ่งจำเป็นสำหรับการคำนวณต่อไปดังนั้นการลดความซับซ้อนเชิงพื้นที่จากเพื่อn) ฉันไม่แน่ใจว่าฉันจะทำเช่นเดียวกันในกรณีนี้ได้อย่างไร การแสดงตารางเป็นไปไม่ได้ดังนั้นคำตอบจะต้องมาจากการสอบถามซ้ำข้างต้นโดยตรงนาที( ม. , n $mn$$\min(m,n)$

UPDATE

ใช้คำแนะนำของ 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

ขนาดที่แตกต่างกันเป็นอิสระ สิ่งที่คุณสามารถทำได้คือการคำนวณสำหรับแต่ละมิติเจหลายวิธีที่แตกต่างกันเดินที่มีอยู่ในเพียงว่ามิติที่ใช้ขั้นตอน ขอให้เราโทรไปยังหมายเลขที่t) จากคำถามของคุณคุณรู้วิธีคำนวณตัวเลขเหล่านี้ด้วยการเขียนโปรแกรมแบบไดนามิกW ( j , t $t$$W(j,t)$

ตอนนี้มันเป็นเรื่องง่ายที่จะนับจำนวนของการเดินที่เกิดขั้นตอนในมิติฉันคุณมี วิธีการ interspersing มิติเพื่อให้จำนวนรวมของขั้นตอนการดำเนินการในมิติที่เป็นและสำหรับแต่ละวิธีการเหล่านี้คุณมีเดิน รวมผลรวมเหล่านี้เพื่อรับ ขณะนี้หน่วยความจำอยู่ภายใต้การควบคุมเนื่องจากคุณจะต้องจดจำค่าเท่านั้น เวลาเพิ่มขึ้นอย่างมากสำหรับขนาดใหญ่แต่คอมพิวเตอร์ส่วนใหญ่มีเวลามากกว่าหน่วยความจำมาก i ($t_i$$i$ฉันtฉันΠ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)$

คุณสามารถทำได้ดียิ่งขึ้น ซ้ำแบ่งขนาดเป็นสองส่วนย่อย, และและคำนวณหลายวิธีเดินมีใช้เพียงมิติในเซตและเพียงแค่ผู้ที่อยู่ในBเรียกหมายเลขเหล่านี้และตามลำดับ คุณได้รับจำนวนทั้งหมดของการเดิน$A$$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}$

นี่คือแนวคิดบางส่วน

• เราจะเห็นว่าเมื่อคุณได้คำนวณค่าทั้งหมดสำหรับคุณสามารถวางค่าคำนวณทั้งหมด<k$s=k$$s<k$
• สำหรับที่มีการแก้ไขคุณควรคำนวณรายการตารางตามลำดับพจนานุกรม (เพียงเพราะมันง่าย) จากนั้นโปรดทราบว่าทุกเซลล์ต้องการเพียงเซลล์ดังกล่าวภายใน "รัศมีหนึ่ง" ซึ่งไม่มีพิกัดใดที่จะห่างออกไปมากกว่าหนึ่ง ดังนั้นเมื่อฮิตซ้ำของคุณคุณสามารถวางค่าทั้งหมดสำหรับI-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$
• โปรดทราบว่า "เพื่อให้มีเสมอการเคลื่อนไหวที่แตกต่างกันไปได้" ถือเฉพาะในช่วงกลางของตารางที่คือถ้าและสำหรับฉันแต่นั่นก็หมายความว่าคำตอบเป็นเรื่องง่ายที่อยู่ตรงกลาง: มันเป็นเพียงแค่ M หากคุณมีการเขียนโปรแกรมแบบไดนามิกที่เกิดขึ้นซ้ำเพียงอย่างเดียวนั่นจะช่วยให้คุณสามารถกำจัดตารางส่วนใหญ่ (ถ้า )$2N$$x_i - M > 0$$x_i + M < D_i$$i$$(2N)^M$$M\ll N$
• สิ่งที่ควรทราบอีกประการหนึ่งคือคุณไม่จำเป็นต้องคำนวณทั้งตาราง ค่าส่วนใหญ่จะถูกเติมด้วยอย่างไรก็ตาม (ถ้า ) คุณสามารถ จำกัด ตัวเองให้เป็นลูกบาศก์ (ไฮเปอร์) ของความยาวขอบรอบ ๆ (โปรดทราบว่ามันจะเว้าแหว่งเนื่องจากเส้นทางออกจากตาราง)$0$$M\ll N$$2M$$x$

นั่นควรจะเพียงพอที่จะทำให้การใช้หน่วยความจำค่อนข้างต่ำ