Calculer toutes les permutations d'entiers qui forment un graphe acyclique selon des conditions données

Pour compter les étapes dans un entier N, former un graphe acyclique nécessite d'étudier tous les changements possibles et de vérifier s'ils forment un graphe acyclique selon les conditions données. Ces conditions peuvent être liées à la structure des graphiques de coordination formés par les changements, où l'absence de cycles indique une acyclicité. Ce problème implique des concepts de la théorie des graphes et peut être résolu par une recherche en profondeur ou une programmation dynamique. La recherche en profondeur fonctionne en examinant chaque étape de manière récursive, et la programmation dynamique optimise les boucles en stockant les résultats intermédiaires. Le nombre d'étapes valides comptées à la fin montre le nombre de manières au sein d'un entier N qui peuvent être organisées en un graphe acyclique satisfaisant des conditions prédéterminées.

Méthode à utiliser

• Recherche en profondeur d'abord (DFS)

• Programmation dynamique

Recherche en profondeur d'abord (DFS)

Dans la méthode DFS de génération de regroupements avec une opération donnée, on part du nombre donné et on recalcule jusqu'à ce que la valeur 1 soit atteinte. On procède de la manière suivante : si le nombre est bien 2, on le divise par 2 ; si c'est un nombre impair, on le multiplie par 3 et on ajoute 1. Nous mettons à jour les chiffres pour refléter les résultats inutilisés et les ajoutons à la série. Ce processus se poursuit jusqu'à ce que le nombre atteigne 1. La séquence résultante représente une séquence Collatz répétitive pour un numéro de départ donné. Cette approche nous permet de suivre la progression des nombres à mesure qu'ils changent grâce à des calculs répétés, de révéler des modèles et de considérer le comportement des séquences de Collatz. Il fournit une méthode simple et reproductible pour générer des séquences et analyser les caractéristiques fascinantes de cette merveille mathématique.

Algorithme

• Choisissez un hub de départ pour commencer votre voyage

• Marquez les centres comme visités pour surveiller quels centres ont enquêté de manière proactive.

• Visitez les voisins non visités du nœud central en cours (le cas échéant). Pour déterminer les voisins d'un nœud central en cours, vous avez vraiment besoin de connaître une description infectieuse du graphe (par exemple, une liste de proximité ou un cadre de proximité)

• En supposant qu'il y ait des voisins non visités, choisissez-en un et répétez les étapes 2 à 4 de ce voisin (de manière récursive)

• En supposant qu'il n'y a pas de voisins non visités, retournez au centre précédent et poursuivez l'enquête à partir de ce point (si possible). Cette étape est cruciale pour explorer tous les chemins potentiels dans le graphique

• Re-hachez les étapes 2 à 5 jusqu'à ce que tous les nœuds centraux du graphique aient été visités. Si le graphique n'est pas connecté (contient plusieurs parties), vous devrez peut-être effectuer une recherche en profondeur d'abord (DFS) à partir d'un nœud central non visité.

La traduction chinoise de

Exemple

est :

Exemple

#include <iostream>
#include <vector>

using namespace std;

void dfs(int node, vector<vector<int>>& graph, vector<bool>& visited) {
   visited[node] = true;
   cout << "Visited hub: " << node << endl;
   for (int neighbor : graph[node]) {
      if (!visited[neighbor]) {
         cout << "Moving to neighbor: " << neighbor << endl;
         dfs(neighbor, graph, visited);
      }
   }
}

int main() {
   vector<vector<int>> graph = {
      {1, 2},
      {0, 2, 3},
      {0, 1, 3},
      {1, 2, 4},
      {3}
   };
   int hubs = graph.size();
   vector<bool> visited(hubs, false);
   int startingHub = 0;
   cout << "DFS Traversal starting from hub " << startingHub << ":" << endl;
   dfs(startingHub, graph, visited);
   return 0;
}

Sortie

DFS Traversal starting from hub 0:
Visited hub: 0
Moving to neighbor: 1
Visited hub: 1
Moving to neighbor: 2
Visited hub: 2
Moving to neighbor: 3
Visited hub: 3
Moving to neighbor: 4
Visited hub: 4

Programmation dynamique

Dans cette approche, nous pouvons utiliser la programmation dynamique pour calculer efficacement le nombre d'étapes acycliques pour atteindre N. Nous définirons une table DP, où dp[i] représente le nombre de transitions non cycliques se terminant par le nombre I.

Algorithme

• Enquêtez sur le problème et décidez s'il peut être décomposé en sous-problèmes plus petits. Si résoudre plusieurs fois le même sous-problème s’avère inefficace, la programmation dynamique peut améliorer la solution en mémorisant les solutions aux sous-problèmes.

• Exprimer l'arrangement d'un problème plus vaste comme l'arrangement de ses sous-problèmes. Cette connexion en double est la clé pour résoudre le problème en utilisant DP.

• Compte tenu des connexions répétées, réalisez un tableau ou un affichage pour stocker les réponses aux sous-questions. Cela évitera une double comptabilisation.

• Remplissez le formulaire en commençant par le plus petit sous-problème, généralement selon une approche ascendante, ou en utilisant la mémorisation pour stocker et récupérer la solution dans un processus récursif

• Lorsque tous les sous-problèmes sont résolus, séparez l'arrangement final du tableau DP ou de l'affichage mémorisé.

La traduction chinoise de

Exemple

est :

Exemple

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

int knapsackHelper(vector<vector<int>>& dp, vector<int>& weights, vector<int>& values, int n, int capacity) {
   if (n == 0 || capacity == 0) {
      return 0;
   }

   if (dp[n][capacity] != -1) {
      return dp[n][capacity];
   }

   if (weights[n - 1] <= capacity) {
      dp[n][capacity] = max(values[n - 1] + knapsackHelper(dp, weights, values, n - 1, capacity - weights[n - 1]),
                      knapsackHelper(dp, weights, values, n - 1, capacity));
   } else {
      dp[n][capacity] = knapsackHelper(dp, weights, values, n - 1, capacity);
   }

   return dp[n][capacity];
}

int knapsack(vector<int>& weights, vector<int>& values, int capacity) {
   int n = weights.size();
   vector<vector<int>> dp(n + 1, vector<int>(capacity + 1, -1));
   return knapsackHelper(dp, weights, values, n, capacity);
}

int main() {
   vector<int> weights = {10, 20, 30};
   vector<int> values = {60, 100, 120};
   int capacity = 50;
   cout << "Maximum value in Knapsack: " << knapsack(weights, values, capacity) << endl;
   return 0;
}

Sortie

Maximum value in Knapsack: 220

Conclusion

Les étapes de calcul de la manière dont les graphes acycliques peuvent être formés impliquent l'étude de différents arrangements d'entiers pour s'assurer qu'ils satisfont à une condition donnée. DFS explore les étapes de manière récursive, tandis que DP améliore la boucle grâce à la mémorisation. Ces deux méthodes fournissent des moyens importants pour résoudre ce problème. Le choix de la méthode dépend des contraintes et de la taille de N. Grâce à ces méthodes, nous pouvons trouver efficacement le nombre d’étapes légales, nous aidant ainsi à comprendre la manière dont les nombres peuvent former des graphiques acycliques selon des conditions prédéterminées.

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!