算法学习 | day41/60 打家截舍/打家劫舍II/打家劫舍III

已于 2024-04-15 15:45:20 修改
阅读量365 收藏 3
点赞数 2
文章标签： 算法 学习 leetcode
于 2024-04-15 15:39:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tomily12138/article/details/137746210
版权

一、题目打卡

        1.1 打家截舍

        题目链接：198. 打家劫舍 - 力扣（LeetCode）

class Solution {
public:
    int rob(vector<int>& nums) {
        // 题目条件里面从 1 开始的
        if(nums.size() <= 1) return nums[0];
        vector<int> dp(nums.size(),0);

        dp[0] = nums[0];
        dp[1] = max(nums[0],nums[1]);
        for(int i = 2 ; i < nums.size(); i++){
            dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]); //不偷和偷
        }
        return dp[nums.size() - 1];
    }
};

        感觉如果从之前的背包问题过过渡到这个题目的话，就不是很难理解，状态变量——从0 到 i 所得到的最大价值，递推公式，是否选择索引所对应的价值，和背包问题很类似，题目的原型感觉比背包问题更好理解，不够题目应该还有不同的变种，继续看还会有什么样的变化。

        1.2 打家截舍II

        题目链接：​​​​​​​. - 力扣（LeetCode）

class Solution {
public:
    int get_max(vector<int> &nums){
        int res = nums[0];
        for(int i = 0 ; i < nums.size() ; i++){
            res = max(nums[i],res);
        }
        return res;
    }
    int rob(vector<int>& nums) {
        if(nums.size() <= 2) return get_max(nums); // 因为是一个环，所以只能取一个
        vector<int> dp1(nums.size() - 1, 0); // 存储不包含最后一个的时候的最大价值
        vector<int> dp2(nums.size() - 1, 0); // 存储不包含第一个的最大价值

        dp1[0] = nums[0];
        dp2[0] = nums[1];
        dp1[1] = max(nums[0],nums[1]);
        dp2[1] = max(nums[1],nums[2]);

        // for(int i = 2 ; i < nums.size() - 1 ; i++){
        //     dp1[i] = max(dp1[i - 1], dp1[i - 2] + nums[i]);
        // }

        // for(int i = 2 ; i < nums.size() - 1; i++){
        //     dp2[i] = max(dp2[i - 1], dp2[i - 2] + nums[i + 1]);
        // }

        // 优化一下
        for(int i = 2 ; i < nums.size() - 1 ; i++){
            dp1[i] = max(dp1[i - 1], dp1[i - 2] + nums[i]);
            dp2[i] = max(dp2[i - 1], dp2[i - 2] + nums[i + 1]);
        }

        return max(dp1.back(), dp2.back());


        // for(int i = 3 ; i < nums.size() ; i++){
        //     if(i <= nums.size() - 1) dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
        //     if(i >= 4) dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
        // }
    }
};

        这个题目主要是处理环这种结构，其实本质上来说，环也就是需要对首位进行区分，因为这两者不能同时被纳入 dp 数组的选择考虑（注意这里只是考虑，和选不选择没有关系，如果考虑是否选择就会陷入误区），所以也就是分成了两种情况，选择首项纳入考虑和选择尾项纳入考虑，这样分别对应了两个循环（其实也可以合并成为一个）。

        在合并的过程中，需要对遍历过程中 i 的意义理解清楚，这里的 i 指的是dp数组的索引，所以对应nums的时候，如果不取第一个，就需要做 +1处理。

        1.3 打家截舍III

        题目链接：. - 力扣（LeetCode）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    // int get_length(TreeNode* root){
    //     if(!root) return 0;
    //     return get_length(root->left) + get_length(root->right) + 1;
    // }
    // void recur(TreeNode* root, vector<int> &dp, int i){
    //     if(!root) return;

    //     recur(root->left, dp, i + 1);
    //     dp[i] = max(dp[i - 1], dp[i - 2] + root->val);
    //     recur(root->right, dp, i + 1);
    // }
    // int rob(TreeNode* root) {
    //     // int length = 0;
    //     // length = get_length(root);
    //     // cout << length << endl;
    //     // if(length <= 1) return root->val;

    //     // vector<int> dp(length, 0);

    //     // // dp[0] = root->left ? root->left->val : root->val;
    //     // TreeNode* tmp = root;
    //     // while(tmp){
    //     //     dp[0] = root->val;
    //     //     tmp = tmp->left;
    //     // }
    //     // dp[1] = root->left ? (max(root->left->val, root->val)) : (max(root->val, root->right->val));
    //     // recur(root, dp, 2);
    //     // for(int i = 0 ; i < length; i++){
    //     //     cout << dp[i] << " ";
    //     // }
    //     // return dp[length - 1];
    // }

    // void tree2vector(vector<int> &nums, TreeNode* root){
    //     if(!root) return;

    //     tree2vector(nums, root->left);
    //     nums.push_back(root->val);
    //     tree2vector(nums, root->right);
    // }

    // int rob(TreeNode* root) {
    //     vector<int> nums;
    //     tree2vector(nums, root);

    //     for(int i = 0 ; i < nums.size() ; i++){
    //         cout << nums[i] << " ";
    //     }

    //     if(nums.size() <= 1) return nums[0];

    //     vector<int> dp(nums.size(), 0);
    //     dp[0] = nums[0];
    //     dp[1] = max(nums[0],nums[1]);

    //     for(int i = 2 ; i < nums.size(); i++){
    //         dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
    //     }

    //     return dp.back();
    // }

    // pair<int,int> recur(TreeNode* root){ // 用前一位存储之前概念的 dp[i -1] 第二位存储 dp[i - 2]
    //     if(!root) return make_pair(0,0);

    //     pair<int,int> res1 = recur(root->left);
    //     pair<int,int> res2 = recur(root->right);

    //     pair<int,int> res = make_pair(0,0);
    //     res.first = max(res1.first + res2.first, res1.second + res2.second + root->val);
    //     res.second = min(res1.first + res2.first, res1.second + res2.second + root->val);

    //     cout << res.first << " " << res.second << endl;
    //     cout << "---------------" << endl;
    //     return res;
        // int tmp = res1.first;
        // res1.first = max(res1.first + res2.first, root->val + res1.second + res2.second);
        // res1.second = tmp;

        // int tmp1 = res2.first;
        // res2.first = max(res1.first + res2.first, root->val + res1.second + res2.second);
        // res2.second = tmp1;
        // return make_pair(max(res1.first + res2.first, root->val + res1.second + res2.second), );
    // }

    // int rob(TreeNode* root) {
    //     // pair<int, int> res = recur(root);
    //     // return res.first;

    //     // if(!root) return 0;

    //     // int res1 = rob(root->left);
    //     // int res2 = rob(root->right);
    //     // cout << res1 << " " << res2 <<endl;
    //     // cout << "-----------" << endl;
    //     // return max(res1 + res2, root->val);
    // }


    vector<int> recur(TreeNode* root){
        if(!root) return vector<int>{0,0}; // 抢当前节点获得的最大值和不抢当前节点获得的最大值

        vector<int> res1 = recur(root->left);
        vector<int> res2 = recur(root->right);

        int tmp1 = res1[1] + res2[1] + root->val; // 抢当前节点
        // 因为不抢这个节点的话，那子节点就有自己选择的权利是否抢
        int tmp2 = max(res1[0], res1[1]) + max(res2[0], res2[1]); // 不抢当前节点
        return vector<int>{tmp1,tmp2};
    }
    int rob(TreeNode* root) {

        vector<int> res = recur(root);
        return max(res[0],res[1]);
    }
};

        这个题目我做的过程，很多其实想明白了，但是没有写出来，最后发现原因就是对于状态的定义没有认知清楚，首先我想到了这个返回的值，肯定需要用两个数来表示，这样才能表征 1.1 和 1.2 中的 i - 1 和 i - 2， 但是我发现我递归记录的方法不太正确，如果按照我这个思路，正确的写法应该是这样的：

class Solution {
public:
    unordered_map<TreeNode* , int> umap; // 记录计算过的结果
    int rob(TreeNode* root) {
        if (root == NULL) return 0;
        if (root->left == NULL && root->right == NULL) return root->val;
        if (umap[root]) return umap[root]; // 如果umap里已经有记录则直接返回
        // 偷父节点
        int val1 = root->val;
        if (root->left) val1 += rob(root->left->left) + rob(root->left->right); // 跳过root->left
        if (root->right) val1 += rob(root->right->left) + rob(root->right->right); // 跳过root->right
        // 不偷父节点
        int val2 = rob(root->left) + rob(root->right); // 考虑root的左右孩子
        umap[root] = max(val1, val2); // umap记录一下结果
        return max(val1, val2);
    }
};

        这样的话，其实选择当前节点的过程就是前序遍历，不选择当前节点，因为要处理返回值，所以就是后序遍历。

        转换到dp方法，其实思路很类似，只是这里处理选择当前节点的时候，这里其实用了一小步贪心的思想，也就是无论如何都要取到最大，不管子节点是怎么考虑的，这其实也对应了上面递归方法中比较的过程，这也算是第一次接触了树形dp。

Vincent Willem
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
算法训练Day48 打家劫舍系列 | LeetCode198. 打家劫舍（普通直街道）；213. 打家劫舍II（环形房屋）；337. 打家劫舍III（树形房屋）
weixin_47284299的博客
11-07 809
算法训练Day48 打家劫舍系列 | LeetCode198. 打家劫舍（普通直街道）；213. 打家劫舍II（环形房屋）；337. 打家劫舍III（树形房屋）
day4.zip_打印编程_C/C++_
08-11
This is a c program to print a data from a RAM memory. The data is directly accessed.
随想录day 50 | 198. 打家劫舍 213. 打家劫舍 II 337. 打家劫舍III
weixin_44645059的博客
06-05 233
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
代码随想录算法训练营Day47 | 198.打家劫舍、213.打家劫舍II、337.打家劫舍III | Python | 个人记录向
Python基本算法
05-22 406
动态规划：198.打家劫舍、213.打家劫舍II、337.打家劫舍III。
代码随想录算法训练营-day48-198.打家劫舍、213.打家劫舍II、337.打家劫舍 III
weixin_47067912的博客
12-24 147
代码随想录算法训练营-day48-198.打家劫舍、213.打家劫舍II、337.打家劫舍 III
代码随想录 Day40 动态规划08 LeetCodeT198打家劫舍 T213打家劫舍II T337 打家劫舍III
qiuqiushuibx的博客
11-08 279
动规08
【LeetCode】Day51-打家劫舍 I&II&变形
qq_43417265的博客
05-05 534
打家劫舍 I&II、删除并获得点数（变形）【中等】-动态规划
算法学习day48
qq_45960599的博客
04-03 582
算法学习day48
力扣算法学习day31-3
weixin_45609749的博客
02-21 152
文章目录力扣算法学习day31-3213-打家劫舍 II题目代码实现 力扣算法学习day31-3 213-打家劫舍 II 题目 代码实现 class Solution { public int rob(int[] nums) { if(nums.length == 1){ return nums[0]; } // dp // 思路：本题是在打家劫舍I的特殊版本，因为环形结构所以如果取了第一个就不能取最后一个，
算法打卡day41|动态规划篇09| Leetcode198.打家劫舍、213.打家劫舍II、337.打家劫舍 III
改变从现在开始
04-10 1094
JAVA算法|动态规划篇09| Leetcode198.打家劫舍、213.打家劫舍II、337.打家劫舍 III
day2txt_EXCEL/VBA读通达信日线_通达信_
10-01
通达信日线文件一般是 D:\通达信目录\Vipdoc\sz\lday\szXXXXXX.day附件中是一个带宏的xls文件(EXCEL)和测试数据。文件可以之间将day文件读入excel，便于后续分析。
ABAP4Day4.rar_ABAP/4_SAP_abap
07-15
SAP中进行二次开发培训 资料ABAP/4程序员之路——第4天
ABAP4Day3.rar_ABAP/4_SAP_abap
07-14
SAP中进行二次开发培训 资料ABAP/4程序员之路——第3天
ABAP4Day2.rar_ABAP/4_SAP_abap
07-14
SAP中进行二次开发培训 资料ABAP/4程序员之路——第2天
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 236
【代码】力扣LCP 08.剧情触发时间。
代码随想录算法训练营第31天|● 理论基础 ● 455.分发饼干 ● 376. 摆动序列 ● 53. 最大子序和
weixin_74408291的博客
06-07 479
题目分类大纲如下：。。所以唯一的难点就是如何通过局部最优，推出整体最优。
力扣1438.绝对差不超过限制的最长连续子数组
Pisasama的博客
06-05 280
难点：保存数组缩小后的最大最小值。
C语言中数组和指针的关系
最新发布
2402_85246552的博客
06-12 242
因此，在函数内部，你无法知道数组的大小（除非作为另一个参数传递），但你可以通过指针访问数组的元素。对于数组，如果越界访问（访问数组索引超出其实际大小的元素），可能会导致未定义的行为，包括访问到无效的内存地址或覆盖其他变量的值。对于指针，如果指针指向了无效的内存地址（如未初始化的指针、已释放的内存或不存在的内存地址），解引用该指针也会导致未定义的行为。数组的大小在编译时是固定的，而指针可以指向任意大小的内存区域（只要该区域已被分配且指针已正确初始化）。），这会得到整个数组的地址或指向下一个元素的指针。
C语言/* 函数sum_day:计算日期 */
06-06
以下是一个计算日期的示例代码： ```c #include <stdio.h> struct Date { int year; int month; int day; }; int isLeapYear(int year); // 判断是否为闰年 int getDaysInMonth(int year, int month); // 获取该月的天数 int sum_day(struct Date date); // 计算日期 int main() { struct Date date = {2021, 8, 18}; int days = sum_day(date); printf("%d年%d月%d日是该年的第%d天\n", date.year, date.month, date.day, days); return 0; } int isLeapYear(int year) { return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0); } int getDaysInMonth(int year, int month) { int daysInMonth[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; // 每个月的天数 if (month == 2 && isLeapYear(year)) { return 29; } else { return daysInMonth[month - 1]; } } int sum_day(struct Date date) { int days = 0; for (int i = 1; i < date.month; i++) { days += getDaysInMonth(date.year, i); } days += date.day; return days; } ``` 解释一下，首先定义了一个 `Date` 结构体用来存储日期信息。然后定义了两个函数，一个是判断闰年的函数 `isLeapYear`，另一个是获取该月的天数的函数 `getDaysInMonth`。在 `getDaysInMonth` 函数中，先定义了数组 `daysInMonth` 存储每个月的天数，然后根据是否为闰年来修改二月的天数。最后根据月份返回天数。在 `sum_day` 函数中，使用循环计算出累加到该月的天数，最后再加上当月的天数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值