Dynamic programming is an optimization algorithm technique that solves specific problems by breaking them into a number of simple sub-problems. Through this process, we can combine qualities, conditions, or facts from a complete search to obtain a precise and accurate greedy algorithm. But this approach itself is a contradiction, because it has great advantages, but it is also its greatest disadvantage and limitation. We can divide a problem into sub-problems, but we cannot divide it into sub-problems. They should resolve themselves. The concept of subproblems can be used to solve more important problems because they are highly optimizing in nature.
Coins are components of an array representing the sum of integers representing the total amount. In the process, you should return some coins to balance the total. If not built, returns -1.
There are two solutions for changing coins -
Recursion - Simple and slow method.
Dynamic programming - a timely and efficient method
Applications of coins in computer science -
is used to distribute changes.
Here is the process of how we gradually increase the value of coins in adjacent rows.
Step One - Start
Step 2 - Construct a new array of length n 1
Step 3 - Set dynamic prog[0] to 1 for one-way processing
Step 4 - Iterate over the value
Step 5 - Add the value of dynamicprog[index-coins[i]] to dynamicprog[index]
Step 6 - Set a range from 1 to n
Step 7 − Return a value
Step 8 - Termination
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));
Here is the possible coin change syntax in a C environment. By applying this syntax, we will build some code to fully understand this coin.
Method 1 - Recursive C program to find maximum number of coins
Method 2−Maximize the value of coins when coins in adjacent rows and columns cannot be collected
In this code, we apply dynamic programming. The logic is: arr[i][j 1] and arr[i][j – 1].
The Chinese translation of#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
In this C code, we apply the method of finding and collecting the most coins before hitting a dead end.
Move forward one step, that is, cell (i, j 1), the direction remains unchanged.
Move one step down and face left, i.e. cell (i 1, j) and the direction changes to left.
#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
Today in this post we learned how to maximize the value of coins from columns that cannot be collected from adjacent rows by building code and algorithms in possible C.
The above is the detailed content of Maximize the value of coins that cannot be collected in adjacent rows and columns. For more information, please follow other related articles on the PHP Chinese website!