各种迷宫问题

迷宫游戏Ⅰ

迷宫问题的解法就需要用到dfs。我们对上下左右四个方向，一个方向一个方向地尝试，如果沿着某个方向不能走到终点，我们就要原路返回，继续尝试其他方向，直到走出迷宫。这是一种最朴素的走迷宫方式，虽然效率也许比较低，但如果迷宫有解，就一定能走出终点。

上面说的这种走法，就对应着我们要讲的dfs算法。首先找到起点s，走到每个点时，按照左、下、右、上的顺序尝试。每走到下一个点以后，我们把这个点当做起点s，继续按顺序尝试。如果某个点上下左右四个方向都尝试过，便回到走到这个点之前的点，这一步我们称之为回溯。继续尝试其他方向。直到所有点都尝试过上下左右四个方向。

这就好比你自己去走这个迷宫，你也要一个方向一个方向的尝试着走，如果这条路不行，就回头，尝试下一条路，dfs的思想和我们直观的想法很类似。只不过，接下来我们需要用程序来完成这个过程。
我们用一个二维的字符数组来表示迷宫，其中字符’S’表示起点，字符’T’表示终点，字符’*‘表示墙壁，字符’.'表示平地。你需要从S出发走到T，每次只能向上下左右相邻的位置移动，不能走出地图，也不能穿过墙壁，每个点只能通过一次。你需要输出一种从起点到终点的走法，将走过的点用’m’表示。

输入
```
5 6
....S.
.***..
.*..*.
*.***.
.T....
```
输出
```
....Sm
.***.m
.*..*m
*.***m
.Tmmmm
```

import java.util.Scanner;

public class Main {
    static int n;
    static int m;
    static char ch[][];
    static boolean visited[][];//判断该点是否已经访问过
    static int index[][] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        ch = new char[n][m];
        visited = new boolean[n][m];
        in.nextLine();
        for (int i = 0; i < n; i++) {
            String str = in.nextLine();
            ch[i] = str.toCharArray();
        }
        int x = 0, y = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                visited[i][j] = false;
                if (ch[i][j] == 'S') {
                    x = i;
                    y = j;
                }
            }
        }
        if (dfs(x, y)) {
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    ch[x][y] = 'S';
                    System.out.print(ch[i][j]);
                    if (j == m - 1) {
                        System.out.println();
                    }
                }
            }
        } else {
            System.out.println("没有找到合适的路径");
        }
    }

    public static boolean dfs(int x, int y) {
        if (ch[x][y] == 'T') {
            return true;
        }
        visited[x][y] = true;
        ch[x][y] = 'm';
        for (int i = 0; i < 4; i++) {
            int tx = x + index[i][0];
            int ty = y + index[i][1];
            if (in(tx, ty) && !visited[tx][ty] && ch[tx][ty] != '*') {
                if (dfs(tx, ty)) {
                    return true;
                }
            }
        }
        visited[x][y] = false;
        ch[x][y] = '.';
        return false;
    }

    public static boolean in(int x, int y) {
        return x >= 0 && x < n && y >= 0 && y < m;
    }
}

迷宫游戏Ⅱ

有一个n xm的地图，地图由’.‘、’#'、'S '、‘T’这四个部分组成。’.‘表示可以通行的路，’#’表示迷宫的墙，'S’表示起始点，'T’表示终点。输出一个整数，表示从’S’到达’T’的所有方案数。

输入
```
5 5
S####
.####
.####
.####
....T
```
输出
```
m####
m####
m####
m####
mmmmT
 
1
```

import java.util.Scanner;

public class Main {
    static int n;
    static int m;
    static int count;
    static char ch[][];
    static boolean visited[][];
    static int index[][] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        ch = new char[n][m];
        visited = new boolean[n][m];
        in.nextLine();
        for (int i = 0; i < n; i++) {
            String str = in.nextLine();
            ch[i] = str.toCharArray();
        }
        int x = 0, y = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                visited[i][j] = false;
                if (ch[i][j] == 'S') {
                    x = i;
                    y = j;
                }
            }
        }
        dfs(x, y);
        System.out.println(count);
    }
    
    public static boolean in(int x, int y) {
        return x >= 0 && x < n && y >= 0 && y < m;
    }

    public static void dfs(int x, int y) {
        if (!in(x, y) || visited[x][y] || ch[x][y] == '#') {
            return;
        }
        if (ch[x][y] == 'T') {
            count++;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    System.out.print(ch[i][j]);
                    if (j == m - 1)
                        System.out.println();
                    if(i==n-1&&j==m-1)
                        System.out.println(" ");
                }
            }
            return;
        }
        visited[x][y] = true;
        ch[x][y] = 'm';
        for (int i = 0; i < 4; i++) {
            int tx = x + index[i][0];
            int ty = y + index[i][1];
            dfs(tx, ty);
        }
        visited[x][y] = false;
        ch[x][y] = '.';
        return;//可删除
    }
}

迷宫游戏Ⅲ

有一个n xm的地图，地图由’.‘、’#‘这两个部分组成。四连通的’#'被认为是一个块，请问地图中最大的块是多少。

输入
```
3 3
##.
..#
###
```
输出
```
4
```

import java.util.Scanner;

public class Main {
    static int count;
    static int n;
    static int m;
    static boolean visited[][];
    static char ch[][];
    static int index[][] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

    public static void main(String[] args) {
        int temp = 0;
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        ch = new char[n][m];
        visited = new boolean[n][m];
        in.nextLine();
        for (int i = 0; i < n; i++) {
            String str = in.nextLine();
            ch[i] = str.toCharArray();
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                visited[i][j] = false;
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (ch[i][j] == '#' && !visited[i][j]) {
                    count = 0;
                    dfs(i, j);
                    if (count > temp) {
                        temp = count;
                    }
                }
            }
        }
        System.out.println(temp);
    }

    public static void dfs(int x, int y) {
        if (x < 0 || x >= n || y < 0 || y >= m || visited[x][y] || ch[x][y] == '.') {
            return;
        }
        visited[x][y] = true;
        count++;
        ch[x][y] = '.';
        for (int i = 0; i < 4; i++) {
            int tx = x + index[i][0];
            int ty = y + index[i][1];
            dfs(tx, ty);
        }
    }
}

水洼数

有一个大小为N乘M的园子，雨后积起了水。八连通的积水被认为是连接在一起的。请求出园子里总共有多少水洼?(八连通指的是下图中相对W的*部分，W表示积水， '*'表示没有积水)

***

*w*

***

限制条件
N, M <=100
样例：

输入
```
10 12
W********WW*
*WWW*****WWW
****WW***WW*
*********WW*
*********W**
**W******W**
*W*W*****WW*
W*W*W*****W*
*W*W******W*
**W*******W*
```
输出
```
3
```

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int N = in.nextInt();
		int M = in.nextInt();
		char ch[][] = new char[N][M];
		for (int i = 0; i < N; i++) {
			ch[i] = in.next().toCharArray();
		}

		int count = 0;
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < M; j++) {
				if (ch[i][j] == 'W') {
					dfs(ch, i, j);
					count++;
				}
			}
		}
		System.out.println(count);
	}

	public static void dfs(char ch[][], int i, int j) {
        //不需要回溯
		ch[i][j] = '*';
		for (int m = -1; m <= 1; m++) {
			for (int n = -1; n <= 1; n++) {
				if (m == 0 && n == 0) {
					continue;
				}
				if (i + m >= 0 && i + m <= ch.length - 1 && j + n >= 0 && j + n <= ch[i].length - 1) {
					if (ch[i + m][j + n] == 'W') {
						dfs(ch, i + m, j + n);
					}
				}
			}
		}
	}
}

各种迷宫问题

迷宫游戏Ⅰ

迷宫游戏Ⅱ

迷宫游戏Ⅲ

水洼数

悦读