leetcode 46 和47 . 全排列,两种生成树的方案来解决全排列问题

最新推荐文章于 2021-08-08 17:57:31 发布
最新推荐文章于 2021-08-08 17:57:31 发布
阅读量275 收藏
点赞数
分类专栏： python 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Julse/article/details/119120838
版权

题目来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems
https://www.nowcoder.com/activity/oj
特别鸣谢：来自夸夸群的 醉笑陪公看落花@知乎，王不懂不懂@知乎，QFIUNE@csdn
感谢醉笑陪公看落花@知乎 倾囊相授，感谢小伙伴们督促学习，一起进步

文章目录


tips

  • python中传参是形参，如int，tuple等，但是遇到动态数组或集合就是传递的实参，如set和list，dict

  • 动态数组无法被hash化，所以无法加入集合，转为tuple形式即可

  • 深度优先搜索（DFS） 的一般框架，参考博文

    
void dfs()   //参数的个数根据实际情况确定
{  
    if(终止条件)  {  
        //根据题意添加  
        return;  
    }  
 
    for(扩展方式)  
    {  
        if(扩展方式所达到状态合法)  
        {  
            操作;  
            dfs（）；  
            回溯；   # 主要是让系统状态回到 “操作” 步骤之前
        }  
 
    }

leetcode 46. 全排列

给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

示例 1：

输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/permutations

把寻找全排列的过程，看作一棵树的生成过程。
【方法1】空集作为根节点，每次加入一个之前（父节点，祖先节点等）未使用的元素，直到元素被使用完。 时间复杂度O(n!n^2) 空间O(n+n!)
【方法2】每一层对原数组进行交换，i=0时，第一层为原数组，此时交换i号位置和i号及以后位置的数据(j= 0,1,2)，i= 1时，第二层是由第一层交换之后得到的，继续进行交换，交换i号位置和i号及以后位置的数据(j= 1,2)，当i= len(nums)-2的时候，把交换后的集合保存下来。 时间复杂度O(nn!)，空间O(n!)

【方法1】是对队列进行pop和append，与【方法1】相比，【方法2】的每一个节点，都是来自原数组的修改，没有后再额外申请变量，因此占用时间更少。

在这里插入图片描述
扩展： 方法2 只看交换之前的内容 nums[:i] ,可以 视作求子集过程
实现见 leetcode 446. 等差数列划分 II - 子序列 - 困难题目- 官方题解 - 动态规划 - DFS

红色框中表示求得的子集，求得的子集有重复的，可以剪枝避免重复计算

在这里插入图片描述

用方法1 构建树

广度优先

逐层遍历

from copy import deepcopy
class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        self.nums = nums
        self.all_subs = []
        self.BFS()
        return self.all_subs
    def BFS(self):
        from queue import Queue
        q = Queue()
        q.put([])
        while(not q.empty()):
            node = q.get()
            if len(node)==len(self.nums):
                self.all_subs.append(node[:])
                continue
            for i in range(len(self.nums)):
                if self.nums[i] in node:continue
                node.append(self.nums[i])
                q.put(node[:])
                node.pop()

在这里插入图片描述

循环体内判断某个元素是否在node集合中比较费时

self.nums[i] in node

深度优先+候选者数组

每使用一个元素，候选者数组丢弃一个元素，从而保证self.nums[i] not in node
尝试用深度优先来做

from copy import deepcopy
class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:

        self.nums = nums
        self.all_subs = []
        self.DFS(nums[:],[])
        return self.all_subs
    def DFS(self,candidates,subset):
        if len(subset)==len(self.nums):
            self.all_subs.append(subset[:])
            return
        n = len(candidates)
        for i in range(n):
            elem = candidates.pop(0)
            subset.append(elem)
            self.DFS(deepcopy(candidates),subset)
            candidates.append(elem)
            subset.pop()

候选者数组涉及频繁的删除和插入操作，会导致低效率，经观察发现，候选者数组，用set实现的时候，会有一点问题见后文【候选者数组用set实现】
由于set集合每次pop出来的元素是随机的，不可控因素太大，因此弃用

尤其是删除数组的第一个元素，会导致后面的元素全部向前移动一位，解决这个问题可以用队列来优化，但是队列也频繁地插入和删除，依然会浪费很多时间。

下文用访问数组来标记元素是否被使用过，每次对访问数组的值进行修改即可

在这里插入图片描述

深度优先+访问数组

from copy import deepcopy
class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        self.nums = nums
        self.all_subs = []
        self.DFS([0 for i in range(len(nums))],[])
        return self.all_subs
    def DFS(self,visited,subset):
        if len(subset)==len(self.nums):
            self.all_subs.append(subset[:])
            return
        for i in range(len(self.nums)):
            if visited[i] == 1:continue
            visited[i] = 1
            elem = self.nums[i]
            subset.append(elem)
            self.DFS(visited,subset)
            subset.pop()
            visited[i] = 0

在这里插入图片描述

用方法2构建树

深度优先搜索

from copy import deepcopy
class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        self.nums = nums
        self.all_subs = []
        self.DFS(0)
        return self.all_subs

    def DFS(self,i):
        if i == len(self.nums)-1:
            self.all_subs.append(self.nums[:])
            return
        for j in range(i,len(self.nums)):
            self.nums[i],self.nums[j] = self.nums[j],self.nums[i]
            self.DFS(i+1)
            self.nums[i],self.nums[j] = self.nums[j],self.nums[i]

效率
在这里插入图片描述

广度优先搜索

需要确定所在的层数，从而决定i的值，一层是否遍历结束不太好确定

'''
交换 DFS

长度为3
i=0 n_ndoe = 1 j = 0,1,2
i=1 n_node = n_ndoe * len(j) = 1*3 = 3, j= 1,2
i=2 n_node = n_node * len(j) = 3 * 2 = 6 , j = 2
'''
class Solution:
    def permute(self,nums):
        self.nums = nums
        self.all_subs = []
        self.BFS()
        return self.all_subs
    
    def BFS(self):
        from queue import Queue
        q = Queue()
        q.put(self.nums)
        i = 0
        n_node = len(self.nums) # 第i+1层结点数目
        if n_node ==1:
            self.all_subs.append(self.nums[0])
            return
        while not q.empty():
            subset = q.get()
            for j in range(i,len(subset)):
                subset[i],subset[j] = subset[j],subset[i]
                if i == len(self.nums)-2:self.all_subs.append(subset[:])
                else:
                    q.put(subset[:])
                subset[i],subset[j] = subset[j],subset[i]
            if q.qsize() == n_node:
                i+=1
                n_node = n_node * (len(self.nums) - i)

在这里插入图片描述

候选者数组用set实现的问题

当 nums = [0,-1,1] 时，pycharm结果和提交的结果不一致

'''
pycharm

# DFS  {0, 1, -1}, DFS  {1, -1}, DFS  {-1}, DFS  set(),[0, 1, -1]
# DFS  {1}, DFS  set(),[0, -1, 1]
# DFS  {0, -1}, DFS  {-1}, DFS  set(),[1, 0, -1]
# DFS  {0}, DFS  set(),[1, -1, 0]  ##### 此处pop的是-1  
# DFS  {0, 1}, DFS  {1}, DFS  set(),[-1, 0, 1]
# DFS  {0}, DFS  set(),[-1, 1, 0]

leetcode

# DFS  {0, 1, -1},DFS  {1, -1},DFS  {-1},DFS  set(),[0, 1, -1]
# DFS  {1},DFS  set(),[0, -1, 1]
# DFS  {0, -1},DFS  {-1},DFS  set(),[1, 0, -1]
# DFS  {-1},DFS  set(),[1, 0, -1]  ##### 此处pop的是0                                
# DFS  {0, 1},DFS  {1},DFS  set(),[-1, 0, 1]
# DFS  {0},DFS  set(),[-1, 1, 0]
'''
from copy import deepcopy


class Solution:
    def permute(self,nums):
        self.nums = nums
        self.all_subs = []
        self.DFS(set(nums),[])
        return self.all_subs
    def DFS(self,candidates,subset):
        if len(subset)==len(self.nums):
            self.all_subs.append(subset[:])
            return
        n = len(candidates)
        for i in range(n):
            elem = candidates.pop()
            subset.append(elem)
            self.DFS(deepcopy(candidates),subset)
            candidates.add(elem)
            subset.pop()

pycharm上的结果

在这里插入图片描述
leetcode 上 测试用例结果
在这里插入图片描述
猜想原因是 set是一个无序的集合，每次pop的内容是随机的。

在pycharm和leetcode中，当键都是数值的话，都是按照键值从小到大来pop的，首先pop的是非负数从小到大，然后是负数从小到大。

   nums = [0,-1,1,2,-5]

   myset = set(nums)
   while(myset):
       print(myset.pop(),end=',')
   print('\n###############')
   myset = set(nums)
   for x in nums:
       myset.add(x)
   while(myset):
       print(myset.pop(),end=',')

0,1,2,-5,-1,
###############
0,1,2,-5,-1,

而在实际调试中发现，pycharm在遇到{-1，0} 的时候，第一次pop的是0，第二次pop的是-1

在这里插入图片描述

说明前面按照键大小pop的想法是有问题的，事实上set每次pop的内容是随机的，会导致一些元素反复被pop出来，一些元素始终没有被pop。

leetcode 47. 全排列 II 包含重复数字序列，返回不重复全排列

给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]
输出：
[[1,1,2],
[1,2,1],
[2,1,1]]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/permutations-ii

在方法1构建树（元素加入结点集中的方式构建树）的基础上，加入备忘录进行剪枝即可，将树的每一个结点加入备忘录中，相同结点集合直接返回，不再遍历

在这里插入图片描述
关键代码

if tuple(subset) in self.memor:return
self.memor.add(tuple(subset[:]))

class Solution:
    def permuteUnique(self,nums):
        self.nums = nums
        self.all_subs = []
        self.memor = set()
        self.DFS([0 for i in range(len(nums))],[])
        return self.all_subs

    def DFS(self,visited,subset):
        if tuple(subset) in self.memor:return
        self.memor.add(tuple(subset[:]))
        if len(subset)==len(self.nums):
            self.all_subs.append(subset[:])
            return
        for i in range(len(self.nums)):
            if visited[i] == 1:continue
            visited[i] = 1
            elem = self.nums[i]
            subset.append(elem)
            self.DFS(visited,subset)
            subset.pop()
            visited[i] = 0

在这里插入图片描述

Julse
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode - 46 全排列
程序员阿甘的博客
10-12 2673
LeetCode - 46 全排列，实现：回溯算法
LeetCode - 47 全排列 II
最新发布
程序员阿甘的博客
10-13 2254
LeetCode - 47 全排列 II，考察：回溯算法，全排列问题，树层去重
LeetCode 根据题目给定的输入生成树
qq_32830061的博客
07-08 582
在刷LeetCode的时候，经常碰到树模型的题目，但是他给的输入是一个数组，类似： [5,4,8,11,null,13,4,7,2,null,null,5,1] 而LeetCode不开会员又没办法调试，所以需要在本地的IDEA上建树调试，具体代码如下： 树类： public class TreeNode { public int val; public TreeNode left; public TreeNode right; public TreeNode(int x)
生成树问题（1）
weixin_33727510的博客
12-06 95
最小瓶颈生成树：(给出加权无向图，求一棵生成树，是的最大边权尽量小) 　　可以从一个空树开始，按照权值从小到大，依次加入各条边，则图第一次连通的时候，改图的最小生成树就是原图的最小瓶颈生成树。 　 这一过程就是Kruskal，原图的最小生成树就是一棵最小瓶颈生成树。 最小瓶颈路：（u,v，求一条路径从 u 到 v ，是的路径上的最长边短） 　　1、可以用 Dijkstra 松弛条...
python 生成树算法实现全排列
chuanzhu1719的博客
11-18 146
#!/usr/bin/python _array=range(4) _path=[] deffull_range(array,path): iflen(set(array)-set(path))==0: printpath foriin...
[leetcode][回溯][排序树]全排列
BRAVE_NO1的专栏
11-23 270
1.题目 给定一个没有重复数字的序列，返回其所有可能的全排列。 示例: 输入: [1,2,3] 输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ] 2.代码 class Solution { public: vector<vector<int>>res...
leetcode叶值的最小代价生成树
weixin_41672404的博客
08-08 168
思路： 给出的序列是中序遍历的叶子节点，也就是每个值都只能和其左边或者右边结合成左右子树的叶子节点。[1,2,3,4]，比如2只能和1或者3组成左右子树的叶子节点 构造的树有点类似于哈夫曼树，就是希望最小的叶子节点处于最下面，即计算次数最多，从底向上就是先进行计算的，需要找到当前叶子节点极小值。 所以入栈的都是比栈顶小的值，只有找到比栈顶大的值，栈顶才是找到的极小值。 单调递减栈 当找到栈顶极小值时，栈顶可以和左右两边的最小值构成左右子树节点，stack[top-1]和arr[i]中的最小值 在栈顶部..
【leetcode】46.全排列 （回溯算法详细解析。java实现）
Viper的程序员修炼手册
08-04 2357
46. 全排列 难度中等825收藏分享切换为英文关注反馈 给定一个 没有重复 数字的序列，返回其所有可能的全排列。 示例: 输入: [1,2,3] 输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ] 分析 请读者带着以下问题理解回溯搜索算法的思想。 1、什么是“树形问题”？为什么是在树形问题上使用“深度优先遍历”？不用深度优先遍历我们还可以用什么？ 2、什么是“回溯”？为什么需要回溯？ 3、不回溯可以吗？ 首
go-LeetCode问题解决方案
02-08
在这个“go-LeetCode问题解决方案”中，我们重点探讨的是使用Go语言来解决LeetCode上的问题，特别是深度优先搜索（DFS）和回溯（Backtracking）这两种算法。 深度优先搜索是一种用于遍历或搜索树或图的算法。在Go中...
Leetcode:Leetcode解决方案
03-16
在这个“LeetCode: LeetCode解决方案”中，我们主要关注的是使用Java语言来解决这些题目。Java是一种广泛使用的面向对象的编程语言，以其平台独立性、强大的类库和丰富的API而闻名，因此在处理算法问题时非常受欢迎...
通过动态规划方式实现全排列
每天进步一点点
04-08 3659
原文：http://www.codeproject.com/Articles/891811/Calculating-Permutation-using-dynamic-programming The application accepts inputs from the user which is a string and will be passed as an array of chars
集合元素全排列的生成（排列树+递归回溯）
75 69 69 80 32 67 79 68 73 78 71 33
10-17 2253
文章目录1. 问题定义2. 递归生成1~n的排列3. 复杂度分析4. 排列树（解答树）5.可重集的全排列6. STL中的下一个排列函数 1. 问题定义 输入整数n，按照字典序从小到大输出前n个数得到所有排列。 即若n=3，则有全排列 {123，132，213，231，312，321}\{123，132，213，231，312，321\}{123，132，213，231，312，321}。 或者输...
数据结构：全排列的生成算法
ykk345967417的专栏
09-20 845
 　全排列的生成算法就是对于给定的字符集，用有效的方法将所有可能的全排列无重复无遗漏地枚举出来。任何n个字符集的排列都可以与1～n的n个数字的排列一一对应，因此在此就以n个数字的排列为例说明排列的生成法。­　　n个字符的全体排列之间存在一个确定的线性顺序关系。所有的排列中除最后一个排列外，都有一个后继；除第一个排列外，都有一个前驱。每个排列的后继都可以从 它 的前驱经过最少的变化而得到，全
AC解 - 用动态规划解决一道排列组合计数问题（序关系计算）
ljsspace的专栏
05-26 3794
AC解 - 用动态规划解决一道排列组合计数问题（序关系计算） 原题如下：http://acm.nankai.edu.cn/problem.php?problem=1134 [同时请参考网友pandm发的帖子：http://topic.csdn.net/u/20110525/01/adf4d0b0- 2b8e-4c0a-b8da-07b27f1711cc.html] There are 13 possible orderings for three numbers, if we sort them wi
利用遍历解答树实现数列的全排序
matrixa17的专栏
03-21 4797
利用图的深度优先遍历实现数列的全排序 例如 1 2 3 ------>1 2 3，1 3 2，2 1 3，2 3 1，3 1 2，3 2 1共6中不同的排序 参考代码如下： #include #include using namespace std; const int N = 99999999; //输入排序的个数的最大值 int record[N];
计算a的全排列（解空间为排列树）
weixin_46112487的博客
10-08 1070
#include<iostream> using namespace std; void swap(int &x,int &y); void dispasolution(int a[],int n); void dfs(int a[],int n,int i); int main() { int a[]={1,2,3}; int n=sizeof(a)/sizeof(a[0]); cout<<"a的全排列"<<endl;
全排列（next_permutation，递归）
xx_ii
08-16 1214
http://www.cnblogs.com/zyoung/p/6764371.html 下面用递归算法实现对1 2 3 4 全排列：#include <iostream> using namespace std;template<typename T> void permutation(T array[], int begin, int end) { int i; if(begin
全排列和全组合实现
u012861978的专栏
07-17 806
全排列 所谓全排列，就是打印出字符串中所有字符的所有排列。例如输入字符串abc，则打印出 a、b、c 所能排列出来的所有字符串 abc、acb、bac、bca、cab 和 cba 。 一般最先想到的方法是暴力循环法，即对于每一位，遍历集合中可能的元素，如果在这一位之前出现过了该元素，跳过该元素。例如对于abc，第一位可以是 a 或 b 或 c 。当第一位为 a 时，第二位再遍历集合，发现 a
LeetCode: 橘子腐烂问题的BFS解决方案
提供的代码片段是用C++实现的一种基于BFS（广度优先搜索）的方法来解决此问题。" 在给定的网格问题中，每个单元格可能有三种状态：0表示空单元格，1表示新鲜橘子，2表示腐烂的橘子。腐烂的橘子每分钟会将相邻的四个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值