贪心算法 9. 加油站

贪心算法 9. 加油站

134. 加油站 - 力扣（LeetCode）

代码随想录

难度 6 - 中等

• 稀里糊涂ac了第一版代码

• 代码：

  class Solution:
      def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
          remain_gas = [gas[i] - cost[i] for i in range(len(gas))]
          if sum(remain_gas) < 0: return -1
  
          cur_start = -1 # 存储起点的非负索引
          cur_gas = 0 # 存放当前剩余gas
          pre_gas = 0 # 存放前面前面所有加油站的剩余gas，一定是非正的
          for i in range(len(remain_gas)):
              # 当前剩余gas为0且remain_gas[i]非负时，说明找到起点
              # 即便cur_gas为0，若remain_gas[i]恰好为0，
              # 那么仍然必须要在之后remain_gas为正时再确定起点
              if cur_gas == 0 and remain_gas[i] >= 0:
                  cur_start = i
  
              # 更新当前剩余gas
              cur_gas += remain_gas[i]
              # 如果当前剩余gas变成负数，则将其加入到前面的所有剩余gas中，在i之后重新找起点
              if cur_gas <= 0:
                  pre_gas += cur_gas
                  cur_gas = 0
  
              # 一切更新完毕之后，当i抵达末尾时
              if i == len(remain_gas) - 1:
                  if cur_gas + pre_gas < 0: # 如果当前剩余gas比前面的所有剩余gas少，说明不可能有解
                      return -1
                  else: # 如果当前剩余gas比前面的所有剩余gas多，说明找到了解
                      return cur_start
  
  

• 时间复杂度：O(n)

• 空间复杂度：O(1)

学习代码随想录：

• 方法一：

  直接从全局进行贪心选择，情况如下：

  • 情况一：如果gas的总和小于cost总和，那么无论从哪里出发，一定是跑不了一圈的
  • 情况二：rest[i] = gas[i]-cost[i]为一天剩下的油，i从0开始计算累加到最后一站，如果累加没有出现负数，说明从0出发，油就没有断过，那么0就是起点。
  • 情况三：如果累加的最小值是负数，汽车就要从非0节点出发，从后向前，看哪个节点能把这个负数填平，能把这个负数填平的节点就是出发节点。

  代码：

  class Solution:
      def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
          curSum = 0  # 当前累计的剩余油量
          minFuel = float('inf')  # 从起点出发，油箱里的油量最小值
  
          for i in range(len(gas)):
              rest = gas[i] - cost[i]
              curSum += rest
              if curSum < minFuel:
                  minFuel = curSum
  
          if curSum < 0:
              return -1  # 情况1：整个行程的总消耗大于总供给，无法完成一圈
  
          if minFuel >= 0:
              return 0  # 情况2：从起点出发到任何一个加油站时油箱的剩余油量都不会小于0，可以从起点出发完成一圈
  
          for i in range(len(gas) - 1, -1, -1):
              rest = gas[i] - cost[i]
              minFuel += rest
              if minFuel >= 0:
                  return i  # 情况3：找到一个位置使得从该位置出发油箱的剩余油量不会小于0，返回该位置的索引
  
          return -1  # 无法完成一圈
  

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)

• 方法二：

  可以换一个思路，首先如果总油量减去总消耗大于等于零那么一定可以跑完一圈，说明 各个站点的加油站 剩油量rest[i]相加一定是大于等于零的。

  每个加油站的剩余量rest[i]为gas[i] - cost[i]。

  i从0开始累加rest[i]，和记为curSum，一旦curSum小于零，说明[0, i]区间都不能作为起始位置，因为这个区间选择任何一个位置作为起点，到i这里都会断油，那么起始位置从i+1算起，再从0计算curSum。

  ---

  那么为什么一旦[0，i] 区间和为负数，起始位置就可以是i+1呢，i+1后面就不会出现更大的负数？

  如果出现更大的负数，就是更新i，那么起始位置又变成新的i+1了。

  那有没有可能 [0，i] 区间 选某一个作为起点，累加到 i这里 curSum是不会小于零呢？

  ---

  参考图像

  如果 curSum<0 说明 区间和1 + 区间和2 < 0， 那么 假设从上图中的位置开始计数curSum不会小于0的话，就是 区间和2>0。

  区间和1 + 区间和2 < 0 同时 区间和2>0，只能说明区间和1 < 0， 那么就会从假设的箭头初就开始从新选择起始位置了。

  那么局部最优：当前累加rest[i]的和curSum一旦小于0，起始位置至少要是i+1，因为从i之前开始一定不行。全局最优：找到可以跑一圈的起始位置。

  局部最优可以推出全局最优，找不出反例，试试贪心！

  这个做法其实和我前面第一版的做法一样，思路也相似，但是代码更加清晰一些。

  • cur_sum和start的重置是比我的写法优秀的，不需要那么多判断

  • 为什么 **​totalSum​**​ **非负时，​​start​**​ 一定是解？（这个问题对我来说很重要）

    可以参看灵茶山艾府的题解

    由GPT生成证明如下（个人觉得解释的很好）：

    我们设：

    • ​i0, i1, ..., start-1​ 是曾经的 curSum < 0​ 的站点，它们都不能作为起点。
    • ​start​ 是最终确定的起点。

    (1) 为什么 ​start​​ 之前的点都不可能是解？

    • 在 ​curSum < 0​​ 的情况下，我们才会更新 ​start​​ 。
    • 也就是说，在 start​ 之前的所有点，都曾经有某个 curSum​ 变为负数，说明从它们开始都无法抵达 ​start​​。
    • 换句话说，start​ 是 第一个未被淘汰的起点。

    (2) 为什么 ​start​​ 之后可以完成一圈？（最重要之处）

    • ​totalSum >= 0​ 说明油是足够的，只是前面有些地方的亏空较多。

    • ​start​ 是 在 ​curSum​​ 归零之后继续累积的，也就是说：

      • 从 ​start​​ 到最后一站，油量至少可以维持不变（否则 start​ 也会被淘汰）。
      • **既然​ ​​totalSum >= 0​**​ **，那么​ ​​start​​ ​之后的盈余足以补偿之前的亏空**​，因此 ​​start​​ 一定能完成一圈。

  不管那些杂七杂八的，要点其实就一句话：

  局部最优：当前累加rest[i]的和curSum一旦小于0，起始位置至少要是i+1，因为从i之前开始一定不行；全局最优：找到可以跑一圈的起始位置。

  代码：

  class Solution:
      def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
          curSum = 0  # 当前累计的剩余油量
          totalSum = 0  # 总剩余油量
          start = 0  # 起始位置
  
          for i in range(len(gas)):
              curSum += gas[i] - cost[i]
              totalSum += gas[i] - cost[i]
  
              if curSum < 0:  # 当前累计剩余油量curSum小于0
                  start = i + 1  # 起始位置更新为i+1
                  curSum = 0  # curSum重新从0开始累计
  
          if totalSum < 0:
              return -1  # 总剩余油量totalSum小于0，说明无法环绕一圈
          return start
  

  • 时间复杂度：O(n)
  • 空间复杂度：O(1)

• 还有一个暴力法，注意模拟的过程：

  代码：

  class Solution:
      def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
          for i in range(len(cost)):
              rest = gas[i] - cost[i]  # 记录剩余油量
              index = (i + 1) % len(cost)  # 下一个加油站的索引
  
              while rest > 0 and index != i:  # 模拟以i为起点行驶一圈（如果有rest==0，那么答案就不唯一了）
                  rest += gas[index] - cost[index]  # 更新剩余油量
                  index = (index + 1) % len(cost)  # 更新下一个加油站的索引
  
              if rest >= 0 and index == i:  # 如果以i为起点跑一圈，剩余油量>=0，并且回到起始位置
                  return i  # 返回起始位置i
  
          return -1  # 所有起始位置都无法环绕一圈，返回-1
  

  • 时间复杂度：O(n^2)
  • 空间复杂度：O(1)