[leetcode] 全排列 (提供一个小技巧, 带Debug日志, 方便理解代码执行过程)

使用回溯算法解决全排列问题

leetcode 题目链接:

https://leetcode-cn.com/problems/permutations/

代码

带执行流程日志的代码

public class Solution {
    List<List<Integer>> ans;
    int[] nums;
    boolean[] used;

    public List<List<Integer>> permute(int[] nums) {
        ans = new LinkedList<>();
        if (nums.length == 0) {
            return ans;
        }
        this.nums = nums;
        used = new boolean[nums.length];
        LinkedList<Integer> list = new LinkedList<>();
        dfs(0, list);
        return ans;
    }

    int count = 0;

    void dfs(int idx, LinkedList<Integer> list) {
        printIndent(count++);
        System.out.println("dfs(idx = " + idx + ", list = " + list + ")");
        // --- 满足结束条件 ---
        if (idx >= nums.length) {
            ans.add(new LinkedList<>(list));

            printIndent(--count);
            System.out.println("找到一个排列, return");
            return;
        }

        for (int i = 0; i < nums.length; i++) {
            // 找到选择列表
            if (!used[i]) {
                // --- 做选择 start ---
                list.add(nums[i]);
                used[i] = true;
                // --- 做选择 end ---
                printIndent(count - 1);
                System.out.println("当前for-start: idx=" + idx + ", i=" + i + ", list=" + list + ", used=" + Arrays.toString(used));
                dfs(idx + 1, list);
                // --- 撤销选择 start ---
                // 如果使用的是Java语言, 此处是坑点
                // 此处代码也可以替换为 list.remove(list.size() - 1);
                list.remove(new Integer(nums[i]));
                used[i] = false;
                // --- 撤销选择 end ---
                printIndent(count - 1);
                System.out.println("当前for-end: idx=" + idx + ", i=" + i + ", list=" + list + ", used=" + Arrays.toString(used));
            } else {
                printIndent(count - 1);
                System.out.println("idx=" + idx + ", i=" + i + ", 已经访问过数组nums的" + i + "位置");
            }
        }
        printIndent(--count);
        System.out.println("结束循环, return");
        return;
    }

    void printIndent(int n) {
        for (int i = 0; i < n; i++) {
            System.out.print("--");
        }
    }

    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println(sol.permute(new int[]{1, 2, 3}));
    }
}

执行过程的日志

dfs(idx = 0, list = [])
当前for-start: idx=0, i=0, list=[1], used=[true, false, false]
--dfs(idx = 1, list = [1])
--idx=1, i=0, 已经访问过数组nums的0位置
--当前for-start: idx=1, i=1, list=[1, 2], used=[true, true, false]
----dfs(idx = 2, list = [1, 2])
----idx=2, i=0, 已经访问过数组nums的0位置
----idx=2, i=1, 已经访问过数组nums的1位置
----当前for-start: idx=2, i=2, list=[1, 2, 3], used=[true, true, true]
------dfs(idx = 3, list = [1, 2, 3])
------找到一个排列, return
----当前for-end: idx=2, i=2, list=[1, 2], used=[true, true, false]
----循环结束, 当前函数调用结束, return
--当前for-end: idx=1, i=1, list=[1], used=[true, false, false]
--当前for-start: idx=1, i=2, list=[1, 3], used=[true, false, true]
----dfs(idx = 2, list = [1, 3])
----idx=2, i=0, 已经访问过数组nums的0位置
----当前for-start: idx=2, i=1, list=[1, 3, 2], used=[true, true, true]
------dfs(idx = 3, list = [1, 3, 2])
------找到一个排列, return
----当前for-end: idx=2, i=1, list=[1, 3], used=[true, false, true]
----idx=2, i=2, 已经访问过数组nums的2位置
----循环结束, 当前函数调用结束, return
--当前for-end: idx=1, i=2, list=[1], used=[true, false, false]
--循环结束, 当前函数调用结束, return
当前for-end: idx=0, i=0, list=[], used=[false, false, false]
当前for-start: idx=0, i=1, list=[2], used=[false, true, false]
--dfs(idx = 1, list = [2])
--当前for-start: idx=1, i=0, list=[2, 1], used=[true, true, false]
----dfs(idx = 2, list = [2, 1])
----idx=2, i=0, 已经访问过数组nums的0位置
----idx=2, i=1, 已经访问过数组nums的1位置
----当前for-start: idx=2, i=2, list=[2, 1, 3], used=[true, true, true]
------dfs(idx = 3, list = [2, 1, 3])
------找到一个排列, return
----当前for-end: idx=2, i=2, list=[2, 1], used=[true, true, false]
----循环结束, 当前函数调用结束, return
--当前for-end: idx=1, i=0, list=[2], used=[false, true, false]
--idx=1, i=1, 已经访问过数组nums的1位置
--当前for-start: idx=1, i=2, list=[2, 3], used=[false, true, true]
----dfs(idx = 2, list = [2, 3])
----当前for-start: idx=2, i=0, list=[2, 3, 1], used=[true, true, true]
------dfs(idx = 3, list = [2, 3, 1])
------找到一个排列, return
----当前for-end: idx=2, i=0, list=[2, 3], used=[false, true, true]
----idx=2, i=1, 已经访问过数组nums的1位置
----idx=2, i=2, 已经访问过数组nums的2位置
----循环结束, 当前函数调用结束, return
--当前for-end: idx=1, i=2, list=[2], used=[false, true, false]
--循环结束, 当前函数调用结束, return
当前for-end: idx=0, i=1, list=[], used=[false, false, false]
当前for-start: idx=0, i=2, list=[3], used=[false, false, true]
--dfs(idx = 1, list = [3])
--当前for-start: idx=1, i=0, list=[3, 1], used=[true, false, true]
----dfs(idx = 2, list = [3, 1])
----idx=2, i=0, 已经访问过数组nums的0位置
----当前for-start: idx=2, i=1, list=[3, 1, 2], used=[true, true, true]
------dfs(idx = 3, list = [3, 1, 2])
------找到一个排列, return
----当前for-end: idx=2, i=1, list=[3, 1], used=[true, false, true]
----idx=2, i=2, 已经访问过数组nums的2位置
----循环结束, 当前函数调用结束, return
--当前for-end: idx=1, i=0, list=[3], used=[false, false, true]
--当前for-start: idx=1, i=1, list=[3, 2], used=[false, true, true]
----dfs(idx = 2, list = [3, 2])
----当前for-start: idx=2, i=0, list=[3, 2, 1], used=[true, true, true]
------dfs(idx = 3, list = [3, 2, 1])
------找到一个排列, return
----当前for-end: idx=2, i=0, list=[3, 2], used=[false, true, true]
----idx=2, i=1, 已经访问过数组nums的1位置
----idx=2, i=2, 已经访问过数组nums的2位置
----循环结束, 当前函数调用结束, return
--当前for-end: idx=1, i=1, list=[3], used=[false, false, true]
--idx=1, i=2, 已经访问过数组nums的2位置
--循环结束, 当前函数调用结束, return
当前for-end: idx=0, i=2, list=[], used=[false, false, false]
循环结束, 当前函数调用结束, return

回溯代码的框架

以伪代码的形式给出

result = []
def backtrack(路径, 选择列表):
	if 满足结束条件:
		result.add(路径)
		return
	for 选择 in 选择列表:
		做选择
		backtrack(路径, 选择列表)
		撤销选择

此处参考labuladong