LEETCODE-DAY29

最新推荐文章于 2024-07-25 18:40:03 发布
最新推荐文章于 2024-07-25 18:40:03 发布
阅读量1.6k 收藏 24
点赞数 41
文章标签： leetcode python 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qyc_sh/article/details/136914838
版权

title: LEETCODE-DAY29
date: 2024-03-20 15:22:38
tags:

今日内容：491.递增子序列、46.全排列、47.全排列 II

T1

class Solution:
    def backtracking(self,nums,index,path,res):
        if index==len(nums):
            res.append(path.copy())
            return
        for i in range(index,len(nums)):
            if i> index and nums[i]<nums[i-1]:
                continue
            path.append(nums[i])
            self.backtracking(nums,i+1,path,res)
            path.pop()
                

    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.backtracking(nums,0,[],res)
        return res

输入
nums =
[4,4,3,2,1]
输出
[[4,4,3,2,1],[4,3,2,1]]
预期结果
[[4,4]]

class Solution:
    def backtracking(self,nums,index,path,res):
        if index==len(nums):
            res.append(path.copy())
            return
        for i in range(index,len(nums)):
            if i> index and nums[i]>=nums[i-1]:
                
                path.append(nums[i])
                self.backtracking(nums,i+1,path,res)
                path.pop()
            else:
                continue
                
    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.backtracking(nums,0,[],res)
        return res

输入
nums =
[4,4,3,2,1]
输出
[]
预期结果
[[4,4]]

nums =
[4,6,7,7]
输出
[[6,7],[7]]
预期结果
[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

逻辑错了应该跟path最后一位比较

class Solution:
    def backtracking(self,nums,index,path,res):
        if index==len(nums):
            res.append(path.copy())
            return
        for i in range(index,len(nums)):
            path.append(nums[i])
            if len(path)>=2 and path[-1]<path[-2]:    
                return
            self.backtracking(nums,i+1,path,res)
            path.pop()
                

    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.backtracking(nums,0,[],res)
        return res

输入
nums =
[4,6,7,7]
输出
[[4,6,7,7],[4,6,7],[4,7,7],[4,7],[6,7,7],[6,7],[7,7],[7]]
预期结果
[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

输入
nums =
[4,4,3,2,1]
输出
[]
预期结果
[[4,4]]

应该是收集结果的判断有问题
[4,6]满足递增条件但是还没到队列尾部所以没有放入res中

class Solution:
    def backtracking(self,nums,index,path,res):
        if len(path)>=2 and path[-1]>=path[-2]:
            res.append(path.copy())
            return
        for i in range(index,len(nums)):
            path.append(nums[i])
            if len(path)>=2 and path[-1]<path[-2]:    
                return
            self.backtracking(nums,i+1,path,res)
            path.pop()
                

    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.backtracking(nums,0,[],res)
        return res

输入
nums =
[4,6,7,7]
输出
[[4,6],[4,7],[4,7],[6,7],[6,7],[7,7]]
预期结果
[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]
貌似也不对

因为是取树上的节点所以不要return

class Solution:
    def backtracking(self,nums,index,path,res):
        if len(path)>=2 and path[-1]>=path[-2]:
        #此处直接写if len(path)>=2: 结果一样
            res.append(path.copy())
            
        for i in range(index,len(nums)):
            path.append(nums[i])
            if len(path)>=2 and path[-1]<path[-2]:    
                return
            self.backtracking(nums,i+1,path,res)
            path.pop()
                

    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.backtracking(nums,0,[],res)
        return res

nums =
[4,4,3,2,1]
输出
[[4,4],[4,4,4]]
预期结果
[[4,4]]

输入
nums =
[4,6,7,7]
输出
[[4,6],[4,6,7],[4,6,7,7],[4,6,7],[4,7],[4,7,7],[4,7],[6,7],[6,7,7],[6,7],[7,7]]
预期结果
[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]
有重复

class Solution:
    def backtracking(self,nums,index,path,res):
        if len(path)>=2 :
            res.append(path.copy())
            
        for i in range(index,len(nums)):
            if not path:
                path.append(nums[i])
                self.backtracking(nums,i+1,path,res)
                path.pop()
            else:
                if nums[i]>=path[-1]:
                    path.append(nums[i])
                    self.backtracking(nums,i+1,path,res)
                    path.pop()
                else:
                    return
        '''def backtracking(self,nums,index,path,res):
            if len(path)>=2  :
                res.append(path.copy())
            
            for i in range(index,len(nums)):
                if path and nums[i]<path[-1]:
                    return（continue）
                path.append(nums[i])
                self.backtracking(nums,i+1,path,res)
                path.pop()   结果一样'''            

                

    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.backtracking(nums,0,[],res)
        return res

输入
nums =
[4,4,3,2,1]
输出
[[4,4]]
预期结果
[[4,4]]

输入
nums =
[4,6,7,7]
输出
[[4,6],[4,6,7],[4,6,7,7],[4,6,7],[4,7],[4,7,7],[4,7],[6,7],[6,7,7],[6,7],[7,7]]
预期结果
[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

class Solution:
    def backtracking(self,nums,index,path,res):
        if len(path)>=2 and path not in res :
            res.append(path.copy())
            
        for i in range(index,len(nums)):
            if not path:
                path.append(nums[i])
                self.backtracking(nums,i+1,path,res)
                path.pop()
            else:
                if nums[i]>=path[-1]:
                    path.append(nums[i])
                    self.backtracking(nums,i+1,path,res)
                    path.pop()
                else:
                    return

                

    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.backtracking(nums,0,[],res)
        return res

用例过了但没AC

class Solution:
    def backtracking(self,nums,index,path,res):
        if len(path)>=2  :
            res.append(path.copy())
        used=set()    
        for i in range(index,len(nums)):
            if (path and nums[i]<path[-1]) or nums[i] in used:
                return
            path.append(nums[i])
            used.add(nums[i])
            self.backtracking(nums,i+1,path,res)
            path.pop()               

    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.backtracking(nums,0,[],res)
        return res

18 / 58 个通过的测试用例

class Solution:
    def backtracking(self,nums,index,path,res):
        if len(path)>=2  :
            res.append(path.copy())
        used=set()    
        for i in range(index,len(nums)):
            if (path and nums[i]<path[-1]) or nums[i] in used:
                continue
            path.append(nums[i])
            used.add(nums[i])
            self.backtracking(nums,i+1,path,res)
            path.pop()               

    def findSubsequences(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.backtracking(nums,0,[],res)
        return res

return与continue的区别
return：函数终止
continue：for 循环中 这一层的i终止进入i+1

T2

class Solution:
    def backtracking(self,nums,path,res):
        if len(path)==len(nums):
            res.append(path)
            return
        used=list()
        for i in range(len(nums)):
            if nums[i] in used: 
                continue
            path.append(nums[i])
            self.backtracking(nums,path,res)
            path.pop()


    def permute(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.backtracking(nums,[],res)
        return res

输入
nums =
[0,1]
输出
[[],[],[],[]]
预期结果
[[0,1],[1,0]]

class Solution:
    def backtracking(self,nums,path,res,used):
        if len(path)==len(nums):
            res.append(path)
            return
        for i in range(len(nums)):
            if nums[i] in used: 
                continue
            path.append(nums[i])
            used.append(nums[i])
            self.backtracking(nums,path,res,used)
            path.pop()


    def permute(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.backtracking(nums,[],res,[])
        return res

输入
nums =
[1,2,3]
输出
[[]]
预期结果
[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

细节忘记path.copy了

class Solution:
    def backtracking(self,nums,path,res,used):
        if len(path)==len(nums):
            res.append(path.copy())
            return
        for i in range(len(nums)):
            if nums[i] in used: 
                continue
            path.append(nums[i])
            used.append(nums[i])
            self.backtracking(nums,path,res,used)
            path.pop()


    def permute(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.backtracking(nums,[],res,[])
        return res

输入
nums =
[0,1]
输出
[[0,1]]
预期结果
[[0,1],[1,0]]

要注意used数组也要相应的做回溯

class Solution:
    def backtracking(self,nums,path,res,used):
        if len(path)==len(nums):
            res.append(path.copy())
            return

        for i in range(len(nums)):
            if nums[i] in used: 
                continue
            path.append(nums[i])
            used.append(nums[i])
            self.backtracking(nums,path,res,used)
            path.pop()
            used.pop()


    def permute(self, nums: List[int]) -> List[List[int]]:
        res=[]
        self.backtracking(nums,[],res,[])
        return res

AC

细节上还是要注意

T3

class Solution:
    def backtracking(self,nums,path,res,used):
        if len(path)==len(nums):
            if path not in res:
                res.append(path.copy())
            return
        for i in range(len(nums)):
            if used[i]:
                continue
            path.append(nums[i])
            used[i]=True
            self.backtracking(nums,path,res,used)
            path.pop()
            used[i]=False

    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        res=[]
        used=[False]*(len(nums))
        self.backtracking(nums,[],res,used)
        return res

这是暴力去重，还有简化解法，后补
qyc_sh
关注
  • 41
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Leetcode-day:JS Leetcode
05-05
Leetcode Day Leetcode Javascript 解题。 issue 中给出具体思路，Label 分类。 当前排名： 30,357（更新时间：2020/12/17）（:backhand_index_pointing_right:：） 分类 回溯 栈 递归 历史排名： 30357（更新时间：...
leetCode-day-pratice:每日练习，开发遇到的问题，技术笔记
03-19
标题 "leetCode-day-pratice" 暗示这是一个关于 LeetCode 每日练习的项目，其中可能包含了开发者在解决算法问题时遇到的挑战、解决方案和技术笔记。LeetCode 是一个在线平台，提供了各种编程问题，帮助程序员提高...
LEETCODE-DAY37
qyc_sh的博客
03-29 220
从第一个不递增的开始-1并替换后面的为9。
LEETCODE-DAY9
qyc_sh的博客
03-01 246
注意数组切片s[i:j]返回的是数组中下标i到j-1，也即s[j]并不返回，这里非常容易错。今日题目：28找出字符串中第一个匹配项的下标 459.重复的子字符串。128 / 129 个通过的测试用例。注意求最大相等前后缀是关键。即为KMP算法的实践。
Leetcode-day01-数组
m0_61890209的博客
07-17 289
2. if(nums[middle]>target) 此时应该是right = middle 还是right = middle -1;答案是middle-1，因为是闭区间，已经判断了中间值不是target，查找区间就把它去掉。这个时候可以做带入，我的原则是[left,right]的区间，如果left==right是否满足该条件呢？2.while(left<right) 因为如果加了等于[1.1) 这是不合规的。3.right = mid 因为右开，(nums[mid]>target)
leetcode-day1
LQalive的博客
05-08 106
【代码】leetcode-day1。
LeetCode--day1
子非愚的博客
12-18 323
给你一个数组 nums 。数组「动态和」的计算公式为：runningSum[i] = sum(nums[0]…nums[i]) 。 请返回 nums 的动态和。 示例 1： 输入：nums = [1,2,3,4] 输出：[1,3,6,10] 解释：动态和计算过程为 [1, 1+2, 1+2+3, 1+2+3+4] 。 示例 2： 输入：nums = [1,1,1,1,1] 输出：[1,2,3,4,5] 解释：动态和计算过程为 [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1.
Happy-Leetcode-Per-Day
03-22
项目“Happy-Leetcode-Per-Day”正是以此为目标，通过每日解决一道LeetCode题目，以C++语言进行解答，旨在打造一个快乐而持久的学习过程。 在这个项目中，开发者坚持每天解决一道LeetCode题目，并将解题思路记录在`...
leetcode卡-Leetcode-May-30-day-Challenge:Leetcode-May-30-day-Challenge
07-06
leetcode卡力码 30 天 该存储库作为点对点通信渠道创建和维护，以便 CP 世界的新来者可以讨论他们对 Leetcode ...向“manthanchauhan/Leetcode-May-30-day-Challenge/master”提交 PR。 资源 教程：
leetcode中国-LeetCode-100DAY-Challenge:我于2019年12月5日开始了leetcode-100天挑战
06-29
leetcode中国LeetCode-100DAY-挑战 我于 2019 年 12 月 5 日开始了 leetcode-100 天挑战。 会有期末考试周、农历新年等大型活动，所以这很有挑战性。 希望我能完成它！ :) 顺便说一句，也许我会根据我是否忙来做一些...
leetcode日记（51）不同路径Ⅱ
s478527548的博客
07-25 745
琢磨了一下代码，原理是将上面的二维数组优化成了一维，记录开始位置到达每一行末尾的路径数。没有障碍物就将数目设为上一行路径数加上这一行路径数。需要注意的是遍历方向，按照上面这种思路需要先遍历列再遍历行，如果先遍历行，如果上一行末尾有障碍物那么下一行就通过不了。根据上一题改的代码如下，添加了对障碍物的判定，如果有障碍物则将数组值设为0。然后看了答案，答案说可以使用滚动数组优化，就又去搜了一下滚动数组的使用方法。和上一道题（无障碍物的最短路径）很像，但事实上比上一题多了优化方法。
【力扣练习题】C语言答案
m0_65146517的博客
07-24 611
4、判断两数大小，p小于等于q返回p，p->next递归调用函数。2、遍历判断两个链表的单个值，用尾插法将小的值代入链表。1、如果q为NULL，p为NULL；3、如果遇到大于100000的数则返回true;5、否则返回q，q->next递归调用函数。1、将所有遍历过的值全部替换为100001。2、判断如果遇到NULL则返回false。3、如果p为NULL,返回 q;2、如果q为NULL，返回p；
LeetCode 2766.重新放置石块：哈希表
<font color="Pink">Tisfy的博客</font>
07-25 860
LeetCode 2766.重新放置石块：哈希表 给你一个下标从 0 开始的整数数组 nums ，表示一些石块的初始位置。再给你两个长度 相等 下标从 0 开始的整数数组 moveFrom 和 moveTo 。 在 moveFrom.length 次操作内，你可以改变石块的位置。在第 i 次操作中，你将位置在 moveFrom[i] 的所有石块移到位置 moveTo[i] 。 完成这些操作后，请你按升序返回所有 有 石块的位置。 注意： 如果一个位置至少有一个石块，我们称这个位置 有 石块。 一个位
【动态规划】力扣.213. 打家劫舍 II
sjsjs11的博客
07-25 481
同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。具体步骤和思路跟打家劫舍1的相同（主页有打家劫舍1的三种算法的详细思路），唯一区别是增加了首尾房子不能同时被偷的限制，所以可以分类讨论，然后返回出能偷到最大的金额即可。解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。输入：nums = [1,2,3,1]
力扣621.任务调度器
最新发布
Pisasama的博客
07-25 330
【代码】力扣621.任务调度器。
C++ | Leetcode C++题解之第284题窥视迭代器
Ddddddd_158的博客
07-25 484
C++ | Leetcode C++题解之第284题窥视迭代器
LeetCode 2844.生成特殊数字的最少操作（哈希表 + 贪心）
AuRoRamth的博客
07-25 864
在来观察，被25整除，思考思考，你会发现25 * （1 ~ n）中的数他的后两位尾数是{25，50，75，00}，只要能发现这个规律，那这道题也就结束了，当然想不到也没关系，慢慢积累。那接下来就是两个指针i和j去遍历就行了，把{25，50，75，00}存到哈希表里面，如果key = num[i] + num[j]在哈希表里面找到了，就去更新一次ans的值。删除 num[3]、num[4] 和 num[6] ，得到数字 "2900" ，可以被 25 整除。在一次操作中，您可以选择。，表示一个非负整数。
力扣69题 x的平方根 二分查找法（简单易懂）
xiaoye7288的博客
07-25 328
一种人一种写法 建议大家用自己的二分做来题 不要一味去模仿他人的二分 加油！
力扣1405.最长快乐字符串
Pisasama的博客
07-25 359
【代码】力扣1405.最长快乐字符串。
idea leetcode-edito乱码
09-01
LeetCode-Editor是一种在线编码工具，它提供了一个用户友好的界面编写和运行代码。在使用LeetCode-Editor时，有时候会出现乱码的问题。 乱码的原因可能是由于编码格式不兼容或者编码错误导致的。在这种情况下，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值