C++算法 —— 贪心(3)

文章目录

  • 1、买卖股票的最佳时机
  • 2、买卖股票的最佳时机Ⅱ
  • 3、K次取反后最大化的数组和
  • 4、按身高排序
  • 5、优势洗牌
  • 6、最长回文串
  • 7、增减字符串匹配


1、买卖股票的最佳时机

121. 买卖股票的最佳时机

C++算法 —— 贪心(3)_第1张图片
这里最容易想到的就是暴力枚举,两层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

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

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

        //双指针
        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 次取反后最大化的数组和

C++算法 —— 贪心(3)_第3张图片
理解这道题后会发现,应当先对最小的负数取反,才能得到最大和。从负数开始,从小到大,一个个取反。假设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. 按身高排序

C++算法 —— 贪心(3)_第4张图片
我们可以创建一个新数组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. 优势洗牌

C++算法 —— 贪心(3)_第5张图片
这道题的意思是给了两个数组,返回一个最终的数组,比如例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. 最长回文串

C++算法 —— 贪心(3)_第6张图片
按照题目,回文串的长度是偶数或者奇数,从中间切一刀,两边都一样,中间切开的那个位置没有元素或者只有一个元素。所以我们可以这样想,一个字符串中可能出现的所有字符,记录下每个字符出现的次数,如果次数为偶数,就可以两边都放,那就是直接加上这个数字;如果是奇数,就-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. 增减字符串匹配

C++算法 —— 贪心(3)_第7张图片
题目的意思就是给定一个字符串,比如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;
    }

结束。

你可能感兴趣的:(C++算法,c++,算法,开发语言,贪心算法)