8.1. Таблица значений (динамическое программирование)

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

      Зачем это нужно? Ответ прагматика мог бы быть таким: во многих компьютерах (в том числе, к сожалению, и в современных, использующих так называемые RISC-процессоры), рекурсивные программы в несколько раз медленнее соответствующих нерекурсивных программ. Еще один возможный ответ: в некоторых языках программирования рекурсивные программы запрещены. А главное, при удалении рекурсии возникают изящные и поучительные конструкции.

      8.1.1. Следующая рекурсивная процедура вычисляет числа сочетаний (биномиальные коэффициенты). Написать эквивалентную нерекурсивную программу.
      function C(n,k: integer):integer;
      | {n >= 0; 0 <= k <= n}
      begin
      | if (k = 0) or (k = n) then begin
      | | C:=1;
      | end else begin {0<k><n}
      | | C:= C(n-1,k-1)+C(n-1,k)
      | end;
      end;

      Замечание. C(n,k) - число k-элементных подмножеств n-элементного множества. Соотношение C(n,k) = C(n-1,k-1)+C(n-1,k) получится, если мы фиксируем некоторый элемент n-элементного множества и отдельно подсчитаем k-элементные подмножества, включающие и не включающие этот элемент. Таблица значений C(n,k)
      1
      1 1
      1 2 1
      1 3 3 1
      .................

      называется треугольником Паскаля (того самого). В нем каждый элемент, кроме крайних единиц, равен сумме двух стоящих над ним.

      Решение. Можно воспользоваться формулой
      C(n,k) = n! / (k! * (n-k)!)

      Мы, однако, не будем этого делать, так как хотим продемонстрировать более общие приемы устранения рекурсии. Вместо этого составим таблицу значений функции C(n,k), заполняя ее для n = 0, 1, 2,..., пока не дойдем до интересующего нас элемента.

      8.1.2. Что можно сказать о времени работы рекурсивной и нерекурсивной версий в предыдущей задаче? Тот же вопрос о памяти.

      Решение. Таблица занимает место порядка n*n, его можно сократить до n, если заметить, что для вычисления следующей строки треугольника Паскаля нужна только предыдущая. Время работы в обоих случаях порядка n*n. Рекурсивная программа требует существенно большего времени: вызов C(n,k) сводится к двум вызовам для C(n-1,..), те - к четырем вызовам для C(n-2,..) и т.д. Таким образом, время оказывается экспоненциальным (порядка 2 в степени n). Используемая рекурсивной версией память пропорциональна n - умножаем глубину рекурсии (n) на количество памяти, используемое одним экземпляром процедуры (константа).

      Кардинальный выигрыш во времени при переходе от рекурсивной версии к нерекурсивной связан с тем, что в рекурсивном варианте одни и те же вычисления происходят много раз. Например, вызов C(5,3) в конечном счете порождает два вызова C(3,2):
      C(5,3)
      / \
      C(4,2) C(4,3)
      / \ / \
      C(3,1) C(3,2) C(3,3)
      ......................

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

      8.1.2. Порассуждать на ту же тему на примере рекурсивной и (простейшей) нерекурсивной программ для вычисления чисел Фибоначчи, заданных соотношением
      f(1) = f (2) = 1; f(n) = f(n-1) + f(n-2) для n > 2.

      8.1.3. Дан выпуклый n-угольник (заданный координатами своих вершин в порядке обхода). Его разрезают на треугольники диагоналями, для чего необходимо n-2 диагонали (докажите индукцией по n). Стоимостью разрезания назовем сумму длин всех использованных диагоналей. Найти минимальную стоимость разрезания. Число действий должно быть ограничено некоторым многочленом от n. (Перебор не подходит, так как число вариантов не ограничено многочленом.)

      Решение. Будем считать, что вершины пронумерованы от 1 до n и идут по часовой стрелке. Пусть k, l - номера вершин, причем l>k. Через A(k,l) обозначим многоугольник, отрезаемый от нашего хордой k--l. (Эта хорда разрезает многоугольник на 2, один из которых включает сторону 1--n; через A(k,l) мы обозначаем другой.) Исходный многоугольник естественно обозначить A(1,n). При l=k+1 получается "двуугольник" с совпадающими сторонами.

      Через a(k,l) обозначим стоимость разрезания многоугольника A(k,l) диагоналями на треугольники. Напишем рекуррентную формулу для a(k,l). При l=k+1 получается двуугольник, и мы полагаем a(k,l)=0. При l=k+2 получается треугольник, и в этом случае также a(k,l)=0. Пусть l > k+2. Хорда k--l является стороной многоугольника A(k,l) и, следовательно, стороной одного из треугольников, на которые он разрезан. Противоположной вершиной i этого треугольника может быть любая из вершин k+1,...,l-1, и минимальная стоимость разрезания может быть вычислена как
      min {(длина хорды k--i)+(длина хорды i--l)+a(k,i)+a(i,l)}

      по всем i=k+1,..., i=l-1. При этом надо учесть, что при q=p+1 хорда p--q - не хорда, а сторона, и ее длину надо считать равной 0 (по стороне разрез не проводится).

      Составив таблицу для a(k,l) и заполняя ее в порядке возрастания числа вершин (равного l-k+1), мы получаем программу, использующую память порядка n*n и время порядка n*n*n (однократное применение рекуррентной формулы требует выбора минимума из не более чем n чисел).

      8.1.4. Матрицей размера m*n называется прямоугольная таблица из m строк и n столбцов, заполненная числами. Матрицу размера m*n можно умножить на матрицу размера n*k (ширина левого сомножителя должна равняться высоте правого), и получается матрица размером m*k. Ценой такого умножения будем считать произведение m*n*k (таково число умножений, которые нужно выполнить при стандартном способе умножения - но сейчас это нам не важно). Умножение матриц ассоциативно, поэтому произведение s матриц можно вычислять в разном порядке. Для каждого порядка подсчитаем суммарную цену всех матричных умножений. Найти минимальную цену вычисления произведения, если известны размеры всех матриц. Число действий должно быть ограничено многочленом от числа матриц.

      Пример. Матрицы размером 2*3, 3*4, 4*5 можно перемножать двумя способами. В первом цена равна 2*3*4 + 2*4*5 = 24 + 40 = 64, во втором цена равна 3*4*5 + 2*3*5 = 90.

      Решение. Представим себе, что первая матрица написана на отрезке [0,1], вторая - на отрезке [1,2],..., s-ая - на отрезке [s-1,s]. Матрицы на отрезках [i-1,i] и [i,i+1] имеют общий размер, позволяющих их перемножить. Обозначим его через d[i]. Таким образом, исходным данным в задаче является массив d[0]..d[s].

      Через a(i,j) обозначим минимальную цену вычисления произведения матриц на участке [i,j] (при 0<=i<j><=s). Искомая величина равна a(0,s). Величины a(i,i+1) равны нулю (матрица одна и перемножать ничего не надо). Рекуррентная формула будет такой:
      a(i,j) = min {a(i,k)+ a(k,j) + d[i]*d[k]*d[j]}

      где минимум берется по всем возможных местам последнего умножения, то есть по всем k=i+1..j-1. В самом деле, произведение матриц на отрезке [i,k] есть матрица размера d[i]*d[k], произведение матриц на отрезке [k,j] имеет размер d[k]*d[j], и цена вычисления их произведения равна d[i]*d[k]*d[j].

      Замечание. Две последние задачи похожи. Это сходство станет яснее, если написать матрицы-множители на сторонах 1--2, 2--3,..., s-1--s многоугольника, а на каждой хорде i--j написать произведение всех матриц, стягиваемых этой хордой.

      8.1.5. Железная дорога с односторонним движением имеет n станций. Известны цены билетов от i-ой станции до j-ой (при i < j - в обратную сторону проезда нет). Найти минимальную стоимость проезда от начала до конца (с учетом возможной экономии за счет пересадок).

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

      8.1.6. Задано конечное множество с бинарной операцией (вообще говоря, не коммутативной и даже не ассоциативной). Имеется n элементов a[1]..a[n] этого множества и еще один элемент x. Проверить, можно ли так расставить скобки в произведении a[1]..a[n], чтобы в результате получился x. Число операций должно не превосходить C*n*n*n для некоторой константы C (зависящей от числа элементов в выбранном конечном множестве).

      Решение. Заполняем таблицу, в которой для каждого участка a[i]..a[j] нашего произведения хранится список всех возможных его значений (при разной расстановке скобок).

      По существу этот же прием применяется в полиномиальном алгоритме проверки принадлежности слова произвольному контекстно-свободному языку (см. главу 13).

      Следующая задача (задача о рюкзаке) уже упоминалась в главе 3 (Обход дерева).

      8.1.7. Имеется n положительных целых чисел x[1]..x[n] и число N. Выяснить, можно ли получить N, складывая некоторые из чисел x[1]..x[n]. Число действий должно быть порядка N*n.

      Указание. После i шагов хранится множество тех чисел на отрезке 0..N, которые представимы в виде суммы некоторых из x[1]..x[i].