代码随想录算法训练营第 28 天 | 134. 加油站、135. 分发糖果、860. 柠檬水找零、406. 根据身高重建队列

134. 加油站

题目链接

用一个变量 curSum 统计每个站点剩余的油量，一旦 curSum 变为负数，则表示无论从前面哪一站出发都不能迈过这一站，则从这一站的下一站作为新起点再重试。

格式一：
两个 for 循环，逻辑性强，时间短

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int n = gas.length;
        int curSum = 0;
        int totalSum = 0;
        int start = 0;
        
        for (int i = 0; i < n; i++) {
            totalSum += gas[i] - cost[i];
        }
        if (totalSum < 0) {
            return -1;
        }

        for (int i = 0; i < n; i++) {
            curSum += gas[i] - cost[i];
            if (curSum < 0) {
                start = i + 1;            
                curSum = 0;
            }
        }
        
        return start;
    }
}

格式二：
一个 for 循环，更简洁

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int n = gas.length;
        int curSum = 0;
        int totalSum = 0;
        int start = 0;

        for (int i = 0; i < n; i++) {
            curSum += gas[i] - cost[i];
            totalSum += gas[i] - cost[i];
            if (curSum < 0) {
                curSum = 0;
                start = i + 1;
            }
        }

        if (totalSum < 0) { // 如果 totalSum >= 0，则必然有解
            return -1;
        }

        return start;
    }
}

135. 分发糖果（妙）

题目链接

先确定一边、再确定另一边。不要两边一起比较，会顾此失彼。

左边小孩比右边小孩得分高要从后向前遍历

class Solution {
    public int candy(int[] ratings) {
        int n = ratings.length;
        int[] candies = new int[n];
        Arrays.fill(candies, 1); // 一开始初始化为 1

        // 右边的小孩评分比左边大的情况
        for (int i = 1; i < n; i++) {
            if (ratings[i] > ratings[i - 1]) {
                candies[i] = candies[i - 1] + 1;
            }
        }

        // 左边的小孩评分比右边大的情况
        for (int i = n - 2; i >= 0; i--) {
            if (ratings[i] > ratings[i + 1]) {
                candies[i] = Math.max(candies[i], candies[i + 1] + 1);
            }
        }

        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum += candies[i];
        }
        return sum;
    }
}

860. 柠檬水找零

题目链接

1. 遇到 5 直接收。
2. 遇到 10 找 5 + 5
3. 遇到 20 找 10 + 5 或三个 5

局部最优：优先用 10 + 5 来找零 20
因为 5 是更万能的。

class Solution {
    public boolean lemonadeChange(int[] bills) {
        int n = bills.length;
        int fiveCount = 0, tenCount = 0, twentyCount = 0;
        for (int bill : bills) {
            if (bill == 5) {
                fiveCount++;
            } else if (bill == 10) {
                if (fiveCount <= 0) {
                    return false;
                }
                fiveCount--;
                tenCount++;
            } else {
                if (tenCount > 0 && fiveCount > 0) {
                    tenCount--;
                    fiveCount--;
                    twentyCount++;
                } else if (fiveCount >= 3) {
                    fiveCount -= 3;
                    twentyCount++;
                } else {
                    return false;
                }
            }
        }
        return true;
    }
}

406. 根据身高重建队列

题目链接

先按身高降序排序（升高相同按排名升序排序）

我们的排序方式保证了第一名的位置一定是 0，这样插入的时候不会越界。
后面的插入也一定不会越界，因为题目保证了有唯一解。

然后从左往右遍历，根据排名的位置插入到空列表的相应位置。

为什么是正确的，因为矮个子的人插入到前面，不会影响高个子人的排名。

class Solution {
    public int[][] reconstructQueue(int[][] people) {
        int n = people.length;
        Arrays.sort(people, new Comparator<int[]>() {
            @Override
            public int compare(int[] a, int[] b) {
                if (a[0] == b[0]) {
                    return a[1] - b[1]; // 身高相同按排名升序排列
                } else {
                    return b[0] - a[0]; // 身高不同按身高降序排列
                }
            }
        });

        List<int[]> list = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            int[] addition = people[i];
            int position = addition[1];
            list.add(position, addition); // 根据 k 插入到列表相应位置
        }
        
        return list.toArray(new int[0][]);
    }
}

贪心法总结

当涉及到两个维度的题目时，如：分发糖果和根据身高重建队列
不要两个维度一起考虑，而是先考虑一个。