Dynamic Programming - The wine selling with maximum profit - recursion

Question

Let’s consider you have a collection of N wines placed next to each other on a shelf. The price of the ith wine is pi. (prices of different wines can be different). Because the wines get better every year, supposing today is the year 1, on year y the price of the ith wine will be y*pi, i.e. y-times the value that current year.
You want to sell all the wines you have, but you want to sell exactly one wine per year, starting on this year. One more constraint - on each year you are allowed to sell only either the leftmost or the rightmost wine on the shelf and you are not allowed to reorder the wines on the shelf (i.e. they must stay in the same order as they are in the beginning).
You want to find out, what is the maximum profit you can get, if you sell the wines in optimal order?
int N; // number of wines
int p[N]; // array of wine prices
int cache[N][N]; // all values initialized to -1
int profit(int be, int en) {
if (be > en)
return 0;
if (cache[be][en] != -1)
return cache[be][en];
int year = N - (en-be+1) + 1;
return cache[be][en] = max(profit(be+1, en) + year * p[be],profit(be, en-1) + year * p[en]);
}
Time Complexity: O(n^2).
I have already found this O(n^2) solution. Can we do it in O(n) ? (Better time complexity)

Answer 1

You are supposed to find the optimal cost by selling all the wines from the shelf. And only the constraint is that you are allowed to pick only left or right wine(you can't pick a wine bottle from the middle of the shelf).
As we are allowed to pick the left or right wine, the optimal sequence of solution will include either left or right bottle.
Let's find a recursive solution for that.
Just pick-up the left bottle and calculate it's cost
pick-up the right bottle and calculate the cost
Compare both the cost and choose the maximum cost
Write the necessary condition for the base case
Let's write a c++ program for this--
#include<bits/stdc++.h>
using namespace std;
int max_cost(int wine[], int cost, int counter, int i, int j){
// Here `counter` keeps track of the number of years
// `i` is the left indices of the shelf
// `j` is the right indices of the shelf
// `cost` is the maximum cost that we have to find
if(i > j)
return cost;
else if(i == j){
cost += counter * wine[i];
return cost;
}
else{
int cost1 = counter * wine[i] + max_cost(wine, 0, counter + 1, i + 1, j);
int cost2 = counter * wine[j] + max_cost(wine, 0, counter + 1, i, j - 1);
cost += max(cost1, cost2);
return cost;
}
}
int main(){
int n;
cin >> n;
int wine[n];
for(int j = 0; j < n; ++j)
cin >> wine[j];
cout << max_cost(wine, 0, 1, 0, n - 1) << endl;
return 0;
}
I think the above code is self exlanatory
Let's run it:
Input1:
5
1
3
1
5
2
Output:
43
Input2:
4
10
1
10
9
Output:
79
The time complexity of above code is O(2^n), where n is the no. of wine bottles in the shelf.
Can we improvise the time complexity?
Ofcourse. We are basically calculating for some sequences again and again, which can be avoided by memorization technique.
The recurrence relation will be basically same. In addition to that, we will memorize the value for the specific i and j. And hence we will not have to calculate the value for the same i and j again and again.
The c++ code will be --
#include<bits/stdc++.h>
using namespace std;
int find_cost(vector<int>& box, vector<vector<int>>& dp, int i, int j){
if(i == j) // base case
dp[i][j] = box[i] * box.size();
else if(!dp[i][j]){ // If not calculated so far
int n = box.size();
dp[i][j] = max(find_cost(box, dp, i, j - 1) + box[j] * (n - (j - i)),
find_cost(box, dp, i + 1, j) + box[i] * (n - (j - i)));
}
return dp[i][j];
}
void cost_wine(vector<int> box){
int n = box.size();
vector<vector<int>> dp(n + 1, vector<int>(n + 1)); // Initialize dp array
cout << find_cost(box, dp, 0, n - 1);
return;
}
int main(){
int n;
cin >> n;
vector<int> box(n);
for(int i = 0; i < n; ++i)
cin >> box[i];
cost_wine(box);
return 0;
}
Now the time complexity of the above code would be O(n^2), which is far better than the recursion method.