0304leetcode刷题5道python

143

题目描述：
给定一个单链表 L：L0→L1→…→Ln-1→Ln ，
将其重新排列后变为： L0→Ln→L1→Ln-1→L2→Ln-2→…
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例：

解答：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reorderList(self, head: ListNode) -> None:
        """
        Do not return anything, modify head in-place instead.
        """
        if not head or not head.next: 
            return head
        fast, slow = head, head
        #找到中点
        while fast.next and fast.next.next:
            fast = fast.next.next
            slow = slow.next
        #反转后半链表
        p, right = slow.next, None
        slow.next = None
        while p:
            right, right.next, p = p, right, p.next
        #重排练表
        left = head
        while left and right:
            left.next,right.next,left,right = right,left.next,left.next,right.next

354

题目描述：
给定一些标记了宽度和高度的信封，宽度和高度以整数对形式 (w, h) 出现。当另一个信封的宽度和高度都比这个信封大的时候，这个信封就可以放进另一个信封里，如同俄罗斯套娃一样。
请计算最多能有多少个信封能组成一组“俄罗斯套娃”信封（即可以把一个信封放到另一个信封里面）。
说明:
不允许旋转信封。

示例：

解答：

class Solution:
    def maxEnvelopes(self, envelopes: List[List[int]]) -> int:
        '''
        if len(envelopes) <= 0:
            return 0
        arr = list(sorted(envelopes, key=functools.cmp_to_key(
            lambda x, y: y[1] - x[1] if x[0] == y[0] else x[0] - y[0])))
        arr = [_[1] for _ in arr]
        dp = [1]
        for i in range(1, len(arr)):
            max_len = 1
            for j in range(i):
                if arr[i] > arr[j]:
                    max_len = max(max_len, dp[j] + 1)
            dp.append(max_len)
        return max(dp)
        '''
        if not envelopes:
            return 0
        envelopes.sort(key = lambda x:(x[0],-x[1]))
        n = len(envelopes)
        dp = [1]*n
        for i in range(n):
            for j in range(i):
                if envelopes[i][1] > envelopes[j][1]:
                    dp[i] = max(dp[i],dp[j]+1)
        return max(dp)

817

题目描述：
给定链表头结点 head，该链表上的每个结点都有一个 唯一的整型值 。
同时给定列表 G，该列表是上述链表中整型值的一个子集。
返回列表 G 中组件的个数，这里对组件的定义为：链表中一段最长连续结点的值（该值必须在列表 G 中）构成的集合。

示例：

解答：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def numComponents(self, head: ListNode, G: List[int]) -> int:
        g=set(G)
        pre,res=0,0
        while head:
            if head.val in g:
                if not pre:
                    res+=1
                pre=1
            else:
                pre=0
            head=head.next
        return res

876

题目描述：
给定一个头结点为 head 的非空单链表，返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。

示例：

解答：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        slow=fast=head
        while fast and fast.next:
            slow=slow.next
            fast=fast.next.next
        return slow

剑指offer56-II

题目描述：
在一个数组 nums 中除一个数字只出现一次之外，其他数字都出现了三次。请找出那个只出现一次的数字。

示例：

解答：

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        '''
        return (sum(set(nums))*3-sum(nums))//2
        '''
        dict = {}
        for num in nums:
            if num not in dict:
                dict[num] = 1
            else:
                dict[num] += 1
        for num in dict:
            if dict[num] == 1:
                return num