Leetcode47. 全排列 II

Leetcode47. 全排列 II

题目：
给定一个可包含重复数字的序列，返回所有不重复的全排列。

示例:

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

题解：
回溯

java代码：

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

    }


    public static void dfs2(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++) {
            // 剪枝条件：i > 0 是为了保证 nums[i - 1] 有意义
            // 写 !used[i - 1] 是因为 nums[i - 1] 在深度优先遍历的过程中刚刚被撤销选择
            if ((i > 0 && !used[i - 1] && nums[i] == nums[i - 1]) || (used[i])) continue;

            path.add(nums[i]);
            used[i] = true;
            dfs2(nums, length, depth + 1, used, path, list);
            used[i] = false;
            path.remove(path.size() - 1);
        }
    }

scala代码：

 /**
    *
    * @param nums
    * @return
    */
  def permuteUnique(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 sortedNums = nums.sorted
      val path = new ArrayBuffer[Int]()
      val used = new Array[Boolean](len)
      dfs(sortedNums, 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: ArrayBuffer[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)) {
      breakable {
        // 剪枝条件：i > 0 是为了保证 nums[i - 1] 有意义
        // 写 !used[i - 1] 是因为 nums[i - 1] 在深度优先遍历的过程中刚刚被撤销选择
        if ((i > 0 &&  !used(i-1) && nums(i) == nums(i - 1)) || (used(i)) ) break()
        path.append(nums(i))
        used(i) = true
        dfs(nums, depth + 1, len, path, used, res)
        used(i) = false
        path.remove(path.length - 1)
      }
    }
  }