LeetCode 每日一题 2025/2/24-2025/3/2

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

2/24 1656. 设计有序流

数组保存数据 插入数据后
检查指针节点是否可以往后移动

class OrderedStream(object):

    def __init__(self, n):
        """
        :type n: int
        """
        self.n = n
        self.ptr = 0
        self.l = [""]*(n+1)


    def insert(self, idKey, value):
        """
        :type idKey: int
        :type value: str
        :rtype: List[str]
        """
        ans = []
        self.l[idKey] = value
        while self.ptr<self.n and self.l[self.ptr+1]!="":
            ans.append(self.l[self.ptr+1])
            self.ptr +=1
            if self.ptr>self.n:
                break
        return ans

2/25 2502. 设计内存分配器

使用长度为n的数字 记录每个位置内存使用情况

class Allocator(object):

    def __init__(self, n):
        """
        :type n: int
        """
        self.n=n
        self.mem=[0]*n
        

    def allocate(self, size, mID):
        """
        :type size: int
        :type mID: int
        :rtype: int
        """
        cnt = 0
        for i in range(self.n):
            if self.mem[i]>0:
                cnt=0
            else:
                cnt+=1
                if cnt==size:
                    for j in range(i-cnt+1,i+1):
                        self.mem[j]=mID
                    return i-cnt+1
        return -1
        

    def freeMemory(self, mID):
        """
        :type mID: int
        :rtype: int
        """
        cnt = 0
        for i in range(self.n):
            if self.mem[i]==mID:
                cnt+=1
                self.mem[i]=0
        return cnt

2/26 1472. 设计浏览器历史记录

模拟 使用一个数组urls保存网页记录
cur指向当前访问的网页索引

class BrowserHistory(object):

    def __init__(self, homepage):
        """
        :type homepage: str
        """
        self.urls = [homepage]
        self.cur = 0
        

    def visit(self, url):
        """
        :type url: str
        :rtype: None
        """
        self.urls = self.urls[:self.cur+1]
        self.urls.append(url)
        self.cur+=1
        
        

    def back(self, steps):
        """
        :type steps: int
        :rtype: str
        """
        self.cur = max(0,self.cur-steps)
        return self.urls[self.cur]
        
        

    def forward(self, steps):
        """
        :type steps: int
        :rtype: str
        """
        self.cur = min(len(self.urls)-1,self.cur+steps)
        return self.urls[self.cur]

2/27 2296. 设计一个文本编辑器

使用left,right两个栈分别存储光标左右的内容
add:将text压入left中
delete:从left中取出k个直至为空
cursorleft:将left中取出放入right中
cursorright:将right中取出放入left中

class TextEditor(object):

    def __init__(self):
        self.left=[]
        self.right=[]

    def addText(self, text):
        """
        :type text: str
        :rtype: None
        """
        self.left.extend(text)
        

    def deleteText(self, k):
        """
        :type k: int
        :rtype: int
        """
        cnt=min(k,len(self.left))
        del self.left[-cnt:]
        return cnt

    def cursorLeft(self, k):
        """
        :type k: int
        :rtype: str
        """
        for _ in range(min(k,len(self.left))):
            self.right.append(self.left.pop())
        return ''.join(self.left[-10:])
        

    def cursorRight(self, k):
        """
        :type k: int
        :rtype: str
        """
        for _ in range(min(k,len(self.right))):
            self.left.append(self.right.pop())
        return ''.join(self.left[-10:])
        

2/28 2353. 设计食物评分系统

foodmap维护food对应的分数和烹饪方法
ratemap[cuisines] 使用最小堆维护同一烹饪方法中的分数 用负数变为最大堆

import heapq
class FoodRatings(object):

    def __init__(self, foods, cuisines, ratings):
        """
        :type foods: List[str]
        :type cuisines: List[str]
        :type ratings: List[int]
        """
        self.food={}
        self.rate={}
        self.n=len(foods)
        for i in range(self.n):
            f = foods[i]
            c = cuisines[i]
            r = ratings[i]
            self.food[f]=(c,r)
            if c not in self.rate:
                self.rate[c]=[]
            heapq.heappush(self.rate[c], (-r,f))
            
        

    def changeRating(self, food, newRating):
        """
        :type food: str
        :type newRating: int
        :rtype: None
        """
        c,r = self.food[food]
        heapq.heappush(self.rate[c], (-newRating,food))
        self.food[food]=(c,newRating)
        

    def highestRated(self, cuisine):
        """
        :type cuisine: str
        :rtype: str
        """
        while self.rate[cuisine]:
            r,f = self.rate[cuisine][0]
            if -r == self.food[f][1]:
                return f
            heapq.heappop(self.rate[cuisine])
        return ""

3/1 131. 分割回文串

check检查字符串l是否回文
pdic存放pos开头所有回文的子串

def partition(s):
    """
    :type s: str
    :rtype: List[List[str]]
    """
    def check(l):
        t = True
        if len(l)==0:
            return t
        while t and len(l)>1:
            if l[0]==l[-1]:
                l.pop(0)
                l.pop(-1)
            else:
                t = False
        if len(l)>1:
            return False
        else:
            return True
    ret =[]
    if len(s)==0:
        return ret
    l = list(s)    
    dic = {}
    for i in range(len(l)):
        begin = l[i]
        for j in range(len(l)-1,i-1,-1):
            if begin == l[j]:
                if check(l[i:j+1]):
                    dic[(i,j)] = l[i:j+1]
    pdic = {}
    for i in dic:
        pos = i[0]
        tmp = pdic.get(pos,[])
        tmp.append(i)
        pdic[pos] = tmp
    
    def combine(begin):
        ret = []
        va = pdic[begin]
        for v in va:
            end = v[1]
            if end == (len(s)-1):
                ret.append([v])
            else:
                l = combine(end+1)
                for t in l:
                    t.insert(0,v)
                ret.extend(l)     
        return ret
    
    r = combine(0)
    for v in r:
        tmp = []
        for i in v:
            tmp.append(''.join(dic[i]))
        ret.append(tmp)
    return ret

3/2