递归设计

递归设计的核心

递归设计的核心在于两点：

1. 递归停止条件的判断
2. 递归中对于问题的普适情况的解决方案

抓住这两点才能巧妙的解决问题。

递归问题的经典案例：

1. 迷宫问题
2. 汉诺塔问题

迷宫问题

假设有如下迷宫，其中1代表通路，0代表短路，请找出走出迷宫的道路。

1110110001111
1011101111001
0000101010100
1110111010111
1010000111001
1011111101111
1000000000000
1111111111111

解决问题的思路：

1. 终止条件：
   如果所在格子是迷宫的最右下角，且该格子数值为1，那么迷宫走通，递归结束。

2. 递归内容
   如果所在格子是迷宫的第m行，第n列，则进行如下判断

a. 如果该格子是在迷宫矩阵中，且数值为1，那么我们将齐标记为以判定格子（改写数值为3）
b. 然后分别判断该格子的上下左右相邻格子是否为通路
c. 如果相邻格子中有一个递归判断是通路，则当前格子在走出迷宫的道路上（改写数值为7）
d. 向上层返回对格子是否在通路上的判断

代码展示
Maze.java

package recurrence.maze;

public class Maze {

    public static int UNBLOCKED = 1;

    public static int TRIED = 3;

    public static int PATH = 7;

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

    public static boolean traverse(int row, int column) {
        boolean isValidPath = false;

        if (valid(row, column)) {
            MAZE[row][column] = TRIED;

            if (row == MAZE.length - 1 && column == MAZE[0].length - 1) {
                isValidPath = true;
            } else {
                isValidPath = traverse(row + 1, column); // down
                if (!isValidPath) {
                    isValidPath = traverse(row, column + 1); // right
                }
                if (!isValidPath) {
                    isValidPath = traverse(row - 1, column); // up
                }
                if (!isValidPath) {
                    isValidPath = traverse(row, column - 1); // left
                }
            }

            if (isValidPath) {
                MAZE[row][column] = PATH;
            }
        }

        return isValidPath;
    }

    public static boolean valid(int row, int column) {
        boolean result = false;

        if (row >= 0 && row < MAZE.length && column >= 0 && column < MAZE[row].length) {
            if (MAZE[row][column] == UNBLOCKED) {
                result = true;
            }
        }

        return result;
    }

    public static void printMaze() {
        for (int[] row : Maze.MAZE) {
            for (int column : row) {
                System.out.print("" + column);
            }
            System.out.println();
        }
    }
}

MazeSearch.java

public class MazeSearch {

    public static void main(String[] args) {
        System.out.println("Before search");
        Maze.printMaze();

        if (Maze.traverse(0, 0)) {
            System.out.println("\nThere is a path.\n");
        } else {
            System.out.println("\nNo valid path.\n");
        }

        System.out.println("After search");
        Maze.printMaze();
    }

}

最后结果

7770110001111
3077707771001
0000707070300
7770777070333
7070000773003
7077777703333
7000000000000
7777777777777

汉诺塔问题

汉诺塔问题所解决的问题模型是：
有三根柱子1柱子、2柱子和3柱子，n个盘子按照从小到大的顺序依次叠放在一根柱子上，要求在不能将大盘子放置在小盘子的规则下，将n个盘子移至另一个柱子上，从小到大按序叠放好。

解决思路：

1. 递归停止的判断条件为将一个盘子从起点柱子直接移至终点柱子。
2. 递归内容：如要完成n个盘子从起点柱子1移至终点柱子3需要
   a. 将n-1个盘子从柱子1移至柱子2
   b. 将最大的盘子从柱子1移至柱子3
   c. 将n-1个盘子从柱子2移至柱子3
   其中a，b又创造了新的移动问题，即移动n-1个盘子从某一起点柱至终点柱。

public class Hanoi {

    public static void main(String[] args) {
        int n = 4;
        System.out.println("Begin to resolve Hanoi problem for [" + n + "] disks.");
        Hanoi.hanoiMove(n, 1, 3, 2);
    }

    public static void hanoiMove(int n, int start, int end, int temp) {
        if (n == 1) {
            moveOneDisk(start, end);
        } else {
            hanoiMove(n - 1, start, temp, end);
            moveOneDisk(start, end);
            hanoiMove(n - 1, temp, end, start);
        }
    }

    public static void moveOneDisk(int start, int end) {
        System.out.println("Move disk from post [" + start + "] to post [" + end + "]");
    }
}

输出结果

Begin to resolve Hanoi problem for [4] disks.
Move disk from post [1] to post [2]
Move disk from post [1] to post [3]
Move disk from post [2] to post [3]
Move disk from post [1] to post [2]
Move disk from post [3] to post [1]
Move disk from post [3] to post [2]
Move disk from post [1] to post [2]
Move disk from post [1] to post [3]
Move disk from post [2] to post [3]
Move disk from post [2] to post [1]
Move disk from post [3] to post [1]
Move disk from post [2] to post [3]
Move disk from post [1] to post [2]
Move disk from post [1] to post [3]
Move disk from post [2] to post [3]