๐ ๋ฌธ์
https://www.acmicpc.net/problem/1719
๋ฌธ์
๋ช ์ฐ๊ธฐ์ ์ 2008๋ ๋ถํฐ ํ๋ฐฐ ์ฌ์ ์ ์๋ก์ด ์์ํ๊ธฐ๋ก ํ์๋ค. ์ฐ์ ํ๋ฐฐ ํ๋ฌผ์ ๋ชจ์์ ์ฒ๋ฆฌํ๋ ์งํ์ฅ์ ๋ช ๊ฐ ๋ง๋ จํ์ง๋ง, ํ๋ฐฐ ํ๋ฌผ์ด ๊ฐ ์งํ์ฅ๋ค ์ฌ์ด๋ฅผ ์ค๊ฐ ๋ ์ด๋ค ๊ฒฝ๋ก๋ฅผ ๊ฑฐ์ณ์ผ ํ๋์ง ๊ฒฐ์ ํ์ง ๋ชปํ๋ค. ์ด๋ค ๊ฒฝ๋ก๋ฅผ ๊ฑฐ์น ์ง ์ ํด์, ์ด๋ฅผ ๊ฒฝ๋กํ๋ก ์ ๋ฆฌํ๋ ๊ฒ์ด ์ฌ๋ฌ๋ถ์ด ํ ์ผ์ด๋ค.
์์๋ ๊ทธ๋ํ์์ ๊ตต๊ฒ ํ์๋ 1, 2, 3, 4, 5, 6์ ์งํ์ฅ์ ๋ํ๋ธ๋ค. ์ ์ ๊ฐ์ ๊ฐ์ ์ ๋ ์งํ์ฅ๊ฐ์ ํ๋ฌผ ์ด๋์ด ๊ฐ๋ฅํจ์ ๋ํ๋ด๋ฉฐ, ๊ฐ์ค์น๋ ์ด๋์ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ด๋ค. ์ด๋ก๋ถํฐ ์ป์ด๋ด์ผ ํ๋ ๊ฒฝ๋กํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ฒฝ๋กํ๋ ํ ์งํ์ฅ์์ ๋ค๋ฅธ ์งํ์ฅ์ผ๋ก ์ต๋จ๊ฒฝ๋ก๋ก ํ๋ฌผ์ ์ด๋์ํค๊ธฐ ์ํด ๊ฐ์ฅ ๋จผ์ ๊ฑฐ์ณ์ผ ํ๋ ์งํ์ฅ์ ๋ํ๋ธ ๊ฒ์ด๋ค. ์๋ฅผ ๋ค์ด 4ํ 5์ด์ 6์ 4๋ฒ ์งํ์ฅ์์ 5๋ฒ ์งํ์ฅ์ผ๋ก ์ต๋จ ๊ฒฝ๋ก๋ฅผ ํตํด ๊ฐ๊ธฐ ์ํด์๋ ์ ์ผ ๋จผ์ 6๋ฒ ์งํ์ฅ์ผ๋ก ์ด๋ํด์ผ ํ๋ค๋ ์๋ฏธ์ด๋ค.
์ด์ ๊ฐ์ ๊ฒฝ๋กํ๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋ ์ n๊ณผ m์ด ๋น ์นธ์ ์ฌ์ด์ ๋๊ณ ์์๋๋ก ์ฃผ์ด์ง๋ค. n์ ์งํ์ฅ์ ๊ฐ์๋ก 200์ดํ์ ์์ฐ์, m์ ์งํ์ฅ๊ฐ ๊ฒฝ๋ก์ ๊ฐ์๋ก 10000์ดํ์ ์์ฐ์์ด๋ค. ์ด์ด์ ํ ์ค์ ํ๋์ฉ ์งํ์ฅ๊ฐ ๊ฒฝ๋ก๊ฐ ์ฃผ์ด์ง๋๋ฐ, ๋ ์งํ์ฅ์ ๋ฒํธ์ ๊ทธ ์ฌ์ด๋ฅผ ์ค๊ฐ๋๋ฐ ํ์ํ ์๊ฐ์ด ์์๋๋ก ์ฃผ์ด์ง๋ค. ์งํ์ฅ์ ๋ฒํธ๋ค๊ณผ ๊ฒฝ๋ก์ ์์์๊ฐ์ ๋ชจ๋ 1000์ดํ์ ์์ฐ์์ด๋ค.
์ถ๋ ฅ
์์๋ ๊ฒ๊ณผ ๊ฐ์ ํ์์ ๊ฒฝ๋กํ๋ฅผ ์ถ๋ ฅํ๋ค.
โ๏ธ ํ์ด
๋ค์ต์คํธ๋ผ๋ฅผ ๋งค ์งํ์ฅ๋ง๋ค ๋์์ฃผ๋ ๊ฒ์ผ๋ก ํ์๋ค.
N๊ฐ์ ์งํ์ฅ ์ค ํ๋์์, ๋จ์ ๋ค๋ฅธ N-1๊ฐ์ ์งํ์ฅ ์ค ํ๋๋ก ๊ฐ๋ ๊ฒฝ๋กํ๋ฅผ ๋ชจ๋ ๋ง๋ค์ด์ผ ํ๋ฏ๋ก, ์ด ์ฝ๋๋ ์ด ์ธ ๋ฒ์ ๋ฃจํ๋ฅผ ๋๊ฒ ํ์๋ค.
1๏ธโฃ ์ถ๋ฐ ์งํ์ฅ์ 1๋ฒ๋ถํฐ N๋ฒ ์งํ์ฅ๊น์ง ์ค์ ํ๋ for๋ฌธ
2๏ธโฃ (๋ค์ต์คํธ๋ผ) ๋งค ์ํ๋ง๋ค ์ต์ ๊ฐ์ค์น ๋ ธ๋(current๋ก ์ค์ ํ ๋ ธ๋)๋ฅผ ์ฐพ๋ for๋ฌธ.
3๏ธโฃ (๋ค์ต์คํธ๋ผ) 2๋ฒ์์ ์ฐพ์ ์ต์๊ฐ์ค์น ๋ ธ๋์ ์ฐ๊ฒฐ๋์ด์๋ N-1๊ฐ์ ๋ ธ๋๋ฅผ ํ์ํ์ฌ, ์ต์ ๊ฐ์ค์น๋ฅผ ์ ๋ฐ์ดํธ ํ๋ for๋ฌธ.
>> ์ ์ฅ ๋ณ์
๐๏ธ int[][] containers: ๊ฐ์ค์น๋ฅผ ์ ์ฅํ๋ ์ธ์ ํ๋ ฌ ๋ฐฐ์ด.
๐๏ธ int[][] outputs: ๊ฒฐ๊ณผ๋ก ์ถ๋ ฅํ ๊ฒฝ๋กํ. output[i][j]๋ i๋ฒ ์งํ์ฅ์์ j๋ฒ ์งํ์ฅ์ผ๋ก ๊ฐ ๋ ๊ฐ์ฅ ๋จผ์ ๊ฑฐ์น๋ ์งํ์ฅ ๋ฒํธ๋ฅผ ๊ฐ๋๋ค.
>> ๋ค์ต์คํธ๋ผ ์๊ณ ๋ฆฌ์ฆ
๐๏ธ boolean[][] visited:
๐๏ธ int[] temp: 1๏ธโฃ๋ฒ ๋ฃจํ์์ ์ค์ ๋ ์ถ๋ฐ ์งํ์ฅ์ด ๋ค๋ฅธ ์งํ์ฅ๊น์ง ๊ฐ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์ต์ ๊ฐ์ค์น๋ฅผ ๋ด์ ๋ณ์. ๋ฃจํ ์์ ๋ถ๋ถ์์ ๋ฏธ๋ฆฌ ์ธํ์ผ๋ก ๋ฐ์ ๊ฐ์ค์น๋ฅผ containers ๋ณ์์์ ๋ณต์ฌํด์จ๋ค.
โป๏ธ 1๏ธโฃ๋ฒ ๋ฃจํ์์ ๋งค ์ถ๋ฐ ์งํ์ฅ์ current ๋ ธ๋(์์ ๋ ธ๋)๋ก ์ค์ ํ๊ณ , ๊ฐ์ค์น ๋ณ์ temp๋ฅผ ์ค์ ํ๋ค.
โป๏ธ current ๋ ธ๋(์ต์๊ฐ์ค์น ๋ ธ๋)์ ์ฐ๊ฒฐ๋ ๋ ธ๋๋ค์ ์ดํด๋ณธ๋ค. (3๏ธโฃ๋ฒ ๋ฃจํ)
โป๏ธ ์ฐ๊ฒฐ๋ ๋ ธ๋๋ค์ ๊ฑฐ๊ธฐ๊น์ง ๊ฐ๋ ๊ฒฝ๋ก ๋น์ฉ์ด ์ต์ ๊ฐ์ค์น๋ก ์ ๋ฐ์ดํธ ๋๋ ๊ฒ์ ๋ปํ๋ค.
โป๏ธ ๋ง์ฝ current๋ ธ๋๊ฐ ์ถ๋ฐ ์งํ์ฅ(1๏ธโฃ๋ฒ ๋ฃจํ)์ด๋ฉด, current ๋ ธ๋์ ์ฐ๊ฒฐ๋ ๋ ธ๋(k)๋ค์ ์ถ๋ฐ ์งํ์ฅ์ด ๊ฐ์ฅ ๋จผ์ ๊ฑฐ์น๋ ์งํ์ฅ์ด ๋๋ค. ๋ฐ๋ผ์ ์ด ๋ ธ๋๋ค์ ๋ฒํธ๋ฅผ output[์ถ๋ฐ์งํ์ฅ=current][k] ๋ฐฐ์ด์ ๋ฃ์ด์ค๋ค.
โป๏ธ ๋ง์ฝ current๋ ธ๋๊ฐ ์ถ๋ฐ ์งํ์ฅ์ด ์๋๋ฉด, ์ฌ๊ธฐ์ ์ฐ๊ฒฐ๋ ๋ ธ๋(k)๋ค์ output[์ถ๋ฐ์งํ์ฅ][current]์ ์ ์ฅ๋ ๊ฐ์ ๊ทธ๋๋ก output[์ถ๋ฐ์งํ์ฅ][k]์ ๋ฃ์ด์ค๋ค.
์๋ฅผ ๋ค์ด 1๋ฒ ์งํ์ฅ์์ 2๋ฒ>5๋ฒ>6๋ฒ ์์ผ๋ก ์ฐ๊ฒฐ๋์ด ๊ฐ๋ค๊ณ ํ ๋, 1๋ฒ ์งํ์ฅ์์ 5๋ฒ, 6๋ฒ ์งํ์ฅ์ผ๋ก ๊ฐ๊ธฐ ์ํด ๊ฐ์ฅ ๋จผ์ ๊ฑฐ์น๋ ์งํ์ฅ์ ๋ชจ๋ 2๋ฒ ์งํ์ฅ์ด ๋๋ฏ๋ก, output[1][2]=2 >> output[1][5]=output[1][2] >> output[1][6]=output[1][5]๊ฐ ๋๋ ๊ฒ์ด๋ค.
โป๏ธ 3๏ธโฃ๋ฒ ๋ฃจํ๊ฐ ๋๋๋ฉด ๊ฒฝ๋ก ๊ฐ์ค์น๊ฐ ์ ์ผ ์์ ๋ ธ๋๊ฐ ๋ค์์ ํ์ํ current ๋ ธ๋๊ฐ ๋๋ค.(2๏ธโฃ๋ฒ ๋ฃจํ ๋ฐ๋ณต)
๐โ๏ธ ์๊ฒฌ
๋ค์ต์คํธ๋ผ์ ๊ฐ๋ ์ ๋ค์ ํ ๋ฒ ๋ค์ง ์ ์๋ ๋ฌธ์ ์๋ค๊ณ ์๊ฐํ๋ค.
ํจ์จ์ฑ์...........์ ๋ชจ๋ฅด๊ฒ ๋ค. ํ๋ฃจ์ด๋-์์ฌ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก๋ ํ ์ ์๊ฒ ์ง๋ง, ๋ ๋ค์ต์คํธ๋ผ ์๊ธธ์ ๊ฑท๊ธฐ์(ใ ใ )
๐ป ์์ค์ฝ๋: ์๋ฐ(Java)
public class Main_๋ฐฑ์ค_1719_ํ๋ฐฐ_๊ณจ๋IV {
static boolean[] visited;
static int N, M;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
N = Integer.parseInt(st.nextToken());
M = Integer.parseInt(st.nextToken());
int[][] containers = new int[N+1][N+1];
int[][] outputs = new int[N+1][N+1];
visited = new boolean[N+1];
for (int i = 0; i < M; i++) {
st = new StringTokenizer(br.readLine());
int v1 = Integer.parseInt(st.nextToken());
int v2 = Integer.parseInt(st.nextToken());
int weight = Integer.parseInt(st.nextToken());
containers[v1][v2] = containers[v2][v1] = weight;
}// input
for (int i = 1; i <= N; i++) { //๊ฐ ์์์ (ํ)์ ๋ํ์ฌ
int current=i;
int[] temp = Arrays.copyOf(containers[i], N+1);
for (int j = 1; j <= N; j++) { // N๊ฐ์ current ๋
ธ๋ ํ์ธ
int min=Integer.MAX_VALUE, minVertex=current;
visited[current]=true;
for (int k = 1; k <= N; k++) { // current๋
ธ๋์ ์ฐ๊ฒฐ๋์ด์๋ ๊ฒ๋ค ํ์ธ
if(containers[current][k]==0 || visited[k]) continue;
if(containers[current][k] != 0 && !visited[k]) {
if(current == i) {
outputs[i][k] = k;
}else {
if(temp[k]==0) {
temp[k] = temp[current] + containers[current][k];
outputs[i][k] = outputs[i][current];
}else {
if(temp[current] + containers[current][k] < temp[k]) {
temp[k] = temp[current] + containers[current][k];
outputs[i][k] = outputs[i][current];
}
}
}
}
}//์ต์๋น์ฉ ๋
ธ๋์ ์ฐ๊ฒฐ๋ ๋
ธ๋๋ค
// ์ต์๋น์ฉ๋
ธ๋๋ฅผ current๋ก ์
๋ฐ์ดํธ
for (int t = 1; t <= N; t++) {
if(t==current || visited[t]) continue;
if(temp[t]!=0 && temp[t] < min) {
min = temp[t];
minVertex = t;
}
}
current = minVertex;
}
clearIsVisited();
}
for (int i = 1; i <= N; i++) { //print
for (int j = 1; j <= N; j++) {
if(i==j) System.out.print("- ");
else System.out.print(outputs[i][j]+" ");
}
System.out.println();
}
}//end of main
static void clearIsVisited() {
for (int i = 1; i <= N; i++) {
visited[i] = false;
}
}
}//end of class
๐ ๐ ๐
๏ผฐ๏ฝ๏ฝ๏ฝ๏ฝ ๏ฝ ๏ผข๏ฝ ๏ผณ๏ผก๏ผน
๐๐ฉ๐ข๐ฏ๐ฌ๐ด ๐ง๐ฐ๐ณ ๐ณ๐ฆ๐ข๐ฅ๐ช๐ฏ๐จ