Leetcode - Best Time to Buy and Sell Stock 2
์๊ณ ๋ฆฌ์ฆ ๊ณต๋ถ
๋ฌธ์ ๋ ํด์ํ๋ฉด ์ด๋ ๋ค. ์ด์ ๊ณผ ๋ค๋ฅด๊ฒ ๋ค์ํ ๋ ์ง์ ์ฌ๊ณ ํ๋ ค๊ณ ํ๋ค. ๋ค๋ง ์ฃผ์์ ํ๋ฒ์ ์ต๋ ํ ๊ฐ๋ง ๊ฐ์ง๊ณ ์์ด์ผ ํ๋ฉฐ ๋์ผ ๋ ์ง์ ๋งค๋ ํ ๋งค์๊ฐ ๊ฐ๋ฅํ๋ค.
์ด๋ฐ ์ํฉ์์ ๊ฐ์ฅ ํฐ ์์ต์ ๊ตฌํ๋ฉด ๋๋ค.
๐ Greedy Solution
๋ฌธ์ ๋ฅผ ์๊ฐํด๋ณด๋ฉด ๊ณ์ ์ฌ๊ณ ํ๊ณ ๋ฅผ ์งํํด์ผ๋๋ ๊ฒ ๊ฐ๋ค. ๊ทธ๋ ๋ค๋ฉด ๋ด๊ฐ ๋ด์ผ๋ณด๋ค ์ธ๊ฒ ๋งค์ํ๋ค๋ฉด ํญ์ ์ด๋์ด ์๋๊น?
์๋ฅผ ๋ค์ด [1,2,1,2,8]
๋ฐ์ดํฐ๋ฅผ ๋ณธ๋ค๊ณ ํ ๋ ๋ต์ 1์ ๋งค์ 2์ ๋งค๋ / 1์ ๋งค์ 8์ ๋งค๋
๋ก ์ด 8์ ์์ต์ ์ฌ๋ฆด ์ ์๋ค.
ํ์ง๋ง ์ ๋ต์ ๊ฒฐ๊ตญ 1์ ๋งค์ 2์ ๋งค๋ / 1์ ๋งค์ 2์ ๋งค๋ / 2์ ๋งค์ 8์ ๋งค๋
์ ๊ฐ์ผ๋ฉฐ ํด๋น ์ด๋ ์ญ์ 8์ด ๋๊ฒ ๋๋ค.
์ฆ ์ต์ ์ ๋งค๋ ํ์ด๋ฐ์ ์ฐพ๋ ๊ฒ์ด ์๋๋ผ ๋ค์๋ ๋ณด๋ค๋ง ์ธ๋ค๋ฉด ๋งค์๋ฅผ ํ๋ฉด ๋๋ ๊ฒ์ด๋ค. ์ด๋ฅผ ์๋ ์ฝ๋์ฒ๋ผ ํํํ ์ ์๋ค.
class Solution:
def maxProfit(self, prices: List[int]) -> int:
days = len(prices)
profit = 0
for day in range(days-1):
if prices[day] < prices[day+1]:
profit += (prices[day+1] - prices[day])
return profit
TC : O(N)
SC : O(1)
๋ฉด์ ๊ด์ด ๋ค๋ฅธ ํ์ด๋ฅผ ๋ ์ฌ๋ ค๋ณด๋ผ ํ๋ค.
๐ชซ Dynamic Programming Solution
์ฃผ์ ๋งค๋งค์๋ ๋ ๊ฐ์ ์ก์
์ ์ทจํ ์ ์๋ค. ๊ด๋ง ํน์ ๋งค์. ๊ทธ๋ ๋ค๋ฉด ๋ด๊ฐ ํน์ ๋ ์ง์ ๋งค์ํ์ ๋, ํน์ ๋งค์ํ์ง ์๊ณ ๊ด๋ง๋ง ํ ๋๋ฅผ DP
๋ก ์ฒ๋ฆฌํ ์ ์๋ค.
class Solution:
def maxProfit(self, prices: List[int]) -> int:
days = len(prices)
STAY, HOLD = 0, 1
dp = [[0 for _ in range(days)] for _ in range(2)]
dp[HOLD][0] = -prices[0]
for day in range(1, days):
dp[STAY][day] = max(dp[STAY][day-1], dp[HOLD][day-1]+prices[day])
dp[HOLD][day] = max(dp[HOLD][day-1], dp[STAY][day-1]-prices[day])
return dp[STAY][days-1]
STAY
๋ ๊ด๋ง์ด๋ฉฐ HOLD
๋ ์ฃผ์์ ๋ณด์ ํ๋ค๋ ๊ฒ์ด๋ค. ๋ฐ๋ผ์ ์ฒซ์งธ๋ dp[HOLD]๋ ์ฃผ์์ ๋งค์ํ๊ธฐ์ ์์๊ฐ์ผ๋ก ์ทจํด์ค๋ค.
๊ทธ ๋ค์๋ถํฐ๋ ๋ณธ๊ฒฉ์ ์ผ๋ก DP
๊ฐ ์์๋๋ค.
- ๊ด๋งํ๋ ๊ฒฝ์ฐ : ์ ๋ ์ ๊ด๋งํ์ ๋ ์ป์ ์์ต, ๋ณด์ ์ค์ธ ์ฃผ์์ ๋งค๋ํ์ฌ ์์ต์ ๋ด๋ ๊ฒฝ์ฐ ์ค ํฐ ๊ฐ์ ์ ์ฅํ๋ค.
- ๋งค์ํ๋ ๊ฒฝ์ฐ : ์ ๋ ์ ๋ณด์ ํ์ ๋ ์ป์ ์์ต, ์ด์ ๊น์ง ๊ด๋งํด์ ์ป์ ์์ต์์ ์ค๋ ์ฃผ์์ ๋งค์ํ์ฌ ๋น ์ง ๊ฐ ์ค ํฐ ๊ฐ์ ์ ์ฅํ๋ค.
๋ง์ง๋ง์ผ๋ก ๋ฆฌํดํ ๋๋ ๋ฌด์กฐ๊ฑด ๋งค๋๋ฅผ ํด์ผ๋๊ธฐ์ STAY index๋ฅผ ๋ณด๊ฒ ๋๋ค.
TC : O(N)
SC : O(N)
์ด๋ฐ ์ํฉ์์๋ ํฌ๊ฒ DP๊ฐ ์๋ฟ์ง๋ ์๋ ๊ฒ ๊ฐ๋ค.