Calculate the max total price of rods, cut with unique length value - c++

Question

Rod-cutting problem(there is a rod of length n where n > 0, n is an integer, and we want to cut it into pieces of integer lengths such that the total price is maximized), p is the list of price, n is the length of the rod. I want to cut the rod, in order to get the maximum price, at the meantime, we also need to ensure that the length is unqiue, that is if we already cut a piece length = 3, we cannot cut another piece length = 3.
For example vector p = {1, 5, 8, 9, 10, 12, 17, 20}; Gives me max price: 21 and length are: 2,3,3. As stated, there shouldn't be double 3. So the result should be 20 and length is 8 instead of 2,3,3
How could I modify my code, and maintain the time complexity O(n^2) Thanks.
int n = 8;
vector<int> p = {1,5,8,9,10,12,17,20};
void cut_rod(vector<int>& p, int n){
int r[n+1];
int s[n+1];
r[0] = 0;
for (int j = 1; j<=n; j++){
int q = INT_MIN;
for (int i = 1; i <= j; i++){
if(q < p[i-1] + r[j-i]){
q = p[i-1] + r[j-i];
s[j] = i;
}
}
r[j] = q;
}
return r[n];
}

Answer 1

You could use a n + 1 by n + 1 matrix when you store the pieces for a given length. This way you can check if you have a same sized piece in constant time and copying a row costs linear time, so in total the complexity is still O(n^2), but now your space complexity is O(n^2).
I modified the code by geeksforgeeks below.
// A Dynamic Programming solution for Rod cutting problem
#include<stdio.h>
#include<limits.h>
using namespace std;
// A utility function to get the maximum of two integers
int max(int a, int b) { return (a > b)? a : b;}
/* Returns the best obtainable price for a rod of length n and
price[] as prices of different pieces */
int cutRod(int price[], int n)
{
int pieces[n+1][n+1];
int val[n+1];
val[0] = 0;
int i, j;
// Build the table val[] in bottom up manner and return the last entry
// from the table
for (i = 1; i<=n; i++)
{
int max_val = INT_MIN, ind = -1;
for (j = 1; j <= i; j++) {
if (max_val < price[j - 1] + val[i-j]) {
if (pieces[i-j][j] != 1) {
max_val = price[j - 1] + val[i-j];
ind = j;
}
}
}
val[i] = max_val;
for (int k = 0; k <= n; ++k) { // Copy the pieces
pieces[i][k] = pieces[i-ind][k];
}
pieces[i][ind] = 1; // Add the piece of length ind (which is the max j)
}
return val[n];
}
/* Driver program to test above functions */
int main()
{
int arr[] = {1,5,8,9,10,12,17,20};
int size = sizeof(arr)/sizeof(arr[0]);
printf("Maximum Obtainable Value is %dn", cutRod(arr, size));
getchar();
return 0;
}
The DP algorithm saves in the i-th position of the array val, that goes from 0 to n, the maximum price for a rod with length i. We save the cuts of a rod of length i in pieces[i] which is an array that goes from 0 to n, if we have 1 at the position j that means to get the max value val[i] you must have a piece of length j. Now, the DP algorithm for some length i makes a cut of length j and calculates the sum of the price of a price of length j and the max price of the remainder piece of length i-j which is already calculated. This sum will have a max value for some j, meaning there will be some j that price[j - 1] + val[i-j] will be max (where j isn't an already existing cut). So now for length i we have a piece of length j and the pieces for length i - j which we have saved at pieces[i - j]. Now to get pieces[i] we have to copy the pieces pieces[i - j] and add the piece of length j.
You can get the length of the pieces like that
for (int i = 0; i <= n; ++i)
if (pieces[n][i] == 1) cout << i << ' ';