Комбинаторные алгоритмы.
Поиск кратчайшего пути на графе

Тип работы:
Курсовая
Предмет:
Программирование


Узнать стоимость

Детальная информация о работе

Выдержка из работы

http: ///

ФГБОУ ВПО МОСКОВСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ ЭКОНОМИКИ, СТАТИСТИКИ И ИНФОРМАТИКИ

Курсовой проект

«Комбинаторные алгоритмы. Поиск кратчайшего пути на графе. »

Дисциплина: «Структуры и алгоритмы компьютерной обработки данных «

Москва 2013

Содержание

Задача о ходе коня

Методы решения

Описание алгоритмов

Итеративная программа

Рекурсивная программа

Генерация перестановок из n элементов

Постановка задачи

Методы решения и описание алгоритмов

Построение эйлерова цикла на графе

Постановка задачи

Методы решения и описания алгоритма

Поиск кратчайшего пути на графе

Постановка задачи

Описание задачи

Программная реализация

Используемая литература

Приложение

Задача о ходе коня

Постановка задачи. Дана доска nxn. Конь, который ходит согласно шахматным правилам, помещается на поле с начальными координатами x0, y0. Нужно покрыть всю доску ходами коня, т. е. вычислить обход доски, если он существует, такой, что каждое поле посещается ровно один раз.

Методы решения

Метод Эйлера

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

Метод Вандермонда

Вандермонд попытался свести задачу к арифметической. Для этого он обозначал маршрут коня по доске в виде последовательности дробей x/y, где x и y -- координаты поля на доске. Очевидно, что в последовательности дробей, соответствующей ходам коня, разность числителей двух соседних дробей может быть только 1 или 2, при том, что разность их знаменателей составляет соответственно 2 или 1. Кроме того, числитель и знаменатель не могут быть меньше 1 и больше 8.

Его метод нахождения подходящей последовательности аналогичен методу Эйлера, но позволяет находить маршруты коня только для досок чётной размерности.

Правило Варнсдорфа

Правило Варнсдорфа, являющееся разновидностью жадного алгоритма для отыскания маршрута коня, формулируется так: При обходе доски конь следует на то поле, с которого можно пойти на минимальное число ещё не пройденных полей. Если таких полей несколько, то можно пойти на любое из них. Долгое время считалось, что правило Варнсдорфа работает безукоризненно. Позднее с помощью компьютеров была установлена неточность во второй его части: если существует несколько подходящих полей, то не все они равноценны, и произвольный выбор поля может завести коня в тупик. На практике однако вероятность попадания в тупик невелика даже при вольном пользовании второй частью правила Варнсдорфа.

Со времен Эйлера известен так называемый «раздельный ход коня»; который заключается в нахождении пути по одной половине доски, его симметричном дублировании и соединении обеих путей вместе (рис. 1).

Многие решения опираются на создание симметричного маршрута, пример одного из них на рисунке 2.

Если говорить о графиках маршрутов коня, то здесь придумано множество необычных решений, изображающих различные предметы, буквы или знаки (известен даже график, посвященный Наполеону). Два достопримечательных примера такого рода приведены ниже. График одного маршрута (он является замкнутым) напоминает собой вазу, а график другого подобен цветку, части которого расположены в высшей степени симметрично (см. рис. 3 и 4)

Описание алгоритмов

Данная задача из области «искусственного интеллекта». Здесь нужно строить алгоритмы, которые находят решение задачи не по фиксированным правилам вычисления, а методом проб и ошибок. Процесс проб и ошибок можно рассматривать в общем виде как поисковый процесс, который постепенно строит и просматривает (а так же обрезает) дерево подазадач. Во многих случаях такие деревья поиска растут очень быстро, обычно экспоненциально, в зависимости от заданного параметра. Так как мы хотим сохранять историю последовательного «захвата» доски, то мы будем представлять каждое поле доски целым числом, по которому можно судить посещалось ли поле и на каком ходу.

Итеративная программа

Полный перебор

Идея алгоритма для итеративной программы заключается в следующем:

· на каждом шаге ищется фрагмент пути, начинающийся из текущей клетки и не включающий уже пройденные;

· при совершении хода из массива возможных ходов извлекается очередной элемент, который приводит в незанятую клетку, находящуюся в пределах доски;

· если ход невозможен, то происходит возврат в предыдущую клетку (отмена хода);

· поиск пути считается успешным тогда, когда номер текущего хода станет равным количеству клеток на доске. Если из начальной клетки перебраны все возможные ходы, то пути не существует.

Ниже приведена структура функции, выполняющей перебор:

void find_path ()

{

for (move_num = 1; move_num <= max_moves;)

{

if (make_move ()) // Сделать ход.

move_num++;

else // Ход невозможен.

if (move_num > 1)

{

undo_move (); // Отменить ход.

move_num--;

}

else

return; // Обход невозможен.

}

}

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

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

Оценить сложность данного алгоритма трудно. Для некоторых клеток программа работает чрезвычайно медленно уже при небольших размерах доски. Например, для доски 6 * 6 при старте из клетки (5,2) поиск пути требует более 290 миллионов возвратов.

Рекурсивная программа

Наиболее известное решение для задачи обхода конем — рекурсивное. При этом структура функции, выполняющей перебор, имеет следующий вид:

int find_path (int cur_x, int cur_y, int move_num)

{

desk_state[cur_x][cur_y] = move_num; // Запомнить ход.

if (move_num > max_moves) return 1; // Проверить завершение обхода.

// Проверить каждый возможный ход из текущей клетки.

for (int i = 0; i < 8; i++)

{

int next_x = cur_x + possible_moves[i][0]; // Определить следующее поле.

int next_y = cur_y + possible_moves[i][1];

if ((move_possible (next_x, next_y) & & find_path (next_x, next_y, move_num+1)) return 1;

}

// Возврат.

desk_state[cur_x][cur_y] = 0;

back_ret++;

return 0;

}

Оптимизированный алгоритм

1. Определение клеток, обход из которых невозможен

Если количество клеток доски нечетно (число белых и черных клеток отличается на единицу), то обход из некоторых клеток не существует. Отметим, что путь коня проходит по клеткам, чередующимся по цвету. Если общее число клеток доски нечетно, то первая и последняя клетки пути, пройденного конем, будут одного и того же цвета. Таким образом, обход будет существовать только тогда, когда он начнется клеткой того цвета, который имеют наибольшее число клеток.

Выполнение этого условия проверяется следующей функцией:

int solution_impossible ()

{

// Если произведение сторон доски нечетно и сумма координат начальной позиции

// нечетна, то решения не существует.

return ((size_x*size_y) % 2 ≠ 0) & & ((start_x+start_y) % 2 ≠ 0);

}

Однако приведенное правило не охватывает всех клеток, для которых обхода не существует. Так, для доски размером 3*7, помимо тех клеток, для которых выполняется приведенное правило, обход невозможен также из клетки (2,4).

2. Выявление заблокированных клеток

Если при очередном ходе образуется клетка, куда можно войти, но откуда нельзя выйти, то такой ход недопустим, за исключением предпоследнего в обходе. Данный метод оптимизации позволяет значительно сократить число возвратов, в том числе и при совместном использовании с правилом Варнсдорфа.

Развитием этого метода является определение групп заблокированных клеток, связанных друг с другом, но отрезанных от остальной части доски. В рассматриваемой программе определяются группы из двух заблокированных клеток, что значительно уменьшает количество возвратов для небольших досок, а при использовании вместе с правилом Варнсдорфа — и для больших (например, размером 100*100 клеток).

3. Применение правила Варнсдорфа

Среди многих эвристических методов, используемых для сокращения перебора, правило Варнсдорфа является наиболее простым. В соответствии с ним при обходе доски коня следует каждый раз ставить на то поле, из которого он может сделать наименьшее число ходов по еще не пройденным полям. Если таких полей несколько, то можно выбрать любое из них, что может, однако, завести коня в тупик и потребовать возврата. Отметим, что наилучшим образом правило Варнсдорфа работает для угловых полей.

4. Использование различных массивов ходов коня

Ходы коня могут быть заданы, например, в виде следующего массива:

int possible_moves_sh[][2] = {

{-1, -2}, {-2, -1}, {-2, 1}, { 1, -2},

{-1, 2}, { 2, -1}, { 1, 2}, { 2, 1} };

Каждый его элемент определяет один возможный ход коня и содержит изменения его координат на доске при совершении хода.

В написанной программе используется массив ходов и правило Варнсдорфа. Программа находится в приложении.

Генерация перестановок из n элементов

Постановка задачи

Дано число n, n > 1. Получить все перестановки элементов множества {1, 2, …, n}.

Перестановка-- это упорядоченный набор чисел 1, 2, …, n, которая числу i ставит соответствие i-й элемент из набора. Число n при этом называется порядком перестановки.

Перестановка — это упорядоченный набор элементов. Это означает, что порядок элементов в наборе имеет значение. И две перестановки, состоящие из одних элементов, расположенных в разном порядке различными.

Методы решения и описание алгоритмов

Количество различных перестановок множества, состоящего из n элементов равно n! В этом нетрудно убедиться: на первом месте в перестановке может стоять любой из n элементов множества, после того, как мы на первом месте зафиксировали какой-либо элемент, на втором месте может стоять любой из n — 1 оставшегося элемента и т. д. Таким образом, общее количество вариантов равно n (n — 1)(n — 2)… 3*2*1 = n!

итеративный рекурсивный программный граф

Генерация всех перестановок по индексам

Алгоритм заключается в поиске n-факториального представления числа i и восстановлению перестановки по найденному представлению. Мы не будем рассматривать его подробно, так как время работы данного алгоритма есть O (nn!), что не является оптимальным, как в случае следующих алгоритмов.

Циклический сдвиг

Циклический сдвиг заключается в последовательном сдвиге по циклу на один разряд всех n элементов. При завершении круга, т. е. возвращении к исходной перестановке, осуществляется сдвиг первых n-1 элементов, далее, если и этот шаг возвращает нас к уже полученной перестановке, сдвигаем на один разряд первые элементов и т. д.

Алгоритм генерации перестановок в антилексикографическом порядке

Алгоритм для генерации перестановок в антилексикографическом порядке может базироваться на двух утверждениях:

1. Если множество перестановок P упорядочено антилексикографически, то начальная и конечная перестановки — это соответственно (1, 2, …, n) и (n, n-1,…, 1).

2. Упорядоченная антилексикографически последовательность перестановок по значению последнего элемента в них может быть разбита на n блоков длины (n-1)!. При этом q-й блок на последнем месте имеет элемент, равный (n-q+1), а первые n-1 позиций этого блока определяют последовательность перестановок множества {1,2,…, n}{q} в антилексикографическом порядке.

Алгоритм генерации перестановок в лексикографическом порядке:

При генерации перестановок в лексикографическом порядке, начиная с тождественной перестановки (1,2,. ,n), требуется переходить от уже построенное перестановки a=(a1,…an) к непосредственно следующей за ней перестановкой b=(b1,. bn) до тех пор, пока не получим наибольшую перестановку (n, n-1…, 1)(относительно лексикографического порядка).

Рассмотрим способ построения такой перестановки b. Просматриваем справа налево перестановку a=(a1,…an) в поисках самой правой позиции i такой, что ai< ai+1. Если такой позиции нет, то a1> a2>… >an, т. е. a=(n, n-1,…, 1) и генерировать больше нечего. Поэтому считаем, что такая позиция i есть. Значит, ai< ai+1>ai+2>…>an. Далее ищем первую позицию j при переходе от позиции n к позиции i такую, что ai< aj. Тогда i<j. Затем меняем местами элементы ai и aj, а в полученной перестановке a,=(a`1,…, a`n)отрезок a`1,…, a`n-1, a`n переворачиваем. Построенную перестановку обозначим через b. Например, пусть a=(2,6,5,8,7,4,3,1). Тогда ai=5 и aj=7. Поменяем местами эти элементы, повернем отрезок (8,5,4,3,1) и получим перестановку b=(2,6,7,1,3,4,5,8).

Сложность такого алгоритма — O (n!).

Программа, демонстрирующая генерации перестановок в лексикографическом порядке представлена в приложении.

Построение эйлерова цикла на графе

Постановка задачи

Необходимо найти эйлеров цикл на графе.

Эйлеровым циклом называется замкнутый маршрут, в котором каждое ребро графа встречается точно один раз. Для существования такого маршрута в связном графе необходимо и достаточно, чтобы степени всех вершин были четными.

Методы решения и описания алгоритма

Алгоритм Флери

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

*все рёбра, по которым мы проходим, стираются, так же как и появившиеся в результате изолированные вершины;

*на каждом шаге идём по мосту только тогда, когда нет других возможностей (мост -- это такое ребро графа, при стирании которого граф становится несвязным).

Другой алгоритм похож на алгоритм поиска в глубину: начиная с произвольно выбранной стартовой вершины a, строим путь, выбирая каждый раз для дальнейшего продвижения еще не пройденное ребро. Главное отличие от поиска в глубину состоит в том, что как пройденные помечаются именно ребра, а не вершины. Поэтому одна и та же вершина может посещаться несколько раз, но каждое ребро проходится не более одного раза, так что в полученном маршруте ребра не будут повторяться. Вершины пути накапливаются в стеке S. Через некоторое количество шагов неизбежно наступит тупик — все ребра, инцидентные активной (последней посещенной) вершине x, уже пройдены. Так как степени всех вершин графа четны, в этот момент x=a и пройденные ребра образуют цикл, но он может включать не все ребра графа. Для обнаружения еще не пройденных ребер возвращаемся по пройденному пути, перекладывая вершины из стека S в другой стек C, пока не встретим вершину x, которой инцидентно непройденное ребро. Так как граф связен, такая вершина обязательно встретится. Тогда возобновляем движение вперед по не пройденным ребрам, пока не дойдем до нового тупика и т. д. Процесс заканчивается, когда в очередном тупике обнаруживается, что S пуст. В этот момент в стеке C находится последовательность вершин эйлерова цикла.

Алгоритм построения эйлерова цикла:

1. выбрать произвольно вершину a

2. aS

3. while S=! 0 do

4. x=top (S)

5. if имеется непройденное ребро (x, y)

6. then пометить ребро (x, y) как пройденное

7. yS

8. else переместить вершину x из S в C

Программа представлена в приложении.

Поиск кратчайшего пути на графе

Кратчайший путь рассматривается при помощи математического объекта, называемого графом.

Существуют три наиболее эффективных алгоритма нахождения кратчайшего пути:

1) Алгоритм Дейкстры;

2) Алгоритм Флойда -- Уоршелла;

3) Алгоритм Беллмана -- Форда.

Принцип работы некоторых из указанных алгоритмов будет рассмотрен в рамках данной работы.

Постановка задачи

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

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

Описание задачи

Алгоритм Дейкстры

Данный алгоритм был изобретён нидерландским ученым Э. Дейкстрой в 1959 году.

Каждой вершине сопоставим метку -- минимальное известное расстояние от этой вершины до начальной, с которой мы начинаем поиск кратчайшего пути. Алгоритм работает пошагово -- на каждом шаге он посещает одну вершину и пытается уменьшать метки. Работа алгоритма завершается, когда все вершины посещены.

Инициализация. Метка начальной вершины полагается равной 0, метки остальных вершин -- бесконечности. Это отражает то, что расстояния от начальной до других вершин пока неизвестны. Все вершины графа помечаются как непосещённые.

Шаг алгоритма. Если все вершины посещены, алгоритм завершается. В противном случае, из ещё не посещённых вершин выбирается вершина, имеющая минимальную метку. Обозначим её за U. Мы рассматриваем всевозможные маршруты, в которых U является предпоследним пунктом. Вершины, в которые ведут рёбра из U, назовем соседями этой вершины. Для каждого соседа вершины U, кроме отмеченных как посещённые, рассмотрим новую длину пути, равную сумме значений текущей метки U и длины ребра, соединяющего U с этим соседом. Если полученное значение длины меньше значения метки соседа, заменим значение метки полученным значением длины. Рассмотрев всех соседей, пометим вершину U как посещенную и повторим шаг алгоритма.

Сложность алгоритма в простейшем случае, когда для поиска вершины с минимальным d[v] просматривается все множество вершин, время работы алгоритма есть

Алгоритм Флойда -- Уоршелла

Предложен независимо Ричардом Беллманом и Лестером Фордом.

За время O (|V|? |E|) алгоритм находит кратчайшие пути от одной вершины графа до всех остальных. В отличие от алгоритма Дейкстры, алгоритм Беллмана-Форда допускает рёбра с отрицательным весом.

Программная реализация

В рамках данной работы мною реализован алгоритм Дейкстры. Проведем машинный эксперимент. Запустим программу, после чего введем количество вершин. Далее, поочередно будем вводить длину пути или «цену» между указанными вершинами. Если вершины не соединены между собой напрямую, то необходимо ввести ноль. После окончания ввода программа построит матрицу смежности и предложит ввести начальную и конечную координату.

Далее, введем начальную и конечную вершины, после чего программа найдет кратчайший путь и выведет его на экран. Результат получен.

Используемая литература

* Алгоритмы+структуры данных=программы. Вирт Н. — М.: Мир, 1989.

* ru. wikipedia. org

* Комбинаторные алгоритмы: Учебное пособие. Т. И. Федоряева, Новосиб. гос. ун-т. Новосибирск, 2011

* Комбинаторика для программистов / Липский В. — М.: Мир, 1988.

* http: //www. dokwork. ru/2012/03/blog-post. html

* http: //www. intuit. ru

* http: //www. softcraft. ru/auto/switch/knight/knight. shtml — Задача о ходе коня. Анатолий Шалыто, Никита Туккель, Никита Шамгунов. Статья опубликована в журнале «Мир ПК», 2003. № 1. C. 152−155.

ПРИЛОЖЕНИЯ

Приложение 1. Задача о ходе коня

#include «stdafx. h»

#include < stdio. h>

#include < stdlib. h>

#include < time. h>

void move (int board[][8], int vertical[], int horizontal[], int & currentRow, int & currentColumn, int Numb, int cnt);

void vozmojnost (int accessibility[][8], int horizontal[], int vertical[], int crRow, int crColumn);

int fhod (int board[][8], int accessibility[][8], int vertical[], int horizontal[], int crRow, int crColumn);

int main ()

{

int kolvohodov=0;

int board[][8] = {{0},{0},{0},{0},{0},{0},{0},{0}}; //Массив Ходов (по-умолчанию — Нулевой)

int horizontal[] = {2, 1, -1, -2, -2, -1, 1, 2}; //Массив возможных Ходов. Горизонталь

int vertical[] = {-1, -2, -2, -1, 1, 2, 2, 1}; //Массив возможных ходов. Вертикаль

int accessibility[][8] = {{2,3,4,4,4,4,3,2},

{3,4,6,6,6,6,4,3},

{4,6,8,8,8,8,6,4},

{4,6,8,8,8,8,6,4},

{4,6,8,8,8,8,6,4}, //Массив с количествами возможных попаданий в каждую клетку.

{4,6,8,8,8,8,6,4},

{3,4,6,6,6,6,4,3},

{2,3,4,4,4,4,3,2}};

srand (unsigned (time (NULL))); //Входим в таблицу случайных ходов в случайном месте (RANDOMIZE TIMER)

for (int i = 0; i < 8; i++){

for (int j = 0; j < 8; j++)

printf («%i «, board[i][j]); //(Для консоли) Выводим пустую таблицу на экран

printf («n»);

}

printf («n»);

int Go = 1;

int currentRow = rand ()%7; //Случайным образом выбираем клетку входа

int currentColumn =rand ()%7;

if (Go)

{

vozmojnost (accessibility, horizontal, vertical, currentRow, currentColumn); //Изменяем возможности клеток на -=1

board[currentRow][currentColumn] = 1; //Говорим, что в текущей клетке мы уже были

int MoveNumber;

int count = 1;

int exit = 1;

/* Ищем клетку, которая не выходит за границу массива, в которой еще не было коня, с минимальным количеством возможностей */

do

{

MoveNumber = fhod (board, accessibility, vertical, horizontal, currentRow, currentColumn);

if (MoveNumber ≠-1)

{

count++;

move (board, vertical, horizontal, currentRow, currentColumn, MoveNumber, count);

vozmojnost (accessibility, vertical, horizontal, currentRow, currentColumn);

for (int i = 0; i < 8; i++){

for (int j = 0; j < 8; j++)

printf («%i «, board[i][j]);

printf («n»);

}

printf («n»);

}

else exit = 0;

}

while (exit);

/* Конец поиска клетки */

}

}

void move (int board[][8], int vertical[], int horizontal[], int & currentRow, int & currentColumn, int Numb, int cnt)

{

//изменяем текущие координаты

currentRow += vertical[Numb];

currentColumn += horizontal[Numb];

//запоминаем, что на этой клетке мы уже были

board[currentRow][currentColumn] = 1;

}void vozmojnost (int accessibility[][8], int horizontal[], int vertical[], int crRow, int crColumn)

{

int Hmove, Vmove; //координаты клеток, лежащих в одном ходу от текущей

//перебираем все возможные варианты ходов и уменьшаем на 1 значения

//соответствующих элементов массива accessibility

for (int i=0; i< 8; i++)

{

Hmove = crRow + vertical[i];

Vmove = crColumn + horizontal[i];

//проверка выхода за границу массива

if ((Hmove< 8)&&(Hmove>=0)&&(Vmove<8)&&(Vmove>=0))

accessibility[Hmove][Vmove] -= 1;

}

}

int fhod (int board[][8], int accessibility[][8], int vertical[], int horizontal[], int crRow, int crColumn)

{

int PossibleMoves[8] = {-1,-1,-1,-1,-1,-1,-1,-1};

int tRow, tColumn;

for (int i=0; i< 8; i++)

{

tRow = crRow + vertical[i];

tColumn = crColumn + horizontal[i];

if (tRow<8 & & tRow> =0 & & tColumn<8 & &tColumn>=0 & & board[tRow][tColumn]==0)

PossibleMoves[i] = accessibility[tRow][tColumn];

}

int count = 0;

int min = 8;

int Pos = 0;

for (int j=0; j< 8; j++)

if (PossibleMoves[j]≠-1 & & PossibleMoves[j]< =min)

{

min = PossibleMoves[j];

count++;

Pos = j;

}

if (count==0) return -1;

if (count==1) return Pos;

int Ind = rand ()%count;

for (int k=0; k< 8; k++)

if (PossibleMoves[k]==min & & Ind==0)

{

Pos = k;

break;

}

else Ind--;

return Pos; }

Приложение 2. Генерация перестановок из n элементов

Программа

#include «stdafx. h»

#include < iostream>

using namespace std;

int X[100];

int N;

void Swap (int a, int b)

{

int t=X[a];

X[a]=X[b];

X[b]=t;

}

void Generate (int k)

{

if (k==N)

{

for (int i=0; i<N;i++)

cout< <X[i]<<" «;

cout< <"n";

}

else

{

for (int j=k; j<N;j++)

{

Swap (k, j);

Generate (k+1);

Swap (k, j);

}

}

}

int _tmain (int argc, _TCHAR* argv[])

{

cout< <"N=";

cin> >N;

for (int i=0; i<N;i++)

X[i]=i+1;

Generate (0);

cout< <"Press any button";

cin. get ();

return 0;

}

Приложение 3. Построение эйлерова цикла на графе

#include «stdafx. h»

#include < stack>

#include < iostream>

using namespace std;

int main ()

{

stack< int> stackArray;

const int N=3;

cout< <"Enter the adjacency matrix for 3 elements"< <'n';

int vertexArray[N]; // массив вершин

bool adjacencyArray[N][N]; // матрица смежности

for (int i=0; i< N; i++)

{

int k=0;

for (int j=0; j< N; j++)

{

cin> >adjacencyArray[i][j];

if (adjacencyArray[i][j]≠0) k++;

}

vertexArray[i]=k;

}

for (int i=0; i< N; i++)

if (vertexArray[i]%2≠0)

{

cout< <"There is no Euler tour. «; // Если кол-во единиц нечетно — пути Эйлера нет

return 0;

}

cout< <"The Euler tour is: «<<'n'; // Если четно — путь есть, выводим на экран сам путь

stackArray. push (0); // Принцип работы стека — последний зашел — первый вышел

while (!stackArray. empty ())

{

int topOfStack=stackArray. top ();

if (vertexArray[topOfStack]==0)

{

stackArray. pop ();

cout< <topOfStack+1<<" «; // Выводим на экран

}

else

{

int i=0; while (adjacencyArray[topOfStack][i]==0) i++;

stackArray. push (i);

adjacencyArray[topOfStack][i]=adjacencyArray[i][topOfStack]=0;

vertexArray[topOfStack]--; vertexArray[i]--;

}

}

int ab;

std: :cin > > ab;

return 0;

}

Приложение 4. Поиск кратчайшего пути на графе. Алгоритм Дейкстры

Исходный код программы на языке программирования C++

#include «StdAfx. h»

#include < iostream>

using namespace std;

int i, j, n, num, start_pos, end_pos;

int infinity = 99 999;

int visit[15];

int matrix[15][15];

int lenght[15];

char s[100];

char path[100][15];

void _tmain ()

{

setlocale (LC_ALL,"Russian");

cout< <"Введите количество вершин: «;

cin> >n;

cout< <"n";

for (i=0; i<n;i++)

for (j=0; j<n;j++) matrix[i][j]=0;

for (i=0; i<n;i++)

for (j=i+1; j<n;j++)

{

cout< <"Расстояние от «< <i+1<<» до «< <j+1<<»: «;

cin> >matrix[i][j];

}

cout< <"nn «;

for (i=0; i<n;i++) cout< <" X"< <i+1;

cout< <endl<<endl;

cout< <"n";

for (i=0; i<n;i++)

{

printf («X%d», i+1);

for (j=0; j<n;j++)

{

printf («%6d», matrix[i][j]);

matrix[j][i]=matrix[i][j];

}

printf («nn»);

}

for (i=0; i<n;i++)

for (j=0; j<n;j++)

if (matrix[i][j]==0) matrix[i][j]=infinity;

cout< <"n";

for (; ;)

{

cout< <"Введите начальную вершину: «;

cin> >start_pos;

if (start_pos<1 || start_pos> n)

{

cin. clear ();

fflush (stdin);

cout< <"Некорректный ввод. Введите номер вершины в интервале от 1 до «< <n<<"n»;

}

else break;

}

start_pos--;

for (; ;)

{

cout< <"Введите конечную вершину: «;

cin> >end_pos;

if (end_pos<1 || end_pos> n)

{

cin. clear ();

fflush (stdin);

cout< <"Некорректный ввод. Введите номер вершины в интервале от 1 до «< <n<<"n»;

}

else break;

}

end_pos--;

cout < <"n";

if (start_pos==end_pos)

{

cout< <"Начальная и конечная точка совпадаютn"< <endl;

return;

}

for (i=0; i<n;i++)

{

visit[i]=0;

lenght[i]=infinity;

}

lenght[start_pos]=0;

visit[start_pos]=1;

num=start_pos;

itoa (start_pos+1,s, 10);

for (i=1; i<=n;i++)

{

strcpy (path[i],"X");

strcat (path[i], s);

}

do

{

for (i=0; i<n;i++)

if ((matrix[num][i]≠infinity)& &(!visit[i])&&(i≠num))

{

if (lenght[i]> lenght[num]+matrix[num][i])

{

itoa (i+1,s, 10);

strcpy (path[i+1], path[num+1]);

strcat (path[i+1],"-X");

strcat (path[i+1], s);

}

if (lenght[i]> lenght[num]+matrix[num][i]) {

lenght[i] = lenght[num]+matrix[num][i];

}

}

for (i=0; i<n;i++)

if (!(visit[i])) num=i;

for (i=0; i<n;i++)

if ((lenght[num]> lenght[i])&&(!visit[i])) num=i;

visit[num]=1;

}

while (num≠end_pos);

if (lenght[num]≠infinity)

{

cout< <"Путь: «< <path[num+1]<<endl;

cout< <"Длина пути: «< <lenght[num]<<endl<<endl;

}

else

cout< <"Такого пути не существует"< <endl<<endl;

}

ПоказатьСвернуть
Заполнить форму текущей работой