Maximisez la valeur des pièces qui ne peuvent pas être collectées dans les lignes et colonnes adjacentes

La programmation dynamique est une technique d'algorithme d'optimisation qui résout des problèmes spécifiques en les décomposant en un certain nombre de sous-problèmes simples. Grâce à ce processus, nous pouvons combiner des qualités, des conditions ou des faits issus d'une recherche complète pour obtenir un algorithme glouton précis et exact. Mais cette approche elle-même est contradictoire, car elle présente de grands avantages, mais elle constitue également son plus grand inconvénient et sa plus grande limite. Nous pouvons diviser un problème en sous-problèmes, mais nous ne pouvons pas le diviser en sous-problèmes. Ils devraient se résoudre eux-mêmes. Le concept de sous-problèmes peut être utilisé pour résoudre des problèmes plus importants car ils sont de nature hautement optimisée.

Qu'est-ce qu'une pièce et comment l'échanger ?

Les pièces sont des composants d'un tableau représentant la somme d'entiers représentant le montant total. Dans le processus, vous devez restituer quelques pièces pour équilibrer le total. S'il n'est pas construit, renvoie -1.

Il existe deux solutions pour changer les pièces -

• Récursion - méthode simple et lente.

• Programmation dynamique - une méthode rapide et efficace

Applications des pièces en informatique -

• Pour distribuer les modifications.

Algorithme de fonctionnement des pièces

Voici le processus par lequel nous augmentons progressivement la valeur des pièces dans les rangées adjacentes.

• Étape 1 - Démarrer

• Étape 2 - Construire un nouveau tableau de longueur n+1

• Étape 3 - Définissez Dynamic prog[0] sur 1 pour un traitement unidirectionnel

• Étape 4 - Itérer sur la valeur

• Étape 5 - Ajoutez la valeur de Dynamicprog[index-coins[i]] à Dynamicprog[index]

• Étape 6 - Définissez une plage de 1 à n

• Étape 7 - Renvoyez une valeur

• Étape 8 - Résiliation

Syntaxe des pièces

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));

Voici la syntaxe de changement de pièce possible dans un environnement C++. En appliquant cette syntaxe, nous allons construire du code pour acquérir une compréhension complète de cette pièce.

Méthode à suivre :

• Méthode 1 - Programme C++ récursif pour trouver le nombre maximum de pièces

• Méthode 2− Maximiser la valeur des pièces lorsque les pièces des lignes et colonnes adjacentes ne peuvent pas être collectées

Programme C++ récursif pour trouver le nombre maximum de pièces

Dans ce code, nous appliquons une programmation dynamique. La logique est la suivante : arr[i][j + 1] et arr[i][j – 1].

La traduction chinoise de

Exemple 1

est :

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

Sortie

Maximum number of collected coins is 8

Maximisez la valeur des pièces lorsque les pièces des lignes et colonnes adjacentes ne peuvent pas être collectées

Dans ce code C++, nous appliquons la méthode consistant à trouver et à collecter le plus de pièces avant de tomber dans une impasse.

• Avancez d'un pas, c'est-à-dire la cellule (i, j+1), la direction reste inchangée.

• Déplacez-vous d'un pas vers le bas et faites face à gauche, c'est-à-dire la cellule (i+1, j) et la direction change vers la gauche.

Exemple 2

se traduit par :

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

Sortie

25

Conclusion

Aujourd'hui, dans cet article, nous avons appris comment maximiser la valeur des pièces des colonnes qui ne peuvent pas être collectées à partir des lignes adjacentes en créant du code et des algorithmes en C++ possible.

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!