Технологии Программирования. 9 лекция

П.1.

В качестве начальной (стартовой) вершины возьмем вершину V= 0 ( с нее начинаем обход).

(В качестве стартовой можно взять любую вершину)

После того, как мы объявили вершину V= 0 стартовой, она заносится в очередь и получает метку =0.

Создание очереди на 1-ом шаге волнового алгоритма.

П.2. Далее просматриваем нулевую строку матрицы смежности

A[0][i].

Если некоторый элементA[0][i] не равен 0, то I помещается в очередь.

В нашем случае вершины 3 и 4 будут занесены в очередь и помечены меткой 1.

После данных действий вершина V=0 будет удалена из очереди путем перемещения указателя начала очереди на один элемент вправо.

П.3.

Далее рассматриваем окружение вершин 3 и 4, т.е. поочередно

просматриваем 4-ую и 5-ую строки матрицы смежности. Если некоторый элементA[3][i] не равен 0, то i помещается в очередь.

В нашем случае вершина 2 будет занесена в очередь и получит

метку 2.

Очередь на 3-ом шаге волнового алгоритма.

После данных действий вершина V=3 будет удалена из очереди путем

перемещения указателя начала очереди на один элемент вправо

П.4.

Аналогично рассматриваем элемент элементы матрицы смежностиA[4][i].

Записать действия самостоятельно и заполнить таблицы для очереди и массива меток на 4-м шаге.

П.5.

Рассматривая окружение вершин 1 и 5, не находим ни одной непомеченной вершины, следовательно, вершины последовательно удаляются из очереди.

Очередь пуста. Поиск закончен.

Код программы int i,j,k,p,cur; int Start, N, M; int main()

{int **Graf; // объявляем матрицу смежности int *Label; // объявляем массив меток

int *FIFO; // объявляем СД очередь

//открываем файл для чтения ifstream input(“graf.txt”);

input>>N>>M>>Start; // читаем из файла

//количество вершин в графе N

//количество ребер в графе M

//Start – стартовая вершина обхода

//выделяем динамическую память для массива меток

Label= new int [N];

//выделяем динамическую память для очереди

FIFO= new int [N];

//выделяем динамическую память для матрицы // смежности

Graf= new int * [N];

for(i=0;i<N;i++) {Graf[i]= new int [N];}

/*==============================

Последовательно читаем из файла очередные две смежные вершины и помечаем в матрице, что они соединены ребром

*/

for(k=0;k<M;k++)

{input>>i>>j; // читаем номера смежных вершин Graf[i][j]=1; // матрица смежности

}

for(i=0;i<M;i++){FIFO[i]=0;Label[i]=32767;}

//==============================

После этого определяем положение указателей начала и конца очереди

p=0; // указатель на начало очереди k=1; // указатель на конец очереди

// заносим стартовую вершину обхода в очередь

FIFO[p]=Start;Label[Start]=0; // и помечаем ее меткой 0

//==============================

Все промежуточные преобразования выполнены, алгоритм будет работать до тех пор, пока очередь не станет пустой while (p!=k) {

cur=FIFO[p]; // выбираем 1-ый элемент в очереди и p++; // сдвигаем указатель p на единицу вправо

//==============================

Просматриваем строку матрицы с номером cur, то есть с номеров выбранной вершины.

Если нек-рый элемент не равен 0, и вершина, номер к-рой соответствует номеру столбца ненулевого элемента, не помечена, то заносим ее в очередь и помечаем

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

if(Graf[cur][i]==1 && Label[i]>Label[cur]+1) {FIFO[k]=i; // выделяем очередную вершину из очереди k++; // сдвигаем указатель начала на 1

Label[i]=Label[cur]+1; //помечаем вершину

}

}

// вывод результата

for(i=0;i<N;i++) cout<<Label[i]<<” ” ; getch();

return 0;

}