LeetCode 每日一题 2023/7/24-2023/7/30

alphaTao

已于 2023-07-30 09:21:29 修改

阅读量223

点赞数

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

于 2023-07-29 01:08:06 首次发布

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

版权

Exercise 专栏收录该内容

197 篇文章 0 订阅

订阅专栏

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

7/24 771. 宝石与石头

将宝石类型放入set中
一次判断石头中宝石个数

def numJewelsInStones(jewels, stones):
    """
    :type jewels: str
    :type stones: str
    :rtype: int
    """
    j = set(jewels)
    ans = 0
    for s in stones:
        if s in j:
            ans+=1
    return ans

7/25 2208. 将数组和减半的最少操作次数

大顶堆记录当前最大值每次取最大值减半

def halveArray(nums):
    """
    :type nums: List[int]
    :rtype: int
    """
    import heapq
    target = sum(nums)*1.0/2
    
    l = []
    for num in nums:
        heapq.heappush(l,-num)
        
    cur = 0
    ans = 0
    while True:
        v = -heapq.heappop(l)
        cur +=v*1.0/2
        ans+=1
        if cur>=target:
            break
        heapq.heappush(l,-v*1.0/2)
    return ans

7/26 2569. 更新数组后处理求和查询

操作1是将nums1中[l,r]的数反转
操作2是将nums2的和加上p*sum(nums1)
操作3是求nums2的和
只要考虑nums1的变化即可
线段树维护nums1区间
l,r左右端点 s区间和 lazy懒标记

class Node:
    def __init__(self):
        self.l=self.r=0
        self.s = 0
        self.lazy = 0
class SegmentTree:
    def __init__(self,nums):
        self.nums = nums
        n = len(nums)
        self.tr = [Node() for _ in range(n<<2)]
        self.build(1,1,n)
    
    def build(self,u,l,r):
        self.tr[u].l,self.tr[u].r=l,r
        if l==r:
            self.tr[u].s = self.nums[l-1]
            return
        mid = (l+r)>>1
        self.build(u<<1,l,mid)
        self.build(u<<1|1,mid+1,r)
        self.pushup(u)
    
    def modify(self,u,l,r):
        if self.tr[u].l>=l and self.tr[u].r<=r:
            self.tr[u].lazy^=1
            self.tr[u].s = self.tr[u].r-self.tr[u].l+1-self.tr[u].s
            return
        self.pushdown(u)
        mid = (self.tr[u].l+self.tr[u].r)>>1
        if l<=mid:
            self.modify(u<<1,l,r)
        if r>mid:
            self.modify(u<<1|1,l,r)
        self.pushup(u)
        
    def query(self,u,l,r):
        if self.tr[u].l>=l and self.tr[u].r<=r:
            return self.tr[u].s
        self.pushdown(u)
        mid = (self.tr[u].l+self.tr[u].r)>>1
        ans = 0
        if l<=mid:
            ans +=self.query(u<<1,l,r)
        if r>mid:
            ans +=self.query(u<<1|1,l,r)
        return ans
    
    def pushup(self,u):
        self.tr[u].s = self.tr[u<<1].s+self.tr[u<<1|1].s
    
    def pushdown(self,u):
        if self.tr[u].lazy:
            mid = (self.tr[u].l+self.tr[u].r)>>1
            self.tr[u<<1].s = mid-self.tr[u].l+1-self.tr[u<<1].s
            self.tr[u<<1].lazy^=1
            self.tr[u<<1|1].s = self.tr[u].r-mid-self.tr[u<<1|1].s
            self.tr[u<<1|1].lazy^=1
            self.tr[u].lazy^=1
            
def handleQuery(nums1, nums2, queries):
    """
    :type nums1: List[int]
    :type nums2: List[int]
    :type queries: List[List[int]]
    :rtype: List[int]
    """
    tr = SegmentTree(nums1)
    s = sum(nums2)
    ans = []
    for op,l,r in queries:
        if op==1:
            tr.modify(1,l+1,r+1)
        elif op==2:
            s+=l*tr.query(1,1,len(nums1))
        else:
            ans.append(s)
    return ans

7/27 2500. 删除每行中的最大值

每一行从小到大排序
再取每一列的最大值

def deleteGreatestValue(grid):
    """
    :type grid: List[List[int]]
    :rtype: int
    """
    cur =[]
    for l in grid:
        cur.append(sorted(l))
    return sum([max([cur[i][j] for i in range(len(cur))]) for j in range(len(grid[0]))])

7/28 2050. 并行课程 III

m[i]记录课程i为多少课程的前置课程
ind[i]记录课程i有几个前置课程
t[i]记录课程i的最早完成时间

def minimumTime(n, relations, time):
    """
    :type n: int
    :type relations: List[List[int]]
    :type time: List[int]
    :rtype: int
    """
    from collections import defaultdict
    m = defaultdict(list)
    ind=[0]*n
    for pre,nxt in relations:
        m[pre-1].append(nxt-1)
        ind[nxt-1]+=1
    l = []
    t=[0]*n
    ans = 0
    for i in range(n):
        if ind[i]==0:
            l.append(i)
            t[i]=time[i]
            ans = max(ans,t[i])
    while l:
        tmp = []
        for i in l:
            for j in m[i]:
                t[j] = max(t[j],t[i]+time[j])
                ans = max(ans,t[j])
                ind[j]-=1
                if ind[j]==0:
                    tmp.append(j)
        l=tmp
    return ans

7/29 141. 环形链表

快慢指针

class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None
def hasCycle(head):
    """
    :type head: ListNode
    :rtype: bool
    """
    if head==None or head.next==None:
        return False
    slow = head
    fast = head.next
    
    while(slow!=fast):
        if fast==None or fast.next==None:
            return False
        slow=slow.next
        fast=fast.next.next
    return True

7/30 142. 环形链表 II

快慢指针

class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None
def detectCycle(head):
    """
    :type head: ListNode
    :rtype: ListNode
    """
    if head==None:
        return head
    node = ListNode()
    node.next = head
    fast,slow=node,node
    while fast==node or fast!=slow:
        slow = slow.next
        if fast.next==None or fast.next.next==None:
            return None
        fast = fast.next.next
    fast = node
    while fast!=slow:
        fast = fast.next
        slow = slow.next
    return slow