Maison > Article > développement back-end > 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.
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.
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
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 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
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#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; }
Maximum number of collected coins is 8
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.
#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; }
25
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!