【LeetCode算法学习笔记】股票买卖问题

labuladong算法公众号个人学习笔记

用“状态机”的技巧来解决问题，即DP table。

穷举框架

利用[状态]进行穷举，看看总共有几种可能的[状态]，再找出每个[状态]对应的[选择]。
每天有三种选择：买入，卖出，无操作。
有三个状态：天数，允许交易的最大次数，当前持有的状态。

for 0<=i<=n:
//n为天数
    for 0<=k<=K:
    //K为最多交易次数
        for s in {0,1}:
        //s为当前持有状态
            dp[i][k][s]=max(buy,sell,rest);
//所求的最终答案是dp[n-1][K][0]

状态转移框架

base case:

/*base case*/
dp[-1][k][0]=dp[i][0][0]=0 //还未开始  不允许交易
dp[-1][k][1]=dp[i][0][1]=-infinity //不可能持有股票

状态转移方程：

/*状态转移方程*/
dp[i][k][0]=max(dp[i-1][k][0], dp[i-1][k][1]+prices[i])
          //max(   选择rest  ，    选择sell            )
dp[i][k][1]=max(dp[i-1][k][1], dp[i-1][k-1][0]-prices[i])
          //max(   选择rest  ，    选择buy             )

题目

121

//k==1
int maxProfit(int[] prices){
    int n=prices.length;
    int dp_i_0=0,dp_i_1=Integer.MIN_VALUE;
    for(int i=0;i<n;i++){
        dp_i_0=Math.max(dp_i_0, dp_i_1+prices[i]);
        dp_i_1=Math.max(dp_i_1, -prices[i]);
    }
    return dp_i_0;
}

122

//k为正无穷，则k和k-1是一样的。就可以改写框架。
int maxProfit(int[] prices){
    int n=prices.length;
    int dp_i_0=0,dp_i_1=Integer.MIN_VALUE;
    for(int i=0;i<n;i++){
        int temp=dp_i_0;
        dp_i_0=Math.max(dp_i_0, dp_i_1+prices[i]);
        dp_i_1=Math.max(dp_i_1, temp-prices[i]);
    }
    return dp_i_0;
}

309

//多次买卖一只股票
//有冷冻期，即卖出股票后，无法在第二条就买入股票
dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]);
dp[i][1]=max(dp[i-1][1],dp[i-2][0]-prices[i]);

//k为无穷，但含有冷冻期，每次sell后要等一天才能继续交易。
int maxProfit(int[] prices){
    int n=prices.length;
    int dp_i_0=0,dp_i_1=Integer.MIN_VALUE;
    int dp_pre_0=0;//dp[i-2][0]
    for(int i=0;i<n;i++){
        int temp=dp_i_0;
        dp_i_0=Math.max(dp_i_0, dp_i_1+prices[i]);
        dp_i_1=Math.max(dp_i_1, dp_pre_0-prices[i]);
        dp_pre_0=temp;
    }
    return dp_i_0;
}

714

含有手续费，减掉即可

int maxProfit(int[] prices,int fee){
    int n=prices.length;
    int dp_i_0=0,dp_i_1=Integer.MIN_VALUE;
    for(int i=0;i<n;i++){
        int temp=dp_i_0;
        dp_i_0=Math.max(dp_i_0, dp_i_1+prices[i]);
        dp_i_1=Math.max(dp_i_1, temp-prices[i]-fee);
    }
    return dp_i_0;
}

123

k为2的情况与前面都不相同，前面的情况都与k无关。

int maxProfit(int[] prices,int fee){
    int n=prices.length;
    int dp_i20=0,dp_i21=Integer.MIN_VALUE;
    int dp_i10=0,dp_i11=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_i11-prices[i]);
        dp_i10=Math.max(dp_i10, dp_i11+prices[i]);
        dp_i11=Math.max(dp_i11, -prices[i]);
    }
    return dp_i20;
}

188

一次交易由买入和卖出构成，至少需要两天。所以说有效的限制k应该不超过n/2。