代码随想录算法训练营第36期DAY50

DAY50

如果写累了就去写套磁信吧。

198打家劫舍

1. class Solution {
2. public:
3. int rob(vector<int>& nums) {
4. vector<int> dp(nums.size());
5. dp0=nums0;
6. if(nums.size()==1) return nums0;
7. dp1=max(nums0,nums1);
8. for(int i=2;i<nums.size();i++){
9. dpi=max(dpi-1,dpi-2+numsi);
10. }
11. return dpnums.size()-1;
12. }
13. };

213打家劫舍ii

数组成环，分三种情况：

1. 不考虑首尾
2. 不考虑首，仅考虑尾
3. 不考虑尾，仅考虑首

注意，考虑不代表必选。

那么情况2 3 就已经包括了情况1。

写函数来解决，就不用挪数组。

注意是从dpstart开始赋值

1. class Solution {
2. public:
3. int getres(vector<int>nums,int start,int end){
4. vector<int> dp(nums.size());
5. if(start==end) return numsstart;
6. dpstart=numsstart;
7. dpstart+1=max(numsstart,numsstart+1);
8. //注意i的初值
9. for(int i=start+2;i<=end;i++)
10. dpi=max(dpi-2+numsi,dpi-1);
11. return dpend;
12. }
13. int rob(vector<int>& nums) {
14. if(nums.size()==1) return nums0;
15. int res1=getres(nums,0,nums.size()-2);
16. int res2=getres(nums,1,nums.size()-1);
17. if(res1>res2) return res1;
18. else return res2;
19. }
20. };

337打家劫舍 iii--树形DP

能想到：后序遍历，把孩子信息传到父节点：若孩子之和没有大于父节点，则买入父节点。反之买入孩子之和。还要注意一些复杂的逻辑。还是不会。

节点之间的状态影响进一步计算，那么是动态规划

状态dp表示抢或不抢，抢的话，就不能动两个孩子；不抢的话，就要考虑动孩子了。

1. 暴力递归

超时了：

1. /**

2. * Definition for a binary tree node.

3. * struct TreeNode {

4. * int val;

5. * TreeNode *left;

6. * TreeNode *right;

7. * TreeNode() : val(0), left(nullptr), right(nullptr) {}

8. * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}

9. * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}

10. * };

11. */

12. class Solution {

13. public:

14. //这个递归还挺难想

15. int rob(TreeNode* root) {

16. if(root==nullptr) return 0;

17. if(root->left==nullptr&&root->right==nullptr) return root->val;

19. int val1=root->val;

20. if(root->left) val1+=rob(root->left->left)+rob(root->left->right);

21. if(root->right) val1+=rob(root->right->left)+rob(root->right->right);

23. int val2=rob(root->left)+rob(root->right);

24. return max(val1,val2);

25. }

26. };

27. 动态规划

记录当前偷与不偷得到的最大金额。

树形DP，在树上做状态转移。

求一个节点，偷与不偷两个状态分别所得到的金钱，返回值是一个长度为2的数组。

1. /**
2. * Definition for a binary tree node.
3. * struct TreeNode {
4. * int val;
5. * TreeNode *left;
6. * TreeNode *right;
7. * TreeNode() : val(0), left(nullptr), right(nullptr) {}
8. * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9. * TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10. * };
11. */
12. class Solution {
13. public:
14. vector<int> getres(TreeNode* cur){
15. if(cur==nullptr) return {0,0};
17. vector<int> left=getres(cur->left);
18. vector<int> right=getres(cur->right);
20. int val1=cur->val+left0+right0;
21. int val2=max(left0,left1)+max(right0,right1);
22. return {val2,val1};
23. }
24. int rob(TreeNode* root) {
25. vector<int> res=getres(root);
26. return max(res0,res1);
27. }
28. };