[LeetCode] Gas Station，轉化為求最大序列的解法，和更簡單簡單的Jump解法。

LeetCode上 Gas Station是比較經典的一題，它的魅力在於算法足夠優秀的情況下，代碼可以簡化到非常簡潔的程度。

原題如下

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.

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

 

最直觀的思路

最直觀的解法自然是O(n²) 時間復雜度的挨個嘗試。這里不做討論。

 

思路變化一

如果你是司機，你肯定會選這么樣的一個站點：從這個站點出發，先遇到的站點都是給車加油大於耗油的，從而讓車攢夠足夠的余油，來撐過剩下的那些耗油大於加油的站點。

對於站點 i，我們把 gas[i] - cost[i] 當作整體考慮，我們用diff[i] = gas[i] - cost[i] 表示從當前站點出發，到下一個站點后剩余的油量。

因此結合司機的經驗，題目就是需要找出這么一個點，從這個點出發，diff的累加值能達到峰值。

想起了什么嗎？這道題就是求diff[]數組上的 和最大連續子序列，這個最大子序列的起始點就是車的出發點！如果車從這兒開都不能做到油箱不空，那么這個題目就該返回-1了。

因此，這道題轉化成了 求循環數組的最大子序列問題。

這種問題的求法，主要就是利用動態規划，求出diff[0] 到 diff[size-1]這個非循環數組上的最大子序列MAX和最小子序列MIN。然后比較MAX和 Total - MIN，選出較大值(Total為 diff數組所有元素和)。當然，我們要求的不是最大子序列的和，而是最大子序列的其實位置。因此，如果MAX 較大，返回MAX所代表的最大子序列的起始元素；否則，返回MIN所代表的最小子序列末尾的下一個元素。

參照這種思路，我們可以寫出如下代碼：

class Solution {
public:
    int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
        if(gas.size() != cost.size()) return -1;
        if(gas.size() == 0) return -1;
        int MAX = gas[0] - cost[0], MIN = gas[0] - cost[0], max = gas[0] - cost[0], min = gas[0] - cost[0];
        int stmax = 0, stMAX = 0, endMIN = 0;
        int total = 0, diff = 0;
        for(int i = 0; i < gas.size(); ++i){
            diff = gas[i] - cost[i];
            total += diff;
            
            if(max < 0){
                max = diff;
                stmax = i; //stmax用來存儲當前序列的起始點
            }else max += diff;
            if(max > MAX){
                MAX = max;
                stMAX = stmax; //stmax用來存儲最大序列的起始點
            }
            
            if(min > 0) min = diff;
            else min += diff;
            if(min < MIN){
                MIN = min;
                endMIN = i; //endMIN用來存儲最小序列的末尾點
            }
        }
        return total < 0 ? -1 : (MAX >= (total - MIN) ? stMAX : (endMIN+1) % gas.size()); //通過比較 MAX 和 (total - MIN) 返回相應結果。
    }
};

 

這樣的解法的時間復雜度是 O(N)

在末尾可以發現，最后我們在通過比較 MAX 和 (total - MIN) 得出結果后，並沒有模擬讓車從所得站點跑一圈，來驗證是否正確，而是直接通過比較 total 和 0的關系來確定是否有解。

如果Total >= 0，那么直接返回站點，如果Total < 0，返回-1。

也就是說，直接通過Total的值就可以來確定該題是否有解。

 

思路變化二

這道題最直觀的思路，是逐個嘗試每一個站點，從站 i 點出發，看看是否能走完全程。如果不行，就接着試着從站點 i+1出發。

假設從站點 i 出發，到達站點 k 之前，依然能保證油箱里油沒見底兒，從k 出發后，見底兒了。那么就說明 diff[i] + diff[i+1] + ... + diff[k] < 0，而除掉diff[k]以外，從diff[i]開始的累加都是 >= 0的。也就是說diff[i] 也是 >= 0的，這個時候我們還有必要從站點 i + 1 嘗試嗎？仔細一想就知道：車要是從站點 i+1出發，到達站點k后，甚至還沒到站點k，油箱就見底兒了，因為少加了站點 i 的油。。。

因此，當我們發現到達k 站點郵箱見底兒后，i 到 k 這些站點都不用作為出發點來試驗了，肯定不滿足條件，只需要從k+1站點嘗試即可！因此解法時間復雜度從O(n²)降到了 O(2n)。之所以是O(2n)，是因為將k+1站作為始發站，車得繞圈開回k，來驗證k+1是否滿足。

等等，真的需要這樣嗎？

我們模擬一下過程：

a. 最開始，站點0是始發站，假設車開出站點p后，油箱空了，假設sum1 = diff[0] +diff[1] + ... + diff[p]，可知sum1 < 0；

b. 根據上面的論述，我們將p+1作為始發站，開出q站后，油箱又空了，設sum2 = diff[p+1] +diff[p+2] + ... + diff[q]，可知sum2 < 0。

c. 將q+1作為始發站，假設一直開到了未循環的最末站，油箱沒見底兒，設sum3 = diff[q+1] +diff[q+2] + ... + diff[size-1]，可知sum3 >= 0。

要想知道車能否開回 q 站，其實就是在sum3 的基礎上，依次加上 diff[0] 到 diff[q]，看看sum3在這個過程中是否會小於0。但是我們之前已經知道 diff[0] 到 diff[p-1] 這段路，油箱能一直保持非負，因此我們只要算算sum3 + sum1是否 <0，就知道能不能開到 p+1站了。如果能從p+1站開出，只要算算sum3 + sum1 + sum2 是否 < 0，就知都能不能開回q站了。

因為 sum1, sum2 都 < 0，因此如果 sum3 + sum1 + sum2 >=0 那么 sum3 + sum1 必然 >= 0，也就是說，只要sum3 + sum1 + sum2 >=0，車必然能開回q站。而sum3 + sum1 + sum2 其實就是 diff數組的總和 Total，遍歷完所有元素已經算出來了。因此 Total 能否 >= 0，就是是否存在這樣的站點的 充分必要條件。

這樣時間復雜度進一步從O(2n)降到了 O(n)。

基於這個思路，可以寫出更加簡潔的代碼：

class Solution {
public:
    int canCompleteCircuit(vector<int> &gas, vector<int> &cost) {
        if(gas.size() == 0 || cost.size() == 0 || gas.size() != cost.size()) return -1;
        int total = 0, sum = 0, start = 0;
        for(int i = 0; i < gas.size(); ++i){
            total += (gas[i] - cost[i]);
            if(sum < 0){ //發現油箱空了，從下一個站點嘗試
                sum = (gas[i] - cost[i]);
                start = i;
            }else
                sum += (gas[i] - cost[i]);
        }
        return total < 0 ? -1 : start; //用total判斷start 是否是滿足要求的解
    }
};

 

 

這種解法其實依托於一個數學命題：

對於一個循環數組，如果這個數組整體和 SUM >= 0，那么必然可以在數組中找到這么一個元素：從這個數組元素出發，繞數組一圈，能保證累加和一直是出於非負狀態。

我在這里給出比較簡單的證明，來證明這個命題為真：用反證法，假設數組A[]的和SUM >= 0，對於所有元素都不能做到累加和能保持非負。我們取任意元素，下標為p，假設累加至下標為q-1時，累加和還能保持非負，但是加上A[q]后，累加和成了負數。那么就是 A[p] + .. + A[q] < 0 (1)；  A[p] + .. + A[k] >= 0 (p <= k <= q-1) (2)。

又因為SUM >= 0，因此A[q+1] + ... A[p-1] = SUM - (A[p] + .. + A[q]) > 0，也就是說，從q+1開始，能保證 A[q+1] + ... A[p-1] > 0 (3)。既然A[q+1] + ... A[p-1] > 0，那么聯合結論(2)，A[q+1] + ... A[p-1] + A[p] + .. + A[k] 也是正數，也就是說，從A[q+1]出發，能保證到達A[p], A[p+1].... , A[q-1] 時累加和都是非負數；到達A[q]時呢？正好繞一圈，累加和就是SUM，因此此時累加和也是非負數。

那么，至此，我們可以保證從A[q+1] 出發，到達A[p], A[p+1].... , A[q] 時累加和都是非負數。剩余部分的部分是A[q+2], A[q+3]... A[p-1]，只要繼續證明到達這些元素時，累加和是非負即可。由於結論(3)，我們已經知道 A[q+1] + ... A[p-1] > 0，因此這道題就是證明總和 >0 時，A[q+1] 到達 A[q+2] 至  A[p-1]中的任意元素，其和都依然大於等於0。

之前用模擬的方式，大概給出了直觀的推衍，但是暫時沒能給出嚴格的數學證明(無視那段被我划掉的部分吧。。)。