递归的通用代码结构剖析【待持续补充】

前言：

递归调用一般有下面三个部分的结构： 

第一部分：变量加工和终止判断逻辑

终止条件，如：

if(){
    return (void/int/boolean)
}
引用变量加工，如dp[i][j] = true;

说明：

1、该处代码逻辑递归层次越上方的越先执行到，即每次执行前先判断或者加工的代码逻辑。
2、如果递归在for循环里面进行调用，终止条件为：最后一次调用时不再走到递归调用代码，可能场景：

        1）、for循环最后一次递归时循环0次；

        2）、for循环里面增加了if条件，只有满足if条件的才会进行递归调用，即最深一次递归调用时所有循环都不满足if条件，使代码顺利终止进入回溯阶段。
下面数独示例代码属于第二类场景。
 

第二部分：递归调用处

dfs(参数：如果是引用类型则需要注意是否需要回溯);

说明：

难点在于参数列表的定义。让相邻层次之间产生返回值的联系或者引用变量的联系（逐层加工）

第三部分：引用变量回溯

如dp[i][j] = false;（呼应前面第一部分的加工处理）

说明：

该处代码执行顺序：该处代码逻辑递归层次越往下或者说越深的越先执行到，即一层一层往上进行回溯

递归失败后回溯逻辑的作用：即回到上层前恢复所有的变动，保证不影响上层的后续尝试。

#真实案例：数独

题目：数独（Sudoku）是一款大众喜爱的数字逻辑游戏。玩家需要根据9X9盘面上的已知数字，推算出所有剩余空格的数字，并且满足每一行、每一列、每一个3X3粗线宫内的数字均含1-9，并且不重复。

数据范围：输入一个 9*9 的矩阵
输入描述：包含已知数字的9X9盘面数组[空缺位以数字0表示]

输出描述：
完整的9X9盘面数组

示例1
输入：
0 9 2 4 8 1 7 6 3
4 1 3 7 6 2 9 8 5
8 6 7 3 5 9 4 1 2
6 2 4 1 9 5 3 7 8
7 5 9 8 4 3 1 2 6
1 3 8 6 2 7 5 9 4
2 7 1 5 3 8 6 4 9
3 8 6 9 1 4 2 5 7
0 4 5 2 7 6 8 3 1

输出：
5 9 2 4 8 1 7 6 3
4 1 3 7 6 2 9 8 5
8 6 7 3 5 9 4 1 2
6 2 4 1 9 5 3 7 8
7 5 9 8 4 3 1 2 6
1 3 8 6 2 7 5 9 4
2 7 1 5 3 8 6 4 9
3 8 6 9 1 4 2 5 7
9 4 5 2 7 6 8 3 1


// 注意类名必须为 Main, 不要有任何 package xxx 信息
// 递归:每次递归到最深处时，当前所有层的和为一个疑似解，每个层次的结果依赖于下一个层次的结果（比如：下一次递归结果为真，本次才为真，否则为假，那即是说往下的每一层递归都必须是真，才能得到可行解，只要存在一个假即非可行解）
// 递归的结构：
// 处理和判断逻辑
// 递归调用处
// 递归失败后回溯逻辑
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int[][] sudu = new int[9][9];
            for (int i = 0; i < 9; i++) {
                for (int j = 0; j < 9; j++) {
                    sudu[i][j] = in.nextInt();
                }
                in.nextLine();
            }
            dfs(sudu);
            for (int i = 0; i < 9; i++) {
                for (int j = 0; j < 9; j++) {
                    System.out.print(sudu[i][j] + " ");
                }
                System.out.println();
            }

        }
    }
    public static boolean dfs(int[][] sudu) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                // 如果仍然存在0，则是false;
                if (sudu[i][j] == 0) {
                    for (int k = 1; k <= 9; k++) {
                        sudu[i][j] = k;
                        boolean b = ifValid(sudu, i, j, k);
                        if (b && dfs(sudu)) {//如果满足规则且递归也满足规则，则返回可行解，否则走下方回溯逻辑
                            return true;
                        }
                        sudu[i][j] = 0;
                    }
                    return false;
                }
            }
        }
        return true;
    }
    public static boolean ifValid(int[][] sudu, int i, int j, int k) {

        for (int a = i, b = 0; b < 9; b++) {
            if (b == j) {
                continue;
            }
            if (sudu[a][b] == k) {
                return false;

            }

        }
        for (int a = 0, b = j; a < 9; a++) {
            if (a == i) {
                continue;
            }
            if (sudu[a][b] == k) {
                return false;

            }
        }
        for (int a = i / 3 * 3; a < i / 3 * 3 + 3; a++) {
            for (int b = j / 3 * 3; b < j / 3 * 3 + 3; b++) {
                if (a == i && b == j) {
                    continue;
                }
                if (sudu[a][b] == k) {
                    return false;

                }

            }
        }
        return true;
    }
}