Imprimer des nœuds dans un graphe orienté qui n'appartiennent à aucun cycle

Dans les diagrammes de coordination, l'identification des pôles qui n'appartiennent à aucun cycle est cruciale pour différentes applications. Ces centres constituent la base des sous-graphes acycliques et jouent un rôle important dans la compréhension de la structure générale des graphes. En utilisant des calculs efficaces d'intersection de graphiques, tels que Profundity First Hunt (DFS) ou le calcul de Tarjan de parties étroitement liées, nous pouvons facilement décider et imprimer des hubs qui ne participent à aucune boucle. Ces méthodes assurent la caractérisation des centres sans collaboration circulaire, fournissent des connaissances importantes sur les parties non circulaires des diagrammes et prennent en charge différentes situations de pensée critique liées aux diagrammes.

Méthode à utiliser

• Recherche en profondeur (DFS) avec détection de boucle

• L'algorithme de composants fortement connectés de Tarjan

Recherche en profondeur (DFS) avec détection de boucle

Dans cette approche, nous utilisons le suivi en profondeur (DFS) pour naviguer dans le tableau de coordination et distinguer les cycles en cours de route. Nous marquons les centres visités et conservons une liste afin que les centres puissent être suivis de manière continue par DFS. Si nous rencontrons un bord de fuite (atteignant le bord du hub de manière DFS soutenue), nous différencions un cycle. A la fin du DFS, le centre en cours de DFS sera important pour un cycle. Les hubs qui n'utilisent pas de DFS persistant ne font partie d'aucune boucle et peuvent être imprimés.

Algorithme

• Démarrez une Deep First Hunt (DFS) à partir de chaque centre non visité de la carte.

• Pendant DFS, les hubs visités sont marqués et ajoutés à la liste des chemins DFS en cours.

• Si nous rencontrons un bord arrière (le bord d'un hub dans le mode DFS actuel), nous différencions un cycle et marquons tous les hubs dans le mode DFS actuel comme faisant partie du cycle.

• Lorsque le DFS du hub est terminé, supprimez-le de la liste des chemins DFS en cours.

• Après avoir complété le DFS de tous les hubs, les hubs qui n'appartiennent à aucun cycle resteront inchangés et nous pourrons les imprimer.

Exemple

#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;
}

Sortie

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

L'algorithme de composants fortement connectés de Tarjan

Le calcul de Tarjan est un calcul puissant utilisé pour suivre toutes les parties clés liées du diagramme de coordination. Les parties explicitement liées sont des sous-ensembles de hubs pour lesquels une coordination existe entre deux hubs quelconques du sous-ensemble. Un hub qui ne fait partie d’aucun composant étroitement lié ne fait partie d’aucun cycle. En trouvant les pièces clés associées, nous pouvons identifier les moyeux qui n'appartiennent à aucun cycle et les imprimer

Algorithme

• Appliquez les calculs de Tarjan à votre carte guide pour garder une trace de toutes les parties clés pertinentes.

• Après avoir tracé toutes les parties liées importantes, distinguez les centres qui sont cruciaux pour les parties étroitement liées.

• Les hubs qui ne font partie d'aucun widget explicitement associé n'appartiennent à aucune boucle et peuvent être imprimés.

• Les deux méthodes différencient et impriment les centres qui n'appartiennent à aucun cycle de la grille de coordination. La méthode DFS offre une mise en œuvre plus simple et plus directe, tandis que les calculs de Tarjan sont plus complexes mais fournissent des données supplémentaires sur des parties de corrélation ciblées, ce qui peut être utile pour des tâches spécifiques liées aux graphiques. La décision concernant l’approche dépend des besoins spécifiques et du contexte des principales questions urgentes.

Exemple

#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;
}

Sortie

Essential Nodes for Each SCC:
0 1 2 4 5

Conclusion

Ces deux méthodes résolvent le problème de l'identification des centres qui n'appartiennent à aucun cycle dans l'organigramme de coordination. La méthode DFS est facile à mettre en œuvre et ne nécessite pas beaucoup de structures d'informations supplémentaires. Les calculs de Tarjan, en revanche, fournissent des données supplémentaires sur les éléments clés de la corrélation, ce qui peut être utile dans certaines situations.

La décision entre les deux méthodes dépend des conditions préalables spécifiques du problème et des exigences en matière de données supplémentaires transitant par des centres de différenciation indépendants des périodes. De manière générale, si le seul objectif est de trouver des pôles qui n’appartiennent à aucun cycle, l’approche DFS peut être privilégiée pour sa simplicité. Néanmoins, les calculs de Tarjan peuvent être un outil important si un examen plus approfondi des éléments clés pertinents est nécessaire. Les deux méthodes offrent un arrangement efficace et peuvent être ajustées en fonction des propriétés du tableau de coordination et du résultat souhaité de l'examen.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!