记录一下python-leetcode(一)

一、Longest Substring Without Repeating Characters
描述:给定一个字符串,找到不含有重复字符的最长子串的长度
最简单的方法,双循环,从每个字符开始找到最长子串,然后输出最长的那个

def Longeststring(s):
    k = [] #存放不重复字符
    w = [] #存放长度
    longth = 0
    if len(s) == 0:
        return 0
    if len(s) == 1:
        return 1
    for j in range(len(s) - 1):
        for i in range(j, len(s)):
            if i == len(s) - 1 and s[i] not in k:
                longth += 1
                w.append(longth)
                return max(w)
            if s[i] not in k:
                longth += 1
                k.append(s[i])
            else:
                w.append(longth)
                longth = 0
                k.clear() #当找到重复字符的时候把k clear
    return max(w)

改进版:

def lengthOfLongestSubstring(self, s: str) -> int:
    dict = {} #存放不同字符串
    longth = 0 #不重复的长度长度
    start = 0 #开始的位置
    for index, item in enumerate(s):
        if item in dict:
            longth = max(longth, index - start) #如何找到了重复字符,更新长度
            start = max(start, dict[item] + 1) #更新开始的位置
        dict[item] = index #更新字典
    return max(longth, len(s) - start)

速度大概是暴力枚举的50分之一
二、Median of Two Sorted Arrays
描述:给定两个排好序的数组,找到两个数组的中位数,假定2个数组长度为n,m,时间复杂度应该为: O(log (m+n))
例如:a=[1,2] b=[3] 输出:2
a=[1, 2] b=[3,4] 输出:(2+3)/ 2 = 2.5
解决方法:

def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        # 组合后的数组长度为偶数: ((mid) + (mid+1)) / 2
        # 长度为奇数输出 merged[len(merged)//2]
        # 比较困难的是排序时间复杂度为 O(n+m). 但是得达到O(log(n+m))
        def merge(A, B):
            i, j = 0, 0
            res = []
            while i < len(A) and j < len(B):
                if A[i] <= B[j]:
                    res.append(A[i])
                    i += 1
                else:
                    res.append(B[j])
                    j += 1
            if i < len(A): 
            	 res += A[i:] #如果B完事了,直接把A全部append
            if j < len(B):
            	 res += B[j:]
            return res
        merged = merge(nums1, nums2)
        mid = (len(merged) - 1) // 2
        if len(merged) % 2 == 0:
            return (merged[mid] + merged[mid + 1]) / 2
        else:
            return merged[mid]

我也试了一下直接用sorted直接重新排序A+B,答案也通过了,而且运行时间还更快,不得不说底层语言实现的归并排序还是更快点


def findMedianSortedArrays(self, nums1, nums2):
    x = sorted(nums1 + nums2)
    median = None
    n = len(x) // 2
    if len(x) % 2 == 1:
        median = x[n]
    else:
        median = (x[n] + x[n - 1]) / 2
    return median

三、Longest Palindromic Substring
描述:给定一个字符串,找到其中最长的对称子串,保证s的长度最大为1000
例如:“abcbbcca” 输出为:bbcc

def longestPalindrome(self, s):
    if len(s) < 2 or s == s[::-1]: #处理最简单的状况
        return s
    max_len = 1
    start = 0
    for i in range(1, len(s)):
        even = s[i - max_len: i + 1]
        odd = s[i - max_len - 1: i + 1]
        if i - max_len - 1 >= 0 and odd == odd[::-1]:
            start = i - max_len - 1 # 记录开始的位置
            max_len += 2  # 不看max_len 长度差2,所以+2
            continue  # 由于even跟odd长度只差了1,所以满足前者不可能满足后面的条件,所以直接continue
        if i - max_len >= 0 and even == even[::-1]:
            start = i - max_len
            max_len += 1 
    return s[start: start + max_len]

建议用调试模式一步一步看一个例子

©️2020 CSDN 皮肤主题: 深蓝海洋 设计师:CSDN官方博客 返回首页