学习and交流

题目

Given a collection of distinct integers, return all possible permutations.

Example:

Input: [1,2,3]
Output:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
即给出一堆不重复的整数，计算其所有可能的排列组合。

image.png

将问题转化为递归问题：
（1）明确问题目标，即需求全排列f(digits)：代表输入数字的全排列
（2）递归表达式
f(digits[n]) = 选取任意一个数 + f(digits[n] - 选取的数字)
（3）递归结束条件
选取到最后一个数字了，无新的数字可选择，自然结束。
参考解析代码：

import org.testng.collections.Lists;

import java.util.ArrayList;
import java.util.List;

public class P46Permutations {


    public static void main(String[] args) {

        P46Permutations p46Permutations = new P46Permutations();
        List<List<Integer>> permute = p46Permutations.permute(new int[]{1, 2, 3});
        permute.forEach(System.out::println);
    }

    public List<List<Integer>> permute(int[] nums) {
        if (nums == null || nums.length == 0) {
            return new ArrayList<>();
        }
        boolean[] isVisit = new boolean[nums.length];
        findPermutations(nums, 0, new ArrayList<>(), isVisit);
        return finalResults;
    }

    List<List<Integer>> finalResults = Lists.newArrayList();
    /**
     *
     * @param nums : 即待递归的原始输入
     * @param index： 代表目前已经处理好多个数字的排列
     * @param indexBeforeResult： 代表已经处理好index个数字的全排列，现在将处理index+1个数字的加入，构成index+1个大小的全排列
     */
    public void findPermutations(int[] nums, int index, List<Integer> indexBeforeResult, boolean[] isVisit) {

        if (index == nums.length) {
            //System.out.println(indexBeforeResult);
            finalResults.add(new ArrayList<>(indexBeforeResult));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            // 当前处理的字符尚未访问过
            if (!isVisit[i]) {
                indexBeforeResult.add(nums[i]);
                isVisit[i] = true;
                findPermutations(nums, index + 1, indexBeforeResult, isVisit);
                // 回溯回去，让这个数字可以后续被访问，因此赋值为false
                isVisit[i] = false;
                indexBeforeResult.remove(indexBeforeResult.size() - 1);
            }
        }

    }
}

image.png