道心破碎的一天，继续加油吧，坚持努力。

DAY39

738单调递增的数字

1. 暴力法：

没有想到用int i=n;i>0;i--来遍历。

1. class Solution {
2. private:
3.     bool checknum(int num){
4.         if(num<10) return true;
5.         while(num/10!=0){
6.             int low=num%10;
7.             num/=10;
8.             if(num%10>low) return false;
9.         }
10.         return true;
11.     }
12. public:
13.     //先试试暴力法。
14.     int monotoneIncreasingDigits(int n) {
15.         for(int i=n;i>0;i--){
16.             if(checknum(i)) return i;
17.         }
18.         return 0;
19.     }
20. };

1. 力扣优质题解--Sweetiee

自己写了一遍，写不出来。。。

整理一下题解的思路：

既然要尽可能的大，那么这个数从高位开始要尽可能地保持不变。我们要找到从高到低第一个满足str[i]>str[i+1]的位置，然后把str[i]-1,再把后面的位置都变成9即可。

但是由于减小了str[i]之后，可能不满足str[i-1]<=str[i]了，若发生了这种情况，一定是str[i-1]==str[i]，此时就需要再str[i-1]-1,递归地会处理到某个位置idx，我们发现：str[idx]==str[idx+1]==...==str[i]。然后只要str[idx]-1，然后后面都补上9即可。

所以：遍历时候，求当前最大数字max，只在max<arr[i]的时候才更新max对应的idx（类似于：查找数组中最大的元素，返回最小的下标）。**接着判断是否有arr[i]>arr[i+1]**，如果是，那么idx位置数字减1，后面位置全部为9即可。

很多细节。也算是锻炼到了。加油。

1. class Solution {
2. public:
3.     int monotoneIncreasingDigits(int n) {
4.         int max=-1,idx=-1;
5.         auto s=to_string(n);
6.         //注意不要越界
7.         for(int i=0;i<s.size()-1;i++){
8.             if(max<s[i]){
9.                 max=s[i];
10.                 idx=i;
11.             }
12.             if(s[i]>s[i+1]){
13.                 s[idx]-=1;
14.                 for(int j=idx+1;j<s.size();j++) s[j]='9';
15.                 break;
16.             }
17.         }
18.         return stoi(s);
19.     }
20. };

1. 代码随想录官方题解

这个贪心就稍微好想到，也容易理解和实现了：

思路：遇到非递增，就让大数减1，声明变量记录需要置为9的位置。为了利用局部信息，需要从后向前遍历。

1. class Solution {
2. public:
3.     int monotoneIncreasingDigits(int n) {
4.         auto s=to_string(n);
5.         int flag=s.size();
6.         for(int i=s.size()-1;i>0;i--){
7.             if(s[i-1]>s[i]){
8.                 flag=i;
9.                 s[i-1]--;
10.             }
11.         }
12.         for(int i=flag;i<s.size();i++){
13.             s[i]='9';
14.         }
15.         return stoi(s);
16.     }
17. };

除此之外，你还需要掌握函数名及手写它们：

1. to_string()

1. std::string my_to_string(int num){
2.     bool isNegative=false;
3.     std::string str;
4.     if(num==0) return "0";
5.     if(num<0){
6.         isNegative=true;
7.         num*=-1;
8.     }
9.     while(num>0){
10.         //不知道+'0'和减'0'有什么区别，还是写+吧。
11.         str+=(num%10)+'0';
12.         num/=10;
13.     }
14.     if(isNegative) str+='-';
15.     reverse(str.begin(),str.end());
16.     return str;
17. }

1. stroi()

1. int my_stoi(std::string str){
2.     int result=0;
3.     bool isNegative=false;
4.     int i=0;
5.     if(str[0]=='-'){
6.         isNegative=true;
7.         i=1;
8.     }
9.     for(;i<str.size();i++){
10.         if(str[i]<'0'||str[i]>'9'){
11.             throw std::invalid_argument("Invalid input string");
12.         }
13.         //记住这句模版
14.         result=result*10+(str[i]-'0');
15.     }
16.     if(isNegative) result*=-1;
17.     return result;
18. }

1. stol

968监控二叉树,困难

看代码随想录题解过的：

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.     int result=0;
15.     int getres(TreeNode* root){
16.         //递归终止逻辑
17.         if(root==nullptr) return 2;
18.         int l=getres(root->left);
19.         int r=getres(root->right);
20.         if(l==2&&r==2) return 0;
21.         if(l==0||r==0){
22.             result++;
23.             return 1;
24.         }
25.         if(l==1||r==1){
26.             return 2;
27.         }
28.         return -1;
29.     }
30.     int minCameraCover(TreeNode* root) {
31.         if(getres(root)==0) result++;
32.         return result;
33.     }
34. };