贪心算法
-
按照区间的左界对区间进行升序排序（如遇到相同的值，则按照第二个值小的在前）
如果当前区间的左界大于等于已处理过的区间右界（right_index变量存储这个值），则对right_index值进行更新
否则：需要移除一个区间，保留区间右界小的那个（以尽可能少的移除区间）
-
968. 监控二叉树 没写出来 重点复习
二叉树+贪心，主要还是分析好遍历二叉树的过程中的 对节点的处理逻辑，详细过程在下面。
cpp
class Solution {
public:
bool lemonadeChange(vector<int>& bills) {
int num5 = 0, num10 = 0,num20 = 0;
for(int i=0;i<bills.size();i++) {
if(bills[i]==5) {
num5++;
}
else if(bills[i]==10) {
num10++;
num5--;
}
else if(bills[i]==20) {
num20++;
if(num10>0) {
num10--;
num5--;
}else {
num5-=3;
}
}
if(num10<0 || num20<0 || num5<0)
return false;
}
return true;
}
};
cpp
class Solution {
public:
//按照身高排序------二维数组的排序问题
static bool cmp(vector<int>& a,vector<int>& b) {
if(a[0]==b[0]) return a[1]<b[1];
return a[0]>b[0];
}
vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
sort(people.begin(),people.end(),cmp);
//排好序后，按照第二列的位置信息在对应位置插入
vector<vector<int>> que;
for(int i=0;i<people.size();i++) {
int position = people[i][1];
que.insert(que.begin()+position, people[i]);
}
return que;
}
};
cpp
class Solution {
public:
//所有区间按照第一个值的大小 进行升序排序
static bool cmp(vector<int>& a,vector<int>& b) {
return a[0]<b[0];
}
int findMinArrowShots(vector<vector<int>>& points) {
if(points.size()==0)
return 0;
sort(points.begin(),points.end(),cmp);
int res = 1;
for(int i=1;i<points.size();i++) {
//如果当前区间的左界大于上一个区间的右界，说明无法合并在一起，需要重新使用一只箭
if(points[i][0] > points[i-1][1]) {
res++;
}
//否则，更新当前区间的右界（缩小范围，以两个区间的最小值右界为准，方便下一步操作）
else {
points[i][1] = min(points[i-1][1], points[i][1]);
}
}
return res;
}
};按照区间的左界对区间进行升序排序（如遇到相同的值，则按照第二个值小的在前）
如果当前区间的左界大于等于已处理过的区间右界（right_index变量存储这个值），则对right_index值进行更新
否则：需要移除一个区间，保留区间右界小的那个（以尽可能少的移除区间）
cpp
class Solution {
public:
static bool cmp(vector<int>& a, vector<int>& b) {
if(a[0]==b[0])
return a[1]<b[1];
return a[0] < b[0];
}
int eraseOverlapIntervals(vector<vector<int>>& intervals) {
if(intervals.size()<=0)
return 0;
sort(intervals.begin(),intervals.end(), cmp);
int res = 0;
int right_index = intervals[0][1];
for(int i=1;i<intervals.size();i++) {
if(intervals[i][0] >= right_index) {
right_index = intervals[i][1];
} else {
res++;
right_index = min(right_index, intervals[i][1]);
continue;
}
}
return res;
}
};
cpp
class Solution {
public:
vector<int> partitionLabels(string s) {
vector<int> hash(27);
vector<int> res;
for(int i=0;i<s.size();i++) {
hash[s[i]-'a']=i;
}
int left = 0;
int right = 0;
for(int i=0;i<s.size();i++) {
right = max(right,hash[s[i]-'a']);
if(i==right) {
res.push_back(right-left+1);
left=i+1;
}
}
return res;
}
};
cpp
class Solution {
public:
static bool cmp(vector<int>&a, vector<int>& b) {
if(a[0]==b[0]) {
return a[1]<b[1];
}
return a[0]<b[0];
}
vector<vector<int>> merge(vector<vector<int>>& intervals) {
if(intervals.size()<=1)
return intervals;
vector<vector<int>> res;
sort(intervals.begin(),intervals.end(),cmp);
res.push_back(intervals[0]);//二维数组 一次性赋值a[0] = {a[0][0],a[0][1]}
for(int i=0;i<intervals.size();i++) {
if(intervals[i][0] <= res.back()[1]) {
//这里对区间右界的修改！！！！ 还是没记住怎么写
res.back()[1] = max(intervals[i][1],res.back()[1]);
}
else {
res.push_back(intervals[i]);
}
}
return res;
}
};
cpp
class Solution {
public:
int monotoneIncreasingDigits(int n) {
//①数字转字符串
string strNum = to_string(n);
//标记开始写9的位置下标
int flag = strNum.size();
//逆序处理
for(int i=strNum.size()-1;i>0;i--) {
//如果前一个值比当前值大的话，不满足递增，前一值--，当前值记录下来需要改为9
if(strNum[i-1] > strNum[i]) {
flag = i;
strNum[i-1]--;
}
}
for(int i=flag;i<strNum.size();i++) {
strNum[i]='9';
}
//字符串转整型stoi
return stoi(strNum);
}
};判断逻辑：
1.二叉树的遍历------递归后序遍历
2.叶子节点不做处理，从叶子节点的父节点处放置摄像头
3.遍历函数traversal的目的是返回节点的状态：
判断逻辑：0状态表示未做处理；1表示当前节点放摄像头；2表示当前节点在摄像头覆盖范围内
当前节点cur ，通过判断左右孩的状态来决定是否放摄像头：
左、右孩 至少有一个为0------>当前放置摄像头 标记为1；
左右孩都为2 ------> 当前节点标记为 0 ；
其他------>当前节点标记为2；在摄像头覆盖范围内；
4.需要额外的变量result来存储结果，在设置为1的时候result++;'
在minCameraCover函数中，调用函数返回头结点的状态，需多加一步判断是否对头结点放置摄像头。
cpp
/**
* 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 {
private:
int result;
int traversal(TreeNode* cur) {
//0表示未作处理；1表示当前节点为摄像头； 2表示当前节点在摄像头覆盖范围
//从叶子节点开始处理，摄像头不能放在叶子节点层，放在叶子结点的父节点才能最有效利用
//如果当前节点为空，标记为2
if(cur==NULL) {
return 2;
}
//递归处理左右节点
int left = traversal(cur->left);
int right = traversal(cur->right);
//这里可以看作，若左右都为2 即左右都为空，当前节点标记为0
if(left==2 && right==2) {
return 0;
}
//若左右孩子节点都是0，说明找到孩子节点的父节点，标记为一个摄像头，并返回1
if(left==0 || right==0) {
result++;
return 1;
}
if(left==1 || right==1){
return 2;
}
return -1;
}
public:
int minCameraCover(TreeNode* root) {
result=0;
//判断头结点的状态
if(traversal(root)==0)
result++;
return result;
}
};