基础算法（Leetcode）刻意练习训练营：第五天打卡

今天的题目是16. 最接近的三数之和

这题解法和昨天三数之和是类似的，三指针向内夹，当和目标一致直接返回。

class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        # 特判：n=3，返回sum(nums)
        n = len(nums)
        if n == 3:
            return sum(nums)
        # 令最小差的绝对值为无限大
        minDiff = float("inf")
        closestSum = 0
        # nums排序
        nums.sort()
        # 遍历nums
        for i in range(n-2):
            if i > 1 and nums[i] == nums[i-1]:
                continue
            # 双指针
            L = i + 1
            R = n - 1
            while(L < R):
                threeSum = nums[i] + nums[L] + nums[R]
                diff = threeSum - target
                # 如果diff的绝对值比minDiff小，那么更新minDiff和closestSum
                if abs(diff) < minDiff:
                    minDiff = abs(diff)
                    closestSum = threeSum
                if diff == 0:
                    # 如果diff为0，直接返回threeSum
                    return closestSum
                elif diff < 0:
                    # 说明threeSum < target，L右移
                    L += 1
                    while(L<R and nums[L]==nums[L-1]):
                        L +=1
                else:
                    # 说明threeSum > target，R左移
                    R -= 1
                    while(L<R and nums[R]==nums[R+1]):
                        R -= 1
        return closestSum

在VSCODE上直接刷题：
Your runtime beats 97.16 % of python3 submissions
Your memory usage beats 23.06 % of python3 submissions (13.4 MB)

今天力扣的每日一题：994. 腐烂的橘子
思路想好了写了几行有点不自信放弃了。。。
最后看了题解，用广度优先搜索BFS，我不懂广度优先搜索，我就想着
逐个遍历暴力解，但看了解法也是差不多先O（n）遍历一次找到烂橘子和好橘子，然后模拟所有烂橘子感染好橘子，记录烂的最短时间，最后判断是否还有好橘子，有返回-1，否则返回时间。

class Solution:
    def orangesRotting(self, grid: List[List[int]]) -> int:
    	# 二维数组的长度
        M = len(grid)
        N = len(grid[0])
        # 记录烂橘子的位置的数组
        queue = []
        # count 表示新鲜橘子的数量
        count = 0
        # 遍历矩阵
        for r in range(M):
            for c in range(N):
                if grid[r][c] == 1:
                	# 好橘子数量 + 1
                    count += 1
                elif grid[r][c] == 2:
                	# 坏橘子位置记录
                    queue.append((r, c))
        # round 表示腐烂的轮数，或者分钟数           
        round = 0 
        # 当存在好橘子和坏橘子时循环
        while count > 0 and len(queue) > 0:
        	# 回合 + 1
            round += 1
            # 坏橘子数量 
            n = len(queue)
            # 以每个坏橘子作为起点进行搜索
            for i in range(n):
            	# 拿出一个坏橘子
                r, c = queue.pop(0)
                # 如果左边有「好」「橘子」
                if r-1 >= 0 and grid[r-1][c] == 1:
                	# 左边的橘子腐烂
                    grid[r-1][c] = 2
                    # 好橘子 - 1 
                    count -= 1
                    # 烂橘子列表中记录这个被腐烂的橘子
                    queue.append((r-1, c))
                # 如果右边有「好」「橘子」
                if r+1 < M and grid[r+1][c] == 1:
                	# 右边橘子烂掉
                    grid[r+1][c] = 2
                    # 好橘子 - 1
                    count -= 1
                    # 烂橘子加到烂橘子列表
                    queue.append((r+1, c))
                # 如果上面有「好」「橘子」
                if c-1 >= 0 and grid[r][c-1] == 1:
                    grid[r][c-1] = 2
                    count -= 1
                    queue.append((r, c-1))
                # 如果下面有「好」「橘子」
                if c+1 < N and grid[r][c+1] == 1:
                    grid[r][c+1] = 2
                    count -= 1
                    queue.append((r, c+1))
                    
        # 当还有好橘子则返回 - 1，否则返回回合数。
        if count > 0:
            return -1
        else:
            return round

执行用时 :60 ms, 在所有 Python3 提交中击败了57.61%的用户
内存消耗 :13.5 MB, 在所有 Python3 提交中击败了17.24%的用户

这道题难度只有简单，好吧。