[LeetCode] Gas Station

Recording my thought on the go might be fun when I check back later, so this kinda blog has no intention to be read by others(its just for recording, not article). but if you insist, hope you enjoy it. if you find me wrong, please let me know, very appreciated!

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.

My first try:

 class Solution {
 public:
     int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
         int footPrint = ;
         int gasMount = gas[footPrint];

         while (gasMount-cost[footPrint] >= ){
             footPrint = (footPrint+)% gas.size();
             if (footPrint == ){
                 //return to first
                 return footPrint;
             }
             gasMount = gasMount - cost[footPrint] + cost[footPrint];
         }
         return -;
     }
 };

Test failed on:

Input:	[1,2], [2,1]
Output:	-1
Expected:	1

Then I realized that I'v completely underastimate the complexity of this problem(of course). what the problem really want me to provide is a choice on which station to begin with so that we can complete the circuit!
like the test case above, gas=[1,2] cost=[2,1], then if we start at gas[0] we failed to do circle, but if we choose gas[1] to begin with, we first make to gas[0] left for 1 gas, then we refule at gas[0] to get 2 gas,
and then we can make it to gas[1], thats complete the circuit, so the program output 1, because this is where we begin with.
But you may wonder, there might be many choices which satisfy this condition, your right, but the NOTE told us, there is only one :), so with that understanding, I have something to work with. 

  Here I am again, but the problem still not solved:( here is the code:
  My 2nd try:

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

         for (int i=; i<gas.size(); i++){
             footPrint = i;
             gasMount = gas[footPrint];

             while (gasMount - cost[footPrint] >= ){
                 gasMount -= cost[footPrint];
                 footPrint = (footPrint+)%gas.size();
                 gasMount += gas[footPrint];
                 if (footPrint == i){
                     return footPrint;
                 }
             }
         }
         return -;
     }
 };

This is really looks like the anwser, I mean its a naive but worked version. it passed all the test until it meet the very large one....I think there might be thousands of elements in input array...
and the system throw out the Time Limit Exceeded error. damn! that make things even more complicated! That means this naive solution is not acceptable, we have to do it smart, algorithem is a bitch :p

And finally, I did not work out this problem, what a shame to faile my first leetcode challenge :( , anyway, I did search for anwsers and I really got some hint, also I stole some idea from others and
then implemented my own AC version.

My final anwser:

     int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
         int total=;
         for (int i=; i < gas.size(); i++){
             int j=;
             for (; j < gas.size(); j++){
                 total += gas[((i+j)%gas.size())] - cost[(i+j)%gas.size()];
                 if (total < ){
                     i +=j;
                     total = ;
                     break;
                 }
             }
             if (j==gas.size())return i;
         }
         return -;
     }

This is a really nice approach which cost only O(n) time, If you think its O(n^2) by just simply looking at the double for loop, then you are wrong, mind that the j is pushing the i forward.
whenever total is less then 0, the elements which between i to j is no longer need to be checked again, so we simply skip them, in this way, theres actually only 1 loop occurred during the entire operation.
the thinking behind this algorithm is called Dynamic Programming, and this problem is very similar to Longest Consecutive Sequence problem, the difference is this one do a circuit.

For the purpose of enhancing what I'v learned, I decide to write down a snippet of code for solving Longest Consecutive Sequence problem. 

 int maxSum(int *a, int len){
     int i, sum=, max=;
     for (i=;i<len;i++){
         if (sum >= ){
             sum += a[i];
             if (sum > max){
                 max = sum;
             }
         else{
             sum = a[i];
         }
     }
     return max;
 }