[Algorithm] ๋ถ๋๋ณต๊ท
๐ ๋ฌธ์
๊ฐ์ฒ ๋ถ๋์ ๊ฐ ๋ถ๋์์ด ์ฌ๋ฌ ์ง์ญ์ ๋ฟ๋ฟ์ด ํฉ์ด์ ธ ํน์ ์๋ฌด๋ฅผ ์ํ ์ค์ ๋๋ค. ์ง๋์์ ๊ฐ์ฒ ๋ถ๋๊ฐ ์์นํ ์ง์ญ์ ํฌํจํ ๊ฐ ์ง์ญ์ ์ ์ผํ ๋ฒํธ๋ก ๊ตฌ๋ถ๋๋ฉฐ, ๋ ์ง์ญ ๊ฐ์ ๊ธธ์ ํต๊ณผํ๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ๋ชจ๋ 1๋ก ๋์ผํฉ๋๋ค. ์๋ฌด๋ฅผ ์ํํ ๊ฐ ๋ถ๋์์ ์ง๋ ์ ๋ณด๋ฅผ ์ด์ฉํ์ฌ ์ต๋จ์๊ฐ์ ๋ถ๋๋ก ๋ณต๊ทํ๊ณ ์ ํฉ๋๋ค. ๋ค๋ง ์ ๊ตฐ์ ๋ฐฉํด๋ก ์ธํด, ์๋ฌด์ ์์ ๋์ ๋ค๋ฅด๊ฒ ๋๋์์ค๋ ๊ฒฝ๋ก๊ฐ ์์ด์ ธ ๋ณต๊ท๊ฐ ๋ถ๊ฐ๋ฅํ ๋ถ๋์๋ ์์ ์ ์์ต๋๋ค.
๊ฐ์ฒ ๋ถ๋๊ฐ ์์นํ ์ง์ญ์ ํฌํจํ ์ด์ง์ญ์ ์ n, ๋ ์ง์ญ์ ์๋ณตํ ์ ์๋ ๊ธธ ์ ๋ณด๋ฅผ ๋ด์ 2์ฐจ์ ์ ์ ๋ฐฐ์ด roads, ๊ฐ ๋ถ๋์์ด ์์นํ ์๋ก ๋ค๋ฅธ ์ง์ญ๋ค์ ๋ํ๋ด๋ ์ ์ ๋ฐฐ์ด sources, ๊ฐ์ฒ ๋ถ๋์ ์ง์ญ destination์ด ์ฃผ์ด์ก์ ๋, ์ฃผ์ด์ง sources์ ์์ ์์๋๋ก ๊ฐ์ฒ ๋ถ๋๋ก ๋ณต๊ทํ ์ ์๋ ์ต๋จ์๊ฐ์ ๋ด์ ๋ฐฐ์ด์ returnํ๋ solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์. ๋ณต๊ท๊ฐ ๋ถ๊ฐ๋ฅํ ๊ฒฝ์ฐ ํด๋น ๋ถ๋์์ ์ต๋จ์๊ฐ์ -1์ ๋๋ค.
์ ํ ์ฌํญ
- 3 ≤ n ≤ 100,000
- ๊ฐ ์ง์ญ์ ์ ์ 1๋ถํฐ n๊น์ง์ ๋ฒํธ๋ก ๊ตฌ๋ถ๋ฉ๋๋ค.
- 2 ≤ roads์ ๊ธธ์ด ≤ 500,000
- roads์ ์์์ ๊ธธ์ด = 2
- roads์ ์์๋ [a, b] ํํ๋ก ๋ ์ง์ญ a, b๊ฐ ์๋ก ์๋ณตํ ์ ์์์ ์๋ฏธํฉ๋๋ค.(1 ≤ a, b ≤ n, a ≠ b)
- ๋์ผํ ์ ๋ณด๊ฐ ์ค๋ณตํด์ ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- ๋์ผํ [a, b]๊ฐ ์ค๋ณตํด์ ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- [a, b]๊ฐ ์๋ค๋ฉด [b, a]๋ ์ฃผ์ด์ง์ง ์์ต๋๋ค.
- 1 ≤ sources์ ๊ธธ์ด ≤ 500
- 1 ≤ sources[i] ≤ n
- 1 ≤ destination ≤ n
์ ์ถ๋ ฅ ์
3 | [[1, 2], [2, 3]] | [2, 3] | 1 | [1, 2] |
5 | [[1, 2], [1, 4], [2, 4], [2, 5], [4, 5]] | [1, 3, 5] | 5 | [2, -1, 0] |
โ๏ธ ํ์ด
๋ฌธ์ ๋ฅผ ์ฝ๊ณ ๊ธธ์ ๊ทธ๋ํํ ์์ผ์ BFS๋ฅผ ๋๋ฆฌ๋ฉด ๋ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ๋ค. ๊ทธ๋ํ๋ ๊ฐ์ฒด ๋ด ๋ฐฐ์ด๋ก ๊ตฌ์ฑํ๊ณ ๋งค๊ฐ๋ณ์์ธ roads๋ ์๋ฐฉํฅ์ด๊ธฐ ๋๋ฌธ์ ์์ชฝ์ ๋ฃ์ด์คฌ๋ค. ์ต๋จ๊ฑฐ๋ฆฌ์ด๊ธฐ ๋๋ฌธ์ ๋ฐฉ๋ฌธํ ์ง์ ์ ๋ค์ ๋ฐฉ๋ฌธํ๋ค๋ณด๋ฉด ์๋์น์์ ๋จผ ๊ธธ์ด ๋์ฌ ๊ฒ์ด๊ณ ์๊ฐ์ด๊ณผ๋ก ์ด์ด์ง ์ ์์ด check ๋ฐฐ์ด์ ํ์ฉํ๊ณ answer์๋ sources ์์๋๋ก ๋ค์ด๊ฐ์ผ ํ๊ธฐ ๋๋ฌธ์ ๋ณ๋์ ์ฝ๋๊ฐ ํ์ํ๋ค๊ณ ํ๋จํ๋ค. ๋ฐ๋ผ์ 100,000์ ๊ธธ์ด์ธ ๋ฐฐ์ด์ ์ต๋จ๊ฑฐ๋ฆฌ๋ฅผ ํ์ํด๋๊ณ sources๋ฅผ ์ํํ๋ฉด์ answer์ ๋ฃ์ด์คฌ๋ค.
โจ๏ธ ์ฝ๋
function solution(n, roads, sources, destination) {
var answer = [];
const graph = {};
for (const road of roads) {
const [start, end] = road;
if (graph[start]) graph[start].push(end);
else graph[start] = [end];
if (graph[end]) graph[end].push(start);
else graph[end] = [start];
}
const queue = [destination];
const sourcesArr = new Array(100000).fill(-1);
const check = new Array(100000).fill(0);
let dist = 1;
sourcesArr[destination] = 0;
check[destination] = 1;
while (queue.length) {
const len = queue.length;
for (let i = 0; i < len; i++) {
const area = queue.shift();
if (!graph[area]) continue;
for (const nextArea of graph[area]) {
if (check[nextArea]) continue;
sourcesArr[nextArea] = dist;
check[nextArea] = 1;
queue.push(nextArea);
}
}
dist++;
}
for (const source of sources) {
answer.push(sourcesArr[source]);
}
return answer;
}