Maksimumkan nilai syiling yang tidak boleh dikumpulkan dalam baris dan lajur bersebelahan

Pengaturcaraan dinamik ialah teknik algoritma pengoptimuman yang menyelesaikan masalah tertentu dengan memecahkannya kepada beberapa sub-masalah mudah. Melalui proses ini, kita boleh menggabungkan kualiti, keadaan atau fakta daripada carian lengkap untuk mendapatkan algoritma tamak yang tepat dan tepat. Tetapi pendekatan ini sendiri adalah percanggahan, kerana ia mempunyai kelebihan yang besar, tetapi ia juga merupakan kelemahan dan batasan terbesarnya. Kita boleh membahagikan masalah kepada sub-masalah, tetapi kita tidak boleh membahagikannya kepada sub-masalah. Mereka harus menyelesaikan sendiri. Konsep submasalah boleh digunakan untuk menyelesaikan masalah yang lebih penting kerana ia bersifat sangat mengoptimumkan.

Apakah syiling dan bagaimana untuk menebusnya?

Syiling ialah komponen tatasusunan yang mewakili jumlah integer yang mewakili jumlah keseluruhan. Dalam proses itu, anda harus memulangkan beberapa syiling untuk mengimbangi jumlah keseluruhan. Jika tidak dibina, mengembalikan -1.

Terdapat dua penyelesaian untuk menukar syiling -

• Rekursi - kaedah mudah dan perlahan.

• Pengaturcaraan dinamik - kaedah yang tepat pada masanya dan cekap

Aplikasi syiling dalam sains komputer -

• Untuk mengedarkan perubahan.

Algoritma operasi syiling

Berikut ialah proses bagaimana kami meningkatkan nilai syiling dalam baris bersebelahan secara beransur-ansur.

• Langkah 1 - Mulakan

• Langkah 2 - Bina tatasusunan baharu panjang n+1

• Langkah 3 - Tetapkan prog dinamik[0] kepada 1 untuk pemprosesan sehala

• Langkah 4 - Ulangi nilai

• Langkah 5 - Tambahkan nilai dynamicprog[index-coins[i]] pada dynamicprog[index]

• Langkah 6 - Tetapkan julat dari 1 hingga n

• Langkah 7 − Kembalikan nilai

• Langkah 8 - Penamatan

Sintaks syiling

If the coin value is greater than the dynamicprogSum, the coin is ignored, i.e.
dynamicprogTable[i][j]=dynamicprogTable[i-1][j].
If the coin value is less than the dynamicprogSum, you can consider it, i.e.
dynamicprogTable[i][j]=dynamicprogTable[i-
1].[dynamicprogSum]+dynamicprogTable[i][j-coins[i-1]].
Or;
maxCoins(i, j, d): Maximum number of coins that can be
collected if we begin at cell (i, j) and direction d.
   d can be either 0 (left) or 1 (right)
If (arr[i][j] == ‘#’ or isValid(i, j) == false)
   return 0
If (arr[i][j] == ‘C’)
   result = 1;
Else
   result = 0;
If (d == 0)
return result + max(maxCoins(i+1, j, 1),
   maxCoins(i, j-1, 0));
If (d == 1)
return result + max(maxCoins(i+1, j, 1),
   maxCoins(i, j+1, 0));

Berikut ialah kemungkinan sintaks penukaran syiling dalam persekitaran C++. Dengan menggunakan sintaks ini, kami akan membina beberapa kod untuk mendapatkan pemahaman yang lengkap tentang syiling ini.

Kaedah untuk diikuti:

• Kaedah 1 - Program C++ rekursif untuk mencari bilangan maksimum syiling

• Kaedah 2− Maksimumkan nilai syiling apabila syiling dalam baris dan lajur bersebelahan tidak dapat dikumpulkan

Program C++ rekursif untuk mencari bilangan maksimum syiling

Dalam kod ini, kami menggunakan pengaturcaraan dinamik. Logiknya ialah: arr[i][j + 1] dan arr[i][j – 1].

Contoh 1

Contoh 1

#include<bits/stdc++.h>
using namespace std;
#define R 5
#define C 5
bool isValid(int i, int j) {
   return (i >=0 && i < R && j >=0 && j < C);
}
int maxCoinsRec(char arr[R][C], int i, int j, int dir){
   if (isValid(i,j) == false || arr[i][j] == '#')
      return 0;
   int result = (arr[i][j] == 'C')? 1: 0;
   if (dir == 1)
      return result + max(maxCoinsRec(arr, i+1, j, 0),
   maxCoinsRec(arr, i, j+1, 1));
   return result + max(maxCoinsRec(arr, i+1, j, 1),
   maxCoinsRec(arr, i, j-1, 0));
}
int main() {
   char arr[R][C] = {
      {'E', 'C', 'C', 'C', 'C'},
      {'C', '#', 'C', '#', 'E'},
      {'#', 'C', 'C', '#', 'C'},
      {'C', 'E', 'E', 'C', 'E'},
      {'C', 'E', '#', 'C', 'E'}
   };
   cout << "Maximum number of collected coins is "<< maxCoinsRec(arr, 0, 0, 1);
   return 0;
}

Output

Maximum number of collected coins is 8

Maksimumkan nilai syiling apabila syiling dalam baris dan lajur bersebelahan tidak dapat dikumpulkan

Dalam kod C++ ini, kami menggunakan kaedah mencari dan mengumpul syiling terbanyak sebelum menemui jalan buntu.

• Bergerak ke hadapan satu langkah, iaitu sel (i, j+1), arahnya kekal tidak berubah.

• Gerak satu langkah ke bawah dan menghadap ke kiri, iaitu sel (i+1, j) dan arah bertukar ke kiri.

Contoh 2

Contoh 2

#include <bits/stdc++.h>
using namespace std;
int findMax(vector<int>& arr) {
   int n = arr.size(), result = 0;
   vector<int> dp(n);
   dp[0] = arr[0];
   result = dp[0];
   if (n <= 1)
      return result;
   dp[1] = max(arr[1], arr[0]);
   result = max(result, dp[1]);
   for (int i = 2; i < n; i++) {
      dp[i] = max(dp[i - 1], arr[i] + dp[i - 2]);
      result = max(result, dp[i]);
   }
   return result;
}
int solve(vector<vector<int> >& matrix){
   int m = matrix.size();
   if (m == 0)
      return 0;
   vector<int> dp;
   for (int i = 0; i < m; i++) {
      int val = findMax(matrix[i]);
   dp.push_back(val);
   }
   return findMax(dp);
}
int main() {
   vector<vector<int> > arr = { { 2, 7, 6, 5 },
      { 9, 9, 1, 2 },
      { 3, 8, 1, 5 } };
   int result = solve(arr);
   cout << result;
   return 0;
}

Output

25

Kesimpulan

Hari ini dalam artikel ini kami belajar cara memaksimumkan nilai syiling daripada lajur yang tidak boleh dikumpulkan dari baris bersebelahan dengan membina kod dan algoritma dalam kemungkinan C++.

Atas ialah kandungan terperinci Maksimumkan nilai syiling yang tidak boleh dikumpulkan dalam baris dan lajur bersebelahan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!