LeetCode刷题指南：贪心算法

45. 跳跃游戏 II

思路：广度优先遍历，每到一个点，判断该点所能到达范围的所有点下一次跳跃能到达的最远距离是多少

class Solution {
public:
    int jump(vector<int>& nums) {
        if(nums.size() < 2)
            return 0;
        int count = 0,i = 0,maxL = 0;
        while(i < nums.size())
        {
            count++;
            int nextMax = 0;
            for(;i<=maxL;i++)
            {
                nextMax = max(nextMax,i+nums[i]);
                if(nextMax >= nums.size()-1)return count;
            }
            maxL = nextMax;

        }
        return 0;
    }
};

134. 加油站

第一种解法：比较容易理解，但是效率比较低

思路：先通过遍历找到第一个能够到达下一站的加油站，然后从此站点开始遍历判断是否能够走完一圈

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        for(int i = 0;i<gas.size();i++)
        {
            if(gas[i] < cost[i])
                continue;
            int res = gas[i] -cost[i];
            int j = (i+1+gas.size())%gas.size();
            while(i != j)
            {
                res += gas[j] - cost[j];
                if(res < 0)
                    break;
                j = (j+1 + gas.size())%gas.size();
            }
            if(i == j)
                return i;
        }
        return -1;
    }
};

第二种解法：

思路：想明白两个问题

1、为什么应该将起始站点设为k+1？

因为k->k+1站耗油太大，0->k站剩余油量都是不为负的，每减少一站，就少了一些剩余油量。所以如果从k前面的站点作为起始站，剩余油量不可能冲过k+1站。

2、为什么如果k+1->end全部可以正常通行，且rest>=零就可以说明车子从k+1站点出发可以开完全程？

因为，起始点将当前路径分为A、B两部分。其中，必然有A部分剩余油量<0。B部分剩余油量>0。

所以，无论多少个站，都可以抽象为两个站点（A、B）。从B站加满油出发，开往A站，车加油，再开回B站的过程。

重点：B剩余的油>=A缺少的总油。必然可以推出，B剩余的油>=A站点的每个子站点缺少的油。

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
    int rest = 0, run = 0, start = 0;
    for (int i = 0; i < gas.size(); ++i){
        run += (gas[i] - cost[i]);
        rest += (gas[i] - cost[i]);
        if (run < 0){
            start = i + 1;
            run = 0;
        }
    }
    return rest < 0 ? -1: start;
}
};

621. 任务调度器

给定一个用字符数组表示的 CPU 需要执行的任务列表。其中包含使用大写的 A - Z 字母表示的26 种不同种类的任务。任务可以以任意顺序执行，并且每个任务都可以在 1 个单位时间内执行完。CPU 在任何一个单位时间内都可以执行一个任务，或者在待命状态。

然而，两个相同种类的任务之间必须有长度为 n 的冷却时间，因此至少有连续 n 个单位时间内 CPU 在执行不同的任务，或者在待命状态。

你需要计算完成所有任务所需要的最短时间。

示例 1：

输入: tasks = ["A","A","A","B","B","B"], n = 2
输出: 8
执行顺序: A -> B -> (待命) -> A -> B -> (待命) -> A -> B.

思路：

找到出现次数最大的任务t_max，完成任务的时间就是在该任务之间插入n+1个单位的时间，最后还应该找出最后一次执行的任务数，即和t_max出现次数相同的任务，另外还可能存在任务列表中所有任务只出现一次的情况，注意考虑

class Solution {
public:
    int leastInterval(vector<char>& tasks, int n) {
        vector<int> m(26,0);
        for(int i = 0;i<tasks.size();i++)
        {
            m[tasks[i] - 'A']++;
        }
        sort(m.begin(),m.end());
        int ans = (m[m.size()-1]-1)*(n+1);
        int i = m.size()-1;
        while(i >= 0 && m[i] == m[m.size()-1])
        {
            ans+=1;
            i--;
        }
        int len = tasks.size();
        int res = max(ans,len);
        return res;
    }
};