Strona główna » Algorytmy » Artykuły » Algorytm Prima
 

Algorytm Prima

https://mattomatti.com/a0146

Opis

Algorytma Prima pozwala znaleźć w grafie nieskierowanym minimalne drzewo rozpinające. Każda z krawędzi musi mieć określoną wagę. To na podstawie tych wartości algorytm będzie dopasowywał je do drzewa. Punktem początkowym może być dowolny wierzchołek grafu. Innymi słowy minimalne drzewo rozpinające uzyskane na końcu zawsze będzie takie samo dla tego samego grafu.

Algorytm

Dla każdego wierzchołka określamy, że jego koszt wynosi nieskończoność, a poprzednik jest nieokreślony. Wybranemu wierzchołkowi przypisujemy wartość 0, a następnie tworzymy kolejkę wierzchołków do rozpatrzenia. W kolejce dane są posortowane po koszcie elementu. Następnie, dopóki kolejka nie jest pusta, wybieramy wierzchołek o najniższym koszcie i aktualizujemy jego sąsiadów, którzy występują w kolejce. Jeśli krawędź z wybranego wierzchołka z kolejki do sąsiada ma niższą wartość niż sąsiad ma koszt to aktualizujemy informacje.

Przykład

Rozpatrzmy następujący graf:

Przykładowy graf

Zgodnie z algorytmem najpierw utwórzmy dla każdego wierzchołka parę danych: koszt i poprzednika. Szukamy drzewa rozpoczynając od wierzchołka 0.

Kolejka012345WybranyKomentarz
0, 1, 2, 3, 4, 50 | -1∞ | -1∞ | -1∞ | -1∞ | -1∞ | -10Usuwamy 0 z kolejki i aktualizujemy sąsiadów
1, 2, 3, 4, 50 | -14 | 05 | 0∞ | -1∞ | -1∞ | -11Najmniejszy koszt wierzchołek 1
2, 3, 4, 50 | -14 | 03 | 14 | 1∞ | -1∞ | -12Najmniejszy koszt wierzchołek 2
3, 4, 50 | -14 | 03 | 12 | 26 | 21 | 25Najmniejszy koszt wierzchołek 5
3, 40 | -14 | 03 | 12 | 25 | 51 | 23Najmniejszy koszt wierzchołek 3
30 | -14 | 03 | 12 | 24 | 31 | 24Najmniejszy koszt wierzchołek 4
-0 | -14 | 03 | 12 | 24 | 31 | 2-Kolejka pusta, koniec algorytmu

Dla każdego wierzchołka zostały otrzymane dwie wartości. Pierwsza z nich określa koszt wierzchołka. Suma tej wartości dla wszystkich wierzchołków da łączną wartość minimalnego drzewa rozpinającego. W tym przypadku wynosi ona 14. Z kolei druga wartość poprzednik pozwala określić, które węzły są ze sobą połączone. W tym przypadku warto pamiętać, że graf nie jest skierowany. Na podstawie otrzymanych danych można narysować następujące minimalne drzewo rozpinające:

Minimalne drzewo rozpinające graf

Analiza złożoności

Złożoność algorytmu jest zależna od implementacji kolejki. Niemniej wewnątrz algorytmu przechodzimy po wszystkich n elementach kolejki i za każdym razem aktualizujemy n sąsiadów. Oznacza to, że sam algorytm ma złożoność O(n2). Jednak należy pamiętać, że dodatkowo w każdej pętli należy uaktualnić kolejkę priorytetową, albo przeszukiwać listę w celu znalezienia minimalnego elementu.

Implementacja

Założenia

Algorytm otrzymuje jako argumeny macierz sąsiedztwa grafu, a w wyniku zwraca parę danych: koszt i poprzednik dla każdego wierzchołka. Program nie sprawdza poprawności danych wejściowych. W celu wczytania przykładowego grafu należy podać go w następujący sposób:

  1. 0 4 5 0 0 0
  2. 4 0 3 4 0 0
  3. 5 3 0 2 6 1
  4. 0 4 2 0 4 2
  5. 0 0 6 4 0 5
  6. 0 0 1 2 5 0

Algorytm

Funkcja AlgorytmPrima() spełnia opisane wyżej założenia. W celu wyszukiwania minimalnego elementu w kolejce wykorzystuje wyszukiwanie.

  1. static dane[] AlgorytmPrima(int[,] macierz, int s) {
  2.   int n = macierz.GetLength(0);
  3.   dane[] wynik = new dane[n];
  4.   for (int i = 0; i < n; i++) {
  5.     wynik[i].koszt = int.MaxValue;
  6.     wynik[i].poprzednik = -1;
  7.   }
  8.   wynik[s].koszt = 0;
  9.   List<int> kolejka = new List<int>();
  10.   for (int i = 0; i < n; i++)
  11.     kolejka.Add(i);
  12.   while (kolejka.Count != 0) {
  13.     int u = -1;
  14.     foreach(int q in kolejka)
  15.       if (wynik[q].koszt != int.MaxValue &&
  16.       (u == -1 || wynik[q].koszt < wynik[u].koszt))
  17.         u = q;
  18.     for (int j = 0; j < n; j++) {
  19.       if (kolejka.IndexOf(j) != -1 && macierz[u, j] == 0)
  20.         continue;
  21.       if (wynik[j].koszt > macierz[u, j]) {
  22.         wynik[j].koszt = macierz[u, j];
  23.         wynik[j].poprzednik = u;
  24.       }
  25.     }
  26.     int poz = kolejka.IndexOf(u);
  27.     kolejka.RemoveAt(poz);
  28.   }
  29.   return wynik;
  30. }

(3.) Utwórz miejsce do zapisu wyniku, (3. - 6.) wypełnij domyślnymi wartościami oraz (7.) przypisz pierwszemu wierzchołkowi zerowy koszt. Następnie (8. - 10.) utwórz kolejkę i (11.) operuj na niej, aż zostanie pusta. (12. - 16.) Znajdź element w kolejce o najniższym koszcie. Potem (17.) dla każdego jego sąsiada: (18. - 19.) sprawdź czy istnieje pomiędzy nimi krawędź i czy sąsiad jest w kolejce oraz (20.) czy koszt trzeba zaktualizować. Jeśli tak to (21. - 22.) należy to wykonać. Na koniec pętli (25. - 26.) należy pamiętać o usunięciu wybranego z kolejki elementu! Na koniec zwracana jest wyznaczona tablica wynik.

Testowanie funkcji

W celu przetestowania działania napisanej funkcji można skorzystać z poniższego fragmentu kodu:

  1. static void Main(string[] args) {
  2.   Console.Write("Ile wierzchołków ma graf?\n n = ");
  3.   int n = Convert.ToInt32(Console.ReadLine());
  4.   Console.Write("Od którego wierzchołka zacząć?\n s = ");
  5.   int s = Convert.ToInt32(Console.ReadLine());
  6.   Console.Write("Podaj macierz:\n");
  7.   int[,] macierz = new int[n, n];
  8.   for (int i = 0; i < n; i++) {
  9.     string[] dane = Console.ReadLine().Split(' ');
  10.     for (int j = 0; j < n; j++)
  11.       macierz[i, j] = Convert.ToInt32(dane[j]);
  12.   }
  13.   dane[] wynik = AlgorytmPrima(macierz, s);
  14.   int suma = 0;
  15.   Console.WriteLine("ID\tPoprzednik");
  16.   for (int i = 0; i < n; i++) {
  17.     Console.WriteLine("{0}\t{1}", i, wynik[i].poprzednik);
  18.     suma += wynik[i].koszt;
  19.   }
  20.   Console.WriteLine("Łączny koszt wynosi: {0}", suma);
  21.   Console.ReadKey();
  22. }