Leetcode46. 全排列

Leetcode46. 全排列

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

示例:

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

题解：
回溯

java代码：

 public static List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> list = new ArrayList<>();
        if (nums.length == 0) return list;
        boolean[] used = new boolean[nums.length];
        ArrayList<Integer> path = new ArrayList<>();
        dfs(nums, nums.length, 0, used, path, list);
        return list;

    }

    public static void dfs(int[] nums, int length, int depth, boolean[] used, ArrayList<Integer> path, List<List<Integer>> list) {

        if (depth == length) {
            list.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < length; i++) {
            if (!used[i]) {
                path.add(nums[i]);
                used[i] = true;
                dfs(nums, length, depth + 1, used, path, list);
                used[i] = false;
                path.remove(path.size() - 1);
            }
        }
    }

scala代码：

 /**
    *
    * @param nums
    * @return
    */

  def permute(nums: Array[Int]): List[List[Int]] = {

    val len = nums.length
    // 使用一个动态数组保存所有可能的全排列
    val res = new mutable.ArrayBuffer[mutable.ArrayBuffer[Int]]()

    if (len == 0) res.map(_.toList).toList
    else {
      val path = new ArrayBuffer[Int]()
      val used = new Array[Boolean](len)
      dfs(nums, 0, len, path, used, res)
      res.map(_.toList).toList
    }
  }

  def dfs(nums: Array[Int], depth: Int, len: Int, path: ArrayBuffer[Int], used: Array[Boolean], res: mutable.ArrayBuffer[mutable.ArrayBuffer[Int]]): Unit = {

    var flag = true
    if (depth == len) {
      val s = new ArrayBuffer[Int]
      s.++=(path)
      res.append(s)
      flag = false
    }

    for (i <- 0 until len; if (flag)) {
      if (!used(i)) {
        path.append(nums(i))
        used(i) = true
        dfs(nums, depth + 1, len, path, used, res)
        // 注意：这里是状态重置，是从深层结点回到浅层结点的过程，代码在形式上和递归之前是对称的
        used(i) = false
        path.remove(path.length - 1)
      }
    }
  }