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

---

1、买卖股票的最佳时机

121. 买卖股票的最佳时机

这里最容易想到的就是暴力枚举，两层for循环，i = 0， j = i + 1开始，但是这样是O(n ^ 2)的时间复杂度，即使倒过来，选定一个值，找到这个值前面的一堆数字中的最小值，一减就能找到最大利润，但是没解决本质。不妨想一下，从第二个数开始往后走。每一次都找前面一堆数字的最小值，但后面要找的其实已经包含前面要找的了，也就是找第7个数字之前的最小值，一大部分已经在找第6个数字之前的最小值时找过了，只要把这个最小值和第6个数字一比较，谁小，谁就是找第7个数字之前的最小值，这样，算法就是O(N)了。

    int maxProfit(vector<int>& prices) {
        int res = 0;
        for(int i = 0, prev = INT_MAX; i < prices.size(); ++i)
        {
            res = max(res, prices[i] - prev);//先更新结果是因为如果先更新最小值，那么结果就没法计算了
            prev = min(prev, prices[i]);
        }
        return res;
    }

2、买卖股票的最佳时机Ⅱ

122. 买卖股票的最佳时机 II

根据这个图，可以画一个折线图，每天的价格就是一个点，连接起来所有点。思路就是每次选一个点，都找到从这个点开始持续递增后的点，如果价格出现减少或不变，那就停止，这样每个增长趋势内可得到的最大利润都被算进来了，就能得到最大利润。

为了找到严格递增过程中最大的点，可以用双指针来控制。另一个方法是把每段交易变成一天一天，这个思路是只要第二天的数字比第一天大，那就加上第二天的数字。

        //双指针
        int ret = 0, n = prices.size();
        for(int i = 0; i < n; ++i)
        {
            int j = i;
            while(j + 1 < n && prices[j + 1] > prices[j]) ++j;
            ret += prices[j] - prices[i];
            i = j;
        }
        return ret;
        //拆分
        int ret = 0;
        for(int i = 1; i < prices.size(); ++i)
        {
            if(prices[i] > prices[i - 1])
                ret += prices[i] - prices[i - 1];
        }
        return ret;

3、K次取反后最大化的数组和

1005. K 次取反后最大化的数组和

理解这道题后会发现，应当先对最小的负数取反，才能得到最大和。从负数开始，从小到大，一个个取反。假设m是负数个数，m > k，那就把前k小的负数转化成正数；m == k，把所有负数全部转化为正数；m < k，先把所有负数都取反，剩余的次数k - m，如果它是偶数，那么就无影响，可以只对一个数字取反偶次数，那么这个数不变，如果是k - m是奇数，那就得把现有正数（因为已经取反了所有负数）中最小的那个数取反奇次数，就可以拿到最大数组和了。

    int largestSumAfterKNegations(vector<int>& nums, int k) {
        int m = 0, minElem = INT_MAX, n = nums.size();
        for(auto x : nums)
        {
            if(x < 0) m++;
            minElem = min(minElem, abs(x));
        }
        int ret = 0;
        if(m > k)
        {
            sort(nums.begin(), nums.end());
            for(int i = 0; i < k; ++i)
            {
                ret += -nums[i];
            }
            for(int i = k; i < n; ++i)
            {
                ret += nums[i];
            }
        }
        else
        {
            for(auto x: nums) ret += abs(x);
            if((k - m) % 2)
            {
                ret -= minElem * 2;
            }
        }
        return ret;
    }

4、按身高排序

2418. 按身高排序

我们可以创建一个新数组pair这样名字和数字都在一起，对这个数组排序就行。

解法二是利用哈希表存映射关系。对身高数组排序，根据结果在哈希表里找名字即可。

以上两种思路类似，这里走一个不同的思路，虽然要排序，但不是真正的排序，对其中的元素不做手脚，但要能按照给出最终的顺序对应的元素。这里创建一个下标数组，只对下标数组排序，根据下标数组排序后的结果，找到原数组的信息。

    vector<string> sortPeople(vector<string>& names, vector<int>& heights) {
        int n = names.size();
        vector<int> index(n);
        for(int i = 0; i < n; ++i)
        {
            index[i] = i;
        }
        sort(index.begin(), index.end(), [&](int i, int j)
        {
            return heights[i] > heights[j];
        });
        vector<string> ret;
        for(auto i : index)
        {
            ret.push_back(names[i]);
        }
        return ret;
    }

5、优势洗牌

870. 优势洗牌

这道题的意思是给了两个数组，返回一个最终的数组，比如例1，
2 7 11 15
1 10 4 11
第一个位置可以放2，比1，第二个位置可以放11，比10大，第三个可以放15，比4大，但这样第四个位置就放不了，所以这样优势不是最大化，第三个位置放7，第四个位置可以放15，这样优势就最大化了。

这道题可以用田忌赛马的思路，即，如果比不过，就放到另一个数组最大的那个对应的位置，如果能比过，那就直接比。在这之前，先排序一遍。

按照这个思路，看例2，我们会得到[12, 24, 32, 8]这个答案，和示例不一样，这是因为，我们是按照排序后的数组去做的结果，这个结果还需要对应上原先数组，所以还得改一下顺序，才是最终结果。

为此，要和上一个题一样，用下标数组来做。

    vector<int> advantageCount(vector<int>& nums1, vector<int>& nums2) {
        int n = nums1.size();
        //排序
        sort(nums1.begin(), nums1.end());
        vector<int> index2(n);
        for(int i = 0; i < n; ++i) index2[i] = i;
        sort(index2.begin(), index2.end(), [&](int i, int j)
        {
            return nums2[i] < nums2[j];
        });

        //田忌赛马
        vector<int> ret(n);
        int left = 0, right = n - 1;
        for(auto x : nums1)
        {
            if(x > nums2[index2[left]]) ret[index2[left++]] = x;
            else ret[index2[right--]] = x;
        }
        return ret;
    }

6、最长回文串

409. 最长回文串

按照题目，回文串的长度是偶数或者奇数，从中间切一刀，两边都一样，中间切开的那个位置没有元素或者只有一个元素。所以我们可以这样想，一个字符串中可能出现的所有字符，记录下每个字符出现的次数，如果次数为偶数，就可以两边都放，那就是直接加上这个数字；如果是奇数，就-1，然后两边都放。所有次数可能不止有一个奇数，但奇数的个数不用担心，按照上面的做法，偶数就直接加，奇数就-1加上，算出来的长度如果等于原字符串长度，说明都是偶数，那就不用继续处理，直接返回；如果小于原字符串，说明出现了奇数，那么就+1，再返回。

    int longestPalindrome(string s) {
        int hash[127] = {0};
        for(char ch : s) hash[ch]++;
        int ret = 0;
        for(int x : hash)
        {
            ret += x / 2 * 2;//这样奇数偶数都能计算
        }
        return ret < s.size() ? ret + 1 : ret;
    }

7、增减字符串匹配

942. 增减字符串匹配

题目的意思就是给定一个字符串，比如IDI，那就增减增，从0123四个数字中选择来组成数组。

这道题体现的贪心是，为了符合字符串展现的规则，遇到I时，应当选择当前最小的那个数，遇到D时，选择当前最大的那个数。

    vector<int> diStringMatch(string s) {
        int left = 0, right = s.size();
        vector<int> res;
        for(auto ch : s)
        {
            if(ch == 'I') res.push_back(left++);
            else res.push_back(right--);
        }
        res.push_back(left);
        return res;
    }

结束。