[BOJ][๐ก5][๋ฐฑ์ค#02493] ํ
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold V
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
KOI ํต์ ์ฐ๊ตฌ์๋ ๋ ์ด์ ๋ฅผ ์ด์ฉํ ์๋ก์ด ๋น๋ฐ ํต์ ์์คํ ๊ฐ๋ฐ์ ์ํ ์คํ์ ํ๊ณ ์๋ค. ์คํ์ ์ํ์ฌ ์ผ์ง์ ์์ N๊ฐ์ ๋์ด๊ฐ ์๋ก ๋ค๋ฅธ ํ์ ์ํ ์ง์ ์ ์ผ์ชฝ๋ถํฐ ์ค๋ฅธ์ชฝ ๋ฐฉํฅ์ผ๋ก ์ฐจ๋ก๋ก ์ธ์ฐ๊ณ , ๊ฐ ํ์ ๊ผญ๋๊ธฐ์ ๋ ์ด์ ์ก์ ๊ธฐ๋ฅผ ์ค์นํ์๋ค. ๋ชจ๋ ํ์ ๋ ์ด์ ์ก์ ๊ธฐ๋ ๋ ์ด์ ์ ํธ๋ฅผ ์งํ๋ฉด๊ณผ ํํํ๊ฒ ์ํ ์ง์ ์ ์ผ์ชฝ ๋ฐฉํฅ์ผ๋ก ๋ฐ์ฌํ๊ณ , ํ์ ๊ธฐ๋ฅ ๋ชจ๋์๋ ๋ ์ด์ ์ ํธ๋ฅผ ์์ ํ๋ ์ฅ์น๊ฐ ์ค์น๋์ด ์๋ค. ํ๋์ ํ์์ ๋ฐ์ฌ๋ ๋ ์ด์ ์ ํธ๋ ๊ฐ์ฅ ๋จผ์ ๋ง๋๋ ๋จ ํ๋์ ํ์์๋ง ์์ ์ด ๊ฐ๋ฅํ๋ค.ย ์๋ฅผ ๋ค์ด ๋์ด๊ฐ 6, 9, 5, 7, 4์ธ ๋ค์ฏ ๊ฐ์ ํ์ด ์ํ ์ง์ ์ ์ผ๋ ฌ๋ก ์ ์๊ณ , ๋ชจ๋ ํ์์๋ ์ฃผ์ด์ง ํ ์์์ ๋ฐ๋ ๋ฐฉํฅ(์ผ์ชฝ ๋ฐฉํฅ)์ผ๋ก ๋์์ ๋ ์ด์ ์ ํธ๋ฅผ ๋ฐ์ฌํ๋ค๊ณ ํ์. ๊ทธ๋ฌ๋ฉด, ๋์ด๊ฐ 4์ธ ๋ค์ฏ ๋ฒ์งธ ํ์์ ๋ฐ์ฌํ ๋ ์ด์ ์ ํธ๋ ๋์ด๊ฐ 7์ธ ๋ค ๋ฒ์งธ ํ์ด ์์ ์ ํ๊ณ , ๋์ด๊ฐ 7์ธ ๋ค ๋ฒ์งธ ํ์ ์ ํธ๋ ๋์ด๊ฐ 9์ธ ๋ ๋ฒ์งธ ํ์ด, ๋์ด๊ฐ 5์ธ ์ธ ๋ฒ์งธ ํ์ ์ ํธ๋ ๋์ด๊ฐ 9์ธ ๋ ๋ฒ์งธ ํ์ด ์์ ์ ํ๋ค. ๋์ด๊ฐ 9์ธ ๋ ๋ฒ์งธ ํ๊ณผ ๋์ด๊ฐ 6์ธ ์ฒซ ๋ฒ์งธ ํ์ด ๋ณด๋ธ ๋ ์ด์ ์ ํธ๋ ์ด๋ค ํ์์๋ ์์ ์ ํ์ง ๋ชปํ๋ค. ํ๋ค์ ๊ฐ์ N๊ณผ ํ๋ค์ ๋์ด๊ฐ ์ฃผ์ด์ง ๋, ๊ฐ๊ฐ์ ํ์์ ๋ฐ์ฌํ ๋ ์ด์ ์ ํธ๋ฅผ ์ด๋ ํ์์ ์์ ํ๋์ง๋ฅผ ์์๋ด๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋ผ.ย
์ ๋ ฅ
์ฒซ์งธ ์ค์ ํ์ ์๋ฅผ ๋ํ๋ด๋ ์ ์ N์ด ์ฃผ์ด์ง๋ค. N์ 1 ์ด์ 500,000 ์ดํ์ด๋ค. ๋์งธ ์ค์๋ N๊ฐ์ ํ๋ค์ ๋์ด๊ฐ ์ง์ ์์ ๋์ธ ์์๋๋ก ํ๋์ ๋น์นธ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค. ํ๋ค์ ๋์ด๋ 1 ์ด์ 100,000,000 ์ดํ์ ์ ์์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ฃผ์ด์ง ํ๋ค์ ์์๋๋ก ๊ฐ๊ฐ์ ํ๋ค์์ ๋ฐ์ฌํ ๋ ์ด์ ์ ํธ๋ฅผ ์์ ํ ํ๋ค์ ๋ฒํธ๋ฅผ ํ๋์ ๋น์นธ์ ์ฌ์ด์ ๋๊ณ ์ถ๋ ฅํ๋ค. ๋ง์ฝ ๋ ์ด์ ์ ํธ๋ฅผ ์์ ํ๋ ํ์ด ์กด์ฌํ์ง ์์ผ๋ฉด 0์ ์ถ๋ ฅํ๋ค.
์์
์ ๋ ฅ
5
6 9 5 7 4
์ถ๋ ฅ
0 0 2 2 4
My Sol
import sys
input = sys.stdin.readline
from heapq import heappop, heappush
N = int(input())
arr = list(map(int, input().split()))
ret = [0]*N
i = N-1
Q = []
while i >= 0:
nowh = arr[i]
heappush(Q, (arr[i], i))
minh, mini = heappop(Q)
while nowh > minh:
ret[mini] = i+1
minh, mini = heappop(Q)
heappush(Q, (minh, mini))
i -= 1
print(*ret)
heapq๋ฅผ ์ด์ฉํ์ฌ ํด๊ฒฐํ์๋ค. ๋์ด์ ์ต์๊ฐ๊ณผ ์ธ๋ฑ์ค๋ฅผ ํจ๊ป ํํ๋ก ์ ์ฅํ๊ณ , ์ด๋ฅผ heapq์ ๋ฃ์ด์ ๋ค์์๋ถํฐ ์์ผ๋ก ๋์ด๋ฅผ ์ฒดํฌํ๋ค. ์ฒดํฌ๋ ํ์ฌ ๋์ด๊ฐ heapq์ ์๋ ์ต์ ๋์ด๋ณด๋ค ๋๋ค๋ฉด ํด๋น ์ต์ ๋์ด์ ์ธ๋ฑ์ค์ ํ์ฌ ์ธ๋ฑ์ค๋ฅผ ๋ถ์ฌํ๋ค. ์ด ๊ณผ์ ์ heaqp์์ ๊บผ๋ธ ์ต์ ๋์ด๊ฐ ํ์ฌ ์ธ๋ฑ์ค์ ๋์ด๋ณด๋ค ๊ฐ๊ฑฐ๋ ๋์ ๊ฒฝ์ฐ๊น์ง ๋ฐ๋ณตํ๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋ชจ๋ฒ๋ต์
import sys
input = sys.stdin.readline
n = int(input())
tower = list(map(int, input().split()))
stack = []
sol = [0] * n
for i in range(n):
while stack and tower[stack[-1]] < tower[i]:
stack.pop()
if stack:
sol[i] = stack[-1] + 1
stack.append(i)
print(' '.join(map(str,sol)))
stack์ ์ด์ฉํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์ จ๋ค. ์์์๋ถํฐ ํ์์ ์ธ๋ฑ์ค๋ฅผ stack์ ์ฑ์๋๊ฐ์ จ๋๋ฐ, stack์ ์ ์ฅ๋ tower๊ฐ ์๋ค๋ฉด stack์ ํ์ฌ ์ธ๋ฑ์ค๋ฅผ ์ถ๊ฐํ๊ณ , stack์ ํ์๊ฐ ์๋ค๋ฉด ํ์ฌ ํ์์ ๋์ด๊ฐ stack์ ๋ง์ง๋ง ํ์์ ๋์ด๋ณด๋ค ๋๋ค๋ฉด stack์ ์ธ๋ฑ์ค๋ฅผ ๋นผ๋ฒ๋ฆฌ๋ ๊ฒ์ด๋ค. ์ด์ ์ stack์ ๋ฃ์๋ ํ์ฌ ์ธ๋ฑ์ค์ ๋์ด๋ณด๋ค ๋ฎ์ ํ์๋ค์ ์ดํ์๋ ํ์๊ฐ ์๊ธฐ ๋๋ฌธ์ ๋นผ๋ฒ๋ ค๋ ๋ฌธ์ ๊ฐ ์๋ค.
๋ง์ฝ stack์ ๋ง์ง๋ง ํ์์ ๋์ด๊ฐ ํ์ฌ ํ์์ ๋์ด๋ณด๋ค ๊ฐ๊ฑฐ๋ ํฌ๋ค๋ฉด ํ์ฌ ํ์์ ๋์ด๋ฅผ stack์ ๋ง์ง๋ง ํ์์ ์ธ๋ฑ์ค+1 ๋ก ์ง์ ํ์ฌ ์ ์ฅํ๋ค.
๋๋ heqpq์์ ๋งค๋ฒ ๋ฒ๋ฆฌ๋ ๋ฐฉ์์ด์ง๋ง, ์ด ๋ฐฉ์์ ์์์ ๋นผ๋์๋ ๋ถ๊ตฌํ๊ณ stack์ ํฌ๊ธฐ๋ฅผ ์๊ฒ ์ ์งํ๋ฉฐ ๋ฐ๋ณต์ ์ค์ผ ์ ์๋ค๋ ์ ์์ ์ข์ ์ฝ๋๋ผ๊ณ ์๊ฐํ๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ