Динамічне програмування з великою кількістю підпрограм

Динамічне програмування з великою кількістю підпрограм. Тому я намагаюся вирішити цю проблему з Інтерв'ю-стріт:

Сіткова ходьба (Оцінка 50 балів)
Ви знаходитесь у мірній сітці в положенні . Розміри сітки ). За один крок ви можете піти на крок вперед або позаду в будь-якому з вимірів. (Отже, завжди є можливих різних ходів). Скількома способами можна зробити кроків, щоб ні в якому разі не залишати сітку? Ви залишаєте сітку, якщо для будь-якого , або або .$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, де дорівнює . Тож насправді функція може бути з .n 10 1 ≤ x i ≤ $n$$n$$10$number_of_ways(steps, x1, x2, x3, ... x10)$1 \leq x_i \leq 100$

Проблеми з динамічним програмуванням, які я бачив у підручниках, майже у всіх мають змінні twp, тому потрібна лише двовимірна матриця. У цьому випадку знадобиться десятивимірна матриця. Тож клітин усього.$100^{10}$

Для двовимірних матриць у динамічному програмуванні зазвичай потрібен лише попередній ряд обчислень для наступного обчислення, отже, зменшення просторової складності з до . Я не впевнений, як би я зробив те саме в цій справі. Візуалізація таблиці неможлива, тому відповідь повинна була б бути безпосередньо з рекурсії вище.$mn$$\min(m,n)$

ОНОВЛЕННЯ

Використання пропозицій Пітера Шора та внесення деяких незначних виправлень, зокрема, необхідності відстежувати положення у функції , а не розбивати розміри на два набори 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 , скільки різних прогулянок існує лише в тому вимірі, який робить кроки. Назвемо це число . З вашого запитання ви вже знаєте, як обчислити ці числа за допомогою динамічного програмування.$t$$W(j,t)$

Тепер легко підрахувати кількість прогулянок, які роблять кроки в розмірі . У вас є способи розмірів, так що загальна кількість кроків, виконаних у вимірі є , і для кожного з цих способів ви . їх, щоб отримати Тепер пам’ять знаходиться під контролем, оскільки вам потрібно запам’ятати лише значення . Час зростає суперполіномічно для великих , але більшість комп'ютерів мають набагато більше часу, ніж пам'ять.$t_i$$i$$N \choose t_1,t_2, \ldots, t_M$$i$$t_i$$\Pi_1^N W(i,t_i)$

Можна зробити ще краще. Рекурсивний розділити розміри на два підмножини, і , і обчислити , скільки ходить там , використовуючи тільки розміри в підмножина , і тільки ті , в . Назвіть ці числа та відповідно. Ви отримуєте загальну кількість прогулянок за$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}$

Ось кілька ідей.

• Ми бачимо, що після того, як ви обчислили всі значення для , ви можете скинути всі обчислені значення для .$s=k$$s<k$
• Для фіксованого слід обчислити записи таблиці в лексикографічному порядку (тільки тому, що це просто). Потім зауважте, що кожна комірка потребує таких клітинок лише в "радіусі одиниці", тобто жодна координата не може бути далі, ніж одна. Тому, як тільки ваша ітерація потрапить , ви можете скинути всі значення для . Якщо цього недостатньо, зробіть те ж саме для - для фіксованих , скиньте значення з та коли досягнуто - тощо.$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$
• Зауважте, що "тому завжди є можливих різних рухів", виконується лише посередині сітки, тобто якщо і для всіх . Але це також означає , що відповідь проста в середині: це просто . Якщо у вас був робочий динамічний повтор програмування, то одне лише дозволило б вам поголити більшу частину таблиці (якщо ).$2N$$x_i - M > 0$$x_i + M < D_i$$i$$(2N)^M$$M\ll N$
• Ще одна річ, що слід зазначити, що вам не потрібно обчислювати всю таблицю; більшість значень все одно заповниться (якщо ). Ви можете обмежитися (гіпер) кубом довжиною ребра навколо (зауважте, що він буде пом'ятий через шляхи, що залишають сітку).$0$$M\ll N$$2M$$x$

Цього повинно бути достатньо, щоб використання пам'яті було досить низьким.