datawhale-leetcode打卡 第013-025题

搜索旋转排序数组（leetcode-033）

这道题非常简单，基本送分，之前做的代码还能用上

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        try:
            return nums.index(target)
        except:
            return -1

寻找峰值（leetcode-162）

它的本质是一个搜索，例如：

class Solution:
    def findPeakElement(self, nums: List[int]) -> int:
        for i in range(1,len(nums)-1):
            if nums[i]>nums[i-1] and nums[i]>nums[i+1]:
                return i
        if nums[0]>nums[-1]:
            return 0
        else:
            return len(nums)-1

寻找两个数组的中位数（leetcode 004）

本质上是一个归并排序问题。当然这个题因为两个数组有序，其实可以不用归并排序法做，只需要找到两个数组各自的中位数，然后看谁更大，对应的一个往左移一个右移

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        l=nums1+nums2
        l.sort()
        if len(l)%2:
            return float(l[len(l)//2])
        else:
            return (l[len(l)//2]+l[len(l)//2-1])/2

搜寻二维数组（leetcode 240）

这个题的本质就是搜索，python使用in是很好实现的。

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        for line in matrix:
            if target in line:
                return True
        return False

实现平方根（leetcode 069）

解出一个数的平方根这个其实并不难。我是做数学建模出身的，让我们回顾到《数学建模导论》第三章3.6节的数值计算方法。假设\(\sqrt(x)=a\)，那么问题也就是解方程：

\[a^2-x=0
\]

我们令\(f(a)=a^2-x\)，那么可以基于牛顿法解得结果。牛顿法的迭代公式为：

\[x_{n+1}=x_{n}-\frac{f(x_n)}{f'(x_n)}
\]

这里精度要求没有特别高，迭代10次以内必然是可以求出来的。

class Solution:
    def mySqrt(self, x: int) -> int:
        a=1
        for i in range(5):
            a=a-(a*a-x)/(2*a)
        return int(a)

我超，原来它要返回整数啊，那我还求什么平方根，直接遍历就好了。

移动零（leetcode 283）

这个题的话，数组元素遇到0则循环左移，记录零的个数，然后把数组末尾修改就好了。

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        n=len(nums)
        count=0
        for i in range(n):
            if nums[i]==0:
                count+=1
                for j in range(i+1,n):
                    nums[j-1]=nums[j]
        for i in range(count):
            nums[-1-i]=0

字符串相加（leetcode 415）

等等，这个题只是让我不能用大整数库，不能把字符转整数，没说不能用eval指令吧（笑）

那要这么说的话，我可就有活可整了

class Solution:
    def addStrings(self, num1: str, num2: str) -> str:
        return str(eval(num1+'+'+num2))

当然，这个题其实你要做的话就设计按位加法和进位就可以了。大家都是学习过计算机组成原理的人，串行进位加法器这个还是能够设计的。

滑动窗口最大值（leetcode 239）

这个有什么很困难的吗，一顺的往下遍历就好了啊，如果窗口比数组还长就返回自己，否则就一个个遍历啊

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        slide=[]
        if k>=len(nums):
            return nums
        for i in range(len(nums)-k+1):
            slide.append(max(nums[i:i+k]))
        return slide

无重复子串（leetcode 003）

这一题就是典型的队列应用了。可以用滑动窗口法，如果后一个字符可以加进来，窗口长度+1；如果加进来重复，就队列出队

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        i,j=0,1
        count=[1]
        if s[j] not in s[i:j]:
            j+=1
            count.append(len(s[i:j+1]))
        else:
            i+=1
        return max(count)

最小覆盖子串（leetcode 076）

其实还是滑动窗口的思想，代码框架比较类似，用字典记录然后查找就好了

class Solution:
    def minWindow(self, s: str, t: str) -> str:
        n = len(s)
        left = 0
        need = {}  # 字典记录满足条件的目标字符 char     int
        need_cnt = len(t)  # 记录目标字符个数
        l_min = 0
        r_min = n + 1 # 记录最短子串右端下标

        for c in t:
            need[c] = need.get(c, 0) + 1

        for right, c in enumerate(s):  # c = s[right]
            if c in need:
                need[c] -= 1
                if need[c] >= 0: # 减一后大于等于 0，及时更新
                    need_cnt -= 1

            while need_cnt == 0: # 满足条件，记录答案，收缩左端点
                if right - left < r_min - l_min:
                    r_min = right
                    l_min = left
                if s[left] in need:
                    need[s[left]] += 1
                    if need[s[left]] > 0:
                        need_cnt += 1
                left += 1

        if r_min == n + 1: # j 没更新
            return ""
        else:
            return s[l_min : r_min + 1]

最长子数组（leetcode 812）

这个题和最长子串其实是一回事，所以确定是考动态规划。但是动态规划这个东西一直不太会，还是要借助一下题解：

class Solution:
    def findLength(self, A, B):
        m, n = len(A), len(B)
        ans = 0
        dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if A[i - 1] == B[j - 1]:
                    dp[i][j] = dp[i - 1][j - 1] + 1
                    ans = max(ans, dp[i][j])
        return ans

删除链表中的重复元素（leetcode 082）

这个问题是数据结构比较基础的东西，但是链表其实还是C可能更好实现一些，Python的面向对象版本链表总感觉差点味道。代码就参考以前C版本去改就可以了。

class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        p=[]
        while head:
            if head.val not in p:
                p.append(head.val)
            head=head.next
        s=[ListNode(val=i) for i in p]
        for i in range(len(s)-1):
            s[i].next=s[i+1]
        return s[0]

删除链表中的重复元素II（leetcode 083）

问题在于，有重复的元素都会被删除，如何统计有无重复？我想了个办法，比较烧，就是把链表转成数组处理以后再转回去。

class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        p=[]
        while head.next:
            p.append(head.val)
            head=head.next
        p.append(head.val)
        r=[]
        for i in p:
            if p.count(i)==1:
                r.append(i)
        print(r)
        s=[ListNode(val=i) for i in r]
        for i in range(len(s)-1):
            s[i].next=s[i+1]
        return s[0]