LeetCode 每日一题 2023/12/18-2023/12/24

alphaTao

已于 2023-12-24 09:47:39 修改

阅读量839

点赞数 6

分类专栏： Exercise 文章标签： leetcode 算法

于 2023-12-23 12:58:55 首次发布

本文链接：https://blog.csdn.net/zkt286468541/article/details/135166366

版权

Exercise 专栏收录该内容

197 篇文章 0 订阅

订阅专栏

记录了初步解题思路以及本地实现代码；并不一定为最优也希望大家能一起探讨一起进步

12/18 162. 寻找峰值

二分
因为边界为负无穷
只要往高坡移动必定能找到峰值

def findPeakElement(nums):
    """
    :type nums: List[int]
    :rtype: int
    """
    l,r = 0,len(nums)-1
    while l<r:
        mid = l+((r-l)>>1)
        if nums[mid]<nums[mid+1]:
            l = mid+1
        else:
            r = mid
    return l

12/19 1901. 寻找峰值 II

按每一行来二分对于某一行i来说取其中最大值mat[i][j]
判断该最大值与上下相邻值的关系
如果都大于邻值说明该位置为峰顶
如果存在大的邻值说明该方向存在峰顶

def findPeakGrid(mat):
    """
    :type mat: List[List[int]]
    :rtype: List[int]
    """
    l,r = 0,len(mat)-2
    while l<=r:
        mid = (l+r)>>1
        mx = max(mat[mid])
        j = mat[mid].index(mx)
        if mx>mat[mid+1][j]:
            r = mid-1
        else:
            l = mid+1
    i = l
    return [i,mat[i].index(max(mat[i]))]

12/20 2828. 判别首字母缩略词

依次判断

def isAcronym(words, s):
    """
    :type words: List[str]
    :type s: str
    :rtype: bool
    """
    n = len(words)
    if n!=len(s):
        return False
    for i in range(n):
        if words[i][0]!=s[i]:
            return False
    return True

12/21 2866. 美丽塔 II

以i为山顶
计算0~i能够得到的最大和left[i]
计算i~n能够得到的最大和right[i]
left[i]+right[i+1]就是最大和
单调栈来统计

def maximumSumOfHeights(maxHeights):
    """
    :type maxHeights: List[int]
    :rtype: int
    """
    n=len(maxHeights)
    right = [0]*(n+1)
    st = [n]
    s = 0
    for i in range(n-1,-1,-1):
        v = maxHeights[i]
        while len(st)>1 and v<=maxHeights[st[-1]]:
            j = st.pop()
            s -= maxHeights[j]*(st[-1]-j)
        s+=v*(st[-1]-i)
        right[i]=s
        st.append(i)
    ans = s
    st=[-1]
    l = 0
    for i,v in enumerate(maxHeights):
        while len(st)>1 and v<=maxHeights[st[-1]]:
            j = st.pop()
            l -= maxHeights[j]*(j-st[-1])
        l+=v*(i-st[-1])
        ans = max(ans,l+right[i+1])
        st.append(i)
    return ans

12/22 1671. 得到山形数组的最少删除次数

左侧到山顶是递增山顶到右侧是递减
只考虑一边即求递增子序列
另一边倒序后同样求递增子序列

def minimumMountainRemovals(nums):
    """
    :type nums: List[int]
    :rtype: int
    """
    n = len(nums)
    def getLIS(nums):
        dp=[1]*n
        for i in range(n):
            for j in range(i):
                if nums[j]<nums[i]:
                    dp[i] = max(dp[i],dp[j]+1)
        return dp
    
    left = getLIS(nums)
    right = getLIS(nums[::-1])[::-1]
    ans = 0
    for i,j in zip(left,right):
        if i>1 and j>1:
            ans = max(ans,i+j-1)
    return n-ans

12/23 1962. 移除石子使总数最小

大顶堆每次取最大一堆石子进行操作

def minStoneSum(piles, k):
    """
    :type piles: List[int]
    :type k: int
    :rtype: int
    """
    import heapq
    s = sum(piles)
    l = [-x for x in piles]
    heapq.heapify(l)
    while k>0:
        v = -heapq.heappop(l)
        s -= v//2
        v -= v//2
        heapq.heappush(l,-v)
        k-=1
    return s

12/24 1954. 收集足够苹果的最小花园周长

找规律可以划分为四块数量相同的区域
对于边长2n的正方形
一份区域内元素和n(n+1)(2n+1)/2
所以总和为2n(n+1)(2n+1)

def minimumPerimeter(neededApples):
    """
    :type neededApples: int
    :rtype: int
    """
    n = int((neededApples/4)**(1/3))
    if 2*n*(n+1)*(2*n+1)<neededApples:
        n+=1
    return 8*n