Программирование: теоремы и задачи (стр. 14 )

| | | Обнаружена_Ошибка := true;

| | end else begin

| | | Взять (t, s);

| | | Обнаружена ошибка := (t <> - a[i]);

| | end;

| end;

end;

Правильно := (not Обнаружена_Ошибка) and Пуст (s);

Убедимся в правильности программы. (1) Если последова-

тельность построена по правилам, то программа даст ответ "да".

Это легко доказать индукцией по построению правильной последова-

тельности. Надо проверить для пустой, для последовательности AB

в предположении, что для A и B уже проверено - и для последова-

тельностей [A] и (A) - в предположении, что для A уже проверено.

Для пустой очевидно. Для AB действия программы происходят как

для A и кончаются с пустым стеком; затем все происходит как для

B. Для [A] сначала помещается в стек открывающая квадратная

скобка и затем все идет как для A - с той разницей, что в глуби-

не стека лежит лишняя скобка. По окончании A стек становится

пустым - если не считать этой скобки - а затем и совсем пустым.

Аналогично для (A).

(2) Покажем, что если программа завершает работу с ответом

"да", то последовательность правильная. Рассуждаем индукцией по

длине последовательности. Проследим за состоянием стека в про-

цессе работы программы. Если он в некоторый промежуточный момент

пуст, то последовательность разбивается на две части, для каждой

из которых программа дает ответ "да"; остается воспользоваться

предположением индукции и определением правильности. Пусть стек

все время непуст. Это значит, что положенная в него на первом

шаге скобка будет вынута на последнем шаге. Тем самым, первый и

последний символы последовательности - это парные скобки, и пос-

ледовательность имеет вид (A) или [A], а работа программы (кроме

первого и последнего шагов) отличается от ее работы на A лишь

наличием лишней скобки на дне стека (раз ее не вынимают, она ни-

как не влияет на работу программы). Снова ссылаемся на предполо-

жение индукции и определение правильности.

6.1.2. Как упростится программа, если известно, что в пос-

ледовательности могут быть только круглые скобки?

Решение. В этом случае от стека остается лишь его длина, и

мы фактически приходим к такому утверждению: последовательность

круглых скобок правильна тогда и только тогда, когда в любом на-

чальном ее отрезке число закрывающихся скобок не превосходит

числа открывающихся, а для всей последовательности эти числа

равны.

6.1.3. Реализовать с помощью одного массива два стека, сум-

марное количество элементов в которых ограничено длиной массива;

все действия со стеками должны выполняться за время, ограничен-

ное константой, не зависящей от длины стеков.

Решение. Стеки должны расти с концов массива навстречу друг

другу: первый должен занимать места

Содержание[1] ... Содержание[Длина1],

а второй -

Содержание[n] ... Содержание[n - Длина2 + 1]

(вершины обоих стеков записаны последними).

6.1.4. Реализовать k стеков с элементами типа T, общее ко-

личество элементов в которых не превосходит n, с использованием

массивов суммарной длины C*(n+k), затрачивая на каждое действие

со стеками (кроме начальных действий, делающих все стеки пусты-

ми) время, ограниченное некоторой константой.

Решение. Применяемый метод называется "ссылочной реализаци-

ей". Он использует три массива:

Содержание: array [1..n] of T;

Следующий: array [1..n] of 0..n;

Вершина: array [1..k] of 0..n.

Массив Содержание будем изображать как n ячеек с номерами

1..n, каждая из которых содержит элемент типа T. Массив Следу-

ющий изобразим в виде стрелок, проведя стрелку из i в j, если

Следующий[i] = j. (Если Следующий[i] = 0, стрелок из i не прово-

дим.) Содержимое s-го стека (s из 1..k) хранится так: вершина

равна Содержание[Вершина[s]], остальные элементы s-го стека мож-

но найти, идя по стрелкам - до тех пор, пока они не кончатся.

При этом (s-ый стек пуст) <=> Вершина[s] = 0.

Стрелочные траектории, выходящие из Вершина[1], ..., Верши-

на[k] (из тех, которые не равны 0) не должны пересекаться. Поми-

мо них, нам понадобится еще одна стрелочная траектория, содержа-

щая все неиспользуемые в данный момент ячейки. Ее начало мы бу-

дем хранить в переменной Свободная (равенство Свободная = 0 оз-

начает, что пустого места не осталось). Вот что получается:

n=8 | a | p | q | d | s | t | v | w |

k=2 | | | Свободная

Содержание = <a, p,q, d,s, t,v, w>, Следующий = <3,0,6,0,0,2,5,4>

Вершина = <1, 7>, Свободная = 8

Стеки: 1-ый: p t q a (a-вершина); 2-ой: s v (v-вершина).

procedure Начать_работу; {Делает все стеки пустыми}

| var i: integer;

begin

| for i := 1 to k do begin

| | Вершина [i]:=0;

| end;

| for i := 1 to n-1 do begin

| | Следующий [i] := i+1;

| end;

| Свободная:=1;

end;

function Есть_место: boolean;

begin

| Есть Место := (Свободная <> 0);

end;

procedure Добавить (t: T; s: integer);

| {Добавить t к s-му стеку}

| var i: 1..n;

begin

| {Есть_место}

| i := Свободная;

| Свободная := Следующий [i];

| Вершина [s] :=i;

| Содержание [i] := t;

| Следующий [i] := Вершина [s];

end;

function Пуст (s: integer): boolean; {s-ый стек пуст}

begin

| Пуст := (Вершина [s] = 0);

end;

procedure Взять (var t: T; s: integer);

| {взять из s-го стека в t}

| var i: 1..n;

| begin

| {not Пуст (s)}

| i := Вершина [s];

| t := Содержание [i];

| Вершина [s] := Следующий [i];

| Следующий [i] := Свободная;

| Свободная := i;

end;

6.2. Очереди.

Значениями типа "очередь элементов типа T", как и для сте-

ков, являются последовательности значений типа T. Разница состо-

ит в том, что берутся элементы не с конца, а с начала (а добав-

ляются по-прежнему в конец).

Операции с очередями.

Сделать_пустой (var x: очередь элементов типа T);

Добавить (t: T, var x: очередь элементов типа T);

Взять (var t: T, var x: очередь элементов типа T);

Пуста (x: очередь элементов типа T): boolean;

Очередной (x: очередь элементов типа T): T.

При выполнении команды "Добавить" указанный элемент добав-

ляется в конец очереди. Команда "Взять" выполнима, лишь если

очередь непуста, и забирает из нее первый (положенный туда

раньше всех) элемент, помещая его в t. Значением функции "Оче-

редной" (определенной для непустой очереди) является первый эле-

мент очереди.

Английские названия стеков - Last In First Out (последним

вошел - первым вышел), а очередей - First In First Out (первым

вошел - первым вышел).

Реализация очередей в массиве.

6.2.1. Реализовать операции с очередью ограниченной длины

так, чтобы количество действий для каждой операции было ограни-

чено константой, не зависящей от длины очереди.

Решение. Будем хранить элементы очереди в соседних элемен-

тах массива. Тогда очередь будет прирастать справа и убывать

слева. Поскольку при этом она может дойти до края, свернем мас-

сив в окружность.

Введем массив Содержание: array [0..n-1] of T и переменные

Первый: 0..n-1,

Длина : 0..n.

При этом элементами очереди будут

Содержание [Первый], Содержание [Первый + 1],...,

Содержание [Первый + Длина - 1],

где сложение рассматривается по модулю n. (Предупреждение. Если

вместо этого ввести переменные Первый и Последний, принимающие

значения в вычетах по модулю n, то пустая очередь может быть

спутана с очередью из n элементов.)

Моделирование операций:

Сделать Пустой:

Длина := 0;

Первый := 0;

Добавить элемент:

{Длина < n}

Содержание [(Первый + Длина) mod n] := элемент;

Длина := Длина + 1;

Взять элемент;

{Длина > 0}

элемент := Содержание [Первый];

Первый := (Первый + 1) mod n;

Длина := Длина - 1;

Пуста = (Длина = 0);

Очередной = Содержание [Первый];

6.2.2. (Сообщил ) Придумать способ моделиро-

вания очереди с помощью двух стеков (и фиксированного числа пе-

ременных типа T). При этом отработка n операций с очередью (на-

чатых, когда очередь была пуста) должна требовать порядка n

действий.

Решение. Инвариант: стеки, составленные концами, образуют

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

менты второго наружу, мы перечисляем все элементы очереди от

первого до последнего.) Ясно, что добавление сводится к добавле-

нию к одному из стеков, а проверка пустоты - к проверке пустоты

обоих стеков. Если мы хотим взять элемент, есть два случая. Если

стек, где находится начало очереди, не пуст, то берем из него

элемент. Если он пуст, то предварительно переписываем в него все

элементы второго стека, меняя порядок (это происходит само при

перекладывании из стека в стек) и сводим дело к первому случаю.

Хотя число действий при этом и не ограничено константой, но тре-

бование задачи выполнено, так как каждый элемент очереди может

участвовать в этом процессе не более одного раза.

6.2.3. Деком называют структуру, сочетающую очередь и стек:

класть и забирать элементы можно с обоих концов. Как реализовать

дек ограниченного размера на базе массива так, чтобы каждая опе-

рация требовала ограниченного числа действий?

6.2.4. (Сообщил .) Имеется дек элементов типа

T и конечное число переменных типа T и целого типа. В начальном

состоянии в деке некоторое число элементов. Составить программу,

после исполнения которой в деке остались бы те же самые элемен-

ты, а их число было бы в одной из целых переменных.

Указание. (1) Элементы дека можно циклически переставлять,

забирая с одного конца и помещая в другой. После этого, сделав

столько же шагов в обратном направлении, можно вернуть все на

место. (2) Как понять, прошли мы полный круг или не прошли? Если

бы был какой-то элемент, заведомо отсутствующий в деке, то можно

было бы его подсунуть и ждать вторичного появления. Но таких

элементов нет. Вместо этого можно для данного n выполнить цикли-

ческий сдвиг на n дважды, подсунув разные элементы, и посмот-

реть, появятся ли разные элементы через n шагов.

Применение очередей.