LeetCode —— python3

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

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

主要用到 滑动窗口，定义窗口左边元素的下标，窗口长度，和最大窗口长度。 不满足要求时只需要把最左边的元素移出来，遍历整个字符串得到最大窗口长度。

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        if not s:
            return 0
        left, cur_len, max_len = 0, 0, 0
        lookup = set()
        for i in range(len(s)):
            cur_len += 1
            while s[i] in lookup:
                lookup.remove(s[left])
                left += 1
                cur_len -=1
            if cur_len > max_len:
                max_len = cur_len
            lookup.add(s[i])
        return max_len

 

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

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

采用 递归法 ，首先将两个数组分别两等分，将数组 A 和数组 B 的左半部分看成一个整体 left ，其右半部分看成一个整体 right ，这样 left 和 right 两部分长度相同，在此基础上判断 max_left 和 min_right 的大小关系。之后调整 A_left 和 B_left 的长度（调整 A_left 时,B_left 必然也会改变，因为前提是 left 和 right 的长度相同），使得 max_left ＜ min_right 。最后根据 m+n 是奇数还是偶数，分情况求出中位数。具体题解

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        A, B = nums1, nums2
        m, n = len(A), len(B)
        if m > n:
            A, B, m, n = B, A, n, m 
        if n == 0:
            return 0
        
        imin, imax, half_len = 0, m, (m + n + 1) // 2
        while imin <= imax:
            i = (imin + imax) // 2
            j = half_len - i
            if i < m and B[j-1] > A[i]:
                imin = i + 1
            elif i > 0 and A[i-1] > B[j]:
                imax = i - 1
            else:
                if i == 0:
                    max_of_left = B[j-1]
                elif j == 0:
                    max_of_left = A[i-1]
                else:
                    max_of_left = max(A[i-1], B[j-1])
               
                if (m + n) % 2 == 1 :
                        return max_of_left
               
                if i == m:
                    min_of_right = B[j]
                elif j == n:
                    min_of_right = A[i]
                else:
                    min_of_right = min(A[i], B[j])
            
                return (max_of_left + min_of_right) / 2

 

5. 最长回文子串

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

“动态规划”，1.定义状态，2.找到状态转移方程。 考虑字符串长度≤1时，本身就是一个最长回文串。窗口区间可以先定义 right，left 便限制在range(right)中。

class Solution:
    def longestPalindrome(self, s: str) -> str:
        size = len(s)
        if size <= 1:
            return s
        dp = [[False for i in range(size)] for j in range(size)]
        max_len = 1
        res = s[0]
        for right in range(1, size):
            for left in range(right):
                if s[left] == s[right] and (right - left <= 2 or dp[left + 1][right - 1]):
                    dp[left][right] = True
                    cur_len = right - left + 1
                    if cur_len > max_len :
                        max_len = cur_len
                        res = s[left:right+1]
        return res
                        

 

6. Z 字形变换

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

s_Initialize = ['' for i in range(numRows)] 和 s_Initialize = [''] * numRows 是等价的；join()：连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串

class Solution:
    def convert(self, s: str, numRows: int) -> str:
        if numRows <= 1:
            return s
        if numRows == 2:
            s1 = s[::2]
            s2 = s[1::2]
            s3 = s1 + s2
            return s3
        s_Initialize = ['' for i in range(numRows)]
        #  s_Initialize = [''] * numRows
        i = 0
        n = len(s)
        while i < n:
            for count_columns in range(numRows):
                if i < n:
                    s_Initialize[count_columns] += s[i]
                    i += 1
            for count_Rows in range(numRows-2, 0, -1):
                if i < n:
                    s_Initialize[count_Rows] += s[i]
                    i += 1
        return ''.join(s_Initialize)