Écrit en C++ au niveau K, battez le boss de niveau A avec la puissance maximale du niveau N, en augmentant la puissance de B

Dans le monde du développement de jeux, l'optimisation des capacités et des progrès des joueurs est un aspect important de la création d'expériences engageantes et stimulantes. Une mécanique courante consiste à vaincre des boss à différents niveaux, chaque victoire accordant au joueur une augmentation de puissance. Dans cet article, nous allons explorer comment calculer la puissance maximale qu'un joueur peut atteindre dans N niveaux étant donné un niveau de puissance initial K, en tenant compte de l'incrément de puissance B[i]] gagné en battant un boss au niveau A[i]]. Nous approfondirons la syntaxe, les algorithmes et démontrerons deux approches différentes avec des exemples complets de code exécutable en C++.

Grammar

Avant d'approfondir ce sujet. Nous devons décrire et clarifier la syntaxe impliquée dans l'utilisation de la méthode choisie dans les prochaines illustrations de code. Une fois cette base établie, nous pouvons développer une compréhension plus complète de cette technologie spécifique. -

int calculateMaximumPower(int N, int K, int A[], int B[]);

Algorithme

Pour déterminer la puissance maximale atteignable dans N niveaux, nous pouvons suivre l'algorithme étape par étape suivant −

• Initialiser une variable maxPower pour stocker la puissance maximale obtenue.

• Réglez le courant variable Power au niveau de puissance initial K.

• Itérer chaque niveau, i, de 0 à N-1 −

• Si vaincre un boss au niveau A[i] entraîne un incrément de puissance de B[i], mettre à jour en ajoutant B[i] currentPower .

• Vérifiez si la puissance actuelle est supérieure à la puissance maximale. Si tel est le cas, mettez à jour maxPower avec la nouvelle valeur.

• Renvoyer maxPower comme puissance maximale réalisable dans N niveaux.

Méthode 1 : Programmation dynamique

Une solution possible à ce problème consiste à utiliser la programmation dynamique. Pour stocker efficacement la puissance maximale réalisable pour chaque niveau, initialisez un tableau nommé dp de taille N+1.

Exemple

#include <iostream>
#include <algorithm>

int calculateMaximumPower(int N, int K, int A[], int B[]) {
   int dp[N + 1];
   dp[0] = K;

   for (int i = 1; i <= N; i++) {
      dp[i] = dp[i - 1];
      for (int j = 0; j < i; j++) {
         if (A[j] <= i)
            dp[i] = std::max(dp[i], dp[i - A[j]] + B[j]);
      }
   }

   return dp[N];
}

int main() {
   // Example usage
   int N = 5;
   int K = 10;
   int A[] = {2, 3, 1, 4, 2};
   int B[] = {5, 3, 2, 7, 4};

   int maxPower = calculateMaximumPower(N, K, A, B);
   
   std::cout << "Maximum power achievable: " << maxPower << std::endl;

   return 0;
}

Sortie

Maximum power achievable: 22

Explication

Dans cette approche, nous utilisons la programmation dynamique pour calculer la puissance maximale réalisable dans N niveaux. Nous créons un tableau dp de taille N+1 pour stocker la puissance maximale réalisable à chaque niveau. Tout d’abord, notre tableau de programmation dynamique dp[0] commence par la valeur K, qui représente le niveau de puissance initial. Ensuite, notre méthode pour chaque i-ème niveau de 1 jusqu'à N implique de mettre à jour ce tableau comme suit : Nous récupérons et stockons en mémoire la puissance maximale qui peut être obtenue après avoir vaincu le capitaine dans un niveau précédent. Un patron en position A[j] provoque correctement une augmentation du pouvoir de quelqu'un de B[j] (où j s'étend sur les valeurs 0 à i-1). En utilisant max(dp[i - A[j]] + B [j],dp [i]). Nous pouvons mettre à jour la valeur de dp[i] afin que son intensité maximale précédente devienne ce que reflète le résultat actuel. Enfin, nous renvoyons dp[N] comme puissance maximale pouvant être obtenue parmi N niveaux. En raison des boucles imbriquées, la complexité temporelle de cette méthode est O(N^2).

Méthode 2 : Utiliser un algorithme glouton

L'utilisation d'un algorithme glouton peut fournir une solution efficace. Cela nécessite de pratiquer une bonne prise de décision en triant les niveaux en augmentant le niveau du boss A[i], puis de parcourir chaque étape du jeu et d'augmenter la puissance uniquement lorsque cela permet de vaincre un boss spécifique.

Exemple

#include <iostream>
#include <algorithm>

bool compareLevels(std::pair<int, int> boss1, std::pair<int, int> boss2) {
   return boss1.first < boss2.first;
}

int calculateMaximumPower(int N, int K, int A[], int B[]) {
   std::pair<int, int> bosses[N];
   for (int i = 0; i < N; i++) {
      bosses[i] = std::make_pair(A[i], B[i]);
   }

   std::sort(bosses, bosses + N, compareLevels);

   int currentPower = K;
   int maxPower = K;
   int index = 0;

   for (int i = 1; i <= N; i++) {
      while (index < N && bosses[index].first <= i) {
         currentPower += bosses[index].second;
         index++;
      }

      maxPower = std::max(maxPower, currentPower);
   }
   return maxPower;
}

int main() {
   // Example usage
   int N = 5;
   int K = 10;
   int A[] = {2, 3, 1, 4, 2};
   int B[] = {5, 3, 2, 7, 4};

   int maxPower = calculateMaximumPower(N, K, A, B);

   std::cout << "Maximum power achievable: " << maxPower << std::endl;

   return 0;
}

Sortie

Maximum power achievable: 31

Explication

Dans l'approche de l'algorithme glouton, nous trions d'abord les niveaux selon l'ordre croissant du niveau de boss A[i]. Ensuite, nous parcourons chaque niveau de 1 à N. Nous maintenons une variable currentPower pour suivre le niveau de puissance actuel et une variable maxPower pour stocker la puissance maximale atteinte jusqu'à présent. À partir du niveau de capacité initial K, nous vérifions si vaincre le boss du niveau actuel augmentera la capacité. Si tel est le cas, nous mettons à jour currentPower en ajoutant l'incrément de puissance B[i]. Nous continuons ce processus jusqu'à ce que tous les boss jusqu'au niveau actuel soient vaincus. Chaque fois que currentPower dépasse maxPower, nous mettons à jour maxPower. À la fin de l’itération, maxPower contiendra la puissance maximale réalisable parmi N niveaux. En raison de l’opération de tri, la complexité temporelle de cette approche est O(N log N).

Conclusion

Notre article explique comment déterminer la puissance maximale atteignable au niveau N - en partant d'un niveau d'énergie brute K et en obtenant des récompenses énergétiques supplémentaires après avoir vaincu des boss spécifiques à une étape. Nous proposons deux options : utiliser la programmation dynamique ou utiliser un algorithme glouton.

Bien que les deux méthodes produisent des résultats réalisables, il existe quelques différences subtiles dans la mise en œuvre. Les développeurs qui acquièrent ces compétences et les intègrent dans le développement de jeux via la programmation C++ construiront des systèmes de progression satisfaisants qui engageront les utilisateurs dans une expérience de jeu remplie de riches récompenses.

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!