leetcode题目两数和、最大字符串长度、中位数、最长回文子串

给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

这道题目比较容易想到的是通过暴力搜索求解，但暴力搜索的时间复杂度为 O(n^2)。
如果使用哈希的思想，利用Python中list的查询方式，我们可以将复杂度降低到 O(n)。有两个值得注意的地方：

同样的元素不能重复使用（也就是不能自己加自己）
给定的数组中可能有相同的元素（比如 [3, 3, 4, 4, 5]）

class Solution:
    """
    给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
    你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
    示例:
    给定 nums = [2, 7, 11, 15], target = 9
    因为 nums[0] + nums[1] = 2 + 7 = 9
    所以返回 [0, 1]

    这道题目比较容易想到的是通过暴力搜索求解，但暴力搜索的时间复杂度为 O(n^2)。
    如果使用哈希的思想，利用Python中list的查询方式，我们可以将复杂度降低到 O(n)。有两个值得注意的地方：

    同样的元素不能重复使用（也就是不能自己加自己）
    给定的数组中可能有相同的元素（比如 [3, 3, 4, 4, 5]）

    """
    def twoSum(self, nums, target):
        i = 0
        while i < len(nums):
            if i == len(nums) - 1:
                return "No solution here!"
            r = target - nums[i]
            # Can't use a num twice
            num_follow = nums[i + 1:]
            if r in num_follow:
                return [i, num_follow.index(r) + i + 1]
            i = i + 1

if __name__ == '__main__':
    s = Solution()
    print(s.twoSum([3, 3, 4, 4, 5], 9))

    给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
    你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
    示例:
    给定 nums = [1，2, 7, 8，11, 15], target = 9
    因为 nums[0] + nums[3] = 2 + 7 = 9
    所以返回 [[0, 3],[1,2]]

    这道题目比较容易想到的是通过暴力搜索求解，但暴力搜索的时间复杂度为 O(n^2)。
    如果使用哈希的思想，利用Python中list的查询方式，我们可以将复杂度降低到 O(n)。有两个值得注意的地方：

b_index=[]
for i in mylist:
    r=4-i
    if r in mylist :
        b_index.append([mylist.index(i),mylist.index(r)])
        a.append((i,r))
        mylist.remove(i)
print(b_index)

 最大字符串长度
    给定一个字符串，找出不含有重复字符的最长子串的长度。
    示例：
    给定 "abcabcbb" ，没有重复字符的最长子串是 "abc" ，那么长度就是3。
    给定 "bbbbb" ，最长的子串就是 "b" ，长度是1。
    给定 "himhbgghc" ，最长子串是 "imhbg" ，长度是5。请注意答案必须是一个子串，"pwke" 是 子序列 而不是子串。

class Solution:
    """
    #最大字串长度
    给定一个字符串，找出不含有重复字符的最长子串的长度。
    示例：
    给定 "abcabcbb" ，没有重复字符的最长子串是 "abc" ，那么长度就是3。
    给定 "bbbbb" ，最长的子串就是 "b" ，长度是1。
    给定 "himhbgghc" ，最长子串是 "imhbg" ，长度是5。请注意答案必须是一个子串，"pwke" 是 子序列 而不是子串。
    """
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """

        len_s = len(s)
        if len_s == 0:
            return 0
        set_s = set(s)
        # get the max_size of sild window
        max_len = len(set_s)
        max_sub_str = ""
        while max_len:
            if max_len == 1:
                return 1
            i = 0
            while i + max_len <= len_s:
                sub_s = s[i:i + max_len]
                set_sub = set(sub_s)
                # if there is no repeat in sub string
                if len(set_sub) == len(sub_s):
                    max_sub_str = sub_s
                    return(len(list(max_sub_str)))
                i = i + 1
            # adjust the size of window
            max_len = max_len - 1
 
if __name__ == '__main__':
    s=Solution()
    s.lengthOfLongestSubstring('himhbgghc') # 5 最长字串imhbg 不重复

中位数是一个可将数值集合划分为相等的上下两部分的一个数值。

如果列表数据的个数是奇数，则列表中间那个数据就是列表数据的中位数；
如果列表数据的个数是偶数，则列表中间那2个数据的算术平均值就是列表数据的中位数。
输入: 一个作为数组的整数(int)列表(list)的。
输出: 数组的中位数(int, float).

class Solution:
    """
    中位数是一个可将数值集合划分为相等的上下两部分的一个数值。
    如果列表数据的个数是奇数，则列表中间那个数据就是列表数据的中位数；
    如果列表数据的个数是偶数，则列表中间那2个数据的算术平均值就是列表数据的中位数。
    输入: 一个作为数组的整数(int)列表(list)的。
    输出: 数组的中位数(int, float).
    第一种
    """
    def findMedianSortedArraysOne(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: float
        """
        self.nums = nums1 + nums2
        self.nums.sort() #[1,2,3,4]
        size = len(self.nums)

        if size % 2 == 1:
            return self.nums[size // 2]

        if size % 2 == 0:
            return (self.nums[size // 2] + self.nums[size // 2 - 1]) / 2
    """
    利用了取反数和为1的特性，通过列表负索引来获得列表中位数。
    # 解析：
    if len = 6, half = 3, -half = -4, 此时 ，对中间2个数 data[~half] 和 data[half] 求和，再取平均值

    if len = 5， half = 2， ~half = -3, 此时 data[half] = data[~half] ，求和取平均，等于 data[half]

    all: half + ~half = -1
    第二种

    """
    def findMedianSortedArraysTwo(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: float
        """
        self.nums = nums1 + nums2
        self.nums.sort() #[1,2,3,4]
        size = len(self.nums)
        half = size // 2
        if size % 2 == 1:
            return self.nums[half]

        if size % 2 == 0:
            return (self.nums[half] + self.nums[~half]) / 2

if __name__ == '__main__':
    s=Solution()
s.findMedianSortedArraysOne([1,2,4],[5,6])
s.findMedianSortedArraysTwo([1,2,4],[5,6])

最长回文子串
回文是指正着读和倒着读，结果一些样，比如abcba或abba。
题目是要在一个字符串中要到最长的回文子串。
最容易想到的就是暴力破解，求出每一个子串，之后判断是不是回文，找到最长的那个。
求每一个子串时间复杂度O(N^2)，判断子串是不是回文O(N)，两者是相乘关系，所以时间复杂度为O(N^3)。

class Solution:
    """
        最长回文子串
        回文是指正着读和倒着读，结果一些样，比如abcba或abba。
        题目是要在一个字符串中要到最长的回文子串。
        最容易想到的就是暴力破解，求出每一个子串，之后判断是不是回文，找到最长的那个。
        求每一个子串时间复杂度O(N^2)，判断子串是不是回文O(N)，两者是相乘关系，所以时间复杂度为O(N^3)。
    """
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        s = s
        mlen = len(s)
        while True:
            i = 0
            while i + mlen <= len(s):
                sl = s[i:i + mlen]
                sr = sl[::-1]
                if sl == sr:
                    return sl
                i = i + 1
            mlen = mlen - 1
            if mlen == 0:
                return "No solution"

if __name__ == '__main__':
    s=Solution()
    s.longestPalindrome('himhbggbc') 

 

第二种
class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        # 使用动态规划，用空间换时间，把问题拆分
        # 获取字符串s的长度
        str_length = len(s)
        # 记录最大字符串长度
        max_length = 0
        # 记录位置
        start = 0
        # 循环遍历字符串的每一个字符
        for i in range(str_length):
            # 如果当前循环次数-当前最大长度大于等于1  并  字符串[当前循环次数-当前最大长度-1:当前循环次数+1]  == 取反后字符串
            if i - max_length >= 1 and s[i-max_length-1: i+1] == s[i-max_length-1: i+1][::-1]:
                # 记录当前开始位置
                start = i - max_length - 1
                # 取字符串最小长度为2，所以+=2，s[i-max_length-1: i+1]
                max_length += 2
                continue
            # 如果当前循环次数-当前最大长度大于等于0  并  字符串[当前循环次数-当前最大长度:当前循环次数+1]  == 取反后字符串
            if i - max_length >= 0 and s[i-max_length: i+1] == s[i-max_length: i+1][::-1]:
                start = i - max_length
                # 取字符串最小长度为1，所以+=1，s[i-max_length: i+1]
                max_length += 1
        # 返回最长回文子串
        return s[start: start + max_length]


if __name__ == '__main__':
    s = "babad"
    # s = "cbbd"
    sl = Solution()
    print(sl.longestPalindrome(s))

第三种
根据回文串对称性，分为奇数长度回文串和偶数长度回文串

def match(s):
    res=0
    for i in range(len(s)-1):
        if s[i]==s[i+1]:#奇数长度
            first=i
            end=i+1
            while first>=0 and end<len(s) and s[first]==s[end]:
            #满足条件就向两边扩展
                first-=1
                end+=1
            res=max(res,end-first-1)
        elif s[i-1]==s[i+1]:#偶数长度
            first=i-1
            end=i+1
            while first>=0 and end<len(s) and s[first]==s[end]:
                first-=1
                end+=1
            res=max(res,end-first-1)
    return res
match('abba')