Динамическое программирование представляет собой математический аппарат, позволяющий быстро находить оптимальное решение в случае, когда анализируемая ситуация не содержит факторов неопределенности, но имеется большое количество вариантов поведения, приносящих различные результаты, среди которых необходимо выбрать наилучший. Динамическое программирование подходит к решению некоторого класса задач путем их разложения на небольшие и менее сложные задачи. В принципе, задачи такого рода могут быть решены путем простого перебора всех возможных вариантов и выбора среди них наилучшего, однако часто такой перебор весьма затруднителен. В таких случаях процесс принятия оптимального решения может быть разбит на шаги (этапы) и исследован с помощью метода динамического программирования.
Решение задач методами динамического программирования проводится на основе сформулированного Р. Э. Беллманом принципа оптимальности: оптимальное поведение обладает тем свойством, что каким бы не было первоначальное поведение системы и первоначальное решение, последующее решение должно определять оптимальное поведение относительно состояния, полученного в результате первоначального решения.
Таким образом, планирование каждого шага должно проводиться с учетом общей выгоды, получаемой по завершении всего процесса, что и позволяет оптимизировать конечный результат по выбранному критерию.
Вместе с тем динамическое программирование не является универсальным методом решения. Практическая каждая задача, решаемая этим методом, характеризуется своими особенностями и требует проведения поиска наиболее приемлемой совокупности методов ее решения. Кроме того, большие объемы и трудоемкость решения многошаговых задач, имеющих множество состояний, приводят к необходимости отбора задач малой размерности либо использования сжатой информации.
Динамическое программирование применяется для решения таких задач, как: распределение дефицитных капитальных вложений между новыми направлениями их использования; разработка правил управления спросом или запасами; разработка принципов календарного планирования производства и выравнивания занятости в условиях колеблющегося спроса на продукцию, составления календарных планов текущего и капитального ремонтов оборудования и его замены; поиск кратчайших расстояний на транспортной сети; формирования последовательности развития коммерческой операции и т. д.
Пусть
процесс оптимизации разбит на n
шагов. На каждом шаге необходимо
определить два типа переменных –
переменную состояния S
и переменную управления X
.
Переменная
определяет, в каких состояниях может
оказаться система на данном k
-м
шаге. В зависимости от
на этом шаге можно применить некоторые
управления, которые характеризуются
переменной .
Применение управления
на k
-м
шаге приносит некоторый результат
и переводит систему в некоторое новое
состояние .
Для каждого возможного состояния на
k
-м
шаге среди всех возможных управлений
выбирается оптимальное управление
такое, чтобы результат, который достигается
за шаги сk
-го
по n
-й
оказался оптимальным. Числовая
характеристика этого результата
называется функцией Беллмана
и зависит от номера шага k
и состояния системы .
Всё решение задачи разбивается на два этапа. На первом этапе, который называют условной оптимизацией ,отыскивается функция Беллмана и оптимальные управления для всех возможных состояний на каждом шаге, начиная с последнего.
После того, как функция Беллмана и соответствующие оптимальные управления найдены для всех шагов с n -го по первый, производится второй этап решения задачи, который называется безусловной оптимизацией .
В
общем случае задача динамического
программирования формулируется следующим
образом: требуется определить такое
управление
,
переводящее систему из начального
состояния
в
конечное состояние
,
при котором целевая функция
принимает наибольшее (наименьшее)
значение.
Особенности математической модели динамического программирования заключаются в следующем:
задача оптимизации формулируется как конечный многошаговый процесс управления;
целевая функция (выигрыш) является аддитивной и равна сумме целевых функций каждого шага:
Условная
оптимизация.
Как уже отмечалось выше, на данном этапе
отыскиваются функция Беллмана и
оптимальное управление для всех возможных
состояний на каждом шаге, начиная с
последнего в соответствии с алгоритмом
обратной прогонки. На последнем n
-м
шаге найти оптимальное управление
и значение функции Беллмана не сложно,
так как ,
где максимум берется по всем возможным
значениям
.
Дальнейшее вычисление производится согласно рекуррентному соотношению, связывающему функцию Беллмана на каждом шаге с этой же функцией, но вычисленной на предыдущем шаге:
Этот максимум (или минимум) определяется по всем возможным для k и S значениям переменной управления X .
Безусловная
оптимизация.
После того, как функция Беллмана и
соответствующие оптимальные управления
найдены для всех шагов с n
-го
по первый (на первом шаге k
=1 состояние
системы равно ее начальному состоянию
),
осуществляется второй этап решения
задачи. Находится оптимальное управление
на первом шаге
,
применение которого переведет систему
в состояние
,
зная которое можно, пользуясь результатами
условной оптимизации, найти оптимальное
управление на втором шаге, и так далее
до последнегоn
-го
шага.
Рассмотрим примеры решения трех задач с использованием динамического программирования, содержание которых требует выбора переменных состояния и управления.
Динамическое программирование - тема, которой в рунете посвящено довольно мало статей, поэтому мы решили ею заняться. В этой статье будут разобраны классические задачи на последовательности, одномерную и двумерную динамику, будет дано обоснование решениям и описаны разные подходы к их реализации. Весь приведённый в статье код написан на Java.
О чём вообще речь? Что такое динамическое программирование?
Метод решения задачи путём её разбиения на несколько одинаковых подзадач, рекуррентно связанных между собой. Самым простым примером будут числа Фибоначчи - чтобы вычислить некоторое число в этой последовательности, нам нужно сперва вычислить третье число, сложив первые два, затем четвёртое таким же образом
на основе второго и третьего, и так далее (да, мы слышали про замкнутую формулу).
Хорошо, как это использовать?
Решение задачи динамическим программированием должно содержать следующее:
И что, мне для решения рекурсивный метод писать надо? Я слышал, они медленные.
Конечно, не надо, есть и другие подходы к реализации динамики. Разберём их на примере следующей задачи:
Вычислить n-й член последовательности, заданной формулами:
a 2n = a n + a n-1 ,
a 2n+1 = a n — a n-1 ,
a 0 = a 1 = 1.
Идея решения
Здесь нам даны и начальные состояния (a 0 = a 1 = 1), и зависимости. Единственная сложность, которая может возникнуть - понимание того, что 2n - условие чётности числа, а 2n+1 - нечётности. Иными словами, нам нужно проверять, чётно ли число, и считать его в зависимости от этого по разным формулам.
Рекурсивное решение
Очевидная реализация состоит в написании следующего метода:
Private static int f(int n){ if(n==0 || n==1) return 1; // Проверка на начальное значение if(n%2==0){ //Проверка на чётность return f(n/2)+f(n/2-1); // Вычисляем по формуле для чётных индексов, // ссылаясь на предыдущие значения }else{ return f((n-1)/2)-f((n-1)/2-1); // Вычисляем по формуле для нечётных //индексов, ссылаясь на предыдущие значения } }
И она отлично работает, но есть нюансы. Если мы захотим вычислить f(12) , то метод будет вычислять сумму f(6)+f(5) . В то же время, f(6)=f(3)+f(2) и f(5)=f(2)-f(1) , т.е. значение f(2) мы будем вычислять дважды. Спасение от этого есть - мемоизация (кеширование значений).
Рекурсивное решение с кэшированием значений
Идея мемоизации очень проста - единожды вычисляя значение, мы заносим его в какую-то структуру данных. Перед каждым вычислением мы проверяем, есть ли вычисляемое значение в этой структуре, и если есть, используем его. В качестве структуры данных можно использовать массив, заполненный флаговыми значениями. Если значение элемента по индексу N равно значению флага, значит, мы его ещё не вычисляли. Это создаёт определённые трудности, т.к. значение флага не должно принадлежать множеству значений функции, которое не всегда очевидно. Лично я предпочитаю использовать хэш-таблицу - все действия в ней выполняются за O(1) , что очень удобно. Однако, при большом количестве значений два числа могут иметь одинаковый хэш, что, естественно, порождает проблемы. В таком случае стоит использовать, например, красно-чёрное дерево .
Для уже написанной функции f(int) кэширование значений будет выглядеть следующим образом:
Private static HashMap
Не слишком сложно, согласитесь? Зато это избавляет от огромного числа операций. Платите вы за это лишним расходом памяти.
Последовательное вычисление
Теперь вернёмся к тому, с чего начали - рекурсия работает медленно. Не слишком медленно, чтобы это приносило действительные неприятности в настоящей жизни, но на соревнованиях по спортивному программированию каждая миллисекунда на счету.
Метод последовательного вычисления подходит, только если функция ссылается исключительно на элементы перед ней - это его основной, но не единственный минус. Наша задача этому условию удовлетворяет.
Суть метода в следующем: мы создаём массив на N элементов и последовательно заполняем его значениями. Вы, наверное, уже догадались, что таким образом мы можем вычислять в том числе те значения, которые для ответа не нужны. В значительной части задач на динамику этот факт можно опустить, так как для ответа часто бывают нужны как раз все значения. Например, при поиске наименьшего пути мы не можем не вычислять путь до какой-то точки, нам нужно пересмотреть все варианты. Но в нашей задаче нам нужно вычислять приблизительно log 2 (N) значений (на практике больше), для 922337203685477580-го элемента (MaxLong/10) нам потребуется 172 вычисления.
Private static int f(int n){
if(n<2) return 1; //Может, нам и вычислять ничего не нужно?
int fs = int[n]; //Создаём массив для значений
fs=fs=1; //Задаём начальные состояния
for(int i=2; i Ещё одним минусом такого подхода является сравнительно большой расход памяти. Сейчас нам предстоит, по сути, написать свою собственную рекурсию. Идея состоит в следующем - сначала мы проходим «вниз» от N до начальных состояний, запоминая аргументы, функцию от которых нам нужно будет вычислять. Затем возвращаемся «вверх», последовательно вычисляя значения от этих аргументов, в том порядке, который мы записали. Зависимости вычисляются следующим образом: LinkedList Полученный размер стека – то, сколько вычислений нам потребуется сделать. Именно так я получил упомянутое выше число 172. Теперь мы поочередно извлекаем индексы и вычисляем для них значения по формулам – гарантируется, что все необходимые значения уже будут вычислены. Хранить будем как раньше – в хэш-таблице. HashMap Все необходимые значения вычислены, осталось только написать Return values.get(n);
Конечно, такое решение гораздо более трудоёмкое, однако это того стоит. Для больше ясности разберём следующую задачу на одномерную динамику: На вершине лесенки, содержащей N ступенек, находится мячик, который начинает прыгать по ним вниз, к основанию. Мячик может прыгнуть на следующую ступеньку, на ступеньку через одну или через 2. (То есть, если мячик лежит на 8-ой ступеньке, то он может переместиться на 5-ую, 6-ую или 7-ую.) Определить число всевозможных «маршрутов» мячика с вершины на землю. На первую ступеньку можно попасть только одним образом - сделав прыжок с длиной равной единице. На вторую ступеньку можно попасть сделав прыжок длиной 2, или с первой ступеньки - всего 2 варианта. На третью ступеньку можно попасть сделав прыжок длиной три, с первой или со втрой ступенек. Т.е. всего 4 варианта (0->3; 0->1->3; 0->2->3; 0->1->2->3). Теперь рассмотрим четвёртую ступеньку. На неё можно попасть с первой ступеньки - по одному маршруту на каждый маршрут до неё, со второй или с третьей - аналогично. Иными словами, количество путей до 4-й ступеньки есть сумма маршрутов до 1-й, 2-й и 3-й ступенек. Математически выражаясь, F(N) = F(N-1)+F(N-2)+F(N-3) . Первые три ступеньки будем считать начальными состояниями. Здесь ничего хитрого нет. Исходя из того, что, по большому счёту, простое решение на массиве из N элементов очевидно, я продемонстрирую тут решение на массиве всего из трёх. Int vars = new int;
vars=1;vars=2;vars=4;
for(int i=3; i Так как каждое следующее значение зависит только от трёх предыдущих, ни одно значение под индексом меньше i-3 нам бы не пригодилось. В приведённом выше коде мы записываем новое значение на место самого старого, не нужного больше. Цикличность остатка от деления на 3 помогает нам избежать кучи условных операторов. Просто, компактно, элегантно. С двумерной динамикой не связано никаких особенностей, однако я, на всякий случай, рассмотрю здесь одну задачу и на неё. В прямоугольной таблице NxM в начале игрок находится в левой верхней клетке. За один ход ему разрешается перемещаться в соседнюю клетку либо вправо, либо вниз (влево и вверх перемещаться запрещено). Посчитайте, сколько есть способов у игрока попасть в правую нижнюю клетку. Логика решения полностью идентична таковой в задаче про мячик и лестницу - только теперь в клетку (x,y) можно попасть из клеток (x-1,y) или (x, y-1) . Итого F(x,y) = F(x-1, y)+F(x,y-1) . Дополнительно можно понять, что все клетки вида (1,y) и (x,1) имеют только один маршрут - по прямой вниз или по прямой вправо. Ради всего святого, не нужно делать двумерную динамику через рекурсию. Уже было упомянуто, что рекурсия менее выгодна, чем цикл по быстродействию, так двумерная рекурсия ещё и читается ужасно. Это только на таком простом примере она смотрится легко и безобидно. Private static int f(int i, int j) {
if(i==1 || j==1) return 1;
return f(i-1, j)+f(i, j-1);
}
В заключение приведу ряд типичных задач на одномерную и двумерную динамику, разборы прилагаются. При переработке радиоактивных материалов образуются отходы двух видов - особо опасные (тип A) и неопасные (тип B). Для их хранения используются одинаковые контейнеры. После помещения отходов в контейнеры последние укладываются вертикальной стопкой. Стопка считается взрывоопасной, если в ней подряд идет более одного контейнера типа A. Стопка считается безопасной, если она не является взрывоопасной. Для заданного количества контейнеров N определить количество возможных типов безопасных стопок. Ответом является (N+1)-е число Фибоначчи. Догадаться можно было, просто вычислив 2-3 первых значения. Строго доказать можно было, построив дерево возможных построений. Каждый основной элемент делится на два - основной (заканчивается на B) и побочный (заканчивается на A). Побочные элементы превращаются в основные за одну итерацию (к последовательности, заканчивающейся на A, можно дописать только B). Это характерно для чисел Фибоначчи. Например, так: //Ввод числа N с клавиатуры
N+=2;
BigInteger fib = new BigInteger;
fib=fib=BigInteger.ONE;
for(int i=2; i Мальчик подошел к платной лестнице. Чтобы наступить на любую ступеньку, нужно заплатить указанную на ней сумму. Мальчик умеет перешагивать на следующую ступеньку, либо перепрыгивать через ступеньку. Требуется узнать, какая наименьшая сумма понадобится мальчику, чтобы добраться до верхней ступеньки. Очевидно, что сумма, которую мальчик отдаст на N-ой ступеньке, есть сумма, которую он отдал до этого плюс стоимость самой ступеньки. «Сумма, которую он отдал до этого» зависит от того, с какой ступеньки мальчик шагает на N-ую - с (N-1)-й или с (N-2)-й. Выбирать нужно наименьшую. Например, так: Int Imax;
//*ввод с клавиатуры числа ступенек*
DP = new int;
for(int i=0; i Имеется калькулятор, который выполняет три операции: Определите, какое наименьшее число операций необходимо для того, чтобы получить из числа 1 заданное число N. Выведите это число, и, на следующей строке, набор исполненных операций вида «111231». Наивное решение состоит в том, чтобы делить число на 3, пока это возможно, иначе на 2, если это возможно, иначе вычитать единицу, и так до тех пор, пока оно не обратится в единицу. Это неверное решение, т.к. оно исключает, например, возможность убавить число на единицу, а затем разделить на три, из-за чего на больших числах (например, 32718) возникают ошибки. Правильное решение заключается в нахождении для каждого числа от 2 до N минимального количества действий на основе предыдущих элементов, иначе говоря: F(N) = min(F(N-1), F(N/2), F(N/3)) + 1 . Следует помнить, что все индексы должны быть целыми. Для воссоздания списка действий необходимо идти в обратном направлении и искать такой индекс i, что F(i)=F(N) , где N - номер рассматриваемого элемента. Если i=N-1 , записываем в начало строки 1, если i=N/2 - двойку, иначе - тройку. В каждой клетке прямоугольной таблицы N*M записано некоторое число. Изначально игрок находится в левой верхней клетке. За один ход ему разрешается перемещаться в соседнюю клетку либо вправо, либо вниз (влево и вверх перемещаться запрещено). При проходе через клетку с игрока берут столько килограммов еды, какое число записано в этой клетке (еду берут также за первую и последнюю клетки его пути). Требуется найти минимальный вес еды в килограммах, отдав которую игрок может попасть в правый нижний угол. Допустим, есть задача, которую мы уже решили динамическим программированием, например, извечные числа Фибоначчи. Это значит, что если взять вектор А теперь, зачем всё это надо. Умножение матриц обладает свойством ассоциативности, то есть (но при этом не обладает коммутативностью, что по-моему удивительно). Это свойство даёт нам право сделать так: . Это хорошо тем, что теперь можно применить метод быстрого возведения в степень , который работает за . Итого мы сумели посчитать N -ое число Фибоначчи за логарифм арифметических операций. А теперь пример посерьёзнее: Решение
Для начала решение без матрицы перехода: 1) Состояние динамики: dp[n] - количество пилообразных последовательностей длины n , заканчивающихся на цифру last . Причём если less == 0 , то последняя цифра меньше предпоследней, а если less == 1 , значит больше. Теперь надо придумать начальный вектор и матрицу перехода к нему. Вектор, кажется, придумывается быстро: все состояния, обозначающие длину последовательности N . Ну а матрица перехода выводится, смотря на формулы пересчёта. Вектор и матрица перехода
Определим сжатую строку: Необходимо по строке s узнать длину самой короткой сжатой строки, разжимающийся в неё. Решение
Решается эта задача, как вы уже наверняка догадались, динамикой по подотрезкам. 1) Состояние динамики: d[l][r] - сжатая строка минимальной длины, разжимающаяся в строку s Dp_len = r - l
dp[l][r] = dp_len # Первый вариант сжатия - просто строка.
for i in range(l + 1, r):
dp[l][r] = min(dp[l][r], dp[l][i] + dp[i][r]) # Попробовать разделить на две сжатые подстроки
for cnt in range(2, dp_len):
if (dp_len % cnt == 0): # Если не делится, то нет смысла пытаться разделить
good = True
for j in range(1, (dp_len / cnt) + 1): # Проверка на то, что все cnt подстрок одинаковы
good &= s == s
if good: # Попробовать разделить на cnt одинаковых подстрок и сжать
dp[l][r] = min(dp[l][r], len(str(cnt)) + 1 + dp[l] + 1)
4) Порядок пересчёта: прямой по возрастанию длины подстроки или ленивая динамика. Требуется найти минимальное количество изменений логических операций во внутренних вершинах, такое, чтобы изменилось значение в корне или сообщить, что это невозможно. Решение
1) Состояние динамики: d[v][x] - количество операций, требуемых для получения значения x в вершине v . Если это невозможно, то значение состояния - +inf . Если операция «И» и нужно получить «0», то ответ это минимум из значений d[i] , где i - сын v . 4) Порядок пересчёта: легче всего реализуется лениво - в виде поиска в глубину из корня. Решение
Так как мы ищем цикл, проходящий через все вершины, то можно выбрать за «начальную» вершину любую. Пусть это будет вершина с номером 0 . 1) Состояние динамики: dp[v] - путь минимального веса из вершины 0 в вершину v , проходящий по всем вершинам, лежащим в mask и только по ним. Эти задачи можно решить полным перебором за , где a - количество вариантов замощения одной клетки. Динамика по профилю же оптимизирует время по одной из размерностей до линейной, оставив от себя в экспоненте только коэффициент. Получится что-то такое: . Профиль - это k (зачастую один) столбцов, являющиеся границей между уже замощённой частью и ещё не замощённой. Эта граница заполнена только частично. Очень часто является частью состояния динамики. Почти всегда состояние - это профиль и то, где этот профиль. А переход увеличивает это местоположение на один. Узнать, можно ли перейти из одного профиля в другой можно за линейное от размера профиля время. Это можно проверять каждый раз во время пересчёта, но можно и предподсчитать. Предподсчитывать будем двумерный массив can - можно ли от одной маски перейти к другой, положив несколько фигурок, увеличив положение профиля на один. Если предподсчитывать, то времени на выполнение потребуется меньше, а памяти - больше. Решение
Здесь профиль - это один столбец. Хранить его удобно в виде двоичной маски: 0 - не замощенная клетка столбца, 1 - замощенная. То есть всего профилей . 0) Предподсчёт (опционально): перебрать все пары профилей и проверить, что из одного можно перейти в другой. В этой задаче это проверяется так: Если в первом профиле на очередном месте стоит 1 , значит во втором обязательно должен стоять 0 , так как мы не сможем замостить эту клетку никакой фигуркой. Если в первом профиле на очередном месте стоит 0 , то есть два варианта - или во втором 0 или 1 . Примеры переходов (из верхнего профиля можно перейти в нижние и только в них): После этого сохранить всё в массив can - 1 , если можно перейти, 0 - если нельзя. Полученная асимптотика - . Теперь, после добавления излома в профиль, можно переходить к следующему состоянию, добавляя всего одну фигурку, накрывающую левую клетку излома. То есть увеличением числа состояний в N раз (надо помнить, где место излома) мы сократили число переходов из одного состояния в другое с до . Асимптотика улучшилась с до Переходы в динамике по изломанному профилю на примере задачи про замощение доминошками (пример №8): В каждой задаче свой способ восстановления ответа, но самые распространенные: На уроке будет рассмотрено понятие динамического программирования и исторический аспект его появления. Рассмотрены задачи динамического программирования и некоторые примеры их решения Само понятие «динамическое программирование» впервые было использовано в 1940-х годах Ричардом Беллманом для описания процесса нахождения решения задачи, где ответ на одну задачу может быть получен только после решения другой задачи, «предшествующей» ей. Позднее формулировка понятия была доработана и усовершенствованна до современного вида самим же Беллманом. Слово «программирование»
в контексте «динамическое программирование» на самом деле к классическому пониманию программирования (написанию кода на языке программирования) практически никакого отношения не имеет
. Слово «Программирование» имеет такой же смысл как в словосочетании «математическое программирование», которое является синонимом слова «оптимизация». Поэтому программы
будут использоваться в качестве оптимальной последовательности действий для получения решения задачи. В общем же для начала, неформальное определение понятия динамического программирования
может звучать так: Динамическое программирование
— это техника или метод, которая позволяет решать некоторые задачи комбинаторики, оптимизации и другие задачи, обладающие определенным свойством (свойством сооптимальности у подзадач). Задачи оптимизации
, как правило, связаны с задачей максимизации или минимизации той или иной целевой функции (например, максимизировать вероятность того, что система не сломается, максимизировать мат. ожидание получения прибыли и т.д.). Задачи комбинаторики
, как правило, отвечают на вопрос, сколько существует объектов, обладающих теми или иными свойствами, или сколько существует комбинаторных объектов, обладающих заданными свойствами. То есть, ДП решает не все задачи, а лишь некоторые, определенный класс подзадач. Но этот класс подзадачи используется во многих областях знаний: программирование, математика, лингвистика, статистика, теория игр, экономика, в компьютерных науках и т.п. Задачи, решаемые при помощи динамического программирования, должны обладать свойством сооптимальности
, о котором будет сказано в дальнейших уроках. Неформальное объяснение свойства оптимальности у подзадач может быть продемонстрировано с помощью диаграммы: Рис. 1.1. Неформальное объяснение свойства оптимальности у подзадач Более подробно неформальное объяснение рассматривается . Сначала рассмотрим задачи оптимизации (задачи 1-5): Пример:
Есть некоторая карта дорог, представленная в виде графа. Наша цель: добраться из пункта А
в пункт Б
. Это сделать надо так, чтобы минимизировать расстояние или потраченное топливо. Целевой функцией
здесь является расстояние от А
до Б
. Т.е. наша цель — минимизировать расстояние. А что является переменной выбора
? Для того, чтобы найти кратчайший путь, надо каждый раз принимать решения. Т.е. в каждой точке или на каждом перекрестке необходимо принимать решения: куда повернуть или ехать прямо. Важно:
Из этой задачи уже можно увидеть общую структуру задач, решаемых при помощи динамического программирования: в каждой задаче есть целевая функция и переменная выбора
. Пример:
Каждый год мы принимаем решение, ездить ли на старой машине еще год и понести при этом издержки на поддержку и обслуживание старой машины или же продать эту машину и купить новую (и понести при этом издержки на покупку). Целевая функция:
минимизация расходов (либо на издержки на поддержку старого автомобиля, либо на покупку нового). Переменная выбора:
каждый год принимать решение продать машину или оставить. Пример:
Игра на бирже, приобретение акций каких-либо компаний Переменная выбора:
то, какой портфель вложений будет: сколько акций и какой фирмы нам необходимо купить. Пример:
Есть завод, изготавливающий мебель. На заводе работает определенное количество работников, которые могут изготовить соответствующее кол-во определенной мебели (стулья, столы, шкафы и т.п.) Переменная выбора:
выбор того, сколько необходимо изготовить стульев или столов, чтобы хватило рабочей силы. Пример:
Участие в различных играх Переменная выбора здесь зависит от конкретной игры. Задачи 1 — 5 — это примеры задач оптимизации.
Комбинаторика:
Пример:
Задача на решение того, сколько существует деревьев, у которых определенное число листьев; или сколько существует графов для решения такого-то задания и т.п. Пример:
Есть монеты разного достоинства, какими способами можно вернуть сдачу. Это краткое описание задач для динамического программирования, которые подробно будут рассмотрены позднее. Неформальное объяснение оптимальности подзадач ДП.
Рассмотрим неформальную
идею ДП. Итак, возьмем пример с заводом, изготавливающим мебель. Для достижения цели максимизации прибыли необходимо решить множество подзадач:
При большом количестве подзадач сложно понять, как решать такую задачу. Как правило, решить одну малую задачу проще, чем решить большую задачу
, состоящую из маленьких. Поэтому ДП предлагает следующее: Например, завод производит только стулья. У директора стоит задача получения максимальной прибыли с продажи стульев. Часто при постановке задачи кажущимся оптимальным решением является перебор всех возможных вариантов
. Однако, вследствии очень большого количества таких вариантов и, как результат, перегрузки памяти компьютера, такой способ не всегда приемлем. Кроме того, может возникнуть такой вопрос: для того чтобы найти, например, минимум или максимум, почему бы нам не найти производную? или не использовать множества Ла-Гранжа, или другие методы аппарата математического анализа? Зачем нужно ДП, если есть большой арсенал средств? Дело в том, что: В основе динамического программирования лежит идея решения поставленной задачи путем деления ее на отдельные части (подзадачи, этапы), решение этих подзадач и последующего объединения этих решений в одно общее решение. Часто большинство из подзадач абсолютно одинаковы. При этом важно, что при решении более сложной задачи, мы не решаем заново маленькую подзадачу, а используем уже решенный ответ этой подзадачи.
Важно:
По этой причине разделение задачи на подзадачи и решение этих подзадач только один раз (!)
, сокращая этим количество общих вычислений — более оптимальный способ, который и заложен в динамическом программировании Когда мы решаем задачу с производными, множествами Ла-Гранжа и т.п., то мы работаем с непрерывными функциями. При решении же задач ДП мы будем работать в основном с дискретными функциями, поэтому говорить здесь о применении непрерывных функций неуместно. Рассмотрим вариант решения задачи с помощью динамического программирования. Пример:
Необходимо вычислить сумму n чисел: 1 + 2 + 3 + ... + n Попробуем применить к задаче идеи ДП и решить ее, разбивая на простые подзадачи. Простой пример, где пока неоправданно используется ДП (искусственно), демонстрирует принцип идей ДП. Рассмотрим еще один пример. Пример:
имеется лесенка из n ступенек, перед которой находится человек, который за 1
шаг умеет подниматься либо на следующую ступеньку, либо перепрыгивает через одну ступеньку. Вопрос: сколькими способами он может попасть на последнюю ступеньку? Рассмотрим самые простые варианты (подзадачи): Рассмотрим пример из i ступенек
Как мы можем попасть на i ступеньку: Например, как попасть на 4-ю ступеньку
: Т.о., общее количество способов
попасть на i ступеньку: Определим начальные значения
, с которых следует начинать решать задачу. Мы видим, что задача по сути комбинаторная (т.е. количество способов сделать что-либо) свелась к вычислению некоторой рекуррентной последовательности. Задание 1:
реализовать пример для первых десяти ступенек (по сути, первые 10 чисел ряда Фибоначчи), используя рекурсию.
Дополните код:
var c:integer;
procedure getKolSposob(i,n: integer);
begin
writeln (i+n," ");
inc(c);
if ... then
getKolSposob(...,...)
end;
begin
c:=1;
getKolSposob(0,1);
end. Задание 2:
Создание стека индексов
Хорошо, математика - это красиво. А что с задачами, в которых не всё дано?
Идея решения
Реализация через рекурсию
private static int f(int n){
if(n==1) return 1;
if(n==2) return 2;
if(n==3) return 4;
return f(n-1)+f(n-2)+f(n-3);
}
Там вверху ещё было написано про какую-то двумерную динамику?..
Идея решения
Реализация через рекурсию
Реализация через массив значений
int dp = new int;
for(int i=0; iОтлично, я всё понял. На чём мне проверить свои навыки?
Взрывоопасность
Решение
Реализация
Подъём по лестнице
Решение
Реализация
Калькулятор
Решение
Реализация
int N;
//Ввод с клавиатуры
int a = new int;
a= 0;
{
int min;
for(int i=2; iСамый дешёвый путь
Давайте немного переформулируем её. Пусть у нас есть вектор , из которого мы хотим получить вектор . Чуть-чуть раскроем формулы: . Можно заметить, что из вектора можно получить вектор 
путем умножения на какую-то матрицу, ведь в итоговом векторе фигурируют только сложенные переменные из первого вектора. Эту матрицу легко вывести, вот она: 
. Назовём её матрицей перехода.
и умножить его на матрицу перехода n - 1 раз, то получим вектор , в котором лежит fib[n] - ответ на задачу.Пример №3: Пилообразная последовательность
Обозначим пилообразную последовательность длины N как последовательность, у которой для каждого не крайнего элемента выполняется условие: он или меньше обоих своих соседей или больше. Требуется посчитать количество пилообразных последовательностей из цифр длины N . Выглядит это как-то так: 
2) Начальные значения:
for last in range(10):
dp = 9 - last
dp = last
3) Пересчёт динамики:
for prev in range(10):
if prev > last:
dp[n] += dp
if prev < last:
dp[n] += dp
4) Порядок пересчёта: мы всегда обращаемся к предыдущей длине, так что просто пара вложенных for "ов.
5) Ответ - это сумма dp[N] .
Динамика по подотрезкам
Это класс динамики, в котором состояние - это границы подотрезка какого-нибудь массива. Суть в том, чтобы подсчитать ответы для подзадач, основывающихся на всех возможных подотрезках нашего массива. Обычно перебираются они в порядке увеличения длины, и пересчёт основывается, соответственно на более коротких отрезках.Пример №4: Запаковка строки
Вот Развернутое условие . Я вкратце его перескажу:
1) Строка состоящая только из букв - это сжатая строка. Разжимается она в саму себя.
2) Строка, являющаяся конкатенацией двух сжатых строк A и B . Разжимается она в конкатенацию разжатых строк A и B .
3) Строка D(X) , где D - целое число, большее 1 , а X - сжатая строка. Разжимается она в конкатенацию D строк, разжатых из X .
Пример: “3(2(A)2(B))C” разжимается в “AABBAABBAABBC” .
2) Начальные состояния: все подстроки длины один можно сжать только в них самих.
3) Пересчёт динамики:
У лучшего ответа есть какая-то последняя операция сжатия: либо это просто строка из заглавных букв, или это конкатенация двух строк, или само сжатие. Так давайте переберём все варианты и выберем лучший.
5) Ответ лежит в d .Пример №5:
Динамика по поддеревьям
Параметром состояния динамики по поддеревьям обычно бывает вершина, обозначающая поддерево, в котором эта вершина - корень. Для получения значения текущего состояния обычно нужно знать результаты всех своих детей. Чаще всего реализуют лениво - просто пишут поиск в глубину из корня дерева.Пример №6: Логическое дерево
Дано подвешенное дерево, в листьях которого записаны однобитовые числа - 0 или 1 . Во всех внутренних вершинах так же записаны числа, но по следующему правилу: для каждой вершины выбрана одна из логических операций: «И» или «ИЛИ». Если это «И», то значение вершины - это логическое «И» от значений всех её детей. Если же «ИЛИ», то значение вершины - это логическое «ИЛИ» от значений всех её детей.
2) Начальные значения: для листьев, очевидно, что своё значение можно получить за ноль изменений, изменить же значение невозможно, то есть возможно, но только за +inf операций.
3) Формула пересчёта:
Если в этой вершине уже значение x , то ноль. Если нет, то есть два варианта: изменить в текущей вершине операцию или нет. Для обоих нужно найти оптимальный вариант и выбрать наилучший.
Если операция «И» и нужно получить «1», то ответ это сумма всех значений d[i] , где i - сын v .
Если операция «ИЛИ» и нужно получить «0», то ответ это сумма всех значений d[i] , где i - сын v .
Если операция «ИЛИ» и нужно получить «1», то ответ это минимум из значений d[i] , где i - сын v .
5) Ответ - d xor 1] .Динамика по подмножествам
В динамике по подмножествам обычно в состояние входит маска заданного множества. Перебираются чаще всего в порядке увеличения количества единиц в этой маске и пересчитываются, соответственно, из состояний, меньших по включению. Обычно используется ленивая динамика, чтобы специально не думать о порядке обхода, который иногда бывает не совсем тривиальным.Пример №7: Гамильтонов цикл минимального веса, или задача коммивояжера
Задан взвешенный (веса рёбер неотрицательны) граф G размера N . Найти гамильтонов цикл (цикл, проходящий по всем вершинам без самопересечений) минимального веса.
2) Начальные значения: dp = 0 , все остальные состояния изначально - +inf .
3) Формула пересчёта: Если i -й бит в mask равен 1 и есть ребро из i в v , то:
dp[v] = min(dp[v], dp[i] + w[i][v])
Где w[i][v] - вес ребра из i в v .
4) Порядок пересчёта: самый простой и удобный способ - это написать ленивую динамику, но можно поизвращаться и написать перебор масок в порядке увеличения количества единичных битов в ней.
5) Ответ лежит в d[(1 << N) - 1] .Динамика по профилю
Классическими задачами, решающимися динамикой по профилю, являются задачи на замощение поля какими-нибудь фигурами. Причём спрашиваться могут разные вещи, например, количество способов замощения или замощение минимальным количеством фигур. 
Пример №8: Замощение доминошками
Найти количество способов замостить таблицу N x M с помощью доминошек размерами 1 x 2 и 2 x 1 .
Если 0 , это значит, что мы обязаны положить вертикальную доминошку, а значит следующую клетку можно рассматривать как 1 . Если 1 , то мы ставим вертикальную доминошку и переходим к следующей клетке.
1) Состояние динамики: dp - количество полных замощений первых pos - 1 столбцов с профилем mask .
2) Начальное состояние: dp = 1 - левая граница поля - прямая стенка.
3) Формула пересчёта:
dp += dp * can
4) Порядок обхода - в порядке увеличения pos .
5) Ответ лежит в dp.Динамика по изломанному профилю
Это очень сильная оптимизация динамики по профилю. Здесь профиль - это не только маска, но ещё и место излома. Выглядит это так:
.
Восстановление ответа
Иногда бывает, что просто знать какую-то характеристику лучшего ответа недостаточно. Например, в задаче «Запаковка строки» (пример №4) мы в итоге получаем только длину самой короткой сжатой строки, но, скорее всего, нам нужна не её длина, а сама строка. В таком случае надо восстановить ответ.Небольшие оптимизации
Память
Зачастую в динамике можно встретить задачу, в которой состояние требует быть посчитанными не очень большое количество других состояний. Например, при подсчёте чисел Фибоначчи мы используем только два последних, а к предыдущим уже никогда не обратимся. Значит, можно про них забыть, то есть не хранить в памяти. Иногда это улучшает асимптотическую оценку по памяти. Этим приёмом можно воспользоваться в примерах №1, №2, №3 (в решении без матрицы перехода), №7 и №8. Правда, этим никак не получится воспользоваться, если порядок обхода - ленивая динамика.Время
Иногда бывает так, что можно улучшить асимптотическое время, используя какую-нибудь структуру данных. К примеру, в алгоритме Дейкстры можно воспользоваться очередью с приоритетами для изменения асимптотического времени.Замена состояния
В решениях динамикой обязательно фигурирует состояние - параметры, однозначно задающие подзадачу, но это состояние не обязательно одно единственное. Иногда можно придумать другие параметры и получить с этого выгоду в виде снижения асимптотического времени или памяти.Пример №9: Разложение числа
Требуется найти количество разложений числа N на различные слагаемые. Например, если N = 7 , то таких разложений 5:
Таким образом, американский математик и один из ведущих специалистов в области математики и вычислительной техники — Ричард Эрнст Беллман
— стал прородителем динамического программирования.
Есть задача, которую мы хотим решить при помощи ДП, т.е. найти какой-то план ее решения. Допустим эта задача сложна и сразу решить мы ее не можем. Мы берем малую подзадачу и решаем сначала ее (для x1). Затем используя это малое решение x1 , и не меняя структуру этого решения, решаем следующую задачу уже с x1 и x2 . И т.д.
Примеры, решаемых при помощи динамического программирования задач
Целевая функция:
максимизация средних
доходов, т.к. на бирже доход получается вероятностным путем, т.е. это статистический процесс, вероятностный.
Целевая функция
: максимизация прибыли.
Целевая функция:
максимизация вероятности выигрыша или максимизация среднего выигрыша и т.д.
Понятие динамического программирования
Формальная идея ДП
На графике это может выглядеть так:
По этой причине во многих задачах, но не во всех, применение аппарата математического анализа будет неприемлемым.Простой пример решения задач при помощи ДП
В чем состоит якобы «сложность» данной задачи: в том, что необходимо сразу взять большое количество чисел и получить ответ.
(В ДП всегда необходимо сначала определить начальные условия или условие)
F(1) = 1
F(2) = F(1) + 2 = 1 + 2 = 3 , т.е. надо взять сумму первого элемента и добавить к нему второй элемент
F(n) = F(n-1) + An
Итак, что мы сделали: определили порядок и вычленили подзадачи, затем решили каждую из них, опираясь на решение предыдущей.
Решение:
f(a i) = f(a i-1) + f(a i-2)
Если начинать с 1, то формула соответствует нахождению последовательности чисел Фибоначчи. 1
2
3
4
5
6
7
8
9
10
11
12
13
var
c:
integer
;
procedure
getKolSposob(i,
n:
integer
)
;
begin
writeln
(i+
n,
" "
)
;
inc(c)
;
if
...
then
getKolSposob(...,...
)
end
;
begin
c:
=
1
;
getKolSposob(0
,
1
)
;
end
.
Решение 15-го типа заданий ЕГЭ (Графы. Поиск количества путей).
Значение слова неудачный
Обзор Samsung Galaxy A7 (2017): не боится воды и экономии Стоит ли покупать samsung a7
Делаем бэкап прошивки на андроиде
Как настроить файл подкачки?
Установка режима совместимости в Windows