題目：

最佳時間買入賣出股票：你有一個數組儲存了股票在第i天的價錢，現在你可以進行多次買入賣出，但同一時間你手上只能保持一個股票，如何賺的最多

思路：

貪心法，本題和前面的Best Time to Buy and Sell Stock 不同在於，本題可以多次買賣股票，
從而累積賺取所有的價格差。因此用貪心法，基本思想是鎖定一個低價，然後在價格升到區域性最高點
（即下一天的價錢就下降了）時候，丟擲股票，然後把下一天較低的價錢作為買入，接著計算。
要注意最後要處理最後一次的利潤

package Level3;

/**
 * Best Time to Buy and Sell Stock II
 * 
 *  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).
 *
 */
public class S122 {

	public static void main(String[] args) {
		int[] prices = {2,1,2,0,4};
		System.out.println(maxProfit(prices));
	}

	// 貪心法，本題和前面的Best Time to Buy and Sell Stock 不同在於，本題可以多次買賣股票，
	// 從而累積賺取所有的價格差。因此用貪心法，基本思想是鎖定一個低價，然後在價格升到區域性最高點
	// （即下一天的價錢就下降了）時候，丟擲股票，然後把下一天較低的價錢作為買入，接著計算。
	// 要注意最後要處理最後一次的利潤
	public static int maxProfit(int[] prices) {
		if(prices.length == 0){
			return 0;
		}
        int totalProfit = 0;
        int startIndex = 0;
        int i;
        
        for(i=1; i<prices.length; i++){
        	if(prices[i] < prices[i-1]){	// 因為第i天的價錢就下降了，因此把從startIndex到i-1的利潤積累到總利潤中
        		totalProfit += prices[i-1] - prices[startIndex];
        		startIndex = i;		// 更新startIndex
        	}
        }
    	// 記得要處理最後一次的利潤
        if(prices[i-1] > prices[startIndex]){
        	totalProfit += prices[i-1] - prices[startIndex];
        }
        
        return totalProfit;
    }
}
 

Again:

public class Solution {
    public int maxProfit(int[] prices) {
        
        if(prices.length == 0){
            return 0;
        }
        
        int profits = 0;
        int minBuy = prices[0];
        for(int i=1; i<prices.length; i++){
            if(prices[i] < prices[i-1]){
                profits += prices[i-1]-minBuy;
                minBuy = prices[i];
            }else{
                
            }
        }
        if(prices[prices.length-1] > minBuy){
            profits += prices[prices.length-1]-minBuy;
        }
        return profits;
    }
}
 

其實最簡單的做法是：

計算每個相鄰的diff差，只要diff大於0，就累積起來

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