DataWhale第21期组队学习LeetCode刷题task1—2，4，5题

很久没有接触在线编程系统了，之前系统训练算法还是大一时候参加学校ACM社团。这么多年，还停留在C语言，这次参加leetcode训练选择了python，在学习算法的同时，也为了提高自己对python使用的熟练程度。

1.第二题，两数相加

题目：

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-two-numbers

解法思想：

本题比较简答，因为链表是倒序存储，所以可以在遍历两个链表的时候，把链表对应位置相加，保存到新的链表中即可。

解题过程（参考来源：）： https://github.com/datawhalechina/team-learning-program/blob/master/LeetCodeTencent/002%20%E4%B8%A4%E6%95%B0%E7%9B%B8%E5%8A%A0%20.md

class Solution:

    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:

        result = ListNode(-1)

        l3 = result

        flag = 0

        while l1 is not None and l2 is not None:

            a = l1.val

            b = l2.val

            c = a + b + flag

            l3.next = ListNode(c % 10)

            flag = 1 if c >= 10 else 0

            l1 = l1.next

            l2 = l2.next

            l3 = l3.next



        while l1 is not None:

            a = l1.val + flag

            l3.next = ListNode(a % 10)

            flag = 1 if a >= 10 else 0

            l1 = l1.next

            l3 = l3.next



        while l2 is not None:

            b = l2.val + flag

            l3.next = ListNode(b % 10)

            flag = 1 if b >= 10 else 0

            l2 = l2.next

            l3 = l3.next



        if flag == 1:

            l3.next = ListNode(flag)



        return result.next

 

2. 第四题， 寻找两个正序数组的中位数

题目：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/median-of-two-sorted-arrays/ 

解法思想：

因为两个数组是有序数组，所以可以从头开始遍历每个数组，将两个数组最小位置的数进行比较，较小的数放入新数组，这样就合并成一个新的有序数组。接下来问题转换为在新合并的有序数组中寻找中位数。若数组长度是偶数，则取中间两个数的平均数，若数组长度是奇数，则取中间数即可。

解题过程：

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        import math
        x = len(nums1)+len(nums2)

        if x % 2 == 1:    #x是奇数
            y = math.ceil(x/2)
            a = 1
            b = 0
    
        else:             #x是偶数
            d = int(x/2)
            y = d+1
            a = 0
            b = 1

        nums3 = [0 for e in range(0, y)]
        i = 0
        j = 0
        k = 0
        while i < y:
            if j < len(nums1) and k < len(nums2):
                if nums1[j] <= nums2[k]:
                    nums3[i] = nums1[j]
                    i = i+1
                    j = j+1
                else:
                    nums3[i] = nums2[k]
                    i = i+1
                    k = k+1
            elif j < len(nums1):
                nums3[i] = nums1[j]
                i = i+1
                j = j+1
            
            elif k < len(nums2):
                nums3[i] = nums2[k]
                i = i+1
                k = k+1
        if a == 1:
            return(nums3[i-1])
        elif b == 1:
            return((nums3[i-2]+nums3[i-1])/2)

 

3.第五题，最长回文子串

题目：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-palindromic-substring/

 解法思想：

1. 我自己的思想是，找到每个字串，找到最长字串即可。但是该方法时间复杂度比较大，自己方法会造成超出时间限制

2. 第二种方法是参考leetcode论坛的方法（链接：https://leetcode-cn.com/problems/longest-palindromic-substring/solution/zhong-xin-kuo-san-dong-tai-gui-hua-by-liweiwei1419/）

第二种方法是使用动态规划的方法：

动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。

与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解）。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，这样就可以避免大量的重复计算，节省时间。

我们可以用一个表来记录所有已解的子问题的答案。不管该子问题以后是否被用到，只要它被计算过，就将其结果填入表中。这就是动态规划法的基本思路。

解题过程：

方法一：

def isPalindrome(s , left , right):
        if((left == right)or(right < left)):
            return 1
        if(s[left] == s[right]):
            return isPalindrome(s , left+1 , right-1)
        else :
            return 0
class Solution:
    def longestPalindrome(self, s: str) -> str:
        lp = list()
        lp = s[0]
        for i in range(0,len(s)):
            for j in range(i , len(s)):
                if(isPalindrome(s,i,j)):
                    if(lp is None or j-i >= len(lp)):
                        lp = s[i:j+1]
                        if(len(lp) == len(s)):
                            return lp
        return lp

方法二：

class Solution:
    def longestPalindrome(self, s: str) -> str:
        count = len(s)
        if count == 0 or count == 1:
            return s
        longestPalindromelen = 1
        longestPalindromeStr = s[0:1]
        dp = [[False] * count for i in range(count)]
        for r in range(1, count):
            for l in range(0, r):
                if s[r] == s[l] and (r - l <= 2 or dp[l + 1][r - 1] == True):
                    dp[l][r] = True
                    if longestPalindromelen < r - l + 1:
                        longestPalindromelen = r - l + 1
                        longestPalindromeStr = s[l:l + longestPalindromelen]
        return longestPalindromeStr