买股票最佳时机（1次多次2次）

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。
注意你不能在买入股票前卖出股票。
示例 1:
输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
一次

public class MaxProfit {
    public int maxProfit(int[] prices) {
        int[] dp=new int[prices.length+1];
        dp[0]=0;
        int min=Integer.MAX_VALUE;
        for (int i = 0; i <prices.length ; i++) {
            if (prices[i]<min)min=prices[i];
            dp[i+1]=Math.max(dp[i],prices[i]-min);
        }
        return dp[dp.length-1];
    }
 
    public static void main(String[] args) {
        MaxProfit a=new MaxProfit();
        int[] b={7,1,5,3,6,4};
        System.out.println(a.maxProfit(b));
    }
}
/
public int maxProfit_1(int[] prices) {
	for (int i = 0; i < n; i++) { 
		if (i == 0) {		
			// dp[i][0] = max(dp[-1][0], dp[-1][1] + prices[i]) 
			//          = max(0, -infinity + prices[i]) 
			//  		= 0 
			dp[i][0] = 0;
		 
			// dp[i][1] = max(dp[-1][1], dp[-1][0] - prices[i]) 
			// 			= max(-infinity, 0 - prices[i]) 
			// 			= -prices[i] 
			dp[i][1] = -prices[i];
			continue; 
		} 
		dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] + prices[i]);
		dp[i][1] = Math.max(dp[i-1][1], -prices[i]); 
	} 
	return dp[n - 1][0];
}


##########################################################
public int maxProfit_2(int[] prices) {
	int n = prices.length;
	// Base Case: dp[-1][0] = 0, dp[-1][1] = -infinity
	int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
	for (int i = 0; i < n; i++) { 
		// dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
		dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]); 
		// dp[i][1] = max(dp[i-1][1], -prices[i]) 
		dp_i_1 = Math.max(dp_i_1, -prices[i]); 
	} 
	return dp_i_0;
}

多次交易

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

两次交易

public int maxProfit_3(int[] prices){
	int max_k = 2; 
	int[][][] dp = new int[n][max_k + 1][2]; 
	// 穷举了 n × max_k × 2 个状态
	for (int i = 0; i < n; i++) { 
		for (int k = max_k; k >= 1; k--) { 
			if (i == 0) { /* 此处省略 Base Case */ } 
			dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + 	prices[i]); 
			dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i]); 
		} 
	} 
	return dp[n - 1][max_k][0];
}
//
dp[i][2][0] = max(dp[i-1][2][0], dp[i-1][2][1] + prices[i])
dp[i][2][1] = max(dp[i-1][2][1], dp[i-1][1][0] - prices[i])
dp[i][1][0] = max(dp[i-1][1][0], dp[i-1][1][1] + prices[i])
dp[i][1][1] = max(dp[i-1][1][1], -prices[i])
#########################################################
public int maxProfit_3(int[] prices) {
	int dp_i10 = 0, dp_i11 = Integer.MIN_VALUE;
	int dp_i20 = 0, dp_i21 = Integer.MIN_VALUE;
	for (int i = 0; i < n; i++) {
		dp_i20 = Math.max(dp_i20, dp_i21 + prices[i]); 
		dp_i21 = Math.max(dp_i21, dp_i10 - prices[i]); 
		dp_i10 = Math.max(dp_i10, dp_i11 + prices[i]); 
		dp_i11 = Math.max(dp_i11, -prices[i]); 
	} 
	return dp_i20;
}

max_k∈N

public int maxProfit_4(int max_k, int[] prices) {
	int n = prices.length;
	if (max_k > n / 2) 
		return maxProfit_2(prices); // 代码参见买卖股票的最佳时机 II
	int[][][] dp = new int[n][max_k + 1][2];
	for (int i = 0; i < n; i++) {
		for (int k = max_k; k >= 1; k--) {
			if (i == 0) {
                dp[i][k][0] = 0;
                dp[i][k][1] = -prices[i];
                continue;
            }
			dp[i][k][0] = Math.max(dp[i-1][k][0], dp[i-1][k][1] + prices[i]);
			dp[i][k][1] = Math.max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i]);
		}
	}
	return dp[n-1][max_k][0];
}