[Algorithm] ์์
๐ ๋ฌธ์
n๋ช ์ ๊ถํฌ์ ์๊ฐ ๊ถํฌ ๋ํ์ ์ฐธ์ฌํ๊ณ ๊ฐ๊ฐ 1๋ฒ๋ถํฐ n๋ฒ๊น์ง ๋ฒํธ๋ฅผ ๋ฐ์์ต๋๋ค. ๊ถํฌ ๊ฒฝ๊ธฐ๋ 1๋1 ๋ฐฉ์์ผ๋ก ์งํ์ด ๋๊ณ , ๋ง์ฝ A ์ ์๊ฐ B ์ ์๋ณด๋ค ์ค๋ ฅ์ด ์ข๋ค๋ฉด A ์ ์๋ B ์ ์๋ฅผ ํญ์ ์ด๊น๋๋ค. ์ฌํ์ ์ฃผ์ด์ง ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ง๊ณ ์ ์๋ค์ ์์๋ฅผ ๋งค๊ธฐ๋ ค ํฉ๋๋ค. ํ์ง๋ง ๋ช๋ช ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ๋ฅผ ๋ถ์คํ์ฌ ์ ํํ๊ฒ ์์๋ฅผ ๋งค๊ธธ ์ ์์ต๋๋ค.
์ ์์ ์ n, ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ๋ฅผ ๋ด์ 2์ฐจ์ ๋ฐฐ์ด results๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋ ์ ํํ๊ฒ ์์๋ฅผ ๋งค๊ธธ ์ ์๋ ์ ์์ ์๋ฅผ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ ์ฌํญ
- ์ ์์ ์๋ 1๋ช ์ด์ 100๋ช ์ดํ์ ๋๋ค.
- ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ๋ 1๊ฐ ์ด์ 4,500๊ฐ ์ดํ์ ๋๋ค.
- results ๋ฐฐ์ด ๊ฐ ํ [A, B]๋ A ์ ์๊ฐ B ์ ์๋ฅผ ์ด๊ฒผ๋ค๋ ์๋ฏธ์ ๋๋ค.
- ๋ชจ๋ ๊ฒฝ๊ธฐ ๊ฒฐ๊ณผ์๋ ๋ชจ์์ด ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
5 | [[4, 3], [4, 2], [3, 2], [1, 2], [2, 5]] | 2 |
โ๏ธ ํ์ด
์ ๋ง ์ฌ๋ฌ๊ฐ์ง๋ฅผ ์๋ํ๋ ๋ฌธ์ ์๋ค. ์ฒซ ๋ฒ์งธ๋ก ํ๋ก์ด๋ ์์ฌ๋ก ํ์ด๋ณด๊ธฐ๋ ํ๋๋ฐ ํ ์คํธ ์ผ์ด์ค ๋ช๊ฐ๋ฅผ ํต๊ณผํ์ง ๋ชปํ๋๋ฐ ์ด์ ๋ฅผ ์ฐพ์ง ๋ชปํด์ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ์ ๊ทผํ๋ค. ๋ ๋ฒ์งธ๋ก๋ DFS๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ์ด์๋๋ฐ ํด๊ฒฐํ๋ค.
๋จผ์ ์นํจ ๊ฒฐ๊ณผ๋ฅผ graph์ ์ ์ฅํ๋ค. ์น๋ฆฌํ์ ๋, ํจ๋ฐฐํ์ ๋๋ก ๋๊ฐ์ graph๋ฅผ ๋ฐ๋ก ๋ถ๋ฆฌํ๊ณ key๋ ์ ์, value๋ ์๋ ์ ์๋ฅผ ๋ฐฐ์ด๋ก ๊ด๋ฆฌํ๋ค. ๊ทธ๋ฆฌ๊ณ ์ ์๋ฅผ ํ๋ํ๋ ๋๋ฉด์ DFS๋ก ํ์ํ๋ค.
์ฒ์์ ์๊ฐ์ ์๋ชปํ๋ ์ ์ด ๊ฐ์ ์ ์๋ฅผ ์ค๋ณต์ผ๋ก ๋์ง ์๊ธฐ ์ํด ๋ฐฐ์ด์ ๊ฐ์ ์ ์ฅํ๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋๋ฐ ๋ง์ฝ 2๋ฒ ์ ์๊ฐ [5, 1] ์ด 2๋ช ์ ์ ์์๊ฒ ์น๋ฆฌํ์ฌ ๋ฐฐ์ด์ ์ ์ฅํด๋๊ณ 4๋ฒ ์ ์๊ฐ [1, 2] ์ ์์๊ฒ ์น๋ฆฌํ ๊ฒ์ ๊ณ์ฐํ ๋ 2๋ฒ ์ ์๋ฅผ ๋ฐฐ์ด์ ์ ์ฅํ ๊ฐ์ ๊ฐ์ ธ์ค๊ธฐ ๋๋ฌธ์ ๋๊ฐ์๊ฒ ์น๋ฆฌํ๋์ง ์ ์ ์์ด 1๋ฒ ์ ์๊ฐ ์ค๋ณต๋๋ ๊ฒ์ ๊ณ์ฐํ๋ ๊ฒ์ด ๋ถ๊ฐ๋ฅํ๋ค.
๊ทธ๋์ ๊ณ ๋ฏผ์ ํด๋ณด๋ ์ ์๋ 100๋ช ์ด ์ต๋์ด๊ธฐ ๋๋ฌธ์ dfs์ ๊น์ด๋ ์ต๋ 100์ด๋ฏ๋ก ์ต์ ์ ๊ฒฝ์ฐ์๋ 10000์ ๊ฒฝ์ฐ๋ฐ์ ์๋ค๋ ๊ฒ์ ์์๋ค. ๊ทธ๋์ ๋ชจ๋ ์ ์๋ฅผ ์ํํ๋ฉด์ ์น๋ฆฌ, ํจ๋ฐฐํ ์ ์๋ฅผ ์ฒดํฌํ๋ ์ฒดํฌ ๋ฐฐ์ด(checkWin, checkLose)์ 2๊ฐ ๋ง๋ค์ด DFS์ ๋๊ฒจ์ฃผ๊ณ DFS๋ฅผ ๋๋ฉด์ ์นํจ ์ฌ๋ถ๋ฅผ ์ฒดํฌํ๊ณ DFS๊ฐ ์ข ๋ฃ๋๋ฉด ์ด ์ฒดํฌ๋ฐฐ์ด์ reduce๋ฅผ ์ฌ์ฉํด ํฉ์ ๊ตฌํด ๋ํด์ ์นํจ๋ฅผ ์๊ณ ์๋ ์ ์๊ฐ n - 1(๋ชจ๋ ์ ์ - ์๊ธฐ ์์ )๊ณผ ๊ฐ๋ค๋ฉด ์์ ์ด ๋ช ์์์ธ์ง ์ ํํ๊ฒ ์ ์ ์๋ค๋ ์๋ฏธ์ด๋ฏ๋ก answer์ 1์ ๋ํด์ค์ผ๋ก์ ํด๊ฒฐํ๋ค.
โจ๏ธ ์ฝ๋
function solution(n, results) {
var answer = 0;
const graphWinner = {};
const graphLoser = {};
for (const result of results) {
const [winner, loser] = result;
if (!graphLoser[winner]) graphLoser[winner] = [];
graphLoser[winner].push(loser);
if (!graphWinner[loser]) graphWinner[loser] = [];
graphWinner[loser].push(winner);
}
const dfs = (player, type, check) => {
const opponents = type === 'win' ? graphWinner[player] : graphLoser[player];
if (!opponents) return;
for (const opponent of opponents) {
if (check[opponent]) continue;
dfs(opponent, type, check);
check[opponent] = 1;
}
return;
};
for (let player = 1; player < n + 1; player++) {
const checkWin = new Array(n + 1).fill(0);
const checkLose = new Array(n + 1).fill(0);
dfs(player, 'win', checkWin);
dfs(player, 'lose', checkLose);
const cntWin = checkWin.reduce((a, b) => a + b, 0);
const cntLose = checkLose.reduce((a, b) => a + b, 0);
if (cntWin + cntLose === n - 1) answer += 1;
}
return answer;
}