算法题复健之路 第19 20天

第十九天：

对应leetcode:

11. 盛最多水的容器

class Solution:
    def maxArea(self, height: List[int]) -> int:
        i, j, res = 0, len(height)-1, 0

        while i < j:
            if height[i] < height[j]:
                res = max(res, height[i] * (j-i))
                i += 1
            else:
                res = max(res, height[j] * (j-i))
                j -= 1

        return res

跟接雨水1差不多一个意思，双指针，两边遍历，找到短的边计算容积，然后记录下来即可。

55. 跳跃游戏

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        max_id = 0
        
        for i, jump in enumerate(nums):
            if max_id < i:
                return False
            if max_id >= i and i+jump > max_id:
                max_id = i+jump

        return max_id >= len(nums)-1

这题就是题目理解有点难，明白了就很简单，就是每一个位置往前跳呗，能跳到3就肯定能跳到12，然后每一个都计算一下，不停往前遍历。

406. 根据身高重建队列

这题就是纯迷幻，题目长的一批，根本没看懂，然后看了答案，理解了题目就几行代码：

class Solution:
    def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:
        people.sort(key=lambda x:(-x[0], x[1]))

        res = []

        for i in people:
            res.insert(i[1], i)

        return res

代码意思很简单，先排序，然后一个个人往前插队就行了，找到每个人应该在的位置，先排序的话只需要考虑一个位置就可以了。最大的收获反而是.sort(key=lambda x:(-x[0], x[1]))这个可以多看看，可以这样考sort和key和lambda来指定元素排序，默认从小到大，加上负从大到小。

第二十天：

对应leetcode:

169. 多数元素

简单，就计数就可以了，最简单的你用个字典也行

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        numdict = dict()
        for num in nums:
            if num not in numdict:
                numdict[num] = 1
            else:
                numdict[num] += 1
        
        res = -1
        for key, value in numdict.items():
            if value > len(nums)/2:
                res = key
        return res

高端点的你用个count和set，这个倒确实厉害，记住这count和set，真的好用，可以多用：

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        return next((num for num in set(nums) if nums.count(num) > len(nums) // 2), -1)

next第二个参数是默认值，没有的话，遍历完了会出异常。

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

不知道为什么是困难的简单题，最简单的做法直接两个数组相加然后去中间就行了：

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        nums = nums1 + nums2
        nums.sort()
        n = len(nums) // 2
        if len(nums) % 2 == 0:
            return (nums[n-1] + nums[n]) / 2.0
        else:
            return nums[n]

也可以像这样

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        k1 = (len(nums1) + len(nums2) + 1) // 2
        k2 = (len(nums1) + len(nums2) + 2) // 2

        def helper(nums1, nums2, k):
            if(len(nums1) < len(nums2)):
                nums1, nums2 = nums2, 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)

        return (helper(nums1, nums2, k1) + helper(nums1, nums2, k2)) / 2

就是两个数组不停的往后找，然后抛弃小的那一半，就跟快排一样，取中间，然后取到中间那个数字后就行了，有两个K只是为了做两次这个事情，然后取半而已，这样就不用考虑奇偶数，是躯壳的办法 可以学一下，那个K1 K2，不用也一样，分奇偶。这样加一然后加二然后除2的肯定可以取到中间的数字。

这题一开始卡住有个小技巧之前忘了，如果一直是整数取不到浮点数，因为一直/2了，让他/2.0这种或者乘，就会自动变成浮点数。