0046. Permutations (M)

Permutations (M)

题目

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]
]

---

题意

输出给定数组的全排列。

思路

1. 排列组合常用回溯法：
   • 使用hash：用一张hash表记录对应下标的数是否已被使用，每次操作都先往已有序列后插入一个未被使用的数，更新hash，递归，再移除改数，更新hash。
   • 不使用hash：对于结果序列中的每一个位置，它可能存放的数为nums从当前位置到最后一个位置中的任意一个数(因为各异)，所以每次操作都从这些数中选一个放到当前空位，再对右边的空格进行递归操作。
2. 结合 31. Next Permutation 来实现全排列。
3. 通过在长度为n的已有序列中的(n+1)个间隔位置插入数，重复操作来实现全排列。

---

代码实现

Java

回溯法hash

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        permute(nums, new boolean[nums.length], new ArrayList<>(), ans);
        return ans;
    }

    // hash用来标记对应下标是否已经被使用过
    private void permute(int[] nums, boolean[] hash, List<Integer> list, List<List<Integer>> ans) {
        if (list.size() == nums.length) {
            ans.add(new ArrayList<>(list));
            return;
        }
        
        for (int i = 0; i < nums.length; i++) {
            if (!hash[i]) {
                list.add(nums[i]);
                hash[i] = true;
                permute(nums, hash, list, ans);
                list.remove(list.size() - 1);
                hash[i] = false;
            }
        }
    }
}

回溯法无hash

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        permute(nums, 0, ans);
        return ans;
    }

    private void permute(int[] nums, int index, List<List<Integer>> ans) {
        if (index == nums.length) {
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < nums.length; i++) {
                list.add(nums[i]);
            }
            ans.add(list);
            return;
        }

        // 每次更新当前位置处的数字
        for (int i = index; i < nums.length; i++) {
            swap(nums, index, i);
            permute(nums, index + 1, ans);
            swap(nums, index, i);
        }
    }

    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

nextPermutation

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        Arrays.sort(nums);
        while (true) {
            List<Integer> list = new ArrayList<>();
            for (int i = 0; i < nums.length; i++) {
                list.add(nums[i]);
            }
            ans.add(list);
            if (hasNextPermutation(nums)) {
                nextPermutation(nums);
            } else {
                break;
            }
        }
        return ans;
    }

    // 根据当前排列计算下一个排列 
    private void nextPermutation(int[] nums) {
        int i = nums.length - 2;
        while (i >= 0 &&  nums[i] >= nums[i + 1]) {
            i--;
        }
        int j = nums.length - 1;
        while (nums[j] <= nums[i]) {
            j--;
        }
        swap(nums, i, j);
        reverse(nums, i + 1, nums.length - 1);
    }

    // 判断是否存在下一个排列，即判断是否已经是完全逆序数列
    private boolean hasNextPermutation(int[] nums) {
        int i = nums.length - 2;
        while (i >= 0 &&  nums[i] >= nums[i + 1]) {
            i--;
        }
        return i >=0;
    }

    private void reverse(int[] nums, int left, int right) {
        while (left < right) {
            swap(nums, left++, right--);
        }
    }

    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

插入法

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        ans.add(new ArrayList<>());
        // 第一重循环确定每次要插入的数的下标
        for (int i = 0; i < nums.length; i++) {
            int size = ans.size();
            // 第二重循环控制更新所有待插入数列
            for (int j = 0; j < size; j++) {
                List<Integer> cur = ans.remove(0);
                // 第三重循环选择在cur.size()+1个间隔位置处插入nums[i]
                for (int k = 0; k <= cur.size(); k++) {
                    List<Integer> temp = new ArrayList<>(cur);
                    temp.add(k, nums[i]);
                    ans.add(temp);
                }
            }
        }
        return ans;
    }
}

JavaScript

回溯法hash

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var permute = function (nums) {
  let lists = []
  dfs(nums, 0, [], lists, new Set())
  return lists
}

let dfs = function (nums, index, list, lists, used) {
  if (index === nums.length) {
    lists.push([...list])
    return
  }

  for (let i = 0; i < nums.length; i++) {
    if (!used.has(i)) {
      used.add(i)
      list.push(nums[i])
      dfs(nums, index + 1, list, lists, used)
      list.pop()
      used.delete(i)
    }
  }
}

回溯法无hash

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var permute = function (nums) {
  let lists = []
  dfs(nums, 0, lists)
  return lists
}

let dfs = function (nums, index, lists) {
  if (index === nums.length) {
    lists.push([...nums])
    return
  }

  for (let i = index; i < nums.length; i++) {
    [nums[index], nums[i]] = [nums[i], nums[index]]
    dfs(nums, index + 1, lists);
    [nums[index], nums[i]] = [nums[i], nums[index]]
  }
}

nextPermutation

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var permute = function (nums) {
  let lists = []
  nums.sort((a, b) => a - b)

  lists.push([...nums])
  while (nextPos(nums) >= 0) {
    lists.push([...nextPermutation(nums)])
  }

  return lists
}

let nextPos = function (nums) {
  let i = nums.length - 2
  while (i >= 0 && nums[i] >= nums[i + 1]) {
    i--
  }
  return i
}

let nextPermutation = function (nums) {
  let index = nextPos(nums)
  for (let i = nums.length - 1; i > index; i--) {
    if (nums[i] > nums[index]) {
      [nums[i], nums[index]] = [nums[index], nums[i]]
      break
    }
  }
  let left = index + 1, right = nums.length - 1
  while (left < right) {
    [nums[left++], nums[right--]] = [nums[right], nums[left]]
  }
  return nums
}

插入法

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var permute = function (nums) {
  let lists = [[]]

  for (let i = 0; i < nums.length; i++) {
    let size = lists.length
    for (let j = 0; j < size; j++) {
      let array = lists.shift()
      for (let k = 0; k <= array.length; k++) {
        let copy = [...array]
        copy.splice(k, 0, nums[i])
        lists.push(copy)
      }
    }
  }

  return lists
}