[Java] ํ๋ก์ด๋–์์ | ๋ฐฑ์ค 1389 ์ผ๋น ๋ฒ ์ด์ปจ์ 6๋จ๊ณ ๋ฒ์น
https://www.acmicpc.net/problem/1389
์ฒซ ์ ๊ทผ ๋ฐฉ์(์คํจ)
ํ๋ก์ด๋ ์์ ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํ ์ ์์ ๊ฒ ๊ฐ์ ๋๋์ด ๋ค์์ง๋ง ์ด๋ฅผ ๊ตฌํํ๊ธฐ ๋ง๋งํด ๋ธ๋ฃจํธํฌ์ค ๋ฐฉ์์ผ๋ก ํ์ด๋ณด์๊ณ ๊ฒฐ๊ณผ๋ ์ญ์ ์คํจ์๋ค.
๋๋ต ์๋์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ์ ๊ทผํ์๋ค.
1. ๋ชจ๋ ๊ฐ๋ฅํ ๋
ธ๋ ์ (i, j)์ ๋ํด ๋ฐ๋ณตํ๋ฉฐ ์ฐ๊ฒฐ ์ฐพ๊ธฐ
2. searchMin ํจ์๋ฅผ ํตํ ํ์
3. ๊ฐ ์ฐ๊ฒฐ๋์ง ์์ ๋
ธ๋ ์์ ๋ํด searchMin ํจ์๋ฅผ ํธ์ถํ์ฌ ์ค๊ฐ ๋
ธ๋ ์ฐพ๊ธฐ
4. ๋ชจ๋ ๊ฐ๋ฅํ ๊ฒฝ๋ก๋ฅผ ํ์ํ๊ณ ์ต์๊ฐ์ ๊ฐฑ์
์์ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ์ฌ๋ฐ๋ฅด๊ฒ ๋์ฌ ์ ์์์ง๋ง ์๊ฐ ์ด๊ณผ ๋ฑ์ ๋ฌธ์ ๋ก ์คํจํ์๋ค.
๋ค์ ํ๋ก์ด๋ ์์ ํ์ตํ๊ณ ํ์ดํ ๋ด์ฉ์ ์ ๋ฆฌํด ๋ณธ๋ค.
๋ด๊ฐ ๋ธ๋ฃจํธํฌ์ค ๋ฐฉ์์ผ๋ก ์ ๊ทผํ์๋๋ ๊ฒฐ๊ตญ ์ฐ๊ฒฐ๋์ง ์์ ์ ์ ์์ ์ด์ ์ ์๋ ์ค๊ฐ ์ ์ ๋ฅผ ๊ตฌํ๋ ๊ฒ์ด ๋ชฉ์ ์ด์๋ค.
=> ํ๋ก์ด๋ ์์ ๋ฐฉ์์ ์ด๋ป๊ฒ ์ ์ฉํด์ผ๋ ์ง ์ ํํ ๋ชฐ๋ผ ์ด๋ ค์ ๋๊ฒ ๊ฐ๋ค.
์ฐ์ ์ ์ ์ต์ ๊ด๊ณ๋ฅผ ์ ์ฅํ ์ ์๋ 2์ฐจ์ ๋ฐฐ์ด์ ์์ฑํ๋ค. ๋ชจ๋ ๊ฐ์ ์ต๋ ๊ด๊ณ์์ธ 5000์ผ๋ก ์ฑ์ฐ๊ณ , iํ i์ด ์๊ธฐ ์์ ๊ณผ์ ๊ด๊ณ๋ 0์ผ๋ก ์ค์ ํ๋ค.
for (int i = 1; i <= N; i++) {
Arrays.fill(bacon[i], 5000);
bacon[i][i] = 0;
}
๋ค์ ๋จ๊ณ๋ก M๊ฐ์ ์น๊ตฌ ๊ด๊ณ๋ฅผ ๋ฐ๋ก ์ฐ๊ฒฐ๋์ด ์๋ ๊ด๊ณ์ด๋ฏ๋ก 1๋ก ์ ๋ฐ์ดํธํ๋ค.
๊ด๊ณ๊ฐ u1 u2 ์ผ ๊ฒฝ์ฐ => u1 ํ u2์ด, u2ํ u1์ด์ 1๋ก ์ ๋ฐ์ดํธ
for(int i=0; i < M; i++) {
st = new StringTokenizer(br.readLine());
int u1 = Integer.parseInt(st.nextToken());
int u2 = Integer.parseInt(st.nextToken());
bacon[u1][u2] = bacon[u2][u1] = 1;
}
์ด์ ํ๋ก์ด๋ ์์ ์๊ณ ๋ฆฌ์ฆ์ ์ ์ฉํ ๋จ๊ณ๋ค.
๊ฑฐ์ฒ๊ฐ ์ ์ ๋ฅผ k๋ก ํ๊ณ , i ์ j ์ฌ์ด์ ๊ด๊ณ๊ฐ i ์ k ์ฌ์ด์ ๊ด๊ณ + k ์ ์ฌ์ด์ ๊ด๊ณ๋ณด๋ค ํฌ๋ค๋ฉด k๋ฅผ ํตํ ๊ด๊ณ๊ฐ ๋ ์์ ๋จ๊ณ๋ฅผ ๊ฑฐ์น๋ฏ๋ก ์ด๋ก ์๋ฐ์ดํธ ํ๋ค. (i == j ์ธ ๊ฒฝ์ฐ๋ 0์ผ๋ก ์ ์ฅํด ๋์๊ธฐ ๋๋ฌธ์ ์ด๋ค ๊ฒฝ์ฐ์๋ ์์๋ก ์ ๋ฐ์ดํธ ๋ ์ ์๋ค)
for(int k=1; k <=N; k++) {
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= N; j++) {
if (bacon[i][j] > bacon[i][k] + bacon[k][j]) {
bacon[i][j] = bacon[i][k] + bacon[k][j];
}
}
}
}
๋ง์ง๋ง์ผ๋ก ๊ฐ ํ์ ํฉ ์ค ์ต์ ๊ฐ์ ๊ฐ์ง๋ user๋ฅผ ์ถ๋ ฅํด์ฃผ๋ฉด ์ ๋ต์ ์ถ๋ ฅํ ์ ์๋ค. ํฉ์ ์ต์๊ฐ์ด ์ฌ๋ฌ ๋ช ์ผ ๊ฒฝ์ฐ์๋ ๋ฒํธ๊ฐ ๊ฐ์ฅ ์์ ์ฌ๋์ ์ถ๋ ฅํ๋ค ํ์ผ๋ฏ๋ก,
์ ์ 1๋ถํฐ ์ํํ์ฌ min > sum ์ผ ๊ฒฝ์ฐ์๋ง ์ ์ ๋ฒํธ๋ฅผ ์ ๋ฐ์ดํธํ์ฌ ํฉ์ ์ต์๊ฐ์ด ๋์ผํ ์ ์ ๋ ๋ฒํธ๊ฐ ํฐ ์ ์ ์ด๋ฏ๋ก ๋ฌด์ํ๋ฉด ๋๋ค.
int min = Integer.MAX_VALUE;
int user = 0;
for(int i = 1; i <= N; i++){
int sum = 0;
for(int j = 1; j <= N; j++){
sum += bacon[i][j];
}
if(min > sum) {
min = sum;
user = i;
}
}
System.out.println(user);
๋ฐฐ์ด์ :
ํ๋ก์ด๋ ์์ ์๊ณ ๋ฆฌ์ฆ์ ์์ง ์๋ฒฝํ๊ฒ ์ดํดํ์ง ๋ชปํ๋ค๋ ๊ฒ์ ์์๋ค. ์๊ณ ๋ฆฌ์ฆ์ ๋์ถฉ ์ดํด์๋ ๊ฐ์ ์๊ณ ๋ฆฌ์ฆ ์ ํ์ ๋ฌธ์ ๋ผ๋ ๊ณ์ ํ๋ฆด ์ ์๊ธฐ ๋๋ฌธ์ ์ ํํ๊ฒ ๋ฌธ์ ์ ํด๋น ์๊ณ ๋ฆฌ์ฆ์ ํต์ฌ์ ์ง๋ ๋ ธ๋ ฅ์ ํด์ผ๊ฒ ๋ค.
i ์ j ์ฌ์ด์ ๋จ๊ณ์ (i ์ k ์ฌ์ด์ ๋จ๊ณ + k ์ j์ฌ์ด์ ๋จ๊ณ), ์ด์ ํ์ด๋ณด์๋ ์ ์ i์์ j๋ก ๊ฐ๋ ๊ธธ์ด๊ฐ ์์์ธ ๊ฒฝ๋ก ๋ ๋ฌธ์ ๋ ๊ณตํต์ ์ผ๋ก ๊ฒฐ๊ตญ ๋ชจ๋ ๋ ธ๋์ ๋ ธ๋๊ฐ์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ๊ฒ์ ๋ชฉํ๋ก ํ๋ค. ๊ด๋ จ ๋ฌธ์ ๋ฅผ ๋ ํ์ด๋ณด๋ฉฐ ํ๋ก์ด๋ ์์ ์๊ณ ๋ฆฌ์ฆ์ ๋ ํ์คํ๊ฒ ์ดํดํด๋ณด์์ผ๊ฒ ๋ค.