买卖股票的最好时机(二)

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 计算最大收益
     * @param prices int整型vector 股票每一天的价格
     * @return int整型
     */
    int maxProfit(vector<int>& prices) {
        int res=0;
        for(int i=1;i<prices.size();i++) {
            if(prices[i]>prices[i-1]) {
                res+=prices[i]-prices[i-1];
            }
        }
        return res;
    }
};

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 计算最大收益
     * @param prices int整型一维数组 股票每一天的价格
     * @return int整型
     */
    public int maxProfit (int[] prices) {
        //持有股票1和不持有股票0两种状态，第0天和第1，2，3...第prices.length天
        int[][] dp = new int[2][prices.length + 1];

        //第0天未持有股票，收益为0
        dp[0][0] = 0;
        //第0天持有股票，不存在，收益为负无穷
        dp[1][0] = Integer.MIN_VALUE;

        for (int i = 1; i <= prices.length; i++) {
            //第i天未持有股票，两个可能：
            //1.在前面i-1天都持有，第i天卖掉了，卖掉价值增加。dp[1][i - 1] + prices[i - 1]
            //2.到当前为止都为未持有，维持第i-1天的结果。dp[0][i - 1]
            dp[0][i] = Math.max(dp[0][i - 1], dp[1][i - 1] + prices[i - 1]);
            //第i天持有股票，两个可能：
            //1.在前面i-1天都未持有，第i天买入了，总价值减少。dp[0][i - 1] - prices[i - 1]
            //2.到当前为止都为持有，维持第i-1天的结果。dp[1][i - 1]
            dp[1][i] = Math.max(dp[1][i - 1], dp[0][i - 1] - prices[i - 1]);
        }

        //获取最后一天卖掉的最大值
        return dp[0][prices.length];
    }
}

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 计算最大收益
     * @param prices int整型一维数组 股票每一天的价格
     * @return int整型
     */
    public int maxProfit (int[] prices) {
        // write code here
        int profit=0;
        for(int i=1;i<prices.length;i++){
           if(prices[i]>prices[i-1]){
             profit+=prices[i]-prices[i-1];  
           }
        }
        return profit;
    }
}

int maxProfit(vector<int>& prices) {
        //完成无限次的交易
        int size=prices.size();
        vector<vector<int>> dp(size,vector<int>(2,0));//1=持有 0=未持有
        dp[0][0]=0;
        dp[0][1]=-prices[0];
        for(int i=1;i<size;++i){
            dp[i][0]=std::max(dp[i-1][0],dp[i-1][1]+prices[i]);
            dp[i][1]=std::max(dp[i-1][1],dp[i-1][0]-prices[i]);
        }
        return dp[size-1][0];
    }

int maxProfit(int* prices, int n ) {
    int sum = 0;
    int i = 0;
    if(n < 2) return 0;
    while(i < n-1) {    //将股票价格画成折线图，计算上升沿的总长度
        if(prices[i] < prices[i+1]) {
            sum += prices[i+1] - prices[i];
        }
        i++;
    }
    return sum;
}

    public int maxProfit (int[] prices) {
        int n=prices.length,profit=0;
        for(int i=1;i<n;i++){
            if(prices[i]>prices[i-1])
                profit+=prices[i]-prices[i-1];
        }
        return profit;
    }

function maxProfit( prices ) {
    // write code here
    let profit = 0
    for(let i = 1; i < prices.length; i++) {
        if(prices[i] > prices[i - 1]) {
            profit += prices[i] - prices[i - 1]
        }
    }
    return profit
}

需要毛的动态规划啊。直接遍历求解
class Solution:
    def maxProfit(self , prices: List[int]) -> int:
        # write code here
        n = len(prices)
        if n < 2:
            return 0
        
        res = 0
        i = 0
        while i < n-1:
            if prices[i+1] > prices[i]:
                res += prices[i+1] - prices[i]
                i += 1
            else:
                i += 1
        return res

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 计算最大收益
     * @param prices int整型vector 股票每一天的价格
     * @return int整型
     */
    int maxProfit(vector<int>& prices) {
        // 时间复杂度O(N)，空间复杂度O(N)
        if (prices.empty()) return 0;
        int dp[2][prices.size()];
        dp[0][0] = -prices[0], dp[1][0] = 0;
        for (int i = 1; i < prices.size(); ++i) {
            dp[0][i] = max(dp[0][i - 1], dp[1][i - 1] - prices[i]);
            dp[1][i] = max(dp[1][i - 1], dp[0][i - 1] + prices[i]);
        }
        return dp[1][prices.size() - 1];
    }
};

class Solution:
    def maxProfit(self , prices: List[int]) -> int:
        n = len(prices)
        #dp[i][0]表示某一天不持股到该天为止的最大收益，dp[i][1]表示某天持股，到该天为止的最大收益
        dp = [[0] * 2 for i in range(n)]
        #第一天不持股，总收益为0
        dp[0][0] = 0
        #第一天持股，总收益为减去该天的股价
        dp[0][1] = -prices[0]
        #遍历后续每天，状态转移
        for i in range(1, n):
            # 第i天不持股有两种情况，第一种昨天就没有买股票，第二种昨天卖出了股票（这里一直保存最大收益，整个过程下来相当于只买了一次）
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i])
            # 第i天持股有两种情况，第一种昨天就持股，第二种昨天不持股，但是今天买入了（这里相当于寻找最最小值了）
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i])
        #最后一天不持股，到该天为止的最大收益
        return dp[n - 1][0]

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 计算最大收益
     * @param prices int整型一维数组 股票每一天的价格
     * @return int整型
     */
    public int maxProfit (int[] prices) {
        // write code here
        int profits = 0;
        int len = prices.length;
        for(int i =1;i<len;i++){
            if(prices[i]>prices[i-1]){
                profits+=prices[i]-prices[i-1]; //逢高卖出
            }
        }
        return profits;
    }
}

class Solution:
    def maxProfit(self , prices ):
        # write code here
        profit = 0
        for i in range(1, len(prices)):
            if prices[i] > prices[i-1]:
                profit += prices[i]-prices[i-1]
        return profit

public class Solution {
    public int maxProfit(int[] prices) {
        int res = 0;
        for (int i = 1; i < prices.length; i++) {
            res += Math.max(prices[i] - prices[i - 1], 0);
        }
        return res;
    }
}