Imprimer le degré de chaque nœud dans la séquence Prufer donnée

Imprimez le degré de chaque centre dans la permutation Prufer donnée, en vous préparant à mettre en évidence et à compter les événements pour chaque nœud à travers la permutation. En traçant la récursion pour chaque nœud, nous déterminerons le degré de ce centre dans l'arbre étiqueté correspondant. Ces données fournissent un aperçu du réseau et de la structure de l'arborescence. En imprimant le degré de chaque moyeu, vous pouvez analyser la transmission et différencier les moyeux nécessaires. Cet examen fait une différence dans la compréhension des propriétés et des caractéristiques de l'arbre initial représenté sur la base de l'arrangement Prufer.

Méthode à utiliser

• Méthode de comptage de fréquence

• Représentation de liste de contiguïté

Méthode de comptage de fréquence

La méthode de comptage de fréquence consistant à imprimer le degré de chaque hub à partir d'un arrangement Prufer donné implique de compter les événements pour chaque hub afin de déterminer son degré. Pour mettre en œuvre cette approche, un dictionnaire ou cluster est initialisé pour stocker les fréquences des centres. Répétez l’arrangement Prufer et augmentez le nombre de chaque hub expérimenté. Le nombre de chaque hub indique son degré dans l'arborescence des balises. Enfin, les degrés de tous les moyeux sont imprimés sur la base de contrôles répétés. Cette méthode fournit un moyen clair d’analyser la répartition des degrés de réseau et de moyeu au sein de l’arrangement Prufer et d’obtenir les caractéristiques structurelles du premier arbre.

Algorithme

• Initialisez une référence de mot clair ou un cluster pour stocker la fréquence des nœuds.

• Parcourez chaque composant "centre" de la séquence Prufer.

• Vérifiez si "hub" existe dans le dictionnaire ou le tableau.

• S'il est présent, augmentez son nombre de 1.

• S'il n'est pas présent, incluez-le dans une référence de mot ou un cluster avec un compte initial de 1.

• Une fois la boucle terminée, vous pouvez obtenir la fréquence de chaque centre de la séquence Prufer.

• Parcourez chaque paire clé-valeur dans une référence de mot ou un tableau.

• Les clés se rapportent au centre, tandis que l'estime de soi se rapporte à la quantité ou au degré dans l'arbre des marqueurs.

• Imprimez le centre de chaque paire clé-valeur et son degré de comparaison.

• Les degrés de moyeu imprimés illustrent leur degré spécifique dans l’arbre des étiquettes.

Exemple

#include <iostream>
#include <vector>

struct HubFrequency {
   int hub;
   int frequency;
};

void countFrequencies(const std::vector<int>& pruferSequence) {
   std::vector<HubFrequency> frequencyVector;

   for (int hub : pruferSequence) {
      bool found = false;
      for (HubFrequency& hf : frequencyVector) {
         if (hf.hub == hub) {
            hf.frequency++;
            found = true;
            break;
         }
      }

      if (!found) {
         frequencyVector.push_back({hub, 1});
      }
   }

   for (const HubFrequency& hf : frequencyVector) {
      std::cout << "Hub: " << hf.hub << ", Degree: " << hf.frequency << std::endl;
   }
}

int main() {
   std::vector<int> pruferSequence = {1, 2, 3, 1, 3};
   countFrequencies(pruferSequence);

   return 0;
}

Sortie

Hub: 1, Degree: 2
Hub: 2, Degree: 1
Hub: 3, Degree: 2

Représentation de liste de contiguïté

La méthode de représentation de liste de contiguïté consiste à modifier le regroupement Prufer en structure d'information de liste de contiguïté. Initialisez une liste de contiguïté effacée et pour chaque composant de la séquence Prufer, ajoutez une section à la liste affichant les voisins de ce nœud. Lors de la création de votre liste de contiguïté, gardez une trace de la fréquence de chaque hub. Enfin, le centre ayant le taux de redoublement le plus élevé dans la liste de contiguïté est identifié et comparé au centre ayant le diplôme le plus élevé du groupe Prufer. Cette approche nous permet d'exploiter la structure des listes de contiguïté et les données récursives déduites des groupements Prufer pour maximiser la compétence dans la détermination des hubs.

Algorithme

• Initialisez une liste de contiguïté vide et effacez le compteur de doublons.

• Parcourez chaque composant de la séquence Prufer :

• a. Incrémentez le compteur de répétitions du nœud actuel.

• b. Inclut le hub actuel comme voisin du hub mentionné dans la séquence.

• Trouvez le centre avec la fréquence de répétition la plus élevée dans le compteur de répétitions. Ce hub est comparé au hub ayant le plus grand degré.

• Rétablissez le moyeu de roue au maximum.

Exemple

#include <iostream>
#include <vector>
#include <unordered_map>

// Function to find the hub with the highest recurrence
int findHighestRecurrence(const std::unordered_map<int, int>& recurrenceCounter) {
   int highestRecurrence = 0;
   int hubWithHighestRecurrence = -1;

   for (const auto& entry : recurrenceCounter) {
      int hub = entry.first;
      int recurrence = entry.second;

      if (recurrence > highestRecurrence) {
         highestRecurrence = recurrence;
         hubWithHighestRecurrence = hub;
      }
   }

   return hubWithHighestRecurrence;
}

// Function to construct adjacency list from Prufer sequence
std::vector<std::vector<int>> constructAdjacencyList(const std::vector<int>& pruferSequence) {
   std::unordered_map<int, int> recurrenceCounter;
   std::vector<std::vector<int>> adjacencyList(pruferSequence.size() + 2);

   for (int hub : pruferSequence) {
      recurrenceCounter[hub]++;
      adjacencyList[hub].push_back(findHighestRecurrence(recurrenceCounter));
      adjacencyList[findHighestRecurrence(recurrenceCounter)].push_back(hub);
   }

   recurrenceCounter[findHighestRecurrence(recurrenceCounter)]++;

   return adjacencyList;
}

int main() {
   // Example Prufer sequence: {1, 3, 4, 2}
   std::vector<int> pruferSequence = {1, 3, 4, 2};
   std::vector<std::vector<int>> adjacencyList = constructAdjacencyList(pruferSequence);

   // Print the constructed adjacency list
   for (int i = 1; i < adjacencyList.size(); i++) {
      std::cout << "Node " << i << " connects to: ";
      for (int j = 0; j < adjacencyList[i].size(); j++) {
         std::cout << adjacencyList[i][j] << " ";
      }
      std::cout << std::endl;
   }

   return 0;
}

Sortie

Node 1 connects to: 1 1 
Node 2 connects to: 2 2 
Node 3 connects to: 3 3 
Node 4 connects to: 4 4 
Node 5 connects to: 

Conclusion

Cet article illustre comment imprimer le degré de chaque centre dans un groupement Prufer donné en utilisant deux méthodes différentes : la méthode de comptage récursif et la méthode de représentation par liste de contiguïté. Les méthodes de comptage répété impliquent de compter les événements dans chaque centre d'un groupe pour déterminer leur étendue. La méthode de représentation par liste de contiguïté développe des listes de contiguïté basées sur des permutations et suit la répétition de chaque pôle pour découvrir le pôle présentant le degré le plus remarquable. Cet article fournit des descriptions en code C des deux méthodes et explique leur utilisation. En imprimant les degrés de hub, nous pouvons analyser la structure tissulaire et identifier les hubs critiques dans la représentation de l’arrangement de Prufer.

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!