迷宫问题的DFS

这道题我还是觉得bfs简单，可是这货居然DFS也能解，Orz之余，学习学习......

文章转自http://www.2cto.com/kf/201308/235681.html

POJ 3984 迷宫问题 (DFS(深度优先搜索))

迷宫问题
Time Limit: 1000MS   Memory Limit: 65536K
Total Submissions: 6322   Accepted: 3673

Description

定义一个二维数组：

int maze[5][5] = {

0, 1, 0, 0, 0,

0, 1, 0, 1, 0,

0, 0, 0, 0, 0,

0, 1, 1, 1, 0,

0, 0, 0, 1, 0,

};
它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。
Input

一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。
Output

左上角到右下角的最短路径，格式如样例所示。
Sample Input

0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0Sample Output

(0, 0)
(1, 0)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(2, 4)
(3, 4)
(4, 4)

思路： DFS算法

?

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

51

52

53

54

55

56

57

58

59

import java.io.*;

import java.util.*;

public class Main {

public static int map[][] = new int[5][5];

public static int fx[] = { 0, 0, 1, -1 };

public static int fy[] = { 1, -1, 0, 0 };

public static int px, py;

public static void main(String[] args) {

Scanner sc = new Scanner(newBufferedInputStream(System.in));

while (sc.hasNextInt()) {

for (int i = 0; i < map.length; i++) {

for (int j = 0; j < map[i].length; j++) {

map[i][j] = sc.nextInt();

}

}

map[0][0] = 3;//标记走过

px = 0;

py = 0;

DFS(0, 0); 

}

}

public static void DFS(int p1, int p2) {

if (p1 == map.length - 1 && p2 == map[0].length - 1){

out();

return;

}

else {

//四个方向进行判定

for (int i = 0; i < 4; i++) {

int px = p1 + fx[i];

int py = p2 + fy[i];

if (check(px, py)) {

map[px][py] = 3;//标记走过的路

DFS(px, py);

}

}

}

}

public static void out() {

for (int i = 0; i <5; i++) {

for (int j = 0; j <5; j++) {

if (map[i][j] == 3) {

System.out.println("(" + i + ", " + j + ")");

}

}

}

}

public static boolean check(intp1, int p2) {

if (p1 < 0 || p1 > map[0].length - 1 || p2 < 0 || p2 > map.length - 1

|| map[p1][p2] != 0)

return false;

else

return true;

}

}