Leetcode第231 场周赛

5697. 检查二进制字符串字段

给你一个二进制字符串 s ，该字符串 不含前导零 。

如果 s 最多包含 一个由连续的 ‘1’ 组成的字段 ，返回 true 。否则，返回 false 。

示例 1：

输入：s = “1001”

输出：false

解释：字符串中的 1 没有形成一个连续字段。

示例 2：

输入：s = “110”

输出：true

提示：

• 1 <= s.length <= 100

• s[i] 为 ‘0’ 或 ‘1’

• s[0] 为 ‘1’

class Solution: 

    def checkOnesSegment(self, s: str) -> bool: 

        flag = False 

        for i in range(1,len(s)): 

            if s[i] == '0': 

                flag = True 

            elif flag and s[i] == '1': 

                return False 


        return True 

5698. 构成特定和需要添加的最少元素

给你一个整数数组 nums ，和两个整数 limit 与 goal 。数组 nums 有一条重要属性：abs(nums[i]) <= limit 。

返回使数组元素总和等于 goal 所需要向数组中添加的 最少元素数量 ，添加元素 不应改变 数组中 abs(nums[i]) <= limit 这一属性。

注意，如果 x >= 0 ，那么 abs(x) 等于 x ；否则，等于 -x 。

示例 1：

输入：nums = [1,-1,1], limit = 3, goal = -4

输出：2

解释：可以将 -2 和 -3 添加到数组中，数组的元素总和变为 1 - 1 + 1 - 2 - 3 = -4 。

示例 2：

输入：nums = [1,-10,9,1], limit = 100, goal = 0

输出：1

提示：

• 1 <= nums.length <= 10⁵
• 1 <= limit <= 10⁶
• -limit <= nums[i] <= limit
• -10⁹ <= goal <= 10⁹

class Solution: 

    def minElements(self, nums: List[int], limit: int, goal: int) -> int: 

        res = 0 

        tmp = 0 

        tempSum = sum(nums) 

        if tempSum < goal:     

            res = (goal - tempSum) // limit + 1 if (goal - tempSum) % limit != 0 else (goal - tempSum) // limit 

        elif tempSum > goal: 

            res = (tempSum - goal) // limit + 1 if (tempSum - goal) % limit != 0 else (tempSum - goal) // limit 


        return res 

5699. 从第一个节点出发到最后一个节点的受限路径数

示例 1：

示例1：

输入：n = 5, edges = [[1,2,3],[1,3,3],[2,3,1],[1,4,2],[5,2,2],[3,5,1],[5,4,10]]

输出：3

解释：每个圆包含黑色的节点编号和蓝色的 distanceToLastNode 值。三条受限路径分别是：

1. 1 --> 2 --> 5

2. 1 --> 2 --> 3 --> 5

3. 1 --> 3 --> 5

示例 2：

输入：n = 7, edges = [[1,3,1],[4,1,2],[7,3,4],[2,5,3],[5,6,1],[6,7,2],[7,5,3],[2,6,4]]

输出：1

解释：每个圆包含黑色的节点编号和蓝色的 distanceToLastNode 值。唯一一条受限路径是：1 --> 3 --> 7 。

1. 将边转换为邻接表

为啥不用邻接矩阵？因为占的空间大，而且会超时。

neighs = defaultdict(dict) 

for item in edges: 

    neighs[item[0]][item[1]] = item[2] 

    neighs[item[1]][item[0]] = item[2] 

2. Dijkstra算法求出从n点到各点的最短路径

Dijkstra算法本质是贪心算法，每次去寻找从n点出发可达的最近的点，确定这个点的最短距离，然后更新从n点出发且通过这个点的所有点的距离。

普通版：

# 存储所有点的最短路径 

dist = [float('inf')] * (n + 1) 

dist[n] = 0 

unchecked = {i for i in range(1, n + 1)} 

while unchecked: 

    # 找到未到达过的且距离最短的节点 
    closest_node = -1 
    for i in unchecked: 
        if closest_node == -1 or dist[i] < dist[closest_node]: 
            closest_node = i 
    unchecked.remove(closest_node) 

 
    # 更新这个点可达的所有点 
    for i in neighs[closest_node]: 
        dist[i] = min(dist[i], dist[closest_node] + neighs[closest_node][i]) 

因为每次只需要找到寻找从n点出发可达的最近的点，这就使用最小堆优化查找过程，可以避免遍历所有点。

堆优化版：

# 迪杰斯特拉算法（最小堆优化） 

distance: List[int] = [float('inf')] * (n + 1) 
distance[n] = 0 
checked = set() 
heap = [(0, n)] 

while heap: 

    # 找到距离最短的节点 
    closest_dist, closest_node = heapq.heappop(heap) 
    # 已经确定最短距离的节点，不需要重复更新 
    if closest_node in checked: 
        continue 
    checked.add(closest_node) 

    # 更新这个点可达的所有点 

    for i in neighs[closest_node]: 
        new_dist = distance[closest_node] + neighs[closest_node][i] 
        if distance[i] > new_dist: 
            distance[i] = new_dist 
            heapq.heappush(heap, (new_dist, i)) 

3. 动态规划遍历每个点相邻的最短距离小于自身的节点

# 计算满足首先路径的点 
last_node = [0] * (n + 1) 
last_node[n] = 1 

# 根据最短距离进行排序 
arr = sorted([i for i in range(len(distance))], key=lambda x: distance[x]) 
for node in arr: 
    for i in neighs[node]: 
        if distance[i] < distance[node]: 
            last_node[node] += last_node[i] 

    if node == 1: 
        break 

4. 输出结果

对10^9 + 7取余

return last_node[1] % (10 ** 9 + 7) 

class Solution: 

    def countRestrictedPaths(self, n: int, edges: List[List[int]]) -> int: 

        # 邻接表 
        neighs = defaultdict(dict) 
        for item in edges: 
            neighs[item[0]][item[1]] = item[2] 
            neighs[item[1]][item[0]] = item[2] 


        # 迪杰斯特拉算法（最小堆优化） 
        distance = [float("inf")] * (n+1)
        distance[n] = 0 
        checked = set() 
        heap = [(0,n)] 

 
        while heap: 

            # 找到距离最短的节点 
            closese_dist, closese_node = heapq.heappop(
            # 已经确定最短距离的节点，不需要重复更新 
            if closese_node in checked: 
                continue 
            checked.add(closese_node) 

             
            # 更新这个点可达的所有点 
            for i in neighs[closese_node]: 
                new_dist = distance[closese_node] + neighs[closese_node][i] 
                if distance[i] > new_dist: 
                    distance[i] = new_dist 
                    heapq.heappush(heap,(new_dist,i)) 

   
         # 计算满足首先路径的点 
        last_node = [0] * (n+1) 
        last_node[n] = 1 

    
        # 根据最短距离进行排序 
        arr = sorted([i for i in range(len(distance))], key = lambda x:distance[x]) 

        for node in arr: 
            for i in neighs[node]: 
                if distance[i] < distance[node]: 
                    last_node[node] += last_node[i] 
           
            if node == 1: 
                break 

        return last_node[1] %(10**9+7)