Written in C++ in level K, defeat the level A boss with the maximum power of level N, increasing the power by B

In the world of game development, optimizing player abilities and progression is an important aspect of creating engaging and challenging experiences. A common mechanic involves defeating bosses at different levels, with each victory granting the player a power increase. In this article we will explore how to calculate the maximum power a player can achieve in N levels given an initial power level K, taking into account the power increment B[i]] gained by defeating a boss at level A[i]]. We'll delve into the syntax, algorithms, and demonstrate two different approaches with complete executable code examples in C.

Grammar

Before exploring this topic further. We must outline and clarify the syntax involved in using the chosen method in the upcoming code illustrations. Once this foundation is established, we can develop a more complete understanding of this specific technology. -

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

Algorithm

To determine the maximum power achievable in N levels, we can follow the following step-by-step algorithm −

• Initialization A variable maxPower is used to store the maximum power obtained.

• Set the variable currentPower to the initial power level K.

• Iterate each level, i, from 0 to N-1 −

• If the boss of level A[i] is defeated, the power will increase. The quantity is B[i], then currentPower is updated by adding B[i].

• Check whether the current power is greater than the maximum power. If so, update maxPower with the new value.

• Return maxPower as the maximum achievable power in N levels.

Method 1: Dynamic Programming

A feasible solution to this problem is to utilize dynamic programming. To efficiently store the maximum achievable power for each level, initialize an array named dp with size N 1.

Example

#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;
}

Output

Maximum power achievable: 22

Explanation

In this approach, we utilize dynamic programming to calculate the maximum power achievable in N levels . We create an array dp of size N 1 to store the maximum power achievable at each level. First, our dynamic programming array dp[0] starts with the K value, which represents the initial power level. Moving on, our method for each i-th level from 1 all the way up to N involves updating this array as follows: We retrieve and store into memory the maximum power that can be obtained after defeating the captain in an earlier level. A boss at position A[j], correctly causes someone's power to increase by B[j] (where j spans the values ​​0 to i-1). By using max(dp[i - A[j]] B [j],dp [i]). We can update the value of dp[i] so that its previous maximum intensity becomes what the current result reflects. Finally, we return dp[N] as the maximum power obtainable among N levels. Due to the nested loops, the time complexity of this method is O(N^2).

Method 2: Using the Greedy Algorithm

Using the greedy algorithm may provide an efficient solution. This requires practicing good decision-making by sorting the levels by increasing the boss level A[i], then iterating through each stage of the game and only increasing power when it helps defeat a specific boss.

Example

#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;
}

Output

Maximum power achievable: 31

Explanation

In the method of greedy algorithm, we first perform the rankings according to the ascending order of the boss level A[i] Sort. Then we iterate through each level from 1 to N. We maintain a currentPower variable to track the current power level, and a maxPower variable to store the maximum power achieved so far. Starting from the initial ability level K, we check whether defeating the boss of the current level will increase the ability. If so, we update currentPower by adding the power increment B[i]. We continue this process until all bosses up to the current level are defeated. Whenever currentPower exceeds maxPower, we update maxPower. At the end of the iteration, maxPower will contain the maximum achievable power among N levels. Due to the sorting operation, the time complexity of this approach is O(N log N).

Conclusion

Our article discussed how to determine the peak power achievable in level N - starting from the original energy level K and gaining incremental energy rewards after defeating stage-specific bosses. We propose two options: use dynamic programming or use a greedy algorithm.

While both methods produce workable results, there are some subtle differences in implementation. Developers who learn these skills and incorporate them into game development through C programming will build satisfying progression systems that engage users in a game experience filled with rich rewards.

The above is the detailed content of Written in C++ in level K, defeat the level A boss with the maximum power of level N, increasing the power by B. For more information, please follow other related articles on the PHP Chinese website!