Die Summe aller Paare kürzester Pfade im Baum

In Bäumen bezieht sich der Begriff „Summe der kürzesten Pfade über alle Knotenpaare“ auf die Berechnung der Summe der einzelnen kürzesten Pfade für alle Knotenpaare. Eine effektive Methode ist die Verwendung des dualen DFS-Algorithmus (Tiefensuche). Der Abstand zwischen dem ausgewählten Knoten und jedem anderen Knoten wird während des ersten DFS-Durchlaufs bestimmt. Der Baum wird während des zweiten DFS-Durchlaufs erneut durchlaufen, wobei jeder Knoten als potenzieller LCA (niedrigster gemeinsamer Vorfahre) betrachtet und die Summe der Abstände zwischen Paaren von Nachkommenknoten des ausgewählten LCA berechnet wird. Mit dieser Methode können Sie die Summe der kürzesten Pfade für alle Knotenpaare im Baum berechnen und eine ideale Lösung sicherstellen

Anwendungsmethode

• Doppelte DFS-Methode (Tiefensuche).

• Dynamische Programmiermethode

Doppelte DFS-Methode (Depth First Search)

Für die Summe aller Paare kürzester Pfade im Baum verwenden wir eine duale DFS-Methode (Tiefensuche), die zwei DFS-Durchgänge umfasst. Zuerst berechnen wir den Abstand von jedem Knoten zu allen anderen Knoten. Während des zweiten DFS-Durchlaufs navigieren wir dann durch den Baum und betrachten dabei jeden Knoten als potenziellen LCA. Wir berechnen und summieren die Abstände zwischen Knotenpaaren, die während der Durchquerung Nachkommen des ausgewählten LCA sind. Indem wir diesen Vorgang für alle Knoten wiederholen, erhalten wir die Summe aller Paare kürzester Pfade. Diese Strategie ist für dieses Problem sehr überzeugend, da sie effektiv die Summe der Abstände zwischen allen Knotensätzen im Baum berechnet.

Algorithmus

• Jeder Knoten im Baum kann als Startknoten verwendet werden

• Um die Entfernung vom ausgewählten Startknoten zu allen anderen Knoten zu bestimmen, führen Sie eine Tiefensuche (DFS) ausgehend von diesem Knoten durch. Diese Abstände sollten in einem Array oder einer Datenstruktur gespeichert werden.

• Als nächstes führen Sie eine zweite Tiefensuche (DFS) im Baum durch und betrachten dabei jeden Knoten als seinen möglichen nächsten gemeinsamen Vorfahren (LCA).

• Berechnen Sie beim Durchlaufen des Baums während des zweiten DFS den Abstand zwischen Knotenpaaren, die Nachkommen des ausgewählten LCA sind. Für jede LCA werden diese Distanzen addiert.

• Wiederholen Sie diesen Vorgang für jeden Knoten im Baum

• Die Summe aller Übereinstimmungen auf die endlichste Art im Baum wird durch die Summe aller in Schritt 4 berechneten Abstände dargestellt.

Die chinesische Übersetzung von

Beispiel

lautet:

Beispiel

#include <iostream>
#include <vector>
using namespace std;

const int MAXN = 10005;
vector<int> graph[MAXN];
int ancestor[MAXN];

int dfs(int node, int lca, int distance) {
   int sum = 0;
   for (int neighbor : graph[node]) {
      if (neighbor != lca) {
         sum += dfs(neighbor, lca, distance + 1);
      }
   }
   return sum + distance;
}

int main() {

   int lca_node = 0;
   int total_sum = 0;

   for (int node = 0; node < MAXN; ++node) {
      if (node != lca_node) {
         total_sum += dfs(node, lca_node, 0);
      }
   }

   cout << "Total sum of distances between descendants of the LCA: " << total_sum << endl;

   return 0;
}

Ausgabe

Total sum of distances between descendants of the LCA: 0

Dynamische Programmiermethode:

Wir wählen zunächst einen beliebigen Knoten als Wurzelknoten aus und wandeln den Baum im dynamischen Programmierverfahren in einen Wurzelbaum um, mit dem die Summe der kürzesten Pfade zwischen allen Knoten im Baum berechnet wird. Wir verwenden dynamische Programmierung, um die Aufteilung zwischen jedem Knoten und dem Wurzelknoten zu berechnen und die Ergebnisse in einem Array zu speichern. Dann addieren wir für jeden Knoten die (berechneten) Abstände seiner untergeordneten Knoten vom Wurzelknoten, um den Gesamtabstand aller anderen Knoten zu bestimmen. Auf diese Weise können wir schnell die Gesamtzahl der kürzesten Wege zwischen allen Knoten berechnen. Um dieses Problem effizient zu lösen, beträgt die zeitliche Komplexität dieses Algorithmus O(N), wobei N die Anzahl der Knoten im Baum ist.

Algorithmus

• Nehmen Sie einen beliebigen Knoten im Baum als Wurzel und verwurzeln Sie den Baum (z. B. mithilfe einer Tiefensuche des Wurzelknotens), um einen verwurzelten Baum zu erstellen.

• Dynamische Programmierung kann verwendet werden, um den Abstand jedes Knotens von der Wurzel zu bestimmen. Diese Abstände sollten in einem Array oder einer Datenstruktur gespeichert werden.

• Berechnen Sie die Summe der Abstände von jedem Knoten zu allen anderen Knoten im Baum:

a. Durchlaufen Sie die untergeordneten Knoten des aktuellen Knotens.

b. Um den Pfad durch den aktuellen Knoten zu berücksichtigen, addieren Sie die Anzahl der Knoten im Teilbaum und den zuvor für jeden Teilbaum berechneten Abstand zur Wurzel.

c. Addieren Sie für jeden untergeordneten Knoten des aktiven Knotens diese Beträge

d. Addieren Sie die Gesamtsumme des aktuellen Knotens zum Endergebnis.

• Die Summe aller Paare kürzester Pfade im Baum ist das Endergebnis.

#include <iostream>
#include <vector>

using namespace std;

struct TreeNode {
   int val;
   vector<TreeNode*> children;
};

int dfs(TreeNode* node, vector<int>& distances) {
   int subtree_size = 1;
   for (TreeNode* child : node->children) {
      subtree_size += dfs(child, distances);
      distances[node->val] += distances[child->val] + subtree_size;
   }
   return subtree_size;
}

int sumOfAllPairShortestPaths(TreeNode* root) {
   vector<int> distances(root->val + 1, 0);
   dfs(root, distances);
   int total_sum = 0;
   for (int distance : distances) {
      total_sum += distance;
   }
   return total_sum;
}

int main() {
   TreeNode* root = new TreeNode{0};
   int result = sumOfAllPairShortestPaths(root);
   cout << "Sum of all pair shortest paths in the tree: " << result << endl;
   return 0;
}

Ausgabe

Sum of all pair shortest paths in the tree: 0

Fazit

Die Summe aller Paare kürzester Pfade im Baum kann mithilfe der Double DFS-Methode (Depth First Search) oder dynamischer Programmierung berechnet werden. Die Double-DFS-Methode besteht aus zwei Durchgängen: Zuerst wird der Abstand vom ausgewählten Knoten zu allen anderen Knoten berechnet und dann wird der Baum erneut durchlaufen, wobei jeder Knoten als potenzieller niedrigster gemeinsamer Vorfahre (LCA) behandelt wird, um die Abstände zwischen Descendant-Knotenpaaren zu summieren. Dynamische Programmiermethoden erfordern die rekursive Verwendung von DFS, um die Wurzel des Baums zu erstellen und den Abstand von der Wurzel zu jedem anderen Knoten zu berechnen. Das Ergebnis beider Methoden ist das gleiche und besteht aus der Summe aller paarweise kürzesten Pfade im Baum. Die Entscheidung zwischen zwei Algorithmen kann auf spezifischen Implementierungspräferenzen oder Baumstrukturen basieren, aber beide Algorithmen bieten effiziente Lösungen.

Das obige ist der detaillierte Inhalt vonDie Summe aller Paare kürzester Pfade im Baum. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!