[BOJ][๐ก5][๋ฐฑ์ค#19598] ์ต์ ํ์์ค ๊ฐ์
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold V
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
์์ค์ด๋ ์๋น ๋ก๋ถํฐ N๊ฐ์ ํ์๋ฅผ ๋ชจ๋ ์งํํ ์ ์๋ ์ต์ ํ์์ค ๊ฐ์๋ฅผ ๊ตฌํ๋ผ๋ ๋ฏธ์ ์ ๋ฐ์๋ค. ๊ฐ ํ์๋ ์์ ์๊ฐ๊ณผ ๋๋๋ ์๊ฐ์ด ์ฃผ์ด์ง๊ณ ํ ํ์์ค์์ ๋์์ ๋ ๊ฐ ์ด์์ ํ์๊ฐ ์งํ๋ ์ ์๋ค.ย ๋จ, ํ์๋ ํ๋ฒ ์์๋๋ฉดย ์ค๊ฐ์ ์ค๋จ๋ ์ ์์ผ๋ฉฐ ํ ํ์๊ฐ ๋๋๋ ๊ฒ๊ณผ ๋์์ ๋ค์ ํ์๊ฐ ์์๋ ์ ์๋ค. ํ์์ ์์ ์๊ฐ์ย ๋๋๋ ์๊ฐ๋ณด๋ค ํญ์ ์๋ค. N์ด ๋๋ฌด ์ปค์ ๊ดด๋ก์ ํ๋ ์ฐ๋ฆฌ ์์ค์ด๋ฅผ ๋์์ฃผ์.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋ฐฐ์ด์ ํฌ๊ธฐย N(1 โค N โค 100,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N+1 ์ค๊น์งย ๊ณต๋ฐฑ์ ์ฌ์ด์ ๋๊ณ ํ์์ ์์์๊ฐ๊ณผ ๋๋๋ ์๊ฐ์ด ์ฃผ์ด์ง๋ค. ์์ ์๊ฐ๊ณผ ๋๋๋ ์๊ฐ์ 231โ1๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์ ๋๋ 0์ด๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ต์ ํ์์ค ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
์์
์์ 1
์ ๋ ฅ
3
0 40
15 30
5 10
์ถ๋ ฅ
2
์์ 2
์ ๋ ฅ
2
10 20
5 10
์ถ๋ ฅ
1
My Sol
import sys
input = sys.stdin.readline
from heapq import heappop, heappush
def main():
def make_H():
H = []
for _ in range(N):
s, e = map(int, input().split())
heappush(H, (s, e))
return H
def count_place():
cnt = 1
K = []
s, e = heappop(H)
heappush(K, e)
while H:
s, e = heappop(H)
if K[0] > s:
cnt += 1
else:
heappop(K)
heappush(K, e)
return cnt
N = int(input())
H = make_H()
return count_place()
print(main())
heapq๋ฅผ ์ฌ์ฉํด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์๋ค.
- ๊ฐ ํ์์ค ์ผ์ ์ ์
๋ ฅ์ผ๋ก ๋ฐ๋๋ฐ, ์ด๋ฅผ heapq์ ๋ด๋๋ค. (์์์๊ฐ, ์ข
๋ฃ์๊ฐ)์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ๋๋ค. ์ด๋ฅผ ๋ฐํํ๋
make_H
ํจ์๋ฅผ ์์ฑํ๋ค. - ์ด๋ ๊ฒ ๋ง๋ค์ด์ง
H
heapq์์ ๊ฐ์ฅ ๋นจ๋ฆฌ ์์ํ ํ์๋ฅผ ๋งค๋ฒ ๊บผ๋ด๋ฉฐ ํ์ธ์ ์งํํ๋๋ฐ, ์ด๋ฅผcount_place
ํจ์์์ ์งํํ๋ค. count_place
ํจ์ ๋ด์์๋ heapqK
๋ฅผ ์ถ๊ฐ๋ก ์ ์ํ๋๋ฐ, ์ด heapq๋ ์ข ๋ฃ์๊ฐ์ ๋น ๋ฅธ ์์ผ๋ก ์ ์ฅํ๋ heapq์ด๋ค. ์ฆ,H
์์ ๊บผ๋ธ ํ์์ค ์ผ์ ์ ์์์๊ฐ์ดK
์ ๊ฐ์ฅ ๋น ๋ฅธ ์ข ๋ฃ์๊ฐ์ ํ์๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์์ง, ํน์ ํฐ์ง์ ๋ฐ๋ผ ๋ถ๊ธฐ ์ฒ๋ฆฌ๋ฅผ ํ๋ค.- ๋ง์ฝ
K
์ ๊ฐ์ฅ ์์ ๊ฐ, ์ฆ ๊ฐ์ฅ ๋นจ๋ฆฌ ๋๋๋ ํ์ ์๊ฐ์ดH
์์ ์ด์ ๊บผ๋ธ ํ์ ์ผ์ ์ ์์์๊ฐ๋ณด๋ค ํฌ๋ฉด ํ์ฌ๊น์ง ๋น๋ฆฐ ๊ฐ์์ค๋ก๋ ์ปค๋ฒํ ์๊ฐ ์๋ ์ํฉ์ด๋ฏ๋ก ๊ฐ์์ค์ ํ๋ ๋ ๋น๋ฆฐ๋ค๊ณ ๊ฐ์ํ์ฌcnt
๋ฅผ 1 ๋ ๋๋ ค์ฃผ๊ณe
๋ฅผK
์ ๋ฃ์ด์ค๋ค. - ๋ฐ๋๋ก
K
์ ๊ฐ์ฅ ์์ ๊ฐ์ดH
์s
๋ณด๋ค ์์ผ๋ฉด, ํ์ฌ ๋ฑ๋กํด์ผํ๋ ํ์์ผ์ ์ ๊ฐ์ฉํ ํ์์ค์K
์์ ์ ๊ณตํ ์ ์๋ ๊ฒ์ด๋ฏ๋ก ๋จ์ํK
์ ๊ฐ์ฅ ์์ ๊ฐ์heap pop
์ ์ด์ฉํด ์ ๊ฑฐํ๊ณ , ์ ๊ท ๋ฑ๋ก๋ ํ์์ ์ข ๋ฃ์๊ฐe
๋ฅผK
์ ์ถ๊ฐํ๋ค.cnt
์ ์ฆ๊ฐ๋ ํ์ํ์ง ์๋ค. - ์ด๋ฌํ ๊ณผ์ ์
H
๊ฐ ๋น ๋๊น์ง ํ๊ณ , ๋์ ๋cnt
๋ฅผ ๋ฐํ, ์ด๋ฅผ ์ต์ข ์ ์ผ๋ก ์ถ๋ ฅํด์ฃผ๋ฉด ๋๊ฒ ๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋ชจ๋ฒ๋ต์
import sys, heapq
input = sys.stdin.readline
N = int(input())
schedules = sorted([list(map(int, input().split())) for _ in range(N)])
h = []
for start, end in schedules:
if h and h[0] <= start:
heapq.heappop(h)
heapq.heappush(h, end)
print(len(h))
์ฐ์ฐ์๊ฐ์ ๊ฐ์ง๋ง ์ฝ๋๊ธธ์ด๊ฐ ์งง์ ์ฝ๋๋ฅผ ๋ถ์ํ๋ ค ํ๋ค. ์ฐ์ ํ์ ์ผ์ ์ heapq์ ๋ด์ง ์๊ณ list์ ๋ด์ sortํ๋ค. heapq์ ์ ๋ ฌ์ O(nlogn)
์ด๊ณ , list์ ์ ๋ ฌ์ O(n2)
์ด์ง๋ง, ์๊ทผํ list์ ์ ๋ ฌ์ด ๊ฝค๋ ๋น ๋ฅด๋ค.
๊ฐ์ฅ ํฐ ์ฐจ์ด๋ for๋ฌธ์ ๊ณผ์ ์ธ๋ฐ ์ด์ฐจํผ cnt๋ฅผ ๋ฐ๋ก ์ค์ ํด์ค ํ์ ์์ด heapq์ ์ต์๊ฐ๊ณผ์ ๋น๊ต๋ก heap์์ pop์ ํ๋ฉด cnt๋ 1 ์ค์ด๋ค๊ฒ ๋๋๋ฐ, ์ด๋ฅผ ์ ํ์ฉํ ํ์ด์ธ ๊ฒ ๊ฐ๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ