2021_01_21 LeetCode刷题

661. 图片平滑器

简单模拟题。四周方向的取值使用数组存放，在取值的时候需要判定该位置是否合理，如果合理，将数值进行相加同时记录数值的个数，最终的结果直接相除即可。

class Solution {
public:
    vector<vector<int>> imageSmoother(vector<vector<int>>& M) {
        int hang1 = M.size(), lie1 = M[0].size();
        vector<vector<int>> ans;
        int next1[8][2] = {{0,1},{0,-1},{1,0},{-1,0},{-1,1},{1,1},{-1,-1},{1,-1}};
        for(int i = 0; i < hang1; i++) {
            vector<int> temp;
            for(int j = 0;j < lie1; j++) {
                int sum = M[i][j], num1 = 1;
                for(int k = 0; k < 8; k++) {
                    int x1 = i + next1[k][0];
                    int y1 = j + next1[k][1];
                    if(x1 >= 0 && x1 < hang1 && y1 >= 0 && y1 < lie1)
                        sum += M[x1][y1],num1 += 1;
                }
                temp.push_back(sum / num1);
            }
            ans.push_back(temp);
        }
        return ans;
    }
};

671. 二叉树中第二小的节点

递归简单模拟题。通过观察这棵树的性质，可以知道其实需要查找所有的叶子节点中第二小的，那么只需要遍历一遍树中的所有节点，存储其中的叶子节点的值，找出第二小的数值即可。对于存储的数值需要经过去重处理，可以使用集合set。

/**
 * 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 ans = -1;
    int findSecondMinimumValue(TreeNode* root) {
        if(root == nullptr)
            return -1;
        ans = -1;
        set<int> p;
        dfs(root,p);
        if(p.size() >= 2) {
            int num1 = 1;
            for(set<int>::iterator it1 = p.begin(); it1 != p.end(); it1++) {
                if(num1 == 2) {
                    ans = *it1;
                    break;
                } else
                    num1 += 1;
            }
        }
        return ans;
    }
    void dfs(TreeNode* root,set<int>& p) {
        if(root == nullptr)
            return;
        if(root->left == nullptr && root->right == nullptr)
            p.insert(root->val);
        dfs(root->left, p);
        dfs(root->right, p);
    }
};

697. 数组的度

简单模拟题。首先需要理解数组的度的定义，理解了之后会发现其实就是寻找一个子数组，在其中包含某一个出现次数最多的数，某一个出现次数最多的数的所有的存在于数组的位置都包含在其中。首先使用map映射存储每个数组元素出现的次数，之后遍历统计出出现最多次数的元素，之后遍历原数组，找到出现最多次数元素的第一个出现的位置和最后一个出现的位置。两个位置相减加一就是其中之一的答案，在这些答案中取出最小值即为最终的结果。

class Solution {
public:
    int findShortestSubArray(vector<int>& nums) {
        int length1 = nums.size();
        int ans = length1, max1 = 0, num1 = 0;
        map<int,int> p;
        for(int i = 0;i < length1; i++) {
            p[nums[i]] += 1;
            if(p[nums[i]] > max1) 
                max1 = p[nums[i]], num1 = nums[i];
        }
        vector<int> sum;
        for(map<int,int>::iterator it1 = p.begin(); it1 != p.end(); it1++) {
            if(it1->second == max1)
                sum.push_back(it1->first);
        }
        int length2 = sum.size();
        for(int i = 0; i < length2; i++) {
            int temp1 = sum[i],begin1 = 0,end1 = 0;
            for(int j = 0; j < length1; j++) {
                if(nums[j] == temp1) {
                    begin1 = j;
                    break;
                }
            }
            for(int j = length1 - 1; j >= 0; j--) {
                if(nums[j] == temp1) {
                    end1 = j;
                    break;
                }
            }
            ans = min(ans,end1 - begin1 + 1);
        }
        return ans;
    }
};

669. 修剪二叉搜索树

递归题。不会，实打实的不会，看了题解写完的，感觉有所收获，想明白了递归是根据每一棵树进行修改递归，敲了一遍，明天继续复习这道题目。

/**
 * 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:
    TreeNode* trimBST(TreeNode* root, int low, int high) {
        if(root == nullptr)
            return root;
        if(root->val > high) 
            return trimBST(root->left,low,high);
        if(root->val < low)
            return trimBST(root->right,low,high);
        root->left = trimBST(root->left,low,high);
        root->right = trimBST(root->right,low,high);
        return root;   
    }
};