葡萄酒酒进销存单机版

Problem statement:

问题陈述：

Given n wines in a row, with integers denoting the cost of each wine respectively. Each year you can sale the first or the last wine in the row. Let the initial profits from the wines be P1, P2, P3…Pn. On the Y^th year, the profit from the ith wine will be Y*P[i], calculate the maximum profit from all the wines.

连续给出n种葡萄酒，其中整数分别表示每种葡萄酒的价格。 每年您都可以出售该行中的第一个或最后一个葡萄酒。 假设从葡萄酒中获得的初始利润为P1，P2，P3 ... Pn 。 在^第五年的Y，从第i个酒的利润将Y * P [I]， 从所有的葡萄酒计算最大的利润 。

Input:

输入：

The first line of the input is T denoting the number of test cases. Then T test cases follow. Each test case contains two lines. The first line of each test case is a number N denoting the size of the price array of wine, the next line is N separated values of P[].

输入的第一行是T，表示测试用例的数量。 然后是T测试用例。 每个测试用例包含两行。 每个测试用例的第一行是一个数字N，表示葡萄酒价格数组的大小，下一行是N个独立的P []值。

Output:

输出：

For each test case output in a new line the max profit from the sale of all the wines.

对于新行中的每个测试用例输出，所有葡萄酒的销售都会获得最大利润。

Example with explanation:

带有说明的示例：

    Input:
T = 1 // Test case
N = 4
P = [1,4,2,3]
Output:
29
The optimal solution would be to sell the wines
in the order p1, p4, p3, p2
for a total profit 1 * 1 + 3 * 2 + 2 * 3 + 4 * 4 = 29.
Input:
T = 1 // Test case
N = 5
P = [2,3,5,1,4]
Output:
50
The optimal solution would be to sell the wines
in the order p1, p5, p4, p2, p3
for a total profit 2 * 1 + 4 * 2 + 1 * 3 + 3 * 4 + 5 * 5 = 50.

Solution Approach

解决方法

1) Recursive Approach

1)递归方法

Here we will try all possible solution(using all subproblems answer) then check the solution which gives the maximum answer. We will pick either the first wine and multiply with the current year and recursively move to next year or we will select the last wine and multiply with the current year and move recursively to the next part then we will select the maximum of the two subproblems for the current solution.

在这里，我们将尝试所有可能的解决方案(使用所有子问题答案)，然后检查给出最大答案的解决方案。 我们将选择第一个葡萄酒并与当前年份相乘，然后递归移动到下一年；或者我们选择最后一个葡萄酒并与当前年份相乘，然后递归移动到下一部分，然后我们将选择两个子问题中的最大值当前的解决方案。

Pseudo Code:

伪代码：

int maxprofit(start, end, year)
{if (start > end)
return 0;
if (start <= end)
return max(P[start] * year + maxprofit(st + 1, end, year + 1), P[end] * year + maxprofit(st, end - 1, year + 1));
else
return 0;
}

Time Complexity:

时间复杂度：

The time complexity for the above approach is O(2^n), exponential time since we either take endpoint in the solution or we do not take the endpoint,that is we have two options for all the cases.

上面方法的时间复杂度是O(2 ^ n) ，因为我们要么在解决方案中采用端点，要么不采用端点，这是指数时间，即在所有情况下我们都有两个选择。

C++ Implementation:

C ++实现：

#include <bits/stdc++.h>
using namespace std;
int maxprofit(int P[], int start, int end, int n, int year)
{if (start > end)
return 0;
else if (start <= end) {return max(P[start] * year + maxprofit(P, start + 1, end, n, year + 1), P[end] * year + maxprofit(P, start, end - 1, n, year + 1));
}
else
return 0;
}
int main()
{int t;
cout << "Enter number of test cases: ";
cin >> t;
while (t--) {int n;
cout << "Enter number of wines: ";
cin >> n;
int P[n];
cout << "Enter the wines prices: ";
for (int i = 0; i < n; i++)
cin >> P[i];
int start = 0;
int end = n - 1;
int year = 1;
int res = maxprofit(P, start, end, n, year);
cout << "Max Profit: ";
cout << res << "\n";
}
return 0;
}

Output

输出量

Enter number of test cases: 2
Enter number of wines: 4
Enter the wines prices: 1 4 2 3
Max Profit: 29
Enter number of wines: 5
Enter the wines prices: 2 3 5 1 4
Max Profit: 50

2) Dynamic Programming (Better Approach):

2)动态编程(更好的方法)：

By carefully observing the recursion tree, we can see that we encounter the property of subproblem overlapping which can be prevented using memoization or dynamic programming.

通过仔细观察递归树，我们可以看到我们遇到了子问题重叠的属性，可以使用备注或动态编程来避免这种重叠。

We will use the 2-D array to store the profit for a particular year, initially, all the profit from the sale is zero. For memoization, we will use the start and end state. If the dp[start][end] is equal to zero it means we haven't solved for that year and if the dp[start][end] is not equal to zero then that dp[start][end] is returned.

我们将使用二维数组存储特定年份的利润，最初，所有销售利润均为零。 为了便于记忆，我们将使用开始和结束状态。 如果dp [start] [end]等于零，则表示那一年我们还没有解决，如果dp [start] [end]不等于零，则返回dp [start] [end]。

Pseudo Code:

伪代码：

int maxprofit(start, end, year)
{if (start > end)
return 0;
if (dp[start][end] != 0)
return dp[start][end];
else if (start <= end)
return dp[start][end] = max(P[start] * ye + maxprofit(start + 1, end, year + 1), P[end] * year + maxprofit(start, end - 1, year + 1));
else
return 0;
}

Time Complexity:

时间复杂度：

The time complexity for the above case is O(N^2), where N is the number of wines.

上述情况的时间复杂度为O(N ^ 2) ，其中N是葡萄酒的数量。

C++ Implementation:

C ++实现：

#include <bits/stdc++.h>
using namespace std;
int dp[1004][1004];
int maxprofit(int P[], int start, int end, int n, int year)
{if (start > end)
return 0;
else if (dp[start][end] != 0)
return dp[start][end];
else {dp[start][end] = max(P[start] * year + maxprofit(P, start + 1, end, n, year + 1), P[end] * year + maxprofit(P, start, end - 1, n, year + 1));
return dp[start][end];
}
}
int main()
{int t;
cout << "Enter number of test cases: ";
cin >> t;
while (t--) {int n;
cout << "Enter number of wines: ";
cin >> n;
int P[n];
cout << "Enter the wines prices: ";
for (int i = 0; i < n; i++)
cin >> P[i];
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++)
dp[i][j] = 0;
int start = 0;
int end = n - 1;
int year = 1;
int res = maxprofit(P, start, end, n, year);
cout << "Max Profit: ";
cout << res << "\n";
}
return 0;
}

Output

输出量

Enter number of test cases: 2
Enter number of wines: 6
Enter the wines prices: 2 5 6 2 4 5
Max Profit: 93
Enter number of wines: 5
Enter the wines prices: 2 3 5 1 4
Max Profit: 50

翻译自: https://www.includehelp.com/icp/wine-selling-problem.aspx

葡萄酒酒进销存单机版