LeetCode:Gas Station

題目地址：here

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個加油站首尾相連成一個圓，已知每個加油站的油量，以及從第i個加油站到第i+1個加油站需消耗的油量，問：能否開車從某個加油站出發，循環一圈又回到起點，如果可以返回出發的起點（車的郵箱容量是無限的）。

該題實際上可以轉化為求最大字段和問題，只不過是求循環數組的最大子段和。

我們把gas[i] - cost[i]保存在數組edge中，然后對數組edge求最大子段和（求最大子段和和時，我們把edge數組看作首尾相連的循環數組），如果edge的所有元素之和>=0，則汽車可以循環一圈，且這個最大子段的起始位置就是汽車的出發位置；若edge之和小於0，則汽車不能循環一圈。我們之所以對edge數組求最大子段和，是因為按照最大子段和問題的特性，保證了汽車從最大子段的起始端出發到最大子段的末尾的過程中汽車油箱內的油量一直是正數，且汽車走完該子段后，車內可以剩余最多的油。

其實：edge數組所有元素之和>=0 是 汽車可以循環一圈的充分必要條件

另外在求循環數組最大子段和時需要注意幾點：（1）最大子段的起始端只會循環一次，即起始端不會兩次經過起點（2）防止子段出現首尾相連的情況。這兩點代碼里都有注釋

算法時間復雜度O(N)，代碼如下：

class Solution {
public:
    int canCompleteCircuit(vector<int> &gas, vector<int> &cost)
    {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        const int n = gas.size();
        vector<int> edge(n);
        int sum = 0;//sum是edge數組所有元素之和
        for(int i = 0; i < n; i++)
        {
            edge[i] = gas[i] - cost[i];
            sum += edge[i];
        }
        if(sum < 0)
            return -1;
        int startpos = 0, endpos = 0;
        int maxSub = maxSubSegment(edge, startpos, endpos);
        return startpos;
    }

    //求循環數組的最大子段和,並返回最大子段的首尾位置
    int maxSubSegment(vector<int>&arr, int &startpos, int &endpos)
    {
        int n = arr.size();
        int result = INT_MIN, sum = -1;
        int starting = -1, ending = -1;//當前子段的起始端
        int i = 0, j=0; //j是i對n求模之前的值，即i = j%n
        while(starting < n)
        {
            if(i == starting)//防止子段首尾相接
                break;
            if(sum >= 0)
            {
                sum += arr[i];
                ending = i;
            }
            else
            {
                sum = arr[i];
                starting = j;
                //設置成j是為了控制while循環結束條件，
                //因為子段的起始位置不會過了尾部又循環到數組首部
                ending = i;
            }
            if(result < sum)
            {
                result = sum;
                startpos = starting;
                endpos = ending;
            }
            i = (i+1)%n;
            j ++;
        }

        return result;
    }
};

 

---

 

關於循環數組最大子段和可以參考我的另一篇博文：最大子數組和（最大子段和），根據這篇博文，本題有以下代碼：

class Solution {
public:
    int canCompleteCircuit(vector<int> &gas, vector<int> &cost)
    {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        const int n = gas.size();
        vector<int> edge(n);
        int sum = 0;//sum是edge數組所有元素之和
        for(int i = 0; i < n; i++)
        {
            edge[i] = gas[i] - cost[i];
            sum += edge[i];
        }
        if(sum < 0)
            return -1;
        int startpos = 0, endpos = 0;
        int maxSub = maxSumCycle(edge, startpos, endpos);
        return startpos;
    }

    //求循環數組的最大子段和,並返回最大子段的首尾位置
    int maxSumCycle(vector<int>&vec, int &left, int&right)
    {
        int maxsum = INT_MIN, curMaxSum = 0;
        int minsum = INT_MAX, curMinSum = 0;
        int sum = 0;
        int begin_max = 0, begin_min = 0;
        int minLeft, minRight;
        for(int i = 0; i < vec.size(); i++)
        {
            sum += vec[i];
            if(curMaxSum >= 0)
            {
                curMaxSum += vec[i];
            }
            else
            {
                curMaxSum = vec[i];
                begin_max = i;
            }
     
            if(maxsum < curMaxSum)
            {
                maxsum = curMaxSum;
                left = begin_max;
                right = i;
            }
            ///////////////求和最小的子數組
            if(curMinSum <= 0)
            {
                curMinSum += vec[i];
            }
            else
            {
                curMinSum = vec[i];
                begin_min = i;
            }
     
            if(minsum > curMinSum)
            {
                minsum = curMinSum;
                minLeft = begin_min;
                minRight = i;
            }
        }
        if(maxsum >= sum - minsum)
            return maxsum;
        else
        {
            left = minRight+1;
            right = minLeft-1;
            return sum - minsum;
        }
    }
};

 

---

 

網上看到了一種更優雅的實現，它的本質還是最大子段和，代碼如下

public class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        int N = gas.length, startIndex = -1;
        int sum = 0, total = 0;
        for(int i = 0; i < N; i++){
            sum += (gas[i] - cost[i]);
            total += (gas[i] - cost[i]);
            if(sum < 0){
                startIndex = i; 
                sum = 0;
            }
        }
        return total >= 0 ? startIndex + 1 : -1;
    }
}

解釋：

若 i = k時，sum小於0，表示車無法到達第k個加油站，必須從下一個加油站開始出發，total來判斷是否能夠循環一圈

 

【版權聲明】轉載請注明出處：http://www.cnblogs.com/TenosDoIt/p/3389924.html