LeetCode 46 Permutations(全排列问题)

题目链接:https://leetcode.com/problems/permutations/?tab=Description

Problem:给出一个数组(数组中的元素均不相同),求出这个数组能够产生的所有全排列

采用递归算法,传入参数

List<List<Integer>> list, List<Integer> tempList, int[] nums, boolean[] used

  其中list保存最终结果

  tempList保存其中一个全排列

  nums为最初的数组

  used随着计算不断更新,保存数组中元素是否已经使用过

参考代码:

package leetcode_50;

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

/***
 *
 * @author pengfei_zheng
 * 给定数组元素均不相同,求出所有全排列
 */
public class Solution46 {
    public static List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> list = new ArrayList<>();
        prem(list,new ArrayList<>(),nums,new boolean[nums.length]);
        return list;
    }

    private static void prem(List<List<Integer>> list, List<Integer> tempList, int[] nums, boolean[] used) {
        if(tempList.size()==nums.length){
            list.add(new ArrayList<>(tempList));
        }
        else{
            for(int i = 0; i < nums.length; i++){
                if(used[i] || i>0 && nums[i]==nums[i-1] && !used[i-1]) continue;
                used[i]=true;
                tempList.add(nums[i]);
                prem(list,tempList,nums,used);
                used[i]=false;
                tempList.remove(tempList.size()-1);
            }
        }
    }
    public static void main(String[]args){
        int []nums={1,2,3};
        List<List<Integer>> list = permute(nums);
        for(List<Integer> item:list){
            System.out.println(item);
        }
    }
}
时间: 2024-10-13 17:24:58

LeetCode 46 Permutations(全排列问题)的相关文章

LeetCode 46 Permutations (全排列)

Given a collection of distinct numbers, return all possible permutations. For example, [1,2,3] have the following permutations: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ] 题目链接:https://leetcode.com/problems/permutations/ 题目大意:求全排列 题目分析:求

DFS解法的两道题 Leetcode 46 Permutations &amp; Leetcode 78 Subset

Leetcode 78 Subset Given a set of distinct integers, S, return all possible subsets. Note: Elements in a subset must be in non-descending order. The solution set must not contain duplicate subsets. For example,If S = [1,2,3], a solution is: [ [3], [1

leetCode 46. Permutations 回溯问题 | Medium

46. Permutations(全排列问题--回溯问题经典) Given a collection of distinct numbers, return all possible permutations. For example,[1,2,3] have the following permutations: [   [1,2,3],   [1,3,2],   [2,1,3],   [2,3,1],   [3,1,2],   [3,2,1] ] 题目大意:求一个序列的全排列. 思路:做排列

[Lintcode]15. Permutations/[Leetcode]46. Permutations

15. Permutations/46. Permutations 本题难度: Medium Topic: Search & Recursion Description Given a list of numbers, return all possible permutations. Example Example 1: Input: [1] Output: [ [1]] Example 2: Input: [1,2,3] Output: [ [1,2,3], [1,3,2], [2,1,3]

46. Permutations (全排列)

Given a collection of distinct numbers, return all possible permutations. For example,[1,2,3] have the following permutations: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ] 运用递归. 1234为例子 for  i in 1234: 1  +  234(的全排列) 2  +  134(的全排列) 3  +

leetcode 46 Permutations Python 实现(回溯算法)

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]] 回溯算法自己的一个思路如下:需要保留数字使用情况,my_nums增加和删除元素等操作 1 class Solution: 2 def permute(self, nums: Li

46 Permutations(全排列Medium)

题目意思:全排列 思路:其实看这题目意思,是不太希望用递归的,不过还是用了递归,非递归的以后再搞吧 ps:vector这玩意不能随便返回,开始递归方法用vector,直接到500ms,换成void,到12ms 1 class Solution { 2 public: 3 vector<vector<int>> permute(vector<int>& nums) { 4 vector<vector<int> >ans; 5 permute

LeetCode 46. Permutations

原题 Given a collection of distinct numbers, return all possible permutations. For example,[1,2,3] have the following permutations: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ] 解题思路 递归:递归的方法,创建一个visit判断此值是否已经添加过,每一层不断地循环,加入没有被访问的元素,直到最后结果的长

leetcode 46 Permutations ----- java

Given a collection of distinct numbers, return all possible permutations. For example,[1,2,3] have the following permutations: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ] 给定一个数组,求所有的排列组合. 做出这道题很简单,主要是要比较快的速度,第一次做,耗时5ms,比较慢,主要就是用递归,每次向arr