๐ ๋ฌธ์
https://programmers.co.kr/learn/courses/30/lessons/49191
๋ฌธ์ ์ค๋ช
n๋ช ์ ๊ถํฌ์ ์๊ฐ ๊ถํฌ ๋ํ์ ์ฐธ์ฌํ๊ณ ๊ฐ๊ฐ 1๋ฒ๋ถํฐ n๋ฒ๊น์ง ๋ฒํธ๋ฅผ ๋ฐ์์ต๋๋ค. ๊ถํฌ ๊ฒฝ๊ธฐ๋ 1๋1 ๋ฐฉ์์ผ๋ก ์งํ์ด ๋๊ณ , ๋ง์ฝ A ์ ์๊ฐ B ์ ์๋ณด๋ค ์ค๋ ฅ์ด ์ข๋ค๋ฉด A ์ ์๋ B ์ ์๋ฅผ ํญ์ ์ด๊น๋๋ค. ์ฌํ์ ์ฃผ์ด์ง ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ง๊ณ ์ ์๋ค์ ์์๋ฅผ ๋งค๊ธฐ๋ ค ํฉ๋๋ค. ํ์ง๋ง ๋ช๋ช ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ๋ฅผ ๋ถ์คํ์ฌ ์ ํํ๊ฒ ์์๋ฅผ ๋งค๊ธธ ์ ์์ต๋๋ค.
์ ์์ ์ n, ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ๋ฅผ ๋ด์ 2์ฐจ์ ๋ฐฐ์ด results๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋ ์ ํํ๊ฒ ์์๋ฅผ ๋งค๊ธธ ์ ์๋ ์ ์์ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- ์ ์์ ์๋ 1๋ช ์ด์ 100๋ช ์ดํ์ ๋๋ค.
- ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ๋ 1๊ฐ ์ด์ 4,500๊ฐ ์ดํ์ ๋๋ค.
- results ๋ฐฐ์ด ๊ฐ ํ [A, B]๋ A ์ ์๊ฐ B ์ ์๋ฅผ ์ด๊ฒผ๋ค๋ ์๋ฏธ์ ๋๋ค.
- ๋ชจ๋ ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ์๋ ๋ชจ์์ด ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
n/ results/ return
5 | [[4, 3], [4, 2], [3, 2], [1, 2], [2, 5]] | 2 |
์ ์ถ๋ ฅ ์ ์ค๋ช
2๋ฒ ์ ์๋ [1, 3, 4] ์ ์์๊ฒ ํจ๋ฐฐํ๊ณ 5๋ฒ ์ ์์๊ฒ ์น๋ฆฌํ๊ธฐ ๋๋ฌธ์ 4์์
๋๋ค.
5๋ฒ ์ ์๋ 4์์ธ 2๋ฒ ์ ์์๊ฒ ํจ๋ฐฐํ๊ธฐ ๋๋ฌธ์ 5์์
๋๋ค.
โ๏ธ ํ์ด
์ค๋ณต์ ์ ๊ฑฐํ๊ธฐ ์ํด โก๏ธ set() ํจ์๋ฅผ ์ฌ์ฉํ์ฌ win, lose ๋ณ์๋ฅผ ์ ์ธํ๋ค.
ex) win[1]={2,3,4} : 1๋ฒ์ด ์ด๊ธด ์ฌ๋์ผ๋ก 2,3,4๋ฒ์ด ์๋ค๋ ๋ป์ด๋ค.
ex) lose[2]={1,5}: 2๋ฒ์ด ์ง ์ฌ๋์ผ๋ก 1,5๋ฒ์ด ์๋ค๋ ๋ป์ด๋ค.
์ด๊ธฐ๊ณ ์ง ๊ด๊ณ๋ฅผ ์ ์ํ๊ธฐ ์ํด์๋ ๋ด๊ฐ ์ด๊ธด ์ฌ๋๋ค์๊ฒ ์ง ์ฌ๋๋ค์, ์ฌ์ ํ ๋ด๊ฐ ์ด๊ธด๋ค๋ ๊ฐ๋ ์ ์ดํดํด์ผ ํ๋ค.
โ๏ธ ์ฆ A๊ฐ ์ด๊ธด ์ฌ๋๋ค(win[A]: A์๊ฒ ์ง ์ฌ๋๋ค)์, A๊ฐ ์ง ์ฌ๋๋ค(lose[A]: A๋ฅผ ์ด๊ธด ์ฌ๋๋ค)์๊ฒ๋ ์ง๋ ๊ฒ์ด๋ค.
๋ฐ๋๋ก A๊ฐ ์ง ์ฌ๋๋ค(lose[A]: A๋ฅผ ์ด๊ธด ์ฌ๋๋ค)์ A๊ฐ ์ด๊ธด ์ฌ๋๋ค(win[A]: A์๊ฒ ์ง ์ฌ๋๋ค)์๊ฒ๋ ์ด๊ธธ ์ ์๋ค.
์ด ๋, ์ค๋ณต์ด ์์ ์ ์์ผ๋ฏ๋ก(A>C/ B>C/ A>B์ธ ๊ฒฝ์ฐ) set()ํจ์๋ฅผ ์ฐ๋ ๊ฒ์ด๋ค.
๐ป ์์ค์ฝ๋: ํ์ด์ฌ(Python)
def solution(n, results):
win = {}
lose = {}
for i in range(n+1):
win[i] = set()
lose[i] = set()
for result in results:
winner = result[0]
loser = result[1]
win[winner].add(loser)
lose[loser].add(winner)
for i in range(1, n+1):
# i๋ฒ์งธ ์ฌ๋์๊ฒ ์ด๊ธด ์ฌ๋๋ค
# i๋ฒ์งธ๊ฐ ์ด๊ธด ์ฌ๋๋ค์๊ฒ๋ ์ด๊ธด๋ค.
for winner in lose[i]:
win[winner].update(win[i])
# i๋ฒ์งธ ์ฌ๋์๊ฒ ์ง ์ฌ๋๋ค
# i๋ฒ์งธ๊ฐ ์ง ์ฌ๋๋ค์๊ฒ๋ ์ง๋ค.
for loser in win[i]:
lose[loser].update(lose[i])
answer = 0
for i in range(1, n+1):
if len(win[i])+len(lose[i]) == (n-1):
answer += 1
return answer
#์์
n = 5
results = [[4, 3], [4, 2], [3, 2], [1, 2], [2, 5]]
#๊ฒฐ๊ณผ ์ถ๋ ฅ
print(solution(n, results))
๐ ๐ ๐
๏ผฐ๏ฝ๏ฝ๏ฝ๏ฝ ๏ฝ ๏ผข๏ฝ ๏ผณ๏ผก๏ผน
๐๐ฉ๐ข๐ฏ๐ฌ๐ด ๐ง๐ฐ๐ณ ๐ณ๐ฆ๐ข๐ฅ๐ช๐ฏ๐จ