class Solution {
public:
static bool cmp(vector<int>&a, vector<int>&b){
return a[0]<b[0];
}
vector<vector<int>> merge(vector<vector<int>>& intervals) {
sort(intervals.begin(), intervals.end(), cmp);
vector<vector<int>>result;
int l=intervals[0][0], r=intervals[0][1];
for(int i=1;i<intervals.size();i++){
if(r>=intervals[i][0]){
r=max(r,intervals[i][1]);
}else{
result.push_back({l,r});
l=intervals[i][0];
r=intervals[i][1];
}
}
result.push_back({l,r});
return result;
}
};
这题与之前的射气球等类似,对左边界进行排序后对是否重叠进行判断,对重叠的元素进行合并即可。
class Solution {
public:
int monotoneIncreasingDigits(int n) {
string s=to_string(n);
if(s.size()>1){
for(int i=s.size()-1;i>0;i--){
if(s[i]<s[i-1]){
for(int j=i;j<s.size();j++){
if(s[j]!='9') s[j]='9';
else break;
}
s[i-1]-=1;
}
}
}
return stoi(s);
}
};
对这题稍加观察就会发现,如果所给的数字不满足单调递增,则答案的数字尾必然是一串9,因为一串9是最大的,所以对数字从后往前判断是否满足单调递增,不满足的地方将前一位-1,保证后面全为9时也小于原数字,即可得到答案。
/**
* 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 result=0;
int minCameraCover(TreeNode* root) {
rd(root);
if(root->val==0){
root->val=2;
result++;
}
return result;
}
void rd(TreeNode* root){
if(root==NULL) return;
rd(root->left);
rd(root->right);
if(root->left==NULL&&root->right==NULL) return;
if(root->left!=NULL){
if(root->left->val==0){
root->val=2;
root->left->val=1;
result++;
return;
}
if(root->left->val==2){
root->val=1;
}
}
if(root->right!=NULL){
if(root->right->val==0){
root->val=2;
root->right->val=1;
result++;
return;
}
if(root->right->val==2){
root->val=1;
}
}
}
};
这题随想录给的思路是使用3个数字标记节点的三种状态,采用后序遍历,先从叶子节点开始判断是否加监控,只需要理清一个节点在子节点具有什么状态时需要加监控即可。