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.

简要分析：有N个gas station，每一个都有一定的gas存储量gas[ i ] , 在汽车到达这个gas station时 ，加上此gas station的所有存储量。（由于汽车的存储是不限制的），看其是否能到达下一个gas station ，即当前的油量是否小于  cost[ i ]。 简单的想，就是保证从某一个点开始出发，保证不会在中途出现没有油的情况。

首先：各个加油站油的存储量相当于一个数组   a1, a2, a3, ... , an。各个加油站之间的消耗量为 cost[ i ] , 于是我们只需要将每次车子一到达加油站 i  ，就将其油量之间减少  cost [ i ] 即可，如果剩余的油量大于或者等于0，则相当于到达了加油站 i+1 ，因此：

首先计算如果加油站 i   要顺利到达下一个加油站 i + 1，那么该加油站有多少结余的油量，定义如下数组need(其中正数表示结余的油量，负数表示需要的油量)：

rest[ i ]  =    gas[ i ] - cost[ i ]；

看其是否小于车辆到达时需要的油量，也就是说，如果车辆到达时需要的油量大于该站剩余的，那么不满足。显然我们应当从rest为正的加油站中选择出发的加油站。

因此代码如下：

    int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
        if(gas.size() == 0 || gas.size() != cost.size()) return -1; //输入异常，直接返回
        vector<int> rest;
        int len = gas.size();
        
        for(int i = 0 ; i < len ; ++i)
        {
            rest.push_back(gas[i] - cost[i]); //计算每个加油站在到达下一个加油站可以结余的油量
        }
        int sum = 0;
        for(int i = 0 ; i < len ; ++i )
        {
            sum += rest[i];   
        }
        if(sum < 0) return -1;  <span style="font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;">//如果所有的结余量都小于0，那么直接返回。</span>
        sum = 0;
        int index;
        for(index = 0 ; index < len ; ++index)
        {
            sum = 0 ;
            if(rest[index] >= 0)
            {
                /*
                for(int j = 0 ; ( j < index) ||( (j >= index) && (j < len) ) ; ++j)
                {
                    sum += rest[j];
                    if(sum < 0) break;
                }
                  这段代码比较次数太多，直接超时。*/ 
                  
                for(int j = index; j < len ; ++j)
                {
                    sum += rest[j];
                    if(sum < 0) break;//如果在某一步油量不够用，那么该出发点有问题。找下一个开始。
                }
                if(sum >= 0)
                {
                    for(int j = 0 ; j < index ; ++j)
                        sum += rest[j];
                        if(sum < 0 )break;
                }
                if(sum >= 0)return index;
            }
            
        }
        return -1;
    }

总结：此题是个很简单的题目，只要考虑到了每个 “ 供 >= 需” 的情况，那么就可以很简单的解决这个问题了。

Trail 2：看过大神们的代码，知道还有O（n）的算法，下面做一些简单的介绍并且给出该算法的正确性证明。

首先，为了简单起见，我们直接考察上述定义的数组 rest ，即rest[1], rest[2], ... , rest[n] ,只需要考虑这个数组存在某一个k （1 =< k <= n）,使得数组 rest[ k ] , rest[k + 1] , ... , rest[ n ] , rest[1] , ... , rest[ k - 1]，这个数组的部分和（从第一项开始加的）都是正的。因此代码实现如下：

    int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
              assert(gas.size() == cost.size());
        if(gas.size() == 0) return 0;
        int len = gas.size();
        
        int total = 0;
        int subSum = 0;
        int prev = -1; //用于记录不满足“供不小于需”的加油站
        
        for(int i = 0; i < len; ++i)
        {
            subSum += (gas[i] - cost[i]);
            total += (gas[i] - cost[i]);
            if(subSum < 0)
            {
                prev = i;
                subSum = 0;
            }
        }
        return (total >= 0) ?(prev+1):-1;
    }

正确性证明：上述算法只对数组进行遍历一遍，假设在某一个加油站 i 处的油量为负，不足以再往下走到 i +1，那么我们接下来证明 任意的 看

k ( 1 <= k <= i)，都不可能作为起点。也就是说1到i之间的所有的加油站都不满足条件。即sum[1...i] < 0.

假设存在一个 m ，（1 <= m <= i） ，可以作为起点，那么由起点应该满足的条件，（从该点开始一直往后加，中间每一次的和都应该不小于0），因此有sum[ k,...,i] (表示ｋ到ｉ的和大于等于０.)，那么由于sum[1,...,i] < 0 ,因此 sum[1,...,k ] < 0,这与  “到达 i 处油量才不足” 这一条件矛盾，因此假设不成立。即原结论成立。

因此，我们考虑到某个 i 的时候不满足条件，那么当前的起点到 i 的所有点都不满足。

总结：上述算法确实是很精彩，只要能够想到正确性证明，就很容易解决。。