[12]递增的三元子序列和两数相加

题目来自leetcode

1.递增的三元子序列

题目要求

给你一个整数数组 nums ，判断这个数组中是否存在长度为 3 的递增子序列。

如果存在这样的三元组下标 (i, j, k) 且满足 i < j < k ，使得 nums[i] < nums[j] < nums[k] ，返回 true ；否则，返回 false 。

示例 1：

输入：nums = [1,2,3,4,5]
输出：true
解释：任何 i < j < k 的三元组都满足题意
示例 2：

输入：nums = [5,4,3,2,1]
输出：false
解释：不存在满足题意的三元组

思路

开始以为是连续的三个递增为True，但是事情并没有这么简单。实际要求为存在不连续的递增子序列即可。最为简单思路就是三重循环来完成，理论上来说是可行的，但是实际运行会超时。。。

class Solution:
    def increasingTriplet(self, nums: List[int]) -> bool:
        #三重循环
        for i in range(len(nums)-2):
            for j in range(i+1,len(nums)-1):
                if nums[i] < nums[j]:
                    for k in range(j+1,len(nums)):
                        if nums[j] < nums[k]:
                            return True
        return False

既然超时那就只能寻找别的办法，略微看了一点评论区的解答，启发到可以通过记录最小和第二小的数字来查看是否满足条件，时间复杂度和空间复杂度分别为O(n)和O(1)。

class Solution:
    def increasingTriplet(self, nums: List[int]) -> bool:
        #记录2个small，所给num的上限为2的32次方-1
        minest = 4294967296
        secmin = 4294967296

        for i in range(len(nums)):
            #如果后续数组中有大于第二小的数字，则满足要求
            if (nums[i] - secmin) > 0:
                return True
            #如果数组中出现了更小的数字，更新最小数
            if nums[i] < minest:
                minest = nums[i]
            #更新记录第二小的数字
            if (nums[i] - minest) > 0:
                secmin = nums[i]
        return False

官方另外给出了一种解答，采用双向遍历实现，时间复杂度和空间复杂度均为O(n)

class Solution:
    def increasingTriplet(self, nums: List[int]) -> bool:
        #记录三个small
        left = [0] * len(nums)
        right = [0] * len(nums)
        left[0] = nums[0]
        right[len(nums)-1] = nums[len(nums)-1]
        for i in range(1,len(nums)):
            left[i] = min(left[i-1],nums[i])
        for i in range(len(nums)-2,-1,-1):
            right[i] = max(right[i+1],nums[i])
        for i in range(1,len(nums)-1):
            if left[i-1] < nums[i] < right[i+1]:
                return True
        return False
        

2.两数相加

题目要求

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

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

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

示例1

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

思路

由于是链表的每一个位置存储数的每一位，同时还是逆序存储。最直观的办法就是通过链表得到两个加数，再将得到的和按要求写入一个新的链表中。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        num1,num2 = 0,0
        ti1,ti2 = 1,1
        while l1.next != None:
            num1 = num1 + l1.val*ti1
            l1 = l1.next
            ti1 *= 10
        while l2.next != None:
            num2 = num2 + l2.val*ti2
            l2 = l2.next
            ti2 *= 10
        #加上链表最后的数
        num1 = num1 + l1.val*ti1 + num2 + l2.val*ti2

        result = ListNode()
        foll = result

        result.val = num1 % 10
        num1 = num1 // 10
        while num1 != 0:
            next = ListNode(num1 % 10)
            foll.next = next
            foll = foll.next
            num1 = num1 // 10
        return result

官方给出的模拟的思想

由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。

我们同时遍历两个链表，逐位计算它们的和，并与当前位置的进位值相加。具体而言，如果当前两个链表处相应位置的数字为 n1,n2，进位值为 carry。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        result = ListNode(-1)
        tail =result
        carry = 0
        while l1 or l2:
            num1,num2 = 0,0
            if l1:
                num1 = l1.val
            else:
                num1 = 0
            if l2:
                num2 = l2.val
            else:
                num2 = 0
            sum = num1 + num2 + carry
            carry = sum // 10
            #此处为了写入链表第一个，属实是有些麻烦
            #可以考虑从链表的第二个位置开始存数字
            if result.val == -1:
                result.val = sum % 10
            else:
                tail.next = ListNode(sum % 10)
                tail = tail.next
            if l1:
                l1 = l1.next
            if l2:
                l2 = l2.next
            
        if carry != 0:
            tail.next = ListNode(carry)
        return result