
๐ค๋ฌธ์ ํด๊ฒฐ
-
Lv3
ํ์ ์ด ์ด์๋จ์ ์ ์๋ ์กฐ๊ฑด:
- ๋ด ํ์ ๊ธฐ์ค ์ผ์ชฝ ํ์ ํฌ๊ธฐ๊ฐ ํด ๋
- ๋ด ํ์ ๊ธฐ์ค ์ค๋ฅธ์ชฝ ํ์ ํฌ๊ธฐ๊ฐ ํด ๋
- ๋ง์ฝ ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ ๋๋ค ํฌ๊ธฐ๊ฐ ์์ผ๋ฉด ํ์ ์ ์ฃฝ๋๋ค
์ด ๋ฌธ์ ์์ ํต์ฌ์ ํ์ ์ ํฌ๊ธฐ๊ฐ ๊ฐ์ฅ ์์ ๋ ์๋ค์ ํ๋์ฉ ๋ฝ์์ฃผ๋ฉด ๋๋ ๊ฒ!

๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ์ ํด์ฃผ๋ฉด

- ํฌ๊ธฐ๊ฐ ๊ฐ์ฅ ์์ ํ์ (5)์ ๋ฌด์กฐ๊ฑด ์ด์๋จ๋๋ค. - (๋ชจ๋ ๋ค ํฐํธ๋ฆด ์ ์๋ค)
- ํฌ๊ธฐ๊ฐ ๋๋ฒ์งธ๋ก ์์ ํ์ (6)๋ ๋ฌด์กฐ๊ฑด ์ด์๋จ๋๋ค. - (์์ ๋ณด๋ค ์์ ํ์ (5)์ ํฐํธ๋ฆด ์ฐฌ์ค๊ฐ 1๋ฒ ์๊ธฐ ๋๋ฌธ)
- ํฌ๊ธฐ๊ฐ ์ธ๋ฒ์งธ๋ก ์์ ํ์ (7) ๋ถํฐ๋ ์ธ๋ฑ์ค์ ์ํฉ์ ๋ฐ๋ผ ๊ฒฐ์ ๋๋ค.
๋ง์ฝ 7์ด ์์ ๋ ํ์ ์ฌ์ด์ ์์ ๊ฒฝ์ฐ ์์ ์ ์์ชฝ์ด ๋ชจ๋ ์๊ธฐ ๋๋ฌธ์ ํ์ ์ ์ฃฝ๋๋ค.
ํ์ง๋ง ๋ ํ์ ์ฌ์ด๊ฐ ์๋๋ผ๋ฉด ( 5 < 6 < 7 )
7 ํ์ ์ ์ค๋ฅธ์ชฝ์ ๋ชจ๋ 7 ํ์ ๋ณด๋ค ํฌ๊ธฐ๊ฐ ํฌ๊ธฐ ๋๋ฌธ์ ๋ค ํฐํธ๋ฆด ์ ์๋ค.
7 ํ์ ์ ์ผ์ชฝ์ 5 ํ์ ์ด ๋ค๋ฅธ ๋ชจ๋ ํ์ ์ ํฐํธ๋ฆด ์ ์๋ค.
๊ฒฐ๊ณผ์ ์ผ๋ก 7 ํ์ ๊ณผ 5 ํ์ ์ด ๋จ๊ฒ ๋๋ฉด ์ฐฌ์ค๋ฅผ ์ฌ์ฉํด 5 ํ์ ์ ํฐํธ๋ฆฐ๋ค.
!! ์์ฝํ์๋ฉด ์์ ๋ ํ์ ์ฌ์ด์ ๋ค์ด๊ฐ์ง ์๋๋ค๋ฉด ํ์ ์ ์ด์๋จ๊ฒ ๋๋ ๊ฒ!
๐จ ๋์ ๊ฒฝ์ฐ sort๋ฅผ ๋ฐ๋ก ํด์ฃผ๊ธฐ๋ณด๋ค ์ฐ์ ์์ ํ๋ฅผ ์ด์ฉํ๋ค(ํํ)
๐ป์์ค ์ฝ๋
import heapq
def solution(a):
if len(a) < 3:
return len(a)
answer = 2
pq = []
for i in range(len(a)):
heapq.heappush(pq, (a[i], i))
left = heapq.heappop(pq)[1]
right = heapq.heappop(pq)[1]
if left > right:
left, right = right, left
while pq:
c = heapq.heappop(pq)[1]
if c < left:
answer += 1
left = c
elif c > right:
answer += 1
right = c
return answer
๐๋ฌธ์ ํ์ธ
์ถ์ฒ: ํ๋ก๊ทธ๋๋จธ์ค
๋งํฌ: https://programmers.co.kr/learn/courses/30/lessons/68646?language=python3
์ฝ๋ฉํ ์คํธ ์ฐ์ต - ํ์ ํฐํธ๋ฆฌ๊ธฐ
[-16,27,65,-2,58,-92,-71,-68,-61,-33] 6
programmers.co.kr
๋ฌธ์ ์ค๋ช
์ผ๋ ฌ๋ก ๋์ด๋ n๊ฐ์ ํ์ ์ด ์์ต๋๋ค. ๋ชจ๋ ํ์ ์๋ ์๋ก ๋ค๋ฅธ ์ซ์๊ฐ ์จ์ ธ ์์ต๋๋ค. ๋น์ ์ ๋ค์ ๊ณผ์ ์ ๋ฐ๋ณตํ๋ฉด์ ํ์ ๋ค์ ๋จ 1๊ฐ๋ง ๋จ์ ๋๊น์ง ๊ณ์ ํฐํธ๋ฆฌ๋ ค๊ณ ํฉ๋๋ค.
- ์์์ ์ธ์ ํ ๋ ํ์ ์ ๊ณ ๋ฅธ ๋ค, ๋ ํ์ ์ค ํ๋๋ฅผ ํฐํธ๋ฆฝ๋๋ค.
- ํฐ์ง ํ์ ์ผ๋ก ์ธํด ํ์ ๋ค ์ฌ์ด์ ๋น ๊ณต๊ฐ์ด ์๊ฒผ๋ค๋ฉด, ๋น ๊ณต๊ฐ์ด ์๋๋ก ํ์ ๋ค์ ์ค์์ผ๋ก ๋ฐ์ฐฉ์ํต๋๋ค.
์ฌ๊ธฐ์ ์กฐ๊ฑด์ด ์์ต๋๋ค. ์ธ์ ํ ๋ ํ์ ์ค์์ ๋ฒํธ๊ฐ ๋ ์์ ํ์ ์ ํฐํธ๋ฆฌ๋ ํ์๋ ์ต๋ 1๋ฒ๋ง ํ ์ ์์ต๋๋ค. ์ฆ, ์ด๋ค ์์ ์์ ์ธ์ ํ ๋ ํ์ ์ค ๋ฒํธ๊ฐ ๋ ์์ ํ์ ์ ํฐํธ๋ ธ๋ค๋ฉด, ๊ทธ ์ดํ์๋ ์ธ์ ํ ๋ ํ์ ์ ๊ณ ๋ฅธ ๋ค ๋ฒํธ๊ฐ ๋ ํฐ ํ์ ๋ง์ ํฐํธ๋ฆด ์ ์์ต๋๋ค.
๋น์ ์ ์ด๋ค ํ์ ์ด ์ตํ๊น์ง ๋จ์ ์ ์๋์ง ์์๋ณด๊ณ ์ถ์ต๋๋ค. ์์ ์์ ๋ ์กฐ๊ฑด๋๋ก ํ์ ์ ํฐํธ๋ฆฌ๋ค ๋ณด๋ฉด, ์ด๋ค ํ์ ์ ์ตํ๊น์ง ๋จ์ ์๋ ์์ง๋ง, ์ด๋ค ํ์ ์ ๋ฌด์จ ์๋ฅผ ์ฐ๋๋ผ๋ ๋ง์ง๋ง๊น์ง ๋จ๊ธฐ๋ ๊ฒ์ด ๋ถ๊ฐ๋ฅํ ์๋ ์์ต๋๋ค.
์ผ๋ ฌ๋ก ๋์ด๋ ํ์ ๋ค์ ๋ฒํธ๊ฐ ๋ด๊ธด ๋ฐฐ์ด a๊ฐ ์ฃผ์ด์ง๋๋ค. ์์ ์์ ๋ ๊ท์น๋๋ก ํ์ ๋ค์ 1๊ฐ๋ง ๋จ์ ๋๊น์ง ํฐํธ๋ ธ์ ๋ ์ตํ๊น์ง ๋จ๊ธฐ๋ ๊ฒ์ด ๊ฐ๋ฅํ ํ์ ๋ค์ ๊ฐ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ ์ฌํญ
- a์ ๊ธธ์ด๋ 1 ์ด์ 1,000,000 ์ดํ์
๋๋ค.
- a[i]๋ i+1 ๋ฒ์งธ ํ์ ์ ์จ์ง ์ซ์๋ฅผ ์๋ฏธํฉ๋๋ค.
- a์ ๋ชจ๋ ์๋ -1,000,000,000 ์ด์ 1,000,000,000 ์ดํ์ธ ์ ์์ ๋๋ค.
- a์ ๋ชจ๋ ์๋ ์๋ก ๋ค๋ฆ ๋๋ค.
์ ์ถ๋ ฅ ์
a | result |
[9,-1,-5] | 3 |
[-16,27,65,-2,58,-92,-71,-68,-61,-33] | 6 |
์ ์ถ๋ ฅ ์ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
- ์ฒซ ๋ฒ์งธ ํ์ (9๊ฐ ์จ์ง ํ์ )์ ์ตํ๊น์ง ๋จ๊ธฐ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- [9, -1, -5] ์์ -1, -5๊ฐ ์จ์ง ํ์ ์ ๊ณ ๋ฅธ ๋ค, -1์ด ์จ์ง ํ์ (๋ฒํธ๊ฐ ๋ ํฐ ๊ฒ)์ ํฐํธ๋ฆฝ๋๋ค.
- [9, -5] ์์ 9, -5๊ฐ ์จ์ง ํ์ ์ ๊ณ ๋ฅธ ๋ค, -5๊ฐ ์จ์ง ํ์ (๋ฒํธ๊ฐ ๋ ์์ ๊ฒ)์ ํฐํธ๋ฆฝ๋๋ค.
- ๋ ๋ฒ์งธ ํ์ (-1์ด ์จ์ง ํ์ )์ ์ตํ๊น์ง ๋จ๊ธฐ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- [9, -1, -5] ์์ 9, -1์ด ์จ์ง ํ์ ์ ๊ณ ๋ฅธ ๋ค, 9๊ฐ ์จ์ง ํ์ (๋ฒํธ๊ฐ ๋ ํฐ ๊ฒ)์ ํฐํธ๋ฆฝ๋๋ค.
- [-1, -5] ์์ -1, -5๊ฐ ์จ์ง ํ์ ์ ๊ณ ๋ฅธ ๋ค, -5๊ฐ ์จ์ง ํ์ (๋ฒํธ๊ฐ ๋ ์์ ๊ฒ)์ ํฐํธ๋ฆฝ๋๋ค.
- ์ธ ๋ฒ์งธ ํ์ (-5๊ฐ ์จ์ง ํ์ )์ ์ตํ๊น์ง ๋จ๊ธฐ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- [9, -1, -5] ์์ 9, -1์ด ์จ์ง ํ์ ์ ๊ณ ๋ฅธ ๋ค, 9๊ฐ ์จ์ง ํ์ (๋ฒํธ๊ฐ ๋ ํฐ ๊ฒ)์ ํฐํธ๋ฆฝ๋๋ค.
- [-1, -5] ์์ -1, -5๊ฐ ์จ์ง ํ์ ์ ๊ณ ๋ฅธ ๋ค, -1์ด ์จ์ง ํ์ (๋ฒํธ๊ฐ ๋ ํฐ ๊ฒ)์ ํฐํธ๋ฆฝ๋๋ค.
- 3๊ฐ์ ํ์ ์ด ์ตํ๊น์ง ๋จ์ ์ ์์ผ๋ฏ๋ก, 3์ return ํด์ผ ํฉ๋๋ค.
์ ์ถ๋ ฅ ์ #2
- ์ตํ๊น์ง ๋จ์ ์ ์๋ ํ์ ์ -16, -92, -71, -68, -61, -33์ด ์จ์ง ํ์ ์ผ๋ก ๋ชจ๋ 6๊ฐ์ ๋๋ค.
'Algorithm Problem > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[python] ๋ฐฑ์ค - 1929. ์์ ๊ตฌํ๊ธฐ (0) | 2020.09.28 |
---|---|
[python] ๋ฐฑ์ค - 1011. Fly me to the Alpha Centauri (0) | 2020.09.26 |
[python] ๋ฐฑ์ค - 5014. ์คํํธ๋งํฌ (0) | 2020.09.24 |
[python] ๋ฐฑ์ค - 3055. ํ์ถ (0) | 2020.09.23 |
[python] ๋ฐฑ์ค - 1916. ์ต์๋น์ฉ ๊ตฌํ๊ธฐ (0) | 2020.09.23 |