LEETCODE-DAY27

最新推荐文章于 2025-12-20 20:19:18 发布
原创 最新推荐文章于 2025-12-20 20:19:18 发布 · 437 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#leetcode #python #算法

文章介绍了在LeetCode题目中，如何通过回溯算法实现组合总和（包括常规版本和去重版本）以及判断字符串是否为回文串。着重讨论了代码优化，如避免重复和处理边界条件，以提高算法效率。

title: LEETCODE-DAY27
date: 2024-03-18 12:55:19
tags:

今日内容：39. 组合总和、40.组合总和II、131.分割回文串

T1

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

    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        res=[]
        self.backtracking(candidates,target,[],res)
        return res

超出时间限制

class Solution:
    def backtracking(self,candidates,target,nums,res):
        if sum(nums)==target:
            res.append(nums.copy())
            return
        if sum(nums)> target:
            return
        for i in range(len(candidates)):
            nums.append(candidates[i])
            self.backtracking(candidates,target,nums,res)
            nums.pop()

    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        res=[]
        self.backtracking(candidates,target,[],res)
        return res

andidates =
[2,3,6,7]
target =
7
输出
[[2,2,3],[2,3,2],[3,2,2],[7]]
预期结果
[[2,2,3],[7]]

有重复

暴力去重

class Solution:
    def backtracking(self,candidates,target,nums,res):
        if sum(nums)==target:
            if sorted(nums.copy()) not in res:
                res.append(sorted(nums.copy()))
            return
        if sum(nums)> target:
            return
        for i in range(len(candidates)):
            nums.append(candidates[i])
            self.backtracking(candidates,target,nums,res)
            nums.pop()

    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        res=[]
        self.backtracking(candidates,target,[],res)
        return res

更便捷的方法：用index

T2

class Solution:
    def backtracking(self,candidates,target,index,nums,res):
        if sum(nums)> target:
            return
        if index==len(candidates):
            return
        if sum(nums)==target:
            if sorted(nums.copy()) not in res:
                res.append(sorted(nums.copy()))
            return
        for i in range(index,len(candidates)):
            nums.append(candidates[i])
            self.backtracking(candidates,target,index+1,nums,res)
            nums.pop()

    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        res=[]
        self.backtracking(candidates,target,0,[],res)
        return res

candidates =
[2,5,2,1,2]
target =
5
输出
[[1,2,2],[1,1,1,2],[5]]
预期结果
[[1,2,2],[5]]

输入
candidates =
[10,1,2,7,6,1,5]
target =
8
输出
[[1,1,6],[1,1,1,5],[1,1,1,1,2,2],[1,2,5],[1,7],[1,1,2,2,2],[2,6]]
预期结果
[[1,1,6],[1,2,5],[1,7],[2,6]]

class Solution:
    def backtracking(self,candidates,target,index,nums,res):
        if sum(nums)> target:
            return
        if sum(nums)==target:
            if sorted(nums.copy()) not in res:
                res.append(sorted(nums.copy()))
            return
        for i in range(index,len(candidates)):
            nums.append(candidates[i])
            self.backtracking(candidates,target,i+1,nums,res)
            nums.pop()

    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        res=[]
        self.backtracking(candidates,target,0,[],res)
        return res

回溯时参数应为i+1
此时超出时间限制27/176

class Solution:
    def backtracking(self,candidates,target,index,nums,res):
        if sum(nums)> target:
            return
        if sum(nums)==target:
            if sorted(nums.copy()) not in res:
                res.append(sorted(nums.copy()))
            return
        for i in range(index,len(candidates)):
            nums.append(candidates[i])
            self.backtracking(candidates,target,i+1,nums,res)
            nums.pop()

    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        if sum(candidates)<target:
            return []
        res=[]
        self.backtracking(candidates,target,0,[],res)
        return res

超出时间限制172/176

直接对candidates排序，这样可以减少排序的次数

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

    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        if sum(candidates)<target:
            return []
        res=[]
        candidates.sort()
        self.backtracking(candidates,target,0,[],res)
        return res

candidates =
[2,5,2,1,2]
target =
5
输出
[[5]]
预期结果
[[1,2,2],[5]]

 def backtracking(self,candidates,target,index,nums,res):
        if sum(nums)> target:
            return
        if sum(nums)==target:
            
            res.append(nums.copy())
            return
        for i in range(index,len(candidates)):
            #if candidates[i]==candidates[i-1]:
                #continue
           
            nums.append(candidates[i])
            self.backtracking(candidates,target,i+1,nums,res)
            nums.pop()

输入
candidates =
[10,1,2,7,6,1,5]
target =
8
输出
[[1,1,6],[1,2,5],[1,7],[1,2,5],[1,7],[2,6]]
预期结果
[[1,1,6],[1,2,5],[1,7],[2,6]]

问题在于i=index时多去重了

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

    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        if sum(candidates)<target:
            return []
        res=[]
        candidates.sort()
        self.backtracking(candidates,target,0,[],res)
        return res

AC

T3

class Solution:
    def isPalindrome(self,s):
        i=0
        j=len(s)-1
        while i<=j:
            if s[i] !=s[j]:
                return False
            i+=1
            j-=1
        return True
    def backtracking(self,s,index,path,res):
        if index==len(s):
            res.append(path)
            return

        for i in range(index,len(s)):
            if self.isPalindrome(s[index:i]):
                path+=s[index:i]
                self.backtracking(s,i,path,res)
                path=path[:-(i-index)]

    def partition(self, s: str) -> List[List[str]]:
        res=[]
        self.backtracking(s,0,[],res)
        return res

RecursionError: maximum recursion depth exceeded in comparison
^^^^^^^^^^^^^^^^^^^
for i in range(index,len(s)):
Line 16 in backtracking (Solution.py)

for i in range(index,len(s)):
            if self.isPalindrome(s[index:i]):
                path.append(s[index:i])
                self.backtracking(s,i,path,res)
                path.pop()
            else:
                return

仍错误

class Solution:
    def isPalindrome(self,s):
        i=0
        j=len(s)-1
        while i<=j:
            if s[i] !=s[j]:
                return False
            i+=1
            j-=1
        return True
    def backtracking(self,s,index,path,res):
        if index==len(s):
            res.append(path)
            return

        for i in range(index,len(s)):
            if self.isPalindrome(s[index:i]):
                path.append(s[index:i])
                
            else:
                continue
            self.backtracking(s,i+1,path,res)
        


    def partition(self, s: str) -> List[List[str]]:
        res=[]
        self.backtracking(s,0,[],res)
        return res

输入
s =
“a”
输出
[[“”]]
预期结果
[[“a”]]

输入
s =
“aab”
输出
[[“”,“”,“”,“a”,“a”,“”,“aa”],[“”,“”,“”,“a”,“a”,“”,“aa”],[“”,“”,“”,“a”,“a”,“”,“aa”],[“”,“”,“”,“a”,“a”,“”,“aa”]]
预期结果
[[“a”,“a”,“b”],[“aa”,“b”]]

def backtracking(self,s,index,path,res):
        if index==len(s):
            res.append(path.copy())
            return

        for i in range(index,len(s)):
            if self.isPalindrome(s[index:i]):
                path.append(s[index:i])
                self.backtracking(s,i+1,path,res)
                path.pop()

输入
s =
“aab”
输出
[[“”,“”,“”],[“”,“a”],[“a”,“”],[“aa”]]
预期结果
[[“a”,“a”,“b”],[“aa”,“b”]]

错误在于出现为空的情况即i=index
故i应改为i+1,这并不会造成下标溢出，因为s[index,len(s)]正好取到s最后一个元素

class Solution:
    def isPalindrome(self,s):
        i=0
        j=len(s)-1
        while i<=j:
            if s[i] !=s[j]:
                return False
            i+=1
            j-=1
        return True
    def backtracking(self,s,index,path,res):
        if index==len(s):
            res.append(path.copy())
            return

        for i in range(index,len(s)):
            if self.isPalindrome(s[index:i+1]):
                path.append(s[index:i+1])
                self.backtracking(s,i+1,path,res)
                path.pop()        


    def partition(self, s: str) -> List[List[str]]:
        res=[]
        self.backtracking(s,0,[],res)
        return res

AC
qyc_sh
关注
LEETCODE-DAY37
qyc_sh的博客
03-29 338
从第一个不递增的开始-1并替换后面的为9。
LEETCODE-DAY9
qyc_sh的博客
03-01 389
注意数组切片s[i:j]返回的是数组中下标i到j-1，也即s[j]并不返回，这里非常容易错。今日题目：28找出字符串中第一个匹配项的下标 459.重复的子字符串。128 / 129 个通过的测试用例。注意求最大相等前后缀是关键。即为KMP算法的实践。
Leetcode-day01-数组
m0_61890209的博客
07-17 447
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 232
【代码】leetcode-day1。
LeetCode--day1
子非愚的博客
12-18 469
给你一个数组 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.
Leetcode-day17-二叉树
m0_61890209的博客
08-07 251
TODO。
Leetcode-day15-二叉树
m0_61890209的博客
08-07 212
TODO。
LeetCode-day08-881. 救生艇
小李的便利店
06-10 561
881. 救生艇
Leetcode-day28-贪心算法
m0_61890209的博客
08-20 615
贪心的思路是：curSum也就是当前剩余的油量如果小于0了，说明只能从i+1开始走。如果totalSum最终小于0，怎么走都无解。而且题目中说如果是有解，唯一解。
LeetCode-day44-551. 学生出勤记录 I
小李的便利店
08-18 454
551. 学生出勤记录 I
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-day:JS Leetcode
05-05
Leetcode Day Leetcode Javascript 解题。 issue 中给出具体思路，Label 分类。 当前排名： 30,357（更新时间：2020/12/17）（:backhand_index_pointing_right:：） 分类 回溯 栈 递归 历史排名： 30357（更新时间：...
leetcode卡-Leetcode-30-day-challenge-april:30天LeetCoding挑战
07-06
《LeetCode 30天挑战解析：2020年4月篇》 LeetCode，一个全球知名的在线编程挑战...而压缩包文件"LeetCode-30-day-challenge-april-master"则包含了这次挑战的所有题目和解决方案，是进一步深入学习和研究的好材料。
leetcode卡-leetcode-may-30-day-challenge:5月30天挑战的解决方案
07-06
"master"分支通常代表了项目的主线开发，而"leetcode-may-30-day-challenge"可能是这个项目特定的目录或子模块，专门用于存放5月份30天挑战的代码。 深入学习这个压缩包，你将获得以下知识点： 1. **算法与数据...
LeetCode热题100--70. 爬楼梯--简单
2301_80071187的博客
12-20 155
这道题考察爬楼梯问题，每次可以爬1或2个台阶，求爬到n阶的不同方法数。采用动态规划解法，初始化dp数组，dp[0]=1，dp[1]=1。对于i≥2，dp[i]=dp[i-1]+dp[i-2]，即当前台阶的方法数等于前两个台阶方法数之和。最终返回dp[n]即为结果。该解法时间复杂度O(n)，空间复杂度O(n)。
力扣(LeetCode) 83: 删除排序链表中的重复元素 - 解法思路
最新发布
Yao H. Wang's Blog
12-20 76
给定一个已排序的链表的头head，删除所有重复的元素，使每个元素只出现一次。返回同样已排序的链表。迭代方法通过一次遍历并跳过重复节点，高效地从已排序链表中删除重复元素。由于链表已排序，重复元素总是相邻的，这使得解决方案非常直接。
力扣（LeetCode）- 93. 复原 IP 地址（JavaScript）
小妖666个人笔记
12-20 203
力扣（LeetCode）- 93. 复原 IP 地址（JavaScript）
(leetcode) 力扣100 15轮转数组（环状替代）
qq_62235017的博客
12-18 979
我们利用这个过程，首先计算需要多少个从起点走回起点的圈数（count，为数组长度与步数的最大公约数，具体推推导后面会给），然后再遍历每一圈，通过创建一个临时变量（current,next，类似于指针的作用），来存储需要移动的变量将其移动到下一个位置，而下一个位置变为信的需移动变量，直到走完当前圈数。我们可以把数组想象一个圆圈，如果我们每次固定步数前进，肯定会在有限圈数回到出发点，这个过程中，有可能会遍历完数组所有数，有可能遍历有限数。这句话的意思是：在这个游戏中，你启动一次任务，只能覆盖到。
2019年LeetCode-100天挑战经验分享及开源项目更新
资源摘要信息:"LeetCode-100DAY-Challenge是个人为提升编程技能而设立的挑战活动，发起者在2019年12月5日开始了一系列的编程练习，这些练习通常设计为算法和数据结构方面的编程题目。这次挑战活动，对于参与者而言，...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值