121~123 188 Best Time to Buy and Sell StockI II III IV

摘自
http://liangjiabin.com/blog/2015/04/leetcode-best-time-to-buy-and-sell-stock.html

Best Time to Buy and Sell Stock I

Description: Say you have an array for which the ith element is the price of a given stock on day i. 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.

题意：用一个数组表示股票每天的价格，数组的第i个数表示股票在第i天的价格。 如果只允许进行一次交易，也就是说只允许买一支股票并卖掉，求最大的收益。

分析：动态规划法。从前向后遍历数组，记录当前出现过的最低价格，作为买入价格，并计算以当天价格出售的收益，作为可能的最大收益，整个遍历过程中，出现过的最大收益就是所求。

代码：O(n)时间，O(1)空间。

public int maxProfit(int[] prices)
{
if (prices.length < 2)
return 0;

int maxProfit = 0;
int curMin = prices[0];

for (int i = 1; i < prices.length; i++)
{
curMin = Math.min(curMin, prices[i]);
maxProfit = Math.max(maxProfit, prices[i] - curMin);
}

return maxProfit;
}

public static int maxProfit(int[] prices)
{
int len=prices.length;
if(len<=1)
return 0;

int curmin=prices[0];
int[] dp=new int[len];
for(int i=1;i<len;i++)
{
int dis=0;
if(prices[i]>=curmin)
{
dis=prices[i]-curmin;
dp[i]=Math.max(dp[i-1], dis);
}
else {
dp[i]=dp[i-1];
}
if(prices[i]<curmin)
curmin=prices[i];
}

return dp[len-1];

}

Best Time to Buy and Sell Stock II

Description: 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 as many transactions
as you like (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

题目：用一个数组表示股票每天的价格，数组的第i个数表示股票在第i天的价格。交易次数不限，但一次只能交易一支股票，也就是说手上最多只能持有一支股票，求最大收益。

分析：贪心法。从前向后遍历数组，只要当天的价格高于前一天的价格，就算入收益。

代码：时间O(n)，空间O(1)。

public int maxProfit(int[] prices)
{
if (prices.length < 2)
return 0;

int maxProfit = 0;
for (int i = 1; i < prices.length; i++)
{
int diff = prices[i] - prices[i - 1];
if (diff > 0)
maxProfit += diff;
}
return maxProfit;
}

Best Time to Buy and Sell Stock III

Description: 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 two transactions.
Note: You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

题意：用一个数组表示股票每天的价格，数组的第i个数表示股票在第i天的价格。最多交易两次，手上最多只能持有一支股票，求最大收益。

分析：动态规划法。以第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。

因为能买2次（第一次的卖可以和第二次的买在同一时间），但第二次的买不能在第一次的卖左边。

代码：时间O(n)，空间O(n)。

public int maxProfit(int[] prices)
{
if (prices.length < 2)
return 0;

int n = prices.length;
int[] preProfit = new int
;
int[] postProfit = new int
;

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

Description: 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).

题意：用一个数组表示股票每天的价格，数组的第i个数表示股票在第i天的价格。最多交易k次，手上最多只能持有一支股票，求最大收益。
https://discuss.leetcode.com/topic/26169/clean-java-dp-solution-with-comment/2

/**
* dp[i, j] represents the max profit up until prices[j] using at most i transactions.
* dp[i, j] = max(dp[i, j-1], prices[j] - prices[jj] + dp[i-1, jj]) { jj in range of [0, j-1] }
*          = max(dp[i, j-1], prices[j] + max(dp[i-1, jj] - prices[jj]))
* dp[0, j] = 0; 0 transactions makes 0 profit
* dp[i, 0] = 0; if there is only one price data point you can't make any transaction.
*/

public int maxProfit(int k, int[] prices) {
int n = prices.length;
if (n <= 1)
return 0;

//if k >= n/2, then you can make maximum number of transactions.
if (k >=  n/2) {
int maxPro = 0;
for (int i = 1; i < n; i++) {
if (prices[i] > prices[i-1])
maxPro += prices[i] - prices[i-1];
}
return maxPro;
}

int[][] dp = new int[k+1]
;
for (int i = 1; i <= k; i++) {
int localMax = dp[i-1][0] - prices[0];
for (int j = 1; j < n; j++) {
dp[i][j] = Math.max(dp[i][j-1],  prices[j] + localMax);
localMax = Math.max(localMax, dp[i-1][j] - prices[j]);
}
}
return dp[k][n-1];
}

It basically means we can either do not use the prices[j] (thus, dp[i][j-1]), or use prices[j] (if prices[j] is used, the last transaction must start some point, jj; then, before
jj, we can do at most i - 1 transactions).

At certain i, j, for each jj, prices[j] is not changing. only prices[jj] and dp[i - 1][jj] are changing. So we can separate prices[j] from prices[jj] and dp[i - 1][jj].

1 transaction = buy & sell, which takes at least two days. if k>=n/2 ，it becomes the problem

 <<Best Time to Buy and Sell Stock II>>