DAY35

122买卖股票的最佳时机ii

很巧妙，也很难想到：计算每天的利润（今天卖出，昨天买入的利润），只取正数相加。

1. class Solution {
2. public:
3.     int maxProfit(vector<int>& prices) {
4.         int diif=0,res=0;
5.         for(int i=0;i<prices.size()-1;i++){
6.             diif=prices[i+1]-prices[i];
7.             if(diif<0) diif=0;
8.             res+=diif;
9.         }
10.         return res;
11.     }
12. };

55跳跃游戏

把可选的（每次可选跳几步）复杂问题转化为覆盖单位问题（能覆盖到哪）。

自己还是写不出覆盖的代码。多学一下；

关键在于 i<=cover; i要在覆盖范围内移动；

取max也是关键

1. class Solution {
2. public:
3.     bool canJump(vector<int>& nums) {
4.         int cover=0;
5.         if(nums.size()==1) return true;
6.         //关键在于 i<=cover; i要在覆盖范围内移动
7.         for(int i=0;i<=cover;i++){
8.             cover=max(nums[i]+i,cover);//也是关键
9.             if(cover>=nums.size()-1) return true;
10.         }
11.         return false;
12.     }
13. };

45跳跃游戏ii

难呀。复杂。

方法一：

用最少的步数，尽可能覆盖最多的范围。

当前覆盖范围用完，但是仍然没有覆盖到终点，就启动下一步覆盖范围(nextcover)

1. class Solution {
2. public:
3.     int jump(vector<int>& nums) {
4.         int cur=0,next=0,res=0;
5.         if(nums.size()==1) return 0;
6.         for(int i=0;i<nums.size();i++){
7.             next=max(next,i+nums[i]);
8.             if(i==cur){
9.                 res++;
10.                 cur=next;
11.                 if(cur>=nums.size()-1) break;
12.             }
13.         }
14.         return res;
15.     }
16. };

442数组中重复的数据，中等

学习参考：b站up主，老汤讲底层基础。

(高频算法面试题：找出数组中的重复元素)

[https://www.bilibili.com/video/BV1hG411q7q6/?spm_id_from=333.788&vd_source=baa5f3043be10f96febc0c68c5983df5]

注意要找到所有出现两次的整数，这样的整数可能不只有一个。        

1. 暴力线性查找

1. vector<int> res;
2. for(int i=0;i<nums.size();i++){
3.    for(int j=i+1;j<nums.size();j++){
4.        if(nums[i]==nums[j]) res.push_back(nums[i]);
5.     }
6. }

1. 排序+二分查找

二分怎么用？学一学：

首先对数组排序，然后使用二分查找来查找后面的元素中是否有和当前元素相同的元素，如果找到，就添加到结果中。

1. class Solution {
2. public:
3.     int EFfind(int l,int r,vector<int>&nums,int target){
4.         while(l<r){
5.             int mid=(l+r+1)/2;
6.             if(nums[mid]<=target) l=mid;
7.             else r=mid-1;
8.         }
9.         if(nums[l]!=target) return -1;
10.         return l;
11.     }
12.     vector<int> findDuplicates(vector<int>& nums) {
13.         sort(nums.begin(),nums.end());
14.         vector<int> res;
15.         for(int i=0;i<nums.size()-1;i++){
16.             if(EFfind(i+1,nums.size()-1,nums,nums[i])!=-1) res.push_back(nums[i]);
17.         }
18.         return res;
19.     }
20. };

1. 排序+双指针

法2没有用到相邻这一特性，这里用到了：

1. class Solution {
2. public:
3.     vector<int> findDuplicates(vector<int>& nums) {
4.         sort(nums.begin(),nums.end());
5.         vector<int>res;
6.         for(int i=0;i<nums.size();i++){
7.             int j=i+1;
8.             if(j<nums.size()&&nums[i]==nums[j]) res.push_back(nums[i]);
9.         }
10.         return res;
11.     }
12. };

1. 哈希查找

1. unordered_set<int> set;
2. vector<int>res;
3. for(int i=0;i<nums.size();i++){
4.     if(set.count(nums[i])) res.push_back(nums[i]);
5.     set.insert(nums[i]);
6. }

1. 数组代替哈希表

1. class Solution {
2. public:
3.     vector<int> findDuplicates(vector<int>& nums) {
4.         vector<int>res;
5.         int cnt[100010]={0};
6.         for(int i=0;i<nums.size();i++){
7.             if(cnt[nums[i]]) res.push_back(nums[i]);
8.             cnt[nums[i]]++;
9.         }
10.         return res;
11.     }
12. };

1. 最佳解决方案，符合题目要求：时间复杂度O(n),常量级的空间复杂度。

没必要了。。

复习一下树的对称的判断

101对称二叉树

还是不会呀，每天抽时间来复习做过的题吧。

这个题还是有很多细节，比如：什么时候才能继续往下递归；虽然是遍历树，但是仍然要接住他。

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.     bool isres(TreeNode* left,TreeNode* right){
15.         //排除空节点，避免空指针报错。且只有值相等时，才能往下递归
16.         if(left==nullptr&&right==nullptr) return true;
17.         else if(left==nullptr&&right!=nullptr) return false;
18.         else if(left!=nullptr&&right==nullptr) return false;
19.         else if(left->val!=right->val) return false;
20.         bool inside=isres(left->right,right->left);
21.         bool outside=isres(left->left,right->right);
22.         return inside&&outside;
23.     }
24.     bool isSymmetric(TreeNode* root) {
25.         if(root==nullptr) return true;
26.         return isres(root->left,root->right);
27.     }
28. };

100相同的树

注意方向就好。

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. private:
14.     bool findres(TreeNode*p,TreeNode*q){
15.         if(p==nullptr&&q==nullptr) return true;
16.         else if(p!=nullptr&&q==nullptr) return false;
17.         else if(p==nullptr&&q!=nullptr) return false;
18.         else if(p->val!=q->val) return false;
19.         bool in=findres(p->left,q->left);
20.         bool out=findres(p->right,q->right);
21.         return in&&out;
22.     }
23. public:
24.     bool isSameTree(TreeNode* p, TreeNode* q) {
25.     return findres(p,q);
26.     }
27. };