Динамическое программирование

редактировать

Рисунок 1. Поиск кратчайшего пути в графе с использованием оптимальной подструктуры; прямая линия указывает на одно ребро; волнистая линия указывает кратчайший путь между двумя вершинами, которые она соединяет (среди других путей, имеющих одни и те же две вершины); жирная линия обозначает общий кратчайший путь от начала до цели.

Динамическое программирование - это одновременно метод математической оптимизации и метод компьютерного программирования. Метод был разработан Ричардом Беллманом в 1950-х годах и нашел применение во многих областях, от аэрокосмической техники до экономики.

В обоих контекстах он означает упрощение сложной проблемы, разбивая ее на более простые подзадачи в рекурсивной манере. Хотя некоторые проблемы с решениями нельзя разделить таким образом, решения, которые охватывают несколько моментов времени, часто рекурсивно распадаются. Аналогичным образом, в информатике, если проблема может быть решена оптимальным образом, разбив ее на подзадачи, а затем рекурсивно найдя оптимальные решения подзадач, то говорят, что она имеет оптимальную подструктуру.

. крупные задачи, так что применимы методы динамического программирования, тогда существует связь между значением более крупной проблемы и значениями подзадач. В литературе по оптимизации это соотношение называется уравнением Беллмана.

Содержание

1 Обзор
- 1.1 Математическая оптимизация
- 1.2 Теория управления
  - 1.2.1 Пример экономики: проблема Рамсея оптимальной экономии
- 1.3 Компьютерное программирование
- 1.4 Биоинформатика
2 Примеры: Компьютерные алгоритмы
- 2.1 Алгоритм Дейкстры для задачи кратчайшего пути
- 2.2 Последовательность Фибоначчи
- 2.3 Тип сбалансированной матрицы 0–1
- 2.4 Шахматная доска
- 2.5 Выравнивание следовать
- 2.6 Загадка Ханойской башни
- 2.7 Головоломка с падением яйца
  - 2.7.1 Более быстрое решение DP с использованием другого параметра
- 2.8 Умножение цепочки матриц
3 История
4 Алгоритмы, использующие динамическое программирование
5 См.
6 Ссылки
7 Дополнительная литература
8 Внешние ссылки

Обзор

Математическая оптимизация

В точки зрения математической оптимизации, динамическое программирование обычно означает упрощение решения путем разбиения его на последовательность решений ул. eps с течением времени. Это делается путем определения параметров значений V1, V 2,..., V n, высокой y в качестве аргумента, представляющего состояние системы в моменты времени i от 1 до n. Определение V n (y) - это значение, полученное в состоянии y в последний момент n. Значения V i в более ранние моменты времени i = n −1, n - 2,..., 2, 1 можно найти, работая в обратном направлении, используя рекурсивную связь, называемую Уравнение Беллмана. Для i = 2,..., n, V i - 1 в любом состоянии y вычисляется из V i путем максимизации простых функций (обычно суммы) усиления от решения в момент времени i - 1 и функция V i в новом состоянии системы, если это решение принято. Времена V i уже вычислено для необходимых состояний, вышеупомянутая операция дает V i-1 для этих состояний. Наконец, V 1 в начальном состоянии системы является значением оптимального решения. Оптимальные значения восстановления можно восстановить одно за другим, отслеживая уже выполненные вычисления.

Теория управления

В теории управления типичной проверкой является поиск допустимого управления $u ∗ {\ displaystyle \ mathbf {u} ^ {\ ast}}$ ${\ displaystyle \ mathbf {u} ^ {\ ast}}$ , что вызывает систему $x ˙ (t) = g (x (t), u (t), t) {\ displaystyle {\ dot {\ mathbf {x}}} (t) = \ mathbf {g} \ left (\ mathbf {x} (t), \ mathbf {u} (t), t \ right)}$ ${\ displaystyle {\ dot {\ mathbf {x}}} (t) = \ mathbf {g} \ left (\ mathbf {x} (t), \ mathbf {u} (t), t \ right)}$ , чтобы следовать по допустимой траектории $x ∗ {\ displaystyle \ mathbf {x} ^ {\ ast}}$ ${\ displaystyle \ mathbf {х} ^ {\ ast}}$ на непрерывном временном интервале $t 0 ≤ t ≤ t 1 {\ displaystyle t_ {0} \ leq t \ leq t_ {1}}$ ${\ displaystyle t_ {0 } \ leq t \ leq t_ {1}}$ , который минимизирует функцию стоимости

J = b (x (t 1), t 1) + ∫ t 0 t 1 f (x (t), u (t), t) dt { \ Displaystyle J = b \ left (\ mathbf {x} (t_ {1}), t_ {1} \ right) + \ int _ {t_ {0}} ^ {t_ {1}} f \ left (\ mathbf {x} (t), \ mathbf {u} (t), t \ right) \ mathrm {d} t}

{\ displaystyle J = b \ left (\ mathbf {x} (t_ {1}), t_ {1} \ right) + \ int _ { t_ {0}} ^ {t_ {1}} f \ left (\ mathbf {x} (t), \ mathbf {u} (t), t \ right) \ mathrm {d} t}

Решением этой проблемы является закон или политика оптимального управления $u ∗ = час (x (t), т) {\ Displaystyle \ mathbf {и} ^ {\ Ast } = час (\ mathbf {x} (t), t)}$ ${\ displaystyle \ mathbf {u} ^ {\ ast} = h (\ mathbf {x} (t), t)}$ , что дает оптимальную траекторию $x ∗ {\ displaystyle \ mathbf {x} ^ {\ ast}}$ ${\ displaystyle \ mathbf {х} ^ {\ ast}}$ и функция затрат на производство $J ∗ {\ displaystyle J ^ {\ ast}}$ ${\ displaystyle J ^ {\ ast}}$ . Последний подчиняется фундаментальному уравнению динамического программирования:

- J t ∗ = min u {f (x (t), u (t), t) + J x ∗ T g (x (t), u (t), t)} {\ displaystyle -J_ {t} ^ {\ ast} = \ min _ {\ mathbf {u}} \ left \ {f \ left (\ mathbf {x} (t), \ mathbf {u} (t), t \ right) + J_ {x} ^ {\ ast {\ mathsf {T}}} \ mathbf {g} \ left (\ mathbf {x} (t), \ mathbf {u} (t), t \ right) \ right \}}

{\ displaystyle -J_ {t} ^ {\ ast} = \ min _ {\ mathbf {u}} \ left \ {f \ left (\ mathbf {x} (t), \ mathbf {u} (t), t \ right) + J_ {x} ^ {\ ast {\ mathsf {T}}} \ mathbf {g} \ left (\ mathbf {x} (t), \ mathbf {u} (t), t \ right) \ right \}}

a уравнение в частных производных, известное как уравнение Гамильтона - Якоби - Беллмана, в котором $J x ∗ = ∂ J ∗ ∂ x Знак равно равно [∂ J ∗ ∂ Икс 1 ∂ J ∗ ∂ Икс 2… ∂ J ∗ ∂ Xn] T {\ Displaystyle J_ {x} ^ {\ ast} = {\ frac {\ partial J ^ {\ ast}} {\ partial \ mathbf {x}}} = \ left [{\ frac {\ partial J ^ {\ ast}} {\ partial x_ {1}}} ~~~~ {\ frac {\ partial J ^ {\ ast}} {\ partial x_ {2}}} ~~~~ \ dots ~~~~ {\ frac {\ partial J ^ {\ ast}} {\ partial x_ {n}}} \ right] ^ {\ mathsf {T }}}$ ${\ displaystyle J_ {x} ^ {\ ast} = {\ frac {\ partial J ^ {\ ast}} {\ partial \ mathbf {x}}} = \ left [{\ frac {\ partial J ^ {\ ast} } {\ partial x_ {1}}} ~~~~ {\ frac {\ partial J ^ {\ ast}} {\ partial x_ {2}}} ~~~~ \ dots ~~~~ {\ frac { \ partial J ^ {\ ast}} {\ partial x_ {n}}} \ right] ^ {\ mathsf {T}}}$ и $J t ∗ = ∂ J ∗ ∂ t {\ displaystyle J_ {t} ^ {\ ast} = {\ frac {\ partial J ^ {\ ast}} {\ partial t}}}$ ${ \ displaystyle J_ {t} ^ {\ ast} = {\ frac {\ partial J ^ {\ ast}} {\ partial t}}}$ . Можно найти минимизирующий $u {\ displaystyle \ mathbf {u}}$ $\ mathbf {u}$ в терминах $t {\ displaystyle t}$ $t$ , $x {\ displaystyle \ mathbf {x}}$ $\ mathbf {x}$ и неизвестная функция $J x ∗ {\ displaystyle J_ {x} ^ {\ ast}}$ ${\ displaystyle J_ {x} ^ {\ ast} }$ , а затем подставляет результат в уравнение Гамильтона - Якоби - Беллмана, чтобы получить уравнение в частных производных, которое необходимо решить с граничным условием $J (t 1) = b (x (t 1), t 1) {\ displaystyle J \ left (t_ {1} \ right) = b \ left (\ mathbf {x} (t_ {1}), t_ {1} \ right)}$ ${\ displaystyle J \ left (t_ {1} \ right) = b \ left (\ mathbf {x} (t_ {1}), t_ {1} \ right)}$ . На практике это обычно требует численных методов для некоторого дискретного приближения к точному использованию оптимизации.

В качестве альтернативного непрерывного процесса может быть аппроксимирован дискретной системой, что приводит к следующему рекуррентному процессу, аналогичному уравнению Гамильтона - Якоби - Беллмана:

J k ∗ (xn - k) = min un - К {е ^ (xn - к, un - k) + J К - 1 * (g ^ (xn - k, un - k))} {\ displaystyle J_ {k} ^ {\ ast} \ left (\ mathbf {x} _ {nk} \ right) = \ min _ {\ mathbf {u} _ {nk}} \ left \ {{\ hat {f}} \ left (\ mathbf {x} _ {nk}, \ mathbf {u } _ {nk} \ right) + J_ {k-1} ^ {\ ast} \ left ({\ hat {g}} \ left (\ mathbf {x} _ {nk}, \ mathbf {u} _ { nk} \ right) \ right) \ right \}}

{\ displaystyle J_ {k} ^ {\ ast} \ left (\ mathbf {x} _ {nk} \ right) = \ min _ {\ mathbf {u} _ {nk}} \ left \ {{\ hat {f}} \ left (\ mathbf {x} _ {nk}, \ mathbf {u} _ {nk} \ right) + J_ {k-1 } ^ {\ ast} \ left ({\ hat {g}} \ left (\ mathbf {x} _ {nk}, \ mathbf {u} _ {nk} \ right) \ right) \ right \}}

на $k {\ displaystyle k}$ $k$ -й стадии $n {\ displaystyle n}$ $n$ равноудаленные дискретные временные интервалы, и где $f ^ {\ displaystyle {\ hat {f}}}$ ${\ hat {f} }$ и $g ^ {\ displaystyle {\ hat {g}}}$ ${\ hat {g}}$ обозначают дискретные приближения к $f {\ displaystyle f}$ $f$ и $g {\ displaystyle \ mathbf {g}}$ $\ mathbf {g}$ . Это уравнение используется как уравнение Беллмана, может быть решено для точного решения дискретной аппроксимации уравнения оптимизации.

Пример из экономики: проблема оптимальной экономии Рамси

В экономике обычно состоит в том, чтобы максимизировать (а не минимизировать) некоторую динамическую функцию общественного благосостояния. В задаче Рэмси эта функция связывает объем потребления с уровнями полезности. Грубо говоря, планировщик сталкивается с компромиссом между одновременным потреблением и будущим потреблением (через инвестиции в основной капитал, который используется в производстве), известный как межвременной выбор. Будущее потребление дисконтируется с постоянной ставкой $β ∈ (0, 1) {\ displaystyle \ beta \ in (0,1)}$ ${\ displaystyle \ beta \ in (0,1)}$ . Дискретное приближение к уравнению перехода капитала дается следующим образом:

kt + 1 = g ^ (kt, ct) = f (kt) - ct {\ displaystyle k_ {t + 1} = {\ hat {g}} \ left (k_ {t}, c_ {t} \ right) = f (k_ {t}) - c_ {t}}

{\ displaystyle k_ {t + 1} = {\ hat {g}} \ left (k_ {t}, c_ {t } \ right) = f (k_ {t}) - c_ {t}}

, где $c {\ displaystyle c}$ $c$ - потребление, $k {\ displaystyle k}$ $k$ - капитал, а $f {\ displaystyle f}$ $f$ - производственная функция, удовлетворяющая Условия инада. Начальный капитал $k 0>0 {\ displaystyle k_ {0}>0}$ $k_{0}>0$ обычно.

Пусть $ct {\ displaystyle c_ {t}}$ $c_{t}$ будет потреблением в период t, и предположим, что потребление дает полезность $u (ct) = ln ⁡ (ct) {\ displaystyle u (c_ {t}) = \ ln (c_ {t})}$ $u(c_{t})=\ln(c_{t})$ пока живет потребитель. Предположим, что потребитель нетерпелив, поэтому он дисконтирует будущую полезность на коэффициент b каждый период, где $0 < b < 1 {\displaystyle 0$ $0 <b <1$ . Пусть $kt {\ displaystyle k_ {t}}$ $k_ {t}$ быть капиталом в период т. Предположим, что начальный капитал равен заданной сумме $k 0>0 {\ displaystyle k_ {0}>0}$ $k_{0}>0$ , и предположим, что этот период капитала и потребление определяют капитал следующего периода как $тыс. т + 1 = A k t a - c t {\ displaystyle k_ {t + 1} = Ak_ {t} ^ {a} -c_ {t}}$ $k_ {t + 1} = Ak_ {t} ^ {a} -c_ {t}$ , где A - положительная константа и $0 < a < 1 {\displaystyle 0$ $0 <a <1$ . Предположим, что капитал не может быть отрицательным. Тогда проблема принятия решения потребителем может быть записана следующим образом:

max ∑ t = 0 T bt ln ⁡ (ct) {\ displaystyle \ max \ sum _ {t = 0} ^ {T} b ^ {t} \ ln (c_ {t})}

\ max \ sum _ {t = 0} ^ {T} b ^ {t} \ ln (c_ {t })

при условии

kt + 1 = A kta - ct ≥ 0 {\ displaystyle k_ {t + 1} = Ak_ {t} ^ {a} -c_ {t } \ geq 0}

k_ {t + 1} = Ak_ {t} ^ {a} -c_ {t} \ geq 0

для всех

t = 0, 1, 2,…, T {\ displaystyle t = 0,1,2, \ ldots, T}

t = 0,1,2, \ ldots, T

Написано таким образом, проблема выглядит сложной, потому что она включает решение для всех чисел выбора $c 0, c 1, c 2,…, c T {\ displaystyle c_ {0}, c_ {1}, c_ {2}, \ ldots, c_ {T}}$ $c_ {0}, c_ {1}, c_ {2}, \ ldots, c_ {T}$ . (Заглавная буква $k 0 {\ displaystyle k_ {0}}$ $k _ {0}$ не является альтернативным выбором - начальный капитал потребителя принимается заданным.)

Подход динамического программирования для решения эта проблема включает разбиение ее на последовательность более мелких решений. Для этого мы определяем последовательность функций $V t (k) {\ displaystyle V_ {t} (k)}$ $V_ {t} (k)$ для $t = 0, 1, 2,…, T, T + 1 {\ displaystyle t = 0,1,2, \ ldots, T, T + 1}$ $t = 0,1,2, \ ldots, T, T + 1$ , что необходимо наличия любого количества капитала k в каждый момент времени t. Нет (по предположению) никакой пользы от капитала после смерти, $VT + 1 (k) = 0 {\ displaystyle V_ {T + 1} (k) = 0}$ $V_ {T + 1} (к) = 0$ .

Стоимость любого количества капитала в любой предыдущий момент может быть рассчитан по обратной индукции с использованием уравнения Беллмана. В этой задаче для каждого $t = 0, 1, 2,…, T {\ displaystyle t = 0,1,2, \ ldots, T}$ $t = 0,1,2, \ ldots, T$ уравнение Беллмана имеет вид

В T (кт) знак равно макс (пер (ct) + б V t + 1 (кт + 1)) {\ displaystyle V_ {t} (k_ {t}) \, = \, \ max \ left (\ ln (c_ {t}) + bV_ {t + 1} (k_ {t + 1}) \ right)}

{\ Displaystyle V_ {t} (k_ {t}) \, = \, \ max \ left (\ ln (c_ {t}) + bV_ {t + 1} (k_ {t + 1}) \ right)}

при условии

kt + 1 = A kta - ct ≥ 0 {\ displaystyle k_ {t + 1} = Ak_ {t} ^ {a} -c_ {t} \ geq 0}

k_ {t + 1} = Ak_ {t} ^ {a} -c_ {t} \ geq 0

Эта задача намного проще, чем та, которую мы записали ранее, потому что она включает только две переменные решения, $ct {\ displaystyle c_ {t}}$ $c_{t}$ и $kt + 1 {\ displaystyle k_ {t + 1}}$ $k_ {t + 1}$ . Интуитивно, вместо того, чтобы выбирать план на всю жизнь при рождении, потребитель может делать шаги за шагом. В момент t задан его текущий капитал $kt {\ displaystyle k_ {t}}$ $k_ {t}$ , и ему нужно только выбрать текущее потребление $ct {\ displaystyle c_ {t}}$ $c_{t}$ и сохраняя $kt + 1 {\ displaystyle k_ {t + 1}}$ $k_ {t + 1}$ .

Чтобы решить эту проблему, мы работаем в обратном порядке. Для простоты текущий уровень капитала обозначен как k. $VT + 1 (k) {\ displaystyle V_ {T + 1} (k)}$ $V_{T+1}(k)$ уже известно, поэтому, используя уравнение Беллмана, мы можем вычислить $VT (k) {\ displaystyle V_ {T} (k)}$ $V_ {T} (k)$ и так далее, пока мы не дойдем до $V 0 (k) {\ displaystyle V_ {0} (k)}$ $V_{0}(k)$ , который - значение задачи начального решения на все время жизни. Другими словами, если мы знаем $VT - j + 1 (k) {\ displaystyle V_ {Tj + 1} (k)}$ $V_ {T-j + 1} (k)$ , мы можем вычислить $VT - j (k) { \ displaystyle V_ {Tj} (k)}$ $V_ {Tj} (k)$ , что является максимумом $ln ⁡ (c T - j) + b VT - j + 1 (A ka - c T - j) {\ displaystyle \ ln (c_ {Tj}) + bV_ {Tj + 1} (Ak ^ {a} -c_ {Tj})}$ $\ ln (c_ {Tj}) + bV_ {T-j + 1} (Ak ^ {a} -c_ {Tj})$ , где $c T - j {\ displaystyle c_ {Tj} }$ $c_ {Tj}$ - переменная выбора, а $A ka - c T - j ≥ 0 {\ displaystyle Ak ^ {a} -c_ {Tj} \ geq 0}$ $Ak ^ {a} -c_ {Tj} \ geq 0$ .

Работая в обратном направлении, можно показать, что функция значения в момент времени $t = T - j {\ displaystyle t = Tj}$ $t=Tj$ равно

VT - j (k) = a ∑ i = 0 jaibi пер ⁡ К + v T - j {\ displaystyle V_ {Tj} (k) \, = \, a \ sum _ {i = 0} ^ {j} a ^ {i} b ^ {i} \ ln k + v_ {Tj} }

V_ {Tj} (k) \, = \, a \ sum _ {i = 0} ^ {j} a ^ {i} b ^ {i} \ ln k + v_ {Tj}

, где каждый $v T - j {\ displaystyle v_ {Tj}}$ $v_ {Tj}$ является константой, а оптимальное количество потребления в момент $t = T - j {\ displaystyle t = Tj}$ $t=Tj$ is

c T - j (k) = 1 ∑ i = 0 jaibi A ka {\ dis стиль игры c_ {Tj} (k) \, = \, {\ frac {1} {\ sum _ {i = 0} ^ {j} a ^ {i} b ^ {i}}} Ak ^ {a}}

c_ {Tj} ( k) \, = \, {\ frac {1} {\ sum _ {i = 0} ^ {j} a ^ {i} b ^ {i}}} Ak ^ {a}

который можно упростить до

c T (k) = A kac T - 1 (k) = A ka 1 + abc T - 2 (k) = A ka 1 + ab + a 2 b 2… c 2 (k) = A ka 1 + ab + a 2 b 2 +… + a T - 2 b T - 2 c 1 (k) = A ka 1 + ab + a 2 b 2 +… + a T - 2 b T - 2 + a T - 1 b T - 1 c 0 (k) = A ka 1 + ab + a 2 b 2 +… + a T - 2 b T - 2 + a T - 1 b T - 1 + a T б T {\ displaystyle {\ begin {align} c_ {T} (k) = Ak ^ {a} \\ c_ {T-1} (k) = {\ frac {Ak ^ {a}} {1 + ab}} \\ c_ {T-2} (k) = {\ frac {Ak ^ {a}} {1 + ab + a ^ {2} b ^ {2}}} \\ \ dots \ \ c_ {2} (k) = {\ frac {Ak ^ {a}} {1 + ab + a ^ {2} b ^ {2} + \ ldots + a ^ {T-2} b ^ {T -2}}} \\ c_ {1} (k) = {\ frac {Ak ^ {a}} {1 + ab + a ^ {2} b ^ {2} + \ ldots + a ^ {T- 2} b ^ {T-2} + a ^ {T-1} b ^ {T-1}}} \\ c_ {0} (k) = {\ frac {Ak ^ {a}} {1 + ab + a ^ {2} b ^ {2} + \ ldots + a ^ {T-2} b ^ {T-2} + a ^ {T-1} b ^ {T-1} + a ^ {T } b ^ {T}}} \ end {align}}}

{\ displaystyle {\ begin {align} c_ {T} (k) = Ak ^ {a} \\ c_ {T-1} (k) = { \ frac {Ak ^ {a}} {1 + ab}} \\ c_ {T-2} (k) = {\ frac {Ak ^ {a}} {1 + ab + a ^ {2} b ^ {2}}} \\ \ dots \\ c_ {2} (k) = {\ frac {Ak ^ {a}} {1 + ab + a ^ {2} b ^ {2} + \ ldots + a ^ {T-2} b ^ {T-2}}} \\ c_ {1} (k) = {\ frac {Ak ^ {a}} {1 + ab + a ^ {2} b ^ { 2} + \ ldots + a ^ {T-2} b ^ {T-2} + a ^ {T-1} b ^ {T-1}}} \\ c_ {0} (k) = {\ гидроразрыв {Ak ^ {a}} {1 + ab + a ^ {2} b ^ {2} + \ ldots + a ^ {T-2} b ^ {T-2} + a ^ {T-1} b ^ {T-1} + a ^ {T} b ^ {T}}} \ end {align}}}

Мы видим, что оптимально п отреблять большую часть богатства по мере того, как человек становится старше, в итоге потребляя все оставшееся богатство в периоде T, последний период жизни.

Компьютерное программирование

Есть два ключевых атрибута, которые должны иметь, чтобы оптимальное динамическое программирование было применимо: оптимальная динамическая подструктура и перекрывающиеся подзадачи. Если проблема может быть решена путем комбинирования оптимальных решений неперекрывающихся подзадач, стратегия вместо этого называется «разделяй и властвуй ». Вот почему сортировка слиянием и быстрая сортировка не классифицируются как задачи динамического программирования.

Оптимальная подструктура означает, что решение данной проблемы может быть получено путем комбинации оптимальных решений ее подзадач. Такие оптимальные подструктуры обычно описываются с помощью рекурсии. Например, для графа G = (V, E) кратчайший путь p от вершины u до вершины v имеет оптимальную подструктуру: возьмите любую промежуточную вершину w на этом кратчайшем пути p. Если p действительно является кратчайшим путем, то его можно разделить на подпути p 1 от u до w и p 2 от w до v, так что они, в свою очередь, действительно, кратчайшие пути между установлен вершинами (с помощью простого аргумента вырезания и вставки, описанного в Введение в алгоритмы ). Следовательно, можно легко сформулировать решение для поиска кратчайших путей рекурсивным способом, что и делает алгоритм Беллмана - Форда или алгоритм Флойда - Уоршалла.

Перекрывающиеся подзадачи означают, что пространство подзадач должно быть небольшим, то есть любой ресивный алгоритм, решает проблему, должен решать одни и те же подзадачи и снова, а не генерировать новые подзадачи. Например, рассмотрим рекурсивную формулировку для генерации ряда Фибоначчи: F i = F i - 1 + F i - 2, с базовым случаем F 1 = F 2 = 1. Тогда F 43 = F 42 + F 41 и F 42 = F 41 + F 40. Теперь F 41 решается в рекурсивных поддеревьях как F 43, так и F 42. Хотя общее количество подзадач на самом деле невелико (43 из них), мы в итоге решаем одни и те же проблемы снова и снова, если принимаем наивное рекурсивное решение, подобное этому. Динамическое программирование учитывает этот факт и решает каждую подзадачу только один раз.

Рисунок 2. Граф подзадач для следовать Фибоначчи. Тот факт, что это не дерево , указывает на перекрывающиеся подзадачи.

Это может быть достигнуто одним из двух способов:

Подход сверху вниз : Это прямое следствие рекурсивная постановка любой задачи. Если решение какой-либо проблемы может быть предложено рекурсивно с использованием решений его подзадач, и если его подзадачи перекрываются, то можно легко запоминать или правила решения подзадач в таблице. Каждый раз, когда мы пытаемся решить новую подзадачу, мы сначала проверяем таблицу, чтобы увидеть, решена ли она уже. Если решение было записано, мы можем использовать его напрямую, в противном случае мы решаем подзадачу и добавляем его решение в таблицу.
Подход снизу вверх : как только мы формулируем решение проблемы рекурсивно, как в С точки зрения подзадач, мы можем попробовать переформулировать проблему снизу вверх: сначала решить подзадачи и использовать их решения, чтобы развить и найти решения более другими подзадач. Это также обычно делается в табличной форме, итеративно генерируя решения все больших и больших подзадач, используя решения небольших подзадач. Например, если нам уже известны значения F 41 и F 40, мы можем напрямую определить значение F 42.

Некоторые языки программирования могут автоматически запоминать вызов функции с определенным набором аргументов, чтобы ускорить вычисление вызов по имени (механизм называется вызовом по -Нужно ). Некоторые языки делают это возможным переносимым (например, Scheme, Common Lisp, Perl или D ). Некоторые языки имеют встроенную автоматическую запоминание , например tabled Prolog и J, который поддерживает мемоизацию с помощью наречия M. В любом случае это возможно только для ссылочно прозрачной функции. Как Wolfram Language.

Биоинформатика

Динамическое программирование широко используется в биоинформатике для таких задач, как выравнивание последовательностей., сворачивание белка, предсказание структуры РНК и связывание белок-ДНК. Первые алгоритмы динамического программирования для связывания белка с ДНК были разработаны в 1970-х независимо Чарльзом ДеЛизи в США и Георгием Гурским и Александром Заседателевым в СССР. В последнее время эти алгоритмы стали очень популярными в биоинформатике и вычислительной биологии, особенно в исследованиях позиционирования нуклеосом и связывания фактора транскрипции.

Примеры: компьютерные алгоритмы

алгоритм Дейкстры для задачи кратчайшего пути

С точки зрения динамического программирования, алгоритм Дейкстры для Задача кратчайшего пути представляет собой схему последовательного приближения, которая решает функциональное уравнение динамического программирования для задачи кратчайшего пути с помощью метода Reaching.

Фактически, объяснение Дейкстры логики, лежащей в основе алгоритм, а именно

Задача 2. Найти путь минимальной общей длины между двумя заданными узлами $P {\ displaystyle P}$ $P$ и $Q {\ displaystyle Q}$ $Q$ .

Мы используем тот факт, что если $R {\ displaystyle R}$ $R$ является узлом на минимальном пути от $P {\ displaystyle P}$ $P$ до $Q {\ displaystyle Q}$ $Q$ , знание последнего подразумевает знание минимального пути от $P {\ displaystyle P}$ $P$ до $R {\ displaystyle R}$ $R$ .

- это перефразирование извест ного известного принципа оптимальности Беллмана.>в контексте проблемы кратчайшего пути .

последовательность Фибоначчи

Использование динамического программирования в вычислении n-го члена последовательности Фибоначчи значительно улучшает ее производительность. Вот наивная реализация, основанная непосредственно на математическом определении:

function fib (n) ifn <= 1 return n return fib (n - 1) + fib (n - 2)

Обратите внимание, что если мы вызываем, скажем, fib (5), мы создаем дерево вызовов, которое вызывает функцию для одного и того же значения много раз:

fib (5)
fib (4) + fib (3)
(fib (3) + fib (2)) + (fib (2) + fib (1))
((fib (2) + fib (1)) + (fib (1) + fib (0))) + ((fib (1) + fib (0)) + fib (1))
(((fib (1) + fib (0)) + fib (1)) + (fib (1) + fib (0))) + ((fib (1) + fib (0)) + fib (1))

В частности, fib (2)рассчитывался трижды с нуля. В более крупных примерах повторно вычисляется гораздо больше значений fibили подзадач, что приводит к алгоритму экспоненциального времени.

Теперь предположим, что у нас есть простой объект map, m, который сопоставляет каждое значение fib, которое уже было вычислено, с его результатом, и мы модифицируем нашу функцию использовать его и обновлять. Результирующая функция требует только O (n) времени вместо экспоненциального времени (но требует O (n) пространства):

var m: = map (0 → 0, 1 → 1) функция fib (n), если ключ n отсутствует на карте mm [n]: = fib ( n - 1) + fib (n - 2) return m [n]

Этот метод сохранения уже вычисленных значений называется мемоизацией ; это нисходящий подход, поскольку мы сначала разбиваем проблему на подзадачи, а затем вычисляем и сохраняем значения.

В подходе снизу вверх мы сначала вычисляем меньшие значения fib, а затем строим из них большие значения. Этот метод также использует время O (n), поскольку он содержит цикл, который повторяется n - 1 раз, но он занимает только постоянное (O (1)) пространство, в отличие от подхода сверху вниз, который требует пространства O (n) для хранить карту.

function fib (n) if n = 0 return 0 elsevar previousFib: = 0, currentFib: = 1 repeat n - 1 раз // цикл пропускается, если n = 1 var newFib: = previousFib + currentFib previousFib: = currentFib currentFib: = newFib return currentFib

В обоих примерах мы вычисляем fib (2)только один раз, а затем используем его для вычисления обоих fib (4)и fib (3), вместо того, чтобы вычислять его каждый раз, когда оценивается любой из них.

Вышеупомянутый метод фактически занимает $Ω (n 2) {\ displaystyle \ Omega (n ^ {2})}$ $\ Omega (n ^ {2})$ времени для большого n, потому что сложение двух целых чисел с $Ω (n) {\ displaystyle \ Omega (n)}$ $\ Omega (n)$ бит занимает $Ω (n) {\ displaystyle \ Omega (n)}$ $\ Omega (n)$ времени. (Число Фибоначчи n имеет $Ω (n) {\ displaystyle \ Omega (n)}$ $\ Omega (n)$ бит.) Кроме того, существует закрытая форма для последовательности Фибоначчи, , известная как формула Бине, из которого $n {\ displaystyle n}$ $n$ -й член может быть вычислен приблизительно за $O (n (log ⁡ n) 2) { \ displaystyle O (n (\ log n) ^ {2})}$ $O ( n (\ log n) ^ {2})$ время, которое более эффективно, чем описанный выше метод динамического программирования. Однако простое повторение непосредственно дает матричную форму, которая приводит к приблизительно $алгоритму O (n log ⁡ n) {\ displaystyle O (n \ log n)}$ $O (n \ log n)$ посредством быстрое возведение в степень матрицы.

Тип сбалансированной матрицы 0–1

Рассмотрим проблему присвоения значений, либо нуля, либо единицы, позициям матрицы n× nс nдаже, так что каждая строка и каждый столбец содержат ровно n/ 2 нуля и n/ 2 единиц. Мы спрашиваем, сколько разных назначений существует для данного $n {\ displaystyle n}$ $n$ . Например, когда n= 4, четыре возможных решения:

[0 1 0 1 1 0 1 0 0 1 0 1 1 0 1 0] и [0 0 1 1 0 0 1 1 1 1 0 0 1 1 0 0] и [1 1 0 0 0 0 1 1 1 1 0 0 0 0 1 1] и [1 0 0 1 0 1 1 0 0 1 1 0 1 0 0 1]. {\ displaystyle {\ begin {bmatrix} 0 1 0 1 \\ 1 0 1 0 \\ 0 1 0 1 \\ 1 0 1 0 \ end {bmatrix}} {\ text {and}} {\ begin {bmatrix} 0 0 1 1 \\ 0 0 1 1 \\ 1 1 0 0 \\ 1 1 0 0 \\ 1 1 0 0 \\ 1 1 0 0 {bmatrix}} {\ text {и}} {\ begin {bmatrix} 1 1 0 0 \\ 0 0 1 1 \\ 1 1 0 0 \\ 0 0 1 1 \ end {bmatrix}} {\ text {and}} {\ begin {bmatrix} 1 0 0 1 \\ 0 1 1 0 \\ 0 1 1 0 \\ 1 0 0 1 \ end {bmatrix}}.}

{\ begin {bmatrix} 0 1 0 1 \\ 1 0 1 0 \\ 0 1 0 1 \\ 1 0 1 0 \ end {bmatrix}} {\ text {and}} {\ begin {bmatrix} 0 0 1 1 \\ 0 0 1 1 \\ 1 1 0 0 \\ 1 1 0 0 \\ 1 1 0 0 \\ 1 1 0 0 \\ 1 1 0 0 \ end {bmatrix}} {\ text {and}} {\ begin {bmatrix} 1 1 0 0 \\ 0 0 1 1 \\ 1 1 0 0 \\ 0 0 1 1 \ end {bmatrix}} {\ text {and}} {\ begin {bmatrix} 1 0 0 1 \ \ 0 1 1 0 \\ 0 1 1 0 \\ 1 0 0 1 \ end {bmatrix}}.

Существует по крайней мере три возможных подхода: грубая сила, возврат с возвратом и динамическое программирование.

Грубая сила состоит из проверки всех присвоений нулей и единиц и подсчета тех, которые имеют сбалансированные строки и столбцы (n/ 2 нуля и n/ 2 единицы). Поскольку существует $(nn / 2) n {\ displaystyle {\ tbinom {n} {n / 2}} ^ {n}}$ ${\ tbinom {n} {n / 2}} ^ {n}$ возможных назначений, эта стратегия нецелесообразна, за исключением, возможно, до $n = 6 {\ displaystyle n = 6}$ $n = 6$ .

Поиск с возвратом для этой проблемы состоит из выбора некоторого порядка элементов матрицы и рекурсивного размещения единиц или нулей, при этом проверяя, что в каждой строке и столбце количество элементов, которые имеют не назначено, плюс количество единиц или нулей как минимум n/ 2. Хотя этот подход более сложен, чем грубая сила, этот подход будет посещать каждое решение один раз, что делает его непрактичным для nбольше шести, поскольку количество решений уже составляет 116 963 796 250 для n= 8, как мы увидим.

Динамическое программирование позволяет подсчитывать количество решений, не посещая их все. Представьте себе значения обратного отслеживания для первой строки - какая информация нам потребуется об оставшихся строках, чтобы иметь возможность точно подсчитать решения, полученные для каждого значения первой строки? Мы рассматриваем доски k× n, где 1 ≤ k≤ n, чьи строки $k {\ displaystyle k}$ $k$ содержат $n / 2 {\ displaystyle n / 2}$ $n / 2$ нулей и $n / 2 {\ displaystyle n / 2}$ $n / 2$ единиц. Функция f, к которой применяется мемоизация, отображает векторы из n пар целых чисел на количество допустимых досок (решений). Для каждого столбца есть одна пара, и два ее компонента указывают, соответственно, количество нулей и единиц, которые еще не были помещены в этот столбец. Мы ищем значение $f ((n / 2, n / 2), (n / 2, n / 2),… (n / 2, n / 2)) {\ displaystyle f ((n / 2, n / 2), (n / 2, n / 2), \ ldots (n / 2, n / 2))}$ $f ((n / 2, n / 2), (n / 2, n / 2), \ ldots (n / 2, n / 2))$ ( $n {\ displaystyle n}$ $n$ аргументы или один вектор $n {\ displaystyle n}$ $n$ элементов). Процесс создания подзадач включает итерацию по каждому из $(nn / 2) {\ displaystyle {\ tbinom {n} {n / 2}}}$ ${\ tbinom {n} {n / 2}}$ возможных назначений для верхней строки доски., и просматривая каждый столбец, вычитая единицу из соответствующего элемента пары для этого столбца, в зависимости от того, содержит ли назначение для верхней строки ноль или единицу в этой позиции. Если какой-либо из результатов отрицательный, то присвоение недопустимо и не влияет на набор решений (рекурсия прекращается). В противном случае у нас есть назначение для верхней строки доски k× nи рекурсивно вычисляем количество решений для оставшейся (k- 1) × nдоски, складывая числа решений для каждого допустимого присвоения верхней строки и возвращение суммы, которая запоминается. Базовый случай - это тривиальная подзадача, которая возникает для платы 1 × n. Количество решений для этой платы равно нулю или одному, в зависимости от того, является ли вектор перестановкой n/ 2 $(0, 1) {\ displaystyle (0,1)}$ $(0,1)$ и n/ 2 $(1, 0) {\ displaystyle (1,0)}$ $(1,0)$ пары или нет.

Например, на первых двух досках, показанных выше, последовательности векторов будут

((2, 2) (2, 2) (2, 2) (2, 2)) ((2, 2) (2, 2) (2, 2) (2, 2)) k = 4 0 1 0 1 0 0 1 1 ((1, 2) (2, 1) (1, 2) ( 2, 1)) ((1, 2) (1, 2) (2, 1) (2, 1)) k = 3 1 0 1 0 0 0 1 1 ((1, 1) (1, 1) ( 1, 1) (1, 1)) ((0, 2) (0, 2) (2, 0) (2, 0)) k = 2 0 1 0 1 1 1 0 0 ((0, 1) ( 1, 0) (0, 1) (1, 0)) ((0, 1) (0, 1) (1, 0) (1, 0)) k = 1 1 0 1 0 1 1 0 0 (( 0, 0) (0, 0) (0, 0) (0, 0)) ((0, 0) (0, 0), (0, 0) (0, 0))

количество решений (последовательность A058527 в OEIS ) равно

1, 2, 90, 297200, 116963796250, 6736218287430460752,… {\ displaystyle 1, \, 2, \, 90, \, 297200, \, 116963796250, \, 6736218287430460752, \ ldots}

1, \, 2, \, 90, \, 297200, \, 116963796250, \, 6736218287430460752, \ ldots

Ссылки на реализацию MAPLE подхода динамического программирования можно найти среди внешних ссылок.

Шахматная доска

Рассмотрим шахматную доску с n × n квадратов и функцию стоимости c (i, j), которая возвращает стои мость, связанную с squ (i, j)(i- строка, j- столбец). Например (на шахматной доске 5 × 5),

	1	2	3	4	5
5	6	7	4	7	8
4	7	6	1	1	4
3	3	5	7	8	2
2	–	6	7	0	–
1	–	–	* 5 *	–	–

Таким образом, c (1, 3) = 5

Допустим, была шашка, которая могла начинаться с любого квадрата на первый ранг (т. е. строка), и вы хотели узнать кратчайший путь (сумму минимальных затрат на каждом посещенном ранге) до последнего ранга; при условии, что шашка может двигаться только по диагонали влево вперед, вправо по диагонали или прямо вперед. То есть, проверка на (1,3)может перейти на (2,2), (2,3)или (2, 4).

	2	3	4
5
4
3
2	x	x	x
1		o

Эта проблема демонстрирует оптимальную подструктуру . То есть решение всей проблемы зависит от решения подзадач. Определим функцию q (i, j)как

q (i, j) = минимальная стоимость достижения квадрата (i, j).

Начиная с ранга nи спускаясь до ранга 1, мы вычисляем значение этой функции для всех квадратов в каждом последовательном ранге. Выбор квадрата, который содержит минимальное значение для каждого ранга, дает нам кратчайший путь между рангом nи рангом 1.

. Функция q (i, j)равна минимальной стоимости чтобы добраться до любого из трех квадратов под ним (так как это единственные квадраты, которые могут его достичь) плюс c (i, j). Например:

	2	3	4
5
4		A
3	B	C	D
2
1

q (A) = min (q (B), q (C), q (D)) + c (A) {\ displaystyle q (A) = \ min (q (B), q (C), q (D)) + c (A) \,}

q ( A) = \ min (q (B), q (C), q (D)) + c (A) \,

Теперь определим q (i, j)в несколько более общих терминах:

q (i, j) = {∞ j < 1 or j>nc (i, j) i = 1 min (q (i - 1, j - 1), q (i - 1, j), q (i - 1, j + 1)) + c (i, j) в противном случае. {\ Displaystyle д (я, j) ​​= {\ begin {case} \ infty j <1{\text{ or }}j>п \\ с (я, j) ​​я = 1 \\\ мин (д (я-1, j-1), q (i-1, j), q (i-1, j + 1)) + c (i, j) {\ text {в противном случае.}} \ end {case}}}

q(i,j)={\begin{cases}\infty j<1{\text{ or }}j>n \\ c (i, j) i = 1 \\\ min (q (i-1, j-1), q (i-1, j), q (i-1, j + 1)) + c ( i, j) {\ text {в противном случае.}} \ end {ases}}

Первая строка этого уравнения относится к доске, смоделированной в виде квадратов, проиндексированных на 1в нижней части и nв верхней bound. The second line specifies what happens at the last rank; providing a base case. The third line, the recursion, is the important part. It represents the A,B,C,Dterms in the example. From this definition we can derive straightforward recursive code for q(i, j). In the following pseudocode, nis the size of th e board, c(i, j)is the cost function, and min()returns the minimum of a number of values:

functio nminCost(i, j) ifj < 1 orj>n returninfinity else ifi = 1 returnc(i, j) elsereturnmin( minCost(i-1, j-1), minCost(i-1, j), minCost(i-1, j+1)) + c(i, j)

This function only computes the path cost, not the actual path. We discuss the actual path below. This, like the Fibonacci-numbers example, is horribly slow because it too exhibits the overlapping sub-problemsattribute. That is, it recomputes the same path costs over and over. However, we can compute it much faster in a bottom-up fashion if we store path costs in a two-dimensional array q[i, j]rather than using a function. This avoids recomputation; all the values needed for array q[i, j]are computed ahead of time only once. Precomputed values for (i,j)are simply looked up whenever needed.

We also need to know what the actual shortest path is. To do this, we use another array p[i, j]; a predecessor array. This array records the path to any square s. The predecessor of sis modeled as an offset relative to the index (in q[i, j]) of the precomputed path cost of s. To reconstruct the complete path, we lookup the predecessor of s, then the predecessor of that square, then the predecessor of that square, and so on recursively, until we reach the starting square. Consider the following code:

functioncomputeShortestPathArrays() forx from1 ton q[1, x] := c(1, x) fory from1 ton q[y, 0] := infinity q[y, n + 1] := infinity fory from2 ton для x из 1 toнм: = min (q [y-1, x-1], q [y-1, x], q [y-1, x + 1]) q [ y, x]: = m + c (y, x) если m = q [y-1, x-1] p [y, x]: = -1 иначе, если m = q [y-1, x] p [y, x]: = 0 else p [y, x]: = 1

Теперь остальное - простой вопрос найти минимум и распечатать его.

функция computeShortestPath () computeShortestPathArrays () minIndex: = 1 мин: = q [n, 1] для i из 2 ton ifq [n, i] < min minIndex := i min := q[n, i] printPath(n, minIndex)

функция printPath (y, x) print (x) print ("<-") ify = 2 print (x + p [y, x]) else printPath (y-1, x + p [y, x])

Выравнивание последовательностей

В генетике, выравнивание последовательностей является важным приложением, в котором необходимо динамическое программирование. Обычно проблема состоит в преобразовании одной последовательности в другую с помощью операций редактирования, которые заменяют, вставляют или удаляют элемент. Каждая операция имеет соответствующую стоимость, и цель состоит в том, чтобы найти последовательность редактирования с наименьшей общей стоимостью.

Проблема может быть естественным образом сформулирована как рекурсия, последовательность A оптимально редактируется в последовательность B посредством любого :

вставка первого символа B и выполнение оптимального выравнивания A и хвоста B
удаление первого символа A и выполнение оптимального выравнивания хвоста A и B
замена первого символа A на первый символ B и выполнение оптимального выравнивания хвостов A и B.

Частичное выравнивание может быть сведено в таблицу в матрице, где ячейка (i, j) содержит стоимость оптимального выравнивания A [1..i] к B [1..j]. Стоимость в ячейке (i, j) может быть рассчитана путем добавления стоимости соответствующих операций к стоимости соседних ячеек и выбора оптимума.

Существуют разные варианты, см. алгоритм Смита – Уотермана и алгоритм Нидлмана – Вунша.

Загадка Ханойская башня

Модельный набор Ханойских башен (с 8 дисков)

Анимированное решение головоломки Ханойская башня для T (4,3).

Ханойская башня или Башни Ханоя - это математическая игра или головоломка. Это состоит из трех стержней и ряда дисков разного размера, которые могут надеваться на любой стержень. Головоломка начинается с дисков в аккуратной стопке в порядке возрастания размера на одном стержне, наименьший наверху, образуя коническую форму.

Задача головоломки - переместить всю стопку на другой стержень, соблюдая следующие правила:

Одновременно можно перемещать только один диск.
Каждый ход состоит из взятия верхний диск с одного из стержней и надевание его на другой стержень поверх других дисков, которые могут уже присутствовать на этом стержне.
Диск не может быть помещен поверх диска меньшего размера.

Решение динамического программирования состоит из решения функционального уравнения

S (n, h, t) = S (n-1, h, not (h, t)); S (1, h, t); S (n-1, not (h, t), t)

где n обозначает количество дисков, которые нужно переместить, h обозначает исходную штангу, t обозначает цельень, а не (h, t) обозначает третий стержень (ни ч, ни т), ";" означает конкатенацию, а

S (n, h, t): = решение задачи, состоящей из n дисков, которые нужно переместить от стержня h к стержню t.

Для n = 1 задача тривиальна, а именно S (1, h, t) = «переместить диск от стержня h на стержню t» (остался только один диск).

Количество ходов, необходимых для этого решения, составляет 2-1. Если цель состоит в максимальном количестве ходов (без циклического переключения), функциональное уравнение динамического программирования немного сложнее, и требуется 3 - 1 ход.

Головоломка с падением яйца

Ниже представлено описание примера знаменитой головоломки с участием N = 2 яйца и здание H = 36 эта:

Предположим, мы хотим Используется "английская английская терминология, в которой первый этаж находится на уровне земли", чтобы безопасно сбрасывать яйца, а в каких они разбрасываются при приземлении. Мы делаем несколько предположений:

Яйцо, пережившее падение, можно использовать снова.
Разбитое яйцо нужно выбросить.
Эффект от падения одинаков для всех яиц..
Если яйцо разбивается при падении, оно разобьется при падении из более высокого окна.
Если яйцо выживает при падении, то оно выдерживает более короткое падение.
Не исключено, что окна первого этажа разбивают яйца, и не исключено, что яйца могут выжить в окнах 36 этажа.

Если доступно только одно яйцо, и мы хотим убедиться в получении права через эксперимент, можно провести только одним способом. Бросьте яйцо из окна первого этажа; если он выживает, бросьте его из второго окна этажа. Продолжайте движение вверх, пока не сломается. В худшем случае этого метода может потребоваться 36 помет. Допустим, есть 2 яйца. Какое наименьшее количество яичных пометов гарантированно будет работать во всех случаях?

Чтобы вывести функциональное уравнение динамического программирования для этой головоломки, позвольте состояние динамической модели программирования представляет собой пару s = (n, k), где

n = количество тестовых яиц, n = 0, 1, 2, 3,..., N - 1.

k = количество (последовательных) этажей, которые еще предстоит протестировать, k = 0, 1, 2,..., H - 1.

Например, s = (2,6) указывает, что доступны два тестовых яйца и 6 (последовательные) этажи еще предстоит испытать. Начальное состояние процесса s = (N, H), где N обозначает тестовых яиц, доступных в начале эксперимента. Процесс завершается либо когда больше нет тестовых яиц (n = 0), либо когда k = 0, в зависимости от того, что произойдет раньше. Если завершение происходит в состоянии s = (0, k) и k>0, то тест не пройден.

Теперь пусть

W (n, k) = минимальное количество испытаний, необходимое для определения значений критического минимального уровня в наихудшем сценарии, учитывая, что процесс находится в состоянии s = (n, k).

Тогда можно показать, что

W (n, k) = 1 + min {max (W (n - 1, x - 1), W (n, k - x)): x = 1, 2,..., k}

с W (n, 0) = 0 для всех n>0 и W (1, k) = k для всех k. Это уравнение легко решить итеративно, систематически увеличивая значения n и k.

Более быстрое решение DP с использованием другого параметра

Обратите внимание, что для приведенного выше решения требуется $O (nk 2) {\ displaystyle O (nk ^ {2})}$ $O (nk ^ {2})$ время с решением DP. Это можно улучшить до $O (nk log ⁡ k) {\ displaystyle O (nk \ log k)}$ $O (nk \ log k)$ путем времени двоичного поиска по оптимальному $x {\ displaystyle x}$ $x$ в приведенном выше повторении, поскольку $W (n - 1, x - 1) {\ displaystyle W (n-1, x-1)}$ $W (n-1, x-1)$ увеличивается на $x {\ displaystyle x}$ $x$ в то время как $W (n, k - x) {\ displaystyle W (n, kx)}$ $W (n, kx)$ уменьшается в $x {\ displaystyle x}$ $x$ , таким образом, локальный минимум $max (W (n - 1, x - 1), W (n, k - x)) {\ displaystyle \ max (W (n-1, x -1), W (n, kx))}$ $\ max (W (n-1, x-1), W (n, kx))$ - глобальный минимум. Кроме того, сохраняя оптимальное значение $x {\ displaystyle x}$ $x$ для каждой ячейки в таблице DP и указанное на его значение для предыдущих ячеек, оптимальное значение $x {\ displaystyle x}$ $x$ для каждой ячейки может быть найдено постоянное время, улучшая его до $O (nk) {\ displaystyle O (nk)}$ $O (nk)$ времени. Однако есть еще более быстрое решение, которое включает другие параметры проблемы:

Пусть $k {\ displaystyle k}$ $k$ будет общим этижей, на которых яйца разбиваются. при падении с $k {\ displaystyle k}$ $k$ -го этажа (приведенный выше пример эквивалент взятию $k = 37 {\ displaystyle k = 37}$ $k = 37$ ).

Пусть $m {\ displaystyle m}$ $m$ будет минимальным этажом, с которого нужно уронить яйцо, чтобы разбить его.

Пусть $f (t, n) {\ displaystyle f (t, n)}$ $f (t, n)$ будет максимальным качеством $m {\ displaystyle m}$ $m$ , которые можно различить с помощью $t {\ displaystyle t}$ $t$ попыток и $n {\ displaystyle n}$ $n$ яиц.

Тогда $f (t, 0) = f (0, n) = 1 {\ displaystyle f (t, 0) = f (0, n) = 1}$ $f (t, 0) = f (0, n) = 1$ для всех $t, n ≥ 0 {\ displaystyle t, n \ geq 0}$ $t, n \ geq 0$ .

Пусть $a {\ displaystyle a}$ $a$ будет полом, с которого упало первое яйцо оптимальная стратегия.

Если первое яйцо разбилось, $m {\ displaystyle m}$ $m$ принимает значение от $1 {\ displaystyle 1}$ $1$ до $a { \ displaystyle a}$ $a$ и различимы с использованием не более $t - 1 {\ displaystyle t-1}$ $т -1$ попытка и $n - 1 {\ displaystyle n-1}$ $n-1$ яиц.

Если первое яйцо не разбилось, $m {\ displaystyle m}$ $m$ берется из $a + 1 {\ displaystyle a + 1}$ $a + 1$ к $k {\ displaystyle k}$ $k$ и различим с помощью $t - 1 {\ displaystyle t-1}$ $т -1$ попытка и $n {\ displaystyle n}$ $n$ яиц.

Следовательно, $f (t, n) = f (t - 1, n - 1) + f (t - 1, n) {\ displaystyle f (t, n) = f (t -1, n-1) + f (t-1, n)}$ $f (t, n) = f (t-1, n-1) + f (t-1, n)$ .

Тогда задача эквивалентна сопоставлению минимума $x {\ displaystyle x}$ $x$ такого, что $f (x, n) ≥ k {\ displaystyle f (x, n) \ geq k}$ $f (x, n) \ geq k$ .

Для этого мы могли бы вычислить ${f (t, i): 0 ≤ i ≤ n} {\ displaystyle \ {f ( t, i): 0 \ leq i \ leq n \}}$ $\ {f (t, i): 0 \ leq i \ leq n \}$ в порядке увеличения $t {\ displaystyle t}$ $t$ , что займет $O (nx) { \ Displaystyle O (nx)}$ $O (nx)$ время.

Таким образом, если мы отдельно обработаем случай $n = 1 {\ displaystyle n = 1}$ $n = 1$ , алгоритм будет принимать $O (nk) {\ displaystyle O (n {\ sqrt {k}})}$ $O (n {\ sqrt {k}})$ раз.

Но на самом деле рекуррентное отношение может быть решено, давая $f (t, n) = ∑ я = 0 n (ti) {\ displaystyle f (t, n) = \ sum _ {i = 0} ^ {n} {\ binom {t} {i}}}$ $f ( t, n) = \ sum _ {i = 0} ^ {n} {\ binom {t} {i}}$ , которое можно вычислить в $O (n) {\ displaystyle O (n)}$ $O (n)$ время с использованием тождества $(ti + 1) = (ti) t - ii + 1 {\ displaystyle {\ binom {t} {i + 1}} = {\ binom {t} {i}} {\ frac {ti} {i + 1}}}$ ${ \ binom {t} {i + 1}} = {\ binom {t} {i}} {\ frac {ti} {i + 1}}$ для всех $i ≥ 0 {\ displaystyle i \ geq 0}$ $i \ geq 0$ .

Буквально $f (t, n) ≤ f (t + 1, n) {\ displaystyle f (t, n) \ leq f (t + 1, n)}$ $f (t, n) \ leq f (t + 1, n)$ для всех $t ≥ 0 {\ displaystyle t \ geq 0}$ $t \ geq 0$ , мы можем выполнить двоичный поиск по $t {\ displaystyle t}$ $t$ , чтобы найти $x {\ displaystyle x}$ $x$ , давая $O (n журнал ⁡ k) {\ displaystyle O (n \ log k)}$ $O (n \ log k)$ алгоритм.

Умножение цепочки матриц

Умножение цепочки матриц - хорошо известный пример, демонстрирующий полезность динамического программирования. Например, инженерные приложения часто умножать цепочку матриц. Неудивительно, что матрицы больших размеров, например 100 × 100. Поэтому наша задача - перемножить матрицы $A 1, A 2,.... A n {\ displaystyle A_ {1}, A_ {2},.... A_ {n}}$ ${\ displaystyle A_ {1}, A_ {2},.... A_ {n}}$ . Как мы знаем из линейной алгебры, коммутативно, а ассоциативно; и мы можем перемножать только две матрицы за раз. Итак, мы можем умножить эту цепочку матриц множеством разными способами, например:

((A 1 × A 2) × A 3) ×... A n

A1× (((A 2×A3) ×...) × A n)

(A1× A 2) × (A 3 ×... A n)

и т. Д. Существует множество способов умножения этой цепочки матриц. Все они будут давать один и тот же конечный результат, однако для их вычисления потребуются больше или меньше времени в зависимости от того, какие матрицы матрицы умножаются. m × n, а матрица B имеет размеры n × q, тогда матрица C = A × B будет иметь размеры m × q и потребует скалярных умножений m * n * q (с использованием упрощенного алгоритма умножения матриц для целей иллюстрации

Например, перемножим матрицы A, B и C. Предположим, что их размеры равны m × n, n × p и p × s соответственно. Матрица A × B × C будет иметь размер m × s и может быть вычислен двумя способами, показанными. ниже:

Топор (B × C) Этот порядок умножения матриц потребует скалярн ых умножений nps + mns.
(A × B) × C Для порядка умножения матриц потребуются скалярные вычисления mnp + mps.

Предположим, что m = 10, n = 100, p = 10 и s = 1000. Итак, первый способ умножения цепочки потребует 1 000 000 + 1 000 000 вычислений.. Второй способ потребует всего 10 000 + 100 000 вычислений. Очевидно, что второй способ быстрее.

Таким образом, мы пришли к выводу, что порядок скобок имеет значение, и что наша задача - найти порядок скобок.

На данный момент у нас есть несколько вариантов, один из которых - алгоритм динамического программирования, который разделит проблему на перекрывающиеся задачи и вычислит оптимальное расположение скобок. Решение динамического программирования представленного ниже.

Назовем m [i, j] минимальным числом скалярных умножений, необходимых для умножения цепочки матриц от матрицы i до матрицы j (то есть A i ×.... × A j, т.е. i <=j). We split the chain at some matrix k, such that i <= k < j, and try to find out which combination produces minimum m[i,j].

Формула:

ifi = j, m [i, j] = 0 ifi < j, m[i,j]= min over all possible values of k (m[i,k]+m[k+1,j] +  $pi - 1 ∗ pk ∗ pj {\ displaystyle p_ {i-1} * p_ {k} * p_ {j}}$  $p_ {i-1} * p_ {k} * p_ {j}$ )

где k находится в диапазоне от i до j - 1.

$pi - 1 {\ displaystyle p_ {i-1}}$ $p_ {i- 1}$ - строка размер i матрицы,
$pk {\ displaystyle p_ {k}}$ $p_ {k}$ - размер столбца матрицы k,
$pj {\ displaystyle p_ {j}}$ $p_ {j}$ - размер столбца матрицы j.

Эту формулу можно закодировать, как показано ниже, где входной параметр "цепочка" - это цепочка матриц, то есть $A 1, A 2,... A n {\ displaystyle A_ {1}, A_ { 2},... A_ {n}}$ $A_ {1}, A_ {2},... A_ {n}$ :

функция OptimalMatrixChainParenthesis (цепочка) n = длина (цепочка) для i = 1, нм [i, i] = 0 // Времен для умножения одной матрицы на len = 2 не требуется вычислений, n для i = 1, n - len + 1 j = i + len -1 m [i, j ] = бесконечность // Чтобы первое вычисление обновляет для k = i, j-1 q = m [i, k] + m [k + 1, j] +  $pi - 1 ∗ pk ∗ pj {\ displaystyle p_ {i-1} * p_ {k} * p_ {j}}$  $p_ {i-1} * p_ {k} * p_ {j}$ ifq < m[i, j] // The new order of parentheses is better than what we had m[i, j] = q // Update s[i, j] = k // Record which k to split on, i.e. where to place the parenthesis

Итак, мы рассчитали значения для всех исполнителей m [i, j], минимальное количество вычислений для умножения цепочки от матрицы i к матрице j, и мы записали соответствующую «точку разделения» s [i, j]. Например, если мы умножаем цепочку A 1×A2×A3×A4, и оказывается, что m [1, 3] = 100 и s [1, 3] = 2, это означает, что оптимальное расположение скобок для матриц с 1 по 3 - $(A 1 × A 2) × A 3 {\ displaystyle (A_ {1} \ times A_ {2}) \ times A_ {3}}$ ${\ displaystyle (A_ {1} \ times A_ {2}) \ times A_ { 3}}$ и для умножения этих матриц потребуется 100 скаляров расчет.

Этот алгоритм создаст «таблицы» m [,] и s [,], которые будут содержать записи для всех значений i и j. Окончательное решение для всей цепочки - m [1, n] с соответствующим разбиением в s [1, n]. Решение будет рекурсивным, начиная сверху и продолжая до тех пор, пока мы не дойдем до базового случая, то есть умножения отдельных матриц.

Следовательно, следующим шагом будет фактическое разделение, то есть размещение скобок там, где они (оптимально) принадлежат. Для этого можно использовать следующий алгоритм:

function PrintOptimalParenthesis (s, i, j) if i = j print "A" i else print "(« PrintOptimalParenthesis ( s, i, s [i, j]) PrintOptimalParenthesis (s, s [i, j] + 1, j) »)«

Конечно, этот алгоритм бесполезен для фактического умножения. увидеть, как выглядит результат.

Чтобы действительно умножить матрицу с использованием правильного разбиения, нам понадобится следующий алгоритм:

function MatrixChainMultiply (цепочка от 1 до n) // возвращает окончательную матрицу, то есть A1 × A2 ×... × An OptimalMatrixChainParenthesis (цепочка от 1 до n) // это даст s [.] И м [.] "Таблицы" OptimalMatrixMultiplication (s, цепочка от 1 до n) // фактически функция умножения OptimalMatrixMultiplication (s, i, j) // возвращает результат умножения цепочки матриц от Ai до Aj оптимальным образом, если i < j // keep on splitting the chain and multiplying the matrices in left and right sides LeftSide = OptimalMatrixMultiplication(s, i, s[i, j]) RightSide = OptimalMatrixMultiplication(s, s[i, j] + 1, j) return MatrixMultiply(LeftSide, RightSide) else if i = j return Ai // matrix at position i else print "error, i <= j must hold" function MatrixMultiply(A, B) // function that multiplies two matrices if columns(A) = rows(B) for i = 1, rows(A) for j = 1, columns(B) C[i, j] = 0 for k = 1, columns(A) C[i, j] = C[i, j] + A[i, k]*B[k, j] return C else print "error, incompatible dimensions."

История

Термин «динамическое программирование» был перво начально использован в 1940-х годах Ричардом Беллманом для описания процесса решения проблем, когда нужно найти наилучшие решения одно за другими. К 1953 году он уточнил это до современного значения, обращаясь конкретно к вложению меньших проблем принятия решений в более крупных решениях, и имеет эту область была признана IEEE как системный анализ и инженерная тема. Вклад Беллмана запомнился названием уравнения Белл, центрального динамического результата программирования, которое переформулирует проблему оптимизации в рекурсивной форме.

Беллман объясняет причину термина «динамическое программирование» в своей автобиографии «Глаз урагана: автобиография»:

Осенний квартал (1950 г.) я провел в RAND. Моей первой рекомендации было найти название для многоступенчатых процессов принятия решений. Интересный вопрос: «Откуда взялось название« динамическое программирование »?» 1950-е годы не были хорошими годами для математических исследований. У нас был очень интересный джентльмен в Вашингтоне по имени Уилсон. Он был министром обороны и на самом деле испытывал патологический страх и ненависть к слову «исследование». Я не использую этот термин легкомысленно; Я использую точно. Его лицо покрылось кровью, он покраснел и стал бы агрессивным, если бы люди использовали термин «исследование» в его присутствии. Вы можете себе представить, как он относился к термину «математика». Корпорация RAND использовалась в ВВС, и по сути, во главе ВВС был Уилсон. Следовательно, я чувствовал, что должно что-то сделать, чтобы я действительно занимался математикой внутри корпорации RAND. Какое название, какое имя я мог бы выбрать? В первую очередь меня интересовало планирование, принятие решений, мышление. Но планирование - не лучшее слово по разным причинам. Поэтому я решил использовать слово «программирование». Я хотел донести идею, это было многоэтапно, это было изменяющимся во времени. Я подумал, давай убьем зайцев одним выстрелом. Возьмем слово, имеющее абсолютно точное значение, а именно динамический в классическом физическом смысле. У него также есть очень интересное свойство прилагаемого, а именно: слово динамический использовать невозможно в уничижительном смысле. Попробуйте придумать какую-нибудь комбинацию, которая, возможно, придаст уничижительное значение. Это невозможно. Таким образом, я подумал, что динамическое программирование - хорошее имя. Против этого не мог возражать даже конгрессмен. Поэтому я использовал его как прикрытие для своей деятельности.

— Ричард Беллман, «Глаз урагана: автобиография» (1984, стр. 159)

Слово «динамика» было выбрано Беллманом для отражения меняющегося во времени проблемы аспектов, и потому что это звучит впечатляюще. Слово «программирование» относится к использованию метода поиска оптимальной программы в смысле военного расписания для обучения или логистики. Это использование аналогично тому, что используется во фразах линейное программирование и математическое программирование, синоним математической оптимизации.

. Приведенное выше объяснение происхождения термина отсутствует. «Это не может быть строго правдой, потому что его статья, в которой используется этот термин (Bellman, 1952), появилась до того, как Вильсон стал министром обороны в» 1953 году ». Также есть комментарий в речи Гарольда Дж. Кушнера, где он вспоминает Беллмана. Цитируя Кушнера, когда он говорит о Беллмане: «С другой стороны, когда я задал ему тот же вопрос, он ответил, что пытался отодвинуть на задний план линейное программирование Данцига, добавив динамику». Возможно, обе мотивации были верны ».

Алгоритмы, использующие динамическое программирование

Рекуррентные решения для решетчатых моделей для связывания белок-ДНК
Обратная индукция как метод решения для конечного горизонта дискретных -время задачи динамической оптимизации
Метод неопределенных коэффициентов можно использовать для решения уравнения Беллмана в бесконечном горизонте, дискретном времени, дисконтированном, не зависящие от времени задачи динамической оптимизации
Многие строковые алгоритмы, включая самую длинную общую подпоследовательность, самую длинную возрастающую подпоследовательность, самая длинная общая подстрока, расстояние Левенштейна (расстояние редактирования)
Многие алгоритмические проблемы на графах могут быть эффективно решены для графов с ограниченной шириной дерева или ограниченной шириной клики с помощью динамиче ского программирования на древовидной декомпозиции графа.
Алгоритм Кок-Янгера-Касами (CYK) который определяет, будет ли данная полоса ng может быть сгенерирован заданной контекстно-свободной грамматикой
алгоритмом переноса слов Кнута, который минимизирует неровность при переносе текста
Использование таблиц транспонирования и таблицы опровержения в компьютерных шахматах
алгоритм Витерби (используется для скрытых марковских моделей, и особенно в части речевых тегов )
алгоритм Эрли (тип анализатора диаграмм )
алгоритм Нидлмана – Вунша и другие алгоритмы, используемые в биоинформатике, включая выравнивание последовательностей, структурное выравнивание, прогнозирование структуры РНК
алгоритм кратчайшего пути всех пар Флойда
Оптимизация порядка умножения матриц цепочек
Псевдополином time для задач суммы, ранца и partition
Алгоритм динамического изменения времени для вычисление глобального расстояния между двумя временными рядами
S Элингер (он же System R ) алгоритм оптимизации запросов к реляционной базе данных
алгоритм Де Бура для оценки кривых B-сплайна
метод Дакворта – Льюиса для решения проблемы, когда игры в крикет прерываются
Метод итерации значений для решения Марковских процессов принятия решений
Некоторые методы выделения края графического изображения, такие как инструмент выделения «магнит» в Photoshop
Некоторые методы решения интервальное планирование задачи
Некоторые методы решения задачи коммивояжера либо точно (в экспоненциальном времени ), либо приблизительно (например, с помощью bitonic tour )
Рекурсивный метод наименьших квадратов метод
Beat отслеживание в поиске музыкальной информации
Стратегия обучения адаптивного критика для искусственных нейронных сетей
Стереоалгоритмы для решения проблема соответствия используется в стереозрении
Вырезание швов (изменение размера изображения с учетом содержимого)
Bellman – Ford алгоритм для поиска кратчайшего расстояния в графе
Некоторые методы приближенного решения для задачи линейного поиска
алгоритм Кадана для задачи максимального подмассива
Оптимизация генерации электроэнергии планы расширения в пакете Wein Automatic System Planning (WASP)

См. также

Ссылки

Дополнительная литература

Адда, Джером; Купер, Рассел (2003), Dynamic Economics, MIT Press. Доступное введение в динамическое программирование в экономике. Код MATLAB для книги.
Ричард Беллман (1954), «Теория динамического программирования», Бюллетень Американского математического общества, 60(6): 503–516, DOI : 10.1090 / S0002-9904-1954-09848-8, MR 0067459. Включает обширную библиографию литературы по данной области до 1954 года.
Беллман, Ричард (1957), Динамическое программирование, Princeton University Press. Издание Dover в мягкой обложке (2003 г.), ISBN 0-486-42809-5.
Кормен, Томас Х. ; Лейзерсон, Чарльз Э. ; Ривест, Рональд Л. ; Стейн, Клиффорд (2001), Введение в алгоритмы (2-е изд.), MIT Press McGraw – Hill, ISBN 978-0-262 -03293-3. Особенно стр. 323–69.
Dreyfus, Stuart E.; Закон, Аверилл М. (1977), Искусство и теория динамического программирования, Academic Press, ISBN 978-0-12-221860-6.
Giegerich, R.; Meyer, C.; Стеффен, П. (2004), «Дисциплина динамического программирования на основе данных последовательности» (PDF), Наука компьютерного программирования, 51 (3): 215–263, doi : 10.1016 / j.scico.2003.12.005.
Мейн, Шон (2007), Методы управления для сложных сетей, Cambridge University Press, ISBN 978-0-521-88441-9, заархивировано с оригинального 19.06.2010.
Шритаран, СС (1991). «Динамическое программирование уравнений Навье-Стокса». Системы и контрольные письма. 16 (4): 299–307. doi : 10.1016 / 0167-6911 (91) 90020-f.
Стоки, Нэнси ; Лукас, Роберт Э. ; Прескотт, Эдвард (1989), Рекурсивные методы в экономической динамике, Гарвардский университет. Press, ISBN 978-0-674-75096-8.

Внешние ссылки

Учебник по динамическому программированию
Курс MIT по алгоритмам - включает видео-лекцию по DP вместе с конспектами лекций см. Лекцию 15.
Другие заметки DP
King, Ian, 2002 (1987), «Простое введение в динамическое программирование в макроэкономических моделях. » Введение в динамическое программирование как важный инструмент экономической теории.
Динамическое программирование: от новичка к продвинутому Статья Думитру на TopCoder.com о динамическом программировании
Алгебраическое динамическое программирование - формализованная структура для динамического программирования, включая курс начального уровня для DP, Университет Билефельда
Дрейфус, Стюарт, «Ричард Беллман о рождении динамического программирования. "
Учебник по динамическому программированию
A Нежное введение в динамическое программирование и алгоритм Витерби
табличный пролог BProlog и XSB
интерактивные интерактивные модули динамического программирования IFORS, включая, кратчайший путь, коммивояжер, рюкзак, фальшивая монета, падение яйца, мост и факел, замена, связанные матричные продукты и проблема критического пути.