手撕算法(1)

IP属地归属（双指针法）

输出最长回文子串

这段代码的目的是找到字符串 s 中的最长回文子串。回文子串是指正读和反读都相同的子串。代码的核心思想是通过遍历字符串中的每一个字符，尝试以该字符为中心扩展，找到最长的回文子串。

代码解析

1. for i in range(len(s)):

• 这行代码遍历字符串 s 中的每一个字符，i 是当前字符的索引。
• 对于每一个字符，代码尝试找到以该字符为中心的最长回文子串。

2. start = max(i - len(res) -1, 0)

• start 是当前考虑的子串的起始索引。
• i - len(res) - 1 是为了确保当前考虑的子串长度至少比已经找到的最长回文子串 res 长 1。这是因为如果当前子串的长度不大于 res，那么它不可能是更长的回文子串。
• max(..., 0) 是为了确保 start 不会小于 0，即不会超出字符串的起始位置。

3. temp = s[start: i+1]

• temp 是从 start 到 i 的子串（包括 i）。
• 这个子串的长度是 i - start + 1。

4. if temp == temp[::-1]:

• 这行代码检查 temp 是否是回文子串。temp[::-1] 是 temp 的反转。
• 如果 temp 是回文子串，那么更新 res 为 temp。

5. else: temp = temp[1::]

• 如果 temp 不是回文子串，那么代码尝试去掉 temp 的第一个字符，得到一个新的子串 temp[1::]。
• 这个新的子串是从 start + 1 到 i 的子串。

6. if temp == temp[::-1]: res = temp

• 再次检查新的子串 temp 是否是回文子串。
• 如果是，更新 res 为 temp。

重点解析

start = max(i - len(res) -1, 0)

• 这个公式的目的是为了减少不必要的检查。如果当前已经找到的最长回文子串 res 的长度是 len(res)，那么只有当新的子串长度大于 len(res) 时，才有可能找到更长的回文子串。
• i - len(res) - 1 是为了确保新的子串长度至少比 res 长 1。
• max(..., 0) 是为了防止 start 为负数，确保子串不会超出字符串的起始位置。

else: temp = temp[1::]

• 如果当前子串 temp 不是回文子串，代码尝试去掉 temp 的第一个字符，得到一个新的子串 temp[1::]。
• 这个操作相当于将子串的起始位置向右移动一位，继续检查新的子串是否是回文子串。
• 这个操作是为了确保即使当前子串不是回文子串，仍然有可能在去掉一个字符后找到更长的回文子串。

总结

这段代码通过遍历字符串中的每一个字符，尝试以该字符为中心扩展，找到最长的回文子串。start = max(i - len(res) -1, 0) 是为了减少不必要的检查，而 else: temp = temp[1::] 是为了确保即使当前子串不是回文子串，仍然有可能在去掉一个字符后找到更长的回文子串。

class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        res = ' '
        for i in range(len(s)):
            start = max(i-len(res)-1, 0)
            temp = s[start: i+1]
            if temp == temp[::-1]:
                res = temp
            else:
                temp = temp[1::]
                if temp == temp[::-1]:
                    res = temp
        return res

最长连续子序列

股票买卖的最佳时机

合并两个有序数组

如果 p1 == m，说明 nums1 已经遍历完毕，直接将 nums2 的剩余部分添加到 sorted_list。

如果 p2 == n，说明 nums2 已经遍历完毕，直接将 nums1 的剩余部分添加到 sorted_list。

如果 nums1[p1] < nums2[p2]，将 nums1[p1] 添加到 sorted_list，并移动 p1 指针。

否则，将 nums2[p2] 添加到 sorted_list，并移动 p2 指针。

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None Do not return anything, modify nums1 in-place instead.
        """
        sorted_list = []
        p1, p2 = 0, 0
        while p1 < m or p2 < n:
            if p1 == m:
                sorted_list.append(nums2[p2])
                p2 += 1
            elif p2 == n:
                sorted_list.append(nums1[p1])
                p1 += 1
            elif nums1[p1] < nums2[p2]:
                sorted_list.append(nums1[p1])
                p1 += 1
            else:
                sorted_list.append(nums2[p2])
                p2 += 1
        nums1[:] = sorted_list

快手测开