leetcode 狂刷 day01

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

from typing import List
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        occ = dict()
        for i,num in enumerate(nums):
            if target - num in occ:
                return [occ[target-num],i]
            occ[num] = i

s = Solution()
print(s.twoSum([2,7,11,15],9))

在这里要注意一点，更新occ字典要放在判断的后面！！！

2. 两数相加

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

输入：l1 = [2,4,3], l2 = [5,6,4]

输出：[7,0,8]

解释：342 + 465 = 807.

from typing import Optional
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        if not l1:
            return l2
        if not l2:
            return l1
        l1.val += l2.val
        if l1.val >= 10:
            l1.next = self.addTwoNumbers(ListNode(l1.val // 10),l1.next)
            l1.val %= 10
        l1.next = self.addTwoNumbers(l1.next,l2.next)
        return l1
s = Solution()
print('ok')

来不及写一些测试运例，而且python的ListNode也要自己写

3. 无重复字符的最长子串

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        occ = set()
        n = len(s)
        ans = 0
        rk = -1
        for i in range(n):
            if i != 0:
                occ.remove(s[i-1])
            while rk + 1 < n and s[rk+1] not in occ:
                occ.add(s[rk+1])
                rk += 1
            ans = max(ans,rk-i+1)
        return ans
s = Solution()
print(s.lengthOfLongestSubstring('absbsbdnam'))

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

4. 寻找两个正序数组的中位数

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

算法的时间复杂度应该为 O(log (m+n)) 。

输入：nums1 = [1,3], nums2 = [2]

输出：2.00000

解释：合并数组 = [1,2,3] ，中位数 2

from typing import List
class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        def findKthelem(k:int):
            index1,index2 = 0,0
            while True:
                if index1 == m:
                    return nums2[index2+k-1]
                if index2 == n:
                    return nums1[index1+k-1]
                if k == 1:
                    return min(nums1[index1],nums2[index2])
                newIndex1 = min(index1+k//2-1,m-1)
                newIndex2 = min(index2+k//2-1,n-1)
                privot1,privot2 = nums1[newIndex1],nums2[newIndex2]
                if privot1 <= privot2:
                    k -= newIndex1 - index1 + 1
                    index1 = newIndex1 + 1
                else:
                    index2 = newIndex2 + 1

        m,n = len(nums1),len(nums2)
        total = m + n
        if total % 2 == 1:
            return findKthelem((total+1) // 2)
        else:
            return (findKthelem(total // 2) + findKthelem(total // 2 + 1))/2
s = Solution()
print(s.findMedianSortedArrays([1,2],[3,4]))

index1,newIndex1,index2,newIndex2那里看的不是很清楚！！！还得之后再研究

5. 最长回文子串

给你一个字符串 s，找到 s 中最长的回文子串。

如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。

采用动态规划的方式

class Solution:
    def longestPalindrome(self, s: str) -> str:
        n = len(s)
        if n < 2:
            return s
        begin = 0
        max_len = 0
        dp = [[False]*n for _ in range(n)]
        for i in range(n):
            dp[i][i] = True
        for L in range(2,n+1):
            for i in range(n):
                j = L + i -1
                if j >= n:
                    break
                if s[i] != s[j]:
                    dp[i][j] = False
                else:
                    if j - i < 3:
                        dp[i][j] = True
                    else:
                        dp[i][j] = dp[i+1][j-1]
                if dp[i][j] and j-i+1 > max_len:
                    max_len = j-i+1
                    begin = i
        return s[begin:begin+max_len]
s = Solution()
print(s.longestPalindrome("babad"))

6. N字形变换

将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。

比如输入字符串为 "PAYPALISHIRING" 行数为 3 时，排列如下：

示例 1：

输入：s = "PAYPALISHIRING", numRows = 3

输出："PAHNAPLSIIGYIR"

class Solution:
    def convert(self, s: str, numRows: int) -> str:
        r = numRows
        n = len(s)
        ans = []
        # N字周期
        t = 2 * r - 2
        for i in range(r):
            for j in range(0,n-i,t):
                ans.append(s[j+i])
                if 0 < i < r-1 and j + t -i < n:
                    ans.append(s[j + t - i])
        return ''.join(ans)
s = Solution()
print(s.convert('PAYPALISHIRING',3))