挑战程序竞赛系列（4）：2.1深度优先搜索

2.1 深度优先搜索

详细代码可以fork下Github上leetcode项目，不定期更新。

练习题如下：
1. POJ 1979: Red and Black
2. AOJ 0118: Property Distribution
3. AOJ 0033: Ball
4. POJ 3009: Curling 2.0

POJ 1979: Red and Black

水题，直接深度优先搜索即可，代码如下：

public class SolutionDay09_P1979 {    public static void main(String[] args) {        Scanner in = new Scanner(System.in);        while (true) {            int W = in.nextInt();            int H = in.nextInt();            char[][] map = new char[H][W];            if (W == 0 && H == 0)                break;            for (int i = 0; i < H; i++) {                char[] ss = in.next().trim().toCharArray();                for (int j = 0; j < W; j++) {                    map[i][j] = ss[j];                }            }            System.out.println(solve(map));        }        in.close();    }    private static int solve(char[][] map) {        int row = map.length;        int col = map[0].length;        count = 0;        for (int i = 0; i < row; i++){            for (int j = 0; j < col; j++){                if (map[i][j] == '@'){                    dfs(map, i, j);                }            }        }        return count;    }    static int count = 0;    private static void dfs(char[][] map, int i, int j){        map[i][j] = '#';        int row = map.length;        int col = map[0].length;        count ++;        int[][] directions = {{-1,0},{1,0},{0,-1},{0,1}};        for (int d = 0; d < 4; d++){            int x = i + directions[d][0];            int y = j + directions[d][1];            if (x >= 0 && x < row && y >= 0 && y < col && map[x][y] == '.'){                dfs(map, x, y);            }        }    }}

AOJ 0118: Property Distribution

在H * W的矩形果园里有苹果、梨、蜜柑三种果树， 相邻（上下左右）的同种果树属于同一个区域，给出果园的果树分布，求总共有多少个区域。 （原题的样图中苹果为リ，梨为カ，蜜柑为ミ， 图中共10个区域）
输入：
多组数据，每组数据第一行为两个整数H，W（H <= 100, W <= 100）， H =0 且 W = 0代表输入结束。以下H行W列表示果园的果树分布， 苹果是@，梨是#， 蜜柑是*。
输出：
对于每组数据，输出其区域的个数。

依旧很水，代码如下：

public class SolutionDay09_A0118 {    public static void main(String[] args) {        Scanner in = new Scanner(System.in);        while (true) {            int W = in.nextInt();            int H = in.nextInt();            char[][] map = new char[H][W];            if (W == 0 && H == 0)                break;            for (int i = 0; i < H; i++) {                char[] ss = in.next().trim().toCharArray();                for (int j = 0; j < W; j++) {                    map[i][j] = ss[j];                }            }            System.out.println(solve(map));        }        in.close();    }    private static int solve(char[][] map){        int row = map.length;        int col = map[0].length;        int count = 0;        for (int i = 0; i < row; i++) {            for (int j = 0; j < col; j++) {                if (map[i][j] != '.'){                    count ++;                    dfs(map, i, j, map[i][j]);                }            }        }        return count;    }    private static void dfs(char[][] map, int i, int j, char c){        map[i][j] = '.';        int row = map.length;        int col = map[0].length;        int[][] directions = {{-1,0},{1,0},{0,1},{0,-1}};        for (int d = 0; d < 4; d++){            int x = i + directions[d][0];            int y = j + directions[d][1];            if (x >= 0 && x < row && y >= 0 && y < col && map[x][y] == c){                dfs(map, x, y, c);            }        }    }}

AOJ 0033: Ball

有一个形似央视大楼（Orz）的筒，从A口可以放球，放进去的球可通过挡板DE使其掉进B裤管或C裤管里，现有带1-10标号的球按给定顺序从A口放入，问是否有一种控制挡板的策略可以使B裤管和C裤管中的球从下往上标号递增。
输入：
第一行输入数据组数N。接下来N行为N组具体数据，每组数据中有10个整数，代表球的放入顺序。
输出：
对于每组数据，若策略存在，输出YES；若不存在，输出NO
翻译来自http://blog.csdn.net/synapse7/article/details/14454885

本题有多种解法，dp求最长递减子序列。此处我们用DFS，因为每次最多判断10个球。

思路：
准备两个容器，如果左边容器能放入小球，则继续。否则，尝试放入右边那个容器，如果两个均不能放入小球，那自然而然应该返回”NO”.

鸽巢原理，两个容器中的元素总是满足单调递增，如果出现三个连续的递减元素时，那么两个容器都不能装下第三个元素，因此DFS将直接结束，否则DFS一定能遍历到i>10的情况。代码如下：

public class SolutionDay09_A0033 {    public static void main(String[] args) {        Scanner in = new Scanner(System.in);        int n = in.nextInt();        for (int i = 0; i < n; i++){            for(int j = 1; j <= 10; j++){                ball[j] = in.nextInt();            }            System.out.println(solve(ball));        }        in.close();    }    static int kase;    static int[] ball = new int[15];    static int[] l = new int[15];    static int[] r = new int[15];    private static String solve(int[] ball){        kase = 0;        dfs(1, 1, 1);        return kase == 1 ? "YES" : "NO";    }    private static void dfs(int i, int j, int k){        if (i > 10){ //终止条件            kase = 1;            return;        }        if (kase == 1) return;        if (ball[i] > l[j-1]){ //守卫条件            l[j] = ball[i];            dfs(i+1, j+1, k);        }        if (ball[i] > r[k-1]){ //守卫条件            r[k] = ball[i];            dfs(i+1, j, k+1);        }    }}

POJ 3009: Curling 2.0

扔石头，上下左右四个方向如果某一个方向紧挨着block就不能扔这个方向，否则碰到block停住，block消失，再次四个方向扔。

思路：
DFS穷尽搜索，从起点开始，向四个方向探索，碰到block时，回到上一步，且删除block。如果不幸，在某个方向后达到终点的步数超过了最小规定的步数，那么剪枝，并且在一步步返回时，进行现场还原，重新让删除的block，变回block，且换个方向继续搜索。代码如下：

public class SolutionDay09_P3009 {    public static void main(String[] args) {        Scanner in = new Scanner(System.in);        while (true) {            int w = in.nextInt();            int h = in.nextInt();            row = h;            col = w;            if (w == 0 && h == 0)                break;            int[][] board = new int[h][w];            for (int i = 0; i < h; i++) {                for (int j = 0; j < w; j++) {                    board[i][j] = in.nextInt();                }            }            System.out.println(solve(board));        }        in.close();    }    static int row, col;    static int sx, sy;    static int min_step;    static int[][] directions = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };    private static int solve(int[][] board) {        for (int i = 0; i < row; i++) {            for (int j = 0; j < col; j++) {                if (2 == board[i][j]) {                    sx = i;                    sy = j;                    // 连环跳，好技巧                    i = row;                    break;                }            }        }        board[sx][sy] = 0;        min_step = 11;        dfs(sx, sy, 0, board);        return min_step > 10 ? -1 : min_step;    }    private static void dfs(int x, int y, int step, int[][] board) {        // 超过最小步数，进行剪枝        if (step >= 10 || step > min_step) {            return;        }        for (int i = 0; i < 4; i++) {            int nx = x;            int ny = y;            // 让石头往固定的方向一直飞            while (nx >= 0 && nx < row && ny >= 0 && ny < col) {                switch (board[nx][ny]) {                case 0: {                    // keep go                    nx += directions[i][0];                    ny += directions[i][1];                }                    break;                case 3: {                    //到达终点，记录最小步数                    if (step + 1 < min_step) {                        min_step = step + 1;                    }                    //重新换个方向                    nx = -1;                }                    break;                case 1: {                    // 撞到了block                    if (!(nx - directions[i][0] == x && ny - directions[i][1] == y)) { //起点下一个撞击方向不能紧挨着block                        board[nx][ny] = 0;                          dfs(nx - directions[i][0], ny - directions[i][1], step + 1, board);                        //还原状态                        board[nx][ny] = 1;                    }                    //重新选择一个方向                    nx = -1;                }                    break;                default:                    break;                }            }        }    }}

典型的回溯+剪枝算法，得空得强化整理下，这一章节暂告一段落。