LeetCode 每日一题 2023/6/26-2023/7/2

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

---

6/26 2485. 找出中枢整数

数学算法
1+2+…+x = x+(x+1)+…+n
(1+x)x=(x+n)(n-x+1)
x^2 = (n+1)*n/2

def pivotInteger(n):
    """
    :type n: int
    :rtype: int
    """
    import math
    ans = math.sqrt(n*(n+1)/2)
    if ans-int(ans)==0:
        return int(ans)
    else:
        return -1

---

6/27 1186. 删除一次得到子数组最大和

dp
dp0[i]表示以arr[i]结尾的最大值
dp1[i]表示以arr[i]结尾删除一个后的最大值
dp0[i]=max(dp0[i-1],0)+arr[i]
dp1[i]=max(dp1[i-1]+arr[i],dp0[i-1])

def maximumSum(arr):
    """
    :type arr: List[int]
    :rtype: int
    """
    dp0,dp1=arr[0],0
    ans = dp0
    for i in range(1,len(arr)):
        dp1=max(dp1+arr[i],dp0)
        dp0=max(dp0,0)+arr[i]
        ans=max(ans,max(dp0,dp1))
    return ans

---

6/28 1681. 最小不兼容性

n位的二进制mask用来表示选取的子集
遍历所有子集 筛选符合条件的mask 求其不兼容性value[mask]
dp[mask]表示改子集的不兼容性之和 求dp[-1]

def minimumIncompatibility(nums, k):
    """
    :type nums: List[int]
    :type k: int
    :rtype: int
    """
    n = len(nums)
    if n%k>0:
        return -1
    m = n//k
    dp=[float("inf")]*(1<<n)
    dp[0]=0
    value={}
    for mask in range(1<<n):
        if mask.bit_count()!=m:
            continue
        maxv,minv = 1,16
        cur = set()
        for i in range(n):
            if mask&(1<<i)>0:
                if nums[i] in cur:
                    break
                cur.add(nums[i])
                maxv=max(nums[i],maxv)
                minv=min(nums[i],minv)
        if len(cur)==m:
            value[mask]=maxv-minv
    
    for mask in range(1<<n):
        if dp[mask]==float("inf"):
            continue
        left = {}
        for i in range(n):
            if mask&(1<<i)==0:
                left[nums[i]]=i
        if len(left)<m:
            continue
        sub = 0
        for v in left:
            sub |= 1<<left[v]
        nxt = sub
        while nxt>0:
            if nxt in value:
                dp[mask|nxt] = min(dp[mask|nxt],dp[mask]+value[nxt])
            nxt = (nxt-1)&sub
    return dp[-1] if dp[-1]<float("inf") else -1

---

6/29 1253. 重构 2 行二进制矩阵

如果upper和lower的和 与colsum的和不一致 说明不存在
如果colsum[i]为2说明上下都是1 为0说明上下都是0
先统计2的个数m
再一次判断1 先放upper在放lower 如果upper或者lower都为0说明失败

def reconstructMatrix(upper, lower, colsum):
    """
    :type upper: int
    :type lower: int
    :type colsum: List[int]
    :rtype: List[List[int]]
    """
    if upper+lower!=sum(colsum):
        return []
    n = len(colsum)
    ans = [[0]*n for _ in range(2)]
    m = 0
    for v in colsum:
        if v==2:
            m+=1
    upper-=m
    lower-=m
    if upper<0 or lower<0:
        return []
    for i,v in enumerate(colsum):
        if v==2:
            ans[0][i]=1
            ans[1][i]=1
        elif v==1:
            if upper>0:
                ans[0][i]=1
                upper-=1
            elif lower>0:
                ans[1][i]=1
                lower-=1
            else:
                return []
    return ans

---

6/30 2490. 回环句

按规则判断

def isCircularSentence(sentence):
    """
    :type sentence: str
    :rtype: bool
    """
    l = sentence.split(" ")
    for i in range(len(l)-1):
        if l[i][-1]!=l[i+1][0]:
            return False
    return l[len(l)-1][-1]==l[0][0]

---

7/1 1. 两数之和

map记录出现值的位置 从头到尾遍历
对于数值v 判断target-v是否出现过

def twoSum(nums, target):
    """
    :type nums: List[int]
    :type target: int
    :rtype: List[int]
    """
    m={}
    for i,v in enumerate(nums):
        if target-v in m:
            return [m[target-v],i]
        m[v]=i
    

---

7/2 2. 两数相加

同时遍历两个链表

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None


def addTwoNumbers(l1, l2):
    """
    :type l1: ListNode
    :type l2: ListNode
    :rtype: ListNode
    """
    ad = 0
    ret = ListNode(0)
    node = ret
    while (l1!=None) or (l2!=None) or (ad==1):
        s = ad
        if l1:
            s+=l1.val
            l1 = l1.next
        if l2:
            s+=l2.val
            l2 = l2.next
        if s>=10:
            ad = 1
            s = s-10
        else:
            ad = 0
        x = ListNode(s)
        node.next = x
        node = x
    return ret.next

---