Drucken Sie Knoten in einem gerichteten Graphen, die zu keinem Zyklus gehören

In Koordinationsdiagrammen ist die Identifizierung von Hubs, die zu keinem Zyklus gehören, für verschiedene Anwendungen von entscheidender Bedeutung. Diese Zentren bilden die Grundlage azyklischer Untergraphen und spielen eine wichtige Rolle beim Verständnis der allgemeinen Graphenstruktur. Durch die Verwendung effizienter Graphenschnittpunktberechnungen wie Profundity First Hunt (DFS) oder Tarjans Berechnung eng verwandter Teile können wir mühelos Hubs bestimmen und drucken, die an keinen Schleifen teilnehmen. Diese Methoden gewährleisten die Charakterisierung von Zentren ohne zirkuläre Zusammenarbeit, liefern wichtige Erkenntnisse für die nicht-zirkulären Teile von Diagrammen und unterstützen verschiedene kritische Denksituationen im Zusammenhang mit Diagrammen.

Anwendungsmethode

• Tiefensuche (DFS) mit Schleifenerkennung

• Tarjans stark verbundener Komponentenalgorithmus

Tiefensuche (DFS) mit Schleifenerkennung

Bei diesem Ansatz verwenden wir Depth-First-Tracking (DFS), um im Koordinationsdiagramm zu navigieren und unterwegs Zyklen zu unterscheiden. Wir markieren besuchte Zentren und führen eine Liste, damit die Zentren fortlaufend nach DFS-Methode verfolgt werden können. Wenn wir auf eine Hinterkante stoßen (die Kante der Nabe auf nachhaltige DFS-Weise erreichen), differenzieren wir einen Zyklus. Am Ende der DFS wird das Zentrum im weiteren Verlauf der DFS für einen Zyklus wichtig sein. Hubs, die kein persistentes DFS verwenden, sind nicht Teil einer Schleife und können gedruckt werden.

Algorithmus

• Starten Sie eine Deep First Hunt (DFS) von jedem nicht besuchten Zentrum auf der Karte.

• Während der DFS werden besuchte Hubs markiert und zur laufenden DFS-Pfadliste hinzugefügt.

• Wenn wir auf eine Hinterkante stoßen (die Kante zu einem Hub im aktuellen DFS-Modus), differenzieren wir einen Zyklus und markieren alle Hubs im aktuellen DFS-Modus als Teil des Zyklus.

• Wenn das DFS des Hubs abgeschlossen ist, entfernen Sie es aus der Liste der in Bearbeitung befindlichen DFS-Pfade.

• Nach Abschluss der DFS aller Hubs bleiben die Hubs, die keinem Zyklus angehören, unverändert und wir können sie ausdrucken.

Beispiel

#include <iostream>
#include <vector>

class Graph {
public:
   Graph(int numVertices);
   void addEdge(int src, int dest);
   void DFS();
private:
   void DFSUtil(int v, std::vector<bool>& visited, std::vector<int>& dfsPath);
   int numVertices;
   std::vector<std::vector<int>> adjList;
};

Graph::Graph(int numVertices) : numVertices(numVertices) {
   adjList.resize(numVertices);
}

void Graph::addEdge(int src, int dest) {
   adjList[src].push_back(dest);
}

void Graph::DFSUtil(int v, std::vector<bool>& visited, std::vector<int>& dfsPath) {
   visited[v] = true;
   dfsPath.push_back(v);

   for (int neighbor : adjList[v]) {
      if (!visited[neighbor]) {
         DFSUtil(neighbor, visited, dfsPath);
      }
      else {
         std::cout << "Cycle found: ";
         for (size_t i = 0; i < dfsPath.size(); ++i) {
            if (dfsPath[i] == neighbor) {
               while (i < dfsPath.size()) {
                  std::cout << dfsPath[i] << " ";
                  ++i;
               }
               break;
            }
         }
         std::cout << std::endl;
      }
   }

   dfsPath.pop_back();
}

void Graph::DFS() {
   std::vector<bool> visited(numVertices, false);
   std::vector<int> dfsPath;

   for (int i = 0; i < numVertices; ++i) {
      if (!visited[i]) {
         DFSUtil(i, visited, dfsPath);
      }
   }
}

int main() {
   Graph graph(6);
   graph.addEdge(0, 1);
   graph.addEdge(1, 2);
   graph.addEdge(2, 3);
   graph.addEdge(3, 4);
   graph.addEdge(4, 1);
   graph.addEdge(4, 5);
   
   std::cout << "DFS traversal with cycle detection:\n";
   graph.DFS();

   return 0;
}

Ausgabe

DFS traversal with cycle detection:
Cycle found: 1 2 3 4 

Tarjans stark verbundener Komponentenalgorithmus

Tarjans Berechnung ist eine leistungsstarke Berechnung, mit der alle wichtigen relevanten Teile des Koordinationsdiagramms verfolgt werden. Explizit verwandte Teile sind Teilmengen von Hubs, für die eine Koordination zwischen zwei beliebigen Hubs in der Teilmenge besteht. Ein Hub, der nicht Teil einer eng verwandten Komponente ist, ist nicht Teil eines Zyklus. Indem wir wichtige verwandte Teile finden, können wir Naben identifizieren, die zu keinem Zyklus gehören, und diese ausdrucken

Algorithmus

• Wenden Sie Tarjans Berechnungen auf Ihre Reiseführerkarte an, um den Überblick über alle wichtigen relevanten Teile zu behalten.

• Unterscheiden Sie nach der Verfolgung aller wichtigen zusammenhängenden Teile die Zentren, die für die eng verwandten Teile entscheidend sind.

• Hubs, die nicht Teil eines explizit zugeordneten Widgets sind, gehören zu keiner Schleife und können gedruckt werden.

• Beide Methoden unterscheiden und drucken Zentren, die zu keinem Zyklus im Koordinationsdiagramm gehören. Die DFS-Methode bietet eine einfachere und unkompliziertere Implementierung, während Tarjans Berechnungen komplexer sind, aber zusätzliche Daten zu fokussierten Korrelationsteilen liefern, die für bestimmte diagrammbezogene Aufgaben hilfreich sein können. Die Entscheidung über den Ansatz hängt von den spezifischen Bedürfnissen und dem Kontext der wichtigsten drängenden Probleme ab.

Beispiel

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

class Graph {
   int V;
   vector<vector<int>> adj;
   vector<bool> visited;
   vector<int> disc, low;
   stack<int> st;
   vector<vector<int>> SCCs;
   vector<bool> essentialNodes;

public:
   Graph(int V) : V(V) {
      adj.resize(V);
      visited.resize(V, false);
      disc.resize(V, -1);
      low.resize(V, -1);
      essentialNodes.resize(V, true);
   }

   void addEdge(int u, int v) {
      adj[u].push_back(v);
   }

   void tarjanDFS(int u) {
      static int time = 0;
      disc[u] = low[u] = ++time;
      st.push(u);
      visited[u] = true;

      for (int v : adj[u]) {
         if (disc[v] == -1) {
            tarjanDFS(v);
            low[u] = min(low[u], low[v]);
         } else if (visited[v]) {
            low[u] = min(low[u], disc[v]);
         }
      }

      if (low[u] == disc[u]) {
         vector<int> SCC;
         int v;
         do {
            v = st.top();
            st.pop();
            SCC.push_back(v);
            visited[v] = false;
         } while (v != u);

         SCCs.push_back(SCC);
      }
   }

   void tarjan() {
      for (int i = 0; i < V; ++i) {
         if (disc[i] == -1) {
            tarjanDFS(i);
         }
      }
   }

   void identifyEssentialNodes() {
      for (const vector<int>& SCC : SCCs) {
         for (int v : SCC) {
            for (int u : adj[v]) {
               if (find(SCC.begin(), SCC.end(), u) == SCC.end()) {
                  essentialNodes[u] = false;
               }
            }
         }
      }
   }

   void printEssentialNodes() {
      cout << "Essential Nodes for Each SCC:\n";
      for (int i = 0; i < V; ++i) {
         if (essentialNodes[i]) {
            cout << i << " ";
         }
      }
      cout << endl;
   }
};

int main() {
   Graph g(6);
   g.addEdge(0, 1);
   g.addEdge(1, 2);
   g.addEdge(2, 0);
   g.addEdge(1, 3);
   g.addEdge(3, 4);
   g.addEdge(4, 5);
   g.addEdge(5, 3);

   g.tarjan();
   g.identifyEssentialNodes();
   g.printEssentialNodes();

   return 0;
}

Ausgabe

Essential Nodes for Each SCC:
0 1 2 4 5

Fazit

Diese beiden Methoden lösen das Problem der Identifizierung von Zentren, die zu keinem Zyklus im Koordinationsdiagramm gehören. Die DFS-Methode ist einfach zu implementieren und erfordert nicht viele zusätzliche Informationsstrukturen. Tarjans Berechnungen hingegen liefern zusätzliche Daten zu wichtigen Korrelationsteilen, die in bestimmten Situationen hilfreich sein können.

Die Entscheidung zwischen den beiden Methoden hängt von den spezifischen Voraussetzungen des Problems und den Anforderungen an zusätzliche Daten ab, die periodenunabhängige Differenzierungszentren durchlaufen. Wenn das einzige Ziel im Allgemeinen darin besteht, Hubs zu finden, die zu keinem Zyklus gehören, kann der DFS-Ansatz aufgrund seiner Einfachheit bevorzugt werden. Dennoch können Tarjans Berechnungen ein wichtiges Hilfsmittel sein, wenn eine weitere Untersuchung wichtiger relevanter Teile erforderlich ist. Beide Methoden ermöglichen eine kompetente Gestaltung und können je nach den Eigenschaften des Koordinationsdiagramms und dem gewünschten Ergebnis der Prüfung angepasst werden

Das obige ist der detaillierte Inhalt vonDrucken Sie Knoten in einem gerichteten Graphen, die zu keinem Zyklus gehören. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!