дуем такому правилу:
while змея включает не все ребра do begin
| if из головы выходит неиспользованное в змее ребро then begin
| | удлинить змею этим ребром
| end else begin
| | {хвост змеи в той же вершине, что и голова}
| | отрезать конец хвоста и добавить его к голове
| | {"змея откусывает конец хвоста"}
| end;
end;
Докажем, что мы достигнем цели.
1) Идя по змее от хвоста к голове, мы входим в каждую вер-
шину столько же раз, сколько выходим. Так как в любую вершину
входит столько же ребер, сколько выходит, то невозможность выйти
означает, что мы начали движение в этой же точке.
2) Змея не укорачивается, поэтому либо она охватывает все
ребра, либо, начиная с некоторого момента, будет иметь постоян-
ную длину. Во втором случае змея будет бесконечно "скользить по
себе". Это возможно, только если из всех вершин змеи не выходит
неиспользованных ребер. Из связности следует, что использованы
все ребра.
Замечание по реализации на паскале. Вершинами графа будем
считать числа 1..n. Для каждой вершины i будем хранить число
Out[i] выходящих из нее ребер, а также номера Num[i][1],...,
Num[i][Out[i]] тех вершин, куда эти ребра ведут. В процессе
построения змеи будет выбирать первое свободное ребро. Тогда
достаточно будет хранить для каждой вершины число выходящих из
нее использованных ребер - это будут ребра, идущие в начале
списка.
6.2.7. Доказать, что для всякого n существует последова-
тельность нулей и единиц длины (2 в степени n) со следующим
свойством: если "свернуть ее в кольцо" и рассмотреть все фраг-
менты длины n (их число равно (2 в степени n)), то мы получим
все возможные последовательности нулей и единиц длины n. Постро-
ить алгоритм отыскания такой последовательности, требующий не
более (C в степени n) действий для некоторой константы C.
Указание. Рассмотрим граф, вершинами которого являются пос-
ледовательности нулей и единиц длины (n-1). Будем считать, что
из вершины x ведет ребро в вершину y, если x может быть началом,
а y - концом некоторой последовательности длины n. Тогда из каж-
дой вершины входит и выходит два ребра. Цикл, проходящий по всем
ребрам, и даст требуемую последовательность.
6.2.8. Реализовать k очередей с ограниченной суммарной дли-
ной n, используя память порядка n+k, причем каждая операция
(кроме начальной, делающей все очереди пустыми) должна требовать
ограниченного константой числа действий.
Решение. Действуем аналогично ссылочной реализации стеков:
мы помним (для каждой очереди) первого, каждый член очереди пом-
нит следующего за ним (для последнего считается, что за ним сто-
ит фиктивный элемент с номером 0). Кроме того, мы должны для
каждой очереди знать последнего (если он есть) - иначе не
удастся добавлять. Как и для стеков, отдельно есть цепь свобод-
ных ячеек. Заметим, что для пустой очереди информация о послед-
нем элементе теряет смысл - но она и не используется при добав-
лении.
Содержание: array [1..n] of T;
Следующий: array [1..n] of 0..n;
Первый: array [1..n] of 0..n;
Последний: array [1..k] of 0..n;
Свободная : 0..n;
procedure Сделать_пустым;
| var i: integer;
begin
| for i := 1 to n-1 do begin
| | Следующий [i] := i + 1;
| end;
| Свободная := 1;
| for i := 1 to k do begin
| | Первый [i]:=0;
| end;
end;
function Есть_место : boolean;
begin
| Есть_место := Свободная <> 0;
end;
function Пуста (номер_очереди: integer): boolean;
begin
| Пуста := Первый [номер_очереди] = 0;
end;
procedure Взять (var t: T; номер_очереди: integer);
| var перв: integer;
begin
| {not Пуста (номер_очереди)}
| перв := Первый [номер_очереди];
| t := Содержание [перв]
| Первый [номер_очереди] := Следующий [перв];
| Следующий [перв] := Свободная;
| Свободная := Перв;
end;
procedure Добавить (t: T; номер_очереди: integer);
| var нов, посл: 1..n;
begin
| {Есть_свободное_место }
| нов := Свободная; Свободная := Следующий [Свободная];
| {из списка свободного места изъят номер нов}
| if Пуста (номер_очереди) then begin
| | Первый [номер_очереди] := нов;
| | Последний [номер_очереди] := нов;
| | Следующий [нов] := 0;
| | Содержание [нов] := t;
| end else begin
| | посл := Последний [номер_очереди];
| | {Следующий [посл] = 0 }
| | Следующий [посл] := нов;
| | Следующий [нов] := 0;
| | Содержание [нов] := t
| | Последний [номер_очереди] := нов;
| end;
end;
function Очередной (номер_очереди: integer): T;
begin
| Очередной := Содержание [Первый [номер_очереди]];
end;
6.2.9. Та же задача для деков вместо очередей.
Указание. Дек - структура симметричная, поэтому надо хра-
нить ссылки в обе стороны (вперед и назад). При этом удобно к
каждому деку добавить фиктивный элемент, замкнув его в кольцо, и
точно такое же кольцо образовать из свободных позиций.
В следующей задаче дек используется для хранения вершин вы-
пуклого многоугольника.
6.2.10. На плоскости задано n точек, пронумерованных слева
направо (а при равных абсциссах - снизу вверх). Составить прог-
рамму, которая строит многоугольник, являющийся их выпуклой обо-
лочкой, за не более чем C*n действий.
Решение. Будем присоединять точки к выпуклой оболочке одна
за другой. Легко показать, что последняя присоединенная точка
будет одной из вершин выпуклой оболочки. Эту вершину мы будем
называть выделенной. Очередная присоединяемая точка видна из вы-
деленной (почему?). Дополним наш многоугольник, выпустив из вы-
деленной вершины "иглу", ведущую в присоединяемую точку. Полу-
чится вырожденный многоугольник, и остается ликвидировать в нем
"впуклости".
[Рисунок]
Будем хранить вершины многоугольника в деке в порядке обхо-
да его периметра по часовой стрелке. При этом выделенная вершина
является началом и концом (головой и хвостом) дека. Присоедине-
ние "иглы" теперь состоит в добавлении присоединяемой вершины в
голову и в хвост дека. Устранение впуклостей несколько более
сложно. Назовем подхвостом и подподхвостом элементы дека, сто-
ящие за его хвостом. Устранение впуклости у хвоста делается так:
while по дороге из хвоста в подподхвост мы поворачиваем
| у подхвоста влево ("впуклость") do begin
| выкинуть подхвост из дека
end
Таким же способом устраняется впуклость у головы дека.
Замечание. Действия с подхвостом и подподхвостом не входят в
определение дека, однако сводятся к небольшому числу манипуляций
с деком (надо забрать три элемента с хвоста, сделать что надо и
вернуть).
Ещё одно замечание. Есть два вырожденных случая: если мы во-
обще не поворачиваем у похвоста (т.е. три соседние вершины лежат
на одной прямой) и если мы поворачиваем на 180 градусов (так бы-
вает, если наш многоугольник есть двуугольник). В первом случае
подхвост стоит удалить (чтобы в выпуклой оболочке не было лишних
вершин), а во втором случае - обязательно оставить.
6.3. Множества.
Пусть Т - некоторый тип. Существует много способов хранить
(конечные) множества элементов типа Т; выбор между ними опреде-
ляется типом T и набором требуемых операций.
Подмножества множества {1..n}.
6.3.1. Используя память, пропорциональную n, хранить
подмножества множества {1..n}.
Операции Число действий
Сделать пустым C*n
Проверить принадлежность C
Добавить C
Удалить С
Минимальный элемент C*n
Проверка пустоты C*n
Решение. Храним множество как array [1..n] of boolean.
6.3.2. То же, но проверка пустоты должна выполняться за
время C.
Решение. Храним дополнительно количество элементов.
6.3.3. То же при следующих ограничениях на число действий:
Операции Число действий
Сделать пустым C*n
Проверить принадлежность C
Добавить C
Удалить C*n
Минимальный элемент C
Проверка пустоты C
Решение. Дополнительно храним минимальный элемент мно-
жества.
6.3.4 То же при следующих ограничениях на число действий:
Операции Число действий
Сделать пустым С*n
Проверить принадлежность С
Добавить С*n
Удалить С
Минимальный элемент С
Проверка пустоты C
Решение. Храним минимальный, а для каждого - следующий и
предыдущий по величине.
Множества целых чисел.
В следующих задачах величина элементов множества не ограни-
чена, но их количество не превосходит n.
6.3.5. Память C*n.
Операции Число действий
Сделать пустым C
Число элементов C
Проверить принадлежность C*n
Добавить новый
(заведомо отсутствующий) C
Удалить C*n
Минимальный элемент C*n
Взять какой-то элемент C
Решение. Множество представляем с помощью переменных
a:array [1..n] of integer, k: 0..n; множество содержит k элемен-
тов a[1],...,a[k]; все они различны. По существу мы храним эле-
менты множества в стеке (без повторений).
6.3.6. Память C*n.
Операции Число действий
Сделать пустым C
Проверить пустоту C
Проверить принадлежность C*(log n)
Добавить С*n
Удалить C*n
Минимальный элемент С
Решение. См. решение предыдущей задачи с дополнительным ус-
ловием a[1] < ... < a[k]. При проверке принадлежности используем
двоичный поиск.
В следующей задаче полезно комбинировать разные способы.
6.3.7. Используя описанное в предыдущей задаче представле-
ние множеств, найти все вершины ориентированного графа, доступ-
ные из данной по ребрам. (Вершины считаем числами 1..n.) Время
не больше C * (общее число ребер, выходящих из доступных вер-
шин).
Решение. (Другое решение смотри в главе о рекурсии.) Пусть
num[i] - число ребер, выходящих из i, out[i][1], ...,
out[i][num[i]] - вершины, куда ведут ребра.
procedure Доступные (i: integer);
| {напечатать все вершины, доступные из i, включая i}
| var X: подмножество 1..n;
| P: подмножество 1..n;
| q, v, w: 1..n;
| k: integer;
begin
| ...сделать X, P пустыми;
| writeln (i);
| ...добавить i к X, P;
| {(1) P = множество напечатанных вершин; P содержит i;
| (2) напечатаны только доступные из i вершины;
| (3) X - подмножество P;
| (4) все напечатанные вершины, из которых выходит
| ребро в ненапечатанную вершину, принадлежат X}
| while X непусто do begin
| | ...взять какой-нибудь элемент X в v;
| | for k := 1 to num [v] do begin
| | | w := out [v][k];
| | | if w не принадлежит P then begin
| | | | writeln (w);
| | | | добавить w в P;
| | | | добавить w в X
| | | end;
| | end;
| end;
end;
Свойство (1) не нарушается, так как печать происходит од-
новременно с добавлением в P. Свойства (2): раз v было в X, то v
доступно, поэтому w доступно. Свойство (3) очевидно. Свойство
(4): мы удалили из X элемент v, но все вершины, куда из v идут
ребра, перед этим напечатаны.
Оценка времени работы. Заметим, что изъятые из X элементы
больше туда не добавляются, так как они в момент изъятия (и,
