Forum Pasja Informatyki - Najnowsze z tagiem dijkstra

Ścieżka o największym koszcie w grafie ważonym

Mon, 06 Mar 2023 09:28:29 +0000

Mam wydaje mi się, że ciekawy problem. Dużo uczy się algorytmów do najkrótszych / o najmniejszym koszcie scieżek, np BFS czy Dijkstra. Ale ostatnio zainteresowałem się najdłuższymi scieżkami, problem, gdzie krawędzie mają wagi jeden, i trzeba znaleźć najdłuższą scieżkę w takim grafie, już sobie z nim poradziłem: dzielę graf na SCC, wrzucam na kolejkę, z których nie wychodzą już żadne, mam licznik ile wychodzi krawędzi z każdego wierzchołka, i jak przetwarzam wierzchołek to idę po wszystkich krawędziech, którego do niego idą, i odejmuję jeden. I tak w kółko jak nic nie wychodzi to wrzucam na kolejkę, aktualizuje ile wchodzi..... - dynamik. Chodzi mi o to co jest w tym zadaniu: https://atcoder.jp/contests/dp/tasks/dp_g , tylko w tym zadaniu nie trzeba dzielić na SCC, bo nie ma cykli.

Zastanawiam się jak znaleźć ścieżkę o największym koszcie, intuicyjne wydaje się, żeby zrobić Dijkstrę, tylko zamiast od najmniejszych iść do największych, tylko nie wiem czy to jest dobre. Bo teorytycznie wydaje mi się, że na podobnej zasadzie jak w algorytmie Dijkstry, będziemy mieć pewność, że jest to ścieżka o największym koszcie. Więc mam pytania:

1- czy to jest dobre

2 - Czy da się to zrobić w złożonności szybszej niż Dijkstra?

Z góry dziękuję za pomoc i poświęcony czas!

edit: oczywiście zakładam, że po każdej krawędzi można przejść maksymalnie raz, bo tak to byśmy sobie w kółko chodzili i zrobili koszt nieskończoność.

3 - czy algorytmy najdłuższch / o największym koszcie pojawiają się w zadaniach?, bo ja np. jeszcze nigdy się z czymś takim nie spotkałem, oprócz tego z Atcodera.

Jaką ten algorytm ma złożonność?, Zadanie Zawody 1 etap OI, Algorytm Dijkstry

Sun, 12 Feb 2023 15:29:36 +0000

Natknąłem się na zadanie Zawody z 1 etapu XI OI: https://szkopul.edu.pl/problemset/problem/UiDG8sd_wsS2RfUPL3zQQ1XW/site/?key=statement

Napisałem algorytm, który wydaje mi się, że działa w O(N^2 * lg(N) ), odpalam Dijkstrę z każdego wierzchołka x, do którego wychodzi krawędź z wierzchołka 1 -> x (wierzchołek 1 to wejściowy). Kod wchodził na 70pkt, ale po dodaniu linii 57 i 58(żeby nie iśc niepotrzebnie tą Dijkstrą, jak wynik i tak będzie większy) daje 100pkt z bardzo dużym zapasem. Myślałem, że to poprostu przyśpieszy, ale myślałem, że nie wejdzie na 100, bo dalej jest O(N^2 * lg(N)). Więc zastanawiam się, czy złożonność się amortyzuje do lepszej złożonności, czy poprostu dlatego, że jest tylko 10 testów właściwych + 5 przykładowych(W wszystkich się szybko kończy)? W ksiażce "Przygody Bajtazara 25 lat Olimpiady Informatycznej" jest opisane rozwiązanie O((N+M) * lg(N)), którego jeszcze nie rozumiem, ale tez używają tam Dijkstry. Poglądowy rysunek mojego rozwiązania, jakbym źle opisał. Na czerwono zaznaczone wierzchołki, z których puszczam Dijkstrę(osobno), na zielono jakieś przykładowe wierzchołki z krawędziami(gdzie zwroty to wierzchołki), a wierzchołek "wejsciowy", ma numer 1.

Kod:

#include <iostream>
#include <vector>
#include <set>

using namespace std;

struct Krawedz
{
    int do_kogo;
    int waga;
};

struct Element_seta
{
    int wierzcholek;
    int wartosc;
    bool operator < (const Element_seta &element_seta) const
    {
        if (wartosc == element_seta.wartosc)
            return wierzcholek < element_seta.wierzcholek;
        return wartosc < element_seta.wartosc;
    }
};

int n = 0, m = 0, a = 0, b = 0, c = 0, d = 0, wyn = 0, min_wyn = 1e9+20;
vector<vector<Krawedz>> krawedzie;
vector<int> dp;
set<Element_seta> S;

int main()
{
    // O(N^2 * lg(N))???
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    cin >> n >> m;
    krawedzie.assign(n+1,{});
    dp.assign(n+1,-1);
    for (int i = 0; i < m; ++i)
    {
        cin >> a >> b >> c >> d;
        krawedzie[a].push_back({b,c});
        krawedzie[b].push_back({a,d});
    }

    for (int i = 0; i < krawedzie[1].size(); ++i)
    {
        fill(dp.begin(),dp.end(),-1);
        S.clear();
        dp[krawedzie[1][i].do_kogo] = krawedzie[1][i].waga;
        S.insert({krawedzie[1][i].do_kogo,krawedzie[1][i].waga});
        wyn = -1;
        while(!S.empty())
        {
            Element_seta spr = *S.begin();
            if (spr.wartosc > min_wyn)
                break;
            S.erase(spr);
            if (spr.wierzcholek == 1)
            {
                wyn = spr.wartosc;
                break;
            }
            for (int j = 0; j < krawedzie[spr.wierzcholek].size(); ++j)
            {
                int v = krawedzie[spr.wierzcholek][j].do_kogo;
                if (v == 1 && spr.wierzcholek == krawedzie[1][i].do_kogo)
                    continue;
                if (dp[v] == -1 || spr.wartosc + krawedzie[spr.wierzcholek][j].waga < dp[v])
                {
                    auto it = S.find({v,dp[v]});
                    if (it != S.end())
                        S.erase(*it);
                    dp[v] = spr.wartosc + krawedzie[spr.wierzcholek][j].waga;
                    S.insert({v,spr.wartosc + krawedzie[spr.wierzcholek][j].waga});
                }
            }
        }
        if (wyn != -1)
            min_wyn = min(min_wyn,wyn);
    }

    cout << min_wyn << '\n';

    return 0;
}

Z góry dziękuję za pomoc i poświęcony czas!

Modyfikacja algorytmu Dijkstry

Mon, 16 Jan 2023 21:28:12 +0000

Siemka ponownie, tym razem mam kłopot z zadaniem Przemytnicy z X OI, I etap. Od razu zauważyłem, że w tym zadaniu trzeba wykorzystać algorytm Dijkstry. Oto moje spostrzeżenia nt. tego zadania:

Zauważyłem, że można oprócz tablicy dis[x], (która przechowuje min. odległość od wierzchołka 1. do x) zrobić tablicę disTo1[x], która przechowywać będzie min. odległość z wierzchołka x do 1 (o ile istnieje).

Tutaj załączam tabelkę, która zwizualizuje wam ten problem i zadanie stanie się proste do zrozumienia: link. Suma sum jest równa sumie dis[x], disTo1[x] oraz połowy val[x], gdyż cło wynosi połowę przewożonego ładunku.

Jedyny problem dla mnie to jakiś wydajny sposób na stworzenie tablicy disTo1[x]. Ma ktoś pomysł i zechciałby się nim podzielić? I jak to zrobić tak, aby nie lecieć n (gdzie n to liczba wierzchołków) razy algorytmem Dijkstry?

Jak do tej pory napisałem tyle:

[on-line]

#include <bits/stdc++.h>

#define x first
#define y second

using namespace std;

vector <pair <int, int>> v[5001];
priority_queue <pair <int, int>> q;
int dis[5001], disTo1[5001], val[5001], sum[5001];
bool vis[5001];
const int INF = 1e9 + 1;
int n;

void dij(int w) {
    for (int i = 2; i <= n; i ++)
        dis[i] = INF;
    dis[1] = 0;

    q.push({0, w});
    while (!q.empty()) {
        w = q.top().y;
        q.pop();

        if (vis[w])
            continue;
        vis[w] = 1;

        for (auto a : v[w]) {
            dis[a.x] = min(dis[a.x], dis[w] + a.y);
            if (!vis[a.x])
                q.push({-dis[a.x], a.x});
        }
    }
}

int main() {
    cin >> n;
    for (int i = 1; i <= n; i ++)
        cin >> val[i];

    int k;
    cin >> k;
    while (k --) {
        int a, b, c;
        cin >> a >> b >> c;
        v[a].push_back({b, c});
    }

    dij(1);

    /* for (int i = 1; i <= n; i ++)
        cout << i << ' ' << dis[i] << '\n'; */
}

Zadanie Bitocja - Algorytm Dijkstry.

Fri, 17 Jun 2022 21:55:58 +0000

Cześć,

Ostatnio natknąłem się na zadanie z 3 etapu 1 edycji OIG - https://szkopul.edu.pl/problemset/problem/HP0-iQt7v7vElza8XxoucKto/site/?key=statement

Wydaje mi się, że mam dobry pomysł a mianowicie: Robię algorytm Dijkstry najpierw dla danych krawędzi które mamy i ustalam min wynik, potem dodaję cały czas kolejną krawędź i sprawdzam znowu algorytmem Dijkstry czy wynik się nie poprawił jak tak to wypisuję 1 w przeciwnym razie 0.

Dostaję jednak tylko 20 pkt (19 testów łącznie - 7 dobrze,5 zle odpowiedzi, 7 przekroczono limit czasu). Pewnie dlatego, że mam jakiś błąd w algorytmie Dijkstry. (Pierwszy raz piszę ten algorytm) Nie mogę znaleźć błędu. Wyczytałem w internecie, że najszybsza wersja tego algorytmu to na kolejce priorytetowej, więc set też powinien być ok. Jak ktoś by znajdzie błąd to jestem bardzo wdzięczny. Kod:

#include <iostream>
#include <vector>
#include <set>

using namespace std;

struct Wierzcholek
{
    long long cena;
    long long numer_wierzcholka;

    bool operator < (const Wierzcholek&wierzcholek) const
    {
        if (cena != wierzcholek.cena)
        {
            return cena < wierzcholek.cena;
        }
        return numer_wierzcholka > wierzcholek.numer_wierzcholka;
    }

    bool operator == (const Wierzcholek&wierzcholek) const
    {
        return numer_wierzcholka == wierzcholek.numer_wierzcholka;
    }
};

struct Krawedz
{
    long long cena;
    long long do_kod;
};

vector<vector<Krawedz>> krawedzie;

long long dijkstra(int n)
{
    set <Wierzcholek> Q;
    vector<bool> czy_odwiedzony;
    for (int i = 0 ; i <= n; ++i)
    {
        czy_odwiedzony.push_back(false);
    }
    Q.insert({0,1});
    while (!Q.empty())
    {
        Wierzcholek sprawdzany;
        for (auto c : Q)
        {
            sprawdzany = c;
            break;
        }

        if (sprawdzany.numer_wierzcholka == n)
        {
            return sprawdzany.cena;
        }
        czy_odwiedzony[sprawdzany.numer_wierzcholka] = true;

        for (int i = 0; i < krawedzie[sprawdzany.numer_wierzcholka].size(); ++i)
        {
            if (czy_odwiedzony[krawedzie[sprawdzany.numer_wierzcholka][i].do_kod] == false)
            {
                Q.insert({sprawdzany.cena + krawedzie[sprawdzany.numer_wierzcholka][i].cena,krawedzie[sprawdzany.numer_wierzcholka][i].do_kod});
            }
        }
        Q.erase(sprawdzany);
    }
}

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int n = 0, k = 0, m = 0, a = 0, b = 0, wczytany_koszt = 0, min_wynik = 0, wynik = 0;

    cin >> n >> k >> m;

    for (int i = 0 ; i <= n; ++i)
    {
        krawedzie.push_back({});
    }

    for (int i = 0; i < k; ++i)
    {
        cin >> a >> b >> wczytany_koszt;
        krawedzie[a].push_back({wczytany_koszt,b});
        krawedzie[b].push_back({wczytany_koszt,a});
    }

    min_wynik = dijkstra(n);

    for (int i = 0; i < m; ++i)
    {
        cin >> a >> b >> wczytany_koszt;
        krawedzie[a].push_back({wczytany_koszt,b});
        krawedzie[b].push_back({wczytany_koszt,a});

        wynik = dijkstra(n);

        if (wynik < min_wynik)
        {
            cout << "1 \n";
            min_wynik = wynik;
        }
        else
        {
            cout << "0 \n";
        }
    }


    return 0;
}

Czy wogóle poprawnie piszę ten algorytm ? W sensie żeby była najszybsza wersja.

Z góry bardzo dziękuję za pomoc!

Algorytm Dijkstry

Thu, 07 Jan 2021 16:10:09 +0000

W jaki sposób zmodyfikować poniższy kod aby prawidłowo czytał z wektora i obliczał drogę metodą D

#include <iostream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <fstream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <utility>

//#include "def.cpp"
//#include "funkcje.h"

using namespace std;
struct Node {
    string city;
    vector<pair<unsigned, unsigned>> connections;
};

int findOrAddCity(vector<Node>& g, const string& name)
{
    for (int i = 0; i < g.size(); i++)
        if (g[i].city == name) return i;

    g.push_back({ name, {} });
    return g.size() - 1;
}
int wczytaj_arg(int argc, char* argv[])
{

    int pozI = 0;
    int pozC = 0;
    string nPlikuI = "";
    string nPlikuC = "";
    string plik, centrala;
    if (argc == 5)
    {
        for (int i = 0; i < argc; i++) {
            if ((string(argv[i]) == "-i") and i < argc - 1) {
                pozI = i + 1;
                plik = argv[pozI];
            }
            if ((string(argv[i]) == "-c") and i < argc - 1) {
                pozC = i + 1;
                centrala = argv[pozC];
            }
        }
        cout << "\nNazwa pliku wejĹ›ciowego : " << plik << endl;
        cout << "Nazwa Centrali: " << centrala << endl;

    }
    else
    {
        cout << "ZLE ARGUMENTY\n" << "PODAJ : \n\n" << "-i nazwa pliku wejsciowego \n -c nazwa centrali\n";
    }
    return pozI;
}
struct slistEl
{
    slistEl* next;
    int v, w;           // numer wÄ™zĹ‚a docelowego i waga krawÄ™dzi
};

const int MAXINT = 2147483647;
int main(int argc, char* argv[])
{
    system("chcp 1250");
    system("cls");

    wczytaj_arg(argc, argv);
    string nazwa_pliku = argv[2];

    ifstream ifs(nazwa_pliku);
    vector<Node> graph;
    string m1, m2;
    unsigned dist;

    while (ifs >> m1 >> m2 >> dist) {
        int i1 = findOrAddCity(graph, m1);
        int i2 = findOrAddCity(graph, m2);
        graph[i1].connections.push_back(make_pair(i2, dist));
    }

    for (auto& i : graph) {
        cout << i.city << '\n';
        for (auto& c : i.connections)
            cout << '\t' << graph[c.first].city << " - " << c.second << '\n';
    }
    int i, j, m, n, v, u, w, x, y, sptr, * d, * p, * S;
    bool* QS;           // Zbiory Q i S
    slistEl** graf;     // Tablica list sÄ…siedztwa
    slistEl* pw, * rw;
    v = 0;
        n = 7;
        m = 7;
   // cin >> v >> n >> m; // WÄ™zeĹ‚ startowy, liczba wierzchoĹ‚kĂłw i krawÄ™dzi

    // Tworzymy tablice dynamiczne

    d = new int[n];          // Tablica kosztĂłw dojĹ›cia
    p = new int[n];          // Tablica poprzednikĂłw
    QS = new bool[n];        // Zbiory Q i S
    graf = new slistEl * [n]; // Tablica list sÄ…siedztwa
    S = new int[n];          // Stos
    sptr = 0;                   // WskaĹşnik stosu

    // Inicjujemy tablice dynamiczne

    for (i = 0; i < n; i++)
    {
        d[i] = MAXINT;
        p[i] = -1;
        QS[i] = false;
        graf[i] = NULL;
    }

    // Odczytujemy dane wejĹ›ciowe

    for (i = 0; i < m; i++)
    {
        cin >> x >> y >> w;    // Odczytujemy krawÄ™dĹş z wagÄ…
        pw = new slistEl;      // Tworzymy element listy sÄ…siedztwa
        pw->v = y;             // WierzchoĹ‚ek docelowy krawÄ™dzi
        pw->w = w;             // Waga krawÄ™dzi
        pw->next = graf[x];
        graf[x] = pw;       // Element doĹ‚Ä…czamy do listy
    }

    cout << endl;

    d[v] = 0;             // Koszt dojĹ›cia v jest zerowy

    // Wyznaczamy Ĺ›cieĹĽki

    for (i = 0; i < n; i++)
    {
        // Szukamy wierzchoĹ‚ka w Q o najmniejszym koszcie d

        for (j = 0; QS[j]; j++);
        for (u = j++; j < n; j++)
            if (!QS[j] && (d[j] < d[u])) u = j;

        // Znaleziony wierzchoĹ‚ek przenosimy do S

        QS[u] = true;

        // Modyfikujemy odpowiednio wszystkich sÄ…siadĂłw u, ktĂłrzy sÄ… w Q

        for (pw = graf[u]; pw; pw = pw->next)
            if (!QS[pw->v] && (d[pw->v] > d[u] + pw->w))
            {
                d[pw->v] = d[u] + pw->w;
                p[pw->v] = u;
            }
    }

    // Gotowe, wyĹ›wietlamy wyniki

    for (i = 0; i < n; i++)
    {
        cout << i << ": ";

        // ĹšcieĹĽkÄ™ przechodzimy od koĹ„ca ku poczÄ…tkowi, 
        // ZapisujÄ…c na stosie kolejne wierzchoĹ‚ki

        for (j = i; j > -1; j = p[j]) S[sptr++] = j;

        // WyĹ›wietlamy Ĺ›cieĹĽkÄ™, pobierajÄ…c wierzchoĹ‚ki ze stosu

        while (sptr) cout << S[--sptr] << " ";

        // Na koĹ„cu Ĺ›cieĹĽki wypisujemy jej koszt

        cout << "$" << d[i] << endl;
    }

    // Usuwamy tablice dynamiczne

    delete[] d;
    delete[] p;
    delete[] QS;
    delete[] S;

    for (i = 0; i < n; i++)
    {
        pw = graf[i];
        while (pw)
        {
            rw = pw;
            pw = pw->next;
            delete rw;
        }
    }

    delete[] graf;
    system("pause");

    return 0;
}

ijkstry

Algorytm Dijkstry

Tue, 29 Dec 2020 19:34:28 +0000

Mam do rozwiązania poniższe zadnie z zastosowaniem algorytmu Dijkstry. Mam napisane trochę kodu niestety nie wiem jak wprowadzić ten algorytmu

Firma spedycyjna przyjmuje towary w centrali, skąd rozsyła do odbiorców w całym kraju.
Trasy między miastami są zapisane w pliku w następujący sposób:
<miasto> <miasto> <odległość>
Przykładowy plik:
Szczecin Poznan 220
Szczecin Koszalin 110
Poznan Bytom 300
Poznan Lodz 130
Lodz Katowice 170
Bytom Katowice 15
Bytom Wroclaw 180
W wyniki działania programu zostanie tworzony plik z trasami spedycyjnymi w następującej
postaci (przykład dla centrali w Poznaniu):
Poznan -> Bytom: 300
Poznan -> Lodz -> Katowice: 300
Poznan -> Szczecin -> Koszalin: 330
Poznan -> Lodz: 130
Poznan -> Szczecin: 220
Poznan -> Bytom -> Wroclaw: 480
Trasy spedycyjne mają najkrótsze możliwe długości. Należy wykorzystać algorytm Dĳkstry.
Program uruchamiany jest z linii poleceń z potrzebnymi przełącznikami, natomiast
uruchomienie programu bez parametrów powoduje wypisanie krótkiej instrukcji.

#include <iostream>
#include <cstdlib>
#include <string>
#include <cstring>
#include <fstream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <utility>

//#include "def.cpp"
//#include "funkcje.h"

using namespace std;
struct Node {
    string city;
    vector<pair<unsigned, unsigned>> connections;
};

int findOrAddCity(vector<Node>& g, const string& name)
{
    for (int i = 0; i < g.size(); i++)
        if (g[i].city == name) return i;

    g.push_back({ name, {} });
    return g.size() - 1;
}
int wczytaj_arg(int argc, char* argv[])
{
  
        int pozI = 0;
        int pozC = 0;
        string nPlikuI = "";
        string nPlikuC = "";
        string plik, centrala;
        if (argc == 5)
        {
            for (int i = 0; i < argc; i++) {
                if ((string(argv[i]) == "-i") and i < argc - 1) {
                    pozI = i + 1;
                    plik = argv[pozI];
                }
                if ((string(argv[i]) == "-c") and i < argc - 1) {
                    pozC = i + 1;
                    centrala = argv[pozC];
                }
            }
            cout << "\nNazwa pliku wejściowego : " << plik << endl;
            cout << "Nazwa Centrali: " << centrala << endl;

        }
        else
        {
            cout << "ZŁE ARGUMENTY\n" << "PODAJ : \n\n" << "-i nazwa pliku wejsciowego \n -c nazwa centrali\n";
        }
        return pozI;
    }

int main(int argc, char* argv[])
{
    
    fstream plik1;
    string linia;
	system("chcp 1250");
	system("cls");
	
	wczytaj_arg(argc, argv);
	string nazwa_pliku = argv[2];
	
    plik1.open(nazwa_pliku);
    if (plik1.good() == true)
    {
       
           
     
        while (!plik1.eof()) {
            getline(plik1, linia);
            istringstream ifs(linia);


            vector<Node> graph;
            string n1, n2;
            unsigned dist;

            while (ifs >> n1 >> n2 >> dist) {
                int i1 = findOrAddCity(graph, n1);
                int i2 = findOrAddCity(graph, n2);
                graph[i1].connections.push_back(make_pair(i2, dist));
            }


            for (auto& i : graph) {
                cout << i.city;

                for (auto& c : i.connections)
                    cout << graph[c.first].city << " - " << c.second << endl;
                
            }

        }
        cout << endl;
        plik1.close();

    }
    else cout << "\n\tBłąd otwarcia pliku";


}

algorytm dijkstry ocena rozwiązania

Tue, 03 Nov 2020 17:12:25 +0000

Dzień dobry miałem na zadanie rozwiązac poniższy problem i chciałbym się spytać czy moje rozwiązanie jestpoprawne

Algorytm Dijkstry

Sun, 10 May 2020 07:46:38 +0000

Witam wszystkich, muszę uzupełnić taką tabelkę:

Na podstawie algorytmu Dijkstry, czyli muszę przedstawić przebieg algorytmu Dijkstry oraz arytmu Bellmana-Forda
Dla poniższego grafu, kompletnie nie wiem jak powinna wyglądać ta tabelka, pomimo tego że uważam że wiem jak działa ten algorytm

Algorytm Dijkstry

Fri, 06 Mar 2020 11:59:53 +0000

W jaki sposób mogę zmienić klasyczną implementacje algorytmu Dijktstry, żeby ograniczyć zużycie pamięci? Moja implementacja przy założeniu, każdy wierzchołek ma połączenie z każdym, przy tworzeniu tablicy wag krawędzi zużywa ogromne ilości pamięci. W jaki sposób mogę zoptymalizować algorytm by ten zużywał jak najmniej pamięci?

Algorytm Dijkstry a Drzewo List

Thu, 26 Dec 2019 22:25:02 +0000

Witam. Mam problem z zastosowaniem algorytmu Dijkstry do drzewa list gdzie każde drzewo przechowuje nazwę wierzchołku oraz wskaźnik do listy w której każdy element zawiera odległość do innego wierzchołka,który wskazywany jest przez wskaźnik do drzewa. Widziałem kilka różnych implementacji tego algorytmu, ale zupełnie nie wiem jak go dostosować pod mój problem oraz jak poruszać się po drzewie (na myśl przychodzi mi rekurencja)? Najlepiej jakby było to z użyciem std::priority_queue.

Porównać algorytm A* z algorytmem Dijkstry

Sun, 08 Dec 2019 19:48:46 +0000

Witam, mam problem z algorytmami A* oraz Dijkstry. Nie zostały one dobrze wytłumaczone i teraz mam z nimi kłopot. Czy ktoś mógłby je porównać ze sobą ? Oraz najprościej wytłumaczyć A* ? Grupa 185IC będzie wdzięczna !

Przekonwertuj algorytm Dijkstra na A* (Astar)

Thu, 17 May 2018 15:39:40 +0000

Witam,
Dostałem zadanie w którym muszę przekonwertować algorytm Dijkstra na A* i totalnie nie mam pojęcia jak to zrobić.

Tutaj jest kod źródłowy Dijkstry, w razie jak by czegoś brakowało, napiszcie, potrzebuję pilnie pomocy!

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package nl.hva.dmci.ict.se.sortingsearching.pathfinding;

import java.util.Stack;
import nl.hva.dmci.ict.se.sortingsearching.weigthedgraph.DirectedEdge;
import nl.hva.dmci.ict.se.sortingsearching.weigthedgraph.EdgeWeightedDigraph;
import nl.hva.dmci.ict.se.sortingsearching.weigthedgraph.IndexMinPQ;

/**
 *
 * @author kamci
 */
public class Astar {
    private double[] distTo;          // distTo[v] = distance  of shortest s->v path
    private DirectedEdge[] edgeTo;    // edgeTo[v] = last edge on shortest s->v path
    private IndexMinPQ<Double> pq;    // priority queue of vertices
    private int vertexesProcessed = 0;

    public int getVertexesProcessed() {
        return vertexesProcessed;
    }
    /**
     * Computes a shortest paths tree from <tt>s</tt> to every other vertex in
     * the edge-weighted digraph <tt>G</tt>.
     * @param G the edge-weighted digraph
     * @param s the source vertex
     * @throws IllegalArgumentException if an edge weight is negative
     * @throws IllegalArgumentException unless 0 &le; <tt>s</tt> &le; <tt>V</tt> - 1
     */
    public Astar(EdgeWeightedDigraph G, int s) {
        for (DirectedEdge e : G.edges()) {
            if (e.weight() < 0)
                throw new IllegalArgumentException("edge " + e + " has negative weight");
        }

        distTo = new double[G.V()];
        edgeTo = new DirectedEdge[G.V()];
        for (int v = 0; v < G.V(); v++)
            distTo[v] = Double.POSITIVE_INFINITY;
        distTo[s] = 0.0;

        // relax vertices in order of distance from s
        pq = new IndexMinPQ<Double>(G.V());
        pq.insert(s, distTo[s]);
        while (!pq.isEmpty()) {
            int v = pq.delMin();
            for (DirectedEdge e : G.adj(v))
                relax(e);
        }

        // check optimality conditions
        assert check(G, s);
    }

    // relax edge e and update pq if changed
    private void relax(DirectedEdge e) {
        int v = e.from(), w = e.to();
        if (distTo[w] > distTo[v] + e.weight()) {
            distTo[w] = distTo[v] + e.weight();
            edgeTo[w] = e;
            vertexesProcessed++;
            if (pq.contains(w)) pq.decreaseKey(w, distTo[w]);
            else                pq.insert(w, distTo[w]);
        }
    }

    /**
     * Returns the length of a shortest path from the source vertex <tt>s</tt> to vertex <tt>v</tt>.
     * @param v the destination vertex
     * @return the length of a shortest path from the source vertex <tt>s</tt> to vertex <tt>v</tt>;
     *    <tt>Double.POSITIVE_INFINITY</tt> if no such path
     */
    public double distTo(int v) {
        return distTo[v];
    }

    /**
     * Is there a path from the source vertex <tt>s</tt> to vertex <tt>v</tt>?
     * @param v the destination vertex
     * @return <tt>true</tt> if there is a path from the source vertex
     *    <tt>s</tt> to vertex <tt>v</tt>, and <tt>false</tt> otherwise
     */
    public boolean hasPathTo(int v) {
        return distTo[v] < Double.POSITIVE_INFINITY;
    }

    /**
     * Returns a shortest path from the source vertex <tt>s</tt> to vertex <tt>v</tt>.
     * @param v the destination vertex
     * @return a shortest path from the source vertex <tt>s</tt> to vertex <tt>v</tt>
     *    as an iterable of edges, and <tt>null</tt> if no such path
     */
    public Iterable<DirectedEdge> pathTo(int v) {
        if (!hasPathTo(v)) return null;
        Stack<DirectedEdge> path = new Stack<DirectedEdge>();
        for (DirectedEdge e = edgeTo[v]; e != null; e = edgeTo[e.from()]) {
            path.push(e);
        }
        return path;
    }


    // check optimality conditions:
    // (i) for all edges e:            distTo[e.to()] <= distTo[e.from()] + e.weight()
    // (ii) for all edge e on the SPT: distTo[e.to()] == distTo[e.from()] + e.weight()
    private boolean check(EdgeWeightedDigraph G, int s) {

        // check that edge weights are nonnegative
        for (DirectedEdge e : G.edges()) {
            if (e.weight() < 0) {
                System.err.println("negative edge weight detected");
                return false;
            }
        }

        // check that distTo[v] and edgeTo[v] are consistent
        if (distTo[s] != 0.0 || edgeTo[s] != null) {
            System.err.println("distTo[s] and edgeTo[s] inconsistent");
            return false;
        }
        for (int v = 0; v < G.V(); v++) {
            if (v == s) continue;
            if (edgeTo[v] == null && distTo[v] != Double.POSITIVE_INFINITY) {
                System.err.println("distTo[] and edgeTo[] inconsistent");
                return false;
            }
        }

        // check that all edges e = v->w satisfy distTo[w] <= distTo[v] + e.weight()
        for (int v = 0; v < G.V(); v++) {
            for (DirectedEdge e : G.adj(v)) {
                int w = e.to();
                if (distTo[v] + e.weight() < distTo[w]) {
                    System.err.println("edge " + e + " not relaxed");
                    return false;
                }
            }
        }

        // check that all edges e = v->w on SPT satisfy distTo[w] == distTo[v] + e.weight()
        for (int w = 0; w < G.V(); w++) {
            if (edgeTo[w] == null) continue;
            DirectedEdge e = edgeTo[w];
            int v = e.from();
            if (w != e.to()) return false;
            if (distTo[v] + e.weight() != distTo[w]) {
                System.err.println("edge " + e + " on shortest path not tight");
                return false;
            }
        }
        return true;
    }
}