์ธํ์ ๋ฌธ์ ๋?
๊ฐ์ฅ ์ ๋ช ํ ์ต์ ํ ๋ฌธ์ ์ค ํ๋๋ก Traveling Sales-man Problem (TSP)๋ผ๊ณ ๋ถ๋ฆฌ๋ ๋ฌธ์ ์ด๋ค. ์ด๋ค ๋๋ผ์ n(2<=n<=10)๊ฐ์ ํฐ ๋์๊ฐ ์๋ค๊ณ ํด๋ณด์. ํ ์์ ์ฌ์์ด ํ ๋์์์ ์ถ๋ฐํด ๋ค๋ฅธ ๋์๋ค์ ์ ๋ถ ํ ๋ฒ์ฉ ๋ฐฉ๋ฌธํ ๋ค ์์ ๋์๋ก ๋์์ค๋ ค๊ณ ํ๋ค.
์ด๋ ๊ฐ ๋์๋ค์ ๋ชจ๋ ์ง์ ๋๋ก๋ก ์ฐ๊ฒฐ๋์ด ์๋ค๊ณ ํ์ ๋, ์์ ์ฌ์์ด ์ฌํํด์ผ ํ ๊ฑฐ๋ฆฌ๋ ์ด๋ ์์๋ก ๊ฐ ๋์๋ค์ ๋ฐฉ๋ฌธํ๋๋์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋ค. ์ด๋ ๊ฐ๋ฅํ ๋ชจ๋ ๊ฒฝ๋ก ์ค ๊ฐ์ฅ ์งง์ ๊ฒฝ๋ก๋ฅผ ์ด๋ป๊ฒ ์ฐพ์๋ผ ์ ์์๊น?
๋ฌด์ํ๊ฒ ํ๊ธฐ
์์ํ ๋์๋ก ๋์์ค๋ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ๊ฒ์ด๋ฏ๋ก, ๊ฒฝ๋ก์ ์์์ ์ ์ด๋ค ์ ์ผ๋ก ํ๋ ๊ฒฐ๊ณผ๋ ๋ ๊ฐ๋ค.
ํด๋น ๋ฌธ์ ๋ฅผ ๋ฌด์ํ๊ฒ ํ๊ธฐ ์ํด์๋ (n-1)! ๊ฐ์ ๊ฒฝ๋ก๋ฅผ ์ง์ ํ์ํด์ผ๋ง ํ๋ค. n์ด ์ต๋ 10์ด ๋ ์๊ฐ ์์ผ๋ฏ๋ก ํ์ํด์ผ ํ๋ ๊ฒฝ๋ก์ ์ต๋ ์๋ 9! ์ฆ, 362,880๊ฐ๊ฐ ๋๋ค. ๋ฐ๋ผ์ ์์ ํ๊ฒ ์์ ํ์ ๋ฐฉ์์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
์ฌ๊ทํธ์ถ ๋ฐฉ์
๊ฐ ์ ์์ ๋๋ฌํ ์ ์๋ ๋์๋ ์ด ์์ ์ ์ ์ธํ n-1๊ฐ์ ๋์์ด๋ค. ์ฆ, ์์ ํ์์ ์ํด์๋ ๊ฐ ์ ์์ n-1๊ฐ์ ๋ชจ๋ ๋์๋ฅผ ๋ฐฉ๋ฌธํ์ฌ ๊ฒฝ๋ก์ distance๋ฅผ ๊ณ์ฐํ ํ, ์ต์๊ฐ์ ๊ตฌํ๋ฉด ๋๋ค.
n๊ฐ์ ๋์๋ก ๊ตฌ์ฑ๋ ๊ฒฝ๋ก๋ฅผ n๊ฐ์ ์กฐ๊ฐ์ผ๋ก ๋๋์ด์, ์ฌ๊ทํธ์ถ ๋ฐฉ์์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ฉด ๋๋ค.
์ฝ๋
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
import java.util.LinkedList;
public class TSP {
static int n = 5;
static final int INF = 123456;
static int dist[][] = {
{0,3,4,5,6},
{3,0,2,1,3},
{4,2,0,4,3},
{5,1,4,0,4},
{6,3,3,4,0} };
public static void main(String[] args) {
LinkedList<Integer> path = new LinkedList<Integer>();
boolean[] visited = {true,false,false,false,false};
path.add(0);
System.out.println(tsp(0, path, visited));
}
public static int tsp(int currentLength, LinkedList<Integer> path, boolean[] visited) {
int ret = INF;
return currentLength + dist[path.peekFirst()][path.peekLast()];
}
for(int i=0; i<n; i++) {
if(visited[i]) {
continue;
}
int here = path.peekLast();
path.add(i);
visited[i] = true;
int now = tsp(currentLength + dist[here][i], path, visited);
if(ret > now) {
ret = now;
}
path.pollLast();
visited[i] = false;
}
return ret;
}
}
|