Will memoization work for all DP problems? [closed] - c++

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 1 year ago.
Improve this question
I was solving this famous DP problem (ROD cutting) Problem Link
I understood the approach given in the editorials, but I came up with my own recursive solution..
that actually worked but the time limit is exceeding, so when I tried memoizing the same, I'm getting different answers
Code:
#include <bits/stdc++.h>
using namespace std;
// Approach 1:
// Recursion
int helper1(vector<int> &price, int size, int index, int profit)
{
if (size == 0)
return profit;
if (size < 0 or index == price.size())
return INT_MIN;
return max(helper1(price, size - (index + 1), index, profit + price[index]),
helper1(price, size, index + 1, profit));
}
int cutRod1(vector<int> &price)
{
int n = price.size();
return helper1(price, n, 0, 0);
}
// Approach 2:
// Recursion + Memoization
int helper2(vector<int> &price, int size, int index, int profit, vector<vector<int>> &dp)
{
if (size == 0)
return profit;
if (size < 0 or index == price.size())
return INT_MIN;
if (dp[index][size] != -1)
return dp[index][size];
return dp[index][size] = max(helper2(price, size - (index + 1), index, profit + price[index], dp),
helper2(price, size, index + 1, profit, dp));
}
int cutRod2(vector<int> &price)
{
int n = price.size();
vector<vector<int>> dp(n + 1, vector<int>(n + 1, -1));
return helper2(price, n, 0, 0, dp);
}
void solve()
{
vector<int> price{3, 9, 13, 12, 8, 12, 8, 8, 3, 10, 13};
cout << cutRod1(price) << endl;
cout << cutRod2(price) << endl;
}
int main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t{1};
// cin >> t;
while (t--)
solve();
return 0;
}
Recursive solution's result: 49 (Correct)
Memoized solutions's result: 48 (Wrong)
Intuition behind my approach:
It is an unbounded Knapsack problem, we have two choices:
Take a cut at index's position and stay there (for making furthur cuts at the same position)
Not take a cut at index's position, move to next index (index+1)
can anyone help me finding out the reason why memoized version doesn't work

Answer 1

You need to include profit in the memoization lookup. At some point, you're calling helper with the same (size, index) pair but the passed in profit value is different.

Answer 2

This is a solution with memoization. The source contains a complete explanation. Source
#include <iostream>
#include<algorithm> // To use the built in max function
using namespace std;
int main() {
// Suppose that we have a rod of length 5, and an array containing the
// length(1,2,3 and 4 ) and price(2,5,7 and 8 ) of the pieces.
int price[] = {2,5,7,8};
int n = 5;
// Declaring a 2D array, T
int T[n-1][n+1];
// Initializing the array to all zeros
for(int i=0; i < n-1; i++)
{
for(int j=0; j < n+1; j++ )
{
T[i][j] = 0;
}
}
for(int i=0; i < n-1; i++)
{
for(int j=0; j < n+1; j++ )
{
// First column => 0 length of rod => 0 profit
if(j == 0) {
continue;
}
// First row => T[i-1][j] doesn't exist so just pick the second value
else if(i == 0) {
T[i][j] = price[i] + T[i][j-i-1];
}
// where j <= i => T[i][j-i-1] doesn't exist so just pick the first value
else if(j-i-1 < 0) {
T[i][j] = T[i-1][j];
}
// using the whole expression
else {
T[i][j] = std::max(T[i-1][j], (price[i] + T[i][j-i-1]));
}
}
}
// Answer in the extreme bottom right cell
cout << "Maximum profit is " << T[n-2][n] << endl;
return 0;
}