LeetCode 每日一题 2023/7/3-2023/7/9
记录了初步解题思路 以及本地实现代码；并不一定为最优 也希望大家能一起探讨 一起进步
目录
-
-
- 7/3 445. 两数相加 II
- 7/4 2679. 矩阵中的和
- 7/5 2600. K 件物品的最大和
- 7/6 2178. 拆分成最多数目的正偶数之和
- 7/7 2532. 过桥的时间
- 7/8 167. 两数之和 II - 输入有序数组
- 7/9 15. 三数之和
-
7/3 445. 两数相加 II
将链表中的数值存入数组
倒序相加
class ListNode(object):
def __init__(self, val=0, next=None):
self.val = val
self.next = next
def addTwoNumbers(l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
li1,li2=[],[]
while l1:
li1.append(l1.val)
l1=l1.next
while l2:
li2.append(l2.val)
l2=l2.next
n1,n2=len(li1)-1,len(li2)-1
pre = ListNode()
v,ad = 0,0
while n1>=0 or n2>=0:
if n1>=0 and n2>=0:
v = li1[n1]+li2[n2]+ad
ad = v//10
v = v%10
n1-=1
n2-=1
elif n1>=0:
v = li1[n1]+ad
ad = v//10
v = v%10
n1-=1
else:
v = li2[n2]+ad
ad = v//10
v = v%10
n2-=1
cur = ListNode(v)
cur.next = pre.next
pre.next = cur
if ad>0:
cur = ListNode(ad)
cur.next = pre.next
pre.next = cur
return pre.next
7/4 2679. 矩阵中的和
将每一行排序
取每一列的最大值 求和
def matrixSum(nums):
"""
:type nums: List[List[int]]
:rtype: int
"""
cur = []
for l in nums:
cur.append(sorted(l))
n = len(cur[0])
ans = 0
for i in range(n):
v = max([cur[j][i] for j in range(len(nums))])
ans += v
return ans
7/5 2600. K 件物品的最大和
先取1 再取0 最后取-1
def kItemsWithMaximumSum(numOnes, numZeros, numNegOnes, k):
"""
:type numOnes: int
:type numZeros: int
:type numNegOnes: int
:type k: int
:rtype: int
"""
if k<=numOnes+numZeros:
return min(k,numOnes)
else:
return numOnes-(k-numOnes-numZeros)
7/6 2178. 拆分成最多数目的正偶数之和
如果是奇数必定不可以
为了使得尽可能多 尽量使用小的偶数 从2开始
def maximumEvenSplit(finalSum):
"""
:type finalSum: int
:rtype: List[int]
"""
if finalSum%2==1:
return []
cur = 2
ans = []
while cur<=finalSum:
ans.append(cur)
finalSum-=cur
cur+=2
ans[-1]+=finalSum
return ans
7/7 2532. 过桥的时间
按工人效率从高到低排序 编号越大效率越低
waitl,waitr 大根堆 记录左右岸等待工人的编号
workl,workr 小根堆 记录左右岸工人处理箱子时间及编号
初始所有工人在waitl cur记录当前时间
模拟
判断workl是否有工人放好箱子 有将工人放入waitl中等待
同理workr有工人放好箱子 将工人放入waitr中
判断当前是否有工人在左右两岸等待 如果不存在 则将cur更新为下一个工人放好箱子的时间
如果右岸有人等待，取出一个工人更新cur时间 如果所有工人都已过了右岸 则返回cur
如果左岸有人等待，取出一个工人更新cur时间，放入workr 箱子数量减一
def findCrossingTime(n, k, time):
"""
:type n: int
:type k: int
:type time: List[List[int]]
:rtype: int
"""
import heapq
time.sort(key=lambda x:x[0]+x[2])
cur = 0
waitl,waitr=[],[]
workl,workr=[],[]
for i in range(k):
heapq.heappush(waitl,-i)
while True:
while workl:
t,i = workl[0]
if t>cur:
break
heapq.heappop(workl)
heapq.heappush(waitl,-i)
while workr:
t,i = workr[0]
if t>cur:
break
heapq.heappop(workr)
heapq.heappush(waitr,-i)
ltr = n>0 and waitl
rtl = len(waitr)>0
if not ltr and not rtl:
nxt = float("inf")
if workl:
nxt = min(nxt,workl[0][0])
if workr:
nxt = min(nxt,workr[0][0])
cur = nxt
continue
if rtl:
i = -heapq.heappop(waitr)
cur += time[i][2]
if n==0 and not waitr and not workr:
return cur
heapq.heappush(workl,(cur+time[i][3],i))
else:
i = -heapq.heappop(waitl)
cur+=time[i][0]
n-=1
heapq.heappush(workr,(cur+time[i][1],i))
7/8 167. 两数之和 II - 输入有序数组
双指针 数组为非递减
将数组中最大值最小值相加 及最后一个数和第一个数
如果小于目标值 则将右边指针左移
如果大于目标值 则将左边指针右移
直到等于目标值
def twoSum(numbers, target):
"""
:type numbers: List[int]
:type target: int
:rtype: List[int]
"""
l,r=0,len(numbers)-1
while l<r:
cur = numbers[l]+numbers[r]
if cur==target:
return [l+1,r+1]
elif cur<target:
l+=1
else:
r-=1
7/9 15. 三数之和
neg,pos统计负数和正数
选两个数 确定第三个数
def threeSum(nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
"""
ret = []
neg = []
pos = []
dic = {}
zeronum = 0
for i in nums:
dic[i] = dic.get(i,0) + 1
if i == 0:
zeronum += 1
elif i<0:
neg.append(i)
else:
pos.append(i)
neg = list(set(neg))
pos = list(set(pos))
if zeronum > 2:
ret.append([0,0,0])
for num1 in neg:
for num2 in pos:
s = -(num1+num2)
if s in dic:
if s in (num1,num2) and dic[s]>1:
ret.append([num1,s,num2])
elif s>num1 and s<num2:
ret.append([num1,s,num2])
return ret