There are N gas stations along a circular route, where the amount of gas at station i is gas[i].

You have a car with an unlimited gas tank and it costs cost[i] of gas to travel from station i to its next station (i+1). You begin the journey with an empty tank at one of the gas stations.

Return the starting gas station‘s index if you can travel around the circuit once in the clockwise direction, otherwise return -1.

Note:

• If there exists a solution, it is guaranteed to be unique.
• Both input arrays are non-empty and have the same length.
• Each element in the input arrays is a non-negative integer.

Example 1:

Input: 
gas  = [1,2,3,4,5]
cost = [3,4,5,1,2]

Output: 3

Explanation:
Start at station 3 (index 3) and fill up with 4 unit of gas. Your tank = 0 + 4 = 4
Travel to station 4. Your tank = 4 - 1 + 5 = 8
Travel to station 0. Your tank = 8 - 2 + 1 = 7
Travel to station 1. Your tank = 7 - 3 + 2 = 6
Travel to station 2. Your tank = 6 - 4 + 3 = 5
Travel to station 3. The cost is 5. Your gas is just enough to travel back to station 3.
Therefore, return 3 as the starting index.

Example 2:

Input: 
gas  = [2,3,4]
cost = [3,4,3]

Output: -1

Explanation:
You can‘t start at station 0 or 1, as there is not enough gas to travel to the next station.
Let‘s start at station 2 and fill up with 4 unit of gas. Your tank = 0 + 4 = 4
Travel to station 0. Your tank = 4 - 3 + 2 = 3
Travel to station 1. Your tank = 3 - 3 + 3 = 3
You cannot travel back to station 2, as it requires 4 unit of gas but you only have 3.
Therefore, you can‘t travel around the circuit once no matter where you start.

在一條環路上有 N 個加油站，其中第 i 個加油站有汽油 gas[i] 升。

你有一輛油箱容量無限的的汽車，從第 i 個加油站開往第 i+1 個加油站需要消耗汽油 cost[i] 升。你從其中的一個加油站出發，開始時油箱為空。

如果你可以繞環路行駛一周，則返回出發時加油站的編號，否則返回 -1。

說明:

• 如果題目有解，該答案即為唯一答案。
• 輸入數組均為非空數組，且長度相同。
• 輸入數組中的元素均為非負數。

示例 1:

輸入: 
gas  = [1,2,3,4,5]
cost = [3,4,5,1,2]

輸出: 3

解釋:
從 3 號加油站(索引為 3 處)出發，可獲得 4 升汽油。此時油箱有 = 0 + 4 = 4 升汽油
開往 4 號加油站，此時油箱有 4 - 1 + 5 = 8 升汽油
開往 0 號加油站，此時油箱有 8 - 2 + 1 = 7 升汽油
開往 1 號加油站，此時油箱有 7 - 3 + 2 = 6 升汽油
開往 2 號加油站，此時油箱有 6 - 4 + 3 = 5 升汽油
開往 3 號加油站，你需要消耗 5 升汽油，正好足夠你返回到 3 號加油站。
因此，3 可為起始索引。

示例 2:

輸入: 
gas  = [2,3,4]
cost = [3,4,3]

輸出: -1

解釋:
你不能從 0 號或 1 號加油站出發，因為沒有足夠的汽油可以讓你行駛到下一個加油站。
我們從 2 號加油站出發，可以獲得 4 升汽油。 此時油箱有 = 0 + 4 = 4 升汽油
開往 0 號加油站，此時油箱有 4 - 3 + 2 = 3 升汽油
開往 1 號加油站，此時油箱有 3 - 3 + 3 = 3 升汽油
你無法返回 2 號加油站，因為返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
因此，無論怎樣，你都不可能繞環路行駛一周。

12ms

 1 class Solution {
 2     func canCompleteCircuit(_ gas: [Int], _ cost: [Int]) -> Int {
 3         var sum = 0 
 4         var total = 0  
 5         var start = 0  
 6         for i in 0..<gas.count{
 7             sum += gas[i] - cost[i]
 8             total += gas[i] - cost[i]
 9             if sum < 0 {
10                 start = i + 1
11                 sum = 0
12             }
13         }
14         if total < 0 {
15             return -1
16         } else {
17             return start
18         }
19     }
20 }

16ms

 1 class Solution {
 2     func canCompleteCircuit(_ gas: [Int], _ cost: [Int]) -> Int {
 3         var start = 0, tank = 0, deficit = 0
 4         for i in 0..<gas.count {
 5             tank += gas[i]
 6             if tank >= cost[i] {
 7                 tank -= cost[i]
 8             } else {
 9                 deficit += cost[i] - tank
10                 tank = 0
11                 start = i + 1
12             }
13         }
14         if tank < deficit || start == gas.count { return -1 } 
15         return start
16     }
17 }

20ms

 1 class Solution {
 2     func canCompleteCircuit(_ gas: [Int], _ cost: [Int]) -> Int {
 3         let totalGas = gas.reduce(0) { $0 + $1 }
 4         let totalCost = cost.reduce(0) { $0 + $1 }
 5         
 6         guard totalGas >= totalCost else {
 7             return -1
 8         }
 9         
10         var start = 0
11         var gasSum = 0
12         var gasCost = 0
13         
14         for (i, currentGas) in gas.enumerated() {
15             let currentCost = cost[i]
16         
17             gasSum += currentGas
18             gasCost += currentCost
19             
20             if gasSum < gasCost {
21                 start = i + 1
22                 gasSum = 0
23                 gasCost = 0
24             }
25         }
26         return start
27     }
28 }

176ms

 1 class Solution {
 2     func canCompleteCircuit(_ gas: [Int], _ cost: [Int]) -> Int {
 3         guard gas.count > 0 && cost.count > 0 else {
 4             return -1
 5         }
 6         
 7         var potentailIndex = [Int]()
 8         
 9         for i in 0..<gas.count {
10             if gas[i] - cost[i] >= 0 {
11                 potentailIndex.append(i)
12             }
13         }
14         
15         
16         for index in potentailIndex {
17             var count = gas.count - 1
18             var remining = 0
19             var currentIndex = index
20             for _ in 0...count {
21                 remining = gas[currentIndex] + remining - cost[currentIndex]
22                 if remining < 0 {
23                     break
24                 }
25                 if currentIndex == count {
26                     currentIndex = 0
27                 } else {
28                     currentIndex += 1
29                 }    
30             }
31             if remining >= 0 {
32                 return index
33             }
34         }
35         
36         return -1
37     }
38 }

[Swift]LeetCode134. 加油站 | Gas Station