46 Permutations

最新推荐文章于 2019-05-06 15:09:00 发布

dongbeier

最新推荐文章于 2019-05-06 15:09:00 发布

阅读量358

点赞数

CC 4.0 BY-SA版权

分类专栏： MicroSoft Linkedin LeetCode

本文链接：https://blog.csdn.net/dongbeier/article/details/80276133

LeetCode 同时被 3 个专栏收录

146 篇文章

订阅专栏

MicroSoft

85 篇文章

订阅专栏

50 篇文章

订阅专栏

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

函数 next_permutation()

/**
 *
 * @author dongb
 * Permutations
 * rebuild next_purmation()
 * TC O(n!), SC O(1)
 */
public class Solution {
    public static List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        
        do {
            ArrayList<Integer> first = new ArrayList<>();
            for (int i: nums) {
                first.add(i);
            }
            result.add(first);
        } while (nextPermutation(nums, 0, nums.length));
        
        return result;
    }
    
    private static boolean nextPermutation(int[] nums, int begin, int end) {
        // From right to left, find the first digit(partitionNumber) 
        // which violates the increase trend
        int p = end - 2;
        while (p > -1 && nums[p] >= nums[p + 1]) --p;

        // If not found, which means current sequence is already the largest
        // permutation, then rearrange to the first permutation and return false
        if(p == -1) {
            reverse(nums, begin, end);
            return false;
        }

        // From right to left, find the first digit which is greater
        // than the partition number, call it changeNumber
        int c = end - 1;
        while (c > 0 && nums[c] <= nums[p]) --c;

        // Swap the partitionNumber and changeNumber
        swap(nums, p, c);
        // Reverse all the digits on the right of partitionNumber
        reverse(nums, p+1, end);
        return true;
    }
    private static void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
    private static void reverse(int[] nums, int begin, int end) {
        end--;
        while (begin < end) {
            swap(nums, begin++, end--);
        }
    }
    
    public static void main(String args[]) {
        Scanner cin = new Scanner(System.in);
        int[] nums = new int[3];
        for (int i = 0; i < nums.length; i++) {
            nums[i] = cin.nextInt();
        }
        List<List<Integer>> answer = permute(nums);
        System.out.println(answer);
    }
}

本题是求路径本身，求所有解，函数参数需要标记当前走到了哪步，还需要中间结果的引用，最终结果的引用。扩展节点，每次从左到右，选一个没有出现过的元素。本题不需要判重，因为状态装换图是一颗有层次的树。收敛条件是当前走到了最后一个元素

/**
 *
 * @author dongb
 * Permutations
 * Recursion, DSF, incremental construction
 * TC O(n!), SC O(n)
 */
public class Solution {
    public List<List<Integer>> permute(int[] nums) {
        Arrays.sort(nums);
        
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        boolean[] selected = new boolean[nums.length];
        dfs(nums, selected, path, result);
        return result;
    }
    
    private void dfs(int[] nums, boolean[] selected, List<Integer> path, List<List<Integer>> result) {
        if (path.size() == nums.length) {   // convergence condition
            result.add(new ArrayList<Integer>(path));
            return;
        }
        
        // expand condition
        for (int i = 0; i < nums.length; i++) {
            if (selected[i]) {
                continue;
            }
            
            selected[i] = true;
            path.add(nums[i]);
            dfs(nums, selected, path, result);
            selected[i] = false;
            path.remove(path.size() - 1);
        }
    }
}