Жанр: Учеба
Программирование в теоремах и задачах
...ючающие этот элемент. Таблица значений 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. При этом надо учесть, что при 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] нашего произведения хранится список всех возможных
его значений (при разной расстановке скобок).
По существу этот же прием применяется в полиномиальном алгоритме
проверки принадлежности слова произвольному контекстно-свободному
языку (см. главу 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].
8.2. Стек отложенных заданий.
Другой прием устранения рекурсии продемонстрируем на примере
задачи о ханойских башнях.
8.2.1. Написать нерекурсивную программу для нахождения последовательности
перемещений дисков в задаче о ханойских башнях.
Решение. Вспомним рекурсивную программу:
procedure move(i,m,n: integer);
| var s: integer;
begin
| if i = 1 then begin
| | writeln ('сделать ход', m, '-"', n);
| end else begin
| | s:=6-m-n; {s - третий стержень: сумма номеров равна 6}
| | move (i-1, m, s);
| | writeln ('сделать ход', m, '-"', n);
| | move (i-1, s, n);
| end;
end;
Видно, что задача "переложить i верхних дисков с m-го стержня на
n-ый" сводится к трем задачам того же типа: двум задачам с i-1
дисками и к одной задаче с единственным диском. Выполняя эти задачи,
важно не позабыть, что еще осталось сделать.
Для этой цели заведем стек отложенных заданий, элементами
которого будут тройки "i,m,n". Каждая такая тройка интерпретируется
как заказ "переложить i верхних дисков с m-го стержня на
n-ый". Заказы упорядочены в соответствии с требуемым порядком их
выполнения: самый срочный - вершина стека. Получам такую программу:
procedure move(i,m,n: integer);
begin
| сделать стек заказов пустым
| положить в стек тройку "i,m,n"
| {инвариант: осталось выполнить заказы в стеке}
| while стек непуст do begin
| | удалить верхний элемент, переложив его в "j,p,q"
| | if j = 1 then begin
| | | writeln ('сделать ход', p, '-"', q);
| | end else begin
| | | s:=6-p-q;
| | | {s - третий стержень: сумма номеров равна 6}
| | | положить в стек тройки "j-1,s,q", "1,p,q", "j-1,p,s"
| | end;
| end;
end;
(Заметим, что сначала в стек кладется тройка, которую надо выполнять
последней.) Стек троек может быть реализован как стри
отдельных стека. (Кроме того, в паскале есть специальный тип,
называемый "запись", который может быть применен.)
8.2.2. (Сообщил А.К.Звонкин со ссылкой на Анджея Лисовского.)
Для задачи о ханойских башнях есть и другие нерекусивные
алгоритмы. Вот один из них: простаивающим стержнем (не тем, с
которого переносят, и не тем, на который переносят) должны быть
все стержни по очереди. Другое правило: поочередно перемещать
наименьшее кольцо и не наименьшее кольцо, причем наименьшее - по
кругу.
8.2.3. Использовать замену рекурсии стеком отложенных заданий
в рекурсивной программе печати десятичной записи целого числа.
Решение. Цифры добываются с конца и закладываются в стек, а
затем печатаются в обратном порядке.
8.2.4. Написать нерекурсивную программу, печатающую все
вершины двоичного дерева.
Решение. В этом случае стек отложенных заданий будет содержать
заказы двух сортов: заказ напечатать (в свое время) данную
вершину и заказ напечатать все вершины поддерева с данным корнем
(при этом nil считается корнем пустого дерева). Таким образом,
элемент стека есть пара: "тип заказа, номер вершины".
Вынимая элемент из стека, мы либо сразу исполняем его (если
это заказ первого типа) либо помещаем в стек три порожденных им
заказа - в одном из шести возможных порядков.
8.2.5. Что изменится, если требуется не печатать вершины
двоичного дерева, а подсчитать их количество?
Решение. Печатание вершины следует заменить прибавлением
единицы к счетчику. Другими словами, инвариант таков: (общее
число вершин) = (счетчик) + (сумма чисел вершин в поддеревьях,
корни которых лежат в стеке).
8.2.6. Для некоторых из шести возможных порядков возможны
упрощения, делающие ненужным хранение в стеке элементов двух видов.
Указать некоторые из них.
Решение. Если требуемый порядок таков:
корень, левое поддерево, правое поддерево,
то заказ на печатание корня можно не закладывать в стек, а выполнять
сразу.
Несколько более сложная конструкция применима для порядка
левое поддерево, корень, правое поддерево.
В этом случае все заказы в стеке, кроме самого первого (напечатать
поддерево) делятся на пары:
напечатать вершину x, напечатать правое поддерево x
(т.е. поддерево с корнем в правом сыне x). Объединив эти пары в
заказы специального вида и введя переменную для отдельного хранения
первого заказа, мы обойдемся стеком однотипных заказов.
То же самое, разумеется, верно, если поменять местами левое
и правое - получается еще два порядка.
Замечание. Другую программу печати всех вершин дерева можно
построить на основе программы обхода дерева, разобранной в соответствующей
главе. Там используется команда "вниз". Поскольку
теперешнее представление дерева с помощью массивов l и r не позволяет
найти предка заданной вершины, придется хранить список
всех вершин на пути от корня к текущей вершине. Смотри также
главу об алгоритмах на графах.
8.2.7. Написать нерекурсивный вариант программы быстрой
сортировки. Как обойтись стеком, глубина которого ограничена
C*log n, где n - число сортируемых элементов?
Решение. В стек кладутся пары "i,j", интерпретируемые как
отложенные задания на сортировку соответствующих участков массива.
Все эти заказы не пересекаются, поэтому размер стека не может
превысить n. Чтобы ограничиться стеком логарифмической глубины,
будем придерживаться такого правила: глубже в стек помещать
больший из возникающих двух заказов. Пусть f(n) - максимальная
глубина стека, которая может встретиться при сортировке
массива из не более чем n элементов таким способом. Оценим f(n)
сверху таким способом: после разбиения массива на два участка мы
сначала сортируем более короткий (храня в стеке про запас) более
длинный, при этом глубина стека не больше f(n/2)+1, затем сортируем
более длинный, так что
f(n) "= max (f(n/2)+1, f(n-1)),
откуда очевидной индукцией получаем f(n) = O(log n).
8.3. Более сложные случаи рекурсии.
Пусть функция f с натуральными аргументами и значениями определена
рекурсивно условиями
f(0) = a,
f(x) = h(x, f(l(x))),
где a - некоторое число, а h и l - известные функции. Другими
словами, значение функции f в точке x выражается через значение
f в точке l(x). При этом предполагается, что для любого x в последовательности
x, l(x), l(l(x)),...
рано или поздно встретится 0.
Если дополнительно известно, что l(x) " x для всех x, то
вычисление f не представляет труда: вычисляем последовательно
f(0), f(1), f(2),...
8.3.1. Написать нерекурсивную программу вычисления f для
общего случая.
Решение. Для вычисления f(x) вычисляем последовательность
l(x), l(l(x)), l(l(l(x))),...
до появления нуля и запоминаем ее, а затем вычисляем значения f
в точках этой последовательности, идя справа налево.
Еще более сложный случай из следующей задачи вряд ли встретится
на практике (а если и встретися, то проще рекурсию не
устранять, а оставить). Но тем не менее: пусть функция f с натуральными
аргументами и значениями определяется соотношениями
f(0) = a,
f(x) = h(x, f(l(x)), f(r(x))),
где a - некоторое число, а l, r и h - известные функции. Предполагается,
что если взять произвольное число и начать применять к
нему функции l и r в произвольном порядке, то рано или поздно
получится 0.
8.3.2. Написать нерекурсивную программу вычисления f.
Решение. Можно было бы сначала построить дерево, у которого
в корне находится x, а в сыновьях вершины i стоят l(i) и r(i) -
если только i не равно нулю, а затем вычислять значения функции,
идя от листьев к корню. Однако есть и другой способ.
"Обратной польской записью" (или "постфиксной записью") выражения
называют запись, где знак функции стоит после всех ее
аргументов, а скобки не используются. Вот несколько примеров:
f(2) 2 f
f(g(2)) 2 g f
s(2,t(7)) 2 7 t s
s(2, u(2, s(5,3)) 2 2 5 3 s u s
Постфиксная запись выражения позволяет удобно вычислять его с
помощью "стекового калькулятора". Этот калькулятор имеет стек,
который мы будем представлять себе расположенным горизонтально
(числа вынимаются и кладутся справа). При нажатии на клавишу с
числом это число кладется в стек. При нажатии на функциональную
клавишу соответствующая функция применяется к нескольким аргументам
у вершины стека. Например, если в стеке были числа
2 3 4 5 6
и нажата функциональная клавиша s, соотвтетствующая функции от
двух аргументов, то в стеке окажутся числа
2 3 4 s(5,6)
Перейдем теперь к нашей задаче. В процессе вычисления значения
функции f мы будем работать со стеком чисел, а также с последовательностью
чисел и символов "f", "l", "r", "h", которую мы будем
интерпретировать как последовательность нажатий кнопок на
стековом калькуляторе. Инвариант такой:
если стек чисел представляет собой текущее состояние
стекового калькулятора, то после нажатия всех клавиш
последовательности в стеке останется единственное
число, и оно будет искомым ответом.
Пусть нам требуется вычислить значение, к примеру, f(100). Тогда
вначале мы помещаем в стек число 100, а последовательность содержит
единственный символ "f". (При этом инвариант соблюдается.)
Далее с последовательностью и стеком выполняются такие преобразования:
старый старая новый новая
стек последовательность стек последовательность
X x P X x P
X x l P X l(x) P
X x r P X r(x) P
X x y z h P X h(x,y,z) P
X 0 f P X a P
X x f P X x x l f x r f h P
Обозначения: x, y, z,.. - числа, X - последовательность чисел, P
- последовательность чисел и символов "f", "l", "r", "h". В последней
строке предполагается, что m не равно 0. Эта строка соответствует
равенству
f(x) = h(x, f(l(x)), f(r(x))),
Эти преобразования выполняются, пока последовательность не станет
пуста. В этот момент в стеке окажется единственное число,
которое и будет ответом.
Замечание. Последовательность по существу представляет собой
стек отложенных заданий (вершина которого находится слева).
9.1. Кратчайшие пути
В этом разделе рассматриваются различные варианты одной задач.
Пусть имеется n городов, пронумерованных числами от 1 до n.
Для каждой пары городов с номерами i, j в таблице a[i][j] хранится
целое число - цена прямого авиабилета из города i в город
j. Считается, что рейсы существуют между любыми городами, a[i,i]
= 0 при всех i, a[i][j] может отличаться от a[j,i]. Наименьшей
стоимостью проезда из i в j считается минимально возможная сумма
цен билетов для маршрутов (в том числе с пересадками), ведущих
из i в j. (Она не превосходит a[i][j], но может быть меньше.)
В предлагаемых ниже задачах требуется найти наименьшую стоимость
проезда для некоторых пар городов при тех или иных ограничениях
на массив a и на время работы алгоритма.
9.1.1. Предположим, что не существует замкнутых маршрутов,
для которых сумма цен отрицательна. Доказать, что в этом случае
маршрут с наименьшей стоимостью существует.
Решение. Маршрут длиной больше n всегда содержит цикл, поэтому
минимум можно искать среди маршрутов длиной не более n, а
их конечное число.
Во всех следующих задачах предполагается, что это условие
(отсутствие циклов с отрицательной суммой) выполнено.
9.1.2. Найти наименьшую стоимость проезда из 1-го города во
все остальные за время O(n в степени 3).
Решение. Обозначим через МинСт(1,s,к) наименьшую стоимость
проезда из 1 в s менее чем с k пересадками. Тогда выполняется
такое соотношение:
МинСт (1,s,k+1) = наименьшему из чисел МинСт(1,s,k) и
МинСт(1,i,k) + a[i][s] (i=1..n)
Как отмечалось выше, искомым ответом является МинСт(1,i,n) для
всех i=1..n.
k:= 1;
for i := 1 to n do begin x[i] := a[1][i]; end;
{инвариант: x[i] := МинСт(1,i,k)}
while k "" n do begin
| for s := 1 to n do begin
| | y[s] := x[s];
| | for i := 1 to n do begin
| | | if y[s] " x[i]+a[i][s] then begin
| | | | y[s] := x[i]+a[i][s];
| | | end;
| | end
| | {y[s] = МинСт(1,s,k+1)}
| | for i := 1 to n do begin x[s] := y[s]; end;
| end;
| k := k + 1;
end;
Приведенный алгоритм называют алгоритмом динамического программирования,
или алгоритмом Форда - Беллмана.
9.1.3. Доказать, что программа останется правильной, если
не заводить массива y, а производить изменения в самом массиве x
(заменив в программе все вхождения буквы y на x и затем удалить
ставшие лишними строки).
Решение. Инвариант будет таков:
МинСт(1,i,n) "= x[i] "= МинСт(1,i,k)
Этот алгоритм может быть улучшен в двух отношениях: можно
за то же время O(n в степени 3) найти наименьшую стоимость проезда
i-"j для ВСЕХ пар i,j (а не только с i=1), а можно сократить
время работы до O(n в степени 2). Правда, в последнем случае
нам потребуется, чтобы все цены a[i][j] были неотрицательны.
9.1.4. Найти наименьшую стоимость проезда i-"j для всех i,j
за время O(n в степени 3).
Решение. Для k = 0..n через А(i,j,k) обозначим наименьшую
стоимость маршрута из i в j, если в качестве пересадочных разрешено
использовать только пункты с номерами не больше k. Тогда
A(i,j,0) = a[i][j],
а
A(i,j,k+1) = min (A(i,j,k), A(i,k+1,k)+A(k+1,j,k))
(два варианта соответствуют неиспользованию и использованию
пункта k+1 в качестве пересадочного; отметим, что в нем незачем
бывать более одного раза).
Этот алгоритм называют алгоритмом Флойда.
9.1.5. Известны, что все цены неотрицательны. Найти наименьшую
стоимость проезда 1-"i для всех i=1..n за время O(n в
степени 2).
Решение. В процессе работы алгоритма некоторые города будут
выделенными (в начале - только город 1, в конце - все). При
этом:
для каждого выделенного города i хранится наименьшая стоимость
пути 1-"i; при этом известно, что минимум достигается на
пути, проходящем только через выделенные города;
для каждого невыделенного города i хранится наименьшая стоимость
пути 1-"i, в котором в качестве промежуточных используются
только выделенные города.
Множество выделенных городов расширяется на основании следующего
замечания: если среди всех невыделенных городов взять
тот, для которого хранимое число минимально, то это число является
истинной наименьшей стоимостью. В самом деле, пусть есть
более короткий путь. Рассмотрим первый невыделенный город на
этом пути - уже до него путь длиннее! (Здесь существенна неотрицательность
цен.)
Добавив выбранный город к выделенным, мы должны скорректировать
информацию, хранимую для невыделенных городов. При этом
достаточно учесть лишь пути, в которых новый город является последним
пунктом пересадки, а это легко сделать, так как минимальную
стоимость проезда в новый город мы уже знаем.
При самом бесхитростном способе хранения множества выделенных
городов (в булевском векторе) добавление одного города к
числу выделенных требует времени O(n).
Этот алгоритм называют алгоритмом Дейкстры.
Отыскании кратчайшего пути имеет естественную интерпретацию
в терминах матриц. Пусть A - матрица цен одной аваиакомпании, а
B - матрица цен другой. (Мы считаем, что диагональные элементы
матриц равны 0.) Пусть мы хотим лететь с одной пересадкой, причем
сначала самолетом компании A, а затем - компании B. Сколько
нам придется заплатить, чтобы попасть из города i в город j?
9.1.6. Доказать, что эта матрица вычисляется по обычной
формуле для произведения матриц, только вместо суммы надо брать
минимум, а вместо умножения - сумму.
9.1.7. Доказать, что таким образом определенное произведение
матриц ассоциативно.
9.1.8. Доказать, что задача о кратчайших путях эквивалентна
вычислению "бесконечной степени" матрицы цен A: в последовательности
A, A*A, A*A*A,... все элементы, начиная с некоторого,
равны искомой матрице стоимостей кратчайших путей. (Если нет отрицательных
циклов!)
9.1.9. Начиная с какого элемента можно гарантировать равенство
в предыдущей задаче?
Обычное (не модифицированное) умножение матриц тоже может
оказаться полезным, только матрицы должны быть другие. Пусть
есть не все рейсы (как в следующем разделе), а только некоторые,
a[i,j] равно 1, если рейс есть, и 0, если рейса нет. Возведем
матрицу a (обычным образом) в степень k и посмотрим на ее i-j-ый
элемент.
9.1.10. Чему он равен?
Ответ. Числу различных способов попасть из i в j за k
рейсов.
Случай, когда есть не все рейсы, можно свести к исходному,
введя фиктивные рейсы с бесконечно большой (или достаточно
большой) стоимостью. Тем не менее возникает такой вопрос. Число
реальных рейсов может быть существенно меньше n*n, поэтому интересны
алгоритмы, которые работают эффективно в такой ситуации.
Исходные данные естественно представлять тогда в такой форме:
для каждого города известно число выходящих из него рейсов, их
пункты назначения и цены.
9.1.11. Доказать, что алгоритм Дейкстры можно модифицировать
так, чтобы для n городов и k маршрутов он требовал не более
C*(n+k log n) операций.
Указание. Что надо сделать на каждом шаге? Выбрать невыделенный
город с минимальной стоимостью и скорректировать цены для
всех городов, в которые из него есть маршруты. Если бы кто-то
сообщал нам, для какого города стоимость минимальна, то хватило
бы C*(n+k) действий. А поддержание сведений о том, какой элемент
в массиве минимален (см. задачу 6.4.1 в главе о типах данных)
обходится еще в множитель log n.
9.2. Связные компоненты, поиск в глубину и ширину
Наиболее простой случай задачи о кратчайших путях - если
все цены равны 0 или бесконечны. Другими словами, мы интересуемся
возможностью попасть из i в j, но за ценой не постоим (и она
нас не интересует). В других терминах: мы имеем ориентированный
граф (картинку из точек, некоторые из которых соединены стрелками)
и нас интересу
...Закладка в соц.сетях
