Жанр: Учеба
Программирование в теоремах и задачах
...оцедура print_subtree(x) печатает все вершины
поддерева с корнем в x по одному разу; главная программа содержит
вызов print_subtree(root).
procedure print_subtree (x:integer);
begin
| if x = nil then begin
| | {ничего не делать}
| end else begin
| | writeln (x);
| | print_subtree (l[x]);
| | print_subtree (r[x]);
| end;
end;
Данная программа печатает сначала корень поддерева, затем поддерево
над левым сыном, а затем над правым. Три строки в else-части
могут быть переставлены 6 способами, и каждый из этих способов
дает свой порядок печати вершин.
7.3. Порождение комбинаторных объектов, перебор
Рекурсивные программы являются удобным способом порождения
комбинаторных объектов заданного вида. Мы решим заново несколько
задач соотвтетсвующей главы.
7.3.1. Написать программу, которая печатает по одному разу
все последовательности длины n, составленные из чисел 1..k (их
количество равно k в степени n).
Решение. Программа будет оперировать с массивом a[1]..a[n]
и числом t. Рекурсивная процедура generate печатает все последовательности,
начинающиеся на a[1]..a[t]; после ее окончания t
имеет то же значение, что и в начале:
procedure generate;
| var i,j : integer;
begin
| if t = n then begin
| | for i:=1 to n do begin
| | | write(a[i]);
| | end;
| | writeln;
| end else begin {t " n}
| | for j:=1 to k do begin
| | | t:=t+1;
| | | a[t]:=j;
| | | generate;
| | | t:=t-1;
| | end;
| end;
end;
Основная программа теперь состоит из двух операторов:
t:=0; generate;
7.3.2. Написать программу, которая печатала бы все перестановки
чисел 1..n по одному разу.
Решение. Программа оперирует с массивом a[1]..a[n], в котором
хранится перестановка чисел 1..n. Рекурсивная процедура
generate в такой ситуации печатает все перестановки, которые на
первых t позициях совпадают с перестановкой a; по выходе из нее
переменные t и a имеют те же значения, что и до входа. Основная
программа такова:
for i:=1 to n do begin a[i]:=i; end;
t:=0;
generate;
вот описание процедуры:
procedure generate;
| var i,j : integer;
begin
| if t = n then begin
| | for i:=1 to n do begin
| | | write(a[i]);
| | end;
| | writeln;
| end else begin {t " n}
| | for j:=t+1 to n do begin
| | | поменять местами a[t+1] и a[j]
| | | t:=t+1;
| | | generate;
| | | t:=t-1;
| | | поменять местами a[t+1] и a[j]
| | end;
| end;
end;
7.3.3. Напечатать все возрастающие последовательности длины
k, элементами которых являются натуральные числа от 1 до n.
(Предполагается, что k не превосходит n - иначе таких последовательностей
не существует.)
Решение. Программа оперирует с массивом a[1]..a[k] и целой
переменной t. Предполагая, что a[1]..a[t] - возрастающая последовательность
чисел натуральных чисел из отрезка 1..n, рекурсивно
определенная процедура generate печатает все ее возрастающие
продолжения длины k.
procedure generate;
| var i: integer;
begin
| if t = k then begin
| | печатать a[1]..a[k]
| end else begin
| | t:=t+1;
| | for i:=a[t-1]+1 to t-k+n do begin
| | | a[t]:=i;
| | | generate;
| | end;
| | t:=t-1;
| end;
end;
Замечание. Цикл for мог бы иметь верхней границей n (вместо
t-k+n). Наш вариант экономит часть работы, учитывая тот факт,
что предпоследний (k-1-ый) член не может превосходить n-1,
k-2-ой член не может превосходить n-2 и т.п.
Основная программа теперь выглядит так:
t:=1;
for j:=1 to 1-k+n do begin
| a[1]:=j;
| generate;
end;
Можно было бы добавить к массиву a слева еще и a[0]=0, положить
t=0 и ограничиться единственным вызовом процедуры generate.
7.3.4. Перечислить все представления положительного целого
числа n в виде суммы последовательности невозрастающих целых положительных
слагаемых.
Решение. Программа оперирует с массивом a[1..n] (максимальное
число слагаемых равно n) и с целой переменной t. Предполагая,
что a[1],...,a[t] - невозрастающая последовательность целых
чисел, сумма которых не превосходит n, процедура generate
печатает все представления требуемого вида, продолжающие эту
последовательность. Для экономии вычислений сумма a[1]+...+a[t]
хранится в специальной переменной s.
procedure generate;
| var i: integer;
begin
| if s = n then begin
| | печатать последовательность a[1]..a[t]
| end else begin
| | for i:=1 to min(a[t], n-s) do begin
| | | t:=t+1;
| | | a[t]:=i;
| | | s:=s+i;
| | | generate;
| | | s:=s-i;
| | | t:=t-1;
| | end;
| end;
end;
Основная программа при этом может быть такой:
t:=1;
for j:=1 to n do begin
| a[1]:=j
| s:=j;
| generate;
end;
Замечание. Можно немного сэконмить, вынеся операции увеличения
и уменьшения t из цикла, а также не возвращая s каждый раз
к исходному значению (а увеличивая его на 1 и возвращая к исходному
значению в конце). Кроме того, добавив фиктивный элемент
a[0]=n, можно упростить основную программу:
t:=0; s:=0; a[0]:=n; generate;
7.3.5. Написать рекурсивную программу обхода дерева (используя
те же команды и проверки, что и в главе про обход дерева).
Решение. Процедура обработать_над обрабатывает все листья
над текущей вершиной и заканчивает работу в той же вершине, что
и начала. Вот ее рекурсивное описание:
procedure обработать_над;
begin
| if есть_сверху then begin
| | вверх_налево;
| | обработать_над;
| | while есть_справа do begin
| | | вправо;
| | | обработать_над;
| | end;
| | вниз;
| end else begin
| | обработать;
| end;
end;
7.4. Другие применения рекурсии
Топологическая сортировка. Представим себе n чиновников,
каждый из которых выдает справки определенного вида. Мы хотим
получить все эти справки, соблюдая ограничения, установленные
чиновниками. Ограничения состоят в том, что у каждого чиновника
есть список справок, которые нужно собрать перед обращением к
нему. Дело безнадежно, если схема зависимостей имеет цикл
(справку A нельзя получить без B, B без C,..., Y без Z и Z без
A). Предполагая, что такого цикла нет, требуется составить план,
указывающий один из возможных порядков получения справок.
Изображая чиновников точками, а зависимости - стрелками,
приходим к такой формулировке. Имеется n точек, пронумерованных
от 1 до n. Из каждой точки ведет несколько (возможно, 0) стрелок
в другие точки. (Такая картинка называется ориентированным графом.)
Циклов нет. Требуется расположить вершины графа (точки) в
таком порядке, чтобы конец любой стрелки предшествовал ее началу.
Эта задача называется топологической сортировкой.
7.4.1. Доказать, что это всегда возможно.
Решение. Из условия отсутствия циклов вытекает, что есть
вершина, из которой вообще не выходит стрелок (иначе можно двигаться
по стрелкам, пока не зациклимся). Ее будем считать первой.
Выкидывая все стрелки, в нее ведущие, мы сводим задачу к
графу с меньшим числом вершин и продолжаем рассуждение по индукции.
7.4.2. Предположим, что ориентированный граф без циклов
хранится в такой форме: для каждого i от 1 до n в num[i] хранится
число выходящих из i стрелок, в adr[i][1],..., adr[i][num[i]]
- номера вершин, куда эти стрелки ведут. Составить (рекурсивный)
алгоритм, который производит топологическую сортировку не более
чем за C*(n+m) действий, где m - число ребер графа (стрелок).
Замечание. Непосредственная реализация приведенного выше
доказательства существования не дает требуемой оценки; ее приходится
немного подправить.
Решение. Наша программа будет печатать номера вершин. В
массиве printed: array[1..n] of boolean мы будем хранить сведения
о том, какие вершины напечатаны (и корректировать их одновременно
с печатью вершины). Будем говорить, что напечатанная
последовательность вершин корректна, если никакая вершина не напечатана
дважды и для любого номера i, входящего в эту последостельность,
все вершины, в которые ведут стрелки из i, напечатаны,
и притом до i.
procedure add (i: 1..n);
| {дано: напечатанное корректно;}
| {надо: напечатанное корректно и включает вершину i}
begin
| if printed [i] then begin {вершина i уже напечатана}
| | {ничего делать не надо}
| end else begin
| | {напечатанное корректно}
| | for j:=1 to num[i] do begin
| | | add(adr[i][j]);
| | end;
| | {напечатанное корректно, все вершины, в которые из
| | i ведут стрелки, уже напечатаны - так что можно
| | печатать i, не нарушая корректности}
| | if not printed[i] then begin
| | | writeln(i); printed [i]:= TRUE;
| | end;
| end;
end;
Основная программа:
for i:=1 to n do begin
| printed[i]:= FALSE;
end;
for i:=1 to n do begin
| add(i)
end;
7.4.3. В приведенной программе можно выбросить проверку,
заменив
if not printed[i] then begin
| writeln(i); printed [i]:= TRUE;
end;
на
writeln(i); printed [i]:= TRUE;
Почему? Как изменится спецификация процедуры?
Решение. Спецификацию можно выбрать такой:
дано: напеватанное корректно
надо: напечатанное корректно и включает вершину i;
все вновь напечатанные вершины доступны из i.
7.4.4. Где использован тот факт, что граф не имеет циклов?
Решение. Мы опустили доказательство конечности глубины рекурсии.
Для каждой вершины рассмотрим ее "глубину" - максимальную
длину пути по стрелкам, из нее выходящего. Условие отсутствия
циклов гарантирует, что эта величина конечна. Из вершины
нулевой глубины стрелок не выходит. Глубина конца стрелки по
крайней мере на 1 меньше, чем глубина начала. При работе процедуры
add(i) все рекурсивные вызовы add(j) относятся к вершинам
меньшей глубины.
Связная компонента графа. Неориентированный граф - набор
точек (вершин), некоторые из которых соединены линиями (ребрами).
Неориентированный граф можно считать частным случаем ориентированного
графа, в котором для каждой стрелки есть обратная.
Связной компонентой вершины i называется множество всех тех
вершин, в которые можно попасть из i, идя по ребрам графа. (Поскольку
граф неориентированный, отношение "j принадлежит связной
компоненте i" является отношением эквивалентности.)
7.4.5. Дан неориентированный граф (для каждой вершины указано
число соседей и массив номеров соседей, как в предыдущей
задаче). Составить алгоритм, который по заданному i печатает все
вершины связной компоненты i по одному разу (и только их). Число
действий не должно превосходить C*(общее число вершин и ребер в
связной компоненте).
Решение. Программа в процессе работы будет "закрашивать"
некоторые вершины графа. Незакрашенной частью графа будем называть
то, что останется, если выбросить все закрашенные вершины и
ведущие в них ребра. Процедура add(i) закрашивает связную компоненту
i в незакрашенном графе (и не делает ничего, если вершина
i уже закрашена).
procedure add (i:1..n);
begin
| if вершина i закрашена then begin
| | ничего делать не надо
| end else begin
| | закрасить i (напечатать и пометить как закрашенную)
| | для всех j, соседних с i
| | | add(j);
| | end;
| end;
end;
Докажем, что эта процедура действует правильно (в предположении,
что рекурсивные вызовы работают правильно). В самом деле, ничего,
кроме связной компоненты незакрашенного графа, она закрасить
не может. Проверим, что вся она будет закрашена. Пусть k - вершина,
доступная из вершины i по пути i-j-...-k, проходящему
только по незакрашенным вершинам. Будем рассматривать только пути,
не возвращающиеся снова в i. Из всех таких путей выберем
путь с наименьшим j (в порядке просмотра соседей в цикле в процедуре).
Тогда при рассмотрении предыдущих соседей ни одна из
вершин j-...-k не будет закрашена (иначе j не было бы минимальным)
и потому k окажется в связной компоненте незакрашенного
графа к моменту вызова add(j). Что и требовалось.
Чтобы установить конечность глубины рекурсии, заметим, что
на каждом уровне рекурсии число незакрашенных вершин уменьшается
хотя бы на 1.
Оценим число действий. Каждая вершина закрашивается не более
одного раза - при первым вызове add(i) с данным i. Все последующие
вызовы происходят при закрашивании соседей - количество
таких вызовов не больше числа соседей - и сводятся к проверке
того, что вершина i уже закрашена. Первый же вызов состоит в
просмотре всех соседей и рекурсивных вызовах add(j) для всех
них. Таким образом, общее число действий, связанных с вершиной
i, не превосходит константы, умноженной на число ее соседей. Отсюда
и вытекает требуемая оценка.
7.4.6. Решить ту же задачу для ориентированного графа (напечатать
все вершины, доступные из данной по стрелкам; граф может
содержать циклы).
Ответ. Годится по существу та же программа (строку "для
всех соседей" надо заменить на "для всех вершин, куда ведут
стрелки").
Быстрая сортировка Хоара. В заключение приведем рекурсивный
алгоритм сортировки массива, который на практике является одним
из самых быстрых. Пусть дан массив a[1]..a[n]. Рекурсивная процедура
sort (l,r:integer) сортирует участок массива с индексами
из полуинтервала (l,r] (т.е. a[l+1]..a[r]), не затрагивая остального
массива.
procedure sort (l,r: integer);
begin
| if (l = r) then begin
| | ничего делать не надо - участок пуст
| end else begin
| | выбрать случайное число s в полуинтервале (l,r]
| | b := a[s]
| | переставить элементы сортируемого участка так, чтобы
| | сначала шли элементы, меньшие b - участок (l,ll]
| | затем элементы, равные b - участок (ll,rr]
| | затем элементы, большие b - участок (rr,r]
| | sort (l,ll);
| | sort (rr,r);
| end;
end;
Перестановка элементов сортируемого участка рассматривалась в
главе о массивах (это можно сделать за время, пропорциональное
длине участка). Конечность глубины рекурсии гарантируется тем,
что длина сортируемого участка на каждом уровне рекурсии
уменьшается хотя бы на 1.
7.4.7. (Для знакомых с основами теории вероятностей). Доказать,
что математическое ожидание числа операций при работе этого
алгоритма не превосходит C*n*log n, причем константа C не зависит
от сортируемого массива.
Указание. Пусть T(n) - максимум математического ожидания
числа операций для всех входов длины n. Из текста процедуры вытекает
такое неравенство:
T(n) "= Cn + 1/n [сумма по всем k+l=(n-1) чисел T(k)+T(l)]
Первый член соответствует распределению элементов на меньшие,
равные и большие. Второй член - это среднее математическое ожидание
для всех вариантов случайного выбора. (Строго говоря, поскольку
среди элементов могут быть равные, в правой части вместо
T(k) и T(l) должны стоять максимумы T(x) по всем x, не превосходящим
k или l, но это не мешает дальнейшим рассуждениям.) Далее
индукцией по n нужно доказывать оценку T(n) "= C'nlog n. При
этом для вычисления среднего значения x log x по всем
x=1,..,n-1 нужно интегрировать x lnx по частям как lnx * d(x*x).
При достаточно большом C' член Cn в правой части перевешивается
за счет интеграла x*x*d(ln x), и индуктивный шаг проходит.
7.4.8. Имеется массив из n различных целых чисел a[1]..a[n]
и число k. Требуется найти k-ое по величине число в этом массиве,
сделав не более C*n действий, где C - некоторая константа,
не зависящая от k.
Замечание. Сортировка позволяет очевидным образом сделать
это за C*n*log(n) действий. Очевидный способ: найти наименьший
элемент, затем найти второй, затем третий,..., k-ый требует порядка
k*n действий, то есть не годится (константа при n зависит
от k).
Указание. Изящный (хотя практически и бесполезный -
константы слишком велики) способ сделать это таков:
А. Разобьем наш массив на n/5 групп, в каждой из которых по
5 элементов. Каждую группу упорядочим.
Б. Рассмотрим средние элементы всех групп и перепишем их в
массив из n/5 элементов. С помощью рекурсивного вызова найдем
средний по величине элемент этого массива.
В. Сравним этот элемент со всеми элементами исходного массива:
они разделятся на большие его и меньшие его (и один равный
ему). Подсчитав количество тех и других, мы узнаем, в какой из
этих частей должен находится искомый (k-ый) элемент и каков он
там по порядку.
Г. Применим рекурсивно наш алгоритм к выбранной части.
Пусть T(n) - максимально возможное число действий, если
этот способ применять к массивам из не более чем n элементов (k
может быть каким угодно). Имеем оценку:
T(n) "= Cn + T(n/5) + T(примерно 0.7n)
Последнее слагаемое объясняется так: при разбиении на части каждая
часть содержит не менее 0.3n элементов. В самом деле, если x
- средний из средних, то примерно половина всех средних меньше
x. А если в пятерке средний элемент меньше x, то еще два заведомо
меньше x. Тем самым по крайней мере 3/5 от половины элементов
меньше x.
Теперь по индукции можно доказать оценку T(n) "= Cn (решающую
роль при этом играет то обстоятельство, что 1/5 + 0.7 " 1).
Глава 8. Как обойтись без рекурсии.
Для универсальных языков программирования (каковым является
паскаль) рекурсия не дает ничего нового: для всякой рекурсивной
программы можно написать эквивалентную программу без рекурсии.
Мы не будем доказывать этого, а продемонстрируем некоторые приемы,
позволяющие избавиться от рекурсии в конкретных ситуациях.
Зачем это нужно? Ответ прагматика мог бы быть таким: во
многих компьютерах (в том числе, к сожалению, и в современных,
использующих так называемые RISC-процессоры), рекурсивные программы
в несколько раз медленнее соответствующих нерекурсивных
программ. Еще один возможный ответ: в некоторых языках программирования
рекурсивные программы запрещены. А главное, при удалении
рекурсии возникают изящные и поучительные конструкции.
8.1. Таблица значений (динамическое программирование)
8.1.1. Следующая рекурсивная процедура вычисляет числа сочетаний
(биномиальные коэффициенты). Написать эквивалентную нерекурсивную
программу.
function C(n,k: integer):integer;
| {n,k "=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 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. При этом надо учесть, что при i=k+1
хорда k--i - не хорда, а сторона, и ее длину надо считать равной
0 (по стороне разрез не проводится).
Составив таблицу для a(k,l) и заполняя ее в порядке возрастания
числа вершин (равного l-k+2), мы получаем программу, использующую
память порядка n*n и время порядка n*n*n (однократное
применение рекуррентной формулы требует выбора минимума из не
более чем n чисел).
8.1.4. Матрицей размера m*n называется прямоугольная таблица
из m строк и n столбцов, заполненная числами. Матрицу размера
m*n можно умножить на матрицу размера n*k (ширина левого сомножителя
должна равняться высоте правого), и получается матрица
размером m*k. Ценой такого умножения будем считать произведение
m*n*k (таково число умножений, которые нужно выполнить при стандартном
способе умножения - но сейчас это нам не важно). Умножение
матриц ассоциативно, поэтому произведение n матриц можно вычислять
в разном порядке. Для каждого порядка подсчитаем суммарную
цену всех матричных умножений. Найти минимальную цену вычисления
произведения, если известны размеры всех матриц. Число
действий должно быть ограничено многочленом от числа матриц.
Пример. Матрицы размером 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] нашего произведения хранится список всех возможных
его значений (при разной расстановке скобок).
По существу этот же прием применяется в полиномиальном алгоритме
провер
...Закладка в соц.сетях
