买卖股票6种类型

股票类型的问题很繁多，有许多变种，这里全部简写，把常见的几种变种列举出来

下面规定股票买卖次数为k

第一种，买卖次数k为一次

int maxProfit(vector<int>& prices) {
        int n=prices.size();
        int dp_i_0=0,dp_i_1=-10000;
        for(int i=0;i<n;i++)
        {
           dp_i_0=max(dp_i_0,dp_i_1+prices[i]);
           dp_i_1=max(dp_i_1,-prices[i]); 
        }
        return dp_i_0;
        }

第二种，买卖次数为无限次

int maxProfit(vector<int>& prices) {
        int n=prices.size();
        int dp_i_0=0,dp_i_1=-10000;
        int temp;
        for(int i=0;i<n;i++)
        {
            temp=dp_i_0;
            dp_i_0=max(dp_i_0,dp_i_1+prices[i]);
            dp_i_1=max(dp_i_1,temp-prices[i]);
        }
        return dp_i_0;
    }

第三种，买卖次数k为2次

int maxProfit(vector<int>& prices) {
        int max_k=2;
        int n=prices.size();
        if(n==0)
            return 0;
        int dp[n][max_k+1][2]={0};
        for(int i=0;i<n;i++)
            for(int k=max_k;k>=1;k--)
            {
                if(i-1==-1)
                {
                    dp[i][k][0]=0;
                    dp[i][k][1]=-prices[i];
                    continue;
                }
                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];
    }

第四种，买卖次数k为有限次，k由输入给定

int maxProfit_inf(vector<int>& prices){
    int len_ = prices.size();
    int dp_i_0 = 0;
    int dp_i_1 = INT_MIN;
    for(int i=0; i<len_; i++){
        int tmp = dp_i_0;
        dp_i_0 = max(dp_i_0, dp_i_1+prices[i]);
        dp_i_1 = max(dp_i_1, tmp-prices[i]);
    }
    return dp_i_0;
    }
    int maxProfit(int k, vector<int>& prices) {
        int max_k=k;
        int n=prices.size();
        if(n==0)
            return 0;
//当k大于n/2，k就不起到约束作用
        if(max_k>n/2)
        return maxProfit_inf(prices);    
        int dp[n][max_k+1][2]={0};
        for(int i=0;i<n;i++)
            for(int k=max_k;k>=1;k--)
            {
                if(i-1==-1)
                {
                    dp[i][k][0]=0;
                    dp[i][k][1]=-prices[i];
                    continue;
                }
                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];
    }

第五种，k为无限次，然后买次交易需要交手续费fee

int maxProfit(vector<int>& prices, int fee) {
         int n=prices.size();
        int dp_i_0=0,dp_i_1=-100000;
        int temp;
        for(int i=0;i<n;i++)
        {
            temp=dp_i_0;
            dp_i_0=max(dp_i_0,dp_i_1+prices[i]);
            dp_i_1=max(dp_i_1,temp-prices[i]-fee);
        }
        return dp_i_0;
    }

第六种，k为无限次，其中交易之后，需等待一天，才能进行第二次交易

 int maxProfit(vector<int>& prices) {
        int n=prices.size();
        int dp_i_0=0,dp_i_1=-100000,dp_pre_0=0;
        int temp;
        for(int i=0;i<n;i++)
        {
            temp=dp_i_0;
            dp_i_0=max(dp_i_0,dp_i_1+prices[i]);
            dp_i_1=max(dp_i_1,dp_pre_0-prices[i]);
             dp_pre_0=temp;
        }
        return dp_i_0;
    }