Best Time to Buy and Sell Stock
Say you have an array for which the ith element is the price of a given stock on dayi.
If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.
Example 1:
Input: [7, 1, 5, 3, 6, 4] Output: 5 max. difference = 6-1 = 5 (not 7-1 = 6, as selling price needs to be larger than buying price)
Example 2:
Input: [7, 6, 4, 3, 1] Output: 0 In this case, no transaction is done, i.e. max profit = 0.
这个题很简单，直接上代码：
public class Solution {
public int maxProfit(int[] prices) {
int maxProfit=0;
int min=Integer.MAX_VALUE;
for(int i=0;i<prices.length;i++){
if(prices[i]<min){
min=prices[i];
}else{
maxProfit=prices[i]-min>maxProfit?prices[i]-min:maxProfit;
}
}
return maxProfit;
}
}Best Time to Buy and Sell Stock III
Say you have an array for which the ith element is the price of a given stock on dayi.
Design an algorithm to find the maximum profit. You may complete at most two transactions.
Note:
You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
我先用maxProfits[i][j]来存储从i到j买卖一次获得的最大利润，然后用dp[i][j]来存储从i到j最多买卖2次获得的最大利润。
dp[i][j]=max(dp[i,k], dp[k+1,j], maxProfits[i,k]+maxProfits[k+1,j]) (i-1<k<j)而不是简单的dp[i,k]+dp[k+1,j]。以为当以k为分界线时，要么是左边的两次买卖取最大值，要么右边的两次买卖取最大值，要么就是左边一次买卖和右边一次买卖取最大值。
代码如下：
public class Solution {
public int maxProfit(int[] prices) {
int n=prices.length;
if(n==0)
return 0;
int[][] maxProfits=new int[n][n];
for(int i=0;i<n-1;i++){
int min=prices[i];
for(int j=i+1;j<n;j++){
if(prices[j]>min){
maxProfits[i][j]=prices[j]-min;
}else{
maxProfits[i][j]=maxProfits[i][j-1];
min=prices[j]<min?prices[j]:min;
}
}
}
int[][] dp=new int[n][n];
for(int len=2;len<=n;len++){
for(int i=0;i<=n-len;i++){
int j=i+len-1;
int maxProfit=0;
for(int k=i;k<j;k++){
int onlyLeft=dp[i][k];
int onlyRight=dp[k+1][j];
int leftAndRight=maxProfits[i][k]+maxProfits[k+1][j];
int num=Integer.max(Integer.max(onlyLeft, onlyRight),leftAndRight);
maxProfit=num>maxProfit?num:maxProfit;
}
dp[i][j]=maxProfit>maxProfits[i][j]?maxProfit:maxProfits[i][j];
}
}
return dp[0][n-1];
}
}以第i天为分界线，计算第i天之前进行一次交易的最大收益preProfit[i]，和第i天之后进行一次交易的最大收益postProfit[i]，最后遍历一遍，max{preProfit[i] + postProfit[i]} (0≤i≤n-1)就是最大收益。第i天之前和第i天之后进行一次的最大收益求法同Best Time to Buy and Sell Stock I。
代码如下：
public class Solution {
public int maxProfit(int[] prices) {
if (prices.length < 2) return 0;
int n = prices.length;
int[] preProfit = new int[n];
int[] postProfit = new int[n];
int curMin = prices[0];
for (int i = 1; i < n; i++) {
curMin = Math.min(curMin, prices[i]);
preProfit[i] = Math.max(preProfit[i - 1], prices[i] - curMin);
}
int curMax = prices[n - 1];
for (int i = n - 2; i >= 0; i--) {
curMax = Math.max(curMax, prices[i]);
postProfit[i] = Math.max(postProfit[i + 1], curMax - prices[i]);
}
int maxProfit = 0;
for (int i = 0; i < n; i++) {
maxProfit = Math.max(maxProfit, preProfit[i] + postProfit[i]);
}
return maxProfit;
}
}Best Time to Buy and Sell Stock IV
Say you have an array for which the ith element is the price of a given stock on day i.
Design an algorithm to find the maximum profit. You may complete at most k transactions.
Note:
You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
profit[i][j] = max(profit[i – 1][j], profit[i – 1][j – 1] + diff)
看起来很有道理，但其实不对，为什么不对呢？因为diff是第i天和第i-1天的差额收益，如果第i-1天当天本身也有交易呢（也就是说第i-1天刚卖出了股票，然后又买入等到第i天再卖出），那么这两次交易就可以合为一次交易，这样profit[i – 1][j – 1] + diff实际上只进行了j-1次交易，而不是最多可以的j次，这样得到的最大收益就小了。
那么怎样计算第i天进行交易的情况的最大收益，才会避免少计算一次交易呢？我们用一个局部最优解和全局最有解表示到第i天进行j次的收益，这就是该动态规划的特殊之处。
用local[i][j]表示到达第i天时，最多进行j次交易的局部最优解；用global[i][j]表示到达第i天时，最多进行j次的全局最优解。它们二者的关系如下（其中diff = prices[i] – prices[i – 1]）：
local[i][j] = max(global[i – 1][j – 1] , local[i – 1][j] + diff)
global[i][j] = max(global[i – 1][j], local[i][j])
local[i][j]和global[i][j]的区别是：local[i][j]意味着在第i天一定有交易（卖出）发生，当第i天的价格高于第i-1天（即diff > 0）时，那么可以把这次交易（第i-1天买入第i天卖出）跟第i-1天的交易（卖出）合并为一次交易，即local[i][j]=local[i-1][j]+diff；当第i天的价格不高于第i-1天（即diff<=0）时，那么local[i][j]=global[i-1][j-1]+diff，而由于diff<=0，所以可写成local[i][j]=global[i-1][j-1]。global[i][j]就是我们所求的前i天最多进行k次交易的最大收益，可分为两种情况：如果第i天没有交易（卖出），那么global[i][j]=global[i-1][j]；如果第i天有交易（卖出），那么global[i][j]=local[i][j]。
参考：点击打开链接http://www.cnblogs.com/grandyang/p/4295761.html
代码：时间O(nk)，空间O(nk)。
public class Solution {
public int maxProfit(int k, int[] prices) {
if (prices.length < 2) return 0;
int days = prices.length;
if (k >= days) return maxProfit2(prices);
int[][] local = new int[days][k + 1];
int[][] global = new int[days][k + 1];
for (int i = 1; i < days ; i++) {
int diff = prices[i] - prices[i - 1];
for (int j = 1; j <= k; j++) {
local[i][j] = Math.max(global[i - 1][j - 1], local[i - 1][j] + diff);
global[i][j] = Math.max(global[i - 1][j], local[i][j]);
}
}
return global[days - 1][k];
}
public int maxProfit2(int[] prices) {
int maxProfit = 0;
for (int i = 1; i < prices.length; i++) {
if (prices[i] > prices[i - 1]) {
maxProfit += prices[i] - prices[i - 1];
}
}
return maxProfit;
}
}我们知道，动规所用的二维辅助数组可以降为一维的，即只用大小为k的一维数组记录到达第i天时的局部最优解和全局最优解。需要注意的是，由于第i天时交易k次的最优解依赖于第i-1天时交易k-1次的最优解，所以数组更新应当从后往前（即从k到1）更新。
代码：时间O(nk)，空间O(k)。
public class Solution {
public int maxProfit(int k, int[] prices) {
if (prices.length < 2) return 0;
if (k >= prices.length) return maxProfit2(prices);
int[] local = new int[k + 1];
int[] global = new int[k + 1];
for (int i = 1; i < prices.length ; i++) {
int diff = prices[i] - prices[i - 1];
for (int j = k; j > 0; j--) {
local[j] = Math.max(global[j - 1], local[j] + diff);
global[j] = Math.max(global[j], local[j]);
}
}
return global[k];
}
public int maxProfit2(int[] prices) {
int maxProfit = 0;
for (int i = 1; i < prices.length; i++) {
if (prices[i] > prices[i - 1]) {
maxProfit += prices[i] - prices[i - 1];
}
}
return maxProfit;
}
}
843
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
