Finden Sie in einem gerichteten gewichteten Graphen den kürzesten Pfad, der genau k Kanten enthält.

In einem koordinierten gewichteten Diagramm besteht das Problem, den kürzesten Pfad mit genau k Kanten zu finden, darin, den Pfad mit dem geringsten Gewicht zu bestimmen und dabei genau k Kanten zu navigieren. Dies wird durch den Einsatz dynamischer Programmierstrategien erreicht, beispielsweise durch den Einsatz von 3D-Frameworks, um minimale Gewichte auf alle erdenklichen Arten zu speichern. Die Berechnung wird an Eckpunkten und Kanten wiederholt, wobei das Mindestgewicht bei jedem Schritt angepasst wird. Durch die Berücksichtigung aller möglichen Möglichkeiten, genau k Kanten zu haben, kann die Berechnung die eingeschränkteste Art unterscheiden, k Kanten im Diagramm zu haben.

Anwendungsmethode

• Naive rekursive Methode

• Dijkstra-Algorithmus mit Kantenbeschränkungen

Naive rekursive Methode

Naive rekursive Methoden können eine wichtige und klare Strategie zur Problemlösung sein, die darin besteht, komplexe Probleme in kleinere Teilprobleme zu zerlegen und diese rekursiv zu lösen. Bei diesem Ansatz ruft sich die Arbeit mehrmals auf, um Teilprobleme zu untersuchen, bis der Basisfall erreicht ist. Dennoch kann es bei größeren Problemen aufgrund der Doppelzählung und der Abdeckung von Teilproblemen verschwenderisch sein. Es erfordert Optimierungsmethoden wie Speicher- oder Energieprogrammierung. Leichtgläubige rekursive Methoden sind leicht zu beschaffen und zu implementieren, können jedoch unter einer exponentiellen Zeitkomplexität leiden. Es wird häufig zur Lösung kleinerer Probleme oder als Ausgangspunkt für optimalere Berechnungen verwendet.

Algorithmus

• Stellt den funktionierenden kürzesten Pfad (Graph, u, v, k) dar, der als Eingabe einen Graphen, einen Quellscheitelpunkt u, einen Zielscheitelpunkt v und die Anzahl der Kanten k verwendet.

• Überprüfen Sie die Grundsituation:

• a. Gibt zurück, wenn k und u mit v brechen (da in diesem Fall keine Kanten zulässig sind).

• Der Zweite. Wenn k 1 ist und es im Diagramm eine Kante zwischen u und v gibt, wird dessen Gewicht zurückgegeben.

• c. Wenn k kleiner oder gleich 0 ist, wird unbegrenzt zurückgegeben (da negative oder Nullkanten nicht zulässig sind).

• Initialisieren Sie eine unendliche Variable res, um die kürzeste Pfadentfernung zu speichern.

• Der Graph sollte über alle Eckpunkte wie folgt iterieren:

• a. Wenn u und i nicht zu u oder v aufsteigen, dann gibt es einen Rand von u zu i:

• Rufen Sie shortestPath rekursiv auf, wobei i der moderne Quellscheitelpunkt, v der Zielscheitelpunkt und k−1 die Anzahl der verbleibenden Kanten ist.

• Wenn das zurückgegebene Ergebnis nicht unendlich ist, wird res auf den Mindestwert von res und das Gewicht der aktuellen Kante und des rekursiven Ergebnisses aktualisiert.

• Gibt den Wert von res als die eingeschränkteste Möglichkeit zur genauen Trennung von k Kanten zurück.

Beispiel

#include <iostream>
#include <climits>

#define V 4
#define INF INT_MAX

int shortestPathWithKEdges(int graph[][V], int source, int destination, int k) {
    // Base cases
    if (k == 0 && source == destination)
        return 0;
    if (k == 1 && graph[source][destination] != INF)
        return graph[source][destination];
    if (k <= 0)
        return INF;

    // Initialize result
    int shortestPathDistance = INF;

    // Explore all adjacent vertices of the source vertex
    for (int i = 0; i < V; i++) {
        if (graph[source][i] != INF && source != i && destination != i) {
            int recursiveDistance = shortestPathWithKEdges(graph, i, destination, k - 1);
            if (recursiveDistance != INF)
                shortestPathDistance = std::min(shortestPathDistance, graph[source][i] + recursiveDistance);
        }
    }

    return shortestPathDistance;
}

int main() {
    int graph[V][V] = {
        {0, 10, 3, 2},
        {INF, 0, INF, 7},
        {INF, INF, 0, 6},
        {INF, INF, INF, 0}
    };
    int source = 0, destination = 3, k = 2;
    std::cout << "Weight of the shortest path is " << shortestPathWithKEdges(graph, source, destination, k) << std::endl;
    return 0;
}

Ausgabe

Weight of the shortest path is 9

Dijkstra-Algorithmus mit Kantenbeschränkungen

Dijkstras Algorithmus mit Kantenbeschränkungen ist eine Graph-Traversal-Berechnung, die den kürzesten Weg zwischen einem Quellscheitelpunkt und allen anderen Scheitelpunkten im Diagramm identifiziert. Es berücksichtigt Grenzen oder Einschränkungen an den Kanten des Diagramms, wie z. B. die höchsten oder niedrigsten Kantengewichte. Die Berechnung behält die erforderlichen Scheitelpunktlinien bei und wählt iterativ die wenigsten zu entfernenden Scheitelpunkte aus. Wenn an diesem Punkt ein kürzerer Pfad gefunden wird, werden benachbarte Scheitelpunkte entspannt, indem der Abstand zwischen ihnen vergrößert wird. Diese Vorbereitung wird fortgesetzt, bis alle Eckpunkte besucht wurden. Der Dijkstra-Algorithmus mit Kantenbefehlen garantiert, dass der gewählte Weg die erforderlichen Kantenbeschränkungen erfüllt und gleichzeitig den am stärksten eingeschränkten Weg findet

Algorithmus

• Verwenden Sie die folgenden Parameter, um Dijkstras Kunstwerk zu erstellen

• Grafik: Eingabediagramm mit Eckpunkten und Kanten

  Quelle: Startscheitelpunkt des am stärksten begrenzten Pfades

  Einschränkungen: Einschränkungen oder Hindernisse an den Rändern

  Initialisieren Sie einen Satz verschwundener Scheitelpunkte und eine Bedarfslinie, um die Scheitelpunkte und ihre Abstände zu speichern.

• Erstellen Sie einen Löschcluster und setzen Sie die Löschung für alle Scheitelpunkte auf Endbarkeit, mit Ausnahme des Quellscheitelpunkts, der auf 0 gesetzt ist.

• Ordnen Sie die Quellscheitelpunkte entsprechend ihrem Abstand in den gewünschten Reihen an.

• Auch wenn die Nachfragepipeline nicht gelöscht werden kann, gehen Sie bitte wie folgt vor:

• Entfernen Sie den Scheitelpunkt mit der geringsten Anzahl an Eliminierungen aus der gewünschten Warteschlange.

• Wenn der Scheitelpunkt jetzt nicht mehr besucht wird,

• Markieren Sie es als besucht.

• Für jeden angrenzenden Scheitelpunkt eines modernen Scheitelpunkts:

• Wenden Sie Kantenbarrieren an, um festzustellen, ob eine Kante in Betracht gezogen werden kann.

• Berechnen Sie den ungenutzten Abstand von Speisescheitelpunkten zu benachbarten Scheitelpunkten unter Berücksichtigung von Kantengewichten und Einschränkungen.

• Verbessern Sie das Trennzeichen-Array, wenn die aktuellen Trennzeichen kürzer als moderne Trennzeichen sind.

• Stellen Sie benachbarte Eckpunkte mit ihrem ungenutzten Abstand in die gewünschte Reihe.

• Nachdem alle Scheitelpunkte erreicht sind, enthält ein separater Cluster die maximale kurze Entfernung vom Versorgungsscheitelpunkt zu jedem Scheitelpunkt, der die Kantenbeschränkungen erfüllt.

• Einzelne Cluster als Ergebnisse zurückgeben.

示例

#include <iostream>
#include <vector>
#include <limits>

struct Edge {
    int destination;
    int weight;
};

void dijkstra(const std::vector<std::vector<Edge>>& graph, int source, std::vector<int>& distance) {
    int numVertices = graph.size();
    std::vector<bool> visited(numVertices, false);
    distance.resize(numVertices, std::numeric_limits<int>::max());
    distance[source] = 0;

    for (int i = 0; i < numVertices - 1; ++i) {
        int minDistance = std::numeric_limits<int>::max();
        int minVertex = -1;

        for (int v = 0; v < numVertices; ++v) {
            if (!visited[v] && distance[v] < minDistance) {
                minDistance = distance[v];
                minVertex = v;
            }
        }

        if (minVertex == -1)
            break;

        visited[minVertex] = true;

        for (const auto& edge : graph[minVertex]) {
            int destination = edge.destination;
            int weight = edge.weight;

            if (!visited[destination] && distance[minVertex] != std::numeric_limits<int>::max() &&
                distance[minVertex] + weight < distance[destination]) {
                distance[destination] = distance[minVertex] + weight;
            }
        }
    }
}

int main() {
    int numVertices = 4;
    int source = 0;
    std::vector<std::vector<Edge>> graph(numVertices);

    // Add edges to the graph (destination, weight)
    graph[0] = {{1, 10}, {2, 3}};
    graph[1] = {{2, 1}, {3, 7}};
    graph[2] = {{3, 6}};

    std::vector<int> distance;
    dijkstra(graph, source, distance);

    // Print the shortest distances from the source vertex
    std::cout << "Shortest distances from vertex " << source << ":\n";
    for (int i = 0; i < numVertices; ++i) {
        std::cout << "Vertex " << i << ": " << distance[i] << '\n';
    }

    return 0;
}

输出

Shortest distances from vertex 0:
Vertex 0: 0
Vertex 1: 10
Vertex 2: 3
Vertex 3: 9

结论

本文概述了两个重要的计算，以帮助理解协调和加权图表中的大多数问题。它阐明了易受骗的递归方法和带有边缘限制的 Dijkstra 计算。轻信递归方法包括递归地研究具有精确 k 个边的所有可能的方式，以发现最有限的方式。 Dijkstra 的边命令式计算采用了所需的线和面积规则，成功地找出了图表中从供给顶点到所有不同顶点的最大受限方式。本文包含了计算的具体说明，并给出了测试代码来说明其用法.

Das obige ist der detaillierte Inhalt vonFinden Sie in einem gerichteten gewichteten Graphen den kürzesten Pfad, der genau k Kanten enthält.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!