leetcode刷题第一天

2两数相加

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

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

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

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        dummy = p = ListNode(None) #保存头结点，返回结果
        s = 0 #每一步的求和暂存变量
        while l1 or l2 or s:           #循环条件：l1 或者l2（没有遍历完成），s(进位)不为0
            s += (l1.val if l1 else 0) + (l2.val if l2 else 0)           #这其实是好多代码，我自己写了好多行，但是作者这样写非常简洁，赞
            p.next = ListNode(s % 10)             #构建新的list存储结果，其实用较长的加数链表存也可以，%10：求个位
            p = p.next                        
            s //= 10                                         #求进位
            l1 = l1.next if l1 else None           
            l2 = l2.next if l2 else None
        return dummy.next`在这里插入代码片

4寻找两个正序数组的中位数

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

进阶：你能设计一个时间复杂度为 O(log (m+n)) 的算法解决此问题吗？

示例 1：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2
示例 2：

输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

先找第k个小数

找第k小数
对于两个有序数组，我们要找第k小的数
由于时间复制度要求是log，所以自然的想法就是对两个数组每次切一半。
好，假设我们取两个数组k/2位置上的数(这里暂时不考虑上溢)
如果nums1[k/2]>=nums2[k/2]，这意味着：
nums2数组的左半边都不需要考虑了，因为肯定会比第k小的数要来得小。
所以我们可以切掉nums2数组的一半，如此递归，每次都能切走一半
自然能达到O（log(m+n)）复杂度的要求了。
在具体的代码实现中，为了方便处理边界情况，
我们可以令nums1始终是长的那个数组，
然后令t = min(k//2,len(nums2))便可以防止上溢的发生。


def helper(nums1,nums2,k):
    if(len(nums1) <len(nums2) ):
        nums1, nums2 = nums2 , nums1 #保持nums1比较长
    if(len(nums2)==0):
        return nums1[k-1] # 短数组空，直接返回
    if(k==1):
        return min(nums1[0],nums2[0])  #找最小数，比较数组首位
    t = min(k//2,len(nums2)) # 保证不上溢
    if( nums1[t-1]>=nums2[t-1] ):
        return helper(nums1 , nums2[t:],k-t)
    else:
        return helper(nums1[t:],nums2,k-t)

5 最长回文数

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

示例 1：

输入：s = “babad”
输出：“bab”
解释：“aba” 同样是符合题意的答案。
示例 2：

输入：s = “cbbd”
输出：“bb”
示例 3：

输入：s = “a”
输出：“a”

5最长回文子数

动态规划
思路与算法

对于一个子串而言，如果它是回文串，并且长度大于 22，那么将它首尾的两个字母去除之后，它仍然是个回文串。例如对于字符串 \textrm{ababa''}“ababa”，如果我们已经知道 \textrm{bab’’}“bab” 是回文串，那么 \textrm{ababa''}“ababa” 一定是回文串，这是因为它的首尾两个字母都是 \textrm{a’’}“a”。

根据这样的思路，我们就可以用动态规划的方法解决本题。我们用 P(i,j)P(i,j) 表示字符串 ss 的第 ii 到 jj 个字母组成的串（下文表示成 s[i:j]s[i:j]）是否为回文串：

P(i,j) = \begin{cases} \text{true,} &\quad\text{如果子串~} S_i \dots S_j \text{~是回文串}\ \text{false,} &\quad\text{其它情况} \end{cases}
P(i,j)={
true,
false,
​

如果子串 S
i
​
…S
j
​
是回文串
其它情况
​

这里的「其它情况」包含两种可能性：

s[i, j]s[i,j] 本身不是一个回文串；

i > ji>j，此时 s[i, j]s[i,j] 本身不合法。

那么我们就可以写出动态规划的状态转移方程：

P(i, j) = P(i+1, j-1) \wedge (S_i == S_j)
P(i,j)=P(i+1,j−1)∧(S
i
​
==S
j
​
)

也就是说，只有 s[i+1:j-1]s[i+1:j−1] 是回文串，并且 ss 的第 ii 和 jj 个字母相同时，s[i:j]s[i:j] 才会是回文串。

上文的所有讨论是建立在子串长度大于 22 的前提之上的，我们还需要考虑动态规划中的边界条件，即子串的长度为 11 或 22。对于长度为 11 的子串，它显然是个回文串；对于长度为 22 的子串，只要它的两个字母相同，它就是一个回文串。因此我们就可以写出动态规划的边界条件：

\begin{cases} P(i, i) = \text{true} \ P(i, i+1) = ( S_i == S_{i+1} ) \end{cases}
{
P(i,i)=true
P(i,i+1)=(S
i
​
==S
i+1
​
)
​

根据这个思路，我们就可以完成动态规划了，最终的答案即为所有 P(i, j) = \text{true}P(i,j)=true 中 j-i+1j−i+1（即子串长度）的最大值。注意：在状态转移方程中，我们是从长度较短的字符串向长度较长的字符串进行转移的，因此一定要注意动态规划的循环顺序。

class Solution:
    def longestPalindrome(self, s: str) -> str:
        n = len(s)
        dp = [[False] * n for _ in range(n)]
        ans = ""
        # 枚举子串的长度 l+1
        for l in range(n):
            # 枚举子串的起始位置 i，这样可以通过 j=i+l 得到子串的结束位置
            for i in range(n):
                j = i + l
                if j >= len(s):
                    break
                if l == 0:
                    dp[i][j] = True
                elif l == 1:
                    dp[i][j] = (s[i] == s[j])
                else:
                    dp[i][j] = (dp[i + 1][j - 1] and s[i] == s[j])
                if dp[i][j] and l + 1 > len(ans):
                    ans = s[i:j+1]
        return ans
。

`