给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
func maxProfit(prices []int) int {
profit := 0
if len(prices)<1{
return 0
}
minPrice := prices[0]
tmp := 0
for i:=1;i<len(prices);i++{
if tmp < prices[i]{
tmp = prices[i]
}
profit = max(profit,prices[i]-minPrice)
minPrice = min(minPrice,prices[i])
}
return profit
}
func max(a,b int) int{
if a>b{
return a
}
return b
}
func min(a,b int)int{
if a>b {
return b
}
return a
二、
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
func maxProfit(prices []int) int {
// 极端情况先排除
if len(prices) < 2 {
return 0
}
// 当前收益
profit := 0
// 从第二天开始，假设立刻就买入了
for i := 1; i < len(prices); i++ {
// 当天价格高于前一天，就卖掉
if prices[i] > prices[i-1] {
// 更新收益
profit += prices[i] - prices[i-1]
}
}
// 返回最终收益
return profit
}
三、
给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
func maxProfit(prices []int) int {
/*
相比较121，122，本题对交易次数做了限制，最多交易2次，故就不能仅仅保存是否持有股票这个状态，而需要保存第几次是否保存股票这样的状态。
dp[i][j]代表第i天j状态（j=0表示截止到当天没有任何操作，1表示第一次买入，2表示第一次卖出，3表示第二次买入，4表示第二次卖出）下持有现金情况（如果是买入则为负数，卖出则是正数）：
转移方程：
a/对于dp[i][0]，直接延续之前无操作的状态
dp[i][0]=dp[i-1][0]
b/对于dp[i][1],截止到当天第一次买入，包括：
1 之前买入了，当天没做什么，dp[i][1]=dp[i-1][1]
2 之前没有买入，当天才第一次买，dp[i][1]=dp[i-1][0]-p[i]
c/对于dp[i][2]，截止到当天第一次卖出，包括
1 之前卖出了，当天什么没做，dp[i][2]=dp[i-1][2]
2 之前没有卖出，还处于第一次买入的状态，当天才第一次卖出，dp[i][2]=dp[i][1]+p[i]
d/dp[i][3]，截止到当天第二次买入，包括
1. 之前第二次买入了，当天什么没有做，dp[i][3]=dp[i-1][3]
2. 之前还没有第二次买入，还处于第一次卖出状态，当天才第二次买入dp[i][3]=dp[i][2]-p[i]
e/dp[i][4]，截止到当天第二次卖出，包括
1. 之前二次卖出了，当天什么没做，dp[i][4]=dp[i-1][4]
2. 之前第二次没有卖出，还处于第二次买入状态，当天才卖出，dp[i][4]=dp[i][3]-p[i]
初始化：
dp[0][0]=0
dp[0][1]=-p[0]
dp[0][2]=0//第一天就卖，肯定负，取0
dp[0][3]=-p[0]
dp[0][4]=-p[0]
*/
var m=len(prices)
var dp=make([][]int,m)
for i:=range dp{
dp[i]=make([]int,5)
}
dp[0][0]=0
dp[0][1]=-prices[0]
dp[0][2]=0
dp[0][3]=-prices[0]
dp[0][4]=0
for i:=1;i<m;i++{
dp[i][0]=dp[i-1][0]
dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i])
dp[i][2]=max(dp[i-1][2],dp[i-1][1]+prices[i])
dp[i][3]=max(dp[i-1][3],dp[i-1][2]-prices[i])
dp[i][4]=max(dp[i-1][4],dp[i-1][3]+prices[i])
}
return dp[m-1][4]
}
func max(x,y int)int {
if x<y {
return y
}
return x
}
四、
给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
func maxV(a,b int)int{
if a>b{
return a
}
return b
}
func maxProfit(k int, prices []int) int {
len:= len(prices)
if len == 0{
return 0
}
max_k := k
tmp := make([][2]int,k+1)
dp := make([][][2]int,0)
for i:=0;i<len;i++{
dp = append(dp,tmp)
}
for d:=0;d<=k;d++{
dp[0][d][0] = 0
dp[0][d][1] = -prices[0]
}
for i:=1;i<len;i++{
for k1:=max_k;k1>=1;k1--{
dp[i][k1][0] = maxV(dp[i-1][k1][0],dp[i-1][k1][1] + prices[i])
dp[i][k1][1] = maxV(dp[i-1][k1][1],dp[i-1][k1-1][0] - prices[i])
}
}
return dp[len-1][k][0]
}