算法套路十七——买卖股票问题：状态机 DP

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。
在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
返回 你能获得的 最大 利润 。

给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。
你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。
返回获得利润的最大值。
注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

与示例一样的思路，只是需要在购买时不仅减去股票价格，并减去手续费

func maxProfit(prices []int, fee int) int {
    n := len(prices)
    dp := make([][]int, n+1)
    for i := range dp {
        dp[i] = make([]int, 2)
    }
    dp[0][1] = -math.MaxInt32
    for i, price := range prices {
    	//不买或卖
        dp[i+1][0] = max(dp[i][0], dp[i][1]+price)
        //买并支付小费
        dp[i+1][1] = max(dp[i][0]-price-fee, dp[i][1])
        
    }
    return dp[n][0]
}
func max(x, y int) int {if x > y {return x};return y}

给定一个整数数组prices，其中第 prices[i] 表示第 i 天的股票价格 。​设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

本题与示例唯一的差距在于多了冷冻期，而这也只会影响买股票这一种情况，由于冷冻期，所以在计算买股票这种情况时，只能用2天前且手上没有股票的最大利润来计算，且第一天结束时不存在前一天买入的情况，因此我们需要对第一天单独处理。

func maxProfit(prices []int) int {
    n := len(prices)
    dp := make([][]int, n+1)
    for i := range dp {
        dp[i] = make([]int, 2)
    }
    //-math.MaxInt32表示不符合现实
    dp[0][1] = -math.MaxInt32
    for i, price := range prices {
        //当前没有股票，只能不买或卖
        dp[i+1][0] = max(dp[i][0], dp[i][1]+price)
        //当前有股票，只能买或不卖
        if i>0{
        //i>0时，对于买的情况，由于冷冻期所以只能用dp[i-1][0]即2天前且手上没有股票的最大利润
        dp[i+1][1] = max(dp[i-1][0]-price, dp[i][1])
        }else {
            //i=0即第一天想要有股票只能买
            dp[i+1][1] =-price
        }
    }
    return dp[n][0]
}
func max(x, y int) int {if x > y {return x};return y}

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格，和一个整型 k 。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。也就是说，你最多可以买 k 次，卖 k 次。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

直接采用上题的思路，将j的范围由0-2修改到0-k即可

func maxProfit(k int, prices []int) int {
    n := len(prices)
    dp := make([][][2]int, n+1)
    for i:=range dp{
        dp[i]=make([][2]int,k+1)
        for j:=0;j<k+1;j++{
            dp[i][j][1] = math.MinInt32/2
        }
    }
    for i:=0;i<n;i++{
        for j:=0;j<k;j++{
            //不买或卖
            dp[i+1][j+1][0]=max(dp[i][j+1][0],dp[i][j+1][1]+prices[i])
            //不卖或买，买即增加一次交易
            dp[i+1][j+1][1]=max(dp[i][j+1][1],dp[i][j][0]-prices[i])
        }
    }
    return dp[n][k][0]
}
func max(x, y int) int {if x > y {return x};return y}

一个下标从 0 开始的数组的 交替和 定义为 偶数 下标处元素之 和 减去 奇数 下标处元素之 和 。
比方说，数组 [4,2,5,3] 的交替和为 (4 + 5) - (2 + 3) = 4 。
给你一个数组 nums ，请你返回 nums 中任意子序列的 最大交替和 （子序列的下标 重新 从 0 开始编号）。
一个数组的 子序列 是从原数组中删除一些元素后（也可能一个也不删除）剩余元素不改变顺序组成的数组。比方说，[2,7,4] 是 [4,2,3,7,2,1,4] 的一个子序列（加粗元素），但是 [2,4,2] 不是。

类比买卖股票，区别在于本题刚开始就已经0元买进了股票，故初始化数组dp[0][1] =0，dp[0][0] =math.MinInt64 / 2，其余则和示例思路一样

func maxAlternatingSum(nums []int) int64 {
    //类比买卖股票，即第一次0元买进，之后卖出
    n := len(nums)
    dp := make([][]int, n+1)
    for i := range dp {
        dp[i] = make([]int, 2)
    }
    //负无穷表示不符合题意，/2防止越界
    dp[0][0] =math.MinInt64 / 2
    //开始0元买进了股票
    dp[0][1] =0
    for i, num := range nums {
        dp[i+1][0] = max(dp[i][0], dp[i][1]+num)
        dp[i+1][1] = max(dp[i][0]-num, dp[i][1])
    }
    return int64(dp[n][0])
}
func max(x, y int) int {if x > y {return x};return y}