Beispiel #1
0
            //реализация алгоритма обхода графа в ширину
            public void Bfs(int v)
            {
                Queue q = new Queue();                  // инициализируем очередь

                q.Add(v);                               //помещаем вершину v в очередь
                nov[v] = false;                         // помечаем вершину v как просмотренную
                while (!q.IsEmpty)                      // пока очередь не пуста
                {
                    v = Convert.ToInt32(q.Take());      //извлекаем вершину из очереди
                    Console.Write("{0} ", v);           //просматриваем ее
                    for (int u = 0; u < Size; u++)      //находим все вершины
                    {
                        if (array[v, u] != 0 && nov[u]) // смежные с данной и еще не просмотренные
                        {
                            q.Add(u);                   //помещаем их в очередь
                            nov[u] = false;             //и помечаем как просмотренные
                        }
                    }
                }
            }
Beispiel #2
0
            } //всеми парами вершин
            //восстановление пути от вершины a до вершины в для алгоритма Флойда
            public void WayFloyd(int a, int b, int[,] p, ref Queue items)
            {
                int k = p[a, b];

                //если k<> -1, то путь состоит более чем из двух вершин а и b, и проходит через
                //вершину k, поэтому
                if (k != -1)
                {
                    // рекурсивно восстанавливаем путь между вершинами а и k
                    WayFloyd(a, k, p, ref items);
                    items.Add(k); //помещаем вершину к в очередь
                                  // рекурсивно восстанавливаем путь между вершинами k и b
                    WayFloyd(k, b, p, ref items);
                }
            }
Beispiel #3
0
        public bool Floyd(int size, int index, int Jindex)
        {
            int count = 0;

            int[,] p;

            int tempVer = graph.array[index, Jindex];

            graph.array[index, Jindex] = 0;


            long[,] a = graph.Floyd(out p); //запускаем алгоритм Флойда
            int i, j;

            //анализируем полученные данные и выводим их на экран
            for (i = 0; i < graph.Size; i++)
            {
                for (j = 0; j < graph.Size; j++)
                {
                    if (i != j)
                    {
                        if (a[i, j] == int.MaxValue)
                        {
                            Console.WriteLine("Пути из вершины {0} в вершину {1} не существует", i, j);
                        }
                        else if (a[i, j] >= size)
                        {
                            Console.WriteLine("Путь из вершины {0} в вершину {1} превышает допустимое значение", i, j);
                        }
                        else
                        {
                            Console.Write("Кратчайший путь от вершины {0} до вершины {1}равен {2}, ", i, j, a[i, j]);
                            Console.Write(" путь ");
                            Queue items = new Queue();
                            items.Add(i);
                            graph.WayFloyd(i, j, p, ref items);
                            items.Add(j);
                            while (!items.IsEmpty)
                            {
                                Console.Write("{0} ", items.Take());
                            }
                            Console.WriteLine();
                            count++;
                        }
                    }
                }
            }
            graph.array[index, Jindex] = tempVer;

            if (count == graph.Size * (graph.Size - 1))
            {
                Console.WriteLine();
                Console.WriteLine(count + " " + graph.Size * (graph.Size - 1));
                return(true);
            }
            else
            {
                Console.WriteLine();
                Console.WriteLine(count + " " + graph.Size * (graph.Size - 1));
                return(false);
            }
        }