买卖股票的最佳时机III

 

 

详细思路

具有某种递归关系，最多进行几笔用第三维，不可能作为边界的初始化为-0x3f3f3f3f，k次数超过一半就是无数次交易的函数

 

精确定义

dpijt 第i天0代表还没开始1代表第1天，0无股票1有股票，正在处理第t笔交易，t=0代表最多买入0次，t=1代表最多买入一次

 

转移

3 3 5 0 0 3 1 4 

一旦买入必须说明t-1，卖出不用管

dp i 0 t=max(dpi-1 0 t , dp i-1 1 t +val)

dp i 1 t=max(dp i-1 1 t,dp i-1 0 t -val)

 

初始化

dp i 0 0=0

dp 0 0 t=0

无论什么时候，最多0笔交易答案必定为0，无论什么时候，还没开始最多无数次买入利润也是0

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int k=2;
        int n=prices.size();
        if(k>=n/2)k=n/2;
        vector<vector<vector<int>>>dp(n+1,vector<vector<int>>(2,vector<int>(k+1,-0x3f3f3f3f)));
        for(int i=0;i<=n;i++)dp[i][0][0]=0;
        for(int t=0;t<=k;t++)dp[0][0][t]=0;
        for(int i=1;i<=n;i++){
            for(int t=1;t<=k;t++){
                dp[i][0][t]=max(dp[i-1][0][t],dp[i-1][1][t]+prices[i-1]);
                dp[i][1][t]=max(dp[i-1][1][t],dp[i-1][0][t-1]-prices[i-1]);
            }
        }
        return dp[n][0][k];
    }
    int unlimited(vector<int>& prices) {
        int n=prices.size();
        vector<vector<int>>dp(n+1,vector<int>(2,-0x3f3f3f3f));
        dp[0][0]=0;
        for(int i=1;i<=n;i++){
            dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i-1]);
            dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i-1]);
        }
        return dp[n][0];
    }
};

踩过的坑

第三维t是最多进行了，而不是已经进行了，也不是正在进行，不然的话你也

不应该返回dp[n][0][k]而是返回dp[n][0][t]的最大值

 

每次买入，最多买入的次数t要从t-1推过来，卖出的话最多买入次数是不变的

                dp[i][0][t]=max(dp[i-1][0][t],dp[i-1][1][t]+prices[i-1]);

                dp[i][1][t]=max(dp[i-1][1][t],dp[i-1][0][t-1]-prices[i-1]);

无论什么时候，最多0笔交易答案必定为0，无论什么时候，还没开始最多无数次买入利润也是0

        for(int i=0;i<=n;i++)dp[i][0][0]=0;

        for(int t=0;t<=k;t++)dp[0][0][t]=0;

 

 

状态压缩

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int k=2;
        int n=prices.size();
        if(k>=n/2)k=n/2;
        vector<vector<vector<int>>>dp(2,vector<vector<int>>(2,vector<int>(k+1,-0x3f3f3f3f)));
        for(int i=0;i<=n;i++)dp[i%2][0][0]=0;
        for(int t=0;t<=k;t++)dp[0][0][t]=0;
        for(int i=1;i<=n;i++){
            for(int t=1;t<=k;t++){
                dp[i%2][0][t]=max(dp[(i-1)%2][0][t],dp[(i-1)%2][1][t]+prices[i-1]);
                dp[i%2][1][t]=max(dp[(i-1)%2][1][t],dp[(i-1)%2][0][t-1]-prices[i-1]);
            }
        }
        return dp[n%2][0][k];
    }
    int unlimited(vector<int>& prices) {
        int n=prices.size();
        vector<vector<int>>dp(2,vector<int>(2,-0x3f3f3f3f));
        dp[0][0]=0;
        for(int i=1;i<=n;i++){
            dp[i%2][0]=max(dp[(i-1)%2][0],dp[(i-1)%2][1]+prices[i-1]);
            dp[i%2][1]=max(dp[(i-1)%2][1],dp[(i-1)%2][0]-prices[i-1]);
        }
        return dp[n%2][0];
    }
};


k较难压缩，因为dp[t]出现在等号右边干扰