La recherche en largeur n'utilise pas de files d'attente

Breadth First, Look (BFS) est un calcul de traversée de graphique utilisé pour étudier le centre en mouvement en largeur dans un graphique. L'utilisation normale de BFS utilise la structure d'informations de ligne pour suivre les hubs entrants. Quoi qu’il en soit, il est concevable d’exploiter d’autres structures d’informations pour effectuer des BFS sans utiliser de câbles explicites.

Une autre façon d'implémenter BFS sans câbles consiste à utiliser deux clusters ou enregistrements : un pour le hub du niveau actuel étudié et un pour le hub du niveau suivant à étudier. Initialement, la liste de niveaux actuelle contient le centre source.

Le calcul met d'abord en évidence la liste de niveaux actuelle et va à chaque hub. Pour chaque hub traversé, ses hubs adjacents sont inspectés. Si un hub adjacent n'est pas visité, il est marqué comme visité et ajouté à la liste des autres niveaux. Le handle continuera jusqu'à ce que tous les hubs de la liste de niveaux actuelle aient été transmis.

Une fois la liste de niveaux actuelle entièrement parcourue, le calcul continue vers une autre liste de niveaux et hache à nouveau le chemin vers le hub et accède à la liste de niveaux suivante. Cette préparation se poursuit jusqu'à ce qu'il n'y ait plus de nœuds non visités.

Méthode à utiliser

Approche axée sur la largeur d'abord

Approche axée sur la largeur d'abord

L'algorithme BFS part du hub source, étudie ses voisins et est plus récemment passé à un autre niveau de voisins. Utilisez la structure d’informations de ligne pour suivre les hubs que vous visitez. À chaque cycle, le calcul visite un hub, le marque comme terminé et met en file d'attente les hubs adjacents non visités. Cette préparation se poursuivra jusqu'à ce que tous les centres accessibles aient été visités.

Le code initialise un vecteur adj pour représenter la liste infectieuse du graphique. Chaque fichier de vecteurs est comparé à un centre et chaque valeur enregistrée contient des centres adjacents. Un parcours BFS est effectué par une tâche BFS, qui prend le hub source, le nombre de hubs N, le vecteur vis passant par le hub, un dp séparé et le vecteur v utilisé pour garder une trace des hubs à visiter. Le travail bfsTraversal initialise le hub disparu et supprime les vecteurs, puis appelle le travail BFS pour effectuer le parcours.

Algorithme

• Créez une représentation de liste d'infections du graphique.

• Initialisez une ligne pour stocker le hub auquel accéder.

• Initialisez le cluster en voie de disparition pour suivre les nœuds qui disparaissent.

• Initialisez le cluster de suppression pour stocker le contenu supprimé du hub source sur chaque hub. Définissez le délimiteur du hub source sur 0.

• Mettez le hub source en file d'attente et vérifiez s'il a été consulté.

• Bien que le pipeline ne puisse pas être purifié, veuillez procéder comme suit :

• Supprimez le hub en tête de file d'attente. Pour chaque hub voisin qui a été retiré de la file d'attente et non encore traversé, procédez comme suit : Mettez le hub voisin en file d'attente. Marquez les hubs adjacents comme visités. Suppression du hub voisin mis à jour pour supprimer la suppression du hub de la file d'attente (également 1).

• Répétez l'étape 6 jusqu'à ce que la ligne soit vide.

• Une fois le parcours BFS terminé, un cluster distinct contiendra les intervalles allant du nœud source à tous les autres centres du graphique.

• (Facultatif) Vous pouvez également suivre le hub parent de chaque hub dans une traversée BFS pour passer du hub source à tous les autres hubs de la manière la plus simple.

Exemple

#include <iostream>
#include <queue>
#include <unordered_set>
using namespace std;

void bfsTraversal(int adjacencyList[][2], int numVertices, int source) {
   bool visited[numVertices + 1] = {false};
   int distances[numVertices + 1] = {0};

   queue<int> vertices;
   vertices.push(source);
   visited[source] = true;

   while (!vertices.empty()) {
      int node = vertices.front();
      cout << node << ", ";
      vertices.pop();

      for (int i = 0; i < 2; i++) {
         int next = adjacencyList[node][i];
            
         if (!visited[next]) {
            vertices.push(next);
            distances[next] = distances[node] + 1;
            visited[next] = true;
         }
      }
   }
}

int main() {
    int adjacencyList[][2] = {{0, 0}, {1, 2}, {3, 4}, {0, 0}, {0, 0}};
    int numVertices = 4;
    int source = 2;

    bfsTraversal(adjacencyList, numVertices, source);

    return 0;
}

Sortie

2,3,4,0

Exemple

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

void bfsTraversal(vector<vector<int>>& adjacencyList, int N, int source) {
    vector<bool> visited(N + 1, false);
    vector<int> distances(N + 1, 0);
    vector<int> vertices;

    vertices.push_back(source);
    visited[source] = true;

    int curr = 0;
    while (curr < vertices.size()) {
        int node = vertices[curr];
        cout << node << ", ";

        for (int i = 0; i < adjacencyList[node].size(); i++) {
            int next = adjacencyList[node][i];

            if (!visited[next]) {
                vertices.push_back(next);
                distances[next] = distances[node] + 1;
                visited[next] = true;
            }
        }

        curr++;
    }

    cout << "\nDistances from source " << source << ":\n";
    for (int i = 1; i <= N; i++) {
        cout << "Node " << i << ": " << distances[i] << endl;
    }
}

int main() {
    int N = 8;
    vector<vector<int>> adjacencyList(N + 1);
    adjacencyList[0] = {1, 2};
    adjacencyList[1] = {2};
    adjacencyList[2] = {0, 3};
    adjacencyList[3] = {3};
    adjacencyList[4] = {5};
    adjacencyList[5] = {6, 7};
    adjacencyList[6] = {};
    adjacencyList[7] = {};
    adjacencyList[8] = {};

    int source = 5;

    bfsTraversal(adjacencyList, N, source);

    return 0;
}

Sortie

5, 6, 7, 
Distances from source 5:
Node 1: 0
Node 2: 0
Node 3: 0
Node 4: 0
Node 5: 0
Node 6: 1
Node 7: 1
Node 8: 0

Conclusion

Cet article explique les calculs de recherche en largeur d'abord (BFS) sans utiliser de structures d'informations sur les lignes. Les calculs BFS sont généralement utilisés pour parcourir un graphique étape par étape à partir d'un centre source donné. En règle générale, un itinéraire est utilisé pour stocker les hubs vers lesquels voyager. Quoi qu’il en soit, cet article examine une approche alternative qui utilise des listes ou des clusters de base pour stocker le niveau suivant de hubs.

Cette utilisation sélective complète l'étude en profondeur des graphiques. Cet article retrace les étapes du calcul BFS, telles que l'initialisation des enregistrements infectieux, la gestion des clusters de référence et de séparation et l'utilisation de cercles pour mettre l'accent sur les niveaux centraux. Il fournit également des instructions en code C illustrant le parcours BFS sans utiliser une seule ligne. Le code étudie avec précision le graphique, imprime la permutation de traversée BFS et calcule la distance entre le hub source et tous les autres nœuds. Dans l'ensemble, cet article fournit une explication claire et une utilisation réalisable des calculs BFS sans utiliser de lignes, démontrant une approche alternative pour naviguer dans les graphiques en largeur.

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!