【日常系列】LeetCode《13·综合应用1》

常某某的好奇心

已于 2023-02-16 23:42:28 修改

阅读量365

点赞数

分类专栏：《数据结构与算法入门》文章标签： leetcode 算法职场和发展

于 2022-10-05 20:14:55 首次发布

本文链接：https://blog.csdn.net/qq_42889517/article/details/126907937

版权

《数据结构与算法入门》专栏收录该内容

37 篇文章 0 订阅

订阅专栏

数据规模->时间复杂度

<=10^4 😮(n^2)
<=10^7:o(nlogn)
<=10^8:o(n)
10^8<=:o(logn),o(1)

综合 <直接模拟、经典查找>

在这里插入图片描述

lc 1【top100】：两数之和
https://leetcode.cn/problems/two-sum/
提示：
2 <= nums.length <= 10^4
-10^9 <= nums[i] <= 10^9
-10^9 <= target <= 10^9
只会存在一个有效答案
进阶：
你可以想出一个时间复杂度小于 O(n^2) 的算法吗？

#方案一：线性查找
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
    	#o(1),o(n^2)
        for i in range(len(nums)):
            for j in range(i+1,len(nums)):
                if nums[i]+nums[j]==target:
                    return [i,j]
        return -1
        
#方案二：排序二分查找->hash查找
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        #o(n),o(2n)
        #预处理 
        hashmap={}
        hashmap = {x: i for i, x in enumerate(nums)}
        #
        for i in range(len(nums)):
            x=nums[i]
            if target-x in hashmap:
                j=hashmap[target-x]
                if j!= i:
                   return [i,j]
        return -1 
        
#方案三:hash查找优化
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        #o(n)
        hashmap={}
        #o(n)
        for i in range(len(nums)):
            x=nums[i]
            if target-x in hashmap:
                j=hashmap[target-x]
                #if j!= i: 不需要
                return [i,j]
            hashmap[nums[i]]=i
        return -1

lc 167【剑指 006】：两数之和：输入有序数组
https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted/
提示：
2 <= numbers.length <= 3 * 10^4
-1000 <= numbers[i] <= 1000
numbers 按非递减顺序排列
-1000 <= target <= 1000
仅存在一个有效答案

#方案一：二分查找法
class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        n=len(numbers)
        for i in range(n):
            x=numbers[i]
            #O(logn),O(1)
            index=self.bi_search(numbers,i+1,n-1,target-x)
            if index!=-1:return [i+1,index+1]#题目首位为1
        return []
    
    def bi_search(self,numbers,left,right,t):
        while left<=right:
            mid=left+(right-left)//2
            if numbers[mid]==t:return mid
            elif numbers[mid]>t:right=mid-1
            else:left=mid+1
        return -1

#方案二：双指针法
class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        left,right=0,len(numbers)-1
        #o(n),o(1)
        while left<right:
            s=numbers[left]+numbers[right]
            if target==s:return [left+1,right+1]
            elif target>s:left=left+1
            else:right=right-1
        return []

lc 170：两数之和：数据结构设计
https://leetcode.cn/problems/two-sum-iii-data-structure-design/

#方案一：二分查找
class TwoSum:

    def __init__(self):
        self.numbers=[]
        self.is_sorted=False

    def add(self, number: int) -> None:
        self.numbers.append(number)
        self.is_sorted=False

    def find(self, value: int) -> bool:
        #o(nlogn),o(n)
        if not self.is_sorted:
            self.numbers.sort()
            self.is_sorted=True
        #
        left,right=0,len(self.numbers)-1
        while left < right:
            s = self.numbers[left] + self.numbers[right]
            if s ==value:return True
            elif s<value:left += 1
            else:right -= 1
        return False

# Your TwoSum object will be instantiated and called as such:
# obj = TwoSum()
# obj.add(number)
# param_2 = obj.find(value)

#方案二：hash查找
class TwoSum:
    def __init__(self):
        self.numbers=dict()
  
    def add(self, number: int) -> None:
        if number in self.numbers:self.numbers[number]+=1
        else:self.numbers[number]=1
    
    def find(self, value: int) -> bool:
        #o(n),o(n)
        for num in self.numbers.keys():
            t=value-num
            if t==num and self.numbers[t]>=2:return True
            elif t!=num and t in self.numbers:return True
        return False

# Your TwoSum object will be instantiated and called as such:
# obj = TwoSum()
# obj.add(number)
# param_2 = obj.find(value)

lc 653：两数之和：输入 BST
https://leetcode.cn/problems/two-sum-iv-input-is-a-bst/
提示:
二叉树的节点个数的范围是 [1, 10^4].
-10^4 <= Node.val <= 10^4
题目数据保证，输入的 root 是一棵有效的二叉搜索树
-10^5 <= k <= 10^5

#方案一:二分查找
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findTarget(self, root: Optional[TreeNode], k: int) -> bool:
        #o(n)
        nums=[]  
        #中序遍历：o(n)
        def inorder(node):
            if not node:return 
            inorder(node.left)
            nums.append(node.val)
            inorder(node.right)
        inorder(root)
        #
        left,right=0,len(nums)-1
        while left<right:
            s=nums[left]+nums[right]
            if s==k:return True
            elif s>k:right-=1
            else:left+=1
        return False

#方案二：一次遍历hash查找
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findTarget(self, root: Optional[TreeNode], k: int) -> bool:
        #o(n),o(n)
        s=set()
        #DFS
        def find(node):
            if not node:return False
            if k-node.val in s:return True
            s.add(node.val)
            return find(node.left) or find(node.right) #key
        return find(root) #return

lc 15【剑指 007】【top100】：三数之和
https://leetcode.cn/problems/3sum/
提示：
3 <= nums.length <= 3000
-10^5 <= nums[i] <= 10^5

#方案一：二分查找(去重技巧)
class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        #
        nums.sort()
        res=[]
        #o(n^2)
        for i in range(len(nums)-2):
            #去重1
            if i>=1 and nums[i]==nums[i-1]:continue
            #
            t=-nums[i]
            left,right=i+1,len(nums)-1
            while left<right:
                s=nums[left]+nums[right]
                if s==t:
                    res.append([nums[i],nums[left],nums[right]])
                    #去重2
                    #写法1
                    # while left < right:
                    #     left = left + 1
                    #     if nums[left - 1] != nums[left]: break
                    # while left < right:
                    #     right = right - 1
                    #     if nums[right + 1] != nums[right]: break
                    #写法2
                    while left<right and nums[left]==nums[left+1]:left+=1
                    left+=1
                    while left<right and nums[right]==nums[right-1]:right-=1
                    right-1
                #
                elif s>t:right-=1
                else:left+=1
        return res

lc 18 ：四数之和
https://leetcode.cn/problems/4sum/
提示：
1 <= nums.length <= 200
-10^9 <= nums[i] <= 10^9
-10^9 <= target <= 10^9

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        #
        nums.sort()
        res = []
        #o(n^3)
        for i in range(len(nums) - 3):
            #去重1
            if i>=1 and nums[i]==nums[i-1]:continue
            for j in range(i+1,len(nums)-2):
                #去重2
                if j>=i+2 and nums[j]==nums[j-1]:continue
                #
                s1=nums[i]+nums[j]
                left,right=j+1,len(nums)-1
                while left<right:
                    s=s1+nums[left]+nums[right]
                    if s==target:
                        res.append([nums[i],nums[j],nums[left],nums[right]])
                        #去重3
                        while left<right and nums[left]==nums[left+1]:left+=1
                        left+=1
                        while left<right and nums[right]==nums[right-1]:right-=1
                        right-=1
                    elif s>target:
                        right-=1
                    else:left+=1
        return res

lc 349 : 两个数组的交集
https://leetcode.cn/problems/intersection-of-two-arrays/
提示：【去重】
1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000

#方案一：线性查找
class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        #o(m*n),o(min(m,n))
        res=set()
        for n1 in nums1:
            for n2 in nums2:
                if n1==n2:
                    res.add(n1)
        return list(res) #key 
#方案二：二分查找
class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        #o(nlogn+mlogn),o(min(m,n))
        res=set()
        nums2.sort() #nlogn
        for n1 in nums1:
            #o(logn)
            if self.contain(nums2,n1):
                res.add(n1)
        return list(res) #key

    def contain(self,nums,t):
        left,right=0,len(nums)-1
        while left<=right:
            mid=left+(right-left)//2 
            if nums[mid]==t:return True
            elif nums[mid]>t:right=mid-1
            else:left=mid+1
        return False

#方案三：hash查找
class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        #o(n+m),o(min(m,n)+n)
        res=set()#o(min(m,n))
        set2=set(nums2) #o(n),o(n)
        #o(m)
        for n1 in nums1:
            #o(1)
            if n1 in set2:
                res.add(n1)
        #
        return list(res)

#方案四：双指针排序去重
class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        #o(nlogn+mlogm),o(min(m,n))
        res=[]
        nums1.sort()
        nums2.sort()
        #
        i=j=0
        while i<len(nums1) and j<len(nums2):
            if nums1[i]==nums2[j]:
                if len(res)==0 or nums1[i]!=res[-1]:
                    res.append(nums1[i])
                #注:位置
                i+=1
                j+=1
            elif nums1[i]>nums2[j]:
                j+=1
            else:i+=1
        return res

lc 350 ：两个数组的交集 II
https://leetcode.cn/problems/intersection-of-two-arrays-ii/
提示：【不去重】
1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000
进阶：
如果给定的数组已经排好序呢？你将如何优化你的算法？
如果 nums1 的大小比 nums2 小，哪种方法更优？
如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

#方案一：哈希查找
class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        #o(min(m,n)+n),o(m+n)
        res=[]
        map1={num:0 for num in nums1}
        for num in nums1:map1[num]+=1
        #
        for n in nums2:
            if n in map1 and map1.get(n)>0:
                res.append(n)
                map1[n]-=1
        #
        return res
#方案二：二分查找
class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        #o(),o(m+n)
        res=[]
        nums1.sort()
        nums2.sort()
        #
        i=0
        while i<len(nums1):
            #第一个等
            lowerI=self.firstTindex(nums2,nums1[i])
            if lowerI==-1:
                i+=1
                continue
            #nums2中统计等的个数
            cnt=0
            while lowerI<len(nums2) and nums2[lowerI]==nums1[i]:
                cnt+=1
                lowerI+=1
            #nums1中处理等元素
            j=i
            index=0
            while j<len(nums1) and nums1[j]==nums1[i]:
                j+=1
                if cnt>0:
                    res.append(nums1[i]) #注：不是nums[j]
                    cnt-=1
            #key:下一轮
            i=j
        #
        return res

    def firstTindex(self,nums,T):
        left,right=0,len(nums)-1
        while left<right:
            mid=left+(right-left)//2
            if nums[mid]<T:
                left=mid+1
            else:right=mid
        if nums[left]==T:return left
        return -1
        
#方案三：排序双指针查找
class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        #
        res=[]
        nums1.sort()
        nums2.sort()
        #o(max(m,n)),o(min(m,n))
        index=0
        i=j=0
        while i<len(nums1) and j<len(nums2):
            if nums1[i]==nums2[j]:
                res.append(nums1[i])
                i+=1
                j+=1
            elif nums1[i]>nums2[j]:
                j+=1
            else:i+=1
        return res  
          
#进阶：2和3
如果 nums1 的大小比 nums2 小，哪种方法更优？nums1做hashmap，方案一最优
如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？外部排序+双指针方案

lc 169 【剑指 39】【top100】：多数元素
https://leetcode.cn/problems/majority-element/
提示：
n == nums.length
1 <= n <= 5 * 10^4
-10^9 <= nums[i] <= 10^9
进阶：
尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。

#方案一：哈希查找-排序查找-堆查找-快速排序
#hash查找
class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        #o(n),o(n)
        Map={num:0 for num in nums}
        for num in nums:
            Map[num]+=1
            if Map[num]> len(nums)//2:
                return num
#排序查找
class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        #时：o(nlogn)
        #空：快排o(logn)归并o(n)
        nums.sort()
        return nums[len(nums)//2]
        
#堆查找（大顶堆：查找第k小元素）
class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        #时：o(nlogn),空：o(n/2)
        k=len(nums)//2 +1
        #
        pq=[]
        for num in nums:
            if len(pq)<k:
                heapq.heappush(pq,num)
            else:heapq.heappushpop(pq,num)
        return pq[0]

#快排

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        #时：o(n),空：o(1)
        n=len(nums)
        left,right=0,n-1
        T=n//2
        while True:
            p=self.partition(nums,left,right)
            if p==T:return nums[p]
            elif p<T:left=p+1
            else:right=p-1
 
    def partition(self,nums,lo,hi):
        #
        i=random.randint(lo,hi)
        nums[i],nums[hi]=nums[hi],nums[i]
        pivot=nums[hi]
        #
        less=great=lo
        while great<hi:
            if nums[great]<pivot:
                nums[less],nums[great]=nums[great],nums[less]
                less+=1
            great+=1
        nums[less],nums[hi]=nums[hi],nums[less]
        return less
        
#方案二：分治解法
class Solution:
    #时：O(nlogn-合并中含有计数比较)，空：O(logn)
    def majorityElement(self, nums: List[int]) -> int:
        return self.majorityElement1(nums,0,len(nums)-1) #return
    
    def majorityElement1(self,nums,lo,hi):
        #
        if lo==hi:return nums[lo]
        #
        mid=lo+(hi-lo)//2
        leftnum=self.majorityElement1(nums,lo,mid) #o(logn)
        rightnum=self.majorityElement1(nums,mid+1,hi)
        #
        if leftnum==rightnum:return leftnum
        cntleftnum=self.cntInrange(nums,leftnum,lo,mid) #o(n)
        cntrightnum=self.cntInrange(nums,rightnum,mid+1,hi)
        return leftnum if cntleftnum>cntrightnum else rightnum 

    def cntInrange(self,nums,num,lo,hi):
        cnt=0
        for i in range(lo,hi+1):#hi+1
            if nums[i]==num:cnt+=1
        return cnt
        
#方案三：摩尔投票法
#你可以假设数组是非空的，并且给定的数组总是存在多数元素
class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        #时：o(n),空：o(1)
        candidate=-1
        cnt=0
        for num in nums:
            if cnt==0:
                candidate=num
                cnt+=1
            elif num==candidate:
                cnt+=1
            else:
                cnt-=1
        return candidate

lc 229 ：多数元素变形题
https://leetcode.cn/problems/majority-element-ii/
提示：
1 <= nums.length <= 5 * 10^4
-10^9 <= nums[i] <= 10^9
进阶：
尝试设计时间复杂度为 O(n)、空间复杂度为 O(1)的算法解决此问题。

#题目未假设数组是非空的，并且给定的数组总是存在多数元素

#方案一：摩尔投票
class Solution:
    def majorityElement(self, nums: List[int]) -> List[int]:
        #o(n),o(1)
        candidate1=cnt1=0
        candidate2=cnt2=0
        for num in nums:
            if candidate1==num:
                cnt1+=1
            elif candidate2==num:
                 cnt2+=1
            #注：位置
            elif cnt1==0:
                candidate1=num
                cnt1+=1
            elif cnt2==0:
                candidate2=num
                cnt2+=1
            else:
                cnt1-=1
                cnt2-=1
        #
        cnt1=cnt2=0
        res=[]
        for num in nums:
            if num==candidate1:cnt1+=1
            elif num==candidate2:cnt2+=1
        if cnt1 > len(nums)//3:res.append(candidate1)
        if cnt2 > len(nums)//3:res.append(candidate2)
        #
        return res
#方案二：hash查找
class Solution:
    def majorityElement(self, nums: List[int]) -> List[int]:
        #o(n),o(n)
        res=[]
        Map={num:0 for num in nums}
        for num in nums:
            Map[num]+=1
        #
        for k in Map.keys():
            if Map.get(k)>len(nums)//3:
                res.append(k)
        return res

lc 844：比较含退格的字符串
https://leetcode.cn/problems/backspace-string-compare/
提示：
1 <= s.length, t.length <= 200
s 和 t 只含有小写字母以及字符 ‘#’
进阶：
你可以用 O(n) 的时间复杂度和 O(1) 的空间复杂度解决该问题吗？

#方案一：使用栈重建字符串(先进后出)
class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        #o(m+n),o(m+n)
        return self.build(s)==self.build(t)
    
    def build(self,s):
        res=list() #[] 
        for c in s:
            if c!='#':
                res.append(c)
            elif res:#非空
                res.pop()
        return ''.join(res)
        
#方案二：快慢指针（从前至后）重建字符串
class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        #o(m+n),o(1)
        return self.build(s)==self.build(t)
    
    def build(self,s):
        s=list(s)
        slow=-1
        fast=0
        while fast<len(s):
            if s[fast]!='#':
                slow+=1
                if fast != slow:s[slow],s[fast]=s[fast],s[slow]
            elif slow>-1:
                slow-=1
            fast+=1
        return s[0:slow+1] if slow!=-1 else ''

#方案四：双指针（从后至前）重建字符串
class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        #o(m+n),o(1)
        s=list(s)
        t=list(t)
        i,j=len(s)-1,len(t)-1
        skipS=skipT=0
        while i>=0 or j>=0: #key：or
            #s串
            while i>=0:
                if s[i]=='#':
                    skipS+=1
                    i-=1
                elif skipS>0:
                    skipS-=1
                    i-=1
                else:
                    break
            #t串 
            while j>=0:
                if t[j]=='#':
                    skipT+=1
                    j-=1
                elif skipT>0:
                    skipT-=1
                    j-=1
                else:
                    break
            #key
            if i >= 0 and j >= 0 and s[i]!=t[j]:return False
            if (i>=0) != (j>=0):return False #一个已到头
            i-=1
            j-=1
        return True

lc 318 【剑指 005】：最大单词长度乘积
https://leetcode.cn/problems/maximum-product-of-word-lengths/
提示：
2 <= words.length <= 1000
1 <= words[i].length <= 1000
words[i] 仅包含小写字母
这两个单词不含有公共字母

#方案一：暴力
#方案二：计数优化
#方案三:位运算+预计算
class Solution:
    def maxProduct(self, words: List[str]) -> int:
        #o(mn+n^2),o(n)
        #o(mn)预计算masks:单词表达
        n=len(words)
        masks=[0]*n
        for i in range(n):
            bitmask=0
            for c in words[i]:
                bitmask |=1<<(ord(c)-ord('a'))
            masks[i]=bitmask
        #o(n^2)比较
        ans=0
        for i in range(n):
            word1=words[i]
            for j in range(i+1,n):
                word2=words[j]
                if (masks[i]&masks[j])==0:
                    ans=max(ans,len(word1)*len(word2))
        return ans
        
#方案四：位运算+预计算改进（key:相同的bitmask对应不同单词）
class Solution:
    def maxProduct(self, words: List[str]) -> int:
        #o(mn+n^2),o(n)
        
        #o(mn)预计算masks:单词表达
        n=len(words)
        map_masks={}
        for i in range(n):
            bitmask=0
            for c in words[i]:
                bitmask |=1<<(ord(c)-ord('a'))
            #key:同bitmask可能对应不同长度单词
            map_masks[bitmask]=max(map_masks[bitmask],len(words[i])) if bitmask in map_masks else len(words[i])
        #o(n^2)比较
        ans=0
        for x in map_masks.keys():
            for y in map_masks.keys():
                if x&y == 0: #若x==y,x&y==1
                    ans=max(ans,map_masks[x]*map_masks[y])
        return ans

lc 14：最长公共前缀
https://leetcode.cn/problems/longest-common-prefix/
提示：
1 <= strs.length <= 200
0 <= strs[i].length <= 200
strs[i] 仅由小写英文字母组成

#方案一：纵向
class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        #
        if len(strs)==0:return ''
        #o(mn),o(1)
        for j in range(len(strs[0])):
            char=strs[0][j]
            for i in range(1,len(strs)):
                #终止条件
                if len(strs[i])-1 < j or strs[i][j] != char:
                    return strs[0][:j]
        #key:一直未终止
        return strs[0]
        
#方案二：横向
class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        #
        if len(strs)==0:return ''
        #o(mn),o(1)
        prefix=strs[0]
        for i in range(1,len(strs)):
            prefix=self.maxlcommonprefix(prefix,strs[i])
            if len(prefix)==0:return ''
        return prefix

    def maxlcommonprefix(self,str1,str2):
        m=min(len(str1),len(str2))
        i=0
        while i<m:
            if str1[i]!=str2[i]:break
            i+=1
        return str1[:i]
      
方案三：分治
class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        #
        if len(strs)==0:return ''
        #o(mn),o(mlogn) m-平均长度 n-字符个数
        return self.largestcommonprefix(strs,0,len(strs)-1)

    def largestcommonprefix(self,strs,left,right):
        #终止条件：不可分
        if left==right:
            return strs[left]
        #分
        mid=left+(right-left)//2
        left_w=self.largestcommonprefix(strs,left,mid)
        right_w=self.largestcommonprefix(strs,mid+1,right)
        #治
        return self.maxlcommonprefix(left_w,right_w)

    def maxlcommonprefix(self,str1,str2):
        m=min(len(str1),len(str2))
        i=0
        while i<m:
            if str1[i]!=str2[i]:break
            i+=1
        return str1[:i]

常某某的好奇心

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【日常系列】LeetCode《13·综合应用1》

如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。尝试设计时间复杂度为 O(n)、空间复杂度为 O(1)的算法解决此问题。你可以用 O(n) 的时间复杂度和 O(1) 的空间复杂度解决该问题吗？#题目未假设数组是非空的，并且给定的数组总是存在多数元素。lc 167【剑指 006】：两数之和：输入有序数组。lc 15【剑指 007】【top100】：三数之和。你将如何优化你的算法？
复制链接

扫一扫