C++算法 —— 贪心（4）

---

1、分发饼干

455. 分发饼干

其实看完这个题会发现，如果给定的两个数组不排序的话会非常难受，所以无论怎样，先排序。接下来需要比较两个数组的值，可以用双指针来指向。两个数组的两个元素比较时，和之前有相同的思路，如果满足条件，那么后面的元素都比这个元素大，肯定也满足，但为了满足更多次的条件，所以就选用最小的那个值；如果不满足条件，这里就跳过去，找下一个更大的元素去看看能否满足条件。这也就是贪心思想。

    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int res = 0, m = g.size(), n = s.size();
        for(int i = 0, j = 0; i < m && j < n; ++i, ++j)
        {
            while(j < n && s[j] < g[i]) ++j;
            if(j < n) res++;
        }
        return res;
    }

2、最优除法

553. 最优除法

无论怎样，假设abcdefg7个数，a / b / c / d / e / f，整个式子就是一个分式，a一定在分子，b一定在分母。对于贪心来说，让分子变大，让分母变小，就是最优解。这道题来看，其实应当让分子变大就是它的最优解，所以接下来就要让分子变大。让分子变大的办法就是在把b ~ f都放到一个括号里，这样就变成了 a * c * d * e * f / b。

    string optimalDivision(vector<int>& nums) {
        int n = nums.size();
        if(n == 1) return to_string(nums[0]);
        if(n == 2) return to_string(nums[0]) + "/" + to_string(nums[1]);
        string res = to_string(nums[0]) + "/(" + to_string(nums[1]);
        for(int i = 2; i < n; ++i)
        {
            res += "/" + to_string(nums[i]);
        }
        res += ")";
        return res;
    }

3、跳跃游戏Ⅱ

45. 跳跃游戏 II

这道题意思就是如果是[2, 3, 1, 5, 4]，那么在0下标位置时最多可以跳2步到1这个位置。

这道题可以用动规，以i位置为结尾，遍历一遍前面所有的元素，如果能从某个位置跳过来，那就选那个位置，而那个位置存储了到它的最小跳跃数，然后+1即可，但这样是n ^ 2的时间复杂度，思路并不行。

这道题的思路可以是一个类似层序遍历的过程。假设一个数组[2, 3, 1, 1, 4, 2, 6, 7, 1, 5, 8]，从0下标开始，是2，我们能够确定跳到3或1这个点，也就是第一次选定起点后确定了下一次起跳的左端点和右端点；接着，3可以跳到1，1，4，而1这里，就加上贪心，因为3跳得远，且它一定比1要至少1，所以1能跳到的，3一定能跳到的，所以这里就只考虑大的数字，跳的区间为114，但是重叠了，重叠部分是2下标处的1，所以把这部分去掉，只看1和4，1就是左端点，4就是右端点；接着从4走，能到2671，这时候14和2671没有重叠的，所有不会划掉一部分，2就是左端点，1就是右端点。这样的过程就是选定了一个点后，就能确定下一次的左端点和右端点，所以很像层序遍历。

这个思路的时间复杂度是O(N)。

    int jump(vector<int>& nums) {
        int left = 0, right = 0, maxPos = 0, n = nums.size(), res = 0;
        while(left <= right)//防止跳不到n - 1位置
        {
            if(maxPos >= n - 1)//先判断是否已经能跳到最后一个位置
                return res;
            for(int i = left; i <= right; ++i)
            {
                maxPos = max(maxPos, nums[i] + i);
            }
            left = right + 1;
            right = maxPos;
            res++;
        }
        return -1;
    }

4、跳跃游戏Ⅰ

55. 跳跃游戏

先看跳跃游戏Ⅱ。

其实就是改两处

    bool canJump(vector<int>& nums) {
        int left = 0, right = 0, maxPos = 0, n = nums.size();
        while(left <= right)//防止跳不到n - 1位置
        {
            if(maxPos >= n - 1)//先判断是否已经能跳到最后一个位置
                return true;
            for(int i = left; i <= right; ++i)
            {
                maxPos = max(maxPos, nums[i] + i);
            }
            left = right + 1;
            right = maxPos;
        }
        return false;
    }

5、加油站

134. 加油站

按照这个题的思路来看，两个数组要同时看，这时不如作为一个数组，因为真正需要的是差。gas和cost两个数组每每对应，用gas的减cost的，比如例1，就得到[-2, -2, -2, 3, 3]。最简单的办法就是暴力解法，依次枚举所有起点，模拟加油的流程。

实际上，这道题可以在暴力解法上改进而得到。差值的数组不需要创建出来，不过下面还是看差值数组。用i表示下标，然后用一个step变量，表示走多少步，比如走0步就还是原地，走1步就到下一个位置，不过要%上数组大小，这样就不会越界了。

    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int n = gas.size();
        for(int i = 0; i < n; i++)
        {
            int rest = 0;
            for(int step = 0; step < n; step++)
            {
                int index = (i + step) % n;
                rest = rest + gas[index] - cost[index];
                if(rest < 0) break;
            }
            if(rest >= 0) return i;
        }
        return -1;
    }

不过这样肯定超出时间限制。现在基于这个来优化。假设差值数组是abcdefg，从a走到f就不能走了，说明a + b + c + d + e + f < 0，暴力解法就会从b再来一遍，但这样明显做了无用功。上面的式子小于0，那么去掉a，还是小于0，所以就不用管这些了，直接从g位置再出发。这样平均时间复杂度就是O(N)了。

    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        int n = gas.size();
        for(int i = 0; i < n; i++)
        {
            int rest = 0;
            int step = 0;
            for(; step < n; step++)
            {
                int index = (i + step) % n;
                rest = rest + gas[index] - cost[index];
                if(rest < 0) break;
            }
            if(rest >= 0) return i;
            i = i + step;
        }
        return -1;
    }

6、单调递增的数字

738. 单调递增的数字

当然最简单的方法就是暴力枚举，从这个数字到0，判断每一个数字是否是单调递增，找到的第一个就是结果。不过重点在于如何判断单调递增。

对于一个数字，如果想对每一位做一些判断，转换成字符串就好。另一个经典操作就是模10再除10，就能从个位开始拿到每一位。

这个暴力解法的时间复杂度是O(nlogn)，取一个数字的每一位的时间复杂度是logn。

但这里不用暴力解法，要用贪心，不过这更像找规律。

从头开始判断，如果发现了不是递增，那要对字符串如何操作？比如123454367，到了5这个位置就不能继续了，但因为要找更小的数字，那么4367不能改为6367。我们可以修改5，把它减1，然后后面的数字全变成9，就是要求的数字。但这里还有问题，如果是连续的几个5之后有个4呢？这样就得把第一个5改成4，后面全变成9。

    int monotoneIncreasingDigits(int n) {
        string s = to_string(n);
        int i = 0, m = s.size();
        while(i + 1 < m && s[i] <= s[i + 1]) ++i;
        if(i + 1 == m) return n;
        while(i - 1 >= 0 && s[i] == s[i - 1]) --i;
        s[i]--;
        for(int j = i + 1; j < m; ++j) s[j] = '9';
        return stoi(s);
    }

7、坏了的计算器

991. 坏了的计算器

对于小于目标的数，那么乘2会更快地接近目标，但是也有不是最优解的，比如6和目标10。

这道题适合逆着思考，把操作变成除2和+1。
这个题没有小数，所以能除2的只能是偶数，那么遇到奇数的话就只能+1。偶数可以除2，可以+1。把目标值变成原始值，原始值则变成目标值。假设原有的目标值是end，原始值是begin。

针对偶数，如果end <= begin，也就是目标值更小，那么遇到偶数就得+1。如果end > begin，奇数还是只能+1，而偶数，经过证明，其实是先除更优。

    int brokenCalc(int startValue, int target) {
        //正难则反 + 贪心
        int res = 0;
        while(target > startValue)
        {
            if(target % 2 == 0) target /= 2;
            else target += 1;
            res++;
        }
        return res + startValue - target;//目标值变成小于原始值了，奇偶数都是+1，所以就是加上差值。
    }

结束。