简单模拟题。四周方向的取值使用数组存放,在取值的时候需要判定该位置是否合理,如果合理,将数值进行相加同时记录数值的个数,最终的结果直接相除即可。
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;
}
};
递归简单模拟题。通过观察这棵树的性质,可以知道其实需要查找所有的叶子节点中第二小的,那么只需要遍历一遍树中的所有节点,存储其中的叶子节点的值,找出第二小的数值即可。对于存储的数值需要经过去重处理,可以使用集合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);
}
};
简单模拟题。首先需要理解数组的度的定义,理解了之后会发现其实就是寻找一个子数组,在其中包含某一个出现次数最多的数,某一个出现次数最多的数的所有的存在于数组的位置都包含在其中。首先使用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;
}
};
递归题。不会,实打实的不会,看了题解写完的,感觉有所收获,想明白了递归是根据每一棵树进行修改递归,敲了一遍,明天继续复习这道题目。
/**
* 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;
}
};