Construire un graphique qui ne contient aucune paire de nœuds adjacents avec la même valeur

Le graphique construit peut être un plan d'action central non dupliqué où deux centres adjacents ne partagent pas la même valeur. Chaque centre représente une valeur unique et les bords de connexion relient les centres sans dupliquer les valeurs. Le diagramme reflète une conception qui donne la priorité à la diversité et à l'unicité, garantissant que les centres adjacents sont toujours distincts les uns des autres. En suivant cette règle, les diagrammes cultivent une représentation ciblée et visuellement unique qui peut être pertinente dans des domaines aussi divers que la planification organisationnelle, la visualisation d'informations ou l'allocation de ressources. Sa structure évite les clusters ennuyeux et favorise des connexions dynamiques et diverses entre les centres, contribuant à une représentation graphique plus pédagogique et engageante.

Méthode à utiliser

• Construction récursive

Construction récursive

Dans cette technique, le graphique est construit à l'aide de fonctions récursives. Le centre d'exécution, sa valeur et la liste de valeurs sont transmis comme limites de la fonction. Cette fonction consiste à ajouter un bord avec une valeur alternative à n'importe quel hub actuel à chaque étape. Si tel est le cas, cela ajoute un avantage et nécessite des valeurs ultérieures de manière récursive. S'il ne parvient pas à se connecter à un hub approprié, il revient au hub principal et essaie d'autres valeurs.

Algorithme

• Commencez par dessiner un graphique clair et répertoriez les valeurs requises pour chaque centre du graphique.

• Développez une fonction récursive appelée "constructGraph" qui a trois limites : le centre actuel, sa valeur et une liste des masses restantes.

• Enregistré dans la fonction « constructGraph » :

• a - N'oubliez pas les centres et incitations en cours associés au thème

• b - Insistez sur le centre de persistance du graphique pour voir si des valeurs qu'il contient sont différentes de la valeur du centre de persistance.

• a - Si nous trouvons un hub avec une valeur alternative, ajoutez un bord entre le hub actuel et le hub actuel.

• Avec le centre continu comme centre de départ, pour chaque valeur encore présente dans la liste, appelez la fonction "constructGraph" à plusieurs reprises

Exemple

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

const int N = 5; // Number of nodes in the graph

class Graph {
public:
   vector<int> graph[N];

   void constructGraph(int currentNode, int currentValue, vector<int>& 
remainingValues) {
      graph[currentNode].push_back(currentValue);
      for (int i = 0; i < N; ++i) {
         if (i != currentNode) {
            for (int j = 0; j < remainingValues.size(); ++j) {
               int nextValue = remainingValues[j];
               remainingValues.erase(remainingValues.begin() + j);
               constructGraph(i, nextValue, remainingValues);
               remainingValues.insert(remainingValues.begin() + j, nextValue);
            }
         }
      }
   }
};

int main() {
   Graph g;
   vector<int> values = {1, 2, 3};
   g.constructGraph(0, 0, values);

   for (int i = 0; i < N; ++i) {
      cout << "Node " << i << ": ";
      for (int neighbor : g.graph[i]) {
         cout << neighbor << " ";
      }
      cout << endl;
   }

   return 0;
}

Sortie

Node 0: 0 2 3 3 2 3 2 3 2 1 3 3 1 3 1 3 1 1 2 2 1 2 1 2 1 2 3 3 2 3 2 3 2 1 3 
3 1 3 1 3 1 1 2 2 1 2 1 2 1 2 3 3 2 3 2 3 2 1 3 3 1 3 1 3 1 1 2 2 1 2 1 2 1 2 
3 3 2 3 2 3 2 1 3 3 1 3 1 3 1 1 2 2 1 2 1 2 1 
Node 1: 1 3 2 3 2 3 2 3 2 2 3 1 3 1 3 1 3 1 3 2 1 2 1 2 1 2 1 3 2 2 3 3 2 3 2 
3 1 1 3 3 1 3 1 2 1 1 2 2 1 2 1 3 2 2 3 3 2 3 2 3 1 1 3 3 1 3 1 2 1 1 2 2 1 2 
1 3 2 2 3 3 2 3 2 3 1 1 3 3 1 3 1 2 1 1 2 2 1 2 1 
Node 2: 3 2 2 3 3 2 3 2 3 1 1 3 3 1 3 1 2 1 1 2 2 1 2 1 1 3 2 3 2 3 2 3 2 2 3 
1 3 1 3 1 3 1 3 2 1 2 1 2 1 2 1 3 2 3 2 2 3 3 2 3 1 3 1 1 3 3 1 2 1 2 1 1 2 2 
1 3 2 3 2 2 3 3 2 3 1 3 1 1 3 3 1 2 1 2 1 1 2 2 1 
Node 3: 3 2 3 2 2 3 3 2 3 1 3 1 1 3 3 1 2 1 2 1 1 2 2 1 3 2 3 2 2 3 3 2 3 1 3 
1 1 3 3 1 2 1 2 1 1 2 2 1 1 3 2 3 2 3 2 3 2 2 3 1 3 1 3 1 3 1 3 2 1 2 1 2 1 2 
1 3 2 3 2 3 2 2 3 3 1 3 1 3 1 1 3 2 1 2 1 2 1 1 2 
Node 4: 3 2 3 2 3 2 2 3 3 1 3 1 3 1 1 3 2 1 2 1 2 1 1 2 3 2 3 2 3 2 2 3 3 1 3 
1 3 1 1 3 2 1 2 1 2 1 1 2 3 2 3 2 3 2 2 3 3 1 3 1 3 1 1 3 2 1 2 1 2 1 1 2 1 3 
2 3 2 3 2 3 2 2 3 1 3 1 3 1 3 1 3 2 1 2 1 2 1 2 1 

Conclusion

N'importe laquelle de ces trois stratégies peut être utilisée pour créer un graphique qui n'a pas de centres adjacents ayant la même valeur. La méthode choisie dépend des prérequis spécifiques, de la structure ouverte de l'information et de la complexité du diagramme à venir. Chaque méthode fournit des conseils pratiques pour créer de tels diagrammes et peut être étendue pour traiter des situations plus complexes.

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!