【贪心算法】LeetCode #134 加油站

题目链接：

LeetCode #134 加油站

题目描述：

#134. 加油站（难度：中等）

在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。

你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。

如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。

说明:

如果题目有解，该答案即为唯一答案。
输入数组均为非空数组，且长度相同。
输入数组中的元素均为非负数。
示例 1:

输入:
gas = [1,2,3,4,5]
cost = [3,4,5,1,2]

输出: 3

解释:
从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油
开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油
开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油
开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油
开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。
因此，3 可为起始索引。
示例 2:

输入:
gas = [2,3,4]
cost = [3,4,3]

输出: -1

解释:
你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。
我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油
开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油
开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油
你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
因此，无论怎样，你都不可能绕环路行驶一周。

通过次数40,847 提交次数76,151

初步分析：

想要满足题目要求，需要两个条件：
*要能够走完一圈，即总的汽油升数 gas[] > 总消耗 cost[]；
*想要从第 i 个加油站到第 i + 1 个加油站，需要保证剩余油量 remain + 可以加多少油 gas[i] - 到下一个加油站位置需要消耗的油量 cost[i]，三者运算后的 remain >= 0。

算法思想：

• 先去计算每个加油站处，能加的油和开往下一个加油站消耗的差值 gas[i] - cost[i];
• 起步一定是从某个差值 >= 0处，否则到不了下一个加油站，更不可能走完一圈。故对于于差值 >= 0的地方，都需要判断是否能走完环路：
  • 维护一个 remain，指的是油箱中剩余的油；
  • 每走一个加油站，就去计算新的 remain += gas[i] - cost[i]；
  • 只要 remain < 0，就无法环路行驶一圈。

代码01：

/*
 * 想要环路行驶一周，需要总的汽油升数 > 消耗
 * 先去计算每个加油站处，能加的油和开往下一个加油站消耗的差值 gas[i] - cost[i]
 * 对于差值 >= 0的地方，都需要判断是否能走完环路
 * 维护一个 remain，指的是油箱中剩余的油量
 * 每走一个加油站，就去计算新的 remain
 * 只要 remain < 0，就无法环路行驶一周
 */
public class Solution {
	
    public int canCompleteCircuit(int[] gas, int[] cost) {
    	int remain = 0;
    	for(int i = 0; i < gas.length; i++) {
    		if(gas[i] >= cost[i]) {
    			remain = gas[i] - cost[i];
    			int j = (i + 1) % gas.length;
    			while(j != i && j < gas.length) {
    				remain += gas[j] - cost[j];
    				if(remain < 0) break;
    				j = (j + 1) % gas.length;
    			}
    			if(j == i) return i;
    		}
    	}
    	return -1;
    }
}

时间复杂度为 O(n^2)，显然是较高的，有没有什么办法可以把时间复杂度降到 O(n)？

进一步分析：

先来看看下面的情况：

• 如果从 i 到 j - 1 的差值累加的和 >= 0，而从 i 到 j 的差值累加的和 < 0，说明不可能从 i ~ j 之间起步，只有在 j + 1 及其往后起步，才有可能环路。

怎么理解？

• 因为已知 i ~ j - 1 之间的差值累加均 >= 0;
• 假设从 i ~ j 之间起步，那么相当于减去一个 >= 0的数；
• 已知到 i ~ j 差值累加 < 0，若从其中间范围起步，差值累加要再减去一个非负数，必然 < 0;
• 故如果可能形成环路，只有可能是在 j + 1 及其往后起步。

举个栗子：

比如 gas[] - cost[] = {3, -3, 4, 2, -7, 2}

• 其中 3 - 3 + 4 + 2 = 6 > 0;（i = 0，j = 4）
• 走到第 j 个位置，差值为 -7，累加和 = -1 < 0
• 显然想从 4 或者 2 起步，都无法满足第 j 个位置的 -7
• 所以如果能形成环路，必然是从第 j + 1 及其以后的位置起
• 该例子从索引为 5 的位置（即最后一个位置）开始走，可以形成环路。

代码02（时间复杂度O(n)）：

/*
* 时间复杂度为 O(n)：遍历一遍
* 如果从 i 到 j 的差值累加的和 < 0，说明不可能从 i ~ j 之间起步
* 一定是在 j + 1 往后，才有可能环路一周
* 因为 i ~ j 之间的差值累加均 >= 0，
* 如果从其中间开始，那么相当于减去一个 >= 0的数
* 就不可能满足累加和 >= 0
* 比如 gas[] - cost[] = {3, -3, 4, 2, -7, 2}
* 其中 3 - 3 + 4 + 2 = 6 > 0;
* 走到第 j 个位置，差值为 -7，累加和 = -1 < 0
* 显然想从 4 或者 2 起步，都无法满足第 j 个位置的 -7
* 所以如果能形成环路，必然是从第 j + 1 及其以后的位置起步的
*/
public class Solution {
	
    public int canCompleteCircuit(int[] gas, int[] cost) {
    	int remain = 0;//记录差值的累加和，如果 < 0 不能走了，就重置
    	int total = 0;//记录总的可加油数 - 消耗数，如果 < 0，肯定不能走一圈
    	int start = 0;
    	for(int i = 0; i < gas.length; i++) {
    		total += gas[i] - cost[i];
    		remain += gas[i] - cost[i];
    		if(remain < 0) {
    			remain = 0;
    			start = i + 1;
    		}
    	}
    	return total >= 0 ? start : -1;
    }
}