Ditulis dalam C++ dalam tahap K, kalahkan bos tahap A dengan kuasa maksimum tahap N, meningkatkan kuasa dengan B

Dalam dunia pembangunan permainan, mengoptimumkan kebolehan dan kemajuan pemain ialah aspek penting untuk mencipta pengalaman yang menarik dan mencabar. Mekanik biasa melibatkan mengalahkan bos pada tahap yang berbeza, dengan setiap kemenangan memberikan pemain peningkatan kuasa. Dalam artikel ini kita akan meneroka cara mengira kuasa maksimum yang boleh dicapai oleh pemain dalam peringkat N berdasarkan tahap kuasa awal K, dengan mengambil kira kenaikan kuasa B[i]] yang diperolehi dengan mengalahkan bos pada tahap A[i]]. Kami akan menyelidiki sintaks, algoritma dan menunjukkan dua pendekatan berbeza dengan contoh kod boleh laku yang lengkap dalam C++.

Tatabahasa

Sebelum meneroka topik ini dengan lebih lanjut. Kita mesti menggariskan dan menjelaskan sintaks yang terlibat dalam menggunakan kaedah yang dipilih dalam ilustrasi kod yang akan datang. Setelah asas ini ditubuhkan, kita boleh membangunkan pemahaman yang lebih lengkap tentang teknologi khusus ini. -

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

Algoritma

Untuk menentukan kuasa maksimum yang boleh dicapai dalam peringkat N, kita boleh mengikuti algoritma langkah demi langkah berikut −

• Memulakan maxPower pembolehubah untuk menyimpan kuasa maksimum yang diperolehi.

• Tetapkan kuasa arus berubah kepada aras kuasa awal K.

• Lelarkan setiap tahap, i, dari 0 hingga N-1 −

• Jika mengalahkan bos pada tahap A[i] mengakibatkan kenaikan kuasa B[i], kemas kini dengan menambah B[i] currentPower .

• Periksa sama ada kuasa semasa lebih besar daripada kuasa maksimum. Jika ya, kemas kini maxPower dengan nilai baharu.

• Kembalikan maxPower sebagai kuasa maksimum yang boleh dicapai dalam tahap N.

Kaedah 1: Pengaturcaraan Dinamik

Penyelesaian yang mungkin untuk masalah ini adalah dengan menggunakan pengaturcaraan dinamik. Untuk menyimpan kuasa maksimum yang boleh dicapai dengan cekap bagi setiap peringkat, mulakan tatasusunan bernama dp dengan saiz N+1.

Contoh

#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

Penjelasan

Dalam pendekatan ini, kami menggunakan pengaturcaraan dinamik untuk mengira kuasa maksimum yang boleh dicapai dalam peringkat N. Kami mencipta dp tatasusunan bersaiz N+1 untuk menyimpan kuasa maksimum yang boleh dicapai pada setiap peringkat. Pertama, tatasusunan pengaturcaraan dinamik kami dp[0] bermula dengan nilai K, yang mewakili tahap kuasa awal. Seterusnya, kaedah kami untuk setiap tahap ke-i dari 1 hingga ke N melibatkan pengemaskinian tatasusunan ini seperti berikut: Kami mendapatkan semula dan menyimpan ke dalam ingatan kuasa maksimum yang boleh diperolehi selepas mengalahkan kapten dalam tahap yang lebih awal. Seorang bos pada kedudukan A[j], dengan betul menyebabkan kuasa seseorang meningkat sebanyak B[j] (di mana j menjangkau nilai 0 hingga i-1). Dengan menggunakan max(dp[i - A[j]] + B [j],dp [i]). Kita boleh mengemas kini nilai dp[i] supaya keamatan maksimum sebelumnya menjadi apa yang ditunjukkan oleh hasil semasa. Akhir sekali, kami mengembalikan dp[N] sebagai kuasa maksimum yang boleh diperolehi di antara peringkat N. Disebabkan gelung bersarang, kerumitan masa kaedah ini ialah O(N^2).

Kaedah 2: Gunakan algoritma tamak

Menggunakan algoritma tamak boleh memberikan penyelesaian yang cekap. Ini melibatkan latihan membuat keputusan yang baik dengan mengisih tahap dengan meningkatkan tahap bos A[i], kemudian mengulangi setiap peringkat permainan dan hanya meningkatkan kuasa apabila ia membantu mengalahkan bos tertentu.

Contoh

#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

Penjelasan

Dalam pendekatan algoritma tamak, kita mula-mula menyusun tahap mengikut susunan menaik tahap bos A[i]. Kemudian kami mengulangi setiap tahap dari 1 hingga N. Kami mengekalkan pembolehubah CurrentPower untuk menjejaki tahap kuasa semasa, dan pembolehubah maxPower untuk menyimpan kuasa maksimum yang dicapai setakat ini. Bermula dari tahap keupayaan awal K, kami menyemak sama ada mengalahkan bos tahap semasa akan meningkatkan keupayaan. Jika ya, kami mengemas kini currentPower dengan menambahkan kenaikan kuasa B[i]. Kami meneruskan proses ini sehingga semua bos sehingga tahap semasa dikalahkan. Apabila currentPower melebihi maxPower, kami mengemas kini maxPower. Pada penghujung lelaran, maxPower akan mengandungi kuasa maksimum yang boleh dicapai antara peringkat N. Disebabkan oleh operasi pengisihan, kerumitan masa pendekatan ini ialah O(N log N).

Kesimpulan

Artikel kami membincangkan cara menentukan kuasa puncak yang boleh dicapai dalam Tahap N - bermula daripada tahap tenaga mentah K dan memperoleh ganjaran tenaga tambahan selepas mengalahkan bos khusus peringkat. Kami mencadangkan dua pilihan: gunakan pengaturcaraan dinamik atau gunakan algoritma tamak.

Walaupun kedua-dua kaedah menghasilkan hasil yang boleh dilaksanakan, terdapat beberapa perbezaan yang ketara dalam pelaksanaan. Pembangun yang mempelajari kemahiran ini dan memasukkannya ke dalam pembangunan permainan melalui pengaturcaraan C++ akan membina sistem kemajuan yang memuaskan yang melibatkan pengguna dalam pengalaman permainan yang dipenuhi dengan ganjaran yang kaya.

Atas ialah kandungan terperinci Ditulis dalam C++ dalam tahap K, kalahkan bos tahap A dengan kuasa maksimum tahap N, meningkatkan kuasa dengan B. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!