---
# System prepended metadata

title: LC 122. Best Time to Buy and Sell Stock II
tags: [medium, leedcode, DP, Greedy, python, c++]

---

# LC 122. Best Time to Buy and Sell Stock II

### [Problem link](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)

###### tags: `leedcode` `python` `c++` `medium` `Greedy` `DP`

## Description

You are given an integer array `prices` where `prices[i]` is the price of a given stock on the `i^th` day.

On each day, you may decide to buy and/or sell the stock. You can only hold **at most one**  share of the stock at any time. However, you can buy it then immediately sell it on the **same day** .

Find and return the **maximum**  profit you can achieve.

**Example 1:** 

```
Input: prices = [7,1,5,3,6,4]
Output: 7
Explanation: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
Total profit is 4 + 3 = 7.
```

**Example 2:** 

```
Input: prices = [1,2,3,4,5]
Output: 4
Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
Total profit is 4.
```

**Example 3:** 

```
Input: prices = [7,6,4,3,1]
Output: 0
Explanation: There is no way to make a positive profit, so we never buy the stock to achieve the maximum profit of 0.
```

**Constraints:** 

- `1 <= prices.length <= 3 * 10^4`
- `0 <= prices[i] <= 10^4`

## Solution 1 - Greedy
#### Python
```python=
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        res = 0

        for i in range(1, n):
            if prices[i] > prices[i - 1]:
                res += prices[i] - prices[i - 1]

        return res

```
#### C++
```cpp=
class Solution {
public:
    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;
    }
};
```

## Solution 1 - DP
```python=
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        '''
        dp[i][0]: 第i天時擁有股票的最大利潤
        dp[i][1]: 第i天時不擁有股票的最大利潤
        '''
        dp = [[0, 0] for _ in range(n)]
        dp[0][0] = -prices[0]

        for i in range(1, n):
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i])
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i])

        return dp[-1][1]
```

>### Complexity
>|             | Time Complexity | Space Complexity |
>| ----------- | --------------- | ---------------- |
>| Solution 1  | O(n)            | O(1)             |
>| Solution 1  | O(n)            | O(n)             |

## Note
Greedy - Find the daily profit first, and then find the maximum profit.
