Medium

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.

题目大意：一个汽车在循环道路上走，每到一个站就加一次油，gas[i]是第i个加油站可供汽车加油的量，cost[i]是从i站到i+1站要消耗的油量。汽车在起点油箱内的油为0，那么求以哪个站为起点能使汽车走完全程。-1表示没有站点能使得汽车走完全程。

方法：
方法一：
一看到要选择站点我就想到了双层for循环，比较油箱所剩油量和从当前站到下一站要消耗的油量，如果汽车能顺利走完一圈就返回这个站点值i，否则换下一个站点作为开始站。
代码如下：

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int len = gas.size();
        for (int i = 0; i < len; ++i) {
            int tank = 0;
            int flag = 1;
            for (int k = 0,j=i; k < len; ++k,++j) {
                if (j >= len) {
                    j -= len;
                }
                tank += gas[j];
                if (cost[j] > tank) {
                    flag = 0;
                    break;
                }
                else {
                    tank -= cost[j];
                }
            }
            if (flag==1 && tank >= 0)return i;
        }
        return -1;
    }
};

 

方法二：
按照以上思路倒是简单易懂，但是运行时间过长，运行时间为θ(n^2)。
参考了网上的思路，一次遍历完成计算。计算出汽车走完全程所能得到的油量和所要消耗的油量，如果总消耗油量大于总获得油量，那么无论从哪个站点开始都不能支撑汽车走完全程。如果总消耗油量小于或等于总获得油量，那么即使当前站点的油箱出现赤字也总能从后边的站获得补给。
从第一个站点开始计算油箱内所剩油量，如果油量为负，那么开始站就在该站之后。
代码如下：

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int len = gas.size();
        int sumGas = 0, sumCost = 0, tank = 0;
        int start = 0;
        for (int i = 0; i < len; ++i) {
            sumCost += cost[i];
            sumGas += gas[i];
            tank += gas[i]-cost[i];
            if (tank < 0) {
                start = i + 1;
                tank = 0;
            }
        }
        if (sumCost > sumGas) {
            return -1;
        }
        else return start;
    }
};