๋ฌธ์ ์ค๋ช
n๋ช ์ ๊ถํฌ์ ์๊ฐ ๊ถํฌ ๋ํ์ ์ฐธ์ฌํ๊ณ ๊ฐ๊ฐ 1๋ฒ๋ถํฐ n๋ฒ๊น์ง ๋ฒํธ๋ฅผ ๋ฐ์์ต๋๋ค. ๊ถํฌ ๊ฒฝ๊ธฐ๋ 1๋1 ๋ฐฉ์์ผ๋ก ์งํ์ด ๋๊ณ , ๋ง์ฝ A ์ ์๊ฐ B ์ ์๋ณด๋ค ์ค๋ ฅ์ด ์ข๋ค๋ฉด A ์ ์๋ B ์ ์๋ฅผ ํญ์ ์ด๊น๋๋ค. ์ฌํ์ ์ฃผ์ด์ง ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ง๊ณ ์ ์๋ค์ ์์๋ฅผ ๋งค๊ธฐ๋ ค ํฉ๋๋ค. ํ์ง๋ง ๋ช๋ช ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ๋ฅผ ๋ถ์คํ์ฌ ์ ํํ๊ฒ ์์๋ฅผ ๋งค๊ธธ ์ ์์ต๋๋ค.
์ ์์ ์ n, ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ๋ฅผ ๋ด์ 2์ฐจ์ ๋ฐฐ์ด results๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋ ์ ํํ๊ฒ ์์๋ฅผ ๋งค๊ธธ ์ ์๋ ์ ์์ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
์ ์ถ๋ ฅ ์ ์ค๋ช
2๋ฒ ์ ์๋ [1, 3, 4] ์ ์์๊ฒ ํจ๋ฐฐํ๊ณ 5๋ฒ ์ ์์๊ฒ ์น๋ฆฌํ๊ธฐ ๋๋ฌธ์ 4์์
๋๋ค.
5๋ฒ ์ ์๋ 4์์ธ 2๋ฒ ์ ์์๊ฒ ํจ๋ฐฐํ๊ธฐ ๋๋ฌธ์ 5์์
๋๋ค.
๋์ ํ์ด
function solution(n, results) {
const arrayN = Array.from(Array(n),(_,i) => i+1)
const winHistory = {}
const loseHistory = {}
// ๋์งํ ๊ฐ ๋ฒํธ ๋ณ ์ํฉ์ ๋ฑ๋ก
arrayN.forEach(item => {
winHistory[item] = new Set([])
loseHistory[item] = new Set([])
})
results.forEach(result => {
const [winner, loser] = result
winHistory[winner].add(loser)
loseHistory[loser].add(winner)
})
arrayN.forEach((n) => {
// i ์ ์๋ฅผ ์ด๊ธด ์ ์ ์ ๋งํผ ๋ฐ๋ณต
for(const winI of loseHistory[n]) {
// ์น๋ฆฌ ๋ช
๋จ์ ์๋ค๋ฉด ์ถ๊ฐ X
if(!winHistory[winI]) continue
// i ์๊ฒ ์ง ์ ์๋ฅผ i๋ฅผ ์ด๊ธด ์ ์์๊ฒ ๋ณต์ฌ
for(const loser of winHistory[n]) {
winHistory[winI].add(loser)
}
}
// i ์๊ฒ ์ง ์ ์ ์ ๋งํผ ๋ฐ๋ณต
for(const loser of winHistory[n]) {
// ํจ๋ฐฐ ๋ช
๋จ์ ์๋ค๋ฉด ์ถ๊ฐ X
if(!loseHistory[loser]) continue
// i ์๊ฒ ์ง ์ ์๋ i๋ฅผ ์ด๊ธด ์ ์์๊ฒ๋ ํจ๋ฐฐ
for(const winner of loseHistory[n]) {
loseHistory[loser].add(winner)
}
}
})
return arrayN.reduce((prev,next) => (winHistory[next].size + loseHistory[next].size === n-1 ? prev+1 : prev ) ,0)
}
์น๋ฆฌ ๋ช ๋จ๊ณผ ํจ๋ฐฐ ๋ช ๋จ์ ๊ฐ์ ์ ์ฐ๊ฒฐ
1๋ฒ ์ ์๋ถํฐ ๋์๊ฐ๋ฉฐ ํจ๋ฐฐํ ์ ์์๊ฒ ํจ๋ฐฐํ ์ ์๋ ์น๋ฆฌํ ์ ์์๊ฒ ๋ชจ๋ ํจ๋ฐฐํจ! ์ค์!!
์น๋ฆฌ ํ ๊ฒฝ๊ธฐ ์ + ์๊ธฐ์์ === n-1 ์ด๋ผ๋ฉด ์์๋ฅผ ํ์ ์ง์ ์ ์์ผ๋ฏ๋ก ์ ๋ต์ +1