LeetCode

Gas Station

2014.2.26 00:34

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.

Solution:

　　The problem asks you to find a position where you start at, and can finish your trip through all the stations without running out of gas.

　　Aparrently there is an O(n^2) solution. You do an O(n) scan for every position and get the correct result, as well as an TLE.

　　Let's think about a situation: you started at position i, and unluckily ran out of gas at position j. Then would it be possible to start at some position k between i and j and successfully finish the trip? The answer must be no, otherwise an O(n) algorithm cannot be achieved.

　　When you're travelling, your gas g >= 0. When you run out of gas, g < 0. So you must've spent more than you get. You started at i and stopped at j, that means g[i]~g[j - 1] are all >= 0, while g[j] < 0.

　　Let's suppose you start at some position k between i and j. If you can successfully pass position j, we have:

　　　　1. g'[j] = g[j] - g[k] >= 0, suppose you can reach j if you start at k.

　　　　2. for all k in [i, j - 1], g[k] >= 0, because you reached all positions before j.

　　　　3. g[j] < 0, you failed to reach j if you start at i.

　　　　4. g[j] - g[k] >= 0, a negative must be smaller than a non-negative, contradiction.

　　Thus we know the hypothesis above cannot hold, i.e. if you failed at position [j] when you started at position [i], you'll sure fail in the positions between them. Start searching from [j + 1] instead.

　　That conclusion expains why it's a linear algorithm, as well as online.

　　Total time complexity is O(n). Space complexity is O(1).

Accepted code:

// 1WA, 1AC, O(n) online solution.
class Solution {
public:
    int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
        int total_sum;
        int current_sum;
        int i;
        int n;
        int start_pos;
        
        n = (int)gas.size();
        if (n == 0) {
            return -1;
        }
        
        total_sum = current_sum = 0;
        start_pos = 0;
        for (i = 0; i < n; ++i) {
            total_sum += gas[i] - cost[i];
            current_sum += gas[i] - cost[i];
            if (current_sum < 0) {
                // you cannot finish the trip
                // because you used us the gasoline here
                // need a new start from next station
                start_pos = (i + 1) % n;
                current_sum = 0;
            }
        }
        
        if (total_sum < 0) {
            // impossible to finish the trip
            return -1;
        } else {
            return start_pos;
        }
    }
};