134. Gas Station

题目：

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, otherwise return -1.

Note:
The solution is guaranteed to be unique. 

Hide Tags

 Greedy 

链接：  http://leetcode.com/problems/gas-station/

6/8/2017

110ms, 0.8%，丢人的运行时间

想法是算出来remaining数组，然后从每个点出发开始算。

public class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        if (gas == null || cost == null || gas.length != cost.length) {
            return -1;
        }
        int[] remaining = new int[gas.length];
        for (int i = 0; i < remaining.length; i++) {
            remaining[i] = gas[i] - cost[i];
        }
        int i;
        int j = 0;

        for (i = 0; i < remaining.length; i++) {
            int sum = 0;
            if (remaining[i] < 0) {
                continue;
            }
            for (j = 0; j < remaining.length; j++) {
                int index = (i + j) % remaining.length;
                sum += remaining[index];
                if (sum < 0) {
                    break;
                }
            }
            if (j == remaining.length) {
                break;
            }
        }
        if (j == remaining.length) {
            return i;
        }
        return -1;
    }
}

别人的答案

很巧妙的方法

curGas用来计算当前的剩余是不是负的，是的话就重置curGas和startIndex。在整个过程中只要有负的，那么当时开始的startIndex就会被后面的赋值所覆盖。

最后比较存活下来的startIndex，是否totalGas在走过整个数组之后仍然是非负的，若是，则证明这个startIndex不但能够保证其之后的gas station，也能保证包括其前面的那些gas station。否则没有一个startIndex可以覆盖所有Gas station，返回-1

public class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        if (gas == null || cost == null || gas.length != cost.length) {
            return -1;
        }
        int curGas = 0;
        int totalGas = 0;
        int startIndex = 0;

        for (int i = 0; i < gas.length; i++) {
            curGas += gas[i] - cost[i];
            totalGas += gas[i] - cost[i];
            if (curGas < 0) {
                startIndex = i + 1;
                curGas = 0;
            }
        }
        if (totalGas >= 0) {
            return startIndex;
        }
        return -1;
    }
}

类似更简单的

https://discuss.leetcode.com/topic/1344/share-some-of-my-ideas

这个看上去很厉害，但是没有看懂

貌似是用2个指针，如果当前Sum非负，那么end从前往后走，若sum是负值, start从后往前尝试cover，最终等到start, end指向同一个位置时，判断最终的Sum是否非负

https://discuss.leetcode.com/topic/5088/my-ac-is-o-1-space-o-n-running-time-solution-does-anybody-have-posted-this-solution

class Solution {
public:
    int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {

       int start = gas.size()-1;
       int end = 0;
       int sum = gas[start] - cost[start];
       while (start > end) {
          if (sum >= 0) {
             sum += gas[end] - cost[end];
             ++end;
          }
          else {
             --start;
             sum += gas[start] - cost[start];
          }
       }
       return sum >= 0 ? start : -1;
    }
};

更多讨论

https://discuss.leetcode.com/category/142/gas-station