๋ฌธ์ : ํ๋ก๊ทธ๋๋จธ์ค - ๊ฐ์ฅ ๋จผ ๋ ธ๋
์นดํ ๊ณ ๋ฆฌ : ๊ทธ๋ํ
์ถ์ฒ : ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉ ํ ์คํธ ์ฐ์ต, https://school.programmers.co.kr/learn/challenges
[[3, 6], [4, 3], [3, 2], [1, 3], [1, 2], [2, 4], [5, 2]]
์ด๋ฐ ์์ผ๋ก ๊ทธ๋ํ์ ๊ฐ ๋
ธ๋์ ๋
ธ๋ ๊ฐ์ ๊ฐ์ ์ ๋ณด๊ฐ ์ฃผ์ด์ง๋๋ฐ, ์ด๋ฅผ ํตํด ๋
ธ๋ 1๋ก๋ถํฐ ๊ฐ์ฅ ๋ฉ๋ฆฌ๋จ์ด์ง ๋
ธ๋๋ค์ ์ฐพ์์ผํ๋ ๋ฌธ์ ์๋ค.
"๊ฐ์ฅ ๋ฉ๋ฆฌ ๋จ์ด์ง" ๋ ธ๋๋ค์ ํ๋จํ๊ธฐ ์ํด์๋, ๋ ธ๋ 1๊ณผ ๋๋จธ์ง ๋ ธ๋๋ค๊ฐ์ ๊ฑฐ๋ฆฌ๋ฅผ ๋ค ๊ตฌํด์ ๋น๊ตํด์ผ ๊ฒ ๋ค๋ ์๊ฐ์ด ๋ค์๋ค.
๊ฐ ๋ ธ๋๋ค๊ฐ์ ๊ฑฐ๋ฆฌ๋ฅผ ๊ตฌํ๋ ค๋ฉด, ๋ ธ๋๋ค์ด ์๋ก ์ด๋๊น์ง ์ฐ๊ฒฐ๋์ด์๋์ง ๋ค ํ์ํด๋ด์ผ ํ๋ค๊ณ ์๊ฐํด์, BFS ๋ฐฉ์์ ์ฌ์ฉํ๋ค.
BFS๋ฅผ ์ํ Queue ์๋ฃ๊ตฌ์กฐ ์ง์ ๊ตฌํ
์ธ์ ๋ฆฌ์คํธ ๋ฐฉ์์ผ๋ก ๊ทธ๋ํ ๊ตฌํ
const graph = Array.from( // ์ธ์ ๋ฆฌ์คํธ ๋ฐฉ์์ผ๋ก ๊ทธ๋ํ ๊ตฌํ
Array(n+1), // 1~n ๊น์ง ์ฌ์ฉํ ๊ฒ์ด๋ฏ๋ก
() => []
);
for(let [i,j] of edge){ // ๊ทธ๋ํ ์ด๊ธฐํ
graph[i].push(j);
graph[j].push(i);
}
let dist = new Array(n+1).fill(-1); // 1๋ฒ ๋
ธ๋์ 1 ~ n๋ฒ ๋
ธ๋ ์ฌ์ด์ ๊ฑฐ๋ฆฌ
let queue = new Queue();
dist[1] = 0;
let max_dist = 0; // 1๋ฒ ๋
ธ๋์ 1 ~ n๋ฒ ๋
ธ๋ ์ฌ์ด์ ๊ฑฐ๋ฆฌ ์ค ์ต๋๊ฐ
queue.enqueue([1, 0]); // 1๋ฒ ๋
ธ๋๋ก๋ถํฐ ํ์ ์์
while(queue.size()){
let [node, now_dist] = queue.dequeue(); // [1, 0]
for(let x of graph[node]){ // 2, 3
if(dist[x] !== -1) continue;// ๋ฐฉ๋ฌธ ์ && ๊ฑฐ๋ฆฌ๊ฐ ์
๋ฐ์ดํธ ๋ ์ ์์ ๋
dist[x] = now_dist+1; // ๋ฐฉ๋ฌธ ํ์
if(max_dist < now_dist+1){
max_dist = now_dist+1;
}
queue.enqueue([x, now_dist+1]);
}
}
max_dist
๋ฅผ ์ ์ธํด์ฃผ๊ณ , ๊ฐ node๋ค์ ๋ฐฉ๋ฌธํ ๋๋ง๋ค ์
๋ฐ์ดํธ ๊ฐ๋ฅ ์ ์
๋ฐ์ดํธ ํด์ค๋ค. let answer = 0;
dist.forEach((dist) => {
if(dist === max_dist)
answer++;
})
return answer;
๋ฐฐ์ด๋ก ํ๋ฅผ ์ฌ์ฉํ ๋ shift
์ฐ์ฐ์ O(n)
์ด๋ฏ๋ก ์ฐ๋ฆฌ๊ฐ ์๊ฐํ๋ queue์๋ ๋ค๋ฅด๊ฒ ๋์ํ๋ค๊ณ ํ๋๋ฐ, ๋ง์ฝ ์์๊ฐ ์ ์ ๊ฒฝ์ฐ์๋ ์๋ฐ์คํฌ๋ฆฝํธ ์์ง์์ ์ด๋์ ๋ ์ต์ ํ๋ฅผ ํด์ค๋ค.
=> ๋ฐ๋ผ์, ์ด ๋ฌธ์ ์์๋ ๋ฐฐ์ด์ shift
๋ฅผ ์ด์ฉํด์ queue๋ฅผ ์ฌ์ฉํด๋ ๊ด์ฐฎ๋ค !
Solution์ ๋ณด๊ณ , ๋ด ์ฝ๋๋ฅผ ๊ฐ์ ํด๋ณด์๋ค.
for(let [i,j] of edge) => for(const[src, dest] of edge)
๋๋ BFS๋ฅผ ๋๋ฉด์ queue์ [node ๋ฒํธ, ๊ฑฐ๋ฆฌ]
๋ฅผ ๋๊ฒจ์คฌ๋๋ฐ, ๊ฑฐ๋ฆฌ ๊ฐ์ ๋๊ฒจ์ฃผ์ง ์๊ณ ๊ทธ๋ฅ ๊ฐ ๋
ธ๋๋ฅผ queue์ ๋ฃ์ ๋ ๋ฐ๋ก distance๋ฅผ ๊ณ์ฐํด์ค ์ ์๋ค.
distance[ํ์ฌ ๋
ธ๋] = distane[์ด์ ๋
ธ๋] + 1
๋๋ max_dist
๋ณ์๋ฅผ ๋ฐ๋ก๋์ง๋ง ํ์ ๋ฐฉ์์ผ๋ก ๋ ์งง๊ณ ๊ฐ๋จํ๊ฒ ๊ตฌํ ์ ์๋ค !
const max = Math.max(...distance);
return distance.filter(item => item === max).length;