LeetCode 每日一题 2023/11/20-2023/11/26

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

---

目录

• • • [11/20 53. 最大子数组和](#11/20 53. 最大子数组和)
    • [11/21 2216. 美化数组的最少删除数](#11/21 2216. 美化数组的最少删除数)
    • [11/22 2304. 网格中的最小路径代价](#11/22 2304. 网格中的最小路径代价)
    • [11/23 1410. HTML 实体解析器](#11/23 1410. HTML 实体解析器)
    • [11/24 2824. 统计和小于目标的下标对数目](#11/24 2824. 统计和小于目标的下标对数目)
    • [11/25 1457. 二叉树中的伪回文路径](#11/25 1457. 二叉树中的伪回文路径)
    • [11/26 828. 统计子串中的唯一字符](#11/26 828. 统计子串中的唯一字符)

11/20 53. 最大子数组和

遍历每一个数 如果当前和大于0则将其加上 否则从0开始

def maxSubArray(nums):
    """
    :type nums: List[int]
    :rtype: int
    """
    ret = max(nums)
    now = 0    
    for i in range(len(nums)):
        if now + nums[i]>0:
            now += nums[i]
            ret = max(ret,now)
        else:
            now = 0
    return ret

---

11/21 2216. 美化数组的最少删除数

对于某个偶数坐标i 如果nums[i]==nums[i+1]

此时需要处理

如果删除i+1后的数据 不产生影响

如果删除i之前的数据 可能产生新的问题坐标需要处理

所以删除i最优

def minDeletion(nums):
    """
    :type nums: List[int]
    :rtype: int
    """
    n= len(nums)
    ans = 0
    loc = True
    for i in range(n-1):
        if nums[i]==nums[i+1] and loc:
            ans+=1
        else:
            loc = not loc
    ans += (n-ans)%2
    return ans

---

11/22 2304. 网格中的最小路径代价

从最后一行往前考虑

dp[i][j] 表示在第i行j列的最小代价

dp[m-1] = grid[m-1]

def minPathCost(grid, moveCost):
    """
    :type grid: List[List[int]]
    :type moveCost: List[List[int]]
    :rtype: int
    """
    m,n=len(grid),len(grid[0])
    dp = [[float("inf")]*n for _ in range(m)]
    dp[-1] = grid[-1]
    for i in range(m-2,-1,-1):
        for j,g in enumerate(grid[i]):
            for k,c in enumerate(moveCost[g]):
                dp[i][j] = min(dp[i][j],dp[i+1][k]+c)
            dp[i][j]+=g
    return min(dp[0])
    

---

11/23 1410. HTML 实体解析器

从头遍历 判断是否存在匹配的字符实体

def entityParser(text):
    """
    :type text: str
    :rtype: str
    """
    m = {
            '"': '"',
            ''': "'",
            '>': '>',
            '&lt;': '<',
            '&frasl;': '/',
            '&amp;': '&',
        }
    i = 0
    n = len(text)
    ans = []
    while i<n:
        tag = False
        if text[i]=='&':
            for e in m:
                if text[i:i+len(e)]==e:
                    ans.append(m[e])
                    i+=len(e)
                    tag = True
                    break
        if not tag:
            ans.append(text[i])
            i+=1
    return ''.join(ans)

---

11/24 2824. 统计和小于目标的下标对数目

从小到大排序

双指针

确定小的位置l 大的位置r往左移动知道满足条件

def countPairs(nums, target):
    """
    :type nums: List[int]
    :type target: int
    :rtype: int
    """
    nums.sort()
    ans = 0
    l,r=0,len(nums)-1
    while l<r:
        while l<r and nums[l]+nums[r]>=target:
            r-=1
        ans += r-l
        l+=1
    return ans

---

11/25 1457. 二叉树中的伪回文路径

如果是伪回文路径 那么其节点值中最多只能有一个值出现奇数次 其他都是偶数次

节点值为1到9 使用一个9位二进制tag来记录节点值出现次数的奇偶性

如果这个tag中存在小于1个的1那么满足条件

class TreeNode(object):
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right
def pseudoPalindromicPaths (root):
    """
    :type root: TreeNode
    :rtype: int
    """
    def dfs(tag,node):
        tag ^= 1<<node.val
        left = True
        v = 0
        if node.left:
            v += dfs(tag,node.left)
            left = False
        if node.right:
            v += dfs(tag,node.right)
            left = False
        if left:
            if tag==0 or tag&(tag-1)==0:
                v+=1
        return v
    
    return dfs(0,root)

---

11/26 828. 统计子串中的唯一字符

对每一个位置的字符计算其贡献值

对于当前位置i的字符 找到相同字符的前一个位置a 和后一个位置b

这个位置的贡献值为(i-a)*(b-i)

def uniqueLetterString(s):
    """
    :type s: str
    :rtype: int
    """
    from collections import defaultdict
    m = defaultdict(list)
    for i,c in enumerate(s):
        m[c].append(i)
        
    ans = 0
    for l in m.values():
        l = [-1]+l+[len(s)]
        for i in range(1,len(l)-1):
            ans += (l[i]-l[i-1])*(l[i+1]-l[i])
    return ans

---