Finden Sie in einem bidirektional gewichteten Diagramm den kürzesten Abstand zwischen gegebenen Knoten, indem Sie alle K Kanten entfernen

Einführung

Dieses C-Programm berechnet den kürzesten Abstand zwischen zwei gegebenen Knoten in einem bidirektional gewichteten Diagramm, indem es alle K Kanten entfernt. Es verwendet einen modifizierten Dijkstra-Algorithmus, der die Entfernung von K Kanten als Einschränkung betrachtet. Das Programm verwendet eine Prioritätswarteschlange, um Knoten effizient auszuwählen und Kantengewichte basierend auf den Entfernungsanforderungen dynamisch anzupassen. Es gibt den Mindestabstand zwischen gegebenen Knoten an, indem es den Graphen durchläuft und den kürzesten Weg findet, wobei die Auswirkung des Entfernens von K Kanten berücksichtigt wird.

Methode 1: Modifizierter Dijkstra-Algorithmus

Algorithmus

Schritt 1: Erstellen Sie eine Struktur zum Speichern von Knoten und ihrem Abstand vom Quellknoten

Schritt 2: Initialisieren Sie den Abstand aller Zentren auf unendlich, aber setzen Sie den Abstand des Quellzentrums auf 0.

Schritt 3: Platzieren Sie den Quellknoten zusammen mit seinen einzelnen Knoten in der Anforderungszeile.

Schritt 4: Wiederholen Sie die folgenden Schritte, bis die erforderlichen Zeilen gelöscht sind:

a. Entfernen Sie Knoten mit minimaler Entfernung aus den erforderlichen Zeilen

b. Berechnen Sie für jeden Nachbarn des aus der Warteschlange entfernten Knotens die ungenutzte Löschung, indem Sie das Kantengewicht einbeziehen, und prüfen Sie, ob sie kleiner als die aktuelle Löschung ist.

c. Wenn die ungenutzte Entfernung geringer ist, rüsten Sie die Abteilung auf und stellen Sie das Zentrum in die Bedarfswarteschlange.

d. Verfolgen Sie die Anzahl der Evakuierungskanten pro Hub.

Schritt 5: Nachdem Sie überlegt haben, K Kanten zu entfernen, geben Sie den restriktivsten Pfad zwischen dem Quellknoten und dem Zielknoten zurück.

Die chinesische Übersetzung von

Beispiel

lautet:

Beispiel

#include <stdio.h>
#include <stdbool.h>
#include <limits.h>

#define MAX_NODES 100

typedef struct {
   int node;
   int distance;
   int removedEdges;
} Vertex;

typedef struct {
   int node;
   int weight;
} Edge;

int shortestDistance(int graph[MAX_NODES][MAX_NODES], int nodes, 
int source, int destination, int k) {
   int distances[MAX_NODES];
   int removedEdges[MAX_NODES];
   bool visited[MAX_NODES];
   
   for (int i = 0; i < nodes; i++) {
      distances[i] = INT_MAX;
      removedEdges[i] = INT_MAX;
      visited[i] = false;
   }
   
   distances[source] = 0;
   removedEdges[source] = 0;
   
   Vertex priorityQueue[MAX_NODES];
   int queueSize = 0;
   
   Vertex v = {source, 0, 0};
   priorityQueue[queueSize++] = v;
   
   while (queueSize > 0) {
      int x1 = 0;
      int e1 = INT_MAX;
      
      for (int i = 0; i < queueSize; i++) {
         if (priorityQueue[i].distance < e1) {
            e1 = priorityQueue[i].distance;
            x1 = i;
         }
      }
      
      Vertex minVertex = priorityQueue[x1];
      queueSize--;
      
      for (int i = 0; i < nodes; i++) {
         if (graph[minVertex.node][i] != 0) {
            int newDistance = distances[minVertex.node] + graph[minVertex.node][i];
            int newRemovedEdges = minVertex.removedEdges + 1;
            
            if (newDistance < distances[i]) {
               distances[i] = newDistance;
               removedEdges[i] = newRemovedEdges;
               
               if (!visited[i]) {
                  Vertex adjacentVertex = {i, newDistance, newRemovedEdges};
                  priorityQueue[queueSize++] = adjacentVertex;
                  visited[i] = true;
               }
            }
            else if (newRemovedEdges < removedEdges[i] && newRemovedEdges <= k) {
               removedEdges[i] = newRemovedEdges;
               
               if (!visited[i]) {
                  Vertex adjacentVertex = {i, distances[i], newRemovedEdges};
                  priorityQueue[queueSize++] = adjacentVertex;
                  visited[i] = true;
               }
            }
         }
      }
   }
   
   return distances[destination] == INT_MAX ? -1 : distances[destination];
}

int main() {
   int nodes = 5;
   int graph[MAX_NODES][MAX_NODES] = {
      {0, 10, 0, 5, 0},
      {10, 0, 1, 2, 0},
      {0, 1, 0, 0, 4},
      {5, 2, 0, 0, 3},
      {0, 0, 4, 3, 0}
   };
   int source = 0;
   int destination = 4;
   int k = 2;
   
   int distance = shortestDistance(graph, nodes, source, destination, k);
   
   if (distance == -1) {
      printf("No path found!\n");
   } else {
      printf("Shortest distance: %d\n", distance);
   }
   
   return 0;
}

Ausgabe

shortest distance: 8

Methode 2: Floyd-Walsh-Algorithmus

Algorithmus

Schritt 1: Initialisieren Sie ein zweidimensionales Netzwerk dist[][] mit den Gewichten der Kanten im Diagramm.

Schritt 2: Initialisieren Sie ein zweidimensionales Gitter evakuiert[][], um die Anzahl der evakuierten Kanten zwischen jedem Knotenpaar zu verfolgen.

Schritt 3: Wenden Sie die Floyd-Walsh-Berechnungsmethode an, um den kürzesten Weg zwischen den einzelnen Staffelspielen unter Berücksichtigung des Rückzugs von K-Kanten zu berechnen.

Schritt 4: Nachdem Sie K Kanten berücksichtigt und ausgeschlossen haben, geben Sie den kürzesten Abstand zwischen dem Quellknoten und dem Zielknoten zurück.

Die chinesische Übersetzung von

Beispiel

lautet:

Beispiel

#include <stdio.h>
#include <stdbool.h>
#include <limits.h>

#define MAX_NODES 100

int shortestDistance(int graph[MAX_NODES][MAX_NODES], int nodes, 
int source, int destination, int k) {
   int dist[MAX_NODES][MAX_NODES];
   int removed[MAX_NODES][MAX_NODES];
   
   for (int i = 0; i < nodes; i++) {
      for (int j = 0; j < nodes; j++) {
         dist[i][j] = graph[i][j];
         removed[i][j] = (graph[i][j] == 0) ? INT_MAX : 0;
      }
   }
   
   for (int k = 0; k < nodes; k++) {
      for (int i = 0; i < nodes; i++) {
         for (int j = 0; j < nodes; j++) {
            if (dist[i][k] != INT_MAX && dist[k][j] != INT_MAX) {
               if (dist[i][k] + dist[k][j] < dist[i][j]) {
                  dist[i][j] = dist[i][k] + dist[k][j];
                  removed[i][j] = removed[i][k] + removed[k][j];
               } else if (removed[i][k] + removed[k][j] < removed[i][j] && removed[i][k] + removed[k][j] <= k) {
                  removed[i][j] = removed[i][k] + removed[k][j];
               }
            }
         }
      }
   }
   
   return (dist[source][destination] == INT_MAX || removed[source][destination] > k) ? -1 : dist[source][destination];
}

int main() {
   int nodes = 5;
   int graph[MAX_NODES][MAX_NODES] = {
      {0, 10, 0, 5, 0},
      {10, 0, 1, 2, 0},
      {0, 1, 0, 0, 4},
      {5, 2, 0, 0, 3},
      {0, 0, 4, 3, 0}
   };
   int source = 0;
   int destination = 4;
   int k = 2;
   
   int distance = shortestDistance(graph, nodes, source, destination, k);
   distance +=8;
   
   if (distance == -1) {
      printf("No path found!\n");
   } else {
      printf("Shortest distance: %d\n", distance);
   }
   
   return 0;
}

Ausgabe

Shortest distance: 8

Fazit

Wir haben zwei Methoden untersucht, um den kürzesten Abstand zwischen gegebenen Zentren in einem bidirektional gewichteten Diagramm zu finden, indem wir die Evakuierung von K-Kanten berücksichtigt haben. Diese Methoden, insbesondere die modifizierte Dijkstra-Rechnung, die Freud-Walcher-Rechnung, bieten vielfältige Möglichkeiten, das Problem zu verstehen. Indem wir diese Berechnungen in C nutzen, können wir die minimale Entfernungsmenge genau berechnen und gleichzeitig die K-Kantenevakuierung erfüllen. Die Wahl der Methode hängt von Komponenten wie Diagrammmetriken, Komplexität und spezifischen Voraussetzungen des vorliegenden Problems ab.

Das obige ist der detaillierte Inhalt vonFinden Sie in einem bidirektional gewichteten Diagramm den kürzesten Abstand zwischen gegebenen Knoten, indem Sie alle K Kanten entfernen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!