C++ leetcode之删除并获得点数的示例代码

 更新时间:2021年05月07日 09:58:23   作者:cqu_shuai  
这篇文章主要介绍了C++ leetcode之删除并获得点数的示例代码,本文给大家分享问题解析及解决方案,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下

参考链接

 https://leetcode-cn.com/problems/delete-and-earn/

https://leetcode-cn.com/problems/delete-and-earn/solution/shan-chu-bing-huo-de-dian-shu-by-leetcod-x1pu/

题目描述

给你一个整数数组 nums ,你可以对它进行一些操作。

每次操作中,选择任意一个 nums[i] ,删除它并获得 nums[i] 的点数。之后,你必须删除每个等于 nums[i] - 1 或 nums[i] + 1 的元素。

开始你拥有 0 个点数。返回你能通过这些操作获得的最大点数。

在这里插入图片描述

解题思路

本题需要明确的一点是,如果删除了有多个相同值的元素,因为比它大1或小1的元素都被删了,后面这些相同的元素还会被剩下,所以可以一次全部删除。

回溯法

即暴力穷举所有情况。首先用哈希表记录所有相同元素的和,穷举哈希表的每一个键,记录下它的值,并去除哈希表中键比它大1和小1的值,递归后再恢复。(会超时!)

递归式动态规划

先对数组进行排序,然后用哈希表记录所有相同元素的和,同时新建一个记录所有不重复元素的数组,这样就可以把“状态”设为不重复数组的索引了,状态表存储的就是当前索引到最后一个索引间能获得的最大点数。“选择”就是是否删除当前索引处元素。如果要删除当前元素,这一步中需要判断下一个元素与当前元素的差是否等于1,如果等于1,就往下跳2个元素,否则跳1个元素;如果不删除当前元素,则直接跳一个元素。

迭代式动态规划

官方解法用数组代替哈希表存储相同元素的元素和,这样每个元素间的差都是1,状态表记录第0个元素到当前元素能获得的最大点数。“选择”是是否删除当前元素,如果删除,点数为当前元素与第0个元素到前2个元素的最大点数和,如果不删,就是第0个元素到前一个元素的最大点数。

排序 + 动态规划

同样是官方的最优解法,若 nums 中不存在某个元素 x,则选择任一小于 x 的元素不会影响到大于 x 的元素的选择。因此我们可以将 nums 排序后,将其划分成若干连续子数组,子数组内任意相邻元素之差不超过 1。对每个子数组按照方法一的动态规划过程计算出结果,累加所有结果即为答案。

代码

回溯法

class Solution {
public:
    int deleteAndEarn(vector<int>& nums) {
        unordered_map<int, int> mp;
        for (int num : nums)
        {
            mp[num] += num;
        }
        int res = Earn(mp);
        return res;
    }

    int Earn(unordered_map<int, int>& mp)
    {
        int res = 0;
        for (auto& item : mp)
        {
            if (mp[item.first] == 0)
            {
                continue;
            }
            int sum = mp[item.first];
            mp[item.first] = 0;
            int prev_plus_1 = mp[item.first + 1];
            int prev_sub_1 = mp[item.first - 1];
            mp[item.first + 1] = 0;
            mp[item.first - 1] = 0;
            res = max(res, sum + Earn(mp));
            mp[item.first] = sum;
            mp[item.first + 1] = prev_plus_1;
            mp[item.first - 1] = prev_sub_1;
        }
        return res;
    }

};

递归式动态规划

class Solution {
public:
    unordered_map<int, int> memo;
    int deleteAndEarn(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        unordered_map<int, int> mp;
        vector<int> unique;
        int tmp = INT_MAX;
        for (int num : nums)
        {
            if (tmp != num)
            {
                unique.push_back(num);
                tmp = num;
            }
            mp[num] += num;
        }
        unique.push_back(INT_MAX);
        int res = dp(mp, unique, 0);
        return res;
    }
    int dp(unordered_map<int, int>& mp, vector<int>& nums, int start)
    {
        if (start + 1 >= nums.size())
        {
            return 0;
        }
        if (memo.count(start) == 1)
        {
            return memo[start];
        }
        int do_it = 0;
        if (nums[start] - nums[start + 1] == 1 || nums[start + 1] - nums[start] == 1)
        {
            do_it = mp[nums[start]] + dp(mp, nums, start + 2);
        }
        else
        {
            do_it = mp[nums[start]] + dp(mp, nums, start + 1);
        }
        int not_do = dp(mp, nums, start + 1);
        memo[start] = max(do_it, not_do);
        return max(do_it, not_do);
    }
};

迭代式动态规划

class Solution {
private:
    int rob(vector<int> &nums) {
        int size = nums.size();
        int first = nums[0], second = max(nums[0], nums[1]);
        for (int i = 2; i < size; i++) {
            int temp = second;
            second = max(first + nums[i], second);
            first = temp;
        }
        return second;
    }

public:
    int deleteAndEarn(vector<int> &nums) {
        int maxVal = 0;
        for (int val : nums) {
            maxVal = max(maxVal, val);
        }
        vector<int> sum(maxVal + 1);
        for (int val : nums) {
            sum[val] += val;
        }
        return rob(sum);
    }
};

排序 + 动态规划

class Solution {
private:
    int rob(vector<int> &nums) {
        int size = nums.size();
        if (size == 1) {
            return nums[0];
        }
        int first = nums[0], second = max(nums[0], nums[1]);
        for (int i = 2; i < size; i++) {
            int temp = second;
            second = max(first + nums[i], second);
            first = temp;
        }
        return second;
    }

public:
    int deleteAndEarn(vector<int> &nums) {
        int n = nums.size();
        int ans = 0;
        sort(nums.begin(), nums.end());
        vector<int> sum = {nums[0]};
        for (int i = 1; i < n; ++i) {
            int val = nums[i];
            if (val == nums[i - 1]) {
                sum.back() += val;
            } else if (val == nums[i - 1] + 1) {
                sum.push_back(val);
            } else {
                ans += rob(sum);
                sum = {val};
            }
        }
        ans += rob(sum);
        return ans;
    }
};

到此这篇关于C++ leetcode之删除并获得点数的示例代码的文章就介绍到这了,更多相关C++ leetcode内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • C++使用递归方法求n阶勒让德多项式完整实例

    C++使用递归方法求n阶勒让德多项式完整实例

    这篇文章主要介绍了C++使用递归方法求n阶勒让德多项式,涉及C++递归算法与浮点数运算的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
    2016-05-05
  • 详解C语言中不同类型的数据转换规则

    详解C语言中不同类型的数据转换规则

    这篇文章给大家讲解不同类型数据间的混合运算与类型转换,有自动类型转换和强制类型转换,针对每种转换方法小编给大家介绍的非常详细,需要的朋友参考下吧
    2021-07-07
  • C++优先级队列的使用指南与模拟实现

    C++优先级队列的使用指南与模拟实现

    优先级队列是一种特殊的队列,其中每个元素都有一个与之关联的优先级,优先级较高的元素会在队列中较早地被处理,而优先级较低的元素会在后续处理,本文给大家介绍C++优先级队列的使用指南与模拟实现,需要的朋友可以参考下
    2023-09-09
  • C语言实现树的动态查找实例代码

    C语言实现树的动态查找实例代码

    这篇文章主要介绍了C语言实现树的动态查找实例代码的相关资料,需要的朋友可以参考下
    2017-06-06
  • C语言 坐标移动详解及实例代码

    C语言 坐标移动详解及实例代码

    这篇文章主要介绍了C语言 坐标移动详解及实例代码的相关资料,需要的朋友可以参考下
    2017-01-01
  • c语言获取直播吧最近一周nba比赛信息

    c语言获取直播吧最近一周nba比赛信息

    这篇文章主要介绍了使用c语言获取直播吧最近一周nba比赛信息的方法,需要的朋友可以参考下
    2014-04-04
  • 详细讲解C语言中的数据以及位运算

    详细讲解C语言中的数据以及位运算

    这篇文章主要为大家详细介绍了C语言中数据表示方法以及位运算的相关知识点,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下
    2023-06-06
  • IOS开发之UIScrollView实现图片轮播器的无限滚动

    IOS开发之UIScrollView实现图片轮播器的无限滚动

    这篇文章主要介绍了IOS开发之UIScrollView实现图片轮播器的无限滚动的相关资料,需要的朋友可以参考下
    2017-07-07
  • C++中运算符重载的规则语法实例

    C++中运算符重载的规则语法实例

    今天小编就为大家分享一篇关于C++中运算符重载的规则语法实例,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
    2018-12-12
  • 解析C++类内存分布

    解析C++类内存分布

    本篇文章介绍了C++类内存分布结构,我们来看看编译器是怎么处理类成员内存分布的,特别是在继承、虚函数存在的情况下
    2021-06-06

最新评论