LeetCode——深度优先搜索框架（排列、组合问题应用）

框架思想：首先深度优先搜索 头脑中一定要有树的概念。一层层往下递归搜索。在搜索的过程当中要使用index记录层级索引。每递归一层 index + 1

递归函数中首先要判断边界条件，边界条件代表一次搜索完成，可以获取到搜索答案。

说白了，深度优先搜索就是通过递归（自顶向下）进行暴力搜索，在搜索的过程当中保留满足符合条件的结果

1、全排列问题
给定一个没有重复数字的序列，返回其所有可能的全排列。

输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

private List<List<Integer>> ans = new ArrayList<>();

    private int[] paths = new int[100]; // 用来记录路径
    private boolean[] v = new boolean[100]; // 用来记录该数字是否在上一次出现过

    private void robot(int index, int[] nums) {
        if (index >= nums.length) {
            // return answer
            List<Integer> temp = new ArrayList<>();
            for(int i = 0; i < nums.length; i++) {
                temp.add(nums[paths[i]]);
            }
            ans.add(temp);
            return;
        }
        // for循环代表下一层搜索的范围
        for(int i = 0; i < nums.length; i++) {
            if (v[i] == false) {
                paths[index] = i;
                v[i] = true;
                robot(index + 1, nums);
                v[i] = false;
            }
        }

    }


    public List<List<Integer>> permute(int[] nums) {
        ans.clear();
        robot(0, nums);
        return ans;
    }

2、组合问题
给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

private List<List<Integer>> ans = new ArrayList<>();
    private int[] paths = new int[100];
    private int K;

    private void robot(int index, int n, int k) {

        if (k == -1) {
            // return answer
            List<Integer> temp = new ArrayList<>();
            for(int i = K - 1; i >= 0; i--) {
                temp.add(paths[i]);
            }
            ans.add(temp);
            return;
        }

        for(int i = index; i <= n; i++) {
            paths[k] = i;
            robot(i + 1, n, k - 1);
        }

    }


    public List<List<Integer>> combine(int n, int k) {
        K = k;
        robot(1, n, k - 1);
        return ans;
    }